RTEMS 4.11Annotated Report
Sun Sep 11 19:11:25 2011
ffc0c238 <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 ) {
ffc0c238: 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;
ffc0c23c: 81 23 00 10 lwz r9,16(r3)
switch( node->type ) {
ffc0c240: 81 6b 00 4c lwz r11,76(r11)
)
{
IMFS_jnode_t *node = loc->node_access;
IMFS_fs_info_t *fs_info;
fs_info = loc->mt_entry->fs_info;
ffc0c244: 81 29 00 34 lwz r9,52(r9)
switch( node->type ) {
ffc0c248: 38 0b ff ff addi r0,r11,-1
ffc0c24c: 2b 80 00 06 cmplwi cr7,r0,6
ffc0c250: 41 9d 00 50 bgt- cr7,ffc0c2a0 <IMFS_Set_handlers+0x68> <== NEVER TAKEN
ffc0c254: 3d 60 ff c2 lis r11,-62
ffc0c258: 39 6b d9 20 addi r11,r11,-9952
ffc0c25c: 54 00 10 3a rlwinm r0,r0,2,0,29
ffc0c260: 7c 0b 00 2e lwzx r0,r11,r0
ffc0c264: 7d 60 5a 14 add r11,r0,r11
ffc0c268: 7d 69 03 a6 mtctr r11
ffc0c26c: 4e 80 04 20 bctr
case IMFS_DIRECTORY:
loc->handlers = fs_info->directory_handlers;
ffc0c270: 80 09 00 0c lwz r0,12(r9)
ffc0c274: 48 00 00 28 b ffc0c29c <IMFS_Set_handlers+0x64>
break;
case IMFS_DEVICE:
loc->handlers = &IMFS_device_handlers;
ffc0c278: 3d 20 ff c2 lis r9,-62
ffc0c27c: 38 09 d9 48 addi r0,r9,-9912
ffc0c280: 48 00 00 1c b ffc0c29c <IMFS_Set_handlers+0x64>
break;
case IMFS_SYM_LINK:
case IMFS_HARD_LINK:
loc->handlers = &IMFS_link_handlers;
ffc0c284: 3d 20 ff c2 lis r9,-62
ffc0c288: 38 09 d9 b8 addi r0,r9,-9800
ffc0c28c: 48 00 00 10 b ffc0c29c <IMFS_Set_handlers+0x64>
break;
case IMFS_LINEAR_FILE:
loc->handlers = fs_info->memfile_handlers;
break;
case IMFS_MEMORY_FILE:
loc->handlers = fs_info->memfile_handlers;
ffc0c290: 80 09 00 08 lwz r0,8(r9)
ffc0c294: 48 00 00 08 b ffc0c29c <IMFS_Set_handlers+0x64>
break;
case IMFS_FIFO:
loc->handlers = fs_info->fifo_handlers;
ffc0c298: 80 09 00 10 lwz r0,16(r9)
ffc0c29c: 90 03 00 08 stw r0,8(r3)
break;
}
return 0;
}
ffc0c2a0: 38 60 00 00 li r3,0
ffc0c2a4: 4e 80 00 20 blr
ffc0bf34 <IMFS_chown>:
int IMFS_chown(
rtems_filesystem_location_info_t *pathloc, /* IN */
uid_t owner, /* IN */
gid_t group /* IN */
)
{
ffc0bf34: 94 21 ff d8 stwu r1,-40(r1)
ffc0bf38: 7c 08 02 a6 mflr r0
ffc0bf3c: 90 01 00 2c stw r0,44(r1)
ffc0bf40: bf a1 00 1c stmw r29,28(r1)
ffc0bf44: 7c 9e 23 78 mr r30,r4
ffc0bf48: 7c bd 2b 78 mr r29,r5
IMFS_jnode_t *jnode;
#if defined(RTEMS_POSIX_API)
uid_t st_uid;
#endif
jnode = (IMFS_jnode_t *) pathloc->node_access;
ffc0bf4c: 83 e3 00 00 lwz r31,0(r3)
/*
* Verify I am the owner of the node or the super user.
*/
#if defined(RTEMS_POSIX_API)
st_uid = geteuid();
ffc0bf50: 48 00 11 a1 bl ffc0d0f0 <geteuid>
if ( ( st_uid != jnode->st_uid ) && ( st_uid != 0 ) )
ffc0bf54: a0 1f 00 3c lhz r0,60(r31)
ffc0bf58: 7f 80 18 00 cmpw cr7,r0,r3
ffc0bf5c: 41 9e 00 20 beq- cr7,ffc0bf7c <IMFS_chown+0x48>
ffc0bf60: 2f 83 00 00 cmpwi cr7,r3,0
ffc0bf64: 41 be 00 18 beq+ cr7,ffc0bf7c <IMFS_chown+0x48> <== NEVER TAKEN
rtems_set_errno_and_return_minus_one( EPERM );
ffc0bf68: 48 00 4c 4d bl ffc10bb4 <__errno>
ffc0bf6c: 38 00 00 01 li r0,1
ffc0bf70: 90 03 00 00 stw r0,0(r3)
ffc0bf74: 38 60 ff ff li r3,-1
ffc0bf78: 48 00 00 24 b ffc0bf9c <IMFS_chown+0x68>
#endif
jnode->st_uid = owner;
ffc0bf7c: b3 df 00 3c sth r30,60(r31)
jnode->st_gid = group;
IMFS_update_ctime( jnode );
ffc0bf80: 38 61 00 08 addi r3,r1,8
ffc0bf84: 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;
ffc0bf88: b3 bf 00 3e sth r29,62(r31)
IMFS_update_ctime( jnode );
ffc0bf8c: 4b ff 8a 85 bl ffc04a10 <gettimeofday>
ffc0bf90: 80 01 00 08 lwz r0,8(r1)
return 0;
ffc0bf94: 38 60 00 00 li r3,0
#endif
jnode->st_uid = owner;
jnode->st_gid = group;
IMFS_update_ctime( jnode );
ffc0bf98: 90 1f 00 48 stw r0,72(r31)
return 0;
}
ffc0bf9c: 39 61 00 28 addi r11,r1,40
ffc0bfa0: 4b ff 45 9c b ffc0053c <_restgpr_29_x>
ffc0c02c <IMFS_create_node>:
IMFS_fs_info_t *fs_info;
/*
* MUST have a parent node to call this routine.
*/
if ( parent_loc == NULL )
ffc0c02c: 2c 03 00 00 cmpwi r3,0
IMFS_jnode_types_t type,
const char *name,
mode_t mode,
const IMFS_types_union *info
)
{
ffc0c030: 94 21 ff e0 stwu r1,-32(r1)
ffc0c034: 7c 08 02 a6 mflr r0
ffc0c038: bf 61 00 0c stmw r27,12(r1)
ffc0c03c: 7c 9f 23 78 mr r31,r4
ffc0c040: 7c fe 3b 78 mr r30,r7
ffc0c044: 90 01 00 24 stw r0,36(r1)
/*
* MUST have a parent node to call this routine.
*/
if ( parent_loc == NULL )
return NULL;
ffc0c048: 3b 60 00 00 li r27,0
IMFS_fs_info_t *fs_info;
/*
* MUST have a parent node to call this routine.
*/
if ( parent_loc == NULL )
ffc0c04c: 41 82 01 24 beq- ffc0c170 <IMFS_create_node+0x144> <== NEVER TAKEN
fs_info = parent_loc->mt_entry->fs_info;
/*
* Reject creation of FIFOs if support is disabled.
*/
if ( type == IMFS_FIFO &&
ffc0c050: 2f 84 00 07 cmpwi cr7,r4,7
*/
if ( parent_loc == NULL )
return NULL;
parent = parent_loc->node_access;
fs_info = parent_loc->mt_entry->fs_info;
ffc0c054: 81 23 00 10 lwz r9,16(r3)
* MUST have a parent node to call this routine.
*/
if ( parent_loc == NULL )
return NULL;
parent = parent_loc->node_access;
ffc0c058: 83 83 00 00 lwz r28,0(r3)
fs_info = parent_loc->mt_entry->fs_info;
ffc0c05c: 83 a9 00 34 lwz r29,52(r9)
/*
* Reject creation of FIFOs if support is disabled.
*/
if ( type == IMFS_FIFO &&
ffc0c060: 40 9e 00 18 bne- cr7,ffc0c078 <IMFS_create_node+0x4c>
ffc0c064: 81 3d 00 10 lwz r9,16(r29)
ffc0c068: 3d 60 ff c2 lis r11,-62
ffc0c06c: 38 0b d8 b8 addi r0,r11,-10056
ffc0c070: 7f 89 00 00 cmpw cr7,r9,r0
ffc0c074: 41 9e 00 fc beq- cr7,ffc0c170 <IMFS_create_node+0x144>
return NULL;
/*
* Allocate filesystem node and fill in basic information
*/
node = IMFS_allocate_node( type, name, mode & ~rtems_filesystem_umask );
ffc0c078: 3d 20 00 00 lis r9,0
ffc0c07c: 81 29 27 7c lwz r9,10108(r9)
ffc0c080: 7c a4 2b 78 mr r4,r5
ffc0c084: 7f e3 fb 78 mr r3,r31
ffc0c088: 80 09 00 2c lwz r0,44(r9)
ffc0c08c: 7c c5 00 78 andc r5,r6,r0
ffc0c090: 4b ff ff 15 bl ffc0bfa4 <IMFS_allocate_node>
if ( !node )
ffc0c094: 7c 7b 1b 79 mr. r27,r3
ffc0c098: 41 82 00 d8 beq- ffc0c170 <IMFS_create_node+0x144>
return NULL;
/*
* Set the type specific information
*/
if ( type == IMFS_DIRECTORY ) {
ffc0c09c: 2f 9f 00 01 cmpwi cr7,r31,1
ffc0c0a0: 40 be 00 1c bne+ cr7,ffc0c0bc <IMFS_create_node+0x90>
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 );
ffc0c0a4: 39 3b 00 54 addi r9,r27,84
head->next = tail;
ffc0c0a8: 91 3b 00 50 stw r9,80(r27)
head->previous = NULL;
ffc0c0ac: 39 20 00 00 li r9,0
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 );
ffc0c0b0: 38 1b 00 50 addi r0,r27,80
head->next = tail;
head->previous = NULL;
ffc0c0b4: 91 3b 00 54 stw r9,84(r27)
ffc0c0b8: 48 00 00 54 b ffc0c10c <IMFS_create_node+0xe0>
rtems_chain_initialize_empty(&node->info.directory.Entries);
} else if ( type == IMFS_HARD_LINK ) {
ffc0c0bc: 2f 9f 00 03 cmpwi cr7,r31,3
ffc0c0c0: 41 9e 00 0c beq- cr7,ffc0c0cc <IMFS_create_node+0xa0>
node->info.hard_link.link_node = info->hard_link.link_node;
} else if ( type == IMFS_SYM_LINK ) {
ffc0c0c4: 2f 9f 00 04 cmpwi cr7,r31,4
ffc0c0c8: 40 be 00 0c bne+ cr7,ffc0c0d4 <IMFS_create_node+0xa8>
node->info.sym_link.name = info->sym_link.name;
ffc0c0cc: 80 1e 00 00 lwz r0,0(r30)
ffc0c0d0: 48 00 00 7c b ffc0c14c <IMFS_create_node+0x120>
} else if ( type == IMFS_DEVICE ) {
ffc0c0d4: 2f 9f 00 02 cmpwi cr7,r31,2
ffc0c0d8: 40 be 00 18 bne+ cr7,ffc0c0f0 <IMFS_create_node+0xc4>
node->info.device.major = info->device.major;
ffc0c0dc: 80 1e 00 00 lwz r0,0(r30)
ffc0c0e0: 90 1b 00 50 stw r0,80(r27)
node->info.device.minor = info->device.minor;
ffc0c0e4: 80 1e 00 04 lwz r0,4(r30)
ffc0c0e8: 90 1b 00 54 stw r0,84(r27)
ffc0c0ec: 48 00 00 64 b ffc0c150 <IMFS_create_node+0x124>
} else if ( type == IMFS_LINEAR_FILE ) {
ffc0c0f0: 2f 9f 00 06 cmpwi cr7,r31,6
ffc0c0f4: 40 be 00 20 bne+ cr7,ffc0c114 <IMFS_create_node+0xe8>
node->info.linearfile.size = 0;
ffc0c0f8: 39 40 00 00 li r10,0
ffc0c0fc: 39 60 00 00 li r11,0
ffc0c100: 91 5b 00 50 stw r10,80(r27)
node->info.linearfile.direct = 0;
ffc0c104: 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;
ffc0c108: 91 7b 00 54 stw r11,84(r27)
node->info.linearfile.direct = 0;
ffc0c10c: 90 1b 00 58 stw r0,88(r27)
ffc0c110: 48 00 00 40 b ffc0c150 <IMFS_create_node+0x124>
} else if ( type == IMFS_MEMORY_FILE ) {
ffc0c114: 2f 9f 00 05 cmpwi cr7,r31,5
ffc0c118: 40 be 00 28 bne+ cr7,ffc0c140 <IMFS_create_node+0x114>
node->info.file.size = 0;
node->info.file.indirect = 0;
ffc0c11c: 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;
ffc0c120: 39 40 00 00 li r10,0
node->info.file.indirect = 0;
ffc0c124: 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;
ffc0c128: 39 60 00 00 li r11,0
ffc0c12c: 91 5b 00 50 stw r10,80(r27)
ffc0c130: 91 7b 00 54 stw r11,84(r27)
node->info.file.indirect = 0;
node->info.file.doubly_indirect = 0;
ffc0c134: 90 1b 00 5c stw r0,92(r27)
node->info.file.triply_indirect = 0;
ffc0c138: 90 1b 00 60 stw r0,96(r27)
ffc0c13c: 48 00 00 14 b ffc0c150 <IMFS_create_node+0x124>
} else if ( type == IMFS_FIFO ) {
ffc0c140: 2f 9f 00 07 cmpwi cr7,r31,7
ffc0c144: 40 be 00 0c bne+ cr7,ffc0c150 <IMFS_create_node+0x124> <== NEVER TAKEN
node->info.fifo.pipe = NULL;
ffc0c148: 38 00 00 00 li r0,0
ffc0c14c: 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;
ffc0c150: 81 3d 00 04 lwz r9,4(r29)
ffc0c154: 38 7c 00 50 addi r3,r28,80
}
/*
* This node MUST have a parent, so put it in that directory list.
*/
node->Parent = parent;
ffc0c158: 93 9b 00 08 stw r28,8(r27)
ffc0c15c: 7f 64 db 78 mr r4,r27
node->st_ino = ++fs_info->ino_count;
ffc0c160: 38 09 00 01 addi r0,r9,1
ffc0c164: 90 1d 00 04 stw r0,4(r29)
ffc0c168: 90 1b 00 38 stw r0,56(r27)
ffc0c16c: 4b ff ca dd bl ffc08c48 <_Chain_Append>
rtems_chain_append( &parent->info.directory.Entries, &node->Node );
return node;
}
ffc0c170: 39 61 00 20 addi r11,r1,32
ffc0c174: 7f 63 db 78 mr r3,r27
ffc0c178: 4b ff 43 bc b ffc00534 <_restgpr_27_x>
ffc0c388 <IMFS_eval_path>:
const char *pathname, /* IN */
size_t pathnamelen, /* IN */
int flags, /* IN */
rtems_filesystem_location_info_t *pathloc /* IN/OUT */
)
{
ffc0c388: 94 21 ff a8 stwu r1,-88(r1)
ffc0c38c: 7c 08 02 a6 mflr r0
ffc0c390: 90 01 00 5c stw r0,92(r1)
int i = 0;
ffc0c394: 38 00 00 00 li r0,0
ffc0c398: 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 ) ) {
ffc0c39c: 54 a0 00 39 rlwinm. r0,r5,0,0,28
const char *pathname, /* IN */
size_t pathnamelen, /* IN */
int flags, /* IN */
rtems_filesystem_location_info_t *pathloc /* IN/OUT */
)
{
ffc0c3a0: bf 41 00 40 stmw r26,64(r1)
ffc0c3a4: 7c 7e 1b 78 mr r30,r3
ffc0c3a8: 7c bd 2b 78 mr r29,r5
ffc0c3ac: 90 81 00 38 stw r4,56(r1)
ffc0c3b0: 7c df 33 78 mr r31,r6
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 ) ) {
ffc0c3b4: 41 a2 00 10 beq+ ffc0c3c4 <IMFS_eval_path+0x3c> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( EIO );
ffc0c3b8: 48 00 47 fd bl ffc10bb4 <__errno> <== NOT EXECUTED
ffc0c3bc: 38 00 00 05 li r0,5 <== NOT EXECUTED
ffc0c3c0: 48 00 02 78 b ffc0c638 <IMFS_eval_path+0x2b0> <== NOT EXECUTED
/*
* This was filled in by the caller and is valid in the
* mount table.
*/
node = pathloc->node_access;
ffc0c3c4: 83 86 00 00 lwz r28,0(r6)
case IMFS_UP_DIR:
/*
* Am I at the root of all filesystems? (chroot'ed?)
*/
if ( pathloc->node_access == rtems_filesystem_root.node_access )
ffc0c3c8: 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 );
ffc0c3cc: 80 61 00 0c lwz r3,12(r1)
ffc0c3d0: 38 a1 00 10 addi r5,r1,16
ffc0c3d4: 80 81 00 38 lwz r4,56(r1)
ffc0c3d8: 38 c1 00 08 addi r6,r1,8
ffc0c3dc: 7c 7e 1a 14 add r3,r30,r3
ffc0c3e0: 48 00 07 f1 bl ffc0cbd0 <IMFS_get_token>
pathnamelen -= len;
ffc0c3e4: 80 01 00 08 lwz r0,8(r1)
ffc0c3e8: 81 21 00 38 lwz r9,56(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 );
ffc0c3ec: 7c 7a 1b 78 mr r26,r3
pathnamelen -= len;
ffc0c3f0: 7d 20 48 50 subf r9,r0,r9
ffc0c3f4: 91 21 00 38 stw r9,56(r1)
i += len;
ffc0c3f8: 81 21 00 0c lwz r9,12(r1)
ffc0c3fc: 7c 09 02 14 add r0,r9,r0
ffc0c400: 90 01 00 0c stw r0,12(r1)
if ( !pathloc->node_access )
ffc0c404: 80 1f 00 00 lwz r0,0(r31)
ffc0c408: 2f 80 00 00 cmpwi cr7,r0,0
ffc0c40c: 41 9e 00 f8 beq- cr7,ffc0c504 <IMFS_eval_path+0x17c> <== 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 )
ffc0c410: 2f 83 00 00 cmpwi cr7,r3,0
ffc0c414: 41 9e 00 24 beq- cr7,ffc0c438 <IMFS_eval_path+0xb0>
if ( node->type == IMFS_DIRECTORY )
ffc0c418: 80 1c 00 4c lwz r0,76(r28)
ffc0c41c: 2f 80 00 01 cmpwi cr7,r0,1
ffc0c420: 40 be 00 18 bne+ cr7,ffc0c438 <IMFS_eval_path+0xb0>
if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_SEARCH ) )
ffc0c424: 7f e3 fb 78 mr r3,r31
ffc0c428: 38 80 00 01 li r4,1
ffc0c42c: 4b ff fe 7d bl ffc0c2a8 <IMFS_evaluate_permission>
ffc0c430: 2f 83 00 00 cmpwi cr7,r3,0
ffc0c434: 41 9e 01 fc beq- cr7,ffc0c630 <IMFS_eval_path+0x2a8>
rtems_set_errno_and_return_minus_one( EACCES );
node = pathloc->node_access;
switch( type ) {
ffc0c438: 2f 9a 00 03 cmpwi cr7,r26,3
if ( type != IMFS_NO_MORE_PATH )
if ( node->type == IMFS_DIRECTORY )
if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_SEARCH ) )
rtems_set_errno_and_return_minus_one( EACCES );
node = pathloc->node_access;
ffc0c43c: 83 9f 00 00 lwz r28,0(r31)
switch( type ) {
ffc0c440: 41 9e 00 54 beq- cr7,ffc0c494 <IMFS_eval_path+0x10c>
ffc0c444: 2f 9a 00 04 cmpwi cr7,r26,4
ffc0c448: 41 9e 01 54 beq- cr7,ffc0c59c <IMFS_eval_path+0x214>
ffc0c44c: 2f 1a 00 02 cmpwi cr6,r26,2
ffc0c450: 40 ba 01 58 bne+ cr6,ffc0c5a8 <IMFS_eval_path+0x220>
case IMFS_UP_DIR:
/*
* Am I at the root of all filesystems? (chroot'ed?)
*/
if ( pathloc->node_access == rtems_filesystem_root.node_access )
ffc0c454: 81 3b 27 7c lwz r9,10108(r27)
ffc0c458: 80 09 00 18 lwz r0,24(r9)
ffc0c45c: 7f 9c 00 00 cmpw cr7,r28,r0
ffc0c460: 41 be ff 6c beq- cr7,ffc0c3cc <IMFS_eval_path+0x44>
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;
ffc0c464: 81 7f 00 10 lwz r11,16(r31)
/*
* Am I at the root of this mounted filesystem?
*/
if ( rtems_filesystem_is_root_location( pathloc ) ) {
ffc0c468: 80 0b 00 1c lwz r0,28(r11)
ffc0c46c: 7f 80 e0 00 cmpw cr7,r0,r28
ffc0c470: 40 be 00 0c bne+ cr7,ffc0c47c <IMFS_eval_path+0xf4>
*/
if ( pathloc->node_access == rtems_filesystem_root.node_access ) {
break; /* Throw out the .. in this case */
} else {
*pathloc = pathloc->mt_entry->mt_point_node;
ffc0c474: 39 6b 00 08 addi r11,r11,8
ffc0c478: 48 00 01 58 b ffc0c5d0 <IMFS_eval_path+0x248>
pathnamelen+len,
flags,pathloc);
}
} else {
if ( !node->Parent )
ffc0c47c: 83 9c 00 08 lwz r28,8(r28)
ffc0c480: 2f 9c 00 00 cmpwi cr7,r28,0
ffc0c484: 40 be 01 10 bne+ cr7,ffc0c594 <IMFS_eval_path+0x20c>
rtems_set_errno_and_return_minus_one( ENOENT );
ffc0c488: 48 00 47 2d bl ffc10bb4 <__errno>
ffc0c48c: 93 43 00 00 stw r26,0(r3)
ffc0c490: 48 00 01 ac b ffc0c63c <IMFS_eval_path+0x2b4>
case IMFS_NAME:
/*
* If we are at a link follow it.
*/
if ( node->type == IMFS_HARD_LINK ) {
ffc0c494: 80 1c 00 4c lwz r0,76(r28)
ffc0c498: 2f 80 00 03 cmpwi cr7,r0,3
ffc0c49c: 40 be 00 18 bne+ cr7,ffc0c4b4 <IMFS_eval_path+0x12c>
IMFS_evaluate_hard_link( pathloc, 0 );
ffc0c4a0: 7f e3 fb 78 mr r3,r31
ffc0c4a4: 38 80 00 00 li r4,0
ffc0c4a8: 4b ff fe 81 bl ffc0c328 <IMFS_evaluate_hard_link>
node = pathloc->node_access;
ffc0c4ac: 83 9f 00 00 lwz r28,0(r31)
ffc0c4b0: 48 00 00 28 b ffc0c4d8 <IMFS_eval_path+0x150>
* It would be a design error if we evaluated the link and
* was broken.
*/
IMFS_assert( node );
} else if ( node->type == IMFS_SYM_LINK ) {
ffc0c4b4: 2f 80 00 04 cmpwi cr7,r0,4
ffc0c4b8: 40 be 00 20 bne+ cr7,ffc0c4d8 <IMFS_eval_path+0x150>
result = IMFS_evaluate_sym_link( pathloc, 0 );
ffc0c4bc: 7f e3 fb 78 mr r3,r31
ffc0c4c0: 38 80 00 00 li r4,0
ffc0c4c4: 48 00 01 89 bl ffc0c64c <IMFS_evaluate_sym_link>
/*
* In contrast to a hard link, it is possible to have a broken
* symbolic link.
*/
node = pathloc->node_access;
ffc0c4c8: 83 9f 00 00 lwz r28,0(r31)
if ( result == -1 )
ffc0c4cc: 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 );
ffc0c4d0: 7c 7a 1b 78 mr r26,r3
/*
* In contrast to a hard link, it is possible to have a broken
* symbolic link.
*/
node = pathloc->node_access;
if ( result == -1 )
ffc0c4d4: 41 9e 01 6c beq- cr7,ffc0c640 <IMFS_eval_path+0x2b8> <== NEVER TAKEN
}
/*
* Only a directory can be decended into.
*/
if ( node->type != IMFS_DIRECTORY )
ffc0c4d8: 80 1c 00 4c lwz r0,76(r28)
ffc0c4dc: 2f 80 00 01 cmpwi cr7,r0,1
ffc0c4e0: 41 be 00 10 beq+ cr7,ffc0c4f0 <IMFS_eval_path+0x168>
rtems_set_errno_and_return_minus_one( ENOTDIR );
ffc0c4e4: 48 00 46 d1 bl ffc10bb4 <__errno>
ffc0c4e8: 38 00 00 14 li r0,20
ffc0c4ec: 48 00 01 4c b ffc0c638 <IMFS_eval_path+0x2b0>
/*
* Find the token name in the current node.
*/
node = IMFS_find_match_in_dir( node, token );
ffc0c4f0: 7f 83 e3 78 mr r3,r28
ffc0c4f4: 38 81 00 10 addi r4,r1,16
ffc0c4f8: 48 00 06 45 bl ffc0cb3c <IMFS_find_match_in_dir>
if ( !node )
ffc0c4fc: 7c 7c 1b 79 mr. r28,r3
ffc0c500: 40 a2 00 10 bne+ ffc0c510 <IMFS_eval_path+0x188>
rtems_set_errno_and_return_minus_one( ENOENT );
ffc0c504: 48 00 46 b1 bl ffc10bb4 <__errno>
ffc0c508: 38 00 00 02 li r0,2
ffc0c50c: 48 00 01 2c b ffc0c638 <IMFS_eval_path+0x2b0>
* 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 )) {
ffc0c510: 80 1c 00 4c lwz r0,76(r28)
ffc0c514: 2f 80 00 01 cmpwi cr7,r0,1
ffc0c518: 40 be 00 7c bne+ cr7,ffc0c594 <IMFS_eval_path+0x20c>
ffc0c51c: 80 1c 00 5c lwz r0,92(r28)
ffc0c520: 2f 80 00 00 cmpwi cr7,r0,0
ffc0c524: 41 9e 00 70 beq- cr7,ffc0c594 <IMFS_eval_path+0x20c>
IMFS_skip_separator( pathname, &pathnamelen, &i);
ffc0c528: 7f c3 f3 78 mr r3,r30
ffc0c52c: 38 81 00 38 addi r4,r1,56
ffc0c530: 38 a1 00 0c addi r5,r1,12
ffc0c534: 4b ff fc 99 bl ffc0c1cc <IMFS_skip_separator>
if ((pathname[i] != '.') || (pathname[i + 1] != '.')) {
ffc0c538: 81 21 00 0c lwz r9,12(r1)
ffc0c53c: 7c 1e 48 ae lbzx r0,r30,r9
ffc0c540: 7d 7e 4a 14 add r11,r30,r9
ffc0c544: 2f 80 00 2e cmpwi cr7,r0,46
ffc0c548: 40 9e 00 10 bne- cr7,ffc0c558 <IMFS_eval_path+0x1d0>
ffc0c54c: 88 0b 00 01 lbz r0,1(r11)
ffc0c550: 2f 80 00 2e cmpwi cr7,r0,46
ffc0c554: 41 be 00 28 beq+ cr7,ffc0c57c <IMFS_eval_path+0x1f4>
*pathloc = node->info.directory.mt_fs->mt_fs_root;
ffc0c558: 80 9c 00 5c lwz r4,92(r28)
return (*pathloc->ops->evalpath_h)( &pathname[i],
ffc0c55c: 7d 63 5b 78 mr r3,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;
ffc0c560: 38 84 00 1c addi r4,r4,28
ffc0c564: 7c a4 a4 aa lswi r5,r4,20
ffc0c568: 7c bf a5 aa stswi r5,r31,20
return (*pathloc->ops->evalpath_h)( &pathname[i],
ffc0c56c: 81 3f 00 0c lwz r9,12(r31)
ffc0c570: 80 81 00 38 lwz r4,56(r1)
ffc0c574: 80 09 00 00 lwz r0,0(r9)
ffc0c578: 48 00 00 80 b ffc0c5f8 <IMFS_eval_path+0x270>
pathnamelen,
flags, pathloc );
}
i += 2;
ffc0c57c: 39 29 00 02 addi r9,r9,2
pathnamelen -= 2;
node = node->Parent;
ffc0c580: 83 9c 00 08 lwz r28,8(r28)
*pathloc = node->info.directory.mt_fs->mt_fs_root;
return (*pathloc->ops->evalpath_h)( &pathname[i],
pathnamelen,
flags, pathloc );
}
i += 2;
ffc0c584: 91 21 00 0c stw r9,12(r1)
pathnamelen -= 2;
ffc0c588: 81 21 00 38 lwz r9,56(r1)
ffc0c58c: 38 09 ff fe addi r0,r9,-2
ffc0c590: 90 01 00 38 stw r0,56(r1)
}
/*
* Set the node access to the point we have found.
*/
pathloc->node_access = node;
ffc0c594: 93 9f 00 00 stw r28,0(r31)
break;
ffc0c598: 4b ff fe 34 b ffc0c3cc <IMFS_eval_path+0x44>
case IMFS_NO_MORE_PATH:
case IMFS_CURRENT_DIR:
break;
case IMFS_INVALID_TOKEN:
rtems_set_errno_and_return_minus_one( ENAMETOOLONG );
ffc0c59c: 48 00 46 19 bl ffc10bb4 <__errno>
ffc0c5a0: 38 00 00 5b li r0,91
ffc0c5a4: 48 00 00 94 b ffc0c638 <IMFS_eval_path+0x2b0>
/*
* Evaluate all tokens until we are done or an error occurs.
*/
while( (type != IMFS_NO_MORE_PATH) && (type != IMFS_INVALID_TOKEN) ) {
ffc0c5a8: 2f 1a 00 00 cmpwi cr6,r26,0
ffc0c5ac: 41 9a 00 08 beq- cr6,ffc0c5b4 <IMFS_eval_path+0x22c>
ffc0c5b0: 40 9e fe 1c bne+ cr7,ffc0c3cc <IMFS_eval_path+0x44> <== ALWAYS TAKEN
* 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 ) {
ffc0c5b4: 80 1c 00 4c lwz r0,76(r28)
ffc0c5b8: 2f 80 00 01 cmpwi cr7,r0,1
ffc0c5bc: 40 9e 00 54 bne- cr7,ffc0c610 <IMFS_eval_path+0x288>
if ( node->info.directory.mt_fs != NULL ) {
ffc0c5c0: 81 7c 00 5c lwz r11,92(r28)
ffc0c5c4: 2f 8b 00 00 cmpwi cr7,r11,0
ffc0c5c8: 41 9e 00 48 beq- cr7,ffc0c610 <IMFS_eval_path+0x288> <== ALWAYS TAKEN
*pathloc = node->info.directory.mt_fs->mt_fs_root;
ffc0c5cc: 39 6b 00 1c addi r11,r11,28 <== NOT EXECUTED
ffc0c5d0: 7c ab a4 aa lswi r5,r11,20
ffc0c5d4: 7c bf a5 aa stswi r5,r31,20
return (*pathloc->ops->evalpath_h)( &pathname[i-len],
ffc0c5d8: 80 61 00 0c lwz r3,12(r1)
ffc0c5dc: 81 21 00 08 lwz r9,8(r1)
ffc0c5e0: 81 7f 00 0c lwz r11,12(r31)
ffc0c5e4: 80 81 00 38 lwz r4,56(r1)
ffc0c5e8: 7c 69 18 50 subf r3,r9,r3
ffc0c5ec: 80 0b 00 00 lwz r0,0(r11)
ffc0c5f0: 7c 7e 1a 14 add r3,r30,r3
ffc0c5f4: 7c 89 22 14 add r4,r9,r4
ffc0c5f8: 7f a5 eb 78 mr r5,r29
ffc0c5fc: 7c 09 03 a6 mtctr r0
ffc0c600: 7f e6 fb 78 mr r6,r31
ffc0c604: 4e 80 04 21 bctrl
ffc0c608: 7c 7a 1b 78 mr r26,r3
ffc0c60c: 48 00 00 34 b ffc0c640 <IMFS_eval_path+0x2b8>
flags, pathloc );
} else {
result = IMFS_Set_handlers( pathloc );
}
} else {
result = IMFS_Set_handlers( pathloc );
ffc0c610: 7f e3 fb 78 mr r3,r31
ffc0c614: 4b ff fc 25 bl ffc0c238 <IMFS_Set_handlers>
/*
* Verify we have the correct permissions for this node.
*/
if ( !IMFS_evaluate_permission( pathloc, flags ) )
ffc0c618: 7f a4 eb 78 mr r4,r29
flags, pathloc );
} else {
result = IMFS_Set_handlers( pathloc );
}
} else {
result = IMFS_Set_handlers( pathloc );
ffc0c61c: 7c 7a 1b 78 mr r26,r3
/*
* Verify we have the correct permissions for this node.
*/
if ( !IMFS_evaluate_permission( pathloc, flags ) )
ffc0c620: 7f e3 fb 78 mr r3,r31
ffc0c624: 4b ff fc 85 bl ffc0c2a8 <IMFS_evaluate_permission>
ffc0c628: 2f 83 00 00 cmpwi cr7,r3,0
ffc0c62c: 40 be 00 14 bne+ cr7,ffc0c640 <IMFS_eval_path+0x2b8>
rtems_set_errno_and_return_minus_one( EACCES );
ffc0c630: 48 00 45 85 bl ffc10bb4 <__errno>
ffc0c634: 38 00 00 0d li r0,13
ffc0c638: 90 03 00 00 stw r0,0(r3)
ffc0c63c: 3b 40 ff ff li r26,-1
return result;
}
ffc0c640: 39 61 00 58 addi r11,r1,88
ffc0c644: 7f 43 d3 78 mr r3,r26
ffc0c648: 4b ff 3e e8 b ffc00530 <_restgpr_26_x>
ffc0c7a0 <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 */
)
{
ffc0c7a0: 94 21 ff b0 stwu r1,-80(r1)
ffc0c7a4: 7c 08 02 a6 mflr r0
ffc0c7a8: 90 01 00 54 stw r0,84(r1)
int i = 0;
ffc0c7ac: 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 */
)
{
ffc0c7b0: bf 41 00 38 stmw r26,56(r1)
ffc0c7b4: 7c 7e 1b 78 mr r30,r3
ffc0c7b8: 7c 9f 23 78 mr r31,r4
ffc0c7bc: 7c bd 2b 78 mr r29,r5
int i = 0;
ffc0c7c0: 90 01 00 10 stw r0,16(r1)
case IMFS_UP_DIR:
/*
* Am I at the root of all filesystems? (chroot'ed?)
*/
if ( pathloc->node_access == rtems_filesystem_root.node_access )
ffc0c7c4: 3f 60 00 00 lis r27,0
/*
* This was filled in by the caller and is valid in the
* mount table.
*/
node = pathloc->node_access;
ffc0c7c8: 83 84 00 00 lwz r28,0(r4)
/*
* Get the path length.
*/
pathlen = strlen( path );
ffc0c7cc: 48 00 5d 15 bl ffc124e0 <strlen>
ffc0c7d0: 90 61 00 08 stw r3,8(r1)
* Evaluate all tokens until we are done or an error occurs.
*/
while( !done ) {
type = IMFS_get_token( &path[i], pathlen, token, &len );
ffc0c7d4: 80 61 00 10 lwz r3,16(r1)
ffc0c7d8: 38 a1 00 14 addi r5,r1,20
ffc0c7dc: 80 81 00 08 lwz r4,8(r1)
ffc0c7e0: 38 c1 00 0c addi r6,r1,12
ffc0c7e4: 7c 7e 1a 14 add r3,r30,r3
ffc0c7e8: 48 00 03 e9 bl ffc0cbd0 <IMFS_get_token>
pathlen -= len;
ffc0c7ec: 80 01 00 0c lwz r0,12(r1)
ffc0c7f0: 81 21 00 08 lwz r9,8(r1)
* Evaluate all tokens until we are done or an error occurs.
*/
while( !done ) {
type = IMFS_get_token( &path[i], pathlen, token, &len );
ffc0c7f4: 7c 7a 1b 78 mr r26,r3
pathlen -= len;
ffc0c7f8: 7d 20 48 50 subf r9,r0,r9
ffc0c7fc: 91 21 00 08 stw r9,8(r1)
i += len;
ffc0c800: 81 21 00 10 lwz r9,16(r1)
ffc0c804: 7c 09 02 14 add r0,r9,r0
ffc0c808: 90 01 00 10 stw r0,16(r1)
if ( !pathloc->node_access )
ffc0c80c: 80 1f 00 00 lwz r0,0(r31)
ffc0c810: 2f 80 00 00 cmpwi cr7,r0,0
ffc0c814: 41 9e 01 e8 beq- cr7,ffc0c9fc <IMFS_evaluate_for_make+0x25c><== NEVER TAKEN
/*
* I cannot move out of this directory without execute permission.
*/
if ( type != IMFS_NO_MORE_PATH )
ffc0c818: 2f 83 00 00 cmpwi cr7,r3,0
ffc0c81c: 41 9e 00 24 beq- cr7,ffc0c840 <IMFS_evaluate_for_make+0xa0>
if ( node->type == IMFS_DIRECTORY )
ffc0c820: 80 1c 00 4c lwz r0,76(r28)
ffc0c824: 2f 80 00 01 cmpwi cr7,r0,1
ffc0c828: 40 be 00 18 bne+ cr7,ffc0c840 <IMFS_evaluate_for_make+0xa0>
if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_SEARCH ) )
ffc0c82c: 7f e3 fb 78 mr r3,r31
ffc0c830: 38 80 00 01 li r4,1
ffc0c834: 4b ff fa 75 bl ffc0c2a8 <IMFS_evaluate_permission>
ffc0c838: 2f 83 00 00 cmpwi cr7,r3,0
ffc0c83c: 41 9e 02 24 beq- cr7,ffc0ca60 <IMFS_evaluate_for_make+0x2c0>
rtems_set_errno_and_return_minus_one( EACCES );
node = pathloc->node_access;
switch( type ) {
ffc0c840: 2f 9a 00 02 cmpwi cr7,r26,2
if ( type != IMFS_NO_MORE_PATH )
if ( node->type == IMFS_DIRECTORY )
if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_SEARCH ) )
rtems_set_errno_and_return_minus_one( EACCES );
node = pathloc->node_access;
ffc0c844: 83 9f 00 00 lwz r28,0(r31)
switch( type ) {
ffc0c848: 41 9e 00 2c beq- cr7,ffc0c874 <IMFS_evaluate_for_make+0xd4>
ffc0c84c: 2b 9a 00 02 cmplwi cr7,r26,2
ffc0c850: 41 9d 00 10 bgt- cr7,ffc0c860 <IMFS_evaluate_for_make+0xc0>
ffc0c854: 2f 9a 00 00 cmpwi cr7,r26,0
ffc0c858: 41 9e 01 68 beq- cr7,ffc0c9c0 <IMFS_evaluate_for_make+0x220>
ffc0c85c: 4b ff ff 78 b ffc0c7d4 <IMFS_evaluate_for_make+0x34>
ffc0c860: 2f 9a 00 03 cmpwi cr7,r26,3
ffc0c864: 41 9e 00 70 beq- cr7,ffc0c8d4 <IMFS_evaluate_for_make+0x134>
ffc0c868: 2f 9a 00 04 cmpwi cr7,r26,4
ffc0c86c: 40 9e ff 68 bne+ cr7,ffc0c7d4 <IMFS_evaluate_for_make+0x34><== NEVER TAKEN
ffc0c870: 48 00 01 5c b ffc0c9cc <IMFS_evaluate_for_make+0x22c>
case IMFS_UP_DIR:
/*
* Am I at the root of all filesystems? (chroot'ed?)
*/
if ( pathloc->node_access == rtems_filesystem_root.node_access )
ffc0c874: 81 3b 27 7c lwz r9,10108(r27)
ffc0c878: 80 09 00 18 lwz r0,24(r9)
ffc0c87c: 7f 9c 00 00 cmpw cr7,r28,r0
ffc0c880: 41 be ff 54 beq- cr7,ffc0c7d4 <IMFS_evaluate_for_make+0x34>
ffc0c884: 81 7f 00 10 lwz r11,16(r31)
/*
* Am I at the root of this mounted filesystem?
*/
if ( rtems_filesystem_is_root_location( pathloc ) ) {
ffc0c888: 80 0b 00 1c lwz r0,28(r11)
ffc0c88c: 7f 80 e0 00 cmpw cr7,r0,r28
ffc0c890: 40 be 00 2c bne+ cr7,ffc0c8bc <IMFS_evaluate_for_make+0x11c>
if ( pathloc->node_access == rtems_filesystem_root.node_access ) {
break;
} else {
*pathloc = pathloc->mt_entry->mt_point_node;
ffc0c894: 39 6b 00 08 addi r11,r11,8
return (*pathloc->ops->evalformake_h)( &path[i-len], pathloc, name );
ffc0c898: 80 01 00 0c lwz r0,12(r1)
if ( pathloc->node_access == rtems_filesystem_root.node_access ) {
break;
} else {
*pathloc = pathloc->mt_entry->mt_point_node;
ffc0c89c: 7c ab a4 aa lswi r5,r11,20
ffc0c8a0: 7c bf a5 aa stswi r5,r31,20
return (*pathloc->ops->evalformake_h)( &path[i-len], pathloc, name );
ffc0c8a4: 80 61 00 10 lwz r3,16(r1)
ffc0c8a8: 81 3f 00 0c lwz r9,12(r31)
ffc0c8ac: 7c 60 18 50 subf r3,r0,r3
ffc0c8b0: 7c 7e 1a 14 add r3,r30,r3
ffc0c8b4: 80 09 00 04 lwz r0,4(r9)
ffc0c8b8: 48 00 00 d0 b ffc0c988 <IMFS_evaluate_for_make+0x1e8>
}
} else {
if ( !node->Parent )
ffc0c8bc: 83 9c 00 08 lwz r28,8(r28)
ffc0c8c0: 2f 9c 00 00 cmpwi cr7,r28,0
ffc0c8c4: 40 be 00 f4 bne+ cr7,ffc0c9b8 <IMFS_evaluate_for_make+0x218>
rtems_set_errno_and_return_minus_one( ENOENT );
ffc0c8c8: 48 00 42 ed bl ffc10bb4 <__errno>
ffc0c8cc: 93 43 00 00 stw r26,0(r3)
ffc0c8d0: 48 00 01 9c b ffc0ca6c <IMFS_evaluate_for_make+0x2cc>
pathloc->node_access = node;
break;
case IMFS_NAME:
if ( node->type == IMFS_HARD_LINK ) {
ffc0c8d4: 80 1c 00 4c lwz r0,76(r28)
ffc0c8d8: 2f 80 00 03 cmpwi cr7,r0,3
ffc0c8dc: 41 9e 00 0c beq- cr7,ffc0c8e8 <IMFS_evaluate_for_make+0x148>
result = IMFS_evaluate_link( pathloc, 0 );
if ( result == -1 )
return -1;
} else if ( node->type == IMFS_SYM_LINK ) {
ffc0c8e0: 2f 80 00 04 cmpwi cr7,r0,4
ffc0c8e4: 40 be 00 1c bne+ cr7,ffc0c900 <IMFS_evaluate_for_make+0x160>
result = IMFS_evaluate_link( pathloc, 0 );
ffc0c8e8: 7f e3 fb 78 mr r3,r31
ffc0c8ec: 38 80 00 00 li r4,0
ffc0c8f0: 4b ff fd f5 bl ffc0c6e4 <IMFS_evaluate_link>
if ( result == -1 )
ffc0c8f4: 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 );
ffc0c8f8: 7c 7c 1b 78 mr r28,r3
if ( result == -1 )
ffc0c8fc: 41 9e 01 74 beq- cr7,ffc0ca70 <IMFS_evaluate_for_make+0x2d0><== NEVER TAKEN
return -1;
}
node = pathloc->node_access;
ffc0c900: 80 7f 00 00 lwz r3,0(r31)
if ( !node )
ffc0c904: 2f 83 00 00 cmpwi cr7,r3,0
ffc0c908: 41 9e 01 38 beq- cr7,ffc0ca40 <IMFS_evaluate_for_make+0x2a0><== NEVER TAKEN
/*
* Only a directory can be decended into.
*/
if ( node->type != IMFS_DIRECTORY )
ffc0c90c: 80 03 00 4c lwz r0,76(r3)
ffc0c910: 2f 80 00 01 cmpwi cr7,r0,1
ffc0c914: 40 9e 01 2c bne- cr7,ffc0ca40 <IMFS_evaluate_for_make+0x2a0>
/*
* Find the token name in the present location.
*/
node = IMFS_find_match_in_dir( node, token );
ffc0c918: 38 81 00 14 addi r4,r1,20
ffc0c91c: 48 00 02 21 bl ffc0cb3c <IMFS_find_match_in_dir>
/*
* If there is no node we have found the name of the node we
* wish to create.
*/
if ( ! node )
ffc0c920: 7c 7c 1b 79 mr. r28,r3
ffc0c924: 41 82 00 b4 beq- ffc0c9d8 <IMFS_evaluate_for_make+0x238>
done = true;
else {
if (( node->type == IMFS_DIRECTORY ) && ( node->info.directory.mt_fs != NULL )) {
ffc0c928: 80 1c 00 4c lwz r0,76(r28)
ffc0c92c: 2f 80 00 01 cmpwi cr7,r0,1
ffc0c930: 40 be 00 88 bne+ cr7,ffc0c9b8 <IMFS_evaluate_for_make+0x218>
ffc0c934: 80 1c 00 5c lwz r0,92(r28)
ffc0c938: 2f 80 00 00 cmpwi cr7,r0,0
ffc0c93c: 41 9e 00 7c beq- cr7,ffc0c9b8 <IMFS_evaluate_for_make+0x218>
IMFS_skip_separator( path, &pathlen, &i);
ffc0c940: 7f c3 f3 78 mr r3,r30
ffc0c944: 38 81 00 08 addi r4,r1,8
ffc0c948: 38 a1 00 10 addi r5,r1,16
ffc0c94c: 4b ff f8 81 bl ffc0c1cc <IMFS_skip_separator>
if ((path[i] != '.') || (path[i + 1] != '.')) {
ffc0c950: 81 21 00 10 lwz r9,16(r1)
ffc0c954: 7c 1e 48 ae lbzx r0,r30,r9
ffc0c958: 7c 7e 4a 14 add r3,r30,r9
ffc0c95c: 2f 80 00 2e cmpwi cr7,r0,46
ffc0c960: 40 9e 00 10 bne- cr7,ffc0c970 <IMFS_evaluate_for_make+0x1d0>
ffc0c964: 88 03 00 01 lbz r0,1(r3)
ffc0c968: 2f 80 00 2e cmpwi cr7,r0,46
ffc0c96c: 41 be 00 34 beq+ cr7,ffc0c9a0 <IMFS_evaluate_for_make+0x200><== ALWAYS TAKEN
*pathloc = node->info.directory.mt_fs->mt_fs_root;
ffc0c970: 81 7c 00 5c lwz r11,92(r28)
ffc0c974: 39 6b 00 1c addi r11,r11,28
ffc0c978: 7c ab a4 aa lswi r5,r11,20
ffc0c97c: 7c bf a5 aa stswi r5,r31,20
return (*pathloc->ops->evalformake_h)( &path[i],
ffc0c980: 81 3f 00 0c lwz r9,12(r31)
ffc0c984: 80 09 00 04 lwz r0,4(r9)
ffc0c988: 7f e4 fb 78 mr r4,r31
ffc0c98c: 7c 09 03 a6 mtctr r0
ffc0c990: 7f a5 eb 78 mr r5,r29
ffc0c994: 4e 80 04 21 bctrl
ffc0c998: 7c 7c 1b 78 mr r28,r3
ffc0c99c: 48 00 00 d4 b ffc0ca70 <IMFS_evaluate_for_make+0x2d0>
pathloc,
name );
}
i += 2;
ffc0c9a0: 39 29 00 02 addi r9,r9,2
pathlen -= 2;
node = node->Parent;
ffc0c9a4: 83 9c 00 08 lwz r28,8(r28)
*pathloc = node->info.directory.mt_fs->mt_fs_root;
return (*pathloc->ops->evalformake_h)( &path[i],
pathloc,
name );
}
i += 2;
ffc0c9a8: 91 21 00 10 stw r9,16(r1)
pathlen -= 2;
ffc0c9ac: 81 21 00 08 lwz r9,8(r1)
ffc0c9b0: 38 09 ff fe addi r0,r9,-2
ffc0c9b4: 90 01 00 08 stw r0,8(r1)
node = node->Parent;
}
pathloc->node_access = node;
ffc0c9b8: 93 9f 00 00 stw r28,0(r31)
ffc0c9bc: 4b ff fe 18 b ffc0c7d4 <IMFS_evaluate_for_make+0x34>
}
break;
case IMFS_NO_MORE_PATH:
rtems_set_errno_and_return_minus_one( EEXIST );
ffc0c9c0: 48 00 41 f5 bl ffc10bb4 <__errno>
ffc0c9c4: 38 00 00 11 li r0,17
ffc0c9c8: 48 00 00 a0 b ffc0ca68 <IMFS_evaluate_for_make+0x2c8>
break;
case IMFS_INVALID_TOKEN:
rtems_set_errno_and_return_minus_one( ENAMETOOLONG );
ffc0c9cc: 48 00 41 e9 bl ffc10bb4 <__errno>
ffc0c9d0: 38 00 00 5b li r0,91
ffc0c9d4: 48 00 00 94 b ffc0ca68 <IMFS_evaluate_for_make+0x2c8>
case IMFS_CURRENT_DIR:
break;
}
}
*name = &path[ i - len ];
ffc0c9d8: 80 01 00 0c lwz r0,12(r1)
ffc0c9dc: 81 21 00 10 lwz r9,16(r1)
ffc0c9e0: 7c 00 48 50 subf r0,r0,r9
ffc0c9e4: 7c 1e 02 14 add r0,r30,r0
ffc0c9e8: 90 1d 00 00 stw r0,0(r29)
/*
* 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++) {
ffc0c9ec: 48 00 00 28 b ffc0ca14 <IMFS_evaluate_for_make+0x274>
if ( !IMFS_is_separator( path[ i ] ) )
ffc0c9f0: 4b ff 8f 85 bl ffc05974 <rtems_filesystem_is_separator>
ffc0c9f4: 2f 83 00 00 cmpwi cr7,r3,0
ffc0c9f8: 40 be 00 10 bne+ cr7,ffc0ca08 <IMFS_evaluate_for_make+0x268>
rtems_set_errno_and_return_minus_one( ENOENT );
ffc0c9fc: 48 00 41 b9 bl ffc10bb4 <__errno>
ffc0ca00: 38 00 00 02 li r0,2
ffc0ca04: 48 00 00 64 b ffc0ca68 <IMFS_evaluate_for_make+0x2c8>
/*
* 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++) {
ffc0ca08: 81 21 00 10 lwz r9,16(r1)
ffc0ca0c: 38 09 00 01 addi r0,r9,1
ffc0ca10: 90 01 00 10 stw r0,16(r1)
ffc0ca14: 80 01 00 10 lwz r0,16(r1)
ffc0ca18: 7c 7e 00 ae lbzx r3,r30,r0
ffc0ca1c: 2f 83 00 00 cmpwi cr7,r3,0
ffc0ca20: 40 9e ff d0 bne+ cr7,ffc0c9f0 <IMFS_evaluate_for_make+0x250>
/*
* Verify we can execute and write to this directory.
*/
result = IMFS_Set_handlers( pathloc );
ffc0ca24: 7f e3 fb 78 mr r3,r31
ffc0ca28: 4b ff f8 11 bl ffc0c238 <IMFS_Set_handlers>
/*
* The returned node must be a directory
*/
node = pathloc->node_access;
if ( node->type != IMFS_DIRECTORY )
ffc0ca2c: 81 3f 00 00 lwz r9,0(r31)
/*
* Verify we can execute and write to this directory.
*/
result = IMFS_Set_handlers( pathloc );
ffc0ca30: 7c 7c 1b 78 mr r28,r3
/*
* The returned node must be a directory
*/
node = pathloc->node_access;
if ( node->type != IMFS_DIRECTORY )
ffc0ca34: 80 09 00 4c lwz r0,76(r9)
ffc0ca38: 2f 80 00 01 cmpwi cr7,r0,1
ffc0ca3c: 41 be 00 10 beq+ cr7,ffc0ca4c <IMFS_evaluate_for_make+0x2ac><== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( ENOTDIR );
ffc0ca40: 48 00 41 75 bl ffc10bb4 <__errno>
ffc0ca44: 38 00 00 14 li r0,20
ffc0ca48: 48 00 00 20 b ffc0ca68 <IMFS_evaluate_for_make+0x2c8>
/*
* We must have Write and execute permission on the returned node.
*/
if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_WX ) )
ffc0ca4c: 7f e3 fb 78 mr r3,r31
ffc0ca50: 38 80 00 03 li r4,3
ffc0ca54: 4b ff f8 55 bl ffc0c2a8 <IMFS_evaluate_permission>
ffc0ca58: 2f 83 00 00 cmpwi cr7,r3,0
ffc0ca5c: 40 be 00 14 bne+ cr7,ffc0ca70 <IMFS_evaluate_for_make+0x2d0>
rtems_set_errno_and_return_minus_one( EACCES );
ffc0ca60: 48 00 41 55 bl ffc10bb4 <__errno>
ffc0ca64: 38 00 00 0d li r0,13
ffc0ca68: 90 03 00 00 stw r0,0(r3)
ffc0ca6c: 3b 80 ff ff li r28,-1
return result;
}
ffc0ca70: 39 61 00 50 addi r11,r1,80
ffc0ca74: 7f 83 e3 78 mr r3,r28
ffc0ca78: 4b ff 3a b8 b ffc00530 <_restgpr_26_x>
ffc0c2a8 <IMFS_evaluate_permission>:
*/
int IMFS_evaluate_permission(
rtems_filesystem_location_info_t *node,
int flags
)
{
ffc0c2a8: 94 21 ff e8 stwu r1,-24(r1)
ffc0c2ac: 7c 08 02 a6 mflr r0
ffc0c2b0: 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 ) )
ffc0c2b4: 54 80 00 39 rlwinm. r0,r4,0,0,28
*/
int IMFS_evaluate_permission(
rtems_filesystem_location_info_t *node,
int flags
)
{
ffc0c2b8: bf a1 00 0c stmw r29,12(r1)
ffc0c2bc: 7c 9e 23 78 mr r30,r4
uid_t st_uid;
gid_t st_gid;
IMFS_jnode_t *jnode;
int flags_to_test;
if ( !rtems_libio_is_valid_perms( flags ) )
ffc0c2c0: 41 a2 00 18 beq+ ffc0c2d8 <IMFS_evaluate_permission+0x30><== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( EPERM );
ffc0c2c4: 48 00 48 f1 bl ffc10bb4 <__errno> <== NOT EXECUTED
ffc0c2c8: 38 00 00 01 li r0,1 <== NOT EXECUTED
ffc0c2cc: 90 03 00 00 stw r0,0(r3) <== NOT EXECUTED
ffc0c2d0: 38 60 ff ff li r3,-1 <== NOT EXECUTED
ffc0c2d4: 48 00 00 4c b ffc0c320 <IMFS_evaluate_permission+0x78><== NOT EXECUTED
jnode = node->node_access;
ffc0c2d8: 83 e3 00 00 lwz r31,0(r3)
#if defined(RTEMS_POSIX_API)
st_uid = geteuid();
ffc0c2dc: 48 00 0e 15 bl ffc0d0f0 <geteuid>
ffc0c2e0: 7c 7d 1b 78 mr r29,r3
st_gid = getegid();
ffc0c2e4: 48 00 0d fd bl ffc0d0e0 <getegid>
* Check if I am owner or a group member or someone else.
*/
flags_to_test = flags;
if ( st_uid == jnode->st_uid )
ffc0c2e8: a0 1f 00 3c lhz r0,60(r31)
ffc0c2ec: 7f 80 e8 00 cmpw cr7,r0,r29
ffc0c2f0: 40 be 00 0c bne+ cr7,ffc0c2fc <IMFS_evaluate_permission+0x54>
flags_to_test <<= 6;
ffc0c2f4: 57 de 30 32 rlwinm r30,r30,6,0,25
ffc0c2f8: 48 00 00 14 b ffc0c30c <IMFS_evaluate_permission+0x64>
else if ( st_gid == jnode->st_gid )
ffc0c2fc: a0 1f 00 3e lhz r0,62(r31)
ffc0c300: 7f 80 18 00 cmpw cr7,r0,r3
ffc0c304: 40 be 00 08 bne+ cr7,ffc0c30c <IMFS_evaluate_permission+0x64>
flags_to_test <<= 3;
ffc0c308: 57 de 18 38 rlwinm r30,r30,3,0,28
/*
* If all of the flags are set we have permission
* to do this.
*/
if ( ( flags_to_test & jnode->st_mode) == flags_to_test )
ffc0c30c: 80 7f 00 30 lwz r3,48(r31)
ffc0c310: 7f c3 18 38 and r3,r30,r3
return 1;
ffc0c314: 7c 63 f2 78 xor r3,r3,r30
ffc0c318: 7c 63 00 34 cntlzw r3,r3
ffc0c31c: 54 63 d9 7e rlwinm r3,r3,27,5,31
return 0;
}
ffc0c320: 39 61 00 18 addi r11,r1,24
ffc0c324: 4b ff 42 18 b ffc0053c <_restgpr_29_x>
ffc1003c <IMFS_fchmod>:
int IMFS_fchmod(
rtems_filesystem_location_info_t *loc,
mode_t mode
)
{
ffc1003c: 94 21 ff e0 stwu r1,-32(r1)
ffc10040: 7c 08 02 a6 mflr r0
ffc10044: 90 01 00 24 stw r0,36(r1)
ffc10048: bf c1 00 18 stmw r30,24(r1)
ffc1004c: 7c 9e 23 78 mr r30,r4
IMFS_jnode_t *jnode;
#if defined(RTEMS_POSIX_API)
uid_t st_uid;
#endif
jnode = loc->node_access;
ffc10050: 83 e3 00 00 lwz r31,0(r3)
/*
* Verify I am the owner of the node or the super user.
*/
#if defined(RTEMS_POSIX_API)
st_uid = geteuid();
ffc10054: 4b ff d0 9d bl ffc0d0f0 <geteuid>
if ( ( st_uid != jnode->st_uid ) && ( st_uid != 0 ) )
ffc10058: a0 1f 00 3c lhz r0,60(r31)
ffc1005c: 7f 80 18 00 cmpw cr7,r0,r3
ffc10060: 41 9e 00 20 beq- cr7,ffc10080 <IMFS_fchmod+0x44>
ffc10064: 2f 83 00 00 cmpwi cr7,r3,0
ffc10068: 41 be 00 18 beq+ cr7,ffc10080 <IMFS_fchmod+0x44> <== NEVER TAKEN
rtems_set_errno_and_return_minus_one( EPERM );
ffc1006c: 48 00 0b 49 bl ffc10bb4 <__errno>
ffc10070: 38 00 00 01 li r0,1
ffc10074: 90 03 00 00 stw r0,0(r3)
ffc10078: 38 60 ff ff li r3,-1
ffc1007c: 48 00 00 30 b ffc100ac <IMFS_fchmod+0x70>
/*
* 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);
ffc10080: 80 1f 00 30 lwz r0,48(r31)
jnode->st_mode |= mode & (S_IRWXU | S_IRWXG | S_IRWXO | S_ISUID | S_ISGID | S_ISVTX);
ffc10084: 57 de 05 3e clrlwi r30,r30,20
IMFS_update_ctime( jnode );
ffc10088: 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);
ffc1008c: 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);
ffc10090: 7f de 03 78 or r30,r30,r0
ffc10094: 93 df 00 30 stw r30,48(r31)
IMFS_update_ctime( jnode );
ffc10098: 38 80 00 00 li r4,0
ffc1009c: 4b ff 49 75 bl ffc04a10 <gettimeofday>
ffc100a0: 80 01 00 08 lwz r0,8(r1)
return 0;
ffc100a4: 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 );
ffc100a8: 90 1f 00 48 stw r0,72(r31)
return 0;
}
ffc100ac: 39 61 00 20 addi r11,r1,32
ffc100b0: 4b ff 04 90 b ffc00540 <_restgpr_30_x>
ffc04f70 <IMFS_fifo_lseek>:
rtems_off64_t IMFS_fifo_lseek(
rtems_libio_t *iop,
rtems_off64_t offset,
int whence
)
{
ffc04f70: 94 21 ff f0 stwu r1,-16(r1)
ffc04f74: 7c 08 02 a6 mflr r0
ffc04f78: 7c 68 1b 78 mr r8,r3
ffc04f7c: 90 01 00 14 stw r0,20(r1)
ffc04f80: bf c1 00 08 stmw r30,8(r1)
off_t err = pipe_lseek(LIBIO2PIPE(iop), offset, whence, iop);
ffc04f84: 81 23 00 1c lwz r9,28(r3)
ffc04f88: 80 69 00 50 lwz r3,80(r9)
ffc04f8c: 48 00 a4 b5 bl ffc0f440 <pipe_lseek>
ffc04f90: 7c 7e fe 70 srawi r30,r3,31
IMFS_FIFO_RETURN(err);
ffc04f94: 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);
ffc04f98: 7c 7f 1b 78 mr r31,r3
IMFS_FIFO_RETURN(err);
ffc04f9c: 40 bc 00 18 bge+ cr7,ffc04fb4 <IMFS_fifo_lseek+0x44> <== NEVER TAKEN
ffc04fa0: 48 00 d9 a1 bl ffc12940 <__errno>
ffc04fa4: 7c 1f 00 d0 neg r0,r31
ffc04fa8: 90 03 00 00 stw r0,0(r3)
ffc04fac: 3b c0 ff ff li r30,-1
ffc04fb0: 3b e0 ff ff li r31,-1
}
ffc04fb4: 39 61 00 10 addi r11,r1,16
ffc04fb8: 7f c3 f3 78 mr r3,r30
ffc04fbc: 7f e4 fb 78 mr r4,r31
ffc04fc0: 48 01 c1 34 b ffc210f4 <_restgpr_30_x>
ffc04fc4 <IMFS_fifo_write>:
ssize_t IMFS_fifo_write(
rtems_libio_t *iop,
const void *buffer,
size_t count
)
{
ffc04fc4: 94 21 ff e0 stwu r1,-32(r1)
ffc04fc8: 7c 08 02 a6 mflr r0
ffc04fcc: 7c 66 1b 78 mr r6,r3
ffc04fd0: 90 01 00 24 stw r0,36(r1)
ffc04fd4: bf c1 00 18 stmw r30,24(r1)
IMFS_jnode_t *jnode = iop->pathinfo.node_access;
ffc04fd8: 83 e3 00 1c lwz r31,28(r3)
int err = pipe_write(JNODE2PIPE(jnode), buffer, count, iop);
ffc04fdc: 80 7f 00 50 lwz r3,80(r31)
ffc04fe0: 48 00 a2 11 bl ffc0f1f0 <pipe_write>
if (err > 0) {
ffc04fe4: 7c 7e 1b 79 mr. r30,r3
ffc04fe8: 40 81 00 20 ble- ffc05008 <IMFS_fifo_write+0x44>
IMFS_mtime_ctime_update(jnode);
ffc04fec: 38 61 00 08 addi r3,r1,8
ffc04ff0: 38 80 00 00 li r4,0
ffc04ff4: 48 00 12 85 bl ffc06278 <gettimeofday>
ffc04ff8: 80 01 00 08 lwz r0,8(r1)
ffc04ffc: 90 1f 00 44 stw r0,68(r31)
ffc05000: 90 1f 00 48 stw r0,72(r31)
ffc05004: 48 00 00 18 b ffc0501c <IMFS_fifo_write+0x58>
}
IMFS_FIFO_RETURN(err);
ffc05008: 41 a2 00 14 beq+ ffc0501c <IMFS_fifo_write+0x58> <== NEVER TAKEN
ffc0500c: 7f de 00 d0 neg r30,r30
ffc05010: 48 00 d9 31 bl ffc12940 <__errno>
ffc05014: 93 c3 00 00 stw r30,0(r3)
ffc05018: 3b c0 ff ff li r30,-1
}
ffc0501c: 39 61 00 20 addi r11,r1,32
ffc05020: 7f c3 f3 78 mr r3,r30
ffc05024: 48 01 c0 d0 b ffc210f4 <_restgpr_30_x>
ffc0cb3c <IMFS_find_match_in_dir>:
IMFS_jnode_t *IMFS_find_match_in_dir(
IMFS_jnode_t *directory,
char *name
)
{
ffc0cb3c: 94 21 ff e8 stwu r1,-24(r1)
ffc0cb40: 7c 08 02 a6 mflr r0
ffc0cb44: bf a1 00 0c stmw r29,12(r1)
/*
* Check for "." and ".."
*/
if ( !strcmp( name, dotname ) )
ffc0cb48: 3f c0 ff c2 lis r30,-62
ffc0cb4c: 3b de d9 3c addi r30,r30,-9924
IMFS_jnode_t *IMFS_find_match_in_dir(
IMFS_jnode_t *directory,
char *name
)
{
ffc0cb50: 7c 7f 1b 78 mr r31,r3
ffc0cb54: 90 01 00 1c stw r0,28(r1)
/*
* Check for "." and ".."
*/
if ( !strcmp( name, dotname ) )
ffc0cb58: 7c 83 23 78 mr r3,r4
IMFS_jnode_t *IMFS_find_match_in_dir(
IMFS_jnode_t *directory,
char *name
)
{
ffc0cb5c: 7c 9d 23 78 mr r29,r4
/*
* Check for "." and ".."
*/
if ( !strcmp( name, dotname ) )
ffc0cb60: 7f c4 f3 78 mr r4,r30
ffc0cb64: 48 00 53 a1 bl ffc11f04 <strcmp>
ffc0cb68: 2f 83 00 00 cmpwi cr7,r3,0
ffc0cb6c: 41 9e 00 58 beq- cr7,ffc0cbc4 <IMFS_find_match_in_dir+0x88><== NEVER TAKEN
return directory;
if ( !strcmp( name, dotdotname ) )
ffc0cb70: 7f a3 eb 78 mr r3,r29
ffc0cb74: 38 9e 00 04 addi r4,r30,4
ffc0cb78: 48 00 53 8d bl ffc11f04 <strcmp>
ffc0cb7c: 2f 83 00 00 cmpwi cr7,r3,0
ffc0cb80: 40 be 00 0c bne+ cr7,ffc0cb8c <IMFS_find_match_in_dir+0x50><== ALWAYS TAKEN
return directory->Parent;
ffc0cb84: 83 ff 00 08 lwz r31,8(r31) <== NOT EXECUTED
ffc0cb88: 48 00 00 3c b ffc0cbc4 <IMFS_find_match_in_dir+0x88> <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
ffc0cb8c: 83 df 00 50 lwz r30,80(r31)
RTEMS_INLINE_ROUTINE bool _Chain_Is_tail(
Chain_Control *the_chain,
const Chain_Node *the_node
)
{
return (the_node == _Chain_Tail(the_chain));
ffc0cb90: 3b ff 00 54 addi r31,r31,84
the_chain = &directory->info.directory.Entries;
for ( the_node = rtems_chain_first( the_chain );
ffc0cb94: 48 00 00 1c b ffc0cbb0 <IMFS_find_match_in_dir+0x74>
!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 ) )
ffc0cb98: 7f a3 eb 78 mr r3,r29
ffc0cb9c: 38 9e 00 0c addi r4,r30,12
ffc0cba0: 48 00 53 65 bl ffc11f04 <strcmp>
ffc0cba4: 2f 83 00 00 cmpwi cr7,r3,0
ffc0cba8: 41 9e 00 18 beq- cr7,ffc0cbc0 <IMFS_find_match_in_dir+0x84>
the_chain = &directory->info.directory.Entries;
for ( the_node = rtems_chain_first( the_chain );
!rtems_chain_is_tail( the_chain, the_node );
the_node = the_node->next ) {
ffc0cbac: 83 de 00 00 lwz r30,0(r30)
if ( !strcmp( name, dotdotname ) )
return directory->Parent;
the_chain = &directory->info.directory.Entries;
for ( the_node = rtems_chain_first( the_chain );
ffc0cbb0: 7f 9e f8 00 cmpw cr7,r30,r31
ffc0cbb4: 40 9e ff e4 bne+ cr7,ffc0cb98 <IMFS_find_match_in_dir+0x5c>
if ( !strcmp( name, the_jnode->name ) )
return the_jnode;
}
return 0;
ffc0cbb8: 3b e0 00 00 li r31,0
ffc0cbbc: 48 00 00 08 b ffc0cbc4 <IMFS_find_match_in_dir+0x88>
!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 ) )
ffc0cbc0: 7f df f3 78 mr r31,r30
return the_jnode;
}
return 0;
}
ffc0cbc4: 39 61 00 18 addi r11,r1,24
ffc0cbc8: 7f e3 fb 78 mr r3,r31
ffc0cbcc: 4b ff 39 70 b ffc0053c <_restgpr_29_x>
ffc0ca7c <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
)
{
ffc0ca7c: 94 21 ff c8 stwu r1,-56(r1)
ffc0ca80: 7c 08 02 a6 mflr r0
/*
* Traverse tree that starts at the mt_fs_root and deallocate memory
* associated memory space
*/
jnode = (IMFS_jnode_t *)temp_mt_entry->mt_fs_root.node_access;
ffc0ca84: 7c 6b 1b 78 mr r11,r3
((IMFS_jnode_t *)( rtems_chain_head( jnode_get_control( jnode ) )->next))
int IMFS_fsunmount(
rtems_filesystem_mount_table_entry_t *temp_mt_entry
)
{
ffc0ca88: 90 01 00 3c stw r0,60(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;
ffc0ca8c: 38 81 00 08 addi r4,r1,8
/*
* Set this to null to indicate that it is being unmounted.
*/
temp_mt_entry->mt_fs_root.node_access = NULL;
ffc0ca90: 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
)
{
ffc0ca94: bf a1 00 2c stmw r29,44(r1)
temp_mt_entry->mt_fs_root.node_access = NULL;
do {
next = jnode->Parent;
loc.node_access = (void *)jnode;
IMFS_Set_handlers( &loc );
ffc0ca98: 7c 9e 23 78 mr r30,r4
/*
* 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;
ffc0ca9c: 87 eb 00 1c lwzu r31,28(r11)
loc = temp_mt_entry->mt_fs_root;
ffc0caa0: 7c ab a4 aa lswi r5,r11,20
ffc0caa4: 7c a4 a5 aa stswi r5,r4,20
/*
* Set this to null to indicate that it is being unmounted.
*/
temp_mt_entry->mt_fs_root.node_access = NULL;
ffc0caa8: 90 03 00 1c stw r0,28(r3)
ffc0caac: 48 00 00 08 b ffc0cab4 <IMFS_fsunmount+0x38>
if ( jnode->type == IMFS_DIRECTORY ) {
if ( jnode_has_children( jnode ) )
jnode = jnode_get_first_child( jnode );
}
}
} while (jnode != NULL);
ffc0cab0: 7c 1f 03 78 mr r31,r0
temp_mt_entry->mt_fs_root.node_access = NULL;
do {
next = jnode->Parent;
loc.node_access = (void *)jnode;
IMFS_Set_handlers( &loc );
ffc0cab4: 7f c3 f3 78 mr r3,r30
*/
temp_mt_entry->mt_fs_root.node_access = NULL;
do {
next = jnode->Parent;
ffc0cab8: 83 bf 00 08 lwz r29,8(r31)
loc.node_access = (void *)jnode;
ffc0cabc: 93 e1 00 08 stw r31,8(r1)
IMFS_Set_handlers( &loc );
ffc0cac0: 4b ff f7 79 bl ffc0c238 <IMFS_Set_handlers>
if ( jnode->type != IMFS_DIRECTORY ) {
ffc0cac4: 80 1f 00 4c lwz r0,76(r31)
ffc0cac8: 2f 80 00 01 cmpwi cr7,r0,1
ffc0cacc: 40 9e 00 14 bne- cr7,ffc0cae0 <IMFS_fsunmount+0x64>
result = IMFS_unlink( NULL, &loc );
if (result != 0)
return -1;
jnode = next;
} else if ( jnode_has_no_children( jnode ) ) {
ffc0cad0: 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 );
ffc0cad4: 38 1f 00 54 addi r0,r31,84
ffc0cad8: 7f 89 00 00 cmpw cr7,r9,r0
ffc0cadc: 40 be 00 1c bne+ cr7,ffc0caf8 <IMFS_fsunmount+0x7c>
result = IMFS_unlink( NULL, &loc );
ffc0cae0: 38 60 00 00 li r3,0
ffc0cae4: 7f c4 f3 78 mr r4,r30
ffc0cae8: 4b ff 75 a5 bl ffc0408c <IMFS_unlink>
if (result != 0)
ffc0caec: 2f 83 00 00 cmpwi cr7,r3,0
ffc0caf0: 40 9e 00 38 bne- cr7,ffc0cb28 <IMFS_fsunmount+0xac> <== NEVER TAKEN
return -1;
jnode = next;
ffc0caf4: 7f bf eb 78 mr r31,r29
}
if ( jnode != NULL ) {
ffc0caf8: 2f 9f 00 00 cmpwi cr7,r31,0
ffc0cafc: 41 9e 00 34 beq- cr7,ffc0cb30 <IMFS_fsunmount+0xb4>
if ( jnode->type == IMFS_DIRECTORY ) {
ffc0cb00: 80 1f 00 4c lwz r0,76(r31)
ffc0cb04: 2f 80 00 01 cmpwi cr7,r0,1
ffc0cb08: 40 9e ff ac bne+ cr7,ffc0cab4 <IMFS_fsunmount+0x38> <== NEVER TAKEN
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_head( the_chain )->next;
ffc0cb0c: 80 1f 00 50 lwz r0,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 );
ffc0cb10: 39 3f 00 54 addi r9,r31,84
if ( jnode_has_children( jnode ) )
ffc0cb14: 7f 80 48 00 cmpw cr7,r0,r9
ffc0cb18: 41 be ff 9c beq- cr7,ffc0cab4 <IMFS_fsunmount+0x38>
jnode = jnode_get_first_child( jnode );
}
}
} while (jnode != NULL);
ffc0cb1c: 2f 80 00 00 cmpwi cr7,r0,0
ffc0cb20: 40 9e ff 90 bne+ cr7,ffc0cab0 <IMFS_fsunmount+0x34> <== ALWAYS TAKEN
ffc0cb24: 48 00 00 0c b ffc0cb30 <IMFS_fsunmount+0xb4> <== NOT EXECUTED
return -1;
jnode = next;
} else if ( jnode_has_no_children( jnode ) ) {
result = IMFS_unlink( NULL, &loc );
if (result != 0)
return -1;
ffc0cb28: 38 60 ff ff li r3,-1 <== NOT EXECUTED
ffc0cb2c: 48 00 00 08 b ffc0cb34 <IMFS_fsunmount+0xb8> <== NOT EXECUTED
jnode = jnode_get_first_child( jnode );
}
}
} while (jnode != NULL);
return 0;
ffc0cb30: 38 60 00 00 li r3,0
}
ffc0cb34: 39 61 00 38 addi r11,r1,56
ffc0cb38: 4b ff 3a 04 b ffc0053c <_restgpr_29_x>
ffc0cbd0 <IMFS_get_token>:
const char *path,
int pathlen,
char *token,
int *token_len
)
{
ffc0cbd0: 94 21 ff e0 stwu r1,-32(r1)
ffc0cbd4: 7c 08 02 a6 mflr r0
ffc0cbd8: bf 41 00 08 stmw r26,8(r1)
ffc0cbdc: 7c 7f 1b 78 mr r31,r3
ffc0cbe0: 7c 9d 23 78 mr r29,r4
ffc0cbe4: 90 01 00 24 stw r0,36(r1)
ffc0cbe8: 7c be 2b 78 mr r30,r5
ffc0cbec: 7c da 33 78 mr r26,r6
register char c;
/*
* Copy a name into token. (Remember NULL is a token.)
*/
c = path[i];
ffc0cbf0: 8b 63 00 00 lbz r27,0(r3)
int pathlen,
char *token,
int *token_len
)
{
register int i = 0;
ffc0cbf4: 3b 80 00 00 li r28,0
/*
* Copy a name into token. (Remember NULL is a token.)
*/
c = path[i];
while ( (!IMFS_is_separator(c)) && (i < pathlen) && (i <= IMFS_NAME_MAX) ) {
ffc0cbf8: 48 00 00 18 b ffc0cc10 <IMFS_get_token+0x40>
token[i] = c;
if ( i == IMFS_NAME_MAX )
ffc0cbfc: 2f 9c 00 20 cmpwi cr7,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) ) {
token[i] = c;
ffc0cc00: 7f 7e e1 ae stbx r27,r30,r28
if ( i == IMFS_NAME_MAX )
ffc0cc04: 41 9e 00 b4 beq- cr7,ffc0ccb8 <IMFS_get_token+0xe8>
return IMFS_INVALID_TOKEN;
if ( !IMFS_is_valid_name_char(c) )
type = IMFS_INVALID_TOKEN;
c = path [++i];
ffc0cc08: 3b 9c 00 01 addi r28,r28,1
ffc0cc0c: 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) ) {
ffc0cc10: 7f 63 db 78 mr r3,r27
ffc0cc14: 4b ff 8d 61 bl ffc05974 <rtems_filesystem_is_separator>
ffc0cc18: 2f 83 00 00 cmpwi cr7,r3,0
ffc0cc1c: 40 9e 00 0c bne- cr7,ffc0cc28 <IMFS_get_token+0x58>
ffc0cc20: 7f 9c e8 00 cmpw cr7,r28,r29
ffc0cc24: 41 9c ff d8 blt+ cr7,ffc0cbfc <IMFS_get_token+0x2c>
/*
* Copy a seperator into token.
*/
if ( i == 0 ) {
ffc0cc28: 2f 9c 00 00 cmpwi cr7,r28,0
ffc0cc2c: 40 9e 00 30 bne- cr7,ffc0cc5c <IMFS_get_token+0x8c>
token[i] = c;
if ( (token[i] != '\0') && pathlen ) {
ffc0cc30: 2f 9b 00 00 cmpwi cr7,r27,0
/*
* Copy a seperator into token.
*/
if ( i == 0 ) {
token[i] = c;
ffc0cc34: 9b 7e 00 00 stb r27,0(r30)
if ( (token[i] != '\0') && pathlen ) {
i++;
type = IMFS_CURRENT_DIR;
} else {
type = IMFS_NO_MORE_PATH;
ffc0cc38: 3b e0 00 00 li r31,0
*/
if ( i == 0 ) {
token[i] = c;
if ( (token[i] != '\0') && pathlen ) {
ffc0cc3c: 41 9e 00 3c beq- cr7,ffc0cc78 <IMFS_get_token+0xa8>
ffc0cc40: 2f 9d 00 00 cmpwi cr7,r29,0
i++;
type = IMFS_CURRENT_DIR;
ffc0cc44: 3b e0 00 01 li r31,1
if ( i == 0 ) {
token[i] = c;
if ( (token[i] != '\0') && pathlen ) {
i++;
ffc0cc48: 3b 80 00 01 li r28,1
*/
if ( i == 0 ) {
token[i] = c;
if ( (token[i] != '\0') && pathlen ) {
ffc0cc4c: 40 9e 00 2c bne- cr7,ffc0cc78 <IMFS_get_token+0xa8>
ffc0cc50: 3b 80 00 00 li r28,0
i++;
type = IMFS_CURRENT_DIR;
} else {
type = IMFS_NO_MORE_PATH;
ffc0cc54: 3b e0 00 00 li r31,0
ffc0cc58: 48 00 00 20 b ffc0cc78 <IMFS_get_token+0xa8>
}
} else if (token[ i-1 ] != '\0') {
ffc0cc5c: 7d 3e e2 14 add r9,r30,r28
ffc0cc60: 88 09 ff ff lbz r0,-1(r9)
char *token,
int *token_len
)
{
register int i = 0;
IMFS_token_types type = IMFS_NAME;
ffc0cc64: 3b e0 00 03 li r31,3
i++;
type = IMFS_CURRENT_DIR;
} else {
type = IMFS_NO_MORE_PATH;
}
} else if (token[ i-1 ] != '\0') {
ffc0cc68: 2f 80 00 00 cmpwi cr7,r0,0
ffc0cc6c: 41 9e 00 0c beq- cr7,ffc0cc78 <IMFS_get_token+0xa8> <== NEVER TAKEN
token[i] = '\0';
ffc0cc70: 38 00 00 00 li r0,0
ffc0cc74: 7c 1e e1 ae stbx r0,r30,r28
/*
* If we copied something that was not a seperator see if
* it was a special name.
*/
if ( type == IMFS_NAME ) {
ffc0cc78: 2f 9f 00 03 cmpwi cr7,r31,3
/*
* Set token_len to the number of characters copied.
*/
*token_len = i;
ffc0cc7c: 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 ) {
ffc0cc80: 40 be 00 4c bne+ cr7,ffc0cccc <IMFS_get_token+0xfc>
if ( strcmp( token, "..") == 0 )
ffc0cc84: 3c 80 ff c2 lis r4,-62
ffc0cc88: 7f c3 f3 78 mr r3,r30
ffc0cc8c: 38 84 d9 43 addi r4,r4,-9917
ffc0cc90: 48 00 52 75 bl ffc11f04 <strcmp>
ffc0cc94: 2f 83 00 00 cmpwi cr7,r3,0
ffc0cc98: 41 9e 00 28 beq- cr7,ffc0ccc0 <IMFS_get_token+0xf0>
type = IMFS_UP_DIR;
else if ( strcmp( token, "." ) == 0 )
ffc0cc9c: 3c 80 ff c2 lis r4,-62
ffc0cca0: 7f c3 f3 78 mr r3,r30
ffc0cca4: 38 84 d9 44 addi r4,r4,-9916
ffc0cca8: 48 00 52 5d bl ffc11f04 <strcmp>
ffc0ccac: 2f 83 00 00 cmpwi cr7,r3,0
ffc0ccb0: 41 9e 00 18 beq- cr7,ffc0ccc8 <IMFS_get_token+0xf8>
ffc0ccb4: 48 00 00 18 b ffc0cccc <IMFS_get_token+0xfc>
while ( (!IMFS_is_separator(c)) && (i < pathlen) && (i <= IMFS_NAME_MAX) ) {
token[i] = c;
if ( i == IMFS_NAME_MAX )
return IMFS_INVALID_TOKEN;
ffc0ccb8: 3b e0 00 04 li r31,4
ffc0ccbc: 48 00 00 10 b ffc0cccc <IMFS_get_token+0xfc>
* it was a special name.
*/
if ( type == IMFS_NAME ) {
if ( strcmp( token, "..") == 0 )
type = IMFS_UP_DIR;
ffc0ccc0: 3b e0 00 02 li r31,2
ffc0ccc4: 48 00 00 08 b ffc0cccc <IMFS_get_token+0xfc>
else if ( strcmp( token, "." ) == 0 )
type = IMFS_CURRENT_DIR;
ffc0ccc8: 3b e0 00 01 li r31,1
}
return type;
}
ffc0cccc: 39 61 00 20 addi r11,r1,32
ffc0ccd0: 7f e3 fb 78 mr r3,r31
ffc0ccd4: 4b ff 38 5c b ffc00530 <_restgpr_26_x>
ffc0f574 <IMFS_memfile_extend>:
*/
MEMFILE_STATIC int IMFS_memfile_extend(
IMFS_jnode_t *the_jnode,
off_t new_length
)
{
ffc0f574: 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 )
ffc0f578: 3d 20 00 00 lis r9,0
*/
MEMFILE_STATIC int IMFS_memfile_extend(
IMFS_jnode_t *the_jnode,
off_t new_length
)
{
ffc0f57c: 7c 08 02 a6 mflr r0
ffc0f580: bf 01 00 18 stmw r24,24(r1)
ffc0f584: 7c 7f 1b 78 mr r31,r3
ffc0f588: 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 )
ffc0f58c: 83 c9 27 e8 lwz r30,10216(r9)
*/
MEMFILE_STATIC int IMFS_memfile_extend(
IMFS_jnode_t *the_jnode,
off_t new_length
)
{
ffc0f590: 7c dd 33 78 mr r29,r6
ffc0f594: 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 )
ffc0f598: 57 c9 f0 be rlwinm r9,r30,30,2,31
ffc0f59c: 39 69 00 01 addi r11,r9,1
ffc0f5a0: 7d 6b 49 d6 mullw r11,r11,r9
ffc0f5a4: 38 0b 00 01 addi r0,r11,1
ffc0f5a8: 7d 20 49 d6 mullw r9,r0,r9
ffc0f5ac: 38 00 00 00 li r0,0
ffc0f5b0: 7f 80 28 00 cmpw cr7,r0,r5
ffc0f5b4: 39 29 ff ff addi r9,r9,-1
ffc0f5b8: 7d 29 f1 d6 mullw r9,r9,r30
ffc0f5bc: 41 bd 00 1c bgt+ cr7,ffc0f5d8 <IMFS_memfile_extend+0x64>
ffc0f5c0: 40 9e 00 0c bne- cr7,ffc0f5cc <IMFS_memfile_extend+0x58><== NEVER TAKEN
ffc0f5c4: 7f 89 30 40 cmplw cr7,r9,r6
ffc0f5c8: 41 bd 00 10 bgt+ cr7,ffc0f5d8 <IMFS_memfile_extend+0x64>
rtems_set_errno_and_return_minus_one( EINVAL );
ffc0f5cc: 48 00 15 e9 bl ffc10bb4 <__errno>
ffc0f5d0: 38 00 00 16 li r0,22
ffc0f5d4: 48 00 00 94 b ffc0f668 <IMFS_memfile_extend+0xf4>
/*
* Verify new file size is actually larger than current size
*/
if ( new_length <= the_jnode->info.file.size )
ffc0f5d8: 83 3f 00 50 lwz r25,80(r31)
ffc0f5dc: 83 5f 00 54 lwz r26,84(r31)
ffc0f5e0: 7f 9c c8 00 cmpw cr7,r28,r25
ffc0f5e4: 41 bd 00 10 bgt+ cr7,ffc0f5f4 <IMFS_memfile_extend+0x80><== NEVER TAKEN
ffc0f5e8: 40 9e 00 c8 bne- cr7,ffc0f6b0 <IMFS_memfile_extend+0x13c>
ffc0f5ec: 7f 9d d0 40 cmplw cr7,r29,r26
ffc0f5f0: 40 9d 00 c0 ble- cr7,ffc0f6b0 <IMFS_memfile_extend+0x13c>
return 0;
/*
* Calculate the number of range of blocks to allocate
*/
new_blocks = new_length / IMFS_MEMFILE_BYTES_PER_BLOCK;
ffc0f5f4: 7f db fe 70 srawi r27,r30,31
ffc0f5f8: 7f 65 db 78 mr r5,r27
ffc0f5fc: 7f c6 f3 78 mr r6,r30
ffc0f600: 7f 83 e3 78 mr r3,r28
ffc0f604: 7f a4 eb 78 mr r4,r29
ffc0f608: 48 00 ac e1 bl ffc1a2e8 <__divdi3>
old_blocks = the_jnode->info.file.size / IMFS_MEMFILE_BYTES_PER_BLOCK;
ffc0f60c: 7f 65 db 78 mr r5,r27
ffc0f610: 7f c6 f3 78 mr r6,r30
return 0;
/*
* Calculate the number of range of blocks to allocate
*/
new_blocks = new_length / IMFS_MEMFILE_BYTES_PER_BLOCK;
ffc0f614: 7c 98 23 78 mr r24,r4
old_blocks = the_jnode->info.file.size / IMFS_MEMFILE_BYTES_PER_BLOCK;
ffc0f618: 7f 23 cb 78 mr r3,r25
ffc0f61c: 7f 44 d3 78 mr r4,r26
ffc0f620: 48 00 ac c9 bl ffc1a2e8 <__divdi3>
ffc0f624: 7c 9b 23 78 mr r27,r4
/*
* Now allocate each of those blocks.
*/
for ( block=old_blocks ; block<=new_blocks ; block++ ) {
ffc0f628: 7c 9e 23 78 mr r30,r4
ffc0f62c: 48 00 00 4c b ffc0f678 <IMFS_memfile_extend+0x104>
if ( IMFS_memfile_addblock( the_jnode, block ) ) {
ffc0f630: 7f e3 fb 78 mr r3,r31
ffc0f634: 7f c4 f3 78 mr r4,r30
ffc0f638: 4b ff fc e9 bl ffc0f320 <IMFS_memfile_addblock>
ffc0f63c: 2f 83 00 00 cmpwi cr7,r3,0
ffc0f640: 41 be 00 34 beq+ cr7,ffc0f674 <IMFS_memfile_extend+0x100>
ffc0f644: 48 00 00 14 b ffc0f658 <IMFS_memfile_extend+0xe4>
for ( ; block>=old_blocks ; block-- ) {
IMFS_memfile_remove_block( the_jnode, block );
ffc0f648: 7f c4 f3 78 mr r4,r30
ffc0f64c: 7f e3 fb 78 mr r3,r31
ffc0f650: 4b ff fe e9 bl ffc0f538 <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-- ) {
ffc0f654: 3b de ff ff addi r30,r30,-1
ffc0f658: 7f 9e d8 40 cmplw cr7,r30,r27
ffc0f65c: 40 9c ff ec bge+ cr7,ffc0f648 <IMFS_memfile_extend+0xd4>
IMFS_memfile_remove_block( the_jnode, block );
}
rtems_set_errno_and_return_minus_one( ENOSPC );
ffc0f660: 48 00 15 55 bl ffc10bb4 <__errno>
ffc0f664: 38 00 00 1c li r0,28
ffc0f668: 90 03 00 00 stw r0,0(r3)
ffc0f66c: 38 60 ff ff li r3,-1
ffc0f670: 48 00 00 44 b ffc0f6b4 <IMFS_memfile_extend+0x140>
old_blocks = the_jnode->info.file.size / IMFS_MEMFILE_BYTES_PER_BLOCK;
/*
* Now allocate each of those blocks.
*/
for ( block=old_blocks ; block<=new_blocks ; block++ ) {
ffc0f674: 3b de 00 01 addi r30,r30,1
ffc0f678: 7f 9e c0 40 cmplw cr7,r30,r24
ffc0f67c: 40 9d ff b4 ble+ cr7,ffc0f630 <IMFS_memfile_extend+0xbc>
}
/*
* Set the new length of the file.
*/
the_jnode->info.file.size = new_length;
ffc0f680: 93 9f 00 50 stw r28,80(r31)
IMFS_update_ctime(the_jnode);
ffc0f684: 38 80 00 00 li r4,0
ffc0f688: 38 61 00 08 addi r3,r1,8
}
/*
* Set the new length of the file.
*/
the_jnode->info.file.size = new_length;
ffc0f68c: 93 bf 00 54 stw r29,84(r31)
IMFS_update_ctime(the_jnode);
ffc0f690: 4b ff 53 81 bl ffc04a10 <gettimeofday>
ffc0f694: 80 01 00 08 lwz r0,8(r1)
IMFS_update_mtime(the_jnode);
ffc0f698: 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);
ffc0f69c: 90 1f 00 48 stw r0,72(r31)
IMFS_update_mtime(the_jnode);
ffc0f6a0: 38 80 00 00 li r4,0
ffc0f6a4: 4b ff 53 6d bl ffc04a10 <gettimeofday>
ffc0f6a8: 80 01 00 08 lwz r0,8(r1)
ffc0f6ac: 90 1f 00 44 stw r0,68(r31)
/*
* Verify new file size is actually larger than current size
*/
if ( new_length <= the_jnode->info.file.size )
return 0;
ffc0f6b0: 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;
}
ffc0f6b4: 39 61 00 38 addi r11,r1,56
ffc0f6b8: 4b ff 0e 70 b ffc00528 <_restgpr_24_x>
ffc0ef34 <IMFS_memfile_get_block_pointer>:
my_block = block;
/*
* Is the block number in the simple indirect portion?
*/
if ( my_block <= LAST_INDIRECT ) {
ffc0ef34: 3d 20 00 00 lis r9,0
#endif
IMFS_jnode_t *the_jnode,
unsigned int block,
int malloc_it
)
{
ffc0ef38: 94 21 ff e0 stwu r1,-32(r1)
ffc0ef3c: 7c 08 02 a6 mflr r0
my_block = block;
/*
* Is the block number in the simple indirect portion?
*/
if ( my_block <= LAST_INDIRECT ) {
ffc0ef40: 81 29 27 e8 lwz r9,10216(r9)
#endif
IMFS_jnode_t *the_jnode,
unsigned int block,
int malloc_it
)
{
ffc0ef44: 90 01 00 24 stw r0,36(r1)
my_block = block;
/*
* Is the block number in the simple indirect portion?
*/
if ( my_block <= LAST_INDIRECT ) {
ffc0ef48: 55 29 f0 be rlwinm r9,r9,30,2,31
ffc0ef4c: 38 09 ff ff addi r0,r9,-1
#endif
IMFS_jnode_t *the_jnode,
unsigned int block,
int malloc_it
)
{
ffc0ef50: bf 61 00 0c stmw r27,12(r1)
my_block = block;
/*
* Is the block number in the simple indirect portion?
*/
if ( my_block <= LAST_INDIRECT ) {
ffc0ef54: 7f 84 00 40 cmplw cr7,r4,r0
#endif
IMFS_jnode_t *the_jnode,
unsigned int block,
int malloc_it
)
{
ffc0ef58: 7c 7f 1b 78 mr r31,r3
ffc0ef5c: 7c 9e 23 78 mr r30,r4
my_block = block;
/*
* Is the block number in the simple indirect portion?
*/
if ( my_block <= LAST_INDIRECT ) {
ffc0ef60: 41 9d 00 44 bgt- cr7,ffc0efa4 <IMFS_memfile_get_block_pointer+0x70>
p = info->indirect;
if ( malloc_it ) {
ffc0ef64: 2f 05 00 00 cmpwi cr6,r5,0
/*
* Is the block number in the simple indirect portion?
*/
if ( my_block <= LAST_INDIRECT ) {
p = info->indirect;
ffc0ef68: 80 03 00 58 lwz r0,88(r3)
ffc0ef6c: 2f 80 00 00 cmpwi cr7,r0,0
if ( malloc_it ) {
ffc0ef70: 41 9a 00 2c beq- cr6,ffc0ef9c <IMFS_memfile_get_block_pointer+0x68>
if ( !p ) {
ffc0ef74: 40 be 00 18 bne+ cr7,ffc0ef8c <IMFS_memfile_get_block_pointer+0x58>
p = memfile_alloc_block();
ffc0ef78: 4b ff ff 79 bl ffc0eef0 <memfile_alloc_block>
if ( !p )
return 0;
ffc0ef7c: 3b a0 00 00 li r29,0
if ( malloc_it ) {
if ( !p ) {
p = memfile_alloc_block();
if ( !p )
ffc0ef80: 2c 03 00 00 cmpwi r3,0
ffc0ef84: 41 82 01 78 beq- ffc0f0fc <IMFS_memfile_get_block_pointer+0x1c8><== NEVER TAKEN
return 0;
info->indirect = p;
ffc0ef88: 90 7f 00 58 stw r3,88(r31)
}
return &info->indirect[ my_block ];
ffc0ef8c: 83 bf 00 58 lwz r29,88(r31)
ffc0ef90: 57 de 10 3a rlwinm r30,r30,2,0,29
ffc0ef94: 7f bd f2 14 add r29,r29,r30
ffc0ef98: 48 00 01 64 b ffc0f0fc <IMFS_memfile_get_block_pointer+0x1c8>
}
if ( !p )
ffc0ef9c: 40 be 01 50 bne+ cr7,ffc0f0ec <IMFS_memfile_get_block_pointer+0x1b8><== ALWAYS TAKEN
ffc0efa0: 48 00 01 58 b ffc0f0f8 <IMFS_memfile_get_block_pointer+0x1c4><== NOT EXECUTED
/*
* Is the block number in the doubly indirect portion?
*/
if ( my_block <= LAST_DOUBLY_INDIRECT ) {
ffc0efa4: 39 69 00 01 addi r11,r9,1
ffc0efa8: 7d 6b 49 d6 mullw r11,r11,r9
ffc0efac: 38 0b ff ff addi r0,r11,-1
ffc0efb0: 7f 84 00 40 cmplw cr7,r4,r0
ffc0efb4: 41 9d 00 60 bgt- cr7,ffc0f014 <IMFS_memfile_get_block_pointer+0xe0>
my_block -= FIRST_DOUBLY_INDIRECT;
ffc0efb8: 7f c9 20 50 subf r30,r9,r4
singly = my_block % IMFS_MEMFILE_BLOCK_SLOTS;
doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS;
p = info->doubly_indirect;
ffc0efbc: 80 63 00 5c lwz r3,92(r3)
*/
if ( my_block <= LAST_DOUBLY_INDIRECT ) {
my_block -= FIRST_DOUBLY_INDIRECT;
singly = my_block % IMFS_MEMFILE_BLOCK_SLOTS;
ffc0efc0: 7f 9e 4b 96 divwu r28,r30,r9
doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS;
p = info->doubly_indirect;
if ( malloc_it ) {
ffc0efc4: 2f 05 00 00 cmpwi cr6,r5,0
*/
if ( my_block <= LAST_DOUBLY_INDIRECT ) {
my_block -= FIRST_DOUBLY_INDIRECT;
singly = my_block % IMFS_MEMFILE_BLOCK_SLOTS;
ffc0efc8: 7d 3c 49 d6 mullw r9,r28,r9
ffc0efcc: 2f 83 00 00 cmpwi cr7,r3,0
ffc0efd0: 7f c9 f0 50 subf r30,r9,r30
doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS;
p = info->doubly_indirect;
if ( malloc_it ) {
ffc0efd4: 41 9a 00 2c beq- cr6,ffc0f000 <IMFS_memfile_get_block_pointer+0xcc>
if ( !p ) {
ffc0efd8: 40 be 00 18 bne+ cr7,ffc0eff0 <IMFS_memfile_get_block_pointer+0xbc>
p = memfile_alloc_block();
ffc0efdc: 4b ff ff 15 bl ffc0eef0 <memfile_alloc_block>
if ( !p )
return 0;
ffc0efe0: 3b a0 00 00 li r29,0
p = info->doubly_indirect;
if ( malloc_it ) {
if ( !p ) {
p = memfile_alloc_block();
if ( !p )
ffc0efe4: 2c 03 00 00 cmpwi r3,0
ffc0efe8: 41 82 01 14 beq- ffc0f0fc <IMFS_memfile_get_block_pointer+0x1c8><== NEVER TAKEN
return 0;
info->doubly_indirect = p;
ffc0efec: 90 7f 00 5c stw r3,92(r31)
}
p1 = (block_p *)p[ doubly ];
ffc0eff0: 57 9c 10 3a rlwinm r28,r28,2,0,29
ffc0eff4: 7f e3 e2 14 add r31,r3,r28
ffc0eff8: 7c 63 e0 2e lwzx r3,r3,r28
ffc0effc: 48 00 00 a4 b ffc0f0a0 <IMFS_memfile_get_block_pointer+0x16c>
}
return (block_p *)&p1[ singly ];
}
if ( !p )
ffc0f000: 41 9e 00 f8 beq- cr7,ffc0f0f8 <IMFS_memfile_get_block_pointer+0x1c4><== NEVER TAKEN
return 0;
p = (block_p *)p[ doubly ];
ffc0f004: 57 9c 10 3a rlwinm r28,r28,2,0,29
ffc0f008: 7c 03 e0 2e lwzx r0,r3,r28
if ( !p )
return 0;
ffc0f00c: 3b a0 00 00 li r29,0
ffc0f010: 48 00 00 d4 b ffc0f0e4 <IMFS_memfile_get_block_pointer+0x1b0>
}
/*
* Is the block number in the triply indirect portion?
*/
if ( my_block <= LAST_TRIPLY_INDIRECT ) {
ffc0f014: 39 4b 00 01 addi r10,r11,1
ffc0f018: 7d 4a 49 d6 mullw r10,r10,r9
}
/*
* This means the requested block number is out of range.
*/
return 0;
ffc0f01c: 3b a0 00 00 li r29,0
}
/*
* Is the block number in the triply indirect portion?
*/
if ( my_block <= LAST_TRIPLY_INDIRECT ) {
ffc0f020: 38 0a ff ff addi r0,r10,-1
ffc0f024: 7f 84 00 40 cmplw cr7,r4,r0
ffc0f028: 41 9d 00 d4 bgt- cr7,ffc0f0fc <IMFS_memfile_get_block_pointer+0x1c8><== NEVER TAKEN
my_block -= FIRST_TRIPLY_INDIRECT;
ffc0f02c: 7f cb 20 50 subf r30,r11,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;
ffc0f030: 80 63 00 60 lwz r3,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;
ffc0f034: 7c 1e 4b 96 divwu r0,r30,r9
doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS;
triply = doubly / IMFS_MEMFILE_BLOCK_SLOTS;
ffc0f038: 7f 80 4b 96 divwu r28,r0,r9
doubly %= IMFS_MEMFILE_BLOCK_SLOTS;
p = info->triply_indirect;
if ( malloc_it ) {
ffc0f03c: 2f 05 00 00 cmpwi cr6,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;
ffc0f040: 7d 60 49 d6 mullw r11,r0,r9
doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS;
triply = doubly / IMFS_MEMFILE_BLOCK_SLOTS;
doubly %= IMFS_MEMFILE_BLOCK_SLOTS;
ffc0f044: 7f 7c 49 d6 mullw r27,r28,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;
ffc0f048: 7f cb f0 50 subf r30,r11,r30
doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS;
triply = doubly / IMFS_MEMFILE_BLOCK_SLOTS;
doubly %= IMFS_MEMFILE_BLOCK_SLOTS;
ffc0f04c: 7f 7b 00 50 subf r27,r27,r0
ffc0f050: 2f 83 00 00 cmpwi cr7,r3,0
p = info->triply_indirect;
if ( malloc_it ) {
ffc0f054: 41 9a 00 74 beq- cr6,ffc0f0c8 <IMFS_memfile_get_block_pointer+0x194>
if ( !p ) {
ffc0f058: 40 be 00 14 bne+ cr7,ffc0f06c <IMFS_memfile_get_block_pointer+0x138>
p = memfile_alloc_block();
ffc0f05c: 4b ff fe 95 bl ffc0eef0 <memfile_alloc_block>
if ( !p )
ffc0f060: 2c 03 00 00 cmpwi r3,0
ffc0f064: 41 82 00 98 beq- ffc0f0fc <IMFS_memfile_get_block_pointer+0x1c8><== NEVER TAKEN
return 0;
info->triply_indirect = p;
ffc0f068: 90 7f 00 60 stw r3,96(r31)
}
p1 = (block_p *) p[ triply ];
ffc0f06c: 57 9c 10 3a rlwinm r28,r28,2,0,29
ffc0f070: 7f e3 e2 14 add r31,r3,r28
ffc0f074: 7c 63 e0 2e lwzx r3,r3,r28
if ( !p1 ) {
ffc0f078: 2f 83 00 00 cmpwi cr7,r3,0
ffc0f07c: 40 be 00 18 bne+ cr7,ffc0f094 <IMFS_memfile_get_block_pointer+0x160>
p1 = memfile_alloc_block();
ffc0f080: 4b ff fe 71 bl ffc0eef0 <memfile_alloc_block>
if ( !p1 )
return 0;
ffc0f084: 3b a0 00 00 li r29,0
}
p1 = (block_p *) p[ triply ];
if ( !p1 ) {
p1 = memfile_alloc_block();
if ( !p1 )
ffc0f088: 2c 03 00 00 cmpwi r3,0
ffc0f08c: 41 82 00 70 beq- ffc0f0fc <IMFS_memfile_get_block_pointer+0x1c8><== NEVER TAKEN
return 0;
p[ triply ] = (block_p) p1;
ffc0f090: 90 7f 00 00 stw r3,0(r31)
}
p2 = (block_p *)p1[ doubly ];
ffc0f094: 57 7b 10 3a rlwinm r27,r27,2,0,29
ffc0f098: 7f e3 da 14 add r31,r3,r27
ffc0f09c: 7c 63 d8 2e lwzx r3,r3,r27
if ( !p2 ) {
ffc0f0a0: 2f 83 00 00 cmpwi cr7,r3,0
ffc0f0a4: 40 be 00 18 bne+ cr7,ffc0f0bc <IMFS_memfile_get_block_pointer+0x188>
p2 = memfile_alloc_block();
ffc0f0a8: 4b ff fe 49 bl ffc0eef0 <memfile_alloc_block>
if ( !p2 )
return 0;
ffc0f0ac: 3b a0 00 00 li r29,0
}
p2 = (block_p *)p1[ doubly ];
if ( !p2 ) {
p2 = memfile_alloc_block();
if ( !p2 )
ffc0f0b0: 2c 03 00 00 cmpwi r3,0
ffc0f0b4: 41 82 00 48 beq- ffc0f0fc <IMFS_memfile_get_block_pointer+0x1c8><== NEVER TAKEN
return 0;
p1[ doubly ] = (block_p) p2;
ffc0f0b8: 90 7f 00 00 stw r3,0(r31)
}
return (block_p *)&p2[ singly ];
ffc0f0bc: 57 de 10 3a rlwinm r30,r30,2,0,29
ffc0f0c0: 7f a3 f2 14 add r29,r3,r30
ffc0f0c4: 48 00 00 38 b ffc0f0fc <IMFS_memfile_get_block_pointer+0x1c8>
}
if ( !p )
ffc0f0c8: 41 9e 00 34 beq- cr7,ffc0f0fc <IMFS_memfile_get_block_pointer+0x1c8><== NEVER TAKEN
return 0;
p1 = (block_p *) p[ triply ];
ffc0f0cc: 57 9c 10 3a rlwinm r28,r28,2,0,29
ffc0f0d0: 7d 23 e0 2e lwzx r9,r3,r28
if ( !p1 )
ffc0f0d4: 2f 89 00 00 cmpwi cr7,r9,0
ffc0f0d8: 41 9e 00 24 beq- cr7,ffc0f0fc <IMFS_memfile_get_block_pointer+0x1c8><== NEVER TAKEN
return 0;
p2 = (block_p *)p1[ doubly ];
ffc0f0dc: 57 7b 10 3a rlwinm r27,r27,2,0,29
ffc0f0e0: 7c 09 d8 2e lwzx r0,r9,r27
if ( !p2 )
ffc0f0e4: 2f 80 00 00 cmpwi cr7,r0,0
ffc0f0e8: 41 9e 00 14 beq- cr7,ffc0f0fc <IMFS_memfile_get_block_pointer+0x1c8><== NEVER TAKEN
return 0;
return (block_p *)&p2[ singly ];
ffc0f0ec: 57 de 10 3a rlwinm r30,r30,2,0,29
ffc0f0f0: 7f a0 f2 14 add r29,r0,r30
ffc0f0f4: 48 00 00 08 b ffc0f0fc <IMFS_memfile_get_block_pointer+0x1c8>
}
return &info->indirect[ my_block ];
}
if ( !p )
return 0;
ffc0f0f8: 3b a0 00 00 li r29,0 <== NOT EXECUTED
/*
* This means the requested block number is out of range.
*/
return 0;
}
ffc0f0fc: 39 61 00 20 addi r11,r1,32
ffc0f100: 7f a3 eb 78 mr r3,r29
ffc0f104: 4b ff 14 30 b ffc00534 <_restgpr_27_x>
ffc0f108 <IMFS_memfile_read>:
IMFS_jnode_t *the_jnode,
off_t start,
unsigned char *destination,
unsigned int length
)
{
ffc0f108: 94 21 ff c8 stwu r1,-56(r1)
ffc0f10c: 7c 08 02 a6 mflr r0
ffc0f110: 90 01 00 3c stw r0,60(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) {
ffc0f114: 80 03 00 4c lwz r0,76(r3)
IMFS_jnode_t *the_jnode,
off_t start,
unsigned char *destination,
unsigned int length
)
{
ffc0f118: bf 01 00 18 stmw r24,24(r1)
ffc0f11c: 7c 7d 1b 78 mr r29,r3
* 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) {
ffc0f120: 2f 80 00 06 cmpwi cr7,r0,6
IMFS_jnode_t *the_jnode,
off_t start,
unsigned char *destination,
unsigned int length
)
{
ffc0f124: 7c df 33 78 mr r31,r6
ffc0f128: 7c be 2b 78 mr r30,r5
ffc0f12c: 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) {
ffc0f130: 40 be 00 68 bne+ cr7,ffc0f198 <IMFS_memfile_read+0x90>
unsigned char *file_ptr;
file_ptr = (unsigned char *)the_jnode->info.linearfile.direct;
if (my_length > (the_jnode->info.linearfile.size - start))
ffc0f134: 81 43 00 50 lwz r10,80(r3)
ffc0f138: 38 00 00 00 li r0,0
ffc0f13c: 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;
ffc0f140: 80 83 00 58 lwz r4,88(r3)
if (my_length > (the_jnode->info.linearfile.size - start))
ffc0f144: 7c ff 58 10 subfc r7,r31,r11
ffc0f148: 7c de 51 10 subfe r6,r30,r10
ffc0f14c: 7f 80 30 00 cmpw cr7,r0,r6
ffc0f150: 41 bd 00 10 bgt+ cr7,ffc0f160 <IMFS_memfile_read+0x58> <== NEVER TAKEN
ffc0f154: 40 9e 00 14 bne- cr7,ffc0f168 <IMFS_memfile_read+0x60> <== NEVER TAKEN
ffc0f158: 7f 88 38 40 cmplw cr7,r8,r7
ffc0f15c: 40 9d 00 0c ble- cr7,ffc0f168 <IMFS_memfile_read+0x60> <== NEVER TAKEN
my_length = the_jnode->info.linearfile.size - start;
ffc0f160: 7f 7f 58 50 subf r27,r31,r11
ffc0f164: 48 00 00 08 b ffc0f16c <IMFS_memfile_read+0x64>
/*
* Linear files (as created from a tar file are easier to handle
* than block files).
*/
my_length = length;
ffc0f168: 7d 1b 43 78 mr r27,r8 <== NOT EXECUTED
file_ptr = (unsigned char *)the_jnode->info.linearfile.direct;
if (my_length > (the_jnode->info.linearfile.size - start))
my_length = the_jnode->info.linearfile.size - start;
memcpy(dest, &file_ptr[start], my_length);
ffc0f16c: 7c 84 fa 14 add r4,r4,r31
ffc0f170: 7f 65 db 78 mr r5,r27
ffc0f174: 7f 83 e3 78 mr r3,r28
ffc0f178: 48 00 27 79 bl ffc118f0 <memcpy>
IMFS_update_atime( the_jnode );
ffc0f17c: 38 61 00 08 addi r3,r1,8
ffc0f180: 38 80 00 00 li r4,0
ffc0f184: 4b ff 58 8d bl ffc04a10 <gettimeofday>
ffc0f188: 80 01 00 08 lwz r0,8(r1)
return my_length;
ffc0f18c: 7f 7e db 78 mr r30,r27
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 );
ffc0f190: 90 1d 00 40 stw r0,64(r29)
return my_length;
ffc0f194: 48 00 01 64 b ffc0f2f8 <IMFS_memfile_read+0x1f0>
/*
* 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 )
ffc0f198: 81 63 00 50 lwz r11,80(r3)
ffc0f19c: 39 40 00 00 li r10,0
/*
* 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;
ffc0f1a0: 7c c0 33 78 mr r0,r6
if ( last_byte > the_jnode->info.file.size )
ffc0f1a4: 83 63 00 54 lwz r27,84(r3)
ffc0f1a8: 7f 8a 58 00 cmpw cr7,r10,r11
/*
* 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;
ffc0f1ac: 7d 28 32 14 add r9,r8,r6
if ( last_byte > the_jnode->info.file.size )
ffc0f1b0: 41 9d 00 10 bgt- cr7,ffc0f1c0 <IMFS_memfile_read+0xb8> <== NEVER TAKEN
ffc0f1b4: 40 9e 00 14 bne- cr7,ffc0f1c8 <IMFS_memfile_read+0xc0> <== NEVER TAKEN
ffc0f1b8: 7f 89 d8 40 cmplw cr7,r9,r27
ffc0f1bc: 40 9d 00 0c ble- cr7,ffc0f1c8 <IMFS_memfile_read+0xc0>
my_length = the_jnode->info.file.size - start;
ffc0f1c0: 7f 60 d8 50 subf r27,r0,r27
ffc0f1c4: 48 00 00 08 b ffc0f1cc <IMFS_memfile_read+0xc4>
/*
* Linear files (as created from a tar file are easier to handle
* than block files).
*/
my_length = length;
ffc0f1c8: 7d 1b 43 78 mr r27,r8
*/
/*
* Phase 1: possibly the last part of one block
*/
start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;
ffc0f1cc: 3d 20 00 00 lis r9,0
ffc0f1d0: 83 49 27 e8 lwz r26,10216(r9)
ffc0f1d4: 7f c3 f3 78 mr r3,r30
ffc0f1d8: 7f e4 fb 78 mr r4,r31
ffc0f1dc: 7f 58 fe 70 srawi r24,r26,31
ffc0f1e0: 7f 05 c3 78 mr r5,r24
ffc0f1e4: 7f 46 d3 78 mr r6,r26
ffc0f1e8: 48 00 b5 41 bl ffc1a728 <__moddi3>
block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;
ffc0f1ec: 7f c3 f3 78 mr r3,r30
*/
/*
* Phase 1: possibly the last part of one block
*/
start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;
ffc0f1f0: 7c 99 23 78 mr r25,r4
block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;
ffc0f1f4: 7f 05 c3 78 mr r5,r24
ffc0f1f8: 7f e4 fb 78 mr r4,r31
ffc0f1fc: 7f 46 d3 78 mr r6,r26
ffc0f200: 48 00 b0 e9 bl ffc1a2e8 <__divdi3>
if ( start_offset ) {
ffc0f204: 2f 99 00 00 cmpwi cr7,r25,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;
ffc0f208: 7c 98 23 78 mr r24,r4
unsigned int last_byte;
unsigned int copied;
unsigned int start_offset;
unsigned char *dest;
dest = destination;
ffc0f20c: 7f 9f e3 78 mr r31,r28
*/
last_byte = start + length;
if ( last_byte > the_jnode->info.file.size )
my_length = the_jnode->info.file.size - start;
copied = 0;
ffc0f210: 3b c0 00 00 li r30,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 ) {
ffc0f214: 41 9e 00 4c beq- cr7,ffc0f260 <IMFS_memfile_read+0x158>
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 );
ffc0f218: 7f a3 eb 78 mr r3,r29
ffc0f21c: 38 a0 00 00 li r5,0
ffc0f220: 4b ff fd 15 bl ffc0ef34 <IMFS_memfile_get_block_pointer>
if ( !block_ptr )
ffc0f224: 2c 03 00 00 cmpwi r3,0
ffc0f228: 41 82 00 d0 beq- ffc0f2f8 <IMFS_memfile_read+0x1f0> <== 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;
ffc0f22c: 7f 59 d0 50 subf r26,r25,r26
ffc0f230: 7f 9b d0 40 cmplw cr7,r27,r26
ffc0f234: 7f 7e db 78 mr r30,r27
ffc0f238: 40 9d 00 08 ble- cr7,ffc0f240 <IMFS_memfile_read+0x138>
ffc0f23c: 7f 5e d3 78 mr r30,r26
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 );
ffc0f240: 80 83 00 00 lwz r4,0(r3)
ffc0f244: 7f c5 f3 78 mr r5,r30
ffc0f248: 7f 83 e3 78 mr r3,r28
ffc0f24c: 7c 84 ca 14 add r4,r4,r25
ffc0f250: 48 00 26 a1 bl ffc118f0 <memcpy>
dest += to_copy;
ffc0f254: 7f fc f2 14 add r31,r28,r30
block++;
ffc0f258: 3b 18 00 01 addi r24,r24,1
my_length -= to_copy;
ffc0f25c: 7f 7e d8 50 subf r27,r30,r27
}
/*
* Phase 2: all of zero of more blocks
*/
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;
ffc0f260: 3f 40 00 00 lis r26,0
ffc0f264: 83 9a 27 e8 lwz r28,10216(r26)
while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {
ffc0f268: 48 00 00 3c b ffc0f2a4 <IMFS_memfile_read+0x19c>
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
ffc0f26c: 7f a3 eb 78 mr r3,r29
ffc0f270: 7f 04 c3 78 mr r4,r24
ffc0f274: 38 a0 00 00 li r5,0
ffc0f278: 4b ff fc bd bl ffc0ef34 <IMFS_memfile_get_block_pointer>
if ( !block_ptr )
ffc0f27c: 7c 69 1b 79 mr. r9,r3
ffc0f280: 41 82 00 78 beq- ffc0f2f8 <IMFS_memfile_read+0x1f0> <== NEVER TAKEN
return copied;
memcpy( dest, &(*block_ptr)[ 0 ], to_copy );
ffc0f284: 80 89 00 00 lwz r4,0(r9)
ffc0f288: 7f e3 fb 78 mr r3,r31
ffc0f28c: 7f 85 e3 78 mr r5,r28
ffc0f290: 48 00 26 61 bl ffc118f0 <memcpy>
dest += to_copy;
ffc0f294: 7f ff e2 14 add r31,r31,r28
block++;
ffc0f298: 3b 18 00 01 addi r24,r24,1
my_length -= to_copy;
ffc0f29c: 7f 7c d8 50 subf r27,r28,r27
copied += to_copy;
ffc0f2a0: 7f de e2 14 add r30,r30,r28
/*
* Phase 2: all of zero of more blocks
*/
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;
while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {
ffc0f2a4: 80 1a 27 e8 lwz r0,10216(r26)
ffc0f2a8: 7f 9b 00 40 cmplw cr7,r27,r0
ffc0f2ac: 40 9c ff c0 bge+ cr7,ffc0f26c <IMFS_memfile_read+0x164>
/*
* Phase 3: possibly the first part of one block
*/
IMFS_assert( my_length < IMFS_MEMFILE_BYTES_PER_BLOCK );
if ( my_length ) {
ffc0f2b0: 2f 9b 00 00 cmpwi cr7,r27,0
ffc0f2b4: 41 9e 00 30 beq- cr7,ffc0f2e4 <IMFS_memfile_read+0x1dc>
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
ffc0f2b8: 7f a3 eb 78 mr r3,r29
ffc0f2bc: 7f 04 c3 78 mr r4,r24
ffc0f2c0: 38 a0 00 00 li r5,0
ffc0f2c4: 4b ff fc 71 bl ffc0ef34 <IMFS_memfile_get_block_pointer>
if ( !block_ptr )
ffc0f2c8: 7c 69 1b 79 mr. r9,r3
ffc0f2cc: 41 82 00 2c beq- ffc0f2f8 <IMFS_memfile_read+0x1f0> <== NEVER TAKEN
return copied;
memcpy( dest, &(*block_ptr)[ 0 ], my_length );
ffc0f2d0: 80 89 00 00 lwz r4,0(r9)
ffc0f2d4: 7f e3 fb 78 mr r3,r31
ffc0f2d8: 7f 65 db 78 mr r5,r27
ffc0f2dc: 48 00 26 15 bl ffc118f0 <memcpy>
copied += my_length;
ffc0f2e0: 7f db f2 14 add r30,r27,r30
}
IMFS_update_atime( the_jnode );
ffc0f2e4: 38 61 00 08 addi r3,r1,8
ffc0f2e8: 38 80 00 00 li r4,0
ffc0f2ec: 4b ff 57 25 bl ffc04a10 <gettimeofday>
ffc0f2f0: 80 01 00 08 lwz r0,8(r1)
ffc0f2f4: 90 1d 00 40 stw r0,64(r29)
return copied;
}
ffc0f2f8: 39 61 00 38 addi r11,r1,56
ffc0f2fc: 7f c3 f3 78 mr r3,r30
ffc0f300: 4b ff 12 28 b ffc00528 <_restgpr_24_x>
ffc0f408 <IMFS_memfile_remove>:
* is better to stick to simple, easy to understand algorithms.
*/
int IMFS_memfile_remove(
IMFS_jnode_t *the_jnode
)
{
ffc0f408: 94 21 ff d8 stwu r1,-40(r1)
ffc0f40c: 7c 08 02 a6 mflr r0
/*
* 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;
ffc0f410: 3d 20 00 00 lis r9,0
* is better to stick to simple, easy to understand algorithms.
*/
int IMFS_memfile_remove(
IMFS_jnode_t *the_jnode
)
{
ffc0f414: 90 01 00 2c stw r0,44(r1)
* + doubly indirect
* + triply indirect
*/
info = &the_jnode->info.file;
if ( info->indirect ) {
ffc0f418: 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
)
{
ffc0f41c: bf 21 00 0c stmw r25,12(r1)
ffc0f420: 7c 7f 1b 78 mr r31,r3
* + doubly indirect
* + triply indirect
*/
info = &the_jnode->info.file;
if ( info->indirect ) {
ffc0f424: 2f 80 00 00 cmpwi cr7,r0,0
/*
* 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;
ffc0f428: 83 c9 27 e8 lwz r30,10216(r9)
ffc0f42c: 57 de f0 be rlwinm r30,r30,30,2,31
* + doubly indirect
* + triply indirect
*/
info = &the_jnode->info.file;
if ( info->indirect ) {
ffc0f430: 41 9e 00 10 beq- cr7,ffc0f440 <IMFS_memfile_remove+0x38>
memfile_free_blocks_in_table( &info->indirect, to_free );
ffc0f434: 38 63 00 58 addi r3,r3,88
ffc0f438: 7f c4 f3 78 mr r4,r30
ffc0f43c: 4b ff ff 69 bl ffc0f3a4 <memfile_free_blocks_in_table>
}
if ( info->doubly_indirect ) {
ffc0f440: 80 1f 00 5c lwz r0,92(r31)
ffc0f444: 3b a0 00 00 li r29,0
for ( i=0 ; i<IMFS_MEMFILE_BLOCK_SLOTS ; i++ ) {
ffc0f448: 3f 80 00 00 lis r28,0
if ( info->indirect ) {
memfile_free_blocks_in_table( &info->indirect, to_free );
}
if ( info->doubly_indirect ) {
ffc0f44c: 2f 80 00 00 cmpwi cr7,r0,0
ffc0f450: 40 be 00 2c bne+ cr7,ffc0f47c <IMFS_memfile_remove+0x74>
ffc0f454: 48 00 00 44 b ffc0f498 <IMFS_memfile_remove+0x90>
for ( i=0 ; i<IMFS_MEMFILE_BLOCK_SLOTS ; i++ ) {
if ( info->doubly_indirect[i] ) {
ffc0f458: 81 3f 00 5c lwz r9,92(r31)
* 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(
ffc0f45c: 57 a0 10 3a rlwinm r0,r29,2,0,29
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] ) {
ffc0f460: 7c 69 02 14 add r3,r9,r0
ffc0f464: 7c 09 00 2e lwzx r0,r9,r0
ffc0f468: 2f 80 00 00 cmpwi cr7,r0,0
ffc0f46c: 41 9e 00 0c beq- cr7,ffc0f478 <IMFS_memfile_remove+0x70><== NEVER TAKEN
memfile_free_blocks_in_table(
ffc0f470: 7f c4 f3 78 mr r4,r30
ffc0f474: 4b ff ff 31 bl ffc0f3a4 <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++ ) {
ffc0f478: 3b bd 00 01 addi r29,r29,1
ffc0f47c: 80 1c 27 e8 lwz r0,10216(r28)
ffc0f480: 54 00 f0 be rlwinm r0,r0,30,2,31
ffc0f484: 7f 9d 00 40 cmplw cr7,r29,r0
ffc0f488: 41 9c ff d0 blt+ cr7,ffc0f458 <IMFS_memfile_remove+0x50>
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 );
ffc0f48c: 38 7f 00 5c addi r3,r31,92
ffc0f490: 7f c4 f3 78 mr r4,r30
ffc0f494: 4b ff ff 11 bl ffc0f3a4 <memfile_free_blocks_in_table>
}
if ( info->triply_indirect ) {
ffc0f498: 80 1f 00 60 lwz r0,96(r31)
ffc0f49c: 3b a0 00 00 li r29,0
for ( i=0 ; i<IMFS_MEMFILE_BLOCK_SLOTS ; i++ ) {
ffc0f4a0: 3f 40 00 00 lis r26,0
}
memfile_free_blocks_in_table( &info->doubly_indirect, to_free );
}
if ( info->triply_indirect ) {
ffc0f4a4: 2f 80 00 00 cmpwi cr7,r0,0
ffc0f4a8: 40 be 00 68 bne+ cr7,ffc0f510 <IMFS_memfile_remove+0x108>
ffc0f4ac: 48 00 00 80 b ffc0f52c <IMFS_memfile_remove+0x124>
for ( i=0 ; i<IMFS_MEMFILE_BLOCK_SLOTS ; i++ ) {
p = (block_p *) info->triply_indirect[i];
ffc0f4b0: 81 3f 00 60 lwz r9,96(r31)
* 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(
ffc0f4b4: 57 b9 10 3a rlwinm r25,r29,2,0,29
}
if ( info->triply_indirect ) {
for ( i=0 ; i<IMFS_MEMFILE_BLOCK_SLOTS ; i++ ) {
p = (block_p *) info->triply_indirect[i];
ffc0f4b8: 7f 89 c8 2e lwzx r28,r9,r25
if ( !p ) /* ensure we have a valid pointer */
ffc0f4bc: 2f 9c 00 00 cmpwi cr7,r28,0
ffc0f4c0: 41 9e 00 60 beq- cr7,ffc0f520 <IMFS_memfile_remove+0x118><== NEVER TAKEN
ffc0f4c4: 3b 60 00 00 li r27,0
ffc0f4c8: 48 00 00 24 b ffc0f4ec <IMFS_memfile_remove+0xe4>
break;
for ( j=0 ; j<IMFS_MEMFILE_BLOCK_SLOTS ; j++ ) {
if ( p[j] ) {
ffc0f4cc: 80 1c 00 00 lwz r0,0(r28)
ffc0f4d0: 2f 80 00 00 cmpwi cr7,r0,0
ffc0f4d4: 41 9e 00 10 beq- cr7,ffc0f4e4 <IMFS_memfile_remove+0xdc><== NEVER TAKEN
memfile_free_blocks_in_table( (block_p **)&p[j], to_free);
ffc0f4d8: 7f 83 e3 78 mr r3,r28
ffc0f4dc: 7f c4 f3 78 mr r4,r30
ffc0f4e0: 4b ff fe c5 bl ffc0f3a4 <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++ ) {
ffc0f4e4: 3b 7b 00 01 addi r27,r27,1
ffc0f4e8: 3b 9c 00 04 addi r28,r28,4
ffc0f4ec: 80 1a 27 e8 lwz r0,10216(r26)
ffc0f4f0: 54 00 f0 be rlwinm r0,r0,30,2,31
ffc0f4f4: 7f 9b 00 40 cmplw cr7,r27,r0
ffc0f4f8: 41 9c ff d4 blt+ cr7,ffc0f4cc <IMFS_memfile_remove+0xc4>
if ( p[j] ) {
memfile_free_blocks_in_table( (block_p **)&p[j], to_free);
}
}
memfile_free_blocks_in_table(
ffc0f4fc: 80 7f 00 60 lwz r3,96(r31)
ffc0f500: 7f c4 f3 78 mr r4,r30
memfile_free_blocks_in_table( &info->doubly_indirect, to_free );
}
if ( info->triply_indirect ) {
for ( i=0 ; i<IMFS_MEMFILE_BLOCK_SLOTS ; i++ ) {
ffc0f504: 3b bd 00 01 addi r29,r29,1
for ( j=0 ; j<IMFS_MEMFILE_BLOCK_SLOTS ; j++ ) {
if ( p[j] ) {
memfile_free_blocks_in_table( (block_p **)&p[j], to_free);
}
}
memfile_free_blocks_in_table(
ffc0f508: 7c 63 ca 14 add r3,r3,r25
ffc0f50c: 4b ff fe 99 bl ffc0f3a4 <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++ ) {
ffc0f510: 80 1a 27 e8 lwz r0,10216(r26)
ffc0f514: 54 00 f0 be rlwinm r0,r0,30,2,31
ffc0f518: 7f 9d 00 40 cmplw cr7,r29,r0
ffc0f51c: 41 9c ff 94 blt+ cr7,ffc0f4b0 <IMFS_memfile_remove+0xa8>
}
}
memfile_free_blocks_in_table(
(block_p **)&info->triply_indirect[i], to_free );
}
memfile_free_blocks_in_table(
ffc0f520: 38 7f 00 60 addi r3,r31,96
ffc0f524: 7f c4 f3 78 mr r4,r30
ffc0f528: 4b ff fe 7d bl ffc0f3a4 <memfile_free_blocks_in_table>
(block_p **)&info->triply_indirect, to_free );
}
return 0;
}
ffc0f52c: 39 61 00 28 addi r11,r1,40
ffc0f530: 38 60 00 00 li r3,0
ffc0f534: 4b ff 0f f8 b ffc0052c <_restgpr_25_x>
ffc0f6bc <IMFS_memfile_write>:
IMFS_jnode_t *the_jnode,
off_t start,
const unsigned char *source,
unsigned int length
)
{
ffc0f6bc: 94 21 ff c8 stwu r1,-56(r1)
ffc0f6c0: 7c 08 02 a6 mflr r0
ffc0f6c4: bf 01 00 18 stmw r24,24(r1)
ffc0f6c8: 7c de 33 78 mr r30,r6
ffc0f6cc: 7c 7f 1b 78 mr r31,r3
ffc0f6d0: 90 01 00 3c stw r0,60(r1)
ffc0f6d4: 7c bd 2b 78 mr r29,r5
ffc0f6d8: 7c fc 3b 78 mr r28,r7
* 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 ) {
ffc0f6dc: 80 03 00 50 lwz r0,80(r3)
IMFS_jnode_t *the_jnode,
off_t start,
const unsigned char *source,
unsigned int length
)
{
ffc0f6e0: 7d 1b 43 78 mr r27,r8
/*
* 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;
ffc0f6e4: 7c c8 32 14 add r6,r8,r6
if ( last_byte > the_jnode->info.file.size ) {
ffc0f6e8: 2f 80 00 00 cmpwi cr7,r0,0
ffc0f6ec: 41 9c 00 14 blt- cr7,ffc0f700 <IMFS_memfile_write+0x44> <== NEVER TAKEN
ffc0f6f0: 40 be 00 38 bne+ cr7,ffc0f728 <IMFS_memfile_write+0x6c> <== NEVER TAKEN
ffc0f6f4: 80 03 00 54 lwz r0,84(r3)
ffc0f6f8: 7f 80 30 40 cmplw cr7,r0,r6
ffc0f6fc: 40 bc 00 2c bge+ cr7,ffc0f728 <IMFS_memfile_write+0x6c>
status = IMFS_memfile_extend( the_jnode, last_byte );
ffc0f700: 7f e3 fb 78 mr r3,r31
ffc0f704: 38 a0 00 00 li r5,0
ffc0f708: 4b ff fe 6d bl ffc0f574 <IMFS_memfile_extend>
if ( status )
ffc0f70c: 2f 83 00 00 cmpwi cr7,r3,0
ffc0f710: 41 be 00 18 beq+ cr7,ffc0f728 <IMFS_memfile_write+0x6c>
rtems_set_errno_and_return_minus_one( ENOSPC );
ffc0f714: 48 00 14 a1 bl ffc10bb4 <__errno>
ffc0f718: 38 00 00 1c li r0,28
ffc0f71c: 90 03 00 00 stw r0,0(r3)
ffc0f720: 3b c0 ff ff li r30,-1
ffc0f724: 48 00 01 30 b ffc0f854 <IMFS_memfile_write+0x198>
*/
/*
* Phase 1: possibly the last part of one block
*/
start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;
ffc0f728: 3d 20 00 00 lis r9,0
ffc0f72c: 83 49 27 e8 lwz r26,10216(r9)
ffc0f730: 7f a3 eb 78 mr r3,r29
ffc0f734: 7f c4 f3 78 mr r4,r30
ffc0f738: 7f 58 fe 70 srawi r24,r26,31
ffc0f73c: 7f 05 c3 78 mr r5,r24
ffc0f740: 7f 46 d3 78 mr r6,r26
ffc0f744: 48 00 af e5 bl ffc1a728 <__moddi3>
block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;
ffc0f748: 7f a3 eb 78 mr r3,r29
*/
/*
* Phase 1: possibly the last part of one block
*/
start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;
ffc0f74c: 7c 99 23 78 mr r25,r4
block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;
ffc0f750: 7f 05 c3 78 mr r5,r24
ffc0f754: 7f c4 f3 78 mr r4,r30
ffc0f758: 7f 46 d3 78 mr r6,r26
ffc0f75c: 48 00 ab 8d bl ffc1a2e8 <__divdi3>
if ( start_offset ) {
ffc0f760: 2f 99 00 00 cmpwi cr7,r25,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;
ffc0f764: 7c 9d 23 78 mr r29,r4
status = IMFS_memfile_extend( the_jnode, last_byte );
if ( status )
rtems_set_errno_and_return_minus_one( ENOSPC );
}
copied = 0;
ffc0f768: 3b c0 00 00 li r30,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 ) {
ffc0f76c: 41 9e 00 4c beq- cr7,ffc0f7b8 <IMFS_memfile_write+0xfc>
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 );
ffc0f770: 7f e3 fb 78 mr r3,r31
ffc0f774: 38 a0 00 00 li r5,0
ffc0f778: 4b ff f7 bd bl ffc0ef34 <IMFS_memfile_get_block_pointer>
if ( !block_ptr )
return copied;
ffc0f77c: 3b c0 00 00 li r30,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 )
ffc0f780: 2c 03 00 00 cmpwi r3,0
ffc0f784: 41 82 00 d0 beq- ffc0f854 <IMFS_memfile_write+0x198> <== 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;
ffc0f788: 7f d9 d0 50 subf r30,r25,r26
ffc0f78c: 7f 9e d8 40 cmplw cr7,r30,r27
ffc0f790: 40 9d 00 08 ble- cr7,ffc0f798 <IMFS_memfile_write+0xdc>
ffc0f794: 7f 7e db 78 mr r30,r27
block,
to_copy,
src
);
#endif
memcpy( &(*block_ptr)[ start_offset ], src, to_copy );
ffc0f798: 80 63 00 00 lwz r3,0(r3)
ffc0f79c: 7f 84 e3 78 mr r4,r28
ffc0f7a0: 7f c5 f3 78 mr r5,r30
ffc0f7a4: 7c 63 ca 14 add r3,r3,r25
ffc0f7a8: 48 00 21 49 bl ffc118f0 <memcpy>
src += to_copy;
ffc0f7ac: 7f 9c f2 14 add r28,r28,r30
block++;
ffc0f7b0: 3b bd 00 01 addi r29,r29,1
my_length -= to_copy;
ffc0f7b4: 7f 7e d8 50 subf r27,r30,r27
/*
* Phase 2: all of zero of more blocks
*/
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;
ffc0f7b8: 3f 20 00 00 lis r25,0
ffc0f7bc: 83 59 27 e8 lwz r26,10216(r25)
while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {
ffc0f7c0: 48 00 00 3c b ffc0f7fc <IMFS_memfile_write+0x140>
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
ffc0f7c4: 7f e3 fb 78 mr r3,r31
ffc0f7c8: 7f a4 eb 78 mr r4,r29
ffc0f7cc: 38 a0 00 00 li r5,0
ffc0f7d0: 4b ff f7 65 bl ffc0ef34 <IMFS_memfile_get_block_pointer>
if ( !block_ptr )
ffc0f7d4: 2c 03 00 00 cmpwi r3,0
ffc0f7d8: 41 82 00 7c beq- ffc0f854 <IMFS_memfile_write+0x198> <== NEVER TAKEN
return copied;
#if 0
fprintf(stdout, "write %d in %d: %*s\n", to_copy, block, to_copy, src );
#endif
memcpy( &(*block_ptr)[ 0 ], src, to_copy );
ffc0f7dc: 80 63 00 00 lwz r3,0(r3)
ffc0f7e0: 7f 84 e3 78 mr r4,r28
ffc0f7e4: 7f 45 d3 78 mr r5,r26
ffc0f7e8: 48 00 21 09 bl ffc118f0 <memcpy>
src += to_copy;
ffc0f7ec: 7f 9c d2 14 add r28,r28,r26
block++;
ffc0f7f0: 3b bd 00 01 addi r29,r29,1
my_length -= to_copy;
ffc0f7f4: 7f 7a d8 50 subf r27,r26,r27
* 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(
ffc0f7f8: 7f de d2 14 add r30,r30,r26
/*
* Phase 2: all of zero of more blocks
*/
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;
while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {
ffc0f7fc: 80 19 27 e8 lwz r0,10216(r25)
ffc0f800: 7f 9b 00 40 cmplw cr7,r27,r0
ffc0f804: 40 9c ff c0 bge+ cr7,ffc0f7c4 <IMFS_memfile_write+0x108>
* 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 ) {
ffc0f808: 2f 9b 00 00 cmpwi cr7,r27,0
ffc0f80c: 41 9e 00 30 beq- cr7,ffc0f83c <IMFS_memfile_write+0x180>
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
ffc0f810: 7f e3 fb 78 mr r3,r31
ffc0f814: 7f a4 eb 78 mr r4,r29
ffc0f818: 38 a0 00 00 li r5,0
ffc0f81c: 4b ff f7 19 bl ffc0ef34 <IMFS_memfile_get_block_pointer>
if ( !block_ptr )
ffc0f820: 2c 03 00 00 cmpwi r3,0
ffc0f824: 41 82 00 30 beq- ffc0f854 <IMFS_memfile_write+0x198> <== 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 );
ffc0f828: 80 63 00 00 lwz r3,0(r3)
ffc0f82c: 7f 84 e3 78 mr r4,r28
ffc0f830: 7f 65 db 78 mr r5,r27
ffc0f834: 48 00 20 bd bl ffc118f0 <memcpy>
my_length = 0;
copied += to_copy;
ffc0f838: 7f de da 14 add r30,r30,r27
}
IMFS_mtime_ctime_update( the_jnode );
ffc0f83c: 38 61 00 08 addi r3,r1,8
ffc0f840: 38 80 00 00 li r4,0
ffc0f844: 4b ff 51 cd bl ffc04a10 <gettimeofday>
ffc0f848: 80 01 00 08 lwz r0,8(r1)
ffc0f84c: 90 1f 00 44 stw r0,68(r31)
ffc0f850: 90 1f 00 48 stw r0,72(r31)
return copied;
}
ffc0f854: 39 61 00 38 addi r11,r1,56
ffc0f858: 7f c3 f3 78 mr r3,r30
ffc0f85c: 4b ff 0c cc b ffc00528 <_restgpr_24_x>
ffc03efc <IMFS_mount>:
#include <rtems/seterr.h>
int IMFS_mount(
rtems_filesystem_mount_table_entry_t *mt_entry
)
{
ffc03efc: 7c 08 02 a6 mflr r0
ffc03f00: 94 21 ff f8 stwu r1,-8(r1)
ffc03f04: 90 01 00 0c stw r0,12(r1)
IMFS_jnode_t *node;
node = mt_entry->mt_point_node.node_access;
ffc03f08: 81 23 00 08 lwz r9,8(r3)
/*
* Is the node that we are mounting onto a directory node ?
*/
if ( node->type != IMFS_DIRECTORY )
ffc03f0c: 80 09 00 4c lwz r0,76(r9)
ffc03f10: 2f 80 00 01 cmpwi cr7,r0,1
ffc03f14: 41 be 00 18 beq+ cr7,ffc03f2c <IMFS_mount+0x30> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( ENOTDIR );
ffc03f18: 48 00 cc 9d bl ffc10bb4 <__errno> <== NOT EXECUTED
ffc03f1c: 38 00 00 14 li r0,20 <== NOT EXECUTED
ffc03f20: 90 03 00 00 stw r0,0(r3) <== NOT EXECUTED
ffc03f24: 38 60 ff ff li r3,-1 <== NOT EXECUTED
ffc03f28: 48 00 00 0c b ffc03f34 <IMFS_mount+0x38> <== NOT EXECUTED
/*
* Set mt_fs pointer to point to the mount table entry for
* the mounted file system.
*/
node->info.directory.mt_fs = mt_entry;
ffc03f2c: 90 69 00 5c stw r3,92(r9)
return 0;
ffc03f30: 38 60 00 00 li r3,0
}
ffc03f34: 80 01 00 0c lwz r0,12(r1)
ffc03f38: 38 21 00 08 addi r1,r1,8
ffc03f3c: 7c 08 03 a6 mtlr r0
ffc03f40: 4e 80 00 20 blr
ffc06c08 <IMFS_print_jnode>:
* This routine prints the contents of the specified jnode.
*/
void IMFS_print_jnode(
IMFS_jnode_t *the_jnode
)
{
ffc06c08: 94 21 ff f0 stwu r1,-16(r1)
ffc06c0c: 7c 08 02 a6 mflr r0
ffc06c10: bf c1 00 08 stmw r30,8(r1)
IMFS_assert( the_jnode );
fprintf(stdout, "%s", the_jnode->name );
ffc06c14: 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
)
{
ffc06c18: 7c 7f 1b 78 mr r31,r3
ffc06c1c: 90 01 00 14 stw r0,20(r1)
IMFS_assert( the_jnode );
fprintf(stdout, "%s", the_jnode->name );
ffc06c20: 38 63 00 0c addi r3,r3,12
ffc06c24: 81 3e 27 d4 lwz r9,10196(r30)
ffc06c28: 80 89 00 08 lwz r4,8(r9)
ffc06c2c: 48 00 f0 f9 bl ffc15d24 <fputs>
switch( the_jnode->type ) {
ffc06c30: 80 bf 00 4c lwz r5,76(r31)
ffc06c34: 38 05 ff ff addi r0,r5,-1
ffc06c38: 2b 80 00 06 cmplwi cr7,r0,6
ffc06c3c: 41 9d 00 a8 bgt- cr7,ffc06ce4 <IMFS_print_jnode+0xdc> <== NEVER TAKEN
ffc06c40: 3d 20 ff c2 lis r9,-62
ffc06c44: 39 29 52 0c addi r9,r9,21004
ffc06c48: 54 00 10 3a rlwinm r0,r0,2,0,29
ffc06c4c: 7c 09 00 2e lwzx r0,r9,r0
ffc06c50: 7d 20 4a 14 add r9,r0,r9
ffc06c54: 7d 29 03 a6 mtctr r9
case IMFS_SYM_LINK:
fprintf(stdout, " links not printed\n" );
return;
case IMFS_FIFO:
fprintf(stdout, " FIFO not printed\n" );
ffc06c58: 81 3e 27 d4 lwz r9,10196(r30)
)
{
IMFS_assert( the_jnode );
fprintf(stdout, "%s", the_jnode->name );
switch( the_jnode->type ) {
ffc06c5c: 4e 80 04 20 bctr
case IMFS_DIRECTORY:
fprintf(stdout, "/" );
ffc06c60: 80 89 00 08 lwz r4,8(r9)
ffc06c64: 38 60 00 2f li r3,47
ffc06c68: 48 00 ef a1 bl ffc15c08 <fputc>
break;
ffc06c6c: 48 00 00 94 b ffc06d00 <IMFS_print_jnode+0xf8>
case IMFS_DEVICE:
fprintf(stdout, " (device %" PRId32 ", %" PRId32 ")",
ffc06c70: 3c 80 ff c2 lis r4,-62
ffc06c74: 80 69 00 08 lwz r3,8(r9)
ffc06c78: 38 84 52 28 addi r4,r4,21032
ffc06c7c: 80 bf 00 50 lwz r5,80(r31)
ffc06c80: 80 df 00 54 lwz r6,84(r31)
ffc06c84: 48 00 00 18 b ffc06c9c <IMFS_print_jnode+0x94>
the_jnode->info.device.major, the_jnode->info.device.minor );
break;
case IMFS_LINEAR_FILE:
fprintf(stdout, " (file %" PRId32 " %p)",
ffc06c88: 3c 80 ff c2 lis r4,-62
ffc06c8c: 80 69 00 08 lwz r3,8(r9)
ffc06c90: 80 bf 00 54 lwz r5,84(r31)
ffc06c94: 38 84 52 3b addi r4,r4,21051
ffc06c98: 80 df 00 58 lwz r6,88(r31)
ffc06c9c: 4c c6 31 82 crclr 4*cr1+eq
ffc06ca0: 48 00 ee 81 bl ffc15b20 <fprintf>
(uint32_t)the_jnode->info.linearfile.size,
the_jnode->info.linearfile.direct
);
break;
ffc06ca4: 48 00 00 5c b ffc06d00 <IMFS_print_jnode+0xf8>
the_jnode->info.file.indirect,
the_jnode->info.file.doubly_indirect,
the_jnode->info.file.triply_indirect
);
#else
fprintf(stdout, " (file %" PRId32 ")",
ffc06ca8: 80 69 00 08 lwz r3,8(r9)
ffc06cac: 3c 80 ff c2 lis r4,-62
ffc06cb0: 80 bf 00 54 lwz r5,84(r31)
ffc06cb4: 38 84 52 4a addi r4,r4,21066
ffc06cb8: 4c c6 31 82 crclr 4*cr1+eq
ffc06cbc: 48 00 ee 65 bl ffc15b20 <fprintf>
(uint32_t)the_jnode->info.file.size );
#endif
break;
ffc06cc0: 48 00 00 40 b ffc06d00 <IMFS_print_jnode+0xf8>
case IMFS_HARD_LINK:
fprintf(stdout, " links not printed\n" );
return;
case IMFS_SYM_LINK:
fprintf(stdout, " links not printed\n" );
ffc06cc4: 3c 60 ff c2 lis r3,-62
ffc06cc8: 38 63 52 56 addi r3,r3,21078
ffc06ccc: 48 00 00 0c b ffc06cd8 <IMFS_print_jnode+0xd0>
return;
case IMFS_FIFO:
fprintf(stdout, " FIFO not printed\n" );
ffc06cd0: 3c 60 ff c2 lis r3,-62
ffc06cd4: 38 63 52 6a addi r3,r3,21098
ffc06cd8: 80 89 00 08 lwz r4,8(r9)
ffc06cdc: 48 00 f0 49 bl ffc15d24 <fputs>
return;
ffc06ce0: 48 00 00 2c b ffc06d0c <IMFS_print_jnode+0x104>
default:
fprintf(stdout, " bad type %d\n", the_jnode->type );
ffc06ce4: 81 3e 27 d4 lwz r9,10196(r30) <== NOT EXECUTED
ffc06ce8: 3c 80 ff c2 lis r4,-62 <== NOT EXECUTED
ffc06cec: 38 84 52 7d addi r4,r4,21117 <== NOT EXECUTED
ffc06cf0: 80 69 00 08 lwz r3,8(r9) <== NOT EXECUTED
ffc06cf4: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc06cf8: 48 00 ee 29 bl ffc15b20 <fprintf> <== NOT EXECUTED
return;
ffc06cfc: 48 00 00 10 b ffc06d0c <IMFS_print_jnode+0x104> <== NOT EXECUTED
}
puts("");
ffc06d00: 3c 60 ff c2 lis r3,-62
ffc06d04: 38 63 59 17 addi r3,r3,22807
ffc06d08: 48 01 0f cd bl ffc17cd4 <puts>
}
ffc06d0c: 39 61 00 10 addi r11,r1,16
ffc06d10: 4b ff c8 20 b ffc03530 <_restgpr_30_x>
ffc03f84 <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 */
)
{
ffc03f84: 94 21 ff e0 stwu r1,-32(r1)
ffc03f88: 7c 08 02 a6 mflr r0
ffc03f8c: 90 01 00 24 stw r0,36(r1)
ffc03f90: bf c1 00 18 stmw r30,24(r1)
ffc03f94: 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 );
ffc03f98: 38 a0 00 20 li r5,32
)
{
IMFS_jnode_t *the_jnode;
IMFS_jnode_t *new_parent;
the_jnode = old_loc->node_access;
ffc03f9c: 83 e4 00 00 lwz r31,0(r4)
strncpy( the_jnode->name, new_name, IMFS_NAME_MAX );
ffc03fa0: 7c c4 33 78 mr r4,r6
ffc03fa4: 38 7f 00 0c addi r3,r31,12
ffc03fa8: 48 00 e5 f5 bl ffc1259c <strncpy>
if ( the_jnode->Parent != NULL )
ffc03fac: 80 1f 00 08 lwz r0,8(r31)
ffc03fb0: 2f 80 00 00 cmpwi cr7,r0,0
ffc03fb4: 41 9e 00 0c beq- cr7,ffc03fc0 <IMFS_rename+0x3c> <== NEVER TAKEN
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
ffc03fb8: 7f e3 fb 78 mr r3,r31
ffc03fbc: 48 00 4c bd bl ffc08c78 <_Chain_Extract>
rtems_chain_extract( (rtems_chain_node *) the_jnode );
new_parent = new_parent_loc->node_access;
ffc03fc0: 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 );
ffc03fc4: 7f e4 fb 78 mr r4,r31
the_jnode->Parent = new_parent;
ffc03fc8: 90 7f 00 08 stw r3,8(r31)
ffc03fcc: 38 63 00 50 addi r3,r3,80
ffc03fd0: 48 00 4c 79 bl ffc08c48 <_Chain_Append>
rtems_chain_append( &new_parent->info.directory.Entries, &the_jnode->Node );
/*
* Update the time.
*/
IMFS_update_ctime( the_jnode );
ffc03fd4: 38 61 00 08 addi r3,r1,8
ffc03fd8: 38 80 00 00 li r4,0
ffc03fdc: 48 00 0a 35 bl ffc04a10 <gettimeofday>
ffc03fe0: 80 01 00 08 lwz r0,8(r1)
return 0;
}
ffc03fe4: 39 61 00 20 addi r11,r1,32
ffc03fe8: 38 60 00 00 li r3,0
rtems_chain_append( &new_parent->info.directory.Entries, &the_jnode->Node );
/*
* Update the time.
*/
IMFS_update_ctime( the_jnode );
ffc03fec: 90 1f 00 48 stw r0,72(r31)
return 0;
}
ffc03ff0: 4b ff c5 50 b ffc00540 <_restgpr_30_x>
ffc0c1cc <IMFS_skip_separator>:
static void IMFS_skip_separator (
const char *path, /* IN */
size_t *len, /* IN/OUT */
int *index /* IN/OUT */
)
{
ffc0c1cc: 94 21 ff e8 stwu r1,-24(r1)
ffc0c1d0: 7c 08 02 a6 mflr r0
ffc0c1d4: bf a1 00 0c stmw r29,12(r1)
ffc0c1d8: 7c 7f 1b 78 mr r31,r3
ffc0c1dc: 7c 9e 23 78 mr r30,r4
ffc0c1e0: 90 01 00 1c stw r0,28(r1)
ffc0c1e4: 7c bd 2b 78 mr r29,r5
while ( IMFS_is_separator( path[*index] ) && path[*index] && *len ) {
ffc0c1e8: 48 00 00 18 b ffc0c200 <IMFS_skip_separator+0x34>
++(*index);
ffc0c1ec: 39 29 00 01 addi r9,r9,1
ffc0c1f0: 91 3d 00 00 stw r9,0(r29)
--(*len);
ffc0c1f4: 81 3e 00 00 lwz r9,0(r30)
ffc0c1f8: 38 09 ff ff addi r0,r9,-1
ffc0c1fc: 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 ) {
ffc0c200: 80 1d 00 00 lwz r0,0(r29)
ffc0c204: 7c 7f 00 ae lbzx r3,r31,r0
ffc0c208: 4b ff 97 6d bl ffc05974 <rtems_filesystem_is_separator>
ffc0c20c: 2f 83 00 00 cmpwi cr7,r3,0
ffc0c210: 41 9e 00 20 beq- cr7,ffc0c230 <IMFS_skip_separator+0x64>
ffc0c214: 81 3d 00 00 lwz r9,0(r29)
ffc0c218: 7c 1f 48 ae lbzx r0,r31,r9
ffc0c21c: 2f 80 00 00 cmpwi cr7,r0,0
ffc0c220: 41 9e 00 10 beq- cr7,ffc0c230 <IMFS_skip_separator+0x64>
ffc0c224: 80 1e 00 00 lwz r0,0(r30)
ffc0c228: 2f 80 00 00 cmpwi cr7,r0,0
ffc0c22c: 40 9e ff c0 bne+ cr7,ffc0c1ec <IMFS_skip_separator+0x20><== ALWAYS TAKEN
++(*index);
--(*len);
}
}
ffc0c230: 39 61 00 18 addi r11,r1,24
ffc0c234: 4b ff 43 08 b ffc0053c <_restgpr_29_x>
ffc0cde4 <IMFS_stat>:
int IMFS_stat(
rtems_filesystem_location_info_t *loc,
struct stat *buf
)
{
ffc0cde4: 7c 08 02 a6 mflr r0
ffc0cde8: 94 21 ff f8 stwu r1,-8(r1)
ffc0cdec: 90 01 00 0c stw r0,12(r1)
IMFS_fs_info_t *fs_info;
IMFS_jnode_t *the_jnode;
IMFS_device_t *io;
the_jnode = loc->node_access;
ffc0cdf0: 81 23 00 00 lwz r9,0(r3)
switch ( the_jnode->type ) {
ffc0cdf4: 81 69 00 4c lwz r11,76(r9)
ffc0cdf8: 38 0b ff fe addi r0,r11,-2
ffc0cdfc: 2b 80 00 05 cmplwi cr7,r0,5
ffc0ce00: 41 9d 00 54 bgt- cr7,ffc0ce54 <IMFS_stat+0x70> <== NEVER TAKEN
ffc0ce04: 3d 60 ff c2 lis r11,-62
ffc0ce08: 39 6b da 28 addi r11,r11,-9688
ffc0ce0c: 54 00 10 3a rlwinm r0,r0,2,0,29
ffc0ce10: 7c 0b 00 2e lwzx r0,r11,r0
ffc0ce14: 7d 60 5a 14 add r11,r0,r11
ffc0ce18: 7d 69 03 a6 mtctr r11
ffc0ce1c: 4e 80 04 20 bctr
case IMFS_DEVICE:
io = &the_jnode->info.device;
buf->st_rdev = rtems_filesystem_make_dev_t( io->major, io->minor );
ffc0ce20: 80 09 00 54 lwz r0,84(r9)
rtems_device_minor_number _minor
)
{
union __rtems_dev_t temp;
temp.__overlay.major = _major;
ffc0ce24: 81 69 00 50 lwz r11,80(r9)
ffc0ce28: 90 04 00 1c stw r0,28(r4)
ffc0ce2c: 91 64 00 18 stw r11,24(r4)
break;
ffc0ce30: 48 00 00 38 b ffc0ce68 <IMFS_stat+0x84>
case IMFS_LINEAR_FILE:
case IMFS_MEMORY_FILE:
buf->st_size = the_jnode->info.file.size;
ffc0ce34: 81 49 00 50 lwz r10,80(r9)
ffc0ce38: 81 69 00 54 lwz r11,84(r9)
ffc0ce3c: 48 00 00 0c b ffc0ce48 <IMFS_stat+0x64>
case IMFS_SYM_LINK:
buf->st_size = 0;
break;
case IMFS_FIFO:
buf->st_size = 0;
ffc0ce40: 39 40 00 00 li r10,0
ffc0ce44: 39 60 00 00 li r11,0
ffc0ce48: 91 44 00 20 stw r10,32(r4)
ffc0ce4c: 91 64 00 24 stw r11,36(r4)
break;
ffc0ce50: 48 00 00 18 b ffc0ce68 <IMFS_stat+0x84>
default:
rtems_set_errno_and_return_minus_one( ENOTSUP );
ffc0ce54: 48 00 3d 61 bl ffc10bb4 <__errno>
ffc0ce58: 38 00 00 86 li r0,134
ffc0ce5c: 90 03 00 00 stw r0,0(r3)
ffc0ce60: 38 60 ff ff li r3,-1
ffc0ce64: 48 00 00 70 b ffc0ced4 <IMFS_stat+0xf0>
/*
* The device number of the IMFS is the major number and the minor is the
* instance.
*/
fs_info = loc->mt_entry->fs_info;
ffc0ce68: 81 63 00 10 lwz r11,16(r3)
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;
ffc0ce6c: 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 );
ffc0ce70: 81 6b 00 34 lwz r11,52(r11)
ffc0ce74: 80 0b 00 00 lwz r0,0(r11)
ffc0ce78: 39 60 00 00 li r11,0
ffc0ce7c: 61 6b ff fe ori r11,r11,65534
/*
* 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 =
ffc0ce80: 90 04 00 04 stw r0,4(r4)
rtems_filesystem_make_dev_t( IMFS_DEVICE_MAJOR_NUMBER, fs_info->instance );
buf->st_mode = the_jnode->st_mode;
ffc0ce84: 80 09 00 30 lwz r0,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 =
ffc0ce88: 91 64 00 00 stw r11,0(r4)
rtems_filesystem_make_dev_t( IMFS_DEVICE_MAJOR_NUMBER, fs_info->instance );
buf->st_mode = the_jnode->st_mode;
ffc0ce8c: 90 04 00 0c stw r0,12(r4)
buf->st_nlink = the_jnode->st_nlink;
ffc0ce90: a0 09 00 34 lhz r0,52(r9)
ffc0ce94: b0 04 00 10 sth r0,16(r4)
buf->st_ino = the_jnode->st_ino;
ffc0ce98: 80 09 00 38 lwz r0,56(r9)
ffc0ce9c: 90 04 00 08 stw r0,8(r4)
buf->st_uid = the_jnode->st_uid;
ffc0cea0: a0 09 00 3c lhz r0,60(r9)
ffc0cea4: b0 04 00 12 sth r0,18(r4)
buf->st_gid = the_jnode->st_gid;
ffc0cea8: a0 09 00 3e lhz r0,62(r9)
ffc0ceac: b0 04 00 14 sth r0,20(r4)
buf->st_atime = the_jnode->stat_atime;
ffc0ceb0: 80 09 00 40 lwz r0,64(r9)
ffc0ceb4: 90 04 00 28 stw r0,40(r4)
buf->st_mtime = the_jnode->stat_mtime;
ffc0ceb8: 80 09 00 44 lwz r0,68(r9)
ffc0cebc: 90 04 00 30 stw r0,48(r4)
buf->st_ctime = the_jnode->stat_ctime;
ffc0cec0: 80 09 00 48 lwz r0,72(r9)
buf->st_blksize = imfs_rq_memfile_bytes_per_block;
ffc0cec4: 3d 20 00 00 lis r9,0
buf->st_uid = the_jnode->st_uid;
buf->st_gid = the_jnode->st_gid;
buf->st_atime = the_jnode->stat_atime;
buf->st_mtime = the_jnode->stat_mtime;
buf->st_ctime = the_jnode->stat_ctime;
ffc0cec8: 90 04 00 38 stw r0,56(r4)
buf->st_blksize = imfs_rq_memfile_bytes_per_block;
ffc0cecc: 80 09 27 38 lwz r0,10040(r9)
ffc0ced0: 90 04 00 40 stw r0,64(r4)
return 0;
}
ffc0ced4: 80 01 00 0c lwz r0,12(r1)
ffc0ced8: 38 21 00 08 addi r1,r1,8
ffc0cedc: 7c 08 03 a6 mtlr r0
ffc0cee0: 4e 80 00 20 blr
ffc0408c <IMFS_unlink>:
int IMFS_unlink(
rtems_filesystem_location_info_t *parentloc, /* IN */
rtems_filesystem_location_info_t *loc /* IN */
)
{
ffc0408c: 94 21 ff c8 stwu r1,-56(r1)
ffc04090: 7c 08 02 a6 mflr r0
ffc04094: 90 01 00 3c stw r0,60(r1)
ffc04098: bf 81 00 28 stmw r28,40(r1)
ffc0409c: 7c 7d 1b 78 mr r29,r3
ffc040a0: 7c 9f 23 78 mr r31,r4
IMFS_jnode_t *node;
rtems_filesystem_location_info_t the_link;
int result = 0;
node = loc->node_access;
ffc040a4: 83 c4 00 00 lwz r30,0(r4)
/*
* If this is the last last pointer to the node
* free the node.
*/
if ( node->type == IMFS_HARD_LINK ) {
ffc040a8: 80 1e 00 4c lwz r0,76(r30)
ffc040ac: 2f 80 00 03 cmpwi cr7,r0,3
ffc040b0: 40 9e 00 94 bne- cr7,ffc04144 <IMFS_unlink+0xb8>
if ( !node->info.hard_link.link_node )
ffc040b4: 80 1e 00 50 lwz r0,80(r30)
ffc040b8: 2f 80 00 00 cmpwi cr7,r0,0
ffc040bc: 40 be 00 18 bne+ cr7,ffc040d4 <IMFS_unlink+0x48> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( EINVAL );
ffc040c0: 48 00 ca f5 bl ffc10bb4 <__errno> <== NOT EXECUTED
ffc040c4: 38 00 00 16 li r0,22 <== NOT EXECUTED
ffc040c8: 90 03 00 00 stw r0,0(r3) <== NOT EXECUTED
ffc040cc: 38 00 ff ff li r0,-1 <== NOT EXECUTED
ffc040d0: 48 00 00 90 b ffc04160 <IMFS_unlink+0xd4> <== NOT EXECUTED
the_link = *loc;
ffc040d4: 3b 81 00 10 addi r28,r1,16
the_link.node_access = node->info.hard_link.link_node;
IMFS_Set_handlers( &the_link );
ffc040d8: 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;
ffc040dc: 7c a4 a4 aa lswi r5,r4,20
ffc040e0: 7c bc a5 aa stswi r5,r28,20
the_link.node_access = node->info.hard_link.link_node;
ffc040e4: 90 01 00 10 stw r0,16(r1)
IMFS_Set_handlers( &the_link );
ffc040e8: 48 00 81 51 bl ffc0c238 <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)
ffc040ec: 81 3e 00 50 lwz r9,80(r30)
ffc040f0: a1 69 00 34 lhz r11,52(r9)
ffc040f4: 2f 8b 00 01 cmpwi cr7,r11,1
ffc040f8: 40 be 00 2c bne+ cr7,ffc04124 <IMFS_unlink+0x98>
{
result = (*the_link.handlers->rmnod_h)( parentloc, &the_link );
ffc040fc: 81 21 00 18 lwz r9,24(r1)
ffc04100: 7f a3 eb 78 mr r3,r29
ffc04104: 7f 84 e3 78 mr r4,r28
ffc04108: 80 09 00 34 lwz r0,52(r9)
ffc0410c: 7c 09 03 a6 mtctr r0
ffc04110: 4e 80 04 21 bctrl
if ( result != 0 )
return -1;
ffc04114: 38 00 ff ff li r0,-1
*/
if ( node->info.hard_link.link_node->st_nlink == 1)
{
result = (*the_link.handlers->rmnod_h)( parentloc, &the_link );
if ( result != 0 )
ffc04118: 2f 83 00 00 cmpwi cr7,r3,0
ffc0411c: 41 be 00 28 beq+ cr7,ffc04144 <IMFS_unlink+0xb8>
ffc04120: 48 00 00 40 b ffc04160 <IMFS_unlink+0xd4>
return -1;
}
else
{
node->info.hard_link.link_node->st_nlink --;
ffc04124: 39 6b ff ff addi r11,r11,-1
ffc04128: b1 69 00 34 sth r11,52(r9)
IMFS_update_ctime( node->info.hard_link.link_node );
ffc0412c: 38 61 00 08 addi r3,r1,8
ffc04130: 38 80 00 00 li r4,0
ffc04134: 48 00 08 dd bl ffc04a10 <gettimeofday>
ffc04138: 81 3e 00 50 lwz r9,80(r30)
ffc0413c: 80 01 00 08 lwz r0,8(r1)
ffc04140: 90 09 00 48 stw r0,72(r9)
/*
* Now actually free the node we were asked to free.
*/
result = (*loc->handlers->rmnod_h)( parentloc, loc );
ffc04144: 81 3f 00 08 lwz r9,8(r31)
ffc04148: 7f a3 eb 78 mr r3,r29
ffc0414c: 7f e4 fb 78 mr r4,r31
ffc04150: 80 09 00 34 lwz r0,52(r9)
ffc04154: 7c 09 03 a6 mtctr r0
ffc04158: 4e 80 04 21 bctrl
ffc0415c: 7c 60 1b 78 mr r0,r3
return result;
}
ffc04160: 39 61 00 38 addi r11,r1,56
ffc04164: 7c 03 03 78 mr r3,r0
ffc04168: 4b ff c3 d0 b ffc00538 <_restgpr_28_x>
ffc0416c <IMFS_unmount>:
#include <rtems/seterr.h>
int IMFS_unmount(
rtems_filesystem_mount_table_entry_t *mt_entry
)
{
ffc0416c: 7c 08 02 a6 mflr r0
ffc04170: 94 21 ff f8 stwu r1,-8(r1)
ffc04174: 90 01 00 0c stw r0,12(r1)
IMFS_jnode_t *node;
node = mt_entry->mt_point_node.node_access;
ffc04178: 81 23 00 08 lwz r9,8(r3)
/*
* Is the node that we are mounting onto a directory node ?
*/
if ( node->type != IMFS_DIRECTORY )
ffc0417c: 80 09 00 4c lwz r0,76(r9)
ffc04180: 2f 80 00 01 cmpwi cr7,r0,1
ffc04184: 41 be 00 10 beq+ cr7,ffc04194 <IMFS_unmount+0x28> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( ENOTDIR );
ffc04188: 48 00 ca 2d bl ffc10bb4 <__errno> <== NOT EXECUTED
ffc0418c: 38 00 00 14 li r0,20 <== NOT EXECUTED
ffc04190: 48 00 00 18 b ffc041a8 <IMFS_unmount+0x3c> <== NOT EXECUTED
/*
* Did the node indicate that there was a directory mounted here?
*/
if ( node->info.directory.mt_fs == NULL )
ffc04194: 80 09 00 5c lwz r0,92(r9)
ffc04198: 2f 80 00 00 cmpwi cr7,r0,0
ffc0419c: 40 be 00 18 bne+ cr7,ffc041b4 <IMFS_unmount+0x48> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( EINVAL ); /* XXX */
ffc041a0: 48 00 ca 15 bl ffc10bb4 <__errno> <== NOT EXECUTED
ffc041a4: 38 00 00 16 li r0,22 <== NOT EXECUTED
ffc041a8: 90 03 00 00 stw r0,0(r3) <== NOT EXECUTED
ffc041ac: 38 60 ff ff li r3,-1 <== NOT EXECUTED
ffc041b0: 48 00 00 10 b ffc041c0 <IMFS_unmount+0x54> <== NOT EXECUTED
/*
* Set the mt_fs pointer to indicate that there is no longer
* a file system mounted to this point.
*/
node->info.directory.mt_fs = NULL;
ffc041b4: 38 00 00 00 li r0,0
ffc041b8: 90 09 00 5c stw r0,92(r9)
return 0;
ffc041bc: 38 60 00 00 li r3,0
}
ffc041c0: 80 01 00 0c lwz r0,12(r1)
ffc041c4: 38 21 00 08 addi r1,r1,8
ffc041c8: 7c 08 03 a6 mtlr r0
ffc041cc: 4e 80 00 20 blr
ffc041dc <Stack_check_Dump_threads_usage>:
static rtems_printk_plugin_t print_handler;
void Stack_check_Dump_threads_usage(
Thread_Control *the_thread
)
{
ffc041dc: 94 21 ff c0 stwu r1,-64(r1)
ffc041e0: 7c 08 02 a6 mflr r0
ffc041e4: 90 01 00 44 stw r0,68(r1)
* match pattern
*/
base += PATTERN_SIZE_WORDS;
for (ebase = base + length; base < ebase; base++)
if (*base != U32_PATTERN)
ffc041e8: 3c 00 a5 a5 lis r0,-23131
ffc041ec: 60 00 a5 a5 ori r0,r0,42405
static rtems_printk_plugin_t print_handler;
void Stack_check_Dump_threads_usage(
Thread_Control *the_thread
)
{
ffc041f0: be e1 00 1c stmw r23,28(r1)
ffc041f4: 7c 7b 1b 78 mr r27,r3
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);
ffc041f8: 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);
ffc041fc: 81 63 00 bc lwz r11,188(r3)
size = Stack_check_usable_stack_size(stack);
ffc04200: 3b 9c ff 80 addi r28,r28,-128
current = 0;
} else
#endif
{
stack = &the_thread->Start.Initial_stack;
current = (void *)_CPU_Context_Get_SP( &the_thread->Registers );
ffc04204: 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;
ffc04208: 39 2b 01 00 addi r9,r11,256
for (ebase = base + length; base < ebase; base++)
ffc0420c: 57 8a 00 3a rlwinm r10,r28,0,0,29
ffc04210: 7d 49 52 14 add r10,r9,r10
ffc04214: 48 00 00 14 b ffc04228 <Stack_check_Dump_threads_usage+0x4c>
if (*base != U32_PATTERN)
ffc04218: 81 09 00 00 lwz r8,0(r9)
ffc0421c: 7f 88 00 00 cmpw cr7,r8,r0
ffc04220: 40 9e 00 18 bne- cr7,ffc04238 <Stack_check_Dump_threads_usage+0x5c>
* start at lower memory and find first word that does not
* match pattern
*/
base += PATTERN_SIZE_WORDS;
for (ebase = base + length; base < ebase; base++)
ffc04224: 39 29 00 04 addi r9,r9,4
ffc04228: 7f 89 50 40 cmplw cr7,r9,r10
ffc0422c: 41 9c ff ec blt+ cr7,ffc04218 <Stack_check_Dump_threads_usage+0x3c><== 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;
ffc04230: 3b a0 00 00 li r29,0 <== NOT EXECUTED
ffc04234: 48 00 00 1c b ffc04250 <Stack_check_Dump_threads_usage+0x74><== NOT EXECUTED
low = Stack_check_usable_stack_start(stack);
size = Stack_check_usable_stack_size(stack);
high_water_mark = Stack_check_find_high_water_mark(low, size);
if ( high_water_mark )
ffc04238: 2f 89 00 00 cmpwi cr7,r9,0
used = Stack_check_Calculate_used( low, size, high_water_mark );
else
used = 0;
ffc0423c: 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 )
ffc04240: 41 9e 00 10 beq- cr7,ffc04250 <Stack_check_Dump_threads_usage+0x74><== NEVER TAKEN
{
stack = &the_thread->Start.Initial_stack;
current = (void *)_CPU_Context_Get_SP( &the_thread->Registers );
}
low = Stack_check_usable_stack_start(stack);
ffc04244: 3b ab 00 80 addi r29,r11,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 );
ffc04248: 7f bd e2 14 add r29,r29,r28
ffc0424c: 7f a9 e8 50 subf r29,r9,r29
#if (CPU_ALLOCATE_INTERRUPT_STACK == TRUE)
if ( the_thread )
#endif
{
(*print_handler)(
ffc04250: 3f c0 00 00 lis r30,0
ffc04254: 83 1b 00 08 lwz r24,8(r27)
ffc04258: 3b fe 28 f4 addi r31,r30,10484
ffc0425c: 83 3e 28 f4 lwz r25,10484(r30)
ffc04260: 82 ff 00 04 lwz r23,4(r31)
ffc04264: 38 80 00 05 li r4,5
ffc04268: 38 a1 00 08 addi r5,r1,8
ffc0426c: 7f 03 c3 78 mr r3,r24
ffc04270: 48 00 63 49 bl ffc0a5b8 <rtems_object_get_name>
ffc04274: 3c 80 ff c2 lis r4,-62
ffc04278: 7c 66 1b 78 mr r6,r3
ffc0427c: 7f 29 03 a6 mtctr r25
ffc04280: 38 84 a0 d0 addi r4,r4,-24368
ffc04284: 7f 05 c3 78 mr r5,r24
ffc04288: 7e e3 bb 78 mr r3,r23
ffc0428c: 4c c6 31 82 crclr 4*cr1+eq
ffc04290: 4e 80 04 21 bctrl
(*print_handler)(
print_context,
" %010p - %010p %010p %8" PRId32 " ",
stack->area,
stack->area + stack->size - 1,
ffc04294: 80 db 00 b8 lwz r6,184(r27)
else {
(*print_handler)( print_context, "0x%08" PRIx32 " INTR", ~0 );
}
#endif
(*print_handler)(
ffc04298: 80 1e 28 f4 lwz r0,10484(r30)
ffc0429c: 3c 80 ff c2 lis r4,-62
print_context,
" %010p - %010p %010p %8" PRId32 " ",
stack->area,
stack->area + stack->size - 1,
ffc042a0: 80 bb 00 bc lwz r5,188(r27)
ffc042a4: 38 c6 ff ff addi r6,r6,-1
else {
(*print_handler)( print_context, "0x%08" PRIx32 " INTR", ~0 );
}
#endif
(*print_handler)(
ffc042a8: 7c 09 03 a6 mtctr r0
ffc042ac: 80 7f 00 04 lwz r3,4(r31)
ffc042b0: 38 84 a0 dd addi r4,r4,-24355
ffc042b4: 7c c5 32 14 add r6,r5,r6
ffc042b8: 7f 47 d3 78 mr r7,r26
ffc042bc: 7f 88 e3 78 mr r8,r28
ffc042c0: 4c c6 31 82 crclr 4*cr1+eq
ffc042c4: 4e 80 04 21 bctrl
stack->area + stack->size - 1,
current,
size
);
if (Stack_check_Initialized == 0) {
ffc042c8: 80 1f 00 08 lwz r0,8(r31)
(*print_handler)( print_context, "Unavailable\n" );
ffc042cc: 80 7f 00 04 lwz r3,4(r31)
stack->area + stack->size - 1,
current,
size
);
if (Stack_check_Initialized == 0) {
ffc042d0: 2f 80 00 00 cmpwi cr7,r0,0
(*print_handler)( print_context, "Unavailable\n" );
ffc042d4: 80 1e 28 f4 lwz r0,10484(r30)
stack->area + stack->size - 1,
current,
size
);
if (Stack_check_Initialized == 0) {
ffc042d8: 40 be 00 1c bne+ cr7,ffc042f4 <Stack_check_Dump_threads_usage+0x118><== ALWAYS TAKEN
(*print_handler)( print_context, "Unavailable\n" );
ffc042dc: 3c 80 ff c2 lis r4,-62 <== NOT EXECUTED
ffc042e0: 7c 09 03 a6 mtctr r0 <== NOT EXECUTED
ffc042e4: 38 84 a0 fb addi r4,r4,-24325 <== NOT EXECUTED
ffc042e8: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc042ec: 4e 80 04 21 bctrl <== NOT EXECUTED
ffc042f0: 48 00 00 1c b ffc0430c <Stack_check_Dump_threads_usage+0x130><== NOT EXECUTED
} else {
(*print_handler)( print_context, "%8" PRId32 "\n", used );
ffc042f4: 3c 80 ff c2 lis r4,-62
ffc042f8: 7c 09 03 a6 mtctr r0
ffc042fc: 38 84 a1 08 addi r4,r4,-24312
ffc04300: 7f a5 eb 78 mr r5,r29
ffc04304: 4c c6 31 82 crclr 4*cr1+eq
ffc04308: 4e 80 04 21 bctrl
}
}
ffc0430c: 39 61 00 40 addi r11,r1,64
ffc04310: 4b ff c7 d8 b ffc00ae8 <_restgpr_23_x>
ffc043e4 <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)
{
ffc043e4: 94 21 ff c8 stwu r1,-56(r1)
ffc043e8: 7c 08 02 a6 mflr r0
ffc043ec: 90 01 00 3c stw r0,60(r1)
ffc043f0: bf a1 00 2c stmw r29,44(r1)
ffc043f4: 7c 7d 1b 78 mr r29,r3
ffc043f8: 7c 9e 23 78 mr r30,r4
Stack_Control *stack = &running->Start.Initial_stack;
void *pattern_area = Stack_check_Get_pattern(stack);
ffc043fc: 83 e3 00 bc lwz r31,188(r3)
char name[32];
printk("BLOWN STACK!!!\n");
ffc04400: 3c 60 ff c2 lis r3,-62
ffc04404: 38 63 a1 0e addi r3,r3,-24306
ffc04408: 4c c6 31 82 crclr 4*cr1+eq
ffc0440c: 48 00 1f 71 bl ffc0637c <printk>
printk("task control block: 0x%08" PRIxPTR "\n", running);
ffc04410: 3c 60 ff c2 lis r3,-62
ffc04414: 38 63 a1 1e addi r3,r3,-24290
ffc04418: 7f a4 eb 78 mr r4,r29
ffc0441c: 4c c6 31 82 crclr 4*cr1+eq
ffc04420: 48 00 1f 5d bl ffc0637c <printk>
printk("task ID: 0x%08lx\n", (unsigned long) running->Object.id);
ffc04424: 80 9d 00 08 lwz r4,8(r29)
ffc04428: 3c 60 ff c2 lis r3,-62
ffc0442c: 38 63 a1 3b addi r3,r3,-24261
ffc04430: 4c c6 31 82 crclr 4*cr1+eq
ffc04434: 48 00 1f 49 bl ffc0637c <printk>
printk(
ffc04438: 80 9d 00 0c lwz r4,12(r29)
ffc0443c: 3c 60 ff c2 lis r3,-62
ffc04440: 38 63 a1 4d addi r3,r3,-24243
ffc04444: 4c c6 31 82 crclr 4*cr1+eq
ffc04448: 48 00 1f 35 bl ffc0637c <printk>
"task name: 0x%08" PRIx32 "\n",
running->Object.name.name_u32
);
printk(
ffc0444c: 80 7d 00 08 lwz r3,8(r29)
ffc04450: 38 a1 00 08 addi r5,r1,8
ffc04454: 38 80 00 20 li r4,32
ffc04458: 48 00 61 61 bl ffc0a5b8 <rtems_object_get_name>
ffc0445c: 7c 64 1b 78 mr r4,r3
ffc04460: 3c 60 ff c2 lis r3,-62
ffc04464: 38 63 a1 61 addi r3,r3,-24223
ffc04468: 4c c6 31 82 crclr 4*cr1+eq
ffc0446c: 48 00 1f 11 bl ffc0637c <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)
ffc04470: 80 bd 00 bc lwz r5,188(r29)
ffc04474: 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(
ffc04478: 3c 60 ff c2 lis r3,-62
ffc0447c: 38 63 a1 77 addi r3,r3,-24201
ffc04480: 7c c5 22 14 add r6,r5,r4
ffc04484: 4c c6 31 82 crclr 4*cr1+eq
ffc04488: 48 00 1e f5 bl ffc0637c <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) {
ffc0448c: 2f 9e 00 00 cmpwi cr7,r30,0
ffc04490: 40 be 00 20 bne+ cr7,ffc044b0 <Stack_check_report_blown_task+0xcc><== NEVER TAKEN
printk(
ffc04494: 3c 60 ff c2 lis r3,-62
ffc04498: 38 63 a1 a8 addi r3,r3,-24152
ffc0449c: 38 80 00 80 li r4,128
ffc044a0: 38 bf 00 08 addi r5,r31,8
ffc044a4: 38 df 00 88 addi r6,r31,136
ffc044a8: 4c c6 31 82 crclr 4*cr1+eq
ffc044ac: 48 00 1e d1 bl ffc0637c <printk>
rtems_configuration_get_user_multiprocessing_table()->node
);
}
#endif
rtems_fatal_error_occurred(0x81);
ffc044b0: 38 60 00 81 li r3,129
ffc044b4: 48 00 6a 95 bl ffc0af48 <rtems_fatal_error_occurred>
ffc0e7e0 <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();
ffc0e7e0: 3d 20 00 00 lis r9,0
ffc0e7e4: 80 09 20 28 lwz r0,8232(r9)
ticks = microseconds / microseconds_per_tick;
ffc0e7e8: 7d 23 03 96 divwu r9,r3,r0
if ( (microseconds % microseconds_per_tick) != 0 )
ffc0e7ec: 7c 09 01 d6 mullw r0,r9,r0
ffc0e7f0: 7f 83 00 00 cmpw cr7,r3,r0
ffc0e7f4: 41 9e 00 08 beq- cr7,ffc0e7fc <TOD_MICROSECONDS_TO_TICKS+0x1c><== ALWAYS TAKEN
ticks += 1;
ffc0e7f8: 39 29 00 01 addi r9,r9,1 <== NOT EXECUTED
return ticks;
}
ffc0e7fc: 7d 23 4b 78 mr r3,r9
ffc0e800: 4e 80 00 20 blr
ffc09a50 <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();
ffc09a50: 3d 20 00 00 lis r9,0
ffc09a54: 81 29 20 10 lwz r9,8208(r9)
ffc09a58: 38 00 03 e8 li r0,1000
ffc09a5c: 7c 09 03 96 divwu r0,r9,r0
ticks = milliseconds / milliseconds_per_tick;
ffc09a60: 7d 23 03 96 divwu r9,r3,r0
if ( (milliseconds % milliseconds_per_tick) != 0 )
ffc09a64: 7c 09 01 d6 mullw r0,r9,r0
ffc09a68: 7f 83 00 00 cmpw cr7,r3,r0
ffc09a6c: 41 9e 00 08 beq- cr7,ffc09a74 <TOD_MILLISECONDS_TO_TICKS+0x24><== ALWAYS TAKEN
ticks += 1;
ffc09a70: 39 29 00 01 addi r9,r9,1 <== NOT EXECUTED
return ticks;
}
ffc09a74: 7d 23 4b 78 mr r3,r9
ffc09a78: 4e 80 00 20 blr
ffc0b144 <_CORE_RWLock_Release>:
*/
CORE_RWLock_Status _CORE_RWLock_Release(
CORE_RWLock_Control *the_rwlock
)
{
ffc0b144: 7c 2b 0b 78 mr r11,r1
ffc0b148: 7c 08 02 a6 mflr r0
ffc0b14c: 94 21 ff f0 stwu r1,-16(r1)
ISR_Level level;
Thread_Control *executing = _Thread_Executing;
ffc0b150: 3d 20 00 00 lis r9,0
*/
CORE_RWLock_Status _CORE_RWLock_Release(
CORE_RWLock_Control *the_rwlock
)
{
ffc0b154: 90 01 00 14 stw r0,20(r1)
ffc0b158: 48 00 ce 61 bl ffc17fb8 <_savegpr_31>
ffc0b15c: 7c 7f 1b 78 mr r31,r3
ISR_Level level;
Thread_Control *executing = _Thread_Executing;
ffc0b160: 81 69 31 30 lwz r11,12592(r9)
static inline uint32_t ppc_interrupt_disable( void )
{
uint32_t level;
uint32_t mask;
__asm__ volatile (
ffc0b164: 7c 00 00 a6 mfmsr r0
ffc0b168: 7d 30 42 a6 mfsprg r9,0
ffc0b16c: 7c 09 48 78 andc r9,r0,r9
ffc0b170: 7d 20 01 24 mtmsr r9
* 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){
ffc0b174: 81 23 00 44 lwz r9,68(r3)
ffc0b178: 2f 89 00 00 cmpwi cr7,r9,0
ffc0b17c: 40 be 00 14 bne+ cr7,ffc0b190 <_CORE_RWLock_Release+0x4c>
return level;
}
static inline void ppc_interrupt_enable( uint32_t level )
{
__asm__ volatile (
ffc0b180: 7c 00 01 24 mtmsr r0
_ISR_Enable( level );
executing->Wait.return_code = CORE_RWLOCK_UNAVAILABLE;
ffc0b184: 38 00 00 02 li r0,2
ffc0b188: 90 0b 00 34 stw r0,52(r11)
return CORE_RWLOCK_SUCCESSFUL;
ffc0b18c: 48 00 00 a8 b ffc0b234 <_CORE_RWLock_Release+0xf0>
}
if ( the_rwlock->current_state == CORE_RWLOCK_LOCKED_FOR_READING ) {
ffc0b190: 2f 89 00 01 cmpwi cr7,r9,1
ffc0b194: 40 9e 00 20 bne- cr7,ffc0b1b4 <_CORE_RWLock_Release+0x70>
the_rwlock->number_of_readers -= 1;
ffc0b198: 81 23 00 48 lwz r9,72(r3)
ffc0b19c: 39 29 ff ff addi r9,r9,-1
if ( the_rwlock->number_of_readers != 0 ) {
ffc0b1a0: 2f 89 00 00 cmpwi cr7,r9,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;
ffc0b1a4: 91 23 00 48 stw r9,72(r3)
if ( the_rwlock->number_of_readers != 0 ) {
ffc0b1a8: 41 be 00 0c beq+ cr7,ffc0b1b4 <_CORE_RWLock_Release+0x70>
ffc0b1ac: 7c 00 01 24 mtmsr r0
/* must be unlocked again */
_ISR_Enable( level );
return CORE_RWLOCK_SUCCESSFUL;
ffc0b1b0: 48 00 00 84 b ffc0b234 <_CORE_RWLock_Release+0xf0>
}
}
/* CORE_RWLOCK_LOCKED_FOR_WRITING or READING with readers */
executing->Wait.return_code = CORE_RWLOCK_SUCCESSFUL;
ffc0b1b4: 39 20 00 00 li r9,0
ffc0b1b8: 91 2b 00 34 stw r9,52(r11)
/*
* Implicitly transition to "unlocked" and find another thread interested
* in obtaining this rwlock.
*/
the_rwlock->current_state = CORE_RWLOCK_UNLOCKED;
ffc0b1bc: 91 3f 00 44 stw r9,68(r31)
ffc0b1c0: 7c 00 01 24 mtmsr r0
_ISR_Enable( level );
next = _Thread_queue_Dequeue( &the_rwlock->Wait_queue );
ffc0b1c4: 7f e3 fb 78 mr r3,r31
ffc0b1c8: 48 00 1e f5 bl ffc0d0bc <_Thread_queue_Dequeue>
if ( next ) {
ffc0b1cc: 2c 03 00 00 cmpwi r3,0
ffc0b1d0: 41 82 00 64 beq- ffc0b234 <_CORE_RWLock_Release+0xf0>
if ( next->Wait.option == CORE_RWLOCK_THREAD_WAITING_FOR_WRITE ) {
ffc0b1d4: 80 03 00 30 lwz r0,48(r3)
ffc0b1d8: 2f 80 00 01 cmpwi cr7,r0,1
ffc0b1dc: 40 be 00 10 bne+ cr7,ffc0b1ec <_CORE_RWLock_Release+0xa8>
the_rwlock->current_state = CORE_RWLOCK_LOCKED_FOR_WRITING;
ffc0b1e0: 38 00 00 02 li r0,2
ffc0b1e4: 90 1f 00 44 stw r0,68(r31)
return CORE_RWLOCK_SUCCESSFUL;
ffc0b1e8: 48 00 00 4c b ffc0b234 <_CORE_RWLock_Release+0xf0>
}
/*
* Must be CORE_RWLOCK_THREAD_WAITING_FOR_READING
*/
the_rwlock->number_of_readers += 1;
ffc0b1ec: 81 3f 00 48 lwz r9,72(r31)
ffc0b1f0: 38 09 00 01 addi r0,r9,1
ffc0b1f4: 90 1f 00 48 stw r0,72(r31)
the_rwlock->current_state = CORE_RWLOCK_LOCKED_FOR_READING;
ffc0b1f8: 38 00 00 01 li r0,1
ffc0b1fc: 90 1f 00 44 stw r0,68(r31)
/*
* Now see if more readers can be let go.
*/
while ( 1 ) {
next = _Thread_queue_First( &the_rwlock->Wait_queue );
ffc0b200: 7f e3 fb 78 mr r3,r31
ffc0b204: 48 00 24 15 bl ffc0d618 <_Thread_queue_First>
if ( !next ||
ffc0b208: 7c 64 1b 79 mr. r4,r3
ffc0b20c: 41 82 00 28 beq- ffc0b234 <_CORE_RWLock_Release+0xf0>
ffc0b210: 80 04 00 30 lwz r0,48(r4)
ffc0b214: 2f 80 00 01 cmpwi cr7,r0,1
ffc0b218: 41 9e 00 1c beq- cr7,ffc0b234 <_CORE_RWLock_Release+0xf0><== NEVER TAKEN
next->Wait.option == CORE_RWLOCK_THREAD_WAITING_FOR_WRITE )
return CORE_RWLOCK_SUCCESSFUL;
the_rwlock->number_of_readers += 1;
ffc0b21c: 81 3f 00 48 lwz r9,72(r31)
_Thread_queue_Extract( &the_rwlock->Wait_queue, next );
ffc0b220: 7f e3 fb 78 mr r3,r31
while ( 1 ) {
next = _Thread_queue_First( &the_rwlock->Wait_queue );
if ( !next ||
next->Wait.option == CORE_RWLOCK_THREAD_WAITING_FOR_WRITE )
return CORE_RWLOCK_SUCCESSFUL;
the_rwlock->number_of_readers += 1;
ffc0b224: 38 09 00 01 addi r0,r9,1
ffc0b228: 90 1f 00 48 stw r0,72(r31)
_Thread_queue_Extract( &the_rwlock->Wait_queue, next );
ffc0b22c: 48 00 22 81 bl ffc0d4ac <_Thread_queue_Extract>
}
ffc0b230: 4b ff ff d0 b ffc0b200 <_CORE_RWLock_Release+0xbc>
}
/* indentation is to match _ISR_Disable at top */
return CORE_RWLOCK_SUCCESSFUL;
}
ffc0b234: 39 61 00 10 addi r11,r1,16
ffc0b238: 38 60 00 00 li r3,0
ffc0b23c: 4b ff 6a 04 b ffc01c40 <_restgpr_31_x>
ffc0b240 <_CORE_RWLock_Timeout>:
void _CORE_RWLock_Timeout(
Objects_Id id,
void *ignored
)
{
ffc0b240: 94 21 ff e8 stwu r1,-24(r1)
ffc0b244: 7c 08 02 a6 mflr r0
Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
ffc0b248: 38 81 00 08 addi r4,r1,8
void _CORE_RWLock_Timeout(
Objects_Id id,
void *ignored
)
{
ffc0b24c: 90 01 00 1c stw r0,28(r1)
Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
ffc0b250: 48 00 1a f1 bl ffc0cd40 <_Thread_Get>
switch ( location ) {
ffc0b254: 80 01 00 08 lwz r0,8(r1)
ffc0b258: 2f 80 00 00 cmpwi cr7,r0,0
ffc0b25c: 40 9e 00 1c bne- cr7,ffc0b278 <_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 );
ffc0b260: 48 00 24 d1 bl ffc0d730 <_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--;
ffc0b264: 3d 20 00 00 lis r9,0
ffc0b268: 81 69 28 34 lwz r11,10292(r9)
ffc0b26c: 38 0b ff ff addi r0,r11,-1
ffc0b270: 90 09 28 34 stw r0,10292(r9)
return _Thread_Dispatch_disable_level;
ffc0b274: 80 09 28 34 lwz r0,10292(r9)
_Thread_Unnest_dispatch();
break;
}
}
ffc0b278: 80 01 00 1c lwz r0,28(r1)
ffc0b27c: 38 21 00 18 addi r1,r1,24
ffc0b280: 7c 08 03 a6 mtlr r0
ffc0b284: 4e 80 00 20 blr
ffc11b88 <_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
)
{
ffc11b88: 94 21 ff e0 stwu r1,-32(r1)
ffc11b8c: 7c 08 02 a6 mflr r0
ffc11b90: 90 01 00 24 stw r0,36(r1)
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;
ffc11b94: 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
)
{
ffc11b98: bf 81 00 10 stmw r28,16(r1)
ffc11b9c: 7c 7f 1b 78 mr r31,r3
ffc11ba0: 7c 9d 23 78 mr r29,r4
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;
ffc11ba4: 90 03 00 48 stw r0,72(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)) {
ffc11ba8: 7c dc 33 78 mr r28,r6
CORE_message_queue_Control *the_message_queue,
CORE_message_queue_Notify_Handler the_handler,
void *the_argument
)
{
the_message_queue->notify_handler = the_handler;
ffc11bac: 90 03 00 60 stw r0,96(r3)
the_message_queue->notify_argument = the_argument;
ffc11bb0: 90 03 00 64 stw r0,100(r3)
ffc11bb4: 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;
ffc11bb8: 90 a3 00 44 stw r5,68(r3)
the_message_queue->number_of_pending_messages = 0;
the_message_queue->maximum_message_size = maximum_message_size;
ffc11bbc: 90 c3 00 4c stw r6,76(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)) {
ffc11bc0: 41 82 00 18 beq- ffc11bd8 <_CORE_message_queue_Initialize+0x50>
allocated_message_size += sizeof(uint32_t);
ffc11bc4: 3b 86 00 04 addi r28,r6,4
allocated_message_size &= ~(sizeof(uint32_t) - 1);
ffc11bc8: 57 9c 00 3a rlwinm r28,r28,0,0,29
}
if (allocated_message_size < maximum_message_size)
ffc11bcc: 7f 9c 30 40 cmplw cr7,r28,r6
return false;
ffc11bd0: 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)
ffc11bd4: 41 bc 00 80 blt+ cr7,ffc11c54 <_CORE_message_queue_Initialize+0xcc><== NEVER TAKEN
/*
* Calculate how much total memory is required for message buffering and
* check for overflow on the multiplication.
*/
if ( !size_t_mult32_with_overflow(
ffc11bd8: 3b 9c 00 14 addi r28,r28,20
size_t a,
size_t b,
size_t *c
)
{
long long x = (long long)a*b;
ffc11bdc: 7d 45 e0 16 mulhwu r10,r5,r28
ffc11be0: 7d 65 e1 d6 mullw r11,r5,r28
if ( x > SIZE_MAX )
ffc11be4: 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;
ffc11be8: 3b c0 00 00 li r30,0
size_t *c
)
{
long long x = (long long)a*b;
if ( x > SIZE_MAX )
ffc11bec: 41 9d 00 68 bgt- cr7,ffc11c54 <_CORE_message_queue_Initialize+0xcc>
/*
* Attempt to allocate the message memory
*/
the_message_queue->message_buffers = (CORE_message_queue_Buffer *)
_Workspace_Allocate( message_buffering_required );
ffc11bf0: 7d 63 5b 78 mr r3,r11
ffc11bf4: 90 a1 00 08 stw r5,8(r1)
ffc11bf8: 48 00 33 ed bl ffc14fe4 <_Workspace_Allocate>
if (the_message_queue->message_buffers == 0)
ffc11bfc: 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 *)
ffc11c00: 90 7f 00 5c stw r3,92(r31)
_Workspace_Allocate( message_buffering_required );
ffc11c04: 7c 64 1b 78 mr r4,r3
if (the_message_queue->message_buffers == 0)
ffc11c08: 80 a1 00 08 lwz r5,8(r1)
ffc11c0c: 41 9e 00 48 beq- cr7,ffc11c54 <_CORE_message_queue_Initialize+0xcc>
/*
* Initialize the pool of inactive messages, pending messages,
* and set of waiting threads.
*/
_Chain_Initialize (
ffc11c10: 38 7f 00 68 addi r3,r31,104
ffc11c14: 7f 86 e3 78 mr r6,r28
ffc11c18: 48 00 5a fd bl ffc17714 <_Chain_Initialize>
allocated_message_size + sizeof( CORE_message_queue_Buffer_control )
);
_Chain_Initialize_empty( &the_message_queue->Pending_messages );
_Thread_queue_Initialize(
ffc11c1c: 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 );
ffc11c20: 38 1f 00 50 addi r0,r31,80
head->next = tail;
head->previous = NULL;
ffc11c24: 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 );
ffc11c28: 39 3f 00 54 addi r9,r31,84
ffc11c2c: 68 84 00 01 xori r4,r4,1
head->next = tail;
ffc11c30: 91 3f 00 50 stw r9,80(r31)
ffc11c34: 7c 84 00 34 cntlzw r4,r4
head->previous = NULL;
tail->previous = head;
ffc11c38: 90 1f 00 58 stw r0,88(r31)
ffc11c3c: 7f e3 fb 78 mr r3,r31
ffc11c40: 54 84 d9 7e rlwinm r4,r4,27,5,31
ffc11c44: 38 a0 00 80 li r5,128
ffc11c48: 38 c0 00 06 li r6,6
ffc11c4c: 48 00 29 21 bl ffc1456c <_Thread_queue_Initialize>
THREAD_QUEUE_DISCIPLINE_PRIORITY : THREAD_QUEUE_DISCIPLINE_FIFO,
STATES_WAITING_FOR_MESSAGE,
CORE_MESSAGE_QUEUE_STATUS_TIMEOUT
);
return true;
ffc11c50: 3b c0 00 01 li r30,1
}
ffc11c54: 39 61 00 20 addi r11,r1,32
ffc11c58: 7f c3 f3 78 mr r3,r30
ffc11c5c: 4b ff 3d 7c b ffc059d8 <_restgpr_28_x>
ffc090d8 <_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
)
{
ffc090d8: 7c 08 02 a6 mflr r0
ffc090dc: 7c 2b 0b 78 mr r11,r1
ffc090e0: 94 21 ff f0 stwu r1,-16(r1)
ffc090e4: 90 01 00 14 stw r0,20(r1)
ffc090e8: 48 01 22 65 bl ffc1b34c <_savegpr_31>
ffc090ec: 7c 7f 1b 78 mr r31,r3
ISR_Level level;
CORE_semaphore_Status status;
status = CORE_SEMAPHORE_STATUS_SUCCESSFUL;
if ( (the_thread = _Thread_queue_Dequeue(&the_semaphore->Wait_queue)) ) {
ffc090f0: 48 00 1d 79 bl ffc0ae68 <_Thread_queue_Dequeue>
ffc090f4: 2f 83 00 00 cmpwi cr7,r3,0
{
Thread_Control *the_thread;
ISR_Level level;
CORE_semaphore_Status status;
status = CORE_SEMAPHORE_STATUS_SUCCESSFUL;
ffc090f8: 38 00 00 00 li r0,0
if ( (the_thread = _Thread_queue_Dequeue(&the_semaphore->Wait_queue)) ) {
ffc090fc: 40 be 00 38 bne+ cr7,ffc09134 <_CORE_semaphore_Surrender+0x5c>
static inline uint32_t ppc_interrupt_disable( void )
{
uint32_t level;
uint32_t mask;
__asm__ volatile (
ffc09100: 7d 60 00 a6 mfmsr r11
ffc09104: 7c 10 42 a6 mfsprg r0,0
ffc09108: 7d 60 00 78 andc r0,r11,r0
ffc0910c: 7c 00 01 24 mtmsr r0
(*api_semaphore_mp_support) ( the_thread, id );
#endif
} else {
_ISR_Disable( level );
if ( the_semaphore->count < the_semaphore->Attributes.maximum_count )
ffc09110: 81 3f 00 48 lwz r9,72(r31)
the_semaphore->count += 1;
else
status = CORE_SEMAPHORE_MAXIMUM_COUNT_EXCEEDED;
ffc09114: 38 00 00 04 li r0,4
(*api_semaphore_mp_support) ( the_thread, id );
#endif
} else {
_ISR_Disable( level );
if ( the_semaphore->count < the_semaphore->Attributes.maximum_count )
ffc09118: 81 5f 00 40 lwz r10,64(r31)
ffc0911c: 7f 89 50 40 cmplw cr7,r9,r10
ffc09120: 40 9c 00 10 bge- cr7,ffc09130 <_CORE_semaphore_Surrender+0x58><== NEVER TAKEN
the_semaphore->count += 1;
ffc09124: 39 29 00 01 addi r9,r9,1
ffc09128: 91 3f 00 48 stw r9,72(r31)
{
Thread_Control *the_thread;
ISR_Level level;
CORE_semaphore_Status status;
status = CORE_SEMAPHORE_STATUS_SUCCESSFUL;
ffc0912c: 38 00 00 00 li r0,0
return level;
}
static inline void ppc_interrupt_enable( uint32_t level )
{
__asm__ volatile (
ffc09130: 7d 60 01 24 mtmsr r11
status = CORE_SEMAPHORE_MAXIMUM_COUNT_EXCEEDED;
_ISR_Enable( level );
}
return status;
}
ffc09134: 39 61 00 10 addi r11,r1,16
ffc09138: 7c 03 03 78 mr r3,r0
ffc0913c: 4b ff 74 08 b ffc00544 <_restgpr_31_x>
ffc07c5c <_Event_Surrender>:
*/
void _Event_Surrender(
Thread_Control *the_thread
)
{
ffc07c5c: 7c 2b 0b 78 mr r11,r1
ffc07c60: 7c 08 02 a6 mflr r0
ffc07c64: 94 21 ff f0 stwu r1,-16(r1)
ffc07c68: 90 01 00 14 stw r0,20(r1)
ffc07c6c: 48 01 36 e1 bl ffc1b34c <_savegpr_31>
ffc07c70: 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 ];
ffc07c74: 81 03 01 30 lwz r8,304(r3)
option_set = (rtems_option) the_thread->Wait.option;
ffc07c78: 80 e3 00 30 lwz r7,48(r3)
static inline uint32_t ppc_interrupt_disable( void )
{
uint32_t level;
uint32_t mask;
__asm__ volatile (
ffc07c7c: 7c 00 00 a6 mfmsr r0
ffc07c80: 7d 30 42 a6 mfsprg r9,0
ffc07c84: 7c 09 48 78 andc r9,r0,r9
ffc07c88: 7d 20 01 24 mtmsr r9
_ISR_Disable( level );
pending_events = api->pending_events;
ffc07c8c: 81 68 00 00 lwz r11,0(r8)
event_condition = (rtems_event_set) the_thread->Wait.count;
ffc07c90: 81 43 00 24 lwz r10,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 ) ) {
ffc07c94: 7d 49 58 39 and. r9,r10,r11
ffc07c98: 41 82 00 f4 beq- ffc07d8c <_Event_Surrender+0x130>
/*
* If we are in an ISR and sending to the current thread, then
* we have a critical section issue to deal with.
*/
if ( _ISR_Is_in_progress() &&
ffc07c9c: 3c c0 00 00 lis r6,0
ffc07ca0: 38 c6 31 44 addi r6,r6,12612
ffc07ca4: 80 a6 00 08 lwz r5,8(r6)
ffc07ca8: 2f 85 00 00 cmpwi cr7,r5,0
ffc07cac: 41 9e 00 64 beq- cr7,ffc07d10 <_Event_Surrender+0xb4>
ffc07cb0: 80 c6 00 0c lwz r6,12(r6)
ffc07cb4: 7f 83 30 00 cmpw cr7,r3,r6
ffc07cb8: 40 be 00 58 bne+ cr7,ffc07d10 <_Event_Surrender+0xb4>
_Thread_Is_executing( the_thread ) &&
((_Event_Sync_state == THREAD_BLOCKING_OPERATION_TIMEOUT) ||
ffc07cbc: 3c c0 00 00 lis r6,0
ffc07cc0: 80 a6 28 54 lwz r5,10324(r6)
/*
* 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 ) &&
ffc07cc4: 2f 85 00 02 cmpwi cr7,r5,2
ffc07cc8: 41 9e 00 10 beq- cr7,ffc07cd8 <_Event_Surrender+0x7c> <== NEVER TAKEN
((_Event_Sync_state == THREAD_BLOCKING_OPERATION_TIMEOUT) ||
(_Event_Sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED)) ) {
ffc07ccc: 80 c6 28 54 lwz r6,10324(r6)
* 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) ||
ffc07cd0: 2f 86 00 01 cmpwi cr7,r6,1
ffc07cd4: 40 be 00 3c bne+ cr7,ffc07d10 <_Event_Surrender+0xb4>
(_Event_Sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED)) ) {
if ( seized_events == event_condition || _Options_Is_any(option_set) ) {
ffc07cd8: 7f 89 50 00 cmpw cr7,r9,r10
ffc07cdc: 41 9e 00 0c beq- cr7,ffc07ce8 <_Event_Surrender+0x8c>
ffc07ce0: 70 e5 00 02 andi. r5,r7,2
ffc07ce4: 41 82 00 a8 beq- ffc07d8c <_Event_Surrender+0x130> <== NEVER TAKEN
RTEMS_INLINE_ROUTINE rtems_event_set _Event_sets_Clear(
rtems_event_set the_event_set,
rtems_event_set the_mask
)
{
return ( the_event_set & ~(the_mask) );
ffc07ce8: 7d 6b 48 78 andc r11,r11,r9
api->pending_events = _Event_sets_Clear( pending_events,seized_events );
ffc07cec: 91 68 00 00 stw r11,0(r8)
the_thread->Wait.count = 0;
ffc07cf0: 39 60 00 00 li r11,0
ffc07cf4: 91 7f 00 24 stw r11,36(r31)
*(rtems_event_set *)the_thread->Wait.return_argument = seized_events;
ffc07cf8: 81 7f 00 28 lwz r11,40(r31)
ffc07cfc: 91 2b 00 00 stw r9,0(r11)
_Event_Sync_state = THREAD_BLOCKING_OPERATION_SATISFIED;
ffc07d00: 39 60 00 03 li r11,3
ffc07d04: 3d 20 00 00 lis r9,0
ffc07d08: 91 69 28 54 stw r11,10324(r9)
ffc07d0c: 48 00 00 80 b ffc07d8c <_Event_Surrender+0x130>
*/
RTEMS_INLINE_ROUTINE bool _States_Is_waiting_for_event (
States_Control the_states
)
{
return (the_states & STATES_WAITING_FOR_EVENT);
ffc07d10: 80 df 00 10 lwz r6,16(r31)
}
/*
* Otherwise, this is a normal send to another thread
*/
if ( _States_Is_waiting_for_event( the_thread->current_state ) ) {
ffc07d14: 70 c5 01 00 andi. r5,r6,256
ffc07d18: 41 82 00 74 beq- ffc07d8c <_Event_Surrender+0x130>
if ( seized_events == event_condition || _Options_Is_any( option_set ) ) {
ffc07d1c: 7f 89 50 00 cmpw cr7,r9,r10
ffc07d20: 41 9e 00 0c beq- cr7,ffc07d2c <_Event_Surrender+0xd0>
ffc07d24: 70 ea 00 02 andi. r10,r7,2
ffc07d28: 41 82 00 64 beq- ffc07d8c <_Event_Surrender+0x130> <== NEVER TAKEN
ffc07d2c: 7d 6b 48 78 andc r11,r11,r9
api->pending_events = _Event_sets_Clear( pending_events, seized_events );
ffc07d30: 91 68 00 00 stw r11,0(r8)
the_thread->Wait.count = 0;
ffc07d34: 39 60 00 00 li r11,0
ffc07d38: 91 7f 00 24 stw r11,36(r31)
*(rtems_event_set *)the_thread->Wait.return_argument = seized_events;
ffc07d3c: 81 7f 00 28 lwz r11,40(r31)
ffc07d40: 91 2b 00 00 stw r9,0(r11)
static inline void ppc_interrupt_flash( uint32_t level )
{
uint32_t current_level;
__asm__ volatile (
ffc07d44: 7d 20 00 a6 mfmsr r9
ffc07d48: 7c 00 01 24 mtmsr r0
ffc07d4c: 7d 20 01 24 mtmsr r9
_ISR_Flash( level );
if ( !_Watchdog_Is_active( &the_thread->Timer ) ) {
ffc07d50: 81 3f 00 50 lwz r9,80(r31)
ffc07d54: 2f 89 00 02 cmpwi cr7,r9,2
ffc07d58: 41 9e 00 0c beq- cr7,ffc07d64 <_Event_Surrender+0x108>
return level;
}
static inline void ppc_interrupt_enable( uint32_t level )
{
__asm__ volatile (
ffc07d5c: 7c 00 01 24 mtmsr r0
ffc07d60: 48 00 00 18 b ffc07d78 <_Event_Surrender+0x11c>
RTEMS_INLINE_ROUTINE void _Watchdog_Deactivate(
Watchdog_Control *the_watchdog
)
{
the_watchdog->state = WATCHDOG_REMOVE_IT;
ffc07d64: 39 20 00 03 li r9,3
ffc07d68: 91 3f 00 50 stw r9,80(r31)
ffc07d6c: 7c 00 01 24 mtmsr r0
_ISR_Enable( level );
_Thread_Unblock( the_thread );
} else {
_Watchdog_Deactivate( &the_thread->Timer );
_ISR_Enable( level );
(void) _Watchdog_Remove( &the_thread->Timer );
ffc07d70: 38 7f 00 48 addi r3,r31,72
ffc07d74: 48 00 3e 19 bl ffc0bb8c <_Watchdog_Remove>
RTEMS_INLINE_ROUTINE void _Thread_Unblock (
Thread_Control *the_thread
)
{
_Thread_Clear_state( the_thread, STATES_BLOCKED );
ffc07d78: 3c 80 10 03 lis r4,4099
ffc07d7c: 7f e3 fb 78 mr r3,r31
ffc07d80: 60 84 ff f8 ori r4,r4,65528
ffc07d84: 48 00 29 69 bl ffc0a6ec <_Thread_Clear_state>
ffc07d88: 48 00 00 08 b ffc07d90 <_Event_Surrender+0x134>
ffc07d8c: 7c 00 01 24 mtmsr r0
}
return;
}
}
_ISR_Enable( level );
}
ffc07d90: 39 61 00 10 addi r11,r1,16
ffc07d94: 4b ff 87 b0 b ffc00544 <_restgpr_31_x>
ffc07d98 <_Event_Timeout>:
void _Event_Timeout(
Objects_Id id,
void *ignored
)
{
ffc07d98: 94 21 ff e8 stwu r1,-24(r1)
ffc07d9c: 7c 08 02 a6 mflr r0
Thread_Control *the_thread;
Objects_Locations location;
ISR_Level level;
the_thread = _Thread_Get( id, &location );
ffc07da0: 38 81 00 08 addi r4,r1,8
void _Event_Timeout(
Objects_Id id,
void *ignored
)
{
ffc07da4: 90 01 00 1c stw r0,28(r1)
Thread_Control *the_thread;
Objects_Locations location;
ISR_Level level;
the_thread = _Thread_Get( id, &location );
ffc07da8: 48 00 2d 45 bl ffc0aaec <_Thread_Get>
switch ( location ) {
ffc07dac: 80 01 00 08 lwz r0,8(r1)
ffc07db0: 2f 80 00 00 cmpwi cr7,r0,0
ffc07db4: 40 9e 00 6c bne- cr7,ffc07e20 <_Event_Timeout+0x88> <== NEVER TAKEN
static inline uint32_t ppc_interrupt_disable( void )
{
uint32_t level;
uint32_t mask;
__asm__ volatile (
ffc07db8: 7d 60 00 a6 mfmsr r11
ffc07dbc: 7d 30 42 a6 mfsprg r9,0
ffc07dc0: 7d 69 48 78 andc r9,r11,r9
ffc07dc4: 7d 20 01 24 mtmsr r9
RTEMS_INLINE_ROUTINE bool _Thread_Is_executing (
const Thread_Control *the_thread
)
{
return ( the_thread == _Thread_Executing );
ffc07dc8: 3d 20 00 00 lis r9,0
_ISR_Enable( level );
return;
}
#endif
the_thread->Wait.count = 0;
ffc07dcc: 90 03 00 24 stw r0,36(r3)
if ( _Thread_Is_executing( the_thread ) ) {
ffc07dd0: 80 09 31 50 lwz r0,12624(r9)
ffc07dd4: 7f 83 00 00 cmpw cr7,r3,r0
ffc07dd8: 40 be 00 1c bne+ cr7,ffc07df4 <_Event_Timeout+0x5c>
if ( _Event_Sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED )
ffc07ddc: 3d 20 00 00 lis r9,0
ffc07de0: 80 09 28 54 lwz r0,10324(r9)
ffc07de4: 2f 80 00 01 cmpwi cr7,r0,1
ffc07de8: 40 be 00 0c bne+ cr7,ffc07df4 <_Event_Timeout+0x5c>
_Event_Sync_state = THREAD_BLOCKING_OPERATION_TIMEOUT;
ffc07dec: 38 00 00 02 li r0,2
ffc07df0: 90 09 28 54 stw r0,10324(r9)
}
the_thread->Wait.return_code = RTEMS_TIMEOUT;
ffc07df4: 38 00 00 06 li r0,6
ffc07df8: 90 03 00 34 stw r0,52(r3)
return level;
}
static inline void ppc_interrupt_enable( uint32_t level )
{
__asm__ volatile (
ffc07dfc: 7d 60 01 24 mtmsr r11
RTEMS_INLINE_ROUTINE void _Thread_Unblock (
Thread_Control *the_thread
)
{
_Thread_Clear_state( the_thread, STATES_BLOCKED );
ffc07e00: 3c 80 10 03 lis r4,4099
ffc07e04: 60 84 ff f8 ori r4,r4,65528
ffc07e08: 48 00 28 e5 bl ffc0a6ec <_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--;
ffc07e0c: 3d 20 00 00 lis r9,0
ffc07e10: 81 69 28 0c lwz r11,10252(r9)
ffc07e14: 38 0b ff ff addi r0,r11,-1
ffc07e18: 90 09 28 0c stw r0,10252(r9)
return _Thread_Dispatch_disable_level;
ffc07e1c: 80 09 28 0c lwz r0,10252(r9)
case OBJECTS_REMOTE: /* impossible */
#endif
case OBJECTS_ERROR:
break;
}
}
ffc07e20: 80 01 00 1c lwz r0,28(r1)
ffc07e24: 38 21 00 18 addi r1,r1,24
ffc07e28: 7c 08 03 a6 mtlr r0
ffc07e2c: 4e 80 00 20 blr
ffc0e53c <_Heap_Extend>:
Heap_Control *heap,
void *extend_area_begin_ptr,
uintptr_t extend_area_size,
uintptr_t *extended_size_ptr
)
{
ffc0e53c: 94 21 ff c0 stwu r1,-64(r1)
ffc0e540: 7c 08 02 a6 mflr r0
ffc0e544: be c1 00 18 stmw r22,24(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;
ffc0e548: 7f c4 2a 14 add r30,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 ) {
ffc0e54c: 7f 9e 20 40 cmplw cr7,r30,r4
Heap_Control *heap,
void *extend_area_begin_ptr,
uintptr_t extend_area_size,
uintptr_t *extended_size_ptr
)
{
ffc0e550: 90 01 00 44 stw r0,68(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;
ffc0e554: 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
)
{
ffc0e558: 7c d9 33 78 mr r25,r6
ffc0e55c: 7c 7f 1b 78 mr r31,r3
Heap_Statistics *const stats = &heap->stats;
Heap_Block *const first_block = heap->first_block;
ffc0e560: 83 83 00 20 lwz r28,32(r3)
Heap_Control *heap,
void *extend_area_begin_ptr,
uintptr_t extend_area_size,
uintptr_t *extended_size_ptr
)
{
ffc0e564: 7c 9d 23 78 mr r29,r4
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;
ffc0e568: 93 41 00 0c stw r26,12(r1)
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;
ffc0e56c: 38 00 00 00 li r0,0
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;
Heap_Block *extend_last_block = NULL;
ffc0e570: 93 41 00 08 stw r26,8(r1)
uintptr_t const page_size = heap->page_size;
ffc0e574: 83 63 00 10 lwz r27,16(r3)
uintptr_t const min_block_size = heap->min_block_size;
ffc0e578: 80 c3 00 14 lwz r6,20(r3)
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;
ffc0e57c: 83 03 00 30 lwz r24,48(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 ) {
ffc0e580: 41 bc 02 70 blt+ cr7,ffc0e7f0 <_Heap_Extend+0x2b4>
return false;
}
extend_area_ok = _Heap_Get_first_and_last_block(
ffc0e584: 7c 83 23 78 mr r3,r4
ffc0e588: 38 e1 00 0c addi r7,r1,12
ffc0e58c: 7c a4 2b 78 mr r4,r5
ffc0e590: 39 01 00 08 addi r8,r1,8
ffc0e594: 7f 65 db 78 mr r5,r27
ffc0e598: 4b ff aa bd bl ffc09054 <_Heap_Get_first_and_last_block>
&extend_first_block,
&extend_last_block
);
if (!extend_area_ok ) {
/* For simplicity we reject extend areas that are too small */
return false;
ffc0e59c: 7f 40 d3 78 mr r0,r26
page_size,
min_block_size,
&extend_first_block,
&extend_last_block
);
if (!extend_area_ok ) {
ffc0e5a0: 2f 83 00 00 cmpwi cr7,r3,0
ffc0e5a4: 41 9e 02 4c beq- cr7,ffc0e7f0 <_Heap_Extend+0x2b4>
ffc0e5a8: 7f 89 e3 78 mr r9,r28
ffc0e5ac: 3a c0 00 00 li r22,0
ffc0e5b0: 39 40 00 00 li r10,0
ffc0e5b4: 3a e0 00 00 li r23,0
return false;
}
do {
uintptr_t const sub_area_begin = (start_block != first_block) ?
(uintptr_t) start_block : heap->area_begin;
ffc0e5b8: 7f 89 e0 00 cmpw cr7,r9,r28
ffc0e5bc: 7d 2b 4b 78 mr r11,r9
ffc0e5c0: 40 be 00 08 bne+ cr7,ffc0e5c8 <_Heap_Extend+0x8c>
ffc0e5c4: 81 7f 00 18 lwz r11,24(r31)
uintptr_t const sub_area_end = start_block->prev_size;
ffc0e5c8: 80 09 00 00 lwz r0,0(r9)
Heap_Block *const end_block =
_Heap_Block_of_alloc_area( sub_area_end, page_size );
if (
ffc0e5cc: 7f 80 e8 40 cmplw cr7,r0,r29
ffc0e5d0: 40 9d 00 0c ble- cr7,ffc0e5dc <_Heap_Extend+0xa0>
sub_area_end > extend_area_begin && extend_area_end > sub_area_begin
ffc0e5d4: 7f 9e 58 40 cmplw cr7,r30,r11
ffc0e5d8: 41 9d 02 14 bgt- cr7,ffc0e7ec <_Heap_Extend+0x2b0>
) {
return false;
}
if ( extend_area_end == sub_area_begin ) {
ffc0e5dc: 7f 9e 58 00 cmpw cr7,r30,r11
ffc0e5e0: 41 9e 00 10 beq- cr7,ffc0e5f0 <_Heap_Extend+0xb4>
merge_below_block = start_block;
} else if ( extend_area_end < sub_area_end ) {
ffc0e5e4: 7f 9e 00 40 cmplw cr7,r30,r0
ffc0e5e8: 41 9c 00 10 blt- cr7,ffc0e5f8 <_Heap_Extend+0xbc>
ffc0e5ec: 48 00 00 10 b ffc0e5fc <_Heap_Extend+0xc0>
sub_area_end > extend_area_begin && extend_area_end > sub_area_begin
) {
return false;
}
if ( extend_area_end == sub_area_begin ) {
ffc0e5f0: 7d 37 4b 78 mr r23,r9
ffc0e5f4: 48 00 00 08 b ffc0e5fc <_Heap_Extend+0xc0>
merge_below_block = start_block;
} else if ( extend_area_end < sub_area_end ) {
ffc0e5f8: 7d 2a 4b 78 mr r10,r9
ffc0e5fc: 7d 60 db 96 divwu r11,r0,r27
link_below_block = start_block;
}
if ( sub_area_end == extend_area_begin ) {
ffc0e600: 7f 80 e8 00 cmpw cr7,r0,r29
ffc0e604: 7d 6b d9 d6 mullw r11,r11,r27
uintptr_t alloc_begin,
uintptr_t page_size
)
{
return (Heap_Block *) (_Heap_Align_down( alloc_begin, page_size )
- HEAP_BLOCK_HEADER_SIZE);
ffc0e608: 39 6b ff f8 addi r11,r11,-8
ffc0e60c: 40 be 00 10 bne+ cr7,ffc0e61c <_Heap_Extend+0xe0>
start_block->prev_size = extend_area_end;
ffc0e610: 93 c9 00 00 stw r30,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 )
ffc0e614: 7d 7a 5b 78 mr r26,r11
ffc0e618: 48 00 00 10 b ffc0e628 <_Heap_Extend+0xec>
merge_above_block = end_block;
} else if ( sub_area_end < extend_area_begin ) {
ffc0e61c: 7f 80 e8 40 cmplw cr7,r0,r29
ffc0e620: 40 9c 00 08 bge- cr7,ffc0e628 <_Heap_Extend+0xec>
ffc0e624: 7d 76 5b 78 mr r22,r11
- 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;
ffc0e628: 81 2b 00 04 lwz r9,4(r11)
ffc0e62c: 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);
ffc0e630: 7d 29 5a 14 add r9,r9,r11
link_above_block = end_block;
}
start_block = _Heap_Block_at( end_block, _Heap_Block_size( end_block ) );
} while ( start_block != first_block );
ffc0e634: 7f 89 e0 00 cmpw cr7,r9,r28
ffc0e638: 40 9e ff 80 bne+ cr7,ffc0e5b8 <_Heap_Extend+0x7c>
if ( extend_area_begin < heap->area_begin ) {
ffc0e63c: 80 1f 00 18 lwz r0,24(r31)
ffc0e640: 7f 9d 00 40 cmplw cr7,r29,r0
ffc0e644: 40 9c 00 0c bge- cr7,ffc0e650 <_Heap_Extend+0x114>
heap->area_begin = extend_area_begin;
ffc0e648: 93 bf 00 18 stw r29,24(r31)
ffc0e64c: 48 00 00 14 b ffc0e660 <_Heap_Extend+0x124>
} else if ( heap->area_end < extend_area_end ) {
ffc0e650: 80 1f 00 1c lwz r0,28(r31)
ffc0e654: 7f 80 f0 40 cmplw cr7,r0,r30
ffc0e658: 40 9c 00 08 bge- cr7,ffc0e660 <_Heap_Extend+0x124>
heap->area_end = extend_area_end;
ffc0e65c: 93 df 00 1c stw r30,28(r31)
}
extend_first_block_size =
(uintptr_t) extend_last_block - (uintptr_t) extend_first_block;
ffc0e660: 81 61 00 0c lwz r11,12(r1)
ffc0e664: 81 21 00 08 lwz r9,8(r1)
extend_first_block->prev_size = extend_area_end;
ffc0e668: 93 cb 00 00 stw r30,0(r11)
heap->area_begin = extend_area_begin;
} else if ( heap->area_end < extend_area_end ) {
heap->area_end = extend_area_end;
}
extend_first_block_size =
ffc0e66c: 7c 0b 48 50 subf r0,r11,r9
(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;
ffc0e670: 60 08 00 01 ori r8,r0,1
_Heap_Protection_block_initialize( heap, extend_first_block );
extend_last_block->prev_size = extend_first_block_size;
ffc0e674: 90 09 00 00 stw r0,0(r9)
extend_last_block->size_and_flag = 0;
ffc0e678: 38 00 00 00 li r0,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 =
ffc0e67c: 91 0b 00 04 stw r8,4(r11)
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;
ffc0e680: 90 09 00 04 stw r0,4(r9)
_Heap_Protection_block_initialize( heap, extend_last_block );
if ( (uintptr_t) extend_first_block < (uintptr_t) heap->first_block ) {
ffc0e684: 80 1f 00 20 lwz r0,32(r31)
ffc0e688: 7f 80 58 40 cmplw cr7,r0,r11
ffc0e68c: 40 9d 00 0c ble- cr7,ffc0e698 <_Heap_Extend+0x15c>
heap->first_block = extend_first_block;
ffc0e690: 91 7f 00 20 stw r11,32(r31)
ffc0e694: 48 00 00 14 b ffc0e6a8 <_Heap_Extend+0x16c>
} else if ( (uintptr_t) extend_last_block > (uintptr_t) heap->last_block ) {
ffc0e698: 80 1f 00 24 lwz r0,36(r31)
ffc0e69c: 7f 80 48 40 cmplw cr7,r0,r9
ffc0e6a0: 40 9c 00 08 bge- cr7,ffc0e6a8 <_Heap_Extend+0x16c>
heap->last_block = extend_last_block;
ffc0e6a4: 91 3f 00 24 stw r9,36(r31)
}
if ( merge_below_block != NULL ) {
ffc0e6a8: 2f 97 00 00 cmpwi cr7,r23,0
ffc0e6ac: 41 9e 00 48 beq- cr7,ffc0e6f4 <_Heap_Extend+0x1b8>
Heap_Control *heap,
uintptr_t extend_area_begin,
Heap_Block *first_block
)
{
uintptr_t const page_size = heap->page_size;
ffc0e6b0: 80 1f 00 10 lwz r0,16(r31)
uintptr_t const new_first_block_alloc_begin =
_Heap_Align_up( extend_area_begin + HEAP_BLOCK_HEADER_SIZE, page_size );
ffc0e6b4: 3b bd 00 08 addi r29,r29,8
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_up(
uintptr_t value,
uintptr_t alignment
)
{
uintptr_t remainder = value % alignment;
ffc0e6b8: 7d 3d 03 96 divwu r9,r29,r0
ffc0e6bc: 7d 29 01 d6 mullw r9,r9,r0
if ( remainder != 0 ) {
ffc0e6c0: 7d 29 e8 51 subf. r9,r9,r29
ffc0e6c4: 41 82 00 0c beq- ffc0e6d0 <_Heap_Extend+0x194> <== NEVER TAKEN
return value - remainder + alignment;
ffc0e6c8: 7f bd 02 14 add r29,r29,r0
ffc0e6cc: 7f a9 e8 50 subf r29,r9,r29
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;
ffc0e6d0: 80 17 00 00 lwz r0,0(r23)
)
{
uintptr_t const page_size = heap->page_size;
uintptr_t const new_first_block_alloc_begin =
_Heap_Align_up( extend_area_begin + HEAP_BLOCK_HEADER_SIZE, page_size );
uintptr_t const new_first_block_begin =
ffc0e6d4: 38 9d ff f8 addi r4,r29,-8
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;
_Heap_Free_block( heap, new_first_block );
ffc0e6d8: 7f e3 fb 78 mr r3,r31
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;
ffc0e6dc: 90 1d ff f8 stw r0,-8(r29)
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 =
ffc0e6e0: 7c 04 b8 50 subf r0,r4,r23
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;
ffc0e6e4: 60 00 00 01 ori r0,r0,1
ffc0e6e8: 90 04 00 04 stw r0,4(r4)
_Heap_Free_block( heap, new_first_block );
ffc0e6ec: 4b ff fe 15 bl ffc0e500 <_Heap_Free_block>
ffc0e6f0: 48 00 00 1c b ffc0e70c <_Heap_Extend+0x1d0>
heap->last_block = extend_last_block;
}
if ( merge_below_block != NULL ) {
_Heap_Merge_below( heap, extend_area_begin, merge_below_block );
} else if ( link_below_block != NULL ) {
ffc0e6f4: 2f 8a 00 00 cmpwi cr7,r10,0
ffc0e6f8: 41 9e 00 14 beq- cr7,ffc0e70c <_Heap_Extend+0x1d0>
_Heap_Link_below(
ffc0e6fc: 81 21 00 08 lwz r9,8(r1)
{
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;
ffc0e700: 7d 49 50 50 subf r10,r9,r10
ffc0e704: 61 4a 00 01 ori r10,r10,1
)
{
uintptr_t const last_block_begin = (uintptr_t) last_block;
uintptr_t const link_begin = (uintptr_t) link;
last_block->size_and_flag =
ffc0e708: 91 49 00 04 stw r10,4(r9)
link_below_block,
extend_last_block
);
}
if ( merge_above_block != NULL ) {
ffc0e70c: 2f 9a 00 00 cmpwi cr7,r26,0
ffc0e710: 41 9e 00 4c beq- cr7,ffc0e75c <_Heap_Extend+0x220>
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(
uintptr_t value,
uintptr_t alignment
)
{
return value - (value % alignment);
ffc0e714: 80 1f 00 10 lwz r0,16(r31)
)
{
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,
ffc0e718: 3b de ff f8 addi r30,r30,-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(
ffc0e71c: 7f da f0 50 subf r30,r26,r30
ffc0e720: 7f de 03 96 divwu r30,r30,r0
ffc0e724: 7f de 01 d6 mullw r30,r30,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)
ffc0e728: 80 1a 00 04 lwz r0,4(r26)
| HEAP_PREV_BLOCK_USED;
_Heap_Block_set_size( last_block, last_block_new_size );
_Heap_Free_block( heap, last_block );
ffc0e72c: 7f e3 fb 78 mr r3,r31
);
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)
ffc0e730: 7c 1e 00 50 subf r0,r30,r0
page_size
);
Heap_Block *const new_last_block =
_Heap_Block_at( last_block, last_block_new_size );
new_last_block->size_and_flag =
ffc0e734: 7d 3e d2 14 add r9,r30,r26
(last_block->size_and_flag - last_block_new_size)
| HEAP_PREV_BLOCK_USED;
ffc0e738: 60 00 00 01 ori r0,r0,1
page_size
);
Heap_Block *const new_last_block =
_Heap_Block_at( last_block, last_block_new_size );
new_last_block->size_and_flag =
ffc0e73c: 90 09 00 04 stw r0,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 );
ffc0e740: 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;
ffc0e744: 80 1a 00 04 lwz r0,4(r26)
ffc0e748: 54 00 07 fe clrlwi r0,r0,31
block->size_and_flag = size | flag;
ffc0e74c: 7f de 03 78 or r30,r30,r0
ffc0e750: 93 da 00 04 stw r30,4(r26)
ffc0e754: 4b ff fd ad bl ffc0e500 <_Heap_Free_block>
ffc0e758: 48 00 00 34 b ffc0e78c <_Heap_Extend+0x250>
);
}
if ( merge_above_block != NULL ) {
_Heap_Merge_above( heap, merge_above_block, extend_area_end );
} else if ( link_above_block != NULL ) {
ffc0e75c: 2f 96 00 00 cmpwi cr7,r22,0
ffc0e760: 41 9e 00 2c beq- cr7,ffc0e78c <_Heap_Extend+0x250>
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;
ffc0e764: 81 76 00 04 lwz r11,4(r22)
)
{
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 );
ffc0e768: 80 01 00 0c lwz r0,12(r1)
ffc0e76c: 55 6b 07 fe clrlwi r11,r11,31
}
if ( merge_above_block != NULL ) {
_Heap_Merge_above( heap, merge_above_block, extend_area_end );
} else if ( link_above_block != NULL ) {
_Heap_Link_above(
ffc0e770: 81 21 00 08 lwz r9,8(r1)
)
{
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 );
ffc0e774: 7c 16 00 50 subf r0,r22,r0
block->size_and_flag = size | flag;
ffc0e778: 7d 60 03 78 or r0,r11,r0
ffc0e77c: 90 16 00 04 stw r0,4(r22)
last_block->size_and_flag |= HEAP_PREV_BLOCK_USED;
ffc0e780: 80 09 00 04 lwz r0,4(r9)
ffc0e784: 60 00 00 01 ori r0,r0,1
ffc0e788: 90 09 00 04 stw r0,4(r9)
extend_first_block,
extend_last_block
);
}
if ( merge_below_block == NULL && merge_above_block == NULL ) {
ffc0e78c: 2f 97 00 00 cmpwi cr7,r23,0
ffc0e790: 40 be 00 18 bne+ cr7,ffc0e7a8 <_Heap_Extend+0x26c>
ffc0e794: 2f 9a 00 00 cmpwi cr7,r26,0
ffc0e798: 40 be 00 10 bne+ cr7,ffc0e7a8 <_Heap_Extend+0x26c>
_Heap_Free_block( heap, extend_first_block );
ffc0e79c: 80 81 00 0c lwz r4,12(r1)
ffc0e7a0: 7f e3 fb 78 mr r3,r31
ffc0e7a4: 4b ff fd 5d bl ffc0e500 <_Heap_Free_block>
*/
RTEMS_INLINE_ROUTINE void _Heap_Set_last_block_size( Heap_Control *heap )
{
_Heap_Block_set_size(
heap->last_block,
(uintptr_t) heap->first_block - (uintptr_t) heap->last_block
ffc0e7a8: 81 3f 00 24 lwz r9,36(r31)
extended_size = stats->free_size - free_size;
/* Statistics */
stats->size += extended_size;
if ( extended_size_ptr != NULL )
ffc0e7ac: 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(
ffc0e7b0: 80 1f 00 20 lwz r0,32(r31)
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;
ffc0e7b4: 81 69 00 04 lwz r11,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(
ffc0e7b8: 7c 09 00 50 subf r0,r9,r0
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;
ffc0e7bc: 55 6b 07 fe clrlwi r11,r11,31
block->size_and_flag = size | flag;
ffc0e7c0: 7d 60 03 78 or r0,r11,r0
ffc0e7c4: 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;
ffc0e7c8: 80 1f 00 30 lwz r0,48(r31)
ffc0e7cc: 7f 18 00 50 subf r24,r24,r0
/* Statistics */
stats->size += extended_size;
ffc0e7d0: 80 1f 00 2c lwz r0,44(r31)
ffc0e7d4: 7c 00 c2 14 add r0,r0,r24
ffc0e7d8: 90 1f 00 2c stw r0,44(r31)
if ( extended_size_ptr != NULL )
*extended_size_ptr = extended_size;
return true;
ffc0e7dc: 38 00 00 01 li r0,1
extended_size = stats->free_size - free_size;
/* Statistics */
stats->size += extended_size;
if ( extended_size_ptr != NULL )
ffc0e7e0: 41 9e 00 10 beq- cr7,ffc0e7f0 <_Heap_Extend+0x2b4> <== NEVER TAKEN
*extended_size_ptr = extended_size;
ffc0e7e4: 93 19 00 00 stw r24,0(r25)
ffc0e7e8: 48 00 00 08 b ffc0e7f0 <_Heap_Extend+0x2b4>
_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;
ffc0e7ec: 38 00 00 00 li r0,0
if ( extended_size_ptr != NULL )
*extended_size_ptr = extended_size;
return true;
}
ffc0e7f0: 39 61 00 40 addi r11,r1,64
ffc0e7f4: 7c 03 03 78 mr r3,r0
ffc0e7f8: 4b ff 1c e0 b ffc004d8 <_restgpr_22_x>
ffc0e87c <_Heap_Free>:
return do_free;
}
#endif
bool _Heap_Free( Heap_Control *heap, void *alloc_begin_ptr )
{
ffc0e87c: 7c 2b 0b 78 mr r11,r1
ffc0e880: 94 21 ff f0 stwu r1,-16(r1)
ffc0e884: 7c 08 02 a6 mflr r0
ffc0e888: 7c 69 1b 78 mr r9,r3
ffc0e88c: 48 00 ca c1 bl ffc1b34c <_savegpr_31>
/*
* 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 ) {
ffc0e890: 7c 8b 23 79 mr. r11,r4
return do_free;
}
#endif
bool _Heap_Free( Heap_Control *heap, void *alloc_begin_ptr )
{
ffc0e894: 90 01 00 14 stw r0,20(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;
ffc0e898: 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 ) {
ffc0e89c: 41 82 01 e8 beq- ffc0ea84 <_Heap_Free+0x208>
ffc0e8a0: 80 09 00 10 lwz r0,16(r9)
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
ffc0e8a4: 80 a9 00 20 lwz r5,32(r9)
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(
uintptr_t value,
uintptr_t alignment
)
{
return value - (value % alignment);
ffc0e8a8: 7d 6b 03 96 divwu r11,r11,r0
ffc0e8ac: 7d 6b 01 d6 mullw r11,r11,r0
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;
ffc0e8b0: 38 00 00 00 li r0,0
uintptr_t alloc_begin,
uintptr_t page_size
)
{
return (Heap_Block *) (_Heap_Align_down( alloc_begin, page_size )
- HEAP_BLOCK_HEADER_SIZE);
ffc0e8b4: 39 6b ff f8 addi r11,r11,-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;
ffc0e8b8: 7f 8b 28 40 cmplw cr7,r11,r5
ffc0e8bc: 41 9c 00 14 blt- cr7,ffc0e8d0 <_Heap_Free+0x54>
ffc0e8c0: 80 09 00 24 lwz r0,36(r9)
ffc0e8c4: 7c 0b 00 10 subfc r0,r11,r0
ffc0e8c8: 38 00 00 00 li r0,0
ffc0e8cc: 7c 00 01 14 adde r0,r0,r0
}
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 ) ) {
ffc0e8d0: 2f 80 00 00 cmpwi cr7,r0,0
return false;
ffc0e8d4: 38 60 00 00 li r3,0
}
alloc_begin = (uintptr_t) alloc_begin_ptr;
block = _Heap_Block_of_alloc_area( alloc_begin, heap->page_size );
if ( !_Heap_Is_block_in_heap( heap, block ) ) {
ffc0e8d8: 41 9e 01 ac beq- cr7,ffc0ea84 <_Heap_Free+0x208>
--stats->used_blocks;
++stats->frees;
stats->free_size += block_size;
return( true );
}
ffc0e8dc: 80 cb 00 04 lwz r6,4(r11)
ffc0e8e0: 38 00 00 00 li r0,0
- 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;
ffc0e8e4: 54 c8 00 3c rlwinm r8,r6,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);
ffc0e8e8: 7d 48 5a 14 add r10,r8,r11
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;
ffc0e8ec: 7f 8a 28 40 cmplw cr7,r10,r5
ffc0e8f0: 41 9c 00 14 blt- cr7,ffc0e904 <_Heap_Free+0x88> <== NEVER TAKEN
ffc0e8f4: 80 09 00 24 lwz r0,36(r9)
ffc0e8f8: 7c 0a 00 10 subfc r0,r10,r0
ffc0e8fc: 38 00 00 00 li r0,0
ffc0e900: 7c 00 01 14 adde r0,r0,r0
_Heap_Protection_block_check( heap, block );
block_size = _Heap_Block_size( block );
next_block = _Heap_Block_at( block, block_size );
if ( !_Heap_Is_block_in_heap( heap, next_block ) ) {
ffc0e904: 2f 80 00 00 cmpwi cr7,r0,0
return false;
ffc0e908: 38 60 00 00 li r3,0
_Heap_Protection_block_check( heap, block );
block_size = _Heap_Block_size( block );
next_block = _Heap_Block_at( block, block_size );
if ( !_Heap_Is_block_in_heap( heap, next_block ) ) {
ffc0e90c: 41 9e 01 78 beq- cr7,ffc0ea84 <_Heap_Free+0x208>
--stats->used_blocks;
++stats->frees;
stats->free_size += block_size;
return( true );
}
ffc0e910: 80 0a 00 04 lwz r0,4(r10)
return false;
}
_Heap_Protection_block_check( heap, next_block );
if ( !_Heap_Is_prev_used( next_block ) ) {
ffc0e914: 70 04 00 01 andi. r4,r0,1
ffc0e918: 41 82 01 6c beq- ffc0ea84 <_Heap_Free+0x208>
if ( !_Heap_Protection_determine_block_free( heap, block ) ) {
return true;
}
next_block_size = _Heap_Block_size( next_block );
next_is_free = next_block != heap->last_block
ffc0e91c: 80 69 00 24 lwz r3,36(r9)
- 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;
ffc0e920: 54 00 00 3c rlwinm r0,r0,0,0,30
&& !_Heap_Is_prev_used( _Heap_Block_at( next_block, next_block_size ));
ffc0e924: 38 80 00 00 li r4,0
ffc0e928: 7f 8a 18 00 cmpw cr7,r10,r3
ffc0e92c: 41 9e 00 18 beq- cr7,ffc0e944 <_Heap_Free+0xc8>
--stats->used_blocks;
++stats->frees;
stats->free_size += block_size;
return( true );
}
ffc0e930: 7c ea 02 14 add r7,r10,r0
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;
ffc0e934: 80 e7 00 04 lwz r7,4(r7)
return do_free;
}
#endif
bool _Heap_Free( Heap_Control *heap, void *alloc_begin_ptr )
ffc0e938: 70 ff 00 01 andi. r31,r7,1
ffc0e93c: 7c 80 00 26 mfcr r4
ffc0e940: 54 84 1f fe rlwinm r4,r4,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 ) ) {
ffc0e944: 70 c7 00 01 andi. r7,r6,1
if ( !_Heap_Protection_determine_block_free( heap, block ) ) {
return true;
}
next_block_size = _Heap_Block_size( next_block );
next_is_free = next_block != heap->last_block
ffc0e948: 54 84 06 3e clrlwi r4,r4,24
&& !_Heap_Is_prev_used( _Heap_Block_at( next_block, next_block_size ));
if ( !_Heap_Is_prev_used( block ) ) {
ffc0e94c: 40 82 00 94 bne- ffc0e9e0 <_Heap_Free+0x164>
uintptr_t const prev_size = block->prev_size;
ffc0e950: 80 cb 00 00 lwz r6,0(r11)
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;
ffc0e954: 39 80 00 00 li r12,0
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
const Heap_Block *block,
uintptr_t offset
)
{
return (Heap_Block *) ((uintptr_t) block + offset);
ffc0e958: 7c e6 58 50 subf r7,r6,r11
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;
ffc0e95c: 7f 87 28 40 cmplw cr7,r7,r5
ffc0e960: 41 9c 00 10 blt- cr7,ffc0e970 <_Heap_Free+0xf4> <== NEVER TAKEN
ffc0e964: 7d 87 18 10 subfc r12,r7,r3
ffc0e968: 39 80 00 00 li r12,0
ffc0e96c: 7d 8c 61 14 adde r12,r12,r12
Heap_Block * const prev_block = _Heap_Block_at( block, -prev_size );
if ( !_Heap_Is_block_in_heap( heap, prev_block ) ) {
ffc0e970: 2f 8c 00 00 cmpwi cr7,r12,0
_HAssert( false );
return( false );
ffc0e974: 38 60 00 00 li r3,0
if ( !_Heap_Is_prev_used( block ) ) {
uintptr_t const prev_size = block->prev_size;
Heap_Block * const prev_block = _Heap_Block_at( block, -prev_size );
if ( !_Heap_Is_block_in_heap( heap, prev_block ) ) {
ffc0e978: 41 9e 01 0c beq- cr7,ffc0ea84 <_Heap_Free+0x208> <== 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;
ffc0e97c: 80 a7 00 04 lwz r5,4(r7)
return( false );
}
/* As we always coalesce free blocks, the block that preceedes prev_block
must have been used. */
if ( !_Heap_Is_prev_used ( prev_block) ) {
ffc0e980: 70 bf 00 01 andi. r31,r5,1
ffc0e984: 41 82 01 00 beq- ffc0ea84 <_Heap_Free+0x208> <== NEVER TAKEN
_HAssert( false );
return( false );
}
if ( next_is_free ) { /* coalesce both */
ffc0e988: 2f 84 00 00 cmpwi cr7,r4,0
ffc0e98c: 7c c8 32 14 add r6,r8,r6
ffc0e990: 41 9e 00 34 beq- cr7,ffc0e9c4 <_Heap_Free+0x148>
return _Heap_Free_list_tail(heap)->prev;
}
RTEMS_INLINE_ROUTINE void _Heap_Free_list_remove( Heap_Block *block )
{
Heap_Block *next = block->next;
ffc0e994: 81 6a 00 08 lwz r11,8(r10)
uintptr_t const size = block_size + prev_size + next_block_size;
ffc0e998: 7c c6 02 14 add r6,r6,r0
Heap_Block *prev = block->prev;
ffc0e99c: 81 4a 00 0c lwz r10,12(r10)
prev->next = next;
ffc0e9a0: 91 6a 00 08 stw r11,8(r10)
next->prev = prev;
ffc0e9a4: 91 4b 00 0c stw r10,12(r11)
_Heap_Free_list_remove( next_block );
stats->free_blocks -= 1;
ffc0e9a8: 81 69 00 38 lwz r11,56(r9)
ffc0e9ac: 38 0b ff ff addi r0,r11,-1
ffc0e9b0: 90 09 00 38 stw r0,56(r9)
prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
ffc0e9b4: 60 c0 00 01 ori r0,r6,1
ffc0e9b8: 90 07 00 04 stw r0,4(r7)
next_block = _Heap_Block_at( prev_block, size );
_HAssert(!_Heap_Is_prev_used( next_block));
next_block->prev_size = size;
ffc0e9bc: 7c c6 39 2e stwx r6,r6,r7
ffc0e9c0: 48 00 00 9c b ffc0ea5c <_Heap_Free+0x1e0>
} else { /* coalesce prev */
uintptr_t const size = block_size + prev_size;
prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
ffc0e9c4: 60 c0 00 01 ori r0,r6,1
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
next_block->prev_size = size;
ffc0e9c8: 7c c8 59 2e stwx r6,r8,r11
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;
ffc0e9cc: 90 07 00 04 stw r0,4(r7)
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
ffc0e9d0: 80 0a 00 04 lwz r0,4(r10)
ffc0e9d4: 54 00 00 3c rlwinm r0,r0,0,0,30
ffc0e9d8: 90 0a 00 04 stw r0,4(r10)
ffc0e9dc: 48 00 00 80 b ffc0ea5c <_Heap_Free+0x1e0>
next_block->prev_size = size;
}
} else if ( next_is_free ) { /* coalesce next */
ffc0e9e0: 2f 84 00 00 cmpwi cr7,r4,0
ffc0e9e4: 41 9e 00 30 beq- cr7,ffc0ea14 <_Heap_Free+0x198>
RTEMS_INLINE_ROUTINE void _Heap_Free_list_replace(
Heap_Block *old_block,
Heap_Block *new_block
)
{
Heap_Block *next = old_block->next;
ffc0e9e8: 80 ca 00 08 lwz r6,8(r10)
uintptr_t const size = block_size + next_block_size;
ffc0e9ec: 7c e0 42 14 add r7,r0,r8
Heap_Block *prev = old_block->prev;
ffc0e9f0: 81 4a 00 0c lwz r10,12(r10)
_Heap_Free_list_replace( next_block, block );
block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
ffc0e9f4: 60 e0 00 01 ori r0,r7,1
new_block->next = next;
ffc0e9f8: 90 cb 00 08 stw r6,8(r11)
new_block->prev = prev;
ffc0e9fc: 91 4b 00 0c stw r10,12(r11)
next->prev = new_block;
prev->next = new_block;
ffc0ea00: 91 6a 00 08 stw r11,8(r10)
Heap_Block *prev = old_block->prev;
new_block->next = next;
new_block->prev = prev;
next->prev = new_block;
ffc0ea04: 91 66 00 0c stw r11,12(r6)
ffc0ea08: 90 0b 00 04 stw r0,4(r11)
next_block = _Heap_Block_at( block, size );
next_block->prev_size = size;
ffc0ea0c: 7c e7 59 2e stwx r7,r7,r11
ffc0ea10: 48 00 00 4c b ffc0ea5c <_Heap_Free+0x1e0>
} 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;
ffc0ea14: 61 00 00 01 ori r0,r8,1
RTEMS_INLINE_ROUTINE void _Heap_Free_list_insert_after(
Heap_Block *block_before,
Heap_Block *new_block
)
{
Heap_Block *next = block_before->next;
ffc0ea18: 80 e9 00 08 lwz r7,8(r9)
ffc0ea1c: 90 0b 00 04 stw r0,4(r11)
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
ffc0ea20: 80 0a 00 04 lwz r0,4(r10)
new_block->next = next;
ffc0ea24: 90 eb 00 08 stw r7,8(r11)
ffc0ea28: 54 00 00 3c rlwinm r0,r0,0,0,30
new_block->prev = block_before;
ffc0ea2c: 91 2b 00 0c stw r9,12(r11)
next_block->prev_size = block_size;
ffc0ea30: 7d 08 59 2e stwx r8,r8,r11
block_before->next = new_block;
next->prev = new_block;
ffc0ea34: 91 67 00 0c stw r11,12(r7)
{
Heap_Block *next = block_before->next;
new_block->next = next;
new_block->prev = block_before;
block_before->next = new_block;
ffc0ea38: 91 69 00 08 stw r11,8(r9)
/* Statistics */
++stats->free_blocks;
ffc0ea3c: 81 69 00 38 lwz r11,56(r9)
} 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;
ffc0ea40: 90 0a 00 04 stw r0,4(r10)
next_block->prev_size = block_size;
/* Statistics */
++stats->free_blocks;
ffc0ea44: 38 0b 00 01 addi r0,r11,1
if ( stats->max_free_blocks < stats->free_blocks ) {
ffc0ea48: 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;
ffc0ea4c: 90 09 00 38 stw r0,56(r9)
if ( stats->max_free_blocks < stats->free_blocks ) {
ffc0ea50: 7f 8b 00 40 cmplw cr7,r11,r0
ffc0ea54: 40 9c 00 08 bge- cr7,ffc0ea5c <_Heap_Free+0x1e0>
stats->max_free_blocks = stats->free_blocks;
ffc0ea58: 90 09 00 3c stw r0,60(r9)
}
}
/* Statistics */
--stats->used_blocks;
ffc0ea5c: 81 69 00 40 lwz r11,64(r9)
++stats->frees;
stats->free_size += block_size;
return( true );
ffc0ea60: 38 60 00 01 li r3,1
stats->max_free_blocks = stats->free_blocks;
}
}
/* Statistics */
--stats->used_blocks;
ffc0ea64: 38 0b ff ff addi r0,r11,-1
++stats->frees;
ffc0ea68: 81 69 00 50 lwz r11,80(r9)
stats->max_free_blocks = stats->free_blocks;
}
}
/* Statistics */
--stats->used_blocks;
ffc0ea6c: 90 09 00 40 stw r0,64(r9)
++stats->frees;
ffc0ea70: 38 0b 00 01 addi r0,r11,1
ffc0ea74: 90 09 00 50 stw r0,80(r9)
stats->free_size += block_size;
ffc0ea78: 80 09 00 30 lwz r0,48(r9)
ffc0ea7c: 7d 00 42 14 add r8,r0,r8
ffc0ea80: 91 09 00 30 stw r8,48(r9)
return( true );
}
ffc0ea84: 39 61 00 10 addi r11,r1,16
ffc0ea88: 4b ff 1a bc b ffc00544 <_restgpr_31_x>
ffc1c324 <_Heap_Size_of_alloc_area>:
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(
uintptr_t value,
uintptr_t alignment
)
{
return value - (value % alignment);
ffc1c324: 80 03 00 10 lwz r0,16(r3)
bool _Heap_Size_of_alloc_area(
Heap_Control *heap,
void *alloc_begin_ptr,
uintptr_t *alloc_size
)
{
ffc1c328: 7c 69 1b 78 mr r9,r3
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
ffc1c32c: 81 03 00 20 lwz r8,32(r3)
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(
uintptr_t value,
uintptr_t alignment
)
{
return value - (value % alignment);
ffc1c330: 7d 44 03 96 divwu r10,r4,r0
ffc1c334: 7d 4a 01 d6 mullw r10,r10,r0
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;
ffc1c338: 38 00 00 00 li r0,0
uintptr_t alloc_begin,
uintptr_t page_size
)
{
return (Heap_Block *) (_Heap_Align_down( alloc_begin, page_size )
- HEAP_BLOCK_HEADER_SIZE);
ffc1c33c: 39 4a ff f8 addi r10,r10,-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;
ffc1c340: 7f 8a 40 40 cmplw cr7,r10,r8
ffc1c344: 41 9c 00 14 blt- cr7,ffc1c358 <_Heap_Size_of_alloc_area+0x34>
ffc1c348: 80 03 00 24 lwz r0,36(r3)
ffc1c34c: 7c 0a 00 10 subfc r0,r10,r0
ffc1c350: 38 00 00 00 li r0,0
ffc1c354: 7c 00 01 14 adde r0,r0,r0
uintptr_t const alloc_begin = (uintptr_t) alloc_begin_ptr;
Heap_Block *block = _Heap_Block_of_alloc_area( alloc_begin, page_size );
Heap_Block *next_block = NULL;
uintptr_t block_size = 0;
if ( !_Heap_Is_block_in_heap( heap, block ) ) {
ffc1c358: 2f 80 00 00 cmpwi cr7,r0,0
return false;
ffc1c35c: 38 60 00 00 li r3,0
uintptr_t const alloc_begin = (uintptr_t) alloc_begin_ptr;
Heap_Block *block = _Heap_Block_of_alloc_area( alloc_begin, page_size );
Heap_Block *next_block = NULL;
uintptr_t block_size = 0;
if ( !_Heap_Is_block_in_heap( heap, block ) ) {
ffc1c360: 4d 9e 00 20 beqlr cr7
- 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;
ffc1c364: 81 6a 00 04 lwz r11,4(r10)
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;
ffc1c368: 38 00 00 00 li r0,0
- 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;
ffc1c36c: 55 6b 00 3c rlwinm r11,r11,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);
ffc1c370: 7d 6b 52 14 add r11,r11,r10
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;
ffc1c374: 7f 8b 40 40 cmplw cr7,r11,r8
ffc1c378: 41 9c 00 14 blt- cr7,ffc1c38c <_Heap_Size_of_alloc_area+0x68><== NEVER TAKEN
ffc1c37c: 80 09 00 24 lwz r0,36(r9)
ffc1c380: 7c 0b 00 10 subfc r0,r11,r0
ffc1c384: 38 00 00 00 li r0,0
ffc1c388: 7c 00 01 14 adde r0,r0,r0
}
block_size = _Heap_Block_size( block );
next_block = _Heap_Block_at( block, block_size );
if (
ffc1c38c: 2f 80 00 00 cmpwi cr7,r0,0
!_Heap_Is_block_in_heap( heap, next_block )
|| !_Heap_Is_prev_used( next_block )
) {
return false;
ffc1c390: 38 60 00 00 li r3,0
}
block_size = _Heap_Block_size( block );
next_block = _Heap_Block_at( block, block_size );
if (
ffc1c394: 4d 9e 00 20 beqlr cr7
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;
ffc1c398: 80 0b 00 04 lwz r0,4(r11)
!_Heap_Is_block_in_heap( heap, next_block )
|| !_Heap_Is_prev_used( next_block )
ffc1c39c: 70 09 00 01 andi. r9,r0,1
ffc1c3a0: 4d 82 00 20 beqlr
) {
return false;
}
*alloc_size = (uintptr_t) next_block + HEAP_ALLOC_BONUS - alloc_begin;
ffc1c3a4: 20 84 00 04 subfic r4,r4,4
ffc1c3a8: 7d 64 5a 14 add r11,r4,r11
ffc1c3ac: 91 65 00 00 stw r11,0(r5)
return true;
ffc1c3b0: 38 60 00 01 li r3,1
}
ffc1c3b4: 4e 80 00 20 blr
ffc09cc0 <_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;
ffc09cc0: 2f 85 00 00 cmpwi cr7,r5,0
bool _Heap_Walk(
Heap_Control *heap,
int source,
bool dump
)
{
ffc09cc4: 94 21 ff 98 stwu r1,-104(r1)
ffc09cc8: 7c 08 02 a6 mflr r0
ffc09ccc: bd c1 00 20 stmw r14,32(r1)
ffc09cd0: 7c 7e 1b 78 mr r30,r3
ffc09cd4: 7c 9f 23 78 mr r31,r4
ffc09cd8: 90 01 00 6c stw r0,108(r1)
uintptr_t const page_size = heap->page_size;
ffc09cdc: 83 43 00 10 lwz r26,16(r3)
uintptr_t const min_block_size = heap->min_block_size;
ffc09ce0: 83 23 00 14 lwz r25,20(r3)
Heap_Block *const first_block = heap->first_block;
ffc09ce4: 83 03 00 20 lwz r24,32(r3)
Heap_Block *const last_block = heap->last_block;
ffc09ce8: 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;
ffc09cec: 41 9e 00 10 beq- cr7,ffc09cfc <_Heap_Walk+0x3c>
ffc09cf0: 3d 20 ff c1 lis r9,-63
ffc09cf4: 39 29 9c 10 addi r9,r9,-25584
ffc09cf8: 48 00 00 0c b ffc09d04 <_Heap_Walk+0x44>
ffc09cfc: 3d 20 ff c1 lis r9,-63
ffc09d00: 39 29 9c 0c addi r9,r9,-25588
ffc09d04: 91 21 00 18 stw r9,24(r1)
if ( !_System_state_Is_up( _System_state_Get() ) ) {
ffc09d08: 3d 20 00 00 lis r9,0
return true;
ffc09d0c: 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() ) ) {
ffc09d10: 80 09 28 24 lwz r0,10276(r9)
ffc09d14: 2f 80 00 03 cmpwi cr7,r0,3
ffc09d18: 40 be 04 bc bne+ cr7,ffc0a1d4 <_Heap_Walk+0x514>
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)(
ffc09d1c: 80 1e 00 08 lwz r0,8(r30)
ffc09d20: 3c a0 ff c2 lis r5,-62
ffc09d24: 81 1e 00 18 lwz r8,24(r30)
ffc09d28: 7f e3 fb 78 mr r3,r31
ffc09d2c: 90 01 00 0c stw r0,12(r1)
ffc09d30: 38 80 00 00 li r4,0
ffc09d34: 38 a5 84 d9 addi r5,r5,-31527
ffc09d38: 80 1e 00 0c lwz r0,12(r30)
ffc09d3c: 7f 46 d3 78 mr r6,r26
ffc09d40: 81 3e 00 1c lwz r9,28(r30)
ffc09d44: 7f 27 cb 78 mr r7,r25
ffc09d48: 90 01 00 10 stw r0,16(r1)
ffc09d4c: 7f 0a c3 78 mr r10,r24
ffc09d50: 80 01 00 18 lwz r0,24(r1)
ffc09d54: 92 e1 00 08 stw r23,8(r1)
ffc09d58: 7c 09 03 a6 mtctr r0
ffc09d5c: 4c c6 31 82 crclr 4*cr1+eq
ffc09d60: 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 ) {
ffc09d64: 2f 9a 00 00 cmpwi cr7,r26,0
ffc09d68: 40 be 00 18 bne+ cr7,ffc09d80 <_Heap_Walk+0xc0>
(*printer)( source, true, "page size is zero\n" );
ffc09d6c: 3c a0 ff c2 lis r5,-62
ffc09d70: 7f e3 fb 78 mr r3,r31
ffc09d74: 38 80 00 01 li r4,1
ffc09d78: 38 a5 85 6a addi r5,r5,-31382
ffc09d7c: 48 00 00 c0 b ffc09e3c <_Heap_Walk+0x17c>
return false;
}
if ( !_Addresses_Is_aligned( (void *) page_size ) ) {
ffc09d80: 73 49 00 07 andi. r9,r26,7
ffc09d84: 41 a2 00 1c beq+ ffc09da0 <_Heap_Walk+0xe0>
(*printer)(
ffc09d88: 3c a0 ff c2 lis r5,-62
ffc09d8c: 7f e3 fb 78 mr r3,r31
ffc09d90: 38 80 00 01 li r4,1
ffc09d94: 38 a5 85 7d addi r5,r5,-31363
ffc09d98: 7f 46 d3 78 mr r6,r26
ffc09d9c: 48 00 04 54 b ffc0a1f0 <_Heap_Walk+0x530>
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
ffc09da0: 7c 19 d3 96 divwu r0,r25,r26
ffc09da4: 7c 00 d1 d6 mullw r0,r0,r26
);
return false;
}
if ( !_Heap_Is_aligned( min_block_size, page_size ) ) {
ffc09da8: 7f 99 00 00 cmpw cr7,r25,r0
ffc09dac: 41 be 00 1c beq+ cr7,ffc09dc8 <_Heap_Walk+0x108>
(*printer)(
ffc09db0: 3c a0 ff c2 lis r5,-62
ffc09db4: 7f e3 fb 78 mr r3,r31
ffc09db8: 38 80 00 01 li r4,1
ffc09dbc: 38 a5 85 9b addi r5,r5,-31333
ffc09dc0: 7f 26 cb 78 mr r6,r25
ffc09dc4: 48 00 04 2c b ffc0a1f0 <_Heap_Walk+0x530>
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Alloc_area_of_block(
const Heap_Block *block
)
{
return (uintptr_t) block + HEAP_BLOCK_HEADER_SIZE;
ffc09dc8: 38 18 00 08 addi r0,r24,8
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
ffc09dcc: 7d 20 d3 96 divwu r9,r0,r26
ffc09dd0: 7d 29 d1 d6 mullw r9,r9,r26
);
return false;
}
if (
ffc09dd4: 7f 80 48 00 cmpw cr7,r0,r9
ffc09dd8: 41 be 00 1c beq+ cr7,ffc09df4 <_Heap_Walk+0x134>
!_Heap_Is_aligned( _Heap_Alloc_area_of_block( first_block ), page_size )
) {
(*printer)(
ffc09ddc: 3c a0 ff c2 lis r5,-62
ffc09de0: 7f e3 fb 78 mr r3,r31
ffc09de4: 38 80 00 01 li r4,1
ffc09de8: 38 a5 85 bf addi r5,r5,-31297
ffc09dec: 7f 06 c3 78 mr r6,r24
ffc09df0: 48 00 04 00 b ffc0a1f0 <_Heap_Walk+0x530>
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;
ffc09df4: 80 18 00 04 lwz r0,4(r24)
);
return false;
}
if ( !_Heap_Is_prev_used( first_block ) ) {
ffc09df8: 70 09 00 01 andi. r9,r0,1
ffc09dfc: 40 a2 00 18 bne+ ffc09e14 <_Heap_Walk+0x154>
(*printer)(
ffc09e00: 3c a0 ff c2 lis r5,-62
ffc09e04: 7f e3 fb 78 mr r3,r31
ffc09e08: 38 80 00 01 li r4,1
ffc09e0c: 38 a5 85 f0 addi r5,r5,-31248
ffc09e10: 48 00 00 2c b ffc09e3c <_Heap_Walk+0x17c>
- 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;
ffc09e14: 83 b7 00 04 lwz r29,4(r23)
ffc09e18: 57 bd 00 3c rlwinm r29,r29,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);
ffc09e1c: 7f b7 ea 14 add r29,r23,r29
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;
ffc09e20: 80 1d 00 04 lwz r0,4(r29)
);
return false;
}
if ( _Heap_Is_free( last_block ) ) {
ffc09e24: 70 09 00 01 andi. r9,r0,1
ffc09e28: 40 a2 00 28 bne+ ffc09e50 <_Heap_Walk+0x190>
(*printer)(
ffc09e2c: 3c a0 ff c2 lis r5,-62
ffc09e30: 7f e3 fb 78 mr r3,r31
ffc09e34: 38 80 00 01 li r4,1
ffc09e38: 38 a5 86 1e addi r5,r5,-31202
ffc09e3c: 80 01 00 18 lwz r0,24(r1)
ffc09e40: 7c 09 03 a6 mtctr r0
ffc09e44: 4c c6 31 82 crclr 4*cr1+eq
ffc09e48: 4e 80 04 21 bctrl
ffc09e4c: 48 00 00 ec b ffc09f38 <_Heap_Walk+0x278>
);
return false;
}
if (
ffc09e50: 7f 9d c0 00 cmpw cr7,r29,r24
ffc09e54: 41 9e 00 18 beq- cr7,ffc09e6c <_Heap_Walk+0x1ac>
_Heap_Block_at( last_block, _Heap_Block_size( last_block ) ) != first_block
) {
(*printer)(
ffc09e58: 3c a0 ff c2 lis r5,-62
ffc09e5c: 7f e3 fb 78 mr r3,r31
ffc09e60: 38 80 00 01 li r4,1
ffc09e64: 38 a5 86 33 addi r5,r5,-31181
ffc09e68: 4b ff ff d4 b ffc09e3c <_Heap_Walk+0x17c>
int source,
Heap_Walk_printer printer,
Heap_Control *heap
)
{
uintptr_t const page_size = heap->page_size;
ffc09e6c: 81 3e 00 10 lwz r9,16(r30)
const Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap );
ffc09e70: 7f c0 f3 78 mr r0,r30
return &heap->free_list;
}
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Free_list_first( Heap_Control *heap )
{
return _Heap_Free_list_head(heap)->next;
ffc09e74: 80 de 00 08 lwz r6,8(r30)
ffc09e78: 48 00 00 d0 b ffc09f48 <_Heap_Walk+0x288>
const Heap_Control *heap,
const Heap_Block *block
)
{
return (uintptr_t) block >= (uintptr_t) heap->first_block
&& (uintptr_t) block <= (uintptr_t) heap->last_block;
ffc09e7c: 81 5e 00 20 lwz r10,32(r30)
ffc09e80: 39 60 00 00 li r11,0
ffc09e84: 7f 8a 30 40 cmplw cr7,r10,r6
ffc09e88: 41 9d 00 14 bgt- cr7,ffc09e9c <_Heap_Walk+0x1dc>
ffc09e8c: 81 7e 00 24 lwz r11,36(r30)
ffc09e90: 7d 66 58 10 subfc r11,r6,r11
ffc09e94: 39 60 00 00 li r11,0
ffc09e98: 7d 6b 59 14 adde r11,r11,r11
const Heap_Block *const first_free_block = _Heap_Free_list_first( heap );
const Heap_Block *prev_block = free_list_tail;
const Heap_Block *free_block = first_free_block;
while ( free_block != free_list_tail ) {
if ( !_Heap_Is_block_in_heap( heap, free_block ) ) {
ffc09e9c: 2f 8b 00 00 cmpwi cr7,r11,0
ffc09ea0: 40 be 00 18 bne+ cr7,ffc09eb8 <_Heap_Walk+0x1f8>
(*printer)(
ffc09ea4: 3c a0 ff c2 lis r5,-62
ffc09ea8: 7f e3 fb 78 mr r3,r31
ffc09eac: 38 80 00 01 li r4,1
ffc09eb0: 38 a5 86 62 addi r5,r5,-31134
ffc09eb4: 48 00 03 3c b ffc0a1f0 <_Heap_Walk+0x530>
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Alloc_area_of_block(
const Heap_Block *block
)
{
return (uintptr_t) block + HEAP_BLOCK_HEADER_SIZE;
ffc09eb8: 39 66 00 08 addi r11,r6,8
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
ffc09ebc: 7d 4b 4b 96 divwu r10,r11,r9
ffc09ec0: 7d 4a 49 d6 mullw r10,r10,r9
);
return false;
}
if (
ffc09ec4: 7f 8b 50 00 cmpw cr7,r11,r10
ffc09ec8: 41 be 00 18 beq+ cr7,ffc09ee0 <_Heap_Walk+0x220>
!_Heap_Is_aligned( _Heap_Alloc_area_of_block( free_block ), page_size )
) {
(*printer)(
ffc09ecc: 3c a0 ff c2 lis r5,-62
ffc09ed0: 7f e3 fb 78 mr r3,r31
ffc09ed4: 38 80 00 01 li r4,1
ffc09ed8: 38 a5 86 82 addi r5,r5,-31102
ffc09edc: 48 00 03 14 b ffc0a1f0 <_Heap_Walk+0x530>
- 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;
ffc09ee0: 81 66 00 04 lwz r11,4(r6)
ffc09ee4: 55 6b 00 3c rlwinm r11,r11,0,0,30
block = next_block;
} while ( block != first_block );
return true;
}
ffc09ee8: 7d 66 5a 14 add r11,r6,r11
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;
ffc09eec: 81 6b 00 04 lwz r11,4(r11)
);
return false;
}
if ( _Heap_Is_used( free_block ) ) {
ffc09ef0: 71 6a 00 01 andi. r10,r11,1
ffc09ef4: 41 a2 00 18 beq+ ffc09f0c <_Heap_Walk+0x24c>
(*printer)(
ffc09ef8: 3c a0 ff c2 lis r5,-62
ffc09efc: 7f e3 fb 78 mr r3,r31
ffc09f00: 38 80 00 01 li r4,1
ffc09f04: 38 a5 86 b2 addi r5,r5,-31054
ffc09f08: 48 00 02 e8 b ffc0a1f0 <_Heap_Walk+0x530>
);
return false;
}
if ( free_block->prev != prev_block ) {
ffc09f0c: 80 e6 00 0c lwz r7,12(r6)
ffc09f10: 7f 87 00 00 cmpw cr7,r7,r0
ffc09f14: 41 be 00 2c beq+ cr7,ffc09f40 <_Heap_Walk+0x280>
(*printer)(
ffc09f18: 3c a0 ff c2 lis r5,-62
ffc09f1c: 7f e3 fb 78 mr r3,r31
ffc09f20: 38 80 00 01 li r4,1
ffc09f24: 38 a5 86 ce addi r5,r5,-31026
ffc09f28: 80 01 00 18 lwz r0,24(r1)
ffc09f2c: 7c 09 03 a6 mtctr r0
ffc09f30: 4c c6 31 82 crclr 4*cr1+eq
ffc09f34: 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;
ffc09f38: 38 60 00 00 li r3,0
ffc09f3c: 48 00 02 98 b ffc0a1d4 <_Heap_Walk+0x514>
return false;
}
prev_block = free_block;
free_block = free_block->next;
ffc09f40: 7c c0 33 78 mr r0,r6
ffc09f44: 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 ) {
ffc09f48: 7f 86 f0 00 cmpw cr7,r6,r30
ffc09f4c: 40 9e ff 30 bne+ cr7,ffc09e7c <_Heap_Walk+0x1bc>
ffc09f50: 48 00 00 0c b ffc09f5c <_Heap_Walk+0x29c>
block->prev_size
);
}
block = next_block;
} while ( block != first_block );
ffc09f54: 7f 7d db 78 mr r29,r27
ffc09f58: 48 00 00 30 b ffc09f88 <_Heap_Walk+0x2c8>
"block 0x%08x: size %u\n",
block,
block_size
);
} else {
(*printer)(
ffc09f5c: 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)(
ffc09f60: 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)(
ffc09f64: 3e 40 ff c2 lis r18,-62
"block 0x%08x: size %u\n",
block,
block_size
);
} else {
(*printer)(
ffc09f68: 3a 73 88 6e addi r19,r19,-30610
if ( !_Heap_Is_prev_used( next_block ) ) {
if ( !_Heap_Walk_check_free_block( source, printer, heap, block ) ) {
return false;
}
} else if (prev_used) {
(*printer)(
ffc09f6c: 3a 94 88 57 addi r20,r20,-30633
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)(
ffc09f70: 3a 52 87 ba addi r18,r18,-30790
ffc09f74: 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)" : "")
ffc09f78: 3e c0 ff c2 lis r22,-62
ffc09f7c: 3e 00 ff c2 lis r16,-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)(
ffc09f80: 3d e0 ff c2 lis r15,-62
block,
block_size,
block->prev,
block->prev == first_free_block ?
" (= first free)"
: (block->prev == free_list_head ? " (= head)" : ""),
ffc09f84: 3d c0 ff c2 lis r14,-62
block = next_block;
} while ( block != first_block );
return true;
}
ffc09f88: 82 bd 00 04 lwz r21,4(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;
ffc09f8c: 38 00 00 00 li r0,0
ffc09f90: 81 3e 00 20 lwz r9,32(r30)
- 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;
ffc09f94: 56 bc 00 3c rlwinm r28,r21,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);
ffc09f98: 7f 7c ea 14 add r27,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;
ffc09f9c: 7f 89 d8 40 cmplw cr7,r9,r27
ffc09fa0: 41 9d 00 14 bgt- cr7,ffc09fb4 <_Heap_Walk+0x2f4> <== NEVER TAKEN
ffc09fa4: 80 1e 00 24 lwz r0,36(r30)
ffc09fa8: 7c 1b 00 10 subfc r0,r27,r0
ffc09fac: 38 00 00 00 li r0,0
ffc09fb0: 7c 00 01 14 adde r0,r0,r0
bool const prev_used = _Heap_Is_prev_used( block );
Heap_Block *const next_block = _Heap_Block_at( block, block_size );
uintptr_t const next_block_begin = (uintptr_t) next_block;
bool const is_not_last_block = block != last_block;
if ( !_Heap_Is_block_in_heap( heap, next_block ) ) {
ffc09fb4: 2f 80 00 00 cmpwi cr7,r0,0
ffc09fb8: 40 be 00 18 bne+ cr7,ffc09fd0 <_Heap_Walk+0x310>
(*printer)(
ffc09fbc: 3c a0 ff c2 lis r5,-62
ffc09fc0: 7f e3 fb 78 mr r3,r31
ffc09fc4: 38 80 00 01 li r4,1
ffc09fc8: 38 a5 87 00 addi r5,r5,-30976
ffc09fcc: 48 00 00 a8 b ffc0a074 <_Heap_Walk+0x3b4>
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
ffc09fd0: 7d 3c d3 96 divwu r9,r28,r26
ffc09fd4: 7d 29 d1 d6 mullw r9,r9,r26
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;
ffc09fd8: 7f a0 ba 78 xor r0,r29,r23
);
return false;
}
if ( !_Heap_Is_aligned( block_size, page_size ) && is_not_last_block ) {
ffc09fdc: 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;
ffc09fe0: 7c 00 00 34 cntlzw r0,r0
ffc09fe4: 54 00 d9 7e rlwinm r0,r0,27,5,31
ffc09fe8: 68 00 00 01 xori r0,r0,1
);
return false;
}
if ( !_Heap_Is_aligned( block_size, page_size ) && is_not_last_block ) {
ffc09fec: 41 9e 00 28 beq- cr7,ffc0a014 <_Heap_Walk+0x354>
ffc09ff0: 2f 80 00 00 cmpwi cr7,r0,0
ffc09ff4: 41 be 00 20 beq+ cr7,ffc0a014 <_Heap_Walk+0x354>
(*printer)(
ffc09ff8: 3c a0 ff c2 lis r5,-62
ffc09ffc: 7f e3 fb 78 mr r3,r31
ffc0a000: 38 80 00 01 li r4,1
ffc0a004: 38 a5 87 2d addi r5,r5,-30931
ffc0a008: 7f a6 eb 78 mr r6,r29
ffc0a00c: 7f 87 e3 78 mr r7,r28
ffc0a010: 4b ff ff 18 b ffc09f28 <_Heap_Walk+0x268>
);
return false;
}
if ( block_size < min_block_size && is_not_last_block ) {
ffc0a014: 7f 9c c8 40 cmplw cr7,r28,r25
ffc0a018: 40 9c 00 3c bge- cr7,ffc0a054 <_Heap_Walk+0x394>
ffc0a01c: 2f 80 00 00 cmpwi cr7,r0,0
ffc0a020: 41 be 00 34 beq+ cr7,ffc0a054 <_Heap_Walk+0x394> <== NEVER TAKEN
(*printer)(
ffc0a024: 80 01 00 18 lwz r0,24(r1)
ffc0a028: 3c a0 ff c2 lis r5,-62
ffc0a02c: 7f e3 fb 78 mr r3,r31
ffc0a030: 38 80 00 01 li r4,1
ffc0a034: 7c 09 03 a6 mtctr r0
ffc0a038: 38 a5 87 5b addi r5,r5,-30885
ffc0a03c: 7f a6 eb 78 mr r6,r29
ffc0a040: 7f 87 e3 78 mr r7,r28
ffc0a044: 7f 28 cb 78 mr r8,r25
ffc0a048: 4c c6 31 82 crclr 4*cr1+eq
ffc0a04c: 4e 80 04 21 bctrl
ffc0a050: 4b ff fe e8 b ffc09f38 <_Heap_Walk+0x278>
);
return false;
}
if ( next_block_begin <= block_begin && is_not_last_block ) {
ffc0a054: 7f 9b e8 40 cmplw cr7,r27,r29
ffc0a058: 41 9d 00 28 bgt- cr7,ffc0a080 <_Heap_Walk+0x3c0>
ffc0a05c: 2f 80 00 00 cmpwi cr7,r0,0
ffc0a060: 41 be 00 20 beq+ cr7,ffc0a080 <_Heap_Walk+0x3c0>
(*printer)(
ffc0a064: 3c a0 ff c2 lis r5,-62
ffc0a068: 7f e3 fb 78 mr r3,r31
ffc0a06c: 38 80 00 01 li r4,1
ffc0a070: 38 a5 87 86 addi r5,r5,-30842
ffc0a074: 7f a6 eb 78 mr r6,r29
ffc0a078: 7f 67 db 78 mr r7,r27
ffc0a07c: 4b ff fe ac b ffc09f28 <_Heap_Walk+0x268>
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;
ffc0a080: 80 1b 00 04 lwz r0,4(r27)
ffc0a084: 56 b5 07 fe clrlwi r21,r21,31
);
return false;
}
if ( !_Heap_Is_prev_used( next_block ) ) {
ffc0a088: 70 09 00 01 andi. r9,r0,1
ffc0a08c: 40 a2 00 ec bne+ ffc0a178 <_Heap_Walk+0x4b8>
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 ?
ffc0a090: 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)(
ffc0a094: 39 2f 84 a6 addi r9,r15,-31578
ffc0a098: 80 1e 00 08 lwz r0,8(r30)
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;
ffc0a09c: 81 7e 00 0c lwz r11,12(r30)
ffc0a0a0: 7f 88 00 00 cmpw cr7,r8,r0
ffc0a0a4: 41 9e 00 14 beq- cr7,ffc0a0b8 <_Heap_Walk+0x3f8>
block,
block_size,
block->prev,
block->prev == first_free_block ?
" (= first free)"
: (block->prev == free_list_head ? " (= head)" : ""),
ffc0a0a8: 7f 88 f0 00 cmpw cr7,r8,r30
ffc0a0ac: 39 36 83 eb addi r9,r22,-31765
ffc0a0b0: 40 be 00 08 bne+ cr7,ffc0a0b8 <_Heap_Walk+0x3f8>
ffc0a0b4: 39 2e 84 b6 addi r9,r14,-31562
block->next,
block->next == last_free_block ?
ffc0a0b8: 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)(
ffc0a0bc: 38 11 84 c0 addi r0,r17,-31552
ffc0a0c0: 7f 8a 58 00 cmpw cr7,r10,r11
ffc0a0c4: 41 9e 00 14 beq- cr7,ffc0a0d8 <_Heap_Walk+0x418>
" (= first free)"
: (block->prev == free_list_head ? " (= head)" : ""),
block->next,
block->next == last_free_block ?
" (= last free)"
: (block->next == free_list_tail ? " (= tail)" : "")
ffc0a0c8: 7f 8a f0 00 cmpw cr7,r10,r30
ffc0a0cc: 38 16 83 eb addi r0,r22,-31765
ffc0a0d0: 40 be 00 08 bne+ cr7,ffc0a0d8 <_Heap_Walk+0x418>
ffc0a0d4: 38 10 84 cf addi r0,r16,-31537
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)(
ffc0a0d8: 90 01 00 08 stw r0,8(r1)
ffc0a0dc: 7f e3 fb 78 mr r3,r31
ffc0a0e0: 38 80 00 00 li r4,0
ffc0a0e4: 80 01 00 18 lwz r0,24(r1)
ffc0a0e8: 7e 45 93 78 mr r5,r18
ffc0a0ec: 7f a6 eb 78 mr r6,r29
ffc0a0f0: 7f 87 e3 78 mr r7,r28
ffc0a0f4: 7c 09 03 a6 mtctr r0
ffc0a0f8: 4c c6 31 82 crclr 4*cr1+eq
ffc0a0fc: 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 ) {
ffc0a100: 81 1b 00 00 lwz r8,0(r27)
ffc0a104: 7f 9c 40 00 cmpw cr7,r28,r8
ffc0a108: 41 be 00 34 beq+ cr7,ffc0a13c <_Heap_Walk+0x47c>
(*printer)(
ffc0a10c: 80 01 00 18 lwz r0,24(r1)
ffc0a110: 3c a0 ff c2 lis r5,-62
ffc0a114: 7f e3 fb 78 mr r3,r31
ffc0a118: 38 80 00 01 li r4,1
ffc0a11c: 7c 09 03 a6 mtctr r0
ffc0a120: 38 a5 87 ef addi r5,r5,-30737
ffc0a124: 7f a6 eb 78 mr r6,r29
ffc0a128: 7f 87 e3 78 mr r7,r28
ffc0a12c: 7f 69 db 78 mr r9,r27
ffc0a130: 4c c6 31 82 crclr 4*cr1+eq
ffc0a134: 4e 80 04 21 bctrl
ffc0a138: 4b ff fe 00 b ffc09f38 <_Heap_Walk+0x278>
);
return false;
}
if ( !prev_used ) {
ffc0a13c: 2f 95 00 00 cmpwi cr7,r21,0
ffc0a140: 40 be 00 18 bne+ cr7,ffc0a158 <_Heap_Walk+0x498>
(*printer)(
ffc0a144: 3c a0 ff c2 lis r5,-62
ffc0a148: 7f e3 fb 78 mr r3,r31
ffc0a14c: 38 80 00 01 li r4,1
ffc0a150: 38 a5 88 28 addi r5,r5,-30680
ffc0a154: 48 00 00 98 b ffc0a1ec <_Heap_Walk+0x52c>
return &heap->free_list;
}
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Free_list_first( Heap_Control *heap )
{
return _Heap_Free_list_head(heap)->next;
ffc0a158: 81 3e 00 08 lwz r9,8(r30)
ffc0a15c: 48 00 00 10 b ffc0a16c <_Heap_Walk+0x4ac>
{
const Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap );
const Heap_Block *free_block = _Heap_Free_list_first( heap );
while ( free_block != free_list_tail ) {
if ( free_block == block ) {
ffc0a160: 7f 89 e8 00 cmpw cr7,r9,r29
ffc0a164: 41 9e 00 64 beq- cr7,ffc0a1c8 <_Heap_Walk+0x508>
return true;
}
free_block = free_block->next;
ffc0a168: 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 ) {
ffc0a16c: 7f 89 f0 00 cmpw cr7,r9,r30
ffc0a170: 40 9e ff f0 bne+ cr7,ffc0a160 <_Heap_Walk+0x4a0>
ffc0a174: 48 00 00 68 b ffc0a1dc <_Heap_Walk+0x51c>
if ( !_Heap_Is_prev_used( next_block ) ) {
if ( !_Heap_Walk_check_free_block( source, printer, heap, block ) ) {
return false;
}
} else if (prev_used) {
ffc0a178: 2f 95 00 00 cmpwi cr7,r21,0
(*printer)(
ffc0a17c: 7f e3 fb 78 mr r3,r31
ffc0a180: 38 80 00 00 li r4,0
if ( !_Heap_Is_prev_used( next_block ) ) {
if ( !_Heap_Walk_check_free_block( source, printer, heap, block ) ) {
return false;
}
} else if (prev_used) {
ffc0a184: 41 9e 00 24 beq- cr7,ffc0a1a8 <_Heap_Walk+0x4e8>
(*printer)(
ffc0a188: 80 01 00 18 lwz r0,24(r1)
ffc0a18c: 7e 85 a3 78 mr r5,r20
ffc0a190: 7f a6 eb 78 mr r6,r29
ffc0a194: 7f 87 e3 78 mr r7,r28
ffc0a198: 7c 09 03 a6 mtctr r0
ffc0a19c: 4c c6 31 82 crclr 4*cr1+eq
ffc0a1a0: 4e 80 04 21 bctrl
ffc0a1a4: 48 00 00 24 b ffc0a1c8 <_Heap_Walk+0x508>
"block 0x%08x: size %u\n",
block,
block_size
);
} else {
(*printer)(
ffc0a1a8: 80 01 00 18 lwz r0,24(r1)
ffc0a1ac: 7e 65 9b 78 mr r5,r19
ffc0a1b0: 7f a6 eb 78 mr r6,r29
ffc0a1b4: 81 1d 00 00 lwz r8,0(r29)
ffc0a1b8: 7f 87 e3 78 mr r7,r28
ffc0a1bc: 7c 09 03 a6 mtctr r0
ffc0a1c0: 4c c6 31 82 crclr 4*cr1+eq
ffc0a1c4: 4e 80 04 21 bctrl
block->prev_size
);
}
block = next_block;
} while ( block != first_block );
ffc0a1c8: 7f 9b c0 00 cmpw cr7,r27,r24
ffc0a1cc: 40 9e fd 88 bne+ cr7,ffc09f54 <_Heap_Walk+0x294>
return true;
ffc0a1d0: 38 60 00 01 li r3,1
}
ffc0a1d4: 39 61 00 68 addi r11,r1,104
ffc0a1d8: 4b ff 69 24 b ffc00afc <_restgpr_14_x>
return false;
}
if ( !_Heap_Walk_is_in_free_list( heap, block ) ) {
(*printer)(
ffc0a1dc: 3c a0 ff c2 lis r5,-62
ffc0a1e0: 7f e3 fb 78 mr r3,r31
ffc0a1e4: 38 80 00 01 li r4,1
ffc0a1e8: 38 a5 88 93 addi r5,r5,-30573
ffc0a1ec: 7f a6 eb 78 mr r6,r29
ffc0a1f0: 80 01 00 18 lwz r0,24(r1)
ffc0a1f4: 7c 09 03 a6 mtctr r0
ffc0a1f8: 4c c6 31 82 crclr 4*cr1+eq
ffc0a1fc: 4e 80 04 21 bctrl
ffc0a200: 4b ff fd 38 b ffc09f38 <_Heap_Walk+0x278>
ffc09c10 <_Heap_Walk_print>:
static void _Heap_Walk_print( int source, bool error, const char *fmt, ... )
{
ffc09c10: 7c 08 02 a6 mflr r0
ffc09c14: 7c 2b 0b 78 mr r11,r1
ffc09c18: 94 21 ff 88 stwu r1,-120(r1)
ffc09c1c: 90 01 00 7c stw r0,124(r1)
ffc09c20: 4b ff 6e d5 bl ffc00af4 <_savegpr_31>
ffc09c24: 7c 60 1b 78 mr r0,r3
ffc09c28: 90 c1 00 1c stw r6,28(r1)
ffc09c2c: 90 e1 00 20 stw r7,32(r1)
ffc09c30: 91 01 00 24 stw r8,36(r1)
ffc09c34: 91 21 00 28 stw r9,40(r1)
ffc09c38: 91 41 00 2c stw r10,44(r1)
ffc09c3c: 40 86 00 24 bne- cr1,ffc09c60 <_Heap_Walk_print+0x50> <== ALWAYS TAKEN
ffc09c40: d8 21 00 30 stfd f1,48(r1) <== NOT EXECUTED
ffc09c44: d8 41 00 38 stfd f2,56(r1) <== NOT EXECUTED
ffc09c48: d8 61 00 40 stfd f3,64(r1) <== NOT EXECUTED
ffc09c4c: d8 81 00 48 stfd f4,72(r1) <== NOT EXECUTED
ffc09c50: d8 a1 00 50 stfd f5,80(r1) <== NOT EXECUTED
ffc09c54: d8 c1 00 58 stfd f6,88(r1) <== NOT EXECUTED
ffc09c58: d8 e1 00 60 stfd f7,96(r1) <== NOT EXECUTED
ffc09c5c: d9 01 00 68 stfd f8,104(r1) <== NOT EXECUTED
va_list ap;
if ( error ) {
ffc09c60: 2f 84 00 00 cmpwi cr7,r4,0
{
/* Do nothing */
}
static void _Heap_Walk_print( int source, bool error, const char *fmt, ... )
{
ffc09c64: 7c bf 2b 78 mr r31,r5
va_list ap;
if ( error ) {
ffc09c68: 41 be 00 10 beq+ cr7,ffc09c78 <_Heap_Walk_print+0x68>
printk( "FAIL[%d]: ", source );
ffc09c6c: 3c 60 ff c2 lis r3,-62
ffc09c70: 38 63 84 90 addi r3,r3,-31600
ffc09c74: 48 00 00 0c b ffc09c80 <_Heap_Walk_print+0x70>
} else {
printk( "PASS[%d]: ", source );
ffc09c78: 3c 60 ff c2 lis r3,-62
ffc09c7c: 38 63 84 9b addi r3,r3,-31589
ffc09c80: 7c 04 03 78 mr r4,r0
ffc09c84: 4c c6 31 82 crclr 4*cr1+eq
ffc09c88: 4b ff be 5d bl ffc05ae4 <printk>
}
va_start( ap, fmt );
ffc09c8c: 38 00 00 03 li r0,3
ffc09c90: 98 01 00 08 stb r0,8(r1)
ffc09c94: 38 00 00 00 li r0,0
vprintk( fmt, ap );
ffc09c98: 7f e3 fb 78 mr r3,r31
printk( "FAIL[%d]: ", source );
} else {
printk( "PASS[%d]: ", source );
}
va_start( ap, fmt );
ffc09c9c: 98 01 00 09 stb r0,9(r1)
ffc09ca0: 38 01 00 80 addi r0,r1,128
vprintk( fmt, ap );
ffc09ca4: 38 81 00 08 addi r4,r1,8
printk( "FAIL[%d]: ", source );
} else {
printk( "PASS[%d]: ", source );
}
va_start( ap, fmt );
ffc09ca8: 90 01 00 0c stw r0,12(r1)
ffc09cac: 38 01 00 10 addi r0,r1,16
ffc09cb0: 90 01 00 10 stw r0,16(r1)
vprintk( fmt, ap );
ffc09cb4: 4b ff db d1 bl ffc07884 <vprintk>
va_end( ap );
}
ffc09cb8: 39 61 00 78 addi r11,r1,120
ffc09cbc: 4b ff 6e 84 b ffc00b40 <_restgpr_31_x>
ffc09668 <_Internal_error_Occurred>:
void _Internal_error_Occurred(
Internal_errors_Source the_source,
bool is_internal,
Internal_errors_t the_error
)
{
ffc09668: 7c 2b 0b 78 mr r11,r1
ffc0966c: 94 21 ff f0 stwu r1,-16(r1)
ffc09670: 7c 08 02 a6 mflr r0
ffc09674: 48 01 1c d9 bl ffc1b34c <_savegpr_31>
_Internal_errors_What_happened.the_source = the_source;
ffc09678: 3d 60 00 00 lis r11,0
ffc0967c: 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
)
{
ffc09680: 90 01 00 14 stw r0,20(r1)
ffc09684: 7c bf 2b 78 mr r31,r5
_Internal_errors_What_happened.the_source = the_source;
_Internal_errors_What_happened.is_internal = is_internal;
ffc09688: 98 89 00 04 stb r4,4(r9)
_Internal_errors_What_happened.the_error = the_error;
ffc0968c: 90 a9 00 08 stw r5,8(r9)
bool is_internal,
Internal_errors_t the_error
)
{
_Internal_errors_What_happened.the_source = the_source;
ffc09690: 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 );
ffc09694: 48 00 21 bd bl ffc0b850 <_User_extensions_Fatal>
RTEMS_INLINE_ROUTINE void _System_state_Set (
System_state_Codes state
)
{
_System_state_Current = state;
ffc09698: 38 00 00 05 li r0,5
ffc0969c: 3d 20 00 00 lis r9,0
_System_state_Set( SYSTEM_STATE_FAILED );
_CPU_Fatal_halt( the_error );
ffc096a0: 7f e3 fb 78 mr r3,r31
ffc096a4: 90 09 28 48 stw r0,10312(r9)
ffc096a8: 4b ff a2 b9 bl ffc03960 <_BSP_Fatal_error>
ffc096ac: 48 00 00 00 b ffc096ac <_Internal_error_Occurred+0x44><== NOT EXECUTED
ffc096c4 <_Objects_Allocate>:
*/
Objects_Control *_Objects_Allocate(
Objects_Information *information
)
{
ffc096c4: 94 21 ff f0 stwu r1,-16(r1)
ffc096c8: 7c 08 02 a6 mflr r0
ffc096cc: 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 )
ffc096d0: 80 03 00 18 lwz r0,24(r3)
*/
Objects_Control *_Objects_Allocate(
Objects_Information *information
)
{
ffc096d4: bf c1 00 08 stmw r30,8(r1)
ffc096d8: 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 )
ffc096dc: 2f 80 00 00 cmpwi cr7,r0,0
return NULL;
ffc096e0: 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 )
ffc096e4: 41 9e 00 70 beq- cr7,ffc09754 <_Objects_Allocate+0x90> <== 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 );
ffc096e8: 3b df 00 20 addi r30,r31,32
ffc096ec: 7f c3 f3 78 mr r3,r30
ffc096f0: 4b ff f5 b1 bl ffc08ca0 <_Chain_Get>
if ( information->auto_extend ) {
ffc096f4: 88 1f 00 12 lbz r0,18(r31)
ffc096f8: 2f 80 00 00 cmpwi cr7,r0,0
ffc096fc: 41 9e 00 58 beq- cr7,ffc09754 <_Objects_Allocate+0x90>
/*
* If the list is empty then we are out of objects and need to
* extend information base.
*/
if ( !the_object ) {
ffc09700: 2f 83 00 00 cmpwi cr7,r3,0
ffc09704: 40 be 00 1c bne+ cr7,ffc09720 <_Objects_Allocate+0x5c>
_Objects_Extend_information( information );
ffc09708: 7f e3 fb 78 mr r3,r31
ffc0970c: 48 00 00 85 bl ffc09790 <_Objects_Extend_information>
the_object = (Objects_Control *) _Chain_Get( &information->Inactive );
ffc09710: 7f c3 f3 78 mr r3,r30
ffc09714: 4b ff f5 8d bl ffc08ca0 <_Chain_Get>
}
if ( the_object ) {
ffc09718: 2c 03 00 00 cmpwi r3,0
ffc0971c: 41 a2 00 38 beq+ ffc09754 <_Objects_Allocate+0x90>
uint32_t block;
block = (uint32_t) _Objects_Get_index( the_object->id ) -
ffc09720: a1 23 00 0a lhz r9,10(r3)
ffc09724: a0 1f 00 0a lhz r0,10(r31)
ffc09728: 7c 00 48 50 subf r0,r0,r9
_Objects_Get_index( information->minimum_id );
block /= information->allocation_size;
ffc0972c: a1 3f 00 14 lhz r9,20(r31)
ffc09730: 7c 00 4b 96 divwu r0,r0,r9
information->inactive_per_block[ block ]--;
ffc09734: 81 3f 00 30 lwz r9,48(r31)
ffc09738: 54 00 10 3a rlwinm r0,r0,2,0,29
ffc0973c: 7d 69 00 2e lwzx r11,r9,r0
ffc09740: 39 6b ff ff addi r11,r11,-1
ffc09744: 7d 69 01 2e stwx r11,r9,r0
information->inactive--;
ffc09748: a1 3f 00 2c lhz r9,44(r31)
ffc0974c: 38 09 ff ff addi r0,r9,-1
ffc09750: b0 1f 00 2c sth r0,44(r31)
);
}
#endif
return the_object;
}
ffc09754: 39 61 00 10 addi r11,r1,16
ffc09758: 4b ff 6d e8 b ffc00540 <_restgpr_30_x>
ffc09790 <_Objects_Extend_information>:
*/
void _Objects_Extend_information(
Objects_Information *information
)
{
ffc09790: 94 21 ff b8 stwu r1,-72(r1)
ffc09794: 7c 08 02 a6 mflr r0
ffc09798: 90 01 00 4c stw r0,76(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 )
ffc0979c: 81 63 00 34 lwz r11,52(r3)
*/
void _Objects_Extend_information(
Objects_Information *information
)
{
ffc097a0: be a1 00 1c stmw r21,28(r1)
ffc097a4: 7c 7f 1b 78 mr r31,r3
minimum_index = _Objects_Get_index( information->minimum_id );
index_base = minimum_index;
block = 0;
/* if ( information->maximum < minimum_index ) */
if ( information->object_blocks == NULL )
ffc097a8: 2f 8b 00 00 cmpwi cr7,r11,0
/*
* 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 );
ffc097ac: a3 83 00 0a lhz r28,10(r3)
index_base = minimum_index;
block = 0;
/* if ( information->maximum < minimum_index ) */
if ( information->object_blocks == NULL )
ffc097b0: 41 9e 00 58 beq- cr7,ffc09808 <_Objects_Extend_information+0x78>
block_count = 0;
else {
block_count = information->maximum / information->allocation_size;
ffc097b4: a1 43 00 14 lhz r10,20(r3)
for ( ; block < block_count; block++ ) {
ffc097b8: 39 20 00 00 li r9,0
/* if ( information->maximum < minimum_index ) */
if ( information->object_blocks == NULL )
block_count = 0;
else {
block_count = information->maximum / information->allocation_size;
ffc097bc: a3 63 00 10 lhz r27,16(r3)
* 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;
ffc097c0: 3b a0 00 00 li r29,0
/* if ( information->maximum < minimum_index ) */
if ( information->object_blocks == NULL )
block_count = 0;
else {
block_count = information->maximum / information->allocation_size;
ffc097c4: 7f 7b 53 96 divwu r27,r27,r10
ffc097c8: 2f 9b 00 00 cmpwi cr7,r27,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;
ffc097cc: 38 1b 00 01 addi r0,r27,1
ffc097d0: 40 be 00 24 bne+ cr7,ffc097f4 <_Objects_Extend_information+0x64><== ALWAYS TAKEN
ffc097d4: 38 00 00 01 li r0,1 <== NOT EXECUTED
ffc097d8: 48 00 00 1c b ffc097f4 <_Objects_Extend_information+0x64><== NOT EXECUTED
* information - object information table
*
* Output parameters: NONE
*/
void _Objects_Extend_information(
ffc097dc: 57 a8 10 3a rlwinm r8,r29,2,0,29
block_count = 0;
else {
block_count = information->maximum / information->allocation_size;
for ( ; block < block_count; block++ ) {
if ( information->object_blocks[ block ] == NULL ) {
ffc097e0: 7d 0b 40 2e lwzx r8,r11,r8
if ( information->object_blocks == NULL )
block_count = 0;
else {
block_count = information->maximum / information->allocation_size;
for ( ; block < block_count; block++ ) {
ffc097e4: 7d 29 52 14 add r9,r9,r10
if ( information->object_blocks[ block ] == NULL ) {
ffc097e8: 2f 88 00 00 cmpwi cr7,r8,0
ffc097ec: 41 9e 00 30 beq- cr7,ffc0981c <_Objects_Extend_information+0x8c>
if ( information->object_blocks == NULL )
block_count = 0;
else {
block_count = information->maximum / information->allocation_size;
for ( ; block < block_count; block++ ) {
ffc097f0: 3b bd 00 01 addi r29,r29,1
ffc097f4: 34 00 ff ff addic. r0,r0,-1
* information - object information table
*
* Output parameters: NONE
*/
void _Objects_Extend_information(
ffc097f8: 7f c9 e2 14 add r30,r9,r28
if ( information->object_blocks == NULL )
block_count = 0;
else {
block_count = information->maximum / information->allocation_size;
for ( ; block < block_count; block++ ) {
ffc097fc: 40 82 ff e0 bne+ ffc097dc <_Objects_Extend_information+0x4c>
/*
* 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;
ffc09800: 3b 40 00 01 li r26,1
ffc09804: 48 00 00 1c b ffc09820 <_Objects_Extend_information+0x90>
minimum_index = _Objects_Get_index( information->minimum_id );
ffc09808: 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;
ffc0980c: 3b 40 00 01 li r26,1
minimum_index = _Objects_Get_index( information->minimum_id );
index_base = minimum_index;
block = 0;
ffc09810: 3b a0 00 00 li r29,0
/* if ( information->maximum < minimum_index ) */
if ( information->object_blocks == NULL )
block_count = 0;
ffc09814: 3b 60 00 00 li r27,0
ffc09818: 48 00 00 08 b ffc09820 <_Objects_Extend_information+0x90>
else {
block_count = information->maximum / information->allocation_size;
for ( ; block < block_count; block++ ) {
if ( information->object_blocks[ block ] == NULL ) {
do_extend = false;
ffc0981c: 3b 40 00 00 li r26,0
} else
index_base += information->allocation_size;
}
}
maximum = (uint32_t) information->maximum + information->allocation_size;
ffc09820: a0 1f 00 14 lhz r0,20(r31)
ffc09824: a2 ff 00 10 lhz r23,16(r31)
ffc09828: 7e e0 ba 14 add r23,r0,r23
/*
* 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 ) {
ffc0982c: 2b 97 ff ff cmplwi cr7,r23,65535
ffc09830: 41 9d 02 10 bgt- cr7,ffc09a40 <_Objects_Extend_information+0x2b0>
/*
* 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;
ffc09834: 80 7f 00 18 lwz r3,24(r31)
ffc09838: 7c 60 19 d6 mullw r3,r0,r3
if ( information->auto_extend ) {
ffc0983c: 88 1f 00 12 lbz r0,18(r31)
ffc09840: 2f 80 00 00 cmpwi cr7,r0,0
ffc09844: 41 9e 00 14 beq- cr7,ffc09858 <_Objects_Extend_information+0xc8>
new_object_block = _Workspace_Allocate( block_size );
ffc09848: 48 00 25 05 bl ffc0bd4c <_Workspace_Allocate>
if ( !new_object_block )
ffc0984c: 7c 78 1b 79 mr. r24,r3
ffc09850: 40 a2 00 10 bne+ ffc09860 <_Objects_Extend_information+0xd0>
ffc09854: 48 00 01 ec b ffc09a40 <_Objects_Extend_information+0x2b0>
return;
} else {
new_object_block = _Workspace_Allocate_or_fatal_error( block_size );
ffc09858: 48 00 25 55 bl ffc0bdac <_Workspace_Allocate_or_fatal_error>
ffc0985c: 7c 78 1b 78 mr r24,r3
}
/*
* Do we need to grow the tables?
*/
if ( do_extend ) {
ffc09860: 2f 9a 00 00 cmpwi cr7,r26,0
ffc09864: 41 9e 01 58 beq- cr7,ffc099bc <_Objects_Extend_information+0x22c>
*/
/*
* Up the block count and maximum
*/
block_count++;
ffc09868: 3b 5b 00 01 addi r26,r27,1
/*
* Allocate the tables and break it up.
*/
block_size = block_count *
(sizeof(void *) + sizeof(uint32_t) + sizeof(Objects_Name *)) +
ffc0986c: 1c 1a 00 03 mulli r0,r26,3
((maximum + minimum_index) * sizeof(Objects_Control *));
ffc09870: 7c 77 e2 14 add r3,r23,r28
/*
* Allocate the tables and break it up.
*/
block_size = block_count *
(sizeof(void *) + sizeof(uint32_t) + sizeof(Objects_Name *)) +
ffc09874: 7c 63 02 14 add r3,r3,r0
((maximum + minimum_index) * sizeof(Objects_Control *));
object_blocks = (void**) _Workspace_Allocate( block_size );
ffc09878: 54 63 10 3a rlwinm r3,r3,2,0,29
ffc0987c: 48 00 24 d1 bl ffc0bd4c <_Workspace_Allocate>
if ( !object_blocks ) {
ffc09880: 7c 76 1b 79 mr. r22,r3
ffc09884: 40 a2 00 10 bne+ ffc09894 <_Objects_Extend_information+0x104>
_Workspace_Free( new_object_block );
ffc09888: 7f 03 c3 78 mr r3,r24
ffc0988c: 48 00 24 f5 bl ffc0bd80 <_Workspace_Free>
return;
ffc09890: 48 00 01 b0 b ffc09a40 <_Objects_Extend_information+0x2b0>
* Take the block count down. Saves all the (block_count - 1)
* in the copies.
*/
block_count--;
if ( information->maximum > minimum_index ) {
ffc09894: a0 1f 00 10 lhz r0,16(r31)
}
/*
* Break the block into the various sections.
*/
inactive_per_block = (uint32_t *) _Addresses_Add_offset(
ffc09898: 57 5a 10 3a rlwinm r26,r26,2,0,29
RTEMS_INLINE_ROUTINE void *_Addresses_Add_offset (
const void *base,
uintptr_t offset
)
{
return (void *)((uintptr_t)base + offset);
ffc0989c: 7f 36 d2 14 add r25,r22,r26
* Take the block count down. Saves all the (block_count - 1)
* in the copies.
*/
block_count--;
if ( information->maximum > minimum_index ) {
ffc098a0: 7f 80 e0 40 cmplw cr7,r0,r28
ffc098a4: 7f 59 d2 14 add r26,r25,r26
ffc098a8: 39 20 00 00 li r9,0
ffc098ac: 40 bd 00 50 ble+ cr7,ffc098fc <_Objects_Extend_information+0x16c>
* separate parts as size of each block has changed.
*/
memcpy( object_blocks,
information->object_blocks,
block_count * sizeof(void*) );
ffc098b0: 57 75 10 3a rlwinm r21,r27,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,
ffc098b4: 80 9f 00 34 lwz r4,52(r31)
ffc098b8: 7e a5 ab 78 mr r5,r21
ffc098bc: 48 00 80 35 bl ffc118f0 <memcpy>
information->object_blocks,
block_count * sizeof(void*) );
memcpy( inactive_per_block,
ffc098c0: 80 9f 00 30 lwz r4,48(r31)
ffc098c4: 7e a5 ab 78 mr r5,r21
ffc098c8: 7f 23 cb 78 mr r3,r25
ffc098cc: 48 00 80 25 bl ffc118f0 <memcpy>
information->inactive_per_block,
block_count * sizeof(uint32_t) );
memcpy( local_table,
information->local_table,
(information->maximum + minimum_index) * sizeof(Objects_Control *) );
ffc098d0: a0 1f 00 10 lhz r0,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,
ffc098d4: 80 9f 00 1c lwz r4,28(r31)
ffc098d8: 7f 43 d3 78 mr r3,r26
information->local_table,
(information->maximum + minimum_index) * sizeof(Objects_Control *) );
ffc098dc: 7f 9c 02 14 add r28,r28,r0
information->object_blocks,
block_count * sizeof(void*) );
memcpy( inactive_per_block,
information->inactive_per_block,
block_count * sizeof(uint32_t) );
memcpy( local_table,
ffc098e0: 57 85 10 3a rlwinm r5,r28,2,0,29
ffc098e4: 48 00 80 0d bl ffc118f0 <memcpy>
ffc098e8: 48 00 00 30 b ffc09918 <_Objects_Extend_information+0x188>
* information - object information table
*
* Output parameters: NONE
*/
void _Objects_Extend_information(
ffc098ec: 55 2a 10 3a rlwinm r10,r9,2,0,29
/*
* Deal with the special case of the 0 to minimum_index
*/
for ( index = 0; index < minimum_index; index++ ) {
local_table[ index ] = NULL;
ffc098f0: 7d 6a d1 2e stwx r11,r10,r26
} else {
/*
* Deal with the special case of the 0 to minimum_index
*/
for ( index = 0; index < minimum_index; index++ ) {
ffc098f4: 39 29 00 01 addi r9,r9,1
ffc098f8: 48 00 00 18 b ffc09910 <_Objects_Extend_information+0x180>
ffc098fc: 2f 9c 00 00 cmpwi cr7,r28,0
local_table[ index ] = NULL;
ffc09900: 39 60 00 00 li r11,0
ffc09904: 38 1c 00 01 addi r0,r28,1
ffc09908: 40 be 00 08 bne+ cr7,ffc09910 <_Objects_Extend_information+0x180><== ALWAYS TAKEN
ffc0990c: 38 00 00 01 li r0,1 <== NOT EXECUTED
} else {
/*
* Deal with the special case of the 0 to minimum_index
*/
for ( index = 0; index < minimum_index; index++ ) {
ffc09910: 34 00 ff ff addic. r0,r0,-1
ffc09914: 40 82 ff d8 bne+ ffc098ec <_Objects_Extend_information+0x15c>
*/
object_blocks[block_count] = NULL;
inactive_per_block[block_count] = 0;
for ( index=index_base ;
index < ( information->allocation_size + index_base );
ffc09918: a1 5f 00 14 lhz r10,20(r31)
}
/*
* Initialise the new entries in the table.
*/
object_blocks[block_count] = NULL;
ffc0991c: 38 00 00 00 li r0,0
ffc09920: 57 7b 10 3a rlwinm r27,r27,2,0,29
inactive_per_block[block_count] = 0;
for ( index=index_base ;
index < ( information->allocation_size + index_base );
index++ ) {
local_table[ index ] = NULL;
ffc09924: 7d 7e 52 14 add r11,r30,r10
}
/*
* Initialise the new entries in the table.
*/
object_blocks[block_count] = NULL;
ffc09928: 7c 16 d9 2e stwx r0,r22,r27
ffc0992c: 7f 9e 58 40 cmplw cr7,r30,r11
inactive_per_block[block_count] = 0;
ffc09930: 7c 19 d9 2e stwx r0,r25,r27
for ( index=index_base ;
ffc09934: 39 20 00 00 li r9,0
* information - object information table
*
* Output parameters: NONE
*/
void _Objects_Extend_information(
ffc09938: 57 c8 10 3a rlwinm r8,r30,2,0,29
inactive_per_block[block_count] = 0;
for ( index=index_base ;
index < ( information->allocation_size + index_base );
index++ ) {
local_table[ index ] = NULL;
ffc0993c: 38 e0 00 00 li r7,0
ffc09940: 38 0a 00 01 addi r0,r10,1
ffc09944: 41 9d 00 0c bgt- cr7,ffc09950 <_Objects_Extend_information+0x1c0><== NEVER TAKEN
ffc09948: 2f 8b 00 00 cmpwi cr7,r11,0
ffc0994c: 40 be 00 18 bne+ cr7,ffc09964 <_Objects_Extend_information+0x1d4><== ALWAYS TAKEN
ffc09950: 38 00 00 01 li r0,1 <== NOT EXECUTED
ffc09954: 48 00 00 10 b ffc09964 <_Objects_Extend_information+0x1d4><== NOT EXECUTED
* information - object information table
*
* Output parameters: NONE
*/
void _Objects_Extend_information(
ffc09958: 7d 7a 42 14 add r11,r26,r8
inactive_per_block[block_count] = 0;
for ( index=index_base ;
index < ( information->allocation_size + index_base );
index++ ) {
local_table[ index ] = NULL;
ffc0995c: 7c eb 49 2e stwx r7,r11,r9
object_blocks[block_count] = NULL;
inactive_per_block[block_count] = 0;
for ( index=index_base ;
index < ( information->allocation_size + index_base );
index++ ) {
ffc09960: 39 29 00 04 addi r9,r9,4
* Initialise the new entries in the table.
*/
object_blocks[block_count] = NULL;
inactive_per_block[block_count] = 0;
for ( index=index_base ;
ffc09964: 34 00 ff ff addic. r0,r0,-1
ffc09968: 40 82 ff f0 bne+ ffc09958 <_Objects_Extend_information+0x1c8>
static inline uint32_t ppc_interrupt_disable( void )
{
uint32_t level;
uint32_t mask;
__asm__ volatile (
ffc0996c: 7c 00 00 a6 mfmsr r0
ffc09970: 7d 30 42 a6 mfsprg r9,0
ffc09974: 7c 09 48 78 andc r9,r0,r9
ffc09978: 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) |
ffc0997c: 81 3f 00 00 lwz r9,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;
ffc09980: 56 f7 04 3e clrlwi r23,r23,16
information->maximum_id = _Objects_Build_id(
ffc09984: a1 7f 00 04 lhz r11,4(r31)
ffc09988: 55 29 c0 0e rlwinm r9,r9,24,0,7
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;
ffc0998c: b2 ff 00 10 sth r23,16(r31)
(( (Objects_Id) the_class ) << OBJECTS_CLASS_START_BIT) |
ffc09990: 55 6b d8 08 rlwinm r11,r11,27,0,4
uint32_t the_class,
uint32_t node,
uint32_t index
)
{
return (( (Objects_Id) the_api ) << OBJECTS_API_START_BIT) |
ffc09994: 65 29 00 01 oris r9,r9,1
local_table[ index ] = NULL;
}
_ISR_Disable( level );
old_tables = information->object_blocks;
ffc09998: 80 7f 00 34 lwz r3,52(r31)
(( (Objects_Id) the_class ) << OBJECTS_CLASS_START_BIT) |
ffc0999c: 7d 29 5b 78 or r9,r9,r11
information->object_blocks = object_blocks;
ffc099a0: 92 df 00 34 stw r22,52(r31)
uint32_t the_class,
uint32_t node,
uint32_t index
)
{
return (( (Objects_Id) the_api ) << OBJECTS_API_START_BIT) |
ffc099a4: 7d 37 bb 78 or r23,r9,r23
information->inactive_per_block = inactive_per_block;
ffc099a8: 93 3f 00 30 stw r25,48(r31)
information->local_table = local_table;
ffc099ac: 93 5f 00 1c stw r26,28(r31)
information->maximum = (Objects_Maximum) maximum;
information->maximum_id = _Objects_Build_id(
ffc099b0: 92 ff 00 0c stw r23,12(r31)
return level;
}
static inline void ppc_interrupt_enable( uint32_t level )
{
__asm__ volatile (
ffc099b4: 7c 00 01 24 mtmsr r0
information->maximum
);
_ISR_Enable( level );
_Workspace_Free( old_tables );
ffc099b8: 48 00 23 c9 bl ffc0bd80 <_Workspace_Free>
}
/*
* Assign the new object block to the object block table.
*/
information->object_blocks[ block ] = new_object_block;
ffc099bc: 81 3f 00 34 lwz r9,52(r31)
ffc099c0: 57 bd 10 3a rlwinm r29,r29,2,0,29
/*
* Initialize objects .. add to a local chain first.
*/
_Chain_Initialize(
ffc099c4: 3b 81 00 08 addi r28,r1,8
ffc099c8: a0 bf 00 14 lhz r5,20(r31)
}
/*
* Assign the new object block to the object block table.
*/
information->object_blocks[ block ] = new_object_block;
ffc099cc: 7f 09 e9 2e stwx r24,r9,r29
/*
* Initialize objects .. add to a local chain first.
*/
_Chain_Initialize(
ffc099d0: 7f 83 e3 78 mr r3,r28
information->the_class,
_Objects_Local_node,
index
);
_Chain_Append( &information->Inactive, &the_object->Node );
ffc099d4: 3b 7f 00 20 addi r27,r31,32
information->object_blocks[ block ] = new_object_block;
/*
* Initialize objects .. add to a local chain first.
*/
_Chain_Initialize(
ffc099d8: 81 3f 00 34 lwz r9,52(r31)
ffc099dc: 80 df 00 18 lwz r6,24(r31)
ffc099e0: 7c 89 e8 2e lwzx r4,r9,r29
ffc099e4: 48 00 4b 1d bl ffc0e500 <_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 ) {
ffc099e8: 48 00 00 30 b ffc09a18 <_Objects_Extend_information+0x288>
ffc099ec: 81 3f 00 00 lwz r9,0(r31)
information->the_class,
_Objects_Local_node,
index
);
_Chain_Append( &information->Inactive, &the_object->Node );
ffc099f0: 7f 63 db 78 mr r3,r27
*/
index = index_base;
while ((the_object = (Objects_Control *) _Chain_Get( &Inactive )) != NULL ) {
the_object->id = _Objects_Build_id(
ffc099f4: a0 1f 00 04 lhz r0,4(r31)
ffc099f8: 55 29 c0 0e rlwinm r9,r9,24,0,7
ffc099fc: 65 29 00 01 oris r9,r9,1
(( (Objects_Id) the_class ) << OBJECTS_CLASS_START_BIT) |
ffc09a00: 54 00 d8 08 rlwinm r0,r0,27,0,4
ffc09a04: 7d 20 03 78 or r0,r9,r0
uint32_t the_class,
uint32_t node,
uint32_t index
)
{
return (( (Objects_Id) the_api ) << OBJECTS_API_START_BIT) |
ffc09a08: 7c 00 f3 78 or r0,r0,r30
ffc09a0c: 90 04 00 08 stw r0,8(r4)
index
);
_Chain_Append( &information->Inactive, &the_object->Node );
index++;
ffc09a10: 3b de 00 01 addi r30,r30,1
information->the_class,
_Objects_Local_node,
index
);
_Chain_Append( &information->Inactive, &the_object->Node );
ffc09a14: 4b ff f2 35 bl ffc08c48 <_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 ) {
ffc09a18: 7f 83 e3 78 mr r3,r28
ffc09a1c: 4b ff f2 85 bl ffc08ca0 <_Chain_Get>
ffc09a20: 7c 64 1b 79 mr. r4,r3
ffc09a24: 40 82 ff c8 bne+ ffc099ec <_Objects_Extend_information+0x25c>
_Chain_Append( &information->Inactive, &the_object->Node );
index++;
}
information->inactive_per_block[ block ] = information->allocation_size;
ffc09a28: a0 1f 00 14 lhz r0,20(r31)
ffc09a2c: 81 3f 00 30 lwz r9,48(r31)
ffc09a30: 7c 09 e9 2e stwx r0,r9,r29
information->inactive =
(Objects_Maximum)(information->inactive + information->allocation_size);
ffc09a34: a1 3f 00 2c lhz r9,44(r31)
ffc09a38: 7c 00 4a 14 add r0,r0,r9
index++;
}
information->inactive_per_block[ block ] = information->allocation_size;
information->inactive =
ffc09a3c: b0 1f 00 2c sth r0,44(r31)
(Objects_Maximum)(information->inactive + information->allocation_size);
}
ffc09a40: 39 61 00 48 addi r11,r1,72
ffc09a44: 4b ff 6a d8 b ffc0051c <_restgpr_21_x>
ffc09afc <_Objects_Get_information>:
Objects_Information *_Objects_Get_information(
Objects_APIs the_api,
uint16_t the_class
)
{
ffc09afc: 94 21 ff e8 stwu r1,-24(r1)
ffc09b00: 7c 08 02 a6 mflr r0
ffc09b04: bf a1 00 0c stmw r29,12(r1)
Objects_Information *info;
int the_class_api_maximum;
if ( !the_class )
ffc09b08: 7c 9d 23 79 mr. r29,r4
Objects_Information *_Objects_Get_information(
Objects_APIs the_api,
uint16_t the_class
)
{
ffc09b0c: 7c 7e 1b 78 mr r30,r3
ffc09b10: 90 01 00 1c stw r0,28(r1)
Objects_Information *info;
int the_class_api_maximum;
if ( !the_class )
return NULL;
ffc09b14: 3b e0 00 00 li r31,0
)
{
Objects_Information *info;
int the_class_api_maximum;
if ( !the_class )
ffc09b18: 41 82 00 50 beq- ffc09b68 <_Objects_Get_information+0x6c>
/*
* 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 );
ffc09b1c: 48 00 4f 71 bl ffc0ea8c <_Objects_API_maximum_class>
if ( the_class_api_maximum == 0 )
ffc09b20: 2c 03 00 00 cmpwi r3,0
ffc09b24: 41 82 00 44 beq- ffc09b68 <_Objects_Get_information+0x6c>
return NULL;
if ( the_class > (uint32_t) the_class_api_maximum )
ffc09b28: 7f 9d 18 40 cmplw cr7,r29,r3
ffc09b2c: 41 9d 00 3c bgt- cr7,ffc09b68 <_Objects_Get_information+0x6c>
return NULL;
if ( !_Objects_Information_table[ the_api ] )
ffc09b30: 3d 20 00 00 lis r9,0
ffc09b34: 57 de 10 3a rlwinm r30,r30,2,0,29
ffc09b38: 39 29 2c 60 addi r9,r9,11360
ffc09b3c: 7d 29 f0 2e lwzx r9,r9,r30
ffc09b40: 2f 89 00 00 cmpwi cr7,r9,0
ffc09b44: 41 9e 00 24 beq- cr7,ffc09b68 <_Objects_Get_information+0x6c><== NEVER TAKEN
return NULL;
info = _Objects_Information_table[ the_api ][ the_class ];
ffc09b48: 57 bd 10 3a rlwinm r29,r29,2,0,29
ffc09b4c: 7f e9 e8 2e lwzx r31,r9,r29
if ( !info )
ffc09b50: 2f 9f 00 00 cmpwi cr7,r31,0
ffc09b54: 41 9e 00 14 beq- cr7,ffc09b68 <_Objects_Get_information+0x6c><== 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 )
ffc09b58: a0 1f 00 10 lhz r0,16(r31)
ffc09b5c: 2f 80 00 00 cmpwi cr7,r0,0
ffc09b60: 40 be 00 08 bne+ cr7,ffc09b68 <_Objects_Get_information+0x6c>
return NULL;
ffc09b64: 3b e0 00 00 li r31,0
#endif
return info;
}
ffc09b68: 39 61 00 18 addi r11,r1,24
ffc09b6c: 7f e3 fb 78 mr r3,r31
ffc09b70: 4b ff 69 cc b ffc0053c <_restgpr_29_x>
ffc0a5b0 <_Objects_Id_to_name>:
*/
Objects_Name_or_id_lookup_errors _Objects_Id_to_name (
Objects_Id id,
Objects_Name *name
)
{
ffc0a5b0: 94 21 ff e0 stwu r1,-32(r1)
ffc0a5b4: 7c 08 02 a6 mflr r0
ffc0a5b8: bf c1 00 18 stmw r30,24(r1)
ffc0a5bc: 7c 9e 23 78 mr r30,r4
/*
* Caller is trusted for name != NULL.
*/
tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id;
ffc0a5c0: 7c 64 1b 79 mr. r4,r3
*/
Objects_Name_or_id_lookup_errors _Objects_Id_to_name (
Objects_Id id,
Objects_Name *name
)
{
ffc0a5c4: 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;
ffc0a5c8: 40 82 00 10 bne- ffc0a5d8 <_Objects_Id_to_name+0x28>
ffc0a5cc: 3d 20 00 00 lis r9,0
ffc0a5d0: 81 29 31 b0 lwz r9,12720(r9)
ffc0a5d4: 80 89 00 08 lwz r4,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);
ffc0a5d8: 54 89 47 7e rlwinm r9,r4,8,29,31
*/
RTEMS_INLINE_ROUTINE bool _Objects_Is_api_valid(
uint32_t the_api
)
{
if ( !the_api || the_api > OBJECTS_APIS_LAST )
ffc0a5dc: 38 09 ff ff addi r0,r9,-1
ffc0a5e0: 2b 80 00 02 cmplwi cr7,r0,2
the_api = _Objects_Get_API( tmpId );
if ( !_Objects_Is_api_valid( the_api ) )
return OBJECTS_INVALID_ID;
ffc0a5e4: 3b e0 00 03 li r31,3
ffc0a5e8: 41 9d 00 44 bgt- cr7,ffc0a62c <_Objects_Id_to_name+0x7c>
ffc0a5ec: 48 00 00 4c b ffc0a638 <_Objects_Id_to_name+0x88>
if ( !_Objects_Information_table[ the_api ] )
return OBJECTS_INVALID_ID;
the_class = _Objects_Get_class( tmpId );
information = _Objects_Information_table[ the_api ][ the_class ];
ffc0a5f0: 54 80 3e 7a rlwinm r0,r4,7,25,29
ffc0a5f4: 7c 69 00 2e lwzx r3,r9,r0
if ( !information )
ffc0a5f8: 2f 83 00 00 cmpwi cr7,r3,0
ffc0a5fc: 41 9e 00 30 beq- cr7,ffc0a62c <_Objects_Id_to_name+0x7c><== NEVER TAKEN
return OBJECTS_INVALID_ID;
#if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES)
if ( information->is_string )
ffc0a600: 88 03 00 38 lbz r0,56(r3)
ffc0a604: 2f 80 00 00 cmpwi cr7,r0,0
ffc0a608: 40 be 00 24 bne+ cr7,ffc0a62c <_Objects_Id_to_name+0x7c><== NEVER TAKEN
return OBJECTS_INVALID_ID;
#endif
the_object = _Objects_Get( information, tmpId, &ignored_location );
ffc0a60c: 38 a1 00 08 addi r5,r1,8
ffc0a610: 4b ff ff 21 bl ffc0a530 <_Objects_Get>
if ( !the_object )
ffc0a614: 2c 03 00 00 cmpwi r3,0
ffc0a618: 41 82 00 14 beq- ffc0a62c <_Objects_Id_to_name+0x7c>
return OBJECTS_INVALID_ID;
*name = the_object->name;
ffc0a61c: 80 03 00 0c lwz r0,12(r3)
_Thread_Enable_dispatch();
return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL;
ffc0a620: 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;
ffc0a624: 90 1e 00 00 stw r0,0(r30)
_Thread_Enable_dispatch();
ffc0a628: 48 00 0e 79 bl ffc0b4a0 <_Thread_Enable_dispatch>
return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL;
}
ffc0a62c: 39 61 00 20 addi r11,r1,32
ffc0a630: 7f e3 fb 78 mr r3,r31
ffc0a634: 4b ff 64 b8 b ffc00aec <_restgpr_30_x>
the_api = _Objects_Get_API( tmpId );
if ( !_Objects_Is_api_valid( the_api ) )
return OBJECTS_INVALID_ID;
if ( !_Objects_Information_table[ the_api ] )
ffc0a638: 3d 60 00 00 lis r11,0
ffc0a63c: 55 29 10 3a rlwinm r9,r9,2,0,29
ffc0a640: 39 6b 2c c0 addi r11,r11,11456
ffc0a644: 7d 2b 48 2e lwzx r9,r11,r9
ffc0a648: 2f 89 00 00 cmpwi cr7,r9,0
ffc0a64c: 40 9e ff a4 bne+ cr7,ffc0a5f0 <_Objects_Id_to_name+0x40>
ffc0a650: 4b ff ff dc b ffc0a62c <_Objects_Id_to_name+0x7c>
ffc0a124 <_POSIX_Absolute_timeout_to_ticks>:
*/
POSIX_Absolute_timeout_conversion_results_t _POSIX_Absolute_timeout_to_ticks(
const struct timespec *abstime,
Watchdog_Interval *ticks_out
)
{
ffc0a124: 94 21 ff e0 stwu r1,-32(r1)
ffc0a128: 7c 08 02 a6 mflr r0
ffc0a12c: 90 01 00 24 stw r0,36(r1)
/*
* Make sure there is always a value returned.
*/
*ticks_out = 0;
ffc0a130: 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
)
{
ffc0a134: bf c1 00 18 stmw r30,24(r1)
ffc0a138: 7c 7e 1b 78 mr r30,r3
ffc0a13c: 7c 9f 23 78 mr r31,r4
/*
* Make sure there is always a value returned.
*/
*ticks_out = 0;
ffc0a140: 90 04 00 00 stw r0,0(r4)
/*
* Is the absolute time even valid?
*/
if ( !_Timespec_Is_valid(abstime) )
ffc0a144: 48 00 46 4d bl ffc0e790 <_Timespec_Is_valid>
return POSIX_ABSOLUTE_TIMEOUT_INVALID;
ffc0a148: 38 00 00 00 li r0,0
*ticks_out = 0;
/*
* Is the absolute time even valid?
*/
if ( !_Timespec_Is_valid(abstime) )
ffc0a14c: 2f 83 00 00 cmpwi cr7,r3,0
ffc0a150: 41 be 00 50 beq+ cr7,ffc0a1a0 <_POSIX_Absolute_timeout_to_ticks+0x7c>
return POSIX_ABSOLUTE_TIMEOUT_INVALID;
/*
* Is the absolute time in the past?
*/
_TOD_Get( ¤t_time );
ffc0a154: 38 61 00 10 addi r3,r1,16
ffc0a158: 48 00 20 31 bl ffc0c188 <_TOD_Get>
if ( _Timespec_Less_than( abstime, ¤t_time ) )
ffc0a15c: 7f c3 f3 78 mr r3,r30
ffc0a160: 38 81 00 10 addi r4,r1,16
ffc0a164: 48 00 46 6d bl ffc0e7d0 <_Timespec_Less_than>
return POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST;
ffc0a168: 38 00 00 01 li r0,1
/*
* Is the absolute time in the past?
*/
_TOD_Get( ¤t_time );
if ( _Timespec_Less_than( abstime, ¤t_time ) )
ffc0a16c: 2f 83 00 00 cmpwi cr7,r3,0
ffc0a170: 40 be 00 30 bne+ cr7,ffc0a1a0 <_POSIX_Absolute_timeout_to_ticks+0x7c>
return POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST;
/*
* How long until the requested absolute time?
*/
_Timespec_Subtract( ¤t_time, abstime, &difference );
ffc0a174: 38 61 00 10 addi r3,r1,16
ffc0a178: 7f c4 f3 78 mr r4,r30
ffc0a17c: 38 a1 00 08 addi r5,r1,8
ffc0a180: 48 00 46 8d bl ffc0e80c <_Timespec_Subtract>
/*
* Internally the SuperCore uses ticks, so convert to them.
*/
*ticks_out = _Timespec_To_ticks( &difference );
ffc0a184: 38 61 00 08 addi r3,r1,8
ffc0a188: 48 00 46 c5 bl ffc0e84c <_Timespec_To_ticks>
/*
* This is the case we were expecting and it took this long to
* get here.
*/
return POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE;
ffc0a18c: 38 00 00 03 li r0,3
/*
* If the difference was 0, then the future is now. It is so bright
* we better wear shades.
*/
if ( !*ticks_out )
ffc0a190: 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 );
ffc0a194: 90 7f 00 00 stw r3,0(r31)
/*
* If the difference was 0, then the future is now. It is so bright
* we better wear shades.
*/
if ( !*ticks_out )
ffc0a198: 40 9e 00 08 bne- cr7,ffc0a1a0 <_POSIX_Absolute_timeout_to_ticks+0x7c><== ALWAYS TAKEN
return POSIX_ABSOLUTE_TIMEOUT_IS_NOW;
ffc0a19c: 38 00 00 02 li r0,2 <== NOT EXECUTED
/*
* This is the case we were expecting and it took this long to
* get here.
*/
return POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE;
}
ffc0a1a0: 39 61 00 20 addi r11,r1,32
ffc0a1a4: 7c 03 03 78 mr r3,r0
ffc0a1a8: 4b ff 87 30 b ffc028d8 <_restgpr_30_x>
ffc10244 <_POSIX_Keys_Run_destructors>:
*/
void _POSIX_Keys_Run_destructors(
Thread_Control *thread
)
{
ffc10244: 94 21 ff e0 stwu r1,-32(r1)
ffc10248: 7c 08 02 a6 mflr r0
ffc1024c: 90 01 00 24 stw r0,36(r1)
ffc10250: bf 41 00 08 stmw r26,8(r1)
*
* 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;
ffc10254: 3f c0 00 00 lis r30,0
if ( key != NULL && key->destructor != NULL ) {
void *value = key->Values [ thread_api ][ thread_index ];
if ( value != NULL ) {
key->Values [ thread_api ][ thread_index ] = NULL;
ffc10258: 3b 80 00 00 li r28,0
void _POSIX_Keys_Run_destructors(
Thread_Control *thread
)
{
Objects_Maximum thread_index = _Objects_Get_index( thread->Object.id );
ffc1025c: 83 63 00 08 lwz r27,8(r3)
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 ];
ffc10260: 57 7d 13 ba rlwinm r29,r27,2,14,29
ffc10264: 57 7b 56 fa rlwinm r27,r27,10,27,29
ffc10268: 3b 7b 00 10 addi r27,r27,16
*
* 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;
ffc1026c: 39 3e 30 24 addi r9,r30,12324
ffc10270: a3 49 00 10 lhz r26,16(r9)
done = true;
for ( index = 1 ; index <= max ; ++index ) {
ffc10274: 3b e0 00 01 li r31,1
*/
while ( !done ) {
Objects_Maximum index = 0;
Objects_Maximum max = _POSIX_Keys_Information.maximum;
done = true;
ffc10278: 38 00 00 01 li r0,1
for ( index = 1 ; index <= max ; ++index ) {
ffc1027c: 48 00 00 58 b ffc102d4 <_POSIX_Keys_Run_destructors+0x90>
POSIX_Keys_Control *key = (POSIX_Keys_Control *)
_POSIX_Keys_Information.local_table [ index ];
ffc10280: 39 3e 30 24 addi r9,r30,12324
Objects_Maximum max = _POSIX_Keys_Information.maximum;
done = true;
for ( index = 1 ; index <= max ; ++index ) {
POSIX_Keys_Control *key = (POSIX_Keys_Control *)
ffc10284: 81 69 00 1c lwz r11,28(r9)
ffc10288: 57 e9 10 3a rlwinm r9,r31,2,0,29
ffc1028c: 7d 2b 48 2e lwzx r9,r11,r9
_POSIX_Keys_Information.local_table [ index ];
if ( key != NULL && key->destructor != NULL ) {
ffc10290: 2f 89 00 00 cmpwi cr7,r9,0
ffc10294: 41 9e 00 38 beq- cr7,ffc102cc <_POSIX_Keys_Run_destructors+0x88>
ffc10298: 81 69 00 10 lwz r11,16(r9)
ffc1029c: 2f 8b 00 00 cmpwi cr7,r11,0
ffc102a0: 41 9e 00 2c beq- cr7,ffc102cc <_POSIX_Keys_Run_destructors+0x88>
void *value = key->Values [ thread_api ][ thread_index ];
ffc102a4: 7d 69 da 14 add r11,r9,r27
ffc102a8: 81 6b 00 04 lwz r11,4(r11)
ffc102ac: 7c 6b e8 2e lwzx r3,r11,r29
if ( value != NULL ) {
ffc102b0: 2f 83 00 00 cmpwi cr7,r3,0
ffc102b4: 41 9e 00 18 beq- cr7,ffc102cc <_POSIX_Keys_Run_destructors+0x88><== ALWAYS TAKEN
key->Values [ thread_api ][ thread_index ] = NULL;
ffc102b8: 7f 8b e9 2e stwx r28,r11,r29 <== NOT EXECUTED
(*key->destructor)( value );
ffc102bc: 80 09 00 10 lwz r0,16(r9) <== NOT EXECUTED
ffc102c0: 7c 09 03 a6 mtctr r0 <== NOT EXECUTED
ffc102c4: 4e 80 04 21 bctrl <== NOT EXECUTED
done = false;
ffc102c8: 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 ) {
ffc102cc: 3b ff 00 01 addi r31,r31,1
ffc102d0: 57 ff 04 3e clrlwi r31,r31,16
ffc102d4: 7f 9f d0 40 cmplw cr7,r31,r26
ffc102d8: 40 bd ff a8 ble- cr7,ffc10280 <_POSIX_Keys_Run_destructors+0x3c>
* 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 ) {
ffc102dc: 2f 80 00 00 cmpwi cr7,r0,0
ffc102e0: 41 9e ff 8c beq+ cr7,ffc1026c <_POSIX_Keys_Run_destructors+0x28><== NEVER TAKEN
done = false;
}
}
}
}
}
ffc102e4: 39 61 00 20 addi r11,r1,32
ffc102e8: 4b ff 02 48 b ffc00530 <_restgpr_26_x>
ffc0cea0 <_POSIX_Message_queue_Receive_support>:
size_t msg_len,
unsigned int *msg_prio,
bool wait,
Watchdog_Interval timeout
)
{
ffc0cea0: 94 21 ff c8 stwu r1,-56(r1)
ffc0cea4: 7c 08 02 a6 mflr r0
ffc0cea8: bf 61 00 24 stmw r27,36(r1)
ffc0ceac: 7c 7e 1b 78 mr r30,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(
ffc0ceb0: 3c 60 00 00 lis r3,0
ffc0ceb4: 7c 9d 23 78 mr r29,r4
ffc0ceb8: 90 01 00 3c stw r0,60(r1)
ffc0cebc: 7c bc 2b 78 mr r28,r5
ffc0cec0: 38 63 36 18 addi r3,r3,13848
ffc0cec4: 91 01 00 18 stw r8,24(r1)
ffc0cec8: 7f c4 f3 78 mr r4,r30
ffc0cecc: 38 a1 00 0c addi r5,r1,12
ffc0ced0: 7c df 33 78 mr r31,r6
ffc0ced4: 7c fb 3b 78 mr r27,r7
ffc0ced8: 48 00 35 ed bl ffc104c4 <_Objects_Get>
Objects_Locations location;
size_t length_out;
bool do_wait;
the_mq_fd = _POSIX_Message_queue_Get_fd( mqdes, &location );
switch ( location ) {
ffc0cedc: 80 01 00 0c lwz r0,12(r1)
ffc0cee0: 81 01 00 18 lwz r8,24(r1)
ffc0cee4: 2f 80 00 00 cmpwi cr7,r0,0
ffc0cee8: 40 9e 00 d4 bne- cr7,ffc0cfbc <_POSIX_Message_queue_Receive_support+0x11c>
case OBJECTS_LOCAL:
if ( (the_mq_fd->oflag & O_ACCMODE) == O_WRONLY ) {
ffc0ceec: 81 23 00 14 lwz r9,20(r3)
ffc0cef0: 55 20 07 be clrlwi r0,r9,30
ffc0cef4: 2f 80 00 01 cmpwi cr7,r0,1
ffc0cef8: 40 be 00 0c bne+ cr7,ffc0cf04 <_POSIX_Message_queue_Receive_support+0x64>
_Thread_Enable_dispatch();
ffc0cefc: 48 00 45 31 bl ffc1142c <_Thread_Enable_dispatch>
ffc0cf00: 48 00 00 bc b ffc0cfbc <_POSIX_Message_queue_Receive_support+0x11c>
rtems_set_errno_and_return_minus_one( EBADF );
}
the_mq = the_mq_fd->Queue;
ffc0cf04: 80 63 00 10 lwz r3,16(r3)
if ( msg_len < the_mq->Message_queue.maximum_message_size ) {
ffc0cf08: 80 03 00 68 lwz r0,104(r3)
ffc0cf0c: 7f 9c 00 40 cmplw cr7,r28,r0
ffc0cf10: 40 bc 00 14 bge+ cr7,ffc0cf24 <_POSIX_Message_queue_Receive_support+0x84>
_Thread_Enable_dispatch();
ffc0cf14: 48 00 45 19 bl ffc1142c <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one( EMSGSIZE );
ffc0cf18: 48 00 ad c1 bl ffc17cd8 <__errno>
ffc0cf1c: 38 00 00 7a li r0,122
ffc0cf20: 48 00 00 a4 b ffc0cfc4 <_POSIX_Message_queue_Receive_support+0x124>
length_out = -1;
/*
* A timed receive with a bad time will do a poll regardless.
*/
if ( wait )
ffc0cf24: 2f 9b 00 00 cmpwi cr7,r27,0
/*
* Now if something goes wrong, we return a "length" of -1
* to indicate an error.
*/
length_out = -1;
ffc0cf28: 38 00 ff ff li r0,-1
ffc0cf2c: 90 01 00 08 stw r0,8(r1)
/*
* A timed receive with a bad time will do a poll regardless.
*/
if ( wait )
ffc0cf30: 38 00 00 00 li r0,0
ffc0cf34: 41 9e 00 10 beq- cr7,ffc0cf44 <_POSIX_Message_queue_Receive_support+0xa4>
do_wait = (the_mq_fd->oflag & O_NONBLOCK) ? false : true;
ffc0cf38: 71 20 40 00 andi. r0,r9,16384
ffc0cf3c: 7c 00 00 26 mfcr r0
ffc0cf40: 54 00 1f fe rlwinm r0,r0,3,31,31
do_wait = wait;
/*
* Now perform the actual message receive
*/
_CORE_message_queue_Seize(
ffc0cf44: 38 63 00 1c addi r3,r3,28
ffc0cf48: 7f c4 f3 78 mr r4,r30
ffc0cf4c: 7f a5 eb 78 mr r5,r29
ffc0cf50: 38 c1 00 08 addi r6,r1,8
ffc0cf54: 7c 07 03 78 mr r7,r0
ffc0cf58: 48 00 23 c5 bl ffc0f31c <_CORE_message_queue_Seize>
&length_out,
do_wait,
timeout
);
_Thread_Enable_dispatch();
ffc0cf5c: 48 00 44 d1 bl ffc1142c <_Thread_Enable_dispatch>
if (msg_prio) {
ffc0cf60: 2f 9f 00 00 cmpwi cr7,r31,0
ffc0cf64: 41 9e 00 20 beq- cr7,ffc0cf84 <_POSIX_Message_queue_Receive_support+0xe4><== NEVER TAKEN
*msg_prio = _POSIX_Message_queue_Priority_from_core(
_Thread_Executing->Wait.count
ffc0cf68: 3d 20 00 00 lis r9,0
ffc0cf6c: 81 29 36 90 lwz r9,13968(r9)
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);
ffc0cf70: 80 09 00 24 lwz r0,36(r9)
ffc0cf74: 7c 09 fe 70 srawi r9,r0,31
ffc0cf78: 7d 20 02 78 xor r0,r9,r0
ffc0cf7c: 7c 09 00 50 subf r0,r9,r0
timeout
);
_Thread_Enable_dispatch();
if (msg_prio) {
*msg_prio = _POSIX_Message_queue_Priority_from_core(
ffc0cf80: 90 1f 00 00 stw r0,0(r31)
_Thread_Executing->Wait.count
);
}
if ( !_Thread_Executing->Wait.return_code )
ffc0cf84: 3f e0 00 00 lis r31,0
return length_out;
ffc0cf88: 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 )
ffc0cf8c: 3b ff 36 84 addi r31,r31,13956
ffc0cf90: 81 3f 00 0c lwz r9,12(r31)
ffc0cf94: 80 09 00 34 lwz r0,52(r9)
ffc0cf98: 2f 80 00 00 cmpwi cr7,r0,0
ffc0cf9c: 41 be 00 30 beq+ cr7,ffc0cfcc <_POSIX_Message_queue_Receive_support+0x12c>
return length_out;
rtems_set_errno_and_return_minus_one(
ffc0cfa0: 48 00 ad 39 bl ffc17cd8 <__errno>
ffc0cfa4: 81 3f 00 0c lwz r9,12(r31)
ffc0cfa8: 7c 7e 1b 78 mr r30,r3
ffc0cfac: 80 69 00 34 lwz r3,52(r9)
ffc0cfb0: 48 00 02 a5 bl ffc0d254 <_POSIX_Message_queue_Translate_core_message_queue_return_code>
ffc0cfb4: 90 7e 00 00 stw r3,0(r30)
ffc0cfb8: 48 00 00 10 b ffc0cfc8 <_POSIX_Message_queue_Receive_support+0x128>
#endif
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EBADF );
ffc0cfbc: 48 00 ad 1d bl ffc17cd8 <__errno>
ffc0cfc0: 38 00 00 09 li r0,9
ffc0cfc4: 90 03 00 00 stw r0,0(r3)
ffc0cfc8: 38 60 ff ff li r3,-1
}
ffc0cfcc: 39 61 00 38 addi r11,r1,56
ffc0cfd0: 4b ff 89 28 b ffc058f8 <_restgpr_27_x>
ffc0d4cc <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch>:
#include <rtems/posix/pthread.h>
void _POSIX_Thread_Evaluate_cancellation_and_enable_dispatch(
Thread_Control *the_thread
)
{
ffc0d4cc: 7c 08 02 a6 mflr r0
ffc0d4d0: 94 21 ff f8 stwu r1,-8(r1)
ffc0d4d4: 90 01 00 0c stw r0,12(r1)
POSIX_API_Control *thread_support;
thread_support = the_thread->API_Extensions[ THREAD_API_POSIX ];
ffc0d4d8: 81 23 01 34 lwz r9,308(r3)
if ( thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE &&
ffc0d4dc: 80 09 00 d8 lwz r0,216(r9)
ffc0d4e0: 2f 80 00 00 cmpwi cr7,r0,0
ffc0d4e4: 40 9e 00 3c bne- cr7,ffc0d520 <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch+0x54><== NEVER TAKEN
ffc0d4e8: 80 09 00 dc lwz r0,220(r9)
ffc0d4ec: 2f 80 00 01 cmpwi cr7,r0,1
ffc0d4f0: 40 be 00 30 bne+ cr7,ffc0d520 <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch+0x54>
thread_support->cancelability_type == PTHREAD_CANCEL_ASYNCHRONOUS &&
ffc0d4f4: 80 09 00 e0 lwz r0,224(r9)
ffc0d4f8: 2f 80 00 00 cmpwi cr7,r0,0
ffc0d4fc: 41 be 00 24 beq+ cr7,ffc0d520 <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch+0x54>
*
* This routine decrements the thread dispatch level.
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_decrement_disable_level(void)
{
_Thread_Dispatch_disable_level--;
ffc0d500: 3d 20 00 00 lis r9,0
ffc0d504: 81 69 28 14 lwz r11,10260(r9)
thread_support->cancelation_requested ) {
_Thread_Unnest_dispatch();
_POSIX_Thread_Exit( the_thread, PTHREAD_CANCELED );
ffc0d508: 38 80 ff ff li r4,-1
ffc0d50c: 38 0b ff ff addi r0,r11,-1
ffc0d510: 90 09 28 14 stw r0,10260(r9)
return _Thread_Dispatch_disable_level;
ffc0d514: 80 09 28 14 lwz r0,10260(r9)
ffc0d518: 48 00 07 3d bl ffc0dc54 <_POSIX_Thread_Exit>
ffc0d51c: 48 00 00 08 b ffc0d524 <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch+0x58>
} else
_Thread_Enable_dispatch();
ffc0d520: 4b ff d4 19 bl ffc0a938 <_Thread_Enable_dispatch>
}
ffc0d524: 80 01 00 0c lwz r0,12(r1)
ffc0d528: 38 21 00 08 addi r1,r1,8
ffc0d52c: 7c 08 03 a6 mtlr r0
ffc0d530: 4e 80 00 20 blr
ffc0e9bc <_POSIX_Thread_Translate_sched_param>:
int policy,
struct sched_param *param,
Thread_CPU_budget_algorithms *budget_algorithm,
Thread_CPU_budget_algorithm_callout *budget_callout
)
{
ffc0e9bc: 94 21 ff e0 stwu r1,-32(r1)
ffc0e9c0: 7c 08 02 a6 mflr r0
ffc0e9c4: bf 61 00 0c stmw r27,12(r1)
ffc0e9c8: 7c 7f 1b 78 mr r31,r3
ffc0e9cc: 7c 9e 23 78 mr r30,r4
if ( !_POSIX_Priority_Is_valid( param->sched_priority ) )
ffc0e9d0: 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
)
{
ffc0e9d4: 7c bd 2b 78 mr r29,r5
ffc0e9d8: 90 01 00 24 stw r0,36(r1)
ffc0e9dc: 7c db 33 78 mr r27,r6
if ( !_POSIX_Priority_Is_valid( param->sched_priority ) )
ffc0e9e0: 4b ff ff b5 bl ffc0e994 <_POSIX_Priority_Is_valid>
return EINVAL;
ffc0e9e4: 3b 80 00 16 li r28,22
struct sched_param *param,
Thread_CPU_budget_algorithms *budget_algorithm,
Thread_CPU_budget_algorithm_callout *budget_callout
)
{
if ( !_POSIX_Priority_Is_valid( param->sched_priority ) )
ffc0e9e8: 2f 83 00 00 cmpwi cr7,r3,0
ffc0e9ec: 41 be 00 c8 beq+ cr7,ffc0eab4 <_POSIX_Thread_Translate_sched_param+0xf8><== NEVER TAKEN
return EINVAL;
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE;
*budget_callout = NULL;
if ( policy == SCHED_OTHER ) {
ffc0e9f0: 2f 9f 00 00 cmpwi cr7,r31,0
)
{
if ( !_POSIX_Priority_Is_valid( param->sched_priority ) )
return EINVAL;
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE;
ffc0e9f4: 38 00 00 00 li r0,0
ffc0e9f8: 90 1d 00 00 stw r0,0(r29)
*budget_callout = NULL;
ffc0e9fc: 90 1b 00 00 stw r0,0(r27)
if ( policy == SCHED_OTHER ) {
ffc0ea00: 40 be 00 10 bne+ cr7,ffc0ea10 <_POSIX_Thread_Translate_sched_param+0x54>
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE;
ffc0ea04: 38 00 00 01 li r0,1
ffc0ea08: 90 1d 00 00 stw r0,0(r29)
ffc0ea0c: 48 00 00 a4 b ffc0eab0 <_POSIX_Thread_Translate_sched_param+0xf4>
return 0;
}
if ( policy == SCHED_FIFO ) {
ffc0ea10: 2f 9f 00 01 cmpwi cr7,r31,1
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE;
return 0;
ffc0ea14: 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 ) {
ffc0ea18: 41 9e 00 9c beq- cr7,ffc0eab4 <_POSIX_Thread_Translate_sched_param+0xf8>
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE;
return 0;
}
if ( policy == SCHED_RR ) {
ffc0ea1c: 2f 9f 00 02 cmpwi cr7,r31,2
ffc0ea20: 40 be 00 0c bne+ cr7,ffc0ea2c <_POSIX_Thread_Translate_sched_param+0x70>
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_EXHAUST_TIMESLICE;
ffc0ea24: 93 fd 00 00 stw r31,0(r29)
return 0;
ffc0ea28: 48 00 00 8c b ffc0eab4 <_POSIX_Thread_Translate_sched_param+0xf8>
}
if ( policy == SCHED_SPORADIC ) {
ffc0ea2c: 2f 9f 00 04 cmpwi cr7,r31,4
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_CALLOUT;
*budget_callout = _POSIX_Threads_Sporadic_budget_callout;
return 0;
}
return EINVAL;
ffc0ea30: 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 ) {
ffc0ea34: 40 be 00 80 bne+ cr7,ffc0eab4 <_POSIX_Thread_Translate_sched_param+0xf8>
if ( (param->sched_ss_repl_period.tv_sec == 0) &&
ffc0ea38: 80 1e 00 08 lwz r0,8(r30)
ffc0ea3c: 2f 80 00 00 cmpwi cr7,r0,0
ffc0ea40: 40 9e 00 10 bne- cr7,ffc0ea50 <_POSIX_Thread_Translate_sched_param+0x94>
ffc0ea44: 80 1e 00 0c lwz r0,12(r30)
ffc0ea48: 2f 80 00 00 cmpwi cr7,r0,0
ffc0ea4c: 41 be 00 68 beq+ cr7,ffc0eab4 <_POSIX_Thread_Translate_sched_param+0xf8>
(param->sched_ss_repl_period.tv_nsec == 0) )
return EINVAL;
if ( (param->sched_ss_init_budget.tv_sec == 0) &&
ffc0ea50: 80 1e 00 10 lwz r0,16(r30)
ffc0ea54: 2f 80 00 00 cmpwi cr7,r0,0
ffc0ea58: 40 9e 00 14 bne- cr7,ffc0ea6c <_POSIX_Thread_Translate_sched_param+0xb0>
ffc0ea5c: 80 1e 00 14 lwz r0,20(r30)
(param->sched_ss_init_budget.tv_nsec == 0) )
return EINVAL;
ffc0ea60: 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) &&
ffc0ea64: 2f 80 00 00 cmpwi cr7,r0,0
ffc0ea68: 41 be 00 4c beq+ cr7,ffc0eab4 <_POSIX_Thread_Translate_sched_param+0xf8>
(param->sched_ss_init_budget.tv_nsec == 0) )
return EINVAL;
if ( _Timespec_To_ticks( ¶m->sched_ss_repl_period ) <
ffc0ea6c: 38 7e 00 08 addi r3,r30,8
ffc0ea70: 4b ff d9 d1 bl ffc0c440 <_Timespec_To_ticks>
_Timespec_To_ticks( ¶m->sched_ss_init_budget ) )
return EINVAL;
ffc0ea74: 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 ) <
ffc0ea78: 7c 7f 1b 78 mr r31,r3
_Timespec_To_ticks( ¶m->sched_ss_init_budget ) )
ffc0ea7c: 38 7e 00 10 addi r3,r30,16
ffc0ea80: 4b ff d9 c1 bl ffc0c440 <_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 ) <
ffc0ea84: 7f 9f 18 40 cmplw cr7,r31,r3
ffc0ea88: 41 bc 00 2c blt+ cr7,ffc0eab4 <_POSIX_Thread_Translate_sched_param+0xf8>
_Timespec_To_ticks( ¶m->sched_ss_init_budget ) )
return EINVAL;
if ( !_POSIX_Priority_Is_valid( param->sched_ss_low_priority ) )
ffc0ea8c: 80 7e 00 04 lwz r3,4(r30)
ffc0ea90: 4b ff ff 05 bl ffc0e994 <_POSIX_Priority_Is_valid>
ffc0ea94: 2f 83 00 00 cmpwi cr7,r3,0
ffc0ea98: 41 be 00 1c beq+ cr7,ffc0eab4 <_POSIX_Thread_Translate_sched_param+0xf8>
return EINVAL;
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_CALLOUT;
ffc0ea9c: 38 00 00 03 li r0,3
*budget_callout = _POSIX_Threads_Sporadic_budget_callout;
ffc0eaa0: 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;
ffc0eaa4: 90 1d 00 00 stw r0,0(r29)
*budget_callout = _POSIX_Threads_Sporadic_budget_callout;
ffc0eaa8: 38 09 83 4c addi r0,r9,-31924
ffc0eaac: 90 1b 00 00 stw r0,0(r27)
return 0;
ffc0eab0: 3b 80 00 00 li r28,0
}
return EINVAL;
}
ffc0eab4: 39 61 00 20 addi r11,r1,32
ffc0eab8: 7f 83 e3 78 mr r3,r28
ffc0eabc: 4b ff 20 a0 b ffc00b5c <_restgpr_27_x>
ffc0db88 <_POSIX_Threads_Delete_extension>:
*/
void _POSIX_Threads_Delete_extension(
Thread_Control *executing __attribute__((unused)),
Thread_Control *deleted
)
{
ffc0db88: 94 21 ff e8 stwu r1,-24(r1)
ffc0db8c: 7c 08 02 a6 mflr r0
api = deleted->API_Extensions[ THREAD_API_POSIX ];
/*
* Run the POSIX cancellation handlers
*/
_POSIX_Threads_cancel_run( deleted );
ffc0db90: 7c 83 23 78 mr r3,r4
*/
void _POSIX_Threads_Delete_extension(
Thread_Control *executing __attribute__((unused)),
Thread_Control *deleted
)
{
ffc0db94: bf 81 00 08 stmw r28,8(r1)
ffc0db98: 7c 9f 23 78 mr r31,r4
Thread_Control *the_thread;
POSIX_API_Control *api;
void **value_ptr;
api = deleted->API_Extensions[ THREAD_API_POSIX ];
ffc0db9c: 83 c4 01 34 lwz r30,308(r4)
*/
void _POSIX_Threads_Delete_extension(
Thread_Control *executing __attribute__((unused)),
Thread_Control *deleted
)
{
ffc0dba0: 90 01 00 1c stw r0,28(r1)
api = deleted->API_Extensions[ THREAD_API_POSIX ];
/*
* Run the POSIX cancellation handlers
*/
_POSIX_Threads_cancel_run( deleted );
ffc0dba4: 48 00 26 29 bl ffc101cc <_POSIX_Threads_cancel_run>
/*
* Run all the key destructors
*/
_POSIX_Keys_Run_destructors( deleted );
ffc0dba8: 7f e3 fb 78 mr r3,r31
ffc0dbac: 48 00 26 99 bl ffc10244 <_POSIX_Keys_Run_destructors>
/*
* 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 )) )
ffc0dbb0: 3b be 00 44 addi r29,r30,68
_POSIX_Keys_Run_destructors( deleted );
/*
* Wakeup all the tasks which joined with this one
*/
value_ptr = (void **) deleted->Wait.return_argument;
ffc0dbb4: 83 9f 00 28 lwz r28,40(r31)
while ( (the_thread = _Thread_queue_Dequeue( &api->Join_List )) )
ffc0dbb8: 48 00 00 0c b ffc0dbc4 <_POSIX_Threads_Delete_extension+0x3c>
*(void **)the_thread->Wait.return_argument = value_ptr;
ffc0dbbc: 81 23 00 28 lwz r9,40(r3) <== NOT EXECUTED
ffc0dbc0: 93 89 00 00 stw r28,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 )) )
ffc0dbc4: 7f a3 eb 78 mr r3,r29
ffc0dbc8: 4b ff d2 a1 bl ffc0ae68 <_Thread_queue_Dequeue>
ffc0dbcc: 2c 03 00 00 cmpwi r3,0
ffc0dbd0: 40 82 ff ec bne+ ffc0dbbc <_POSIX_Threads_Delete_extension+0x34><== NEVER TAKEN
*(void **)the_thread->Wait.return_argument = value_ptr;
if ( api->schedpolicy == SCHED_SPORADIC )
ffc0dbd4: 80 1e 00 84 lwz r0,132(r30)
ffc0dbd8: 2f 80 00 04 cmpwi cr7,r0,4
ffc0dbdc: 40 be 00 0c bne+ cr7,ffc0dbe8 <_POSIX_Threads_Delete_extension+0x60>
(void) _Watchdog_Remove( &api->Sporadic_timer );
ffc0dbe0: 38 7e 00 a8 addi r3,r30,168
ffc0dbe4: 4b ff df a9 bl ffc0bb8c <_Watchdog_Remove>
deleted->API_Extensions[ THREAD_API_POSIX ] = NULL;
ffc0dbe8: 38 00 00 00 li r0,0
ffc0dbec: 90 1f 01 34 stw r0,308(r31)
_Workspace_Free( api );
ffc0dbf0: 7f c3 f3 78 mr r3,r30
ffc0dbf4: 4b ff e1 8d bl ffc0bd80 <_Workspace_Free>
}
ffc0dbf8: 39 61 00 18 addi r11,r1,24
ffc0dbfc: 4b ff 29 3c b ffc00538 <_restgpr_28_x>
ffc08034 <_POSIX_Threads_Initialize_user_threads_body>:
*
* Output parameters: NONE
*/
void _POSIX_Threads_Initialize_user_threads_body(void)
{
ffc08034: 94 21 ff 98 stwu r1,-104(r1)
ffc08038: 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;
ffc0803c: 3d 20 00 00 lis r9,0
*
* Output parameters: NONE
*/
void _POSIX_Threads_Initialize_user_threads_body(void)
{
ffc08040: 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;
ffc08044: 39 29 20 44 addi r9,r9,8260
*
* Output parameters: NONE
*/
void _POSIX_Threads_Initialize_user_threads_body(void)
{
ffc08048: bf a1 00 5c stmw r29,92(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;
ffc0804c: 83 e9 00 34 lwz r31,52(r9)
maximum = Configuration_POSIX_API.number_of_initialization_threads;
ffc08050: 83 a9 00 30 lwz r29,48(r9)
if ( !user_threads || maximum == 0 )
ffc08054: 2f 9f 00 00 cmpwi cr7,r31,0
ffc08058: 41 9e 00 68 beq- cr7,ffc080c0 <_POSIX_Threads_Initialize_user_threads_body+0x8c><== NEVER TAKEN
ffc0805c: 2f 9d 00 00 cmpwi cr7,r29,0
ffc08060: 41 9e 00 60 beq- cr7,ffc080c0 <_POSIX_Threads_Initialize_user_threads_body+0x8c><== NEVER TAKEN
ffc08064: 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 );
ffc08068: 38 61 00 0c addi r3,r1,12
ffc0806c: 48 00 6a 55 bl ffc0eac0 <pthread_attr_init>
(void) pthread_attr_setinheritsched( &attr, PTHREAD_EXPLICIT_SCHED );
ffc08070: 38 80 00 02 li r4,2
ffc08074: 38 61 00 0c addi r3,r1,12
ffc08078: 48 00 6a 89 bl ffc0eb00 <pthread_attr_setinheritsched>
(void) pthread_attr_setstacksize(&attr, user_threads[ index ].stack_size);
ffc0807c: 80 9f 00 04 lwz r4,4(r31)
ffc08080: 38 61 00 0c addi r3,r1,12
ffc08084: 48 00 6a b5 bl ffc0eb38 <pthread_attr_setstacksize>
status = pthread_create(
ffc08088: 80 bf 00 00 lwz r5,0(r31)
ffc0808c: 38 61 00 08 addi r3,r1,8
ffc08090: 38 81 00 0c addi r4,r1,12
ffc08094: 38 c0 00 00 li r6,0
ffc08098: 4b ff fc 5d bl ffc07cf4 <pthread_create>
&thread_id,
&attr,
user_threads[ index ].thread_entry,
NULL
);
if ( status )
ffc0809c: 7c 65 1b 79 mr. r5,r3
ffc080a0: 41 a2 00 10 beq+ ffc080b0 <_POSIX_Threads_Initialize_user_threads_body+0x7c>
_Internal_error_Occurred( INTERNAL_ERROR_POSIX_API, true, status );
ffc080a4: 38 60 00 02 li r3,2
ffc080a8: 38 80 00 01 li r4,1
ffc080ac: 48 00 22 d5 bl ffc0a380 <_Internal_error_Occurred>
*
* Setting the attributes explicitly is critical, since we don't want
* to inherit the idle tasks attributes.
*/
for ( index=0 ; index < maximum ; index++ ) {
ffc080b0: 3b de 00 01 addi r30,r30,1
ffc080b4: 7f 9e e8 00 cmpw cr7,r30,r29
ffc080b8: 3b ff 00 08 addi r31,r31,8
ffc080bc: 40 9e ff ac bne+ cr7,ffc08068 <_POSIX_Threads_Initialize_user_threads_body+0x34><== NEVER TAKEN
NULL
);
if ( status )
_Internal_error_Occurred( INTERNAL_ERROR_POSIX_API, true, status );
}
}
ffc080c0: 39 61 00 68 addi r11,r1,104
ffc080c4: 4b ff 8a a0 b ffc00b64 <_restgpr_29_x>
ffc0dd24 <_POSIX_Threads_Sporadic_budget_TSR>:
*/
void _POSIX_Threads_Sporadic_budget_TSR(
Objects_Id id __attribute__((unused)),
void *argument
)
{
ffc0dd24: 94 21 ff f0 stwu r1,-16(r1)
ffc0dd28: 7c 08 02 a6 mflr r0
ffc0dd2c: 90 01 00 14 stw r0,20(r1)
ffc0dd30: bf c1 00 08 stmw r30,8(r1)
ffc0dd34: 7c 9e 23 78 mr r30,r4
Thread_Control *the_thread;
POSIX_API_Control *api;
the_thread = argument;
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
ffc0dd38: 83 e4 01 34 lwz r31,308(r4)
/* ticks is guaranteed to be at least one */
ticks = _Timespec_To_ticks( &api->schedparam.sched_ss_init_budget );
ffc0dd3c: 38 7f 00 98 addi r3,r31,152
ffc0dd40: 48 00 10 a9 bl ffc0ede8 <_Timespec_To_ticks>
RTEMS_INLINE_ROUTINE Priority_Control _POSIX_Priority_To_core(
int priority
)
{
return (Priority_Control) (POSIX_SCHEDULER_MAXIMUM_PRIORITY - priority + 1);
ffc0dd44: 3d 20 00 00 lis r9,0
ffc0dd48: 80 1f 00 88 lwz r0,136(r31)
ffc0dd4c: 88 89 27 24 lbz r4,10020(r9)
the_thread->cpu_time_budget = ticks;
ffc0dd50: 90 7e 00 78 stw r3,120(r30)
ffc0dd54: 7c 80 20 50 subf r4,r0,r4
*/
#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 ) {
ffc0dd58: 80 1e 00 1c lwz r0,28(r30)
ticks = _Timespec_To_ticks( &api->schedparam.sched_ss_init_budget );
the_thread->cpu_time_budget = ticks;
new_priority = _POSIX_Priority_To_core( api->schedparam.sched_priority );
the_thread->real_priority = new_priority;
ffc0dd5c: 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 ) {
ffc0dd60: 2f 80 00 00 cmpwi cr7,r0,0
ffc0dd64: 40 9e 00 1c bne- cr7,ffc0dd80 <_POSIX_Threads_Sporadic_budget_TSR+0x5c><== NEVER TAKEN
/*
* If this would make them less important, then do not change it.
*/
if ( the_thread->current_priority > new_priority ) {
ffc0dd68: 80 1e 00 14 lwz r0,20(r30)
ffc0dd6c: 7f 80 20 40 cmplw cr7,r0,r4
ffc0dd70: 40 bd 00 10 ble+ cr7,ffc0dd80 <_POSIX_Threads_Sporadic_budget_TSR+0x5c>
_Thread_Change_priority( the_thread, new_priority, true );
ffc0dd74: 7f c3 f3 78 mr r3,r30
ffc0dd78: 38 a0 00 01 li r5,1
ffc0dd7c: 4b ff c8 59 bl ffc0a5d4 <_Thread_Change_priority>
#endif
}
}
/* ticks is guaranteed to be at least one */
ticks = _Timespec_To_ticks( &api->schedparam.sched_ss_repl_period );
ffc0dd80: 38 7f 00 90 addi r3,r31,144
ffc0dd84: 48 00 10 65 bl ffc0ede8 <_Timespec_To_ticks>
)
{
the_watchdog->initial = units;
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
ffc0dd88: 38 9f 00 a8 addi r4,r31,168
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
ffc0dd8c: 90 7f 00 b4 stw r3,180(r31)
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
ffc0dd90: 3c 60 00 00 lis r3,0
ffc0dd94: 38 63 2d 68 addi r3,r3,11624
ffc0dd98: 4b ff dc 9d bl ffc0ba34 <_Watchdog_Insert>
_Watchdog_Insert_ticks( &api->Sporadic_timer, ticks );
}
ffc0dd9c: 39 61 00 10 addi r11,r1,16
ffc0dda0: 4b ff 27 a0 b ffc00540 <_restgpr_30_x>
ffc0dda4 <_POSIX_Threads_Sporadic_budget_callout>:
* _POSIX_Threads_Sporadic_budget_callout
*/
void _POSIX_Threads_Sporadic_budget_callout(
Thread_Control *the_thread
)
{
ffc0dda4: 7c 08 02 a6 mflr r0
ffc0dda8: 94 21 ff f8 stwu r1,-8(r1)
ffc0ddac: 3d 40 00 00 lis r10,0
ffc0ddb0: 90 01 00 0c stw r0,12(r1)
/*
* 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 */
ffc0ddb4: 38 00 ff ff li r0,-1
)
{
POSIX_API_Control *api;
uint32_t new_priority;
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
ffc0ddb8: 81 63 01 34 lwz r11,308(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 */
ffc0ddbc: 90 03 00 78 stw r0,120(r3)
ffc0ddc0: 88 8a 27 24 lbz r4,10020(r10)
ffc0ddc4: 80 0b 00 8c lwz r0,140(r11)
ffc0ddc8: 7c 80 20 50 subf r4,r0,r4
*/
#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 ) {
ffc0ddcc: 80 03 00 1c lwz r0,28(r3)
* while at low priority.
*/
the_thread->cpu_time_budget = 0xFFFFFFFF; /* XXX should be based on MAX_U32 */
new_priority = _POSIX_Priority_To_core(api->schedparam.sched_ss_low_priority);
the_thread->real_priority = new_priority;
ffc0ddd0: 90 83 00 18 stw r4,24(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 ) {
ffc0ddd4: 2f 80 00 00 cmpwi cr7,r0,0
ffc0ddd8: 40 9e 00 18 bne- cr7,ffc0ddf0 <_POSIX_Threads_Sporadic_budget_callout+0x4c><== 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 ) {
ffc0dddc: 80 03 00 14 lwz r0,20(r3)
ffc0dde0: 7f 80 20 40 cmplw cr7,r0,r4
ffc0dde4: 40 bc 00 0c bge+ cr7,ffc0ddf0 <_POSIX_Threads_Sporadic_budget_callout+0x4c><== NEVER TAKEN
_Thread_Change_priority( the_thread, new_priority, true );
ffc0dde8: 38 a0 00 01 li r5,1
ffc0ddec: 4b ff c7 e9 bl ffc0a5d4 <_Thread_Change_priority>
#if 0
printk( "lower priority\n" );
#endif
}
}
}
ffc0ddf0: 80 01 00 0c lwz r0,12(r1)
ffc0ddf4: 38 21 00 08 addi r1,r1,8
ffc0ddf8: 7c 08 03 a6 mtlr r0
ffc0ddfc: 4e 80 00 20 blr
ffc07d80 <_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)
{
ffc07d80: 7c 08 02 a6 mflr r0
ffc07d84: 7c 2b 0b 78 mr r11,r1
ffc07d88: 94 21 ff f0 stwu r1,-16(r1)
ffc07d8c: 90 01 00 14 stw r0,20(r1)
ffc07d90: 48 01 42 a5 bl ffc1c034 <_savegpr_31>
ffc07d94: 7c 9f 23 78 mr r31,r4
bool activated;
ptimer = (POSIX_Timer_Control *)data;
/* Increment the number of expirations. */
ptimer->overrun = ptimer->overrun + 1;
ffc07d98: 81 24 00 68 lwz r9,104(r4)
ffc07d9c: 38 09 00 01 addi r0,r9,1
ffc07da0: 90 04 00 68 stw r0,104(r4)
/* The timer must be reprogrammed */
if ( ( ptimer->timer_data.it_interval.tv_sec != 0 ) ||
ffc07da4: 80 04 00 54 lwz r0,84(r4)
ffc07da8: 2f 80 00 00 cmpwi cr7,r0,0
ffc07dac: 40 9e 00 10 bne- cr7,ffc07dbc <_POSIX_Timer_TSR+0x3c>
ffc07db0: 80 04 00 58 lwz r0,88(r4)
ffc07db4: 2f 80 00 00 cmpwi cr7,r0,0
ffc07db8: 41 9e 00 38 beq- cr7,ffc07df0 <_POSIX_Timer_TSR+0x70> <== NEVER TAKEN
( ptimer->timer_data.it_interval.tv_nsec != 0 ) ) {
activated = _POSIX_Timer_Insert_helper(
ffc07dbc: 80 9f 00 64 lwz r4,100(r31)
ffc07dc0: 3c c0 ff c0 lis r6,-64
ffc07dc4: 80 bf 00 08 lwz r5,8(r31)
ffc07dc8: 38 7f 00 10 addi r3,r31,16
ffc07dcc: 38 c6 7d 80 addi r6,r6,32128
ffc07dd0: 7f e7 fb 78 mr r7,r31
ffc07dd4: 48 00 68 f5 bl ffc0e6c8 <_POSIX_Timer_Insert_helper>
ptimer->ticks,
ptimer->Object.id,
_POSIX_Timer_TSR,
ptimer
);
if ( !activated )
ffc07dd8: 2f 83 00 00 cmpwi cr7,r3,0
ffc07ddc: 41 be 00 30 beq+ cr7,ffc07e0c <_POSIX_Timer_TSR+0x8c> <== NEVER TAKEN
return;
/* Store the time when the timer was started again */
_TOD_Get( &ptimer->time );
ffc07de0: 38 7f 00 6c addi r3,r31,108
ffc07de4: 48 00 19 49 bl ffc0972c <_TOD_Get>
/* The state really did not change but just to be safe */
ptimer->state = POSIX_TIMER_STATE_CREATE_RUN;
ffc07de8: 38 00 00 03 li r0,3
ffc07dec: 48 00 00 08 b ffc07df4 <_POSIX_Timer_TSR+0x74>
} else {
/* Indicates that the timer is stopped */
ptimer->state = POSIX_TIMER_STATE_CREATE_STOP;
ffc07df0: 38 00 00 04 li r0,4 <== NOT EXECUTED
ffc07df4: 98 1f 00 3c stb r0,60(r31)
/*
* 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 ) ) {
ffc07df8: 80 7f 00 38 lwz r3,56(r31)
ffc07dfc: 80 9f 00 44 lwz r4,68(r31)
ffc07e00: 48 00 63 f1 bl ffc0e1f0 <pthread_kill>
}
/* After the signal handler returns, the count of expirations of the
* timer must be set to 0.
*/
ptimer->overrun = 0;
ffc07e04: 38 00 00 00 li r0,0
ffc07e08: 90 1f 00 68 stw r0,104(r31)
}
ffc07e0c: 39 61 00 10 addi r11,r1,16
ffc07e10: 4b ff 88 48 b ffc00658 <_restgpr_31_x>
ffc102ec <_POSIX_signals_Check_signal>:
bool _POSIX_signals_Check_signal(
POSIX_API_Control *api,
int signo,
bool is_global
)
{
ffc102ec: 94 21 ff 98 stwu r1,-104(r1)
ffc102f0: 7c 08 02 a6 mflr r0
ffc102f4: 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,
ffc102f8: 38 e0 00 01 li r7,1
bool _POSIX_signals_Check_signal(
POSIX_API_Control *api,
int signo,
bool is_global
)
{
ffc102fc: bf 21 00 4c stmw r25,76(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,
ffc10300: 38 a1 00 08 addi r5,r1,8
bool _POSIX_signals_Check_signal(
POSIX_API_Control *api,
int signo,
bool is_global
)
{
ffc10304: 90 01 00 6c stw r0,108(r1)
ffc10308: 7c 7f 1b 78 mr r31,r3
ffc1030c: 7c 9e 23 78 mr r30,r4
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,
ffc10310: 48 00 00 b1 bl ffc103c0 <_POSIX_signals_Clear_signals>
ffc10314: 2f 83 00 00 cmpwi cr7,r3,0
is_global, true ) )
return false;
ffc10318: 38 00 00 00 li r0,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,
ffc1031c: 41 9e 00 98 beq- cr7,ffc103b4 <_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 )
ffc10320: 3f 20 00 00 lis r25,0
ffc10324: 1f 5e 00 0c mulli r26,r30,12
ffc10328: 3b 39 31 c0 addi r25,r25,12736
ffc1032c: 7d 39 d2 14 add r9,r25,r26
ffc10330: 83 a9 00 08 lwz r29,8(r9)
ffc10334: 2f 9d 00 01 cmpwi cr7,r29,1
ffc10338: 41 9e 00 7c beq- cr7,ffc103b4 <_POSIX_signals_Check_signal+0xc8><== NEVER TAKEN
/*
* Block the signals requested in sa_mask
*/
saved_signals_blocked = api->signals_blocked;
api->signals_blocked |= _POSIX_signals_Vectors[ signo ].sa_mask;
ffc1033c: 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,
ffc10340: 3f 60 00 00 lis r27,0
return false;
/*
* Block the signals requested in sa_mask
*/
saved_signals_blocked = api->signals_blocked;
ffc10344: 83 9f 00 d0 lwz r28,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,
ffc10348: 39 3b 31 44 addi r9,r27,12612
ffc1034c: 80 89 00 0c lwz r4,12(r9)
ffc10350: 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;
ffc10354: 7c 00 e3 78 or r0,r0,r28
ffc10358: 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,
ffc1035c: 38 84 00 20 addi r4,r4,32
ffc10360: 38 a0 00 28 li r5,40
ffc10364: 48 00 15 8d bl ffc118f0 <memcpy>
sizeof( Thread_Wait_information ));
/*
* Here, the signal handler function executes
*/
switch ( _POSIX_signals_Vectors[ signo ].sa_flags ) {
ffc10368: 7c 19 d0 2e lwzx r0,r25,r26
case SA_SIGINFO:
(*_POSIX_signals_Vectors[ signo ].sa_sigaction)(
ffc1036c: 7f c3 f3 78 mr r3,r30
sizeof( Thread_Wait_information ));
/*
* Here, the signal handler function executes
*/
switch ( _POSIX_signals_Vectors[ signo ].sa_flags ) {
ffc10370: 2f 80 00 02 cmpwi cr7,r0,2
ffc10374: 40 be 00 18 bne+ cr7,ffc1038c <_POSIX_signals_Check_signal+0xa0>
case SA_SIGINFO:
(*_POSIX_signals_Vectors[ signo ].sa_sigaction)(
ffc10378: 38 81 00 08 addi r4,r1,8
ffc1037c: 7f a9 03 a6 mtctr r29
ffc10380: 38 a0 00 00 li r5,0
ffc10384: 4e 80 04 21 bctrl
signo,
&siginfo_struct,
NULL /* context is undefined per 1003.1b-1993, p. 66 */
);
break;
ffc10388: 48 00 00 0c b ffc10394 <_POSIX_signals_Check_signal+0xa8>
default:
(*_POSIX_signals_Vectors[ signo ].sa_handler)( signo );
ffc1038c: 7f a9 03 a6 mtctr r29
ffc10390: 4e 80 04 21 bctrl
}
/*
* Restore the blocking information
*/
memcpy( &_Thread_Executing->Wait, &stored_thread_wait_information,
ffc10394: 3b 7b 31 44 addi r27,r27,12612
ffc10398: 80 7b 00 0c lwz r3,12(r27)
ffc1039c: 38 81 00 14 addi r4,r1,20
ffc103a0: 38 a0 00 28 li r5,40
ffc103a4: 38 63 00 20 addi r3,r3,32
ffc103a8: 48 00 15 49 bl ffc118f0 <memcpy>
sizeof( Thread_Wait_information ));
/*
* Restore the previous set of blocked signals
*/
api->signals_blocked = saved_signals_blocked;
ffc103ac: 93 9f 00 d0 stw r28,208(r31)
return true;
ffc103b0: 38 00 00 01 li r0,1
}
ffc103b4: 39 61 00 68 addi r11,r1,104
ffc103b8: 7c 03 03 78 mr r3,r0
ffc103bc: 4b ff 01 70 b ffc0052c <_restgpr_25_x>
ffc10b30 <_POSIX_signals_Clear_process_signals>:
static inline uint32_t ppc_interrupt_disable( void )
{
uint32_t level;
uint32_t mask;
__asm__ volatile (
ffc10b30: 7d 60 00 a6 mfmsr r11
ffc10b34: 7c 10 42 a6 mfsprg r0,0
ffc10b38: 7d 60 00 78 andc r0,r11,r0
ffc10b3c: 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 ) {
ffc10b40: 3d 20 00 00 lis r9,0
ffc10b44: 1c 03 00 0c mulli r0,r3,12
ffc10b48: 39 29 31 c0 addi r9,r9,12736
ffc10b4c: 7d 29 00 2e lwzx r9,r9,r0
ffc10b50: 2f 89 00 02 cmpwi cr7,r9,2
ffc10b54: 40 be 00 20 bne+ cr7,ffc10b74 <_POSIX_signals_Clear_process_signals+0x44>
if ( !_Chain_Is_empty( &_POSIX_signals_Siginfo[ signo ] ) )
ffc10b58: 3d 20 00 00 lis r9,0
ffc10b5c: 39 29 33 b4 addi r9,r9,13236
ffc10b60: 7d 40 4a 14 add r10,r0,r9
ffc10b64: 7c 09 00 2e lwzx r0,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 );
ffc10b68: 39 4a 00 04 addi r10,r10,4
ffc10b6c: 7f 80 50 00 cmpw cr7,r0,r10
ffc10b70: 40 be 00 20 bne+ cr7,ffc10b90 <_POSIX_signals_Clear_process_signals+0x60><== NEVER TAKEN
clear_signal = false;
}
if ( clear_signal ) {
_POSIX_signals_Pending &= ~mask;
ffc10b74: 3d 20 00 00 lis r9,0
ffc10b78: 38 00 ff fe li r0,-2
ffc10b7c: 38 63 ff ff addi r3,r3,-1
ffc10b80: 5c 03 18 3e rotlw r3,r0,r3
ffc10b84: 80 09 28 50 lwz r0,10320(r9)
ffc10b88: 7c 63 00 38 and r3,r3,r0
ffc10b8c: 90 69 28 50 stw r3,10320(r9)
return level;
}
static inline void ppc_interrupt_enable( uint32_t level )
{
__asm__ volatile (
ffc10b90: 7d 60 01 24 mtmsr r11
}
_ISR_Enable( level );
}
ffc10b94: 4e 80 00 20 blr
ffc088b0 <_POSIX_signals_Get_lowest>:
ffc088b0: 39 40 00 05 li r10,5
ffc088b4: 7d 49 03 a6 mtctr r10
sigset_t set
)
{
int signo;
for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) {
ffc088b8: 39 20 00 1b li r9,27
ffc088bc: 38 00 00 01 li r0,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(
ffc088c0: 39 69 ff ff addi r11,r9,-1
ffc088c4: 7c 0b 58 30 slw r11,r0,r11
)
{
int signo;
for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) {
if ( set & signo_to_mask( signo ) ) {
ffc088c8: 7d 6a 18 39 and. r10,r11,r3
ffc088cc: 40 82 00 34 bne- ffc08900 <_POSIX_signals_Get_lowest+0x50><== NEVER TAKEN
sigset_t set
)
{
int signo;
for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) {
ffc088d0: 39 29 00 01 addi r9,r9,1
ffc088d4: 42 00 ff ec bdnz+ ffc088c0 <_POSIX_signals_Get_lowest+0x10>
ffc088d8: 39 60 00 1a li r11,26
ffc088dc: 7d 69 03 a6 mtctr r11
ffc088e0: 39 20 00 01 li r9,1
ffc088e4: 38 00 00 01 li r0,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(
ffc088e8: 39 69 ff ff addi r11,r9,-1
ffc088ec: 7c 0b 58 30 slw r11,r0,r11
#if (SIGHUP != 1)
#error "Assumption that SIGHUP==1 violated!!"
#endif
for ( signo = SIGHUP ; signo <= __SIGLASTNOTRT ; signo++ ) {
if ( set & signo_to_mask( signo ) ) {
ffc088f0: 7d 6a 18 39 and. r10,r11,r3
ffc088f4: 40 82 00 0c bne- ffc08900 <_POSIX_signals_Get_lowest+0x50>
*/
#if (SIGHUP != 1)
#error "Assumption that SIGHUP==1 violated!!"
#endif
for ( signo = SIGHUP ; signo <= __SIGLASTNOTRT ; signo++ ) {
ffc088f8: 39 29 00 01 addi r9,r9,1
ffc088fc: 42 00 ff ec bdnz+ ffc088e8 <_POSIX_signals_Get_lowest+0x38>
* a return 0. This routine will NOT be called unless a signal
* is pending in the set passed in.
*/
found_it:
return signo;
}
ffc08900: 7d 23 4b 78 mr r3,r9
ffc08904: 4e 80 00 20 blr
ffc1bf38 <_POSIX_signals_Unblock_thread>:
bool _POSIX_signals_Unblock_thread(
Thread_Control *the_thread,
int signo,
siginfo_t *info
)
{
ffc1bf38: 94 21 ff f0 stwu r1,-16(r1)
ffc1bf3c: 7c 08 02 a6 mflr r0
/*
* Is the thread is specifically waiting for a signal?
*/
if ( _States_Is_interruptible_signal( the_thread->current_state ) ) {
ffc1bf40: 3c e0 10 00 lis r7,4096
bool _POSIX_signals_Unblock_thread(
Thread_Control *the_thread,
int signo,
siginfo_t *info
)
{
ffc1bf44: 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 ) ) {
ffc1bf48: 60 e7 80 00 ori r7,r7,32768
ffc1bf4c: 39 64 ff ff addi r11,r4,-1
ffc1bf50: 80 03 00 10 lwz r0,16(r3)
ffc1bf54: 39 40 00 01 li r10,1
bool _POSIX_signals_Unblock_thread(
Thread_Control *the_thread,
int signo,
siginfo_t *info
)
{
ffc1bf58: bf c1 00 08 stmw r30,8(r1)
ffc1bf5c: 7c a9 2b 78 mr r9,r5
/*
* Is the thread is specifically waiting for a signal?
*/
if ( _States_Is_interruptible_signal( the_thread->current_state ) ) {
ffc1bf60: 7c 06 38 38 and r6,r0,r7
ffc1bf64: 7f 86 38 00 cmpw cr7,r6,r7
{
POSIX_API_Control *api;
sigset_t mask;
siginfo_t *the_info = NULL;
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
ffc1bf68: 81 03 01 34 lwz r8,308(r3)
bool _POSIX_signals_Unblock_thread(
Thread_Control *the_thread,
int signo,
siginfo_t *info
)
{
ffc1bf6c: 7c 7f 1b 78 mr r31,r3
ffc1bf70: 7d 4b 58 30 slw r11,r10,r11
/*
* Is the thread is specifically waiting for a signal?
*/
if ( _States_Is_interruptible_signal( the_thread->current_state ) ) {
ffc1bf74: 40 be 00 60 bne+ cr7,ffc1bfd4 <_POSIX_signals_Unblock_thread+0x9c>
if ( (the_thread->Wait.option & mask) || (~api->signals_blocked & mask) ) {
ffc1bf78: 80 03 00 30 lwz r0,48(r3)
ffc1bf7c: 7d 6a 00 39 and. r10,r11,r0
ffc1bf80: 40 82 00 14 bne- ffc1bf94 <_POSIX_signals_Unblock_thread+0x5c>
ffc1bf84: 80 08 00 d0 lwz r0,208(r8)
/*
* This should only be reached via pthread_kill().
*/
return false;
ffc1bf88: 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) ) {
ffc1bf8c: 7d 68 00 79 andc. r8,r11,r0
ffc1bf90: 41 82 00 cc beq- ffc1c05c <_POSIX_signals_Unblock_thread+0x124>
the_thread->Wait.return_code = EINTR;
the_info = (siginfo_t *) the_thread->Wait.return_argument;
if ( !info ) {
ffc1bf94: 2f 89 00 00 cmpwi cr7,r9,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;
ffc1bf98: 81 7f 00 28 lwz r11,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;
ffc1bf9c: 38 00 00 04 li r0,4
ffc1bfa0: 90 1f 00 34 stw r0,52(r31)
the_info = (siginfo_t *) the_thread->Wait.return_argument;
if ( !info ) {
ffc1bfa4: 40 be 00 18 bne+ cr7,ffc1bfbc <_POSIX_signals_Unblock_thread+0x84>
the_info->si_signo = signo;
the_info->si_code = SI_USER;
ffc1bfa8: 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;
ffc1bfac: 90 8b 00 00 stw r4,0(r11)
the_info->si_code = SI_USER;
ffc1bfb0: 90 0b 00 04 stw r0,4(r11)
the_info->si_value.sival_int = 0;
ffc1bfb4: 91 2b 00 08 stw r9,8(r11)
ffc1bfb8: 48 00 00 0c b ffc1bfc4 <_POSIX_signals_Unblock_thread+0x8c>
} else {
*the_info = *info;
ffc1bfbc: 7c a9 64 aa lswi r5,r9,12
ffc1bfc0: 7c ab 65 aa stswi r5,r11,12
}
_Thread_queue_Extract_with_proxy( the_thread );
ffc1bfc4: 7f e3 fb 78 mr r3,r31
ffc1bfc8: 4b fe f2 91 bl ffc0b258 <_Thread_queue_Extract_with_proxy>
return true;
ffc1bfcc: 3b c0 00 01 li r30,1
ffc1bfd0: 48 00 00 8c b ffc1c05c <_POSIX_signals_Unblock_thread+0x124>
}
/*
* Thread is not waiting due to a sigwait.
*/
if ( ~api->signals_blocked & mask ) {
ffc1bfd4: 81 28 00 d0 lwz r9,208(r8)
} else if ( the_thread->current_state == STATES_READY ) {
if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
_Thread_Dispatch_necessary = true;
}
}
return false;
ffc1bfd8: 3b c0 00 00 li r30,0
}
/*
* Thread is not waiting due to a sigwait.
*/
if ( ~api->signals_blocked & mask ) {
ffc1bfdc: 7d 68 48 79 andc. r8,r11,r9
ffc1bfe0: 41 82 00 7c beq- ffc1c05c <_POSIX_signals_Unblock_thread+0x124>
* 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 ) ) {
ffc1bfe4: 74 09 10 00 andis. r9,r0,4096
ffc1bfe8: 41 82 00 48 beq- ffc1c030 <_POSIX_signals_Unblock_thread+0xf8>
the_thread->Wait.return_code = EINTR;
ffc1bfec: 39 20 00 04 li r9,4
ffc1bff0: 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) )
ffc1bff4: 3d 20 00 03 lis r9,3
ffc1bff8: 61 29 be e0 ori r9,r9,48864
ffc1bffc: 7c 0a 48 39 and. r10,r0,r9
ffc1c000: 41 a2 00 0c beq+ ffc1c00c <_POSIX_signals_Unblock_thread+0xd4>
_Thread_queue_Extract_with_proxy( the_thread );
ffc1c004: 4b fe f2 55 bl ffc0b258 <_Thread_queue_Extract_with_proxy>
ffc1c008: 48 00 00 54 b ffc1c05c <_POSIX_signals_Unblock_thread+0x124>
else if ( _States_Is_delaying(the_thread->current_state) ) {
ffc1c00c: 70 0b 00 08 andi. r11,r0,8
ffc1c010: 41 a2 00 4c beq+ ffc1c05c <_POSIX_signals_Unblock_thread+0x124><== NEVER TAKEN
(void) _Watchdog_Remove( &the_thread->Timer );
ffc1c014: 38 63 00 48 addi r3,r3,72
ffc1c018: 4b fe fb 75 bl ffc0bb8c <_Watchdog_Remove>
RTEMS_INLINE_ROUTINE void _Thread_Unblock (
Thread_Control *the_thread
)
{
_Thread_Clear_state( the_thread, STATES_BLOCKED );
ffc1c01c: 3c 80 10 03 lis r4,4099
ffc1c020: 7f e3 fb 78 mr r3,r31
ffc1c024: 60 84 ff f8 ori r4,r4,65528
ffc1c028: 4b fe e6 c5 bl ffc0a6ec <_Thread_Clear_state>
ffc1c02c: 48 00 00 30 b ffc1c05c <_POSIX_signals_Unblock_thread+0x124>
_Thread_Unblock( the_thread );
}
} else if ( the_thread->current_state == STATES_READY ) {
ffc1c030: 2f 80 00 00 cmpwi cr7,r0,0
ffc1c034: 40 9e 00 28 bne- cr7,ffc1c05c <_POSIX_signals_Unblock_thread+0x124><== NEVER TAKEN
if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
ffc1c038: 3d 20 00 00 lis r9,0
ffc1c03c: 39 29 31 44 addi r9,r9,12612
ffc1c040: 80 09 00 08 lwz r0,8(r9)
ffc1c044: 2f 80 00 00 cmpwi cr7,r0,0
ffc1c048: 41 9e 00 14 beq- cr7,ffc1c05c <_POSIX_signals_Unblock_thread+0x124>
ffc1c04c: 80 09 00 0c lwz r0,12(r9)
ffc1c050: 7f 83 00 00 cmpw cr7,r3,r0
ffc1c054: 40 be 00 08 bne+ cr7,ffc1c05c <_POSIX_signals_Unblock_thread+0x124><== NEVER TAKEN
_Thread_Dispatch_necessary = true;
ffc1c058: 99 49 00 18 stb r10,24(r9)
}
}
return false;
}
ffc1c05c: 39 61 00 10 addi r11,r1,16
ffc1c060: 7f c3 f3 78 mr r3,r30
ffc1c064: 4b fe 44 dc b ffc00540 <_restgpr_30_x>
ffc0f778 <_RBTree_Extract_unprotected>:
*/
void _RBTree_Extract_unprotected(
RBTree_Control *the_rbtree,
RBTree_Node *the_node
)
{
ffc0f778: 94 21 ff e8 stwu r1,-24(r1)
ffc0f77c: 7c 08 02 a6 mflr r0
ffc0f780: bf 81 00 08 stmw r28,8(r1)
RBTree_Node *leaf, *target;
RBTree_Color victim_color;
RBTree_Direction dir;
if (!the_node) return;
ffc0f784: 7c 9e 23 79 mr. r30,r4
*/
void _RBTree_Extract_unprotected(
RBTree_Control *the_rbtree,
RBTree_Node *the_node
)
{
ffc0f788: 7c 7f 1b 78 mr r31,r3
ffc0f78c: 90 01 00 1c stw r0,28(r1)
RBTree_Node *leaf, *target;
RBTree_Color victim_color;
RBTree_Direction dir;
if (!the_node) return;
ffc0f790: 41 82 01 b4 beq- ffc0f944 <_RBTree_Extract_unprotected+0x1cc>
/* check if min needs to be updated */
if (the_node == the_rbtree->first[RBT_LEFT]) {
ffc0f794: 80 03 00 08 lwz r0,8(r3)
ffc0f798: 7f 9e 00 00 cmpw cr7,r30,r0
ffc0f79c: 40 be 00 24 bne+ cr7,ffc0f7c0 <_RBTree_Extract_unprotected+0x48>
if (the_node->child[RBT_RIGHT])
ffc0f7a0: 80 1e 00 08 lwz r0,8(r30)
ffc0f7a4: 2f 80 00 00 cmpwi cr7,r0,0
ffc0f7a8: 40 be 00 14 bne+ cr7,ffc0f7bc <_RBTree_Extract_unprotected+0x44>
the_rbtree->first[RBT_LEFT] = the_node->child[RBT_RIGHT];
else {
the_rbtree->first[RBT_LEFT] = the_node->parent;
ffc0f7ac: 81 3e 00 00 lwz r9,0(r30)
if(_RBTree_Are_nodes_equal((RBTree_Node *)the_rbtree,
ffc0f7b0: 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;
ffc0f7b4: 91 23 00 08 stw r9,8(r3)
if(_RBTree_Are_nodes_equal((RBTree_Node *)the_rbtree,
ffc0f7b8: 40 be 00 08 bne+ cr7,ffc0f7c0 <_RBTree_Extract_unprotected+0x48>
the_rbtree->first[RBT_LEFT]))
the_rbtree->first[RBT_LEFT] = NULL;
ffc0f7bc: 90 1f 00 08 stw r0,8(r31)
}
}
/* check if max needs to be updated: note, min can equal max (1 element) */
if (the_node == the_rbtree->first[RBT_RIGHT]) {
ffc0f7c0: 80 1f 00 0c lwz r0,12(r31)
ffc0f7c4: 83 9e 00 04 lwz r28,4(r30)
ffc0f7c8: 7f 9e 00 00 cmpw cr7,r30,r0
ffc0f7cc: 40 be 00 20 bne+ cr7,ffc0f7ec <_RBTree_Extract_unprotected+0x74>
if (the_node->child[RBT_LEFT])
ffc0f7d0: 2f 9c 00 00 cmpwi cr7,r28,0
ffc0f7d4: 40 be 00 14 bne+ cr7,ffc0f7e8 <_RBTree_Extract_unprotected+0x70>
the_rbtree->first[RBT_RIGHT] = the_node->child[RBT_LEFT];
else {
the_rbtree->first[RBT_RIGHT] = the_node->parent;
ffc0f7d8: 80 1e 00 00 lwz r0,0(r30)
if(_RBTree_Are_nodes_equal((RBTree_Node *)the_rbtree,
ffc0f7dc: 7f 9f 00 00 cmpw cr7,r31,r0
/* 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;
ffc0f7e0: 90 1f 00 0c stw r0,12(r31)
if(_RBTree_Are_nodes_equal((RBTree_Node *)the_rbtree,
ffc0f7e4: 40 be 00 08 bne+ cr7,ffc0f7ec <_RBTree_Extract_unprotected+0x74>
the_rbtree->first[RBT_RIGHT]))
the_rbtree->first[RBT_RIGHT] = NULL;
ffc0f7e8: 93 9f 00 0c stw r28,12(r31)
* 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]) {
ffc0f7ec: 2f 9c 00 00 cmpwi cr7,r28,0
ffc0f7f0: 80 1e 00 08 lwz r0,8(r30)
ffc0f7f4: 7f 9d e3 78 mr r29,r28
ffc0f7f8: 41 9e 00 d0 beq- cr7,ffc0f8c8 <_RBTree_Extract_unprotected+0x150>
ffc0f7fc: 2f 80 00 00 cmpwi cr7,r0,0
ffc0f800: 40 be 00 0c bne+ cr7,ffc0f80c <_RBTree_Extract_unprotected+0x94>
ffc0f804: 48 00 00 d0 b ffc0f8d4 <_RBTree_Extract_unprotected+0x15c>
target = the_node->child[RBT_LEFT]; /* find max in node->child[RBT_LEFT] */
while (target->child[RBT_RIGHT]) target = target->child[RBT_RIGHT];
ffc0f808: 7c 1d 03 78 mr r29,r0
ffc0f80c: 80 1d 00 08 lwz r0,8(r29)
ffc0f810: 2f 80 00 00 cmpwi cr7,r0,0
ffc0f814: 40 9e ff f4 bne+ cr7,ffc0f808 <_RBTree_Extract_unprotected+0x90>
* 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];
ffc0f818: 83 9d 00 04 lwz r28,4(r29)
if(leaf) {
ffc0f81c: 2f 9c 00 00 cmpwi cr7,r28,0
ffc0f820: 41 9e 00 10 beq- cr7,ffc0f830 <_RBTree_Extract_unprotected+0xb8>
leaf->parent = target->parent;
ffc0f824: 80 1d 00 00 lwz r0,0(r29)
ffc0f828: 90 1c 00 00 stw r0,0(r28)
ffc0f82c: 48 00 00 0c b ffc0f838 <_RBTree_Extract_unprotected+0xc0>
} else {
/* fix the tree here if the child is a null leaf. */
_RBTree_Extract_validate_unprotected(target);
ffc0f830: 7f a3 eb 78 mr r3,r29
ffc0f834: 4b ff fd 6d bl ffc0f5a0 <_RBTree_Extract_validate_unprotected>
}
victim_color = target->color;
dir = target != target->parent->child[0];
ffc0f838: 81 7d 00 00 lwz r11,0(r29)
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;
ffc0f83c: 81 3d 00 0c lwz r9,12(r29)
dir = target != target->parent->child[0];
ffc0f840: 80 0b 00 04 lwz r0,4(r11)
ffc0f844: 7f a0 02 78 xor r0,r29,r0
ffc0f848: 7c 00 00 34 cntlzw r0,r0
ffc0f84c: 54 00 d9 7e rlwinm r0,r0,27,5,31
ffc0f850: 68 00 00 01 xori r0,r0,1
target->parent->child[dir] = leaf;
ffc0f854: 54 00 10 3a rlwinm r0,r0,2,0,29
ffc0f858: 7d 6b 02 14 add r11,r11,r0
ffc0f85c: 93 8b 00 04 stw r28,4(r11)
/* now replace the_node with target */
dir = the_node != the_node->parent->child[0];
ffc0f860: 81 7e 00 00 lwz r11,0(r30)
ffc0f864: 80 0b 00 04 lwz r0,4(r11)
ffc0f868: 7f c0 02 78 xor r0,r30,r0
ffc0f86c: 7c 00 00 34 cntlzw r0,r0
ffc0f870: 54 00 d9 7e rlwinm r0,r0,27,5,31
ffc0f874: 68 00 00 01 xori r0,r0,1
the_node->parent->child[dir] = target;
ffc0f878: 54 00 10 3a rlwinm r0,r0,2,0,29
ffc0f87c: 7d 6b 02 14 add r11,r11,r0
ffc0f880: 93 ab 00 04 stw r29,4(r11)
/* set target's new children to the original node's children */
target->child[RBT_RIGHT] = the_node->child[RBT_RIGHT];
ffc0f884: 80 1e 00 08 lwz r0,8(r30)
ffc0f888: 90 1d 00 08 stw r0,8(r29)
if (the_node->child[RBT_RIGHT])
ffc0f88c: 81 7e 00 08 lwz r11,8(r30)
ffc0f890: 2f 8b 00 00 cmpwi cr7,r11,0
ffc0f894: 41 9e 00 08 beq- cr7,ffc0f89c <_RBTree_Extract_unprotected+0x124><== NEVER TAKEN
the_node->child[RBT_RIGHT]->parent = target;
ffc0f898: 93 ab 00 00 stw r29,0(r11)
target->child[RBT_LEFT] = the_node->child[RBT_LEFT];
ffc0f89c: 80 1e 00 04 lwz r0,4(r30)
ffc0f8a0: 90 1d 00 04 stw r0,4(r29)
if (the_node->child[RBT_LEFT])
ffc0f8a4: 81 7e 00 04 lwz r11,4(r30)
ffc0f8a8: 2f 8b 00 00 cmpwi cr7,r11,0
ffc0f8ac: 41 9e 00 08 beq- cr7,ffc0f8b4 <_RBTree_Extract_unprotected+0x13c>
the_node->child[RBT_LEFT]->parent = target;
ffc0f8b0: 93 ab 00 00 stw r29,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;
ffc0f8b4: 80 1e 00 00 lwz r0,0(r30)
ffc0f8b8: 90 1d 00 00 stw r0,0(r29)
target->color = the_node->color;
ffc0f8bc: 80 1e 00 0c lwz r0,12(r30)
ffc0f8c0: 90 1d 00 0c stw r0,12(r29)
ffc0f8c4: 48 00 00 4c b ffc0f910 <_RBTree_Extract_unprotected+0x198>
* 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];
if( leaf ) {
ffc0f8c8: 2f 80 00 00 cmpwi cr7,r0,0
ffc0f8cc: 7c 1c 03 78 mr r28,r0
ffc0f8d0: 41 9e 00 10 beq- cr7,ffc0f8e0 <_RBTree_Extract_unprotected+0x168>
leaf->parent = the_node->parent;
ffc0f8d4: 80 1e 00 00 lwz r0,0(r30)
ffc0f8d8: 90 1c 00 00 stw r0,0(r28)
ffc0f8dc: 48 00 00 0c b ffc0f8e8 <_RBTree_Extract_unprotected+0x170>
} else {
/* fix the tree here if the child is a null leaf. */
_RBTree_Extract_validate_unprotected(the_node);
ffc0f8e0: 7f c3 f3 78 mr r3,r30
ffc0f8e4: 4b ff fc bd bl ffc0f5a0 <_RBTree_Extract_validate_unprotected>
}
victim_color = the_node->color;
/* remove the_node from the tree */
dir = the_node != the_node->parent->child[0];
ffc0f8e8: 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;
ffc0f8ec: 81 3e 00 0c lwz r9,12(r30)
/* remove the_node from the tree */
dir = the_node != the_node->parent->child[0];
ffc0f8f0: 80 0b 00 04 lwz r0,4(r11)
ffc0f8f4: 7f c0 02 78 xor r0,r30,r0
ffc0f8f8: 7c 00 00 34 cntlzw r0,r0
ffc0f8fc: 54 00 d9 7e rlwinm r0,r0,27,5,31
ffc0f900: 68 00 00 01 xori r0,r0,1
the_node->parent->child[dir] = leaf;
ffc0f904: 54 00 10 3a rlwinm r0,r0,2,0,29
ffc0f908: 7d 6b 02 14 add r11,r11,r0
ffc0f90c: 93 8b 00 04 stw r28,4(r11)
/* 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 */
ffc0f910: 2f 89 00 00 cmpwi cr7,r9,0
ffc0f914: 40 9e 00 10 bne- cr7,ffc0f924 <_RBTree_Extract_unprotected+0x1ac>
if (leaf) {
ffc0f918: 2f 9c 00 00 cmpwi cr7,r28,0
ffc0f91c: 41 9e 00 08 beq- cr7,ffc0f924 <_RBTree_Extract_unprotected+0x1ac>
leaf->color = RBT_BLACK; /* case 2 */
ffc0f920: 91 3c 00 0c stw r9,12(r28)
/* 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;
ffc0f924: 81 3f 00 04 lwz r9,4(r31)
*/
RTEMS_INLINE_ROUTINE void _RBTree_Set_off_rbtree(
RBTree_Node *node
)
{
node->parent = node->child[RBT_LEFT] = node->child[RBT_RIGHT] = NULL;
ffc0f928: 38 00 00 00 li r0,0
ffc0f92c: 90 1e 00 08 stw r0,8(r30)
ffc0f930: 2f 89 00 00 cmpwi cr7,r9,0
ffc0f934: 90 1e 00 04 stw r0,4(r30)
ffc0f938: 90 1e 00 00 stw r0,0(r30)
ffc0f93c: 41 9e 00 08 beq- cr7,ffc0f944 <_RBTree_Extract_unprotected+0x1cc>
ffc0f940: 90 09 00 0c stw r0,12(r9)
}
ffc0f944: 39 61 00 18 addi r11,r1,24
ffc0f948: 4b ff 11 f4 b ffc00b3c <_restgpr_28_x>
ffc0f5a0 <_RBTree_Extract_validate_unprotected>:
* of the extract operation.
*/
void _RBTree_Extract_validate_unprotected(
RBTree_Node *the_node
)
{
ffc0f5a0: 94 21 ff e0 stwu r1,-32(r1)
ffc0f5a4: 7c 08 02 a6 mflr r0
ffc0f5a8: 90 01 00 24 stw r0,36(r1)
ffc0f5ac: bf 41 00 08 stmw r26,8(r1)
ffc0f5b0: 7c 7e 1b 78 mr r30,r3
RBTree_Node *parent, *sibling;
RBTree_Direction dir;
parent = the_node->parent;
ffc0f5b4: 83 e3 00 00 lwz r31,0(r3)
if(!parent->parent) return;
ffc0f5b8: 80 1f 00 00 lwz r0,0(r31)
ffc0f5bc: 2f 80 00 00 cmpwi cr7,r0,0
ffc0f5c0: 41 9e 01 b0 beq- cr7,ffc0f770 <_RBTree_Extract_validate_unprotected+0x1d0>
sibling = _RBTree_Sibling(the_node);
ffc0f5c4: 4b ff ff 29 bl ffc0f4ec <_RBTree_Sibling>
* 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;
ffc0f5c8: 3b 40 00 00 li r26,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;
ffc0f5cc: 3b 60 00 01 li r27,1
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) {
ffc0f5d0: 48 00 01 58 b ffc0f728 <_RBTree_Extract_validate_unprotected+0x188>
*/
RTEMS_INLINE_ROUTINE bool _RBTree_Is_red(
const RBTree_Node *the_node
)
{
return (the_node && the_node->color == RBT_RED);
ffc0f5d4: 2f 83 00 00 cmpwi cr7,r3,0
ffc0f5d8: 41 9e 00 48 beq- cr7,ffc0f620 <_RBTree_Extract_validate_unprotected+0x80><== NEVER TAKEN
ffc0f5dc: 80 03 00 0c lwz r0,12(r3)
ffc0f5e0: 2f 80 00 01 cmpwi cr7,r0,1
ffc0f5e4: 40 be 00 3c bne+ cr7,ffc0f620 <_RBTree_Extract_validate_unprotected+0x80>
* update sibling pointer.
*/
if (_RBTree_Is_red(sibling)) {
parent->color = RBT_RED;
sibling->color = RBT_BLACK;
dir = the_node != parent->child[0];
ffc0f5e8: 83 bf 00 04 lwz r29,4(r31)
* 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;
ffc0f5ec: 90 1f 00 0c stw r0,12(r31)
sibling->color = RBT_BLACK;
dir = the_node != parent->child[0];
ffc0f5f0: 7f dd ea 78 xor r29,r30,r29
ffc0f5f4: 7f bd 00 34 cntlzw r29,r29
* 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;
ffc0f5f8: 93 43 00 0c stw r26,12(r3)
dir = the_node != parent->child[0];
ffc0f5fc: 57 bd d9 7e rlwinm r29,r29,27,5,31
ffc0f600: 6b bd 00 01 xori r29,r29,1
_RBTree_Rotate(parent, dir);
ffc0f604: 7f a4 eb 78 mr r4,r29
sibling = parent->child[!dir];
ffc0f608: 6b bd 00 01 xori r29,r29,1
ffc0f60c: 57 bd 10 3a rlwinm r29,r29,2,0,29
*/
if (_RBTree_Is_red(sibling)) {
parent->color = RBT_RED;
sibling->color = RBT_BLACK;
dir = the_node != parent->child[0];
_RBTree_Rotate(parent, dir);
ffc0f610: 7f e3 fb 78 mr r3,r31
sibling = parent->child[!dir];
ffc0f614: 7f bf ea 14 add r29,r31,r29
*/
if (_RBTree_Is_red(sibling)) {
parent->color = RBT_RED;
sibling->color = RBT_BLACK;
dir = the_node != parent->child[0];
_RBTree_Rotate(parent, dir);
ffc0f618: 4b ff ff 11 bl ffc0f528 <_RBTree_Rotate>
sibling = parent->child[!dir];
ffc0f61c: 80 7d 00 04 lwz r3,4(r29)
}
/* sibling is black, see if both of its children are also black. */
if (!_RBTree_Is_red(sibling->child[RBT_RIGHT]) &&
ffc0f620: 81 23 00 08 lwz r9,8(r3)
ffc0f624: 38 00 00 00 li r0,0
ffc0f628: 2f 89 00 00 cmpwi cr7,r9,0
ffc0f62c: 41 9e 00 14 beq- cr7,ffc0f640 <_RBTree_Extract_validate_unprotected+0xa0>
* This function maintains the properties of the red-black tree.
*
* @note It does NOT disable interrupts to ensure the atomicity
* of the extract operation.
*/
void _RBTree_Extract_validate_unprotected(
ffc0f630: 80 09 00 0c lwz r0,12(r9)
ffc0f634: 68 00 00 01 xori r0,r0,1
ffc0f638: 7c 00 00 34 cntlzw r0,r0
ffc0f63c: 54 00 d9 7e rlwinm r0,r0,27,5,31
_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]) &&
ffc0f640: 2f 80 00 00 cmpwi cr7,r0,0
ffc0f644: 40 9e 00 40 bne- cr7,ffc0f684 <_RBTree_Extract_validate_unprotected+0xe4>
!_RBTree_Is_red(sibling->child[RBT_LEFT])) {
ffc0f648: 81 23 00 04 lwz r9,4(r3)
ffc0f64c: 2f 89 00 00 cmpwi cr7,r9,0
ffc0f650: 41 9e 00 14 beq- cr7,ffc0f664 <_RBTree_Extract_validate_unprotected+0xc4>
* This function maintains the properties of the red-black tree.
*
* @note It does NOT disable interrupts to ensure the atomicity
* of the extract operation.
*/
void _RBTree_Extract_validate_unprotected(
ffc0f654: 80 09 00 0c lwz r0,12(r9)
ffc0f658: 68 00 00 01 xori r0,r0,1
ffc0f65c: 7c 00 00 34 cntlzw r0,r0
ffc0f660: 54 00 d9 7e rlwinm r0,r0,27,5,31
_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]) &&
ffc0f664: 2f 80 00 00 cmpwi cr7,r0,0
ffc0f668: 40 9e 00 1c bne- cr7,ffc0f684 <_RBTree_Extract_validate_unprotected+0xe4>
!_RBTree_Is_red(sibling->child[RBT_LEFT])) {
sibling->color = RBT_RED;
ffc0f66c: 93 63 00 0c stw r27,12(r3)
ffc0f670: 81 3f 00 0c lwz r9,12(r31)
ffc0f674: 2f 89 00 01 cmpwi cr7,r9,1
ffc0f678: 40 be 00 e0 bne+ cr7,ffc0f758 <_RBTree_Extract_validate_unprotected+0x1b8>
if (_RBTree_Is_red(parent)) {
parent->color = RBT_BLACK;
ffc0f67c: 90 1f 00 0c stw r0,12(r31)
break;
ffc0f680: 48 00 00 c0 b ffc0f740 <_RBTree_Extract_validate_unprotected+0x1a0>
* 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];
ffc0f684: 83 bf 00 04 lwz r29,4(r31)
ffc0f688: 38 00 00 00 li r0,0
ffc0f68c: 7f dd ea 78 xor r29,r30,r29
ffc0f690: 7f bd 00 34 cntlzw r29,r29
ffc0f694: 57 bd d9 7e rlwinm r29,r29,27,5,31
ffc0f698: 6b bd 00 01 xori r29,r29,1
if (!_RBTree_Is_red(sibling->child[!dir])) {
ffc0f69c: 6b bc 00 01 xori r28,r29,1
ffc0f6a0: 57 89 10 3a rlwinm r9,r28,2,0,29
ffc0f6a4: 7d 23 4a 14 add r9,r3,r9
ffc0f6a8: 81 29 00 04 lwz r9,4(r9)
ffc0f6ac: 2f 89 00 00 cmpwi cr7,r9,0
ffc0f6b0: 41 9e 00 14 beq- cr7,ffc0f6c4 <_RBTree_Extract_validate_unprotected+0x124>
* This function maintains the properties of the red-black tree.
*
* @note It does NOT disable interrupts to ensure the atomicity
* of the extract operation.
*/
void _RBTree_Extract_validate_unprotected(
ffc0f6b4: 80 09 00 0c lwz r0,12(r9)
ffc0f6b8: 68 00 00 01 xori r0,r0,1
ffc0f6bc: 7c 00 00 34 cntlzw r0,r0
ffc0f6c0: 54 00 d9 7e rlwinm r0,r0,27,5,31
* 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];
if (!_RBTree_Is_red(sibling->child[!dir])) {
ffc0f6c4: 2f 80 00 00 cmpwi cr7,r0,0
ffc0f6c8: 40 be 00 30 bne+ cr7,ffc0f6f8 <_RBTree_Extract_validate_unprotected+0x158>
sibling->color = RBT_RED;
ffc0f6cc: 39 20 00 01 li r9,1
ffc0f6d0: 91 23 00 0c stw r9,12(r3)
sibling->child[dir]->color = RBT_BLACK;
ffc0f6d4: 57 a9 10 3a rlwinm r9,r29,2,0,29
ffc0f6d8: 7d 23 4a 14 add r9,r3,r9
ffc0f6dc: 81 29 00 04 lwz r9,4(r9)
_RBTree_Rotate(sibling, !dir);
ffc0f6e0: 6b a4 00 01 xori r4,r29,1
* 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;
ffc0f6e4: 90 09 00 0c stw r0,12(r9)
_RBTree_Rotate(sibling, !dir);
ffc0f6e8: 4b ff fe 41 bl ffc0f528 <_RBTree_Rotate>
sibling = parent->child[!dir];
ffc0f6ec: 57 89 10 3a rlwinm r9,r28,2,0,29
ffc0f6f0: 7d 3f 4a 14 add r9,r31,r9
ffc0f6f4: 80 69 00 04 lwz r3,4(r9)
}
sibling->color = parent->color;
ffc0f6f8: 80 1f 00 0c lwz r0,12(r31)
parent->color = RBT_BLACK;
sibling->child[!dir]->color = RBT_BLACK;
ffc0f6fc: 57 9c 10 3a rlwinm r28,r28,2,0,29
_RBTree_Rotate(parent, dir);
ffc0f700: 7f a4 eb 78 mr r4,r29
sibling->color = RBT_RED;
sibling->child[dir]->color = RBT_BLACK;
_RBTree_Rotate(sibling, !dir);
sibling = parent->child[!dir];
}
sibling->color = parent->color;
ffc0f704: 90 03 00 0c stw r0,12(r3)
parent->color = RBT_BLACK;
sibling->child[!dir]->color = RBT_BLACK;
ffc0f708: 7c 63 e2 14 add r3,r3,r28
sibling->child[dir]->color = RBT_BLACK;
_RBTree_Rotate(sibling, !dir);
sibling = parent->child[!dir];
}
sibling->color = parent->color;
parent->color = RBT_BLACK;
ffc0f70c: 38 00 00 00 li r0,0
sibling->child[!dir]->color = RBT_BLACK;
ffc0f710: 81 23 00 04 lwz r9,4(r3)
_RBTree_Rotate(parent, dir);
ffc0f714: 7f e3 fb 78 mr r3,r31
sibling->child[dir]->color = RBT_BLACK;
_RBTree_Rotate(sibling, !dir);
sibling = parent->child[!dir];
}
sibling->color = parent->color;
parent->color = RBT_BLACK;
ffc0f718: 90 1f 00 0c stw r0,12(r31)
sibling->child[!dir]->color = RBT_BLACK;
ffc0f71c: 90 09 00 0c stw r0,12(r9)
_RBTree_Rotate(parent, dir);
ffc0f720: 4b ff fe 09 bl ffc0f528 <_RBTree_Rotate>
break; /* done */
ffc0f724: 48 00 00 1c b ffc0f740 <_RBTree_Extract_validate_unprotected+0x1a0>
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) {
ffc0f728: 80 1e 00 0c lwz r0,12(r30)
ffc0f72c: 2f 80 00 01 cmpwi cr7,r0,1
ffc0f730: 41 9e 00 10 beq- cr7,ffc0f740 <_RBTree_Extract_validate_unprotected+0x1a0>
ffc0f734: 80 1f 00 00 lwz r0,0(r31)
ffc0f738: 2f 80 00 00 cmpwi cr7,r0,0
ffc0f73c: 40 9e fe 98 bne+ cr7,ffc0f5d4 <_RBTree_Extract_validate_unprotected+0x34>
sibling->child[!dir]->color = RBT_BLACK;
_RBTree_Rotate(parent, dir);
break; /* done */
}
} /* while */
if(!the_node->parent->parent) the_node->color = RBT_BLACK;
ffc0f740: 81 3e 00 00 lwz r9,0(r30)
ffc0f744: 80 09 00 00 lwz r0,0(r9)
ffc0f748: 2f 80 00 00 cmpwi cr7,r0,0
ffc0f74c: 40 be 00 24 bne+ cr7,ffc0f770 <_RBTree_Extract_validate_unprotected+0x1d0>
ffc0f750: 90 1e 00 0c stw r0,12(r30)
ffc0f754: 48 00 00 1c b ffc0f770 <_RBTree_Extract_validate_unprotected+0x1d0>
if (_RBTree_Is_red(parent)) {
parent->color = RBT_BLACK;
break;
}
the_node = parent; /* done if parent is red */
parent = the_node->parent;
ffc0f758: 83 bf 00 00 lwz r29,0(r31)
sibling = _RBTree_Sibling(the_node);
ffc0f75c: 7f e3 fb 78 mr r3,r31
ffc0f760: 7f fe fb 78 mr r30,r31
ffc0f764: 4b ff fd 89 bl ffc0f4ec <_RBTree_Sibling>
if (_RBTree_Is_red(parent)) {
parent->color = RBT_BLACK;
break;
}
the_node = parent; /* done if parent is red */
parent = the_node->parent;
ffc0f768: 7f bf eb 78 mr r31,r29
sibling = _RBTree_Sibling(the_node);
ffc0f76c: 4b ff ff bc b ffc0f728 <_RBTree_Extract_validate_unprotected+0x188>
_RBTree_Rotate(parent, dir);
break; /* done */
}
} /* while */
if(!the_node->parent->parent) the_node->color = RBT_BLACK;
}
ffc0f770: 39 61 00 20 addi r11,r1,32
ffc0f774: 4b ff 13 c0 b ffc00b34 <_restgpr_26_x>
ffc0b3d8 <_RBTree_Initialize>:
void *starting_address,
size_t number_nodes,
size_t node_size,
bool is_unique
)
{
ffc0b3d8: 94 21 ff e8 stwu r1,-24(r1)
ffc0b3dc: 7c 08 02 a6 mflr r0
ffc0b3e0: bf 81 00 08 stmw r28,8(r1)
size_t count;
RBTree_Node *next;
/* TODO: Error message? */
if (!the_rbtree) return;
ffc0b3e4: 7c 7d 1b 79 mr. r29,r3
void *starting_address,
size_t number_nodes,
size_t node_size,
bool is_unique
)
{
ffc0b3e8: 7c df 33 78 mr r31,r6
ffc0b3ec: 90 01 00 1c stw r0,28(r1)
ffc0b3f0: 7c fe 3b 78 mr r30,r7
size_t count;
RBTree_Node *next;
/* TODO: Error message? */
if (!the_rbtree) return;
ffc0b3f4: 41 82 00 44 beq- ffc0b438 <_RBTree_Initialize+0x60> <== NEVER TAKEN
RBTree_Control *the_rbtree,
RBTree_Compare_function compare_function,
bool is_unique
)
{
the_rbtree->permanent_null = NULL;
ffc0b3f8: 38 00 00 00 li r0,0
the_rbtree->root = NULL;
the_rbtree->first[0] = NULL;
the_rbtree->first[1] = NULL;
the_rbtree->compare_function = compare_function;
ffc0b3fc: 90 9d 00 10 stw r4,16(r29)
/* could do sanity checks here */
_RBTree_Initialize_empty(the_rbtree, compare_function, is_unique);
count = number_nodes;
next = starting_address;
ffc0b400: 7c bc 2b 78 mr r28,r5
RBTree_Control *the_rbtree,
RBTree_Compare_function compare_function,
bool is_unique
)
{
the_rbtree->permanent_null = NULL;
ffc0b404: 90 1d 00 00 stw r0,0(r29)
the_rbtree->root = NULL;
ffc0b408: 90 1d 00 04 stw r0,4(r29)
the_rbtree->first[0] = NULL;
ffc0b40c: 90 1d 00 08 stw r0,8(r29)
the_rbtree->first[1] = NULL;
ffc0b410: 90 1d 00 0c stw r0,12(r29)
the_rbtree->compare_function = compare_function;
the_rbtree->is_unique = is_unique;
ffc0b414: 99 1d 00 14 stb r8,20(r29)
while ( count-- ) {
ffc0b418: 48 00 00 18 b ffc0b430 <_RBTree_Initialize+0x58>
_RBTree_Insert(the_rbtree, next);
ffc0b41c: 7f 84 e3 78 mr r4,r28
ffc0b420: 7f a3 eb 78 mr r3,r29
ffc0b424: 4b ff ff a1 bl ffc0b3c4 <_RBTree_Insert>
* node_size - size of node in bytes
*
* Output parameters: NONE
*/
void _RBTree_Initialize(
ffc0b428: 7f 9c f2 14 add r28,r28,r30
ffc0b42c: 3b ff ff ff addi r31,r31,-1
/* could do sanity checks here */
_RBTree_Initialize_empty(the_rbtree, compare_function, is_unique);
count = number_nodes;
next = starting_address;
while ( count-- ) {
ffc0b430: 2f 9f 00 00 cmpwi cr7,r31,0
ffc0b434: 40 9e ff e8 bne+ cr7,ffc0b41c <_RBTree_Initialize+0x44>
_RBTree_Insert(the_rbtree, next);
next = (RBTree_Node *)
_Addresses_Add_offset( (void *) next, node_size );
}
}
ffc0b438: 39 61 00 18 addi r11,r1,24
ffc0b43c: 4b ff 65 48 b ffc01984 <_restgpr_28_x>
ffc0f4ec <_RBTree_Sibling>:
*/
RTEMS_INLINE_ROUTINE RBTree_Node *_RBTree_Sibling(
RBTree_Node *the_node
)
{
if(!the_node) return NULL;
ffc0f4ec: 2c 03 00 00 cmpwi r3,0
ffc0f4f0: 38 00 00 00 li r0,0
ffc0f4f4: 41 82 00 2c beq- ffc0f520 <_RBTree_Sibling+0x34>
if(!(the_node->parent)) return NULL;
ffc0f4f8: 81 23 00 00 lwz r9,0(r3)
ffc0f4fc: 2f 89 00 00 cmpwi cr7,r9,0
ffc0f500: 41 9e 00 20 beq- cr7,ffc0f520 <_RBTree_Sibling+0x34> <== NEVER TAKEN
if(!(the_node->parent->parent)) return NULL;
ffc0f504: 81 69 00 00 lwz r11,0(r9)
ffc0f508: 2f 8b 00 00 cmpwi cr7,r11,0
ffc0f50c: 41 9e 00 14 beq- cr7,ffc0f520 <_RBTree_Sibling+0x34>
if(the_node == the_node->parent->child[RBT_LEFT])
ffc0f510: 80 09 00 04 lwz r0,4(r9)
ffc0f514: 7f 83 00 00 cmpw cr7,r3,r0
ffc0f518: 40 be 00 08 bne+ cr7,ffc0f520 <_RBTree_Sibling+0x34>
return the_node->parent->child[RBT_RIGHT];
ffc0f51c: 80 09 00 08 lwz r0,8(r9)
else
return the_node->parent->child[RBT_LEFT];
}
ffc0f520: 7c 03 03 78 mr r3,r0
ffc0f524: 4e 80 00 20 blr
ffc0f9f8 <_RBTree_Validate_insert_unprotected>:
* append operation.
*/
void _RBTree_Validate_insert_unprotected(
RBTree_Node *the_node
)
{
ffc0f9f8: 94 21 ff e0 stwu r1,-32(r1)
ffc0f9fc: 7c 08 02 a6 mflr r0
ffc0fa00: bf 61 00 0c stmw r27,12(r1)
ffc0fa04: 7c 7e 1b 78 mr r30,r3
/* 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;
ffc0fa08: 3b 80 00 00 li r28,0
* append operation.
*/
void _RBTree_Validate_insert_unprotected(
RBTree_Node *the_node
)
{
ffc0fa0c: 90 01 00 24 stw r0,36(r1)
if (dir != pdir) {
_RBTree_Rotate(the_node->parent, pdir);
the_node = the_node->child[pdir];
}
the_node->parent->color = RBT_BLACK;
g->color = RBT_RED;
ffc0fa10: 3b 60 00 01 li r27,1
RBTree_Node *u,*g;
/* note: the insert root case is handled already */
/* if the parent is black, nothing needs to be done
* otherwise may need to loop a few times */
while (_RBTree_Is_red(_RBTree_Parent(the_node))) {
ffc0fa14: 48 00 00 74 b ffc0fa88 <_RBTree_Validate_insert_unprotected+0x90>
)
{
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;
ffc0fa18: 80 1f 00 00 lwz r0,0(r31)
ffc0fa1c: 2f 80 00 00 cmpwi cr7,r0,0
ffc0fa20: 41 9e 00 90 beq- cr7,ffc0fab0 <_RBTree_Validate_insert_unprotected+0xb8><== 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])
ffc0fa24: 81 3f 00 04 lwz r9,4(r31)
ffc0fa28: 7f 83 48 00 cmpw cr7,r3,r9
ffc0fa2c: 40 be 00 08 bne+ cr7,ffc0fa34 <_RBTree_Validate_insert_unprotected+0x3c>
return the_node->parent->child[RBT_RIGHT];
ffc0fa30: 81 3f 00 08 lwz r9,8(r31)
*/
RTEMS_INLINE_ROUTINE bool _RBTree_Is_red(
const RBTree_Node *the_node
)
{
return (the_node && the_node->color == RBT_RED);
ffc0fa34: 2f 89 00 00 cmpwi cr7,r9,0
ffc0fa38: 41 9e 00 78 beq- cr7,ffc0fab0 <_RBTree_Validate_insert_unprotected+0xb8>
ffc0fa3c: 80 09 00 0c lwz r0,12(r9)
ffc0fa40: 2f 80 00 01 cmpwi cr7,r0,1
ffc0fa44: 40 be 00 6c bne+ cr7,ffc0fab0 <_RBTree_Validate_insert_unprotected+0xb8>
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;
ffc0fa48: 93 83 00 0c stw r28,12(r3)
u->color = RBT_BLACK;
g->color = RBT_RED;
ffc0fa4c: 7f fe fb 78 mr r30,r31
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;
ffc0fa50: 93 89 00 0c stw r28,12(r9)
g->color = RBT_RED;
ffc0fa54: 90 1f 00 0c stw r0,12(r31)
ffc0fa58: 48 00 00 30 b ffc0fa88 <_RBTree_Validate_insert_unprotected+0x90>
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) {
_RBTree_Rotate(the_node->parent, pdir);
ffc0fa5c: 7f a4 eb 78 mr r4,r29
ffc0fa60: 4b ff ff 21 bl ffc0f980 <_RBTree_Rotate>
the_node = the_node->child[pdir];
ffc0fa64: 57 a0 10 3a rlwinm r0,r29,2,0,29
ffc0fa68: 7f de 02 14 add r30,r30,r0
ffc0fa6c: 83 de 00 04 lwz r30,4(r30)
}
the_node->parent->color = RBT_BLACK;
ffc0fa70: 81 3e 00 00 lwz r9,0(r30)
g->color = RBT_RED;
/* now rotate grandparent in the other branch direction (toward uncle) */
_RBTree_Rotate(g, (1-pdir));
ffc0fa74: 7f e3 fb 78 mr r3,r31
ffc0fa78: 20 9d 00 01 subfic r4,r29,1
/* 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;
ffc0fa7c: 93 89 00 0c stw r28,12(r9)
g->color = RBT_RED;
ffc0fa80: 93 7f 00 0c stw r27,12(r31)
/* now rotate grandparent in the other branch direction (toward uncle) */
_RBTree_Rotate(g, (1-pdir));
ffc0fa84: 4b ff fe fd bl ffc0f980 <_RBTree_Rotate>
ISR_Level level;
_ISR_Disable( level );
return _RBTree_Insert_unprotected( tree, node );
_ISR_Enable( level );
}
ffc0fa88: 80 7e 00 00 lwz r3,0(r30)
*/
RTEMS_INLINE_ROUTINE RBTree_Node *_RBTree_Parent(
RBTree_Node *the_node
)
{
if (!the_node->parent->parent) return NULL;
ffc0fa8c: 83 e3 00 00 lwz r31,0(r3)
ffc0fa90: 2f 9f 00 00 cmpwi cr7,r31,0
ffc0fa94: 41 9e 00 14 beq- cr7,ffc0faa8 <_RBTree_Validate_insert_unprotected+0xb0>
*/
RTEMS_INLINE_ROUTINE bool _RBTree_Is_red(
const RBTree_Node *the_node
)
{
return (the_node && the_node->color == RBT_RED);
ffc0fa98: 80 03 00 0c lwz r0,12(r3)
ffc0fa9c: 2f 80 00 01 cmpwi cr7,r0,1
ffc0faa0: 40 be 00 44 bne+ cr7,ffc0fae4 <_RBTree_Validate_insert_unprotected+0xec>
ffc0faa4: 4b ff ff 74 b ffc0fa18 <_RBTree_Validate_insert_unprotected+0x20>
/* 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;
ffc0faa8: 93 fe 00 0c stw r31,12(r30)
ffc0faac: 48 00 00 38 b ffc0fae4 <_RBTree_Validate_insert_unprotected+0xec>
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];
RBTree_Direction pdir = the_node->parent != g->child[0];
ffc0fab0: 83 bf 00 04 lwz r29,4(r31)
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];
ffc0fab4: 80 03 00 04 lwz r0,4(r3)
RBTree_Direction pdir = the_node->parent != g->child[0];
ffc0fab8: 7c 7d ea 78 xor r29,r3,r29
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];
ffc0fabc: 7f c0 02 78 xor r0,r30,r0
RBTree_Direction pdir = the_node->parent != g->child[0];
ffc0fac0: 7f bd 00 34 cntlzw r29,r29
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];
ffc0fac4: 7c 00 00 34 cntlzw r0,r0
RBTree_Direction pdir = the_node->parent != g->child[0];
ffc0fac8: 57 bd d9 7e rlwinm r29,r29,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];
ffc0facc: 54 00 d9 7e rlwinm r0,r0,27,5,31
RBTree_Direction pdir = the_node->parent != g->child[0];
ffc0fad0: 6b bd 00 01 xori r29,r29,1
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];
ffc0fad4: 68 00 00 01 xori r0,r0,1
RBTree_Direction pdir = the_node->parent != g->child[0];
/* ensure node is on the same branch direction as parent */
if (dir != pdir) {
ffc0fad8: 7f 80 e8 00 cmpw cr7,r0,r29
ffc0fadc: 40 be ff 80 bne- cr7,ffc0fa5c <_RBTree_Validate_insert_unprotected+0x64>
ffc0fae0: 4b ff ff 90 b ffc0fa70 <_RBTree_Validate_insert_unprotected+0x78>
/* 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;
}
ffc0fae4: 39 61 00 20 addi r11,r1,32
ffc0fae8: 4b ff 10 50 b ffc00b38 <_restgpr_27_x>
ffc09324 <_Rate_monotonic_Timeout>:
void _Rate_monotonic_Timeout(
Objects_Id id,
void *ignored
)
{
ffc09324: 7c 2b 0b 78 mr r11,r1
ffc09328: 94 21 ff e0 stwu r1,-32(r1)
ffc0932c: 7c 08 02 a6 mflr r0
ffc09330: 7c 64 1b 78 mr r4,r3
ffc09334: 3c 60 00 00 lis r3,0
ffc09338: 48 01 3a 1d bl ffc1cd54 <_savegpr_31>
ffc0933c: 38 63 2c 98 addi r3,r3,11416
ffc09340: 90 01 00 24 stw r0,36(r1)
ffc09344: 38 a1 00 08 addi r5,r1,8
ffc09348: 48 00 21 b9 bl ffc0b500 <_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 ) {
ffc0934c: 80 01 00 08 lwz r0,8(r1)
ffc09350: 7c 7f 1b 78 mr r31,r3
ffc09354: 2f 80 00 00 cmpwi cr7,r0,0
ffc09358: 40 9e 00 88 bne- cr7,ffc093e0 <_Rate_monotonic_Timeout+0xbc><== NEVER TAKEN
case OBJECTS_LOCAL:
the_thread = the_period->owner;
ffc0935c: 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);
ffc09360: 80 03 00 10 lwz r0,16(r3)
if ( _States_Is_waiting_for_period( the_thread->current_state ) &&
ffc09364: 70 09 40 00 andi. r9,r0,16384
ffc09368: 41 82 00 24 beq- ffc0938c <_Rate_monotonic_Timeout+0x68>
ffc0936c: 81 23 00 20 lwz r9,32(r3)
ffc09370: 80 1f 00 08 lwz r0,8(r31)
ffc09374: 7f 89 00 00 cmpw cr7,r9,r0
ffc09378: 40 be 00 14 bne+ cr7,ffc0938c <_Rate_monotonic_Timeout+0x68>
RTEMS_INLINE_ROUTINE void _Thread_Unblock (
Thread_Control *the_thread
)
{
_Thread_Clear_state( the_thread, STATES_BLOCKED );
ffc0937c: 3c 80 10 03 lis r4,4099
ffc09380: 60 84 ff f8 ori r4,r4,65528
ffc09384: 48 00 2c 85 bl ffc0c008 <_Thread_Clear_state>
ffc09388: 48 00 00 18 b ffc093a0 <_Rate_monotonic_Timeout+0x7c>
_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 ) {
ffc0938c: 80 1f 00 38 lwz r0,56(r31)
ffc09390: 2f 80 00 01 cmpwi cr7,r0,1
ffc09394: 40 be 00 30 bne+ cr7,ffc093c4 <_Rate_monotonic_Timeout+0xa0>
the_period->state = RATE_MONOTONIC_EXPIRED_WHILE_BLOCKING;
ffc09398: 38 00 00 03 li r0,3
ffc0939c: 90 1f 00 38 stw r0,56(r31)
_Rate_monotonic_Initiate_statistics( the_period );
ffc093a0: 7f e3 fb 78 mr r3,r31
ffc093a4: 4b ff f9 35 bl ffc08cd8 <_Rate_monotonic_Initiate_statistics>
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
ffc093a8: 80 1f 00 3c lwz r0,60(r31)
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
ffc093ac: 3c 60 00 00 lis r3,0
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
ffc093b0: 90 1f 00 1c stw r0,28(r31)
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
ffc093b4: 38 63 2e 68 addi r3,r3,11880
ffc093b8: 38 9f 00 10 addi r4,r31,16
ffc093bc: 48 00 40 91 bl ffc0d44c <_Watchdog_Insert>
ffc093c0: 48 00 00 0c b ffc093cc <_Rate_monotonic_Timeout+0xa8>
_Watchdog_Insert_ticks( &the_period->Timer, the_period->next_length );
} else
the_period->state = RATE_MONOTONIC_EXPIRED;
ffc093c4: 38 00 00 04 li r0,4
ffc093c8: 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--;
ffc093cc: 3d 20 00 00 lis r9,0
ffc093d0: 81 69 28 6c lwz r11,10348(r9)
ffc093d4: 38 0b ff ff addi r0,r11,-1
ffc093d8: 90 09 28 6c stw r0,10348(r9)
return _Thread_Dispatch_disable_level;
ffc093dc: 80 09 28 6c lwz r0,10348(r9)
case OBJECTS_REMOTE: /* impossible */
#endif
case OBJECTS_ERROR:
break;
}
}
ffc093e0: 39 61 00 20 addi r11,r1,32
ffc093e4: 4b ff 7e 28 b ffc0120c <_restgpr_31_x>
ffc0a8e4 <_Scheduler_EDF_Allocate>:
#include <rtems/score/wkspace.h>
void *_Scheduler_EDF_Allocate(
Thread_Control *the_thread
)
{
ffc0a8e4: 7c 2b 0b 78 mr r11,r1
ffc0a8e8: 94 21 ff f0 stwu r1,-16(r1)
ffc0a8ec: 7c 08 02 a6 mflr r0
ffc0a8f0: 48 01 24 29 bl ffc1cd18 <_savegpr_31>
ffc0a8f4: 7c 7f 1b 78 mr r31,r3
void *sched;
Scheduler_EDF_Per_thread *schinfo;
sched = _Workspace_Allocate( sizeof(Scheduler_EDF_Per_thread) );
ffc0a8f8: 38 60 00 18 li r3,24
#include <rtems/score/wkspace.h>
void *_Scheduler_EDF_Allocate(
Thread_Control *the_thread
)
{
ffc0a8fc: 90 01 00 14 stw r0,20(r1)
void *sched;
Scheduler_EDF_Per_thread *schinfo;
sched = _Workspace_Allocate( sizeof(Scheduler_EDF_Per_thread) );
ffc0a900: 48 00 1e 8d bl ffc0c78c <_Workspace_Allocate>
if ( sched ) {
ffc0a904: 2c 03 00 00 cmpwi r3,0
ffc0a908: 41 82 00 14 beq- ffc0a91c <_Scheduler_EDF_Allocate+0x38><== 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;
ffc0a90c: 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;
ffc0a910: 90 7f 00 8c stw r3,140(r31)
schinfo = (Scheduler_EDF_Per_thread *)(the_thread->scheduler_info);
schinfo->thread = the_thread;
ffc0a914: 93 e3 00 00 stw r31,0(r3)
schinfo->queue_state = SCHEDULER_EDF_QUEUE_STATE_NEVER_HAS_BEEN;
ffc0a918: 90 03 00 14 stw r0,20(r3)
}
return sched;
}
ffc0a91c: 39 61 00 10 addi r11,r1,16
ffc0a920: 4b ff 62 28 b ffc00b48 <_restgpr_31_x>
ffc0a924 <_Scheduler_EDF_Block>:
#include <rtems/score/thread.h>
void _Scheduler_EDF_Block(
Thread_Control *the_thread
)
{
ffc0a924: 94 21 ff f0 stwu r1,-16(r1)
ffc0a928: 7c 08 02 a6 mflr r0
ffc0a92c: bf c1 00 08 stmw r30,8(r1)
RTEMS_INLINE_ROUTINE bool _Thread_Is_heir (
const Thread_Control *the_thread
)
{
return ( the_thread == _Thread_Heir );
ffc0a930: 3f c0 00 00 lis r30,0
ffc0a934: 3b de 31 c4 addi r30,r30,12740
ffc0a938: 90 01 00 14 stw r0,20(r1)
ffc0a93c: 7c 7f 1b 78 mr r31,r3
_Scheduler_EDF_Extract( the_thread );
ffc0a940: 48 00 00 89 bl ffc0a9c8 <_Scheduler_EDF_Extract>
/* TODO: flash critical section? */
if ( _Thread_Is_heir( the_thread ) )
ffc0a944: 80 1e 00 10 lwz r0,16(r30)
ffc0a948: 7f 9f 00 00 cmpw cr7,r31,r0
ffc0a94c: 40 be 00 08 bne+ cr7,ffc0a954 <_Scheduler_EDF_Block+0x30><== NEVER TAKEN
_Scheduler_EDF_Schedule();
ffc0a950: 48 00 01 e1 bl ffc0ab30 <_Scheduler_EDF_Schedule>
if ( _Thread_Is_executing( the_thread ) )
ffc0a954: 80 1e 00 0c lwz r0,12(r30)
ffc0a958: 7f 9f 00 00 cmpw cr7,r31,r0
ffc0a95c: 40 be 00 0c bne+ cr7,ffc0a968 <_Scheduler_EDF_Block+0x44><== NEVER TAKEN
_Thread_Dispatch_necessary = true;
ffc0a960: 38 00 00 01 li r0,1
ffc0a964: 98 1e 00 18 stb r0,24(r30)
}
ffc0a968: 39 61 00 10 addi r11,r1,16
ffc0a96c: 4b ff 61 d8 b ffc00b44 <_restgpr_30_x>
ffc0ab68 <_Scheduler_EDF_Unblock>:
#include <rtems/score/scheduleredf.h>
void _Scheduler_EDF_Unblock(
Thread_Control *the_thread
)
{
ffc0ab68: 94 21 ff f0 stwu r1,-16(r1)
ffc0ab6c: 7c 08 02 a6 mflr r0
ffc0ab70: bf c1 00 08 stmw r30,8(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(
ffc0ab74: 3f c0 00 00 lis r30,0
#include <rtems/score/scheduleredf.h>
void _Scheduler_EDF_Unblock(
Thread_Control *the_thread
)
{
ffc0ab78: 7c 7f 1b 78 mr r31,r3
ffc0ab7c: 90 01 00 14 stw r0,20(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(
ffc0ab80: 3b de 31 c4 addi r30,r30,12740
void _Scheduler_EDF_Unblock(
Thread_Control *the_thread
)
{
_Scheduler_EDF_Enqueue(the_thread);
ffc0ab84: 4b ff fe 0d bl ffc0a990 <_Scheduler_EDF_Enqueue>
ffc0ab88: 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(
ffc0ab8c: 81 3e 00 10 lwz r9,16(r30)
ffc0ab90: 80 0b 21 10 lwz r0,8464(r11)
ffc0ab94: 80 69 00 14 lwz r3,20(r9)
ffc0ab98: 80 9f 00 14 lwz r4,20(r31)
ffc0ab9c: 7c 09 03 a6 mtctr r0
ffc0aba0: 4e 80 04 21 bctrl
ffc0aba4: 2f 83 00 00 cmpwi cr7,r3,0
ffc0aba8: 40 bc 00 34 bge+ cr7,ffc0abdc <_Scheduler_EDF_Unblock+0x74>
_Thread_Heir->current_priority,
the_thread->current_priority )) {
_Thread_Heir = the_thread;
if ( _Thread_Executing->is_preemptible ||
ffc0abac: 81 3e 00 0c lwz r9,12(r30)
* 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;
ffc0abb0: 93 fe 00 10 stw r31,16(r30)
if ( _Thread_Executing->is_preemptible ||
ffc0abb4: 88 09 00 74 lbz r0,116(r9)
ffc0abb8: 2f 80 00 00 cmpwi cr7,r0,0
ffc0abbc: 40 9e 00 10 bne- cr7,ffc0abcc <_Scheduler_EDF_Unblock+0x64><== ALWAYS TAKEN
ffc0abc0: 80 1f 00 14 lwz r0,20(r31) <== NOT EXECUTED
ffc0abc4: 2f 80 00 00 cmpwi cr7,r0,0 <== NOT EXECUTED
ffc0abc8: 40 9e 00 14 bne- cr7,ffc0abdc <_Scheduler_EDF_Unblock+0x74><== NOT EXECUTED
the_thread->current_priority == 0 )
_Thread_Dispatch_necessary = true;
ffc0abcc: 3d 20 00 00 lis r9,0
ffc0abd0: 38 00 00 01 li r0,1
ffc0abd4: 39 29 31 c4 addi r9,r9,12740
ffc0abd8: 98 09 00 18 stb r0,24(r9)
}
}
ffc0abdc: 39 61 00 10 addi r11,r1,16
ffc0abe0: 4b ff 5f 64 b ffc00b44 <_restgpr_30_x>
ffc0abe4 <_Scheduler_EDF_Update>:
#include <rtems/score/thread.h>
void _Scheduler_EDF_Update(
Thread_Control *the_thread
)
{
ffc0abe4: 94 21 ff e8 stwu r1,-24(r1)
ffc0abe8: 7c 08 02 a6 mflr r0
ffc0abec: 90 01 00 1c stw r0,28(r1)
ffc0abf0: bf a1 00 0c stmw r29,12(r1)
ffc0abf4: 7c 7f 1b 78 mr r31,r3
Scheduler_EDF_Per_thread *sched_info =
ffc0abf8: 83 c3 00 8c lwz r30,140(r3)
(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) {
ffc0abfc: 80 1e 00 14 lwz r0,20(r30)
ffc0ac00: 2f 80 00 02 cmpwi cr7,r0,2
ffc0ac04: 40 be 00 20 bne+ cr7,ffc0ac24 <_Scheduler_EDF_Update+0x40>
/* Shifts the priority to the region of background tasks. */
the_thread->Start.initial_priority |= (SCHEDULER_EDF_PRIO_MSB);
ffc0ac08: 80 03 00 b0 lwz r0,176(r3)
ffc0ac0c: 64 00 80 00 oris r0,r0,32768
ffc0ac10: 90 03 00 b0 stw r0,176(r3)
the_thread->real_priority = the_thread->Start.initial_priority;
ffc0ac14: 90 03 00 18 stw r0,24(r3)
the_thread->current_priority = the_thread->Start.initial_priority;
ffc0ac18: 90 03 00 14 stw r0,20(r3)
sched_info->queue_state = SCHEDULER_EDF_QUEUE_STATE_NOT_PRESENTLY;
ffc0ac1c: 38 00 00 00 li r0,0
ffc0ac20: 90 1e 00 14 stw r0,20(r30)
}
if ( sched_info->queue_state == SCHEDULER_EDF_QUEUE_STATE_YES ) {
ffc0ac24: 80 1e 00 14 lwz r0,20(r30)
ffc0ac28: 2f 80 00 01 cmpwi cr7,r0,1
ffc0ac2c: 40 be 00 68 bne+ cr7,ffc0ac94 <_Scheduler_EDF_Update+0xb0><== ALWAYS TAKEN
_RBTree_Extract(&_Scheduler_EDF_Ready_queue, the_node);
ffc0ac30: 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);
ffc0ac34: 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);
ffc0ac38: 3b bd 31 e8 addi r29,r29,12776 <== NOT EXECUTED
ffc0ac3c: 7f a3 eb 78 mr r3,r29 <== NOT EXECUTED
ffc0ac40: 7f c4 f3 78 mr r4,r30 <== NOT EXECUTED
ffc0ac44: 48 00 4d 09 bl ffc0f94c <_RBTree_Extract> <== NOT EXECUTED
_RBTree_Insert(&_Scheduler_EDF_Ready_queue, the_node);
ffc0ac48: 7f c4 f3 78 mr r4,r30 <== NOT EXECUTED
ffc0ac4c: 7f a3 eb 78 mr r3,r29 <== NOT EXECUTED
ffc0ac50: 48 00 4f 85 bl ffc0fbd4 <_RBTree_Insert> <== NOT EXECUTED
_Scheduler_EDF_Schedule();
ffc0ac54: 4b ff fe dd bl ffc0ab30 <_Scheduler_EDF_Schedule> <== NOT EXECUTED
if ( _Thread_Executing != _Thread_Heir ) {
ffc0ac58: 3d 60 00 00 lis r11,0 <== NOT EXECUTED
ffc0ac5c: 39 4b 31 c4 addi r10,r11,12740 <== NOT EXECUTED
ffc0ac60: 81 2a 00 0c lwz r9,12(r10) <== NOT EXECUTED
ffc0ac64: 80 0a 00 10 lwz r0,16(r10) <== NOT EXECUTED
ffc0ac68: 7f 89 00 00 cmpw cr7,r9,r0 <== NOT EXECUTED
ffc0ac6c: 41 9e 00 28 beq- cr7,ffc0ac94 <_Scheduler_EDF_Update+0xb0><== NOT EXECUTED
if ( _Thread_Executing->is_preemptible ||
ffc0ac70: 88 09 00 74 lbz r0,116(r9) <== NOT EXECUTED
ffc0ac74: 2f 80 00 00 cmpwi cr7,r0,0 <== NOT EXECUTED
ffc0ac78: 40 9e 00 10 bne- cr7,ffc0ac88 <_Scheduler_EDF_Update+0xa4><== NOT EXECUTED
ffc0ac7c: 80 1f 00 14 lwz r0,20(r31) <== NOT EXECUTED
ffc0ac80: 2f 80 00 00 cmpwi cr7,r0,0 <== NOT EXECUTED
ffc0ac84: 40 9e 00 10 bne- cr7,ffc0ac94 <_Scheduler_EDF_Update+0xb0><== NOT EXECUTED
the_thread->current_priority == 0 )
_Thread_Dispatch_necessary = true;
ffc0ac88: 39 6b 31 c4 addi r11,r11,12740 <== NOT EXECUTED
ffc0ac8c: 38 00 00 01 li r0,1 <== NOT EXECUTED
ffc0ac90: 98 0b 00 18 stb r0,24(r11) <== NOT EXECUTED
}
}
}
ffc0ac94: 39 61 00 18 addi r11,r1,24
ffc0ac98: 4b ff 5e a8 b ffc00b40 <_restgpr_29_x>
ffc0ac9c <_Scheduler_EDF_Yield>:
#include <rtems/score/scheduler.h>
#include <rtems/score/scheduleredf.h>
#include <rtems/score/thread.h>
void _Scheduler_EDF_Yield(void)
{
ffc0ac9c: 94 21 ff e8 stwu r1,-24(r1) <== NOT EXECUTED
ffc0aca0: 7c 08 02 a6 mflr r0 <== NOT EXECUTED
Scheduler_EDF_Per_thread *first_info;
RBTree_Node *first_node;
ISR_Level level;
Thread_Control *executing = _Thread_Executing;
ffc0aca4: 3d 20 00 00 lis r9,0 <== NOT EXECUTED
#include <rtems/score/scheduler.h>
#include <rtems/score/scheduleredf.h>
#include <rtems/score/thread.h>
void _Scheduler_EDF_Yield(void)
{
ffc0aca8: 90 01 00 1c stw r0,28(r1) <== NOT EXECUTED
ffc0acac: bf 81 00 08 stmw r28,8(r1) <== NOT EXECUTED
Scheduler_EDF_Per_thread *first_info;
RBTree_Node *first_node;
ISR_Level level;
Thread_Control *executing = _Thread_Executing;
ffc0acb0: 83 e9 31 d0 lwz r31,12752(r9) <== NOT EXECUTED
Scheduler_EDF_Per_thread *executing_info =
ffc0acb4: 83 9f 00 8c lwz r28,140(r31) <== NOT EXECUTED
static inline uint32_t ppc_interrupt_disable( void )
{
uint32_t level;
uint32_t mask;
__asm__ volatile (
ffc0acb8: 7f a0 00 a6 mfmsr r29 <== NOT EXECUTED
ffc0acbc: 7c 10 42 a6 mfsprg r0,0 <== NOT EXECUTED
ffc0acc0: 7f a0 00 78 andc r0,r29,r0 <== NOT EXECUTED
ffc0acc4: 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);
ffc0acc8: 3d 20 00 00 lis r9,0 <== NOT EXECUTED
ffc0accc: 81 29 31 ec lwz r9,12780(r9) <== NOT EXECUTED
ffc0acd0: 38 00 00 00 li r0,0 <== NOT EXECUTED
ffc0acd4: 81 69 00 04 lwz r11,4(r9) <== NOT EXECUTED
ffc0acd8: 2f 8b 00 00 cmpwi cr7,r11,0 <== NOT EXECUTED
ffc0acdc: 40 be 00 10 bne+ cr7,ffc0acec <_Scheduler_EDF_Yield+0x50><== NOT EXECUTED
#include <rtems/score/isr.h>
#include <rtems/score/scheduler.h>
#include <rtems/score/scheduleredf.h>
#include <rtems/score/thread.h>
void _Scheduler_EDF_Yield(void)
ffc0ace0: 80 09 00 08 lwz r0,8(r9) <== NOT EXECUTED
ffc0ace4: 7c 00 00 34 cntlzw r0,r0 <== NOT EXECUTED
ffc0ace8: 54 00 d9 7e rlwinm r0,r0,27,5,31 <== NOT EXECUTED
(Scheduler_EDF_Per_thread *) executing->scheduler_info;
RBTree_Node *executing_node = &(executing_info->Node);
_ISR_Disable( level );
if ( !_RBTree_Has_only_one_node(&_Scheduler_EDF_Ready_queue) ) {
ffc0acec: 2f 80 00 00 cmpwi cr7,r0,0 <== NOT EXECUTED
ffc0acf0: 40 be 00 6c bne+ cr7,ffc0ad5c <_Scheduler_EDF_Yield+0xc0><== NOT EXECUTED
/*
* 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 );
ffc0acf4: 3f c0 00 00 lis r30,0 <== NOT EXECUTED
ISR_Level level;
Thread_Control *executing = _Thread_Executing;
Scheduler_EDF_Per_thread *executing_info =
(Scheduler_EDF_Per_thread *) executing->scheduler_info;
RBTree_Node *executing_node = &(executing_info->Node);
ffc0acf8: 3b 9c 00 04 addi r28,r28,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 );
ffc0acfc: 3b de 31 e8 addi r30,r30,12776 <== NOT EXECUTED
ffc0ad00: 7f c3 f3 78 mr r3,r30 <== NOT EXECUTED
ffc0ad04: 7f 84 e3 78 mr r4,r28 <== NOT EXECUTED
ffc0ad08: 48 00 4c 45 bl ffc0f94c <_RBTree_Extract> <== NOT EXECUTED
_RBTree_Insert( &_Scheduler_EDF_Ready_queue, executing_node );
ffc0ad0c: 7f c3 f3 78 mr r3,r30 <== NOT EXECUTED
ffc0ad10: 7f 84 e3 78 mr r4,r28 <== NOT EXECUTED
ffc0ad14: 48 00 4e c1 bl ffc0fbd4 <_RBTree_Insert> <== NOT EXECUTED
static inline void ppc_interrupt_flash( uint32_t level )
{
uint32_t current_level;
__asm__ volatile (
ffc0ad18: 7c 00 00 a6 mfmsr r0 <== NOT EXECUTED
ffc0ad1c: 7f a0 01 24 mtmsr r29 <== NOT EXECUTED
ffc0ad20: 7c 00 01 24 mtmsr r0 <== NOT EXECUTED
ffc0ad24: 3f 80 00 00 lis r28,0 <== NOT EXECUTED
ffc0ad28: 3b 9c 31 c4 addi r28,r28,12740 <== NOT EXECUTED
_ISR_Flash( level );
if ( _Thread_Is_heir( executing ) ) {
ffc0ad2c: 80 1c 00 10 lwz r0,16(r28) <== NOT EXECUTED
ffc0ad30: 7f 9f 00 00 cmpw cr7,r31,r0 <== NOT EXECUTED
ffc0ad34: 40 be 00 18 bne+ cr7,ffc0ad4c <_Scheduler_EDF_Yield+0xb0><== NOT EXECUTED
first_node = _RBTree_Peek( &_Scheduler_EDF_Ready_queue, RBT_LEFT );
ffc0ad38: 7f c3 f3 78 mr r3,r30 <== NOT EXECUTED
ffc0ad3c: 38 80 00 00 li r4,0 <== NOT EXECUTED
ffc0ad40: 48 00 4e a9 bl ffc0fbe8 <_RBTree_Peek> <== NOT EXECUTED
first_info =
_RBTree_Container_of(first_node, Scheduler_EDF_Per_thread, Node);
_Thread_Heir = first_info->thread;
ffc0ad44: 80 03 ff fc lwz r0,-4(r3) <== NOT EXECUTED
ffc0ad48: 90 1c 00 10 stw r0,16(r28) <== NOT EXECUTED
}
_Thread_Dispatch_necessary = true;
ffc0ad4c: 3d 20 00 00 lis r9,0 <== NOT EXECUTED
ffc0ad50: 38 00 00 01 li r0,1 <== NOT EXECUTED
ffc0ad54: 39 29 31 c4 addi r9,r9,12740 <== NOT EXECUTED
ffc0ad58: 48 00 00 1c b ffc0ad74 <_Scheduler_EDF_Yield+0xd8> <== NOT EXECUTED
ffc0ad5c: 3d 20 00 00 lis r9,0 <== NOT EXECUTED
ffc0ad60: 39 29 31 c4 addi r9,r9,12740 <== NOT EXECUTED
}
else if ( !_Thread_Is_heir( executing ) )
ffc0ad64: 80 09 00 10 lwz r0,16(r9) <== NOT EXECUTED
ffc0ad68: 7f 9f 00 00 cmpw cr7,r31,r0 <== NOT EXECUTED
ffc0ad6c: 41 9e 00 0c beq- cr7,ffc0ad78 <_Scheduler_EDF_Yield+0xdc><== NOT EXECUTED
_Thread_Dispatch_necessary = true;
ffc0ad70: 38 00 00 01 li r0,1 <== NOT EXECUTED
ffc0ad74: 98 09 00 18 stb r0,24(r9) <== NOT EXECUTED
return level;
}
static inline void ppc_interrupt_enable( uint32_t level )
{
__asm__ volatile (
ffc0ad78: 7f a0 01 24 mtmsr r29 <== NOT EXECUTED
_ISR_Enable( level );
}
ffc0ad7c: 39 61 00 18 addi r11,r1,24 <== NOT EXECUTED
ffc0ad80: 4b ff 5d bc b ffc00b3c <_restgpr_28_x> <== NOT EXECUTED
ffc09ff4 <_Scheduler_priority_Block>:
)
{
Scheduler_priority_Per_thread *sched_info;
Chain_Control *ready;
sched_info = (Scheduler_priority_Per_thread *) the_thread->scheduler_info;
ffc09ff4: 81 63 00 8c lwz r11,140(r3)
ready = sched_info->ready_chain;
ffc09ff8: 81 2b 00 00 lwz r9,0(r11)
if ( _Chain_Has_only_one_node( ready ) ) {
ffc09ffc: 81 49 00 00 lwz r10,0(r9)
ffc0a000: 80 09 00 08 lwz r0,8(r9)
ffc0a004: 7f 8a 00 00 cmpw cr7,r10,r0
ffc0a008: 40 be 00 4c bne+ cr7,ffc0a054 <_Scheduler_priority_Block+0x60>
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 );
ffc0a00c: 38 09 00 04 addi r0,r9,4
head->next = tail;
head->previous = NULL;
tail->previous = head;
ffc0a010: 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;
ffc0a014: 90 09 00 00 stw r0,0(r9)
head->previous = NULL;
ffc0a018: 38 00 00 00 li r0,0
ffc0a01c: 90 09 00 04 stw r0,4(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;
ffc0a020: 81 2b 00 04 lwz r9,4(r11)
ffc0a024: 80 0b 00 14 lwz r0,20(r11)
ffc0a028: 81 49 00 00 lwz r10,0(r9)
ffc0a02c: 7d 40 00 38 and r0,r10,r0
if ( *the_priority_map->minor == 0 )
ffc0a030: 2f 80 00 00 cmpwi cr7,r0,0
RTEMS_INLINE_ROUTINE void _Priority_bit_map_Remove (
Priority_bit_map_Information *the_priority_map
)
{
*the_priority_map->minor &= the_priority_map->block_minor;
ffc0a034: 90 09 00 00 stw r0,0(r9)
if ( *the_priority_map->minor == 0 )
ffc0a038: 40 9e 00 2c bne- cr7,ffc0a064 <_Scheduler_priority_Block+0x70>
_Priority_Major_bit_map &= the_priority_map->block_major;
ffc0a03c: 3d 20 00 00 lis r9,0
ffc0a040: 80 0b 00 10 lwz r0,16(r11)
ffc0a044: 81 49 28 4c lwz r10,10316(r9)
ffc0a048: 7d 40 00 38 and r0,r10,r0
ffc0a04c: 90 09 28 4c stw r0,10316(r9)
ffc0a050: 48 00 00 14 b ffc0a064 <_Scheduler_priority_Block+0x70>
)
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
ffc0a054: 81 63 00 00 lwz r11,0(r3)
previous = the_node->previous;
ffc0a058: 81 23 00 04 lwz r9,4(r3)
next->previous = previous;
ffc0a05c: 91 2b 00 04 stw r9,4(r11)
previous->next = next;
ffc0a060: 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 );
ffc0a064: 3d 20 00 00 lis r9,0
{
_Scheduler_priority_Ready_queue_extract( the_thread );
/* TODO: flash critical section? */
if ( _Thread_Is_heir( the_thread ) )
ffc0a068: 80 09 31 54 lwz r0,12628(r9)
ffc0a06c: 7f 83 00 00 cmpw cr7,r3,r0
ffc0a070: 40 be 00 60 bne+ cr7,ffc0a0d0 <_Scheduler_priority_Block+0xdc>
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 );
ffc0a074: 3d 40 00 00 lis r10,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
ffc0a078: 3d 20 00 00 lis r9,0
ffc0a07c: 80 0a 28 4c lwz r0,10316(r10)
ffc0a080: 81 29 20 e0 lwz r9,8416(r9)
ffc0a084: 7c 0b 00 34 cntlzw r11,r0
_Bitfield_Find_first_bit( _Priority_Bit_map[major], minor );
ffc0a088: 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 );
ffc0a08c: 90 0a 28 4c stw r0,10316(r10)
_Bitfield_Find_first_bit( _Priority_Bit_map[major], minor );
ffc0a090: 39 08 31 80 addi r8,r8,12672
ffc0a094: 55 6a 10 3a rlwinm r10,r11,2,0,29
ffc0a098: 7c 08 50 2e lwzx r0,r8,r10
ffc0a09c: 7c 07 00 34 cntlzw r7,r0
ffc0a0a0: 7c 08 51 2e stwx r0,r8,r10
return (_Priority_Bits_index( major ) << 4) +
ffc0a0a4: 55 60 20 36 rlwinm r0,r11,4,0,27
ffc0a0a8: 7c 00 3a 14 add r0,r0,r7
Chain_Control *the_ready_queue
)
{
Priority_Control index = _Priority_bit_map_Get_highest();
if ( !_Chain_Is_empty( &the_ready_queue[ index ] ) )
ffc0a0ac: 1c 00 00 0c mulli r0,r0,12
ffc0a0b0: 7d 69 02 14 add r11,r9,r0
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_head( the_chain )->next;
ffc0a0b4: 7c 09 00 2e lwzx r0,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 );
ffc0a0b8: 39 2b 00 04 addi r9,r11,4
ffc0a0bc: 7f 80 48 00 cmpw cr7,r0,r9
ffc0a0c0: 40 be 00 08 bne+ cr7,ffc0a0c8 <_Scheduler_priority_Block+0xd4><== ALWAYS TAKEN
return (Thread_Control *) _Chain_First( &the_ready_queue[ index ] );
return NULL;
ffc0a0c4: 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(
ffc0a0c8: 3d 20 00 00 lis r9,0
ffc0a0cc: 90 09 31 54 stw r0,12628(r9)
RTEMS_INLINE_ROUTINE bool _Thread_Is_executing (
const Thread_Control *the_thread
)
{
return ( the_thread == _Thread_Executing );
ffc0a0d0: 3d 20 00 00 lis r9,0
ffc0a0d4: 39 29 31 44 addi r9,r9,12612
_Scheduler_priority_Schedule_body();
if ( _Thread_Is_executing( the_thread ) )
ffc0a0d8: 80 09 00 0c lwz r0,12(r9)
ffc0a0dc: 7f 83 00 00 cmpw cr7,r3,r0
ffc0a0e0: 4c be 00 20 bnelr+ cr7
_Thread_Dispatch_necessary = true;
ffc0a0e4: 38 00 00 01 li r0,1
ffc0a0e8: 98 09 00 18 stb r0,24(r9)
ffc0a0ec: 4e 80 00 20 blr
ffc0a2c0 <_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 );
ffc0a2c0: 3d 40 00 00 lis r10,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
ffc0a2c4: 3d 20 00 00 lis r9,0
ffc0a2c8: 80 0a 28 4c lwz r0,10316(r10)
ffc0a2cc: 81 29 20 e0 lwz r9,8416(r9)
ffc0a2d0: 7c 0b 00 34 cntlzw r11,r0
_Bitfield_Find_first_bit( _Priority_Bit_map[major], minor );
ffc0a2d4: 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 );
ffc0a2d8: 90 0a 28 4c stw r0,10316(r10)
_Bitfield_Find_first_bit( _Priority_Bit_map[major], minor );
ffc0a2dc: 39 08 31 80 addi r8,r8,12672
ffc0a2e0: 55 6a 10 3a rlwinm r10,r11,2,0,29
ffc0a2e4: 7c 08 50 2e lwzx r0,r8,r10
ffc0a2e8: 7c 07 00 34 cntlzw r7,r0
ffc0a2ec: 7c 08 51 2e stwx r0,r8,r10
return (_Priority_Bits_index( major ) << 4) +
ffc0a2f0: 55 60 20 36 rlwinm r0,r11,4,0,27
ffc0a2f4: 7c 00 3a 14 add r0,r0,r7
Chain_Control *the_ready_queue
)
{
Priority_Control index = _Priority_bit_map_Get_highest();
if ( !_Chain_Is_empty( &the_ready_queue[ index ] ) )
ffc0a2f8: 1c 00 00 0c mulli r0,r0,12
ffc0a2fc: 7d 69 02 14 add r11,r9,r0
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_head( the_chain )->next;
ffc0a300: 7c 09 00 2e lwzx r0,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 );
ffc0a304: 39 2b 00 04 addi r9,r11,4
ffc0a308: 7f 80 48 00 cmpw cr7,r0,r9
ffc0a30c: 40 be 00 08 bne+ cr7,ffc0a314 <_Scheduler_priority_Schedule+0x54><== ALWAYS TAKEN
return (Thread_Control *) _Chain_First( &the_ready_queue[ index ] );
return NULL;
ffc0a310: 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(
ffc0a314: 3d 20 00 00 lis r9,0
ffc0a318: 90 09 31 54 stw r0,12628(r9)
#include <rtems/score/schedulerpriority.h>
void _Scheduler_priority_Schedule(void)
{
_Scheduler_priority_Schedule_body();
}
ffc0a31c: 4e 80 00 20 blr
ffc0a320 <_Scheduler_priority_Tick>:
#include <rtems/system.h>
#include <rtems/score/schedulerpriority.h>
void _Scheduler_priority_Tick( void )
{
ffc0a320: 7c 08 02 a6 mflr r0
ffc0a324: 7c 2b 0b 78 mr r11,r1
ffc0a328: 94 21 ff f0 stwu r1,-16(r1)
Thread_Control *executing;
executing = _Thread_Executing;
ffc0a32c: 3d 20 00 00 lis r9,0
#include <rtems/system.h>
#include <rtems/score/schedulerpriority.h>
void _Scheduler_priority_Tick( void )
{
ffc0a330: 90 01 00 14 stw r0,20(r1)
ffc0a334: 48 01 10 19 bl ffc1b34c <_savegpr_31>
Thread_Control *executing;
executing = _Thread_Executing;
ffc0a338: 83 e9 31 50 lwz r31,12624(r9)
/*
* If the thread is not preemptible or is not ready, then
* just return.
*/
if ( !executing->is_preemptible )
ffc0a33c: 88 1f 00 74 lbz r0,116(r31)
ffc0a340: 2f 80 00 00 cmpwi cr7,r0,0
ffc0a344: 41 9e 00 88 beq- cr7,ffc0a3cc <_Scheduler_priority_Tick+0xac>
return;
if ( !_States_Is_ready( executing->current_state ) )
ffc0a348: 80 1f 00 10 lwz r0,16(r31)
ffc0a34c: 2f 80 00 00 cmpwi cr7,r0,0
ffc0a350: 40 9e 00 7c bne- cr7,ffc0a3cc <_Scheduler_priority_Tick+0xac>
/*
* The cpu budget algorithm determines what happens next.
*/
switch ( executing->budget_algorithm ) {
ffc0a354: 80 1f 00 7c lwz r0,124(r31)
ffc0a358: 2b 80 00 01 cmplwi cr7,r0,1
ffc0a35c: 41 9c 00 70 blt- cr7,ffc0a3cc <_Scheduler_priority_Tick+0xac>
ffc0a360: 2b 80 00 02 cmplwi cr7,r0,2
ffc0a364: 40 9d 00 10 ble- cr7,ffc0a374 <_Scheduler_priority_Tick+0x54>
ffc0a368: 2f 80 00 03 cmpwi cr7,r0,3
ffc0a36c: 40 be 00 60 bne+ cr7,ffc0a3cc <_Scheduler_priority_Tick+0xac><== NEVER TAKEN
ffc0a370: 48 00 00 38 b ffc0a3a8 <_Scheduler_priority_Tick+0x88>
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 ) {
ffc0a374: 81 3f 00 78 lwz r9,120(r31)
ffc0a378: 38 09 ff ff addi r0,r9,-1
ffc0a37c: 2f 80 00 00 cmpwi cr7,r0,0
ffc0a380: 90 1f 00 78 stw r0,120(r31)
ffc0a384: 41 bd 00 48 bgt+ cr7,ffc0a3cc <_Scheduler_priority_Tick+0xac>
* always operates on the scheduler that 'owns' the currently executing
* thread.
*/
RTEMS_INLINE_ROUTINE void _Scheduler_Yield( void )
{
_Scheduler.Operations.yield();
ffc0a388: 3d 20 00 00 lis r9,0
ffc0a38c: 80 09 20 ec lwz r0,8428(r9)
ffc0a390: 7c 09 03 a6 mtctr r0
ffc0a394: 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;
ffc0a398: 3d 20 00 00 lis r9,0
ffc0a39c: 80 09 28 08 lwz r0,10248(r9)
ffc0a3a0: 90 1f 00 78 stw r0,120(r31)
ffc0a3a4: 48 00 00 28 b ffc0a3cc <_Scheduler_priority_Tick+0xac>
}
break;
#if defined(RTEMS_SCORE_THREAD_ENABLE_SCHEDULER_CALLOUT)
case THREAD_CPU_BUDGET_ALGORITHM_CALLOUT:
if ( --executing->cpu_time_budget == 0 )
ffc0a3a8: 81 3f 00 78 lwz r9,120(r31)
ffc0a3ac: 38 09 ff ff addi r0,r9,-1
ffc0a3b0: 2f 80 00 00 cmpwi cr7,r0,0
ffc0a3b4: 90 1f 00 78 stw r0,120(r31)
ffc0a3b8: 40 be 00 14 bne+ cr7,ffc0a3cc <_Scheduler_priority_Tick+0xac>
(*executing->budget_callout)( executing );
ffc0a3bc: 80 1f 00 80 lwz r0,128(r31)
ffc0a3c0: 7f e3 fb 78 mr r3,r31
ffc0a3c4: 7c 09 03 a6 mtctr r0
ffc0a3c8: 4e 80 04 21 bctrl
break;
#endif
}
}
ffc0a3cc: 39 61 00 10 addi r11,r1,16
ffc0a3d0: 4b ff 61 74 b ffc00544 <_restgpr_31_x>
ffc08d48 <_TOD_Validate>:
uint32_t days_in_month;
uint32_t ticks_per_second;
ticks_per_second = TOD_MICROSECONDS_PER_SECOND /
rtems_configuration_get_microseconds_per_tick();
if ((!the_tod) ||
ffc08d48: 2c 03 00 00 cmpwi r3,0
{
uint32_t days_in_month;
uint32_t ticks_per_second;
ticks_per_second = TOD_MICROSECONDS_PER_SECOND /
rtems_configuration_get_microseconds_per_tick();
ffc08d4c: 3d 20 00 00 lis r9,0
ffc08d50: 81 29 20 30 lwz r9,8240(r9)
(the_tod->hour >= TOD_HOURS_PER_DAY) ||
(the_tod->month == 0) ||
(the_tod->month > TOD_MONTHS_PER_YEAR) ||
(the_tod->year < TOD_BASE_YEAR) ||
(the_tod->day == 0) )
return false;
ffc08d54: 38 00 00 00 li r0,0
uint32_t days_in_month;
uint32_t ticks_per_second;
ticks_per_second = TOD_MICROSECONDS_PER_SECOND /
rtems_configuration_get_microseconds_per_tick();
if ((!the_tod) ||
ffc08d58: 41 82 00 94 beq- ffc08dec <_TOD_Validate+0xa4> <== NEVER TAKEN
)
{
uint32_t days_in_month;
uint32_t ticks_per_second;
ticks_per_second = TOD_MICROSECONDS_PER_SECOND /
ffc08d5c: 3d 60 00 0f lis r11,15
ffc08d60: 61 6b 42 40 ori r11,r11,16960
ffc08d64: 7d 2b 4b 96 divwu r9,r11,r9
rtems_configuration_get_microseconds_per_tick();
if ((!the_tod) ||
ffc08d68: 81 63 00 18 lwz r11,24(r3)
ffc08d6c: 7f 8b 48 40 cmplw cr7,r11,r9
ffc08d70: 40 9c 00 7c bge- cr7,ffc08dec <_TOD_Validate+0xa4>
(the_tod->ticks >= ticks_per_second) ||
ffc08d74: 81 23 00 14 lwz r9,20(r3)
ffc08d78: 2b 89 00 3b cmplwi cr7,r9,59
ffc08d7c: 41 9d 00 70 bgt- cr7,ffc08dec <_TOD_Validate+0xa4>
(the_tod->second >= TOD_SECONDS_PER_MINUTE) ||
ffc08d80: 81 23 00 10 lwz r9,16(r3)
ffc08d84: 2b 89 00 3b cmplwi cr7,r9,59
ffc08d88: 41 9d 00 64 bgt- cr7,ffc08dec <_TOD_Validate+0xa4>
(the_tod->minute >= TOD_MINUTES_PER_HOUR) ||
ffc08d8c: 81 23 00 0c lwz r9,12(r3)
ffc08d90: 2b 89 00 17 cmplwi cr7,r9,23
ffc08d94: 41 9d 00 58 bgt- cr7,ffc08dec <_TOD_Validate+0xa4>
(the_tod->hour >= TOD_HOURS_PER_DAY) ||
(the_tod->month == 0) ||
ffc08d98: 81 23 00 04 lwz r9,4(r3)
rtems_configuration_get_microseconds_per_tick();
if ((!the_tod) ||
(the_tod->ticks >= ticks_per_second) ||
(the_tod->second >= TOD_SECONDS_PER_MINUTE) ||
(the_tod->minute >= TOD_MINUTES_PER_HOUR) ||
(the_tod->hour >= TOD_HOURS_PER_DAY) ||
ffc08d9c: 2f 89 00 00 cmpwi cr7,r9,0
ffc08da0: 41 9e 00 4c beq- cr7,ffc08dec <_TOD_Validate+0xa4> <== NEVER TAKEN
(the_tod->month == 0) ||
ffc08da4: 2b 89 00 0c cmplwi cr7,r9,12
ffc08da8: 41 9d 00 44 bgt- cr7,ffc08dec <_TOD_Validate+0xa4>
(the_tod->month > TOD_MONTHS_PER_YEAR) ||
(the_tod->year < TOD_BASE_YEAR) ||
ffc08dac: 81 43 00 00 lwz r10,0(r3)
(the_tod->ticks >= ticks_per_second) ||
(the_tod->second >= TOD_SECONDS_PER_MINUTE) ||
(the_tod->minute >= TOD_MINUTES_PER_HOUR) ||
(the_tod->hour >= TOD_HOURS_PER_DAY) ||
(the_tod->month == 0) ||
(the_tod->month > TOD_MONTHS_PER_YEAR) ||
ffc08db0: 2b 8a 07 c3 cmplwi cr7,r10,1987
ffc08db4: 40 9d 00 38 ble- cr7,ffc08dec <_TOD_Validate+0xa4>
(the_tod->year < TOD_BASE_YEAR) ||
(the_tod->day == 0) )
ffc08db8: 81 63 00 08 lwz r11,8(r3)
(the_tod->second >= TOD_SECONDS_PER_MINUTE) ||
(the_tod->minute >= TOD_MINUTES_PER_HOUR) ||
(the_tod->hour >= TOD_HOURS_PER_DAY) ||
(the_tod->month == 0) ||
(the_tod->month > TOD_MONTHS_PER_YEAR) ||
(the_tod->year < TOD_BASE_YEAR) ||
ffc08dbc: 2f 8b 00 00 cmpwi cr7,r11,0
ffc08dc0: 41 9e 00 2c beq- cr7,ffc08dec <_TOD_Validate+0xa4> <== NEVER TAKEN
(the_tod->day == 0) )
return false;
if ( (the_tod->year % 4) == 0 )
ffc08dc4: 71 40 00 03 andi. r0,r10,3
ffc08dc8: 3d 40 ff c2 lis r10,-62
ffc08dcc: 39 4a fe 34 addi r10,r10,-460
ffc08dd0: 40 82 00 08 bne- ffc08dd8 <_TOD_Validate+0x90>
days_in_month = _TOD_Days_per_month[ 1 ][ the_tod->month ];
ffc08dd4: 39 29 00 0d addi r9,r9,13
else
days_in_month = _TOD_Days_per_month[ 0 ][ the_tod->month ];
ffc08dd8: 55 29 10 3a rlwinm r9,r9,2,0,29
ffc08ddc: 7c 0a 48 2e lwzx r0,r10,r9
* false - if the the_tod is invalid
*
* NOTE: This routine only works for leap-years through 2099.
*/
bool _TOD_Validate(
ffc08de0: 7c 0b 00 10 subfc r0,r11,r0
ffc08de4: 38 00 00 00 li r0,0
ffc08de8: 7c 00 01 14 adde r0,r0,r0
if ( the_tod->day > days_in_month )
return false;
return true;
}
ffc08dec: 7c 03 03 78 mr r3,r0
ffc08df0: 4e 80 00 20 blr
ffc0a5d4 <_Thread_Change_priority>:
void _Thread_Change_priority(
Thread_Control *the_thread,
Priority_Control new_priority,
bool prepend_it
)
{
ffc0a5d4: 94 21 ff e0 stwu r1,-32(r1)
ffc0a5d8: 7c 08 02 a6 mflr r0
ffc0a5dc: 90 01 00 24 stw r0,36(r1)
ffc0a5e0: bf 81 00 10 stmw r28,16(r1)
ffc0a5e4: 7c 7f 1b 78 mr r31,r3
ffc0a5e8: 7c be 2b 78 mr r30,r5
States_Control state, original_state;
/*
* Save original state
*/
original_state = the_thread->current_state;
ffc0a5ec: 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 );
ffc0a5f0: 90 81 00 08 stw r4,8(r1)
ffc0a5f4: 48 00 0e 8d bl ffc0b480 <_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 )
ffc0a5f8: 80 1f 00 14 lwz r0,20(r31)
ffc0a5fc: 80 81 00 08 lwz r4,8(r1)
ffc0a600: 7f 80 20 00 cmpw cr7,r0,r4
ffc0a604: 41 9e 00 0c beq- cr7,ffc0a610 <_Thread_Change_priority+0x3c>
_Thread_Set_priority( the_thread, new_priority );
ffc0a608: 7f e3 fb 78 mr r3,r31
ffc0a60c: 48 00 0d e9 bl ffc0b3f4 <_Thread_Set_priority>
static inline uint32_t ppc_interrupt_disable( void )
{
uint32_t level;
uint32_t mask;
__asm__ volatile (
ffc0a610: 7f 80 00 a6 mfmsr r28
ffc0a614: 7c 10 42 a6 mfsprg r0,0
ffc0a618: 7f 80 00 78 andc r0,r28,r0
ffc0a61c: 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;
ffc0a620: 80 1f 00 10 lwz r0,16(r31)
ffc0a624: 57 bd 07 7a rlwinm r29,r29,0,29,29
if ( state != STATES_TRANSIENT ) {
ffc0a628: 2f 80 00 04 cmpwi cr7,r0,4
ffc0a62c: 41 9e 00 38 beq- cr7,ffc0a664 <_Thread_Change_priority+0x90>
/* Only clear the transient state if it wasn't set already */
if ( ! _States_Is_transient( original_state ) )
ffc0a630: 2f 9d 00 00 cmpwi cr7,r29,0
ffc0a634: 40 9e 00 0c bne- cr7,ffc0a640 <_Thread_Change_priority+0x6c><== NEVER TAKEN
RTEMS_INLINE_ROUTINE States_Control _States_Clear (
States_Control states_to_clear,
States_Control current_state
)
{
return (current_state & ~states_to_clear);
ffc0a638: 54 09 07 b8 rlwinm r9,r0,0,30,28
the_thread->current_state = _States_Clear( STATES_TRANSIENT, state );
ffc0a63c: 91 3f 00 10 stw r9,16(r31)
return level;
}
static inline void ppc_interrupt_enable( uint32_t level )
{
__asm__ volatile (
ffc0a640: 7f 80 01 24 mtmsr r28
_ISR_Enable( level );
if ( _States_Is_waiting_on_thread_queue( state ) ) {
ffc0a644: 3d 20 00 03 lis r9,3
ffc0a648: 61 29 be e0 ori r9,r9,48864
ffc0a64c: 7c 0b 48 39 and. r11,r0,r9
ffc0a650: 41 a2 00 94 beq+ ffc0a6e4 <_Thread_Change_priority+0x110>
_Thread_queue_Requeue( the_thread->Wait.queue, the_thread );
ffc0a654: 80 7f 00 44 lwz r3,68(r31)
ffc0a658: 7f e4 fb 78 mr r4,r31
ffc0a65c: 48 00 0c dd bl ffc0b338 <_Thread_queue_Requeue>
ffc0a660: 48 00 00 84 b ffc0a6e4 <_Thread_Change_priority+0x110>
}
return;
}
/* Only clear the transient state if it wasn't set already */
if ( ! _States_Is_transient( original_state ) ) {
ffc0a664: 2f 9d 00 00 cmpwi cr7,r29,0
ffc0a668: 40 9e 00 30 bne- cr7,ffc0a698 <_Thread_Change_priority+0xc4><== NEVER TAKEN
* 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 )
ffc0a66c: 2f 9e 00 00 cmpwi cr7,r30,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 );
ffc0a670: 93 bf 00 10 stw r29,16(r31)
ffc0a674: 3d 20 00 00 lis r9,0
ffc0a678: 39 29 20 e0 addi r9,r9,8416
if ( prepend_it )
ffc0a67c: 41 9e 00 0c beq- cr7,ffc0a688 <_Thread_Change_priority+0xb4>
*/
RTEMS_INLINE_ROUTINE void _Scheduler_Enqueue_first(
Thread_Control *the_thread
)
{
_Scheduler.Operations.enqueue_first( the_thread );
ffc0a680: 80 09 00 28 lwz r0,40(r9)
ffc0a684: 48 00 00 08 b ffc0a68c <_Thread_Change_priority+0xb8>
*/
RTEMS_INLINE_ROUTINE void _Scheduler_Enqueue(
Thread_Control *the_thread
)
{
_Scheduler.Operations.enqueue( the_thread );
ffc0a688: 80 09 00 24 lwz r0,36(r9)
ffc0a68c: 7f e3 fb 78 mr r3,r31
ffc0a690: 7c 09 03 a6 mtctr r0
ffc0a694: 4e 80 04 21 bctrl
static inline void ppc_interrupt_flash( uint32_t level )
{
uint32_t current_level;
__asm__ volatile (
ffc0a698: 7c 00 00 a6 mfmsr r0
ffc0a69c: 7f 80 01 24 mtmsr r28
ffc0a6a0: 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();
ffc0a6a4: 3d 20 00 00 lis r9,0
ffc0a6a8: 80 09 20 e8 lwz r0,8424(r9)
ffc0a6ac: 7c 09 03 a6 mtctr r0
ffc0a6b0: 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 );
ffc0a6b4: 3d 20 00 00 lis r9,0
ffc0a6b8: 39 29 31 44 addi r9,r9,12612
ffc0a6bc: 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() &&
ffc0a6c0: 80 09 00 10 lwz r0,16(r9)
ffc0a6c4: 7f 8b 00 00 cmpw cr7,r11,r0
ffc0a6c8: 41 9e 00 18 beq- cr7,ffc0a6e0 <_Thread_Change_priority+0x10c>
ffc0a6cc: 88 0b 00 74 lbz r0,116(r11)
ffc0a6d0: 2f 80 00 00 cmpwi cr7,r0,0
ffc0a6d4: 41 9e 00 0c beq- cr7,ffc0a6e0 <_Thread_Change_priority+0x10c>
_Thread_Executing->is_preemptible )
_Thread_Dispatch_necessary = true;
ffc0a6d8: 38 00 00 01 li r0,1
ffc0a6dc: 98 09 00 18 stb r0,24(r9)
return level;
}
static inline void ppc_interrupt_enable( uint32_t level )
{
__asm__ volatile (
ffc0a6e0: 7f 80 01 24 mtmsr r28
_ISR_Enable( level );
}
ffc0a6e4: 39 61 00 20 addi r11,r1,32
ffc0a6e8: 4b ff 5e 50 b ffc00538 <_restgpr_28_x>
ffc0a904 <_Thread_Delay_ended>:
void _Thread_Delay_ended(
Objects_Id id,
void *ignored __attribute__((unused))
)
{
ffc0a904: 94 21 ff e8 stwu r1,-24(r1)
ffc0a908: 7c 08 02 a6 mflr r0
Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
ffc0a90c: 38 81 00 08 addi r4,r1,8
void _Thread_Delay_ended(
Objects_Id id,
void *ignored __attribute__((unused))
)
{
ffc0a910: 90 01 00 1c stw r0,28(r1)
Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
ffc0a914: 48 00 01 d9 bl ffc0aaec <_Thread_Get>
switch ( location ) {
ffc0a918: 80 01 00 08 lwz r0,8(r1)
ffc0a91c: 2f 80 00 00 cmpwi cr7,r0,0
ffc0a920: 40 9e 00 24 bne- cr7,ffc0a944 <_Thread_Delay_ended+0x40><== NEVER TAKEN
#if defined(RTEMS_MULTIPROCESSING)
case OBJECTS_REMOTE: /* impossible */
#endif
break;
case OBJECTS_LOCAL:
_Thread_Clear_state(
ffc0a924: 3c 80 10 00 lis r4,4096
ffc0a928: 60 84 00 18 ori r4,r4,24
ffc0a92c: 4b ff fd c1 bl ffc0a6ec <_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--;
ffc0a930: 3d 20 00 00 lis r9,0
ffc0a934: 81 69 28 0c lwz r11,10252(r9)
ffc0a938: 38 0b ff ff addi r0,r11,-1
ffc0a93c: 90 09 28 0c stw r0,10252(r9)
return _Thread_Dispatch_disable_level;
ffc0a940: 80 09 28 0c lwz r0,10252(r9)
| STATES_INTERRUPTIBLE_BY_SIGNAL
);
_Thread_Unnest_dispatch();
break;
}
}
ffc0a944: 80 01 00 1c lwz r0,28(r1)
ffc0a948: 38 21 00 18 addi r1,r1,24
ffc0a94c: 7c 08 03 a6 mtlr r0
ffc0a950: 4e 80 00 20 blr
ffc0a954 <_Thread_Dispatch>:
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
_Thread_Dispatch_disable_level++;
ffc0a954: 3d 20 00 00 lis r9,0
* INTERRUPT LATENCY:
* dispatch thread
* no dispatch thread
*/
void _Thread_Dispatch( void )
{
ffc0a958: 94 21 ff c8 stwu r1,-56(r1)
ffc0a95c: 7c 08 02 a6 mflr r0
ffc0a960: 81 69 28 0c lwz r11,10252(r9)
ffc0a964: 90 01 00 3c stw r0,60(r1)
ffc0a968: 38 0b 00 01 addi r0,r11,1
ffc0a96c: 90 09 28 0c stw r0,10252(r9)
ffc0a970: bf 21 00 1c stmw r25,28(r1)
return _Thread_Dispatch_disable_level;
ffc0a974: 80 09 28 0c lwz r0,10252(r9)
#endif
/*
* Now determine if we need to perform a dispatch on the current CPU.
*/
executing = _Thread_Executing;
ffc0a978: 3f 80 00 00 lis r28,0
ffc0a97c: 3b bc 31 44 addi r29,r28,12612
ffc0a980: 83 fd 00 0c lwz r31,12(r29)
static inline uint32_t ppc_interrupt_disable( void )
{
uint32_t level;
uint32_t mask;
__asm__ volatile (
ffc0a984: 7c 00 00 a6 mfmsr r0
ffc0a988: 7d 30 42 a6 mfsprg r9,0
ffc0a98c: 7c 09 48 78 andc r9,r0,r9
ffc0a990: 7d 20 01 24 mtmsr r9
_ISR_Disable( level );
while ( _Thread_Dispatch_necessary == true ) {
heir = _Thread_Heir;
_Thread_Dispatch_necessary = false;
ffc0a994: 3b 20 00 00 li r25,0
#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;
ffc0a998: 3f 40 00 00 lis r26,0
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
{
Timestamp_Control uptime, ran;
_TOD_Get_uptime( &uptime );
_Timestamp_Subtract(
ffc0a99c: 3b bd 00 1c addi r29,r29,28
#endif
/*
* Switch libc's task specific data.
*/
if ( _Thread_libc_reent ) {
ffc0a9a0: 3f 60 00 00 lis r27,0
/*
* Now determine if we need to perform a dispatch on the current CPU.
*/
executing = _Thread_Executing;
_ISR_Disable( level );
while ( _Thread_Dispatch_necessary == true ) {
ffc0a9a4: 48 00 00 d8 b ffc0aa7c <_Thread_Dispatch+0x128>
heir = _Thread_Heir;
ffc0a9a8: 83 c9 00 10 lwz r30,16(r9)
_Thread_Dispatch_necessary = false;
ffc0a9ac: 9b 29 00 18 stb r25,24(r9)
/*
* 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 )
ffc0a9b0: 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;
ffc0a9b4: 93 c9 00 0c stw r30,12(r9)
/*
* 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 )
ffc0a9b8: 41 9e 00 d4 beq- cr7,ffc0aa8c <_Thread_Dispatch+0x138>
*/
#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 )
ffc0a9bc: 81 3e 00 7c lwz r9,124(r30)
ffc0a9c0: 2f 89 00 01 cmpwi cr7,r9,1
ffc0a9c4: 40 be 00 0c bne+ cr7,ffc0a9d0 <_Thread_Dispatch+0x7c>
heir->cpu_time_budget = _Thread_Ticks_per_timeslice;
ffc0a9c8: 81 3a 28 08 lwz r9,10248(r26)
ffc0a9cc: 91 3e 00 78 stw r9,120(r30)
return level;
}
static inline void ppc_interrupt_enable( uint32_t level )
{
__asm__ volatile (
ffc0a9d0: 7c 00 01 24 mtmsr r0
_ISR_Enable( level );
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
{
Timestamp_Control uptime, ran;
_TOD_Get_uptime( &uptime );
ffc0a9d4: 38 61 00 10 addi r3,r1,16
ffc0a9d8: 48 00 3c 99 bl ffc0e670 <_TOD_Get_uptime>
_Timestamp_Subtract(
ffc0a9dc: 7f a3 eb 78 mr r3,r29
ffc0a9e0: 38 81 00 10 addi r4,r1,16
ffc0a9e4: 38 a1 00 08 addi r5,r1,8
ffc0a9e8: 48 00 0c d1 bl ffc0b6b8 <_Timespec_Subtract>
&_Thread_Time_of_last_context_switch,
&uptime,
&ran
);
_Timestamp_Add_to( &executing->cpu_time_used, &ran );
ffc0a9ec: 38 7f 00 84 addi r3,r31,132
ffc0a9f0: 38 81 00 08 addi r4,r1,8
ffc0a9f4: 48 00 0c 69 bl ffc0b65c <_Timespec_Add_to>
#endif
/*
* Switch libc's task specific data.
*/
if ( _Thread_libc_reent ) {
ffc0a9f8: 81 3b 28 20 lwz r9,10272(r27)
&_Thread_Time_of_last_context_switch,
&uptime,
&ran
);
_Timestamp_Add_to( &executing->cpu_time_used, &ran );
_Thread_Time_of_last_context_switch = uptime;
ffc0a9fc: 81 41 00 10 lwz r10,16(r1)
#endif
/*
* Switch libc's task specific data.
*/
if ( _Thread_libc_reent ) {
ffc0aa00: 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;
ffc0aa04: 81 61 00 14 lwz r11,20(r1)
ffc0aa08: 91 5d 00 00 stw r10,0(r29)
ffc0aa0c: 91 7d 00 04 stw r11,4(r29)
#endif
/*
* Switch libc's task specific data.
*/
if ( _Thread_libc_reent ) {
ffc0aa10: 41 9e 00 14 beq- cr7,ffc0aa24 <_Thread_Dispatch+0xd0> <== NEVER TAKEN
executing->libc_reent = *_Thread_libc_reent;
ffc0aa14: 80 09 00 00 lwz r0,0(r9)
ffc0aa18: 90 1f 01 2c stw r0,300(r31)
*_Thread_libc_reent = heir->libc_reent;
ffc0aa1c: 80 1e 01 2c lwz r0,300(r30)
ffc0aa20: 90 09 00 00 stw r0,0(r9)
}
_User_extensions_Thread_switch( executing, heir );
ffc0aa24: 7f e3 fb 78 mr r3,r31
ffc0aa28: 7f c4 f3 78 mr r4,r30
ffc0aa2c: 48 00 0f b5 bl ffc0b9e0 <_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 )
ffc0aa30: 80 1f 01 28 lwz r0,296(r31)
ffc0aa34: 2f 80 00 00 cmpwi cr7,r0,0
ffc0aa38: 41 9e 00 0c beq- cr7,ffc0aa44 <_Thread_Dispatch+0xf0>
_Context_Save_fp( &executing->fp_context );
ffc0aa3c: 38 7f 01 28 addi r3,r31,296
ffc0aa40: 48 01 09 e1 bl ffc1b420 <_CPU_Context_save_fp>
#endif
#endif
_Context_Switch( &executing->Registers, &heir->Registers );
ffc0aa44: 38 7f 00 c8 addi r3,r31,200
ffc0aa48: 38 9e 00 c8 addi r4,r30,200
ffc0aa4c: 48 01 0b 55 bl ffc1b5a0 <_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 )
ffc0aa50: 80 1f 01 28 lwz r0,296(r31)
ffc0aa54: 2f 80 00 00 cmpwi cr7,r0,0
ffc0aa58: 41 9e 00 0c beq- cr7,ffc0aa64 <_Thread_Dispatch+0x110>
_Context_Restore_fp( &executing->fp_context );
ffc0aa5c: 38 7f 01 28 addi r3,r31,296
ffc0aa60: 48 01 0a 81 bl ffc1b4e0 <_CPU_Context_restore_fp>
#endif
#endif
executing = _Thread_Executing;
ffc0aa64: 39 3c 31 44 addi r9,r28,12612
ffc0aa68: 83 e9 00 0c lwz r31,12(r9)
static inline uint32_t ppc_interrupt_disable( void )
{
uint32_t level;
uint32_t mask;
__asm__ volatile (
ffc0aa6c: 7c 00 00 a6 mfmsr r0
ffc0aa70: 7d 30 42 a6 mfsprg r9,0
ffc0aa74: 7c 09 48 78 andc r9,r0,r9
ffc0aa78: 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 ) {
ffc0aa7c: 39 3c 31 44 addi r9,r28,12612
ffc0aa80: 89 69 00 18 lbz r11,24(r9)
ffc0aa84: 2f 8b 00 00 cmpwi cr7,r11,0
ffc0aa88: 40 9e ff 20 bne+ cr7,ffc0a9a8 <_Thread_Dispatch+0x54>
return level;
}
static inline void ppc_interrupt_enable( uint32_t level )
{
__asm__ volatile (
ffc0aa8c: 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--;
ffc0aa90: 3d 20 00 00 lis r9,0
ffc0aa94: 81 69 28 0c lwz r11,10252(r9)
ffc0aa98: 38 0b ff ff addi r0,r11,-1
ffc0aa9c: 90 09 28 0c stw r0,10252(r9)
return _Thread_Dispatch_disable_level;
ffc0aaa0: 80 09 28 0c lwz r0,10252(r9)
_ISR_Enable( level );
_Thread_Unnest_dispatch();
_API_extensions_Run_postswitch();
ffc0aaa4: 4b ff e0 15 bl ffc08ab8 <_API_extensions_Run_postswitch>
}
ffc0aaa8: 39 61 00 38 addi r11,r1,56
ffc0aaac: 4b ff 5a 80 b ffc0052c <_restgpr_25_x>
ffc1098c <_Thread_Handler>:
* Input parameters: NONE
*
* Output parameters: NONE
*/
void _Thread_Handler( void )
{
ffc1098c: 94 21 ff f0 stwu r1,-16(r1)
ffc10990: 7c 08 02 a6 mflr r0
#if defined(EXECUTE_GLOBAL_CONSTRUCTORS)
static bool doneConstructors;
bool doCons;
#endif
executing = _Thread_Executing;
ffc10994: 3d 20 00 00 lis r9,0
* Input parameters: NONE
*
* Output parameters: NONE
*/
void _Thread_Handler( void )
{
ffc10998: 90 01 00 14 stw r0,20(r1)
ffc1099c: bf c1 00 08 stmw r30,8(r1)
#if defined(EXECUTE_GLOBAL_CONSTRUCTORS)
static bool doneConstructors;
bool doCons;
#endif
executing = _Thread_Executing;
ffc109a0: 83 e9 31 50 lwz r31,12624(r9)
/*
* have to put level into a register for those cpu's that use
* inline asm here
*/
level = executing->Start.isr_level;
ffc109a4: 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);
ffc109a8: 38 00 00 00 li r0,0
ffc109ac: 7c 00 00 a6 mfmsr r0
if (!(level & CPU_MODES_INTERRUPT_MASK)) {
ffc109b0: 71 2b 00 01 andi. r11,r9,1
static inline uint32_t ppc_interrupt_get_disable_mask( void )
{
uint32_t mask;
__asm__ volatile (
ffc109b4: 7d 30 42 a6 mfsprg r9,0
ffc109b8: 40 82 00 0c bne- ffc109c4 <_Thread_Handler+0x38>
msr |= ppc_interrupt_get_disable_mask();
ffc109bc: 7d 20 03 78 or r0,r9,r0
ffc109c0: 48 00 00 08 b ffc109c8 <_Thread_Handler+0x3c>
}
else {
msr &= ~ppc_interrupt_get_disable_mask();
ffc109c4: 7c 00 48 78 andc r0,r0,r9
}
_CPU_MSR_SET(msr);
ffc109c8: 7c 00 01 24 mtmsr r0
doCons = !doneConstructors
&& _Objects_Get_API( executing->Object.id ) != OBJECTS_INTERNAL_API;
if (doCons)
doneConstructors = true;
#else
doCons = !doneConstructors;
ffc109cc: 3d 20 00 00 lis r9,0
ffc109d0: 8b c9 29 f8 lbz r30,10744(r9)
doneConstructors = true;
ffc109d4: 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 );
ffc109d8: 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;
ffc109dc: 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 );
ffc109e0: 4b ff ad cd bl ffc0b7ac <_User_extensions_Thread_begin>
/*
* At this point, the dispatch disable level BETTER be 1.
*/
_Thread_Enable_dispatch();
ffc109e4: 4b ff a0 cd bl ffc0aab0 <_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) */ {
ffc109e8: 2f 9e 00 00 cmpwi cr7,r30,0
ffc109ec: 40 be 00 08 bne+ cr7,ffc109f4 <_Thread_Handler+0x68>
INIT_NAME ();
ffc109f0: 48 00 bc 4d bl ffc1c63c <_init>
_Thread_Enable_dispatch();
#endif
}
#endif
if ( executing->Start.prototype == THREAD_START_NUMERIC ) {
ffc109f4: 80 1f 00 94 lwz r0,148(r31)
ffc109f8: 2f 80 00 00 cmpwi cr7,r0,0
ffc109fc: 40 be 00 10 bne+ cr7,ffc10a0c <_Thread_Handler+0x80>
executing->Wait.return_argument =
(*(Thread_Entry_numeric) executing->Start.entry_point)(
ffc10a00: 80 1f 00 90 lwz r0,144(r31)
ffc10a04: 80 7f 00 9c lwz r3,156(r31)
ffc10a08: 48 00 00 14 b ffc10a1c <_Thread_Handler+0x90>
executing->Start.numeric_argument
);
}
#if defined(RTEMS_POSIX_API)
else if ( executing->Start.prototype == THREAD_START_POINTER ) {
ffc10a0c: 2f 80 00 01 cmpwi cr7,r0,1
ffc10a10: 40 be 00 18 bne+ cr7,ffc10a28 <_Thread_Handler+0x9c> <== NEVER TAKEN
executing->Wait.return_argument =
(*(Thread_Entry_pointer) executing->Start.entry_point)(
ffc10a14: 80 1f 00 90 lwz r0,144(r31)
ffc10a18: 80 7f 00 98 lwz r3,152(r31)
ffc10a1c: 7c 09 03 a6 mtctr r0
ffc10a20: 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 =
ffc10a24: 90 7f 00 28 stw r3,40(r31)
* 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 );
ffc10a28: 7f e3 fb 78 mr r3,r31
ffc10a2c: 4b ff ad d5 bl ffc0b800 <_User_extensions_Thread_exitted>
_Internal_error_Occurred(
ffc10a30: 38 60 00 00 li r3,0
ffc10a34: 38 80 00 01 li r4,1
ffc10a38: 38 a0 00 05 li r5,5
ffc10a3c: 4b ff 8c 2d bl ffc09668 <_Internal_error_Occurred>
ffc0ab9c <_Thread_Initialize>:
Thread_CPU_budget_algorithms budget_algorithm,
Thread_CPU_budget_algorithm_callout budget_callout,
uint32_t isr_level,
Objects_Name name
)
{
ffc0ab9c: 94 21 ff d0 stwu r1,-48(r1)
ffc0aba0: 7c 08 02 a6 mflr r0
ffc0aba4: be e1 00 0c stmw r23,12(r1)
if ( !actual_stack_size || actual_stack_size < stack_size )
return false; /* stack allocation failed */
stack = the_thread->Start.stack;
#else
if ( !stack_area ) {
ffc0aba8: 7c b7 2b 79 mr. r23,r5
Thread_CPU_budget_algorithms budget_algorithm,
Thread_CPU_budget_algorithm_callout budget_callout,
uint32_t isr_level,
Objects_Name name
)
{
ffc0abac: 7d 3a 4b 78 mr r26,r9
ffc0abb0: 90 01 00 34 stw r0,52(r1)
/*
* Zero out all the allocated memory fields
*/
for ( i=0 ; i <= THREAD_API_LAST ; i++ )
the_thread->API_Extensions[i] = NULL;
ffc0abb4: 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
)
{
ffc0abb8: 7c 7e 1b 78 mr r30,r3
ffc0abbc: 81 21 00 40 lwz r9,64(r1)
ffc0abc0: 7c 9f 23 78 mr r31,r4
ffc0abc4: 7c dd 33 78 mr r29,r6
/*
* Zero out all the allocated memory fields
*/
for ( i=0 ; i <= THREAD_API_LAST ; i++ )
the_thread->API_Extensions[i] = NULL;
ffc0abc8: 90 04 01 30 stw r0,304(r4)
Thread_CPU_budget_algorithms budget_algorithm,
Thread_CPU_budget_algorithm_callout budget_callout,
uint32_t isr_level,
Objects_Name name
)
{
ffc0abcc: 7c fc 3b 78 mr r28,r7
ffc0abd0: 7d 1b 43 78 mr r27,r8
ffc0abd4: 83 09 00 00 lwz r24,0(r9)
ffc0abd8: 7d 59 53 78 mr r25,r10
/*
* Zero out all the allocated memory fields
*/
for ( i=0 ; i <= THREAD_API_LAST ; i++ )
the_thread->API_Extensions[i] = NULL;
ffc0abdc: 90 04 01 34 stw r0,308(r4)
extensions_area = NULL;
the_thread->libc_reent = NULL;
ffc0abe0: 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 ) {
ffc0abe4: 40 a2 00 38 bne+ ffc0ac1c <_Thread_Initialize+0x80>
actual_stack_size = _Thread_Stack_Allocate( the_thread, stack_size );
ffc0abe8: 7c 83 23 78 mr r3,r4
ffc0abec: 7c c4 33 78 mr r4,r6
ffc0abf0: 48 00 08 e5 bl ffc0b4d4 <_Thread_Stack_Allocate>
if ( !actual_stack_size || actual_stack_size < stack_size )
return false; /* stack allocation failed */
ffc0abf4: 38 00 00 00 li r0,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 )
ffc0abf8: 2c 03 00 00 cmpwi r3,0
ffc0abfc: 41 82 01 b0 beq- ffc0adac <_Thread_Initialize+0x210>
ffc0ac00: 7f 83 e8 40 cmplw cr7,r3,r29
return false; /* stack allocation failed */
ffc0ac04: 7e e0 bb 78 mr r0,r23
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 )
ffc0ac08: 41 9c 01 a4 blt- cr7,ffc0adac <_Thread_Initialize+0x210><== NEVER TAKEN
return false; /* stack allocation failed */
stack = the_thread->Start.stack;
the_thread->Start.core_allocated_stack = true;
ffc0ac0c: 38 00 00 01 li r0,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;
ffc0ac10: 82 ff 00 c4 lwz r23,196(r31)
the_thread->Start.core_allocated_stack = true;
ffc0ac14: 98 1f 00 b4 stb r0,180(r31)
ffc0ac18: 48 00 00 0c b ffc0ac24 <_Thread_Initialize+0x88>
} else {
stack = stack_area;
actual_stack_size = stack_size;
the_thread->Start.core_allocated_stack = false;
ffc0ac1c: 98 04 00 b4 stb r0,180(r4)
ffc0ac20: 7c c3 33 78 mr r3,r6
/*
* Allocate the floating point area for this thread
*/
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
if ( is_fp ) {
ffc0ac24: 2f 9c 00 00 cmpwi cr7,r28,0
Stack_Control *the_stack,
void *starting_address,
size_t size
)
{
the_stack->area = starting_address;
ffc0ac28: 92 ff 00 bc stw r23,188(r31)
extensions_area = NULL;
the_thread->libc_reent = NULL;
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
fp_area = NULL;
ffc0ac2c: 3a e0 00 00 li r23,0
the_stack->size = size;
ffc0ac30: 90 7f 00 b8 stw r3,184(r31)
/*
* Allocate the floating point area for this thread
*/
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
if ( is_fp ) {
ffc0ac34: 41 be 00 14 beq+ cr7,ffc0ac48 <_Thread_Initialize+0xac>
fp_area = _Workspace_Allocate( CONTEXT_FP_SIZE );
ffc0ac38: 38 60 01 08 li r3,264
ffc0ac3c: 48 00 11 11 bl ffc0bd4c <_Workspace_Allocate>
if ( !fp_area )
ffc0ac40: 7c 77 1b 79 mr. r23,r3
ffc0ac44: 41 82 01 24 beq- ffc0ad68 <_Thread_Initialize+0x1cc>
#endif
/*
* Allocate the extensions area for this thread
*/
if ( _Thread_Maximum_extensions ) {
ffc0ac48: 3d 20 00 00 lis r9,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;
ffc0ac4c: 92 ff 01 28 stw r23,296(r31)
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
ffc0ac50: 38 00 00 00 li r0,0
#endif
/*
* Allocate the extensions area for this thread
*/
if ( _Thread_Maximum_extensions ) {
ffc0ac54: 80 69 28 2c lwz r3,10284(r9)
* Zero out all the allocated memory fields
*/
for ( i=0 ; i <= THREAD_API_LAST ; i++ )
the_thread->API_Extensions[i] = NULL;
extensions_area = NULL;
ffc0ac58: 3b a0 00 00 li r29,0
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;
ffc0ac5c: 92 ff 00 c0 stw r23,192(r31)
#endif
/*
* Allocate the extensions area for this thread
*/
if ( _Thread_Maximum_extensions ) {
ffc0ac60: 2f 83 00 00 cmpwi cr7,r3,0
ffc0ac64: 90 1f 00 50 stw r0,80(r31)
the_watchdog->routine = routine;
ffc0ac68: 90 1f 00 64 stw r0,100(r31)
the_watchdog->id = id;
ffc0ac6c: 90 1f 00 68 stw r0,104(r31)
the_watchdog->user_data = user_data;
ffc0ac70: 90 1f 00 6c stw r0,108(r31)
ffc0ac74: 41 be 00 18 beq+ cr7,ffc0ac8c <_Thread_Initialize+0xf0>
extensions_area = _Workspace_Allocate(
ffc0ac78: 38 63 00 01 addi r3,r3,1
ffc0ac7c: 54 63 10 3a rlwinm r3,r3,2,0,29
ffc0ac80: 48 00 10 cd bl ffc0bd4c <_Workspace_Allocate>
(_Thread_Maximum_extensions + 1) * sizeof( void * )
);
if ( !extensions_area )
ffc0ac84: 7c 7d 1b 79 mr. r29,r3
ffc0ac88: 41 82 00 e4 beq- ffc0ad6c <_Thread_Initialize+0x1d0>
* if they are linked to the thread. An extension user may
* create the extension long after tasks have been created
* so they cannot rely on the thread create user extension
* call.
*/
if ( the_thread->extensions ) {
ffc0ac8c: 2f 9d 00 00 cmpwi cr7,r29,0
(_Thread_Maximum_extensions + 1) * sizeof( void * )
);
if ( !extensions_area )
goto failed;
}
the_thread->extensions = (void **) extensions_area;
ffc0ac90: 93 bf 01 38 stw r29,312(r31)
* if they are linked to the thread. An extension user may
* create the extension long after tasks have been created
* so they cannot rely on the thread create user extension
* call.
*/
if ( the_thread->extensions ) {
ffc0ac94: 41 9e 00 30 beq- cr7,ffc0acc4 <_Thread_Initialize+0x128>
for ( i = 0; i <= _Thread_Maximum_extensions ; i++ )
ffc0ac98: 3d 20 00 00 lis r9,0
ffc0ac9c: 81 69 28 2c lwz r11,10284(r9)
the_thread->extensions[i] = NULL;
ffc0aca0: 38 00 00 00 li r0,0
* 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++ )
ffc0aca4: 39 20 00 00 li r9,0
ffc0aca8: 48 00 00 14 b ffc0acbc <_Thread_Initialize+0x120>
the_thread->extensions[i] = NULL;
ffc0acac: 81 1f 01 38 lwz r8,312(r31)
ffc0acb0: 55 2a 10 3a rlwinm r10,r9,2,0,29
* 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++ )
ffc0acb4: 39 29 00 01 addi r9,r9,1
the_thread->extensions[i] = NULL;
ffc0acb8: 7c 08 51 2e stwx r0,r8,r10
* 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++ )
ffc0acbc: 7f 89 58 40 cmplw cr7,r9,r11
ffc0acc0: 40 9d ff ec ble+ cr7,ffc0acac <_Thread_Initialize+0x110>
the_thread->Start.is_preemptible = is_preemptible;
the_thread->Start.budget_algorithm = budget_algorithm;
the_thread->Start.budget_callout = budget_callout;
switch ( budget_algorithm ) {
ffc0acc4: 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;
ffc0acc8: 80 01 00 38 lwz r0,56(r1)
/*
* General initialization
*/
the_thread->Start.is_preemptible = is_preemptible;
ffc0accc: 9b 5f 00 a0 stb r26,160(r31)
the_thread->Start.budget_algorithm = budget_algorithm;
ffc0acd0: 93 3f 00 a4 stw r25,164(r31)
the_thread->Start.budget_callout = budget_callout;
ffc0acd4: 90 1f 00 a8 stw r0,168(r31)
switch ( budget_algorithm ) {
ffc0acd8: 40 be 00 10 bne+ cr7,ffc0ace8 <_Thread_Initialize+0x14c>
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;
ffc0acdc: 3d 20 00 00 lis r9,0
ffc0ace0: 80 09 28 08 lwz r0,10248(r9)
ffc0ace4: 90 1f 00 78 stw r0,120(r31)
case THREAD_CPU_BUDGET_ALGORITHM_CALLOUT:
break;
#endif
}
the_thread->Start.isr_level = isr_level;
ffc0ace8: 80 01 00 3c lwz r0,60(r1)
*/
RTEMS_INLINE_ROUTINE void* _Scheduler_Allocate(
Thread_Control *the_thread
)
{
return _Scheduler.Operations.allocate( the_thread );
ffc0acec: 3d 20 00 00 lis r9,0
the_thread->current_state = STATES_DORMANT;
the_thread->Wait.queue = NULL;
ffc0acf0: 3b 80 00 00 li r28,0
the_thread->resource_count = 0;
the_thread->real_priority = priority;
ffc0acf4: 93 7f 00 18 stw r27,24(r31)
ffc0acf8: 7f e3 fb 78 mr r3,r31
case THREAD_CPU_BUDGET_ALGORITHM_CALLOUT:
break;
#endif
}
the_thread->Start.isr_level = isr_level;
ffc0acfc: 90 1f 00 ac stw r0,172(r31)
the_thread->current_state = STATES_DORMANT;
ffc0ad00: 38 00 00 01 li r0,1
ffc0ad04: 90 1f 00 10 stw r0,16(r31)
ffc0ad08: 80 09 20 f8 lwz r0,8440(r9)
the_thread->Wait.queue = NULL;
ffc0ad0c: 93 9f 00 44 stw r28,68(r31)
ffc0ad10: 7c 09 03 a6 mtctr r0
the_thread->resource_count = 0;
ffc0ad14: 93 9f 00 1c stw r28,28(r31)
the_thread->real_priority = priority;
the_thread->Start.initial_priority = priority;
ffc0ad18: 93 7f 00 b0 stw r27,176(r31)
ffc0ad1c: 4e 80 04 21 bctrl
sched =_Scheduler_Allocate( the_thread );
if ( !sched )
ffc0ad20: 7c 7a 1b 79 mr. r26,r3
ffc0ad24: 41 82 00 4c beq- ffc0ad70 <_Thread_Initialize+0x1d4>
goto failed;
_Thread_Set_priority( the_thread, priority );
ffc0ad28: 7f e3 fb 78 mr r3,r31
ffc0ad2c: 7f 64 db 78 mr r4,r27
ffc0ad30: 48 00 06 c5 bl ffc0b3f4 <_Thread_Set_priority>
Objects_Information *information,
Objects_Control *the_object,
Objects_Name name
)
{
_Objects_Set_local_object(
ffc0ad34: a0 1f 00 0a lhz r0,10(r31)
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
ffc0ad38: 81 3e 00 1c lwz r9,28(r30)
* 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 );
ffc0ad3c: 7f e3 fb 78 mr r3,r31
ffc0ad40: 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 );
ffc0ad44: 93 9f 00 84 stw r28,132(r31)
ffc0ad48: 93 9f 00 88 stw r28,136(r31)
ffc0ad4c: 7f e9 01 2e stwx r31,r9,r0
information,
_Objects_Get_index( the_object->id ),
the_object
);
the_object->name = name;
ffc0ad50: 93 1f 00 0c stw r24,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 );
ffc0ad54: 48 00 0b 5d bl ffc0b8b0 <_User_extensions_Thread_create>
if ( extension_status )
return true;
ffc0ad58: 38 00 00 01 li r0,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 )
ffc0ad5c: 2f 83 00 00 cmpwi cr7,r3,0
ffc0ad60: 41 be 00 10 beq+ cr7,ffc0ad70 <_Thread_Initialize+0x1d4>
ffc0ad64: 48 00 00 48 b ffc0adac <_Thread_Initialize+0x210>
* Zero out all the allocated memory fields
*/
for ( i=0 ; i <= THREAD_API_LAST ; i++ )
the_thread->API_Extensions[i] = NULL;
extensions_area = NULL;
ffc0ad68: 3b a0 00 00 li r29,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;
ffc0ad6c: 3b 40 00 00 li r26,0
extension_status = _User_extensions_Thread_create( the_thread );
if ( extension_status )
return true;
failed:
_Workspace_Free( the_thread->libc_reent );
ffc0ad70: 80 7f 01 2c lwz r3,300(r31)
ffc0ad74: 48 00 10 0d bl ffc0bd80 <_Workspace_Free>
for ( i=0 ; i <= THREAD_API_LAST ; i++ )
_Workspace_Free( the_thread->API_Extensions[i] );
ffc0ad78: 80 7f 01 30 lwz r3,304(r31)
ffc0ad7c: 48 00 10 05 bl ffc0bd80 <_Workspace_Free>
ffc0ad80: 80 7f 01 34 lwz r3,308(r31)
ffc0ad84: 48 00 0f fd bl ffc0bd80 <_Workspace_Free>
_Workspace_Free( extensions_area );
ffc0ad88: 7f a3 eb 78 mr r3,r29
ffc0ad8c: 48 00 0f f5 bl ffc0bd80 <_Workspace_Free>
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
_Workspace_Free( fp_area );
ffc0ad90: 7e e3 bb 78 mr r3,r23
ffc0ad94: 48 00 0f ed bl ffc0bd80 <_Workspace_Free>
#endif
_Workspace_Free( sched );
ffc0ad98: 7f 43 d3 78 mr r3,r26
ffc0ad9c: 48 00 0f e5 bl ffc0bd80 <_Workspace_Free>
_Thread_Stack_Free( the_thread );
ffc0ada0: 7f e3 fb 78 mr r3,r31
ffc0ada4: 48 00 07 a5 bl ffc0b548 <_Thread_Stack_Free>
return false;
ffc0ada8: 38 00 00 00 li r0,0
}
ffc0adac: 39 61 00 30 addi r11,r1,48
ffc0adb0: 7c 03 03 78 mr r3,r0
ffc0adb4: 4b ff 57 70 b ffc00524 <_restgpr_23_x>
ffc0bd70 <_Thread_Restart>:
bool _Thread_Restart(
Thread_Control *the_thread,
void *pointer_argument,
Thread_Entry_numeric_type numeric_argument
)
{
ffc0bd70: 94 21 ff e8 stwu r1,-24(r1)
ffc0bd74: 7c 08 02 a6 mflr r0
ffc0bd78: 90 01 00 1c stw r0,28(r1)
_Thread_Restart_self();
return true;
}
return false;
ffc0bd7c: 38 00 00 00 li r0,0
*/
RTEMS_INLINE_ROUTINE bool _States_Is_dormant (
States_Control the_states
)
{
return (the_states & STATES_DORMANT);
ffc0bd80: 81 23 00 10 lwz r9,16(r3)
bool _Thread_Restart(
Thread_Control *the_thread,
void *pointer_argument,
Thread_Entry_numeric_type numeric_argument
)
{
ffc0bd84: bf c1 00 10 stmw r30,16(r1)
ffc0bd88: 7c 7f 1b 78 mr r31,r3
if ( !_States_Is_dormant( the_thread->current_state ) ) {
ffc0bd8c: 71 2b 00 01 andi. r11,r9,1
ffc0bd90: 40 a2 00 70 bne+ ffc0be00 <_Thread_Restart+0x90>
_Thread_Set_transient( the_thread );
ffc0bd94: 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 );
ffc0bd98: 3f c0 00 00 lis r30,0
ffc0bd9c: 3b de 31 64 addi r30,r30,12644
ffc0bda0: 90 a1 00 0c stw r5,12(r1)
ffc0bda4: 48 00 00 f5 bl ffc0be98 <_Thread_Set_transient>
_Thread_Reset( the_thread, pointer_argument, numeric_argument );
ffc0bda8: 7f e3 fb 78 mr r3,r31
ffc0bdac: 80 81 00 08 lwz r4,8(r1)
ffc0bdb0: 80 a1 00 0c lwz r5,12(r1)
ffc0bdb4: 48 00 3a ad bl ffc0f860 <_Thread_Reset>
_Thread_Load_environment( the_thread );
ffc0bdb8: 7f e3 fb 78 mr r3,r31
ffc0bdbc: 48 00 37 69 bl ffc0f524 <_Thread_Load_environment>
_Thread_Ready( the_thread );
ffc0bdc0: 7f e3 fb 78 mr r3,r31
ffc0bdc4: 48 00 3a 55 bl ffc0f818 <_Thread_Ready>
_User_extensions_Thread_restart( the_thread );
ffc0bdc8: 7f e3 fb 78 mr r3,r31
ffc0bdcc: 48 00 05 cd bl ffc0c398 <_User_extensions_Thread_restart>
if ( _Thread_Is_executing ( the_thread ) )
ffc0bdd0: 81 3e 00 0c lwz r9,12(r30)
_Thread_Restart_self();
return true;
ffc0bdd4: 38 00 00 01 li r0,1
_Thread_Ready( the_thread );
_User_extensions_Thread_restart( the_thread );
if ( _Thread_Is_executing ( the_thread ) )
ffc0bdd8: 7f 9f 48 00 cmpw cr7,r31,r9
ffc0bddc: 40 be 00 24 bne+ cr7,ffc0be00 <_Thread_Restart+0x90>
*/
RTEMS_INLINE_ROUTINE void _Thread_Restart_self( void )
{
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
if ( _Thread_Executing->fp_context != NULL )
ffc0bde0: 80 1f 01 28 lwz r0,296(r31)
ffc0bde4: 2f 80 00 00 cmpwi cr7,r0,0
ffc0bde8: 41 9e 00 0c beq- cr7,ffc0bdf4 <_Thread_Restart+0x84> <== NEVER TAKEN
_Context_Restore_fp( &_Thread_Executing->fp_context );
ffc0bdec: 38 7f 01 28 addi r3,r31,296
ffc0bdf0: 48 01 01 f1 bl ffc1bfe0 <_CPU_Context_restore_fp>
#endif
_CPU_Context_Restart_self( &_Thread_Executing->Registers );
ffc0bdf4: 80 7e 00 0c lwz r3,12(r30)
ffc0bdf8: 38 63 00 c8 addi r3,r3,200
ffc0bdfc: 48 01 03 a5 bl ffc1c1a0 <_CPU_Context_restore>
return true;
}
return false;
}
ffc0be00: 39 61 00 18 addi r11,r1,24
ffc0be04: 7c 03 03 78 mr r3,r0
ffc0be08: 4b ff 4f ac b ffc00db4 <_restgpr_30_x>
ffc0b548 <_Thread_Stack_Free>:
*/
void _Thread_Stack_Free(
Thread_Control *the_thread
)
{
ffc0b548: 7c 08 02 a6 mflr r0
ffc0b54c: 94 21 ff f8 stwu r1,-8(r1)
ffc0b550: 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 )
ffc0b554: 88 03 00 b4 lbz r0,180(r3)
ffc0b558: 2f 80 00 00 cmpwi cr7,r0,0
ffc0b55c: 41 9e 00 28 beq- cr7,ffc0b584 <_Thread_Stack_Free+0x3c> <== 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 )
ffc0b560: 3d 20 00 00 lis r9,0
ffc0b564: 80 63 00 bc lwz r3,188(r3)
ffc0b568: 80 09 20 28 lwz r0,8232(r9)
ffc0b56c: 2f 80 00 00 cmpwi cr7,r0,0
ffc0b570: 41 9e 00 10 beq- cr7,ffc0b580 <_Thread_Stack_Free+0x38>
(*Configuration.stack_free_hook)( the_thread->Start.Initial_stack.area );
ffc0b574: 7c 09 03 a6 mtctr r0
ffc0b578: 4e 80 04 21 bctrl
ffc0b57c: 48 00 00 08 b ffc0b584 <_Thread_Stack_Free+0x3c>
else
_Workspace_Free( the_thread->Start.Initial_stack.area );
ffc0b580: 48 00 08 01 bl ffc0bd80 <_Workspace_Free>
}
ffc0b584: 80 01 00 0c lwz r0,12(r1)
ffc0b588: 38 21 00 08 addi r1,r1,8
ffc0b58c: 7c 08 03 a6 mtlr r0
ffc0b590: 4e 80 00 20 blr
ffc0b338 <_Thread_queue_Requeue>:
void _Thread_queue_Requeue(
Thread_queue_Control *the_thread_queue,
Thread_Control *the_thread
)
{
ffc0b338: 94 21 ff d8 stwu r1,-40(r1)
ffc0b33c: 7c 08 02 a6 mflr r0
ffc0b340: bf a1 00 1c stmw r29,28(r1)
/*
* Just in case the thread really wasn't blocked on a thread queue
* when we get here.
*/
if ( !the_thread_queue )
ffc0b344: 7c 7f 1b 79 mr. r31,r3
void _Thread_queue_Requeue(
Thread_queue_Control *the_thread_queue,
Thread_Control *the_thread
)
{
ffc0b348: 7c 9e 23 78 mr r30,r4
ffc0b34c: 90 01 00 2c stw r0,44(r1)
/*
* Just in case the thread really wasn't blocked on a thread queue
* when we get here.
*/
if ( !the_thread_queue )
ffc0b350: 41 82 00 54 beq- ffc0b3a4 <_Thread_queue_Requeue+0x6c> <== 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 ) {
ffc0b354: 80 1f 00 34 lwz r0,52(r31)
ffc0b358: 2f 80 00 01 cmpwi cr7,r0,1
ffc0b35c: 40 be 00 48 bne+ cr7,ffc0b3a4 <_Thread_queue_Requeue+0x6c><== NEVER TAKEN
static inline uint32_t ppc_interrupt_disable( void )
{
uint32_t level;
uint32_t mask;
__asm__ volatile (
ffc0b360: 7f a0 00 a6 mfmsr r29
ffc0b364: 7d 30 42 a6 mfsprg r9,0
ffc0b368: 7f a9 48 78 andc r9,r29,r9
ffc0b36c: 7d 20 01 24 mtmsr r9
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 ) ) {
ffc0b370: 3d 60 00 03 lis r11,3
ffc0b374: 81 24 00 10 lwz r9,16(r4)
ffc0b378: 61 6b be e0 ori r11,r11,48864
ffc0b37c: 7d 6a 48 39 and. r10,r11,r9
ffc0b380: 41 a2 00 20 beq+ ffc0b3a0 <_Thread_queue_Requeue+0x68> <== NEVER TAKEN
RTEMS_INLINE_ROUTINE void _Thread_queue_Enter_critical_section (
Thread_queue_Control *the_thread_queue
)
{
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
ffc0b384: 90 1f 00 30 stw r0,48(r31)
_Thread_queue_Enter_critical_section( tq );
_Thread_queue_Extract_priority_helper( tq, the_thread, true );
ffc0b388: 38 a0 00 01 li r5,1
ffc0b38c: 48 00 38 bd bl ffc0ec48 <_Thread_queue_Extract_priority_helper>
(void) _Thread_queue_Enqueue_priority( tq, the_thread, &level_ignored );
ffc0b390: 7f e3 fb 78 mr r3,r31
ffc0b394: 7f c4 f3 78 mr r4,r30
ffc0b398: 38 a1 00 08 addi r5,r1,8
ffc0b39c: 4b ff fd 19 bl ffc0b0b4 <_Thread_queue_Enqueue_priority>
return level;
}
static inline void ppc_interrupt_enable( uint32_t level )
{
__asm__ volatile (
ffc0b3a0: 7f a0 01 24 mtmsr r29
}
_ISR_Enable( level );
}
}
ffc0b3a4: 39 61 00 28 addi r11,r1,40
ffc0b3a8: 4b ff 51 94 b ffc0053c <_restgpr_29_x>
ffc0b3ac <_Thread_queue_Timeout>:
void _Thread_queue_Timeout(
Objects_Id id,
void *ignored __attribute__((unused))
)
{
ffc0b3ac: 94 21 ff e8 stwu r1,-24(r1)
ffc0b3b0: 7c 08 02 a6 mflr r0
Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
ffc0b3b4: 38 81 00 08 addi r4,r1,8
void _Thread_queue_Timeout(
Objects_Id id,
void *ignored __attribute__((unused))
)
{
ffc0b3b8: 90 01 00 1c stw r0,28(r1)
Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
ffc0b3bc: 4b ff f7 31 bl ffc0aaec <_Thread_Get>
switch ( location ) {
ffc0b3c0: 80 01 00 08 lwz r0,8(r1)
ffc0b3c4: 2f 80 00 00 cmpwi cr7,r0,0
ffc0b3c8: 40 9e 00 1c bne- cr7,ffc0b3e4 <_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 );
ffc0b3cc: 48 00 39 6d bl ffc0ed38 <_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--;
ffc0b3d0: 3d 20 00 00 lis r9,0
ffc0b3d4: 81 69 28 0c lwz r11,10252(r9)
ffc0b3d8: 38 0b ff ff addi r0,r11,-1
ffc0b3dc: 90 09 28 0c stw r0,10252(r9)
return _Thread_Dispatch_disable_level;
ffc0b3e0: 80 09 28 0c lwz r0,10252(r9)
_Thread_Unnest_dispatch();
break;
}
}
ffc0b3e4: 80 01 00 1c lwz r0,28(r1)
ffc0b3e8: 38 21 00 18 addi r1,r1,24
ffc0b3ec: 7c 08 03 a6 mtlr r0
ffc0b3f0: 4e 80 00 20 blr
ffc18edc <_Timer_server_Body>:
* @a arg points to the corresponding timer server control block.
*/
static rtems_task _Timer_server_Body(
rtems_task_argument arg
)
{
ffc18edc: 94 21 ff 98 stwu r1,-104(r1)
ffc18ee0: 7c 08 02 a6 mflr r0
ffc18ee4: be 21 00 2c stmw r17,44(r1)
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
ffc18ee8: 3a 21 00 14 addi r17,r1,20
ffc18eec: 3a 81 00 18 addi r20,r1,24
ffc18ef0: 90 01 00 6c stw r0,108(r1)
ffc18ef4: 3b 61 00 0c addi r27,r1,12
head->previous = NULL;
ffc18ef8: 38 00 00 00 li r0,0
tail->previous = head;
ffc18efc: 3b 81 00 08 addi r28,r1,8
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
ffc18f00: 92 81 00 14 stw r20,20(r1)
ffc18f04: 7c 7f 1b 78 mr r31,r3
head->previous = NULL;
ffc18f08: 90 01 00 18 stw r0,24(r1)
static void _Timer_server_Process_interval_watchdogs(
Timer_server_Watchdogs *watchdogs,
Chain_Control *fire_chain
)
{
Watchdog_Interval snapshot = _Watchdog_Ticks_since_boot;
ffc18f0c: 3e 40 00 00 lis r18,0
*/
Watchdog_Interval delta = snapshot - watchdogs->last_snapshot;
watchdogs->last_snapshot = snapshot;
_Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
ffc18f10: 3b 43 00 30 addi r26,r3,48
tail->previous = head;
ffc18f14: 92 21 00 1c stw r17,28(r1)
static void _Timer_server_Process_tod_watchdogs(
Timer_server_Watchdogs *watchdogs,
Chain_Control *fire_chain
)
{
Watchdog_Interval snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch();
ffc18f18: 3e 60 00 00 lis r19,0
/*
* 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 );
ffc18f1c: 3b a3 00 68 addi r29,r3,104
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
ffc18f20: 93 61 00 08 stw r27,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;
ffc18f24: 3a a0 00 00 li r21,0
* the active flag of the timer server is true.
*/
(*watchdog->routine)( watchdog->id, watchdog->user_data );
}
} else {
ts->active = false;
ffc18f28: 3a c0 00 00 li r22,0
head->previous = NULL;
ffc18f2c: 90 01 00 0c stw r0,12(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;
ffc18f30: 3a e0 00 01 li r23,1
static void _Timer_server_Stop_interval_system_watchdog(
Timer_server_Control *ts
)
{
_Watchdog_Remove( &ts->Interval_watchdogs.System_watchdog );
ffc18f34: 3b 03 00 08 addi r24,r3,8
tail->previous = head;
ffc18f38: 93 81 00 10 stw r28,16(r1)
static void _Timer_server_Stop_tod_system_watchdog(
Timer_server_Control *ts
)
{
_Watchdog_Remove( &ts->TOD_watchdogs.System_watchdog );
ffc18f3c: 3b 23 00 40 addi r25,r3,64
{
/*
* Afterwards all timer inserts are directed to this chain and the interval
* and TOD chains will be no more modified by other parties.
*/
ts->insert_chain = insert_chain;
ffc18f40: 92 3f 00 78 stw r17,120(r31)
static void _Timer_server_Process_interval_watchdogs(
Timer_server_Watchdogs *watchdogs,
Chain_Control *fire_chain
)
{
Watchdog_Interval snapshot = _Watchdog_Ticks_since_boot;
ffc18f44: 80 12 29 14 lwz r0,10516(r18)
*/
Watchdog_Interval delta = snapshot - watchdogs->last_snapshot;
watchdogs->last_snapshot = snapshot;
_Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
ffc18f48: 7f 85 e3 78 mr r5,r28
Watchdog_Interval snapshot = _Watchdog_Ticks_since_boot;
/*
* We assume adequate unsigned arithmetic here.
*/
Watchdog_Interval delta = snapshot - watchdogs->last_snapshot;
ffc18f4c: 80 9f 00 3c lwz r4,60(r31)
watchdogs->last_snapshot = snapshot;
_Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
ffc18f50: 7f 43 d3 78 mr r3,r26
/*
* We assume adequate unsigned arithmetic here.
*/
Watchdog_Interval delta = snapshot - watchdogs->last_snapshot;
watchdogs->last_snapshot = snapshot;
ffc18f54: 90 1f 00 3c stw r0,60(r31)
_Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
ffc18f58: 7c 84 00 50 subf r4,r4,r0
ffc18f5c: 48 00 4b 79 bl ffc1dad4 <_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();
ffc18f60: 83 d3 28 f8 lwz r30,10488(r19)
Watchdog_Interval last_snapshot = watchdogs->last_snapshot;
ffc18f64: 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 ) {
ffc18f68: 7f 9e 28 40 cmplw cr7,r30,r5
ffc18f6c: 40 bd 00 18 ble+ cr7,ffc18f84 <_Timer_server_Body+0xa8>
/*
* 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 );
ffc18f70: 7c 85 f0 50 subf r4,r5,r30
ffc18f74: 7f a3 eb 78 mr r3,r29
ffc18f78: 7f 85 e3 78 mr r5,r28
ffc18f7c: 48 00 4b 59 bl ffc1dad4 <_Watchdog_Adjust_to_chain>
ffc18f80: 48 00 00 18 b ffc18f98 <_Timer_server_Body+0xbc>
} else if ( snapshot < last_snapshot ) {
ffc18f84: 40 bc 00 14 bge+ cr7,ffc18f98 <_Timer_server_Body+0xbc>
/*
* 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 );
ffc18f88: 7f a3 eb 78 mr r3,r29
ffc18f8c: 38 80 00 01 li r4,1
ffc18f90: 7c be 28 50 subf r5,r30,r5
ffc18f94: 48 00 4a 89 bl ffc1da1c <_Watchdog_Adjust>
}
watchdogs->last_snapshot = snapshot;
ffc18f98: 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 );
ffc18f9c: 80 7f 00 78 lwz r3,120(r31)
ffc18fa0: 48 00 0b d9 bl ffc19b78 <_Chain_Get>
if ( timer == NULL ) {
ffc18fa4: 7c 7e 1b 79 mr. r30,r3
ffc18fa8: 41 82 00 2c beq- ffc18fd4 <_Timer_server_Body+0xf8>
static void _Timer_server_Insert_timer(
Timer_server_Control *ts,
Timer_Control *timer
)
{
if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) {
ffc18fac: 80 1e 00 38 lwz r0,56(r30)
_Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker );
ffc18fb0: 7f 43 d3 78 mr r3,r26
static void _Timer_server_Insert_timer(
Timer_server_Control *ts,
Timer_Control *timer
)
{
if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) {
ffc18fb4: 2f 80 00 01 cmpwi cr7,r0,1
ffc18fb8: 41 9e 00 10 beq- cr7,ffc18fc8 <_Timer_server_Body+0xec>
_Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker );
} else if ( timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) {
ffc18fbc: 2f 80 00 03 cmpwi cr7,r0,3
ffc18fc0: 40 9e ff dc bne+ cr7,ffc18f9c <_Timer_server_Body+0xc0> <== NEVER TAKEN
_Watchdog_Insert( &ts->TOD_watchdogs.Chain, &timer->Ticker );
ffc18fc4: 7f a3 eb 78 mr r3,r29
ffc18fc8: 38 9e 00 10 addi r4,r30,16
ffc18fcc: 48 00 4b b9 bl ffc1db84 <_Watchdog_Insert>
ffc18fd0: 4b ff ff cc b ffc18f9c <_Timer_server_Body+0xc0>
* of zero it will be processed in the next iteration of the timer server
* body loop.
*/
_Timer_server_Process_insertions( ts );
_ISR_Disable( level );
ffc18fd4: 4b ff fe 1d bl ffc18df0 <ppc_interrupt_disable>
if ( _Chain_Is_empty( insert_chain ) ) {
ffc18fd8: 80 01 00 14 lwz r0,20(r1)
ffc18fdc: 7f 80 a0 00 cmpw cr7,r0,r20
ffc18fe0: 40 be 00 1c bne+ cr7,ffc18ffc <_Timer_server_Body+0x120><== NEVER TAKEN
ts->insert_chain = NULL;
ffc18fe4: 93 df 00 78 stw r30,120(r31)
ffc18fe8: 7c 60 01 24 mtmsr r3
_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 ) ) {
ffc18fec: 80 01 00 08 lwz r0,8(r1)
ffc18ff0: 7f 80 d8 00 cmpw cr7,r0,r27
ffc18ff4: 40 be 00 10 bne+ cr7,ffc19004 <_Timer_server_Body+0x128>
ffc18ff8: 48 00 00 50 b ffc19048 <_Timer_server_Body+0x16c>
ffc18ffc: 7c 60 01 24 mtmsr r3 <== NOT EXECUTED
ffc19000: 4b ff ff 44 b ffc18f44 <_Timer_server_Body+0x68> <== NOT EXECUTED
/*
* It is essential that interrupts are disable here since an interrupt
* service routine may remove a watchdog from the chain.
*/
_ISR_Disable( level );
ffc19004: 4b ff fd ed bl ffc18df0 <ppc_interrupt_disable>
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_head( the_chain )->next;
ffc19008: 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))
ffc1900c: 7f 89 d8 00 cmpw cr7,r9,r27
ffc19010: 41 9e 00 30 beq- cr7,ffc19040 <_Timer_server_Body+0x164>
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *old_first = head->next;
Chain_Node *new_first = old_first->next;
ffc19014: 81 69 00 00 lwz r11,0(r9)
head->next = new_first;
new_first->previous = head;
ffc19018: 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;
ffc1901c: 91 61 00 08 stw r11,8(r1)
watchdog = (Watchdog_Control *) _Chain_Get_unprotected( &fire_chain );
if ( watchdog != NULL ) {
watchdog->state = WATCHDOG_INACTIVE;
ffc19020: 92 a9 00 08 stw r21,8(r9)
ffc19024: 7c 60 01 24 mtmsr r3
/*
* The timer server may block here and wait for resources or time.
* The system watchdogs are inactive and will remain inactive since
* the active flag of the timer server is true.
*/
(*watchdog->routine)( watchdog->id, watchdog->user_data );
ffc19028: 80 09 00 1c lwz r0,28(r9)
ffc1902c: 80 69 00 20 lwz r3,32(r9)
ffc19030: 80 89 00 24 lwz r4,36(r9)
ffc19034: 7c 09 03 a6 mtctr r0
ffc19038: 4e 80 04 21 bctrl
}
ffc1903c: 4b ff ff c8 b ffc19004 <_Timer_server_Body+0x128>
ffc19040: 7c 60 01 24 mtmsr r3
ffc19044: 4b ff fe fc b ffc18f40 <_Timer_server_Body+0x64>
} else {
ts->active = false;
ffc19048: 9a df 00 7c stb r22,124(r31)
/*
* Block until there is something to do.
*/
_Thread_Disable_dispatch();
ffc1904c: 4b ff fd b9 bl ffc18e04 <_Thread_Disable_dispatch>
_Thread_Set_state( ts->thread, STATES_DELAYING );
ffc19050: 80 7f 00 00 lwz r3,0(r31)
ffc19054: 38 80 00 08 li r4,8
ffc19058: 48 00 42 dd bl ffc1d334 <_Thread_Set_state>
_Timer_server_Reset_interval_system_watchdog( ts );
ffc1905c: 7f e3 fb 78 mr r3,r31
ffc19060: 4b ff fd bd bl ffc18e1c <_Timer_server_Reset_interval_system_watchdog>
_Timer_server_Reset_tod_system_watchdog( ts );
ffc19064: 7f e3 fb 78 mr r3,r31
ffc19068: 4b ff fe 15 bl ffc18e7c <_Timer_server_Reset_tod_system_watchdog>
_Thread_Enable_dispatch();
ffc1906c: 48 00 38 b9 bl ffc1c924 <_Thread_Enable_dispatch>
ts->active = true;
ffc19070: 9a ff 00 7c stb r23,124(r31)
static void _Timer_server_Stop_interval_system_watchdog(
Timer_server_Control *ts
)
{
_Watchdog_Remove( &ts->Interval_watchdogs.System_watchdog );
ffc19074: 7f 03 c3 78 mr r3,r24
ffc19078: 48 00 4c 65 bl ffc1dcdc <_Watchdog_Remove>
static void _Timer_server_Stop_tod_system_watchdog(
Timer_server_Control *ts
)
{
_Watchdog_Remove( &ts->TOD_watchdogs.System_watchdog );
ffc1907c: 7f 23 cb 78 mr r3,r25
ffc19080: 48 00 4c 5d bl ffc1dcdc <_Watchdog_Remove>
ffc19084: 4b ff fe bc b ffc18f40 <_Timer_server_Body+0x64>
ffc19088 <_Timer_server_Schedule_operation_method>:
static void _Timer_server_Schedule_operation_method(
Timer_server_Control *ts,
Timer_Control *timer
)
{
ffc19088: 94 21 ff f0 stwu r1,-16(r1)
ffc1908c: 7c 08 02 a6 mflr r0
ffc19090: 90 01 00 14 stw r0,20(r1)
if ( ts->insert_chain == NULL ) {
ffc19094: 80 03 00 78 lwz r0,120(r3)
static void _Timer_server_Schedule_operation_method(
Timer_server_Control *ts,
Timer_Control *timer
)
{
ffc19098: bf c1 00 08 stmw r30,8(r1)
ffc1909c: 7c 7f 1b 78 mr r31,r3
if ( ts->insert_chain == NULL ) {
ffc190a0: 2f 80 00 00 cmpwi cr7,r0,0
static void _Timer_server_Schedule_operation_method(
Timer_server_Control *ts,
Timer_Control *timer
)
{
ffc190a4: 7c 9e 23 78 mr r30,r4
if ( ts->insert_chain == NULL ) {
ffc190a8: 40 be 01 00 bne+ cr7,ffc191a8 <_Timer_server_Schedule_operation_method+0x120>
* is the reference point for the delta chain. Thus if we do not update the
* reference point we have to add DT to the initial delta of the watchdog
* being inserted. This could result in an integer overflow.
*/
_Thread_Disable_dispatch();
ffc190ac: 4b ff fd 59 bl ffc18e04 <_Thread_Disable_dispatch>
if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) {
ffc190b0: 80 1e 00 38 lwz r0,56(r30)
ffc190b4: 2f 80 00 01 cmpwi cr7,r0,1
ffc190b8: 40 be 00 6c bne+ cr7,ffc19124 <_Timer_server_Schedule_operation_method+0x9c>
/*
* We have to advance the last known ticks value of the server and update
* the watchdog chain accordingly.
*/
_ISR_Disable( level );
ffc190bc: 4b ff fd 35 bl ffc18df0 <ppc_interrupt_disable>
snapshot = _Watchdog_Ticks_since_boot;
ffc190c0: 3d 20 00 00 lis r9,0
ffc190c4: 80 09 29 14 lwz r0,10516(r9)
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
ffc190c8: 39 7f 00 34 addi r11,r31,52
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_head( the_chain )->next;
ffc190cc: 81 3f 00 30 lwz r9,48(r31)
last_snapshot = ts->Interval_watchdogs.last_snapshot;
ffc190d0: 81 5f 00 3c lwz r10,60(r31)
if ( !_Chain_Is_empty( &ts->Interval_watchdogs.Chain ) ) {
ffc190d4: 7f 89 58 00 cmpw cr7,r9,r11
ffc190d8: 41 9e 00 20 beq- cr7,ffc190f8 <_Timer_server_Schedule_operation_method+0x70>
/*
* We assume adequate unsigned arithmetic here.
*/
delta = snapshot - last_snapshot;
delta_interval = first_watchdog->delta_interval;
ffc190dc: 81 09 00 10 lwz r8,16(r9)
first_watchdog = _Watchdog_First( &ts->Interval_watchdogs.Chain );
/*
* We assume adequate unsigned arithmetic here.
*/
delta = snapshot - last_snapshot;
ffc190e0: 7d 4a 00 50 subf r10,r10,r0
delta_interval = first_watchdog->delta_interval;
if (delta_interval > delta) {
delta_interval -= delta;
} else {
delta_interval = 0;
ffc190e4: 39 60 00 00 li r11,0
* We assume adequate unsigned arithmetic here.
*/
delta = snapshot - last_snapshot;
delta_interval = first_watchdog->delta_interval;
if (delta_interval > delta) {
ffc190e8: 7f 88 50 40 cmplw cr7,r8,r10
ffc190ec: 40 9d 00 08 ble- cr7,ffc190f4 <_Timer_server_Schedule_operation_method+0x6c>
delta_interval -= delta;
ffc190f0: 7d 6a 40 50 subf r11,r10,r8
} else {
delta_interval = 0;
}
first_watchdog->delta_interval = delta_interval;
ffc190f4: 91 69 00 10 stw r11,16(r9)
}
ts->Interval_watchdogs.last_snapshot = snapshot;
ffc190f8: 90 1f 00 3c stw r0,60(r31)
ffc190fc: 7c 60 01 24 mtmsr r3
_ISR_Enable( level );
_Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker );
ffc19100: 38 7f 00 30 addi r3,r31,48
ffc19104: 38 9e 00 10 addi r4,r30,16
ffc19108: 48 00 4a 7d bl ffc1db84 <_Watchdog_Insert>
if ( !ts->active ) {
ffc1910c: 88 1f 00 7c lbz r0,124(r31)
ffc19110: 2f 80 00 00 cmpwi cr7,r0,0
ffc19114: 40 be 00 8c bne+ cr7,ffc191a0 <_Timer_server_Schedule_operation_method+0x118>
_Timer_server_Reset_interval_system_watchdog( ts );
ffc19118: 7f e3 fb 78 mr r3,r31
ffc1911c: 4b ff fd 01 bl ffc18e1c <_Timer_server_Reset_interval_system_watchdog>
ffc19120: 48 00 00 80 b ffc191a0 <_Timer_server_Schedule_operation_method+0x118>
}
} else if ( timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) {
ffc19124: 2f 80 00 03 cmpwi cr7,r0,3
ffc19128: 40 be 00 78 bne+ cr7,ffc191a0 <_Timer_server_Schedule_operation_method+0x118>
/*
* We have to advance the last known seconds value of the server and update
* the watchdog chain accordingly.
*/
_ISR_Disable( level );
ffc1912c: 4b ff fc c5 bl ffc18df0 <ppc_interrupt_disable>
snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch();
ffc19130: 3d 20 00 00 lis r9,0
last_snapshot = ts->TOD_watchdogs.last_snapshot;
ffc19134: 81 1f 00 74 lwz r8,116(r31)
/*
* 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();
ffc19138: 80 09 28 f8 lwz r0,10488(r9)
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
ffc1913c: 39 7f 00 6c addi r11,r31,108
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_head( the_chain )->next;
ffc19140: 81 3f 00 68 lwz r9,104(r31)
last_snapshot = ts->TOD_watchdogs.last_snapshot;
if ( !_Chain_Is_empty( &ts->TOD_watchdogs.Chain ) ) {
ffc19144: 7f 89 58 00 cmpw cr7,r9,r11
ffc19148: 41 9e 00 30 beq- cr7,ffc19178 <_Timer_server_Schedule_operation_method+0xf0>
first_watchdog = _Watchdog_First( &ts->TOD_watchdogs.Chain );
delta_interval = first_watchdog->delta_interval;
if ( snapshot > last_snapshot ) {
ffc1914c: 7f 80 40 40 cmplw cr7,r0,r8
_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;
ffc19150: 81 49 00 10 lwz r10,16(r9)
}
} else {
/*
* Someone put us in the past.
*/
delta = last_snapshot - snapshot;
ffc19154: 7d 6a 42 14 add r11,r10,r8
delta_interval += delta;
ffc19158: 7d 60 58 50 subf r11,r0,r11
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 ) {
ffc1915c: 40 9d 00 18 ble- cr7,ffc19174 <_Timer_server_Schedule_operation_method+0xec>
/*
* We advanced in time.
*/
delta = snapshot - last_snapshot;
ffc19160: 7d 08 00 50 subf r8,r8,r0
if (delta_interval > delta) {
ffc19164: 7f 8a 40 40 cmplw cr7,r10,r8
delta_interval -= delta;
} else {
delta_interval = 0;
ffc19168: 39 60 00 00 li r11,0
if ( snapshot > last_snapshot ) {
/*
* We advanced in time.
*/
delta = snapshot - last_snapshot;
if (delta_interval > delta) {
ffc1916c: 40 9d 00 08 ble- cr7,ffc19174 <_Timer_server_Schedule_operation_method+0xec><== NEVER TAKEN
delta_interval -= delta;
ffc19170: 7d 68 50 50 subf r11,r8,r10
* Someone put us in the past.
*/
delta = last_snapshot - snapshot;
delta_interval += delta;
}
first_watchdog->delta_interval = delta_interval;
ffc19174: 91 69 00 10 stw r11,16(r9)
}
ts->TOD_watchdogs.last_snapshot = snapshot;
ffc19178: 90 1f 00 74 stw r0,116(r31)
ffc1917c: 7c 60 01 24 mtmsr r3
_ISR_Enable( level );
_Watchdog_Insert( &ts->TOD_watchdogs.Chain, &timer->Ticker );
ffc19180: 38 7f 00 68 addi r3,r31,104
ffc19184: 38 9e 00 10 addi r4,r30,16
ffc19188: 48 00 49 fd bl ffc1db84 <_Watchdog_Insert>
if ( !ts->active ) {
ffc1918c: 88 1f 00 7c lbz r0,124(r31)
ffc19190: 2f 80 00 00 cmpwi cr7,r0,0
ffc19194: 40 be 00 0c bne+ cr7,ffc191a0 <_Timer_server_Schedule_operation_method+0x118>
_Timer_server_Reset_tod_system_watchdog( ts );
ffc19198: 7f e3 fb 78 mr r3,r31
ffc1919c: 4b ff fc e1 bl ffc18e7c <_Timer_server_Reset_tod_system_watchdog>
}
}
_Thread_Enable_dispatch();
ffc191a0: 48 00 37 85 bl ffc1c924 <_Thread_Enable_dispatch>
ffc191a4: 48 00 00 0c b ffc191b0 <_Timer_server_Schedule_operation_method+0x128>
* 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 );
ffc191a8: 80 63 00 78 lwz r3,120(r3)
ffc191ac: 48 00 09 75 bl ffc19b20 <_Chain_Append>
}
}
ffc191b0: 39 61 00 10 addi r11,r1,16
ffc191b4: 4b ff 4f e8 b ffc0e19c <_restgpr_30_x>
ffc0b6f8 <_User_extensions_Handler_initialization>:
#include <rtems/score/userext.h>
#include <rtems/score/wkspace.h>
#include <string.h>
void _User_extensions_Handler_initialization(void)
{
ffc0b6f8: 94 21 ff e8 stwu r1,-24(r1)
ffc0b6fc: 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;
ffc0b700: 3d 20 00 00 lis r9,0
#include <rtems/score/userext.h>
#include <rtems/score/wkspace.h>
#include <string.h>
void _User_extensions_Handler_initialization(void)
{
ffc0b704: 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;
ffc0b708: 39 29 20 04 addi r9,r9,8196
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
ffc0b70c: 3d 60 00 00 lis r11,0
#include <rtems/score/userext.h>
#include <rtems/score/wkspace.h>
#include <string.h>
void _User_extensions_Handler_initialization(void)
{
ffc0b710: bf 81 00 08 stmw r28,8(r1)
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;
ffc0b714: 83 a9 00 3c lwz r29,60(r9)
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;
ffc0b718: 83 c9 00 38 lwz r30,56(r9)
ffc0b71c: 39 2b 2d f4 addi r9,r11,11764
initial_extensions = Configuration.User_extension_table;
_Chain_Initialize_empty( &_User_extensions_List );
_Chain_Initialize_empty( &_User_extensions_Switches_list );
if ( initial_extensions ) {
ffc0b720: 2f 9d 00 00 cmpwi cr7,r29,0
head->previous = NULL;
tail->previous = head;
ffc0b724: 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;
ffc0b728: 38 09 00 04 addi r0,r9,4
ffc0b72c: 90 0b 2d f4 stw r0,11764(r11)
head->previous = NULL;
ffc0b730: 38 00 00 00 li r0,0
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
ffc0b734: 3d 60 00 00 lis r11,0
head->previous = NULL;
ffc0b738: 90 09 00 04 stw r0,4(r9)
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
ffc0b73c: 39 2b 2c d0 addi r9,r11,11472
ffc0b740: 39 49 00 04 addi r10,r9,4
ffc0b744: 91 4b 2c d0 stw r10,11472(r11)
head->previous = NULL;
ffc0b748: 90 09 00 04 stw r0,4(r9)
tail->previous = head;
ffc0b74c: 91 29 00 08 stw r9,8(r9)
ffc0b750: 41 9e 00 54 beq- cr7,ffc0b7a4 <_User_extensions_Handler_initialization+0xac><== NEVER TAKEN
extension = (User_extensions_Control *)
_Workspace_Allocate_or_fatal_error(
number_of_extensions * sizeof( User_extensions_Control )
ffc0b754: 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 *)
ffc0b758: 7f 83 e3 78 mr r3,r28
ffc0b75c: 48 00 06 51 bl ffc0bdac <_Workspace_Allocate_or_fatal_error>
_Workspace_Allocate_or_fatal_error(
number_of_extensions * sizeof( User_extensions_Control )
);
memset (
ffc0b760: 7f 85 e3 78 mr r5,r28
ffc0b764: 38 80 00 00 li r4,0
_Chain_Initialize_empty( &_User_extensions_List );
_Chain_Initialize_empty( &_User_extensions_Switches_list );
if ( initial_extensions ) {
extension = (User_extensions_Control *)
ffc0b768: 7c 7f 1b 78 mr r31,r3
_Workspace_Allocate_or_fatal_error(
number_of_extensions * sizeof( User_extensions_Control )
);
memset (
ffc0b76c: 48 00 62 69 bl ffc119d4 <memset>
extension,
0,
number_of_extensions * sizeof( User_extensions_Control )
);
for ( i = 0 ; i < number_of_extensions ; i++ ) {
ffc0b770: 3b 80 00 00 li r28,0
ffc0b774: 48 00 00 28 b ffc0b79c <_User_extensions_Handler_initialization+0xa4>
#include <rtems/config.h>
#include <rtems/score/userext.h>
#include <rtems/score/wkspace.h>
#include <string.h>
void _User_extensions_Handler_initialization(void)
ffc0b778: 57 83 28 34 rlwinm r3,r28,5,0,26
RTEMS_INLINE_ROUTINE void _User_extensions_Add_set_with_table(
User_extensions_Control *extension,
const User_extensions_Table *extension_table
)
{
extension->Callouts = *extension_table;
ffc0b77c: 38 9f 00 14 addi r4,r31,20
ffc0b780: 7c 7d 1a 14 add r3,r29,r3
ffc0b784: 7c a3 04 aa lswi r5,r3,32
ffc0b788: 7c a4 05 aa stswi r5,r4,32
_User_extensions_Add_set( extension );
ffc0b78c: 7f e3 fb 78 mr r3,r31
extension,
0,
number_of_extensions * sizeof( User_extensions_Control )
);
for ( i = 0 ; i < number_of_extensions ; i++ ) {
ffc0b790: 3b 9c 00 01 addi r28,r28,1
ffc0b794: 48 00 36 bd bl ffc0ee50 <_User_extensions_Add_set>
_User_extensions_Add_set_with_table (extension, &initial_extensions[i]);
extension++;
ffc0b798: 3b ff 00 34 addi r31,r31,52
extension,
0,
number_of_extensions * sizeof( User_extensions_Control )
);
for ( i = 0 ; i < number_of_extensions ; i++ ) {
ffc0b79c: 7f 9c f0 00 cmpw cr7,r28,r30
ffc0b7a0: 40 9e ff d8 bne+ cr7,ffc0b778 <_User_extensions_Handler_initialization+0x80>
_User_extensions_Add_set_with_table (extension, &initial_extensions[i]);
extension++;
}
}
}
ffc0b7a4: 39 61 00 18 addi r11,r1,24
ffc0b7a8: 4b ff 4d 90 b ffc00538 <_restgpr_28_x>
ffc0d458 <_Watchdog_Adjust>:
void _Watchdog_Adjust(
Chain_Control *header,
Watchdog_Adjust_directions direction,
Watchdog_Interval units
)
{
ffc0d458: 94 21 ff e8 stwu r1,-24(r1)
ffc0d45c: 7c 08 02 a6 mflr r0
ffc0d460: 90 01 00 1c stw r0,28(r1)
ffc0d464: bf 81 00 08 stmw r28,8(r1)
ffc0d468: 7c 7f 1b 78 mr r31,r3
ffc0d46c: 7c be 2b 78 mr r30,r5
static inline uint32_t ppc_interrupt_disable( void )
{
uint32_t level;
uint32_t mask;
__asm__ volatile (
ffc0d470: 7c 00 00 a6 mfmsr r0
ffc0d474: 7d 30 42 a6 mfsprg r9,0
ffc0d478: 7c 09 48 78 andc r9,r0,r9
ffc0d47c: 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;
ffc0d480: 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 );
ffc0d484: 3b a3 00 04 addi r29,r3,4
* hence the compiler must not assume *header to remain
* unmodified across that call.
*
* Till Straumann, 7/2003
*/
if ( !_Chain_Is_empty( header ) ) {
ffc0d488: 7f 89 e8 00 cmpw cr7,r9,r29
ffc0d48c: 41 9e 00 78 beq- cr7,ffc0d504 <_Watchdog_Adjust+0xac>
switch ( direction ) {
ffc0d490: 2f 84 00 00 cmpwi cr7,r4,0
if ( units < _Watchdog_First( header )->delta_interval ) {
_Watchdog_First( header )->delta_interval -= units;
break;
} else {
units -= _Watchdog_First( header )->delta_interval;
_Watchdog_First( header )->delta_interval = 1;
ffc0d494: 3b 80 00 01 li r28,1
* unmodified across that call.
*
* Till Straumann, 7/2003
*/
if ( !_Chain_Is_empty( header ) ) {
switch ( direction ) {
ffc0d498: 41 9e 00 64 beq- cr7,ffc0d4fc <_Watchdog_Adjust+0xa4>
ffc0d49c: 2f 84 00 01 cmpwi cr7,r4,1
ffc0d4a0: 40 be 00 64 bne+ cr7,ffc0d504 <_Watchdog_Adjust+0xac> <== NEVER TAKEN
case WATCHDOG_BACKWARD:
_Watchdog_First( header )->delta_interval += units;
ffc0d4a4: 81 69 00 10 lwz r11,16(r9)
ffc0d4a8: 7f cb 2a 14 add r30,r11,r5
ffc0d4ac: 48 00 00 18 b ffc0d4c4 <_Watchdog_Adjust+0x6c>
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
ffc0d4b0: 81 3f 00 00 lwz r9,0(r31)
break;
case WATCHDOG_FORWARD:
while ( units ) {
if ( units < _Watchdog_First( header )->delta_interval ) {
ffc0d4b4: 81 69 00 10 lwz r11,16(r9)
ffc0d4b8: 7f 9e 58 40 cmplw cr7,r30,r11
ffc0d4bc: 40 bc 00 10 bge+ cr7,ffc0d4cc <_Watchdog_Adjust+0x74>
_Watchdog_First( header )->delta_interval -= units;
ffc0d4c0: 7f de 58 50 subf r30,r30,r11
ffc0d4c4: 93 c9 00 10 stw r30,16(r9)
break;
ffc0d4c8: 48 00 00 3c b ffc0d504 <_Watchdog_Adjust+0xac>
} else {
units -= _Watchdog_First( header )->delta_interval;
_Watchdog_First( header )->delta_interval = 1;
ffc0d4cc: 93 89 00 10 stw r28,16(r9)
while ( units ) {
if ( units < _Watchdog_First( header )->delta_interval ) {
_Watchdog_First( header )->delta_interval -= units;
break;
} else {
units -= _Watchdog_First( header )->delta_interval;
ffc0d4d0: 7f cb f0 50 subf r30,r11,r30
return level;
}
static inline void ppc_interrupt_enable( uint32_t level )
{
__asm__ volatile (
ffc0d4d4: 7c 00 01 24 mtmsr r0
_Watchdog_First( header )->delta_interval = 1;
_ISR_Enable( level );
_Watchdog_Tickle( header );
ffc0d4d8: 7f e3 fb 78 mr r3,r31
ffc0d4dc: 48 00 02 35 bl ffc0d710 <_Watchdog_Tickle>
static inline uint32_t ppc_interrupt_disable( void )
{
uint32_t level;
uint32_t mask;
__asm__ volatile (
ffc0d4e0: 7c 00 00 a6 mfmsr r0
ffc0d4e4: 7d 30 42 a6 mfsprg r9,0
ffc0d4e8: 7c 09 48 78 andc r9,r0,r9
ffc0d4ec: 7d 20 01 24 mtmsr r9
_ISR_Disable( level );
if ( _Chain_Is_empty( header ) )
ffc0d4f0: 81 3f 00 00 lwz r9,0(r31)
ffc0d4f4: 7f 89 e8 00 cmpw cr7,r9,r29
ffc0d4f8: 41 9e 00 0c beq- cr7,ffc0d504 <_Watchdog_Adjust+0xac>
switch ( direction ) {
case WATCHDOG_BACKWARD:
_Watchdog_First( header )->delta_interval += units;
break;
case WATCHDOG_FORWARD:
while ( units ) {
ffc0d4fc: 2f 9e 00 00 cmpwi cr7,r30,0
ffc0d500: 40 9e ff b0 bne+ cr7,ffc0d4b0 <_Watchdog_Adjust+0x58> <== ALWAYS TAKEN
return level;
}
static inline void ppc_interrupt_enable( uint32_t level )
{
__asm__ volatile (
ffc0d504: 7c 00 01 24 mtmsr r0
}
}
_ISR_Enable( level );
}
ffc0d508: 39 61 00 18 addi r11,r1,24
ffc0d50c: 4b ff 3e 34 b ffc01340 <_restgpr_28_x>
ffc0bb8c <_Watchdog_Remove>:
*/
Watchdog_States _Watchdog_Remove(
Watchdog_Control *the_watchdog
)
{
ffc0bb8c: 7c 69 1b 78 mr r9,r3
static inline uint32_t ppc_interrupt_disable( void )
{
uint32_t level;
uint32_t mask;
__asm__ volatile (
ffc0bb90: 7c 00 00 a6 mfmsr r0
ffc0bb94: 7d 70 42 a6 mfsprg r11,0
ffc0bb98: 7c 0b 58 78 andc r11,r0,r11
ffc0bb9c: 7d 60 01 24 mtmsr r11
ISR_Level level;
Watchdog_States previous_state;
Watchdog_Control *next_watchdog;
_ISR_Disable( level );
previous_state = the_watchdog->state;
ffc0bba0: 80 63 00 08 lwz r3,8(r3)
switch ( previous_state ) {
ffc0bba4: 2f 83 00 01 cmpwi cr7,r3,1
ffc0bba8: 41 9e 00 18 beq- cr7,ffc0bbc0 <_Watchdog_Remove+0x34>
ffc0bbac: 2b 83 00 01 cmplwi cr7,r3,1
ffc0bbb0: 41 9c 00 70 blt- cr7,ffc0bc20 <_Watchdog_Remove+0x94>
ffc0bbb4: 2b 83 00 03 cmplwi cr7,r3,3
ffc0bbb8: 41 9d 00 68 bgt- cr7,ffc0bc20 <_Watchdog_Remove+0x94> <== NEVER TAKEN
ffc0bbbc: 48 00 00 10 b ffc0bbcc <_Watchdog_Remove+0x40>
/*
* 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;
ffc0bbc0: 39 60 00 00 li r11,0
ffc0bbc4: 91 69 00 08 stw r11,8(r9)
break;
ffc0bbc8: 48 00 00 58 b ffc0bc20 <_Watchdog_Remove+0x94>
case WATCHDOG_ACTIVE:
case WATCHDOG_REMOVE_IT:
the_watchdog->state = WATCHDOG_INACTIVE;
ffc0bbcc: 39 60 00 00 li r11,0
ffc0bbd0: 91 69 00 08 stw r11,8(r9)
}
the_watchdog->stop_time = _Watchdog_Ticks_since_boot;
_ISR_Enable( level );
return( previous_state );
}
ffc0bbd4: 81 69 00 00 lwz r11,0(r9)
case WATCHDOG_REMOVE_IT:
the_watchdog->state = WATCHDOG_INACTIVE;
next_watchdog = _Watchdog_Next( the_watchdog );
if ( _Watchdog_Next(next_watchdog) )
ffc0bbd8: 81 4b 00 00 lwz r10,0(r11)
ffc0bbdc: 2f 8a 00 00 cmpwi cr7,r10,0
ffc0bbe0: 41 9e 00 14 beq- cr7,ffc0bbf4 <_Watchdog_Remove+0x68>
next_watchdog->delta_interval += the_watchdog->delta_interval;
ffc0bbe4: 81 0b 00 10 lwz r8,16(r11)
ffc0bbe8: 81 49 00 10 lwz r10,16(r9)
ffc0bbec: 7d 48 52 14 add r10,r8,r10
ffc0bbf0: 91 4b 00 10 stw r10,16(r11)
if ( _Watchdog_Sync_count )
ffc0bbf4: 3d 40 00 00 lis r10,0
ffc0bbf8: 81 4a 28 3c lwz r10,10300(r10)
ffc0bbfc: 2f 8a 00 00 cmpwi cr7,r10,0
ffc0bc00: 41 9e 00 14 beq- cr7,ffc0bc14 <_Watchdog_Remove+0x88>
_Watchdog_Sync_level = _ISR_Nest_level;
ffc0bc04: 3d 40 00 00 lis r10,0
ffc0bc08: 81 0a 31 4c lwz r8,12620(r10)
ffc0bc0c: 3d 40 00 00 lis r10,0
ffc0bc10: 91 0a 28 34 stw r8,10292(r10)
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
previous = the_node->previous;
ffc0bc14: 81 49 00 04 lwz r10,4(r9)
next->previous = previous;
ffc0bc18: 91 4b 00 04 stw r10,4(r11)
previous->next = next;
ffc0bc1c: 91 6a 00 00 stw r11,0(r10)
_Chain_Extract_unprotected( &the_watchdog->Node );
break;
}
the_watchdog->stop_time = _Watchdog_Ticks_since_boot;
ffc0bc20: 3d 60 00 00 lis r11,0
ffc0bc24: 81 6b 28 40 lwz r11,10304(r11)
ffc0bc28: 91 69 00 18 stw r11,24(r9)
return level;
}
static inline void ppc_interrupt_enable( uint32_t level )
{
__asm__ volatile (
ffc0bc2c: 7c 00 01 24 mtmsr r0
_ISR_Enable( level );
return( previous_state );
}
ffc0bc30: 4e 80 00 20 blr
ffc14cf4 <_fat_block_read>:
uint32_t start,
uint32_t offset,
uint32_t count,
void *buff
)
{
ffc14cf4: 94 21 ff c8 stwu r1,-56(r1)
ffc14cf8: 7c 08 02 a6 mflr r0
ffc14cfc: 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;
ffc14d00: 38 00 00 00 li r0,0
uint32_t start,
uint32_t offset,
uint32_t count,
void *buff
)
{
ffc14d04: bf 01 00 18 stmw r24,24(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;
ffc14d08: 7c 3b 0b 78 mr r27,r1
uint32_t start,
uint32_t offset,
uint32_t count,
void *buff
)
{
ffc14d0c: 7c df 33 78 mr r31,r6
ffc14d10: 7c f9 3b 78 mr r25,r7
int rc = RC_OK;
register fat_fs_info_t *fs_info = mt_entry->fs_info;
ffc14d14: 83 43 00 34 lwz r26,52(r3)
ssize_t cmpltd = 0;
uint32_t blk = start;
uint32_t ofs = offset;
rtems_bdbuf_buffer *block = NULL;
ffc14d18: 94 1b 00 08 stwu r0,8(r27)
{
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;
ffc14d1c: 7c bc 2b 78 mr r28,r5
)
{
int rc = RC_OK;
register fat_fs_info_t *fs_info = mt_entry->fs_info;
ssize_t cmpltd = 0;
uint32_t blk = start;
ffc14d20: 7c 9d 23 78 mr r29,r4
void *buff
)
{
int rc = RC_OK;
register fat_fs_info_t *fs_info = mt_entry->fs_info;
ssize_t cmpltd = 0;
ffc14d24: 3b c0 00 00 li r30,0
uint32_t blk = start;
uint32_t ofs = offset;
rtems_bdbuf_buffer *block = NULL;
uint32_t c = 0;
while (count > 0)
ffc14d28: 48 00 00 5c b ffc14d84 <_fat_block_read+0x90>
{
rc = fat_buf_access(fs_info, blk, FAT_OP_TYPE_READ, &block);
ffc14d2c: 7f 43 d3 78 mr r3,r26
ffc14d30: 7f a4 eb 78 mr r4,r29
ffc14d34: 38 a0 00 01 li r5,1
ffc14d38: 7f 66 db 78 mr r6,r27
ffc14d3c: 4b ff fc 81 bl ffc149bc <fat_buf_access>
if (rc != RC_OK)
ffc14d40: 2f 83 00 00 cmpwi cr7,r3,0
ffc14d44: 40 9e 00 4c bne- cr7,ffc14d90 <_fat_block_read+0x9c> <== NEVER TAKEN
return -1;
c = MIN(count, (fs_info->vol.bps - ofs));
ffc14d48: a3 1a 00 00 lhz r24,0(r26)
ffc14d4c: 7f 1c c0 50 subf r24,r28,r24
ffc14d50: 7f 98 f8 40 cmplw cr7,r24,r31
ffc14d54: 40 9d 00 08 ble- cr7,ffc14d5c <_fat_block_read+0x68>
ffc14d58: 7f f8 fb 78 mr r24,r31
memcpy((buff + cmpltd), (block->buffer + ofs), c);
ffc14d5c: 81 21 00 08 lwz r9,8(r1)
ffc14d60: 7c 79 f2 14 add r3,r25,r30
ffc14d64: 7f 05 c3 78 mr r5,r24
ffc14d68: 80 89 00 24 lwz r4,36(r9)
count -= c;
ffc14d6c: 7f f8 f8 50 subf r31,r24,r31
cmpltd += c;
ffc14d70: 7f d8 f2 14 add r30,r24,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);
ffc14d74: 7c 84 e2 14 add r4,r4,r28
ffc14d78: 48 00 a2 95 bl ffc1f00c <memcpy>
count -= c;
cmpltd += c;
blk++;
ffc14d7c: 3b bd 00 01 addi r29,r29,1
ofs = 0;
ffc14d80: 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)
ffc14d84: 2f 9f 00 00 cmpwi cr7,r31,0
ffc14d88: 40 9e ff a4 bne+ cr7,ffc14d2c <_fat_block_read+0x38>
ffc14d8c: 48 00 00 08 b ffc14d94 <_fat_block_read+0xa0>
{
rc = fat_buf_access(fs_info, blk, FAT_OP_TYPE_READ, &block);
if (rc != RC_OK)
return -1;
ffc14d90: 3b c0 ff ff li r30,-1 <== NOT EXECUTED
cmpltd += c;
blk++;
ofs = 0;
}
return cmpltd;
}
ffc14d94: 39 61 00 38 addi r11,r1,56
ffc14d98: 7f c3 f3 78 mr r3,r30
ffc14d9c: 4b fe dd 40 b ffc02adc <_restgpr_24_x>
ffc14e60 <_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);
ffc14e60: 80 63 00 34 lwz r3,52(r3) <== NOT EXECUTED
ffc14e64: 4b ff fd 3c b ffc14ba0 <fat_buf_release> <== NOT EXECUTED
ffc14da0 <_fat_block_write>:
rtems_filesystem_mount_table_entry_t *mt_entry,
uint32_t start,
uint32_t offset,
uint32_t count,
const void *buff)
{
ffc14da0: 94 21 ff c0 stwu r1,-64(r1)
ffc14da4: 7c 08 02 a6 mflr r0
ffc14da8: 90 01 00 44 stw r0,68(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;
ffc14dac: 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)
{
ffc14db0: be e1 00 1c stmw r23,28(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;
ffc14db4: 7c 3b 0b 78 mr r27,r1
rtems_filesystem_mount_table_entry_t *mt_entry,
uint32_t start,
uint32_t offset,
uint32_t count,
const void *buff)
{
ffc14db8: 7c df 33 78 mr r31,r6
ffc14dbc: 7c f7 3b 78 mr r23,r7
int rc = RC_OK;
fat_fs_info_t *fs_info = mt_entry->fs_info;
ffc14dc0: 83 43 00 34 lwz r26,52(r3)
ssize_t cmpltd = 0;
uint32_t blk = start;
uint32_t ofs = offset;
rtems_bdbuf_buffer *block = NULL;
ffc14dc4: 94 1b 00 08 stwu r0,8(r27)
{
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;
ffc14dc8: 7c b9 2b 78 mr r25,r5
const void *buff)
{
int rc = RC_OK;
fat_fs_info_t *fs_info = mt_entry->fs_info;
ssize_t cmpltd = 0;
uint32_t blk = start;
ffc14dcc: 7c 9c 23 78 mr r28,r4
uint32_t count,
const void *buff)
{
int rc = RC_OK;
fat_fs_info_t *fs_info = mt_entry->fs_info;
ssize_t cmpltd = 0;
ffc14dd0: 3b a0 00 00 li r29,0
}
static inline void
fat_buf_mark_modified(fat_fs_info_t *fs_info)
{
fs_info->c.modified = true;
ffc14dd4: 3b 00 00 01 li r24,1
uint32_t blk = start;
uint32_t ofs = offset;
rtems_bdbuf_buffer *block = NULL;
uint32_t c = 0;
while(count > 0)
ffc14dd8: 48 00 00 6c b ffc14e44 <_fat_block_write+0xa4>
{
c = MIN(count, (fs_info->vol.bps - ofs));
ffc14ddc: a0 1a 00 00 lhz r0,0(r26)
ffc14de0: 7f d9 00 50 subf r30,r25,r0
ffc14de4: 7f 9e f8 40 cmplw cr7,r30,r31
ffc14de8: 40 9d 00 08 ble- cr7,ffc14df0 <_fat_block_write+0x50>
ffc14dec: 7f fe fb 78 mr r30,r31
if (c == fs_info->vol.bps)
ffc14df0: 7f 9e 00 00 cmpw cr7,r30,r0
rc = fat_buf_access(fs_info, blk, FAT_OP_TYPE_GET, &block);
ffc14df4: 7f 43 d3 78 mr r3,r26
ffc14df8: 7f 84 e3 78 mr r4,r28
ffc14dfc: 38 a0 00 02 li r5,2
while(count > 0)
{
c = MIN(count, (fs_info->vol.bps - ofs));
if (c == fs_info->vol.bps)
ffc14e00: 41 9e 00 08 beq- cr7,ffc14e08 <_fat_block_write+0x68>
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);
ffc14e04: 38 a0 00 01 li r5,1
ffc14e08: 7f 66 db 78 mr r6,r27
ffc14e0c: 4b ff fb b1 bl ffc149bc <fat_buf_access>
if (rc != RC_OK)
ffc14e10: 2f 83 00 00 cmpwi cr7,r3,0
ffc14e14: 40 9e 00 3c bne- cr7,ffc14e50 <_fat_block_write+0xb0> <== NEVER TAKEN
return -1;
memcpy((block->buffer + ofs), (buff + cmpltd), c);
ffc14e18: 81 21 00 08 lwz r9,8(r1)
ffc14e1c: 7c 97 ea 14 add r4,r23,r29
ffc14e20: 7f c5 f3 78 mr r5,r30
ffc14e24: 80 69 00 24 lwz r3,36(r9)
fat_buf_mark_modified(fs_info);
count -= c;
ffc14e28: 7f fe f8 50 subf r31,r30,r31
cmpltd +=c;
ffc14e2c: 7f be ea 14 add r29,r30,r29
else
rc = fat_buf_access(fs_info, blk, FAT_OP_TYPE_READ, &block);
if (rc != RC_OK)
return -1;
memcpy((block->buffer + ofs), (buff + cmpltd), c);
ffc14e30: 7c 63 ca 14 add r3,r3,r25
ffc14e34: 48 00 a1 d9 bl ffc1f00c <memcpy>
ffc14e38: 9b 1a 00 84 stb r24,132(r26)
fat_buf_mark_modified(fs_info);
count -= c;
cmpltd +=c;
blk++;
ffc14e3c: 3b 9c 00 01 addi r28,r28,1
ofs = 0;
ffc14e40: 3b 20 00 00 li r25,0
uint32_t blk = start;
uint32_t ofs = offset;
rtems_bdbuf_buffer *block = NULL;
uint32_t c = 0;
while(count > 0)
ffc14e44: 2f 9f 00 00 cmpwi cr7,r31,0
ffc14e48: 40 9e ff 94 bne+ cr7,ffc14ddc <_fat_block_write+0x3c>
ffc14e4c: 48 00 00 08 b ffc14e54 <_fat_block_write+0xb4>
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)
return -1;
ffc14e50: 3b a0 ff ff li r29,-1 <== NOT EXECUTED
cmpltd +=c;
blk++;
ofs = 0;
}
return cmpltd;
}
ffc14e54: 39 61 00 40 addi r11,r1,64
ffc14e58: 7f a3 eb 78 mr r3,r29
ffc14e5c: 4b fe dc 7c b ffc02ad8 <_restgpr_23_x>
ffc13d48 <_hash_search>:
rtems_chain_control *hash,
uint32_t key1,
uint32_t key2,
fat_file_fd_t **ret
)
{
ffc13d48: 94 21 ff d8 stwu r1,-40(r1)
ffc13d4c: 7c 08 02 a6 mflr r0
ffc13d50: 7d 80 00 26 mfcr r12
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) )
ffc13d54: 2e 06 00 00 cmpwi cr4,r6,0
rtems_chain_control *hash,
uint32_t key1,
uint32_t key2,
fat_file_fd_t **ret
)
{
ffc13d58: 90 01 00 2c stw r0,44(r1)
uint32_t mod = (key1) % FAT_HASH_MODULE;
ffc13d5c: 54 a0 07 fe clrlwi r0,r5,31
rtems_chain_node *the_node = rtems_chain_first(hash + mod);
ffc13d60: 1c 00 00 0c mulli r0,r0,12
rtems_chain_control *hash,
uint32_t key1,
uint32_t key2,
fat_file_fd_t **ret
)
{
ffc13d64: bf 41 00 10 stmw r26,16(r1)
uint32_t mod = (key1) % FAT_HASH_MODULE;
rtems_chain_node *the_node = rtems_chain_first(hash + mod);
ffc13d68: 7f 64 02 14 add r27,r4,r0
rtems_chain_control *hash,
uint32_t key1,
uint32_t key2,
fat_file_fd_t **ret
)
{
ffc13d6c: 91 81 00 0c stw r12,12(r1)
ffc13d70: 7c 7f 1b 78 mr r31,r3
ffc13d74: 7c be 2b 78 mr r30,r5
ffc13d78: 7c fc 3b 78 mr r28,r7
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
ffc13d7c: 7f a4 00 2e lwzx r29,r4,r0
RTEMS_INLINE_ROUTINE bool _Chain_Is_tail(
Chain_Control *the_chain,
const Chain_Node *the_node
)
{
return (the_node == _Chain_Tail(the_chain));
ffc13d80: 3b 7b 00 04 addi r27,r27,4
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) )
ffc13d84: 7c da 33 78 mr r26,r6
)
{
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) ; )
ffc13d88: 48 00 00 38 b ffc13dc0 <_hash_search+0x78>
{
fat_file_fd_t *ffd = (fat_file_fd_t *)the_node;
uint32_t ck = fat_construct_key(mt_entry, &ffd->dir_pos.sname);
ffc13d8c: 7f e3 fb 78 mr r3,r31
ffc13d90: 38 9d 00 20 addi r4,r29,32
ffc13d94: 4b ff ff 5d bl ffc13cf0 <fat_construct_key>
if ( (key1) == ck)
ffc13d98: 7f 9e 18 00 cmpw cr7,r30,r3
ffc13d9c: 40 be 00 20 bne+ cr7,ffc13dbc <_hash_search+0x74>
{
if ( ((key2) == 0) || ((key2) == ffd->ino) )
ffc13da0: 41 92 00 10 beq- cr4,ffc13db0 <_hash_search+0x68> <== ALWAYS TAKEN
ffc13da4: 80 1d 00 0c lwz r0,12(r29) <== NOT EXECUTED
ffc13da8: 7f 9a 00 00 cmpw cr7,r26,r0 <== NOT EXECUTED
ffc13dac: 40 be 00 10 bne+ cr7,ffc13dbc <_hash_search+0x74> <== NOT EXECUTED
{
*ret = (void *)the_node;
ffc13db0: 93 bc 00 00 stw r29,0(r28)
return 0;
ffc13db4: 38 60 00 00 li r3,0
ffc13db8: 48 00 00 14 b ffc13dcc <_hash_search+0x84>
}
}
the_node = the_node->next;
ffc13dbc: 83 bd 00 00 lwz r29,0(r29)
)
{
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) ; )
ffc13dc0: 7f 9d d8 00 cmpw cr7,r29,r27
ffc13dc4: 40 9e ff c8 bne+ cr7,ffc13d8c <_hash_search+0x44>
return 0;
}
}
the_node = the_node->next;
}
return -1;
ffc13dc8: 38 60 ff ff li r3,-1
}
ffc13dcc: 81 81 00 0c lwz r12,12(r1)
ffc13dd0: 39 61 00 28 addi r11,r1,40
ffc13dd4: 7d 80 81 20 mtcrf 8,r12
ffc13dd8: 4b fe ed 0c b ffc02ae4 <_restgpr_26_x>
ffc22300 <_rename_r>:
int _rename_r(
struct _reent *ptr __attribute__((unused)),
const char *old,
const char *new
)
{
ffc22300: 94 21 ff 90 stwu r1,-112(r1)
ffc22304: 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 );
ffc22308: 7c 83 23 78 mr r3,r4
int _rename_r(
struct _reent *ptr __attribute__((unused)),
const char *old,
const char *new
)
{
ffc2230c: bf 41 00 58 stmw r26,88(r1)
ffc22310: 7c 9d 23 78 mr r29,r4
ffc22314: 7c bb 2b 78 mr r27,r5
ffc22318: 90 01 00 74 stw r0,116(r1)
/*
* Get the parent node of the old path to be renamed. Find the parent path.
*/
old_parent_pathlen = rtems_filesystem_dirname ( old );
ffc2231c: 4b fe 47 b5 bl ffc06ad0 <rtems_filesystem_dirname>
if ( old_parent_pathlen == 0 )
ffc22320: 7c 7a 1b 79 mr. r26,r3
rtems_filesystem_get_start_loc( old, &i, &old_parent_loc );
ffc22324: 7f a3 eb 78 mr r3,r29
* 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 )
ffc22328: 40 82 00 18 bne- ffc22340 <_rename_r+0x40>
rtems_filesystem_get_start_loc( old, &i, &old_parent_loc );
ffc2232c: 38 81 00 0c addi r4,r1,12
ffc22330: 38 a1 00 24 addi r5,r1,36
ffc22334: 4b fe 60 d9 bl ffc0840c <rtems_filesystem_get_start_loc>
rtems_filesystem_location_info_t old_parent_loc;
rtems_filesystem_location_info_t new_parent_loc;
int i;
int result;
const char *name;
bool free_old_parentloc = false;
ffc22338: 3b c0 00 00 li r30,0
ffc2233c: 48 00 00 28 b ffc22364 <_rename_r+0x64>
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,
ffc22340: 7f 44 d3 78 mr r4,r26
ffc22344: 38 a0 00 02 li r5,2
ffc22348: 38 c1 00 24 addi r6,r1,36
ffc2234c: 38 e0 00 00 li r7,0
ffc22350: 4b fe 47 25 bl ffc06a74 <rtems_filesystem_evaluate_path>
RTEMS_LIBIO_PERMS_WRITE,
&old_parent_loc,
false );
if ( result != 0 )
return -1;
ffc22354: 3b 80 ff ff li r28,-1
else {
result = rtems_filesystem_evaluate_path( old, old_parent_pathlen,
RTEMS_LIBIO_PERMS_WRITE,
&old_parent_loc,
false );
if ( result != 0 )
ffc22358: 2f 83 00 00 cmpwi cr7,r3,0
ffc2235c: 40 9e 01 5c bne- cr7,ffc224b8 <_rename_r+0x1b8> <== NEVER TAKEN
return -1;
free_old_parentloc = true;
ffc22360: 3b c0 00 01 li r30,1
/*
* Start from the parent to find the node that should be under it.
*/
old_loc = old_parent_loc;
ffc22364: 3b 81 00 38 addi r28,r1,56
ffc22368: 3b e1 00 24 addi r31,r1,36
ffc2236c: 7c bf a4 aa lswi r5,r31,20
ffc22370: 7c bc a5 aa stswi r5,r28,20
name = old + old_parent_pathlen;
ffc22374: 7f bd d2 14 add r29,r29,r26
name += rtems_filesystem_prefix_separators( name, strlen( name ) );
ffc22378: 7f a3 eb 78 mr r3,r29
/*
* Start from the parent to find the node that should be under it.
*/
old_loc = old_parent_loc;
name = old + old_parent_pathlen;
ffc2237c: 93 a1 00 08 stw r29,8(r1)
name += rtems_filesystem_prefix_separators( name, strlen( name ) );
ffc22380: 4b ff 2a e1 bl ffc14e60 <strlen>
ffc22384: 7c 64 1b 78 mr r4,r3
ffc22388: 7f a3 eb 78 mr r3,r29
ffc2238c: 4b fe 47 8d bl ffc06b18 <rtems_filesystem_prefix_separators>
ffc22390: 7f bd 1a 14 add r29,r29,r3
result = rtems_filesystem_evaluate_relative_path( name , strlen( name ),
ffc22394: 7f a3 eb 78 mr r3,r29
* 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 ) );
ffc22398: 93 a1 00 08 stw r29,8(r1)
result = rtems_filesystem_evaluate_relative_path( name , strlen( name ),
ffc2239c: 4b ff 2a c5 bl ffc14e60 <strlen>
ffc223a0: 38 a0 00 00 li r5,0
ffc223a4: 7c 64 1b 78 mr r4,r3
ffc223a8: 7f 86 e3 78 mr r6,r28
ffc223ac: 7f a3 eb 78 mr r3,r29
ffc223b0: 38 e0 00 00 li r7,0
ffc223b4: 4b fe 46 3d bl ffc069f0 <rtems_filesystem_evaluate_relative_path>
0, &old_loc, false );
if ( result != 0 ) {
ffc223b8: 2f 83 00 00 cmpwi cr7,r3,0
ffc223bc: 41 9e 00 18 beq- cr7,ffc223d4 <_rename_r+0xd4>
if ( free_old_parentloc )
ffc223c0: 2f 9e 00 00 cmpwi cr7,r30,0
rtems_filesystem_freenode( &old_parent_loc );
return -1;
ffc223c4: 3b 80 ff ff li r28,-1
result = rtems_filesystem_evaluate_relative_path( name , strlen( name ),
0, &old_loc, false );
if ( result != 0 ) {
if ( free_old_parentloc )
rtems_filesystem_freenode( &old_parent_loc );
ffc223c8: 7f e3 fb 78 mr r3,r31
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 )
ffc223cc: 41 be 00 ec beq+ cr7,ffc224b8 <_rename_r+0x1b8>
ffc223d0: 48 00 00 e4 b ffc224b4 <_rename_r+0x1b4>
/*
* Get the parent of the new node we are renaming to.
*/
rtems_filesystem_get_start_loc( new, &i, &new_parent_loc );
ffc223d4: 7f 63 db 78 mr r3,r27
ffc223d8: 38 81 00 0c addi r4,r1,12
ffc223dc: 38 a1 00 10 addi r5,r1,16
ffc223e0: 4b fe 60 2d bl ffc0840c <rtems_filesystem_get_start_loc>
result = (*new_parent_loc.ops->evalformake_h)( &new[i], &new_parent_loc, &name );
ffc223e4: 81 21 00 1c lwz r9,28(r1)
ffc223e8: 80 61 00 0c lwz r3,12(r1)
ffc223ec: 38 81 00 10 addi r4,r1,16
ffc223f0: 80 09 00 04 lwz r0,4(r9)
ffc223f4: 38 a1 00 08 addi r5,r1,8
ffc223f8: 7c 7b 1a 14 add r3,r27,r3
ffc223fc: 7c 09 03 a6 mtctr r0
ffc22400: 4e 80 04 21 bctrl
if ( result != 0 ) {
ffc22404: 2f 83 00 00 cmpwi cr7,r3,0
ffc22408: 41 be 00 28 beq+ cr7,ffc22430 <_rename_r+0x130>
rtems_filesystem_freenode( &new_parent_loc );
ffc2240c: 38 61 00 10 addi r3,r1,16
ffc22410: 4b fe 48 55 bl ffc06c64 <rtems_filesystem_freenode>
if ( free_old_parentloc )
ffc22414: 2f 9e 00 00 cmpwi cr7,r30,0
ffc22418: 41 be 00 0c beq+ cr7,ffc22424 <_rename_r+0x124>
rtems_filesystem_freenode( &old_parent_loc );
ffc2241c: 7f e3 fb 78 mr r3,r31
ffc22420: 4b fe 48 45 bl ffc06c64 <rtems_filesystem_freenode>
rtems_filesystem_freenode( &old_loc );
ffc22424: 38 61 00 38 addi r3,r1,56
ffc22428: 4b fe 48 3d bl ffc06c64 <rtems_filesystem_freenode>
ffc2242c: 48 00 00 40 b ffc2246c <_rename_r+0x16c>
/*
* 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 ) {
ffc22430: 80 01 00 20 lwz r0,32(r1)
ffc22434: 81 21 00 34 lwz r9,52(r1)
ffc22438: 7f 89 00 00 cmpw cr7,r9,r0
ffc2243c: 41 be 00 38 beq+ cr7,ffc22474 <_rename_r+0x174>
rtems_filesystem_freenode( &new_parent_loc );
ffc22440: 38 61 00 10 addi r3,r1,16
ffc22444: 4b fe 48 21 bl ffc06c64 <rtems_filesystem_freenode>
if ( free_old_parentloc )
ffc22448: 2f 9e 00 00 cmpwi cr7,r30,0
ffc2244c: 41 be 00 0c beq+ cr7,ffc22458 <_rename_r+0x158>
rtems_filesystem_freenode( &old_parent_loc );
ffc22450: 7f e3 fb 78 mr r3,r31
ffc22454: 4b fe 48 11 bl ffc06c64 <rtems_filesystem_freenode>
rtems_filesystem_freenode( &old_loc );
ffc22458: 38 61 00 38 addi r3,r1,56
ffc2245c: 4b fe 48 09 bl ffc06c64 <rtems_filesystem_freenode>
rtems_set_errno_and_return_minus_one( EXDEV );
ffc22460: 4b ff 11 b5 bl ffc13614 <__errno>
ffc22464: 38 00 00 12 li r0,18
ffc22468: 90 03 00 00 stw r0,0(r3)
ffc2246c: 3b 80 ff ff li r28,-1
ffc22470: 48 00 00 48 b ffc224b8 <_rename_r+0x1b8>
}
result = (*new_parent_loc.ops->rename_h)( &old_parent_loc, &old_loc, &new_parent_loc, name );
ffc22474: 81 21 00 1c lwz r9,28(r1)
ffc22478: 7f 84 e3 78 mr r4,r28
ffc2247c: 38 a1 00 10 addi r5,r1,16
ffc22480: 80 c1 00 08 lwz r6,8(r1)
ffc22484: 80 09 00 40 lwz r0,64(r9)
ffc22488: 7f e3 fb 78 mr r3,r31
ffc2248c: 7c 09 03 a6 mtctr r0
ffc22490: 4e 80 04 21 bctrl
ffc22494: 7c 7c 1b 78 mr r28,r3
rtems_filesystem_freenode( &new_parent_loc );
ffc22498: 38 61 00 10 addi r3,r1,16
ffc2249c: 4b fe 47 c9 bl ffc06c64 <rtems_filesystem_freenode>
if ( free_old_parentloc )
ffc224a0: 2f 9e 00 00 cmpwi cr7,r30,0
ffc224a4: 41 be 00 0c beq+ cr7,ffc224b0 <_rename_r+0x1b0>
rtems_filesystem_freenode( &old_parent_loc );
ffc224a8: 7f e3 fb 78 mr r3,r31
ffc224ac: 4b fe 47 b9 bl ffc06c64 <rtems_filesystem_freenode>
rtems_filesystem_freenode( &old_loc );
ffc224b0: 38 61 00 38 addi r3,r1,56
ffc224b4: 4b fe 47 b1 bl ffc06c64 <rtems_filesystem_freenode>
return result;
}
ffc224b8: 39 61 00 70 addi r11,r1,112
ffc224bc: 7f 83 e3 78 mr r3,r28
ffc224c0: 4b fe 03 ac b ffc0286c <_restgpr_26_x>
ffc08520 <aio_cancel>:
* operation(s) cannot be canceled
*/
int aio_cancel(int fildes, struct aiocb *aiocbp)
{
ffc08520: 94 21 ff e0 stwu r1,-32(r1)
ffc08524: 7c 08 02 a6 mflr r0
ffc08528: bf 61 00 0c stmw r27,12(r1)
rtems_aio_request_chain *r_chain;
int result;
pthread_mutex_lock (&aio_request_queue.mutex);
ffc0852c: 3f e0 00 00 lis r31,0
ffc08530: 3b ff 2c 70 addi r31,r31,11376
* operation(s) cannot be canceled
*/
int aio_cancel(int fildes, struct aiocb *aiocbp)
{
ffc08534: 7c 7d 1b 78 mr r29,r3
ffc08538: 90 01 00 24 stw r0,36(r1)
rtems_aio_request_chain *r_chain;
int result;
pthread_mutex_lock (&aio_request_queue.mutex);
ffc0853c: 7f e3 fb 78 mr r3,r31
* operation(s) cannot be canceled
*/
int aio_cancel(int fildes, struct aiocb *aiocbp)
{
ffc08540: 7c 9e 23 78 mr r30,r4
rtems_aio_request_chain *r_chain;
int result;
pthread_mutex_lock (&aio_request_queue.mutex);
ffc08544: 48 00 12 01 bl ffc09744 <pthread_mutex_lock>
if (fcntl (fildes, F_GETFD) < 0) {
ffc08548: 7f a3 eb 78 mr r3,r29
ffc0854c: 38 80 00 01 li r4,1
ffc08550: 4c c6 31 82 crclr 4*cr1+eq
ffc08554: 48 00 75 51 bl ffc0faa4 <fcntl>
ffc08558: 2f 83 00 00 cmpwi cr7,r3,0
ffc0855c: 40 bc 00 18 bge+ cr7,ffc08574 <aio_cancel+0x54>
pthread_mutex_unlock(&aio_request_queue.mutex);
ffc08560: 7f e3 fb 78 mr r3,r31
ffc08564: 48 00 12 85 bl ffc097e8 <pthread_mutex_unlock>
rtems_set_errno_and_return_minus_one (EBADF);
ffc08568: 48 00 ad d5 bl ffc1333c <__errno>
ffc0856c: 38 00 00 09 li r0,9
ffc08570: 48 00 00 c8 b ffc08638 <aio_cancel+0x118>
}
/* if aiocbp is NULL remove all request for given file descriptor */
if (aiocbp == NULL) {
ffc08574: 2f 9e 00 00 cmpwi cr7,r30,0
ffc08578: 40 be 00 a4 bne+ cr7,ffc0861c <aio_cancel+0xfc>
AIO_printf ("Cancel all requests\n");
r_chain = rtems_aio_search_fd (&aio_request_queue.work_req, fildes, 0);
ffc0857c: 38 7f 00 48 addi r3,r31,72
ffc08580: 7f a4 eb 78 mr r4,r29
ffc08584: 38 a0 00 00 li r5,0
ffc08588: 48 00 02 d1 bl ffc08858 <rtems_aio_search_fd>
if (r_chain == NULL) {
ffc0858c: 7c 7e 1b 79 mr. r30,r3
ffc08590: 40 a2 00 58 bne+ ffc085e8 <aio_cancel+0xc8>
AIO_printf ("Request chain not on [WQ]\n");
if (!rtems_chain_is_empty (&aio_request_queue.idle_req)) {
ffc08594: 81 3f 00 54 lwz r9,84(r31)
ffc08598: 38 1f 00 58 addi r0,r31,88
ffc0859c: 7f 89 00 00 cmpw cr7,r9,r0
ffc085a0: 41 9e 00 f8 beq- cr7,ffc08698 <aio_cancel+0x178> <== NEVER TAKEN
r_chain = rtems_aio_search_fd (&aio_request_queue.idle_req, fildes, 0);
ffc085a4: 38 7f 00 54 addi r3,r31,84
ffc085a8: 7f a4 eb 78 mr r4,r29
ffc085ac: 38 a0 00 00 li r5,0
ffc085b0: 48 00 02 a9 bl ffc08858 <rtems_aio_search_fd>
if (r_chain == NULL) {
ffc085b4: 7c 7e 1b 79 mr. r30,r3
ffc085b8: 41 82 00 e0 beq- ffc08698 <aio_cancel+0x178>
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
ffc085bc: 48 00 2d 89 bl ffc0b344 <_Chain_Extract>
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);
ffc085c0: 3b be 00 1c addi r29,r30,28
}
AIO_printf ("Request chain on [IQ]\n");
rtems_chain_extract (&r_chain->next_fd);
rtems_aio_remove_fd (r_chain);
ffc085c4: 7f c3 f3 78 mr r3,r30
ffc085c8: 48 00 06 59 bl ffc08c20 <rtems_aio_remove_fd>
pthread_mutex_destroy (&r_chain->mutex);
ffc085cc: 7f a3 eb 78 mr r3,r29
ffc085d0: 48 00 0e b1 bl ffc09480 <pthread_mutex_destroy>
pthread_cond_destroy (&r_chain->mutex);
ffc085d4: 7f a3 eb 78 mr r3,r29
ffc085d8: 48 00 0a e1 bl ffc090b8 <pthread_cond_destroy>
free (r_chain);
ffc085dc: 7f c3 f3 78 mr r3,r30
ffc085e0: 4b ff cb 29 bl ffc05108 <free>
ffc085e4: 48 00 00 28 b ffc0860c <aio_cancel+0xec>
return AIO_ALLDONE;
}
AIO_printf ("Request chain on [WQ]\n");
pthread_mutex_lock (&r_chain->mutex);
ffc085e8: 3b be 00 1c addi r29,r30,28
ffc085ec: 7f a3 eb 78 mr r3,r29
ffc085f0: 48 00 11 55 bl ffc09744 <pthread_mutex_lock>
ffc085f4: 7f c3 f3 78 mr r3,r30
ffc085f8: 48 00 2d 4d bl ffc0b344 <_Chain_Extract>
rtems_chain_extract (&r_chain->next_fd);
rtems_aio_remove_fd (r_chain);
ffc085fc: 7f c3 f3 78 mr r3,r30
ffc08600: 48 00 06 21 bl ffc08c20 <rtems_aio_remove_fd>
pthread_mutex_unlock (&r_chain->mutex);
ffc08604: 7f a3 eb 78 mr r3,r29
ffc08608: 48 00 11 e1 bl ffc097e8 <pthread_mutex_unlock>
pthread_mutex_unlock (&aio_request_queue.mutex);
ffc0860c: 7f e3 fb 78 mr r3,r31
ffc08610: 48 00 11 d9 bl ffc097e8 <pthread_mutex_unlock>
return AIO_CANCELED;
ffc08614: 3b c0 00 00 li r30,0
ffc08618: 48 00 00 bc b ffc086d4 <aio_cancel+0x1b4>
} else {
AIO_printf ("Cancel request\n");
if (aiocbp->aio_fildes != fildes) {
ffc0861c: 83 9e 00 00 lwz r28,0(r30)
ffc08620: 7f 9c e8 00 cmpw cr7,r28,r29
ffc08624: 41 be 00 20 beq+ cr7,ffc08644 <aio_cancel+0x124>
pthread_mutex_unlock (&aio_request_queue.mutex);
ffc08628: 7f e3 fb 78 mr r3,r31
ffc0862c: 48 00 11 bd bl ffc097e8 <pthread_mutex_unlock>
rtems_set_errno_and_return_minus_one (EINVAL);
ffc08630: 48 00 ad 0d bl ffc1333c <__errno>
ffc08634: 38 00 00 16 li r0,22
ffc08638: 90 03 00 00 stw r0,0(r3)
ffc0863c: 3b c0 ff ff li r30,-1
ffc08640: 48 00 00 94 b ffc086d4 <aio_cancel+0x1b4>
}
r_chain = rtems_aio_search_fd (&aio_request_queue.work_req, fildes, 0);
ffc08644: 38 7f 00 48 addi r3,r31,72
ffc08648: 7f 84 e3 78 mr r4,r28
ffc0864c: 38 a0 00 00 li r5,0
ffc08650: 48 00 02 09 bl ffc08858 <rtems_aio_search_fd>
if (r_chain == NULL) {
ffc08654: 7c 7b 1b 79 mr. r27,r3
ffc08658: 40 a2 00 50 bne+ ffc086a8 <aio_cancel+0x188>
if (!rtems_chain_is_empty (&aio_request_queue.idle_req)) {
ffc0865c: 81 3f 00 54 lwz r9,84(r31)
ffc08660: 38 1f 00 58 addi r0,r31,88
ffc08664: 7f 89 00 00 cmpw cr7,r9,r0
ffc08668: 41 9e 00 30 beq- cr7,ffc08698 <aio_cancel+0x178> <== NEVER TAKEN
r_chain = rtems_aio_search_fd (&aio_request_queue.idle_req, fildes, 0);
ffc0866c: 38 7f 00 54 addi r3,r31,84
ffc08670: 7f 84 e3 78 mr r4,r28
ffc08674: 38 a0 00 00 li r5,0
ffc08678: 48 00 01 e1 bl ffc08858 <rtems_aio_search_fd>
if (r_chain == NULL) {
ffc0867c: 2c 03 00 00 cmpwi r3,0
ffc08680: 41 a2 ff a8 beq- ffc08628 <aio_cancel+0x108>
rtems_set_errno_and_return_minus_one (EINVAL);
}
AIO_printf ("Request on [IQ]\n");
result = rtems_aio_remove_req (&r_chain->perfd, aiocbp);
ffc08684: 7f c4 f3 78 mr r4,r30
ffc08688: 38 63 00 08 addi r3,r3,8
ffc0868c: 48 00 05 ed bl ffc08c78 <rtems_aio_remove_req>
ffc08690: 7c 7e 1b 78 mr r30,r3
ffc08694: 48 00 00 38 b ffc086cc <aio_cancel+0x1ac>
pthread_mutex_unlock (&aio_request_queue.mutex);
return result;
} else {
pthread_mutex_unlock (&aio_request_queue.mutex);
ffc08698: 7f e3 fb 78 mr r3,r31
ffc0869c: 48 00 11 4d bl ffc097e8 <pthread_mutex_unlock>
return AIO_ALLDONE;
ffc086a0: 3b c0 00 02 li r30,2
ffc086a4: 48 00 00 30 b ffc086d4 <aio_cancel+0x1b4>
}
}
AIO_printf ("Request on [WQ]\n");
pthread_mutex_lock (&r_chain->mutex);
ffc086a8: 3b bb 00 1c addi r29,r27,28
ffc086ac: 7f a3 eb 78 mr r3,r29
ffc086b0: 48 00 10 95 bl ffc09744 <pthread_mutex_lock>
result = rtems_aio_remove_req (&r_chain->perfd, aiocbp);
ffc086b4: 7f c4 f3 78 mr r4,r30
ffc086b8: 38 7b 00 08 addi r3,r27,8
ffc086bc: 48 00 05 bd bl ffc08c78 <rtems_aio_remove_req>
ffc086c0: 7c 7e 1b 78 mr r30,r3
pthread_mutex_unlock (&r_chain->mutex);
ffc086c4: 7f a3 eb 78 mr r3,r29
ffc086c8: 48 00 11 21 bl ffc097e8 <pthread_mutex_unlock>
pthread_mutex_unlock (&aio_request_queue.mutex);
ffc086cc: 7f e3 fb 78 mr r3,r31
ffc086d0: 48 00 11 19 bl ffc097e8 <pthread_mutex_unlock>
return result;
}
return AIO_ALLDONE;
}
ffc086d4: 39 61 00 20 addi r11,r1,32
ffc086d8: 7f c3 f3 78 mr r3,r30
ffc086dc: 4b ff 84 1c b ffc00af8 <_restgpr_27_x>
ffc086e8 <aio_fsync>:
)
{
rtems_aio_request *req;
int mode;
if (op != O_SYNC)
ffc086e8: 2f 83 20 00 cmpwi cr7,r3,8192
int aio_fsync(
int op,
struct aiocb *aiocbp
)
{
ffc086ec: 94 21 ff f0 stwu r1,-16(r1)
ffc086f0: 7c 08 02 a6 mflr r0
ffc086f4: bf c1 00 08 stmw r30,8(r1)
ffc086f8: 7c 9f 23 78 mr r31,r4
rtems_aio_request *req;
int mode;
if (op != O_SYNC)
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
ffc086fc: 3b c0 00 16 li r30,22
int aio_fsync(
int op,
struct aiocb *aiocbp
)
{
ffc08700: 90 01 00 14 stw r0,20(r1)
rtems_aio_request *req;
int mode;
if (op != O_SYNC)
ffc08704: 40 9e 00 28 bne- cr7,ffc0872c <aio_fsync+0x44>
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
ffc08708: 80 64 00 00 lwz r3,0(r4)
ffc0870c: 38 80 00 03 li r4,3
ffc08710: 4c c6 31 82 crclr 4*cr1+eq
ffc08714: 48 00 73 91 bl ffc0faa4 <fcntl>
if (!(((mode & O_ACCMODE) == O_WRONLY) || ((mode & O_ACCMODE) == O_RDWR)))
ffc08718: 54 63 07 be clrlwi r3,r3,30
ffc0871c: 38 63 ff ff addi r3,r3,-1
ffc08720: 2b 83 00 01 cmplwi cr7,r3,1
ffc08724: 40 bd 00 24 ble+ cr7,ffc08748 <aio_fsync+0x60>
rtems_aio_set_errno_return_minus_one (EBADF, aiocbp);
ffc08728: 3b c0 00 09 li r30,9
ffc0872c: 38 00 ff ff li r0,-1
ffc08730: 93 df 00 34 stw r30,52(r31)
ffc08734: 90 1f 00 38 stw r0,56(r31)
ffc08738: 48 00 ac 05 bl ffc1333c <__errno>
ffc0873c: 93 c3 00 00 stw r30,0(r3)
ffc08740: 38 60 ff ff li r3,-1
ffc08744: 48 00 00 28 b ffc0876c <aio_fsync+0x84>
req = malloc (sizeof (rtems_aio_request));
ffc08748: 38 60 00 18 li r3,24
ffc0874c: 4b ff d0 29 bl ffc05774 <malloc>
if (req == NULL)
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
ffc08750: 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)
ffc08754: 7c 69 1b 79 mr. r9,r3
ffc08758: 41 a2 ff d4 beq- ffc0872c <aio_fsync+0x44> <== NEVER TAKEN
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
req->aiocbp = aiocbp;
req->aiocbp->aio_lio_opcode = LIO_SYNC;
ffc0875c: 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;
ffc08760: 93 e9 00 14 stw r31,20(r9)
req->aiocbp->aio_lio_opcode = LIO_SYNC;
ffc08764: 90 1f 00 30 stw r0,48(r31)
return rtems_aio_enqueue (req);
ffc08768: 48 00 05 8d bl ffc08cf4 <rtems_aio_enqueue>
}
ffc0876c: 39 61 00 10 addi r11,r1,16
ffc08770: 4b ff 83 94 b ffc00b04 <_restgpr_30_x>
ffc08f00 <aio_read>:
* 0 - otherwise
*/
int
aio_read (struct aiocb *aiocbp)
{
ffc08f00: 94 21 ff f0 stwu r1,-16(r1)
ffc08f04: 7c 08 02 a6 mflr r0
rtems_aio_request *req;
int mode;
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
ffc08f08: 38 80 00 03 li r4,3
* 0 - otherwise
*/
int
aio_read (struct aiocb *aiocbp)
{
ffc08f0c: 90 01 00 14 stw r0,20(r1)
ffc08f10: bf c1 00 08 stmw r30,8(r1)
ffc08f14: 7c 7f 1b 78 mr r31,r3
rtems_aio_request *req;
int mode;
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
ffc08f18: 80 63 00 00 lwz r3,0(r3)
ffc08f1c: 4c c6 31 82 crclr 4*cr1+eq
ffc08f20: 48 00 6b 85 bl ffc0faa4 <fcntl>
if (!(((mode & O_ACCMODE) == O_RDONLY) || ((mode & O_ACCMODE) == O_RDWR)))
ffc08f24: 70 63 00 03 andi. r3,r3,3
ffc08f28: 41 82 00 10 beq- ffc08f38 <aio_read+0x38> <== NEVER TAKEN
ffc08f2c: 2f 83 00 02 cmpwi cr7,r3,2
rtems_aio_set_errno_return_minus_one (EBADF, aiocbp);
ffc08f30: 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)))
ffc08f34: 40 9e 00 14 bne- cr7,ffc08f48 <aio_read+0x48>
rtems_aio_set_errno_return_minus_one (EBADF, aiocbp);
if (aiocbp->aio_reqprio < 0 || aiocbp->aio_reqprio > AIO_PRIO_DELTA_MAX)
ffc08f38: 80 1f 00 18 lwz r0,24(r31)
ffc08f3c: 2f 80 00 00 cmpwi cr7,r0,0
ffc08f40: 41 be 00 24 beq+ cr7,ffc08f64 <aio_read+0x64>
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
ffc08f44: 3b c0 00 16 li r30,22
ffc08f48: 38 00 ff ff li r0,-1
ffc08f4c: 93 df 00 34 stw r30,52(r31)
ffc08f50: 90 1f 00 38 stw r0,56(r31)
ffc08f54: 48 00 a3 e9 bl ffc1333c <__errno>
ffc08f58: 93 c3 00 00 stw r30,0(r3)
ffc08f5c: 38 60 ff ff li r3,-1
ffc08f60: 48 00 00 34 b ffc08f94 <aio_read+0x94>
if (aiocbp->aio_offset < 0)
ffc08f64: 80 1f 00 08 lwz r0,8(r31)
ffc08f68: 2f 80 00 00 cmpwi cr7,r0,0
ffc08f6c: 41 bc ff d8 blt- cr7,ffc08f44 <aio_read+0x44>
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
req = malloc (sizeof (rtems_aio_request));
ffc08f70: 38 60 00 18 li r3,24
ffc08f74: 4b ff c8 01 bl ffc05774 <malloc>
if (req == NULL)
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
ffc08f78: 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)
ffc08f7c: 7c 69 1b 79 mr. r9,r3
ffc08f80: 41 a2 ff c8 beq- ffc08f48 <aio_read+0x48> <== NEVER TAKEN
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
req->aiocbp = aiocbp;
req->aiocbp->aio_lio_opcode = LIO_READ;
ffc08f84: 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;
ffc08f88: 93 e9 00 14 stw r31,20(r9)
req->aiocbp->aio_lio_opcode = LIO_READ;
ffc08f8c: 90 1f 00 30 stw r0,48(r31)
return rtems_aio_enqueue (req);
ffc08f90: 4b ff fd 65 bl ffc08cf4 <rtems_aio_enqueue>
}
ffc08f94: 39 61 00 10 addi r11,r1,16
ffc08f98: 4b ff 7b 6c b ffc00b04 <_restgpr_30_x>
ffc08fa4 <aio_write>:
* 0 - otherwise
*/
int
aio_write (struct aiocb *aiocbp)
{
ffc08fa4: 94 21 ff f0 stwu r1,-16(r1)
ffc08fa8: 7c 08 02 a6 mflr r0
rtems_aio_request *req;
int mode;
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
ffc08fac: 38 80 00 03 li r4,3
* 0 - otherwise
*/
int
aio_write (struct aiocb *aiocbp)
{
ffc08fb0: 90 01 00 14 stw r0,20(r1)
ffc08fb4: bf c1 00 08 stmw r30,8(r1)
ffc08fb8: 7c 7f 1b 78 mr r31,r3
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);
ffc08fbc: 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);
ffc08fc0: 80 63 00 00 lwz r3,0(r3)
ffc08fc4: 4c c6 31 82 crclr 4*cr1+eq
ffc08fc8: 48 00 6a dd bl ffc0faa4 <fcntl>
if (!(((mode & O_ACCMODE) == O_WRONLY) || ((mode & O_ACCMODE) == O_RDWR)))
ffc08fcc: 54 63 07 be clrlwi r3,r3,30
ffc08fd0: 38 63 ff ff addi r3,r3,-1
ffc08fd4: 2b 83 00 01 cmplwi cr7,r3,1
ffc08fd8: 41 9d 00 14 bgt- cr7,ffc08fec <aio_write+0x48>
rtems_aio_set_errno_return_minus_one (EBADF, aiocbp);
if (aiocbp->aio_reqprio < 0 || aiocbp->aio_reqprio > AIO_PRIO_DELTA_MAX)
ffc08fdc: 80 1f 00 18 lwz r0,24(r31)
ffc08fe0: 2f 80 00 00 cmpwi cr7,r0,0
ffc08fe4: 41 be 00 24 beq+ cr7,ffc09008 <aio_write+0x64>
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
ffc08fe8: 3b c0 00 16 li r30,22
ffc08fec: 38 00 ff ff li r0,-1
ffc08ff0: 93 df 00 34 stw r30,52(r31)
ffc08ff4: 90 1f 00 38 stw r0,56(r31)
ffc08ff8: 48 00 a3 45 bl ffc1333c <__errno>
ffc08ffc: 93 c3 00 00 stw r30,0(r3)
ffc09000: 38 60 ff ff li r3,-1
ffc09004: 48 00 00 34 b ffc09038 <aio_write+0x94>
if (aiocbp->aio_offset < 0)
ffc09008: 80 1f 00 08 lwz r0,8(r31)
ffc0900c: 2f 80 00 00 cmpwi cr7,r0,0
ffc09010: 41 bc ff d8 blt- cr7,ffc08fe8 <aio_write+0x44>
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
req = malloc (sizeof (rtems_aio_request));
ffc09014: 38 60 00 18 li r3,24
ffc09018: 4b ff c7 5d bl ffc05774 <malloc>
if (req == NULL)
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
ffc0901c: 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)
ffc09020: 7c 69 1b 79 mr. r9,r3
ffc09024: 41 a2 ff c8 beq- ffc08fec <aio_write+0x48> <== NEVER TAKEN
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
req->aiocbp = aiocbp;
req->aiocbp->aio_lio_opcode = LIO_WRITE;
ffc09028: 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;
ffc0902c: 93 e9 00 14 stw r31,20(r9)
req->aiocbp->aio_lio_opcode = LIO_WRITE;
ffc09030: 90 1f 00 30 stw r0,48(r31)
return rtems_aio_enqueue (req);
ffc09034: 4b ff fc c1 bl ffc08cf4 <rtems_aio_enqueue>
}
ffc09038: 39 61 00 10 addi r11,r1,16
ffc0903c: 4b ff 7a c8 b ffc00b04 <_restgpr_30_x>
ffc06898 <chroot>:
#include <rtems/seterr.h>
int chroot(
const char *pathname
)
{
ffc06898: 94 21 ff c8 stwu r1,-56(r1)
ffc0689c: 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) {
ffc068a0: 3d 20 00 00 lis r9,0
#include <rtems/seterr.h>
int chroot(
const char *pathname
)
{
ffc068a4: bf a1 00 2c stmw r29,44(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) {
ffc068a8: 3f c0 00 00 lis r30,0
#include <rtems/seterr.h>
int chroot(
const char *pathname
)
{
ffc068ac: 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) {
ffc068b0: 83 fe 27 5c lwz r31,10076(r30)
#include <rtems/seterr.h>
int chroot(
const char *pathname
)
{
ffc068b4: 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) {
ffc068b8: 38 09 2b 70 addi r0,r9,11120
ffc068bc: 7f 9f 00 00 cmpw cr7,r31,r0
ffc068c0: 40 be 00 24 bne+ cr7,ffc068e4 <chroot+0x4c>
rtems_libio_set_private_env(); /* try to set a new private env*/
ffc068c4: 48 00 17 01 bl ffc07fc4 <rtems_libio_set_private_env>
if (rtems_current_user_env == &rtems_global_user_env) /* not ok */
ffc068c8: 80 1e 27 5c lwz r0,10076(r30)
ffc068cc: 7f 80 f8 00 cmpw cr7,r0,r31
ffc068d0: 40 be 00 14 bne+ cr7,ffc068e4 <chroot+0x4c>
rtems_set_errno_and_return_minus_one( ENOTSUP );
ffc068d4: 48 00 cd 41 bl ffc13614 <__errno>
ffc068d8: 38 00 00 86 li r0,134
ffc068dc: 90 03 00 00 stw r0,0(r3)
ffc068e0: 48 00 00 28 b ffc06908 <chroot+0x70>
}
result = chdir(pathname);
ffc068e4: 7f a3 eb 78 mr r3,r29
ffc068e8: 4b ff fe f5 bl ffc067dc <chdir>
if (result) {
ffc068ec: 2f 83 00 00 cmpwi cr7,r3,0
ffc068f0: 41 be 00 20 beq+ cr7,ffc06910 <chroot+0x78>
rtems_set_errno_and_return_minus_one( errno );
ffc068f4: 48 00 cd 21 bl ffc13614 <__errno>
ffc068f8: 7c 7f 1b 78 mr r31,r3
ffc068fc: 48 00 cd 19 bl ffc13614 <__errno>
ffc06900: 80 03 00 00 lwz r0,0(r3)
ffc06904: 90 1f 00 00 stw r0,0(r31)
ffc06908: 38 60 ff ff li r3,-1
ffc0690c: 48 00 00 50 b ffc0695c <chroot+0xc4>
}
/* clone the new root location */
if (rtems_filesystem_evaluate_path(".", 1, 0, &loc, 0)) {
ffc06910: 3c 60 ff c2 lis r3,-62
ffc06914: 3b e1 00 08 addi r31,r1,8
ffc06918: 38 63 30 00 addi r3,r3,12288
ffc0691c: 38 80 00 01 li r4,1
ffc06920: 38 a0 00 00 li r5,0
ffc06924: 7f e6 fb 78 mr r6,r31
ffc06928: 38 e0 00 00 li r7,0
ffc0692c: 48 00 01 49 bl ffc06a74 <rtems_filesystem_evaluate_path>
ffc06930: 2f 83 00 00 cmpwi cr7,r3,0
ffc06934: 40 be ff c0 bne- cr7,ffc068f4 <chroot+0x5c> <== NEVER TAKEN
/* our cwd has changed, though - but there is no easy way of return :-( */
rtems_set_errno_and_return_minus_one( errno );
}
rtems_filesystem_freenode(&rtems_filesystem_root);
ffc06938: 3f c0 00 00 lis r30,0
ffc0693c: 80 7e 27 5c lwz r3,10076(r30)
ffc06940: 38 63 00 18 addi r3,r3,24
ffc06944: 48 00 03 21 bl ffc06c64 <rtems_filesystem_freenode>
rtems_filesystem_root = loc;
ffc06948: 81 7e 27 5c lwz r11,10076(r30)
return 0;
ffc0694c: 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;
ffc06950: 39 6b 00 18 addi r11,r11,24
ffc06954: 7c bf a4 aa lswi r5,r31,20
ffc06958: 7c ab a5 aa stswi r5,r11,20
return 0;
}
ffc0695c: 39 61 00 38 addi r11,r1,56
ffc06960: 4b ff bf 18 b ffc02878 <_restgpr_29_x>
ffc079e8 <clock_gettime>:
int clock_gettime(
clockid_t clock_id,
struct timespec *tp
)
{
ffc079e8: 7c 08 02 a6 mflr r0
ffc079ec: 94 21 ff f8 stwu r1,-8(r1)
ffc079f0: 90 01 00 0c stw r0,12(r1)
ffc079f4: 7c 60 1b 78 mr r0,r3
if ( !tp )
ffc079f8: 7c 83 23 79 mr. r3,r4
ffc079fc: 41 82 00 44 beq- ffc07a40 <clock_gettime+0x58>
rtems_set_errno_and_return_minus_one( EINVAL );
if ( clock_id == CLOCK_REALTIME ) {
ffc07a00: 2f 80 00 01 cmpwi cr7,r0,1
ffc07a04: 40 be 00 0c bne+ cr7,ffc07a10 <clock_gettime+0x28>
_TOD_Get(tp);
ffc07a08: 48 00 21 b1 bl ffc09bb8 <_TOD_Get>
ffc07a0c: 48 00 00 18 b ffc07a24 <clock_gettime+0x3c>
return 0;
}
#ifdef CLOCK_MONOTONIC
if ( clock_id == CLOCK_MONOTONIC ) {
ffc07a10: 2f 80 00 04 cmpwi cr7,r0,4
ffc07a14: 41 9e 00 0c beq- cr7,ffc07a20 <clock_gettime+0x38> <== NEVER TAKEN
return 0;
}
#endif
#ifdef _POSIX_CPUTIME
if ( clock_id == CLOCK_PROCESS_CPUTIME_ID ) {
ffc07a18: 2f 80 00 02 cmpwi cr7,r0,2
ffc07a1c: 40 be 00 10 bne+ cr7,ffc07a2c <clock_gettime+0x44>
_TOD_Get_uptime_as_timespec( tp );
ffc07a20: 48 00 22 19 bl ffc09c38 <_TOD_Get_uptime_as_timespec>
return 0;
ffc07a24: 38 60 00 00 li r3,0
ffc07a28: 48 00 00 28 b ffc07a50 <clock_gettime+0x68>
}
#endif
#ifdef _POSIX_THREAD_CPUTIME
if ( clock_id == CLOCK_THREAD_CPUTIME_ID )
ffc07a2c: 2f 80 00 03 cmpwi cr7,r0,3
ffc07a30: 40 be 00 10 bne+ cr7,ffc07a40 <clock_gettime+0x58>
rtems_set_errno_and_return_minus_one( ENOSYS );
ffc07a34: 48 00 9d c1 bl ffc117f4 <__errno>
ffc07a38: 38 00 00 58 li r0,88
ffc07a3c: 48 00 00 0c b ffc07a48 <clock_gettime+0x60>
#endif
rtems_set_errno_and_return_minus_one( EINVAL );
ffc07a40: 48 00 9d b5 bl ffc117f4 <__errno>
ffc07a44: 38 00 00 16 li r0,22
ffc07a48: 90 03 00 00 stw r0,0(r3)
ffc07a4c: 38 60 ff ff li r3,-1
return 0;
}
ffc07a50: 80 01 00 0c lwz r0,12(r1)
ffc07a54: 38 21 00 08 addi r1,r1,8
ffc07a58: 7c 08 03 a6 mtlr r0
ffc07a5c: 4e 80 00 20 blr
ffc07a60 <clock_settime>:
int clock_settime(
clockid_t clock_id,
const struct timespec *tp
)
{
ffc07a60: 7c 08 02 a6 mflr r0
ffc07a64: 94 21 ff f8 stwu r1,-8(r1)
ffc07a68: 90 01 00 0c stw r0,12(r1)
ffc07a6c: 7c 60 1b 78 mr r0,r3
if ( !tp )
ffc07a70: 7c 83 23 79 mr. r3,r4
ffc07a74: 41 82 00 60 beq- ffc07ad4 <clock_settime+0x74> <== NEVER TAKEN
rtems_set_errno_and_return_minus_one( EINVAL );
if ( clock_id == CLOCK_REALTIME ) {
ffc07a78: 2f 80 00 01 cmpwi cr7,r0,1
ffc07a7c: 40 be 00 3c bne+ cr7,ffc07ab8 <clock_settime+0x58>
if ( tp->tv_sec < TOD_SECONDS_1970_THROUGH_1988 )
ffc07a80: 81 23 00 00 lwz r9,0(r3)
ffc07a84: 3c 00 21 da lis r0,8666
ffc07a88: 60 00 e4 ff ori r0,r0,58623
ffc07a8c: 7f 89 00 40 cmplw cr7,r9,r0
ffc07a90: 40 9d 00 44 ble- cr7,ffc07ad4 <clock_settime+0x74>
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
_Thread_Dispatch_disable_level++;
ffc07a94: 3d 20 00 00 lis r9,0
ffc07a98: 81 69 28 78 lwz r11,10360(r9)
ffc07a9c: 38 0b 00 01 addi r0,r11,1
ffc07aa0: 90 09 28 78 stw r0,10360(r9)
return _Thread_Dispatch_disable_level;
ffc07aa4: 80 09 28 78 lwz r0,10360(r9)
rtems_set_errno_and_return_minus_one( EINVAL );
_Thread_Disable_dispatch();
_TOD_Set( tp );
ffc07aa8: 48 00 22 01 bl ffc09ca8 <_TOD_Set>
_Thread_Enable_dispatch();
ffc07aac: 48 00 3b 45 bl ffc0b5f0 <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one( ENOSYS );
#endif
else
rtems_set_errno_and_return_minus_one( EINVAL );
return 0;
ffc07ab0: 38 60 00 00 li r3,0
ffc07ab4: 48 00 00 30 b ffc07ae4 <clock_settime+0x84>
_Thread_Disable_dispatch();
_TOD_Set( tp );
_Thread_Enable_dispatch();
}
#ifdef _POSIX_CPUTIME
else if ( clock_id == CLOCK_PROCESS_CPUTIME_ID )
ffc07ab8: 2f 80 00 02 cmpwi cr7,r0,2
ffc07abc: 41 9e 00 0c beq- cr7,ffc07ac8 <clock_settime+0x68>
rtems_set_errno_and_return_minus_one( ENOSYS );
#endif
#ifdef _POSIX_THREAD_CPUTIME
else if ( clock_id == CLOCK_THREAD_CPUTIME_ID )
ffc07ac0: 2f 80 00 03 cmpwi cr7,r0,3
ffc07ac4: 40 be 00 10 bne+ cr7,ffc07ad4 <clock_settime+0x74>
rtems_set_errno_and_return_minus_one( ENOSYS );
ffc07ac8: 48 00 9d 2d bl ffc117f4 <__errno>
ffc07acc: 38 00 00 58 li r0,88
ffc07ad0: 48 00 00 0c b ffc07adc <clock_settime+0x7c>
#endif
else
rtems_set_errno_and_return_minus_one( EINVAL );
ffc07ad4: 48 00 9d 21 bl ffc117f4 <__errno>
ffc07ad8: 38 00 00 16 li r0,22
ffc07adc: 90 03 00 00 stw r0,0(r3)
ffc07ae0: 38 60 ff ff li r3,-1
return 0;
}
ffc07ae4: 80 01 00 0c lwz r0,12(r1)
ffc07ae8: 38 21 00 08 addi r1,r1,8
ffc07aec: 7c 08 03 a6 mtlr r0
ffc07af0: 4e 80 00 20 blr
ffc03fe4 <create_disk>:
return disktab [major].minor + minor;
}
static rtems_status_code
create_disk(dev_t dev, const char *name, rtems_disk_device **dd_ptr)
{
ffc03fe4: 94 21 ff c8 stwu r1,-56(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) {
ffc03fe8: 3d 20 00 00 lis r9,0
return disktab [major].minor + minor;
}
static rtems_status_code
create_disk(dev_t dev, const char *name, rtems_disk_device **dd_ptr)
{
ffc03fec: 7c 08 02 a6 mflr r0
rtems_device_major_number major = 0;
rtems_device_minor_number minor = 0;
rtems_filesystem_split_dev_t(dev, major, minor);
if (major >= disktab_size) {
ffc03ff0: 39 69 28 e8 addi r11,r9,10472
return disktab [major].minor + minor;
}
static rtems_status_code
create_disk(dev_t dev, const char *name, rtems_disk_device **dd_ptr)
{
ffc03ff4: be a1 00 0c stmw r21,12(r1)
ffc03ff8: 7c 7d 1b 78 mr r29,r3
ffc03ffc: 7c 9e 23 78 mr r30,r4
rtems_device_major_number major = 0;
rtems_device_minor_number minor = 0;
rtems_filesystem_split_dev_t(dev, major, minor);
if (major >= disktab_size) {
ffc04000: 83 49 28 e8 lwz r26,10472(r9)
return disktab [major].minor + minor;
}
static rtems_status_code
create_disk(dev_t dev, const char *name, rtems_disk_device **dd_ptr)
{
ffc04004: 7c bc 2b 78 mr r28,r5
ffc04008: 90 01 00 3c stw r0,60(r1)
ffc0400c: 7c d8 33 78 mr r24,r6
rtems_device_major_number major = 0;
rtems_device_minor_number minor = 0;
rtems_filesystem_split_dev_t(dev, major, minor);
if (major >= disktab_size) {
ffc04010: 7f 83 d0 40 cmplw cr7,r3,r26
ffc04014: 41 9c 00 54 blt- cr7,ffc04068 <create_disk+0x84>
rtems_disk_device_table *table = disktab;
rtems_device_major_number old_size = disktab_size;
rtems_device_major_number new_size = 2 * old_size;
ffc04018: 57 5f 08 3c rlwinm r31,r26,1,0,30
rtems_device_minor_number minor = 0;
rtems_filesystem_split_dev_t(dev, major, minor);
if (major >= disktab_size) {
rtems_disk_device_table *table = disktab;
ffc0401c: 80 6b 00 04 lwz r3,4(r11)
rtems_device_major_number old_size = disktab_size;
rtems_device_major_number new_size = 2 * old_size;
if (major >= new_size) {
ffc04020: 7f 9d f8 40 cmplw cr7,r29,r31
ffc04024: 41 9c 00 08 blt- cr7,ffc0402c <create_disk+0x48> <== NEVER TAKEN
new_size = major + 1;
ffc04028: 3b fd 00 01 addi r31,r29,1
}
table = realloc(table, new_size * sizeof(*table));
ffc0402c: 57 e4 18 38 rlwinm r4,r31,3,0,28
ffc04030: 48 00 21 69 bl ffc06198 <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;
ffc04034: 3a a0 00 1a li r21,26
if (major >= new_size) {
new_size = major + 1;
}
table = realloc(table, new_size * sizeof(*table));
if (table == NULL) {
ffc04038: 7c 7b 1b 79 mr. r27,r3
ffc0403c: 41 82 01 4c beq- ffc04188 <create_disk+0x1a4> <== ALWAYS TAKEN
return NULL;
}
memset(table + old_size, 0, (new_size - old_size) * sizeof(*table));
ffc04040: 7c ba f8 50 subf r5,r26,r31 <== NOT EXECUTED
ffc04044: 57 43 18 38 rlwinm r3,r26,3,0,28 <== NOT EXECUTED
ffc04048: 7c 7b 1a 14 add r3,r27,r3 <== NOT EXECUTED
ffc0404c: 38 80 00 00 li r4,0 <== NOT EXECUTED
ffc04050: 54 a5 18 38 rlwinm r5,r5,3,0,28 <== NOT EXECUTED
ffc04054: 48 01 12 f9 bl ffc1534c <memset> <== NOT EXECUTED
disktab = table;
ffc04058: 3d 20 00 00 lis r9,0 <== NOT EXECUTED
ffc0405c: 39 69 28 e8 addi r11,r9,10472 <== NOT EXECUTED
disktab_size = new_size;
ffc04060: 93 e9 28 e8 stw r31,10472(r9) <== NOT EXECUTED
if (table == NULL) {
return NULL;
}
memset(table + old_size, 0, (new_size - old_size) * sizeof(*table));
disktab = table;
ffc04064: 93 6b 00 04 stw r27,4(r11) <== NOT EXECUTED
disktab_size = new_size;
}
if (disktab [major].minor == NULL || minor >= disktab[major].size) {
ffc04068: 3d 20 00 00 lis r9,0
ffc0406c: 83 29 28 ec lwz r25,10476(r9)
ffc04070: 57 ba 18 38 rlwinm r26,r29,3,0,28
ffc04074: 7c 79 d0 2e lwzx r3,r25,r26
ffc04078: 7f 79 d2 14 add r27,r25,r26
ffc0407c: 82 db 00 04 lwz r22,4(r27)
ffc04080: 2f 83 00 00 cmpwi cr7,r3,0
ffc04084: 41 9e 00 0c beq- cr7,ffc04090 <create_disk+0xac>
ffc04088: 7f 9e b0 40 cmplw cr7,r30,r22
ffc0408c: 41 9c 00 54 blt- cr7,ffc040e0 <create_disk+0xfc> <== ALWAYS TAKEN
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) {
ffc04090: 2f 96 00 00 cmpwi cr7,r22,0
new_size = DISKTAB_INITIAL_SIZE;
ffc04094: 3b e0 00 08 li r31,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) {
ffc04098: 41 9e 00 08 beq- cr7,ffc040a0 <create_disk+0xbc> <== ALWAYS TAKEN
new_size = DISKTAB_INITIAL_SIZE;
} else {
new_size = 2 * old_size;
ffc0409c: 56 df 08 3c rlwinm r31,r22,1,0,30 <== NOT EXECUTED
}
if (minor >= new_size) {
ffc040a0: 7f 9e f8 40 cmplw cr7,r30,r31
ffc040a4: 41 9c 00 08 blt- cr7,ffc040ac <create_disk+0xc8>
new_size = minor + 1;
ffc040a8: 3b fe 00 01 addi r31,r30,1
}
table = realloc(table, new_size * sizeof(*table));
ffc040ac: 57 e4 10 3a rlwinm r4,r31,2,0,29
ffc040b0: 48 00 20 e9 bl ffc06198 <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;
ffc040b4: 3a a0 00 1a li r21,26
if (minor >= new_size) {
new_size = minor + 1;
}
table = realloc(table, new_size * sizeof(*table));
if (table == NULL) {
ffc040b8: 7c 77 1b 79 mr. r23,r3
ffc040bc: 41 82 00 cc beq- ffc04188 <create_disk+0x1a4>
return NULL;
}
memset(table + old_size, 0, (new_size - old_size) * sizeof(*table));
ffc040c0: 7c b6 f8 50 subf r5,r22,r31
ffc040c4: 56 c3 10 3a rlwinm r3,r22,2,0,29
ffc040c8: 7c 77 1a 14 add r3,r23,r3
ffc040cc: 38 80 00 00 li r4,0
ffc040d0: 54 a5 10 3a rlwinm r5,r5,2,0,29
ffc040d4: 48 01 12 79 bl ffc1534c <memset>
disktab [major].minor = table;
ffc040d8: 7e f9 d1 2e stwx r23,r25,r26
disktab [major].size = new_size;
ffc040dc: 93 fb 00 04 stw r31,4(r27)
}
return disktab [major].minor + minor;
ffc040e0: 7f 59 d0 2e lwzx r26,r25,r26
ffc040e4: 57 db 10 3a rlwinm r27,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) {
return RTEMS_NO_MEMORY;
ffc040e8: 3a a0 00 1a li r21,26
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;
ffc040ec: 7c 1a da 14 add r0,r26,r27
{
rtems_disk_device **dd_entry = create_disk_table_entry(dev);
rtems_disk_device *dd = NULL;
char *alloc_name = NULL;
if (dd_entry == NULL) {
ffc040f0: 2f 80 00 00 cmpwi cr7,r0,0
ffc040f4: 41 9e 00 94 beq- cr7,ffc04188 <create_disk+0x1a4> <== NEVER TAKEN
return RTEMS_NO_MEMORY;
}
if (*dd_entry != NULL) {
ffc040f8: 7c 1a d8 2e lwzx r0,r26,r27
return RTEMS_RESOURCE_IN_USE;
ffc040fc: 3a a0 00 0c li r21,12
if (dd_entry == NULL) {
return RTEMS_NO_MEMORY;
}
if (*dd_entry != NULL) {
ffc04100: 2f 80 00 00 cmpwi cr7,r0,0
ffc04104: 40 be 00 84 bne+ cr7,ffc04188 <create_disk+0x1a4>
return RTEMS_RESOURCE_IN_USE;
}
dd = malloc(sizeof(*dd));
ffc04108: 38 60 00 38 li r3,56
ffc0410c: 48 00 15 0d bl ffc05618 <malloc>
if (dd == NULL) {
return RTEMS_NO_MEMORY;
ffc04110: 3a a0 00 1a li r21,26
if (*dd_entry != NULL) {
return RTEMS_RESOURCE_IN_USE;
}
dd = malloc(sizeof(*dd));
if (dd == NULL) {
ffc04114: 7c 7f 1b 79 mr. r31,r3
ffc04118: 41 82 00 70 beq- ffc04188 <create_disk+0x1a4> <== NEVER TAKEN
return RTEMS_NO_MEMORY;
}
if (name != NULL) {
ffc0411c: 2f 9c 00 00 cmpwi cr7,r28,0
ffc04120: 41 9e 00 40 beq- cr7,ffc04160 <create_disk+0x17c>
alloc_name = strdup(name);
ffc04124: 7f 83 e3 78 mr r3,r28
ffc04128: 48 01 15 f9 bl ffc15720 <strdup>
if (alloc_name == NULL) {
ffc0412c: 2f 83 00 00 cmpwi cr7,r3,0
if (dd == NULL) {
return RTEMS_NO_MEMORY;
}
if (name != NULL) {
alloc_name = strdup(name);
ffc04130: 7c 7c 1b 78 mr r28,r3
ffc04134: 7c 79 1b 78 mr r25,r3
if (alloc_name == NULL) {
ffc04138: 40 be 00 5c bne+ cr7,ffc04194 <create_disk+0x1b0> <== ALWAYS TAKEN
free(dd);
ffc0413c: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc04140: 48 00 11 31 bl ffc05270 <free> <== NOT EXECUTED
return RTEMS_NO_MEMORY;
ffc04144: 48 00 00 44 b ffc04188 <create_disk+0x1a4> <== NOT EXECUTED
}
}
if (name != NULL) {
if (mknod(alloc_name, 0777 | S_IFBLK, dev) < 0) {
free(alloc_name);
ffc04148: 7f 83 e3 78 mr r3,r28 <== NOT EXECUTED
ffc0414c: 48 00 11 25 bl ffc05270 <free> <== NOT EXECUTED
free(dd);
ffc04150: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc04154: 48 00 11 1d bl ffc05270 <free> <== NOT EXECUTED
return RTEMS_UNSATISFIED;
ffc04158: 3a a0 00 0d li r21,13 <== NOT EXECUTED
ffc0415c: 48 00 00 2c b ffc04188 <create_disk+0x1a4> <== NOT EXECUTED
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;
ffc04160: 3b 20 00 00 li r25,0
}
}
dd->dev = dev;
dd->name = alloc_name;
dd->uses = 0;
ffc04164: 38 00 00 00 li r0,0
free(dd);
return RTEMS_UNSATISFIED;
}
}
dd->dev = dev;
ffc04168: 93 bf 00 00 stw r29,0(r31)
dd->deleted = false;
*dd_entry = dd;
*dd_ptr = dd;
return RTEMS_SUCCESSFUL;
ffc0416c: 3a a0 00 00 li r21,0
free(dd);
return RTEMS_UNSATISFIED;
}
}
dd->dev = dev;
ffc04170: 93 df 00 04 stw r30,4(r31)
dd->name = alloc_name;
ffc04174: 93 3f 00 10 stw r25,16(r31)
dd->uses = 0;
ffc04178: 90 1f 00 14 stw r0,20(r31)
dd->deleted = false;
ffc0417c: 98 1f 00 30 stb r0,48(r31)
*dd_entry = dd;
ffc04180: 7f fa d9 2e stwx r31,r26,r27
*dd_ptr = dd;
ffc04184: 93 f8 00 00 stw r31,0(r24)
return RTEMS_SUCCESSFUL;
}
ffc04188: 39 61 00 38 addi r11,r1,56
ffc0418c: 7e a3 ab 78 mr r3,r21
ffc04190: 48 01 53 60 b ffc194f0 <_restgpr_21_x>
return RTEMS_NO_MEMORY;
}
}
if (name != NULL) {
if (mknod(alloc_name, 0777 | S_IFBLK, dev) < 0) {
ffc04194: 38 80 61 ff li r4,25087
ffc04198: 7f a5 eb 78 mr r5,r29
ffc0419c: 7f c6 f3 78 mr r6,r30
ffc041a0: 48 00 15 a1 bl ffc05740 <mknod>
ffc041a4: 2f 83 00 00 cmpwi cr7,r3,0
ffc041a8: 40 9c ff bc bge+ cr7,ffc04164 <create_disk+0x180> <== ALWAYS TAKEN
ffc041ac: 4b ff ff 9c b ffc04148 <create_disk+0x164> <== NOT EXECUTED
ffc0c044 <devFS_evaluate_path>:
const char *pathname,
size_t pathnamelen,
int flags,
rtems_filesystem_location_info_t *pathloc
)
{
ffc0c044: 94 21 ff d8 stwu r1,-40(r1)
ffc0c048: 7c 08 02 a6 mflr r0
ffc0c04c: 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 ) )
ffc0c050: 54 a0 00 39 rlwinm. r0,r5,0,0,28
const char *pathname,
size_t pathnamelen,
int flags,
rtems_filesystem_location_info_t *pathloc
)
{
ffc0c054: bf 21 00 0c stmw r25,12(r1)
ffc0c058: 7c 7e 1b 78 mr r30,r3
ffc0c05c: 7c 9f 23 78 mr r31,r4
ffc0c060: 7c dd 33 78 mr r29,r6
int i;
rtems_device_name_t *device_name_table;
/* see if 'flags' is valid */
if ( !rtems_libio_is_valid_perms( flags ) )
ffc0c064: 41 a2 00 10 beq+ ffc0c074 <devFS_evaluate_path+0x30> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( EPERM );
ffc0c068: 48 00 29 3d bl ffc0e9a4 <__errno> <== NOT EXECUTED
ffc0c06c: 38 00 00 01 li r0,1 <== NOT EXECUTED
ffc0c070: 48 00 00 a0 b ffc0c110 <devFS_evaluate_path+0xcc> <== NOT EXECUTED
/* get the device name table */
device_name_table = (rtems_device_name_t *)pathloc->node_access;
ffc0c074: 83 86 00 00 lwz r28,0(r6)
if (!device_name_table)
ffc0c078: 3b 60 00 00 li r27,0
rtems_set_errno_and_return_minus_one( EFAULT );
for (i = 0; i < rtems_device_table_size; i++) {
ffc0c07c: 3f 20 00 00 lis r25,0
if ( !rtems_libio_is_valid_perms( flags ) )
rtems_set_errno_and_return_minus_one( EPERM );
/* get the device name table */
device_name_table = (rtems_device_name_t *)pathloc->node_access;
if (!device_name_table)
ffc0c080: 2f 9c 00 00 cmpwi cr7,r28,0
ffc0c084: 40 be 00 78 bne+ cr7,ffc0c0fc <devFS_evaluate_path+0xb8>
rtems_set_errno_and_return_minus_one( EFAULT );
ffc0c088: 48 00 29 1d bl ffc0e9a4 <__errno>
ffc0c08c: 38 00 00 0e li r0,14
ffc0c090: 48 00 00 80 b ffc0c110 <devFS_evaluate_path+0xcc>
for (i = 0; i < rtems_device_table_size; i++) {
if (!device_name_table[i].device_name)
ffc0c094: 83 5c 00 00 lwz r26,0(r28)
ffc0c098: 2f 9a 00 00 cmpwi cr7,r26,0
ffc0c09c: 41 9e 00 58 beq- cr7,ffc0c0f4 <devFS_evaluate_path+0xb0>
continue;
if (strncmp(pathname, device_name_table[i].device_name, pathnamelen) != 0)
ffc0c0a0: 7f c3 f3 78 mr r3,r30
ffc0c0a4: 7f 44 d3 78 mr r4,r26
ffc0c0a8: 7f e5 fb 78 mr r5,r31
ffc0c0ac: 48 00 42 75 bl ffc10320 <strncmp>
ffc0c0b0: 2f 83 00 00 cmpwi cr7,r3,0
ffc0c0b4: 40 9e 00 40 bne- cr7,ffc0c0f4 <devFS_evaluate_path+0xb0>
continue;
if (device_name_table[i].device_name[pathnamelen] != '\0')
ffc0c0b8: 7c 1a f8 ae lbzx r0,r26,r31
ffc0c0bc: 2f 80 00 00 cmpwi cr7,r0,0
ffc0c0c0: 40 be 00 34 bne+ cr7,ffc0c0f4 <devFS_evaluate_path+0xb0><== NEVER TAKEN
continue;
/* find the device, set proper values */
pathloc->node_access = (void *)&device_name_table[i];
pathloc->handlers = &devFS_file_handlers;
ffc0c0c4: 3d 20 00 00 lis r9,0
if (device_name_table[i].device_name[pathnamelen] != '\0')
continue;
/* find the device, set proper values */
pathloc->node_access = (void *)&device_name_table[i];
ffc0c0c8: 93 9d 00 00 stw r28,0(r29)
pathloc->handlers = &devFS_file_handlers;
ffc0c0cc: 38 09 21 84 addi r0,r9,8580
pathloc->ops = &devFS_ops;
ffc0c0d0: 3d 20 00 00 lis r9,0
if (device_name_table[i].device_name[pathnamelen] != '\0')
continue;
/* find the device, set proper values */
pathloc->node_access = (void *)&device_name_table[i];
pathloc->handlers = &devFS_file_handlers;
ffc0c0d4: 90 1d 00 08 stw r0,8(r29)
pathloc->ops = &devFS_ops;
ffc0c0d8: 38 09 21 bc addi r0,r9,8636
pathloc->mt_entry = rtems_filesystem_root.mt_entry;
ffc0c0dc: 3d 20 00 00 lis r9,0
continue;
/* find the device, set proper values */
pathloc->node_access = (void *)&device_name_table[i];
pathloc->handlers = &devFS_file_handlers;
pathloc->ops = &devFS_ops;
ffc0c0e0: 90 1d 00 0c stw r0,12(r29)
pathloc->mt_entry = rtems_filesystem_root.mt_entry;
ffc0c0e4: 81 29 27 b4 lwz r9,10164(r9)
ffc0c0e8: 80 09 00 28 lwz r0,40(r9)
ffc0c0ec: 90 1d 00 10 stw r0,16(r29)
return 0;
ffc0c0f0: 48 00 00 28 b ffc0c118 <devFS_evaluate_path+0xd4>
/* 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++) {
ffc0c0f4: 3b 7b 00 01 addi r27,r27,1
ffc0c0f8: 3b 9c 00 14 addi r28,r28,20
ffc0c0fc: 80 19 27 78 lwz r0,10104(r25)
ffc0c100: 7f 9b 00 40 cmplw cr7,r27,r0
ffc0c104: 41 9c ff 90 blt+ cr7,ffc0c094 <devFS_evaluate_path+0x50>
pathloc->mt_entry = rtems_filesystem_root.mt_entry;
return 0;
}
/* no such file or directory */
rtems_set_errno_and_return_minus_one( ENOENT );
ffc0c108: 48 00 28 9d bl ffc0e9a4 <__errno>
ffc0c10c: 38 00 00 02 li r0,2
ffc0c110: 90 03 00 00 stw r0,0(r3)
ffc0c114: 38 60 ff ff li r3,-1
}
ffc0c118: 39 61 00 28 addi r11,r1,40
ffc0c11c: 48 00 c0 8c b ffc181a8 <_restgpr_25_x>
ffc043f0 <devFS_mknod>:
const char *path,
mode_t mode,
dev_t dev,
rtems_filesystem_location_info_t *pathloc
)
{
ffc043f0: 94 21 ff d8 stwu r1,-40(r1)
ffc043f4: 7c 08 02 a6 mflr r0
ffc043f8: bf 01 00 08 stmw r24,8(r1)
ffc043fc: 7c 7f 1b 78 mr r31,r3
ffc04400: 7c 9e 23 78 mr r30,r4
ffc04404: 90 01 00 2c stw r0,44(r1)
ffc04408: 7c bd 2b 78 mr r29,r5
ffc0440c: 7c dc 33 78 mr r28,r6
* 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') &&
ffc04410: 88 03 00 00 lbz r0,0(r3)
ffc04414: 2f 80 00 64 cmpwi cr7,r0,100
ffc04418: 40 be 00 2c bne+ cr7,ffc04444 <devFS_mknod+0x54>
ffc0441c: 88 03 00 01 lbz r0,1(r3)
ffc04420: 2f 80 00 65 cmpwi cr7,r0,101
ffc04424: 40 be 00 20 bne+ cr7,ffc04444 <devFS_mknod+0x54> <== NEVER TAKEN
ffc04428: 88 03 00 02 lbz r0,2(r3)
ffc0442c: 2f 80 00 76 cmpwi cr7,r0,118
ffc04430: 40 be 00 14 bne+ cr7,ffc04444 <devFS_mknod+0x54> <== NEVER TAKEN
(path[2] == 'v') && (path[3] == '\0'))
ffc04434: 88 03 00 03 lbz r0,3(r3)
return 0;
ffc04438: 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'))
ffc0443c: 2f 80 00 00 cmpwi cr7,r0,0
ffc04440: 41 9e 00 e0 beq- cr7,ffc04520 <devFS_mknod+0x130>
return 0;
/* must be a character device or a block device */
if (!S_ISBLK(mode) && !S_ISCHR(mode))
ffc04444: 57 c0 04 26 rlwinm r0,r30,0,16,19
ffc04448: 2f 80 60 00 cmpwi cr7,r0,24576
ffc0444c: 41 9e 00 18 beq- cr7,ffc04464 <devFS_mknod+0x74>
ffc04450: 2f 80 20 00 cmpwi cr7,r0,8192
ffc04454: 41 be 00 10 beq+ cr7,ffc04464 <devFS_mknod+0x74>
rtems_set_errno_and_return_minus_one( EINVAL );
ffc04458: 48 00 a5 4d bl ffc0e9a4 <__errno>
ffc0445c: 38 00 00 16 li r0,22
ffc04460: 48 00 00 24 b ffc04484 <devFS_mknod+0x94>
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;
ffc04464: 83 47 00 00 lwz r26,0(r7)
if (!device_name_table)
ffc04468: 3b 20 ff ff li r25,-1
ffc0446c: 3b 60 00 00 li r27,0
ffc04470: 2f 9a 00 00 cmpwi cr7,r26,0
rtems_set_errno_and_return_minus_one( EFAULT );
for (slot = -1, i = 0; i < rtems_device_table_size; i++){
ffc04474: 3f 00 00 00 lis r24,0
else
rtems_filesystem_split_dev_t(dev, major, minor);
/* Find an empty slot in device name table */
device_name_table = (rtems_device_name_t *)pathloc->node_access;
if (!device_name_table)
ffc04478: 40 be 00 4c bne+ cr7,ffc044c4 <devFS_mknod+0xd4>
rtems_set_errno_and_return_minus_one( EFAULT );
ffc0447c: 48 00 a5 29 bl ffc0e9a4 <__errno>
ffc04480: 38 00 00 0e li r0,14
ffc04484: 90 03 00 00 stw r0,0(r3)
ffc04488: 38 60 ff ff li r3,-1
ffc0448c: 48 00 00 94 b ffc04520 <devFS_mknod+0x130>
#include <stdlib.h>
#include <rtems/seterr.h>
#include "devfs.h"
int devFS_mknod(
ffc04490: 1c 1b 00 14 mulli r0,r27,20
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)
ffc04494: 7c 9a 00 2e lwzx r4,r26,r0
ffc04498: 2f 84 00 00 cmpwi cr7,r4,0
ffc0449c: 41 9e 00 20 beq- cr7,ffc044bc <devFS_mknod+0xcc>
slot = i;
else
if (strcmp(path, device_name_table[i].device_name) == 0)
ffc044a0: 7f e3 fb 78 mr r3,r31
ffc044a4: 48 00 bc f9 bl ffc1019c <strcmp>
ffc044a8: 2f 83 00 00 cmpwi cr7,r3,0
ffc044ac: 40 be 00 14 bne+ cr7,ffc044c0 <devFS_mknod+0xd0>
rtems_set_errno_and_return_minus_one( EEXIST );
ffc044b0: 48 00 a4 f5 bl ffc0e9a4 <__errno>
ffc044b4: 38 00 00 11 li r0,17
ffc044b8: 4b ff ff cc b ffc04484 <devFS_mknod+0x94>
if (!device_name_table)
rtems_set_errno_and_return_minus_one( EFAULT );
for (slot = -1, i = 0; i < rtems_device_table_size; i++){
if (device_name_table[i].device_name == NULL)
slot = i;
ffc044bc: 7f 79 db 78 mr r25,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++){
ffc044c0: 3b 7b 00 01 addi r27,r27,1
ffc044c4: 80 18 27 78 lwz r0,10104(r24)
ffc044c8: 7f 9b 00 40 cmplw cr7,r27,r0
ffc044cc: 41 9c ff c4 blt+ cr7,ffc04490 <devFS_mknod+0xa0>
else
if (strcmp(path, device_name_table[i].device_name) == 0)
rtems_set_errno_and_return_minus_one( EEXIST );
}
if (slot == -1)
ffc044d0: 2f 99 ff ff cmpwi cr7,r25,-1
ffc044d4: 40 be 00 10 bne+ cr7,ffc044e4 <devFS_mknod+0xf4>
rtems_set_errno_and_return_minus_one( ENOMEM );
ffc044d8: 48 00 a4 cd bl ffc0e9a4 <__errno>
ffc044dc: 38 00 00 0c li r0,12
ffc044e0: 4b ff ff a4 b ffc04484 <devFS_mknod+0x94>
static inline uint32_t ppc_interrupt_disable( void )
{
uint32_t level;
uint32_t mask;
__asm__ volatile (
ffc044e4: 7f 00 00 a6 mfmsr r24
ffc044e8: 7c 10 42 a6 mfsprg r0,0
ffc044ec: 7f 00 00 78 andc r0,r24,r0
ffc044f0: 7c 00 01 24 mtmsr r0
_ISR_Disable(level);
device_name_table[slot].device_name = (char *)path;
ffc044f4: 1f 39 00 14 mulli r25,r25,20
ffc044f8: 7f fa c9 2e stwx r31,r26,r25
device_name_table[slot].device_name_length = strlen(path);
ffc044fc: 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;
ffc04500: 7f 7a ca 14 add r27,r26,r25
device_name_table[slot].device_name_length = strlen(path);
ffc04504: 48 00 bd 61 bl ffc10264 <strlen>
device_name_table[slot].major = major;
ffc04508: 93 bb 00 08 stw r29,8(r27)
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);
ffc0450c: 90 7b 00 04 stw r3,4(r27)
device_name_table[slot].major = major;
device_name_table[slot].minor = minor;
ffc04510: 93 9b 00 0c stw r28,12(r27)
device_name_table[slot].mode = mode;
ffc04514: 93 db 00 10 stw r30,16(r27)
return level;
}
static inline void ppc_interrupt_enable( uint32_t level )
{
__asm__ volatile (
ffc04518: 7f 00 01 24 mtmsr r24
_ISR_Enable(level);
return 0;
ffc0451c: 38 60 00 00 li r3,0
}
ffc04520: 39 61 00 28 addi r11,r1,40
ffc04524: 48 01 3c 80 b ffc181a4 <_restgpr_24_x>
ffc03f4c <disk_lock>:
*/
static volatile bool diskdevs_protected;
static rtems_status_code
disk_lock(void)
{
ffc03f4c: 7c 08 02 a6 mflr r0
ffc03f50: 7c 2b 0b 78 mr r11,r1
ffc03f54: 94 21 ff f0 stwu r1,-16(r1)
rtems_status_code sc = RTEMS_SUCCESSFUL;
sc = rtems_semaphore_obtain(diskdevs_mutex, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
ffc03f58: 38 80 00 00 li r4,0
ffc03f5c: 38 a0 00 00 li r5,0
*/
static volatile bool diskdevs_protected;
static rtems_status_code
disk_lock(void)
{
ffc03f60: 90 01 00 14 stw r0,20(r1)
ffc03f64: 48 01 55 69 bl ffc194cc <_savegpr_31>
rtems_status_code sc = RTEMS_SUCCESSFUL;
sc = rtems_semaphore_obtain(diskdevs_mutex, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
ffc03f68: 3f e0 00 00 lis r31,0
ffc03f6c: 3b ff 28 e8 addi r31,r31,10472
ffc03f70: 80 7f 00 08 lwz r3,8(r31)
ffc03f74: 48 00 4b a5 bl ffc08b18 <rtems_semaphore_obtain>
if (sc == RTEMS_SUCCESSFUL) {
diskdevs_protected = true;
return RTEMS_SUCCESSFUL;
} else {
return RTEMS_NOT_CONFIGURED;
ffc03f78: 38 00 00 16 li r0,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) {
ffc03f7c: 2f 83 00 00 cmpwi cr7,r3,0
ffc03f80: 40 be 00 10 bne+ cr7,ffc03f90 <disk_lock+0x44> <== NEVER TAKEN
diskdevs_protected = true;
ffc03f84: 38 00 00 01 li r0,1
ffc03f88: 98 1f 00 0c stb r0,12(r31)
return RTEMS_SUCCESSFUL;
ffc03f8c: 38 00 00 00 li r0,0
} else {
return RTEMS_NOT_CONFIGURED;
}
}
ffc03f90: 39 61 00 10 addi r11,r1,16
ffc03f94: 7c 03 03 78 mr r3,r0
ffc03f98: 48 01 55 80 b ffc19518 <_restgpr_31_x>
ffc03f9c <disk_unlock>:
static void
disk_unlock(void)
{
ffc03f9c: 94 21 ff f8 stwu r1,-8(r1)
ffc03fa0: 7c 08 02 a6 mflr r0
rtems_status_code sc = RTEMS_SUCCESSFUL;
diskdevs_protected = false;
ffc03fa4: 3d 20 00 00 lis r9,0
}
}
static void
disk_unlock(void)
{
ffc03fa8: 90 01 00 0c stw r0,12(r1)
rtems_status_code sc = RTEMS_SUCCESSFUL;
diskdevs_protected = false;
ffc03fac: 39 29 28 e8 addi r9,r9,10472
ffc03fb0: 38 00 00 00 li r0,0
ffc03fb4: 98 09 00 0c stb r0,12(r9)
sc = rtems_semaphore_release(diskdevs_mutex);
ffc03fb8: 80 69 00 08 lwz r3,8(r9)
ffc03fbc: 48 00 4c 89 bl ffc08c44 <rtems_semaphore_release>
if (sc != RTEMS_SUCCESSFUL) {
ffc03fc0: 2f 83 00 00 cmpwi cr7,r3,0
ffc03fc4: 41 be 00 10 beq+ cr7,ffc03fd4 <disk_unlock+0x38> <== ALWAYS TAKEN
/* FIXME: Error number */
rtems_fatal_error_occurred(0xdeadbeef);
ffc03fc8: 3c 60 de ad lis r3,-8531 <== NOT EXECUTED
ffc03fcc: 60 63 be ef ori r3,r3,48879 <== NOT EXECUTED
ffc03fd0: 48 00 52 d5 bl ffc092a4 <rtems_fatal_error_occurred> <== NOT EXECUTED
}
}
ffc03fd4: 80 01 00 0c lwz r0,12(r1)
ffc03fd8: 38 21 00 08 addi r1,r1,8
ffc03fdc: 7c 08 03 a6 mtlr r0
ffc03fe0: 4e 80 00 20 blr
ffc05a00 <drainOutput.part.0>:
/*
* Drain output queue
*/
static void
drainOutput (struct rtems_termios_tty *tty)
ffc05a00: 94 21 ff f0 stwu r1,-16(r1)
ffc05a04: 7c 08 02 a6 mflr r0
ffc05a08: bf c1 00 08 stmw r30,8(r1)
ffc05a0c: 7c 7f 1b 78 mr r31,r3
ffc05a10: 90 01 00 14 stw r0,20(r1)
{
rtems_interrupt_level level;
rtems_status_code sc;
if (tty->device.outputUsesInterrupts != TERMIOS_POLLED) {
rtems_interrupt_disable (level);
ffc05a14: 4b ff ff d9 bl ffc059ec <ppc_interrupt_disable>
while (tty->rawOutBuf.Tail != tty->rawOutBuf.Head) {
tty->rawOutBufState = rob_wait;
ffc05a18: 3b c0 00 02 li r30,2
ffc05a1c: 48 00 00 2c b ffc05a48 <drainOutput.part.0+0x48>
ffc05a20: 93 df 00 94 stw r30,148(r31) <== NOT EXECUTED
static inline void ppc_interrupt_enable( uint32_t level )
{
__asm__ volatile (
ffc05a24: 7c 60 01 24 mtmsr r3 <== NOT EXECUTED
rtems_interrupt_enable (level);
sc = rtems_semaphore_obtain(
ffc05a28: 80 7f 00 8c lwz r3,140(r31) <== NOT EXECUTED
ffc05a2c: 38 80 00 00 li r4,0 <== NOT EXECUTED
ffc05a30: 38 a0 00 00 li r5,0 <== NOT EXECUTED
ffc05a34: 48 00 26 71 bl ffc080a4 <rtems_semaphore_obtain> <== NOT EXECUTED
tty->rawOutBuf.Semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
ffc05a38: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc05a3c: 41 be 00 08 beq+ cr7,ffc05a44 <drainOutput.part.0+0x44> <== NOT EXECUTED
rtems_fatal_error_occurred (sc);
ffc05a40: 48 00 2e 3d bl ffc0887c <rtems_fatal_error_occurred> <== NOT EXECUTED
rtems_interrupt_disable (level);
ffc05a44: 4b ff ff a9 bl ffc059ec <ppc_interrupt_disable> <== 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) {
ffc05a48: 81 3f 00 84 lwz r9,132(r31)
ffc05a4c: 80 1f 00 80 lwz r0,128(r31)
ffc05a50: 7f 89 00 00 cmpw cr7,r9,r0
ffc05a54: 40 9e ff cc bne+ cr7,ffc05a20 <drainOutput.part.0+0x20> <== NEVER TAKEN
ffc05a58: 7c 60 01 24 mtmsr r3
rtems_fatal_error_occurred (sc);
rtems_interrupt_disable (level);
}
rtems_interrupt_enable (level);
}
}
ffc05a5c: 39 61 00 10 addi r11,r1,16
ffc05a60: 4b ff aa e0 b ffc00540 <_restgpr_30_x>
ffc066d8 <echo>:
/*
* Echo a typed character
*/
static void
echo (unsigned char c, struct rtems_termios_tty *tty)
{
ffc066d8: 7c 08 02 a6 mflr r0
ffc066dc: 7c 2b 0b 78 mr r11,r1
ffc066e0: 94 21 ff e0 stwu r1,-32(r1)
ffc066e4: 90 01 00 24 stw r0,36(r1)
ffc066e8: 48 01 4c 65 bl ffc1b34c <_savegpr_31>
ffc066ec: 7c 9f 23 78 mr r31,r4
if ((tty->termios.c_lflag & ECHOCTL) &&
ffc066f0: 80 04 00 3c lwz r0,60(r4)
ffc066f4: 70 09 02 00 andi. r9,r0,512
ffc066f8: 41 82 00 5c beq- ffc06754 <echo+0x7c> <== NEVER TAKEN
iscntrl(c) && (c != '\t') && (c != '\n')) {
ffc066fc: 3d 20 00 00 lis r9,0
ffc06700: 81 29 27 84 lwz r9,10116(r9)
ffc06704: 7d 29 1a 14 add r9,r9,r3
ffc06708: 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) &&
ffc0670c: 70 09 00 20 andi. r9,r0,32
ffc06710: 41 82 00 44 beq- ffc06754 <echo+0x7c>
iscntrl(c) && (c != '\t') && (c != '\n')) {
ffc06714: 2f 83 00 09 cmpwi cr7,r3,9
ffc06718: 41 9e 00 3c beq- cr7,ffc06754 <echo+0x7c>
ffc0671c: 2f 83 00 0a cmpwi cr7,r3,10
ffc06720: 41 be 00 34 beq+ cr7,ffc06754 <echo+0x7c>
char echobuf[2];
echobuf[0] = '^';
echobuf[1] = c ^ 0x40;
ffc06724: 68 63 00 40 xori r3,r3,64
{
if ((tty->termios.c_lflag & ECHOCTL) &&
iscntrl(c) && (c != '\t') && (c != '\n')) {
char echobuf[2];
echobuf[0] = '^';
ffc06728: 38 00 00 5e li r0,94
echobuf[1] = c ^ 0x40;
ffc0672c: 98 61 00 09 stb r3,9(r1)
rtems_termios_puts (echobuf, 2, tty);
ffc06730: 38 80 00 02 li r4,2
ffc06734: 38 61 00 08 addi r3,r1,8
{
if ((tty->termios.c_lflag & ECHOCTL) &&
iscntrl(c) && (c != '\t') && (c != '\n')) {
char echobuf[2];
echobuf[0] = '^';
ffc06738: 98 01 00 08 stb r0,8(r1)
echobuf[1] = c ^ 0x40;
rtems_termios_puts (echobuf, 2, tty);
ffc0673c: 7f e5 fb 78 mr r5,r31
ffc06740: 4b ff fd 0d bl ffc0644c <rtems_termios_puts>
tty->column += 2;
ffc06744: 81 3f 00 28 lwz r9,40(r31)
ffc06748: 38 09 00 02 addi r0,r9,2
ffc0674c: 90 1f 00 28 stw r0,40(r31)
ffc06750: 48 00 00 0c b ffc0675c <echo+0x84>
} else {
oproc (c, tty);
ffc06754: 7f e4 fb 78 mr r4,r31
ffc06758: 4b ff fe 15 bl ffc0656c <oproc>
}
}
ffc0675c: 39 61 00 20 addi r11,r1,32
ffc06760: 4b ff 9d e4 b ffc00544 <_restgpr_31_x>
ffc055dc <endgrent>:
void endgrent(void)
{
if (group_fp != NULL)
ffc055dc: 3d 20 00 00 lis r9,0
fclose(group_fp);
group_fp = fopen("/etc/group", "r");
}
void endgrent(void)
{
ffc055e0: 94 21 ff f8 stwu r1,-8(r1)
ffc055e4: 7c 08 02 a6 mflr r0
if (group_fp != NULL)
ffc055e8: 80 69 2a 94 lwz r3,10900(r9)
fclose(group_fp);
group_fp = fopen("/etc/group", "r");
}
void endgrent(void)
{
ffc055ec: 90 01 00 0c stw r0,12(r1)
if (group_fp != NULL)
ffc055f0: 2f 83 00 00 cmpwi cr7,r3,0
ffc055f4: 41 9e 00 08 beq- cr7,ffc055fc <endgrent+0x20> <== NEVER TAKEN
fclose(group_fp);
ffc055f8: 48 00 c2 0d bl ffc11804 <fclose>
}
ffc055fc: 80 01 00 0c lwz r0,12(r1)
ffc05600: 38 21 00 08 addi r1,r1,8
ffc05604: 7c 08 03 a6 mtlr r0
ffc05608: 4e 80 00 20 blr
ffc0541c <endpwent>:
void endpwent(void)
{
if (passwd_fp != NULL)
ffc0541c: 3d 20 00 00 lis r9,0
fclose(passwd_fp);
passwd_fp = fopen("/etc/passwd", "r");
}
void endpwent(void)
{
ffc05420: 94 21 ff f8 stwu r1,-8(r1)
ffc05424: 7c 08 02 a6 mflr r0
if (passwd_fp != NULL)
ffc05428: 80 69 29 b8 lwz r3,10680(r9)
fclose(passwd_fp);
passwd_fp = fopen("/etc/passwd", "r");
}
void endpwent(void)
{
ffc0542c: 90 01 00 0c stw r0,12(r1)
if (passwd_fp != NULL)
ffc05430: 2f 83 00 00 cmpwi cr7,r3,0
ffc05434: 41 9e 00 08 beq- cr7,ffc0543c <endpwent+0x20> <== NEVER TAKEN
fclose(passwd_fp);
ffc05438: 48 00 c3 cd bl ffc11804 <fclose>
}
ffc0543c: 80 01 00 0c lwz r0,12(r1)
ffc05440: 38 21 00 08 addi r1,r1,8
ffc05444: 7c 08 03 a6 mtlr r0
ffc05448: 4e 80 00 20 blr
ffc06764 <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)
{
ffc06764: 94 21 ff e0 stwu r1,-32(r1)
ffc06768: 7c 08 02 a6 mflr r0
ffc0676c: 7d 80 00 26 mfcr r12
ffc06770: 90 01 00 24 stw r0,36(r1)
if (tty->ccount == 0)
ffc06774: 80 03 00 20 lwz r0,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)
{
ffc06778: bf 61 00 0c stmw r27,12(r1)
ffc0677c: 7c 7f 1b 78 mr r31,r3
if (tty->ccount == 0)
ffc06780: 2f 80 00 00 cmpwi cr7,r0,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)
{
ffc06784: 91 81 00 08 stw r12,8(r1)
if (tty->ccount == 0)
ffc06788: 41 9e 01 d8 beq- cr7,ffc06960 <erase+0x1fc>
return;
if (lineFlag) {
ffc0678c: 2f 84 00 00 cmpwi cr7,r4,0
ffc06790: 41 9e 01 ac beq- cr7,ffc0693c <erase+0x1d8>
if (!(tty->termios.c_lflag & ECHO)) {
ffc06794: 80 03 00 3c lwz r0,60(r3)
ffc06798: 70 09 00 08 andi. r9,r0,8
ffc0679c: 40 a2 00 0c bne+ ffc067a8 <erase+0x44> <== ALWAYS TAKEN
tty->ccount = 0;
ffc067a0: 91 23 00 20 stw r9,32(r3) <== NOT EXECUTED
return;
ffc067a4: 48 00 01 bc b ffc06960 <erase+0x1fc> <== NOT EXECUTED
}
if (!(tty->termios.c_lflag & ECHOE)) {
ffc067a8: 70 00 00 10 andi. r0,r0,16
ffc067ac: 40 a2 01 90 bne+ ffc0693c <erase+0x1d8> <== ALWAYS TAKEN
tty->ccount = 0;
ffc067b0: 90 03 00 20 stw r0,32(r3) <== NOT EXECUTED
echo (tty->termios.c_cc[VKILL], tty);
ffc067b4: 7f e4 fb 78 mr r4,r31 <== NOT EXECUTED
ffc067b8: 88 63 00 44 lbz r3,68(r3) <== NOT EXECUTED
ffc067bc: 4b ff ff 1d bl ffc066d8 <echo> <== NOT EXECUTED
if (tty->termios.c_lflag & ECHOK)
ffc067c0: 80 1f 00 3c lwz r0,60(r31) <== NOT EXECUTED
echo ('\n', tty);
ffc067c4: 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)
ffc067c8: 70 07 00 20 andi. r7,r0,32 <== NOT EXECUTED
ffc067cc: 41 a2 01 94 beq+ ffc06960 <erase+0x1fc> <== NOT EXECUTED
ffc067d0: 48 00 00 30 b ffc06800 <erase+0x9c> <== NOT EXECUTED
}
while (tty->ccount) {
unsigned char c = tty->cbuf[--tty->ccount];
if (tty->termios.c_lflag & ECHO) {
ffc067d4: 80 1f 00 3c lwz r0,60(r31)
return;
}
}
while (tty->ccount) {
unsigned char c = tty->cbuf[--tty->ccount];
ffc067d8: 39 29 ff ff addi r9,r9,-1
ffc067dc: 81 5f 00 1c lwz r10,28(r31)
if (tty->termios.c_lflag & ECHO) {
ffc067e0: 70 0b 00 08 andi. r11,r0,8
return;
}
}
while (tty->ccount) {
unsigned char c = tty->cbuf[--tty->ccount];
ffc067e4: 91 3f 00 20 stw r9,32(r31)
ffc067e8: 7f ca 48 ae lbzx r30,r10,r9
if (tty->termios.c_lflag & ECHO) {
ffc067ec: 41 82 01 48 beq- ffc06934 <erase+0x1d0> <== NEVER TAKEN
if (!lineFlag && !(tty->termios.c_lflag & ECHOE)) {
ffc067f0: 40 92 00 30 bne- cr4,ffc06820 <erase+0xbc>
ffc067f4: 70 07 00 10 andi. r7,r0,16
ffc067f8: 40 a2 00 28 bne+ ffc06820 <erase+0xbc> <== ALWAYS TAKEN
echo (tty->termios.c_cc[VERASE], tty);
ffc067fc: 88 7f 00 43 lbz r3,67(r31) <== NOT EXECUTED
}
}
if (!lineFlag)
break;
}
}
ffc06800: 80 01 00 24 lwz r0,36(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);
ffc06804: 7f e4 fb 78 mr r4,r31 <== NOT EXECUTED
}
}
if (!lineFlag)
break;
}
}
ffc06808: 81 81 00 08 lwz r12,8(r1) <== NOT EXECUTED
ffc0680c: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
ffc06810: bb 61 00 0c lmw r27,12(r1) <== NOT EXECUTED
ffc06814: 38 21 00 20 addi r1,r1,32 <== NOT EXECUTED
ffc06818: 7d 80 81 20 mtcrf 8,r12 <== 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);
ffc0681c: 4b ff fe bc b ffc066d8 <echo> <== NOT EXECUTED
} else if (c == '\t') {
ffc06820: 2f 9e 00 09 cmpwi cr7,r30,9
ffc06824: 40 be 00 90 bne+ cr7,ffc068b4 <erase+0x150>
while (i != tty->ccount) {
c = tty->cbuf[i++];
if (c == '\t') {
col = (col | 7) + 1;
} else if (iscntrl (c)) {
if (tty->termios.c_lflag & ECHOCTL)
ffc06828: 39 29 00 01 addi r9,r9,1
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;
ffc0682c: 83 df 00 2c lwz r30,44(r31)
*/
while (i != tty->ccount) {
c = tty->cbuf[i++];
if (c == '\t') {
col = (col | 7) + 1;
} else if (iscntrl (c)) {
ffc06830: 81 1d 27 84 lwz r8,10116(r29)
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;
ffc06834: 39 60 00 00 li r11,0
while (i != tty->ccount) {
c = tty->cbuf[i++];
if (c == '\t') {
col = (col | 7) + 1;
} else if (iscntrl (c)) {
if (tty->termios.c_lflag & ECHOCTL)
ffc06838: 70 07 02 00 andi. r7,r0,512
ffc0683c: 7d 29 03 a6 mtctr r9
ffc06840: 48 00 00 40 b ffc06880 <erase+0x11c>
/*
* Find the character before the tab
*/
while (i != tty->ccount) {
c = tty->cbuf[i++];
ffc06844: 7c 0a 58 ae lbzx r0,r10,r11
ffc06848: 39 6b 00 01 addi r11,r11,1
if (c == '\t') {
ffc0684c: 2f 80 00 09 cmpwi cr7,r0,9
ffc06850: 40 be 00 0c bne+ cr7,ffc0685c <erase+0xf8>
col = (col | 7) + 1;
ffc06854: 63 de 00 07 ori r30,r30,7
ffc06858: 48 00 00 24 b ffc0687c <erase+0x118>
} else if (iscntrl (c)) {
ffc0685c: 7d 28 02 14 add r9,r8,r0
ffc06860: 88 09 00 01 lbz r0,1(r9)
ffc06864: 54 09 df fe rlwinm r9,r0,27,31,31
ffc06868: 2f 89 00 00 cmpwi cr7,r9,0
ffc0686c: 41 9e 00 10 beq- cr7,ffc0687c <erase+0x118> <== ALWAYS TAKEN
if (tty->termios.c_lflag & ECHOCTL)
ffc06870: 41 82 00 10 beq- ffc06880 <erase+0x11c> <== NOT EXECUTED
col += 2;
ffc06874: 3b de 00 02 addi r30,r30,2 <== NOT EXECUTED
ffc06878: 48 00 00 08 b ffc06880 <erase+0x11c> <== NOT EXECUTED
} else {
col++;
ffc0687c: 3b de 00 01 addi r30,r30,1
int i = 0;
/*
* Find the character before the tab
*/
while (i != tty->ccount) {
ffc06880: 42 00 ff c4 bdnz+ ffc06844 <erase+0xe0>
ffc06884: 48 00 00 20 b ffc068a4 <erase+0x140>
/*
* Back up over the tab
*/
while (tty->column > col) {
rtems_termios_puts ("\b", 1, tty);
ffc06888: 7f 63 db 78 mr r3,r27
ffc0688c: 38 80 00 01 li r4,1
ffc06890: 7f e5 fb 78 mr r5,r31
ffc06894: 4b ff fb b9 bl ffc0644c <rtems_termios_puts>
tty->column--;
ffc06898: 81 3f 00 28 lwz r9,40(r31)
ffc0689c: 38 09 ff ff addi r0,r9,-1
ffc068a0: 90 1f 00 28 stw r0,40(r31)
}
/*
* Back up over the tab
*/
while (tty->column > col) {
ffc068a4: 80 1f 00 28 lwz r0,40(r31)
ffc068a8: 7f 80 f0 00 cmpw cr7,r0,r30
ffc068ac: 41 9d ff dc bgt+ cr7,ffc06888 <erase+0x124>
ffc068b0: 48 00 00 84 b ffc06934 <erase+0x1d0>
rtems_termios_puts ("\b", 1, tty);
tty->column--;
}
}
else {
if (iscntrl (c) && (tty->termios.c_lflag & ECHOCTL)) {
ffc068b4: 81 3d 27 84 lwz r9,10116(r29)
ffc068b8: 3b de 00 01 addi r30,r30,1
ffc068bc: 7d 29 f0 ae lbzx r9,r9,r30
ffc068c0: 71 2b 00 20 andi. r11,r9,32
ffc068c4: 41 82 00 30 beq- ffc068f4 <erase+0x190> <== ALWAYS TAKEN
ffc068c8: 70 07 02 00 andi. r7,r0,512 <== NOT EXECUTED
ffc068cc: 41 a2 00 28 beq+ ffc068f4 <erase+0x190> <== NOT EXECUTED
rtems_termios_puts ("\b \b", 3, tty);
ffc068d0: 7f 83 e3 78 mr r3,r28 <== NOT EXECUTED
ffc068d4: 38 80 00 03 li r4,3 <== NOT EXECUTED
ffc068d8: 7f e5 fb 78 mr r5,r31 <== NOT EXECUTED
ffc068dc: 4b ff fb 71 bl ffc0644c <rtems_termios_puts> <== NOT EXECUTED
if (tty->column)
ffc068e0: 81 3f 00 28 lwz r9,40(r31) <== NOT EXECUTED
ffc068e4: 2f 89 00 00 cmpwi cr7,r9,0 <== NOT EXECUTED
ffc068e8: 41 9e 00 0c beq- cr7,ffc068f4 <erase+0x190> <== NOT EXECUTED
tty->column--;
ffc068ec: 39 29 ff ff addi r9,r9,-1 <== NOT EXECUTED
ffc068f0: 91 3f 00 28 stw r9,40(r31) <== NOT EXECUTED
}
if (!iscntrl (c) || (tty->termios.c_lflag & ECHOCTL)) {
ffc068f4: 81 3d 27 84 lwz r9,10116(r29)
ffc068f8: 7c 09 f0 ae lbzx r0,r9,r30
ffc068fc: 70 09 00 20 andi. r9,r0,32
ffc06900: 41 82 00 10 beq- ffc06910 <erase+0x1ac> <== ALWAYS TAKEN
ffc06904: 80 1f 00 3c lwz r0,60(r31) <== NOT EXECUTED
ffc06908: 70 0b 02 00 andi. r11,r0,512 <== NOT EXECUTED
ffc0690c: 41 82 00 28 beq- ffc06934 <erase+0x1d0> <== NOT EXECUTED
rtems_termios_puts ("\b \b", 3, tty);
ffc06910: 7f 83 e3 78 mr r3,r28
ffc06914: 38 80 00 03 li r4,3
ffc06918: 7f e5 fb 78 mr r5,r31
ffc0691c: 4b ff fb 31 bl ffc0644c <rtems_termios_puts>
if (tty->column)
ffc06920: 81 3f 00 28 lwz r9,40(r31)
ffc06924: 2f 89 00 00 cmpwi cr7,r9,0
ffc06928: 41 9e 00 0c beq- cr7,ffc06934 <erase+0x1d0> <== NEVER TAKEN
tty->column--;
ffc0692c: 39 29 ff ff addi r9,r9,-1
ffc06930: 91 3f 00 28 stw r9,40(r31)
}
}
}
if (!lineFlag)
ffc06934: 40 b2 00 20 bne+ cr4,ffc06954 <erase+0x1f0>
ffc06938: 48 00 00 28 b ffc06960 <erase+0x1fc>
while (tty->ccount) {
unsigned char c = tty->cbuf[--tty->ccount];
if (tty->termios.c_lflag & ECHO) {
if (!lineFlag && !(tty->termios.c_lflag & ECHOE)) {
ffc0693c: 2e 04 00 00 cmpwi cr4,r4,0
rtems_termios_puts ("\b \b", 3, tty);
if (tty->column)
tty->column--;
}
if (!iscntrl (c) || (tty->termios.c_lflag & ECHOCTL)) {
rtems_termios_puts ("\b \b", 3, tty);
ffc06940: 3f 80 ff c2 lis r28,-62
/*
* Back up over the tab
*/
while (tty->column > col) {
rtems_termios_puts ("\b", 1, tty);
ffc06944: 3f 60 ff c2 lis r27,-62
ffc06948: 3f a0 00 00 lis r29,0
rtems_termios_puts ("\b \b", 3, tty);
if (tty->column)
tty->column--;
}
if (!iscntrl (c) || (tty->termios.c_lflag & ECHOCTL)) {
rtems_termios_puts ("\b \b", 3, tty);
ffc0694c: 3b 9c d8 10 addi r28,r28,-10224
/*
* Back up over the tab
*/
while (tty->column > col) {
rtems_termios_puts ("\b", 1, tty);
ffc06950: 3b 7b d8 12 addi r27,r27,-10222
echo ('\n', tty);
return;
}
}
while (tty->ccount) {
ffc06954: 81 3f 00 20 lwz r9,32(r31)
ffc06958: 2f 89 00 00 cmpwi cr7,r9,0
ffc0695c: 40 9e fe 78 bne+ cr7,ffc067d4 <erase+0x70>
}
}
if (!lineFlag)
break;
}
}
ffc06960: 81 81 00 08 lwz r12,8(r1)
ffc06964: 39 61 00 20 addi r11,r1,32
ffc06968: 7d 80 81 20 mtcrf 8,r12
ffc0696c: 4b ff 9b c8 b ffc00534 <_restgpr_27_x>
ffc149bc <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)
{
ffc149bc: 94 21 ff d0 stwu r1,-48(r1)
ffc149c0: 7c 08 02 a6 mflr r0
ffc149c4: bf 41 00 18 stmw r26,24(r1)
ffc149c8: 7c 7f 1b 78 mr r31,r3
ffc149cc: 7c 9e 23 78 mr r30,r4
ffc149d0: 90 01 00 34 stw r0,52(r1)
ffc149d4: 7c bc 2b 78 mr r28,r5
ffc149d8: 7c db 33 78 mr r27,r6
rtems_status_code sc = RTEMS_SUCCESSFUL;
uint8_t i;
bool sec_of_fat;
if (fs_info->c.state == FAT_CACHE_EMPTY)
ffc149dc: 88 03 00 85 lbz r0,133(r3)
ffc149e0: 2f 80 00 00 cmpwi cr7,r0,0
ffc149e4: 40 9e 00 40 bne- cr7,ffc14a24 <fat_buf_access+0x68>
{
if (op_type == FAT_OP_TYPE_READ)
ffc149e8: 2f 9c 00 01 cmpwi cr7,r28,1
ffc149ec: 80 63 00 58 lwz r3,88(r3)
sc = rtems_bdbuf_read(fs_info->vol.dev, blk, &fs_info->c.buf);
ffc149f0: 7c 85 23 78 mr r5,r4
ffc149f4: 80 9f 00 5c lwz r4,92(r31)
ffc149f8: 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)
ffc149fc: 40 be 00 0c bne+ cr7,ffc14a08 <fat_buf_access+0x4c>
sc = rtems_bdbuf_read(fs_info->vol.dev, blk, &fs_info->c.buf);
ffc14a00: 4b ff e5 79 bl ffc12f78 <rtems_bdbuf_read>
ffc14a04: 48 00 00 08 b ffc14a0c <fat_buf_access+0x50>
else
sc = rtems_bdbuf_get(fs_info->vol.dev, blk, &fs_info->c.buf);
ffc14a08: 4b ff e4 95 bl ffc12e9c <rtems_bdbuf_get>
if (sc != RTEMS_SUCCESSFUL)
ffc14a0c: 2f 83 00 00 cmpwi cr7,r3,0
ffc14a10: 40 9e 01 5c bne- cr7,ffc14b6c <fat_buf_access+0x1b0> <== NEVER TAKEN
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;
ffc14a14: 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;
ffc14a18: 93 df 00 80 stw r30,128(r31)
fs_info->c.modified = 0;
ffc14a1c: 98 7f 00 84 stb r3,132(r31)
fs_info->c.state = FAT_CACHE_ACTUAL;
ffc14a20: 98 1f 00 85 stb r0,133(r31)
}
sec_of_fat = ((fs_info->c.blk_num >= fs_info->vol.fat_loc) &&
ffc14a24: 80 1f 00 80 lwz r0,128(r31)
ffc14a28: 3b a0 00 00 li r29,0
ffc14a2c: a1 3f 00 14 lhz r9,20(r31)
ffc14a30: 7f 80 48 40 cmplw cr7,r0,r9
ffc14a34: 41 9c 00 14 blt- cr7,ffc14a48 <fat_buf_access+0x8c> <== NEVER TAKEN
ffc14a38: 83 bf 00 1c lwz r29,28(r31)
ffc14a3c: 7f bd 00 10 subfc r29,r29,r0
ffc14a40: 7f bd e9 10 subfe r29,r29,r29
ffc14a44: 7f bd 00 d0 neg r29,r29
(fs_info->c.blk_num < fs_info->vol.rdir_loc));
if (fs_info->c.blk_num != blk)
ffc14a48: 7f 80 f0 00 cmpw cr7,r0,r30
ffc14a4c: 41 9e 01 40 beq- cr7,ffc14b8c <fat_buf_access+0x1d0>
{
if (fs_info->c.modified)
ffc14a50: 8b 5f 00 84 lbz r26,132(r31)
ffc14a54: 2f 9a 00 00 cmpwi cr7,r26,0
ffc14a58: 41 9e 00 d4 beq- cr7,ffc14b2c <fat_buf_access+0x170>
{
if (sec_of_fat && !fs_info->vol.mirror)
ffc14a5c: 73 bd 00 ff andi. r29,r29,255
ffc14a60: 41 82 00 24 beq- ffc14a84 <fat_buf_access+0xc8> <== ALWAYS TAKEN
ffc14a64: 88 1f 00 48 lbz r0,72(r31) <== NOT EXECUTED
ffc14a68: 2f 80 00 00 cmpwi cr7,r0,0 <== NOT EXECUTED
ffc14a6c: 40 be 00 18 bne+ cr7,ffc14a84 <fat_buf_access+0xc8> <== NOT EXECUTED
memcpy(fs_info->sec_buf, fs_info->c.buf->buffer,
ffc14a70: 81 3f 00 88 lwz r9,136(r31) <== NOT EXECUTED
ffc14a74: 80 7f 00 8c lwz r3,140(r31) <== NOT EXECUTED
ffc14a78: 80 89 00 24 lwz r4,36(r9) <== NOT EXECUTED
ffc14a7c: a0 bf 00 00 lhz r5,0(r31) <== NOT EXECUTED
ffc14a80: 48 00 a5 8d bl ffc1f00c <memcpy> <== NOT EXECUTED
fs_info->vol.bps);
sc = rtems_bdbuf_release_modified(fs_info->c.buf);
ffc14a84: 80 7f 00 88 lwz r3,136(r31)
ffc14a88: 4b ff e8 51 bl ffc132d8 <rtems_bdbuf_release_modified>
fs_info->c.state = FAT_CACHE_EMPTY;
ffc14a8c: 38 00 00 00 li r0,0
fs_info->c.modified = 0;
if (sc != RTEMS_SUCCESSFUL)
ffc14a90: 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;
ffc14a94: 98 1f 00 85 stb r0,133(r31)
fs_info->c.modified = 0;
ffc14a98: 98 1f 00 84 stb r0,132(r31)
if (sc != RTEMS_SUCCESSFUL)
ffc14a9c: 40 9e 00 d0 bne- cr7,ffc14b6c <fat_buf_access+0x1b0> <== NEVER TAKEN
rtems_set_errno_and_return_minus_one(EIO);
if (sec_of_fat && !fs_info->vol.mirror)
ffc14aa0: 2f 9d 00 00 cmpwi cr7,r29,0
ffc14aa4: 41 9e 00 9c beq- cr7,ffc14b40 <fat_buf_access+0x184> <== ALWAYS TAKEN
ffc14aa8: 88 1f 00 48 lbz r0,72(r31) <== NOT EXECUTED
ffc14aac: 3b a0 00 01 li r29,1 <== NOT EXECUTED
ffc14ab0: 2f 80 00 00 cmpwi cr7,r0,0 <== NOT EXECUTED
ffc14ab4: 41 9e 00 68 beq- cr7,ffc14b1c <fat_buf_access+0x160> <== NOT EXECUTED
ffc14ab8: 48 00 00 88 b ffc14b40 <fat_buf_access+0x184> <== NOT EXECUTED
for (i = 1; i < fs_info->vol.fats; i++)
{
sc = rtems_bdbuf_get(fs_info->vol.dev,
fs_info->c.blk_num +
fs_info->vol.fat_length * i,
ffc14abc: 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,
ffc14ac0: 38 c1 00 08 addi r6,r1,8 <== NOT EXECUTED
ffc14ac4: 80 1f 00 80 lwz r0,128(r31) <== NOT EXECUTED
fs_info->c.blk_num +
fs_info->vol.fat_length * i,
ffc14ac8: 7c bd 29 d6 mullw r5,r29,r5 <== NOT EXECUTED
{
rtems_bdbuf_buffer *b;
for (i = 1; i < fs_info->vol.fats; i++)
{
sc = rtems_bdbuf_get(fs_info->vol.dev,
ffc14acc: 80 7f 00 58 lwz r3,88(r31) <== NOT EXECUTED
ffc14ad0: 80 9f 00 5c lwz r4,92(r31) <== NOT EXECUTED
ffc14ad4: 7c a5 02 14 add r5,r5,r0 <== NOT EXECUTED
ffc14ad8: 4b ff e3 c5 bl ffc12e9c <rtems_bdbuf_get> <== NOT EXECUTED
fs_info->c.blk_num +
fs_info->vol.fat_length * i,
&b);
if ( sc != RTEMS_SUCCESSFUL)
ffc14adc: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc14ae0: 40 9e 00 28 bne- cr7,ffc14b08 <fat_buf_access+0x14c> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(ENOMEM);
memcpy(b->buffer, fs_info->sec_buf, fs_info->vol.bps);
ffc14ae4: 81 21 00 08 lwz r9,8(r1) <== NOT EXECUTED
ffc14ae8: 80 9f 00 8c lwz r4,140(r31) <== NOT EXECUTED
ffc14aec: 80 69 00 24 lwz r3,36(r9) <== NOT EXECUTED
ffc14af0: a0 bf 00 00 lhz r5,0(r31) <== NOT EXECUTED
ffc14af4: 48 00 a5 19 bl ffc1f00c <memcpy> <== NOT EXECUTED
sc = rtems_bdbuf_release_modified(b);
ffc14af8: 80 61 00 08 lwz r3,8(r1) <== NOT EXECUTED
ffc14afc: 4b ff e7 dd bl ffc132d8 <rtems_bdbuf_release_modified><== NOT EXECUTED
if ( sc != RTEMS_SUCCESSFUL)
ffc14b00: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc14b04: 41 be 00 10 beq+ cr7,ffc14b14 <fat_buf_access+0x158> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(ENOMEM);
ffc14b08: 48 00 96 d1 bl ffc1e1d8 <__errno> <== NOT EXECUTED
ffc14b0c: 38 00 00 0c li r0,12 <== NOT EXECUTED
ffc14b10: 48 00 00 64 b ffc14b74 <fat_buf_access+0x1b8> <== NOT EXECUTED
if (sec_of_fat && !fs_info->vol.mirror)
{
rtems_bdbuf_buffer *b;
for (i = 1; i < fs_info->vol.fats; i++)
ffc14b14: 3b bd 00 01 addi r29,r29,1 <== NOT EXECUTED
ffc14b18: 57 bd 06 3e clrlwi r29,r29,24 <== NOT EXECUTED
ffc14b1c: 88 1f 00 09 lbz r0,9(r31) <== NOT EXECUTED
ffc14b20: 7f 80 e8 40 cmplw cr7,r0,r29 <== NOT EXECUTED
ffc14b24: 41 9d ff 98 bgt+ cr7,ffc14abc <fat_buf_access+0x100> <== NOT EXECUTED
ffc14b28: 48 00 00 18 b ffc14b40 <fat_buf_access+0x184> <== NOT EXECUTED
}
}
}
else
{
sc = rtems_bdbuf_release(fs_info->c.buf);
ffc14b2c: 80 7f 00 88 lwz r3,136(r31)
ffc14b30: 4b ff e6 c5 bl ffc131f4 <rtems_bdbuf_release>
fs_info->c.state = FAT_CACHE_EMPTY;
ffc14b34: 9b 5f 00 85 stb r26,133(r31)
if (sc != RTEMS_SUCCESSFUL)
ffc14b38: 2f 83 00 00 cmpwi cr7,r3,0
ffc14b3c: 40 9e 00 30 bne- cr7,ffc14b6c <fat_buf_access+0x1b0> <== NEVER TAKEN
rtems_set_errno_and_return_minus_one(EIO);
}
if (op_type == FAT_OP_TYPE_READ)
ffc14b40: 2f 9c 00 01 cmpwi cr7,r28,1
ffc14b44: 80 7f 00 58 lwz r3,88(r31)
sc = rtems_bdbuf_read(fs_info->vol.dev, blk, &fs_info->c.buf);
ffc14b48: 7f c5 f3 78 mr r5,r30
ffc14b4c: 80 9f 00 5c lwz r4,92(r31)
ffc14b50: 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)
ffc14b54: 40 be 00 0c bne+ cr7,ffc14b60 <fat_buf_access+0x1a4>
sc = rtems_bdbuf_read(fs_info->vol.dev, blk, &fs_info->c.buf);
ffc14b58: 4b ff e4 21 bl ffc12f78 <rtems_bdbuf_read>
ffc14b5c: 48 00 00 08 b ffc14b64 <fat_buf_access+0x1a8>
else
sc = rtems_bdbuf_get(fs_info->vol.dev, blk, &fs_info->c.buf);
ffc14b60: 4b ff e3 3d bl ffc12e9c <rtems_bdbuf_get>
if (sc != RTEMS_SUCCESSFUL)
ffc14b64: 2f 83 00 00 cmpwi cr7,r3,0
ffc14b68: 41 be 00 18 beq+ cr7,ffc14b80 <fat_buf_access+0x1c4> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one(EIO);
ffc14b6c: 48 00 96 6d bl ffc1e1d8 <__errno> <== NOT EXECUTED
ffc14b70: 38 00 00 05 li r0,5 <== NOT EXECUTED
ffc14b74: 90 03 00 00 stw r0,0(r3) <== NOT EXECUTED
ffc14b78: 38 60 ff ff li r3,-1 <== NOT EXECUTED
ffc14b7c: 48 00 00 1c b ffc14b98 <fat_buf_access+0x1dc> <== NOT EXECUTED
fs_info->c.blk_num = blk;
fs_info->c.state = FAT_CACHE_ACTUAL;
ffc14b80: 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;
ffc14b84: 93 df 00 80 stw r30,128(r31)
fs_info->c.state = FAT_CACHE_ACTUAL;
ffc14b88: 98 1f 00 85 stb r0,133(r31)
}
*buf = fs_info->c.buf;
ffc14b8c: 80 1f 00 88 lwz r0,136(r31)
return RC_OK;
ffc14b90: 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;
ffc14b94: 90 1b 00 00 stw r0,0(r27)
return RC_OK;
}
ffc14b98: 39 61 00 30 addi r11,r1,48
ffc14b9c: 4b fe df 48 b ffc02ae4 <_restgpr_26_x>
ffc14ba0 <fat_buf_release>:
int
fat_buf_release(fat_fs_info_t *fs_info)
{
ffc14ba0: 94 21 ff e0 stwu r1,-32(r1)
ffc14ba4: 7c 08 02 a6 mflr r0
ffc14ba8: bf c1 00 18 stmw r30,24(r1)
ffc14bac: 7c 7f 1b 78 mr r31,r3
ffc14bb0: 90 01 00 24 stw r0,36(r1)
rtems_status_code sc = RTEMS_SUCCESSFUL;
uint8_t i;
bool sec_of_fat;
if (fs_info->c.state == FAT_CACHE_EMPTY)
ffc14bb4: 88 03 00 85 lbz r0,133(r3)
return RC_OK;
ffc14bb8: 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)
ffc14bbc: 2f 80 00 00 cmpwi cr7,r0,0
ffc14bc0: 41 9e 01 2c beq- cr7,ffc14cec <fat_buf_release+0x14c>
return RC_OK;
sec_of_fat = ((fs_info->c.blk_num >= fs_info->vol.fat_loc) &&
ffc14bc4: 80 1f 00 80 lwz r0,128(r31)
ffc14bc8: 3b c0 00 00 li r30,0
ffc14bcc: a1 3f 00 14 lhz r9,20(r31)
ffc14bd0: 7f 80 48 40 cmplw cr7,r0,r9
ffc14bd4: 41 9c 00 14 blt- cr7,ffc14be8 <fat_buf_release+0x48> <== NEVER TAKEN
*buf = fs_info->c.buf;
return RC_OK;
}
int
fat_buf_release(fat_fs_info_t *fs_info)
ffc14bd8: 83 df 00 1c lwz r30,28(r31)
ffc14bdc: 7f de 00 10 subfc r30,r30,r0
ffc14be0: 7f de f1 10 subfe r30,r30,r30
ffc14be4: 7f de 00 d0 neg r30,r30
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)
ffc14be8: 88 1f 00 84 lbz r0,132(r31)
ffc14bec: 2f 80 00 00 cmpwi cr7,r0,0
ffc14bf0: 41 9e 00 cc beq- cr7,ffc14cbc <fat_buf_release+0x11c>
{
if (sec_of_fat && !fs_info->vol.mirror)
ffc14bf4: 73 de 00 ff andi. r30,r30,255
ffc14bf8: 41 82 00 24 beq- ffc14c1c <fat_buf_release+0x7c>
ffc14bfc: 88 1f 00 48 lbz r0,72(r31)
ffc14c00: 2f 80 00 00 cmpwi cr7,r0,0
ffc14c04: 40 be 00 18 bne+ cr7,ffc14c1c <fat_buf_release+0x7c> <== NEVER TAKEN
memcpy(fs_info->sec_buf, fs_info->c.buf->buffer, fs_info->vol.bps);
ffc14c08: 81 3f 00 88 lwz r9,136(r31)
ffc14c0c: 80 7f 00 8c lwz r3,140(r31)
ffc14c10: 80 89 00 24 lwz r4,36(r9)
ffc14c14: a0 bf 00 00 lhz r5,0(r31)
ffc14c18: 48 00 a3 f5 bl ffc1f00c <memcpy>
sc = rtems_bdbuf_release_modified(fs_info->c.buf);
ffc14c1c: 80 7f 00 88 lwz r3,136(r31)
ffc14c20: 4b ff e6 b9 bl ffc132d8 <rtems_bdbuf_release_modified>
if (sc != RTEMS_SUCCESSFUL)
ffc14c24: 2c 03 00 00 cmpwi r3,0
ffc14c28: 40 82 00 a4 bne- ffc14ccc <fat_buf_release+0x12c> <== NEVER TAKEN
rtems_set_errno_and_return_minus_one(EIO);
fs_info->c.modified = 0;
if (sec_of_fat && !fs_info->vol.mirror)
ffc14c2c: 2f 9e 00 00 cmpwi cr7,r30,0
memcpy(fs_info->sec_buf, fs_info->c.buf->buffer, fs_info->vol.bps);
sc = rtems_bdbuf_release_modified(fs_info->c.buf);
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(EIO);
fs_info->c.modified = 0;
ffc14c30: 98 7f 00 84 stb r3,132(r31)
if (sec_of_fat && !fs_info->vol.mirror)
ffc14c34: 41 9e 00 ac beq- cr7,ffc14ce0 <fat_buf_release+0x140>
ffc14c38: 88 1f 00 48 lbz r0,72(r31)
ffc14c3c: 3b c0 00 01 li r30,1
ffc14c40: 2f 80 00 00 cmpwi cr7,r0,0
ffc14c44: 41 9e 00 68 beq- cr7,ffc14cac <fat_buf_release+0x10c> <== ALWAYS TAKEN
ffc14c48: 48 00 00 98 b ffc14ce0 <fat_buf_release+0x140> <== NOT EXECUTED
for (i = 1; i < fs_info->vol.fats; i++)
{
sc = rtems_bdbuf_get(fs_info->vol.dev,
fs_info->c.blk_num +
fs_info->vol.fat_length * i,
ffc14c4c: 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,
ffc14c50: 38 c1 00 08 addi r6,r1,8
ffc14c54: 80 1f 00 80 lwz r0,128(r31)
fs_info->c.blk_num +
fs_info->vol.fat_length * i,
ffc14c58: 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,
ffc14c5c: 80 7f 00 58 lwz r3,88(r31)
ffc14c60: 80 9f 00 5c lwz r4,92(r31)
ffc14c64: 7c a5 02 14 add r5,r5,r0
ffc14c68: 4b ff e2 35 bl ffc12e9c <rtems_bdbuf_get>
fs_info->c.blk_num +
fs_info->vol.fat_length * i,
&b);
if ( sc != RTEMS_SUCCESSFUL)
ffc14c6c: 2f 83 00 00 cmpwi cr7,r3,0
ffc14c70: 40 9e 00 28 bne- cr7,ffc14c98 <fat_buf_release+0xf8> <== NEVER TAKEN
rtems_set_errno_and_return_minus_one(ENOMEM);
memcpy(b->buffer, fs_info->sec_buf, fs_info->vol.bps);
ffc14c74: 81 21 00 08 lwz r9,8(r1)
ffc14c78: 80 9f 00 8c lwz r4,140(r31)
ffc14c7c: 80 69 00 24 lwz r3,36(r9)
ffc14c80: a0 bf 00 00 lhz r5,0(r31)
ffc14c84: 48 00 a3 89 bl ffc1f00c <memcpy>
sc = rtems_bdbuf_release_modified(b);
ffc14c88: 80 61 00 08 lwz r3,8(r1)
ffc14c8c: 4b ff e6 4d bl ffc132d8 <rtems_bdbuf_release_modified>
if ( sc != RTEMS_SUCCESSFUL)
ffc14c90: 2f 83 00 00 cmpwi cr7,r3,0
ffc14c94: 41 be 00 10 beq+ cr7,ffc14ca4 <fat_buf_release+0x104> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one(ENOMEM);
ffc14c98: 48 00 95 41 bl ffc1e1d8 <__errno> <== NOT EXECUTED
ffc14c9c: 38 00 00 0c li r0,12 <== NOT EXECUTED
ffc14ca0: 48 00 00 34 b ffc14cd4 <fat_buf_release+0x134> <== NOT EXECUTED
if (sec_of_fat && !fs_info->vol.mirror)
{
rtems_bdbuf_buffer *b;
for (i = 1; i < fs_info->vol.fats; i++)
ffc14ca4: 3b de 00 01 addi r30,r30,1
ffc14ca8: 57 de 06 3e clrlwi r30,r30,24
ffc14cac: 88 1f 00 09 lbz r0,9(r31)
ffc14cb0: 7f 80 f0 40 cmplw cr7,r0,r30
ffc14cb4: 41 9d ff 98 bgt+ cr7,ffc14c4c <fat_buf_release+0xac>
ffc14cb8: 48 00 00 28 b ffc14ce0 <fat_buf_release+0x140>
}
}
}
else
{
sc = rtems_bdbuf_release(fs_info->c.buf);
ffc14cbc: 80 7f 00 88 lwz r3,136(r31)
ffc14cc0: 4b ff e5 35 bl ffc131f4 <rtems_bdbuf_release>
if (sc != RTEMS_SUCCESSFUL)
ffc14cc4: 2f 83 00 00 cmpwi cr7,r3,0
ffc14cc8: 41 be 00 18 beq+ cr7,ffc14ce0 <fat_buf_release+0x140> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one(EIO);
ffc14ccc: 48 00 95 0d bl ffc1e1d8 <__errno> <== NOT EXECUTED
ffc14cd0: 38 00 00 05 li r0,5 <== NOT EXECUTED
ffc14cd4: 90 03 00 00 stw r0,0(r3) <== NOT EXECUTED
ffc14cd8: 38 60 ff ff li r3,-1 <== NOT EXECUTED
ffc14cdc: 48 00 00 10 b ffc14cec <fat_buf_release+0x14c> <== NOT EXECUTED
}
fs_info->c.state = FAT_CACHE_EMPTY;
ffc14ce0: 38 00 00 00 li r0,0
ffc14ce4: 98 1f 00 85 stb r0,133(r31)
return RC_OK;
ffc14ce8: 38 60 00 00 li r3,0
}
ffc14cec: 39 61 00 20 addi r11,r1,32
ffc14cf0: 4b fe de 04 b ffc02af4 <_restgpr_30_x>
ffc13cbc <fat_cluster_num_to_sector_num.isra.0>:
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)) )
ffc13cbc: 7c 89 23 79 mr. r9,r4
ffc13cc0: 40 82 00 18 bne- ffc13cd8 <fat_cluster_num_to_sector_num.isra.0+0x1c>
ffc13cc4: 88 03 00 0a lbz r0,10(r3)
ffc13cc8: 70 0b 00 03 andi. r11,r0,3
ffc13ccc: 41 a2 00 0c beq+ ffc13cd8 <fat_cluster_num_to_sector_num.isra.0+0x1c><== NEVER TAKEN
return fs_info->vol.rdir_loc;
ffc13cd0: 80 63 00 1c lwz r3,28(r3)
ffc13cd4: 4e 80 00 20 blr
return (((cln - FAT_RSRVD_CLN) << fs_info->vol.spc_log2) +
ffc13cd8: 88 03 00 05 lbz r0,5(r3)
ffc13cdc: 39 29 ff fe addi r9,r9,-2
ffc13ce0: 7d 29 00 30 slw r9,r9,r0
ffc13ce4: 80 03 00 30 lwz r0,48(r3)
ffc13ce8: 7c 69 02 14 add r3,r9,r0
fs_info->vol.data_fsec);
}
ffc13cec: 4e 80 00 20 blr
ffc14e68 <fat_cluster_read>:
fat_cluster_read(
rtems_filesystem_mount_table_entry_t *mt_entry,
uint32_t cln,
void *buff
)
{
ffc14e68: 94 21 ff e8 stwu r1,-24(r1) <== NOT EXECUTED
ffc14e6c: 7c 08 02 a6 mflr r0 <== NOT EXECUTED
ffc14e70: 90 01 00 1c stw r0,28(r1) <== NOT EXECUTED
ffc14e74: bf a1 00 0c stmw r29,12(r1) <== NOT EXECUTED
ffc14e78: 7c 7e 1b 78 mr r30,r3 <== NOT EXECUTED
ffc14e7c: 7c bf 2b 78 mr r31,r5 <== NOT EXECUTED
fat_fs_info_t *fs_info = mt_entry->fs_info;
ffc14e80: 83 a3 00 34 lwz r29,52(r3) <== NOT EXECUTED
uint32_t fsec = 0;
fsec = fat_cluster_num_to_sector_num(mt_entry, cln);
ffc14e84: 7f a3 eb 78 mr r3,r29 <== NOT EXECUTED
ffc14e88: 4b ff fb 01 bl ffc14988 <fat_cluster_num_to_sector_num.isra.0><== NOT EXECUTED
return _fat_block_read(mt_entry, fsec, 0,
fs_info->vol.spc << fs_info->vol.sec_log2, buff);
ffc14e8c: 88 1d 00 02 lbz r0,2(r29) <== NOT EXECUTED
ffc14e90: 88 dd 00 04 lbz r6,4(r29) <== 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);
ffc14e94: 7c 64 1b 78 mr r4,r3 <== NOT EXECUTED
return _fat_block_read(mt_entry, fsec, 0,
ffc14e98: 7f e7 fb 78 mr r7,r31 <== NOT EXECUTED
ffc14e9c: 7c c6 00 30 slw r6,r6,r0 <== NOT EXECUTED
fs_info->vol.spc << fs_info->vol.sec_log2, buff);
}
ffc14ea0: 80 01 00 1c lwz r0,28(r1) <== 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,
ffc14ea4: 7f c3 f3 78 mr r3,r30 <== NOT EXECUTED
fs_info->vol.spc << fs_info->vol.sec_log2, buff);
}
ffc14ea8: bb a1 00 0c lmw r29,12(r1) <== NOT EXECUTED
ffc14eac: 7c 08 03 a6 mtlr r0 <== 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,
ffc14eb0: 38 a0 00 00 li r5,0 <== NOT EXECUTED
fs_info->vol.spc << fs_info->vol.sec_log2, buff);
}
ffc14eb4: 38 21 00 18 addi r1,r1,24 <== 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,
ffc14eb8: 4b ff fe 3c b ffc14cf4 <_fat_block_read> <== NOT EXECUTED
ffc150e8 <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
)
{
ffc150e8: 94 21 ff d8 stwu r1,-40(r1) <== NOT EXECUTED
ffc150ec: 7c 08 02 a6 mflr r0 <== NOT EXECUTED
ffc150f0: 90 01 00 2c stw r0,44(r1) <== NOT EXECUTED
ffc150f4: bf a1 00 1c stmw r29,28(r1) <== NOT EXECUTED
ffc150f8: 7c 7e 1b 78 mr r30,r3 <== NOT EXECUTED
ssize_t ret1 = 0, ret2 = 0;
register fat_fs_info_t *fs_info = mt_entry->fs_info;
ffc150fc: 83 e3 00 34 lwz r31,52(r3) <== NOT EXECUTED
uint32_t value
)
{
uint32_t swapped;
__asm__ volatile("rlwimi %0,%1,8,24,31;"
ffc15100: 50 80 46 3e rlwimi r0,r4,8,24,31 <== NOT EXECUTED
ffc15104: 50 80 c4 2e rlwimi r0,r4,24,16,23 <== NOT EXECUTED
ffc15108: 50 80 42 1e rlwimi r0,r4,8,8,15 <== NOT EXECUTED
ffc1510c: 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);
ffc15110: 90 01 00 0c stw r0,12(r1) <== NOT EXECUTED
ffc15114: 50 a0 46 3e rlwimi r0,r5,8,24,31 <== NOT EXECUTED
ffc15118: 50 a0 c4 2e rlwimi r0,r5,24,16,23 <== NOT EXECUTED
ffc1511c: 50 a0 42 1e rlwimi r0,r5,8,8,15 <== NOT EXECUTED
ffc15120: 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,
ffc15124: a0 9f 00 3c lhz r4,60(r31) <== NOT EXECUTED
ffc15128: 38 a0 01 e8 li r5,488 <== NOT EXECUTED
ffc1512c: 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);
ffc15130: 90 01 00 08 stw r0,8(r1) <== NOT EXECUTED
ret1 = _fat_block_write(mt_entry,
ffc15134: 38 e1 00 0c addi r7,r1,12 <== NOT EXECUTED
ffc15138: 4b ff fc 69 bl ffc14da0 <_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,
ffc1513c: 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,
ffc15140: 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,
ffc15144: 38 a0 01 ec li r5,492 <== NOT EXECUTED
ffc15148: 7f c3 f3 78 mr r3,r30 <== NOT EXECUTED
ffc1514c: 38 c0 00 04 li r6,4 <== NOT EXECUTED
ffc15150: 38 e1 00 08 addi r7,r1,8 <== NOT EXECUTED
ffc15154: 4b ff fc 4d bl ffc14da0 <_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) )
ffc15158: 2f 9d 00 00 cmpwi cr7,r29,0 <== NOT EXECUTED
return -1;
ffc1515c: 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) )
ffc15160: 41 9c 00 08 blt- cr7,ffc15168 <fat_fat32_update_fsinfo_sector+0x80><== NOT EXECUTED
return -1;
ffc15164: 7c 60 fe 70 srawi r0,r3,31 <== NOT EXECUTED
return RC_OK;
}
ffc15168: 39 61 00 28 addi r11,r1,40 <== NOT EXECUTED
ffc1516c: 7c 03 03 78 mr r3,r0 <== NOT EXECUTED
ffc15170: 4b fe d9 80 b ffc02af0 <_restgpr_29_x> <== NOT EXECUTED
ffc14204 <fat_file_close>:
int
fat_file_close(
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_file_fd_t *fat_fd
)
{
ffc14204: 94 21 ff e8 stwu r1,-24(r1)
ffc14208: 7c 08 02 a6 mflr r0
ffc1420c: 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)
ffc14210: 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
)
{
ffc14214: bf 81 00 08 stmw r28,8(r1)
ffc14218: 7c 7e 1b 78 mr r30,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)
ffc1421c: 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
)
{
ffc14220: 7c 9f 23 78 mr r31,r4
int rc = RC_OK;
fat_fs_info_t *fs_info = mt_entry->fs_info;
ffc14224: 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)
ffc14228: 40 9d 00 14 ble- cr7,ffc1423c <fat_file_close+0x38>
{
fat_fd->links_num--;
ffc1422c: 39 29 ff ff addi r9,r9,-1
ffc14230: 91 24 00 08 stw r9,8(r4)
return rc;
ffc14234: 38 60 00 00 li r3,0
ffc14238: 48 00 00 7c b ffc142b4 <fat_file_close+0xb0>
}
key = fat_construct_key(mt_entry, &fat_fd->dir_pos.sname);
if (fat_fd->flags & FAT_FILE_REMOVED)
ffc1423c: 88 04 00 30 lbz r0,48(r4)
ffc14240: 70 1c 00 01 andi. r28,r0,1
ffc14244: 41 82 00 40 beq- ffc14284 <fat_file_close+0x80> <== ALWAYS TAKEN
{
rc = fat_file_truncate(mt_entry, fat_fd, 0);
ffc14248: 38 a0 00 00 li r5,0 <== NOT EXECUTED
ffc1424c: 4b ff fe a1 bl ffc140ec <fat_file_truncate> <== NOT EXECUTED
if ( rc != RC_OK )
ffc14250: 2c 03 00 00 cmpwi r3,0 <== NOT EXECUTED
ffc14254: 40 a2 00 60 bne+ ffc142b4 <fat_file_close+0xb0> <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
ffc14258: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc1425c: 4b ff 87 ed bl ffc0ca48 <_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) )
ffc14260: 80 9f 00 0c lwz r4,12(r31) <== NOT EXECUTED
ffc14264: 7f c3 f3 78 mr r3,r30 <== NOT EXECUTED
ffc14268: 48 00 0e 69 bl ffc150d0 <fat_ino_is_unique> <== NOT EXECUTED
ffc1426c: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc14270: 41 be 00 34 beq+ cr7,ffc142a4 <fat_file_close+0xa0> <== NOT EXECUTED
fat_free_unique_ino(mt_entry, fat_fd->ino);
ffc14274: 80 9f 00 0c lwz r4,12(r31) <== NOT EXECUTED
ffc14278: 7f c3 f3 78 mr r3,r30 <== NOT EXECUTED
ffc1427c: 48 00 0e 25 bl ffc150a0 <fat_free_unique_ino> <== NOT EXECUTED
ffc14280: 48 00 00 24 b ffc142a4 <fat_file_close+0xa0> <== NOT EXECUTED
free(fat_fd);
}
else
{
if (fat_ino_is_unique(mt_entry, fat_fd->ino))
ffc14284: 80 84 00 0c lwz r4,12(r4)
ffc14288: 48 00 0e 49 bl ffc150d0 <fat_ino_is_unique>
ffc1428c: 2f 83 00 00 cmpwi cr7,r3,0
ffc14290: 41 9e 00 0c beq- cr7,ffc1429c <fat_file_close+0x98> <== ALWAYS TAKEN
{
fat_fd->links_num = 0;
ffc14294: 93 9f 00 08 stw r28,8(r31) <== NOT EXECUTED
ffc14298: 48 00 00 14 b ffc142ac <fat_file_close+0xa8> <== NOT EXECUTED
ffc1429c: 7f e3 fb 78 mr r3,r31
ffc142a0: 4b ff 87 a9 bl ffc0ca48 <_Chain_Extract>
}
else
{
_hash_delete(fs_info->vhash, key, fat_fd->ino, fat_fd);
free(fat_fd);
ffc142a4: 7f e3 fb 78 mr r3,r31
ffc142a8: 4b ff 36 41 bl ffc078e8 <free>
}
}
/*
* flush any modified "cached" buffer back to disk
*/
rc = fat_buf_release(fs_info);
ffc142ac: 7f a3 eb 78 mr r3,r29
ffc142b0: 48 00 08 f1 bl ffc14ba0 <fat_buf_release>
return rc;
}
ffc142b4: 39 61 00 18 addi r11,r1,24
ffc142b8: 4b fe e8 34 b ffc02aec <_restgpr_28_x>
ffc147e0 <fat_file_datasync>:
int
fat_file_datasync(
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_file_fd_t *fat_fd
)
{
ffc147e0: 94 21 ff d0 stwu r1,-48(r1) <== NOT EXECUTED
ffc147e4: 7c 08 02 a6 mflr r0 <== NOT EXECUTED
ffc147e8: 90 01 00 34 stw r0,52(r1) <== 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;
ffc147ec: 80 04 00 1c lwz r0,28(r4) <== NOT EXECUTED
int
fat_file_datasync(
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_file_fd_t *fat_fd
)
{
ffc147f0: bf 61 00 1c stmw r27,28(r1) <== NOT EXECUTED
ffc147f4: 7c 7c 1b 78 mr r28,r3 <== 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;
ffc147f8: 3b e0 00 00 li r31,0 <== 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;
ffc147fc: 90 01 00 0c stw r0,12(r1) <== NOT EXECUTED
rtems_bdbuf_buffer *block = NULL;
ffc14800: 38 00 00 00 li r0,0 <== NOT EXECUTED
ffc14804: 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)
ffc14808: 80 04 00 18 lwz r0,24(r4) <== NOT EXECUTED
fat_file_fd_t *fat_fd
)
{
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
fat_fs_info_t *fs_info = mt_entry->fs_info;
ffc1480c: 83 c3 00 34 lwz r30,52(r3) <== 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)
ffc14810: 2f 80 00 00 cmpwi cr7,r0,0 <== NOT EXECUTED
ffc14814: 41 be 00 b4 beq+ cr7,ffc148c8 <fat_file_datasync+0xe8> <== 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);
ffc14818: 7f c3 f3 78 mr r3,r30 <== NOT EXECUTED
ffc1481c: 48 00 03 85 bl ffc14ba0 <fat_buf_release> <== NOT EXECUTED
if (rc != RC_OK)
ffc14820: 7c 7f 1b 79 mr. r31,r3 <== NOT EXECUTED
ffc14824: 41 a2 00 84 beq+ ffc148a8 <fat_file_datasync+0xc8> <== NOT EXECUTED
ffc14828: 48 00 00 a0 b ffc148c8 <fat_file_datasync+0xe8> <== NOT EXECUTED
return rc;
/* 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);
ffc1482c: 80 7c 00 34 lwz r3,52(r28) <== NOT EXECUTED
/* for each sector in cluster ... */
for ( i = 0; i < fs_info->vol.spc; i++ )
ffc14830: 3b a0 00 00 li r29,0 <== NOT EXECUTED
return rc;
/* 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);
ffc14834: 4b ff f4 89 bl ffc13cbc <fat_cluster_num_to_sector_num.isra.0><== NOT EXECUTED
ffc14838: 7c 7b 1b 78 mr r27,r3 <== NOT EXECUTED
/* for each sector in cluster ... */
for ( i = 0; i < fs_info->vol.spc; i++ )
ffc1483c: 48 00 00 48 b ffc14884 <fat_file_datasync+0xa4> <== NOT EXECUTED
{
/* ... sync it */
sc = rtems_bdbuf_read(fs_info->vol.dev, (sec + i), &block);
ffc14840: 80 7e 00 58 lwz r3,88(r30) <== NOT EXECUTED
ffc14844: 7c bd da 14 add r5,r29,r27 <== NOT EXECUTED
ffc14848: 80 9e 00 5c lwz r4,92(r30) <== NOT EXECUTED
ffc1484c: 38 c1 00 08 addi r6,r1,8 <== NOT EXECUTED
ffc14850: 4b ff e7 29 bl ffc12f78 <rtems_bdbuf_read> <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
ffc14854: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc14858: 40 9e 00 14 bne- cr7,ffc1486c <fat_file_datasync+0x8c> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EIO );
sc = rtems_bdbuf_sync(block);
ffc1485c: 80 61 00 08 lwz r3,8(r1) <== NOT EXECUTED
ffc14860: 4b ff eb 11 bl ffc13370 <rtems_bdbuf_sync> <== NOT EXECUTED
if ( sc != RTEMS_SUCCESSFUL )
ffc14864: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc14868: 41 be 00 18 beq+ cr7,ffc14880 <fat_file_datasync+0xa0> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EIO );
ffc1486c: 48 00 99 6d bl ffc1e1d8 <__errno> <== NOT EXECUTED
ffc14870: 38 00 00 05 li r0,5 <== NOT EXECUTED
ffc14874: 90 03 00 00 stw r0,0(r3) <== NOT EXECUTED
ffc14878: 3b e0 ff ff li r31,-1 <== NOT EXECUTED
ffc1487c: 48 00 00 4c b ffc148c8 <fat_file_datasync+0xe8> <== 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++ )
ffc14880: 3b bd 00 01 addi r29,r29,1 <== NOT EXECUTED
ffc14884: 88 1e 00 04 lbz r0,4(r30) <== NOT EXECUTED
ffc14888: 7f 9d 00 40 cmplw cr7,r29,r0 <== NOT EXECUTED
ffc1488c: 41 9c ff b4 blt+ cr7,ffc14840 <fat_file_datasync+0x60> <== 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);
ffc14890: 80 81 00 0c lwz r4,12(r1) <== NOT EXECUTED
ffc14894: 7f 83 e3 78 mr r3,r28 <== NOT EXECUTED
ffc14898: 38 a1 00 0c addi r5,r1,12 <== NOT EXECUTED
ffc1489c: 48 00 7b 05 bl ffc1c3a0 <fat_get_fat_cluster> <== NOT EXECUTED
if ( rc != RC_OK )
ffc148a0: 2c 03 00 00 cmpwi r3,0 <== NOT EXECUTED
ffc148a4: 40 82 00 20 bne- ffc148c4 <fat_file_datasync+0xe4> <== NOT EXECUTED
rc = fat_buf_release(fs_info);
if (rc != RC_OK)
return rc;
/* for each cluster of the file ... */
while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)
ffc148a8: 80 81 00 0c lwz r4,12(r1) <== NOT EXECUTED
ffc148ac: 81 3e 00 0c lwz r9,12(r30) <== NOT EXECUTED
ffc148b0: 80 1e 00 10 lwz r0,16(r30) <== NOT EXECUTED
ffc148b4: 7c 89 48 38 and r9,r4,r9 <== NOT EXECUTED
ffc148b8: 7f 89 00 40 cmplw cr7,r9,r0 <== NOT EXECUTED
ffc148bc: 41 9c ff 70 blt+ cr7,ffc1482c <fat_file_datasync+0x4c> <== NOT EXECUTED
ffc148c0: 48 00 00 08 b ffc148c8 <fat_file_datasync+0xe8> <== 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);
ffc148c4: 7c 7f 1b 78 mr r31,r3 <== NOT EXECUTED
if ( rc != RC_OK )
return rc;
}
return rc;
}
ffc148c8: 39 61 00 30 addi r11,r1,48 <== NOT EXECUTED
ffc148cc: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc148d0: 4b fe e2 18 b ffc02ae8 <_restgpr_27_x> <== NOT EXECUTED
ffc14394 <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
)
{
ffc14394: 94 21 ff c0 stwu r1,-64(r1)
ffc14398: 7c 08 02 a6 mflr r0
ffc1439c: 90 01 00 44 stw r0,68(r1)
int rc = RC_OK;
fat_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t chain = 0;
ffc143a0: 38 00 00 00 li r0,0
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_file_fd_t *fat_fd,
uint32_t new_length,
uint32_t *a_length
)
{
ffc143a4: be e1 00 1c stmw r23,28(r1)
ffc143a8: 7c d8 33 78 mr r24,r6
ffc143ac: 7c 7d 1b 78 mr r29,r3
int rc = RC_OK;
fat_fs_info_t *fs_info = mt_entry->fs_info;
ffc143b0: 83 83 00 34 lwz r28,52(r3)
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_file_fd_t *fat_fd,
uint32_t new_length,
uint32_t *a_length
)
{
ffc143b4: 7c 9f 23 78 mr r31,r4
uint32_t old_last_cl;
uint32_t last_cl = 0;
uint32_t bytes_remain = 0;
uint32_t cls_added;
*a_length = new_length;
ffc143b8: 90 b8 00 00 stw r5,0(r24)
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_file_fd_t *fat_fd,
uint32_t new_length,
uint32_t *a_length
)
{
ffc143bc: 7c bb 2b 78 mr r27,r5
uint32_t cls_added;
*a_length = new_length;
if (new_length <= fat_fd->fat_file_size)
return RC_OK;
ffc143c0: 3b c0 00 00 li r30,0
uint32_t bytes_remain = 0;
uint32_t cls_added;
*a_length = new_length;
if (new_length <= fat_fd->fat_file_size)
ffc143c4: 82 e4 00 18 lwz r23,24(r4)
uint32_t *a_length
)
{
int rc = RC_OK;
fat_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t chain = 0;
ffc143c8: 90 01 00 14 stw r0,20(r1)
uint32_t bytes_remain = 0;
uint32_t cls_added;
*a_length = new_length;
if (new_length <= fat_fd->fat_file_size)
ffc143cc: 7f 85 b8 40 cmplw cr7,r5,r23
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;
ffc143d0: 90 01 00 0c stw r0,12(r1)
uint32_t bytes_remain = 0;
uint32_t cls_added;
*a_length = new_length;
if (new_length <= fat_fd->fat_file_size)
ffc143d4: 40 9d 01 ac ble- cr7,ffc14580 <fat_file_extend+0x1ec>
return RC_OK;
if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&
ffc143d8: 80 04 00 20 lwz r0,32(r4)
ffc143dc: 2f 80 00 01 cmpwi cr7,r0,1
ffc143e0: 40 be 00 1c bne+ cr7,ffc143fc <fat_file_extend+0x68> <== ALWAYS TAKEN
ffc143e4: 80 04 00 24 lwz r0,36(r4) <== NOT EXECUTED
ffc143e8: 2f 80 00 00 cmpwi cr7,r0,0 <== NOT EXECUTED
ffc143ec: 40 9e 00 10 bne- cr7,ffc143fc <fat_file_extend+0x68> <== NOT EXECUTED
(fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))
ffc143f0: 88 1c 00 0a lbz r0,10(r28) <== 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)) &&
ffc143f4: 70 09 00 03 andi. r9,r0,3 <== NOT EXECUTED
ffc143f8: 40 82 00 6c bne- ffc14464 <fat_file_extend+0xd0> <== NOT EXECUTED
(fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))
rtems_set_errno_and_return_minus_one( ENOSPC );
bytes_remain = (fs_info->vol.bpc -
ffc143fc: a1 3c 00 06 lhz r9,6(r28)
* 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;
ffc14400: 3b c0 00 00 li r30,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))) &
ffc14404: 38 09 ff ff addi r0,r9,-1
ffc14408: 7c 1a b8 38 and r26,r0,r23
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 -
ffc1440c: 7f 5a 48 50 subf r26,r26,r9
ffc14410: 7f 5a 00 38 and r26,r26,r0
(fat_fd->fat_file_size & (fs_info->vol.bpc - 1))) &
(fs_info->vol.bpc - 1);
bytes2add = new_length - fat_fd->fat_file_size;
ffc14414: 7e f7 d8 50 subf r23,r23,r27
if (bytes2add > bytes_remain)
ffc14418: 7f 97 d0 40 cmplw cr7,r23,r26
ffc1441c: 40 9d 01 64 ble- cr7,ffc14580 <fat_file_extend+0x1ec>
/*
* 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)
ffc14420: 7e fa b8 51 subf. r23,r26,r23
ffc14424: 41 82 01 5c beq- ffc14580 <fat_file_extend+0x1ec> <== NEVER TAKEN
return RC_OK;
cls2add = ((bytes2add - 1) >> fs_info->vol.bpc_log2) + 1;
ffc14428: 88 1c 00 08 lbz r0,8(r28)
ffc1442c: 3b 37 ff ff addi r25,r23,-1
rc = fat_scan_fat_for_free_clusters(mt_entry, &chain, cls2add,
ffc14430: 7f a3 eb 78 mr r3,r29
* file ) - return
*/
if (bytes2add == 0)
return RC_OK;
cls2add = ((bytes2add - 1) >> fs_info->vol.bpc_log2) + 1;
ffc14434: 7f 39 04 30 srw r25,r25,r0
ffc14438: 3b 39 00 01 addi r25,r25,1
rc = fat_scan_fat_for_free_clusters(mt_entry, &chain, cls2add,
ffc1443c: 38 81 00 14 addi r4,r1,20
ffc14440: 7f 25 cb 78 mr r5,r25
ffc14444: 38 c1 00 08 addi r6,r1,8
ffc14448: 38 e1 00 0c addi r7,r1,12
ffc1444c: 48 00 84 81 bl ffc1c8cc <fat_scan_fat_for_free_clusters>
&cls_added, &last_cl);
/* this means that low level I/O error occured */
if (rc != RC_OK)
ffc14450: 7c 7e 1b 79 mr. r30,r3
ffc14454: 40 82 01 2c bne- ffc14580 <fat_file_extend+0x1ec> <== NEVER TAKEN
return rc;
/* this means that no space left on device */
if ((cls_added == 0) && (bytes_remain == 0))
ffc14458: 80 01 00 08 lwz r0,8(r1)
ffc1445c: 7f 49 03 79 or. r9,r26,r0
ffc14460: 40 a2 00 18 bne+ ffc14478 <fat_file_extend+0xe4> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one(ENOSPC);
ffc14464: 48 00 9d 75 bl ffc1e1d8 <__errno> <== NOT EXECUTED
ffc14468: 38 00 00 1c li r0,28 <== NOT EXECUTED
ffc1446c: 90 03 00 00 stw r0,0(r3) <== NOT EXECUTED
ffc14470: 3b c0 ff ff li r30,-1 <== NOT EXECUTED
ffc14474: 48 00 01 0c b ffc14580 <fat_file_extend+0x1ec> <== NOT EXECUTED
/* check wether we satisfied request for 'cls2add' clusters */
if (cls2add != cls_added)
ffc14478: 7f 99 00 00 cmpw cr7,r25,r0
ffc1447c: 41 9e 00 2c beq- cr7,ffc144a8 <fat_file_extend+0x114> <== ALWAYS TAKEN
*a_length = new_length -
((cls2add - cls_added - 1) << fs_info->vol.bpc_log2) -
ffc14480: 89 3c 00 08 lbz r9,8(r28) <== NOT EXECUTED
ffc14484: 7c 00 00 f8 not r0,r0 <== NOT EXECUTED
ffc14488: 7f 20 ca 14 add r25,r0,r25 <== NOT EXECUTED
ffc1448c: 7f 39 48 30 slw r25,r25,r9 <== NOT EXECUTED
(bytes2add & (fs_info->vol.bpc - 1));
ffc14490: a1 3c 00 06 lhz r9,6(r28) <== 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 -
ffc14494: 7f 39 d8 50 subf r25,r25,r27 <== NOT EXECUTED
((cls2add - cls_added - 1) << fs_info->vol.bpc_log2) -
(bytes2add & (fs_info->vol.bpc - 1));
ffc14498: 38 09 ff ff addi r0,r9,-1 <== NOT EXECUTED
ffc1449c: 7e f7 00 38 and r23,r23,r0 <== 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) -
ffc144a0: 7e f7 c8 50 subf r23,r23,r25 <== 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 -
ffc144a4: 92 f8 00 00 stw r23,0(r24) <== 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 )
ffc144a8: 80 df 00 18 lwz r6,24(r31)
ffc144ac: 2f 86 00 00 cmpwi cr7,r6,0
ffc144b0: 40 9e 00 18 bne- cr7,ffc144c8 <fat_file_extend+0x134>
{
fat_fd->map.disk_cln = fat_fd->cln = chain;
ffc144b4: 80 01 00 14 lwz r0,20(r1)
fat_fd->map.file_cln = 0;
ffc144b8: 90 df 00 34 stw r6,52(r31)
(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;
ffc144bc: 90 1f 00 1c stw r0,28(r31)
ffc144c0: 90 1f 00 38 stw r0,56(r31)
ffc144c4: 48 00 00 70 b ffc14534 <fat_file_extend+0x1a0>
fat_fd->map.file_cln = 0;
}
else
{
if (fat_fd->map.last_cln != FAT_UNDEFINED_VALUE)
ffc144c8: 80 1f 00 3c lwz r0,60(r31)
ffc144cc: 2f 80 ff ff cmpwi cr7,r0,-1
ffc144d0: 41 9e 00 0c beq- cr7,ffc144dc <fat_file_extend+0x148> <== NEVER TAKEN
{
old_last_cl = fat_fd->map.last_cln;
ffc144d4: 90 01 00 10 stw r0,16(r1)
ffc144d8: 48 00 00 28 b ffc14500 <fat_file_extend+0x16c>
}
else
{
rc = fat_file_ioctl(mt_entry, fat_fd, F_CLU_NUM,
ffc144dc: 7f a3 eb 78 mr r3,r29 <== NOT EXECUTED
ffc144e0: 7f e4 fb 78 mr r4,r31 <== NOT EXECUTED
ffc144e4: 38 a0 00 01 li r5,1 <== NOT EXECUTED
ffc144e8: 38 c6 ff ff addi r6,r6,-1 <== NOT EXECUTED
ffc144ec: 38 e1 00 10 addi r7,r1,16 <== NOT EXECUTED
ffc144f0: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc144f4: 4b ff fd c9 bl ffc142bc <fat_file_ioctl> <== NOT EXECUTED
(fat_fd->fat_file_size - 1), &old_last_cl);
if ( rc != RC_OK )
ffc144f8: 7c 7a 1b 79 mr. r26,r3 <== NOT EXECUTED
ffc144fc: 40 82 00 1c bne- ffc14518 <fat_file_extend+0x184> <== NOT EXECUTED
fat_free_fat_clusters_chain(mt_entry, chain);
return rc;
}
}
rc = fat_set_fat_cluster(mt_entry, old_last_cl, chain);
ffc14500: 80 81 00 10 lwz r4,16(r1)
ffc14504: 7f a3 eb 78 mr r3,r29
ffc14508: 80 a1 00 14 lwz r5,20(r1)
ffc1450c: 48 00 80 51 bl ffc1c55c <fat_set_fat_cluster>
if ( rc != RC_OK )
ffc14510: 7c 7a 1b 79 mr. r26,r3
ffc14514: 41 a2 00 18 beq+ ffc1452c <fat_file_extend+0x198> <== ALWAYS TAKEN
{
fat_free_fat_clusters_chain(mt_entry, chain);
ffc14518: 80 81 00 14 lwz r4,20(r1) <== NOT EXECUTED
ffc1451c: 7f a3 eb 78 mr r3,r29 <== NOT EXECUTED
return rc;
ffc14520: 7f 5e d3 78 mr r30,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);
ffc14524: 48 00 82 d1 bl ffc1c7f4 <fat_free_fat_clusters_chain> <== NOT EXECUTED
return rc;
ffc14528: 48 00 00 58 b ffc14580 <fat_file_extend+0x1ec> <== NOT EXECUTED
}
fat_buf_release(fs_info);
ffc1452c: 7f 83 e3 78 mr r3,r28
ffc14530: 48 00 06 71 bl ffc14ba0 <fat_buf_release>
}
/* update number of the last cluster of the file if it changed */
if (cls_added != 0)
ffc14534: 80 01 00 08 lwz r0,8(r1)
ffc14538: 2f 80 00 00 cmpwi cr7,r0,0
ffc1453c: 41 9e 00 40 beq- cr7,ffc1457c <fat_file_extend+0x1e8> <== NEVER TAKEN
{
fat_fd->map.last_cln = last_cl;
ffc14540: 80 01 00 0c lwz r0,12(r1)
ffc14544: 90 1f 00 3c stw r0,60(r31)
if (fat_fd->fat_file_type == FAT_DIRECTORY)
ffc14548: 80 1f 00 10 lwz r0,16(r31)
ffc1454c: 2f 80 00 01 cmpwi cr7,r0,1
ffc14550: 40 be 00 2c bne+ cr7,ffc1457c <fat_file_extend+0x1e8>
{
rc = fat_init_clusters_chain(mt_entry, chain);
ffc14554: 80 81 00 14 lwz r4,20(r1)
ffc14558: 7f a3 eb 78 mr r3,r29
ffc1455c: 48 00 09 b5 bl ffc14f10 <fat_init_clusters_chain>
if ( rc != RC_OK )
ffc14560: 7c 7c 1b 79 mr. r28,r3
ffc14564: 41 a2 00 18 beq+ ffc1457c <fat_file_extend+0x1e8> <== ALWAYS TAKEN
{
fat_free_fat_clusters_chain(mt_entry, chain);
ffc14568: 80 81 00 14 lwz r4,20(r1) <== NOT EXECUTED
ffc1456c: 7f a3 eb 78 mr r3,r29 <== NOT EXECUTED
return rc;
ffc14570: 7f 9e e3 78 mr r30,r28 <== 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);
ffc14574: 48 00 82 81 bl ffc1c7f4 <fat_free_fat_clusters_chain> <== NOT EXECUTED
return rc;
ffc14578: 48 00 00 08 b ffc14580 <fat_file_extend+0x1ec> <== NOT EXECUTED
}
}
}
fat_fd->fat_file_size = new_length;
ffc1457c: 93 7f 00 18 stw r27,24(r31)
return RC_OK;
}
ffc14580: 39 61 00 40 addi r11,r1,64
ffc14584: 7f c3 f3 78 mr r3,r30
ffc14588: 4b fe e5 50 b ffc02ad8 <_restgpr_23_x>
ffc142bc <fat_file_ioctl>:
fat_file_ioctl(
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_file_fd_t *fat_fd,
int cmd,
...)
{
ffc142bc: 94 21 ff d0 stwu r1,-48(r1)
ffc142c0: 7c 08 02 a6 mflr r0
uint32_t *ret;
va_list ap;
va_start(ap, cmd);
switch (cmd)
ffc142c4: 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,
...)
{
ffc142c8: 90 01 00 34 stw r0,52(r1)
int rc = RC_OK;
fat_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t cur_cln = 0;
ffc142cc: 38 00 00 00 li r0,0
uint32_t cl_start = 0;
uint32_t pos = 0;
uint32_t *ret;
va_list ap;
va_start(ap, cmd);
ffc142d0: 7c 29 0b 78 mr r9,r1
int cmd,
...)
{
int rc = RC_OK;
fat_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t cur_cln = 0;
ffc142d4: 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);
ffc142d8: 38 00 00 03 li r0,3
ffc142dc: 98 01 00 0c stb r0,12(r1)
ffc142e0: 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,
...)
{
ffc142e4: 90 c1 00 1c stw r6,28(r1)
ffc142e8: 90 e1 00 20 stw r7,32(r1)
ffc142ec: bf c1 00 28 stmw r30,40(r1)
uint32_t cl_start = 0;
uint32_t pos = 0;
uint32_t *ret;
va_list ap;
va_start(ap, cmd);
ffc142f0: 94 09 00 10 stwu r0,16(r9)
fat_file_fd_t *fat_fd,
int cmd,
...)
{
int rc = RC_OK;
fat_fs_info_t *fs_info = mt_entry->fs_info;
ffc142f4: 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);
ffc142f8: 91 21 00 14 stw r9,20(r1)
switch (cmd)
ffc142fc: 40 be 00 80 bne+ cr7,ffc1437c <fat_file_ioctl+0xc0> <== NEVER TAKEN
{
case F_CLU_NUM:
pos = va_arg(ap, uint32_t);
ret = va_arg(ap, uint32_t *);
ffc14300: 3b c0 00 05 li r30,5
va_start(ap, cmd);
switch (cmd)
{
case F_CLU_NUM:
pos = va_arg(ap, uint32_t);
ffc14304: 80 09 00 0c lwz r0,12(r9)
ret = va_arg(ap, uint32_t *);
ffc14308: 9b c1 00 0c stb r30,12(r1)
ffc1430c: 83 e9 00 10 lwz r31,16(r9)
/* sanity check */
if ( pos >= fat_fd->fat_file_size ) {
ffc14310: 81 24 00 18 lwz r9,24(r4)
ffc14314: 7f 80 48 40 cmplw cr7,r0,r9
ffc14318: 41 bc 00 10 blt+ cr7,ffc14328 <fat_file_ioctl+0x6c> <== ALWAYS TAKEN
va_end(ap);
rtems_set_errno_and_return_minus_one( EIO );
ffc1431c: 48 00 9e bd bl ffc1e1d8 <__errno> <== NOT EXECUTED
ffc14320: 93 c3 00 00 stw r30,0(r3) <== NOT EXECUTED
ffc14324: 48 00 00 64 b ffc14388 <fat_file_ioctl+0xcc> <== NOT EXECUTED
}
if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&
ffc14328: 81 24 00 20 lwz r9,32(r4)
ffc1432c: 2f 89 00 01 cmpwi cr7,r9,1
ffc14330: 40 9e 00 28 bne- cr7,ffc14358 <fat_file_ioctl+0x9c>
ffc14334: 81 24 00 24 lwz r9,36(r4)
ffc14338: 2f 89 00 00 cmpwi cr7,r9,0
ffc1433c: 40 9e 00 1c bne- cr7,ffc14358 <fat_file_ioctl+0x9c> <== NEVER TAKEN
(fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))
ffc14340: 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)) &&
ffc14344: 71 48 00 03 andi. r8,r10,3
ffc14348: 41 82 00 10 beq- ffc14358 <fat_file_ioctl+0x9c> <== NEVER TAKEN
(fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))
{
/* cluster 0 (zero) reserved for root dir */
*ret = 0;
ffc1434c: 91 3f 00 00 stw r9,0(r31)
rc = RC_OK;
ffc14350: 38 60 00 00 li r3,0
break;
ffc14354: 48 00 00 38 b ffc1438c <fat_file_ioctl+0xd0>
}
cl_start = pos >> fs_info->vol.bpc_log2;
ffc14358: 88 ab 00 08 lbz r5,8(r11)
rc = fat_file_lseek(mt_entry, fat_fd, cl_start, &cur_cln);
ffc1435c: 38 c1 00 08 addi r6,r1,8
ffc14360: 7c 05 2c 30 srw r5,r0,r5
ffc14364: 4b ff f8 a1 bl ffc13c04 <fat_file_lseek>
if ( rc != RC_OK )
ffc14368: 7c 83 23 79 mr. r3,r4
ffc1436c: 40 82 00 20 bne- ffc1438c <fat_file_ioctl+0xd0> <== NEVER TAKEN
break;
*ret = cur_cln;
ffc14370: 80 01 00 08 lwz r0,8(r1)
ffc14374: 90 1f 00 00 stw r0,0(r31)
break;
ffc14378: 48 00 00 14 b ffc1438c <fat_file_ioctl+0xd0>
default:
errno = EINVAL;
ffc1437c: 48 00 9e 5d bl ffc1e1d8 <__errno> <== NOT EXECUTED
ffc14380: 38 00 00 16 li r0,22 <== NOT EXECUTED
ffc14384: 90 03 00 00 stw r0,0(r3) <== NOT EXECUTED
rc = -1;
ffc14388: 38 60 ff ff li r3,-1 <== NOT EXECUTED
break;
}
va_end(ap);
return rc;
}
ffc1438c: 39 61 00 30 addi r11,r1,48
ffc14390: 4b fe e7 64 b ffc02af4 <_restgpr_30_x>
ffc13c04 <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
)
{
ffc13c04: 94 21 ff d0 stwu r1,-48(r1)
ffc13c08: 7c 08 02 a6 mflr r0
ffc13c0c: 90 01 00 34 stw r0,52(r1)
ffc13c10: bf 41 00 18 stmw r26,24(r1)
ffc13c14: 7c 7d 1b 78 mr r29,r3
ffc13c18: 7c 9f 23 78 mr r31,r4
int rc = RC_OK;
if (file_cln == fat_fd->map.file_cln)
ffc13c1c: 83 44 00 34 lwz r26,52(r4)
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_file_fd_t *fat_fd,
uint32_t file_cln,
uint32_t *disk_cln
)
{
ffc13c20: 7c be 2b 78 mr r30,r5
ffc13c24: 7c db 33 78 mr r27,r6
int rc = RC_OK;
if (file_cln == fat_fd->map.file_cln)
ffc13c28: 7f 85 d0 00 cmpw cr7,r5,r26
ffc13c2c: 40 be 00 10 bne+ cr7,ffc13c3c <fat_file_lseek+0x38> <== NEVER TAKEN
*disk_cln = fat_fd->map.disk_cln;
ffc13c30: 80 04 00 38 lwz r0,56(r4)
ffc13c34: 90 06 00 00 stw r0,0(r6)
ffc13c38: 48 00 00 6c b ffc13ca4 <fat_file_lseek+0xa0>
{
uint32_t cur_cln;
uint32_t count;
uint32_t i;
if (file_cln > fat_fd->map.file_cln)
ffc13c3c: 7f 85 d0 40 cmplw cr7,r5,r26 <== NOT EXECUTED
ffc13c40: 40 9d 00 14 ble- cr7,ffc13c54 <fat_file_lseek+0x50> <== NOT EXECUTED
{
cur_cln = fat_fd->map.disk_cln;
ffc13c44: 80 04 00 38 lwz r0,56(r4) <== NOT EXECUTED
count = file_cln - fat_fd->map.file_cln;
ffc13c48: 7f 5a 28 50 subf r26,r26,r5 <== NOT EXECUTED
uint32_t count;
uint32_t i;
if (file_cln > fat_fd->map.file_cln)
{
cur_cln = fat_fd->map.disk_cln;
ffc13c4c: 90 01 00 08 stw r0,8(r1) <== NOT EXECUTED
ffc13c50: 48 00 00 10 b ffc13c60 <fat_file_lseek+0x5c> <== NOT EXECUTED
count = file_cln - fat_fd->map.file_cln;
}
else
{
cur_cln = fat_fd->cln;
ffc13c54: 80 04 00 1c lwz r0,28(r4) <== NOT EXECUTED
ffc13c58: 7c ba 2b 78 mr r26,r5 <== NOT EXECUTED
ffc13c5c: 90 01 00 08 stw r0,8(r1) <== NOT EXECUTED
count = file_cln;
}
/* skip over the clusters */
for (i = 0; i < count; i++)
ffc13c60: 3b 80 00 00 li r28,0 <== NOT EXECUTED
ffc13c64: 48 00 00 28 b ffc13c8c <fat_file_lseek+0x88> <== NOT EXECUTED
{
rc = fat_get_fat_cluster(mt_entry, cur_cln, &cur_cln);
ffc13c68: 7f a3 eb 78 mr r3,r29 <== NOT EXECUTED
ffc13c6c: 38 a1 00 08 addi r5,r1,8 <== NOT EXECUTED
ffc13c70: 48 00 87 31 bl ffc1c3a0 <fat_get_fat_cluster> <== NOT EXECUTED
if ( rc != RC_OK )
ffc13c74: 2c 03 00 00 cmpwi r3,0 <== NOT EXECUTED
ffc13c78: 41 a2 00 10 beq+ ffc13c88 <fat_file_lseek+0x84> <== NOT EXECUTED
return rc;
ffc13c7c: 7c 6b 1b 78 mr r11,r3 <== NOT EXECUTED
ffc13c80: 7c 6a fe 70 srawi r10,r3,31 <== NOT EXECUTED
ffc13c84: 48 00 00 28 b ffc13cac <fat_file_lseek+0xa8> <== NOT EXECUTED
cur_cln = fat_fd->cln;
count = file_cln;
}
/* skip over the clusters */
for (i = 0; i < count; i++)
ffc13c88: 3b 9c 00 01 addi r28,r28,1 <== NOT EXECUTED
ffc13c8c: 7f 9c d0 00 cmpw cr7,r28,r26 <== NOT EXECUTED
ffc13c90: 80 81 00 08 lwz r4,8(r1) <== NOT EXECUTED
ffc13c94: 40 9e ff d4 bne+ cr7,ffc13c68 <fat_file_lseek+0x64> <== NOT EXECUTED
if ( rc != RC_OK )
return rc;
}
/* update cache */
fat_fd->map.file_cln = file_cln;
ffc13c98: 93 df 00 34 stw r30,52(r31) <== NOT EXECUTED
fat_fd->map.disk_cln = cur_cln;
ffc13c9c: 90 9f 00 38 stw r4,56(r31) <== NOT EXECUTED
*disk_cln = cur_cln;
ffc13ca0: 90 9b 00 00 stw r4,0(r27) <== NOT EXECUTED
}
return RC_OK;
ffc13ca4: 39 40 00 00 li r10,0
ffc13ca8: 39 60 00 00 li r11,0
}
ffc13cac: 7d 64 5b 78 mr r4,r11
ffc13cb0: 39 61 00 30 addi r11,r1,48
ffc13cb4: 7d 43 53 78 mr r3,r10
ffc13cb8: 4b fe ee 2c b ffc02ae4 <_restgpr_26_x>
ffc14788 <fat_file_mark_removed>:
void
fat_file_mark_removed(
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_file_fd_t *fat_fd
)
{
ffc14788: 94 21 ff e8 stwu r1,-24(r1) <== NOT EXECUTED
ffc1478c: 7c 08 02 a6 mflr r0 <== NOT EXECUTED
ffc14790: 90 01 00 1c stw r0,28(r1) <== NOT EXECUTED
ffc14794: bf a1 00 0c stmw r29,12(r1) <== NOT EXECUTED
ffc14798: 7c 9f 23 78 mr r31,r4 <== NOT EXECUTED
fat_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t key = 0;
key = fat_construct_key(mt_entry, &fat_fd->dir_pos.sname);
ffc1479c: 38 84 00 20 addi r4,r4,32 <== NOT EXECUTED
fat_file_mark_removed(
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_file_fd_t *fat_fd
)
{
fat_fs_info_t *fs_info = mt_entry->fs_info;
ffc147a0: 83 c3 00 34 lwz r30,52(r3) <== NOT EXECUTED
uint32_t key = 0;
key = fat_construct_key(mt_entry, &fat_fd->dir_pos.sname);
ffc147a4: 4b ff f5 4d bl ffc13cf0 <fat_construct_key> <== NOT EXECUTED
ffc147a8: 7c 7d 1b 78 mr r29,r3 <== 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);
ffc147ac: 57 bd 07 fe clrlwi r29,r29,31 <== NOT EXECUTED
ffc147b0: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc147b4: 4b ff 82 95 bl ffc0ca48 <_Chain_Extract> <== NOT EXECUTED
ffc147b8: 1f bd 00 0c mulli r29,r29,12 <== NOT EXECUTED
ffc147bc: 80 7e 00 6c lwz r3,108(r30) <== 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 );
ffc147c0: 7f e4 fb 78 mr r4,r31 <== NOT EXECUTED
ffc147c4: 7c 63 ea 14 add r3,r3,r29 <== NOT EXECUTED
ffc147c8: 4b ff 82 51 bl ffc0ca18 <_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;
ffc147cc: 88 1f 00 30 lbz r0,48(r31) <== NOT EXECUTED
}
ffc147d0: 39 61 00 18 addi r11,r1,24 <== 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;
ffc147d4: 60 00 00 01 ori r0,r0,1 <== NOT EXECUTED
ffc147d8: 98 1f 00 30 stb r0,48(r31) <== NOT EXECUTED
}
ffc147dc: 4b fe e3 14 b ffc02af0 <_restgpr_29_x> <== NOT EXECUTED
ffc13ddc <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
)
{
ffc13ddc: 94 21 ff c8 stwu r1,-56(r1)
ffc13de0: 7c 08 02 a6 mflr r0
ffc13de4: bf 21 00 1c stmw r25,28(r1)
int rc = RC_OK;
fat_fs_info_t *fs_info = mt_entry->fs_info;
fat_file_fd_t *lfat_fd = NULL;
ffc13de8: 7c 3f 0b 78 mr r31,r1
fat_file_open(
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_dir_pos_t *dir_pos,
fat_file_fd_t **fat_fd
)
{
ffc13dec: 7c 7d 1b 78 mr r29,r3
ffc13df0: 90 01 00 3c stw r0,60(r1)
int rc = RC_OK;
fat_fs_info_t *fs_info = mt_entry->fs_info;
fat_file_fd_t *lfat_fd = NULL;
ffc13df4: 38 00 00 00 li r0,0
fat_file_open(
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_dir_pos_t *dir_pos,
fat_file_fd_t **fat_fd
)
{
ffc13df8: 7c 99 23 78 mr r25,r4
int rc = RC_OK;
fat_fs_info_t *fs_info = mt_entry->fs_info;
fat_file_fd_t *lfat_fd = NULL;
ffc13dfc: 94 1f 00 08 stwu r0,8(r31)
fat_file_open(
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_dir_pos_t *dir_pos,
fat_file_fd_t **fat_fd
)
{
ffc13e00: 7c bb 2b 78 mr r27,r5
int rc = RC_OK;
fat_fs_info_t *fs_info = mt_entry->fs_info;
ffc13e04: 83 83 00 34 lwz r28,52(r3)
fat_file_fd_t *lfat_fd = NULL;
uint32_t key = 0;
/* construct key */
key = fat_construct_key(mt_entry, &dir_pos->sname);
ffc13e08: 4b ff fe e9 bl ffc13cf0 <fat_construct_key>
ffc13e0c: 7c 7e 1b 78 mr r30,r3
/* access "valid" hash table */
rc = _hash_search(mt_entry, fs_info->vhash, key, 0, &lfat_fd);
ffc13e10: 80 9c 00 68 lwz r4,104(r28)
ffc13e14: 7f a3 eb 78 mr r3,r29
ffc13e18: 7f c5 f3 78 mr r5,r30
ffc13e1c: 38 c0 00 00 li r6,0
ffc13e20: 7f e7 fb 78 mr r7,r31
ffc13e24: 4b ff ff 25 bl ffc13d48 <_hash_search>
if ( rc == RC_OK )
ffc13e28: 2c 03 00 00 cmpwi r3,0
ffc13e2c: 40 82 00 1c bne- ffc13e48 <fat_file_open+0x6c>
{
/* return pointer to fat_file_descriptor allocated before */
(*fat_fd) = lfat_fd;
ffc13e30: 81 21 00 08 lwz r9,8(r1)
lfat_fd->links_num++;
ffc13e34: 81 69 00 08 lwz r11,8(r9)
/* 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;
ffc13e38: 91 3b 00 00 stw r9,0(r27)
lfat_fd->links_num++;
ffc13e3c: 38 0b 00 01 addi r0,r11,1
ffc13e40: 90 09 00 08 stw r0,8(r9)
return rc;
ffc13e44: 48 00 00 d4 b ffc13f18 <fat_file_open+0x13c>
}
/* access "removed-but-still-open" hash table */
rc = _hash_search(mt_entry, fs_info->rhash, key, key, &lfat_fd);
ffc13e48: 80 9c 00 6c lwz r4,108(r28)
ffc13e4c: 7f e7 fb 78 mr r7,r31
ffc13e50: 7f c5 f3 78 mr r5,r30
ffc13e54: 7f c6 f3 78 mr r6,r30
ffc13e58: 7f a3 eb 78 mr r3,r29
ffc13e5c: 4b ff fe ed bl ffc13d48 <_hash_search>
ffc13e60: 7c 7a 1b 78 mr r26,r3
lfat_fd = (*fat_fd) = (fat_file_fd_t*)malloc(sizeof(fat_file_fd_t));
ffc13e64: 38 60 00 44 li r3,68
ffc13e68: 4b ff 41 ed bl ffc08054 <malloc>
if ( lfat_fd == NULL )
ffc13e6c: 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));
ffc13e70: 90 7b 00 00 stw r3,0(r27)
ffc13e74: 7c 7f 1b 78 mr r31,r3
ffc13e78: 90 61 00 08 stw r3,8(r1)
if ( lfat_fd == NULL )
ffc13e7c: 41 9e 00 6c beq- cr7,ffc13ee8 <fat_file_open+0x10c>
rtems_set_errno_and_return_minus_one( ENOMEM );
memset(lfat_fd, 0, sizeof(fat_file_fd_t));
ffc13e80: 38 a0 00 44 li r5,68
ffc13e84: 38 80 00 00 li r4,0
ffc13e88: 48 00 b2 69 bl ffc1f0f0 <memset>
lfat_fd->links_num = 1;
ffc13e8c: 38 00 00 01 li r0,1
ffc13e90: 90 1f 00 08 stw r0,8(r31)
lfat_fd->flags &= ~FAT_FILE_REMOVED;
lfat_fd->map.last_cln = FAT_UNDEFINED_VALUE;
lfat_fd->dir_pos = *dir_pos;
if ( rc != RC_OK )
ffc13e94: 2f 9a 00 00 cmpwi cr7,r26,0
lfat_fd->links_num = 1;
lfat_fd->flags &= ~FAT_FILE_REMOVED;
lfat_fd->map.last_cln = FAT_UNDEFINED_VALUE;
lfat_fd->dir_pos = *dir_pos;
ffc13e98: 39 3f 00 20 addi r9,r31,32
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;
ffc13e9c: 88 1f 00 30 lbz r0,48(r31)
ffc13ea0: 54 00 00 3c rlwinm r0,r0,0,0,30
ffc13ea4: 98 1f 00 30 stb r0,48(r31)
lfat_fd->map.last_cln = FAT_UNDEFINED_VALUE;
ffc13ea8: 38 00 ff ff li r0,-1
ffc13eac: 90 1f 00 3c stw r0,60(r31)
lfat_fd->dir_pos = *dir_pos;
ffc13eb0: 7c b9 84 aa lswi r5,r25,16
ffc13eb4: 7c a9 85 aa stswi r5,r9,16
if ( rc != RC_OK )
ffc13eb8: 41 9e 00 0c beq- cr7,ffc13ec4 <fat_file_open+0xe8> <== NEVER TAKEN
lfat_fd->ino = key;
ffc13ebc: 93 df 00 0c stw r30,12(r31)
ffc13ec0: 48 00 00 3c b ffc13efc <fat_file_open+0x120>
else
{
lfat_fd->ino = fat_get_unique_ino(mt_entry);
ffc13ec4: 7f a3 eb 78 mr r3,r29 <== NOT EXECUTED
ffc13ec8: 48 00 11 01 bl ffc14fc8 <fat_get_unique_ino> <== NOT EXECUTED
if ( lfat_fd->ino == 0 )
ffc13ecc: 81 21 00 08 lwz r9,8(r1) <== NOT EXECUTED
if ( rc != RC_OK )
lfat_fd->ino = key;
else
{
lfat_fd->ino = fat_get_unique_ino(mt_entry);
ffc13ed0: 90 7f 00 0c stw r3,12(r31) <== NOT EXECUTED
if ( lfat_fd->ino == 0 )
ffc13ed4: 80 09 00 0c lwz r0,12(r9) <== NOT EXECUTED
ffc13ed8: 2f 80 00 00 cmpwi cr7,r0,0 <== NOT EXECUTED
ffc13edc: 40 be 00 20 bne+ cr7,ffc13efc <fat_file_open+0x120> <== NOT EXECUTED
{
free((*fat_fd));
ffc13ee0: 80 7b 00 00 lwz r3,0(r27) <== NOT EXECUTED
ffc13ee4: 4b ff 3a 05 bl ffc078e8 <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 );
ffc13ee8: 48 00 a2 f1 bl ffc1e1d8 <__errno>
ffc13eec: 38 00 00 0c li r0,12
ffc13ef0: 90 03 00 00 stw r0,0(r3)
ffc13ef4: 38 60 ff ff li r3,-1
ffc13ef8: 48 00 00 20 b ffc13f18 <fat_file_open+0x13c>
*/
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);
ffc13efc: 57 de 07 fe clrlwi r30,r30,31
ffc13f00: 80 7c 00 68 lwz r3,104(r28)
ffc13f04: 1f de 00 0c mulli r30,r30,12
ffc13f08: 80 81 00 08 lwz r4,8(r1)
ffc13f0c: 7c 63 f2 14 add r3,r3,r30
ffc13f10: 4b ff 8b 09 bl ffc0ca18 <_Chain_Append>
/*
* other fields of fat-file descriptor will be initialized on upper
* level
*/
return RC_OK;
ffc13f14: 38 60 00 00 li r3,0
}
ffc13f18: 39 61 00 38 addi r11,r1,56
ffc13f1c: 4b fe eb c4 b ffc02ae0 <_restgpr_25_x>
ffc13f34 <fat_file_read>:
fat_file_fd_t *fat_fd,
uint32_t start,
uint32_t count,
uint8_t *buf
)
{
ffc13f34: 94 21 ff b8 stwu r1,-72(r1)
ffc13f38: 7c 08 02 a6 mflr r0
ffc13f3c: be a1 00 1c stmw r21,28(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)
ffc13f40: 7c de 33 79 mr. r30,r6
fat_file_fd_t *fat_fd,
uint32_t start,
uint32_t count,
uint8_t *buf
)
{
ffc13f44: 7c 7b 1b 78 mr r27,r3
ffc13f48: 90 01 00 4c stw r0,76(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;
ffc13f4c: 38 00 00 00 li r0,0
fat_file_fd_t *fat_fd,
uint32_t start,
uint32_t count,
uint8_t *buf
)
{
ffc13f50: 7c 9d 23 78 mr r29,r4
int rc = RC_OK;
ssize_t ret = 0;
fat_fs_info_t *fs_info = mt_entry->fs_info;
ffc13f54: 83 e3 00 34 lwz r31,52(r3)
fat_file_fd_t *fat_fd,
uint32_t start,
uint32_t count,
uint8_t *buf
)
{
ffc13f58: 7c bc 2b 78 mr r28,r5
ffc13f5c: 7c f7 3b 78 mr r23,r7
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;
ffc13f60: 90 01 00 08 stw r0,8(r1)
uint32_t byte = 0;
uint32_t c = 0;
/* it couldn't be removed - otherwise cache update will be broken */
if (count == 0)
return cmpltd;
ffc13f64: 38 60 00 00 li r3,0
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)
ffc13f68: 41 82 01 7c beq- ffc140e4 <fat_file_read+0x1b0> <== NEVER TAKEN
/*
* >= because start is offset and computed from 0 and file_size
* computed from 1
*/
if ( start >= fat_fd->fat_file_size )
ffc13f6c: 81 24 00 18 lwz r9,24(r4)
ffc13f70: 7f 85 48 40 cmplw cr7,r5,r9
ffc13f74: 40 9c 01 70 bge- cr7,ffc140e4 <fat_file_read+0x1b0> <== NEVER TAKEN
return FAT_EOF;
if ((count > fat_fd->fat_file_size) ||
ffc13f78: 7f 9e 48 40 cmplw cr7,r30,r9
ffc13f7c: 41 9d 00 10 bgt- cr7,ffc13f8c <fat_file_read+0x58> <== NEVER TAKEN
(start > fat_fd->fat_file_size - count))
ffc13f80: 7c 1e 48 50 subf r0,r30,r9
* computed from 1
*/
if ( start >= fat_fd->fat_file_size )
return FAT_EOF;
if ((count > fat_fd->fat_file_size) ||
ffc13f84: 7f 85 00 40 cmplw cr7,r5,r0
ffc13f88: 40 9d 00 08 ble- cr7,ffc13f90 <fat_file_read+0x5c> <== ALWAYS TAKEN
(start > fat_fd->fat_file_size - count))
count = fat_fd->fat_file_size - start;
ffc13f8c: 7f dc 48 50 subf r30,r28,r9 <== NOT EXECUTED
if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&
ffc13f90: 80 1d 00 20 lwz r0,32(r29)
ffc13f94: 2f 80 00 01 cmpwi cr7,r0,1
ffc13f98: 40 9e 00 5c bne- cr7,ffc13ff4 <fat_file_read+0xc0>
ffc13f9c: 80 1d 00 24 lwz r0,36(r29)
ffc13fa0: 2f 80 00 00 cmpwi cr7,r0,0
ffc13fa4: 40 9e 00 50 bne- cr7,ffc13ff4 <fat_file_read+0xc0> <== NEVER TAKEN
(fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))
ffc13fa8: 88 1f 00 0a lbz r0,10(r31)
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)) &&
ffc13fac: 70 09 00 03 andi. r9,r0,3
ffc13fb0: 41 a2 00 44 beq+ ffc13ff4 <fat_file_read+0xc0> <== NEVER TAKEN
(fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))
{
sec = fat_cluster_num_to_sector_num(mt_entry, fat_fd->cln);
ffc13fb4: 80 9d 00 1c lwz r4,28(r29)
ffc13fb8: 7f e3 fb 78 mr r3,r31
ffc13fbc: 4b ff fd 01 bl ffc13cbc <fat_cluster_num_to_sector_num.isra.0>
sec += (start >> fs_info->vol.sec_log2);
ffc13fc0: 88 9f 00 02 lbz r4,2(r31)
byte = start & (fs_info->vol.bps - 1);
ffc13fc4: a0 bf 00 00 lhz r5,0(r31)
ret = _fat_block_read(mt_entry, sec, byte, count, buf);
ffc13fc8: 7f c6 f3 78 mr r6,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);
ffc13fcc: 7f 84 24 30 srw r4,r28,r4
byte = start & (fs_info->vol.bps - 1);
ffc13fd0: 38 a5 ff ff addi r5,r5,-1
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);
ffc13fd4: 7c 83 22 14 add r4,r3,r4
byte = start & (fs_info->vol.bps - 1);
ret = _fat_block_read(mt_entry, sec, byte, count, buf);
ffc13fd8: 7f 85 28 38 and r5,r28,r5
ffc13fdc: 7f 63 db 78 mr r3,r27
ffc13fe0: 7e e7 bb 78 mr r7,r23
ffc13fe4: 48 00 0d 11 bl ffc14cf4 <_fat_block_read>
if ( ret < 0 )
ffc13fe8: 2c 03 00 00 cmpwi r3,0
ffc13fec: 40 a0 00 f8 bge+ ffc140e4 <fat_file_read+0x1b0> <== ALWAYS TAKEN
ffc13ff0: 48 00 00 f0 b ffc140e0 <fat_file_read+0x1ac> <== NOT EXECUTED
return -1;
return ret;
}
cl_start = start >> fs_info->vol.bpc_log2;
ffc13ff4: 8b 1f 00 08 lbz r24,8(r31)
save_ofs = ofs = start & (fs_info->vol.bpc - 1);
rc = fat_file_lseek(mt_entry, fat_fd, cl_start, &cur_cln);
ffc13ff8: 3a c1 00 08 addi r22,r1,8
ffc13ffc: 7f 63 db 78 mr r3,r27
return ret;
}
cl_start = start >> fs_info->vol.bpc_log2;
save_ofs = ofs = start & (fs_info->vol.bpc - 1);
ffc14000: a3 3f 00 06 lhz r25,6(r31)
return -1;
return ret;
}
cl_start = start >> fs_info->vol.bpc_log2;
ffc14004: 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);
ffc14008: 7f a4 eb 78 mr r4,r29
ffc1400c: 7f 05 c3 78 mr r5,r24
ffc14010: 7e c6 b3 78 mr r6,r22
ffc14014: 4b ff fb f1 bl ffc13c04 <fat_file_lseek>
if (rc != RC_OK)
ffc14018: 2f 84 00 00 cmpwi cr7,r4,0
ffc1401c: 7c 83 23 78 mr r3,r4
ffc14020: 40 9e 00 c4 bne- cr7,ffc140e4 <fat_file_read+0x1b0> <== NEVER TAKEN
return ret;
}
cl_start = start >> fs_info->vol.bpc_log2;
save_ofs = ofs = start & (fs_info->vol.bpc - 1);
ffc14024: 3b 39 ff ff addi r25,r25,-1
ffc14028: 7f 9c c8 38 and r28,r28,r25
ffc1402c: 7f 95 e3 78 mr r21,r28
ffc14030: 3b 20 00 00 li r25,0
ffc14034: 3b 40 00 00 li r26,0
ffc14038: 48 00 00 7c b ffc140b4 <fat_file_read+0x180>
if (rc != RC_OK)
return rc;
while (count > 0)
{
c = MIN(count, (fs_info->vol.bpc - ofs));
ffc1403c: a3 3f 00 06 lhz r25,6(r31)
ffc14040: 7f 35 c8 50 subf r25,r21,r25
ffc14044: 7f 99 f0 40 cmplw cr7,r25,r30
ffc14048: 40 9d 00 08 ble- cr7,ffc14050 <fat_file_read+0x11c>
ffc1404c: 7f d9 f3 78 mr r25,r30
sec = fat_cluster_num_to_sector_num(mt_entry, cur_cln);
ffc14050: 80 81 00 08 lwz r4,8(r1)
ffc14054: 80 7b 00 34 lwz r3,52(r27)
ffc14058: 4b ff fc 65 bl ffc13cbc <fat_cluster_num_to_sector_num.isra.0>
sec += (ofs >> fs_info->vol.sec_log2);
ffc1405c: 88 9f 00 02 lbz r4,2(r31)
byte = ofs & (fs_info->vol.bps - 1);
ffc14060: a0 bf 00 00 lhz r5,0(r31)
ret = _fat_block_read(mt_entry, sec, byte, c, buf + cmpltd);
ffc14064: 7f 26 cb 78 mr r6,r25
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);
ffc14068: 7e a4 24 30 srw r4,r21,r4
byte = ofs & (fs_info->vol.bps - 1);
ffc1406c: 38 a5 ff ff addi r5,r5,-1
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);
ffc14070: 7c 83 22 14 add r4,r3,r4
byte = ofs & (fs_info->vol.bps - 1);
ret = _fat_block_read(mt_entry, sec, byte, c, buf + cmpltd);
ffc14074: 7e a5 28 38 and r5,r21,r5
ffc14078: 7f 63 db 78 mr r3,r27
ffc1407c: 7c f7 d2 14 add r7,r23,r26
ffc14080: 48 00 0c 75 bl ffc14cf4 <_fat_block_read>
if ( ret < 0 )
ffc14084: 2f 83 00 00 cmpwi cr7,r3,0
ffc14088: 41 9c 00 58 blt- cr7,ffc140e0 <fat_file_read+0x1ac> <== NEVER TAKEN
return -1;
count -= c;
ffc1408c: 7f d9 f0 50 subf r30,r25,r30
cmpltd += c;
ffc14090: 7f 5a ca 14 add r26,r26,r25
save_cln = cur_cln;
ffc14094: 83 21 00 08 lwz r25,8(r1)
rc = fat_get_fat_cluster(mt_entry, cur_cln, &cur_cln);
ffc14098: 7f 63 db 78 mr r3,r27
ffc1409c: 7f 24 cb 78 mr r4,r25
ffc140a0: 7e c5 b3 78 mr r5,r22
ffc140a4: 48 00 82 fd bl ffc1c3a0 <fat_get_fat_cluster>
if ( rc != RC_OK )
ffc140a8: 2c 03 00 00 cmpwi r3,0
ffc140ac: 40 82 00 38 bne- ffc140e4 <fat_file_read+0x1b0> <== NEVER TAKEN
return rc;
ofs = 0;
ffc140b0: 3a a0 00 00 li r21,0
rc = fat_file_lseek(mt_entry, fat_fd, cl_start, &cur_cln);
if (rc != RC_OK)
return rc;
while (count > 0)
ffc140b4: 2f 9e 00 00 cmpwi cr7,r30,0
ffc140b8: 40 9e ff 84 bne+ cr7,ffc1403c <fat_file_read+0x108>
}
/* 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);
ffc140bc: 88 1f 00 08 lbz r0,8(r31)
ffc140c0: 3b 9c ff ff addi r28,r28,-1
ffc140c4: 7f 9c d2 14 add r28,r28,r26
fat_fd->map.disk_cln = save_cln;
ffc140c8: 93 3d 00 38 stw r25,56(r29)
}
/* 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);
ffc140cc: 7f 9c 04 30 srw r28,r28,r0
ofs = 0;
}
/* update cache */
/* XXX: check this - I'm not sure :( */
fat_fd->map.file_cln = cl_start +
ffc140d0: 7f 1c c2 14 add r24,r28,r24
ffc140d4: 93 1d 00 34 stw r24,52(r29)
((save_ofs + cmpltd - 1) >> fs_info->vol.bpc_log2);
fat_fd->map.disk_cln = save_cln;
return cmpltd;
ffc140d8: 7f 43 d3 78 mr r3,r26
ffc140dc: 48 00 00 08 b ffc140e4 <fat_file_read+0x1b0>
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;
ffc140e0: 38 60 ff ff li r3,-1 <== NOT EXECUTED
fat_fd->map.file_cln = cl_start +
((save_ofs + cmpltd - 1) >> fs_info->vol.bpc_log2);
fat_fd->map.disk_cln = save_cln;
return cmpltd;
}
ffc140e4: 39 61 00 48 addi r11,r1,72
ffc140e8: 4b fe e9 e8 b ffc02ad0 <_restgpr_21_x>
ffc148d4 <fat_file_size>:
int
fat_file_size(
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_file_fd_t *fat_fd
)
{
ffc148d4: 94 21 ff d8 stwu r1,-40(r1)
ffc148d8: 7c 08 02 a6 mflr r0
ffc148dc: 90 01 00 2c stw r0,44(r1)
int rc = RC_OK;
fat_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t cur_cln = fat_fd->cln;
ffc148e0: 80 04 00 1c lwz r0,28(r4)
int
fat_file_size(
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_file_fd_t *fat_fd
)
{
ffc148e4: bf 81 00 18 stmw r28,24(r1)
ffc148e8: 7c 7c 1b 78 mr r28,r3
ffc148ec: 7c 9f 23 78 mr r31,r4
int rc = RC_OK;
fat_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t cur_cln = fat_fd->cln;
ffc148f0: 90 01 00 08 stw r0,8(r1)
uint32_t save_cln = 0;
/* Have we requested root dir size for FAT12/16? */
if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&
ffc148f4: 80 04 00 20 lwz r0,32(r4)
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;
ffc148f8: 83 c3 00 34 lwz r30,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)) &&
ffc148fc: 2f 80 00 01 cmpwi cr7,r0,1
ffc14900: 40 be 00 28 bne+ cr7,ffc14928 <fat_file_size+0x54> <== ALWAYS TAKEN
ffc14904: 80 04 00 24 lwz r0,36(r4) <== NOT EXECUTED
ffc14908: 2f 80 00 00 cmpwi cr7,r0,0 <== NOT EXECUTED
ffc1490c: 40 9e 00 1c bne- cr7,ffc14928 <fat_file_size+0x54> <== NOT EXECUTED
(fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))
ffc14910: 88 1e 00 0a lbz r0,10(r30) <== 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)) &&
ffc14914: 70 09 00 03 andi. r9,r0,3 <== NOT EXECUTED
ffc14918: 41 a2 00 10 beq+ ffc14928 <fat_file_size+0x54> <== NOT EXECUTED
(fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))
{
fat_fd->fat_file_size = fs_info->vol.rdir_size;
ffc1491c: 80 1e 00 28 lwz r0,40(r30) <== NOT EXECUTED
ffc14920: 90 04 00 18 stw r0,24(r4) <== NOT EXECUTED
ffc14924: 48 00 00 58 b ffc1497c <fat_file_size+0xa8> <== NOT EXECUTED
return rc;
}
fat_fd->fat_file_size = 0;
ffc14928: 38 00 00 00 li r0,0
ffc1492c: 90 1f 00 18 stw r0,24(r31)
while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)
ffc14930: 48 00 00 30 b ffc14960 <fat_file_size+0x8c>
{
save_cln = cur_cln;
rc = fat_get_fat_cluster(mt_entry, cur_cln, &cur_cln);
ffc14934: 7f 83 e3 78 mr r3,r28
ffc14938: 7f a4 eb 78 mr r4,r29
ffc1493c: 38 a1 00 08 addi r5,r1,8
ffc14940: 48 00 7a 61 bl ffc1c3a0 <fat_get_fat_cluster>
if ( rc != RC_OK )
ffc14944: 2c 03 00 00 cmpwi r3,0
ffc14948: 40 82 00 38 bne- ffc14980 <fat_file_size+0xac> <== NEVER TAKEN
return rc;
fat_fd->fat_file_size += fs_info->vol.bpc;
ffc1494c: a0 1e 00 06 lhz r0,6(r30)
ffc14950: 81 3f 00 18 lwz r9,24(r31)
ffc14954: 7c 09 02 14 add r0,r9,r0
ffc14958: 90 1f 00 18 stw r0,24(r31)
fat_fd->fat_file_size = 0;
while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)
{
save_cln = cur_cln;
ffc1495c: 7f a0 eb 78 mr r0,r29
return rc;
}
fat_fd->fat_file_size = 0;
while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)
ffc14960: 83 a1 00 08 lwz r29,8(r1)
ffc14964: 81 7e 00 0c lwz r11,12(r30)
ffc14968: 81 3e 00 10 lwz r9,16(r30)
ffc1496c: 7f ab 58 38 and r11,r29,r11
ffc14970: 7f 8b 48 40 cmplw cr7,r11,r9
ffc14974: 41 9c ff c0 blt+ cr7,ffc14934 <fat_file_size+0x60>
if ( rc != RC_OK )
return rc;
fat_fd->fat_file_size += fs_info->vol.bpc;
}
fat_fd->map.last_cln = save_cln;
ffc14978: 90 1f 00 3c stw r0,60(r31)
return rc;
ffc1497c: 38 60 00 00 li r3,0
}
ffc14980: 39 61 00 28 addi r11,r1,40
ffc14984: 4b fe e1 68 b ffc02aec <_restgpr_28_x>
ffc140ec <fat_file_truncate>:
fat_file_truncate(
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_file_fd_t *fat_fd,
uint32_t new_length
)
{
ffc140ec: 94 21 ff d8 stwu r1,-40(r1)
ffc140f0: 7c 08 02 a6 mflr r0
ffc140f4: 90 01 00 2c stw r0,44(r1)
int rc = RC_OK;
fat_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t cur_cln = 0;
ffc140f8: 38 00 00 00 li r0,0
uint32_t cl_start = 0;
uint32_t new_last_cln = FAT_UNDEFINED_VALUE;
if ( new_length >= fat_fd->fat_file_size )
ffc140fc: 81 24 00 18 lwz r9,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;
ffc14100: 90 01 00 0c stw r0,12(r1)
uint32_t cl_start = 0;
uint32_t new_last_cln = FAT_UNDEFINED_VALUE;
ffc14104: 38 00 ff ff li r0,-1
if ( new_length >= fat_fd->fat_file_size )
ffc14108: 7f 85 48 40 cmplw cr7,r5,r9
fat_file_truncate(
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_file_fd_t *fat_fd,
uint32_t new_length
)
{
ffc1410c: bf a1 00 1c stmw r29,28(r1)
ffc14110: 7c 7d 1b 78 mr r29,r3
ffc14114: 7c 9e 23 78 mr r30,r4
int rc = RC_OK;
fat_fs_info_t *fs_info = mt_entry->fs_info;
ffc14118: 81 63 00 34 lwz r11,52(r3)
uint32_t cur_cln = 0;
uint32_t cl_start = 0;
uint32_t new_last_cln = FAT_UNDEFINED_VALUE;
ffc1411c: 90 01 00 08 stw r0,8(r1)
if ( new_length >= fat_fd->fat_file_size )
ffc14120: 40 9c 00 d4 bge- cr7,ffc141f4 <fat_file_truncate+0x108> <== NEVER TAKEN
return rc;
assert(fat_fd->fat_file_size);
ffc14124: 2f 89 00 00 cmpwi cr7,r9,0
ffc14128: 40 be 00 24 bne+ cr7,ffc1414c <fat_file_truncate+0x60> <== ALWAYS TAKEN
ffc1412c: 3c 60 ff c3 lis r3,-61 <== NOT EXECUTED
ffc14130: 3c a0 ff c3 lis r5,-61 <== NOT EXECUTED
ffc14134: 3c c0 ff c3 lis r6,-61 <== NOT EXECUTED
ffc14138: 38 63 ee d6 addi r3,r3,-4394 <== NOT EXECUTED
ffc1413c: 38 80 02 6d li r4,621 <== NOT EXECUTED
ffc14140: 38 a5 ee c4 addi r5,r5,-4412 <== NOT EXECUTED
ffc14144: 38 c6 ef 1e addi r6,r6,-4322 <== NOT EXECUTED
ffc14148: 4b ff 31 39 bl ffc07280 <__assert_func> <== NOT EXECUTED
cl_start = (new_length + fs_info->vol.bpc - 1) >> fs_info->vol.bpc_log2;
ffc1414c: a3 eb 00 06 lhz r31,6(r11)
ffc14150: 88 0b 00 08 lbz r0,8(r11)
ffc14154: 3b ff ff ff addi r31,r31,-1
ffc14158: 7f ff 2a 14 add r31,r31,r5
ffc1415c: 7f ff 04 30 srw r31,r31,r0
if ((cl_start << fs_info->vol.bpc_log2) >= fat_fd->fat_file_size)
ffc14160: 7f eb 00 30 slw r11,r31,r0
ffc14164: 7f 8b 48 40 cmplw cr7,r11,r9
return RC_OK;
ffc14168: 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)
ffc1416c: 40 9c 00 8c bge- cr7,ffc141f8 <fat_file_truncate+0x10c> <== NEVER TAKEN
return RC_OK;
if (cl_start != 0)
ffc14170: 2f 9f 00 00 cmpwi cr7,r31,0
ffc14174: 41 9e 00 18 beq- cr7,ffc1418c <fat_file_truncate+0xa0> <== ALWAYS TAKEN
{
rc = fat_file_lseek(mt_entry, fat_fd, cl_start - 1, &new_last_cln);
ffc14178: 38 bf ff ff addi r5,r31,-1 <== NOT EXECUTED
ffc1417c: 38 c1 00 08 addi r6,r1,8 <== NOT EXECUTED
ffc14180: 4b ff fa 85 bl ffc13c04 <fat_file_lseek> <== NOT EXECUTED
if (rc != RC_OK)
ffc14184: 7c 80 23 79 mr. r0,r4 <== NOT EXECUTED
ffc14188: 40 82 00 70 bne- ffc141f8 <fat_file_truncate+0x10c> <== NOT EXECUTED
return rc;
}
rc = fat_file_lseek(mt_entry, fat_fd, cl_start, &cur_cln);
ffc1418c: 7f a3 eb 78 mr r3,r29
ffc14190: 7f c4 f3 78 mr r4,r30
ffc14194: 7f e5 fb 78 mr r5,r31
ffc14198: 38 c1 00 0c addi r6,r1,12
ffc1419c: 4b ff fa 69 bl ffc13c04 <fat_file_lseek>
if (rc != RC_OK)
ffc141a0: 7c 80 23 79 mr. r0,r4
ffc141a4: 40 a2 00 54 bne+ ffc141f8 <fat_file_truncate+0x10c> <== NEVER TAKEN
return rc;
rc = fat_free_fat_clusters_chain(mt_entry, cur_cln);
ffc141a8: 80 81 00 0c lwz r4,12(r1)
ffc141ac: 7f a3 eb 78 mr r3,r29
ffc141b0: 48 00 86 45 bl ffc1c7f4 <fat_free_fat_clusters_chain>
if (rc != RC_OK)
ffc141b4: 7c 60 1b 79 mr. r0,r3
ffc141b8: 40 82 00 40 bne- ffc141f8 <fat_file_truncate+0x10c> <== NEVER TAKEN
return rc;
if (cl_start != 0)
ffc141bc: 2f 9f 00 00 cmpwi cr7,r31,0
ffc141c0: 41 be 00 38 beq+ cr7,ffc141f8 <fat_file_truncate+0x10c> <== ALWAYS TAKEN
{
rc = fat_set_fat_cluster(mt_entry, new_last_cln, FAT_GENFAT_EOC);
ffc141c4: 80 81 00 08 lwz r4,8(r1) <== NOT EXECUTED
ffc141c8: 7f a3 eb 78 mr r3,r29 <== NOT EXECUTED
ffc141cc: 38 a0 ff ff li r5,-1 <== NOT EXECUTED
ffc141d0: 48 00 83 8d bl ffc1c55c <fat_set_fat_cluster> <== NOT EXECUTED
if ( rc != RC_OK )
ffc141d4: 7c 60 1b 79 mr. r0,r3 <== NOT EXECUTED
ffc141d8: 40 82 00 20 bne- ffc141f8 <fat_file_truncate+0x10c> <== NOT EXECUTED
return rc;
fat_fd->map.file_cln = cl_start - 1;
fat_fd->map.disk_cln = new_last_cln;
ffc141dc: 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;
ffc141e0: 3b ff ff ff addi r31,r31,-1 <== NOT EXECUTED
ffc141e4: 93 fe 00 34 stw r31,52(r30) <== NOT EXECUTED
fat_fd->map.disk_cln = new_last_cln;
ffc141e8: 91 3e 00 38 stw r9,56(r30) <== NOT EXECUTED
fat_fd->map.last_cln = new_last_cln;
ffc141ec: 91 3e 00 3c stw r9,60(r30) <== NOT EXECUTED
ffc141f0: 48 00 00 08 b ffc141f8 <fat_file_truncate+0x10c> <== NOT EXECUTED
uint32_t cl_start = 0;
uint32_t new_last_cln = FAT_UNDEFINED_VALUE;
if ( new_length >= fat_fd->fat_file_size )
return rc;
ffc141f4: 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;
}
ffc141f8: 39 61 00 28 addi r11,r1,40
ffc141fc: 7c 03 03 78 mr r3,r0
ffc14200: 4b fe e8 f0 b ffc02af0 <_restgpr_29_x>
ffc1458c <fat_file_write>:
fat_file_fd_t *fat_fd,
uint32_t start,
uint32_t count,
const uint8_t *buf
)
{
ffc1458c: 94 21 ff b8 stwu r1,-72(r1)
ffc14590: 7c 08 02 a6 mflr r0
ffc14594: be a1 00 1c stmw r21,28(r1)
uint32_t save_ofs;
uint32_t sec = 0;
uint32_t byte = 0;
uint32_t c = 0;
if ( count == 0 )
ffc14598: 7c df 33 79 mr. r31,r6
fat_file_fd_t *fat_fd,
uint32_t start,
uint32_t count,
const uint8_t *buf
)
{
ffc1459c: 7c 7b 1b 78 mr r27,r3
ffc145a0: 90 01 00 4c stw r0,76(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;
ffc145a4: 38 00 00 00 li r0,0
fat_file_fd_t *fat_fd,
uint32_t start,
uint32_t count,
const uint8_t *buf
)
{
ffc145a8: 7c 9d 23 78 mr r29,r4
ffc145ac: 7c bc 2b 78 mr r28,r5
int rc = 0;
ssize_t ret = 0;
fat_fs_info_t *fs_info = mt_entry->fs_info;
ffc145b0: 83 c3 00 34 lwz r30,52(r3)
fat_file_fd_t *fat_fd,
uint32_t start,
uint32_t count,
const uint8_t *buf
)
{
ffc145b4: 7c f8 3b 78 mr r24,r7
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;
ffc145b8: 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;
ffc145bc: 90 01 00 08 stw r0,8(r1)
if ( count == 0 )
ffc145c0: 41 82 01 bc beq- ffc1477c <fat_file_write+0x1f0> <== NEVER TAKEN
return cmpltd;
if ( start > fat_fd->fat_file_size )
ffc145c4: 80 04 00 18 lwz r0,24(r4)
ffc145c8: 7f 85 00 40 cmplw cr7,r5,r0
ffc145cc: 41 9d 00 1c bgt- cr7,ffc145e8 <fat_file_write+0x5c> <== NEVER TAKEN
rtems_set_errno_and_return_minus_one( EIO );
if ((count > fat_fd->size_limit) ||
ffc145d0: 80 04 00 14 lwz r0,20(r4)
ffc145d4: 7f 9f 00 40 cmplw cr7,r31,r0
ffc145d8: 41 9d 00 10 bgt- cr7,ffc145e8 <fat_file_write+0x5c> <== NEVER TAKEN
(start > fat_fd->size_limit - count))
ffc145dc: 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) ||
ffc145e0: 7f 85 00 40 cmplw cr7,r5,r0
ffc145e4: 40 bd 00 14 ble+ cr7,ffc145f8 <fat_file_write+0x6c> <== ALWAYS TAKEN
(start > fat_fd->size_limit - count))
rtems_set_errno_and_return_minus_one( EIO );
ffc145e8: 48 00 9b f1 bl ffc1e1d8 <__errno> <== NOT EXECUTED
ffc145ec: 38 00 00 05 li r0,5 <== NOT EXECUTED
ffc145f0: 90 03 00 00 stw r0,0(r3) <== NOT EXECUTED
ffc145f4: 48 00 01 84 b ffc14778 <fat_file_write+0x1ec> <== NOT EXECUTED
rc = fat_file_extend(mt_entry, fat_fd, start + count, &c);
ffc145f8: 7f 5f 2a 14 add r26,r31,r5
ffc145fc: 7f 45 d3 78 mr r5,r26
ffc14600: 38 c1 00 08 addi r6,r1,8
ffc14604: 4b ff fd 91 bl ffc14394 <fat_file_extend>
if (rc != RC_OK)
ffc14608: 7c 60 1b 79 mr. r0,r3
ffc1460c: 40 82 01 70 bne- ffc1477c <fat_file_write+0x1f0> <== NEVER TAKEN
/*
* check whether there was enough room on device to locate
* file of 'start + count' bytes
*/
if (c != (start + count))
ffc14610: 80 01 00 08 lwz r0,8(r1)
ffc14614: 7f 80 d0 00 cmpw cr7,r0,r26
ffc14618: 41 9e 00 08 beq- cr7,ffc14620 <fat_file_write+0x94> <== ALWAYS TAKEN
count = c - start;
ffc1461c: 7f fc 00 50 subf r31,r28,r0 <== NOT EXECUTED
if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&
ffc14620: 80 1d 00 20 lwz r0,32(r29)
ffc14624: 2f 80 00 01 cmpwi cr7,r0,1
ffc14628: 40 9e 00 5c bne- cr7,ffc14684 <fat_file_write+0xf8>
ffc1462c: 80 1d 00 24 lwz r0,36(r29)
ffc14630: 2f 80 00 00 cmpwi cr7,r0,0
ffc14634: 40 9e 00 50 bne- cr7,ffc14684 <fat_file_write+0xf8> <== NEVER TAKEN
(fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))
ffc14638: 88 1e 00 0a lbz r0,10(r30)
* file of 'start + count' bytes
*/
if (c != (start + count))
count = c - start;
if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&
ffc1463c: 70 09 00 03 andi. r9,r0,3
ffc14640: 41 a2 00 44 beq+ ffc14684 <fat_file_write+0xf8> <== NEVER TAKEN
(fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))
{
sec = fat_cluster_num_to_sector_num(mt_entry, fat_fd->cln);
ffc14644: 80 9d 00 1c lwz r4,28(r29)
ffc14648: 80 7b 00 34 lwz r3,52(r27)
ffc1464c: 4b ff f6 71 bl ffc13cbc <fat_cluster_num_to_sector_num.isra.0>
sec += (start >> fs_info->vol.sec_log2);
ffc14650: 88 9e 00 02 lbz r4,2(r30)
byte = start & (fs_info->vol.bps - 1);
ffc14654: a0 be 00 00 lhz r5,0(r30)
ret = _fat_block_write(mt_entry, sec, byte, count, buf);
ffc14658: 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);
ffc1465c: 7f 84 24 30 srw r4,r28,r4
byte = start & (fs_info->vol.bps - 1);
ffc14660: 38 a5 ff ff addi r5,r5,-1
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);
ffc14664: 7c 83 22 14 add r4,r3,r4
byte = start & (fs_info->vol.bps - 1);
ret = _fat_block_write(mt_entry, sec, byte, count, buf);
ffc14668: 7f 85 28 38 and r5,r28,r5
ffc1466c: 7f 63 db 78 mr r3,r27
ffc14670: 7f 07 c3 78 mr r7,r24
ffc14674: 48 00 07 2d bl ffc14da0 <_fat_block_write>
if ( ret < 0 )
ffc14678: 7c 60 1b 79 mr. r0,r3
ffc1467c: 40 a0 01 00 bge+ ffc1477c <fat_file_write+0x1f0> <== ALWAYS TAKEN
ffc14680: 48 00 00 f8 b ffc14778 <fat_file_write+0x1ec> <== NOT EXECUTED
return -1;
return ret;
}
cl_start = start >> fs_info->vol.bpc_log2;
ffc14684: 8b 3e 00 08 lbz r25,8(r30)
save_ofs = ofs = start & (fs_info->vol.bpc - 1);
rc = fat_file_lseek(mt_entry, fat_fd, cl_start, &cur_cln);
ffc14688: 3a e1 00 0c addi r23,r1,12
ffc1468c: 7f 63 db 78 mr r3,r27
return ret;
}
cl_start = start >> fs_info->vol.bpc_log2;
save_ofs = ofs = start & (fs_info->vol.bpc - 1);
ffc14690: a3 5e 00 06 lhz r26,6(r30)
return -1;
return ret;
}
cl_start = start >> fs_info->vol.bpc_log2;
ffc14694: 7f 99 cc 30 srw r25,r28,r25
save_ofs = ofs = start & (fs_info->vol.bpc - 1);
rc = fat_file_lseek(mt_entry, fat_fd, cl_start, &cur_cln);
ffc14698: 7f a4 eb 78 mr r4,r29
ffc1469c: 7f 25 cb 78 mr r5,r25
ffc146a0: 7e e6 bb 78 mr r6,r23
ffc146a4: 4b ff f5 61 bl ffc13c04 <fat_file_lseek>
if (rc != RC_OK)
ffc146a8: 2f 84 00 00 cmpwi cr7,r4,0
}
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);
ffc146ac: 7c 80 23 78 mr r0,r4
if (rc != RC_OK)
ffc146b0: 40 9e 00 cc bne- cr7,ffc1477c <fat_file_write+0x1f0> <== NEVER TAKEN
return ret;
}
cl_start = start >> fs_info->vol.bpc_log2;
save_ofs = ofs = start & (fs_info->vol.bpc - 1);
ffc146b4: 3b 5a ff ff addi r26,r26,-1
ffc146b8: 7f 9c d0 38 and r28,r28,r26
ffc146bc: 7f 95 e3 78 mr r21,r28
ffc146c0: 3a c0 00 00 li r22,0
ffc146c4: 3b 40 00 00 li r26,0
ffc146c8: 48 00 00 84 b ffc1474c <fat_file_write+0x1c0>
if (rc != RC_OK)
return rc;
while (count > 0)
{
c = MIN(count, (fs_info->vol.bpc - ofs));
ffc146cc: a2 de 00 06 lhz r22,6(r30)
ffc146d0: 7e d5 b0 50 subf r22,r21,r22
ffc146d4: 7f 96 f8 40 cmplw cr7,r22,r31
ffc146d8: 40 9d 00 08 ble- cr7,ffc146e0 <fat_file_write+0x154>
ffc146dc: 7f f6 fb 78 mr r22,r31
sec = fat_cluster_num_to_sector_num(mt_entry, cur_cln);
ffc146e0: 80 81 00 0c lwz r4,12(r1)
ffc146e4: 80 7b 00 34 lwz r3,52(r27)
if (rc != RC_OK)
return rc;
while (count > 0)
{
c = MIN(count, (fs_info->vol.bpc - ofs));
ffc146e8: 92 c1 00 08 stw r22,8(r1)
sec = fat_cluster_num_to_sector_num(mt_entry, cur_cln);
ffc146ec: 4b ff f5 d1 bl ffc13cbc <fat_cluster_num_to_sector_num.isra.0>
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);
ffc146f0: 7e c6 b3 78 mr r6,r22
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);
ffc146f4: 88 9e 00 02 lbz r4,2(r30)
byte = ofs & (fs_info->vol.bps - 1);
ret = _fat_block_write(mt_entry, sec, byte, c, buf + cmpltd);
ffc146f8: 7c f8 d2 14 add r7,r24,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);
ffc146fc: a0 be 00 00 lhz r5,0(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);
ffc14700: 7e a4 24 30 srw r4,r21,r4
byte = ofs & (fs_info->vol.bps - 1);
ffc14704: 38 a5 ff ff addi r5,r5,-1
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);
ffc14708: 7c 83 22 14 add r4,r3,r4
byte = ofs & (fs_info->vol.bps - 1);
ret = _fat_block_write(mt_entry, sec, byte, c, buf + cmpltd);
ffc1470c: 7e a5 28 38 and r5,r21,r5
ffc14710: 7f 63 db 78 mr r3,r27
ffc14714: 48 00 06 8d bl ffc14da0 <_fat_block_write>
if ( ret < 0 )
ffc14718: 2f 83 00 00 cmpwi cr7,r3,0
ffc1471c: 41 9c 00 5c blt- cr7,ffc14778 <fat_file_write+0x1ec> <== NEVER TAKEN
return -1;
count -= c;
cmpltd += c;
save_cln = cur_cln;
ffc14720: 82 c1 00 0c lwz r22,12(r1)
rc = fat_get_fat_cluster(mt_entry, cur_cln, &cur_cln);
ffc14724: 7f 63 db 78 mr r3,r27
ret = _fat_block_write(mt_entry, sec, byte, c, buf + cmpltd);
if ( ret < 0 )
return -1;
count -= c;
ffc14728: 80 01 00 08 lwz r0,8(r1)
cmpltd += c;
save_cln = cur_cln;
rc = fat_get_fat_cluster(mt_entry, cur_cln, &cur_cln);
ffc1472c: 7e e5 bb 78 mr r5,r23
ffc14730: 7e c4 b3 78 mr r4,r22
ret = _fat_block_write(mt_entry, sec, byte, c, buf + cmpltd);
if ( ret < 0 )
return -1;
count -= c;
ffc14734: 7f e0 f8 50 subf r31,r0,r31
cmpltd += c;
ffc14738: 7f 5a 02 14 add r26,r26,r0
save_cln = cur_cln;
rc = fat_get_fat_cluster(mt_entry, cur_cln, &cur_cln);
ffc1473c: 48 00 7c 65 bl ffc1c3a0 <fat_get_fat_cluster>
if ( rc != RC_OK )
ffc14740: 7c 60 1b 79 mr. r0,r3
ffc14744: 40 82 00 38 bne- ffc1477c <fat_file_write+0x1f0> <== NEVER TAKEN
return rc;
ofs = 0;
ffc14748: 3a a0 00 00 li r21,0
rc = fat_file_lseek(mt_entry, fat_fd, cl_start, &cur_cln);
if (rc != RC_OK)
return rc;
while (count > 0)
ffc1474c: 2f 9f 00 00 cmpwi cr7,r31,0
ffc14750: 40 9e ff 7c bne+ cr7,ffc146cc <fat_file_write+0x140>
}
/* 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);
ffc14754: 88 1e 00 08 lbz r0,8(r30)
ffc14758: 3b 9c ff ff addi r28,r28,-1
ffc1475c: 7f 9c d2 14 add r28,r28,r26
fat_fd->map.disk_cln = save_cln;
ffc14760: 92 dd 00 38 stw r22,56(r29)
}
/* 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);
ffc14764: 7f 9c 04 30 srw r28,r28,r0
ofs = 0;
}
/* update cache */
/* XXX: check this - I'm not sure :( */
fat_fd->map.file_cln = cl_start +
ffc14768: 7f 3c ca 14 add r25,r28,r25
ffc1476c: 93 3d 00 34 stw r25,52(r29)
((save_ofs + cmpltd - 1) >> fs_info->vol.bpc_log2);
fat_fd->map.disk_cln = save_cln;
return cmpltd;
ffc14770: 7f 40 d3 78 mr r0,r26
ffc14774: 48 00 00 08 b ffc1477c <fat_file_write+0x1f0>
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;
ffc14778: 38 00 ff ff li r0,-1 <== NOT EXECUTED
fat_fd->map.file_cln = cl_start +
((save_ofs + cmpltd - 1) >> fs_info->vol.bpc_log2);
fat_fd->map.disk_cln = save_cln;
return cmpltd;
}
ffc1477c: 39 61 00 48 addi r11,r1,72
ffc14780: 7c 03 03 78 mr r3,r0
ffc14784: 4b fe e3 4c b ffc02ad0 <_restgpr_21_x>
ffc1c7f4 <fat_free_fat_clusters_chain>:
int
fat_free_fat_clusters_chain(
rtems_filesystem_mount_table_entry_t *mt_entry,
uint32_t chain
)
{
ffc1c7f4: 94 21 ff c8 stwu r1,-56(r1)
ffc1c7f8: 7c 08 02 a6 mflr r0
ffc1c7fc: 90 01 00 3c stw r0,60(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;
ffc1c800: 38 00 00 00 li r0,0
int
fat_free_fat_clusters_chain(
rtems_filesystem_mount_table_entry_t *mt_entry,
uint32_t chain
)
{
ffc1c804: bf 01 00 18 stmw r24,24(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;
ffc1c808: 7c 3c 0b 78 mr r28,r1
int
fat_free_fat_clusters_chain(
rtems_filesystem_mount_table_entry_t *mt_entry,
uint32_t chain
)
{
ffc1c80c: 7c 7b 1b 78 mr r27,r3
ffc1c810: 7c 99 23 78 mr r25,r4
int rc = RC_OK, rc1 = RC_OK;
fat_fs_info_t *fs_info = mt_entry->fs_info;
ffc1c814: 83 e3 00 34 lwz r31,52(r3)
uint32_t cur_cln = chain;
uint32_t next_cln = 0;
ffc1c818: 94 1c 00 08 stwu r0,8(r28)
uint32_t chain
)
{
int rc = RC_OK, rc1 = RC_OK;
fat_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t cur_cln = chain;
ffc1c81c: 7c 9d 23 78 mr r29,r4
uint32_t next_cln = 0;
uint32_t freed_cls_cnt = 0;
ffc1c820: 3b c0 00 00 li r30,0
fat_free_fat_clusters_chain(
rtems_filesystem_mount_table_entry_t *mt_entry,
uint32_t chain
)
{
int rc = RC_OK, rc1 = RC_OK;
ffc1c824: 3b 40 00 00 li r26,0
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)
ffc1c828: 48 00 00 60 b ffc1c888 <fat_free_fat_clusters_chain+0x94>
{
rc = fat_get_fat_cluster(mt_entry, cur_cln, &next_cln);
ffc1c82c: 7f 63 db 78 mr r3,r27
ffc1c830: 7f a4 eb 78 mr r4,r29
ffc1c834: 7f 85 e3 78 mr r5,r28
ffc1c838: 4b ff fb 69 bl ffc1c3a0 <fat_get_fat_cluster>
if ( rc != RC_OK )
ffc1c83c: 7c 78 1b 79 mr. r24,r3
ffc1c840: 41 a2 00 24 beq+ ffc1c864 <fat_free_fat_clusters_chain+0x70><== ALWAYS TAKEN
{
if(fs_info->vol.free_cls != FAT_UNDEFINED_VALUE)
ffc1c844: 80 1f 00 40 lwz r0,64(r31) <== NOT EXECUTED
ffc1c848: 2f 80 ff ff cmpwi cr7,r0,-1 <== NOT EXECUTED
ffc1c84c: 41 9e 00 0c beq- cr7,ffc1c858 <fat_free_fat_clusters_chain+0x64><== NOT EXECUTED
fs_info->vol.free_cls += freed_cls_cnt;
ffc1c850: 7f de 02 14 add r30,r30,r0 <== NOT EXECUTED
ffc1c854: 93 df 00 40 stw r30,64(r31) <== NOT EXECUTED
fat_buf_release(fs_info);
ffc1c858: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc1c85c: 4b ff 83 45 bl ffc14ba0 <fat_buf_release> <== NOT EXECUTED
return rc;
ffc1c860: 48 00 00 60 b ffc1c8c0 <fat_free_fat_clusters_chain+0xcc><== NOT EXECUTED
}
rc = fat_set_fat_cluster(mt_entry, cur_cln, FAT_GENFAT_FREE);
ffc1c864: 7f 63 db 78 mr r3,r27
ffc1c868: 7f a4 eb 78 mr r4,r29
ffc1c86c: 38 a0 00 00 li r5,0
ffc1c870: 4b ff fc ed bl ffc1c55c <fat_set_fat_cluster>
if ( rc != RC_OK )
ffc1c874: 2c 03 00 00 cmpwi r3,0
ffc1c878: 41 82 00 08 beq- ffc1c880 <fat_free_fat_clusters_chain+0x8c><== ALWAYS TAKEN
ffc1c87c: 7c 7a 1b 78 mr r26,r3 <== NOT EXECUTED
rc1 = rc;
freed_cls_cnt++;
cur_cln = next_cln;
ffc1c880: 83 a1 00 08 lwz r29,8(r1)
rc = fat_set_fat_cluster(mt_entry, cur_cln, FAT_GENFAT_FREE);
if ( rc != RC_OK )
rc1 = rc;
freed_cls_cnt++;
ffc1c884: 3b de 00 01 addi r30,r30,1
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)
ffc1c888: 81 3f 00 0c lwz r9,12(r31)
ffc1c88c: 80 1f 00 10 lwz r0,16(r31)
ffc1c890: 7f a9 48 38 and r9,r29,r9
ffc1c894: 7f 89 00 40 cmplw cr7,r9,r0
ffc1c898: 41 9c ff 94 blt+ cr7,ffc1c82c <fat_free_fat_clusters_chain+0x38>
freed_cls_cnt++;
cur_cln = next_cln;
}
fs_info->vol.next_cl = chain;
if (fs_info->vol.free_cls != FAT_UNDEFINED_VALUE)
ffc1c89c: 80 1f 00 40 lwz r0,64(r31)
freed_cls_cnt++;
cur_cln = next_cln;
}
fs_info->vol.next_cl = chain;
ffc1c8a0: 93 3f 00 44 stw r25,68(r31)
if (fs_info->vol.free_cls != FAT_UNDEFINED_VALUE)
ffc1c8a4: 2f 80 ff ff cmpwi cr7,r0,-1
ffc1c8a8: 41 9e 00 0c beq- cr7,ffc1c8b4 <fat_free_fat_clusters_chain+0xc0><== ALWAYS TAKEN
fs_info->vol.free_cls += freed_cls_cnt;
ffc1c8ac: 7f de 02 14 add r30,r30,r0 <== NOT EXECUTED
ffc1c8b0: 93 df 00 40 stw r30,64(r31) <== NOT EXECUTED
fat_buf_release(fs_info);
ffc1c8b4: 7f e3 fb 78 mr r3,r31
ffc1c8b8: 4b ff 82 e9 bl ffc14ba0 <fat_buf_release>
ffc1c8bc: 7f 58 d3 78 mr r24,r26
if (rc1 != RC_OK)
return rc1;
return RC_OK;
}
ffc1c8c0: 39 61 00 38 addi r11,r1,56
ffc1c8c4: 7f 03 c3 78 mr r3,r24
ffc1c8c8: 4b fe 62 14 b ffc02adc <_restgpr_24_x>
ffc150a0 <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;
ffc150a0: 81 23 00 34 lwz r9,52(r3) <== NOT EXECUTED
FAT_SET_UNIQ_INO_FREE((ino - fs_info->uino_base), fs_info->uino);
ffc150a4: 39 40 ff fe li r10,-2 <== NOT EXECUTED
ffc150a8: 80 09 00 7c lwz r0,124(r9) <== NOT EXECUTED
ffc150ac: 81 29 00 70 lwz r9,112(r9) <== NOT EXECUTED
ffc150b0: 7c 00 20 50 subf r0,r0,r4 <== NOT EXECUTED
ffc150b4: 54 0b e8 fe rlwinm r11,r0,29,3,31 <== NOT EXECUTED
ffc150b8: 54 00 07 7e clrlwi r0,r0,29 <== NOT EXECUTED
ffc150bc: 5d 40 00 3e rotlw r0,r10,r0 <== NOT EXECUTED
ffc150c0: 7d 49 58 ae lbzx r10,r9,r11 <== NOT EXECUTED
ffc150c4: 7c 00 50 38 and r0,r0,r10 <== NOT EXECUTED
ffc150c8: 7c 09 59 ae stbx r0,r9,r11 <== NOT EXECUTED
}
ffc150cc: 4e 80 00 20 blr <== NOT EXECUTED
ffc1c3a0 <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)) )
ffc1c3a0: 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
)
{
ffc1c3a4: 94 21 ff c8 stwu r1,-56(r1)
ffc1c3a8: 7c 08 02 a6 mflr r0
ffc1c3ac: bf 21 00 1c stmw r25,28(r1)
ffc1c3b0: 7c 9f 23 78 mr r31,r4
ffc1c3b4: 7c be 2b 78 mr r30,r5
ffc1c3b8: 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;
ffc1c3bc: 38 00 00 00 li r0,0
uint32_t cln,
uint32_t *ret_val
)
{
int rc = RC_OK;
register fat_fs_info_t *fs_info = mt_entry->fs_info;
ffc1c3c0: 83 a3 00 34 lwz r29,52(r3)
rtems_bdbuf_buffer *block0 = NULL;
ffc1c3c4: 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)) )
ffc1c3c8: 40 9d 01 70 ble- cr7,ffc1c538 <fat_get_fat_cluster+0x198><== NEVER TAKEN
ffc1c3cc: 81 3d 00 34 lwz r9,52(r29)
ffc1c3d0: 38 09 00 01 addi r0,r9,1
ffc1c3d4: 7f 84 00 40 cmplw cr7,r4,r0
ffc1c3d8: 41 9d 01 60 bgt- cr7,ffc1c538 <fat_get_fat_cluster+0x198><== NEVER TAKEN
rtems_set_errno_and_return_minus_one(EIO);
sec = (FAT_FAT_OFFSET(fs_info->vol.type, cln) >> fs_info->vol.sec_log2) +
ffc1c3dc: 88 1d 00 0a lbz r0,10(r29)
ffc1c3e0: 54 9a f8 7e rlwinm r26,r4,31,1,31
ffc1c3e4: 7f 5a 22 14 add r26,r26,r4
ffc1c3e8: 70 09 00 01 andi. r9,r0,1
ffc1c3ec: 40 82 00 14 bne- ffc1c400 <fat_get_fat_cluster+0x60> <== ALWAYS TAKEN
ffc1c3f0: 70 0b 00 02 andi. r11,r0,2 <== NOT EXECUTED
ffc1c3f4: 54 9a 10 3a rlwinm r26,r4,2,0,29 <== NOT EXECUTED
ffc1c3f8: 41 82 00 08 beq- ffc1c400 <fat_get_fat_cluster+0x60> <== NOT EXECUTED
ffc1c3fc: 54 9a 08 3c rlwinm r26,r4,1,0,30 <== NOT EXECUTED
fs_info->vol.afat_loc;
ofs = FAT_FAT_OFFSET(fs_info->vol.type, cln) & (fs_info->vol.bps - 1);
ffc1c400: 2f 89 00 00 cmpwi cr7,r9,0
/* 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) +
ffc1c404: 89 7d 00 02 lbz r11,2(r29)
fs_info->vol.afat_loc;
ofs = FAT_FAT_OFFSET(fs_info->vol.type, cln) & (fs_info->vol.bps - 1);
ffc1c408: 57 fb f8 7e rlwinm r27,r31,31,1,31
/* 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) +
ffc1c40c: 7f 5a 5c 30 srw r26,r26,r11
ffc1c410: 81 7d 00 4c lwz r11,76(r29)
fs_info->vol.afat_loc;
ofs = FAT_FAT_OFFSET(fs_info->vol.type, cln) & (fs_info->vol.bps - 1);
ffc1c414: 7f 7b fa 14 add r27,r27,r31
/* 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) +
ffc1c418: 7f 5a 5a 14 add r26,r26,r11
fs_info->vol.afat_loc;
ofs = FAT_FAT_OFFSET(fs_info->vol.type, cln) & (fs_info->vol.bps - 1);
ffc1c41c: 40 9e 00 14 bne- cr7,ffc1c430 <fat_get_fat_cluster+0x90><== ALWAYS TAKEN
ffc1c420: 70 09 00 02 andi. r9,r0,2 <== NOT EXECUTED
ffc1c424: 57 fb 10 3a rlwinm r27,r31,2,0,29 <== NOT EXECUTED
ffc1c428: 41 82 00 08 beq- ffc1c430 <fat_get_fat_cluster+0x90> <== NOT EXECUTED
ffc1c42c: 57 fb 08 3c rlwinm r27,r31,1,0,30 <== NOT EXECUTED
rc = fat_buf_access(fs_info, sec, FAT_OP_TYPE_READ, &block0);
ffc1c430: 7f a3 eb 78 mr r3,r29
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);
ffc1c434: a3 3d 00 00 lhz r25,0(r29)
rc = fat_buf_access(fs_info, sec, FAT_OP_TYPE_READ, &block0);
ffc1c438: 7f 44 d3 78 mr r4,r26
ffc1c43c: 38 a0 00 01 li r5,1
ffc1c440: 38 c1 00 08 addi r6,r1,8
ffc1c444: 4b ff 85 79 bl ffc149bc <fat_buf_access>
if (rc != RC_OK)
ffc1c448: 7c 7c 1b 79 mr. r28,r3
ffc1c44c: 40 82 01 04 bne- ffc1c550 <fat_get_fat_cluster+0x1b0> <== NEVER TAKEN
return rc;
switch ( fs_info->vol.type )
ffc1c450: 88 1d 00 0a lbz r0,10(r29)
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);
ffc1c454: 3b 39 ff ff addi r25,r25,-1
ffc1c458: 7f 7b c8 38 and r27,r27,r25
rc = fat_buf_access(fs_info, sec, FAT_OP_TYPE_READ, &block0);
if (rc != RC_OK)
return rc;
switch ( fs_info->vol.type )
ffc1c45c: 2f 80 00 02 cmpwi cr7,r0,2
ffc1c460: 41 9e 00 98 beq- cr7,ffc1c4f8 <fat_get_fat_cluster+0x158><== NEVER TAKEN
ffc1c464: 2f 80 00 04 cmpwi cr7,r0,4
ffc1c468: 41 9e 00 ac beq- cr7,ffc1c514 <fat_get_fat_cluster+0x174><== NEVER TAKEN
ffc1c46c: 2f 80 00 01 cmpwi cr7,r0,1
ffc1c470: 40 be 00 c8 bne+ cr7,ffc1c538 <fat_get_fat_cluster+0x198><== NEVER TAKEN
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)));
ffc1c474: 81 21 00 08 lwz r9,8(r1)
ffc1c478: 83 29 00 24 lwz r25,36(r9)
if ( ofs == (fs_info->vol.bps - 1) )
ffc1c47c: a1 3d 00 00 lhz r9,0(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)));
ffc1c480: 7c 19 d8 ae lbzx r0,r25,r27
if ( ofs == (fs_info->vol.bps - 1) )
ffc1c484: 39 29 ff ff addi r9,r9,-1
ffc1c488: 7f 9b 48 00 cmpw cr7,r27,r9
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)));
ffc1c48c: 90 1e 00 00 stw r0,0(r30)
if ( ofs == (fs_info->vol.bps - 1) )
ffc1c490: 40 be 00 38 bne+ cr7,ffc1c4c8 <fat_get_fat_cluster+0x128><== ALWAYS TAKEN
{
rc = fat_buf_access(fs_info, sec + 1, FAT_OP_TYPE_READ,
ffc1c494: 7f a3 eb 78 mr r3,r29 <== NOT EXECUTED
ffc1c498: 38 9a 00 01 addi r4,r26,1 <== NOT EXECUTED
ffc1c49c: 38 a0 00 01 li r5,1 <== NOT EXECUTED
ffc1c4a0: 38 c1 00 08 addi r6,r1,8 <== NOT EXECUTED
ffc1c4a4: 4b ff 85 19 bl ffc149bc <fat_buf_access> <== NOT EXECUTED
&block0);
if (rc != RC_OK)
ffc1c4a8: 2c 03 00 00 cmpwi r3,0 <== NOT EXECUTED
ffc1c4ac: 40 82 00 a0 bne- ffc1c54c <fat_get_fat_cluster+0x1ac> <== NOT EXECUTED
return rc;
*ret_val |= (*((uint8_t *)(block0->buffer)))<<8;
ffc1c4b0: 81 21 00 08 lwz r9,8(r1) <== NOT EXECUTED
ffc1c4b4: 81 29 00 24 lwz r9,36(r9) <== NOT EXECUTED
ffc1c4b8: 88 09 00 00 lbz r0,0(r9) <== NOT EXECUTED
ffc1c4bc: 81 3e 00 00 lwz r9,0(r30) <== NOT EXECUTED
ffc1c4c0: 54 00 40 2e rlwinm r0,r0,8,0,23 <== NOT EXECUTED
ffc1c4c4: 48 00 00 10 b ffc1c4d4 <fat_get_fat_cluster+0x134> <== NOT EXECUTED
}
else
{
*ret_val |= (*((uint8_t *)(block0->buffer + ofs + 1)))<<8;
ffc1c4c8: 7f 79 da 14 add r27,r25,r27
ffc1c4cc: 89 3b 00 01 lbz r9,1(r27)
ffc1c4d0: 55 29 40 2e rlwinm r9,r9,8,0,23
}
if ( FAT_CLUSTER_IS_ODD(cln) )
ffc1c4d4: 73 eb 00 01 andi. r11,r31,1
*ret_val |= (*((uint8_t *)(block0->buffer)))<<8;
}
else
{
*ret_val |= (*((uint8_t *)(block0->buffer + ofs + 1)))<<8;
ffc1c4d8: 7d 20 03 78 or r0,r9,r0
ffc1c4dc: 90 1e 00 00 stw r0,0(r30)
ffc1c4e0: 80 1e 00 00 lwz r0,0(r30)
}
if ( FAT_CLUSTER_IS_ODD(cln) )
ffc1c4e4: 41 82 00 0c beq- ffc1c4f0 <fat_get_fat_cluster+0x150>
*ret_val = (*ret_val) >> FAT12_SHIFT;
ffc1c4e8: 54 00 e1 3e rlwinm r0,r0,28,4,31
ffc1c4ec: 48 00 00 44 b ffc1c530 <fat_get_fat_cluster+0x190>
else
*ret_val = (*ret_val) & FAT_FAT12_MASK;
ffc1c4f0: 54 00 05 3e clrlwi r0,r0,20
ffc1c4f4: 48 00 00 3c b ffc1c530 <fat_get_fat_cluster+0x190>
break;
case FAT_FAT16:
*ret_val = *((uint16_t *)(block0->buffer + ofs));
ffc1c4f8: 81 21 00 08 lwz r9,8(r1) <== NOT EXECUTED
ffc1c4fc: 81 29 00 24 lwz r9,36(r9) <== NOT EXECUTED
ffc1c500: 7c 09 da 2e lhzx r0,r9,r27 <== NOT EXECUTED
*ret_val = CF_LE_W(*ret_val);
ffc1c504: 54 09 c2 3e rlwinm r9,r0,24,8,31 <== NOT EXECUTED
ffc1c508: 54 00 44 2e rlwinm r0,r0,8,16,23 <== NOT EXECUTED
ffc1c50c: 7d 20 03 78 or r0,r9,r0 <== NOT EXECUTED
ffc1c510: 48 00 00 20 b ffc1c530 <fat_get_fat_cluster+0x190> <== NOT EXECUTED
break;
case FAT_FAT32:
*ret_val = *((uint32_t *)(block0->buffer + ofs));
ffc1c514: 81 21 00 08 lwz r9,8(r1) <== NOT EXECUTED
ffc1c518: 81 29 00 24 lwz r9,36(r9) <== NOT EXECUTED
ffc1c51c: 7d 29 d8 2e lwzx r9,r9,r27 <== NOT EXECUTED
ffc1c520: 51 20 46 3e rlwimi r0,r9,8,24,31 <== NOT EXECUTED
ffc1c524: 51 20 c4 2e rlwimi r0,r9,24,16,23 <== NOT EXECUTED
ffc1c528: 51 20 42 1e rlwimi r0,r9,8,8,15 <== NOT EXECUTED
ffc1c52c: 51 20 c0 0e rlwimi r0,r9,24,0,7 <== NOT EXECUTED
*ret_val = CF_LE_L(*ret_val);
ffc1c530: 90 1e 00 00 stw r0,0(r30)
break;
ffc1c534: 48 00 00 1c b ffc1c550 <fat_get_fat_cluster+0x1b0>
default:
rtems_set_errno_and_return_minus_one(EIO);
ffc1c538: 48 00 1c a1 bl ffc1e1d8 <__errno> <== NOT EXECUTED
ffc1c53c: 38 00 00 05 li r0,5 <== NOT EXECUTED
ffc1c540: 90 03 00 00 stw r0,0(r3) <== NOT EXECUTED
ffc1c544: 3b 80 ff ff li r28,-1 <== NOT EXECUTED
ffc1c548: 48 00 00 08 b ffc1c550 <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)
ffc1c54c: 7c 7c 1b 78 mr r28,r3 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
break;
}
return RC_OK;
}
ffc1c550: 39 61 00 38 addi r11,r1,56
ffc1c554: 7f 83 e3 78 mr r3,r28
ffc1c558: 4b fe 65 88 b ffc02ae0 <_restgpr_25_x>
ffc14fc8 <fat_get_unique_ino>:
* 0 means FAILED !!!
*
*/
uint32_t
fat_get_unique_ino(rtems_filesystem_mount_table_entry_t *mt_entry)
{
ffc14fc8: 94 21 ff e8 stwu r1,-24(r1) <== NOT EXECUTED
ffc14fcc: 7c 08 02 a6 mflr r0 <== NOT EXECUTED
ffc14fd0: 90 01 00 1c stw r0,28(r1) <== NOT EXECUTED
ffc14fd4: bf a1 00 0c stmw 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))
ffc14fd8: 3f c0 0f ff lis r30,4095 <== NOT EXECUTED
uint32_t j = 0;
bool resrc_unsuff = false;
while (!resrc_unsuff)
{
for (j = 0; j < fs_info->uino_pool_size; j++)
ffc14fdc: 3b a0 00 00 li r29,0 <== 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;
ffc14fe0: 83 e3 00 34 lwz r31,52(r3) <== 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))
ffc14fe4: 63 de ff ff ori r30,r30,65535 <== NOT EXECUTED
{
register fat_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t j = 0;
bool resrc_unsuff = false;
while (!resrc_unsuff)
ffc14fe8: 48 00 00 98 b ffc15080 <fat_get_unique_ino+0xb8> <== NOT EXECUTED
{
for (j = 0; j < fs_info->uino_pool_size; j++)
{
if (!FAT_UNIQ_INO_IS_BUSY(fs_info->index, fs_info->uino))
ffc14fec: 81 3f 00 74 lwz r9,116(r31) <== NOT EXECUTED
ffc14ff0: 81 7f 00 70 lwz r11,112(r31) <== NOT EXECUTED
ffc14ff4: 55 20 e8 fe rlwinm r0,r9,29,3,31 <== NOT EXECUTED
ffc14ff8: 7d 0b 02 14 add r8,r11,r0 <== NOT EXECUTED
ffc14ffc: 7c 0b 00 ae lbzx r0,r11,r0 <== NOT EXECUTED
ffc15000: 55 2b 07 7e clrlwi r11,r9,29 <== NOT EXECUTED
ffc15004: 7c 07 5e 30 sraw r7,r0,r11 <== NOT EXECUTED
ffc15008: 70 e6 00 01 andi. r6,r7,1 <== NOT EXECUTED
ffc1500c: 40 a2 00 24 bne+ ffc15030 <fat_get_unique_ino+0x68> <== NOT EXECUTED
{
FAT_SET_UNIQ_INO_BUSY(fs_info->index, fs_info->uino);
ffc15010: 39 20 00 01 li r9,1 <== NOT EXECUTED
ffc15014: 7d 2b 58 30 slw r11,r9,r11 <== NOT EXECUTED
ffc15018: 7d 60 03 78 or r0,r11,r0 <== NOT EXECUTED
ffc1501c: 98 08 00 00 stb r0,0(r8) <== NOT EXECUTED
return (fs_info->uino_base + fs_info->index);
ffc15020: 80 7f 00 74 lwz r3,116(r31) <== NOT EXECUTED
ffc15024: 80 1f 00 7c lwz r0,124(r31) <== NOT EXECUTED
ffc15028: 7c 63 02 14 add r3,r3,r0 <== NOT EXECUTED
ffc1502c: 48 00 00 6c b ffc15098 <fat_get_unique_ino+0xd0> <== NOT EXECUTED
}
fs_info->index++;
ffc15030: 39 29 00 01 addi r9,r9,1 <== NOT EXECUTED
if (fs_info->index >= fs_info->uino_pool_size)
ffc15034: 7f 89 50 40 cmplw cr7,r9,r10 <== 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++;
ffc15038: 91 3f 00 74 stw r9,116(r31) <== NOT EXECUTED
if (fs_info->index >= fs_info->uino_pool_size)
ffc1503c: 41 9c 00 08 blt- cr7,ffc15044 <fat_get_unique_ino+0x7c> <== NOT EXECUTED
fs_info->index = 0;
ffc15040: 93 bf 00 74 stw r29,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++)
ffc15044: 38 84 00 01 addi r4,r4,1 <== NOT EXECUTED
ffc15048: 42 00 ff a4 bdnz+ ffc14fec <fat_get_unique_ino+0x24> <== 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))
ffc1504c: 80 1f 00 7c lwz r0,124(r31) <== NOT EXECUTED
ffc15050: 54 84 08 3c rlwinm r4,r4,1,0,30 <== NOT EXECUTED
ffc15054: 7c 00 f0 50 subf r0,r0,r30 <== NOT EXECUTED
ffc15058: 7f 84 00 40 cmplw cr7,r4,r0 <== NOT EXECUTED
ffc1505c: 40 bc 00 38 bge+ cr7,ffc15094 <fat_get_unique_ino+0xcc> <== NOT EXECUTED
{
fs_info->uino_pool_size <<= 1;
ffc15060: 90 9f 00 78 stw r4,120(r31) <== NOT EXECUTED
fs_info->uino = realloc(fs_info->uino, fs_info->uino_pool_size);
ffc15064: 80 7f 00 70 lwz r3,112(r31) <== NOT EXECUTED
ffc15068: 4b ff 3e 1d bl ffc08e84 <realloc> <== NOT EXECUTED
if (fs_info->uino != NULL)
ffc1506c: 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);
ffc15070: 90 7f 00 70 stw r3,112(r31) <== NOT EXECUTED
if (fs_info->uino != NULL)
ffc15074: 41 be 00 20 beq+ cr7,ffc15094 <fat_get_unique_ino+0xcc> <== NOT EXECUTED
fs_info->index = fs_info->uino_pool_size;
ffc15078: 80 1f 00 78 lwz r0,120(r31) <== NOT EXECUTED
ffc1507c: 90 1f 00 74 stw r0,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++)
ffc15080: 81 5f 00 78 lwz r10,120(r31) <== NOT EXECUTED
ffc15084: 38 80 00 00 li r4,0 <== 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;
ffc15088: 38 0a 00 01 addi r0,r10,1 <== NOT EXECUTED
ffc1508c: 7c 09 03 a6 mtctr r0 <== NOT EXECUTED
ffc15090: 4b ff ff b8 b ffc15048 <fat_get_unique_ino+0x80> <== NOT EXECUTED
resrc_unsuff = true;
}
else
resrc_unsuff = true;
}
return 0;
ffc15094: 38 60 00 00 li r3,0 <== NOT EXECUTED
}
ffc15098: 39 61 00 18 addi r11,r1,24 <== NOT EXECUTED
ffc1509c: 4b fe da 54 b ffc02af0 <_restgpr_29_x> <== NOT EXECUTED
ffc14f10 <fat_init_clusters_chain>:
int
fat_init_clusters_chain(
rtems_filesystem_mount_table_entry_t *mt_entry,
uint32_t start_cln
)
{
ffc14f10: 94 21 ff d8 stwu r1,-40(r1)
ffc14f14: 7c 08 02 a6 mflr r0
ffc14f18: 90 01 00 2c stw r0,44(r1)
ffc14f1c: bf 81 00 18 stmw r28,24(r1)
ffc14f20: 7c 7d 1b 78 mr r29,r3
int rc = RC_OK;
ssize_t ret = 0;
register fat_fs_info_t *fs_info = mt_entry->fs_info;
ffc14f24: 83 c3 00 34 lwz r30,52(r3)
uint32_t cur_cln = start_cln;
ffc14f28: 90 81 00 08 stw r4,8(r1)
char *buf;
buf = calloc(fs_info->vol.bpc, sizeof(char));
ffc14f2c: 38 80 00 01 li r4,1
ffc14f30: a0 7e 00 06 lhz r3,6(r30)
ffc14f34: 4b ff 24 a5 bl ffc073d8 <calloc>
if ( buf == NULL )
ffc14f38: 7c 7f 1b 79 mr. r31,r3
ffc14f3c: 40 a2 00 5c bne+ ffc14f98 <fat_init_clusters_chain+0x88><== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( EIO );
ffc14f40: 48 00 92 99 bl ffc1e1d8 <__errno> <== NOT EXECUTED
ffc14f44: 38 00 00 05 li r0,5 <== NOT EXECUTED
ffc14f48: 90 03 00 00 stw r0,0(r3) <== NOT EXECUTED
ffc14f4c: 48 00 00 20 b ffc14f6c <fat_init_clusters_chain+0x5c><== NOT EXECUTED
while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)
{
ret = fat_cluster_write(mt_entry, cur_cln, buf);
ffc14f50: 7f a3 eb 78 mr r3,r29
ffc14f54: 7f e5 fb 78 mr r5,r31
ffc14f58: 4b ff ff 65 bl ffc14ebc <fat_cluster_write>
if ( ret == -1 )
ffc14f5c: 2f 83 ff ff cmpwi cr7,r3,-1
ffc14f60: 40 be 00 14 bne+ cr7,ffc14f74 <fat_init_clusters_chain+0x64><== ALWAYS TAKEN
{
free(buf);
ffc14f64: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc14f68: 4b ff 29 81 bl ffc078e8 <free> <== NOT EXECUTED
return -1;
ffc14f6c: 3b 80 ff ff li r28,-1 <== NOT EXECUTED
ffc14f70: 48 00 00 4c b ffc14fbc <fat_init_clusters_chain+0xac><== NOT EXECUTED
}
rc = fat_get_fat_cluster(mt_entry, cur_cln, &cur_cln);
ffc14f74: 80 81 00 08 lwz r4,8(r1)
ffc14f78: 7f a3 eb 78 mr r3,r29
ffc14f7c: 38 a1 00 08 addi r5,r1,8
ffc14f80: 48 00 74 21 bl ffc1c3a0 <fat_get_fat_cluster>
if ( rc != RC_OK )
ffc14f84: 7c 7c 1b 79 mr. r28,r3
ffc14f88: 41 a2 00 10 beq+ ffc14f98 <fat_init_clusters_chain+0x88><== ALWAYS TAKEN
{
free(buf);
ffc14f8c: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc14f90: 4b ff 29 59 bl ffc078e8 <free> <== NOT EXECUTED
return rc;
ffc14f94: 48 00 00 28 b ffc14fbc <fat_init_clusters_chain+0xac><== NOT EXECUTED
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)
ffc14f98: 80 81 00 08 lwz r4,8(r1)
ffc14f9c: 81 3e 00 0c lwz r9,12(r30)
ffc14fa0: 80 1e 00 10 lwz r0,16(r30)
ffc14fa4: 7c 89 48 38 and r9,r4,r9
ffc14fa8: 7f 89 00 40 cmplw cr7,r9,r0
ffc14fac: 41 9c ff a4 blt+ cr7,ffc14f50 <fat_init_clusters_chain+0x40>
free(buf);
return rc;
}
}
free(buf);
ffc14fb0: 7f e3 fb 78 mr r3,r31
ffc14fb4: 4b ff 29 35 bl ffc078e8 <free>
return rc;
ffc14fb8: 3b 80 00 00 li r28,0
}
ffc14fbc: 39 61 00 28 addi r11,r1,40
ffc14fc0: 7f 83 e3 78 mr r3,r28
ffc14fc4: 4b fe db 28 b ffc02aec <_restgpr_28_x>
ffc15278 <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)
{
ffc15278: 94 21 ff 20 stwu r1,-224(r1)
ffc1527c: 7c 08 02 a6 mflr r0
ffc15280: 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);
ffc15284: 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;
ffc15288: 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)
{
ffc1528c: bd c1 00 98 stmw r14,152(r1)
ffc15290: 7c 7e 1b 78 mr r30,r3
rtems_status_code sc = RTEMS_SUCCESSFUL;
int rc = RC_OK;
fat_fs_info_t *fs_info = mt_entry->fs_info;
ffc15294: 83 e3 00 34 lwz r31,52(r3)
ssize_t ret = 0;
struct stat stat_buf;
int i = 0;
rtems_bdbuf_buffer *block = NULL;
rc = stat(mt_entry->dev, &stat_buf);
ffc15298: 80 63 00 70 lwz r3,112(r3)
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;
ffc1529c: 90 01 00 08 stw r0,8(r1)
rc = stat(mt_entry->dev, &stat_buf);
ffc152a0: 4b ff 3e 51 bl ffc090f0 <stat>
if (rc == -1)
ffc152a4: 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);
ffc152a8: 7c 7d 1b 78 mr r29,r3
if (rc == -1)
ffc152ac: 41 9e 06 64 beq- cr7,ffc15910 <fat_init_volume_info+0x698><== NEVER TAKEN
return rc;
/* Must be a block device. */
if (!S_ISBLK(stat_buf.st_mode))
ffc152b0: 80 01 00 24 lwz r0,36(r1)
ffc152b4: 54 00 04 26 rlwinm r0,r0,0,16,19
ffc152b8: 2f 80 60 00 cmpwi cr7,r0,24576
ffc152bc: 41 be 00 10 beq+ cr7,ffc152cc <fat_init_volume_info+0x54><== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one(ENOTTY);
ffc152c0: 48 00 8f 19 bl ffc1e1d8 <__errno> <== NOT EXECUTED
ffc152c4: 38 00 00 19 li r0,25 <== NOT EXECUTED
ffc152c8: 48 00 06 40 b ffc15908 <fat_init_volume_info+0x690> <== NOT EXECUTED
/* check that device is registred as block device and lock it */
vol->dd = rtems_disk_obtain(stat_buf.st_rdev);
ffc152cc: 80 61 00 30 lwz r3,48(r1)
ffc152d0: 80 81 00 34 lwz r4,52(r1)
ffc152d4: 4b ff 15 99 bl ffc0686c <rtems_disk_obtain>
if (vol->dd == NULL)
ffc152d8: 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);
ffc152dc: 90 7f 00 60 stw r3,96(r31)
if (vol->dd == NULL)
ffc152e0: 41 9e 00 30 beq- cr7,ffc15310 <fat_init_volume_info+0x98><== NEVER TAKEN
rtems_set_errno_and_return_minus_one(EIO);
vol->dev = stat_buf.st_rdev;
ffc152e4: 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);
ffc152e8: 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;
ffc152ec: 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);
ffc152f0: 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;
ffc152f4: 90 7f 00 58 stw r3,88(r31)
ffc152f8: 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);
ffc152fc: 4b ff dc 7d bl ffc12f78 <rtems_bdbuf_read>
if (sc != RTEMS_SUCCESSFUL)
ffc15300: 2f 83 00 00 cmpwi cr7,r3,0
ffc15304: 41 be 00 18 beq+ cr7,ffc1531c <fat_init_volume_info+0xa4><== ALWAYS TAKEN
{
rtems_disk_release(vol->dd);
ffc15308: 80 7f 00 60 lwz r3,96(r31) <== NOT EXECUTED
ffc1530c: 4b ff 15 e5 bl ffc068f0 <rtems_disk_release> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EIO);
ffc15310: 48 00 8e c9 bl ffc1e1d8 <__errno> <== NOT EXECUTED
ffc15314: 38 00 00 05 li r0,5 <== NOT EXECUTED
ffc15318: 48 00 05 f0 b ffc15908 <fat_init_volume_info+0x690> <== NOT EXECUTED
}
memcpy( boot_rec, block->buffer, FAT_MAX_BPB_SIZE);
ffc1531c: 80 61 00 08 lwz r3,8(r1)
ffc15320: 81 83 00 24 lwz r12,36(r3)
ffc15324: 88 0c 00 0b lbz r0,11(r12)
ffc15328: 88 ec 00 0e lbz r7,14(r12)
ffc1532c: 89 4c 00 11 lbz r10,17(r12)
ffc15330: 89 0c 00 12 lbz r8,18(r12)
ffc15334: 89 2c 00 16 lbz r9,22(r12)
ffc15338: 89 6c 00 17 lbz r11,23(r12)
ffc1533c: 88 8c 00 0c lbz r4,12(r12)
ffc15340: 88 cc 00 0f lbz r6,15(r12)
ffc15344: 88 ac 00 30 lbz r5,48(r12)
ffc15348: 8b ac 00 0d lbz r29,13(r12)
ffc1534c: 8b 6c 00 10 lbz r27,16(r12)
ffc15350: 8a 4c 00 13 lbz r18,19(r12)
ffc15354: 8a 2c 00 14 lbz r17,20(r12)
ffc15358: 8a ac 00 20 lbz r21,32(r12)
ffc1535c: 8a 6c 00 21 lbz r19,33(r12)
ffc15360: 8a 8c 00 22 lbz r20,34(r12)
ffc15364: 8a cc 00 23 lbz r22,35(r12)
ffc15368: 89 ec 00 24 lbz r15,36(r12)
ffc1536c: 89 cc 00 26 lbz r14,38(r12)
ffc15370: 8a 0c 00 27 lbz r16,39(r12)
ffc15374: 8b 8c 00 28 lbz r28,40(r12)
ffc15378: 8b 2c 00 2c lbz r25,44(r12)
ffc1537c: 8a ec 00 2d lbz r23,45(r12)
ffc15380: 8b 0c 00 2e lbz r24,46(r12)
ffc15384: 8b 4c 00 2f lbz r26,47(r12)
ffc15388: 90 01 00 94 stw r0,148(r1)
ffc1538c: 88 0c 00 25 lbz r0,37(r12)
ffc15390: 89 8c 00 31 lbz r12,49(r12)
ffc15394: 90 a1 00 68 stw r5,104(r1)
sc = rtems_bdbuf_release( block);
ffc15398: 90 01 00 70 stw r0,112(r1)
ffc1539c: 90 81 00 84 stw r4,132(r1)
ffc153a0: 90 c1 00 78 stw r6,120(r1)
ffc153a4: 90 e1 00 74 stw r7,116(r1)
ffc153a8: 91 01 00 80 stw r8,128(r1)
ffc153ac: 91 21 00 88 stw r9,136(r1)
ffc153b0: 91 41 00 7c stw r10,124(r1)
ffc153b4: 91 61 00 8c stw r11,140(r1)
ffc153b8: 91 81 00 6c stw r12,108(r1)
ffc153bc: 4b ff de 39 bl ffc131f4 <rtems_bdbuf_release>
if (sc != RTEMS_SUCCESSFUL)
ffc153c0: 2f 83 00 00 cmpwi cr7,r3,0
ffc153c4: 80 01 00 70 lwz r0,112(r1)
ffc153c8: 80 81 00 84 lwz r4,132(r1)
ffc153cc: 80 c1 00 78 lwz r6,120(r1)
ffc153d0: 80 e1 00 74 lwz r7,116(r1)
ffc153d4: 81 01 00 80 lwz r8,128(r1)
ffc153d8: 81 21 00 88 lwz r9,136(r1)
ffc153dc: 81 41 00 7c lwz r10,124(r1)
ffc153e0: 81 61 00 8c lwz r11,140(r1)
ffc153e4: 81 81 00 6c lwz r12,108(r1)
ffc153e8: 40 be ff 20 bne- cr7,ffc15308 <fat_init_volume_info+0x90><== 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);
ffc153ec: 80 61 00 94 lwz r3,148(r1)
ffc153f0: 54 84 40 2e rlwinm r4,r4,8,0,23
ffc153f4: 7c 85 1b 78 or r5,r4,r3
if ( (vol->bps != 512) &&
ffc153f8: 2f 85 02 00 cmpwi cr7,r5,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);
ffc153fc: b0 bf 00 00 sth r5,0(r31)
if ( (vol->bps != 512) &&
ffc15400: 41 9e 00 1c beq- cr7,ffc1541c <fat_init_volume_info+0x1a4><== ALWAYS TAKEN
ffc15404: 2f 85 04 00 cmpwi cr7,r5,1024 <== NOT EXECUTED
ffc15408: 41 9e 00 14 beq- cr7,ffc1541c <fat_init_volume_info+0x1a4><== NOT EXECUTED
(vol->bps != 1024) &&
ffc1540c: 2f 85 08 00 cmpwi cr7,r5,2048 <== NOT EXECUTED
ffc15410: 41 9e 00 0c beq- cr7,ffc1541c <fat_init_volume_info+0x1a4><== NOT EXECUTED
(vol->bps != 2048) &&
ffc15414: 2f 85 10 00 cmpwi cr7,r5,4096 <== NOT EXECUTED
ffc15418: 40 9e 02 b4 bne- cr7,ffc156cc <fat_init_volume_info+0x454><== 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;
ffc1541c: 38 80 00 00 li r4,0
ffc15420: 98 9f 00 03 stb r4,3(r31)
ffc15424: 54 a4 ba 7e rlwinm r4,r5,23,9,31
ffc15428: 48 00 00 14 b ffc1543c <fat_init_volume_info+0x1c4>
i >>= 1, vol->sec_mul++);
ffc1542c: 88 7f 00 03 lbz r3,3(r31) <== NOT EXECUTED
ffc15430: 7c 84 0e 70 srawi r4,r4,1 <== NOT EXECUTED
ffc15434: 38 63 00 01 addi r3,r3,1 <== NOT EXECUTED
ffc15438: 98 7f 00 03 stb r3,3(r31) <== 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;
ffc1543c: 70 83 00 01 andi. r3,r4,1
ffc15440: 41 82 ff ec beq+ ffc1542c <fat_init_volume_info+0x1b4> <== NEVER TAKEN
i >>= 1, vol->sec_mul++);
for (vol->sec_log2 = 0, i = vol->bps; (i & 1) == 0;
ffc15444: 38 80 00 00 li r4,0
ffc15448: 98 9f 00 02 stb r4,2(r31)
ffc1544c: 7c a4 2b 78 mr r4,r5
ffc15450: 48 00 00 14 b ffc15464 <fat_init_volume_info+0x1ec>
i >>= 1, vol->sec_log2++);
ffc15454: 88 7f 00 02 lbz r3,2(r31)
ffc15458: 7c 84 0e 70 srawi r4,r4,1
ffc1545c: 38 63 00 01 addi r3,r3,1
ffc15460: 98 7f 00 02 stb r3,2(r31)
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;
ffc15464: 70 83 00 01 andi. r3,r4,1
ffc15468: 41 82 ff ec beq+ ffc15454 <fat_init_volume_info+0x1dc>
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)
ffc1546c: 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);
ffc15470: 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)
ffc15474: 41 9e 02 58 beq- cr7,ffc156cc <fat_init_volume_info+0x454><== 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;
ffc15478: 38 80 00 00 li r4,0
ffc1547c: 98 9f 00 05 stb r4,5(r31)
ffc15480: 7f a3 eb 78 mr r3,r29
ffc15484: 48 00 00 10 b ffc15494 <fat_init_volume_info+0x21c>
i >>= 1, vol->spc_log2++);
ffc15488: 38 84 00 01 addi r4,r4,1
ffc1548c: 98 9f 00 05 stb r4,5(r31)
ffc15490: 7c 63 0e 70 srawi r3,r3,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;
ffc15494: 70 64 00 01 andi. r4,r3,1
ffc15498: 88 9f 00 05 lbz r4,5(r31)
ffc1549c: 41 82 ff ec beq+ ffc15488 <fat_init_volume_info+0x210>
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)
ffc154a0: 54 84 06 3e clrlwi r4,r4,24
ffc154a4: 7c a4 20 30 slw r4,r5,r4
ffc154a8: 54 84 04 3e clrlwi r4,r4,16
ffc154ac: 2b 84 80 00 cmplwi cr7,r4,32768
ffc154b0: b0 9f 00 06 sth r4,6(r31)
{
rtems_disk_release(vol->dd);
rtems_set_errno_and_return_minus_one(EINVAL);
}
for (vol->bpc_log2 = 0, i = vol->bpc; (i & 1) == 0;
ffc154b4: 38 60 00 00 li r3,0
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)
ffc154b8: 40 bd 00 14 ble+ cr7,ffc154cc <fat_init_volume_info+0x254><== ALWAYS TAKEN
ffc154bc: 48 00 02 10 b ffc156cc <fat_init_volume_info+0x454> <== NOT EXECUTED
rtems_disk_release(vol->dd);
rtems_set_errno_and_return_minus_one(EINVAL);
}
for (vol->bpc_log2 = 0, i = vol->bpc; (i & 1) == 0;
i >>= 1, vol->bpc_log2++);
ffc154c0: 88 7f 00 08 lbz r3,8(r31)
ffc154c4: 7c 84 0e 70 srawi r4,r4,1
ffc154c8: 38 63 00 01 addi r3,r3,1
ffc154cc: 98 7f 00 08 stb r3,8(r31)
{
rtems_disk_release(vol->dd);
rtems_set_errno_and_return_minus_one(EINVAL);
}
for (vol->bpc_log2 = 0, i = vol->bpc; (i & 1) == 0;
ffc154d0: 70 83 00 01 andi. r3,r4,1
ffc154d4: 41 82 ff ec beq+ ffc154c0 <fat_init_volume_info+0x248>
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);
ffc154d8: 55 08 40 2e rlwinm r8,r8,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);
ffc154dc: 9b 7f 00 09 stb r27,9(r31)
vol->fat_loc = FAT_GET_BR_RESERVED_SECTORS_NUM(boot_rec);
ffc154e0: 54 c6 40 2e rlwinm r6,r6,8,0,23
vol->rdir_entrs = FAT_GET_BR_FILES_PER_ROOT_DIR(boot_rec);
ffc154e4: 7d 0a 53 78 or r10,r8,r10
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);
ffc154e8: 7c c7 3b 78 or r7,r6,r7
vol->rdir_entrs = FAT_GET_BR_FILES_PER_ROOT_DIR(boot_rec);
ffc154ec: b1 5f 00 20 sth r10,32(r31)
/* calculate the count of sectors occupied by the root directory */
vol->rdir_secs = ((vol->rdir_entrs * FAT_DIRENTRY_SIZE) + (vol->bps - 1)) /
ffc154f0: 38 c5 ff ff addi r6,r5,-1
ffc154f4: 55 4a 28 34 rlwinm r10,r10,5,0,26
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);
ffc154f8: b0 ff 00 14 sth r7,20(r31)
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)) /
ffc154fc: 7d 4a 32 14 add r10,r10,r6
ffc15500: 7c aa 2b d6 divw r5,r10,r5
vol->bps;
vol->rdir_size = vol->rdir_secs << vol->sec_log2;
ffc15504: 89 5f 00 02 lbz r10,2(r31)
if ( (FAT_GET_BR_SECTORS_PER_FAT(boot_rec)) != 0)
ffc15508: 55 6b 40 2e rlwinm r11,r11,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)) /
ffc1550c: 90 bf 00 24 stw r5,36(r31)
vol->bps;
vol->rdir_size = vol->rdir_secs << vol->sec_log2;
if ( (FAT_GET_BR_SECTORS_PER_FAT(boot_rec)) != 0)
ffc15510: 7d 69 4b 78 or r9,r11,r9
ffc15514: 7d 29 07 35 extsh. r9,r9
/* 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;
ffc15518: 7c aa 50 30 slw r10,r5,r10
ffc1551c: 91 5f 00 28 stw r10,40(r31)
if ( (FAT_GET_BR_SECTORS_PER_FAT(boot_rec)) != 0)
ffc15520: 41 82 00 10 beq- ffc15530 <fat_init_volume_info+0x2b8> <== NEVER TAKEN
vol->fat_length = FAT_GET_BR_SECTORS_PER_FAT(boot_rec);
ffc15524: 55 29 04 3e clrlwi r9,r9,16
ffc15528: 91 3f 00 18 stw r9,24(r31)
ffc1552c: 48 00 00 20 b ffc1554c <fat_init_volume_info+0x2d4>
else
vol->fat_length = FAT_GET_BR_SECTORS_PER_FAT32(boot_rec);
ffc15530: 54 00 40 2e rlwinm r0,r0,8,0,23 <== NOT EXECUTED
ffc15534: 55 ce 80 1e rlwinm r14,r14,16,0,15 <== NOT EXECUTED
ffc15538: 7c 00 73 78 or r0,r0,r14 <== NOT EXECUTED
ffc1553c: 7c 0f 7b 78 or r15,r0,r15 <== NOT EXECUTED
ffc15540: 56 10 c0 0e rlwinm r16,r16,24,0,7 <== NOT EXECUTED
ffc15544: 7d f0 83 78 or r16,r15,r16 <== NOT EXECUTED
ffc15548: 92 1f 00 18 stw r16,24(r31) <== NOT EXECUTED
vol->data_fsec = vol->fat_loc + vol->fats * vol->fat_length +
ffc1554c: 80 1f 00 18 lwz r0,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)
ffc15550: 56 31 40 2e rlwinm r17,r17,8,0,23
ffc15554: 7e 32 93 78 or r18,r17,r18
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 +
ffc15558: 7f 7b 01 d6 mullw r27,r27,r0
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)
ffc1555c: 7e 52 07 35 extsh. r18,r18
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 +
ffc15560: 7f 67 da 14 add r27,r7,r27
ffc15564: 7c a5 da 14 add r5,r5,r27
vol->rdir_secs;
/* for FAT12/16 root dir starts at(sector) */
vol->rdir_loc = vol->fat_loc + vol->fats * vol->fat_length;
ffc15568: 93 7f 00 1c stw r27,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 +
ffc1556c: 90 bf 00 30 stw r5,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)
ffc15570: 41 82 00 10 beq- ffc15580 <fat_init_volume_info+0x308> <== NEVER TAKEN
vol->tot_secs = FAT_GET_BR_TOTAL_SECTORS_NUM16(boot_rec);
ffc15574: 56 52 04 3e clrlwi r18,r18,16
ffc15578: 92 5f 00 2c stw r18,44(r31)
ffc1557c: 48 00 00 20 b ffc1559c <fat_init_volume_info+0x324>
else
vol->tot_secs = FAT_GET_BR_TOTAL_SECTORS_NUM32(boot_rec);
ffc15580: 56 73 40 2e rlwinm r19,r19,8,0,23 <== NOT EXECUTED
ffc15584: 56 94 80 1e rlwinm r20,r20,16,0,15 <== NOT EXECUTED
ffc15588: 7e 74 a3 78 or r20,r19,r20 <== NOT EXECUTED
ffc1558c: 7e 95 ab 78 or r21,r20,r21 <== NOT EXECUTED
ffc15590: 56 d6 c0 0e rlwinm r22,r22,24,0,7 <== NOT EXECUTED
ffc15594: 7e b6 b3 78 or r22,r21,r22 <== NOT EXECUTED
ffc15598: 92 df 00 2c stw r22,44(r31) <== NOT EXECUTED
data_secs = vol->tot_secs - vol->data_fsec;
ffc1559c: 80 1f 00 2c lwz r0,44(r31)
ffc155a0: 7c a5 00 50 subf r5,r5,r0
vol->data_cls = data_secs / vol->spc;
ffc155a4: 7f a5 eb 96 divwu r29,r5,r29
/* determine FAT type at least */
if ( vol->data_cls < FAT_FAT12_MAX_CLN)
ffc155a8: 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;
ffc155ac: 93 bf 00 34 stw r29,52(r31)
/* determine FAT type at least */
if ( vol->data_cls < FAT_FAT12_MAX_CLN)
ffc155b0: 41 9d 00 1c bgt- cr7,ffc155cc <fat_init_volume_info+0x354><== NEVER TAKEN
{
vol->type = FAT_FAT12;
ffc155b4: 38 00 00 01 li r0,1
ffc155b8: 98 1f 00 0a stb r0,10(r31)
vol->mask = FAT_FAT12_MASK;
ffc155bc: 38 00 0f ff li r0,4095
ffc155c0: 90 1f 00 0c stw r0,12(r31)
vol->eoc_val = FAT_FAT12_EOC;
ffc155c4: 38 00 0f f8 li r0,4088
ffc155c8: 48 00 00 44 b ffc1560c <fat_init_volume_info+0x394>
}
else
{
if ( vol->data_cls < FAT_FAT16_MAX_CLN)
ffc155cc: 2b 9d ff f4 cmplwi cr7,r29,65524 <== NOT EXECUTED
ffc155d0: 41 9d 00 20 bgt- cr7,ffc155f0 <fat_init_volume_info+0x378><== NOT EXECUTED
{
vol->type = FAT_FAT16;
ffc155d4: 38 00 00 02 li r0,2 <== NOT EXECUTED
ffc155d8: 98 1f 00 0a stb r0,10(r31) <== NOT EXECUTED
vol->mask = FAT_FAT16_MASK;
ffc155dc: 38 00 00 00 li r0,0 <== NOT EXECUTED
ffc155e0: 60 00 ff ff ori r0,r0,65535 <== NOT EXECUTED
ffc155e4: 90 1f 00 0c stw r0,12(r31) <== NOT EXECUTED
vol->eoc_val = FAT_FAT16_EOC;
ffc155e8: 38 00 00 00 li r0,0 <== NOT EXECUTED
ffc155ec: 48 00 00 1c b ffc15608 <fat_init_volume_info+0x390> <== NOT EXECUTED
}
else
{
vol->type = FAT_FAT32;
ffc155f0: 38 00 00 04 li r0,4 <== NOT EXECUTED
ffc155f4: 98 1f 00 0a stb r0,10(r31) <== NOT EXECUTED
vol->mask = FAT_FAT32_MASK;
ffc155f8: 3c 00 0f ff lis r0,4095 <== NOT EXECUTED
ffc155fc: 60 00 ff ff ori r0,r0,65535 <== NOT EXECUTED
ffc15600: 90 1f 00 0c stw r0,12(r31) <== NOT EXECUTED
vol->eoc_val = FAT_FAT32_EOC;
ffc15604: 3c 00 0f ff lis r0,4095 <== NOT EXECUTED
ffc15608: 60 00 ff f8 ori r0,r0,65528 <== NOT EXECUTED
ffc1560c: 90 1f 00 10 stw r0,16(r31)
}
}
if (vol->type == FAT_FAT32)
ffc15610: 88 1f 00 0a lbz r0,10(r31)
ffc15614: 2f 80 00 04 cmpwi cr7,r0,4
ffc15618: 40 be 01 80 bne+ cr7,ffc15798 <fat_init_volume_info+0x520><== ALWAYS TAKEN
{
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;
ffc1561c: 57 80 00 30 rlwinm r0,r28,0,0,24 <== NOT EXECUTED
ffc15620: 54 00 06 3e clrlwi r0,r0,24 <== NOT EXECUTED
if (vol->mirror)
ffc15624: 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);
vol->mirror = FAT_GET_BR_EXT_FLAGS(boot_rec) & FAT_BR_EXT_FLAGS_MIRROR;
ffc15628: 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);
ffc1562c: 56 f7 40 2e rlwinm r23,r23,8,0,23 <== NOT EXECUTED
ffc15630: 57 18 80 1e rlwinm r24,r24,16,0,15 <== NOT EXECUTED
ffc15634: 7e f8 c3 78 or r24,r23,r24 <== NOT EXECUTED
ffc15638: 7f 19 cb 78 or r25,r24,r25 <== NOT EXECUTED
ffc1563c: 57 5a c0 0e rlwinm r26,r26,24,0,7 <== NOT EXECUTED
ffc15640: 7f 3a d3 78 or r26,r25,r26 <== NOT EXECUTED
ffc15644: 93 5f 00 38 stw r26,56(r31) <== NOT EXECUTED
vol->mirror = FAT_GET_BR_EXT_FLAGS(boot_rec) & FAT_BR_EXT_FLAGS_MIRROR;
if (vol->mirror)
ffc15648: 41 9e 00 10 beq- cr7,ffc15658 <fat_init_volume_info+0x3e0><== NOT EXECUTED
vol->afat = FAT_GET_BR_EXT_FLAGS(boot_rec) & FAT_BR_EXT_FLAGS_FAT_NUM;
ffc1564c: 57 9c 07 3e clrlwi r28,r28,28 <== NOT EXECUTED
ffc15650: 9b 9f 00 50 stb r28,80(r31) <== NOT EXECUTED
ffc15654: 48 00 00 08 b ffc1565c <fat_init_volume_info+0x3e4> <== NOT EXECUTED
else
vol->afat = 0;
ffc15658: 98 1f 00 50 stb r0,80(r31) <== NOT EXECUTED
vol->info_sec = FAT_GET_BR_FAT32_FS_INFO_SECTOR(boot_rec);
ffc1565c: 80 a1 00 68 lwz r5,104(r1) <== NOT EXECUTED
ffc15660: 55 8c 40 2e rlwinm r12,r12,8,0,23 <== NOT EXECUTED
ffc15664: 7d 84 2b 78 or r4,r12,r5 <== NOT EXECUTED
if( vol->info_sec == 0 )
ffc15668: 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);
ffc1566c: b0 9f 00 3c sth r4,60(r31) <== NOT EXECUTED
if( vol->info_sec == 0 )
ffc15670: 41 9e 00 5c beq- cr7,ffc156cc <fat_init_volume_info+0x454><== 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,
ffc15674: 7f c3 f3 78 mr r3,r30 <== NOT EXECUTED
ffc15678: 38 a0 00 00 li r5,0 <== NOT EXECUTED
ffc1567c: 38 c0 00 04 li r6,4 <== NOT EXECUTED
ffc15680: 38 e1 00 0c addi r7,r1,12 <== NOT EXECUTED
ffc15684: 4b ff f6 71 bl ffc14cf4 <_fat_block_read> <== NOT EXECUTED
FAT_FSI_LEADSIG_SIZE, fs_info_sector);
if ( ret < 0 )
ffc15688: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc1568c: 41 9c 00 7c blt- cr7,ffc15708 <fat_init_volume_info+0x490><== NOT EXECUTED
{
rtems_disk_release(vol->dd);
return -1;
}
if (FAT_GET_FSINFO_LEAD_SIGNATURE(fs_info_sector) !=
ffc15690: 89 21 00 0d lbz r9,13(r1) <== NOT EXECUTED
ffc15694: 88 01 00 0e lbz r0,14(r1) <== NOT EXECUTED
ffc15698: 55 29 40 2e rlwinm r9,r9,8,0,23 <== NOT EXECUTED
ffc1569c: 54 00 80 1e rlwinm r0,r0,16,0,15 <== NOT EXECUTED
ffc156a0: 7d 29 03 78 or r9,r9,r0 <== NOT EXECUTED
ffc156a4: 88 01 00 0c lbz r0,12(r1) <== NOT EXECUTED
ffc156a8: 7d 29 03 78 or r9,r9,r0 <== NOT EXECUTED
ffc156ac: 88 01 00 0f lbz r0,15(r1) <== NOT EXECUTED
ffc156b0: 54 00 c0 0e rlwinm r0,r0,24,0,7 <== NOT EXECUTED
ffc156b4: 7d 29 03 78 or r9,r9,r0 <== NOT EXECUTED
ffc156b8: 6d 20 41 61 xoris r0,r9,16737 <== NOT EXECUTED
ffc156bc: 2f 80 52 52 cmpwi cr7,r0,21074 <== NOT EXECUTED
ffc156c0: 41 9e 00 20 beq- cr7,ffc156e0 <fat_init_volume_info+0x468><== 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);
ffc156c4: 80 7e 00 34 lwz r3,52(r30) <== NOT EXECUTED
ffc156c8: 4b ff f4 d9 bl ffc14ba0 <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);
ffc156cc: 80 7f 00 60 lwz r3,96(r31) <== NOT EXECUTED
ffc156d0: 4b ff 12 21 bl ffc068f0 <rtems_disk_release> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
ffc156d4: 48 00 8b 05 bl ffc1e1d8 <__errno> <== NOT EXECUTED
ffc156d8: 38 00 00 16 li r0,22 <== NOT EXECUTED
ffc156dc: 48 00 02 2c b ffc15908 <fat_init_volume_info+0x690> <== NOT EXECUTED
}
else
{
ret = _fat_block_read(mt_entry, vol->info_sec , FAT_FSI_INFO,
ffc156e0: a0 9f 00 3c lhz r4,60(r31) <== NOT EXECUTED
ffc156e4: 7f c3 f3 78 mr r3,r30 <== NOT EXECUTED
ffc156e8: 38 a0 01 e4 li r5,484 <== NOT EXECUTED
ffc156ec: 38 c0 00 0c li r6,12 <== NOT EXECUTED
ffc156f0: 38 e1 00 0c addi r7,r1,12 <== NOT EXECUTED
ffc156f4: 4b ff f6 01 bl ffc14cf4 <_fat_block_read> <== NOT EXECUTED
FAT_USEFUL_INFO_SIZE, fs_info_sector);
if ( ret < 0 )
ffc156f8: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc156fc: 40 bc 00 18 bge+ cr7,ffc15714 <fat_init_volume_info+0x49c><== 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);
ffc15700: 80 7e 00 34 lwz r3,52(r30) <== NOT EXECUTED
ffc15704: 4b ff f4 9d bl ffc14ba0 <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);
ffc15708: 80 7f 00 60 lwz r3,96(r31) <== NOT EXECUTED
ffc1570c: 4b ff 11 e5 bl ffc068f0 <rtems_disk_release> <== NOT EXECUTED
ffc15710: 48 00 01 fc b ffc1590c <fat_init_volume_info+0x694> <== NOT EXECUTED
return -1;
}
vol->free_cls = FAT_GET_FSINFO_FREE_CLUSTER_COUNT(fs_info_sector);
ffc15714: 89 21 00 11 lbz r9,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,
ffc15718: 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);
ffc1571c: 88 01 00 12 lbz r0,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,
ffc15720: 38 80 ff ff li r4,-1 <== 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);
ffc15724: 55 29 40 2e rlwinm r9,r9,8,0,23 <== NOT EXECUTED
ffc15728: 54 00 80 1e rlwinm r0,r0,16,0,15 <== NOT EXECUTED
ffc1572c: 7d 20 03 78 or r0,r9,r0 <== NOT EXECUTED
ffc15730: 89 21 00 10 lbz r9,16(r1) <== NOT EXECUTED
vol->next_cl = FAT_GET_FSINFO_NEXT_FREE_CLUSTER(fs_info_sector);
rc = fat_fat32_update_fsinfo_sector(mt_entry, 0xFFFFFFFF,
ffc15734: 38 a0 ff ff li r5,-1 <== 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);
ffc15738: 7c 00 4b 78 or r0,r0,r9 <== NOT EXECUTED
ffc1573c: 89 21 00 13 lbz r9,19(r1) <== NOT EXECUTED
ffc15740: 55 29 c0 0e rlwinm r9,r9,24,0,7 <== NOT EXECUTED
ffc15744: 7c 00 4b 78 or r0,r0,r9 <== NOT EXECUTED
vol->next_cl = FAT_GET_FSINFO_NEXT_FREE_CLUSTER(fs_info_sector);
ffc15748: 89 21 00 15 lbz r9,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);
ffc1574c: 90 1f 00 40 stw r0,64(r31) <== NOT EXECUTED
vol->next_cl = FAT_GET_FSINFO_NEXT_FREE_CLUSTER(fs_info_sector);
ffc15750: 55 29 40 2e rlwinm r9,r9,8,0,23 <== NOT EXECUTED
ffc15754: 88 01 00 16 lbz r0,22(r1) <== NOT EXECUTED
ffc15758: 54 00 80 1e rlwinm r0,r0,16,0,15 <== NOT EXECUTED
ffc1575c: 7d 20 03 78 or r0,r9,r0 <== NOT EXECUTED
ffc15760: 89 21 00 14 lbz r9,20(r1) <== NOT EXECUTED
ffc15764: 7c 00 4b 78 or r0,r0,r9 <== NOT EXECUTED
ffc15768: 89 21 00 17 lbz r9,23(r1) <== NOT EXECUTED
ffc1576c: 55 29 c0 0e rlwinm r9,r9,24,0,7 <== NOT EXECUTED
ffc15770: 7c 00 4b 78 or r0,r0,r9 <== NOT EXECUTED
ffc15774: 90 1f 00 44 stw r0,68(r31) <== NOT EXECUTED
rc = fat_fat32_update_fsinfo_sector(mt_entry, 0xFFFFFFFF,
ffc15778: 4b ff f9 71 bl ffc150e8 <fat_fat32_update_fsinfo_sector><== NOT EXECUTED
0xFFFFFFFF);
if ( rc != RC_OK )
ffc1577c: 7c 7d 1b 79 mr. r29,r3 <== NOT EXECUTED
ffc15780: 41 a2 00 34 beq+ ffc157b4 <fat_init_volume_info+0x53c> <== 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);
ffc15784: 80 7e 00 34 lwz r3,52(r30) <== NOT EXECUTED
ffc15788: 4b ff f4 19 bl ffc14ba0 <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);
ffc1578c: 80 7f 00 60 lwz r3,96(r31) <== NOT EXECUTED
ffc15790: 4b ff 11 61 bl ffc068f0 <rtems_disk_release> <== NOT EXECUTED
return rc;
ffc15794: 48 00 01 7c b ffc15910 <fat_init_volume_info+0x698> <== NOT EXECUTED
}
}
}
else
{
vol->rdir_cl = 0;
ffc15798: 38 00 00 00 li r0,0
ffc1579c: 90 1f 00 38 stw r0,56(r31)
vol->mirror = 0;
ffc157a0: 98 1f 00 48 stb r0,72(r31)
vol->afat = 0;
ffc157a4: 98 1f 00 50 stb r0,80(r31)
vol->free_cls = 0xFFFFFFFF;
ffc157a8: 38 00 ff ff li r0,-1
ffc157ac: 90 1f 00 40 stw r0,64(r31)
vol->next_cl = 0xFFFFFFFF;
ffc157b0: 90 1f 00 44 stw r0,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);
ffc157b4: 80 7e 00 34 lwz r3,52(r30)
ffc157b8: 4b ff f3 e9 bl ffc14ba0 <fat_buf_release>
vol->next_cl = 0xFFFFFFFF;
}
_fat_block_release(mt_entry);
vol->afat_loc = vol->fat_loc + vol->fat_length * vol->afat;
ffc157bc: 89 3f 00 50 lbz r9,80(r31)
ffc157c0: 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));
ffc157c4: 38 60 00 02 li r3,2
ffc157c8: 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;
ffc157cc: 7c 09 01 d6 mullw r0,r9,r0
ffc157d0: a1 3f 00 14 lhz r9,20(r31)
ffc157d4: 7c 00 4a 14 add r0,r0,r9
ffc157d8: 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));
ffc157dc: 4b ff 1b fd bl ffc073d8 <calloc>
if ( fs_info->vhash == NULL )
ffc157e0: 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));
ffc157e4: 90 7f 00 68 stw r3,104(r31)
if ( fs_info->vhash == NULL )
ffc157e8: 41 9e 00 48 beq- cr7,ffc15830 <fat_init_volume_info+0x5b8><== 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 );
ffc157ec: 38 03 00 04 addi r0,r3,4
head->next = tail;
head->previous = NULL;
tail->previous = head;
ffc157f0: 90 63 00 08 stw r3,8(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 );
ffc157f4: 39 23 00 10 addi r9,r3,16
head->next = tail;
ffc157f8: 90 03 00 00 stw r0,0(r3)
head->previous = NULL;
ffc157fc: 3b c0 00 00 li r30,0
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 );
ffc15800: 38 03 00 0c addi r0,r3,12
head->next = tail;
head->previous = NULL;
ffc15804: 93 c3 00 04 stw r30,4(r3)
}
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));
ffc15808: 38 80 00 0c li r4,12
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
ffc1580c: 91 23 00 0c stw r9,12(r3)
head->previous = NULL;
ffc15810: 93 c3 00 10 stw r30,16(r3)
tail->previous = head;
ffc15814: 90 03 00 14 stw r0,20(r3)
ffc15818: 38 60 00 02 li r3,2
ffc1581c: 4b ff 1b bd bl ffc073d8 <calloc>
if ( fs_info->rhash == NULL )
ffc15820: 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));
ffc15824: 90 7f 00 6c stw r3,108(r31)
if ( fs_info->rhash == NULL )
ffc15828: 40 be 00 14 bne+ cr7,ffc1583c <fat_init_volume_info+0x5c4><== ALWAYS TAKEN
ffc1582c: 48 00 00 70 b ffc1589c <fat_init_volume_info+0x624> <== 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);
ffc15830: 80 7f 00 60 lwz r3,96(r31) <== NOT EXECUTED
ffc15834: 4b ff 10 bd bl ffc068f0 <rtems_disk_release> <== NOT EXECUTED
ffc15838: 48 00 00 c8 b ffc15900 <fat_init_volume_info+0x688> <== 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 );
ffc1583c: 38 03 00 04 addi r0,r3,4
head->next = tail;
head->previous = NULL;
ffc15840: 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 );
ffc15844: 39 23 00 10 addi r9,r3,16
head->next = tail;
ffc15848: 90 03 00 00 stw r0,0(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 );
ffc1584c: 38 03 00 0c addi r0,r3,12
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));
ffc15850: 38 80 00 01 li r4,1
head->next = tail;
ffc15854: 91 23 00 0c stw r9,12(r3)
head->previous = NULL;
tail->previous = head;
ffc15858: 90 03 00 14 stw r0,20(r3)
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;
ffc1585c: 38 00 01 00 li r0,256
ffc15860: 90 63 00 08 stw r3,8(r3)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
head->previous = NULL;
ffc15864: 93 c3 00 10 stw r30,16(r3)
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));
ffc15868: 38 60 01 00 li r3,256
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;
ffc1586c: 90 1f 00 78 stw r0,120(r31)
fs_info->uino_base = (vol->tot_secs << vol->sec_mul) << 4;
ffc15870: 81 3f 00 2c lwz r9,44(r31)
ffc15874: 88 1f 00 03 lbz r0,3(r31)
fs_info->index = 0;
ffc15878: 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;
ffc1587c: 7d 20 00 30 slw r0,r9,r0
ffc15880: 54 00 20 36 rlwinm r0,r0,4,0,27
ffc15884: 90 1f 00 7c stw r0,124(r31)
fs_info->index = 0;
fs_info->uino = (char *)calloc(fs_info->uino_pool_size, sizeof(char));
ffc15888: 4b ff 1b 51 bl ffc073d8 <calloc>
if ( fs_info->uino == NULL )
ffc1588c: 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));
ffc15890: 90 7f 00 70 stw r3,112(r31)
if ( fs_info->uino == NULL )
ffc15894: 40 be 00 30 bne+ cr7,ffc158c4 <fat_init_volume_info+0x64c><== ALWAYS TAKEN
ffc15898: 48 00 00 14 b ffc158ac <fat_init_volume_info+0x634> <== 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);
ffc1589c: 80 7f 00 60 lwz r3,96(r31) <== NOT EXECUTED
ffc158a0: 4b ff 10 51 bl ffc068f0 <rtems_disk_release> <== NOT EXECUTED
free(fs_info->vhash);
ffc158a4: 80 7f 00 68 lwz r3,104(r31) <== NOT EXECUTED
ffc158a8: 48 00 00 54 b ffc158fc <fat_init_volume_info+0x684> <== 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);
ffc158ac: 80 7f 00 60 lwz r3,96(r31) <== NOT EXECUTED
ffc158b0: 4b ff 10 41 bl ffc068f0 <rtems_disk_release> <== NOT EXECUTED
free(fs_info->vhash);
ffc158b4: 80 7f 00 68 lwz r3,104(r31) <== NOT EXECUTED
ffc158b8: 4b ff 20 31 bl ffc078e8 <free> <== NOT EXECUTED
free(fs_info->rhash);
ffc158bc: 80 7f 00 6c lwz r3,108(r31) <== NOT EXECUTED
ffc158c0: 48 00 00 3c b ffc158fc <fat_init_volume_info+0x684> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOMEM );
}
fs_info->sec_buf = (uint8_t *)calloc(vol->bps, sizeof(uint8_t));
ffc158c4: a0 7f 00 00 lhz r3,0(r31)
ffc158c8: 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;
ffc158cc: 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));
ffc158d0: 4b ff 1b 09 bl ffc073d8 <calloc>
if (fs_info->sec_buf == NULL)
ffc158d4: 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));
ffc158d8: 90 7f 00 8c stw r3,140(r31)
if (fs_info->sec_buf == NULL)
ffc158dc: 40 be 00 34 bne+ cr7,ffc15910 <fat_init_volume_info+0x698><== ALWAYS TAKEN
{
rtems_disk_release(vol->dd);
ffc158e0: 80 7f 00 60 lwz r3,96(r31) <== NOT EXECUTED
ffc158e4: 4b ff 10 0d bl ffc068f0 <rtems_disk_release> <== NOT EXECUTED
free(fs_info->vhash);
ffc158e8: 80 7f 00 68 lwz r3,104(r31) <== NOT EXECUTED
ffc158ec: 4b ff 1f fd bl ffc078e8 <free> <== NOT EXECUTED
free(fs_info->rhash);
ffc158f0: 80 7f 00 6c lwz r3,108(r31) <== NOT EXECUTED
ffc158f4: 4b ff 1f f5 bl ffc078e8 <free> <== NOT EXECUTED
free(fs_info->uino);
ffc158f8: 80 7f 00 70 lwz r3,112(r31) <== NOT EXECUTED
ffc158fc: 4b ff 1f ed bl ffc078e8 <free> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOMEM );
ffc15900: 48 00 88 d9 bl ffc1e1d8 <__errno> <== NOT EXECUTED
ffc15904: 38 00 00 0c li r0,12 <== NOT EXECUTED
ffc15908: 90 03 00 00 stw r0,0(r3) <== NOT EXECUTED
ffc1590c: 3b a0 ff ff li r29,-1 <== NOT EXECUTED
}
return RC_OK;
}
ffc15910: 39 61 00 e0 addi r11,r1,224
ffc15914: 7f a3 eb 78 mr r3,r29
ffc15918: 4b fe d1 9c b ffc02ab4 <_restgpr_14_x>
ffc1c8cc <fat_scan_fat_for_free_clusters>:
uint32_t *chain,
uint32_t count,
uint32_t *cls_added,
uint32_t *last_cl
)
{
ffc1c8cc: 94 21 ff b8 stwu r1,-72(r1)
ffc1c8d0: 7c 08 02 a6 mflr r0
ffc1c8d4: 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;
ffc1c8d8: 38 00 00 00 li r0,0
uint32_t *chain,
uint32_t count,
uint32_t *cls_added,
uint32_t *last_cl
)
{
ffc1c8dc: be 81 00 18 stmw r20,24(r1)
uint32_t data_cls_val = fs_info->vol.data_cls + 2;
uint32_t i = 2;
*cls_added = 0;
if (count == 0)
ffc1c8e0: 7c b5 2b 79 mr. r21,r5
uint32_t *chain,
uint32_t count,
uint32_t *cls_added,
uint32_t *last_cl
)
{
ffc1c8e4: 7c 7f 1b 78 mr r31,r3
int rc = RC_OK;
fat_fs_info_t *fs_info = mt_entry->fs_info;
ffc1c8e8: 83 63 00 34 lwz r27,52(r3)
uint32_t *chain,
uint32_t count,
uint32_t *cls_added,
uint32_t *last_cl
)
{
ffc1c8ec: 7c 9e 23 78 mr r30,r4
ffc1c8f0: 7c dd 33 78 mr r29,r6
int rc = RC_OK;
fat_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t cl4find = 2;
uint32_t next_cln = 0;
ffc1c8f4: 90 01 00 08 stw r0,8(r1)
uint32_t *chain,
uint32_t count,
uint32_t *cls_added,
uint32_t *last_cl
)
{
ffc1c8f8: 7c f7 3b 78 mr r23,r7
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;
ffc1c8fc: 82 db 00 34 lwz r22,52(r27)
uint32_t i = 2;
*cls_added = 0;
if (count == 0)
return rc;
ffc1c900: 3b 40 00 00 li r26,0
uint32_t next_cln = 0;
uint32_t save_cln = 0;
uint32_t data_cls_val = fs_info->vol.data_cls + 2;
uint32_t i = 2;
*cls_added = 0;
ffc1c904: 90 06 00 00 stw r0,0(r6)
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;
ffc1c908: 3a d6 00 02 addi r22,r22,2
uint32_t i = 2;
*cls_added = 0;
if (count == 0)
ffc1c90c: 41 82 01 8c beq- ffc1ca98 <fat_scan_fat_for_free_clusters+0x1cc><== NEVER TAKEN
return rc;
if (fs_info->vol.next_cl != FAT_UNDEFINED_VALUE)
ffc1c910: 83 9b 00 44 lwz r28,68(r27)
ffc1c914: 2f 9c ff ff cmpwi cr7,r28,-1
ffc1c918: 40 be 00 08 bne+ cr7,ffc1c920 <fat_scan_fat_for_free_clusters+0x54>
uint32_t *last_cl
)
{
int rc = RC_OK;
fat_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t cl4find = 2;
ffc1c91c: 3b 80 00 02 li r28,2
}
}
i++;
cl4find++;
if (cl4find >= data_cls_val)
cl4find = 2;
ffc1c920: 3b 00 00 02 li r24,2
ffc1c924: 3b 20 00 00 li r25,0
ffc1c928: 48 00 01 34 b ffc1ca5c <fat_scan_fat_for_free_clusters+0x190>
* starting at cluster 2, so the maximum valid cluster number is
* (fs_info->vol.data_cls + 1)
*/
while (i < data_cls_val)
{
rc = fat_get_fat_cluster(mt_entry, cl4find, &next_cln);
ffc1c92c: 7f e3 fb 78 mr r3,r31
ffc1c930: 7f 84 e3 78 mr r4,r28
ffc1c934: 38 a1 00 08 addi r5,r1,8
ffc1c938: 4b ff fa 69 bl ffc1c3a0 <fat_get_fat_cluster>
if ( rc != RC_OK )
ffc1c93c: 7c 7a 1b 79 mr. r26,r3
ffc1c940: 41 a2 00 20 beq+ ffc1c960 <fat_scan_fat_for_free_clusters+0x94><== ALWAYS TAKEN
{
if (*cls_added != 0)
ffc1c944: 80 1d 00 00 lwz r0,0(r29) <== NOT EXECUTED
ffc1c948: 2f 80 00 00 cmpwi cr7,r0,0 <== NOT EXECUTED
ffc1c94c: 41 be 01 4c beq+ cr7,ffc1ca98 <fat_scan_fat_for_free_clusters+0x1cc><== NOT EXECUTED
fat_free_fat_clusters_chain(mt_entry, (*chain));
ffc1c950: 80 9e 00 00 lwz r4,0(r30) <== NOT EXECUTED
ffc1c954: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc1c958: 4b ff fe 9d bl ffc1c7f4 <fat_free_fat_clusters_chain> <== NOT EXECUTED
ffc1c95c: 48 00 01 3c b ffc1ca98 <fat_scan_fat_for_free_clusters+0x1cc><== NOT EXECUTED
return rc;
}
if (next_cln == FAT_GENFAT_FREE)
ffc1c960: 80 01 00 08 lwz r0,8(r1)
ffc1c964: 2f 80 00 00 cmpwi cr7,r0,0
ffc1c968: 40 9e 00 e0 bne- cr7,ffc1ca48 <fat_scan_fat_for_free_clusters+0x17c>
/*
* 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)
ffc1c96c: 80 1d 00 00 lwz r0,0(r29)
ffc1c970: 2f 80 00 00 cmpwi cr7,r0,0
ffc1c974: 40 9e 00 24 bne- cr7,ffc1c998 <fat_scan_fat_for_free_clusters+0xcc><== NEVER TAKEN
{
*chain = cl4find;
ffc1c978: 93 9e 00 00 stw r28,0(r30)
rc = fat_set_fat_cluster(mt_entry, cl4find, FAT_GENFAT_EOC);
ffc1c97c: 7f e3 fb 78 mr r3,r31
ffc1c980: 7f 84 e3 78 mr r4,r28
ffc1c984: 38 a0 ff ff li r5,-1
ffc1c988: 4b ff fb d5 bl ffc1c55c <fat_set_fat_cluster>
if ( rc != RC_OK )
ffc1c98c: 2c 03 00 00 cmpwi r3,0
ffc1c990: 41 a2 00 74 beq+ ffc1ca04 <fat_scan_fat_for_free_clusters+0x138><== ALWAYS TAKEN
ffc1c994: 48 00 01 00 b ffc1ca94 <fat_scan_fat_for_free_clusters+0x1c8><== NOT EXECUTED
}
}
else
{
/* set EOC value to new allocated cluster */
rc = fat_set_fat_cluster(mt_entry, cl4find, FAT_GENFAT_EOC);
ffc1c998: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc1c99c: 7f 84 e3 78 mr r4,r28 <== NOT EXECUTED
ffc1c9a0: 38 a0 ff ff li r5,-1 <== NOT EXECUTED
ffc1c9a4: 4b ff fb b9 bl ffc1c55c <fat_set_fat_cluster> <== NOT EXECUTED
if ( rc != RC_OK )
ffc1c9a8: 7c 74 1b 79 mr. r20,r3 <== NOT EXECUTED
{
/* cleanup activity */
fat_free_fat_clusters_chain(mt_entry, (*chain));
ffc1c9ac: 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);
if ( rc != RC_OK )
ffc1c9b0: 41 a2 00 14 beq+ ffc1c9c4 <fat_scan_fat_for_free_clusters+0xf8><== NOT EXECUTED
{
/* cleanup activity */
fat_free_fat_clusters_chain(mt_entry, (*chain));
ffc1c9b4: 80 9e 00 00 lwz r4,0(r30) <== NOT EXECUTED
}
}
else
{
/* set EOC value to new allocated cluster */
rc = fat_set_fat_cluster(mt_entry, cl4find, FAT_GENFAT_EOC);
ffc1c9b8: 7e 9a a3 78 mr r26,r20 <== NOT EXECUTED
if ( rc != RC_OK )
{
/* cleanup activity */
fat_free_fat_clusters_chain(mt_entry, (*chain));
ffc1c9bc: 4b ff fe 39 bl ffc1c7f4 <fat_free_fat_clusters_chain> <== NOT EXECUTED
return rc;
ffc1c9c0: 48 00 00 d8 b ffc1ca98 <fat_scan_fat_for_free_clusters+0x1cc><== NOT EXECUTED
}
rc = fat_set_fat_cluster(mt_entry, save_cln, cl4find);
ffc1c9c4: 7f 24 cb 78 mr r4,r25 <== NOT EXECUTED
ffc1c9c8: 7f 85 e3 78 mr r5,r28 <== NOT EXECUTED
ffc1c9cc: 4b ff fb 91 bl ffc1c55c <fat_set_fat_cluster> <== NOT EXECUTED
if ( rc != RC_OK )
ffc1c9d0: 7c 79 1b 79 mr. r25,r3 <== NOT EXECUTED
ffc1c9d4: 41 a2 00 30 beq+ ffc1ca04 <fat_scan_fat_for_free_clusters+0x138><== NOT EXECUTED
{
/* cleanup activity */
fat_free_fat_clusters_chain(mt_entry, (*chain));
ffc1c9d8: 80 9e 00 00 lwz r4,0(r30) <== NOT EXECUTED
ffc1c9dc: 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);
ffc1c9e0: 7f 3a cb 78 mr r26,r25 <== NOT EXECUTED
if ( rc != RC_OK )
{
/* cleanup activity */
fat_free_fat_clusters_chain(mt_entry, (*chain));
ffc1c9e4: 4b ff fe 11 bl ffc1c7f4 <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);
ffc1c9e8: 7f 84 e3 78 mr r4,r28 <== NOT EXECUTED
ffc1c9ec: 38 a0 00 00 li r5,0 <== NOT EXECUTED
ffc1c9f0: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc1c9f4: 4b ff fb 69 bl ffc1c55c <fat_set_fat_cluster> <== NOT EXECUTED
fat_buf_release(fs_info);
ffc1c9f8: 7f 63 db 78 mr r3,r27 <== NOT EXECUTED
ffc1c9fc: 4b ff 81 a5 bl ffc14ba0 <fat_buf_release> <== NOT EXECUTED
return rc;
ffc1ca00: 48 00 00 98 b ffc1ca98 <fat_scan_fat_for_free_clusters+0x1cc><== NOT EXECUTED
}
}
save_cln = cl4find;
(*cls_added)++;
ffc1ca04: 81 3d 00 00 lwz r9,0(r29)
ffc1ca08: 38 09 00 01 addi r0,r9,1
/* have we satisfied request ? */
if (*cls_added == count)
ffc1ca0c: 7f 80 a8 00 cmpw cr7,r0,r21
return rc;
}
}
save_cln = cl4find;
(*cls_added)++;
ffc1ca10: 90 1d 00 00 stw r0,0(r29)
/* have we satisfied request ? */
if (*cls_added == count)
ffc1ca14: 40 be 00 30 bne+ cr7,ffc1ca44 <fat_scan_fat_for_free_clusters+0x178><== NEVER TAKEN
{
fs_info->vol.next_cl = save_cln;
if (fs_info->vol.free_cls != 0xFFFFFFFF)
ffc1ca18: 80 1b 00 40 lwz r0,64(r27)
(*cls_added)++;
/* have we satisfied request ? */
if (*cls_added == count)
{
fs_info->vol.next_cl = save_cln;
ffc1ca1c: 93 9b 00 44 stw r28,68(r27)
if (fs_info->vol.free_cls != 0xFFFFFFFF)
ffc1ca20: 2f 80 ff ff cmpwi cr7,r0,-1
ffc1ca24: 41 9e 00 10 beq- cr7,ffc1ca34 <fat_scan_fat_for_free_clusters+0x168><== ALWAYS TAKEN
fs_info->vol.free_cls -= (*cls_added);
ffc1ca28: 81 3d 00 00 lwz r9,0(r29) <== NOT EXECUTED
ffc1ca2c: 7c 09 00 50 subf r0,r9,r0 <== NOT EXECUTED
ffc1ca30: 90 1b 00 40 stw r0,64(r27) <== NOT EXECUTED
*last_cl = save_cln;
ffc1ca34: 93 97 00 00 stw r28,0(r23)
fat_buf_release(fs_info);
ffc1ca38: 7f 63 db 78 mr r3,r27
ffc1ca3c: 4b ff 81 65 bl ffc14ba0 <fat_buf_release>
return rc;
ffc1ca40: 48 00 00 58 b ffc1ca98 <fat_scan_fat_for_free_clusters+0x1cc>
save_cln = cl4find;
(*cls_added)++;
/* have we satisfied request ? */
if (*cls_added == count)
ffc1ca44: 7f 99 e3 78 mr r25,r28 <== NOT EXECUTED
fat_buf_release(fs_info);
return rc;
}
}
i++;
cl4find++;
ffc1ca48: 3b 9c 00 01 addi r28,r28,1
if (cl4find >= data_cls_val)
ffc1ca4c: 7f 9c b0 40 cmplw cr7,r28,r22
*last_cl = save_cln;
fat_buf_release(fs_info);
return rc;
}
}
i++;
ffc1ca50: 3b 18 00 01 addi r24,r24,1
cl4find++;
if (cl4find >= data_cls_val)
ffc1ca54: 41 9c 00 08 blt- cr7,ffc1ca5c <fat_scan_fat_for_free_clusters+0x190><== ALWAYS TAKEN
cl4find = 2;
ffc1ca58: 3b 80 00 02 li r28,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)
ffc1ca5c: 7f 98 b0 40 cmplw cr7,r24,r22
ffc1ca60: 41 9c fe cc blt+ cr7,ffc1c92c <fat_scan_fat_for_free_clusters+0x60><== ALWAYS TAKEN
if (cl4find >= data_cls_val)
cl4find = 2;
}
fs_info->vol.next_cl = save_cln;
if (fs_info->vol.free_cls != 0xFFFFFFFF)
ffc1ca64: 80 1b 00 40 lwz r0,64(r27) <== NOT EXECUTED
cl4find++;
if (cl4find >= data_cls_val)
cl4find = 2;
}
fs_info->vol.next_cl = save_cln;
ffc1ca68: 93 3b 00 44 stw r25,68(r27) <== NOT EXECUTED
if (fs_info->vol.free_cls != 0xFFFFFFFF)
ffc1ca6c: 2f 80 ff ff cmpwi cr7,r0,-1 <== NOT EXECUTED
ffc1ca70: 41 9e 00 10 beq- cr7,ffc1ca80 <fat_scan_fat_for_free_clusters+0x1b4><== NOT EXECUTED
fs_info->vol.free_cls -= (*cls_added);
ffc1ca74: 81 3d 00 00 lwz r9,0(r29) <== NOT EXECUTED
ffc1ca78: 7c 09 00 50 subf r0,r9,r0 <== NOT EXECUTED
ffc1ca7c: 90 1b 00 40 stw r0,64(r27) <== NOT EXECUTED
*last_cl = save_cln;
ffc1ca80: 93 37 00 00 stw r25,0(r23) <== NOT EXECUTED
fat_buf_release(fs_info);
ffc1ca84: 7f 63 db 78 mr r3,r27 <== NOT EXECUTED
return RC_OK;
ffc1ca88: 3b 40 00 00 li r26,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);
ffc1ca8c: 4b ff 81 15 bl ffc14ba0 <fat_buf_release> <== NOT EXECUTED
return RC_OK;
ffc1ca90: 48 00 00 08 b ffc1ca98 <fat_scan_fat_for_free_clusters+0x1cc><== NOT EXECUTED
* wouldn't work properly
*/
if (*cls_added == 0)
{
*chain = cl4find;
rc = fat_set_fat_cluster(mt_entry, cl4find, FAT_GENFAT_EOC);
ffc1ca94: 7c 7a 1b 78 mr r26,r3 <== NOT EXECUTED
fs_info->vol.free_cls -= (*cls_added);
*last_cl = save_cln;
fat_buf_release(fs_info);
return RC_OK;
}
ffc1ca98: 39 61 00 48 addi r11,r1,72
ffc1ca9c: 7f 43 d3 78 mr r3,r26
ffc1caa0: 4b fe 60 2c b ffc02acc <_restgpr_20_x>
ffc1c55c <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)) )
ffc1c55c: 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
)
{
ffc1c560: 94 21 ff d0 stwu r1,-48(r1)
ffc1c564: 7c 08 02 a6 mflr r0
ffc1c568: bf 41 00 18 stmw r26,24(r1)
ffc1c56c: 7c 9e 23 78 mr r30,r4
ffc1c570: 7c bc 2b 78 mr r28,r5
ffc1c574: 90 01 00 34 stw r0,52(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;
ffc1c578: 38 00 00 00 li r0,0
uint32_t cln,
uint32_t in_val
)
{
int rc = RC_OK;
fat_fs_info_t *fs_info = mt_entry->fs_info;
ffc1c57c: 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;
ffc1c580: 90 01 00 08 stw r0,8(r1)
/* sanity check */
if ( (cln < 2) || (cln > (fs_info->vol.data_cls + 1)) )
ffc1c584: 40 9d 02 58 ble- cr7,ffc1c7dc <fat_set_fat_cluster+0x280><== NEVER TAKEN
ffc1c588: 81 3f 00 34 lwz r9,52(r31)
ffc1c58c: 38 09 00 01 addi r0,r9,1
ffc1c590: 7f 84 00 40 cmplw cr7,r4,r0
ffc1c594: 41 9d 02 48 bgt- cr7,ffc1c7dc <fat_set_fat_cluster+0x280><== NEVER TAKEN
rtems_set_errno_and_return_minus_one(EIO);
sec = (FAT_FAT_OFFSET(fs_info->vol.type, cln) >> fs_info->vol.sec_log2) +
ffc1c598: 88 1f 00 0a lbz r0,10(r31)
ffc1c59c: 54 9b f8 7e rlwinm r27,r4,31,1,31
ffc1c5a0: 7f 7b 22 14 add r27,r27,r4
ffc1c5a4: 70 09 00 01 andi. r9,r0,1
ffc1c5a8: 40 82 00 14 bne- ffc1c5bc <fat_set_fat_cluster+0x60> <== ALWAYS TAKEN
ffc1c5ac: 70 0b 00 02 andi. r11,r0,2 <== NOT EXECUTED
ffc1c5b0: 54 9b 10 3a rlwinm r27,r4,2,0,29 <== NOT EXECUTED
ffc1c5b4: 41 82 00 08 beq- ffc1c5bc <fat_set_fat_cluster+0x60> <== NOT EXECUTED
ffc1c5b8: 54 9b 08 3c rlwinm r27,r4,1,0,30 <== NOT EXECUTED
fs_info->vol.afat_loc;
ofs = FAT_FAT_OFFSET(fs_info->vol.type, cln) & (fs_info->vol.bps - 1);
ffc1c5bc: 2f 89 00 00 cmpwi cr7,r9,0
/* 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) +
ffc1c5c0: 89 7f 00 02 lbz r11,2(r31)
fs_info->vol.afat_loc;
ofs = FAT_FAT_OFFSET(fs_info->vol.type, cln) & (fs_info->vol.bps - 1);
ffc1c5c4: 57 dd f8 7e rlwinm r29,r30,31,1,31
/* 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) +
ffc1c5c8: 7f 7b 5c 30 srw r27,r27,r11
ffc1c5cc: 81 7f 00 4c lwz r11,76(r31)
fs_info->vol.afat_loc;
ofs = FAT_FAT_OFFSET(fs_info->vol.type, cln) & (fs_info->vol.bps - 1);
ffc1c5d0: 7f bd f2 14 add r29,r29,r30
/* 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) +
ffc1c5d4: 7f 7b 5a 14 add r27,r27,r11
fs_info->vol.afat_loc;
ofs = FAT_FAT_OFFSET(fs_info->vol.type, cln) & (fs_info->vol.bps - 1);
ffc1c5d8: 40 9e 00 14 bne- cr7,ffc1c5ec <fat_set_fat_cluster+0x90><== ALWAYS TAKEN
ffc1c5dc: 70 09 00 02 andi. r9,r0,2 <== NOT EXECUTED
ffc1c5e0: 57 dd 10 3a rlwinm r29,r30,2,0,29 <== NOT EXECUTED
ffc1c5e4: 41 82 00 08 beq- ffc1c5ec <fat_set_fat_cluster+0x90> <== NOT EXECUTED
ffc1c5e8: 57 dd 08 3c rlwinm r29,r30,1,0,30 <== NOT EXECUTED
rc = fat_buf_access(fs_info, sec, FAT_OP_TYPE_READ, &block0);
ffc1c5ec: 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);
ffc1c5f0: a3 5f 00 00 lhz r26,0(r31)
rc = fat_buf_access(fs_info, sec, FAT_OP_TYPE_READ, &block0);
ffc1c5f4: 7f 64 db 78 mr r4,r27
ffc1c5f8: 38 a0 00 01 li r5,1
ffc1c5fc: 38 c1 00 08 addi r6,r1,8
ffc1c600: 4b ff 83 bd bl ffc149bc <fat_buf_access>
if (rc != RC_OK)
ffc1c604: 2c 03 00 00 cmpwi r3,0
ffc1c608: 40 82 01 e4 bne- ffc1c7ec <fat_set_fat_cluster+0x290> <== NEVER TAKEN
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);
ffc1c60c: 3b 5a ff ff addi r26,r26,-1
ffc1c610: 7f ba d0 38 and r26,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 )
ffc1c614: 8b bf 00 0a lbz r29,10(r31)
ffc1c618: 2f 9d 00 02 cmpwi cr7,r29,2
ffc1c61c: 41 9e 01 54 beq- cr7,ffc1c770 <fat_set_fat_cluster+0x214><== NEVER TAKEN
ffc1c620: 2f 9d 00 04 cmpwi cr7,r29,4
ffc1c624: 41 9e 01 6c beq- cr7,ffc1c790 <fat_set_fat_cluster+0x234><== NEVER TAKEN
ffc1c628: 2f 9d 00 01 cmpwi cr7,r29,1
ffc1c62c: 40 be 01 b0 bne+ cr7,ffc1c7dc <fat_set_fat_cluster+0x280><== NEVER TAKEN
{
case FAT_FAT12:
if ( FAT_CLUSTER_IS_ODD(cln) )
ffc1c630: 73 cb 00 01 andi. r11,r30,1
ffc1c634: 81 21 00 08 lwz r9,8(r1)
ffc1c638: 41 82 00 80 beq- ffc1c6b8 <fat_set_fat_cluster+0x15c>
{
fat16_clv = ((uint16_t )in_val) << FAT_FAT12_SHIFT;
*((uint8_t *)(block0->buffer + ofs)) =
(*((uint8_t *)(block0->buffer + ofs))) & 0x0F;
ffc1c63c: 81 29 00 24 lwz r9,36(r9)
switch ( fs_info->vol.type )
{
case FAT_FAT12:
if ( FAT_CLUSTER_IS_ODD(cln) )
{
fat16_clv = ((uint16_t )in_val) << FAT_FAT12_SHIFT;
ffc1c640: 57 9c 24 36 rlwinm r28,r28,4,16,27
*((uint8_t *)(block0->buffer + ofs)) =
ffc1c644: 7c 09 d0 ae lbzx r0,r9,r26
ffc1c648: 54 00 07 3e clrlwi r0,r0,28
ffc1c64c: 7c 09 d1 ae stbx r0,r9,r26
(*((uint8_t *)(block0->buffer + ofs))) & 0x0F;
*((uint8_t *)(block0->buffer + ofs)) =
(*((uint8_t *)(block0->buffer + ofs))) |
ffc1c650: 81 21 00 08 lwz r9,8(r1)
ffc1c654: 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)) =
ffc1c658: 7c 09 d0 ae lbzx r0,r9,r26
ffc1c65c: 7c 00 e3 78 or r0,r0,r28
ffc1c660: 7c 09 d1 ae stbx r0,r9,r26
(*((uint8_t *)(block0->buffer + ofs))) |
(uint8_t )(fat16_clv & 0x00FF);
fat_buf_mark_modified(fs_info);
if ( ofs == (fs_info->vol.bps - 1) )
ffc1c664: a1 3f 00 00 lhz r9,0(r31)
}
static inline void
fat_buf_mark_modified(fat_fs_info_t *fs_info)
{
fs_info->c.modified = true;
ffc1c668: 9b bf 00 84 stb r29,132(r31)
ffc1c66c: 38 09 ff ff addi r0,r9,-1
ffc1c670: 7f 9a 00 00 cmpw cr7,r26,r0
ffc1c674: 40 be 00 30 bne+ cr7,ffc1c6a4 <fat_set_fat_cluster+0x148><== ALWAYS TAKEN
{
rc = fat_buf_access(fs_info, sec + 1, FAT_OP_TYPE_READ,
ffc1c678: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc1c67c: 38 9b 00 01 addi r4,r27,1 <== NOT EXECUTED
ffc1c680: 38 a0 00 01 li r5,1 <== NOT EXECUTED
ffc1c684: 38 c1 00 08 addi r6,r1,8 <== NOT EXECUTED
ffc1c688: 4b ff 83 35 bl ffc149bc <fat_buf_access> <== NOT EXECUTED
&block0);
if (rc != RC_OK)
ffc1c68c: 2c 03 00 00 cmpwi r3,0 <== NOT EXECUTED
ffc1c690: 40 82 01 5c bne- ffc1c7ec <fat_set_fat_cluster+0x290> <== NOT EXECUTED
return rc;
*((uint8_t *)(block0->buffer)) &= 0x00;
ffc1c694: 81 21 00 08 lwz r9,8(r1) <== NOT EXECUTED
ffc1c698: 81 29 00 24 lwz r9,36(r9) <== NOT EXECUTED
ffc1c69c: 98 69 00 00 stb r3,0(r9) <== NOT EXECUTED
ffc1c6a0: 48 00 00 7c b ffc1c71c <fat_set_fat_cluster+0x1c0> <== NOT EXECUTED
fat_buf_mark_modified(fs_info);
}
else
{
*((uint8_t *)(block0->buffer + ofs + 1)) &= 0x00;
ffc1c6a4: 81 21 00 08 lwz r9,8(r1)
ffc1c6a8: 3b 5a 00 01 addi r26,r26,1
ffc1c6ac: 81 29 00 24 lwz r9,36(r9)
ffc1c6b0: 7c 69 d1 ae stbx r3,r9,r26
ffc1c6b4: 48 00 00 a0 b ffc1c754 <fat_set_fat_cluster+0x1f8>
}
}
else
{
fat16_clv = ((uint16_t )in_val) & FAT_FAT12_MASK;
*((uint8_t *)(block0->buffer + ofs)) &= 0x00;
ffc1c6b8: 81 29 00 24 lwz r9,36(r9)
(uint8_t )((fat16_clv & 0xFF00)>>8);
}
}
else
{
fat16_clv = ((uint16_t )in_val) & FAT_FAT12_MASK;
ffc1c6bc: 57 9c 05 3e clrlwi r28,r28,20
*((uint8_t *)(block0->buffer + ofs)) &= 0x00;
ffc1c6c0: 7c 69 d1 ae stbx r3,r9,r26
*((uint8_t *)(block0->buffer + ofs)) =
(*((uint8_t *)(block0->buffer + ofs))) |
ffc1c6c4: 81 21 00 08 lwz r9,8(r1)
ffc1c6c8: 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)) =
ffc1c6cc: 7c 09 d0 ae lbzx r0,r9,r26
ffc1c6d0: 7c 00 e3 78 or r0,r0,r28
ffc1c6d4: 7c 09 d1 ae stbx r0,r9,r26
(*((uint8_t *)(block0->buffer + ofs))) |
(uint8_t )(fat16_clv & 0x00FF);
fat_buf_mark_modified(fs_info);
if ( ofs == (fs_info->vol.bps - 1) )
ffc1c6d8: a1 3f 00 00 lhz r9,0(r31)
ffc1c6dc: 9b bf 00 84 stb r29,132(r31)
ffc1c6e0: 38 09 ff ff addi r0,r9,-1
ffc1c6e4: 7f 9a 00 00 cmpw cr7,r26,r0
ffc1c6e8: 40 be 00 54 bne+ cr7,ffc1c73c <fat_set_fat_cluster+0x1e0><== ALWAYS TAKEN
{
rc = fat_buf_access(fs_info, sec + 1, FAT_OP_TYPE_READ,
ffc1c6ec: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc1c6f0: 38 9b 00 01 addi r4,r27,1 <== NOT EXECUTED
ffc1c6f4: 38 a0 00 01 li r5,1 <== NOT EXECUTED
ffc1c6f8: 38 c1 00 08 addi r6,r1,8 <== NOT EXECUTED
ffc1c6fc: 4b ff 82 c1 bl ffc149bc <fat_buf_access> <== NOT EXECUTED
&block0);
if (rc != RC_OK)
ffc1c700: 2c 03 00 00 cmpwi r3,0 <== NOT EXECUTED
ffc1c704: 40 82 00 e8 bne- ffc1c7ec <fat_set_fat_cluster+0x290> <== NOT EXECUTED
return rc;
*((uint8_t *)(block0->buffer)) =
(*((uint8_t *)(block0->buffer))) & 0xF0;
ffc1c708: 81 21 00 08 lwz r9,8(r1) <== NOT EXECUTED
ffc1c70c: 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)) =
ffc1c710: 88 09 00 00 lbz r0,0(r9) <== NOT EXECUTED
ffc1c714: 54 00 00 36 rlwinm r0,r0,0,0,27 <== NOT EXECUTED
ffc1c718: 98 09 00 00 stb r0,0(r9) <== NOT EXECUTED
(*((uint8_t *)(block0->buffer))) & 0xF0;
*((uint8_t *)(block0->buffer)) =
(*((uint8_t *)(block0->buffer))) |
ffc1c71c: 81 21 00 08 lwz r9,8(r1) <== NOT EXECUTED
(uint8_t )((fat16_clv & 0xFF00)>>8);
ffc1c720: 57 9c c2 3e rlwinm r28,r28,24,8,31 <== NOT EXECUTED
*((uint8_t *)(block0->buffer)) =
(*((uint8_t *)(block0->buffer))) & 0xF0;
*((uint8_t *)(block0->buffer)) =
(*((uint8_t *)(block0->buffer))) |
ffc1c724: 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)) =
ffc1c728: 88 09 00 00 lbz r0,0(r9) <== NOT EXECUTED
ffc1c72c: 7f 9c 03 78 or r28,r28,r0 <== NOT EXECUTED
ffc1c730: 9b 89 00 00 stb r28,0(r9) <== NOT EXECUTED
ffc1c734: 9b bf 00 84 stb r29,132(r31) <== NOT EXECUTED
ffc1c738: 48 00 00 b4 b ffc1c7ec <fat_set_fat_cluster+0x290> <== NOT EXECUTED
fat_buf_mark_modified(fs_info);
}
else
{
*((uint8_t *)(block0->buffer + ofs + 1)) =
(*((uint8_t *)(block0->buffer + ofs + 1))) & 0xF0;
ffc1c73c: 81 21 00 08 lwz r9,8(r1)
ffc1c740: 3b 5a 00 01 addi r26,r26,1
ffc1c744: 81 29 00 24 lwz r9,36(r9)
fat_buf_mark_modified(fs_info);
}
else
{
*((uint8_t *)(block0->buffer + ofs + 1)) =
ffc1c748: 7c 09 d0 ae lbzx r0,r9,r26
ffc1c74c: 54 00 00 36 rlwinm r0,r0,0,0,27
ffc1c750: 7c 09 d1 ae stbx r0,r9,r26
(*((uint8_t *)(block0->buffer + ofs + 1))) & 0xF0;
*((uint8_t *)(block0->buffer + ofs+1)) =
(*((uint8_t *)(block0->buffer + ofs+1))) |
ffc1c754: 81 21 00 08 lwz r9,8(r1)
(uint8_t )((fat16_clv & 0xFF00)>>8);
ffc1c758: 57 9c c2 3e rlwinm r28,r28,24,8,31
{
*((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))) |
ffc1c75c: 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)) =
ffc1c760: 7c 09 d0 ae lbzx r0,r9,r26
ffc1c764: 7c 1c e3 78 or r28,r0,r28
ffc1c768: 7f 89 d1 ae stbx r28,r9,r26
ffc1c76c: 48 00 00 80 b ffc1c7ec <fat_set_fat_cluster+0x290>
}
}
break;
case FAT_FAT16:
*((uint16_t *)(block0->buffer + ofs)) =
ffc1c770: 81 21 00 08 lwz r9,8(r1) <== NOT EXECUTED
(uint16_t )(CT_LE_W(in_val));
ffc1c774: 57 9c 04 3e clrlwi r28,r28,16 <== NOT EXECUTED
ffc1c778: 57 80 40 2e rlwinm r0,r28,8,0,23 <== NOT EXECUTED
}
}
break;
case FAT_FAT16:
*((uint16_t *)(block0->buffer + ofs)) =
ffc1c77c: 81 29 00 24 lwz r9,36(r9) <== NOT EXECUTED
(uint16_t )(CT_LE_W(in_val));
ffc1c780: 57 9c c2 3e rlwinm r28,r28,24,8,31 <== NOT EXECUTED
ffc1c784: 7c 1c e3 78 or r28,r0,r28 <== NOT EXECUTED
}
}
break;
case FAT_FAT16:
*((uint16_t *)(block0->buffer + ofs)) =
ffc1c788: 7f 89 d3 2e sthx r28,r9,r26 <== NOT EXECUTED
ffc1c78c: 48 00 00 44 b ffc1c7d0 <fat_set_fat_cluster+0x274> <== NOT EXECUTED
(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));
ffc1c790: 57 9c 01 3e clrlwi r28,r28,4 <== NOT EXECUTED
ffc1c794: 53 8b 46 3e rlwimi r11,r28,8,24,31 <== NOT EXECUTED
ffc1c798: 53 8b c4 2e rlwimi r11,r28,24,16,23 <== NOT EXECUTED
ffc1c79c: 53 8b 42 1e rlwimi r11,r28,8,8,15 <== NOT EXECUTED
ffc1c7a0: 53 8b c0 0e rlwimi r11,r28,24,0,7 <== NOT EXECUTED
*((uint32_t *)(block0->buffer + ofs)) =
(*((uint32_t *)(block0->buffer + ofs))) & (CT_LE_L(0xF0000000));
ffc1c7a4: 81 21 00 08 lwz r9,8(r1) <== NOT EXECUTED
ffc1c7a8: 3c 00 f0 00 lis r0,-4096 <== NOT EXECUTED
ffc1c7ac: 81 29 00 24 lwz r9,36(r9) <== NOT EXECUTED
ffc1c7b0: 50 0a 46 3e rlwimi r10,r0,8,24,31 <== NOT EXECUTED
ffc1c7b4: 50 0a c4 2e rlwimi r10,r0,24,16,23 <== NOT EXECUTED
ffc1c7b8: 50 0a 42 1e rlwimi r10,r0,8,8,15 <== NOT EXECUTED
ffc1c7bc: 50 0a c0 0e rlwimi r10,r0,24,0,7 <== NOT EXECUTED
ffc1c7c0: 7c 09 d0 2e lwzx r0,r9,r26 <== NOT EXECUTED
ffc1c7c4: 7d 40 00 38 and r0,r10,r0 <== NOT EXECUTED
*((uint32_t *)(block0->buffer + ofs)) =
fat32_clv | (*((uint32_t *)(block0->buffer + ofs)));
ffc1c7c8: 7c 00 5b 78 or r0,r0,r11 <== 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)) =
ffc1c7cc: 7c 09 d1 2e stwx r0,r9,r26 <== NOT EXECUTED
ffc1c7d0: 38 00 00 01 li r0,1 <== NOT EXECUTED
ffc1c7d4: 98 1f 00 84 stb r0,132(r31) <== NOT EXECUTED
ffc1c7d8: 48 00 00 14 b ffc1c7ec <fat_set_fat_cluster+0x290> <== NOT EXECUTED
fat_buf_mark_modified(fs_info);
break;
default:
rtems_set_errno_and_return_minus_one(EIO);
ffc1c7dc: 48 00 19 fd bl ffc1e1d8 <__errno> <== NOT EXECUTED
ffc1c7e0: 38 00 00 05 li r0,5 <== NOT EXECUTED
ffc1c7e4: 90 03 00 00 stw r0,0(r3) <== NOT EXECUTED
ffc1c7e8: 38 60 ff ff li r3,-1 <== NOT EXECUTED
break;
}
return RC_OK;
}
ffc1c7ec: 39 61 00 30 addi r11,r1,48
ffc1c7f0: 4b fe 62 f4 b ffc02ae4 <_restgpr_26_x>
ffc15174 <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)
{
ffc15174: 94 21 ff e8 stwu r1,-24(r1) <== NOT EXECUTED
ffc15178: 7c 08 02 a6 mflr r0 <== NOT EXECUTED
ffc1517c: 90 01 00 1c stw r0,28(r1) <== NOT EXECUTED
ffc15180: bf 81 00 08 stmw r28,8(r1) <== NOT EXECUTED
int rc = RC_OK;
ffc15184: 3b c0 00 00 li r30,0 <== NOT EXECUTED
fat_fs_info_t *fs_info = mt_entry->fs_info;
ffc15188: 83 e3 00 34 lwz r31,52(r3) <== NOT EXECUTED
int i = 0;
if (fs_info->vol.type & FAT_FAT32)
ffc1518c: 88 1f 00 0a lbz r0,10(r31) <== NOT EXECUTED
ffc15190: 70 09 00 04 andi. r9,r0,4 <== NOT EXECUTED
ffc15194: 41 a2 00 1c beq+ ffc151b0 <fat_shutdown_drive+0x3c> <== NOT EXECUTED
{
rc = fat_fat32_update_fsinfo_sector(mt_entry, fs_info->vol.free_cls,
ffc15198: 80 9f 00 40 lwz r4,64(r31) <== NOT EXECUTED
ffc1519c: 80 bf 00 44 lwz r5,68(r31) <== NOT EXECUTED
ffc151a0: 4b ff ff 49 bl ffc150e8 <fat_fat32_update_fsinfo_sector><== NOT EXECUTED
fs_info->vol.next_cl);
if ( rc != RC_OK )
ffc151a4: 7c 7e 1b 79 mr. r30,r3 <== NOT EXECUTED
ffc151a8: 41 82 00 08 beq- ffc151b0 <fat_shutdown_drive+0x3c> <== NOT EXECUTED
rc = -1;
ffc151ac: 3b c0 ff ff li r30,-1 <== NOT EXECUTED
}
fat_buf_release(fs_info);
ffc151b0: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc151b4: 4b ff f9 ed bl ffc14ba0 <fat_buf_release> <== NOT EXECUTED
if (rtems_bdbuf_syncdev(fs_info->vol.dev) != RTEMS_SUCCESSFUL)
ffc151b8: 80 7f 00 58 lwz r3,88(r31) <== NOT EXECUTED
ffc151bc: 80 9f 00 5c lwz r4,92(r31) <== NOT EXECUTED
ffc151c0: 4b ff e3 19 bl ffc134d8 <rtems_bdbuf_syncdev> <== NOT EXECUTED
ffc151c4: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc151c8: 41 be 00 08 beq+ cr7,ffc151d0 <fat_shutdown_drive+0x5c> <== NOT EXECUTED
rc = -1;
ffc151cc: 3b c0 ff ff li r30,-1 <== NOT EXECUTED
ffc151d0: 3b a0 00 00 li r29,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;
ffc151d4: 83 9f 00 68 lwz r28,104(r31) <== NOT EXECUTED
ffc151d8: 7f 9c ea 14 add r28,r28,r29 <== NOT EXECUTED
while ( (node = rtems_chain_get(the_chain)) != NULL )
ffc151dc: 48 00 00 08 b ffc151e4 <fat_shutdown_drive+0x70> <== NOT EXECUTED
free(node);
ffc151e0: 4b ff 27 09 bl ffc078e8 <free> <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE rtems_chain_node *rtems_chain_get(
rtems_chain_control *the_chain
)
{
return _Chain_Get( the_chain );
ffc151e4: 7f 83 e3 78 mr r3,r28 <== NOT EXECUTED
ffc151e8: 4b ff 78 89 bl ffc0ca70 <_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 )
ffc151ec: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc151f0: 40 9e ff f0 bne+ cr7,ffc151e0 <fat_shutdown_drive+0x6c> <== 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++)
ffc151f4: 2f 9d 00 0c cmpwi cr7,r29,12 <== NOT EXECUTED
ffc151f8: 3b bd 00 0c addi r29,r29,12 <== NOT EXECUTED
ffc151fc: 40 be ff d8 bne- cr7,ffc151d4 <fat_shutdown_drive+0x60> <== NOT EXECUTED
ffc15200: 3b a0 00 00 li r29,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;
ffc15204: 83 9f 00 6c lwz r28,108(r31) <== NOT EXECUTED
ffc15208: 7f 9c ea 14 add r28,r28,r29 <== NOT EXECUTED
while ( (node = rtems_chain_get(the_chain)) != NULL )
ffc1520c: 48 00 00 08 b ffc15214 <fat_shutdown_drive+0xa0> <== NOT EXECUTED
free(node);
ffc15210: 4b ff 26 d9 bl ffc078e8 <free> <== NOT EXECUTED
ffc15214: 7f 83 e3 78 mr r3,r28 <== NOT EXECUTED
ffc15218: 4b ff 78 59 bl ffc0ca70 <_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 )
ffc1521c: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc15220: 40 9e ff f0 bne+ cr7,ffc15210 <fat_shutdown_drive+0x9c> <== NOT EXECUTED
while ( (node = rtems_chain_get(the_chain)) != NULL )
free(node);
}
for (i = 0; i < FAT_HASH_SIZE; i++)
ffc15224: 2f 9d 00 0c cmpwi cr7,r29,12 <== NOT EXECUTED
ffc15228: 3b bd 00 0c addi r29,r29,12 <== NOT EXECUTED
ffc1522c: 40 be ff d8 bne- cr7,ffc15204 <fat_shutdown_drive+0x90> <== NOT EXECUTED
while ( (node = rtems_chain_get(the_chain)) != NULL )
free(node);
}
free(fs_info->vhash);
ffc15230: 80 7f 00 68 lwz r3,104(r31) <== NOT EXECUTED
ffc15234: 4b ff 26 b5 bl ffc078e8 <free> <== NOT EXECUTED
free(fs_info->rhash);
ffc15238: 80 7f 00 6c lwz r3,108(r31) <== NOT EXECUTED
ffc1523c: 4b ff 26 ad bl ffc078e8 <free> <== NOT EXECUTED
free(fs_info->uino);
ffc15240: 80 7f 00 70 lwz r3,112(r31) <== NOT EXECUTED
ffc15244: 4b ff 26 a5 bl ffc078e8 <free> <== NOT EXECUTED
free(fs_info->sec_buf);
ffc15248: 80 7f 00 8c lwz r3,140(r31) <== NOT EXECUTED
ffc1524c: 4b ff 26 9d bl ffc078e8 <free> <== NOT EXECUTED
rtems_disk_release(fs_info->vol.dd);
ffc15250: 80 7f 00 60 lwz r3,96(r31) <== NOT EXECUTED
ffc15254: 4b ff 16 9d bl ffc068f0 <rtems_disk_release> <== NOT EXECUTED
if (rc)
ffc15258: 2f 9e 00 00 cmpwi cr7,r30,0 <== NOT EXECUTED
ffc1525c: 41 be 00 10 beq+ cr7,ffc1526c <fat_shutdown_drive+0xf8> <== NOT EXECUTED
errno = EIO;
ffc15260: 48 00 8f 79 bl ffc1e1d8 <__errno> <== NOT EXECUTED
ffc15264: 38 00 00 05 li r0,5 <== NOT EXECUTED
ffc15268: 90 03 00 00 stw r0,0(r3) <== NOT EXECUTED
return rc;
}
ffc1526c: 39 61 00 18 addi r11,r1,24 <== NOT EXECUTED
ffc15270: 7f c3 f3 78 mr r3,r30 <== NOT EXECUTED
ffc15274: 4b fe d8 78 b ffc02aec <_restgpr_28_x> <== NOT EXECUTED
ffc1c81c <fcntl>:
int fd2;
int flags;
int mask;
int ret = 0;
rtems_libio_check_fd( fd );
ffc1c81c: 3d 20 00 00 lis r9,0
int fcntl(
int fd,
int cmd,
...
)
{
ffc1c820: 94 21 ff c8 stwu r1,-56(r1)
ffc1c824: 7c 08 02 a6 mflr r0
int fd2;
int flags;
int mask;
int ret = 0;
rtems_libio_check_fd( fd );
ffc1c828: 81 09 27 1c lwz r8,10012(r9)
int fcntl(
int fd,
int cmd,
...
)
{
ffc1c82c: 90 01 00 3c stw r0,60(r1)
int ret;
va_list ap;
va_start( ap, cmd );
ffc1c830: 38 00 00 02 li r0,2
int fd2;
int flags;
int mask;
int ret = 0;
rtems_libio_check_fd( fd );
ffc1c834: 7f 83 40 40 cmplw cr7,r3,r8
...
)
{
int ret;
va_list ap;
va_start( ap, cmd );
ffc1c838: 98 01 00 08 stb r0,8(r1)
ffc1c83c: 38 01 00 40 addi r0,r1,64
ffc1c840: 90 01 00 0c stw r0,12(r1)
ffc1c844: 38 01 00 10 addi r0,r1,16
int fcntl(
int fd,
int cmd,
...
)
{
ffc1c848: bf a1 00 2c stmw r29,44(r1)
ffc1c84c: 7c 9e 23 78 mr r30,r4
ffc1c850: 90 a1 00 18 stw r5,24(r1)
ffc1c854: 90 c1 00 1c stw r6,28(r1)
ffc1c858: 90 e1 00 20 stw r7,32(r1)
int ret;
va_list ap;
va_start( ap, cmd );
ffc1c85c: 90 01 00 10 stw r0,16(r1)
int fd2;
int flags;
int mask;
int ret = 0;
rtems_libio_check_fd( fd );
ffc1c860: 40 9c 00 20 bge- cr7,ffc1c880 <fcntl+0x64>
iop = rtems_libio_iop( fd );
ffc1c864: 3d 20 00 00 lis r9,0
ffc1c868: 81 49 27 cc lwz r10,10188(r9)
ffc1c86c: 54 7f 30 32 rlwinm r31,r3,6,0,25
ffc1c870: 7f ea fa 14 add r31,r10,r31
rtems_libio_check_is_open(iop);
ffc1c874: 80 7f 00 18 lwz r3,24(r31)
ffc1c878: 70 60 01 00 andi. r0,r3,256
ffc1c87c: 40 a2 00 10 bne+ ffc1c88c <fcntl+0x70>
ffc1c880: 4b ff 4d a5 bl ffc11624 <__errno>
ffc1c884: 38 00 00 09 li r0,9
ffc1c888: 48 00 01 80 b ffc1ca08 <fcntl+0x1ec>
/*
* This switch should contain all the cases from POSIX.
*/
switch ( cmd ) {
ffc1c88c: 2b 84 00 09 cmplwi cr7,r4,9
ffc1c890: 41 9d 01 70 bgt- cr7,ffc1ca00 <fcntl+0x1e4>
ffc1c894: 3d 20 ff c2 lis r9,-62
ffc1c898: 39 29 fb e4 addi r9,r9,-1052
ffc1c89c: 54 80 10 3a rlwinm r0,r4,2,0,29
ffc1c8a0: 7c 09 00 2e lwzx r0,r9,r0
ffc1c8a4: 7d 20 4a 14 add r9,r0,r9
ffc1c8a8: 7d 29 03 a6 mtctr r9
ffc1c8ac: 4e 80 04 20 bctr
case F_DUPFD: /* dup */
fd2 = va_arg( ap, int );
ffc1c8b0: 89 61 00 08 lbz r11,8(r1)
ffc1c8b4: 2b 8b 00 07 cmplwi cr7,r11,7
ffc1c8b8: 41 9d 00 1c bgt- cr7,ffc1c8d4 <fcntl+0xb8> <== NEVER TAKEN
ffc1c8bc: 81 21 00 10 lwz r9,16(r1)
ffc1c8c0: 55 60 10 3a rlwinm r0,r11,2,0,29
ffc1c8c4: 39 6b 00 01 addi r11,r11,1
ffc1c8c8: 7d 29 02 14 add r9,r9,r0
ffc1c8cc: 99 61 00 08 stb r11,8(r1)
ffc1c8d0: 48 00 00 10 b ffc1c8e0 <fcntl+0xc4>
ffc1c8d4: 81 21 00 0c lwz r9,12(r1) <== NOT EXECUTED
ffc1c8d8: 38 09 00 04 addi r0,r9,4 <== NOT EXECUTED
ffc1c8dc: 90 01 00 0c stw r0,12(r1) <== NOT EXECUTED
ffc1c8e0: 80 09 00 00 lwz r0,0(r9)
if ( fd2 )
ffc1c8e4: 2f 80 00 00 cmpwi cr7,r0,0
ffc1c8e8: 41 9e 00 1c beq- cr7,ffc1c904 <fcntl+0xe8>
diop = rtems_libio_iop( fd2 );
ffc1c8ec: 7f 80 40 40 cmplw cr7,r0,r8
ffc1c8f0: 38 60 00 00 li r3,0
ffc1c8f4: 40 9c 00 1c bge- cr7,ffc1c910 <fcntl+0xf4> <== NEVER TAKEN
ffc1c8f8: 54 03 30 32 rlwinm r3,r0,6,0,25
ffc1c8fc: 7c 6a 1a 14 add r3,r10,r3
ffc1c900: 48 00 00 10 b ffc1c910 <fcntl+0xf4>
else {
/* allocate a file control block */
diop = rtems_libio_allocate();
ffc1c904: 4b fe 89 6d bl ffc05270 <rtems_libio_allocate>
if ( diop == 0 ) {
ffc1c908: 2c 03 00 00 cmpwi r3,0
ffc1c90c: 41 82 01 34 beq- ffc1ca40 <fcntl+0x224> <== NEVER TAKEN
break;
}
}
diop->flags = iop->flags;
diop->pathinfo = iop->pathinfo;
ffc1c910: 39 63 00 1c addi r11,r3,28
ret = -1;
break;
}
}
diop->flags = iop->flags;
ffc1c914: 80 1f 00 18 lwz r0,24(r31)
diop->pathinfo = iop->pathinfo;
ffc1c918: 38 9f 00 1c addi r4,r31,28
ffc1c91c: 7c a4 a4 aa lswi r5,r4,20
ffc1c920: 7c ab a5 aa stswi r5,r11,20
ret = (int) (diop - rtems_libio_iops);
ffc1c924: 3d 20 00 00 lis r9,0
ffc1c928: 83 a9 27 cc lwz r29,10188(r9)
ret = -1;
break;
}
}
diop->flags = iop->flags;
ffc1c92c: 90 03 00 18 stw r0,24(r3)
diop->pathinfo = iop->pathinfo;
ret = (int) (diop - rtems_libio_iops);
ffc1c930: 7c 7d 18 50 subf r3,r29,r3
ffc1c934: 7c 7d 36 70 srawi r29,r3,6
ffc1c938: 48 00 00 d8 b ffc1ca10 <fcntl+0x1f4>
break;
case F_GETFD: /* get f_flags */
ret = ((iop->flags & LIBIO_FLAGS_CLOSE_ON_EXEC) != 0);
ffc1c93c: 54 7d af fe rlwinm r29,r3,21,31,31
ffc1c940: 48 00 00 d8 b ffc1ca18 <fcntl+0x1fc>
* 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 ) )
ffc1c944: 89 61 00 08 lbz r11,8(r1)
ffc1c948: 2b 8b 00 07 cmplwi cr7,r11,7
ffc1c94c: 41 9d 00 1c bgt- cr7,ffc1c968 <fcntl+0x14c> <== NEVER TAKEN
ffc1c950: 81 21 00 10 lwz r9,16(r1)
ffc1c954: 55 60 10 3a rlwinm r0,r11,2,0,29
ffc1c958: 39 6b 00 01 addi r11,r11,1
ffc1c95c: 7d 29 02 14 add r9,r9,r0
ffc1c960: 99 61 00 08 stb r11,8(r1)
ffc1c964: 48 00 00 10 b ffc1c974 <fcntl+0x158>
ffc1c968: 81 21 00 0c lwz r9,12(r1) <== NOT EXECUTED
ffc1c96c: 38 09 00 04 addi r0,r9,4 <== NOT EXECUTED
ffc1c970: 90 01 00 0c stw r0,12(r1) <== NOT EXECUTED
ffc1c974: 80 09 00 00 lwz r0,0(r9)
ffc1c978: 2f 80 00 00 cmpwi cr7,r0,0
ffc1c97c: 41 9e 00 0c beq- cr7,ffc1c988 <fcntl+0x16c>
iop->flags |= LIBIO_FLAGS_CLOSE_ON_EXEC;
ffc1c980: 60 63 08 00 ori r3,r3,2048
ffc1c984: 48 00 00 64 b ffc1c9e8 <fcntl+0x1cc>
else
iop->flags &= ~LIBIO_FLAGS_CLOSE_ON_EXEC;
ffc1c988: 54 63 05 66 rlwinm r3,r3,0,21,19
ffc1c98c: 48 00 00 5c b ffc1c9e8 <fcntl+0x1cc>
break;
case F_GETFL: /* more flags (cloexec) */
ret = rtems_libio_to_fcntl_flags( iop->flags );
ffc1c990: 4b fe 88 95 bl ffc05224 <rtems_libio_to_fcntl_flags>
ffc1c994: 7c 7d 1b 78 mr r29,r3
ffc1c998: 48 00 00 78 b ffc1ca10 <fcntl+0x1f4>
break;
case F_SETFL:
flags = rtems_libio_fcntl_flags( va_arg( ap, int ) );
ffc1c99c: 89 61 00 08 lbz r11,8(r1)
ffc1c9a0: 2b 8b 00 07 cmplwi cr7,r11,7
ffc1c9a4: 41 9d 00 1c bgt- cr7,ffc1c9c0 <fcntl+0x1a4> <== NEVER TAKEN
ffc1c9a8: 81 21 00 10 lwz r9,16(r1)
ffc1c9ac: 55 60 10 3a rlwinm r0,r11,2,0,29
ffc1c9b0: 39 6b 00 01 addi r11,r11,1
ffc1c9b4: 7d 29 02 14 add r9,r9,r0
ffc1c9b8: 99 61 00 08 stb r11,8(r1)
ffc1c9bc: 48 00 00 10 b ffc1c9cc <fcntl+0x1b0>
ffc1c9c0: 81 21 00 0c lwz r9,12(r1) <== NOT EXECUTED
ffc1c9c4: 38 09 00 04 addi r0,r9,4 <== NOT EXECUTED
ffc1c9c8: 90 01 00 0c stw r0,12(r1) <== NOT EXECUTED
ffc1c9cc: 80 69 00 00 lwz r3,0(r9)
ffc1c9d0: 4b fe 88 11 bl ffc051e0 <rtems_libio_fcntl_flags>
/*
* XXX If we are turning on append, should we seek to the end?
*/
iop->flags = (iop->flags & ~mask) | (flags & mask);
ffc1c9d4: 80 1f 00 18 lwz r0,24(r31)
ffc1c9d8: 70 63 02 01 andi. r3,r3,513
ffc1c9dc: 39 20 fd fe li r9,-514
ffc1c9e0: 7d 20 00 38 and r0,r9,r0
ffc1c9e4: 7c 63 03 78 or r3,r3,r0
ffc1c9e8: 90 7f 00 18 stw r3,24(r31)
rtems_libio_t *iop;
rtems_libio_t *diop;
int fd2;
int flags;
int mask;
int ret = 0;
ffc1c9ec: 3b a0 00 00 li r29,0
ffc1c9f0: 48 00 00 28 b ffc1ca18 <fcntl+0x1fc>
errno = ENOTSUP;
ret = -1;
break;
case F_GETOWN: /* for sockets. */
errno = ENOTSUP;
ffc1c9f4: 4b ff 4c 31 bl ffc11624 <__errno>
ffc1c9f8: 38 00 00 86 li r0,134
ffc1c9fc: 48 00 00 0c b ffc1ca08 <fcntl+0x1ec>
ret = -1;
break;
default:
errno = EINVAL;
ffc1ca00: 4b ff 4c 25 bl ffc11624 <__errno>
ffc1ca04: 38 00 00 16 li r0,22
ffc1ca08: 90 03 00 00 stw r0,0(r3)
ffc1ca0c: 48 00 00 34 b ffc1ca40 <fcntl+0x224>
/*
* If we got this far successfully, then we give the optional
* filesystem specific handler a chance to process this.
*/
if (ret >= 0) {
ffc1ca10: 2f 9d 00 00 cmpwi cr7,r29,0
ffc1ca14: 41 9c 00 30 blt- cr7,ffc1ca44 <fcntl+0x228> <== NEVER TAKEN
int err = (*iop->pathinfo.handlers->fcntl_h)( cmd, iop );
ffc1ca18: 81 3f 00 24 lwz r9,36(r31)
ffc1ca1c: 7f e4 fb 78 mr r4,r31
ffc1ca20: 7f c3 f3 78 mr r3,r30
ffc1ca24: 80 09 00 30 lwz r0,48(r9)
ffc1ca28: 7c 09 03 a6 mtctr r0
ffc1ca2c: 4e 80 04 21 bctrl
if (err) {
ffc1ca30: 7c 7f 1b 79 mr. r31,r3
ffc1ca34: 41 a2 00 10 beq+ ffc1ca44 <fcntl+0x228> <== ALWAYS TAKEN
errno = err;
ffc1ca38: 4b ff 4b ed bl ffc11624 <__errno> <== NOT EXECUTED
ffc1ca3c: 93 e3 00 00 stw r31,0(r3) <== NOT EXECUTED
ret = -1;
ffc1ca40: 3b a0 ff ff li r29,-1
va_list ap;
va_start( ap, cmd );
ret = vfcntl(fd,cmd,ap);
va_end(ap);
return ret;
}
ffc1ca44: 39 61 00 38 addi r11,r1,56
ffc1ca48: 7f a3 eb 78 mr r3,r29
ffc1ca4c: 4b fe 41 24 b ffc00b70 <_restgpr_29_x>
ffc0ec3c <fifo_open>:
*/
int fifo_open(
pipe_control_t **pipep,
rtems_libio_t *iop
)
{
ffc0ec3c: 94 21 ff d0 stwu r1,-48(r1)
ffc0ec40: 7c 08 02 a6 mflr r0
ffc0ec44: bf 61 00 1c stmw r27,28(r1)
static int pipe_lock(void)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
if (pipe_semaphore == RTEMS_ID_NONE) {
ffc0ec48: 3f c0 00 00 lis r30,0
*/
int fifo_open(
pipe_control_t **pipep,
rtems_libio_t *iop
)
{
ffc0ec4c: 7c 7d 1b 78 mr r29,r3
ffc0ec50: 90 01 00 34 stw r0,52(r1)
ffc0ec54: 7c 9c 23 78 mr r28,r4
static int pipe_lock(void)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
if (pipe_semaphore == RTEMS_ID_NONE) {
ffc0ec58: 3b fe 29 f8 addi r31,r30,10744
ffc0ec5c: 80 1e 29 f8 lwz r0,10744(r30)
ffc0ec60: 2f 80 00 00 cmpwi cr7,r0,0
ffc0ec64: 40 be 00 60 bne+ cr7,ffc0ecc4 <fifo_open+0x88>
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 );
ffc0ec68: 3d 20 00 00 lis r9,0
ffc0ec6c: 80 69 27 f4 lwz r3,10228(r9)
ffc0ec70: 38 80 00 00 li r4,0
ffc0ec74: 38 a0 00 00 li r5,0
ffc0ec78: 4b ff b1 b1 bl ffc09e28 <rtems_semaphore_obtain>
rtems_libio_lock();
if (pipe_semaphore == RTEMS_ID_NONE) {
ffc0ec7c: 80 1e 29 f8 lwz r0,10744(r30)
free(pipe);
}
static int pipe_lock(void)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
ffc0ec80: 3b 60 00 00 li r27,0
if (pipe_semaphore == RTEMS_ID_NONE) {
rtems_libio_lock();
if (pipe_semaphore == RTEMS_ID_NONE) {
ffc0ec84: 2f 80 00 00 cmpwi cr7,r0,0
ffc0ec88: 40 be 00 24 bne+ cr7,ffc0ecac <fifo_open+0x70> <== NEVER TAKEN
sc = rtems_semaphore_create(
ffc0ec8c: 3c 60 50 49 lis r3,20553
ffc0ec90: 60 63 50 45 ori r3,r3,20549
ffc0ec94: 38 80 00 01 li r4,1
ffc0ec98: 38 a0 00 54 li r5,84
ffc0ec9c: 38 c0 00 00 li r6,0
ffc0eca0: 7f e7 fb 78 mr r7,r31
ffc0eca4: 4b ff af 11 bl ffc09bb4 <rtems_semaphore_create>
ffc0eca8: 7c 7b 1b 78 mr r27,r3
}
static inline void rtems_libio_unlock( void )
{
rtems_semaphore_release( rtems_libio_semaphore );
ffc0ecac: 3d 20 00 00 lis r9,0
ffc0ecb0: 80 69 27 f4 lwz r3,10228(r9)
}
rtems_libio_unlock();
}
if (sc == RTEMS_SUCCESSFUL) {
ffc0ecb4: 3b c0 ff f4 li r30,-12
ffc0ecb8: 4b ff b2 9d bl ffc09f54 <rtems_semaphore_release>
ffc0ecbc: 2f 9b 00 00 cmpwi cr7,r27,0
ffc0ecc0: 40 be 03 84 bne+ cr7,ffc0f044 <fifo_open+0x408>
sc = rtems_semaphore_obtain(pipe_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
ffc0ecc4: 3d 20 00 00 lis r9,0
ffc0ecc8: 80 69 29 f8 lwz r3,10744(r9)
ffc0eccc: 38 80 00 00 li r4,0
ffc0ecd0: 38 a0 00 00 li r5,0
ffc0ecd4: 4b ff b1 55 bl ffc09e28 <rtems_semaphore_obtain>
}
if (sc == RTEMS_SUCCESSFUL) {
ffc0ecd8: 3b c0 ff f4 li r30,-12
ffc0ecdc: 2f 83 00 00 cmpwi cr7,r3,0
ffc0ece0: 40 9e 03 64 bne- cr7,ffc0f044 <fifo_open+0x408> <== NEVER TAKEN
err = pipe_lock();
if (err)
return err;
pipe = *pipep;
ffc0ece4: 83 fd 00 00 lwz r31,0(r29)
if (pipe == NULL) {
ffc0ece8: 2f 9f 00 00 cmpwi cr7,r31,0
ffc0ecec: 40 be 01 40 bne+ cr7,ffc0ee2c <fifo_open+0x1f0>
{
static char c = 'a';
pipe_control_t *pipe;
int err = -ENOMEM;
pipe = malloc(sizeof(pipe_control_t));
ffc0ecf0: 38 60 00 34 li r3,52
ffc0ecf4: 4b ff 7d 09 bl ffc069fc <malloc>
if (pipe == NULL)
ffc0ecf8: 7c 7f 1b 79 mr. r31,r3
ffc0ecfc: 41 82 01 28 beq- ffc0ee24 <fifo_open+0x1e8>
return err;
memset(pipe, 0, sizeof(pipe_control_t));
ffc0ed00: 38 80 00 00 li r4,0
ffc0ed04: 38 a0 00 34 li r5,52
ffc0ed08: 48 00 53 71 bl ffc14078 <memset>
pipe->Size = PIPE_BUF;
ffc0ed0c: 38 00 02 00 li r0,512
ffc0ed10: 90 1f 00 04 stw r0,4(r31)
pipe->Buffer = malloc(pipe->Size);
ffc0ed14: 38 60 02 00 li r3,512
ffc0ed18: 4b ff 7c e5 bl ffc069fc <malloc>
if (! pipe->Buffer)
ffc0ed1c: 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);
ffc0ed20: 90 7f 00 00 stw r3,0(r31)
if (! pipe->Buffer)
ffc0ed24: 41 9e 00 f8 beq- cr7,ffc0ee1c <fifo_open+0x1e0> <== NEVER TAKEN
goto err_buf;
err = -ENOMEM;
if (rtems_barrier_create(
rtems_build_name ('P', 'I', 'r', c),
ffc0ed28: 3f c0 00 00 lis r30,0
ffc0ed2c: 88 7e 21 bd lbz r3,8637(r30)
if (! pipe->Buffer)
goto err_buf;
err = -ENOMEM;
if (rtems_barrier_create(
ffc0ed30: 38 80 00 00 li r4,0
ffc0ed34: 38 a0 00 00 li r5,0
ffc0ed38: 64 63 50 49 oris r3,r3,20553
ffc0ed3c: 60 63 72 00 ori r3,r3,29184
ffc0ed40: 38 df 00 2c addi r6,r31,44
ffc0ed44: 48 00 1a 01 bl ffc10744 <rtems_barrier_create>
ffc0ed48: 2f 83 00 00 cmpwi cr7,r3,0
ffc0ed4c: 40 9e 00 c8 bne- cr7,ffc0ee14 <fifo_open+0x1d8>
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),
ffc0ed50: 88 7e 21 bd lbz r3,8637(r30)
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(
ffc0ed54: 38 80 00 00 li r4,0
ffc0ed58: 38 a0 00 00 li r5,0
ffc0ed5c: 64 63 50 49 oris r3,r3,20553
ffc0ed60: 60 63 77 00 ori r3,r3,30464
ffc0ed64: 38 df 00 30 addi r6,r31,48
ffc0ed68: 48 00 19 dd bl ffc10744 <rtems_barrier_create>
ffc0ed6c: 2f 83 00 00 cmpwi cr7,r3,0
ffc0ed70: 40 9e 00 9c bne- cr7,ffc0ee0c <fifo_open+0x1d0>
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,
ffc0ed74: 88 7e 21 bd lbz r3,8637(r30)
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(
ffc0ed78: 38 80 00 01 li r4,1
ffc0ed7c: 38 a0 00 10 li r5,16
ffc0ed80: 64 63 50 49 oris r3,r3,20553
ffc0ed84: 60 63 73 00 ori r3,r3,29440
ffc0ed88: 38 c0 00 00 li r6,0
ffc0ed8c: 38 ff 00 28 addi r7,r31,40
ffc0ed90: 4b ff ae 25 bl ffc09bb4 <rtems_semaphore_create>
ffc0ed94: 2f 83 00 00 cmpwi cr7,r3,0
ffc0ed98: 40 9e 00 6c bne- cr7,ffc0ee04 <fifo_open+0x1c8>
RTEMS_INLINE_ROUTINE Barrier_Control *_Barrier_Get (
Objects_Id id,
Objects_Locations *location
)
{
return (Barrier_Control *)
ffc0ed9c: 3f 60 00 00 lis r27,0
ffc0eda0: 80 9f 00 2c lwz r4,44(r31)
ffc0eda4: 3b 7b 35 5c addi r27,r27,13660
ffc0eda8: 38 a1 00 08 addi r5,r1,8
ffc0edac: 7f 63 db 78 mr r3,r27
ffc0edb0: 4b ff cb 6d bl ffc0b91c <_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;
ffc0edb4: 80 03 00 4c lwz r0,76(r3)
ffc0edb8: 64 00 10 00 oris r0,r0,4096
ffc0edbc: 90 03 00 4c stw r0,76(r3)
_Thread_Enable_dispatch();
ffc0edc0: 4b ff da 6d bl ffc0c82c <_Thread_Enable_dispatch>
ffc0edc4: 80 9f 00 30 lwz r4,48(r31)
ffc0edc8: 38 a1 00 08 addi r5,r1,8
ffc0edcc: 7f 63 db 78 mr r3,r27
ffc0edd0: 4b ff cb 4d bl ffc0b91c <_Objects_Get>
_Barrier_Get(pipe->writeBarrier, &location)->Barrier.Wait_queue.state
|= STATES_INTERRUPTIBLE_BY_SIGNAL;
ffc0edd4: 80 03 00 4c lwz r0,76(r3)
ffc0edd8: 64 00 10 00 oris r0,r0,4096
ffc0eddc: 90 03 00 4c stw r0,76(r3)
_Thread_Enable_dispatch();
ffc0ede0: 4b ff da 4d bl ffc0c82c <_Thread_Enable_dispatch>
#ifdef RTEMS_POSIX_API
pipe_interruptible(pipe);
#endif
*pipep = pipe;
if (c ++ == 'z')
ffc0ede4: 89 3e 21 bd lbz r9,8637(r30)
ffc0ede8: 2f 89 00 7a cmpwi cr7,r9,122
ffc0edec: 38 09 00 01 addi r0,r9,1
ffc0edf0: 98 1e 21 bd stb r0,8637(r30)
ffc0edf4: 40 be 00 38 bne+ cr7,ffc0ee2c <fifo_open+0x1f0>
c = 'a';
ffc0edf8: 38 00 00 61 li r0,97
ffc0edfc: 98 1e 21 bd stb r0,8637(r30)
ffc0ee00: 48 00 00 2c b ffc0ee2c <fifo_open+0x1f0>
return 0;
err_sem:
rtems_barrier_delete(pipe->writeBarrier);
ffc0ee04: 80 7f 00 30 lwz r3,48(r31)
ffc0ee08: 48 00 1a 0d bl ffc10814 <rtems_barrier_delete>
err_wbar:
rtems_barrier_delete(pipe->readBarrier);
ffc0ee0c: 80 7f 00 2c lwz r3,44(r31)
ffc0ee10: 48 00 1a 05 bl ffc10814 <rtems_barrier_delete>
err_rbar:
free(pipe->Buffer);
ffc0ee14: 80 7f 00 00 lwz r3,0(r31)
ffc0ee18: 4b ff 73 8d bl ffc061a4 <free>
err_buf:
free(pipe);
ffc0ee1c: 7f e3 fb 78 mr r3,r31
ffc0ee20: 4b ff 73 85 bl ffc061a4 <free>
if (err)
goto out;
}
if (! PIPE_LOCK(pipe))
err = -EINTR;
ffc0ee24: 3b c0 ff f4 li r30,-12
ffc0ee28: 48 00 00 48 b ffc0ee70 <fifo_open+0x234>
err = pipe_alloc(&pipe);
if (err)
goto out;
}
if (! PIPE_LOCK(pipe))
ffc0ee2c: 80 7f 00 28 lwz r3,40(r31)
ffc0ee30: 38 80 00 00 li r4,0
ffc0ee34: 38 a0 00 00 li r5,0
ffc0ee38: 4b ff af f1 bl ffc09e28 <rtems_semaphore_obtain>
err = -EINTR;
ffc0ee3c: 3b c0 ff fc li r30,-4
err = pipe_alloc(&pipe);
if (err)
goto out;
}
if (! PIPE_LOCK(pipe))
ffc0ee40: 2f 83 00 00 cmpwi cr7,r3,0
ffc0ee44: 40 9e 00 08 bne- cr7,ffc0ee4c <fifo_open+0x210> <== NEVER TAKEN
ffc0ee48: 3b c0 00 00 li r30,0
err = -EINTR;
if (*pipep == NULL) {
ffc0ee4c: 80 1d 00 00 lwz r0,0(r29)
ffc0ee50: 2f 80 00 00 cmpwi cr7,r0,0
ffc0ee54: 40 be 00 1c bne+ cr7,ffc0ee70 <fifo_open+0x234>
if (err)
ffc0ee58: 2f 9e 00 00 cmpwi cr7,r30,0
ffc0ee5c: 41 be 00 10 beq+ cr7,ffc0ee6c <fifo_open+0x230> <== ALWAYS TAKEN
pipe_free(pipe);
ffc0ee60: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc0ee64: 4b ff fc d5 bl ffc0eb38 <pipe_free> <== NOT EXECUTED
ffc0ee68: 48 00 00 08 b ffc0ee70 <fifo_open+0x234> <== NOT EXECUTED
else
*pipep = pipe;
ffc0ee6c: 93 fd 00 00 stw r31,0(r29)
static void pipe_unlock(void)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
sc = rtems_semaphore_release(pipe_semaphore);
ffc0ee70: 3d 20 00 00 lis r9,0
ffc0ee74: 80 69 29 f8 lwz r3,10744(r9)
ffc0ee78: 4b ff b0 dd bl ffc09f54 <rtems_semaphore_release>
pipe_control_t *pipe;
unsigned int prevCounter;
int err;
err = pipe_new(pipep);
if (err)
ffc0ee7c: 2f 9e 00 00 cmpwi cr7,r30,0
ffc0ee80: 40 9e 01 c4 bne- cr7,ffc0f044 <fifo_open+0x408>
return err;
pipe = *pipep;
switch (LIBIO_ACCMODE(iop)) {
ffc0ee84: 80 1c 00 18 lwz r0,24(r28)
int err;
err = pipe_new(pipep);
if (err)
return err;
pipe = *pipep;
ffc0ee88: 83 fd 00 00 lwz r31,0(r29)
switch (LIBIO_ACCMODE(iop)) {
ffc0ee8c: 54 00 07 7c rlwinm r0,r0,0,29,30
ffc0ee90: 2f 80 00 04 cmpwi cr7,r0,4
ffc0ee94: 41 9e 00 a0 beq- cr7,ffc0ef34 <fifo_open+0x2f8>
ffc0ee98: 2f 80 00 06 cmpwi cr7,r0,6
ffc0ee9c: 41 9e 01 34 beq- cr7,ffc0efd0 <fifo_open+0x394>
ffc0eea0: 2f 80 00 02 cmpwi cr7,r0,2
ffc0eea4: 40 be 01 84 bne+ cr7,ffc0f028 <fifo_open+0x3ec> <== NEVER TAKEN
case LIBIO_FLAGS_READ:
pipe->readerCounter ++;
ffc0eea8: 81 3f 00 20 lwz r9,32(r31)
ffc0eeac: 38 09 00 01 addi r0,r9,1
if (pipe->Readers ++ == 0)
ffc0eeb0: 81 3f 00 10 lwz r9,16(r31)
return err;
pipe = *pipep;
switch (LIBIO_ACCMODE(iop)) {
case LIBIO_FLAGS_READ:
pipe->readerCounter ++;
ffc0eeb4: 90 1f 00 20 stw r0,32(r31)
if (pipe->Readers ++ == 0)
ffc0eeb8: 2f 89 00 00 cmpwi cr7,r9,0
ffc0eebc: 38 09 00 01 addi r0,r9,1
ffc0eec0: 90 1f 00 10 stw r0,16(r31)
ffc0eec4: 40 be 00 10 bne+ cr7,ffc0eed4 <fifo_open+0x298> <== NEVER TAKEN
PIPE_WAKEUPWRITERS(pipe);
ffc0eec8: 80 7f 00 30 lwz r3,48(r31)
ffc0eecc: 38 81 00 0c addi r4,r1,12
ffc0eed0: 48 00 19 fd bl ffc108cc <rtems_barrier_release>
if (pipe->Writers == 0) {
ffc0eed4: 80 1f 00 14 lwz r0,20(r31)
ffc0eed8: 2f 80 00 00 cmpwi cr7,r0,0
ffc0eedc: 40 9e 01 4c bne- cr7,ffc0f028 <fifo_open+0x3ec>
/* Not an error */
if (LIBIO_NODELAY(iop))
ffc0eee0: 80 1c 00 18 lwz r0,24(r28)
ffc0eee4: 70 09 00 01 andi. r9,r0,1
ffc0eee8: 40 82 01 40 bne- ffc0f028 <fifo_open+0x3ec>
break;
prevCounter = pipe->writerCounter;
ffc0eeec: 83 7f 00 24 lwz r27,36(r31)
err = -EINTR;
/* Wait until a writer opens the pipe */
do {
PIPE_UNLOCK(pipe);
ffc0eef0: 80 7f 00 28 lwz r3,40(r31)
ffc0eef4: 4b ff b0 61 bl ffc09f54 <rtems_semaphore_release>
if (! PIPE_READWAIT(pipe))
ffc0eef8: 80 7f 00 2c lwz r3,44(r31)
ffc0eefc: 38 80 00 00 li r4,0
ffc0ef00: 48 00 1a 39 bl ffc10938 <rtems_barrier_wait>
ffc0ef04: 2f 83 00 00 cmpwi cr7,r3,0
ffc0ef08: 40 9e 01 2c bne- cr7,ffc0f034 <fifo_open+0x3f8> <== NEVER TAKEN
goto out_error;
if (! PIPE_LOCK(pipe))
ffc0ef0c: 80 7f 00 28 lwz r3,40(r31)
ffc0ef10: 38 80 00 00 li r4,0
ffc0ef14: 38 a0 00 00 li r5,0
ffc0ef18: 4b ff af 11 bl ffc09e28 <rtems_semaphore_obtain>
ffc0ef1c: 2f 83 00 00 cmpwi cr7,r3,0
ffc0ef20: 40 9e 01 14 bne- cr7,ffc0f034 <fifo_open+0x3f8> <== NEVER TAKEN
goto out_error;
} while (prevCounter == pipe->writerCounter);
ffc0ef24: 80 1f 00 24 lwz r0,36(r31)
ffc0ef28: 7f 9b 00 00 cmpw cr7,r27,r0
ffc0ef2c: 41 9e ff c4 beq+ cr7,ffc0eef0 <fifo_open+0x2b4> <== NEVER TAKEN
ffc0ef30: 48 00 00 f8 b ffc0f028 <fifo_open+0x3ec>
}
break;
case LIBIO_FLAGS_WRITE:
pipe->writerCounter ++;
ffc0ef34: 81 3f 00 24 lwz r9,36(r31)
ffc0ef38: 38 09 00 01 addi r0,r9,1
if (pipe->Writers ++ == 0)
ffc0ef3c: 81 3f 00 14 lwz r9,20(r31)
} while (prevCounter == pipe->writerCounter);
}
break;
case LIBIO_FLAGS_WRITE:
pipe->writerCounter ++;
ffc0ef40: 90 1f 00 24 stw r0,36(r31)
if (pipe->Writers ++ == 0)
ffc0ef44: 2f 89 00 00 cmpwi cr7,r9,0
ffc0ef48: 38 09 00 01 addi r0,r9,1
ffc0ef4c: 90 1f 00 14 stw r0,20(r31)
ffc0ef50: 40 be 00 10 bne+ cr7,ffc0ef60 <fifo_open+0x324> <== NEVER TAKEN
PIPE_WAKEUPREADERS(pipe);
ffc0ef54: 80 7f 00 2c lwz r3,44(r31)
ffc0ef58: 38 81 00 0c addi r4,r1,12
ffc0ef5c: 48 00 19 71 bl ffc108cc <rtems_barrier_release>
if (pipe->Readers == 0 && LIBIO_NODELAY(iop)) {
ffc0ef60: 80 1f 00 10 lwz r0,16(r31)
ffc0ef64: 2f 80 00 00 cmpwi cr7,r0,0
ffc0ef68: 40 9e 00 c0 bne- cr7,ffc0f028 <fifo_open+0x3ec>
ffc0ef6c: 80 1c 00 18 lwz r0,24(r28)
ffc0ef70: 70 09 00 01 andi. r9,r0,1
ffc0ef74: 41 a2 00 14 beq+ ffc0ef88 <fifo_open+0x34c>
PIPE_UNLOCK(pipe);
ffc0ef78: 80 7f 00 28 lwz r3,40(r31)
err = -ENXIO;
ffc0ef7c: 3b c0 ff fa li r30,-6
if (pipe->Writers ++ == 0)
PIPE_WAKEUPREADERS(pipe);
if (pipe->Readers == 0 && LIBIO_NODELAY(iop)) {
PIPE_UNLOCK(pipe);
ffc0ef80: 4b ff af d5 bl ffc09f54 <rtems_semaphore_release>
err = -ENXIO;
goto out_error;
ffc0ef84: 48 00 00 b4 b ffc0f038 <fifo_open+0x3fc>
}
if (pipe->Readers == 0) {
prevCounter = pipe->readerCounter;
ffc0ef88: 83 7f 00 20 lwz r27,32(r31)
err = -EINTR;
do {
PIPE_UNLOCK(pipe);
ffc0ef8c: 80 7f 00 28 lwz r3,40(r31)
ffc0ef90: 4b ff af c5 bl ffc09f54 <rtems_semaphore_release>
if (! PIPE_WRITEWAIT(pipe))
ffc0ef94: 80 7f 00 30 lwz r3,48(r31)
ffc0ef98: 38 80 00 00 li r4,0
ffc0ef9c: 48 00 19 9d bl ffc10938 <rtems_barrier_wait>
ffc0efa0: 2f 83 00 00 cmpwi cr7,r3,0
ffc0efa4: 40 9e 00 90 bne- cr7,ffc0f034 <fifo_open+0x3f8> <== NEVER TAKEN
goto out_error;
if (! PIPE_LOCK(pipe))
ffc0efa8: 80 7f 00 28 lwz r3,40(r31)
ffc0efac: 38 80 00 00 li r4,0
ffc0efb0: 38 a0 00 00 li r5,0
ffc0efb4: 4b ff ae 75 bl ffc09e28 <rtems_semaphore_obtain>
ffc0efb8: 2f 83 00 00 cmpwi cr7,r3,0
ffc0efbc: 40 9e 00 78 bne- cr7,ffc0f034 <fifo_open+0x3f8> <== NEVER TAKEN
goto out_error;
} while (prevCounter == pipe->readerCounter);
ffc0efc0: 80 1f 00 20 lwz r0,32(r31)
ffc0efc4: 7f 9b 00 00 cmpw cr7,r27,r0
ffc0efc8: 41 9e ff c4 beq+ cr7,ffc0ef8c <fifo_open+0x350> <== NEVER TAKEN
ffc0efcc: 48 00 00 5c b ffc0f028 <fifo_open+0x3ec>
}
break;
case LIBIO_FLAGS_READ_WRITE:
pipe->readerCounter ++;
ffc0efd0: 81 3f 00 20 lwz r9,32(r31)
ffc0efd4: 38 09 00 01 addi r0,r9,1
if (pipe->Readers ++ == 0)
ffc0efd8: 81 3f 00 10 lwz r9,16(r31)
} while (prevCounter == pipe->readerCounter);
}
break;
case LIBIO_FLAGS_READ_WRITE:
pipe->readerCounter ++;
ffc0efdc: 90 1f 00 20 stw r0,32(r31)
if (pipe->Readers ++ == 0)
ffc0efe0: 2f 89 00 00 cmpwi cr7,r9,0
ffc0efe4: 38 09 00 01 addi r0,r9,1
ffc0efe8: 90 1f 00 10 stw r0,16(r31)
ffc0efec: 40 be 00 10 bne+ cr7,ffc0effc <fifo_open+0x3c0> <== NEVER TAKEN
PIPE_WAKEUPWRITERS(pipe);
ffc0eff0: 80 7f 00 30 lwz r3,48(r31)
ffc0eff4: 38 81 00 0c addi r4,r1,12
ffc0eff8: 48 00 18 d5 bl ffc108cc <rtems_barrier_release>
pipe->writerCounter ++;
ffc0effc: 81 3f 00 24 lwz r9,36(r31)
ffc0f000: 38 09 00 01 addi r0,r9,1
if (pipe->Writers ++ == 0)
ffc0f004: 81 3f 00 14 lwz r9,20(r31)
case LIBIO_FLAGS_READ_WRITE:
pipe->readerCounter ++;
if (pipe->Readers ++ == 0)
PIPE_WAKEUPWRITERS(pipe);
pipe->writerCounter ++;
ffc0f008: 90 1f 00 24 stw r0,36(r31)
if (pipe->Writers ++ == 0)
ffc0f00c: 2f 89 00 00 cmpwi cr7,r9,0
ffc0f010: 38 09 00 01 addi r0,r9,1
ffc0f014: 90 1f 00 14 stw r0,20(r31)
ffc0f018: 40 be 00 10 bne+ cr7,ffc0f028 <fifo_open+0x3ec> <== NEVER TAKEN
PIPE_WAKEUPREADERS(pipe);
ffc0f01c: 80 7f 00 2c lwz r3,44(r31)
ffc0f020: 38 81 00 0c addi r4,r1,12
ffc0f024: 48 00 18 a9 bl ffc108cc <rtems_barrier_release>
break;
}
PIPE_UNLOCK(pipe);
ffc0f028: 80 7f 00 28 lwz r3,40(r31)
ffc0f02c: 4b ff af 29 bl ffc09f54 <rtems_semaphore_release>
return 0;
ffc0f030: 48 00 00 14 b ffc0f044 <fifo_open+0x408>
goto out_error;
}
if (pipe->Readers == 0) {
prevCounter = pipe->readerCounter;
err = -EINTR;
ffc0f034: 3b c0 ff fc li r30,-4 <== NOT EXECUTED
PIPE_UNLOCK(pipe);
return 0;
out_error:
pipe_release(pipep, iop);
ffc0f038: 7f a3 eb 78 mr r3,r29
ffc0f03c: 7f 84 e3 78 mr r4,r28
ffc0f040: 4b ff fb 41 bl ffc0eb80 <pipe_release>
return err;
}
ffc0f044: 39 61 00 30 addi r11,r1,48
ffc0f048: 7f c3 f3 78 mr r3,r30
ffc0f04c: 48 01 20 9c b ffc210e8 <_restgpr_27_x>
ffc0518c <fpathconf>:
long fpathconf(
int fd,
int name
)
{
ffc0518c: 7c 08 02 a6 mflr r0
ffc05190: 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);
ffc05194: 3d 20 00 00 lis r9,0
long fpathconf(
int fd,
int name
)
{
ffc05198: 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);
ffc0519c: 80 09 27 1c lwz r0,10012(r9)
ffc051a0: 7f 83 00 40 cmplw cr7,r3,r0
ffc051a4: 40 9c 00 20 bge- cr7,ffc051c4 <fpathconf+0x38>
iop = rtems_libio_iop(fd);
ffc051a8: 3d 20 00 00 lis r9,0
ffc051ac: 80 09 27 cc lwz r0,10188(r9)
ffc051b0: 54 63 30 32 rlwinm r3,r3,6,0,25
ffc051b4: 7c 60 1a 14 add r3,r0,r3
rtems_libio_check_is_open(iop);
ffc051b8: 80 03 00 18 lwz r0,24(r3)
ffc051bc: 70 09 01 00 andi. r9,r0,256
ffc051c0: 40 a2 00 10 bne+ ffc051d0 <fpathconf+0x44> <== ALWAYS TAKEN
ffc051c4: 48 00 c6 11 bl ffc117d4 <__errno>
ffc051c8: 38 00 00 09 li r0,9
ffc051cc: 48 00 00 94 b ffc05260 <fpathconf+0xd4>
* Now process the information request.
*/
the_limits = &iop->pathinfo.mt_entry->pathconf_limits_and_options;
switch ( name ) {
ffc051d0: 2b 84 00 0b cmplwi cr7,r4,11
/*
* Now process the information request.
*/
the_limits = &iop->pathinfo.mt_entry->pathconf_limits_and_options;
ffc051d4: 81 23 00 2c lwz r9,44(r3)
switch ( name ) {
ffc051d8: 41 9d 00 80 bgt- cr7,ffc05258 <fpathconf+0xcc>
ffc051dc: 3d 60 ff c2 lis r11,-62
ffc051e0: 39 6b 91 04 addi r11,r11,-28412
ffc051e4: 54 84 10 3a rlwinm r4,r4,2,0,29
ffc051e8: 7c 0b 20 2e lwzx r0,r11,r4
ffc051ec: 7d 60 5a 14 add r11,r0,r11
ffc051f0: 7d 69 03 a6 mtctr r11
ffc051f4: 4e 80 04 20 bctr
case _PC_LINK_MAX:
return_value = the_limits->link_max;
ffc051f8: 80 69 00 38 lwz r3,56(r9)
break;
ffc051fc: 48 00 00 6c b ffc05268 <fpathconf+0xdc>
case _PC_MAX_CANON:
return_value = the_limits->max_canon;
ffc05200: 80 69 00 3c lwz r3,60(r9)
break;
ffc05204: 48 00 00 64 b ffc05268 <fpathconf+0xdc>
case _PC_MAX_INPUT:
return_value = the_limits->max_input;
ffc05208: 80 69 00 40 lwz r3,64(r9)
break;
ffc0520c: 48 00 00 5c b ffc05268 <fpathconf+0xdc>
case _PC_NAME_MAX:
return_value = the_limits->name_max;
ffc05210: 80 69 00 44 lwz r3,68(r9)
break;
ffc05214: 48 00 00 54 b ffc05268 <fpathconf+0xdc>
case _PC_PATH_MAX:
return_value = the_limits->path_max;
ffc05218: 80 69 00 48 lwz r3,72(r9)
break;
ffc0521c: 48 00 00 4c b ffc05268 <fpathconf+0xdc>
case _PC_PIPE_BUF:
return_value = the_limits->pipe_buf;
ffc05220: 80 69 00 4c lwz r3,76(r9)
break;
ffc05224: 48 00 00 44 b ffc05268 <fpathconf+0xdc>
case _PC_CHOWN_RESTRICTED:
return_value = the_limits->posix_chown_restrictions;
ffc05228: 80 69 00 54 lwz r3,84(r9)
break;
ffc0522c: 48 00 00 3c b ffc05268 <fpathconf+0xdc>
case _PC_NO_TRUNC:
return_value = the_limits->posix_no_trunc;
ffc05230: 80 69 00 58 lwz r3,88(r9)
break;
ffc05234: 48 00 00 34 b ffc05268 <fpathconf+0xdc>
case _PC_VDISABLE:
return_value = the_limits->posix_vdisable;
ffc05238: 80 69 00 64 lwz r3,100(r9)
break;
ffc0523c: 48 00 00 2c b ffc05268 <fpathconf+0xdc>
case _PC_ASYNC_IO:
return_value = the_limits->posix_async_io;
ffc05240: 80 69 00 50 lwz r3,80(r9)
break;
ffc05244: 48 00 00 24 b ffc05268 <fpathconf+0xdc>
case _PC_PRIO_IO:
return_value = the_limits->posix_prio_io;
ffc05248: 80 69 00 5c lwz r3,92(r9)
break;
ffc0524c: 48 00 00 1c b ffc05268 <fpathconf+0xdc>
case _PC_SYNC_IO:
return_value = the_limits->posix_sync_io;
ffc05250: 80 69 00 60 lwz r3,96(r9)
break;
ffc05254: 48 00 00 14 b ffc05268 <fpathconf+0xdc>
default:
rtems_set_errno_and_return_minus_one( EINVAL );
ffc05258: 48 00 c5 7d bl ffc117d4 <__errno>
ffc0525c: 38 00 00 16 li r0,22
ffc05260: 90 03 00 00 stw r0,0(r3)
ffc05264: 38 60 ff ff li r3,-1
break;
}
return return_value;
}
ffc05268: 80 01 00 0c lwz r0,12(r1)
ffc0526c: 38 21 00 08 addi r1,r1,8
ffc05270: 7c 08 03 a6 mtlr r0
ffc05274: 4e 80 00 20 blr
ffc0495c <free>:
#include <stdlib.h>
void free(
void *ptr
)
{
ffc0495c: 94 21 ff f0 stwu r1,-16(r1)
ffc04960: 7c 08 02 a6 mflr r0
MSBUMP(free_calls, 1);
ffc04964: 3d 20 00 00 lis r9,0
#include <stdlib.h>
void free(
void *ptr
)
{
ffc04968: 90 01 00 14 stw r0,20(r1)
MSBUMP(free_calls, 1);
ffc0496c: 39 29 2b 60 addi r9,r9,11104
#include <stdlib.h>
void free(
void *ptr
)
{
ffc04970: bf c1 00 08 stmw r30,8(r1)
MSBUMP(free_calls, 1);
if ( !ptr )
ffc04974: 7c 7f 1b 79 mr. r31,r3
void free(
void *ptr
)
{
MSBUMP(free_calls, 1);
ffc04978: 81 69 00 0c lwz r11,12(r9)
ffc0497c: 38 0b 00 01 addi r0,r11,1
ffc04980: 90 09 00 0c stw r0,12(r9)
if ( !ptr )
ffc04984: 41 82 00 84 beq- ffc04a08 <free+0xac>
return;
/*
* Do not attempt to free memory if in a critical section or ISR.
*/
if ( _System_state_Is_up(_System_state_Get()) &&
ffc04988: 3d 20 00 00 lis r9,0
ffc0498c: 80 09 28 48 lwz r0,10312(r9)
ffc04990: 2f 80 00 03 cmpwi cr7,r0,3
ffc04994: 40 be 00 1c bne+ cr7,ffc049b0 <free+0x54> <== NEVER TAKEN
!malloc_is_system_state_OK() ) {
ffc04998: 48 00 01 c5 bl ffc04b5c <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()) &&
ffc0499c: 2f 83 00 00 cmpwi cr7,r3,0
ffc049a0: 40 be 00 10 bne+ cr7,ffc049b0 <free+0x54>
!malloc_is_system_state_OK() ) {
malloc_deferred_free(ptr);
ffc049a4: 7f e3 fb 78 mr r3,r31
ffc049a8: 48 00 02 39 bl ffc04be0 <malloc_deferred_free>
return;
ffc049ac: 48 00 00 5c b ffc04a08 <free+0xac>
}
/*
* If configured, update the statistics
*/
if ( rtems_malloc_statistics_helpers )
ffc049b0: 3d 20 00 00 lis r9,0
ffc049b4: 81 29 27 ac lwz r9,10156(r9)
ffc049b8: 2f 89 00 00 cmpwi cr7,r9,0
ffc049bc: 41 9e 00 14 beq- cr7,ffc049d0 <free+0x74>
(*rtems_malloc_statistics_helpers->at_free)(ptr);
ffc049c0: 80 09 00 08 lwz r0,8(r9)
ffc049c4: 7f e3 fb 78 mr r3,r31
ffc049c8: 7c 09 03 a6 mtctr r0
ffc049cc: 4e 80 04 21 bctrl
if ( !_Protected_heap_Free( RTEMS_Malloc_Heap, ptr ) ) {
ffc049d0: 3f c0 00 00 lis r30,0
ffc049d4: 80 7e 27 2c lwz r3,10028(r30)
ffc049d8: 7f e4 fb 78 mr r4,r31
ffc049dc: 48 00 55 71 bl ffc09f4c <_Protected_heap_Free>
ffc049e0: 2f 83 00 00 cmpwi cr7,r3,0
ffc049e4: 40 be 00 24 bne+ cr7,ffc04a08 <free+0xac>
printk( "Program heap: free of bad pointer %p -- range %p - %p \n",
ptr,
RTEMS_Malloc_Heap->area_begin,
ffc049e8: 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",
ffc049ec: 3c 60 ff c2 lis r3,-62
ffc049f0: 38 63 d7 a4 addi r3,r3,-10332
ffc049f4: 80 a9 00 18 lwz r5,24(r9)
ffc049f8: 7f e4 fb 78 mr r4,r31
ffc049fc: 80 c9 00 1c lwz r6,28(r9)
ffc04a00: 4c c6 31 82 crclr 4*cr1+eq
ffc04a04: 48 00 0e 8d bl ffc05890 <printk>
RTEMS_Malloc_Heap->area_begin,
RTEMS_Malloc_Heap->area_end
);
}
}
ffc04a08: 39 61 00 10 addi r11,r1,16
ffc04a0c: 4b ff bb 34 b ffc00540 <_restgpr_30_x>
ffc07f7c <free_user_env>:
* NOTE: this must be called with
* thread dispatching disabled!
*/
static void
free_user_env(void *venv)
{
ffc07f7c: 7c 08 02 a6 mflr r0
ffc07f80: 7c 2b 0b 78 mr r11,r1
ffc07f84: 94 21 ff f0 stwu r1,-16(r1)
rtems_user_env_t *env = (rtems_user_env_t*) venv ;
if (env != &rtems_global_user_env
ffc07f88: 3d 20 00 00 lis r9,0
* NOTE: this must be called with
* thread dispatching disabled!
*/
static void
free_user_env(void *venv)
{
ffc07f8c: 90 01 00 14 stw r0,20(r1)
rtems_user_env_t *env = (rtems_user_env_t*) venv ;
if (env != &rtems_global_user_env
ffc07f90: 38 09 2b 70 addi r0,r9,11120
ffc07f94: 7f 83 00 00 cmpw cr7,r3,r0
* NOTE: this must be called with
* thread dispatching disabled!
*/
static void
free_user_env(void *venv)
{
ffc07f98: 4b ff a8 9d bl ffc02834 <_savegpr_31>
ffc07f9c: 7c 7f 1b 78 mr r31,r3
rtems_user_env_t *env = (rtems_user_env_t*) venv ;
if (env != &rtems_global_user_env
ffc07fa0: 41 9e 00 1c beq- cr7,ffc07fbc <free_user_env+0x40> <== NEVER TAKEN
#ifdef HAVE_USERENV_REFCNT
&& --env->refcnt <= 0
#endif
) {
rtems_filesystem_freenode( &env->current_directory);
ffc07fa4: 38 63 00 04 addi r3,r3,4
ffc07fa8: 4b ff ec bd bl ffc06c64 <rtems_filesystem_freenode>
rtems_filesystem_freenode( &env->root_directory);
ffc07fac: 38 7f 00 18 addi r3,r31,24
ffc07fb0: 4b ff ec b5 bl ffc06c64 <rtems_filesystem_freenode>
free(env);
ffc07fb4: 7f e3 fb 78 mr r3,r31
ffc07fb8: 4b ff ec d9 bl ffc06c90 <free>
}
}
ffc07fbc: 39 61 00 10 addi r11,r1,16
ffc07fc0: 4b ff a8 c0 b ffc02880 <_restgpr_31_x>
ffc03e64 <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) {
ffc03e64: 3d 20 00 00 lis r9,0
ffc03e68: 80 09 28 e8 lwz r0,10472(r9)
ffc03e6c: 39 69 28 e8 addi r11,r9,10472
return dd;
}
}
return NULL;
ffc03e70: 39 20 00 00 li r9,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) {
ffc03e74: 7f 83 00 40 cmplw cr7,r3,r0
ffc03e78: 40 9c 00 68 bge- cr7,ffc03ee0 <get_disk_entry+0x7c> <== NEVER TAKEN
ffc03e7c: 81 6b 00 04 lwz r11,4(r11)
ffc03e80: 2f 8b 00 00 cmpwi cr7,r11,0
ffc03e84: 41 9e 00 5c beq- cr7,ffc03ee0 <get_disk_entry+0x7c> <== NEVER TAKEN
rtems_disk_device_table *dtab = disktab + major;
ffc03e88: 54 63 18 38 rlwinm r3,r3,3,0,28
ffc03e8c: 7d 4b 1a 14 add r10,r11,r3
if (minor < dtab->size && dtab->minor != NULL) {
ffc03e90: 80 0a 00 04 lwz r0,4(r10)
ffc03e94: 7f 84 00 40 cmplw cr7,r4,r0
ffc03e98: 40 9c 00 48 bge- cr7,ffc03ee0 <get_disk_entry+0x7c> <== NEVER TAKEN
ffc03e9c: 7d 6b 18 2e lwzx r11,r11,r3
ffc03ea0: 2f 8b 00 00 cmpwi cr7,r11,0
ffc03ea4: 41 9e 00 3c beq- cr7,ffc03ee0 <get_disk_entry+0x7c> <== NEVER TAKEN
rtems_disk_device *dd = dtab->minor [minor];
ffc03ea8: 54 84 10 3a rlwinm r4,r4,2,0,29
ffc03eac: 7d 2b 20 2e lwzx r9,r11,r4
if (dd != NULL && !lookup_only) {
ffc03eb0: 2f 89 00 00 cmpwi cr7,r9,0
ffc03eb4: 41 9e 00 2c beq- cr7,ffc03ee0 <get_disk_entry+0x7c>
ffc03eb8: 2f 85 00 00 cmpwi cr7,r5,0
ffc03ebc: 40 9e 00 24 bne- cr7,ffc03ee0 <get_disk_entry+0x7c>
if (!dd->deleted) {
ffc03ec0: 88 09 00 30 lbz r0,48(r9)
ffc03ec4: 2f 80 00 00 cmpwi cr7,r0,0
ffc03ec8: 40 9e 00 14 bne- cr7,ffc03edc <get_disk_entry+0x78>
++dd->uses;
ffc03ecc: 81 69 00 14 lwz r11,20(r9)
ffc03ed0: 38 0b 00 01 addi r0,r11,1
ffc03ed4: 90 09 00 14 stw r0,20(r9)
ffc03ed8: 48 00 00 08 b ffc03ee0 <get_disk_entry+0x7c>
} else {
dd = NULL;
ffc03edc: 39 20 00 00 li r9,0
return dd;
}
}
return NULL;
}
ffc03ee0: 7d 23 4b 78 mr r3,r9
ffc03ee4: 4e 80 00 20 blr
ffc1cb28 <getdents>:
int getdents(
int dd_fd,
char *dd_buf,
int dd_len
)
{
ffc1cb28: 94 21 ff c8 stwu r1,-56(r1)
ffc1cb2c: 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 );
ffc1cb30: 3d 20 00 00 lis r9,0
int getdents(
int dd_fd,
char *dd_buf,
int dd_len
)
{
ffc1cb34: 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 );
ffc1cb38: 80 09 27 1c lwz r0,10012(r9)
int getdents(
int dd_fd,
char *dd_buf,
int dd_len
)
{
ffc1cb3c: bf c1 00 30 stmw r30,48(r1)
ffc1cb40: 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 );
ffc1cb44: 7f 83 00 40 cmplw cr7,r3,r0
ffc1cb48: 3b c0 00 00 li r30,0
ffc1cb4c: 40 9c 00 14 bge- cr7,ffc1cb60 <getdents+0x38> <== NEVER TAKEN
ffc1cb50: 3d 20 00 00 lis r9,0
ffc1cb54: 83 c9 27 cc lwz r30,10188(r9)
ffc1cb58: 54 63 30 32 rlwinm r3,r3,6,0,25
ffc1cb5c: 7f de 1a 14 add r30,r30,r3
/*
* Make sure we are working on a directory
*/
loc = iop->pathinfo;
ffc1cb60: 39 7e 00 1c addi r11,r30,28
ffc1cb64: 38 61 00 08 addi r3,r1,8
ffc1cb68: 7c ab a4 aa lswi r5,r11,20
ffc1cb6c: 7c a3 a5 aa stswi r5,r3,20
if ( (*loc.ops->node_type_h)( &loc ) != RTEMS_FILESYSTEM_DIRECTORY )
ffc1cb70: 81 21 00 14 lwz r9,20(r1)
ffc1cb74: 80 09 00 10 lwz r0,16(r9)
ffc1cb78: 90 81 00 28 stw r4,40(r1)
ffc1cb7c: 7c 09 03 a6 mtctr r0
ffc1cb80: 4e 80 04 21 bctrl
ffc1cb84: 80 81 00 28 lwz r4,40(r1)
ffc1cb88: 2f 83 00 01 cmpwi cr7,r3,1
ffc1cb8c: 41 be 00 18 beq+ cr7,ffc1cba4 <getdents+0x7c>
rtems_set_errno_and_return_minus_one( ENOTDIR );
ffc1cb90: 4b ff 4a 95 bl ffc11624 <__errno>
ffc1cb94: 38 00 00 14 li r0,20
ffc1cb98: 90 03 00 00 stw r0,0(r3)
ffc1cb9c: 38 60 ff ff li r3,-1
ffc1cba0: 48 00 00 1c b ffc1cbbc <getdents+0x94>
/*
* 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 );
ffc1cba4: 81 3e 00 24 lwz r9,36(r30)
ffc1cba8: 7f c3 f3 78 mr r3,r30
ffc1cbac: 7f e5 fb 78 mr r5,r31
ffc1cbb0: 80 09 00 08 lwz r0,8(r9)
ffc1cbb4: 7c 09 03 a6 mtctr r0
ffc1cbb8: 4e 80 04 21 bctrl
}
ffc1cbbc: 39 61 00 38 addi r11,r1,56
ffc1cbc0: 4b fe 3f b4 b ffc00b74 <_restgpr_30_x>
ffc0fd80 <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 )
ffc0fd80: 81 23 00 1c lwz r9,28(r3)
return -1; /* It wasn't a directory --> return error */
ffc0fd84: 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 )
ffc0fd88: 81 29 00 4c lwz r9,76(r9)
ffc0fd8c: 2f 89 00 01 cmpwi cr7,r9,1
ffc0fd90: 40 9e 00 18 bne- cr7,ffc0fda8 <imfs_dir_open+0x28> <== NEVER TAKEN
return -1; /* It wasn't a directory --> return error */
iop->offset = 0;
ffc0fd94: 39 40 00 00 li r10,0
ffc0fd98: 39 60 00 00 li r11,0
ffc0fd9c: 91 43 00 10 stw r10,16(r3)
return 0;
ffc0fda0: 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;
ffc0fda4: 91 63 00 14 stw r11,20(r3)
return 0;
}
ffc0fda8: 7c 03 03 78 mr r3,r0
ffc0fdac: 4e 80 00 20 blr
ffc0ffbc <imfs_dir_rmnod>:
int imfs_dir_rmnod(
rtems_filesystem_location_info_t *parent_pathloc, /* IN */
rtems_filesystem_location_info_t *pathloc /* IN */
)
{
ffc0ffbc: 7c 08 02 a6 mflr r0
ffc0ffc0: 7c 2b 0b 78 mr r11,r1
ffc0ffc4: 94 21 ff f0 stwu r1,-16(r1)
ffc0ffc8: 90 01 00 14 stw r0,20(r1)
ffc0ffcc: 48 00 b3 81 bl ffc1b34c <_savegpr_31>
IMFS_jnode_t *the_jnode;
the_jnode = (IMFS_jnode_t *) pathloc->node_access;
ffc0ffd0: 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 ) )
ffc0ffd4: 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 );
ffc0ffd8: 38 1f 00 54 addi r0,r31,84
ffc0ffdc: 7f 89 00 00 cmpw cr7,r9,r0
ffc0ffe0: 41 be 00 10 beq+ cr7,ffc0fff0 <imfs_dir_rmnod+0x34>
rtems_set_errno_and_return_minus_one( ENOTEMPTY );
ffc0ffe4: 48 00 0b d1 bl ffc10bb4 <__errno>
ffc0ffe8: 38 00 00 5a li r0,90
ffc0ffec: 48 00 00 1c b ffc10008 <imfs_dir_rmnod+0x4c>
ffc0fff0: 81 24 00 10 lwz r9,16(r4)
/*
* You cannot remove the file system root node.
*/
if ( rtems_filesystem_is_root_location(pathloc) )
ffc0fff4: 80 09 00 1c lwz r0,28(r9)
ffc0fff8: 7f 80 f8 00 cmpw cr7,r0,r31
ffc0fffc: 40 be 00 18 bne+ cr7,ffc10014 <imfs_dir_rmnod+0x58>
rtems_set_errno_and_return_minus_one( EBUSY );
ffc10000: 48 00 0b b5 bl ffc10bb4 <__errno>
ffc10004: 38 00 00 10 li r0,16
ffc10008: 90 03 00 00 stw r0,0(r3)
ffc1000c: 38 60 ff ff li r3,-1
ffc10010: 48 00 00 24 b ffc10034 <imfs_dir_rmnod+0x78>
/*
* You cannot remove a mountpoint.
*/
if ( the_jnode->info.directory.mt_fs != NULL )
ffc10014: 80 1f 00 5c lwz r0,92(r31)
ffc10018: 2f 80 00 00 cmpwi cr7,r0,0
ffc1001c: 40 be ff e4 bne- cr7,ffc10000 <imfs_dir_rmnod+0x44> <== NEVER TAKEN
rtems_set_errno_and_return_minus_one( EBUSY );
IMFS_create_orphan( the_jnode );
ffc10020: 7f e3 fb 78 mr r3,r31
ffc10024: 4b ff cc b5 bl ffc0ccd8 <IMFS_create_orphan>
IMFS_check_node_remove( the_jnode );
ffc10028: 7f e3 fb 78 mr r3,r31
ffc1002c: 4b ff cd 05 bl ffc0cd30 <IMFS_check_node_remove>
return 0;
ffc10030: 38 60 00 00 li r3,0
}
ffc10034: 39 61 00 10 addi r11,r1,16
ffc10038: 4b ff 05 0c b ffc00544 <_restgpr_31_x>
ffc04ff8 <init_etc_passwd_group>:
/*
* Initialize useable but dummy databases
*/
void init_etc_passwd_group(void)
{
ffc04ff8: 7c 08 02 a6 mflr r0
ffc04ffc: 7c 2b 0b 78 mr r11,r1
ffc05000: 94 21 ff f0 stwu r1,-16(r1)
FILE *fp;
static char etc_passwd_initted = 0;
if (etc_passwd_initted)
ffc05004: 3d 20 00 00 lis r9,0
/*
* Initialize useable but dummy databases
*/
void init_etc_passwd_group(void)
{
ffc05008: 90 01 00 14 stw r0,20(r1)
ffc0500c: 48 01 21 19 bl ffc17124 <_savegpr_31>
FILE *fp;
static char etc_passwd_initted = 0;
if (etc_passwd_initted)
ffc05010: 88 09 28 d0 lbz r0,10448(r9)
ffc05014: 2f 80 00 00 cmpwi cr7,r0,0
ffc05018: 40 be 00 bc bne+ cr7,ffc050d4 <init_etc_passwd_group+0xdc>
return;
etc_passwd_initted = 1;
mkdir("/etc", 0777);
ffc0501c: 3c 60 ff c2 lis r3,-62
FILE *fp;
static char etc_passwd_initted = 0;
if (etc_passwd_initted)
return;
etc_passwd_initted = 1;
ffc05020: 38 00 00 01 li r0,1
mkdir("/etc", 0777);
ffc05024: 38 80 01 ff li r4,511
FILE *fp;
static char etc_passwd_initted = 0;
if (etc_passwd_initted)
return;
etc_passwd_initted = 1;
ffc05028: 98 09 28 d0 stb r0,10448(r9)
mkdir("/etc", 0777);
ffc0502c: 38 63 8f 7b addi r3,r3,-28805
/*
* Initialize /etc/passwd
*/
if ((fp = fopen("/etc/passwd", "r")) != NULL) {
ffc05030: 3f e0 ff c2 lis r31,-62
static char etc_passwd_initted = 0;
if (etc_passwd_initted)
return;
etc_passwd_initted = 1;
mkdir("/etc", 0777);
ffc05034: 48 00 09 e1 bl ffc05a14 <mkdir>
/*
* Initialize /etc/passwd
*/
if ((fp = fopen("/etc/passwd", "r")) != NULL) {
ffc05038: 3b ff 8f 80 addi r31,r31,-28800
ffc0503c: 3c 80 ff c2 lis r4,-62
ffc05040: 7f e3 fb 78 mr r3,r31
ffc05044: 38 84 87 a0 addi r4,r4,-30816
ffc05048: 48 00 d1 65 bl ffc121ac <fopen>
ffc0504c: 2f 83 00 00 cmpwi cr7,r3,0
ffc05050: 40 be 00 30 bne+ cr7,ffc05080 <init_etc_passwd_group+0x88>
fclose(fp);
}
else if ((fp = fopen("/etc/passwd", "w")) != NULL) {
ffc05054: 3c 80 ff c2 lis r4,-62
ffc05058: 7f e3 fb 78 mr r3,r31
ffc0505c: 38 84 8f 8c addi r4,r4,-28788
ffc05060: 48 00 d1 4d bl ffc121ac <fopen>
ffc05064: 7c 7f 1b 79 mr. r31,r3
ffc05068: 41 82 00 1c beq- ffc05084 <init_etc_passwd_group+0x8c> <== NEVER TAKEN
fprintf(fp, "root:*:0:0:root::/:/bin/sh\n"
ffc0506c: 3c 60 ff c2 lis r3,-62
ffc05070: 38 63 8f 8e addi r3,r3,-28786
ffc05074: 7f e4 fb 78 mr r4,r31
ffc05078: 48 00 d1 f9 bl ffc12270 <fputs>
"rtems:*:1:1:RTEMS Application::/:/bin/sh\n"
"tty:!:2:2:tty owner::/:/bin/false\n" );
fclose(fp);
ffc0507c: 7f e3 fb 78 mr r3,r31
ffc05080: 48 00 c7 85 bl ffc11804 <fclose>
}
/*
* Initialize /etc/group
*/
if ((fp = fopen("/etc/group", "r")) != NULL) {
ffc05084: 3f e0 ff c2 lis r31,-62
ffc05088: 3b ff 8f f5 addi r31,r31,-28683
ffc0508c: 3c 80 ff c2 lis r4,-62
ffc05090: 7f e3 fb 78 mr r3,r31
ffc05094: 38 84 87 a0 addi r4,r4,-30816
ffc05098: 48 00 d1 15 bl ffc121ac <fopen>
ffc0509c: 2f 83 00 00 cmpwi cr7,r3,0
ffc050a0: 40 be 00 30 bne+ cr7,ffc050d0 <init_etc_passwd_group+0xd8>
fclose(fp);
}
else if ((fp = fopen("/etc/group", "w")) != NULL) {
ffc050a4: 3c 80 ff c2 lis r4,-62
ffc050a8: 7f e3 fb 78 mr r3,r31
ffc050ac: 38 84 8f 8c addi r4,r4,-28788
ffc050b0: 48 00 d0 fd bl ffc121ac <fopen>
ffc050b4: 7c 7f 1b 79 mr. r31,r3
ffc050b8: 41 82 00 1c beq- ffc050d4 <init_etc_passwd_group+0xdc> <== NEVER TAKEN
fprintf( fp, "root:x:0:root\n"
ffc050bc: 3c 60 ff c2 lis r3,-62
ffc050c0: 38 63 90 00 addi r3,r3,-28672
ffc050c4: 7f e4 fb 78 mr r4,r31
ffc050c8: 48 00 d1 a9 bl ffc12270 <fputs>
"rtems:x:1:rtems\n"
"tty:x:2:tty\n" );
fclose(fp);
ffc050cc: 7f e3 fb 78 mr r3,r31
ffc050d0: 48 00 c7 35 bl ffc11804 <fclose>
}
}
ffc050d4: 39 61 00 10 addi r11,r1,16
ffc050d8: 4b ff b7 e8 b ffc008c0 <_restgpr_31_x>
ffc06970 <iproc>:
/*
* Process a single input character
*/
static int
iproc (unsigned char c, struct rtems_termios_tty *tty)
{
ffc06970: 94 21 ff f0 stwu r1,-16(r1)
ffc06974: 7c 08 02 a6 mflr r0
ffc06978: 90 01 00 14 stw r0,20(r1)
if (tty->termios.c_iflag & ISTRIP)
ffc0697c: 80 04 00 30 lwz r0,48(r4)
/*
* Process a single input character
*/
static int
iproc (unsigned char c, struct rtems_termios_tty *tty)
{
ffc06980: bf c1 00 08 stmw r30,8(r1)
ffc06984: 7c 7e 1b 78 mr r30,r3
if (tty->termios.c_iflag & ISTRIP)
ffc06988: 70 09 00 20 andi. r9,r0,32
/*
* Process a single input character
*/
static int
iproc (unsigned char c, struct rtems_termios_tty *tty)
{
ffc0698c: 7c 9f 23 78 mr r31,r4
if (tty->termios.c_iflag & ISTRIP)
ffc06990: 41 82 00 08 beq- ffc06998 <iproc+0x28> <== ALWAYS TAKEN
c &= 0x7f;
ffc06994: 54 7e 06 7e clrlwi r30,r3,25 <== NOT EXECUTED
if (tty->termios.c_iflag & IUCLC)
ffc06998: 70 09 02 00 andi. r9,r0,512
ffc0699c: 41 82 00 28 beq- ffc069c4 <iproc+0x54>
c = tolower (c);
ffc069a0: 3d 20 00 00 lis r9,0
ffc069a4: 81 29 27 84 lwz r9,10116(r9)
ffc069a8: 7d 29 f2 14 add r9,r9,r30
ffc069ac: 89 29 00 01 lbz r9,1(r9)
ffc069b0: 55 29 07 be clrlwi r9,r9,30
ffc069b4: 2f 89 00 01 cmpwi cr7,r9,1
ffc069b8: 40 be 00 08 bne+ cr7,ffc069c0 <iproc+0x50>
ffc069bc: 3b de 00 20 addi r30,r30,32
ffc069c0: 57 de 06 3e clrlwi r30,r30,24
if (c == '\r') {
ffc069c4: 2f 9e 00 0d cmpwi cr7,r30,13
ffc069c8: 40 be 00 20 bne+ cr7,ffc069e8 <iproc+0x78>
if (tty->termios.c_iflag & IGNCR)
ffc069cc: 70 09 00 80 andi. r9,r0,128
return 0;
ffc069d0: 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)
ffc069d4: 40 82 01 44 bne- ffc06b18 <iproc+0x1a8> <== NEVER TAKEN
return 0;
if (tty->termios.c_iflag & ICRNL)
ffc069d8: 70 09 01 00 andi. r9,r0,256
ffc069dc: 41 82 00 2c beq- ffc06a08 <iproc+0x98> <== NEVER TAKEN
c = '\n';
ffc069e0: 3b c0 00 0a li r30,10
ffc069e4: 48 00 00 24 b ffc06a08 <iproc+0x98>
} else if ((c == '\n') && (tty->termios.c_iflag & INLCR)) {
ffc069e8: 2f 9e 00 0a cmpwi cr7,r30,10
ffc069ec: 40 be 00 14 bne+ cr7,ffc06a00 <iproc+0x90>
ffc069f0: 70 09 00 40 andi. r9,r0,64
ffc069f4: 41 82 00 14 beq- ffc06a08 <iproc+0x98> <== ALWAYS TAKEN
c = '\r';
ffc069f8: 3b c0 00 0d li r30,13 <== NOT EXECUTED
ffc069fc: 48 00 00 0c b ffc06a08 <iproc+0x98> <== NOT EXECUTED
}
if ((c != '\0') && (tty->termios.c_lflag & ICANON)) {
ffc06a00: 2f 9e 00 00 cmpwi cr7,r30,0
ffc06a04: 41 be 00 c8 beq+ cr7,ffc06acc <iproc+0x15c> <== NEVER TAKEN
ffc06a08: 80 1f 00 3c lwz r0,60(r31)
ffc06a0c: 70 09 00 02 andi. r9,r0,2
ffc06a10: 41 82 00 bc beq- ffc06acc <iproc+0x15c>
if (c == tty->termios.c_cc[VERASE]) {
ffc06a14: 89 3f 00 43 lbz r9,67(r31)
erase (tty, 0);
ffc06a18: 7f e3 fb 78 mr r3,r31
ffc06a1c: 38 80 00 00 li r4,0
} else if ((c == '\n') && (tty->termios.c_iflag & INLCR)) {
c = '\r';
}
if ((c != '\0') && (tty->termios.c_lflag & ICANON)) {
if (c == tty->termios.c_cc[VERASE]) {
ffc06a20: 7f 89 f0 00 cmpw cr7,r9,r30
ffc06a24: 41 9e 00 18 beq- cr7,ffc06a3c <iproc+0xcc>
erase (tty, 0);
return 0;
}
else if (c == tty->termios.c_cc[VKILL]) {
ffc06a28: 89 3f 00 44 lbz r9,68(r31)
ffc06a2c: 7f 89 f0 00 cmpw cr7,r9,r30
ffc06a30: 40 be 00 14 bne+ cr7,ffc06a44 <iproc+0xd4>
erase (tty, 1);
ffc06a34: 7f e3 fb 78 mr r3,r31
ffc06a38: 38 80 00 01 li r4,1
ffc06a3c: 4b ff fd 29 bl ffc06764 <erase>
ffc06a40: 48 00 00 d4 b ffc06b14 <iproc+0x1a4>
return 0;
}
else if (c == tty->termios.c_cc[VEOF]) {
ffc06a44: 89 3f 00 45 lbz r9,69(r31)
return 1;
ffc06a48: 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]) {
ffc06a4c: 7f 89 f0 00 cmpw cr7,r9,r30
ffc06a50: 41 9e 00 c8 beq- cr7,ffc06b18 <iproc+0x1a8> <== NEVER TAKEN
return 1;
} else if (c == '\n') {
ffc06a54: 2f 9e 00 0a cmpwi cr7,r30,10
ffc06a58: 40 be 00 2c bne+ cr7,ffc06a84 <iproc+0x114>
if (tty->termios.c_lflag & (ECHO | ECHONL))
ffc06a5c: 70 09 00 48 andi. r9,r0,72
ffc06a60: 41 a2 00 10 beq+ ffc06a70 <iproc+0x100> <== NEVER TAKEN
echo (c, tty);
ffc06a64: 38 60 00 0a li r3,10
ffc06a68: 7f e4 fb 78 mr r4,r31
ffc06a6c: 4b ff fc 6d bl ffc066d8 <echo>
tty->cbuf[tty->ccount++] = c;
ffc06a70: 81 3f 00 20 lwz r9,32(r31)
ffc06a74: 38 00 00 0a li r0,10
ffc06a78: 81 7f 00 1c lwz r11,28(r31)
ffc06a7c: 7c 0b 49 ae stbx r0,r11,r9
ffc06a80: 48 00 00 3c b ffc06abc <iproc+0x14c>
return 1;
} else if ((c == tty->termios.c_cc[VEOL]) ||
ffc06a84: 89 3f 00 4c lbz r9,76(r31)
ffc06a88: 7f 89 f0 00 cmpw cr7,r9,r30
ffc06a8c: 41 9e 00 10 beq- cr7,ffc06a9c <iproc+0x12c> <== NEVER TAKEN
ffc06a90: 89 3f 00 51 lbz r9,81(r31)
ffc06a94: 7f 89 f0 00 cmpw cr7,r9,r30
ffc06a98: 40 be 00 34 bne+ cr7,ffc06acc <iproc+0x15c> <== ALWAYS TAKEN
(c == tty->termios.c_cc[VEOL2])) {
if (tty->termios.c_lflag & ECHO)
ffc06a9c: 70 09 00 08 andi. r9,r0,8 <== NOT EXECUTED
ffc06aa0: 41 a2 00 10 beq+ ffc06ab0 <iproc+0x140> <== NOT EXECUTED
echo (c, tty);
ffc06aa4: 7f c3 f3 78 mr r3,r30 <== NOT EXECUTED
ffc06aa8: 7f e4 fb 78 mr r4,r31 <== NOT EXECUTED
ffc06aac: 4b ff fc 2d bl ffc066d8 <echo> <== NOT EXECUTED
tty->cbuf[tty->ccount++] = c;
ffc06ab0: 81 3f 00 20 lwz r9,32(r31) <== NOT EXECUTED
ffc06ab4: 81 7f 00 1c lwz r11,28(r31) <== NOT EXECUTED
ffc06ab8: 7f cb 49 ae stbx r30,r11,r9 <== NOT EXECUTED
ffc06abc: 39 29 00 01 addi r9,r9,1
ffc06ac0: 91 3f 00 20 stw r9,32(r31)
return 1;
ffc06ac4: 38 60 00 01 li r3,1
ffc06ac8: 48 00 00 50 b ffc06b18 <iproc+0x1a8>
}
/*
* FIXME: Should do IMAXBEL handling somehow
*/
if (tty->ccount < (CBUFSIZE-1)) {
ffc06acc: 3d 20 00 00 lis r9,0
ffc06ad0: 81 29 21 b8 lwz r9,8632(r9)
if (tty->termios.c_lflag & ECHO)
echo (c, tty);
tty->cbuf[tty->ccount++] = c;
}
return 0;
ffc06ad4: 38 60 00 00 li r3,0
}
/*
* FIXME: Should do IMAXBEL handling somehow
*/
if (tty->ccount < (CBUFSIZE-1)) {
ffc06ad8: 38 09 ff ff addi r0,r9,-1
ffc06adc: 81 3f 00 20 lwz r9,32(r31)
ffc06ae0: 7f 89 00 00 cmpw cr7,r9,r0
ffc06ae4: 40 9c 00 34 bge- cr7,ffc06b18 <iproc+0x1a8> <== NEVER TAKEN
if (tty->termios.c_lflag & ECHO)
ffc06ae8: 80 1f 00 3c lwz r0,60(r31)
ffc06aec: 70 09 00 08 andi. r9,r0,8
ffc06af0: 41 a2 00 10 beq+ ffc06b00 <iproc+0x190> <== NEVER TAKEN
echo (c, tty);
ffc06af4: 7f c3 f3 78 mr r3,r30
ffc06af8: 7f e4 fb 78 mr r4,r31
ffc06afc: 4b ff fb dd bl ffc066d8 <echo>
tty->cbuf[tty->ccount++] = c;
ffc06b00: 81 3f 00 20 lwz r9,32(r31)
ffc06b04: 81 7f 00 1c lwz r11,28(r31)
ffc06b08: 7f cb 49 ae stbx r30,r11,r9
ffc06b0c: 39 29 00 01 addi r9,r9,1
ffc06b10: 91 3f 00 20 stw r9,32(r31)
}
return 0;
ffc06b14: 38 60 00 00 li r3,0
}
ffc06b18: 39 61 00 10 addi r11,r1,16
ffc06b1c: 4b ff 9a 24 b ffc00540 <_restgpr_30_x>
ffc1bc98 <killinfo>:
int killinfo(
pid_t pid,
int sig,
const union sigval *value
)
{
ffc1bc98: 94 21 ff d8 stwu r1,-40(r1)
ffc1bc9c: 7c 08 02 a6 mflr r0
ffc1bca0: bf 81 00 18 stmw r28,24(r1)
ffc1bca4: 7c 7e 1b 78 mr r30,r3
ffc1bca8: 7c 9f 23 78 mr r31,r4
ffc1bcac: 90 01 00 2c stw r0,44(r1)
ffc1bcb0: 7c bd 2b 78 mr r29,r5
POSIX_signals_Siginfo_node *psiginfo;
/*
* Only supported for the "calling process" (i.e. this node).
*/
if ( pid != getpid() )
ffc1bcb4: 4b ff fb 4d bl ffc1b800 <getpid>
ffc1bcb8: 7f 9e 18 00 cmpw cr7,r30,r3
ffc1bcbc: 41 be 00 10 beq+ cr7,ffc1bccc <killinfo+0x34>
rtems_set_errno_and_return_minus_one( ESRCH );
ffc1bcc0: 4b ff 4e f5 bl ffc10bb4 <__errno>
ffc1bcc4: 38 00 00 03 li r0,3
ffc1bcc8: 48 00 00 14 b ffc1bcdc <killinfo+0x44>
/*
* Validate the signal passed.
*/
if ( !sig )
ffc1bccc: 2f 9f 00 00 cmpwi cr7,r31,0
ffc1bcd0: 40 be 00 18 bne+ cr7,ffc1bce8 <killinfo+0x50>
rtems_set_errno_and_return_minus_one( EINVAL );
ffc1bcd4: 4b ff 4e e1 bl ffc10bb4 <__errno>
ffc1bcd8: 38 00 00 16 li r0,22
ffc1bcdc: 90 03 00 00 stw r0,0(r3)
ffc1bce0: 38 60 ff ff li r3,-1
ffc1bce4: 48 00 02 24 b ffc1bf08 <killinfo+0x270>
static inline bool is_valid_signo(
int signo
)
{
return ((signo) >= 1 && (signo) <= 32 );
ffc1bce8: 3b df ff ff addi r30,r31,-1
if ( !is_valid_signo(sig) )
ffc1bcec: 2b 9e 00 1f cmplwi cr7,r30,31
ffc1bcf0: 41 bd ff e4 bgt- cr7,ffc1bcd4 <killinfo+0x3c>
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 )
ffc1bcf4: 1c 1f 00 0c mulli r0,r31,12
ffc1bcf8: 3d 20 00 00 lis r9,0
ffc1bcfc: 39 29 31 c0 addi r9,r9,12736
ffc1bd00: 7d 29 02 14 add r9,r9,r0
ffc1bd04: 80 09 00 08 lwz r0,8(r9)
return 0;
ffc1bd08: 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 )
ffc1bd0c: 2f 80 00 01 cmpwi cr7,r0,1
ffc1bd10: 41 9e 01 f8 beq- cr7,ffc1bf08 <killinfo+0x270>
/*
* 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 ) )
ffc1bd14: 2f 9f 00 08 cmpwi cr7,r31,8
ffc1bd18: 41 9e 00 14 beq- cr7,ffc1bd2c <killinfo+0x94>
ffc1bd1c: 2f 9f 00 04 cmpwi cr7,r31,4
ffc1bd20: 41 9e 00 0c beq- cr7,ffc1bd2c <killinfo+0x94>
ffc1bd24: 2f 9f 00 0b cmpwi cr7,r31,11
ffc1bd28: 40 be 00 14 bne+ cr7,ffc1bd3c <killinfo+0xa4>
return pthread_kill( pthread_self(), sig );
ffc1bd2c: 48 00 04 0d bl ffc1c138 <pthread_self>
ffc1bd30: 7f e4 fb 78 mr r4,r31
ffc1bd34: 48 00 03 35 bl ffc1c068 <pthread_kill>
ffc1bd38: 48 00 01 d0 b ffc1bf08 <killinfo+0x270>
* Build up a siginfo structure
*/
siginfo = &siginfo_struct;
siginfo->si_signo = sig;
siginfo->si_code = SI_USER;
if ( !value ) {
ffc1bd3c: 2f 9d 00 00 cmpwi cr7,r29,0
/*
* Build up a siginfo structure
*/
siginfo = &siginfo_struct;
siginfo->si_signo = sig;
ffc1bd40: 93 e1 00 08 stw r31,8(r1)
static inline sigset_t signo_to_mask(
uint32_t sig
)
{
return 1u << (sig - 1);
ffc1bd44: 38 00 00 01 li r0,1
ffc1bd48: 7c 1e f0 30 slw r30,r0,r30
siginfo->si_code = SI_USER;
ffc1bd4c: 90 01 00 0c stw r0,12(r1)
if ( !value ) {
ffc1bd50: 40 be 00 0c bne+ cr7,ffc1bd5c <killinfo+0xc4>
siginfo->si_value.sival_int = 0;
ffc1bd54: 93 a1 00 10 stw r29,16(r1)
ffc1bd58: 48 00 00 0c b ffc1bd64 <killinfo+0xcc>
} else {
siginfo->si_value = *value;
ffc1bd5c: 80 1d 00 00 lwz r0,0(r29)
ffc1bd60: 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++;
ffc1bd64: 3d 20 00 00 lis r9,0
ffc1bd68: 81 69 28 0c lwz r11,10252(r9)
ffc1bd6c: 38 0b 00 01 addi r0,r11,1
ffc1bd70: 90 09 28 0c stw r0,10252(r9)
return _Thread_Dispatch_disable_level;
ffc1bd74: 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;
ffc1bd78: 3d 20 00 00 lis r9,0
ffc1bd7c: 80 69 31 50 lwz r3,12624(r9)
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
if ( _POSIX_signals_Is_interested( api, mask ) ) {
ffc1bd80: 81 23 01 34 lwz r9,308(r3)
ffc1bd84: 80 09 00 d0 lwz r0,208(r9)
ffc1bd88: 7f c5 00 79 andc. r5,r30,r0
ffc1bd8c: 40 82 00 fc bne- ffc1be88 <killinfo+0x1f0>
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
ffc1bd90: 3d 20 00 00 lis r9,0
ffc1bd94: 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 );
ffc1bd98: 3d 20 00 00 lis r9,0
ffc1bd9c: 38 09 33 50 addi r0,r9,13136
ffc1bda0: 48 00 00 24 b ffc1bdc4 <killinfo+0x12c>
#endif
/*
* Is this thread is actually blocked waiting for the signal?
*/
if (the_thread->Wait.option & mask)
ffc1bda4: 81 63 00 30 lwz r11,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 ];
ffc1bda8: 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)
ffc1bdac: 7f ca 58 39 and. r10,r30,r11
ffc1bdb0: 40 82 00 d8 bne- ffc1be88 <killinfo+0x1f0>
/*
* Is this thread is blocked waiting for another signal but has
* not blocked this one?
*/
if (~api->signals_blocked & mask)
ffc1bdb4: 81 29 00 d0 lwz r9,208(r9)
ffc1bdb8: 7f cb 48 79 andc. r11,r30,r9
ffc1bdbc: 40 82 00 cc bne- ffc1be88 <killinfo+0x1f0>
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 ) {
ffc1bdc0: 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 );
ffc1bdc4: 7f 83 00 00 cmpw cr7,r3,r0
ffc1bdc8: 40 9e ff dc bne+ cr7,ffc1bda4 <killinfo+0x10c>
* NOTES:
*
* + rtems internal threads do not receive signals.
*/
interested = NULL;
interested_priority = PRIORITY_MAXIMUM + 1;
ffc1bdcc: 3d 20 00 00 lis r9,0
ffc1bdd0: 89 29 27 24 lbz r9,10020(r9)
ffc1bdd4: 3d 60 00 00 lis r11,0
ffc1bdd8: 39 6b 2c 64 addi r11,r11,11364
ffc1bddc: 38 09 00 01 addi r0,r9,1
*/
#define _POSIX_signals_Is_interested( _api, _mask ) \
( ~(_api)->signals_blocked & (_mask) )
int killinfo(
ffc1bde0: 38 8b 00 08 addi r4,r11,8
*
* NOTES:
*
* + rtems internal threads do not receive signals.
*/
interested = NULL;
ffc1bde4: 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 ] )
ffc1bde8: 85 2b 00 04 lwzu r9,4(r11)
ffc1bdec: 2f 89 00 00 cmpwi cr7,r9,0
ffc1bdf0: 41 9e 00 88 beq- cr7,ffc1be78 <killinfo+0x1e0> <== NEVER TAKEN
continue;
the_info = _Objects_Information_table[ the_api ][ 1 ];
ffc1bdf4: 81 29 00 04 lwz r9,4(r9)
#endif
maximum = the_info->maximum;
object_table = the_info->local_table;
for ( index = 1 ; index <= maximum ; index++ ) {
ffc1bdf8: 39 00 00 01 li r8,1
*/
if ( !the_info )
continue;
#endif
maximum = the_info->maximum;
ffc1bdfc: a3 a9 00 10 lhz r29,16(r9)
ffc1be00: 80 e9 00 1c lwz r7,28(r9)
object_table = the_info->local_table;
for ( index = 1 ; index <= maximum ; index++ ) {
ffc1be04: 48 00 00 6c b ffc1be70 <killinfo+0x1d8>
the_thread = (Thread_Control *) object_table[ index ];
ffc1be08: 85 27 00 04 lwzu r9,4(r7)
if ( !the_thread )
ffc1be0c: 2f 89 00 00 cmpwi cr7,r9,0
ffc1be10: 41 9e 00 5c beq- cr7,ffc1be6c <killinfo+0x1d4>
/*
* If this thread is of lower priority than the interested thread,
* go on to the next thread.
*/
if ( the_thread->current_priority > interested_priority )
ffc1be14: 81 49 00 14 lwz r10,20(r9)
ffc1be18: 7f 8a 00 40 cmplw cr7,r10,r0
ffc1be1c: 41 9d 00 50 bgt- cr7,ffc1be6c <killinfo+0x1d4>
#if defined(RTEMS_DEBUG)
if ( !api )
continue;
#endif
if ( !_POSIX_signals_Is_interested( api, mask ) )
ffc1be20: 80 c9 01 34 lwz r6,308(r9)
ffc1be24: 80 c6 00 d0 lwz r6,208(r6)
ffc1be28: 7f dc 30 79 andc. r28,r30,r6
ffc1be2c: 41 82 00 40 beq- ffc1be6c <killinfo+0x1d4>
*
* 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 ) {
ffc1be30: 41 9c 00 34 blt- cr7,ffc1be64 <killinfo+0x1cc>
* and blocking interruptibutable by signal.
*
* If the interested thread is ready, don't think about changing.
*/
if ( interested && !_States_Is_ready( interested->current_state ) ) {
ffc1be34: 2f 83 00 00 cmpwi cr7,r3,0
ffc1be38: 41 9e 00 34 beq- cr7,ffc1be6c <killinfo+0x1d4> <== NEVER TAKEN
ffc1be3c: 80 a3 00 10 lwz r5,16(r3)
ffc1be40: 2f 85 00 00 cmpwi cr7,r5,0
ffc1be44: 41 9e 00 28 beq- cr7,ffc1be6c <killinfo+0x1d4> <== NEVER TAKEN
/* preferred ready over blocked */
DEBUG_STEP("5");
if ( _States_Is_ready( the_thread->current_state ) ) {
ffc1be48: 80 c9 00 10 lwz r6,16(r9)
ffc1be4c: 2f 86 00 00 cmpwi cr7,r6,0
ffc1be50: 41 9e 00 14 beq- cr7,ffc1be64 <killinfo+0x1cc>
continue;
}
DEBUG_STEP("6");
/* prefer blocked/interruptible over blocked/not interruptible */
if ( !_States_Is_interruptible_by_signal(interested->current_state) ) {
ffc1be54: 74 bc 10 00 andis. r28,r5,4096
ffc1be58: 40 82 00 14 bne- ffc1be6c <killinfo+0x1d4>
DEBUG_STEP("7");
if ( _States_Is_interruptible_by_signal(the_thread->current_state) ) {
ffc1be5c: 74 c5 10 00 andis. r5,r6,4096
ffc1be60: 41 82 00 0c beq- ffc1be6c <killinfo+0x1d4>
*/
if ( interested && !_States_Is_ready( interested->current_state ) ) {
/* preferred ready over blocked */
DEBUG_STEP("5");
if ( _States_Is_ready( the_thread->current_state ) ) {
ffc1be64: 7d 40 53 78 mr r0,r10
ffc1be68: 7d 23 4b 78 mr r3,r9
#endif
maximum = the_info->maximum;
object_table = the_info->local_table;
for ( index = 1 ; index <= maximum ; index++ ) {
ffc1be6c: 39 08 00 01 addi r8,r8,1
ffc1be70: 7f 88 e8 40 cmplw cr7,r8,r29
ffc1be74: 40 9d ff 94 ble+ cr7,ffc1be08 <killinfo+0x170>
* + 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++) {
ffc1be78: 7f 8b 20 00 cmpw cr7,r11,r4
ffc1be7c: 40 be ff 6c bne- cr7,ffc1bde8 <killinfo+0x150>
}
}
}
}
if ( interested ) {
ffc1be80: 2f 83 00 00 cmpwi cr7,r3,0
ffc1be84: 41 9e 00 18 beq- cr7,ffc1be9c <killinfo+0x204>
/*
* 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 ) ) {
ffc1be88: 7f e4 fb 78 mr r4,r31
ffc1be8c: 38 a1 00 08 addi r5,r1,8
ffc1be90: 48 00 00 a9 bl ffc1bf38 <_POSIX_signals_Unblock_thread>
ffc1be94: 2f 83 00 00 cmpwi cr7,r3,0
ffc1be98: 40 9e 00 68 bne- cr7,ffc1bf00 <killinfo+0x268>
/*
* 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 );
ffc1be9c: 7f c3 f3 78 mr r3,r30
ffc1bea0: 48 00 00 71 bl ffc1bf10 <_POSIX_signals_Set_process_signals>
if ( _POSIX_signals_Vectors[ sig ].sa_flags == SA_SIGINFO ) {
ffc1bea4: 1f ff 00 0c mulli r31,r31,12
ffc1bea8: 3d 20 00 00 lis r9,0
ffc1beac: 39 29 31 c0 addi r9,r9,12736
ffc1beb0: 7c 09 f8 2e lwzx r0,r9,r31
ffc1beb4: 2f 80 00 02 cmpwi cr7,r0,2
ffc1beb8: 40 be 00 48 bne+ cr7,ffc1bf00 <killinfo+0x268>
psiginfo = (POSIX_signals_Siginfo_node *)
ffc1bebc: 3c 60 00 00 lis r3,0
ffc1bec0: 38 63 33 40 addi r3,r3,13120
ffc1bec4: 4b fe cd dd bl ffc08ca0 <_Chain_Get>
_Chain_Get( &_POSIX_signals_Inactive_siginfo );
if ( !psiginfo ) {
ffc1bec8: 7c 64 1b 79 mr. r4,r3
ffc1becc: 40 a2 00 14 bne+ ffc1bee0 <killinfo+0x248>
_Thread_Enable_dispatch();
ffc1bed0: 4b fe eb e1 bl ffc0aab0 <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one( EAGAIN );
ffc1bed4: 4b ff 4c e1 bl ffc10bb4 <__errno>
ffc1bed8: 38 00 00 0b li r0,11
ffc1bedc: 4b ff fe 00 b ffc1bcdc <killinfo+0x44>
}
psiginfo->Info = *siginfo;
ffc1bee0: 39 24 00 08 addi r9,r4,8
ffc1bee4: 39 61 00 08 addi r11,r1,8
_Chain_Append( &_POSIX_signals_Siginfo[ sig ], &psiginfo->Node );
ffc1bee8: 3c 60 00 00 lis r3,0
if ( !psiginfo ) {
_Thread_Enable_dispatch();
rtems_set_errno_and_return_minus_one( EAGAIN );
}
psiginfo->Info = *siginfo;
ffc1beec: 7c ab 64 aa lswi r5,r11,12
ffc1bef0: 7c a9 65 aa stswi r5,r9,12
_Chain_Append( &_POSIX_signals_Siginfo[ sig ], &psiginfo->Node );
ffc1bef4: 38 63 33 b4 addi r3,r3,13236
ffc1bef8: 7c 63 fa 14 add r3,r3,r31
ffc1befc: 4b fe cd 4d bl ffc08c48 <_Chain_Append>
}
DEBUG_STEP("\n");
_Thread_Enable_dispatch();
ffc1bf00: 4b fe eb b1 bl ffc0aab0 <_Thread_Enable_dispatch>
return 0;
ffc1bf04: 38 60 00 00 li r3,0
}
ffc1bf08: 39 61 00 28 addi r11,r1,40
ffc1bf0c: 4b fe 46 2c b ffc00538 <_restgpr_28_x>
ffc05290 <libc_wrapup>:
extern void _wrapup_reent(struct _reent *);
extern void _reclaim_reent(struct _reent *);
void libc_wrapup(void)
{
ffc05290: 94 21 ff f0 stwu r1,-16(r1)
ffc05294: 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()))
ffc05298: 3d 20 00 00 lis r9,0
extern void _wrapup_reent(struct _reent *);
extern void _reclaim_reent(struct _reent *);
void libc_wrapup(void)
{
ffc0529c: 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()))
ffc052a0: 80 09 28 48 lwz r0,10312(r9)
extern void _wrapup_reent(struct _reent *);
extern void _reclaim_reent(struct _reent *);
void libc_wrapup(void)
{
ffc052a4: bf c1 00 08 stmw 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()))
ffc052a8: 2f 80 00 03 cmpwi cr7,r0,3
ffc052ac: 40 be 00 4c bne+ cr7,ffc052f8 <libc_wrapup+0x68> <== NEVER TAKEN
/*
* This was already done if the user called exit() directly .
_wrapup_reent(0);
*/
if (_REENT != _global_impure_ptr) {
ffc052b0: 3d 20 00 00 lis r9,0
ffc052b4: 3f e0 00 00 lis r31,0
ffc052b8: 83 c9 27 88 lwz r30,10120(r9)
ffc052bc: 80 1f 27 8c lwz r0,10124(r31)
ffc052c0: 7f 80 f0 00 cmpw cr7,r0,r30
ffc052c4: 41 9e 00 10 beq- cr7,ffc052d4 <libc_wrapup+0x44>
_wrapup_reent(_global_impure_ptr);
ffc052c8: 7f c3 f3 78 mr r3,r30
ffc052cc: 48 00 c9 fd bl ffc11cc8 <_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;
ffc052d0: 93 df 27 8c stw r30,10124(r31)
*
* Should this be changed to do *all* file streams?
* _fwalk (_REENT, fclose);
*/
fclose (stdin);
ffc052d4: 81 3f 27 8c lwz r9,10124(r31)
ffc052d8: 80 69 00 04 lwz r3,4(r9)
ffc052dc: 48 00 ba 65 bl ffc10d40 <fclose>
fclose (stdout);
ffc052e0: 81 3f 27 8c lwz r9,10124(r31)
ffc052e4: 80 69 00 08 lwz r3,8(r9)
ffc052e8: 48 00 ba 59 bl ffc10d40 <fclose>
fclose (stderr);
ffc052ec: 81 3f 27 8c lwz r9,10124(r31)
ffc052f0: 80 69 00 0c lwz r3,12(r9)
ffc052f4: 48 00 ba 4d bl ffc10d40 <fclose>
}
ffc052f8: 39 61 00 10 addi r11,r1,16
ffc052fc: 4b ff b2 44 b ffc00540 <_restgpr_30_x>
ffc04d04 <malloc>:
#include "malloc_p.h"
void *malloc(
size_t size
)
{
ffc04d04: 94 21 ff f0 stwu r1,-16(r1)
ffc04d08: 7c 08 02 a6 mflr r0
void *return_this;
MSBUMP(malloc_calls, 1);
ffc04d0c: 3d 20 00 00 lis r9,0
#include "malloc_p.h"
void *malloc(
size_t size
)
{
ffc04d10: 90 01 00 14 stw r0,20(r1)
void *return_this;
MSBUMP(malloc_calls, 1);
ffc04d14: 39 29 2b 60 addi r9,r9,11104
ffc04d18: 81 69 00 04 lwz r11,4(r9)
#include "malloc_p.h"
void *malloc(
size_t size
)
{
ffc04d1c: bf c1 00 08 stmw r30,8(r1)
ffc04d20: 7c 7f 1b 78 mr r31,r3
void *return_this;
MSBUMP(malloc_calls, 1);
ffc04d24: 38 0b 00 01 addi r0,r11,1
ffc04d28: 90 09 00 04 stw r0,4(r9)
/*
* Validate the parameters
*/
if ( !size )
return (void *) 0;
ffc04d2c: 3b c0 00 00 li r30,0
MSBUMP(malloc_calls, 1);
/*
* If some free's have been deferred, then do them now.
*/
malloc_deferred_frees_process();
ffc04d30: 4b ff fe 75 bl ffc04ba4 <malloc_deferred_frees_process>
/*
* Validate the parameters
*/
if ( !size )
ffc04d34: 2f 9f 00 00 cmpwi cr7,r31,0
ffc04d38: 41 9e 00 bc beq- cr7,ffc04df4 <malloc+0xf0>
return (void *) 0;
/*
* Do not attempt to allocate memory if not in correct system state.
*/
if ( _System_state_Is_up(_System_state_Get()) &&
ffc04d3c: 3d 20 00 00 lis r9,0
ffc04d40: 80 09 28 48 lwz r0,10312(r9)
ffc04d44: 2f 80 00 03 cmpwi cr7,r0,3
ffc04d48: 40 be 00 10 bne+ cr7,ffc04d58 <malloc+0x54>
!malloc_is_system_state_OK() )
ffc04d4c: 4b ff fe 11 bl ffc04b5c <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()) &&
ffc04d50: 2f 83 00 00 cmpwi cr7,r3,0
ffc04d54: 41 9e 00 a0 beq- cr7,ffc04df4 <malloc+0xf0> <== NEVER TAKEN
RTEMS_INLINE_ROUTINE void *_Protected_heap_Allocate(
Heap_Control *heap,
uintptr_t size
)
{
return _Protected_heap_Allocate_aligned_with_boundary( heap, size, 0, 0 );
ffc04d58: 3d 20 00 00 lis r9,0
ffc04d5c: 80 69 27 2c lwz r3,10028(r9)
ffc04d60: 7f e4 fb 78 mr r4,r31
ffc04d64: 38 a0 00 00 li r5,0
ffc04d68: 38 c0 00 00 li r6,0
ffc04d6c: 48 00 51 89 bl ffc09ef4 <_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 ) {
ffc04d70: 7c 7e 1b 79 mr. r30,r3
ffc04d74: 40 a2 00 40 bne+ ffc04db4 <malloc+0xb0>
if (rtems_malloc_sbrk_helpers)
ffc04d78: 3d 20 00 00 lis r9,0
ffc04d7c: 81 29 27 a8 lwz r9,10152(r9)
ffc04d80: 2f 89 00 00 cmpwi cr7,r9,0
ffc04d84: 41 9e 00 1c beq- cr7,ffc04da0 <malloc+0x9c>
return_this = (*rtems_malloc_sbrk_helpers->extend)( size );
ffc04d88: 80 09 00 04 lwz r0,4(r9)
ffc04d8c: 7f e3 fb 78 mr r3,r31
ffc04d90: 7c 09 03 a6 mtctr r0
ffc04d94: 4e 80 04 21 bctrl
if ( !return_this ) {
ffc04d98: 7c 7e 1b 79 mr. r30,r3
ffc04d9c: 40 a2 00 18 bne+ ffc04db4 <malloc+0xb0> <== NEVER TAKEN
errno = ENOMEM;
ffc04da0: 48 00 be 15 bl ffc10bb4 <__errno>
ffc04da4: 38 00 00 0c li r0,12
ffc04da8: 90 03 00 00 stw r0,0(r3)
return (void *) 0;
ffc04dac: 3b c0 00 00 li r30,0
ffc04db0: 48 00 00 44 b ffc04df4 <malloc+0xf0>
}
/*
* If the user wants us to dirty the allocated memory, then do it.
*/
if ( rtems_malloc_dirty_helper )
ffc04db4: 3d 20 00 00 lis r9,0
ffc04db8: 80 09 27 a4 lwz r0,10148(r9)
ffc04dbc: 2f 80 00 00 cmpwi cr7,r0,0
ffc04dc0: 41 9e 00 14 beq- cr7,ffc04dd4 <malloc+0xd0>
(*rtems_malloc_dirty_helper)( return_this, size );
ffc04dc4: 7f c3 f3 78 mr r3,r30
ffc04dc8: 7c 09 03 a6 mtctr r0
ffc04dcc: 7f e4 fb 78 mr r4,r31
ffc04dd0: 4e 80 04 21 bctrl
/*
* If configured, update the statistics
*/
if ( rtems_malloc_statistics_helpers )
ffc04dd4: 3d 20 00 00 lis r9,0
ffc04dd8: 81 29 27 ac lwz r9,10156(r9)
ffc04ddc: 2f 89 00 00 cmpwi cr7,r9,0
ffc04de0: 41 9e 00 14 beq- cr7,ffc04df4 <malloc+0xf0>
(*rtems_malloc_statistics_helpers->at_malloc)(return_this);
ffc04de4: 80 09 00 04 lwz r0,4(r9)
ffc04de8: 7f c3 f3 78 mr r3,r30
ffc04dec: 7c 09 03 a6 mtctr r0
ffc04df0: 4e 80 04 21 bctrl
return return_this;
}
ffc04df4: 39 61 00 10 addi r11,r1,16
ffc04df8: 7f c3 f3 78 mr r3,r30
ffc04dfc: 4b ff b7 44 b ffc00540 <_restgpr_30_x>
ffc04aac <malloc_sbrk_extend_and_allocate>:
}
void *malloc_sbrk_extend_and_allocate(
size_t size
)
{
ffc04aac: 94 21 ff e8 stwu r1,-24(r1)
ffc04ab0: 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;
ffc04ab4: 3d 20 00 00 lis r9,0
}
void *malloc_sbrk_extend_and_allocate(
size_t size
)
{
ffc04ab8: 90 01 00 1c stw r0,28(r1)
* 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;
ffc04abc: 80 09 27 e0 lwz r0,10208(r9)
}
void *malloc_sbrk_extend_and_allocate(
size_t size
)
{
ffc04ac0: bf 81 00 08 stmw r28,8(r1)
ffc04ac4: 7c 7d 1b 78 mr r29,r3
* in "page" amounts.
*/
sbrk_amount = RTEMS_Malloc_Sbrk_amount;
if ( sbrk_amount == 0 )
ffc04ac8: 2f 80 00 00 cmpwi cr7,r0,0
return (void *) 0;
ffc04acc: 3b c0 00 00 li r30,0
* in "page" amounts.
*/
sbrk_amount = RTEMS_Malloc_Sbrk_amount;
if ( sbrk_amount == 0 )
ffc04ad0: 41 9e 00 7c beq- cr7,ffc04b4c <malloc_sbrk_extend_and_allocate+0xa0><== NEVER TAKEN
return (void *) 0;
the_size = ((size + sbrk_amount) / sbrk_amount * sbrk_amount);
ffc04ad4: 7f e3 02 14 add r31,r3,r0
ffc04ad8: 7f ff 03 96 divwu r31,r31,r0
ffc04adc: 7f ff 01 d6 mullw r31,r31,r0
starting_address = (void *) sbrk(the_size);
ffc04ae0: 7f e3 fb 78 mr r3,r31
ffc04ae4: 4b ff b8 dd bl ffc003c0 <sbrk>
if ( starting_address == (void*) -1 )
ffc04ae8: 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);
ffc04aec: 7c 64 1b 78 mr r4,r3
if ( starting_address == (void*) -1 )
ffc04af0: 41 9e 00 5c beq- cr7,ffc04b4c <malloc_sbrk_extend_and_allocate+0xa0>
return (void *) 0;
if ( !_Protected_heap_Extend(
ffc04af4: 3f 80 00 00 lis r28,0
ffc04af8: 80 7c 27 0c lwz r3,9996(r28)
ffc04afc: 7f e5 fb 78 mr r5,r31
ffc04b00: 48 00 51 29 bl ffc09c28 <_Protected_heap_Extend>
ffc04b04: 2f 83 00 00 cmpwi cr7,r3,0
ffc04b08: 40 be 00 1c bne+ cr7,ffc04b24 <malloc_sbrk_extend_and_allocate+0x78>
RTEMS_Malloc_Heap, starting_address, the_size) ) {
sbrk(-the_size);
ffc04b0c: 7c 7f 00 d0 neg r3,r31
ffc04b10: 4b ff b8 b1 bl ffc003c0 <sbrk>
errno = ENOMEM;
ffc04b14: 48 00 bf f9 bl ffc10b0c <__errno>
ffc04b18: 38 00 00 0c li r0,12
ffc04b1c: 90 03 00 00 stw r0,0(r3)
return (void *) 0;
ffc04b20: 48 00 00 2c b ffc04b4c <malloc_sbrk_extend_and_allocate+0xa0>
}
MSBUMP(space_available, the_size);
ffc04b24: 3d 20 00 00 lis r9,0
ffc04b28: 80 7c 27 0c lwz r3,9996(r28)
ffc04b2c: 80 09 2c 88 lwz r0,11400(r9)
ffc04b30: 7f a4 eb 78 mr r4,r29
ffc04b34: 38 a0 00 00 li r5,0
ffc04b38: 7f ff 02 14 add r31,r31,r0
ffc04b3c: 38 c0 00 00 li r6,0
ffc04b40: 93 e9 2c 88 stw r31,11400(r9)
ffc04b44: 48 00 50 8d bl ffc09bd0 <_Protected_heap_Allocate_aligned_with_boundary>
ffc04b48: 7c 7e 1b 78 mr r30,r3
return_this = _Protected_heap_Allocate( RTEMS_Malloc_Heap, size );
return return_this;
}
ffc04b4c: 39 61 00 18 addi r11,r1,24
ffc04b50: 7f c3 f3 78 mr r3,r30
ffc04b54: 4b ff b9 9c b ffc004f0 <_restgpr_28_x>
ffc04b58 <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) {
ffc04b58: 2c 03 00 00 cmpwi r3,0
void *malloc_sbrk_initialize(
void *starting_address,
size_t length
)
{
ffc04b5c: 94 21 ff f8 stwu r1,-8(r1)
ffc04b60: 7c 08 02 a6 mflr r0
uintptr_t old_address;
uintptr_t uaddress;
RTEMS_Malloc_Sbrk_amount = length;
ffc04b64: 3d 20 00 00 lis r9,0
ffc04b68: 90 89 27 e0 stw r4,10208(r9)
void *malloc_sbrk_initialize(
void *starting_address,
size_t length
)
{
ffc04b6c: 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) {
ffc04b70: 40 a2 00 2c bne+ ffc04b9c <malloc_sbrk_initialize+0x44>
uaddress = (uintptr_t)sbrk(length);
ffc04b74: 7c 83 23 78 mr r3,r4
ffc04b78: 4b ff b8 49 bl ffc003c0 <sbrk>
if (uaddress == (uintptr_t) -1) {
ffc04b7c: 2f 83 ff ff cmpwi cr7,r3,-1
ffc04b80: 40 be 00 0c bne+ cr7,ffc04b8c <malloc_sbrk_initialize+0x34><== NEVER TAKEN
rtems_fatal_error_occurred( RTEMS_NO_MEMORY );
ffc04b84: 38 60 00 1a li r3,26
ffc04b88: 48 00 39 d1 bl ffc08558 <rtems_fatal_error_occurred>
/* DOES NOT RETURN!!! */
}
if (uaddress & (CPU_HEAP_ALIGNMENT-1)) {
ffc04b8c: 70 60 00 07 andi. r0,r3,7 <== NOT EXECUTED
ffc04b90: 41 82 00 0c beq- ffc04b9c <malloc_sbrk_initialize+0x44> <== NOT EXECUTED
old_address = uaddress;
uaddress = (uaddress + CPU_HEAP_ALIGNMENT) & ~(CPU_HEAP_ALIGNMENT-1);
ffc04b94: 38 63 00 08 addi r3,r3,8 <== NOT EXECUTED
ffc04b98: 54 63 00 38 rlwinm r3,r3,0,0,28 <== NOT EXECUTED
}
starting_address = (void *)uaddress;
}
return starting_address;
}
ffc04b9c: 80 01 00 0c lwz r0,12(r1)
ffc04ba0: 38 21 00 08 addi r1,r1,8
ffc04ba4: 7c 08 03 a6 mtlr r0
ffc04ba8: 4e 80 00 20 blr
ffc0f968 <memfile_ftruncate>:
*/
int memfile_ftruncate(
rtems_libio_t *iop,
rtems_off64_t length
)
{
ffc0f968: 7c 08 02 a6 mflr r0
ffc0f96c: 7c 2b 0b 78 mr r11,r1
ffc0f970: 94 21 ff e0 stwu r1,-32(r1)
ffc0f974: 90 01 00 24 stw r0,36(r1)
ffc0f978: 48 00 b9 d5 bl ffc1b34c <_savegpr_31>
IMFS_jnode_t *the_jnode;
the_jnode = iop->pathinfo.node_access;
ffc0f97c: 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 )
ffc0f980: 80 1f 00 50 lwz r0,80(r31)
ffc0f984: 7f 80 28 00 cmpw cr7,r0,r5
ffc0f988: 41 9c 00 14 blt- cr7,ffc0f99c <memfile_ftruncate+0x34> <== NEVER TAKEN
ffc0f98c: 40 be 00 1c bne+ cr7,ffc0f9a8 <memfile_ftruncate+0x40>
ffc0f990: 80 1f 00 54 lwz r0,84(r31)
ffc0f994: 7f 80 30 40 cmplw cr7,r0,r6
ffc0f998: 40 bc 00 10 bge+ cr7,ffc0f9a8 <memfile_ftruncate+0x40>
return IMFS_memfile_extend( the_jnode, length );
ffc0f99c: 7f e3 fb 78 mr r3,r31
ffc0f9a0: 4b ff fb d5 bl ffc0f574 <IMFS_memfile_extend>
ffc0f9a4: 48 00 00 2c b ffc0f9d0 <memfile_ftruncate+0x68>
/*
* 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;
ffc0f9a8: 90 bf 00 50 stw r5,80(r31)
iop->size = the_jnode->info.file.size;
IMFS_update_atime( the_jnode );
ffc0f9ac: 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;
ffc0f9b0: 90 df 00 54 stw r6,84(r31)
iop->size = the_jnode->info.file.size;
ffc0f9b4: 90 a3 00 08 stw r5,8(r3)
ffc0f9b8: 90 c3 00 0c stw r6,12(r3)
IMFS_update_atime( the_jnode );
ffc0f9bc: 38 61 00 08 addi r3,r1,8
ffc0f9c0: 4b ff 50 51 bl ffc04a10 <gettimeofday>
ffc0f9c4: 80 01 00 08 lwz r0,8(r1)
return 0;
ffc0f9c8: 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 );
ffc0f9cc: 90 1f 00 40 stw r0,64(r31)
return 0;
}
ffc0f9d0: 39 61 00 20 addi r11,r1,32
ffc0f9d4: 4b ff 0b 70 b ffc00544 <_restgpr_31_x>
ffc0f9d8 <memfile_lseek>:
rtems_off64_t memfile_lseek(
rtems_libio_t *iop,
rtems_off64_t offset,
int whence
)
{
ffc0f9d8: 94 21 ff f0 stwu r1,-16(r1)
ffc0f9dc: 7c 08 02 a6 mflr r0
ffc0f9e0: 90 01 00 14 stw r0,20(r1)
ffc0f9e4: bf c1 00 08 stmw r30,8(r1)
ffc0f9e8: 7c 7f 1b 78 mr r31,r3
IMFS_jnode_t *the_jnode;
the_jnode = iop->pathinfo.node_access;
ffc0f9ec: 83 c3 00 1c lwz r30,28(r3)
if (the_jnode->type == IMFS_LINEAR_FILE) {
ffc0f9f0: 80 1e 00 4c lwz r0,76(r30)
ffc0f9f4: 2f 80 00 06 cmpwi cr7,r0,6
ffc0f9f8: 40 9e 00 34 bne- cr7,ffc0fa2c <memfile_lseek+0x54>
if (iop->offset > the_jnode->info.linearfile.size)
ffc0f9fc: 81 3e 00 50 lwz r9,80(r30)
ffc0fa00: 81 63 00 10 lwz r11,16(r3)
ffc0fa04: 80 1e 00 54 lwz r0,84(r30)
ffc0fa08: 7f 8b 48 00 cmpw cr7,r11,r9
ffc0fa0c: 41 9d 00 14 bgt- cr7,ffc0fa20 <memfile_lseek+0x48> <== NEVER TAKEN
ffc0fa10: 40 9e 00 5c bne- cr7,ffc0fa6c <memfile_lseek+0x94> <== NEVER TAKEN
ffc0fa14: 81 63 00 14 lwz r11,20(r3)
ffc0fa18: 7f 8b 00 40 cmplw cr7,r11,r0
ffc0fa1c: 40 9d 00 50 ble- cr7,ffc0fa6c <memfile_lseek+0x94> <== ALWAYS TAKEN
iop->offset = the_jnode->info.linearfile.size;
ffc0fa20: 91 3f 00 10 stw r9,16(r31) <== NOT EXECUTED
ffc0fa24: 90 1f 00 14 stw r0,20(r31) <== NOT EXECUTED
ffc0fa28: 48 00 00 44 b ffc0fa6c <memfile_lseek+0x94> <== NOT EXECUTED
}
else { /* Must be a block file (IMFS_MEMORY_FILE). */
if (IMFS_memfile_extend( the_jnode, iop->offset ))
ffc0fa2c: 80 bf 00 10 lwz r5,16(r31)
ffc0fa30: 7f c3 f3 78 mr r3,r30
ffc0fa34: 80 df 00 14 lwz r6,20(r31)
ffc0fa38: 4b ff fb 3d bl ffc0f574 <IMFS_memfile_extend>
ffc0fa3c: 2f 83 00 00 cmpwi cr7,r3,0
ffc0fa40: 41 be 00 1c beq+ cr7,ffc0fa5c <memfile_lseek+0x84>
rtems_set_errno_and_return_minus_one( ENOSPC );
ffc0fa44: 48 00 11 71 bl ffc10bb4 <__errno>
ffc0fa48: 38 00 00 1c li r0,28
ffc0fa4c: 90 03 00 00 stw r0,0(r3)
ffc0fa50: 39 40 ff ff li r10,-1
ffc0fa54: 39 60 ff ff li r11,-1
ffc0fa58: 48 00 00 1c b ffc0fa74 <memfile_lseek+0x9c>
iop->size = the_jnode->info.file.size;
ffc0fa5c: 81 5e 00 50 lwz r10,80(r30)
ffc0fa60: 81 7e 00 54 lwz r11,84(r30)
ffc0fa64: 91 5f 00 08 stw r10,8(r31)
ffc0fa68: 91 7f 00 0c stw r11,12(r31)
}
return iop->offset;
ffc0fa6c: 81 5f 00 10 lwz r10,16(r31)
ffc0fa70: 81 7f 00 14 lwz r11,20(r31)
}
ffc0fa74: 7d 64 5b 78 mr r4,r11
ffc0fa78: 39 61 00 10 addi r11,r1,16
ffc0fa7c: 7d 43 53 78 mr r3,r10
ffc0fa80: 4b ff 0a c0 b ffc00540 <_restgpr_30_x>
ffc0f8a8 <memfile_open>:
rtems_libio_t *iop,
const char *pathname,
uint32_t flag,
uint32_t mode
)
{
ffc0f8a8: 94 21 ff f0 stwu r1,-16(r1)
ffc0f8ac: 7c 08 02 a6 mflr r0
ffc0f8b0: 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))
ffc0f8b4: 80 03 00 18 lwz r0,24(r3)
rtems_libio_t *iop,
const char *pathname,
uint32_t flag,
uint32_t mode
)
{
ffc0f8b8: bf c1 00 08 stmw r30,8(r1)
ffc0f8bc: 7c 7e 1b 78 mr r30,r3
the_jnode = iop->pathinfo.node_access;
/*
* Perform 'copy on write' for linear files
*/
if ((iop->flags & (LIBIO_FLAGS_WRITE | LIBIO_FLAGS_APPEND))
ffc0f8c0: 70 09 02 04 andi. r9,r0,516
uint32_t mode
)
{
IMFS_jnode_t *the_jnode;
the_jnode = iop->pathinfo.node_access;
ffc0f8c4: 83 e3 00 1c lwz r31,28(r3)
/*
* Perform 'copy on write' for linear files
*/
if ((iop->flags & (LIBIO_FLAGS_WRITE | LIBIO_FLAGS_APPEND))
ffc0f8c8: 41 82 00 64 beq- ffc0f92c <memfile_open+0x84>
&& (the_jnode->type == IMFS_LINEAR_FILE)) {
ffc0f8cc: 80 1f 00 4c lwz r0,76(r31)
ffc0f8d0: 2f 80 00 06 cmpwi cr7,r0,6
ffc0f8d4: 40 be 00 58 bne+ cr7,ffc0f92c <memfile_open+0x84> <== ALWAYS TAKEN
uint32_t count = the_jnode->info.linearfile.size;
ffc0f8d8: 81 1f 00 54 lwz r8,84(r31) <== NOT EXECUTED
const unsigned char *buffer = the_jnode->info.linearfile.direct;
the_jnode->type = IMFS_MEMORY_FILE;
ffc0f8dc: 38 00 00 05 li r0,5 <== NOT EXECUTED
ffc0f8e0: 90 1f 00 4c stw r0,76(r31) <== NOT EXECUTED
the_jnode->info.file.size = 0;
ffc0f8e4: 39 40 00 00 li r10,0 <== NOT EXECUTED
the_jnode->info.file.indirect = 0;
the_jnode->info.file.doubly_indirect = 0;
the_jnode->info.file.triply_indirect = 0;
if ((count != 0)
ffc0f8e8: 2f 88 00 00 cmpwi cr7,r8,0 <== NOT EXECUTED
uint32_t count = the_jnode->info.linearfile.size;
const unsigned char *buffer = the_jnode->info.linearfile.direct;
the_jnode->type = IMFS_MEMORY_FILE;
the_jnode->info.file.size = 0;
the_jnode->info.file.indirect = 0;
ffc0f8ec: 38 00 00 00 li r0,0 <== 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;
ffc0f8f0: 80 ff 00 58 lwz r7,88(r31) <== NOT EXECUTED
the_jnode->type = IMFS_MEMORY_FILE;
the_jnode->info.file.size = 0;
ffc0f8f4: 39 60 00 00 li r11,0 <== NOT EXECUTED
ffc0f8f8: 91 5f 00 50 stw r10,80(r31) <== NOT EXECUTED
ffc0f8fc: 91 7f 00 54 stw r11,84(r31) <== NOT EXECUTED
the_jnode->info.file.indirect = 0;
ffc0f900: 90 1f 00 58 stw r0,88(r31) <== NOT EXECUTED
the_jnode->info.file.doubly_indirect = 0;
ffc0f904: 90 1f 00 5c stw r0,92(r31) <== NOT EXECUTED
the_jnode->info.file.triply_indirect = 0;
ffc0f908: 90 1f 00 60 stw r0,96(r31) <== NOT EXECUTED
if ((count != 0)
ffc0f90c: 41 be 00 20 beq+ cr7,ffc0f92c <memfile_open+0x84> <== NOT EXECUTED
&& (IMFS_memfile_write(the_jnode, 0, buffer, count) == -1))
ffc0f910: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc0f914: 38 a0 00 00 li r5,0 <== NOT EXECUTED
ffc0f918: 38 c0 00 00 li r6,0 <== NOT EXECUTED
ffc0f91c: 4b ff fd a1 bl ffc0f6bc <IMFS_memfile_write> <== NOT EXECUTED
return -1;
ffc0f920: 38 00 ff ff li r0,-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))
ffc0f924: 2f 83 ff ff cmpwi cr7,r3,-1 <== NOT EXECUTED
ffc0f928: 41 9e 00 34 beq- cr7,ffc0f95c <memfile_open+0xb4> <== NOT EXECUTED
return -1;
}
if (iop->flags & LIBIO_FLAGS_APPEND)
ffc0f92c: 80 1e 00 18 lwz r0,24(r30)
ffc0f930: 70 09 02 00 andi. r9,r0,512
ffc0f934: 41 82 00 14 beq- ffc0f948 <memfile_open+0xa0>
iop->offset = the_jnode->info.file.size;
ffc0f938: 81 5f 00 50 lwz r10,80(r31)
ffc0f93c: 81 7f 00 54 lwz r11,84(r31)
ffc0f940: 91 5e 00 10 stw r10,16(r30)
ffc0f944: 91 7e 00 14 stw r11,20(r30)
iop->size = the_jnode->info.file.size;
ffc0f948: 81 5f 00 50 lwz r10,80(r31)
return 0;
ffc0f94c: 38 00 00 00 li r0,0
return -1;
}
if (iop->flags & LIBIO_FLAGS_APPEND)
iop->offset = the_jnode->info.file.size;
iop->size = the_jnode->info.file.size;
ffc0f950: 81 7f 00 54 lwz r11,84(r31)
ffc0f954: 91 5e 00 08 stw r10,8(r30)
ffc0f958: 91 7e 00 0c stw r11,12(r30)
return 0;
}
ffc0f95c: 39 61 00 10 addi r11,r1,16
ffc0f960: 7c 03 03 78 mr r3,r0
ffc0f964: 4b ff 0b dc b ffc00540 <_restgpr_30_x>
ffc04fcc <mount>:
/*
* Are the file system options valid?
*/
if ( options != RTEMS_FILESYSTEM_READ_ONLY &&
ffc04fcc: 2b 86 00 01 cmplwi cr7,r6,1
const char *target,
const char *filesystemtype,
rtems_filesystem_options_t options,
const void *data
)
{
ffc04fd0: 94 21 ff a0 stwu r1,-96(r1)
ffc04fd4: 7c 08 02 a6 mflr r0
ffc04fd8: be 41 00 28 stmw r18,40(r1)
ffc04fdc: 7c 7c 1b 78 mr r28,r3
ffc04fe0: 7c 9f 23 78 mr r31,r4
ffc04fe4: 90 01 00 64 stw r0,100(r1)
ffc04fe8: 7c b9 2b 78 mr r25,r5
ffc04fec: 7c d8 33 78 mr r24,r6
ffc04ff0: 7c fa 3b 78 mr r26,r7
/*
* Are the file system options valid?
*/
if ( options != RTEMS_FILESYSTEM_READ_ONLY &&
ffc04ff4: 41 9d 00 14 bgt- cr7,ffc05008 <mount+0x3c>
rtems_set_errno_and_return_minus_one( EINVAL );
/*
* Get mount handler
*/
mount_h = rtems_filesystem_get_mount_handler( filesystemtype );
ffc04ff8: 7c a3 2b 78 mr r3,r5
ffc04ffc: 48 00 85 1d bl ffc0d518 <rtems_filesystem_get_mount_handler>
if ( !mount_h )
ffc05000: 7c 7b 1b 79 mr. r27,r3
ffc05004: 40 a2 00 10 bne+ ffc05014 <mount+0x48>
rtems_set_errno_and_return_minus_one( EINVAL );
ffc05008: 48 00 bb ad bl ffc10bb4 <__errno>
ffc0500c: 38 00 00 16 li r0,22
ffc05010: 48 00 00 f0 b ffc05100 <mount+0x134>
{
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;
ffc05014: 7f fd 00 34 cntlzw r29,r31
ffc05018: 57 bd d9 7e rlwinm r29,r29,27,5,31
ffc0501c: 6b bd 00 01 xori r29,r29,1
const char *target_or_null,
const char *filesystemtype,
size_t *target_length_ptr
)
{
const char *target = target_or_null != NULL ? target_or_null : "/";
ffc05020: 2f 9d 00 00 cmpwi cr7,r29,0
ffc05024: 7f f6 fb 78 mr r22,r31
ffc05028: 40 be 00 0c bne+ cr7,ffc05034 <mount+0x68>
ffc0502c: 3e c0 ff c2 lis r22,-62
ffc05030: 3a d6 d3 28 addi r22,r22,-11480
size_t filesystemtype_size = strlen( filesystemtype ) + 1;
ffc05034: 7f 23 cb 78 mr r3,r25
ffc05038: 48 00 d4 a9 bl ffc124e0 <strlen>
size_t source_size = source_or_null != NULL ?
strlen( source_or_null ) + 1 : 0;
ffc0503c: 2f 9c 00 00 cmpwi cr7,r28,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;
ffc05040: 7c 72 1b 78 mr r18,r3
size_t source_size = source_or_null != NULL ?
strlen( source_or_null ) + 1 : 0;
ffc05044: 3a e0 00 00 li r23,0
ffc05048: 41 9e 00 10 beq- cr7,ffc05058 <mount+0x8c>
ffc0504c: 7f 83 e3 78 mr r3,r28
ffc05050: 48 00 d4 91 bl ffc124e0 <strlen>
ffc05054: 3a e3 00 01 addi r23,r3,1
size_t target_size = strlen( target ) + 1;
ffc05058: 7e c3 b3 78 mr r3,r22
ffc0505c: 48 00 d4 85 bl ffc124e0 <strlen>
size_t size = sizeof( rtems_filesystem_mount_table_entry_t )
+ filesystemtype_size + source_size + target_size;
ffc05060: 38 92 00 75 addi r4,r18,117
{
const char *target = target_or_null != NULL ? target_or_null : "/";
size_t filesystemtype_size = strlen( filesystemtype ) + 1;
size_t source_size = source_or_null != NULL ?
strlen( source_or_null ) + 1 : 0;
size_t target_size = strlen( target ) + 1;
ffc05064: 3a 63 00 01 addi r19,r3,1
size_t size = sizeof( rtems_filesystem_mount_table_entry_t )
+ filesystemtype_size + source_size + target_size;
ffc05068: 7c 84 ba 14 add r4,r4,r23
{
const char *target = target_or_null != NULL ? target_or_null : "/";
size_t filesystemtype_size = strlen( filesystemtype ) + 1;
size_t source_size = source_or_null != NULL ?
strlen( source_or_null ) + 1 : 0;
size_t target_size = strlen( target ) + 1;
ffc0506c: 7c 74 1b 78 mr r20,r3
size_t size = sizeof( rtems_filesystem_mount_table_entry_t )
+ filesystemtype_size + source_size + target_size;
rtems_filesystem_mount_table_entry_t *mt_entry = calloc( 1, size );
ffc05070: 7c 84 9a 14 add r4,r4,r19
ffc05074: 38 60 00 01 li r3,1
ffc05078: 4b ff f3 cd bl ffc04444 <calloc>
if ( mt_entry != NULL ) {
ffc0507c: 7c 7e 1b 79 mr. r30,r3
ffc05080: 41 82 00 78 beq- ffc050f8 <mount+0x12c> <== NEVER TAKEN
char *str = (char *) mt_entry + sizeof( *mt_entry );
ffc05084: 3a be 00 74 addi r21,r30,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;
ffc05088: 3a 52 00 01 addi r18,r18,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 );
ffc0508c: 7f 24 cb 78 mr r4,r25
ffc05090: 7e 45 93 78 mr r5,r18
ffc05094: 7e a3 ab 78 mr r3,r21
ffc05098: 48 00 c8 59 bl ffc118f0 <memcpy>
mt_entry->type = str;
str += filesystemtype_size;
ffc0509c: 7f 35 92 14 add r25,r21,r18
if ( mt_entry != NULL ) {
char *str = (char *) mt_entry + sizeof( *mt_entry );
memcpy( str, filesystemtype, filesystemtype_size );
mt_entry->type = str;
ffc050a0: 92 be 00 6c stw r21,108(r30)
str += filesystemtype_size;
memcpy( str, source_or_null, source_size );
ffc050a4: 7e e5 bb 78 mr r5,r23
ffc050a8: 7f 84 e3 78 mr r4,r28
ffc050ac: 7f 23 cb 78 mr r3,r25
ffc050b0: 48 00 c8 41 bl ffc118f0 <memcpy>
mt_entry->dev = str;
str += source_size;
ffc050b4: 7e f9 ba 14 add r23,r25,r23
memcpy( str, filesystemtype, filesystemtype_size );
mt_entry->type = str;
str += filesystemtype_size;
memcpy( str, source_or_null, source_size );
mt_entry->dev = str;
ffc050b8: 93 3e 00 70 stw r25,112(r30)
str += source_size;
memcpy( str, target, target_size );
ffc050bc: 7e c4 b3 78 mr r4,r22
ffc050c0: 7e 65 9b 78 mr r5,r19
ffc050c4: 7e e3 bb 78 mr r3,r23
ffc050c8: 48 00 c8 29 bl ffc118f0 <memcpy>
mt_entry->target = str;
ffc050cc: 92 fe 00 68 stw r23,104(r30)
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;
ffc050d0: 3c 80 ff c2 lis r4,-62
&target_length
);
if ( !mt_entry )
rtems_set_errno_and_return_minus_one( ENOMEM );
mt_entry->mt_fs_root.mt_entry = mt_entry;
ffc050d4: 93 de 00 2c stw r30,44(r30)
mt_entry->options = options;
mt_entry->pathconf_limits_and_options = rtems_filesystem_default_pathconf;
ffc050d8: 38 7e 00 38 addi r3,r30,56
ffc050dc: 38 84 d7 dc addi r4,r4,-10276
);
if ( !mt_entry )
rtems_set_errno_and_return_minus_one( ENOMEM );
mt_entry->mt_fs_root.mt_entry = mt_entry;
mt_entry->options = options;
ffc050e0: 93 1e 00 30 stw r24,48(r30)
mt_entry->pathconf_limits_and_options = rtems_filesystem_default_pathconf;
ffc050e4: 38 a0 00 30 li r5,48
ffc050e8: 48 00 c8 09 bl ffc118f0 <memcpy>
/*
* The mount_point should be a directory with read/write/execute
* permissions in the existing tree.
*/
if ( has_target ) {
ffc050ec: 2f 9d 00 00 cmpwi cr7,r29,0
ffc050f0: 41 be 00 d0 beq+ cr7,ffc051c0 <mount+0x1f4>
ffc050f4: 48 00 00 18 b ffc0510c <mount+0x140>
target,
filesystemtype,
&target_length
);
if ( !mt_entry )
rtems_set_errno_and_return_minus_one( ENOMEM );
ffc050f8: 48 00 ba bd bl ffc10bb4 <__errno> <== NOT EXECUTED
ffc050fc: 38 00 00 0c li r0,12 <== NOT EXECUTED
ffc05100: 90 03 00 00 stw r0,0(r3)
ffc05104: 3b e0 ff ff li r31,-1
ffc05108: 48 00 01 7c b ffc05284 <mount+0x2b8>
* The mount_point should be a directory with read/write/execute
* permissions in the existing tree.
*/
if ( has_target ) {
if ( rtems_filesystem_evaluate_path(
ffc0510c: 7f e3 fb 78 mr r3,r31
ffc05110: 7e 84 a3 78 mr r4,r20
ffc05114: 38 a0 00 07 li r5,7
ffc05118: 38 c1 00 08 addi r6,r1,8
ffc0511c: 38 e0 00 01 li r7,1
ffc05120: 4b ff f7 1d bl ffc0483c <rtems_filesystem_evaluate_path>
ffc05124: 2f 83 ff ff cmpwi cr7,r3,-1
ffc05128: 41 9e 01 3c beq- cr7,ffc05264 <mount+0x298> <== NEVER TAKEN
/*
* Test to see if it is a directory
*/
if ( loc.ops->node_type_h( &loc ) != RTEMS_FILESYSTEM_DIRECTORY ) {
ffc0512c: 81 21 00 14 lwz r9,20(r1)
ffc05130: 38 61 00 08 addi r3,r1,8
ffc05134: 80 09 00 10 lwz r0,16(r9)
ffc05138: 7c 09 03 a6 mtctr r0
ffc0513c: 4e 80 04 21 bctrl
ffc05140: 2f 83 00 01 cmpwi cr7,r3,1
ffc05144: 41 9e 00 10 beq- cr7,ffc05154 <mount+0x188>
errno = ENOTDIR;
ffc05148: 48 00 ba 6d bl ffc10bb4 <__errno>
ffc0514c: 38 00 00 14 li r0,20
ffc05150: 48 00 00 24 b ffc05174 <mount+0x1a8>
/*
* You can only mount one file system onto a single mount point.
*/
if ( rtems_filesystem_mount_iterate( is_node_fs_root, loc.node_access ) ) {
ffc05154: 3c 60 ff c0 lis r3,-64
ffc05158: 80 81 00 08 lwz r4,8(r1)
ffc0515c: 38 63 4f 14 addi r3,r3,20244
ffc05160: 4b ff fd f9 bl ffc04f58 <rtems_filesystem_mount_iterate>
ffc05164: 2f 83 00 00 cmpwi cr7,r3,0
ffc05168: 41 9e 00 18 beq- cr7,ffc05180 <mount+0x1b4>
errno = EBUSY;
ffc0516c: 48 00 ba 49 bl ffc10bb4 <__errno>
ffc05170: 38 00 00 10 li r0,16
ffc05174: 90 03 00 00 stw r0,0(r3)
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;
ffc05178: 3b 81 00 08 addi r28,r1,8
* You can only mount one file system onto a single mount point.
*/
if ( rtems_filesystem_mount_iterate( is_node_fs_root, loc.node_access ) ) {
errno = EBUSY;
goto cleanup_and_bail;
ffc0517c: 48 00 00 ec b ffc05268 <mount+0x29c>
* 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;
ffc05180: 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 ) ) {
ffc05184: 7f c3 f3 78 mr r3,r30
* 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;
ffc05188: 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;
ffc0518c: 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;
ffc05190: 90 1e 00 08 stw r0,8(r30)
mt_entry->mt_point_node.handlers = loc.handlers;
ffc05194: 80 01 00 10 lwz r0,16(r1)
mt_entry->mt_point_node.ops = loc.ops;
ffc05198: 91 3e 00 14 stw r9,20(r30)
* 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;
ffc0519c: 90 1e 00 10 stw r0,16(r30)
mt_entry->mt_point_node.ops = loc.ops;
mt_entry->mt_point_node.mt_entry = loc.mt_entry;
ffc051a0: 80 01 00 18 lwz r0,24(r1)
ffc051a4: 90 1e 00 18 stw r0,24(r30)
/*
* 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 ) ) {
ffc051a8: 80 09 00 20 lwz r0,32(r9)
ffc051ac: 7c 09 03 a6 mtctr r0
ffc051b0: 4e 80 04 21 bctrl
ffc051b4: 2f 83 00 00 cmpwi cr7,r3,0
ffc051b8: 40 9e 00 b0 bne- cr7,ffc05268 <mount+0x29c> <== NEVER TAKEN
ffc051bc: 48 00 00 30 b ffc051ec <mount+0x220>
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_head( the_chain )->next;
ffc051c0: 3d 20 00 00 lis r9,0
ffc051c4: 39 69 21 a4 addi r11,r9,8612
}
} else {
/*
* Do we already have a base file system ?
*/
if ( !rtems_chain_is_empty( &mount_chain ) ) {
ffc051c8: 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 );
ffc051cc: 38 0b 00 04 addi r0,r11,4
ffc051d0: 7f 89 00 00 cmpw cr7,r9,r0
ffc051d4: 41 9e 00 14 beq- cr7,ffc051e8 <mount+0x21c> <== ALWAYS TAKEN
errno = EINVAL;
ffc051d8: 48 00 b9 dd bl ffc10bb4 <__errno> <== NOT EXECUTED
ffc051dc: 38 00 00 16 li r0,22 <== NOT EXECUTED
ffc051e0: 90 03 00 00 stw r0,0(r3) <== NOT EXECUTED
ffc051e4: 48 00 00 80 b ffc05264 <mount+0x298> <== NOT EXECUTED
)
{
rtems_filesystem_fsmount_me_t mount_h = NULL;
rtems_filesystem_location_info_t loc;
rtems_filesystem_mount_table_entry_t *mt_entry = NULL;
rtems_filesystem_location_info_t *loc_to_free = NULL;
ffc051e8: 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 ) ) {
ffc051ec: 7f c3 f3 78 mr r3,r30
ffc051f0: 7f 69 03 a6 mtctr r27
ffc051f4: 7f 44 d3 78 mr r4,r26
ffc051f8: 4e 80 04 21 bctrl
ffc051fc: 2f 83 00 00 cmpwi cr7,r3,0
ffc05200: 41 9e 00 1c beq- cr7,ffc0521c <mount+0x250>
/*
* Try to undo the mount operation
*/
loc.ops->unmount_h( mt_entry );
ffc05204: 81 21 00 14 lwz r9,20(r1)
ffc05208: 7f c3 f3 78 mr r3,r30
ffc0520c: 80 09 00 28 lwz r0,40(r9)
ffc05210: 7c 09 03 a6 mtctr r0
ffc05214: 4e 80 04 21 bctrl
goto cleanup_and_bail;
ffc05218: 48 00 00 50 b ffc05268 <mount+0x29c>
}
/*
* Add the mount table entry to the mount table chain
*/
rtems_libio_lock();
ffc0521c: 4b ff fd 0d bl ffc04f28 <rtems_libio_lock>
ffc05220: 3c 60 00 00 lis r3,0
ffc05224: 38 63 21 a4 addi r3,r3,8612
ffc05228: 7f c4 f3 78 mr r4,r30
ffc0522c: 48 00 3a 1d bl ffc08c48 <_Chain_Append>
ffc05230: 3d 20 00 00 lis r9,0
ffc05234: 80 69 27 f8 lwz r3,10232(r9)
rtems_libio_unlock();
if ( !has_target )
rtems_filesystem_root = mt_entry->mt_fs_root;
return 0;
ffc05238: 3b e0 00 00 li r31,0
ffc0523c: 48 00 2f 95 bl ffc081d0 <rtems_semaphore_release>
*/
rtems_libio_lock();
rtems_chain_append( &mount_chain, &mt_entry->Node );
rtems_libio_unlock();
if ( !has_target )
ffc05240: 2f 9d 00 00 cmpwi cr7,r29,0
ffc05244: 40 9e 00 40 bne- cr7,ffc05284 <mount+0x2b8>
rtems_filesystem_root = mt_entry->mt_fs_root;
ffc05248: 3d 20 00 00 lis r9,0
ffc0524c: 81 69 27 7c lwz r11,10108(r9)
ffc05250: 38 7e 00 1c addi r3,r30,28
ffc05254: 39 6b 00 18 addi r11,r11,24
ffc05258: 7c a3 a4 aa lswi r5,r3,20
ffc0525c: 7c ab a5 aa stswi r5,r11,20
ffc05260: 48 00 00 24 b ffc05284 <mount+0x2b8>
)
{
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;
ffc05264: 3b 80 00 00 li r28,0 <== NOT EXECUTED
return 0;
cleanup_and_bail:
free( mt_entry );
ffc05268: 7f c3 f3 78 mr r3,r30
ffc0526c: 4b ff f6 f1 bl ffc0495c <free>
if ( loc_to_free )
ffc05270: 2f 9c 00 00 cmpwi cr7,r28,0
rtems_filesystem_freenode( loc_to_free );
return -1;
ffc05274: 3b e0 ff ff li r31,-1
cleanup_and_bail:
free( mt_entry );
if ( loc_to_free )
ffc05278: 41 9e 00 0c beq- cr7,ffc05284 <mount+0x2b8> <== NEVER TAKEN
rtems_filesystem_freenode( loc_to_free );
ffc0527c: 7f 83 e3 78 mr r3,r28
ffc05280: 4b ff f6 b1 bl ffc04930 <rtems_filesystem_freenode>
return -1;
}
ffc05284: 39 61 00 60 addi r11,r1,96
ffc05288: 7f e3 fb 78 mr r3,r31
ffc0528c: 4b ff b2 84 b ffc00510 <_restgpr_18_x>
ffc04e54 <mount_and_make_target_path>:
const char *target,
const char *filesystemtype,
rtems_filesystem_options_t options,
const void *data
)
{
ffc04e54: 94 21 ff e0 stwu r1,-32(r1)
ffc04e58: 7c 08 02 a6 mflr r0
ffc04e5c: bf c1 00 18 stmw r30,24(r1)
int rv = -1;
if (target != NULL) {
ffc04e60: 7c 9e 23 79 mr. r30,r4
const char *target,
const char *filesystemtype,
rtems_filesystem_options_t options,
const void *data
)
{
ffc04e64: 7c 7f 1b 78 mr r31,r3
ffc04e68: 90 01 00 24 stw r0,36(r1)
int rv = -1;
if (target != NULL) {
ffc04e6c: 41 82 00 40 beq- ffc04eac <mount_and_make_target_path+0x58>
rv = rtems_mkdir(target, S_IRWXU | S_IRWXG | S_IRWXO);
ffc04e70: 7f c3 f3 78 mr r3,r30
ffc04e74: 90 a1 00 08 stw r5,8(r1)
ffc04e78: 38 80 01 ff li r4,511
ffc04e7c: 90 c1 00 0c stw r6,12(r1)
ffc04e80: 90 e1 00 10 stw r7,16(r1)
ffc04e84: 48 00 09 b1 bl ffc05834 <rtems_mkdir>
if (rv == 0) {
ffc04e88: 2c 03 00 00 cmpwi r3,0
ffc04e8c: 80 a1 00 08 lwz r5,8(r1)
ffc04e90: 80 c1 00 0c lwz r6,12(r1)
ffc04e94: 80 e1 00 10 lwz r7,16(r1)
ffc04e98: 40 a2 00 24 bne+ ffc04ebc <mount_and_make_target_path+0x68><== NEVER TAKEN
rv = mount(
ffc04e9c: 7f e3 fb 78 mr r3,r31
ffc04ea0: 7f c4 f3 78 mr r4,r30
ffc04ea4: 48 00 00 d9 bl ffc04f7c <mount>
ffc04ea8: 48 00 00 14 b ffc04ebc <mount_and_make_target_path+0x68>
options,
data
);
}
} else {
errno = EINVAL;
ffc04eac: 48 00 b9 91 bl ffc1083c <__errno>
ffc04eb0: 38 00 00 16 li r0,22
ffc04eb4: 90 03 00 00 stw r0,0(r3)
const char *filesystemtype,
rtems_filesystem_options_t options,
const void *data
)
{
int rv = -1;
ffc04eb8: 38 60 ff ff li r3,-1
} else {
errno = EINVAL;
}
return rv;
}
ffc04ebc: 39 61 00 20 addi r11,r1,32
ffc04ec0: 48 01 08 54 b ffc15714 <_restgpr_30_x>
ffc198a8 <msdos_creat_node>:
msdos_node_type_t type,
const char *name,
int name_len,
mode_t mode,
const fat_file_fd_t *link_fd)
{
ffc198a8: 94 21 ff 30 stwu r1,-208(r1)
ffc198ac: 7c 08 02 a6 mflr r0
ffc198b0: 90 01 00 d4 stw r0,212(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;
ffc198b4: 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;
ffc198b8: 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)
{
ffc198bc: be c1 00 a8 stmw r22,168(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;
ffc198c0: 3b 80 00 00 li r28,0
msdos_node_type_t type,
const char *name,
int name_len,
mode_t mode,
const fat_file_fd_t *link_fd)
{
ffc198c4: 7c b9 2b 78 mr r25,r5
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;
ffc198c8: 83 a3 00 00 lwz r29,0(r3)
uint32_t sec = 0;
uint32_t byte = 0;
fat_dir_pos_init(&dir_pos);
memset(short_node, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
ffc198cc: 38 a0 00 20 li r5,32
msdos_node_type_t type,
const char *name,
int name_len,
mode_t mode,
const fat_file_fd_t *link_fd)
{
ffc198d0: 7c 7f 1b 78 mr r31,r3
int rc = RC_OK;
ssize_t ret = 0;
msdos_fs_info_t *fs_info = parent_loc->mt_entry->fs_info;
ffc198d4: 83 c9 00 34 lwz r30,52(r9)
msdos_node_type_t type,
const char *name,
int name_len,
mode_t mode,
const fat_file_fd_t *link_fd)
{
ffc198d8: 7c 9b 23 78 mr r27,r4
ffc198dc: 90 01 00 18 stw r0,24(r1)
uint32_t sec = 0;
uint32_t byte = 0;
fat_dir_pos_init(&dir_pos);
memset(short_node, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
ffc198e0: 38 80 00 00 li r4,0
ffc198e4: 38 61 00 40 addi r3,r1,64
dir_pos->lname.ofs = FAT_FILE_SHORT_NAME;
ffc198e8: 90 01 00 1c stw r0,28(r1)
msdos_node_type_t type,
const char *name,
int name_len,
mode_t mode,
const fat_file_fd_t *link_fd)
{
ffc198ec: 7c da 33 78 mr r26,r6
ffc198f0: 7d 17 43 78 mr r23,r8
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;
ffc198f4: 93 81 00 0c stw r28,12(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;
ffc198f8: 3a c0 ff ff li r22,-1
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;
time_t time_ret = 0;
uint16_t time_val = 0;
ffc198fc: b3 81 00 0a sth r28,10(r1)
uint16_t date = 0;
ffc19900: b3 81 00 08 sth r28,8(r1)
static inline void
fat_dir_pos_init(
fat_dir_pos_t *dir_pos
)
{
dir_pos->sname.cln = 0;
ffc19904: 93 81 00 10 stw r28,16(r1)
dir_pos->sname.ofs = 0;
ffc19908: 93 81 00 14 stw r28,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);
ffc1990c: 48 00 57 e5 bl ffc1f0f0 <memset>
memset(dot_dotdot, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE * 2);
ffc19910: 38 80 00 00 li r4,0
ffc19914: 38 a0 00 40 li r5,64
ffc19918: 38 61 00 60 addi r3,r1,96
ffc1991c: 48 00 57 d5 bl ffc1f0f0 <memset>
name_type = msdos_long_to_short (name, name_len,
ffc19920: 7f 44 d3 78 mr r4,r26
ffc19924: 38 a1 00 40 addi r5,r1,64
ffc19928: 38 c0 00 0b li r6,11
ffc1992c: 7f 23 cb 78 mr r3,r25
ffc19930: 48 00 10 09 bl ffc1a938 <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;
ffc19934: 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,
ffc19938: 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;
ffc1993c: 98 01 00 4c stb r0,76(r1)
/* set up last write date and time */
time_ret = time(NULL);
ffc19940: 38 60 00 00 li r3,0
ffc19944: 48 00 90 55 bl ffc22998 <time>
if ( time_ret == -1 )
ffc19948: 2f 83 ff ff cmpwi cr7,r3,-1
ffc1994c: 41 9e 02 bc beq- cr7,ffc19c08 <msdos_creat_node+0x360> <== NEVER TAKEN
return -1;
msdos_date_unix2dos(time_ret, &date, &time_val);
ffc19950: 38 81 00 08 addi r4,r1,8
ffc19954: 38 a1 00 0a addi r5,r1,10
ffc19958: 48 00 3b e9 bl ffc1d540 <msdos_date_unix2dos>
*MSDOS_DIR_CRT_TIME(short_node) = CT_LE_W(time_val);
ffc1995c: a0 01 00 0a lhz r0,10(r1)
*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) {
ffc19960: 2f 9b 00 01 cmpwi cr7,r27,1
*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;
ffc19964: 93 81 00 5c stw r28,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);
ffc19968: 54 0b c2 3e rlwinm r11,r0,24,8,31
ffc1996c: 54 09 44 2e rlwinm r9,r0,8,16,23
ffc19970: 7d 29 5b 78 or r9,r9,r11
*MSDOS_DIR_CRT_DATE(short_node) = CT_LE_W(date);
ffc19974: 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);
ffc19978: b1 21 00 4e sth r9,78(r1)
*MSDOS_DIR_CRT_DATE(short_node) = CT_LE_W(date);
ffc1997c: 55 6a c2 3e rlwinm r10,r11,24,8,31
ffc19980: 55 60 44 2e rlwinm r0,r11,8,16,23
*MSDOS_DIR_WRITE_TIME(short_node) = CT_LE_W(time_val);
ffc19984: b1 21 00 56 sth r9,86(r1)
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);
*MSDOS_DIR_CRT_DATE(short_node) = CT_LE_W(date);
ffc19988: 7c 00 53 78 or r0,r0,r10
ffc1998c: b0 01 00 50 sth r0,80(r1)
*MSDOS_DIR_WRITE_TIME(short_node) = CT_LE_W(time_val);
*MSDOS_DIR_WRITE_DATE(short_node) = CT_LE_W(date);
ffc19990: b0 01 00 58 sth r0,88(r1)
*MSDOS_DIR_LAST_ACCESS_DATE(short_node) = CT_LE_W(date);
ffc19994: 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) {
*MSDOS_DIR_ATTR(short_node) |= MSDOS_ATTR_DIRECTORY;
ffc19998: 88 01 00 4b lbz r0,75(r1)
ffc1999c: 60 00 00 10 ori r0,r0,16
*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) {
ffc199a0: 41 9e 00 b8 beq- cr7,ffc19a58 <msdos_creat_node+0x1b0>
*MSDOS_DIR_ATTR(short_node) |= MSDOS_ATTR_DIRECTORY;
}
else if (type == MSDOS_HARD_LINK) {
ffc199a4: 2f 9b 00 03 cmpwi cr7,r27,3
* 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;
ffc199a8: 88 01 00 4b lbz r0,75(r1)
*MSDOS_DIR_FILE_SIZE(short_node) = MSDOS_INIT_DIR_SIZE;
if (type == MSDOS_DIRECTORY) {
*MSDOS_DIR_ATTR(short_node) |= MSDOS_ATTR_DIRECTORY;
}
else if (type == MSDOS_HARD_LINK) {
ffc199ac: 40 be 00 a8 bne+ cr7,ffc19a54 <msdos_creat_node+0x1ac> <== ALWAYS TAKEN
* node to the newly created
*/
/*
* read the original directory entry
*/
sec = fat_cluster_num_to_sector_num(parent_loc->mt_entry,
ffc199b0: 81 37 00 20 lwz r9,32(r23) <== NOT EXECUTED
ffc199b4: 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)) )
ffc199b8: 2f 89 00 00 cmpwi cr7,r9,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;
}
ffc199bc: 81 63 00 34 lwz r11,52(r3) <== NOT EXECUTED
ffc199c0: 40 9e 00 18 bne- cr7,ffc199d8 <msdos_creat_node+0x130> <== NOT EXECUTED
ffc199c4: 88 0b 00 0a lbz r0,10(r11) <== NOT EXECUTED
ffc199c8: 70 0a 00 03 andi. r10,r0,3 <== NOT EXECUTED
ffc199cc: 41 82 00 0c beq- ffc199d8 <msdos_creat_node+0x130> <== NOT EXECUTED
return fs_info->vol.rdir_loc;
ffc199d0: 81 2b 00 1c lwz r9,28(r11) <== NOT EXECUTED
ffc199d4: 48 00 00 18 b ffc199ec <msdos_creat_node+0x144> <== NOT EXECUTED
return (((cln - FAT_RSRVD_CLN) << fs_info->vol.spc_log2) +
ffc199d8: 88 0b 00 05 lbz r0,5(r11) <== NOT EXECUTED
ffc199dc: 39 29 ff fe addi r9,r9,-2 <== NOT EXECUTED
ffc199e0: 7d 29 00 30 slw r9,r9,r0 <== NOT EXECUTED
ffc199e4: 80 0b 00 30 lwz r0,48(r11) <== NOT EXECUTED
ffc199e8: 7d 29 02 14 add r9,r9,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);
ffc199ec: 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,
ffc199f0: 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);
ffc199f4: 88 9e 00 02 lbz r4,2(r30) <== NOT EXECUTED
byte = (link_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1));
ret = _fat_block_read(parent_loc->mt_entry,
ffc199f8: 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));
ffc199fc: a0 be 00 00 lhz r5,0(r30) <== NOT EXECUTED
ret = _fat_block_read(parent_loc->mt_entry,
sec, byte, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE,
link_node);
if (ret < 0) {
return -1;
ffc19a00: 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);
ffc19a04: 7c 04 24 30 srw r4,r0,r4 <== NOT EXECUTED
byte = (link_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1));
ffc19a08: 38 a5 ff ff addi r5,r5,-1 <== NOT EXECUTED
ret = _fat_block_read(parent_loc->mt_entry,
ffc19a0c: 7c 89 22 14 add r4,r9,r4 <== NOT EXECUTED
ffc19a10: 7c a5 00 38 and r5,r5,r0 <== NOT EXECUTED
ffc19a14: 4b ff b2 e1 bl ffc14cf4 <_fat_block_read> <== NOT EXECUTED
sec, byte, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE,
link_node);
if (ret < 0) {
ffc19a18: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc19a1c: 41 9c 01 ec blt- cr7,ffc19c08 <msdos_creat_node+0x360> <== 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);
ffc19a20: 89 21 00 2d lbz r9,45(r1) <== NOT EXECUTED
return -1;
}
/*
* copy various attributes
*/
*MSDOS_DIR_ATTR(short_node) =*MSDOS_DIR_ATTR(link_node);
ffc19a24: 88 01 00 2b lbz r0,43(r1) <== NOT EXECUTED
*MSDOS_DIR_CRT_TIME_TENTH(short_node)=*MSDOS_DIR_CRT_TIME_TENTH(link_node);
ffc19a28: 99 21 00 4d stb r9,77(r1) <== NOT EXECUTED
*MSDOS_DIR_CRT_TIME(short_node) =*MSDOS_DIR_CRT_TIME(link_node);
ffc19a2c: a1 21 00 2e lhz r9,46(r1) <== NOT EXECUTED
ffc19a30: b1 21 00 4e sth r9,78(r1) <== NOT EXECUTED
*MSDOS_DIR_CRT_DATE(short_node) =*MSDOS_DIR_CRT_DATE(link_node);
ffc19a34: a1 21 00 30 lhz r9,48(r1) <== NOT EXECUTED
ffc19a38: b1 21 00 50 sth r9,80(r1) <== NOT EXECUTED
/*
* copy/set "file size", "first cluster"
*/
*MSDOS_DIR_FILE_SIZE(short_node) =*MSDOS_DIR_FILE_SIZE(link_node);
ffc19a3c: 81 21 00 3c lwz r9,60(r1) <== NOT EXECUTED
ffc19a40: 91 21 00 5c stw r9,92(r1) <== NOT EXECUTED
*MSDOS_DIR_FIRST_CLUSTER_LOW(short_node) =
ffc19a44: a1 21 00 3a lhz r9,58(r1) <== NOT EXECUTED
ffc19a48: b1 21 00 5a sth r9,90(r1) <== NOT EXECUTED
*MSDOS_DIR_FIRST_CLUSTER_LOW(link_node);
*MSDOS_DIR_FIRST_CLUSTER_HI(short_node) =
ffc19a4c: a1 21 00 34 lhz r9,52(r1) <== NOT EXECUTED
ffc19a50: b1 21 00 54 sth r9,84(r1) <== NOT EXECUTED
* 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;
ffc19a54: 60 00 00 20 ori r0,r0,32
/*
* 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,
name_type, &dir_pos, short_node);
ffc19a58: 3b 81 00 40 addi r28,r1,64
* 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;
ffc19a5c: 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,
ffc19a60: 7f e3 fb 78 mr r3,r31
ffc19a64: 38 80 00 01 li r4,1
ffc19a68: 7f 25 cb 78 mr r5,r25
ffc19a6c: 7f 46 d3 78 mr r6,r26
ffc19a70: 7f 07 c3 78 mr r7,r24
ffc19a74: 39 01 00 10 addi r8,r1,16
ffc19a78: 7f 89 e3 78 mr r9,r28
ffc19a7c: 48 00 22 35 bl ffc1bcb0 <msdos_get_name_node>
name_type, &dir_pos, short_node);
if ( rc != RC_OK )
ffc19a80: 7c 76 1b 79 mr. r22,r3
ffc19a84: 40 82 01 84 bne- ffc19c08 <msdos_creat_node+0x360> <== NEVER TAKEN
/*
* if we create a new file we are done, if directory there are more steps
* to do
*/
if (type == MSDOS_DIRECTORY)
ffc19a88: 2f 9b 00 01 cmpwi cr7,r27,1
ffc19a8c: 40 be 01 7c bne+ cr7,ffc19c08 <msdos_creat_node+0x360>
{
/* open new directory as fat-file */
rc = fat_file_open(parent_loc->mt_entry, &dir_pos, &fat_fd);
ffc19a90: 80 7f 00 10 lwz r3,16(r31)
ffc19a94: 38 81 00 10 addi r4,r1,16
ffc19a98: 38 a1 00 0c addi r5,r1,12
ffc19a9c: 4b ff a3 41 bl ffc13ddc <fat_file_open>
if (rc != RC_OK)
ffc19aa0: 7c 76 1b 79 mr. r22,r3
ffc19aa4: 40 82 01 54 bne- ffc19bf8 <msdos_creat_node+0x350> <== NEVER TAKEN
/*
* we opened fat-file for node we just created, so initialize fat-file
* descritor
*/
fat_fd->fat_file_size = 0;
ffc19aa8: 80 81 00 0c lwz r4,12(r1)
fat_fd->fat_file_type = FAT_DIRECTORY;
fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
ffc19aac: 3c 00 00 20 lis r0,32
* dot and dotdot entries are identical to new node except the
* names
*/
memcpy(DOT_NODE_P(dot_dotdot), short_node,
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
memcpy(DOTDOT_NODE_P(dot_dotdot), short_node,
ffc19ab0: 38 61 00 80 addi r3,r1,128
/*
* we opened fat-file for node we just created, so initialize fat-file
* descritor
*/
fat_fd->fat_file_size = 0;
fat_fd->fat_file_type = FAT_DIRECTORY;
ffc19ab4: 93 64 00 10 stw r27,16(r4)
/*
* dot and dotdot entries are identical to new node except the
* names
*/
memcpy(DOT_NODE_P(dot_dotdot), short_node,
ffc19ab8: 3b 61 00 60 addi r27,r1,96
* we opened fat-file for node we just created, so initialize fat-file
* descritor
*/
fat_fd->fat_file_size = 0;
fat_fd->fat_file_type = FAT_DIRECTORY;
fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
ffc19abc: 90 04 00 14 stw r0,20(r4)
/*
* we opened fat-file for node we just created, so initialize fat-file
* descritor
*/
fat_fd->fat_file_size = 0;
ffc19ac0: 92 c4 00 18 stw r22,24(r4)
/*
* dot and dotdot entries are identical to new node except the
* names
*/
memcpy(DOT_NODE_P(dot_dotdot), short_node,
ffc19ac4: 7c bc 04 aa lswi r5,r28,32
ffc19ac8: 7c bb 05 aa stswi r5,r27,32
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
memcpy(DOTDOT_NODE_P(dot_dotdot), short_node,
ffc19acc: 7c bc 04 aa lswi r5,r28,32
ffc19ad0: 7c a3 05 aa stswi r5,r3,32
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
memcpy(MSDOS_DIR_NAME(DOT_NODE_P(dot_dotdot)), MSDOS_DOT_NAME,
ffc19ad4: 3d 20 00 00 lis r9,0
ffc19ad8: 81 29 27 e8 lwz r9,10216(r9)
ffc19adc: 7c a9 5c aa lswi r5,r9,11
ffc19ae0: 7c bb 5d aa stswi r5,r27,11
MSDOS_NAME_MAX);
memcpy(MSDOS_DIR_NAME(DOTDOT_NODE_P(dot_dotdot)), MSDOS_DOTDOT_NAME,
ffc19ae4: 3d 20 00 00 lis r9,0
ffc19ae8: 81 29 27 e4 lwz r9,10212(r9)
ffc19aec: 7c a9 5c aa lswi r5,r9,11
ffc19af0: 7c a3 5d aa stswi r5,r3,11
/*
* 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)) &&
ffc19af4: 80 1d 00 20 lwz r0,32(r29)
ffc19af8: 2f 80 00 01 cmpwi cr7,r0,1
ffc19afc: 40 be 00 24 bne+ cr7,ffc19b20 <msdos_creat_node+0x278>
ffc19b00: 80 1d 00 24 lwz r0,36(r29)
ffc19b04: 2f 80 00 00 cmpwi cr7,r0,0
ffc19b08: 40 9e 00 18 bne- cr7,ffc19b20 <msdos_creat_node+0x278> <== NEVER TAKEN
(fs_info->fat.vol.type & FAT_FAT32))
ffc19b0c: 89 3e 00 0a lbz r9,10(r30)
/*
* 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)) &&
ffc19b10: 71 2b 00 04 andi. r11,r9,4
ffc19b14: 41 82 00 0c beq- ffc19b20 <msdos_creat_node+0x278> <== ALWAYS TAKEN
(fs_info->fat.vol.type & FAT_FAT32))
{
*MSDOS_DIR_FIRST_CLUSTER_LOW(DOTDOT_NODE_P(dot_dotdot)) = 0x0000;
ffc19b18: b0 01 00 9a sth r0,154(r1) <== NOT EXECUTED
ffc19b1c: 48 00 00 2c b ffc19b48 <msdos_creat_node+0x2a0> <== NOT EXECUTED
*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));
ffc19b20: 80 1d 00 1c lwz r0,28(r29)
ffc19b24: 54 09 04 3e clrlwi r9,r0,16
ffc19b28: 55 2b 40 2e rlwinm r11,r9,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)) =
ffc19b2c: 55 29 c2 3e rlwinm r9,r9,24,8,31
ffc19b30: 7d 69 4b 78 or r9,r11,r9
CT_LE_W((uint16_t )((parent_fat_fd->cln) & 0x0000FFFF));
*MSDOS_DIR_FIRST_CLUSTER_HI(DOTDOT_NODE_P(dot_dotdot)) =
CT_LE_W((uint16_t )(((parent_fat_fd->cln) & 0xFFFF0000)>>16));
ffc19b34: 54 00 84 3e rlwinm r0,r0,16,16,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)) =
ffc19b38: 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)) =
CT_LE_W((uint16_t )(((parent_fat_fd->cln) & 0xFFFF0000)>>16));
ffc19b3c: 54 09 40 2e rlwinm r9,r0,8,0,23
}
else
{
*MSDOS_DIR_FIRST_CLUSTER_LOW(DOTDOT_NODE_P(dot_dotdot)) =
CT_LE_W((uint16_t )((parent_fat_fd->cln) & 0x0000FFFF));
*MSDOS_DIR_FIRST_CLUSTER_HI(DOTDOT_NODE_P(dot_dotdot)) =
ffc19b40: 54 00 c2 3e rlwinm r0,r0,24,8,31
ffc19b44: 7d 20 03 78 or r0,r9,r0
/*
* 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,
ffc19b48: 80 7f 00 10 lwz r3,16(r31)
ffc19b4c: 38 a0 00 00 li r5,0
ffc19b50: 38 c0 00 40 li r6,64
}
else
{
*MSDOS_DIR_FIRST_CLUSTER_LOW(DOTDOT_NODE_P(dot_dotdot)) =
CT_LE_W((uint16_t )((parent_fat_fd->cln) & 0x0000FFFF));
*MSDOS_DIR_FIRST_CLUSTER_HI(DOTDOT_NODE_P(dot_dotdot)) =
ffc19b54: 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,
ffc19b58: 38 e1 00 60 addi r7,r1,96
ffc19b5c: 4b ff aa 31 bl ffc1458c <fat_file_write>
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE * 2,
(uint8_t *)dot_dotdot);
if (ret < 0)
ffc19b60: 2f 83 00 00 cmpwi cr7,r3,0
ffc19b64: 41 9c 00 84 blt- cr7,ffc19be8 <msdos_creat_node+0x340> <== NEVER TAKEN
rc = -1;
goto error;
}
/* increment fat-file size by cluster size */
fat_fd->fat_file_size += fs_info->fat.vol.bpc;
ffc19b68: 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,
ffc19b6c: 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;
ffc19b70: a0 1e 00 06 lhz r0,6(r30)
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,
ffc19b74: 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;
ffc19b78: 81 24 00 18 lwz r9,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,
ffc19b7c: 38 e1 00 60 addi r7,r1,96
ffc19b80: 80 7f 00 10 lwz r3,16(r31)
rc = -1;
goto error;
}
/* increment fat-file size by cluster size */
fat_fd->fat_file_size += fs_info->fat.vol.bpc;
ffc19b84: 7c 09 02 14 add r0,r9,r0
ffc19b88: 90 04 00 18 stw r0,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));
ffc19b8c: 80 04 00 1c lwz r0,28(r4)
ffc19b90: 54 09 04 3e clrlwi r9,r0,16
ffc19b94: 55 2b 40 2e rlwinm r11,r9,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)) =
ffc19b98: 55 29 c2 3e rlwinm r9,r9,24,8,31
ffc19b9c: 7d 69 4b 78 or r9,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));
ffc19ba0: 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)) =
ffc19ba4: 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)) =
CT_LE_W((uint16_t )(((fat_fd->cln) & 0xFFFF0000) >> 16));
ffc19ba8: 54 09 40 2e rlwinm r9,r0,8,0,23
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));
*MSDOS_DIR_FIRST_CLUSTER_HI(DOT_NODE_P(dot_dotdot)) =
ffc19bac: 54 00 c2 3e rlwinm r0,r0,24,8,31
ffc19bb0: 7d 20 03 78 or r0,r9,r0
ffc19bb4: 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,
ffc19bb8: 4b ff a9 d5 bl ffc1458c <fat_file_write>
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE,
(uint8_t *)DOT_NODE_P(dot_dotdot));
if (ret < 0)
ffc19bbc: 2f 83 00 00 cmpwi cr7,r3,0
ffc19bc0: 41 9c 00 28 blt- cr7,ffc19be8 <msdos_creat_node+0x340> <== 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);
ffc19bc4: 80 7f 00 10 lwz r3,16(r31)
ffc19bc8: 80 81 00 0c lwz r4,12(r1)
ffc19bcc: 48 00 11 19 bl ffc1ace4 <msdos_set_first_cluster_num>
if (rc != RC_OK)
ffc19bd0: 7c 76 1b 79 mr. r22,r3
ffc19bd4: 40 a2 00 18 bne+ ffc19bec <msdos_creat_node+0x344> <== NEVER TAKEN
goto error;
fat_file_close(parent_loc->mt_entry, fat_fd);
ffc19bd8: 80 7f 00 10 lwz r3,16(r31)
ffc19bdc: 80 81 00 0c lwz r4,12(r1)
ffc19be0: 4b ff a6 25 bl ffc14204 <fat_file_close>
ffc19be4: 48 00 00 24 b ffc19c08 <msdos_creat_node+0x360>
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;
ffc19be8: 3a c0 ff ff li r22,-1 <== NOT EXECUTED
fat_file_close(parent_loc->mt_entry, fat_fd);
}
return RC_OK;
error:
fat_file_close(parent_loc->mt_entry, fat_fd);
ffc19bec: 80 7f 00 10 lwz r3,16(r31) <== NOT EXECUTED
ffc19bf0: 80 81 00 0c lwz r4,12(r1) <== NOT EXECUTED
ffc19bf4: 4b ff a6 11 bl ffc14204 <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);
ffc19bf8: 80 7f 00 10 lwz r3,16(r31) <== NOT EXECUTED
ffc19bfc: 38 81 00 10 addi r4,r1,16 <== NOT EXECUTED
ffc19c00: 38 a0 00 e5 li r5,229 <== NOT EXECUTED
ffc19c04: 48 00 12 31 bl ffc1ae34 <msdos_set_first_char4file_name><== NOT EXECUTED
return rc;
}
ffc19c08: 39 61 00 d0 addi r11,r1,208
ffc19c0c: 7e c3 b3 78 mr r3,r22
ffc19c10: 4b fe 8e c4 b ffc02ad4 <_restgpr_22_x>
ffc1d674 <msdos_date_dos2unix>:
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;
ffc1d674: 54 89 ae fe rlwinm r9,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
ffc1d678: 54 80 de be rlwinm r0,r4,27,26,31
+ ((dt & MSDOS_DT_HOURS_MASK) >> MSDOS_DT_HOURS_SHIFT) * 3600;
ffc1d67c: 1d 29 07 08 mulli r9,r9,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
ffc1d680: 1c 00 00 1e mulli r0,r0,30
+ ((dt & MSDOS_DT_HOURS_MASK) >> MSDOS_DT_HOURS_SHIFT) * 3600;
ffc1d684: 7c 09 02 14 add r0,r9,r0
/*
* If the year, month, and day from the last conversion are the
* same then use the saved value.
*/
if (lastdosdate != dd) {
ffc1d688: 3d 20 00 00 lis r9,0
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)
ffc1d68c: 54 84 06 fe clrlwi r4,r4,27
+ ((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) {
ffc1d690: 39 29 2a fc addi r9,r9,11004
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;
ffc1d694: 7c 80 22 14 add r4,r0,r4
/*
* If the year, month, and day from the last conversion are the
* same then use the saved value.
*/
if (lastdosdate != dd) {
ffc1d698: a0 09 00 0e lhz r0,14(r9)
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)
ffc1d69c: 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) {
ffc1d6a0: 7f 80 18 00 cmpw cr7,r0,r3
ffc1d6a4: 41 9e 00 a4 beq- cr7,ffc1d748 <msdos_date_dos2unix+0xd4>
lastdosdate = dd;
days = 0;
year = (dd & MSDOS_DD_YEAR_MASK) >> MSDOS_DD_YEAR_SHIFT;
ffc1d6a8: 54 6b be 7e rlwinm r11,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;
ffc1d6ac: b0 69 00 0e sth r3,14(r9)
days = 0;
year = (dd & MSDOS_DD_YEAR_MASK) >> MSDOS_DD_YEAR_SHIFT;
for (y = 0; y < year; y++)
ffc1d6b0: 39 6b 00 01 addi r11,r11,1
* If the year, month, and day from the last conversion are the
* same then use the saved value.
*/
if (lastdosdate != dd) {
lastdosdate = dd;
days = 0;
ffc1d6b4: 38 00 00 00 li r0,0
year = (dd & MSDOS_DD_YEAR_MASK) >> MSDOS_DD_YEAR_SHIFT;
for (y = 0; y < year; y++)
ffc1d6b8: 7d 69 03 a6 mtctr r11
ffc1d6bc: 39 20 00 00 li r9,0
ffc1d6c0: 48 00 00 18 b ffc1d6d8 <msdos_date_dos2unix+0x64>
days += y & 0x03 ? 365 : 366;
ffc1d6c4: 7d 6b 00 34 cntlzw r11,r11
ffc1d6c8: 55 6b d9 7e rlwinm r11,r11,27,5,31
ffc1d6cc: 39 6b 01 6d addi r11,r11,365
ffc1d6d0: 7c 00 5a 14 add r0,r0,r11
*/
if (lastdosdate != dd) {
lastdosdate = dd;
days = 0;
year = (dd & MSDOS_DD_YEAR_MASK) >> MSDOS_DD_YEAR_SHIFT;
for (y = 0; y < year; y++)
ffc1d6d4: 39 29 00 01 addi r9,r9,1
ffc1d6d8: 55 2b 07 be clrlwi r11,r9,30
ffc1d6dc: 42 00 ff e8 bdnz+ ffc1d6c4 <msdos_date_dos2unix+0x50>
days += y & 0x03 ? 365 : 366;
months = year & 0x03 ? regyear : leapyear;
ffc1d6e0: 2f 8b 00 00 cmpwi cr7,r11,0
ffc1d6e4: 3d 40 00 00 lis r10,0
ffc1d6e8: 39 4a 22 ac addi r10,r10,8876
ffc1d6ec: 40 9e 00 08 bne- cr7,ffc1d6f4 <msdos_date_dos2unix+0x80><== NEVER TAKEN
ffc1d6f0: 39 4a 00 18 addi r10,r10,24
/*
* Prevent going from 0 to 0xffffffff in the following
* loop.
*/
month = (dd & MSDOS_DD_MONTH_MASK) >> MSDOS_DD_MONTH_SHIFT;
if (month == 0) {
ffc1d6f4: 54 6b df 3f rlwinm. r11,r3,27,28,31
ffc1d6f8: 40 82 00 08 bne- ffc1d700 <msdos_date_dos2unix+0x8c> <== ALWAYS TAKEN
month = 1;
ffc1d6fc: 39 60 00 01 li r11,1 <== NOT EXECUTED
}
for (m = 0; m < month - 1; m++)
ffc1d700: 39 20 00 00 li r9,0
ffc1d704: 7d 69 03 a6 mtctr r11
ffc1d708: 48 00 00 14 b ffc1d71c <msdos_date_dos2unix+0xa8>
* 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)
ffc1d70c: 55 2b 08 3c rlwinm r11,r9,1,0,30 <== 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];
ffc1d710: 7d 6a 5a 2e lhzx r11,r10,r11 <== NOT EXECUTED
*/
month = (dd & MSDOS_DD_MONTH_MASK) >> MSDOS_DD_MONTH_SHIFT;
if (month == 0) {
month = 1;
}
for (m = 0; m < month - 1; m++)
ffc1d714: 39 29 00 01 addi r9,r9,1 <== NOT EXECUTED
days += months[m];
ffc1d718: 7c 00 5a 14 add r0,r0,r11 <== NOT EXECUTED
*/
month = (dd & MSDOS_DD_MONTH_MASK) >> MSDOS_DD_MONTH_SHIFT;
if (month == 0) {
month = 1;
}
for (m = 0; m < month - 1; m++)
ffc1d71c: 42 00 ff f0 bdnz+ ffc1d70c <msdos_date_dos2unix+0x98>
days += months[m];
days += ((dd & MSDOS_DD_DAY_MASK) >> MSDOS_DD_DAY_SHIFT) - 1;
ffc1d720: 54 69 06 fe clrlwi r9,r3,27
ffc1d724: 39 29 ff ff addi r9,r9,-1
ffc1d728: 7c 09 02 14 add r0,r9,r0
lastseconds = (days + DAYSTO1980) * SECONDSPERDAY;
ffc1d72c: 3d 20 00 01 lis r9,1
ffc1d730: 61 29 51 80 ori r9,r9,20864
ffc1d734: 7d 20 49 d6 mullw r9,r0,r9
ffc1d738: 3d 29 12 cf addis r9,r9,4815
ffc1d73c: 38 09 a6 00 addi r0,r9,-23040
ffc1d740: 3d 20 00 00 lis r9,0
ffc1d744: 90 09 2b 0c stw r0,11020(r9)
}
return seconds + lastseconds;
ffc1d748: 3d 20 00 00 lis r9,0
ffc1d74c: 80 09 2b 0c lwz r0,11020(r9)
}
ffc1d750: 7c 64 02 14 add r3,r4,r0
ffc1d754: 4e 80 00 20 blr
ffc1d540 <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) {
ffc1d540: 3d 60 00 00 lis r11,0
ffc1d544: 80 0b 2a fc lwz r0,11004(r11)
ffc1d548: 39 2b 2a fc addi r9,r11,11004
ffc1d54c: 7f 80 18 00 cmpw cr7,r0,r3
ffc1d550: 41 9e 01 08 beq- cr7,ffc1d658 <msdos_date_unix2dos+0x118>
lasttime = t;
ffc1d554: 90 6b 2a fc stw r3,11004(r11)
lastdtime = (((t % 60) >> 1) << MSDOS_DT_2SECONDS_SHIFT)
+ (((t / 60) % 60) << MSDOS_DT_MINUTES_SHIFT)
ffc1d558: 39 60 00 3c li r11,60
ffc1d55c: 7c 03 5b 96 divwu r0,r3,r11
ffc1d560: 7d 40 5b 96 divwu r10,r0,r11
+ (((t / 3600) % 24) << MSDOS_DT_HOURS_SHIFT);
ffc1d564: 39 60 0e 10 li r11,3600
ffc1d568: 7d 63 5b 96 divwu r11,r3,r11
ffc1d56c: 39 00 00 18 li r8,24
ffc1d570: 7d 0b 43 96 divwu r8,r11,r8
* 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)
ffc1d574: 1d 4a 00 3c mulli r10,r10,60
+ (((t / 3600) % 24) << MSDOS_DT_HOURS_SHIFT);
ffc1d578: 1d 08 00 18 mulli r8,r8,24
* 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)
ffc1d57c: 7d 4a 00 50 subf r10,r10,r0
* 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)
ffc1d580: 1c 00 00 3c mulli r0,r0,60
+ (((t / 60) % 60) << MSDOS_DT_MINUTES_SHIFT)
+ (((t / 3600) % 24) << MSDOS_DT_HOURS_SHIFT);
ffc1d584: 7d 68 58 50 subf r11,r8,r11
* 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)
ffc1d588: 7c 00 18 50 subf r0,r0,r3
ffc1d58c: 55 4a 28 34 rlwinm r10,r10,5,0,26
ffc1d590: 55 6b 58 28 rlwinm r11,r11,11,0,20
ffc1d594: 7d 6a 5a 14 add r11,r10,r11
ffc1d598: 54 00 f8 7e rlwinm r0,r0,31,1,31
ffc1d59c: 7c 0b 02 14 add r0,r11,r0
ffc1d5a0: b0 09 00 04 sth r0,4(r9)
/*
* 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);
ffc1d5a4: 3c 00 00 01 lis r0,1
ffc1d5a8: 60 00 51 80 ori r0,r0,20864
ffc1d5ac: 7c 63 03 96 divwu r3,r3,r0
if (days != lastday) {
ffc1d5b0: 80 09 00 08 lwz r0,8(r9)
ffc1d5b4: 7f 83 00 00 cmpw cr7,r3,r0
ffc1d5b8: 41 9e 00 a0 beq- cr7,ffc1d658 <msdos_date_unix2dos+0x118><== NEVER TAKEN
lastday = days;
ffc1d5bc: 90 69 00 08 stw r3,8(r9)
for (year = 1970;; year++) {
ffc1d5c0: 39 20 07 b2 li r9,1970
inc = year & 0x03 ? 365 : 366;
ffc1d5c4: 71 20 00 03 andi. r0,r9,3
ffc1d5c8: 7d 60 00 26 mfcr r11
ffc1d5cc: 55 6b 1f fe rlwinm r11,r11,3,31,31
ffc1d5d0: 38 0b 01 6d addi r0,r11,365
if (days < inc)
ffc1d5d4: 7f 83 00 40 cmplw cr7,r3,r0
ffc1d5d8: 41 9c 00 10 blt- cr7,ffc1d5e8 <msdos_date_unix2dos+0xa8>
break;
days -= inc;
ffc1d5dc: 7c 60 18 50 subf r3,r0,r3
* and month stuff.
*/
days = t / (SECONDSPERDAY);
if (days != lastday) {
lastday = days;
for (year = 1970;; year++) {
ffc1d5e0: 39 29 00 01 addi r9,r9,1
inc = year & 0x03 ? 365 : 366;
if (days < inc)
break;
days -= inc;
}
ffc1d5e4: 4b ff ff e0 b ffc1d5c4 <msdos_date_unix2dos+0x84>
ffc1d5e8: 3d 40 00 00 lis r10,0
ffc1d5ec: 39 4a 22 ac addi r10,r10,8876
months = year & 0x03 ? regyear : leapyear;
ffc1d5f0: 40 82 00 08 bne- ffc1d5f8 <msdos_date_unix2dos+0xb8> <== NEVER TAKEN
ffc1d5f4: 39 4a 00 18 addi r10,r10,24
for (month = 0; month < 12; month++) {
ffc1d5f8: 38 00 00 0c li r0,12
ffc1d5fc: 7c 09 03 a6 mtctr r0
ffc1d600: 39 60 00 00 li r11,0
/*
* 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,
ffc1d604: 55 60 08 3c rlwinm r0,r11,1,0,30
break;
days -= inc;
}
months = year & 0x03 ? regyear : leapyear;
for (month = 0; month < 12; month++) {
if (days < months[month])
ffc1d608: 7c 0a 02 2e lhzx r0,r10,r0
ffc1d60c: 7f 83 00 40 cmplw cr7,r3,r0
ffc1d610: 41 9c 00 10 blt- cr7,ffc1d620 <msdos_date_unix2dos+0xe0><== ALWAYS TAKEN
break;
days -= months[month];
ffc1d614: 7c 60 18 50 subf r3,r0,r3 <== NOT EXECUTED
if (days < inc)
break;
days -= inc;
}
months = year & 0x03 ? regyear : leapyear;
for (month = 0; month < 12; month++) {
ffc1d618: 39 6b 00 01 addi r11,r11,1 <== NOT EXECUTED
ffc1d61c: 42 00 ff e8 bdnz+ ffc1d604 <msdos_date_unix2dos+0xc4> <== 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)
ffc1d620: 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)
ffc1d624: 39 6b 00 01 addi r11,r11,1
ffc1d628: 38 63 00 01 addi r3,r3,1
ffc1d62c: 55 6b 28 34 rlwinm r11,r11,5,0,26
ffc1d630: 7c 63 5a 14 add r3,r3,r11
ffc1d634: 3d 40 00 00 lis r10,0
ffc1d638: 54 63 04 3e clrlwi r3,r3,16
ffc1d63c: 39 4a 2a fc addi r10,r10,11004
ffc1d640: b0 6a 00 0c sth r3,12(r10)
* 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)
ffc1d644: 40 9d 00 14 ble- cr7,ffc1d658 <msdos_date_unix2dos+0x118><== NEVER TAKEN
lastddate += (year - 1980) <<
ffc1d648: 39 29 f8 44 addi r9,r9,-1980
ffc1d64c: 55 29 48 2c rlwinm r9,r9,9,0,22
ffc1d650: 7c 63 4a 14 add r3,r3,r9
ffc1d654: b0 6a 00 0c sth r3,12(r10)
MSDOS_DD_YEAR_SHIFT;
}
}
*dtp = lastdtime;
ffc1d658: 3d 20 00 00 lis r9,0
ffc1d65c: 39 29 2a fc addi r9,r9,11004
ffc1d660: a0 09 00 04 lhz r0,4(r9)
ffc1d664: b0 05 00 00 sth r0,0(r5)
*ddp = lastddate;
ffc1d668: a0 09 00 0c lhz r0,12(r9)
ffc1d66c: b0 04 00 00 sth r0,0(r4)
}
ffc1d670: 4e 80 00 20 blr
ffc1dff4 <msdos_dir_chmod>:
int
msdos_dir_chmod(rtems_filesystem_location_info_t *pathloc,
mode_t mode)
{
return RC_OK;
}
ffc1dff4: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc1dff8: 4e 80 00 20 blr <== NOT EXECUTED
ffc1d928 <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)
{
ffc1d928: 94 21 ff e8 stwu r1,-24(r1)
ffc1d92c: 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,
ffc1d930: 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)
{
ffc1d934: 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,
ffc1d938: 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;
ffc1d93c: 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)
{
ffc1d940: bf a1 00 0c stmw r29,12(r1)
ffc1d944: 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;
ffc1d948: 83 c9 00 34 lwz r30,52(r9)
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
ffc1d94c: 83 a3 00 1c lwz r29,28(r3)
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
ffc1d950: 80 7e 00 98 lwz r3,152(r30)
ffc1d954: 4b fe e3 9d bl ffc0bcf0 <rtems_semaphore_obtain>
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
ffc1d958: 2f 83 00 00 cmpwi cr7,r3,0
ffc1d95c: 41 be 00 18 beq+ cr7,ffc1d974 <msdos_dir_close+0x4c> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( EIO );
ffc1d960: 48 00 08 79 bl ffc1e1d8 <__errno> <== NOT EXECUTED
ffc1d964: 38 00 00 05 li r0,5 <== NOT EXECUTED
ffc1d968: 90 03 00 00 stw r0,0(r3) <== NOT EXECUTED
ffc1d96c: 3b e0 ff ff li r31,-1 <== NOT EXECUTED
ffc1d970: 48 00 00 1c b ffc1d98c <msdos_dir_close+0x64> <== NOT EXECUTED
rc = fat_file_close(iop->pathinfo.mt_entry, fat_fd);
ffc1d974: 80 7f 00 2c lwz r3,44(r31)
ffc1d978: 7f a4 eb 78 mr r4,r29
ffc1d97c: 4b ff 68 89 bl ffc14204 <fat_file_close>
if (rc != RC_OK)
ffc1d980: 7c 7f 1b 79 mr. r31,r3
ffc1d984: 80 7e 00 98 lwz r3,152(r30)
{
rtems_semaphore_release(fs_info->vol_sema);
return rc;
}
rtems_semaphore_release(fs_info->vol_sema);
ffc1d988: 4b fe e4 95 bl ffc0be1c <rtems_semaphore_release>
return RC_OK;
}
ffc1d98c: 39 61 00 18 addi r11,r1,24
ffc1d990: 7f e3 fb 78 mr r3,r31
ffc1d994: 4b fe 51 5c b ffc02af0 <_restgpr_29_x>
ffc1af58 <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
)
{
ffc1af58: 94 21 ff c8 stwu r1,-56(r1) <== NOT EXECUTED
ffc1af5c: 7c 08 02 a6 mflr r0 <== NOT EXECUTED
ffc1af60: 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;
ffc1af64: 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
)
{
ffc1af68: be a1 00 0c stmw r21,12(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,
ffc1af6c: 3f 40 ff c3 lis r26,-61 <== NOT EXECUTED
MSDOS_SHORT_NAME_LEN) == 0) ||
(strncmp(MSDOS_DIR_NAME((entry)),
ffc1af70: 3f 60 ff c3 lis r27,-61 <== NOT EXECUTED
fat_file_fd_t *fat_fd,
bool *ret_val
)
{
ssize_t ret = 0;
msdos_fs_info_t *fs_info = mt_entry->fs_info;
ffc1af74: 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
)
{
ffc1af78: 7c 7c 1b 78 mr r28,r3 <== NOT EXECUTED
ffc1af7c: 7c 99 23 78 mr r25,r4 <== 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;
ffc1af80: 98 05 00 00 stb r0,0(r5) <== NOT EXECUTED
msdos_dir_is_empty(
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_file_fd_t *fat_fd,
bool *ret_val
)
{
ffc1af84: 7c be 2b 78 mr r30,r5 <== NOT EXECUTED
ssize_t ret = 0;
msdos_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t j = 0, i = 0;
ffc1af88: 3b a0 00 00 li r29,0 <== 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,
ffc1af8c: 3b 5a f3 9a addi r26,r26,-3174 <== NOT EXECUTED
MSDOS_SHORT_NAME_LEN) == 0) ||
(strncmp(MSDOS_DIR_NAME((entry)),
ffc1af90: 3b 7b f3 a6 addi r27,r27,-3162 <== NOT EXECUTED
uint32_t j = 0, i = 0;
/* dir is not empty */
*ret_val = false;
while ((ret = fat_file_read(mt_entry, fat_fd, j * fs_info->fat.vol.bps,
ffc1af94: 48 00 00 bc b ffc1b050 <msdos_dir_is_empty+0xf8> <== NOT EXECUTED
fs_info->fat.vol.bps,
fs_info->cl_buf)) != FAT_EOF)
{
if (ret < MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
ffc1af98: 2f 83 00 1f cmpwi cr7,r3,31 <== NOT EXECUTED
ffc1af9c: 40 9d 00 e4 ble- cr7,ffc1b080 <msdos_dir_is_empty+0x128><== NOT EXECUTED
return -1;
assert(ret == fs_info->fat.vol.bps);
ffc1afa0: a2 bf 00 00 lhz r21,0(r31) <== NOT EXECUTED
ffc1afa4: 7f 83 a8 00 cmpw cr7,r3,r21 <== NOT EXECUTED
ffc1afa8: 41 be 00 98 beq+ cr7,ffc1b040 <msdos_dir_is_empty+0xe8> <== NOT EXECUTED
ffc1afac: 3c 60 ff c3 lis r3,-61 <== NOT EXECUTED
ffc1afb0: 3c a0 ff c3 lis r5,-61 <== NOT EXECUTED
ffc1afb4: 3c c0 ff c3 lis r6,-61 <== NOT EXECUTED
ffc1afb8: 38 63 f3 34 addi r3,r3,-3276 <== NOT EXECUTED
ffc1afbc: 38 80 03 b5 li r4,949 <== NOT EXECUTED
ffc1afc0: 38 a5 f2 c0 addi r5,r5,-3392 <== NOT EXECUTED
ffc1afc4: 38 c6 f3 7e addi r6,r6,-3202 <== NOT EXECUTED
ffc1afc8: 4b fe c2 b9 bl ffc07280 <__assert_func> <== NOT EXECUTED
/* 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)
{
char* entry = (char*) fs_info->cl_buf + i;
ffc1afcc: 81 3f 00 9c lwz r9,156(r31) <== 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)) ==
ffc1afd0: 7e c9 c0 ae lbzx r22,r9,r24 <== NOT EXECUTED
/* 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)
{
char* entry = (char*) fs_info->cl_buf + i;
ffc1afd4: 7e e9 c2 14 add r23,r9,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)) ==
ffc1afd8: 2f 96 00 e5 cmpwi cr7,r22,229 <== NOT EXECUTED
ffc1afdc: 41 9e 00 44 beq- cr7,ffc1b020 <msdos_dir_is_empty+0xc8> <== NOT EXECUTED
MSDOS_THIS_DIR_ENTRY_EMPTY) ||
((*MSDOS_DIR_ATTR(entry) & MSDOS_ATTR_LFN_MASK) ==
ffc1afe0: 88 17 00 0b lbz r0,11(r23) <== NOT EXECUTED
ffc1afe4: 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) ||
ffc1afe8: 2f 80 00 0f cmpwi cr7,r0,15 <== NOT EXECUTED
ffc1afec: 41 9e 00 34 beq- cr7,ffc1b020 <msdos_dir_is_empty+0xc8> <== NOT EXECUTED
((*MSDOS_DIR_ATTR(entry) & MSDOS_ATTR_LFN_MASK) ==
MSDOS_ATTR_LFN) ||
(strncmp(MSDOS_DIR_NAME((entry)), MSDOS_DOT_NAME,
ffc1aff0: 7e e3 bb 78 mr r3,r23 <== NOT EXECUTED
ffc1aff4: 7f 44 d3 78 mr r4,r26 <== NOT EXECUTED
ffc1aff8: 38 a0 00 0b li r5,11 <== NOT EXECUTED
ffc1affc: 48 00 4e 15 bl ffc1fe10 <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) ||
ffc1b000: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc1b004: 41 9e 00 1c beq- cr7,ffc1b020 <msdos_dir_is_empty+0xc8> <== NOT EXECUTED
(strncmp(MSDOS_DIR_NAME((entry)), MSDOS_DOT_NAME,
MSDOS_SHORT_NAME_LEN) == 0) ||
(strncmp(MSDOS_DIR_NAME((entry)),
ffc1b008: 7e e3 bb 78 mr r3,r23 <== NOT EXECUTED
ffc1b00c: 7f 64 db 78 mr r4,r27 <== NOT EXECUTED
ffc1b010: 38 a0 00 0b li r5,11 <== NOT EXECUTED
ffc1b014: 48 00 4d fd bl ffc1fe10 <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) ||
ffc1b018: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc1b01c: 40 9e 00 0c bne- cr7,ffc1b028 <msdos_dir_is_empty+0xd0> <== 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)
ffc1b020: 3b 18 00 20 addi r24,r24,32 <== NOT EXECUTED
ffc1b024: 48 00 00 20 b ffc1b044 <msdos_dir_is_empty+0xec> <== NOT EXECUTED
continue;
/*
* Nothing more to look at.
*/
if ((*MSDOS_DIR_NAME(entry)) ==
ffc1b028: 2f 96 00 00 cmpwi cr7,r22,0 <== NOT EXECUTED
}
/*
* Short file name entries mean not empty.
*/
return RC_OK;
ffc1b02c: 38 60 00 00 li r3,0 <== NOT EXECUTED
continue;
/*
* Nothing more to look at.
*/
if ((*MSDOS_DIR_NAME(entry)) ==
ffc1b030: 40 9e 00 54 bne- cr7,ffc1b084 <msdos_dir_is_empty+0x12c><== NOT EXECUTED
MSDOS_THIS_DIR_ENTRY_AND_REST_EMPTY)
{
*ret_val = true;
ffc1b034: 38 00 00 01 li r0,1 <== NOT EXECUTED
ffc1b038: 98 1e 00 00 stb r0,0(r30) <== NOT EXECUTED
return RC_OK;
ffc1b03c: 48 00 00 48 b ffc1b084 <msdos_dir_is_empty+0x12c> <== NOT EXECUTED
fs_info->cl_buf)) != FAT_EOF)
{
if (ret < MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
return -1;
assert(ret == fs_info->fat.vol.bps);
ffc1b040: 3b 00 00 00 li r24,0 <== NOT EXECUTED
/* have to look at the DIR_NAME as "raw" 8-bit data */
for (i = 0;
ffc1b044: 7f 98 a8 40 cmplw cr7,r24,r21 <== NOT EXECUTED
ffc1b048: 41 9c ff 84 blt+ cr7,ffc1afcc <msdos_dir_is_empty+0x74> <== NOT EXECUTED
/*
* Short file name entries mean not empty.
*/
return RC_OK;
}
j++;
ffc1b04c: 3b bd 00 01 addi r29,r29,1 <== NOT EXECUTED
uint32_t j = 0, i = 0;
/* dir is not empty */
*ret_val = false;
while ((ret = fat_file_read(mt_entry, fat_fd, j * fs_info->fat.vol.bps,
ffc1b050: a0 df 00 00 lhz r6,0(r31) <== NOT EXECUTED
ffc1b054: 7f 83 e3 78 mr r3,r28 <== NOT EXECUTED
ffc1b058: 80 ff 00 9c lwz r7,156(r31) <== NOT EXECUTED
ffc1b05c: 7f 24 cb 78 mr r4,r25 <== NOT EXECUTED
ffc1b060: 7c bd 31 d6 mullw r5,r29,r6 <== NOT EXECUTED
ffc1b064: 4b ff 8e d1 bl ffc13f34 <fat_file_read> <== NOT EXECUTED
ffc1b068: 2c 03 00 00 cmpwi r3,0 <== NOT EXECUTED
ffc1b06c: 40 82 ff 2c bne+ ffc1af98 <msdos_dir_is_empty+0x40> <== NOT EXECUTED
*/
return RC_OK;
}
j++;
}
*ret_val = true;
ffc1b070: 38 00 00 01 li r0,1 <== NOT EXECUTED
ffc1b074: 98 1e 00 00 stb r0,0(r30) <== NOT EXECUTED
return RC_OK;
ffc1b078: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc1b07c: 48 00 00 08 b ffc1b084 <msdos_dir_is_empty+0x12c> <== 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;
ffc1b080: 38 60 ff ff li r3,-1 <== NOT EXECUTED
}
j++;
}
*ret_val = true;
return RC_OK;
}
ffc1b084: 39 61 00 38 addi r11,r1,56 <== NOT EXECUTED
ffc1b088: 4b fe 7a 48 b ffc02ad0 <_restgpr_21_x> <== NOT EXECUTED
ffc1de88 <msdos_dir_lseek>:
* set apropriately).
*/
rtems_off64_t
msdos_dir_lseek(rtems_libio_t *iop, rtems_off64_t offset, int whence)
{
switch (whence)
ffc1de88: 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)
{
ffc1de8c: 94 21 ff f8 stwu r1,-8(r1) <== NOT EXECUTED
ffc1de90: 7c 08 02 a6 mflr r0 <== NOT EXECUTED
case SEEK_END:
default:
rtems_set_errno_and_return_minus_one( EINVAL );
break;
}
return RC_OK;
ffc1de94: 39 40 00 00 li r10,0 <== NOT EXECUTED
ffc1de98: 39 60 00 00 li r11,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)
{
ffc1de9c: 90 01 00 0c stw r0,12(r1) <== NOT EXECUTED
switch (whence)
ffc1dea0: 40 9d 00 18 ble- cr7,ffc1deb8 <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 );
ffc1dea4: 48 00 03 35 bl ffc1e1d8 <__errno> <== NOT EXECUTED
ffc1dea8: 38 00 00 16 li r0,22 <== NOT EXECUTED
ffc1deac: 90 03 00 00 stw r0,0(r3) <== NOT EXECUTED
ffc1deb0: 39 40 ff ff li r10,-1 <== NOT EXECUTED
ffc1deb4: 39 60 ff ff li r11,-1 <== NOT EXECUTED
break;
}
return RC_OK;
}
ffc1deb8: 80 01 00 0c lwz r0,12(r1) <== NOT EXECUTED
ffc1debc: 7d 43 53 78 mr r3,r10 <== NOT EXECUTED
ffc1dec0: 7d 64 5b 78 mr r4,r11 <== NOT EXECUTED
ffc1dec4: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
ffc1dec8: 38 21 00 08 addi r1,r1,8 <== NOT EXECUTED
ffc1decc: 4e 80 00 20 blr <== NOT EXECUTED
ffc1d8a8 <msdos_dir_open>:
* set apropriately)
*/
int
msdos_dir_open(rtems_libio_t *iop, const char *pathname, uint32_t flag,
uint32_t mode)
{
ffc1d8a8: 94 21 ff e8 stwu r1,-24(r1)
ffc1d8ac: 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,
ffc1d8b0: 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)
{
ffc1d8b4: 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,
ffc1d8b8: 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;
ffc1d8bc: 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)
{
ffc1d8c0: bf a1 00 0c stmw r29,12(r1)
ffc1d8c4: 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;
ffc1d8c8: 83 c9 00 34 lwz r30,52(r9)
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
ffc1d8cc: 83 a3 00 1c lwz r29,28(r3)
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
ffc1d8d0: 80 7e 00 98 lwz r3,152(r30)
ffc1d8d4: 4b fe e4 1d bl ffc0bcf0 <rtems_semaphore_obtain>
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
ffc1d8d8: 2f 83 00 00 cmpwi cr7,r3,0
ffc1d8dc: 41 be 00 18 beq+ cr7,ffc1d8f4 <msdos_dir_open+0x4c> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( EIO );
ffc1d8e0: 48 00 08 f9 bl ffc1e1d8 <__errno> <== NOT EXECUTED
ffc1d8e4: 38 00 00 05 li r0,5 <== NOT EXECUTED
ffc1d8e8: 90 03 00 00 stw r0,0(r3) <== NOT EXECUTED
ffc1d8ec: 3b a0 ff ff li r29,-1 <== NOT EXECUTED
ffc1d8f0: 48 00 00 2c b ffc1d91c <msdos_dir_open+0x74> <== NOT EXECUTED
rc = fat_file_reopen(fat_fd);
ffc1d8f4: 7f a3 eb 78 mr r3,r29
ffc1d8f8: 4b ff 66 29 bl ffc13f20 <fat_file_reopen>
if (rc != RC_OK)
ffc1d8fc: 7c 7d 1b 79 mr. r29,r3
ffc1d900: 80 7e 00 98 lwz r3,152(r30)
ffc1d904: 40 82 00 14 bne- ffc1d918 <msdos_dir_open+0x70> <== NEVER TAKEN
{
rtems_semaphore_release(fs_info->vol_sema);
return rc;
}
iop->offset = 0;
ffc1d908: 39 40 00 00 li r10,0
ffc1d90c: 39 60 00 00 li r11,0
ffc1d910: 91 5f 00 10 stw r10,16(r31)
ffc1d914: 91 7f 00 14 stw r11,20(r31)
rtems_semaphore_release(fs_info->vol_sema);
ffc1d918: 4b fe e5 05 bl ffc0be1c <rtems_semaphore_release>
return RC_OK;
}
ffc1d91c: 39 61 00 18 addi r11,r1,24
ffc1d920: 7f a3 eb 78 mr r3,r29
ffc1d924: 4b fe 51 cc b ffc02af0 <_restgpr_29_x>
ffc1d998 <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)
{
ffc1d998: 94 21 fe 78 stwu r1,-392(r1) <== NOT EXECUTED
ffc1d99c: 7c 08 02 a6 mflr r0 <== NOT EXECUTED
ffc1d9a0: 90 01 01 8c stw r0,396(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;
ffc1d9a4: 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)
{
ffc1d9a8: bd c1 01 40 stmw r14,320(r1) <== NOT EXECUTED
ffc1d9ac: 7c 7e 1b 78 mr r30,r3 <== NOT EXECUTED
ffc1d9b0: 7c bd 2b 78 mr r29,r5 <== 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;
ffc1d9b4: 83 03 00 1c lwz r24,28(r3) <== NOT EXECUTED
fat_file_fd_t *tmp_fat_fd = NULL;
ffc1d9b8: 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;
ffc1d9bc: 90 01 00 08 stw r0,8(r1) <== 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 :
ffc1d9c0: 80 18 00 20 lwz r0,32(r24) <== 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;
ffc1d9c4: 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 :
ffc1d9c8: 2f 80 00 01 cmpwi cr7,r0,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)
{
ffc1d9cc: 90 81 01 38 stw r4,312(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;
ffc1d9d0: 83 e9 00 34 lwz r31,52(r9) <== 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);
ffc1d9d4: 83 43 00 10 lwz r26,16(r3) <== NOT EXECUTED
ffc1d9d8: 83 63 00 14 lwz r27,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 :
ffc1d9dc: 40 be 00 24 bne+ cr7,ffc1da00 <msdos_dir_read+0x68> <== 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) &&
ffc1d9e0: 80 18 00 24 lwz r0,36(r24) <== NOT EXECUTED
ffc1d9e4: 2f 80 00 00 cmpwi cr7,r0,0 <== NOT EXECUTED
ffc1d9e8: 40 9e 00 18 bne- cr7,ffc1da00 <msdos_dir_read+0x68> <== NOT EXECUTED
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16))) ?
ffc1d9ec: 88 1f 00 0a lbz r0,10(r31) <== 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) &&
ffc1d9f0: 70 05 00 03 andi. r5,r0,3 <== NOT EXECUTED
ffc1d9f4: 41 82 00 0c beq- ffc1da00 <msdos_dir_read+0x68> <== NOT EXECUTED
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16))) ?
fat_fd->fat_file_size :
ffc1d9f8: 82 98 00 18 lwz r20,24(r24) <== NOT EXECUTED
ffc1d9fc: 48 00 00 08 b ffc1da04 <msdos_dir_read+0x6c> <== NOT EXECUTED
ffc1da00: a2 9f 00 06 lhz r20,6(r31) <== NOT EXECUTED
fs_info->fat.vol.bpc;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
ffc1da04: 80 7f 00 98 lwz r3,152(r31) <== NOT EXECUTED
ffc1da08: 38 80 00 00 li r4,0 <== NOT EXECUTED
ffc1da0c: 38 a0 00 00 li r5,0 <== NOT EXECUTED
ffc1da10: 4b fe e2 e1 bl ffc0bcf0 <rtems_semaphore_obtain> <== NOT EXECUTED
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
ffc1da14: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc1da18: 40 9e 00 80 bne- cr7,ffc1da98 <msdos_dir_read+0x100> <== 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);
ffc1da1c: 3a e0 01 18 li r23,280 <== NOT EXECUTED
ffc1da20: 7e fd bb 96 divwu r23,r29,r23 <== 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);
ffc1da24: 7f 43 d3 78 mr r3,r26 <== NOT EXECUTED
ffc1da28: 7f 64 db 78 mr r4,r27 <== NOT EXECUTED
ffc1da2c: 38 a0 00 00 li r5,0 <== NOT EXECUTED
ffc1da30: 38 c0 01 18 li r6,280 <== NOT EXECUTED
ffc1da34: 48 00 e2 39 bl ffc2bc6c <__divdi3> <== NOT EXECUTED
count = (count / sizeof(struct dirent)) * sizeof(struct dirent);
ffc1da38: 1e f7 01 18 mulli r23,r23,280 <== 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);
ffc1da3c: 7c 96 23 78 mr r22,r4 <== NOT EXECUTED
count = (count / sizeof(struct dirent)) * sizeof(struct dirent);
ffc1da40: 3b 20 00 00 li r25,0 <== NOT EXECUTED
ffc1da44: 3b 40 00 00 li r26,0 <== NOT EXECUTED
ffc1da48: 3a a0 00 00 li r21,0 <== NOT EXECUTED
ffc1da4c: 3b a0 ff ff li r29,-1 <== NOT EXECUTED
ffc1da50: 3b 60 00 00 li r27,0 <== 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;
ffc1da54: 3a 40 ff ff li r18,-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);
ffc1da58: 3a 00 01 18 li r16,280 <== NOT EXECUTED
* copy base name to destination
*/
src_tmp = src;
len = i;
while (i-- > 0) {
*dst++ = tolower((unsigned char)(*src_tmp++));
ffc1da5c: 3e 20 00 00 lis r17,0 <== NOT EXECUTED
{};
/*
* extension is not empty
*/
if (i > 0) {
*dst++ = '.'; /* append dot */
ffc1da60: 39 e0 00 2e li r15,46 <== NOT EXECUTED
while (i-- > 0) {
*dst++ = tolower((unsigned char)(*src_tmp++));
len++;
}
}
*dst = '\0'; /* terminate string */
ffc1da64: 39 c0 00 00 li r14,0 <== NOT EXECUTED
ffc1da68: 48 00 03 bc b ffc1de24 <msdos_dir_read+0x48c> <== 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),
ffc1da6c: 80 7e 00 2c lwz r3,44(r30) <== NOT EXECUTED
ffc1da70: 7f 04 c3 78 mr r4,r24 <== NOT EXECUTED
ffc1da74: 80 ff 00 9c lwz r7,156(r31) <== NOT EXECUTED
ffc1da78: 7f 25 cb 78 mr r5,r25 <== NOT EXECUTED
ffc1da7c: 7e 86 a3 78 mr r6,r20 <== NOT EXECUTED
ffc1da80: 4b ff 64 b5 bl ffc13f34 <fat_file_read> <== NOT EXECUTED
bts2rd, fs_info->cl_buf);
if (ret < MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
ffc1da84: 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),
ffc1da88: 7c 73 1b 78 mr r19,r3 <== NOT EXECUTED
bts2rd, fs_info->cl_buf);
if (ret < MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
ffc1da8c: 41 bd 03 88 bgt+ cr7,ffc1de14 <msdos_dir_read+0x47c> <== NOT EXECUTED
{
rtems_semaphore_release(fs_info->vol_sema);
ffc1da90: 80 7f 00 98 lwz r3,152(r31) <== NOT EXECUTED
ffc1da94: 4b fe e3 89 bl ffc0be1c <rtems_semaphore_release> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
ffc1da98: 48 00 07 41 bl ffc1e1d8 <__errno> <== NOT EXECUTED
ffc1da9c: 38 00 00 05 li r0,5 <== NOT EXECUTED
ffc1daa0: 90 03 00 00 stw r0,0(r3) <== NOT EXECUTED
ffc1daa4: 38 00 ff ff li r0,-1 <== NOT EXECUTED
ffc1daa8: 48 00 03 90 b ffc1de38 <msdos_dir_read+0x4a0> <== NOT EXECUTED
}
for (i = 0; i < ret; i += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
{
char* entry = (char*) fs_info->cl_buf + i;
ffc1daac: 81 7f 00 9c lwz r11,156(r31) <== NOT EXECUTED
/*
* Is this directory from here on empty ?
*/
if ((*MSDOS_DIR_ENTRY_TYPE(entry)) ==
ffc1dab0: 7c 0b e0 ae lbzx r0,r11,r28 <== 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;
ffc1dab4: 7d 2b e2 14 add r9,r11,r28 <== NOT EXECUTED
/*
* Is this directory from here on empty ?
*/
if ((*MSDOS_DIR_ENTRY_TYPE(entry)) ==
ffc1dab8: 2f 80 00 00 cmpwi cr7,r0,0 <== NOT EXECUTED
ffc1dabc: 41 9e 03 70 beq- cr7,ffc1de2c <msdos_dir_read+0x494> <== 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)
ffc1dac0: 2f 80 00 e5 cmpwi cr7,r0,229 <== NOT EXECUTED
ffc1dac4: 41 9e 03 48 beq- cr7,ffc1de0c <msdos_dir_read+0x474> <== NOT EXECUTED
continue;
/* Is the directory entry empty a volume label */
if (((*MSDOS_DIR_ATTR(entry)) & MSDOS_ATTR_VOLUME_ID) &&
ffc1dac8: 89 69 00 0b lbz r11,11(r9) <== NOT EXECUTED
ffc1dacc: 71 66 00 08 andi. r6,r11,8 <== NOT EXECUTED
ffc1dad0: 55 6b 06 be clrlwi r11,r11,26 <== NOT EXECUTED
ffc1dad4: 41 82 00 0c beq- ffc1dae0 <msdos_dir_read+0x148> <== NOT EXECUTED
ffc1dad8: 2f 8b 00 0f cmpwi cr7,r11,15 <== NOT EXECUTED
ffc1dadc: 40 be 03 30 bne+ cr7,ffc1de0c <msdos_dir_read+0x474> <== 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) ==
ffc1dae0: 2f 8b 00 0f cmpwi cr7,r11,15 <== NOT EXECUTED
ffc1dae4: 40 be 00 cc bne+ cr7,ffc1dbb0 <msdos_dir_read+0x218> <== NOT EXECUTED
int q;
/*
* Is this is the first entry of a LFN ?
*/
if (lfn_start == FAT_FILE_SHORT_NAME)
ffc1dae8: 2f 9d ff ff cmpwi cr7,r29,-1 <== NOT EXECUTED
ffc1daec: 40 be 00 34 bne+ cr7,ffc1db20 <msdos_dir_read+0x188> <== NOT EXECUTED
{
/*
* The first entry must have the last long entry flag set.
*/
if ((*MSDOS_DIR_ENTRY_TYPE(entry) &
ffc1daf0: 70 07 00 40 andi. r7,r0,64 <== NOT EXECUTED
ffc1daf4: 41 a2 03 18 beq+ ffc1de0c <msdos_dir_read+0x474> <== 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));
ffc1daf8: 38 61 00 34 addi r3,r1,52 <== 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);
ffc1dafc: 8a a9 00 0d lbz r21,13(r9) <== NOT EXECUTED
memset (tmp_dirent.d_name, 0, sizeof(tmp_dirent.d_name));
ffc1db00: 38 80 00 00 li r4,0 <== NOT EXECUTED
ffc1db04: 91 21 01 3c stw r9,316(r1) <== NOT EXECUTED
ffc1db08: 38 a0 01 00 li r5,256 <== NOT EXECUTED
/*
* Remember the start location of the long file name.
*/
lfn_start =
((j * bts2rd) + i) / MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE;
ffc1db0c: 7f bc ca 14 add r29,r28,r25 <== 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) &
ffc1db10: 54 1a 06 be clrlwi r26,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));
ffc1db14: 48 00 15 dd bl ffc1f0f0 <memset> <== NOT EXECUTED
ffc1db18: 81 21 01 3c lwz r9,316(r1) <== NOT EXECUTED
continue;
/*
* Remember the start location of the long file name.
*/
lfn_start =
ffc1db1c: 57 bd d9 7e rlwinm r29,r29,27,5,31 <== 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) &
ffc1db20: 88 09 00 00 lbz r0,0(r9) <== NOT EXECUTED
ffc1db24: 54 00 06 be clrlwi r0,r0,26 <== NOT EXECUTED
ffc1db28: 7f 9a 00 00 cmpw cr7,r26,r0 <== NOT EXECUTED
ffc1db2c: 40 be 02 dc bne+ cr7,ffc1de08 <msdos_dir_read+0x470> <== NOT EXECUTED
MSDOS_LAST_LONG_ENTRY_MASK)) ||
ffc1db30: 88 09 00 0d lbz r0,13(r9) <== NOT EXECUTED
ffc1db34: 7f 80 a8 00 cmpw cr7,r0,r21 <== NOT EXECUTED
ffc1db38: 40 be 02 d0 bne+ cr7,ffc1de08 <msdos_dir_read+0x470> <== 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)
ffc1db3c: 39 00 00 0d li r8,13 <== NOT EXECUTED
ffc1db40: 7d 09 03 a6 mtctr r8 <== 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--;
ffc1db44: 3b 5a ff ff addi r26,r26,-1 <== NOT EXECUTED
p = entry + 1;
o = lfn_entries * MSDOS_LFN_LEN_PER_ENTRY;
ffc1db48: 1d 5a 00 0d mulli r10,r26,13 <== 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;
ffc1db4c: 39 29 00 01 addi r9,r9,1 <== NOT EXECUTED
o = lfn_entries * MSDOS_LFN_LEN_PER_ENTRY;
for (q = 0; q < MSDOS_LFN_LEN_PER_ENTRY; q++)
ffc1db50: 39 60 00 00 li r11,0 <== NOT EXECUTED
{
if (o >= (sizeof(tmp_dirent.d_name) - 1))
ffc1db54: 2b 8a 00 fe cmplwi cr7,r10,254 <== NOT EXECUTED
ffc1db58: 41 9d 02 a4 bgt- cr7,ffc1ddfc <msdos_dir_read+0x464> <== NOT EXECUTED
break;
tmp_dirent.d_name[o++] = *p;
ffc1db5c: 88 09 00 00 lbz r0,0(r9) <== 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)
ffc1db60: 38 a1 00 20 addi r5,r1,32 <== NOT EXECUTED
ffc1db64: 7d 05 52 14 add r8,r5,r10 <== 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;
ffc1db68: 98 08 00 14 stb r0,20(r8) <== NOT EXECUTED
ffc1db6c: 39 4a 00 01 addi r10,r10,1 <== NOT EXECUTED
if (*p == '\0')
ffc1db70: 88 09 00 00 lbz r0,0(r9) <== NOT EXECUTED
ffc1db74: 2f 80 00 00 cmpwi cr7,r0,0 <== NOT EXECUTED
ffc1db78: 41 9e 02 84 beq- cr7,ffc1ddfc <msdos_dir_read+0x464> <== NOT EXECUTED
break;
switch (q)
ffc1db7c: 2f 8b 00 04 cmpwi cr7,r11,4 <== NOT EXECUTED
ffc1db80: 41 9e 00 10 beq- cr7,ffc1db90 <msdos_dir_read+0x1f8> <== NOT EXECUTED
ffc1db84: 2f 8b 00 0a cmpwi cr7,r11,10 <== NOT EXECUTED
ffc1db88: 40 be 00 18 bne+ cr7,ffc1dba0 <msdos_dir_read+0x208> <== NOT EXECUTED
ffc1db8c: 48 00 00 0c b ffc1db98 <msdos_dir_read+0x200> <== NOT EXECUTED
{
case 4:
p += 5;
ffc1db90: 39 29 00 05 addi r9,r9,5 <== NOT EXECUTED
break;
ffc1db94: 48 00 00 10 b ffc1dba4 <msdos_dir_read+0x20c> <== NOT EXECUTED
case 10:
p += 4;
ffc1db98: 39 29 00 04 addi r9,r9,4 <== NOT EXECUTED
break;
ffc1db9c: 48 00 00 08 b ffc1dba4 <msdos_dir_read+0x20c> <== NOT EXECUTED
default:
p += 2;
ffc1dba0: 39 29 00 02 addi r9,r9,2 <== 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++)
ffc1dba4: 39 6b 00 01 addi r11,r11,1 <== NOT EXECUTED
ffc1dba8: 42 00 ff ac bdnz+ ffc1db54 <msdos_dir_read+0x1bc> <== NOT EXECUTED
ffc1dbac: 48 00 02 50 b ffc1ddfc <msdos_dir_read+0x464> <== NOT EXECUTED
fat_dir_pos_t dir_pos;
/*
* Skip active entries until get the entry to start from.
*/
if (start)
ffc1dbb0: 2f 96 00 00 cmpwi cr7,r22,0 <== NOT EXECUTED
ffc1dbb4: 41 9e 00 0c beq- cr7,ffc1dbc0 <msdos_dir_read+0x228> <== NOT EXECUTED
{
lfn_start = FAT_FILE_SHORT_NAME;
start--;
ffc1dbb8: 3a d6 ff ff addi r22,r22,-1 <== NOT EXECUTED
ffc1dbbc: 48 00 02 4c b ffc1de08 <msdos_dir_read+0x470> <== 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,
ffc1dbc0: 80 7e 00 2c lwz r3,44(r30) <== NOT EXECUTED
ffc1dbc4: 7f 04 c3 78 mr r4,r24 <== NOT EXECUTED
ffc1dbc8: 38 a0 00 01 li r5,1 <== NOT EXECUTED
ffc1dbcc: 91 21 01 3c stw r9,316(r1) <== NOT EXECUTED
ffc1dbd0: 7f 26 cb 78 mr r6,r25 <== NOT EXECUTED
ffc1dbd4: 38 e1 00 08 addi r7,r1,8 <== NOT EXECUTED
ffc1dbd8: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc1dbdc: 4b ff 66 e1 bl ffc142bc <fat_file_ioctl> <== NOT EXECUTED
j * bts2rd, &cur_cln);
if (rc != RC_OK)
ffc1dbe0: 81 21 01 3c lwz r9,316(r1) <== NOT EXECUTED
ffc1dbe4: 7c 60 1b 79 mr. r0,r3 <== NOT EXECUTED
ffc1dbe8: 40 82 02 00 bne- ffc1dde8 <msdos_dir_read+0x450> <== NOT EXECUTED
rtems_semaphore_release(fs_info->vol_sema);
return rc;
}
fat_dir_pos_init(&dir_pos);
dir_pos.sname.cln = cur_cln;
ffc1dbec: 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);
ffc1dbf0: 38 81 00 10 addi r4,r1,16 <== NOT EXECUTED
ffc1dbf4: 80 7e 00 2c lwz r3,44(r30) <== NOT EXECUTED
ffc1dbf8: 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;
ffc1dbfc: 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);
ffc1dc00: 91 21 01 3c stw r9,316(r1) <== NOT EXECUTED
ffc1dc04: 92 41 00 18 stw r18,24(r1) <== NOT EXECUTED
dir_pos->lname.ofs = FAT_FILE_SHORT_NAME;
ffc1dc08: 92 41 00 1c stw r18,28(r1) <== NOT EXECUTED
return rc;
}
fat_dir_pos_init(&dir_pos);
dir_pos.sname.cln = cur_cln;
dir_pos.sname.ofs = i;
ffc1dc0c: 93 81 00 14 stw r28,20(r1) <== NOT EXECUTED
rc = fat_file_open(iop->pathinfo.mt_entry, &dir_pos, &tmp_fat_fd);
ffc1dc10: 4b ff 61 cd bl ffc13ddc <fat_file_open> <== NOT EXECUTED
if (rc != RC_OK)
ffc1dc14: 7c 60 1b 79 mr. r0,r3 <== NOT EXECUTED
ffc1dc18: 81 21 01 3c lwz r9,316(r1) <== NOT EXECUTED
ffc1dc1c: 40 82 01 cc bne- ffc1dde8 <msdos_dir_read+0x450> <== 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)
ffc1dc20: 2f 9d ff ff cmpwi cr7,r29,-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;
ffc1dc24: 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;
ffc1dc28: 93 61 00 2c stw r27,44(r1) <== NOT EXECUTED
tmp_dirent.d_reclen = sizeof(struct dirent);
tmp_dirent.d_ino = tmp_fat_fd->ino;
ffc1dc2c: 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;
ffc1dc30: 92 c1 00 28 stw r22,40(r1) <== NOT EXECUTED
tmp_dirent.d_reclen = sizeof(struct dirent);
ffc1dc34: b2 01 00 30 sth r16,48(r1) <== NOT EXECUTED
tmp_dirent.d_ino = tmp_fat_fd->ino;
ffc1dc38: 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)
ffc1dc3c: 41 9e 00 64 beq- cr7,ffc1dca0 <msdos_dir_read+0x308> <== 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;
ffc1dc40: 38 c0 00 0b li r6,11 <== NOT EXECUTED
ffc1dc44: 7c c9 03 a6 mtctr r6 <== 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)
ffc1dc48: 39 60 00 00 li r11,0 <== NOT EXECUTED
ffc1dc4c: 38 00 00 00 li r0,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;
ffc1dc50: 70 07 00 01 andi. r7,r0,1 <== NOT EXECUTED
ffc1dc54: 39 40 00 00 li r10,0 <== NOT EXECUTED
ffc1dc58: 41 82 00 08 beq- ffc1dc60 <msdos_dir_read+0x2c8> <== NOT EXECUTED
ffc1dc5c: 39 40 00 80 li r10,128 <== NOT EXECUTED
ffc1dc60: 7d 09 58 ae lbzx r8,r9,r11 <== NOT EXECUTED
ffc1dc64: 54 00 f8 7e rlwinm r0,r0,31,1,31 <== NOT EXECUTED
{
uint8_t cs = 0;
uint8_t* p = (uint8_t*) entry;
int i;
for (i = 0; i < 11; i++, p++)
ffc1dc68: 39 6b 00 01 addi r11,r11,1 <== NOT EXECUTED
cs = ((cs & 1) ? 0x80 : 0) + (cs >> 1) + *p;
ffc1dc6c: 7c 08 02 14 add r0,r8,r0 <== NOT EXECUTED
ffc1dc70: 7c 00 52 14 add r0,r0,r10 <== NOT EXECUTED
ffc1dc74: 54 00 06 3e clrlwi r0,r0,24 <== NOT EXECUTED
{
uint8_t cs = 0;
uint8_t* p = (uint8_t*) entry;
int i;
for (i = 0; i < 11; i++, p++)
ffc1dc78: 42 00 ff d8 bdnz+ ffc1dc50 <msdos_dir_read+0x2b8> <== NOT EXECUTED
cs = ((cs & 1) ? 0x80 : 0) + (cs >> 1) + *p;
if (lfn_entries || (lfn_checksum != cs))
ffc1dc7c: 2f 9a 00 00 cmpwi cr7,r26,0 <== NOT EXECUTED
const char *src_tmp;
/*
* find last non-blank character of base name
*/
for ((i = MSDOS_SHORT_BASE_LEN ,
ffc1dc80: 39 60 00 08 li r11,8 <== 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))
ffc1dc84: 40 9e 00 20 bne- cr7,ffc1dca4 <msdos_dir_read+0x30c> <== NOT EXECUTED
ffc1dc88: 7f 95 00 00 cmpw cr7,r21,r0 <== NOT EXECUTED
ffc1dc8c: 40 be 00 18 bne+ cr7,ffc1dca4 <msdos_dir_read+0x30c> <== NOT EXECUTED
ffc1dc90: 48 00 01 b4 b ffc1de44 <msdos_dir_read+0x4ac> <== NOT EXECUTED
*/
for ((i = MSDOS_SHORT_BASE_LEN ,
src_tmp = src + MSDOS_SHORT_BASE_LEN-1);
((i > 0) &&
(*src_tmp == ' '));
i--,src_tmp--)
ffc1dc94: 39 6b ff ff addi r11,r11,-1 <== NOT EXECUTED
const char *src_tmp;
/*
* find last non-blank character of base name
*/
for ((i = MSDOS_SHORT_BASE_LEN ,
ffc1dc98: 42 00 00 14 bdnz- ffc1dcac <msdos_dir_read+0x314> <== NOT EXECUTED
ffc1dc9c: 48 00 00 20 b ffc1dcbc <msdos_dir_read+0x324> <== NOT EXECUTED
ffc1dca0: 39 60 00 08 li r11,8 <== NOT EXECUTED
ffc1dca4: 39 00 00 08 li r8,8 <== NOT EXECUTED
ffc1dca8: 7d 09 03 a6 mtctr r8 <== 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)
ffc1dcac: 7d 49 5a 14 add r10,r9,r11 <== 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) &&
ffc1dcb0: 88 0a ff ff lbz r0,-1(r10) <== NOT EXECUTED
ffc1dcb4: 2f 80 00 20 cmpwi cr7,r0,32 <== NOT EXECUTED
ffc1dcb8: 41 9e ff dc beq+ cr7,ffc1dc94 <msdos_dir_read+0x2fc> <== NOT EXECUTED
ffc1dcbc: 2f 8b 00 00 cmpwi cr7,r11,0 <== NOT EXECUTED
* copy base name to destination
*/
src_tmp = src;
len = i;
while (i-- > 0) {
*dst++ = tolower((unsigned char)(*src_tmp++));
ffc1dcc0: 80 f1 27 ec lwz r7,10220(r17) <== NOT EXECUTED
ffc1dcc4: 39 40 00 00 li r10,0 <== 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)
ffc1dcc8: 38 0b 00 01 addi r0,r11,1 <== NOT EXECUTED
ffc1dccc: 40 bc 00 38 bge+ cr7,ffc1dd04 <msdos_dir_read+0x36c> <== NOT EXECUTED
ffc1dcd0: 38 00 00 01 li r0,1 <== NOT EXECUTED
ffc1dcd4: 48 00 00 30 b ffc1dd04 <msdos_dir_read+0x36c> <== NOT EXECUTED
* copy base name to destination
*/
src_tmp = src;
len = i;
while (i-- > 0) {
*dst++ = tolower((unsigned char)(*src_tmp++));
ffc1dcd8: 7d 09 50 ae lbzx r8,r9,r10 <== NOT EXECUTED
ffc1dcdc: 7c c7 42 14 add r6,r7,r8 <== NOT EXECUTED
ffc1dce0: 88 c6 00 01 lbz r6,1(r6) <== NOT EXECUTED
ffc1dce4: 54 c6 07 be clrlwi r6,r6,30 <== NOT EXECUTED
ffc1dce8: 2f 86 00 01 cmpwi cr7,r6,1 <== NOT EXECUTED
ffc1dcec: 40 be 00 08 bne+ cr7,ffc1dcf4 <msdos_dir_read+0x35c> <== NOT EXECUTED
ffc1dcf0: 39 08 00 20 addi r8,r8,32 <== 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)
ffc1dcf4: 38 a1 00 20 addi r5,r1,32 <== NOT EXECUTED
ffc1dcf8: 7c c5 52 14 add r6,r5,r10 <== NOT EXECUTED
* copy base name to destination
*/
src_tmp = src;
len = i;
while (i-- > 0) {
*dst++ = tolower((unsigned char)(*src_tmp++));
ffc1dcfc: 99 06 00 14 stb r8,20(r6) <== NOT EXECUTED
ffc1dd00: 39 4a 00 01 addi r10,r10,1 <== NOT EXECUTED
/*
* copy base name to destination
*/
src_tmp = src;
len = i;
while (i-- > 0) {
ffc1dd04: 34 00 ff ff addic. r0,r0,-1 <== NOT EXECUTED
ffc1dd08: 40 82 ff d0 bne+ ffc1dcd8 <msdos_dir_read+0x340> <== 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) &&
ffc1dd0c: 89 49 00 0a lbz r10,10(r9) <== 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)
ffc1dd10: 7d 60 58 f8 not r0,r11 <== NOT EXECUTED
ffc1dd14: 7c 00 fe 70 srawi r0,r0,31 <== 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) &&
ffc1dd18: 2f 8a 00 20 cmpwi cr7,r10,32 <== 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)
ffc1dd1c: 7d 60 00 38 and r0,r11,r0 <== NOT EXECUTED
ffc1dd20: 38 a1 00 20 addi r5,r1,32 <== NOT EXECUTED
ffc1dd24: 7d 05 02 14 add r8,r5,r0 <== NOT EXECUTED
ffc1dd28: 39 08 00 14 addi r8,r8,20 <== 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) &&
ffc1dd2c: 40 9e 01 28 bne- cr7,ffc1de54 <msdos_dir_read+0x4bc> <== NOT EXECUTED
ffc1dd30: 89 49 00 09 lbz r10,9(r9) <== NOT EXECUTED
ffc1dd34: 2f 8a 00 20 cmpwi cr7,r10,32 <== NOT EXECUTED
ffc1dd38: 40 9e 01 24 bne- cr7,ffc1de5c <msdos_dir_read+0x4c4> <== NOT EXECUTED
ffc1dd3c: 89 49 00 08 lbz r10,8(r9) <== NOT EXECUTED
ffc1dd40: 2f 8a 00 20 cmpwi cr7,r10,32 <== NOT EXECUTED
ffc1dd44: 41 be 00 4c beq+ cr7,ffc1dd90 <msdos_dir_read+0x3f8> <== NOT EXECUTED
ffc1dd48: 39 40 00 01 li r10,1 <== NOT EXECUTED
ffc1dd4c: 48 00 01 14 b ffc1de60 <msdos_dir_read+0x4c8> <== 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)
ffc1dd50: 7c c9 3a 14 add r6,r9,r7 <== NOT EXECUTED
if (i > 0) {
*dst++ = '.'; /* append dot */
len += i + 1; /* extension + dot */
src_tmp = src + MSDOS_SHORT_BASE_LEN;
while (i-- > 0) {
*dst++ = tolower((unsigned char)(*src_tmp++));
ffc1dd54: 88 c6 00 08 lbz r6,8(r6) <== NOT EXECUTED
ffc1dd58: 7c 64 32 14 add r3,r4,r6 <== NOT EXECUTED
ffc1dd5c: 88 03 00 01 lbz r0,1(r3) <== NOT EXECUTED
ffc1dd60: 54 00 07 be clrlwi r0,r0,30 <== NOT EXECUTED
ffc1dd64: 2f 80 00 01 cmpwi cr7,r0,1 <== NOT EXECUTED
ffc1dd68: 40 be 00 08 bne+ cr7,ffc1dd70 <msdos_dir_read+0x3d8> <== NOT EXECUTED
ffc1dd6c: 38 c6 00 20 addi r6,r6,32 <== NOT EXECUTED
ffc1dd70: 9c c8 00 01 stbu r6,1(r8) <== NOT EXECUTED
ffc1dd74: 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) {
ffc1dd78: 42 00 ff d8 bdnz+ ffc1dd50 <msdos_dir_read+0x3b8> <== 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)
ffc1dd7c: 7d 40 50 f8 not r0,r10 <== NOT EXECUTED
ffc1dd80: 7c 00 fe 70 srawi r0,r0,31 <== NOT EXECUTED
ffc1dd84: 7d 4a 00 38 and r10,r10,r0 <== NOT EXECUTED
ffc1dd88: 7d 05 52 14 add r8,r5,r10 <== NOT EXECUTED
ffc1dd8c: 7d 6b 52 14 add r11,r11,r10 <== NOT EXECUTED
while (i-- > 0) {
*dst++ = tolower((unsigned char)(*src_tmp++));
len++;
}
}
*dst = '\0'; /* terminate string */
ffc1dd90: 99 c8 00 00 stb r14,0(r8) <== 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(
ffc1dd94: 3b a0 ff ff li r29,-1 <== NOT EXECUTED
ffc1dd98: b1 61 00 32 sth r11,50(r1) <== NOT EXECUTED
else
{
tmp_dirent.d_namlen = strlen(tmp_dirent.d_name);
}
memcpy(buffer + cmpltd, &tmp_dirent, sizeof(struct dirent));
ffc1dd9c: 81 01 01 38 lwz r8,312(r1) <== NOT EXECUTED
ffc1dda0: 38 81 00 20 addi r4,r1,32 <== NOT EXECUTED
ffc1dda4: 38 a0 01 18 li r5,280 <== NOT EXECUTED
ffc1dda8: 7c 68 da 14 add r3,r8,r27 <== NOT EXECUTED
ffc1ddac: 48 00 12 61 bl ffc1f00c <memcpy> <== NOT EXECUTED
iop->offset = iop->offset + sizeof(struct dirent);
ffc1ddb0: 81 5e 00 10 lwz r10,16(r30) <== NOT EXECUTED
ffc1ddb4: 81 7e 00 14 lwz r11,20(r30) <== 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);
ffc1ddb8: 80 7e 00 2c lwz r3,44(r30) <== 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);
ffc1ddbc: 31 6b 01 18 addic r11,r11,280 <== NOT EXECUTED
ffc1ddc0: 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);
ffc1ddc4: 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);
ffc1ddc8: 91 5e 00 10 stw r10,16(r30) <== NOT EXECUTED
ffc1ddcc: 91 7e 00 14 stw r11,20(r30) <== 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);
ffc1ddd0: 4b ff 64 35 bl ffc14204 <fat_file_close> <== NOT EXECUTED
if (rc != RC_OK)
ffc1ddd4: 7c 60 1b 79 mr. r0,r3 <== NOT EXECUTED
ffc1ddd8: 40 82 00 10 bne- ffc1dde8 <msdos_dir_read+0x450> <== NOT EXECUTED
}
memcpy(buffer + cmpltd, &tmp_dirent, sizeof(struct dirent));
iop->offset = iop->offset + sizeof(struct dirent);
cmpltd += (sizeof(struct dirent));
ffc1dddc: 3b 7b 01 18 addi r27,r27,280 <== NOT EXECUTED
count -= (sizeof(struct dirent));
ffc1dde0: 3a f7 fe e8 addi r23,r23,-280 <== NOT EXECUTED
ffc1dde4: 48 00 00 18 b ffc1ddfc <msdos_dir_read+0x464> <== NOT EXECUTED
/* inode number extracted, close fat-file */
rc = fat_file_close(iop->pathinfo.mt_entry, tmp_fat_fd);
if (rc != RC_OK)
{
rtems_semaphore_release(fs_info->vol_sema);
ffc1dde8: 80 7f 00 98 lwz r3,152(r31) <== NOT EXECUTED
ffc1ddec: 90 01 01 3c stw r0,316(r1) <== NOT EXECUTED
ffc1ddf0: 4b fe e0 2d bl ffc0be1c <rtems_semaphore_release> <== NOT EXECUTED
return rc;
ffc1ddf4: 80 01 01 3c lwz r0,316(r1) <== NOT EXECUTED
ffc1ddf8: 48 00 00 40 b ffc1de38 <msdos_dir_read+0x4a0> <== NOT EXECUTED
}
}
if (count <= 0)
ffc1ddfc: 2f 97 00 00 cmpwi cr7,r23,0 <== NOT EXECUTED
ffc1de00: 40 be 00 0c bne+ cr7,ffc1de0c <msdos_dir_read+0x474> <== NOT EXECUTED
ffc1de04: 48 00 00 1c b ffc1de20 <msdos_dir_read+0x488> <== 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;
ffc1de08: 3b a0 ff ff li r29,-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)
ffc1de0c: 3b 9c 00 20 addi r28,r28,32 <== NOT EXECUTED
ffc1de10: 48 00 00 08 b ffc1de18 <msdos_dir_read+0x480> <== NOT EXECUTED
* 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),
bts2rd, fs_info->cl_buf);
if (ret < MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
ffc1de14: 3b 80 00 00 li r28,0 <== 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)
ffc1de18: 7f 9c 98 40 cmplw cr7,r28,r19 <== NOT EXECUTED
ffc1de1c: 41 9c fc 90 blt+ cr7,ffc1daac <msdos_dir_read+0x114> <== NOT EXECUTED
ffc1de20: 7f 39 a2 14 add r25,r25,r20 <== 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)
ffc1de24: 2f 97 00 00 cmpwi cr7,r23,0 <== NOT EXECUTED
ffc1de28: 40 9e fc 44 bne+ cr7,ffc1da6c <msdos_dir_read+0xd4> <== NOT EXECUTED
break;
}
j++;
}
rtems_semaphore_release(fs_info->vol_sema);
ffc1de2c: 80 7f 00 98 lwz r3,152(r31) <== NOT EXECUTED
ffc1de30: 4b fe df ed bl ffc0be1c <rtems_semaphore_release> <== NOT EXECUTED
return cmpltd;
ffc1de34: 7f 60 db 78 mr r0,r27 <== NOT EXECUTED
}
ffc1de38: 39 61 01 88 addi r11,r1,392 <== NOT EXECUTED
ffc1de3c: 7c 03 03 78 mr r3,r0 <== NOT EXECUTED
ffc1de40: 4b fe 4c 74 b ffc02ab4 <_restgpr_14_x> <== 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);
ffc1de44: 38 61 00 34 addi r3,r1,52 <== NOT EXECUTED
ffc1de48: 48 00 1f 0d bl ffc1fd54 <strlen> <== NOT EXECUTED
ffc1de4c: b0 61 00 32 sth r3,50(r1) <== NOT EXECUTED
ffc1de50: 4b ff ff 4c b ffc1dd9c <msdos_dir_read+0x404> <== NOT EXECUTED
*dst++ = tolower((unsigned char)(*src_tmp++));
}
/*
* find last non-blank character of extension
*/
for ((i = MSDOS_SHORT_EXT_LEN ,
ffc1de54: 39 40 00 03 li r10,3 <== NOT EXECUTED
ffc1de58: 48 00 00 08 b ffc1de60 <msdos_dir_read+0x4c8> <== NOT EXECUTED
src_tmp = src + MSDOS_SHORT_BASE_LEN+MSDOS_SHORT_EXT_LEN-1);
((i > 0) &&
(*src_tmp == ' '));
i--,src_tmp--)
ffc1de5c: 39 40 00 02 li r10,2 <== NOT EXECUTED
{};
/*
* extension is not empty
*/
if (i > 0) {
*dst++ = '.'; /* append dot */
ffc1de60: 38 a1 00 08 addi r5,r1,8 <== NOT EXECUTED
len += i + 1; /* extension + dot */
src_tmp = src + MSDOS_SHORT_BASE_LEN;
while (i-- > 0) {
*dst++ = tolower((unsigned char)(*src_tmp++));
ffc1de64: 80 91 27 ec lwz r4,10220(r17) <== NOT EXECUTED
{};
/*
* extension is not empty
*/
if (i > 0) {
*dst++ = '.'; /* append dot */
ffc1de68: 7c e5 02 14 add r7,r5,r0 <== NOT EXECUTED
len += i + 1; /* extension + dot */
ffc1de6c: 38 0a 00 01 addi r0,r10,1 <== NOT EXECUTED
{};
/*
* extension is not empty
*/
if (i > 0) {
*dst++ = '.'; /* append dot */
ffc1de70: 99 e7 00 2c stb r15,44(r7) <== NOT EXECUTED
ffc1de74: 38 a8 00 01 addi r5,r8,1 <== NOT EXECUTED
len += i + 1; /* extension + dot */
src_tmp = src + MSDOS_SHORT_BASE_LEN;
while (i-- > 0) {
*dst++ = tolower((unsigned char)(*src_tmp++));
ffc1de78: 7c 09 03 a6 mtctr r0 <== NOT EXECUTED
/*
* extension is not empty
*/
if (i > 0) {
*dst++ = '.'; /* append dot */
len += i + 1; /* extension + dot */
ffc1de7c: 7d 6b 02 14 add r11,r11,r0 <== NOT EXECUTED
src_tmp = src + MSDOS_SHORT_BASE_LEN;
while (i-- > 0) {
*dst++ = tolower((unsigned char)(*src_tmp++));
ffc1de80: 38 e0 00 00 li r7,0 <== NOT EXECUTED
ffc1de84: 4b ff fe f4 b ffc1dd78 <msdos_dir_read+0x3e0> <== NOT EXECUTED
ffc1dffc <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)
{
ffc1dffc: 94 21 ff d8 stwu r1,-40(r1) <== NOT EXECUTED
ffc1e000: 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,
ffc1e004: 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)
{
ffc1e008: 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;
ffc1e00c: 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;
ffc1e010: 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)
{
ffc1e014: bf 81 00 18 stmw r28,24(r1) <== NOT EXECUTED
ffc1e018: 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 = pathloc->mt_entry->fs_info;
ffc1e01c: 83 e9 00 34 lwz r31,52(r9) <== NOT EXECUTED
fat_file_fd_t *fat_fd = pathloc->node_access;
ffc1e020: 83 a4 00 00 lwz r29,0(r4) <== NOT EXECUTED
bool is_empty = false;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
ffc1e024: 38 80 00 00 li r4,0 <== NOT EXECUTED
ffc1e028: 80 7f 00 98 lwz r3,152(r31) <== 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;
ffc1e02c: 98 01 00 08 stb r0,8(r1) <== NOT EXECUTED
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
ffc1e030: 4b fe dc c1 bl ffc0bcf0 <rtems_semaphore_obtain> <== NOT EXECUTED
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
ffc1e034: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc1e038: 41 be 00 10 beq+ cr7,ffc1e048 <msdos_dir_rmnod+0x4c> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
ffc1e03c: 48 00 01 9d bl ffc1e1d8 <__errno> <== NOT EXECUTED
ffc1e040: 38 00 00 05 li r0,5 <== NOT EXECUTED
ffc1e044: 48 00 00 20 b ffc1e064 <msdos_dir_rmnod+0x68> <== 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)
ffc1e048: 80 1d 00 08 lwz r0,8(r29) <== NOT EXECUTED
ffc1e04c: 2b 80 00 01 cmplwi cr7,r0,1 <== NOT EXECUTED
ffc1e050: 40 bd 00 20 ble+ cr7,ffc1e070 <msdos_dir_rmnod+0x74> <== NOT EXECUTED
{
rtems_semaphore_release(fs_info->vol_sema);
ffc1e054: 80 7f 00 98 lwz r3,152(r31) <== NOT EXECUTED
ffc1e058: 4b fe dd c5 bl ffc0be1c <rtems_semaphore_release> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EBUSY);
ffc1e05c: 48 00 01 7d bl ffc1e1d8 <__errno> <== NOT EXECUTED
ffc1e060: 38 00 00 10 li r0,16 <== NOT EXECUTED
ffc1e064: 90 03 00 00 stw r0,0(r3) <== NOT EXECUTED
ffc1e068: 3b 80 ff ff li r28,-1 <== NOT EXECUTED
ffc1e06c: 48 00 00 78 b ffc1e0e4 <msdos_dir_rmnod+0xe8> <== NOT EXECUTED
}
/*
* You cannot remove a node that still has children
*/
rc = msdos_dir_is_empty(pathloc->mt_entry, fat_fd, &is_empty);
ffc1e070: 80 7e 00 10 lwz r3,16(r30) <== NOT EXECUTED
ffc1e074: 7f a4 eb 78 mr r4,r29 <== NOT EXECUTED
ffc1e078: 38 a1 00 08 addi r5,r1,8 <== NOT EXECUTED
ffc1e07c: 4b ff ce dd bl ffc1af58 <msdos_dir_is_empty> <== NOT EXECUTED
if (rc != RC_OK)
ffc1e080: 7c 7c 1b 79 mr. r28,r3 <== NOT EXECUTED
ffc1e084: 40 82 00 58 bne- ffc1e0dc <msdos_dir_rmnod+0xe0> <== NOT EXECUTED
{
rtems_semaphore_release(fs_info->vol_sema);
return rc;
}
if (!is_empty)
ffc1e088: 88 01 00 08 lbz r0,8(r1) <== NOT EXECUTED
ffc1e08c: 2f 80 00 00 cmpwi cr7,r0,0 <== NOT EXECUTED
ffc1e090: 40 be 00 18 bne+ cr7,ffc1e0a8 <msdos_dir_rmnod+0xac> <== NOT EXECUTED
{
rtems_semaphore_release(fs_info->vol_sema);
ffc1e094: 80 7f 00 98 lwz r3,152(r31) <== NOT EXECUTED
ffc1e098: 4b fe dd 85 bl ffc0be1c <rtems_semaphore_release> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(ENOTEMPTY);
ffc1e09c: 48 00 01 3d bl ffc1e1d8 <__errno> <== NOT EXECUTED
ffc1e0a0: 38 00 00 5a li r0,90 <== NOT EXECUTED
ffc1e0a4: 4b ff ff c0 b ffc1e064 <msdos_dir_rmnod+0x68> <== NOT EXECUTED
ffc1e0a8: 80 7e 00 10 lwz r3,16(r30) <== NOT EXECUTED
}
/*
* You cannot remove the file system root node.
*/
if (rtems_filesystem_is_root_location(pathloc))
ffc1e0ac: 80 1e 00 00 lwz r0,0(r30) <== NOT EXECUTED
ffc1e0b0: 81 23 00 1c lwz r9,28(r3) <== NOT EXECUTED
ffc1e0b4: 7f 89 00 00 cmpw cr7,r9,r0 <== NOT EXECUTED
ffc1e0b8: 41 be ff 9c beq- cr7,ffc1e054 <msdos_dir_rmnod+0x58> <== 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,
ffc1e0bc: 38 9d 00 20 addi r4,r29,32 <== NOT EXECUTED
ffc1e0c0: 38 a0 00 e5 li r5,229 <== NOT EXECUTED
ffc1e0c4: 4b ff cd 71 bl ffc1ae34 <msdos_set_first_char4file_name><== NOT EXECUTED
MSDOS_THIS_DIR_ENTRY_EMPTY);
if (rc != RC_OK)
ffc1e0c8: 7c 7c 1b 79 mr. r28,r3 <== NOT EXECUTED
ffc1e0cc: 40 82 00 10 bne- ffc1e0dc <msdos_dir_rmnod+0xe0> <== NOT EXECUTED
{
rtems_semaphore_release(fs_info->vol_sema);
return rc;
}
fat_file_mark_removed(pathloc->mt_entry, fat_fd);
ffc1e0d0: 80 7e 00 10 lwz r3,16(r30) <== NOT EXECUTED
ffc1e0d4: 7f a4 eb 78 mr r4,r29 <== NOT EXECUTED
ffc1e0d8: 4b ff 66 b1 bl ffc14788 <fat_file_mark_removed> <== NOT EXECUTED
rtems_semaphore_release(fs_info->vol_sema);
ffc1e0dc: 80 7f 00 98 lwz r3,152(r31) <== NOT EXECUTED
ffc1e0e0: 4b fe dd 3d bl ffc0be1c <rtems_semaphore_release> <== NOT EXECUTED
return rc;
}
ffc1e0e4: 39 61 00 28 addi r11,r1,40 <== NOT EXECUTED
ffc1e0e8: 7f 83 e3 78 mr r3,r28 <== NOT EXECUTED
ffc1e0ec: 4b fe 4a 00 b ffc02aec <_restgpr_28_x> <== NOT EXECUTED
ffc1ded0 <msdos_dir_stat>:
int
msdos_dir_stat(
rtems_filesystem_location_info_t *loc,
struct stat *buf
)
{
ffc1ded0: 94 21 ff e8 stwu r1,-24(r1)
ffc1ded4: 7c 08 02 a6 mflr r0
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,
ffc1ded8: 38 a0 00 00 li r5,0
int
msdos_dir_stat(
rtems_filesystem_location_info_t *loc,
struct stat *buf
)
{
ffc1dedc: 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;
ffc1dee0: 81 23 00 10 lwz r9,16(r3)
int
msdos_dir_stat(
rtems_filesystem_location_info_t *loc,
struct stat *buf
)
{
ffc1dee4: bf a1 00 0c stmw r29,12(r1)
ffc1dee8: 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,
ffc1deec: 38 80 00 00 li r4,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;
ffc1def0: 83 c9 00 34 lwz r30,52(r9)
fat_file_fd_t *fat_fd = loc->node_access;
ffc1def4: 83 a3 00 00 lwz r29,0(r3)
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
ffc1def8: 80 7e 00 98 lwz r3,152(r30)
ffc1defc: 4b fe dd f5 bl ffc0bcf0 <rtems_semaphore_obtain>
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
ffc1df00: 2c 03 00 00 cmpwi r3,0
ffc1df04: 41 a2 00 18 beq+ ffc1df1c <msdos_dir_stat+0x4c> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one(EIO);
ffc1df08: 48 00 02 d1 bl ffc1e1d8 <__errno> <== NOT EXECUTED
ffc1df0c: 38 00 00 05 li r0,5 <== NOT EXECUTED
ffc1df10: 90 03 00 00 stw r0,0(r3) <== NOT EXECUTED
ffc1df14: 38 60 ff ff li r3,-1 <== NOT EXECUTED
ffc1df18: 48 00 00 64 b ffc1df7c <msdos_dir_stat+0xac> <== NOT EXECUTED
buf->st_dev = fs_info->fat.vol.dev;
buf->st_ino = fat_fd->ino;
ffc1df1c: 80 1d 00 0c lwz r0,12(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;
ffc1df20: 81 5e 00 58 lwz r10,88(r30)
ffc1df24: 81 7e 00 5c lwz r11,92(r30)
buf->st_ino = fat_fd->ino;
ffc1df28: 90 1f 00 08 stw r0,8(r31)
buf->st_mode = S_IFDIR | S_IRWXU | S_IRWXG | S_IRWXO;
ffc1df2c: 38 00 41 ff li r0,16895
ffc1df30: 90 1f 00 0c stw r0,12(r31)
buf->st_rdev = 0ll;
buf->st_size = fat_fd->fat_file_size;
ffc1df34: 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;
ffc1df38: 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;
ffc1df3c: 39 40 00 00 li r10,0
buf->st_size = fat_fd->fat_file_size;
ffc1df40: 90 1f 00 24 stw r0,36(r31)
buf->st_blocks = fat_fd->fat_file_size >> FAT_SECTOR512_BITS;
ffc1df44: 54 00 ba 7e rlwinm r0,r0,23,9,31
ffc1df48: 90 1f 00 44 stw r0,68(r31)
buf->st_blksize = fs_info->fat.vol.bps;
ffc1df4c: a0 1e 00 00 lhz r0,0(r30)
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;
ffc1df50: 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;
buf->st_rdev = 0ll;
ffc1df54: 39 60 00 00 li r11,0
buf->st_size = fat_fd->fat_file_size;
buf->st_blocks = fat_fd->fat_file_size >> FAT_SECTOR512_BITS;
buf->st_blksize = fs_info->fat.vol.bps;
ffc1df58: 90 1f 00 40 stw r0,64(r31)
buf->st_mtime = fat_fd->mtime;
ffc1df5c: 80 1d 00 40 lwz r0,64(r29)
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;
buf->st_rdev = 0ll;
buf->st_size = fat_fd->fat_file_size;
ffc1df60: 90 7f 00 20 stw r3,32(r31)
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;
buf->st_rdev = 0ll;
ffc1df64: 91 5f 00 18 stw r10,24(r31)
ffc1df68: 91 7f 00 1c stw r11,28(r31)
buf->st_size = fat_fd->fat_file_size;
buf->st_blocks = fat_fd->fat_file_size >> FAT_SECTOR512_BITS;
buf->st_blksize = fs_info->fat.vol.bps;
buf->st_mtime = fat_fd->mtime;
ffc1df6c: 90 1f 00 30 stw r0,48(r31)
rtems_semaphore_release(fs_info->vol_sema);
ffc1df70: 80 7e 00 98 lwz r3,152(r30)
ffc1df74: 4b fe de a9 bl ffc0be1c <rtems_semaphore_release>
return RC_OK;
ffc1df78: 38 60 00 00 li r3,0
}
ffc1df7c: 39 61 00 18 addi r11,r1,24
ffc1df80: 4b fe 4b 70 b ffc02af0 <_restgpr_29_x>
ffc1df84 <msdos_dir_sync>:
* RETURNS:
* RC_OK on success, or -1 if error occured (errno set apropriately).
*/
int
msdos_dir_sync(rtems_libio_t *iop)
{
ffc1df84: 94 21 ff e8 stwu r1,-24(r1) <== NOT EXECUTED
ffc1df88: 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,
ffc1df8c: 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)
{
ffc1df90: 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,
ffc1df94: 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;
ffc1df98: 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)
{
ffc1df9c: bf a1 00 0c stmw r29,12(r1) <== NOT EXECUTED
ffc1dfa0: 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;
ffc1dfa4: 83 c9 00 34 lwz r30,52(r9) <== NOT EXECUTED
int
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;
ffc1dfa8: 83 a3 00 1c lwz r29,28(r3) <== NOT EXECUTED
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
ffc1dfac: 80 7e 00 98 lwz r3,152(r30) <== NOT EXECUTED
ffc1dfb0: 4b fe dd 41 bl ffc0bcf0 <rtems_semaphore_obtain> <== NOT EXECUTED
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
ffc1dfb4: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc1dfb8: 41 be 00 18 beq+ cr7,ffc1dfd0 <msdos_dir_sync+0x4c> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
ffc1dfbc: 48 00 02 1d bl ffc1e1d8 <__errno> <== NOT EXECUTED
ffc1dfc0: 38 00 00 05 li r0,5 <== NOT EXECUTED
ffc1dfc4: 90 03 00 00 stw r0,0(r3) <== NOT EXECUTED
ffc1dfc8: 3b e0 ff ff li r31,-1 <== NOT EXECUTED
ffc1dfcc: 48 00 00 1c b ffc1dfe8 <msdos_dir_sync+0x64> <== NOT EXECUTED
rc = fat_file_datasync(iop->pathinfo.mt_entry, fat_fd);
ffc1dfd0: 80 7f 00 2c lwz r3,44(r31) <== NOT EXECUTED
ffc1dfd4: 7f a4 eb 78 mr r4,r29 <== NOT EXECUTED
ffc1dfd8: 4b ff 68 09 bl ffc147e0 <fat_file_datasync> <== NOT EXECUTED
ffc1dfdc: 7c 7f 1b 78 mr r31,r3 <== NOT EXECUTED
rtems_semaphore_release(fs_info->vol_sema);
ffc1dfe0: 80 7e 00 98 lwz r3,152(r30) <== NOT EXECUTED
ffc1dfe4: 4b fe de 39 bl ffc0be1c <rtems_semaphore_release> <== NOT EXECUTED
return rc;
}
ffc1dfe8: 39 61 00 18 addi r11,r1,24 <== NOT EXECUTED
ffc1dfec: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc1dff0: 4b fe 4b 00 b ffc02af0 <_restgpr_29_x> <== NOT EXECUTED
ffc19e4c <msdos_eval4make>:
msdos_eval4make(
const char *path,
rtems_filesystem_location_info_t *pathloc,
const char **name
)
{
ffc19e4c: 94 21 ff b0 stwu r1,-80(r1)
ffc19e50: 7c 08 02 a6 mflr r0
ffc19e54: 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;
ffc19e58: 81 24 00 10 lwz r9,16(r4)
msdos_eval4make(
const char *path,
rtems_filesystem_location_info_t *pathloc,
const char **name
)
{
ffc19e5c: be c1 00 28 stmw r22,40(r1)
ffc19e60: 7c 7c 1b 78 mr r28,r3
ffc19e64: 7c 9f 23 78 mr r31,r4
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = pathloc->mt_entry->fs_info;
ffc19e68: 83 a9 00 34 lwz r29,52(r9)
msdos_eval4make(
const char *path,
rtems_filesystem_location_info_t *pathloc,
const char **name
)
{
ffc19e6c: 7c bb 2b 78 mr r27,r5
int i = 0;
int token_len;
const char *token;
bool done = false;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
ffc19e70: 38 80 00 00 li r4,0
ffc19e74: 80 7d 00 98 lwz r3,152(r29)
ffc19e78: 38 a0 00 00 li r5,0
ffc19e7c: 4b ff 1e 75 bl ffc0bcf0 <rtems_semaphore_obtain>
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
ffc19e80: 2f 83 00 00 cmpwi cr7,r3,0
ffc19e84: 41 be 00 18 beq+ cr7,ffc19e9c <msdos_eval4make+0x50> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one(EIO);
ffc19e88: 48 00 43 51 bl ffc1e1d8 <__errno> <== NOT EXECUTED
ffc19e8c: 38 00 00 05 li r0,5 <== NOT EXECUTED
ffc19e90: 90 03 00 00 stw r0,0(r3) <== NOT EXECUTED
ffc19e94: 3b 40 ff ff li r26,-1 <== NOT EXECUTED
ffc19e98: 48 00 02 1c b ffc1a0b4 <msdos_eval4make+0x268> <== NOT EXECUTED
if (!pathloc->node_access)
ffc19e9c: 80 7f 00 00 lwz r3,0(r31)
ffc19ea0: 2f 83 00 00 cmpwi cr7,r3,0
ffc19ea4: 40 be 00 18 bne+ cr7,ffc19ebc <msdos_eval4make+0x70> <== ALWAYS TAKEN
{
errno = ENOENT;
ffc19ea8: 48 00 43 31 bl ffc1e1d8 <__errno> <== NOT EXECUTED
ffc19eac: 38 00 00 02 li r0,2 <== NOT EXECUTED
ffc19eb0: 90 03 00 00 stw r0,0(r3) <== NOT EXECUTED
rc = -1;
ffc19eb4: 3b 40 ff ff li r26,-1 <== NOT EXECUTED
goto err;
ffc19eb8: 48 00 01 f4 b ffc1a0ac <msdos_eval4make+0x260> <== NOT EXECUTED
}
fat_fd = pathloc->node_access;
rc = fat_file_reopen(fat_fd);
ffc19ebc: 4b ff a0 65 bl ffc13f20 <fat_file_reopen>
if (rc != RC_OK)
ffc19ec0: 7c 7a 1b 79 mr. r26,r3
ffc19ec4: 40 82 01 e8 bne- ffc1a0ac <msdos_eval4make+0x260> <== NEVER TAKEN
ffc19ec8: 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)
ffc19ecc: 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);
ffc19ed0: 7f 1c f2 14 add r24,r28,r30
ffc19ed4: 7f 03 c3 78 mr r3,r24
ffc19ed8: 48 00 5e 7d bl ffc1fd54 <strlen>
ffc19edc: 38 a1 00 08 addi r5,r1,8
ffc19ee0: 7c 64 1b 78 mr r4,r3
ffc19ee4: 38 c1 00 0c addi r6,r1,12
ffc19ee8: 7f 03 c3 78 mr r3,r24
ffc19eec: 48 00 0c 09 bl ffc1aaf4 <msdos_get_token>
i += token_len;
ffc19ef0: 80 a1 00 0c lwz r5,12(r1)
fat_fd = pathloc->node_access;
switch (type)
ffc19ef4: 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;
ffc19ef8: 83 1f 00 00 lwz r24,0(r31)
if (rc != RC_OK)
goto err;
while (!done)
{
type = msdos_get_token(&path[i], strlen(&path[i]), &token, &token_len);
ffc19efc: 7c 77 1b 78 mr r23,r3
i += token_len;
ffc19f00: 7f de 2a 14 add r30,r30,r5
fat_fd = pathloc->node_access;
switch (type)
ffc19f04: 41 9e 00 2c beq- cr7,ffc19f30 <msdos_eval4make+0xe4>
ffc19f08: 2b 83 00 02 cmplwi cr7,r3,2
ffc19f0c: 41 9d 00 10 bgt- cr7,ffc19f1c <msdos_eval4make+0xd0>
ffc19f10: 2f 83 00 00 cmpwi cr7,r3,0
ffc19f14: 41 9e 01 00 beq- cr7,ffc1a014 <msdos_eval4make+0x1c8>
ffc19f18: 4b ff ff b8 b ffc19ed0 <msdos_eval4make+0x84>
ffc19f1c: 2f 83 00 03 cmpwi cr7,r3,3
ffc19f20: 41 9e 00 c8 beq- cr7,ffc19fe8 <msdos_eval4make+0x19c> <== ALWAYS TAKEN
ffc19f24: 2f 83 00 04 cmpwi cr7,r3,4 <== NOT EXECUTED
ffc19f28: 40 9e ff a8 bne+ cr7,ffc19ed0 <msdos_eval4make+0x84> <== NOT EXECUTED
ffc19f2c: 48 00 00 f4 b ffc1a020 <msdos_eval4make+0x1d4> <== NOT EXECUTED
{
case MSDOS_UP_DIR:
/*
* Only a directory can be decended into.
*/
if (fat_fd->fat_file_type != FAT_DIRECTORY)
ffc19f30: 80 18 00 10 lwz r0,16(r24)
ffc19f34: 2f 80 00 01 cmpwi cr7,r0,1
ffc19f38: 40 9e 01 40 bne- cr7,ffc1a078 <msdos_eval4make+0x22c> <== NEVER TAKEN
ffc19f3c: 80 9f 00 10 lwz r4,16(r31)
ffc19f40: 80 04 00 1c lwz r0,28(r4)
}
/*
* Am I at the root of this mounted filesystem?
*/
if (rtems_filesystem_is_root_location(pathloc))
ffc19f44: 7f 80 c0 00 cmpw cr7,r0,r24
ffc19f48: 40 be 00 74 bne+ cr7,ffc19fbc <msdos_eval4make+0x170> <== NEVER TAKEN
/*
* 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)
ffc19f4c: 81 39 27 dc lwz r9,10204(r25)
{
/*
* Am I at the root of all filesystems?
* XXX: MSDOS is not supposed to be base fs.
*/
if (pathloc->node_access ==
ffc19f50: 81 29 00 18 lwz r9,24(r9)
ffc19f54: 7f 80 48 00 cmpw cr7,r0,r9
ffc19f58: 41 9e ff 78 beq+ cr7,ffc19ed0 <msdos_eval4make+0x84> <== ALWAYS TAKEN
{
break; /* Throw out the .. in this case */
}
else
{
newloc = pathloc->mt_entry->mt_point_node;
ffc19f5c: 39 61 00 10 addi r11,r1,16 <== NOT EXECUTED
ffc19f60: 38 84 00 08 addi r4,r4,8 <== NOT EXECUTED
ffc19f64: 7c a4 a4 aa lswi r5,r4,20 <== NOT EXECUTED
ffc19f68: 7c ab a5 aa stswi r5,r11,20 <== NOT EXECUTED
*pathloc = newloc;
rc = fat_file_close(pathloc->mt_entry, fat_fd);
ffc19f6c: 7c 04 03 78 mr r4,r0 <== NOT EXECUTED
break; /* Throw out the .. in this case */
}
else
{
newloc = pathloc->mt_entry->mt_point_node;
*pathloc = newloc;
ffc19f70: 7c ab a4 aa lswi r5,r11,20 <== NOT EXECUTED
ffc19f74: 7c bf a5 aa stswi r5,r31,20 <== NOT EXECUTED
rc = fat_file_close(pathloc->mt_entry, fat_fd);
ffc19f78: 80 7f 00 10 lwz r3,16(r31) <== NOT EXECUTED
ffc19f7c: 4b ff a2 89 bl ffc14204 <fat_file_close> <== NOT EXECUTED
if (rc != RC_OK)
ffc19f80: 7c 7a 1b 79 mr. r26,r3 <== NOT EXECUTED
ffc19f84: 40 a2 01 28 bne+ ffc1a0ac <msdos_eval4make+0x260> <== NOT EXECUTED
goto err;
rtems_semaphore_release(fs_info->vol_sema);
ffc19f88: 80 7d 00 98 lwz r3,152(r29) <== NOT EXECUTED
ffc19f8c: 4b ff 1e 91 bl ffc0be1c <rtems_semaphore_release> <== NOT EXECUTED
return (*pathloc->ops->evalformake_h)(&path[i-token_len],
ffc19f90: 80 01 00 0c lwz r0,12(r1) <== NOT EXECUTED
ffc19f94: 81 3f 00 0c lwz r9,12(r31) <== NOT EXECUTED
ffc19f98: 7f e4 fb 78 mr r4,r31 <== NOT EXECUTED
ffc19f9c: 7f c0 f0 50 subf r30,r0,r30 <== NOT EXECUTED
ffc19fa0: 80 09 00 04 lwz r0,4(r9) <== NOT EXECUTED
ffc19fa4: 7c 7c f2 14 add r3,r28,r30 <== NOT EXECUTED
ffc19fa8: 7f 65 db 78 mr r5,r27 <== NOT EXECUTED
ffc19fac: 7c 09 03 a6 mtctr r0 <== NOT EXECUTED
ffc19fb0: 4e 80 04 21 bctrl <== NOT EXECUTED
ffc19fb4: 7c 7a 1b 78 mr r26,r3 <== NOT EXECUTED
ffc19fb8: 48 00 00 fc b ffc1a0b4 <msdos_eval4make+0x268> <== NOT EXECUTED
pathloc, name);
}
}
else
{
rc = msdos_find_name(pathloc, token, token_len);
ffc19fbc: 80 81 00 08 lwz r4,8(r1) <== NOT EXECUTED
ffc19fc0: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc19fc4: 48 00 1d f5 bl ffc1bdb8 <msdos_find_name> <== NOT EXECUTED
if (rc != RC_OK)
ffc19fc8: 7c 76 1b 79 mr. r22,r3 <== NOT EXECUTED
ffc19fcc: 41 82 ff 04 beq+ ffc19ed0 <msdos_eval4make+0x84> <== NOT EXECUTED
{
if (rc == MSDOS_NAME_NOT_FOUND_ERR)
ffc19fd0: 2f 96 7d 01 cmpwi cr7,r22,32001 <== NOT EXECUTED
ffc19fd4: 40 be 00 c8 bne+ cr7,ffc1a09c <msdos_eval4make+0x250> <== NOT EXECUTED
{
errno = ENOENT;
ffc19fd8: 48 00 42 01 bl ffc1e1d8 <__errno> <== NOT EXECUTED
ffc19fdc: 92 e3 00 00 stw r23,0(r3) <== NOT EXECUTED
rc = -1;
ffc19fe0: 3a c0 ff ff li r22,-1
ffc19fe4: 48 00 00 b8 b ffc1a09c <msdos_eval4make+0x250>
case MSDOS_NAME:
/*
* Only a directory can be decended into.
*/
if (fat_fd->fat_file_type != FAT_DIRECTORY)
ffc19fe8: 80 18 00 10 lwz r0,16(r24)
ffc19fec: 2f 80 00 01 cmpwi cr7,r0,1
ffc19ff0: 40 9e 00 88 bne- cr7,ffc1a078 <msdos_eval4make+0x22c>
/*
* 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);
ffc19ff4: 80 81 00 08 lwz r4,8(r1)
ffc19ff8: 7f e3 fb 78 mr r3,r31
ffc19ffc: 48 00 1d bd bl ffc1bdb8 <msdos_find_name>
if (rc)
ffc1a000: 2c 03 00 00 cmpwi r3,0
ffc1a004: 41 a2 fe cc beq- ffc19ed0 <msdos_eval4make+0x84>
{
if (rc != MSDOS_NAME_NOT_FOUND_ERR)
ffc1a008: 2f 83 7d 01 cmpwi cr7,r3,32001
ffc1a00c: 41 be 00 20 beq+ cr7,ffc1a02c <msdos_eval4make+0x1e0> <== ALWAYS TAKEN
ffc1a010: 48 00 00 3c b ffc1a04c <msdos_eval4make+0x200> <== NOT EXECUTED
done = true;
}
break;
case MSDOS_NO_MORE_PATH:
errno = EEXIST;
ffc1a014: 48 00 41 c5 bl ffc1e1d8 <__errno>
ffc1a018: 38 00 00 11 li r0,17
ffc1a01c: 48 00 00 64 b ffc1a080 <msdos_eval4make+0x234>
case MSDOS_CURRENT_DIR:
break;
case MSDOS_INVALID_TOKEN:
errno = ENAMETOOLONG;
ffc1a020: 48 00 41 b9 bl ffc1e1d8 <__errno> <== NOT EXECUTED
ffc1a024: 38 00 00 5b li r0,91 <== NOT EXECUTED
ffc1a028: 48 00 00 58 b ffc1a080 <msdos_eval4make+0x234> <== NOT EXECUTED
break;
}
}
*name = &path[i - token_len];
ffc1a02c: 80 01 00 0c lwz r0,12(r1)
ffc1a030: 7c 00 f0 50 subf r0,r0,r30
ffc1a034: 7c 1c 02 14 add r0,r28,r0
ffc1a038: 90 1b 00 00 stw r0,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++)
ffc1a03c: 48 00 00 20 b ffc1a05c <msdos_eval4make+0x210>
{
if (!msdos_is_separator(path[i]))
ffc1a040: 4b fe f1 b5 bl ffc091f4 <rtems_filesystem_is_separator>
ffc1a044: 2f 83 00 00 cmpwi cr7,r3,0
ffc1a048: 40 be 00 10 bne+ cr7,ffc1a058 <msdos_eval4make+0x20c>
{
errno = ENOENT;
ffc1a04c: 48 00 41 8d bl ffc1e1d8 <__errno>
ffc1a050: 38 00 00 02 li r0,2
ffc1a054: 48 00 00 2c b ffc1a080 <msdos_eval4make+0x234>
/*
* 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++)
ffc1a058: 3b de 00 01 addi r30,r30,1
ffc1a05c: 7c 7c f0 ae lbzx r3,r28,r30
ffc1a060: 2f 83 00 00 cmpwi cr7,r3,0
ffc1a064: 40 9e ff dc bne+ cr7,ffc1a040 <msdos_eval4make+0x1f4>
rc = -1;
goto error;
}
}
fat_fd = pathloc->node_access;
ffc1a068: 83 1f 00 00 lwz r24,0(r31)
if (fat_fd->fat_file_type != FAT_DIRECTORY)
ffc1a06c: 80 18 00 10 lwz r0,16(r24)
ffc1a070: 2f 80 00 01 cmpwi cr7,r0,1
ffc1a074: 41 9e 00 14 beq- cr7,ffc1a088 <msdos_eval4make+0x23c> <== ALWAYS TAKEN
{
errno = ENOTDIR;
ffc1a078: 48 00 41 61 bl ffc1e1d8 <__errno>
ffc1a07c: 38 00 00 14 li r0,20
ffc1a080: 90 03 00 00 stw r0,0(r3)
ffc1a084: 4b ff ff 5c b ffc19fe0 <msdos_eval4make+0x194>
* None
*/
static void
msdos_set_handlers(rtems_filesystem_location_info_t *loc)
{
msdos_fs_info_t *fs_info = loc->mt_entry->fs_info;
ffc1a088: 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)
loc->handlers = fs_info->directory_handlers;
ffc1a08c: 81 29 00 34 lwz r9,52(r9)
ffc1a090: 80 09 00 90 lwz r0,144(r9)
ffc1a094: 90 1f 00 08 stw r0,8(r31)
ffc1a098: 48 00 00 14 b ffc1a0ac <msdos_eval4make+0x260>
rtems_semaphore_release(fs_info->vol_sema);
return RC_OK;
error:
fat_file_close(pathloc->mt_entry, fat_fd);
ffc1a09c: 80 7f 00 10 lwz r3,16(r31)
ffc1a0a0: 7f 04 c3 78 mr r4,r24
ffc1a0a4: 7e da b3 78 mr r26,r22
ffc1a0a8: 4b ff a1 5d bl ffc14204 <fat_file_close>
err:
rtems_semaphore_release(fs_info->vol_sema);
ffc1a0ac: 80 7d 00 98 lwz r3,152(r29)
ffc1a0b0: 4b ff 1d 6d bl ffc0be1c <rtems_semaphore_release>
return rc;
}
ffc1a0b4: 39 61 00 50 addi r11,r1,80
ffc1a0b8: 7f 43 d3 78 mr r3,r26
ffc1a0bc: 4b fe 8a 18 b ffc02ad4 <_restgpr_22_x>
ffc19c14 <msdos_eval_path>:
const char *pathname,
size_t pathnamelen,
int flags,
rtems_filesystem_location_info_t *pathloc
)
{
ffc19c14: 94 21 ff a8 stwu r1,-88(r1)
ffc19c18: 7c 08 02 a6 mflr r0
ffc19c1c: 90 01 00 5c stw r0,92(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;
ffc19c20: 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;
ffc19c24: 81 26 00 10 lwz r9,16(r6)
const char *pathname,
size_t pathnamelen,
int flags,
rtems_filesystem_location_info_t *pathloc
)
{
ffc19c28: be a1 00 2c stmw r21,44(r1)
ffc19c2c: 7c 7b 1b 78 mr r27,r3
ffc19c30: 7c 9d 23 78 mr r29,r4
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = pathloc->mt_entry->fs_info;
ffc19c34: 83 c9 00 34 lwz r30,52(r9)
const char *pathname,
size_t pathnamelen,
int flags,
rtems_filesystem_location_info_t *pathloc
)
{
ffc19c38: 7c ba 2b 78 mr r26,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,
ffc19c3c: 38 80 00 00 li r4,0
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;
ffc19c40: 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,
ffc19c44: 38 a0 00 00 li r5,0
ffc19c48: 80 7e 00 98 lwz r3,152(r30)
const char *pathname,
size_t pathnamelen,
int flags,
rtems_filesystem_location_info_t *pathloc
)
{
ffc19c4c: 7c df 33 78 mr r31,r6
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,
ffc19c50: 4b ff 20 a1 bl ffc0bcf0 <rtems_semaphore_obtain>
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
ffc19c54: 2f 83 00 00 cmpwi cr7,r3,0
ffc19c58: 41 be 00 18 beq+ cr7,ffc19c70 <msdos_eval_path+0x5c> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one(EIO);
ffc19c5c: 48 00 45 7d bl ffc1e1d8 <__errno> <== NOT EXECUTED
ffc19c60: 38 00 00 05 li r0,5 <== NOT EXECUTED
ffc19c64: 90 03 00 00 stw r0,0(r3) <== NOT EXECUTED
ffc19c68: 3b 20 ff ff li r25,-1 <== NOT EXECUTED
ffc19c6c: 48 00 01 d4 b ffc19e40 <msdos_eval_path+0x22c> <== NOT EXECUTED
if (!pathloc->node_access)
ffc19c70: 80 7f 00 00 lwz r3,0(r31)
ffc19c74: 2f 83 00 00 cmpwi cr7,r3,0
ffc19c78: 40 be 00 18 bne+ cr7,ffc19c90 <msdos_eval_path+0x7c> <== ALWAYS TAKEN
{
errno = ENOENT;
ffc19c7c: 48 00 45 5d bl ffc1e1d8 <__errno> <== NOT EXECUTED
ffc19c80: 38 00 00 02 li r0,2 <== NOT EXECUTED
ffc19c84: 90 03 00 00 stw r0,0(r3) <== NOT EXECUTED
rc = -1;
ffc19c88: 3b 20 ff ff li r25,-1 <== NOT EXECUTED
goto err;
ffc19c8c: 48 00 01 ac b ffc19e38 <msdos_eval_path+0x224> <== NOT EXECUTED
}
fat_fd = pathloc->node_access;
rc = fat_file_reopen(fat_fd);
ffc19c90: 4b ff a2 91 bl ffc13f20 <fat_file_reopen>
if (rc != RC_OK)
ffc19c94: 7c 79 1b 79 mr. r25,r3
ffc19c98: 40 82 01 a0 bne- ffc19e38 <msdos_eval_path+0x224> <== NEVER TAKEN
ffc19c9c: 3b 80 00 00 li r28,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)
ffc19ca0: 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);
ffc19ca4: 7c 7b e2 14 add r3,r27,r28
ffc19ca8: 7f a4 eb 78 mr r4,r29
ffc19cac: 38 a1 00 08 addi r5,r1,8
ffc19cb0: 38 c1 00 0c addi r6,r1,12
ffc19cb4: 48 00 0e 41 bl ffc1aaf4 <msdos_get_token>
pathnamelen -= token_len;
ffc19cb8: 80 a1 00 0c lwz r5,12(r1)
i += token_len;
fat_fd = pathloc->node_access;
switch (type)
ffc19cbc: 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;
ffc19cc0: 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);
ffc19cc4: 7c 77 1b 78 mr r23,r3
pathnamelen -= token_len;
ffc19cc8: 7f a5 e8 50 subf r29,r5,r29
i += token_len;
ffc19ccc: 7f 9c 2a 14 add r28,r28,r5
fat_fd = pathloc->node_access;
switch (type)
ffc19cd0: 41 9e 00 d0 beq- cr7,ffc19da0 <msdos_eval_path+0x18c>
ffc19cd4: 2f 83 00 04 cmpwi cr7,r3,4
ffc19cd8: 41 9e 01 08 beq- cr7,ffc19de0 <msdos_eval_path+0x1cc> <== NEVER TAKEN
ffc19cdc: 2f 03 00 02 cmpwi cr6,r3,2
ffc19ce0: 40 ba 01 10 bne+ cr6,ffc19df0 <msdos_eval_path+0x1dc>
{
case MSDOS_UP_DIR:
/*
* Only a directory can be decended into.
*/
if (fat_fd->fat_file_type != FAT_DIRECTORY)
ffc19ce4: 80 16 00 10 lwz r0,16(r22)
ffc19ce8: 2f 80 00 01 cmpwi cr7,r0,1
ffc19cec: 40 9e 00 c0 bne- cr7,ffc19dac <msdos_eval_path+0x198> <== NEVER TAKEN
ffc19cf0: 80 9f 00 10 lwz r4,16(r31)
ffc19cf4: 80 04 00 1c lwz r0,28(r4)
}
/*
* Am I at the root of this mounted filesystem?
*/
if (rtems_filesystem_is_root_location(pathloc))
ffc19cf8: 7f 80 b0 00 cmpw cr7,r0,r22
ffc19cfc: 40 be 00 78 bne+ cr7,ffc19d74 <msdos_eval_path+0x160> <== ALWAYS TAKEN
/*
* 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)
ffc19d00: 81 38 27 dc lwz r9,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 ==
ffc19d04: 81 29 00 18 lwz r9,24(r9) <== NOT EXECUTED
ffc19d08: 7f 80 48 00 cmpw cr7,r0,r9 <== NOT EXECUTED
ffc19d0c: 41 9e ff 98 beq+ cr7,ffc19ca4 <msdos_eval_path+0x90> <== NOT EXECUTED
{
break; /* Throw out the .. in this case */
}
else
{
newloc = pathloc->mt_entry->mt_point_node;
ffc19d10: 39 61 00 10 addi r11,r1,16 <== NOT EXECUTED
ffc19d14: 38 84 00 08 addi r4,r4,8 <== NOT EXECUTED
ffc19d18: 7c a4 a4 aa lswi r5,r4,20 <== NOT EXECUTED
ffc19d1c: 7c ab a5 aa stswi r5,r11,20 <== NOT EXECUTED
*pathloc = newloc;
rc = fat_file_close(pathloc->mt_entry, fat_fd);
ffc19d20: 7c 04 03 78 mr r4,r0 <== NOT EXECUTED
break; /* Throw out the .. in this case */
}
else
{
newloc = pathloc->mt_entry->mt_point_node;
*pathloc = newloc;
ffc19d24: 7c ab a4 aa lswi r5,r11,20 <== NOT EXECUTED
ffc19d28: 7c bf a5 aa stswi r5,r31,20 <== NOT EXECUTED
rc = fat_file_close(pathloc->mt_entry, fat_fd);
ffc19d2c: 80 7f 00 10 lwz r3,16(r31) <== NOT EXECUTED
ffc19d30: 4b ff a4 d5 bl ffc14204 <fat_file_close> <== NOT EXECUTED
if (rc != RC_OK)
ffc19d34: 7c 79 1b 79 mr. r25,r3 <== NOT EXECUTED
ffc19d38: 40 a2 01 00 bne+ ffc19e38 <msdos_eval_path+0x224> <== NOT EXECUTED
goto err;
rtems_semaphore_release(fs_info->vol_sema);
ffc19d3c: 80 7e 00 98 lwz r3,152(r30) <== NOT EXECUTED
ffc19d40: 4b ff 20 dd bl ffc0be1c <rtems_semaphore_release> <== NOT EXECUTED
return (*pathloc->ops->evalpath_h)(&(pathname[i-token_len]),
ffc19d44: 81 3f 00 0c lwz r9,12(r31) <== NOT EXECUTED
ffc19d48: 80 81 00 0c lwz r4,12(r1) <== NOT EXECUTED
ffc19d4c: 7f 45 d3 78 mr r5,r26 <== NOT EXECUTED
ffc19d50: 80 09 00 00 lwz r0,0(r9) <== NOT EXECUTED
ffc19d54: 7f e6 fb 78 mr r6,r31 <== NOT EXECUTED
ffc19d58: 7c 64 e0 50 subf r3,r4,r28 <== NOT EXECUTED
ffc19d5c: 7c 7b 1a 14 add r3,r27,r3 <== NOT EXECUTED
ffc19d60: 7c 09 03 a6 mtctr r0 <== NOT EXECUTED
ffc19d64: 7c 9d 22 14 add r4,r29,r4 <== NOT EXECUTED
ffc19d68: 4e 80 04 21 bctrl <== NOT EXECUTED
ffc19d6c: 7c 79 1b 78 mr r25,r3 <== NOT EXECUTED
ffc19d70: 48 00 00 d0 b ffc19e40 <msdos_eval_path+0x22c> <== NOT EXECUTED
flags, pathloc);
}
}
else
{
rc = msdos_find_name(pathloc, token, token_len);
ffc19d74: 80 81 00 08 lwz r4,8(r1)
ffc19d78: 7f e3 fb 78 mr r3,r31
ffc19d7c: 48 00 20 3d bl ffc1bdb8 <msdos_find_name>
if (rc != RC_OK)
ffc19d80: 7c 75 1b 79 mr. r21,r3
ffc19d84: 41 82 ff 20 beq+ ffc19ca4 <msdos_eval_path+0x90> <== ALWAYS TAKEN
{
if (rc == MSDOS_NAME_NOT_FOUND_ERR)
ffc19d88: 2f 95 7d 01 cmpwi cr7,r21,32001 <== NOT EXECUTED
ffc19d8c: 40 be 00 9c bne+ cr7,ffc19e28 <msdos_eval_path+0x214> <== NOT EXECUTED
{
errno = ENOENT;
ffc19d90: 48 00 44 49 bl ffc1e1d8 <__errno> <== NOT EXECUTED
ffc19d94: 92 e3 00 00 stw r23,0(r3) <== NOT EXECUTED
rc = -1;
ffc19d98: 3a a0 ff ff li r21,-1
ffc19d9c: 48 00 00 8c b ffc19e28 <msdos_eval_path+0x214>
case MSDOS_NAME:
/*
* Only a directory can be decended into.
*/
if (fat_fd->fat_file_type != FAT_DIRECTORY)
ffc19da0: 80 16 00 10 lwz r0,16(r22)
ffc19da4: 2f 80 00 01 cmpwi cr7,r0,1
ffc19da8: 41 be 00 10 beq+ cr7,ffc19db8 <msdos_eval_path+0x1a4>
{
errno = ENOTSUP;
ffc19dac: 48 00 44 2d bl ffc1e1d8 <__errno>
ffc19db0: 38 00 00 86 li r0,134
ffc19db4: 48 00 00 34 b ffc19de8 <msdos_eval_path+0x1d4>
/*
* 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);
ffc19db8: 80 81 00 08 lwz r4,8(r1)
ffc19dbc: 7f e3 fb 78 mr r3,r31
ffc19dc0: 48 00 1f f9 bl ffc1bdb8 <msdos_find_name>
if (rc != RC_OK)
ffc19dc4: 7c 75 1b 79 mr. r21,r3
ffc19dc8: 41 82 fe dc beq+ ffc19ca4 <msdos_eval_path+0x90>
{
if (rc == MSDOS_NAME_NOT_FOUND_ERR)
ffc19dcc: 2f 95 7d 01 cmpwi cr7,r21,32001
ffc19dd0: 40 be 00 58 bne+ cr7,ffc19e28 <msdos_eval_path+0x214>
{
errno = ENOENT;
ffc19dd4: 48 00 44 05 bl ffc1e1d8 <__errno>
ffc19dd8: 38 00 00 02 li r0,2
ffc19ddc: 48 00 00 0c b ffc19de8 <msdos_eval_path+0x1d4>
case MSDOS_NO_MORE_PATH:
case MSDOS_CURRENT_DIR:
break;
case MSDOS_INVALID_TOKEN:
errno = ENAMETOOLONG;
ffc19de0: 48 00 43 f9 bl ffc1e1d8 <__errno> <== NOT EXECUTED
ffc19de4: 38 00 00 5b li r0,91 <== NOT EXECUTED
ffc19de8: 90 03 00 00 stw r0,0(r3)
ffc19dec: 4b ff ff ac b ffc19d98 <msdos_eval_path+0x184>
rc = fat_file_reopen(fat_fd);
if (rc != RC_OK)
goto err;
while ((type != MSDOS_NO_MORE_PATH) && (type != MSDOS_INVALID_TOKEN))
ffc19df0: 2f 03 00 00 cmpwi cr6,r3,0
ffc19df4: 41 9a 00 08 beq- cr6,ffc19dfc <msdos_eval_path+0x1e8>
ffc19df8: 40 9e fe ac bne+ cr7,ffc19ca4 <msdos_eval_path+0x90> <== 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)
ffc19dfc: 81 7f 00 00 lwz r11,0(r31)
* None
*/
static void
msdos_set_handlers(rtems_filesystem_location_info_t *loc)
{
msdos_fs_info_t *fs_info = loc->mt_entry->fs_info;
ffc19e00: 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)
ffc19e04: 80 0b 00 10 lwz r0,16(r11)
* None
*/
static void
msdos_set_handlers(rtems_filesystem_location_info_t *loc)
{
msdos_fs_info_t *fs_info = loc->mt_entry->fs_info;
ffc19e08: 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)
ffc19e0c: 2f 80 00 01 cmpwi cr7,r0,1
ffc19e10: 40 be 00 0c bne+ cr7,ffc19e1c <msdos_eval_path+0x208>
loc->handlers = fs_info->directory_handlers;
ffc19e14: 80 09 00 90 lwz r0,144(r9)
ffc19e18: 48 00 00 08 b ffc19e20 <msdos_eval_path+0x20c>
else
loc->handlers = fs_info->file_handlers;
ffc19e1c: 80 09 00 94 lwz r0,148(r9)
ffc19e20: 90 1f 00 08 stw r0,8(r31)
ffc19e24: 48 00 00 14 b ffc19e38 <msdos_eval_path+0x224>
rtems_semaphore_release(fs_info->vol_sema);
return RC_OK;
error:
fat_file_close(pathloc->mt_entry, fat_fd);
ffc19e28: 80 7f 00 10 lwz r3,16(r31)
ffc19e2c: 7e c4 b3 78 mr r4,r22
ffc19e30: 7e b9 ab 78 mr r25,r21
ffc19e34: 4b ff a3 d1 bl ffc14204 <fat_file_close>
err:
rtems_semaphore_release(fs_info->vol_sema);
ffc19e38: 80 7e 00 98 lwz r3,152(r30)
ffc19e3c: 4b ff 1f e1 bl ffc0be1c <rtems_semaphore_release>
return rc;
}
ffc19e40: 39 61 00 58 addi r11,r1,88
ffc19e44: 7f 23 cb 78 mr r3,r25
ffc19e48: 4b fe 8c 88 b ffc02ad0 <_restgpr_21_x>
ffc1a724 <msdos_file_chmod>:
int
msdos_file_chmod(rtems_filesystem_location_info_t *pathloc,
mode_t mode)
{
return RC_OK;
}
ffc1a724: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc1a728: 4e 80 00 20 blr <== NOT EXECUTED
ffc1a154 <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)
{
ffc1a154: 94 21 ff e8 stwu r1,-24(r1)
ffc1a158: 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,
ffc1a15c: 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)
{
ffc1a160: 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,
ffc1a164: 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;
ffc1a168: 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)
{
ffc1a16c: bf 81 00 08 stmw r28,8(r1)
ffc1a170: 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;
ffc1a174: 83 c9 00 34 lwz r30,52(r9)
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
ffc1a178: 83 a3 00 1c lwz r29,28(r3)
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
ffc1a17c: 80 7e 00 98 lwz r3,152(r30)
ffc1a180: 4b ff 1b 71 bl ffc0bcf0 <rtems_semaphore_obtain>
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
ffc1a184: 2f 83 00 00 cmpwi cr7,r3,0
ffc1a188: 41 be 00 18 beq+ cr7,ffc1a1a0 <msdos_file_close+0x4c> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one(EIO);
ffc1a18c: 48 00 40 4d bl ffc1e1d8 <__errno> <== NOT EXECUTED
ffc1a190: 38 00 00 05 li r0,5 <== NOT EXECUTED
ffc1a194: 90 03 00 00 stw r0,0(r3) <== NOT EXECUTED
ffc1a198: 3b 80 ff ff li r28,-1 <== NOT EXECUTED
ffc1a19c: 48 00 00 54 b ffc1a1f0 <msdos_file_close+0x9c> <== NOT EXECUTED
/*
* 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))
ffc1a1a0: 88 1d 00 30 lbz r0,48(r29)
ffc1a1a4: 70 09 00 01 andi. r9,r0,1
ffc1a1a8: 40 82 00 30 bne- ffc1a1d8 <msdos_file_close+0x84> <== NEVER TAKEN
ffc1a1ac: 48 00 00 50 b ffc1a1fc <msdos_file_close+0xa8>
{
rtems_semaphore_release(fs_info->vol_sema);
return rc;
}
rc = msdos_set_file_size(iop->pathinfo.mt_entry, fat_fd);
ffc1a1b0: 80 7f 00 2c lwz r3,44(r31)
ffc1a1b4: 7f a4 eb 78 mr r4,r29
ffc1a1b8: 48 00 0b f9 bl ffc1adb0 <msdos_set_file_size>
if (rc != RC_OK)
ffc1a1bc: 7c 7c 1b 79 mr. r28,r3
ffc1a1c0: 40 82 00 28 bne- ffc1a1e8 <msdos_file_close+0x94> <== 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);
ffc1a1c4: 80 7f 00 2c lwz r3,44(r31)
ffc1a1c8: 7f a4 eb 78 mr r4,r29
ffc1a1cc: 48 00 0a 29 bl ffc1abf4 <msdos_set_dir_wrt_time_and_date>
if (rc != RC_OK)
ffc1a1d0: 7c 7c 1b 79 mr. r28,r3
ffc1a1d4: 40 82 00 14 bne- ffc1a1e8 <msdos_file_close+0x94> <== NEVER TAKEN
rtems_semaphore_release(fs_info->vol_sema);
return rc;
}
}
rc = fat_file_close(iop->pathinfo.mt_entry, fat_fd);
ffc1a1d8: 80 7f 00 2c lwz r3,44(r31)
ffc1a1dc: 7f a4 eb 78 mr r4,r29
ffc1a1e0: 4b ff a0 25 bl ffc14204 <fat_file_close>
ffc1a1e4: 7c 7c 1b 78 mr r28,r3
rtems_semaphore_release(fs_info->vol_sema);
ffc1a1e8: 80 7e 00 98 lwz r3,152(r30)
ffc1a1ec: 4b ff 1c 31 bl ffc0be1c <rtems_semaphore_release>
return rc;
}
ffc1a1f0: 39 61 00 18 addi r11,r1,24
ffc1a1f4: 7f 83 e3 78 mr r3,r28
ffc1a1f8: 4b fe 88 f4 b ffc02aec <_restgpr_28_x>
* 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);
ffc1a1fc: 80 7f 00 2c lwz r3,44(r31)
ffc1a200: 7f a4 eb 78 mr r4,r29
ffc1a204: 48 00 0a e1 bl ffc1ace4 <msdos_set_first_cluster_num>
if (rc != RC_OK)
ffc1a208: 7c 7c 1b 79 mr. r28,r3
ffc1a20c: 41 82 ff a4 beq+ ffc1a1b0 <msdos_file_close+0x5c> <== ALWAYS TAKEN
ffc1a210: 4b ff ff d8 b ffc1a1e8 <msdos_file_close+0x94> <== NOT EXECUTED
ffc1a6b0 <msdos_file_datasync>:
* RETURNS:
* RC_OK on success, or -1 if error occured (errno set appropriately)
*/
int
msdos_file_datasync(rtems_libio_t *iop)
{
ffc1a6b0: 94 21 ff e8 stwu r1,-24(r1) <== NOT EXECUTED
ffc1a6b4: 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,
ffc1a6b8: 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)
{
ffc1a6bc: 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,
ffc1a6c0: 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;
ffc1a6c4: 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)
{
ffc1a6c8: bf a1 00 0c stmw r29,12(r1) <== NOT EXECUTED
ffc1a6cc: 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;
ffc1a6d0: 83 c9 00 34 lwz r30,52(r9) <== NOT EXECUTED
int
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;
ffc1a6d4: 83 a3 00 1c lwz r29,28(r3) <== NOT EXECUTED
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
ffc1a6d8: 80 7e 00 98 lwz r3,152(r30) <== NOT EXECUTED
ffc1a6dc: 4b ff 16 15 bl ffc0bcf0 <rtems_semaphore_obtain> <== NOT EXECUTED
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
ffc1a6e0: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc1a6e4: 41 be 00 18 beq+ cr7,ffc1a6fc <msdos_file_datasync+0x4c><== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
ffc1a6e8: 48 00 3a f1 bl ffc1e1d8 <__errno> <== NOT EXECUTED
ffc1a6ec: 38 00 00 05 li r0,5 <== NOT EXECUTED
ffc1a6f0: 90 03 00 00 stw r0,0(r3) <== NOT EXECUTED
ffc1a6f4: 38 60 ff ff li r3,-1 <== NOT EXECUTED
ffc1a6f8: 48 00 00 1c b ffc1a714 <msdos_file_datasync+0x64> <== NOT EXECUTED
/* synchronize file data */
rc = fat_file_datasync(iop->pathinfo.mt_entry, fat_fd);
ffc1a6fc: 80 7f 00 2c lwz r3,44(r31) <== NOT EXECUTED
ffc1a700: 7f a4 eb 78 mr r4,r29 <== NOT EXECUTED
ffc1a704: 4b ff a0 dd bl ffc147e0 <fat_file_datasync> <== NOT EXECUTED
rtems_semaphore_release(fs_info->vol_sema);
ffc1a708: 80 7e 00 98 lwz r3,152(r30) <== NOT EXECUTED
ffc1a70c: 4b ff 17 11 bl ffc0be1c <rtems_semaphore_release> <== NOT EXECUTED
return RC_OK;
ffc1a710: 38 60 00 00 li r3,0 <== NOT EXECUTED
}
ffc1a714: 39 61 00 18 addi r11,r1,24 <== NOT EXECUTED
ffc1a718: 4b fe 83 d8 b ffc02af0 <_restgpr_29_x> <== NOT EXECUTED
ffc1a500 <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)
{
ffc1a500: 94 21 ff e0 stwu r1,-32(r1)
ffc1a504: 7c 08 02 a6 mflr r0
ffc1a508: 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;
ffc1a50c: 81 23 00 2c lwz r9,44(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)
{
ffc1a510: bf 41 00 08 stmw r26,8(r1)
ffc1a514: 7c 7f 1b 78 mr r31,r3
ffc1a518: 7c be 2b 78 mr r30,r5
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
ffc1a51c: 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)
ffc1a520: 39 20 00 00 li r9,0
ffc1a524: 7f 89 28 00 cmpw cr7,r9,r5
msdos_file_ftruncate(rtems_libio_t *iop, rtems_off64_t length)
{
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;
ffc1a528: 83 83 00 1c lwz r28,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)
{
ffc1a52c: 7c dd 33 78 mr r29,r6
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)
ffc1a530: 80 1c 00 18 lwz r0,24(r28)
ffc1a534: 41 9d 00 10 bgt- cr7,ffc1a544 <msdos_file_ftruncate+0x44><== NEVER TAKEN
ffc1a538: 40 be 00 84 bne+ cr7,ffc1a5bc <msdos_file_ftruncate+0xbc><== NEVER TAKEN
ffc1a53c: 7f 80 30 40 cmplw cr7,r0,r6
ffc1a540: 40 bd 00 7c ble+ cr7,ffc1a5bc <msdos_file_ftruncate+0xbc>
return RC_OK;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
ffc1a544: 80 7b 00 98 lwz r3,152(r27)
ffc1a548: 38 80 00 00 li r4,0
ffc1a54c: 38 a0 00 00 li r5,0
ffc1a550: 4b ff 17 a1 bl ffc0bcf0 <rtems_semaphore_obtain>
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
ffc1a554: 2f 83 00 00 cmpwi cr7,r3,0
ffc1a558: 41 be 00 18 beq+ cr7,ffc1a570 <msdos_file_ftruncate+0x70><== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one(EIO);
ffc1a55c: 48 00 3c 7d bl ffc1e1d8 <__errno> <== NOT EXECUTED
ffc1a560: 38 00 00 05 li r0,5 <== NOT EXECUTED
ffc1a564: 90 03 00 00 stw r0,0(r3) <== NOT EXECUTED
ffc1a568: 3b 40 ff ff li r26,-1 <== NOT EXECUTED
ffc1a56c: 48 00 00 54 b ffc1a5c0 <msdos_file_ftruncate+0xc0> <== NOT EXECUTED
rc = fat_file_truncate(iop->pathinfo.mt_entry, fat_fd, length);
ffc1a570: 80 7f 00 2c lwz r3,44(r31)
ffc1a574: 7f 84 e3 78 mr r4,r28
ffc1a578: 7f a5 eb 78 mr r5,r29
ffc1a57c: 4b ff 9b 71 bl ffc140ec <fat_file_truncate>
if (rc != RC_OK)
ffc1a580: 7c 7a 1b 79 mr. r26,r3
ffc1a584: 40 82 00 2c bne- ffc1a5b0 <msdos_file_ftruncate+0xb0> <== 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)
ffc1a588: 7f 9a f0 00 cmpw cr7,r26,r30
ffc1a58c: 80 1c 00 18 lwz r0,24(r28)
ffc1a590: 41 9d 00 10 bgt- cr7,ffc1a5a0 <msdos_file_ftruncate+0xa0><== NEVER TAKEN
ffc1a594: 40 9e 00 1c bne- cr7,ffc1a5b0 <msdos_file_ftruncate+0xb0><== NEVER TAKEN
ffc1a598: 7f 80 e8 40 cmplw cr7,r0,r29
ffc1a59c: 40 9d 00 14 ble- cr7,ffc1a5b0 <msdos_file_ftruncate+0xb0><== NEVER TAKEN
iop->size = fat_fd->fat_file_size = length;
ffc1a5a0: 38 00 00 00 li r0,0
ffc1a5a4: 93 bc 00 18 stw r29,24(r28)
ffc1a5a8: 93 bf 00 0c stw r29,12(r31)
ffc1a5ac: 90 1f 00 08 stw r0,8(r31)
rtems_semaphore_release(fs_info->vol_sema);
ffc1a5b0: 80 7b 00 98 lwz r3,152(r27)
ffc1a5b4: 4b ff 18 69 bl ffc0be1c <rtems_semaphore_release>
return RC_OK;
ffc1a5b8: 48 00 00 08 b ffc1a5c0 <msdos_file_ftruncate+0xc0>
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)
return RC_OK;
ffc1a5bc: 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;
}
ffc1a5c0: 39 61 00 20 addi r11,r1,32
ffc1a5c4: 7f 43 d3 78 mr r3,r26
ffc1a5c8: 4b fe 85 1c b ffc02ae4 <_restgpr_26_x>
ffc1a71c <msdos_file_ioctl>:
msdos_file_ioctl(rtems_libio_t *iop,uint32_t command, void *buffer)
{
int rc = RC_OK;
return rc;
}
ffc1a71c: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc1a720: 4e 80 00 20 blr <== NOT EXECUTED
ffc1a374 <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)
{
ffc1a374: 94 21 ff d8 stwu r1,-40(r1)
ffc1a378: 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,
ffc1a37c: 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)
{
ffc1a380: 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,
ffc1a384: 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;
ffc1a388: 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;
ffc1a38c: 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)
{
ffc1a390: bf 81 00 18 stmw r28,24(r1)
ffc1a394: 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;
ffc1a398: 83 a9 00 34 lwz r29,52(r9)
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
ffc1a39c: 83 c3 00 1c lwz r30,28(r3)
uint32_t real_size = 0;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
ffc1a3a0: 80 7d 00 98 lwz r3,152(r29)
{
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;
ffc1a3a4: 90 01 00 08 stw r0,8(r1)
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
ffc1a3a8: 4b ff 19 49 bl ffc0bcf0 <rtems_semaphore_obtain>
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
ffc1a3ac: 2f 83 00 00 cmpwi cr7,r3,0
ffc1a3b0: 41 be 00 1c beq+ cr7,ffc1a3cc <msdos_file_lseek+0x58> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one(EIO);
ffc1a3b4: 48 00 3e 25 bl ffc1e1d8 <__errno> <== NOT EXECUTED
ffc1a3b8: 38 00 00 05 li r0,5 <== NOT EXECUTED
ffc1a3bc: 90 03 00 00 stw r0,0(r3) <== NOT EXECUTED
ffc1a3c0: 39 40 ff ff li r10,-1 <== NOT EXECUTED
ffc1a3c4: 39 60 ff ff li r11,-1 <== NOT EXECUTED
ffc1a3c8: 48 00 00 70 b ffc1a438 <msdos_file_lseek+0xc4> <== NOT EXECUTED
rc = fat_file_extend(iop->pathinfo.mt_entry, fat_fd, iop->offset,
ffc1a3cc: 80 7f 00 2c lwz r3,44(r31)
ffc1a3d0: 7f c4 f3 78 mr r4,r30
ffc1a3d4: 80 bf 00 14 lwz r5,20(r31)
ffc1a3d8: 38 c1 00 08 addi r6,r1,8
ffc1a3dc: 4b ff 9f b9 bl ffc14394 <fat_file_extend>
&real_size);
if (rc != RC_OK)
ffc1a3e0: 7c 7c 1b 79 mr. r28,r3
ffc1a3e4: 41 a2 00 18 beq+ ffc1a3fc <msdos_file_lseek+0x88> <== ALWAYS TAKEN
{
rtems_semaphore_release(fs_info->vol_sema);
ffc1a3e8: 80 7d 00 98 lwz r3,152(r29) <== NOT EXECUTED
ffc1a3ec: 4b ff 1a 31 bl ffc0be1c <rtems_semaphore_release> <== NOT EXECUTED
return rc;
ffc1a3f0: 7f 8b e3 78 mr r11,r28 <== NOT EXECUTED
ffc1a3f4: 7f 8a fe 70 srawi r10,r28,31 <== NOT EXECUTED
ffc1a3f8: 48 00 00 40 b ffc1a438 <msdos_file_lseek+0xc4> <== NOT EXECUTED
}
if (real_size > fat_fd->fat_file_size)
ffc1a3fc: 80 01 00 08 lwz r0,8(r1)
ffc1a400: 81 3e 00 18 lwz r9,24(r30)
ffc1a404: 7f 80 48 40 cmplw cr7,r0,r9
ffc1a408: 40 9d 00 10 ble- cr7,ffc1a418 <msdos_file_lseek+0xa4> <== ALWAYS TAKEN
fat_fd->fat_file_size = iop->offset = real_size;
ffc1a40c: 90 1f 00 14 stw r0,20(r31) <== NOT EXECUTED
ffc1a410: 93 9f 00 10 stw r28,16(r31) <== NOT EXECUTED
ffc1a414: 90 1e 00 18 stw r0,24(r30) <== NOT EXECUTED
iop->size = fat_fd->fat_file_size;
ffc1a418: 80 1e 00 18 lwz r0,24(r30)
rtems_semaphore_release(fs_info->vol_sema);
ffc1a41c: 80 7d 00 98 lwz r3,152(r29)
}
if (real_size > fat_fd->fat_file_size)
fat_fd->fat_file_size = iop->offset = real_size;
iop->size = fat_fd->fat_file_size;
ffc1a420: 90 1f 00 0c stw r0,12(r31)
ffc1a424: 38 00 00 00 li r0,0
ffc1a428: 90 1f 00 08 stw r0,8(r31)
rtems_semaphore_release(fs_info->vol_sema);
ffc1a42c: 4b ff 19 f1 bl ffc0be1c <rtems_semaphore_release>
return iop->offset;
ffc1a430: 81 5f 00 10 lwz r10,16(r31)
ffc1a434: 81 7f 00 14 lwz r11,20(r31)
}
ffc1a438: 7d 64 5b 78 mr r4,r11
ffc1a43c: 39 61 00 28 addi r11,r1,40
ffc1a440: 7d 43 53 78 mr r3,r10
ffc1a444: 4b fe 86 a8 b ffc02aec <_restgpr_28_x>
ffc1a0c0 <msdos_file_open>:
* and errno set appropriately
*/
int
msdos_file_open(rtems_libio_t *iop, const char *pathname, uint32_t flag,
uint32_t mode)
{
ffc1a0c0: 94 21 ff e8 stwu r1,-24(r1)
ffc1a0c4: 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,
ffc1a0c8: 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)
{
ffc1a0cc: 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,
ffc1a0d0: 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;
ffc1a0d4: 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)
{
ffc1a0d8: bf 81 00 08 stmw r28,8(r1)
ffc1a0dc: 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;
ffc1a0e0: 83 c9 00 34 lwz r30,52(r9)
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
ffc1a0e4: 83 a3 00 1c lwz r29,28(r3)
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
ffc1a0e8: 80 7e 00 98 lwz r3,152(r30)
ffc1a0ec: 4b ff 1c 05 bl ffc0bcf0 <rtems_semaphore_obtain>
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
ffc1a0f0: 2f 83 00 00 cmpwi cr7,r3,0
ffc1a0f4: 41 be 00 18 beq+ cr7,ffc1a10c <msdos_file_open+0x4c> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one(EIO);
ffc1a0f8: 48 00 40 e1 bl ffc1e1d8 <__errno> <== NOT EXECUTED
ffc1a0fc: 38 00 00 05 li r0,5 <== NOT EXECUTED
ffc1a100: 90 03 00 00 stw r0,0(r3) <== NOT EXECUTED
ffc1a104: 3b 80 ff ff li r28,-1 <== NOT EXECUTED
ffc1a108: 48 00 00 40 b ffc1a148 <msdos_file_open+0x88> <== NOT EXECUTED
rc = fat_file_reopen(fat_fd);
ffc1a10c: 7f a3 eb 78 mr r3,r29
ffc1a110: 4b ff 9e 11 bl ffc13f20 <fat_file_reopen>
if (rc != RC_OK)
ffc1a114: 7c 7c 1b 79 mr. r28,r3
ffc1a118: 40 82 00 28 bne- ffc1a140 <msdos_file_open+0x80> <== NEVER TAKEN
{
rtems_semaphore_release(fs_info->vol_sema);
return rc;
}
if (iop->flags & LIBIO_FLAGS_APPEND)
ffc1a11c: 80 1f 00 18 lwz r0,24(r31)
ffc1a120: 70 09 02 00 andi. r9,r0,512
ffc1a124: 80 1d 00 18 lwz r0,24(r29)
ffc1a128: 41 82 00 0c beq- ffc1a134 <msdos_file_open+0x74>
iop->offset = fat_fd->fat_file_size;
ffc1a12c: 90 1f 00 14 stw r0,20(r31)
ffc1a130: 93 9f 00 10 stw r28,16(r31)
iop->size = fat_fd->fat_file_size;
ffc1a134: 90 1f 00 0c stw r0,12(r31)
ffc1a138: 38 00 00 00 li r0,0
ffc1a13c: 90 1f 00 08 stw r0,8(r31)
rtems_semaphore_release(fs_info->vol_sema);
ffc1a140: 80 7e 00 98 lwz r3,152(r30)
ffc1a144: 4b ff 1c d9 bl ffc0be1c <rtems_semaphore_release>
return RC_OK;
}
ffc1a148: 39 61 00 18 addi r11,r1,24
ffc1a14c: 7f 83 e3 78 mr r3,r28
ffc1a150: 4b fe 89 9c b ffc02aec <_restgpr_28_x>
ffc1a214 <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)
{
ffc1a214: 94 21 ff e0 stwu r1,-32(r1)
ffc1a218: 7c 08 02 a6 mflr r0
ffc1a21c: 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;
ffc1a220: 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)
{
ffc1a224: bf 61 00 0c stmw r27,12(r1)
ffc1a228: 7c 7d 1b 78 mr r29,r3
ffc1a22c: 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;
ffc1a230: 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)
{
ffc1a234: 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;
ffc1a238: 83 63 00 1c lwz r27,28(r3)
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
ffc1a23c: 38 80 00 00 li r4,0
ffc1a240: 80 7f 00 98 lwz r3,152(r31)
ffc1a244: 38 a0 00 00 li r5,0
ffc1a248: 4b ff 1a a9 bl ffc0bcf0 <rtems_semaphore_obtain>
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
ffc1a24c: 2f 83 00 00 cmpwi cr7,r3,0
ffc1a250: 41 be 00 18 beq+ cr7,ffc1a268 <msdos_file_read+0x54> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one(EIO);
ffc1a254: 48 00 3f 85 bl ffc1e1d8 <__errno> <== NOT EXECUTED
ffc1a258: 38 00 00 05 li r0,5 <== NOT EXECUTED
ffc1a25c: 90 03 00 00 stw r0,0(r3) <== NOT EXECUTED
ffc1a260: 3b c0 ff ff li r30,-1 <== NOT EXECUTED
ffc1a264: 48 00 00 28 b ffc1a28c <msdos_file_read+0x78> <== NOT EXECUTED
ret = fat_file_read(iop->pathinfo.mt_entry, fat_fd, iop->offset, count,
ffc1a268: 80 7d 00 2c lwz r3,44(r29)
ffc1a26c: 7f c7 f3 78 mr r7,r30
ffc1a270: 80 bd 00 14 lwz r5,20(r29)
ffc1a274: 7f 64 db 78 mr r4,r27
ffc1a278: 7f 86 e3 78 mr r6,r28
ffc1a27c: 4b ff 9c b9 bl ffc13f34 <fat_file_read>
ffc1a280: 7c 7e 1b 78 mr r30,r3
buffer);
rtems_semaphore_release(fs_info->vol_sema);
ffc1a284: 80 7f 00 98 lwz r3,152(r31)
ffc1a288: 4b ff 1b 95 bl ffc0be1c <rtems_semaphore_release>
return ret;
}
ffc1a28c: 39 61 00 20 addi r11,r1,32
ffc1a290: 7f c3 f3 78 mr r3,r30
ffc1a294: 4b fe 88 54 b ffc02ae8 <_restgpr_27_x>
ffc1a72c <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)
{
ffc1a72c: 94 21 ff e8 stwu r1,-24(r1) <== NOT EXECUTED
ffc1a730: 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,
ffc1a734: 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)
{
ffc1a738: 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;
ffc1a73c: 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)
{
ffc1a740: bf 81 00 08 stmw r28,8(r1) <== NOT EXECUTED
ffc1a744: 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;
ffc1a748: 83 c9 00 34 lwz r30,52(r9) <== NOT EXECUTED
fat_file_fd_t *fat_fd = pathloc->node_access;
ffc1a74c: 83 a4 00 00 lwz r29,0(r4) <== NOT EXECUTED
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
ffc1a750: 38 80 00 00 li r4,0 <== NOT EXECUTED
ffc1a754: 80 7e 00 98 lwz r3,152(r30) <== NOT EXECUTED
ffc1a758: 4b ff 15 99 bl ffc0bcf0 <rtems_semaphore_obtain> <== NOT EXECUTED
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
ffc1a75c: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc1a760: 41 be 00 18 beq+ cr7,ffc1a778 <msdos_file_rmnod+0x4c> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
ffc1a764: 48 00 3a 75 bl ffc1e1d8 <__errno> <== NOT EXECUTED
ffc1a768: 38 00 00 05 li r0,5 <== NOT EXECUTED
ffc1a76c: 90 03 00 00 stw r0,0(r3) <== NOT EXECUTED
ffc1a770: 3b 80 ff ff li r28,-1 <== NOT EXECUTED
ffc1a774: 48 00 00 30 b ffc1a7a4 <msdos_file_rmnod+0x78> <== NOT EXECUTED
/* mark file removed */
rc = msdos_set_first_char4file_name(pathloc->mt_entry,
ffc1a778: 80 7f 00 10 lwz r3,16(r31) <== NOT EXECUTED
ffc1a77c: 38 9d 00 20 addi r4,r29,32 <== NOT EXECUTED
ffc1a780: 38 a0 00 e5 li r5,229 <== NOT EXECUTED
ffc1a784: 48 00 06 b1 bl ffc1ae34 <msdos_set_first_char4file_name><== NOT EXECUTED
&fat_fd->dir_pos,
MSDOS_THIS_DIR_ENTRY_EMPTY);
if (rc != RC_OK)
ffc1a788: 7c 7c 1b 79 mr. r28,r3 <== NOT EXECUTED
ffc1a78c: 40 82 00 10 bne- ffc1a79c <msdos_file_rmnod+0x70> <== NOT EXECUTED
{
rtems_semaphore_release(fs_info->vol_sema);
return rc;
}
fat_file_mark_removed(pathloc->mt_entry, fat_fd);
ffc1a790: 80 7f 00 10 lwz r3,16(r31) <== NOT EXECUTED
ffc1a794: 7f a4 eb 78 mr r4,r29 <== NOT EXECUTED
ffc1a798: 4b ff 9f f1 bl ffc14788 <fat_file_mark_removed> <== NOT EXECUTED
rtems_semaphore_release(fs_info->vol_sema);
ffc1a79c: 80 7e 00 98 lwz r3,152(r30) <== NOT EXECUTED
ffc1a7a0: 4b ff 16 7d bl ffc0be1c <rtems_semaphore_release> <== NOT EXECUTED
return RC_OK;
}
ffc1a7a4: 39 61 00 18 addi r11,r1,24 <== NOT EXECUTED
ffc1a7a8: 7f 83 e3 78 mr r3,r28 <== NOT EXECUTED
ffc1a7ac: 4b fe 83 40 b ffc02aec <_restgpr_28_x> <== NOT EXECUTED
ffc1a448 <msdos_file_stat>:
int
msdos_file_stat(
rtems_filesystem_location_info_t *loc,
struct stat *buf
)
{
ffc1a448: 94 21 ff e8 stwu r1,-24(r1)
ffc1a44c: 7c 08 02 a6 mflr r0
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,
ffc1a450: 38 a0 00 00 li r5,0
int
msdos_file_stat(
rtems_filesystem_location_info_t *loc,
struct stat *buf
)
{
ffc1a454: 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;
ffc1a458: 81 23 00 10 lwz r9,16(r3)
int
msdos_file_stat(
rtems_filesystem_location_info_t *loc,
struct stat *buf
)
{
ffc1a45c: bf a1 00 0c stmw r29,12(r1)
ffc1a460: 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,
ffc1a464: 38 80 00 00 li r4,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;
ffc1a468: 83 c9 00 34 lwz r30,52(r9)
fat_file_fd_t *fat_fd = loc->node_access;
ffc1a46c: 83 a3 00 00 lwz r29,0(r3)
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
ffc1a470: 80 7e 00 98 lwz r3,152(r30)
ffc1a474: 4b ff 18 7d bl ffc0bcf0 <rtems_semaphore_obtain>
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
ffc1a478: 2c 03 00 00 cmpwi r3,0
ffc1a47c: 41 a2 00 18 beq+ ffc1a494 <msdos_file_stat+0x4c> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one(EIO);
ffc1a480: 48 00 3d 59 bl ffc1e1d8 <__errno> <== NOT EXECUTED
ffc1a484: 38 00 00 05 li r0,5 <== NOT EXECUTED
ffc1a488: 90 03 00 00 stw r0,0(r3) <== NOT EXECUTED
ffc1a48c: 38 60 ff ff li r3,-1 <== NOT EXECUTED
ffc1a490: 48 00 00 68 b ffc1a4f8 <msdos_file_stat+0xb0> <== NOT EXECUTED
buf->st_dev = fs_info->fat.vol.dev;
buf->st_ino = fat_fd->ino;
ffc1a494: 80 1d 00 0c lwz r0,12(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;
ffc1a498: 81 5e 00 58 lwz r10,88(r30)
ffc1a49c: 81 7e 00 5c lwz r11,92(r30)
buf->st_ino = fat_fd->ino;
ffc1a4a0: 90 1f 00 08 stw r0,8(r31)
buf->st_mode = S_IFREG | S_IRWXU | S_IRWXG | S_IRWXO;
ffc1a4a4: 38 00 00 00 li r0,0
ffc1a4a8: 60 00 81 ff ori r0,r0,33279
ffc1a4ac: 90 1f 00 0c stw r0,12(r31)
buf->st_rdev = 0ll;
buf->st_size = fat_fd->fat_file_size;
ffc1a4b0: 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;
ffc1a4b4: 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;
ffc1a4b8: 39 40 00 00 li r10,0
buf->st_size = fat_fd->fat_file_size;
ffc1a4bc: 90 1f 00 24 stw r0,36(r31)
buf->st_blocks = fat_fd->fat_file_size >> FAT_SECTOR512_BITS;
ffc1a4c0: 54 00 ba 7e rlwinm r0,r0,23,9,31
ffc1a4c4: 90 1f 00 44 stw r0,68(r31)
buf->st_blksize = fs_info->fat.vol.bps;
ffc1a4c8: a0 1e 00 00 lhz r0,0(r30)
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;
ffc1a4cc: 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;
buf->st_rdev = 0ll;
ffc1a4d0: 39 60 00 00 li r11,0
buf->st_size = fat_fd->fat_file_size;
buf->st_blocks = fat_fd->fat_file_size >> FAT_SECTOR512_BITS;
buf->st_blksize = fs_info->fat.vol.bps;
ffc1a4d4: 90 1f 00 40 stw r0,64(r31)
buf->st_mtime = fat_fd->mtime;
ffc1a4d8: 80 1d 00 40 lwz r0,64(r29)
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;
buf->st_rdev = 0ll;
buf->st_size = fat_fd->fat_file_size;
ffc1a4dc: 90 7f 00 20 stw r3,32(r31)
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;
buf->st_rdev = 0ll;
ffc1a4e0: 91 5f 00 18 stw r10,24(r31)
ffc1a4e4: 91 7f 00 1c stw r11,28(r31)
buf->st_size = fat_fd->fat_file_size;
buf->st_blocks = fat_fd->fat_file_size >> FAT_SECTOR512_BITS;
buf->st_blksize = fs_info->fat.vol.bps;
buf->st_mtime = fat_fd->mtime;
ffc1a4e8: 90 1f 00 30 stw r0,48(r31)
rtems_semaphore_release(fs_info->vol_sema);
ffc1a4ec: 80 7e 00 98 lwz r3,152(r30)
ffc1a4f0: 4b ff 19 2d bl ffc0be1c <rtems_semaphore_release>
return RC_OK;
ffc1a4f4: 38 60 00 00 li r3,0
}
ffc1a4f8: 39 61 00 18 addi r11,r1,24
ffc1a4fc: 4b fe 85 f4 b ffc02af0 <_restgpr_29_x>
ffc1a5cc <msdos_file_sync>:
* RETURNS:
* RC_OK on success, or -1 if error occured (errno set appropriately)
*/
int
msdos_file_sync(rtems_libio_t *iop)
{
ffc1a5cc: 94 21 ff e0 stwu r1,-32(r1) <== NOT EXECUTED
ffc1a5d0: 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,
ffc1a5d4: 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)
{
ffc1a5d8: 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,
ffc1a5dc: 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;
ffc1a5e0: 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)
{
ffc1a5e4: bf 61 00 0c stmw r27,12(r1) <== NOT EXECUTED
ffc1a5e8: 7c 7e 1b 78 mr r30,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;
ffc1a5ec: 83 e9 00 34 lwz r31,52(r9) <== NOT EXECUTED
int
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;
ffc1a5f0: 83 a3 00 1c lwz r29,28(r3) <== NOT EXECUTED
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
ffc1a5f4: 80 7f 00 98 lwz r3,152(r31) <== NOT EXECUTED
ffc1a5f8: 4b ff 16 f9 bl ffc0bcf0 <rtems_semaphore_obtain> <== NOT EXECUTED
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
ffc1a5fc: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc1a600: 41 be 00 18 beq+ cr7,ffc1a618 <msdos_file_sync+0x4c> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
ffc1a604: 48 00 3b d5 bl ffc1e1d8 <__errno> <== NOT EXECUTED
ffc1a608: 38 00 00 05 li r0,5 <== NOT EXECUTED
ffc1a60c: 90 03 00 00 stw r0,0(r3) <== NOT EXECUTED
ffc1a610: 3b 80 ff ff li r28,-1 <== NOT EXECUTED
ffc1a614: 48 00 00 78 b ffc1a68c <msdos_file_sync+0xc0> <== NOT EXECUTED
/* synchronize file data */
rc = fat_file_datasync(iop->pathinfo.mt_entry, fat_fd);
ffc1a618: 80 7e 00 2c lwz r3,44(r30) <== NOT EXECUTED
ffc1a61c: 7f a4 eb 78 mr r4,r29 <== NOT EXECUTED
ffc1a620: 4b ff a1 c1 bl ffc147e0 <fat_file_datasync> <== NOT EXECUTED
if (rc != RC_OK)
ffc1a624: 7c 7c 1b 79 mr. r28,r3 <== NOT EXECUTED
ffc1a628: 40 82 00 5c bne- ffc1a684 <msdos_file_sync+0xb8> <== NOT EXECUTED
/*
* if fat-file descriptor is not marked "removed" - synchronize file
* metadata
*/
if (!FAT_FILE_IS_REMOVED(fat_fd))
ffc1a62c: 88 1d 00 30 lbz r0,48(r29) <== NOT EXECUTED
ffc1a630: 70 09 00 01 andi. r9,r0,1 <== NOT EXECUTED
ffc1a634: 40 82 00 50 bne- ffc1a684 <msdos_file_sync+0xb8> <== NOT EXECUTED
ffc1a638: 48 00 00 60 b ffc1a698 <msdos_file_sync+0xcc> <== NOT EXECUTED
if (rc != RC_OK)
{
rtems_semaphore_release(fs_info->vol_sema);
return rc;
}
rc = msdos_set_file_size(iop->pathinfo.mt_entry, fat_fd);
ffc1a63c: 80 7e 00 2c lwz r3,44(r30) <== NOT EXECUTED
ffc1a640: 7f a4 eb 78 mr r4,r29 <== NOT EXECUTED
ffc1a644: 48 00 07 6d bl ffc1adb0 <msdos_set_file_size> <== NOT EXECUTED
if (rc != RC_OK)
ffc1a648: 7c 7b 1b 79 mr. r27,r3 <== NOT EXECUTED
ffc1a64c: 41 a2 00 14 beq+ ffc1a660 <msdos_file_sync+0x94> <== NOT EXECUTED
{
rtems_semaphore_release(fs_info->vol_sema);
ffc1a650: 80 7f 00 98 lwz r3,152(r31) <== NOT EXECUTED
return rc;
ffc1a654: 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);
ffc1a658: 4b ff 17 c5 bl ffc0be1c <rtems_semaphore_release> <== NOT EXECUTED
return rc;
ffc1a65c: 48 00 00 30 b ffc1a68c <msdos_file_sync+0xc0> <== NOT EXECUTED
}
rc = msdos_set_dir_wrt_time_and_date(iop->pathinfo.mt_entry, fat_fd);
ffc1a660: 80 7e 00 2c lwz r3,44(r30) <== NOT EXECUTED
ffc1a664: 7f a4 eb 78 mr r4,r29 <== NOT EXECUTED
ffc1a668: 48 00 05 8d bl ffc1abf4 <msdos_set_dir_wrt_time_and_date><== NOT EXECUTED
if (rc != RC_OK)
ffc1a66c: 7c 7e 1b 79 mr. r30,r3 <== NOT EXECUTED
ffc1a670: 41 a2 00 14 beq+ ffc1a684 <msdos_file_sync+0xb8> <== NOT EXECUTED
{
rtems_semaphore_release(fs_info->vol_sema);
ffc1a674: 80 7f 00 98 lwz r3,152(r31) <== NOT EXECUTED
return rc;
ffc1a678: 7f dc f3 78 mr r28,r30 <== 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);
ffc1a67c: 4b ff 17 a1 bl ffc0be1c <rtems_semaphore_release> <== NOT EXECUTED
return rc;
ffc1a680: 48 00 00 0c b ffc1a68c <msdos_file_sync+0xc0> <== NOT EXECUTED
}
}
rtems_semaphore_release(fs_info->vol_sema);
ffc1a684: 80 7f 00 98 lwz r3,152(r31) <== NOT EXECUTED
ffc1a688: 4b ff 17 95 bl ffc0be1c <rtems_semaphore_release> <== NOT EXECUTED
return RC_OK;
}
ffc1a68c: 39 61 00 20 addi r11,r1,32 <== NOT EXECUTED
ffc1a690: 7f 83 e3 78 mr r3,r28 <== NOT EXECUTED
ffc1a694: 4b fe 84 54 b ffc02ae8 <_restgpr_27_x> <== 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);
ffc1a698: 80 7e 00 2c lwz r3,44(r30) <== NOT EXECUTED
ffc1a69c: 7f a4 eb 78 mr r4,r29 <== NOT EXECUTED
ffc1a6a0: 48 00 06 45 bl ffc1ace4 <msdos_set_first_cluster_num> <== NOT EXECUTED
if (rc != RC_OK)
ffc1a6a4: 7c 7b 1b 79 mr. r27,r3 <== NOT EXECUTED
ffc1a6a8: 41 82 ff 94 beq+ ffc1a63c <msdos_file_sync+0x70> <== NOT EXECUTED
ffc1a6ac: 4b ff ff a4 b ffc1a650 <msdos_file_sync+0x84> <== NOT EXECUTED
ffc1a298 <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)
{
ffc1a298: 94 21 ff e0 stwu r1,-32(r1)
ffc1a29c: 7c 08 02 a6 mflr r0
ffc1a2a0: 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;
ffc1a2a4: 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)
{
ffc1a2a8: bf 61 00 0c stmw r27,12(r1)
ffc1a2ac: 7c 7f 1b 78 mr r31,r3
ffc1a2b0: 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;
ffc1a2b4: 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)
{
ffc1a2b8: 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;
ffc1a2bc: 83 c3 00 1c lwz r30,28(r3)
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
ffc1a2c0: 38 80 00 00 li r4,0
ffc1a2c4: 80 7d 00 98 lwz r3,152(r29)
ffc1a2c8: 38 a0 00 00 li r5,0
ffc1a2cc: 4b ff 1a 25 bl ffc0bcf0 <rtems_semaphore_obtain>
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
ffc1a2d0: 2f 83 00 00 cmpwi cr7,r3,0
ffc1a2d4: 41 be 00 14 beq+ cr7,ffc1a2e8 <msdos_file_write+0x50> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one(EIO);
ffc1a2d8: 48 00 3f 01 bl ffc1e1d8 <__errno> <== NOT EXECUTED
ffc1a2dc: 38 00 00 05 li r0,5 <== NOT EXECUTED
ffc1a2e0: 90 03 00 00 stw r0,0(r3) <== NOT EXECUTED
ffc1a2e4: 48 00 00 2c b ffc1a310 <msdos_file_write+0x78> <== NOT EXECUTED
ret = fat_file_write(iop->pathinfo.mt_entry, fat_fd, iop->offset, count,
ffc1a2e8: 80 7f 00 2c lwz r3,44(r31)
ffc1a2ec: 7f 87 e3 78 mr r7,r28
ffc1a2f0: 80 bf 00 14 lwz r5,20(r31)
ffc1a2f4: 7f c4 f3 78 mr r4,r30
ffc1a2f8: 7f 66 db 78 mr r6,r27
ffc1a2fc: 4b ff a2 91 bl ffc1458c <fat_file_write>
buffer);
if (ret < 0)
ffc1a300: 7c 7c 1b 79 mr. r28,r3
ffc1a304: 40 a0 00 14 bge+ ffc1a318 <msdos_file_write+0x80> <== ALWAYS TAKEN
{
rtems_semaphore_release(fs_info->vol_sema);
ffc1a308: 80 7d 00 98 lwz r3,152(r29) <== NOT EXECUTED
ffc1a30c: 4b ff 1b 11 bl ffc0be1c <rtems_semaphore_release> <== NOT EXECUTED
return -1;
ffc1a310: 3b 80 ff ff li r28,-1 <== NOT EXECUTED
ffc1a314: 48 00 00 54 b ffc1a368 <msdos_file_write+0xd0> <== NOT EXECUTED
/*
* 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)
ffc1a318: 81 1f 00 10 lwz r8,16(r31)
ffc1a31c: 7f 8b e3 78 mr r11,r28
ffc1a320: 81 3f 00 14 lwz r9,20(r31)
ffc1a324: 7f 8a fe 70 srawi r10,r28,31
ffc1a328: 80 1e 00 18 lwz r0,24(r30)
ffc1a32c: 7d 6b 48 14 addc r11,r11,r9
ffc1a330: 7d 4a 41 14 adde r10,r10,r8
ffc1a334: 2f 8a 00 00 cmpwi cr7,r10,0
ffc1a338: 41 9d 00 10 bgt- cr7,ffc1a348 <msdos_file_write+0xb0> <== NEVER TAKEN
ffc1a33c: 40 9e 00 14 bne- cr7,ffc1a350 <msdos_file_write+0xb8> <== NEVER TAKEN
ffc1a340: 7f 8b 00 40 cmplw cr7,r11,r0
ffc1a344: 40 9d 00 0c ble- cr7,ffc1a350 <msdos_file_write+0xb8>
fat_fd->fat_file_size = iop->offset + ret;
ffc1a348: 7c 1c 4a 14 add r0,r28,r9
ffc1a34c: 90 1e 00 18 stw r0,24(r30)
iop->size = fat_fd->fat_file_size;
ffc1a350: 80 1e 00 18 lwz r0,24(r30)
rtems_semaphore_release(fs_info->vol_sema);
ffc1a354: 80 7d 00 98 lwz r3,152(r29)
* file was extended
*/
if (iop->offset + ret > fat_fd->fat_file_size)
fat_fd->fat_file_size = iop->offset + ret;
iop->size = fat_fd->fat_file_size;
ffc1a358: 90 1f 00 0c stw r0,12(r31)
ffc1a35c: 38 00 00 00 li r0,0
ffc1a360: 90 1f 00 08 stw r0,8(r31)
rtems_semaphore_release(fs_info->vol_sema);
ffc1a364: 4b ff 1a b9 bl ffc0be1c <rtems_semaphore_release>
return ret;
}
ffc1a368: 39 61 00 20 addi r11,r1,32
ffc1a36c: 7f 83 e3 78 mr r3,r28
ffc1a370: 4b fe 87 78 b ffc02ae8 <_restgpr_27_x>
ffc1d758 <msdos_filename_unix2dos>:
/*
* Fill the dos filename string with blanks. These are DOS's pad
* characters.
*/
for (i = 0; i <= 10; i++)
dn[i] = ' ';
ffc1d758: 39 60 00 0b li r11,11
ffc1d75c: 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++)
ffc1d760: 39 20 00 00 li r9,0
dn[i] = ' ';
ffc1d764: 38 00 00 20 li r0,32
ffc1d768: 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++)
ffc1d76c: 39 29 00 01 addi r9,r9,1
ffc1d770: 42 00 ff f8 bdnz+ ffc1d768 <msdos_filename_unix2dos+0x10>
/*
* The filenames "." and ".." are handled specially, since they
* don't follow dos filename rules.
*/
if (un[0] == '.' && unlen == 1) {
ffc1d774: 88 03 00 00 lbz r0,0(r3)
ffc1d778: 2f 80 00 2e cmpwi cr7,r0,46
ffc1d77c: 40 be 00 40 bne+ cr7,ffc1d7bc <msdos_filename_unix2dos+0x64><== ALWAYS TAKEN
ffc1d780: 2f 84 00 01 cmpwi cr7,r4,1 <== NOT EXECUTED
ffc1d784: 40 be 00 0c bne+ cr7,ffc1d790 <msdos_filename_unix2dos+0x38><== NOT EXECUTED
dn[0] = '.';
ffc1d788: 98 05 00 00 stb r0,0(r5) <== NOT EXECUTED
return 0;
ffc1d78c: 48 00 01 14 b ffc1d8a0 <msdos_filename_unix2dos+0x148><== NOT EXECUTED
}
if (un[0] == '.' && un[1] == '.' && unlen == 2) {
ffc1d790: 88 03 00 01 lbz r0,1(r3) <== NOT EXECUTED
ffc1d794: 2f 80 00 2e cmpwi cr7,r0,46 <== NOT EXECUTED
ffc1d798: 40 be 00 24 bne+ cr7,ffc1d7bc <msdos_filename_unix2dos+0x64><== NOT EXECUTED
ffc1d79c: 2f 84 00 02 cmpwi cr7,r4,2 <== NOT EXECUTED
ffc1d7a0: 40 be 00 1c bne+ cr7,ffc1d7bc <msdos_filename_unix2dos+0x64><== NOT EXECUTED
dn[0] = '.';
ffc1d7a4: 98 05 00 00 stb r0,0(r5) <== NOT EXECUTED
dn[1] = '.';
ffc1d7a8: 98 05 00 01 stb r0,1(r5) <== NOT EXECUTED
return 0;
ffc1d7ac: 48 00 00 f4 b ffc1d8a0 <msdos_filename_unix2dos+0x148><== NOT EXECUTED
/*
* Remove any dots from the start of a file name.
*/
while (unlen && (*un == '.')) {
un++;
ffc1d7b0: 38 63 00 01 addi r3,r3,1 <== NOT EXECUTED
unlen--;
ffc1d7b4: 38 84 ff ff addi r4,r4,-1 <== NOT EXECUTED
ffc1d7b8: 48 00 00 0c b ffc1d7c4 <msdos_filename_unix2dos+0x6c><== NOT EXECUTED
ffc1d7bc: 38 04 00 01 addi r0,r4,1
ffc1d7c0: 7c 09 03 a6 mtctr r0
}
/*
* Remove any dots from the start of a file name.
*/
while (unlen && (*un == '.')) {
ffc1d7c4: 42 00 00 18 bdnz- ffc1d7dc <msdos_filename_unix2dos+0x84>
* 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++) {
if (msdos_map[c] == 0)
ffc1d7c8: 38 00 00 08 li r0,8
/*
* Fill the dos filename string with blanks. These are DOS's pad
* characters.
*/
for (i = 0; i <= 10; i++)
ffc1d7cc: 39 20 00 00 li r9,0
* 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++) {
if (msdos_map[c] == 0)
ffc1d7d0: 7c 09 03 a6 mtctr r0
ffc1d7d4: 3d 60 ff c3 lis r11,-61
ffc1d7d8: 48 00 00 38 b ffc1d810 <msdos_filename_unix2dos+0xb8>
}
/*
* Remove any dots from the start of a file name.
*/
while (unlen && (*un == '.')) {
ffc1d7dc: 88 03 00 00 lbz r0,0(r3)
ffc1d7e0: 2f 80 00 2e cmpwi cr7,r0,46
ffc1d7e4: 41 9e ff cc beq+ cr7,ffc1d7b0 <msdos_filename_unix2dos+0x58><== NEVER TAKEN
ffc1d7e8: 4b ff ff e0 b ffc1d7c8 <msdos_filename_unix2dos+0x70>
* 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++) {
if (msdos_map[c] == 0)
ffc1d7ec: 39 4b f3 d0 addi r10,r11,-3120
ffc1d7f0: 7c 0a 00 ae lbzx r0,r10,r0
ffc1d7f4: 2f 80 00 00 cmpwi cr7,r0,0
ffc1d7f8: 41 9e 00 4c beq- cr7,ffc1d844 <msdos_filename_unix2dos+0xec><== NEVER TAKEN
break;
dn[i] = msdos_map[c];
ffc1d7fc: 7c 05 49 ae stbx r0,r5,r9
un++;
ffc1d800: 38 63 00 01 addi r3,r3,1
unlen--;
ffc1d804: 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++) {
ffc1d808: 39 29 00 01 addi r9,r9,1
ffc1d80c: 42 40 00 38 bdz- ffc1d844 <msdos_filename_unix2dos+0xec>
ffc1d810: 2f 84 00 00 cmpwi cr7,r4,0
ffc1d814: 41 9e 00 30 beq- cr7,ffc1d844 <msdos_filename_unix2dos+0xec>
ffc1d818: 88 03 00 00 lbz r0,0(r3)
ffc1d81c: 2f 80 00 00 cmpwi cr7,r0,0
ffc1d820: 41 9e 00 24 beq- cr7,ffc1d844 <msdos_filename_unix2dos+0xec><== NEVER TAKEN
ffc1d824: 2f 80 00 2e cmpwi cr7,r0,46
ffc1d828: 40 9e ff c4 bne+ cr7,ffc1d7ec <msdos_filename_unix2dos+0x94><== ALWAYS TAKEN
ffc1d82c: 48 00 00 18 b ffc1d844 <msdos_filename_unix2dos+0xec><== NOT EXECUTED
*/
while (unlen && (c = *un)) {
un++;
unlen--;
/* Make sure we've skipped over the dot before stopping. */
if (c == '.')
ffc1d830: 2f 80 00 2e cmpwi cr7,r0,46
/*
* Strip any further characters up to a '.' or the end of the
* string.
*/
while (unlen && (c = *un)) {
un++;
ffc1d834: 38 63 00 01 addi r3,r3,1
unlen--;
ffc1d838: 38 84 ff ff addi r4,r4,-1
/* Make sure we've skipped over the dot before stopping. */
if (c == '.')
ffc1d83c: 40 be 00 10 bne+ cr7,ffc1d84c <msdos_filename_unix2dos+0xf4><== ALWAYS TAKEN
ffc1d840: 48 00 00 1c b ffc1d85c <msdos_filename_unix2dos+0x104><== NOT EXECUTED
ffc1d844: 39 64 00 01 addi r11,r4,1
ffc1d848: 7d 69 03 a6 mtctr r11
/*
* Strip any further characters up to a '.' or the end of the
* string.
*/
while (unlen && (c = *un)) {
ffc1d84c: 42 40 00 10 bdz- ffc1d85c <msdos_filename_unix2dos+0x104>
ffc1d850: 88 03 00 00 lbz r0,0(r3)
ffc1d854: 2f 80 00 00 cmpwi cr7,r0,0
ffc1d858: 40 9e ff d8 bne+ cr7,ffc1d830 <msdos_filename_unix2dos+0xd8><== ALWAYS TAKEN
/*
* 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)
ffc1d85c: 39 20 00 00 li r9,0
* 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++) {
if (msdos_map[c] == 0)
ffc1d860: 3d 60 ff c3 lis r11,-61
ffc1d864: 48 00 00 28 b ffc1d88c <msdos_filename_unix2dos+0x134>
ffc1d868: 39 4b f3 d0 addi r10,r11,-3120 <== NOT EXECUTED
ffc1d86c: 7c 0a 00 ae lbzx r0,r10,r0 <== NOT EXECUTED
ffc1d870: 2f 80 00 00 cmpwi cr7,r0,0 <== NOT EXECUTED
ffc1d874: 41 9e 00 2c beq- cr7,ffc1d8a0 <msdos_filename_unix2dos+0x148><== 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++) {
ffc1d878: 2f 89 00 02 cmpwi cr7,r9,2 <== NOT EXECUTED
/*
* 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)
ffc1d87c: 7d 45 4a 14 add r10,r5,r9 <== NOT EXECUTED
* Filenames in this form are probably inaccessable under dos.
*/
for (i = 8; i <= 10 && unlen && (c = *un); i++) {
if (msdos_map[c] == 0)
break;
dn[i] = msdos_map[c];
ffc1d880: 98 0a 00 08 stb r0,8(r10) <== 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++) {
ffc1d884: 39 29 00 01 addi r9,r9,1 <== NOT EXECUTED
ffc1d888: 41 9e 00 18 beq- cr7,ffc1d8a0 <msdos_filename_unix2dos+0x148><== NOT EXECUTED
ffc1d88c: 7f 89 20 00 cmpw cr7,r9,r4
ffc1d890: 41 9e 00 10 beq- cr7,ffc1d8a0 <msdos_filename_unix2dos+0x148><== ALWAYS TAKEN
ffc1d894: 7c 03 48 ae lbzx r0,r3,r9 <== NOT EXECUTED
ffc1d898: 2f 80 00 00 cmpwi cr7,r0,0 <== NOT EXECUTED
ffc1d89c: 40 9e ff cc bne+ cr7,ffc1d868 <msdos_filename_unix2dos+0x110><== NOT EXECUTED
dn[i] = msdos_map[c];
un++;
unlen--;
}
return 0;
}
ffc1d8a0: 38 60 00 00 li r3,0
ffc1d8a4: 4e 80 00 20 blr
ffc1bdb8 <msdos_find_name>:
msdos_find_name(
rtems_filesystem_location_info_t *parent_loc,
const char *name,
int name_len
)
{
ffc1bdb8: 94 21 ff a0 stwu r1,-96(r1)
ffc1bdbc: 7c 08 02 a6 mflr r0
ffc1bdc0: 90 01 00 64 stw r0,100(r1)
int rc = RC_OK;
msdos_fs_info_t *fs_info = parent_loc->mt_entry->fs_info;
fat_file_fd_t *fat_fd = NULL;
ffc1bdc4: 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;
ffc1bdc8: 81 23 00 10 lwz r9,16(r3)
msdos_find_name(
rtems_filesystem_location_info_t *parent_loc,
const char *name,
int name_len
)
{
ffc1bdcc: bf 61 00 4c stmw r27,76(r1)
ffc1bdd0: 7c bc 2b 78 mr r28,r5
ffc1bdd4: 7c 9b 23 78 mr r27,r4
ffc1bdd8: 7c 7f 1b 78 mr r31,r3
int rc = RC_OK;
msdos_fs_info_t *fs_info = parent_loc->mt_entry->fs_info;
ffc1bddc: 83 a9 00 34 lwz r29,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);
ffc1bde0: 38 80 00 00 li r4,0
int name_len
)
{
int rc = RC_OK;
msdos_fs_info_t *fs_info = parent_loc->mt_entry->fs_info;
fat_file_fd_t *fat_fd = NULL;
ffc1bde4: 90 01 00 08 stw r0,8(r1)
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);
ffc1bde8: 38 a0 00 20 li r5,32
ffc1bdec: 38 61 00 1c addi r3,r1,28
ffc1bdf0: 48 00 33 01 bl ffc1f0f0 <memset>
name_type = msdos_long_to_short (name,
ffc1bdf4: 7f 84 e3 78 mr r4,r28
ffc1bdf8: 38 a1 00 1c addi r5,r1,28
ffc1bdfc: 38 c0 00 0b li r6,11
ffc1be00: 7f 63 db 78 mr r3,r27
ffc1be04: 4b ff eb 35 bl ffc1a938 <msdos_long_to_short>
/*
* 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,
ffc1be08: 3b c1 00 0c addi r30,r1,12
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,
ffc1be0c: 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,
ffc1be10: 7f 86 e3 78 mr r6,r28
ffc1be14: 7f e3 fb 78 mr r3,r31
ffc1be18: 38 80 00 00 li r4,0
ffc1be1c: 7f 65 db 78 mr r5,r27
ffc1be20: 7f c8 f3 78 mr r8,r30
ffc1be24: 39 21 00 1c addi r9,r1,28
ffc1be28: 4b ff fe 89 bl ffc1bcb0 <msdos_get_name_node>
&dir_pos, node_entry);
if (rc != RC_OK)
ffc1be2c: 7c 7c 1b 79 mr. r28,r3
ffc1be30: 40 82 01 64 bne- ffc1bf94 <msdos_find_name+0x1dc>
return rc;
if (((*MSDOS_DIR_ATTR(node_entry)) & MSDOS_ATTR_VOLUME_ID) ||
ffc1be34: 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;
ffc1be38: 3b 80 7d 01 li r28,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) ||
ffc1be3c: 70 09 00 08 andi. r9,r0,8
ffc1be40: 40 a2 01 54 bne+ ffc1bf94 <msdos_find_name+0x1dc> <== NEVER TAKEN
((*MSDOS_DIR_ATTR(node_entry) & MSDOS_ATTR_LFN_MASK) == MSDOS_ATTR_LFN))
ffc1be44: 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) ||
ffc1be48: 2f 80 00 0f cmpwi cr7,r0,15
ffc1be4c: 41 be 01 48 beq+ cr7,ffc1bf94 <msdos_find_name+0x1dc> <== 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);
ffc1be50: 80 7f 00 10 lwz r3,16(r31)
ffc1be54: 7f c4 f3 78 mr r4,r30
ffc1be58: 38 a1 00 08 addi r5,r1,8
ffc1be5c: 4b ff 7f 81 bl ffc13ddc <fat_file_open>
if (rc != RC_OK)
ffc1be60: 7c 7c 1b 79 mr. r28,r3
ffc1be64: 40 82 01 30 bne- ffc1bf94 <msdos_find_name+0x1dc>
return rc;
fat_fd->dir_pos = dir_pos;
ffc1be68: 83 81 00 08 lwz r28,8(r1)
ffc1be6c: 39 3c 00 20 addi r9,r28,32
ffc1be70: 7c be 84 aa lswi r5,r30,16
ffc1be74: 7c a9 85 aa stswi r5,r9,16
* 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)
ffc1be78: 83 dc 00 08 lwz r30,8(r28)
ffc1be7c: 2f 9e 00 01 cmpwi cr7,r30,1
ffc1be80: 40 be 00 ec bne+ cr7,ffc1bf6c <msdos_find_name+0x1b4>
{
fat_fd->cln = MSDOS_EXTRACT_CLUSTER_NUM(node_entry);
ffc1be84: a1 21 00 30 lhz r9,48(r1)
ffc1be88: a0 01 00 36 lhz r0,54(r1)
ffc1be8c: 55 2b c2 3e rlwinm r11,r9,24,8,31
ffc1be90: 55 29 44 2e rlwinm r9,r9,8,16,23
ffc1be94: 7d 69 4b 78 or r9,r11,r9
ffc1be98: 54 0b c2 3e rlwinm r11,r0,24,8,31
ffc1be9c: 54 00 44 2e rlwinm r0,r0,8,16,23
ffc1bea0: 55 29 80 1e rlwinm r9,r9,16,0,15
ffc1bea4: 7d 60 03 78 or r0,r11,r0
ffc1bea8: 7d 20 03 78 or r0,r9,r0
time_val = *MSDOS_DIR_WRITE_TIME(node_entry);
date = *MSDOS_DIR_WRITE_DATE(node_entry);
ffc1beac: 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);
ffc1beb0: 90 1c 00 1c stw r0,28(r28)
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));
ffc1beb4: 55 23 c2 3e rlwinm r3,r9,24,8,31
*/
if (fat_fd->links_num == 1)
{
fat_fd->cln = MSDOS_EXTRACT_CLUSTER_NUM(node_entry);
time_val = *MSDOS_DIR_WRITE_TIME(node_entry);
ffc1beb8: a0 01 00 32 lhz r0,50(r1)
date = *MSDOS_DIR_WRITE_DATE(node_entry);
fat_fd->mtime = msdos_date_dos2unix(CF_LE_W(date), CF_LE_W(time_val));
ffc1bebc: 55 29 44 2e rlwinm r9,r9,8,16,23
ffc1bec0: 7c 63 4b 78 or r3,r3,r9
ffc1bec4: 54 04 c2 3e rlwinm r4,r0,24,8,31
ffc1bec8: 54 00 44 2e rlwinm r0,r0,8,16,23
ffc1becc: 7c 84 03 78 or r4,r4,r0
ffc1bed0: 48 00 17 a5 bl ffc1d674 <msdos_date_dos2unix>
if ((*MSDOS_DIR_ATTR(node_entry)) & MSDOS_ATTR_DIRECTORY)
ffc1bed4: 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));
ffc1bed8: 90 7c 00 40 stw r3,64(r28)
if ((*MSDOS_DIR_ATTR(node_entry)) & MSDOS_ATTR_DIRECTORY)
ffc1bedc: 70 09 00 10 andi. r9,r0,16
ffc1bee0: 80 81 00 08 lwz r4,8(r1)
ffc1bee4: 41 a2 00 2c beq+ ffc1bf10 <msdos_find_name+0x158>
{
fat_fd->fat_file_type = FAT_DIRECTORY;
fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
ffc1bee8: 3c 00 00 20 lis r0,32
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;
ffc1beec: 93 c4 00 10 stw r30,16(r4)
fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
ffc1bef0: 90 04 00 14 stw r0,20(r4)
rc = fat_file_size(parent_loc->mt_entry, fat_fd);
ffc1bef4: 80 7f 00 10 lwz r3,16(r31)
ffc1bef8: 4b ff 89 dd bl ffc148d4 <fat_file_size>
if (rc != RC_OK)
ffc1befc: 7c 7c 1b 79 mr. r28,r3
ffc1bf00: 41 a2 00 38 beq+ ffc1bf38 <msdos_find_name+0x180> <== ALWAYS TAKEN
{
fat_file_close(parent_loc->mt_entry, fat_fd);
ffc1bf04: 80 7f 00 10 lwz r3,16(r31) <== NOT EXECUTED
ffc1bf08: 80 81 00 08 lwz r4,8(r1) <== NOT EXECUTED
ffc1bf0c: 48 00 00 7c b ffc1bf88 <msdos_find_name+0x1d0> <== NOT EXECUTED
ffc1bf10: 81 21 00 38 lwz r9,56(r1)
ffc1bf14: 51 20 46 3e rlwimi r0,r9,8,24,31
ffc1bf18: 51 20 c4 2e rlwimi r0,r9,24,16,23
ffc1bf1c: 51 20 42 1e rlwimi r0,r9,8,8,15
ffc1bf20: 51 20 c0 0e rlwimi r0,r9,24,0,7
return rc;
}
}
else
{
fat_fd->fat_file_size = CF_LE_L(*MSDOS_DIR_FILE_SIZE(node_entry));
ffc1bf24: 90 04 00 18 stw r0,24(r4)
fat_fd->fat_file_type = FAT_FILE;
ffc1bf28: 38 00 00 05 li r0,5
ffc1bf2c: 90 04 00 10 stw r0,16(r4)
fat_fd->size_limit = MSDOS_MAX_FILE_SIZE;
ffc1bf30: 38 00 ff ff li r0,-1
ffc1bf34: 90 04 00 14 stw r0,20(r4)
}
/* these data is not actual for zero-length fat-file */
fat_fd->map.file_cln = 0;
ffc1bf38: 81 21 00 08 lwz r9,8(r1)
ffc1bf3c: 38 00 00 00 li r0,0
fat_fd->map.disk_cln = fat_fd->cln;
if ((fat_fd->fat_file_size != 0) &&
ffc1bf40: 81 69 00 18 lwz r11,24(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;
ffc1bf44: 90 09 00 34 stw r0,52(r9)
fat_fd->map.disk_cln = fat_fd->cln;
if ((fat_fd->fat_file_size != 0) &&
ffc1bf48: 2f 8b 00 00 cmpwi cr7,r11,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;
ffc1bf4c: 80 09 00 1c lwz r0,28(r9)
ffc1bf50: 90 09 00 38 stw r0,56(r9)
if ((fat_fd->fat_file_size != 0) &&
ffc1bf54: 41 9e 00 10 beq- cr7,ffc1bf64 <msdos_find_name+0x1ac>
(fat_fd->fat_file_size <= fs_info->fat.vol.bpc))
ffc1bf58: a1 5d 00 06 lhz r10,6(r29)
/* 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) &&
ffc1bf5c: 7f 8b 50 40 cmplw cr7,r11,r10
ffc1bf60: 40 9d 00 08 ble- cr7,ffc1bf68 <msdos_find_name+0x1b0> <== ALWAYS TAKEN
{
fat_fd->map.last_cln = fat_fd->cln;
}
else
{
fat_fd->map.last_cln = FAT_UNDEFINED_VALUE;
ffc1bf64: 38 00 ff ff li r0,-1
ffc1bf68: 90 09 00 3c stw r0,60(r9)
}
}
/* close fat-file corresponded to the node we searched in */
rc = fat_file_close(parent_loc->mt_entry, parent_loc->node_access);
ffc1bf6c: 80 9f 00 00 lwz r4,0(r31)
ffc1bf70: 80 7f 00 10 lwz r3,16(r31)
ffc1bf74: 4b ff 82 91 bl ffc14204 <fat_file_close>
ffc1bf78: 80 81 00 08 lwz r4,8(r1)
if (rc != RC_OK)
ffc1bf7c: 7c 7c 1b 79 mr. r28,r3
ffc1bf80: 41 a2 00 10 beq+ ffc1bf90 <msdos_find_name+0x1d8> <== ALWAYS TAKEN
{
fat_file_close(parent_loc->mt_entry, fat_fd);
ffc1bf84: 80 7f 00 10 lwz r3,16(r31) <== NOT EXECUTED
ffc1bf88: 4b ff 82 7d bl ffc14204 <fat_file_close> <== NOT EXECUTED
return rc;
ffc1bf8c: 48 00 00 08 b ffc1bf94 <msdos_find_name+0x1dc> <== NOT EXECUTED
}
/* update node_info_ptr field */
parent_loc->node_access = fat_fd;
ffc1bf90: 90 9f 00 00 stw r4,0(r31)
return rc;
}
ffc1bf94: 39 61 00 60 addi r11,r1,96
ffc1bf98: 7f 83 e3 78 mr r3,r28
ffc1bf9c: 4b fe 6b 4c b ffc02ae8 <_restgpr_27_x>
ffc1b08c <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
)
{
ffc1b08c: 94 21 ff 80 stwu r1,-128(r1)
ffc1b090: 7d 80 00 26 mfcr r12
ffc1b094: 7c 08 02 a6 mflr r0
ffc1b098: 7c ab 2b 78 mr r11,r5
ffc1b09c: bd c1 00 38 stmw r14,56(r1)
ffc1b0a0: 7d 3c 4b 78 mr r28,r9
uint32_t empty_space_count = 0;
bool empty_space_found = false;
uint32_t entries_per_block;
bool read_cluster = false;
assert(name_len > 0);
ffc1b0a4: 7c e9 3b 79 mr. r9,r7
int name_len,
msdos_name_type_t name_type,
fat_dir_pos_t *dir_pos,
char *name_dir_entry
)
{
ffc1b0a8: 90 01 00 84 stw r0,132(r1)
ffc1b0ac: 7c 79 1b 78 mr r25,r3
ffc1b0b0: 7c 9d 23 78 mr r29,r4
ffc1b0b4: 91 81 00 34 stw r12,52(r1)
ffc1b0b8: 7d 5b 53 78 mr r27,r10
ffc1b0bc: 90 c1 00 18 stw r6,24(r1)
ssize_t ret = 0;
msdos_fs_info_t *fs_info = mt_entry->fs_info;
ffc1b0c0: 83 03 00 34 lwz r24,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);
ffc1b0c4: 41 a1 00 28 bgt+ ffc1b0ec <msdos_find_name_in_fat_file+0x60><== ALWAYS TAKEN
ffc1b0c8: 3c a0 ff c3 lis r5,-61 <== NOT EXECUTED
ffc1b0cc: 3c 60 ff c3 lis r3,-61 <== NOT EXECUTED
ffc1b0d0: 38 a5 f2 c0 addi r5,r5,-3392 <== NOT EXECUTED
ffc1b0d4: 3c c0 ff c3 lis r6,-61 <== NOT EXECUTED
ffc1b0d8: 38 63 f3 34 addi r3,r3,-3276 <== NOT EXECUTED
ffc1b0dc: 38 80 04 19 li r4,1049 <== NOT EXECUTED
ffc1b0e0: 38 a5 00 14 addi r5,r5,20 <== NOT EXECUTED
ffc1b0e4: 38 c6 f3 b2 addi r6,r6,-3150 <== NOT EXECUTED
ffc1b0e8: 48 00 00 e0 b ffc1b1c8 <msdos_find_name_in_fat_file+0x13c><== NOT EXECUTED
* 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))
ffc1b0ec: 2f 85 00 00 cmpwi cr7,r5,0
static inline void
fat_dir_pos_init(
fat_dir_pos_t *dir_pos
)
{
dir_pos->sname.cln = 0;
ffc1b0f0: 38 00 00 00 li r0,0
ffc1b0f4: 90 1c 00 00 stw r0,0(r28)
dir_pos->sname.ofs = 0;
ffc1b0f8: 90 1c 00 04 stw r0,4(r28)
dir_pos->lname.cln = FAT_FILE_SHORT_NAME;
ffc1b0fc: 38 00 ff ff li r0,-1
ffc1b100: 90 1c 00 08 stw r0,8(r28)
dir_pos->lname.ofs = FAT_FILE_SHORT_NAME;
ffc1b104: 90 1c 00 0c stw r0,12(r28)
assert(name_len > 0);
fat_dir_pos_init(dir_pos);
lfn_start.cln = lfn_start.ofs = FAT_FILE_SHORT_NAME;
ffc1b108: 90 01 00 10 stw r0,16(r1)
ffc1b10c: 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))
ffc1b110: 41 9e 00 10 beq- cr7,ffc1b120 <msdos_find_name_in_fat_file+0x94>
ffc1b114: 2f 88 00 01 cmpwi cr7,r8,1
lfn_entries = 0;
ffc1b118: 3b 40 00 00 li r26,0
* 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))
ffc1b11c: 41 9e 00 10 beq- cr7,ffc1b12c <msdos_find_name_in_fat_file+0xa0>
lfn_entries = 0;
else
lfn_entries =
((name_len - 1) + MSDOS_LFN_LEN_PER_ENTRY) / MSDOS_LFN_LEN_PER_ENTRY;
ffc1b120: 3b 49 00 0c addi r26,r9,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 =
ffc1b124: 38 00 00 0d li r0,13
ffc1b128: 7f 5a 03 d6 divw r26,r26,r0
((name_len - 1) + MSDOS_LFN_LEN_PER_ENTRY) / MSDOS_LFN_LEN_PER_ENTRY;
if (FAT_FD_OF_ROOT_DIR(fat_fd) &&
ffc1b12c: 80 1d 00 20 lwz r0,32(r29)
ffc1b130: 2f 80 00 01 cmpwi cr7,r0,1
ffc1b134: 40 be 00 24 bne+ cr7,ffc1b158 <msdos_find_name_in_fat_file+0xcc>
ffc1b138: 80 1d 00 24 lwz r0,36(r29)
ffc1b13c: 2f 80 00 00 cmpwi cr7,r0,0
ffc1b140: 40 9e 00 18 bne- cr7,ffc1b158 <msdos_find_name_in_fat_file+0xcc><== NEVER TAKEN
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))
ffc1b144: 88 18 00 0a lbz r0,10(r24)
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) &&
ffc1b148: 70 03 00 03 andi. r3,r0,3
ffc1b14c: 41 82 00 0c beq- ffc1b158 <msdos_find_name_in_fat_file+0xcc><== NEVER TAKEN
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))
bts2rd = fat_fd->fat_file_size;
ffc1b150: 83 fd 00 18 lwz r31,24(r29)
ffc1b154: 48 00 00 08 b ffc1b15c <msdos_find_name_in_fat_file+0xd0>
else
bts2rd = fs_info->fat.vol.bpc;
ffc1b158: a3 f8 00 06 lhz r31,6(r24)
/*
* Remainder is not empty so is this entry empty ?
*/
empty_space_count++;
if (empty_space_count == (lfn_entries + 1))
ffc1b15c: 39 5a 00 01 addi r10,r26,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),
ffc1b160: 3a 20 00 00 li r17,0
/*
* Remainder is not empty so is this entry empty ?
*/
empty_space_count++;
if (empty_space_count == (lfn_entries + 1))
ffc1b164: 91 41 00 1c stw r10,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;
ffc1b168: 38 00 00 00 li r0,0
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;
ffc1b16c: 3a 60 00 00 li r19,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;
ffc1b170: 3a a0 00 00 li r21,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;
ffc1b174: 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;
ffc1b178: 3b c0 00 00 li r30,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;
ffc1b17c: 39 c0 00 00 li r14,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;
ffc1b180: 39 e0 00 00 li r15,0
char *name_dir_entry
)
{
ssize_t ret = 0;
msdos_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t dir_offset = 0;
ffc1b184: 3a 40 00 00 li r18,0
ffc1b188: 2e 0b 00 00 cmpwi cr4,r11,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 ||
ffc1b18c: 2d 88 00 01 cmpwi cr3,r8,1
memcpy(name_dir_entry, entry,
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
return RC_OK;
}
lfn_start.cln = FAT_FILE_SHORT_NAME;
ffc1b190: 3a 00 ff ff li r16,-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),
ffc1b194: 48 00 03 10 b ffc1b4a4 <msdos_find_name_in_fat_file+0x418>
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)
ffc1b198: 2f 83 00 1f cmpwi cr7,r3,31
ffc1b19c: 40 9d 06 dc ble- cr7,ffc1b878 <msdos_find_name_in_fat_file+0x7ec><== NEVER TAKEN
rtems_set_errno_and_return_minus_one(EIO);
assert(ret == bts2rd);
ffc1b1a0: 7f 83 f8 00 cmpw cr7,r3,r31
ffc1b1a4: 41 be 00 28 beq+ cr7,ffc1b1cc <msdos_find_name_in_fat_file+0x140><== ALWAYS TAKEN
ffc1b1a8: 3c a0 ff c3 lis r5,-61 <== NOT EXECUTED
ffc1b1ac: 3c 60 ff c3 lis r3,-61 <== NOT EXECUTED
ffc1b1b0: 38 a5 f2 c0 addi r5,r5,-3392 <== NOT EXECUTED
ffc1b1b4: 3c c0 ff c3 lis r6,-61 <== NOT EXECUTED
ffc1b1b8: 38 63 f3 34 addi r3,r3,-3276 <== NOT EXECUTED
ffc1b1bc: 38 80 04 49 li r4,1097 <== NOT EXECUTED
ffc1b1c0: 38 a5 00 14 addi r5,r5,20 <== NOT EXECUTED
ffc1b1c4: 38 c6 f3 bf addi r6,r6,-3137 <== NOT EXECUTED
ffc1b1c8: 4b fe c0 b9 bl ffc07280 <__assert_func> <== NOT EXECUTED
ffc1b1cc: 3a c0 00 00 li r22,0
* 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)
ffc1b1d0: 2f 93 00 00 cmpwi cr7,r19,0
/* 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;
ffc1b1d4: 81 58 00 9c lwz r10,156(r24)
ffc1b1d8: 7e ea b2 14 add r23,r10,r22
/*
* 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) ==
ffc1b1dc: 7d 4a b0 ae lbzx r10,r10,r22
* 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)
ffc1b1e0: 40 9e 00 0c bne- cr7,ffc1b1ec <msdos_find_name_in_fat_file+0x160><== NEVER TAKEN
ffc1b1e4: 7e d5 b3 78 mr r21,r22
ffc1b1e8: 7e 54 93 78 mr r20,r18
{
empty_space_entry = dir_entry;
empty_space_offset = dir_offset;
}
if (remainder_empty)
ffc1b1ec: 2f 8a 00 00 cmpwi cr7,r10,0
ffc1b1f0: 40 be 00 24 bne+ cr7,ffc1b214 <msdos_find_name_in_fat_file+0x188>
#endif
/*
* If just looking and there is no more entries in the
* directory - return name-not-found
*/
if (!create_node)
ffc1b1f4: 41 92 06 b0 beq- cr4,ffc1b8a4 <msdos_find_name_in_fat_file+0x818>
* 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)
ffc1b1f8: 2f 80 00 00 cmpwi cr7,r0,0
ffc1b1fc: 40 9e 02 f4 bne- cr7,ffc1b4f0 <msdos_find_name_in_fat_file+0x464><== 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;
ffc1b200: 57 e0 d9 7e rlwinm r0,r31,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);
ffc1b204: 7e 73 02 14 add r19,r19,r0
ffc1b208: 56 d6 d9 7e rlwinm r22,r22,27,5,31
* 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)
{
empty_space_count +=
ffc1b20c: 7e 76 98 50 subf r19,r22,r19
ffc1b210: 48 00 02 e0 b ffc1b4f0 <msdos_find_name_in_fat_file+0x464>
printf ("MSFS:[3.2] esf:%i esc%i\n", empty_space_found, empty_space_count);
#endif
}
break;
}
else if (entry_empty)
ffc1b214: 2f 8a 00 e5 cmpwi cr7,r10,229
ffc1b218: 40 be 00 1c bne+ cr7,ffc1b234 <msdos_find_name_in_fat_file+0x1a8><== ALWAYS TAKEN
{
if (create_node)
ffc1b21c: 41 92 02 74 beq- cr4,ffc1b490 <msdos_find_name_in_fat_file+0x404><== NOT EXECUTED
/*
* Remainder is not empty so is this entry empty ?
*/
empty_space_count++;
if (empty_space_count == (lfn_entries + 1))
ffc1b220: 81 41 00 1c lwz r10,28(r1) <== NOT EXECUTED
if (create_node)
{
/*
* Remainder is not empty so is this entry empty ?
*/
empty_space_count++;
ffc1b224: 3a 73 00 01 addi r19,r19,1 <== NOT EXECUTED
if (empty_space_count == (lfn_entries + 1))
ffc1b228: 7f 93 50 00 cmpw cr7,r19,r10 <== NOT EXECUTED
ffc1b22c: 40 be 02 64 bne+ cr7,ffc1b490 <msdos_find_name_in_fat_file+0x404><== NOT EXECUTED
ffc1b230: 48 00 02 5c b ffc1b48c <msdos_find_name_in_fat_file+0x400><== NOT EXECUTED
* 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)
ffc1b234: 41 92 00 14 beq- cr4,ffc1b248 <msdos_find_name_in_fat_file+0x1bc>
ffc1b238: 2f 80 00 00 cmpwi cr7,r0,0
ffc1b23c: 40 9e 00 0c bne- cr7,ffc1b248 <msdos_find_name_in_fat_file+0x1bc><== NEVER TAKEN
{
empty_space_entry = 0;
empty_space_count = 0;
ffc1b240: 3a 60 00 00 li r19,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;
ffc1b244: 3a a0 00 00 li r21,0
/*
* Check the attribute to see if the entry is for a long
* file name.
*/
if ((*MSDOS_DIR_ATTR(entry) & MSDOS_ATTR_LFN_MASK) ==
ffc1b248: 88 f7 00 0b lbz r7,11(r23)
ffc1b24c: 54 e7 06 be clrlwi r7,r7,26
ffc1b250: 2f 87 00 0f cmpwi cr7,r7,15
ffc1b254: 40 be 01 1c bne+ cr7,ffc1b370 <msdos_find_name_in_fat_file+0x2e4>
#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)
ffc1b258: 80 e1 00 0c lwz r7,12(r1)
ffc1b25c: 2f 87 ff ff cmpwi cr7,r7,-1
ffc1b260: 40 be 00 2c bne+ cr7,ffc1b28c <msdos_find_name_in_fat_file+0x200>
/*
* The first entry must have the last long entry
* flag set.
*/
if ((*MSDOS_DIR_ENTRY_TYPE(entry) &
ffc1b264: 71 43 00 40 andi. r3,r10,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;
ffc1b268: 39 e0 00 00 li r15,0
/*
* The first entry must have the last long entry
* flag set.
*/
if ((*MSDOS_DIR_ENTRY_TYPE(entry) &
ffc1b26c: 41 82 02 24 beq- ffc1b490 <msdos_find_name_in_fat_file+0x404>
* 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) &
ffc1b270: 55 4a 06 be clrlwi r10,r10,26
ffc1b274: 7f 9a 50 00 cmpw cr7,r26,r10
ffc1b278: 40 be 02 18 bne+ cr7,ffc1b490 <msdos_find_name_in_fat_file+0x404>
continue;
/*
* Get the checksum of the short entry.
*/
lfn_start.cln = dir_offset;
ffc1b27c: 92 41 00 0c stw r18,12(r1)
lfn_start.ofs = dir_entry;
lfn_entry = lfn_entries;
lfn_checksum = *MSDOS_DIR_LFN_CHECKSUM(entry);
ffc1b280: 7f 5e d3 78 mr r30,r26
/*
* Get the checksum of the short entry.
*/
lfn_start.cln = dir_offset;
lfn_start.ofs = dir_entry;
ffc1b284: 92 c1 00 10 stw r22,16(r1)
lfn_entry = lfn_entries;
lfn_checksum = *MSDOS_DIR_LFN_CHECKSUM(entry);
ffc1b288: 89 d7 00 0d lbz r14,13(r23)
* 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) &
ffc1b28c: 89 57 00 00 lbz r10,0(r23)
ffc1b290: 55 4a 06 be clrlwi r10,r10,26
ffc1b294: 7f 9e 50 00 cmpw cr7,r30,r10
ffc1b298: 40 be 00 10 bne+ cr7,ffc1b2a8 <msdos_find_name_in_fat_file+0x21c><== NEVER TAKEN
MSDOS_LAST_LONG_ENTRY_MASK)) ||
ffc1b29c: 89 57 00 0d lbz r10,13(r23)
ffc1b2a0: 7f 8a 70 00 cmpw cr7,r10,r14
ffc1b2a4: 41 9e 00 0c beq- cr7,ffc1b2b0 <msdos_find_name_in_fat_file+0x224><== 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;
ffc1b2a8: 92 01 00 0c stw r16,12(r1) <== NOT EXECUTED
continue;
ffc1b2ac: 48 00 01 e4 b ffc1b490 <msdos_find_name_in_fat_file+0x404><== NOT EXECUTED
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++)
ffc1b2b0: 38 a0 00 0d li r5,13
ffc1b2b4: 7c a9 03 a6 mtctr r5
#endif
lfn_start.cln = FAT_FILE_SHORT_NAME;
continue;
}
lfn_entry--;
ffc1b2b8: 38 fe ff ff addi r7,r30,-1
o = lfn_entry * MSDOS_LFN_LEN_PER_ENTRY;
ffc1b2bc: 1c c7 00 0d mulli r6,r7,13
p = entry + 1;
ffc1b2c0: 3a f7 00 01 addi r23,r23,1
#if MSDOS_FIND_PRINT
printf ("MSFS:[5] lfne:%i\n", lfn_entry);
#endif
for (i = 0; i < MSDOS_LFN_LEN_PER_ENTRY; i++)
ffc1b2c4: 39 40 00 00 li r10,0
{
#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')
ffc1b2c8: 88 b7 00 00 lbz r5,0(r23)
ffc1b2cc: 2f 85 00 00 cmpwi cr7,r5,0
ffc1b2d0: 40 be 00 1c bne+ cr7,ffc1b2ec <msdos_find_name_in_fat_file+0x260>
/*
* 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) &&
ffc1b2d4: 7f 9e d0 00 cmpw cr7,r30,r26
ffc1b2d8: 40 be 00 6c bne+ cr7,ffc1b344 <msdos_find_name_in_fat_file+0x2b8><== NEVER TAKEN
((o + i) != name_len))
ffc1b2dc: 7d 46 52 14 add r10,r6,r10
/*
* 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) &&
ffc1b2e0: 7f 8a 48 00 cmpw cr7,r10,r9
ffc1b2e4: 40 be 00 28 bne+ cr7,ffc1b30c <msdos_find_name_in_fat_file+0x280><== NEVER TAKEN
ffc1b2e8: 48 00 00 5c b ffc1b344 <msdos_find_name_in_fat_file+0x2b8>
* 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(
ffc1b2ec: 7c 8a 32 14 add r4,r10,r6
((o + i) != name_len))
lfn_start.cln = FAT_FILE_SHORT_NAME;
break;
}
if (((o + i) >= name_len) || (*p != name[o + i]))
ffc1b2f0: 7f 84 48 00 cmpw cr7,r4,r9
ffc1b2f4: 40 9c 00 18 bge- cr7,ffc1b30c <msdos_find_name_in_fat_file+0x280>
* 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(
ffc1b2f8: 80 61 00 18 lwz r3,24(r1)
ffc1b2fc: 7c 83 32 14 add r4,r3,r6
((o + i) != name_len))
lfn_start.cln = FAT_FILE_SHORT_NAME;
break;
}
if (((o + i) >= name_len) || (*p != name[o + i]))
ffc1b300: 7c 84 50 ae lbzx r4,r4,r10
ffc1b304: 7f 84 28 00 cmpw cr7,r4,r5
ffc1b308: 41 be 00 0c beq+ cr7,ffc1b314 <msdos_find_name_in_fat_file+0x288>
{
lfn_start.cln = FAT_FILE_SHORT_NAME;
ffc1b30c: 92 01 00 0c stw r16,12(r1)
break;
ffc1b310: 48 00 00 34 b ffc1b344 <msdos_find_name_in_fat_file+0x2b8>
}
switch (i)
ffc1b314: 2f 8a 00 04 cmpwi cr7,r10,4
ffc1b318: 41 9e 00 10 beq- cr7,ffc1b328 <msdos_find_name_in_fat_file+0x29c>
ffc1b31c: 2f 8a 00 0a cmpwi cr7,r10,10
ffc1b320: 40 be 00 18 bne+ cr7,ffc1b338 <msdos_find_name_in_fat_file+0x2ac>
ffc1b324: 48 00 00 0c b ffc1b330 <msdos_find_name_in_fat_file+0x2a4>
{
case 4:
p += 5;
ffc1b328: 3a f7 00 05 addi r23,r23,5
break;
ffc1b32c: 48 00 00 10 b ffc1b33c <msdos_find_name_in_fat_file+0x2b0>
case 10:
p += 4;
ffc1b330: 3a f7 00 04 addi r23,r23,4
break;
ffc1b334: 48 00 00 08 b ffc1b33c <msdos_find_name_in_fat_file+0x2b0>
default:
p += 2;
ffc1b338: 3a f7 00 02 addi r23,r23,2
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++)
ffc1b33c: 39 4a 00 01 addi r10,r10,1
ffc1b340: 42 00 ff 88 bdnz+ ffc1b2c8 <msdos_find_name_in_fat_file+0x23c>
p += 2;
break;
}
}
lfn_matched = ((lfn_entry == 0) &&
ffc1b344: 2f 87 00 00 cmpwi cr7,r7,0
ffc1b348: 39 e0 00 00 li r15,0
ffc1b34c: 40 9e 00 18 bne- cr7,ffc1b364 <msdos_find_name_in_fat_file+0x2d8>
* 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(
ffc1b350: 81 e1 00 0c lwz r15,12(r1)
ffc1b354: 39 ef 00 01 addi r15,r15,1
ffc1b358: 7d ef 00 34 cntlzw r15,r15
ffc1b35c: 55 ef d9 7e rlwinm r15,r15,27,5,31
ffc1b360: 69 ef 00 01 xori r15,r15,1
p += 2;
break;
}
}
lfn_matched = ((lfn_entry == 0) &&
ffc1b364: 55 ef 06 3e clrlwi r15,r15,24
#endif
lfn_start.cln = FAT_FILE_SHORT_NAME;
continue;
}
lfn_entry--;
ffc1b368: 7c fe 3b 78 mr r30,r7
ffc1b36c: 48 00 01 24 b ffc1b490 <msdos_find_name_in_fat_file+0x404>
* 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)
ffc1b370: 2f 8f 00 00 cmpwi cr7,r15,0
ffc1b374: 41 9e 00 50 beq- cr7,ffc1b3c4 <msdos_find_name_in_fat_file+0x338>
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;
ffc1b378: 38 a0 00 0b li r5,11
ffc1b37c: 7c a9 03 a6 mtctr r5
* 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)
ffc1b380: 38 e0 00 00 li r7,0
ffc1b384: 39 40 00 00 li r10,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;
ffc1b388: 71 43 00 01 andi. r3,r10,1
ffc1b38c: 38 c0 00 00 li r6,0
ffc1b390: 41 82 00 08 beq- ffc1b398 <msdos_find_name_in_fat_file+0x30c>
ffc1b394: 38 c0 00 80 li r6,128
ffc1b398: 7c b7 38 ae lbzx r5,r23,r7
ffc1b39c: 55 4a f8 7e rlwinm r10,r10,31,1,31
{
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++)
ffc1b3a0: 38 e7 00 01 addi r7,r7,1
cs = ((cs & 1) ? 0x80 : 0) + (cs >> 1) + *p;
ffc1b3a4: 7d 45 52 14 add r10,r5,r10
ffc1b3a8: 7d 4a 32 14 add r10,r10,r6
ffc1b3ac: 55 4a 06 3e clrlwi r10,r10,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++)
ffc1b3b0: 42 00 ff d8 bdnz+ ffc1b388 <msdos_find_name_in_fat_file+0x2fc>
cs = ((cs & 1) ? 0x80 : 0) + (cs >> 1) + *p;
if (lfn_entry || (lfn_checksum != cs))
ffc1b3b4: 2f 9e 00 00 cmpwi cr7,r30,0
ffc1b3b8: 40 9e 00 0c bne- cr7,ffc1b3c4 <msdos_find_name_in_fat_file+0x338><== NEVER TAKEN
ffc1b3bc: 7f 8e 50 00 cmpw cr7,r14,r10
ffc1b3c0: 41 9e 00 4c beq- cr7,ffc1b40c <msdos_find_name_in_fat_file+0x380><== 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 ||
ffc1b3c4: 40 ae 00 bc bne+ cr3,ffc1b480 <msdos_find_name_in_fat_file+0x3f4>
((name_type == MSDOS_NAME_SHORT) &&
ffc1b3c8: 81 41 00 0c lwz r10,12(r1)
ffc1b3cc: 2f 8a ff ff cmpwi cr7,r10,-1
ffc1b3d0: 40 be 00 b0 bne+ cr7,ffc1b480 <msdos_find_name_in_fat_file+0x3f4><== NEVER TAKEN
(lfn_start.cln == FAT_FILE_SHORT_NAME) &&
(memcmp(MSDOS_DIR_NAME(entry),
ffc1b3d4: 7e e3 bb 78 mr r3,r23
ffc1b3d8: 90 01 00 28 stw r0,40(r1)
ffc1b3dc: 7f 64 db 78 mr r4,r27
ffc1b3e0: 38 a0 00 0b li r5,11
ffc1b3e4: 91 01 00 24 stw r8,36(r1)
ffc1b3e8: 91 21 00 2c stw r9,44(r1)
ffc1b3ec: 91 61 00 20 stw r11,32(r1)
ffc1b3f0: 48 00 3b 79 bl ffc1ef68 <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) &&
ffc1b3f4: 2f 83 00 00 cmpwi cr7,r3,0
ffc1b3f8: 80 01 00 28 lwz r0,40(r1)
ffc1b3fc: 81 01 00 24 lwz r8,36(r1)
ffc1b400: 81 21 00 2c lwz r9,44(r1)
ffc1b404: 81 61 00 20 lwz r11,32(r1)
ffc1b408: 40 be 00 78 bne+ cr7,ffc1b480 <msdos_find_name_in_fat_file+0x3f4>
#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,
ffc1b40c: 7f 23 cb 78 mr r3,r25
ffc1b410: 7f a4 eb 78 mr r4,r29
ffc1b414: 38 a0 00 01 li r5,1
ffc1b418: 7e 26 8b 78 mr r6,r17
ffc1b41c: 7f 87 e3 78 mr r7,r28
ffc1b420: 4c c6 31 82 crclr 4*cr1+eq
ffc1b424: 4b ff 8e 99 bl ffc142bc <fat_file_ioctl>
dir_offset * bts2rd,
&dir_pos->sname.cln);
if (rc != RC_OK)
ffc1b428: 7c 7e 1b 79 mr. r30,r3
ffc1b42c: 40 82 04 8c bne- ffc1b8b8 <msdos_find_name_in_fat_file+0x82c><== NEVER TAKEN
return rc;
dir_pos->sname.ofs = dir_entry;
if (lfn_start.cln != FAT_FILE_SHORT_NAME)
ffc1b430: 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;
ffc1b434: 92 dc 00 04 stw r22,4(r28)
if (lfn_start.cln != FAT_FILE_SHORT_NAME)
ffc1b438: 2f 86 ff ff cmpwi cr7,r6,-1
ffc1b43c: 41 9e 00 28 beq- cr7,ffc1b464 <msdos_find_name_in_fat_file+0x3d8>
{
rc = fat_file_ioctl(mt_entry, fat_fd, F_CLU_NUM,
ffc1b440: 7c df 31 d6 mullw r6,r31,r6
ffc1b444: 7f 23 cb 78 mr r3,r25
ffc1b448: 7f a4 eb 78 mr r4,r29
ffc1b44c: 38 a0 00 01 li r5,1
ffc1b450: 38 e1 00 0c addi r7,r1,12
ffc1b454: 4c c6 31 82 crclr 4*cr1+eq
ffc1b458: 4b ff 8e 65 bl ffc142bc <fat_file_ioctl>
lfn_start.cln * bts2rd,
&lfn_start.cln);
if (rc != RC_OK)
ffc1b45c: 2c 03 00 00 cmpwi r3,0
ffc1b460: 40 82 04 4c bne- ffc1b8ac <msdos_find_name_in_fat_file+0x820><== NEVER TAKEN
return rc;
}
dir_pos->lname.cln = lfn_start.cln;
ffc1b464: 80 01 00 0c lwz r0,12(r1)
ffc1b468: 90 1c 00 08 stw r0,8(r28)
dir_pos->lname.ofs = lfn_start.ofs;
ffc1b46c: 80 01 00 10 lwz r0,16(r1)
ffc1b470: 90 1c 00 0c stw r0,12(r28)
memcpy(name_dir_entry, entry,
ffc1b474: 7c b7 04 aa lswi r5,r23,32
ffc1b478: 7c bb 05 aa stswi r5,r27,32
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
return RC_OK;
ffc1b47c: 48 00 04 3c b ffc1b8b8 <msdos_find_name_in_fat_file+0x82c>
}
lfn_start.cln = FAT_FILE_SHORT_NAME;
ffc1b480: 92 01 00 0c stw r16,12(r1)
lfn_matched = false;
ffc1b484: 39 e0 00 00 li r15,0
ffc1b488: 48 00 00 08 b ffc1b490 <msdos_find_name_in_fat_file+0x404>
* Remainder is not empty so is this entry empty ?
*/
empty_space_count++;
if (empty_space_count == (lfn_entries + 1))
empty_space_found = true;
ffc1b48c: 38 00 00 01 li r0,1 <== 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)
ffc1b490: 3a d6 00 20 addi r22,r22,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;
ffc1b494: 7f 96 f8 40 cmplw cr7,r22,r31
ffc1b498: 41 9c fd 38 blt+ cr7,ffc1b1d0 <msdos_find_name_in_fat_file+0x144><== ALWAYS TAKEN
ffc1b49c: 7e 31 fa 14 add r17,r17,r31 <== NOT EXECUTED
}
if (remainder_empty)
break;
dir_offset++;
ffc1b4a0: 3a 52 00 01 addi r18,r18,1 <== NOT EXECUTED
/*
* 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),
ffc1b4a4: 80 f8 00 9c lwz r7,156(r24)
ffc1b4a8: 7f 23 cb 78 mr r3,r25
ffc1b4ac: 7f a4 eb 78 mr r4,r29
ffc1b4b0: 90 01 00 28 stw r0,40(r1)
ffc1b4b4: 7e 25 8b 78 mr r5,r17
ffc1b4b8: 7f e6 fb 78 mr r6,r31
ffc1b4bc: 91 01 00 24 stw r8,36(r1)
ffc1b4c0: 91 21 00 2c stw r9,44(r1)
ffc1b4c4: 91 61 00 20 stw r11,32(r1)
ffc1b4c8: 4b ff 8a 6d bl ffc13f34 <fat_file_read>
ffc1b4cc: 2c 03 00 00 cmpwi r3,0
ffc1b4d0: 80 01 00 28 lwz r0,40(r1)
ffc1b4d4: 81 01 00 24 lwz r8,36(r1)
ffc1b4d8: 81 21 00 2c lwz r9,44(r1)
ffc1b4dc: 81 61 00 20 lwz r11,32(r1)
ffc1b4e0: 40 82 fc b8 bne+ ffc1b198 <msdos_find_name_in_fat_file+0x10c><== ALWAYS TAKEN
}
/*
* If we are not to create the entry return a not found error.
*/
if (!create_node)
ffc1b4e4: 2f 8b 00 00 cmpwi cr7,r11,0 <== NOT EXECUTED
return MSDOS_NAME_NOT_FOUND_ERR;
ffc1b4e8: 3b c0 7d 01 li r30,32001 <== NOT EXECUTED
}
/*
* If we are not to create the entry return a not found error.
*/
if (!create_node)
ffc1b4ec: 41 be 03 cc beq+ cr7,ffc1b8b8 <msdos_find_name_in_fat_file+0x82c><== NOT EXECUTED
* 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)
ffc1b4f0: 2f 88 00 02 cmpwi cr7,r8,2
ffc1b4f4: 40 be 00 9c bne+ cr7,ffc1b590 <msdos_find_name_in_fat_file+0x504>
{
int slot = (((empty_space_offset * bts2rd) + empty_space_entry) /
ffc1b4f8: 7d 14 f9 d6 mullw r8,r20,r31
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE) + lfn_entries + 1;
ffc1b4fc: 38 1a 00 01 addi r0,r26,1
* in this directory.
*/
lfn_checksum = 0;
if (name_type == MSDOS_NAME_LONG)
{
int slot = (((empty_space_offset * bts2rd) + empty_space_entry) /
ffc1b500: 7d 08 aa 14 add r8,r8,r21
ffc1b504: 55 08 d9 7e rlwinm r8,r8,27,5,31
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE) + lfn_entries + 1;
ffc1b508: 7d 00 42 14 add r8,r0,r8
{
static const char* hex = "0123456789ABCDEF";
char* c = MSDOS_DIR_NAME(sfn);
int i;
for (i = 0; i < 2; i++, c++)
if ((*c == ' ') || (*c == '.'))
ffc1b50c: 88 1b 00 00 lbz r0,0(r27)
ffc1b510: 2f 80 00 20 cmpwi cr7,r0,32
ffc1b514: 40 be 00 10 bne+ cr7,ffc1b524 <msdos_find_name_in_fat_file+0x498><== ALWAYS TAKEN
*c = '_';
ffc1b518: 38 00 00 5f li r0,95 <== NOT EXECUTED
ffc1b51c: 98 1b 00 00 stb r0,0(r27) <== NOT EXECUTED
ffc1b520: 48 00 00 0c b ffc1b52c <msdos_find_name_in_fat_file+0x4a0><== 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 == '.'))
ffc1b524: 2f 80 00 2e cmpwi cr7,r0,46
ffc1b528: 41 be ff f0 beq- cr7,ffc1b518 <msdos_find_name_in_fat_file+0x48c><== NEVER TAKEN
ffc1b52c: 88 1b 00 01 lbz r0,1(r27)
ffc1b530: 2f 80 00 20 cmpwi cr7,r0,32
ffc1b534: 40 be 00 10 bne+ cr7,ffc1b544 <msdos_find_name_in_fat_file+0x4b8><== ALWAYS TAKEN
*c = '_';
ffc1b538: 38 00 00 5f li r0,95 <== NOT EXECUTED
ffc1b53c: 98 1b 00 01 stb r0,1(r27) <== NOT EXECUTED
ffc1b540: 48 00 00 0c b ffc1b54c <msdos_find_name_in_fat_file+0x4c0><== 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 == '.'))
ffc1b544: 2f 80 00 2e cmpwi cr7,r0,46
ffc1b548: 41 be ff f0 beq- cr7,ffc1b538 <msdos_find_name_in_fat_file+0x4ac><== NEVER TAKEN
*c = '_';
for (i = 0; i < 4; i++, c++)
*c = hex[(num >> ((3 - i) * 4)) & 0xf];
ffc1b54c: 38 a0 00 04 li r5,4
ffc1b550: 7c a9 03 a6 mtctr r5
msdos_short_name_hex(char* sfn, int num)
{
static const char* hex = "0123456789ABCDEF";
char* c = MSDOS_DIR_NAME(sfn);
int i;
for (i = 0; i < 2; i++, c++)
ffc1b554: 39 7b 00 02 addi r11,r27,2
ffc1b558: 39 20 00 0c li r9,12
if ((*c == ' ') || (*c == '.'))
*c = '_';
for (i = 0; i < 4; i++, c++)
*c = hex[(num >> ((3 - i) * 4)) & 0xf];
ffc1b55c: 3d 40 ff c3 lis r10,-61
ffc1b560: 7d 00 4e 30 sraw r0,r8,r9
ffc1b564: 54 00 07 3e clrlwi r0,r0,28
ffc1b568: 38 ea eb d8 addi r7,r10,-5160
ffc1b56c: 7c 07 00 ae lbzx r0,r7,r0
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++)
ffc1b570: 39 29 ff fc addi r9,r9,-4
*c = hex[(num >> ((3 - i) * 4)) & 0xf];
ffc1b574: 98 0b 00 00 stb r0,0(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++)
ffc1b578: 39 6b 00 01 addi r11,r11,1
ffc1b57c: 42 00 ff e4 bdnz+ ffc1b560 <msdos_find_name_in_fat_file+0x4d4>
*c = hex[(num >> ((3 - i) * 4)) & 0xf];
*c++ = '~';
ffc1b580: 38 00 00 7e li r0,126
ffc1b584: 98 1b 00 06 stb r0,6(r27)
*c++ = '1';
ffc1b588: 38 00 00 31 li r0,49
ffc1b58c: 98 1b 00 07 stb r0,7(r27)
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)
ffc1b590: 2f 9a 00 00 cmpwi cr7,r26,0
* If a long file name calculate the checksum of the short file name
* 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;
ffc1b594: 3a 20 00 00 li r17,0
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)
ffc1b598: 41 9e 00 3c beq- cr7,ffc1b5d4 <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 =
ffc1b59c: 38 c0 00 0b li r6,11
ffc1b5a0: 7c c9 03 a6 mtctr r6
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)
ffc1b5a4: 39 20 00 00 li r9,0
{
uint8_t* p = (uint8_t*) MSDOS_DIR_NAME(name_dir_entry);
int i;
for (i = 0; i < 11; i++, p++)
lfn_checksum =
ffc1b5a8: 72 27 00 01 andi. r7,r17,1
ffc1b5ac: 38 00 00 00 li r0,0
ffc1b5b0: 41 82 00 08 beq- ffc1b5b8 <msdos_find_name_in_fat_file+0x52c>
ffc1b5b4: 38 00 00 80 li r0,128
ffc1b5b8: 7d 7b 48 ae lbzx r11,r27,r9
ffc1b5bc: 56 31 f8 7e rlwinm r17,r17,31,1,31
if (lfn_entries)
{
uint8_t* p = (uint8_t*) MSDOS_DIR_NAME(name_dir_entry);
int i;
for (i = 0; i < 11; i++, p++)
ffc1b5c0: 39 29 00 01 addi r9,r9,1
lfn_checksum =
ffc1b5c4: 7e 2b 8a 14 add r17,r11,r17
ffc1b5c8: 7e 31 02 14 add r17,r17,r0
ffc1b5cc: 56 31 06 3e clrlwi r17,r17,24
if (lfn_entries)
{
uint8_t* p = (uint8_t*) MSDOS_DIR_NAME(name_dir_entry);
int i;
for (i = 0; i < 11; i++, p++)
ffc1b5d0: 42 00 ff d8 bdnz+ ffc1b5a8 <msdos_find_name_in_fat_file+0x51c>
* 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)
ffc1b5d4: 2f 93 00 00 cmpwi cr7,r19,0
ffc1b5d8: 41 9e 00 18 beq- cr7,ffc1b5f0 <msdos_find_name_in_fat_file+0x564><== NEVER TAKEN
}
/*
* Have we read past the empty block ? If so go back and read it again.
*/
if (dir_offset != empty_space_offset)
ffc1b5dc: 7f 92 a0 00 cmpw cr7,r18,r20
read_cluster = true;
ffc1b5e0: 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)
ffc1b5e4: 40 be 00 18 bne+ cr7,ffc1b5fc <msdos_find_name_in_fat_file+0x570><== NEVER TAKEN
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;
ffc1b5e8: 38 00 00 00 li r0,0
ffc1b5ec: 48 00 00 10 b ffc1b5fc <msdos_find_name_in_fat_file+0x570>
* 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)
ffc1b5f0: 7e 54 93 78 mr r20,r18 <== NOT EXECUTED
{
read_cluster = true;
ffc1b5f4: 38 00 00 01 li r0,1 <== NOT EXECUTED
empty_space_offset = dir_offset;
empty_space_entry = 0;
ffc1b5f8: 3a a0 00 00 li r21,0 <== NOT EXECUTED
read_cluster = true;
/*
* Handle the entry writes.
*/
lfn_start.cln = lfn_start.ofs = FAT_FILE_SHORT_NAME;
ffc1b5fc: 39 20 ff ff li r9,-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(
ffc1b600: 81 61 00 18 lwz r11,24(r1)
read_cluster = true;
/*
* Handle the entry writes.
*/
lfn_start.cln = lfn_start.ofs = FAT_FILE_SHORT_NAME;
ffc1b604: 91 21 00 10 stw r9,16(r1)
ffc1b608: 7e f4 f9 d6 mullw r23,r20,r31
ffc1b60c: 91 21 00 0c stw r9,12(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(
ffc1b610: 1d 3a 00 0d mulli r9,r26,13
ffc1b614: 39 eb ff f3 addi r15,r11,-13
/*
* Handle the entry writes.
*/
lfn_start.cln = lfn_start.ofs = FAT_FILE_SHORT_NAME;
lfn_entry = 0;
ffc1b618: 3a 60 00 00 li r19,0
* 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(
ffc1b61c: 3a 1a 00 01 addi r16,r26,1
ffc1b620: 7d ef 4a 14 add r15,r15,r9
#endif
/*
* The one more is the short entry.
*/
while (lfn_entry < (lfn_entries + 1))
ffc1b624: 48 00 02 70 b ffc1b894 <msdos_find_name_in_fat_file+0x808>
{
int length = 0;
if (read_cluster)
ffc1b628: 2f 80 00 00 cmpwi cr7,r0,0
ffc1b62c: 41 be 00 24 beq+ cr7,ffc1b650 <msdos_find_name_in_fat_file+0x5c4><== ALWAYS TAKEN
{
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,
ffc1b630: 80 f8 00 9c lwz r7,156(r24) <== NOT EXECUTED
ffc1b634: 7f 23 cb 78 mr r3,r25 <== NOT EXECUTED
ffc1b638: 7f a4 eb 78 mr r4,r29 <== NOT EXECUTED
ffc1b63c: 7e e5 bb 78 mr r5,r23 <== NOT EXECUTED
ffc1b640: 7f e6 fb 78 mr r6,r31 <== NOT EXECUTED
ffc1b644: 4b ff 88 f1 bl ffc13f34 <fat_file_read> <== NOT EXECUTED
(empty_space_offset * bts2rd), bts2rd,
fs_info->cl_buf);
if (ret != bts2rd)
ffc1b648: 7f 83 f8 00 cmpw cr7,r3,r31 <== NOT EXECUTED
ffc1b64c: 40 be 00 28 bne+ cr7,ffc1b674 <msdos_find_name_in_fat_file+0x5e8><== NOT EXECUTED
* 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(
ffc1b650: 3b d3 00 01 addi r30,r19,1
ffc1b654: 1c 13 00 0d mulli r0,r19,13
#endif
ret = fat_file_read(mt_entry, fat_fd,
(empty_space_offset * bts2rd), bts2rd,
fs_info->cl_buf);
if (ret != bts2rd)
ffc1b658: 7f de 80 50 subf r30,r30,r16
ffc1b65c: 57 de 06 3e clrlwi r30,r30,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(
ffc1b660: 7e ae ab 78 mr r14,r21
ffc1b664: 39 20 00 00 li r9,0
ffc1b668: 3a 40 00 00 li r18,0
ffc1b66c: 7c 00 78 50 subf r0,r0,r15
ffc1b670: 48 00 01 d0 b ffc1b840 <msdos_find_name_in_fat_file+0x7b4>
(empty_space_offset * bts2rd), bts2rd,
fs_info->cl_buf);
if (ret != bts2rd)
{
if (ret != FAT_EOF)
ffc1b674: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc1b678: 40 9e 02 00 bne- cr7,ffc1b878 <msdos_find_name_in_fat_file+0x7ec><== 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,
ffc1b67c: 7f 23 cb 78 mr r3,r25 <== NOT EXECUTED
ffc1b680: 7f a4 eb 78 mr r4,r29 <== NOT EXECUTED
ffc1b684: 7e e5 bb 78 mr r5,r23 <== NOT EXECUTED
ffc1b688: 38 c1 00 08 addi r6,r1,8 <== NOT EXECUTED
ffc1b68c: 4b ff 8d 09 bl ffc14394 <fat_file_extend> <== NOT EXECUTED
&new_length);
if (ret != RC_OK)
ffc1b690: 7c 7e 1b 79 mr. r30,r3 <== NOT EXECUTED
ffc1b694: 40 82 02 24 bne- ffc1b8b8 <msdos_find_name_in_fat_file+0x82c><== 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))
ffc1b698: 80 01 00 08 lwz r0,8(r1) <== NOT EXECUTED
ffc1b69c: 7f 80 b8 00 cmpw cr7,r0,r23 <== NOT EXECUTED
ffc1b6a0: 40 9e 01 d8 bne- cr7,ffc1b878 <msdos_find_name_in_fat_file+0x7ec><== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
memset(fs_info->cl_buf, 0, bts2rd);
ffc1b6a4: 80 78 00 9c lwz r3,156(r24) <== NOT EXECUTED
ffc1b6a8: 38 80 00 00 li r4,0 <== NOT EXECUTED
ffc1b6ac: 7f e5 fb 78 mr r5,r31 <== NOT EXECUTED
ffc1b6b0: 48 00 3a 41 bl ffc1f0f0 <memset> <== NOT EXECUTED
ret = fat_file_write(mt_entry, fat_fd,
ffc1b6b4: 80 f8 00 9c lwz r7,156(r24) <== NOT EXECUTED
ffc1b6b8: 7f 23 cb 78 mr r3,r25 <== NOT EXECUTED
ffc1b6bc: 7f a4 eb 78 mr r4,r29 <== NOT EXECUTED
ffc1b6c0: 7e e5 bb 78 mr r5,r23 <== NOT EXECUTED
ffc1b6c4: 7f e6 fb 78 mr r6,r31 <== NOT EXECUTED
ffc1b6c8: 4b ff 8e c5 bl ffc1458c <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)
ffc1b6cc: 2f 83 ff ff cmpwi cr7,r3,-1 <== NOT EXECUTED
ffc1b6d0: 41 9e 01 e4 beq- cr7,ffc1b8b4 <msdos_find_name_in_fat_file+0x828><== NOT EXECUTED
return ret;
else if (ret != bts2rd)
ffc1b6d4: 7f 83 f8 00 cmpw cr7,r3,r31 <== NOT EXECUTED
ffc1b6d8: 41 9e ff 78 beq+ cr7,ffc1b650 <msdos_find_name_in_fat_file+0x5c4><== NOT EXECUTED
ffc1b6dc: 48 00 01 9c b ffc1b878 <msdos_find_name_in_fat_file+0x7ec><== NOT EXECUTED
const char* n;
int i;
char fill = 0;
length += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE;
lfn_entry++;
ffc1b6e0: 3a 73 00 01 addi r19,r19,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;
ffc1b6e4: 82 d8 00 9c lwz r22,156(r24)
length, lfn_entry);
#endif
/*
* Time to write the short file name entry.
*/
if (lfn_entry == (lfn_entries + 1))
ffc1b6e8: 7f 93 80 00 cmpw cr7,r19,r16
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;
ffc1b6ec: 7e d6 72 14 add r22,r22,r14
char* p;
const char* n;
int i;
char fill = 0;
length += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE;
ffc1b6f0: 3a 52 00 20 addi r18,r18,32
length, lfn_entry);
#endif
/*
* Time to write the short file name entry.
*/
if (lfn_entry == (lfn_entries + 1))
ffc1b6f4: 40 be 00 78 bne+ cr7,ffc1b76c <msdos_find_name_in_fat_file+0x6e0>
{
/* get current cluster number */
int rc = fat_file_ioctl(mt_entry, fat_fd, F_CLU_NUM,
ffc1b6f8: 7f 23 cb 78 mr r3,r25
ffc1b6fc: 7f a4 eb 78 mr r4,r29
ffc1b700: 38 a0 00 01 li r5,1
ffc1b704: 7e e6 bb 78 mr r6,r23
ffc1b708: 7f 87 e3 78 mr r7,r28
ffc1b70c: 4c c6 31 82 crclr 4*cr1+eq
ffc1b710: 4b ff 8b ad bl ffc142bc <fat_file_ioctl>
empty_space_offset * bts2rd,
&dir_pos->sname.cln);
if (rc != RC_OK)
ffc1b714: 7c 7e 1b 79 mr. r30,r3
ffc1b718: 40 82 01 a0 bne- ffc1b8b8 <msdos_find_name_in_fat_file+0x82c><== NEVER TAKEN
return rc;
dir_pos->sname.ofs = dir_entry;
if (lfn_start.cln != FAT_FILE_SHORT_NAME)
ffc1b71c: 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;
ffc1b720: 91 dc 00 04 stw r14,4(r28)
if (lfn_start.cln != FAT_FILE_SHORT_NAME)
ffc1b724: 2f 86 ff ff cmpwi cr7,r6,-1
ffc1b728: 41 9e 00 28 beq- cr7,ffc1b750 <msdos_find_name_in_fat_file+0x6c4>
{
rc = fat_file_ioctl(mt_entry, fat_fd, F_CLU_NUM,
ffc1b72c: 7c df 31 d6 mullw r6,r31,r6
ffc1b730: 7f 23 cb 78 mr r3,r25
ffc1b734: 7f a4 eb 78 mr r4,r29
ffc1b738: 38 a0 00 01 li r5,1
ffc1b73c: 38 e1 00 0c addi r7,r1,12
ffc1b740: 4c c6 31 82 crclr 4*cr1+eq
ffc1b744: 4b ff 8b 79 bl ffc142bc <fat_file_ioctl>
lfn_start.cln * bts2rd,
&lfn_start.cln);
if (rc != RC_OK)
ffc1b748: 7c 7e 1b 79 mr. r30,r3
ffc1b74c: 40 82 01 6c bne- ffc1b8b8 <msdos_find_name_in_fat_file+0x82c><== NEVER TAKEN
return rc;
}
dir_pos->lname.cln = lfn_start.cln;
ffc1b750: 80 01 00 0c lwz r0,12(r1)
ffc1b754: 90 1c 00 08 stw r0,8(r28)
dir_pos->lname.ofs = lfn_start.ofs;
ffc1b758: 80 01 00 10 lwz r0,16(r1)
ffc1b75c: 90 1c 00 0c stw r0,12(r28)
/* write new node entry */
memcpy (entry, (uint8_t *) name_dir_entry,
ffc1b760: 7c bb 04 aa lswi r5,r27,32
ffc1b764: 7c b6 05 aa stswi r5,r22,32
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
break;
ffc1b768: 48 00 00 e0 b ffc1b848 <msdos_find_name_in_fat_file+0x7bc>
* 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)
ffc1b76c: 81 61 00 0c lwz r11,12(r1)
ffc1b770: 2f 8b ff ff cmpwi cr7,r11,-1
ffc1b774: 40 be 00 0c bne+ cr7,ffc1b780 <msdos_find_name_in_fat_file+0x6f4>
{
lfn_start.cln = empty_space_offset;
ffc1b778: 92 81 00 0c stw r20,12(r1)
lfn_start.ofs = dir_entry;
ffc1b77c: 91 c1 00 10 stw r14,16(r1)
}
/*
* Clear the entry before loading the data.
*/
memset (entry, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
ffc1b780: 7e c3 b3 78 mr r3,r22
ffc1b784: 90 01 00 28 stw r0,40(r1)
ffc1b788: 38 80 00 00 li r4,0
ffc1b78c: 38 a0 00 20 li r5,32
ffc1b790: 91 21 00 2c stw r9,44(r1)
ffc1b794: 48 00 39 5d bl ffc1f0f0 <memset>
}
else
{
p [0] = fill;
p [1] = fill;
fill = 0xff;
ffc1b798: 38 60 00 0d li r3,13
/*
* Clear the entry before loading the data.
*/
memset (entry, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
*MSDOS_DIR_LFN_CHECKSUM(entry) = lfn_checksum;
ffc1b79c: 9a 36 00 0d stb r17,13(r22)
}
else
{
p [0] = fill;
p [1] = fill;
fill = 0xff;
ffc1b7a0: 7c 69 03 a6 mtctr r3
*/
memset (entry, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
*MSDOS_DIR_LFN_CHECKSUM(entry) = lfn_checksum;
p = entry + 1;
ffc1b7a4: 39 76 00 01 addi r11,r22,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(
ffc1b7a8: 80 01 00 28 lwz r0,40(r1)
{
char* entry = (char*) fs_info->cl_buf + dir_entry;
char* p;
const char* n;
int i;
char fill = 0;
ffc1b7ac: 39 00 00 00 li r8,0
* 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(
ffc1b7b0: 81 21 00 2c lwz r9,44(r1)
*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++)
ffc1b7b4: 39 40 00 00 li r10,0
* 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(
ffc1b7b8: 7c e0 4a 14 add r7,r0,r9
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)
ffc1b7bc: 88 c7 00 00 lbz r6,0(r7)
ffc1b7c0: 2f 86 00 00 cmpwi cr7,r6,0
ffc1b7c4: 41 9e 00 10 beq- cr7,ffc1b7d4 <msdos_find_name_in_fat_file+0x748>
{
*p = *n;
ffc1b7c8: 98 cb 00 00 stb r6,0(r11)
n++;
ffc1b7cc: 38 e7 00 01 addi r7,r7,1
ffc1b7d0: 48 00 00 10 b ffc1b7e0 <msdos_find_name_in_fat_file+0x754>
}
else
{
p [0] = fill;
ffc1b7d4: 99 0b 00 00 stb r8,0(r11)
p [1] = fill;
ffc1b7d8: 99 0b 00 01 stb r8,1(r11)
fill = 0xff;
ffc1b7dc: 39 00 00 ff li r8,255
}
switch (i)
ffc1b7e0: 2f 8a 00 04 cmpwi cr7,r10,4
ffc1b7e4: 41 9e 00 10 beq- cr7,ffc1b7f4 <msdos_find_name_in_fat_file+0x768>
ffc1b7e8: 2f 8a 00 0a cmpwi cr7,r10,10
ffc1b7ec: 40 be 00 18 bne+ cr7,ffc1b804 <msdos_find_name_in_fat_file+0x778>
ffc1b7f0: 48 00 00 0c b ffc1b7fc <msdos_find_name_in_fat_file+0x770>
{
case 4:
p += 5;
ffc1b7f4: 39 6b 00 05 addi r11,r11,5
break;
ffc1b7f8: 48 00 00 10 b ffc1b808 <msdos_find_name_in_fat_file+0x77c>
case 10:
p += 4;
ffc1b7fc: 39 6b 00 04 addi r11,r11,4
break;
ffc1b800: 48 00 00 08 b ffc1b808 <msdos_find_name_in_fat_file+0x77c>
default:
p += 2;
ffc1b804: 39 6b 00 02 addi r11,r11,2
*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++)
ffc1b808: 39 4a 00 01 addi r10,r10,1
ffc1b80c: 42 00 ff b0 bdnz+ ffc1b7bc <msdos_find_name_in_fat_file+0x730>
break;
}
}
*MSDOS_DIR_ENTRY_TYPE(entry) = (lfn_entries - lfn_entry) + 1;
if (lfn_entry == 1)
ffc1b810: 2f 93 00 01 cmpwi cr7,r19,1
p += 2;
break;
}
}
*MSDOS_DIR_ENTRY_TYPE(entry) = (lfn_entries - lfn_entry) + 1;
ffc1b814: 9b d6 00 00 stb r30,0(r22)
if (lfn_entry == 1)
ffc1b818: 40 be 00 0c bne+ cr7,ffc1b824 <msdos_find_name_in_fat_file+0x798>
*MSDOS_DIR_ENTRY_TYPE(entry) |= MSDOS_LAST_LONG_ENTRY;
ffc1b81c: 63 cb 00 40 ori r11,r30,64
ffc1b820: 99 76 00 00 stb r11,0(r22)
*MSDOS_DIR_ATTR(entry) |= MSDOS_ATTR_LFN;
ffc1b824: 89 76 00 0b lbz r11,11(r22)
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)
ffc1b828: 3b de ff ff addi r30,r30,-1
ffc1b82c: 39 ce 00 20 addi r14,r14,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;
ffc1b830: 61 6b 00 0f ori r11,r11,15
ffc1b834: 99 76 00 0b stb r11,11(r22)
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)
ffc1b838: 57 de 06 3e clrlwi r30,r30,24
ffc1b83c: 39 29 ff f3 addi r9,r9,-13
#if MSDOS_FIND_PRINT
printf ("MSFS:[10] eso:%li\n", empty_space_offset);
#endif
for (dir_entry = empty_space_entry;
ffc1b840: 7f 8e f8 40 cmplw cr7,r14,r31
ffc1b844: 41 9c fe 9c blt+ cr7,ffc1b6e0 <msdos_find_name_in_fat_file+0x654><== ALWAYS TAKEN
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,
ffc1b848: 80 f8 00 9c lwz r7,156(r24)
ffc1b84c: 7f 23 cb 78 mr r3,r25
ffc1b850: 7f a4 eb 78 mr r4,r29
ffc1b854: 7c b7 aa 14 add r5,r23,r21
ffc1b858: 7e 46 93 78 mr r6,r18
ffc1b85c: 7c e7 aa 14 add r7,r7,r21
ffc1b860: 4b ff 8d 2d bl ffc1458c <fat_file_write>
(empty_space_offset * bts2rd) + empty_space_entry,
length, fs_info->cl_buf + empty_space_entry);
if (ret == -1)
ffc1b864: 2f 83 ff ff cmpwi cr7,r3,-1
ffc1b868: 41 9e 00 4c beq- cr7,ffc1b8b4 <msdos_find_name_in_fat_file+0x828><== NEVER TAKEN
return ret;
else if (ret != length)
ffc1b86c: 7f 83 90 00 cmpw cr7,r3,r18
}
ret = fat_file_write(mt_entry, fat_fd,
(empty_space_offset * bts2rd) + empty_space_entry,
length, fs_info->cl_buf + empty_space_entry);
if (ret == -1)
ffc1b870: 7e f7 fa 14 add r23,r23,r31
return ret;
else if (ret != length)
ffc1b874: 41 be 00 14 beq+ cr7,ffc1b888 <msdos_find_name_in_fat_file+0x7fc><== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one(EIO);
ffc1b878: 48 00 29 61 bl ffc1e1d8 <__errno> <== NOT EXECUTED
ffc1b87c: 38 00 00 05 li r0,5 <== NOT EXECUTED
ffc1b880: 90 03 00 00 stw r0,0(r3) <== NOT EXECUTED
ffc1b884: 48 00 00 30 b ffc1b8b4 <msdos_find_name_in_fat_file+0x828><== NOT EXECUTED
empty_space_offset++;
ffc1b888: 3a 94 00 01 addi r20,r20,1
empty_space_entry = 0;
ffc1b88c: 3a a0 00 00 li r21,0
read_cluster = true;
ffc1b890: 38 00 00 01 li r0,1
#endif
/*
* The one more is the short entry.
*/
while (lfn_entry < (lfn_entries + 1))
ffc1b894: 7f 9a 98 00 cmpw cr7,r26,r19
ffc1b898: 40 9c fd 90 bge+ cr7,ffc1b628 <msdos_find_name_in_fat_file+0x59c>
empty_space_offset++;
empty_space_entry = 0;
read_cluster = true;
}
return 0;
ffc1b89c: 3b c0 00 00 li r30,0
ffc1b8a0: 48 00 00 18 b ffc1b8b8 <msdos_find_name_in_fat_file+0x82c>
/*
* If just looking and there is no more entries in the
* directory - return name-not-found
*/
if (!create_node)
return MSDOS_NAME_NOT_FOUND_ERR;
ffc1b8a4: 3b c0 7d 01 li r30,32001
ffc1b8a8: 48 00 00 10 b ffc1b8b8 <msdos_find_name_in_fat_file+0x82c>
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)
ffc1b8ac: 7c 7e 1b 78 mr r30,r3 <== NOT EXECUTED
ffc1b8b0: 48 00 00 08 b ffc1b8b8 <msdos_find_name_in_fat_file+0x82c><== NOT EXECUTED
}
ret = fat_file_write(mt_entry, fat_fd,
(empty_space_offset * bts2rd) + empty_space_entry,
length, fs_info->cl_buf + empty_space_entry);
if (ret == -1)
ffc1b8b4: 3b c0 ff ff li r30,-1 <== NOT EXECUTED
empty_space_entry = 0;
read_cluster = true;
}
return 0;
}
ffc1b8b8: 81 81 00 34 lwz r12,52(r1)
ffc1b8bc: 39 61 00 80 addi r11,r1,128
ffc1b8c0: 7f c3 f3 78 mr r3,r30
ffc1b8c4: 7d 81 81 20 mtcrf 24,r12
ffc1b8c8: 4b fe 71 ec b ffc02ab4 <_restgpr_14_x>
ffc1b8cc <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
)
{
ffc1b8cc: 94 21 ff d0 stwu r1,-48(r1) <== NOT EXECUTED
ffc1b8d0: 7c 08 02 a6 mflr r0 <== NOT EXECUTED
ffc1b8d4: 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) &&
ffc1b8d8: 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
)
{
ffc1b8dc: be c1 00 08 stmw r22,8(r1) <== NOT EXECUTED
ffc1b8e0: 7c 77 1b 78 mr r23,r3 <== 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) &&
ffc1b8e4: 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
)
{
ffc1b8e8: 7c 9d 23 78 mr r29,r4 <== NOT EXECUTED
int rc = RC_OK;
ssize_t ret = 0;
msdos_fs_info_t *fs_info = mt_entry->fs_info;
ffc1b8ec: 83 03 00 34 lwz r24,52(r3) <== NOT EXECUTED
fat_file_fd_t *fat_fd,
uint32_t cl4find,
fat_dir_pos_t *dir_pos,
char *dir_entry
)
{
ffc1b8f0: 7c b6 2b 78 mr r22,r5 <== NOT EXECUTED
ffc1b8f4: 7c db 33 78 mr r27,r6 <== NOT EXECUTED
ffc1b8f8: 7c fe 3b 78 mr r30,r7 <== 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) &&
ffc1b8fc: 40 be 00 28 bne+ cr7,ffc1b924 <msdos_find_node_by_cluster_num_in_fat_file+0x58><== NOT EXECUTED
ffc1b900: 80 04 00 24 lwz r0,36(r4) <== NOT EXECUTED
ffc1b904: 2f 80 00 00 cmpwi cr7,r0,0 <== NOT EXECUTED
ffc1b908: 40 9e 00 1c bne- cr7,ffc1b924 <msdos_find_node_by_cluster_num_in_fat_file+0x58><== NOT EXECUTED
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))
ffc1b90c: 88 18 00 0a lbz r0,10(r24) <== 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) &&
ffc1b910: 70 09 00 03 andi. r9,r0,3 <== NOT EXECUTED
ffc1b914: 41 82 00 10 beq- ffc1b924 <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;
ffc1b918: 83 84 00 18 lwz r28,24(r4) <== NOT EXECUTED
assert(ret == bts2rd);
for (i = 0; i < bts2rd; i += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
{
char* entry = (char*) fs_info->cl_buf + i;
ffc1b91c: 3b 20 00 00 li r25,0 <== NOT EXECUTED
ffc1b920: 48 00 00 f4 b ffc1ba14 <msdos_find_node_by_cluster_num_in_fat_file+0x148><== NOT EXECUTED
if (FAT_FD_OF_ROOT_DIR(fat_fd) &&
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))
bts2rd = fat_fd->fat_file_size;
else
bts2rd = fs_info->fat.vol.bpc;
ffc1b924: a3 98 00 06 lhz r28,6(r24) <== NOT EXECUTED
ffc1b928: 4b ff ff f4 b ffc1b91c <msdos_find_node_by_cluster_num_in_fat_file+0x50><== 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 )
ffc1b92c: 2f 83 00 1f cmpwi cr7,r3,31 <== NOT EXECUTED
ffc1b930: 41 bd 00 18 bgt+ cr7,ffc1b948 <msdos_find_node_by_cluster_num_in_fat_file+0x7c><== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EIO );
ffc1b934: 48 00 28 a5 bl ffc1e1d8 <__errno> <== NOT EXECUTED
ffc1b938: 38 00 00 05 li r0,5 <== NOT EXECUTED
ffc1b93c: 90 03 00 00 stw r0,0(r3) <== NOT EXECUTED
ffc1b940: 38 60 ff ff li r3,-1 <== NOT EXECUTED
ffc1b944: 48 00 00 f4 b ffc1ba38 <msdos_find_node_by_cluster_num_in_fat_file+0x16c><== NOT EXECUTED
assert(ret == bts2rd);
ffc1b948: 7f 83 e0 00 cmpw cr7,r3,r28 <== NOT EXECUTED
ffc1b94c: 41 be 00 28 beq+ cr7,ffc1b974 <msdos_find_node_by_cluster_num_in_fat_file+0xa8><== NOT EXECUTED
ffc1b950: 3c a0 ff c3 lis r5,-61 <== NOT EXECUTED
ffc1b954: 3c 60 ff c3 lis r3,-61 <== NOT EXECUTED
ffc1b958: 38 a5 f2 c0 addi r5,r5,-3392 <== NOT EXECUTED
ffc1b95c: 3c c0 ff c3 lis r6,-61 <== NOT EXECUTED
ffc1b960: 38 63 f3 34 addi r3,r3,-3276 <== NOT EXECUTED
ffc1b964: 38 80 06 9e li r4,1694 <== NOT EXECUTED
ffc1b968: 38 a5 00 30 addi r5,r5,48 <== NOT EXECUTED
ffc1b96c: 38 c6 f3 bf addi r6,r6,-3137 <== NOT EXECUTED
ffc1b970: 4b fe b9 11 bl ffc07280 <__assert_func> <== NOT EXECUTED
ffc1b974: 83 f8 00 9c lwz r31,156(r24) <== NOT EXECUTED
for (i = 0; i < bts2rd; i += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
{
char* entry = (char*) fs_info->cl_buf + i;
ffc1b978: 3b 40 00 00 li r26,0 <== NOT EXECUTED
/* if this and all rest entries are empty - return not-found */
if ((*MSDOS_DIR_ENTRY_TYPE(entry)) ==
ffc1b97c: 88 1f 00 00 lbz r0,0(r31) <== NOT EXECUTED
ffc1b980: 2f 80 00 00 cmpwi cr7,r0,0 <== NOT EXECUTED
ffc1b984: 41 9e 00 b0 beq- cr7,ffc1ba34 <msdos_find_node_by_cluster_num_in_fat_file+0x168><== 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)) ==
ffc1b988: 2f 80 00 e5 cmpwi cr7,r0,229 <== NOT EXECUTED
ffc1b98c: 41 9e 00 74 beq- cr7,ffc1ba00 <msdos_find_node_by_cluster_num_in_fat_file+0x134><== NOT EXECUTED
MSDOS_THIS_DIR_ENTRY_EMPTY)
continue;
/* if get a non-empty entry - compare clusters num */
if (MSDOS_EXTRACT_CLUSTER_NUM(entry) == cl4find)
ffc1b990: a1 3f 00 14 lhz r9,20(r31) <== NOT EXECUTED
ffc1b994: a0 1f 00 1a lhz r0,26(r31) <== NOT EXECUTED
ffc1b998: 55 2b c2 3e rlwinm r11,r9,24,8,31 <== NOT EXECUTED
ffc1b99c: 55 29 44 2e rlwinm r9,r9,8,16,23 <== NOT EXECUTED
ffc1b9a0: 7d 69 4b 78 or r9,r11,r9 <== NOT EXECUTED
ffc1b9a4: 54 0b c2 3e rlwinm r11,r0,24,8,31 <== NOT EXECUTED
ffc1b9a8: 54 00 44 2e rlwinm r0,r0,8,16,23 <== NOT EXECUTED
ffc1b9ac: 55 29 80 1e rlwinm r9,r9,16,0,15 <== NOT EXECUTED
ffc1b9b0: 7d 60 03 78 or r0,r11,r0 <== NOT EXECUTED
ffc1b9b4: 7d 20 03 78 or r0,r9,r0 <== NOT EXECUTED
ffc1b9b8: 7f 80 b0 00 cmpw cr7,r0,r22 <== NOT EXECUTED
ffc1b9bc: 40 be 00 44 bne+ cr7,ffc1ba00 <msdos_find_node_by_cluster_num_in_fat_file+0x134><== NOT EXECUTED
{
/* on success fill aux structure and copy all 32 bytes */
rc = fat_file_ioctl(mt_entry, fat_fd, F_CLU_NUM, j * bts2rd,
ffc1b9c0: 7e e3 bb 78 mr r3,r23 <== NOT EXECUTED
ffc1b9c4: 7f a4 eb 78 mr r4,r29 <== NOT EXECUTED
ffc1b9c8: 38 a0 00 01 li r5,1 <== NOT EXECUTED
ffc1b9cc: 7f 26 cb 78 mr r6,r25 <== NOT EXECUTED
ffc1b9d0: 7f 67 db 78 mr r7,r27 <== NOT EXECUTED
ffc1b9d4: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc1b9d8: 4b ff 88 e5 bl ffc142bc <fat_file_ioctl> <== NOT EXECUTED
&dir_pos->sname.cln);
if (rc != RC_OK)
ffc1b9dc: 2c 03 00 00 cmpwi r3,0 <== NOT EXECUTED
ffc1b9e0: 40 a2 00 58 bne+ ffc1ba38 <msdos_find_node_by_cluster_num_in_fat_file+0x16c><== NOT EXECUTED
return rc;
dir_pos->sname.ofs = i;
dir_pos->lname.cln = FAT_FILE_SHORT_NAME;
ffc1b9e4: 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;
ffc1b9e8: 93 5b 00 04 stw r26,4(r27) <== NOT EXECUTED
dir_pos->lname.cln = FAT_FILE_SHORT_NAME;
ffc1b9ec: 90 1b 00 08 stw r0,8(r27) <== NOT EXECUTED
dir_pos->lname.ofs = FAT_FILE_SHORT_NAME;
ffc1b9f0: 90 1b 00 0c stw r0,12(r27) <== NOT EXECUTED
memcpy(dir_entry, entry,
ffc1b9f4: 7c bf 04 aa lswi r5,r31,32 <== NOT EXECUTED
ffc1b9f8: 7c be 05 aa stswi r5,r30,32 <== NOT EXECUTED
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
return RC_OK;
ffc1b9fc: 48 00 00 3c b ffc1ba38 <msdos_find_node_by_cluster_num_in_fat_file+0x16c><== 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)
ffc1ba00: 3b 5a 00 20 addi r26,r26,32 <== NOT EXECUTED
ffc1ba04: 7f 9a e0 40 cmplw cr7,r26,r28 <== NOT EXECUTED
ffc1ba08: 3b ff 00 20 addi r31,r31,32 <== NOT EXECUTED
ffc1ba0c: 41 9c ff 70 blt+ cr7,ffc1b97c <msdos_find_node_by_cluster_num_in_fat_file+0xb0><== NOT EXECUTED
ffc1ba10: 7f 39 e2 14 add r25,r25,r28 <== 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,
ffc1ba14: 80 f8 00 9c lwz r7,156(r24) <== NOT EXECUTED
ffc1ba18: 7e e3 bb 78 mr r3,r23 <== NOT EXECUTED
ffc1ba1c: 7f a4 eb 78 mr r4,r29 <== NOT EXECUTED
ffc1ba20: 7f 25 cb 78 mr r5,r25 <== NOT EXECUTED
ffc1ba24: 7f 86 e3 78 mr r6,r28 <== NOT EXECUTED
ffc1ba28: 4b ff 85 0d bl ffc13f34 <fat_file_read> <== NOT EXECUTED
ffc1ba2c: 2c 03 00 00 cmpwi r3,0 <== NOT EXECUTED
ffc1ba30: 40 82 fe fc bne+ ffc1b92c <msdos_find_node_by_cluster_num_in_fat_file+0x60><== 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;
ffc1ba34: 38 60 7d 01 li r3,32001 <== NOT EXECUTED
}
}
j++;
}
return MSDOS_NAME_NOT_FOUND_ERR;
}
ffc1ba38: 39 61 00 30 addi r11,r1,48 <== NOT EXECUTED
ffc1ba3c: 4b fe 70 98 b ffc02ad4 <_restgpr_22_x> <== NOT EXECUTED
ffc0febc <msdos_format>:
)
/*-------------------------------------------------------------------------*\
| Return Value: |
| 0, if success, -1 and errno if failed |
\*=========================================================================*/
{
ffc0febc: 94 21 fd 28 stwu r1,-728(r1)
ffc0fec0: 7d 80 00 26 mfcr r12
ffc0fec4: 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");
ffc0fec8: 3c a0 ff c3 lis r5,-61
)
/*-------------------------------------------------------------------------*\
| Return Value: |
| 0, if success, -1 and errno if failed |
\*=========================================================================*/
{
ffc0fecc: bf 21 02 bc stmw r25,700(r1)
msdos_format_param_t fmt_params;
/*
* open device for writing
*/
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL, "open device\n");
ffc0fed0: 38 a5 ec bf addi r5,r5,-4929
)
/*-------------------------------------------------------------------------*\
| Return Value: |
| 0, if success, -1 and errno if failed |
\*=========================================================================*/
{
ffc0fed4: 7c 7d 1b 78 mr r29,r3
ffc0fed8: 7c 9f 23 78 mr r31,r4
ffc0fedc: 90 01 02 dc stw r0,732(r1)
msdos_format_param_t fmt_params;
/*
* open device for writing
*/
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL, "open device\n");
ffc0fee0: 7c 83 23 78 mr r3,r4
ffc0fee4: 38 80 00 02 li r4,2
)
/*-------------------------------------------------------------------------*\
| Return Value: |
| 0, if success, -1 and errno if failed |
\*=========================================================================*/
{
ffc0fee8: 91 81 02 b8 stw r12,696(r1)
msdos_format_param_t fmt_params;
/*
* open device for writing
*/
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL, "open device\n");
ffc0feec: 4c c6 31 82 crclr 4*cr1+eq
ffc0fef0: 4b ff fd 81 bl ffc0fc70 <msdos_format_printf>
fd = open(devname, O_RDWR);
ffc0fef4: 38 80 00 02 li r4,2
ffc0fef8: 7f a3 eb 78 mr r3,r29
ffc0fefc: 4c c6 31 82 crclr 4*cr1+eq
ffc0ff00: 4b ff 8a 09 bl ffc08908 <open>
}
/*
* sanity check on device
*/
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
ffc0ff04: 3c a0 ff c3 lis r5,-61
{
char tmp_sec[FAT_TOTAL_MBR_SIZE];
int rc;
rtems_disk_device *dd = NULL;
struct stat stat_buf;
int ret_val = 0;
ffc0ff08: 3b 83 00 01 addi r28,r3,1
/*
* open device for writing
*/
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL, "open device\n");
fd = open(devname, O_RDWR);
ffc0ff0c: 7c 7e 1b 78 mr r30,r3
{
char tmp_sec[FAT_TOTAL_MBR_SIZE];
int rc;
rtems_disk_device *dd = NULL;
struct stat stat_buf;
int ret_val = 0;
ffc0ff10: 33 9c ff ff addic r28,r28,-1
ffc0ff14: 7f 9c e1 10 subfe r28,r28,r28
}
/*
* sanity check on device
*/
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
ffc0ff18: 7f e3 fb 78 mr r3,r31
ffc0ff1c: 38 80 00 02 li r4,2
ffc0ff20: 38 a5 ec cc addi r5,r5,-4916
ffc0ff24: 7f a6 eb 78 mr r6,r29
ffc0ff28: 4c c6 31 82 crclr 4*cr1+eq
ffc0ff2c: 4b ff fd 45 bl ffc0fc70 <msdos_format_printf>
"stat check: %s\n", devname);
if (ret_val == 0) {
ffc0ff30: 2f 9c 00 00 cmpwi cr7,r28,0
ffc0ff34: 3b 20 ff ff li r25,-1
ffc0ff38: 40 be 00 14 bne+ cr7,ffc0ff4c <msdos_format+0x90> <== NEVER TAKEN
rc = fstat(fd, &stat_buf);
ffc0ff3c: 7f c3 f3 78 mr r3,r30
ffc0ff40: 38 81 00 18 addi r4,r1,24
ffc0ff44: 48 00 6a 8d bl ffc169d0 <fstat>
ffc0ff48: 7c 79 1b 78 mr r25,r3
ret_val = rc;
}
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_INFO,
ffc0ff4c: 3c a0 ff c3 lis r5,-61
ffc0ff50: 7f e3 fb 78 mr r3,r31
ffc0ff54: 38 80 00 01 li r4,1
ffc0ff58: 38 a5 ec dc addi r5,r5,-4900
ffc0ff5c: 7f a6 eb 78 mr r6,r29
ffc0ff60: 4c c6 31 82 crclr 4*cr1+eq
ffc0ff64: 4b ff fd 0d bl ffc0fc70 <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))) {
ffc0ff68: 2f 99 00 00 cmpwi cr7,r25,0
ffc0ff6c: 40 9e 00 24 bne- cr7,ffc0ff90 <msdos_format+0xd4> <== NEVER TAKEN
ffc0ff70: 80 01 00 24 lwz r0,36(r1)
ffc0ff74: 54 00 04 26 rlwinm r0,r0,0,16,19
ffc0ff78: 2f 80 60 00 cmpwi cr7,r0,24576
ffc0ff7c: 41 9e 0a 4c beq- cr7,ffc109c8 <msdos_format+0xb0c> <== 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;
ffc0ff80: 48 00 e2 59 bl ffc1e1d8 <__errno> <== NOT EXECUTED
ffc0ff84: 38 00 00 19 li r0,25 <== NOT EXECUTED
ffc0ff88: 90 03 00 00 stw r0,0(r3) <== NOT EXECUTED
ret_val = -1;
ffc0ff8c: 3b 20 ff ff li r25,-1 <== NOT EXECUTED
/* FAT entry 1: EOC */
FAT_SET_VAL32(tmp_sec,4,FAT_FAT32_EOC);
break;
default:
ret_val = -1;
ffc0ff90: 3b a0 00 00 li r29,0 <== NOT EXECUTED
ffc0ff94: 48 00 0a 00 b ffc10994 <msdos_format+0xad8> <== NOT EXECUTED
/*
* determine number of FATs
*/
if (ret_val == 0) {
if ((rqdata == NULL) ||
(rqdata->fat_num == 0)) {
ffc0ff98: 80 1f 00 0c lwz r0,12(r31)
}
/*
* determine number of FATs
*/
if (ret_val == 0) {
if ((rqdata == NULL) ||
ffc0ff9c: 2f 80 00 00 cmpwi cr7,r0,0
ffc0ffa0: 40 9e 00 0c bne- cr7,ffc0ffac <msdos_format+0xf0> <== NEVER TAKEN
(rqdata->fat_num == 0)) {
fmt_params->fat_num = 2;
ffc0ffa4: 38 00 00 02 li r0,2
ffc0ffa8: 48 00 00 10 b ffc0ffb8 <msdos_format+0xfc>
}
else if (rqdata->fat_num <= 6) {
ffc0ffac: 2b 80 00 06 cmplwi cr7,r0,6 <== NOT EXECUTED
fmt_params->fat_num = rqdata->fat_num;
}
else {
ret_val = EINVAL;
ffc0ffb0: 3b 40 00 16 li r26,22 <== NOT EXECUTED
if (ret_val == 0) {
if ((rqdata == NULL) ||
(rqdata->fat_num == 0)) {
fmt_params->fat_num = 2;
}
else if (rqdata->fat_num <= 6) {
ffc0ffb4: 41 9d 03 60 bgt- cr7,ffc10314 <msdos_format+0x458> <== NOT EXECUTED
fmt_params->fat_num = rqdata->fat_num;
ffc0ffb8: 98 01 00 90 stb r0,144(r1)
ret_val = EINVAL;
}
}
if (ret_val == 0)
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
ffc0ffbc: 3c a0 ff c3 lis r5,-61
ffc0ffc0: 7f e3 fb 78 mr r3,r31
ffc0ffc4: 88 c1 00 90 lbz r6,144(r1)
ffc0ffc8: 38 80 00 02 li r4,2
ffc0ffcc: 38 a5 ec eb addi r5,r5,-4885
ffc0ffd0: 4c c6 31 82 crclr 4*cr1+eq
ffc0ffd4: 4b ff fc 9d bl ffc0fc70 <msdos_format_printf>
* determine FAT type and sectors per cluster
* depends on
*/
if (ret_val == 0) {
fmt_params->sectors_per_cluster = 1;
if ((rqdata != NULL) &&
ffc0ffd8: 2f 9f 00 00 cmpwi cr7,r31,0
/*
* determine FAT type and sectors per cluster
* depends on
*/
if (ret_val == 0) {
fmt_params->sectors_per_cluster = 1;
ffc0ffdc: 38 00 00 01 li r0,1
ffc0ffe0: 90 01 00 6c stw r0,108(r1)
if ((rqdata != NULL) &&
ffc0ffe4: 41 9e 00 4c beq- cr7,ffc10030 <msdos_format+0x174> <== NEVER TAKEN
(rqdata->fattype == MSDOS_FMT_FAT12)) {
ffc0ffe8: 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) &&
ffc0ffec: 2f 80 00 01 cmpwi cr7,r0,1
ffc0fff0: 41 9e 00 18 beq- cr7,ffc10008 <msdos_format+0x14c> <== NEVER TAKEN
(rqdata->fattype == MSDOS_FMT_FAT12)) {
fmt_params->fattype = FAT_FAT12;
}
else if ((rqdata != NULL) &&
ffc0fff4: 2f 80 00 02 cmpwi cr7,r0,2
ffc0fff8: 41 9e 00 10 beq- cr7,ffc10008 <msdos_format+0x14c> <== NEVER TAKEN
(rqdata->fattype == MSDOS_FMT_FAT16)) {
fmt_params->fattype = FAT_FAT16;
}
else if ((rqdata != NULL) &&
ffc0fffc: 2f 80 00 03 cmpwi cr7,r0,3
ffc10000: 40 be 00 14 bne+ cr7,ffc10014 <msdos_format+0x158> <== ALWAYS TAKEN
(rqdata->fattype == MSDOS_FMT_FAT32)) {
fmt_params->fattype = FAT_FAT32;
ffc10004: 38 00 00 04 li r0,4 <== NOT EXECUTED
ffc10008: 98 01 00 92 stb r0,146(r1) <== NOT EXECUTED
ffc1000c: 3b 40 00 00 li r26,0 <== NOT EXECUTED
ffc10010: 48 00 00 ac b ffc100bc <msdos_format+0x200> <== NOT EXECUTED
}
else if ((rqdata != NULL) &&
ffc10014: 2f 80 00 00 cmpwi cr7,r0,0
ffc10018: 41 be 00 18 beq+ cr7,ffc10030 <msdos_format+0x174> <== ALWAYS TAKEN
(rqdata->fattype != MSDOS_FMT_FATANY)) {
ret_val = -1;
errno = EINVAL;
ffc1001c: 48 00 e1 bd bl ffc1e1d8 <__errno> <== NOT EXECUTED
ffc10020: 38 00 00 16 li r0,22 <== NOT EXECUTED
ffc10024: 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;
ffc10028: 3b 40 ff ff li r26,-1 <== NOT EXECUTED
ffc1002c: 48 00 00 90 b ffc100bc <msdos_format+0x200> <== NOT EXECUTED
/*
* 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
ffc10030: 2b 9c 7f a7 cmplwi cr7,r28,32679
< ((uint32_t)FAT_FAT12_MAX_CLN)*8) {
fmt_params->fattype = FAT_FAT12;
ffc10034: 38 00 00 01 li r0,1
/*
* 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
ffc10038: 40 9d 00 18 ble- cr7,ffc10050 <msdos_format+0x194> <== ALWAYS TAKEN
< ((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
ffc1003c: 3c 00 00 1f lis r0,31 <== NOT EXECUTED
ffc10040: 60 00 fe 9f ori r0,r0,65183 <== NOT EXECUTED
ffc10044: 7f 9c 00 40 cmplw cr7,r28,r0 <== NOT EXECUTED
ffc10048: 41 9d 00 18 bgt- cr7,ffc10060 <msdos_format+0x1a4> <== NOT EXECUTED
< ((uint32_t)FAT_FAT16_MAX_CLN)*32) {
fmt_params->fattype = FAT_FAT16;
ffc1004c: 38 00 00 02 li r0,2 <== NOT EXECUTED
ffc10050: 98 01 00 92 stb r0,146(r1)
/* start trying with small clusters */
fmt_params->sectors_per_cluster = 2;
ffc10054: 38 00 00 02 li r0,2
ffc10058: 90 01 00 6c stw r0,108(r1)
ffc1005c: 48 00 00 54 b ffc100b0 <msdos_format+0x1f4>
}
else {
#define ONE_GB (1024L * 1024L * 1024L)
uint32_t gigs = (total_size + ONE_GB) / ONE_GB;
int b;
fmt_params->fattype = FAT_FAT32;
ffc10060: 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;
ffc10064: 3c 1b 40 00 addis r0,r27,16384 <== NOT EXECUTED
int b;
fmt_params->fattype = FAT_FAT32;
ffc10068: 99 21 00 92 stb r9,146(r1) <== NOT EXECUTED
/* scale with the size of disk... */
for (b = 31; b > 0; b--)
ffc1006c: 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;
ffc10070: 7f 7b 00 10 subfc r27,r27,r0 <== NOT EXECUTED
ffc10074: 7f 7b d9 10 subfe r27,r27,r27 <== 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)
ffc10078: 7d 29 03 a6 mtctr r9 <== 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;
ffc1007c: 7f 7b 00 d0 neg r27,r27 <== NOT EXECUTED
ffc10080: 57 7b 10 3a rlwinm r27,r27,2,0,29 <== NOT EXECUTED
ffc10084: 54 00 17 be rlwinm r0,r0,2,30,31 <== NOT EXECUTED
ffc10088: 7f 7b 03 78 or r27,r27,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)
ffc1008c: 39 60 00 01 li r11,1 <== NOT EXECUTED
ffc10090: 7d 60 48 30 slw r0,r11,r9 <== NOT EXECUTED
ffc10094: 7c 05 d8 39 and. r5,r0,r27 <== NOT EXECUTED
ffc10098: 40 82 00 0c bne- ffc100a4 <msdos_format+0x1e8> <== 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--)
ffc1009c: 39 29 ff ff addi r9,r9,-1 <== NOT EXECUTED
ffc100a0: 42 00 ff f0 bdnz+ ffc10090 <msdos_format+0x1d4> <== NOT EXECUTED
if ((gigs & (1 << b)) != 0)
break;
fmt_params->sectors_per_cluster = 1 << b;
ffc100a4: 38 00 00 01 li r0,1 <== NOT EXECUTED
ffc100a8: 7c 09 48 30 slw r9,r0,r9 <== NOT EXECUTED
ffc100ac: 91 21 00 6c stw r9,108(r1) <== NOT EXECUTED
}
}
/*
* try to use user requested cluster size
*/
if ((rqdata != NULL) &&
ffc100b0: 2f 9f 00 00 cmpwi cr7,r31,0
ffc100b4: 3b 40 00 00 li r26,0
ffc100b8: 41 9e 00 14 beq- cr7,ffc100cc <msdos_format+0x210> <== NEVER TAKEN
(rqdata->sectors_per_cluster > 0)) {
ffc100bc: 80 1f 00 08 lwz r0,8(r31)
}
}
/*
* try to use user requested cluster size
*/
if ((rqdata != NULL) &&
ffc100c0: 2f 80 00 00 cmpwi cr7,r0,0
ffc100c4: 41 9e 00 08 beq- cr7,ffc100cc <msdos_format+0x210> <== ALWAYS TAKEN
(rqdata->sectors_per_cluster > 0)) {
fmt_params->sectors_per_cluster =
ffc100c8: 90 01 00 6c stw r0,108(r1) <== NOT EXECUTED
*/
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) {
ffc100cc: 39 20 00 00 li r9,0
ffc100d0: 81 61 00 60 lwz r11,96(r1)
ffc100d4: 80 c1 00 6c lwz r6,108(r1)
ffc100d8: 38 00 00 80 li r0,128
ffc100dc: 61 29 80 00 ori r9,r9,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) {
ffc100e0: 7f 86 00 40 cmplw cr7,r6,r0
ffc100e4: 41 9c 00 18 blt- cr7,ffc100fc <msdos_format+0x240>
fmt_params->sectors_per_cluster = onebit;
if (fmt_params->sectors_per_cluster
<= 32768L/fmt_params->bytes_per_sector) {
ffc100e8: 7d 49 5b 96 divwu r10,r9,r11
* 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
ffc100ec: 7f 80 50 40 cmplw cr7,r0,r10
ffc100f0: 7c 06 03 78 mr r6,r0
ffc100f4: 41 9d 00 08 bgt- cr7,ffc100fc <msdos_format+0x240> <== NEVER TAKEN
<= 32768L/fmt_params->bytes_per_sector) {
/* value is small enough so this value is ok */
onebit = 1;
ffc100f8: 38 00 00 01 li r0,1
* 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) {
ffc100fc: 54 00 f8 7f rlwinm. r0,r0,31,1,31
ffc10100: 40 82 ff e0 bne+ ffc100e0 <msdos_format+0x224>
}
}
}
}
if (ret_val == 0) {
ffc10104: 2f 9a 00 00 cmpwi cr7,r26,0
* 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) {
ffc10108: 90 c1 00 6c stw r6,108(r1)
}
}
}
}
if (ret_val == 0) {
ffc1010c: 40 9e 02 04 bne- cr7,ffc10310 <msdos_format+0x454> <== NEVER TAKEN
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
ffc10110: 3c a0 ff c3 lis r5,-61
ffc10114: 7f e3 fb 78 mr r3,r31
ffc10118: 38 80 00 02 li r4,2
ffc1011c: 38 a5 ec ff addi r5,r5,-4865
ffc10120: 4c c6 31 82 crclr 4*cr1+eq
ffc10124: 4b ff fb 4d bl ffc0fc70 <msdos_format_printf>
"sectors per cluster: %d\n", fmt_params->sectors_per_cluster);
if (fmt_params->fattype == FAT_FAT32) {
ffc10128: 88 01 00 92 lbz r0,146(r1)
ffc1012c: 2f 80 00 04 cmpwi cr7,r0,4
ffc10130: 40 be 00 24 bne+ cr7,ffc10154 <msdos_format+0x298> <== ALWAYS TAKEN
/* recommended: for FAT32, always set reserved sector count to 32 */
fmt_params->rsvd_sector_cnt = 32;
ffc10134: 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;
ffc10138: 93 41 00 78 stw r26,120(r1) <== 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;
ffc1013c: 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;
ffc10140: 38 00 00 06 li r0,6 <== NOT EXECUTED
ffc10144: 90 01 00 88 stw r0,136(r1) <== NOT EXECUTED
/* location of fsinfo sector */
fmt_params->fsinfo_sec = 1;
ffc10148: 38 00 00 01 li r0,1 <== NOT EXECUTED
ffc1014c: 90 01 00 8c stw r0,140(r1) <== NOT EXECUTED
ffc10150: 48 00 00 60 b ffc101b0 <msdos_format+0x2f4> <== NOT EXECUTED
/* 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) &&
ffc10154: 2f 9f 00 00 cmpwi cr7,r31,0
fmt_params->fsinfo_sec = 1;
}
else {
/* recommended: for FAT12/FAT16, always set reserved sector count to 1 */
fmt_params->rsvd_sector_cnt = 1;
ffc10158: 39 20 00 01 li r9,1
ffc1015c: 91 21 00 68 stw r9,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) &&
ffc10160: 41 9e 00 18 beq- cr7,ffc10178 <msdos_format+0x2bc> <== NEVER TAKEN
(rqdata->files_per_root_dir > 0)) {
ffc10164: 81 3f 00 10 lwz r9,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) &&
ffc10168: 2f 89 00 00 cmpwi cr7,r9,0
ffc1016c: 41 9e 00 0c beq- cr7,ffc10178 <msdos_format+0x2bc> <== ALWAYS TAKEN
(rqdata->files_per_root_dir > 0)) {
fmt_params->files_per_root_dir = rqdata->files_per_root_dir;
ffc10170: 91 21 00 78 stw r9,120(r1) <== NOT EXECUTED
ffc10174: 48 00 00 1c b ffc10190 <msdos_format+0x2d4> <== NOT EXECUTED
}
else {
if (fmt_params->fattype == FAT_FAT16) {
ffc10178: 2f 80 00 02 cmpwi cr7,r0,2
ffc1017c: 40 be 00 0c bne+ cr7,ffc10188 <msdos_format+0x2cc> <== ALWAYS TAKEN
fmt_params->files_per_root_dir = 512;
ffc10180: 38 00 02 00 li r0,512 <== NOT EXECUTED
ffc10184: 48 00 00 08 b ffc1018c <msdos_format+0x2d0> <== NOT EXECUTED
}
else {
fmt_params->files_per_root_dir = 64;
ffc10188: 38 00 00 40 li r0,64
ffc1018c: 90 01 00 78 stw r0,120(r1)
}
}
fmt_params->files_per_root_dir = (fmt_params->files_per_root_dir +
ffc10190: 81 21 00 78 lwz r9,120(r1)
(2*fmt_params->bytes_per_sector/
ffc10194: 80 01 00 60 lwz r0,96(r1)
}
else {
fmt_params->files_per_root_dir = 64;
}
}
fmt_params->files_per_root_dir = (fmt_params->files_per_root_dir +
ffc10198: 39 29 ff ff addi r9,r9,-1
(2*fmt_params->bytes_per_sector/
ffc1019c: 54 00 e1 7e rlwinm r0,r0,28,5,31
}
else {
fmt_params->files_per_root_dir = 64;
}
}
fmt_params->files_per_root_dir = (fmt_params->files_per_root_dir +
ffc101a0: 7d 29 02 14 add r9,r9,r0
(2*fmt_params->bytes_per_sector/
FAT_DIRENTRY_SIZE-1));
fmt_params->files_per_root_dir -= (fmt_params->files_per_root_dir %
ffc101a4: 7d 29 03 96 divwu r9,r9,r0
ffc101a8: 7c 09 01 d6 mullw r0,r9,r0
ffc101ac: 90 01 00 78 stw r0,120(r1)
(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)
ffc101b0: 81 61 00 60 lwz r11,96(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) {
ffc101b4: 39 40 00 00 li r10,0
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 =
(((fmt_params->files_per_root_dir * FAT_DIRENTRY_SIZE)
ffc101b8: 80 01 00 78 lwz r0,120(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) {
ffc101bc: 61 4a 80 00 ori r10,r10,32768
(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)
ffc101c0: 38 eb ff ff addi r7,r11,-1
/ fmt_params->bytes_per_sector);
}
if (ret_val == 0) {
fatdata_sect_cnt = (fmt_params->totl_sector_cnt -
ffc101c4: 81 21 00 68 lwz r9,104(r1)
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 =
(((fmt_params->files_per_root_dir * FAT_DIRENTRY_SIZE)
ffc101c8: 54 00 28 34 rlwinm r0,r0,5,0,26
+ fmt_params->bytes_per_sector - 1)
/ fmt_params->bytes_per_sector);
}
if (ret_val == 0) {
fatdata_sect_cnt = (fmt_params->totl_sector_cnt -
ffc101cc: 80 a1 00 64 lwz r5,100(r1)
(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)
ffc101d0: 7c 07 02 14 add r0,r7,r0
/*
* check values to get legal arrangement of FAT type and cluster count
*/
ret_val = msdos_format_eval_sectors_per_cluster
(fmt_params->fattype,
ffc101d4: 88 81 00 90 lbz r4,144(r1)
/FAT_DIRENTRY_SIZE));
}
fmt_params->root_dir_sectors =
(((fmt_params->files_per_root_dir * FAT_DIRENTRY_SIZE)
+ fmt_params->bytes_per_sector - 1)
/ fmt_params->bytes_per_sector);
ffc101d8: 7c 00 5b 96 divwu r0,r0,r11
}
if (ret_val == 0) {
fatdata_sect_cnt = (fmt_params->totl_sector_cnt -
ffc101dc: 7c a9 28 50 subf r5,r9,r5
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 =
ffc101e0: 90 01 00 7c stw r0,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 -
ffc101e4: 7c a0 28 50 subf r5,r0,r5
/*
* check values to get legal arrangement of FAT type and cluster count
*/
ret_val = msdos_format_eval_sectors_per_cluster
(fmt_params->fattype,
ffc101e8: 81 21 00 6c lwz r9,108(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) {
ffc101ec: 7d 4a 5b 96 divwu r10,r10,r11
/*
* check values to get legal arrangement of FAT type and cluster count
*/
ret_val = msdos_format_eval_sectors_per_cluster
(fmt_params->fattype,
ffc101f0: 88 01 00 92 lbz r0,146(r1)
ffc101f4: 48 00 00 08 b ffc101fc <msdos_format+0x340>
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) {
sectors_per_cluster /= 2;
ffc101f8: 55 29 f8 7e rlwinm r9,r9,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) {
ffc101fc: 7f 8a 48 40 cmplw cr7,r10,r9
ffc10200: 41 9c ff f8 blt+ cr7,ffc101f8 <msdos_format+0x33c> <== NEVER TAKEN
* - 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;
if (fattype == FAT_FAT12) {
ffc10204: 2f 00 00 01 cmpwi cr6,r0,1
fat_capacity = fatdata_cluster_cnt * 3 / 2;
}
else if (fattype == FAT_FAT16) {
ffc10208: 2f 80 00 02 cmpwi cr7,r0,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;
ffc1020c: 7c 05 4b 96 divwu r0,r5,r9
if (fattype == FAT_FAT12) {
ffc10210: 40 ba 00 10 bne+ cr6,ffc10220 <msdos_format+0x364> <== NEVER TAKEN
fat_capacity = fatdata_cluster_cnt * 3 / 2;
ffc10214: 1d 40 00 03 mulli r10,r0,3
ffc10218: 55 4a f8 7e rlwinm r10,r10,31,1,31
ffc1021c: 48 00 00 10 b ffc1022c <msdos_format+0x370>
}
else if (fattype == FAT_FAT16) {
fat_capacity = fatdata_cluster_cnt * 2;
}
else { /* FAT32 */
fat_capacity = fatdata_cluster_cnt * 4;
ffc10220: 54 0a 10 3a rlwinm r10,r0,2,0,29 <== 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) {
ffc10224: 40 be 00 08 bne+ cr7,ffc1022c <msdos_format+0x370> <== NOT EXECUTED
fat_capacity = fatdata_cluster_cnt * 2;
ffc10228: 54 0a 08 3c rlwinm r10,r0,1,0,30 <== NOT EXECUTED
else { /* FAT32 */
fat_capacity = fatdata_cluster_cnt * 4;
}
sectors_per_fat = ((fat_capacity
+ (bytes_per_sector - 1))
ffc1022c: 7d 4a 3a 14 add r10,r10,r7
}
else { /* FAT32 */
fat_capacity = fatdata_cluster_cnt * 4;
}
sectors_per_fat = ((fat_capacity
ffc10230: 7d 0a 5b 96 divwu r8,r10,r11
+ (bytes_per_sector - 1))
/ bytes_per_sector);
data_cluster_cnt = (fatdata_cluster_cnt -
(((sectors_per_fat * fat_num)
ffc10234: 7d 48 21 d6 mullw r10,r8,r4
+ (sectors_per_cluster - 1))
ffc10238: 38 c9 ff ff addi r6,r9,-1
ffc1023c: 7c c6 52 14 add r6,r6,r10
/ sectors_per_cluster));
ffc10240: 7c c6 4b 96 divwu r6,r6,r9
sectors_per_fat = ((fat_capacity
+ (bytes_per_sector - 1))
/ bytes_per_sector);
data_cluster_cnt = (fatdata_cluster_cnt -
ffc10244: 7c c6 00 50 subf r6,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)) ||
ffc10248: 40 ba 00 14 bne+ cr6,ffc1025c <msdos_format+0x3a0> <== NEVER TAKEN
ffc1024c: 28 86 0f f5 cmplwi cr1,r6,4085
((fattype == FAT_FAT16) && (data_cluster_cnt > FAT_FAT16_MAX_CLN))) {
sectors_per_cluster *= 2;
}
else {
finished = true;
ffc10250: 39 40 00 01 li r10,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)) ||
ffc10254: 40 85 00 20 ble- cr1,ffc10274 <msdos_format+0x3b8> <== ALWAYS TAKEN
ffc10258: 48 00 00 14 b ffc1026c <msdos_format+0x3b0> <== NOT EXECUTED
((fattype == FAT_FAT16) && (data_cluster_cnt > FAT_FAT16_MAX_CLN))) {
sectors_per_cluster *= 2;
}
else {
finished = true;
ffc1025c: 39 40 00 01 li r10,1 <== NOT EXECUTED
+ (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)) ||
ffc10260: 40 be 00 14 bne+ cr7,ffc10274 <msdos_format+0x3b8> <== NOT EXECUTED
((fattype == FAT_FAT16) && (data_cluster_cnt > FAT_FAT16_MAX_CLN))) {
ffc10264: 28 86 ff f5 cmplwi cr1,r6,65525 <== NOT EXECUTED
ffc10268: 40 85 00 0c ble- cr1,ffc10274 <msdos_format+0x3b8> <== NOT EXECUTED
sectors_per_cluster *= 2;
ffc1026c: 55 29 08 3c rlwinm r9,r9,1,0,30 <== NOT EXECUTED
ffc10270: 39 40 00 00 li r10,0 <== NOT EXECUTED
finished = true;
}
/*
* when maximum cluster size is exceeded, we have invalid data, abort...
*/
if ((sectors_per_cluster * bytes_per_sector)
ffc10274: 7c 09 59 d6 mullw r0,r9,r11
ffc10278: 28 80 80 00 cmplwi cr1,r0,32768
ffc1027c: 41 85 00 14 bgt- cr1,ffc10290 <msdos_format+0x3d4> <== NEVER TAKEN
> MS_BYTES_PER_CLUSTER_LIMIT) {
ret_val = EINVAL;
finished = true;
}
} while (!finished);
ffc10280: 2c 8a 00 00 cmpwi cr1,r10,0
ffc10284: 41 86 ff 88 beq+ cr1,ffc1020c <msdos_format+0x350> <== 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;
ffc10288: 91 01 00 70 stw r8,112(r1)
ffc1028c: 48 00 00 18 b ffc102a4 <msdos_format+0x3e8>
finished = true;
}
} while (!finished);
if (ret_val != 0) {
rtems_set_errno_and_return_minus_one(ret_val);
ffc10290: 48 00 df 49 bl ffc1e1d8 <__errno> <== NOT EXECUTED
ffc10294: 38 00 00 16 li r0,22 <== NOT EXECUTED
ffc10298: 90 03 00 00 stw r0,0(r3) <== NOT EXECUTED
\*=========================================================================*/
{
int ret_val = 0;
uint32_t fatdata_sect_cnt;
uint32_t onebit;
uint32_t sectors_per_cluster_adj = 0;
ffc1029c: 39 20 00 00 li r9,0 <== NOT EXECUTED
finished = true;
}
} while (!finished);
if (ret_val != 0) {
rtems_set_errno_and_return_minus_one(ret_val);
ffc102a0: 3b 40 ff ff li r26,-1 <== NOT EXECUTED
}
/*
* determine media code
*/
if (ret_val == 0) {
ffc102a4: 2f 9a 00 00 cmpwi cr7,r26,0
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;
ffc102a8: 91 21 00 6c stw r9,108(r1)
}
/*
* determine media code
*/
if (ret_val == 0) {
ffc102ac: 40 9e 00 64 bne- cr7,ffc10310 <msdos_format+0x454> <== NEVER TAKEN
if ((rqdata != NULL) &&
ffc102b0: 2f 9f 00 00 cmpwi cr7,r31,0
ffc102b4: 41 9e 00 50 beq- cr7,ffc10304 <msdos_format+0x448> <== NEVER TAKEN
(rqdata->media != 0)) {
ffc102b8: 8b 9f 00 15 lbz r28,21(r31)
/*
* determine media code
*/
if (ret_val == 0) {
if ((rqdata != NULL) &&
ffc102bc: 2f 9c 00 00 cmpwi cr7,r28,0
ffc102c0: 41 9e 00 44 beq- cr7,ffc10304 <msdos_format+0x448> <== ALWAYS TAKEN
(rqdata->media != 0)) {
const char valid_media_codes[] =
ffc102c4: 3d 20 ff c3 lis r9,-61 <== NOT EXECUTED
ffc102c8: 38 61 00 08 addi r3,r1,8 <== NOT EXECUTED
ffc102cc: 39 29 ec 7c addi r9,r9,-4996 <== NOT EXECUTED
ffc102d0: 7c a9 4c aa lswi r5,r9,9 <== NOT EXECUTED
ffc102d4: 7c a3 4d aa stswi r5,r3,9 <== NOT EXECUTED
{0xF0,0xF8,0xF9,0xFA,0xFB,0xFC,0xFD,0xFE,0xFF};
if (NULL==memchr(valid_media_codes,
ffc102d8: 7f 84 e3 78 mr r4,r28 <== NOT EXECUTED
ffc102dc: 38 a0 00 09 li r5,9 <== NOT EXECUTED
ffc102e0: 48 00 eb 91 bl ffc1ee70 <memchr> <== NOT EXECUTED
ffc102e4: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc102e8: 40 be 00 14 bne+ cr7,ffc102fc <msdos_format+0x440> <== NOT EXECUTED
rqdata->media,
sizeof(valid_media_codes))) {
ret_val = -1;
errno = EINVAL;
ffc102ec: 48 00 de ed bl ffc1e1d8 <__errno> <== NOT EXECUTED
ffc102f0: 38 00 00 16 li r0,22 <== NOT EXECUTED
ffc102f4: 90 03 00 00 stw r0,0(r3) <== NOT EXECUTED
ffc102f8: 48 00 00 18 b ffc10310 <msdos_format+0x454> <== NOT EXECUTED
}
else {
fmt_params->media_code = rqdata->media;
ffc102fc: 9b 81 00 91 stb r28,145(r1) <== NOT EXECUTED
ffc10300: 48 00 00 14 b ffc10314 <msdos_format+0x458> <== NOT EXECUTED
}
}
else {
fmt_params->media_code = FAT_BR_MEDIA_FIXED;
ffc10304: 38 00 ff f8 li r0,-8
ffc10308: 98 01 00 91 stb r0,145(r1)
ffc1030c: 48 00 00 08 b ffc10314 <msdos_format+0x458>
}
/*
* determine media code
*/
if (ret_val == 0) {
ffc10310: 3b 40 ff ff li r26,-1 <== NOT EXECUTED
}
/*
* determine location and size of root directory
* for formatting
*/
if (fmt_params->root_dir_sectors > 0) {
ffc10314: 81 41 00 7c lwz r10,124(r1)
ffc10318: 89 61 00 90 lbz r11,144(r1)
ffc1031c: 81 21 00 70 lwz r9,112(r1)
ffc10320: 2f 8a 00 00 cmpwi cr7,r10,0
fmt_params->root_dir_start_sec =
fmt_params->rsvd_sector_cnt
+ (fmt_params-> fat_num*fmt_params->sectors_per_fat);
ffc10324: 55 6b 06 3e clrlwi r11,r11,24
ffc10328: 80 01 00 68 lwz r0,104(r1)
ffc1032c: 7d 2b 49 d6 mullw r9,r11,r9
ffc10330: 7c 09 02 14 add r0,r9,r0
/*
* determine location and size of root directory
* for formatting
*/
if (fmt_params->root_dir_sectors > 0) {
fmt_params->root_dir_start_sec =
ffc10334: 90 01 00 80 stw r0,128(r1)
}
/*
* determine location and size of root directory
* for formatting
*/
if (fmt_params->root_dir_sectors > 0) {
ffc10338: 41 9e 00 0c beq- cr7,ffc10344 <msdos_format+0x488> <== NEVER TAKEN
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->root_dir_sectors;
ffc1033c: 91 41 00 84 stw r10,132(r1)
ffc10340: 48 00 00 0c b ffc1034c <msdos_format+0x490>
* 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;
ffc10344: 80 01 00 6c lwz r0,108(r1) <== NOT EXECUTED
ffc10348: 90 01 00 84 stw r0,132(r1) <== NOT EXECUTED
}
/*
* determine usable OEMName
*/
if (ret_val == 0) {
ffc1034c: 2f 9a 00 00 cmpwi cr7,r26,0
ffc10350: 40 9e 01 24 bne- cr7,ffc10474 <msdos_format+0x5b8> <== NEVER TAKEN
const char *from;
char *to = fmt_params->OEMName;
int cnt;
from = "RTEMS"; /* default: make "from" point to OS Name */
if ((rqdata != NULL) &&
ffc10354: 2f 9f 00 00 cmpwi cr7,r31,0
ffc10358: 41 9e 00 10 beq- cr7,ffc10368 <msdos_format+0x4ac> <== NEVER TAKEN
(rqdata->OEMName != NULL)) {
ffc1035c: 81 3f 00 00 lwz r9,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) &&
ffc10360: 2f 89 00 00 cmpwi cr7,r9,0
ffc10364: 40 be 00 0c bne+ cr7,ffc10370 <msdos_format+0x4b4> <== ALWAYS TAKEN
*/
if (ret_val == 0) {
const char *from;
char *to = fmt_params->OEMName;
int cnt;
from = "RTEMS"; /* default: make "from" point to OS Name */
ffc10368: 3d 20 ff c3 lis r9,-61 <== NOT EXECUTED
ffc1036c: 39 29 e0 4a addi r9,r9,-8118 <== NOT EXECUTED
from = rqdata->OEMName;
}
for (cnt = 0;
cnt < (sizeof(fmt_params->OEMName)-1);
cnt++) {
if (isprint((unsigned char)*from)) {
ffc10370: 3d 60 00 00 lis r11,0
* at that character and replace all following characters
* with a ' '
*/
*to++=' ';
}
*to = '\0';
ffc10374: 39 40 00 09 li r10,9
from = rqdata->OEMName;
}
for (cnt = 0;
cnt < (sizeof(fmt_params->OEMName)-1);
cnt++) {
if (isprint((unsigned char)*from)) {
ffc10378: 80 cb 27 ec lwz r6,10220(r11)
/*
* non-printable character in given name, so keep stuck
* at that character and replace all following characters
* with a ' '
*/
*to++=' ';
ffc1037c: 38 e0 00 20 li r7,32
}
*to = '\0';
ffc10380: 7d 49 03 a6 mtctr r10
/*
* determine usable OEMName
*/
if (ret_val == 0) {
const char *from;
char *to = fmt_params->OEMName;
ffc10384: 39 61 00 93 addi r11,r1,147
* at that character and replace all following characters
* with a ' '
*/
*to++=' ';
}
*to = '\0';
ffc10388: 39 00 00 00 li r8,0
ffc1038c: 48 00 00 38 b ffc103c4 <msdos_format+0x508>
from = rqdata->OEMName;
}
for (cnt = 0;
cnt < (sizeof(fmt_params->OEMName)-1);
cnt++) {
if (isprint((unsigned char)*from)) {
ffc10390: 88 09 00 00 lbz r0,0(r9)
ffc10394: 7d 46 02 14 add r10,r6,r0
ffc10398: 89 4a 00 01 lbz r10,1(r10)
ffc1039c: 71 45 00 97 andi. r5,r10,151
ffc103a0: 39 4b 00 01 addi r10,r11,1
ffc103a4: 41 82 00 14 beq- ffc103b8 <msdos_format+0x4fc>
*to++ = *from++;
ffc103a8: 98 0b 00 00 stb r0,0(r11)
ffc103ac: 39 29 00 01 addi r9,r9,1
ffc103b0: 7d 4b 53 78 mr r11,r10
ffc103b4: 48 00 00 0c b ffc103c0 <msdos_format+0x504>
/*
* non-printable character in given name, so keep stuck
* at that character and replace all following characters
* with a ' '
*/
*to++=' ';
ffc103b8: 98 eb 00 00 stb r7,0(r11)
ffc103bc: 7d 4b 53 78 mr r11,r10
}
*to = '\0';
ffc103c0: 99 0a 00 00 stb r8,0(r10)
from = "RTEMS"; /* default: make "from" point to OS Name */
if ((rqdata != NULL) &&
(rqdata->OEMName != NULL)) {
from = rqdata->OEMName;
}
for (cnt = 0;
ffc103c4: 42 00 ff cc bdnz+ ffc10390 <msdos_format+0x4d4>
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) &&
ffc103c8: 2f 9f 00 00 cmpwi cr7,r31,0
ffc103cc: 41 9e 00 1c beq- cr7,ffc103e8 <msdos_format+0x52c> <== NEVER TAKEN
(rqdata->VolLabel != NULL)) {
ffc103d0: 81 3f 00 04 lwz r9,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) &&
ffc103d4: 2f 89 00 00 cmpwi cr7,r9,0
ffc103d8: 41 9e 00 10 beq- cr7,ffc103e8 <msdos_format+0x52c> <== NEVER TAKEN
(rqdata->VolLabel != NULL)) {
from = rqdata->VolLabel;
fmt_params->VolLabel_present = true;
ffc103dc: 38 00 00 01 li r0,1
ffc103e0: 98 01 00 a8 stb r0,168(r1)
ffc103e4: 48 00 00 0c b ffc103f0 <msdos_format+0x534>
*/
if (ret_val == 0) {
const char *from;
char *to = fmt_params->VolLabel;
int cnt;
from = ""; /* default: make "from" point to empty string */
ffc103e8: 3d 20 ff c3 lis r9,-61 <== NOT EXECUTED
ffc103ec: 39 29 eb d7 addi r9,r9,-5161 <== NOT EXECUTED
fmt_params->VolLabel_present = true;
}
for (cnt = 0;
cnt < (sizeof(fmt_params->VolLabel)-1);
cnt++) {
if (isprint((unsigned char)*from)) {
ffc103f0: 3d 60 00 00 lis r11,0
* at that character and replace all following characters
* with a ' '
*/
*to++=' ';
}
*to = '\0';
ffc103f4: 39 40 00 0c li r10,12
fmt_params->VolLabel_present = true;
}
for (cnt = 0;
cnt < (sizeof(fmt_params->VolLabel)-1);
cnt++) {
if (isprint((unsigned char)*from)) {
ffc103f8: 80 cb 27 ec lwz r6,10220(r11)
/*
* non-printable character in given name, so keep stuck
* at that character and replace all following characters
* with a ' '
*/
*to++=' ';
ffc103fc: 38 e0 00 20 li r7,32
}
*to = '\0';
ffc10400: 7d 49 03 a6 mtctr r10
/*
* determine usable Volume Label
*/
if (ret_val == 0) {
const char *from;
char *to = fmt_params->VolLabel;
ffc10404: 39 61 00 9c addi r11,r1,156
* at that character and replace all following characters
* with a ' '
*/
*to++=' ';
}
*to = '\0';
ffc10408: 39 00 00 00 li r8,0
ffc1040c: 48 00 00 38 b ffc10444 <msdos_format+0x588>
fmt_params->VolLabel_present = true;
}
for (cnt = 0;
cnt < (sizeof(fmt_params->VolLabel)-1);
cnt++) {
if (isprint((unsigned char)*from)) {
ffc10410: 88 09 00 00 lbz r0,0(r9)
ffc10414: 7d 46 02 14 add r10,r6,r0
ffc10418: 89 4a 00 01 lbz r10,1(r10)
ffc1041c: 71 45 00 97 andi. r5,r10,151
ffc10420: 39 4b 00 01 addi r10,r11,1
ffc10424: 41 82 00 14 beq- ffc10438 <msdos_format+0x57c>
*to++ = *from++;
ffc10428: 98 0b 00 00 stb r0,0(r11)
ffc1042c: 39 29 00 01 addi r9,r9,1
ffc10430: 7d 4b 53 78 mr r11,r10
ffc10434: 48 00 00 0c b ffc10440 <msdos_format+0x584>
/*
* non-printable character in given name, so keep stuck
* at that character and replace all following characters
* with a ' '
*/
*to++=' ';
ffc10438: 98 eb 00 00 stb r7,0(r11)
ffc1043c: 7d 4b 53 78 mr r11,r10
}
*to = '\0';
ffc10440: 99 0a 00 00 stb r8,0(r10)
if ((rqdata != NULL) &&
(rqdata->VolLabel != NULL)) {
from = rqdata->VolLabel;
fmt_params->VolLabel_present = true;
}
for (cnt = 0;
ffc10444: 42 00 ff cc bdnz+ ffc10410 <msdos_format+0x554>
{
int ret_val = 0;
int rc;
struct timeval time_value;
rc = rtems_clock_get_tod_timeval(&time_value);
ffc10448: 38 61 00 08 addi r3,r1,8
ffc1044c: 48 00 73 55 bl ffc177a0 <rtems_clock_get_tod_timeval>
if (rc == RTEMS_SUCCESSFUL) {
ffc10450: 2f 83 00 00 cmpwi cr7,r3,0
ffc10454: 40 9e 00 14 bne- cr7,ffc10468 <msdos_format+0x5ac> <== ALWAYS TAKEN
*volid_ptr = time_value.tv_sec + time_value.tv_sec;
ffc10458: 80 01 00 08 lwz r0,8(r1) <== NOT EXECUTED
ffc1045c: 54 00 08 3c rlwinm r0,r0,1,0,30 <== NOT EXECUTED
ffc10460: 90 01 00 ac stw r0,172(r1) <== NOT EXECUTED
ffc10464: 48 00 05 cc b ffc10a30 <msdos_format+0xb74> <== NOT EXECUTED
}
else {
*volid_ptr = rand();
ffc10468: 48 00 ed a9 bl ffc1f210 <rand>
ffc1046c: 90 61 00 ac stw r3,172(r1)
ffc10470: 48 00 05 c0 b ffc10a30 <msdos_format+0xb74>
}
/*
* Phuuu.... That's it.
*/
if (ret_val != 0) {
rtems_set_errno_and_return_minus_one(ret_val);
ffc10474: 48 00 dd 65 bl ffc1e1d8 <__errno> <== NOT EXECUTED
ffc10478: 93 43 00 00 stw r26,0(r3) <== NOT EXECUTED
ffc1047c: 48 00 00 84 b ffc10500 <msdos_format+0x644> <== NOT EXECUTED
}
/*
* if requested, write whole disk/partition with 0xe5
*/
if ((ret_val == 0) &&
(rqdata != NULL) &&
ffc10480: 88 1f 00 16 lbz r0,22(r31)
ffc10484: 2f 80 00 00 cmpwi cr7,r0,0
ffc10488: 40 be 00 28 bne+ cr7,ffc104b0 <msdos_format+0x5f4> <== NEVER TAKEN
!(rqdata->quick_format)) {
ret_val = msdos_format_fill_sectors
ffc1048c: 80 c1 00 64 lwz r6,100(r1)
ffc10490: 7f e3 fb 78 mr r3,r31
ffc10494: 80 e1 00 60 lwz r7,96(r1)
ffc10498: 7f c4 f3 78 mr r4,r30
ffc1049c: 38 a0 00 00 li r5,0
ffc104a0: 39 00 00 e5 li r8,229
ffc104a4: 4b ff f8 d5 bl ffc0fd78 <msdos_format_fill_sectors>
}
/*
* create master boot record
*/
if (ret_val == 0) {
ffc104a8: 7c 79 1b 79 mr. r25,r3
ffc104ac: 40 a2 04 e8 bne+ ffc10994 <msdos_format+0xad8> <== NEVER TAKEN
/*
* Read the current MBR to obtain the partition table.
*/
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
ffc104b0: 3c a0 ff c3 lis r5,-61
ffc104b4: 7f e3 fb 78 mr r3,r31
ffc104b8: 38 80 00 02 li r4,2
ffc104bc: 38 a5 ed 18 addi r5,r5,-4840
ffc104c0: 4c c6 31 82 crclr 4*cr1+eq
ffc104c4: 4b ff f7 ad bl ffc0fc70 <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)) {
ffc104c8: 7f c3 f3 78 mr r3,r30
ffc104cc: 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,
ffc104d0: 83 81 00 60 lwz r28,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)) {
ffc104d4: 38 c0 00 00 li r6,0
ffc104d8: 38 e0 00 00 li r7,0
ffc104dc: 4b ff 78 d1 bl ffc07dac <lseek>
ffc104e0: 2f 83 00 00 cmpwi cr7,r3,0
ffc104e4: 41 9c 00 1c blt- cr7,ffc10500 <msdos_format+0x644> <== NEVER TAKEN
ret_val = -1;
}
if (ret_val == 0) {
if (0 > read(fd,buffer,sector_size)) {
ffc104e8: 7f c3 f3 78 mr r3,r30
ffc104ec: 38 81 00 b0 addi r4,r1,176
ffc104f0: 7f 85 e3 78 mr r5,r28
ffc104f4: 4b ff 88 c1 bl ffc08db4 <read>
ffc104f8: 2f 83 00 00 cmpwi cr7,r3,0
ffc104fc: 40 bc 05 40 bge+ cr7,ffc10a3c <msdos_format+0xb80> <== ALWAYS TAKEN
}
/*
* Phuuu.... That's it.
*/
if (ret_val != 0) {
rtems_set_errno_and_return_minus_one(ret_val);
ffc10500: 3b 20 ff ff li r25,-1 <== NOT EXECUTED
ffc10504: 48 00 04 90 b ffc10994 <msdos_format+0xad8> <== 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) {
ffc10508: 7f 7a db 78 mr r26,r27 <== NOT EXECUTED
/*-------------------------------------------------------------------------*\
| Return Value: |
| 0, if success, -1 and errno if failed |
\*=========================================================================*/
{
uint32_t total_sectors_num16 = 0;
ffc1050c: 3b 60 00 00 li r27,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);
ffc10510: 38 61 00 b0 addi r3,r1,176
ffc10514: 38 80 00 00 li r4,0
ffc10518: 38 a0 01 be li r5,446
ffc1051c: 48 00 eb d5 bl ffc1f0f0 <memset>
* 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);
ffc10520: 57 80 c2 3e rlwinm r0,r28,24,8,31
ffc10524: 98 01 00 bc stb r0,188(r1)
*/
/*
* fill OEMName
*/
memcpy(FAT_GET_ADDR_BR_OEMNAME(mbr),
fmt_params->OEMName,
ffc10528: 39 41 00 93 addi r10,r1,147
* with 0xEB,....
*/
/*
* fill OEMName
*/
memcpy(FAT_GET_ADDR_BR_OEMNAME(mbr),
ffc1052c: 39 21 00 b3 addi r9,r1,179
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);
ffc10530: 80 01 00 6c lwz r0,108(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,
ffc10534: 39 60 00 00 li r11,0
* with 0xEB,....
*/
/*
* fill OEMName
*/
memcpy(FAT_GET_ADDR_BR_OEMNAME(mbr),
ffc10538: 7c ea 44 aa lswi r7,r10,8
ffc1053c: 7c e9 45 aa stswi r7,r9,8
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 */
ffc10540: 39 00 00 02 li r8,2
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... */
ffc10544: 39 40 00 01 li r10,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);
ffc10548: 98 01 00 bd stb r0,189(r1)
FAT_SET_BR_RESERVED_SECTORS_NUM(mbr, fmt_params->rsvd_sector_cnt);
ffc1054c: 80 01 00 68 lwz r0,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);
FAT_SET_BR_TOTAL_SECTORS_NUM16(mbr , total_sectors_num16);
ffc10550: 9b 61 00 c3 stb r27,195(r1)
ffc10554: 57 7b c2 3e rlwinm r27,r27,24,8,31
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);
ffc10558: 98 01 00 be stb r0,190(r1)
ffc1055c: 54 00 c2 3e rlwinm r0,r0,24,8,31
ffc10560: 98 01 00 bf stb r0,191(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);
ffc10564: 80 01 00 78 lwz r0,120(r1)
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);
ffc10568: 9b 41 00 d0 stb r26,208(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);
ffc1056c: 98 01 00 c1 stb r0,193(r1)
ffc10570: 54 00 c2 3e rlwinm r0,r0,24,8,31
ffc10574: 98 01 00 c2 stb r0,194(r1)
FAT_SET_BR_TOTAL_SECTORS_NUM16(mbr , total_sectors_num16);
FAT_SET_BR_MEDIA(mbr , fmt_params->media_code);
ffc10578: 88 01 00 91 lbz r0,145(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,
ffc1057c: b1 61 02 ae sth r11,686(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);
ffc10580: 98 01 00 c5 stb r0,197(r1)
FAT_SET_BR_SECTORS_PER_TRACK(mbr , 255); /* only needed for INT13... */
ffc10584: 38 00 ff ff li r0,-1
ffc10588: 98 01 00 c8 stb r0,200(r1)
FAT_SET_BR_NUMBER_OF_HEADS(mbr , 6); /* only needed for INT13... */
ffc1058c: 38 00 00 06 li r0,6
ffc10590: 98 01 00 ca stb r0,202(r1)
FAT_SET_BR_HIDDEN_SECTORS(mbr , 1); /* only needed for INT13... */
FAT_SET_BR_TOTAL_SECTORS_NUM32(mbr , total_sectors_num32);
ffc10594: 57 40 c6 3e rlwinm r0,r26,24,24,31
ffc10598: 98 01 00 d1 stb r0,209(r1)
ffc1059c: 57 40 84 3e rlwinm r0,r26,16,16,31
ffc105a0: 57 5a 46 3e rlwinm r26,r26,8,24,31
ffc105a4: 98 01 00 d2 stb r0,210(r1)
if (fmt_params->fattype != FAT_FAT32) {
ffc105a8: 88 01 00 92 lbz r0,146(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);
ffc105ac: 9b 81 00 bb stb r28,187(r1)
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) {
ffc105b0: 2f 80 00 04 cmpwi cr7,r0,4
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 */
ffc105b4: 99 01 00 c0 stb r8,192(r1)
FAT_SET_BR_FILES_PER_ROOT_DIR(mbr , fmt_params->files_per_root_dir);
FAT_SET_BR_TOTAL_SECTORS_NUM16(mbr , total_sectors_num16);
ffc105b8: 9b 61 00 c4 stb r27,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... */
FAT_SET_BR_HIDDEN_SECTORS(mbr , 1); /* only needed for INT13... */
ffc105bc: 99 41 00 cc stb r10,204(r1)
FAT_SET_BR_TOTAL_SECTORS_NUM32(mbr , total_sectors_num32);
ffc105c0: 9b 41 00 d3 stb r26,211(r1)
ffc105c4: 81 21 00 70 lwz r9,112(r1)
if (fmt_params->fattype != FAT_FAT32) {
ffc105c8: 41 9e 00 74 beq- cr7,ffc1063c <msdos_format+0x780> <== NEVER TAKEN
FAT_SET_BR_SECTORS_PER_FAT(mbr ,fmt_params->sectors_per_fat);
ffc105cc: 99 21 00 c6 stb r9,198(r1)
ffc105d0: 55 29 c2 3e rlwinm r9,r9,24,8,31
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),
ffc105d4: 2f 80 00 01 cmpwi cr7,r0,1
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);
ffc105d8: 99 21 00 c7 stb r9,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);
ffc105dc: 39 20 00 29 li r9,41
ffc105e0: 99 21 00 d6 stb r9,214(r1)
FAT_SET_BR_VOLID(mbr , fmt_params->vol_id); /* volume id */
ffc105e4: 81 21 00 ac lwz r9,172(r1)
ffc105e8: 55 2b c6 3e rlwinm r11,r9,24,24,31
ffc105ec: 99 21 00 d7 stb r9,215(r1)
ffc105f0: 99 61 00 d8 stb r11,216(r1)
ffc105f4: 55 2b 84 3e rlwinm r11,r9,16,16,31
ffc105f8: 55 29 46 3e rlwinm r9,r9,8,24,31
ffc105fc: 99 61 00 d9 stb r11,217(r1)
memcpy(FAT_GET_ADDR_BR_VOLLAB(mbr),
fmt_params->VolLabel,
ffc10600: 39 61 00 9c addi r11,r1,156
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 */
ffc10604: 99 21 00 da stb r9,218(r1)
memcpy(FAT_GET_ADDR_BR_VOLLAB(mbr),
ffc10608: 39 21 00 db addi r9,r1,219
ffc1060c: 7c ab 5c aa lswi r5,r11,11
ffc10610: 7c a9 5d aa stswi r5,r9,11
fmt_params->VolLabel,
FAT_BR_VOLLAB_SIZE);
memcpy(FAT_GET_ADDR_BR_FILSYSTYPE(mbr),
ffc10614: 40 be 00 10 bne+ cr7,ffc10624 <msdos_format+0x768> <== NEVER TAKEN
ffc10618: 3d 20 ff c3 lis r9,-61
ffc1061c: 39 29 ec ad addi r9,r9,-4947
ffc10620: 48 00 00 0c b ffc1062c <msdos_format+0x770>
ffc10624: 3d 20 ff c3 lis r9,-61 <== NOT EXECUTED
ffc10628: 39 29 ec b6 addi r9,r9,-4938 <== NOT EXECUTED
ffc1062c: 39 61 00 e6 addi r11,r1,230
ffc10630: 7c e9 44 aa lswi r7,r9,8
ffc10634: 7c eb 45 aa stswi r7,r11,8
ffc10638: 48 00 00 74 b ffc106ac <msdos_format+0x7f0>
? "FAT12 "
: "FAT16 ",
FAT_BR_FILSYSTYPE_SIZE);
}
else {
FAT_SET_BR_SECTORS_PER_FAT32(mbr ,fmt_params->sectors_per_fat);
ffc1063c: 55 20 c6 3e rlwinm r0,r9,24,24,31 <== NOT EXECUTED
ffc10640: 99 21 00 d4 stb r9,212(r1) <== NOT EXECUTED
ffc10644: 98 01 00 d5 stb r0,213(r1) <== NOT EXECUTED
ffc10648: 55 20 84 3e rlwinm r0,r9,16,16,31 <== NOT EXECUTED
ffc1064c: 55 29 46 3e rlwinm r9,r9,8,24,31 <== NOT EXECUTED
ffc10650: 98 01 00 d6 stb r0,214(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 */
ffc10654: 80 01 00 88 lwz r0,136(r1) <== NOT EXECUTED
? "FAT12 "
: "FAT16 ",
FAT_BR_FILSYSTYPE_SIZE);
}
else {
FAT_SET_BR_SECTORS_PER_FAT32(mbr ,fmt_params->sectors_per_fat);
ffc10658: 99 21 00 d7 stb r9,215(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);
ffc1065c: 39 20 00 29 li r9,41 <== NOT EXECUTED
FAT_SET_BR_SECTORS_PER_FAT32(mbr ,fmt_params->sectors_per_fat);
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 */
ffc10660: 98 01 00 e2 stb r0,226(r1) <== NOT EXECUTED
ffc10664: 54 00 c2 3e rlwinm r0,r0,24,8,31 <== NOT EXECUTED
ffc10668: 98 01 00 e3 stb r0,227(r1) <== NOT EXECUTED
memset(FAT_GET_ADDR_BR_FAT32_RESERVED(mbr),0,FAT_BR_FAT32_RESERVED_SIZE);
ffc1066c: 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);
ffc10670: 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);
memcpy(FAT_GET_ADDR_BR_FAT32_FILSYSTYPE(mbr),
ffc10674: 39 21 01 02 addi r9,r1,258 <== 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);
ffc10678: 99 61 01 01 stb r11,257(r1) <== NOT EXECUTED
memcpy(FAT_GET_ADDR_BR_FAT32_FILSYSTYPE(mbr),
ffc1067c: 3d 60 ff c3 lis r11,-61 <== NOT EXECUTED
ffc10680: 39 6b ed 29 addi r11,r11,-4823 <== NOT EXECUTED
}
else {
FAT_SET_BR_SECTORS_PER_FAT32(mbr ,fmt_params->sectors_per_fat);
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 */
ffc10684: 99 01 00 dc stb r8,220(r1) <== NOT EXECUTED
FAT_SET_BR_FAT32_FS_INFO_SECTOR(mbr, 1); /* Put fsinfo to rsrvd sec 1*/
ffc10688: 99 41 00 e0 stb r10,224(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);
ffc1068c: 90 01 00 e4 stw r0,228(r1) <== NOT EXECUTED
ffc10690: 90 01 00 e8 stw r0,232(r1) <== NOT EXECUTED
ffc10694: 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);
FAT_SET_BR_FAT32_VOLID(mbr , 0); /* not set */
memset(FAT_GET_ADDR_BR_FAT32_VOLLAB(mbr) ,0,FAT_BR_VOLLAB_SIZE);
ffc10698: 90 01 00 f7 stw r0,247(r1) <== NOT EXECUTED
ffc1069c: 90 01 00 fb stw r0,251(r1) <== NOT EXECUTED
ffc106a0: b0 01 00 ff sth r0,255(r1) <== NOT EXECUTED
memcpy(FAT_GET_ADDR_BR_FAT32_FILSYSTYPE(mbr),
ffc106a4: 7c eb 44 aa lswi r7,r11,8 <== NOT EXECUTED
ffc106a8: 7c e9 45 aa stswi r7,r9,8 <== NOT EXECUTED
FAT_BR_FILSYSTYPE_SIZE);
}
/*
* add boot record signature
*/
FAT_SET_BR_SIGNATURE(mbr, FAT_BR_SIGNATURE_VAL);
ffc106ac: 38 00 00 55 li r0,85
ffc106b0: 98 01 02 ae stb r0,686(r1)
ffc106b4: 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,
ffc106b8: 3c a0 ff c3 lis r5,-61
FAT_BR_FILSYSTYPE_SIZE);
}
/*
* add boot record signature
*/
FAT_SET_BR_SIGNATURE(mbr, FAT_BR_SIGNATURE_VAL);
ffc106bc: 98 01 02 af stb r0,687(r1)
/*
* add jump to boot loader at start of sector
*/
FAT_SET_VAL8(mbr,0,0xeb);
ffc106c0: 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,
ffc106c4: 7f e3 fb 78 mr r3,r31
FAT_SET_BR_SIGNATURE(mbr, FAT_BR_SIGNATURE_VAL);
/*
* add jump to boot loader at start of sector
*/
FAT_SET_VAL8(mbr,0,0xeb);
ffc106c8: 98 01 00 b0 stb r0,176(r1)
FAT_SET_VAL8(mbr,1,0x3c);
ffc106cc: 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,
ffc106d0: 38 80 00 02 li r4,2
/*
* add jump to boot loader at start of sector
*/
FAT_SET_VAL8(mbr,0,0xeb);
FAT_SET_VAL8(mbr,1,0x3c);
ffc106d4: 98 01 00 b1 stb r0,177(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,
ffc106d8: 38 a5 ed 32 addi r5,r5,-4814
/*
* add jump to boot loader at start of sector
*/
FAT_SET_VAL8(mbr,0,0xeb);
FAT_SET_VAL8(mbr,1,0x3c);
FAT_SET_VAL8(mbr,2,0x90);
ffc106dc: 38 00 ff 90 li r0,-112
ffc106e0: 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,
ffc106e4: 4c c6 31 82 crclr 4*cr1+eq
ffc106e8: 4b ff f5 89 bl ffc0fc70 <msdos_format_printf>
"write MRB sector\n");
ret_val = msdos_format_write_sec(fd,
ffc106ec: 7f c3 f3 78 mr r3,r30
ffc106f0: 38 80 00 00 li r4,0
ffc106f4: 7f 85 e3 78 mr r5,r28
ffc106f8: 38 c1 00 b0 addi r6,r1,176
ffc106fc: 4b ff f6 25 bl ffc0fd20 <msdos_format_write_sec>
0,
fmt_params.bytes_per_sector,
tmp_sec);
}
if ((ret_val == 0) &&
ffc10700: 7c 79 1b 79 mr. r25,r3
ffc10704: 40 82 02 90 bne- ffc10994 <msdos_format+0xad8> <== NEVER TAKEN
(fmt_params.mbr_copy_sec != 0)) {
ffc10708: 83 61 00 88 lwz r27,136(r1)
ret_val = msdos_format_write_sec(fd,
0,
fmt_params.bytes_per_sector,
tmp_sec);
}
if ((ret_val == 0) &&
ffc1070c: 2f 9b 00 00 cmpwi cr7,r27,0
ffc10710: 41 be 00 38 beq+ cr7,ffc10748 <msdos_format+0x88c> <== ALWAYS TAKEN
(fmt_params.mbr_copy_sec != 0)) {
/*
* write copy of MBR
*/
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
ffc10714: 3c a0 ff c3 lis r5,-61 <== NOT EXECUTED
ffc10718: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc1071c: 38 80 00 02 li r4,2 <== NOT EXECUTED
ffc10720: 38 a5 ed 44 addi r5,r5,-4796 <== NOT EXECUTED
ffc10724: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc10728: 4b ff f5 49 bl ffc0fc70 <msdos_format_printf> <== NOT EXECUTED
"write back up MRB sector\n");
ret_val = msdos_format_write_sec(fd,
ffc1072c: 7f c3 f3 78 mr r3,r30 <== NOT EXECUTED
ffc10730: 7f 64 db 78 mr r4,r27 <== NOT EXECUTED
ffc10734: 7f 85 e3 78 mr r5,r28 <== NOT EXECUTED
ffc10738: 38 c1 00 b0 addi r6,r1,176 <== NOT EXECUTED
ffc1073c: 4b ff f5 e5 bl ffc0fd20 <msdos_format_write_sec> <== NOT EXECUTED
}
}
/*
* for FAT32: initialize info sector on disk
*/
if ((ret_val == 0) &&
ffc10740: 7c 79 1b 79 mr. r25,r3 <== NOT EXECUTED
ffc10744: 40 82 02 50 bne- ffc10994 <msdos_format+0xad8> <== NOT EXECUTED
(fmt_params.fsinfo_sec != 0)) {
ffc10748: 83 61 00 8c lwz r27,140(r1)
}
}
/*
* for FAT32: initialize info sector on disk
*/
if ((ret_val == 0) &&
ffc1074c: 2f 9b 00 00 cmpwi cr7,r27,0
ffc10750: 41 be 00 94 beq+ cr7,ffc107e4 <msdos_format+0x928> <== ALWAYS TAKEN
\*=========================================================================*/
{
/*
* clear fsinfo sector data
*/
memset(fsinfo,0,FAT_TOTAL_FSINFO_SIZE);
ffc10754: 38 80 00 00 li r4,0 <== NOT EXECUTED
ffc10758: 38 a0 02 00 li r5,512 <== NOT EXECUTED
ffc1075c: 38 61 00 b0 addi r3,r1,176 <== NOT EXECUTED
ffc10760: 48 00 e9 91 bl ffc1f0f0 <memset> <== NOT EXECUTED
/*
* write LEADSIG, STRUCTSIG, TRAILSIG
*/
FAT_SET_FSINFO_LEAD_SIGNATURE (fsinfo,FAT_FSINFO_LEAD_SIGNATURE_VALUE );
ffc10764: 38 00 00 52 li r0,82 <== NOT EXECUTED
ffc10768: 98 01 00 b0 stb r0,176(r1) <== NOT EXECUTED
ffc1076c: 39 20 00 41 li r9,65 <== NOT EXECUTED
FAT_SET_FSINFO_STRUC_SIGNATURE(fsinfo,FAT_FSINFO_STRUC_SIGNATURE_VALUE);
ffc10770: 39 60 00 72 li r11,114 <== NOT EXECUTED
*/
memset(fsinfo,0,FAT_TOTAL_FSINFO_SIZE);
/*
* write LEADSIG, STRUCTSIG, TRAILSIG
*/
FAT_SET_FSINFO_LEAD_SIGNATURE (fsinfo,FAT_FSINFO_LEAD_SIGNATURE_VALUE );
ffc10774: 98 01 00 b1 stb r0,177(r1) <== NOT EXECUTED
ffc10778: 38 00 00 61 li r0,97 <== NOT EXECUTED
/*
* write fsinfo sector
*/
if ((ret_val == 0) &&
(fmt_params.fsinfo_sec != 0)) {
ret_val = msdos_format_write_sec(fd,
ffc1077c: 7f c3 f3 78 mr r3,r30 <== NOT EXECUTED
*/
memset(fsinfo,0,FAT_TOTAL_FSINFO_SIZE);
/*
* write LEADSIG, STRUCTSIG, TRAILSIG
*/
FAT_SET_FSINFO_LEAD_SIGNATURE (fsinfo,FAT_FSINFO_LEAD_SIGNATURE_VALUE );
ffc10780: 98 01 00 b2 stb r0,178(r1) <== NOT EXECUTED
/*
* write fsinfo sector
*/
if ((ret_val == 0) &&
(fmt_params.fsinfo_sec != 0)) {
ret_val = msdos_format_write_sec(fd,
ffc10784: 7f 64 db 78 mr r4,r27 <== NOT EXECUTED
ffc10788: 7f 85 e3 78 mr r5,r28 <== NOT EXECUTED
memset(fsinfo,0,FAT_TOTAL_FSINFO_SIZE);
/*
* 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);
ffc1078c: 98 01 02 97 stb r0,663(r1) <== NOT EXECUTED
FAT_SET_FSINFO_TRAIL_SIGNATURE(fsinfo,FAT_FSINFO_TRAIL_SIGNATURE_VALUE);
ffc10790: 38 00 00 55 li r0,85 <== NOT EXECUTED
/*
* write fsinfo sector
*/
if ((ret_val == 0) &&
(fmt_params.fsinfo_sec != 0)) {
ret_val = msdos_format_write_sec(fd,
ffc10794: 38 c1 00 b0 addi r6,r1,176 <== 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);
ffc10798: 98 01 02 ae stb r0,686(r1) <== NOT EXECUTED
ffc1079c: 38 00 ff aa li r0,-86 <== NOT EXECUTED
ffc107a0: 98 01 02 af stb r0,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,
ffc107a4: 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 );
ffc107a8: 99 21 00 b3 stb r9,179(r1) <== NOT EXECUTED
FAT_SET_FSINFO_STRUC_SIGNATURE(fsinfo,FAT_FSINFO_STRUC_SIGNATURE_VALUE);
ffc107ac: 99 61 02 94 stb r11,660(r1) <== NOT EXECUTED
ffc107b0: 99 61 02 95 stb r11,661(r1) <== NOT EXECUTED
ffc107b4: 99 21 02 96 stb r9,662(r1) <== NOT EXECUTED
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,
ffc107b8: 98 01 02 98 stb r0,664(r1) <== NOT EXECUTED
ffc107bc: 98 01 02 99 stb r0,665(r1) <== NOT EXECUTED
ffc107c0: 98 01 02 9a stb r0,666(r1) <== NOT EXECUTED
ffc107c4: 98 01 02 9b stb r0,667(r1) <== NOT EXECUTED
0xffffffff);
FAT_SET_FSINFO_NEXT_FREE_CLUSTER (fsinfo+FAT_FSI_INFO,
ffc107c8: 98 01 02 9c stb r0,668(r1) <== NOT EXECUTED
ffc107cc: 98 01 02 9d stb r0,669(r1) <== NOT EXECUTED
ffc107d0: 98 01 02 9e stb r0,670(r1) <== NOT EXECUTED
ffc107d4: 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,
ffc107d8: 4b ff f5 49 bl ffc0fd20 <msdos_format_write_sec> <== NOT EXECUTED
}
/*
* write FAT as all empty
* -> write all FAT sectors as zero
*/
if (ret_val == 0) {
ffc107dc: 7c 79 1b 79 mr. r25,r3 <== NOT EXECUTED
ffc107e0: 40 a2 01 b4 bne+ ffc10994 <msdos_format+0xad8> <== NOT EXECUTED
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 */
ffc107e4: 8b 61 00 90 lbz r27,144(r1)
/*
* write FAT as all empty
* -> write all FAT sectors as zero
*/
if (ret_val == 0) {
ret_val = msdos_format_fill_sectors
ffc107e8: 7f e3 fb 78 mr r3,r31
ffc107ec: 80 c1 00 70 lwz r6,112(r1)
ffc107f0: 7f c4 f3 78 mr r4,r30
ffc107f4: 80 a1 00 68 lwz r5,104(r1)
ffc107f8: 7f 87 e3 78 mr r7,r28
ffc107fc: 7c db 31 d6 mullw r6,r27,r6
ffc10800: 39 00 00 00 li r8,0
ffc10804: 4b ff f5 75 bl ffc0fd78 <msdos_format_fill_sectors>
}
/*
* clear/init root directory
* -> write all directory sectors as 0x00
*/
if (ret_val == 0) {
ffc10808: 7c 79 1b 79 mr. r25,r3
ffc1080c: 40 82 01 88 bne- ffc10994 <msdos_format+0xad8> <== NEVER TAKEN
ret_val = msdos_format_fill_sectors
(rqdata,
ffc10810: 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
ffc10814: 7f e3 fb 78 mr r3,r31
ffc10818: 80 c1 00 84 lwz r6,132(r1)
ffc1081c: 7f c4 f3 78 mr r4,r30
ffc10820: 7f 45 d3 78 mr r5,r26
ffc10824: 7f 87 e3 78 mr r7,r28
ffc10828: 39 00 00 00 li r8,0
ffc1082c: 4b ff f5 4d bl ffc0fd78 <msdos_format_fill_sectors>
0x00);
}
/*
* write volume label to first entry of directory
*/
if ((ret_val == 0) && fmt_params.VolLabel_present) {
ffc10830: 7c 79 1b 79 mr. r25,r3
ffc10834: 40 82 01 60 bne- ffc10994 <msdos_format+0xad8> <== NEVER TAKEN
ffc10838: 88 01 00 a8 lbz r0,168(r1)
ffc1083c: 2f 80 00 00 cmpwi cr7,r0,0
ffc10840: 41 be 01 54 beq+ cr7,ffc10994 <msdos_format+0xad8> <== NEVER TAKEN
memset(tmp_sec,0,sizeof(tmp_sec));
ffc10844: 3b e1 00 b0 addi r31,r1,176
ffc10848: 38 a0 02 00 li r5,512
ffc1084c: 38 80 00 00 li r4,0
ffc10850: 7f e3 fb 78 mr r3,r31
ffc10854: 48 00 e8 9d bl ffc1f0f0 <memset>
memcpy(MSDOS_DIR_NAME(tmp_sec),fmt_params.VolLabel,MSDOS_SHORT_NAME_LEN);
ffc10858: 39 21 00 9c addi r9,r1,156
ffc1085c: 7c a9 5c aa lswi r5,r9,11
ffc10860: 7c bf 5d aa stswi r5,r31,11
*MSDOS_DIR_ATTR(tmp_sec) = MSDOS_ATTR_VOLUME_ID;
ffc10864: 38 00 00 08 li r0,8
ret_val = msdos_format_write_sec
ffc10868: 7f c3 f3 78 mr r3,r30
ffc1086c: 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);
*MSDOS_DIR_ATTR(tmp_sec) = MSDOS_ATTR_VOLUME_ID;
ffc10870: 98 01 00 bb stb r0,187(r1)
ret_val = msdos_format_write_sec
ffc10874: 7f 85 e3 78 mr r5,r28
ffc10878: 7f e6 fb 78 mr r6,r31
ffc1087c: 4b ff f4 a5 bl ffc0fd20 <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){
ffc10880: 7c 79 1b 79 mr. r25,r3
ffc10884: 40 82 01 10 bne- ffc10994 <msdos_format+0xad8> <== NEVER TAKEN
/*
* empty sector: all clusters are free/do not link further on
*/
memset(tmp_sec,0,sizeof(tmp_sec));
ffc10888: 7f e3 fb 78 mr r3,r31
ffc1088c: 38 80 00 00 li r4,0
ffc10890: 38 a0 02 00 li r5,512
ffc10894: 48 00 e8 5d bl ffc1f0f0 <memset>
switch(fmt_params.fattype) {
ffc10898: 88 01 00 92 lbz r0,146(r1)
ffc1089c: 2f 80 00 02 cmpwi cr7,r0,2
ffc108a0: 41 9e 00 30 beq- cr7,ffc108d0 <msdos_format+0xa14> <== NEVER TAKEN
ffc108a4: 2e 00 00 04 cmpwi cr4,r0,4
ffc108a8: 41 92 00 48 beq- cr4,ffc108f0 <msdos_format+0xa34> <== NEVER TAKEN
ffc108ac: 2f 80 00 01 cmpwi cr7,r0,1
ffc108b0: 40 be 00 74 bne+ cr7,ffc10924 <msdos_format+0xa68> <== NEVER TAKEN
case FAT_FAT12:
/* LSBits of FAT entry 0: media_type */
FAT_SET_VAL8(tmp_sec,0,(fmt_params.media_code));
ffc108b4: 88 01 00 91 lbz r0,145(r1)
ffc108b8: 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)));
ffc108bc: 38 00 ff 8f li r0,-113
ffc108c0: 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));
ffc108c4: 38 00 ff ff li r0,-1
ffc108c8: 98 01 00 b2 stb r0,178(r1)
break;
ffc108cc: 48 00 00 88 b ffc10954 <msdos_format+0xa98>
case FAT_FAT16:
/* FAT entry 0: 0xff00|media_type */
FAT_SET_VAL8(tmp_sec,0,fmt_params.media_code);
ffc108d0: 88 01 00 91 lbz r0,145(r1) <== NOT EXECUTED
FAT_SET_VAL8(tmp_sec,1,0xff);
/* FAT entry 1: EOC */
FAT_SET_VAL16(tmp_sec,2,FAT_FAT16_EOC);
ffc108d4: 39 20 ff f8 li r9,-8 <== NOT EXECUTED
ffc108d8: 99 21 00 b2 stb r9,178(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);
ffc108dc: 98 01 00 b0 stb r0,176(r1) <== NOT EXECUTED
FAT_SET_VAL8(tmp_sec,1,0xff);
ffc108e0: 38 00 ff ff li r0,-1 <== NOT EXECUTED
ffc108e4: 98 01 00 b1 stb r0,177(r1) <== NOT EXECUTED
/* FAT entry 1: EOC */
FAT_SET_VAL16(tmp_sec,2,FAT_FAT16_EOC);
ffc108e8: 98 01 00 b3 stb r0,179(r1) <== NOT EXECUTED
break;
ffc108ec: 48 00 00 68 b ffc10954 <msdos_format+0xa98> <== NOT EXECUTED
case FAT_FAT32:
/* FAT entry 0: 0xffffff00|media_type */
FAT_SET_VAL32(tmp_sec,0,0xffffff00|fmt_params.media_code);
ffc108f0: 88 01 00 91 lbz r0,145(r1) <== NOT EXECUTED
/* FAT entry 1: EOC */
FAT_SET_VAL32(tmp_sec,4,FAT_FAT32_EOC);
ffc108f4: 39 20 ff f8 li r9,-8 <== NOT EXECUTED
ffc108f8: 99 21 00 b4 stb r9,180(r1) <== 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);
ffc108fc: 98 01 00 b0 stb r0,176(r1) <== NOT EXECUTED
ffc10900: 38 00 ff ff li r0,-1 <== NOT EXECUTED
ffc10904: 98 01 00 b1 stb r0,177(r1) <== NOT EXECUTED
ffc10908: 98 01 00 b2 stb r0,178(r1) <== NOT EXECUTED
ffc1090c: 98 01 00 b3 stb r0,179(r1) <== NOT EXECUTED
/* FAT entry 1: EOC */
FAT_SET_VAL32(tmp_sec,4,FAT_FAT32_EOC);
ffc10910: 98 01 00 b5 stb r0,181(r1) <== NOT EXECUTED
ffc10914: 98 01 00 b6 stb r0,182(r1) <== NOT EXECUTED
ffc10918: 38 00 00 0f li r0,15 <== NOT EXECUTED
ffc1091c: 98 01 00 b7 stb r0,183(r1) <== NOT EXECUTED
ffc10920: 48 00 00 18 b ffc10938 <msdos_format+0xa7c> <== NOT EXECUTED
break;
default:
ret_val = -1;
errno = EINVAL;
ffc10924: 48 00 d8 b5 bl ffc1e1d8 <__errno> <== NOT EXECUTED
ffc10928: 38 00 00 16 li r0,22 <== NOT EXECUTED
ffc1092c: 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;
ffc10930: 3b 20 ff ff li r25,-1 <== NOT EXECUTED
errno = EINVAL;
}
if (fmt_params.fattype == FAT_FAT32) {
ffc10934: 40 b2 00 20 bne+ cr4,ffc10954 <msdos_format+0xa98> <== 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);
ffc10938: 38 00 ff f8 li r0,-8 <== NOT EXECUTED
ffc1093c: 98 01 00 b8 stb r0,184(r1) <== NOT EXECUTED
ffc10940: 38 00 ff ff li r0,-1 <== NOT EXECUTED
ffc10944: 98 01 00 b9 stb r0,185(r1) <== NOT EXECUTED
ffc10948: 98 01 00 ba stb r0,186(r1) <== NOT EXECUTED
ffc1094c: 38 00 00 0f li r0,15 <== NOT EXECUTED
ffc10950: 98 01 00 bb stb r0,187(r1) <== NOT EXECUTED
/* FAT entry 1: EOC */
FAT_SET_VAL32(tmp_sec,4,FAT_FAT32_EOC);
break;
default:
ret_val = -1;
ffc10954: 3b e0 00 00 li r31,0
ffc10958: 48 00 00 2c b ffc10984 <msdos_format+0xac8>
(i < fmt_params.fat_num) && (ret_val == 0);
i++) {
ret_val = msdos_format_write_sec
(fd,
fmt_params.rsvd_sector_cnt
+ (i * fmt_params.sectors_per_fat),
ffc1095c: 80 81 00 70 lwz r4,112(r1)
FAT_SET_VAL32(tmp_sec,8,FAT_FAT32_EOC);
}
for (i = 0;
(i < fmt_params.fat_num) && (ret_val == 0);
i++) {
ret_val = msdos_format_write_sec
ffc10960: 7f c3 f3 78 mr r3,r30
ffc10964: 80 01 00 68 lwz r0,104(r1)
ffc10968: 38 c1 00 b0 addi r6,r1,176
(fd,
fmt_params.rsvd_sector_cnt
+ (i * fmt_params.sectors_per_fat),
ffc1096c: 7c 9f 21 d6 mullw r4,r31,r4
FAT_SET_VAL32(tmp_sec,8,FAT_FAT32_EOC);
}
for (i = 0;
(i < fmt_params.fat_num) && (ret_val == 0);
i++) {
ret_val = msdos_format_write_sec
ffc10970: 80 a1 00 60 lwz r5,96(r1)
*/
FAT_SET_VAL32(tmp_sec,8,FAT_FAT32_EOC);
}
for (i = 0;
(i < fmt_params.fat_num) && (ret_val == 0);
i++) {
ffc10974: 3b ff 00 01 addi r31,r31,1
ret_val = msdos_format_write_sec
ffc10978: 7c 84 02 14 add r4,r4,r0
ffc1097c: 4b ff f3 a5 bl ffc0fd20 <msdos_format_write_sec>
ffc10980: 7c 79 1b 78 mr r25,r3
* 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;
ffc10984: 7f 9f d8 00 cmpw cr7,r31,r27
ffc10988: 40 9c 00 0c bge- cr7,ffc10994 <msdos_format+0xad8>
(i < fmt_params.fat_num) && (ret_val == 0);
ffc1098c: 2f 99 00 00 cmpwi cr7,r25,0
ffc10990: 41 9e ff cc beq+ cr7,ffc1095c <msdos_format+0xaa0> <== ALWAYS TAKEN
/*
* cleanup:
* sync and unlock disk
* free any data structures (not needed now)
*/
if (fd != -1) {
ffc10994: 2f 9e ff ff cmpwi cr7,r30,-1
ffc10998: 41 9e 00 0c beq- cr7,ffc109a4 <msdos_format+0xae8> <== NEVER TAKEN
close(fd);
ffc1099c: 7f c3 f3 78 mr r3,r30
ffc109a0: 4b ff 6c 1d bl ffc075bc <close>
}
if (dd != NULL) {
ffc109a4: 2f 9d 00 00 cmpwi cr7,r29,0
ffc109a8: 41 9e 00 0c beq- cr7,ffc109b4 <msdos_format+0xaf8> <== NEVER TAKEN
rtems_disk_release(dd);
ffc109ac: 7f a3 eb 78 mr r3,r29
ffc109b0: 4b ff 5f 41 bl ffc068f0 <rtems_disk_release>
}
return ret_val;
}
ffc109b4: 81 81 02 b8 lwz r12,696(r1)
ffc109b8: 39 61 02 d8 addi r11,r1,728
ffc109bc: 7f 23 cb 78 mr r3,r25
ffc109c0: 7d 80 81 20 mtcrf 8,r12
ffc109c4: 4b ff 21 1c b ffc02ae0 <_restgpr_25_x>
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);
ffc109c8: 80 61 00 30 lwz r3,48(r1)
ffc109cc: 80 81 00 34 lwz r4,52(r1)
ffc109d0: 4b ff 5e 9d bl ffc0686c <rtems_disk_obtain>
if (dd == NULL) {
ffc109d4: 7c 7d 1b 79 mr. r29,r3
ffc109d8: 41 a2 f5 a8 beq- ffc0ff80 <msdos_format+0xc4> <== 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));
ffc109dc: 38 80 00 00 li r4,0
ffc109e0: 38 a0 00 50 li r5,80
ffc109e4: 38 61 00 60 addi r3,r1,96
ffc109e8: 48 00 e7 09 bl ffc1f0f0 <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;
ffc109ec: 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;
ffc109f0: 80 dd 00 20 lwz r6,32(r29)
fmt_params->totl_sector_cnt = dd->size;
total_size = dd->block_size * dd->size;
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
ffc109f4: 3c a0 ff c3 lis r5,-61
ffc109f8: 7f e3 fb 78 mr r3,r31
* 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;
ffc109fc: 93 81 00 64 stw r28,100(r1)
total_size = dd->block_size * dd->size;
ffc10a00: 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;
ffc10a04: 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,
ffc10a08: 38 80 00 02 li r4,2
ffc10a0c: 38 a5 ed 5e addi r5,r5,-4770
ffc10a10: 7f 87 e3 78 mr r7,r28
ffc10a14: 39 20 00 00 li r9,0
ffc10a18: 7f 6a db 78 mr r10,r27
ffc10a1c: 4c c6 31 82 crclr 4*cr1+eq
ffc10a20: 4b ff f2 51 bl ffc0fc70 <msdos_format_printf>
}
/*
* determine number of FATs
*/
if (ret_val == 0) {
if ((rqdata == NULL) ||
ffc10a24: 2f 9f 00 00 cmpwi cr7,r31,0
ffc10a28: 40 9e f5 70 bne+ cr7,ffc0ff98 <msdos_format+0xdc> <== ALWAYS TAKEN
ffc10a2c: 4b ff f5 78 b ffc0ffa4 <msdos_format+0xe8> <== 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) &&
ffc10a30: 2f 9f 00 00 cmpwi cr7,r31,0
ffc10a34: 40 9e fa 4c bne+ cr7,ffc10480 <msdos_format+0x5c4> <== ALWAYS TAKEN
ffc10a38: 4b ff fa 78 b ffc104b0 <msdos_format+0x5f4> <== NOT EXECUTED
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,
ffc10a3c: 3c a0 ff c3 lis r5,-61
ffc10a40: 7f e3 fb 78 mr r3,r31
ffc10a44: 38 80 00 02 li r4,2
ffc10a48: 38 a5 ed 96 addi r5,r5,-4714
ffc10a4c: 4c c6 31 82 crclr 4*cr1+eq
ffc10a50: 4b ff f2 21 bl ffc0fc70 <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) {
ffc10a54: 83 61 00 64 lwz r27,100(r1)
| Return Value: |
| 0, if success, -1 and errno if failed |
\*=========================================================================*/
{
uint32_t total_sectors_num16 = 0;
uint32_t total_sectors_num32 = 0;
ffc10a58: 3b 40 00 00 li r26,0
/* store total sector count in either 16 or 32 bit field in mbr */
if (fmt_params->totl_sector_cnt < 0x10000) {
ffc10a5c: 2b 9b ff ff cmplwi cr7,r27,65535
ffc10a60: 40 bd fa b0 ble- cr7,ffc10510 <msdos_format+0x654> <== ALWAYS TAKEN
ffc10a64: 4b ff fa a4 b ffc10508 <msdos_format+0x64c> <== NOT EXECUTED
ffc0fd78 <msdos_format_fill_sectors>:
)
/*-------------------------------------------------------------------------*\
| Return Value: |
| 0, if success, -1 and errno if failed |
\*=========================================================================*/
{
ffc0fd78: 94 21 ff c8 stwu r1,-56(r1)
ffc0fd7c: 7c 08 02 a6 mflr r0
ffc0fd80: be a1 00 0c stmw r21,12(r1)
ffc0fd84: 7c 7e 1b 78 mr r30,r3
/*
* allocate and fill buffer
*/
if (ret_val == 0) {
fill_buffer = malloc(sector_size);
ffc0fd88: 7c e3 3b 78 mr r3,r7
)
/*-------------------------------------------------------------------------*\
| Return Value: |
| 0, if success, -1 and errno if failed |
\*=========================================================================*/
{
ffc0fd8c: 90 01 00 3c stw r0,60(r1)
ffc0fd90: 7c 9c 23 78 mr r28,r4
ffc0fd94: 7c bf 2b 78 mr r31,r5
ffc0fd98: 7c dd 33 78 mr r29,r6
ffc0fd9c: 7c fb 3b 78 mr r27,r7
ffc0fda0: 7d 1a 43 78 mr r26,r8
/*
* allocate and fill buffer
*/
if (ret_val == 0) {
fill_buffer = malloc(sector_size);
ffc0fda4: 4b ff 82 b1 bl ffc08054 <malloc>
if (fill_buffer == NULL) {
ffc0fda8: 7c 79 1b 79 mr. r25,r3
ffc0fdac: 40 a2 00 18 bne+ ffc0fdc4 <msdos_format_fill_sectors+0x4c><== ALWAYS TAKEN
errno = ENOMEM;
ffc0fdb0: 48 00 e4 29 bl ffc1e1d8 <__errno> <== NOT EXECUTED
ffc0fdb4: 38 00 00 0c li r0,12 <== NOT EXECUTED
ffc0fdb8: 90 03 00 00 stw r0,0(r3) <== NOT EXECUTED
ret_val = -1;
ffc0fdbc: 3b 40 ff ff li r26,-1 <== NOT EXECUTED
ffc0fdc0: 48 00 00 14 b ffc0fdd4 <msdos_format_fill_sectors+0x5c><== NOT EXECUTED
}
else {
memset(fill_buffer,fill_byte,sector_size);
ffc0fdc4: 7f 44 d3 78 mr r4,r26
ffc0fdc8: 7f 65 db 78 mr r5,r27
ffc0fdcc: 48 00 f3 25 bl ffc1f0f0 <memset>
/*-------------------------------------------------------------------------*\
| Return Value: |
| 0, if success, -1 and errno if failed |
\*=========================================================================*/
{
int ret_val = 0;
ffc0fdd0: 3b 40 00 00 li r26,0
else {
memset(fill_buffer,fill_byte,sector_size);
}
}
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
ffc0fdd4: 3c a0 ff c3 lis r5,-61
ffc0fdd8: 7f c3 f3 78 mr r3,r30
ffc0fddc: 38 80 00 02 li r4,2
ffc0fde0: 38 a5 ec 85 addi r5,r5,-4987
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, ".");
ffc0fde4: 3e a0 ff c3 lis r21,-61
else {
memset(fill_buffer,fill_byte,sector_size);
}
}
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
ffc0fde8: 4c c6 31 82 crclr 4*cr1+eq
ffc0fdec: 4b ff fe 85 bl ffc0fc70 <msdos_format_printf>
ffc0fdf0: 1e dd 00 64 mulli r22,r29,100
"Filling : ");
/*
* write to consecutive sectors
*/
while ((ret_val == 0) &&
ffc0fdf4: 7f b7 eb 78 mr r23,r29
\*=========================================================================*/
{
int ret_val = 0;
char *fill_buffer = NULL;
uint32_t total_sectors = sector_cnt;
int last_percent = -1;
ffc0fdf8: 3b 00 ff ff li r24,-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, ".");
ffc0fdfc: 3a b5 db 02 addi r21,r21,-9470
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
"Filling : ");
/*
* write to consecutive sectors
*/
while ((ret_val == 0) &&
ffc0fe00: 48 00 00 54 b ffc0fe54 <msdos_format_fill_sectors+0xdc>
(sector_cnt > 0)) {
int percent = (sector_cnt * 100) / total_sectors;
ffc0fe04: 7c 16 eb 96 divwu r0,r22,r29
if (percent != last_percent) {
ffc0fe08: 7f 80 c0 00 cmpw cr7,r0,r24
ffc0fe0c: 41 9e 00 24 beq- cr7,ffc0fe30 <msdos_format_fill_sectors+0xb8>
if ((percent & 1) == 0)
ffc0fe10: 7c 18 03 78 mr r24,r0
ffc0fe14: 73 00 00 01 andi. r0,r24,1
ffc0fe18: 40 a2 00 18 bne+ ffc0fe30 <msdos_format_fill_sectors+0xb8>
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL, ".");
ffc0fe1c: 7f c3 f3 78 mr r3,r30
ffc0fe20: 38 80 00 02 li r4,2
ffc0fe24: 7e a5 ab 78 mr r5,r21
ffc0fe28: 4c c6 31 82 crclr 4*cr1+eq
ffc0fe2c: 4b ff fe 45 bl ffc0fc70 <msdos_format_printf>
last_percent = percent;
}
ret_val = msdos_format_write_sec(fd,start_sector,sector_size,fill_buffer);
ffc0fe30: 7f e4 fb 78 mr r4,r31
ffc0fe34: 7f 83 e3 78 mr r3,r28
ffc0fe38: 7f 65 db 78 mr r5,r27
ffc0fe3c: 7f 26 cb 78 mr r6,r25
ffc0fe40: 4b ff fe e1 bl ffc0fd20 <msdos_format_write_sec>
start_sector++;
ffc0fe44: 3b ff 00 01 addi r31,r31,1
if (percent != last_percent) {
if ((percent & 1) == 0)
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);
ffc0fe48: 7c 7a 1b 78 mr r26,r3
start_sector++;
sector_cnt--;
ffc0fe4c: 3a f7 ff ff addi r23,r23,-1
ffc0fe50: 3a d6 ff 9c addi r22,r22,-100
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
"Filling : ");
/*
* write to consecutive sectors
*/
while ((ret_val == 0) &&
ffc0fe54: 2f 9a 00 00 cmpwi cr7,r26,0
ffc0fe58: 40 9e 00 0c bne- cr7,ffc0fe64 <msdos_format_fill_sectors+0xec><== NEVER TAKEN
ffc0fe5c: 2f 97 00 00 cmpwi cr7,r23,0
ffc0fe60: 40 9e ff a4 bne+ cr7,ffc0fe04 <msdos_format_fill_sectors+0x8c>
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");
ffc0fe64: 3c a0 ff c3 lis r5,-61
ffc0fe68: 7f c3 f3 78 mr r3,r30
ffc0fe6c: 38 80 00 02 li r4,2
ffc0fe70: 38 a5 da 35 addi r5,r5,-9675
ffc0fe74: 4c c6 31 82 crclr 4*cr1+eq
ffc0fe78: 4b ff fd f9 bl ffc0fc70 <msdos_format_printf>
if (ret_val)
ffc0fe7c: 2f 9a 00 00 cmpwi cr7,r26,0
ffc0fe80: 41 be 00 20 beq+ cr7,ffc0fea0 <msdos_format_fill_sectors+0x128><== ALWAYS TAKEN
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_INFO,
ffc0fe84: 3c a0 ff c3 lis r5,-61 <== NOT EXECUTED
ffc0fe88: 7f c3 f3 78 mr r3,r30 <== NOT EXECUTED
ffc0fe8c: 38 80 00 01 li r4,1 <== NOT EXECUTED
ffc0fe90: 38 a5 ec 90 addi r5,r5,-4976 <== NOT EXECUTED
ffc0fe94: 7f e6 fb 78 mr r6,r31 <== NOT EXECUTED
ffc0fe98: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc0fe9c: 4b ff fd d5 bl ffc0fc70 <msdos_format_printf> <== NOT EXECUTED
"filling error on sector: %d\n", start_sector);
/*
* cleanup
*/
if (fill_buffer != NULL) {
ffc0fea0: 2f 99 00 00 cmpwi cr7,r25,0
ffc0fea4: 41 9e 00 0c beq- cr7,ffc0feb0 <msdos_format_fill_sectors+0x138><== NEVER TAKEN
free(fill_buffer);
ffc0fea8: 7f 23 cb 78 mr r3,r25
ffc0feac: 4b ff 7a 3d bl ffc078e8 <free>
fill_buffer = NULL;
}
return ret_val;
}
ffc0feb0: 39 61 00 38 addi r11,r1,56
ffc0feb4: 7f 43 d3 78 mr r3,r26
ffc0feb8: 4b ff 2c 18 b ffc02ad0 <_restgpr_21_x>
ffc0fc70 <msdos_format_printf>:
*/
static void
msdos_format_printf (const msdos_format_request_param_t *rqdata,
int info_level,
const char *format, ...)
{
ffc0fc70: 7c 08 02 a6 mflr r0
ffc0fc74: 7c 2b 0b 78 mr r11,r1
ffc0fc78: 94 21 ff 88 stwu r1,-120(r1)
ffc0fc7c: 90 01 00 7c stw r0,124(r1)
ffc0fc80: 4b ff 2e 2d bl ffc02aac <_savegpr_31>
ffc0fc84: 7c 80 23 78 mr r0,r4
ffc0fc88: 90 c1 00 1c stw r6,28(r1)
ffc0fc8c: 90 e1 00 20 stw r7,32(r1)
ffc0fc90: 91 01 00 24 stw r8,36(r1)
ffc0fc94: 91 21 00 28 stw r9,40(r1)
ffc0fc98: 91 41 00 2c stw r10,44(r1)
ffc0fc9c: 40 86 00 24 bne- cr1,ffc0fcc0 <msdos_format_printf+0x50><== ALWAYS TAKEN
ffc0fca0: d8 21 00 30 stfd f1,48(r1) <== NOT EXECUTED
ffc0fca4: d8 41 00 38 stfd f2,56(r1) <== NOT EXECUTED
ffc0fca8: d8 61 00 40 stfd f3,64(r1) <== NOT EXECUTED
ffc0fcac: d8 81 00 48 stfd f4,72(r1) <== NOT EXECUTED
ffc0fcb0: d8 a1 00 50 stfd f5,80(r1) <== NOT EXECUTED
ffc0fcb4: d8 c1 00 58 stfd f6,88(r1) <== NOT EXECUTED
ffc0fcb8: d8 e1 00 60 stfd f7,96(r1) <== NOT EXECUTED
ffc0fcbc: 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)
ffc0fcc0: 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);
ffc0fcc4: 39 20 00 03 li r9,3
ffc0fcc8: 99 21 00 08 stb r9,8(r1)
ffc0fccc: 39 20 00 00 li r9,0
ffc0fcd0: 99 21 00 09 stb r9,9(r1)
ffc0fcd4: 39 21 00 80 addi r9,r1,128
ffc0fcd8: 91 21 00 0c stw r9,12(r1)
ffc0fcdc: 39 21 00 10 addi r9,r1,16
ffc0fce0: 91 21 00 10 stw r9,16(r1)
if (rqdata != NULL && rqdata->info_level >= info_level)
ffc0fce4: 41 9e 00 34 beq- cr7,ffc0fd18 <msdos_format_printf+0xa8><== NEVER TAKEN
ffc0fce8: 81 23 00 1c lwz r9,28(r3)
ffc0fcec: 7f 89 00 00 cmpw cr7,r9,r0
ffc0fcf0: 41 bc 00 28 blt+ cr7,ffc0fd18 <msdos_format_printf+0xa8><== ALWAYS TAKEN
{
vfprintf (stdout, format, args);
ffc0fcf4: 3f e0 00 00 lis r31,0 <== NOT EXECUTED
ffc0fcf8: 81 3f 27 f4 lwz r9,10228(r31) <== NOT EXECUTED
ffc0fcfc: 7c a4 2b 78 mr r4,r5 <== NOT EXECUTED
ffc0fd00: 38 a1 00 08 addi r5,r1,8 <== NOT EXECUTED
ffc0fd04: 80 69 00 08 lwz r3,8(r9) <== NOT EXECUTED
ffc0fd08: 48 01 6d c5 bl ffc26acc <vfprintf> <== NOT EXECUTED
fflush (stdout);
ffc0fd0c: 81 3f 27 f4 lwz r9,10228(r31) <== NOT EXECUTED
ffc0fd10: 80 69 00 08 lwz r3,8(r9) <== NOT EXECUTED
ffc0fd14: 48 00 e9 99 bl ffc1e6ac <fflush> <== NOT EXECUTED
}
va_end (args);
}
ffc0fd18: 39 61 00 78 addi r11,r1,120
ffc0fd1c: 4b ff 2d dc b ffc02af8 <_restgpr_31_x>
ffc0fd20 <msdos_format_write_sec>:
)
/*-------------------------------------------------------------------------*\
| Return Value: |
| 0, if success, -1 and errno if failed |
\*=========================================================================*/
{
ffc0fd20: 94 21 ff e8 stwu r1,-24(r1)
ffc0fd24: 7c 08 02 a6 mflr r0
int ret_val = 0;
if (0 > lseek(fd,((off_t)start_sector)*sector_size,SEEK_SET)) {
ffc0fd28: 38 e0 00 00 li r7,0
)
/*-------------------------------------------------------------------------*\
| Return Value: |
| 0, if success, -1 and errno if failed |
\*=========================================================================*/
{
ffc0fd2c: bf a1 00 0c stmw r29,12(r1)
ffc0fd30: 7c bf 2b 78 mr r31,r5
ffc0fd34: 7c de 33 78 mr r30,r6
int ret_val = 0;
if (0 > lseek(fd,((off_t)start_sector)*sector_size,SEEK_SET)) {
ffc0fd38: 7c a4 28 16 mulhwu r5,r4,r5
)
/*-------------------------------------------------------------------------*\
| Return Value: |
| 0, if success, -1 and errno if failed |
\*=========================================================================*/
{
ffc0fd3c: 90 01 00 1c stw r0,28(r1)
int ret_val = 0;
if (0 > lseek(fd,((off_t)start_sector)*sector_size,SEEK_SET)) {
ffc0fd40: 7c c4 f9 d6 mullw r6,r4,r31
)
/*-------------------------------------------------------------------------*\
| Return Value: |
| 0, if success, -1 and errno if failed |
\*=========================================================================*/
{
ffc0fd44: 7c 7d 1b 78 mr r29,r3
int ret_val = 0;
if (0 > lseek(fd,((off_t)start_sector)*sector_size,SEEK_SET)) {
ffc0fd48: 4b ff 80 65 bl ffc07dac <lseek>
ffc0fd4c: 38 00 ff ff li r0,-1
ffc0fd50: 2f 83 00 00 cmpwi cr7,r3,0
ffc0fd54: 41 9c 00 18 blt- cr7,ffc0fd6c <msdos_format_write_sec+0x4c><== NEVER TAKEN
ret_val = -1;
}
if (ret_val == 0) {
if (0 > write(fd,buffer,sector_size)) {
ffc0fd58: 7f a3 eb 78 mr r3,r29
ffc0fd5c: 7f c4 f3 78 mr r4,r30
ffc0fd60: 7f e5 fb 78 mr r5,r31
ffc0fd64: 4b ff b7 d5 bl ffc0b538 <write>
ffc0fd68: 7c 60 fe 70 srawi r0,r3,31
ret_val = -1;
}
}
return ret_val;
}
ffc0fd6c: 39 61 00 18 addi r11,r1,24
ffc0fd70: 7c 03 03 78 mr r3,r0
ffc0fd74: 4b ff 2d 7c b ffc02af0 <_restgpr_29_x>
ffc1a7b0 <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)
{
ffc1a7b0: 94 21 ff f0 stwu r1,-16(r1)
ffc1a7b4: 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,
ffc1a7b8: 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)
{
ffc1a7bc: 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,
ffc1a7c0: 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;
ffc1a7c4: 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)
{
ffc1a7c8: bf c1 00 08 stmw r30,8(r1)
ffc1a7cc: 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;
ffc1a7d0: 83 c9 00 34 lwz r30,52(r9)
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
ffc1a7d4: 80 7e 00 98 lwz r3,152(r30)
ffc1a7d8: 4b ff 15 19 bl ffc0bcf0 <rtems_semaphore_obtain>
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
ffc1a7dc: 2f 83 00 00 cmpwi cr7,r3,0
ffc1a7e0: 41 be 00 18 beq+ cr7,ffc1a7f8 <msdos_free_node_info+0x48><== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one(EIO);
ffc1a7e4: 48 00 39 f5 bl ffc1e1d8 <__errno> <== NOT EXECUTED
ffc1a7e8: 38 00 00 05 li r0,5 <== NOT EXECUTED
ffc1a7ec: 90 03 00 00 stw r0,0(r3) <== NOT EXECUTED
ffc1a7f0: 3b e0 ff ff li r31,-1 <== NOT EXECUTED
ffc1a7f4: 48 00 00 1c b ffc1a810 <msdos_free_node_info+0x60> <== NOT EXECUTED
rc = fat_file_close(pathloc->mt_entry, pathloc->node_access);
ffc1a7f8: 80 7f 00 10 lwz r3,16(r31)
ffc1a7fc: 80 9f 00 00 lwz r4,0(r31)
ffc1a800: 4b ff 9a 05 bl ffc14204 <fat_file_close>
ffc1a804: 7c 7f 1b 78 mr r31,r3
rtems_semaphore_release(fs_info->vol_sema);
ffc1a808: 80 7e 00 98 lwz r3,152(r30)
ffc1a80c: 4b ff 16 11 bl ffc0be1c <rtems_semaphore_release>
return rc;
}
ffc1a810: 39 61 00 10 addi r11,r1,16
ffc1a814: 7f e3 fb 78 mr r3,r31
ffc1a818: 4b fe 82 dc b ffc02af4 <_restgpr_30_x>
ffc1ba40 <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
)
{
ffc1ba40: 94 21 ff 88 stwu r1,-120(r1) <== NOT EXECUTED
ffc1ba44: 7c 08 02 a6 mflr r0 <== NOT EXECUTED
ffc1ba48: bf 01 00 58 stmw r24,88(r1) <== NOT EXECUTED
ffc1ba4c: 7c be 2b 78 mr r30,r5 <== NOT EXECUTED
int rc = RC_OK;
msdos_fs_info_t *fs_info = mt_entry->fs_info;
fat_file_fd_t *fat_fd = NULL;
ffc1ba50: 7c 25 0b 78 mr r5,r1 <== NOT EXECUTED
rtems_filesystem_mount_table_entry_t *mt_entry,
uint32_t cln,
fat_dir_pos_t *dir_pos,
char *dir_entry
)
{
ffc1ba54: 90 01 00 7c stw r0,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;
ffc1ba58: 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
)
{
ffc1ba5c: 7c 9a 23 78 mr r26,r4 <== NOT EXECUTED
int rc = RC_OK;
msdos_fs_info_t *fs_info = mt_entry->fs_info;
fat_file_fd_t *fat_fd = NULL;
ffc1ba60: 94 05 00 08 stwu r0,8(r5) <== NOT EXECUTED
uint32_t cl4find = 0;
/*
* open fat-file corresponded to ".."
*/
rc = fat_file_open(mt_entry, dir_pos, &fat_fd);
ffc1ba64: 7f c4 f3 78 mr r4,r30 <== NOT EXECUTED
rtems_filesystem_mount_table_entry_t *mt_entry,
uint32_t cln,
fat_dir_pos_t *dir_pos,
char *dir_entry
)
{
ffc1ba68: 7c 7f 1b 78 mr r31,r3 <== NOT EXECUTED
ffc1ba6c: 7c dc 33 78 mr r28,r6 <== NOT EXECUTED
int rc = RC_OK;
msdos_fs_info_t *fs_info = mt_entry->fs_info;
ffc1ba70: 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);
ffc1ba74: 4b ff 83 69 bl ffc13ddc <fat_file_open> <== NOT EXECUTED
if (rc != RC_OK)
ffc1ba78: 7c 78 1b 79 mr. r24,r3 <== NOT EXECUTED
ffc1ba7c: 40 a2 02 28 bne+ ffc1bca4 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x264><== NOT EXECUTED
return rc;
fat_fd->cln = cln;
ffc1ba80: 80 81 00 08 lwz r4,8(r1) <== NOT EXECUTED
fat_fd->fat_file_type = FAT_DIRECTORY;
fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
ffc1ba84: 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;
ffc1ba88: 3b a0 00 01 li r29,1 <== NOT EXECUTED
fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
fat_fd->map.file_cln = 0;
ffc1ba8c: 93 04 00 34 stw r24,52(r4) <== NOT EXECUTED
fat_fd->map.disk_cln = fat_fd->cln;
rc = fat_file_size(mt_entry, fat_fd);
ffc1ba90: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
*/
rc = fat_file_open(mt_entry, dir_pos, &fat_fd);
if (rc != RC_OK)
return rc;
fat_fd->cln = cln;
ffc1ba94: 93 44 00 1c stw r26,28(r4) <== NOT EXECUTED
fat_fd->fat_file_type = FAT_DIRECTORY;
ffc1ba98: 93 a4 00 10 stw r29,16(r4) <== NOT EXECUTED
fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
ffc1ba9c: 90 04 00 14 stw r0,20(r4) <== NOT EXECUTED
fat_fd->map.file_cln = 0;
fat_fd->map.disk_cln = fat_fd->cln;
ffc1baa0: 93 44 00 38 stw r26,56(r4) <== NOT EXECUTED
rc = fat_file_size(mt_entry, fat_fd);
ffc1baa4: 4b ff 8e 31 bl ffc148d4 <fat_file_size> <== NOT EXECUTED
if (rc != RC_OK)
ffc1baa8: 7c 78 1b 79 mr. r24,r3 <== NOT EXECUTED
ffc1baac: 40 82 00 5c bne- ffc1bb08 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0xc8><== 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);
ffc1bab0: 3f 40 ff c3 lis r26,-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);
ffc1bab4: 38 80 00 00 li r4,0 <== NOT EXECUTED
ffc1bab8: 38 a0 00 20 li r5,32 <== NOT EXECUTED
msdos_long_to_short(".", 1, dot_node, MSDOS_SHORT_NAME_LEN);
ffc1babc: 3b 5a db 02 addi r26,r26,-9470 <== 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);
ffc1bac0: 38 61 00 2c addi r3,r1,44 <== NOT EXECUTED
ffc1bac4: 48 00 36 2d bl ffc1f0f0 <memset> <== NOT EXECUTED
msdos_long_to_short(".", 1, dot_node, MSDOS_SHORT_NAME_LEN);
ffc1bac8: 38 80 00 01 li r4,1 <== NOT EXECUTED
ffc1bacc: 38 a1 00 2c addi r5,r1,44 <== NOT EXECUTED
ffc1bad0: 38 c0 00 0b li r6,11 <== NOT EXECUTED
ffc1bad4: 7f 43 d3 78 mr r3,r26 <== NOT EXECUTED
ffc1bad8: 4b ff ee 61 bl ffc1a938 <msdos_long_to_short> <== NOT EXECUTED
rc = msdos_find_name_in_fat_file(mt_entry, fat_fd, false, ".", 1,
ffc1badc: 80 81 00 08 lwz r4,8(r1) <== NOT EXECUTED
ffc1bae0: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc1bae4: 38 a0 00 00 li r5,0 <== NOT EXECUTED
ffc1bae8: 7f 46 d3 78 mr r6,r26 <== NOT EXECUTED
ffc1baec: 38 e0 00 01 li r7,1 <== NOT EXECUTED
ffc1baf0: 39 00 00 01 li r8,1 <== NOT EXECUTED
ffc1baf4: 7f c9 f3 78 mr r9,r30 <== NOT EXECUTED
ffc1baf8: 39 41 00 2c addi r10,r1,44 <== NOT EXECUTED
ffc1bafc: 4b ff f5 91 bl ffc1b08c <msdos_find_name_in_fat_file> <== NOT EXECUTED
MSDOS_NAME_SHORT, dir_pos, dot_node);
if (rc != RC_OK)
ffc1bb00: 7c 78 1b 79 mr. r24,r3 <== NOT EXECUTED
ffc1bb04: 41 a2 00 10 beq+ ffc1bb14 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0xd4><== NOT EXECUTED
{
fat_file_close(mt_entry, fat_fd);
ffc1bb08: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc1bb0c: 80 81 00 08 lwz r4,8(r1) <== NOT EXECUTED
ffc1bb10: 48 00 01 84 b ffc1bc94 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x254><== 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);
ffc1bb14: 3f 40 ff c3 lis r26,-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);
ffc1bb18: 38 80 00 00 li r4,0 <== NOT EXECUTED
ffc1bb1c: 38 a0 00 20 li r5,32 <== NOT EXECUTED
msdos_long_to_short("..", 2, dotdot_node, MSDOS_SHORT_NAME_LEN);
ffc1bb20: 3b 5a db 01 addi r26,r26,-9471 <== 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);
ffc1bb24: 38 61 00 0c addi r3,r1,12 <== NOT EXECUTED
ffc1bb28: 48 00 35 c9 bl ffc1f0f0 <memset> <== NOT EXECUTED
msdos_long_to_short("..", 2, dotdot_node, MSDOS_SHORT_NAME_LEN);
ffc1bb2c: 38 80 00 02 li r4,2 <== NOT EXECUTED
ffc1bb30: 38 a1 00 0c addi r5,r1,12 <== NOT EXECUTED
ffc1bb34: 38 c0 00 0b li r6,11 <== NOT EXECUTED
ffc1bb38: 7f 43 d3 78 mr r3,r26 <== NOT EXECUTED
ffc1bb3c: 4b ff ed fd bl ffc1a938 <msdos_long_to_short> <== NOT EXECUTED
rc = msdos_find_name_in_fat_file(mt_entry, fat_fd, false, "..", 2,
ffc1bb40: 80 81 00 08 lwz r4,8(r1) <== NOT EXECUTED
ffc1bb44: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc1bb48: 38 a0 00 00 li r5,0 <== NOT EXECUTED
ffc1bb4c: 7f 46 d3 78 mr r6,r26 <== NOT EXECUTED
ffc1bb50: 38 e0 00 02 li r7,2 <== NOT EXECUTED
ffc1bb54: 39 00 00 01 li r8,1 <== NOT EXECUTED
ffc1bb58: 7f c9 f3 78 mr r9,r30 <== NOT EXECUTED
ffc1bb5c: 39 41 00 0c addi r10,r1,12 <== NOT EXECUTED
ffc1bb60: 4b ff f5 2d bl ffc1b08c <msdos_find_name_in_fat_file> <== NOT EXECUTED
ffc1bb64: 80 81 00 08 lwz r4,8(r1) <== NOT EXECUTED
MSDOS_NAME_SHORT, dir_pos,
dotdot_node);
if (rc != RC_OK)
ffc1bb68: 7c 78 1b 79 mr. r24,r3 <== NOT EXECUTED
ffc1bb6c: 40 82 00 e0 bne- ffc1bc4c <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x20c><== NOT EXECUTED
}
cl4find = MSDOS_EXTRACT_CLUSTER_NUM(dot_node);
/* close fat-file corresponded to ".." directory */
rc = fat_file_close(mt_entry, fat_fd);
ffc1bb70: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
{
fat_file_close(mt_entry, fat_fd);
return rc;
}
cl4find = MSDOS_EXTRACT_CLUSTER_NUM(dot_node);
ffc1bb74: a3 41 00 46 lhz r26,70(r1) <== NOT EXECUTED
ffc1bb78: a3 21 00 40 lhz r25,64(r1) <== NOT EXECUTED
/* close fat-file corresponded to ".." directory */
rc = fat_file_close(mt_entry, fat_fd);
ffc1bb7c: 4b ff 86 89 bl ffc14204 <fat_file_close> <== NOT EXECUTED
if ( rc != RC_OK )
ffc1bb80: 7c 78 1b 79 mr. r24,r3 <== NOT EXECUTED
ffc1bb84: 40 82 01 20 bne- ffc1bca4 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x264><== NOT EXECUTED
return rc;
if ( (MSDOS_EXTRACT_CLUSTER_NUM(dotdot_node)) == 0)
ffc1bb88: a1 41 00 20 lhz r10,32(r1) <== NOT EXECUTED
ffc1bb8c: a1 61 00 26 lhz r11,38(r1) <== NOT EXECUTED
ffc1bb90: 55 49 c2 3e rlwinm r9,r10,24,8,31 <== NOT EXECUTED
ffc1bb94: 55 4a 44 2e rlwinm r10,r10,8,16,23 <== NOT EXECUTED
ffc1bb98: 55 60 c2 3e rlwinm r0,r11,24,8,31 <== NOT EXECUTED
ffc1bb9c: 7d 29 53 78 or r9,r9,r10 <== NOT EXECUTED
ffc1bba0: 55 6b 44 2e rlwinm r11,r11,8,16,23 <== NOT EXECUTED
ffc1bba4: 55 29 80 1e rlwinm r9,r9,16,0,15 <== NOT EXECUTED
ffc1bba8: 7c 00 5b 78 or r0,r0,r11 <== NOT EXECUTED
ffc1bbac: 7d 20 03 79 or. r0,r9,r0 <== NOT EXECUTED
ffc1bbb0: 40 82 00 18 bne- ffc1bbc8 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x188><== NOT EXECUTED
fat_dir_pos_init(
fat_dir_pos_t *dir_pos
)
{
dir_pos->sname.cln = 0;
dir_pos->sname.ofs = 0;
ffc1bbb4: 90 1e 00 04 stw r0,4(r30) <== NOT EXECUTED
dir_pos->lname.cln = FAT_FILE_SHORT_NAME;
ffc1bbb8: 38 00 ff ff li r0,-1 <== NOT EXECUTED
ffc1bbbc: 90 1e 00 08 stw r0,8(r30) <== NOT EXECUTED
dir_pos->lname.ofs = FAT_FILE_SHORT_NAME;
ffc1bbc0: 90 1e 00 0c stw r0,12(r30) <== 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;
ffc1bbc4: 93 be 00 00 stw r29,0(r30) <== NOT EXECUTED
}
/* open fat-file corresponded to second ".." */
rc = fat_file_open(mt_entry, dir_pos, &fat_fd);
ffc1bbc8: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc1bbcc: 7f c4 f3 78 mr r4,r30 <== NOT EXECUTED
ffc1bbd0: 38 a1 00 08 addi r5,r1,8 <== NOT EXECUTED
ffc1bbd4: 4b ff 82 09 bl ffc13ddc <fat_file_open> <== NOT EXECUTED
if (rc != RC_OK)
ffc1bbd8: 7c 78 1b 79 mr. r24,r3 <== NOT EXECUTED
ffc1bbdc: 40 82 00 c8 bne- ffc1bca4 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x264><== NOT EXECUTED
return rc;
if ((MSDOS_EXTRACT_CLUSTER_NUM(dotdot_node)) == 0)
ffc1bbe0: a1 41 00 20 lhz r10,32(r1) <== NOT EXECUTED
ffc1bbe4: a1 61 00 26 lhz r11,38(r1) <== NOT EXECUTED
ffc1bbe8: 55 49 c2 3e rlwinm r9,r10,24,8,31 <== NOT EXECUTED
ffc1bbec: 80 81 00 08 lwz r4,8(r1) <== NOT EXECUTED
ffc1bbf0: 55 4a 44 2e rlwinm r10,r10,8,16,23 <== NOT EXECUTED
ffc1bbf4: 55 60 c2 3e rlwinm r0,r11,24,8,31 <== NOT EXECUTED
ffc1bbf8: 7d 29 53 78 or r9,r9,r10 <== NOT EXECUTED
ffc1bbfc: 55 6b 44 2e rlwinm r11,r11,8,16,23 <== NOT EXECUTED
ffc1bc00: 55 29 80 1e rlwinm r9,r9,16,0,15 <== NOT EXECUTED
ffc1bc04: 7c 00 5b 78 or r0,r0,r11 <== NOT EXECUTED
ffc1bc08: 7d 20 03 79 or. r0,r9,r0 <== NOT EXECUTED
ffc1bc0c: 40 82 00 08 bne- ffc1bc14 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x1d4><== NOT EXECUTED
fat_fd->cln = fs_info->fat.vol.rdir_cl;
ffc1bc10: 80 1b 00 38 lwz r0,56(r27) <== NOT EXECUTED
else
fat_fd->cln = MSDOS_EXTRACT_CLUSTER_NUM(dotdot_node);
ffc1bc14: 90 04 00 1c stw r0,28(r4) <== NOT EXECUTED
fat_fd->fat_file_type = FAT_DIRECTORY;
ffc1bc18: 38 00 00 01 li r0,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;
rc = fat_file_size(mt_entry, fat_fd);
ffc1bc1c: 7f e3 fb 78 mr r3,r31 <== 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;
ffc1bc20: 90 04 00 10 stw r0,16(r4) <== NOT EXECUTED
fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
ffc1bc24: 3c 00 00 20 lis r0,32 <== NOT EXECUTED
ffc1bc28: 90 04 00 14 stw r0,20(r4) <== NOT EXECUTED
fat_fd->map.file_cln = 0;
ffc1bc2c: 38 00 00 00 li r0,0 <== NOT EXECUTED
ffc1bc30: 90 04 00 34 stw r0,52(r4) <== NOT EXECUTED
fat_fd->map.disk_cln = fat_fd->cln;
ffc1bc34: 80 04 00 1c lwz r0,28(r4) <== NOT EXECUTED
ffc1bc38: 90 04 00 38 stw r0,56(r4) <== NOT EXECUTED
rc = fat_file_size(mt_entry, fat_fd);
ffc1bc3c: 4b ff 8c 99 bl ffc148d4 <fat_file_size> <== NOT EXECUTED
ffc1bc40: 80 81 00 08 lwz r4,8(r1) <== NOT EXECUTED
if (rc != RC_OK)
ffc1bc44: 7c 78 1b 79 mr. r24,r3 <== NOT EXECUTED
ffc1bc48: 41 a2 00 0c beq+ ffc1bc54 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x214><== NOT EXECUTED
{
fat_file_close(mt_entry, fat_fd);
ffc1bc4c: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc1bc50: 48 00 00 44 b ffc1bc94 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x254><== NOT EXECUTED
{
fat_file_close(mt_entry, fat_fd);
return rc;
}
cl4find = MSDOS_EXTRACT_CLUSTER_NUM(dot_node);
ffc1bc54: 57 25 c2 3e rlwinm r5,r25,24,8,31 <== NOT EXECUTED
ffc1bc58: 57 39 44 2e rlwinm r25,r25,8,16,23 <== NOT EXECUTED
ffc1bc5c: 57 40 c2 3e rlwinm r0,r26,24,8,31 <== NOT EXECUTED
ffc1bc60: 7c a5 cb 78 or r5,r5,r25 <== NOT EXECUTED
ffc1bc64: 57 5a 44 2e rlwinm r26,r26,8,16,23 <== NOT EXECUTED
ffc1bc68: 7c 1a d3 78 or r26,r0,r26 <== NOT EXECUTED
ffc1bc6c: 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,
ffc1bc70: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc1bc74: 7c a5 d3 78 or r5,r5,r26 <== NOT EXECUTED
ffc1bc78: 7f c6 f3 78 mr r6,r30 <== NOT EXECUTED
ffc1bc7c: 7f 87 e3 78 mr r7,r28 <== NOT EXECUTED
ffc1bc80: 4b ff fc 4d bl ffc1b8cc <msdos_find_node_by_cluster_num_in_fat_file><== NOT EXECUTED
ffc1bc84: 80 81 00 08 lwz r4,8(r1) <== NOT EXECUTED
dir_pos, dir_entry);
if (rc != RC_OK)
ffc1bc88: 7c 78 1b 79 mr. r24,r3 <== NOT EXECUTED
{
fat_file_close(mt_entry, fat_fd);
ffc1bc8c: 7f e3 fb 78 mr r3,r31 <== 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)
ffc1bc90: 41 a2 00 0c beq+ ffc1bc9c <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x25c><== NOT EXECUTED
{
fat_file_close(mt_entry, fat_fd);
ffc1bc94: 4b ff 85 71 bl ffc14204 <fat_file_close> <== NOT EXECUTED
return rc;
ffc1bc98: 48 00 00 0c b ffc1bca4 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x264><== NOT EXECUTED
}
rc = fat_file_close(mt_entry, fat_fd);
ffc1bc9c: 4b ff 85 69 bl ffc14204 <fat_file_close> <== NOT EXECUTED
ffc1bca0: 7c 78 1b 78 mr r24,r3 <== NOT EXECUTED
return rc;
}
ffc1bca4: 39 61 00 78 addi r11,r1,120 <== NOT EXECUTED
ffc1bca8: 7f 03 c3 78 mr r3,r24 <== NOT EXECUTED
ffc1bcac: 4b fe 6e 30 b ffc02adc <_restgpr_24_x> <== NOT EXECUTED
ffc1bcb0 <msdos_get_name_node>:
int name_len,
msdos_name_type_t name_type,
fat_dir_pos_t *dir_pos,
char *name_dir_entry
)
{
ffc1bcb0: 94 21 ff e0 stwu r1,-32(r1)
ffc1bcb4: 7c 08 02 a6 mflr r0
ffc1bcb8: 7c cb 33 78 mr r11,r6
ffc1bcbc: 90 01 00 24 stw r0,36(r1)
ffc1bcc0: 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,
ffc1bcc4: 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
)
{
ffc1bcc8: bf 41 00 08 stmw r26,8(r1)
ffc1bccc: 7c 7d 1b 78 mr r29,r3
ffc1bcd0: 7c 9b 23 78 mr r27,r4
ffc1bcd4: 7c bc 2b 78 mr r28,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,
ffc1bcd8: 80 63 00 10 lwz r3,16(r3)
int name_len,
msdos_name_type_t name_type,
fat_dir_pos_t *dir_pos,
char *name_dir_entry
)
{
ffc1bcdc: 7d 1f 43 78 mr r31,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,
ffc1bce0: 80 9d 00 00 lwz r4,0(r29)
int name_len,
msdos_name_type_t name_type,
fat_dir_pos_t *dir_pos,
char *name_dir_entry
)
{
ffc1bce4: 7d 3e 4b 78 mr r30,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,
ffc1bce8: 7f 65 db 78 mr r5,r27
ffc1bcec: 7f 86 e3 78 mr r6,r28
ffc1bcf0: 7c 08 03 78 mr r8,r0
ffc1bcf4: 7f e9 fb 78 mr r9,r31
ffc1bcf8: 7f ca f3 78 mr r10,r30
ffc1bcfc: 4b ff f3 91 bl ffc1b08c <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))
ffc1bd00: 7c 7a 1b 79 mr. r26,r3
ffc1bd04: 41 82 00 0c beq- ffc1bd10 <msdos_get_name_node+0x60>
ffc1bd08: 2f 9a 7d 01 cmpwi cr7,r26,32001
ffc1bd0c: 40 be 00 a0 bne+ cr7,ffc1bdac <msdos_get_name_node+0xfc><== NEVER TAKEN
return rc;
if (!create_node)
ffc1bd10: 2f 9b 00 00 cmpwi cr7,r27,0
ffc1bd14: 40 9e 00 98 bne- cr7,ffc1bdac <msdos_get_name_node+0xfc>
{
/* if we search for valid name and name not found -> return */
if (rc == MSDOS_NAME_NOT_FOUND_ERR)
ffc1bd18: 2f 9a 7d 01 cmpwi cr7,r26,32001
ffc1bd1c: 41 9e 00 90 beq- cr7,ffc1bdac <msdos_get_name_node+0xfc>
* 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)
ffc1bd20: 2f 9a 00 00 cmpwi cr7,r26,0
ffc1bd24: 40 9e 00 88 bne- cr7,ffc1bdac <msdos_get_name_node+0xfc><== NEVER TAKEN
{
if (strncmp(name, "..", 2) == 0)
ffc1bd28: 3c 80 ff c3 lis r4,-61
ffc1bd2c: 7f 83 e3 78 mr r3,r28
ffc1bd30: 38 84 db 01 addi r4,r4,-9471
ffc1bd34: 38 a0 00 02 li r5,2
ffc1bd38: 48 00 40 d9 bl ffc1fe10 <strncmp>
ffc1bd3c: 2f 83 00 00 cmpwi cr7,r3,0
ffc1bd40: 40 9e 00 6c bne- cr7,ffc1bdac <msdos_get_name_node+0xfc>
{
dotdot_cln = MSDOS_EXTRACT_CLUSTER_NUM((name_dir_entry));
ffc1bd44: a1 7e 00 14 lhz r11,20(r30)
ffc1bd48: a1 3e 00 1a lhz r9,26(r30)
ffc1bd4c: 55 60 c2 3e rlwinm r0,r11,24,8,31
ffc1bd50: 55 6b 44 2e rlwinm r11,r11,8,16,23
ffc1bd54: 55 24 c2 3e rlwinm r4,r9,24,8,31
ffc1bd58: 7c 00 5b 78 or r0,r0,r11
ffc1bd5c: 55 29 44 2e rlwinm r9,r9,8,16,23
ffc1bd60: 54 00 80 1e rlwinm r0,r0,16,0,15
ffc1bd64: 7c 84 4b 78 or r4,r4,r9
/* are we right under root dir ? */
if (dotdot_cln == 0)
ffc1bd68: 7c 04 23 79 or. r4,r0,r4
ffc1bd6c: 40 82 00 20 bne- ffc1bd8c <msdos_get_name_node+0xdc> <== 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;
ffc1bd70: 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;
ffc1bd74: 93 5f 00 04 stw r26,4(r31)
dir_pos->lname.cln = FAT_FILE_SHORT_NAME;
ffc1bd78: 90 1f 00 08 stw r0,8(r31)
dir_pos->lname.ofs = FAT_FILE_SHORT_NAME;
ffc1bd7c: 90 1f 00 0c stw r0,12(r31)
/*
* 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;
ffc1bd80: 38 00 00 01 li r0,1
ffc1bd84: 90 1f 00 00 stw r0,0(r31)
ffc1bd88: 48 00 00 24 b ffc1bdac <msdos_get_name_node+0xfc>
}
}
}
}
return rc;
}
ffc1bd8c: 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 =
ffc1bd90: 7f e5 fb 78 mr r5,r31 <== NOT EXECUTED
ffc1bd94: 80 7d 00 10 lwz r3,16(r29) <== NOT EXECUTED
ffc1bd98: 7f c6 f3 78 mr r6,r30 <== NOT EXECUTED
}
}
}
}
return rc;
}
ffc1bd9c: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
ffc1bda0: bb 41 00 08 lmw r26,8(r1) <== NOT EXECUTED
ffc1bda4: 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 =
ffc1bda8: 4b ff fc 98 b ffc1ba40 <msdos_get_dotdot_dir_info_cluster_num_and_offset><== NOT EXECUTED
}
}
}
}
return rc;
}
ffc1bdac: 39 61 00 20 addi r11,r1,32
ffc1bdb0: 7f 43 d3 78 mr r3,r26
ffc1bdb4: 4b fe 6d 30 b ffc02ae4 <_restgpr_26_x>
ffc1aaf4 <msdos_get_token>:
msdos_token_types_t
msdos_get_token(const char *path,
int pathlen,
const char **ret_token,
int *ret_token_len)
{
ffc1aaf4: 94 21 ff e0 stwu r1,-32(r1)
ffc1aaf8: 7c 08 02 a6 mflr r0
ffc1aafc: bf 61 00 0c stmw r27,12(r1)
int i = 0;
*ret_token = NULL;
*ret_token_len = 0;
if (pathlen == 0)
ffc1ab00: 7c 9b 23 79 mr. r27,r4
msdos_token_types_t
msdos_get_token(const char *path,
int pathlen,
const char **ret_token,
int *ret_token_len)
{
ffc1ab04: 7c 7f 1b 78 mr r31,r3
ffc1ab08: 90 01 00 24 stw r0,36(r1)
msdos_token_types_t type = MSDOS_NAME;
int i = 0;
*ret_token = NULL;
ffc1ab0c: 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)
{
ffc1ab10: 7c be 2b 78 mr r30,r5
msdos_token_types_t type = MSDOS_NAME;
int i = 0;
*ret_token = NULL;
ffc1ab14: 90 05 00 00 stw r0,0(r5)
msdos_token_types_t
msdos_get_token(const char *path,
int pathlen,
const char **ret_token,
int *ret_token_len)
{
ffc1ab18: 7c dd 33 78 mr r29,r6
*ret_token = NULL;
*ret_token_len = 0;
if (pathlen == 0)
return MSDOS_NO_MORE_PATH;
ffc1ab1c: 38 60 00 00 li r3,0
{
msdos_token_types_t type = MSDOS_NAME;
int i = 0;
*ret_token = NULL;
*ret_token_len = 0;
ffc1ab20: 90 06 00 00 stw r0,0(r6)
if (pathlen == 0)
ffc1ab24: 3b 80 00 00 li r28,0
ffc1ab28: 40 a2 00 24 bne+ ffc1ab4c <msdos_get_token+0x58>
ffc1ab2c: 48 00 00 c0 b ffc1abec <msdos_get_token+0xf8>
/*
* Check for a separator.
*/
while (!msdos_is_separator(path[i]) && (i < pathlen))
{
if ( !msdos_is_valid_name_char(path[i]) )
ffc1ab30: 7c 7f e0 ae lbzx r3,r31,r28
ffc1ab34: 4b ff fd 85 bl ffc1a8b8 <msdos_is_valid_name_char>
ffc1ab38: 2f 83 00 00 cmpwi cr7,r3,0
ffc1ab3c: 41 9e 00 9c beq- cr7,ffc1abd8 <msdos_get_token+0xe4> <== NEVER TAKEN
return MSDOS_INVALID_TOKEN;
++i;
if ( i == MSDOS_NAME_MAX_LFN_WITH_DOT )
ffc1ab40: 2f 9c 01 03 cmpwi cr7,r28,259
ffc1ab44: 3b 9c 00 01 addi r28,r28,1
ffc1ab48: 41 9e 00 90 beq- cr7,ffc1abd8 <msdos_get_token+0xe4> <== NEVER TAKEN
return MSDOS_NO_MORE_PATH;
/*
* Check for a separator.
*/
while (!msdos_is_separator(path[i]) && (i < pathlen))
ffc1ab4c: 7c 7f e0 ae lbzx r3,r31,r28
ffc1ab50: 4b fe e6 a5 bl ffc091f4 <rtems_filesystem_is_separator>
ffc1ab54: 2f 83 00 00 cmpwi cr7,r3,0
ffc1ab58: 40 9e 00 0c bne- cr7,ffc1ab64 <msdos_get_token+0x70>
ffc1ab5c: 7f 9c d8 00 cmpw cr7,r28,r27
ffc1ab60: 41 9c ff d0 blt+ cr7,ffc1ab30 <msdos_get_token+0x3c>
*ret_token = path;
/*
* If it is just a separator then it is the current dir.
*/
if ( i == 0 )
ffc1ab64: 2f 9c 00 00 cmpwi cr7,r28,0
++i;
if ( i == MSDOS_NAME_MAX_LFN_WITH_DOT )
return MSDOS_INVALID_TOKEN;
}
*ret_token = path;
ffc1ab68: 93 fe 00 00 stw r31,0(r30)
msdos_get_token(const char *path,
int pathlen,
const char **ret_token,
int *ret_token_len)
{
msdos_token_types_t type = MSDOS_NAME;
ffc1ab6c: 38 60 00 03 li r3,3
*ret_token = path;
/*
* If it is just a separator then it is the current dir.
*/
if ( i == 0 )
ffc1ab70: 40 9e 00 20 bne- cr7,ffc1ab90 <msdos_get_token+0x9c>
{
if ( (*path != '\0') && pathlen )
ffc1ab74: 88 1f 00 00 lbz r0,0(r31)
{
i++;
ffc1ab78: 3b 80 00 01 li r28,1
type = MSDOS_CURRENT_DIR;
ffc1ab7c: 38 60 00 01 li r3,1
/*
* If it is just a separator then it is the current dir.
*/
if ( i == 0 )
{
if ( (*path != '\0') && pathlen )
ffc1ab80: 2f 80 00 00 cmpwi cr7,r0,0
ffc1ab84: 40 9e 00 0c bne- cr7,ffc1ab90 <msdos_get_token+0x9c>
ffc1ab88: 3b 80 00 00 li r28,0
{
i++;
type = MSDOS_CURRENT_DIR;
}
else
type = MSDOS_NO_MORE_PATH;
ffc1ab8c: 38 60 00 00 li r3,0
/*
* If we copied something that was not a seperator see if
* it was a special name.
*/
if ( type == MSDOS_NAME )
ffc1ab90: 2f 83 00 03 cmpwi cr7,r3,3
}
/*
* Set the token and token_len to the token start and length.
*/
*ret_token_len = i;
ffc1ab94: 93 9d 00 00 stw r28,0(r29)
/*
* If we copied something that was not a seperator see if
* it was a special name.
*/
if ( type == MSDOS_NAME )
ffc1ab98: 40 be 00 54 bne+ cr7,ffc1abec <msdos_get_token+0xf8>
{
if ((i == 2) && ((*ret_token)[0] == '.') && ((*ret_token)[1] == '.'))
ffc1ab9c: 2f 9c 00 02 cmpwi cr7,r28,2
ffc1aba0: 40 be 00 20 bne+ cr7,ffc1abc0 <msdos_get_token+0xcc>
ffc1aba4: 88 1f 00 00 lbz r0,0(r31)
ffc1aba8: 2f 80 00 2e cmpwi cr7,r0,46
ffc1abac: 40 be 00 40 bne+ cr7,ffc1abec <msdos_get_token+0xf8> <== NEVER TAKEN
ffc1abb0: 88 1f 00 01 lbz r0,1(r31)
ffc1abb4: 2f 80 00 2e cmpwi cr7,r0,46
ffc1abb8: 40 be 00 34 bne+ cr7,ffc1abec <msdos_get_token+0xf8> <== NEVER TAKEN
ffc1abbc: 48 00 00 24 b ffc1abe0 <msdos_get_token+0xec>
{
type = MSDOS_UP_DIR;
return type;
}
if ((i == 1) && ((*ret_token)[0] == '.'))
ffc1abc0: 2f 9c 00 01 cmpwi cr7,r28,1
ffc1abc4: 40 be 00 28 bne+ cr7,ffc1abec <msdos_get_token+0xf8>
ffc1abc8: 88 1f 00 00 lbz r0,0(r31)
ffc1abcc: 2f 80 00 2e cmpwi cr7,r0,46
ffc1abd0: 40 be 00 1c bne+ cr7,ffc1abec <msdos_get_token+0xf8> <== NEVER TAKEN
ffc1abd4: 48 00 00 14 b ffc1abe8 <msdos_get_token+0xf4>
{
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;
ffc1abd8: 38 60 00 04 li r3,4 <== NOT EXECUTED
ffc1abdc: 48 00 00 10 b ffc1abec <msdos_get_token+0xf8> <== NOT EXECUTED
if ( type == MSDOS_NAME )
{
if ((i == 2) && ((*ret_token)[0] == '.') && ((*ret_token)[1] == '.'))
{
type = MSDOS_UP_DIR;
return type;
ffc1abe0: 38 60 00 02 li r3,2
ffc1abe4: 48 00 00 08 b ffc1abec <msdos_get_token+0xf8>
}
if ((i == 1) && ((*ret_token)[0] == '.'))
{
type = MSDOS_CURRENT_DIR;
return type;
ffc1abe8: 38 60 00 01 li r3,1
}
}
return type;
}
ffc1abec: 39 61 00 20 addi r11,r1,32
ffc1abf0: 4b fe 7e f8 b ffc02ae8 <_restgpr_27_x>
ffc10aa0 <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
)
{
ffc10aa0: 94 21 ff c0 stwu r1,-64(r1)
ffc10aa4: 7c 08 02 a6 mflr r0
ffc10aa8: bf 41 00 28 stmw r26,40(r1)
ffc10aac: 7c 7e 1b 78 mr r30,r3
ffc10ab0: 7c 9b 23 78 mr r27,r4
ffc10ab4: 90 01 00 44 stw r0,68(r1)
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));
ffc10ab8: 38 60 00 01 li r3,1
)
{
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = NULL;
fat_file_fd_t *fat_fd = NULL;
ffc10abc: 38 00 00 00 li r0,0
fat_dir_pos_t root_pos;
uint32_t cl_buf_size;
fs_info = (msdos_fs_info_t *)calloc(1, sizeof(msdos_fs_info_t));
ffc10ac0: 38 80 00 a0 li r4,160
)
{
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = NULL;
fat_file_fd_t *fat_fd = NULL;
ffc10ac4: 90 01 00 08 stw r0,8(r1)
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
)
{
ffc10ac8: 7c ba 2b 78 mr r26,r5
ffc10acc: 7c dc 33 78 mr r28,r6
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));
ffc10ad0: 4b ff 69 09 bl ffc073d8 <calloc>
if (!fs_info)
ffc10ad4: 7c 7f 1b 79 mr. r31,r3
ffc10ad8: 41 82 01 10 beq- ffc10be8 <msdos_initialize_support+0x148><== NEVER TAKEN
rtems_set_errno_and_return_minus_one(ENOMEM);
temp_mt_entry->fs_info = fs_info;
ffc10adc: 93 fe 00 34 stw r31,52(r30)
rc = fat_init_volume_info(temp_mt_entry);
ffc10ae0: 7f c3 f3 78 mr r3,r30
ffc10ae4: 48 00 47 95 bl ffc15278 <fat_init_volume_info>
if (rc != RC_OK)
ffc10ae8: 7c 7d 1b 79 mr. r29,r3
ffc10aec: 40 82 00 44 bne- ffc10b30 <msdos_initialize_support+0x90><== NEVER TAKEN
{
free(fs_info);
return rc;
}
fs_info->file_handlers = file_handlers;
ffc10af0: 93 5f 00 94 stw r26,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;
ffc10af4: 7c 24 0b 78 mr r4,r1
ffc10af8: 3b 40 00 01 li r26,1
free(fs_info);
return rc;
}
fs_info->file_handlers = file_handlers;
fs_info->directory_handlers = directory_handlers;
ffc10afc: 93 9f 00 90 stw r28,144(r31)
fat_dir_pos_t *dir_pos
)
{
dir_pos->sname.cln = 0;
dir_pos->sname.ofs = 0;
dir_pos->lname.cln = FAT_FILE_SHORT_NAME;
ffc10b00: 38 00 ff ff li r0,-1
* 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);
ffc10b04: 7f c3 f3 78 mr r3,r30
/*
* 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;
ffc10b08: 97 44 00 0c stwu r26,12(r4)
rc = fat_file_open(temp_mt_entry, &root_pos, &fat_fd);
ffc10b0c: 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;
ffc10b10: 93 a1 00 10 stw r29,16(r1)
dir_pos->lname.cln = FAT_FILE_SHORT_NAME;
ffc10b14: 90 01 00 14 stw r0,20(r1)
dir_pos->lname.ofs = FAT_FILE_SHORT_NAME;
ffc10b18: 90 01 00 18 stw r0,24(r1)
ffc10b1c: 48 00 32 c1 bl ffc13ddc <fat_file_open>
if (rc != RC_OK)
ffc10b20: 7c 7d 1b 79 mr. r29,r3
ffc10b24: 41 a2 00 18 beq+ ffc10b3c <msdos_initialize_support+0x9c><== ALWAYS TAKEN
{
fat_shutdown_drive(temp_mt_entry);
ffc10b28: 7f c3 f3 78 mr r3,r30 <== NOT EXECUTED
ffc10b2c: 48 00 46 49 bl ffc15174 <fat_shutdown_drive> <== NOT EXECUTED
free(fs_info);
ffc10b30: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc10b34: 4b ff 6d b5 bl ffc078e8 <free> <== NOT EXECUTED
return rc;
ffc10b38: 48 00 01 20 b ffc10c58 <msdos_initialize_support+0x1b8><== NOT EXECUTED
}
/* again: unfortunately "fat-file" is just almost fat file :( */
fat_fd->fat_file_type = FAT_DIRECTORY;
ffc10b3c: 80 81 00 08 lwz r4,8(r1)
fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
ffc10b40: 3c 00 00 20 lis r0,32
ffc10b44: 90 04 00 14 stw r0,20(r4)
fat_fd->cln = fs_info->fat.vol.rdir_cl;
ffc10b48: 80 1f 00 38 lwz r0,56(r31)
free(fs_info);
return rc;
}
/* again: unfortunately "fat-file" is just almost fat file :( */
fat_fd->fat_file_type = FAT_DIRECTORY;
ffc10b4c: 93 44 00 10 stw r26,16(r4)
fat_fd->map.file_cln = 0;
fat_fd->map.disk_cln = fat_fd->cln;
/* if we have FAT12/16 */
if ( fat_fd->cln == 0 )
ffc10b50: 2f 80 00 00 cmpwi cr7,r0,0
}
/* 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;
ffc10b54: 90 04 00 1c stw r0,28(r4)
fat_fd->map.file_cln = 0;
ffc10b58: 93 a4 00 34 stw r29,52(r4)
fat_fd->map.disk_cln = fat_fd->cln;
ffc10b5c: 90 04 00 38 stw r0,56(r4)
/* if we have FAT12/16 */
if ( fat_fd->cln == 0 )
ffc10b60: 40 9e 00 20 bne- cr7,ffc10b80 <msdos_initialize_support+0xe0><== NEVER TAKEN
{
fat_fd->fat_file_size = fs_info->fat.vol.rdir_size;
ffc10b64: 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 :
ffc10b68: 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;
ffc10b6c: 90 04 00 18 stw r0,24(r4)
cl_buf_size = (fs_info->fat.vol.bpc > fs_info->fat.vol.rdir_size) ?
ffc10b70: 7f 83 00 40 cmplw cr7,r3,r0
ffc10b74: 40 9c 00 44 bge- cr7,ffc10bb8 <msdos_initialize_support+0x118><== NEVER TAKEN
ffc10b78: 7c 03 03 78 mr r3,r0
ffc10b7c: 48 00 00 3c b ffc10bb8 <msdos_initialize_support+0x118>
fs_info->fat.vol.bpc :
fs_info->fat.vol.rdir_size;
}
else
{
rc = fat_file_size(temp_mt_entry, fat_fd);
ffc10b80: 7f c3 f3 78 mr r3,r30 <== NOT EXECUTED
ffc10b84: 48 00 3d 51 bl ffc148d4 <fat_file_size> <== NOT EXECUTED
if ( rc != RC_OK )
ffc10b88: 7c 7a 1b 79 mr. r26,r3 <== NOT EXECUTED
ffc10b8c: 41 a2 00 28 beq+ ffc10bb4 <msdos_initialize_support+0x114><== NOT EXECUTED
{
fat_file_close(temp_mt_entry, fat_fd);
ffc10b90: 80 81 00 08 lwz r4,8(r1) <== NOT EXECUTED
ffc10b94: 7f c3 f3 78 mr r3,r30 <== NOT EXECUTED
fat_shutdown_drive(temp_mt_entry);
free(fs_info);
return rc;
ffc10b98: 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);
ffc10b9c: 48 00 36 69 bl ffc14204 <fat_file_close> <== NOT EXECUTED
fat_shutdown_drive(temp_mt_entry);
ffc10ba0: 7f c3 f3 78 mr r3,r30 <== NOT EXECUTED
ffc10ba4: 48 00 45 d1 bl ffc15174 <fat_shutdown_drive> <== NOT EXECUTED
free(fs_info);
ffc10ba8: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc10bac: 4b ff 6d 3d bl ffc078e8 <free> <== NOT EXECUTED
return rc;
ffc10bb0: 48 00 00 a8 b ffc10c58 <msdos_initialize_support+0x1b8><== NOT EXECUTED
}
cl_buf_size = fs_info->fat.vol.bpc;
ffc10bb4: a0 7f 00 06 lhz r3,6(r31) <== NOT EXECUTED
}
fs_info->cl_buf = (uint8_t *)calloc(cl_buf_size, sizeof(char));
ffc10bb8: 38 80 00 01 li r4,1
ffc10bbc: 4b ff 68 1d bl ffc073d8 <calloc>
if (fs_info->cl_buf == NULL)
ffc10bc0: 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));
ffc10bc4: 90 7f 00 9c stw r3,156(r31)
if (fs_info->cl_buf == NULL)
ffc10bc8: 40 be 00 34 bne+ cr7,ffc10bfc <msdos_initialize_support+0x15c><== ALWAYS TAKEN
{
fat_file_close(temp_mt_entry, fat_fd);
ffc10bcc: 80 81 00 08 lwz r4,8(r1) <== NOT EXECUTED
ffc10bd0: 7f c3 f3 78 mr r3,r30 <== NOT EXECUTED
ffc10bd4: 48 00 36 31 bl ffc14204 <fat_file_close> <== NOT EXECUTED
fat_shutdown_drive(temp_mt_entry);
ffc10bd8: 7f c3 f3 78 mr r3,r30 <== NOT EXECUTED
ffc10bdc: 48 00 45 99 bl ffc15174 <fat_shutdown_drive> <== NOT EXECUTED
free(fs_info);
ffc10be0: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc10be4: 4b ff 6d 05 bl ffc078e8 <free> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(ENOMEM);
ffc10be8: 48 00 d5 f1 bl ffc1e1d8 <__errno> <== NOT EXECUTED
ffc10bec: 38 00 00 0c li r0,12 <== NOT EXECUTED
ffc10bf0: 90 03 00 00 stw r0,0(r3) <== NOT EXECUTED
ffc10bf4: 3b a0 ff ff li r29,-1 <== NOT EXECUTED
ffc10bf8: 48 00 00 60 b ffc10c58 <msdos_initialize_support+0x1b8><== NOT EXECUTED
}
sc = rtems_semaphore_create(3,
ffc10bfc: 38 80 00 01 li r4,1
ffc10c00: 38 60 00 03 li r3,3
ffc10c04: 38 a0 00 10 li r5,16
ffc10c08: 38 c0 00 00 li r6,0
ffc10c0c: 38 ff 00 98 addi r7,r31,152
ffc10c10: 4b ff ae 6d bl ffc0ba7c <rtems_semaphore_create>
ffc10c14: 80 81 00 08 lwz r4,8(r1)
1,
RTEMS_BINARY_SEMAPHORE | RTEMS_FIFO,
0,
&fs_info->vol_sema);
if (sc != RTEMS_SUCCESSFUL)
ffc10c18: 2f 83 00 00 cmpwi cr7,r3,0
ffc10c1c: 41 be 00 30 beq+ cr7,ffc10c4c <msdos_initialize_support+0x1ac><== ALWAYS TAKEN
{
fat_file_close(temp_mt_entry, fat_fd);
ffc10c20: 7f c3 f3 78 mr r3,r30 <== NOT EXECUTED
ffc10c24: 48 00 35 e1 bl ffc14204 <fat_file_close> <== NOT EXECUTED
fat_shutdown_drive(temp_mt_entry);
ffc10c28: 7f c3 f3 78 mr r3,r30 <== NOT EXECUTED
ffc10c2c: 48 00 45 49 bl ffc15174 <fat_shutdown_drive> <== NOT EXECUTED
free(fs_info->cl_buf);
ffc10c30: 80 7f 00 9c lwz r3,156(r31) <== NOT EXECUTED
ffc10c34: 4b ff 6c b5 bl ffc078e8 <free> <== NOT EXECUTED
free(fs_info);
ffc10c38: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc10c3c: 4b ff 6c ad bl ffc078e8 <free> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EIO );
ffc10c40: 48 00 d5 99 bl ffc1e1d8 <__errno> <== NOT EXECUTED
ffc10c44: 38 00 00 05 li r0,5 <== NOT EXECUTED
ffc10c48: 4b ff ff a8 b ffc10bf0 <msdos_initialize_support+0x150><== NOT EXECUTED
}
temp_mt_entry->mt_fs_root.node_access = fat_fd;
ffc10c4c: 90 9e 00 1c stw r4,28(r30)
temp_mt_entry->mt_fs_root.handlers = directory_handlers;
ffc10c50: 93 9e 00 24 stw r28,36(r30)
temp_mt_entry->mt_fs_root.ops = op_table;
ffc10c54: 93 7e 00 28 stw r27,40(r30)
return rc;
}
ffc10c58: 39 61 00 40 addi r11,r1,64
ffc10c5c: 7f a3 eb 78 mr r3,r29
ffc10c60: 4b ff 1e 84 b ffc02ae4 <_restgpr_26_x>
ffc1a8b8 <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)
{
ffc1a8b8: 7c 2b 0b 78 mr r11,r1
ffc1a8bc: 94 21 ff f0 stwu r1,-16(r1)
ffc1a8c0: 7c 08 02 a6 mflr r0
ffc1a8c4: 4b fe 81 e9 bl ffc02aac <_savegpr_31>
ffc1a8c8: 7c 7f 1b 78 mr r31,r3
if (strchr(" +,;=[]", ch) != NULL)
ffc1a8cc: 3c 60 ff c3 lis r3,-61
* MSDOS_NAME_LONG - Valid in a long name only.
*
*/
static msdos_name_type_t
msdos_is_valid_name_char(const char ch)
{
ffc1a8d0: 90 01 00 14 stw r0,20(r1)
if (strchr(" +,;=[]", ch) != NULL)
ffc1a8d4: 38 63 f3 1b addi r3,r3,-3301
ffc1a8d8: 7f e4 fb 78 mr r4,r31
ffc1a8dc: 48 00 4c cd bl ffc1f5a8 <strchr>
return MSDOS_NAME_LONG;
ffc1a8e0: 38 00 00 02 li r0,2
*
*/
static msdos_name_type_t
msdos_is_valid_name_char(const char ch)
{
if (strchr(" +,;=[]", ch) != NULL)
ffc1a8e4: 2f 83 00 00 cmpwi cr7,r3,0
ffc1a8e8: 40 be 00 44 bne+ cr7,ffc1a92c <msdos_is_valid_name_char+0x74><== NEVER TAKEN
return MSDOS_NAME_LONG;
if ((ch == '.') || isalnum((unsigned char)ch) ||
ffc1a8ec: 2f 9f 00 2e cmpwi cr7,r31,46
(strchr("$%'-_@~`!(){}^#&", ch) != NULL))
return MSDOS_NAME_SHORT;
ffc1a8f0: 38 00 00 01 li r0,1
msdos_is_valid_name_char(const char ch)
{
if (strchr(" +,;=[]", ch) != NULL)
return MSDOS_NAME_LONG;
if ((ch == '.') || isalnum((unsigned char)ch) ||
ffc1a8f4: 41 9e 00 38 beq- cr7,ffc1a92c <msdos_is_valid_name_char+0x74>
ffc1a8f8: 3d 20 00 00 lis r9,0
ffc1a8fc: 81 29 27 ec lwz r9,10220(r9)
ffc1a900: 7d 29 fa 14 add r9,r9,r31
ffc1a904: 89 29 00 01 lbz r9,1(r9)
ffc1a908: 71 2b 00 07 andi. r11,r9,7
ffc1a90c: 40 82 00 20 bne- ffc1a92c <msdos_is_valid_name_char+0x74>
(strchr("$%'-_@~`!(){}^#&", ch) != NULL))
ffc1a910: 3c 60 ff c3 lis r3,-61
ffc1a914: 38 63 f3 23 addi r3,r3,-3293
ffc1a918: 7f e4 fb 78 mr r4,r31
ffc1a91c: 48 00 4c 8d bl ffc1f5a8 <strchr>
return MSDOS_NAME_SHORT;
ffc1a920: 7c 60 00 34 cntlzw r0,r3
ffc1a924: 54 00 d9 7e rlwinm r0,r0,27,5,31
ffc1a928: 68 00 00 01 xori r0,r0,1
return MSDOS_NAME_INVALID;
}
ffc1a92c: 39 61 00 10 addi r11,r1,16
ffc1a930: 7c 03 03 78 mr r3,r0
ffc1a934: 4b fe 81 c4 b ffc02af8 <_restgpr_31_x>
ffc1a938 <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)
{
ffc1a938: 94 21 ff d0 stwu r1,-48(r1)
ffc1a93c: 7c 08 02 a6 mflr r0
ffc1a940: be e1 00 0c stmw r23,12(r1)
ffc1a944: 7c 7d 1b 78 mr r29,r3
ffc1a948: 7c 9f 23 78 mr r31,r4
int i;
/*
* Fill with spaces. This is how a short directory entry is padded.
*/
memset (sfn, ' ', sfn_len);
ffc1a94c: 7c a3 2b 78 mr r3,r5
*
*/
#define MSDOS_L2S_PRINT 0
msdos_name_type_t
msdos_long_to_short(const char *lfn, int lfn_len, char* sfn, int sfn_len)
{
ffc1a950: 90 01 00 34 stw r0,52(r1)
ffc1a954: 7c be 2b 78 mr r30,r5
int i;
/*
* Fill with spaces. This is how a short directory entry is padded.
*/
memset (sfn, ' ', sfn_len);
ffc1a958: 38 80 00 20 li r4,32
ffc1a95c: 7c c5 33 78 mr r5,r6
ffc1a960: 48 00 47 91 bl ffc1f0f0 <memset>
/*
* Handle '.' and '..' specially.
*/
if ((lfn[0] == '.') && (lfn_len == 1))
ffc1a964: 88 1d 00 00 lbz r0,0(r29)
ffc1a968: 39 20 00 00 li r9,0
ffc1a96c: 2f 80 00 2e cmpwi cr7,r0,46
ffc1a970: 40 be 00 4c bne+ cr7,ffc1a9bc <msdos_long_to_short+0x84>
ffc1a974: 2f 9f 00 01 cmpwi cr7,r31,1
ffc1a978: 41 9e 00 1c beq- cr7,ffc1a994 <msdos_long_to_short+0x5c><== 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))
ffc1a97c: 88 1d 00 01 lbz r0,1(r29)
ffc1a980: 2f 80 00 2e cmpwi cr7,r0,46
ffc1a984: 40 be 00 38 bne+ cr7,ffc1a9bc <msdos_long_to_short+0x84><== NEVER TAKEN
ffc1a988: 2f 9f 00 02 cmpwi cr7,r31,2
ffc1a98c: 40 be 00 30 bne+ cr7,ffc1a9bc <msdos_long_to_short+0x84><== NEVER TAKEN
{
sfn[0] = sfn[1] = '.';
ffc1a990: 98 1e 00 01 stb r0,1(r30)
ffc1a994: 98 1e 00 00 stb r0,0(r30)
#if MSDOS_L2S_PRINT
printf ("MSDOS_L2S: SHORT[2]: lfn:'%s' SFN:'%s'\n", lfn, sfn);
#endif
return MSDOS_NAME_SHORT;
ffc1a998: 3b 80 00 01 li r28,1
ffc1a99c: 48 00 01 34 b ffc1aad0 <msdos_long_to_short+0x198>
/*
* Filenames with only blanks and dots are not allowed!
*/
for (i = 0; i < lfn_len; i++)
if ((lfn[i] != ' ') && (lfn[i] != '.'))
ffc1a9a0: 7d 7d 48 ae lbzx r11,r29,r9
ffc1a9a4: 2f 8b 00 20 cmpwi cr7,r11,32
ffc1a9a8: 41 9e 00 0c beq- cr7,ffc1a9b4 <msdos_long_to_short+0x7c><== NEVER TAKEN
ffc1a9ac: 2f 8b 00 2e cmpwi cr7,r11,46
ffc1a9b0: 40 9e 00 d8 bne- cr7,ffc1aa88 <msdos_long_to_short+0x150><== ALWAYS TAKEN
}
/*
* Filenames with only blanks and dots are not allowed!
*/
for (i = 0; i < lfn_len; i++)
ffc1a9b4: 39 29 00 01 addi r9,r9,1 <== NOT EXECUTED
ffc1a9b8: 48 00 00 20 b ffc1a9d8 <msdos_long_to_short+0xa0> <== NOT EXECUTED
ffc1a9bc: 7f 89 f8 00 cmpw cr7,r9,r31
ffc1a9c0: 38 1f 00 01 addi r0,r31,1
ffc1a9c4: 41 9d 00 10 bgt- cr7,ffc1a9d4 <msdos_long_to_short+0x9c><== NEVER TAKEN
ffc1a9c8: 3d 60 80 00 lis r11,-32768
ffc1a9cc: 7f 9f 58 00 cmpw cr7,r31,r11
ffc1a9d0: 40 be 00 08 bne+ cr7,ffc1a9d8 <msdos_long_to_short+0xa0><== ALWAYS TAKEN
ffc1a9d4: 38 00 00 01 li r0,1 <== NOT EXECUTED
ffc1a9d8: 34 00 ff ff addic. r0,r0,-1
ffc1a9dc: 7f 89 f8 00 cmpw cr7,r9,r31
ffc1a9e0: 40 82 ff c0 bne+ ffc1a9a0 <msdos_long_to_short+0x68> <== ALWAYS TAKEN
if ((lfn[i] != ' ') && (lfn[i] != '.'))
break;
if (i == lfn_len)
ffc1a9e4: 40 be 00 a4 bne+ cr7,ffc1aa88 <msdos_long_to_short+0x150><== NOT EXECUTED
ffc1a9e8: 48 00 00 e4 b ffc1aacc <msdos_long_to_short+0x194> <== NOT EXECUTED
int count = 0;
while (*name && (count < name_len))
{
bool is_dot = *name == '.';
msdos_name_type_t type = msdos_is_valid_name_char(*name);
ffc1a9ec: 7f 23 cb 78 mr r3,r25
ffc1a9f0: 4b ff fe c9 bl ffc1a8b8 <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))
ffc1a9f4: 7c 7c 1b 79 mr. r28,r3
ffc1a9f8: 41 82 00 d8 beq- ffc1aad0 <msdos_long_to_short+0x198>
ffc1a9fc: 2f 9c 00 02 cmpwi cr7,r28,2
ffc1aa00: 41 9e 00 e0 beq- cr7,ffc1aae0 <msdos_long_to_short+0x1a8><== NEVER TAKEN
return type;
if (dot_at >= 0)
ffc1aa04: 2f 1a ff ff cmpwi cr6,r26,-1
int dot_at = -1;
int count = 0;
while (*name && (count < name_len))
{
bool is_dot = *name == '.';
ffc1aa08: 6b 20 00 2e xori r0,r25,46
ffc1aa0c: 7c 00 00 34 cntlzw r0,r0
ffc1aa10: 54 00 d9 7e rlwinm r0,r0,27,5,31
ffc1aa14: 2f 80 00 00 cmpwi cr7,r0,0
#endif
if ((type == MSDOS_NAME_INVALID) || (type == MSDOS_NAME_LONG))
return type;
if (dot_at >= 0)
ffc1aa18: 41 9a 00 18 beq- cr6,ffc1aa30 <msdos_long_to_short+0xf8><== ALWAYS TAKEN
{
if (is_dot || ((count - dot_at) > 3))
ffc1aa1c: 40 9e 00 c0 bne- cr7,ffc1aadc <msdos_long_to_short+0x1a4><== NOT EXECUTED
ffc1aa20: 7c 1a d8 50 subf r0,r26,r27 <== NOT EXECUTED
ffc1aa24: 2f 80 00 03 cmpwi cr7,r0,3 <== NOT EXECUTED
ffc1aa28: 40 bd 00 20 ble+ cr7,ffc1aa48 <msdos_long_to_short+0x110><== NOT EXECUTED
ffc1aa2c: 48 00 00 b0 b ffc1aadc <msdos_long_to_short+0x1a4> <== NOT EXECUTED
return MSDOS_NAME_LONG;
}
}
else
{
if (count == 8 && !is_dot)
ffc1aa30: 2f 1b 00 08 cmpwi cr6,r27,8
ffc1aa34: 40 ba 00 10 bne+ cr6,ffc1aa44 <msdos_long_to_short+0x10c>
ffc1aa38: 41 9e 00 a4 beq- cr7,ffc1aadc <msdos_long_to_short+0x1a4><== ALWAYS TAKEN
ffc1aa3c: 3b 40 00 08 li r26,8 <== NOT EXECUTED
ffc1aa40: 48 00 00 40 b ffc1aa80 <msdos_long_to_short+0x148> <== NOT EXECUTED
#endif
return MSDOS_NAME_LONG;
}
}
if (is_dot)
ffc1aa44: 40 be 00 28 bne+ cr7,ffc1aa6c <msdos_long_to_short+0x134><== NEVER TAKEN
dot_at = count;
else if ((*name >= 'A') && (*name <= 'Z'))
ffc1aa48: 38 19 ff bf addi r0,r25,-65
ffc1aa4c: 54 00 06 3e clrlwi r0,r0,24
ffc1aa50: 2b 80 00 19 cmplwi cr7,r0,25
ffc1aa54: 40 9d 00 20 ble- cr7,ffc1aa74 <msdos_long_to_short+0x13c><== NEVER TAKEN
uppercase = true;
else if ((*name >= 'a') && (*name <= 'z'))
ffc1aa58: 3b 39 ff 9f addi r25,r25,-97
ffc1aa5c: 57 39 06 3e clrlwi r25,r25,24
ffc1aa60: 2b 99 00 19 cmplwi cr7,r25,25
ffc1aa64: 40 9d 00 18 ble- cr7,ffc1aa7c <msdos_long_to_short+0x144>
ffc1aa68: 48 00 00 18 b ffc1aa80 <msdos_long_to_short+0x148>
#endif
return MSDOS_NAME_LONG;
}
}
if (is_dot)
ffc1aa6c: 7f 7a db 78 mr r26,r27 <== NOT EXECUTED
ffc1aa70: 48 00 00 10 b ffc1aa80 <msdos_long_to_short+0x148> <== NOT EXECUTED
dot_at = count;
else if ((*name >= 'A') && (*name <= 'Z'))
uppercase = true;
ffc1aa74: 3b 00 00 01 li r24,1 <== NOT EXECUTED
ffc1aa78: 48 00 00 08 b ffc1aa80 <msdos_long_to_short+0x148> <== NOT EXECUTED
else if ((*name >= 'a') && (*name <= 'z'))
lowercase = true;
ffc1aa7c: 3a e0 00 01 li r23,1
count++;
ffc1aa80: 3b 7b 00 01 addi r27,r27,1
ffc1aa84: 48 00 00 14 b ffc1aa98 <msdos_long_to_short+0x160>
/*
* Filenames with only blanks and dots are not allowed!
*/
for (i = 0; i < lfn_len; i++)
if ((lfn[i] != ' ') && (lfn[i] != '.'))
ffc1aa88: 3b 60 00 00 li r27,0
ffc1aa8c: 3b 40 ff ff li r26,-1
ffc1aa90: 3b 00 00 00 li r24,0
ffc1aa94: 3a e0 00 00 li r23,0
bool lowercase = false;
bool uppercase = false;
int dot_at = -1;
int count = 0;
while (*name && (count < name_len))
ffc1aa98: 7f 3d d8 ae lbzx r25,r29,r27
ffc1aa9c: 2f 99 00 00 cmpwi cr7,r25,0
ffc1aaa0: 41 9e 00 0c beq- cr7,ffc1aaac <msdos_long_to_short+0x174>
ffc1aaa4: 7f 9b f8 00 cmpw cr7,r27,r31
ffc1aaa8: 41 9c ff 44 blt+ cr7,ffc1a9ec <msdos_long_to_short+0xb4>
count++;
name++;
}
if (lowercase && uppercase)
ffc1aaac: 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;
ffc1aab0: 3b 80 00 01 li r28,1
count++;
name++;
}
if (lowercase && uppercase)
ffc1aab4: 41 9e 00 2c beq- cr7,ffc1aae0 <msdos_long_to_short+0x1a8><== NEVER TAKEN
ffc1aab8: 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;
ffc1aabc: 3b 80 00 02 li r28,2
count++;
name++;
}
if (lowercase && uppercase)
ffc1aac0: 40 be 00 20 bne+ cr7,ffc1aae0 <msdos_long_to_short+0x1a8><== NEVER TAKEN
}
#if MSDOS_NAME_TYPE_PRINT
printf ("MSDOS_NAME_TYPE: SHORT[1]\n");
#endif
return MSDOS_NAME_SHORT;
ffc1aac4: 3b 80 00 01 li r28,1
ffc1aac8: 48 00 00 18 b ffc1aae0 <msdos_long_to_short+0x1a8>
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;
ffc1aacc: 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;
}
ffc1aad0: 39 61 00 30 addi r11,r1,48
ffc1aad4: 7f 83 e3 78 mr r3,r28
ffc1aad8: 4b fe 80 00 b ffc02ad8 <_restgpr_23_x>
{
#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;
ffc1aadc: 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);
ffc1aae0: 7f a3 eb 78 mr r3,r29
ffc1aae4: 7f e4 fb 78 mr r4,r31
ffc1aae8: 7f c5 f3 78 mr r5,r30
ffc1aaec: 48 00 2c 6d bl ffc1d758 <msdos_filename_unix2dos>
#if MSDOS_L2S_PRINT
printf ("MSDOS_L2S: TYPE:%d lfn:'%s' SFN:'%s'\n", type, lfn, sfn);
#endif
return type;
ffc1aaf0: 4b ff ff e0 b ffc1aad0 <msdos_long_to_short+0x198>
ffc10c64 <msdos_mknod>:
const char *name,
mode_t mode,
dev_t dev,
rtems_filesystem_location_info_t *pathloc
)
{
ffc10c64: 94 21 ff e0 stwu r1,-32(r1)
ffc10c68: 7c 08 02 a6 mflr r0
ffc10c6c: 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))
ffc10c70: 54 80 04 26 rlwinm r0,r4,0,16,19
ffc10c74: 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;
ffc10c78: 81 27 00 10 lwz r9,16(r7)
const char *name,
mode_t mode,
dev_t dev,
rtems_filesystem_location_info_t *pathloc
)
{
ffc10c7c: bf 61 00 0c stmw r27,12(r1)
ffc10c80: 7c 7d 1b 78 mr r29,r3
ffc10c84: 7c 9e 23 78 mr r30,r4
ffc10c88: 7c fb 3b 78 mr r27,r7
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = pathloc->mt_entry->fs_info;
ffc10c8c: 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))
ffc10c90: 41 9e 00 20 beq- cr7,ffc10cb0 <msdos_mknod+0x4c>
{
type = MSDOS_DIRECTORY;
}
else if (S_ISREG(mode))
ffc10c94: 6c 09 ff ff xoris r9,r0,65535
ffc10c98: 2f 89 80 00 cmpwi cr7,r9,-32768
{
type = MSDOS_REGULAR_FILE;
ffc10c9c: 3b 80 00 05 li r28,5
*/
if (S_ISDIR(mode))
{
type = MSDOS_DIRECTORY;
}
else if (S_ISREG(mode))
ffc10ca0: 41 9e 00 14 beq- cr7,ffc10cb4 <msdos_mknod+0x50> <== ALWAYS TAKEN
{
type = MSDOS_REGULAR_FILE;
}
else
rtems_set_errno_and_return_minus_one(EINVAL);
ffc10ca4: 48 00 d5 35 bl ffc1e1d8 <__errno> <== NOT EXECUTED
ffc10ca8: 38 00 00 16 li r0,22 <== NOT EXECUTED
ffc10cac: 48 00 00 28 b ffc10cd4 <msdos_mknod+0x70> <== NOT EXECUTED
/*
* Figure out what type of msdos node this is.
*/
if (S_ISDIR(mode))
{
type = MSDOS_DIRECTORY;
ffc10cb0: 3b 80 00 01 li r28,1
type = MSDOS_REGULAR_FILE;
}
else
rtems_set_errno_and_return_minus_one(EINVAL);
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
ffc10cb4: 80 7f 00 98 lwz r3,152(r31)
ffc10cb8: 38 80 00 00 li r4,0
ffc10cbc: 38 a0 00 00 li r5,0
ffc10cc0: 4b ff b0 31 bl ffc0bcf0 <rtems_semaphore_obtain>
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
ffc10cc4: 2f 83 00 00 cmpwi cr7,r3,0
ffc10cc8: 41 be 00 18 beq+ cr7,ffc10ce0 <msdos_mknod+0x7c> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one(EIO);
ffc10ccc: 48 00 d5 0d bl ffc1e1d8 <__errno> <== NOT EXECUTED
ffc10cd0: 38 00 00 05 li r0,5 <== NOT EXECUTED
ffc10cd4: 90 03 00 00 stw r0,0(r3) <== NOT EXECUTED
ffc10cd8: 3b c0 ff ff li r30,-1 <== NOT EXECUTED
ffc10cdc: 48 00 00 34 b ffc10d10 <msdos_mknod+0xac> <== NOT EXECUTED
/* Create an MSDOS node */
rc = msdos_creat_node(pathloc, type, name, strlen(name), mode, NULL);
ffc10ce0: 7f a3 eb 78 mr r3,r29
ffc10ce4: 48 00 f0 71 bl ffc1fd54 <strlen>
ffc10ce8: 7f c7 f3 78 mr r7,r30
ffc10cec: 7c 66 1b 78 mr r6,r3
ffc10cf0: 7f 84 e3 78 mr r4,r28
ffc10cf4: 7f 63 db 78 mr r3,r27
ffc10cf8: 7f a5 eb 78 mr r5,r29
ffc10cfc: 39 00 00 00 li r8,0
ffc10d00: 48 00 8b a9 bl ffc198a8 <msdos_creat_node>
ffc10d04: 7c 7e 1b 78 mr r30,r3
rtems_semaphore_release(fs_info->vol_sema);
ffc10d08: 80 7f 00 98 lwz r3,152(r31)
ffc10d0c: 4b ff b1 11 bl ffc0be1c <rtems_semaphore_release>
return rc;
}
ffc10d10: 39 61 00 20 addi r11,r1,32
ffc10d14: 7f c3 f3 78 mr r3,r30
ffc10d18: 4b ff 1d d0 b ffc02ae8 <_restgpr_27_x>
ffc10d28 <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)
{
ffc10d28: 94 21 ff d0 stwu r1,-48(r1) <== NOT EXECUTED
ffc10d2c: 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)) {
ffc10d30: 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)
{
ffc10d34: 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;
ffc10d38: 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)
{
ffc10d3c: bf 61 00 1c stmw r27,28(r1) <== NOT EXECUTED
ffc10d40: 7c dc 33 78 mr r28,r6 <== NOT EXECUTED
ffc10d44: 7c 9d 23 78 mr r29,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;
ffc10d48: 83 c4 00 00 lwz r30,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)
{
ffc10d4c: 7c bb 2b 78 mr r27,r5 <== 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;
ffc10d50: 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)) {
ffc10d54: 48 00 f0 01 bl ffc1fd54 <strlen> <== NOT EXECUTED
ffc10d58: 7c 64 1b 78 mr r4,r3 <== NOT EXECUTED
ffc10d5c: 38 a1 00 0c addi r5,r1,12 <== NOT EXECUTED
ffc10d60: 7f 83 e3 78 mr r3,r28 <== NOT EXECUTED
ffc10d64: 38 c1 00 08 addi r6,r1,8 <== NOT EXECUTED
ffc10d68: 48 00 9d 8d bl ffc1aaf4 <msdos_get_token> <== NOT EXECUTED
ffc10d6c: 2f 83 00 03 cmpwi cr7,r3,3 <== NOT EXECUTED
ffc10d70: 41 be 00 10 beq+ cr7,ffc10d80 <msdos_rename+0x58> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(ENAMETOOLONG);
ffc10d74: 48 00 d4 65 bl ffc1e1d8 <__errno> <== NOT EXECUTED
ffc10d78: 38 00 00 5b li r0,91 <== NOT EXECUTED
ffc10d7c: 48 00 00 24 b ffc10da0 <msdos_rename+0x78> <== NOT EXECUTED
}
/*
* lock volume
*/
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
ffc10d80: 80 7f 00 98 lwz r3,152(r31) <== NOT EXECUTED
ffc10d84: 38 80 00 00 li r4,0 <== NOT EXECUTED
ffc10d88: 38 a0 00 00 li r5,0 <== NOT EXECUTED
ffc10d8c: 4b ff af 65 bl ffc0bcf0 <rtems_semaphore_obtain> <== NOT EXECUTED
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
ffc10d90: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc10d94: 41 be 00 18 beq+ cr7,ffc10dac <msdos_rename+0x84> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
ffc10d98: 48 00 d4 41 bl ffc1e1d8 <__errno> <== NOT EXECUTED
ffc10d9c: 38 00 00 05 li r0,5 <== NOT EXECUTED
ffc10da0: 90 03 00 00 stw r0,0(r3) <== NOT EXECUTED
ffc10da4: 3b 80 ff ff li r28,-1 <== NOT EXECUTED
ffc10da8: 48 00 00 48 b ffc10df0 <msdos_rename+0xc8> <== NOT EXECUTED
/*
* create new directory entry as "hard link", copying relevant info from
* existing file
*/
rc = msdos_creat_node(new_parent_loc,
ffc10dac: 80 c1 00 08 lwz r6,8(r1) <== NOT EXECUTED
ffc10db0: 38 e0 00 00 li r7,0 <== NOT EXECUTED
ffc10db4: 7f 85 e3 78 mr r5,r28 <== NOT EXECUTED
ffc10db8: 7f 63 db 78 mr r3,r27 <== NOT EXECUTED
ffc10dbc: 38 80 00 03 li r4,3 <== NOT EXECUTED
ffc10dc0: 60 e7 80 00 ori r7,r7,32768 <== NOT EXECUTED
ffc10dc4: 7f c8 f3 78 mr r8,r30 <== NOT EXECUTED
ffc10dc8: 48 00 8a e1 bl ffc198a8 <msdos_creat_node> <== NOT EXECUTED
MSDOS_HARD_LINK,new_name,len,S_IFREG,
old_fat_fd);
if (rc != RC_OK)
ffc10dcc: 7c 7c 1b 79 mr. r28,r3 <== NOT EXECUTED
ffc10dd0: 40 82 00 18 bne- ffc10de8 <msdos_rename+0xc0> <== NOT EXECUTED
}
/*
* mark file removed
*/
rc = msdos_set_first_char4file_name(old_loc->mt_entry,
ffc10dd4: 80 7d 00 10 lwz r3,16(r29) <== NOT EXECUTED
ffc10dd8: 38 9e 00 20 addi r4,r30,32 <== NOT EXECUTED
ffc10ddc: 38 a0 00 e5 li r5,229 <== NOT EXECUTED
ffc10de0: 48 00 a0 55 bl ffc1ae34 <msdos_set_first_char4file_name><== NOT EXECUTED
ffc10de4: 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);
ffc10de8: 80 7f 00 98 lwz r3,152(r31) <== NOT EXECUTED
ffc10dec: 4b ff b0 31 bl ffc0be1c <rtems_semaphore_release> <== NOT EXECUTED
return rc;
}
ffc10df0: 39 61 00 30 addi r11,r1,48 <== NOT EXECUTED
ffc10df4: 7f 83 e3 78 mr r3,r28 <== NOT EXECUTED
ffc10df8: 4b ff 1c f0 b ffc02ae8 <_restgpr_27_x> <== NOT EXECUTED
ffc1abf4 <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
)
{
ffc1abf4: 94 21 ff d0 stwu r1,-48(r1)
ffc1abf8: 7c 08 02 a6 mflr r0
ffc1abfc: 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);
ffc1ac00: 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
)
{
ffc1ac04: bf 61 00 1c stmw r27,28(r1)
ffc1ac08: 7c 7f 1b 78 mr r31,r3
ffc1ac0c: 7c 9e 23 78 mr r30,r4
ssize_t ret1 = 0, ret2 = 0, ret3 = 0;
msdos_fs_info_t *fs_info = mt_entry->fs_info;
ffc1ac10: 83 83 00 34 lwz r28,52(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);
ffc1ac14: 80 64 00 40 lwz r3,64(r4)
ffc1ac18: 38 81 00 08 addi r4,r1,8
ffc1ac1c: 48 00 29 25 bl ffc1d540 <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);
ffc1ac20: 80 9e 00 20 lwz r4,32(r30)
ffc1ac24: 80 7f 00 34 lwz r3,52(r31)
ffc1ac28: 4b ff fc 5d bl ffc1a884 <fat_cluster_num_to_sector_num.isra.0>
sec += (fat_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);
ffc1ac2c: 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);
ffc1ac30: 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,
ffc1ac34: 38 c0 00 02 li r6,2
/*
* 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);
ffc1ac38: 8b bc 00 02 lbz r29,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,
ffc1ac3c: 38 e1 00 0a addi r7,r1,10
* (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);
ffc1ac40: 3b de ff ff addi r30,r30,-1
ffc1ac44: 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);
ffc1ac48: 7c 1d ec 30 srw r29,r0,r29
/* 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);
ffc1ac4c: a0 01 00 0a lhz r0,10(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);
ffc1ac50: 7f a3 ea 14 add r29,r3,r29
/* 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);
ffc1ac54: 54 09 40 2e rlwinm r9,r0,8,0,23
ffc1ac58: 54 00 c2 3e rlwinm r0,r0,24,8,31
ffc1ac5c: 7d 20 03 78 or r0,r9,r0
ret1 = _fat_block_write(mt_entry, sec, byte + MSDOS_FILE_WTIME_OFFSET,
ffc1ac60: 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);
ffc1ac64: b0 01 00 0a sth r0,10(r1)
ret1 = _fat_block_write(mt_entry, sec, byte + MSDOS_FILE_WTIME_OFFSET,
ffc1ac68: 38 be 00 16 addi r5,r30,22
ffc1ac6c: 7f e3 fb 78 mr r3,r31
ffc1ac70: 4b ff a1 31 bl ffc14da0 <_fat_block_write>
2, (char *)(&time_val));
date = CT_LE_W(date);
ffc1ac74: a0 01 00 08 lhz r0,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,
ffc1ac78: 7c 7b 1b 78 mr r27,r3
2, (char *)(&time_val));
date = CT_LE_W(date);
ffc1ac7c: 54 09 40 2e rlwinm r9,r0,8,0,23
ffc1ac80: 54 00 c2 3e rlwinm r0,r0,24,8,31
ffc1ac84: 7d 20 03 78 or r0,r9,r0
ret2 = _fat_block_write(mt_entry, sec, byte + MSDOS_FILE_WDATE_OFFSET,
ffc1ac88: 7f a4 eb 78 mr r4,r29
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);
ffc1ac8c: b0 01 00 08 sth r0,8(r1)
ret2 = _fat_block_write(mt_entry, sec, byte + MSDOS_FILE_WDATE_OFFSET,
ffc1ac90: 38 be 00 18 addi r5,r30,24
ffc1ac94: 38 c0 00 02 li r6,2
ffc1ac98: 38 e1 00 08 addi r7,r1,8
ffc1ac9c: 7f e3 fb 78 mr r3,r31
ffc1aca0: 4b ff a1 01 bl ffc14da0 <_fat_block_write>
2, (char *)(&date));
ret3 = _fat_block_write(mt_entry, sec, byte + MSDOS_FILE_ADATE_OFFSET,
ffc1aca4: 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,
ffc1aca8: 7c 7c 1b 78 mr r28,r3
2, (char *)(&date));
ret3 = _fat_block_write(mt_entry, sec, byte + MSDOS_FILE_ADATE_OFFSET,
ffc1acac: 38 be 00 12 addi r5,r30,18
ffc1acb0: 7f e3 fb 78 mr r3,r31
ffc1acb4: 38 c0 00 02 li r6,2
ffc1acb8: 38 e1 00 08 addi r7,r1,8
ffc1acbc: 4b ff a0 e5 bl ffc14da0 <_fat_block_write>
2, (char *)(&date));
if ( (ret1 < 0) || (ret2 < 0) || (ret3 < 0) )
ffc1acc0: 2f 9b 00 00 cmpwi cr7,r27,0
return -1;
ffc1acc4: 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) )
ffc1acc8: 41 9c 00 10 blt- cr7,ffc1acd8 <msdos_set_dir_wrt_time_and_date+0xe4><== NEVER TAKEN
ffc1accc: 2f 9c 00 00 cmpwi cr7,r28,0
ffc1acd0: 41 9c 00 08 blt- cr7,ffc1acd8 <msdos_set_dir_wrt_time_and_date+0xe4><== NEVER TAKEN
return -1;
ffc1acd4: 7c 60 fe 70 srawi r0,r3,31
return RC_OK;
}
ffc1acd8: 39 61 00 30 addi r11,r1,48
ffc1acdc: 7c 03 03 78 mr r3,r0
ffc1ace0: 4b fe 7e 08 b ffc02ae8 <_restgpr_27_x>
ffc1ae34 <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
)
{
ffc1ae34: 94 21 ff c8 stwu r1,-56(r1) <== NOT EXECUTED
ffc1ae38: 7c 08 02 a6 mflr r0 <== NOT EXECUTED
ffc1ae3c: 90 01 00 3c stw r0,60(r1) <== NOT EXECUTED
ffc1ae40: bf 61 00 24 stmw r27,36(r1) <== NOT EXECUTED
ffc1ae44: 7c 7e 1b 78 mr r30,r3 <== NOT EXECUTED
ssize_t ret;
msdos_fs_info_t *fs_info = mt_entry->fs_info;
ffc1ae48: 83 e3 00 34 lwz r31,52(r3) <== NOT EXECUTED
uint32_t dir_block_size;
fat_pos_t start = dir_pos->lname;
fat_pos_t end = dir_pos->sname;
ffc1ae4c: 83 a4 00 00 lwz r29,0(r4) <== NOT EXECUTED
if ((end.cln == fs_info->fat.vol.rdir_cl) &&
ffc1ae50: 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;
ffc1ae54: 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) &&
ffc1ae58: 7f 9d 00 00 cmpw cr7,r29,r0 <== 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;
ffc1ae5c: 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
)
{
ffc1ae60: 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;
ffc1ae64: 91 41 00 08 stw r10,8(r1) <== NOT EXECUTED
ffc1ae68: 91 61 00 0c stw r11,12(r1) <== NOT EXECUTED
fat_pos_t end = dir_pos->sname;
ffc1ae6c: 83 64 00 04 lwz r27,4(r4) <== NOT EXECUTED
if ((end.cln == fs_info->fat.vol.rdir_cl) &&
ffc1ae70: 40 be 00 18 bne+ cr7,ffc1ae88 <msdos_set_first_char4file_name+0x54><== NOT EXECUTED
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))
ffc1ae74: 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) &&
ffc1ae78: 70 09 00 03 andi. r9,r0,3 <== NOT EXECUTED
ffc1ae7c: 41 82 00 0c beq- ffc1ae88 <msdos_set_first_char4file_name+0x54><== NOT EXECUTED
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))
dir_block_size = fs_info->fat.vol.rdir_size;
ffc1ae80: 83 9f 00 28 lwz r28,40(r31) <== NOT EXECUTED
ffc1ae84: 48 00 00 08 b ffc1ae8c <msdos_set_first_char4file_name+0x58><== NOT EXECUTED
else
dir_block_size = fs_info->fat.vol.bpc;
ffc1ae88: a3 9f 00 06 lhz r28,6(r31) <== NOT EXECUTED
if (dir_pos->lname.cln == FAT_FILE_SHORT_NAME)
ffc1ae8c: 80 04 00 08 lwz r0,8(r4) <== NOT EXECUTED
ffc1ae90: 2f 80 ff ff cmpwi cr7,r0,-1 <== NOT EXECUTED
ffc1ae94: 40 be 00 14 bne+ cr7,ffc1aea8 <msdos_set_first_char4file_name+0x74><== NOT EXECUTED
start = dir_pos->sname;
ffc1ae98: 81 44 00 00 lwz r10,0(r4) <== NOT EXECUTED
ffc1ae9c: 81 64 00 04 lwz r11,4(r4) <== NOT EXECUTED
ffc1aea0: 91 41 00 08 stw r10,8(r1) <== NOT EXECUTED
ffc1aea4: 91 61 00 0c stw r11,12(r1) <== NOT EXECUTED
* name code was written rather than use the fat_file_write
* interface.
*/
while (true)
{
uint32_t sec = (fat_cluster_num_to_sector_num(mt_entry, start.cln) +
ffc1aea8: 80 81 00 08 lwz r4,8(r1) <== NOT EXECUTED
ffc1aeac: 80 7e 00 34 lwz r3,52(r30) <== NOT EXECUTED
ffc1aeb0: 4b ff f9 d5 bl ffc1a884 <fat_cluster_num_to_sector_num.isra.0><== NOT EXECUTED
(start.ofs >> fs_info->fat.vol.sec_log2));
ffc1aeb4: 80 01 00 0c lwz r0,12(r1) <== NOT EXECUTED
ffc1aeb8: 88 9f 00 02 lbz r4,2(r31) <== NOT EXECUTED
uint32_t byte = (start.ofs & (fs_info->fat.vol.bps - 1));;
ret = _fat_block_write(mt_entry, sec, byte + MSDOS_FILE_NAME_OFFSET, 1,
ffc1aebc: 38 c0 00 01 li r6,1 <== NOT EXECUTED
*/
while (true)
{
uint32_t sec = (fat_cluster_num_to_sector_num(mt_entry, start.cln) +
(start.ofs >> fs_info->fat.vol.sec_log2));
uint32_t byte = (start.ofs & (fs_info->fat.vol.bps - 1));;
ffc1aec0: a0 bf 00 00 lhz r5,0(r31) <== NOT EXECUTED
ret = _fat_block_write(mt_entry, sec, byte + MSDOS_FILE_NAME_OFFSET, 1,
ffc1aec4: 38 e1 00 18 addi r7,r1,24 <== 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));
ffc1aec8: 7c 04 24 30 srw r4,r0,r4 <== NOT EXECUTED
uint32_t byte = (start.ofs & (fs_info->fat.vol.bps - 1));;
ffc1aecc: 38 a5 ff ff addi r5,r5,-1 <== NOT EXECUTED
* name code was written rather than use the fat_file_write
* interface.
*/
while (true)
{
uint32_t sec = (fat_cluster_num_to_sector_num(mt_entry, start.cln) +
ffc1aed0: 7c 83 22 14 add r4,r3,r4 <== NOT EXECUTED
(start.ofs >> fs_info->fat.vol.sec_log2));
uint32_t byte = (start.ofs & (fs_info->fat.vol.bps - 1));;
ret = _fat_block_write(mt_entry, sec, byte + MSDOS_FILE_NAME_OFFSET, 1,
ffc1aed4: 7c a5 00 38 and r5,r5,r0 <== NOT EXECUTED
ffc1aed8: 7f c3 f3 78 mr r3,r30 <== NOT EXECUTED
ffc1aedc: 4b ff 9e c5 bl ffc14da0 <_fat_block_write> <== NOT EXECUTED
&fchar);
if (ret < 0)
ffc1aee0: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc1aee4: 41 9c 00 60 blt- cr7,ffc1af44 <msdos_set_first_char4file_name+0x110><== NOT EXECUTED
return -1;
if ((start.cln == end.cln) && (start.ofs == end.ofs))
ffc1aee8: 80 81 00 08 lwz r4,8(r1) <== NOT EXECUTED
ffc1aeec: 81 21 00 0c lwz r9,12(r1) <== NOT EXECUTED
ffc1aef0: 7f 84 e8 00 cmpw cr7,r4,r29 <== NOT EXECUTED
ffc1aef4: 40 be 00 0c bne+ cr7,ffc1af00 <msdos_set_first_char4file_name+0xcc><== NOT EXECUTED
ffc1aef8: 7f 89 d8 00 cmpw cr7,r9,r27 <== NOT EXECUTED
ffc1aefc: 41 9e 00 50 beq- cr7,ffc1af4c <msdos_set_first_char4file_name+0x118><== NOT EXECUTED
break;
start.ofs += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE;
ffc1af00: 38 09 00 20 addi r0,r9,32 <== NOT EXECUTED
if (start.ofs >= dir_block_size)
ffc1af04: 7f 80 e0 40 cmplw cr7,r0,r28 <== NOT EXECUTED
return -1;
if ((start.cln == end.cln) && (start.ofs == end.ofs))
break;
start.ofs += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE;
ffc1af08: 90 01 00 0c stw r0,12(r1) <== NOT EXECUTED
if (start.ofs >= dir_block_size)
ffc1af0c: 41 9c ff 9c blt+ cr7,ffc1aea8 <msdos_set_first_char4file_name+0x74><== NOT EXECUTED
{
int rc;
if ((end.cln == fs_info->fat.vol.rdir_cl) &&
ffc1af10: 80 1f 00 38 lwz r0,56(r31) <== NOT EXECUTED
ffc1af14: 7f 9d 00 00 cmpw cr7,r29,r0 <== NOT EXECUTED
ffc1af18: 40 9e 00 10 bne- cr7,ffc1af28 <msdos_set_first_char4file_name+0xf4><== NOT EXECUTED
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))
ffc1af1c: 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) &&
ffc1af20: 70 09 00 03 andi. r9,r0,3 <== NOT EXECUTED
ffc1af24: 40 82 00 28 bne- ffc1af4c <msdos_set_first_char4file_name+0x118><== NOT EXECUTED
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))
break;
rc = fat_get_fat_cluster(mt_entry, start.cln, &start.cln);
ffc1af28: 7f c3 f3 78 mr r3,r30 <== NOT EXECUTED
ffc1af2c: 38 a1 00 08 addi r5,r1,8 <== NOT EXECUTED
ffc1af30: 48 00 14 71 bl ffc1c3a0 <fat_get_fat_cluster> <== NOT EXECUTED
if ( rc != RC_OK )
ffc1af34: 2c 03 00 00 cmpwi r3,0 <== NOT EXECUTED
ffc1af38: 40 82 00 18 bne- ffc1af50 <msdos_set_first_char4file_name+0x11c><== NOT EXECUTED
return rc;
start.ofs = 0;
ffc1af3c: 90 61 00 0c stw r3,12(r1) <== NOT EXECUTED
ffc1af40: 4b ff ff 68 b ffc1aea8 <msdos_set_first_char4file_name+0x74><== NOT EXECUTED
uint32_t byte = (start.ofs & (fs_info->fat.vol.bps - 1));;
ret = _fat_block_write(mt_entry, sec, byte + MSDOS_FILE_NAME_OFFSET, 1,
&fchar);
if (ret < 0)
return -1;
ffc1af44: 38 60 ff ff li r3,-1 <== NOT EXECUTED
ffc1af48: 48 00 00 08 b ffc1af50 <msdos_set_first_char4file_name+0x11c><== NOT EXECUTED
return rc;
start.ofs = 0;
}
}
return RC_OK;
ffc1af4c: 38 60 00 00 li r3,0 <== NOT EXECUTED
}
ffc1af50: 39 61 00 38 addi r11,r1,56 <== NOT EXECUTED
ffc1af54: 4b fe 7b 94 b ffc02ae8 <_restgpr_27_x> <== NOT EXECUTED
ffc1ace4 <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
)
{
ffc1ace4: 94 21 ff d0 stwu r1,-48(r1)
ffc1ace8: 7c 08 02 a6 mflr r0
ffc1acec: 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;
ffc1acf0: 38 00 00 00 li r0,0
int
msdos_set_first_cluster_num(
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_file_fd_t *fat_fd
)
{
ffc1acf4: bf 61 00 1c stmw r27,28(r1)
ffc1acf8: 7c 9e 23 78 mr r30,r4
ffc1acfc: 7c 7f 1b 78 mr r31,r3
ssize_t ret1 = 0, ret2 = 0;
msdos_fs_info_t *fs_info = mt_entry->fs_info;
ffc1ad00: 83 63 00 34 lwz r27,52(r3)
uint32_t new_cln = fat_fd->cln;
ffc1ad04: 83 84 00 1c lwz r28,28(r4)
/*
* 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);
ffc1ad08: 80 84 00 20 lwz r4,32(r4)
ffc1ad0c: 7f 63 db 78 mr r3,r27
)
{
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;
ffc1ad10: b0 01 00 0a sth r0,10(r1)
uint16_t le_cl_hi = 0;
ffc1ad14: b0 01 00 08 sth r0,8(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);
ffc1ad18: 4b ff fb 6d bl ffc1a884 <fat_cluster_num_to_sector_num.isra.0>
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));
ffc1ad1c: 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);
ffc1ad20: 80 1e 00 24 lwz r0,36(r30)
/* 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,
ffc1ad24: 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 from points to start of 32bytes structure */
byte = fat_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1);
ffc1ad28: a3 db 00 00 lhz r30,0(r27)
/*
* 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);
ffc1ad2c: 8b bb 00 02 lbz r29,2(r27)
/* byte from points to start of 32bytes structure */
byte = fat_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1);
ffc1ad30: 3b de ff ff addi r30,r30,-1
ffc1ad34: 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);
ffc1ad38: 7c 1d ec 30 srw r29,r0,r29
/* 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));
ffc1ad3c: 57 80 04 3e clrlwi r0,r28,16
ffc1ad40: 54 09 40 2e rlwinm r9,r0,8,0,23
ffc1ad44: 54 00 c2 3e rlwinm r0,r0,24,8,31
ffc1ad48: 7d 20 03 78 or r0,r9,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);
ffc1ad4c: 7f a3 ea 14 add r29,r3,r29
/* 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));
ffc1ad50: b4 07 00 0a sthu r0,10(r7)
ret1 = _fat_block_write(mt_entry, sec,
ffc1ad54: 7f a4 eb 78 mr r4,r29
ffc1ad58: 38 be 00 1a addi r5,r30,26
byte + MSDOS_FIRST_CLUSTER_LOW_OFFSET, 2,
(char *)(&le_cl_low));
le_cl_hi = CT_LE_W((uint16_t )((new_cln & 0xFFFF0000) >> 16));
ffc1ad5c: 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,
ffc1ad60: 7f e3 fb 78 mr r3,r31
ffc1ad64: 4b ff a0 3d bl ffc14da0 <_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));
ffc1ad68: 57 80 40 2e rlwinm r0,r28,8,0,23
ffc1ad6c: 57 9c c2 3e rlwinm r28,r28,24,8,31
ffc1ad70: 7c 1c e3 78 or r28,r0,r28
ffc1ad74: 7c 27 0b 78 mr r7,r1
ffc1ad78: 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,
ffc1ad7c: 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,
ffc1ad80: 7f a4 eb 78 mr r4,r29
ffc1ad84: 7f e3 fb 78 mr r3,r31
ffc1ad88: 38 be 00 14 addi r5,r30,20
ffc1ad8c: 38 c0 00 02 li r6,2
ffc1ad90: 4b ff a0 11 bl ffc14da0 <_fat_block_write>
byte + MSDOS_FIRST_CLUSTER_HI_OFFSET, 2,
(char *)(&le_cl_hi));
if ( (ret1 < 0) || (ret2 < 0) )
ffc1ad94: 2f 9b 00 00 cmpwi cr7,r27,0
return -1;
ffc1ad98: 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) )
ffc1ad9c: 41 9c 00 08 blt- cr7,ffc1ada4 <msdos_set_first_cluster_num+0xc0><== NEVER TAKEN
return -1;
ffc1ada0: 7c 60 fe 70 srawi r0,r3,31
return RC_OK;
}
ffc1ada4: 39 61 00 30 addi r11,r1,48
ffc1ada8: 7c 03 03 78 mr r3,r0
ffc1adac: 4b fe 7d 3c b ffc02ae8 <_restgpr_27_x>
ffc1a81c <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)
{
ffc1a81c: 94 21 ff e8 stwu r1,-24(r1) <== NOT EXECUTED
ffc1a820: 7c 08 02 a6 mflr r0 <== NOT EXECUTED
ffc1a824: 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)
ffc1a828: 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)
{
ffc1a82c: bf a1 00 0c stmw r29,12(r1) <== NOT EXECUTED
ffc1a830: 7c 7f 1b 78 mr r31,r3 <== 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;
ffc1a834: 3b a0 ff ff li r29,-1 <== NOT EXECUTED
*/
int
msdos_shut_down(rtems_filesystem_mount_table_entry_t *temp_mt_entry)
{
int rc = RC_OK;
msdos_fs_info_t *fs_info = temp_mt_entry->fs_info;
ffc1a838: 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)
ffc1a83c: 4b ff 99 c9 bl ffc14204 <fat_file_close> <== NOT EXECUTED
ffc1a840: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc1a844: 40 9e 00 08 bne- cr7,ffc1a84c <msdos_shut_down+0x30> <== NOT EXECUTED
*
*/
int
msdos_shut_down(rtems_filesystem_mount_table_entry_t *temp_mt_entry)
{
int rc = RC_OK;
ffc1a848: 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)
ffc1a84c: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc1a850: 4b ff a9 25 bl ffc15174 <fat_shutdown_drive> <== NOT EXECUTED
ffc1a854: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc1a858: 41 be 00 08 beq+ cr7,ffc1a860 <msdos_shut_down+0x44> <== NOT EXECUTED
{
/* no return - try to free as much as possible */
rc = -1;
ffc1a85c: 3b a0 ff ff li r29,-1 <== NOT EXECUTED
}
rtems_semaphore_delete(fs_info->vol_sema);
ffc1a860: 80 7e 00 98 lwz r3,152(r30) <== NOT EXECUTED
ffc1a864: 4b ff 13 d5 bl ffc0bc38 <rtems_semaphore_delete> <== NOT EXECUTED
free(fs_info->cl_buf);
ffc1a868: 80 7e 00 9c lwz r3,156(r30) <== NOT EXECUTED
ffc1a86c: 4b fe d0 7d bl ffc078e8 <free> <== NOT EXECUTED
free(temp_mt_entry->fs_info);
ffc1a870: 80 7f 00 34 lwz r3,52(r31) <== NOT EXECUTED
ffc1a874: 4b fe d0 75 bl ffc078e8 <free> <== NOT EXECUTED
return rc;
}
ffc1a878: 39 61 00 18 addi r11,r1,24 <== NOT EXECUTED
ffc1a87c: 7f a3 eb 78 mr r3,r29 <== NOT EXECUTED
ffc1a880: 4b fe 82 70 b ffc02af0 <_restgpr_29_x> <== NOT EXECUTED
ffc0553c <newlib_delete_hook>:
/*
* The reentrancy structure was allocated by newlib using malloc()
*/
if (current_task == deleted_task) {
ffc0553c: 7f 83 20 00 cmpw cr7,r3,r4
void newlib_delete_hook(
rtems_tcb *current_task,
rtems_tcb *deleted_task
)
{
ffc05540: 94 21 ff e8 stwu r1,-24(r1)
ffc05544: 7c 08 02 a6 mflr r0
/*
* The reentrancy structure was allocated by newlib using malloc()
*/
if (current_task == deleted_task) {
ptr = _REENT;
ffc05548: 3d 20 00 00 lis r9,0
void newlib_delete_hook(
rtems_tcb *current_task,
rtems_tcb *deleted_task
)
{
ffc0554c: bf a1 00 0c stmw r29,12(r1)
ffc05550: 7c 7d 1b 78 mr r29,r3
ffc05554: 7c 9e 23 78 mr r30,r4
ffc05558: 90 01 00 1c stw r0,28(r1)
/*
* The reentrancy structure was allocated by newlib using malloc()
*/
if (current_task == deleted_task) {
ptr = _REENT;
ffc0555c: 83 e9 27 8c lwz r31,10124(r9)
/*
* The reentrancy structure was allocated by newlib using malloc()
*/
if (current_task == deleted_task) {
ffc05560: 41 9e 00 08 beq- cr7,ffc05568 <newlib_delete_hook+0x2c>
ptr = _REENT;
} else {
ptr = deleted_task->libc_reent;
ffc05564: 83 e4 01 2c lwz r31,300(r4)
}
if (ptr && ptr != _global_impure_ptr) {
ffc05568: 2f 9f 00 00 cmpwi cr7,r31,0
ffc0556c: 41 9e 00 2c beq- cr7,ffc05598 <newlib_delete_hook+0x5c> <== NEVER TAKEN
ffc05570: 3d 20 00 00 lis r9,0
ffc05574: 80 09 27 88 lwz r0,10120(r9)
ffc05578: 7f 9f 00 00 cmpw cr7,r31,r0
ffc0557c: 41 9e 00 1c beq- cr7,ffc05598 <newlib_delete_hook+0x5c>
_reclaim_reent(ptr);
*/
/*
* Just in case there are some buffers lying around.
*/
_fwalk(ptr, newlib_free_buffers);
ffc05580: 3c 80 ff c0 lis r4,-64
ffc05584: 7f e3 fb 78 mr r3,r31
ffc05588: 38 84 53 24 addi r4,r4,21284
ffc0558c: 48 00 c1 49 bl ffc116d4 <_fwalk>
#if REENT_MALLOCED
free(ptr);
#else
_Workspace_Free(ptr);
ffc05590: 7f e3 fb 78 mr r3,r31
ffc05594: 48 00 67 ed bl ffc0bd80 <_Workspace_Free>
/*
* Require the switch back to another task to install its own
*/
if ( current_task == deleted_task ) {
ffc05598: 7f 9d f0 00 cmpw cr7,r29,r30
#else
_Workspace_Free(ptr);
#endif
}
deleted_task->libc_reent = NULL;
ffc0559c: 38 00 00 00 li r0,0
ffc055a0: 90 1e 01 2c stw r0,300(r30)
/*
* Require the switch back to another task to install its own
*/
if ( current_task == deleted_task ) {
ffc055a4: 40 be 00 0c bne+ cr7,ffc055b0 <newlib_delete_hook+0x74>
_REENT = 0;
ffc055a8: 3d 20 00 00 lis r9,0
ffc055ac: 90 09 27 8c stw r0,10124(r9)
}
}
ffc055b0: 39 61 00 18 addi r11,r1,24
ffc055b4: 4b ff af 88 b ffc0053c <_restgpr_29_x>
ffc05324 <newlib_free_buffers>:
*/
int newlib_free_buffers(
FILE *fp
)
{
ffc05324: 7c 2b 0b 78 mr r11,r1
ffc05328: 7c 08 02 a6 mflr r0
ffc0532c: 94 21 ff f0 stwu r1,-16(r1)
ffc05330: 48 01 60 1d bl ffc1b34c <_savegpr_31>
ffc05334: 90 01 00 14 stw r0,20(r1)
ffc05338: 7c 7f 1b 78 mr r31,r3
switch ( fileno(fp) ) {
ffc0533c: 48 00 bd 9d bl ffc110d8 <fileno>
ffc05340: 2b 83 00 02 cmplwi cr7,r3,2
ffc05344: 41 9d 00 34 bgt- cr7,ffc05378 <newlib_free_buffers+0x54><== NEVER TAKEN
case 0:
case 1:
case 2:
if (fp->_flags & __SMBF) {
ffc05348: a0 1f 00 0c lhz r0,12(r31)
ffc0534c: 70 09 00 80 andi. r9,r0,128
ffc05350: 41 a2 00 30 beq+ ffc05380 <newlib_free_buffers+0x5c> <== ALWAYS TAKEN
free( fp->_bf._base );
ffc05354: 80 7f 00 10 lwz r3,16(r31) <== NOT EXECUTED
ffc05358: 4b ff f6 05 bl ffc0495c <free> <== NOT EXECUTED
fp->_flags &= ~__SMBF;
ffc0535c: a0 1f 00 0c lhz r0,12(r31) <== NOT EXECUTED
ffc05360: 54 00 06 6e rlwinm r0,r0,0,25,23 <== NOT EXECUTED
ffc05364: b0 1f 00 0c sth r0,12(r31) <== NOT EXECUTED
fp->_bf._base = fp->_p = (unsigned char *) NULL;
ffc05368: 38 00 00 00 li r0,0 <== NOT EXECUTED
ffc0536c: 90 1f 00 00 stw r0,0(r31) <== NOT EXECUTED
ffc05370: 90 1f 00 10 stw r0,16(r31) <== NOT EXECUTED
ffc05374: 48 00 00 0c b ffc05380 <newlib_free_buffers+0x5c> <== NOT EXECUTED
}
break;
default:
fclose(fp);
ffc05378: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc0537c: 48 00 b9 c5 bl ffc10d40 <fclose> <== NOT EXECUTED
}
return 0;
}
ffc05380: 39 61 00 10 addi r11,r1,16
ffc05384: 38 60 00 00 li r3,0
ffc05388: 4b ff b1 bc b ffc00544 <_restgpr_31_x>
ffc00b24 <notify>:
void
notify (s)
char *s;
{
ffc00b24: 94 21 ff f8 stwu r1,-8(r1) <== NOT EXECUTED
ffc00b28: 7c 08 02 a6 mflr r0 <== NOT EXECUTED
ffc00b2c: 7c 64 1b 78 mr r4,r3 <== NOT EXECUTED
printf ("%s test appears to be inconsistent...\n", s);
ffc00b30: 3c 60 ff c2 lis r3,-62 <== NOT EXECUTED
}
void
notify (s)
char *s;
{
ffc00b34: 90 01 00 0c stw r0,12(r1) <== NOT EXECUTED
printf ("%s test appears to be inconsistent...\n", s);
ffc00b38: 38 63 2f a6 addi r3,r3,12198 <== NOT EXECUTED
ffc00b3c: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc00b40: 48 01 77 a5 bl ffc182e4 <printf> <== NOT EXECUTED
printf (" PLEASE NOTIFY KARPINKSI!\n");
ffc00b44: 3c 60 ff c2 lis r3,-62 <== NOT EXECUTED
ffc00b48: 38 63 2f cd addi r3,r3,12237 <== NOT EXECUTED
ffc00b4c: 48 01 79 4d bl ffc18498 <puts> <== NOT EXECUTED
}
ffc00b50: 80 01 00 0c lwz r0,12(r1) <== NOT EXECUTED
ffc00b54: 38 21 00 08 addi r1,r1,8 <== NOT EXECUTED
ffc00b58: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
ffc00b5c: 4e 80 00 20 blr <== NOT EXECUTED
ffc05648 <open>:
int open(
const char *pathname,
int flags,
...
)
{
ffc05648: 94 21 ff b8 stwu r1,-72(r1)
ffc0564c: 7c 08 02 a6 mflr r0
ffc05650: 90 01 00 4c stw r0,76(r1)
/*
* Set the Evaluation flags
*/
eval_flags = 0;
status = flags + 1;
ffc05654: 38 04 00 01 addi r0,r4,1
if ( ( status & _FREAD ) == _FREAD )
ffc05658: 70 09 00 01 andi. r9,r0,1
int open(
const char *pathname,
int flags,
...
)
{
ffc0565c: bf 41 00 30 stmw r26,48(r1)
ffc05660: 7c 7d 1b 78 mr r29,r3
ffc05664: 7c 9e 23 78 mr r30,r4
ffc05668: 90 a1 00 28 stw r5,40(r1)
int eval_flags;
/*
* Set the Evaluation flags
*/
eval_flags = 0;
ffc0566c: 3b 80 00 00 li r28,0
status = flags + 1;
if ( ( status & _FREAD ) == _FREAD )
ffc05670: 41 82 00 08 beq- ffc05678 <open+0x30>
eval_flags |= RTEMS_LIBIO_PERMS_READ;
ffc05674: 3b 80 00 04 li r28,4
if ( ( status & _FWRITE ) == _FWRITE )
ffc05678: 70 09 00 02 andi. r9,r0,2
ffc0567c: 41 82 00 08 beq- ffc05684 <open+0x3c>
eval_flags |= RTEMS_LIBIO_PERMS_WRITE;
ffc05680: 63 9c 00 02 ori r28,r28,2
va_start(ap, flags);
ffc05684: 38 01 00 50 addi r0,r1,80
mode = va_arg( ap, int );
ffc05688: 83 61 00 28 lwz r27,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);
ffc0568c: 90 01 00 0c stw r0,12(r1)
ffc05690: 39 21 00 20 addi r9,r1,32
mode = va_arg( ap, int );
ffc05694: 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);
ffc05698: 91 21 00 10 stw r9,16(r1)
mode = va_arg( ap, int );
ffc0569c: 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();
ffc056a0: 48 00 7b 49 bl ffc0d1e8 <rtems_libio_allocate>
if ( iop == 0 ) {
ffc056a4: 7c 7f 1b 79 mr. r31,r3
ffc056a8: 41 82 01 70 beq- ffc05818 <open+0x1d0>
}
/*
* See if the file exists.
*/
status = rtems_filesystem_evaluate_path(
ffc056ac: 7f a3 eb 78 mr r3,r29
ffc056b0: 48 00 ce 31 bl ffc124e0 <strlen>
ffc056b4: 7f 85 e3 78 mr r5,r28
ffc056b8: 7c 64 1b 78 mr r4,r3
ffc056bc: 38 c1 00 14 addi r6,r1,20
ffc056c0: 7f a3 eb 78 mr r3,r29
ffc056c4: 38 e0 00 01 li r7,1
ffc056c8: 4b ff f1 75 bl ffc0483c <rtems_filesystem_evaluate_path>
pathname, strlen( pathname ), eval_flags, &loc, true );
if ( status == -1 ) {
ffc056cc: 2f 83 ff ff cmpwi cr7,r3,-1
ffc056d0: 40 be 00 80 bne+ cr7,ffc05750 <open+0x108>
if ( errno != ENOENT ) {
ffc056d4: 48 00 b4 e1 bl ffc10bb4 <__errno>
ffc056d8: 80 03 00 00 lwz r0,0(r3)
ffc056dc: 2f 80 00 02 cmpwi cr7,r0,2
ffc056e0: 41 9e 00 14 beq- cr7,ffc056f4 <open+0xac>
rc = errno;
ffc056e4: 48 00 b4 d1 bl ffc10bb4 <__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;
ffc056e8: 3b 80 00 00 li r28,0
status = rtems_filesystem_evaluate_path(
pathname, strlen( pathname ), eval_flags, &loc, true );
if ( status == -1 ) {
if ( errno != ENOENT ) {
rc = errno;
ffc056ec: 83 43 00 00 lwz r26,0(r3)
goto done;
ffc056f0: 48 00 01 3c b ffc0582c <open+0x1e4>
}
/* If the file does not exist and we are not trying to create it--> error */
if ( !(flags & O_CREAT) ) {
ffc056f4: 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;
ffc056f8: 3b 80 00 00 li r28,0
goto done;
}
/* If the file does not exist and we are not trying to create it--> error */
if ( !(flags & O_CREAT) ) {
rc = ENOENT;
ffc056fc: 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) ) {
ffc05700: 41 a2 01 34 beq+ ffc05834 <open+0x1ec>
rc = ENOENT;
goto done;
}
/* Create the node for the new regular file */
rc = mknod( pathname, S_IFREG | mode, 0LL );
ffc05704: 7f a3 eb 78 mr r3,r29
ffc05708: 63 64 80 00 ori r4,r27,32768
ffc0570c: 38 a0 00 00 li r5,0
ffc05710: 38 c0 00 00 li r6,0
ffc05714: 4b ff f7 19 bl ffc04e2c <mknod>
if ( rc ) {
ffc05718: 2f 83 00 00 cmpwi cr7,r3,0
ffc0571c: 40 9e 00 8c bne- cr7,ffc057a8 <open+0x160> <== NEVER TAKEN
/*
* 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(
ffc05720: 7f a3 eb 78 mr r3,r29
ffc05724: 48 00 cd bd bl ffc124e0 <strlen>
ffc05728: 38 a0 00 00 li r5,0
ffc0572c: 7c 64 1b 78 mr r4,r3
ffc05730: 38 c1 00 14 addi r6,r1,20
ffc05734: 7f a3 eb 78 mr r3,r29
ffc05738: 38 e0 00 01 li r7,1
ffc0573c: 4b ff f1 01 bl ffc0483c <rtems_filesystem_evaluate_path>
pathname, strlen( pathname ), 0x0, &loc, true );
if ( status != 0 ) { /* The file did not exist */
rc = EACCES;
ffc05740: 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 */
ffc05744: 2f 83 00 00 cmpwi cr7,r3,0
ffc05748: 40 9e 00 ec bne- cr7,ffc05834 <open+0x1ec>
ffc0574c: 48 00 00 10 b ffc0575c <open+0x114>
rc = EACCES;
goto done;
}
} else if ((flags & (O_EXCL|O_CREAT)) == (O_EXCL|O_CREAT)) {
ffc05750: 73 c0 0a 00 andi. r0,r30,2560
ffc05754: 2f 80 0a 00 cmpwi cr7,r0,2560
ffc05758: 41 9e 00 c8 beq- cr7,ffc05820 <open+0x1d8>
/*
* Fill in the file control block based on the loc structure
* returned by successful path evaluation.
*/
iop->flags |= rtems_libio_fcntl_flags( flags );
ffc0575c: 83 9f 00 18 lwz r28,24(r31)
ffc05760: 7f c3 f3 78 mr r3,r30
ffc05764: 48 00 79 f5 bl ffc0d158 <rtems_libio_fcntl_flags>
iop->pathinfo = loc;
ffc05768: 39 7f 00 1c addi r11,r31,28
/*
* Fill in the file control block based on the loc structure
* returned by successful path evaluation.
*/
iop->flags |= rtems_libio_fcntl_flags( flags );
ffc0576c: 7c 63 e3 78 or r3,r3,r28
iop->pathinfo = loc;
ffc05770: 3b 81 00 14 addi r28,r1,20
/*
* Fill in the file control block based on the loc structure
* returned by successful path evaluation.
*/
iop->flags |= rtems_libio_fcntl_flags( flags );
ffc05774: 90 7f 00 18 stw r3,24(r31)
iop->pathinfo = loc;
rc = (*iop->pathinfo.handlers->open_h)( iop, pathname, flags, mode );
ffc05778: 7f a4 eb 78 mr r4,r29
/*
* 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;
ffc0577c: 7c bc a4 aa lswi r5,r28,20
ffc05780: 7c ab a5 aa stswi r5,r11,20
rc = (*iop->pathinfo.handlers->open_h)( iop, pathname, flags, mode );
ffc05784: 7f e3 fb 78 mr r3,r31
ffc05788: 7f c5 f3 78 mr r5,r30
ffc0578c: 81 3f 00 24 lwz r9,36(r31)
ffc05790: 7f 66 db 78 mr r6,r27
ffc05794: 80 09 00 00 lwz r0,0(r9)
ffc05798: 7c 09 03 a6 mtctr r0
ffc0579c: 4e 80 04 21 bctrl
if ( rc ) {
ffc057a0: 2f 83 00 00 cmpwi cr7,r3,0
ffc057a4: 41 be 00 10 beq+ cr7,ffc057b4 <open+0x16c>
rc = errno;
ffc057a8: 48 00 b4 0d bl ffc10bb4 <__errno>
ffc057ac: 83 43 00 00 lwz r26,0(r3)
goto done;
ffc057b0: 48 00 00 7c b ffc0582c <open+0x1e4>
}
/*
* Optionally truncate the file.
*/
if ( (flags & O_TRUNC) == O_TRUNC ) {
ffc057b4: 73 c0 04 00 andi. r0,r30,1024
ffc057b8: 41 a2 00 ac beq+ ffc05864 <open+0x21c>
rc = ftruncate( iop - rtems_libio_iops, 0 );
ffc057bc: 3d 20 00 00 lis r9,0
ffc057c0: 80 69 27 f0 lwz r3,10224(r9)
ffc057c4: 38 a0 00 00 li r5,0
ffc057c8: 38 c0 00 00 li r6,0
ffc057cc: 7c 63 f8 50 subf r3,r3,r31
ffc057d0: 7c 63 36 70 srawi r3,r3,6
ffc057d4: 48 00 78 49 bl ffc0d01c <ftruncate>
if ( rc ) {
ffc057d8: 7c 7a 1b 79 mr. r26,r3
ffc057dc: 41 a2 00 88 beq+ ffc05864 <open+0x21c>
if(errno) rc = errno;
ffc057e0: 48 00 b3 d5 bl ffc10bb4 <__errno>
ffc057e4: 80 03 00 00 lwz r0,0(r3)
ffc057e8: 2f 80 00 00 cmpwi cr7,r0,0
ffc057ec: 41 be 00 0c beq+ cr7,ffc057f8 <open+0x1b0> <== NEVER TAKEN
ffc057f0: 48 00 b3 c5 bl ffc10bb4 <__errno>
ffc057f4: 83 43 00 00 lwz r26,0(r3)
close( iop - rtems_libio_iops );
ffc057f8: 3d 20 00 00 lis r9,0
ffc057fc: 80 09 27 f0 lwz r0,10224(r9)
/* those are released by close(): */
iop = 0;
loc_to_free = NULL;
ffc05800: 3b 80 00 00 li r28,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 );
ffc05804: 7f e0 f8 50 subf r31,r0,r31
ffc05808: 7f e3 36 70 srawi r3,r31,6
ffc0580c: 48 00 77 85 bl ffc0cf90 <close>
/* those are released by close(): */
iop = 0;
ffc05810: 3b e0 00 00 li r31,0
ffc05814: 48 00 00 18 b ffc0582c <open+0x1e4>
*/
/* allocate a file control block */
iop = rtems_libio_allocate();
if ( iop == 0 ) {
rc = ENFILE;
ffc05818: 3b 40 00 17 li r26,23
ffc0581c: 48 00 00 38 b ffc05854 <open+0x20c>
}
} 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;
ffc05820: 3b 81 00 14 addi r28,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;
ffc05824: 3b 40 00 11 li r26,17
ffc05828: 48 00 00 0c b ffc05834 <open+0x1ec>
* Single exit and clean up path.
*/
done:
va_end(ap);
if ( rc ) {
ffc0582c: 2f 9a 00 00 cmpwi cr7,r26,0
ffc05830: 41 be 00 34 beq+ cr7,ffc05864 <open+0x21c> <== NEVER TAKEN
if ( iop )
ffc05834: 2f 9f 00 00 cmpwi cr7,r31,0
ffc05838: 41 9e 00 0c beq- cr7,ffc05844 <open+0x1fc>
rtems_libio_free( iop );
ffc0583c: 7f e3 fb 78 mr r3,r31
ffc05840: 48 00 7a 41 bl ffc0d280 <rtems_libio_free>
if ( loc_to_free )
ffc05844: 2f 9c 00 00 cmpwi cr7,r28,0
ffc05848: 41 9e 00 0c beq- cr7,ffc05854 <open+0x20c>
rtems_filesystem_freenode( loc_to_free );
ffc0584c: 7f 83 e3 78 mr r3,r28
ffc05850: 4b ff f0 e1 bl ffc04930 <rtems_filesystem_freenode>
rtems_set_errno_and_return_minus_one( rc );
ffc05854: 48 00 b3 61 bl ffc10bb4 <__errno>
ffc05858: 93 43 00 00 stw r26,0(r3)
ffc0585c: 38 60 ff ff li r3,-1
ffc05860: 48 00 00 14 b ffc05874 <open+0x22c>
}
return iop - rtems_libio_iops;
ffc05864: 3d 20 00 00 lis r9,0
ffc05868: 80 69 27 f0 lwz r3,10224(r9)
ffc0586c: 7f e3 f8 50 subf r31,r3,r31
ffc05870: 7f e3 36 70 srawi r3,r31,6
}
ffc05874: 39 61 00 48 addi r11,r1,72
ffc05878: 4b ff ac b8 b ffc00530 <_restgpr_26_x>
ffc0656c <oproc>:
/*
* Handle output processing
*/
static void
oproc (unsigned char c, struct rtems_termios_tty *tty)
{
ffc0656c: 7c 08 02 a6 mflr r0
ffc06570: 7c 2b 0b 78 mr r11,r1
ffc06574: 94 21 ff e8 stwu r1,-24(r1)
ffc06578: 90 01 00 1c stw r0,28(r1)
ffc0657c: 48 01 4d d1 bl ffc1b34c <_savegpr_31>
ffc06580: 7c 9f 23 78 mr r31,r4
int i;
if (tty->termios.c_oflag & OPOST) {
ffc06584: 80 04 00 34 lwz r0,52(r4)
/*
* Handle output processing
*/
static void
oproc (unsigned char c, struct rtems_termios_tty *tty)
{
ffc06588: 98 61 00 08 stb r3,8(r1)
int i;
if (tty->termios.c_oflag & OPOST) {
ffc0658c: 70 09 00 01 andi. r9,r0,1
ffc06590: 41 82 01 30 beq- ffc066c0 <oproc+0x154> <== NEVER TAKEN
switch (c) {
ffc06594: 2f 83 00 09 cmpwi cr7,r3,9
ffc06598: 41 9e 00 90 beq- cr7,ffc06628 <oproc+0xbc>
ffc0659c: 2b 83 00 09 cmplwi cr7,r3,9
ffc065a0: 41 9d 00 10 bgt- cr7,ffc065b0 <oproc+0x44> <== ALWAYS TAKEN
ffc065a4: 2f 83 00 08 cmpwi cr7,r3,8 <== NOT EXECUTED
ffc065a8: 40 be 00 c4 bne+ cr7,ffc0666c <oproc+0x100> <== NOT EXECUTED
ffc065ac: 48 00 00 a8 b ffc06654 <oproc+0xe8> <== NOT EXECUTED
ffc065b0: 2f 83 00 0a cmpwi cr7,r3,10
ffc065b4: 41 9e 00 10 beq- cr7,ffc065c4 <oproc+0x58>
ffc065b8: 2f 83 00 0d cmpwi cr7,r3,13
ffc065bc: 40 be 00 b0 bne+ cr7,ffc0666c <oproc+0x100> <== ALWAYS TAKEN
ffc065c0: 48 00 00 34 b ffc065f4 <oproc+0x88> <== NOT EXECUTED
case '\n':
if (tty->termios.c_oflag & ONLRET)
ffc065c4: 70 09 00 20 andi. r9,r0,32
ffc065c8: 41 82 00 0c beq- ffc065d4 <oproc+0x68> <== ALWAYS TAKEN
tty->column = 0;
ffc065cc: 39 20 00 00 li r9,0 <== NOT EXECUTED
ffc065d0: 91 24 00 28 stw r9,40(r4) <== NOT EXECUTED
if (tty->termios.c_oflag & ONLCR) {
ffc065d4: 70 09 00 04 andi. r9,r0,4
ffc065d8: 41 a2 00 e8 beq+ ffc066c0 <oproc+0x154> <== NEVER TAKEN
rtems_termios_puts ("\r", 1, tty);
ffc065dc: 3c 60 ff c2 lis r3,-62
ffc065e0: 38 63 d8 0e addi r3,r3,-10226
ffc065e4: 38 80 00 01 li r4,1
ffc065e8: 7f e5 fb 78 mr r5,r31
ffc065ec: 4b ff fe 61 bl ffc0644c <rtems_termios_puts>
ffc065f0: 48 00 00 30 b ffc06620 <oproc+0xb4>
tty->column = 0;
}
break;
case '\r':
if ((tty->termios.c_oflag & ONOCR) && (tty->column == 0))
ffc065f4: 70 09 00 10 andi. r9,r0,16 <== NOT EXECUTED
ffc065f8: 41 82 00 10 beq- ffc06608 <oproc+0x9c> <== NOT EXECUTED
ffc065fc: 81 24 00 28 lwz r9,40(r4) <== NOT EXECUTED
ffc06600: 2f 89 00 00 cmpwi cr7,r9,0 <== NOT EXECUTED
ffc06604: 41 9e 00 cc beq- cr7,ffc066d0 <oproc+0x164> <== NOT EXECUTED
return;
if (tty->termios.c_oflag & OCRNL) {
ffc06608: 70 09 00 08 andi. r9,r0,8 <== NOT EXECUTED
ffc0660c: 41 82 00 58 beq- ffc06664 <oproc+0xf8> <== NOT EXECUTED
c = '\n';
ffc06610: 39 20 00 0a li r9,10 <== NOT EXECUTED
ffc06614: 99 21 00 08 stb r9,8(r1) <== NOT EXECUTED
if (tty->termios.c_oflag & ONLRET)
ffc06618: 70 09 00 20 andi. r9,r0,32 <== NOT EXECUTED
ffc0661c: 41 82 00 a4 beq- ffc066c0 <oproc+0x154> <== NOT EXECUTED
tty->column = 0;
ffc06620: 38 00 00 00 li r0,0
ffc06624: 48 00 00 98 b ffc066bc <oproc+0x150>
tty->column = 0;
break;
case '\t':
i = 8 - (tty->column & 7);
if ((tty->termios.c_oflag & TABDLY) == XTABS) {
ffc06628: 54 00 04 e8 rlwinm r0,r0,0,19,20
}
tty->column = 0;
break;
case '\t':
i = 8 - (tty->column & 7);
ffc0662c: 81 24 00 28 lwz r9,40(r4)
if ((tty->termios.c_oflag & TABDLY) == XTABS) {
ffc06630: 2f 80 18 00 cmpwi cr7,r0,6144
}
tty->column = 0;
break;
case '\t':
i = 8 - (tty->column & 7);
ffc06634: 55 24 07 7e clrlwi r4,r9,29
ffc06638: 20 84 00 08 subfic r4,r4,8
ffc0663c: 7c 09 22 14 add r0,r9,r4
if ((tty->termios.c_oflag & TABDLY) == XTABS) {
tty->column += i;
ffc06640: 90 1f 00 28 stw r0,40(r31)
tty->column = 0;
break;
case '\t':
i = 8 - (tty->column & 7);
if ((tty->termios.c_oflag & TABDLY) == XTABS) {
ffc06644: 40 be 00 7c bne+ cr7,ffc066c0 <oproc+0x154> <== NEVER TAKEN
tty->column += i;
rtems_termios_puts ( " ", i, tty);
ffc06648: 3c 60 ff c2 lis r3,-62
ffc0664c: 38 63 d0 3e addi r3,r3,-12226
ffc06650: 48 00 00 78 b ffc066c8 <oproc+0x15c>
}
tty->column += i;
break;
case '\b':
if (tty->column > 0)
ffc06654: 81 24 00 28 lwz r9,40(r4) <== NOT EXECUTED
ffc06658: 2f 89 00 00 cmpwi cr7,r9,0 <== NOT EXECUTED
ffc0665c: 40 9d 00 64 ble- cr7,ffc066c0 <oproc+0x154> <== NOT EXECUTED
tty->column--;
ffc06660: 39 29 ff ff addi r9,r9,-1 <== NOT EXECUTED
ffc06664: 91 3f 00 28 stw r9,40(r31) <== NOT EXECUTED
ffc06668: 48 00 00 58 b ffc066c0 <oproc+0x154> <== NOT EXECUTED
break;
default:
if (tty->termios.c_oflag & OLCUC)
ffc0666c: 70 09 00 02 andi. r9,r0,2
ffc06670: 41 82 00 28 beq- ffc06698 <oproc+0x12c> <== ALWAYS TAKEN
c = toupper(c);
ffc06674: 3d 20 00 00 lis r9,0 <== NOT EXECUTED
ffc06678: 81 29 27 84 lwz r9,10116(r9) <== NOT EXECUTED
ffc0667c: 7d 29 1a 14 add r9,r9,r3 <== NOT EXECUTED
ffc06680: 88 09 00 01 lbz r0,1(r9) <== NOT EXECUTED
ffc06684: 54 00 07 be clrlwi r0,r0,30 <== NOT EXECUTED
ffc06688: 2f 80 00 02 cmpwi cr7,r0,2 <== NOT EXECUTED
ffc0668c: 40 be 00 08 bne+ cr7,ffc06694 <oproc+0x128> <== NOT EXECUTED
ffc06690: 38 63 ff e0 addi r3,r3,-32 <== NOT EXECUTED
ffc06694: 98 61 00 08 stb r3,8(r1) <== NOT EXECUTED
if (!iscntrl(c))
ffc06698: 3d 20 00 00 lis r9,0
ffc0669c: 88 01 00 08 lbz r0,8(r1)
ffc066a0: 81 29 27 84 lwz r9,10116(r9)
ffc066a4: 7d 29 02 14 add r9,r9,r0
ffc066a8: 88 09 00 01 lbz r0,1(r9)
ffc066ac: 70 09 00 20 andi. r9,r0,32
ffc066b0: 40 82 00 10 bne- ffc066c0 <oproc+0x154> <== NEVER TAKEN
tty->column++;
ffc066b4: 81 3f 00 28 lwz r9,40(r31)
ffc066b8: 38 09 00 01 addi r0,r9,1
ffc066bc: 90 1f 00 28 stw r0,40(r31)
break;
}
}
rtems_termios_puts (&c, 1, tty);
ffc066c0: 38 61 00 08 addi r3,r1,8
ffc066c4: 38 80 00 01 li r4,1
ffc066c8: 7f e5 fb 78 mr r5,r31
ffc066cc: 4b ff fd 81 bl ffc0644c <rtems_termios_puts>
}
ffc066d0: 39 61 00 18 addi r11,r1,24
ffc066d4: 4b ff 9e 70 b ffc00544 <_restgpr_31_x>
ffc0dc58 <pipe_create>:
* Called by pipe() to create an anonymous pipe.
*/
int pipe_create(
int filsdes[2]
)
{
ffc0dc58: 94 21 ff d8 stwu r1,-40(r1)
ffc0dc5c: 7c 08 02 a6 mflr r0
rtems_libio_t *iop;
int err = 0;
if (rtems_mkdir("/tmp", S_IRWXU | S_IRWXG | S_IRWXO) != 0)
ffc0dc60: 38 80 01 ff li r4,511
* Called by pipe() to create an anonymous pipe.
*/
int pipe_create(
int filsdes[2]
)
{
ffc0dc64: bf 81 00 18 stmw r28,24(r1)
ffc0dc68: 7c 7d 1b 78 mr r29,r3
rtems_libio_t *iop;
int err = 0;
if (rtems_mkdir("/tmp", S_IRWXU | S_IRWXG | S_IRWXO) != 0)
ffc0dc6c: 3c 60 ff c2 lis r3,-62
ffc0dc70: 38 63 fa b8 addi r3,r3,-1352
* Called by pipe() to create an anonymous pipe.
*/
int pipe_create(
int filsdes[2]
)
{
ffc0dc74: 90 01 00 2c stw r0,44(r1)
rtems_libio_t *iop;
int err = 0;
if (rtems_mkdir("/tmp", S_IRWXU | S_IRWXG | S_IRWXO) != 0)
ffc0dc78: 48 00 18 51 bl ffc0f4c8 <rtems_mkdir>
return -1;
ffc0dc7c: 3b c0 ff ff li r30,-1
)
{
rtems_libio_t *iop;
int err = 0;
if (rtems_mkdir("/tmp", S_IRWXU | S_IRWXG | S_IRWXO) != 0)
ffc0dc80: 2f 83 00 00 cmpwi cr7,r3,0
ffc0dc84: 40 9e 01 04 bne- cr7,ffc0dd88 <pipe_create+0x130> <== NEVER TAKEN
return -1;
/* /tmp/.fifoXXXX */
char fifopath[15];
memcpy(fifopath, "/tmp/.fifo", 10);
ffc0dc88: 3d 20 ff c2 lis r9,-62
ffc0dc8c: 3b e1 00 08 addi r31,r1,8
ffc0dc90: 39 29 fa bd addi r9,r9,-1347
ffc0dc94: 7c a9 54 aa lswi r5,r9,10
ffc0dc98: 7c bf 55 aa stswi r5,r31,10
sprintf(fifopath + 10, "%04x", rtems_pipe_no ++);
ffc0dc9c: 3d 20 00 00 lis r9,0
ffc0dca0: 3c 80 ff c2 lis r4,-62
ffc0dca4: a0 a9 29 f8 lhz r5,10744(r9)
ffc0dca8: 38 84 fa c8 addi r4,r4,-1336
ffc0dcac: 38 61 00 12 addi r3,r1,18
ffc0dcb0: 38 05 00 01 addi r0,r5,1
ffc0dcb4: b0 09 29 f8 sth r0,10744(r9)
ffc0dcb8: 4c c6 31 82 crclr 4*cr1+eq
ffc0dcbc: 48 00 53 ad bl ffc13068 <sprintf>
/* Try creating FIFO file until find an available file name */
while (mkfifo(fifopath, S_IRUSR|S_IWUSR) != 0) {
ffc0dcc0: 7f e3 fb 78 mr r3,r31
ffc0dcc4: 38 80 01 80 li r4,384
ffc0dcc8: 48 00 14 fd bl ffc0f1c4 <mkfifo>
ffc0dccc: 2f 83 00 00 cmpwi cr7,r3,0
ffc0dcd0: 41 be 00 0c beq+ cr7,ffc0dcdc <pipe_create+0x84>
if (errno != EEXIST){
ffc0dcd4: 48 00 44 c1 bl ffc12194 <__errno>
ffc0dcd8: 48 00 00 b0 b ffc0dd88 <pipe_create+0x130>
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);
ffc0dcdc: 7f e3 fb 78 mr r3,r31
ffc0dce0: 38 80 40 00 li r4,16384
ffc0dce4: 4c c6 31 82 crclr 4*cr1+eq
ffc0dce8: 4b ff 8a 15 bl ffc066fc <open>
if (filsdes[0] < 0) {
ffc0dcec: 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);
ffc0dcf0: 90 7d 00 00 stw r3,0(r29)
if (filsdes[0] < 0) {
ffc0dcf4: 40 bc 00 14 bge+ cr7,ffc0dd08 <pipe_create+0xb0>
err = errno;
ffc0dcf8: 48 00 44 9d bl ffc12194 <__errno>
ffc0dcfc: 83 83 00 00 lwz r28,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);
ffc0dd00: 7f e3 fb 78 mr r3,r31
ffc0dd04: 48 00 00 68 b ffc0dd6c <pipe_create+0x114>
}
else {
/* Reset open file to blocking mode */
iop = rtems_libio_iop(filsdes[0]);
ffc0dd08: 3d 20 00 00 lis r9,0
ffc0dd0c: 80 09 27 3c lwz r0,10044(r9)
ffc0dd10: 39 20 00 00 li r9,0
ffc0dd14: 7f 83 00 40 cmplw cr7,r3,r0
ffc0dd18: 40 9c 00 14 bge- cr7,ffc0dd2c <pipe_create+0xd4> <== NEVER TAKEN
ffc0dd1c: 3d 20 00 00 lis r9,0
ffc0dd20: 81 29 27 ec lwz r9,10220(r9)
ffc0dd24: 54 63 30 32 rlwinm r3,r3,6,0,25
ffc0dd28: 7d 29 1a 14 add r9,r9,r3
iop->flags &= ~LIBIO_FLAGS_NO_DELAY;
ffc0dd2c: 80 09 00 18 lwz r0,24(r9)
filsdes[1] = open(fifopath, O_WRONLY);
ffc0dd30: 38 61 00 08 addi r3,r1,8
ffc0dd34: 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;
ffc0dd38: 54 00 00 3c rlwinm r0,r0,0,0,30
ffc0dd3c: 90 09 00 18 stw r0,24(r9)
int pipe_create(
int filsdes[2]
)
{
rtems_libio_t *iop;
int err = 0;
ffc0dd40: 3b 80 00 00 li r28,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);
ffc0dd44: 4c c6 31 82 crclr 4*cr1+eq
ffc0dd48: 4b ff 89 b5 bl ffc066fc <open>
if (filsdes[1] < 0) {
ffc0dd4c: 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);
ffc0dd50: 90 7d 00 04 stw r3,4(r29)
if (filsdes[1] < 0) {
ffc0dd54: 40 bc 00 14 bge+ cr7,ffc0dd68 <pipe_create+0x110>
err = errno;
ffc0dd58: 48 00 44 3d bl ffc12194 <__errno>
ffc0dd5c: 83 83 00 00 lwz r28,0(r3)
close(filsdes[0]);
ffc0dd60: 80 7d 00 00 lwz r3,0(r29)
ffc0dd64: 4b ff 77 f9 bl ffc0555c <close>
}
unlink(fifopath);
ffc0dd68: 38 61 00 08 addi r3,r1,8
ffc0dd6c: 4b ff aa 09 bl ffc08774 <unlink>
}
if(err != 0)
ffc0dd70: 2f 9c 00 00 cmpwi cr7,r28,0
rtems_set_errno_and_return_minus_one(err);
return 0;
ffc0dd74: 3b c0 00 00 li r30,0
err = errno;
close(filsdes[0]);
}
unlink(fifopath);
}
if(err != 0)
ffc0dd78: 41 be 00 10 beq+ cr7,ffc0dd88 <pipe_create+0x130>
rtems_set_errno_and_return_minus_one(err);
ffc0dd7c: 48 00 44 19 bl ffc12194 <__errno>
ffc0dd80: 3b c0 ff ff li r30,-1
ffc0dd84: 93 83 00 00 stw r28,0(r3)
return 0;
}
ffc0dd88: 39 61 00 28 addi r11,r1,40
ffc0dd8c: 7f c3 f3 78 mr r3,r30
ffc0dd90: 48 00 fc 40 b ffc1d9d0 <_restgpr_28_x>
ffc0f3d0 <pipe_ioctl>:
uint32_t cmd,
void *buffer,
rtems_libio_t *iop
)
{
if (cmd == FIONREAD) {
ffc0f3d0: 6c 89 40 04 xoris r9,r4,16388
pipe_control_t *pipe,
uint32_t cmd,
void *buffer,
rtems_libio_t *iop
)
{
ffc0f3d4: 94 21 ff f0 stwu r1,-16(r1)
if (cmd == FIONREAD) {
ffc0f3d8: 2f 89 66 7f cmpwi cr7,r9,26239
pipe_control_t *pipe,
uint32_t cmd,
void *buffer,
rtems_libio_t *iop
)
{
ffc0f3dc: 7c 08 02 a6 mflr r0
ffc0f3e0: bf c1 00 08 stmw r30,8(r1)
ffc0f3e4: 7c 7f 1b 78 mr r31,r3
ffc0f3e8: 7c be 2b 78 mr r30,r5
ffc0f3ec: 90 01 00 14 stw r0,20(r1)
*(unsigned int *)buffer = pipe->Length;
PIPE_UNLOCK(pipe);
return 0;
}
return -EINVAL;
ffc0f3f0: 38 00 ff ea li r0,-22
uint32_t cmd,
void *buffer,
rtems_libio_t *iop
)
{
if (cmd == FIONREAD) {
ffc0f3f4: 40 9e 00 40 bne- cr7,ffc0f434 <pipe_ioctl+0x64>
if (buffer == NULL)
ffc0f3f8: 2f 85 00 00 cmpwi cr7,r5,0
return -EFAULT;
ffc0f3fc: 38 00 ff f2 li r0,-14
void *buffer,
rtems_libio_t *iop
)
{
if (cmd == FIONREAD) {
if (buffer == NULL)
ffc0f400: 41 9e 00 34 beq- cr7,ffc0f434 <pipe_ioctl+0x64>
return -EFAULT;
if (! PIPE_LOCK(pipe))
ffc0f404: 80 63 00 28 lwz r3,40(r3)
ffc0f408: 38 80 00 00 li r4,0
ffc0f40c: 38 a0 00 00 li r5,0
ffc0f410: 4b ff aa 19 bl ffc09e28 <rtems_semaphore_obtain>
return -EINTR;
ffc0f414: 38 00 ff fc li r0,-4
{
if (cmd == FIONREAD) {
if (buffer == NULL)
return -EFAULT;
if (! PIPE_LOCK(pipe))
ffc0f418: 2f 83 00 00 cmpwi cr7,r3,0
ffc0f41c: 40 9e 00 18 bne- cr7,ffc0f434 <pipe_ioctl+0x64> <== NEVER TAKEN
return -EINTR;
/* Return length of pipe */
*(unsigned int *)buffer = pipe->Length;
ffc0f420: 80 1f 00 0c lwz r0,12(r31)
PIPE_UNLOCK(pipe);
ffc0f424: 80 7f 00 28 lwz r3,40(r31)
if (! PIPE_LOCK(pipe))
return -EINTR;
/* Return length of pipe */
*(unsigned int *)buffer = pipe->Length;
ffc0f428: 90 1e 00 00 stw r0,0(r30)
PIPE_UNLOCK(pipe);
ffc0f42c: 4b ff ab 29 bl ffc09f54 <rtems_semaphore_release>
return 0;
ffc0f430: 38 00 00 00 li r0,0
}
return -EINVAL;
}
ffc0f434: 39 61 00 10 addi r11,r1,16
ffc0f438: 7c 03 03 78 mr r3,r0
ffc0f43c: 48 01 1c b8 b ffc210f4 <_restgpr_30_x>
ffc0f050 <pipe_read>:
pipe_control_t *pipe,
void *buffer,
size_t count,
rtems_libio_t *iop
)
{
ffc0f050: 94 21 ff c8 stwu r1,-56(r1)
ffc0f054: 7c 08 02 a6 mflr r0
ffc0f058: 90 01 00 3c stw r0,60(r1)
ffc0f05c: bf 21 00 1c stmw r25,28(r1)
ffc0f060: 7c 7f 1b 78 mr r31,r3
ffc0f064: 7c 9e 23 78 mr r30,r4
int chunk, chunk1, read = 0, ret = 0;
if (! PIPE_LOCK(pipe))
ffc0f068: 80 63 00 28 lwz r3,40(r3)
pipe_control_t *pipe,
void *buffer,
size_t count,
rtems_libio_t *iop
)
{
ffc0f06c: 7c bd 2b 78 mr r29,r5
int chunk, chunk1, read = 0, ret = 0;
if (! PIPE_LOCK(pipe))
ffc0f070: 38 80 00 00 li r4,0
ffc0f074: 38 a0 00 00 li r5,0
pipe_control_t *pipe,
void *buffer,
size_t count,
rtems_libio_t *iop
)
{
ffc0f078: 7c d9 33 78 mr r25,r6
int chunk, chunk1, read = 0, ret = 0;
if (! PIPE_LOCK(pipe))
ffc0f07c: 4b ff ad ad bl ffc09e28 <rtems_semaphore_obtain>
ffc0f080: 2f 83 00 00 cmpwi cr7,r3,0
return -EINTR;
ffc0f084: 3b 80 ff fc li r28,-4
rtems_libio_t *iop
)
{
int chunk, chunk1, read = 0, ret = 0;
if (! PIPE_LOCK(pipe))
ffc0f088: 40 9e 01 5c bne- cr7,ffc0f1e4 <pipe_read+0x194> <== NEVER TAKEN
ffc0f08c: 3b 80 00 00 li r28,0
ffc0f090: 48 00 01 24 b ffc0f1b4 <pipe_read+0x164>
return -EINTR;
while (read < count) {
while (PIPE_EMPTY(pipe)) {
/* Not an error */
if (pipe->Writers == 0)
ffc0f094: 80 1f 00 14 lwz r0,20(r31)
ffc0f098: 2f 80 00 00 cmpwi cr7,r0,0
ffc0f09c: 41 9e 01 20 beq- cr7,ffc0f1bc <pipe_read+0x16c>
goto out_locked;
if (LIBIO_NODELAY(iop)) {
ffc0f0a0: 80 19 00 18 lwz r0,24(r25)
ffc0f0a4: 70 09 00 01 andi. r9,r0,1
ffc0f0a8: 40 82 01 1c bne- ffc0f1c4 <pipe_read+0x174>
ret = -EAGAIN;
goto out_locked;
}
/* Wait until pipe is no more empty or no writer exists */
pipe->waitingReaders ++;
ffc0f0ac: 81 3f 00 18 lwz r9,24(r31)
PIPE_UNLOCK(pipe);
if (! PIPE_READWAIT(pipe))
ret = -EINTR;
ffc0f0b0: 3b 60 ff fc li r27,-4
goto out_locked;
}
/* Wait until pipe is no more empty or no writer exists */
pipe->waitingReaders ++;
PIPE_UNLOCK(pipe);
ffc0f0b4: 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 ++;
ffc0f0b8: 38 09 00 01 addi r0,r9,1
ffc0f0bc: 90 1f 00 18 stw r0,24(r31)
PIPE_UNLOCK(pipe);
ffc0f0c0: 4b ff ae 95 bl ffc09f54 <rtems_semaphore_release>
if (! PIPE_READWAIT(pipe))
ffc0f0c4: 80 7f 00 2c lwz r3,44(r31)
ffc0f0c8: 38 80 00 00 li r4,0
ffc0f0cc: 48 00 18 6d bl ffc10938 <rtems_barrier_wait>
ffc0f0d0: 2f 83 00 00 cmpwi cr7,r3,0
ffc0f0d4: 40 9e 00 08 bne- cr7,ffc0f0dc <pipe_read+0x8c> <== NEVER TAKEN
ffc0f0d8: 3b 60 00 00 li r27,0
ret = -EINTR;
if (! PIPE_LOCK(pipe)) {
ffc0f0dc: 80 7f 00 28 lwz r3,40(r31)
ffc0f0e0: 38 80 00 00 li r4,0
ffc0f0e4: 38 a0 00 00 li r5,0
ffc0f0e8: 4b ff ad 41 bl ffc09e28 <rtems_semaphore_obtain>
ffc0f0ec: 2f 83 00 00 cmpwi cr7,r3,0
ffc0f0f0: 40 9e 00 e4 bne- cr7,ffc0f1d4 <pipe_read+0x184> <== NEVER TAKEN
/* WARN waitingReaders not restored! */
ret = -EINTR;
goto out_nolock;
}
pipe->waitingReaders --;
if (ret != 0)
ffc0f0f4: 2f 9b 00 00 cmpwi cr7,r27,0
if (! PIPE_LOCK(pipe)) {
/* WARN waitingReaders not restored! */
ret = -EINTR;
goto out_nolock;
}
pipe->waitingReaders --;
ffc0f0f8: 81 3f 00 18 lwz r9,24(r31)
ffc0f0fc: 38 09 ff ff addi r0,r9,-1
ffc0f100: 90 1f 00 18 stw r0,24(r31)
if (ret != 0)
ffc0f104: 40 9e 00 c4 bne- cr7,ffc0f1c8 <pipe_read+0x178> <== NEVER TAKEN
if (! PIPE_LOCK(pipe))
return -EINTR;
while (read < count) {
while (PIPE_EMPTY(pipe)) {
ffc0f108: 83 7f 00 0c lwz r27,12(r31)
ffc0f10c: 2f 9b 00 00 cmpwi cr7,r27,0
ffc0f110: 41 9e ff 84 beq+ cr7,ffc0f094 <pipe_read+0x44>
if (ret != 0)
goto out_locked;
}
/* Read chunk bytes */
chunk = MIN(count - read, pipe->Length);
ffc0f114: 7c 1c e8 50 subf r0,r28,r29
ffc0f118: 7f 9b 00 40 cmplw cr7,r27,r0
ffc0f11c: 40 9d 00 08 ble- cr7,ffc0f124 <pipe_read+0xd4>
ffc0f120: 7c 1b 03 78 mr r27,r0
chunk1 = pipe->Size - pipe->Start;
ffc0f124: 80 1f 00 08 lwz r0,8(r31)
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);
ffc0f128: 7f 65 db 78 mr r5,r27
goto out_locked;
}
/* Read chunk bytes */
chunk = MIN(count - read, pipe->Length);
chunk1 = pipe->Size - pipe->Start;
ffc0f12c: 83 5f 00 04 lwz r26,4(r31)
ffc0f130: 7c 7e e2 14 add r3,r30,r28
ffc0f134: 80 9f 00 00 lwz r4,0(r31)
ffc0f138: 7f 40 d0 50 subf r26,r0,r26
if (chunk > chunk1) {
ffc0f13c: 7f 9b d0 00 cmpw cr7,r27,r26
memcpy(buffer + read, pipe->Buffer + pipe->Start, chunk1);
ffc0f140: 7c 84 02 14 add r4,r4,r0
}
/* Read chunk bytes */
chunk = MIN(count - read, pipe->Length);
chunk1 = pipe->Size - pipe->Start;
if (chunk > chunk1) {
ffc0f144: 40 9d 00 1c ble- cr7,ffc0f160 <pipe_read+0x110>
memcpy(buffer + read, pipe->Buffer + pipe->Start, chunk1);
ffc0f148: 7f 45 d3 78 mr r5,r26
ffc0f14c: 48 00 4d 15 bl ffc13e60 <memcpy>
memcpy(buffer + read + chunk1, pipe->Buffer, chunk - chunk1);
ffc0f150: 7c 7c d2 14 add r3,r28,r26
ffc0f154: 80 9f 00 00 lwz r4,0(r31)
ffc0f158: 7c 7e 1a 14 add r3,r30,r3
ffc0f15c: 7c ba d8 50 subf r5,r26,r27
}
else
memcpy(buffer + read, pipe->Buffer + pipe->Start, chunk);
ffc0f160: 48 00 4d 01 bl ffc13e60 <memcpy>
pipe->Start += chunk;
ffc0f164: 80 1f 00 08 lwz r0,8(r31)
pipe->Start %= pipe->Size;
ffc0f168: 81 3f 00 04 lwz r9,4(r31)
memcpy(buffer + read + chunk1, pipe->Buffer, chunk - chunk1);
}
else
memcpy(buffer + read, pipe->Buffer + pipe->Start, chunk);
pipe->Start += chunk;
ffc0f16c: 7c 1b 02 14 add r0,r27,r0
pipe->Start %= pipe->Size;
ffc0f170: 7d 60 4b 96 divwu r11,r0,r9
ffc0f174: 7d 2b 49 d6 mullw r9,r11,r9
ffc0f178: 7c 09 00 50 subf r0,r9,r0
ffc0f17c: 90 1f 00 08 stw r0,8(r31)
pipe->Length -= chunk;
ffc0f180: 80 1f 00 0c lwz r0,12(r31)
ffc0f184: 7c 1b 00 50 subf r0,r27,r0
/* For buffering optimization */
if (PIPE_EMPTY(pipe))
ffc0f188: 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;
ffc0f18c: 90 1f 00 0c stw r0,12(r31)
/* For buffering optimization */
if (PIPE_EMPTY(pipe))
ffc0f190: 40 9e 00 08 bne- cr7,ffc0f198 <pipe_read+0x148>
pipe->Start = 0;
ffc0f194: 90 1f 00 08 stw r0,8(r31)
if (pipe->waitingWriters > 0)
ffc0f198: 80 1f 00 1c lwz r0,28(r31)
ffc0f19c: 2f 80 00 00 cmpwi cr7,r0,0
ffc0f1a0: 41 be 00 10 beq+ cr7,ffc0f1b0 <pipe_read+0x160>
PIPE_WAKEUPWRITERS(pipe);
ffc0f1a4: 80 7f 00 30 lwz r3,48(r31)
ffc0f1a8: 38 81 00 08 addi r4,r1,8
ffc0f1ac: 48 00 17 21 bl ffc108cc <rtems_barrier_release>
read += chunk;
ffc0f1b0: 7f 9c da 14 add r28,r28,r27
int chunk, chunk1, read = 0, ret = 0;
if (! PIPE_LOCK(pipe))
return -EINTR;
while (read < count) {
ffc0f1b4: 7f 9c e8 40 cmplw cr7,r28,r29
ffc0f1b8: 41 9c ff 50 blt+ cr7,ffc0f108 <pipe_read+0xb8>
while (PIPE_EMPTY(pipe)) {
/* Not an error */
if (pipe->Writers == 0)
ffc0f1bc: 3b 60 00 00 li r27,0
ffc0f1c0: 48 00 00 08 b ffc0f1c8 <pipe_read+0x178>
goto out_locked;
if (LIBIO_NODELAY(iop)) {
ret = -EAGAIN;
ffc0f1c4: 3b 60 ff f5 li r27,-11
PIPE_WAKEUPWRITERS(pipe);
read += chunk;
}
out_locked:
PIPE_UNLOCK(pipe);
ffc0f1c8: 80 7f 00 28 lwz r3,40(r31)
ffc0f1cc: 4b ff ad 89 bl ffc09f54 <rtems_semaphore_release>
ffc0f1d0: 48 00 00 08 b ffc0f1d8 <pipe_read+0x188>
PIPE_UNLOCK(pipe);
if (! PIPE_READWAIT(pipe))
ret = -EINTR;
if (! PIPE_LOCK(pipe)) {
/* WARN waitingReaders not restored! */
ret = -EINTR;
ffc0f1d4: 3b 60 ff fc li r27,-4 <== NOT EXECUTED
out_locked:
PIPE_UNLOCK(pipe);
out_nolock:
if (read > 0)
ffc0f1d8: 2f 9c 00 00 cmpwi cr7,r28,0
ffc0f1dc: 41 bd 00 08 bgt+ cr7,ffc0f1e4 <pipe_read+0x194>
return read;
return ret;
ffc0f1e0: 7f 7c db 78 mr r28,r27
}
ffc0f1e4: 39 61 00 38 addi r11,r1,56
ffc0f1e8: 7f 83 e3 78 mr r3,r28
ffc0f1ec: 48 01 1e f4 b ffc210e0 <_restgpr_25_x>
ffc0eb80 <pipe_release>:
*/
void pipe_release(
pipe_control_t **pipep,
rtems_libio_t *iop
)
{
ffc0eb80: 94 21 ff d8 stwu r1,-40(r1)
ffc0eb84: 7c 08 02 a6 mflr r0
ffc0eb88: 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);
ffc0eb8c: 80 04 00 18 lwz r0,24(r4)
*/
void pipe_release(
pipe_control_t **pipep,
rtems_libio_t *iop
)
{
ffc0eb90: bf 81 00 18 stmw r28,24(r1)
ffc0eb94: 7c 7e 1b 78 mr r30,r3
if (!PIPE_LOCK(pipe))
rtems_fatal_error_occurred(0xdeadbeef);
#endif
mode = LIBIO_ACCMODE(iop);
if (mode & LIBIO_FLAGS_READ)
ffc0eb98: 70 09 00 02 andi. r9,r0,2
void pipe_release(
pipe_control_t **pipep,
rtems_libio_t *iop
)
{
pipe_control_t *pipe = *pipep;
ffc0eb9c: 83 e3 00 00 lwz r31,0(r3)
/* WARN pipe not released! */
if (!PIPE_LOCK(pipe))
rtems_fatal_error_occurred(0xdeadbeef);
#endif
mode = LIBIO_ACCMODE(iop);
ffc0eba0: 54 1d 07 7c rlwinm r29,r0,0,29,30
if (mode & LIBIO_FLAGS_READ)
ffc0eba4: 41 82 00 10 beq- ffc0ebb4 <pipe_release+0x34>
pipe->Readers --;
ffc0eba8: 81 3f 00 10 lwz r9,16(r31)
ffc0ebac: 38 09 ff ff addi r0,r9,-1
ffc0ebb0: 90 1f 00 10 stw r0,16(r31)
if (mode & LIBIO_FLAGS_WRITE)
ffc0ebb4: 73 a0 00 04 andi. r0,r29,4
ffc0ebb8: 41 82 00 10 beq- ffc0ebc8 <pipe_release+0x48>
pipe->Writers --;
ffc0ebbc: 81 3f 00 14 lwz r9,20(r31)
ffc0ebc0: 38 09 ff ff addi r0,r9,-1
ffc0ebc4: 90 1f 00 14 stw r0,20(r31)
PIPE_UNLOCK(pipe);
ffc0ebc8: 80 7f 00 28 lwz r3,40(r31)
ffc0ebcc: 4b ff b3 89 bl ffc09f54 <rtems_semaphore_release>
if (pipe->Readers == 0 && pipe->Writers == 0) {
ffc0ebd0: 80 1f 00 10 lwz r0,16(r31)
ffc0ebd4: 2f 80 00 00 cmpwi cr7,r0,0
ffc0ebd8: 40 9e 00 30 bne- cr7,ffc0ec08 <pipe_release+0x88>
ffc0ebdc: 83 9f 00 14 lwz r28,20(r31)
ffc0ebe0: 2f 9c 00 00 cmpwi cr7,r28,0
ffc0ebe4: 40 be 00 14 bne+ cr7,ffc0ebf8 <pipe_release+0x78>
#if 0
/* To delete an anonymous pipe file when all users closed it */
if (pipe->Anonymous)
delfile = TRUE;
#endif
pipe_free(pipe);
ffc0ebe8: 7f e3 fb 78 mr r3,r31
ffc0ebec: 4b ff ff 4d bl ffc0eb38 <pipe_free>
*pipep = NULL;
ffc0ebf0: 93 9e 00 00 stw r28,0(r30)
ffc0ebf4: 48 00 00 34 b ffc0ec28 <pipe_release+0xa8>
}
else if (pipe->Readers == 0 && mode != LIBIO_FLAGS_WRITE)
ffc0ebf8: 2f 9d 00 04 cmpwi cr7,r29,4
ffc0ebfc: 41 be 00 0c beq+ cr7,ffc0ec08 <pipe_release+0x88> <== NEVER TAKEN
/* Notify waiting Writers that all their partners left */
PIPE_WAKEUPWRITERS(pipe);
ffc0ec00: 80 7f 00 30 lwz r3,48(r31)
ffc0ec04: 48 00 00 1c b ffc0ec20 <pipe_release+0xa0>
else if (pipe->Writers == 0 && mode != LIBIO_FLAGS_READ)
ffc0ec08: 80 1f 00 14 lwz r0,20(r31)
ffc0ec0c: 2f 80 00 00 cmpwi cr7,r0,0
ffc0ec10: 40 9e 00 18 bne- cr7,ffc0ec28 <pipe_release+0xa8> <== NEVER TAKEN
ffc0ec14: 2f 9d 00 02 cmpwi cr7,r29,2
ffc0ec18: 41 9e 00 10 beq- cr7,ffc0ec28 <pipe_release+0xa8> <== NEVER TAKEN
PIPE_WAKEUPREADERS(pipe);
ffc0ec1c: 80 7f 00 2c lwz r3,44(r31)
ffc0ec20: 38 81 00 08 addi r4,r1,8
ffc0ec24: 48 00 1c a9 bl ffc108cc <rtems_barrier_release>
static void pipe_unlock(void)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
sc = rtems_semaphore_release(pipe_semaphore);
ffc0ec28: 3d 20 00 00 lis r9,0
ffc0ec2c: 80 69 29 f8 lwz r3,10744(r9)
ffc0ec30: 4b ff b3 25 bl ffc09f54 <rtems_semaphore_release>
iop->flags &= ~LIBIO_FLAGS_OPEN;
if(iop->pathinfo.ops->unlink_h(&iop->pathinfo))
return;
#endif
}
ffc0ec34: 39 61 00 28 addi r11,r1,40
ffc0ec38: 48 01 24 b4 b ffc210ec <_restgpr_28_x>
ffc0f1f0 <pipe_write>:
pipe_control_t *pipe,
const void *buffer,
size_t count,
rtems_libio_t *iop
)
{
ffc0f1f0: 94 21 ff c8 stwu r1,-56(r1)
ffc0f1f4: 7c 08 02 a6 mflr r0
ffc0f1f8: bf 01 00 18 stmw r24,24(r1)
int chunk, chunk1, written = 0, ret = 0;
/* Write nothing */
if (count == 0)
ffc0f1fc: 7c bb 2b 79 mr. r27,r5
pipe_control_t *pipe,
const void *buffer,
size_t count,
rtems_libio_t *iop
)
{
ffc0f200: 7c 7f 1b 78 mr r31,r3
ffc0f204: 90 01 00 3c stw r0,60(r1)
ffc0f208: 7c 9e 23 78 mr r30,r4
ffc0f20c: 7c d8 33 78 mr r24,r6
int chunk, chunk1, written = 0, ret = 0;
/* Write nothing */
if (count == 0)
return 0;
ffc0f210: 3b a0 00 00 li r29,0
)
{
int chunk, chunk1, written = 0, ret = 0;
/* Write nothing */
if (count == 0)
ffc0f214: 41 a2 01 b0 beq+ ffc0f3c4 <pipe_write+0x1d4> <== NEVER TAKEN
return 0;
if (! PIPE_LOCK(pipe))
ffc0f218: 80 63 00 28 lwz r3,40(r3)
ffc0f21c: 38 80 00 00 li r4,0
ffc0f220: 38 a0 00 00 li r5,0
ffc0f224: 4b ff ac 05 bl ffc09e28 <rtems_semaphore_obtain>
return -EINTR;
ffc0f228: 3b a0 ff fc li r29,-4
/* Write nothing */
if (count == 0)
return 0;
if (! PIPE_LOCK(pipe))
ffc0f22c: 2f 83 00 00 cmpwi cr7,r3,0
ffc0f230: 40 9e 01 94 bne- cr7,ffc0f3c4 <pipe_write+0x1d4> <== NEVER TAKEN
return -EINTR;
if (pipe->Readers == 0) {
ffc0f234: 80 1f 00 10 lwz r0,16(r31)
ffc0f238: 2f 80 00 00 cmpwi cr7,r0,0
ffc0f23c: 41 9e 01 40 beq- cr7,ffc0f37c <pipe_write+0x18c>
ret = -EPIPE;
goto out_locked;
}
/* Write of PIPE_BUF bytes or less shall not be interleaved */
chunk = count <= pipe->Size ? count : 1;
ffc0f240: 80 1f 00 04 lwz r0,4(r31)
ffc0f244: 3b 20 00 01 li r25,1
ffc0f248: 7f 9b 00 40 cmplw cr7,r27,r0
ffc0f24c: 41 9d 00 08 bgt- cr7,ffc0f254 <pipe_write+0x64> <== NEVER TAKEN
ffc0f250: 7f 79 db 78 mr r25,r27
/* Wait until there is chunk bytes space or no reader exists */
pipe->waitingWriters ++;
PIPE_UNLOCK(pipe);
if (! PIPE_WRITEWAIT(pipe))
ret = -EINTR;
ffc0f254: 3b a0 00 00 li r29,0
ffc0f258: 48 00 01 14 b ffc0f36c <pipe_write+0x17c>
/* Write of PIPE_BUF bytes or less shall not be interleaved */
chunk = count <= pipe->Size ? count : 1;
while (written < count) {
while (PIPE_SPACE(pipe) < chunk) {
if (LIBIO_NODELAY(iop)) {
ffc0f25c: 80 18 00 18 lwz r0,24(r24)
ffc0f260: 70 09 00 01 andi. r9,r0,1
ffc0f264: 40 82 01 24 bne- ffc0f388 <pipe_write+0x198>
ret = -EAGAIN;
goto out_locked;
}
/* Wait until there is chunk bytes space or no reader exists */
pipe->waitingWriters ++;
ffc0f268: 81 3f 00 1c lwz r9,28(r31)
PIPE_UNLOCK(pipe);
if (! PIPE_WRITEWAIT(pipe))
ret = -EINTR;
ffc0f26c: 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);
ffc0f270: 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 ++;
ffc0f274: 38 09 00 01 addi r0,r9,1
ffc0f278: 90 1f 00 1c stw r0,28(r31)
PIPE_UNLOCK(pipe);
ffc0f27c: 4b ff ac d9 bl ffc09f54 <rtems_semaphore_release>
if (! PIPE_WRITEWAIT(pipe))
ffc0f280: 80 7f 00 30 lwz r3,48(r31)
ffc0f284: 38 80 00 00 li r4,0
ffc0f288: 48 00 16 b1 bl ffc10938 <rtems_barrier_wait>
ffc0f28c: 2f 83 00 00 cmpwi cr7,r3,0
ffc0f290: 40 9e 00 08 bne- cr7,ffc0f298 <pipe_write+0xa8> <== NEVER TAKEN
ffc0f294: 3b 80 00 00 li r28,0
ret = -EINTR;
if (! PIPE_LOCK(pipe)) {
ffc0f298: 80 7f 00 28 lwz r3,40(r31)
ffc0f29c: 38 80 00 00 li r4,0
ffc0f2a0: 38 a0 00 00 li r5,0
ffc0f2a4: 4b ff ab 85 bl ffc09e28 <rtems_semaphore_obtain>
ffc0f2a8: 2f 83 00 00 cmpwi cr7,r3,0
ffc0f2ac: 40 9e 01 08 bne- cr7,ffc0f3b4 <pipe_write+0x1c4> <== NEVER TAKEN
/* WARN waitingWriters not restored! */
ret = -EINTR;
goto out_nolock;
}
pipe->waitingWriters --;
if (ret != 0)
ffc0f2b0: 2f 9c 00 00 cmpwi cr7,r28,0
if (! PIPE_LOCK(pipe)) {
/* WARN waitingWriters not restored! */
ret = -EINTR;
goto out_nolock;
}
pipe->waitingWriters --;
ffc0f2b4: 81 3f 00 1c lwz r9,28(r31)
ffc0f2b8: 38 09 ff ff addi r0,r9,-1
ffc0f2bc: 90 1f 00 1c stw r0,28(r31)
if (ret != 0)
ffc0f2c0: 40 9e 00 d4 bne- cr7,ffc0f394 <pipe_write+0x1a4> <== NEVER TAKEN
goto out_locked;
if (pipe->Readers == 0) {
ffc0f2c4: 80 1f 00 10 lwz r0,16(r31)
ffc0f2c8: 2f 80 00 00 cmpwi cr7,r0,0
ffc0f2cc: 41 9e 00 c4 beq- cr7,ffc0f390 <pipe_write+0x1a0> <== NEVER TAKEN
/* Write of PIPE_BUF bytes or less shall not be interleaved */
chunk = count <= pipe->Size ? count : 1;
while (written < count) {
while (PIPE_SPACE(pipe) < chunk) {
ffc0f2d0: 83 5f 00 04 lwz r26,4(r31)
ffc0f2d4: 80 1f 00 0c lwz r0,12(r31)
ffc0f2d8: 7f 80 d0 50 subf r28,r0,r26
ffc0f2dc: 7f 9c c8 40 cmplw cr7,r28,r25
ffc0f2e0: 41 9c ff 7c blt+ cr7,ffc0f25c <pipe_write+0x6c>
ret = -EPIPE;
goto out_locked;
}
}
chunk = MIN(count - written, PIPE_SPACE(pipe));
ffc0f2e4: 7d 3d d8 50 subf r9,r29,r27
ffc0f2e8: 7f 9c 48 40 cmplw cr7,r28,r9
ffc0f2ec: 40 9d 00 08 ble- cr7,ffc0f2f4 <pipe_write+0x104>
ffc0f2f0: 7d 3c 4b 78 mr r28,r9
chunk1 = pipe->Size - PIPE_WSTART(pipe);
ffc0f2f4: 81 3f 00 08 lwz r9,8(r31)
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);
ffc0f2f8: 7f 85 e3 78 mr r5,r28
ffc0f2fc: 80 7f 00 00 lwz r3,0(r31)
ffc0f300: 7c 9e ea 14 add r4,r30,r29
goto out_locked;
}
}
chunk = MIN(count - written, PIPE_SPACE(pipe));
chunk1 = pipe->Size - PIPE_WSTART(pipe);
ffc0f304: 7d 20 4a 14 add r9,r0,r9
ffc0f308: 7c 09 d3 96 divwu r0,r9,r26
ffc0f30c: 7c 00 d1 d6 mullw r0,r0,r26
ffc0f310: 7c 00 48 50 subf r0,r0,r9
ffc0f314: 7f 40 d0 50 subf r26,r0,r26
if (chunk > chunk1) {
ffc0f318: 7f 9c d0 00 cmpw cr7,r28,r26
memcpy(pipe->Buffer + PIPE_WSTART(pipe), buffer + written, chunk1);
ffc0f31c: 7c 63 02 14 add r3,r3,r0
}
}
chunk = MIN(count - written, PIPE_SPACE(pipe));
chunk1 = pipe->Size - PIPE_WSTART(pipe);
if (chunk > chunk1) {
ffc0f320: 40 9d 00 1c ble- cr7,ffc0f33c <pipe_write+0x14c>
memcpy(pipe->Buffer + PIPE_WSTART(pipe), buffer + written, chunk1);
ffc0f324: 7f 45 d3 78 mr r5,r26
ffc0f328: 48 00 4b 39 bl ffc13e60 <memcpy>
memcpy(pipe->Buffer, buffer + written + chunk1, chunk - chunk1);
ffc0f32c: 7c 9a ea 14 add r4,r26,r29
ffc0f330: 80 7f 00 00 lwz r3,0(r31)
ffc0f334: 7c 9e 22 14 add r4,r30,r4
ffc0f338: 7c ba e0 50 subf r5,r26,r28
}
else
memcpy(pipe->Buffer + PIPE_WSTART(pipe), buffer + written, chunk);
ffc0f33c: 48 00 4b 25 bl ffc13e60 <memcpy>
pipe->Length += chunk;
ffc0f340: 80 1f 00 0c lwz r0,12(r31)
ffc0f344: 7c 00 e2 14 add r0,r0,r28
ffc0f348: 90 1f 00 0c stw r0,12(r31)
if (pipe->waitingReaders > 0)
ffc0f34c: 80 1f 00 18 lwz r0,24(r31)
ffc0f350: 2f 80 00 00 cmpwi cr7,r0,0
ffc0f354: 41 be 00 10 beq+ cr7,ffc0f364 <pipe_write+0x174>
PIPE_WAKEUPREADERS(pipe);
ffc0f358: 80 7f 00 2c lwz r3,44(r31)
ffc0f35c: 38 81 00 08 addi r4,r1,8
ffc0f360: 48 00 15 6d bl ffc108cc <rtems_barrier_release>
written += chunk;
ffc0f364: 7f bd e2 14 add r29,r29,r28
/* Write of more than PIPE_BUF bytes can be interleaved */
chunk = 1;
ffc0f368: 3b 20 00 01 li r25,1
}
/* Write of PIPE_BUF bytes or less shall not be interleaved */
chunk = count <= pipe->Size ? count : 1;
while (written < count) {
ffc0f36c: 7f 9d d8 40 cmplw cr7,r29,r27
ffc0f370: 41 9c ff 60 blt+ cr7,ffc0f2d0 <pipe_write+0xe0>
ffc0f374: 3b 80 00 00 li r28,0
ffc0f378: 48 00 00 1c b ffc0f394 <pipe_write+0x1a4>
if (! PIPE_LOCK(pipe))
return -EINTR;
if (pipe->Readers == 0) {
ret = -EPIPE;
ffc0f37c: 3b 80 ff e0 li r28,-32
const void *buffer,
size_t count,
rtems_libio_t *iop
)
{
int chunk, chunk1, written = 0, ret = 0;
ffc0f380: 3b a0 00 00 li r29,0
ffc0f384: 48 00 00 10 b ffc0f394 <pipe_write+0x1a4>
chunk = count <= pipe->Size ? count : 1;
while (written < count) {
while (PIPE_SPACE(pipe) < chunk) {
if (LIBIO_NODELAY(iop)) {
ret = -EAGAIN;
ffc0f388: 3b 80 ff f5 li r28,-11
ffc0f38c: 48 00 00 08 b ffc0f394 <pipe_write+0x1a4>
pipe->waitingWriters --;
if (ret != 0)
goto out_locked;
if (pipe->Readers == 0) {
ret = -EPIPE;
ffc0f390: 3b 80 ff e0 li r28,-32 <== NOT EXECUTED
/* Write of more than PIPE_BUF bytes can be interleaved */
chunk = 1;
}
out_locked:
PIPE_UNLOCK(pipe);
ffc0f394: 80 7f 00 28 lwz r3,40(r31)
ffc0f398: 4b ff ab bd bl ffc09f54 <rtems_semaphore_release>
out_nolock:
#ifdef RTEMS_POSIX_API
/* Signal SIGPIPE */
if (ret == -EPIPE)
ffc0f39c: 2f 9c ff e0 cmpwi cr7,r28,-32
ffc0f3a0: 40 be 00 18 bne+ cr7,ffc0f3b8 <pipe_write+0x1c8>
kill(getpid(), SIGPIPE);
ffc0f3a4: 48 00 08 5d bl ffc0fc00 <getpid>
ffc0f3a8: 38 80 00 0d li r4,13
ffc0f3ac: 48 00 0b c5 bl ffc0ff70 <kill>
ffc0f3b0: 48 00 00 08 b ffc0f3b8 <pipe_write+0x1c8>
PIPE_UNLOCK(pipe);
if (! PIPE_WRITEWAIT(pipe))
ret = -EINTR;
if (! PIPE_LOCK(pipe)) {
/* WARN waitingWriters not restored! */
ret = -EINTR;
ffc0f3b4: 3b 80 ff fc li r28,-4 <== NOT EXECUTED
/* Signal SIGPIPE */
if (ret == -EPIPE)
kill(getpid(), SIGPIPE);
#endif
if (written > 0)
ffc0f3b8: 2f 9d 00 00 cmpwi cr7,r29,0
ffc0f3bc: 41 bd 00 08 bgt+ cr7,ffc0f3c4 <pipe_write+0x1d4>
ffc0f3c0: 7f 9d e3 78 mr r29,r28
return written;
return ret;
}
ffc0f3c4: 39 61 00 38 addi r11,r1,56
ffc0f3c8: 7f a3 eb 78 mr r3,r29
ffc0f3cc: 48 01 1d 10 b ffc210dc <_restgpr_24_x>
ffc089b0 <posix_memalign>:
int posix_memalign(
void **pointer,
size_t alignment,
size_t size
)
{
ffc089b0: 94 21 ff f8 stwu r1,-8(r1)
ffc089b4: 7c 08 02 a6 mflr r0
/*
* Update call statistics
*/
MSBUMP(memalign_calls, 1);
ffc089b8: 3d 60 00 00 lis r11,0
int posix_memalign(
void **pointer,
size_t alignment,
size_t size
)
{
ffc089bc: 90 01 00 0c stw r0,12(r1)
/*
* Update call statistics
*/
MSBUMP(memalign_calls, 1);
ffc089c0: 39 6b 34 68 addi r11,r11,13416
ffc089c4: 81 4b 00 08 lwz r10,8(r11)
ffc089c8: 38 0a 00 01 addi r0,r10,1
ffc089cc: 90 0b 00 08 stw r0,8(r11)
if (((alignment - 1) & alignment) != 0 || (alignment < sizeof(void *)))
ffc089d0: 39 64 ff ff addi r11,r4,-1
ffc089d4: 7d 6a 20 39 and. r10,r11,r4
return EINVAL;
ffc089d8: 38 00 00 16 li r0,22
/*
* Update call statistics
*/
MSBUMP(memalign_calls, 1);
if (((alignment - 1) & alignment) != 0 || (alignment < sizeof(void *)))
ffc089dc: 40 a2 00 14 bne+ ffc089f0 <posix_memalign+0x40> <== NEVER TAKEN
ffc089e0: 2b 84 00 03 cmplwi cr7,r4,3
ffc089e4: 40 bd 00 0c ble+ cr7,ffc089f0 <posix_memalign+0x40>
/*
* rtems_memalign does all of the error checking work EXCEPT
* for adding restrictionso on the alignment.
*/
return rtems_memalign( pointer, alignment, size );
ffc089e8: 48 00 02 e9 bl ffc08cd0 <rtems_memalign>
ffc089ec: 7c 60 1b 78 mr r0,r3
}
ffc089f0: 7c 03 03 78 mr r3,r0
ffc089f4: 80 01 00 0c lwz r0,12(r1)
ffc089f8: 38 21 00 08 addi r1,r1,8
ffc089fc: 7c 08 03 a6 mtlr r0
ffc08a00: 4e 80 00 20 blr
ffc05890 <printk>:
* printk
*
* Kernel printf function requiring minimal infrastructure.
*/
void printk(const char *fmt, ...)
{
ffc05890: 94 21 ff 88 stwu r1,-120(r1)
ffc05894: 7c 08 02 a6 mflr r0
ffc05898: 90 81 00 1c stw r4,28(r1)
ffc0589c: 90 01 00 7c stw r0,124(r1)
ffc058a0: 90 a1 00 20 stw r5,32(r1)
ffc058a4: 90 c1 00 24 stw r6,36(r1)
ffc058a8: 90 e1 00 28 stw r7,40(r1)
ffc058ac: 91 01 00 2c stw r8,44(r1)
ffc058b0: 91 21 00 30 stw r9,48(r1)
ffc058b4: 91 41 00 34 stw r10,52(r1)
ffc058b8: 40 86 00 24 bne- cr1,ffc058dc <printk+0x4c> <== ALWAYS TAKEN
ffc058bc: d8 21 00 38 stfd f1,56(r1) <== NOT EXECUTED
ffc058c0: d8 41 00 40 stfd f2,64(r1) <== NOT EXECUTED
ffc058c4: d8 61 00 48 stfd f3,72(r1) <== NOT EXECUTED
ffc058c8: d8 81 00 50 stfd f4,80(r1) <== NOT EXECUTED
ffc058cc: d8 a1 00 58 stfd f5,88(r1) <== NOT EXECUTED
ffc058d0: d8 c1 00 60 stfd f6,96(r1) <== NOT EXECUTED
ffc058d4: d8 e1 00 68 stfd f7,104(r1) <== NOT EXECUTED
ffc058d8: 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 */
ffc058dc: 38 00 00 01 li r0,1
ffc058e0: 98 01 00 08 stb r0,8(r1)
ffc058e4: 38 00 00 00 li r0,0
vprintk(fmt, ap);
ffc058e8: 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 */
ffc058ec: 98 01 00 09 stb r0,9(r1)
ffc058f0: 38 01 00 80 addi r0,r1,128
ffc058f4: 90 01 00 0c stw r0,12(r1)
ffc058f8: 38 01 00 18 addi r0,r1,24
ffc058fc: 90 01 00 10 stw r0,16(r1)
vprintk(fmt, ap);
ffc05900: 48 00 1d 31 bl ffc07630 <vprintk>
va_end(ap); /* clean up when done */
}
ffc05904: 80 01 00 7c lwz r0,124(r1)
ffc05908: 38 21 00 78 addi r1,r1,120
ffc0590c: 7c 08 03 a6 mtlr r0
ffc05910: 4e 80 00 20 blr
ffc0696c <printk_plugin>:
int printk_plugin(
void *ignored __attribute__((unused)),
const char *format,
...
)
{
ffc0696c: 94 21 ff 90 stwu r1,-112(r1)
ffc06970: 7c 08 02 a6 mflr r0
ffc06974: 90 a1 00 18 stw r5,24(r1)
ffc06978: 90 01 00 74 stw r0,116(r1)
ffc0697c: 90 c1 00 1c stw r6,28(r1)
ffc06980: 90 e1 00 20 stw r7,32(r1)
ffc06984: 91 01 00 24 stw r8,36(r1)
ffc06988: 91 21 00 28 stw r9,40(r1)
ffc0698c: 91 41 00 2c stw r10,44(r1)
ffc06990: 40 86 00 24 bne- cr1,ffc069b4 <printk_plugin+0x48> <== ALWAYS TAKEN
ffc06994: d8 21 00 30 stfd f1,48(r1) <== NOT EXECUTED
ffc06998: d8 41 00 38 stfd f2,56(r1) <== NOT EXECUTED
ffc0699c: d8 61 00 40 stfd f3,64(r1) <== NOT EXECUTED
ffc069a0: d8 81 00 48 stfd f4,72(r1) <== NOT EXECUTED
ffc069a4: d8 a1 00 50 stfd f5,80(r1) <== NOT EXECUTED
ffc069a8: d8 c1 00 58 stfd f6,88(r1) <== NOT EXECUTED
ffc069ac: d8 e1 00 60 stfd f7,96(r1) <== NOT EXECUTED
ffc069b0: d9 01 00 68 stfd f8,104(r1) <== NOT EXECUTED
va_list arg_pointer;
va_start (arg_pointer, format);
ffc069b4: 38 00 00 02 li r0,2
ffc069b8: 98 01 00 08 stb r0,8(r1)
ffc069bc: 38 00 00 00 li r0,0
vprintk( format, arg_pointer );
ffc069c0: 7c 83 23 78 mr r3,r4
...
)
{
va_list arg_pointer;
va_start (arg_pointer, format);
ffc069c4: 98 01 00 09 stb r0,9(r1)
ffc069c8: 38 01 00 78 addi r0,r1,120
vprintk( format, arg_pointer );
ffc069cc: 38 81 00 08 addi r4,r1,8
...
)
{
va_list arg_pointer;
va_start (arg_pointer, format);
ffc069d0: 90 01 00 0c stw r0,12(r1)
ffc069d4: 38 01 00 10 addi r0,r1,16
ffc069d8: 90 01 00 10 stw r0,16(r1)
vprintk( format, arg_pointer );
ffc069dc: 48 00 1d 35 bl ffc08710 <vprintk>
va_end(arg_pointer); /* clean up when done */
return 0;
}
ffc069e0: 38 60 00 00 li r3,0
ffc069e4: 80 01 00 74 lwz r0,116(r1)
ffc069e8: 38 21 00 70 addi r1,r1,112
ffc069ec: 7c 08 03 a6 mtlr r0
ffc069f0: 4e 80 00 20 blr
ffc0d59c <pthread_attr_setschedpolicy>:
int pthread_attr_setschedpolicy(
pthread_attr_t *attr,
int policy
)
{
if ( !attr || !attr->is_initialized )
ffc0d59c: 2c 03 00 00 cmpwi r3,0
return EINVAL;
ffc0d5a0: 38 00 00 16 li r0,22
int pthread_attr_setschedpolicy(
pthread_attr_t *attr,
int policy
)
{
if ( !attr || !attr->is_initialized )
ffc0d5a4: 41 82 00 38 beq- ffc0d5dc <pthread_attr_setschedpolicy+0x40>
ffc0d5a8: 81 23 00 00 lwz r9,0(r3)
ffc0d5ac: 2f 89 00 00 cmpwi cr7,r9,0
ffc0d5b0: 41 be 00 2c beq+ cr7,ffc0d5dc <pthread_attr_setschedpolicy+0x40>
return EINVAL;
switch ( policy ) {
ffc0d5b4: 2b 84 00 04 cmplwi cr7,r4,4
ffc0d5b8: 41 9d 00 20 bgt- cr7,ffc0d5d8 <pthread_attr_setschedpolicy+0x3c>
ffc0d5bc: 38 00 00 01 li r0,1
ffc0d5c0: 7c 00 20 30 slw r0,r0,r4
ffc0d5c4: 70 09 00 17 andi. r9,r0,23
ffc0d5c8: 41 82 00 10 beq- ffc0d5d8 <pthread_attr_setschedpolicy+0x3c><== NEVER TAKEN
case SCHED_OTHER:
case SCHED_FIFO:
case SCHED_RR:
case SCHED_SPORADIC:
attr->schedpolicy = policy;
ffc0d5cc: 90 83 00 14 stw r4,20(r3)
return 0;
ffc0d5d0: 38 00 00 00 li r0,0
ffc0d5d4: 48 00 00 08 b ffc0d5dc <pthread_attr_setschedpolicy+0x40>
default:
return ENOTSUP;
ffc0d5d8: 38 00 00 86 li r0,134
}
}
ffc0d5dc: 7c 03 03 78 mr r3,r0
ffc0d5e0: 4e 80 00 20 blr
ffc08038 <pthread_barrier_init>:
int pthread_barrier_init(
pthread_barrier_t *barrier,
const pthread_barrierattr_t *attr,
unsigned int count
)
{
ffc08038: 94 21 ff d8 stwu r1,-40(r1)
ffc0803c: 7c 08 02 a6 mflr r0
ffc08040: bf 81 00 18 stmw r28,24(r1)
const pthread_barrierattr_t *the_attr;
/*
* Error check parameters
*/
if ( !barrier )
ffc08044: 7c 7c 1b 79 mr. r28,r3
int pthread_barrier_init(
pthread_barrier_t *barrier,
const pthread_barrierattr_t *attr,
unsigned int count
)
{
ffc08048: 7c bf 2b 78 mr r31,r5
ffc0804c: 90 01 00 2c stw r0,44(r1)
/*
* Error check parameters
*/
if ( !barrier )
return EINVAL;
ffc08050: 38 00 00 16 li r0,22
const pthread_barrierattr_t *the_attr;
/*
* Error check parameters
*/
if ( !barrier )
ffc08054: 41 82 00 a8 beq- ffc080fc <pthread_barrier_init+0xc4>
return EINVAL;
if ( count == 0 )
ffc08058: 2f 85 00 00 cmpwi cr7,r5,0
ffc0805c: 41 be 00 a0 beq+ cr7,ffc080fc <pthread_barrier_init+0xc4>
return EINVAL;
/*
* If the user passed in NULL, use the default attributes
*/
if ( attr ) {
ffc08060: 2f 84 00 00 cmpwi cr7,r4,0
ffc08064: 40 be 00 10 bne+ cr7,ffc08074 <pthread_barrier_init+0x3c>
the_attr = attr;
} else {
(void) pthread_barrierattr_init( &my_attr );
ffc08068: 38 61 00 08 addi r3,r1,8
ffc0806c: 4b ff fe f1 bl ffc07f5c <pthread_barrierattr_init>
the_attr = &my_attr;
ffc08070: 38 81 00 08 addi r4,r1,8
}
/*
* Now start error checking the attributes that we are going to use
*/
if ( !the_attr->is_initialized )
ffc08074: 81 24 00 00 lwz r9,0(r4)
return EINVAL;
ffc08078: 38 00 00 16 li r0,22
}
/*
* Now start error checking the attributes that we are going to use
*/
if ( !the_attr->is_initialized )
ffc0807c: 2f 89 00 00 cmpwi cr7,r9,0
ffc08080: 41 be 00 7c beq+ cr7,ffc080fc <pthread_barrier_init+0xc4>
return EINVAL;
switch ( the_attr->process_shared ) {
ffc08084: 83 c4 00 04 lwz r30,4(r4)
ffc08088: 2f 9e 00 00 cmpwi cr7,r30,0
ffc0808c: 40 9e 00 70 bne- cr7,ffc080fc <pthread_barrier_init+0xc4><== NEVER TAKEN
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
_Thread_Dispatch_disable_level++;
ffc08090: 3d 20 00 00 lis r9,0
}
/*
* Convert from POSIX attributes to Core Barrier attributes
*/
the_attributes.discipline = CORE_BARRIER_AUTOMATIC_RELEASE;
ffc08094: 93 c1 00 10 stw r30,16(r1)
ffc08098: 81 69 28 34 lwz r11,10292(r9)
the_attributes.maximum_count = count;
ffc0809c: 93 e1 00 14 stw r31,20(r1)
ffc080a0: 38 0b 00 01 addi r0,r11,1
ffc080a4: 90 09 28 34 stw r0,10292(r9)
return _Thread_Dispatch_disable_level;
ffc080a8: 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 *)
ffc080ac: 3f a0 00 00 lis r29,0
ffc080b0: 3b bd 2f ac addi r29,r29,12204
ffc080b4: 7f a3 eb 78 mr r3,r29
ffc080b8: 48 00 23 ed bl ffc0a4a4 <_Objects_Allocate>
*/
_Thread_Disable_dispatch(); /* prevents deletion */
the_barrier = _POSIX_Barrier_Allocate();
if ( !the_barrier ) {
ffc080bc: 7c 7f 1b 79 mr. r31,r3
ffc080c0: 40 a2 00 10 bne+ ffc080d0 <pthread_barrier_init+0x98>
_Thread_Enable_dispatch();
ffc080c4: 48 00 37 cd bl ffc0b890 <_Thread_Enable_dispatch>
return EAGAIN;
ffc080c8: 38 00 00 0b li r0,11
ffc080cc: 48 00 00 30 b ffc080fc <pthread_barrier_init+0xc4>
}
_CORE_barrier_Initialize( &the_barrier->Barrier, &the_attributes );
ffc080d0: 38 7f 00 10 addi r3,r31,16
ffc080d4: 38 81 00 10 addi r4,r1,16
ffc080d8: 48 00 19 09 bl ffc099e0 <_CORE_barrier_Initialize>
uint32_t name
)
{
_Objects_Set_local_object(
information,
_Objects_Get_index( the_object->id ),
ffc080dc: 80 1f 00 08 lwz r0,8(r31)
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
ffc080e0: 81 7d 00 1c lwz r11,28(r29)
ffc080e4: 54 09 13 ba rlwinm r9,r0,2,14,29
ffc080e8: 7f eb 49 2e stwx r31,r11,r9
_Objects_Get_index( the_object->id ),
the_object
);
/* ASSERT: information->is_string == false */
the_object->name.name_u32 = name;
ffc080ec: 93 df 00 0c stw r30,12(r31)
);
/*
* Exit the critical section and return the user an operational barrier
*/
*barrier = the_barrier->Object.id;
ffc080f0: 90 1c 00 00 stw r0,0(r28)
_Thread_Enable_dispatch();
ffc080f4: 48 00 37 9d bl ffc0b890 <_Thread_Enable_dispatch>
return 0;
ffc080f8: 38 00 00 00 li r0,0
}
ffc080fc: 39 61 00 28 addi r11,r1,40
ffc08100: 7c 03 03 78 mr r3,r0
ffc08104: 4b ff 8d 38 b ffc00e3c <_restgpr_28_x>
ffc077c0 <pthread_cleanup_push>:
void pthread_cleanup_push(
void (*routine)( void * ),
void *arg
)
{
ffc077c0: 94 21 ff f0 stwu r1,-16(r1)
ffc077c4: 7c 08 02 a6 mflr r0
ffc077c8: bf c1 00 08 stmw 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 )
ffc077cc: 7c 7e 1b 79 mr. r30,r3
void pthread_cleanup_push(
void (*routine)( void * ),
void *arg
)
{
ffc077d0: 7c 9f 23 78 mr r31,r4
ffc077d4: 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 )
ffc077d8: 41 82 00 4c beq- ffc07824 <pthread_cleanup_push+0x64>
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
_Thread_Dispatch_disable_level++;
ffc077dc: 3d 20 00 00 lis r9,0
ffc077e0: 81 69 28 0c lwz r11,10252(r9)
ffc077e4: 38 0b 00 01 addi r0,r11,1
ffc077e8: 90 09 28 0c stw r0,10252(r9)
return _Thread_Dispatch_disable_level;
ffc077ec: 80 09 28 0c lwz r0,10252(r9)
return;
_Thread_Disable_dispatch();
handler = _Workspace_Allocate( sizeof( POSIX_Cancel_Handler_control ) );
ffc077f0: 38 60 00 10 li r3,16
ffc077f4: 48 00 4c 31 bl ffc0c424 <_Workspace_Allocate>
if ( handler ) {
ffc077f8: 7c 69 1b 79 mr. r9,r3
ffc077fc: 41 82 00 24 beq- ffc07820 <pthread_cleanup_push+0x60> <== NEVER TAKEN
thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ];
ffc07800: 3d 60 00 00 lis r11,0
ffc07804: 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 );
ffc07808: 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;
ffc0780c: 80 6b 01 34 lwz r3,308(r11)
handler->routine = routine;
ffc07810: 93 c9 00 08 stw r30,8(r9)
handler->arg = arg;
_Chain_Append( handler_stack, &handler->Node );
ffc07814: 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;
ffc07818: 93 e9 00 0c stw r31,12(r9)
_Chain_Append( handler_stack, &handler->Node );
ffc0781c: 48 00 1a 4d bl ffc09268 <_Chain_Append>
}
_Thread_Enable_dispatch();
ffc07820: 48 00 38 b1 bl ffc0b0d0 <_Thread_Enable_dispatch>
}
ffc07824: 39 61 00 10 addi r11,r1,16
ffc07828: 48 00 ef 28 b ffc16750 <_restgpr_30_x>
ffc08998 <pthread_cond_init>:
int pthread_cond_init(
pthread_cond_t *cond,
const pthread_condattr_t *attr
)
{
ffc08998: 94 21 ff e8 stwu r1,-24(r1)
ffc0899c: 7c 08 02 a6 mflr r0
ffc089a0: bf 81 00 08 stmw r28,8(r1)
POSIX_Condition_variables_Control *the_cond;
const pthread_condattr_t *the_attr;
if ( attr ) the_attr = attr;
ffc089a4: 7c 9e 23 79 mr. r30,r4
int pthread_cond_init(
pthread_cond_t *cond,
const pthread_condattr_t *attr
)
{
ffc089a8: 7c 7c 1b 78 mr r28,r3
ffc089ac: 90 01 00 1c stw r0,28(r1)
POSIX_Condition_variables_Control *the_cond;
const pthread_condattr_t *the_attr;
if ( attr ) the_attr = attr;
ffc089b0: 40 a2 00 0c bne+ ffc089bc <pthread_cond_init+0x24>
else the_attr = &_POSIX_Condition_variables_Default_attributes;
ffc089b4: 3f c0 00 00 lis r30,0
ffc089b8: 3b de 27 88 addi r30,r30,10120
/*
* Be careful about attributes when global!!!
*/
if ( the_attr->process_shared == PTHREAD_PROCESS_SHARED )
ffc089bc: 80 1e 00 04 lwz r0,4(r30)
return EINVAL;
ffc089c0: 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 )
ffc089c4: 2f 80 00 01 cmpwi cr7,r0,1
ffc089c8: 41 9e 00 90 beq- cr7,ffc08a58 <pthread_cond_init+0xc0> <== NEVER TAKEN
return EINVAL;
if ( !the_attr->is_initialized )
ffc089cc: 80 1e 00 00 lwz r0,0(r30)
ffc089d0: 2f 80 00 00 cmpwi cr7,r0,0
ffc089d4: 41 be 00 84 beq+ cr7,ffc08a58 <pthread_cond_init+0xc0>
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
_Thread_Dispatch_disable_level++;
ffc089d8: 3d 20 00 00 lis r9,0
ffc089dc: 81 69 28 40 lwz r11,10304(r9)
ffc089e0: 38 0b 00 01 addi r0,r11,1
ffc089e4: 90 09 28 40 stw r0,10304(r9)
return _Thread_Dispatch_disable_level;
ffc089e8: 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 *)
ffc089ec: 3f a0 00 00 lis r29,0
ffc089f0: 3b bd 30 64 addi r29,r29,12388
ffc089f4: 7f a3 eb 78 mr r3,r29
ffc089f8: 48 00 2a 9d bl ffc0b494 <_Objects_Allocate>
_Thread_Disable_dispatch();
the_cond = _POSIX_Condition_variables_Allocate();
if ( !the_cond ) {
ffc089fc: 7c 7f 1b 79 mr. r31,r3
ffc08a00: 40 a2 00 10 bne+ ffc08a10 <pthread_cond_init+0x78>
_Thread_Enable_dispatch();
ffc08a04: 48 00 3e 7d bl ffc0c880 <_Thread_Enable_dispatch>
return ENOMEM;
ffc08a08: 38 60 00 0c li r3,12
ffc08a0c: 48 00 00 4c b ffc08a58 <pthread_cond_init+0xc0>
}
the_cond->process_shared = the_attr->process_shared;
ffc08a10: 80 1e 00 04 lwz r0,4(r30)
the_cond->Mutex = POSIX_CONDITION_VARIABLES_NO_MUTEX;
ffc08a14: 3b c0 00 00 li r30,0
ffc08a18: 93 df 00 14 stw r30,20(r31)
_Thread_queue_Initialize(
ffc08a1c: 3c a0 10 00 lis r5,4096
ffc08a20: 38 7f 00 18 addi r3,r31,24
if ( !the_cond ) {
_Thread_Enable_dispatch();
return ENOMEM;
}
the_cond->process_shared = the_attr->process_shared;
ffc08a24: 90 1f 00 10 stw r0,16(r31)
the_cond->Mutex = POSIX_CONDITION_VARIABLES_NO_MUTEX;
_Thread_queue_Initialize(
ffc08a28: 38 80 00 00 li r4,0
ffc08a2c: 60 a5 08 00 ori r5,r5,2048
ffc08a30: 38 c0 00 74 li r6,116
ffc08a34: 48 00 46 ed bl ffc0d120 <_Thread_queue_Initialize>
uint32_t name
)
{
_Objects_Set_local_object(
information,
_Objects_Get_index( the_object->id ),
ffc08a38: 80 1f 00 08 lwz r0,8(r31)
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
ffc08a3c: 81 7d 00 1c lwz r11,28(r29)
ffc08a40: 54 09 13 ba rlwinm r9,r0,2,14,29
ffc08a44: 7f eb 49 2e stwx r31,r11,r9
_Objects_Get_index( the_object->id ),
the_object
);
/* ASSERT: information->is_string == false */
the_object->name.name_u32 = name;
ffc08a48: 93 df 00 0c stw r30,12(r31)
&_POSIX_Condition_variables_Information,
&the_cond->Object,
0
);
*cond = the_cond->Object.id;
ffc08a4c: 90 1c 00 00 stw r0,0(r28)
_Thread_Enable_dispatch();
ffc08a50: 48 00 3e 31 bl ffc0c880 <_Thread_Enable_dispatch>
return 0;
ffc08a54: 38 60 00 00 li r3,0
}
ffc08a58: 39 61 00 18 addi r11,r1,24
ffc08a5c: 4b ff 8c 50 b ffc016ac <_restgpr_28_x>
ffc087f0 <pthread_condattr_destroy>:
int pthread_condattr_destroy(
pthread_condattr_t *attr
)
{
if ( !attr || attr->is_initialized == false )
ffc087f0: 2c 03 00 00 cmpwi r3,0
return EINVAL;
ffc087f4: 38 00 00 16 li r0,22
int pthread_condattr_destroy(
pthread_condattr_t *attr
)
{
if ( !attr || attr->is_initialized == false )
ffc087f8: 41 82 00 18 beq- ffc08810 <pthread_condattr_destroy+0x20>
ffc087fc: 81 23 00 00 lwz r9,0(r3)
ffc08800: 2f 89 00 00 cmpwi cr7,r9,0
ffc08804: 41 be 00 0c beq+ cr7,ffc08810 <pthread_condattr_destroy+0x20><== NEVER TAKEN
return EINVAL;
attr->is_initialized = false;
ffc08808: 38 00 00 00 li r0,0
ffc0880c: 90 03 00 00 stw r0,0(r3)
return 0;
}
ffc08810: 7c 03 03 78 mr r3,r0
ffc08814: 4e 80 00 20 blr
ffc07cf4 <pthread_create>:
pthread_t *thread,
const pthread_attr_t *attr,
void *(*start_routine)( void * ),
void *arg
)
{
ffc07cf4: 94 21 ff 80 stwu r1,-128(r1)
ffc07cf8: 7c 08 02 a6 mflr r0
ffc07cfc: be a1 00 54 stmw r21,84(r1)
int schedpolicy = SCHED_RR;
struct sched_param schedparam;
Objects_Name name;
int rc;
if ( !start_routine )
ffc07d00: 7c b8 2b 79 mr. r24,r5
pthread_t *thread,
const pthread_attr_t *attr,
void *(*start_routine)( void * ),
void *arg
)
{
ffc07d04: 7c 7a 1b 78 mr r26,r3
ffc07d08: 90 01 00 84 stw r0,132(r1)
ffc07d0c: 7c d9 33 78 mr r25,r6
struct sched_param schedparam;
Objects_Name name;
int rc;
if ( !start_routine )
return EFAULT;
ffc07d10: 3b c0 00 0e li r30,14
int schedpolicy = SCHED_RR;
struct sched_param schedparam;
Objects_Name name;
int rc;
if ( !start_routine )
ffc07d14: 41 82 02 08 beq- ffc07f1c <pthread_create+0x228>
return EFAULT;
the_attr = (attr) ? attr : &_POSIX_Threads_Default_attributes;
ffc07d18: 2f 84 00 00 cmpwi cr7,r4,0
ffc07d1c: 7c 9f 23 78 mr r31,r4
ffc07d20: 40 be 00 0c bne+ cr7,ffc07d2c <pthread_create+0x38>
ffc07d24: 3f e0 ff c2 lis r31,-62
ffc07d28: 3b ff ef 60 addi r31,r31,-4256
if ( !the_attr->is_initialized )
ffc07d2c: 80 1f 00 00 lwz r0,0(r31)
return EINVAL;
ffc07d30: 3b c0 00 16 li r30,22
if ( !start_routine )
return EFAULT;
the_attr = (attr) ? attr : &_POSIX_Threads_Default_attributes;
if ( !the_attr->is_initialized )
ffc07d34: 2f 80 00 00 cmpwi cr7,r0,0
ffc07d38: 41 be 01 e4 beq+ cr7,ffc07f1c <pthread_create+0x228>
* 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) )
ffc07d3c: 80 1f 00 04 lwz r0,4(r31)
ffc07d40: 2f 80 00 00 cmpwi cr7,r0,0
ffc07d44: 41 9e 00 18 beq- cr7,ffc07d5c <pthread_create+0x68>
ffc07d48: 3d 60 00 00 lis r11,0
ffc07d4c: 81 3f 00 08 lwz r9,8(r31)
ffc07d50: 80 0b 27 28 lwz r0,10024(r11)
ffc07d54: 7f 89 00 40 cmplw cr7,r9,r0
ffc07d58: 41 bc 01 c4 blt+ cr7,ffc07f1c <pthread_create+0x228>
* 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 ) {
ffc07d5c: 80 1f 00 10 lwz r0,16(r31)
ffc07d60: 2f 80 00 01 cmpwi cr7,r0,1
ffc07d64: 41 9e 00 14 beq- cr7,ffc07d78 <pthread_create+0x84>
ffc07d68: 2f 80 00 02 cmpwi cr7,r0,2
schedpolicy = the_attr->schedpolicy;
schedparam = the_attr->schedparam;
break;
default:
return EINVAL;
ffc07d6c: 3b c0 00 16 li r30,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 ) {
ffc07d70: 40 be 01 ac bne+ cr7,ffc07f1c <pthread_create+0x228>
ffc07d74: 48 00 00 1c b ffc07d90 <pthread_create+0x9c>
case PTHREAD_INHERIT_SCHED:
api = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ];
ffc07d78: 3d 20 00 00 lis r9,0
ffc07d7c: 81 29 31 10 lwz r9,12560(r9)
ffc07d80: 80 69 01 34 lwz r3,308(r9)
schedpolicy = api->schedpolicy;
ffc07d84: 83 63 00 84 lwz r27,132(r3)
schedparam = api->schedparam;
ffc07d88: 38 63 00 88 addi r3,r3,136
ffc07d8c: 48 00 00 0c b ffc07d98 <pthread_create+0xa4>
break;
case PTHREAD_EXPLICIT_SCHED:
schedpolicy = the_attr->schedpolicy;
ffc07d90: 83 7f 00 14 lwz r27,20(r31)
schedparam = the_attr->schedparam;
ffc07d94: 38 7f 00 18 addi r3,r31,24
ffc07d98: 38 81 00 20 addi r4,r1,32
ffc07d9c: 7c a3 e4 aa lswi r5,r3,28
ffc07da0: 7c a4 e5 aa stswi r5,r4,28
/*
* Check the contentionscope since rtems only supports PROCESS wide
* contention (i.e. no system wide contention).
*/
if ( the_attr->contentionscope != PTHREAD_SCOPE_PROCESS )
return ENOTSUP;
ffc07da4: 3b c0 00 86 li r30,134
/*
* Check the contentionscope since rtems only supports PROCESS wide
* contention (i.e. no system wide contention).
*/
if ( the_attr->contentionscope != PTHREAD_SCOPE_PROCESS )
ffc07da8: 80 1f 00 0c lwz r0,12(r31)
ffc07dac: 2f 80 00 00 cmpwi cr7,r0,0
ffc07db0: 40 be 01 6c bne+ cr7,ffc07f1c <pthread_create+0x228>
return ENOTSUP;
/*
* Interpret the scheduling parameters.
*/
if ( !_POSIX_Priority_Is_valid( schedparam.sched_priority ) )
ffc07db4: 80 61 00 20 lwz r3,32(r1)
return EINVAL;
ffc07db8: 3b c0 00 16 li r30,22
return ENOTSUP;
/*
* Interpret the scheduling parameters.
*/
if ( !_POSIX_Priority_Is_valid( schedparam.sched_priority ) )
ffc07dbc: 48 00 6b d9 bl ffc0e994 <_POSIX_Priority_Is_valid>
ffc07dc0: 2f 83 00 00 cmpwi cr7,r3,0
ffc07dc4: 41 be 01 58 beq+ cr7,ffc07f1c <pthread_create+0x228> <== NEVER TAKEN
return EINVAL;
core_priority = _POSIX_Priority_To_core( schedparam.sched_priority );
ffc07dc8: 7c 24 0b 78 mr r4,r1
ffc07dcc: 86 e4 00 20 lwzu r23,32(r4)
RTEMS_INLINE_ROUTINE Priority_Control _POSIX_Priority_To_core(
int priority
)
{
return (Priority_Control) (POSIX_SCHEDULER_MAXIMUM_PRIORITY - priority + 1);
ffc07dd0: 3d 20 00 00 lis r9,0
/*
* Set the core scheduling policy information.
*/
rc = _POSIX_Thread_Translate_sched_param(
ffc07dd4: 7f 63 db 78 mr r3,r27
ffc07dd8: 8a c9 27 24 lbz r22,10020(r9)
ffc07ddc: 38 a1 00 1c addi r5,r1,28
ffc07de0: 38 c1 00 18 addi r6,r1,24
ffc07de4: 48 00 6b d9 bl ffc0e9bc <_POSIX_Thread_Translate_sched_param>
schedpolicy,
&schedparam,
&budget_algorithm,
&budget_callout
);
if ( rc )
ffc07de8: 7c 7e 1b 79 mr. r30,r3
ffc07dec: 40 a2 01 30 bne+ ffc07f1c <pthread_create+0x228>
#endif
/*
* Lock the allocator mutex for protection
*/
_RTEMS_Lock_allocator();
ffc07df0: 3e a0 00 00 lis r21,0
ffc07df4: 80 75 28 34 lwz r3,10292(r21)
* _POSIX_Threads_Allocate
*/
RTEMS_INLINE_ROUTINE Thread_Control *_POSIX_Threads_Allocate( void )
{
return (Thread_Control *) _Objects_Allocate( &_POSIX_Threads_Information );
ffc07df8: 3f a0 00 00 lis r29,0
ffc07dfc: 3b bd 2e 0c addi r29,r29,11788
ffc07e00: 48 00 1a 95 bl ffc09894 <_API_Mutex_Lock>
ffc07e04: 7f a3 eb 78 mr r3,r29
ffc07e08: 48 00 25 d5 bl ffc0a3dc <_Objects_Allocate>
* Allocate the thread control block.
*
* NOTE: Global threads are not currently supported.
*/
the_thread = _POSIX_Threads_Allocate();
if ( !the_thread ) {
ffc07e0c: 7c 7c 1b 79 mr. r28,r3
ffc07e10: 40 a2 00 0c bne+ ffc07e1c <pthread_create+0x128>
_RTEMS_Unlock_allocator();
ffc07e14: 80 75 28 34 lwz r3,10292(r21)
ffc07e18: 48 00 00 78 b ffc07e90 <pthread_create+0x19c>
static inline size_t _POSIX_Threads_Ensure_minimum_stack (
size_t size
)
{
if ( size >= PTHREAD_MINIMUM_STACK_SIZE )
ffc07e1c: 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(
ffc07e20: 80 1f 00 08 lwz r0,8(r31)
static inline size_t _POSIX_Threads_Ensure_minimum_stack (
size_t size
)
{
if ( size >= PTHREAD_MINIMUM_STACK_SIZE )
ffc07e24: 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(
ffc07e28: 93 c1 00 48 stw r30,72(r1)
static inline size_t _POSIX_Threads_Ensure_minimum_stack (
size_t size
)
{
if ( size >= PTHREAD_MINIMUM_STACK_SIZE )
ffc07e2c: 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(
ffc07e30: 7f 86 00 40 cmplw cr7,r6,r0
ffc07e34: 80 bf 00 04 lwz r5,4(r31)
ffc07e38: 40 9c 00 08 bge- cr7,ffc07e40 <pthread_create+0x14c>
ffc07e3c: 7c 06 03 78 mr r6,r0
ffc07e40: 80 01 00 18 lwz r0,24(r1)
ffc07e44: 7f a3 eb 78 mr r3,r29
ffc07e48: 81 41 00 1c lwz r10,28(r1)
ffc07e4c: 7f 84 e3 78 mr r4,r28
ffc07e50: 90 01 00 08 stw r0,8(r1)
ffc07e54: 38 00 00 00 li r0,0
ffc07e58: 38 e0 00 01 li r7,1
ffc07e5c: 90 01 00 0c stw r0,12(r1)
ffc07e60: 7d 17 b0 50 subf r8,r23,r22
ffc07e64: 38 01 00 48 addi r0,r1,72
ffc07e68: 39 20 00 01 li r9,1
ffc07e6c: 90 01 00 10 stw r0,16(r1)
ffc07e70: 48 00 3a 45 bl ffc0b8b4 <_Thread_Initialize>
budget_callout,
0, /* isr level */
name /* posix threads don't have a name */
);
if ( !status ) {
ffc07e74: 2f 83 00 00 cmpwi cr7,r3,0
ffc07e78: 40 9e 00 24 bne- cr7,ffc07e9c <pthread_create+0x1a8>
RTEMS_INLINE_ROUTINE void _POSIX_Threads_Free (
Thread_Control *the_pthread
)
{
_Objects_Free( &_POSIX_Threads_Information, &the_pthread->Object );
ffc07e7c: 7f a3 eb 78 mr r3,r29
ffc07e80: 7f 84 e3 78 mr r4,r28
ffc07e84: 48 00 28 dd bl ffc0a760 <_Objects_Free>
_POSIX_Threads_Free( the_thread );
_RTEMS_Unlock_allocator();
ffc07e88: 3d 20 00 00 lis r9,0
ffc07e8c: 80 69 28 34 lwz r3,10292(r9)
ffc07e90: 48 00 1a 89 bl ffc09918 <_API_Mutex_Unlock>
return EAGAIN;
ffc07e94: 3b c0 00 0b li r30,11
ffc07e98: 48 00 00 84 b ffc07f1c <pthread_create+0x228>
}
/*
* finish initializing the per API structure
*/
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
ffc07e9c: 83 bc 01 34 lwz r29,308(r28)
api->Attributes = *the_attr;
ffc07ea0: 38 a0 00 40 li r5,64
ffc07ea4: 7f e4 fb 78 mr r4,r31
ffc07ea8: 7f a3 eb 78 mr r3,r29
ffc07eac: 48 00 a1 a9 bl ffc12054 <memcpy>
api->detachstate = the_attr->detachstate;
ffc07eb0: 80 1f 00 3c lwz r0,60(r31)
api->schedpolicy = schedpolicy;
ffc07eb4: 93 7d 00 84 stw r27,132(r29)
api->schedparam = schedparam;
ffc07eb8: 38 9d 00 88 addi r4,r29,136
ffc07ebc: 38 61 00 20 addi r3,r1,32
* finish initializing the per API structure
*/
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
api->Attributes = *the_attr;
api->detachstate = the_attr->detachstate;
ffc07ec0: 90 1d 00 40 stw r0,64(r29)
api->schedpolicy = schedpolicy;
api->schedparam = schedparam;
ffc07ec4: 7c a3 e4 aa lswi r5,r3,28
ffc07ec8: 7c a4 e5 aa stswi r5,r4,28
/*
* POSIX threads are allocated and started in one operation.
*/
status = _Thread_Start(
ffc07ecc: 7f 83 e3 78 mr r3,r28
ffc07ed0: 38 80 00 01 li r4,1
ffc07ed4: 7f 05 c3 78 mr r5,r24
ffc07ed8: 7f 26 cb 78 mr r6,r25
ffc07edc: 38 e0 00 00 li r7,0
ffc07ee0: 48 00 44 39 bl ffc0c318 <_Thread_Start>
_RTEMS_Unlock_allocator();
return EINVAL;
}
#endif
if ( schedpolicy == SCHED_SPORADIC ) {
ffc07ee4: 2f 9b 00 04 cmpwi cr7,r27,4
ffc07ee8: 40 be 00 20 bne+ cr7,ffc07f08 <pthread_create+0x214>
_Watchdog_Insert_ticks(
ffc07eec: 38 7d 00 90 addi r3,r29,144
ffc07ef0: 48 00 45 51 bl ffc0c440 <_Timespec_To_ticks>
)
{
the_watchdog->initial = units;
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
ffc07ef4: 38 9d 00 a8 addi r4,r29,168
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
ffc07ef8: 90 7d 00 b4 stw r3,180(r29)
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
ffc07efc: 3c 60 00 00 lis r3,0
ffc07f00: 38 63 2d 28 addi r3,r3,11560
ffc07f04: 48 00 49 31 bl ffc0c834 <_Watchdog_Insert>
}
/*
* Return the id and indicate we successfully created the thread
*/
*thread = the_thread->Object.id;
ffc07f08: 80 1c 00 08 lwz r0,8(r28)
_RTEMS_Unlock_allocator();
ffc07f0c: 3d 20 00 00 lis r9,0
ffc07f10: 80 69 28 34 lwz r3,10292(r9)
}
/*
* Return the id and indicate we successfully created the thread
*/
*thread = the_thread->Object.id;
ffc07f14: 90 1a 00 00 stw r0,0(r26)
_RTEMS_Unlock_allocator();
ffc07f18: 48 00 1a 01 bl ffc09918 <_API_Mutex_Unlock>
return 0;
}
ffc07f1c: 39 61 00 80 addi r11,r1,128
ffc07f20: 7f c3 f3 78 mr r3,r30
ffc07f24: 4b ff 8c 20 b ffc00b44 <_restgpr_21_x>
ffc1c068 <pthread_kill>:
int pthread_kill(
pthread_t thread,
int sig
)
{
ffc1c068: 94 21 ff d8 stwu r1,-40(r1)
ffc1c06c: 7c 08 02 a6 mflr r0
ffc1c070: bf 81 00 18 stmw r28,24(r1)
POSIX_API_Control *api;
Thread_Control *the_thread;
Objects_Locations location;
if ( !sig )
ffc1c074: 7c 9d 23 79 mr. r29,r4
int pthread_kill(
pthread_t thread,
int sig
)
{
ffc1c078: 90 01 00 2c stw r0,44(r1)
POSIX_API_Control *api;
Thread_Control *the_thread;
Objects_Locations location;
if ( !sig )
ffc1c07c: 41 82 00 10 beq- ffc1c08c <pthread_kill+0x24>
static inline bool is_valid_signo(
int signo
)
{
return ((signo) >= 1 && (signo) <= 32 );
ffc1c080: 3b 9d ff ff addi r28,r29,-1
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !is_valid_signo(sig) )
ffc1c084: 2b 9c 00 1f cmplwi cr7,r28,31
ffc1c088: 40 bd 00 10 ble+ cr7,ffc1c098 <pthread_kill+0x30>
rtems_set_errno_and_return_minus_one( EINVAL );
ffc1c08c: 4b ff 4b 29 bl ffc10bb4 <__errno>
ffc1c090: 38 00 00 16 li r0,22
ffc1c094: 48 00 00 94 b ffc1c128 <pthread_kill+0xc0>
the_thread = _Thread_Get( thread, &location );
ffc1c098: 38 81 00 08 addi r4,r1,8
ffc1c09c: 4b fe ea 51 bl ffc0aaec <_Thread_Get>
switch ( location ) {
ffc1c0a0: 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 );
ffc1c0a4: 7c 7e 1b 78 mr r30,r3
switch ( location ) {
ffc1c0a8: 2f 80 00 00 cmpwi cr7,r0,0
ffc1c0ac: 40 9e 00 74 bne- cr7,ffc1c120 <pthread_kill+0xb8> <== NEVER TAKEN
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
if ( sig ) {
if ( _POSIX_signals_Vectors[ sig ].sa_handler == SIG_IGN ) {
ffc1c0b0: 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 ];
ffc1c0b4: 81 23 01 34 lwz r9,308(r3)
if ( sig ) {
if ( _POSIX_signals_Vectors[ sig ].sa_handler == SIG_IGN ) {
ffc1c0b8: 3d 60 00 00 lis r11,0
ffc1c0bc: 39 6b 31 c0 addi r11,r11,12736
ffc1c0c0: 7d 6b 02 14 add r11,r11,r0
ffc1c0c4: 80 0b 00 08 lwz r0,8(r11)
ffc1c0c8: 2f 80 00 01 cmpwi cr7,r0,1
ffc1c0cc: 41 9e 00 48 beq- cr7,ffc1c114 <pthread_kill+0xac>
return 0;
}
/* XXX critical section */
api->signals_pending |= signo_to_mask( sig );
ffc1c0d0: 80 09 00 d4 lwz r0,212(r9)
static inline sigset_t signo_to_mask(
uint32_t sig
)
{
return 1u << (sig - 1);
ffc1c0d4: 3b e0 00 01 li r31,1
ffc1c0d8: 7f fc e0 30 slw r28,r31,r28
ffc1c0dc: 7c 1c e3 78 or r28,r0,r28
ffc1c0e0: 93 89 00 d4 stw r28,212(r9)
(void) _POSIX_signals_Unblock_thread( the_thread, sig, NULL );
ffc1c0e4: 7f a4 eb 78 mr r4,r29
ffc1c0e8: 38 a0 00 00 li r5,0
ffc1c0ec: 4b ff fe 4d bl ffc1bf38 <_POSIX_signals_Unblock_thread>
if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
ffc1c0f0: 3d 20 00 00 lis r9,0
ffc1c0f4: 39 29 31 44 addi r9,r9,12612
ffc1c0f8: 80 09 00 08 lwz r0,8(r9)
ffc1c0fc: 2f 80 00 00 cmpwi cr7,r0,0
ffc1c100: 41 9e 00 14 beq- cr7,ffc1c114 <pthread_kill+0xac>
ffc1c104: 80 09 00 0c lwz r0,12(r9)
ffc1c108: 7f 9e 00 00 cmpw cr7,r30,r0
ffc1c10c: 40 be 00 08 bne+ cr7,ffc1c114 <pthread_kill+0xac>
_Thread_Dispatch_necessary = true;
ffc1c110: 9b e9 00 18 stb r31,24(r9)
}
_Thread_Enable_dispatch();
ffc1c114: 4b fe e9 9d bl ffc0aab0 <_Thread_Enable_dispatch>
return 0;
ffc1c118: 38 60 00 00 li r3,0
ffc1c11c: 48 00 00 14 b ffc1c130 <pthread_kill+0xc8>
#endif
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( ESRCH );
ffc1c120: 4b ff 4a 95 bl ffc10bb4 <__errno> <== NOT EXECUTED
ffc1c124: 38 00 00 03 li r0,3 <== NOT EXECUTED
ffc1c128: 90 03 00 00 stw r0,0(r3)
ffc1c12c: 38 60 ff ff li r3,-1
}
ffc1c130: 39 61 00 28 addi r11,r1,40
ffc1c134: 4b fe 44 04 b ffc00538 <_restgpr_28_x>
ffc0a014 <pthread_mutex_timedlock>:
int pthread_mutex_timedlock(
pthread_mutex_t *mutex,
const struct timespec *abstime
)
{
ffc0a014: 94 21 ff d8 stwu r1,-40(r1)
ffc0a018: 7c 08 02 a6 mflr r0
ffc0a01c: bf a1 00 1c stmw r29,28(r1)
ffc0a020: 7c 7d 1b 78 mr r29,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 );
ffc0a024: 7c 83 23 78 mr r3,r4
ffc0a028: 38 81 00 08 addi r4,r1,8
int pthread_mutex_timedlock(
pthread_mutex_t *mutex,
const struct timespec *abstime
)
{
ffc0a02c: 90 01 00 2c stw r0,44(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 );
ffc0a030: 48 00 00 f5 bl ffc0a124 <_POSIX_Absolute_timeout_to_ticks>
int _EXFUN(pthread_mutex_trylock, (pthread_mutex_t *__mutex));
int _EXFUN(pthread_mutex_unlock, (pthread_mutex_t *__mutex));
#if defined(_POSIX_TIMEOUTS)
int _EXFUN(pthread_mutex_timedlock,
ffc0a034: 68 7f 00 03 xori r31,r3,3
if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE )
do_wait = false;
lock_status = _POSIX_Mutex_Lock_support( mutex, do_wait, ticks );
ffc0a038: 80 a1 00 08 lwz r5,8(r1)
ffc0a03c: 7f ff 00 34 cntlzw r31,r31
ffc0a040: 57 ff d9 7e rlwinm r31,r31,27,5,31
*
* 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 );
ffc0a044: 7c 7e 1b 78 mr r30,r3
if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE )
do_wait = false;
lock_status = _POSIX_Mutex_Lock_support( mutex, do_wait, ticks );
ffc0a048: 7f e4 fb 78 mr r4,r31
ffc0a04c: 7f a3 eb 78 mr r3,r29
ffc0a050: 4b ff fe c1 bl ffc09f10 <_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) ) {
ffc0a054: 2f 9f 00 00 cmpwi cr7,r31,0
ffc0a058: 40 9e 00 30 bne- cr7,ffc0a088 <pthread_mutex_timedlock+0x74>
ffc0a05c: 2f 83 00 10 cmpwi cr7,r3,16
ffc0a060: 40 be 00 28 bne+ cr7,ffc0a088 <pthread_mutex_timedlock+0x74>
if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID )
ffc0a064: 2f 9e 00 00 cmpwi cr7,r30,0
ffc0a068: 41 be 00 14 beq+ cr7,ffc0a07c <pthread_mutex_timedlock+0x68><== NEVER TAKEN
return EINVAL;
if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST ||
ffc0a06c: 3b de ff ff addi r30,r30,-1
ffc0a070: 2b 9e 00 01 cmplwi cr7,r30,1
ffc0a074: 41 bd 00 14 bgt+ cr7,ffc0a088 <pthread_mutex_timedlock+0x74><== NEVER TAKEN
ffc0a078: 48 00 00 0c b ffc0a084 <pthread_mutex_timedlock+0x70>
* not obtain the mutex, then not look at the status immediately,
* make sure the right reason is returned.
*/
if ( !do_wait && (lock_status == EBUSY) ) {
if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID )
return EINVAL;
ffc0a07c: 38 60 00 16 li r3,22 <== NOT EXECUTED
ffc0a080: 48 00 00 08 b ffc0a088 <pthread_mutex_timedlock+0x74><== NOT EXECUTED
if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST ||
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
return ETIMEDOUT;
ffc0a084: 38 60 00 74 li r3,116
}
return lock_status;
}
ffc0a088: 39 61 00 28 addi r11,r1,40
ffc0a08c: 4b ff 88 48 b ffc028d4 <_restgpr_29_x>
ffc09b9c <pthread_mutexattr_setpshared>:
int pthread_mutexattr_setpshared(
pthread_mutexattr_t *attr,
int pshared
)
{
if ( !attr || !attr->is_initialized )
ffc09b9c: 2c 03 00 00 cmpwi r3,0
return EINVAL;
ffc09ba0: 38 00 00 16 li r0,22
int pthread_mutexattr_setpshared(
pthread_mutexattr_t *attr,
int pshared
)
{
if ( !attr || !attr->is_initialized )
ffc09ba4: 41 82 00 20 beq- ffc09bc4 <pthread_mutexattr_setpshared+0x28>
ffc09ba8: 81 23 00 00 lwz r9,0(r3)
ffc09bac: 2f 89 00 00 cmpwi cr7,r9,0
ffc09bb0: 41 be 00 14 beq+ cr7,ffc09bc4 <pthread_mutexattr_setpshared+0x28>
return EINVAL;
switch ( pshared ) {
ffc09bb4: 2b 84 00 01 cmplwi cr7,r4,1
ffc09bb8: 41 9d 00 0c bgt- cr7,ffc09bc4 <pthread_mutexattr_setpshared+0x28><== NEVER TAKEN
case PTHREAD_PROCESS_SHARED:
case PTHREAD_PROCESS_PRIVATE:
attr->process_shared = pshared;
ffc09bbc: 90 83 00 04 stw r4,4(r3)
return 0;
ffc09bc0: 38 00 00 00 li r0,0
default:
return EINVAL;
}
}
ffc09bc4: 7c 03 03 78 mr r3,r0
ffc09bc8: 4e 80 00 20 blr
ffc0739c <pthread_mutexattr_settype>:
int pthread_mutexattr_settype(
pthread_mutexattr_t *attr,
int type
)
{
if ( !attr || !attr->is_initialized )
ffc0739c: 2c 03 00 00 cmpwi r3,0
return EINVAL;
ffc073a0: 38 00 00 16 li r0,22
int pthread_mutexattr_settype(
pthread_mutexattr_t *attr,
int type
)
{
if ( !attr || !attr->is_initialized )
ffc073a4: 41 82 00 20 beq- ffc073c4 <pthread_mutexattr_settype+0x28>
ffc073a8: 81 23 00 00 lwz r9,0(r3)
ffc073ac: 2f 89 00 00 cmpwi cr7,r9,0
ffc073b0: 41 be 00 14 beq+ cr7,ffc073c4 <pthread_mutexattr_settype+0x28><== NEVER TAKEN
return EINVAL;
switch ( type ) {
ffc073b4: 2b 84 00 03 cmplwi cr7,r4,3
ffc073b8: 41 9d 00 0c bgt- cr7,ffc073c4 <pthread_mutexattr_settype+0x28>
case PTHREAD_MUTEX_NORMAL:
case PTHREAD_MUTEX_RECURSIVE:
case PTHREAD_MUTEX_ERRORCHECK:
case PTHREAD_MUTEX_DEFAULT:
attr->type = type;
ffc073bc: 90 83 00 10 stw r4,16(r3)
return 0;
ffc073c0: 38 00 00 00 li r0,0
default:
return EINVAL;
}
}
ffc073c4: 7c 03 03 78 mr r3,r0
ffc073c8: 4e 80 00 20 blr
ffc08404 <pthread_once>:
int pthread_once(
pthread_once_t *once_control,
void (*init_routine)(void)
)
{
ffc08404: 94 21 ff e0 stwu r1,-32(r1)
ffc08408: 7c 08 02 a6 mflr r0
ffc0840c: bf c1 00 18 stmw r30,24(r1)
if ( !once_control || !init_routine )
ffc08410: 7c 7f 1b 79 mr. r31,r3
int pthread_once(
pthread_once_t *once_control,
void (*init_routine)(void)
)
{
ffc08414: 7c 9e 23 78 mr r30,r4
ffc08418: 90 01 00 24 stw r0,36(r1)
if ( !once_control || !init_routine )
return EINVAL;
ffc0841c: 38 00 00 16 li r0,22
int pthread_once(
pthread_once_t *once_control,
void (*init_routine)(void)
)
{
if ( !once_control || !init_routine )
ffc08420: 41 82 00 60 beq- ffc08480 <pthread_once+0x7c>
ffc08424: 2f 84 00 00 cmpwi cr7,r4,0
ffc08428: 41 9e 00 58 beq- cr7,ffc08480 <pthread_once+0x7c>
return EINVAL;
if ( !once_control->init_executed ) {
ffc0842c: 81 3f 00 04 lwz r9,4(r31)
once_control->init_executed = true;
(*init_routine)();
}
rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode);
}
return 0;
ffc08430: 38 00 00 00 li r0,0
)
{
if ( !once_control || !init_routine )
return EINVAL;
if ( !once_control->init_executed ) {
ffc08434: 2f 89 00 00 cmpwi cr7,r9,0
ffc08438: 40 be 00 48 bne+ cr7,ffc08480 <pthread_once+0x7c>
rtems_mode saveMode;
rtems_task_mode(RTEMS_NO_PREEMPT, RTEMS_PREEMPT_MASK, &saveMode);
ffc0843c: 38 60 01 00 li r3,256
ffc08440: 38 80 01 00 li r4,256
ffc08444: 38 a1 00 08 addi r5,r1,8
ffc08448: 48 00 0c bd bl ffc09104 <rtems_task_mode>
if ( !once_control->init_executed ) {
ffc0844c: 80 1f 00 04 lwz r0,4(r31)
ffc08450: 2f 80 00 00 cmpwi cr7,r0,0
ffc08454: 40 be 00 18 bne+ cr7,ffc0846c <pthread_once+0x68> <== NEVER TAKEN
once_control->is_initialized = true;
ffc08458: 38 00 00 01 li r0,1
once_control->init_executed = true;
(*init_routine)();
ffc0845c: 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;
ffc08460: 90 1f 00 00 stw r0,0(r31)
once_control->init_executed = true;
ffc08464: 90 1f 00 04 stw r0,4(r31)
(*init_routine)();
ffc08468: 4e 80 04 21 bctrl
}
rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode);
ffc0846c: 7c 25 0b 78 mr r5,r1
ffc08470: 84 65 00 08 lwzu r3,8(r5)
ffc08474: 38 80 01 00 li r4,256
ffc08478: 48 00 0c 8d bl ffc09104 <rtems_task_mode>
}
return 0;
ffc0847c: 38 00 00 00 li r0,0
}
ffc08480: 39 61 00 20 addi r11,r1,32
ffc08484: 7c 03 03 78 mr r3,r0
ffc08488: 4b ff 86 e0 b ffc00b68 <_restgpr_30_x>
ffc08e04 <pthread_rwlock_init>:
int pthread_rwlock_init(
pthread_rwlock_t *rwlock,
const pthread_rwlockattr_t *attr
)
{
ffc08e04: 94 21 ff d8 stwu r1,-40(r1)
ffc08e08: 7c 08 02 a6 mflr r0
ffc08e0c: bf 81 00 18 stmw r28,24(r1)
const pthread_rwlockattr_t *the_attr;
/*
* Error check parameters
*/
if ( !rwlock )
ffc08e10: 7c 7c 1b 79 mr. r28,r3
int pthread_rwlock_init(
pthread_rwlock_t *rwlock,
const pthread_rwlockattr_t *attr
)
{
ffc08e14: 90 01 00 2c stw r0,44(r1)
/*
* Error check parameters
*/
if ( !rwlock )
return EINVAL;
ffc08e18: 38 00 00 16 li r0,22
const pthread_rwlockattr_t *the_attr;
/*
* Error check parameters
*/
if ( !rwlock )
ffc08e1c: 41 82 00 9c beq- ffc08eb8 <pthread_rwlock_init+0xb4>
return EINVAL;
/*
* If the user passed in NULL, use the default attributes
*/
if ( attr ) {
ffc08e20: 2f 84 00 00 cmpwi cr7,r4,0
ffc08e24: 40 be 00 10 bne+ cr7,ffc08e34 <pthread_rwlock_init+0x30>
the_attr = attr;
} else {
(void) pthread_rwlockattr_init( &default_attr );
ffc08e28: 38 61 00 0c addi r3,r1,12
ffc08e2c: 48 00 0a a1 bl ffc098cc <pthread_rwlockattr_init>
the_attr = &default_attr;
ffc08e30: 38 81 00 0c addi r4,r1,12
}
/*
* Now start error checking the attributes that we are going to use
*/
if ( !the_attr->is_initialized )
ffc08e34: 81 24 00 00 lwz r9,0(r4)
return EINVAL;
ffc08e38: 38 00 00 16 li r0,22
}
/*
* Now start error checking the attributes that we are going to use
*/
if ( !the_attr->is_initialized )
ffc08e3c: 2f 89 00 00 cmpwi cr7,r9,0
ffc08e40: 41 be 00 78 beq+ cr7,ffc08eb8 <pthread_rwlock_init+0xb4><== NEVER TAKEN
return EINVAL;
switch ( the_attr->process_shared ) {
ffc08e44: 83 c4 00 04 lwz r30,4(r4)
ffc08e48: 2f 9e 00 00 cmpwi cr7,r30,0
ffc08e4c: 40 9e 00 6c bne- cr7,ffc08eb8 <pthread_rwlock_init+0xb4><== NEVER TAKEN
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
_Thread_Dispatch_disable_level++;
ffc08e50: 3d 20 00 00 lis r9,0
*/
RTEMS_INLINE_ROUTINE void _CORE_RWLock_Initialize_attributes(
CORE_RWLock_Attributes *the_attributes
)
{
the_attributes->XXX = 0;
ffc08e54: 93 c1 00 08 stw r30,8(r1)
ffc08e58: 81 69 28 34 lwz r11,10292(r9)
ffc08e5c: 38 0b 00 01 addi r0,r11,1
ffc08e60: 90 09 28 34 stw r0,10292(r9)
return _Thread_Dispatch_disable_level;
ffc08e64: 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 *)
ffc08e68: 3f a0 00 00 lis r29,0
ffc08e6c: 3b bd 2d ec addi r29,r29,11756
ffc08e70: 7f a3 eb 78 mr r3,r29
ffc08e74: 48 00 2a a5 bl ffc0b918 <_Objects_Allocate>
*/
_Thread_Disable_dispatch(); /* prevents deletion */
the_rwlock = _POSIX_RWLock_Allocate();
if ( !the_rwlock ) {
ffc08e78: 7c 7f 1b 79 mr. r31,r3
ffc08e7c: 40 a2 00 10 bne+ ffc08e8c <pthread_rwlock_init+0x88>
_Thread_Enable_dispatch();
ffc08e80: 48 00 3e 85 bl ffc0cd04 <_Thread_Enable_dispatch>
return EAGAIN;
ffc08e84: 38 00 00 0b li r0,11
ffc08e88: 48 00 00 30 b ffc08eb8 <pthread_rwlock_init+0xb4>
}
_CORE_RWLock_Initialize( &the_rwlock->RWLock, &the_attributes );
ffc08e8c: 38 7f 00 10 addi r3,r31,16
ffc08e90: 38 81 00 08 addi r4,r1,8
ffc08e94: 48 00 21 01 bl ffc0af94 <_CORE_RWLock_Initialize>
uint32_t name
)
{
_Objects_Set_local_object(
information,
_Objects_Get_index( the_object->id ),
ffc08e98: 80 1f 00 08 lwz r0,8(r31)
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
ffc08e9c: 81 7d 00 1c lwz r11,28(r29)
ffc08ea0: 54 09 13 ba rlwinm r9,r0,2,14,29
ffc08ea4: 7f eb 49 2e stwx r31,r11,r9
_Objects_Get_index( the_object->id ),
the_object
);
/* ASSERT: information->is_string == false */
the_object->name.name_u32 = name;
ffc08ea8: 93 df 00 0c stw r30,12(r31)
&_POSIX_RWLock_Information,
&the_rwlock->Object,
0
);
*rwlock = the_rwlock->Object.id;
ffc08eac: 90 1c 00 00 stw r0,0(r28)
_Thread_Enable_dispatch();
ffc08eb0: 48 00 3e 55 bl ffc0cd04 <_Thread_Enable_dispatch>
return 0;
ffc08eb4: 38 00 00 00 li r0,0
}
ffc08eb8: 39 61 00 28 addi r11,r1,40
ffc08ebc: 7c 03 03 78 mr r3,r0
ffc08ec0: 4b ff 8d 74 b ffc01c34 <_restgpr_28_x>
ffc08f3c <pthread_rwlock_timedrdlock>:
int pthread_rwlock_timedrdlock(
pthread_rwlock_t *rwlock,
const struct timespec *abstime
)
{
ffc08f3c: 94 21 ff d8 stwu r1,-40(r1)
ffc08f40: 7c 08 02 a6 mflr r0
ffc08f44: bf 81 00 18 stmw r28,24(r1)
Objects_Locations location;
Watchdog_Interval ticks;
bool do_wait = true;
POSIX_Absolute_timeout_conversion_results_t status;
if ( !rwlock )
ffc08f48: 7c 7c 1b 79 mr. r28,r3
return EINVAL;
ffc08f4c: 3b c0 00 16 li r30,22
int pthread_rwlock_timedrdlock(
pthread_rwlock_t *rwlock,
const struct timespec *abstime
)
{
ffc08f50: 90 01 00 2c stw r0,44(r1)
Objects_Locations location;
Watchdog_Interval ticks;
bool do_wait = true;
POSIX_Absolute_timeout_conversion_results_t status;
if ( !rwlock )
ffc08f54: 41 82 00 a4 beq- ffc08ff8 <pthread_rwlock_timedrdlock+0xbc>
*
* If the status is POSIX_ABSOLUTE_TIMEOUT_INVALID,
* POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST, or POSIX_ABSOLUTE_TIMEOUT_IS_NOW,
* then we should not wait.
*/
status = _POSIX_Absolute_timeout_to_ticks( abstime, &ticks );
ffc08f58: 7c 83 23 78 mr r3,r4
ffc08f5c: 38 81 00 08 addi r4,r1,8
ffc08f60: 48 00 6e d1 bl ffc0fe30 <_POSIX_Absolute_timeout_to_ticks>
ffc08f64: 80 9c 00 00 lwz r4,0(r28)
ffc08f68: 7c 7d 1b 78 mr r29,r3
ffc08f6c: 3c 60 00 00 lis r3,0
ffc08f70: 38 63 2d ec addi r3,r3,11756
ffc08f74: 38 a1 00 0c addi r5,r1,12
ffc08f78: 48 00 2e c1 bl ffc0be38 <_Objects_Get>
if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE )
do_wait = false;
the_rwlock = _POSIX_RWLock_Get( rwlock, &location );
switch ( location ) {
ffc08f7c: 80 01 00 0c lwz r0,12(r1)
ffc08f80: 2f 80 00 00 cmpwi cr7,r0,0
ffc08f84: 40 9e 00 74 bne- cr7,ffc08ff8 <pthread_rwlock_timedrdlock+0xbc>
int _EXFUN(pthread_rwlock_init,
(pthread_rwlock_t *__rwlock, _CONST pthread_rwlockattr_t *__attr));
int _EXFUN(pthread_rwlock_destroy, (pthread_rwlock_t *__rwlock));
int _EXFUN(pthread_rwlock_rdlock,(pthread_rwlock_t *__rwlock));
int _EXFUN(pthread_rwlock_tryrdlock,(pthread_rwlock_t *__rwlock));
int _EXFUN(pthread_rwlock_timedrdlock,
ffc08f88: 6b bf 00 03 xori r31,r29,3
case OBJECTS_LOCAL:
_CORE_RWLock_Obtain_for_reading(
ffc08f8c: 80 9c 00 00 lwz r4,0(r28)
ffc08f90: 7f ff 00 34 cntlzw r31,r31
ffc08f94: 80 c1 00 08 lwz r6,8(r1)
ffc08f98: 57 ff d9 7e rlwinm r31,r31,27,5,31
ffc08f9c: 38 63 00 10 addi r3,r3,16
ffc08fa0: 7f e5 fb 78 mr r5,r31
ffc08fa4: 38 e0 00 00 li r7,0
ffc08fa8: 48 00 20 2d bl ffc0afd4 <_CORE_RWLock_Obtain_for_reading>
do_wait,
ticks,
NULL
);
_Thread_Enable_dispatch();
ffc08fac: 48 00 3d 59 bl ffc0cd04 <_Thread_Enable_dispatch>
if ( !do_wait ) {
ffc08fb0: 2f 9f 00 00 cmpwi cr7,r31,0
ffc08fb4: 40 9e 00 30 bne- cr7,ffc08fe4 <pthread_rwlock_timedrdlock+0xa8>
if ( _Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE ) {
ffc08fb8: 3d 20 00 00 lis r9,0
ffc08fbc: 81 29 31 30 lwz r9,12592(r9)
ffc08fc0: 80 09 00 34 lwz r0,52(r9)
ffc08fc4: 2f 80 00 02 cmpwi cr7,r0,2
ffc08fc8: 40 be 00 1c bne+ cr7,ffc08fe4 <pthread_rwlock_timedrdlock+0xa8>
if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID )
ffc08fcc: 2f 9d 00 00 cmpwi cr7,r29,0
ffc08fd0: 41 be 00 28 beq+ cr7,ffc08ff8 <pthread_rwlock_timedrdlock+0xbc><== NEVER TAKEN
return EINVAL;
if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST ||
ffc08fd4: 3b bd ff ff addi r29,r29,-1
ffc08fd8: 2b 9d 00 01 cmplwi cr7,r29,1
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
return ETIMEDOUT;
ffc08fdc: 3b c0 00 74 li r30,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 ||
ffc08fe0: 40 9d 00 18 ble- cr7,ffc08ff8 <pthread_rwlock_timedrdlock+0xbc><== ALWAYS TAKEN
return ETIMEDOUT;
}
}
return _POSIX_RWLock_Translate_core_RWLock_return_code(
(CORE_RWLock_Status) _Thread_Executing->Wait.return_code
ffc08fe4: 3d 20 00 00 lis r9,0
ffc08fe8: 81 29 31 30 lwz r9,12592(r9)
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
return ETIMEDOUT;
}
}
return _POSIX_RWLock_Translate_core_RWLock_return_code(
ffc08fec: 80 69 00 34 lwz r3,52(r9)
ffc08ff0: 48 00 00 dd bl ffc090cc <_POSIX_RWLock_Translate_core_RWLock_return_code>
ffc08ff4: 7c 7e 1b 78 mr r30,r3
case OBJECTS_ERROR:
break;
}
return EINVAL;
}
ffc08ff8: 39 61 00 28 addi r11,r1,40
ffc08ffc: 7f c3 f3 78 mr r3,r30
ffc09000: 4b ff 8c 34 b ffc01c34 <_restgpr_28_x>
ffc09004 <pthread_rwlock_timedwrlock>:
int pthread_rwlock_timedwrlock(
pthread_rwlock_t *rwlock,
const struct timespec *abstime
)
{
ffc09004: 94 21 ff d8 stwu r1,-40(r1)
ffc09008: 7c 08 02 a6 mflr r0
ffc0900c: bf 81 00 18 stmw r28,24(r1)
Objects_Locations location;
Watchdog_Interval ticks;
bool do_wait = true;
POSIX_Absolute_timeout_conversion_results_t status;
if ( !rwlock )
ffc09010: 7c 7c 1b 79 mr. r28,r3
return EINVAL;
ffc09014: 3b c0 00 16 li r30,22
int pthread_rwlock_timedwrlock(
pthread_rwlock_t *rwlock,
const struct timespec *abstime
)
{
ffc09018: 90 01 00 2c stw r0,44(r1)
Objects_Locations location;
Watchdog_Interval ticks;
bool do_wait = true;
POSIX_Absolute_timeout_conversion_results_t status;
if ( !rwlock )
ffc0901c: 41 82 00 a4 beq- ffc090c0 <pthread_rwlock_timedwrlock+0xbc>
*
* If the status is POSIX_ABSOLUTE_TIMEOUT_INVALID,
* POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST, or POSIX_ABSOLUTE_TIMEOUT_IS_NOW,
* then we should not wait.
*/
status = _POSIX_Absolute_timeout_to_ticks( abstime, &ticks );
ffc09020: 7c 83 23 78 mr r3,r4
ffc09024: 38 81 00 08 addi r4,r1,8
ffc09028: 48 00 6e 09 bl ffc0fe30 <_POSIX_Absolute_timeout_to_ticks>
ffc0902c: 80 9c 00 00 lwz r4,0(r28)
ffc09030: 7c 7d 1b 78 mr r29,r3
ffc09034: 3c 60 00 00 lis r3,0
ffc09038: 38 63 2d ec addi r3,r3,11756
ffc0903c: 38 a1 00 0c addi r5,r1,12
ffc09040: 48 00 2d f9 bl ffc0be38 <_Objects_Get>
if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE )
do_wait = false;
the_rwlock = _POSIX_RWLock_Get( rwlock, &location );
switch ( location ) {
ffc09044: 80 01 00 0c lwz r0,12(r1)
ffc09048: 2f 80 00 00 cmpwi cr7,r0,0
ffc0904c: 40 9e 00 74 bne- cr7,ffc090c0 <pthread_rwlock_timedwrlock+0xbc>
(pthread_rwlock_t *__rwlock, _CONST struct timespec *__abstime));
int _EXFUN(pthread_rwlock_unlock,(pthread_rwlock_t *__rwlock));
int _EXFUN(pthread_rwlock_wrlock,(pthread_rwlock_t *__rwlock));
int _EXFUN(pthread_rwlock_trywrlock,(pthread_rwlock_t *__rwlock));
int _EXFUN(pthread_rwlock_timedwrlock,
ffc09050: 6b bf 00 03 xori r31,r29,3
case OBJECTS_LOCAL:
_CORE_RWLock_Obtain_for_writing(
ffc09054: 80 9c 00 00 lwz r4,0(r28)
ffc09058: 7f ff 00 34 cntlzw r31,r31
ffc0905c: 80 c1 00 08 lwz r6,8(r1)
ffc09060: 57 ff d9 7e rlwinm r31,r31,27,5,31
ffc09064: 38 63 00 10 addi r3,r3,16
ffc09068: 7f e5 fb 78 mr r5,r31
ffc0906c: 38 e0 00 00 li r7,0
ffc09070: 48 00 20 39 bl ffc0b0a8 <_CORE_RWLock_Obtain_for_writing>
do_wait,
ticks,
NULL
);
_Thread_Enable_dispatch();
ffc09074: 48 00 3c 91 bl ffc0cd04 <_Thread_Enable_dispatch>
if ( !do_wait &&
ffc09078: 2f 9f 00 00 cmpwi cr7,r31,0
ffc0907c: 40 9e 00 30 bne- cr7,ffc090ac <pthread_rwlock_timedwrlock+0xa8>
(_Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE) ) {
ffc09080: 3d 20 00 00 lis r9,0
ffc09084: 81 29 31 30 lwz r9,12592(r9)
ticks,
NULL
);
_Thread_Enable_dispatch();
if ( !do_wait &&
ffc09088: 80 09 00 34 lwz r0,52(r9)
ffc0908c: 2f 80 00 02 cmpwi cr7,r0,2
ffc09090: 40 be 00 1c bne+ cr7,ffc090ac <pthread_rwlock_timedwrlock+0xa8>
(_Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE) ) {
if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID )
ffc09094: 2f 9d 00 00 cmpwi cr7,r29,0
ffc09098: 41 be 00 28 beq+ cr7,ffc090c0 <pthread_rwlock_timedwrlock+0xbc><== NEVER TAKEN
return EINVAL;
if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST ||
ffc0909c: 3b bd ff ff addi r29,r29,-1
ffc090a0: 2b 9d 00 01 cmplwi cr7,r29,1
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
return ETIMEDOUT;
ffc090a4: 3b c0 00 74 li r30,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 ||
ffc090a8: 40 9d 00 18 ble- cr7,ffc090c0 <pthread_rwlock_timedwrlock+0xbc><== ALWAYS TAKEN
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
return ETIMEDOUT;
}
return _POSIX_RWLock_Translate_core_RWLock_return_code(
(CORE_RWLock_Status) _Thread_Executing->Wait.return_code
ffc090ac: 3d 20 00 00 lis r9,0
ffc090b0: 81 29 31 30 lwz r9,12592(r9)
if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST ||
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
return ETIMEDOUT;
}
return _POSIX_RWLock_Translate_core_RWLock_return_code(
ffc090b4: 80 69 00 34 lwz r3,52(r9)
ffc090b8: 48 00 00 15 bl ffc090cc <_POSIX_RWLock_Translate_core_RWLock_return_code>
ffc090bc: 7c 7e 1b 78 mr r30,r3
case OBJECTS_ERROR:
break;
}
return EINVAL;
}
ffc090c0: 39 61 00 28 addi r11,r1,40
ffc090c4: 7f c3 f3 78 mr r3,r30
ffc090c8: 4b ff 8b 6c b ffc01c34 <_restgpr_28_x>
ffc098f0 <pthread_rwlockattr_setpshared>:
int pthread_rwlockattr_setpshared(
pthread_rwlockattr_t *attr,
int pshared
)
{
if ( !attr )
ffc098f0: 2c 03 00 00 cmpwi r3,0
return EINVAL;
ffc098f4: 38 00 00 16 li r0,22
int pthread_rwlockattr_setpshared(
pthread_rwlockattr_t *attr,
int pshared
)
{
if ( !attr )
ffc098f8: 41 82 00 20 beq- ffc09918 <pthread_rwlockattr_setpshared+0x28>
return EINVAL;
if ( !attr->is_initialized )
ffc098fc: 81 23 00 00 lwz r9,0(r3)
ffc09900: 2f 89 00 00 cmpwi cr7,r9,0
ffc09904: 41 be 00 14 beq+ cr7,ffc09918 <pthread_rwlockattr_setpshared+0x28>
return EINVAL;
switch ( pshared ) {
ffc09908: 2b 84 00 01 cmplwi cr7,r4,1
ffc0990c: 41 9d 00 0c bgt- cr7,ffc09918 <pthread_rwlockattr_setpshared+0x28><== NEVER TAKEN
case PTHREAD_PROCESS_SHARED:
case PTHREAD_PROCESS_PRIVATE:
attr->process_shared = pshared;
ffc09910: 90 83 00 04 stw r4,4(r3)
return 0;
ffc09914: 38 00 00 00 li r0,0
default:
return EINVAL;
}
}
ffc09918: 7c 03 03 78 mr r3,r0
ffc0991c: 4e 80 00 20 blr
ffc0a968 <pthread_setschedparam>:
int pthread_setschedparam(
pthread_t thread,
int policy,
struct sched_param *param
)
{
ffc0a968: 94 21 ff d0 stwu r1,-48(r1)
ffc0a96c: 7c 08 02 a6 mflr r0
ffc0a970: bf 61 00 1c stmw r27,28(r1)
int rc;
/*
* Check all the parameters
*/
if ( !param )
ffc0a974: 7c bd 2b 79 mr. r29,r5
int pthread_setschedparam(
pthread_t thread,
int policy,
struct sched_param *param
)
{
ffc0a978: 7c 7c 1b 78 mr r28,r3
ffc0a97c: 90 01 00 34 stw r0,52(r1)
ffc0a980: 7c 9f 23 78 mr r31,r4
/*
* Check all the parameters
*/
if ( !param )
return EINVAL;
ffc0a984: 3b c0 00 16 li r30,22
int rc;
/*
* Check all the parameters
*/
if ( !param )
ffc0a988: 41 82 00 e8 beq- ffc0aa70 <pthread_setschedparam+0x108>
return EINVAL;
rc = _POSIX_Thread_Translate_sched_param(
ffc0a98c: 7c 83 23 78 mr r3,r4
ffc0a990: 38 a1 00 10 addi r5,r1,16
ffc0a994: 7f a4 eb 78 mr r4,r29
ffc0a998: 38 c1 00 0c addi r6,r1,12
ffc0a99c: 48 00 64 bd bl ffc10e58 <_POSIX_Thread_Translate_sched_param>
policy,
param,
&budget_algorithm,
&budget_callout
);
if ( rc )
ffc0a9a0: 7c 7e 1b 79 mr. r30,r3
ffc0a9a4: 40 a2 00 cc bne+ ffc0aa70 <pthread_setschedparam+0x108>
return rc;
/*
* Actually change the scheduling policy and parameters
*/
the_thread = _Thread_Get( thread, &location );
ffc0a9a8: 7f 83 e3 78 mr r3,r28
ffc0a9ac: 38 81 00 08 addi r4,r1,8
ffc0a9b0: 48 00 32 15 bl ffc0dbc4 <_Thread_Get>
switch ( location ) {
ffc0a9b4: 80 01 00 08 lwz r0,8(r1)
return rc;
/*
* Actually change the scheduling policy and parameters
*/
the_thread = _Thread_Get( thread, &location );
ffc0a9b8: 7c 7b 1b 78 mr r27,r3
switch ( location ) {
ffc0a9bc: 2f 80 00 00 cmpwi cr7,r0,0
ffc0a9c0: 40 9e 00 ac bne- cr7,ffc0aa6c <pthread_setschedparam+0x104>
case OBJECTS_LOCAL:
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
ffc0a9c4: 83 83 01 34 lwz r28,308(r3)
if ( api->schedpolicy == SCHED_SPORADIC )
ffc0a9c8: 80 1c 00 84 lwz r0,132(r28)
ffc0a9cc: 2f 80 00 04 cmpwi cr7,r0,4
ffc0a9d0: 40 be 00 0c bne+ cr7,ffc0a9dc <pthread_setschedparam+0x74>
(void) _Watchdog_Remove( &api->Sporadic_timer );
ffc0a9d4: 38 7c 00 a8 addi r3,r28,168
ffc0a9d8: 48 00 44 79 bl ffc0ee50 <_Watchdog_Remove>
api->schedpolicy = policy;
api->schedparam = *param;
the_thread->budget_algorithm = budget_algorithm;
the_thread->budget_callout = budget_callout;
switch ( api->schedpolicy ) {
ffc0a9dc: 2f 9f 00 00 cmpwi cr7,r31,0
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
if ( api->schedpolicy == SCHED_SPORADIC )
(void) _Watchdog_Remove( &api->Sporadic_timer );
api->schedpolicy = policy;
ffc0a9e0: 93 fc 00 84 stw r31,132(r28)
api->schedparam = *param;
ffc0a9e4: 38 9c 00 88 addi r4,r28,136
the_thread->budget_algorithm = budget_algorithm;
ffc0a9e8: 80 01 00 10 lwz r0,16(r1)
if ( api->schedpolicy == SCHED_SPORADIC )
(void) _Watchdog_Remove( &api->Sporadic_timer );
api->schedpolicy = policy;
api->schedparam = *param;
ffc0a9ec: 7c bd e4 aa lswi r5,r29,28
ffc0a9f0: 7c a4 e5 aa stswi r5,r4,28
the_thread->budget_algorithm = budget_algorithm;
ffc0a9f4: 90 1b 00 7c stw r0,124(r27)
the_thread->budget_callout = budget_callout;
ffc0a9f8: 80 01 00 0c lwz r0,12(r1)
ffc0a9fc: 90 1b 00 80 stw r0,128(r27)
switch ( api->schedpolicy ) {
ffc0aa00: 41 9c 00 64 blt- cr7,ffc0aa64 <pthread_setschedparam+0xfc><== NEVER TAKEN
ffc0aa04: 2f 9f 00 02 cmpwi cr7,r31,2
ffc0aa08: 40 9d 00 10 ble- cr7,ffc0aa18 <pthread_setschedparam+0xb0>
ffc0aa0c: 2f 9f 00 04 cmpwi cr7,r31,4
ffc0aa10: 40 be 00 54 bne+ cr7,ffc0aa64 <pthread_setschedparam+0xfc><== NEVER TAKEN
ffc0aa14: 48 00 00 34 b ffc0aa48 <pthread_setschedparam+0xe0>
case SCHED_OTHER:
case SCHED_FIFO:
case SCHED_RR:
the_thread->cpu_time_budget = _Thread_Ticks_per_timeslice;
ffc0aa18: 3d 20 00 00 lis r9,0
ffc0aa1c: 80 09 28 84 lwz r0,10372(r9)
ffc0aa20: 3d 20 00 00 lis r9,0
ffc0aa24: 88 89 27 64 lbz r4,10084(r9)
the_thread->real_priority =
_POSIX_Priority_To_core( api->schedparam.sched_priority );
_Thread_Change_priority(
ffc0aa28: 7f 63 db 78 mr r3,r27
switch ( api->schedpolicy ) {
case SCHED_OTHER:
case SCHED_FIFO:
case SCHED_RR:
the_thread->cpu_time_budget = _Thread_Ticks_per_timeslice;
ffc0aa2c: 90 1b 00 78 stw r0,120(r27)
the_thread->real_priority =
_POSIX_Priority_To_core( api->schedparam.sched_priority );
_Thread_Change_priority(
ffc0aa30: 38 a0 00 01 li r5,1
ffc0aa34: 80 1c 00 88 lwz r0,136(r28)
ffc0aa38: 7c 80 20 50 subf r4,r0,r4
case SCHED_OTHER:
case SCHED_FIFO:
case SCHED_RR:
the_thread->cpu_time_budget = _Thread_Ticks_per_timeslice;
the_thread->real_priority =
ffc0aa3c: 90 9b 00 18 stw r4,24(r27)
_POSIX_Priority_To_core( api->schedparam.sched_priority );
_Thread_Change_priority(
ffc0aa40: 48 00 2c 6d bl ffc0d6ac <_Thread_Change_priority>
the_thread,
the_thread->real_priority,
true
);
break;
ffc0aa44: 48 00 00 20 b ffc0aa64 <pthread_setschedparam+0xfc>
case SCHED_SPORADIC:
api->ss_high_priority = api->schedparam.sched_priority;
ffc0aa48: 80 1c 00 88 lwz r0,136(r28)
_Watchdog_Remove( &api->Sporadic_timer );
ffc0aa4c: 38 7c 00 a8 addi r3,r28,168
true
);
break;
case SCHED_SPORADIC:
api->ss_high_priority = api->schedparam.sched_priority;
ffc0aa50: 90 1c 00 a4 stw r0,164(r28)
_Watchdog_Remove( &api->Sporadic_timer );
ffc0aa54: 48 00 43 fd bl ffc0ee50 <_Watchdog_Remove>
_POSIX_Threads_Sporadic_budget_TSR( 0, the_thread );
ffc0aa58: 38 60 00 00 li r3,0
ffc0aa5c: 7f 64 db 78 mr r4,r27
ffc0aa60: 4b ff fd c1 bl ffc0a820 <_POSIX_Threads_Sporadic_budget_TSR>
break;
}
_Thread_Enable_dispatch();
ffc0aa64: 48 00 31 25 bl ffc0db88 <_Thread_Enable_dispatch>
return 0;
ffc0aa68: 48 00 00 08 b ffc0aa70 <pthread_setschedparam+0x108>
#endif
case OBJECTS_ERROR:
break;
}
return ESRCH;
ffc0aa6c: 3b c0 00 03 li r30,3
}
ffc0aa70: 39 61 00 30 addi r11,r1,48
ffc0aa74: 7f c3 f3 78 mr r3,r30
ffc0aa78: 4b ff 7e 54 b ffc028cc <_restgpr_27_x>
ffc08020 <pthread_testcancel>:
/*
* 18.2.2 Setting Cancelability State, P1003.1c/Draft 10, p. 183
*/
void pthread_testcancel( void )
{
ffc08020: 7c 08 02 a6 mflr r0
ffc08024: 7c 2b 0b 78 mr r11,r1
ffc08028: 94 21 ff f0 stwu r1,-16(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() )
ffc0802c: 3d 20 00 00 lis r9,0
ffc08030: 39 29 31 04 addi r9,r9,12548
/*
* 18.2.2 Setting Cancelability State, P1003.1c/Draft 10, p. 183
*/
void pthread_testcancel( void )
{
ffc08034: 90 01 00 14 stw r0,20(r1)
ffc08038: 48 00 e6 d1 bl ffc16708 <_savegpr_31>
* 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() )
ffc0803c: 80 09 00 08 lwz r0,8(r9)
ffc08040: 2f 80 00 00 cmpwi cr7,r0,0
ffc08044: 40 9e 00 5c bne- cr7,ffc080a0 <pthread_testcancel+0x80> <== NEVER TAKEN
return;
thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ];
ffc08048: 81 29 00 0c lwz r9,12(r9)
ffc0804c: 81 69 01 34 lwz r11,308(r9)
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
_Thread_Dispatch_disable_level++;
ffc08050: 3d 20 00 00 lis r9,0
ffc08054: 81 49 28 0c lwz r10,10252(r9)
ffc08058: 38 0a 00 01 addi r0,r10,1
ffc0805c: 90 09 28 0c stw r0,10252(r9)
return _Thread_Dispatch_disable_level;
ffc08060: 80 09 28 0c lwz r0,10252(r9)
_Thread_Disable_dispatch();
if ( thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE &&
ffc08064: 80 0b 00 d8 lwz r0,216(r11)
*/
void pthread_testcancel( void )
{
POSIX_API_Control *thread_support;
bool cancel = false;
ffc08068: 3b e0 00 00 li r31,0
return;
thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ];
_Thread_Disable_dispatch();
if ( thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE &&
ffc0806c: 2f 80 00 00 cmpwi cr7,r0,0
ffc08070: 40 9e 00 14 bne- cr7,ffc08084 <pthread_testcancel+0x64> <== NEVER TAKEN
/* Setting Cancelability State, P1003.1c/Draft 10, p. 183 */
int _EXFUN(pthread_setcancelstate, (int __state, int *__oldstate));
int _EXFUN(pthread_setcanceltype, (int __type, int *__oldtype));
void _EXFUN(pthread_testcancel, (void));
ffc08074: 80 0b 00 e0 lwz r0,224(r11)
ffc08078: 7c 00 00 34 cntlzw r0,r0
ffc0807c: 54 00 d9 7e rlwinm r0,r0,27,5,31
ffc08080: 68 1f 00 01 xori r31,r0,1
thread_support->cancelation_requested )
cancel = true;
_Thread_Enable_dispatch();
ffc08084: 48 00 30 4d bl ffc0b0d0 <_Thread_Enable_dispatch>
if ( cancel )
ffc08088: 2f 9f 00 00 cmpwi cr7,r31,0
ffc0808c: 41 be 00 14 beq+ cr7,ffc080a0 <pthread_testcancel+0x80>
_POSIX_Thread_Exit( _Thread_Executing, PTHREAD_CANCELED );
ffc08090: 3d 20 00 00 lis r9,0
ffc08094: 80 69 31 10 lwz r3,12560(r9)
ffc08098: 38 80 ff ff li r4,-1
ffc0809c: 48 00 64 21 bl ffc0e4bc <_POSIX_Thread_Exit>
}
ffc080a0: 39 61 00 10 addi r11,r1,16
ffc080a4: 48 00 e6 b0 b ffc16754 <_restgpr_31_x>
ffc0ca8c <ramdisk_allocate>:
void *area_begin,
uint32_t block_size,
rtems_blkdev_bnum block_count,
bool trace
)
{
ffc0ca8c: 94 21 ff e0 stwu r1,-32(r1)
ffc0ca90: 7c 08 02 a6 mflr r0
ffc0ca94: bf 61 00 0c stmw r27,12(r1)
ffc0ca98: 7c 7f 1b 78 mr r31,r3
struct ramdisk *rd = malloc(sizeof(struct ramdisk));
ffc0ca9c: 38 60 00 10 li r3,16
void *area_begin,
uint32_t block_size,
rtems_blkdev_bnum block_count,
bool trace
)
{
ffc0caa0: 90 01 00 24 stw r0,36(r1)
ffc0caa4: 7c 9e 23 78 mr r30,r4
ffc0caa8: 7c bd 2b 78 mr r29,r5
ffc0caac: 7c db 33 78 mr r27,r6
struct ramdisk *rd = malloc(sizeof(struct ramdisk));
ffc0cab0: 4b ff 8b 69 bl ffc05618 <malloc>
if (rd == NULL) {
ffc0cab4: 7c 7c 1b 79 mr. r28,r3
ffc0cab8: 41 82 00 54 beq- ffc0cb0c <ramdisk_allocate+0x80> <== NEVER TAKEN
return NULL;
}
if (area_begin == NULL) {
ffc0cabc: 2f 9f 00 00 cmpwi cr7,r31,0
return NULL;
}
rd->malloced = true;
} else {
rd->malloced = false;
ffc0cac0: 38 00 00 00 li r0,0
if (rd == NULL) {
return NULL;
}
if (area_begin == NULL) {
ffc0cac4: 40 be 00 2c bne+ cr7,ffc0caf0 <ramdisk_allocate+0x64> <== NEVER TAKEN
area_begin = calloc(block_count, block_size);
ffc0cac8: 7f a3 eb 78 mr r3,r29
ffc0cacc: 7f c4 f3 78 mr r4,r30
ffc0cad0: 4b ff 85 a1 bl ffc05070 <calloc>
if (area_begin == NULL) {
free(rd);
return NULL;
}
rd->malloced = true;
ffc0cad4: 38 00 00 01 li r0,1
return NULL;
}
if (area_begin == NULL) {
area_begin = calloc(block_count, block_size);
if (area_begin == NULL) {
ffc0cad8: 7c 7f 1b 79 mr. r31,r3
ffc0cadc: 40 a2 00 14 bne+ ffc0caf0 <ramdisk_allocate+0x64> <== ALWAYS TAKEN
free(rd);
ffc0cae0: 7f 83 e3 78 mr r3,r28 <== NOT EXECUTED
ffc0cae4: 4b ff 87 8d bl ffc05270 <free> <== NOT EXECUTED
return NULL;
ffc0cae8: 3b 80 00 00 li r28,0 <== NOT EXECUTED
ffc0caec: 48 00 00 20 b ffc0cb0c <ramdisk_allocate+0x80> <== NOT EXECUTED
}
rd->malloced = true;
} else {
rd->malloced = false;
ffc0caf0: 98 1c 00 0d stb r0,13(r28)
}
rd->block_size = block_size;
rd->block_num = block_count;
rd->area = area_begin;
rd->trace = trace;
rd->initialized = true;
ffc0caf4: 38 00 00 01 li r0,1
}
rd->malloced = true;
} else {
rd->malloced = false;
}
rd->block_size = block_size;
ffc0caf8: 93 dc 00 00 stw r30,0(r28)
rd->block_num = block_count;
ffc0cafc: 93 bc 00 04 stw r29,4(r28)
rd->area = area_begin;
ffc0cb00: 93 fc 00 08 stw r31,8(r28)
rd->trace = trace;
ffc0cb04: 9b 7c 00 0e stb r27,14(r28)
rd->initialized = true;
ffc0cb08: 98 1c 00 0c stb r0,12(r28)
return rd;
}
ffc0cb0c: 39 61 00 20 addi r11,r1,32
ffc0cb10: 7f 83 e3 78 mr r3,r28
ffc0cb14: 48 00 c9 f4 b ffc19508 <_restgpr_27_x>
ffc0cb18 <ramdisk_free>:
void ramdisk_free(ramdisk *rd)
{
ffc0cb18: 7c 2b 0b 78 mr r11,r1
ffc0cb1c: 94 21 ff f0 stwu r1,-16(r1)
ffc0cb20: 7c 08 02 a6 mflr r0
ffc0cb24: 48 00 c9 a9 bl ffc194cc <_savegpr_31>
if (rd != NULL) {
ffc0cb28: 7c 7f 1b 79 mr. r31,r3
return rd;
}
void ramdisk_free(ramdisk *rd)
{
ffc0cb2c: 90 01 00 14 stw r0,20(r1)
if (rd != NULL) {
ffc0cb30: 41 82 00 20 beq- ffc0cb50 <ramdisk_free+0x38> <== NEVER TAKEN
if (rd->malloced) {
ffc0cb34: 88 1f 00 0d lbz r0,13(r31)
ffc0cb38: 2f 80 00 00 cmpwi cr7,r0,0
ffc0cb3c: 41 be 00 0c beq+ cr7,ffc0cb48 <ramdisk_free+0x30> <== NEVER TAKEN
free(rd->area);
ffc0cb40: 80 7f 00 08 lwz r3,8(r31)
ffc0cb44: 4b ff 87 2d bl ffc05270 <free>
}
free(rd);
ffc0cb48: 7f e3 fb 78 mr r3,r31
ffc0cb4c: 4b ff 87 25 bl ffc05270 <free>
}
}
ffc0cb50: 39 61 00 10 addi r11,r1,16
ffc0cb54: 48 00 c9 c4 b ffc19518 <_restgpr_31_x>
ffc0c988 <ramdisk_ioctl>:
return 0;
}
int
ramdisk_ioctl(rtems_disk_device *dd, uint32_t req, void *argp)
{
ffc0c988: 94 21 ff e0 stwu r1,-32(r1)
ffc0c98c: 7c 08 02 a6 mflr r0
ffc0c990: 90 01 00 24 stw r0,36(r1)
switch (req)
ffc0c994: 6c 80 c0 18 xoris r0,r4,49176
ffc0c998: 2f 80 42 01 cmpwi cr7,r0,16897
return 0;
}
int
ramdisk_ioctl(rtems_disk_device *dd, uint32_t req, void *argp)
{
ffc0c99c: bf 61 00 0c stmw r27,12(r1)
ffc0c9a0: 7c bf 2b 78 mr r31,r5
switch (req)
ffc0c9a4: 40 9e 00 dc bne- cr7,ffc0ca80 <ramdisk_ioctl+0xf8>
case RTEMS_BLKIO_REQUEST:
{
rtems_blkdev_request *r = argp;
struct ramdisk *rd = rtems_disk_get_driver_data(dd);
switch (r->req)
ffc0c9a8: 80 05 00 00 lwz r0,0(r5)
break;
}
errno = EINVAL;
return -1;
}
ffc0c9ac: 83 a3 00 2c lwz r29,44(r3)
case RTEMS_BLKIO_REQUEST:
{
rtems_blkdev_request *r = argp;
struct ramdisk *rd = rtems_disk_get_driver_data(dd);
switch (r->req)
ffc0c9b0: 2f 80 00 00 cmpwi cr7,r0,0
ffc0c9b4: 41 9e 00 10 beq- cr7,ffc0c9c4 <ramdisk_ioctl+0x3c>
ffc0c9b8: 2f 80 00 01 cmpwi cr7,r0,1
ffc0c9bc: 40 be 00 b0 bne+ cr7,ffc0ca6c <ramdisk_ioctl+0xe4> <== NEVER TAKEN
ffc0c9c0: 48 00 00 48 b ffc0ca08 <ramdisk_ioctl+0x80>
#endif
static int
ramdisk_read(struct ramdisk *rd, rtems_blkdev_request *req)
{
uint8_t *from = rd->area;
ffc0c9c4: 83 7d 00 08 lwz r27,8(r29)
#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++)
ffc0c9c8: 3b c5 00 18 addi r30,r5,24
ffc0c9cc: 3b 80 00 00 li r28,0
ffc0c9d0: 48 00 00 28 b ffc0c9f8 <ramdisk_ioctl+0x70>
#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);
ffc0c9d4: 80 9e 00 00 lwz r4,0(r30)
#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++)
ffc0c9d8: 3b 9c 00 01 addi r28,r28,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);
ffc0c9dc: 80 1d 00 00 lwz r0,0(r29)
ffc0c9e0: 80 7e 00 08 lwz r3,8(r30)
ffc0c9e4: 7c 84 01 d6 mullw r4,r4,r0
ffc0c9e8: 80 be 00 04 lwz r5,4(r30)
#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++)
ffc0c9ec: 3b de 00 10 addi r30,r30,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);
ffc0c9f0: 7c 9b 22 14 add r4,r27,r4
ffc0c9f4: 48 00 88 75 bl ffc15268 <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++)
ffc0c9f8: 80 1f 00 10 lwz r0,16(r31)
ffc0c9fc: 7f 9c 00 40 cmplw cr7,r28,r0
ffc0ca00: 41 9c ff d4 blt+ cr7,ffc0c9d4 <ramdisk_ioctl+0x4c>
ffc0ca04: 48 00 00 44 b ffc0ca48 <ramdisk_ioctl+0xc0>
}
static int
ramdisk_write(struct ramdisk *rd, rtems_blkdev_request *req)
{
uint8_t *to = rd->area;
ffc0ca08: 83 7d 00 08 lwz r27,8(r29)
#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++)
ffc0ca0c: 3b c5 00 18 addi r30,r5,24
ffc0ca10: 3b 80 00 00 li r28,0
ffc0ca14: 48 00 00 28 b ffc0ca3c <ramdisk_ioctl+0xb4>
#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);
ffc0ca18: 80 7e 00 00 lwz r3,0(r30)
#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++)
ffc0ca1c: 3b 9c 00 01 addi r28,r28,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);
ffc0ca20: 80 1d 00 00 lwz r0,0(r29)
ffc0ca24: 80 9e 00 08 lwz r4,8(r30)
ffc0ca28: 7c 63 01 d6 mullw r3,r3,r0
ffc0ca2c: 80 be 00 04 lwz r5,4(r30)
#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++)
ffc0ca30: 3b de 00 10 addi r30,r30,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);
ffc0ca34: 7c 7b 1a 14 add r3,r27,r3
ffc0ca38: 48 00 88 31 bl ffc15268 <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++)
ffc0ca3c: 80 1f 00 10 lwz r0,16(r31)
ffc0ca40: 7f 9c 00 40 cmplw cr7,r28,r0
ffc0ca44: 41 9c ff d4 blt+ cr7,ffc0ca18 <ramdisk_ioctl+0x90>
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;
ffc0ca48: 38 00 00 00 li r0,0
req->req_done(req->done_arg, RTEMS_SUCCESSFUL);
ffc0ca4c: 80 7f 00 08 lwz r3,8(r31)
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;
ffc0ca50: 90 1f 00 0c stw r0,12(r31)
req->req_done(req->done_arg, RTEMS_SUCCESSFUL);
ffc0ca54: 38 80 00 00 li r4,0
ffc0ca58: 80 1f 00 04 lwz r0,4(r31)
ffc0ca5c: 7c 09 03 a6 mtctr r0
ffc0ca60: 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);
ffc0ca64: 38 60 00 00 li r3,0
ffc0ca68: 48 00 00 1c b ffc0ca84 <ramdisk_ioctl+0xfc>
default:
errno = EINVAL;
ffc0ca6c: 48 00 7b d1 bl ffc1463c <__errno> <== NOT EXECUTED
ffc0ca70: 38 00 00 16 li r0,22 <== NOT EXECUTED
ffc0ca74: 90 03 00 00 stw r0,0(r3) <== NOT EXECUTED
return -1;
ffc0ca78: 38 60 ff ff li r3,-1 <== NOT EXECUTED
ffc0ca7c: 48 00 00 08 b ffc0ca84 <ramdisk_ioctl+0xfc> <== NOT EXECUTED
}
break;
}
default:
return rtems_blkdev_ioctl (dd, req, argp);
ffc0ca80: 48 00 2b 1d bl ffc0f59c <rtems_blkdev_ioctl>
break;
}
errno = EINVAL;
return -1;
}
ffc0ca84: 39 61 00 20 addi r11,r1,32
ffc0ca88: 48 00 ca 80 b ffc19508 <_restgpr_27_x>
ffc0cb58 <ramdisk_register>:
rtems_blkdev_bnum block_count,
bool trace,
const char *disk,
dev_t *dev_ptr
)
{
ffc0cb58: 94 21 ff c8 stwu r1,-56(r1)
ffc0cb5c: 7c 08 02 a6 mflr r0
ffc0cb60: bf 21 00 1c stmw r25,28(r1)
ffc0cb64: 7c bf 2b 78 mr r31,r5
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_device_major_number major = 0;
ffc0cb68: 7c 25 0b 78 mr r5,r1
rtems_blkdev_bnum block_count,
bool trace,
const char *disk,
dev_t *dev_ptr
)
{
ffc0cb6c: 90 01 00 3c stw r0,60(r1)
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_device_major_number major = 0;
ffc0cb70: 38 00 00 00 li r0,0
rtems_blkdev_bnum block_count,
bool trace,
const char *disk,
dev_t *dev_ptr
)
{
ffc0cb74: 7c 9a 23 78 mr r26,r4
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_device_major_number major = 0;
ffc0cb78: 94 05 00 08 stwu r0,8(r5)
ramdisk *rd = NULL;
dev_t dev = 0;
sc = rtems_io_register_driver(0, &ramdisk_ops, &major);
ffc0cb7c: 3c 80 ff c2 lis r4,-62
rtems_blkdev_bnum block_count,
bool trace,
const char *disk,
dev_t *dev_ptr
)
{
ffc0cb80: 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);
ffc0cb84: 38 84 b0 10 addi r4,r4,-20464
ffc0cb88: 38 60 00 00 li r3,0
rtems_blkdev_bnum block_count,
bool trace,
const char *disk,
dev_t *dev_ptr
)
{
ffc0cb8c: 7c db 33 78 mr r27,r6
ffc0cb90: 7c fd 3b 78 mr r29,r7
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);
ffc0cb94: 4b ff c8 0d bl ffc093a0 <rtems_io_register_driver>
if (sc != RTEMS_SUCCESSFUL) {
ffc0cb98: 2f 83 00 00 cmpwi cr7,r3,0
return RTEMS_UNSATISFIED;
ffc0cb9c: 3b c0 00 0d li r30,13
rtems_device_major_number major = 0;
ramdisk *rd = NULL;
dev_t dev = 0;
sc = rtems_io_register_driver(0, &ramdisk_ops, &major);
if (sc != RTEMS_SUCCESSFUL) {
ffc0cba0: 40 be 00 6c bne+ cr7,ffc0cc0c <ramdisk_register+0xb4> <== NEVER TAKEN
return RTEMS_UNSATISFIED;
}
rd = ramdisk_allocate(NULL, block_size, block_count, trace);
ffc0cba4: 7f e6 fb 78 mr r6,r31
ffc0cba8: 7f 24 cb 78 mr r4,r25
ffc0cbac: 7f 45 d3 78 mr r5,r26
ffc0cbb0: 4b ff fe dd bl ffc0ca8c <ramdisk_allocate>
ffc0cbb4: 83 e1 00 08 lwz r31,8(r1)
if (rd == NULL) {
ffc0cbb8: 7c 7c 1b 79 mr. r28,r3
rtems_io_unregister_driver(major);
ffc0cbbc: 7f e3 fb 78 mr r3,r31
if (sc != RTEMS_SUCCESSFUL) {
return RTEMS_UNSATISFIED;
}
rd = ramdisk_allocate(NULL, block_size, block_count, trace);
if (rd == NULL) {
ffc0cbc0: 41 82 00 38 beq- ffc0cbf8 <ramdisk_register+0xa0> <== NEVER TAKEN
return RTEMS_UNSATISFIED;
}
dev = rtems_filesystem_make_dev_t(major, 0);
sc = rtems_disk_create_phys(
ffc0cbc4: 3c e0 ff c1 lis r7,-63
ffc0cbc8: 38 80 00 00 li r4,0
ffc0cbcc: 7f 25 cb 78 mr r5,r25
ffc0cbd0: 7f 46 d3 78 mr r6,r26
ffc0cbd4: 38 e7 c9 88 addi r7,r7,-13944
ffc0cbd8: 7f 88 e3 78 mr r8,r28
ffc0cbdc: 7f 69 db 78 mr r9,r27
ffc0cbe0: 4b ff 75 d1 bl ffc041b0 <rtems_disk_create_phys>
block_count,
ramdisk_ioctl,
rd,
disk
);
if (sc != RTEMS_SUCCESSFUL) {
ffc0cbe4: 2c 03 00 00 cmpwi r3,0
ffc0cbe8: 41 82 00 18 beq- ffc0cc00 <ramdisk_register+0xa8> <== ALWAYS TAKEN
ramdisk_free(rd);
ffc0cbec: 7f 83 e3 78 mr r3,r28 <== NOT EXECUTED
ffc0cbf0: 4b ff ff 29 bl ffc0cb18 <ramdisk_free> <== NOT EXECUTED
rtems_io_unregister_driver(major);
ffc0cbf4: 80 61 00 08 lwz r3,8(r1) <== NOT EXECUTED
ffc0cbf8: 4b ff c9 15 bl ffc0950c <rtems_io_unregister_driver> <== NOT EXECUTED
return RTEMS_UNSATISFIED;
ffc0cbfc: 48 00 00 10 b ffc0cc0c <ramdisk_register+0xb4> <== NOT EXECUTED
}
*dev_ptr = dev;
ffc0cc00: 93 fd 00 00 stw r31,0(r29)
return RTEMS_SUCCESSFUL;
ffc0cc04: 3b c0 00 00 li r30,0
rtems_io_unregister_driver(major);
return RTEMS_UNSATISFIED;
}
*dev_ptr = dev;
ffc0cc08: 90 7d 00 04 stw r3,4(r29)
return RTEMS_SUCCESSFUL;
}
ffc0cc0c: 39 61 00 38 addi r11,r1,56
ffc0cc10: 7f c3 f3 78 mr r3,r30
ffc0cc14: 48 00 c8 ec b ffc19500 <_restgpr_25_x>
ffc1b958 <read>:
ssize_t read(
int fd,
void *buffer,
size_t count
)
{
ffc1b958: 7c 08 02 a6 mflr r0
ffc1b95c: 7c 2b 0b 78 mr r11,r1
ffc1b960: 94 21 ff f0 stwu r1,-16(r1)
ssize_t rc;
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
ffc1b964: 3d 40 00 00 lis r10,0
ssize_t read(
int fd,
void *buffer,
size_t count
)
{
ffc1b968: 90 01 00 14 stw r0,20(r1)
ffc1b96c: 4b ff f9 e1 bl ffc1b34c <_savegpr_31>
ssize_t rc;
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
ffc1b970: 80 0a 27 3c lwz r0,10044(r10)
ffc1b974: 7f 83 00 40 cmplw cr7,r3,r0
ffc1b978: 40 9c 00 48 bge- cr7,ffc1b9c0 <read+0x68>
iop = rtems_libio_iop( fd );
ffc1b97c: 3d 40 00 00 lis r10,0
ffc1b980: 83 ea 27 f0 lwz r31,10224(r10)
ffc1b984: 54 63 30 32 rlwinm r3,r3,6,0,25
ffc1b988: 7f ff 1a 14 add r31,r31,r3
rtems_libio_check_is_open( iop );
ffc1b98c: 80 1f 00 18 lwz r0,24(r31)
ffc1b990: 70 0a 01 00 andi. r10,r0,256
ffc1b994: 41 82 00 2c beq- ffc1b9c0 <read+0x68>
rtems_libio_check_buffer( buffer );
ffc1b998: 2f 84 00 00 cmpwi cr7,r4,0
ffc1b99c: 40 be 00 10 bne+ cr7,ffc1b9ac <read+0x54> <== ALWAYS TAKEN
ffc1b9a0: 4b ff 52 15 bl ffc10bb4 <__errno> <== NOT EXECUTED
ffc1b9a4: 38 00 00 16 li r0,22 <== NOT EXECUTED
ffc1b9a8: 48 00 00 20 b ffc1b9c8 <read+0x70> <== NOT EXECUTED
rtems_libio_check_count( count );
ffc1b9ac: 2f 85 00 00 cmpwi cr7,r5,0
ffc1b9b0: 38 60 00 00 li r3,0
ffc1b9b4: 41 9e 00 5c beq- cr7,ffc1ba10 <read+0xb8>
rtems_libio_check_permissions_with_error( iop, LIBIO_FLAGS_READ, EBADF );
ffc1b9b8: 70 09 00 02 andi. r9,r0,2
ffc1b9bc: 40 a2 00 18 bne+ ffc1b9d4 <read+0x7c>
ffc1b9c0: 4b ff 51 f5 bl ffc10bb4 <__errno>
ffc1b9c4: 38 00 00 09 li r0,9
ffc1b9c8: 90 03 00 00 stw r0,0(r3)
ffc1b9cc: 38 60 ff ff li r3,-1
ffc1b9d0: 48 00 00 40 b ffc1ba10 <read+0xb8>
/*
* Now process the read().
*/
rc = (*iop->pathinfo.handlers->read_h)( iop, buffer, count );
ffc1b9d4: 81 3f 00 24 lwz r9,36(r31)
ffc1b9d8: 7f e3 fb 78 mr r3,r31
ffc1b9dc: 80 09 00 08 lwz r0,8(r9)
ffc1b9e0: 7c 09 03 a6 mtctr r0
ffc1b9e4: 4e 80 04 21 bctrl
if ( rc > 0 )
ffc1b9e8: 2c 03 00 00 cmpwi r3,0
ffc1b9ec: 40 81 00 24 ble- ffc1ba10 <read+0xb8>
iop->offset += rc;
ffc1b9f0: 81 1f 00 10 lwz r8,16(r31)
ffc1b9f4: 7c 6b 1b 78 mr r11,r3
ffc1b9f8: 81 3f 00 14 lwz r9,20(r31)
ffc1b9fc: 7c 6a fe 70 srawi r10,r3,31
ffc1ba00: 7d 6b 48 14 addc r11,r11,r9
ffc1ba04: 7d 4a 41 14 adde r10,r10,r8
ffc1ba08: 91 5f 00 10 stw r10,16(r31)
ffc1ba0c: 91 7f 00 14 stw r11,20(r31)
return rc;
}
ffc1ba10: 39 61 00 10 addi r11,r1,16
ffc1ba14: 4b fe 4b 30 b ffc00544 <_restgpr_31_x>
ffc06bb0 <readlink>:
ssize_t readlink(
const char *pathname,
char *buf,
size_t bufsize
)
{
ffc06bb0: 94 21 ff c8 stwu r1,-56(r1)
ffc06bb4: 7c 08 02 a6 mflr r0
ffc06bb8: bf a1 00 2c stmw r29,44(r1)
rtems_filesystem_location_info_t loc;
int result;
if (!buf)
ffc06bbc: 7c 9e 23 79 mr. r30,r4
ssize_t readlink(
const char *pathname,
char *buf,
size_t bufsize
)
{
ffc06bc0: 7c 7d 1b 78 mr r29,r3
ffc06bc4: 90 01 00 3c stw r0,60(r1)
ffc06bc8: 7c bf 2b 78 mr r31,r5
rtems_filesystem_location_info_t loc;
int result;
if (!buf)
ffc06bcc: 40 a2 00 18 bne+ ffc06be4 <readlink+0x34>
rtems_set_errno_and_return_minus_one( EFAULT );
ffc06bd0: 48 00 b4 55 bl ffc12024 <__errno>
ffc06bd4: 38 00 00 0e li r0,14
ffc06bd8: 90 03 00 00 stw r0,0(r3)
ffc06bdc: 3b a0 ff ff li r29,-1
ffc06be0: 48 00 00 88 b ffc06c68 <readlink+0xb8>
result = rtems_filesystem_evaluate_path( pathname, strlen( pathname ),
ffc06be4: 48 00 cb 05 bl ffc136e8 <strlen>
ffc06be8: 38 a0 00 00 li r5,0
ffc06bec: 7c 64 1b 78 mr r4,r3
ffc06bf0: 38 c1 00 08 addi r6,r1,8
ffc06bf4: 7f a3 eb 78 mr r3,r29
ffc06bf8: 38 e0 00 00 li r7,0
ffc06bfc: 4b ff e9 29 bl ffc05524 <rtems_filesystem_evaluate_path>
0, &loc, false );
if ( result != 0 )
return -1;
ffc06c00: 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 )
ffc06c04: 2f 83 00 00 cmpwi cr7,r3,0
ffc06c08: 40 9e 00 60 bne- cr7,ffc06c68 <readlink+0xb8> <== NEVER TAKEN
return -1;
if ( (*loc.ops->node_type_h)( &loc ) != RTEMS_FILESYSTEM_SYM_LINK ){
ffc06c0c: 81 21 00 14 lwz r9,20(r1)
ffc06c10: 38 61 00 08 addi r3,r1,8
ffc06c14: 80 09 00 10 lwz r0,16(r9)
ffc06c18: 7c 09 03 a6 mtctr r0
ffc06c1c: 4e 80 04 21 bctrl
ffc06c20: 2f 83 00 04 cmpwi cr7,r3,4
ffc06c24: 41 be 00 1c beq+ cr7,ffc06c40 <readlink+0x90>
rtems_filesystem_freenode( &loc );
ffc06c28: 38 61 00 08 addi r3,r1,8
ffc06c2c: 4b ff ea e9 bl ffc05714 <rtems_filesystem_freenode>
rtems_set_errno_and_return_minus_one( EINVAL );
ffc06c30: 48 00 b3 f5 bl ffc12024 <__errno>
ffc06c34: 38 00 00 16 li r0,22
ffc06c38: 90 03 00 00 stw r0,0(r3)
ffc06c3c: 48 00 00 2c b ffc06c68 <readlink+0xb8>
}
result = (*loc.ops->readlink_h)( &loc, buf, bufsize );
ffc06c40: 81 21 00 14 lwz r9,20(r1)
ffc06c44: 38 61 00 08 addi r3,r1,8
ffc06c48: 7f c4 f3 78 mr r4,r30
ffc06c4c: 80 09 00 3c lwz r0,60(r9)
ffc06c50: 7f e5 fb 78 mr r5,r31
ffc06c54: 7c 09 03 a6 mtctr r0
ffc06c58: 4e 80 04 21 bctrl
ffc06c5c: 7c 7d 1b 78 mr r29,r3
rtems_filesystem_freenode( &loc );
ffc06c60: 38 61 00 08 addi r3,r1,8
ffc06c64: 4b ff ea b1 bl ffc05714 <rtems_filesystem_freenode>
return result;
}
ffc06c68: 39 61 00 38 addi r11,r1,56
ffc06c6c: 7f a3 eb 78 mr r3,r29
ffc06c70: 4b ff a6 b8 b ffc01328 <_restgpr_29_x>
ffc06520 <readv>:
ssize_t readv(
int fd,
const struct iovec *iov,
int iovcnt
)
{
ffc06520: 94 21 ff d8 stwu r1,-40(r1)
ffc06524: 7c 08 02 a6 mflr r0
int v;
int bytes;
rtems_libio_t *iop;
bool all_zeros;
rtems_libio_check_fd( fd );
ffc06528: 3d 20 00 00 lis r9,0
ssize_t readv(
int fd,
const struct iovec *iov,
int iovcnt
)
{
ffc0652c: 90 01 00 2c stw r0,44(r1)
int v;
int bytes;
rtems_libio_t *iop;
bool all_zeros;
rtems_libio_check_fd( fd );
ffc06530: 80 09 27 1c lwz r0,10012(r9)
ssize_t readv(
int fd,
const struct iovec *iov,
int iovcnt
)
{
ffc06534: bf 01 00 08 stmw r24,8(r1)
ffc06538: 7c 9a 23 78 mr r26,r4
int v;
int bytes;
rtems_libio_t *iop;
bool all_zeros;
rtems_libio_check_fd( fd );
ffc0653c: 7f 83 00 40 cmplw cr7,r3,r0
ffc06540: 40 9c 00 28 bge- cr7,ffc06568 <readv+0x48>
iop = rtems_libio_iop( fd );
ffc06544: 3d 20 00 00 lis r9,0
ffc06548: 83 69 27 cc lwz r27,10188(r9)
ffc0654c: 54 63 30 32 rlwinm r3,r3,6,0,25
ffc06550: 7f 7b 1a 14 add r27,r27,r3
rtems_libio_check_is_open( iop );
ffc06554: 80 1b 00 18 lwz r0,24(r27)
ffc06558: 70 09 01 00 andi. r9,r0,256
ffc0655c: 41 82 00 0c beq- ffc06568 <readv+0x48>
rtems_libio_check_permissions_with_error( iop, LIBIO_FLAGS_READ, EBADF );
ffc06560: 70 09 00 02 andi. r9,r0,2
ffc06564: 40 a2 00 10 bne+ ffc06574 <readv+0x54> <== ALWAYS TAKEN
ffc06568: 48 00 b0 9d bl ffc11604 <__errno>
ffc0656c: 38 00 00 09 li r0,9
ffc06570: 48 00 00 5c b ffc065cc <readv+0xac>
/*
* Argument validation on IO vector
*/
if ( !iov )
ffc06574: 2f 84 00 00 cmpwi cr7,r4,0
ffc06578: 41 9e 00 4c beq- cr7,ffc065c4 <readv+0xa4>
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iovcnt <= 0 )
ffc0657c: 2f 85 00 00 cmpwi cr7,r5,0
ffc06580: 40 9d 00 44 ble- cr7,ffc065c4 <readv+0xa4>
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iovcnt > IOV_MAX )
ffc06584: 2f 85 04 00 cmpwi cr7,r5,1024
ffc06588: 41 9d 00 3c bgt- cr7,ffc065c4 <readv+0xa4> <== NEVER TAKEN
rtems_set_errno_and_return_minus_one( EINVAL );
ffc0658c: 7c 89 23 78 mr r9,r4
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iovcnt <= 0 )
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iovcnt > IOV_MAX )
ffc06590: 7c a9 03 a6 mtctr r5
ffc06594: 38 00 00 01 li r0,1
ffc06598: 3b 00 00 00 li r24,0
ffc0659c: 39 60 00 00 li r11,0
ffc065a0: 48 00 00 08 b ffc065a8 <readv+0x88>
if ( iov[v].iov_base == 0 )
rtems_set_errno_and_return_minus_one( EINVAL );
/* check for wrap */
old = total;
total += iov[v].iov_len;
ffc065a4: 7d 0b 43 78 mr r11,r8
/*
* 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 )
ffc065a8: 81 49 00 00 lwz r10,0(r9)
ffc065ac: 2f 8a 00 00 cmpwi cr7,r10,0
ffc065b0: 41 9e 00 14 beq- cr7,ffc065c4 <readv+0xa4>
rtems_set_errno_and_return_minus_one( EINVAL );
/* check for wrap */
old = total;
total += iov[v].iov_len;
ffc065b4: 81 49 00 04 lwz r10,4(r9)
ffc065b8: 7d 0a 5a 14 add r8,r10,r11
if ( total < old )
ffc065bc: 7f 88 58 00 cmpw cr7,r8,r11
ffc065c0: 40 bc 00 14 bge+ cr7,ffc065d4 <readv+0xb4>
rtems_set_errno_and_return_minus_one( EINVAL );
ffc065c4: 48 00 b0 41 bl ffc11604 <__errno>
ffc065c8: 38 00 00 16 li r0,22
ffc065cc: 90 03 00 00 stw r0,0(r3)
ffc065d0: 48 00 00 9c b ffc0666c <readv+0x14c>
if ( iov[v].iov_len )
all_zeros = false;
ffc065d4: 31 4a ff ff addic r10,r10,-1
ffc065d8: 7d 4a 51 10 subfe r10,r10,r10
ffc065dc: 7c 00 50 38 and r0,r0,r10
* 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++ ) {
ffc065e0: 3b 18 00 01 addi r24,r24,1
ffc065e4: 39 29 00 08 addi r9,r9,8
ffc065e8: 42 00 ff bc bdnz+ ffc065a4 <readv+0x84>
/*
* 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 ) {
ffc065ec: 2f 80 00 00 cmpwi cr7,r0,0
return 0;
ffc065f0: 3b a0 00 00 li r29,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 ) {
ffc065f4: 40 9e 00 7c bne- cr7,ffc06670 <readv+0x150>
#include <sys/uio.h>
#include <rtems/libio_.h>
#include <rtems/seterr.h>
ssize_t readv(
ffc065f8: 57 18 18 38 rlwinm r24,r24,3,0,28
ffc065fc: 3b 80 00 00 li r28,0
/*
* Now process the readv().
*/
for ( total=0, v=0 ; v < iovcnt ; v++ ) {
bytes = (*iop->pathinfo.handlers->read_h)(
ffc06600: 81 3b 00 24 lwz r9,36(r27)
#include <sys/uio.h>
#include <rtems/libio_.h>
#include <rtems/seterr.h>
ssize_t readv(
ffc06604: 7f 3a e2 14 add r25,r26,r28
/*
* Now process the readv().
*/
for ( total=0, v=0 ; v < iovcnt ; v++ ) {
bytes = (*iop->pathinfo.handlers->read_h)(
ffc06608: 7f 63 db 78 mr r3,r27
ffc0660c: 7c 9a e0 2e lwzx r4,r26,r28
ffc06610: 80 09 00 08 lwz r0,8(r9)
ffc06614: 80 b9 00 04 lwz r5,4(r25)
ffc06618: 7c 09 03 a6 mtctr r0
ffc0661c: 4e 80 04 21 bctrl
iop,
iov[v].iov_base,
iov[v].iov_len
);
if ( bytes < 0 )
ffc06620: 2c 03 00 00 cmpwi r3,0
ffc06624: 41 80 00 48 blt- ffc0666c <readv+0x14c> <== NEVER TAKEN
return -1;
if ( bytes > 0 ) {
ffc06628: 41 82 00 28 beq- ffc06650 <readv+0x130> <== NEVER TAKEN
iop->offset += bytes;
ffc0662c: 81 5b 00 10 lwz r10,16(r27)
ffc06630: 7c 7f 1b 78 mr r31,r3
ffc06634: 81 7b 00 14 lwz r11,20(r27)
ffc06638: 7c 7e fe 70 srawi r30,r3,31
total += bytes;
ffc0663c: 7f bd 1a 14 add r29,r29,r3
if ( bytes < 0 )
return -1;
if ( bytes > 0 ) {
iop->offset += bytes;
ffc06640: 7d 6b f8 14 addc r11,r11,r31
ffc06644: 7d 4a f1 14 adde r10,r10,r30
ffc06648: 91 5b 00 10 stw r10,16(r27)
ffc0664c: 91 7b 00 14 stw r11,20(r27)
total += bytes;
}
if (bytes != iov[ v ].iov_len)
ffc06650: 80 19 00 04 lwz r0,4(r25)
ffc06654: 7f 83 00 00 cmpw cr7,r3,r0
ffc06658: 40 9e 00 18 bne- cr7,ffc06670 <readv+0x150> <== NEVER TAKEN
ffc0665c: 3b 9c 00 08 addi r28,r28,8
}
/*
* Now process the readv().
*/
for ( total=0, v=0 ; v < iovcnt ; v++ ) {
ffc06660: 7f 9c c0 00 cmpw cr7,r28,r24
ffc06664: 40 9e ff 9c bne+ cr7,ffc06600 <readv+0xe0>
ffc06668: 48 00 00 08 b ffc06670 <readv+0x150>
iov[v].iov_base,
iov[v].iov_len
);
if ( bytes < 0 )
return -1;
ffc0666c: 3b a0 ff ff li r29,-1
if (bytes != iov[ v ].iov_len)
break;
}
return total;
}
ffc06670: 39 61 00 28 addi r11,r1,40
ffc06674: 7f a3 eb 78 mr r3,r29
ffc06678: 4b ff a4 fc b ffc00b74 <_restgpr_24_x>
ffc1baa8 <realloc>:
void *realloc(
void *ptr,
size_t size
)
{
ffc1baa8: 94 21 ff d8 stwu r1,-40(r1)
ffc1baac: 7c 08 02 a6 mflr r0
uintptr_t old_size;
char *new_area;
MSBUMP(realloc_calls, 1);
ffc1bab0: 3d 20 00 00 lis r9,0
void *realloc(
void *ptr,
size_t size
)
{
ffc1bab4: 90 01 00 2c stw r0,44(r1)
uintptr_t old_size;
char *new_area;
MSBUMP(realloc_calls, 1);
ffc1bab8: 39 29 2b 60 addi r9,r9,11104
ffc1babc: 81 69 00 10 lwz r11,16(r9)
void *realloc(
void *ptr,
size_t size
)
{
ffc1bac0: bf a1 00 1c stmw r29,28(r1)
ffc1bac4: 7c 7f 1b 78 mr r31,r3
uintptr_t old_size;
char *new_area;
MSBUMP(realloc_calls, 1);
ffc1bac8: 38 0b 00 01 addi r0,r11,1
ffc1bacc: 90 09 00 10 stw r0,16(r9)
/*
* Do not attempt to allocate memory if in a critical section or ISR.
*/
if (_System_state_Is_up(_System_state_Get())) {
ffc1bad0: 3d 20 00 00 lis r9,0
void *realloc(
void *ptr,
size_t size
)
{
ffc1bad4: 7c 9e 23 78 mr r30,r4
/*
* Do not attempt to allocate memory if in a critical section or ISR.
*/
if (_System_state_Is_up(_System_state_Get())) {
ffc1bad8: 80 09 28 48 lwz r0,10312(r9)
ffc1badc: 2f 80 00 03 cmpwi cr7,r0,3
ffc1bae0: 40 be 00 24 bne+ cr7,ffc1bb04 <realloc+0x5c> <== NEVER TAKEN
* 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 )
ffc1bae4: 3d 20 00 00 lis r9,0
ffc1bae8: 80 09 28 0c lwz r0,10252(r9)
ffc1baec: 2f 80 00 00 cmpwi cr7,r0,0
ffc1baf0: 40 9e 00 d8 bne- cr7,ffc1bbc8 <realloc+0x120> <== NEVER TAKEN
if (_Thread_Dispatch_in_critical_section())
return (void *) 0;
if (_ISR_Nest_level > 0)
ffc1baf4: 3d 20 00 00 lis r9,0
ffc1baf8: 80 09 31 4c lwz r0,12620(r9)
ffc1bafc: 2f 80 00 00 cmpwi cr7,r0,0
ffc1bb00: 40 9e 00 c8 bne- cr7,ffc1bbc8 <realloc+0x120> <== NEVER TAKEN
}
/*
* Continue with realloc().
*/
if ( !ptr )
ffc1bb04: 2f 9f 00 00 cmpwi cr7,r31,0
ffc1bb08: 40 be 00 14 bne+ cr7,ffc1bb1c <realloc+0x74>
return malloc( size );
ffc1bb0c: 7f c3 f3 78 mr r3,r30
ffc1bb10: 4b fe 91 f5 bl ffc04d04 <malloc>
ffc1bb14: 7c 7f 1b 78 mr r31,r3
ffc1bb18: 48 00 00 b4 b ffc1bbcc <realloc+0x124>
if ( !size ) {
ffc1bb1c: 2f 9e 00 00 cmpwi cr7,r30,0
ffc1bb20: 40 be 00 10 bne+ cr7,ffc1bb30 <realloc+0x88> <== ALWAYS TAKEN
free( ptr );
ffc1bb24: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc1bb28: 4b fe 8e 35 bl ffc0495c <free> <== NOT EXECUTED
ffc1bb2c: 48 00 00 9c b ffc1bbc8 <realloc+0x120> <== NOT EXECUTED
return (void *) 0;
}
if ( !_Protected_heap_Get_block_size(RTEMS_Malloc_Heap, ptr, &old_size) ) {
ffc1bb30: 3f a0 00 00 lis r29,0
ffc1bb34: 80 7d 27 2c lwz r3,10028(r29)
ffc1bb38: 7f e4 fb 78 mr r4,r31
ffc1bb3c: 38 a1 00 08 addi r5,r1,8
ffc1bb40: 48 00 06 09 bl ffc1c148 <_Protected_heap_Get_block_size>
ffc1bb44: 2f 83 00 00 cmpwi cr7,r3,0
ffc1bb48: 40 be 00 14 bne+ cr7,ffc1bb5c <realloc+0xb4>
errno = EINVAL;
ffc1bb4c: 4b ff 50 69 bl ffc10bb4 <__errno>
ffc1bb50: 38 00 00 16 li r0,22
ffc1bb54: 90 03 00 00 stw r0,0(r3)
ffc1bb58: 48 00 00 70 b ffc1bbc8 <realloc+0x120>
}
/*
* Now resize it.
*/
if ( _Protected_heap_Resize_block( RTEMS_Malloc_Heap, ptr, size ) ) {
ffc1bb5c: 80 7d 27 2c lwz r3,10028(r29)
ffc1bb60: 7f e4 fb 78 mr r4,r31
ffc1bb64: 7f c5 f3 78 mr r5,r30
ffc1bb68: 48 00 06 31 bl ffc1c198 <_Protected_heap_Resize_block>
ffc1bb6c: 2f 83 00 00 cmpwi cr7,r3,0
ffc1bb70: 40 be 00 5c bne+ cr7,ffc1bbcc <realloc+0x124>
* There used to be a free on this error case but it is wrong to
* free the memory per OpenGroup Single UNIX Specification V2
* and the C Standard.
*/
new_area = malloc( size );
ffc1bb74: 7f c3 f3 78 mr r3,r30
ffc1bb78: 4b fe 91 8d bl ffc04d04 <malloc>
MSBUMP(malloc_calls, (uint32_t) -1); /* subtract off the malloc */
ffc1bb7c: 3d 20 00 00 lis r9,0
if ( !new_area ) {
ffc1bb80: 7c 7d 1b 79 mr. r29,r3
* and the C Standard.
*/
new_area = malloc( size );
MSBUMP(malloc_calls, (uint32_t) -1); /* subtract off the malloc */
ffc1bb84: 39 29 2b 60 addi r9,r9,11104
ffc1bb88: 81 69 00 04 lwz r11,4(r9)
ffc1bb8c: 38 0b ff ff addi r0,r11,-1
ffc1bb90: 90 09 00 04 stw r0,4(r9)
if ( !new_area ) {
ffc1bb94: 41 82 00 34 beq- ffc1bbc8 <realloc+0x120>
return (void *) 0;
}
memcpy( new_area, ptr, (size < old_size) ? size : old_size );
ffc1bb98: 80 01 00 08 lwz r0,8(r1)
ffc1bb9c: 7f c5 f3 78 mr r5,r30
ffc1bba0: 7f 9e 00 40 cmplw cr7,r30,r0
ffc1bba4: 40 9d 00 08 ble- cr7,ffc1bbac <realloc+0x104> <== NEVER TAKEN
ffc1bba8: 7c 05 03 78 mr r5,r0
ffc1bbac: 7f e4 fb 78 mr r4,r31
ffc1bbb0: 7f a3 eb 78 mr r3,r29
ffc1bbb4: 4b ff 5d 3d bl ffc118f0 <memcpy>
free( ptr );
ffc1bbb8: 7f e3 fb 78 mr r3,r31
ffc1bbbc: 4b fe 8d a1 bl ffc0495c <free>
return new_area;
ffc1bbc0: 7f bf eb 78 mr r31,r29
ffc1bbc4: 48 00 00 08 b ffc1bbcc <realloc+0x124>
new_area = malloc( size );
MSBUMP(malloc_calls, (uint32_t) -1); /* subtract off the malloc */
if ( !new_area ) {
return (void *) 0;
ffc1bbc8: 3b e0 00 00 li r31,0
memcpy( new_area, ptr, (size < old_size) ? size : old_size );
free( ptr );
return new_area;
}
ffc1bbcc: 39 61 00 28 addi r11,r1,40
ffc1bbd0: 7f e3 fb 78 mr r3,r31
ffc1bbd4: 4b fe 49 68 b ffc0053c <_restgpr_29_x>
ffc05764 <rmdir>:
#include <rtems/seterr.h>
int rmdir(
const char *pathname
)
{
ffc05764: 94 21 ff b0 stwu r1,-80(r1)
ffc05768: 7c 08 02 a6 mflr r0
ffc0576c: bf 41 00 38 stmw r26,56(r1)
ffc05770: 7c 7c 1b 78 mr r28,r3
ffc05774: 90 01 00 54 stw r0,84(r1)
/*
* Get the parent node of the node we wish to remove. Find the parent path.
*/
parentpathlen = rtems_filesystem_dirname ( pathname );
ffc05778: 4b ff f0 01 bl ffc04778 <rtems_filesystem_dirname>
if ( parentpathlen == 0 )
ffc0577c: 7c 7b 1b 79 mr. r27,r3
rtems_filesystem_get_start_loc( pathname, &i, &parentloc );
ffc05780: 7f 83 e3 78 mr r3,r28
* Get the parent node of the node we wish to remove. Find the parent path.
*/
parentpathlen = rtems_filesystem_dirname ( pathname );
if ( parentpathlen == 0 )
ffc05784: 40 82 00 18 bne- ffc0579c <rmdir+0x38>
rtems_filesystem_get_start_loc( pathname, &i, &parentloc );
ffc05788: 38 81 00 08 addi r4,r1,8
ffc0578c: 38 a1 00 20 addi r5,r1,32
ffc05790: 48 00 01 11 bl ffc058a0 <rtems_filesystem_get_start_loc>
const char *name;
rtems_filesystem_location_info_t parentloc;
rtems_filesystem_location_info_t loc;
int i;
int result;
bool free_parentloc = false;
ffc05794: 3b a0 00 00 li r29,0
ffc05798: 48 00 00 28 b ffc057c0 <rmdir+0x5c>
parentpathlen = rtems_filesystem_dirname ( pathname );
if ( parentpathlen == 0 )
rtems_filesystem_get_start_loc( pathname, &i, &parentloc );
else {
result = rtems_filesystem_evaluate_path(pathname, parentpathlen,
ffc0579c: 7f 64 db 78 mr r4,r27
ffc057a0: 38 a0 00 02 li r5,2
ffc057a4: 38 c1 00 20 addi r6,r1,32
ffc057a8: 38 e0 00 00 li r7,0
ffc057ac: 4b ff ef 71 bl ffc0471c <rtems_filesystem_evaluate_path>
RTEMS_LIBIO_PERMS_WRITE,
&parentloc,
false );
if ( result != 0 )
return -1;
ffc057b0: 3b 40 ff ff li r26,-1
else {
result = rtems_filesystem_evaluate_path(pathname, parentpathlen,
RTEMS_LIBIO_PERMS_WRITE,
&parentloc,
false );
if ( result != 0 )
ffc057b4: 2f 83 00 00 cmpwi cr7,r3,0
ffc057b8: 40 9e 00 dc bne- cr7,ffc05894 <rmdir+0x130> <== NEVER TAKEN
return -1;
free_parentloc = true;
ffc057bc: 3b a0 00 01 li r29,1
/*
* Start from the parent to find the node that should be under it.
*/
loc = parentloc;
ffc057c0: 3b e1 00 0c addi r31,r1,12
ffc057c4: 3b c1 00 20 addi r30,r1,32
ffc057c8: 7c be a4 aa lswi r5,r30,20
ffc057cc: 7c bf a5 aa stswi r5,r31,20
name = pathname + parentpathlen;
ffc057d0: 7f 9c da 14 add r28,r28,r27
name += rtems_filesystem_prefix_separators( name, strlen( name ) );
ffc057d4: 7f 83 e3 78 mr r3,r28
ffc057d8: 48 00 c8 0d bl ffc11fe4 <strlen>
result = rtems_filesystem_evaluate_relative_path( name , strlen( name ),
0, &loc, false );
if ( result != 0 ) {
if ( free_parentloc )
rtems_filesystem_freenode( &parentloc );
return -1;
ffc057dc: 3b 40 ff ff li r26,-1
* Start from the parent to find the node that should be under it.
*/
loc = parentloc;
name = pathname + parentpathlen;
name += rtems_filesystem_prefix_separators( name, strlen( name ) );
ffc057e0: 7c 64 1b 78 mr r4,r3
ffc057e4: 7f 83 e3 78 mr r3,r28
ffc057e8: 4b ff ef d9 bl ffc047c0 <rtems_filesystem_prefix_separators>
ffc057ec: 7f 9c 1a 14 add r28,r28,r3
result = rtems_filesystem_evaluate_relative_path( name , strlen( name ),
ffc057f0: 7f 83 e3 78 mr r3,r28
ffc057f4: 48 00 c7 f1 bl ffc11fe4 <strlen>
ffc057f8: 38 a0 00 00 li r5,0
ffc057fc: 7c 64 1b 78 mr r4,r3
ffc05800: 7f e6 fb 78 mr r6,r31
ffc05804: 7f 83 e3 78 mr r3,r28
ffc05808: 38 e0 00 00 li r7,0
ffc0580c: 4b ff ee 8d bl ffc04698 <rtems_filesystem_evaluate_relative_path>
0, &loc, false );
if ( result != 0 ) {
ffc05810: 2f 83 00 00 cmpwi cr7,r3,0
ffc05814: 40 be 00 70 bne+ cr7,ffc05884 <rmdir+0x120>
}
/*
* Verify you can remove this node as a directory.
*/
if ( (*loc.ops->node_type_h)( &loc ) != RTEMS_FILESYSTEM_DIRECTORY ) {
ffc05818: 81 21 00 18 lwz r9,24(r1)
ffc0581c: 7f e3 fb 78 mr r3,r31
ffc05820: 80 09 00 10 lwz r0,16(r9)
ffc05824: 7c 09 03 a6 mtctr r0
ffc05828: 4e 80 04 21 bctrl
ffc0582c: 2f 83 00 01 cmpwi cr7,r3,1
ffc05830: 41 be 00 30 beq+ cr7,ffc05860 <rmdir+0xfc>
rtems_filesystem_freenode( &loc );
ffc05834: 7f e3 fb 78 mr r3,r31
ffc05838: 4b ff ef d9 bl ffc04810 <rtems_filesystem_freenode>
if ( free_parentloc )
ffc0583c: 2f 9d 00 00 cmpwi cr7,r29,0
ffc05840: 41 be 00 0c beq+ cr7,ffc0584c <rmdir+0xe8> <== NEVER TAKEN
rtems_filesystem_freenode( &parentloc );
ffc05844: 7f c3 f3 78 mr r3,r30
ffc05848: 4b ff ef c9 bl ffc04810 <rtems_filesystem_freenode>
rtems_set_errno_and_return_minus_one( ENOTDIR );
ffc0584c: 48 00 b6 1d bl ffc10e68 <__errno>
ffc05850: 38 00 00 14 li r0,20
ffc05854: 90 03 00 00 stw r0,0(r3)
ffc05858: 3b 40 ff ff li r26,-1
ffc0585c: 48 00 00 38 b ffc05894 <rmdir+0x130>
/*
* Use the filesystems rmnod to remove the node.
*/
result = (*loc.handlers->rmnod_h)( &parentloc, &loc );
ffc05860: 81 21 00 14 lwz r9,20(r1)
ffc05864: 7f c3 f3 78 mr r3,r30
ffc05868: 7f e4 fb 78 mr r4,r31
ffc0586c: 80 09 00 34 lwz r0,52(r9)
ffc05870: 7c 09 03 a6 mtctr r0
ffc05874: 4e 80 04 21 bctrl
ffc05878: 7c 7a 1b 78 mr r26,r3
rtems_filesystem_freenode( &loc );
ffc0587c: 7f e3 fb 78 mr r3,r31
ffc05880: 4b ff ef 91 bl ffc04810 <rtems_filesystem_freenode>
if ( free_parentloc )
ffc05884: 2f 9d 00 00 cmpwi cr7,r29,0
ffc05888: 41 be 00 0c beq+ cr7,ffc05894 <rmdir+0x130>
rtems_filesystem_freenode( &parentloc );
ffc0588c: 7f c3 f3 78 mr r3,r30
ffc05890: 4b ff ef 81 bl ffc04810 <rtems_filesystem_freenode>
return result;
}
ffc05894: 39 61 00 50 addi r11,r1,80
ffc05898: 7f 43 d3 78 mr r3,r26
ffc0589c: 48 01 05 dc b ffc15e78 <_restgpr_26_x>
ffc08cf4 <rtems_aio_enqueue>:
* errno - otherwise
*/
int
rtems_aio_enqueue (rtems_aio_request *req)
{
ffc08cf4: 94 21 ff b0 stwu r1,-80(r1)
ffc08cf8: 7c 08 02 a6 mflr r0
ffc08cfc: bf 61 00 3c stmw r27,60(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);
ffc08d00: 3f e0 00 00 lis r31,0
ffc08d04: 3b ff 2c 70 addi r31,r31,11376
* errno - otherwise
*/
int
rtems_aio_enqueue (rtems_aio_request *req)
{
ffc08d08: 7c 7d 1b 78 mr r29,r3
ffc08d0c: 90 01 00 54 stw r0,84(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);
ffc08d10: 7f e3 fb 78 mr r3,r31
ffc08d14: 48 00 0a 31 bl ffc09744 <pthread_mutex_lock>
if (result != 0) {
ffc08d18: 7c 7e 1b 79 mr. r30,r3
ffc08d1c: 41 a2 00 10 beq+ ffc08d2c <rtems_aio_enqueue+0x38> <== ALWAYS TAKEN
free (req);
ffc08d20: 7f a3 eb 78 mr r3,r29 <== NOT EXECUTED
ffc08d24: 4b ff c3 e5 bl ffc05108 <free> <== NOT EXECUTED
return result;
ffc08d28: 48 00 01 cc b ffc08ef4 <rtems_aio_enqueue+0x200> <== NOT EXECUTED
}
/* _POSIX_PRIORITIZED_IO and _POSIX_PRIORITY_SCHEDULING are defined,
we can use aio_reqprio to lower the priority of the request */
pthread_getschedparam (pthread_self(), &policy, ¶m);
ffc08d2c: 48 00 12 e5 bl ffc0a010 <pthread_self>
ffc08d30: 38 81 00 08 addi r4,r1,8
ffc08d34: 38 a1 00 10 addi r5,r1,16
ffc08d38: 48 00 0e 85 bl ffc09bbc <pthread_getschedparam>
ffc08d3c: 3b 9f 00 48 addi r28,r31,72
req->caller_thread = pthread_self ();
ffc08d40: 48 00 12 d1 bl ffc0a010 <pthread_self>
req->priority = param.sched_priority - req->aiocbp->aio_reqprio;
ffc08d44: 81 3d 00 14 lwz r9,20(r29)
ffc08d48: 81 61 00 10 lwz r11,16(r1)
ffc08d4c: 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 ();
ffc08d50: 90 7d 00 10 stw r3,16(r29)
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);
ffc08d54: 7f 83 e3 78 mr r3,r28
/* _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;
ffc08d58: 7c 00 58 50 subf r0,r0,r11
ffc08d5c: 90 1d 00 0c stw r0,12(r29)
req->policy = policy;
ffc08d60: 80 01 00 08 lwz r0,8(r1)
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);
ffc08d64: 80 89 00 00 lwz r4,0(r9)
we can use aio_reqprio to lower the priority of the request */
pthread_getschedparam (pthread_self(), &policy, ¶m);
req->caller_thread = pthread_self ();
req->priority = param.sched_priority - req->aiocbp->aio_reqprio;
req->policy = policy;
ffc08d68: 90 1d 00 08 stw r0,8(r29)
req->aiocbp->error_code = EINPROGRESS;
ffc08d6c: 38 00 00 77 li r0,119
ffc08d70: 90 09 00 34 stw r0,52(r9)
req->aiocbp->return_value = 0;
if ((aio_request_queue.idle_threads == 0) &&
ffc08d74: 80 1f 00 68 lwz r0,104(r31)
req->caller_thread = pthread_self ();
req->priority = param.sched_priority - req->aiocbp->aio_reqprio;
req->policy = policy;
req->aiocbp->error_code = EINPROGRESS;
req->aiocbp->return_value = 0;
ffc08d78: 93 c9 00 38 stw r30,56(r9)
if ((aio_request_queue.idle_threads == 0) &&
ffc08d7c: 2f 80 00 00 cmpwi cr7,r0,0
ffc08d80: 40 9e 00 bc bne- cr7,ffc08e3c <rtems_aio_enqueue+0x148> <== NEVER TAKEN
ffc08d84: 80 1f 00 64 lwz r0,100(r31)
ffc08d88: 2f 80 00 04 cmpwi cr7,r0,4
ffc08d8c: 41 bd 00 b0 bgt+ cr7,ffc08e3c <rtems_aio_enqueue+0x148>
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);
ffc08d90: 38 a0 00 01 li r5,1
ffc08d94: 4b ff fa c5 bl ffc08858 <rtems_aio_search_fd>
if (r_chain->new_fd == 1) {
ffc08d98: 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);
ffc08d9c: 7c 7c 1b 78 mr r28,r3
ffc08da0: 3b 63 00 08 addi r27,r3,8
if (r_chain->new_fd == 1) {
ffc08da4: 2f 80 00 01 cmpwi cr7,r0,1
ffc08da8: 40 be 00 6c bne+ cr7,ffc08e14 <rtems_aio_enqueue+0x120>
RTEMS_INLINE_ROUTINE void _Chain_Prepend(
Chain_Control *the_chain,
Chain_Node *the_node
)
{
_Chain_Insert(_Chain_Head(the_chain), the_node);
ffc08dac: 7f a4 eb 78 mr r4,r29
ffc08db0: 7f 63 db 78 mr r3,r27
ffc08db4: 48 00 25 f9 bl ffc0b3ac <_Chain_Insert>
rtems_chain_prepend (&r_chain->perfd, &req->next_prio);
r_chain->new_fd = 0;
ffc08db8: 93 dc 00 18 stw r30,24(r28)
pthread_mutex_init (&r_chain->mutex, NULL);
ffc08dbc: 38 80 00 00 li r4,0
ffc08dc0: 38 7c 00 1c addi r3,r28,28
ffc08dc4: 48 00 08 29 bl ffc095ec <pthread_mutex_init>
pthread_cond_init (&r_chain->cond, NULL);
ffc08dc8: 38 80 00 00 li r4,0
ffc08dcc: 38 7c 00 20 addi r3,r28,32
ffc08dd0: 48 00 03 d1 bl ffc091a0 <pthread_cond_init>
AIO_printf ("New thread \n");
result = pthread_create (&thid, &aio_request_queue.attr,
ffc08dd4: 3c a0 ff c1 lis r5,-63
ffc08dd8: 38 61 00 0c addi r3,r1,12
ffc08ddc: 38 9f 00 08 addi r4,r31,8
ffc08de0: 38 a5 89 74 addi r5,r5,-30348
ffc08de4: 7f 86 e3 78 mr r6,r28
ffc08de8: 48 00 0b a1 bl ffc09988 <pthread_create>
rtems_aio_handle, (void *) r_chain);
if (result != 0) {
ffc08dec: 7c 7d 1b 79 mr. r29,r3
ffc08df0: 41 a2 00 14 beq+ ffc08e04 <rtems_aio_enqueue+0x110> <== ALWAYS TAKEN
pthread_mutex_unlock (&aio_request_queue.mutex);
ffc08df4: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc08df8: 48 00 09 f1 bl ffc097e8 <pthread_mutex_unlock> <== NOT EXECUTED
return result;
ffc08dfc: 7f be eb 78 mr r30,r29 <== NOT EXECUTED
ffc08e00: 48 00 00 f4 b ffc08ef4 <rtems_aio_enqueue+0x200> <== NOT EXECUTED
}
++aio_request_queue.active_threads;
ffc08e04: 81 3f 00 64 lwz r9,100(r31)
ffc08e08: 38 09 00 01 addi r0,r9,1
ffc08e0c: 90 1f 00 64 stw r0,100(r31)
ffc08e10: 48 00 00 d8 b ffc08ee8 <rtems_aio_enqueue+0x1f4>
}
else {
/* put request in the fd chain it belongs to */
pthread_mutex_lock (&r_chain->mutex);
ffc08e14: 3b e3 00 1c addi r31,r3,28
ffc08e18: 7f e3 fb 78 mr r3,r31
ffc08e1c: 48 00 09 29 bl ffc09744 <pthread_mutex_lock>
rtems_aio_insert_prio (&r_chain->perfd, req);
ffc08e20: 7f 63 db 78 mr r3,r27
ffc08e24: 7f a4 eb 78 mr r4,r29
ffc08e28: 4b ff fd 8d bl ffc08bb4 <rtems_aio_insert_prio>
pthread_cond_signal (&r_chain->cond);
ffc08e2c: 38 7c 00 20 addi r3,r28,32
ffc08e30: 48 00 04 39 bl ffc09268 <pthread_cond_signal>
pthread_mutex_unlock (&r_chain->mutex);
ffc08e34: 7f e3 fb 78 mr r3,r31
ffc08e38: 48 00 00 38 b ffc08e70 <rtems_aio_enqueue+0x17c>
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,
ffc08e3c: 38 a0 00 00 li r5,0
ffc08e40: 4b ff fa 19 bl ffc08858 <rtems_aio_search_fd>
req->aiocbp->aio_fildes, 0);
if (r_chain != NULL)
ffc08e44: 7c 7f 1b 79 mr. r31,r3
ffc08e48: 41 82 00 30 beq- ffc08e78 <rtems_aio_enqueue+0x184>
{
pthread_mutex_lock (&r_chain->mutex);
ffc08e4c: 3b 9f 00 1c addi r28,r31,28
ffc08e50: 7f 83 e3 78 mr r3,r28
ffc08e54: 48 00 08 f1 bl ffc09744 <pthread_mutex_lock>
rtems_aio_insert_prio (&r_chain->perfd, req);
ffc08e58: 38 7f 00 08 addi r3,r31,8
ffc08e5c: 7f a4 eb 78 mr r4,r29
ffc08e60: 4b ff fd 55 bl ffc08bb4 <rtems_aio_insert_prio>
pthread_cond_signal (&r_chain->cond);
ffc08e64: 38 7f 00 20 addi r3,r31,32
ffc08e68: 48 00 04 01 bl ffc09268 <pthread_cond_signal>
pthread_mutex_unlock (&r_chain->mutex);
ffc08e6c: 7f 83 e3 78 mr r3,r28
ffc08e70: 48 00 09 79 bl ffc097e8 <pthread_mutex_unlock>
ffc08e74: 48 00 00 74 b ffc08ee8 <rtems_aio_enqueue+0x1f4>
} else {
/* or to the idle chain */
chain = &aio_request_queue.idle_req;
r_chain = rtems_aio_search_fd (chain, req->aiocbp->aio_fildes, 1);
ffc08e78: 81 3d 00 14 lwz r9,20(r29)
ffc08e7c: 38 7c 00 0c addi r3,r28,12
ffc08e80: 38 a0 00 01 li r5,1
ffc08e84: 80 89 00 00 lwz r4,0(r9)
ffc08e88: 4b ff f9 d1 bl ffc08858 <rtems_aio_search_fd>
ffc08e8c: 7f a4 eb 78 mr r4,r29
if (r_chain->new_fd == 1) {
ffc08e90: 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);
ffc08e94: 7c 7c 1b 78 mr r28,r3
ffc08e98: 38 63 00 08 addi r3,r3,8
if (r_chain->new_fd == 1) {
ffc08e9c: 2f 80 00 01 cmpwi cr7,r0,1
ffc08ea0: 40 be 00 28 bne+ cr7,ffc08ec8 <rtems_aio_enqueue+0x1d4>
ffc08ea4: 48 00 25 09 bl ffc0b3ac <_Chain_Insert>
/* If this is a new fd chain we signal the idle threads that
might be waiting for requests */
AIO_printf (" New chain on waiting queue \n ");
rtems_chain_prepend (&r_chain->perfd, &req->next_prio);
r_chain->new_fd = 0;
ffc08ea8: 93 fc 00 18 stw r31,24(r28)
pthread_mutex_init (&r_chain->mutex, NULL);
ffc08eac: 38 7c 00 1c addi r3,r28,28
ffc08eb0: 38 80 00 00 li r4,0
ffc08eb4: 48 00 07 39 bl ffc095ec <pthread_mutex_init>
pthread_cond_init (&r_chain->cond, NULL);
ffc08eb8: 38 7c 00 20 addi r3,r28,32
ffc08ebc: 38 80 00 00 li r4,0
ffc08ec0: 48 00 02 e1 bl ffc091a0 <pthread_cond_init>
ffc08ec4: 48 00 00 08 b ffc08ecc <rtems_aio_enqueue+0x1d8>
} else
/* just insert the request in the existing fd chain */
rtems_aio_insert_prio (&r_chain->perfd, req);
ffc08ec8: 4b ff fc ed bl ffc08bb4 <rtems_aio_insert_prio>
if (aio_request_queue.idle_threads > 0)
ffc08ecc: 3c 60 00 00 lis r3,0
ffc08ed0: 38 63 2c 70 addi r3,r3,11376
ffc08ed4: 80 03 00 68 lwz r0,104(r3)
ffc08ed8: 2f 80 00 00 cmpwi cr7,r0,0
ffc08edc: 40 9d 00 0c ble- cr7,ffc08ee8 <rtems_aio_enqueue+0x1f4> <== ALWAYS TAKEN
pthread_cond_signal (&aio_request_queue.new_req);
ffc08ee0: 38 63 00 04 addi r3,r3,4 <== NOT EXECUTED
ffc08ee4: 48 00 03 85 bl ffc09268 <pthread_cond_signal> <== NOT EXECUTED
}
}
pthread_mutex_unlock (&aio_request_queue.mutex);
ffc08ee8: 3c 60 00 00 lis r3,0
ffc08eec: 38 63 2c 70 addi r3,r3,11376
ffc08ef0: 48 00 08 f9 bl ffc097e8 <pthread_mutex_unlock>
return 0;
}
ffc08ef4: 39 61 00 50 addi r11,r1,80
ffc08ef8: 7f c3 f3 78 mr r3,r30
ffc08efc: 4b ff 7b fc b ffc00af8 <_restgpr_27_x>
ffc08974 <rtems_aio_handle>:
* NULL - if error
*/
static void *
rtems_aio_handle (void *arg)
{
ffc08974: 94 21 ff a0 stwu r1,-96(r1)
ffc08978: 7c 08 02 a6 mflr r0
ffc0897c: be e1 00 3c stmw r23,60(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);
ffc08980: 3f e0 00 00 lis r31,0
ffc08984: 3b ff 2c 70 addi r31,r31,11376
* NULL - if error
*/
static void *
rtems_aio_handle (void *arg)
{
ffc08988: 90 01 00 64 stw r0,100(r1)
ffc0898c: 7c 7e 1b 78 mr r30,r3
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)) {
ffc08990: 3b 3f 00 58 addi r25,r31,88
--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,
ffc08994: 3b 5f 00 04 addi r26,r31,4
default:
result = -1;
}
if (result == -1) {
req->aiocbp->return_value = -1;
ffc08998: 3b 60 ff ff li r27,-1
req->aiocbp->error_code = errno;
} else {
req->aiocbp->return_value = result;
req->aiocbp->error_code = 0;
ffc0899c: 3b 80 00 00 li r28,0
/* acquire the mutex of the current fd chain.
we don't need to lock the queue mutex since we can
add requests to idle fd chains or even active ones
if the working request has been extracted from the
chain */
result = pthread_mutex_lock (&r_chain->mutex);
ffc089a0: 3b 1e 00 1c addi r24,r30,28
ffc089a4: 7f 03 c3 78 mr r3,r24
ffc089a8: 48 00 0d 9d bl ffc09744 <pthread_mutex_lock>
if (result != 0)
ffc089ac: 7c 77 1b 79 mr. r23,r3
ffc089b0: 40 82 01 f8 bne- ffc08ba8 <rtems_aio_handle+0x234> <== NEVER TAKEN
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_head( the_chain )->next;
ffc089b4: 83 be 00 08 lwz r29,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 );
ffc089b8: 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)) {
ffc089bc: 7f 9d 00 00 cmpw cr7,r29,r0
ffc089c0: 41 9e 00 cc beq- cr7,ffc08a8c <rtems_aio_handle+0x118>
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);
ffc089c4: 48 00 16 4d bl ffc0a010 <pthread_self>
ffc089c8: 38 81 00 08 addi r4,r1,8
ffc089cc: 38 a1 00 14 addi r5,r1,20
ffc089d0: 48 00 11 ed bl ffc09bbc <pthread_getschedparam>
param.sched_priority = req->priority;
ffc089d4: 80 1d 00 0c lwz r0,12(r29)
ffc089d8: 90 01 00 14 stw r0,20(r1)
pthread_setschedparam (pthread_self(), req->policy, ¶m);
ffc089dc: 48 00 16 35 bl ffc0a010 <pthread_self>
ffc089e0: 38 a1 00 14 addi r5,r1,20
ffc089e4: 80 9d 00 08 lwz r4,8(r29)
ffc089e8: 48 00 16 39 bl ffc0a020 <pthread_setschedparam>
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
ffc089ec: 7f a3 eb 78 mr r3,r29
ffc089f0: 48 00 29 55 bl ffc0b344 <_Chain_Extract>
rtems_chain_extract (node);
pthread_mutex_unlock (&r_chain->mutex);
ffc089f4: 7f 03 c3 78 mr r3,r24
ffc089f8: 48 00 0d f1 bl ffc097e8 <pthread_mutex_unlock>
switch (req->aiocbp->aio_lio_opcode) {
ffc089fc: 81 3d 00 14 lwz r9,20(r29)
ffc08a00: 80 09 00 30 lwz r0,48(r9)
ffc08a04: 2f 80 00 02 cmpwi cr7,r0,2
ffc08a08: 41 9e 00 30 beq- cr7,ffc08a38 <rtems_aio_handle+0xc4>
ffc08a0c: 2f 80 00 03 cmpwi cr7,r0,3
ffc08a10: 41 9e 00 44 beq- cr7,ffc08a54 <rtems_aio_handle+0xe0> <== NEVER TAKEN
ffc08a14: 2f 80 00 01 cmpwi cr7,r0,1
ffc08a18: 40 be 00 4c bne+ cr7,ffc08a64 <rtems_aio_handle+0xf0> <== NEVER TAKEN
case LIO_READ:
AIO_printf ("read\n");
result = pread (req->aiocbp->aio_fildes,
ffc08a1c: 80 69 00 00 lwz r3,0(r9)
ffc08a20: 80 89 00 10 lwz r4,16(r9)
ffc08a24: 80 a9 00 14 lwz r5,20(r9)
ffc08a28: 80 e9 00 08 lwz r7,8(r9)
ffc08a2c: 81 09 00 0c lwz r8,12(r9)
ffc08a30: 48 00 b8 41 bl ffc14270 <pread>
(void *) req->aiocbp->aio_buf,
req->aiocbp->aio_nbytes, req->aiocbp->aio_offset);
break;
ffc08a34: 48 00 00 28 b ffc08a5c <rtems_aio_handle+0xe8>
case LIO_WRITE:
AIO_printf ("write\n");
result = pwrite (req->aiocbp->aio_fildes,
ffc08a38: 80 69 00 00 lwz r3,0(r9)
ffc08a3c: 80 89 00 10 lwz r4,16(r9)
ffc08a40: 80 a9 00 14 lwz r5,20(r9)
ffc08a44: 80 e9 00 08 lwz r7,8(r9)
ffc08a48: 81 09 00 0c lwz r8,12(r9)
ffc08a4c: 48 00 b9 61 bl ffc143ac <pwrite>
(void *) req->aiocbp->aio_buf,
req->aiocbp->aio_nbytes, req->aiocbp->aio_offset);
break;
ffc08a50: 48 00 00 0c b ffc08a5c <rtems_aio_handle+0xe8>
case LIO_SYNC:
AIO_printf ("sync\n");
result = fsync (req->aiocbp->aio_fildes);
ffc08a54: 80 69 00 00 lwz r3,0(r9) <== NOT EXECUTED
ffc08a58: 48 00 72 95 bl ffc0fcec <fsync> <== NOT EXECUTED
break;
default:
result = -1;
}
if (result == -1) {
ffc08a5c: 2f 83 ff ff cmpwi cr7,r3,-1
ffc08a60: 40 be 00 1c bne+ cr7,ffc08a7c <rtems_aio_handle+0x108> <== ALWAYS TAKEN
req->aiocbp->return_value = -1;
ffc08a64: 83 bd 00 14 lwz r29,20(r29) <== NOT EXECUTED
ffc08a68: 93 7d 00 38 stw r27,56(r29) <== NOT EXECUTED
req->aiocbp->error_code = errno;
ffc08a6c: 48 00 a8 d1 bl ffc1333c <__errno> <== NOT EXECUTED
ffc08a70: 80 03 00 00 lwz r0,0(r3) <== NOT EXECUTED
ffc08a74: 90 1d 00 34 stw r0,52(r29) <== NOT EXECUTED
ffc08a78: 4b ff ff 28 b ffc089a0 <rtems_aio_handle+0x2c> <== NOT EXECUTED
} else {
req->aiocbp->return_value = result;
ffc08a7c: 81 3d 00 14 lwz r9,20(r29)
ffc08a80: 90 69 00 38 stw r3,56(r9)
req->aiocbp->error_code = 0;
ffc08a84: 93 89 00 34 stw r28,52(r9)
ffc08a88: 4b ff ff 18 b ffc089a0 <rtems_aio_handle+0x2c>
struct timespec timeout;
AIO_printf ("Chain is empty [WQ], wait for work\n");
pthread_mutex_unlock (&r_chain->mutex);
ffc08a8c: 7f 03 c3 78 mr r3,r24
ffc08a90: 48 00 0d 59 bl ffc097e8 <pthread_mutex_unlock>
pthread_mutex_lock (&aio_request_queue.mutex);
ffc08a94: 7f e3 fb 78 mr r3,r31
ffc08a98: 48 00 0c ad bl ffc09744 <pthread_mutex_lock>
if (rtems_chain_is_empty (chain))
ffc08a9c: 80 1e 00 08 lwz r0,8(r30)
ffc08aa0: 7f 80 e8 00 cmpw cr7,r0,r29
ffc08aa4: 40 be 00 f8 bne+ cr7,ffc08b9c <rtems_aio_handle+0x228> <== NEVER TAKEN
{
clock_gettime (CLOCK_REALTIME, &timeout);
ffc08aa8: 38 81 00 0c addi r4,r1,12
ffc08aac: 38 60 00 01 li r3,1
ffc08ab0: 48 00 05 91 bl ffc09040 <clock_gettime>
timeout.tv_sec += 3;
ffc08ab4: 81 21 00 0c lwz r9,12(r1)
timeout.tv_nsec = 0;
result = pthread_cond_timedwait (&r_chain->cond,
ffc08ab8: 3b be 00 20 addi r29,r30,32
if (rtems_chain_is_empty (chain))
{
clock_gettime (CLOCK_REALTIME, &timeout);
timeout.tv_sec += 3;
timeout.tv_nsec = 0;
ffc08abc: 92 e1 00 10 stw r23,16(r1)
pthread_mutex_lock (&aio_request_queue.mutex);
if (rtems_chain_is_empty (chain))
{
clock_gettime (CLOCK_REALTIME, &timeout);
timeout.tv_sec += 3;
ffc08ac0: 38 09 00 03 addi r0,r9,3
timeout.tv_nsec = 0;
result = pthread_cond_timedwait (&r_chain->cond,
ffc08ac4: 7f a3 eb 78 mr r3,r29
pthread_mutex_lock (&aio_request_queue.mutex);
if (rtems_chain_is_empty (chain))
{
clock_gettime (CLOCK_REALTIME, &timeout);
timeout.tv_sec += 3;
ffc08ac8: 90 01 00 0c stw r0,12(r1)
timeout.tv_nsec = 0;
result = pthread_cond_timedwait (&r_chain->cond,
ffc08acc: 7f e4 fb 78 mr r4,r31
ffc08ad0: 38 a1 00 0c addi r5,r1,12
ffc08ad4: 48 00 08 2d bl ffc09300 <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) {
ffc08ad8: 2f 83 00 74 cmpwi cr7,r3,116
ffc08adc: 40 be 00 c0 bne+ cr7,ffc08b9c <rtems_aio_handle+0x228> <== NEVER TAKEN
ffc08ae0: 7f c3 f3 78 mr r3,r30
ffc08ae4: 48 00 28 61 bl ffc0b344 <_Chain_Extract>
rtems_chain_extract (&r_chain->next_fd);
pthread_mutex_destroy (&r_chain->mutex);
ffc08ae8: 7f 03 c3 78 mr r3,r24
ffc08aec: 48 00 09 95 bl ffc09480 <pthread_mutex_destroy>
pthread_cond_destroy (&r_chain->cond);
ffc08af0: 7f a3 eb 78 mr r3,r29
ffc08af4: 48 00 05 c5 bl ffc090b8 <pthread_cond_destroy>
free (r_chain);
ffc08af8: 7f c3 f3 78 mr r3,r30
ffc08afc: 4b ff c6 0d bl ffc05108 <free>
/* If the idle chain is empty sleep for 3 seconds and wait for a
signal. The thread now becomes idle. */
if (rtems_chain_is_empty (&aio_request_queue.idle_req)) {
ffc08b00: 80 1f 00 54 lwz r0,84(r31)
ffc08b04: 7f 80 c8 00 cmpw cr7,r0,r25
ffc08b08: 40 be 00 68 bne+ cr7,ffc08b70 <rtems_aio_handle+0x1fc>
AIO_printf ("Chain is empty [IQ], wait for work\n");
++aio_request_queue.idle_threads;
ffc08b0c: 81 3f 00 68 lwz r9,104(r31)
--aio_request_queue.active_threads;
clock_gettime (CLOCK_REALTIME, &timeout);
ffc08b10: 38 81 00 0c addi r4,r1,12
ffc08b14: 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;
ffc08b18: 38 09 00 01 addi r0,r9,1
--aio_request_queue.active_threads;
ffc08b1c: 81 3f 00 64 lwz r9,100(r31)
/* 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;
ffc08b20: 90 1f 00 68 stw r0,104(r31)
--aio_request_queue.active_threads;
ffc08b24: 38 09 ff ff addi r0,r9,-1
ffc08b28: 90 1f 00 64 stw r0,100(r31)
clock_gettime (CLOCK_REALTIME, &timeout);
ffc08b2c: 48 00 05 15 bl ffc09040 <clock_gettime>
timeout.tv_sec += 3;
ffc08b30: 81 21 00 0c lwz r9,12(r1)
timeout.tv_nsec = 0;
result = pthread_cond_timedwait (&aio_request_queue.new_req,
ffc08b34: 7f 43 d3 78 mr r3,r26
++aio_request_queue.idle_threads;
--aio_request_queue.active_threads;
clock_gettime (CLOCK_REALTIME, &timeout);
timeout.tv_sec += 3;
timeout.tv_nsec = 0;
ffc08b38: 92 e1 00 10 stw r23,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;
ffc08b3c: 38 09 00 03 addi r0,r9,3
timeout.tv_nsec = 0;
result = pthread_cond_timedwait (&aio_request_queue.new_req,
ffc08b40: 7f e4 fb 78 mr r4,r31
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;
ffc08b44: 90 01 00 0c stw r0,12(r1)
timeout.tv_nsec = 0;
result = pthread_cond_timedwait (&aio_request_queue.new_req,
ffc08b48: 38 a1 00 0c addi r5,r1,12
ffc08b4c: 48 00 07 b5 bl ffc09300 <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) {
ffc08b50: 2f 83 00 74 cmpwi cr7,r3,116
ffc08b54: 40 be 00 1c bne+ cr7,ffc08b70 <rtems_aio_handle+0x1fc> <== NEVER TAKEN
AIO_printf ("Etimeout\n");
--aio_request_queue.idle_threads;
ffc08b58: 81 3f 00 68 lwz r9,104(r31)
pthread_mutex_unlock (&aio_request_queue.mutex);
ffc08b5c: 7f e3 fb 78 mr r3,r31
/* 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;
ffc08b60: 38 09 ff ff addi r0,r9,-1
ffc08b64: 90 1f 00 68 stw r0,104(r31)
pthread_mutex_unlock (&aio_request_queue.mutex);
ffc08b68: 48 00 0c 81 bl ffc097e8 <pthread_mutex_unlock>
return NULL;
ffc08b6c: 48 00 00 3c b ffc08ba8 <rtems_aio_handle+0x234>
}
}
/* 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;
ffc08b70: 81 3f 00 68 lwz r9,104(r31)
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
ffc08b74: 83 df 00 54 lwz r30,84(r31)
ffc08b78: 38 09 ff ff addi r0,r9,-1
++aio_request_queue.active_threads;
ffc08b7c: 81 3f 00 64 lwz r9,100(r31)
}
}
/* 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;
ffc08b80: 90 1f 00 68 stw r0,104(r31)
ffc08b84: 7f c3 f3 78 mr r3,r30
++aio_request_queue.active_threads;
ffc08b88: 38 09 00 01 addi r0,r9,1
ffc08b8c: 90 1f 00 64 stw r0,100(r31)
ffc08b90: 48 00 27 b5 bl ffc0b344 <_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);
ffc08b94: 7f c3 f3 78 mr r3,r30
ffc08b98: 4b ff fd 85 bl ffc0891c <rtems_aio_move_to_work>
}
}
/* If there was a request added in the initial fd chain then release
the mutex and process it */
pthread_mutex_unlock (&aio_request_queue.mutex);
ffc08b9c: 7f e3 fb 78 mr r3,r31
ffc08ba0: 48 00 0c 49 bl ffc097e8 <pthread_mutex_unlock>
ffc08ba4: 4b ff fd fc b ffc089a0 <rtems_aio_handle+0x2c>
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
ffc08ba8: 39 61 00 60 addi r11,r1,96
ffc08bac: 38 60 00 00 li r3,0
ffc08bb0: 4b ff 7f 38 b ffc00ae8 <_restgpr_23_x>
ffc08774 <rtems_aio_init>:
* 0 - if initialization succeeded
*/
int
rtems_aio_init (void)
{
ffc08774: 94 21 ff f0 stwu r1,-16(r1)
ffc08778: 7c 08 02 a6 mflr r0
ffc0877c: bf c1 00 08 stmw r30,8(r1)
int result = 0;
result = pthread_attr_init (&aio_request_queue.attr);
ffc08780: 3f e0 00 00 lis r31,0
ffc08784: 3b ff 2c 78 addi r31,r31,11384
ffc08788: 7f e3 fb 78 mr r3,r31
* 0 - if initialization succeeded
*/
int
rtems_aio_init (void)
{
ffc0878c: 90 01 00 14 stw r0,20(r1)
int result = 0;
result = pthread_attr_init (&aio_request_queue.attr);
ffc08790: 48 00 11 89 bl ffc09918 <pthread_attr_init>
if (result != 0)
ffc08794: 7c 7e 1b 79 mr. r30,r3
ffc08798: 40 a2 00 b4 bne+ ffc0884c <rtems_aio_init+0xd8> <== NEVER TAKEN
return result;
result =
ffc0879c: 7f e3 fb 78 mr r3,r31
ffc087a0: 38 80 00 00 li r4,0
ffc087a4: 48 00 11 b5 bl ffc09958 <pthread_attr_setdetachstate>
pthread_attr_setdetachstate (&aio_request_queue.attr,
PTHREAD_CREATE_DETACHED);
if (result != 0)
ffc087a8: 2f 83 00 00 cmpwi cr7,r3,0
ffc087ac: 41 be 00 0c beq+ cr7,ffc087b8 <rtems_aio_init+0x44> <== ALWAYS TAKEN
pthread_attr_destroy (&aio_request_queue.attr);
ffc087b0: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc087b4: 48 00 11 3d bl ffc098f0 <pthread_attr_destroy> <== NOT EXECUTED
result = pthread_mutex_init (&aio_request_queue.mutex, NULL);
ffc087b8: 3f e0 00 00 lis r31,0
ffc087bc: 3b ff 2c 70 addi r31,r31,11376
ffc087c0: 7f e3 fb 78 mr r3,r31
ffc087c4: 38 80 00 00 li r4,0
ffc087c8: 48 00 0e 25 bl ffc095ec <pthread_mutex_init>
if (result != 0)
ffc087cc: 2f 83 00 00 cmpwi cr7,r3,0
ffc087d0: 41 be 00 0c beq+ cr7,ffc087dc <rtems_aio_init+0x68> <== ALWAYS TAKEN
pthread_attr_destroy (&aio_request_queue.attr);
ffc087d4: 38 7f 00 08 addi r3,r31,8 <== NOT EXECUTED
ffc087d8: 48 00 11 19 bl ffc098f0 <pthread_attr_destroy> <== NOT EXECUTED
result = pthread_cond_init (&aio_request_queue.new_req, NULL);
ffc087dc: 3f e0 00 00 lis r31,0
ffc087e0: 3b ff 2c 74 addi r31,r31,11380
ffc087e4: 7f e3 fb 78 mr r3,r31
ffc087e8: 38 80 00 00 li r4,0
ffc087ec: 48 00 09 b5 bl ffc091a0 <pthread_cond_init>
if (result != 0) {
ffc087f0: 7c 7e 1b 79 mr. r30,r3
ffc087f4: 41 a2 00 14 beq+ ffc08808 <rtems_aio_init+0x94> <== ALWAYS TAKEN
pthread_mutex_destroy (&aio_request_queue.mutex);
ffc087f8: 38 7f ff fc addi r3,r31,-4 <== NOT EXECUTED
ffc087fc: 48 00 0c 85 bl ffc09480 <pthread_mutex_destroy> <== NOT EXECUTED
pthread_attr_destroy (&aio_request_queue.attr);
ffc08800: 38 7f 00 04 addi r3,r31,4 <== NOT EXECUTED
ffc08804: 48 00 10 ed bl ffc098f0 <pthread_attr_destroy> <== NOT EXECUTED
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
ffc08808: 3d 20 00 00 lis r9,0
ffc0880c: 39 29 2c 70 addi r9,r9,11376
ffc08810: 38 09 00 4c addi r0,r9,76
head->previous = NULL;
tail->previous = head;
ffc08814: 39 69 00 48 addi r11,r9,72
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
ffc08818: 90 09 00 48 stw r0,72(r9)
head->previous = NULL;
ffc0881c: 38 00 00 00 li r0,0
tail->previous = head;
ffc08820: 91 69 00 50 stw r11,80(r9)
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
ffc08824: 39 69 00 58 addi r11,r9,88
head->previous = NULL;
ffc08828: 90 09 00 4c stw r0,76(r9)
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
ffc0882c: 91 69 00 54 stw r11,84(r9)
head->previous = NULL;
tail->previous = head;
ffc08830: 39 69 00 54 addi r11,r9,84
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
head->previous = NULL;
ffc08834: 90 09 00 58 stw r0,88(r9)
}
rtems_chain_initialize_empty (&aio_request_queue.work_req);
rtems_chain_initialize_empty (&aio_request_queue.idle_req);
aio_request_queue.active_threads = 0;
ffc08838: 90 09 00 64 stw r0,100(r9)
aio_request_queue.idle_threads = 0;
ffc0883c: 90 09 00 68 stw r0,104(r9)
aio_request_queue.initialized = AIO_QUEUE_INITIALIZED;
ffc08840: 60 00 b0 0b ori r0,r0,45067
tail->previous = head;
ffc08844: 91 69 00 5c stw r11,92(r9)
ffc08848: 90 09 00 60 stw r0,96(r9)
return result;
}
ffc0884c: 39 61 00 10 addi r11,r1,16
ffc08850: 7f c3 f3 78 mr r3,r30
ffc08854: 4b ff 82 b0 b ffc00b04 <_restgpr_30_x>
ffc08bb4 <rtems_aio_insert_prio>:
* NONE
*/
void
rtems_aio_insert_prio (rtems_chain_control *chain, rtems_aio_request *req)
{
ffc08bb4: 7c 08 02 a6 mflr r0
ffc08bb8: 94 21 ff f8 stwu r1,-8(r1)
ffc08bbc: 7c 8b 23 78 mr r11,r4
ffc08bc0: 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 );
ffc08bc4: 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;
ffc08bc8: 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)) {
ffc08bcc: 7f 89 00 00 cmpw cr7,r9,r0
ffc08bd0: 41 9e 00 3c beq- cr7,ffc08c0c <rtems_aio_insert_prio+0x58><== NEVER TAKEN
AIO_printf ("First in chain \n");
rtems_chain_prepend (chain, &req->next_prio);
} else {
AIO_printf ("Add by priority \n");
int prio = ((rtems_aio_request *) node)->aiocbp->aio_reqprio;
ffc08bd4: 81 49 00 14 lwz r10,20(r9)
while (req->aiocbp->aio_reqprio > prio &&
ffc08bd8: 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;
ffc08bdc: 81 4a 00 18 lwz r10,24(r10)
while (req->aiocbp->aio_reqprio > prio &&
ffc08be0: 81 08 00 18 lwz r8,24(r8)
ffc08be4: 48 00 00 10 b ffc08bf4 <rtems_aio_insert_prio+0x40>
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
ffc08be8: 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;
ffc08bec: 81 49 00 14 lwz r10,20(r9) <== NOT EXECUTED
ffc08bf0: 81 4a 00 18 lwz r10,24(r10) <== 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 &&
ffc08bf4: 7f 88 50 00 cmpw cr7,r8,r10
ffc08bf8: 40 9d 00 0c ble- cr7,ffc08c04 <rtems_aio_insert_prio+0x50><== ALWAYS TAKEN
ffc08bfc: 7f 89 00 00 cmpw cr7,r9,r0 <== NOT EXECUTED
ffc08c00: 40 9e ff e8 bne+ cr7,ffc08be8 <rtems_aio_insert_prio+0x34><== 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 );
ffc08c04: 80 69 00 04 lwz r3,4(r9)
ffc08c08: 7d 64 5b 78 mr r4,r11
ffc08c0c: 48 00 27 a1 bl ffc0b3ac <_Chain_Insert>
}
rtems_chain_insert (node->previous, &req->next_prio);
}
}
ffc08c10: 80 01 00 0c lwz r0,12(r1)
ffc08c14: 38 21 00 08 addi r1,r1,8
ffc08c18: 7c 08 03 a6 mtlr r0
ffc08c1c: 4e 80 00 20 blr
ffc0891c <rtems_aio_move_to_work>:
* NONE
*/
void
rtems_aio_move_to_work (rtems_aio_request_chain *r_chain)
{
ffc0891c: 7c 08 02 a6 mflr r0
ffc08920: 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;
ffc08924: 3d 60 00 00 lis r11,0
ffc08928: 90 01 00 0c stw r0,12(r1)
ffc0892c: 39 6b 2c 70 addi r11,r11,11376
ffc08930: 7c 64 1b 78 mr r4,r3
rtems_aio_request_chain *temp;
rtems_chain_node *node;
node = rtems_chain_first (&aio_request_queue.work_req);
temp = (rtems_aio_request_chain *) node;
ffc08934: 81 2b 00 48 lwz r9,72(r11)
while (temp->fildes < r_chain->fildes &&
ffc08938: 39 6b 00 4c addi r11,r11,76
ffc0893c: 80 03 00 14 lwz r0,20(r3)
ffc08940: 48 00 00 08 b ffc08948 <rtems_aio_move_to_work+0x2c>
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
ffc08944: 81 29 00 00 lwz r9,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 &&
ffc08948: 81 49 00 14 lwz r10,20(r9)
ffc0894c: 7f 8a 00 00 cmpw cr7,r10,r0
ffc08950: 40 9c 00 0c bge- cr7,ffc0895c <rtems_aio_move_to_work+0x40>
ffc08954: 7f 89 58 00 cmpw cr7,r9,r11
ffc08958: 40 9e ff ec bne+ cr7,ffc08944 <rtems_aio_move_to_work+0x28><== ALWAYS TAKEN
ffc0895c: 80 69 00 04 lwz r3,4(r9)
ffc08960: 48 00 2a 4d bl ffc0b3ac <_Chain_Insert>
node = rtems_chain_next (node);
temp = (rtems_aio_request_chain *) node;
}
rtems_chain_insert (rtems_chain_previous (node), &r_chain->next_fd);
}
ffc08964: 80 01 00 0c lwz r0,12(r1)
ffc08968: 38 21 00 08 addi r1,r1,8
ffc0896c: 7c 08 03 a6 mtlr r0
ffc08970: 4e 80 00 20 blr
ffc08c78 <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)
{
ffc08c78: 7c 08 02 a6 mflr r0
ffc08c7c: 7c 2b 0b 78 mr r11,r1
ffc08c80: 94 21 ff f0 stwu r1,-16(r1)
ffc08c84: 90 01 00 14 stw r0,20(r1)
ffc08c88: 4b ff 7e 35 bl ffc00abc <_savegpr_31>
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
ffc08c8c: 38 03 00 04 addi r0,r3,4
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_head( the_chain )->next;
ffc08c90: 83 e3 00 00 lwz r31,0(r3)
if (rtems_chain_is_empty (chain))
return AIO_ALLDONE;
ffc08c94: 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))
ffc08c98: 7f 9f 00 00 cmpw cr7,r31,r0
ffc08c9c: 40 be 00 0c bne+ cr7,ffc08ca8 <rtems_aio_remove_req+0x30>
ffc08ca0: 48 00 00 4c b ffc08cec <rtems_aio_remove_req+0x74>
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
ffc08ca4: 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) {
ffc08ca8: 7f 9f 00 00 cmpw cr7,r31,r0
ffc08cac: 41 9e 00 3c beq- cr7,ffc08ce8 <rtems_aio_remove_req+0x70><== NEVER TAKEN
ffc08cb0: 81 3f 00 14 lwz r9,20(r31)
ffc08cb4: 7f 89 20 00 cmpw cr7,r9,r4
ffc08cb8: 40 9e ff ec bne+ cr7,ffc08ca4 <rtems_aio_remove_req+0x2c><== NEVER TAKEN
ffc08cbc: 7f e3 fb 78 mr r3,r31
ffc08cc0: 48 00 26 85 bl ffc0b344 <_Chain_Extract>
if (rtems_chain_is_tail (chain, node))
return AIO_NOTCANCELED;
else
{
rtems_chain_extract (node);
current->aiocbp->error_code = ECANCELED;
ffc08cc4: 81 3f 00 14 lwz r9,20(r31)
ffc08cc8: 38 00 00 8c li r0,140
ffc08ccc: 90 09 00 34 stw r0,52(r9)
current->aiocbp->return_value = -1;
ffc08cd0: 38 00 ff ff li r0,-1
free (current);
ffc08cd4: 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;
ffc08cd8: 90 09 00 38 stw r0,56(r9)
free (current);
ffc08cdc: 4b ff c4 2d bl ffc05108 <free>
}
return AIO_CANCELED;
ffc08ce0: 38 60 00 00 li r3,0
ffc08ce4: 48 00 00 08 b ffc08cec <rtems_aio_remove_req+0x74>
node = rtems_chain_next (node);
current = (rtems_aio_request *) node;
}
if (rtems_chain_is_tail (chain, node))
return AIO_NOTCANCELED;
ffc08ce8: 38 60 00 01 li r3,1 <== NOT EXECUTED
current->aiocbp->return_value = -1;
free (current);
}
return AIO_CANCELED;
}
ffc08cec: 39 61 00 10 addi r11,r1,16
ffc08cf0: 4b ff 7e 18 b ffc00b08 <_restgpr_31_x>
ffc0d294 <rtems_bdbuf_add_to_modified_list_after_access>:
}
}
static void
rtems_bdbuf_add_to_modified_list_after_access (rtems_bdbuf_buffer *bd)
{
ffc0d294: 94 21 ff f0 stwu r1,-16(r1)
ffc0d298: 7c 08 02 a6 mflr r0
if (bdbuf_cache.sync_active && bdbuf_cache.sync_device == bd->dev)
ffc0d29c: 3d 20 00 00 lis r9,0
}
}
static void
rtems_bdbuf_add_to_modified_list_after_access (rtems_bdbuf_buffer *bd)
{
ffc0d2a0: 90 01 00 14 stw r0,20(r1)
if (bdbuf_cache.sync_active && bdbuf_cache.sync_device == bd->dev)
ffc0d2a4: 39 29 2a 08 addi r9,r9,10760
ffc0d2a8: 88 09 00 30 lbz r0,48(r9)
}
}
static void
rtems_bdbuf_add_to_modified_list_after_access (rtems_bdbuf_buffer *bd)
{
ffc0d2ac: bf c1 00 08 stmw r30,8(r1)
ffc0d2b0: 7c 7f 1b 78 mr r31,r3
if (bdbuf_cache.sync_active && bdbuf_cache.sync_device == bd->dev)
ffc0d2b4: 2f 80 00 00 cmpwi cr7,r0,0
ffc0d2b8: 41 9e 00 34 beq- cr7,ffc0d2ec <rtems_bdbuf_add_to_modified_list_after_access+0x58><== ALWAYS TAKEN
ffc0d2bc: 81 49 00 38 lwz r10,56(r9) <== NOT EXECUTED
ffc0d2c0: 80 03 00 18 lwz r0,24(r3) <== NOT EXECUTED
ffc0d2c4: 81 69 00 3c lwz r11,60(r9) <== NOT EXECUTED
ffc0d2c8: 7f 80 50 00 cmpw cr7,r0,r10 <== NOT EXECUTED
ffc0d2cc: 40 be 00 20 bne+ cr7,ffc0d2ec <rtems_bdbuf_add_to_modified_list_after_access+0x58><== NOT EXECUTED
ffc0d2d0: 80 03 00 1c lwz r0,28(r3) <== NOT EXECUTED
ffc0d2d4: 7f 80 58 00 cmpw cr7,r0,r11 <== NOT EXECUTED
ffc0d2d8: 40 be 00 14 bne+ cr7,ffc0d2ec <rtems_bdbuf_add_to_modified_list_after_access+0x58><== NOT EXECUTED
{
rtems_bdbuf_unlock_cache ();
ffc0d2dc: 4b ff fb c5 bl ffc0cea0 <rtems_bdbuf_unlock_cache> <== NOT EXECUTED
/*
* Wait for the sync lock.
*/
rtems_bdbuf_lock_sync ();
ffc0d2e0: 4b ff f9 ad bl ffc0cc8c <rtems_bdbuf_lock_sync> <== NOT EXECUTED
rtems_bdbuf_unlock_sync ();
ffc0d2e4: 4b ff fb f9 bl ffc0cedc <rtems_bdbuf_unlock_sync> <== NOT EXECUTED
rtems_bdbuf_lock_cache ();
ffc0d2e8: 4b ff f9 61 bl ffc0cc48 <rtems_bdbuf_lock_cache> <== 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
ffc0d2ec: 80 1f 00 28 lwz r0,40(r31)
ffc0d2f0: 2f 80 00 03 cmpwi cr7,r0,3
ffc0d2f4: 41 9e 00 10 beq- cr7,ffc0d304 <rtems_bdbuf_add_to_modified_list_after_access+0x70>
|| bd->state == RTEMS_BDBUF_STATE_ACCESS_EMPTY)
ffc0d2f8: 80 1f 00 28 lwz r0,40(r31)
ffc0d2fc: 2f 80 00 05 cmpwi cr7,r0,5
ffc0d300: 40 be 00 10 bne+ cr7,ffc0d310 <rtems_bdbuf_add_to_modified_list_after_access+0x7c>
bd->hold_timer = bdbuf_config.swap_block_hold;
ffc0d304: 3d 20 ff c2 lis r9,-62
ffc0d308: 80 09 a2 e4 lwz r0,-23836(r9)
ffc0d30c: 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;
ffc0d310: 38 00 00 07 li r0,7
if (bd->state == RTEMS_BDBUF_STATE_ACCESS_CACHED
|| bd->state == RTEMS_BDBUF_STATE_ACCESS_EMPTY)
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);
ffc0d314: 3f c0 00 00 lis r30,0
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
ffc0d318: 90 1f 00 28 stw r0,40(r31)
if (bd->state == RTEMS_BDBUF_STATE_ACCESS_CACHED
|| bd->state == RTEMS_BDBUF_STATE_ACCESS_EMPTY)
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);
ffc0d31c: 3b de 2a 08 addi r30,r30,10760
RTEMS_INLINE_ROUTINE void rtems_chain_append(
rtems_chain_control *the_chain,
rtems_chain_node *the_node
)
{
_Chain_Append( the_chain, the_node );
ffc0d320: 38 7e 00 50 addi r3,r30,80
ffc0d324: 7f e4 fb 78 mr r4,r31
ffc0d328: 4b ff c5 35 bl ffc0985c <_Chain_Append>
if (bd->waiters)
ffc0d32c: 80 1f 00 2c lwz r0,44(r31)
ffc0d330: 2f 80 00 00 cmpwi cr7,r0,0
ffc0d334: 41 be 00 1c beq+ cr7,ffc0d350 <rtems_bdbuf_add_to_modified_list_after_access+0xbc>
rtems_bdbuf_wake (&bdbuf_cache.access_waiters);
else if (rtems_bdbuf_has_buffer_waiters ())
rtems_bdbuf_wake_swapper ();
}
ffc0d338: 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);
ffc0d33c: 38 7e 00 68 addi r3,r30,104
else if (rtems_bdbuf_has_buffer_waiters ())
rtems_bdbuf_wake_swapper ();
}
ffc0d340: bb c1 00 08 lmw r30,8(r1)
ffc0d344: 38 21 00 10 addi r1,r1,16
ffc0d348: 7c 08 03 a6 mtlr r0
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);
ffc0d34c: 4b ff ff 04 b ffc0d250 <rtems_bdbuf_wake>
}
static bool
rtems_bdbuf_has_buffer_waiters (void)
{
return bdbuf_cache.buffer_waiters.count;
ffc0d350: 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 ())
ffc0d354: 2f 80 00 00 cmpwi cr7,r0,0
ffc0d358: 41 be 00 18 beq+ cr7,ffc0d370 <rtems_bdbuf_add_to_modified_list_after_access+0xdc>
rtems_bdbuf_wake_swapper ();
}
ffc0d35c: 80 01 00 14 lwz r0,20(r1)
ffc0d360: bb c1 00 08 lmw r30,8(r1)
ffc0d364: 38 21 00 10 addi r1,r1,16
ffc0d368: 7c 08 03 a6 mtlr r0
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 ();
ffc0d36c: 4b ff fb e0 b ffc0cf4c <rtems_bdbuf_wake_swapper>
}
ffc0d370: 39 61 00 10 addi r11,r1,16
ffc0d374: 48 00 c1 a0 b ffc19514 <_restgpr_30_x>
ffc0d0a0 <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)
{
ffc0d0a0: 94 21 ff f0 stwu r1,-16(r1)
ffc0d0a4: 7c 08 02 a6 mflr r0
ffc0d0a8: 90 01 00 14 stw r0,20(r1)
rtems_mode prev_mode;
/*
* Indicate we are waiting.
*/
++waiters->count;
ffc0d0ac: 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)
{
ffc0d0b0: bf c1 00 08 stmw r30,8(r1)
ffc0d0b4: 7c 7f 1b 78 mr r31,r3
rtems_mode prev_mode;
/*
* Indicate we are waiting.
*/
++waiters->count;
ffc0d0b8: 38 09 00 01 addi r0,r9,1
ffc0d0bc: 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 ();
ffc0d0c0: 4b ff ff 51 bl ffc0d010 <rtems_bdbuf_disable_preemption>
ffc0d0c4: 7c 7e 1b 78 mr r30,r3
/*
* Unlock the cache, wait, and lock the cache when we return.
*/
rtems_bdbuf_unlock_cache ();
ffc0d0c8: 4b ff fd d9 bl ffc0cea0 <rtems_bdbuf_unlock_cache>
sc = rtems_semaphore_obtain (waiters->sema, RTEMS_WAIT, RTEMS_BDBUF_WAIT_TIMEOUT);
ffc0d0cc: 80 7f 00 04 lwz r3,4(r31)
ffc0d0d0: 38 80 00 00 li r4,0
ffc0d0d4: 38 a0 00 00 li r5,0
ffc0d0d8: 4b ff ba 41 bl ffc08b18 <rtems_semaphore_obtain>
if (sc == RTEMS_TIMEOUT)
ffc0d0dc: 2f 83 00 06 cmpwi cr7,r3,6
ffc0d0e0: 40 be 00 10 bne+ cr7,ffc0d0f0 <rtems_bdbuf_anonymous_wait+0x50><== ALWAYS TAKEN
rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_CACHE_WAIT_TO);
ffc0d0e4: 3c 60 42 00 lis r3,16896 <== NOT EXECUTED
ffc0d0e8: 60 63 00 12 ori r3,r3,18 <== NOT EXECUTED
ffc0d0ec: 48 00 00 14 b ffc0d100 <rtems_bdbuf_anonymous_wait+0x60><== NOT EXECUTED
if (sc != RTEMS_UNSATISFIED)
ffc0d0f0: 2f 83 00 0d cmpwi cr7,r3,13
ffc0d0f4: 41 be 00 10 beq+ cr7,ffc0d104 <rtems_bdbuf_anonymous_wait+0x64><== ALWAYS TAKEN
rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_CACHE_WAIT_2);
ffc0d0f8: 3c 60 42 00 lis r3,16896 <== NOT EXECUTED
ffc0d0fc: 60 63 00 10 ori r3,r3,16 <== NOT EXECUTED
ffc0d100: 4b ff c1 a5 bl ffc092a4 <rtems_fatal_error_occurred> <== NOT EXECUTED
rtems_bdbuf_lock_cache ();
ffc0d104: 4b ff fb 45 bl ffc0cc48 <rtems_bdbuf_lock_cache>
rtems_bdbuf_restore_preemption (prev_mode);
ffc0d108: 7f c3 f3 78 mr r3,r30
ffc0d10c: 4b ff ff 51 bl ffc0d05c <rtems_bdbuf_restore_preemption>
--waiters->count;
ffc0d110: 81 3f 00 00 lwz r9,0(r31)
}
ffc0d114: 39 61 00 10 addi r11,r1,16
rtems_bdbuf_lock_cache ();
rtems_bdbuf_restore_preemption (prev_mode);
--waiters->count;
ffc0d118: 38 09 ff ff addi r0,r9,-1
ffc0d11c: 90 1f 00 00 stw r0,0(r31)
}
ffc0d120: 48 00 c3 f4 b ffc19514 <_restgpr_30_x>
ffc0d1ec <rtems_bdbuf_avl_search.isra.1>:
* @param block block search key
* @retval NULL node with the specified dev/block is not found
* @return pointer to the node with specified dev/block
*/
static rtems_bdbuf_buffer *
rtems_bdbuf_avl_search (rtems_bdbuf_buffer** root,
ffc0d1ec: 48 00 00 34 b ffc0d220 <rtems_bdbuf_avl_search.isra.1+0x34>
{
rtems_bdbuf_buffer* p = *root;
while ((p != NULL) && ((p->dev != dev) || (p->block != block)))
{
if ((p->dev < dev) || ((p->dev == dev) && (p->block < block)))
ffc0d1f0: 7f 85 00 40 cmplw cr7,r5,r0
ffc0d1f4: 41 bd 00 20 bgt+ cr7,ffc0d214 <rtems_bdbuf_avl_search.isra.1+0x28>
ffc0d1f8: 7f 85 00 00 cmpw cr7,r5,r0
ffc0d1fc: 40 9e 00 20 bne- cr7,ffc0d21c <rtems_bdbuf_avl_search.isra.1+0x30><== ALWAYS TAKEN
ffc0d200: 7f 86 48 40 cmplw cr7,r6,r9 <== NOT EXECUTED
ffc0d204: 41 bd 00 10 bgt+ cr7,ffc0d214 <rtems_bdbuf_avl_search.isra.1+0x28><== NOT EXECUTED
ffc0d208: 48 00 00 14 b ffc0d21c <rtems_bdbuf_avl_search.isra.1+0x30><== NOT EXECUTED
ffc0d20c: 7f 80 38 40 cmplw cr7,r0,r7
ffc0d210: 40 9c 00 0c bge- cr7,ffc0d21c <rtems_bdbuf_avl_search.isra.1+0x30>
{
p = p->avl.right;
ffc0d214: 80 63 00 0c lwz r3,12(r3)
ffc0d218: 48 00 00 08 b ffc0d220 <rtems_bdbuf_avl_search.isra.1+0x34>
}
else
{
p = p->avl.left;
ffc0d21c: 80 63 00 08 lwz r3,8(r3)
dev_t dev,
rtems_blkdev_bnum block)
{
rtems_bdbuf_buffer* p = *root;
while ((p != NULL) && ((p->dev != dev) || (p->block != block)))
ffc0d220: 2f 83 00 00 cmpwi cr7,r3,0
ffc0d224: 4d 9e 00 20 beqlr cr7
ffc0d228: 80 03 00 18 lwz r0,24(r3)
ffc0d22c: 81 23 00 1c lwz r9,28(r3)
ffc0d230: 7f 80 28 00 cmpw cr7,r0,r5
ffc0d234: 40 9e ff bc bne+ cr7,ffc0d1f0 <rtems_bdbuf_avl_search.isra.1+0x4>
ffc0d238: 7f 89 30 00 cmpw cr7,r9,r6
ffc0d23c: 40 9e ff b4 bne+ cr7,ffc0d1f0 <rtems_bdbuf_avl_search.isra.1+0x4><== NEVER TAKEN
ffc0d240: 80 03 00 20 lwz r0,32(r3)
ffc0d244: 7f 80 38 00 cmpw cr7,r0,r7
ffc0d248: 40 9e ff c4 bne+ cr7,ffc0d20c <rtems_bdbuf_avl_search.isra.1+0x20>
p = p->avl.left;
}
}
return p;
}
ffc0d24c: 4e 80 00 20 blr
ffc0d010 <rtems_bdbuf_disable_preemption>:
--bd->group->users;
}
static rtems_mode
rtems_bdbuf_disable_preemption (void)
{
ffc0d010: 94 21 ff e8 stwu r1,-24(r1)
ffc0d014: 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);
ffc0d018: 38 60 01 00 li r3,256
--bd->group->users;
}
static rtems_mode
rtems_bdbuf_disable_preemption (void)
{
ffc0d01c: 90 01 00 1c stw r0,28(r1)
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_mode prev_mode = 0;
ffc0d020: 7c 25 0b 78 mr r5,r1
ffc0d024: 38 00 00 00 li r0,0
ffc0d028: 94 05 00 08 stwu r0,8(r5)
sc = rtems_task_mode (RTEMS_NO_PREEMPT, RTEMS_PREEMPT_MASK, &prev_mode);
ffc0d02c: 38 80 01 00 li r4,256
ffc0d030: 48 00 49 e9 bl ffc11a18 <rtems_task_mode>
if (sc != RTEMS_SUCCESSFUL)
ffc0d034: 2f 83 00 00 cmpwi cr7,r3,0
ffc0d038: 41 be 00 10 beq+ cr7,ffc0d048 <rtems_bdbuf_disable_preemption+0x38><== ALWAYS TAKEN
rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_PREEMPT_DIS);
ffc0d03c: 3c 60 42 00 lis r3,16896 <== NOT EXECUTED
ffc0d040: 60 63 00 0f ori r3,r3,15 <== NOT EXECUTED
ffc0d044: 4b ff c2 61 bl ffc092a4 <rtems_fatal_error_occurred> <== NOT EXECUTED
return prev_mode;
}
ffc0d048: 80 01 00 1c lwz r0,28(r1)
ffc0d04c: 80 61 00 08 lwz r3,8(r1)
ffc0d050: 38 21 00 18 addi r1,r1,24
ffc0d054: 7c 08 03 a6 mtlr r0
ffc0d058: 4e 80 00 20 blr
ffc0ccd0 <rtems_bdbuf_fatal>:
#define RTEMS_BDBUF_AVL_MAX_HEIGHT (32)
#endif
static void
rtems_bdbuf_fatal (rtems_bdbuf_buf_state state, uint32_t error)
{
ffc0ccd0: 94 21 ff f8 stwu r1,-8(r1) <== NOT EXECUTED
ffc0ccd4: 7c 08 02 a6 mflr r0 <== NOT EXECUTED
rtems_fatal_error_occurred ((((uint32_t) state) << 16) | error);
ffc0ccd8: 54 63 80 1e rlwinm r3,r3,16,0,15 <== NOT EXECUTED
ffc0ccdc: 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)
{
ffc0cce0: 90 01 00 0c stw r0,12(r1) <== NOT EXECUTED
rtems_fatal_error_occurred ((((uint32_t) state) << 16) | error);
ffc0cce4: 4b ff c5 c1 bl ffc092a4 <rtems_fatal_error_occurred> <== NOT EXECUTED
ffc0eb2c <rtems_bdbuf_get>:
rtems_status_code
rtems_bdbuf_get (dev_t dev,
rtems_blkdev_bnum block,
rtems_bdbuf_buffer **bd_ptr)
{
ffc0eb2c: 94 21 ff d8 stwu r1,-40(r1)
ffc0eb30: 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)
ffc0eb34: 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)
{
ffc0eb38: 90 01 00 2c stw r0,44(r1)
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_disk_device *dd = NULL;
ffc0eb3c: 38 00 00 00 li r0,0
ffc0eb40: 90 01 00 10 stw r0,16(r1)
rtems_bdbuf_buffer *bd = NULL;
rtems_blkdev_bnum media_block = 0;
ffc0eb44: 90 01 00 0c stw r0,12(r1)
size_t bds_per_group = 0;
ffc0eb48: 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)
ffc0eb4c: 88 09 2a 90 lbz r0,10896(r9)
rtems_status_code
rtems_bdbuf_get (dev_t dev,
rtems_blkdev_bnum block,
rtems_bdbuf_buffer **bd_ptr)
{
ffc0eb50: bf 81 00 18 stmw r28,24(r1)
ffc0eb54: 7c 9f 23 78 mr r31,r4
rtems_blkdev_bnum *media_block_ptr,
size_t *bds_per_group_ptr)
{
rtems_disk_device *dd = NULL;
if (!bdbuf_cache.initialised)
ffc0eb58: 2f 80 00 00 cmpwi cr7,r0,0
rtems_status_code
rtems_bdbuf_get (dev_t dev,
rtems_blkdev_bnum block,
rtems_bdbuf_buffer **bd_ptr)
{
ffc0eb5c: 7c 7e 1b 78 mr r30,r3
ffc0eb60: 7c dd 33 78 mr r29,r6
size_t *bds_per_group_ptr)
{
rtems_disk_device *dd = NULL;
if (!bdbuf_cache.initialised)
return RTEMS_NOT_CONFIGURED;
ffc0eb64: 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)
ffc0eb68: 41 be 00 94 beq+ cr7,ffc0ebfc <rtems_bdbuf_get+0xd0> <== NEVER TAKEN
ffc0eb6c: 38 c1 00 10 addi r6,r1,16
ffc0eb70: 38 e1 00 0c addi r7,r1,12
ffc0eb74: 39 01 00 08 addi r8,r1,8
ffc0eb78: 4b ff e8 01 bl ffc0d378 <rtems_bdbuf_obtain_disk.part.7>
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)
ffc0eb7c: 7c 7c 1b 79 mr. r28,r3
ffc0eb80: 40 82 00 7c bne- ffc0ebfc <rtems_bdbuf_get+0xd0> <== NEVER TAKEN
return sc;
rtems_bdbuf_lock_cache ();
ffc0eb84: 4b ff e0 c5 bl ffc0cc48 <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);
ffc0eb88: 80 a1 00 0c lwz r5,12(r1)
ffc0eb8c: 80 c1 00 08 lwz r6,8(r1)
ffc0eb90: 7f c3 f3 78 mr r3,r30
ffc0eb94: 7f e4 fb 78 mr r4,r31
ffc0eb98: 4b ff f9 e9 bl ffc0e580 <rtems_bdbuf_get_buffer_for_access>
switch (bd->state)
ffc0eb9c: 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);
ffc0eba0: 7c 7e 1b 78 mr r30,r3
switch (bd->state)
ffc0eba4: 2f 80 00 02 cmpwi cr7,r0,2
ffc0eba8: 41 9e 00 18 beq- cr7,ffc0ebc0 <rtems_bdbuf_get+0x94>
ffc0ebac: 2f 80 00 07 cmpwi cr7,r0,7
ffc0ebb0: 41 9e 00 34 beq- cr7,ffc0ebe4 <rtems_bdbuf_get+0xb8>
ffc0ebb4: 2f 80 00 01 cmpwi cr7,r0,1
ffc0ebb8: 40 be 00 34 bne+ cr7,ffc0ebec <rtems_bdbuf_get+0xc0> <== NEVER TAKEN
ffc0ebbc: 48 00 00 0c b ffc0ebc8 <rtems_bdbuf_get+0x9c>
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
ffc0ebc0: 38 00 00 03 li r0,3
ffc0ebc4: 48 00 00 08 b ffc0ebcc <rtems_bdbuf_get+0xa0>
ffc0ebc8: 38 00 00 05 li r0,5
ffc0ebcc: 90 1e 00 28 stw r0,40(r30)
{
rtems_bdbuf_show_users ("get", bd);
rtems_bdbuf_show_usage ();
}
rtems_bdbuf_unlock_cache ();
ffc0ebd0: 4b ff e2 d1 bl ffc0cea0 <rtems_bdbuf_unlock_cache>
rtems_bdbuf_release_disk (dd);
ffc0ebd4: 80 61 00 10 lwz r3,16(r1)
ffc0ebd8: 4b ff e3 41 bl ffc0cf18 <rtems_bdbuf_release_disk>
*bd_ptr = bd;
ffc0ebdc: 93 dd 00 00 stw r30,0(r29)
return RTEMS_SUCCESSFUL;
ffc0ebe0: 48 00 00 1c b ffc0ebfc <rtems_bdbuf_get+0xd0>
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
ffc0ebe4: 38 00 00 04 li r0,4
ffc0ebe8: 4b ff ff e4 b ffc0ebcc <rtems_bdbuf_get+0xa0>
* 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);
ffc0ebec: 3c 80 42 00 lis r4,16896 <== NOT EXECUTED
ffc0ebf0: 80 63 00 28 lwz r3,40(r3) <== NOT EXECUTED
ffc0ebf4: 60 84 00 1e ori r4,r4,30 <== NOT EXECUTED
ffc0ebf8: 4b ff e0 d9 bl ffc0ccd0 <rtems_bdbuf_fatal> <== NOT EXECUTED
rtems_bdbuf_release_disk (dd);
*bd_ptr = bd;
return RTEMS_SUCCESSFUL;
}
ffc0ebfc: 39 61 00 28 addi r11,r1,40
ffc0ec00: 7f 83 e3 78 mr r3,r28
ffc0ec04: 48 00 a9 08 b ffc1950c <_restgpr_28_x>
ffc0e580 <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)
{
ffc0e580: 94 21 ff b8 stwu r1,-72(r1)
ffc0e584: 7c 08 02 a6 mflr r0
ffc0e588: be 01 00 08 stmw r16,8(r1)
rtems_bdbuf_buffer *bd = NULL;
do
{
bd = rtems_bdbuf_avl_search (&bdbuf_cache.tree, dev, block);
ffc0e58c: 3f a0 00 00 lis r29,0
ffc0e590: 3b bd 2a 08 addi r29,r29,10760
static bool
rtems_bdbuf_wait_for_recycle (rtems_bdbuf_buffer *bd)
{
while (true)
{
switch (bd->state)
ffc0e594: 3f 60 ff c2 lis r27,-62
static rtems_bdbuf_buffer *
rtems_bdbuf_get_buffer_for_access (dev_t dev,
rtems_blkdev_bnum block,
size_t bds_per_group)
{
ffc0e598: 90 01 00 4c stw r0,76(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);
ffc0e59c: 3b 9d 00 78 addi r28,r29,120
static rtems_bdbuf_buffer *
rtems_bdbuf_get_buffer_for_access (dev_t dev,
rtems_blkdev_bnum block,
size_t bds_per_group)
{
ffc0e5a0: 7c 9f 23 78 mr r31,r4
ffc0e5a4: 7c 7e 1b 78 mr r30,r3
ffc0e5a8: 7c b9 2b 78 mr r25,r5
ffc0e5ac: 7c da 33 78 mr r26,r6
static bool
rtems_bdbuf_wait_for_recycle (rtems_bdbuf_buffer *bd)
{
while (true)
{
switch (bd->state)
ffc0e5b0: 3b 7b b0 54 addi r27,r27,-20396
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);
ffc0e5b4: 3a 3d 00 70 addi r17,r29,112
}
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);
ffc0e5b8: 3a 5d 00 68 addi r18,r29,104
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
ffc0e5bc: 3a 60 00 08 li r19,8
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);
ffc0e5c0: 3a 9d 00 5c addi r20,r29,92
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
ffc0e5c4: 3a a0 00 00 li r21,0
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Head(
Chain_Control *the_chain
)
{
return &the_chain->Head.Node;
ffc0e5c8: 3a dd 00 44 addi r22,r29,68
* It is essential that we wait here without a special wait count and
* without the group in use. Otherwise we could trigger a wait ping
* pong with another recycle waiter. The state of the buffer is
* arbitrary afterwards.
*/
rtems_bdbuf_anonymous_wait (&bdbuf_cache.buffer_waiters);
ffc0e5cc: 7f 97 e3 78 mr r23,r28
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_tail(
const Chain_Control *the_chain
)
{
return &the_chain->Tail.Node;
ffc0e5d0: 3b 1d 00 54 addi r24,r29,84
{
rtems_bdbuf_buffer *bd = NULL;
do
{
bd = rtems_bdbuf_avl_search (&bdbuf_cache.tree, dev, block);
ffc0e5d4: 80 7d 00 40 lwz r3,64(r29)
ffc0e5d8: 7f c5 f3 78 mr r5,r30
ffc0e5dc: 7f e6 fb 78 mr r6,r31
ffc0e5e0: 7f 27 cb 78 mr r7,r25
ffc0e5e4: 4b ff ec 09 bl ffc0d1ec <rtems_bdbuf_avl_search.isra.1>
if (bd != NULL)
ffc0e5e8: 7c 70 1b 79 mr. r16,r3
ffc0e5ec: 41 82 00 b8 beq- ffc0e6a4 <rtems_bdbuf_get_buffer_for_access+0x124>
{
if (bd->group->bds_per_group != bds_per_group)
ffc0e5f0: 81 30 00 30 lwz r9,48(r16)
ffc0e5f4: 80 09 00 08 lwz r0,8(r9)
ffc0e5f8: 7f 80 d0 00 cmpw cr7,r0,r26
ffc0e5fc: 41 9e 00 e0 beq- cr7,ffc0e6dc <rtems_bdbuf_get_buffer_for_access+0x15c>
static bool
rtems_bdbuf_wait_for_recycle (rtems_bdbuf_buffer *bd)
{
while (true)
{
switch (bd->state)
ffc0e600: 80 10 00 28 lwz r0,40(r16)
ffc0e604: 2b 80 00 0a cmplwi cr7,r0,10
ffc0e608: 41 9d 00 68 bgt- cr7,ffc0e670 <rtems_bdbuf_get_buffer_for_access+0xf0><== NEVER TAKEN
ffc0e60c: 54 00 10 3a rlwinm r0,r0,2,0,29
ffc0e610: 7c 1b 00 2e lwzx r0,r27,r0
ffc0e614: 7c 00 da 14 add r0,r0,r27
ffc0e618: 7c 09 03 a6 mtctr r0
ffc0e61c: 4e 80 04 20 bctr
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
ffc0e620: 92 70 00 28 stw r19,40(r16) <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
ffc0e624: 7e 03 83 78 mr r3,r16 <== NOT EXECUTED
ffc0e628: 4b ff b2 65 bl ffc0988c <_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 );
ffc0e62c: 7e 83 a3 78 mr r3,r20 <== NOT EXECUTED
ffc0e630: 7e 04 83 78 mr r4,r16 <== NOT EXECUTED
ffc0e634: 4b ff b2 29 bl ffc0985c <_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 ();
ffc0e638: 4b ff e9 15 bl ffc0cf4c <rtems_bdbuf_wake_swapper> <== NOT EXECUTED
ffc0e63c: 4b ff ff c4 b ffc0e600 <rtems_bdbuf_get_buffer_for_access+0x80><== NOT EXECUTED
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)
ffc0e640: 80 10 00 2c lwz r0,44(r16)
* It is essential that we wait here without a special wait count and
* without the group in use. Otherwise we could trigger a wait ping
* pong with another recycle waiter. The state of the buffer is
* arbitrary afterwards.
*/
rtems_bdbuf_anonymous_wait (&bdbuf_cache.buffer_waiters);
ffc0e644: 7e e3 bb 78 mr r3,r23
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)
ffc0e648: 2f 80 00 00 cmpwi cr7,r0,0
ffc0e64c: 41 be 00 34 beq+ cr7,ffc0e680 <rtems_bdbuf_get_buffer_for_access+0x100><== NEVER TAKEN
ffc0e650: 48 00 00 84 b ffc0e6d4 <rtems_bdbuf_get_buffer_for_access+0x154>
}
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);
ffc0e654: 7e 03 83 78 mr r3,r16
ffc0e658: 7e 44 93 78 mr r4,r18
ffc0e65c: 48 00 00 0c b ffc0e668 <rtems_bdbuf_get_buffer_for_access+0xe8>
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);
ffc0e660: 7e 03 83 78 mr r3,r16 <== NOT EXECUTED
ffc0e664: 7e 24 8b 78 mr r4,r17 <== NOT EXECUTED
ffc0e668: 4b ff ea bd bl ffc0d124 <rtems_bdbuf_wait>
ffc0e66c: 4b ff ff 94 b ffc0e600 <rtems_bdbuf_get_buffer_for_access+0x80>
break;
default:
rtems_bdbuf_fatal (bd->state, RTEMS_BLKDEV_FATAL_BDBUF_STATE_8);
ffc0e670: 3c 80 42 00 lis r4,16896 <== NOT EXECUTED
ffc0e674: 80 70 00 28 lwz r3,40(r16) <== NOT EXECUTED
ffc0e678: 60 84 00 06 ori r4,r4,6 <== NOT EXECUTED
ffc0e67c: 48 00 00 e0 b ffc0e75c <rtems_bdbuf_get_buffer_for_access+0x1dc><== NOT EXECUTED
{
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);
ffc0e680: 7e 03 83 78 mr r3,r16 <== NOT EXECUTED
ffc0e684: 4b ff f1 79 bl ffc0d7fc <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;
ffc0e688: 92 b0 00 28 stw r21,40(r16) <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Chain_Prepend(
Chain_Control *the_chain,
Chain_Node *the_node
)
{
_Chain_Insert(_Chain_Head(the_chain), the_node);
ffc0e68c: 7e c3 b3 78 mr r3,r22 <== NOT EXECUTED
ffc0e690: 7e 04 83 78 mr r4,r16 <== NOT EXECUTED
ffc0e694: 48 00 38 dd bl ffc11f70 <_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);
ffc0e698: 7f 83 e3 78 mr r3,r28 <== NOT EXECUTED
ffc0e69c: 4b ff eb b5 bl ffc0d250 <rtems_bdbuf_wake> <== NOT EXECUTED
ffc0e6a0: 4b ff ff 34 b ffc0e5d4 <rtems_bdbuf_get_buffer_for_access+0x54><== NOT EXECUTED
bd = NULL;
}
}
else
{
bd = rtems_bdbuf_get_buffer_from_lru_list (dev, block, bds_per_group);
ffc0e6a4: 7f c3 f3 78 mr r3,r30
ffc0e6a8: 7f e4 fb 78 mr r4,r31
ffc0e6ac: 7f 25 cb 78 mr r5,r25
ffc0e6b0: 7f 46 d3 78 mr r6,r26
ffc0e6b4: 4b ff fa f9 bl ffc0e1ac <rtems_bdbuf_get_buffer_from_lru_list>
if (bd == NULL)
ffc0e6b8: 7c 70 1b 79 mr. r16,r3
ffc0e6bc: 40 a2 00 20 bne+ ffc0e6dc <rtems_bdbuf_get_buffer_for_access+0x15c>
}
static void
rtems_bdbuf_wait_for_buffer (void)
{
if (!rtems_chain_is_empty (&bdbuf_cache.modified))
ffc0e6c0: 80 1d 00 50 lwz r0,80(r29)
ffc0e6c4: 7f 80 c0 00 cmpw cr7,r0,r24
ffc0e6c8: 41 9e 00 08 beq- cr7,ffc0e6d0 <rtems_bdbuf_get_buffer_for_access+0x150>
rtems_bdbuf_wake_swapper ();
ffc0e6cc: 4b ff e8 81 bl ffc0cf4c <rtems_bdbuf_wake_swapper>
rtems_bdbuf_anonymous_wait (&bdbuf_cache.buffer_waiters);
ffc0e6d0: 7f 83 e3 78 mr r3,r28
ffc0e6d4: 4b ff e9 cd bl ffc0d0a0 <rtems_bdbuf_anonymous_wait>
ffc0e6d8: 4b ff fe fc b ffc0e5d4 <rtems_bdbuf_get_buffer_for_access+0x54>
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);
ffc0e6dc: 3f a0 00 00 lis r29,0
ffc0e6e0: 3b bd 2a 08 addi r29,r29,10760
static void
rtems_bdbuf_wait_for_access (rtems_bdbuf_buffer *bd)
{
while (true)
{
switch (bd->state)
ffc0e6e4: 3f c0 ff c2 lis r30,-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);
ffc0e6e8: 3b 9d 00 70 addi r28,r29,112
static void
rtems_bdbuf_wait_for_access (rtems_bdbuf_buffer *bd)
{
while (true)
{
switch (bd->state)
ffc0e6ec: 3b de b0 80 addi r30,r30,-20352
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);
ffc0e6f0: 3b bd 00 68 addi r29,r29,104
static void
rtems_bdbuf_wait_for_access (rtems_bdbuf_buffer *bd)
{
while (true)
{
switch (bd->state)
ffc0e6f4: 81 30 00 28 lwz r9,40(r16)
ffc0e6f8: 38 09 ff ff addi r0,r9,-1
ffc0e6fc: 2b 80 00 09 cmplwi cr7,r0,9
ffc0e700: 41 9d 00 50 bgt- cr7,ffc0e750 <rtems_bdbuf_get_buffer_for_access+0x1d0><== NEVER TAKEN
ffc0e704: 54 00 10 3a rlwinm r0,r0,2,0,29
ffc0e708: 7c 1e 00 2e lwzx r0,r30,r0
ffc0e70c: 7c 00 f2 14 add r0,r0,r30
ffc0e710: 7c 09 03 a6 mtctr r0
ffc0e714: 4e 80 04 20 bctr
}
static void
rtems_bdbuf_group_release (rtems_bdbuf_buffer *bd)
{
--bd->group->users;
ffc0e718: 81 30 00 30 lwz r9,48(r16)
ffc0e71c: 81 69 00 0c lwz r11,12(r9)
ffc0e720: 38 0b ff ff addi r0,r11,-1
ffc0e724: 90 09 00 0c stw r0,12(r9)
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
ffc0e728: 7e 03 83 78 mr r3,r16
ffc0e72c: 4b ff b1 61 bl ffc0988c <_Chain_Extract>
ffc0e730: 48 00 00 30 b ffc0e760 <rtems_bdbuf_get_buffer_for_access+0x1e0>
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);
ffc0e734: 7e 03 83 78 mr r3,r16
ffc0e738: 7f a4 eb 78 mr r4,r29
ffc0e73c: 48 00 00 0c b ffc0e748 <rtems_bdbuf_get_buffer_for_access+0x1c8>
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);
ffc0e740: 7e 03 83 78 mr r3,r16
ffc0e744: 7f 84 e3 78 mr r4,r28
ffc0e748: 4b ff e9 dd bl ffc0d124 <rtems_bdbuf_wait>
ffc0e74c: 4b ff ff a8 b ffc0e6f4 <rtems_bdbuf_get_buffer_for_access+0x174>
break;
default:
rtems_bdbuf_fatal (bd->state, RTEMS_BLKDEV_FATAL_BDBUF_STATE_7);
ffc0e750: 3c 80 42 00 lis r4,16896 <== NOT EXECUTED
ffc0e754: 80 70 00 28 lwz r3,40(r16) <== NOT EXECUTED
ffc0e758: 60 84 00 05 ori r4,r4,5 <== NOT EXECUTED
ffc0e75c: 4b ff e5 75 bl ffc0ccd0 <rtems_bdbuf_fatal> <== NOT EXECUTED
}
static void
rtems_bdbuf_group_obtain (rtems_bdbuf_buffer *bd)
{
++bd->group->users;
ffc0e760: 81 30 00 30 lwz r9,48(r16)
rtems_bdbuf_wait_for_access (bd);
rtems_bdbuf_group_obtain (bd);
return bd;
}
ffc0e764: 7e 03 83 78 mr r3,r16
}
static void
rtems_bdbuf_group_obtain (rtems_bdbuf_buffer *bd)
{
++bd->group->users;
ffc0e768: 81 69 00 0c lwz r11,12(r9)
ffc0e76c: 38 0b 00 01 addi r0,r11,1
rtems_bdbuf_wait_for_access (bd);
rtems_bdbuf_group_obtain (bd);
return bd;
}
ffc0e770: 39 61 00 48 addi r11,r1,72
}
static void
rtems_bdbuf_group_obtain (rtems_bdbuf_buffer *bd)
{
++bd->group->users;
ffc0e774: 90 09 00 0c stw r0,12(r9)
rtems_bdbuf_wait_for_access (bd);
rtems_bdbuf_group_obtain (bd);
return bd;
}
ffc0e778: 48 00 ad 64 b ffc194dc <_restgpr_16_x>
ffc0e1ac <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)
{
ffc0e1ac: 94 21 ff 40 stwu r1,-192(r1)
ffc0e1b0: 7c 08 02 a6 mflr r0
ffc0e1b4: be 41 00 88 stmw r18,136(r1)
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
ffc0e1b8: 3f 40 00 00 lis r26,0
ffc0e1bc: 3b 5a 2a 08 addi r26,r26,10760
ffc0e1c0: 90 01 00 c4 stw r0,196(r1)
ffc0e1c4: 7c 7f 1b 78 mr r31,r3
ffc0e1c8: 7c 9e 23 78 mr r30,r4
ffc0e1cc: 7c bd 2b 78 mr r29,r5
ffc0e1d0: 83 7a 00 44 lwz r27,68(r26)
ffc0e1d4: 7c d7 33 78 mr r23,r6
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail(
Chain_Control *the_chain
)
{
return &the_chain->Tail.Node;
ffc0e1d8: 3a 5a 00 48 addi r18,r26,72
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;
ffc0e1dc: 3a 60 00 00 li r19,0
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Head(
Chain_Control *the_chain
)
{
return &the_chain->Head.Node;
ffc0e1e0: 3a 9a 00 44 addi r20,r26,68
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);
ffc0e1e4: 3a ba 00 78 addi r21,r26,120
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))
ffc0e1e8: 48 00 03 78 b ffc0e560 <rtems_bdbuf_get_buffer_from_lru_list+0x3b4>
bd->group->bds_per_group, bds_per_group);
/*
* If nobody waits for this BD, we may recycle it.
*/
if (bd->waiters == 0)
ffc0e1ec: 80 1b 00 2c lwz r0,44(r27)
ffc0e1f0: 2f 80 00 00 cmpwi cr7,r0,0
ffc0e1f4: 40 9e 03 68 bne- cr7,ffc0e55c <rtems_bdbuf_get_buffer_from_lru_list+0x3b0>
{
if (bd->group->bds_per_group == bds_per_group)
ffc0e1f8: 83 9b 00 30 lwz r28,48(r27)
ffc0e1fc: 80 1c 00 08 lwz r0,8(r28)
ffc0e200: 7f 80 b8 00 cmpw cr7,r0,r23
ffc0e204: 40 be 00 14 bne+ cr7,ffc0e218 <rtems_bdbuf_get_buffer_from_lru_list+0x6c>
{
rtems_bdbuf_remove_from_tree_and_lru_list (bd);
ffc0e208: 7f 63 db 78 mr r3,r27
ffc0e20c: 4b ff f5 f1 bl ffc0d7fc <rtems_bdbuf_remove_from_tree_and_lru_list>
ffc0e210: 7f 63 db 78 mr r3,r27
ffc0e214: 48 00 00 9c b ffc0e2b0 <rtems_bdbuf_get_buffer_from_lru_list+0x104>
empty_bd = bd;
}
else if (bd->group->users == 0)
ffc0e218: 81 3c 00 0c lwz r9,12(r28)
ffc0e21c: 2f 89 00 00 cmpwi cr7,r9,0
ffc0e220: 40 9e 03 3c bne- cr7,ffc0e55c <rtems_bdbuf_get_buffer_from_lru_list+0x3b0>
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;
ffc0e224: 82 da 00 20 lwz r22,32(r26)
for (b = 0, bd = group->bdbuf;
ffc0e228: 3b 20 00 00 li r25,0
ffc0e22c: 83 1c 00 10 lwz r24,16(r28)
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;
ffc0e230: 7e d6 03 96 divwu r22,r22,r0
for (b = 0, bd = group->bdbuf;
b < group->bds_per_group;
b++, bd += bufs_per_bd)
ffc0e234: 56 d6 30 32 rlwinm r22,r22,6,0,25
ffc0e238: 48 00 00 14 b ffc0e24c <rtems_bdbuf_get_buffer_from_lru_list+0xa0>
rtems_bdbuf_remove_from_tree_and_lru_list (bd);
ffc0e23c: 7f 03 c3 78 mr r3,r24
ffc0e240: 4b ff f5 bd bl ffc0d7fc <rtems_bdbuf_remove_from_tree_and_lru_list>
bufs_per_bd = bdbuf_cache.max_bds_per_group / group->bds_per_group;
for (b = 0, bd = group->bdbuf;
b < group->bds_per_group;
b++, bd += bufs_per_bd)
ffc0e244: 3b 39 00 01 addi r25,r25,1
ffc0e248: 7f 18 b2 14 add r24,r24,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;
ffc0e24c: 80 1c 00 08 lwz r0,8(r28)
ffc0e250: 7f 99 00 40 cmplw cr7,r25,r0
ffc0e254: 41 9c ff e8 blt+ cr7,ffc0e23c <rtems_bdbuf_get_buffer_from_lru_list+0x90>
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;
ffc0e258: 82 da 00 20 lwz r22,32(r26)
for (b = 1, bd = group->bdbuf + bufs_per_bd;
ffc0e25c: 3b 20 00 01 li r25,1
ffc0e260: 83 1c 00 10 lwz r24,16(r28)
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;
ffc0e264: 7e d6 bb 96 divwu r22,r22,r23
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;
ffc0e268: 92 fc 00 08 stw r23,8(r28)
bufs_per_bd = bdbuf_cache.max_bds_per_group / new_bds_per_group;
for (b = 1, bd = group->bdbuf + bufs_per_bd;
ffc0e26c: 56 d6 30 32 rlwinm r22,r22,6,0,25
ffc0e270: 7f 18 b2 14 add r24,r24,r22
ffc0e274: 48 00 00 1c b ffc0e290 <rtems_bdbuf_get_buffer_from_lru_list+0xe4>
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
ffc0e278: 92 78 00 28 stw r19,40(r24)
RTEMS_INLINE_ROUTINE void _Chain_Prepend(
Chain_Control *the_chain,
Chain_Node *the_node
)
{
_Chain_Insert(_Chain_Head(the_chain), the_node);
ffc0e27c: 7f 04 c3 78 mr r4,r24
ffc0e280: 7e 83 a3 78 mr r3,r20
ffc0e284: 48 00 3c ed bl ffc11f70 <_Chain_Insert>
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;
b < group->bds_per_group;
b++, bd += bufs_per_bd)
ffc0e288: 3b 39 00 01 addi r25,r25,1
ffc0e28c: 7f 18 b2 14 add r24,r24,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;
ffc0e290: 80 1c 00 08 lwz r0,8(r28)
ffc0e294: 7f 99 00 40 cmplw cr7,r25,r0
ffc0e298: 41 9c ff e0 blt+ cr7,ffc0e278 <rtems_bdbuf_get_buffer_from_lru_list+0xcc>
b < group->bds_per_group;
b++, bd += bufs_per_bd)
rtems_bdbuf_make_free_and_add_to_lru_list (bd);
if (b > 1)
ffc0e29c: 2b 99 00 01 cmplwi cr7,r25,1
ffc0e2a0: 40 9d 00 0c ble- cr7,ffc0e2ac <rtems_bdbuf_get_buffer_from_lru_list+0x100>
rtems_bdbuf_wake (&bdbuf_cache.buffer_waiters);
ffc0e2a4: 7e a3 ab 78 mr r3,r21
ffc0e2a8: 4b ff ef a9 bl ffc0d250 <rtems_bdbuf_wake>
return group->bdbuf;
ffc0e2ac: 80 7c 00 10 lwz r3,16(r28)
}
else if (bd->group->users == 0)
empty_bd = rtems_bdbuf_group_realloc (bd->group, bds_per_group);
}
if (empty_bd != NULL)
ffc0e2b0: 2f 83 00 00 cmpwi cr7,r3,0
ffc0e2b4: 41 be 02 a8 beq+ cr7,ffc0e55c <rtems_bdbuf_get_buffer_from_lru_list+0x3b0><== NEVER TAKEN
dev_t dev,
rtems_blkdev_bnum block)
{
bd->dev = dev;
bd->block = block;
bd->avl.left = NULL;
ffc0e2b8: 38 00 00 00 li r0,0
static void
rtems_bdbuf_setup_empty_buffer (rtems_bdbuf_buffer *bd,
dev_t dev,
rtems_blkdev_bnum block)
{
bd->dev = dev;
ffc0e2bc: 93 e3 00 18 stw r31,24(r3)
rtems_bdbuf_buffer* node)
{
dev_t dev = node->dev;
rtems_blkdev_bnum block = node->block;
rtems_bdbuf_buffer* p = *root;
ffc0e2c0: 3d 60 00 00 lis r11,0
dev_t dev,
rtems_blkdev_bnum block)
{
bd->dev = dev;
bd->block = block;
bd->avl.left = NULL;
ffc0e2c4: 90 03 00 08 stw r0,8(r3)
rtems_bdbuf_buffer* node)
{
dev_t dev = node->dev;
rtems_blkdev_bnum block = node->block;
rtems_bdbuf_buffer* p = *root;
ffc0e2c8: 39 6b 2a 08 addi r11,r11,10760
rtems_bdbuf_buffer* buf_stack[RTEMS_BDBUF_AVL_MAX_HEIGHT];
rtems_bdbuf_buffer** buf_prev = buf_stack;
bool modified = false;
if (p == NULL)
ffc0e2cc: 38 c1 00 08 addi r6,r1,8
rtems_blkdev_bnum block)
{
bd->dev = dev;
bd->block = block;
bd->avl.left = NULL;
bd->avl.right = NULL;
ffc0e2d0: 90 03 00 0c stw r0,12(r3)
{
*buf_prev++ = p;
if ((p->dev < dev) || ((p->dev == dev) && (p->block < block)))
{
p->avl.cache = 1;
ffc0e2d4: 39 00 00 01 li r8,1
break;
}
}
else if ((p->dev != dev) || (p->block != block))
{
p->avl.cache = -1;
ffc0e2d8: 39 40 ff ff li r10,-1
rtems_bdbuf_buffer* node)
{
dev_t dev = node->dev;
rtems_blkdev_bnum block = node->block;
rtems_bdbuf_buffer* p = *root;
ffc0e2dc: 81 2b 00 40 lwz r9,64(r11)
static void
rtems_bdbuf_setup_empty_buffer (rtems_bdbuf_buffer *bd,
dev_t dev,
rtems_blkdev_bnum block)
{
bd->dev = dev;
ffc0e2e0: 93 c3 00 1c stw r30,28(r3)
rtems_bdbuf_buffer* buf_stack[RTEMS_BDBUF_AVL_MAX_HEIGHT];
rtems_bdbuf_buffer** buf_prev = buf_stack;
bool modified = false;
if (p == NULL)
ffc0e2e4: 2f 89 00 00 cmpwi cr7,r9,0
rtems_bdbuf_setup_empty_buffer (rtems_bdbuf_buffer *bd,
dev_t dev,
rtems_blkdev_bnum block)
{
bd->dev = dev;
bd->block = block;
ffc0e2e8: 93 a3 00 20 stw r29,32(r3)
bd->avl.left = NULL;
bd->avl.right = NULL;
bd->waiters = 0;
ffc0e2ec: 90 03 00 2c stw r0,44(r3)
rtems_bdbuf_buffer* buf_stack[RTEMS_BDBUF_AVL_MAX_HEIGHT];
rtems_bdbuf_buffer** buf_prev = buf_stack;
bool modified = false;
if (p == NULL)
ffc0e2f0: 40 be 00 74 bne+ cr7,ffc0e364 <rtems_bdbuf_get_buffer_from_lru_list+0x1b8>
{
*root = node;
ffc0e2f4: 90 6b 00 40 stw r3,64(r11)
node->avl.left = NULL;
ffc0e2f8: 91 23 00 08 stw r9,8(r3)
node->avl.right = NULL;
ffc0e2fc: 91 23 00 0c stw r9,12(r3)
node->avl.bal = 0;
ffc0e300: 99 23 00 11 stb r9,17(r3)
ffc0e304: 48 00 02 4c b ffc0e550 <rtems_bdbuf_get_buffer_from_lru_list+0x3a4>
while (p != NULL)
{
*buf_prev++ = p;
if ((p->dev < dev) || ((p->dev == dev) && (p->block < block)))
ffc0e308: 7f 80 f8 00 cmpw cr7,r0,r31
ffc0e30c: 40 be 00 38 bne+ cr7,ffc0e344 <rtems_bdbuf_get_buffer_from_lru_list+0x198><== NEVER TAKEN
ffc0e310: 7f 8b f0 00 cmpw cr7,r11,r30
ffc0e314: 40 be 00 30 bne+ cr7,ffc0e344 <rtems_bdbuf_get_buffer_from_lru_list+0x198><== NEVER TAKEN
ffc0e318: 80 09 00 20 lwz r0,32(r9)
ffc0e31c: 7f 80 e8 40 cmplw cr7,r0,r29
ffc0e320: 40 9c 00 1c bge- cr7,ffc0e33c <rtems_bdbuf_get_buffer_from_lru_list+0x190>
{
p->avl.cache = 1;
q = p->avl.right;
ffc0e324: 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;
ffc0e328: 99 09 00 10 stb r8,16(r9)
q = p->avl.right;
if (q == NULL)
ffc0e32c: 2f 80 00 00 cmpwi cr7,r0,0
ffc0e330: 40 be 00 2c bne+ cr7,ffc0e35c <rtems_bdbuf_get_buffer_from_lru_list+0x1b0>
{
q = node;
p->avl.right = q = node;
ffc0e334: 90 69 00 0c stw r3,12(r9)
ffc0e338: 48 00 00 58 b ffc0e390 <rtems_bdbuf_get_buffer_from_lru_list+0x1e4>
break;
}
}
else if ((p->dev != dev) || (p->block != block))
ffc0e33c: 7f 80 e8 00 cmpw cr7,r0,r29
ffc0e340: 41 9e 02 34 beq- cr7,ffc0e574 <rtems_bdbuf_get_buffer_from_lru_list+0x3c8><== NEVER TAKEN
{
p->avl.cache = -1;
q = p->avl.left;
ffc0e344: 80 09 00 08 lwz r0,8(r9)
break;
}
}
else if ((p->dev != dev) || (p->block != block))
{
p->avl.cache = -1;
ffc0e348: 99 49 00 10 stb r10,16(r9)
q = p->avl.left;
if (q == NULL)
ffc0e34c: 2f 80 00 00 cmpwi cr7,r0,0
ffc0e350: 40 be 00 0c bne+ cr7,ffc0e35c <rtems_bdbuf_get_buffer_from_lru_list+0x1b0>
{
q = node;
p->avl.left = q;
ffc0e354: 90 69 00 08 stw r3,8(r9)
ffc0e358: 48 00 00 38 b ffc0e390 <rtems_bdbuf_get_buffer_from_lru_list+0x1e4>
rtems_bdbuf_buffer* buf_stack[RTEMS_BDBUF_AVL_MAX_HEIGHT];
rtems_bdbuf_buffer** buf_prev = buf_stack;
bool modified = false;
if (p == NULL)
ffc0e35c: 7c e6 3b 78 mr r6,r7
ffc0e360: 7c 09 03 78 mr r9,r0
while (p != NULL)
{
*buf_prev++ = p;
if ((p->dev < dev) || ((p->dev == dev) && (p->block < block)))
ffc0e364: 80 09 00 18 lwz r0,24(r9)
return 0;
}
while (p != NULL)
{
*buf_prev++ = p;
ffc0e368: 38 e6 00 04 addi r7,r6,4
ffc0e36c: 91 26 00 00 stw r9,0(r6)
if ((p->dev < dev) || ((p->dev == dev) && (p->block < block)))
ffc0e370: 7f 9f 00 40 cmplw cr7,r31,r0
ffc0e374: 81 69 00 1c lwz r11,28(r9)
ffc0e378: 41 bd ff ac bgt- cr7,ffc0e324 <rtems_bdbuf_get_buffer_from_lru_list+0x178><== NEVER TAKEN
ffc0e37c: 7f 9f 00 00 cmpw cr7,r31,r0
ffc0e380: 40 be ff 88 bne- cr7,ffc0e308 <rtems_bdbuf_get_buffer_from_lru_list+0x15c><== NEVER TAKEN
ffc0e384: 7f 9e 58 40 cmplw cr7,r30,r11
ffc0e388: 41 bd ff 9c bgt- cr7,ffc0e324 <rtems_bdbuf_get_buffer_from_lru_list+0x178><== NEVER TAKEN
ffc0e38c: 4b ff ff 7c b ffc0e308 <rtems_bdbuf_get_buffer_from_lru_list+0x15c>
}
p = q;
}
q->avl.left = q->avl.right = NULL;
ffc0e390: 38 00 00 00 li r0,0
ffc0e394: 90 03 00 0c stw r0,12(r3)
p->avl.bal = 0;
modified = false;
break;
case 0:
p->avl.bal = 1;
ffc0e398: 38 a0 00 01 li r5,1
default:
break;
}
}
q = p;
if (buf_prev > buf_stack)
ffc0e39c: 38 81 00 08 addi r4,r1,8
}
p = q;
}
q->avl.left = q->avl.right = NULL;
ffc0e3a0: 90 03 00 08 stw r0,8(r3)
q->avl.bal = 0;
ffc0e3a4: 98 03 00 11 stb r0,17(r3)
ffc0e3a8: 48 00 00 08 b ffc0e3b0 <rtems_bdbuf_get_buffer_from_lru_list+0x204>
modified = true;
buf_prev--;
while (modified)
ffc0e3ac: 7d 49 53 78 mr r9,r10
{
if (p->avl.cache == -1)
ffc0e3b0: 89 69 00 10 lbz r11,16(r9)
ffc0e3b4: 89 09 00 11 lbz r8,17(r9)
ffc0e3b8: 7d 6a 07 74 extsb r10,r11
ffc0e3bc: 2f 8a ff ff cmpwi cr7,r10,-1
ffc0e3c0: 40 be 00 a0 bne+ cr7,ffc0e460 <rtems_bdbuf_get_buffer_from_lru_list+0x2b4>
{
switch (p->avl.bal)
ffc0e3c4: 7d 0a 07 75 extsb. r10,r8
ffc0e3c8: 41 82 00 18 beq- ffc0e3e0 <rtems_bdbuf_get_buffer_from_lru_list+0x234>
ffc0e3cc: 2f 8a 00 01 cmpwi cr7,r10,1
ffc0e3d0: 41 9e 00 a8 beq- cr7,ffc0e478 <rtems_bdbuf_get_buffer_from_lru_list+0x2cc>
ffc0e3d4: 2f 8a ff ff cmpwi cr7,r10,-1
ffc0e3d8: 40 be 01 34 bne+ cr7,ffc0e50c <rtems_bdbuf_get_buffer_from_lru_list+0x360><== NEVER TAKEN
ffc0e3dc: 48 00 00 0c b ffc0e3e8 <rtems_bdbuf_get_buffer_from_lru_list+0x23c>
p->avl.bal = 0;
modified = false;
break;
case 0:
p->avl.bal = -1;
ffc0e3e0: 99 69 00 11 stb r11,17(r9)
ffc0e3e4: 48 00 01 28 b ffc0e50c <rtems_bdbuf_get_buffer_from_lru_list+0x360>
break;
case -1:
p1 = p->avl.left;
ffc0e3e8: 81 49 00 08 lwz r10,8(r9)
if (p1->avl.bal == -1) /* simple LL-turn */
ffc0e3ec: 89 6a 00 11 lbz r11,17(r10)
ffc0e3f0: 2f 8b 00 ff cmpwi cr7,r11,255
ffc0e3f4: 81 6a 00 0c lwz r11,12(r10)
ffc0e3f8: 40 be 00 18 bne+ cr7,ffc0e410 <rtems_bdbuf_get_buffer_from_lru_list+0x264><== ALWAYS TAKEN
{
p->avl.left = p1->avl.right;
ffc0e3fc: 91 69 00 08 stw r11,8(r9) <== NOT EXECUTED
p1->avl.right = p;
p->avl.bal = 0;
ffc0e400: 7d 4b 53 78 mr r11,r10 <== NOT EXECUTED
case -1:
p1 = p->avl.left;
if (p1->avl.bal == -1) /* simple LL-turn */
{
p->avl.left = p1->avl.right;
p1->avl.right = p;
ffc0e404: 91 2a 00 0c stw r9,12(r10) <== NOT EXECUTED
p->avl.bal = 0;
ffc0e408: 98 09 00 11 stb r0,17(r9) <== NOT EXECUTED
ffc0e40c: 48 00 00 48 b ffc0e454 <rtems_bdbuf_get_buffer_from_lru_list+0x2a8><== NOT EXECUTED
p = p1;
}
else /* double LR-turn */
{
p2 = p1->avl.right;
p1->avl.right = p2->avl.left;
ffc0e410: 80 eb 00 08 lwz r7,8(r11)
p2->avl.left = p1;
ffc0e414: 91 4b 00 08 stw r10,8(r11)
p = p1;
}
else /* double LR-turn */
{
p2 = p1->avl.right;
p1->avl.right = p2->avl.left;
ffc0e418: 90 ea 00 0c stw r7,12(r10)
p2->avl.left = p1;
p->avl.left = p2->avl.right;
ffc0e41c: 80 eb 00 0c lwz r7,12(r11)
p2->avl.right = p;
ffc0e420: 91 2b 00 0c stw r9,12(r11)
else /* double LR-turn */
{
p2 = p1->avl.right;
p1->avl.right = p2->avl.left;
p2->avl.left = p1;
p->avl.left = p2->avl.right;
ffc0e424: 90 e9 00 08 stw r7,8(r9)
p2->avl.right = p;
if (p2->avl.bal == -1) p->avl.bal = +1; else p->avl.bal = 0;
ffc0e428: 88 eb 00 11 lbz r7,17(r11)
ffc0e42c: 68 e7 00 ff xori r7,r7,255
ffc0e430: 7c e7 00 34 cntlzw r7,r7
ffc0e434: 54 e7 d9 7e rlwinm r7,r7,27,5,31
ffc0e438: 98 e9 00 11 stb r7,17(r9)
if (p2->avl.bal == +1) p1->avl.bal = -1; else p1->avl.bal = 0;
ffc0e43c: 89 2b 00 11 lbz r9,17(r11)
ffc0e440: 2f 89 00 01 cmpwi cr7,r9,1
ffc0e444: 40 be 00 0c bne+ cr7,ffc0e450 <rtems_bdbuf_get_buffer_from_lru_list+0x2a4><== ALWAYS TAKEN
ffc0e448: 99 0a 00 11 stb r8,17(r10) <== NOT EXECUTED
ffc0e44c: 48 00 00 08 b ffc0e454 <rtems_bdbuf_get_buffer_from_lru_list+0x2a8><== NOT EXECUTED
ffc0e450: 98 0a 00 11 stb r0,17(r10)
p = p2;
}
p->avl.bal = 0;
ffc0e454: 98 0b 00 11 stb r0,17(r11)
ffc0e458: 7d 69 5b 78 mr r9,r11
ffc0e45c: 48 00 00 a8 b ffc0e504 <rtems_bdbuf_get_buffer_from_lru_list+0x358>
break;
}
}
else
{
switch (p->avl.bal)
ffc0e460: 7d 08 07 75 extsb. r8,r8
ffc0e464: 41 82 00 1c beq- ffc0e480 <rtems_bdbuf_get_buffer_from_lru_list+0x2d4>
ffc0e468: 2f 88 00 01 cmpwi cr7,r8,1
ffc0e46c: 41 9e 00 1c beq- cr7,ffc0e488 <rtems_bdbuf_get_buffer_from_lru_list+0x2dc>
ffc0e470: 2f 88 ff ff cmpwi cr7,r8,-1
ffc0e474: 40 be 00 98 bne+ cr7,ffc0e50c <rtems_bdbuf_get_buffer_from_lru_list+0x360><== NEVER TAKEN
{
case -1:
p->avl.bal = 0;
ffc0e478: 98 09 00 11 stb r0,17(r9)
ffc0e47c: 48 00 00 88 b ffc0e504 <rtems_bdbuf_get_buffer_from_lru_list+0x358>
modified = false;
break;
case 0:
p->avl.bal = 1;
ffc0e480: 98 a9 00 11 stb r5,17(r9)
ffc0e484: 48 00 00 88 b ffc0e50c <rtems_bdbuf_get_buffer_from_lru_list+0x360>
break;
case 1:
p1 = p->avl.right;
ffc0e488: 81 69 00 0c lwz r11,12(r9)
if (p1->avl.bal == 1) /* simple RR-turn */
ffc0e48c: 89 4b 00 11 lbz r10,17(r11)
ffc0e490: 2f 8a 00 01 cmpwi cr7,r10,1
ffc0e494: 81 4b 00 08 lwz r10,8(r11)
ffc0e498: 40 be 00 18 bne+ cr7,ffc0e4b0 <rtems_bdbuf_get_buffer_from_lru_list+0x304>
{
p->avl.right = p1->avl.left;
ffc0e49c: 91 49 00 0c stw r10,12(r9)
p1->avl.left = p;
p->avl.bal = 0;
ffc0e4a0: 7d 68 5b 78 mr r8,r11
case 1:
p1 = p->avl.right;
if (p1->avl.bal == 1) /* simple RR-turn */
{
p->avl.right = p1->avl.left;
p1->avl.left = p;
ffc0e4a4: 91 2b 00 08 stw r9,8(r11)
p->avl.bal = 0;
ffc0e4a8: 98 09 00 11 stb r0,17(r9)
ffc0e4ac: 48 00 00 50 b ffc0e4fc <rtems_bdbuf_get_buffer_from_lru_list+0x350>
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;
ffc0e4b0: 8b ea 00 11 lbz r31,17(r10)
p->avl.bal = 0;
p = p1;
}
else /* double RL-turn */
{
p2 = p1->avl.left;
ffc0e4b4: 7d 48 53 78 mr r8,r10
p1->avl.left = p2->avl.right;
ffc0e4b8: 80 ea 00 0c lwz r7,12(r10)
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;
ffc0e4bc: 2f 9f 00 01 cmpwi cr7,r31,1
}
else /* double RL-turn */
{
p2 = p1->avl.left;
p1->avl.left = p2->avl.right;
p2->avl.right = p1;
ffc0e4c0: 91 6a 00 0c stw r11,12(r10)
p = p1;
}
else /* double RL-turn */
{
p2 = p1->avl.left;
p1->avl.left = p2->avl.right;
ffc0e4c4: 90 eb 00 08 stw r7,8(r11)
p2->avl.right = p1;
p->avl.right = p2->avl.left;
ffc0e4c8: 80 ea 00 08 lwz r7,8(r10)
p2->avl.left = p;
ffc0e4cc: 91 2a 00 08 stw r9,8(r10)
else /* double RL-turn */
{
p2 = p1->avl.left;
p1->avl.left = p2->avl.right;
p2->avl.right = p1;
p->avl.right = p2->avl.left;
ffc0e4d0: 90 e9 00 0c stw r7,12(r9)
p2->avl.left = p;
if (p2->avl.bal == +1) p->avl.bal = -1; else p->avl.bal = 0;
ffc0e4d4: 38 e0 00 00 li r7,0
ffc0e4d8: 40 be 00 08 bne+ cr7,ffc0e4e0 <rtems_bdbuf_get_buffer_from_lru_list+0x334><== ALWAYS TAKEN
ffc0e4dc: 38 e0 ff ff li r7,-1 <== NOT EXECUTED
ffc0e4e0: 98 e9 00 11 stb r7,17(r9)
if (p2->avl.bal == -1) p1->avl.bal = +1; else p1->avl.bal = 0;
ffc0e4e4: 89 2a 00 11 lbz r9,17(r10)
ffc0e4e8: 2f 89 00 ff cmpwi cr7,r9,255
ffc0e4ec: 40 be 00 0c bne+ cr7,ffc0e4f8 <rtems_bdbuf_get_buffer_from_lru_list+0x34c><== ALWAYS TAKEN
ffc0e4f0: 98 ab 00 11 stb r5,17(r11) <== NOT EXECUTED
ffc0e4f4: 48 00 00 08 b ffc0e4fc <rtems_bdbuf_get_buffer_from_lru_list+0x350><== NOT EXECUTED
ffc0e4f8: 98 0b 00 11 stb r0,17(r11)
p = p2;
}
p->avl.bal = 0;
ffc0e4fc: 98 08 00 11 stb r0,17(r8)
ffc0e500: 7d 09 43 78 mr r9,r8
modified = false;
ffc0e504: 39 60 00 00 li r11,0
ffc0e508: 48 00 00 08 b ffc0e510 <rtems_bdbuf_get_buffer_from_lru_list+0x364>
break;
}
}
else
{
switch (p->avl.bal)
ffc0e50c: 39 60 00 01 li r11,1
default:
break;
}
}
q = p;
if (buf_prev > buf_stack)
ffc0e510: 7f 86 20 40 cmplw cr7,r6,r4
ffc0e514: 40 9d 00 24 ble- cr7,ffc0e538 <rtems_bdbuf_get_buffer_from_lru_list+0x38c>
{
p = *--buf_prev;
ffc0e518: 81 46 ff fc lwz r10,-4(r6)
if (p->avl.cache == -1)
ffc0e51c: 89 0a 00 10 lbz r8,16(r10)
ffc0e520: 2f 88 00 ff cmpwi cr7,r8,255
ffc0e524: 40 be 00 0c bne+ cr7,ffc0e530 <rtems_bdbuf_get_buffer_from_lru_list+0x384>
{
p->avl.left = q;
ffc0e528: 91 2a 00 08 stw r9,8(r10)
ffc0e52c: 48 00 00 18 b ffc0e544 <rtems_bdbuf_get_buffer_from_lru_list+0x398>
}
else
{
p->avl.right = q;
ffc0e530: 91 2a 00 0c stw r9,12(r10)
ffc0e534: 48 00 00 10 b ffc0e544 <rtems_bdbuf_get_buffer_from_lru_list+0x398>
}
}
else
{
*root = p;
ffc0e538: 3d 60 00 00 lis r11,0
ffc0e53c: 91 2b 2a 48 stw r9,10824(r11)
ffc0e540: 48 00 00 10 b ffc0e550 <rtems_bdbuf_get_buffer_from_lru_list+0x3a4>
q->avl.left = q->avl.right = NULL;
q->avl.bal = 0;
modified = true;
buf_prev--;
while (modified)
ffc0e544: 2f 8b 00 00 cmpwi cr7,r11,0
p->avl.right = q;
}
}
else
{
*root = p;
ffc0e548: 38 c6 ff fc addi r6,r6,-4
q->avl.left = q->avl.right = NULL;
q->avl.bal = 0;
modified = true;
buf_prev--;
while (modified)
ffc0e54c: 40 9e fe 60 bne+ cr7,ffc0e3ac <rtems_bdbuf_get_buffer_from_lru_list+0x200>
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
ffc0e550: 38 00 00 01 li r0,1
ffc0e554: 90 03 00 28 stw r0,40(r3)
if (empty_bd != NULL)
{
rtems_bdbuf_setup_empty_buffer (empty_bd, dev, block);
return empty_bd;
ffc0e558: 48 00 00 14 b ffc0e56c <rtems_bdbuf_get_buffer_from_lru_list+0x3c0>
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);
}
ffc0e55c: 83 7b 00 00 lwz r27,0(r27)
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))
ffc0e560: 7f 9b 90 00 cmpw cr7,r27,r18
ffc0e564: 40 9e fc 88 bne+ cr7,ffc0e1ec <rtems_bdbuf_get_buffer_from_lru_list+0x40>
}
node = rtems_chain_next (node);
}
return NULL;
ffc0e568: 38 60 00 00 li r3,0
}
ffc0e56c: 39 61 00 c0 addi r11,r1,192
ffc0e570: 48 00 af 74 b ffc194e4 <_restgpr_18_x>
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);
ffc0e574: 3c 60 42 00 lis r3,16896 <== NOT EXECUTED
ffc0e578: 60 63 00 1b ori r3,r3,27 <== NOT EXECUTED
ffc0e57c: 4b ff ad 29 bl ffc092a4 <rtems_fatal_error_occurred> <== NOT EXECUTED
ffc0e77c <rtems_bdbuf_init>:
*
* @return rtems_status_code The initialisation status.
*/
rtems_status_code
rtems_bdbuf_init (void)
{
ffc0e77c: 94 21 ff d0 stwu r1,-48(r1)
ffc0e780: 7c 08 02 a6 mflr r0
rtems_mode prev_mode;
if (rtems_bdbuf_tracer)
printf ("bdbuf:init\n");
if (rtems_interrupt_is_in_progress())
ffc0e784: 3d 20 00 00 lis r9,0
*
* @return rtems_status_code The initialisation status.
*/
rtems_status_code
rtems_bdbuf_init (void)
{
ffc0e788: 90 01 00 34 stw r0,52(r1)
if (rtems_bdbuf_tracer)
printf ("bdbuf:init\n");
if (rtems_interrupt_is_in_progress())
return RTEMS_CALLED_FROM_ISR;
ffc0e78c: 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())
ffc0e790: 80 09 31 ec lwz r0,12780(r9)
*
* @return rtems_status_code The initialisation status.
*/
rtems_status_code
rtems_bdbuf_init (void)
{
ffc0e794: be e1 00 0c stmw r23,12(r1)
rtems_mode prev_mode;
if (rtems_bdbuf_tracer)
printf ("bdbuf:init\n");
if (rtems_interrupt_is_in_progress())
ffc0e798: 2f 80 00 00 cmpwi cr7,r0,0
ffc0e79c: 40 be 03 88 bne+ cr7,ffc0eb24 <rtems_bdbuf_init+0x3a8> <== NEVER TAKEN
return RTEMS_CALLED_FROM_ISR;
/*
* Check the configuration table values.
*/
if ((bdbuf_config.buffer_max % bdbuf_config.buffer_min) != 0)
ffc0e7a0: 3f 80 ff c2 lis r28,-62
ffc0e7a4: 3b 9c a2 d4 addi r28,r28,-23852
ffc0e7a8: 80 1c 00 24 lwz r0,36(r28)
return RTEMS_INVALID_NUMBER;
ffc0e7ac: 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)
ffc0e7b0: 83 dc 00 20 lwz r30,32(r28)
ffc0e7b4: 7f a0 f3 96 divwu r29,r0,r30
ffc0e7b8: 7d 3d f1 d6 mullw r9,r29,r30
ffc0e7bc: 7f 80 48 00 cmpw cr7,r0,r9
ffc0e7c0: 40 be 03 64 bne+ cr7,ffc0eb24 <rtems_bdbuf_init+0x3a8> <== 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)
ffc0e7c4: 3f e0 00 00 lis r31,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 ();
ffc0e7c8: 4b ff e8 49 bl ffc0d010 <rtems_bdbuf_disable_preemption>
if (bdbuf_cache.initialised)
ffc0e7cc: 3b ff 2a 08 addi r31,r31,10760
ffc0e7d0: 8b 7f 00 88 lbz r27,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 ();
ffc0e7d4: 7c 7a 1b 78 mr r26,r3
if (bdbuf_cache.initialised)
ffc0e7d8: 2f 9b 00 00 cmpwi cr7,r27,0
ffc0e7dc: 41 9e 00 10 beq- cr7,ffc0e7ec <rtems_bdbuf_init+0x70> <== ALWAYS TAKEN
{
rtems_bdbuf_restore_preemption (prev_mode);
ffc0e7e0: 4b ff e8 7d bl ffc0d05c <rtems_bdbuf_restore_preemption><== NOT EXECUTED
return RTEMS_RESOURCE_IN_USE;
ffc0e7e4: 38 60 00 0c li r3,12 <== NOT EXECUTED
ffc0e7e8: 48 00 03 3c b ffc0eb24 <rtems_bdbuf_init+0x3a8> <== NOT EXECUTED
}
memset(&bdbuf_cache, 0, sizeof(bdbuf_cache));
ffc0e7ec: 38 80 00 00 li r4,0
ffc0e7f0: 38 a0 00 90 li r5,144
ffc0e7f4: 7f e3 fb 78 mr r3,r31
ffc0e7f8: 48 00 6b 55 bl ffc1534c <memset>
bdbuf_cache.initialised = true;
ffc0e7fc: 38 00 00 01 li r0,1
ffc0e800: 98 1f 00 88 stb r0,136(r31)
rtems_bdbuf_restore_preemption (prev_mode);
ffc0e804: 7f 43 d3 78 mr r3,r26
ffc0e808: 4b ff e8 55 bl ffc0d05c <rtems_bdbuf_restore_preemption>
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
ffc0e80c: 38 1f 00 0c addi r0,r31,12
ffc0e810: 90 1f 00 08 stw r0,8(r31)
head->previous = NULL;
tail->previous = head;
ffc0e814: 38 1f 00 08 addi r0,r31,8
*/
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;
ffc0e818: 39 40 ff ff li r10,-1
ffc0e81c: 90 1f 00 10 stw r0,16(r31)
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
ffc0e820: 38 1f 00 48 addi r0,r31,72
ffc0e824: 39 60 ff ff li r11,-1
ffc0e828: 90 1f 00 44 stw r0,68(r31)
head->previous = NULL;
tail->previous = head;
ffc0e82c: 38 1f 00 44 addi r0,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'),
ffc0e830: 3c 60 42 44 lis r3,16964
ffc0e834: 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;
ffc0e838: 38 1f 00 54 addi r0,r31,84
ffc0e83c: 60 63 43 6c ori r3,r3,17260
ffc0e840: 90 1f 00 50 stw r0,80(r31)
head->previous = NULL;
tail->previous = head;
ffc0e844: 38 1f 00 50 addi r0,r31,80
ffc0e848: 38 80 00 01 li r4,1
ffc0e84c: 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;
ffc0e850: 38 1f 00 60 addi r0,r31,96
ffc0e854: 38 a0 00 54 li r5,84
ffc0e858: 90 1f 00 5c stw r0,92(r31)
head->previous = NULL;
tail->previous = head;
ffc0e85c: 38 1f 00 5c addi r0,r31,92
ffc0e860: 38 c0 00 00 li r6,0
*/
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;
ffc0e864: 91 5f 00 38 stw r10,56(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'),
ffc0e868: 38 ff 00 28 addi r7,r31,40
*/
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;
ffc0e86c: 91 7f 00 3c stw r11,60(r31)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
head->previous = NULL;
ffc0e870: 93 7f 00 0c stw r27,12(r31)
ffc0e874: 93 7f 00 48 stw r27,72(r31)
ffc0e878: 93 7f 00 54 stw r27,84(r31)
ffc0e87c: 93 7f 00 60 stw r27,96(r31)
tail->previous = head;
ffc0e880: 90 1f 00 64 stw r0,100(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'),
ffc0e884: 4b ff a0 21 bl ffc088a4 <rtems_semaphore_create>
1, RTEMS_BDBUF_CACHE_LOCK_ATTRIBS, 0,
&bdbuf_cache.lock);
if (sc != RTEMS_SUCCESSFUL)
ffc0e888: 2f 83 00 00 cmpwi cr7,r3,0
ffc0e88c: 40 be 02 1c bne+ cr7,ffc0eaa8 <rtems_bdbuf_init+0x32c> <== NEVER TAKEN
goto error;
rtems_bdbuf_lock_cache ();
ffc0e890: 4b ff e3 b9 bl ffc0cc48 <rtems_bdbuf_lock_cache>
sc = rtems_semaphore_create (rtems_build_name ('B', 'D', 'C', 's'),
ffc0e894: 3c 60 42 44 lis r3,16964
ffc0e898: 60 63 43 73 ori r3,r3,17267
ffc0e89c: 38 80 00 01 li r4,1
ffc0e8a0: 38 a0 00 54 li r5,84
ffc0e8a4: 38 c0 00 00 li r6,0
ffc0e8a8: 38 ff 00 2c addi r7,r31,44
ffc0e8ac: 4b ff 9f f9 bl ffc088a4 <rtems_semaphore_create>
1, RTEMS_BDBUF_CACHE_LOCK_ATTRIBS, 0,
&bdbuf_cache.sync_lock);
if (sc != RTEMS_SUCCESSFUL)
ffc0e8b0: 2f 83 00 00 cmpwi cr7,r3,0
ffc0e8b4: 40 be 01 f4 bne+ cr7,ffc0eaa8 <rtems_bdbuf_init+0x32c> <== NEVER TAKEN
goto error;
sc = rtems_semaphore_create (rtems_build_name ('B', 'D', 'C', 'a'),
ffc0e8b8: 3c 60 42 44 lis r3,16964
ffc0e8bc: 60 63 43 61 ori r3,r3,17249
ffc0e8c0: 38 80 00 00 li r4,0
ffc0e8c4: 38 a0 00 24 li r5,36
ffc0e8c8: 38 c0 00 00 li r6,0
ffc0e8cc: 38 ff 00 6c addi r7,r31,108
ffc0e8d0: 4b ff 9f d5 bl ffc088a4 <rtems_semaphore_create>
0, RTEMS_BDBUF_CACHE_WAITER_ATTRIBS, 0,
&bdbuf_cache.access_waiters.sema);
if (sc != RTEMS_SUCCESSFUL)
ffc0e8d4: 2f 83 00 00 cmpwi cr7,r3,0
ffc0e8d8: 40 be 01 d0 bne+ cr7,ffc0eaa8 <rtems_bdbuf_init+0x32c> <== NEVER TAKEN
goto error;
sc = rtems_semaphore_create (rtems_build_name ('B', 'D', 'C', 't'),
ffc0e8dc: 3c 60 42 44 lis r3,16964
ffc0e8e0: 60 63 43 74 ori r3,r3,17268
ffc0e8e4: 38 80 00 00 li r4,0
ffc0e8e8: 38 a0 00 24 li r5,36
ffc0e8ec: 38 c0 00 00 li r6,0
ffc0e8f0: 38 ff 00 74 addi r7,r31,116
ffc0e8f4: 4b ff 9f b1 bl ffc088a4 <rtems_semaphore_create>
0, RTEMS_BDBUF_CACHE_WAITER_ATTRIBS, 0,
&bdbuf_cache.transfer_waiters.sema);
if (sc != RTEMS_SUCCESSFUL)
ffc0e8f8: 2f 83 00 00 cmpwi cr7,r3,0
ffc0e8fc: 40 be 01 ac bne+ cr7,ffc0eaa8 <rtems_bdbuf_init+0x32c> <== NEVER TAKEN
goto error;
sc = rtems_semaphore_create (rtems_build_name ('B', 'D', 'C', 'b'),
ffc0e900: 3c 60 42 44 lis r3,16964
ffc0e904: 60 63 43 62 ori r3,r3,17250
ffc0e908: 38 80 00 00 li r4,0
ffc0e90c: 38 a0 00 24 li r5,36
ffc0e910: 38 c0 00 00 li r6,0
ffc0e914: 38 ff 00 7c addi r7,r31,124
ffc0e918: 4b ff 9f 8d bl ffc088a4 <rtems_semaphore_create>
0, RTEMS_BDBUF_CACHE_WAITER_ATTRIBS, 0,
&bdbuf_cache.buffer_waiters.sema);
if (sc != RTEMS_SUCCESSFUL)
ffc0e91c: 2f 83 00 00 cmpwi cr7,r3,0
ffc0e920: 40 be 01 88 bne+ cr7,ffc0eaa8 <rtems_bdbuf_init+0x32c> <== NEVER TAKEN
/*
* Compute the various number of elements in the cache.
*/
bdbuf_cache.buffer_min_count =
bdbuf_config.size / bdbuf_config.buffer_min;
ffc0e924: 83 9c 00 1c lwz r28,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),
ffc0e928: 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 =
ffc0e92c: 93 bf 00 20 stw r29,32(r31)
/*
* Compute the various number of elements in the cache.
*/
bdbuf_cache.buffer_min_count =
bdbuf_config.size / bdbuf_config.buffer_min;
ffc0e930: 7f 9c f3 96 divwu r28,r28,r30
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;
ffc0e934: 7f bc eb 96 divwu r29,r28,r29
goto error;
/*
* Compute the various number of elements in the cache.
*/
bdbuf_cache.buffer_min_count =
ffc0e938: 93 9f 00 1c stw r28,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 =
ffc0e93c: 93 bf 00 80 stw r29,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),
ffc0e940: 7f 84 e3 78 mr r4,r28
ffc0e944: 4b ff 67 2d bl ffc05070 <calloc>
bdbuf_cache.buffer_min_count);
if (!bdbuf_cache.bds)
ffc0e948: 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),
ffc0e94c: 90 7f 00 14 stw r3,20(r31)
bdbuf_cache.buffer_min_count);
if (!bdbuf_cache.bds)
ffc0e950: 41 9e 01 58 beq- cr7,ffc0eaa8 <rtems_bdbuf_init+0x32c> <== NEVER TAKEN
goto error;
/*
* Allocate the memory for the buffer descriptors.
*/
bdbuf_cache.groups = calloc (sizeof (rtems_bdbuf_group),
ffc0e954: 38 60 00 14 li r3,20
ffc0e958: 7f a4 eb 78 mr r4,r29
ffc0e95c: 4b ff 67 15 bl ffc05070 <calloc>
bdbuf_cache.group_count);
if (!bdbuf_cache.groups)
ffc0e960: 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),
ffc0e964: 90 7f 00 84 stw r3,132(r31)
bdbuf_cache.group_count);
if (!bdbuf_cache.groups)
ffc0e968: 41 9e 01 40 beq- cr7,ffc0eaa8 <rtems_bdbuf_init+0x32c> <== 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,
ffc0e96c: 3f e0 00 00 lis r31,0
ffc0e970: 7c bc f1 d6 mullw r5,r28,r30
ffc0e974: 3b ff 2a 08 addi r31,r31,10760
ffc0e978: 38 7f 00 18 addi r3,r31,24
ffc0e97c: 38 80 00 20 li r4,32
ffc0e980: 48 00 24 b9 bl ffc10e38 <rtems_memalign>
ffc0e984: 2f 83 00 00 cmpwi cr7,r3,0
ffc0e988: 40 be 01 20 bne+ cr7,ffc0eaa8 <rtems_bdbuf_init+0x32c> <== 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,
ffc0e98c: 83 1f 00 84 lwz r24,132(r31)
ffc0e990: 3b 40 00 00 li r26,0
bd = bdbuf_cache.bds, buffer = bdbuf_cache.buffers;
ffc0e994: 83 7f 00 14 lwz r27,20(r31)
b < bdbuf_cache.buffer_min_count;
b++, bd++, buffer += bdbuf_config.buffer_min)
{
bd->dev = BDBUF_INVALID_DEV;
ffc0e998: 3b 80 ff ff li r28,-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;
ffc0e99c: 83 3f 00 18 lwz r25,24(r31)
b < bdbuf_cache.buffer_min_count;
b++, bd++, buffer += bdbuf_config.buffer_min)
{
bd->dev = BDBUF_INVALID_DEV;
ffc0e9a0: 3b a0 ff ff li r29,-1
bd->group = group;
bd->buffer = buffer;
rtems_chain_append (&bdbuf_cache.lru, &bd->link);
ffc0e9a4: 3a ff 00 44 addi r23,r31,68
/*
* 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,
ffc0e9a8: 48 00 00 4c b ffc0e9f4 <rtems_bdbuf_init+0x278>
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;
ffc0e9ac: 93 9b 00 18 stw r28,24(r27)
RTEMS_INLINE_ROUTINE void rtems_chain_append(
rtems_chain_control *the_chain,
rtems_chain_node *the_node
)
{
_Chain_Append( the_chain, the_node );
ffc0e9b0: 7e e3 bb 78 mr r3,r23
ffc0e9b4: 7f 64 db 78 mr r4,r27
ffc0e9b8: 93 bb 00 1c stw r29,28(r27)
bd->group = group;
ffc0e9bc: 93 1b 00 30 stw r24,48(r27)
bd->buffer = buffer;
ffc0e9c0: 93 3b 00 24 stw r25,36(r27)
ffc0e9c4: 4b ff ae 99 bl ffc0985c <_Chain_Append>
rtems_chain_append (&bdbuf_cache.lru, &bd->link);
if ((b % bdbuf_cache.max_bds_per_group) ==
ffc0e9c8: 81 3f 00 20 lwz r9,32(r31)
ffc0e9cc: 7c 1a 4b 96 divwu r0,r26,r9
ffc0e9d0: 7c 00 49 d6 mullw r0,r0,r9
(bdbuf_cache.max_bds_per_group - 1))
ffc0e9d4: 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) ==
ffc0e9d8: 7c 00 d0 50 subf r0,r0,r26
ffc0e9dc: 7f 80 48 00 cmpw cr7,r0,r9
ffc0e9e0: 40 be 00 08 bne+ cr7,ffc0e9e8 <rtems_bdbuf_init+0x26c>
(bdbuf_cache.max_bds_per_group - 1))
group++;
ffc0e9e4: 3b 18 00 14 addi r24,r24,20
* 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)
ffc0e9e8: 3b 5a 00 01 addi r26,r26,1
ffc0e9ec: 3b 7b 00 40 addi r27,r27,64
ffc0e9f0: 7f 39 f2 14 add r25,r25,r30
/*
* 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,
ffc0e9f4: 80 1f 00 1c lwz r0,28(r31)
ffc0e9f8: 7f 9a 00 40 cmplw cr7,r26,r0
ffc0e9fc: 41 9c ff b0 blt+ cr7,ffc0e9ac <rtems_bdbuf_init+0x230>
}
for (b = 0,
group = bdbuf_cache.groups,
bd = bdbuf_cache.bds;
b < bdbuf_cache.group_count;
ffc0ea00: 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;
ffc0ea04: 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,
ffc0ea08: 39 4a 00 01 addi r10,r10,1
group = bdbuf_cache.groups,
ffc0ea0c: 81 3f 00 84 lwz r9,132(r31)
bd = bdbuf_cache.bds;
ffc0ea10: 80 1f 00 14 lwz r0,20(r31)
b < bdbuf_cache.group_count;
b++,
group++,
bd += bdbuf_cache.max_bds_per_group)
ffc0ea14: 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,
ffc0ea18: 7d 49 03 a6 mtctr r10
ffc0ea1c: 48 00 00 14 b ffc0ea30 <rtems_bdbuf_init+0x2b4>
b++,
group++,
bd += bdbuf_cache.max_bds_per_group)
{
group->bds_per_group = bdbuf_cache.max_bds_per_group;
group->bdbuf = bd;
ffc0ea20: 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)
ffc0ea24: 7c 00 42 14 add r0,r0,r8
{
group->bds_per_group = bdbuf_cache.max_bds_per_group;
ffc0ea28: 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++,
ffc0ea2c: 39 29 00 14 addi r9,r9,20
if ((b % bdbuf_cache.max_bds_per_group) ==
(bdbuf_cache.max_bds_per_group - 1))
group++;
}
for (b = 0,
ffc0ea30: 42 00 ff f0 bdnz+ ffc0ea20 <rtems_bdbuf_init+0x2a4>
* threads.
*/
bdbuf_cache.swapout_enabled = true;
sc = rtems_task_create (rtems_build_name('B', 'S', 'W', 'P'),
bdbuf_config.swapout_priority ?
ffc0ea34: 3d 20 ff c2 lis r9,-62
ffc0ea38: 80 89 a2 dc lwz r4,-23844(r9)
/*
* Create and start swapout task. This task will create and manage the worker
* threads.
*/
bdbuf_cache.swapout_enabled = true;
ffc0ea3c: 3f e0 00 00 lis r31,0
ffc0ea40: 3b ff 2a 08 addi r31,r31,10760
sc = rtems_task_create (rtems_build_name('B', 'S', 'W', 'P'),
ffc0ea44: 2f 84 00 00 cmpwi cr7,r4,0
/*
* Create and start swapout task. This task will create and manage the worker
* threads.
*/
bdbuf_cache.swapout_enabled = true;
ffc0ea48: 38 00 00 01 li r0,1
ffc0ea4c: 98 1f 00 04 stb r0,4(r31)
sc = rtems_task_create (rtems_build_name('B', 'S', 'W', 'P'),
ffc0ea50: 40 9e 00 08 bne- cr7,ffc0ea58 <rtems_bdbuf_init+0x2dc> <== ALWAYS TAKEN
ffc0ea54: 38 80 00 0f li r4,15 <== NOT EXECUTED
ffc0ea58: 3c 60 42 53 lis r3,16979
ffc0ea5c: 60 63 57 50 ori r3,r3,22352
ffc0ea60: 38 a0 20 00 li r5,8192
ffc0ea64: 38 c0 04 00 li r6,1024
ffc0ea68: 38 e0 00 00 li r7,0
ffc0ea6c: 7f e8 fb 78 mr r8,r31
ffc0ea70: 4b ff a2 8d bl ffc08cfc <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)
ffc0ea74: 2f 83 00 00 cmpwi cr7,r3,0
ffc0ea78: 40 be 00 30 bne+ cr7,ffc0eaa8 <rtems_bdbuf_init+0x32c> <== NEVER TAKEN
goto error;
sc = rtems_task_start (bdbuf_cache.swapout,
ffc0ea7c: 3d 20 00 00 lis r9,0
ffc0ea80: 80 69 2a 08 lwz r3,10760(r9)
ffc0ea84: 3c 80 ff c1 lis r4,-63
ffc0ea88: 38 84 dd bc addi r4,r4,-8772
ffc0ea8c: 7f e5 fb 78 mr r5,r31
ffc0ea90: 4b ff a5 35 bl ffc08fc4 <rtems_task_start>
rtems_bdbuf_swapout_task,
(rtems_task_argument) &bdbuf_cache);
if (sc != RTEMS_SUCCESSFUL)
ffc0ea94: 2f 83 00 00 cmpwi cr7,r3,0
ffc0ea98: 40 be 00 10 bne+ cr7,ffc0eaa8 <rtems_bdbuf_init+0x32c> <== NEVER TAKEN
goto error;
rtems_bdbuf_unlock_cache ();
ffc0ea9c: 4b ff e4 05 bl ffc0cea0 <rtems_bdbuf_unlock_cache>
return RTEMS_SUCCESSFUL;
ffc0eaa0: 38 60 00 00 li r3,0
ffc0eaa4: 48 00 00 80 b ffc0eb24 <rtems_bdbuf_init+0x3a8>
error:
if (bdbuf_cache.swapout != 0)
ffc0eaa8: 3f e0 00 00 lis r31,0 <== NOT EXECUTED
ffc0eaac: 80 7f 2a 08 lwz r3,10760(r31) <== NOT EXECUTED
ffc0eab0: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc0eab4: 41 be 00 08 beq+ cr7,ffc0eabc <rtems_bdbuf_init+0x340> <== NOT EXECUTED
rtems_task_delete (bdbuf_cache.swapout);
ffc0eab8: 4b ff a3 85 bl ffc08e3c <rtems_task_delete> <== NOT EXECUTED
free (bdbuf_cache.buffers);
ffc0eabc: 3b ff 2a 08 addi r31,r31,10760 <== NOT EXECUTED
ffc0eac0: 80 7f 00 18 lwz r3,24(r31) <== NOT EXECUTED
ffc0eac4: 4b ff 67 ad bl ffc05270 <free> <== NOT EXECUTED
free (bdbuf_cache.groups);
ffc0eac8: 80 7f 00 84 lwz r3,132(r31) <== NOT EXECUTED
ffc0eacc: 4b ff 67 a5 bl ffc05270 <free> <== NOT EXECUTED
free (bdbuf_cache.bds);
ffc0ead0: 80 7f 00 14 lwz r3,20(r31) <== NOT EXECUTED
ffc0ead4: 4b ff 67 9d bl ffc05270 <free> <== NOT EXECUTED
rtems_semaphore_delete (bdbuf_cache.buffer_waiters.sema);
ffc0ead8: 80 7f 00 7c lwz r3,124(r31) <== NOT EXECUTED
ffc0eadc: 4b ff 9f 85 bl ffc08a60 <rtems_semaphore_delete> <== NOT EXECUTED
rtems_semaphore_delete (bdbuf_cache.access_waiters.sema);
ffc0eae0: 80 7f 00 6c lwz r3,108(r31) <== NOT EXECUTED
ffc0eae4: 4b ff 9f 7d bl ffc08a60 <rtems_semaphore_delete> <== NOT EXECUTED
rtems_semaphore_delete (bdbuf_cache.transfer_waiters.sema);
ffc0eae8: 80 7f 00 74 lwz r3,116(r31) <== NOT EXECUTED
ffc0eaec: 4b ff 9f 75 bl ffc08a60 <rtems_semaphore_delete> <== NOT EXECUTED
rtems_semaphore_delete (bdbuf_cache.sync_lock);
ffc0eaf0: 80 7f 00 2c lwz r3,44(r31) <== NOT EXECUTED
ffc0eaf4: 4b ff 9f 6d bl ffc08a60 <rtems_semaphore_delete> <== NOT EXECUTED
if (bdbuf_cache.lock != 0)
ffc0eaf8: 80 1f 00 28 lwz r0,40(r31) <== NOT EXECUTED
ffc0eafc: 2f 80 00 00 cmpwi cr7,r0,0 <== NOT EXECUTED
ffc0eb00: 41 be 00 10 beq+ cr7,ffc0eb10 <rtems_bdbuf_init+0x394> <== NOT EXECUTED
{
rtems_bdbuf_unlock_cache ();
ffc0eb04: 4b ff e3 9d bl ffc0cea0 <rtems_bdbuf_unlock_cache> <== NOT EXECUTED
rtems_semaphore_delete (bdbuf_cache.lock);
ffc0eb08: 80 7f 00 28 lwz r3,40(r31) <== NOT EXECUTED
ffc0eb0c: 4b ff 9f 55 bl ffc08a60 <rtems_semaphore_delete> <== NOT EXECUTED
}
bdbuf_cache.initialised = false;
ffc0eb10: 3d 20 00 00 lis r9,0 <== NOT EXECUTED
ffc0eb14: 38 00 00 00 li r0,0 <== NOT EXECUTED
ffc0eb18: 39 29 2a 08 addi r9,r9,10760 <== NOT EXECUTED
ffc0eb1c: 98 09 00 88 stb r0,136(r9) <== NOT EXECUTED
return RTEMS_UNSATISFIED;
ffc0eb20: 38 60 00 0d li r3,13 <== NOT EXECUTED
}
ffc0eb24: 39 61 00 30 addi r11,r1,48
ffc0eb28: 48 00 a9 d0 b ffc194f8 <_restgpr_23_x>
ffc0cc48 <rtems_bdbuf_lock_cache>:
* @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,
ffc0cc48: 3d 20 00 00 lis r9,0
/**
* Lock the cache. A single task can nest calls.
*/
static void
rtems_bdbuf_lock_cache (void)
{
ffc0cc4c: 94 21 ff f8 stwu r1,-8(r1)
ffc0cc50: 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,
ffc0cc54: 38 80 00 00 li r4,0
ffc0cc58: 80 69 2a 30 lwz r3,10800(r9)
ffc0cc5c: 38 a0 00 00 li r5,0
/**
* Lock the cache. A single task can nest calls.
*/
static void
rtems_bdbuf_lock_cache (void)
{
ffc0cc60: 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,
ffc0cc64: 4b ff be b5 bl ffc08b18 <rtems_semaphore_obtain>
RTEMS_WAIT,
RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
ffc0cc68: 2f 83 00 00 cmpwi cr7,r3,0
ffc0cc6c: 41 be 00 10 beq+ cr7,ffc0cc7c <rtems_bdbuf_lock_cache+0x34><== ALWAYS TAKEN
rtems_fatal_error_occurred (fatal_error_code);
ffc0cc70: 3c 60 42 00 lis r3,16896 <== NOT EXECUTED
ffc0cc74: 60 63 00 0d ori r3,r3,13 <== NOT EXECUTED
ffc0cc78: 4b ff c6 2d bl ffc092a4 <rtems_fatal_error_occurred> <== NOT EXECUTED
*/
static void
rtems_bdbuf_lock_cache (void)
{
rtems_bdbuf_lock (bdbuf_cache.lock, RTEMS_BLKDEV_FATAL_BDBUF_CACHE_LOCK);
}
ffc0cc7c: 80 01 00 0c lwz r0,12(r1)
ffc0cc80: 38 21 00 08 addi r1,r1,8
ffc0cc84: 7c 08 03 a6 mtlr r0
ffc0cc88: 4e 80 00 20 blr
ffc0cc8c <rtems_bdbuf_lock_sync>:
* @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,
ffc0cc8c: 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)
{
ffc0cc90: 94 21 ff f8 stwu r1,-8(r1)
ffc0cc94: 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,
ffc0cc98: 38 80 00 00 li r4,0
ffc0cc9c: 80 69 2a 34 lwz r3,10804(r9)
ffc0cca0: 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)
{
ffc0cca4: 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,
ffc0cca8: 4b ff be 71 bl ffc08b18 <rtems_semaphore_obtain>
RTEMS_WAIT,
RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
ffc0ccac: 2f 83 00 00 cmpwi cr7,r3,0
ffc0ccb0: 41 be 00 10 beq+ cr7,ffc0ccc0 <rtems_bdbuf_lock_sync+0x34><== ALWAYS TAKEN
rtems_fatal_error_occurred (fatal_error_code);
ffc0ccb4: 3c 60 42 00 lis r3,16896 <== NOT EXECUTED
ffc0ccb8: 60 63 00 0b ori r3,r3,11 <== NOT EXECUTED
ffc0ccbc: 4b ff c5 e9 bl ffc092a4 <rtems_fatal_error_occurred> <== NOT EXECUTED
*/
static void
rtems_bdbuf_lock_sync (void)
{
rtems_bdbuf_lock (bdbuf_cache.sync_lock, RTEMS_BLKDEV_FATAL_BDBUF_SYNC_LOCK);
}
ffc0ccc0: 80 01 00 0c lwz r0,12(r1)
ffc0ccc4: 38 21 00 08 addi r1,r1,8
ffc0ccc8: 7c 08 03 a6 mtlr r0
ffc0cccc: 4e 80 00 20 blr
ffc0d378 <rtems_bdbuf_obtain_disk.part.7>:
return bd;
}
static rtems_status_code
rtems_bdbuf_obtain_disk (dev_t dev,
ffc0d378: 94 21 ff e0 stwu r1,-32(r1)
ffc0d37c: 7c 08 02 a6 mflr r0
ffc0d380: bf 61 00 0c stmw r27,12(r1)
ffc0d384: 7c be 2b 78 mr r30,r5
ffc0d388: 7c db 33 78 mr r27,r6
ffc0d38c: 90 01 00 24 stw r0,36(r1)
ffc0d390: 7c ff 3b 78 mr r31,r7
ffc0d394: 7d 1c 43 78 mr r28,r8
return RTEMS_NOT_CONFIGURED;
/*
* Do not hold the cache lock when obtaining the disk table.
*/
dd = rtems_disk_obtain (dev);
ffc0d398: 4b ff 71 6d bl ffc04504 <rtems_disk_obtain>
if (dd == NULL)
ffc0d39c: 7c 7d 1b 79 mr. r29,r3
return RTEMS_INVALID_ID;
ffc0d3a0: 38 00 00 04 li r0,4
/*
* Do not hold the cache lock when obtaining the disk table.
*/
dd = rtems_disk_obtain (dev);
if (dd == NULL)
ffc0d3a4: 41 82 00 bc beq- ffc0d460 <rtems_bdbuf_obtain_disk.part.7+0xe8><== NEVER TAKEN
return RTEMS_INVALID_ID;
*dd_ptr = dd;
if (media_block_ptr != NULL)
ffc0d3a8: 2f 9f 00 00 cmpwi cr7,r31,0
*/
dd = rtems_disk_obtain (dev);
if (dd == NULL)
return RTEMS_INVALID_ID;
*dd_ptr = dd;
ffc0d3ac: 93 bb 00 00 stw r29,0(r27)
if (media_block_ptr != NULL)
ffc0d3b0: 41 9e 00 3c beq- cr7,ffc0d3ec <rtems_bdbuf_obtain_disk.part.7+0x74>
* 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,
ffc0d3b4: 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);
ffc0d3b8: 38 a0 00 00 li r5,0
ffc0d3bc: 80 dd 00 24 lwz r6,36(r29)
ffc0d3c0: 7d 5e 19 d6 mullw r10,r30,r3
ffc0d3c4: 7d 3e 18 16 mulhwu r9,r30,r3
ffc0d3c8: 7d 44 53 78 mr r4,r10
ffc0d3cc: 7d 23 4b 78 mr r3,r9
ffc0d3d0: 48 00 b9 01 bl ffc18cd0 <__udivdi3>
* the user.
*/
rtems_blkdev_bnum mb = rtems_bdbuf_media_block (block,
dd->block_size,
dd->media_block_size);
if (mb >= dd->size)
ffc0d3d4: 80 1d 00 1c lwz r0,28(r29)
ffc0d3d8: 7f 84 00 40 cmplw cr7,r4,r0
ffc0d3dc: 40 9c 00 6c bge- cr7,ffc0d448 <rtems_bdbuf_obtain_disk.part.7+0xd0><== NEVER TAKEN
{
rtems_disk_release(dd);
return RTEMS_INVALID_NUMBER;
}
*media_block_ptr = mb + dd->start;
ffc0d3e0: 80 1d 00 18 lwz r0,24(r29)
ffc0d3e4: 7c 84 02 14 add r4,r4,r0
ffc0d3e8: 90 9f 00 00 stw r4,0(r31)
}
if (bds_per_group_ptr != NULL)
ffc0d3ec: 2f 9c 00 00 cmpwi cr7,r28,0
}
*bds_per_group_ptr = bds_per_group;
}
return RTEMS_SUCCESSFUL;
ffc0d3f0: 38 00 00 00 li r0,0
}
*media_block_ptr = mb + dd->start;
}
if (bds_per_group_ptr != NULL)
ffc0d3f4: 41 9e 00 6c beq- cr7,ffc0d460 <rtems_bdbuf_obtain_disk.part.7+0xe8>
rtems_bdbuf_bds_per_group (size_t size)
{
size_t bufs_per_size;
size_t bds_per_size;
if (size > bdbuf_config.buffer_max)
ffc0d3f8: 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);
ffc0d3fc: 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)
ffc0d400: 39 29 a2 d4 addi r9,r9,-23852
ffc0d404: 80 09 00 24 lwz r0,36(r9)
ffc0d408: 7f 8b 00 40 cmplw cr7,r11,r0
ffc0d40c: 41 9d 00 3c bgt- cr7,ffc0d448 <rtems_bdbuf_obtain_disk.part.7+0xd0><== NEVER TAKEN
return 0;
bufs_per_size = ((size - 1) / bdbuf_config.buffer_min) + 1;
ffc0d410: 80 09 00 20 lwz r0,32(r9)
ffc0d414: 39 6b ff ff addi r11,r11,-1
ffc0d418: 7d 6b 03 96 divwu r11,r11,r0
for (bds_per_size = 1;
ffc0d41c: 38 00 00 01 li r0,1
size_t bds_per_size;
if (size > bdbuf_config.buffer_max)
return 0;
bufs_per_size = ((size - 1) / bdbuf_config.buffer_min) + 1;
ffc0d420: 39 6b 00 01 addi r11,r11,1
ffc0d424: 48 00 00 08 b ffc0d42c <rtems_bdbuf_obtain_disk.part.7+0xb4>
for (bds_per_size = 1;
bds_per_size < bufs_per_size;
bds_per_size <<= 1)
ffc0d428: 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;
ffc0d42c: 7f 80 58 40 cmplw cr7,r0,r11
ffc0d430: 41 9c ff f8 blt+ cr7,ffc0d428 <rtems_bdbuf_obtain_disk.part.7+0xb0>
bds_per_size < bufs_per_size;
bds_per_size <<= 1)
;
return bdbuf_cache.max_bds_per_group / bds_per_size;
ffc0d434: 3d 20 00 00 lis r9,0
ffc0d438: 81 29 2a 28 lwz r9,10792(r9)
ffc0d43c: 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)
ffc0d440: 2f 80 00 00 cmpwi cr7,r0,0
ffc0d444: 40 be 00 14 bne+ cr7,ffc0d458 <rtems_bdbuf_obtain_disk.part.7+0xe0><== ALWAYS TAKEN
{
rtems_disk_release (dd);
ffc0d448: 7f a3 eb 78 mr r3,r29 <== NOT EXECUTED
ffc0d44c: 4b ff 71 3d bl ffc04588 <rtems_disk_release> <== NOT EXECUTED
return RTEMS_INVALID_NUMBER;
ffc0d450: 38 00 00 0a li r0,10 <== NOT EXECUTED
ffc0d454: 48 00 00 0c b ffc0d460 <rtems_bdbuf_obtain_disk.part.7+0xe8><== NOT EXECUTED
}
*bds_per_group_ptr = bds_per_group;
ffc0d458: 90 1c 00 00 stw r0,0(r28)
}
return RTEMS_SUCCESSFUL;
ffc0d45c: 38 00 00 00 li r0,0
}
ffc0d460: 39 61 00 20 addi r11,r1,32
ffc0d464: 7c 03 03 78 mr r3,r0
ffc0d468: 48 00 c0 a0 b ffc19508 <_restgpr_27_x>
ffc0d8d8 <rtems_bdbuf_purge>:
}
}
static void
rtems_bdbuf_purge (rtems_bdbuf_purge_compare compare, dev_t dev)
{
ffc0d8d8: 94 21 ff 40 stwu r1,-192(r1)
ffc0d8dc: 7c 08 02 a6 mflr r0
ffc0d8e0: be c1 00 98 stmw r22,152(r1)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
head->previous = NULL;
ffc0d8e4: 3b 60 00 00 li r27,0
tail->previous = head;
ffc0d8e8: 3b 21 00 08 addi r25,r1,8
ffc0d8ec: 90 01 00 c4 stw r0,196(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;
ffc0d8f0: 3f 40 00 00 lis r26,0
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
ffc0d8f4: 38 01 00 0c addi r0,r1,12
*prev = NULL;
ffc0d8f8: 7c 3c 0b 78 mr r28,r1
head->previous = NULL;
ffc0d8fc: 93 61 00 0c stw r27,12(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;
ffc0d900: 3b 5a 2a 08 addi r26,r26,10760
}
}
static void
rtems_bdbuf_purge (rtems_bdbuf_purge_compare compare, dev_t dev)
{
ffc0d904: 7c 76 1b 78 mr r22,r3
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
ffc0d908: 90 01 00 08 stw r0,8(r1)
ffc0d90c: 7c df 33 78 mr r31,r6
ffc0d910: 7c be 2b 78 mr r30,r5
head->previous = NULL;
tail->previous = head;
ffc0d914: 93 21 00 10 stw r25,16(r1)
rtems_chain_control purge_list;
rtems_chain_initialize_empty (&purge_list);
rtems_bdbuf_lock_cache ();
ffc0d918: 4b ff f3 31 bl ffc0cc48 <rtems_bdbuf_lock_cache>
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
ffc0d91c: 3a e0 00 06 li r23,6
{
rtems_bdbuf_buffer *stack [RTEMS_BDBUF_AVL_MAX_HEIGHT];
rtems_bdbuf_buffer **prev = stack;
rtems_bdbuf_buffer *cur = bdbuf_cache.tree;
*prev = NULL;
ffc0d920: 97 7c 00 14 stwu r27,20(r28)
while (cur != NULL)
{
if ((*compare) (cur->dev, dev))
{
switch (cur->state)
ffc0d924: 3f 60 ff c2 lis r27,-62
ffc0d928: 3b 7b b0 28 addi r27,r27,-20440
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;
ffc0d92c: 83 ba 00 40 lwz r29,64(r26)
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
ffc0d930: 3b 00 00 0a li r24,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);
ffc0d934: 3b 5a 00 70 addi r26,r26,112
ffc0d938: 48 00 00 dc b ffc0da14 <rtems_bdbuf_purge+0x13c>
*prev = NULL;
while (cur != NULL)
{
if ((*compare) (cur->dev, dev))
ffc0d93c: 80 7d 00 18 lwz r3,24(r29)
ffc0d940: 7f c5 f3 78 mr r5,r30
ffc0d944: 80 9d 00 1c lwz r4,28(r29)
ffc0d948: 7f e6 fb 78 mr r6,r31
ffc0d94c: 7e c9 03 a6 mtctr r22
ffc0d950: 4e 80 04 21 bctrl
ffc0d954: 2f 83 00 00 cmpwi cr7,r3,0
ffc0d958: 41 9e 00 70 beq- cr7,ffc0d9c8 <rtems_bdbuf_purge+0xf0> <== NEVER TAKEN
{
switch (cur->state)
ffc0d95c: 80 1d 00 28 lwz r0,40(r29)
ffc0d960: 2b 80 00 0a cmplwi cr7,r0,10
ffc0d964: 41 9d 00 58 bgt- cr7,ffc0d9bc <rtems_bdbuf_purge+0xe4> <== NEVER TAKEN
ffc0d968: 54 00 10 3a rlwinm r0,r0,2,0,29
ffc0d96c: 7c 1b 00 2e lwzx r0,r27,r0
ffc0d970: 7c 00 da 14 add r0,r0,r27
ffc0d974: 7c 09 03 a6 mtctr r0
ffc0d978: 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);
ffc0d97c: 7f 43 d3 78 mr r3,r26
ffc0d980: 4b ff f8 d1 bl ffc0d250 <rtems_bdbuf_wake>
}
static void
rtems_bdbuf_group_release (rtems_bdbuf_buffer *bd)
{
--bd->group->users;
ffc0d984: 81 3d 00 30 lwz r9,48(r29)
ffc0d988: 81 69 00 0c lwz r11,12(r9)
ffc0d98c: 38 0b ff ff addi r0,r11,-1
ffc0d990: 90 09 00 0c stw r0,12(r9)
ffc0d994: 7f a3 eb 78 mr r3,r29
ffc0d998: 4b ff be f5 bl ffc0988c <_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 );
ffc0d99c: 7f 23 cb 78 mr r3,r25
ffc0d9a0: 7f a4 eb 78 mr r4,r29
ffc0d9a4: 4b ff be b9 bl ffc0985c <_Chain_Append>
ffc0d9a8: 48 00 00 20 b ffc0d9c8 <rtems_bdbuf_purge+0xf0>
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
ffc0d9ac: 93 1d 00 28 stw r24,40(r29)
ffc0d9b0: 48 00 00 18 b ffc0d9c8 <rtems_bdbuf_purge+0xf0>
ffc0d9b4: 92 fd 00 28 stw r23,40(r29)
ffc0d9b8: 48 00 00 10 b ffc0d9c8 <rtems_bdbuf_purge+0xf0>
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);
ffc0d9bc: 3c 60 42 00 lis r3,16896 <== NOT EXECUTED
ffc0d9c0: 60 63 00 01 ori r3,r3,1 <== NOT EXECUTED
ffc0d9c4: 4b ff b8 e1 bl ffc092a4 <rtems_fatal_error_occurred> <== NOT EXECUTED
}
}
if (cur->avl.left != NULL)
ffc0d9c8: 81 3d 00 08 lwz r9,8(r29)
ffc0d9cc: 2f 89 00 00 cmpwi cr7,r9,0
ffc0d9d0: 40 be 00 10 bne+ cr7,ffc0d9e0 <rtems_bdbuf_purge+0x108> <== NEVER TAKEN
/* Left */
++prev;
*prev = cur;
cur = cur->avl.left;
}
else if (cur->avl.right != NULL)
ffc0d9d4: 81 3d 00 0c lwz r9,12(r29)
ffc0d9d8: 2f 89 00 00 cmpwi cr7,r9,0
ffc0d9dc: 41 9e 00 18 beq- cr7,ffc0d9f4 <rtems_bdbuf_purge+0x11c> <== ALWAYS TAKEN
{
/* Right */
++prev;
*prev = cur;
ffc0d9e0: 93 bc 00 04 stw r29,4(r28) <== NOT EXECUTED
cur = cur->avl.left;
}
else if (cur->avl.right != NULL)
{
/* Right */
++prev;
ffc0d9e4: 3b 9c 00 04 addi r28,r28,4 <== NOT EXECUTED
ffc0d9e8: 48 00 00 28 b ffc0da10 <rtems_bdbuf_purge+0x138> <== NOT EXECUTED
{
while (*prev != NULL && cur == (*prev)->avl.right)
{
/* Up */
cur = *prev;
--prev;
ffc0d9ec: 3b 9c ff fc addi r28,r28,-4 <== NOT EXECUTED
ffc0d9f0: 7d 3d 4b 78 mr r29,r9 <== NOT EXECUTED
*prev = cur;
cur = cur->avl.right;
}
else
{
while (*prev != NULL && cur == (*prev)->avl.right)
ffc0d9f4: 81 3c 00 00 lwz r9,0(r28)
ffc0d9f8: 2f 89 00 00 cmpwi cr7,r9,0
ffc0d9fc: 41 9e 00 14 beq- cr7,ffc0da10 <rtems_bdbuf_purge+0x138> <== ALWAYS TAKEN
ffc0da00: 80 09 00 0c lwz r0,12(r9) <== NOT EXECUTED
ffc0da04: 7f 9d 00 00 cmpw cr7,r29,r0 <== NOT EXECUTED
ffc0da08: 41 9e ff e4 beq+ cr7,ffc0d9ec <rtems_bdbuf_purge+0x114> <== NOT EXECUTED
ffc0da0c: 48 00 00 94 b ffc0daa0 <rtems_bdbuf_purge+0x1c8> <== NOT EXECUTED
}
if (cur->avl.left != NULL)
{
/* Left */
++prev;
ffc0da10: 7d 3d 4b 78 mr r29,r9
rtems_bdbuf_buffer **prev = stack;
rtems_bdbuf_buffer *cur = bdbuf_cache.tree;
*prev = NULL;
while (cur != NULL)
ffc0da14: 2f 9d 00 00 cmpwi cr7,r29,0
ffc0da18: 40 9e ff 24 bne+ cr7,ffc0d93c <rtems_bdbuf_purge+0x64>
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Head(
Chain_Control *the_chain
)
{
return &the_chain->Head.Node;
ffc0da1c: 3f a0 00 00 lis r29,0
ffc0da20: 3b bd 2a 08 addi r29,r29,10760
ffc0da24: 3b c0 00 00 li r30,0
while ((node = rtems_chain_get (purge_list)) != NULL)
{
rtems_bdbuf_buffer *bd = (rtems_bdbuf_buffer *) node;
if (bd->waiters == 0)
wake_buffer_waiters = true;
ffc0da28: 3b 80 00 01 li r28,1
ffc0da2c: 3b bd 00 44 addi r29,r29,68
ffc0da30: 48 00 00 3c b ffc0da6c <rtems_bdbuf_purge+0x194>
while ((node = rtems_chain_get (purge_list)) != NULL)
{
rtems_bdbuf_buffer *bd = (rtems_bdbuf_buffer *) node;
if (bd->waiters == 0)
ffc0da34: 80 1b 00 2c lwz r0,44(r27)
ffc0da38: 2f 80 00 00 cmpwi cr7,r0,0
ffc0da3c: 40 9e 00 08 bne- cr7,ffc0da44 <rtems_bdbuf_purge+0x16c>
wake_buffer_waiters = true;
ffc0da40: 3b c0 00 01 li r30,1
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
ffc0da44: 93 9b 00 28 stw r28,40(r27)
static void
rtems_bdbuf_discard_buffer (rtems_bdbuf_buffer *bd)
{
rtems_bdbuf_make_empty (bd);
if (bd->waiters == 0)
ffc0da48: 83 5b 00 2c lwz r26,44(r27)
ffc0da4c: 2f 9a 00 00 cmpwi cr7,r26,0
ffc0da50: 40 be 00 1c bne+ cr7,ffc0da6c <rtems_bdbuf_purge+0x194>
{
rtems_bdbuf_remove_from_tree (bd);
ffc0da54: 7f 63 db 78 mr r3,r27
ffc0da58: 4b ff fa 15 bl ffc0d46c <rtems_bdbuf_remove_from_tree>
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
ffc0da5c: 93 5b 00 28 stw r26,40(r27)
RTEMS_INLINE_ROUTINE void _Chain_Prepend(
Chain_Control *the_chain,
Chain_Node *the_node
)
{
_Chain_Insert(_Chain_Head(the_chain), the_node);
ffc0da60: 7f a3 eb 78 mr r3,r29
ffc0da64: 7f 64 db 78 mr r4,r27
ffc0da68: 48 00 45 09 bl ffc11f70 <_Chain_Insert>
*/
RTEMS_INLINE_ROUTINE rtems_chain_node *rtems_chain_get(
rtems_chain_control *the_chain
)
{
return _Chain_Get( the_chain );
ffc0da6c: 38 61 00 08 addi r3,r1,8
ffc0da70: 4b ff be 45 bl ffc098b4 <_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)
ffc0da74: 7c 7b 1b 79 mr. r27,r3
ffc0da78: 40 82 ff bc bne+ ffc0da34 <rtems_bdbuf_purge+0x15c>
wake_buffer_waiters = true;
rtems_bdbuf_discard_buffer (bd);
}
if (wake_buffer_waiters)
ffc0da7c: 2f 9e 00 00 cmpwi cr7,r30,0
ffc0da80: 41 be 00 14 beq+ cr7,ffc0da94 <rtems_bdbuf_purge+0x1bc>
rtems_bdbuf_wake (&bdbuf_cache.buffer_waiters);
ffc0da84: 3c 60 00 00 lis r3,0
ffc0da88: 38 63 2a 08 addi r3,r3,10760
ffc0da8c: 38 63 00 78 addi r3,r3,120
ffc0da90: 4b ff f7 c1 bl ffc0d250 <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 ();
ffc0da94: 4b ff f4 0d bl ffc0cea0 <rtems_bdbuf_unlock_cache>
}
ffc0da98: 39 61 00 c0 addi r11,r1,192
ffc0da9c: 48 00 ba 58 b ffc194f4 <_restgpr_22_x>
cur = *prev;
--prev;
}
if (*prev != NULL)
/* Right */
cur = (*prev)->avl.right;
ffc0daa0: 7c 09 03 78 mr r9,r0 <== NOT EXECUTED
ffc0daa4: 4b ff ff 6c b ffc0da10 <rtems_bdbuf_purge+0x138> <== NOT EXECUTED
ffc0cc38 <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);
}
ffc0cc38: 7c 63 2a 78 xor r3,r3,r5 <== NOT EXECUTED
ffc0cc3c: 7c 63 00 34 cntlzw r3,r3 <== NOT EXECUTED
ffc0cc40: 54 63 d9 7e rlwinm r3,r3,27,5,31 <== NOT EXECUTED
ffc0cc44: 4e 80 00 20 blr <== NOT EXECUTED
ffc0f218 <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)
{
ffc0f218: 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);
ffc0f21c: 3c 60 ff c1 lis r3,-63 <== NOT EXECUTED
ffc0f220: 38 63 cc 38 addi r3,r3,-13256 <== NOT EXECUTED
ffc0f224: 38 c0 00 00 li r6,0 <== NOT EXECUTED
ffc0f228: 4b ff e6 b0 b ffc0d8d8 <rtems_bdbuf_purge> <== NOT EXECUTED
ffc0ec08 <rtems_bdbuf_read>:
rtems_blkdev_bnum *media_block_ptr,
size_t *bds_per_group_ptr)
{
rtems_disk_device *dd = NULL;
if (!bdbuf_cache.initialised)
ffc0ec08: 3d 20 00 00 lis r9,0
rtems_status_code
rtems_bdbuf_read (dev_t dev,
rtems_blkdev_bnum block,
rtems_bdbuf_buffer **bd_ptr)
{
ffc0ec0c: 94 21 ff a8 stwu r1,-88(r1)
ffc0ec10: 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)
ffc0ec14: 89 29 2a 90 lbz r9,10896(r9)
rtems_status_code
rtems_bdbuf_read (dev_t dev,
rtems_blkdev_bnum block,
rtems_bdbuf_buffer **bd_ptr)
{
ffc0ec18: be 21 00 1c stmw r17,28(r1)
ffc0ec1c: 7c 3f 0b 78 mr r31,r1
rtems_blkdev_bnum *media_block_ptr,
size_t *bds_per_group_ptr)
{
rtems_disk_device *dd = NULL;
if (!bdbuf_cache.initialised)
ffc0ec20: 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)
{
ffc0ec24: 90 01 00 5c stw r0,92(r1)
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_disk_device *dd = NULL;
ffc0ec28: 38 00 00 00 li r0,0
rtems_status_code
rtems_bdbuf_read (dev_t dev,
rtems_blkdev_bnum block,
rtems_bdbuf_buffer **bd_ptr)
{
ffc0ec2c: 7c de 33 78 mr r30,r6
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_disk_device *dd = NULL;
ffc0ec30: 90 1f 00 10 stw r0,16(r31)
rtems_blkdev_request *req = NULL;
rtems_bdbuf_buffer *bd = NULL;
rtems_blkdev_bnum media_block = 0;
ffc0ec34: 90 1f 00 0c stw r0,12(r31)
size_t bds_per_group = 0;
ffc0ec38: 90 1f 00 08 stw r0,8(r31)
size_t *bds_per_group_ptr)
{
rtems_disk_device *dd = NULL;
if (!bdbuf_cache.initialised)
return RTEMS_NOT_CONFIGURED;
ffc0ec3c: 38 00 00 16 li r0,22
rtems_blkdev_bnum *media_block_ptr,
size_t *bds_per_group_ptr)
{
rtems_disk_device *dd = NULL;
if (!bdbuf_cache.initialised)
ffc0ec40: 41 be 02 2c beq+ cr7,ffc0ee6c <rtems_bdbuf_read+0x264> <== NEVER TAKEN
ffc0ec44: 38 df 00 10 addi r6,r31,16
ffc0ec48: 38 ff 00 0c addi r7,r31,12
ffc0ec4c: 39 1f 00 08 addi r8,r31,8
ffc0ec50: 4b ff e7 29 bl ffc0d378 <rtems_bdbuf_obtain_disk.part.7>
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)
ffc0ec54: 7c 60 1b 79 mr. r0,r3
ffc0ec58: 40 82 02 14 bne- ffc0ee6c <rtems_bdbuf_read+0x264> <== 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) +
ffc0ec5c: 3d 20 ff c2 lis r9,-62
ffc0ec60: 83 89 a2 d4 lwz r28,-23852(r9)
ffc0ec64: 81 21 00 00 lwz r9,0(r1)
ffc0ec68: 3b 9c 00 01 addi r28,r28,1
ffc0ec6c: 57 80 20 36 rlwinm r0,r28,4,0,27
ffc0ec70: 20 00 ff d0 subfic r0,r0,-48
ffc0ec74: 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 ();
ffc0ec78: 4b ff df d1 bl ffc0cc48 <rtems_bdbuf_lock_cache>
rtems_bdbuf_create_read_request (dd, media_block, bds_per_group, req, &bd);
ffc0ec7c: 81 3f 00 10 lwz r9,16(r31)
ffc0ec80: 83 7f 00 0c lwz r27,12(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) +
ffc0ec84: 3b a1 00 17 addi r29,r1,23
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;
ffc0ec88: 83 09 00 1c lwz r24,28(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) +
ffc0ec8c: 57 bd 00 36 rlwinm r29,r29,0,0,27
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;
ffc0ec90: 80 09 00 18 lwz r0,24(r9)
rtems_blkdev_bnum media_block_count = dd->block_size / dd->media_block_size;
ffc0ec94: 82 e9 00 20 lwz r23,32(r9)
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;
ffc0ec98: 7f 18 02 14 add r24,r24,r0
rtems_blkdev_bnum media_block_count = dd->block_size / dd->media_block_size;
ffc0ec9c: 82 29 00 24 lwz r17,36(r9)
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)
ffc0eca0: 7f 1b c0 50 subf r24,r27,r24
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);
ffc0eca4: 82 df 00 08 lwz r22,8(r31)
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;
dev_t dev = dd->dev;
ffc0eca8: 7f 98 e0 40 cmplw cr7,r24,r28
ffc0ecac: 82 89 00 00 lwz r20,0(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;
ffc0ecb0: 7e 37 8b 96 divwu r17,r23,r17
dev_t dev = dd->dev;
ffc0ecb4: 82 a9 00 04 lwz r21,4(r9)
ffc0ecb8: 40 9d 00 08 ble- cr7,ffc0ecc0 <rtems_bdbuf_read+0xb8>
ffc0ecbc: 7f 98 e3 78 mr r24,r28
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;
ffc0ecc0: 3d 20 ff c1 lis r9,-63
req->done_arg = req;
ffc0ecc4: 93 bd 00 08 stw r29,8(r29)
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;
ffc0ecc8: 38 09 cf 8c addi r0,r9,-12404
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;
ffc0eccc: 3b 80 00 00 li r28,0
req->req_done = rtems_bdbuf_transfer_done;
ffc0ecd0: 90 1d 00 04 stw r0,4(r29)
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;
ffc0ecd4: 93 9d 00 00 stw r28,0(r29)
req->req_done = rtems_bdbuf_transfer_done;
req->done_arg = req;
req->io_task = rtems_task_self ();
ffc0ecd8: 48 00 2e f1 bl ffc11bc8 <rtems_task_self>
req->status = RTEMS_RESOURCE_IN_USE;
ffc0ecdc: 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 ();
ffc0ece0: 90 7d 00 14 stw r3,20(r29)
req->status = RTEMS_RESOURCE_IN_USE;
req->bufnum = 0;
bd = rtems_bdbuf_get_buffer_for_access (dev, media_block, bds_per_group);
ffc0ece4: 7e a4 ab 78 mr r4,r21
ffc0ece8: 7e 83 a3 78 mr r3,r20
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;
ffc0ecec: 90 1d 00 0c stw r0,12(r29)
req->bufnum = 0;
bd = rtems_bdbuf_get_buffer_for_access (dev, media_block, bds_per_group);
ffc0ecf0: 7f 65 db 78 mr r5,r27
ffc0ecf4: 7e c6 b3 78 mr r6,r22
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;
ffc0ecf8: 93 9d 00 10 stw r28,16(r29)
bd = rtems_bdbuf_get_buffer_for_access (dev, media_block, bds_per_group);
ffc0ecfc: 4b ff f8 85 bl ffc0e580 <rtems_bdbuf_get_buffer_for_access>
*bd_ptr = bd;
req->bufs [0].user = bd;
req->bufs [0].block = media_block;
ffc0ed00: 93 7d 00 18 stw r27,24(r29)
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);
ffc0ed04: 7c 7c 1b 78 mr r28,r3
*bd_ptr = bd;
req->bufs [0].user = bd;
ffc0ed08: 90 7d 00 24 stw r3,36(r29)
req->bufs [0].block = media_block;
req->bufs [0].length = block_size;
req->bufs [0].buffer = bd->buffer;
ffc0ed0c: 80 03 00 24 lwz r0,36(r3)
*bd_ptr = bd;
req->bufs [0].user = bd;
req->bufs [0].block = media_block;
req->bufs [0].length = block_size;
ffc0ed10: 92 fd 00 1c stw r23,28(r29)
req->bufs [0].buffer = bd->buffer;
ffc0ed14: 90 1d 00 20 stw r0,32(r29)
if (rtems_bdbuf_tracer)
rtems_bdbuf_show_users ("read", bd);
switch (bd->state)
ffc0ed18: 80 03 00 28 lwz r0,40(r3)
ffc0ed1c: 2f 80 00 02 cmpwi cr7,r0,2
ffc0ed20: 41 9e 00 bc beq- cr7,ffc0eddc <rtems_bdbuf_read+0x1d4>
ffc0ed24: 2f 80 00 07 cmpwi cr7,r0,7
ffc0ed28: 41 9e 00 b4 beq- cr7,ffc0eddc <rtems_bdbuf_read+0x1d4>
ffc0ed2c: 2f 80 00 01 cmpwi cr7,r0,1
ffc0ed30: 40 be 00 20 bne+ cr7,ffc0ed50 <rtems_bdbuf_read+0x148> <== NEVER TAKEN
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
ffc0ed34: 38 00 00 09 li r0,9
ffc0ed38: 90 03 00 28 stw r0,40(r3)
ffc0ed3c: 7f ba eb 78 mr r26,r29
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;
ffc0ed40: 3b 20 00 01 li r25,1
rtems_blkdev_bnum block,
size_t bds_per_group)
{
rtems_bdbuf_buffer *bd = NULL;
bd = rtems_bdbuf_avl_search (&bdbuf_cache.tree, dev, block);
ffc0ed44: 3e 40 00 00 lis r18,0
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
ffc0ed48: 3a 60 00 09 li r19,9
ffc0ed4c: 48 00 00 84 b ffc0edd0 <rtems_bdbuf_read+0x1c8>
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);
ffc0ed50: 3c 80 42 00 lis r4,16896 <== NOT EXECUTED
ffc0ed54: 80 63 00 28 lwz r3,40(r3) <== NOT EXECUTED
ffc0ed58: 60 84 00 1d ori r4,r4,29 <== NOT EXECUTED
ffc0ed5c: 48 00 00 fc b ffc0ee58 <rtems_bdbuf_read+0x250> <== NOT EXECUTED
rtems_blkdev_bnum block,
size_t bds_per_group)
{
rtems_bdbuf_buffer *bd = NULL;
bd = rtems_bdbuf_avl_search (&bdbuf_cache.tree, dev, block);
ffc0ed60: 39 32 2a 08 addi r9,r18,10760
break;
}
while (transfer_index < transfer_count)
{
media_block += media_block_count;
ffc0ed64: 7f 7b 8a 14 add r27,r27,r17
rtems_blkdev_bnum block,
size_t bds_per_group)
{
rtems_bdbuf_buffer *bd = NULL;
bd = rtems_bdbuf_avl_search (&bdbuf_cache.tree, dev, block);
ffc0ed68: 80 69 00 40 lwz r3,64(r9)
ffc0ed6c: 7e 85 a3 78 mr r5,r20
ffc0ed70: 7e a6 ab 78 mr r6,r21
ffc0ed74: 7f 67 db 78 mr r7,r27
ffc0ed78: 4b ff e4 75 bl ffc0d1ec <rtems_bdbuf_avl_search.isra.1>
if (bd == NULL)
ffc0ed7c: 2f 83 00 00 cmpwi cr7,r3,0
ffc0ed80: 40 be 00 58 bne+ cr7,ffc0edd8 <rtems_bdbuf_read+0x1d0> <== NEVER TAKEN
{
bd = rtems_bdbuf_get_buffer_from_lru_list (dev, block, bds_per_group);
ffc0ed84: 7e 83 a3 78 mr r3,r20
ffc0ed88: 7e a4 ab 78 mr r4,r21
ffc0ed8c: 7f 65 db 78 mr r5,r27
ffc0ed90: 7e c6 b3 78 mr r6,r22
ffc0ed94: 4b ff f4 19 bl ffc0e1ac <rtems_bdbuf_get_buffer_from_lru_list>
ffc0ed98: 3b 5a 00 10 addi r26,r26,16
if (bd != NULL)
ffc0ed9c: 2c 03 00 00 cmpwi r3,0
ffc0eda0: 41 82 00 38 beq- ffc0edd8 <rtems_bdbuf_read+0x1d0> <== ALWAYS TAKEN
}
static void
rtems_bdbuf_group_obtain (rtems_bdbuf_buffer *bd)
{
++bd->group->users;
ffc0eda4: 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;
ffc0eda8: 3b 39 00 01 addi r25,r25,1 <== NOT EXECUTED
}
static void
rtems_bdbuf_group_obtain (rtems_bdbuf_buffer *bd)
{
++bd->group->users;
ffc0edac: 81 69 00 0c lwz r11,12(r9) <== NOT EXECUTED
ffc0edb0: 38 0b 00 01 addi r0,r11,1 <== NOT EXECUTED
ffc0edb4: 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;
ffc0edb8: 92 63 00 28 stw r19,40(r3) <== NOT EXECUTED
if (bd == NULL)
break;
rtems_bdbuf_set_state (bd, RTEMS_BDBUF_STATE_TRANSFER);
req->bufs [transfer_index].user = bd;
ffc0edbc: 90 7a 00 24 stw r3,36(r26) <== NOT EXECUTED
req->bufs [transfer_index].block = media_block;
ffc0edc0: 93 7a 00 18 stw r27,24(r26) <== NOT EXECUTED
req->bufs [transfer_index].length = block_size;
ffc0edc4: 92 fa 00 1c stw r23,28(r26) <== NOT EXECUTED
req->bufs [transfer_index].buffer = bd->buffer;
ffc0edc8: 80 03 00 24 lwz r0,36(r3) <== NOT EXECUTED
ffc0edcc: 90 1a 00 20 stw r0,32(r26) <== NOT EXECUTED
default:
rtems_bdbuf_fatal (bd->state, RTEMS_BLKDEV_FATAL_BDBUF_STATE_1);
break;
}
while (transfer_index < transfer_count)
ffc0edd0: 7f 99 c0 40 cmplw cr7,r25,r24
ffc0edd4: 41 9c ff 8c blt+ cr7,ffc0ed60 <rtems_bdbuf_read+0x158>
rtems_bdbuf_show_users ("read-ahead", bd);
++transfer_index;
}
req->bufnum = transfer_index;
ffc0edd8: 93 3d 00 10 stw r25,16(r29)
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)
ffc0eddc: 80 1d 00 10 lwz r0,16(r29)
ffc0ede0: 2f 80 00 00 cmpwi cr7,r0,0
ffc0ede4: 41 be 00 34 beq+ cr7,ffc0ee18 <rtems_bdbuf_read+0x210>
{
sc = rtems_bdbuf_execute_transfer_request (dd, req, true);
ffc0ede8: 80 7f 00 10 lwz r3,16(r31)
ffc0edec: 7f a4 eb 78 mr r4,r29
ffc0edf0: 38 a0 00 01 li r5,1
ffc0edf4: 4b ff ec b5 bl ffc0daa8 <rtems_bdbuf_execute_transfer_request>
if (sc == RTEMS_SUCCESSFUL)
ffc0edf8: 7c 7d 1b 79 mr. r29,r3
ffc0edfc: 40 a2 00 7c bne+ ffc0ee78 <rtems_bdbuf_read+0x270>
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
ffc0ee00: 7f 83 e3 78 mr r3,r28
ffc0ee04: 4b ff aa 89 bl ffc0988c <_Chain_Extract>
}
static void
rtems_bdbuf_group_obtain (rtems_bdbuf_buffer *bd)
{
++bd->group->users;
ffc0ee08: 81 3c 00 30 lwz r9,48(r28)
ffc0ee0c: 81 69 00 0c lwz r11,12(r9)
ffc0ee10: 38 0b 00 01 addi r0,r11,1
ffc0ee14: 90 09 00 0c stw r0,12(r9)
}
}
if (sc == RTEMS_SUCCESSFUL)
{
switch (bd->state)
ffc0ee18: 80 1c 00 28 lwz r0,40(r28)
ffc0ee1c: 2f 80 00 02 cmpwi cr7,r0,2
ffc0ee20: 41 9e 00 10 beq- cr7,ffc0ee30 <rtems_bdbuf_read+0x228>
ffc0ee24: 2f 80 00 07 cmpwi cr7,r0,7
ffc0ee28: 40 be 00 24 bne+ cr7,ffc0ee4c <rtems_bdbuf_read+0x244> <== NEVER TAKEN
ffc0ee2c: 48 00 00 0c b ffc0ee38 <rtems_bdbuf_read+0x230>
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
ffc0ee30: 38 00 00 03 li r0,3
ffc0ee34: 48 00 00 08 b ffc0ee3c <rtems_bdbuf_read+0x234>
ffc0ee38: 38 00 00 04 li r0,4
ffc0ee3c: 90 1c 00 28 stw r0,40(r28)
{
rtems_bdbuf_show_users ("read", bd);
rtems_bdbuf_show_usage ();
}
*bd_ptr = bd;
ffc0ee40: 3b a0 00 00 li r29,0
ffc0ee44: 93 9e 00 00 stw r28,0(r30)
ffc0ee48: 48 00 00 14 b ffc0ee5c <rtems_bdbuf_read+0x254>
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);
ffc0ee4c: 3c 80 42 00 lis r4,16896 <== NOT EXECUTED
ffc0ee50: 80 7c 00 28 lwz r3,40(r28) <== NOT EXECUTED
ffc0ee54: 60 84 00 02 ori r4,r4,2 <== NOT EXECUTED
ffc0ee58: 4b ff de 79 bl ffc0ccd0 <rtems_bdbuf_fatal> <== NOT EXECUTED
*bd_ptr = bd;
}
else
*bd_ptr = NULL;
rtems_bdbuf_unlock_cache ();
ffc0ee5c: 4b ff e0 45 bl ffc0cea0 <rtems_bdbuf_unlock_cache>
rtems_bdbuf_release_disk (dd);
ffc0ee60: 80 7f 00 10 lwz r3,16(r31)
ffc0ee64: 4b ff e0 b5 bl ffc0cf18 <rtems_bdbuf_release_disk>
return sc;
ffc0ee68: 7f a0 eb 78 mr r0,r29
}
ffc0ee6c: 39 7f 00 58 addi r11,r31,88
ffc0ee70: 7c 03 03 78 mr r3,r0
ffc0ee74: 48 00 a6 6c b ffc194e0 <_restgpr_17_x>
}
*bd_ptr = bd;
}
else
*bd_ptr = NULL;
ffc0ee78: 38 00 00 00 li r0,0
ffc0ee7c: 90 1e 00 00 stw r0,0(r30)
ffc0ee80: 4b ff ff dc b ffc0ee5c <rtems_bdbuf_read+0x254>
ffc0ee84 <rtems_bdbuf_release>:
return RTEMS_SUCCESSFUL;
}
rtems_status_code
rtems_bdbuf_release (rtems_bdbuf_buffer *bd)
{
ffc0ee84: 94 21 ff f0 stwu r1,-16(r1)
ffc0ee88: 7c 08 02 a6 mflr r0
ffc0ee8c: bf c1 00 08 stmw 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)
ffc0ee90: 3f c0 00 00 lis r30,0
ffc0ee94: 3b de 2a 08 addi r30,r30,10760
return RTEMS_SUCCESSFUL;
}
rtems_status_code
rtems_bdbuf_release (rtems_bdbuf_buffer *bd)
{
ffc0ee98: 90 01 00 14 stw r0,20(r1)
ffc0ee9c: 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)
return RTEMS_NOT_CONFIGURED;
ffc0eea0: 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)
ffc0eea4: 88 1e 00 88 lbz r0,136(r30)
ffc0eea8: 2f 80 00 00 cmpwi cr7,r0,0
ffc0eeac: 41 9e 00 b4 beq- cr7,ffc0ef60 <rtems_bdbuf_release+0xdc><== NEVER TAKEN
return RTEMS_NOT_CONFIGURED;
if (bd == NULL)
ffc0eeb0: 2f 9f 00 00 cmpwi cr7,r31,0
ffc0eeb4: 41 9e 00 34 beq- cr7,ffc0eee8 <rtems_bdbuf_release+0x64><== NEVER TAKEN
if (rtems_bdbuf_tracer)
{
printf ("bdbuf:%s: %" PRIu32 "\n", kind, bd->block);
rtems_bdbuf_show_users (kind, bd);
}
rtems_bdbuf_lock_cache();
ffc0eeb8: 4b ff dd 91 bl ffc0cc48 <rtems_bdbuf_lock_cache>
sc = rtems_bdbuf_check_bd_and_lock_cache (bd, "release");
if (sc != RTEMS_SUCCESSFUL)
return sc;
switch (bd->state)
ffc0eebc: 80 1f 00 28 lwz r0,40(r31)
ffc0eec0: 2f 80 00 04 cmpwi cr7,r0,4
ffc0eec4: 41 9e 00 78 beq- cr7,ffc0ef3c <rtems_bdbuf_release+0xb8>
ffc0eec8: 2b 80 00 04 cmplwi cr7,r0,4
ffc0eecc: 41 9d 00 10 bgt- cr7,ffc0eedc <rtems_bdbuf_release+0x58>
ffc0eed0: 2f 80 00 03 cmpwi cr7,r0,3
ffc0eed4: 40 be 00 74 bne+ cr7,ffc0ef48 <rtems_bdbuf_release+0xc4><== NEVER TAKEN
ffc0eed8: 48 00 00 18 b ffc0eef0 <rtems_bdbuf_release+0x6c>
ffc0eedc: 2b 80 00 06 cmplwi cr7,r0,6
ffc0eee0: 41 9d 00 68 bgt- cr7,ffc0ef48 <rtems_bdbuf_release+0xc4><== NEVER TAKEN
ffc0eee4: 48 00 00 4c b ffc0ef30 <rtems_bdbuf_release+0xac>
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;
ffc0eee8: 38 60 00 09 li r3,9 <== NOT EXECUTED
ffc0eeec: 48 00 00 74 b ffc0ef60 <rtems_bdbuf_release+0xdc> <== NOT EXECUTED
}
static void
rtems_bdbuf_group_release (rtems_bdbuf_buffer *bd)
{
--bd->group->users;
ffc0eef0: 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 );
ffc0eef4: 38 7e 00 44 addi r3,r30,68
ffc0eef8: 7f e4 fb 78 mr r4,r31
ffc0eefc: 81 69 00 0c lwz r11,12(r9)
ffc0ef00: 38 0b ff ff addi r0,r11,-1
ffc0ef04: 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;
ffc0ef08: 38 00 00 02 li r0,2
ffc0ef0c: 90 1f 00 28 stw r0,40(r31)
ffc0ef10: 4b ff a9 4d bl ffc0985c <_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)
ffc0ef14: 80 1f 00 2c lwz r0,44(r31)
rtems_bdbuf_wake (&bdbuf_cache.access_waiters);
ffc0ef18: 38 7e 00 68 addi r3,r30,104
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)
ffc0ef1c: 2f 80 00 00 cmpwi cr7,r0,0
ffc0ef20: 40 9e 00 08 bne- cr7,ffc0ef28 <rtems_bdbuf_release+0xa4>
rtems_bdbuf_wake (&bdbuf_cache.access_waiters);
else
rtems_bdbuf_wake (&bdbuf_cache.buffer_waiters);
ffc0ef24: 38 7e 00 78 addi r3,r30,120
ffc0ef28: 4b ff e3 29 bl ffc0d250 <rtems_bdbuf_wake>
ffc0ef2c: 48 00 00 2c b ffc0ef58 <rtems_bdbuf_release+0xd4>
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);
ffc0ef30: 7f e3 fb 78 mr r3,r31
ffc0ef34: 4b ff e9 1d bl ffc0d850 <rtems_bdbuf_discard_buffer_after_access>
break;
ffc0ef38: 48 00 00 20 b ffc0ef58 <rtems_bdbuf_release+0xd4>
case RTEMS_BDBUF_STATE_ACCESS_MODIFIED:
rtems_bdbuf_add_to_modified_list_after_access (bd);
ffc0ef3c: 7f e3 fb 78 mr r3,r31
ffc0ef40: 4b ff e3 55 bl ffc0d294 <rtems_bdbuf_add_to_modified_list_after_access>
break;
ffc0ef44: 48 00 00 14 b ffc0ef58 <rtems_bdbuf_release+0xd4>
default:
rtems_bdbuf_fatal (bd->state, RTEMS_BLKDEV_FATAL_BDBUF_STATE_0);
ffc0ef48: 3c 80 42 00 lis r4,16896 <== NOT EXECUTED
ffc0ef4c: 80 7f 00 28 lwz r3,40(r31) <== NOT EXECUTED
ffc0ef50: 60 84 00 1c ori r4,r4,28 <== NOT EXECUTED
ffc0ef54: 4b ff dd 7d bl ffc0ccd0 <rtems_bdbuf_fatal> <== NOT EXECUTED
}
if (rtems_bdbuf_tracer)
rtems_bdbuf_show_usage ();
rtems_bdbuf_unlock_cache ();
ffc0ef58: 4b ff df 49 bl ffc0cea0 <rtems_bdbuf_unlock_cache>
return RTEMS_SUCCESSFUL;
ffc0ef5c: 38 60 00 00 li r3,0
}
ffc0ef60: 39 61 00 10 addi r11,r1,16
ffc0ef64: 48 00 a5 b0 b ffc19514 <_restgpr_30_x>
ffc0cf18 <rtems_bdbuf_release_disk>:
return RTEMS_SUCCESSFUL;
}
static void
rtems_bdbuf_release_disk (rtems_disk_device *dd)
{
ffc0cf18: 94 21 ff f8 stwu r1,-8(r1)
ffc0cf1c: 7c 08 02 a6 mflr r0
ffc0cf20: 90 01 00 0c stw r0,12(r1)
rtems_status_code sc = RTEMS_SUCCESSFUL;
sc = rtems_disk_release (dd);
ffc0cf24: 4b ff 76 65 bl ffc04588 <rtems_disk_release>
if (sc != RTEMS_SUCCESSFUL)
ffc0cf28: 2f 83 00 00 cmpwi cr7,r3,0
ffc0cf2c: 41 be 00 10 beq+ cr7,ffc0cf3c <rtems_bdbuf_release_disk+0x24><== ALWAYS TAKEN
rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_DISK_REL);
ffc0cf30: 3c 60 42 00 lis r3,16896 <== NOT EXECUTED
ffc0cf34: 60 63 00 1f ori r3,r3,31 <== NOT EXECUTED
ffc0cf38: 4b ff c3 6d bl ffc092a4 <rtems_fatal_error_occurred> <== NOT EXECUTED
}
ffc0cf3c: 80 01 00 0c lwz r0,12(r1)
ffc0cf40: 38 21 00 08 addi r1,r1,8
ffc0cf44: 7c 08 03 a6 mtlr r0
ffc0cf48: 4e 80 00 20 blr
ffc0ef68 <rtems_bdbuf_release_modified>:
}
static rtems_status_code
rtems_bdbuf_check_bd_and_lock_cache (rtems_bdbuf_buffer *bd, const char *kind)
{
if (!bdbuf_cache.initialised)
ffc0ef68: 3d 20 00 00 lis r9,0
return RTEMS_SUCCESSFUL;
}
rtems_status_code
rtems_bdbuf_release_modified (rtems_bdbuf_buffer *bd)
{
ffc0ef6c: 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)
ffc0ef70: 89 29 2a 90 lbz r9,10896(r9)
return RTEMS_SUCCESSFUL;
}
rtems_status_code
rtems_bdbuf_release_modified (rtems_bdbuf_buffer *bd)
{
ffc0ef74: 94 21 ff f0 stwu r1,-16(r1)
}
static rtems_status_code
rtems_bdbuf_check_bd_and_lock_cache (rtems_bdbuf_buffer *bd, const char *kind)
{
if (!bdbuf_cache.initialised)
ffc0ef78: 2f 89 00 00 cmpwi cr7,r9,0
return RTEMS_SUCCESSFUL;
}
rtems_status_code
rtems_bdbuf_release_modified (rtems_bdbuf_buffer *bd)
{
ffc0ef7c: 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)
return RTEMS_NOT_CONFIGURED;
ffc0ef80: 38 00 00 16 li r0,22
}
static rtems_status_code
rtems_bdbuf_check_bd_and_lock_cache (rtems_bdbuf_buffer *bd, const char *kind)
{
if (!bdbuf_cache.initialised)
ffc0ef84: 41 9e 00 68 beq- cr7,ffc0efec <rtems_bdbuf_release_modified+0x84><== NEVER TAKEN
return RTEMS_NOT_CONFIGURED;
if (bd == NULL)
ffc0ef88: 2f 83 00 00 cmpwi cr7,r3,0
ffc0ef8c: 41 9e 00 30 beq- cr7,ffc0efbc <rtems_bdbuf_release_modified+0x54><== NEVER TAKEN
if (rtems_bdbuf_tracer)
{
printf ("bdbuf:%s: %" PRIu32 "\n", kind, bd->block);
rtems_bdbuf_show_users (kind, bd);
}
rtems_bdbuf_lock_cache();
ffc0ef90: 90 61 00 08 stw r3,8(r1)
ffc0ef94: 4b ff dc b5 bl ffc0cc48 <rtems_bdbuf_lock_cache>
sc = rtems_bdbuf_check_bd_and_lock_cache (bd, "release modified");
if (sc != RTEMS_SUCCESSFUL)
return sc;
switch (bd->state)
ffc0ef98: 80 61 00 08 lwz r3,8(r1)
ffc0ef9c: 80 03 00 28 lwz r0,40(r3)
ffc0efa0: 2b 80 00 03 cmplwi cr7,r0,3
ffc0efa4: 41 9c 00 30 blt- cr7,ffc0efd4 <rtems_bdbuf_release_modified+0x6c><== NEVER TAKEN
ffc0efa8: 2b 80 00 05 cmplwi cr7,r0,5
ffc0efac: 40 9d 00 18 ble- cr7,ffc0efc4 <rtems_bdbuf_release_modified+0x5c>
ffc0efb0: 2f 80 00 06 cmpwi cr7,r0,6
ffc0efb4: 40 be 00 20 bne+ cr7,ffc0efd4 <rtems_bdbuf_release_modified+0x6c><== NEVER TAKEN
ffc0efb8: 48 00 00 14 b ffc0efcc <rtems_bdbuf_release_modified+0x64>
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;
ffc0efbc: 38 00 00 09 li r0,9 <== NOT EXECUTED
ffc0efc0: 48 00 00 2c b ffc0efec <rtems_bdbuf_release_modified+0x84><== 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);
ffc0efc4: 4b ff e2 d1 bl ffc0d294 <rtems_bdbuf_add_to_modified_list_after_access>
break;
ffc0efc8: 48 00 00 1c b ffc0efe4 <rtems_bdbuf_release_modified+0x7c>
case RTEMS_BDBUF_STATE_ACCESS_PURGED:
rtems_bdbuf_discard_buffer_after_access (bd);
ffc0efcc: 4b ff e8 85 bl ffc0d850 <rtems_bdbuf_discard_buffer_after_access>
break;
ffc0efd0: 48 00 00 14 b ffc0efe4 <rtems_bdbuf_release_modified+0x7c>
default:
rtems_bdbuf_fatal (bd->state, RTEMS_BLKDEV_FATAL_BDBUF_STATE_6);
ffc0efd4: 3c 80 42 00 lis r4,16896 <== NOT EXECUTED
ffc0efd8: 80 63 00 28 lwz r3,40(r3) <== NOT EXECUTED
ffc0efdc: 60 84 00 04 ori r4,r4,4 <== NOT EXECUTED
ffc0efe0: 4b ff dc f1 bl ffc0ccd0 <rtems_bdbuf_fatal> <== NOT EXECUTED
}
if (rtems_bdbuf_tracer)
rtems_bdbuf_show_usage ();
rtems_bdbuf_unlock_cache ();
ffc0efe4: 4b ff de bd bl ffc0cea0 <rtems_bdbuf_unlock_cache>
return RTEMS_SUCCESSFUL;
ffc0efe8: 38 00 00 00 li r0,0
}
ffc0efec: 7c 03 03 78 mr r3,r0
ffc0eff0: 80 01 00 14 lwz r0,20(r1)
ffc0eff4: 38 21 00 10 addi r1,r1,16
ffc0eff8: 7c 08 03 a6 mtlr r0
ffc0effc: 4e 80 00 20 blr
ffc0d46c <rtems_bdbuf_remove_from_tree>:
return bdbuf_cache.buffer_waiters.count;
}
static void
rtems_bdbuf_remove_from_tree (rtems_bdbuf_buffer *bd)
{
ffc0d46c: 94 21 ff 60 stwu r1,-160(r1)
ffc0d470: 7c 08 02 a6 mflr r0
const rtems_bdbuf_buffer* node)
{
dev_t dev = node->dev;
rtems_blkdev_bnum block = node->block;
rtems_bdbuf_buffer* p = *root;
ffc0d474: 3d 20 00 00 lis r9,0
return bdbuf_cache.buffer_waiters.count;
}
static void
rtems_bdbuf_remove_from_tree (rtems_bdbuf_buffer *bd)
{
ffc0d478: 90 01 00 a4 stw r0,164(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));
ffc0d47c: 38 80 00 00 li r4,0
ffc0d480: 38 a0 00 80 li r5,128
return bdbuf_cache.buffer_waiters.count;
}
static void
rtems_bdbuf_remove_from_tree (rtems_bdbuf_buffer *bd)
{
ffc0d484: bf 61 00 8c stmw r27,140(r1)
ffc0d488: 7c 7e 1b 78 mr r30,r3
*/
static int
rtems_bdbuf_avl_remove(rtems_bdbuf_buffer** root,
const rtems_bdbuf_buffer* node)
{
dev_t dev = node->dev;
ffc0d48c: 83 a3 00 18 lwz r29,24(r3)
ffc0d490: 83 63 00 1c lwz r27,28(r3)
rtems_blkdev_bnum block = node->block;
ffc0d494: 83 83 00 20 lwz r28,32(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));
ffc0d498: 38 61 00 08 addi r3,r1,8
const rtems_bdbuf_buffer* node)
{
dev_t dev = node->dev;
rtems_blkdev_bnum block = node->block;
rtems_bdbuf_buffer* p = *root;
ffc0d49c: 83 e9 2a 48 lwz r31,10824(r9)
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));
ffc0d4a0: 48 00 7e ad bl ffc1534c <memset>
rtems_bdbuf_buffer* r;
rtems_bdbuf_buffer* s;
rtems_bdbuf_buffer* p1;
rtems_bdbuf_buffer* p2;
rtems_bdbuf_buffer* buf_stack[RTEMS_BDBUF_AVL_MAX_HEIGHT];
rtems_bdbuf_buffer** buf_prev = buf_stack;
ffc0d4a4: 39 41 00 08 addi r10,r1,8
{
*buf_prev++ = p;
if ((p->dev < dev) || ((p->dev == dev) && (p->block < block)))
{
p->avl.cache = 1;
ffc0d4a8: 38 e0 00 01 li r7,1
p = p->avl.right;
}
else if ((p->dev != dev) || (p->block != block))
{
p->avl.cache = -1;
ffc0d4ac: 39 60 ff ff li r11,-1
ffc0d4b0: 48 00 00 68 b ffc0d518 <rtems_bdbuf_remove_from_tree+0xac>
while (p != NULL)
{
*buf_prev++ = p;
if ((p->dev < dev) || ((p->dev == dev) && (p->block < block)))
ffc0d4b4: 80 1f 00 18 lwz r0,24(r31)
memset (buf_stack, 0, sizeof(buf_stack));
while (p != NULL)
{
*buf_prev++ = p;
ffc0d4b8: 39 0a 00 04 addi r8,r10,4
ffc0d4bc: 93 ea 00 00 stw r31,0(r10)
if ((p->dev < dev) || ((p->dev == dev) && (p->block < block)))
ffc0d4c0: 7f 9d 00 40 cmplw cr7,r29,r0
ffc0d4c4: 81 3f 00 1c lwz r9,28(r31)
ffc0d4c8: 41 9d 00 30 bgt- cr7,ffc0d4f8 <rtems_bdbuf_remove_from_tree+0x8c><== NEVER TAKEN
ffc0d4cc: 7f 9d 00 00 cmpw cr7,r29,r0
ffc0d4d0: 40 9e 00 0c bne- cr7,ffc0d4dc <rtems_bdbuf_remove_from_tree+0x70><== NEVER TAKEN
ffc0d4d4: 7f 9b 48 40 cmplw cr7,r27,r9
ffc0d4d8: 41 9d 00 20 bgt- cr7,ffc0d4f8 <rtems_bdbuf_remove_from_tree+0x8c><== NEVER TAKEN
ffc0d4dc: 7f 80 e8 00 cmpw cr7,r0,r29
ffc0d4e0: 40 be 00 2c bne+ cr7,ffc0d50c <rtems_bdbuf_remove_from_tree+0xa0><== NEVER TAKEN
ffc0d4e4: 7f 89 d8 00 cmpw cr7,r9,r27
ffc0d4e8: 40 be 00 24 bne+ cr7,ffc0d50c <rtems_bdbuf_remove_from_tree+0xa0><== NEVER TAKEN
ffc0d4ec: 80 1f 00 20 lwz r0,32(r31)
ffc0d4f0: 7f 80 e0 40 cmplw cr7,r0,r28
ffc0d4f4: 40 9c 00 10 bge- cr7,ffc0d504 <rtems_bdbuf_remove_from_tree+0x98>
{
p->avl.cache = 1;
ffc0d4f8: 98 ff 00 10 stb r7,16(r31)
p = p->avl.right;
ffc0d4fc: 83 ff 00 0c lwz r31,12(r31)
ffc0d500: 48 00 00 14 b ffc0d514 <rtems_bdbuf_remove_from_tree+0xa8>
}
else if ((p->dev != dev) || (p->block != block))
ffc0d504: 7f 80 e0 00 cmpw cr7,r0,r28
ffc0d508: 41 9e 00 1c beq- cr7,ffc0d524 <rtems_bdbuf_remove_from_tree+0xb8>
{
p->avl.cache = -1;
ffc0d50c: 99 7f 00 10 stb r11,16(r31)
p = p->avl.left;
ffc0d510: 83 ff 00 08 lwz r31,8(r31)
memset (buf_stack, 0, sizeof(buf_stack));
while (p != NULL)
{
*buf_prev++ = p;
ffc0d514: 7d 0a 43 78 mr r10,r8
bool modified = false;
memset (buf_stack, 0, sizeof(buf_stack));
while (p != NULL)
ffc0d518: 2f 9f 00 00 cmpwi cr7,r31,0
ffc0d51c: 40 9e ff 98 bne+ cr7,ffc0d4b4 <rtems_bdbuf_remove_from_tree+0x48><== ALWAYS TAKEN
ffc0d520: 48 00 02 c4 b ffc0d7e4 <rtems_bdbuf_remove_from_tree+0x378><== NOT EXECUTED
}
q = p;
buf_prev--;
if (buf_prev > buf_stack)
ffc0d524: 38 01 00 08 addi r0,r1,8
ffc0d528: 7f 8a 00 40 cmplw cr7,r10,r0
{
p = *(buf_prev - 1);
}
else
{
p = NULL;
ffc0d52c: 38 e0 00 00 li r7,0
}
q = p;
buf_prev--;
if (buf_prev > buf_stack)
ffc0d530: 40 9d 00 08 ble- cr7,ffc0d538 <rtems_bdbuf_remove_from_tree+0xcc>
{
p = *(buf_prev - 1);
ffc0d534: 80 e8 ff f8 lwz r7,-8(r8)
{
p = NULL;
}
/* at this moment q - is a node to delete, p is q's parent */
if (q->avl.right == NULL)
ffc0d538: 81 3f 00 0c lwz r9,12(r31)
ffc0d53c: 2f 89 00 00 cmpwi cr7,r9,0
ffc0d540: 40 be 00 1c bne+ cr7,ffc0d55c <rtems_bdbuf_remove_from_tree+0xf0>
{
r = q->avl.left;
ffc0d544: 81 3f 00 08 lwz r9,8(r31)
if (r != NULL)
ffc0d548: 2f 89 00 00 cmpwi cr7,r9,0
ffc0d54c: 41 9e 00 a0 beq- cr7,ffc0d5ec <rtems_bdbuf_remove_from_tree+0x180>
{
r->avl.bal = 0;
ffc0d550: 38 00 00 00 li r0,0
ffc0d554: 98 09 00 11 stb r0,17(r9)
ffc0d558: 48 00 00 94 b ffc0d5ec <rtems_bdbuf_remove_from_tree+0x180>
{
rtems_bdbuf_buffer **t;
r = q->avl.right;
if (r->avl.left == NULL)
ffc0d55c: 80 09 00 08 lwz r0,8(r9)
ffc0d560: 2f 80 00 00 cmpwi cr7,r0,0
ffc0d564: 41 9e 00 18 beq- cr7,ffc0d57c <rtems_bdbuf_remove_from_tree+0x110>
ffc0d568: 7d 2b 4b 78 mr r11,r9
ffc0d56c: 7d 26 4b 78 mr r6,r9
ffc0d570: 7d 0a 43 78 mr r10,r8
while (s->avl.left != NULL)
{
*buf_prev++ = r = s;
s = r->avl.left;
r->avl.cache = -1;
ffc0d574: 38 a0 ff ff li r5,-1
ffc0d578: 48 00 00 3c b ffc0d5b4 <rtems_bdbuf_remove_from_tree+0x148>
r = q->avl.right;
if (r->avl.left == NULL)
{
r->avl.left = q->avl.left;
ffc0d57c: 80 1f 00 08 lwz r0,8(r31)
r->avl.bal = q->avl.bal;
r->avl.cache = 1;
*buf_prev++ = q = r;
ffc0d580: 7d 0a 43 78 mr r10,r8
ffc0d584: 91 28 ff fc stw r9,-4(r8)
r = q->avl.right;
if (r->avl.left == NULL)
{
r->avl.left = q->avl.left;
ffc0d588: 90 09 00 08 stw r0,8(r9)
r->avl.bal = q->avl.bal;
ffc0d58c: 88 1f 00 11 lbz r0,17(r31)
ffc0d590: 98 09 00 11 stb r0,17(r9)
r->avl.cache = 1;
ffc0d594: 38 00 00 01 li r0,1
ffc0d598: 98 09 00 10 stb r0,16(r9)
ffc0d59c: 48 00 00 50 b ffc0d5ec <rtems_bdbuf_remove_from_tree+0x180>
t = buf_prev++;
s = r;
while (s->avl.left != NULL)
{
*buf_prev++ = r = s;
ffc0d5a0: 91 6a 00 00 stw r11,0(r10)
s = r->avl.left;
r->avl.cache = -1;
ffc0d5a4: 7d 66 5b 78 mr r6,r11
t = buf_prev++;
s = r;
while (s->avl.left != NULL)
{
*buf_prev++ = r = s;
ffc0d5a8: 39 4a 00 04 addi r10,r10,4
s = r->avl.left;
r->avl.cache = -1;
ffc0d5ac: 98 ab 00 10 stb r5,16(r11)
ffc0d5b0: 7c 0b 03 78 mr r11,r0
else
{
t = buf_prev++;
s = r;
while (s->avl.left != NULL)
ffc0d5b4: 80 0b 00 08 lwz r0,8(r11)
ffc0d5b8: 2f 80 00 00 cmpwi cr7,r0,0
ffc0d5bc: 40 9e ff e4 bne+ cr7,ffc0d5a0 <rtems_bdbuf_remove_from_tree+0x134>
*buf_prev++ = r = s;
s = r->avl.left;
r->avl.cache = -1;
}
s->avl.left = q->avl.left;
ffc0d5c0: 80 1f 00 08 lwz r0,8(r31)
r->avl.left = s->avl.right;
s->avl.right = q->avl.right;
s->avl.bal = q->avl.bal;
s->avl.cache = 1;
*t = q = s;
ffc0d5c4: 91 68 ff fc stw r11,-4(r8)
*buf_prev++ = r = s;
s = r->avl.left;
r->avl.cache = -1;
}
s->avl.left = q->avl.left;
ffc0d5c8: 90 0b 00 08 stw r0,8(r11)
r->avl.left = s->avl.right;
ffc0d5cc: 80 0b 00 0c lwz r0,12(r11)
s->avl.right = q->avl.right;
ffc0d5d0: 91 2b 00 0c stw r9,12(r11)
s->avl.bal = q->avl.bal;
s->avl.cache = 1;
*t = q = s;
ffc0d5d4: 7d 69 5b 78 mr r9,r11
s = r->avl.left;
r->avl.cache = -1;
}
s->avl.left = q->avl.left;
r->avl.left = s->avl.right;
ffc0d5d8: 90 06 00 08 stw r0,8(r6)
s->avl.right = q->avl.right;
s->avl.bal = q->avl.bal;
ffc0d5dc: 88 1f 00 11 lbz r0,17(r31)
ffc0d5e0: 98 0b 00 11 stb r0,17(r11)
s->avl.cache = 1;
ffc0d5e4: 38 00 00 01 li r0,1
ffc0d5e8: 98 0b 00 10 stb r0,16(r11)
*t = q = s;
}
}
if (p != NULL)
ffc0d5ec: 2f 87 00 00 cmpwi cr7,r7,0
ffc0d5f0: 41 9e 00 2c beq- cr7,ffc0d61c <rtems_bdbuf_remove_from_tree+0x1b0>
{
if (p->avl.cache == -1)
ffc0d5f4: 88 07 00 10 lbz r0,16(r7)
ffc0d5f8: 2f 80 00 ff cmpwi cr7,r0,255
ffc0d5fc: 40 be 00 18 bne+ cr7,ffc0d614 <rtems_bdbuf_remove_from_tree+0x1a8>
{
p->avl.left = q;
ffc0d600: 91 27 00 08 stw r9,8(r7)
modified = true;
while (modified)
{
if (buf_prev > buf_stack)
ffc0d604: 38 01 00 08 addi r0,r1,8
ffc0d608: 7f 8a 00 40 cmplw cr7,r10,r0
ffc0d60c: 41 bd 00 1c bgt+ cr7,ffc0d628 <rtems_bdbuf_remove_from_tree+0x1bc>
ffc0d610: 48 00 01 e4 b ffc0d7f4 <rtems_bdbuf_remove_from_tree+0x388>
{
p->avl.left = q;
}
else
{
p->avl.right = q;
ffc0d614: 91 27 00 0c stw r9,12(r7)
ffc0d618: 4b ff ff ec b ffc0d604 <rtems_bdbuf_remove_from_tree+0x198>
}
}
else
{
*root = q;
ffc0d61c: 3d 60 00 00 lis r11,0
ffc0d620: 91 2b 2a 48 stw r9,10824(r11)
ffc0d624: 4b ff ff e0 b ffc0d604 <rtems_bdbuf_remove_from_tree+0x198>
else
{
break;
}
if (p->avl.cache == -1)
ffc0d628: 38 60 ff ff li r3,-1
{
case -1:
p->avl.bal = 0;
break;
case 0:
p->avl.bal = 1;
ffc0d62c: 38 c0 00 01 li r6,1
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;
p2->avl.bal = 0;
ffc0d630: 38 e0 00 00 li r7,0
default:
break;
}
}
if (buf_prev > buf_stack)
ffc0d634: 7c 04 03 78 mr r4,r0
while (modified)
{
if (buf_prev > buf_stack)
{
p = *--buf_prev;
ffc0d638: 81 2a ff fc lwz r9,-4(r10)
else
{
break;
}
if (p->avl.cache == -1)
ffc0d63c: 88 a9 00 10 lbz r5,16(r9)
ffc0d640: 7c a0 07 74 extsb r0,r5
ffc0d644: 2f 80 ff ff cmpwi cr7,r0,-1
ffc0d648: 88 09 00 11 lbz r0,17(r9)
{
/* rebalance left branch */
switch (p->avl.bal)
ffc0d64c: 7c 0b 07 75 extsb. r11,r0
else
{
break;
}
if (p->avl.cache == -1)
ffc0d650: 40 be 00 9c bne+ cr7,ffc0d6ec <rtems_bdbuf_remove_from_tree+0x280>
{
/* rebalance left branch */
switch (p->avl.bal)
ffc0d654: 41 82 00 18 beq- ffc0d66c <rtems_bdbuf_remove_from_tree+0x200>
ffc0d658: 2f 8b 00 01 cmpwi cr7,r11,1
ffc0d65c: 41 9e 00 18 beq- cr7,ffc0d674 <rtems_bdbuf_remove_from_tree+0x208>
ffc0d660: 2f 8b ff ff cmpwi cr7,r11,-1
ffc0d664: 40 be 01 34 bne+ cr7,ffc0d798 <rtems_bdbuf_remove_from_tree+0x32c><== NEVER TAKEN
ffc0d668: 48 00 00 9c b ffc0d704 <rtems_bdbuf_remove_from_tree+0x298>
{
case -1:
p->avl.bal = 0;
break;
case 0:
p->avl.bal = 1;
ffc0d66c: 98 c9 00 11 stb r6,17(r9)
ffc0d670: 48 00 00 2c b ffc0d69c <rtems_bdbuf_remove_from_tree+0x230>
modified = false;
break;
case +1:
p1 = p->avl.right;
ffc0d674: 81 69 00 0c lwz r11,12(r9)
if (p1->avl.bal >= 0) /* simple RR-turn */
ffc0d678: 88 0b 00 11 lbz r0,17(r11)
ffc0d67c: 7c 08 07 75 extsb. r8,r0
ffc0d680: 81 0b 00 08 lwz r8,8(r11)
ffc0d684: 41 80 00 20 blt- ffc0d6a4 <rtems_bdbuf_remove_from_tree+0x238>
{
p->avl.right = p1->avl.left;
ffc0d688: 91 09 00 0c stw r8,12(r9)
p1->avl.left = p;
ffc0d68c: 91 2b 00 08 stw r9,8(r11)
if (p1->avl.bal == 0)
ffc0d690: 40 82 00 ac bne- ffc0d73c <rtems_bdbuf_remove_from_tree+0x2d0>
{
p1->avl.bal = -1;
ffc0d694: 98 ab 00 11 stb r5,17(r11)
ffc0d698: 7d 69 5b 78 mr r9,r11
modified = false;
ffc0d69c: 38 00 00 00 li r0,0
ffc0d6a0: 48 00 00 fc b ffc0d79c <rtems_bdbuf_remove_from_tree+0x330>
}
else /* double RL-turn */
{
p2 = p1->avl.left;
p1->avl.left = p2->avl.right;
ffc0d6a4: 80 08 00 0c lwz r0,12(r8)
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;
ffc0d6a8: 38 a0 00 00 li r5,0
else /* double RL-turn */
{
p2 = p1->avl.left;
p1->avl.left = p2->avl.right;
p2->avl.right = p1;
ffc0d6ac: 91 68 00 0c stw r11,12(r8)
}
else /* double RL-turn */
{
p2 = p1->avl.left;
p1->avl.left = p2->avl.right;
ffc0d6b0: 90 0b 00 08 stw r0,8(r11)
p2->avl.right = p1;
p->avl.right = p2->avl.left;
ffc0d6b4: 80 08 00 08 lwz r0,8(r8)
p2->avl.left = p;
ffc0d6b8: 91 28 00 08 stw r9,8(r8)
{
p2 = p1->avl.left;
p1->avl.left = p2->avl.right;
p2->avl.right = p1;
p->avl.right = p2->avl.left;
ffc0d6bc: 90 09 00 0c stw r0,12(r9)
p2->avl.left = p;
if (p2->avl.bal == +1) p->avl.bal = -1; else p->avl.bal = 0;
ffc0d6c0: 88 08 00 11 lbz r0,17(r8)
ffc0d6c4: 2f 80 00 01 cmpwi cr7,r0,1
ffc0d6c8: 40 be 00 08 bne+ cr7,ffc0d6d0 <rtems_bdbuf_remove_from_tree+0x264>
ffc0d6cc: 38 a0 ff ff li r5,-1
ffc0d6d0: 98 a9 00 11 stb r5,17(r9)
if (p2->avl.bal == -1) p1->avl.bal = 1; else p1->avl.bal = 0;
ffc0d6d4: 88 08 00 11 lbz r0,17(r8)
ffc0d6d8: 68 00 00 ff xori r0,r0,255
ffc0d6dc: 7c 00 00 34 cntlzw r0,r0
ffc0d6e0: 54 00 d9 7e rlwinm r0,r0,27,5,31
ffc0d6e4: 98 0b 00 11 stb r0,17(r11)
ffc0d6e8: 48 00 00 a8 b ffc0d790 <rtems_bdbuf_remove_from_tree+0x324>
}
}
else
{
/* rebalance right branch */
switch (p->avl.bal)
ffc0d6ec: 41 82 00 20 beq- ffc0d70c <rtems_bdbuf_remove_from_tree+0x2a0>
ffc0d6f0: 2f 8b 00 01 cmpwi cr7,r11,1
ffc0d6f4: 41 9e 00 10 beq- cr7,ffc0d704 <rtems_bdbuf_remove_from_tree+0x298>
ffc0d6f8: 2f 8b ff ff cmpwi cr7,r11,-1
ffc0d6fc: 40 be 00 9c bne+ cr7,ffc0d798 <rtems_bdbuf_remove_from_tree+0x32c><== NEVER TAKEN
ffc0d700: 48 00 00 14 b ffc0d714 <rtems_bdbuf_remove_from_tree+0x2a8>
{
case +1:
p->avl.bal = 0;
ffc0d704: 98 e9 00 11 stb r7,17(r9)
ffc0d708: 48 00 00 90 b ffc0d798 <rtems_bdbuf_remove_from_tree+0x32c>
break;
case 0:
p->avl.bal = -1;
ffc0d70c: 98 69 00 11 stb r3,17(r9)
ffc0d710: 4b ff ff 8c b ffc0d69c <rtems_bdbuf_remove_from_tree+0x230>
modified = false;
break;
case -1:
p1 = p->avl.left;
ffc0d714: 81 69 00 08 lwz r11,8(r9)
if (p1->avl.bal <= 0) /* simple LL-turn */
ffc0d718: 88 0b 00 11 lbz r0,17(r11)
ffc0d71c: 7c 08 07 75 extsb. r8,r0
ffc0d720: 81 0b 00 0c lwz r8,12(r11)
ffc0d724: 41 a1 00 28 bgt+ ffc0d74c <rtems_bdbuf_remove_from_tree+0x2e0>
{
p->avl.left = p1->avl.right;
ffc0d728: 91 09 00 08 stw r8,8(r9)
p1->avl.right = p;
ffc0d72c: 91 2b 00 0c stw r9,12(r11)
if (p1->avl.bal == 0)
ffc0d730: 40 82 00 0c bne- ffc0d73c <rtems_bdbuf_remove_from_tree+0x2d0>
{
p1->avl.bal = 1;
ffc0d734: 98 cb 00 11 stb r6,17(r11)
ffc0d738: 4b ff ff 60 b ffc0d698 <rtems_bdbuf_remove_from_tree+0x22c>
modified = false;
}
else
{
p->avl.bal = 0;
ffc0d73c: 98 e9 00 11 stb r7,17(r9)
p1->avl.bal = 0;
ffc0d740: 7d 69 5b 78 mr r9,r11
ffc0d744: 98 eb 00 11 stb r7,17(r11)
ffc0d748: 48 00 00 50 b ffc0d798 <rtems_bdbuf_remove_from_tree+0x32c>
}
else /* double LR-turn */
{
p2 = p1->avl.right;
p1->avl.right = p2->avl.left;
ffc0d74c: 80 08 00 08 lwz r0,8(r8)
p2->avl.left = p1;
ffc0d750: 91 68 00 08 stw r11,8(r8)
}
else /* double LR-turn */
{
p2 = p1->avl.right;
p1->avl.right = p2->avl.left;
ffc0d754: 90 0b 00 0c stw r0,12(r11)
p2->avl.left = p1;
p->avl.left = p2->avl.right;
ffc0d758: 80 08 00 0c lwz r0,12(r8)
p2->avl.right = p;
ffc0d75c: 91 28 00 0c stw r9,12(r8)
{
p2 = p1->avl.right;
p1->avl.right = p2->avl.left;
p2->avl.left = p1;
p->avl.left = p2->avl.right;
ffc0d760: 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;
ffc0d764: 88 08 00 11 lbz r0,17(r8)
ffc0d768: 68 00 00 ff xori r0,r0,255
ffc0d76c: 7c 00 00 34 cntlzw r0,r0
ffc0d770: 54 00 d9 7e rlwinm r0,r0,27,5,31
ffc0d774: 98 09 00 11 stb r0,17(r9)
if (p2->avl.bal == +1) p1->avl.bal = -1; else p1->avl.bal = 0;
ffc0d778: 39 20 00 00 li r9,0
ffc0d77c: 88 08 00 11 lbz r0,17(r8)
ffc0d780: 2f 80 00 01 cmpwi cr7,r0,1
ffc0d784: 40 be 00 08 bne+ cr7,ffc0d78c <rtems_bdbuf_remove_from_tree+0x320>
ffc0d788: 39 20 ff ff li r9,-1
ffc0d78c: 99 2b 00 11 stb r9,17(r11)
p = p2;
p2->avl.bal = 0;
ffc0d790: 98 e8 00 11 stb r7,17(r8)
ffc0d794: 7d 09 43 78 mr r9,r8
}
}
else
{
/* rebalance right branch */
switch (p->avl.bal)
ffc0d798: 38 00 00 01 li r0,1
{
return bdbuf_cache.buffer_waiters.count;
}
static void
rtems_bdbuf_remove_from_tree (rtems_bdbuf_buffer *bd)
ffc0d79c: 39 6a ff fc addi r11,r10,-4
default:
break;
}
}
if (buf_prev > buf_stack)
ffc0d7a0: 7f 84 58 40 cmplw cr7,r4,r11
ffc0d7a4: 40 9c 00 24 bge- cr7,ffc0d7c8 <rtems_bdbuf_remove_from_tree+0x35c>
{
q = *(buf_prev - 1);
ffc0d7a8: 81 6a ff f8 lwz r11,-8(r10)
if (q->avl.cache == -1)
ffc0d7ac: 89 0b 00 10 lbz r8,16(r11)
ffc0d7b0: 2f 88 00 ff cmpwi cr7,r8,255
ffc0d7b4: 40 be 00 0c bne+ cr7,ffc0d7c0 <rtems_bdbuf_remove_from_tree+0x354>
{
q->avl.left = p;
ffc0d7b8: 91 2b 00 08 stw r9,8(r11)
ffc0d7bc: 48 00 00 18 b ffc0d7d4 <rtems_bdbuf_remove_from_tree+0x368>
}
else
{
q->avl.right = p;
ffc0d7c0: 91 2b 00 0c stw r9,12(r11)
ffc0d7c4: 48 00 00 10 b ffc0d7d4 <rtems_bdbuf_remove_from_tree+0x368>
}
}
else
{
*root = p;
ffc0d7c8: 3d 60 00 00 lis r11,0
ffc0d7cc: 91 2b 2a 48 stw r9,10824(r11)
ffc0d7d0: 48 00 00 24 b ffc0d7f4 <rtems_bdbuf_remove_from_tree+0x388>
*root = q;
}
modified = true;
while (modified)
ffc0d7d4: 2f 80 00 00 cmpwi cr7,r0,0
q->avl.right = p;
}
}
else
{
*root = p;
ffc0d7d8: 39 4a ff fc addi r10,r10,-4
*root = q;
}
modified = true;
while (modified)
ffc0d7dc: 40 9e fe 5c bne+ cr7,ffc0d638 <rtems_bdbuf_remove_from_tree+0x1cc>
ffc0d7e0: 48 00 00 14 b ffc0d7f4 <rtems_bdbuf_remove_from_tree+0x388>
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);
ffc0d7e4: 3c 80 42 00 lis r4,16896 <== NOT EXECUTED
ffc0d7e8: 80 7e 00 28 lwz r3,40(r30) <== NOT EXECUTED
ffc0d7ec: 60 84 00 09 ori r4,r4,9 <== NOT EXECUTED
ffc0d7f0: 4b ff f4 e1 bl ffc0ccd0 <rtems_bdbuf_fatal> <== NOT EXECUTED
}
ffc0d7f4: 39 61 00 a0 addi r11,r1,160
ffc0d7f8: 48 00 bd 10 b ffc19508 <_restgpr_27_x>
ffc0d7fc <rtems_bdbuf_remove_from_tree_and_lru_list>:
static void
rtems_bdbuf_remove_from_tree_and_lru_list (rtems_bdbuf_buffer *bd)
{
ffc0d7fc: 7c 08 02 a6 mflr r0
ffc0d800: 7c 2b 0b 78 mr r11,r1
ffc0d804: 94 21 ff f0 stwu r1,-16(r1)
ffc0d808: 90 01 00 14 stw r0,20(r1)
ffc0d80c: 48 00 bc c1 bl ffc194cc <_savegpr_31>
ffc0d810: 7c 7f 1b 78 mr r31,r3
switch (bd->state)
ffc0d814: 80 03 00 28 lwz r0,40(r3)
ffc0d818: 2f 80 00 00 cmpwi cr7,r0,0
ffc0d81c: 41 9e 00 24 beq- cr7,ffc0d840 <rtems_bdbuf_remove_from_tree_and_lru_list+0x44>
ffc0d820: 2f 80 00 02 cmpwi cr7,r0,2
ffc0d824: 40 be 00 0c bne+ cr7,ffc0d830 <rtems_bdbuf_remove_from_tree_and_lru_list+0x34><== NEVER TAKEN
{
case RTEMS_BDBUF_STATE_FREE:
break;
case RTEMS_BDBUF_STATE_CACHED:
rtems_bdbuf_remove_from_tree (bd);
ffc0d828: 4b ff fc 45 bl ffc0d46c <rtems_bdbuf_remove_from_tree>
break;
ffc0d82c: 48 00 00 14 b ffc0d840 <rtems_bdbuf_remove_from_tree_and_lru_list+0x44>
default:
rtems_bdbuf_fatal (bd->state, RTEMS_BLKDEV_FATAL_BDBUF_STATE_10);
ffc0d830: 3c 80 42 00 lis r4,16896 <== NOT EXECUTED
ffc0d834: 80 63 00 28 lwz r3,40(r3) <== NOT EXECUTED
ffc0d838: 60 84 00 08 ori r4,r4,8 <== NOT EXECUTED
ffc0d83c: 4b ff f4 95 bl ffc0ccd0 <rtems_bdbuf_fatal> <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
ffc0d840: 7f e3 fb 78 mr r3,r31
ffc0d844: 4b ff c0 49 bl ffc0988c <_Chain_Extract>
}
rtems_chain_extract (&bd->link);
}
ffc0d848: 39 61 00 10 addi r11,r1,16
ffc0d84c: 48 00 bc cc b ffc19518 <_restgpr_31_x>
ffc0d05c <rtems_bdbuf_restore_preemption>:
static void
rtems_bdbuf_restore_preemption (rtems_mode prev_mode)
{
ffc0d05c: 94 21 ff f0 stwu r1,-16(r1)
ffc0d060: 7c 08 02 a6 mflr r0
rtems_status_code sc = RTEMS_SUCCESSFUL;
sc = rtems_task_mode (prev_mode, RTEMS_ALL_MODE_MASKS, &prev_mode);
ffc0d064: 38 80 00 00 li r4,0
return prev_mode;
}
static void
rtems_bdbuf_restore_preemption (rtems_mode prev_mode)
{
ffc0d068: 7c 25 0b 78 mr r5,r1
ffc0d06c: 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);
ffc0d070: 60 84 ff ff ori r4,r4,65535
return prev_mode;
}
static void
rtems_bdbuf_restore_preemption (rtems_mode prev_mode)
{
ffc0d074: 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);
ffc0d078: 48 00 49 a1 bl ffc11a18 <rtems_task_mode>
if (sc != RTEMS_SUCCESSFUL)
ffc0d07c: 2f 83 00 00 cmpwi cr7,r3,0
ffc0d080: 41 be 00 10 beq+ cr7,ffc0d090 <rtems_bdbuf_restore_preemption+0x34><== ALWAYS TAKEN
rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_PREEMPT_RST);
ffc0d084: 3c 60 42 00 lis r3,16896 <== NOT EXECUTED
ffc0d088: 60 63 00 11 ori r3,r3,17 <== NOT EXECUTED
ffc0d08c: 4b ff c2 19 bl ffc092a4 <rtems_fatal_error_occurred> <== NOT EXECUTED
}
ffc0d090: 80 01 00 14 lwz r0,20(r1)
ffc0d094: 38 21 00 10 addi r1,r1,16
ffc0d098: 7c 08 03 a6 mtlr r0
ffc0d09c: 4e 80 00 20 blr
ffc0cce8 <rtems_bdbuf_swapout_modified_processing>:
rtems_chain_control* chain,
rtems_chain_control* transfer,
bool sync_active,
bool update_timers,
uint32_t timer_delta)
{
ffc0cce8: 94 21 ff c8 stwu r1,-56(r1)
ffc0ccec: 7c 08 02 a6 mflr r0
ffc0ccf0: 7c 89 23 78 mr r9,r4
ffc0ccf4: 7d 80 00 26 mfcr r12
ffc0ccf8: 90 01 00 3c stw r0,60(r1)
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
ffc0ccfc: 38 09 00 04 addi r0,r9,4
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_head( the_chain )->next;
ffc0cd00: 80 84 00 00 lwz r4,0(r4)
ffc0cd04: bf 01 00 18 stmw r24,24(r1)
ffc0cd08: 7c 7f 1b 78 mr r31,r3
if (!rtems_chain_is_empty (chain))
ffc0cd0c: 7f 84 00 00 cmpw cr7,r4,r0
rtems_chain_control* chain,
rtems_chain_control* transfer,
bool sync_active,
bool update_timers,
uint32_t timer_delta)
{
ffc0cd10: 91 81 00 14 stw r12,20(r1)
ffc0cd14: 7c be 2b 78 mr r30,r5
ffc0cd18: 7d 1b 43 78 mr r27,r8
if (!rtems_chain_is_empty (chain))
ffc0cd1c: 41 9e 01 74 beq- cr7,ffc0ce90 <rtems_bdbuf_swapout_modified_processing+0x1a8>
node = node->next;
/*
* A sync active with no valid dev means sync all.
*/
if (sync_active && (*dev == BDBUF_INVALID_DEV))
ffc0cd20: 2f 86 00 00 cmpwi cr7,r6,0
sync_all = true;
else
sync_all = false;
ffc0cd24: 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))
ffc0cd28: 41 9e 01 30 beq- cr7,ffc0ce58 <rtems_bdbuf_swapout_modified_processing+0x170>
* @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,
ffc0cd2c: 80 03 00 04 lwz r0,4(r3)
ffc0cd30: 81 63 00 00 lwz r11,0(r3)
ffc0cd34: 7d 6b 00 38 and r11,r11,r0
ffc0cd38: 38 0b 00 01 addi r0,r11,1
ffc0cd3c: 7c 00 00 34 cntlzw r0,r0
ffc0cd40: 54 00 d9 7e rlwinm r0,r0,27,5,31
ffc0cd44: 48 00 01 14 b ffc0ce58 <rtems_bdbuf_swapout_modified_processing+0x170>
* 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))
ffc0cd48: 40 92 00 38 bne- cr4,ffc0cd80 <rtems_bdbuf_swapout_modified_processing+0x98>
ffc0cd4c: 41 8e 00 24 beq- cr3,ffc0cd70 <rtems_bdbuf_swapout_modified_processing+0x88>
ffc0cd50: 81 3f 00 00 lwz r9,0(r31)
ffc0cd54: 80 04 00 18 lwz r0,24(r4)
ffc0cd58: 7f 89 00 00 cmpw cr7,r9,r0
ffc0cd5c: 40 be 00 14 bne+ cr7,ffc0cd70 <rtems_bdbuf_swapout_modified_processing+0x88>
ffc0cd60: 81 3f 00 04 lwz r9,4(r31)
ffc0cd64: 80 04 00 1c lwz r0,28(r4)
ffc0cd68: 7f 89 00 00 cmpw cr7,r9,r0
ffc0cd6c: 41 9e 00 14 beq- cr7,ffc0cd80 <rtems_bdbuf_swapout_modified_processing+0x98><== ALWAYS TAKEN
}
static bool
rtems_bdbuf_has_buffer_waiters (void)
{
return bdbuf_cache.buffer_waiters.count;
ffc0cd70: 39 39 2a 08 addi r9,r25,10760
ffc0cd74: 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 ())
ffc0cd78: 2f 80 00 00 cmpwi cr7,r0,0
ffc0cd7c: 41 9e 00 08 beq- cr7,ffc0cd84 <rtems_bdbuf_swapout_modified_processing+0x9c>
bd->hold_timer = 0;
ffc0cd80: 93 84 00 34 stw r28,52(r4)
if (bd->hold_timer)
ffc0cd84: 80 04 00 34 lwz r0,52(r4)
ffc0cd88: 2f 80 00 00 cmpwi cr7,r0,0
ffc0cd8c: 41 9e 00 3c beq- cr7,ffc0cdc8 <rtems_bdbuf_swapout_modified_processing+0xe0>
{
if (update_timers)
ffc0cd90: 41 8a 00 24 beq- cr2,ffc0cdb4 <rtems_bdbuf_swapout_modified_processing+0xcc>
{
if (bd->hold_timer > timer_delta)
ffc0cd94: 80 04 00 34 lwz r0,52(r4)
ffc0cd98: 7f 80 d8 40 cmplw cr7,r0,r27
ffc0cd9c: 40 9d 00 14 ble- cr7,ffc0cdb0 <rtems_bdbuf_swapout_modified_processing+0xc8>
bd->hold_timer -= timer_delta;
ffc0cda0: 80 04 00 34 lwz r0,52(r4)
ffc0cda4: 7c 1b 00 50 subf r0,r27,r0
ffc0cda8: 90 04 00 34 stw r0,52(r4)
ffc0cdac: 48 00 00 08 b ffc0cdb4 <rtems_bdbuf_swapout_modified_processing+0xcc>
else
bd->hold_timer = 0;
ffc0cdb0: 93 84 00 34 stw r28,52(r4)
}
if (bd->hold_timer)
ffc0cdb4: 80 04 00 34 lwz r0,52(r4)
ffc0cdb8: 2f 80 00 00 cmpwi cr7,r0,0
ffc0cdbc: 41 9e 00 0c beq- cr7,ffc0cdc8 <rtems_bdbuf_swapout_modified_processing+0xe0>
{
node = node->next;
ffc0cdc0: 80 84 00 00 lwz r4,0(r4)
continue;
ffc0cdc4: 48 00 00 b0 b ffc0ce74 <rtems_bdbuf_swapout_modified_processing+0x18c>
/*
* 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)
ffc0cdc8: 80 1f 00 00 lwz r0,0(r31)
ffc0cdcc: 2f 80 ff ff cmpwi cr7,r0,-1
ffc0cdd0: 40 be 00 20 bne+ cr7,ffc0cdf0 <rtems_bdbuf_swapout_modified_processing+0x108>
ffc0cdd4: 80 1f 00 04 lwz r0,4(r31)
ffc0cdd8: 2f 80 ff ff cmpwi cr7,r0,-1
ffc0cddc: 40 be 00 14 bne+ cr7,ffc0cdf0 <rtems_bdbuf_swapout_modified_processing+0x108><== NEVER TAKEN
*dev = bd->dev;
ffc0cde0: 81 44 00 18 lwz r10,24(r4)
ffc0cde4: 81 64 00 1c lwz r11,28(r4)
ffc0cde8: 91 5f 00 00 stw r10,0(r31)
ffc0cdec: 91 7f 00 04 stw r11,4(r31)
if (bd->dev == *dev)
ffc0cdf0: 81 24 00 18 lwz r9,24(r4)
ffc0cdf4: 80 1f 00 00 lwz r0,0(r31)
ffc0cdf8: 83 a4 00 00 lwz r29,0(r4)
ffc0cdfc: 7f 89 00 00 cmpw cr7,r9,r0
ffc0ce00: 40 be 00 88 bne+ cr7,ffc0ce88 <rtems_bdbuf_swapout_modified_processing+0x1a0><== NEVER TAKEN
ffc0ce04: 81 24 00 1c lwz r9,28(r4)
ffc0ce08: 80 1f 00 04 lwz r0,4(r31)
ffc0ce0c: 7f 89 00 00 cmpw cr7,r9,r0
ffc0ce10: 40 be 00 78 bne+ cr7,ffc0ce88 <rtems_bdbuf_swapout_modified_processing+0x1a0><== NEVER TAKEN
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
ffc0ce14: 93 44 00 28 stw r26,40(r4)
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
ffc0ce18: 7c 83 23 78 mr r3,r4
ffc0ce1c: 90 81 00 08 stw r4,8(r1)
ffc0ce20: 4b ff ca 6d bl ffc0988c <_Chain_Extract>
rtems_chain_extract (node);
tnode = tnode->previous;
while (node && !rtems_chain_is_head (transfer, tnode))
ffc0ce24: 80 81 00 08 lwz r4,8(r1)
rtems_bdbuf_set_state (bd, RTEMS_BDBUF_STATE_TRANSFER);
rtems_chain_extract (node);
tnode = tnode->previous;
ffc0ce28: 80 7e 00 08 lwz r3,8(r30)
while (node && !rtems_chain_is_head (transfer, tnode))
ffc0ce2c: 2f 84 00 00 cmpwi cr7,r4,0
ffc0ce30: 48 00 00 18 b ffc0ce48 <rtems_bdbuf_swapout_modified_processing+0x160>
{
rtems_bdbuf_buffer* tbd = (rtems_bdbuf_buffer*) tnode;
if (bd->block > tbd->block)
ffc0ce34: 81 24 00 20 lwz r9,32(r4)
ffc0ce38: 80 03 00 20 lwz r0,32(r3)
ffc0ce3c: 7f 09 00 40 cmplw cr6,r9,r0
ffc0ce40: 41 99 00 44 bgt- cr6,ffc0ce84 <rtems_bdbuf_swapout_modified_processing+0x19c>
{
rtems_chain_insert (tnode, node);
node = NULL;
}
else
tnode = tnode->previous;
ffc0ce44: 80 63 00 04 lwz r3,4(r3)
rtems_chain_extract (node);
tnode = tnode->previous;
while (node && !rtems_chain_is_head (transfer, tnode))
ffc0ce48: 41 9e 00 40 beq- cr7,ffc0ce88 <rtems_bdbuf_swapout_modified_processing+0x1a0><== NEVER TAKEN
ffc0ce4c: 7f 03 f0 00 cmpw cr6,r3,r30
ffc0ce50: 40 9a ff e4 bne+ cr6,ffc0ce34 <rtems_bdbuf_swapout_modified_processing+0x14c>
ffc0ce54: 48 00 00 2c b ffc0ce80 <rtems_bdbuf_swapout_modified_processing+0x198>
* 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))
ffc0ce58: 2e 00 00 00 cmpwi cr4,r0,0
ffc0ce5c: 2d 86 00 00 cmpwi cr3,r6,0
|| rtems_bdbuf_has_buffer_waiters ())
bd->hold_timer = 0;
if (bd->hold_timer)
{
if (update_timers)
ffc0ce60: 2d 07 00 00 cmpwi cr2,r7,0
RTEMS_INLINE_ROUTINE bool _Chain_Is_tail(
Chain_Control *the_chain,
const Chain_Node *the_node
)
{
return (the_node == _Chain_Tail(the_chain));
ffc0ce64: 3b 09 00 04 addi r24,r9,4
* @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;
ffc0ce68: 3b 80 00 00 li r28,0
}
static bool
rtems_bdbuf_has_buffer_waiters (void)
{
return bdbuf_cache.buffer_waiters.count;
ffc0ce6c: 3f 20 00 00 lis r25,0
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
ffc0ce70: 3b 40 00 09 li r26,9
if (sync_active && (*dev == BDBUF_INVALID_DEV))
sync_all = true;
else
sync_all = false;
while (!rtems_chain_is_tail (chain, node))
ffc0ce74: 7f 84 c0 00 cmpw cr7,r4,r24
ffc0ce78: 40 9e fe d0 bne+ cr7,ffc0cd48 <rtems_bdbuf_swapout_modified_processing+0x60>
ffc0ce7c: 48 00 00 14 b ffc0ce90 <rtems_bdbuf_swapout_modified_processing+0x1a8>
RTEMS_INLINE_ROUTINE void _Chain_Prepend(
Chain_Control *the_chain,
Chain_Node *the_node
)
{
_Chain_Insert(_Chain_Head(the_chain), the_node);
ffc0ce80: 7f c3 f3 78 mr r3,r30
ffc0ce84: 48 00 50 ed bl ffc11f70 <_Chain_Insert>
}
if (node)
rtems_chain_prepend (transfer, node);
node = next_node;
ffc0ce88: 7f a4 eb 78 mr r4,r29
ffc0ce8c: 4b ff ff e8 b ffc0ce74 <rtems_bdbuf_swapout_modified_processing+0x18c>
{
node = node->next;
}
}
}
}
ffc0ce90: 81 81 00 14 lwz r12,20(r1)
ffc0ce94: 39 61 00 38 addi r11,r1,56
ffc0ce98: 7d 83 81 20 mtcrf 56,r12
ffc0ce9c: 48 00 c6 60 b ffc194fc <_restgpr_24_x>
ffc0ddbc <rtems_bdbuf_swapout_task>:
* not this.
* @return rtems_task Not used.
*/
static rtems_task
rtems_bdbuf_swapout_task (rtems_task_argument arg)
{
ffc0ddbc: 94 21 ff 90 stwu r1,-112(r1)
ffc0ddc0: 7c 08 02 a6 mflr r0
ffc0ddc4: be 41 00 38 stmw r18,56(r1)
rtems_bdbuf_swapout_transfer transfer;
uint32_t period_in_ticks;
const uint32_t period_in_msecs = bdbuf_config.swapout_period;;
ffc0ddc8: 3f 60 ff c2 lis r27,-62
ffc0ddcc: 3b 7b a2 d4 addi r27,r27,-23852
* not this.
* @return rtems_task Not used.
*/
static rtems_task
rtems_bdbuf_swapout_task (rtems_task_argument arg)
{
ffc0ddd0: 90 01 00 74 stw r0,116(r1)
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);
ffc0ddd4: 3e c0 00 00 lis r22,0
ffc0ddd8: 3a d6 2a 08 addi r22,r22,10760
static rtems_task
rtems_bdbuf_swapout_task (rtems_task_argument arg)
{
rtems_bdbuf_swapout_transfer transfer;
uint32_t period_in_ticks;
const uint32_t period_in_msecs = bdbuf_config.swapout_period;;
ffc0dddc: 83 3b 00 0c lwz r25,12(r27)
uint32_t timer_delta;
transfer.write_req = rtems_bdbuf_swapout_writereq_alloc ();
ffc0dde0: 4b ff f3 a5 bl ffc0d184 <rtems_bdbuf_swapout_writereq_alloc>
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
ffc0dde4: 38 01 00 14 addi r0,r1,20
ffc0dde8: 90 61 00 2c stw r3,44(r1)
head->previous = NULL;
tail->previous = head;
ffc0ddec: 39 21 00 10 addi r9,r1,16
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
ffc0ddf0: 90 01 00 10 stw r0,16(r1)
head->previous = NULL;
ffc0ddf4: 38 00 00 00 li r0,0
transfer.syncing = false;
/*
* Localise the period.
*/
period_in_ticks = RTEMS_MICROSECONDS_TO_TICKS (period_in_msecs * 1000);
ffc0ddf8: 1e b9 03 e8 mulli r21,r25,1000
tail->previous = head;
ffc0ddfc: 91 21 00 18 stw r9,24(r1)
ffc0de00: 3d 20 00 00 lis r9,0
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
head->previous = NULL;
ffc0de04: 90 01 00 14 stw r0,20(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;
ffc0de08: 39 40 ff ff li r10,-1
ffc0de0c: 39 60 ff ff li r11,-1
transfer.syncing = false;
ffc0de10: 98 01 00 28 stb r0,40(r1)
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,
ffc0de14: 3f 40 ff c1 lis r26,-63
rtems_status_code sc;
size_t w;
rtems_bdbuf_lock_cache ();
for (w = 0; w < bdbuf_config.swapout_workers; w++)
ffc0de18: 3b 80 00 00 li r28,0
transfer.syncing = false;
/*
* Localise the period.
*/
period_in_ticks = RTEMS_MICROSECONDS_TO_TICKS (period_in_msecs * 1000);
ffc0de1c: 80 09 20 10 lwz r0,8208(r9)
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);
ffc0de20: 3a d6 00 08 addi r22,r22,8
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;
ffc0de24: 91 41 00 20 stw r10,32(r1)
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);
worker->enabled = true;
ffc0de28: 3a e0 00 01 li r23,1
transfer.syncing = false;
/*
* Localise the period.
*/
period_in_ticks = RTEMS_MICROSECONDS_TO_TICKS (period_in_msecs * 1000);
ffc0de2c: 7e b5 03 96 divwu r21,r21,r0
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;
ffc0de30: 91 61 00 24 stw r11,36(r1)
rtems_bdbuf_swapout_workers_open (void)
{
rtems_status_code sc;
size_t w;
rtems_bdbuf_lock_cache ();
ffc0de34: 4b ff ee 15 bl ffc0cc48 <rtems_bdbuf_lock_cache>
for (w = 0; w < bdbuf_config.swapout_workers; w++)
ffc0de38: 82 9b 00 14 lwz r20,20(r27)
ffc0de3c: 3b 00 00 00 li r24,0
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;
ffc0de40: 3b c0 ff ff li r30,-1
ffc0de44: 3b e0 ff ff li r31,-1
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,
ffc0de48: 3b 5a e1 10 addi r26,r26,-7920
ffc0de4c: 48 00 00 c0 b ffc0df0c <rtems_bdbuf_swapout_task+0x150>
for (w = 0; w < bdbuf_config.swapout_workers; w++)
{
rtems_bdbuf_swapout_worker* worker;
worker = malloc (sizeof (rtems_bdbuf_swapout_worker));
ffc0de50: 38 60 00 38 li r3,56 <== NOT EXECUTED
ffc0de54: 4b ff 77 c5 bl ffc05618 <malloc> <== NOT EXECUTED
if (!worker)
ffc0de58: 7c 7d 1b 79 mr. r29,r3 <== NOT EXECUTED
ffc0de5c: 40 a2 00 10 bne+ ffc0de6c <rtems_bdbuf_swapout_task+0xb0><== NOT EXECUTED
rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_SO_NOMEM);
ffc0de60: 3c 60 42 00 lis r3,16896 <== NOT EXECUTED
ffc0de64: 60 63 00 15 ori r3,r3,21 <== NOT EXECUTED
ffc0de68: 48 00 00 78 b ffc0dee0 <rtems_bdbuf_swapout_task+0x124><== 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 );
ffc0de6c: 7f a4 eb 78 mr r4,r29 <== NOT EXECUTED
ffc0de70: 7e c3 b3 78 mr r3,r22 <== NOT EXECUTED
ffc0de74: 4b ff b9 e9 bl ffc0985c <_Chain_Append> <== NOT EXECUTED
rtems_chain_append (&bdbuf_cache.swapout_workers, &worker->link);
worker->enabled = true;
ffc0de78: 9a fd 00 0c stb r23,12(r29) <== NOT EXECUTED
worker->transfer.write_req = rtems_bdbuf_swapout_writereq_alloc ();
ffc0de7c: 4b ff f3 09 bl ffc0d184 <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 ?
ffc0de80: 80 9b 00 08 lwz r4,8(r27) <== 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 ();
ffc0de84: 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),
ffc0de88: 38 7c 00 61 addi r3,r28,97 <== NOT EXECUTED
ffc0de8c: 2f 84 00 00 cmpwi cr7,r4,0 <== 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 );
ffc0de90: 38 1d 00 10 addi r0,r29,16 <== NOT EXECUTED
head->next = tail;
head->previous = NULL;
ffc0de94: 93 1d 00 14 stw r24,20(r29) <== 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 );
ffc0de98: 39 3d 00 14 addi r9,r29,20 <== NOT EXECUTED
ffc0de9c: 64 63 42 44 oris r3,r3,16964 <== NOT EXECUTED
head->next = tail;
ffc0dea0: 91 3d 00 10 stw r9,16(r29) <== NOT EXECUTED
ffc0dea4: 60 63 6f 00 ori r3,r3,28416 <== NOT EXECUTED
head->previous = NULL;
tail->previous = head;
ffc0dea8: 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;
ffc0deac: 93 dd 00 20 stw r30,32(r29) <== NOT EXECUTED
ffc0deb0: 93 fd 00 24 stw r31,36(r29) <== NOT EXECUTED
sc = rtems_task_create (rtems_build_name('B', 'D', 'o', 'a' + w),
ffc0deb4: 40 9e 00 08 bne- cr7,ffc0debc <rtems_bdbuf_swapout_task+0x100><== NOT EXECUTED
ffc0deb8: 38 80 00 0f li r4,15 <== NOT EXECUTED
ffc0debc: 38 a0 20 00 li r5,8192 <== NOT EXECUTED
ffc0dec0: 38 c0 04 00 li r6,1024 <== NOT EXECUTED
ffc0dec4: 38 e0 00 00 li r7,0 <== NOT EXECUTED
ffc0dec8: 39 1d 00 08 addi r8,r29,8 <== NOT EXECUTED
ffc0decc: 4b ff ae 31 bl ffc08cfc <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)
ffc0ded0: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc0ded4: 41 be 00 10 beq+ cr7,ffc0dee4 <rtems_bdbuf_swapout_task+0x128><== NOT EXECUTED
rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_SO_WK_CREATE);
ffc0ded8: 3c 60 42 00 lis r3,16896 <== NOT EXECUTED
ffc0dedc: 60 63 00 16 ori r3,r3,22 <== NOT EXECUTED
ffc0dee0: 4b ff b3 c5 bl ffc092a4 <rtems_fatal_error_occurred> <== NOT EXECUTED
sc = rtems_task_start (worker->id,
ffc0dee4: 80 7d 00 08 lwz r3,8(r29) <== NOT EXECUTED
ffc0dee8: 7f 44 d3 78 mr r4,r26 <== NOT EXECUTED
ffc0deec: 7f a5 eb 78 mr r5,r29 <== NOT EXECUTED
ffc0def0: 4b ff b0 d5 bl ffc08fc4 <rtems_task_start> <== NOT EXECUTED
rtems_bdbuf_swapout_worker_task,
(rtems_task_argument) worker);
if (sc != RTEMS_SUCCESSFUL)
ffc0def4: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc0def8: 41 be 00 10 beq+ cr7,ffc0df08 <rtems_bdbuf_swapout_task+0x14c><== NOT EXECUTED
rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_SO_WK_START);
ffc0defc: 3c 60 42 00 lis r3,16896 <== NOT EXECUTED
ffc0df00: 60 63 00 17 ori r3,r3,23 <== NOT EXECUTED
ffc0df04: 4b ff ff dc b ffc0dee0 <rtems_bdbuf_swapout_task+0x124><== NOT EXECUTED
rtems_status_code sc;
size_t w;
rtems_bdbuf_lock_cache ();
for (w = 0; w < bdbuf_config.swapout_workers; w++)
ffc0df08: 3b 9c 00 01 addi r28,r28,1 <== NOT EXECUTED
ffc0df0c: 7f 9c a0 40 cmplw cr7,r28,r20
ffc0df10: 41 9c ff 40 blt+ cr7,ffc0de50 <rtems_bdbuf_swapout_task+0x94><== NEVER TAKEN
/*
* Create the worker threads.
*/
rtems_bdbuf_swapout_workers_open ();
while (bdbuf_cache.swapout_enabled)
ffc0df14: 3f 80 00 00 lis r28,0
(rtems_task_argument) worker);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_SO_WK_START);
}
rtems_bdbuf_unlock_cache ();
ffc0df18: 4b ff ef 89 bl ffc0cea0 <rtems_bdbuf_unlock_cache>
/*
* Create the worker threads.
*/
rtems_bdbuf_swapout_workers_open ();
while (bdbuf_cache.swapout_enabled)
ffc0df1c: 3b 9c 2a 08 addi r28,r28,10760
* 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;
ffc0df20: 3a 60 00 00 li r19,0
else
{
worker = (rtems_bdbuf_swapout_worker*)
rtems_chain_get (&bdbuf_cache.swapout_workers);
ffc0df24: 3a 9c 00 08 addi r20,r28,8
if (worker)
transfer = &worker->transfer;
}
rtems_chain_initialize_empty (&transfer->bds);
transfer->dev = BDBUF_INVALID_DEV;
ffc0df28: 3b c0 ff ff li r30,-1
ffc0df2c: 3b e0 ff ff li r31,-1
ffc0df30: 7f 9b e3 78 mr r27,r28
/*
* 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,
ffc0df34: 3a dc 00 5c addi r22,r28,92
timer_delta);
/*
* Process the cache's modified list.
*/
rtems_bdbuf_swapout_modified_processing (&transfer->dev,
ffc0df38: 3a fc 00 50 addi r23,r28,80
ffc0df3c: 48 00 01 7c b ffc0e0b8 <rtems_bdbuf_swapout_task+0x2fc>
/*
* 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,
ffc0df40: 3b 00 00 00 li r24,0
ffc0df44: 48 00 00 08 b ffc0df4c <rtems_bdbuf_swapout_task+0x190>
/*
* Create the worker threads.
*/
rtems_bdbuf_swapout_workers_open ();
while (bdbuf_cache.swapout_enabled)
ffc0df48: 3b 00 00 01 li r24,1
rtems_bdbuf_swapout_transfer* transfer)
{
rtems_bdbuf_swapout_worker* worker;
bool transfered_buffers = false;
rtems_bdbuf_lock_cache ();
ffc0df4c: 4b ff ec fd bl ffc0cc48 <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)
ffc0df50: 88 1c 00 30 lbz r0,48(r28)
worker = NULL;
ffc0df54: 3b 40 00 00 li r26,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)
ffc0df58: 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,
ffc0df5c: 3b a1 00 10 addi r29,r1,16
* 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)
ffc0df60: 40 be 00 18 bne+ cr7,ffc0df78 <rtems_bdbuf_swapout_task+0x1bc>
*/
RTEMS_INLINE_ROUTINE rtems_chain_node *rtems_chain_get(
rtems_chain_control *the_chain
)
{
return _Chain_Get( the_chain );
ffc0df64: 7e 83 a3 78 mr r3,r20
ffc0df68: 4b ff b9 4d bl ffc098b4 <_Chain_Get>
worker = NULL;
else
{
worker = (rtems_bdbuf_swapout_worker*)
rtems_chain_get (&bdbuf_cache.swapout_workers);
if (worker)
ffc0df6c: 7c 7a 1b 79 mr. r26,r3
ffc0df70: 41 82 00 08 beq- ffc0df78 <rtems_bdbuf_swapout_task+0x1bc><== ALWAYS TAKEN
transfer = &worker->transfer;
ffc0df74: 3b ba 00 10 addi r29,r26,16 <== 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 );
ffc0df78: 38 1d 00 04 addi r0,r29,4
head->next = tail;
head->previous = NULL;
ffc0df7c: 92 7d 00 04 stw r19,4(r29)
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
ffc0df80: 90 1d 00 00 stw r0,0(r29)
}
rtems_chain_initialize_empty (&transfer->bds);
transfer->dev = BDBUF_INVALID_DEV;
transfer->syncing = bdbuf_cache.sync_active;
ffc0df84: 88 1c 00 30 lbz r0,48(r28)
head->previous = NULL;
tail->previous = head;
ffc0df88: 93 bd 00 08 stw r29,8(r29)
ffc0df8c: 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)
ffc0df90: 88 1c 00 30 lbz r0,48(r28)
if (worker)
transfer = &worker->transfer;
}
rtems_chain_initialize_empty (&transfer->bds);
transfer->dev = BDBUF_INVALID_DEV;
ffc0df94: 93 dd 00 10 stw r30,16(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)
ffc0df98: 2f 80 00 00 cmpwi cr7,r0,0
if (worker)
transfer = &worker->transfer;
}
rtems_chain_initialize_empty (&transfer->bds);
transfer->dev = BDBUF_INVALID_DEV;
ffc0df9c: 93 fd 00 14 stw r31,20(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)
ffc0dfa0: 41 9e 00 14 beq- cr7,ffc0dfb4 <rtems_bdbuf_swapout_task+0x1f8>
transfer->dev = bdbuf_cache.sync_device;
ffc0dfa4: 81 5c 00 38 lwz r10,56(r28)
ffc0dfa8: 81 7c 00 3c lwz r11,60(r28)
ffc0dfac: 91 5d 00 10 stw r10,16(r29)
ffc0dfb0: 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,
ffc0dfb4: 3a 5d 00 10 addi r18,r29,16
ffc0dfb8: 7e 43 93 78 mr r3,r18
ffc0dfbc: 7e c4 b3 78 mr r4,r22
ffc0dfc0: 7f a5 eb 78 mr r5,r29
ffc0dfc4: 38 c0 00 01 li r6,1
ffc0dfc8: 38 e0 00 00 li r7,0
ffc0dfcc: 7f 28 cb 78 mr r8,r25
ffc0dfd0: 4b ff ed 19 bl ffc0cce8 <rtems_bdbuf_swapout_modified_processing>
timer_delta);
/*
* Process the cache's modified list.
*/
rtems_bdbuf_swapout_modified_processing (&transfer->dev,
ffc0dfd4: 88 db 00 30 lbz r6,48(r27)
ffc0dfd8: 7e 43 93 78 mr r3,r18
ffc0dfdc: 7e e4 bb 78 mr r4,r23
ffc0dfe0: 7f a5 eb 78 mr r5,r29
ffc0dfe4: 7f 07 c3 78 mr r7,r24
ffc0dfe8: 7f 28 cb 78 mr r8,r25
ffc0dfec: 4b ff ec fd bl ffc0cce8 <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 ();
ffc0dff0: 4b ff ee b1 bl ffc0cea0 <rtems_bdbuf_unlock_cache>
/*
* If there are buffers to transfer to the media transfer them.
*/
if (!rtems_chain_is_empty (&transfer->bds))
ffc0dff4: 81 3d 00 00 lwz r9,0(r29)
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
ffc0dff8: 38 1d 00 04 addi r0,r29,4
ffc0dffc: 7f 89 00 00 cmpw cr7,r9,r0
ffc0e000: 41 9e 00 38 beq- cr7,ffc0e038 <rtems_bdbuf_swapout_task+0x27c>
{
if (worker)
ffc0e004: 2f 9a 00 00 cmpwi cr7,r26,0
ffc0e008: 41 9e 00 24 beq- cr7,ffc0e02c <rtems_bdbuf_swapout_task+0x270><== ALWAYS TAKEN
{
rtems_status_code sc = rtems_event_send (worker->id,
ffc0e00c: 80 7a 00 08 lwz r3,8(r26) <== NOT EXECUTED
ffc0e010: 38 80 00 04 li r4,4 <== NOT EXECUTED
ffc0e014: 4b ff a6 51 bl ffc08664 <rtems_event_send> <== NOT EXECUTED
RTEMS_BDBUF_SWAPOUT_SYNC);
if (sc != RTEMS_SUCCESSFUL)
ffc0e018: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc0e01c: 41 be 00 24 beq+ cr7,ffc0e040 <rtems_bdbuf_swapout_task+0x284><== NOT EXECUTED
rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_SO_WAKE);
ffc0e020: 3c 60 42 00 lis r3,16896 <== NOT EXECUTED
ffc0e024: 60 63 00 14 ori r3,r3,20 <== NOT EXECUTED
ffc0e028: 4b ff fe b8 b ffc0dee0 <rtems_bdbuf_swapout_task+0x124><== NOT EXECUTED
}
else
{
rtems_bdbuf_swapout_write (transfer);
ffc0e02c: 7f a3 eb 78 mr r3,r29
ffc0e030: 4b ff fb f9 bl ffc0dc28 <rtems_bdbuf_swapout_write>
ffc0e034: 48 00 00 0c b ffc0e040 <rtems_bdbuf_swapout_task+0x284>
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;
ffc0e038: 3b a0 00 00 li r29,0
ffc0e03c: 48 00 00 08 b ffc0e044 <rtems_bdbuf_swapout_task+0x288>
else
{
rtems_bdbuf_swapout_write (transfer);
}
transfered_buffers = true;
ffc0e040: 3b a0 00 01 li r29,1
}
if (bdbuf_cache.sync_active && !transfered_buffers)
ffc0e044: 88 1c 00 30 lbz r0,48(r28)
ffc0e048: 2f 9d 00 00 cmpwi cr7,r29,0
ffc0e04c: 2f 00 00 00 cmpwi cr6,r0,0
ffc0e050: 41 9a 00 34 beq- cr6,ffc0e084 <rtems_bdbuf_swapout_task+0x2c8>
ffc0e054: 40 9e fe ec bne+ cr7,ffc0df40 <rtems_bdbuf_swapout_task+0x184>
{
rtems_id sync_requester;
rtems_bdbuf_lock_cache ();
ffc0e058: 4b ff eb f1 bl ffc0cc48 <rtems_bdbuf_lock_cache>
sync_requester = bdbuf_cache.sync_requester;
ffc0e05c: 83 5b 00 34 lwz r26,52(r27)
bdbuf_cache.sync_active = false;
ffc0e060: 9b bb 00 30 stb r29,48(r27)
bdbuf_cache.sync_requester = 0;
ffc0e064: 93 bb 00 34 stw r29,52(r27)
rtems_bdbuf_unlock_cache ();
ffc0e068: 4b ff ee 39 bl ffc0cea0 <rtems_bdbuf_unlock_cache>
if (sync_requester)
ffc0e06c: 2f 9a 00 00 cmpwi cr7,r26,0
ffc0e070: 41 be 00 18 beq+ cr7,ffc0e088 <rtems_bdbuf_swapout_task+0x2cc><== NEVER TAKEN
rtems_event_send (sync_requester, RTEMS_BDBUF_TRANSFER_SYNC);
ffc0e074: 7f 43 d3 78 mr r3,r26
ffc0e078: 38 80 00 02 li r4,2
ffc0e07c: 4b ff a5 e9 bl ffc08664 <rtems_event_send>
ffc0e080: 48 00 00 08 b ffc0e088 <rtems_bdbuf_swapout_task+0x2cc>
/*
* 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,
ffc0e084: 40 be fe bc bne- cr7,ffc0df40 <rtems_bdbuf_swapout_task+0x184>
*/
update_timers = false;
}
while (transfered_buffers);
sc = rtems_event_receive (RTEMS_BDBUF_SWAPOUT_SYNC,
ffc0e088: 38 60 00 04 li r3,4
ffc0e08c: 38 80 00 00 li r4,0
ffc0e090: 7e a5 ab 78 mr r5,r21
ffc0e094: 38 c1 00 08 addi r6,r1,8
ffc0e098: 4b ff a4 31 bl ffc084c8 <rtems_event_receive>
RTEMS_EVENT_ALL | RTEMS_WAIT,
period_in_ticks,
&out);
if ((sc != RTEMS_SUCCESSFUL) && (sc != RTEMS_TIMEOUT))
ffc0e09c: 2c 03 00 00 cmpwi r3,0
ffc0e0a0: 41 82 00 18 beq- ffc0e0b8 <rtems_bdbuf_swapout_task+0x2fc>
ffc0e0a4: 2f 83 00 06 cmpwi cr7,r3,6
ffc0e0a8: 41 be 00 10 beq+ cr7,ffc0e0b8 <rtems_bdbuf_swapout_task+0x2fc><== ALWAYS TAKEN
rtems_fatal_error_occurred (BLKDEV_FATAL_BDBUF_SWAPOUT_RE);
ffc0e0ac: 3c 60 42 00 lis r3,16896 <== NOT EXECUTED
ffc0e0b0: 60 63 00 18 ori r3,r3,24 <== NOT EXECUTED
ffc0e0b4: 4b ff fe 2c b ffc0dee0 <rtems_bdbuf_swapout_task+0x124><== NOT EXECUTED
/*
* Create the worker threads.
*/
rtems_bdbuf_swapout_workers_open ();
while (bdbuf_cache.swapout_enabled)
ffc0e0b8: 88 1c 00 04 lbz r0,4(r28)
ffc0e0bc: 2f 80 00 00 cmpwi cr7,r0,0
ffc0e0c0: 40 9e fe 88 bne+ cr7,ffc0df48 <rtems_bdbuf_swapout_task+0x18c><== ALWAYS TAKEN
static void
rtems_bdbuf_swapout_workers_close (void)
{
rtems_chain_node* node;
rtems_bdbuf_lock_cache ();
ffc0e0c4: 4b ff eb 85 bl ffc0cc48 <rtems_bdbuf_lock_cache> <== NOT EXECUTED
node = rtems_chain_first (&bdbuf_cache.swapout_workers);
while (!rtems_chain_is_tail (&bdbuf_cache.swapout_workers, node))
{
rtems_bdbuf_swapout_worker* worker = (rtems_bdbuf_swapout_worker*) node;
worker->enabled = false;
ffc0e0c8: 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;
ffc0e0cc: 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;
ffc0e0d0: 3b 9c 00 0c addi r28,r28,12 <== NOT EXECUTED
ffc0e0d4: 48 00 00 18 b ffc0e0ec <rtems_bdbuf_swapout_task+0x330><== NOT EXECUTED
ffc0e0d8: 9b be 00 0c stb r29,12(r30) <== NOT EXECUTED
rtems_event_send (worker->id, RTEMS_BDBUF_SWAPOUT_SYNC);
ffc0e0dc: 38 80 00 04 li r4,4 <== NOT EXECUTED
ffc0e0e0: 80 7e 00 08 lwz r3,8(r30) <== NOT EXECUTED
ffc0e0e4: 4b ff a5 81 bl ffc08664 <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);
}
ffc0e0e8: 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))
ffc0e0ec: 7f 9e e0 00 cmpw cr7,r30,r28 <== NOT EXECUTED
ffc0e0f0: 40 9e ff e8 bne+ cr7,ffc0e0d8 <rtems_bdbuf_swapout_task+0x31c><== NOT EXECUTED
worker->enabled = false;
rtems_event_send (worker->id, RTEMS_BDBUF_SWAPOUT_SYNC);
node = rtems_chain_next (node);
}
rtems_bdbuf_unlock_cache ();
ffc0e0f4: 4b ff ed ad bl ffc0cea0 <rtems_bdbuf_unlock_cache> <== NOT EXECUTED
rtems_fatal_error_occurred (BLKDEV_FATAL_BDBUF_SWAPOUT_RE);
}
rtems_bdbuf_swapout_workers_close ();
free (transfer.write_req);
ffc0e0f8: 80 61 00 2c lwz r3,44(r1) <== NOT EXECUTED
ffc0e0fc: 4b ff 71 75 bl ffc05270 <free> <== NOT EXECUTED
rtems_task_delete (RTEMS_SELF);
ffc0e100: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc0e104: 4b ff ad 39 bl ffc08e3c <rtems_task_delete> <== NOT EXECUTED
}
ffc0e108: 39 61 00 70 addi r11,r1,112 <== NOT EXECUTED
ffc0e10c: 48 00 b3 d8 b ffc194e4 <_restgpr_18_x> <== NOT EXECUTED
ffc0e110 <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)
{
ffc0e110: 94 21 ff d8 stwu r1,-40(r1) <== NOT EXECUTED
ffc0e114: 7c 08 02 a6 mflr r0 <== NOT EXECUTED
ffc0e118: bf 21 00 0c stmw r25,12(r1) <== NOT EXECUTED
rtems_bdbuf_lock_cache ();
rtems_chain_initialize_empty (&worker->transfer.bds);
worker->transfer.dev = BDBUF_INVALID_DEV;
rtems_chain_append (&bdbuf_cache.swapout_workers, &worker->link);
ffc0e11c: 3f 60 00 00 lis r27,0 <== NOT EXECUTED
ffc0e120: 3b 7b 2a 08 addi r27,r27,10760 <== 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)
{
ffc0e124: 90 01 00 2c stw r0,44(r1) <== NOT EXECUTED
ffc0e128: 7c 7d 1b 78 mr r29,r3 <== NOT EXECUTED
while (worker->enabled)
{
rtems_bdbuf_wait_for_event (RTEMS_BDBUF_SWAPOUT_SYNC);
rtems_bdbuf_swapout_write (&worker->transfer);
ffc0e12c: 3b 83 00 10 addi r28,r3,16 <== 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 );
ffc0e130: 3b 23 00 14 addi r25,r3,20 <== NOT EXECUTED
head->next = tail;
head->previous = NULL;
ffc0e134: 3b 40 00 00 li r26,0 <== NOT EXECUTED
rtems_bdbuf_lock_cache ();
rtems_chain_initialize_empty (&worker->transfer.bds);
worker->transfer.dev = BDBUF_INVALID_DEV;
ffc0e138: 3b c0 ff ff li r30,-1 <== NOT EXECUTED
ffc0e13c: 3b e0 ff ff li r31,-1 <== NOT EXECUTED
rtems_chain_append (&bdbuf_cache.swapout_workers, &worker->link);
ffc0e140: 3b 7b 00 08 addi r27,r27,8 <== 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)
ffc0e144: 48 00 00 3c b ffc0e180 <rtems_bdbuf_swapout_worker_task+0x70><== NOT EXECUTED
{
rtems_bdbuf_wait_for_event (RTEMS_BDBUF_SWAPOUT_SYNC);
ffc0e148: 38 60 00 04 li r3,4 <== NOT EXECUTED
ffc0e14c: 4b ff ee 6d bl ffc0cfb8 <rtems_bdbuf_wait_for_event> <== NOT EXECUTED
rtems_bdbuf_swapout_write (&worker->transfer);
ffc0e150: 7f 83 e3 78 mr r3,r28 <== NOT EXECUTED
ffc0e154: 4b ff fa d5 bl ffc0dc28 <rtems_bdbuf_swapout_write> <== NOT EXECUTED
rtems_bdbuf_lock_cache ();
ffc0e158: 4b ff ea f1 bl ffc0cc48 <rtems_bdbuf_lock_cache> <== NOT EXECUTED
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
ffc0e15c: 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 );
ffc0e160: 7f 63 db 78 mr r3,r27 <== NOT EXECUTED
head->previous = NULL;
ffc0e164: 93 5d 00 14 stw r26,20(r29) <== NOT EXECUTED
ffc0e168: 7f a4 eb 78 mr r4,r29 <== NOT EXECUTED
tail->previous = head;
ffc0e16c: 93 9d 00 18 stw r28,24(r29) <== NOT EXECUTED
rtems_chain_initialize_empty (&worker->transfer.bds);
worker->transfer.dev = BDBUF_INVALID_DEV;
ffc0e170: 93 dd 00 20 stw r30,32(r29) <== NOT EXECUTED
ffc0e174: 93 fd 00 24 stw r31,36(r29) <== NOT EXECUTED
ffc0e178: 4b ff b6 e5 bl ffc0985c <_Chain_Append> <== NOT EXECUTED
rtems_chain_append (&bdbuf_cache.swapout_workers, &worker->link);
rtems_bdbuf_unlock_cache ();
ffc0e17c: 4b ff ed 25 bl ffc0cea0 <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)
ffc0e180: 88 1d 00 0c lbz r0,12(r29) <== NOT EXECUTED
ffc0e184: 2f 80 00 00 cmpwi cr7,r0,0 <== NOT EXECUTED
ffc0e188: 40 9e ff c0 bne+ cr7,ffc0e148 <rtems_bdbuf_swapout_worker_task+0x38><== NOT EXECUTED
rtems_chain_append (&bdbuf_cache.swapout_workers, &worker->link);
rtems_bdbuf_unlock_cache ();
}
free (worker->transfer.write_req);
ffc0e18c: 80 7d 00 2c lwz r3,44(r29) <== NOT EXECUTED
ffc0e190: 4b ff 70 e1 bl ffc05270 <free> <== NOT EXECUTED
free (worker);
ffc0e194: 7f a3 eb 78 mr r3,r29 <== NOT EXECUTED
ffc0e198: 4b ff 70 d9 bl ffc05270 <free> <== NOT EXECUTED
rtems_task_delete (RTEMS_SELF);
ffc0e19c: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc0e1a0: 4b ff ac 9d bl ffc08e3c <rtems_task_delete> <== NOT EXECUTED
}
ffc0e1a4: 39 61 00 28 addi r11,r1,40 <== NOT EXECUTED
ffc0e1a8: 48 00 b3 58 b ffc19500 <_restgpr_25_x> <== NOT EXECUTED
ffc0dc28 <rtems_bdbuf_swapout_write>:
*
* @param transfer The transfer transaction.
*/
static void
rtems_bdbuf_swapout_write (rtems_bdbuf_swapout_transfer* transfer)
{
ffc0dc28: 94 21 ff d8 stwu r1,-40(r1)
ffc0dc2c: 7c 08 02 a6 mflr r0
ffc0dc30: 90 01 00 2c stw r0,44(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))
ffc0dc34: 80 03 00 00 lwz r0,0(r3)
*
* @param transfer The transfer transaction.
*/
static void
rtems_bdbuf_swapout_write (rtems_bdbuf_swapout_transfer* transfer)
{
ffc0dc38: bf 01 00 08 stmw r24,8(r1)
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
ffc0dc3c: 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))
ffc0dc40: 7f 80 e0 00 cmpw cr7,r0,r28
*
* @param transfer The transfer transaction.
*/
static void
rtems_bdbuf_swapout_write (rtems_bdbuf_swapout_transfer* transfer)
{
ffc0dc44: 7c 7f 1b 78 mr r31,r3
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))
ffc0dc48: 41 9e 01 6c beq- cr7,ffc0ddb4 <rtems_bdbuf_swapout_write+0x18c><== 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);
ffc0dc4c: 80 63 00 10 lwz r3,16(r3)
ffc0dc50: 80 9f 00 14 lwz r4,20(r31)
ffc0dc54: 4b ff 68 b1 bl ffc04504 <rtems_disk_obtain>
if (dd == NULL)
ffc0dc58: 7c 7e 1b 79 mr. r30,r3
ffc0dc5c: 40 a2 00 0c bne+ ffc0dc68 <rtems_bdbuf_swapout_write+0x40>
dd = &null_disk;
ffc0dc60: 3f c0 00 00 lis r30,0
ffc0dc64: 3b de 21 a0 addi r30,r30,8608
bufs_per_bd = dd->block_size / bdbuf_config.buffer_min;
ffc0dc68: 3f 60 ff c2 lis r27,-62
ffc0dc6c: 83 1e 00 20 lwz r24,32(r30)
ffc0dc70: 39 3b a2 d4 addi r9,r27,-23852
ffc0dc74: 80 09 00 20 lwz r0,32(r9)
{
/*
* The last block number used when the driver only supports
* continuous blocks in a single request.
*/
uint32_t last_block = 0;
ffc0dc78: 3b a0 00 00 li r29,0
* 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;
ffc0dc7c: 81 3f 00 1c lwz r9,28(r31)
transfer->write_req->bufnum = 0;
while ((node = rtems_chain_get(&transfer->bds)) != NULL)
{
rtems_bdbuf_buffer* bd = (rtems_bdbuf_buffer*) node;
bool write = false;
ffc0dc80: 3b 20 00 00 li r25,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;
ffc0dc84: 7f 18 03 96 divwu r24,r24,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;
ffc0dc88: 38 00 00 0c li r0,12
ffc0dc8c: 90 09 00 0c stw r0,12(r9)
transfer->write_req->bufnum = 0;
ffc0dc90: 38 00 00 00 li r0,0
if (write)
{
rtems_bdbuf_execute_transfer_request (dd, transfer->write_req, false);
transfer->write_req->status = RTEMS_RESOURCE_IN_USE;
ffc0dc94: 3b 40 00 0c li r26,12
* 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;
ffc0dc98: 90 09 00 10 stw r0,16(r9)
while ((node = rtems_chain_get(&transfer->bds)) != NULL)
ffc0dc9c: 48 00 00 c0 b ffc0dd5c <rtems_bdbuf_swapout_write+0x134>
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) &&
ffc0dca0: 81 3e 00 08 lwz r9,8(r30)
ffc0dca4: 80 09 00 0c lwz r0,12(r9)
ffc0dca8: 70 09 00 01 andi. r9,r0,1
ffc0dcac: 81 3f 00 1c lwz r9,28(r31)
ffc0dcb0: 41 82 00 30 beq- ffc0dce0 <rtems_bdbuf_swapout_write+0xb8><== ALWAYS TAKEN
ffc0dcb4: 80 09 00 10 lwz r0,16(r9) <== NOT EXECUTED
ffc0dcb8: 2f 80 00 00 cmpwi cr7,r0,0 <== NOT EXECUTED
ffc0dcbc: 41 9e 00 24 beq- cr7,ffc0dce0 <rtems_bdbuf_swapout_write+0xb8><== NOT EXECUTED
transfer->write_req->bufnum &&
ffc0dcc0: 81 64 00 20 lwz r11,32(r4) <== NOT EXECUTED
(bd->block != (last_block + bufs_per_bd)))
ffc0dcc4: 7c 1d c2 14 add r0,r29,r24 <== 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 &&
ffc0dcc8: 7f 8b 00 00 cmpw cr7,r11,r0 <== NOT EXECUTED
ffc0dccc: 41 9e 00 14 beq- cr7,ffc0dce0 <rtems_bdbuf_swapout_write+0xb8><== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Chain_Prepend(
Chain_Control *the_chain,
Chain_Node *the_node
)
{
_Chain_Insert(_Chain_Head(the_chain), the_node);
ffc0dcd0: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc0dcd4: 48 00 42 9d bl ffc11f70 <_Chain_Insert> <== NOT EXECUTED
(bd->block != (last_block + bufs_per_bd)))
{
rtems_chain_prepend (&transfer->bds, &bd->link);
write = true;
ffc0dcd8: 38 00 00 01 li r0,1 <== NOT EXECUTED
ffc0dcdc: 48 00 00 38 b ffc0dd14 <rtems_bdbuf_swapout_write+0xec><== NOT EXECUTED
}
else
{
rtems_blkdev_sg_buffer* buf;
buf = &transfer->write_req->bufs[transfer->write_req->bufnum];
ffc0dce0: 81 69 00 10 lwz r11,16(r9)
transfer->write_req->bufnum++;
buf->user = bd;
buf->block = bd->block;
ffc0dce4: 83 a4 00 20 lwz r29,32(r4)
write = true;
}
else
{
rtems_blkdev_sg_buffer* buf;
buf = &transfer->write_req->bufs[transfer->write_req->bufnum];
ffc0dce8: 38 0b 00 01 addi r0,r11,1
transfer->write_req->bufnum++;
ffc0dcec: 90 09 00 10 stw r0,16(r9)
write = true;
}
else
{
rtems_blkdev_sg_buffer* buf;
buf = &transfer->write_req->bufs[transfer->write_req->bufnum];
ffc0dcf0: 54 0a 20 36 rlwinm r10,r0,4,0,27
ffc0dcf4: 7d 49 52 14 add r10,r9,r10
transfer->write_req->bufnum++;
buf->user = bd;
buf->block = bd->block;
buf->length = dd->block_size;
ffc0dcf8: 80 1e 00 20 lwz r0,32(r30)
else
{
rtems_blkdev_sg_buffer* buf;
buf = &transfer->write_req->bufs[transfer->write_req->bufnum];
transfer->write_req->bufnum++;
buf->user = bd;
ffc0dcfc: 90 8a 00 14 stw r4,20(r10)
buf->block = bd->block;
buf->length = dd->block_size;
ffc0dd00: 90 0a 00 0c stw r0,12(r10)
buf->buffer = bd->buffer;
ffc0dd04: 80 04 00 24 lwz r0,36(r4)
{
rtems_blkdev_sg_buffer* buf;
buf = &transfer->write_req->bufs[transfer->write_req->bufnum];
transfer->write_req->bufnum++;
buf->user = bd;
buf->block = bd->block;
ffc0dd08: 93 aa 00 08 stw r29,8(r10)
buf->length = dd->block_size;
buf->buffer = bd->buffer;
ffc0dd0c: 90 0a 00 10 stw r0,16(r10)
transfer->write_req->bufnum = 0;
while ((node = rtems_chain_get(&transfer->bds)) != NULL)
{
rtems_bdbuf_buffer* bd = (rtems_bdbuf_buffer*) node;
bool write = false;
ffc0dd10: 38 00 00 00 li r0,0
/*
* 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) ||
ffc0dd14: 81 3f 00 00 lwz r9,0(r31)
ffc0dd18: 7f 89 e0 00 cmpw cr7,r9,r28
ffc0dd1c: 41 9e 00 24 beq- cr7,ffc0dd40 <rtems_bdbuf_swapout_write+0x118>
(transfer->write_req->bufnum >= bdbuf_config.max_write_blocks))
ffc0dd20: 81 7f 00 1c lwz r11,28(r31)
ffc0dd24: 39 3b a2 d4 addi r9,r27,-23852
/*
* 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) ||
ffc0dd28: 81 29 00 04 lwz r9,4(r9)
ffc0dd2c: 81 6b 00 10 lwz r11,16(r11)
ffc0dd30: 7f 8b 48 40 cmplw cr7,r11,r9
ffc0dd34: 40 9c 00 0c bge- cr7,ffc0dd40 <rtems_bdbuf_swapout_write+0x118>
(transfer->write_req->bufnum >= bdbuf_config.max_write_blocks))
write = true;
if (write)
ffc0dd38: 2f 80 00 00 cmpwi cr7,r0,0
ffc0dd3c: 41 be 00 20 beq+ cr7,ffc0dd5c <rtems_bdbuf_swapout_write+0x134><== ALWAYS TAKEN
{
rtems_bdbuf_execute_transfer_request (dd, transfer->write_req, false);
ffc0dd40: 80 9f 00 1c lwz r4,28(r31)
ffc0dd44: 7f c3 f3 78 mr r3,r30
ffc0dd48: 38 a0 00 00 li r5,0
ffc0dd4c: 4b ff fd 5d bl ffc0daa8 <rtems_bdbuf_execute_transfer_request>
transfer->write_req->status = RTEMS_RESOURCE_IN_USE;
ffc0dd50: 81 3f 00 1c lwz r9,28(r31)
ffc0dd54: 93 49 00 0c stw r26,12(r9)
transfer->write_req->bufnum = 0;
ffc0dd58: 93 29 00 10 stw r25,16(r9)
*/
RTEMS_INLINE_ROUTINE rtems_chain_node *rtems_chain_get(
rtems_chain_control *the_chain
)
{
return _Chain_Get( the_chain );
ffc0dd5c: 7f e3 fb 78 mr r3,r31
ffc0dd60: 4b ff bb 55 bl ffc098b4 <_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)
ffc0dd64: 7c 64 1b 79 mr. r4,r3
ffc0dd68: 40 82 ff 38 bne+ ffc0dca0 <rtems_bdbuf_swapout_write+0x78>
transfer->write_req->status = RTEMS_RESOURCE_IN_USE;
transfer->write_req->bufnum = 0;
}
}
if (dd != &null_disk)
ffc0dd6c: 3d 20 00 00 lis r9,0
ffc0dd70: 38 09 21 a0 addi r0,r9,8608
ffc0dd74: 7f 9e 00 00 cmpw cr7,r30,r0
ffc0dd78: 41 9e 00 3c beq- cr7,ffc0ddb4 <rtems_bdbuf_swapout_write+0x18c><== NEVER TAKEN
{
/*
* If sync'ing and the deivce is capability of handling a sync IO control
* call perform the call.
*/
if (transfer->syncing &&
ffc0dd7c: 88 1f 00 18 lbz r0,24(r31)
ffc0dd80: 2f 80 00 00 cmpwi cr7,r0,0
ffc0dd84: 41 9e 00 28 beq- cr7,ffc0ddac <rtems_bdbuf_swapout_write+0x184>
(dd->phys_dev->capabilities & RTEMS_BLKDEV_CAP_SYNC))
ffc0dd88: 80 7e 00 08 lwz r3,8(r30)
ffc0dd8c: 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 &&
ffc0dd90: 70 09 00 02 andi. r9,r0,2
ffc0dd94: 41 a2 00 18 beq+ ffc0ddac <rtems_bdbuf_swapout_write+0x184><== ALWAYS TAKEN
(dd->phys_dev->capabilities & RTEMS_BLKDEV_CAP_SYNC))
{
/* int result = */ dd->ioctl (dd->phys_dev, RTEMS_BLKDEV_REQ_SYNC, NULL);
ffc0dd98: 80 1e 00 28 lwz r0,40(r30) <== NOT EXECUTED
ffc0dd9c: 38 80 00 02 li r4,2 <== NOT EXECUTED
ffc0dda0: 38 a0 00 00 li r5,0 <== NOT EXECUTED
ffc0dda4: 7c 09 03 a6 mtctr r0 <== NOT EXECUTED
ffc0dda8: 4e 80 04 21 bctrl <== NOT EXECUTED
/* How should the error be handled ? */
}
rtems_disk_release (dd);
ffc0ddac: 7f c3 f3 78 mr r3,r30
ffc0ddb0: 4b ff 67 d9 bl ffc04588 <rtems_disk_release>
}
}
}
ffc0ddb4: 39 61 00 28 addi r11,r1,40
ffc0ddb8: 48 00 b7 44 b ffc194fc <_restgpr_24_x>
ffc0d184 <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)));
ffc0d184: 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)
{
ffc0d188: 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)));
ffc0d18c: 80 69 a2 d8 lwz r3,-23848(r9)
*
* @return rtems_blkdev_request* The write reference memory.
*/
static rtems_blkdev_request*
rtems_bdbuf_swapout_writereq_alloc (void)
{
ffc0d190: 7c 2b 0b 78 mr r11,r1
ffc0d194: 94 21 ff f0 stwu r1,-16(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)));
ffc0d198: 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 =
ffc0d19c: 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)
{
ffc0d1a0: 48 00 c3 2d bl ffc194cc <_savegpr_31>
ffc0d1a4: 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 =
ffc0d1a8: 4b ff 84 71 bl ffc05618 <malloc>
malloc (sizeof (rtems_blkdev_request) +
(bdbuf_config.max_write_blocks * sizeof (rtems_blkdev_sg_buffer)));
if (!write_req)
ffc0d1ac: 7c 7f 1b 79 mr. r31,r3
ffc0d1b0: 40 a2 00 10 bne+ ffc0d1c0 <rtems_bdbuf_swapout_writereq_alloc+0x3c><== ALWAYS TAKEN
rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_SO_NOMEM);
ffc0d1b4: 3c 60 42 00 lis r3,16896 <== NOT EXECUTED
ffc0d1b8: 60 63 00 15 ori r3,r3,21 <== NOT EXECUTED
ffc0d1bc: 4b ff c0 e9 bl ffc092a4 <rtems_fatal_error_occurred> <== NOT EXECUTED
write_req->req = RTEMS_BLKDEV_REQ_WRITE;
ffc0d1c0: 38 00 00 01 li r0,1
write_req->req_done = rtems_bdbuf_transfer_done;
write_req->done_arg = write_req;
ffc0d1c4: 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;
ffc0d1c8: 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;
ffc0d1cc: 90 1f 00 00 stw r0,0(r31)
write_req->req_done = rtems_bdbuf_transfer_done;
ffc0d1d0: 38 09 cf 8c addi r0,r9,-12404
ffc0d1d4: 90 1f 00 04 stw r0,4(r31)
write_req->done_arg = write_req;
write_req->io_task = rtems_task_self ();
ffc0d1d8: 48 00 49 f1 bl ffc11bc8 <rtems_task_self>
return write_req;
}
ffc0d1dc: 39 61 00 10 addi r11,r1,16
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 ();
ffc0d1e0: 90 7f 00 14 stw r3,20(r31)
return write_req;
}
ffc0d1e4: 7f e3 fb 78 mr r3,r31
ffc0d1e8: 48 00 c3 30 b ffc19518 <_restgpr_31_x>
ffc0f000 <rtems_bdbuf_sync>:
rtems_status_code
rtems_bdbuf_sync (rtems_bdbuf_buffer *bd)
{
ffc0f000: 94 21 ff f0 stwu r1,-16(r1)
ffc0f004: 7c 08 02 a6 mflr r0
ffc0f008: bf c1 00 08 stmw 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)
ffc0f00c: 3f c0 00 00 lis r30,0
ffc0f010: 3b de 2a 08 addi r30,r30,10760
return RTEMS_SUCCESSFUL;
}
rtems_status_code
rtems_bdbuf_sync (rtems_bdbuf_buffer *bd)
{
ffc0f014: 90 01 00 14 stw r0,20(r1)
ffc0f018: 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)
return RTEMS_NOT_CONFIGURED;
ffc0f01c: 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)
ffc0f020: 88 1e 00 88 lbz r0,136(r30)
ffc0f024: 2f 80 00 00 cmpwi cr7,r0,0
ffc0f028: 41 9e 01 38 beq- cr7,ffc0f160 <rtems_bdbuf_sync+0x160> <== NEVER TAKEN
return RTEMS_NOT_CONFIGURED;
if (bd == NULL)
ffc0f02c: 2f 9f 00 00 cmpwi cr7,r31,0
ffc0f030: 41 9e 00 28 beq- cr7,ffc0f058 <rtems_bdbuf_sync+0x58> <== NEVER TAKEN
if (rtems_bdbuf_tracer)
{
printf ("bdbuf:%s: %" PRIu32 "\n", kind, bd->block);
rtems_bdbuf_show_users (kind, bd);
}
rtems_bdbuf_lock_cache();
ffc0f034: 4b ff dc 15 bl ffc0cc48 <rtems_bdbuf_lock_cache>
sc = rtems_bdbuf_check_bd_and_lock_cache (bd, "sync");
if (sc != RTEMS_SUCCESSFUL)
return sc;
switch (bd->state)
ffc0f038: 80 1f 00 28 lwz r0,40(r31)
ffc0f03c: 2b 80 00 03 cmplwi cr7,r0,3
ffc0f040: 41 9c 01 08 blt- cr7,ffc0f148 <rtems_bdbuf_sync+0x148> <== NEVER TAKEN
ffc0f044: 2b 80 00 05 cmplwi cr7,r0,5
ffc0f048: 40 9d 00 18 ble- cr7,ffc0f060 <rtems_bdbuf_sync+0x60>
ffc0f04c: 2f 80 00 06 cmpwi cr7,r0,6
ffc0f050: 40 be 00 f8 bne+ cr7,ffc0f148 <rtems_bdbuf_sync+0x148> <== NEVER TAKEN
ffc0f054: 48 00 00 e8 b ffc0f13c <rtems_bdbuf_sync+0x13c>
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;
ffc0f058: 38 60 00 09 li r3,9 <== NOT EXECUTED
ffc0f05c: 48 00 01 04 b ffc0f160 <rtems_bdbuf_sync+0x160> <== NOT EXECUTED
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
ffc0f060: 38 00 00 08 li r0,8
ffc0f064: 90 1f 00 28 stw r0,40(r31)
ffc0f068: 38 7e 00 5c addi r3,r30,92
ffc0f06c: 7f e4 fb 78 mr r4,r31
ffc0f070: 4b ff a7 ed bl ffc0985c <_Chain_Append>
{
rtems_bdbuf_set_state (bd, RTEMS_BDBUF_STATE_SYNC);
rtems_chain_append (&bdbuf_cache.sync, &bd->link);
if (bd->waiters)
ffc0f074: 80 1f 00 2c lwz r0,44(r31)
ffc0f078: 2f 80 00 00 cmpwi cr7,r0,0
ffc0f07c: 41 be 00 0c beq+ cr7,ffc0f088 <rtems_bdbuf_sync+0x88>
rtems_bdbuf_wake (&bdbuf_cache.access_waiters);
ffc0f080: 38 7e 00 68 addi r3,r30,104
ffc0f084: 4b ff e1 cd bl ffc0d250 <rtems_bdbuf_wake>
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);
ffc0f088: 3f c0 00 00 lis r30,0
rtems_chain_append (&bdbuf_cache.sync, &bd->link);
if (bd->waiters)
rtems_bdbuf_wake (&bdbuf_cache.access_waiters);
rtems_bdbuf_wake_swapper ();
ffc0f08c: 4b ff de c1 bl ffc0cf4c <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);
ffc0f090: 3b de 2a 08 addi r30,r30,10760
ffc0f094: 3b de 00 70 addi r30,r30,112
static void
rtems_bdbuf_wait_for_sync_done (rtems_bdbuf_buffer *bd)
{
while (true)
{
switch (bd->state)
ffc0f098: 80 1f 00 28 lwz r0,40(r31)
ffc0f09c: 2b 80 00 01 cmplwi cr7,r0,1
ffc0f0a0: 41 9c 00 24 blt- cr7,ffc0f0c4 <rtems_bdbuf_sync+0xc4> <== NEVER TAKEN
ffc0f0a4: 2b 80 00 07 cmplwi cr7,r0,7
ffc0f0a8: 40 9d 00 2c ble- cr7,ffc0f0d4 <rtems_bdbuf_sync+0xd4>
ffc0f0ac: 2b 80 00 0a cmplwi cr7,r0,10
ffc0f0b0: 41 9d 00 14 bgt- cr7,ffc0f0c4 <rtems_bdbuf_sync+0xc4> <== 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);
ffc0f0b4: 7f e3 fb 78 mr r3,r31
ffc0f0b8: 7f c4 f3 78 mr r4,r30
ffc0f0bc: 4b ff e0 69 bl ffc0d124 <rtems_bdbuf_wait>
ffc0f0c0: 4b ff ff d8 b ffc0f098 <rtems_bdbuf_sync+0x98>
break;
default:
rtems_bdbuf_fatal (bd->state, RTEMS_BLKDEV_FATAL_BDBUF_STATE_9);
ffc0f0c4: 3c 80 42 00 lis r4,16896 <== NOT EXECUTED
ffc0f0c8: 80 7f 00 28 lwz r3,40(r31) <== NOT EXECUTED
ffc0f0cc: 60 84 00 07 ori r4,r4,7 <== NOT EXECUTED
ffc0f0d0: 48 00 00 84 b ffc0f154 <rtems_bdbuf_sync+0x154> <== NOT EXECUTED
rtems_bdbuf_wait_for_sync_done (bd);
/*
* We may have created a cached or empty buffer which may be recycled.
*/
if (bd->waiters == 0
ffc0f0d4: 80 1f 00 2c lwz r0,44(r31)
ffc0f0d8: 2f 80 00 00 cmpwi cr7,r0,0
ffc0f0dc: 40 9e 00 7c bne- cr7,ffc0f158 <rtems_bdbuf_sync+0x158>
&& (bd->state == RTEMS_BDBUF_STATE_CACHED
ffc0f0e0: 80 1f 00 28 lwz r0,40(r31)
ffc0f0e4: 2f 80 00 02 cmpwi cr7,r0,2
ffc0f0e8: 41 9e 00 10 beq- cr7,ffc0f0f8 <rtems_bdbuf_sync+0xf8>
|| bd->state == RTEMS_BDBUF_STATE_EMPTY))
ffc0f0ec: 80 1f 00 28 lwz r0,40(r31)
ffc0f0f0: 2f 80 00 01 cmpwi cr7,r0,1
ffc0f0f4: 40 be 00 64 bne+ cr7,ffc0f158 <rtems_bdbuf_sync+0x158> <== NEVER TAKEN
{
if (bd->state == RTEMS_BDBUF_STATE_EMPTY)
ffc0f0f8: 80 1f 00 28 lwz r0,40(r31)
ffc0f0fc: 2f 80 00 01 cmpwi cr7,r0,1
ffc0f100: 40 be 00 28 bne+ cr7,ffc0f128 <rtems_bdbuf_sync+0x128>
{
rtems_bdbuf_remove_from_tree (bd);
ffc0f104: 7f e3 fb 78 mr r3,r31
ffc0f108: 4b ff e3 65 bl ffc0d46c <rtems_bdbuf_remove_from_tree>
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
ffc0f10c: 38 00 00 00 li r0,0
RTEMS_INLINE_ROUTINE void _Chain_Prepend(
Chain_Control *the_chain,
Chain_Node *the_node
)
{
_Chain_Insert(_Chain_Head(the_chain), the_node);
ffc0f110: 3c 60 00 00 lis r3,0
ffc0f114: 90 1f 00 28 stw r0,40(r31)
ffc0f118: 38 63 2a 08 addi r3,r3,10760
ffc0f11c: 38 63 00 44 addi r3,r3,68
ffc0f120: 7f e4 fb 78 mr r4,r31
ffc0f124: 48 00 2e 4d bl ffc11f70 <_Chain_Insert>
if (bd->state == RTEMS_BDBUF_STATE_EMPTY)
{
rtems_bdbuf_remove_from_tree (bd);
rtems_bdbuf_make_free_and_add_to_lru_list (bd);
}
rtems_bdbuf_wake (&bdbuf_cache.buffer_waiters);
ffc0f128: 3c 60 00 00 lis r3,0
ffc0f12c: 38 63 2a 08 addi r3,r3,10760
ffc0f130: 38 63 00 78 addi r3,r3,120
ffc0f134: 4b ff e1 1d bl ffc0d250 <rtems_bdbuf_wake>
ffc0f138: 48 00 00 20 b ffc0f158 <rtems_bdbuf_sync+0x158>
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);
ffc0f13c: 7f e3 fb 78 mr r3,r31
ffc0f140: 4b ff e7 11 bl ffc0d850 <rtems_bdbuf_discard_buffer_after_access>
break;
ffc0f144: 48 00 00 14 b ffc0f158 <rtems_bdbuf_sync+0x158>
default:
rtems_bdbuf_fatal (bd->state, RTEMS_BLKDEV_FATAL_BDBUF_STATE_5);
ffc0f148: 3c 80 42 00 lis r4,16896 <== NOT EXECUTED
ffc0f14c: 80 7f 00 28 lwz r3,40(r31) <== NOT EXECUTED
ffc0f150: 60 84 00 03 ori r4,r4,3 <== NOT EXECUTED
ffc0f154: 4b ff db 7d bl ffc0ccd0 <rtems_bdbuf_fatal> <== NOT EXECUTED
}
if (rtems_bdbuf_tracer)
rtems_bdbuf_show_usage ();
rtems_bdbuf_unlock_cache ();
ffc0f158: 4b ff dd 49 bl ffc0cea0 <rtems_bdbuf_unlock_cache>
return RTEMS_SUCCESSFUL;
ffc0f15c: 38 60 00 00 li r3,0
}
ffc0f160: 39 61 00 10 addi r11,r1,16
ffc0f164: 48 00 a3 b0 b ffc19514 <_restgpr_30_x>
ffc0f168 <rtems_bdbuf_syncdev>:
rtems_status_code
rtems_bdbuf_syncdev (dev_t dev)
{
ffc0f168: 94 21 ff d8 stwu r1,-40(r1)
ffc0f16c: 7c 08 02 a6 mflr r0
ffc0f170: bf 81 00 18 stmw r28,24(r1)
rtems_blkdev_bnum *media_block_ptr,
size_t *bds_per_group_ptr)
{
rtems_disk_device *dd = NULL;
if (!bdbuf_cache.initialised)
ffc0f174: 3f a0 00 00 lis r29,0
ffc0f178: 3b bd 2a 08 addi r29,r29,10760
return RTEMS_SUCCESSFUL;
}
rtems_status_code
rtems_bdbuf_syncdev (dev_t dev)
{
ffc0f17c: 90 01 00 2c stw r0,44(r1)
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_disk_device *dd = NULL;
ffc0f180: 38 00 00 00 li r0,0
return RTEMS_SUCCESSFUL;
}
rtems_status_code
rtems_bdbuf_syncdev (dev_t dev)
{
ffc0f184: 7c 9f 23 78 mr r31,r4
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_disk_device *dd = NULL;
ffc0f188: 90 01 00 08 stw r0,8(r1)
return RTEMS_SUCCESSFUL;
}
rtems_status_code
rtems_bdbuf_syncdev (dev_t dev)
{
ffc0f18c: 7c 7e 1b 78 mr r30,r3
size_t *bds_per_group_ptr)
{
rtems_disk_device *dd = NULL;
if (!bdbuf_cache.initialised)
return RTEMS_NOT_CONFIGURED;
ffc0f190: 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)
ffc0f194: 88 1d 00 88 lbz r0,136(r29)
ffc0f198: 2f 80 00 00 cmpwi cr7,r0,0
ffc0f19c: 41 be 00 5c beq+ cr7,ffc0f1f8 <rtems_bdbuf_syncdev+0x90><== NEVER TAKEN
ffc0f1a0: 38 a0 00 00 li r5,0
ffc0f1a4: 38 c1 00 08 addi r6,r1,8
ffc0f1a8: 38 e0 00 00 li r7,0
ffc0f1ac: 39 00 00 00 li r8,0
ffc0f1b0: 4b ff e1 c9 bl ffc0d378 <rtems_bdbuf_obtain_disk.part.7>
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)
ffc0f1b4: 7c 7c 1b 79 mr. r28,r3
ffc0f1b8: 40 82 00 40 bne- ffc0f1f8 <rtems_bdbuf_syncdev+0x90> <== 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 ();
ffc0f1bc: 4b ff da d1 bl ffc0cc8c <rtems_bdbuf_lock_sync>
rtems_bdbuf_lock_cache ();
ffc0f1c0: 4b ff da 89 bl ffc0cc48 <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;
ffc0f1c4: 38 00 00 01 li r0,1
ffc0f1c8: 98 1d 00 30 stb r0,48(r29)
bdbuf_cache.sync_requester = rtems_task_self ();
ffc0f1cc: 48 00 29 fd bl ffc11bc8 <rtems_task_self>
ffc0f1d0: 90 7d 00 34 stw r3,52(r29)
bdbuf_cache.sync_device = dev;
ffc0f1d4: 93 dd 00 38 stw r30,56(r29)
ffc0f1d8: 93 fd 00 3c stw r31,60(r29)
rtems_bdbuf_wake_swapper ();
ffc0f1dc: 4b ff dd 71 bl ffc0cf4c <rtems_bdbuf_wake_swapper>
rtems_bdbuf_unlock_cache ();
ffc0f1e0: 4b ff dc c1 bl ffc0cea0 <rtems_bdbuf_unlock_cache>
rtems_bdbuf_wait_for_event (RTEMS_BDBUF_TRANSFER_SYNC);
ffc0f1e4: 38 60 00 02 li r3,2
ffc0f1e8: 4b ff dd d1 bl ffc0cfb8 <rtems_bdbuf_wait_for_event>
rtems_bdbuf_unlock_sync ();
ffc0f1ec: 4b ff dc f1 bl ffc0cedc <rtems_bdbuf_unlock_sync>
rtems_bdbuf_release_disk (dd);
ffc0f1f0: 80 61 00 08 lwz r3,8(r1)
ffc0f1f4: 4b ff dd 25 bl ffc0cf18 <rtems_bdbuf_release_disk>
return RTEMS_SUCCESSFUL;
}
ffc0f1f8: 39 61 00 28 addi r11,r1,40
ffc0f1fc: 7f 83 e3 78 mr r3,r28
ffc0f200: 48 00 a3 0c b ffc1950c <_restgpr_28_x>
ffc0cea0 <rtems_bdbuf_unlock_cache>:
* @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);
ffc0cea0: 3d 20 00 00 lis r9,0
/**
* Unlock the cache.
*/
static void
rtems_bdbuf_unlock_cache (void)
{
ffc0cea4: 94 21 ff f8 stwu r1,-8(r1)
ffc0cea8: 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);
ffc0ceac: 80 69 2a 30 lwz r3,10800(r9)
/**
* Unlock the cache.
*/
static void
rtems_bdbuf_unlock_cache (void)
{
ffc0ceb0: 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);
ffc0ceb4: 4b ff bd 91 bl ffc08c44 <rtems_semaphore_release>
if (sc != RTEMS_SUCCESSFUL)
ffc0ceb8: 2f 83 00 00 cmpwi cr7,r3,0
ffc0cebc: 41 be 00 10 beq+ cr7,ffc0cecc <rtems_bdbuf_unlock_cache+0x2c><== ALWAYS TAKEN
rtems_fatal_error_occurred (fatal_error_code);
ffc0cec0: 3c 60 42 00 lis r3,16896 <== NOT EXECUTED
ffc0cec4: 60 63 00 0e ori r3,r3,14 <== NOT EXECUTED
ffc0cec8: 4b ff c3 dd bl ffc092a4 <rtems_fatal_error_occurred> <== NOT EXECUTED
*/
static void
rtems_bdbuf_unlock_cache (void)
{
rtems_bdbuf_unlock (bdbuf_cache.lock, RTEMS_BLKDEV_FATAL_BDBUF_CACHE_UNLOCK);
}
ffc0cecc: 80 01 00 0c lwz r0,12(r1)
ffc0ced0: 38 21 00 08 addi r1,r1,8
ffc0ced4: 7c 08 03 a6 mtlr r0
ffc0ced8: 4e 80 00 20 blr
ffc0cedc <rtems_bdbuf_unlock_sync>:
* @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);
ffc0cedc: 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)
{
ffc0cee0: 94 21 ff f8 stwu r1,-8(r1)
ffc0cee4: 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);
ffc0cee8: 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)
{
ffc0ceec: 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);
ffc0cef0: 4b ff bd 55 bl ffc08c44 <rtems_semaphore_release>
if (sc != RTEMS_SUCCESSFUL)
ffc0cef4: 2f 83 00 00 cmpwi cr7,r3,0
ffc0cef8: 41 be 00 10 beq+ cr7,ffc0cf08 <rtems_bdbuf_unlock_sync+0x2c><== ALWAYS TAKEN
rtems_fatal_error_occurred (fatal_error_code);
ffc0cefc: 3c 60 42 00 lis r3,16896 <== NOT EXECUTED
ffc0cf00: 60 63 00 0c ori r3,r3,12 <== NOT EXECUTED
ffc0cf04: 4b ff c3 a1 bl ffc092a4 <rtems_fatal_error_occurred> <== NOT EXECUTED
static void
rtems_bdbuf_unlock_sync (void)
{
rtems_bdbuf_unlock (bdbuf_cache.sync_lock,
RTEMS_BLKDEV_FATAL_BDBUF_SYNC_UNLOCK);
}
ffc0cf08: 80 01 00 0c lwz r0,12(r1)
ffc0cf0c: 38 21 00 08 addi r1,r1,8
ffc0cf10: 7c 08 03 a6 mtlr r0
ffc0cf14: 4e 80 00 20 blr
ffc0cfb8 <rtems_bdbuf_wait_for_event>:
return RTEMS_UNSATISFIED;
}
static void
rtems_bdbuf_wait_for_event (rtems_event_set event)
{
ffc0cfb8: 7c 08 02 a6 mflr r0
ffc0cfbc: 7c 2b 0b 78 mr r11,r1
ffc0cfc0: 94 21 ff e0 stwu r1,-32(r1)
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_event_set out = 0;
sc = rtems_event_receive (event,
ffc0cfc4: 38 80 00 00 li r4,0
ffc0cfc8: 38 a0 00 00 li r5,0
return RTEMS_UNSATISFIED;
}
static void
rtems_bdbuf_wait_for_event (rtems_event_set event)
{
ffc0cfcc: 90 01 00 24 stw r0,36(r1)
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_event_set out = 0;
ffc0cfd0: 7c 26 0b 78 mr r6,r1
ffc0cfd4: 38 00 00 00 li r0,0
return RTEMS_UNSATISFIED;
}
static void
rtems_bdbuf_wait_for_event (rtems_event_set event)
{
ffc0cfd8: 48 00 c4 f5 bl ffc194cc <_savegpr_31>
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_event_set out = 0;
ffc0cfdc: 94 06 00 08 stwu r0,8(r6)
return RTEMS_UNSATISFIED;
}
static void
rtems_bdbuf_wait_for_event (rtems_event_set event)
{
ffc0cfe0: 7c 7f 1b 78 mr r31,r3
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_event_set out = 0;
sc = rtems_event_receive (event,
ffc0cfe4: 4b ff b4 e5 bl ffc084c8 <rtems_event_receive>
RTEMS_EVENT_ALL | RTEMS_WAIT,
RTEMS_NO_TIMEOUT,
&out);
if (sc != RTEMS_SUCCESSFUL || out != event)
ffc0cfe8: 2f 83 00 00 cmpwi cr7,r3,0
ffc0cfec: 40 9e 00 10 bne- cr7,ffc0cffc <rtems_bdbuf_wait_for_event+0x44><== NEVER TAKEN
ffc0cff0: 80 01 00 08 lwz r0,8(r1)
ffc0cff4: 7f 80 f8 00 cmpw cr7,r0,r31
ffc0cff8: 41 be 00 10 beq+ cr7,ffc0d008 <rtems_bdbuf_wait_for_event+0x50><== ALWAYS TAKEN
rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_WAIT_EVNT);
ffc0cffc: 3c 60 42 00 lis r3,16896 <== NOT EXECUTED
ffc0d000: 60 63 00 1a ori r3,r3,26 <== NOT EXECUTED
ffc0d004: 4b ff c2 a1 bl ffc092a4 <rtems_fatal_error_occurred> <== NOT EXECUTED
}
ffc0d008: 39 61 00 20 addi r11,r1,32
ffc0d00c: 48 00 c5 0c b ffc19518 <_restgpr_31_x>
ffc0d250 <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)
{
ffc0d250: 7c 08 02 a6 mflr r0
ffc0d254: 94 21 ff f8 stwu r1,-8(r1)
ffc0d258: 90 01 00 0c stw r0,12(r1)
rtems_status_code sc = RTEMS_SUCCESSFUL;
if (waiters->count > 0)
ffc0d25c: 80 03 00 00 lwz r0,0(r3)
ffc0d260: 2f 80 00 00 cmpwi cr7,r0,0
ffc0d264: 41 be 00 20 beq+ cr7,ffc0d284 <rtems_bdbuf_wake+0x34>
{
sc = rtems_semaphore_flush (waiters->sema);
ffc0d268: 80 63 00 04 lwz r3,4(r3)
ffc0d26c: 48 00 46 f5 bl ffc11960 <rtems_semaphore_flush>
if (sc != RTEMS_SUCCESSFUL)
ffc0d270: 2f 83 00 00 cmpwi cr7,r3,0
ffc0d274: 41 be 00 10 beq+ cr7,ffc0d284 <rtems_bdbuf_wake+0x34> <== ALWAYS TAKEN
rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_CACHE_WAKE);
ffc0d278: 3c 60 42 00 lis r3,16896 <== NOT EXECUTED
ffc0d27c: 60 63 00 13 ori r3,r3,19 <== NOT EXECUTED
ffc0d280: 4b ff c0 25 bl ffc092a4 <rtems_fatal_error_occurred> <== NOT EXECUTED
}
}
ffc0d284: 80 01 00 0c lwz r0,12(r1)
ffc0d288: 38 21 00 08 addi r1,r1,8
ffc0d28c: 7c 08 03 a6 mtlr r0
ffc0d290: 4e 80 00 20 blr
ffc0cf4c <rtems_bdbuf_wake_swapper>:
}
static void
rtems_bdbuf_wake_swapper (void)
{
rtems_status_code sc = rtems_event_send (bdbuf_cache.swapout,
ffc0cf4c: 3d 20 00 00 lis r9,0
}
}
static void
rtems_bdbuf_wake_swapper (void)
{
ffc0cf50: 94 21 ff f8 stwu r1,-8(r1)
ffc0cf54: 7c 08 02 a6 mflr r0
rtems_status_code sc = rtems_event_send (bdbuf_cache.swapout,
ffc0cf58: 38 80 00 04 li r4,4
ffc0cf5c: 80 69 2a 08 lwz r3,10760(r9)
}
}
static void
rtems_bdbuf_wake_swapper (void)
{
ffc0cf60: 90 01 00 0c stw r0,12(r1)
rtems_status_code sc = rtems_event_send (bdbuf_cache.swapout,
ffc0cf64: 4b ff b7 01 bl ffc08664 <rtems_event_send>
RTEMS_BDBUF_SWAPOUT_SYNC);
if (sc != RTEMS_SUCCESSFUL)
ffc0cf68: 2f 83 00 00 cmpwi cr7,r3,0
ffc0cf6c: 41 be 00 10 beq+ cr7,ffc0cf7c <rtems_bdbuf_wake_swapper+0x30><== ALWAYS TAKEN
rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_SO_WAKE);
ffc0cf70: 3c 60 42 00 lis r3,16896 <== NOT EXECUTED
ffc0cf74: 60 63 00 14 ori r3,r3,20 <== NOT EXECUTED
ffc0cf78: 4b ff c3 2d bl ffc092a4 <rtems_fatal_error_occurred> <== NOT EXECUTED
}
ffc0cf7c: 80 01 00 0c lwz r0,12(r1)
ffc0cf80: 38 21 00 08 addi r1,r1,8
ffc0cf84: 7c 08 03 a6 mtlr r0
ffc0cf88: 4e 80 00 20 blr
ffc0f49c <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)
{
ffc0f49c: 7c 08 02 a6 mflr r0
ffc0f4a0: 7c 2b 0b 78 mr r11,r1
ffc0f4a4: 94 21 ff f0 stwu r1,-16(r1)
ffc0f4a8: 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)
ffc0f4ac: 3c 00 40 04 lis r0,16388
ffc0f4b0: 60 00 42 03 ori r0,r0,16899
rtems_device_driver
rtems_blkdev_generic_ioctl(
rtems_device_major_number major __attribute__((unused)),
rtems_device_minor_number minor __attribute__((unused)),
void * arg)
{
ffc0f4b4: 48 00 a0 19 bl ffc194cc <_savegpr_31>
rtems_libio_ioctl_args_t *args = arg;
rtems_libio_t *iop = args->iop;
rtems_disk_device *dd = iop->data1;
int rc;
switch (args->command)
ffc0f4b8: 80 85 00 04 lwz r4,4(r5)
rtems_device_driver
rtems_blkdev_generic_ioctl(
rtems_device_major_number major __attribute__((unused)),
rtems_device_minor_number minor __attribute__((unused)),
void * arg)
{
ffc0f4bc: 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;
ffc0f4c0: 81 25 00 00 lwz r9,0(r5)
int rc;
switch (args->command)
ffc0f4c4: 7f 84 00 00 cmpw cr7,r4,r0
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;
ffc0f4c8: 81 29 00 38 lwz r9,56(r9)
int rc;
switch (args->command)
ffc0f4cc: 41 9e 00 58 beq- cr7,ffc0f524 <rtems_blkdev_generic_ioctl+0x88><== NEVER TAKEN
ffc0f4d0: 7f 84 00 40 cmplw cr7,r4,r0
ffc0f4d4: 41 9d 00 20 bgt- cr7,ffc0f4f4 <rtems_blkdev_generic_ioctl+0x58><== ALWAYS TAKEN
ffc0f4d8: 6c 80 20 00 xoris r0,r4,8192 <== NOT EXECUTED
ffc0f4dc: 2f 80 42 06 cmpwi cr7,r0,16902 <== NOT EXECUTED
ffc0f4e0: 41 9e 00 74 beq- cr7,ffc0f554 <rtems_blkdev_generic_ioctl+0xb8><== NOT EXECUTED
ffc0f4e4: 6c 80 40 04 xoris r0,r4,16388 <== NOT EXECUTED
ffc0f4e8: 2f 80 42 02 cmpwi cr7,r0,16898 <== NOT EXECUTED
ffc0f4ec: 40 9e 00 8c bne- cr7,ffc0f578 <rtems_blkdev_generic_ioctl+0xdc><== NOT EXECUTED
ffc0f4f0: 48 00 00 2c b ffc0f51c <rtems_blkdev_generic_ioctl+0x80><== NOT EXECUTED
ffc0f4f4: 6c 80 80 04 xoris r0,r4,32772
ffc0f4f8: 2f 80 42 04 cmpwi cr7,r0,16900
ffc0f4fc: 41 9e 00 40 beq- cr7,ffc0f53c <rtems_blkdev_generic_ioctl+0xa0><== ALWAYS TAKEN
ffc0f500: 6c 80 c0 18 xoris r0,r4,49176 <== NOT EXECUTED
ffc0f504: 2f 80 42 01 cmpwi cr7,r0,16897 <== NOT EXECUTED
ffc0f508: 41 9e 00 68 beq- cr7,ffc0f570 <rtems_blkdev_generic_ioctl+0xd4><== NOT EXECUTED
ffc0f50c: 6c 80 40 04 xoris r0,r4,16388 <== NOT EXECUTED
ffc0f510: 2f 80 42 05 cmpwi cr7,r0,16901 <== NOT EXECUTED
ffc0f514: 40 9e 00 64 bne- cr7,ffc0f578 <rtems_blkdev_generic_ioctl+0xdc><== NOT EXECUTED
ffc0f518: 48 00 00 34 b ffc0f54c <rtems_blkdev_generic_ioctl+0xb0><== NOT EXECUTED
{
case RTEMS_BLKIO_GETMEDIABLKSIZE:
*((uint32_t *) args->buffer) = dd->media_block_size;
ffc0f51c: 80 09 00 24 lwz r0,36(r9) <== NOT EXECUTED
ffc0f520: 48 00 00 08 b ffc0f528 <rtems_blkdev_generic_ioctl+0x8c><== NOT EXECUTED
args->ioctl_return = 0;
break;
case RTEMS_BLKIO_GETBLKSIZE:
*((uint32_t *) args->buffer) = dd->block_size;
ffc0f524: 80 09 00 20 lwz r0,32(r9) <== NOT EXECUTED
ffc0f528: 81 3f 00 08 lwz r9,8(r31) <== NOT EXECUTED
ffc0f52c: 90 09 00 00 stw r0,0(r9) <== NOT EXECUTED
args->ioctl_return = 0;
ffc0f530: 38 00 00 00 li r0,0
ffc0f534: 90 1f 00 0c stw r0,12(r31)
break;
ffc0f538: 48 00 00 58 b ffc0f590 <rtems_blkdev_generic_ioctl+0xf4>
case RTEMS_BLKIO_SETBLKSIZE:
dd->block_size = *((uint32_t *) args->buffer);
ffc0f53c: 81 65 00 08 lwz r11,8(r5)
ffc0f540: 80 0b 00 00 lwz r0,0(r11)
ffc0f544: 90 09 00 20 stw r0,32(r9)
ffc0f548: 4b ff ff e8 b ffc0f530 <rtems_blkdev_generic_ioctl+0x94>
args->ioctl_return = 0;
break;
case RTEMS_BLKIO_GETSIZE:
*((rtems_blkdev_bnum *) args->buffer) = dd->size;
ffc0f54c: 80 09 00 1c lwz r0,28(r9) <== NOT EXECUTED
ffc0f550: 4b ff ff d8 b ffc0f528 <rtems_blkdev_generic_ioctl+0x8c><== NOT EXECUTED
args->ioctl_return = 0;
break;
case RTEMS_BLKIO_SYNCDEV:
rc = rtems_bdbuf_syncdev(dd->dev);
ffc0f554: 80 69 00 00 lwz r3,0(r9) <== NOT EXECUTED
ffc0f558: 80 89 00 04 lwz r4,4(r9) <== NOT EXECUTED
ffc0f55c: 4b ff fc 0d bl ffc0f168 <rtems_bdbuf_syncdev> <== NOT EXECUTED
args->ioctl_return = (uint32_t) (rc == RTEMS_SUCCESSFUL ? 0 : -1);
ffc0f560: 38 00 ff ff li r0,-1 <== NOT EXECUTED
ffc0f564: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc0f568: 40 9e ff cc bne+ cr7,ffc0f534 <rtems_blkdev_generic_ioctl+0x98><== NOT EXECUTED
ffc0f56c: 4b ff ff c4 b ffc0f530 <rtems_blkdev_generic_ioctl+0x94><== NOT EXECUTED
case RTEMS_BLKIO_REQUEST:
/*
* It is not allowed to directly access the driver circumventing
* the cache.
*/
args->ioctl_return = (uint32_t) -1;
ffc0f570: 38 00 ff ff li r0,-1 <== NOT EXECUTED
ffc0f574: 4b ff ff c0 b ffc0f534 <rtems_blkdev_generic_ioctl+0x98><== NOT EXECUTED
break;
default:
args->ioctl_return = (uint32_t) dd->ioctl(dd->phys_dev,
ffc0f578: 80 09 00 28 lwz r0,40(r9) <== NOT EXECUTED
ffc0f57c: 80 69 00 08 lwz r3,8(r9) <== NOT EXECUTED
ffc0f580: 80 bf 00 08 lwz r5,8(r31) <== NOT EXECUTED
ffc0f584: 7c 09 03 a6 mtctr r0 <== NOT EXECUTED
ffc0f588: 4e 80 04 21 bctrl <== NOT EXECUTED
ffc0f58c: 90 7f 00 0c stw r3,12(r31) <== NOT EXECUTED
args->buffer);
break;
}
return RTEMS_SUCCESSFUL;
}
ffc0f590: 39 61 00 10 addi r11,r1,16
ffc0f594: 38 60 00 00 li r3,0
ffc0f598: 48 00 9f 80 b ffc19518 <_restgpr_31_x>
ffc0f22c <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)
{
ffc0f22c: 94 21 ff c0 stwu r1,-64(r1)
ffc0f230: 7c 08 02 a6 mflr r0
ffc0f234: 90 01 00 44 stw r0,68(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;
ffc0f238: 81 25 00 00 lwz r9,0(r5)
rtems_device_driver
rtems_blkdev_generic_read(
rtems_device_major_number major __attribute__((unused)),
rtems_device_minor_number minor __attribute__((unused)),
void * arg)
{
ffc0f23c: be c1 00 18 stmw r22,24(r1)
ffc0f240: 7c bd 2b 78 mr r29,r5
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;
ffc0f244: 83 69 00 38 lwz r27,56(r9)
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);
ffc0f248: 83 c5 00 08 lwz r30,8(r5)
{
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;
ffc0f24c: 83 3b 00 20 lwz r25,32(r27)
char *buf = args->buffer;
uint32_t count = args->count;
rtems_blkdev_bnum block = (rtems_blkdev_bnum) (args->offset / block_size);
ffc0f250: 83 e5 00 0c lwz r31,12(r5)
ffc0f254: 7f c3 f3 78 mr r3,r30
ffc0f258: 7f 26 cb 78 mr r6,r25
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;
ffc0f25c: 83 05 00 10 lwz r24,16(r5)
uint32_t count = args->count;
rtems_blkdev_bnum block = (rtems_blkdev_bnum) (args->offset / block_size);
ffc0f260: 7f e4 fb 78 mr r4,r31
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;
ffc0f264: 83 85 00 14 lwz r28,20(r5)
rtems_blkdev_bnum block = (rtems_blkdev_bnum) (args->offset / block_size);
ffc0f268: 38 a0 00 00 li r5,0
ffc0f26c: 48 00 91 fd bl ffc18468 <__divdi3>
uint32_t blkofs = (uint32_t) (args->offset % block_size);
ffc0f270: 7f c3 f3 78 mr r3,r30
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);
ffc0f274: 7c 97 23 78 mr r23,r4
uint32_t blkofs = (uint32_t) (args->offset % block_size);
ffc0f278: 38 a0 00 00 li r5,0
ffc0f27c: 7f e4 fb 78 mr r4,r31
ffc0f280: 7f 26 cb 78 mr r6,r25
ffc0f284: 48 00 96 25 bl ffc188a8 <__moddi3>
dev_t dev = dd->dev;
args->bytes_moved = 0;
ffc0f288: 38 00 00 00 li r0,0
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);
uint32_t blkofs = (uint32_t) (args->offset % block_size);
dev_t dev = dd->dev;
ffc0f28c: 83 db 00 00 lwz r30,0(r27)
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);
uint32_t blkofs = (uint32_t) (args->offset % block_size);
ffc0f290: 7c 9a 23 78 mr r26,r4
dev_t dev = dd->dev;
ffc0f294: 83 fb 00 04 lwz r31,4(r27)
args->bytes_moved = 0;
while (count > 0)
ffc0f298: 3b 60 00 00 li r27,0
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;
ffc0f29c: 90 1d 00 1c stw r0,28(r29)
while (count > 0)
ffc0f2a0: 48 00 00 70 b ffc0f310 <rtems_blkdev_generic_read+0xe4>
{
rtems_bdbuf_buffer *diskbuf;
uint32_t copy;
rc = rtems_bdbuf_read(dev, block, &diskbuf);
ffc0f2a4: 7f c3 f3 78 mr r3,r30
ffc0f2a8: 7f e4 fb 78 mr r4,r31
ffc0f2ac: 38 c1 00 08 addi r6,r1,8
ffc0f2b0: 4b ff f9 59 bl ffc0ec08 <rtems_bdbuf_read>
if (rc != RTEMS_SUCCESSFUL)
ffc0f2b4: 2c 03 00 00 cmpwi r3,0
ffc0f2b8: 40 82 00 68 bne- ffc0f320 <rtems_blkdev_generic_read+0xf4><== NEVER TAKEN
break;
copy = block_size - blkofs;
ffc0f2bc: 7e da c8 50 subf r22,r26,r25
ffc0f2c0: 7f 96 e0 40 cmplw cr7,r22,r28
ffc0f2c4: 40 9d 00 08 ble- cr7,ffc0f2cc <rtems_blkdev_generic_read+0xa0><== ALWAYS TAKEN
ffc0f2c8: 7f 96 e3 78 mr r22,r28 <== NOT EXECUTED
if (copy > count)
copy = count;
memcpy(buf, (char *)diskbuf->buffer + blkofs, copy);
ffc0f2cc: 81 21 00 08 lwz r9,8(r1)
ffc0f2d0: 7e c5 b3 78 mr r5,r22
ffc0f2d4: 7f 03 c3 78 mr r3,r24
ffc0f2d8: 80 89 00 24 lwz r4,36(r9)
rc = rtems_bdbuf_release(diskbuf);
args->bytes_moved += copy;
ffc0f2dc: 3b 7b 00 01 addi r27,r27,1
if (rc != RTEMS_SUCCESSFUL)
break;
copy = block_size - blkofs;
if (copy > count)
copy = count;
memcpy(buf, (char *)diskbuf->buffer + blkofs, copy);
ffc0f2e0: 7c 84 d2 14 add r4,r4,r26
ffc0f2e4: 48 00 5f 85 bl ffc15268 <memcpy>
rc = rtems_bdbuf_release(diskbuf);
ffc0f2e8: 80 61 00 08 lwz r3,8(r1)
ffc0f2ec: 4b ff fb 99 bl ffc0ee84 <rtems_bdbuf_release>
args->bytes_moved += copy;
ffc0f2f0: 80 1d 00 1c lwz r0,28(r29)
if (rc != RTEMS_SUCCESSFUL)
ffc0f2f4: 2c 03 00 00 cmpwi r3,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;
ffc0f2f8: 7c 00 b2 14 add r0,r0,r22
ffc0f2fc: 90 1d 00 1c stw r0,28(r29)
if (rc != RTEMS_SUCCESSFUL)
ffc0f300: 40 82 00 20 bne- ffc0f320 <rtems_blkdev_generic_read+0xf4><== NEVER TAKEN
break;
count -= copy;
ffc0f304: 7f 96 e0 50 subf r28,r22,r28
buf += copy;
ffc0f308: 7f 18 b2 14 add r24,r24,r22
blkofs = 0;
ffc0f30c: 3b 40 00 00 li r26,0
uint32_t blkofs = (uint32_t) (args->offset % block_size);
dev_t dev = dd->dev;
args->bytes_moved = 0;
while (count > 0)
ffc0f310: 2f 9c 00 00 cmpwi cr7,r28,0
/* rtems_blkdev_generic_read --
* Generic block device read primitive. Implemented using block device
* buffer management primitives.
*/
rtems_device_driver
rtems_blkdev_generic_read(
ffc0f314: 7c bb ba 14 add r5,r27,r23
uint32_t blkofs = (uint32_t) (args->offset % block_size);
dev_t dev = dd->dev;
args->bytes_moved = 0;
while (count > 0)
ffc0f318: 40 9e ff 8c bne+ cr7,ffc0f2a4 <rtems_blkdev_generic_read+0x78>
ffc0f31c: 38 60 00 00 li r3,0
blkofs = 0;
block++;
}
return rc;
}
ffc0f320: 39 61 00 40 addi r11,r1,64
ffc0f324: 48 00 a1 d0 b ffc194f4 <_restgpr_22_x>
ffc0f328 <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)
{
ffc0f328: 94 21 ff c0 stwu r1,-64(r1)
ffc0f32c: 7c 08 02 a6 mflr r0
ffc0f330: 90 01 00 44 stw r0,68(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;
ffc0f334: 81 25 00 00 lwz r9,0(r5)
rtems_device_driver
rtems_blkdev_generic_write(
rtems_device_major_number major __attribute__((unused)),
rtems_device_minor_number minor __attribute__((unused)),
void * arg)
{
ffc0f338: be c1 00 18 stmw r22,24(r1)
ffc0f33c: 7c bd 2b 78 mr r29,r5
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;
ffc0f340: 83 29 00 38 lwz r25,56(r9)
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);
ffc0f344: 83 c5 00 08 lwz r30,8(r5)
{
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;
ffc0f348: 83 59 00 20 lwz r26,32(r25)
char *buf = args->buffer;
uint32_t count = args->count;
rtems_blkdev_bnum block = (rtems_blkdev_bnum) (args->offset / block_size);
ffc0f34c: 83 e5 00 0c lwz r31,12(r5)
ffc0f350: 7f c3 f3 78 mr r3,r30
ffc0f354: 7f 46 d3 78 mr r6,r26
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;
ffc0f358: 83 05 00 10 lwz r24,16(r5)
uint32_t count = args->count;
rtems_blkdev_bnum block = (rtems_blkdev_bnum) (args->offset / block_size);
ffc0f35c: 7f e4 fb 78 mr r4,r31
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;
ffc0f360: 83 85 00 14 lwz r28,20(r5)
rtems_blkdev_bnum block = (rtems_blkdev_bnum) (args->offset / block_size);
ffc0f364: 38 a0 00 00 li r5,0
ffc0f368: 48 00 91 01 bl ffc18468 <__divdi3>
uint32_t blkofs = (uint32_t) (args->offset % block_size);
ffc0f36c: 7f c3 f3 78 mr r3,r30
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);
ffc0f370: 7c 97 23 78 mr r23,r4
uint32_t blkofs = (uint32_t) (args->offset % block_size);
ffc0f374: 38 a0 00 00 li r5,0
ffc0f378: 7f e4 fb 78 mr r4,r31
ffc0f37c: 7f 46 d3 78 mr r6,r26
ffc0f380: 48 00 95 29 bl ffc188a8 <__moddi3>
dev_t dev = dd->dev;
args->bytes_moved = 0;
ffc0f384: 38 00 00 00 li r0,0
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);
uint32_t blkofs = (uint32_t) (args->offset % block_size);
dev_t dev = dd->dev;
ffc0f388: 83 d9 00 00 lwz r30,0(r25)
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);
uint32_t blkofs = (uint32_t) (args->offset % block_size);
ffc0f38c: 7c 9b 23 78 mr r27,r4
dev_t dev = dd->dev;
ffc0f390: 83 f9 00 04 lwz r31,4(r25)
args->bytes_moved = 0;
while (count > 0)
ffc0f394: 3b 20 00 00 li r25,0
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;
ffc0f398: 90 1d 00 1c stw r0,28(r29)
while (count > 0)
ffc0f39c: 48 00 00 88 b ffc0f424 <rtems_blkdev_generic_write+0xfc>
{
rtems_bdbuf_buffer *diskbuf;
uint32_t copy;
if ((blkofs == 0) && (count >= block_size))
ffc0f3a0: 2f 9b 00 00 cmpwi cr7,r27,0
rc = rtems_bdbuf_get(dev, block, &diskbuf);
ffc0f3a4: 7f c3 f3 78 mr r3,r30
ffc0f3a8: 7f e4 fb 78 mr r4,r31
ffc0f3ac: 38 c1 00 08 addi r6,r1,8
while (count > 0)
{
rtems_bdbuf_buffer *diskbuf;
uint32_t copy;
if ((blkofs == 0) && (count >= block_size))
ffc0f3b0: 40 9e 00 14 bne- cr7,ffc0f3c4 <rtems_blkdev_generic_write+0x9c><== NEVER TAKEN
ffc0f3b4: 7f 9c d0 40 cmplw cr7,r28,r26
ffc0f3b8: 41 bc 00 0c blt+ cr7,ffc0f3c4 <rtems_blkdev_generic_write+0x9c><== NEVER TAKEN
rc = rtems_bdbuf_get(dev, block, &diskbuf);
ffc0f3bc: 4b ff f7 71 bl ffc0eb2c <rtems_bdbuf_get>
ffc0f3c0: 48 00 00 08 b ffc0f3c8 <rtems_blkdev_generic_write+0xa0>
else
rc = rtems_bdbuf_read(dev, block, &diskbuf);
ffc0f3c4: 4b ff f8 45 bl ffc0ec08 <rtems_bdbuf_read> <== NOT EXECUTED
if (rc != RTEMS_SUCCESSFUL)
ffc0f3c8: 2f 83 00 00 cmpwi cr7,r3,0
ffc0f3cc: 40 9e 00 68 bne- cr7,ffc0f434 <rtems_blkdev_generic_write+0x10c><== NEVER TAKEN
break;
copy = block_size - blkofs;
ffc0f3d0: 7e db d0 50 subf r22,r27,r26
ffc0f3d4: 7f 96 e0 40 cmplw cr7,r22,r28
ffc0f3d8: 40 9d 00 08 ble- cr7,ffc0f3e0 <rtems_blkdev_generic_write+0xb8><== ALWAYS TAKEN
ffc0f3dc: 7f 96 e3 78 mr r22,r28 <== NOT EXECUTED
if (copy > count)
copy = count;
memcpy((char *)diskbuf->buffer + blkofs, buf, copy);
ffc0f3e0: 81 21 00 08 lwz r9,8(r1)
ffc0f3e4: 7f 04 c3 78 mr r4,r24
ffc0f3e8: 7e c5 b3 78 mr r5,r22
ffc0f3ec: 80 69 00 24 lwz r3,36(r9)
args->bytes_moved += copy;
rc = rtems_bdbuf_release_modified(diskbuf);
ffc0f3f0: 3b 39 00 01 addi r25,r25,1
break;
copy = block_size - blkofs;
if (copy > count)
copy = count;
memcpy((char *)diskbuf->buffer + blkofs, buf, copy);
ffc0f3f4: 7c 63 da 14 add r3,r3,r27
ffc0f3f8: 48 00 5e 71 bl ffc15268 <memcpy>
args->bytes_moved += copy;
ffc0f3fc: 80 1d 00 1c lwz r0,28(r29)
rc = rtems_bdbuf_release_modified(diskbuf);
ffc0f400: 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;
ffc0f404: 7c 00 b2 14 add r0,r0,r22
ffc0f408: 90 1d 00 1c stw r0,28(r29)
rc = rtems_bdbuf_release_modified(diskbuf);
ffc0f40c: 4b ff fb 5d bl ffc0ef68 <rtems_bdbuf_release_modified>
if (rc != RTEMS_SUCCESSFUL)
ffc0f410: 2c 03 00 00 cmpwi r3,0
ffc0f414: 40 82 00 20 bne- ffc0f434 <rtems_blkdev_generic_write+0x10c><== NEVER TAKEN
break;
count -= copy;
ffc0f418: 7f 96 e0 50 subf r28,r22,r28
buf += copy;
ffc0f41c: 7f 18 b2 14 add r24,r24,r22
blkofs = 0;
ffc0f420: 3b 60 00 00 li r27,0
uint32_t blkofs = (uint32_t) (args->offset % block_size);
dev_t dev = dd->dev;
args->bytes_moved = 0;
while (count > 0)
ffc0f424: 2f 9c 00 00 cmpwi cr7,r28,0
/* rtems_blkdev_generic_write --
* Generic block device write primitive. Implemented using block device
* buffer management primitives.
*/
rtems_device_driver
rtems_blkdev_generic_write(
ffc0f428: 7c b9 ba 14 add r5,r25,r23
uint32_t blkofs = (uint32_t) (args->offset % block_size);
dev_t dev = dd->dev;
args->bytes_moved = 0;
while (count > 0)
ffc0f42c: 40 9e ff 74 bne+ cr7,ffc0f3a0 <rtems_blkdev_generic_write+0x78>
ffc0f430: 38 60 00 00 li r3,0
blkofs = 0;
block++;
}
return rc;
}
ffc0f434: 39 61 00 40 addi r11,r1,64
ffc0f438: 48 00 a0 bc b ffc194f4 <_restgpr_22_x>
ffc0f59c <rtems_blkdev_ioctl>:
int
rtems_blkdev_ioctl(rtems_disk_device *dd, uint32_t req, void *argp)
{
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)
size_t *arg_size = argp;
int rc = 0;
switch (req)
ffc0f5a8: 3c 00 40 04 lis r0,16388
ffc0f5ac: 60 00 42 03 ori r0,r0,16899
ffc0f5b0: 7f 84 00 00 cmpw cr7,r4,r0
ffc0f5b4: 41 9e 00 44 beq- cr7,ffc0f5f8 <rtems_blkdev_ioctl+0x5c> <== NEVER TAKEN
ffc0f5b8: 7f 84 00 40 cmplw cr7,r4,r0
ffc0f5bc: 3c 00 40 04 lis r0,16388
ffc0f5c0: 41 9d 00 14 bgt- cr7,ffc0f5d4 <rtems_blkdev_ioctl+0x38>
ffc0f5c4: 60 00 42 02 ori r0,r0,16898
ffc0f5c8: 7f 84 00 00 cmpw cr7,r4,r0
ffc0f5cc: 40 be 00 50 bne+ cr7,ffc0f61c <rtems_blkdev_ioctl+0x80> <== ALWAYS TAKEN
ffc0f5d0: 48 00 00 20 b ffc0f5f0 <rtems_blkdev_ioctl+0x54> <== NOT EXECUTED
ffc0f5d4: 60 00 42 05 ori r0,r0,16901
ffc0f5d8: 7f 84 00 00 cmpw cr7,r4,r0
ffc0f5dc: 41 9e 00 38 beq- cr7,ffc0f614 <rtems_blkdev_ioctl+0x78> <== NEVER TAKEN
ffc0f5e0: 6c 80 80 04 xoris r0,r4,32772
ffc0f5e4: 2f 80 42 04 cmpwi cr7,r0,16900
ffc0f5e8: 40 9e 00 34 bne- cr7,ffc0f61c <rtems_blkdev_ioctl+0x80> <== NEVER TAKEN
ffc0f5ec: 48 00 00 1c b ffc0f608 <rtems_blkdev_ioctl+0x6c>
{
case RTEMS_BLKIO_GETMEDIABLKSIZE:
*arg_size = dd->media_block_size;
ffc0f5f0: 80 03 00 24 lwz r0,36(r3) <== NOT EXECUTED
ffc0f5f4: 48 00 00 08 b ffc0f5fc <rtems_blkdev_ioctl+0x60> <== NOT EXECUTED
break;
case RTEMS_BLKIO_GETBLKSIZE:
*arg_size = dd->block_size;
ffc0f5f8: 80 03 00 20 lwz r0,32(r3) <== NOT EXECUTED
ffc0f5fc: 90 05 00 00 stw r0,0(r5) <== NOT EXECUTED
int
rtems_blkdev_ioctl(rtems_disk_device *dd, uint32_t req, void *argp)
{
size_t *arg_size = argp;
int rc = 0;
ffc0f600: 38 60 00 00 li r3,0
*arg_size = dd->media_block_size;
break;
case RTEMS_BLKIO_GETBLKSIZE:
*arg_size = dd->block_size;
break;
ffc0f604: 48 00 00 28 b ffc0f62c <rtems_blkdev_ioctl+0x90>
case RTEMS_BLKIO_SETBLKSIZE:
dd->block_size = *arg_size;
ffc0f608: 80 05 00 00 lwz r0,0(r5)
ffc0f60c: 90 03 00 20 stw r0,32(r3)
ffc0f610: 4b ff ff f0 b ffc0f600 <rtems_blkdev_ioctl+0x64>
break;
case RTEMS_BLKIO_GETSIZE:
*arg_size = dd->size;
ffc0f614: 80 03 00 1c lwz r0,28(r3) <== NOT EXECUTED
ffc0f618: 4b ff ff e4 b ffc0f5fc <rtems_blkdev_ioctl+0x60> <== NOT EXECUTED
break;
default:
errno = EINVAL;
ffc0f61c: 48 00 50 21 bl ffc1463c <__errno>
ffc0f620: 38 00 00 16 li r0,22
ffc0f624: 90 03 00 00 stw r0,0(r3)
rc = -1;
ffc0f628: 38 60 ff ff li r3,-1
break;
}
return rc;
}
ffc0f62c: 80 01 00 0c lwz r0,12(r1)
ffc0f630: 38 21 00 08 addi r1,r1,8
ffc0f634: 7c 08 03 a6 mtlr r0
ffc0f638: 4e 80 00 20 blr
ffc0897c <rtems_chain_get_with_wait>:
rtems_chain_control *chain,
rtems_event_set events,
rtems_interval timeout,
rtems_chain_node **node_ptr
)
{
ffc0897c: 94 21 ff d0 stwu r1,-48(r1)
ffc08980: 7c 08 02 a6 mflr r0
ffc08984: bf 61 00 1c stmw r27,28(r1)
ffc08988: 7c 7b 1b 78 mr r27,r3
ffc0898c: 7c 9c 23 78 mr r28,r4
ffc08990: 90 01 00 34 stw r0,52(r1)
ffc08994: 7c bd 2b 78 mr r29,r5
ffc08998: 7c df 33 78 mr r31,r6
ffc0899c: 48 00 00 20 b ffc089bc <rtems_chain_get_with_wait+0x40>
while (
sc == RTEMS_SUCCESSFUL
&& (node = rtems_chain_get( chain )) == NULL
) {
rtems_event_set out;
sc = rtems_event_receive(
ffc089a0: 7f 83 e3 78 mr r3,r28
ffc089a4: 38 80 00 00 li r4,0
ffc089a8: 7f a5 eb 78 mr r5,r29
ffc089ac: 38 c1 00 08 addi r6,r1,8
ffc089b0: 4b ff f2 bd bl ffc07c6c <rtems_event_receive>
)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_chain_node *node = NULL;
while (
ffc089b4: 2c 03 00 00 cmpwi r3,0
ffc089b8: 40 82 00 18 bne- ffc089d0 <rtems_chain_get_with_wait+0x54><== ALWAYS TAKEN
*/
RTEMS_INLINE_ROUTINE rtems_chain_node *rtems_chain_get(
rtems_chain_control *the_chain
)
{
return _Chain_Get( the_chain );
ffc089bc: 7f 63 db 78 mr r3,r27
ffc089c0: 48 00 06 85 bl ffc09044 <_Chain_Get>
sc == RTEMS_SUCCESSFUL
&& (node = rtems_chain_get( chain )) == NULL
ffc089c4: 7c 7e 1b 79 mr. r30,r3
ffc089c8: 41 82 ff d8 beq+ ffc089a0 <rtems_chain_get_with_wait+0x24>
ffc089cc: 38 60 00 00 li r3,0
}
*node_ptr = node;
return sc;
}
ffc089d0: 39 61 00 30 addi r11,r1,48
timeout,
&out
);
}
*node_ptr = node;
ffc089d4: 93 df 00 00 stw r30,0(r31)
return sc;
}
ffc089d8: 48 00 d3 e0 b ffc15db8 <_restgpr_27_x>
ffc04a20 <rtems_cpu_usage_report_with_plugin>:
*/
void rtems_cpu_usage_report_with_plugin(
void *context,
rtems_printk_plugin_t print
)
{
ffc04a20: 94 21 ff 78 stwu r1,-136(r1)
ffc04a24: 7c 08 02 a6 mflr r0
ffc04a28: 90 01 00 8c stw r0,140(r1)
Timestamp_Control uptime, total, ran, uptime_at_last_reset;
#else
uint32_t total_units = 0;
#endif
if ( !print )
ffc04a2c: 7c 80 23 79 mr. r0,r4
*/
void rtems_cpu_usage_report_with_plugin(
void *context,
rtems_printk_plugin_t print
)
{
ffc04a30: be e1 00 64 stmw r23,100(r1)
ffc04a34: 7c 7d 1b 78 mr r29,r3
Timestamp_Control uptime, total, ran, uptime_at_last_reset;
#else
uint32_t total_units = 0;
#endif
if ( !print )
ffc04a38: 90 01 00 58 stw r0,88(r1)
ffc04a3c: 41 82 01 bc beq- ffc04bf8 <rtems_cpu_usage_report_with_plugin+0x1d8><== 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;
ffc04a40: 3d 20 00 00 lis r9,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 );
ffc04a44: 38 00 00 00 li r0,0
uptime_at_last_reset = CPU_usage_Uptime_at_last_reset;
ffc04a48: 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 );
ffc04a4c: 90 01 00 30 stw r0,48(r1)
}
}
}
#endif
(*print)(
ffc04a50: 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 );
ffc04a54: 90 01 00 34 stw r0,52(r1)
}
}
}
#endif
(*print)(
ffc04a58: 38 84 f5 f3 addi r4,r4,-2573
ffc04a5c: 3f e0 00 00 lis r31,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;
ffc04a60: 81 49 00 00 lwz r10,0(r9)
}
}
}
#endif
(*print)(
ffc04a64: 3b ff 30 80 addi r31,r31,12416
* 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;
ffc04a68: 81 69 00 04 lwz r11,4(r9)
if ( !the_thread )
continue;
rtems_object_get_name( the_thread->Object.id, sizeof(name), name );
(*print)(
ffc04a6c: 3f 20 ff c2 lis r25,-62
}
}
}
#endif
(*print)(
ffc04a70: 80 01 00 58 lwz r0,88(r1)
/*
* Print the information
*/
(*print)( context,
ffc04a74: 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;
ffc04a78: 91 41 00 20 stw r10,32(r1)
#endif
/*
* rtems_cpu_usage_report
*/
void rtems_cpu_usage_report_with_plugin(
ffc04a7c: 3b 1f 00 0c addi r24,r31,12
}
}
}
#endif
(*print)(
ffc04a80: 7c 09 03 a6 mtctr r0
if ( !the_thread )
continue;
rtems_object_get_name( the_thread->Object.id, sizeof(name), name );
(*print)(
ffc04a84: 3b 39 f7 65 addi r25,r25,-2203
* 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;
ffc04a88: 91 61 00 24 stw r11,36(r1)
Thread_Control *the_thread,
Timestamp_Control *time_of_context_switch
)
{
#ifndef RTEMS_SMP
if ( _Thread_Executing->Object.id == the_thread->Object.id ) {
ffc04a8c: 3f 40 00 00 lis r26,0
/*
* Print the information
*/
(*print)( context,
ffc04a90: 3b 7b f7 78 addi r27,r27,-2184
}
}
}
#endif
(*print)(
ffc04a94: 4c c6 31 82 crclr 4*cr1+eq
ffc04a98: 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 ];
ffc04a9c: 85 3f 00 04 lwzu r9,4(r31)
if ( information ) {
ffc04aa0: 3b c0 00 01 li r30,1
#if !defined(RTEMS_POSIX_API) || defined(RTEMS_DEBUG)
if ( !_Objects_Information_table[ api_index ] )
continue;
#endif
information = _Objects_Information_table[ api_index ][ 1 ];
ffc04aa4: 83 89 00 04 lwz r28,4(r9)
if ( information ) {
ffc04aa8: 2f 9c 00 00 cmpwi cr7,r28,0
ffc04aac: 40 be 01 0c bne+ cr7,ffc04bb8 <rtems_cpu_usage_report_with_plugin+0x198><== ALWAYS TAKEN
ffc04ab0: 48 00 01 14 b ffc04bc4 <rtems_cpu_usage_report_with_plugin+0x1a4><== NOT EXECUTED
for ( i=1 ; i <= information->maximum ; i++ ) {
the_thread = (Thread_Control *)information->local_table[ i ];
ffc04ab4: 81 3c 00 1c lwz r9,28(r28)
ffc04ab8: 57 c0 10 3a rlwinm r0,r30,2,0,29
ffc04abc: 7e e9 00 2e lwzx r23,r9,r0
if ( !the_thread )
ffc04ac0: 2f 97 00 00 cmpwi cr7,r23,0
ffc04ac4: 41 9e 00 f0 beq- cr7,ffc04bb4 <rtems_cpu_usage_report_with_plugin+0x194><== NEVER TAKEN
continue;
rtems_object_get_name( the_thread->Object.id, sizeof(name), name );
ffc04ac8: 80 77 00 08 lwz r3,8(r23)
ffc04acc: 38 80 00 0d li r4,13
ffc04ad0: 38 a1 00 40 addi r5,r1,64
ffc04ad4: 48 00 46 fd bl ffc091d0 <rtems_object_get_name>
(*print)(
ffc04ad8: 80 01 00 58 lwz r0,88(r1)
ffc04adc: 7f a3 eb 78 mr r3,r29
ffc04ae0: 80 b7 00 08 lwz r5,8(r23)
ffc04ae4: 7c 09 03 a6 mtctr r0
ffc04ae8: 7f 24 cb 78 mr r4,r25
ffc04aec: 38 c1 00 40 addi r6,r1,64
ffc04af0: 4c c6 31 82 crclr 4*cr1+eq
ffc04af4: 4e 80 04 21 bctrl
/*
* If this is the currently executing thread, account for time
* since the last context switch.
*/
ran = the_thread->cpu_time_used;
ffc04af8: 81 77 00 88 lwz r11,136(r23)
Thread_Control *the_thread,
Timestamp_Control *time_of_context_switch
)
{
#ifndef RTEMS_SMP
if ( _Thread_Executing->Object.id == the_thread->Object.id ) {
ffc04afc: 39 3a 35 a4 addi r9,r26,13732
ffc04b00: 80 17 00 08 lwz r0,8(r23)
/*
* If this is the currently executing thread, account for time
* since the last context switch.
*/
ran = the_thread->cpu_time_used;
ffc04b04: 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 ) {
ffc04b08: 81 69 00 0c lwz r11,12(r9)
/*
* If this is the currently executing thread, account for time
* since the last context switch.
*/
ran = the_thread->cpu_time_used;
ffc04b0c: 81 57 00 84 lwz r10,132(r23)
Thread_Control *the_thread,
Timestamp_Control *time_of_context_switch
)
{
#ifndef RTEMS_SMP
if ( _Thread_Executing->Object.id == the_thread->Object.id ) {
ffc04b10: 81 6b 00 08 lwz r11,8(r11)
/*
* If this is the currently executing thread, account for time
* since the last context switch.
*/
ran = the_thread->cpu_time_used;
ffc04b14: 91 41 00 28 stw r10,40(r1)
Thread_Control *the_thread,
Timestamp_Control *time_of_context_switch
)
{
#ifndef RTEMS_SMP
if ( _Thread_Executing->Object.id == the_thread->Object.id ) {
ffc04b18: 7f 8b 00 00 cmpw cr7,r11,r0
ffc04b1c: 40 be 00 3c bne+ cr7,ffc04b58 <rtems_cpu_usage_report_with_plugin+0x138>
*time_of_context_switch = _Thread_Time_of_last_context_switch;
ffc04b20: 81 49 00 1c lwz r10,28(r9)
* 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 );
ffc04b24: 38 61 00 38 addi r3,r1,56
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;
ffc04b28: 81 69 00 20 lwz r11,32(r9)
ffc04b2c: 91 41 00 18 stw r10,24(r1)
ffc04b30: 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 );
ffc04b34: 48 00 5d 01 bl ffc0a834 <_TOD_Get_uptime>
_Timestamp_Subtract( &last, &uptime, &used );
ffc04b38: 38 61 00 18 addi r3,r1,24
ffc04b3c: 38 81 00 38 addi r4,r1,56
ffc04b40: 38 a1 00 10 addi r5,r1,16
ffc04b44: 48 00 85 49 bl ffc0d08c <_Timespec_Subtract>
_Timestamp_Add_to( &ran, &used );
ffc04b48: 38 61 00 28 addi r3,r1,40
ffc04b4c: 38 81 00 10 addi r4,r1,16
ffc04b50: 48 00 84 1d bl ffc0cf6c <_Timespec_Add_to>
ffc04b54: 48 00 00 0c b ffc04b60 <rtems_cpu_usage_report_with_plugin+0x140>
} else {
_TOD_Get_uptime( &uptime );
ffc04b58: 38 61 00 38 addi r3,r1,56
ffc04b5c: 48 00 5c d9 bl ffc0a834 <_TOD_Get_uptime>
}
_Timestamp_Subtract( &uptime_at_last_reset, &uptime, &total );
ffc04b60: 38 61 00 20 addi r3,r1,32
ffc04b64: 38 81 00 38 addi r4,r1,56
ffc04b68: 38 a1 00 30 addi r5,r1,48
ffc04b6c: 48 00 85 21 bl ffc0d08c <_Timespec_Subtract>
_Timestamp_Divide( &ran, &total, &ival, &fval );
ffc04b70: 38 61 00 28 addi r3,r1,40
ffc04b74: 38 81 00 30 addi r4,r1,48
ffc04b78: 38 a1 00 0c addi r5,r1,12
ffc04b7c: 38 c1 00 08 addi r6,r1,8
ffc04b80: 48 00 84 49 bl ffc0cfc8 <_Timespec_Divide>
/*
* Print the information
*/
(*print)( context,
ffc04b84: 80 c1 00 2c lwz r6,44(r1)
ffc04b88: 38 00 03 e8 li r0,1000
ffc04b8c: 80 a1 00 28 lwz r5,40(r1)
ffc04b90: 7c c6 03 96 divwu r6,r6,r0
ffc04b94: 80 01 00 58 lwz r0,88(r1)
ffc04b98: 80 e1 00 0c lwz r7,12(r1)
ffc04b9c: 81 01 00 08 lwz r8,8(r1)
ffc04ba0: 7c 09 03 a6 mtctr r0
ffc04ba4: 7f a3 eb 78 mr r3,r29
ffc04ba8: 7f 64 db 78 mr r4,r27
ffc04bac: 4c c6 31 82 crclr 4*cr1+eq
ffc04bb0: 4e 80 04 21 bctrl
continue;
#endif
information = _Objects_Information_table[ api_index ][ 1 ];
if ( information ) {
for ( i=1 ; i <= information->maximum ; i++ ) {
ffc04bb4: 3b de 00 01 addi r30,r30,1
ffc04bb8: a0 1c 00 10 lhz r0,16(r28)
ffc04bbc: 7f 9e 00 40 cmplw cr7,r30,r0
ffc04bc0: 40 9d fe f4 ble+ cr7,ffc04ab4 <rtems_cpu_usage_report_with_plugin+0x94>
" ID | NAME | TICKS | PERCENT\n"
#endif
"------------+----------------------------------------+---------------+---------\n"
);
for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; api_index++ ) {
ffc04bc4: 7f 9f c0 00 cmpw cr7,r31,r24
ffc04bc8: 40 9e fe d4 bne+ cr7,ffc04a9c <rtems_cpu_usage_report_with_plugin+0x7c>
}
}
}
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
(*print)(
ffc04bcc: 80 c1 00 34 lwz r6,52(r1)
ffc04bd0: 38 00 03 e8 li r0,1000
ffc04bd4: 3c 80 ff c2 lis r4,-62
ffc04bd8: 80 a1 00 30 lwz r5,48(r1)
ffc04bdc: 7c c6 03 96 divwu r6,r6,r0
ffc04be0: 80 01 00 58 lwz r0,88(r1)
ffc04be4: 7c 09 03 a6 mtctr r0
ffc04be8: 7f a3 eb 78 mr r3,r29
ffc04bec: 38 84 f7 90 addi r4,r4,-2160
ffc04bf0: 4c c6 31 82 crclr 4*cr1+eq
ffc04bf4: 4e 80 04 21 bctrl
"-------------------------------------------------------------------------------\n",
_Watchdog_Ticks_since_boot - CPU_usage_Ticks_at_last_reset,
total_units
);
#endif
}
ffc04bf8: 39 61 00 88 addi r11,r1,136
ffc04bfc: 4b ff c7 30 b ffc0132c <_restgpr_23_x>
ffc10adc <rtems_deviceio_errno>:
[RTEMS_PROXY_BLOCKING] = EIO
};
int rtems_deviceio_errno(rtems_status_code sc)
{
if (sc == RTEMS_SUCCESSFUL) {
ffc10adc: 2c 03 00 00 cmpwi r3,0
[RTEMS_IO_ERROR] = EIO,
[RTEMS_PROXY_BLOCKING] = EIO
};
int rtems_deviceio_errno(rtems_status_code sc)
{
ffc10ae0: 7c 08 02 a6 mflr r0
ffc10ae4: 7c 2b 0b 78 mr r11,r1
ffc10ae8: 94 21 ff f0 stwu r1,-16(r1)
ffc10aec: 90 01 00 14 stw r0,20(r1)
ffc10af0: 48 00 a8 5d bl ffc1b34c <_savegpr_31>
if (sc == RTEMS_SUCCESSFUL) {
return 0;
ffc10af4: 38 00 00 00 li r0,0
[RTEMS_PROXY_BLOCKING] = EIO
};
int rtems_deviceio_errno(rtems_status_code sc)
{
if (sc == RTEMS_SUCCESSFUL) {
ffc10af8: 41 a2 00 2c beq+ ffc10b24 <rtems_deviceio_errno+0x48>
return 0;
} else {
int eno = EINVAL;
if ((unsigned) sc <= RTEMS_STATUS_CODES_LAST) {
ffc10afc: 2b 83 00 1c cmplwi cr7,r3,28
int rtems_deviceio_errno(rtems_status_code sc)
{
if (sc == RTEMS_SUCCESSFUL) {
return 0;
} else {
int eno = EINVAL;
ffc10b00: 3b e0 00 16 li r31,22
if ((unsigned) sc <= RTEMS_STATUS_CODES_LAST) {
ffc10b04: 41 9d 00 14 bgt- cr7,ffc10b18 <rtems_deviceio_errno+0x3c><== NEVER TAKEN
eno = status_code_to_errno [sc];
ffc10b08: 3d 20 ff c2 lis r9,-62
ffc10b0c: 54 63 10 3a rlwinm r3,r3,2,0,29
ffc10b10: 39 29 dc 98 addi r9,r9,-9064
ffc10b14: 7f e9 18 2e lwzx r31,r9,r3
}
errno = eno;
ffc10b18: 48 00 00 9d bl ffc10bb4 <__errno>
return -1;
ffc10b1c: 38 00 ff ff li r0,-1
if ((unsigned) sc <= RTEMS_STATUS_CODES_LAST) {
eno = status_code_to_errno [sc];
}
errno = eno;
ffc10b20: 93 e3 00 00 stw r31,0(r3)
return -1;
}
}
ffc10b24: 39 61 00 10 addi r11,r1,16
ffc10b28: 7c 03 03 78 mr r3,r0
ffc10b2c: 4b fe fa 18 b ffc00544 <_restgpr_31_x>
ffc04274 <rtems_disk_create_log>:
dev_t phys,
rtems_blkdev_bnum begin_block,
rtems_blkdev_bnum block_count,
const char *name
)
{
ffc04274: 94 21 ff c8 stwu r1,-56(r1)
ffc04278: 7c 08 02 a6 mflr r0
ffc0427c: 90 01 00 3c stw r0,60(r1)
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_disk_device *physical_disk = NULL;
rtems_disk_device *dd = NULL;
ffc04280: 38 00 00 00 li r0,0
dev_t phys,
rtems_blkdev_bnum begin_block,
rtems_blkdev_bnum block_count,
const char *name
)
{
ffc04284: bf 01 00 18 stmw r24,24(r1)
ffc04288: 7c 9f 23 78 mr r31,r4
ffc0428c: 7c 7e 1b 78 mr r30,r3
ffc04290: 7c db 33 78 mr r27,r6
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_disk_device *physical_disk = NULL;
rtems_disk_device *dd = NULL;
ffc04294: 90 01 00 08 stw r0,8(r1)
dev_t phys,
rtems_blkdev_bnum begin_block,
rtems_blkdev_bnum block_count,
const char *name
)
{
ffc04298: 7c ba 2b 78 mr r26,r5
ffc0429c: 7c fd 3b 78 mr r29,r7
ffc042a0: 7d 1c 43 78 mr r28,r8
ffc042a4: 7d 39 4b 78 mr r25,r9
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;
sc = disk_lock();
ffc042a8: 4b ff fc a5 bl ffc03f4c <disk_lock>
if (sc != RTEMS_SUCCESSFUL) {
ffc042ac: 7c 78 1b 79 mr. r24,r3
ffc042b0: 40 a2 00 b8 bne+ ffc04368 <rtems_disk_create_log+0xf4> <== NEVER TAKEN
return sc;
}
physical_disk = get_disk_entry(phys, true);
ffc042b4: 7f 43 d3 78 mr r3,r26
ffc042b8: 7f 64 db 78 mr r4,r27
ffc042bc: 38 a0 00 01 li r5,1
ffc042c0: 4b ff fb a5 bl ffc03e64 <get_disk_entry>
if (physical_disk == NULL || !is_physical_disk(physical_disk)) {
ffc042c4: 2c 03 00 00 cmpwi r3,0
ffc042c8: 41 82 00 10 beq- ffc042d8 <rtems_disk_create_log+0x64>
}
static bool
is_physical_disk(const rtems_disk_device *dd)
{
return dd->phys_dev == dd;
ffc042cc: 83 43 00 08 lwz r26,8(r3)
if (sc != RTEMS_SUCCESSFUL) {
return sc;
}
physical_disk = get_disk_entry(phys, true);
if (physical_disk == NULL || !is_physical_disk(physical_disk)) {
ffc042d0: 7f 9a 18 00 cmpw cr7,r26,r3
ffc042d4: 41 9e 00 10 beq- cr7,ffc042e4 <rtems_disk_create_log+0x70>
disk_unlock();
ffc042d8: 4b ff fc c5 bl ffc03f9c <disk_unlock>
return RTEMS_INVALID_ID;
ffc042dc: 3b 00 00 04 li r24,4
ffc042e0: 48 00 00 88 b ffc04368 <rtems_disk_create_log+0xf4>
}
if (
begin_block >= physical_disk->size
ffc042e4: 80 1a 00 1c lwz r0,28(r26)
disk_unlock();
return RTEMS_INVALID_ID;
}
if (
ffc042e8: 7f 9d 00 40 cmplw cr7,r29,r0
ffc042ec: 40 9c 00 18 bge- cr7,ffc04304 <rtems_disk_create_log+0x90>
)
{
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;
ffc042f0: 7d 3c ea 14 add r9,r28,r29
return RTEMS_INVALID_ID;
}
if (
begin_block >= physical_disk->size
|| end_block <= begin_block
ffc042f4: 7f 89 e8 40 cmplw cr7,r9,r29
ffc042f8: 40 bd 00 0c ble+ cr7,ffc04304 <rtems_disk_create_log+0x90><== NEVER TAKEN
|| end_block > physical_disk->size
ffc042fc: 7f 89 00 40 cmplw cr7,r9,r0
ffc04300: 40 9d 00 10 ble- cr7,ffc04310 <rtems_disk_create_log+0x9c>
) {
disk_unlock();
ffc04304: 4b ff fc 99 bl ffc03f9c <disk_unlock>
return RTEMS_INVALID_NUMBER;
ffc04308: 3b 00 00 0a li r24,10
ffc0430c: 48 00 00 5c b ffc04368 <rtems_disk_create_log+0xf4>
}
sc = create_disk(dev, name, &dd);
ffc04310: 7f c3 f3 78 mr r3,r30
ffc04314: 7f e4 fb 78 mr r4,r31
ffc04318: 7f 25 cb 78 mr r5,r25
ffc0431c: 38 c1 00 08 addi r6,r1,8
ffc04320: 4b ff fc c5 bl ffc03fe4 <create_disk>
if (sc != RTEMS_SUCCESSFUL) {
ffc04324: 7c 78 1b 79 mr. r24,r3
ffc04328: 40 82 00 3c bne- ffc04364 <rtems_disk_create_log+0xf0>
disk_unlock();
return sc;
}
dd->phys_dev = physical_disk;
ffc0432c: 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;
ffc04330: 80 1a 00 20 lwz r0,32(r26)
disk_unlock();
return sc;
}
dd->phys_dev = physical_disk;
ffc04334: 93 49 00 08 stw r26,8(r9)
dd->start = begin_block;
dd->size = block_count;
dd->block_size = dd->media_block_size = physical_disk->block_size;
ffc04338: 90 09 00 24 stw r0,36(r9)
ffc0433c: 90 09 00 20 stw r0,32(r9)
dd->ioctl = physical_disk->ioctl;
ffc04340: 80 1a 00 28 lwz r0,40(r26)
return sc;
}
dd->phys_dev = physical_disk;
dd->start = begin_block;
ffc04344: 93 a9 00 18 stw r29,24(r9)
dd->size = block_count;
dd->block_size = dd->media_block_size = physical_disk->block_size;
dd->ioctl = physical_disk->ioctl;
ffc04348: 90 09 00 28 stw r0,40(r9)
dd->driver_data = physical_disk->driver_data;
ffc0434c: 80 1a 00 2c lwz r0,44(r26)
return sc;
}
dd->phys_dev = physical_disk;
dd->start = begin_block;
dd->size = block_count;
ffc04350: 93 89 00 1c stw r28,28(r9)
dd->block_size = dd->media_block_size = physical_disk->block_size;
dd->ioctl = physical_disk->ioctl;
dd->driver_data = physical_disk->driver_data;
ffc04354: 90 09 00 2c stw r0,44(r9)
++physical_disk->uses;
ffc04358: 81 3a 00 14 lwz r9,20(r26)
ffc0435c: 38 09 00 01 addi r0,r9,1
ffc04360: 90 1a 00 14 stw r0,20(r26)
disk_unlock();
ffc04364: 4b ff fc 39 bl ffc03f9c <disk_unlock>
return RTEMS_SUCCESSFUL;
}
ffc04368: 39 61 00 38 addi r11,r1,56
ffc0436c: 7f 03 c3 78 mr r3,r24
ffc04370: 48 01 51 8c b ffc194fc <_restgpr_24_x>
ffc041b0 <rtems_disk_create_phys>:
rtems_blkdev_bnum block_count,
rtems_block_device_ioctl handler,
void *driver_data,
const char *name
)
{
ffc041b0: 94 21 ff c8 stwu r1,-56(r1)
ffc041b4: 7c 08 02 a6 mflr r0
ffc041b8: bf 01 00 18 stmw r24,24(r1)
rtems_disk_device *dd = NULL;
rtems_status_code sc = RTEMS_SUCCESSFUL;
if (handler == NULL) {
ffc041bc: 7c f9 3b 79 mr. r25,r7
rtems_blkdev_bnum block_count,
rtems_block_device_ioctl handler,
void *driver_data,
const char *name
)
{
ffc041c0: 7c 9d 23 78 mr r29,r4
ffc041c4: 90 01 00 3c stw r0,60(r1)
rtems_disk_device *dd = NULL;
ffc041c8: 38 00 00 00 li r0,0
rtems_blkdev_bnum block_count,
rtems_block_device_ioctl handler,
void *driver_data,
const char *name
)
{
ffc041cc: 7c 7c 1b 78 mr r28,r3
ffc041d0: 7c bf 2b 78 mr r31,r5
rtems_disk_device *dd = NULL;
ffc041d4: 90 01 00 08 stw r0,8(r1)
rtems_blkdev_bnum block_count,
rtems_block_device_ioctl handler,
void *driver_data,
const char *name
)
{
ffc041d8: 7c de 33 78 mr r30,r6
ffc041dc: 7d 1b 43 78 mr r27,r8
ffc041e0: 7d 38 4b 78 mr r24,r9
rtems_disk_device *dd = NULL;
rtems_status_code sc = RTEMS_SUCCESSFUL;
if (handler == NULL) {
return RTEMS_INVALID_ADDRESS;
ffc041e4: 3b 40 00 09 li r26,9
)
{
rtems_disk_device *dd = NULL;
rtems_status_code sc = RTEMS_SUCCESSFUL;
if (handler == NULL) {
ffc041e8: 41 82 00 80 beq- ffc04268 <rtems_disk_create_phys+0xb8>
return RTEMS_INVALID_ADDRESS;
}
if (block_size == 0) {
ffc041ec: 2f 85 00 00 cmpwi cr7,r5,0
return RTEMS_INVALID_NUMBER;
ffc041f0: 3b 40 00 0a li r26,10
if (handler == NULL) {
return RTEMS_INVALID_ADDRESS;
}
if (block_size == 0) {
ffc041f4: 41 be 00 74 beq+ cr7,ffc04268 <rtems_disk_create_phys+0xb8>
return RTEMS_INVALID_NUMBER;
}
sc = disk_lock();
ffc041f8: 4b ff fd 55 bl ffc03f4c <disk_lock>
if (sc != RTEMS_SUCCESSFUL) {
ffc041fc: 7c 7a 1b 79 mr. r26,r3
ffc04200: 40 a2 00 68 bne+ ffc04268 <rtems_disk_create_phys+0xb8> <== NEVER TAKEN
return sc;
}
sc = create_disk(dev, name, &dd);
ffc04204: 7f 83 e3 78 mr r3,r28
ffc04208: 7f a4 eb 78 mr r4,r29
ffc0420c: 7f 05 c3 78 mr r5,r24
ffc04210: 38 c1 00 08 addi r6,r1,8
ffc04214: 4b ff fd d1 bl ffc03fe4 <create_disk>
if (sc != RTEMS_SUCCESSFUL) {
ffc04218: 7c 7a 1b 79 mr. r26,r3
ffc0421c: 40 82 00 48 bne- ffc04264 <rtems_disk_create_phys+0xb4>
disk_unlock();
return sc;
}
dd->phys_dev = dd;
ffc04220: 80 61 00 08 lwz r3,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) {
ffc04224: 3c 80 20 00 lis r4,8192
ffc04228: 60 84 42 08 ori r4,r4,16904
ffc0422c: 7f 29 03 a6 mtctr r25
disk_unlock();
return sc;
}
dd->phys_dev = dd;
ffc04230: 90 63 00 08 stw r3,8(r3)
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) {
ffc04234: 38 a3 00 0c addi r5,r3,12
return sc;
}
dd->phys_dev = dd;
dd->start = 0;
ffc04238: 93 43 00 18 stw r26,24(r3)
dd->size = block_count;
ffc0423c: 93 c3 00 1c stw r30,28(r3)
dd->block_size = dd->media_block_size = block_size;
ffc04240: 93 e3 00 24 stw r31,36(r3)
ffc04244: 93 e3 00 20 stw r31,32(r3)
dd->ioctl = handler;
ffc04248: 93 23 00 28 stw r25,40(r3)
dd->driver_data = driver_data;
ffc0424c: 93 63 00 2c stw r27,44(r3)
if ((*handler)(dd, RTEMS_BLKIO_CAPABILITIES, &dd->capabilities) < 0) {
ffc04250: 4e 80 04 21 bctrl
ffc04254: 2f 83 00 00 cmpwi cr7,r3,0
ffc04258: 40 bc 00 0c bge+ cr7,ffc04264 <rtems_disk_create_phys+0xb4><== NEVER TAKEN
dd->capabilities = 0;
ffc0425c: 81 21 00 08 lwz r9,8(r1)
ffc04260: 93 49 00 0c stw r26,12(r9)
}
disk_unlock();
ffc04264: 4b ff fd 39 bl ffc03f9c <disk_unlock>
return RTEMS_SUCCESSFUL;
}
ffc04268: 39 61 00 38 addi r11,r1,56
ffc0426c: 7f 43 d3 78 mr r3,r26
ffc04270: 48 01 52 8c b ffc194fc <_restgpr_24_x>
ffc04374 <rtems_disk_delete>:
}
}
rtems_status_code
rtems_disk_delete(dev_t dev)
{
ffc04374: 94 21 ff d0 stwu r1,-48(r1)
ffc04378: 7c 08 02 a6 mflr r0
ffc0437c: be c1 00 08 stmw r22,8(r1)
ffc04380: 7c 9d 23 78 mr r29,r4
ffc04384: 7c 7c 1b 78 mr r28,r3
ffc04388: 90 01 00 34 stw r0,52(r1)
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_disk_device *dd = NULL;
sc = disk_lock();
ffc0438c: 4b ff fb c1 bl ffc03f4c <disk_lock>
if (sc != RTEMS_SUCCESSFUL) {
ffc04390: 7c 7f 1b 79 mr. r31,r3
ffc04394: 40 a2 01 64 bne+ ffc044f8 <rtems_disk_delete+0x184> <== NEVER TAKEN
return sc;
}
dd = get_disk_entry(dev, true);
ffc04398: 7f 83 e3 78 mr r3,r28
ffc0439c: 7f a4 eb 78 mr r4,r29
ffc043a0: 38 a0 00 01 li r5,1
ffc043a4: 4b ff fa c1 bl ffc03e64 <get_disk_entry>
if (dd == NULL) {
ffc043a8: 7c 69 1b 79 mr. r9,r3
ffc043ac: 40 a2 00 10 bne+ ffc043bc <rtems_disk_delete+0x48> <== ALWAYS TAKEN
disk_unlock();
ffc043b0: 4b ff fb ed bl ffc03f9c <disk_unlock> <== NOT EXECUTED
return RTEMS_INVALID_ID;
ffc043b4: 3b e0 00 04 li r31,4 <== NOT EXECUTED
ffc043b8: 48 00 01 40 b ffc044f8 <rtems_disk_delete+0x184> <== NOT EXECUTED
}
dd->deleted = true;
ffc043bc: 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;
ffc043c0: 83 89 00 08 lwz r28,8(r9)
disk_unlock();
return RTEMS_INVALID_ID;
}
dd->deleted = true;
ffc043c4: 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) {
ffc043c8: 88 1c 00 30 lbz r0,48(r28)
ffc043cc: 2f 80 00 00 cmpwi cr7,r0,0
ffc043d0: 41 9e 00 e8 beq- cr7,ffc044b8 <rtems_disk_delete+0x144>
dev_t dev = physical_disk->dev;
ffc043d4: 82 dc 00 00 lwz r22,0(r28)
unsigned deleted_count = 0;
ffc043d8: 3b 60 00 00 li r27,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;
ffc043dc: 82 fc 00 04 lwz r23,4(r28)
unsigned deleted_count = 0;
for (major = 0; major < disktab_size; ++major) {
ffc043e0: 3b c0 00 00 li r30,0
ffc043e4: 3f 40 00 00 lis r26,0
if (dd->uses == 0) {
++deleted_count;
dtab->minor [minor] = NULL;
free_disk_device(dd);
} else {
dd->deleted = true;
ffc043e8: 3b 00 00 01 li r24,1
ffc043ec: 48 00 00 84 b ffc04470 <rtems_disk_delete+0xfc>
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;
ffc043f0: 83 29 00 04 lwz r25,4(r9)
ffc043f4: 57 c0 18 38 rlwinm r0,r30,3,0,28
for (minor = 0; minor < dtab->size; ++minor) {
ffc043f8: 3b a0 00 00 li r29,0
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;
ffc043fc: 7f 39 02 14 add r25,r25,r0
ffc04400: 48 00 00 60 b ffc04460 <rtems_disk_delete+0xec>
for (minor = 0; minor < dtab->size; ++minor) {
rtems_disk_device *dd = dtab->minor [minor];
ffc04404: 81 39 00 00 lwz r9,0(r25)
ffc04408: 57 a0 10 3a rlwinm r0,r29,2,0,29
ffc0440c: 7c 69 00 2e lwzx r3,r9,r0
if (dd != NULL && dd->phys_dev->dev == dev && dd != physical_disk) {
ffc04410: 2f 83 00 00 cmpwi cr7,r3,0
ffc04414: 41 9e 00 48 beq- cr7,ffc0445c <rtems_disk_delete+0xe8>
ffc04418: 81 63 00 08 lwz r11,8(r3)
ffc0441c: 81 4b 00 00 lwz r10,0(r11)
ffc04420: 7f 8a b0 00 cmpw cr7,r10,r22
ffc04424: 40 be 00 38 bne+ cr7,ffc0445c <rtems_disk_delete+0xe8> <== NEVER TAKEN
ffc04428: 81 6b 00 04 lwz r11,4(r11)
ffc0442c: 7f 8b b8 00 cmpw cr7,r11,r23
ffc04430: 40 be 00 2c bne+ cr7,ffc0445c <rtems_disk_delete+0xe8> <== NEVER TAKEN
ffc04434: 7f 83 e0 00 cmpw cr7,r3,r28
ffc04438: 41 9e 00 24 beq- cr7,ffc0445c <rtems_disk_delete+0xe8>
if (dd->uses == 0) {
ffc0443c: 81 63 00 14 lwz r11,20(r3)
ffc04440: 2f 8b 00 00 cmpwi cr7,r11,0
ffc04444: 40 be 00 14 bne+ cr7,ffc04458 <rtems_disk_delete+0xe4>
++deleted_count;
dtab->minor [minor] = NULL;
ffc04448: 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;
ffc0444c: 3b 7b 00 01 addi r27,r27,1
dtab->minor [minor] = NULL;
free_disk_device(dd);
ffc04450: 4b ff fa 99 bl ffc03ee8 <free_disk_device>
ffc04454: 48 00 00 08 b ffc0445c <rtems_disk_delete+0xe8>
} else {
dd->deleted = true;
ffc04458: 9b 03 00 30 stb r24,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) {
ffc0445c: 3b bd 00 01 addi r29,r29,1
ffc04460: 80 19 00 04 lwz r0,4(r25)
ffc04464: 7f 9d 00 40 cmplw cr7,r29,r0
ffc04468: 41 9c ff 9c blt+ cr7,ffc04404 <rtems_disk_delete+0x90>
if (physical_disk->deleted) {
dev_t dev = physical_disk->dev;
unsigned deleted_count = 0;
for (major = 0; major < disktab_size; ++major) {
ffc0446c: 3b de 00 01 addi r30,r30,1
ffc04470: 80 1a 28 e8 lwz r0,10472(r26)
ffc04474: 39 3a 28 e8 addi r9,r26,10472
ffc04478: 7f 9e 00 40 cmplw cr7,r30,r0
ffc0447c: 41 9c ff 74 blt+ cr7,ffc043f0 <rtems_disk_delete+0x7c>
}
}
}
}
physical_disk->uses -= deleted_count;
ffc04480: 80 1c 00 14 lwz r0,20(r28)
ffc04484: 7f 7b 00 50 subf r27,r27,r0
if (physical_disk->uses == 0) {
ffc04488: 2f 9b 00 00 cmpwi cr7,r27,0
}
}
}
}
physical_disk->uses -= deleted_count;
ffc0448c: 93 7c 00 14 stw r27,20(r28)
if (physical_disk->uses == 0) {
ffc04490: 40 be 00 64 bne+ cr7,ffc044f4 <rtems_disk_delete+0x180>
rtems_filesystem_split_dev_t(physical_disk->dev, major, minor);
ffc04494: 81 5c 00 00 lwz r10,0(r28)
disktab [major].minor [minor] = NULL;
free_disk_device(physical_disk);
ffc04498: 7f 83 e3 78 mr r3,r28
}
physical_disk->uses -= deleted_count;
if (physical_disk->uses == 0) {
rtems_filesystem_split_dev_t(physical_disk->dev, major, minor);
disktab [major].minor [minor] = NULL;
ffc0449c: 81 69 00 04 lwz r11,4(r9)
}
}
physical_disk->uses -= deleted_count;
if (physical_disk->uses == 0) {
rtems_filesystem_split_dev_t(physical_disk->dev, major, minor);
ffc044a0: 80 1c 00 04 lwz r0,4(r28)
disktab [major].minor [minor] = NULL;
ffc044a4: 55 49 18 38 rlwinm r9,r10,3,0,28
ffc044a8: 7d 2b 48 2e lwzx r9,r11,r9
ffc044ac: 54 00 10 3a rlwinm r0,r0,2,0,29
ffc044b0: 7f 69 01 2e stwx r27,r9,r0
ffc044b4: 48 00 00 3c b ffc044f0 <rtems_disk_delete+0x17c>
free_disk_device(physical_disk);
}
} else {
if (disk_to_remove->uses == 0) {
ffc044b8: 80 09 00 14 lwz r0,20(r9)
ffc044bc: 2f 80 00 00 cmpwi cr7,r0,0
ffc044c0: 40 be 00 34 bne+ cr7,ffc044f4 <rtems_disk_delete+0x180> <== NEVER TAKEN
--physical_disk->uses;
ffc044c4: 81 7c 00 14 lwz r11,20(r28)
rtems_filesystem_split_dev_t(disk_to_remove->dev, major, minor);
ffc044c8: 81 49 00 00 lwz r10,0(r9)
disktab [major].minor [minor] = NULL;
free_disk_device(physical_disk);
}
} else {
if (disk_to_remove->uses == 0) {
--physical_disk->uses;
ffc044cc: 38 0b ff ff addi r0,r11,-1
ffc044d0: 90 1c 00 14 stw r0,20(r28)
rtems_filesystem_split_dev_t(disk_to_remove->dev, major, minor);
ffc044d4: 80 09 00 04 lwz r0,4(r9)
disktab [major].minor [minor] = NULL;
ffc044d8: 3d 20 00 00 lis r9,0
ffc044dc: 81 69 28 ec lwz r11,10476(r9)
ffc044e0: 55 49 18 38 rlwinm r9,r10,3,0,28
ffc044e4: 54 00 10 3a rlwinm r0,r0,2,0,29
ffc044e8: 7d 2b 48 2e lwzx r9,r11,r9
ffc044ec: 7f e9 01 2e stwx r31,r9,r0
free_disk_device(disk_to_remove);
ffc044f0: 4b ff f9 f9 bl ffc03ee8 <free_disk_device>
}
dd->deleted = true;
rtems_disk_cleanup(dd);
disk_unlock();
ffc044f4: 4b ff fa a9 bl ffc03f9c <disk_unlock>
return RTEMS_SUCCESSFUL;
}
ffc044f8: 39 61 00 30 addi r11,r1,48
ffc044fc: 7f e3 fb 78 mr r3,r31
ffc04500: 48 01 4f f4 b ffc194f4 <_restgpr_22_x>
ffc046f4 <rtems_disk_io_initialize>:
rtems_status_code
rtems_disk_io_initialize(void)
{
ffc046f4: 94 21 ff e8 stwu r1,-24(r1)
ffc046f8: 7c 08 02 a6 mflr r0
ffc046fc: bf 81 00 08 stmw r28,8(r1)
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_device_major_number size = DISKTAB_INITIAL_SIZE;
if (disktab_size > 0) {
ffc04700: 3f a0 00 00 lis r29,0
ffc04704: 3b fd 28 e8 addi r31,r29,10472
ffc04708: 83 9d 28 e8 lwz r28,10472(r29)
return RTEMS_SUCCESSFUL;
ffc0470c: 3b c0 00 00 li r30,0
}
}
rtems_status_code
rtems_disk_io_initialize(void)
{
ffc04710: 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) {
ffc04714: 2f 9c 00 00 cmpwi cr7,r28,0
ffc04718: 40 be 00 84 bne+ cr7,ffc0479c <rtems_disk_io_initialize+0xa8><== NEVER TAKEN
return RTEMS_SUCCESSFUL;
}
disktab = calloc(size, sizeof(rtems_disk_device_table));
ffc0471c: 38 60 00 08 li r3,8
ffc04720: 38 80 00 08 li r4,8
ffc04724: 48 00 09 4d bl ffc05070 <calloc>
if (disktab == NULL) {
return RTEMS_NO_MEMORY;
ffc04728: 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) {
ffc0472c: 2f 83 00 00 cmpwi cr7,r3,0
if (disktab_size > 0) {
return RTEMS_SUCCESSFUL;
}
disktab = calloc(size, sizeof(rtems_disk_device_table));
ffc04730: 90 7f 00 04 stw r3,4(r31)
if (disktab == NULL) {
ffc04734: 41 9e 00 68 beq- cr7,ffc0479c <rtems_disk_io_initialize+0xa8><== NEVER TAKEN
return RTEMS_NO_MEMORY;
}
diskdevs_protected = false;
ffc04738: 9b 9f 00 0c stb r28,12(r31)
sc = rtems_semaphore_create(
ffc0473c: 3c 60 44 44 lis r3,17476
ffc04740: 60 63 45 56 ori r3,r3,17750
ffc04744: 38 80 00 01 li r4,1
ffc04748: 38 a0 00 10 li r5,16
ffc0474c: 38 c0 00 00 li r6,0
ffc04750: 38 ff 00 08 addi r7,r31,8
ffc04754: 48 00 41 51 bl ffc088a4 <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) {
ffc04758: 2f 83 00 00 cmpwi cr7,r3,0
ffc0475c: 41 9e 00 10 beq- cr7,ffc0476c <rtems_disk_io_initialize+0x78><== ALWAYS TAKEN
free(disktab);
ffc04760: 80 7f 00 04 lwz r3,4(r31) <== NOT EXECUTED
ffc04764: 48 00 0b 0d bl ffc05270 <free> <== NOT EXECUTED
return RTEMS_NO_MEMORY;
ffc04768: 48 00 00 34 b ffc0479c <rtems_disk_io_initialize+0xa8><== NOT EXECUTED
}
sc = rtems_bdbuf_init();
ffc0476c: 48 00 a0 11 bl ffc0e77c <rtems_bdbuf_init>
if (sc != RTEMS_SUCCESSFUL) {
ffc04770: 2f 83 00 00 cmpwi cr7,r3,0
ffc04774: 41 9e 00 1c beq- cr7,ffc04790 <rtems_disk_io_initialize+0x9c><== ALWAYS TAKEN
rtems_semaphore_delete(diskdevs_mutex);
ffc04778: 80 7f 00 08 lwz r3,8(r31) <== NOT EXECUTED
free(disktab);
return RTEMS_UNSATISFIED;
ffc0477c: 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);
ffc04780: 48 00 42 e1 bl ffc08a60 <rtems_semaphore_delete> <== NOT EXECUTED
free(disktab);
ffc04784: 80 7f 00 04 lwz r3,4(r31) <== NOT EXECUTED
ffc04788: 48 00 0a e9 bl ffc05270 <free> <== NOT EXECUTED
return RTEMS_UNSATISFIED;
ffc0478c: 48 00 00 10 b ffc0479c <rtems_disk_io_initialize+0xa8><== NOT EXECUTED
}
disktab_size = size;
ffc04790: 38 00 00 08 li r0,8
ffc04794: 90 1d 28 e8 stw r0,10472(r29)
return RTEMS_SUCCESSFUL;
ffc04798: 3b c0 00 00 li r30,0
}
ffc0479c: 39 61 00 18 addi r11,r1,24
ffc047a0: 7f c3 f3 78 mr r3,r30
ffc047a4: 48 01 4d 68 b ffc1950c <_restgpr_28_x>
ffc045f0 <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) {
ffc045f0: 2f 83 ff ff cmpwi cr7,r3,-1
return RTEMS_SUCCESSFUL;
}
rtems_disk_device *
rtems_disk_next(dev_t dev)
{
ffc045f4: 94 21 ff e8 stwu r1,-24(r1)
ffc045f8: 7c 08 02 a6 mflr r0
ffc045fc: bf 81 00 08 stmw r28,8(r1)
ffc04600: 90 01 00 1c stw r0,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) {
ffc04604: 40 be 00 0c bne+ cr7,ffc04610 <rtems_disk_next+0x20>
ffc04608: 2f 84 ff ff cmpwi cr7,r4,-1
ffc0460c: 41 9e 00 2c beq- cr7,ffc04638 <rtems_disk_next+0x48> <== ALWAYS TAKEN
rtems_filesystem_split_dev_t(dev, major, minor);
/* If minor wraps around */
if ((minor + 1) < minor) {
ffc04610: 3b c4 00 01 addi r30,r4,1
ffc04614: 7f 9e 20 40 cmplw cr7,r30,r4
)
{
union __rtems_dev_t temp;
temp.device = device;
return temp.__overlay.major;
ffc04618: 7c 7f 1b 78 mr r31,r3
ffc0461c: 40 9c 00 24 bge- cr7,ffc04640 <rtems_disk_next+0x50> <== ALWAYS TAKEN
/* If major wraps around */
if ((major + 1) < major) {
ffc04620: 3b e3 00 01 addi r31,r3,1 <== NOT EXECUTED
ffc04624: 7f 9f 18 40 cmplw cr7,r31,r3 <== NOT EXECUTED
return NULL;
ffc04628: 3b a0 00 00 li r29,0 <== NOT EXECUTED
}
++major;
minor = 0;
ffc0462c: 3b c0 00 00 li r30,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) {
ffc04630: 40 bc 00 10 bge+ cr7,ffc04640 <rtems_disk_next+0x50> <== NOT EXECUTED
ffc04634: 48 00 00 b4 b ffc046e8 <rtems_disk_next+0xf8> <== NOT EXECUTED
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;
ffc04638: 3b c0 00 00 li r30,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;
ffc0463c: 3b e0 00 00 li r31,0
} else {
++minor;
}
}
sc = disk_lock();
ffc04640: 4b ff f9 0d bl ffc03f4c <disk_lock>
if (sc != RTEMS_SUCCESSFUL) {
return NULL;
ffc04644: 3b a0 00 00 li r29,0
++minor;
}
}
sc = disk_lock();
if (sc != RTEMS_SUCCESSFUL) {
ffc04648: 2f 83 00 00 cmpwi cr7,r3,0
ffc0464c: 40 9e 00 9c bne- cr7,ffc046e8 <rtems_disk_next+0xf8> <== NEVER TAKEN
return NULL;
}
if (major >= disktab_size) {
ffc04650: 3d 20 00 00 lis r9,0
ffc04654: 81 69 28 e8 lwz r11,10472(r9)
ffc04658: 39 49 28 e8 addi r10,r9,10472
ffc0465c: 7f 9f 58 40 cmplw cr7,r31,r11
ffc04660: 41 bc 00 0c blt+ cr7,ffc0466c <rtems_disk_next+0x7c> <== ALWAYS TAKEN
disk_unlock();
ffc04664: 4b ff f9 39 bl ffc03f9c <disk_unlock> <== NOT EXECUTED
return NULL;
ffc04668: 48 00 00 80 b ffc046e8 <rtems_disk_next+0xf8> <== NOT EXECUTED
}
dtab = disktab + major;
ffc0466c: 80 0a 00 04 lwz r0,4(r10)
ffc04670: 57 fd 18 38 rlwinm r29,r31,3,0,28
ffc04674: 7f a0 ea 14 add r29,r0,r29
while (true) {
if (dtab->minor == NULL || minor >= dtab->size) {
ffc04678: 81 3d 00 00 lwz r9,0(r29)
ffc0467c: 2f 89 00 00 cmpwi cr7,r9,0
ffc04680: 41 9e 00 10 beq- cr7,ffc04690 <rtems_disk_next+0xa0>
ffc04684: 81 5d 00 04 lwz r10,4(r29)
ffc04688: 7f 9e 50 40 cmplw cr7,r30,r10
ffc0468c: 41 9c 00 2c blt- cr7,ffc046b8 <rtems_disk_next+0xc8>
minor = 0;
++major;
ffc04690: 3b ff 00 01 addi r31,r31,1
if (major >= disktab_size) {
ffc04694: 7f 9f 58 40 cmplw cr7,r31,r11
ffc04698: 41 bc 00 10 blt+ cr7,ffc046a8 <rtems_disk_next+0xb8>
disk_unlock();
ffc0469c: 4b ff f9 01 bl ffc03f9c <disk_unlock>
return NULL;
ffc046a0: 3b a0 00 00 li r29,0
ffc046a4: 48 00 00 44 b ffc046e8 <rtems_disk_next+0xf8>
}
dtab = disktab + major;
ffc046a8: 57 fd 18 38 rlwinm r29,r31,3,0,28
ffc046ac: 7f a0 ea 14 add r29,r0,r29
}
dtab = disktab + major;
while (true) {
if (dtab->minor == NULL || minor >= dtab->size) {
minor = 0;
ffc046b0: 3b c0 00 00 li r30,0
if (major >= disktab_size) {
disk_unlock();
return NULL;
}
dtab = disktab + major;
ffc046b4: 4b ff ff c4 b ffc04678 <rtems_disk_next+0x88>
} else if (dtab->minor [minor] == NULL) {
ffc046b8: 57 dc 10 3a rlwinm r28,r30,2,0,29
ffc046bc: 7d 29 e0 2e lwzx r9,r9,r28
ffc046c0: 2f 89 00 00 cmpwi cr7,r9,0
ffc046c4: 40 9e 00 0c bne- cr7,ffc046d0 <rtems_disk_next+0xe0>
++minor;
ffc046c8: 3b de 00 01 addi r30,r30,1
ffc046cc: 4b ff ff ac b ffc04678 <rtems_disk_next+0x88>
} else {
++dtab->minor [minor]->uses;
ffc046d0: 81 69 00 14 lwz r11,20(r9)
ffc046d4: 38 0b 00 01 addi r0,r11,1
ffc046d8: 90 09 00 14 stw r0,20(r9)
disk_unlock();
ffc046dc: 4b ff f8 c1 bl ffc03f9c <disk_unlock>
return dtab->minor [minor];
ffc046e0: 81 3d 00 00 lwz r9,0(r29)
ffc046e4: 7f a9 e0 2e lwzx r29,r9,r28
}
}
}
ffc046e8: 39 61 00 18 addi r11,r1,24
ffc046ec: 7f a3 eb 78 mr r3,r29
ffc046f0: 48 01 4e 1c b ffc1950c <_restgpr_28_x>
ffc04504 <rtems_disk_obtain>:
rtems_disk_device *
rtems_disk_obtain(dev_t dev)
{
ffc04504: 94 21 ff e8 stwu r1,-24(r1)
ffc04508: 7c 08 02 a6 mflr r0
ffc0450c: bf 81 00 08 stmw r28,8(r1)
ffc04510: 7c 9d 23 78 mr r29,r4
ffc04514: 7c 7c 1b 78 mr r28,r3
ffc04518: 90 01 00 1c stw r0,28(r1)
static inline uint32_t ppc_interrupt_disable( void )
{
uint32_t level;
uint32_t mask;
__asm__ volatile (
ffc0451c: 7f e0 00 a6 mfmsr r31
ffc04520: 7c 10 42 a6 mfsprg r0,0
ffc04524: 7f e0 00 78 andc r0,r31,r0
ffc04528: 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) {
ffc0452c: 3d 20 00 00 lis r9,0
ffc04530: 88 09 28 f4 lbz r0,10484(r9)
ffc04534: 2f 80 00 00 cmpwi cr7,r0,0
ffc04538: 40 be 00 18 bne+ cr7,ffc04550 <rtems_disk_obtain+0x4c> <== NEVER TAKEN
/* Frequent and quickest case */
dd = get_disk_entry(dev, false);
ffc0453c: 38 a0 00 00 li r5,0
ffc04540: 4b ff f9 25 bl ffc03e64 <get_disk_entry>
ffc04544: 7c 7e 1b 78 mr r30,r3
return level;
}
static inline void ppc_interrupt_enable( uint32_t level )
{
__asm__ volatile (
ffc04548: 7f e0 01 24 mtmsr r31
ffc0454c: 48 00 00 30 b ffc0457c <rtems_disk_obtain+0x78>
ffc04550: 7f e0 01 24 mtmsr r31 <== NOT EXECUTED
rtems_interrupt_enable(level);
} else {
rtems_interrupt_enable(level);
sc = disk_lock();
ffc04554: 4b ff f9 f9 bl ffc03f4c <disk_lock> <== NOT EXECUTED
rtems_disk_device *
rtems_disk_obtain(dev_t dev)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_disk_device *dd = NULL;
ffc04558: 3b c0 00 00 li r30,0 <== NOT EXECUTED
rtems_interrupt_enable(level);
} else {
rtems_interrupt_enable(level);
sc = disk_lock();
if (sc == RTEMS_SUCCESSFUL) {
ffc0455c: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc04560: 40 9e 00 1c bne- cr7,ffc0457c <rtems_disk_obtain+0x78> <== NOT EXECUTED
dd = get_disk_entry(dev, false);
ffc04564: 7f 83 e3 78 mr r3,r28 <== NOT EXECUTED
ffc04568: 7f a4 eb 78 mr r4,r29 <== NOT EXECUTED
ffc0456c: 38 a0 00 00 li r5,0 <== NOT EXECUTED
ffc04570: 4b ff f8 f5 bl ffc03e64 <get_disk_entry> <== NOT EXECUTED
ffc04574: 7c 7e 1b 78 mr r30,r3 <== NOT EXECUTED
disk_unlock();
ffc04578: 4b ff fa 25 bl ffc03f9c <disk_unlock> <== NOT EXECUTED
}
}
return dd;
}
ffc0457c: 39 61 00 18 addi r11,r1,24
ffc04580: 7f c3 f3 78 mr r3,r30
ffc04584: 48 01 4f 88 b ffc1950c <_restgpr_28_x>
ffc0464c <rtems_error>:
int rtems_error(
rtems_error_code_t error_flag,
const char *printf_format,
...
)
{
ffc0464c: 7c 2b 0b 78 mr r11,r1
ffc04650: 7c 08 02 a6 mflr r0
ffc04654: 94 21 ff 88 stwu r1,-120(r1)
ffc04658: 48 01 6c f5 bl ffc1b34c <_savegpr_31>
ffc0465c: 90 01 00 7c stw r0,124(r1)
ffc04660: 7c 7f 1b 78 mr r31,r3
ffc04664: 90 a1 00 18 stw r5,24(r1)
ffc04668: 90 c1 00 1c stw r6,28(r1)
ffc0466c: 90 e1 00 20 stw r7,32(r1)
ffc04670: 91 01 00 24 stw r8,36(r1)
ffc04674: 91 21 00 28 stw r9,40(r1)
ffc04678: 91 41 00 2c stw r10,44(r1)
ffc0467c: 40 86 00 24 bne- cr1,ffc046a0 <rtems_error+0x54> <== ALWAYS TAKEN
ffc04680: d8 21 00 30 stfd f1,48(r1) <== NOT EXECUTED
ffc04684: d8 41 00 38 stfd f2,56(r1) <== NOT EXECUTED
ffc04688: d8 61 00 40 stfd f3,64(r1) <== NOT EXECUTED
ffc0468c: d8 81 00 48 stfd f4,72(r1) <== NOT EXECUTED
ffc04690: d8 a1 00 50 stfd f5,80(r1) <== NOT EXECUTED
ffc04694: d8 c1 00 58 stfd f6,88(r1) <== NOT EXECUTED
ffc04698: d8 e1 00 60 stfd f7,96(r1) <== NOT EXECUTED
ffc0469c: d9 01 00 68 stfd f8,104(r1) <== NOT EXECUTED
va_list arglist;
int chars_written;
va_start(arglist, printf_format);
ffc046a0: 38 00 00 02 li r0,2
ffc046a4: 98 01 00 08 stb r0,8(r1)
ffc046a8: 38 00 00 00 li r0,0
chars_written = rtems_verror(error_flag, printf_format, arglist);
ffc046ac: 7f e3 fb 78 mr r3,r31
)
{
va_list arglist;
int chars_written;
va_start(arglist, printf_format);
ffc046b0: 98 01 00 09 stb r0,9(r1)
ffc046b4: 38 01 00 80 addi r0,r1,128
chars_written = rtems_verror(error_flag, printf_format, arglist);
ffc046b8: 38 a1 00 08 addi r5,r1,8
)
{
va_list arglist;
int chars_written;
va_start(arglist, printf_format);
ffc046bc: 90 01 00 0c stw r0,12(r1)
ffc046c0: 38 01 00 10 addi r0,r1,16
ffc046c4: 90 01 00 10 stw r0,16(r1)
chars_written = rtems_verror(error_flag, printf_format, arglist);
ffc046c8: 4b ff fe 05 bl ffc044cc <rtems_verror>
va_end(arglist);
if (error_flag & RTEMS_ERROR_PANIC) {
ffc046cc: 77 e0 20 00 andis. r0,r31,8192
ffc046d0: 41 a2 00 24 beq+ ffc046f4 <rtems_error+0xa8>
rtems_error(0, "fatal error, exiting");
ffc046d4: 3c 80 ff c2 lis r4,-62
ffc046d8: 38 84 d4 c7 addi r4,r4,-11065
ffc046dc: 38 60 00 00 li r3,0
ffc046e0: 4c c6 31 82 crclr 4*cr1+eq
ffc046e4: 4b ff ff 69 bl ffc0464c <rtems_error>
_exit(errno);
ffc046e8: 48 00 c4 cd bl ffc10bb4 <__errno>
ffc046ec: 80 63 00 00 lwz r3,0(r3)
ffc046f0: 48 00 0c 11 bl ffc05300 <_exit>
}
if (error_flag & RTEMS_ERROR_ABORT) {
ffc046f4: 77 e0 10 00 andis. r0,r31,4096
ffc046f8: 41 a2 00 1c beq+ ffc04714 <rtems_error+0xc8>
rtems_error(0, "fatal error, aborting");
ffc046fc: 3c 80 ff c2 lis r4,-62
ffc04700: 38 84 d4 dc addi r4,r4,-11044
ffc04704: 38 60 00 00 li r3,0
ffc04708: 4c c6 31 82 crclr 4*cr1+eq
ffc0470c: 4b ff ff 41 bl ffc0464c <rtems_error>
abort();
ffc04710: 48 00 c4 89 bl ffc10b98 <abort>
}
return chars_written;
}
ffc04714: 39 61 00 78 addi r11,r1,120
ffc04718: 4b ff be 2c b ffc00544 <_restgpr_31_x>
ffc0d518 <rtems_filesystem_get_mount_handler>:
find_arg fa = {
.type = type,
.mount_h = NULL
};
if ( type != NULL ) {
ffc0d518: 2f 83 00 00 cmpwi cr7,r3,0
rtems_filesystem_fsmount_me_t
rtems_filesystem_get_mount_handler(
const char *type
)
{
ffc0d51c: 94 21 ff e8 stwu r1,-24(r1)
ffc0d520: 7c 08 02 a6 mflr r0
find_arg fa = {
ffc0d524: 90 61 00 08 stw r3,8(r1)
rtems_filesystem_fsmount_me_t
rtems_filesystem_get_mount_handler(
const char *type
)
{
ffc0d528: 90 01 00 1c stw r0,28(r1)
find_arg fa = {
ffc0d52c: 38 00 00 00 li r0,0
ffc0d530: 90 01 00 0c stw r0,12(r1)
.type = type,
.mount_h = NULL
};
if ( type != NULL ) {
ffc0d534: 41 9e 00 14 beq- cr7,ffc0d548 <rtems_filesystem_get_mount_handler+0x30><== NEVER TAKEN
rtems_filesystem_iterate( find_handler, &fa );
ffc0d538: 3c 60 ff c1 lis r3,-63
ffc0d53c: 38 63 d3 c4 addi r3,r3,-11324
ffc0d540: 38 81 00 08 addi r4,r1,8
ffc0d544: 4b ff ff 21 bl ffc0d464 <rtems_filesystem_iterate>
}
return fa.mount_h;
}
ffc0d548: 80 01 00 1c lwz r0,28(r1)
ffc0d54c: 80 61 00 0c lwz r3,12(r1)
ffc0d550: 38 21 00 18 addi r1,r1,24
ffc0d554: 7c 08 03 a6 mtlr r0
ffc0d558: 4e 80 00 20 blr
ffc04344 <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 )
{
ffc04344: 94 21 ff c8 stwu r1,-56(r1)
ffc04348: 7c 08 02 a6 mflr r0
/*
* mount the first filesystem.
*/
if ( rtems_filesystem_mount_table_size == 0 )
rtems_fatal_error_occurred( 0xABCD0001 );
ffc0434c: 3c 60 ab cd lis r3,-21555
* configuration is a single instantiation of the IMFS or miniIMFS with
* a single "/dev" directory in it.
*/
void rtems_filesystem_initialize( void )
{
ffc04350: bf a1 00 2c stmw r29,44(r1)
/*
* Set the default umask to "022".
*/
rtems_filesystem_umask = 022;
ffc04354: 3f c0 00 00 lis r30,0
/*
* mount the first filesystem.
*/
if ( rtems_filesystem_mount_table_size == 0 )
rtems_fatal_error_occurred( 0xABCD0001 );
ffc04358: 60 63 00 01 ori r3,r3,1
/*
* Set the default umask to "022".
*/
rtems_filesystem_umask = 022;
ffc0435c: 81 3e 27 7c lwz r9,10108(r30)
* configuration is a single instantiation of the IMFS or miniIMFS with
* a single "/dev" directory in it.
*/
void rtems_filesystem_initialize( void )
{
ffc04360: 90 01 00 3c stw r0,60(r1)
/*
* Set the default umask to "022".
*/
rtems_filesystem_umask = 022;
ffc04364: 38 00 00 12 li r0,18
ffc04368: 90 09 00 2c stw r0,44(r9)
/*
* mount the first filesystem.
*/
if ( rtems_filesystem_mount_table_size == 0 )
ffc0436c: 3d 20 00 00 lis r9,0
ffc04370: 80 09 27 30 lwz r0,10032(r9)
ffc04374: 2f 80 00 00 cmpwi cr7,r0,0
ffc04378: 41 9e 00 34 beq- cr7,ffc043ac <rtems_filesystem_initialize+0x68><== NEVER TAKEN
rtems_fatal_error_occurred( 0xABCD0001 );
mt = &rtems_filesystem_mount_table[0];
ffc0437c: 3d 20 00 00 lis r9,0
ffc04380: 81 29 27 34 lwz r9,10036(r9)
status = mount( mt->device, mt->mount_point, mt->type, mt->fsoptions, NULL );
ffc04384: 38 e0 00 00 li r7,0
ffc04388: 80 69 00 08 lwz r3,8(r9)
ffc0438c: 80 89 00 0c lwz r4,12(r9)
ffc04390: 80 a9 00 00 lwz r5,0(r9)
ffc04394: 80 c9 00 04 lwz r6,4(r9)
ffc04398: 48 00 0c 35 bl ffc04fcc <mount>
if ( status == -1 )
ffc0439c: 2f 83 ff ff cmpwi cr7,r3,-1
ffc043a0: 40 be 00 10 bne+ cr7,ffc043b0 <rtems_filesystem_initialize+0x6c><== ALWAYS TAKEN
rtems_fatal_error_occurred( 0xABCD0002 );
ffc043a4: 3c 60 ab cd lis r3,-21555 <== NOT EXECUTED
ffc043a8: 60 63 00 02 ori r3,r3,2 <== NOT EXECUTED
ffc043ac: 48 00 44 d1 bl ffc0887c <rtems_fatal_error_occurred> <== NOT EXECUTED
rtems_filesystem_link_counts = 0;
ffc043b0: 81 3e 27 7c lwz r9,10108(r30)
ffc043b4: 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);
ffc043b8: 3f a0 ff c2 lis r29,-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;
ffc043bc: 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);
ffc043c0: 3b e1 00 08 addi r31,r1,8
ffc043c4: 3b bd d3 28 addi r29,r29,-11480
ffc043c8: 38 a0 00 00 li r5,0
ffc043cc: 7f e6 fb 78 mr r6,r31
ffc043d0: 38 e0 00 00 li r7,0
ffc043d4: 38 80 00 01 li r4,1
ffc043d8: 7f a3 eb 78 mr r3,r29
ffc043dc: 48 00 04 61 bl ffc0483c <rtems_filesystem_evaluate_path>
rtems_filesystem_root = loc;
ffc043e0: 81 7e 27 7c lwz r11,10108(r30)
/* One more clone for the current node */
rtems_filesystem_evaluate_path("/", 1, 0, &loc, 0);
ffc043e4: 38 80 00 01 li r4,1
*
* Till Straumann, 10/25/2002
*/
/* Clone the root pathloc */
rtems_filesystem_evaluate_path("/", 1, 0, &loc, 0);
rtems_filesystem_root = loc;
ffc043e8: 39 6b 00 18 addi r11,r11,24
ffc043ec: 7c bf a4 aa lswi r5,r31,20
ffc043f0: 7c ab a5 aa stswi r5,r11,20
/* One more clone for the current node */
rtems_filesystem_evaluate_path("/", 1, 0, &loc, 0);
ffc043f4: 7f a3 eb 78 mr r3,r29
ffc043f8: 38 a0 00 00 li r5,0
ffc043fc: 7f e6 fb 78 mr r6,r31
ffc04400: 38 e0 00 00 li r7,0
ffc04404: 48 00 04 39 bl ffc0483c <rtems_filesystem_evaluate_path>
rtems_filesystem_current = loc;
ffc04408: 81 7e 27 7c lwz r11,10108(r30)
*
* 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);
ffc0440c: 3c 60 ff c2 lis r3,-62
/* 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;
ffc04410: 39 6b 00 04 addi r11,r11,4
ffc04414: 7c bf a4 aa lswi r5,r31,20
ffc04418: 7c ab a5 aa stswi r5,r11,20
*
* 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);
ffc0441c: 38 63 d3 2a addi r3,r3,-11478
ffc04420: 38 80 01 ff li r4,511
ffc04424: 48 00 09 dd bl ffc04e00 <mkdir>
if ( status != 0 )
ffc04428: 2f 83 00 00 cmpwi cr7,r3,0
ffc0442c: 41 be 00 10 beq+ cr7,ffc0443c <rtems_filesystem_initialize+0xf8><== ALWAYS TAKEN
rtems_fatal_error_occurred( 0xABCD0003 );
ffc04430: 3c 60 ab cd lis r3,-21555 <== NOT EXECUTED
ffc04434: 60 63 00 03 ori r3,r3,3 <== NOT EXECUTED
ffc04438: 4b ff ff 74 b ffc043ac <rtems_filesystem_initialize+0x68><== NOT EXECUTED
* it will be mounted onto is created. Moreover, if it is going to
* use a device, then it is REALLY unfair to attempt this
* before device drivers are initialized. So we return via a base
* filesystem image and nothing auto-mounted at this point.
*/
}
ffc0443c: 39 61 00 38 addi r11,r1,56
ffc04440: 4b ff c0 fc b ffc0053c <_restgpr_29_x>
ffc0d464 <rtems_filesystem_iterate>:
bool rtems_filesystem_iterate(
rtems_per_filesystem_routine routine,
void *routine_arg
)
{
ffc0d464: 94 21 ff e0 stwu r1,-32(r1)
ffc0d468: 7c 08 02 a6 mflr r0
ffc0d46c: bf 81 00 10 stmw r28,16(r1)
const rtems_filesystem_table_t *table_entry = &rtems_filesystem_table [0];
ffc0d470: 3f e0 ff c2 lis r31,-62
bool rtems_filesystem_iterate(
rtems_per_filesystem_routine routine,
void *routine_arg
)
{
ffc0d474: 7c 9e 23 78 mr r30,r4
ffc0d478: 90 01 00 24 stw r0,36(r1)
const rtems_filesystem_table_t *table_entry = &rtems_filesystem_table [0];
rtems_chain_node *node = NULL;
bool stop = false;
ffc0d47c: 3b 80 00 00 li r28,0
bool rtems_filesystem_iterate(
rtems_per_filesystem_routine routine,
void *routine_arg
)
{
const rtems_filesystem_table_t *table_entry = &rtems_filesystem_table [0];
ffc0d480: 3b ff c6 a8 addi r31,r31,-14680
bool rtems_filesystem_iterate(
rtems_per_filesystem_routine routine,
void *routine_arg
)
{
ffc0d484: 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 ) {
ffc0d488: 48 00 00 20 b ffc0d4a8 <rtems_filesystem_iterate+0x44>
stop = (*routine)( table_entry, routine_arg );
ffc0d48c: 80 01 00 08 lwz r0,8(r1)
ffc0d490: 7f e3 fb 78 mr r3,r31
ffc0d494: 7f c4 f3 78 mr r4,r30
ffc0d498: 7c 09 03 a6 mtctr r0
++table_entry;
ffc0d49c: 3b ff 00 08 addi r31,r31,8
const rtems_filesystem_table_t *table_entry = &rtems_filesystem_table [0];
rtems_chain_node *node = NULL;
bool stop = false;
while ( table_entry->type && !stop ) {
stop = (*routine)( table_entry, routine_arg );
ffc0d4a0: 4e 80 04 21 bctrl
ffc0d4a4: 7c 7c 1b 78 mr r28,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 ) {
ffc0d4a8: 80 1f 00 00 lwz r0,0(r31)
ffc0d4ac: 2f 9c 00 00 cmpwi cr7,r28,0
ffc0d4b0: 2f 00 00 00 cmpwi cr6,r0,0
ffc0d4b4: 41 9a 00 0c beq- cr6,ffc0d4c0 <rtems_filesystem_iterate+0x5c>
ffc0d4b8: 41 9e ff d4 beq+ cr7,ffc0d48c <rtems_filesystem_iterate+0x28>
ffc0d4bc: 48 00 00 50 b ffc0d50c <rtems_filesystem_iterate+0xa8>
stop = (*routine)( table_entry, routine_arg );
++table_entry;
}
if ( !stop ) {
ffc0d4c0: 40 9e 00 4c bne- cr7,ffc0d50c <rtems_filesystem_iterate+0xa8>
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
ffc0d4c4: 3f a0 00 00 lis r29,0
rtems_libio_lock();
ffc0d4c8: 4b ff ff 45 bl ffc0d40c <rtems_libio_lock>
ffc0d4cc: 83 fd 21 c0 lwz r31,8640(r29)
RTEMS_INLINE_ROUTINE bool _Chain_Is_tail(
Chain_Control *the_chain,
const Chain_Node *the_node
)
{
return (the_node == _Chain_Tail(the_chain));
ffc0d4d0: 3b bd 21 c0 addi r29,r29,8640
ffc0d4d4: 3b bd 00 04 addi r29,r29,4
for (
ffc0d4d8: 48 00 00 20 b ffc0d4f8 <rtems_filesystem_iterate+0x94>
!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 );
ffc0d4dc: 80 01 00 08 lwz r0,8(r1)
ffc0d4e0: 38 7f 00 08 addi r3,r31,8
ffc0d4e4: 7f c4 f3 78 mr r4,r30
ffc0d4e8: 7c 09 03 a6 mtctr r0
ffc0d4ec: 4e 80 04 21 bctrl
}
}
rtems_libio_unlock();
rtems_set_errno_and_return_minus_one( ENOENT );
}
ffc0d4f0: 83 ff 00 00 lwz r31,0(r31)
!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 );
ffc0d4f4: 7c 7c 1b 78 mr r28,r3
++table_entry;
}
if ( !stop ) {
rtems_libio_lock();
for (
ffc0d4f8: 7f 9f e8 00 cmpw cr7,r31,r29
ffc0d4fc: 41 9e 00 0c beq- cr7,ffc0d508 <rtems_filesystem_iterate+0xa4>
node = rtems_chain_first( &filesystem_chain );
!rtems_chain_is_tail( &filesystem_chain, node ) && !stop;
ffc0d500: 2f 9c 00 00 cmpwi cr7,r28,0
ffc0d504: 41 9e ff d8 beq+ cr7,ffc0d4dc <rtems_filesystem_iterate+0x78><== ALWAYS TAKEN
) {
const filesystem_node *fsn = (filesystem_node *) node;
stop = (*routine)( &fsn->entry, routine_arg );
}
rtems_libio_unlock();
ffc0d508: 4b ff ff 35 bl ffc0d43c <rtems_libio_unlock>
}
return stop;
}
ffc0d50c: 39 61 00 20 addi r11,r1,32
ffc0d510: 7f 83 e3 78 mr r3,r28
ffc0d514: 4b ff 30 24 b ffc00538 <_restgpr_28_x>
ffc04f58 <rtems_filesystem_mount_iterate>:
bool rtems_filesystem_mount_iterate(
rtems_per_filesystem_mount_routine routine,
void *routine_arg
)
{
ffc04f58: 94 21 ff e0 stwu r1,-32(r1)
ffc04f5c: 7c 08 02 a6 mflr r0
ffc04f60: bf 61 00 0c stmw r27,12(r1)
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
ffc04f64: 3f c0 00 00 lis r30,0
ffc04f68: 7c 7c 1b 78 mr r28,r3
ffc04f6c: 90 01 00 24 stw r0,36(r1)
ffc04f70: 7c 9d 23 78 mr r29,r4
rtems_chain_node *node = NULL;
bool stop = false;
rtems_libio_lock();
ffc04f74: 4b ff ff b5 bl ffc04f28 <rtems_libio_lock>
rtems_per_filesystem_mount_routine routine,
void *routine_arg
)
{
rtems_chain_node *node = NULL;
bool stop = false;
ffc04f78: 3b 60 00 00 li r27,0
ffc04f7c: 83 fe 21 a4 lwz r31,8612(r30)
RTEMS_INLINE_ROUTINE bool _Chain_Is_tail(
Chain_Control *the_chain,
const Chain_Node *the_node
)
{
return (the_node == _Chain_Tail(the_chain));
ffc04f80: 3b de 21 a4 addi r30,r30,8612
ffc04f84: 3b de 00 04 addi r30,r30,4
rtems_libio_lock();
for (
ffc04f88: 48 00 00 1c b ffc04fa4 <rtems_filesystem_mount_iterate+0x4c>
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 );
ffc04f8c: 7f e3 fb 78 mr r3,r31
ffc04f90: 7f 89 03 a6 mtctr r28
ffc04f94: 7f a4 eb 78 mr r4,r29
ffc04f98: 4e 80 04 21 bctrl
}
rtems_libio_unlock();
return stop;
}
ffc04f9c: 83 ff 00 00 lwz r31,0(r31)
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 );
ffc04fa0: 7c 7b 1b 78 mr r27,r3
{
rtems_chain_node *node = NULL;
bool stop = false;
rtems_libio_lock();
for (
ffc04fa4: 7f 9f f0 00 cmpw cr7,r31,r30
ffc04fa8: 41 9e 00 0c beq- cr7,ffc04fb4 <rtems_filesystem_mount_iterate+0x5c>
node = rtems_chain_first( &mount_chain );
!rtems_chain_is_tail( &mount_chain, node ) && !stop;
ffc04fac: 2f 9b 00 00 cmpwi cr7,r27,0
ffc04fb0: 41 9e ff dc beq+ cr7,ffc04f8c <rtems_filesystem_mount_iterate+0x34><== ALWAYS TAKEN
static inline void rtems_libio_unlock( void )
{
rtems_semaphore_release( rtems_libio_semaphore );
ffc04fb4: 3d 20 00 00 lis r9,0
ffc04fb8: 80 69 27 f8 lwz r3,10232(r9)
ffc04fbc: 48 00 32 15 bl ffc081d0 <rtems_semaphore_release>
stop = (*routine)( mt_entry, routine_arg );
}
rtems_libio_unlock();
return stop;
}
ffc04fc0: 39 61 00 20 addi r11,r1,32
ffc04fc4: 7f 63 db 78 mr r3,r27
ffc04fc8: 4b ff b5 6c b ffc00534 <_restgpr_27_x>
ffc04f14 <rtems_gxx_key_create>:
int rtems_gxx_key_create (__gthread_key_t *key, void (*dtor) (void *))
{
ffc04f14: 94 21 ff e8 stwu r1,-24(r1)
ffc04f18: 7c 08 02 a6 mflr r0
ffc04f1c: bf a1 00 0c stmw r29,12(r1)
ffc04f20: 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 ) );
ffc04f24: 38 60 00 08 li r3,8
}
return 0;
}
int rtems_gxx_key_create (__gthread_key_t *key, void (*dtor) (void *))
{
ffc04f28: 7c 9e 23 78 mr r30,r4
ffc04f2c: 90 01 00 1c stw r0,28(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 ) );
ffc04f30: 48 00 05 31 bl ffc05460 <malloc>
*key = new_key;
new_key->val = NULL;
ffc04f34: 38 00 00 00 li r0,0
* 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 ) );
*key = new_key;
ffc04f38: 90 7d 00 00 stw r3,0(r29)
* 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 ) );
ffc04f3c: 7c 7f 1b 78 mr r31,r3
"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 );
ffc04f40: 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;
ffc04f44: 90 03 00 00 stw r0,0(r3)
"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 );
ffc04f48: 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;
ffc04f4c: 93 c3 00 04 stw r30,4(r3)
"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 );
ffc04f50: 38 60 00 00 li r3,0
ffc04f54: 48 00 3f 51 bl ffc08ea4 <rtems_task_variable_add>
if ( status == RTEMS_SUCCESSFUL )
return 0;
ffc04f58: 38 00 00 00 li r0,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 )
ffc04f5c: 2f 83 00 00 cmpwi cr7,r3,0
ffc04f60: 41 be 00 10 beq+ cr7,ffc04f70 <rtems_gxx_key_create+0x5c><== ALWAYS TAKEN
return 0;
free( new_key );
ffc04f64: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc04f68: 4b ff fe 09 bl ffc04d70 <free> <== NOT EXECUTED
return -1;
ffc04f6c: 38 00 ff ff li r0,-1 <== NOT EXECUTED
}
ffc04f70: 39 61 00 18 addi r11,r1,24
ffc04f74: 7c 03 03 78 mr r3,r0
ffc04f78: 4b ff bc f0 b ffc00c68 <_restgpr_29_x>
ffc04f8c <rtems_gxx_key_delete>:
int rtems_gxx_key_delete (__gthread_key_t key)
{
ffc04f8c: 7c 2b 0b 78 mr r11,r1
ffc04f90: 94 21 ff f0 stwu r1,-16(r1)
ffc04f94: 7c 08 02 a6 mflr r0
ffc04f98: 48 01 12 39 bl ffc161d0 <_savegpr_31>
ffc04f9c: 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 );
ffc04fa0: 7f e4 fb 78 mr r4,r31
key->val = 0;
return 0;
}
int rtems_gxx_key_delete (__gthread_key_t key)
{
ffc04fa4: 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 );
ffc04fa8: 38 60 00 00 li r3,0
ffc04fac: 48 00 3f ad bl ffc08f58 <rtems_task_variable_delete>
if ( status == RTEMS_SUCCESSFUL ) {
ffc04fb0: 2f 83 00 00 cmpwi cr7,r3,0
ffc04fb4: 40 9e 00 14 bne- cr7,ffc04fc8 <rtems_gxx_key_delete+0x3c><== NEVER TAKEN
/* Hmm - hopefully all tasks using this key have gone away... */
if ( key ) free( *(void **)key );
ffc04fb8: 2f 9f 00 00 cmpwi cr7,r31,0
ffc04fbc: 41 9e 00 0c beq- cr7,ffc04fc8 <rtems_gxx_key_delete+0x3c><== NEVER TAKEN
ffc04fc0: 80 7f 00 00 lwz r3,0(r31)
ffc04fc4: 4b ff fd ad bl ffc04d70 <free>
return 0;
}
key = NULL;
return 0;
}
ffc04fc8: 39 61 00 10 addi r11,r1,16
ffc04fcc: 38 60 00 00 li r3,0
ffc04fd0: 4b ff bc a0 b ffc00c70 <_restgpr_31_x>
ffc050e8 <rtems_gxx_mutex_lock>:
int rtems_gxx_mutex_lock (__gthread_mutex_t *mutex)
{
ffc050e8: 7c 08 02 a6 mflr r0
ffc050ec: 94 21 ff f8 stwu r1,-8(r1)
#ifdef DEBUG_GXX_WRAPPERS
printk( "gxx_wrappers: lock mutex=%X\n", *mutex );
#endif
status = rtems_semaphore_obtain(
ffc050f0: 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)
{
ffc050f4: 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(
ffc050f8: 38 a0 00 00 li r5,0
ffc050fc: 80 63 00 00 lwz r3,0(r3)
ffc05100: 48 00 36 71 bl ffc08770 <rtems_semaphore_obtain>
RTEMS_WAIT,
RTEMS_NO_TIMEOUT
);
if ( status == RTEMS_SUCCESSFUL )
return 0;
return -1;
ffc05104: 38 00 ff ff li r0,-1
status = rtems_semaphore_obtain(
*(rtems_id *)mutex,
RTEMS_WAIT,
RTEMS_NO_TIMEOUT
);
if ( status == RTEMS_SUCCESSFUL )
ffc05108: 2f 83 00 00 cmpwi cr7,r3,0
ffc0510c: 40 9e 00 08 bne- cr7,ffc05114 <rtems_gxx_mutex_lock+0x2c><== NEVER TAKEN
return 0;
ffc05110: 38 00 00 00 li r0,0
return -1;
}
ffc05114: 7c 03 03 78 mr r3,r0
ffc05118: 80 01 00 0c lwz r0,12(r1)
ffc0511c: 38 21 00 08 addi r1,r1,8
ffc05120: 7c 08 03 a6 mtlr r0
ffc05124: 4e 80 00 20 blr
ffc05160 <rtems_gxx_mutex_trylock>:
int rtems_gxx_mutex_trylock (__gthread_mutex_t *mutex)
{
ffc05160: 7c 08 02 a6 mflr r0
ffc05164: 94 21 ff f8 stwu r1,-8(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);
ffc05168: 38 80 00 01 li r4,1
return 0;
return -1;
}
int rtems_gxx_mutex_trylock (__gthread_mutex_t *mutex)
{
ffc0516c: 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);
ffc05170: 38 a0 00 00 li r5,0
ffc05174: 80 63 00 00 lwz r3,0(r3)
ffc05178: 48 00 35 f9 bl ffc08770 <rtems_semaphore_obtain>
if ( status == RTEMS_SUCCESSFUL )
return 0;
return -1;
ffc0517c: 38 00 ff ff li r0,-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 )
ffc05180: 2f 83 00 00 cmpwi cr7,r3,0
ffc05184: 40 9e 00 08 bne- cr7,ffc0518c <rtems_gxx_mutex_trylock+0x2c><== NEVER TAKEN
return 0;
ffc05188: 38 00 00 00 li r0,0
return -1;
}
ffc0518c: 7c 03 03 78 mr r3,r0
ffc05190: 80 01 00 0c lwz r0,12(r1)
ffc05194: 38 21 00 08 addi r1,r1,8
ffc05198: 7c 08 03 a6 mtlr r0
ffc0519c: 4e 80 00 20 blr
ffc051a0 <rtems_gxx_mutex_unlock>:
int rtems_gxx_mutex_unlock (__gthread_mutex_t *mutex)
{
ffc051a0: 7c 08 02 a6 mflr r0
ffc051a4: 94 21 ff f8 stwu r1,-8(r1)
ffc051a8: 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 );
ffc051ac: 80 63 00 00 lwz r3,0(r3)
ffc051b0: 48 00 36 ed bl ffc0889c <rtems_semaphore_release>
if ( status == RTEMS_SUCCESSFUL )
return 0;
return -1;
ffc051b4: 38 00 ff ff li r0,-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 )
ffc051b8: 2f 83 00 00 cmpwi cr7,r3,0
ffc051bc: 40 9e 00 08 bne- cr7,ffc051c4 <rtems_gxx_mutex_unlock+0x24><== NEVER TAKEN
return 0;
ffc051c0: 38 00 00 00 li r0,0
return -1;
}
ffc051c4: 7c 03 03 78 mr r3,r0
ffc051c8: 80 01 00 0c lwz r0,12(r1)
ffc051cc: 38 21 00 08 addi r1,r1,8
ffc051d0: 7c 08 03 a6 mtlr r0
ffc051d4: 4e 80 00 20 blr
ffc04ea0 <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))
{
ffc04ea0: 94 21 ff d8 stwu r1,-40(r1)
ffc04ea4: 7c 08 02 a6 mflr r0
ffc04ea8: 90 01 00 2c stw r0,44(r1)
#ifdef DEBUG_GXX_WRAPPERS
printk( "gxx_wrappers: once=%x, func=%x\n", *once, func );
#endif
if ( *(volatile __gthread_once_t *)once == 0 ) {
ffc04eac: 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))
{
ffc04eb0: bf a1 00 1c stmw r29,28(r1)
ffc04eb4: 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 ) {
ffc04eb8: 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))
{
ffc04ebc: 7c 9d 23 78 mr r29,r4
#ifdef DEBUG_GXX_WRAPPERS
printk( "gxx_wrappers: once=%x, func=%x\n", *once, func );
#endif
if ( *(volatile __gthread_once_t *)once == 0 ) {
ffc04ec0: 40 be 00 48 bne+ cr7,ffc04f08 <rtems_gxx_once+0x68>
rtems_mode saveMode;
__gthread_once_t o;
rtems_task_mode(RTEMS_NO_PREEMPT, RTEMS_PREEMPT_MASK, &saveMode);
ffc04ec4: 38 60 01 00 li r3,256
ffc04ec8: 38 80 01 00 li r4,256
ffc04ecc: 38 a1 00 08 addi r5,r1,8
ffc04ed0: 48 00 3d 4d bl ffc08c1c <rtems_task_mode>
if ( (o = *(volatile __gthread_once_t *)once) == 0 ) {
ffc04ed4: 83 df 00 00 lwz r30,0(r31)
ffc04ed8: 2f 9e 00 00 cmpwi cr7,r30,0
ffc04edc: 40 9e 00 0c bne- cr7,ffc04ee8 <rtems_gxx_once+0x48> <== NEVER TAKEN
*(volatile __gthread_once_t *)once = 1;
ffc04ee0: 38 00 00 01 li r0,1
ffc04ee4: 90 1f 00 00 stw r0,0(r31)
}
rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode);
ffc04ee8: 7c 25 0b 78 mr r5,r1
ffc04eec: 84 65 00 08 lwzu r3,8(r5)
ffc04ef0: 38 80 01 00 li r4,256
ffc04ef4: 48 00 3d 29 bl ffc08c1c <rtems_task_mode>
if ( o == 0 )
ffc04ef8: 2f 9e 00 00 cmpwi cr7,r30,0
ffc04efc: 40 be 00 0c bne+ cr7,ffc04f08 <rtems_gxx_once+0x68> <== NEVER TAKEN
(*func)();
ffc04f00: 7f a9 03 a6 mtctr r29
ffc04f04: 4e 80 04 21 bctrl
}
return 0;
}
ffc04f08: 39 61 00 28 addi r11,r1,40
ffc04f0c: 38 60 00 00 li r3,0
ffc04f10: 4b ff bd 58 b ffc00c68 <_restgpr_29_x>
ffc05050 <rtems_gxx_setspecific>:
int rtems_gxx_setspecific(__gthread_key_t key, const void *ptr)
{
ffc05050: 94 21 ff f0 stwu r1,-16(r1)
ffc05054: 7c 08 02 a6 mflr r0
ffc05058: 90 01 00 14 stw r0,20(r1)
ffc0505c: bf c1 00 08 stmw r30,8(r1)
ffc05060: 7c 7f 1b 78 mr r31,r3
ffc05064: 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 );
ffc05068: 80 bf 00 04 lwz r5,4(r31)
ffc0506c: 38 60 00 00 li r3,0
ffc05070: 7f e4 fb 78 mr r4,r31
ffc05074: 48 00 3e 31 bl ffc08ea4 <rtems_task_variable_add>
if ( status == RTEMS_SUCCESSFUL ) {
/* now let's set the proper value */
key->val = (void *)ptr;
return 0;
}
return -1;
ffc05078: 38 00 ff ff li r0,-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 ) {
ffc0507c: 2f 83 00 00 cmpwi cr7,r3,0
ffc05080: 40 9e 00 0c bne- cr7,ffc0508c <rtems_gxx_setspecific+0x3c><== NEVER TAKEN
/* now let's set the proper value */
key->val = (void *)ptr;
ffc05084: 93 df 00 00 stw r30,0(r31)
return 0;
ffc05088: 38 00 00 00 li r0,0
}
return -1;
}
ffc0508c: 39 61 00 10 addi r11,r1,16
ffc05090: 7c 03 03 78 mr r3,r0
ffc05094: 4b ff bb d8 b ffc00c6c <_restgpr_30_x>
ffc08c68 <rtems_heap_allocate_aligned_with_boundary>:
void *rtems_heap_allocate_aligned_with_boundary(
size_t size,
uintptr_t alignment,
uintptr_t boundary
)
{
ffc08c68: 94 21 ff e8 stwu r1,-24(r1)
ffc08c6c: 7c 08 02 a6 mflr r0
if (
ffc08c70: 3d 20 00 00 lis r9,0
void *rtems_heap_allocate_aligned_with_boundary(
size_t size,
uintptr_t alignment,
uintptr_t boundary
)
{
ffc08c74: 90 01 00 1c stw r0,28(r1)
if (
ffc08c78: 80 09 28 c4 lwz r0,10436(r9)
void *rtems_heap_allocate_aligned_with_boundary(
size_t size,
uintptr_t alignment,
uintptr_t boundary
)
{
ffc08c7c: bf a1 00 0c stmw r29,12(r1)
ffc08c80: 7c 7d 1b 78 mr r29,r3
if (
ffc08c84: 2f 80 00 03 cmpwi cr7,r0,3
void *rtems_heap_allocate_aligned_with_boundary(
size_t size,
uintptr_t alignment,
uintptr_t boundary
)
{
ffc08c88: 7c 9e 23 78 mr r30,r4
ffc08c8c: 7c bf 2b 78 mr r31,r5
if (
ffc08c90: 40 be 00 14 bne+ cr7,ffc08ca4 <rtems_heap_allocate_aligned_with_boundary+0x3c><== NEVER TAKEN
_System_state_Is_up( _System_state_Get() )
&& !malloc_is_system_state_OK()
ffc08c94: 4b ff ed 31 bl ffc079c4 <malloc_is_system_state_OK>
) {
return NULL;
ffc08c98: 38 00 00 00 li r0,0
uintptr_t boundary
)
{
if (
_System_state_Is_up( _System_state_Get() )
&& !malloc_is_system_state_OK()
ffc08c9c: 2f 83 00 00 cmpwi cr7,r3,0
ffc08ca0: 41 9e 00 24 beq- cr7,ffc08cc4 <rtems_heap_allocate_aligned_with_boundary+0x5c>
) {
return NULL;
}
malloc_deferred_frees_process();
ffc08ca4: 4b ff ed 69 bl ffc07a0c <malloc_deferred_frees_process>
/* FIXME: Statistics, boundary checks */
return _Protected_heap_Allocate_aligned_with_boundary(
ffc08ca8: 3d 20 00 00 lis r9,0
ffc08cac: 80 69 27 90 lwz r3,10128(r9)
ffc08cb0: 7f a4 eb 78 mr r4,r29
ffc08cb4: 7f c5 f3 78 mr r5,r30
ffc08cb8: 7f e6 fb 78 mr r6,r31
ffc08cbc: 48 00 54 75 bl ffc0e130 <_Protected_heap_Allocate_aligned_with_boundary>
ffc08cc0: 7c 60 1b 78 mr r0,r3
RTEMS_Malloc_Heap,
size,
alignment,
boundary
);
}
ffc08cc4: 39 61 00 18 addi r11,r1,24
ffc08cc8: 7c 03 03 78 mr r3,r0
ffc08ccc: 4b ff a6 d8 b ffc033a4 <_restgpr_29_x>
ffc04248 <rtems_io_lookup_name>:
rtems_status_code rtems_io_lookup_name(
const char *name,
rtems_driver_name_t *device_info
)
{
ffc04248: 94 21 ff c8 stwu r1,-56(r1)
ffc0424c: 7c 08 02 a6 mflr r0
ffc04250: bf 81 00 28 stmw r28,40(r1)
ffc04254: 7c 7e 1b 78 mr r30,r3
ffc04258: 7c 9f 23 78 mr r31,r4
ffc0425c: 90 01 00 3c stw r0,60(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(
ffc04260: 48 00 e2 81 bl ffc124e0 <strlen>
ffc04264: 7c 64 1b 78 mr r4,r3
ffc04268: 38 a0 00 00 li r5,0
ffc0426c: 38 c1 00 08 addi r6,r1,8
ffc04270: 38 e0 00 01 li r7,1
ffc04274: 7f c3 f3 78 mr r3,r30
ffc04278: 48 00 05 c5 bl ffc0483c <rtems_filesystem_evaluate_path>
name, strlen( name ), 0x00, &loc, true );
the_jnode = loc.node_access;
node_type = (*loc.ops->node_type_h)( &loc );
ffc0427c: 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(
ffc04280: 7c 7c 1b 78 mr r28,r3
name, strlen( name ), 0x00, &loc, true );
the_jnode = loc.node_access;
ffc04284: 83 a1 00 08 lwz r29,8(r1)
node_type = (*loc.ops->node_type_h)( &loc );
ffc04288: 80 09 00 10 lwz r0,16(r9)
ffc0428c: 38 61 00 08 addi r3,r1,8
ffc04290: 7c 09 03 a6 mtctr r0
ffc04294: 4e 80 04 21 bctrl
if ( (result != 0) || node_type != RTEMS_FILESYSTEM_DEVICE ) {
ffc04298: 2f 9c 00 00 cmpwi cr7,r28,0
ffc0429c: 40 9e 00 0c bne- cr7,ffc042a8 <rtems_io_lookup_name+0x60><== NEVER TAKEN
ffc042a0: 2f 83 00 02 cmpwi cr7,r3,2
ffc042a4: 41 9e 00 14 beq- cr7,ffc042b8 <rtems_io_lookup_name+0x70>
rtems_filesystem_freenode( &loc );
ffc042a8: 38 61 00 08 addi r3,r1,8
ffc042ac: 48 00 06 85 bl ffc04930 <rtems_filesystem_freenode>
return RTEMS_UNSATISFIED;
ffc042b0: 38 60 00 0d li r3,13
ffc042b4: 48 00 00 30 b ffc042e4 <rtems_io_lookup_name+0x9c>
}
device_info->device_name = (char *) name;
ffc042b8: 93 df 00 00 stw r30,0(r31)
device_info->device_name_length = strlen( name );
ffc042bc: 7f c3 f3 78 mr r3,r30
ffc042c0: 48 00 e2 21 bl ffc124e0 <strlen>
ffc042c4: 90 7f 00 04 stw r3,4(r31)
device_info->major = the_jnode->info.device.major;
device_info->minor = the_jnode->info.device.minor;
rtems_filesystem_freenode( &loc );
ffc042c8: 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;
ffc042cc: 80 1d 00 50 lwz r0,80(r29)
ffc042d0: 90 1f 00 08 stw r0,8(r31)
device_info->minor = the_jnode->info.device.minor;
ffc042d4: 80 1d 00 54 lwz r0,84(r29)
ffc042d8: 90 1f 00 0c stw r0,12(r31)
rtems_filesystem_freenode( &loc );
ffc042dc: 48 00 06 55 bl ffc04930 <rtems_filesystem_freenode>
return RTEMS_SUCCESSFUL;
ffc042e0: 38 60 00 00 li r3,0
}
ffc042e4: 39 61 00 38 addi r11,r1,56
ffc042e8: 4b ff c2 50 b ffc00538 <_restgpr_28_x>
ffc0ae48 <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)
{
ffc0ae48: 94 21 ff e0 stwu r1,-32(r1)
ffc0ae4c: 7c 08 02 a6 mflr r0
ffc0ae50: bf 61 00 0c stmw r27,12(r1)
uint32_t i;
uint32_t api_index;
Thread_Control *the_thread;
Objects_Information *information;
if ( !routine )
ffc0ae54: 7c 7b 1b 79 mr. r27,r3
#include <rtems/system.h>
#include <rtems/score/thread.h>
void rtems_iterate_over_all_threads(rtems_per_thread_routine routine)
{
ffc0ae58: 90 01 00 24 stw r0,36(r1)
uint32_t i;
uint32_t api_index;
Thread_Control *the_thread;
Objects_Information *information;
if ( !routine )
ffc0ae5c: 41 82 00 5c beq- ffc0aeb8 <rtems_iterate_over_all_threads+0x70><== NEVER TAKEN
ffc0ae60: 3f e0 00 00 lis r31,0
ffc0ae64: 3b ff 30 80 addi r31,r31,12416
#endif
#include <rtems/system.h>
#include <rtems/score/thread.h>
void rtems_iterate_over_all_threads(rtems_per_thread_routine routine)
ffc0ae68: 3b 9f 00 0c addi r28,r31,12
#if !defined(RTEMS_POSIX_API) || defined(RTEMS_DEBUG)
if ( !_Objects_Information_table[ api_index ] )
continue;
#endif
information = _Objects_Information_table[ api_index ][ 1 ];
ffc0ae6c: 85 3f 00 04 lwzu r9,4(r31)
if ( !information )
ffc0ae70: 3b c0 00 01 li r30,1
#if !defined(RTEMS_POSIX_API) || defined(RTEMS_DEBUG)
if ( !_Objects_Information_table[ api_index ] )
continue;
#endif
information = _Objects_Information_table[ api_index ][ 1 ];
ffc0ae74: 83 a9 00 04 lwz r29,4(r9)
if ( !information )
ffc0ae78: 2f 9d 00 00 cmpwi cr7,r29,0
ffc0ae7c: 40 be 00 28 bne+ cr7,ffc0aea4 <rtems_iterate_over_all_threads+0x5c>
ffc0ae80: 48 00 00 30 b ffc0aeb0 <rtems_iterate_over_all_threads+0x68>
continue;
for ( i=1 ; i <= information->maximum ; i++ ) {
the_thread = (Thread_Control *)information->local_table[ i ];
ffc0ae84: 81 3d 00 1c lwz r9,28(r29)
ffc0ae88: 57 c0 10 3a rlwinm r0,r30,2,0,29
ffc0ae8c: 7c 69 00 2e lwzx r3,r9,r0
if ( !the_thread )
ffc0ae90: 2f 83 00 00 cmpwi cr7,r3,0
ffc0ae94: 41 9e 00 0c beq- cr7,ffc0aea0 <rtems_iterate_over_all_threads+0x58>
continue;
(*routine)(the_thread);
ffc0ae98: 7f 69 03 a6 mtctr r27
ffc0ae9c: 4e 80 04 21 bctrl
information = _Objects_Information_table[ api_index ][ 1 ];
if ( !information )
continue;
for ( i=1 ; i <= information->maximum ; i++ ) {
ffc0aea0: 3b de 00 01 addi r30,r30,1
ffc0aea4: a0 1d 00 10 lhz r0,16(r29)
ffc0aea8: 7f 9e 00 40 cmplw cr7,r30,r0
ffc0aeac: 40 9d ff d8 ble+ cr7,ffc0ae84 <rtems_iterate_over_all_threads+0x3c>
Objects_Information *information;
if ( !routine )
return;
for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; api_index++ ) {
ffc0aeb0: 7f 9f e0 00 cmpw cr7,r31,r28
ffc0aeb4: 40 9e ff b8 bne+ cr7,ffc0ae6c <rtems_iterate_over_all_threads+0x24>
(*routine)(the_thread);
}
}
}
ffc0aeb8: 39 61 00 20 addi r11,r1,32
ffc0aebc: 4b ff 64 80 b ffc0133c <_restgpr_27_x>
ffc0d280 <rtems_libio_free>:
*/
void rtems_libio_free(
rtems_libio_t *iop
)
{
ffc0d280: 7c 2b 0b 78 mr r11,r1
ffc0d284: 94 21 ff f0 stwu r1,-16(r1)
ffc0d288: 7c 08 02 a6 mflr r0
ffc0d28c: 48 00 e0 c1 bl ffc1b34c <_savegpr_31>
ffc0d290: 7c 7f 1b 78 mr r31,r3
ffc0d294: 90 01 00 14 stw r0,20(r1)
rtems_libio_lock();
ffc0d298: 4b ff fe 69 bl ffc0d100 <rtems_libio_lock>
if (iop->sem)
ffc0d29c: 80 7f 00 30 lwz r3,48(r31)
ffc0d2a0: 2f 83 00 00 cmpwi cr7,r3,0
ffc0d2a4: 41 be 00 08 beq+ cr7,ffc0d2ac <rtems_libio_free+0x2c> <== NEVER TAKEN
rtems_semaphore_delete(iop->sem);
ffc0d2a8: 4b ff ad 45 bl ffc07fec <rtems_semaphore_delete>
iop->flags &= ~LIBIO_FLAGS_OPEN;
ffc0d2ac: 80 1f 00 18 lwz r0,24(r31)
iop->data1 = rtems_libio_iop_freelist;
ffc0d2b0: 3d 20 00 00 lis r9,0
rtems_libio_lock();
if (iop->sem)
rtems_semaphore_delete(iop->sem);
iop->flags &= ~LIBIO_FLAGS_OPEN;
ffc0d2b4: 54 00 06 2c rlwinm r0,r0,0,24,22
ffc0d2b8: 90 1f 00 18 stw r0,24(r31)
iop->data1 = rtems_libio_iop_freelist;
ffc0d2bc: 80 09 27 f4 lwz r0,10228(r9)
rtems_libio_iop_freelist = iop;
ffc0d2c0: 93 e9 27 f4 stw r31,10228(r9)
if (iop->sem)
rtems_semaphore_delete(iop->sem);
iop->flags &= ~LIBIO_FLAGS_OPEN;
iop->data1 = rtems_libio_iop_freelist;
ffc0d2c4: 90 1f 00 38 stw r0,56(r31)
rtems_libio_iop_freelist = iop;
rtems_libio_unlock();
}
ffc0d2c8: 80 01 00 14 lwz r0,20(r1)
ffc0d2cc: 83 e1 00 0c lwz r31,12(r1)
ffc0d2d0: 38 21 00 10 addi r1,r1,16
ffc0d2d4: 7c 08 03 a6 mtlr r0
iop->flags &= ~LIBIO_FLAGS_OPEN;
iop->data1 = rtems_libio_iop_freelist;
rtems_libio_iop_freelist = iop;
rtems_libio_unlock();
ffc0d2d8: 4b ff fe 58 b ffc0d130 <rtems_libio_unlock>
ffc04a8c <rtems_libio_init>:
*
* Called by BSP startup code to initialize the libio subsystem.
*/
void rtems_libio_init( void )
{
ffc04a8c: 7c 2b 0b 78 mr r11,r1
ffc04a90: 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)
ffc04a94: 3d 20 00 00 lis r9,0
*
* Called by BSP startup code to initialize the libio subsystem.
*/
void rtems_libio_init( void )
{
ffc04a98: 7c 08 02 a6 mflr r0
ffc04a9c: 48 01 68 b1 bl ffc1b34c <_savegpr_31>
rtems_status_code rc;
uint32_t i;
rtems_libio_t *iop;
if (rtems_libio_number_iops > 0)
ffc04aa0: 83 e9 27 3c lwz r31,10044(r9)
*
* Called by BSP startup code to initialize the libio subsystem.
*/
void rtems_libio_init( void )
{
ffc04aa4: 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)
ffc04aa8: 2f 9f 00 00 cmpwi cr7,r31,0
ffc04aac: 41 9e 00 64 beq- cr7,ffc04b10 <rtems_libio_init+0x84> <== NEVER TAKEN
{
rtems_libio_iops = (rtems_libio_t *) calloc(rtems_libio_number_iops,
ffc04ab0: 7f e3 fb 78 mr r3,r31
ffc04ab4: 38 80 00 40 li r4,64
ffc04ab8: 4b ff f9 8d bl ffc04444 <calloc>
ffc04abc: 3d 20 00 00 lis r9,0
sizeof(rtems_libio_t));
if (rtems_libio_iops == NULL)
ffc04ac0: 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,
ffc04ac4: 90 69 27 f0 stw r3,10224(r9)
sizeof(rtems_libio_t));
if (rtems_libio_iops == NULL)
ffc04ac8: 40 be 00 0c bne+ cr7,ffc04ad4 <rtems_libio_init+0x48>
rtems_fatal_error_occurred(RTEMS_NO_MEMORY);
ffc04acc: 38 60 00 1a li r3,26
ffc04ad0: 48 00 00 68 b ffc04b38 <rtems_libio_init+0xac>
iop = rtems_libio_iop_freelist = rtems_libio_iops;
ffc04ad4: 3d 20 00 00 lis r9,0
for (i = 0 ; (i + 1) < rtems_libio_number_iops ; i++, iop++)
ffc04ad8: 7f e9 03 a6 mtctr r31
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;
ffc04adc: 90 69 27 f4 stw r3,10228(r9)
for (i = 0 ; (i + 1) < rtems_libio_number_iops ; i++, iop++)
ffc04ae0: 39 60 00 00 li r11,0
ffc04ae4: 7c 69 1b 78 mr r9,r3
ffc04ae8: 48 00 00 0c b ffc04af4 <rtems_libio_init+0x68>
iop->data1 = iop + 1;
ffc04aec: 39 29 00 40 addi r9,r9,64
ffc04af0: 91 29 ff f8 stw r9,-8(r9)
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++)
ffc04af4: 39 6b 00 01 addi r11,r11,1
ffc04af8: 42 00 ff f4 bdnz+ ffc04aec <rtems_libio_init+0x60>
* rtems_libio_init
*
* Called by BSP startup code to initialize the libio subsystem.
*/
void rtems_libio_init( void )
ffc04afc: 55 6b 30 32 rlwinm r11,r11,6,0,25
rtems_fatal_error_occurred(RTEMS_NO_MEMORY);
iop = rtems_libio_iop_freelist = rtems_libio_iops;
for (i = 0 ; (i + 1) < rtems_libio_number_iops ; i++, iop++)
iop->data1 = iop + 1;
iop->data1 = NULL;
ffc04b00: 39 6b ff c0 addi r11,r11,-64
ffc04b04: 7c 63 5a 14 add r3,r3,r11
ffc04b08: 38 00 00 00 li r0,0
ffc04b0c: 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(
ffc04b10: 3c 60 4c 42 lis r3,19522
ffc04b14: 3c e0 00 00 lis r7,0
ffc04b18: 60 63 49 4f ori r3,r3,18767
ffc04b1c: 38 80 00 01 li r4,1
ffc04b20: 38 a0 00 54 li r5,84
ffc04b24: 38 c0 00 00 li r6,0
ffc04b28: 38 e7 27 f8 addi r7,r7,10232
ffc04b2c: 48 00 33 05 bl ffc07e30 <rtems_semaphore_create>
1,
RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY,
RTEMS_NO_PRIORITY,
&rtems_libio_semaphore
);
if ( rc != RTEMS_SUCCESSFUL )
ffc04b30: 2f 83 00 00 cmpwi cr7,r3,0
ffc04b34: 41 be 00 08 beq+ cr7,ffc04b3c <rtems_libio_init+0xb0> <== ALWAYS TAKEN
rtems_fatal_error_occurred( rc );
ffc04b38: 48 00 3d 45 bl ffc0887c <rtems_fatal_error_occurred>
/*
* Initialize the base file system infrastructure.
*/
if (rtems_fs_init_helper)
ffc04b3c: 3d 20 00 00 lis r9,0
ffc04b40: 80 09 27 40 lwz r0,10048(r9)
ffc04b44: 2f 80 00 00 cmpwi cr7,r0,0
ffc04b48: 41 9e 00 0c beq- cr7,ffc04b54 <rtems_libio_init+0xc8> <== NEVER TAKEN
(* rtems_fs_init_helper)();
ffc04b4c: 7c 09 03 a6 mtctr r0
ffc04b50: 4e 80 04 21 bctrl
}
ffc04b54: 39 61 00 10 addi r11,r1,16
ffc04b58: 4b ff b9 ec b ffc00544 <_restgpr_31_x>
ffc07fc4 <rtems_libio_set_private_env>:
rtems_status_code rtems_libio_set_private_env(void)
{
ffc07fc4: 94 21 ff b8 stwu r1,-72(r1)
ffc07fc8: 7c 08 02 a6 mflr r0
ffc07fcc: bf a1 00 3c stmw r29,60(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);
ffc07fd0: 3f e0 ff c2 lis r31,-62
ffc07fd4: 3b ff 32 36 addi r31,r31,12854
free(env);
}
}
rtems_status_code rtems_libio_set_private_env(void)
{
ffc07fd8: 90 01 00 4c stw r0,76(r1)
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_id task_id = rtems_task_self();
ffc07fdc: 48 00 32 c9 bl ffc0b2a4 <rtems_task_self>
ffc07fe0: 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);
ffc07fe4: 38 80 00 01 li r4,1
ffc07fe8: 7f e3 fb 78 mr r3,r31
ffc07fec: 38 a0 00 00 li r5,0
ffc07ff0: 38 c1 00 1c addi r6,r1,28
ffc07ff4: 38 e0 00 00 li r7,0
ffc07ff8: 4b ff ea 7d bl ffc06a74 <rtems_filesystem_evaluate_path>
error_1:
rtems_filesystem_freenode(&root_loc);
error_0:
return RTEMS_NO_MEMORY;
ffc07ffc: 38 00 00 1a li r0,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)
ffc08000: 2f 83 00 00 cmpwi cr7,r3,0
ffc08004: 40 be 00 e0 bne+ cr7,ffc080e4 <rtems_libio_set_private_env+0x120><== NEVER TAKEN
goto error_0;
rv = rtems_filesystem_evaluate_path("/", 1, 0, ¤t_loc, 0);
ffc08008: 7f e3 fb 78 mr r3,r31
ffc0800c: 38 80 00 01 li r4,1
ffc08010: 38 a0 00 00 li r5,0
ffc08014: 38 c1 00 08 addi r6,r1,8
ffc08018: 38 e0 00 00 li r7,0
ffc0801c: 4b ff ea 59 bl ffc06a74 <rtems_filesystem_evaluate_path>
if (rv != 0)
ffc08020: 2f 83 00 00 cmpwi cr7,r3,0
ffc08024: 40 9e 00 b4 bne- cr7,ffc080d8 <rtems_libio_set_private_env+0x114><== 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
ffc08028: 3d 20 00 00 lis r9,0
ffc0802c: 81 29 27 5c lwz r9,10076(r9)
/*
* Bharath: I'm not sure if the check can be reduced to
* if( rtems_current_user_env->task_id != task_id ) {
*/
if (
ffc08030: 3d 60 00 00 lis r11,0
ffc08034: 38 0b 2b 70 addi r0,r11,11120
ffc08038: 7f 89 00 00 cmpw cr7,r9,r0
ffc0803c: 41 9e 00 10 beq- cr7,ffc0804c <rtems_libio_set_private_env+0x88>
rtems_current_user_env == &rtems_global_user_env
|| rtems_current_user_env->task_id != task_id
ffc08040: 80 09 00 00 lwz r0,0(r9)
ffc08044: 7f 80 f0 00 cmpw cr7,r0,r30
ffc08048: 41 9e 00 38 beq- cr7,ffc08080 <rtems_libio_set_private_env+0xbc>
) {
new_env = malloc(sizeof(rtems_user_env_t));
ffc0804c: 38 60 00 48 li r3,72
ffc08050: 4b ff f3 ad bl ffc073fc <malloc>
if (new_env == NULL)
ffc08054: 7c 7f 1b 79 mr. r31,r3
ffc08058: 41 82 00 78 beq- ffc080d0 <rtems_libio_set_private_env+0x10c>
#ifdef HAVE_USERENV_REFCNT
new_env->refcnt = 1;
#endif
sc = rtems_task_variable_add(
ffc0805c: 3f a0 00 00 lis r29,0
ffc08060: 3c a0 ff c0 lis r5,-64
ffc08064: 38 60 00 00 li r3,0
ffc08068: 38 9d 27 5c addi r4,r29,10076
ffc0806c: 38 a5 7f 7c addi r5,r5,32636
ffc08070: 48 00 33 1d bl ffc0b38c <rtems_task_variable_add>
RTEMS_SELF,
(void*)&rtems_current_user_env,
(void(*)(void *))free_user_env
);
if (sc != RTEMS_SUCCESSFUL)
ffc08074: 2f 83 00 00 cmpwi cr7,r3,0
ffc08078: 40 9e 00 50 bne- cr7,ffc080c8 <rtems_libio_set_private_env+0x104>
goto error_3;
rtems_current_user_env = new_env;
ffc0807c: 93 fd 27 5c stw r31,10076(r29)
}
/* Inherit the global values */
*rtems_current_user_env = rtems_global_user_env;
ffc08080: 3d 20 00 00 lis r9,0
ffc08084: 83 e9 27 5c lwz r31,10076(r9)
ffc08088: 3c 80 00 00 lis r4,0
ffc0808c: 38 a0 00 48 li r5,72
ffc08090: 7f e3 fb 78 mr r3,r31
ffc08094: 38 84 2b 70 addi r4,r4,11120
ffc08098: 48 00 c2 b9 bl ffc14350 <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;
ffc0809c: 39 7f 00 18 addi r11,r31,24
ffc080a0: 38 81 00 1c addi r4,r1,28
}
/* Inherit the global values */
*rtems_current_user_env = rtems_global_user_env;
rtems_current_user_env->task_id = task_id;
ffc080a4: 93 df 00 00 stw r30,0(r31)
* 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;
rtems_filesystem_current = current_loc;
ffc080a8: 3b ff 00 04 addi r31,r31,4
* 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;
ffc080ac: 7c a4 a4 aa lswi r5,r4,20
ffc080b0: 7c ab a5 aa stswi r5,r11,20
rtems_filesystem_current = current_loc;
ffc080b4: 39 61 00 08 addi r11,r1,8
return RTEMS_SUCCESSFUL;
ffc080b8: 38 00 00 00 li r0,0
* 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;
rtems_filesystem_current = current_loc;
ffc080bc: 7c ab a4 aa lswi r5,r11,20
ffc080c0: 7c bf a5 aa stswi r5,r31,20
return RTEMS_SUCCESSFUL;
ffc080c4: 48 00 00 20 b ffc080e4 <rtems_libio_set_private_env+0x120>
error_3:
free(new_env);
ffc080c8: 7f e3 fb 78 mr r3,r31
ffc080cc: 4b ff eb c5 bl ffc06c90 <free>
error_2:
rtems_filesystem_freenode(¤t_loc);
ffc080d0: 38 61 00 08 addi r3,r1,8
ffc080d4: 4b ff eb 91 bl ffc06c64 <rtems_filesystem_freenode>
error_1:
rtems_filesystem_freenode(&root_loc);
ffc080d8: 38 61 00 1c addi r3,r1,28
ffc080dc: 4b ff eb 89 bl ffc06c64 <rtems_filesystem_freenode>
error_0:
return RTEMS_NO_MEMORY;
ffc080e0: 38 00 00 1a li r0,26
}
ffc080e4: 39 61 00 48 addi r11,r1,72
ffc080e8: 7c 03 03 78 mr r3,r0
ffc080ec: 4b ff a7 8c b ffc02878 <_restgpr_29_x>
ffc080f0 <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)
{
ffc080f0: 94 21 ff d8 stwu r1,-40(r1)
ffc080f4: 7c 08 02 a6 mflr r0
ffc080f8: bf 81 00 18 stmw r28,24(r1)
ffc080fc: 7c 7c 1b 78 mr r28,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 )
return RTEMS_SUCCESSFUL;
ffc08100: 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)
{
ffc08104: 90 01 00 2c stw r0,44(r1)
rtems_id current_task_id;
/*
* get current task id
*/
current_task_id = rtems_task_self();
ffc08108: 48 00 31 9d bl ffc0b2a4 <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 )
ffc0810c: 7f 9c 18 00 cmpw cr7,r28,r3
rtems_id current_task_id;
/*
* get current task id
*/
current_task_id = rtems_task_self();
ffc08110: 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 )
ffc08114: 41 9e 00 3c beq- cr7,ffc08150 <rtems_libio_share_private_env+0x60><== NEVER TAKEN
return RTEMS_SUCCESSFUL;
/*
* Try to get the requested user environment
*/
sc = rtems_task_variable_get(
ffc08118: 3f c0 00 00 lis r30,0
ffc0811c: 7f 83 e3 78 mr r3,r28
ffc08120: 38 9e 27 5c addi r4,r30,10076
ffc08124: 38 a1 00 08 addi r5,r1,8
ffc08128: 48 00 33 19 bl ffc0b440 <rtems_task_variable_get>
(void*)&shared_user_env );
/*
* If it was not successful, return the error code
*/
if (sc != RTEMS_SUCCESSFUL)
ffc0812c: 7c 7d 1b 79 mr. r29,r3
ffc08130: 40 82 00 20 bne- ffc08150 <rtems_libio_share_private_env+0x60>
* 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) {
ffc08134: 80 7e 27 5c lwz r3,10076(r30)
ffc08138: 80 03 00 00 lwz r0,0(r3)
ffc0813c: 7f 80 f8 00 cmpw cr7,r0,r31
ffc08140: 40 be 00 08 bne+ cr7,ffc08148 <rtems_libio_share_private_env+0x58>
rtems_user_env_t *tmp = rtems_current_user_env;
free_user_env( tmp );
ffc08144: 4b ff fe 39 bl ffc07f7c <free_user_env>
}
/* the current_user_env is the same pointer that remote env */
rtems_current_user_env = shared_user_env;
ffc08148: 80 01 00 08 lwz r0,8(r1)
ffc0814c: 90 1e 27 5c stw r0,10076(r30)
#ifdef HAVE_USERENV_REFCNT
rtems_current_user_env->refcnt++;
#endif
return RTEMS_SUCCESSFUL;
}
ffc08150: 39 61 00 28 addi r11,r1,40
ffc08154: 7f a3 eb 78 mr r3,r29
ffc08158: 4b ff a7 1c b ffc02874 <_restgpr_28_x>
ffc0d19c <rtems_libio_to_fcntl_flags>:
uint32_t flags
)
{
uint32_t fcntl_flags = 0;
if ( (flags & LIBIO_FLAGS_READ_WRITE) == LIBIO_FLAGS_READ_WRITE ) {
ffc0d19c: 54 69 07 7c rlwinm r9,r3,0,29,30
ffc0d1a0: 2f 89 00 06 cmpwi cr7,r9,6
fcntl_flags |= O_RDWR;
ffc0d1a4: 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 ) {
ffc0d1a8: 41 9e 00 14 beq- cr7,ffc0d1bc <rtems_libio_to_fcntl_flags+0x20>
fcntl_flags |= O_RDWR;
} else if ( (flags & LIBIO_FLAGS_READ) == LIBIO_FLAGS_READ) {
ffc0d1ac: 70 69 00 02 andi. r9,r3,2
fcntl_flags |= O_RDONLY;
ffc0d1b0: 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) {
ffc0d1b4: 40 82 00 08 bne- ffc0d1bc <rtems_libio_to_fcntl_flags+0x20><== ALWAYS TAKEN
)
{
uint32_t fcntl_flags = 0;
if ( (flags & LIBIO_FLAGS_READ_WRITE) == LIBIO_FLAGS_READ_WRITE ) {
fcntl_flags |= O_RDWR;
ffc0d1b8: 54 60 f7 fe rlwinm r0,r3,30,31,31 <== NOT EXECUTED
fcntl_flags |= O_RDONLY;
} else if ( (flags & LIBIO_FLAGS_WRITE) == LIBIO_FLAGS_WRITE) {
fcntl_flags |= O_WRONLY;
}
if ( (flags & LIBIO_FLAGS_NO_DELAY) == LIBIO_FLAGS_NO_DELAY ) {
ffc0d1bc: 70 69 00 01 andi. r9,r3,1
ffc0d1c0: 41 82 00 08 beq- ffc0d1c8 <rtems_libio_to_fcntl_flags+0x2c>
fcntl_flags |= O_NONBLOCK;
ffc0d1c4: 60 00 40 00 ori r0,r0,16384
}
if ( (flags & LIBIO_FLAGS_APPEND) == LIBIO_FLAGS_APPEND ) {
ffc0d1c8: 70 69 02 00 andi. r9,r3,512
ffc0d1cc: 41 82 00 08 beq- ffc0d1d4 <rtems_libio_to_fcntl_flags+0x38>
fcntl_flags |= O_APPEND;
ffc0d1d0: 60 00 00 08 ori r0,r0,8
}
if ( (flags & LIBIO_FLAGS_CREATE) == LIBIO_FLAGS_CREATE ) {
ffc0d1d4: 70 69 04 00 andi. r9,r3,1024
ffc0d1d8: 41 82 00 08 beq- ffc0d1e0 <rtems_libio_to_fcntl_flags+0x44>
fcntl_flags |= O_CREAT;
ffc0d1dc: 60 00 02 00 ori r0,r0,512
}
return fcntl_flags;
}
ffc0d1e0: 7c 03 03 78 mr r3,r0
ffc0d1e4: 4e 80 00 20 blr
ffc07dd8 <rtems_malloc_statistics_at_free>:
* size and thus we skip updating the statistics.
*/
static void rtems_malloc_statistics_at_free(
void *pointer
)
{
ffc07dd8: 94 21 ff e8 stwu r1,-24(r1)
uintptr_t size;
if (_Protected_heap_Get_block_size(RTEMS_Malloc_Heap, pointer, &size) ) {
ffc07ddc: 3d 20 00 00 lis r9,0
* size and thus we skip updating the statistics.
*/
static void rtems_malloc_statistics_at_free(
void *pointer
)
{
ffc07de0: 7c 08 02 a6 mflr r0
ffc07de4: 7c 64 1b 78 mr r4,r3
uintptr_t size;
if (_Protected_heap_Get_block_size(RTEMS_Malloc_Heap, pointer, &size) ) {
ffc07de8: 80 69 27 90 lwz r3,10128(r9)
ffc07dec: 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
)
{
ffc07df0: 90 01 00 1c stw r0,28(r1)
uintptr_t size;
if (_Protected_heap_Get_block_size(RTEMS_Malloc_Heap, pointer, &size) ) {
ffc07df4: 48 00 64 31 bl ffc0e224 <_Protected_heap_Get_block_size>
ffc07df8: 2f 83 00 00 cmpwi cr7,r3,0
ffc07dfc: 41 9e 00 2c beq- cr7,ffc07e28 <rtems_malloc_statistics_at_free+0x50><== NEVER TAKEN
MSBUMP(lifetime_freed, size);
ffc07e00: 3c e0 00 00 lis r7,0
ffc07e04: 81 61 00 08 lwz r11,8(r1)
ffc07e08: 38 e7 34 68 addi r7,r7,13416
ffc07e0c: 81 07 00 28 lwz r8,40(r7)
ffc07e10: 39 40 00 00 li r10,0
ffc07e14: 81 27 00 2c lwz r9,44(r7)
ffc07e18: 7d 6b 48 14 addc r11,r11,r9
ffc07e1c: 7d 4a 41 14 adde r10,r10,r8
ffc07e20: 91 47 00 28 stw r10,40(r7)
ffc07e24: 91 67 00 2c stw r11,44(r7)
}
}
ffc07e28: 80 01 00 1c lwz r0,28(r1)
ffc07e2c: 38 21 00 18 addi r1,r1,24
ffc07e30: 7c 08 03 a6 mtlr r0
ffc07e34: 4e 80 00 20 blr
ffc07e38 <rtems_malloc_statistics_at_malloc>:
{
uintptr_t actual_size = 0;
uint32_t current_depth;
rtems_malloc_statistics_t *s = &rtems_malloc_statistics;
if ( !pointer )
ffc07e38: 7c 64 1b 79 mr. r4,r3
}
static void rtems_malloc_statistics_at_malloc(
void *pointer
)
{
ffc07e3c: 94 21 ff e8 stwu r1,-24(r1)
ffc07e40: 7c 08 02 a6 mflr r0
ffc07e44: 90 01 00 1c stw r0,28(r1)
uintptr_t actual_size = 0;
ffc07e48: 38 00 00 00 li r0,0
ffc07e4c: 90 01 00 08 stw r0,8(r1)
uint32_t current_depth;
rtems_malloc_statistics_t *s = &rtems_malloc_statistics;
if ( !pointer )
ffc07e50: 41 82 00 54 beq- ffc07ea4 <rtems_malloc_statistics_at_malloc+0x6c><== NEVER TAKEN
return;
_Protected_heap_Get_block_size(RTEMS_Malloc_Heap, pointer, &actual_size);
ffc07e54: 3d 20 00 00 lis r9,0
ffc07e58: 80 69 27 90 lwz r3,10128(r9)
ffc07e5c: 38 a1 00 08 addi r5,r1,8
ffc07e60: 48 00 63 c5 bl ffc0e224 <_Protected_heap_Get_block_size>
MSBUMP(lifetime_allocated, actual_size);
ffc07e64: 3c e0 00 00 lis r7,0
ffc07e68: 38 e7 34 68 addi r7,r7,13416
ffc07e6c: 81 61 00 08 lwz r11,8(r1)
ffc07e70: 81 27 00 24 lwz r9,36(r7)
ffc07e74: 39 40 00 00 li r10,0
ffc07e78: 81 07 00 20 lwz r8,32(r7)
current_depth = (uint32_t) (s->lifetime_allocated - s->lifetime_freed);
ffc07e7c: 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);
ffc07e80: 7d 6b 48 14 addc r11,r11,r9
ffc07e84: 7d 4a 41 14 adde r10,r10,r8
current_depth = (uint32_t) (s->lifetime_allocated - s->lifetime_freed);
if (current_depth > s->max_depth)
ffc07e88: 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);
ffc07e8c: 91 47 00 20 stw r10,32(r7)
current_depth = (uint32_t) (s->lifetime_allocated - s->lifetime_freed);
ffc07e90: 7c 00 58 50 subf r0,r0,r11
if (current_depth > s->max_depth)
ffc07e94: 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);
ffc07e98: 91 67 00 24 stw r11,36(r7)
current_depth = (uint32_t) (s->lifetime_allocated - s->lifetime_freed);
if (current_depth > s->max_depth)
ffc07e9c: 40 9d 00 08 ble- cr7,ffc07ea4 <rtems_malloc_statistics_at_malloc+0x6c>
s->max_depth = current_depth;
ffc07ea0: 90 07 00 18 stw r0,24(r7)
}
ffc07ea4: 80 01 00 1c lwz r0,28(r1)
ffc07ea8: 38 21 00 18 addi r1,r1,24
ffc07eac: 7c 08 03 a6 mtlr r0
ffc07eb0: 4e 80 00 20 blr
ffc10e38 <rtems_memalign>:
int rtems_memalign(
void **pointer,
size_t alignment,
size_t size
)
{
ffc10e38: 94 21 ff e8 stwu r1,-24(r1)
ffc10e3c: 7c 08 02 a6 mflr r0
ffc10e40: bf 81 00 08 stmw r28,8(r1)
void *return_this;
/*
* Parameter error checks
*/
if ( !pointer )
ffc10e44: 7c 7f 1b 79 mr. r31,r3
int rtems_memalign(
void **pointer,
size_t alignment,
size_t size
)
{
ffc10e48: 7c 9e 23 78 mr r30,r4
ffc10e4c: 90 01 00 1c stw r0,28(r1)
ffc10e50: 7c bc 2b 78 mr r28,r5
/*
* Parameter error checks
*/
if ( !pointer )
return EINVAL;
ffc10e54: 3b a0 00 16 li r29,22
void *return_this;
/*
* Parameter error checks
*/
if ( !pointer )
ffc10e58: 41 82 00 78 beq- ffc10ed0 <rtems_memalign+0x98>
return EINVAL;
*pointer = NULL;
ffc10e5c: 38 00 00 00 li r0,0
/*
* Do not attempt to allocate memory if not in correct system state.
*/
if ( _System_state_Is_up(_System_state_Get()) &&
ffc10e60: 3d 20 00 00 lis r9,0
* Parameter error checks
*/
if ( !pointer )
return EINVAL;
*pointer = NULL;
ffc10e64: 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()) &&
ffc10e68: 80 09 28 40 lwz r0,10304(r9)
ffc10e6c: 2f 80 00 03 cmpwi cr7,r0,3
ffc10e70: 40 be 00 10 bne+ cr7,ffc10e80 <rtems_memalign+0x48> <== NEVER TAKEN
!malloc_is_system_state_OK() )
ffc10e74: 4b ff 45 fd bl ffc05470 <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()) &&
ffc10e78: 2f 83 00 00 cmpwi cr7,r3,0
ffc10e7c: 41 be 00 54 beq+ cr7,ffc10ed0 <rtems_memalign+0x98> <== NEVER TAKEN
return EINVAL;
/*
* If some free's have been deferred, then do them now.
*/
malloc_deferred_frees_process();
ffc10e80: 4b ff 46 39 bl ffc054b8 <malloc_deferred_frees_process>
Heap_Control *heap,
uintptr_t size,
uintptr_t alignment
)
{
return
ffc10e84: 3d 20 00 00 lis r9,0
ffc10e88: 80 69 27 2c lwz r3,10028(r9)
ffc10e8c: 7f c5 f3 78 mr r5,r30
ffc10e90: 7f 84 e3 78 mr r4,r28
ffc10e94: 38 c0 00 00 li r6,0
ffc10e98: 4b ff 9b ed bl ffc0aa84 <_Protected_heap_Allocate_aligned_with_boundary>
RTEMS_Malloc_Heap,
size,
alignment
);
if ( !return_this )
return ENOMEM;
ffc10e9c: 3b a0 00 0c li r29,12
return_this = _Protected_heap_Allocate_aligned(
RTEMS_Malloc_Heap,
size,
alignment
);
if ( !return_this )
ffc10ea0: 7c 7e 1b 79 mr. r30,r3
ffc10ea4: 41 82 00 2c beq- ffc10ed0 <rtems_memalign+0x98>
return ENOMEM;
/*
* If configured, update the more involved statistics
*/
if ( rtems_malloc_statistics_helpers )
ffc10ea8: 3d 20 00 00 lis r9,0
ffc10eac: 81 29 27 ac lwz r9,10156(r9)
ffc10eb0: 2f 89 00 00 cmpwi cr7,r9,0
ffc10eb4: 41 9e 00 14 beq- cr7,ffc10ec8 <rtems_memalign+0x90>
(*rtems_malloc_statistics_helpers->at_malloc)(pointer);
ffc10eb8: 80 09 00 04 lwz r0,4(r9)
ffc10ebc: 7f e3 fb 78 mr r3,r31
ffc10ec0: 7c 09 03 a6 mtctr r0
ffc10ec4: 4e 80 04 21 bctrl
*pointer = return_this;
ffc10ec8: 93 df 00 00 stw r30,0(r31)
return 0;
ffc10ecc: 3b a0 00 00 li r29,0
}
ffc10ed0: 39 61 00 18 addi r11,r1,24
ffc10ed4: 7f a3 eb 78 mr r3,r29
ffc10ed8: 48 00 86 34 b ffc1950c <_restgpr_28_x>
ffc0f4c8 <rtems_mkdir>:
return (retval);
}
int
rtems_mkdir(const char *path, mode_t mode)
{
ffc0f4c8: 94 21 ff 88 stwu r1,-120(r1)
ffc0f4cc: 7c 08 02 a6 mflr r0
ffc0f4d0: bf 01 00 58 stmw r24,88(r1)
ffc0f4d4: 7c 98 23 78 mr r24,r4
ffc0f4d8: 90 01 00 7c stw r0,124(r1)
int success = 0;
char *dup_path = strdup(path);
ffc0f4dc: 48 00 3f 25 bl ffc13400 <strdup>
if (dup_path != NULL) {
ffc0f4e0: 7c 7c 1b 79 mr. r28,r3
success = build(dup_path, mode);
free(dup_path);
}
return success != 0 ? 0 : -1;
ffc0f4e4: 38 00 ff ff li r0,-1
rtems_mkdir(const char *path, mode_t mode)
{
int success = 0;
char *dup_path = strdup(path);
if (dup_path != NULL) {
ffc0f4e8: 41 82 01 8c beq- ffc0f674 <rtems_mkdir+0x1ac> <== NEVER TAKEN
char *p;
p = path;
oumask = 0;
retval = 1;
if (p[0] == '/') /* Skip leading '/'. */
ffc0f4ec: 88 1c 00 00 lbz r0,0(r28)
ffc0f4f0: 3b c0 00 01 li r30,1
ffc0f4f4: 3b 60 00 00 li r27,0
++p;
ffc0f4f8: 68 1d 00 2f xori r29,r0,47
ffc0f4fc: 23 bd 00 00 subfic r29,r29,0
ffc0f500: 7f bc 01 94 addze r29,r28
for (first = 1, last = 0; !last ; ++p) {
if (p[0] == '\0')
last = 1;
else if (p[0] != '/')
continue;
*p = '\0';
ffc0f504: 3b 20 00 00 li r25,0
char *p;
p = path;
oumask = 0;
retval = 1;
if (p[0] == '/') /* Skip leading '/'. */
ffc0f508: 38 00 00 01 li r0,1
retval = 0;
break;
}
}
if (!last)
*p = '/';
ffc0f50c: 3b 40 00 2f li r26,47
oumask = 0;
retval = 1;
if (p[0] == '/') /* Skip leading '/'. */
++p;
for (first = 1, last = 0; !last ; ++p) {
if (p[0] == '\0')
ffc0f510: 89 7d 00 00 lbz r11,0(r29)
last = 1;
ffc0f514: 39 20 00 01 li r9,1
oumask = 0;
retval = 1;
if (p[0] == '/') /* Skip leading '/'. */
++p;
for (first = 1, last = 0; !last ; ++p) {
if (p[0] == '\0')
ffc0f518: 2f 8b 00 00 cmpwi cr7,r11,0
ffc0f51c: 41 9e 00 10 beq- cr7,ffc0f52c <rtems_mkdir+0x64>
last = 1;
else if (p[0] != '/')
ffc0f520: 2f 8b 00 2f cmpwi cr7,r11,47
ffc0f524: 39 20 00 00 li r9,0
ffc0f528: 40 be 01 08 bne+ cr7,ffc0f630 <rtems_mkdir+0x168>
continue;
*p = '\0';
if (!last && p[1] == '\0')
ffc0f52c: 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';
ffc0f530: 9b 3d 00 00 stb r25,0(r29)
if (!last && p[1] == '\0')
ffc0f534: 3b e0 00 01 li r31,1
ffc0f538: 40 9e 00 10 bne- cr7,ffc0f548 <rtems_mkdir+0x80>
ffc0f53c: 8b fd 00 01 lbz r31,1(r29)
ffc0f540: 7f ff 00 34 cntlzw r31,r31
ffc0f544: 57 ff d9 7e rlwinm r31,r31,27,5,31
last = 1;
if (first) {
ffc0f548: 2f 80 00 00 cmpwi cr7,r0,0
ffc0f54c: 41 be 00 18 beq+ cr7,ffc0f564 <rtems_mkdir+0x9c>
* mkdir [-m mode] dir
*
* We change the user's umask and then restore it,
* instead of doing chmod's.
*/
oumask = umask(0);
ffc0f550: 38 60 00 00 li r3,0
ffc0f554: 48 00 01 d1 bl ffc0f724 <umask>
ffc0f558: 7c 7b 1b 78 mr r27,r3
numask = oumask & ~(S_IWUSR | S_IXUSR);
(void)umask(numask);
ffc0f55c: 54 63 06 ae rlwinm r3,r3,0,26,23
ffc0f560: 48 00 01 c5 bl ffc0f724 <umask>
first = 0;
}
if (last)
ffc0f564: 2f 9f 00 00 cmpwi cr7,r31,0
(void)umask(oumask);
if (mkdir(path, last ? omode : S_IRWXU | S_IRWXG | S_IRWXO) < 0) {
ffc0f568: 38 80 01 ff li r4,511
oumask = umask(0);
numask = oumask & ~(S_IWUSR | S_IXUSR);
(void)umask(numask);
first = 0;
}
if (last)
ffc0f56c: 41 be 00 10 beq+ cr7,ffc0f57c <rtems_mkdir+0xb4>
(void)umask(oumask);
ffc0f570: 7f 63 db 78 mr r3,r27
ffc0f574: 48 00 01 b1 bl ffc0f724 <umask>
if (mkdir(path, last ? omode : S_IRWXU | S_IRWXG | S_IRWXO) < 0) {
ffc0f578: 7f 04 c3 78 mr r4,r24
ffc0f57c: 7f 83 e3 78 mr r3,r28
ffc0f580: 4b ff 69 c5 bl ffc05f44 <mkdir>
ffc0f584: 2f 83 00 00 cmpwi cr7,r3,0
ffc0f588: 40 bc 00 80 bge+ cr7,ffc0f608 <rtems_mkdir+0x140>
if (errno == EEXIST || errno == EISDIR) {
ffc0f58c: 48 00 2c 09 bl ffc12194 <__errno>
ffc0f590: 80 03 00 00 lwz r0,0(r3)
ffc0f594: 2f 80 00 11 cmpwi cr7,r0,17
ffc0f598: 41 9e 00 14 beq- cr7,ffc0f5ac <rtems_mkdir+0xe4>
ffc0f59c: 48 00 2b f9 bl ffc12194 <__errno>
ffc0f5a0: 80 03 00 00 lwz r0,0(r3)
ffc0f5a4: 2f 80 00 15 cmpwi cr7,r0,21
ffc0f5a8: 40 9e 00 9c bne- cr7,ffc0f644 <rtems_mkdir+0x17c> <== ALWAYS TAKEN
if (stat(path, &sb) < 0) {
ffc0f5ac: 7f 83 e3 78 mr r3,r28
ffc0f5b0: 38 81 00 08 addi r4,r1,8
ffc0f5b4: 48 00 00 cd bl ffc0f680 <stat>
ffc0f5b8: 2f 83 00 00 cmpwi cr7,r3,0
ffc0f5bc: 41 9c 00 88 blt- cr7,ffc0f644 <rtems_mkdir+0x17c> <== NEVER TAKEN
retval = 0;
break;
} else if (!S_ISDIR(sb.st_mode)) {
ffc0f5c0: 80 01 00 14 lwz r0,20(r1)
ffc0f5c4: 2f 9f 00 00 cmpwi cr7,r31,0
ffc0f5c8: 54 00 04 26 rlwinm r0,r0,0,16,19
ffc0f5cc: 2f 00 40 00 cmpwi cr6,r0,16384
ffc0f5d0: 41 ba 00 30 beq+ cr6,ffc0f600 <rtems_mkdir+0x138>
if (last)
ffc0f5d4: 41 9e 00 1c beq- cr7,ffc0f5f0 <rtems_mkdir+0x128>
errno = EEXIST;
ffc0f5d8: 48 00 2b bd bl ffc12194 <__errno>
ffc0f5dc: 38 00 00 11 li r0,17
ffc0f5e0: 90 03 00 00 stw r0,0(r3)
else
errno = ENOTDIR;
retval = 0;
ffc0f5e4: 3b c0 00 00 li r30,0
if (stat(path, &sb) < 0) {
retval = 0;
break;
} else if (!S_ISDIR(sb.st_mode)) {
if (last)
errno = EEXIST;
ffc0f5e8: 3b e0 00 01 li r31,1
ffc0f5ec: 48 00 00 5c b ffc0f648 <rtems_mkdir+0x180>
else
errno = ENOTDIR;
ffc0f5f0: 48 00 2b a5 bl ffc12194 <__errno>
ffc0f5f4: 38 00 00 14 li r0,20
ffc0f5f8: 90 03 00 00 stw r0,0(r3)
ffc0f5fc: 48 00 00 48 b ffc0f644 <rtems_mkdir+0x17c>
retval = 0;
break;
}
if (last)
ffc0f600: 40 9e 00 24 bne- cr7,ffc0f624 <rtems_mkdir+0x15c>
ffc0f604: 48 00 00 14 b ffc0f618 <rtems_mkdir+0x150>
} else {
retval = 0;
break;
}
}
if (!last)
ffc0f608: 2f 9f 00 00 cmpwi cr7,r31,0
ffc0f60c: 39 20 00 01 li r9,1
ffc0f610: 38 00 00 00 li r0,0
ffc0f614: 40 9e 00 1c bne- cr7,ffc0f630 <rtems_mkdir+0x168>
*p = '/';
ffc0f618: 9b 5d 00 00 stb r26,0(r29)
ffc0f61c: 39 20 00 00 li r9,0
ffc0f620: 48 00 00 0c b ffc0f62c <rtems_mkdir+0x164>
errno = ENOTDIR;
retval = 0;
break;
}
if (last)
retval = 2;
ffc0f624: 3b c0 00 02 li r30,2
else
errno = ENOTDIR;
retval = 0;
break;
}
if (last)
ffc0f628: 39 20 00 01 li r9,1
ffc0f62c: 38 00 00 00 li r0,0
p = path;
oumask = 0;
retval = 1;
if (p[0] == '/') /* Skip leading '/'. */
++p;
for (first = 1, last = 0; !last ; ++p) {
ffc0f630: 2f 89 00 00 cmpwi cr7,r9,0
ffc0f634: 3b bd 00 01 addi r29,r29,1
ffc0f638: 41 9e fe d8 beq+ cr7,ffc0f510 <rtems_mkdir+0x48>
ffc0f63c: 3b e0 00 01 li r31,1
ffc0f640: 48 00 00 0c b ffc0f64c <rtems_mkdir+0x184>
if (last)
(void)umask(oumask);
if (mkdir(path, last ? omode : S_IRWXU | S_IRWXG | S_IRWXO) < 0) {
if (errno == EEXIST || errno == EISDIR) {
if (stat(path, &sb) < 0) {
retval = 0;
ffc0f644: 3b c0 00 00 li r30,0
}
if (last)
(void)umask(oumask);
if (mkdir(path, last ? omode : S_IRWXU | S_IRWXG | S_IRWXO) < 0) {
if (errno == EEXIST || errno == EISDIR) {
if (stat(path, &sb) < 0) {
ffc0f648: 38 00 00 00 li r0,0
}
}
if (!last)
*p = '/';
}
if (!first && !last)
ffc0f64c: 7f e9 03 79 or. r9,r31,r0
ffc0f650: 40 a2 00 0c bne+ ffc0f65c <rtems_mkdir+0x194>
(void)umask(oumask);
ffc0f654: 7f 63 db 78 mr r3,r27
ffc0f658: 48 00 00 cd bl ffc0f724 <umask>
int success = 0;
char *dup_path = strdup(path);
if (dup_path != NULL) {
success = build(dup_path, mode);
free(dup_path);
ffc0f65c: 7f 83 e3 78 mr r3,r28
ffc0f660: 4b ff 61 2d bl ffc0578c <free>
}
return success != 0 ? 0 : -1;
ffc0f664: 2f 9e 00 00 cmpwi cr7,r30,0
ffc0f668: 38 00 00 00 li r0,0
ffc0f66c: 40 be 00 08 bne+ cr7,ffc0f674 <rtems_mkdir+0x1ac>
ffc0f670: 38 00 ff ff li r0,-1
}
ffc0f674: 39 61 00 78 addi r11,r1,120
ffc0f678: 7c 03 03 78 mr r3,r0
ffc0f67c: 48 00 e3 44 b ffc1d9c0 <_restgpr_24_x>
ffc0471c <rtems_panic>:
void rtems_panic(
const char *printf_format,
...
)
{
ffc0471c: 94 21 ff 88 stwu r1,-120(r1)
ffc04720: 7c 08 02 a6 mflr r0
ffc04724: 90 81 00 1c stw r4,28(r1)
ffc04728: 90 01 00 7c stw r0,124(r1)
ffc0472c: 90 a1 00 20 stw r5,32(r1)
ffc04730: 90 c1 00 24 stw r6,36(r1)
ffc04734: 90 e1 00 28 stw r7,40(r1)
ffc04738: 91 01 00 2c stw r8,44(r1)
ffc0473c: 91 21 00 30 stw r9,48(r1)
ffc04740: 91 41 00 34 stw r10,52(r1)
ffc04744: 40 86 00 24 bne- cr1,ffc04768 <rtems_panic+0x4c> <== ALWAYS TAKEN
ffc04748: d8 21 00 38 stfd f1,56(r1) <== NOT EXECUTED
ffc0474c: d8 41 00 40 stfd f2,64(r1) <== NOT EXECUTED
ffc04750: d8 61 00 48 stfd f3,72(r1) <== NOT EXECUTED
ffc04754: d8 81 00 50 stfd f4,80(r1) <== NOT EXECUTED
ffc04758: d8 a1 00 58 stfd f5,88(r1) <== NOT EXECUTED
ffc0475c: d8 c1 00 60 stfd f6,96(r1) <== NOT EXECUTED
ffc04760: d8 e1 00 68 stfd f7,104(r1) <== NOT EXECUTED
ffc04764: d9 01 00 70 stfd f8,112(r1) <== NOT EXECUTED
va_list arglist;
va_start(arglist, printf_format);
ffc04768: 38 00 00 01 li r0,1
ffc0476c: 98 01 00 08 stb r0,8(r1)
ffc04770: 38 00 00 00 li r0,0
void rtems_panic(
const char *printf_format,
...
)
{
ffc04774: 7c 64 1b 78 mr r4,r3
va_list arglist;
va_start(arglist, printf_format);
ffc04778: 98 01 00 09 stb r0,9(r1)
ffc0477c: 38 01 00 80 addi r0,r1,128
(void) rtems_verror(RTEMS_ERROR_PANIC, printf_format, arglist);
ffc04780: 38 a1 00 08 addi r5,r1,8
...
)
{
va_list arglist;
va_start(arglist, printf_format);
ffc04784: 90 01 00 0c stw r0,12(r1)
(void) rtems_verror(RTEMS_ERROR_PANIC, printf_format, arglist);
ffc04788: 3c 60 20 00 lis r3,8192
...
)
{
va_list arglist;
va_start(arglist, printf_format);
ffc0478c: 38 01 00 18 addi r0,r1,24
ffc04790: 90 01 00 10 stw r0,16(r1)
(void) rtems_verror(RTEMS_ERROR_PANIC, printf_format, arglist);
ffc04794: 4b ff fd 39 bl ffc044cc <rtems_verror>
va_end(arglist);
rtems_error(0, "fatal error, exiting");
ffc04798: 3c 80 ff c2 lis r4,-62
ffc0479c: 38 84 d4 c7 addi r4,r4,-11065
ffc047a0: 38 60 00 00 li r3,0
ffc047a4: 4c c6 31 82 crclr 4*cr1+eq
ffc047a8: 4b ff fe a5 bl ffc0464c <rtems_error>
_exit(errno);
ffc047ac: 48 00 c4 09 bl ffc10bb4 <__errno>
ffc047b0: 80 63 00 00 lwz r3,0(r3)
ffc047b4: 48 00 0b 4d bl ffc05300 <_exit>
ffc16528 <rtems_partition_create>:
uint32_t length,
uint32_t buffer_size,
rtems_attribute attribute_set,
rtems_id *id
)
{
ffc16528: 94 21 ff d0 stwu r1,-48(r1)
ffc1652c: 7c 08 02 a6 mflr r0
ffc16530: bf 21 00 14 stmw r25,20(r1)
register Partition_Control *the_partition;
if ( !rtems_is_name_valid( name ) )
ffc16534: 7c 7b 1b 79 mr. r27,r3
uint32_t length,
uint32_t buffer_size,
rtems_attribute attribute_set,
rtems_id *id
)
{
ffc16538: 7c bf 2b 78 mr r31,r5
ffc1653c: 90 01 00 34 stw r0,52(r1)
ffc16540: 7c fa 3b 78 mr r26,r7
ffc16544: 7d 1d 43 78 mr r29,r8
register Partition_Control *the_partition;
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
ffc16548: 38 00 00 03 li r0,3
rtems_id *id
)
{
register Partition_Control *the_partition;
if ( !rtems_is_name_valid( name ) )
ffc1654c: 41 a2 00 d0 beq+ ffc1661c <rtems_partition_create+0xf4>
return RTEMS_INVALID_NAME;
if ( !starting_address )
ffc16550: 2f 84 00 00 cmpwi cr7,r4,0
return RTEMS_INVALID_ADDRESS;
ffc16554: 38 00 00 09 li r0,9
register Partition_Control *the_partition;
if ( !rtems_is_name_valid( name ) )
return RTEMS_INVALID_NAME;
if ( !starting_address )
ffc16558: 41 9e 00 c4 beq- cr7,ffc1661c <rtems_partition_create+0xf4>
return RTEMS_INVALID_ADDRESS;
if ( !id )
ffc1655c: 2f 88 00 00 cmpwi cr7,r8,0
ffc16560: 41 9e 00 bc beq- cr7,ffc1661c <rtems_partition_create+0xf4><== NEVER TAKEN
return RTEMS_INVALID_ADDRESS;
if ( length == 0 || buffer_size == 0 || length < buffer_size ||
ffc16564: 2f 85 00 00 cmpwi cr7,r5,0
!_Partition_Is_buffer_size_aligned( buffer_size ) )
return RTEMS_INVALID_SIZE;
ffc16568: 38 00 00 08 li r0,8
return RTEMS_INVALID_ADDRESS;
if ( !id )
return RTEMS_INVALID_ADDRESS;
if ( length == 0 || buffer_size == 0 || length < buffer_size ||
ffc1656c: 41 be 00 b0 beq+ cr7,ffc1661c <rtems_partition_create+0xf4>
ffc16570: 2f 86 00 00 cmpwi cr7,r6,0
ffc16574: 41 be 00 a8 beq+ cr7,ffc1661c <rtems_partition_create+0xf4>
ffc16578: 7f 85 30 40 cmplw cr7,r5,r6
ffc1657c: 41 bc 00 a0 blt+ cr7,ffc1661c <rtems_partition_create+0xf4>
ffc16580: 70 c9 00 07 andi. r9,r6,7
ffc16584: 40 a2 00 98 bne+ ffc1661c <rtems_partition_create+0xf4>
!_Partition_Is_buffer_size_aligned( buffer_size ) )
return RTEMS_INVALID_SIZE;
if ( !_Addresses_Is_aligned( starting_address ) )
ffc16588: 70 99 00 07 andi. r25,r4,7
return RTEMS_INVALID_ADDRESS;
ffc1658c: 38 00 00 09 li r0,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 ) )
ffc16590: 40 a2 00 8c bne+ ffc1661c <rtems_partition_create+0xf4>
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
_Thread_Dispatch_disable_level++;
ffc16594: 3d 20 00 00 lis r9,0
ffc16598: 81 69 28 e0 lwz r11,10464(r9)
ffc1659c: 38 0b 00 01 addi r0,r11,1
ffc165a0: 90 09 28 e0 stw r0,10464(r9)
return _Thread_Dispatch_disable_level;
ffc165a4: 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 );
ffc165a8: 3f 80 00 00 lis r28,0
ffc165ac: 90 81 00 08 stw r4,8(r1)
ffc165b0: 3b 9c 6f 20 addi r28,r28,28448
ffc165b4: 7f 83 e3 78 mr r3,r28
ffc165b8: 90 c1 00 0c stw r6,12(r1)
ffc165bc: 48 00 4f 3d bl ffc1b4f8 <_Objects_Allocate>
_Thread_Disable_dispatch(); /* prevents deletion */
the_partition = _Partition_Allocate();
if ( !the_partition ) {
ffc165c0: 7c 7e 1b 79 mr. r30,r3
ffc165c4: 80 81 00 08 lwz r4,8(r1)
ffc165c8: 80 c1 00 0c lwz r6,12(r1)
ffc165cc: 40 a2 00 10 bne+ ffc165dc <rtems_partition_create+0xb4>
_Thread_Enable_dispatch();
ffc165d0: 48 00 63 55 bl ffc1c924 <_Thread_Enable_dispatch>
return RTEMS_TOO_MANY;
ffc165d4: 38 00 00 05 li r0,5
ffc165d8: 48 00 00 44 b ffc1661c <rtems_partition_create+0xf4>
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,
ffc165dc: 7c bf 33 96 divwu r5,r31,r6
_Thread_Enable_dispatch();
return RTEMS_TOO_MANY;
}
#endif
the_partition->starting_address = starting_address;
ffc165e0: 90 9e 00 10 stw r4,16(r30)
the_partition->length = length;
the_partition->buffer_size = buffer_size;
ffc165e4: 90 de 00 18 stw r6,24(r30)
return RTEMS_TOO_MANY;
}
#endif
the_partition->starting_address = starting_address;
the_partition->length = length;
ffc165e8: 93 fe 00 14 stw r31,20(r30)
the_partition->buffer_size = buffer_size;
the_partition->attribute_set = attribute_set;
ffc165ec: 93 5e 00 1c stw r26,28(r30)
the_partition->number_of_used_blocks = 0;
ffc165f0: 93 3e 00 20 stw r25,32(r30)
_Chain_Initialize( &the_partition->Memory, starting_address,
ffc165f4: 38 7e 00 24 addi r3,r30,36
ffc165f8: 48 00 35 c1 bl ffc19bb8 <_Chain_Initialize>
Objects_Name name
)
{
_Objects_Set_local_object(
information,
_Objects_Get_index( the_object->id ),
ffc165fc: 80 1e 00 08 lwz r0,8(r30)
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
ffc16600: 81 7c 00 1c lwz r11,28(r28)
ffc16604: 54 09 13 ba rlwinm r9,r0,2,14,29
ffc16608: 7f cb 49 2e stwx r30,r11,r9
information,
_Objects_Get_index( the_object->id ),
the_object
);
the_object->name = name;
ffc1660c: 93 7e 00 0c stw r27,12(r30)
&_Partition_Information,
&the_partition->Object,
(Objects_Name) name
);
*id = the_partition->Object.id;
ffc16610: 90 1d 00 00 stw r0,0(r29)
name,
0 /* Not used */
);
#endif
_Thread_Enable_dispatch();
ffc16614: 48 00 63 11 bl ffc1c924 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
ffc16618: 38 00 00 00 li r0,0
}
ffc1661c: 39 61 00 30 addi r11,r1,48
ffc16620: 7c 03 03 78 mr r3,r0
ffc16624: 4b ff 7b 64 b ffc0e188 <_restgpr_25_x>
ffc16774 <rtems_partition_return_buffer>:
rtems_status_code rtems_partition_return_buffer(
rtems_id id,
void *buffer
)
{
ffc16774: 94 21 ff e0 stwu r1,-32(r1)
ffc16778: 7c 08 02 a6 mflr r0
ffc1677c: 90 01 00 24 stw r0,36(r1)
ffc16780: 7c 60 1b 78 mr r0,r3
RTEMS_INLINE_ROUTINE Partition_Control *_Partition_Get (
Objects_Id id,
Objects_Locations *location
)
{
return (Partition_Control *)
ffc16784: 3c 60 00 00 lis r3,0
ffc16788: bf c1 00 18 stmw r30,24(r1)
ffc1678c: 38 63 6f 20 addi r3,r3,28448
ffc16790: 7c 9f 23 78 mr r31,r4
ffc16794: 38 a1 00 08 addi r5,r1,8
ffc16798: 7c 04 03 78 mr r4,r0
ffc1679c: 48 00 52 bd bl ffc1ba58 <_Objects_Get>
register Partition_Control *the_partition;
Objects_Locations location;
the_partition = _Partition_Get( id, &location );
switch ( location ) {
ffc167a0: 80 01 00 08 lwz r0,8(r1)
ffc167a4: 7c 7e 1b 78 mr r30,r3
ffc167a8: 2f 80 00 00 cmpwi cr7,r0,0
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
ffc167ac: 38 60 00 04 li r3,4
{
register Partition_Control *the_partition;
Objects_Locations location;
the_partition = _Partition_Get( id, &location );
switch ( location ) {
ffc167b0: 40 9e 00 58 bne- cr7,ffc16808 <rtems_partition_return_buffer+0x94>
)
{
void *starting;
void *ending;
starting = the_partition->starting_address;
ffc167b4: 80 1e 00 10 lwz r0,16(r30)
ending = _Addresses_Add_offset( starting, the_partition->length );
ffc167b8: 81 3e 00 14 lwz r9,20(r30)
const void *address,
const void *base,
const void *limit
)
{
return (address >= base && address <= limit);
ffc167bc: 7f 9f 00 40 cmplw cr7,r31,r0
ffc167c0: 41 9c 00 50 blt- cr7,ffc16810 <rtems_partition_return_buffer+0x9c>
RTEMS_INLINE_ROUTINE void *_Addresses_Add_offset (
const void *base,
uintptr_t offset
)
{
return (void *)((uintptr_t)base + offset);
ffc167c4: 7d 20 4a 14 add r9,r0,r9
const void *address,
const void *base,
const void *limit
)
{
return (address >= base && address <= limit);
ffc167c8: 7f 9f 48 40 cmplw cr7,r31,r9
ffc167cc: 41 9d 00 44 bgt- cr7,ffc16810 <rtems_partition_return_buffer+0x9c><== NEVER TAKEN
offset = (uint32_t) _Addresses_Subtract(
the_buffer,
the_partition->starting_address
);
return ((offset % the_partition->buffer_size) == 0);
ffc167d0: 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);
ffc167d4: 7c 00 f8 50 subf r0,r0,r31
ffc167d8: 7d 60 4b 96 divwu r11,r0,r9
ffc167dc: 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 ) &&
ffc167e0: 7f 80 48 00 cmpw cr7,r0,r9
ffc167e4: 40 9e 00 2c bne- cr7,ffc16810 <rtems_partition_return_buffer+0x9c>
RTEMS_INLINE_ROUTINE void _Partition_Free_buffer (
Partition_Control *the_partition,
Chain_Node *the_buffer
)
{
_Chain_Append( &the_partition->Memory, the_buffer );
ffc167e8: 38 7e 00 24 addi r3,r30,36
ffc167ec: 7f e4 fb 78 mr r4,r31
ffc167f0: 48 00 33 31 bl ffc19b20 <_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;
ffc167f4: 81 3e 00 20 lwz r9,32(r30)
ffc167f8: 38 09 ff ff addi r0,r9,-1
ffc167fc: 90 1e 00 20 stw r0,32(r30)
_Thread_Enable_dispatch();
ffc16800: 48 00 61 25 bl ffc1c924 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
ffc16804: 38 60 00 00 li r3,0
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
ffc16808: 39 61 00 20 addi r11,r1,32
ffc1680c: 4b ff 79 90 b ffc0e19c <_restgpr_30_x>
_Partition_Free_buffer( the_partition, buffer );
the_partition->number_of_used_blocks -= 1;
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
_Thread_Enable_dispatch();
ffc16810: 48 00 61 15 bl ffc1c924 <_Thread_Enable_dispatch>
return RTEMS_INVALID_ADDRESS;
ffc16814: 38 60 00 09 li r3,9
ffc16818: 4b ff ff f0 b ffc16808 <rtems_partition_return_buffer+0x94>
ffc08e6c <rtems_rate_monotonic_period>:
rtems_status_code rtems_rate_monotonic_period(
rtems_id id,
rtems_interval length
)
{
ffc08e6c: 94 21 ff d8 stwu r1,-40(r1)
ffc08e70: 7c 08 02 a6 mflr r0
ffc08e74: bf 81 00 18 stmw r28,24(r1)
ffc08e78: 7c 7e 1b 78 mr r30,r3
RTEMS_INLINE_ROUTINE Rate_monotonic_Control *_Rate_monotonic_Get (
Objects_Id id,
Objects_Locations *location
)
{
return (Rate_monotonic_Control *)
ffc08e7c: 3c 60 00 00 lis r3,0
ffc08e80: 7c 9f 23 78 mr r31,r4
ffc08e84: 90 01 00 2c stw r0,44(r1)
ffc08e88: 38 63 2c 98 addi r3,r3,11416
ffc08e8c: 7f c4 f3 78 mr r4,r30
ffc08e90: 38 a1 00 08 addi r5,r1,8
ffc08e94: 48 00 26 6d bl ffc0b500 <_Objects_Get>
rtems_rate_monotonic_period_states local_state;
ISR_Level level;
the_period = _Rate_monotonic_Get( id, &location );
switch ( location ) {
ffc08e98: 80 01 00 08 lwz r0,8(r1)
ffc08e9c: 7c 7d 1b 78 mr r29,r3
ffc08ea0: 2f 80 00 00 cmpwi cr7,r0,0
ffc08ea4: 40 9e 01 88 bne- cr7,ffc0902c <rtems_rate_monotonic_period+0x1c0>
case OBJECTS_LOCAL:
if ( !_Thread_Is_executing( the_period->owner ) ) {
ffc08ea8: 3d 60 00 00 lis r11,0
ffc08eac: 81 23 00 40 lwz r9,64(r3)
ffc08eb0: 80 0b 32 50 lwz r0,12880(r11)
ffc08eb4: 7f 89 00 00 cmpw cr7,r9,r0
ffc08eb8: 41 9e 00 10 beq- cr7,ffc08ec8 <rtems_rate_monotonic_period+0x5c>
_Thread_Enable_dispatch();
ffc08ebc: 48 00 35 11 bl ffc0c3cc <_Thread_Enable_dispatch>
return RTEMS_NOT_OWNER_OF_RESOURCE;
ffc08ec0: 3b c0 00 17 li r30,23
ffc08ec4: 48 00 01 6c b ffc09030 <rtems_rate_monotonic_period+0x1c4>
}
if ( length == RTEMS_PERIOD_STATUS ) {
ffc08ec8: 2f 9f 00 00 cmpwi cr7,r31,0
ffc08ecc: 40 9e 00 28 bne- cr7,ffc08ef4 <rtems_rate_monotonic_period+0x88>
switch ( the_period->state ) {
ffc08ed0: 80 03 00 38 lwz r0,56(r3)
ffc08ed4: 3b c0 00 00 li r30,0
ffc08ed8: 2b 80 00 04 cmplwi cr7,r0,4
ffc08edc: 41 9d 00 10 bgt- cr7,ffc08eec <rtems_rate_monotonic_period+0x80><== NEVER TAKEN
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
ffc08ee0: 3d 20 ff c2 lis r9,-62
ffc08ee4: 39 29 f4 90 addi r9,r9,-2928
ffc08ee8: 7f c9 00 ae lbzx r30,r9,r0
case RATE_MONOTONIC_ACTIVE:
default: /* unreached -- only to remove warnings */
return_value = RTEMS_SUCCESSFUL;
break;
}
_Thread_Enable_dispatch();
ffc08eec: 48 00 34 e1 bl ffc0c3cc <_Thread_Enable_dispatch>
return( return_value );
ffc08ef0: 48 00 01 40 b ffc09030 <rtems_rate_monotonic_period+0x1c4>
static inline uint32_t ppc_interrupt_disable( void )
{
uint32_t level;
uint32_t mask;
__asm__ volatile (
ffc08ef4: 7f 80 00 a6 mfmsr r28
ffc08ef8: 7c 10 42 a6 mfsprg r0,0
ffc08efc: 7f 80 00 78 andc r0,r28,r0
ffc08f00: 7c 00 01 24 mtmsr r0
}
_ISR_Disable( level );
if ( the_period->state == RATE_MONOTONIC_INACTIVE ) {
ffc08f04: 80 03 00 38 lwz r0,56(r3)
ffc08f08: 2f 80 00 00 cmpwi cr7,r0,0
ffc08f0c: 40 be 00 4c bne+ cr7,ffc08f58 <rtems_rate_monotonic_period+0xec>
return level;
}
static inline void ppc_interrupt_enable( uint32_t level )
{
__asm__ volatile (
ffc08f10: 7f 80 01 24 mtmsr r28
_ISR_Enable( level );
the_period->next_length = length;
ffc08f14: 93 e3 00 3c stw r31,60(r3)
/*
* Baseline statistics information for the beginning of a period.
*/
_Rate_monotonic_Initiate_statistics( the_period );
ffc08f18: 4b ff fd c1 bl ffc08cd8 <_Rate_monotonic_Initiate_statistics>
the_period->state = RATE_MONOTONIC_ACTIVE;
ffc08f1c: 38 00 00 02 li r0,2
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
the_watchdog->routine = routine;
ffc08f20: 3d 20 ff c1 lis r9,-63
ffc08f24: 90 1d 00 38 stw r0,56(r29)
ffc08f28: 39 29 93 24 addi r9,r9,-27868
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
ffc08f2c: 38 00 00 00 li r0,0
the_watchdog->routine = routine;
ffc08f30: 91 3d 00 2c stw r9,44(r29)
)
{
the_watchdog->initial = units;
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
ffc08f34: 3c 60 00 00 lis r3,0
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
ffc08f38: 90 1d 00 18 stw r0,24(r29)
)
{
the_watchdog->initial = units;
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
ffc08f3c: 38 63 2e 68 addi r3,r3,11880
ffc08f40: 38 9d 00 10 addi r4,r29,16
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
the_watchdog->routine = routine;
the_watchdog->id = id;
ffc08f44: 93 dd 00 30 stw r30,48(r29)
the_watchdog->user_data = user_data;
ffc08f48: 90 1d 00 34 stw r0,52(r29)
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
ffc08f4c: 93 fd 00 1c stw r31,28(r29)
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
ffc08f50: 48 00 44 fd bl ffc0d44c <_Watchdog_Insert>
ffc08f54: 48 00 00 74 b ffc08fc8 <rtems_rate_monotonic_period+0x15c>
_Watchdog_Insert_ticks( &the_period->Timer, length );
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
if ( the_period->state == RATE_MONOTONIC_ACTIVE ) {
ffc08f58: 2f 80 00 02 cmpwi cr7,r0,2
ffc08f5c: 40 be 00 78 bne+ cr7,ffc08fd4 <rtems_rate_monotonic_period+0x168>
/*
* Update statistics from the concluding period.
*/
_Rate_monotonic_Update_statistics( the_period );
ffc08f60: 4b ff fe 09 bl ffc08d68 <_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;
ffc08f64: 38 00 00 01 li r0,1
ffc08f68: 90 1d 00 38 stw r0,56(r29)
the_period->next_length = length;
ffc08f6c: 93 fd 00 3c stw r31,60(r29)
ffc08f70: 7f 80 01 24 mtmsr r28
_ISR_Enable( level );
_Thread_Executing->Wait.id = the_period->Object.id;
ffc08f74: 3d 20 00 00 lis r9,0
ffc08f78: 80 1d 00 08 lwz r0,8(r29)
ffc08f7c: 80 69 32 50 lwz r3,12880(r9)
_Thread_Set_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD );
ffc08f80: 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;
ffc08f84: 90 03 00 20 stw r0,32(r3)
_Thread_Set_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD );
ffc08f88: 48 00 3d b9 bl ffc0cd40 <_Thread_Set_state>
static inline uint32_t ppc_interrupt_disable( void )
{
uint32_t level;
uint32_t mask;
__asm__ volatile (
ffc08f8c: 7d 20 00 a6 mfmsr r9
ffc08f90: 7c 10 42 a6 mfsprg r0,0
ffc08f94: 7d 20 00 78 andc r0,r9,r0
ffc08f98: 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;
ffc08f9c: 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;
ffc08fa0: 80 1d 00 38 lwz r0,56(r29)
the_period->state = RATE_MONOTONIC_ACTIVE;
ffc08fa4: 91 7d 00 38 stw r11,56(r29)
return level;
}
static inline void ppc_interrupt_enable( uint32_t level )
{
__asm__ volatile (
ffc08fa8: 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 )
ffc08fac: 2f 80 00 03 cmpwi cr7,r0,3
ffc08fb0: 40 be 00 18 bne+ cr7,ffc08fc8 <rtems_rate_monotonic_period+0x15c><== ALWAYS TAKEN
_Thread_Clear_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD );
ffc08fb4: 3d 20 00 00 lis r9,0 <== NOT EXECUTED
ffc08fb8: 39 29 32 44 addi r9,r9,12868 <== NOT EXECUTED
ffc08fbc: 80 69 00 0c lwz r3,12(r9) <== NOT EXECUTED
ffc08fc0: 38 80 40 00 li r4,16384 <== NOT EXECUTED
ffc08fc4: 48 00 30 45 bl ffc0c008 <_Thread_Clear_state> <== NOT EXECUTED
_Thread_Enable_dispatch();
ffc08fc8: 48 00 34 05 bl ffc0c3cc <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
ffc08fcc: 3b c0 00 00 li r30,0
ffc08fd0: 48 00 00 60 b ffc09030 <rtems_rate_monotonic_period+0x1c4>
}
if ( the_period->state == RATE_MONOTONIC_EXPIRED ) {
ffc08fd4: 2f 80 00 04 cmpwi cr7,r0,4
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
ffc08fd8: 3b c0 00 04 li r30,4
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
if ( the_period->state == RATE_MONOTONIC_EXPIRED ) {
ffc08fdc: 40 be 00 54 bne+ cr7,ffc09030 <rtems_rate_monotonic_period+0x1c4><== NEVER TAKEN
/*
* Update statistics from the concluding period
*/
_Rate_monotonic_Update_statistics( the_period );
ffc08fe0: 4b ff fd 89 bl ffc08d68 <_Rate_monotonic_Update_statistics>
ffc08fe4: 7f 80 01 24 mtmsr r28
_ISR_Enable( level );
the_period->state = RATE_MONOTONIC_ACTIVE;
ffc08fe8: 38 00 00 02 li r0,2
the_period->next_length = length;
ffc08fec: 93 fd 00 3c stw r31,60(r29)
ffc08ff0: 3c 60 00 00 lis r3,0
*/
_Rate_monotonic_Update_statistics( the_period );
_ISR_Enable( level );
the_period->state = RATE_MONOTONIC_ACTIVE;
ffc08ff4: 90 1d 00 38 stw r0,56(r29)
ffc08ff8: 38 63 2e 68 addi r3,r3,11880
ffc08ffc: 38 9d 00 10 addi r4,r29,16
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
ffc09000: 93 fd 00 1c stw r31,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;
ffc09004: 3b c0 00 06 li r30,6
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
ffc09008: 48 00 44 45 bl ffc0d44c <_Watchdog_Insert>
ffc0900c: 3d 20 00 00 lis r9,0
ffc09010: 80 09 21 14 lwz r0,8468(r9)
ffc09014: 80 7d 00 40 lwz r3,64(r29)
ffc09018: 80 9d 00 3c lwz r4,60(r29)
ffc0901c: 7c 09 03 a6 mtctr r0
ffc09020: 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();
ffc09024: 48 00 33 a9 bl ffc0c3cc <_Thread_Enable_dispatch>
return RTEMS_TIMEOUT;
ffc09028: 48 00 00 08 b ffc09030 <rtems_rate_monotonic_period+0x1c4>
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
ffc0902c: 3b c0 00 04 li r30,4
}
ffc09030: 39 61 00 28 addi r11,r1,40
ffc09034: 7f c3 f3 78 mr r3,r30
ffc09038: 4b ff 81 c8 b ffc01200 <_restgpr_28_x>
ffc0903c <rtems_rate_monotonic_report_statistics_with_plugin>:
*/
void rtems_rate_monotonic_report_statistics_with_plugin(
void *context,
rtems_printk_plugin_t print
)
{
ffc0903c: 94 21 ff 70 stwu r1,-144(r1)
ffc09040: 7c 08 02 a6 mflr r0
ffc09044: 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 )
ffc09048: 7c 80 23 79 mr. r0,r4
*/
void rtems_rate_monotonic_report_statistics_with_plugin(
void *context,
rtems_printk_plugin_t print
)
{
ffc0904c: bf 01 00 70 stmw r24,112(r1)
ffc09050: 7c 7f 1b 78 mr r31,r3
rtems_id id;
rtems_rate_monotonic_period_statistics the_stats;
rtems_rate_monotonic_period_status the_status;
char name[5];
if ( !print )
ffc09054: 90 01 00 68 stw r0,104(r1)
ffc09058: 41 82 01 e4 beq- ffc0923c <rtems_rate_monotonic_report_statistics_with_plugin+0x200><== NEVER TAKEN
return;
(*print)( context, "Period information by period\n" );
ffc0905c: 3c 80 ff c2 lis r4,-62
ffc09060: 7c 09 03 a6 mtctr r0
ffc09064: 38 84 f4 95 addi r4,r4,-2923
/*
* 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 ;
ffc09068: 3f 00 00 00 lis r24,0
rtems_object_get_name( the_status.owner, sizeof(name), name );
/*
* Print part of report line that is not dependent on granularity
*/
(*print)( context,
ffc0906c: 3f 20 ff c2 lis r25,-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,
ffc09070: 3f 40 ff c2 lis r26,-62
char name[5];
if ( !print )
return;
(*print)( context, "Period information by period\n" );
ffc09074: 4c c6 31 82 crclr 4*cr1+eq
ffc09078: 4e 80 04 21 bctrl
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
(*print)( context, "--- CPU times are in seconds ---\n" );
ffc0907c: 80 01 00 68 lwz r0,104(r1)
ffc09080: 3c 80 ff c2 lis r4,-62
ffc09084: 7c 09 03 a6 mtctr r0
ffc09088: 38 84 f4 b3 addi r4,r4,-2893
ffc0908c: 7f e3 fb 78 mr r3,r31
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,
ffc09090: 3f 60 ff c2 lis r27,-62
/*
* If the count is zero, don't print statistics
*/
if (the_stats.count == 0) {
(*print)( context, "\n" );
ffc09094: 3f 80 ff c2 lis r28,-62
rtems_object_get_name( the_status.owner, sizeof(name), name );
/*
* Print part of report line that is not dependent on granularity
*/
(*print)( context,
ffc09098: 3b 39 f5 8f addi r25,r25,-2673
if ( !print )
return;
(*print)( context, "Period information by period\n" );
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
(*print)( context, "--- CPU times are in seconds ---\n" );
ffc0909c: 4c c6 31 82 crclr 4*cr1+eq
ffc090a0: 4e 80 04 21 bctrl
(*print)( context, "--- Wall times are in seconds ---\n" );
ffc090a4: 80 01 00 68 lwz r0,104(r1)
ffc090a8: 3c 80 ff c2 lis r4,-62
ffc090ac: 7c 09 03 a6 mtctr r0
ffc090b0: 38 84 f4 d5 addi r4,r4,-2859
ffc090b4: 7f e3 fb 78 mr r3,r31
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,
ffc090b8: 3b 5a f5 a6 addi r26,r26,-2650
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,
ffc090bc: 3b 7b f5 c5 addi r27,r27,-2619
/*
* If the count is zero, don't print statistics
*/
if (the_stats.count == 0) {
(*print)( context, "\n" );
ffc090c0: 3b 9c f4 42 addi r28,r28,-3006
return;
(*print)( context, "Period information by period\n" );
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
(*print)( context, "--- CPU times are in seconds ---\n" );
(*print)( context, "--- Wall times are in seconds ---\n" );
ffc090c4: 4c c6 31 82 crclr 4*cr1+eq
ffc090c8: 4e 80 04 21 bctrl
Be sure to test the various cases.
(*print)( context,"\
1234567890123456789012345678901234567890123456789012345678901234567890123456789\
\n");
*/
(*print)( context, " ID OWNER COUNT MISSED "
ffc090cc: 80 01 00 68 lwz r0,104(r1)
ffc090d0: 3c 80 ff c2 lis r4,-62
ffc090d4: 7c 09 03 a6 mtctr r0
ffc090d8: 38 84 f4 f8 addi r4,r4,-2824
ffc090dc: 7f e3 fb 78 mr r3,r31
ffc090e0: 4c c6 31 82 crclr 4*cr1+eq
ffc090e4: 4e 80 04 21 bctrl
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
" "
#endif
" WALL TIME\n"
);
(*print)( context, " "
ffc090e8: 80 01 00 68 lwz r0,104(r1)
ffc090ec: 3c 80 ff c2 lis r4,-62
ffc090f0: 7f e3 fb 78 mr r3,r31
ffc090f4: 7c 09 03 a6 mtctr r0
ffc090f8: 38 84 f5 43 addi r4,r4,-2749
ffc090fc: 4c c6 31 82 crclr 4*cr1+eq
ffc09100: 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 ;
ffc09104: 39 38 2c 98 addi r9,r24,11416
ffc09108: 83 c9 00 08 lwz r30,8(r9)
ffc0910c: 48 00 01 20 b ffc0922c <rtems_rate_monotonic_report_statistics_with_plugin+0x1f0>
id <= _Rate_monotonic_Information.maximum_id ;
id++ ) {
status = rtems_rate_monotonic_get_statistics( id, &the_stats );
ffc09110: 7f c3 f3 78 mr r3,r30
ffc09114: 38 81 00 30 addi r4,r1,48
ffc09118: 48 00 69 d1 bl ffc0fae8 <rtems_rate_monotonic_get_statistics>
if ( status != RTEMS_SUCCESSFUL )
ffc0911c: 2f 83 00 00 cmpwi cr7,r3,0
ffc09120: 40 be 01 08 bne+ cr7,ffc09228 <rtems_rate_monotonic_report_statistics_with_plugin+0x1ec>
#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 );
ffc09124: 38 81 00 18 addi r4,r1,24
ffc09128: 7f c3 f3 78 mr r3,r30
ffc0912c: 48 00 6a 89 bl ffc0fbb4 <rtems_rate_monotonic_get_status>
#endif
rtems_object_get_name( the_status.owner, sizeof(name), name );
ffc09130: 80 61 00 18 lwz r3,24(r1)
ffc09134: 38 80 00 05 li r4,5
ffc09138: 38 a1 00 08 addi r5,r1,8
ffc0913c: 48 00 02 ad bl ffc093e8 <rtems_object_get_name>
/*
* Print part of report line that is not dependent on granularity
*/
(*print)( context,
ffc09140: 80 01 00 68 lwz r0,104(r1)
ffc09144: 7f 24 cb 78 mr r4,r25
ffc09148: 80 e1 00 30 lwz r7,48(r1)
ffc0914c: 7f e3 fb 78 mr r3,r31
ffc09150: 81 01 00 34 lwz r8,52(r1)
ffc09154: 7f c5 f3 78 mr r5,r30
ffc09158: 7c 09 03 a6 mtctr r0
ffc0915c: 38 c1 00 08 addi r6,r1,8
ffc09160: 4c c6 31 82 crclr 4*cr1+eq
ffc09164: 4e 80 04 21 bctrl
);
/*
* If the count is zero, don't print statistics
*/
if (the_stats.count == 0) {
ffc09168: 80 81 00 30 lwz r4,48(r1)
ffc0916c: 2f 84 00 00 cmpwi cr7,r4,0
ffc09170: 40 9e 00 20 bne- cr7,ffc09190 <rtems_rate_monotonic_report_statistics_with_plugin+0x154>
(*print)( context, "\n" );
ffc09174: 80 01 00 68 lwz r0,104(r1)
ffc09178: 7f e3 fb 78 mr r3,r31
ffc0917c: 7f 84 e3 78 mr r4,r28
ffc09180: 7c 09 03 a6 mtctr r0
ffc09184: 4c c6 31 82 crclr 4*cr1+eq
ffc09188: 4e 80 04 21 bctrl
continue;
ffc0918c: 48 00 00 9c b ffc09228 <rtems_rate_monotonic_report_statistics_with_plugin+0x1ec>
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 );
ffc09190: 38 61 00 48 addi r3,r1,72
ffc09194: 38 a1 00 10 addi r5,r1,16
ffc09198: 48 00 3e 3d bl ffc0cfd4 <_Timespec_Divide_by_integer>
(*print)( context,
ffc0919c: 80 01 00 68 lwz r0,104(r1)
ffc091a0: 80 c1 00 3c lwz r6,60(r1)
ffc091a4: 3b a0 03 e8 li r29,1000
ffc091a8: 81 01 00 44 lwz r8,68(r1)
ffc091ac: 7c 09 03 a6 mtctr r0
ffc091b0: 81 41 00 14 lwz r10,20(r1)
ffc091b4: 7c c6 eb d6 divw r6,r6,r29
ffc091b8: 80 e1 00 40 lwz r7,64(r1)
ffc091bc: 81 21 00 10 lwz r9,16(r1)
ffc091c0: 80 a1 00 38 lwz r5,56(r1)
ffc091c4: 7d 08 eb d6 divw r8,r8,r29
ffc091c8: 7d 4a eb d6 divw r10,r10,r29
ffc091cc: 7f 44 d3 78 mr r4,r26
ffc091d0: 7f e3 fb 78 mr r3,r31
ffc091d4: 4c c6 31 82 crclr 4*cr1+eq
ffc091d8: 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);
ffc091dc: 80 81 00 30 lwz r4,48(r1)
ffc091e0: 38 61 00 60 addi r3,r1,96
ffc091e4: 38 a1 00 10 addi r5,r1,16
ffc091e8: 48 00 3d ed bl ffc0cfd4 <_Timespec_Divide_by_integer>
(*print)( context,
ffc091ec: 80 c1 00 54 lwz r6,84(r1)
ffc091f0: 81 01 00 5c lwz r8,92(r1)
ffc091f4: 7f e3 fb 78 mr r3,r31
ffc091f8: 81 41 00 14 lwz r10,20(r1)
ffc091fc: 7f 64 db 78 mr r4,r27
ffc09200: 80 01 00 68 lwz r0,104(r1)
ffc09204: 7c c6 eb d6 divw r6,r6,r29
ffc09208: 80 a1 00 50 lwz r5,80(r1)
ffc0920c: 80 e1 00 58 lwz r7,88(r1)
ffc09210: 7c 09 03 a6 mtctr r0
ffc09214: 81 21 00 10 lwz r9,16(r1)
ffc09218: 7d 08 eb d6 divw r8,r8,r29
ffc0921c: 7d 4a eb d6 divw r10,r10,r29
ffc09220: 4c c6 31 82 crclr 4*cr1+eq
ffc09224: 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 ;
id <= _Rate_monotonic_Information.maximum_id ;
id++ ) {
ffc09228: 3b de 00 01 addi r30,r30,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 ;
id <= _Rate_monotonic_Information.maximum_id ;
ffc0922c: 39 38 2c 98 addi r9,r24,11416
/*
* 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 ;
ffc09230: 80 09 00 0c lwz r0,12(r9)
ffc09234: 7f 9e 00 40 cmplw cr7,r30,r0
ffc09238: 40 9d fe d8 ble+ cr7,ffc09110 <rtems_rate_monotonic_report_statistics_with_plugin+0xd4>
the_stats.min_wall_time, the_stats.max_wall_time, ival_wall, fval_wall
);
#endif
}
}
}
ffc0923c: 39 61 00 90 addi r11,r1,144
ffc09240: 4b ff 7f b0 b ffc011f0 <_restgpr_24_x>
ffc1ac20 <rtems_rfs_bitmap_create_search>:
int
rtems_rfs_bitmap_create_search (rtems_rfs_bitmap_control* control)
{
ffc1ac20: 94 21 ff c8 stwu r1,-56(r1)
ffc1ac24: 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);
ffc1ac28: 38 81 00 08 addi r4,r1,8
return 0;
}
int
rtems_rfs_bitmap_create_search (rtems_rfs_bitmap_control* control)
{
ffc1ac2c: bf 21 00 1c stmw r25,28(r1)
ffc1ac30: 7c 7e 1b 78 mr r30,r3
ffc1ac34: 90 01 00 3c stw r0,60(r1)
rtems_rfs_bitmap_map map;
size_t size;
rtems_rfs_bitmap_bit bit;
int rc;
rc = rtems_rfs_bitmap_load_map (control, &map);
ffc1ac38: 4b ff f9 41 bl ffc1a578 <rtems_rfs_bitmap_load_map>
if (rc > 0)
ffc1ac3c: 2c 03 00 00 cmpwi r3,0
ffc1ac40: 41 a1 00 cc bgt+ ffc1ad0c <rtems_rfs_bitmap_create_search+0xec><== NEVER TAKEN
return rc;
control->free = 0;
ffc1ac44: 38 00 00 00 li r0,0
search_map = control->search_bits;
ffc1ac48: 83 7e 00 14 lwz r27,20(r30)
rc = rtems_rfs_bitmap_load_map (control, &map);
if (rc > 0)
return rc;
control->free = 0;
ffc1ac4c: 90 1e 00 10 stw r0,16(r30)
search_map = control->search_bits;
size = control->size;
bit = 0;
*search_map = RTEMS_RFS_BITMAP_ELEMENT_CLEAR;
ffc1ac50: 38 00 ff ff li r0,-1
return rc;
control->free = 0;
search_map = control->search_bits;
size = control->size;
bit = 0;
ffc1ac54: 3b a0 00 00 li r29,0
if (rc > 0)
return rc;
control->free = 0;
search_map = control->search_bits;
size = control->size;
ffc1ac58: 83 fe 00 0c lwz r31,12(r30)
*/
static bool
rtems_rfs_bitmap_test (rtems_rfs_bitmap_element target,
rtems_rfs_bitmap_bit bit)
{
return RTEMS_RFS_BITMAP_TEST_BIT (target, bit);
ffc1ac5c: 3b 20 00 01 li r25,1
control->free = 0;
search_map = control->search_bits;
size = control->size;
bit = 0;
*search_map = RTEMS_RFS_BITMAP_ELEMENT_CLEAR;
ffc1ac60: 90 1b 00 00 stw r0,0(r27)
if (bit == rtems_rfs_bitmap_element_bits ())
{
bit = 0;
search_map++;
*search_map = RTEMS_RFS_BITMAP_ELEMENT_CLEAR;
ffc1ac64: 3b 40 ff ff li r26,-1
control->free = 0;
search_map = control->search_bits;
size = control->size;
bit = 0;
*search_map = RTEMS_RFS_BITMAP_ELEMENT_CLEAR;
ffc1ac68: 83 81 00 08 lwz r28,8(r1)
while (size)
ffc1ac6c: 48 00 00 94 b ffc1ad00 <rtems_rfs_bitmap_create_search+0xe0>
{
rtems_rfs_bitmap_element bits;
int available;
if (size < rtems_rfs_bitmap_element_bits ())
ffc1ac70: 2b 9f 00 1f cmplwi cr7,r31,31
ffc1ac74: 41 9d 00 20 bgt- cr7,ffc1ac94 <rtems_rfs_bitmap_create_search+0x74>
{
bits = rtems_rfs_bitmap_merge (*map,
ffc1ac78: 38 60 00 00 li r3,0
ffc1ac7c: 7f e4 fb 78 mr r4,r31
ffc1ac80: 4b ff fb 71 bl ffc1a7f0 <rtems_rfs_bitmap_mask_section>
{
/*
* Use the normal bit operators because we do not change the bits just merge
* the 2 separate parts.
*/
bits1 &= mask;
ffc1ac84: 80 1c 00 00 lwz r0,0(r28)
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;
ffc1ac88: 7f e9 fb 78 mr r9,r31
{
/*
* Use the normal bit operators because we do not change the bits just merge
* the 2 separate parts.
*/
bits1 &= mask;
ffc1ac8c: 7c 60 00 38 and r0,r3,r0
ffc1ac90: 48 00 00 0c b ffc1ac9c <rtems_rfs_bitmap_create_search+0x7c>
rtems_rfs_bitmap_mask_section (0, size));
available = size;
}
else
{
bits = *map;
ffc1ac94: 80 1c 00 00 lwz r0,0(r28)
available = rtems_rfs_bitmap_element_bits ();
ffc1ac98: 39 20 00 20 li r9,32
}
if (rtems_rfs_bitmap_match (bits, RTEMS_RFS_BITMAP_ELEMENT_SET))
ffc1ac9c: 2f 80 00 00 cmpwi cr7,r0,0
ffc1aca0: 41 9e 00 3c beq- cr7,ffc1acdc <rtems_rfs_bitmap_create_search+0xbc>
ffc1aca4: 2f 89 00 00 cmpwi cr7,r9,0
ffc1aca8: 39 40 00 00 li r10,0
*/
static bool
rtems_rfs_bitmap_test (rtems_rfs_bitmap_element target,
rtems_rfs_bitmap_bit bit)
{
return RTEMS_RFS_BITMAP_TEST_BIT (target, bit);
ffc1acac: 7d 2b 4b 78 mr r11,r9
ffc1acb0: 41 bd 00 08 bgt+ cr7,ffc1acb8 <rtems_rfs_bitmap_create_search+0x98><== ALWAYS TAKEN
ffc1acb4: 39 60 00 01 li r11,1 <== NOT EXECUTED
ffc1acb8: 7f 28 50 30 slw r8,r25,r10
rtems_rfs_bitmap_set (*search_map, bit);
else
{
int b;
for (b = 0; b < available; b++)
if (!rtems_rfs_bitmap_test (bits, b))
ffc1acbc: 7d 07 00 39 and. r7,r8,r0
ffc1acc0: 41 82 00 10 beq- ffc1acd0 <rtems_rfs_bitmap_create_search+0xb0>
control->free++;
ffc1acc4: 81 1e 00 10 lwz r8,16(r30)
ffc1acc8: 39 08 00 01 addi r8,r8,1
ffc1accc: 91 1e 00 10 stw r8,16(r30)
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++)
ffc1acd0: 35 6b ff ff addic. r11,r11,-1
ffc1acd4: 39 4a 00 01 addi r10,r10,1
ffc1acd8: 40 82 ff e0 bne+ ffc1acb8 <rtems_rfs_bitmap_create_search+0x98>
control->free++;
}
size -= available;
if (bit == rtems_rfs_bitmap_element_bits ())
ffc1acdc: 2f 9d 00 20 cmpwi cr7,r29,32
for (b = 0; b < available; b++)
if (!rtems_rfs_bitmap_test (bits, b))
control->free++;
}
size -= available;
ffc1ace0: 7f e9 f8 50 subf r31,r9,r31
if (bit == rtems_rfs_bitmap_element_bits ())
ffc1ace4: 40 be 00 14 bne+ cr7,ffc1acf8 <rtems_rfs_bitmap_create_search+0xd8><== ALWAYS TAKEN
{
bit = 0;
search_map++;
*search_map = RTEMS_RFS_BITMAP_ELEMENT_CLEAR;
ffc1ace8: 93 5b 00 04 stw r26,4(r27) <== NOT EXECUTED
size -= available;
if (bit == rtems_rfs_bitmap_element_bits ())
{
bit = 0;
ffc1acec: 3b a0 00 00 li r29,0 <== NOT EXECUTED
search_map++;
ffc1acf0: 3b 7b 00 04 addi r27,r27,4 <== NOT EXECUTED
ffc1acf4: 48 00 00 08 b ffc1acfc <rtems_rfs_bitmap_create_search+0xdc><== NOT EXECUTED
*search_map = RTEMS_RFS_BITMAP_ELEMENT_CLEAR;
}
else
bit++;
ffc1acf8: 3b bd 00 01 addi r29,r29,1
ffc1acfc: 3b 9c 00 04 addi r28,r28,4
search_map = control->search_bits;
size = control->size;
bit = 0;
*search_map = RTEMS_RFS_BITMAP_ELEMENT_CLEAR;
while (size)
ffc1ad00: 2f 9f 00 00 cmpwi cr7,r31,0
ffc1ad04: 40 9e ff 6c bne+ cr7,ffc1ac70 <rtems_rfs_bitmap_create_search+0x50>
else
bit++;
map++;
}
return 0;
ffc1ad08: 38 60 00 00 li r3,0
}
ffc1ad0c: 39 61 00 38 addi r11,r1,56
ffc1ad10: 4b fe 7d d0 b ffc02ae0 <_restgpr_25_x>
ffc1a578 <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)
{
ffc1a578: 94 21 ff f0 stwu r1,-16(r1)
ffc1a57c: 7c 08 02 a6 mflr r0
ffc1a580: 90 01 00 14 stw r0,20(r1)
int rc;
if (!control->buffer)
ffc1a584: 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)
{
ffc1a588: bf c1 00 08 stmw r30,8(r1)
ffc1a58c: 7c 7f 1b 78 mr r31,r3
int rc;
if (!control->buffer)
ffc1a590: 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)
{
ffc1a594: 7c 9e 23 78 mr r30,r4
int rc;
if (!control->buffer)
return ENXIO;
ffc1a598: 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)
ffc1a59c: 41 9e 00 38 beq- cr7,ffc1a5d4 <rtems_rfs_bitmap_load_map+0x5c><== NEVER TAKEN
return ENXIO;
*map = NULL;
ffc1a5a0: 38 00 00 00 li r0,0
rc = rtems_rfs_buffer_handle_request (control->fs,
ffc1a5a4: 80 bf 00 08 lwz r5,8(r31)
int rc;
if (!control->buffer)
return ENXIO;
*map = NULL;
ffc1a5a8: 90 04 00 00 stw r0,0(r4)
rc = rtems_rfs_buffer_handle_request (control->fs,
ffc1a5ac: 38 c0 00 01 li r6,1
ffc1a5b0: 80 7f 00 04 lwz r3,4(r31)
ffc1a5b4: 80 9f 00 00 lwz r4,0(r31)
ffc1a5b8: 48 00 1c 31 bl ffc1c1e8 <rtems_rfs_buffer_handle_request>
control->buffer,
control->block,
true);
if (rc)
ffc1a5bc: 2c 03 00 00 cmpwi r3,0
ffc1a5c0: 40 82 00 14 bne- ffc1a5d4 <rtems_rfs_bitmap_load_map+0x5c><== NEVER TAKEN
return rc;
*map = rtems_rfs_buffer_data (control->buffer);
ffc1a5c4: 81 3f 00 00 lwz r9,0(r31)
ffc1a5c8: 81 29 00 08 lwz r9,8(r9)
ffc1a5cc: 80 09 00 24 lwz r0,36(r9)
ffc1a5d0: 90 1e 00 00 stw r0,0(r30)
return 0;
}
ffc1a5d4: 39 61 00 10 addi r11,r1,16
ffc1a5d8: 4b fe 85 1c b ffc02af4 <_restgpr_30_x>
ffc1ab34 <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)
{
ffc1ab34: 94 21 ff e0 stwu r1,-32(r1)
ffc1ab38: 7c 08 02 a6 mflr r0
ffc1ab3c: 90 01 00 24 stw r0,36(r1)
int rc = 0;
/*
* By default we assume the allocation failed.
*/
*allocated = false;
ffc1ab40: 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)
{
ffc1ab44: bf 61 00 0c stmw r27,12(r1)
ffc1ab48: 7c 7d 1b 78 mr r29,r3
ffc1ab4c: 7c bc 2b 78 mr r28,r5
ffc1ab50: 7c db 33 78 mr r27,r6
int rc = 0;
/*
* By default we assume the allocation failed.
*/
*allocated = false;
ffc1ab54: 98 05 00 00 stb r0,0(r5)
* 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;
ffc1ab58: 7c 9f 23 78 mr r31,r4
* 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;
ffc1ab5c: 7c 9e 23 78 mr r30,r4
* 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))
ffc1ab60: 48 00 00 8c b ffc1abec <rtems_rfs_bitmap_map_alloc+0xb8>
|| ((lower_seed >= 0) && (lower_seed < control->size)))
{
/*
* Search up first so bits allocated in succession are grouped together.
*/
if (upper_seed < control->size)
ffc1ab64: 80 1d 00 0c lwz r0,12(r29)
ffc1ab68: 7f 9e 00 40 cmplw cr7,r30,r0
ffc1ab6c: 40 bc 00 30 bge+ cr7,ffc1ab9c <rtems_rfs_bitmap_map_alloc+0x68><== NEVER TAKEN
{
*bit = upper_seed;
ffc1ab70: 93 db 00 00 stw r30,0(r27)
rc = rtems_rfs_search_map_for_clear_bit (control, bit, allocated,
ffc1ab74: 7f a3 eb 78 mr r3,r29
ffc1ab78: 7f 64 db 78 mr r4,r27
ffc1ab7c: 7f 85 e3 78 mr r5,r28
ffc1ab80: 38 c0 00 01 li r6,1
ffc1ab84: 4b ff fa 59 bl ffc1a5dc <rtems_rfs_search_map_for_clear_bit.constprop.1>
window, 1);
if ((rc > 0) || *allocated)
ffc1ab88: 2f 83 00 00 cmpwi cr7,r3,0
ffc1ab8c: 41 9d 00 88 bgt- cr7,ffc1ac14 <rtems_rfs_bitmap_map_alloc+0xe0><== NEVER TAKEN
ffc1ab90: 88 1c 00 00 lbz r0,0(r28)
ffc1ab94: 2f 80 00 00 cmpwi cr7,r0,0
ffc1ab98: 40 9e 00 7c bne- cr7,ffc1ac14 <rtems_rfs_bitmap_map_alloc+0xe0>
break;
}
if (lower_seed >= 0)
ffc1ab9c: 2f 9f 00 00 cmpwi cr7,r31,0
ffc1aba0: 41 9c 00 30 blt- cr7,ffc1abd0 <rtems_rfs_bitmap_map_alloc+0x9c><== NEVER TAKEN
{
*bit = lower_seed;
ffc1aba4: 93 fb 00 00 stw r31,0(r27)
rc = rtems_rfs_search_map_for_clear_bit (control, bit, allocated,
ffc1aba8: 7f a3 eb 78 mr r3,r29
ffc1abac: 7f 64 db 78 mr r4,r27
ffc1abb0: 7f 85 e3 78 mr r5,r28
ffc1abb4: 38 c0 ff ff li r6,-1
ffc1abb8: 4b ff fa 25 bl ffc1a5dc <rtems_rfs_search_map_for_clear_bit.constprop.1>
window, -1);
if ((rc > 0) || *allocated)
ffc1abbc: 2f 83 00 00 cmpwi cr7,r3,0
ffc1abc0: 41 9d 00 54 bgt- cr7,ffc1ac14 <rtems_rfs_bitmap_map_alloc+0xe0><== NEVER TAKEN
ffc1abc4: 88 1c 00 00 lbz r0,0(r28)
ffc1abc8: 2f 80 00 00 cmpwi cr7,r0,0
ffc1abcc: 40 9e 00 48 bne- cr7,ffc1ac14 <rtems_rfs_bitmap_map_alloc+0xe0><== NEVER TAKEN
/*
* 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)
ffc1abd0: 80 1d 00 0c lwz r0,12(r29)
ffc1abd4: 7f 9e 00 40 cmplw cr7,r30,r0
ffc1abd8: 40 9c 00 08 bge- cr7,ffc1abe0 <rtems_rfs_bitmap_map_alloc+0xac><== NEVER TAKEN
upper_seed += window;
ffc1abdc: 3b de 08 00 addi r30,r30,2048
if (lower_seed >= 0)
ffc1abe0: 2f 9f 00 00 cmpwi cr7,r31,0
ffc1abe4: 41 9c 00 08 blt- cr7,ffc1abec <rtems_rfs_bitmap_map_alloc+0xb8><== NEVER TAKEN
lower_seed -= window;
ffc1abe8: 3b ff f8 00 addi r31,r31,-2048
* 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))
ffc1abec: 2f 9e 00 00 cmpwi cr7,r30,0
ffc1abf0: 41 9c 00 10 blt- cr7,ffc1ac00 <rtems_rfs_bitmap_map_alloc+0xcc><== NEVER TAKEN
ffc1abf4: 80 1d 00 0c lwz r0,12(r29)
ffc1abf8: 7f 9e 00 40 cmplw cr7,r30,r0
ffc1abfc: 41 bc ff 68 blt- cr7,ffc1ab64 <rtems_rfs_bitmap_map_alloc+0x30>
|| ((lower_seed >= 0) && (lower_seed < control->size)))
ffc1ac00: 2f 9f 00 00 cmpwi cr7,r31,0
ffc1ac04: 41 9c 00 10 blt- cr7,ffc1ac14 <rtems_rfs_bitmap_map_alloc+0xe0>
ffc1ac08: 80 1d 00 0c lwz r0,12(r29)
ffc1ac0c: 7f 9f 00 40 cmplw cr7,r31,r0
ffc1ac10: 41 9c ff 54 blt+ cr7,ffc1ab64 <rtems_rfs_bitmap_map_alloc+0x30><== NEVER TAKEN
if (lower_seed >= 0)
lower_seed -= window;
}
return 0;
}
ffc1ac14: 39 61 00 20 addi r11,r1,32
ffc1ac18: 38 60 00 00 li r3,0
ffc1ac1c: 4b fe 7e cc b ffc02ae8 <_restgpr_27_x>
ffc1a8bc <rtems_rfs_bitmap_map_clear>:
int
rtems_rfs_bitmap_map_clear (rtems_rfs_bitmap_control* control,
rtems_rfs_bitmap_bit bit)
{
ffc1a8bc: 94 21 ff e0 stwu r1,-32(r1)
ffc1a8c0: 7c 08 02 a6 mflr r0
ffc1a8c4: bf c1 00 18 stmw r30,24(r1)
ffc1a8c8: 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);
ffc1a8cc: 38 81 00 08 addi r4,r1,8
}
int
rtems_rfs_bitmap_map_clear (rtems_rfs_bitmap_control* control,
rtems_rfs_bitmap_bit bit)
{
ffc1a8d0: 90 01 00 24 stw r0,36(r1)
ffc1a8d4: 7c 7f 1b 78 mr r31,r3
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);
ffc1a8d8: 4b ff fc a1 bl ffc1a578 <rtems_rfs_bitmap_load_map>
if (rc > 0)
ffc1a8dc: 2c 03 00 00 cmpwi r3,0
ffc1a8e0: 41 a1 00 70 bgt+ ffc1a950 <rtems_rfs_bitmap_map_clear+0x94><== NEVER TAKEN
return rc;
if (bit >= control->size)
ffc1a8e4: 80 1f 00 0c lwz r0,12(r31)
return EINVAL;
ffc1a8e8: 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)
ffc1a8ec: 7f 9e 00 40 cmplw cr7,r30,r0
ffc1a8f0: 40 bc 00 60 bge+ cr7,ffc1a950 <rtems_rfs_bitmap_map_clear+0x94><== 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);
ffc1a8f4: 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);
ffc1a8f8: 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);
ffc1a8fc: 55 6a 10 3a rlwinm r10,r11,2,0,29
rc = rtems_rfs_bitmap_load_map (control, &map);
if (rc > 0)
return rc;
if (bit >= control->size)
return EINVAL;
search_map = control->search_bits;
ffc1a900: 81 3f 00 14 lwz r9,20(r31)
*/
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);
ffc1a904: 7c c8 50 2e lwzx r6,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);
ffc1a908: 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);
ffc1a90c: 57 c7 06 fe clrlwi r7,r30,27
map[index] = rtems_rfs_bitmap_clear (map[index], 1 << offset);
ffc1a910: 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);
ffc1a914: 7c c7 3b 78 or r7,r6,r7
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);
ffc1a918: 7c e8 51 2e stwx r7,r8,r10
bit = index;
index = rtems_rfs_bitmap_map_index (bit);
ffc1a91c: 7f de 56 70 srawi r30,r30,10
offset = rtems_rfs_bitmap_map_offset(bit);
search_map[index] = rtems_rfs_bitmap_clear (search_map[index], 1 << offset);
ffc1a920: 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);
ffc1a924: 7d 49 f0 2e lwzx r10,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);
ffc1a928: 55 6b 06 fe clrlwi r11,r11,27
search_map[index] = rtems_rfs_bitmap_clear (search_map[index], 1 << offset);
ffc1a92c: 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);
ffc1a930: 7d 4b 5b 78 or r11,r10,r11
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);
ffc1a934: 7d 69 f1 2e stwx r11,r9,r30
rtems_rfs_buffer_mark_dirty (control->buffer);
control->free++;
return 0;
ffc1a938: 38 60 00 00 li r3,0
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);
ffc1a93c: 81 3f 00 00 lwz r9,0(r31)
ffc1a940: 98 09 00 00 stb r0,0(r9)
control->free++;
ffc1a944: 81 3f 00 10 lwz r9,16(r31)
ffc1a948: 38 09 00 01 addi r0,r9,1
ffc1a94c: 90 1f 00 10 stw r0,16(r31)
return 0;
}
ffc1a950: 39 61 00 20 addi r11,r1,32
ffc1a954: 4b fe 81 a0 b ffc02af4 <_restgpr_30_x>
ffc1aa6c <rtems_rfs_bitmap_map_clear_all>:
int
rtems_rfs_bitmap_map_clear_all (rtems_rfs_bitmap_control* control)
{
ffc1aa6c: 7c 2b 0b 78 mr r11,r1
ffc1aa70: 94 21 ff e0 stwu r1,-32(r1)
ffc1aa74: 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);
ffc1aa78: 38 81 00 08 addi r4,r1,8
return 0;
}
int
rtems_rfs_bitmap_map_clear_all (rtems_rfs_bitmap_control* control)
{
ffc1aa7c: 4b fe 80 31 bl ffc02aac <_savegpr_31>
ffc1aa80: 90 01 00 24 stw r0,36(r1)
ffc1aa84: 7c 7f 1b 78 mr r31,r3
rtems_rfs_bitmap_bit last_search_bit;
size_t elements;
int e;
int rc;
rc = rtems_rfs_bitmap_load_map (control, &map);
ffc1aa88: 4b ff fa f1 bl ffc1a578 <rtems_rfs_bitmap_load_map>
if (rc > 0)
ffc1aa8c: 2c 03 00 00 cmpwi r3,0
ffc1aa90: 41 a1 00 9c bgt+ ffc1ab2c <rtems_rfs_bitmap_map_clear_all+0xc0><== NEVER TAKEN
return rc;
elements = rtems_rfs_bitmap_elements (control->size);
ffc1aa94: 81 1f 00 0c lwz r8,12(r31)
control->free = elements;
for (e = 0; e < elements; e++)
ffc1aa98: 39 60 00 00 li r11,0
map[e] = RTEMS_RFS_BITMAP_ELEMENT_CLEAR;
ffc1aa9c: 81 41 00 08 lwz r10,8(r1)
ffc1aaa0: 38 00 ff ff li r0,-1
rc = rtems_rfs_bitmap_load_map (control, &map);
if (rc > 0)
return rc;
elements = rtems_rfs_bitmap_elements (control->size);
ffc1aaa4: 39 08 ff ff addi r8,r8,-1
ffc1aaa8: 55 08 d9 7e rlwinm r8,r8,27,5,31
ffc1aaac: 39 28 00 01 addi r9,r8,1
control->free = elements;
for (e = 0; e < elements; e++)
map[e] = RTEMS_RFS_BITMAP_ELEMENT_CLEAR;
ffc1aab0: 38 e9 00 01 addi r7,r9,1
if (rc > 0)
return rc;
elements = rtems_rfs_bitmap_elements (control->size);
control->free = elements;
ffc1aab4: 91 3f 00 10 stw r9,16(r31)
for (e = 0; e < elements; e++)
map[e] = RTEMS_RFS_BITMAP_ELEMENT_CLEAR;
ffc1aab8: 7c e9 03 a6 mtctr r7
ffc1aabc: 48 00 00 10 b ffc1aacc <rtems_rfs_bitmap_map_clear_all+0x60>
return 0;
}
int
rtems_rfs_bitmap_map_clear_all (rtems_rfs_bitmap_control* control)
ffc1aac0: 55 67 10 3a rlwinm r7,r11,2,0,29
elements = rtems_rfs_bitmap_elements (control->size);
control->free = elements;
for (e = 0; e < elements; e++)
map[e] = RTEMS_RFS_BITMAP_ELEMENT_CLEAR;
ffc1aac4: 7c 0a 39 2e stwx r0,r10,r7
elements = rtems_rfs_bitmap_elements (control->size);
control->free = elements;
for (e = 0; e < elements; e++)
ffc1aac8: 39 6b 00 01 addi r11,r11,1
ffc1aacc: 42 00 ff f4 bdnz+ ffc1aac0 <rtems_rfs_bitmap_map_clear_all+0x54>
* 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)
ffc1aad0: 71 29 00 1f andi. r9,r9,31
ffc1aad4: 40 82 00 08 bne- ffc1aadc <rtems_rfs_bitmap_map_clear_all+0x70><== NEVER TAKEN
last_search_bit = rtems_rfs_bitmap_element_bits ();
ffc1aad8: 39 20 00 20 li r9,32
elements = rtems_rfs_bitmap_elements (elements);
ffc1aadc: 55 08 d9 7e rlwinm r8,r8,27,5,31
for (e = 0; e < (elements - 1); e++)
control->search_bits[e] = RTEMS_RFS_BITMAP_ELEMENT_CLEAR;
ffc1aae0: 39 48 00 01 addi r10,r8,1
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++)
ffc1aae4: 39 60 00 00 li r11,0
control->search_bits[e] = RTEMS_RFS_BITMAP_ELEMENT_CLEAR;
ffc1aae8: 7d 49 03 a6 mtctr r10
ffc1aaec: 38 00 ff ff li r0,-1
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++)
ffc1aaf0: 48 00 00 10 b ffc1ab00 <rtems_rfs_bitmap_map_clear_all+0x94>
control->search_bits[e] = RTEMS_RFS_BITMAP_ELEMENT_CLEAR;
ffc1aaf4: 55 67 10 3a rlwinm r7,r11,2,0,29 <== NOT EXECUTED
ffc1aaf8: 7c 0a 39 2e stwx r0,r10,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++)
ffc1aafc: 39 6b 00 01 addi r11,r11,1 <== NOT EXECUTED
ffc1ab00: 81 5f 00 14 lwz r10,20(r31)
ffc1ab04: 42 00 ff f0 bdnz+ ffc1aaf4 <rtems_rfs_bitmap_map_clear_all+0x88>
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);
ffc1ab08: 38 00 ff ff li r0,-1
ffc1ab0c: 21 29 00 20 subfic r9,r9,32
ffc1ab10: 7c 09 4c 30 srw r9,r0,r9
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] =
ffc1ab14: 55 08 10 3a rlwinm r8,r8,2,0,29
ffc1ab18: 7d 2a 41 2e stwx r9,r10,r8
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);
ffc1ab1c: 38 00 00 01 li r0,1
return 0;
ffc1ab20: 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);
ffc1ab24: 81 3f 00 00 lwz r9,0(r31)
ffc1ab28: 98 09 00 00 stb r0,0(r9)
return 0;
}
ffc1ab2c: 39 61 00 20 addi r11,r1,32
ffc1ab30: 4b fe 7f c8 b ffc02af8 <_restgpr_31_x>
ffc1a818 <rtems_rfs_bitmap_map_set>:
int
rtems_rfs_bitmap_map_set (rtems_rfs_bitmap_control* control,
rtems_rfs_bitmap_bit bit)
{
ffc1a818: 94 21 ff e0 stwu r1,-32(r1)
ffc1a81c: 7c 08 02 a6 mflr r0
ffc1a820: bf c1 00 18 stmw r30,24(r1)
ffc1a824: 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);
ffc1a828: 38 81 00 08 addi r4,r1,8
}
int
rtems_rfs_bitmap_map_set (rtems_rfs_bitmap_control* control,
rtems_rfs_bitmap_bit bit)
{
ffc1a82c: 90 01 00 24 stw r0,36(r1)
ffc1a830: 7c 7f 1b 78 mr r31,r3
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);
ffc1a834: 4b ff fd 45 bl ffc1a578 <rtems_rfs_bitmap_load_map>
if (rc > 0)
ffc1a838: 2c 03 00 00 cmpwi r3,0
ffc1a83c: 41 a1 00 78 bgt+ ffc1a8b4 <rtems_rfs_bitmap_map_set+0x9c><== NEVER TAKEN
return rc;
if (bit >= control->size)
ffc1a840: 80 1f 00 0c lwz r0,12(r31)
return EINVAL;
ffc1a844: 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)
ffc1a848: 7f 9e 00 40 cmplw cr7,r30,r0
ffc1a84c: 40 bc 00 68 bge+ cr7,ffc1a8b4 <rtems_rfs_bitmap_map_set+0x9c><== 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);
ffc1a850: 80 e1 00 08 lwz r7,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);
ffc1a854: 7f cb 2e 70 srawi r11,r30,5
offset = rtems_rfs_bitmap_map_offset (bit);
map[index] = rtems_rfs_bitmap_set (map[index], 1 << offset);
ffc1a858: 55 68 10 3a rlwinm r8,r11,2,0,29
rc = rtems_rfs_bitmap_load_map (control, &map);
if (rc > 0)
return rc;
if (bit >= control->size)
return EINVAL;
search_map = control->search_bits;
ffc1a85c: 81 3f 00 14 lwz r9,20(r31)
*/
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);
ffc1a860: 7c c7 40 2e lwzx r6,r7,r8
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);
ffc1a864: 57 ca 06 fe clrlwi r10,r30,27
map[index] = rtems_rfs_bitmap_set (map[index], 1 << offset);
ffc1a868: 38 00 00 01 li r0,1
ffc1a86c: 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);
ffc1a870: 7c ca 50 78 andc r10,r6,r10
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))
ffc1a874: 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);
ffc1a878: 7d 47 41 2e stwx r10,r7,r8
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;
ffc1a87c: 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))
ffc1a880: 40 9e 00 34 bne- cr7,ffc1a8b4 <rtems_rfs_bitmap_map_set+0x9c><== ALWAYS TAKEN
{
bit = index;
index = rtems_rfs_bitmap_map_index (bit);
ffc1a884: 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);
ffc1a888: 57 de 10 3a rlwinm r30,r30,2,0,29 <== 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);
ffc1a88c: 7d 49 f0 2e lwzx r10,r9,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);
ffc1a890: 55 6b 06 fe clrlwi r11,r11,27 <== NOT EXECUTED
search_map[index] = rtems_rfs_bitmap_set (search_map[index], 1 << offset);
ffc1a894: 7c 0b 58 30 slw r11,r0,r11 <== 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);
ffc1a898: 7d 4b 58 78 andc r11,r10,r11 <== 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);
ffc1a89c: 7d 69 f1 2e stwx r11,r9,r30 <== NOT EXECUTED
control->free--;
ffc1a8a0: 81 3f 00 10 lwz r9,16(r31) <== NOT EXECUTED
ffc1a8a4: 39 29 ff ff addi r9,r9,-1 <== NOT EXECUTED
ffc1a8a8: 91 3f 00 10 stw r9,16(r31) <== NOT EXECUTED
rtems_rfs_buffer_mark_dirty (control->buffer);
ffc1a8ac: 81 3f 00 00 lwz r9,0(r31) <== NOT EXECUTED
ffc1a8b0: 98 09 00 00 stb r0,0(r9) <== NOT EXECUTED
}
return 0;
}
ffc1a8b4: 39 61 00 20 addi r11,r1,32
ffc1a8b8: 4b fe 82 3c b ffc02af4 <_restgpr_30_x>
ffc1a9c8 <rtems_rfs_bitmap_map_set_all>:
int
rtems_rfs_bitmap_map_set_all (rtems_rfs_bitmap_control* control)
{
ffc1a9c8: 7c 2b 0b 78 mr r11,r1 <== NOT EXECUTED
ffc1a9cc: 94 21 ff e0 stwu r1,-32(r1) <== NOT EXECUTED
ffc1a9d0: 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);
ffc1a9d4: 38 81 00 08 addi r4,r1,8 <== NOT EXECUTED
return 0;
}
int
rtems_rfs_bitmap_map_set_all (rtems_rfs_bitmap_control* control)
{
ffc1a9d8: 4b fe 80 d5 bl ffc02aac <_savegpr_31> <== NOT EXECUTED
ffc1a9dc: 90 01 00 24 stw r0,36(r1) <== NOT EXECUTED
ffc1a9e0: 7c 7f 1b 78 mr r31,r3 <== NOT EXECUTED
rtems_rfs_bitmap_map map;
size_t elements;
int e;
int rc;
rc = rtems_rfs_bitmap_load_map (control, &map);
ffc1a9e4: 4b ff fb 95 bl ffc1a578 <rtems_rfs_bitmap_load_map> <== NOT EXECUTED
if (rc > 0)
ffc1a9e8: 2c 03 00 00 cmpwi r3,0 <== NOT EXECUTED
ffc1a9ec: 41 a1 00 78 bgt+ ffc1aa64 <rtems_rfs_bitmap_map_set_all+0x9c><== NOT EXECUTED
return rc;
elements = rtems_rfs_bitmap_elements (control->size);
ffc1a9f0: 81 7f 00 0c lwz r11,12(r31) <== NOT EXECUTED
control->free = 0;
ffc1a9f4: 38 00 00 00 li r0,0 <== NOT EXECUTED
ffc1a9f8: 90 1f 00 10 stw r0,16(r31) <== NOT EXECUTED
for (e = 0; e < elements; e++)
ffc1a9fc: 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);
ffc1aa00: 39 6b ff ff addi r11,r11,-1 <== NOT EXECUTED
ffc1aa04: 55 6b d9 7e rlwinm r11,r11,27,5,31 <== NOT EXECUTED
control->free = 0;
for (e = 0; e < elements; e++)
map[e] = RTEMS_RFS_BITMAP_ELEMENT_SET;
ffc1aa08: 81 41 00 08 lwz r10,8(r1) <== NOT EXECUTED
ffc1aa0c: 39 0b 00 02 addi r8,r11,2 <== NOT EXECUTED
ffc1aa10: 7d 09 03 a6 mtctr r8 <== NOT EXECUTED
ffc1aa14: 48 00 00 10 b ffc1aa24 <rtems_rfs_bitmap_map_set_all+0x5c><== NOT EXECUTED
*state = rtems_rfs_bitmap_test (map[index], bit);
return 0;
}
int
rtems_rfs_bitmap_map_set_all (rtems_rfs_bitmap_control* control)
ffc1aa18: 55 28 10 3a rlwinm r8,r9,2,0,29 <== NOT EXECUTED
elements = rtems_rfs_bitmap_elements (control->size);
control->free = 0;
for (e = 0; e < elements; e++)
map[e] = RTEMS_RFS_BITMAP_ELEMENT_SET;
ffc1aa1c: 7c 0a 41 2e stwx r0,r10,r8 <== NOT EXECUTED
elements = rtems_rfs_bitmap_elements (control->size);
control->free = 0;
for (e = 0; e < elements; e++)
ffc1aa20: 39 29 00 01 addi r9,r9,1 <== NOT EXECUTED
ffc1aa24: 42 00 ff f4 bdnz+ ffc1aa18 <rtems_rfs_bitmap_map_set_all+0x50><== NOT EXECUTED
map[e] = RTEMS_RFS_BITMAP_ELEMENT_SET;
elements = rtems_rfs_bitmap_elements (elements);
ffc1aa28: 55 6b d9 7e rlwinm r11,r11,27,5,31 <== NOT EXECUTED
for (e = 0; e < elements; e++)
control->search_bits[e] = RTEMS_RFS_BITMAP_ELEMENT_SET;
ffc1aa2c: 39 6b 00 02 addi r11,r11,2 <== 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++)
ffc1aa30: 39 20 00 00 li r9,0 <== NOT EXECUTED
control->search_bits[e] = RTEMS_RFS_BITMAP_ELEMENT_SET;
ffc1aa34: 7d 69 03 a6 mtctr r11 <== NOT EXECUTED
ffc1aa38: 38 00 00 00 li r0,0 <== NOT EXECUTED
ffc1aa3c: 48 00 00 14 b ffc1aa50 <rtems_rfs_bitmap_map_set_all+0x88><== NOT EXECUTED
ffc1aa40: 81 5f 00 14 lwz r10,20(r31) <== NOT EXECUTED
ffc1aa44: 55 2b 10 3a rlwinm r11,r9,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++)
ffc1aa48: 39 29 00 01 addi r9,r9,1 <== NOT EXECUTED
control->search_bits[e] = RTEMS_RFS_BITMAP_ELEMENT_SET;
ffc1aa4c: 7c 0a 59 2e stwx r0,r10,r11 <== 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++)
ffc1aa50: 42 00 ff f0 bdnz+ ffc1aa40 <rtems_rfs_bitmap_map_set_all+0x78><== NOT EXECUTED
control->search_bits[e] = RTEMS_RFS_BITMAP_ELEMENT_SET;
rtems_rfs_buffer_mark_dirty (control->buffer);
ffc1aa54: 81 3f 00 00 lwz r9,0(r31) <== NOT EXECUTED
ffc1aa58: 38 00 00 01 li r0,1 <== NOT EXECUTED
return 0;
ffc1aa5c: 38 60 00 00 li r3,0 <== 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);
ffc1aa60: 98 09 00 00 stb r0,0(r9) <== NOT EXECUTED
return 0;
}
ffc1aa64: 39 61 00 20 addi r11,r1,32 <== NOT EXECUTED
ffc1aa68: 4b fe 80 90 b ffc02af8 <_restgpr_31_x> <== NOT EXECUTED
ffc1a958 <rtems_rfs_bitmap_map_test>:
int
rtems_rfs_bitmap_map_test (rtems_rfs_bitmap_control* control,
rtems_rfs_bitmap_bit bit,
bool* state)
{
ffc1a958: 94 21 ff d8 stwu r1,-40(r1) <== NOT EXECUTED
ffc1a95c: 7c 08 02 a6 mflr r0 <== NOT EXECUTED
ffc1a960: bf a1 00 1c stmw r29,28(r1) <== NOT EXECUTED
ffc1a964: 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);
ffc1a968: 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)
{
ffc1a96c: 90 01 00 2c stw r0,44(r1) <== NOT EXECUTED
ffc1a970: 7c 7e 1b 78 mr r30,r3 <== NOT EXECUTED
ffc1a974: 7c bd 2b 78 mr r29,r5 <== NOT EXECUTED
rtems_rfs_bitmap_map map;
int index;
int rc;
rc = rtems_rfs_bitmap_load_map (control, &map);
ffc1a978: 4b ff fc 01 bl ffc1a578 <rtems_rfs_bitmap_load_map> <== NOT EXECUTED
if (rc > 0)
ffc1a97c: 2c 03 00 00 cmpwi r3,0 <== NOT EXECUTED
ffc1a980: 41 a1 00 40 bgt+ ffc1a9c0 <rtems_rfs_bitmap_map_test+0x68><== NOT EXECUTED
return rc;
if (bit >= control->size)
ffc1a984: 80 1e 00 0c lwz r0,12(r30) <== NOT EXECUTED
return EINVAL;
ffc1a988: 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)
ffc1a98c: 7f 9f 00 40 cmplw cr7,r31,r0 <== NOT EXECUTED
ffc1a990: 40 bc 00 30 bge+ cr7,ffc1a9c0 <rtems_rfs_bitmap_map_test+0x68><== 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);
ffc1a994: 39 20 00 01 li r9,1 <== 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);
ffc1a998: 7f e0 2e 70 srawi r0,r31,5 <== 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);
ffc1a99c: 7d 3f f8 30 slw r31,r9,r31 <== NOT EXECUTED
ffc1a9a0: 81 21 00 08 lwz r9,8(r1) <== NOT EXECUTED
if (rc > 0)
return rc;
if (bit >= control->size)
return EINVAL;
index = rtems_rfs_bitmap_map_index (bit);
*state = rtems_rfs_bitmap_test (map[index], bit);
ffc1a9a4: 54 00 10 3a rlwinm r0,r0,2,0,29 <== 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);
ffc1a9a8: 7c 09 00 2e lwzx r0,r9,r0 <== 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;
ffc1a9ac: 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);
ffc1a9b0: 7f e9 00 39 and. r9,r31,r0 <== NOT EXECUTED
ffc1a9b4: 7c 00 00 26 mfcr r0 <== NOT EXECUTED
ffc1a9b8: 54 00 1f fe rlwinm r0,r0,3,31,31 <== NOT EXECUTED
ffc1a9bc: 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;
}
ffc1a9c0: 39 61 00 28 addi r11,r1,40 <== NOT EXECUTED
ffc1a9c4: 4b fe 81 2c b ffc02af0 <_restgpr_29_x> <== NOT EXECUTED
ffc1a7e0 <rtems_rfs_bitmap_mask>:
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);
return mask;
}
ffc1a7e0: 38 00 ff ff li r0,-1 <== 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);
ffc1a7e4: 20 63 00 20 subfic r3,r3,32 <== NOT EXECUTED
return mask;
}
ffc1a7e8: 7c 03 1c 30 srw r3,r0,r3 <== NOT EXECUTED
ffc1a7ec: 4e 80 00 20 blr <== NOT EXECUTED
ffc1ad14 <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)
{
ffc1ad14: 7c 2b 0b 78 mr r11,r1
ffc1ad18: 7c 08 02 a6 mflr r0
ffc1ad1c: 94 21 ff f0 stwu r1,-16(r1)
ffc1ad20: 4b fe 7d 8d bl ffc02aac <_savegpr_31>
ffc1ad24: 90 01 00 14 stw r0,20(r1)
ffc1ad28: 7c 7f 1b 78 mr r31,r3
size_t elements = rtems_rfs_bitmap_elements (size);
control->buffer = buffer;
control->fs = fs;
control->block = block;
control->size = size;
ffc1ad2c: 90 c3 00 0c stw r6,12(r3)
rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* buffer,
size_t size,
rtems_rfs_buffer_block block)
{
size_t elements = rtems_rfs_bitmap_elements (size);
ffc1ad30: 38 c6 ff ff addi r6,r6,-1
control->buffer = buffer;
ffc1ad34: 90 a3 00 00 stw r5,0(r3)
control->fs = fs;
ffc1ad38: 90 83 00 04 stw r4,4(r3)
control->block = block;
ffc1ad3c: 90 e3 00 08 stw r7,8(r3)
control->size = size;
elements = rtems_rfs_bitmap_elements (elements);
ffc1ad40: 54 c3 c2 3a rlwinm r3,r6,24,8,29
control->search_bits = malloc (elements * sizeof (rtems_rfs_bitmap_element));
ffc1ad44: 38 63 00 04 addi r3,r3,4
ffc1ad48: 4b fe d3 0d bl ffc08054 <malloc>
if (!control->search_bits)
ffc1ad4c: 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));
ffc1ad50: 90 7f 00 14 stw r3,20(r31)
if (!control->search_bits)
ffc1ad54: 41 9e 00 1c beq- cr7,ffc1ad70 <rtems_rfs_bitmap_open+0x5c><== NEVER TAKEN
return ENOMEM;
return rtems_rfs_bitmap_create_search (control);
}
ffc1ad58: 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);
ffc1ad5c: 7f e3 fb 78 mr r3,r31
}
ffc1ad60: 83 e1 00 0c lwz r31,12(r1)
ffc1ad64: 38 21 00 10 addi r1,r1,16
ffc1ad68: 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);
ffc1ad6c: 4b ff fe b4 b ffc1ac20 <rtems_rfs_bitmap_create_search>
}
ffc1ad70: 39 61 00 10 addi r11,r1,16 <== NOT EXECUTED
ffc1ad74: 38 60 00 0c li r3,12 <== NOT EXECUTED
ffc1ad78: 4b fe 7d 80 b ffc02af8 <_restgpr_31_x> <== NOT EXECUTED
ffc1aefc <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)
{
ffc1aefc: 94 21 ff e0 stwu r1,-32(r1) <== NOT EXECUTED
ffc1af00: 7c 08 02 a6 mflr r0 <== NOT EXECUTED
ffc1af04: bf 61 00 0c stmw r27,12(r1) <== NOT EXECUTED
ffc1af08: 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);
ffc1af0c: 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)
{
ffc1af10: 90 01 00 24 stw r0,36(r1) <== NOT EXECUTED
ffc1af14: 7c 7d 1b 78 mr r29,r3 <== NOT EXECUTED
ffc1af18: 7c 9c 23 78 mr r28,r4 <== NOT EXECUTED
ffc1af1c: 7c be 2b 78 mr r30,r5 <== NOT EXECUTED
ffc1af20: 7c fb 3b 78 mr r27,r7 <== 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);
ffc1af24: 48 00 12 c5 bl ffc1c1e8 <rtems_rfs_buffer_handle_request><== NOT EXECUTED
if (rc > 0)
ffc1af28: 2c 03 00 00 cmpwi r3,0 <== NOT EXECUTED
ffc1af2c: 41 a1 00 98 bgt+ ffc1afc4 <rtems_rfs_block_find_indirect+0xc8><== NOT EXECUTED
return rc;
*result = rtems_rfs_block_get_number (buffer, offset);
ffc1af30: 81 3c 00 08 lwz r9,8(r28) <== NOT EXECUTED
ffc1af34: 57 eb 10 3a rlwinm r11,r31,2,0,29 <== NOT EXECUTED
ffc1af38: 81 49 00 24 lwz r10,36(r9) <== NOT EXECUTED
ffc1af3c: 7d 2a 5a 14 add r9,r10,r11 <== NOT EXECUTED
ffc1af40: 7c 0a 58 ae lbzx r0,r10,r11 <== NOT EXECUTED
ffc1af44: 89 09 00 03 lbz r8,3(r9) <== NOT EXECUTED
ffc1af48: 89 69 00 01 lbz r11,1(r9) <== NOT EXECUTED
ffc1af4c: 54 00 c0 0e rlwinm r0,r0,24,0,7 <== NOT EXECUTED
ffc1af50: 89 29 00 02 lbz r9,2(r9) <== NOT EXECUTED
ffc1af54: 7d 00 03 78 or r0,r8,r0 <== NOT EXECUTED
ffc1af58: 55 6b 80 1e rlwinm r11,r11,16,0,15 <== NOT EXECUTED
ffc1af5c: 7c 00 5b 78 or r0,r0,r11 <== NOT EXECUTED
ffc1af60: 55 29 40 2e rlwinm r9,r9,8,0,23 <== NOT EXECUTED
ffc1af64: 7c 00 4b 78 or r0,r0,r9 <== NOT EXECUTED
if ((*result + 1) == 0)
ffc1af68: 2f 80 ff ff cmpwi cr7,r0,-1 <== NOT EXECUTED
ffc1af6c: 40 be 00 08 bne+ cr7,ffc1af74 <rtems_rfs_block_find_indirect+0x78><== NOT EXECUTED
*result = 0;
ffc1af70: 38 00 00 00 li r0,0 <== NOT EXECUTED
if (*result >= rtems_rfs_fs_blocks (fs))
ffc1af74: 81 3d 00 04 lwz r9,4(r29) <== NOT EXECUTED
ffc1af78: 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)
ffc1af7c: 90 1b 00 00 stw r0,0(r27) <== NOT EXECUTED
*result = 0;
if (*result >= rtems_rfs_fs_blocks (fs))
ffc1af80: 7f 80 48 40 cmplw cr7,r0,r9 <== NOT EXECUTED
ffc1af84: 41 bc 00 40 blt+ cr7,ffc1afc4 <rtems_rfs_block_find_indirect+0xc8><== NOT EXECUTED
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BLOCK_FIND))
ffc1af88: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc1af8c: 38 80 10 00 li r4,4096 <== NOT EXECUTED
ffc1af90: 4b ff 83 75 bl ffc13304 <rtems_rfs_trace> <== NOT EXECUTED
ffc1af94: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc1af98: 41 be 00 20 beq+ cr7,ffc1afb8 <rtems_rfs_block_find_indirect+0xbc><== NOT EXECUTED
printf ("rtems-rfs: block-find: invalid block in table:"
ffc1af9c: 3c 60 ff c3 lis r3,-61 <== NOT EXECUTED
ffc1afa0: 80 9b 00 00 lwz r4,0(r27) <== NOT EXECUTED
ffc1afa4: 38 63 41 f7 addi r3,r3,16887 <== NOT EXECUTED
ffc1afa8: 7f c5 f3 78 mr r5,r30 <== NOT EXECUTED
ffc1afac: 7f e6 fb 78 mr r6,r31 <== NOT EXECUTED
ffc1afb0: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc1afb4: 48 00 7b 35 bl ffc22ae8 <printf> <== NOT EXECUTED
" block=%" PRId32 ", indirect=%" PRId32 "/%d\n", *result, block, offset);
*result = 0;
ffc1afb8: 38 00 00 00 li r0,0 <== NOT EXECUTED
ffc1afbc: 90 1b 00 00 stw r0,0(r27) <== NOT EXECUTED
ffc1afc0: 38 60 00 00 li r3,0 <== NOT EXECUTED
rc = EIO;
}
return 0;
}
ffc1afc4: 39 61 00 20 addi r11,r1,32 <== NOT EXECUTED
ffc1afc8: 4b fe 7b 20 b ffc02ae8 <_restgpr_27_x> <== NOT EXECUTED
ffc1b11c <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)
{
ffc1b11c: 94 21 ff e8 stwu r1,-24(r1) <== NOT EXECUTED
ffc1b120: 7c 08 02 a6 mflr r0 <== NOT EXECUTED
ffc1b124: bf 81 00 08 stmw r28,8(r1) <== NOT EXECUTED
ffc1b128: 7c be 2b 78 mr r30,r5 <== NOT EXECUTED
ffc1b12c: 7c df 33 78 mr r31,r6 <== NOT EXECUTED
ffc1b130: 90 01 00 1c stw r0,28(r1) <== NOT EXECUTED
if (pos == 0)
ffc1b134: 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)
{
ffc1b138: 7c fd 3b 78 mr r29,r7 <== NOT EXECUTED
if (pos == 0)
ffc1b13c: 40 a2 00 10 bne+ ffc1b14c <rtems_rfs_block_get_block_size+0x30><== 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;
ffc1b140: 90 07 00 00 stw r0,0(r7) <== NOT EXECUTED
size->offset = 0;
ffc1b144: 90 07 00 04 stw r0,4(r7) <== NOT EXECUTED
ffc1b148: 48 00 00 3c b ffc1b184 <rtems_rfs_block_get_block_size+0x68><== NOT EXECUTED
rtems_rfs_block_set_size_zero (size);
else
{
size->count = pos / rtems_rfs_fs_block_size (fs) + 1;
ffc1b14c: 83 83 00 08 lwz r28,8(r3) <== NOT EXECUTED
ffc1b150: 7c c4 33 78 mr r4,r6 <== NOT EXECUTED
ffc1b154: 7c a3 2b 78 mr r3,r5 <== NOT EXECUTED
ffc1b158: 7f 86 e3 78 mr r6,r28 <== NOT EXECUTED
ffc1b15c: 38 a0 00 00 li r5,0 <== NOT EXECUTED
ffc1b160: 48 01 4e e1 bl ffc30040 <__udivdi3> <== NOT EXECUTED
size->offset = pos % rtems_rfs_fs_block_size (fs);
ffc1b164: 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;
ffc1b168: 38 84 00 01 addi r4,r4,1 <== NOT EXECUTED
ffc1b16c: 90 9d 00 00 stw r4,0(r29) <== NOT EXECUTED
size->offset = pos % rtems_rfs_fs_block_size (fs);
ffc1b170: 38 a0 00 00 li r5,0 <== NOT EXECUTED
ffc1b174: 7f e4 fb 78 mr r4,r31 <== NOT EXECUTED
ffc1b178: 7f 86 e3 78 mr r6,r28 <== NOT EXECUTED
ffc1b17c: 48 01 52 b9 bl ffc30434 <__umoddi3> <== NOT EXECUTED
ffc1b180: 90 9d 00 04 stw r4,4(r29) <== NOT EXECUTED
}
}
ffc1b184: 39 61 00 18 addi r11,r1,24 <== NOT EXECUTED
ffc1b188: 4b fe 79 64 b ffc02aec <_restgpr_28_x> <== NOT EXECUTED
ffc1b390 <rtems_rfs_block_map_close>:
int
rtems_rfs_block_map_close (rtems_rfs_file_system* fs,
rtems_rfs_block_map* map)
{
ffc1b390: 94 21 ff e8 stwu r1,-24(r1)
ffc1b394: 7c 08 02 a6 mflr r0
ffc1b398: 90 01 00 1c stw r0,28(r1)
int rc = 0;
int brc;
if (map->dirty && map->inode)
ffc1b39c: 88 04 00 00 lbz r0,0(r4)
}
int
rtems_rfs_block_map_close (rtems_rfs_file_system* fs,
rtems_rfs_block_map* map)
{
ffc1b3a0: bf 81 00 08 stmw r28,8(r1)
ffc1b3a4: 7c 7e 1b 78 mr r30,r3
int rc = 0;
int brc;
if (map->dirty && map->inode)
ffc1b3a8: 2f 80 00 00 cmpwi cr7,r0,0
}
int
rtems_rfs_block_map_close (rtems_rfs_file_system* fs,
rtems_rfs_block_map* map)
{
ffc1b3ac: 7c 9f 23 78 mr r31,r4
int rc = 0;
ffc1b3b0: 3b a0 00 00 li r29,0
int brc;
if (map->dirty && map->inode)
ffc1b3b4: 41 9e 01 84 beq- cr7,ffc1b538 <rtems_rfs_block_map_close+0x1a8>
ffc1b3b8: 80 84 00 04 lwz r4,4(r4)
ffc1b3bc: 2f 84 00 00 cmpwi cr7,r4,0
ffc1b3c0: 41 9e 01 78 beq- cr7,ffc1b538 <rtems_rfs_block_map_close+0x1a8><== NEVER TAKEN
{
brc = rtems_rfs_inode_load (fs, map->inode);
ffc1b3c4: 4b ff 5e 79 bl ffc1123c <rtems_rfs_inode_load>
if (brc > 0)
ffc1b3c8: 2f 83 00 00 cmpwi cr7,r3,0
ffc1b3cc: 7c 7d 1b 78 mr r29,r3
ffc1b3d0: 41 bd 01 68 bgt+ cr7,ffc1b538 <rtems_rfs_block_map_close+0x1a8><== NEVER TAKEN
*/
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);
ffc1b3d4: 38 00 00 05 li r0,5
ffc1b3d8: 7c 09 03 a6 mtctr r0
ffc1b3dc: 39 20 00 01 li r9,1
ffc1b3e0: 39 40 00 00 li r10,0
ffc1b3e4: 39 00 00 01 li r8,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]);
ffc1b3e8: 81 7f 00 04 lwz r11,4(r31)
return rc;
}
int
rtems_rfs_block_map_close (rtems_rfs_file_system* fs,
ffc1b3ec: 7c ff 4a 14 add r7,r31,r9
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]);
ffc1b3f0: 80 07 00 23 lwz r0,35(r7)
* @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);
ffc1b3f4: 38 ea 00 04 addi r7,r10,4
ffc1b3f8: 80 cb 00 0c lwz r6,12(r11)
ffc1b3fc: 54 e7 10 3a rlwinm r7,r7,2,0,29
if (rc == 0)
{
int b;
for (b = 0; b < RTEMS_RFS_INODE_BLOCKS; b++)
ffc1b400: 39 4a 00 01 addi r10,r10,1
ffc1b404: 7c e6 3a 14 add r7,r6,r7
ffc1b408: 54 06 46 3e rlwinm r6,r0,8,24,31
ffc1b40c: 98 c7 00 0c stb r6,12(r7)
ffc1b410: 54 06 84 3e rlwinm r6,r0,16,16,31
ffc1b414: 80 eb 00 0c lwz r7,12(r11)
ffc1b418: 7c e7 4a 14 add r7,r7,r9
ffc1b41c: 98 c7 00 1c stb r6,28(r7)
ffc1b420: 54 06 c2 3e rlwinm r6,r0,24,8,31
ffc1b424: 80 eb 00 0c lwz r7,12(r11)
ffc1b428: 7c e7 4a 14 add r7,r7,r9
ffc1b42c: 98 c7 00 1d stb r6,29(r7)
ffc1b430: 80 eb 00 0c lwz r7,12(r11)
ffc1b434: 7c e7 4a 14 add r7,r7,r9
ffc1b438: 98 07 00 1e stb r0,30(r7)
ffc1b43c: 39 29 00 04 addi r9,r9,4
rtems_rfs_buffer_mark_dirty (&handle->buffer);
ffc1b440: 38 00 00 01 li r0,1
ffc1b444: 99 0b 00 10 stb r8,16(r11)
ffc1b448: 42 00 ff a0 bdnz+ ffc1b3e8 <rtems_rfs_block_map_close+0x58>
rtems_rfs_inode_set_block (map->inode, b, map->blocks[b]);
rtems_rfs_inode_set_block_count (map->inode, map->size.count);
ffc1b44c: 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);
ffc1b450: 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);
ffc1b454: 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);
ffc1b458: 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);
ffc1b45c: 81 49 00 0c lwz r10,12(r9)
ffc1b460: 55 68 46 3e rlwinm r8,r11,8,24,31
ffc1b464: 99 0a 00 0c stb r8,12(r10)
ffc1b468: 55 68 84 3e rlwinm r8,r11,16,16,31
ffc1b46c: 81 49 00 0c lwz r10,12(r9)
ffc1b470: 99 0a 00 0d stb r8,13(r10)
ffc1b474: 55 68 c2 3e rlwinm r8,r11,24,8,31
ffc1b478: 81 49 00 0c lwz r10,12(r9)
ffc1b47c: 99 0a 00 0e stb r8,14(r10)
ffc1b480: 81 49 00 0c lwz r10,12(r9)
ffc1b484: 99 6a 00 0f stb r11,15(r10)
rtems_rfs_buffer_mark_dirty (&handle->buffer);
ffc1b488: 98 09 00 10 stb r0,16(r9)
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);
ffc1b48c: 81 3f 00 04 lwz r9,4(r31)
ffc1b490: 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);
ffc1b494: 81 49 00 0c lwz r10,12(r9)
ffc1b498: 55 68 c2 3e rlwinm r8,r11,24,8,31
ffc1b49c: 99 0a 00 0a stb r8,10(r10)
ffc1b4a0: 81 49 00 0c lwz r10,12(r9)
ffc1b4a4: 99 6a 00 0b stb r11,11(r10)
rtems_rfs_buffer_mark_dirty (&handle->buffer);
ffc1b4a8: 98 09 00 10 stb r0,16(r9)
rtems_rfs_inode_set_last_map_block (map->inode, map->last_map_block);
ffc1b4ac: 81 3f 00 04 lwz r9,4(r31)
ffc1b4b0: 81 7f 00 1c lwz r11,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);
ffc1b4b4: 81 49 00 0c lwz r10,12(r9)
ffc1b4b8: 55 68 46 3e rlwinm r8,r11,8,24,31
ffc1b4bc: 99 0a 00 30 stb r8,48(r10)
ffc1b4c0: 55 68 84 3e rlwinm r8,r11,16,16,31
ffc1b4c4: 81 49 00 0c lwz r10,12(r9)
ffc1b4c8: 99 0a 00 31 stb r8,49(r10)
ffc1b4cc: 55 68 c2 3e rlwinm r8,r11,24,8,31
ffc1b4d0: 81 49 00 0c lwz r10,12(r9)
ffc1b4d4: 99 0a 00 32 stb r8,50(r10)
ffc1b4d8: 81 49 00 0c lwz r10,12(r9)
ffc1b4dc: 99 6a 00 33 stb r11,51(r10)
rtems_rfs_buffer_mark_dirty (&handle->buffer);
ffc1b4e0: 98 09 00 10 stb r0,16(r9)
rtems_rfs_inode_set_last_data_block (map->inode, map->last_data_block);
ffc1b4e4: 81 3f 00 04 lwz r9,4(r31)
ffc1b4e8: 81 7f 00 20 lwz r11,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);
ffc1b4ec: 81 49 00 0c lwz r10,12(r9)
ffc1b4f0: 55 68 46 3e rlwinm r8,r11,8,24,31
ffc1b4f4: 99 0a 00 34 stb r8,52(r10)
ffc1b4f8: 55 68 84 3e rlwinm r8,r11,16,16,31
ffc1b4fc: 81 49 00 0c lwz r10,12(r9)
ffc1b500: 99 0a 00 35 stb r8,53(r10)
ffc1b504: 55 68 c2 3e rlwinm r8,r11,24,8,31
ffc1b508: 81 49 00 0c lwz r10,12(r9)
ffc1b50c: 99 0a 00 36 stb r8,54(r10)
ffc1b510: 81 49 00 0c lwz r10,12(r9)
ffc1b514: 99 6a 00 37 stb r11,55(r10)
rtems_rfs_buffer_mark_dirty (&handle->buffer);
ffc1b518: 98 09 00 10 stb r0,16(r9)
brc = rtems_rfs_inode_unload (fs, map->inode, true);
ffc1b51c: 80 9f 00 04 lwz r4,4(r31)
ffc1b520: 4b ff 5e c5 bl ffc113e4 <rtems_rfs_inode_unload>
ffc1b524: 7c 60 18 f8 not r0,r3
ffc1b528: 7c 00 fe 70 srawi r0,r0,31
ffc1b52c: 7c 7d 00 38 and r29,r3,r0
if (brc > 0)
rc = brc;
map->dirty = false;
ffc1b530: 38 00 00 00 li r0,0
ffc1b534: 98 1f 00 00 stb r0,0(r31)
}
}
map->inode = NULL;
ffc1b538: 3b 80 00 00 li r28,0
ffc1b53c: 93 9f 00 04 stw r28,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);
ffc1b540: 38 9f 00 38 addi r4,r31,56
ffc1b544: 7f c3 f3 78 mr r3,r30
ffc1b548: 48 00 0a c1 bl ffc1c008 <rtems_rfs_buffer_handle_release>
handle->dirty = false;
ffc1b54c: 9b 9f 00 38 stb r28,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);
ffc1b550: 7f c3 f3 78 mr r3,r30
handle->dirty = false;
handle->bnum = 0;
ffc1b554: 93 9f 00 3c stw r28,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);
ffc1b558: 38 9f 00 44 addi r4,r31,68
handle->dirty = false;
handle->bnum = 0;
handle->buffer = NULL;
ffc1b55c: 93 9f 00 40 stw r28,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);
ffc1b560: 48 00 0a a9 bl ffc1c008 <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;
}
ffc1b564: 39 61 00 18 addi r11,r1,24
ffc1b568: 7f a3 eb 78 mr r3,r29
handle->dirty = false;
ffc1b56c: 9b 9f 00 44 stb r28,68(r31)
handle->bnum = 0;
ffc1b570: 93 9f 00 48 stw r28,72(r31)
handle->buffer = NULL;
ffc1b574: 93 9f 00 4c stw r28,76(r31)
ffc1b578: 4b fe 75 74 b ffc02aec <_restgpr_28_x>
ffc1b57c <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)
{
ffc1b57c: 94 21 ff d0 stwu r1,-48(r1)
ffc1b580: 7c 08 02 a6 mflr r0
ffc1b584: 90 01 00 34 stw r0,52(r1)
int rc = 0;
*block = 0;
ffc1b588: 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)
{
ffc1b58c: bf 61 00 1c stmw r27,28(r1)
ffc1b590: 7c 7d 1b 78 mr r29,r3
ffc1b594: 7c 9f 23 78 mr r31,r4
int rc = 0;
*block = 0;
ffc1b598: 90 06 00 00 stw r0,0(r6)
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)
{
ffc1b59c: 7c bc 2b 78 mr r28,r5
ffc1b5a0: 7c de 33 78 mr r30,r6
*block = 0;
/*
* Range checking here makes the remaining logic simpler.
*/
if (rtems_rfs_block_pos_block_past_end (bpos, &map->size))
ffc1b5a4: 83 65 00 00 lwz r27,0(r5)
ffc1b5a8: 80 04 00 08 lwz r0,8(r4)
ffc1b5ac: 2f 9b 00 00 cmpwi cr7,r27,0
ffc1b5b0: 41 9e 00 10 beq- cr7,ffc1b5c0 <rtems_rfs_block_map_find+0x44>
ffc1b5b4: 2f 80 00 00 cmpwi cr7,r0,0
return ENXIO;
ffc1b5b8: 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))
ffc1b5bc: 41 be 01 18 beq+ cr7,ffc1b6d4 <rtems_rfs_block_map_find+0x158><== NEVER TAKEN
ffc1b5c0: 7f 9b 00 40 cmplw cr7,r27,r0
return ENXIO;
ffc1b5c4: 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))
ffc1b5c8: 40 bc 01 0c bge+ cr7,ffc1b6d4 <rtems_rfs_block_map_find+0x158>
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))
ffc1b5cc: 81 3f 00 10 lwz r9,16(r31)
ffc1b5d0: 7f 9b 48 00 cmpw cr7,r27,r9
ffc1b5d4: 40 be 00 18 bne+ cr7,ffc1b5ec <rtems_rfs_block_map_find+0x70><== NEVER TAKEN
ffc1b5d8: 81 3f 00 18 lwz r9,24(r31)
ffc1b5dc: 2f 89 00 00 cmpwi cr7,r9,0
ffc1b5e0: 41 9e 00 0c beq- cr7,ffc1b5ec <rtems_rfs_block_map_find+0x70><== ALWAYS TAKEN
{
*block = map->bpos.block;
ffc1b5e4: 91 3e 00 00 stw r9,0(r30) <== NOT EXECUTED
ffc1b5e8: 48 00 00 c8 b ffc1b6b0 <rtems_rfs_block_map_find+0x134><== NOT EXECUTED
/*
* 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)
ffc1b5ec: 2b 80 00 05 cmplwi cr7,r0,5
ffc1b5f0: 41 9d 00 1c bgt- cr7,ffc1b60c <rtems_rfs_block_map_find+0x90><== NEVER TAKEN
{
*block = map->blocks[bpos->bno];
ffc1b5f4: 3b 7b 00 08 addi r27,r27,8
ffc1b5f8: 57 7b 10 3a rlwinm r27,r27,2,0,29
ffc1b5fc: 7f 7f da 14 add r27,r31,r27
ffc1b600: 80 1b 00 04 lwz r0,4(r27)
ffc1b604: 90 1e 00 00 stw r0,0(r30)
ffc1b608: 48 00 00 a8 b ffc1b6b0 <rtems_rfs_block_map_find+0x134>
* 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;
ffc1b60c: 80 dd 00 30 lwz r6,48(r29) <== NOT EXECUTED
ffc1b610: 7d 7b 33 96 divwu r11,r27,r6 <== NOT EXECUTED
ffc1b614: 7d 2b 31 d6 mullw r9,r11,r6 <== NOT EXECUTED
singly = bpos->bno / fs->blocks_per_block;
ffc1b618: 91 61 00 08 stw r11,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;
ffc1b61c: 7f 69 d8 50 subf r27,r9,r27 <== NOT EXECUTED
singly = bpos->bno / fs->blocks_per_block;
if (map->size.count <= fs->block_map_singly_blocks)
ffc1b620: 81 3d 00 34 lwz r9,52(r29) <== NOT EXECUTED
ffc1b624: 7f 80 48 40 cmplw cr7,r0,r9 <== NOT EXECUTED
ffc1b628: 41 bd 00 20 bgt+ cr7,ffc1b648 <rtems_rfs_block_map_find+0xcc><== NOT EXECUTED
{
/*
* This is a single indirect table of blocks anchored off a slot in the
* inode.
*/
rc = rtems_rfs_block_find_indirect (fs,
ffc1b62c: 38 cb 00 08 addi r6,r11,8 <== NOT EXECUTED
ffc1b630: 54 c6 10 3a rlwinm r6,r6,2,0,29 <== NOT EXECUTED
ffc1b634: 7c df 32 14 add r6,r31,r6 <== NOT EXECUTED
ffc1b638: 7f a3 eb 78 mr r3,r29 <== NOT EXECUTED
ffc1b63c: 80 a6 00 04 lwz r5,4(r6) <== NOT EXECUTED
ffc1b640: 38 9f 00 38 addi r4,r31,56 <== NOT EXECUTED
ffc1b644: 48 00 00 58 b ffc1b69c <rtems_rfs_block_map_find+0x120><== NOT EXECUTED
* The map is doubly indirect.
*/
rtems_rfs_block_no doubly;
doubly = singly / fs->blocks_per_block;
singly %= fs->blocks_per_block;
ffc1b648: 7d 2b 33 96 divwu r9,r11,r6 <== NOT EXECUTED
ffc1b64c: 7c c9 31 d6 mullw r6,r9,r6 <== NOT EXECUTED
{
/*
* This should never happen. Here so Joel can remove once his coverage
* testing gets to the file systems.
*/
rc = ENXIO;
ffc1b650: 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;
ffc1b654: 7c c6 58 50 subf r6,r6,r11 <== NOT EXECUTED
if (map->size.count < fs->block_map_doubly_blocks)
ffc1b658: 81 7d 00 38 lwz r11,56(r29) <== NOT EXECUTED
* The map is doubly indirect.
*/
rtems_rfs_block_no doubly;
doubly = singly / fs->blocks_per_block;
singly %= fs->blocks_per_block;
ffc1b65c: 90 c1 00 08 stw r6,8(r1) <== NOT EXECUTED
if (map->size.count < fs->block_map_doubly_blocks)
ffc1b660: 7f 80 58 40 cmplw cr7,r0,r11 <== NOT EXECUTED
ffc1b664: 40 bc 00 70 bge+ cr7,ffc1b6d4 <rtems_rfs_block_map_find+0x158><== NOT EXECUTED
{
rc = rtems_rfs_block_find_indirect (fs,
ffc1b668: 39 29 00 08 addi r9,r9,8 <== NOT EXECUTED
ffc1b66c: 55 29 10 3a rlwinm r9,r9,2,0,29 <== NOT EXECUTED
ffc1b670: 7d 3f 4a 14 add r9,r31,r9 <== NOT EXECUTED
ffc1b674: 80 a9 00 04 lwz r5,4(r9) <== NOT EXECUTED
ffc1b678: 7f a3 eb 78 mr r3,r29 <== NOT EXECUTED
ffc1b67c: 38 9f 00 44 addi r4,r31,68 <== NOT EXECUTED
ffc1b680: 38 e1 00 08 addi r7,r1,8 <== NOT EXECUTED
ffc1b684: 4b ff f8 79 bl ffc1aefc <rtems_rfs_block_find_indirect><== NOT EXECUTED
&map->doubly_buffer,
map->blocks[doubly],
singly, &singly);
if (rc == 0)
ffc1b688: 2c 03 00 00 cmpwi r3,0 <== NOT EXECUTED
ffc1b68c: 40 a2 00 48 bne+ ffc1b6d4 <rtems_rfs_block_map_find+0x158><== NOT EXECUTED
{
rc = rtems_rfs_block_find_indirect (fs,
ffc1b690: 80 a1 00 08 lwz r5,8(r1) <== NOT EXECUTED
ffc1b694: 7f a3 eb 78 mr r3,r29 <== NOT EXECUTED
ffc1b698: 38 9f 00 38 addi r4,r31,56 <== NOT EXECUTED
ffc1b69c: 7f 66 db 78 mr r6,r27 <== NOT EXECUTED
ffc1b6a0: 7f c7 f3 78 mr r7,r30 <== NOT EXECUTED
ffc1b6a4: 4b ff f8 59 bl ffc1aefc <rtems_rfs_block_find_indirect><== NOT EXECUTED
}
}
}
}
if (rc == 0)
ffc1b6a8: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc1b6ac: 40 be 00 28 bne+ cr7,ffc1b6d4 <rtems_rfs_block_map_find+0x158><== NOT EXECUTED
{
rtems_rfs_block_copy_bpos (&map->bpos, bpos);
ffc1b6b0: 80 1c 00 00 lwz r0,0(r28)
map->bpos.block = *block;
ffc1b6b4: 38 60 00 00 li r3,0
}
}
if (rc == 0)
{
rtems_rfs_block_copy_bpos (&map->bpos, bpos);
ffc1b6b8: 90 1f 00 10 stw r0,16(r31)
ffc1b6bc: 80 1c 00 04 lwz r0,4(r28)
ffc1b6c0: 90 1f 00 14 stw r0,20(r31)
ffc1b6c4: 80 1c 00 08 lwz r0,8(r28)
ffc1b6c8: 90 1f 00 18 stw r0,24(r31)
map->bpos.block = *block;
ffc1b6cc: 80 1e 00 00 lwz r0,0(r30)
ffc1b6d0: 90 1f 00 18 stw r0,24(r31)
}
return rc;
}
ffc1b6d4: 39 61 00 30 addi r11,r1,48
ffc1b6d8: 4b fe 74 10 b ffc02ae8 <_restgpr_27_x>
ffc1b7ac <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)
{
ffc1b7ac: 94 21 ff b8 stwu r1,-72(r1)
ffc1b7b0: 7c 08 02 a6 mflr r0
ffc1b7b4: be 81 00 18 stmw r20,24(r1)
ffc1b7b8: 7c 7e 1b 78 mr r30,r3
ffc1b7bc: 7c 9f 23 78 mr r31,r4
int b;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BLOCK_MAP_GROW))
ffc1b7c0: 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)
{
ffc1b7c4: 90 01 00 4c stw r0,76(r1)
int b;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BLOCK_MAP_GROW))
ffc1b7c8: 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)
{
ffc1b7cc: 7c b7 2b 78 mr r23,r5
ffc1b7d0: 7c d5 33 78 mr r21,r6
int b;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BLOCK_MAP_GROW))
ffc1b7d4: 4b ff 7b 31 bl ffc13304 <rtems_rfs_trace>
ffc1b7d8: 2f 83 00 00 cmpwi cr7,r3,0
ffc1b7dc: 41 be 00 1c beq+ cr7,ffc1b7f8 <rtems_rfs_block_map_grow+0x4c><== ALWAYS TAKEN
printf ("rtems-rfs: block-map-grow: entry: blocks=%zd count=%" PRIu32 "\n",
ffc1b7e0: 3c 60 ff c3 lis r3,-61 <== NOT EXECUTED
ffc1b7e4: 80 bf 00 08 lwz r5,8(r31) <== NOT EXECUTED
ffc1b7e8: 38 63 42 42 addi r3,r3,16962 <== NOT EXECUTED
ffc1b7ec: 7e e4 bb 78 mr r4,r23 <== NOT EXECUTED
ffc1b7f0: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc1b7f4: 48 00 72 f5 bl ffc22ae8 <printf> <== NOT EXECUTED
blocks, map->size.count);
if ((map->size.count + blocks) >= rtems_rfs_fs_max_block_map_blocks (fs))
ffc1b7f8: 81 3f 00 08 lwz r9,8(r31)
return EFBIG;
ffc1b7fc: 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))
ffc1b800: 80 1e 00 38 lwz r0,56(r30)
ffc1b804: 7d 37 4a 14 add r9,r23,r9
ffc1b808: 7f 89 00 40 cmplw cr7,r9,r0
ffc1b80c: 40 bc 03 24 bge+ cr7,ffc1bb30 <rtems_rfs_block_map_grow+0x384><== NEVER TAKEN
map->last_map_block = new_block;
return 0;
}
int
rtems_rfs_block_map_grow (rtems_rfs_file_system* fs,
ffc1b810: 3b 60 00 00 li r27,0
return rc;
}
}
}
rtems_rfs_block_set_number (&map->singly_buffer, direct, block);
ffc1b814: 3b 00 00 01 li r24,1
singly,
singly_block);
}
else
{
rc = rtems_rfs_buffer_handle_request (fs,
ffc1b818: 3b 3f 00 44 addi r25,r31,68
}
singly_block = rtems_rfs_block_get_number (&map->doubly_buffer,
singly);
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
ffc1b81c: 3b 9f 00 38 addi r28,r31,56
ffc1b820: 48 00 03 04 b ffc1bb24 <rtems_rfs_block_map_grow+0x378>
/*
* 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,
ffc1b824: 80 9f 00 20 lwz r4,32(r31)
ffc1b828: 7f c3 f3 78 mr r3,r30
ffc1b82c: 38 a0 00 00 li r5,0
ffc1b830: 38 c1 00 0c addi r6,r1,12
ffc1b834: 4b ff 55 5d bl ffc10d90 <rtems_rfs_group_bitmap_alloc>
false, &block);
if (rc > 0)
ffc1b838: 7c 74 1b 79 mr. r20,r3
ffc1b83c: 41 81 02 f4 bgt- ffc1bb30 <rtems_rfs_block_map_grow+0x384>
return rc;
if (map->size.count < RTEMS_RFS_INODE_BLOCKS)
ffc1b840: 80 ff 00 08 lwz r7,8(r31)
ffc1b844: 2b 87 00 04 cmplwi cr7,r7,4
ffc1b848: 41 9d 00 1c bgt- cr7,ffc1b864 <rtems_rfs_block_map_grow+0xb8>
map->blocks[map->size.count] = block;
ffc1b84c: 38 e7 00 08 addi r7,r7,8
ffc1b850: 80 01 00 0c lwz r0,12(r1)
ffc1b854: 54 e7 10 3a rlwinm r7,r7,2,0,29
ffc1b858: 7c ff 3a 14 add r7,r31,r7
ffc1b85c: 90 07 00 04 stw r0,4(r7)
ffc1b860: 48 00 02 94 b ffc1baf4 <rtems_rfs_block_map_grow+0x348>
* 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;
ffc1b864: 83 5e 00 30 lwz r26,48(r30)
singly = map->size.count / fs->blocks_per_block;
if (map->size.count < fs->block_map_singly_blocks)
ffc1b868: 80 1e 00 34 lwz r0,52(r30)
* 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;
ffc1b86c: 7c c7 d3 96 divwu r6,r7,r26
singly = map->size.count / fs->blocks_per_block;
if (map->size.count < fs->block_map_singly_blocks)
ffc1b870: 7f 87 00 40 cmplw cr7,r7,r0
* 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;
ffc1b874: 7e c6 d1 d6 mullw r22,r6,r26
ffc1b878: 7e d6 38 51 subf. r22,r22,r7
singly = map->size.count / fs->blocks_per_block;
if (map->size.count < fs->block_map_singly_blocks)
ffc1b87c: 40 9c 00 78 bge- cr7,ffc1b8f4 <rtems_rfs_block_map_grow+0x148>
* 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) ||
ffc1b880: 41 82 00 14 beq- ffc1b894 <rtems_rfs_block_map_grow+0xe8>
ffc1b884: 2f 86 00 00 cmpwi cr7,r6,0
ffc1b888: 40 9e 00 3c bne- cr7,ffc1b8c4 <rtems_rfs_block_map_grow+0x118>
((singly == 0) && (direct == RTEMS_RFS_INODE_BLOCKS)))
ffc1b88c: 2f 96 00 05 cmpwi cr7,r22,5
ffc1b890: 40 be 00 34 bne+ cr7,ffc1b8c4 <rtems_rfs_block_map_grow+0x118>
/*
* 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,
ffc1b894: 38 c6 00 08 addi r6,r6,8
ffc1b898: 54 c6 10 3a rlwinm r6,r6,2,0,29
ffc1b89c: 68 e7 00 05 xori r7,r7,5
ffc1b8a0: 7c df 32 14 add r6,r31,r6
ffc1b8a4: 7c e7 00 34 cntlzw r7,r7
ffc1b8a8: 7f c3 f3 78 mr r3,r30
ffc1b8ac: 7f e4 fb 78 mr r4,r31
ffc1b8b0: 7f 85 e3 78 mr r5,r28
ffc1b8b4: 38 c6 00 04 addi r6,r6,4
ffc1b8b8: 54 e7 d9 7e rlwinm r7,r7,27,5,31
ffc1b8bc: 4b ff f4 e9 bl ffc1ada4 <rtems_rfs_block_map_indirect_alloc>
ffc1b8c0: 48 00 00 24 b ffc1b8e4 <rtems_rfs_block_map_grow+0x138>
&map->blocks[singly],
upping);
}
else
{
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
ffc1b8c4: 3b 46 00 08 addi r26,r6,8
ffc1b8c8: 57 5a 10 3a rlwinm r26,r26,2,0,29
ffc1b8cc: 7f 5f d2 14 add r26,r31,r26
ffc1b8d0: 80 ba 00 04 lwz r5,4(r26)
ffc1b8d4: 7f c3 f3 78 mr r3,r30
ffc1b8d8: 7f 84 e3 78 mr r4,r28
ffc1b8dc: 38 c0 00 01 li r6,1
ffc1b8e0: 48 00 09 09 bl ffc1c1e8 <rtems_rfs_buffer_handle_request>
map->blocks[singly], true);
}
if (rc > 0)
ffc1b8e4: 2f 83 00 00 cmpwi cr7,r3,0
&map->blocks[singly],
upping);
}
else
{
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
ffc1b8e8: 7c 74 1b 78 mr r20,r3
map->blocks[singly], true);
}
if (rc > 0)
ffc1b8ec: 40 bd 01 b0 ble+ cr7,ffc1ba9c <rtems_rfs_block_map_grow+0x2f0><== ALWAYS TAKEN
ffc1b8f0: 48 00 01 98 b ffc1ba88 <rtems_rfs_block_map_grow+0x2dc><== 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;
ffc1b8f4: 7f a6 d3 96 divwu r29,r6,r26
singly %= fs->blocks_per_block;
ffc1b8f8: 7f 5d d1 d6 mullw r26,r29,r26
ffc1b8fc: 7f 5a 30 50 subf r26,r26,r6
* 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)
ffc1b900: 40 82 01 0c bne- ffc1ba0c <rtems_rfs_block_map_grow+0x260>
{
rc = rtems_rfs_block_map_indirect_alloc (fs, map,
ffc1b904: 7f c3 f3 78 mr r3,r30
ffc1b908: 7f e4 fb 78 mr r4,r31
ffc1b90c: 7f 85 e3 78 mr r5,r28
ffc1b910: 38 c1 00 08 addi r6,r1,8
ffc1b914: 38 e0 00 00 li r7,0
ffc1b918: 4b ff f4 8d bl ffc1ada4 <rtems_rfs_block_map_indirect_alloc>
&map->singly_buffer,
&singly_block,
false);
if (rc > 0)
ffc1b91c: 7c 74 1b 79 mr. r20,r3
ffc1b920: 41 81 01 68 bgt- ffc1ba88 <rtems_rfs_block_map_grow+0x2dc><== NEVER TAKEN
/*
* 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) ||
ffc1b924: 2f 9a 00 00 cmpwi cr7,r26,0
ffc1b928: 41 9e 00 14 beq- cr7,ffc1b93c <rtems_rfs_block_map_grow+0x190><== NEVER TAKEN
ffc1b92c: 2f 9d 00 00 cmpwi cr7,r29,0
ffc1b930: 40 9e 00 44 bne- cr7,ffc1b974 <rtems_rfs_block_map_grow+0x1c8><== NEVER TAKEN
((doubly == 0) && (singly == RTEMS_RFS_INODE_BLOCKS)))
ffc1b934: 2f 9a 00 05 cmpwi cr7,r26,5
ffc1b938: 40 be 00 3c bne+ cr7,ffc1b974 <rtems_rfs_block_map_grow+0x1c8>
{
bool upping;
upping = map->size.count == fs->block_map_singly_blocks;
ffc1b93c: 80 ff 00 08 lwz r7,8(r31)
rc = rtems_rfs_block_map_indirect_alloc (fs, map,
ffc1b940: 38 dd 00 08 addi r6,r29,8
*/
if ((singly == 0) ||
((doubly == 0) && (singly == RTEMS_RFS_INODE_BLOCKS)))
{
bool upping;
upping = map->size.count == fs->block_map_singly_blocks;
ffc1b944: 80 1e 00 34 lwz r0,52(r30)
rc = rtems_rfs_block_map_indirect_alloc (fs, map,
ffc1b948: 54 c6 10 3a rlwinm r6,r6,2,0,29
ffc1b94c: 7c df 32 14 add r6,r31,r6
ffc1b950: 7c e7 02 78 xor r7,r7,r0
ffc1b954: 7c e7 00 34 cntlzw r7,r7
ffc1b958: 7f c3 f3 78 mr r3,r30
ffc1b95c: 7f e4 fb 78 mr r4,r31
ffc1b960: 7f 25 cb 78 mr r5,r25
ffc1b964: 38 c6 00 04 addi r6,r6,4
ffc1b968: 54 e7 d9 7e rlwinm r7,r7,27,5,31
ffc1b96c: 4b ff f4 39 bl ffc1ada4 <rtems_rfs_block_map_indirect_alloc>
ffc1b970: 48 00 00 24 b ffc1b994 <rtems_rfs_block_map_grow+0x1e8>
return rc;
}
}
else
{
rc = rtems_rfs_buffer_handle_request (fs, &map->doubly_buffer,
ffc1b974: 3b bd 00 08 addi r29,r29,8
ffc1b978: 57 bd 10 3a rlwinm r29,r29,2,0,29
ffc1b97c: 7f bf ea 14 add r29,r31,r29
ffc1b980: 80 bd 00 04 lwz r5,4(r29)
ffc1b984: 7f c3 f3 78 mr r3,r30
ffc1b988: 7f 24 cb 78 mr r4,r25
ffc1b98c: 38 c0 00 01 li r6,1
ffc1b990: 48 00 08 59 bl ffc1c1e8 <rtems_rfs_buffer_handle_request>
map->blocks[doubly], true);
if (rc > 0)
ffc1b994: 7c 74 1b 79 mr. r20,r3
ffc1b998: 40 a1 00 18 ble+ ffc1b9b0 <rtems_rfs_block_map_grow+0x204><== ALWAYS TAKEN
{
rtems_rfs_group_bitmap_free (fs, false, singly_block);
ffc1b99c: 80 a1 00 08 lwz r5,8(r1) <== NOT EXECUTED
ffc1b9a0: 7f c3 f3 78 mr r3,r30 <== NOT EXECUTED
ffc1b9a4: 38 80 00 00 li r4,0 <== NOT EXECUTED
ffc1b9a8: 4b ff 55 e1 bl ffc10f88 <rtems_rfs_group_bitmap_free> <== NOT EXECUTED
ffc1b9ac: 48 00 00 dc b ffc1ba88 <rtems_rfs_block_map_grow+0x2dc><== NOT EXECUTED
rtems_rfs_group_bitmap_free (fs, false, block);
return rc;
}
}
rtems_rfs_block_set_number (&map->doubly_buffer,
ffc1b9b0: 81 3f 00 4c lwz r9,76(r31)
ffc1b9b4: 57 5a 10 3a rlwinm r26,r26,2,0,29
ffc1b9b8: 88 01 00 08 lbz r0,8(r1)
ffc1b9bc: 81 29 00 24 lwz r9,36(r9)
ffc1b9c0: 7c 09 d1 ae stbx r0,r9,r26
ffc1b9c4: 81 3f 00 4c lwz r9,76(r31)
ffc1b9c8: a0 01 00 08 lhz r0,8(r1)
ffc1b9cc: 81 29 00 24 lwz r9,36(r9)
ffc1b9d0: 7d 29 d2 14 add r9,r9,r26
ffc1b9d4: 98 09 00 01 stb r0,1(r9)
ffc1b9d8: 81 3f 00 4c lwz r9,76(r31)
ffc1b9dc: 80 01 00 08 lwz r0,8(r1)
ffc1b9e0: 81 29 00 24 lwz r9,36(r9)
ffc1b9e4: 54 00 c2 3e rlwinm r0,r0,24,8,31
ffc1b9e8: 7d 29 d2 14 add r9,r9,r26
ffc1b9ec: 98 09 00 02 stb r0,2(r9)
ffc1b9f0: 81 3f 00 4c lwz r9,76(r31)
ffc1b9f4: 80 09 00 24 lwz r0,36(r9)
ffc1b9f8: 7f 40 d2 14 add r26,r0,r26
ffc1b9fc: 80 01 00 08 lwz r0,8(r1)
ffc1ba00: 98 1a 00 03 stb r0,3(r26)
ffc1ba04: 9b 1f 00 44 stb r24,68(r31)
ffc1ba08: 48 00 00 94 b ffc1ba9c <rtems_rfs_block_map_grow+0x2f0>
singly,
singly_block);
}
else
{
rc = rtems_rfs_buffer_handle_request (fs,
ffc1ba0c: 3b bd 00 08 addi r29,r29,8
ffc1ba10: 57 bd 10 3a rlwinm r29,r29,2,0,29
ffc1ba14: 7f bf ea 14 add r29,r31,r29
ffc1ba18: 80 bd 00 04 lwz r5,4(r29)
ffc1ba1c: 7f c3 f3 78 mr r3,r30
ffc1ba20: 7f 24 cb 78 mr r4,r25
ffc1ba24: 38 c0 00 01 li r6,1
ffc1ba28: 48 00 07 c1 bl ffc1c1e8 <rtems_rfs_buffer_handle_request>
&map->doubly_buffer,
map->blocks[doubly],
true);
if (rc > 0)
ffc1ba2c: 7c 74 1b 79 mr. r20,r3
ffc1ba30: 41 81 00 58 bgt- ffc1ba88 <rtems_rfs_block_map_grow+0x2dc><== NEVER TAKEN
{
rtems_rfs_group_bitmap_free (fs, false, block);
return rc;
}
singly_block = rtems_rfs_block_get_number (&map->doubly_buffer,
ffc1ba34: 81 3f 00 4c lwz r9,76(r31)
ffc1ba38: 57 5a 10 3a rlwinm r26,r26,2,0,29
singly);
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
ffc1ba3c: 7f c3 f3 78 mr r3,r30
{
rtems_rfs_group_bitmap_free (fs, false, block);
return rc;
}
singly_block = rtems_rfs_block_get_number (&map->doubly_buffer,
ffc1ba40: 81 69 00 24 lwz r11,36(r9)
singly);
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
ffc1ba44: 7f 84 e3 78 mr r4,r28
ffc1ba48: 38 c0 00 01 li r6,1
{
rtems_rfs_group_bitmap_free (fs, false, block);
return rc;
}
singly_block = rtems_rfs_block_get_number (&map->doubly_buffer,
ffc1ba4c: 7d 2b d2 14 add r9,r11,r26
ffc1ba50: 7c ab d0 ae lbzx r5,r11,r26
ffc1ba54: 88 09 00 03 lbz r0,3(r9)
ffc1ba58: 54 a5 c0 0e rlwinm r5,r5,24,0,7
ffc1ba5c: 7c 05 2b 78 or r5,r0,r5
ffc1ba60: 88 09 00 01 lbz r0,1(r9)
ffc1ba64: 54 00 80 1e rlwinm r0,r0,16,0,15
ffc1ba68: 7c a5 03 78 or r5,r5,r0
ffc1ba6c: 88 09 00 02 lbz r0,2(r9)
ffc1ba70: 54 00 40 2e rlwinm r0,r0,8,0,23
ffc1ba74: 7c a5 03 78 or r5,r5,r0
ffc1ba78: 90 a1 00 08 stw r5,8(r1)
singly);
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
ffc1ba7c: 48 00 07 6d bl ffc1c1e8 <rtems_rfs_buffer_handle_request>
singly_block, true);
if (rc > 0)
ffc1ba80: 7c 74 1b 79 mr. r20,r3
ffc1ba84: 40 a1 00 18 ble+ ffc1ba9c <rtems_rfs_block_map_grow+0x2f0><== ALWAYS TAKEN
{
rtems_rfs_group_bitmap_free (fs, false, block);
ffc1ba88: 80 a1 00 0c lwz r5,12(r1) <== NOT EXECUTED
ffc1ba8c: 7f c3 f3 78 mr r3,r30 <== NOT EXECUTED
ffc1ba90: 38 80 00 00 li r4,0 <== NOT EXECUTED
ffc1ba94: 4b ff 54 f5 bl ffc10f88 <rtems_rfs_group_bitmap_free> <== NOT EXECUTED
return rc;
ffc1ba98: 48 00 00 98 b ffc1bb30 <rtems_rfs_block_map_grow+0x384><== NOT EXECUTED
}
}
}
rtems_rfs_block_set_number (&map->singly_buffer, direct, block);
ffc1ba9c: 81 3f 00 40 lwz r9,64(r31)
ffc1baa0: 56 d6 10 3a rlwinm r22,r22,2,0,29
ffc1baa4: 88 01 00 0c lbz r0,12(r1)
ffc1baa8: 81 29 00 24 lwz r9,36(r9)
ffc1baac: 7c 09 b1 ae stbx r0,r9,r22
ffc1bab0: 81 3f 00 40 lwz r9,64(r31)
ffc1bab4: a0 01 00 0c lhz r0,12(r1)
ffc1bab8: 81 29 00 24 lwz r9,36(r9)
ffc1babc: 7d 29 b2 14 add r9,r9,r22
ffc1bac0: 98 09 00 01 stb r0,1(r9)
ffc1bac4: 81 3f 00 40 lwz r9,64(r31)
ffc1bac8: 80 01 00 0c lwz r0,12(r1)
ffc1bacc: 81 29 00 24 lwz r9,36(r9)
ffc1bad0: 54 00 c2 3e rlwinm r0,r0,24,8,31
ffc1bad4: 7d 29 b2 14 add r9,r9,r22
ffc1bad8: 98 09 00 02 stb r0,2(r9)
ffc1badc: 81 3f 00 40 lwz r9,64(r31)
ffc1bae0: 80 09 00 24 lwz r0,36(r9)
ffc1bae4: 7e c0 b2 14 add r22,r0,r22
ffc1bae8: 80 01 00 0c lwz r0,12(r1)
ffc1baec: 98 16 00 03 stb r0,3(r22)
ffc1baf0: 9b 1f 00 38 stb r24,56(r31)
}
map->size.count++;
map->size.offset = 0;
if (b == 0)
ffc1baf4: 2f 9b 00 00 cmpwi cr7,r27,0
}
rtems_rfs_block_set_number (&map->singly_buffer, direct, block);
}
map->size.count++;
ffc1baf8: 81 3f 00 08 lwz r9,8(r31)
ffc1bafc: 38 09 00 01 addi r0,r9,1
ffc1bb00: 90 1f 00 08 stw r0,8(r31)
map->size.offset = 0;
ffc1bb04: 38 00 00 00 li r0,0
ffc1bb08: 90 1f 00 0c stw r0,12(r31)
ffc1bb0c: 80 01 00 0c lwz r0,12(r1)
if (b == 0)
ffc1bb10: 40 9e 00 08 bne- cr7,ffc1bb18 <rtems_rfs_block_map_grow+0x36c><== NEVER TAKEN
*new_block = block;
ffc1bb14: 90 15 00 00 stw r0,0(r21)
map->last_data_block = block;
ffc1bb18: 90 1f 00 20 stw r0,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++)
ffc1bb1c: 3b 7b 00 01 addi r27,r27,1
map->size.offset = 0;
if (b == 0)
*new_block = block;
map->last_data_block = block;
map->dirty = true;
ffc1bb20: 9b 1f 00 00 stb r24,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++)
ffc1bb24: 7f 9b b8 00 cmpw cr7,r27,r23
ffc1bb28: 40 9e fc fc bne+ cr7,ffc1b824 <rtems_rfs_block_map_grow+0x78>
*new_block = block;
map->last_data_block = block;
map->dirty = true;
}
return 0;
ffc1bb2c: 3a 80 00 00 li r20,0
}
ffc1bb30: 39 61 00 48 addi r11,r1,72
ffc1bb34: 7e 83 a3 78 mr r3,r20
ffc1bb38: 4b fe 6f 94 b ffc02acc <_restgpr_20_x>
ffc1ada4 <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)
{
ffc1ada4: 94 21 ff d0 stwu r1,-48(r1)
ffc1ada8: 7c 08 02 a6 mflr r0
ffc1adac: 90 01 00 34 stw r0,52(r1)
ffc1adb0: bf 41 00 18 stmw r26,24(r1)
ffc1adb4: 7c 9e 23 78 mr r30,r4
ffc1adb8: 7c bf 2b 78 mr r31,r5
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);
ffc1adbc: 80 84 00 1c lwz r4,28(r4)
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)
{
ffc1adc0: 7c dc 33 78 mr r28,r6
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);
ffc1adc4: 38 a0 00 00 li r5,0
ffc1adc8: 38 c1 00 08 addi r6,r1,8
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)
{
ffc1adcc: 7c 7d 1b 78 mr r29,r3
ffc1add0: 7c fb 3b 78 mr r27,r7
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);
ffc1add4: 4b ff 5f bd bl ffc10d90 <rtems_rfs_group_bitmap_alloc>
if (rc > 0)
ffc1add8: 7c 7a 1b 79 mr. r26,r3
ffc1addc: 41 a1 01 14 bgt+ ffc1aef0 <rtems_rfs_block_map_indirect_alloc+0x14c><== NEVER TAKEN
return rc;
rc = rtems_rfs_buffer_handle_request (fs, buffer, new_block, false);
ffc1ade0: 80 a1 00 08 lwz r5,8(r1)
ffc1ade4: 7f a3 eb 78 mr r3,r29
ffc1ade8: 7f e4 fb 78 mr r4,r31
ffc1adec: 38 c0 00 00 li r6,0
ffc1adf0: 48 00 13 f9 bl ffc1c1e8 <rtems_rfs_buffer_handle_request>
if (rc > 0)
ffc1adf4: 7c 7a 1b 79 mr. r26,r3
ffc1adf8: 40 81 00 18 ble- ffc1ae10 <rtems_rfs_block_map_indirect_alloc+0x6c><== ALWAYS TAKEN
{
rtems_rfs_group_bitmap_free (fs, false, new_block);
ffc1adfc: 80 a1 00 08 lwz r5,8(r1) <== NOT EXECUTED
ffc1ae00: 7f a3 eb 78 mr r3,r29 <== NOT EXECUTED
ffc1ae04: 38 80 00 00 li r4,0 <== NOT EXECUTED
ffc1ae08: 4b ff 61 81 bl ffc10f88 <rtems_rfs_group_bitmap_free> <== NOT EXECUTED
return rc;
ffc1ae0c: 48 00 00 e4 b ffc1aef0 <rtems_rfs_block_map_indirect_alloc+0x14c><== NOT EXECUTED
}
memset (rtems_rfs_buffer_data (buffer), 0xff, rtems_rfs_fs_block_size (fs));
ffc1ae10: 81 3f 00 08 lwz r9,8(r31)
ffc1ae14: 38 80 00 ff li r4,255
ffc1ae18: 80 bd 00 08 lwz r5,8(r29)
ffc1ae1c: 80 69 00 24 lwz r3,36(r9)
ffc1ae20: 48 00 7b 39 bl ffc22958 <memset>
if (upping)
ffc1ae24: 2f 9b 00 00 cmpwi cr7,r27,0
ffc1ae28: 41 be 00 b0 beq+ cr7,ffc1aed8 <rtems_rfs_block_map_indirect_alloc+0x134>
{
int b;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BLOCK_MAP_GROW))
ffc1ae2c: 38 60 00 00 li r3,0
ffc1ae30: 38 80 20 00 li r4,8192
ffc1ae34: 4b ff 84 d1 bl ffc13304 <rtems_rfs_trace>
ffc1ae38: 2f 83 00 00 cmpwi cr7,r3,0
ffc1ae3c: 41 be 00 18 beq+ cr7,ffc1ae54 <rtems_rfs_block_map_indirect_alloc+0xb0><== ALWAYS TAKEN
printf ("rtems-rfs: block-map-grow: upping: block-count=%" PRId32 "\n",
ffc1ae40: 3c 60 ff c3 lis r3,-61 <== NOT EXECUTED
ffc1ae44: 80 9e 00 08 lwz r4,8(r30) <== NOT EXECUTED
ffc1ae48: 38 63 41 c3 addi r3,r3,16835 <== NOT EXECUTED
ffc1ae4c: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc1ae50: 48 00 7c 99 bl ffc22ae8 <printf> <== NOT EXECUTED
map->size.count);
for (b = 0; b < RTEMS_RFS_INODE_BLOCKS; b++)
rtems_rfs_block_set_number (buffer, b, map->blocks[b]);
ffc1ae54: 39 40 00 05 li r10,5
ffc1ae58: 7d 49 03 a6 mtctr r10
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",
ffc1ae5c: 7f cb f3 78 mr r11,r30
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)
{
ffc1ae60: 39 20 00 00 li r9,0
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]);
ffc1ae64: 38 00 00 01 li r0,1
ffc1ae68: 81 5f 00 08 lwz r10,8(r31)
ffc1ae6c: 89 0b 00 24 lbz r8,36(r11)
ffc1ae70: 81 4a 00 24 lwz r10,36(r10)
ffc1ae74: 7d 0a 49 ae stbx r8,r10,r9
ffc1ae78: 81 5f 00 08 lwz r10,8(r31)
ffc1ae7c: a1 0b 00 24 lhz r8,36(r11)
ffc1ae80: 81 4a 00 24 lwz r10,36(r10)
ffc1ae84: 7d 4a 4a 14 add r10,r10,r9
ffc1ae88: 99 0a 00 01 stb r8,1(r10)
ffc1ae8c: 81 5f 00 08 lwz r10,8(r31)
ffc1ae90: 81 0b 00 24 lwz r8,36(r11)
ffc1ae94: 81 4a 00 24 lwz r10,36(r10)
ffc1ae98: 55 08 c2 3e rlwinm r8,r8,24,8,31
ffc1ae9c: 7d 4a 4a 14 add r10,r10,r9
ffc1aea0: 99 0a 00 02 stb r8,2(r10)
ffc1aea4: 81 5f 00 08 lwz r10,8(r31)
ffc1aea8: 81 0b 00 24 lwz r8,36(r11)
ffc1aeac: 39 6b 00 04 addi r11,r11,4
ffc1aeb0: 81 4a 00 24 lwz r10,36(r10)
ffc1aeb4: 7d 4a 4a 14 add r10,r10,r9
ffc1aeb8: 99 0a 00 03 stb r8,3(r10)
ffc1aebc: 39 29 00 04 addi r9,r9,4
ffc1aec0: 98 1f 00 00 stb r0,0(r31)
{
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++)
ffc1aec4: 42 00 ff a4 bdnz+ ffc1ae68 <rtems_rfs_block_map_indirect_alloc+0xc4>
rtems_rfs_block_set_number (buffer, b, map->blocks[b]);
memset (map->blocks, 0, sizeof (map->blocks));
ffc1aec8: 38 7e 00 24 addi r3,r30,36
ffc1aecc: 38 80 00 00 li r4,0
ffc1aed0: 38 a0 00 14 li r5,20
ffc1aed4: 48 00 7a 85 bl ffc22958 <memset>
}
rtems_rfs_buffer_mark_dirty (buffer);
ffc1aed8: 38 00 00 01 li r0,1
ffc1aedc: 98 1f 00 00 stb r0,0(r31)
*block = new_block;
map->last_map_block = new_block;
return 0;
ffc1aee0: 3b 40 00 00 li r26,0
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;
ffc1aee4: 80 01 00 08 lwz r0,8(r1)
ffc1aee8: 90 1c 00 00 stw r0,0(r28)
map->last_map_block = new_block;
ffc1aeec: 90 1e 00 1c stw r0,28(r30)
return 0;
}
ffc1aef0: 39 61 00 30 addi r11,r1,48
ffc1aef4: 7f 43 d3 78 mr r3,r26
ffc1aef8: 4b fe 7b ec b ffc02ae4 <_restgpr_26_x>
ffc1afcc <rtems_rfs_block_map_indirect_shrink.isra.7>:
* 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) ||
ffc1afcc: 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,
ffc1afd0: 94 21 ff f0 stwu r1,-16(r1) <== NOT EXECUTED
ffc1afd4: 7c 08 02 a6 mflr r0 <== NOT EXECUTED
ffc1afd8: bf c1 00 08 stmw r30,8(r1) <== NOT EXECUTED
ffc1afdc: 7c 9f 23 78 mr r31,r4 <== NOT EXECUTED
ffc1afe0: 90 01 00 14 stw r0,20(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) ||
ffc1afe4: 41 82 00 1c beq- ffc1b000 <rtems_rfs_block_map_indirect_shrink.isra.7+0x34><== NOT EXECUTED
ffc1afe8: 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;
ffc1afec: 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) ||
ffc1aff0: 40 9e 00 ac bne- cr7,ffc1b09c <rtems_rfs_block_map_indirect_shrink.isra.7+0xd0><== NOT EXECUTED
((indirect == 0) && (index == RTEMS_RFS_INODE_BLOCKS)))
ffc1aff4: 2f 87 00 05 cmpwi cr7,r7,5 <== 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;
ffc1aff8: 7c c0 33 78 mr r0,r6 <== NOT EXECUTED
* 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) ||
((indirect == 0) && (index == RTEMS_RFS_INODE_BLOCKS)))
ffc1affc: 40 be 00 a0 bne+ cr7,ffc1b09c <rtems_rfs_block_map_indirect_shrink.isra.7+0xd0><== NOT EXECUTED
{
rtems_rfs_block_no block_to_free = map->blocks[indirect];
if ((indirect == 0) && (index == RTEMS_RFS_INODE_BLOCKS))
ffc1b000: 2f 86 00 00 cmpwi cr7,r6,0 <== 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];
ffc1b004: 38 06 00 08 addi r0,r6,8 <== NOT EXECUTED
ffc1b008: 54 09 10 3a rlwinm r9,r0,2,0,29 <== NOT EXECUTED
ffc1b00c: 7d 3f 4a 14 add r9,r31,r9 <== NOT EXECUTED
ffc1b010: 83 c9 00 04 lwz r30,4(r9) <== NOT EXECUTED
if ((indirect == 0) && (index == RTEMS_RFS_INODE_BLOCKS))
ffc1b014: 40 9e 00 60 bne- cr7,ffc1b074 <rtems_rfs_block_map_indirect_shrink.isra.7+0xa8><== NOT EXECUTED
ffc1b018: 2f 87 00 05 cmpwi cr7,r7,5 <== NOT EXECUTED
ffc1b01c: 40 be 00 58 bne+ cr7,ffc1b074 <rtems_rfs_block_map_indirect_shrink.isra.7+0xa8><== 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);
ffc1b020: 38 00 00 05 li r0,5 <== NOT EXECUTED
ffc1b024: 81 25 00 00 lwz r9,0(r5) <== NOT EXECUTED
ffc1b028: 7c 09 03 a6 mtctr r0 <== NOT EXECUTED
ffc1b02c: 39 60 00 00 li r11,0 <== NOT EXECUTED
if ((index == 0) ||
((indirect == 0) && (index == RTEMS_RFS_INODE_BLOCKS)))
{
rtems_rfs_block_no block_to_free = map->blocks[indirect];
if ((indirect == 0) && (index == RTEMS_RFS_INODE_BLOCKS))
ffc1b030: 81 29 00 24 lwz r9,36(r9) <== 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);
ffc1b034: 89 09 00 00 lbz r8,0(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,
ffc1b038: 7d 5f 5a 14 add r10,r31,r11 <== 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);
ffc1b03c: 88 09 00 01 lbz r0,1(r9) <== NOT EXECUTED
ffc1b040: 39 6b 00 04 addi r11,r11,4 <== NOT EXECUTED
ffc1b044: 55 08 c0 0e rlwinm r8,r8,24,0,7 <== NOT EXECUTED
ffc1b048: 54 00 80 1e rlwinm r0,r0,16,0,15 <== NOT EXECUTED
ffc1b04c: 7d 00 03 78 or r0,r8,r0 <== NOT EXECUTED
ffc1b050: 89 09 00 03 lbz r8,3(r9) <== NOT EXECUTED
ffc1b054: 7c 00 43 78 or r0,r0,r8 <== NOT EXECUTED
ffc1b058: 89 09 00 02 lbz r8,2(r9) <== NOT EXECUTED
ffc1b05c: 39 29 00 04 addi r9,r9,4 <== NOT EXECUTED
ffc1b060: 55 08 40 2e rlwinm r8,r8,8,0,23 <== NOT EXECUTED
ffc1b064: 7c 00 43 78 or r0,r0,r8 <== NOT EXECUTED
ffc1b068: 90 0a 00 24 stw r0,36(r10) <== NOT EXECUTED
{
/*
* Move to direct inode access.
*/
int b;
for (b = 0; b < RTEMS_RFS_INODE_BLOCKS; b++)
ffc1b06c: 42 00 ff c8 bdnz+ ffc1b034 <rtems_rfs_block_map_indirect_shrink.isra.7+0x68><== NOT EXECUTED
ffc1b070: 48 00 00 14 b ffc1b084 <rtems_rfs_block_map_indirect_shrink.isra.7+0xb8><== NOT EXECUTED
else
{
/*
* One less singly indirect block in the inode.
*/
map->blocks[indirect] = 0;
ffc1b074: 54 00 10 3a rlwinm r0,r0,2,0,29 <== NOT EXECUTED
ffc1b078: 7d 3f 02 14 add r9,r31,r0 <== NOT EXECUTED
ffc1b07c: 38 00 00 00 li r0,0 <== NOT EXECUTED
ffc1b080: 90 09 00 04 stw r0,4(r9) <== NOT EXECUTED
}
rc = rtems_rfs_group_bitmap_free (fs, false, block_to_free);
ffc1b084: 38 80 00 00 li r4,0 <== NOT EXECUTED
ffc1b088: 7f c5 f3 78 mr r5,r30 <== NOT EXECUTED
ffc1b08c: 4b ff 5e fd bl ffc10f88 <rtems_rfs_group_bitmap_free> <== NOT EXECUTED
if (rc > 0)
ffc1b090: 7c 60 1b 79 mr. r0,r3 <== NOT EXECUTED
ffc1b094: 41 a1 00 08 bgt+ ffc1b09c <rtems_rfs_block_map_indirect_shrink.isra.7+0xd0><== NOT EXECUTED
return rc;
map->last_map_block = block_to_free;
ffc1b098: 93 df 00 1c stw r30,28(r31) <== NOT EXECUTED
}
return rc;
}
ffc1b09c: 39 61 00 10 addi r11,r1,16 <== NOT EXECUTED
ffc1b0a0: 7c 03 03 78 mr r3,r0 <== NOT EXECUTED
ffc1b0a4: 4b fe 7a 50 b ffc02af4 <_restgpr_30_x> <== NOT EXECUTED
ffc1b1dc <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)
{
ffc1b1dc: 94 21 ff e0 stwu r1,-32(r1)
ffc1b1e0: 7c 08 02 a6 mflr r0
ffc1b1e4: bf 61 00 0c stmw r27,12(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;
ffc1b1e8: 3b 80 00 00 li r28,0
int
rtems_rfs_block_map_open (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* inode,
rtems_rfs_block_map* map)
{
ffc1b1ec: 7c 7e 1b 78 mr r30,r3
ffc1b1f0: 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;
ffc1b1f4: 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)
{
ffc1b1f8: 7c 9f 23 78 mr r31,r4
* 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;
ffc1b1fc: 98 05 00 00 stb r0,0(r5)
int
rtems_rfs_block_map_open (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* inode,
rtems_rfs_block_map* map)
{
ffc1b200: 7c bd 2b 78 mr r29,r5
* 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;
ffc1b204: 93 85 00 04 stw r28,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;
ffc1b208: 93 85 00 08 stw r28,8(r5)
size->offset = 0;
ffc1b20c: 93 85 00 0c stw r28,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;
ffc1b210: 93 85 00 10 stw r28,16(r5)
bpos->boff = 0;
ffc1b214: 93 85 00 14 stw r28,20(r5)
bpos->block = 0;
ffc1b218: 93 85 00 18 stw r28,24(r5)
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
ffc1b21c: 9b 85 00 38 stb r28,56(r5)
handle->bnum = 0;
ffc1b220: 93 85 00 3c stw r28,60(r5)
handle->buffer = NULL;
ffc1b224: 93 85 00 40 stw r28,64(r5)
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
ffc1b228: 9b 85 00 44 stb r28,68(r5)
handle->bnum = 0;
ffc1b22c: 93 85 00 48 stw r28,72(r5)
handle->buffer = NULL;
ffc1b230: 93 85 00 4c stw r28,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);
ffc1b234: 4b ff 60 09 bl ffc1123c <rtems_rfs_inode_load>
if (rc > 0)
ffc1b238: 7c 7b 1b 79 mr. r27,r3
ffc1b23c: 40 a1 00 38 ble+ ffc1b274 <rtems_rfs_block_map_open+0x98><== 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);
ffc1b240: 38 9d 00 38 addi r4,r29,56 <== NOT EXECUTED
ffc1b244: 7f c3 f3 78 mr r3,r30 <== NOT EXECUTED
ffc1b248: 48 00 0d c1 bl ffc1c008 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
handle->dirty = false;
ffc1b24c: 9b 9d 00 38 stb r28,56(r29) <== 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);
ffc1b250: 7f c3 f3 78 mr r3,r30 <== NOT EXECUTED
handle->dirty = false;
handle->bnum = 0;
ffc1b254: 93 9d 00 3c stw r28,60(r29) <== 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);
ffc1b258: 38 9d 00 44 addi r4,r29,68 <== NOT EXECUTED
handle->dirty = false;
handle->bnum = 0;
handle->buffer = NULL;
ffc1b25c: 93 9d 00 40 stw r28,64(r29) <== 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);
ffc1b260: 48 00 0d a9 bl ffc1c008 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
handle->dirty = false;
ffc1b264: 9b 9d 00 44 stb r28,68(r29) <== NOT EXECUTED
handle->bnum = 0;
ffc1b268: 93 9d 00 48 stw r28,72(r29) <== NOT EXECUTED
handle->buffer = NULL;
ffc1b26c: 93 9d 00 4c stw r28,76(r29) <== NOT EXECUTED
{
rtems_rfs_buffer_handle_close (fs, &map->singly_buffer);
rtems_rfs_buffer_handle_close (fs, &map->doubly_buffer);
return rc;
ffc1b270: 48 00 01 14 b ffc1b384 <rtems_rfs_block_map_open+0x1a8><== NOT EXECUTED
/*
* 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++)
ffc1b274: 38 00 00 05 li r0,5
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);
}
ffc1b278: 81 3f 00 0c lwz r9,12(r31)
/*
* 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++)
ffc1b27c: 7c 09 03 a6 mtctr r0
/*
* Extract the block and block count data from the inode into the targets
* byte order.
*/
map->inode = inode;
ffc1b280: 93 fd 00 04 stw r31,4(r29)
* @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]);
ffc1b284: 39 69 00 1c addi r11,r9,28
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);
}
ffc1b288: 7f a8 eb 78 mr r8,r29
/*
* 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++)
ffc1b28c: 39 40 00 00 li r10,0
ffc1b290: 38 ca 00 04 addi r6,r10,4
ffc1b294: 88 eb 00 03 lbz r7,3(r11)
ffc1b298: 54 c6 10 3a rlwinm r6,r6,2,0,29
ffc1b29c: 7c c9 32 14 add r6,r9,r6
ffc1b2a0: 88 06 00 0c lbz r0,12(r6)
ffc1b2a4: 39 4a 00 01 addi r10,r10,1
ffc1b2a8: 54 00 c0 0e rlwinm r0,r0,24,0,7
ffc1b2ac: 7c e0 03 78 or r0,r7,r0
ffc1b2b0: 88 eb 00 01 lbz r7,1(r11)
ffc1b2b4: 54 e7 80 1e rlwinm r7,r7,16,0,15
ffc1b2b8: 7c 00 3b 78 or r0,r0,r7
ffc1b2bc: 88 eb 00 02 lbz r7,2(r11)
ffc1b2c0: 39 6b 00 04 addi r11,r11,4
ffc1b2c4: 54 e7 40 2e rlwinm r7,r7,8,0,23
ffc1b2c8: 7c 00 3b 78 or r0,r0,r7
map->blocks[b] = rtems_rfs_inode_get_block (inode, b);
ffc1b2cc: 90 08 00 24 stw r0,36(r8)
/*
* 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++)
ffc1b2d0: 39 08 00 04 addi r8,r8,4
ffc1b2d4: 42 00 ff bc bdnz+ ffc1b290 <rtems_rfs_block_map_open+0xb4>
* @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);
ffc1b2d8: 89 69 00 0c lbz r11,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);
ffc1b2dc: 7f c3 f3 78 mr r3,r30
ffc1b2e0: 88 09 00 0d lbz r0,13(r9)
ffc1b2e4: 7f e4 fb 78 mr r4,r31
ffc1b2e8: 55 6b c0 0e rlwinm r11,r11,24,0,7
ffc1b2ec: 54 00 80 1e rlwinm r0,r0,16,0,15
ffc1b2f0: 7d 60 03 78 or r0,r11,r0
ffc1b2f4: 89 69 00 0f lbz r11,15(r9)
ffc1b2f8: 38 a0 00 00 li r5,0
ffc1b2fc: 7c 00 5b 78 or r0,r0,r11
ffc1b300: 89 69 00 0e lbz r11,14(r9)
ffc1b304: 55 6b 40 2e rlwinm r11,r11,8,0,23
ffc1b308: 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);
ffc1b30c: 90 1d 00 08 stw r0,8(r29)
* @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);
ffc1b310: 88 09 00 0a lbz r0,10(r9)
ffc1b314: 89 69 00 0b lbz r11,11(r9)
ffc1b318: 54 00 40 2e rlwinm r0,r0,8,0,23
map->size.offset = rtems_rfs_inode_get_block_offset (inode);
ffc1b31c: 7c 00 5b 78 or r0,r0,r11
ffc1b320: 90 1d 00 0c stw r0,12(r29)
* @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);
ffc1b324: 89 69 00 30 lbz r11,48(r9)
ffc1b328: 88 09 00 31 lbz r0,49(r9)
ffc1b32c: 55 6b c0 0e rlwinm r11,r11,24,0,7
ffc1b330: 54 00 80 1e rlwinm r0,r0,16,0,15
ffc1b334: 7d 60 03 78 or r0,r11,r0
ffc1b338: 89 69 00 33 lbz r11,51(r9)
ffc1b33c: 7c 00 5b 78 or r0,r0,r11
ffc1b340: 89 69 00 32 lbz r11,50(r9)
ffc1b344: 55 6b 40 2e rlwinm r11,r11,8,0,23
ffc1b348: 7c 00 5b 78 or r0,r0,r11
map->last_map_block = rtems_rfs_inode_get_last_map_block (inode);
ffc1b34c: 90 1d 00 1c stw r0,28(r29)
* @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);
ffc1b350: 89 69 00 34 lbz r11,52(r9)
ffc1b354: 88 09 00 35 lbz r0,53(r9)
ffc1b358: 55 6b c0 0e rlwinm r11,r11,24,0,7
ffc1b35c: 54 00 80 1e rlwinm r0,r0,16,0,15
ffc1b360: 7d 60 03 78 or r0,r11,r0
ffc1b364: 89 69 00 37 lbz r11,55(r9)
ffc1b368: 89 29 00 36 lbz r9,54(r9)
ffc1b36c: 7c 00 5b 78 or r0,r0,r11
ffc1b370: 55 29 40 2e rlwinm r9,r9,8,0,23
ffc1b374: 7c 00 4b 78 or r0,r0,r9
map->last_data_block = rtems_rfs_inode_get_last_data_block (inode);
ffc1b378: 90 1d 00 20 stw r0,32(r29)
rc = rtems_rfs_inode_unload (fs, inode, false);
ffc1b37c: 4b ff 60 69 bl ffc113e4 <rtems_rfs_inode_unload>
ffc1b380: 7c 7b 1b 78 mr r27,r3
return rc;
}
ffc1b384: 39 61 00 20 addi r11,r1,32
ffc1b388: 7f 63 db 78 mr r3,r27
ffc1b38c: 4b fe 77 5c b ffc02ae8 <_restgpr_27_x>
ffc1bb3c <rtems_rfs_block_map_shrink>:
int
rtems_rfs_block_map_shrink (rtems_rfs_file_system* fs,
rtems_rfs_block_map* map,
size_t blocks)
{
ffc1bb3c: 94 21 ff c0 stwu r1,-64(r1)
ffc1bb40: 7c 08 02 a6 mflr r0
ffc1bb44: be 41 00 08 stmw r18,8(r1)
ffc1bb48: 7c 7e 1b 78 mr r30,r3
ffc1bb4c: 7c 9f 23 78 mr r31,r4
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BLOCK_MAP_SHRINK))
ffc1bb50: 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)
{
ffc1bb54: 90 01 00 44 stw r0,68(r1)
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BLOCK_MAP_SHRINK))
ffc1bb58: 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)
{
ffc1bb5c: 7c bd 2b 78 mr r29,r5
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BLOCK_MAP_SHRINK))
ffc1bb60: 4b ff 77 a5 bl ffc13304 <rtems_rfs_trace>
ffc1bb64: 2f 83 00 00 cmpwi cr7,r3,0
ffc1bb68: 41 be 00 1c beq+ cr7,ffc1bb84 <rtems_rfs_block_map_shrink+0x48><== ALWAYS TAKEN
printf ("rtems-rfs: block-map-shrink: entry: blocks=%zd count=%" PRIu32 "\n",
ffc1bb6c: 3c 60 ff c3 lis r3,-61 <== NOT EXECUTED
ffc1bb70: 80 bf 00 08 lwz r5,8(r31) <== NOT EXECUTED
ffc1bb74: 38 63 42 7a addi r3,r3,17018 <== NOT EXECUTED
ffc1bb78: 7f a4 eb 78 mr r4,r29 <== NOT EXECUTED
ffc1bb7c: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc1bb80: 48 00 6f 69 bl ffc22ae8 <printf> <== NOT EXECUTED
blocks, map->size.count);
if (map->size.count == 0)
ffc1bb84: 80 1f 00 08 lwz r0,8(r31)
return 0;
ffc1bb88: 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)
ffc1bb8c: 2f 80 00 00 cmpwi cr7,r0,0
ffc1bb90: 41 9e 02 bc beq- cr7,ffc1be4c <rtems_rfs_block_map_shrink+0x310><== ALWAYS TAKEN
ffc1bb94: 7f 9d 00 40 cmplw cr7,r29,r0 <== NOT EXECUTED
ffc1bb98: 40 9d 02 20 ble- cr7,ffc1bdb8 <rtems_rfs_block_map_shrink+0x27c><== NOT EXECUTED
ffc1bb9c: 7c 1d 03 78 mr r29,r0 <== NOT EXECUTED
ffc1bba0: 48 00 02 18 b ffc1bdb8 <rtems_rfs_block_map_shrink+0x27c><== NOT EXECUTED
{
rtems_rfs_block_no block;
rtems_rfs_block_no block_to_free;
int rc;
block = map->size.count - 1;
ffc1bba4: 81 3f 00 08 lwz r9,8(r31) <== NOT EXECUTED
ffc1bba8: 38 09 ff ff addi r0,r9,-1 <== NOT EXECUTED
if (block < RTEMS_RFS_INODE_BLOCKS)
ffc1bbac: 2b 80 00 04 cmplwi cr7,r0,4 <== NOT EXECUTED
ffc1bbb0: 41 9d 00 20 bgt- cr7,ffc1bbd0 <rtems_rfs_block_map_shrink+0x94><== NOT EXECUTED
{
/*
* We have less than RTEMS_RFS_INODE_BLOCKS so they are held in the
* inode.
*/
block_to_free = map->blocks[block];
ffc1bbb4: 39 29 00 07 addi r9,r9,7 <== NOT EXECUTED
ffc1bbb8: 55 29 10 3a rlwinm r9,r9,2,0,29 <== NOT EXECUTED
ffc1bbbc: 7d 3f 4a 14 add r9,r31,r9 <== NOT EXECUTED
map->blocks[block] = 0;
ffc1bbc0: 38 00 00 00 li r0,0 <== NOT EXECUTED
{
/*
* We have less than RTEMS_RFS_INODE_BLOCKS so they are held in the
* inode.
*/
block_to_free = map->blocks[block];
ffc1bbc4: 83 89 00 04 lwz r28,4(r9) <== NOT EXECUTED
map->blocks[block] = 0;
ffc1bbc8: 90 09 00 04 stw r0,4(r9) <== NOT EXECUTED
ffc1bbcc: 48 00 01 b0 b ffc1bd7c <rtems_rfs_block_map_shrink+0x240><== NOT EXECUTED
* table of block numbers.
*/
rtems_rfs_block_no direct;
rtems_rfs_block_no singly;
direct = block % fs->blocks_per_block;
ffc1bbd0: 83 9e 00 30 lwz r28,48(r30) <== NOT EXECUTED
singly = block / fs->blocks_per_block;
if (block < fs->block_map_singly_blocks)
ffc1bbd4: 81 3e 00 34 lwz r9,52(r30) <== NOT EXECUTED
* table of block numbers.
*/
rtems_rfs_block_no direct;
rtems_rfs_block_no singly;
direct = block % fs->blocks_per_block;
ffc1bbd8: 7e 60 e3 96 divwu r19,r0,r28 <== NOT EXECUTED
singly = block / fs->blocks_per_block;
if (block < fs->block_map_singly_blocks)
ffc1bbdc: 7f 80 48 40 cmplw cr7,r0,r9 <== NOT EXECUTED
* table of block numbers.
*/
rtems_rfs_block_no direct;
rtems_rfs_block_no singly;
direct = block % fs->blocks_per_block;
ffc1bbe0: 7e 53 e1 d6 mullw r18,r19,r28 <== NOT EXECUTED
ffc1bbe4: 7e 52 00 50 subf r18,r18,r0 <== NOT EXECUTED
singly = block / fs->blocks_per_block;
if (block < fs->block_map_singly_blocks)
ffc1bbe8: 40 bc 00 84 bge+ cr7,ffc1bc6c <rtems_rfs_block_map_shrink+0x130><== NOT EXECUTED
{
/*
* Request the indirect block and then obtain the block number from the
* indirect block.
*/
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
ffc1bbec: 39 33 00 08 addi r9,r19,8 <== NOT EXECUTED
ffc1bbf0: 55 29 10 3a rlwinm r9,r9,2,0,29 <== NOT EXECUTED
ffc1bbf4: 7d 3f 4a 14 add r9,r31,r9 <== NOT EXECUTED
ffc1bbf8: 80 a9 00 04 lwz r5,4(r9) <== NOT EXECUTED
ffc1bbfc: 7f c3 f3 78 mr r3,r30 <== NOT EXECUTED
ffc1bc00: 7f 64 db 78 mr r4,r27 <== NOT EXECUTED
ffc1bc04: 38 c0 00 01 li r6,1 <== NOT EXECUTED
ffc1bc08: 48 00 05 e1 bl ffc1c1e8 <rtems_rfs_buffer_handle_request><== NOT EXECUTED
map->blocks[singly], true);
if (rc > 0)
ffc1bc0c: 2c 03 00 00 cmpwi r3,0 <== NOT EXECUTED
ffc1bc10: 41 81 02 3c bgt- ffc1be4c <rtems_rfs_block_map_shrink+0x310><== NOT EXECUTED
return rc;
block_to_free = rtems_rfs_block_get_number (&map->singly_buffer,
ffc1bc14: 81 3f 00 40 lwz r9,64(r31) <== NOT EXECUTED
ffc1bc18: 56 40 10 3a rlwinm r0,r18,2,0,29 <== NOT EXECUTED
direct);
rc = rtems_rfs_block_map_indirect_shrink (fs, map, &map->singly_buffer,
ffc1bc1c: 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,
ffc1bc20: 81 29 00 24 lwz r9,36(r9) <== NOT EXECUTED
direct);
rc = rtems_rfs_block_map_indirect_shrink (fs, map, &map->singly_buffer,
ffc1bc24: 7f e4 fb 78 mr r4,r31 <== NOT EXECUTED
ffc1bc28: 7f 25 cb 78 mr r5,r25 <== 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,
ffc1bc2c: 7e 89 00 ee lbzux r20,r9,r0 <== NOT EXECUTED
direct);
rc = rtems_rfs_block_map_indirect_shrink (fs, map, &map->singly_buffer,
ffc1bc30: 7e 66 9b 78 mr r6,r19 <== NOT EXECUTED
ffc1bc34: 7e 47 93 78 mr r7,r18 <== 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,
ffc1bc38: 8a a9 00 01 lbz r21,1(r9) <== NOT EXECUTED
ffc1bc3c: 8a c9 00 02 lbz r22,2(r9) <== NOT EXECUTED
ffc1bc40: 8b 89 00 03 lbz r28,3(r9) <== NOT EXECUTED
direct);
rc = rtems_rfs_block_map_indirect_shrink (fs, map, &map->singly_buffer,
ffc1bc44: 4b ff f3 89 bl ffc1afcc <rtems_rfs_block_map_indirect_shrink.isra.7><== NOT EXECUTED
singly, direct);
if (rc)
ffc1bc48: 2c 03 00 00 cmpwi r3,0 <== NOT EXECUTED
ffc1bc4c: 40 82 02 00 bne- ffc1be4c <rtems_rfs_block_map_shrink+0x310><== 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,
ffc1bc50: 56 94 c0 0e rlwinm r20,r20,24,0,7 <== NOT EXECUTED
ffc1bc54: 7f 9c a3 78 or r28,r28,r20 <== NOT EXECUTED
ffc1bc58: 56 b5 80 1e rlwinm r21,r21,16,0,15 <== NOT EXECUTED
ffc1bc5c: 7f 9c ab 78 or r28,r28,r21 <== NOT EXECUTED
ffc1bc60: 56 d6 40 2e rlwinm r22,r22,8,0,23 <== NOT EXECUTED
ffc1bc64: 7f 9c b3 78 or r28,r28,r22 <== NOT EXECUTED
ffc1bc68: 48 00 01 14 b ffc1bd7c <rtems_rfs_block_map_shrink+0x240><== 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)
ffc1bc6c: 81 3e 00 38 lwz r9,56(r30) <== NOT EXECUTED
ffc1bc70: 7f 80 48 40 cmplw cr7,r0,r9 <== NOT EXECUTED
ffc1bc74: 40 9c 01 60 bge- cr7,ffc1bdd4 <rtems_rfs_block_map_shrink+0x298><== 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;
ffc1bc78: 7e d3 e3 96 divwu r22,r19,r28 <== NOT EXECUTED
doubly_singly = singly % fs->blocks_per_block;
rc = rtems_rfs_buffer_handle_request (fs, &map->doubly_buffer,
ffc1bc7c: 39 36 00 08 addi r9,r22,8 <== NOT EXECUTED
ffc1bc80: 55 29 10 3a rlwinm r9,r9,2,0,29 <== NOT EXECUTED
ffc1bc84: 7d 3f 4a 14 add r9,r31,r9 <== NOT EXECUTED
ffc1bc88: 80 a9 00 04 lwz r5,4(r9) <== NOT EXECUTED
ffc1bc8c: 7f c3 f3 78 mr r3,r30 <== NOT EXECUTED
ffc1bc90: 7e e4 bb 78 mr r4,r23 <== NOT EXECUTED
ffc1bc94: 38 c0 00 01 li r6,1 <== NOT EXECUTED
ffc1bc98: 48 00 05 51 bl ffc1c1e8 <rtems_rfs_buffer_handle_request><== NOT EXECUTED
map->blocks[doubly], true);
if (rc > 0)
ffc1bc9c: 2c 03 00 00 cmpwi r3,0 <== NOT EXECUTED
ffc1bca0: 41 81 01 ac bgt- ffc1be4c <rtems_rfs_block_map_shrink+0x310><== 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;
ffc1bca4: 7f 96 e1 d6 mullw r28,r22,r28 <== 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,
ffc1bca8: 81 3f 00 4c lwz r9,76(r31) <== NOT EXECUTED
ffc1bcac: 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,
ffc1bcb0: 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;
ffc1bcb4: 7e 7c 98 50 subf r19,r28,r19 <== 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,
ffc1bcb8: 56 60 10 3a rlwinm r0,r19,2,0,29 <== NOT EXECUTED
ffc1bcbc: 7d 2b 02 14 add r9,r11,r0 <== NOT EXECUTED
ffc1bcc0: 7e ab 00 ae lbzx r21,r11,r0 <== NOT EXECUTED
ffc1bcc4: 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,
ffc1bcc8: 7f 64 db 78 mr r4,r27 <== 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,
ffc1bccc: 88 09 00 01 lbz r0,1(r9) <== NOT EXECUTED
ffc1bcd0: 56 b5 c0 0e rlwinm r21,r21,24,0,7 <== NOT EXECUTED
ffc1bcd4: 7d 55 ab 78 or r21,r10,r21 <== NOT EXECUTED
ffc1bcd8: 54 00 80 1e rlwinm r0,r0,16,0,15 <== NOT EXECUTED
ffc1bcdc: 7e b5 03 78 or r21,r21,r0 <== NOT EXECUTED
ffc1bce0: 88 09 00 02 lbz r0,2(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,
ffc1bce4: 38 c0 00 01 li r6,1 <== 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,
ffc1bce8: 54 00 40 2e rlwinm r0,r0,8,0,23 <== NOT EXECUTED
ffc1bcec: 7e b5 03 78 or r21,r21,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,
ffc1bcf0: 7e a5 ab 78 mr r5,r21 <== NOT EXECUTED
ffc1bcf4: 48 00 04 f5 bl ffc1c1e8 <rtems_rfs_buffer_handle_request><== NOT EXECUTED
singly, true);
if (rc > 0)
ffc1bcf8: 2c 03 00 00 cmpwi r3,0 <== NOT EXECUTED
ffc1bcfc: 41 81 01 50 bgt- ffc1be4c <rtems_rfs_block_map_shrink+0x310><== NOT EXECUTED
return rc;
block_to_free = rtems_rfs_block_get_number (&map->singly_buffer,
ffc1bd00: 81 3f 00 40 lwz r9,64(r31) <== NOT EXECUTED
ffc1bd04: 56 40 10 3a rlwinm r0,r18,2,0,29 <== NOT EXECUTED
direct);
if (direct == 0)
ffc1bd08: 2f 92 00 00 cmpwi cr7,r18,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,
ffc1bd0c: 81 69 00 24 lwz r11,36(r9) <== NOT EXECUTED
ffc1bd10: 7d 2b 02 14 add r9,r11,r0 <== NOT EXECUTED
ffc1bd14: 7f 8b 00 ae lbzx r28,r11,r0 <== NOT EXECUTED
ffc1bd18: 89 49 00 03 lbz r10,3(r9) <== NOT EXECUTED
ffc1bd1c: 88 09 00 01 lbz r0,1(r9) <== NOT EXECUTED
ffc1bd20: 57 9c c0 0e rlwinm r28,r28,24,0,7 <== NOT EXECUTED
ffc1bd24: 7d 5c e3 78 or r28,r10,r28 <== NOT EXECUTED
ffc1bd28: 54 00 80 1e rlwinm r0,r0,16,0,15 <== NOT EXECUTED
ffc1bd2c: 7f 9c 03 78 or r28,r28,r0 <== NOT EXECUTED
ffc1bd30: 88 09 00 02 lbz r0,2(r9) <== NOT EXECUTED
ffc1bd34: 54 00 40 2e rlwinm r0,r0,8,0,23 <== NOT EXECUTED
ffc1bd38: 7f 9c 03 78 or r28,r28,r0 <== NOT EXECUTED
direct);
if (direct == 0)
ffc1bd3c: 40 be 00 40 bne+ cr7,ffc1bd7c <rtems_rfs_block_map_shrink+0x240><== NOT EXECUTED
{
rc = rtems_rfs_group_bitmap_free (fs, false, singly);
ffc1bd40: 7f c3 f3 78 mr r3,r30 <== NOT EXECUTED
ffc1bd44: 38 80 00 00 li r4,0 <== NOT EXECUTED
ffc1bd48: 7e a5 ab 78 mr r5,r21 <== NOT EXECUTED
ffc1bd4c: 4b ff 52 3d bl ffc10f88 <rtems_rfs_group_bitmap_free> <== NOT EXECUTED
if (rc > 0)
ffc1bd50: 2c 03 00 00 cmpwi r3,0 <== NOT EXECUTED
ffc1bd54: 41 81 00 f8 bgt- ffc1be4c <rtems_rfs_block_map_shrink+0x310><== NOT EXECUTED
return rc;
map->last_map_block = singly;
ffc1bd58: 92 bf 00 1c stw r21,28(r31) <== NOT EXECUTED
rc = rtems_rfs_block_map_indirect_shrink (fs, map, &map->doubly_buffer,
ffc1bd5c: 7f c3 f3 78 mr r3,r30 <== NOT EXECUTED
ffc1bd60: 7f e4 fb 78 mr r4,r31 <== NOT EXECUTED
ffc1bd64: 7f 05 c3 78 mr r5,r24 <== NOT EXECUTED
ffc1bd68: 7e c6 b3 78 mr r6,r22 <== NOT EXECUTED
ffc1bd6c: 7e 67 9b 78 mr r7,r19 <== NOT EXECUTED
ffc1bd70: 4b ff f2 5d bl ffc1afcc <rtems_rfs_block_map_indirect_shrink.isra.7><== NOT EXECUTED
doubly, doubly_singly);
if (rc)
ffc1bd74: 2c 03 00 00 cmpwi r3,0 <== NOT EXECUTED
ffc1bd78: 40 82 00 d4 bne- ffc1be4c <rtems_rfs_block_map_shrink+0x310><== NOT EXECUTED
{
rc = EIO;
break;
}
}
rc = rtems_rfs_group_bitmap_free (fs, false, block_to_free);
ffc1bd7c: 7f c3 f3 78 mr r3,r30 <== NOT EXECUTED
ffc1bd80: 38 80 00 00 li r4,0 <== NOT EXECUTED
ffc1bd84: 7f 85 e3 78 mr r5,r28 <== NOT EXECUTED
ffc1bd88: 4b ff 52 01 bl ffc10f88 <rtems_rfs_group_bitmap_free> <== NOT EXECUTED
if (rc > 0)
ffc1bd8c: 2c 03 00 00 cmpwi r3,0 <== NOT EXECUTED
ffc1bd90: 41 81 00 bc bgt- ffc1be4c <rtems_rfs_block_map_shrink+0x310><== NOT EXECUTED
return rc;
map->size.count--;
ffc1bd94: 81 3f 00 08 lwz r9,8(r31) <== NOT EXECUTED
map->size.offset = 0;
map->last_data_block = block_to_free;
map->dirty = true;
blocks--;
ffc1bd98: 3b bd ff ff addi r29,r29,-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;
map->last_data_block = block_to_free;
ffc1bd9c: 93 9f 00 20 stw r28,32(r31) <== NOT EXECUTED
}
}
rc = rtems_rfs_group_bitmap_free (fs, false, block_to_free);
if (rc > 0)
return rc;
map->size.count--;
ffc1bda0: 38 09 ff ff addi r0,r9,-1 <== NOT EXECUTED
ffc1bda4: 90 1f 00 08 stw r0,8(r31) <== NOT EXECUTED
map->size.offset = 0;
ffc1bda8: 38 00 00 00 li r0,0 <== NOT EXECUTED
ffc1bdac: 90 1f 00 0c stw r0,12(r31) <== NOT EXECUTED
map->last_data_block = block_to_free;
map->dirty = true;
ffc1bdb0: 9b 5f 00 00 stb r26,0(r31) <== NOT EXECUTED
ffc1bdb4: 48 00 00 18 b ffc1bdcc <rtems_rfs_block_map_shrink+0x290><== 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,
ffc1bdb8: 3a ff 00 44 addi r23,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,
ffc1bdbc: 3b 7f 00 38 addi r27,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);
}
ffc1bdc0: 3b 1f 00 4c addi r24,r31,76 <== NOT EXECUTED
ffc1bdc4: 3b 3f 00 40 addi r25,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;
ffc1bdc8: 3b 40 00 01 li r26,1 <== NOT EXECUTED
return 0;
if (blocks > map->size.count)
blocks = map->size.count;
while (blocks)
ffc1bdcc: 2f 9d 00 00 cmpwi cr7,r29,0 <== NOT EXECUTED
ffc1bdd0: 40 9e fd d4 bne+ cr7,ffc1bba4 <rtems_rfs_block_map_shrink+0x68><== NOT EXECUTED
map->last_data_block = block_to_free;
map->dirty = true;
blocks--;
}
if (map->size.count == 0)
ffc1bdd4: 81 3f 00 08 lwz r9,8(r31) <== NOT EXECUTED
ffc1bdd8: 2f 89 00 00 cmpwi cr7,r9,0 <== NOT EXECUTED
ffc1bddc: 40 9e 00 0c bne- cr7,ffc1bde8 <rtems_rfs_block_map_shrink+0x2ac><== NOT EXECUTED
{
map->last_map_block = 0;
ffc1bde0: 91 3f 00 1c stw r9,28(r31) <== NOT EXECUTED
map->last_data_block = 0;
ffc1bde4: 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))
ffc1bde8: 80 1f 00 10 lwz r0,16(r31) <== NOT EXECUTED
ffc1bdec: 2f 80 00 00 cmpwi cr7,r0,0 <== NOT EXECUTED
ffc1bdf0: 41 9e 00 0c beq- cr7,ffc1bdfc <rtems_rfs_block_map_shrink+0x2c0><== NOT EXECUTED
ffc1bdf4: 2f 89 00 00 cmpwi cr7,r9,0 <== NOT EXECUTED
ffc1bdf8: 41 9e 00 2c beq- cr7,ffc1be24 <rtems_rfs_block_map_shrink+0x2e8><== NOT EXECUTED
ffc1bdfc: 7f 80 48 40 cmplw cr7,r0,r9 <== NOT EXECUTED
ffc1be00: 40 9c 00 24 bge- cr7,ffc1be24 <rtems_rfs_block_map_shrink+0x2e8><== NOT EXECUTED
ffc1be04: 39 69 ff ff addi r11,r9,-1 <== NOT EXECUTED
ffc1be08: 7f 80 58 00 cmpw cr7,r0,r11 <== NOT EXECUTED
rtems_rfs_block_size_get_bpos (&map->size, &map->bpos);
return 0;
ffc1be0c: 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))
ffc1be10: 40 be 00 3c bne+ cr7,ffc1be4c <rtems_rfs_block_map_shrink+0x310><== NOT EXECUTED
ffc1be14: 81 7f 00 14 lwz r11,20(r31) <== NOT EXECUTED
ffc1be18: 80 1f 00 0c lwz r0,12(r31) <== NOT EXECUTED
ffc1be1c: 7f 8b 00 40 cmplw cr7,r11,r0 <== NOT EXECUTED
ffc1be20: 40 9d 00 2c ble- cr7,ffc1be4c <rtems_rfs_block_map_shrink+0x310><== NOT EXECUTED
rtems_rfs_block_size_get_bpos (&map->size, &map->bpos);
ffc1be24: 80 1f 00 0c lwz r0,12(r31) <== NOT EXECUTED
ffc1be28: 39 60 00 00 li r11,0 <== NOT EXECUTED
ffc1be2c: 91 3f 00 10 stw r9,16(r31) <== NOT EXECUTED
return 0;
ffc1be30: 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);
ffc1be34: 2f 80 00 00 cmpwi cr7,r0,0 <== NOT EXECUTED
ffc1be38: 90 1f 00 14 stw r0,20(r31) <== NOT EXECUTED
ffc1be3c: 91 7f 00 18 stw r11,24(r31) <== NOT EXECUTED
ffc1be40: 41 9e 00 0c beq- cr7,ffc1be4c <rtems_rfs_block_map_shrink+0x310><== NOT EXECUTED
ffc1be44: 39 29 ff ff addi r9,r9,-1 <== NOT EXECUTED
ffc1be48: 91 3f 00 10 stw r9,16(r31) <== NOT EXECUTED
return 0;
}
ffc1be4c: 39 61 00 40 addi r11,r1,64
ffc1be50: 4b fe 6c 74 b ffc02ac4 <_restgpr_18_x>
ffc21688 <rtems_rfs_buffer_bdbuf_release>:
int
rtems_rfs_buffer_bdbuf_release (rtems_rfs_buffer* buffer,
bool modified)
{
ffc21688: 94 21 ff f0 stwu r1,-16(r1)
ffc2168c: 7c 08 02 a6 mflr r0
ffc21690: bf c1 00 08 stmw r30,8(r1)
ffc21694: 7c 7f 1b 78 mr r31,r3
ffc21698: 7c 9e 23 78 mr r30,r4
rtems_status_code sc;
int rc = 0;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_RELEASE))
ffc2169c: 38 60 00 00 li r3,0
}
int
rtems_rfs_buffer_bdbuf_release (rtems_rfs_buffer* buffer,
bool modified)
{
ffc216a0: 90 01 00 14 stw r0,20(r1)
rtems_status_code sc;
int rc = 0;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_RELEASE))
ffc216a4: 38 80 00 40 li r4,64
ffc216a8: 4b ff 1c 5d bl ffc13304 <rtems_rfs_trace>
ffc216ac: 2f 83 00 00 cmpwi cr7,r3,0
ffc216b0: 41 9e 00 38 beq- cr7,ffc216e8 <rtems_rfs_buffer_bdbuf_release+0x60><== ALWAYS TAKEN
printf ("rtems-rfs: bdbuf-release: block=%" PRIuPTR " bdbuf=%" PRIu32 " %s\n",
ffc216b4: 2f 9e 00 00 cmpwi cr7,r30,0 <== NOT EXECUTED
ffc216b8: 80 9f 00 3c lwz r4,60(r31) <== NOT EXECUTED
ffc216bc: 80 bf 00 20 lwz r5,32(r31) <== NOT EXECUTED
ffc216c0: 41 9e 00 10 beq- cr7,ffc216d0 <rtems_rfs_buffer_bdbuf_release+0x48><== NOT EXECUTED
ffc216c4: 3c c0 ff c3 lis r6,-61 <== NOT EXECUTED
ffc216c8: 38 c6 57 a0 addi r6,r6,22432 <== NOT EXECUTED
ffc216cc: 48 00 00 0c b ffc216d8 <rtems_rfs_buffer_bdbuf_release+0x50><== NOT EXECUTED
ffc216d0: 3c c0 ff c3 lis r6,-61 <== NOT EXECUTED
ffc216d4: 38 c6 29 67 addi r6,r6,10599 <== NOT EXECUTED
ffc216d8: 3c 60 ff c3 lis r3,-61 <== NOT EXECUTED
ffc216dc: 38 63 57 ab addi r3,r3,22443 <== NOT EXECUTED
ffc216e0: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc216e4: 48 00 14 05 bl ffc22ae8 <printf> <== NOT EXECUTED
((intptr_t) buffer->user),
buffer->block, modified ? "(modified)" : "");
if (modified)
ffc216e8: 2f 9e 00 00 cmpwi cr7,r30,0
sc = rtems_bdbuf_release_modified (buffer);
ffc216ec: 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)
ffc216f0: 41 9e 00 0c beq- cr7,ffc216fc <rtems_rfs_buffer_bdbuf_release+0x74>
sc = rtems_bdbuf_release_modified (buffer);
ffc216f4: 4b ff 41 d9 bl ffc158cc <rtems_bdbuf_release_modified>
ffc216f8: 48 00 00 08 b ffc21700 <rtems_rfs_buffer_bdbuf_release+0x78>
else
sc = rtems_bdbuf_release (buffer);
ffc216fc: 4b ff 40 ed bl ffc157e8 <rtems_bdbuf_release>
if (sc != RTEMS_SUCCESSFUL)
ffc21700: 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;
ffc21704: 38 00 00 05 li r0,5
if (modified)
sc = rtems_bdbuf_release_modified (buffer);
else
sc = rtems_bdbuf_release (buffer);
if (sc != RTEMS_SUCCESSFUL)
ffc21708: 40 be 00 08 bne+ cr7,ffc21710 <rtems_rfs_buffer_bdbuf_release+0x88><== NEVER TAKEN
int
rtems_rfs_buffer_bdbuf_release (rtems_rfs_buffer* buffer,
bool modified)
{
rtems_status_code sc;
int rc = 0;
ffc2170c: 38 00 00 00 li r0,0
#endif
rc = EIO;
}
return rc;
}
ffc21710: 39 61 00 10 addi r11,r1,16
ffc21714: 7c 03 03 78 mr r3,r0
ffc21718: 4b fe 13 dc b ffc02af4 <_restgpr_30_x>
ffc21630 <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)
{
ffc21630: 7c 08 02 a6 mflr r0
ffc21634: 94 21 ff f8 stwu r1,-8(r1)
rtems_status_code sc;
int rc = 0;
if (read)
ffc21638: 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)
{
ffc2163c: 90 01 00 0c stw r0,12(r1)
ffc21640: 7c 80 23 78 mr r0,r4
rtems_status_code sc;
int rc = 0;
if (read)
sc = rtems_bdbuf_read (rtems_rfs_fs_device (fs), block, buffer);
ffc21644: 7c 05 03 78 mr r5,r0
ffc21648: 81 23 00 0c lwz r9,12(r3)
ffc2164c: 80 69 00 00 lwz r3,0(r9)
ffc21650: 80 89 00 04 lwz r4,4(r9)
rtems_rfs_buffer** buffer)
{
rtems_status_code sc;
int rc = 0;
if (read)
ffc21654: 41 9e 00 0c beq- cr7,ffc21660 <rtems_rfs_buffer_bdbuf_request+0x30>
sc = rtems_bdbuf_read (rtems_rfs_fs_device (fs), block, buffer);
ffc21658: 4b ff 3f 15 bl ffc1556c <rtems_bdbuf_read>
ffc2165c: 48 00 00 08 b ffc21664 <rtems_rfs_buffer_bdbuf_request+0x34>
else
sc = rtems_bdbuf_get (rtems_rfs_fs_device (fs), block, buffer);
ffc21660: 4b ff 3e 31 bl ffc15490 <rtems_bdbuf_get>
if (sc != RTEMS_SUCCESSFUL)
ffc21664: 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;
ffc21668: 38 00 00 05 li r0,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)
ffc2166c: 40 be 00 08 bne+ cr7,ffc21674 <rtems_rfs_buffer_bdbuf_request+0x44><== NEVER TAKEN
rtems_rfs_buffer_block block,
bool read,
rtems_rfs_buffer** buffer)
{
rtems_status_code sc;
int rc = 0;
ffc21670: 38 00 00 00 li r0,0
#endif
rc = EIO;
}
return rc;
}
ffc21674: 7c 03 03 78 mr r3,r0
ffc21678: 80 01 00 0c lwz r0,12(r1)
ffc2167c: 38 21 00 08 addi r1,r1,8
ffc21680: 7c 08 03 a6 mtlr r0
ffc21684: 4e 80 00 20 blr
ffc1c7fc <rtems_rfs_buffer_close>:
return 0;
}
int
rtems_rfs_buffer_close (rtems_rfs_file_system* fs)
{
ffc1c7fc: 94 21 ff f0 stwu r1,-16(r1)
ffc1c800: 7c 08 02 a6 mflr r0
int rc = 0;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CLOSE))
ffc1c804: 38 80 00 10 li r4,16
return 0;
}
int
rtems_rfs_buffer_close (rtems_rfs_file_system* fs)
{
ffc1c808: bf c1 00 08 stmw r30,8(r1)
ffc1c80c: 7c 7e 1b 78 mr r30,r3
int rc = 0;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CLOSE))
ffc1c810: 38 60 00 00 li r3,0
return 0;
}
int
rtems_rfs_buffer_close (rtems_rfs_file_system* fs)
{
ffc1c814: 90 01 00 14 stw r0,20(r1)
int rc = 0;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CLOSE))
ffc1c818: 4b ff 6a ed bl ffc13304 <rtems_rfs_trace>
ffc1c81c: 2f 83 00 00 cmpwi cr7,r3,0
ffc1c820: 41 be 00 10 beq+ cr7,ffc1c830 <rtems_rfs_buffer_close+0x34><== ALWAYS TAKEN
printf ("rtems-rfs: buffer-close: closing\n");
ffc1c824: 3c 60 ff c3 lis r3,-61 <== NOT EXECUTED
ffc1c828: 38 63 46 d5 addi r3,r3,18133 <== NOT EXECUTED
ffc1c82c: 48 00 64 71 bl ffc22c9c <puts> <== NOT EXECUTED
/*
* 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));
ffc1c830: 81 3e 00 0c lwz r9,12(r30)
ffc1c834: 7f c3 f3 78 mr r3,r30
ffc1c838: 80 89 00 24 lwz r4,36(r9)
ffc1c83c: 4b ff fe c5 bl ffc1c700 <rtems_rfs_buffer_setblksize>
if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CLOSE))
ffc1c840: 7c 7f 1b 79 mr. r31,r3
ffc1c844: 40 81 00 38 ble- ffc1c87c <rtems_rfs_buffer_close+0x80> <== ALWAYS TAKEN
ffc1c848: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc1c84c: 38 80 00 10 li r4,16 <== NOT EXECUTED
ffc1c850: 4b ff 6a b5 bl ffc13304 <rtems_rfs_trace> <== NOT EXECUTED
ffc1c854: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc1c858: 41 be 00 24 beq+ cr7,ffc1c87c <rtems_rfs_buffer_close+0x80><== NOT EXECUTED
printf ("rtems-rfs: buffer-close: set media block size failed: %d: %s\n",
ffc1c85c: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc1c860: 48 00 6f f5 bl ffc23854 <strerror> <== NOT EXECUTED
ffc1c864: 7f e4 fb 78 mr r4,r31 <== NOT EXECUTED
ffc1c868: 7c 65 1b 78 mr r5,r3 <== NOT EXECUTED
ffc1c86c: 3c 60 ff c3 lis r3,-61 <== NOT EXECUTED
ffc1c870: 38 63 46 f6 addi r3,r3,18166 <== NOT EXECUTED
ffc1c874: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc1c878: 48 00 62 71 bl ffc22ae8 <printf> <== NOT EXECUTED
rc, strerror (rc));
#if RTEMS_RFS_USE_LIBBLOCK
rtems_disk_release (fs->disk);
ffc1c87c: 80 7e 00 0c lwz r3,12(r30)
ffc1c880: 4b fe a0 71 bl ffc068f0 <rtems_disk_release>
rc, strerror (rc));
}
#endif
return rc;
}
ffc1c884: 39 61 00 10 addi r11,r1,16
ffc1c888: 7f e3 fb 78 mr r3,r31
ffc1c88c: 4b fe 62 68 b ffc02af4 <_restgpr_30_x>
ffc1c008 <rtems_rfs_buffer_handle_release>:
}
int
rtems_rfs_buffer_handle_release (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
ffc1c008: 94 21 ff e8 stwu r1,-24(r1)
ffc1c00c: 7c 08 02 a6 mflr r0
ffc1c010: 90 01 00 1c stw r0,28(r1)
int rc = 0;
if (rtems_rfs_buffer_handle_has_block (handle))
ffc1c014: 80 04 00 08 lwz r0,8(r4)
}
int
rtems_rfs_buffer_handle_release (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
ffc1c018: bf a1 00 0c stmw r29,12(r1)
ffc1c01c: 7c 7f 1b 78 mr r31,r3
int rc = 0;
if (rtems_rfs_buffer_handle_has_block (handle))
ffc1c020: 2f 80 00 00 cmpwi cr7,r0,0
}
int
rtems_rfs_buffer_handle_release (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
ffc1c024: 7c 9e 23 78 mr r30,r4
int rc = 0;
ffc1c028: 3b a0 00 00 li r29,0
if (rtems_rfs_buffer_handle_has_block (handle))
ffc1c02c: 41 9e 01 b0 beq- cr7,ffc1c1dc <rtems_rfs_buffer_handle_release+0x1d4>
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_RELEASE))
ffc1c030: 38 60 00 00 li r3,0
ffc1c034: 38 80 02 00 li r4,512
ffc1c038: 4b ff 72 cd bl ffc13304 <rtems_rfs_trace>
ffc1c03c: 2f 83 00 00 cmpwi cr7,r3,0
ffc1c040: 41 9e 00 5c beq- cr7,ffc1c09c <rtems_rfs_buffer_handle_release+0x94><== ALWAYS TAKEN
printf ("rtems-rfs: buffer-release: block=%" PRIu32 " %s refs=%d %s\n",
ffc1c044: 88 1e 00 00 lbz r0,0(r30) <== NOT EXECUTED
ffc1c048: 80 9e 00 04 lwz r4,4(r30) <== NOT EXECUTED
ffc1c04c: 2f 80 00 00 cmpwi cr7,r0,0 <== NOT EXECUTED
ffc1c050: 41 9e 00 10 beq- cr7,ffc1c060 <rtems_rfs_buffer_handle_release+0x58><== NOT EXECUTED
ffc1c054: 3c a0 ff c3 lis r5,-61 <== NOT EXECUTED
ffc1c058: 38 a5 43 2c addi r5,r5,17196 <== NOT EXECUTED
ffc1c05c: 48 00 00 0c b ffc1c068 <rtems_rfs_buffer_handle_release+0x60><== NOT EXECUTED
ffc1c060: 3c a0 ff c3 lis r5,-61 <== NOT EXECUTED
ffc1c064: 38 a5 29 67 addi r5,r5,10599 <== 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" : "");
ffc1c068: 81 3e 00 08 lwz r9,8(r30) <== NOT EXECUTED
ffc1c06c: 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",
ffc1c070: 2f 86 00 00 cmpwi cr7,r6,0 <== NOT EXECUTED
ffc1c074: 40 9e 00 10 bne- cr7,ffc1c084 <rtems_rfs_buffer_handle_release+0x7c><== NOT EXECUTED
ffc1c078: 3c e0 ff c3 lis r7,-61 <== NOT EXECUTED
ffc1c07c: 38 e7 43 34 addi r7,r7,17204 <== NOT EXECUTED
ffc1c080: 48 00 00 0c b ffc1c08c <rtems_rfs_buffer_handle_release+0x84><== NOT EXECUTED
ffc1c084: 3c e0 ff c3 lis r7,-61 <== NOT EXECUTED
ffc1c088: 38 e7 29 67 addi r7,r7,10599 <== NOT EXECUTED
ffc1c08c: 3c 60 ff c3 lis r3,-61 <== NOT EXECUTED
ffc1c090: 38 63 43 42 addi r3,r3,17218 <== NOT EXECUTED
ffc1c094: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc1c098: 48 00 6a 51 bl ffc22ae8 <printf> <== 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" : "");
if (rtems_rfs_buffer_refs (handle) > 0)
ffc1c09c: 80 7e 00 08 lwz r3,8(r30)
ffc1c0a0: 81 23 00 38 lwz r9,56(r3)
ffc1c0a4: 2f 89 00 00 cmpwi cr7,r9,0
ffc1c0a8: 40 9d 00 0c ble- cr7,ffc1c0b4 <rtems_rfs_buffer_handle_release+0xac><== NEVER TAKEN
rtems_rfs_buffer_refs_down (handle);
ffc1c0ac: 39 29 ff ff addi r9,r9,-1
ffc1c0b0: 91 23 00 38 stw r9,56(r3)
if (rtems_rfs_buffer_refs (handle) == 0)
ffc1c0b4: 80 03 00 38 lwz r0,56(r3)
int
rtems_rfs_buffer_handle_release (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
int rc = 0;
ffc1c0b8: 3b a0 00 00 li r29,0
rtems_rfs_buffer_refs (handle) == 0 ? "BAD REF COUNT" : "");
if (rtems_rfs_buffer_refs (handle) > 0)
rtems_rfs_buffer_refs_down (handle);
if (rtems_rfs_buffer_refs (handle) == 0)
ffc1c0bc: 2f 80 00 00 cmpwi cr7,r0,0
ffc1c0c0: 40 be 01 14 bne+ cr7,ffc1c1d4 <rtems_rfs_buffer_handle_release+0x1cc>
ffc1c0c4: 4b ff 09 85 bl ffc0ca48 <_Chain_Extract>
{
rtems_chain_extract (rtems_rfs_buffer_link (handle));
fs->buffers_count--;
ffc1c0c8: 81 3f 00 4c lwz r9,76(r31)
ffc1c0cc: 38 09 ff ff addi r0,r9,-1
ffc1c0d0: 90 1f 00 4c stw r0,76(r31)
if (rtems_rfs_fs_no_local_cache (fs))
ffc1c0d4: 80 1f 00 00 lwz r0,0(r31)
ffc1c0d8: 70 00 00 02 andi. r0,r0,2
ffc1c0dc: 41 a2 00 1c beq+ ffc1c0f8 <rtems_rfs_buffer_handle_release+0xf0>
{
handle->buffer->user = (void*) 0;
ffc1c0e0: 80 7e 00 08 lwz r3,8(r30)
rc = rtems_rfs_buffer_io_release (handle->buffer,
ffc1c0e4: 88 9e 00 00 lbz r4,0(r30)
rtems_chain_extract (rtems_rfs_buffer_link (handle));
fs->buffers_count--;
if (rtems_rfs_fs_no_local_cache (fs))
{
handle->buffer->user = (void*) 0;
ffc1c0e8: 93 a3 00 3c stw r29,60(r3)
rc = rtems_rfs_buffer_io_release (handle->buffer,
ffc1c0ec: 48 00 55 9d bl ffc21688 <rtems_rfs_buffer_bdbuf_release>
ffc1c0f0: 7c 7d 1b 78 mr r29,r3
ffc1c0f4: 48 00 00 e0 b ffc1c1d4 <rtems_rfs_buffer_handle_release+0x1cc>
* 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 +
ffc1c0f8: 81 3f 00 5c lwz r9,92(r31)
int
rtems_rfs_buffer_handle_release (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
int rc = 0;
ffc1c0fc: 7c 1d 03 78 mr r29,r0
* 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 +
ffc1c100: 81 7f 00 6c lwz r11,108(r31)
ffc1c104: 7d 6b 4a 14 add r11,r11,r9
ffc1c108: 81 3f 00 3c lwz r9,60(r31)
ffc1c10c: 7f 8b 48 40 cmplw cr7,r11,r9
ffc1c110: 41 bc 00 88 blt+ cr7,ffc1c198 <rtems_rfs_buffer_handle_release+0x190>
fs->release_modified_count) >= fs->max_held_buffers)
{
rtems_rfs_buffer* buffer;
bool modified;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_RELEASE))
ffc1c114: 38 60 00 00 li r3,0
ffc1c118: 38 80 02 00 li r4,512
ffc1c11c: 4b ff 71 e9 bl ffc13304 <rtems_rfs_trace>
ffc1c120: 2f 83 00 00 cmpwi cr7,r3,0
ffc1c124: 41 be 00 20 beq+ cr7,ffc1c144 <rtems_rfs_buffer_handle_release+0x13c><== ALWAYS TAKEN
printf ("rtems-rfs: buffer-release: local cache overflow:"
ffc1c128: 80 9f 00 6c lwz r4,108(r31) <== NOT EXECUTED
ffc1c12c: 3c 60 ff c3 lis r3,-61 <== NOT EXECUTED
ffc1c130: 80 1f 00 5c lwz r0,92(r31) <== NOT EXECUTED
ffc1c134: 38 63 43 76 addi r3,r3,17270 <== NOT EXECUTED
ffc1c138: 7c 84 02 14 add r4,r4,r0 <== NOT EXECUTED
ffc1c13c: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc1c140: 48 00 69 a9 bl ffc22ae8 <printf> <== NOT EXECUTED
" %" PRIu32 "\n", fs->release_count + fs->release_modified_count);
if (fs->release_count > fs->release_modified_count)
ffc1c144: 81 3f 00 5c lwz r9,92(r31)
ffc1c148: 80 1f 00 6c lwz r0,108(r31)
ffc1c14c: 7f 89 00 40 cmplw cr7,r9,r0
ffc1c150: 40 9d 00 20 ble- cr7,ffc1c170 <rtems_rfs_buffer_handle_release+0x168><== ALWAYS TAKEN
*/
RTEMS_INLINE_ROUTINE rtems_chain_node *rtems_chain_get(
rtems_chain_control *the_chain
)
{
return _Chain_Get( the_chain );
ffc1c154: 38 7f 00 50 addi r3,r31,80 <== NOT EXECUTED
ffc1c158: 4b ff 09 19 bl ffc0ca70 <_Chain_Get> <== NOT EXECUTED
{
buffer = (rtems_rfs_buffer*) rtems_chain_get (&fs->release);
fs->release_count--;
ffc1c15c: 81 3f 00 5c lwz r9,92(r31) <== NOT EXECUTED
modified = false;
ffc1c160: 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--;
ffc1c164: 38 09 ff ff addi r0,r9,-1 <== NOT EXECUTED
ffc1c168: 90 1f 00 5c stw r0,92(r31) <== NOT EXECUTED
ffc1c16c: 48 00 00 1c b ffc1c188 <rtems_rfs_buffer_handle_release+0x180><== NOT EXECUTED
ffc1c170: 38 7f 00 60 addi r3,r31,96
ffc1c174: 4b ff 08 fd bl ffc0ca70 <_Chain_Get>
}
else
{
buffer =
(rtems_rfs_buffer*) rtems_chain_get (&fs->release_modified);
fs->release_modified_count--;
ffc1c178: 81 3f 00 6c lwz r9,108(r31)
modified = true;
ffc1c17c: 38 80 00 01 li r4,1
}
else
{
buffer =
(rtems_rfs_buffer*) rtems_chain_get (&fs->release_modified);
fs->release_modified_count--;
ffc1c180: 38 09 ff ff addi r0,r9,-1
ffc1c184: 90 1f 00 6c stw r0,108(r31)
modified = true;
}
buffer->user = (void*) 0;
ffc1c188: 38 00 00 00 li r0,0
ffc1c18c: 90 03 00 3c stw r0,60(r3)
rc = rtems_rfs_buffer_io_release (buffer, modified);
ffc1c190: 48 00 54 f9 bl ffc21688 <rtems_rfs_buffer_bdbuf_release>
ffc1c194: 7c 7d 1b 78 mr r29,r3
}
if (rtems_rfs_buffer_dirty (handle))
ffc1c198: 88 1e 00 00 lbz r0,0(r30)
ffc1c19c: 80 9e 00 08 lwz r4,8(r30)
ffc1c1a0: 2f 80 00 00 cmpwi cr7,r0,0
ffc1c1a4: 41 9e 00 1c beq- cr7,ffc1c1c0 <rtems_rfs_buffer_handle_release+0x1b8>
RTEMS_INLINE_ROUTINE void rtems_chain_append(
rtems_chain_control *the_chain,
rtems_chain_node *the_node
)
{
_Chain_Append( the_chain, the_node );
ffc1c1a8: 38 7f 00 60 addi r3,r31,96
ffc1c1ac: 4b ff 08 6d bl ffc0ca18 <_Chain_Append>
{
rtems_chain_append (&fs->release_modified,
rtems_rfs_buffer_link (handle));
fs->release_modified_count++;
ffc1c1b0: 81 3f 00 6c lwz r9,108(r31)
ffc1c1b4: 38 09 00 01 addi r0,r9,1
ffc1c1b8: 90 1f 00 6c stw r0,108(r31)
ffc1c1bc: 48 00 00 18 b ffc1c1d4 <rtems_rfs_buffer_handle_release+0x1cc>
ffc1c1c0: 38 7f 00 50 addi r3,r31,80
ffc1c1c4: 4b ff 08 55 bl ffc0ca18 <_Chain_Append>
}
else
{
rtems_chain_append (&fs->release, rtems_rfs_buffer_link (handle));
fs->release_count++;
ffc1c1c8: 81 3f 00 5c lwz r9,92(r31)
ffc1c1cc: 38 09 00 01 addi r0,r9,1
ffc1c1d0: 90 1f 00 5c stw r0,92(r31)
}
}
}
handle->buffer = NULL;
ffc1c1d4: 38 00 00 00 li r0,0
ffc1c1d8: 90 1e 00 08 stw r0,8(r30)
}
return rc;
}
ffc1c1dc: 39 61 00 18 addi r11,r1,24
ffc1c1e0: 7f a3 eb 78 mr r3,r29
ffc1c1e4: 4b fe 69 0c b ffc02af0 <_restgpr_29_x>
ffc1c1e8 <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)
{
ffc1c1e8: 94 21 ff e0 stwu r1,-32(r1)
ffc1c1ec: 7c 08 02 a6 mflr r0
ffc1c1f0: 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))
ffc1c1f4: 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)
{
ffc1c1f8: bf 61 00 0c stmw r27,12(r1)
ffc1c1fc: 7c 7d 1b 78 mr r29,r3
/*
* 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))
ffc1c200: 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)
{
ffc1c204: 7c 9e 23 78 mr r30,r4
ffc1c208: 7c bc 2b 78 mr r28,r5
ffc1c20c: 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))
ffc1c210: 41 9e 00 68 beq- cr7,ffc1c278 <rtems_rfs_buffer_handle_request+0x90>
{
/*
* Treat block 0 as special to handle the loading of the super block.
*/
if (block && (rtems_rfs_buffer_bnum (handle) == block))
ffc1c214: 2f 85 00 00 cmpwi cr7,r5,0
ffc1c218: 41 9e 00 14 beq- cr7,ffc1c22c <rtems_rfs_buffer_handle_request+0x44><== NEVER TAKEN
ffc1c21c: 80 04 00 04 lwz r0,4(r4)
return 0;
ffc1c220: 3b e0 00 00 li r31,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))
ffc1c224: 7f 80 28 00 cmpw cr7,r0,r5
ffc1c228: 41 9e 02 5c beq- cr7,ffc1c484 <rtems_rfs_buffer_handle_request+0x29c>
return 0;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))
ffc1c22c: 38 60 00 00 li r3,0
ffc1c230: 38 80 01 00 li r4,256
ffc1c234: 4b ff 70 d1 bl ffc13304 <rtems_rfs_trace>
ffc1c238: 2f 83 00 00 cmpwi cr7,r3,0
ffc1c23c: 41 be 00 18 beq+ cr7,ffc1c254 <rtems_rfs_buffer_handle_request+0x6c><== ALWAYS TAKEN
printf ("rtems-rfs: buffer-request: handle has buffer: %" PRIu32 "\n",
ffc1c240: 3c 60 ff c3 lis r3,-61 <== NOT EXECUTED
ffc1c244: 80 9e 00 04 lwz r4,4(r30) <== NOT EXECUTED
ffc1c248: 38 63 43 b0 addi r3,r3,17328 <== NOT EXECUTED
ffc1c24c: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc1c250: 48 00 68 99 bl ffc22ae8 <printf> <== NOT EXECUTED
rtems_rfs_buffer_bnum (handle));
rc = rtems_rfs_buffer_handle_release (fs, handle);
ffc1c254: 7f a3 eb 78 mr r3,r29
ffc1c258: 7f c4 f3 78 mr r4,r30
ffc1c25c: 4b ff fd ad bl ffc1c008 <rtems_rfs_buffer_handle_release>
if (rc > 0)
ffc1c260: 7c 7f 1b 79 mr. r31,r3
ffc1c264: 41 a1 02 20 bgt+ ffc1c484 <rtems_rfs_buffer_handle_request+0x29c><== NEVER TAKEN
return rc;
handle->dirty = false;
ffc1c268: 38 00 00 00 li r0,0
ffc1c26c: 98 1e 00 00 stb r0,0(r30)
handle->bnum = 0;
ffc1c270: 38 00 00 00 li r0,0
ffc1c274: 90 1e 00 04 stw r0,4(r30)
}
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))
ffc1c278: 38 60 00 00 li r3,0
ffc1c27c: 38 80 01 00 li r4,256
ffc1c280: 4b ff 70 85 bl ffc13304 <rtems_rfs_trace>
ffc1c284: 2f 83 00 00 cmpwi cr7,r3,0
ffc1c288: 41 be 00 18 beq+ cr7,ffc1c2a0 <rtems_rfs_buffer_handle_request+0xb8><== ALWAYS TAKEN
printf ("rtems-rfs: buffer-request: block=%" PRIu32 "\n", block);
ffc1c28c: 3c 60 ff c3 lis r3,-61 <== NOT EXECUTED
ffc1c290: 38 63 43 e3 addi r3,r3,17379 <== NOT EXECUTED
ffc1c294: 7f 84 e3 78 mr r4,r28 <== NOT EXECUTED
ffc1c298: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc1c29c: 48 00 68 4d bl ffc22ae8 <printf> <== NOT EXECUTED
* 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)
ffc1c2a0: 80 1d 00 4c lwz r0,76(r29)
ffc1c2a4: 2f 80 00 00 cmpwi cr7,r0,0
ffc1c2a8: 41 be 00 50 beq+ cr7,ffc1c2f8 <rtems_rfs_buffer_handle_request+0x110>
{
/*
* Check the active buffer list for shared buffers.
*/
handle->buffer = rtems_rfs_scan_chain (&fs->buffers,
ffc1c2ac: 38 7d 00 40 addi r3,r29,64
ffc1c2b0: 38 9d 00 4c addi r4,r29,76
ffc1c2b4: 7f 85 e3 78 mr r5,r28
ffc1c2b8: 4b ff fc 45 bl ffc1befc <rtems_rfs_scan_chain>
&fs->buffers_count,
block);
if (rtems_rfs_buffer_handle_has_block (handle) &&
ffc1c2bc: 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,
ffc1c2c0: 90 7e 00 08 stw r3,8(r30)
&fs->buffers_count,
block);
if (rtems_rfs_buffer_handle_has_block (handle) &&
ffc1c2c4: 41 9e 00 34 beq- cr7,ffc1c2f8 <rtems_rfs_buffer_handle_request+0x110>
rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))
ffc1c2c8: 38 60 00 00 li r3,0
ffc1c2cc: 38 80 01 00 li r4,256
ffc1c2d0: 4b ff 70 35 bl ffc13304 <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) &&
ffc1c2d4: 2f 83 00 00 cmpwi cr7,r3,0
ffc1c2d8: 41 be 00 20 beq+ cr7,ffc1c2f8 <rtems_rfs_buffer_handle_request+0x110><== 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);
ffc1c2dc: 81 3e 00 08 lwz r9,8(r30) <== 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",
ffc1c2e0: 3c 60 ff c3 lis r3,-61 <== NOT EXECUTED
ffc1c2e4: 38 63 44 09 addi r3,r3,17417 <== NOT EXECUTED
ffc1c2e8: 80 89 00 38 lwz r4,56(r9) <== NOT EXECUTED
ffc1c2ec: 38 84 00 01 addi r4,r4,1 <== NOT EXECUTED
ffc1c2f0: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc1c2f4: 48 00 67 f5 bl ffc22ae8 <printf> <== 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) &&
ffc1c2f8: 80 1d 00 00 lwz r0,0(r29)
ffc1c2fc: 70 09 00 02 andi. r9,r0,2
ffc1c300: 40 82 00 6c bne- ffc1c36c <rtems_rfs_buffer_handle_request+0x184>
ffc1c304: 80 1e 00 08 lwz r0,8(r30)
ffc1c308: 2f 80 00 00 cmpwi cr7,r0,0
ffc1c30c: 40 be 00 60 bne+ cr7,ffc1c36c <rtems_rfs_buffer_handle_request+0x184>
!rtems_rfs_buffer_handle_has_block (handle))
{
/*
* Check the local cache of released buffers.
*/
if (fs->release_count)
ffc1c310: 80 1d 00 5c lwz r0,92(r29)
ffc1c314: 2f 80 00 00 cmpwi cr7,r0,0
ffc1c318: 41 be 00 18 beq+ cr7,ffc1c330 <rtems_rfs_buffer_handle_request+0x148>
handle->buffer = rtems_rfs_scan_chain (&fs->release,
ffc1c31c: 38 7d 00 50 addi r3,r29,80
ffc1c320: 38 9d 00 5c addi r4,r29,92
ffc1c324: 7f 85 e3 78 mr r5,r28
ffc1c328: 4b ff fb d5 bl ffc1befc <rtems_rfs_scan_chain>
ffc1c32c: 90 7e 00 08 stw r3,8(r30)
&fs->release_count,
block);
if (!rtems_rfs_buffer_handle_has_block (handle) &&
ffc1c330: 80 1e 00 08 lwz r0,8(r30)
ffc1c334: 2f 80 00 00 cmpwi cr7,r0,0
ffc1c338: 40 be 00 34 bne+ cr7,ffc1c36c <rtems_rfs_buffer_handle_request+0x184>
ffc1c33c: 80 1d 00 6c lwz r0,108(r29)
ffc1c340: 2f 80 00 00 cmpwi cr7,r0,0
ffc1c344: 41 be 00 28 beq+ cr7,ffc1c36c <rtems_rfs_buffer_handle_request+0x184>
fs->release_modified_count)
{
handle->buffer = rtems_rfs_scan_chain (&fs->release_modified,
ffc1c348: 38 7d 00 60 addi r3,r29,96
ffc1c34c: 38 9d 00 6c addi r4,r29,108
ffc1c350: 7f 85 e3 78 mr r5,r28
ffc1c354: 4b ff fb a9 bl ffc1befc <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))
ffc1c358: 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,
ffc1c35c: 90 7e 00 08 stw r3,8(r30)
&fs->release_modified_count,
block);
/*
* If we found a buffer retain the dirty buffer state.
*/
if (rtems_rfs_buffer_handle_has_block (handle))
ffc1c360: 41 9e 00 0c beq- cr7,ffc1c36c <rtems_rfs_buffer_handle_request+0x184>
rtems_rfs_buffer_mark_dirty (handle);
ffc1c364: 38 00 00 01 li r0,1
ffc1c368: 98 1e 00 00 stb r0,0(r30)
}
/*
* If not located we request the buffer from the I/O layer.
*/
if (!rtems_rfs_buffer_handle_has_block (handle))
ffc1c36c: 83 fe 00 08 lwz r31,8(r30)
ffc1c370: 2f 9f 00 00 cmpwi cr7,r31,0
ffc1c374: 40 be 00 88 bne+ cr7,ffc1c3fc <rtems_rfs_buffer_handle_request+0x214>
{
rc = rtems_rfs_buffer_io_request (fs, block, read, &handle->buffer);
ffc1c378: 7f a3 eb 78 mr r3,r29
ffc1c37c: 7f 84 e3 78 mr r4,r28
ffc1c380: 7f 65 db 78 mr r5,r27
ffc1c384: 38 de 00 08 addi r6,r30,8
ffc1c388: 48 00 52 a9 bl ffc21630 <rtems_rfs_buffer_bdbuf_request>
rtems_chain_set_off_chain (rtems_rfs_buffer_link(handle));
ffc1c38c: 81 3e 00 08 lwz r9,8(r30)
ffc1c390: 93 e9 00 04 stw r31,4(r9)
ffc1c394: 93 e9 00 00 stw r31,0(r9)
if (rc > 0)
ffc1c398: 7c 7f 1b 79 mr. r31,r3
ffc1c39c: 40 81 00 60 ble- ffc1c3fc <rtems_rfs_buffer_handle_request+0x214><== ALWAYS TAKEN
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))
ffc1c3a0: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc1c3a4: 38 80 01 00 li r4,256 <== NOT EXECUTED
ffc1c3a8: 4b ff 6f 5d bl ffc13304 <rtems_rfs_trace> <== NOT EXECUTED
ffc1c3ac: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc1c3b0: 41 9e 00 d4 beq- cr7,ffc1c484 <rtems_rfs_buffer_handle_request+0x29c><== NOT EXECUTED
printf ("rtems-rfs: buffer-request: block=%" PRIu32 ": bdbuf-%s: %d: %s\n",
ffc1c3b4: 2f 9b 00 00 cmpwi cr7,r27,0 <== NOT EXECUTED
ffc1c3b8: 41 be 00 10 beq+ cr7,ffc1c3c8 <rtems_rfs_buffer_handle_request+0x1e0><== NOT EXECUTED
ffc1c3bc: 3f c0 ff c3 lis r30,-61 <== NOT EXECUTED
ffc1c3c0: 3b de 39 58 addi r30,r30,14680 <== NOT EXECUTED
ffc1c3c4: 48 00 00 0c b ffc1c3d0 <rtems_rfs_buffer_handle_request+0x1e8><== NOT EXECUTED
ffc1c3c8: 3f c0 ff c3 lis r30,-61 <== NOT EXECUTED
ffc1c3cc: 3b de 43 ac addi r30,r30,17324 <== NOT EXECUTED
ffc1c3d0: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc1c3d4: 48 00 74 81 bl ffc23854 <strerror> <== NOT EXECUTED
ffc1c3d8: 7f 84 e3 78 mr r4,r28 <== NOT EXECUTED
ffc1c3dc: 7c 67 1b 78 mr r7,r3 <== NOT EXECUTED
ffc1c3e0: 3c 60 ff c3 lis r3,-61 <== NOT EXECUTED
ffc1c3e4: 7f c5 f3 78 mr r5,r30 <== NOT EXECUTED
ffc1c3e8: 7f e6 fb 78 mr r6,r31 <== NOT EXECUTED
ffc1c3ec: 38 63 44 3d addi r3,r3,17469 <== NOT EXECUTED
ffc1c3f0: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc1c3f4: 48 00 66 f5 bl ffc22ae8 <printf> <== NOT EXECUTED
ffc1c3f8: 48 00 00 8c b ffc1c484 <rtems_rfs_buffer_handle_request+0x29c><== NOT EXECUTED
}
/*
* Increase the reference count of the buffer.
*/
rtems_rfs_buffer_refs_up (handle);
ffc1c3fc: 80 9e 00 08 lwz r4,8(r30)
ffc1c400: 38 7d 00 40 addi r3,r29,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;
ffc1c404: 3b e0 00 00 li r31,0
}
/*
* Increase the reference count of the buffer.
*/
rtems_rfs_buffer_refs_up (handle);
ffc1c408: 81 24 00 38 lwz r9,56(r4)
ffc1c40c: 38 09 00 01 addi r0,r9,1
ffc1c410: 90 04 00 38 stw r0,56(r4)
ffc1c414: 4b ff 06 05 bl ffc0ca18 <_Chain_Append>
rtems_chain_append (&fs->buffers, rtems_rfs_buffer_link (handle));
fs->buffers_count++;
ffc1c418: 81 3d 00 4c lwz r9,76(r29)
handle->buffer->user = (void*) ((intptr_t) block);
handle->bnum = block;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))
ffc1c41c: 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++;
ffc1c420: 38 09 00 01 addi r0,r9,1
handle->buffer->user = (void*) ((intptr_t) block);
ffc1c424: 81 3e 00 08 lwz r9,8(r30)
/*
* 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++;
ffc1c428: 90 1d 00 4c stw r0,76(r29)
handle->buffer->user = (void*) ((intptr_t) block);
handle->bnum = block;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))
ffc1c42c: 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);
ffc1c430: 93 89 00 3c stw r28,60(r9)
handle->bnum = block;
ffc1c434: 93 9e 00 04 stw r28,4(r30)
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))
ffc1c438: 4b ff 6e cd bl ffc13304 <rtems_rfs_trace>
ffc1c43c: 2f 83 00 00 cmpwi cr7,r3,0
ffc1c440: 41 9e 00 44 beq- cr7,ffc1c484 <rtems_rfs_buffer_handle_request+0x29c><== ALWAYS TAKEN
printf ("rtems-rfs: buffer-request: block=%" PRIu32 " bdbuf-%s=%" PRIu32 " refs=%d\n",
ffc1c444: 2f 9b 00 00 cmpwi cr7,r27,0 <== NOT EXECUTED
ffc1c448: 41 9e 00 10 beq- cr7,ffc1c458 <rtems_rfs_buffer_handle_request+0x270><== NOT EXECUTED
ffc1c44c: 3c a0 ff c3 lis r5,-61 <== NOT EXECUTED
ffc1c450: 38 a5 39 58 addi r5,r5,14680 <== NOT EXECUTED
ffc1c454: 48 00 00 0c b ffc1c460 <rtems_rfs_buffer_handle_request+0x278><== NOT EXECUTED
ffc1c458: 3c a0 ff c3 lis r5,-61 <== NOT EXECUTED
ffc1c45c: 38 a5 43 ac addi r5,r5,17324 <== NOT EXECUTED
block, read ? "read" : "get", handle->buffer->block,
ffc1c460: 81 3e 00 08 lwz r9,8(r30) <== 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",
ffc1c464: 3c 60 ff c3 lis r3,-61 <== NOT EXECUTED
ffc1c468: 38 63 44 75 addi r3,r3,17525 <== NOT EXECUTED
ffc1c46c: 80 c9 00 20 lwz r6,32(r9) <== NOT EXECUTED
ffc1c470: 7f 84 e3 78 mr r4,r28 <== NOT EXECUTED
ffc1c474: 80 e9 00 38 lwz r7,56(r9) <== NOT EXECUTED
block, read ? "read" : "get", handle->buffer->block,
handle->buffer->references);
return 0;
ffc1c478: 3b e0 00 00 li r31,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",
ffc1c47c: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc1c480: 48 00 66 69 bl ffc22ae8 <printf> <== NOT EXECUTED
block, read ? "read" : "get", handle->buffer->block,
handle->buffer->references);
return 0;
}
ffc1c484: 39 61 00 20 addi r11,r1,32
ffc1c488: 7f e3 fb 78 mr r3,r31
ffc1c48c: 4b fe 66 5c b ffc02ae8 <_restgpr_27_x>
ffc1c490 <rtems_rfs_buffer_open>:
return rc;
}
int
rtems_rfs_buffer_open (const char* name, rtems_rfs_file_system* fs)
{
ffc1c490: 94 21 ff 98 stwu r1,-104(r1)
ffc1c494: 7c 08 02 a6 mflr r0
ffc1c498: bf a1 00 5c stmw r29,92(r1)
ffc1c49c: 7c 7e 1b 78 mr r30,r3
ffc1c4a0: 7c 9d 23 78 mr r29,r4
struct stat st;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SYNC))
ffc1c4a4: 38 60 00 00 li r3,0
return rc;
}
int
rtems_rfs_buffer_open (const char* name, rtems_rfs_file_system* fs)
{
ffc1c4a8: 90 01 00 6c stw r0,108(r1)
struct stat st;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SYNC))
ffc1c4ac: 38 80 00 20 li r4,32
ffc1c4b0: 4b ff 6e 55 bl ffc13304 <rtems_rfs_trace>
ffc1c4b4: 2f 83 00 00 cmpwi cr7,r3,0
ffc1c4b8: 41 be 00 18 beq+ cr7,ffc1c4d0 <rtems_rfs_buffer_open+0x40><== ALWAYS TAKEN
printf ("rtems-rfs: buffer-open: opening: %s\n", name);
ffc1c4bc: 3c 60 ff c3 lis r3,-61 <== NOT EXECUTED
ffc1c4c0: 38 63 44 b0 addi r3,r3,17584 <== NOT EXECUTED
ffc1c4c4: 7f c4 f3 78 mr r4,r30 <== NOT EXECUTED
ffc1c4c8: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc1c4cc: 48 00 66 1d bl ffc22ae8 <printf> <== NOT EXECUTED
if (stat (name, &st) < 0)
ffc1c4d0: 7f c3 f3 78 mr r3,r30
ffc1c4d4: 38 81 00 08 addi r4,r1,8
ffc1c4d8: 4b fe cc 19 bl ffc090f0 <stat>
ffc1c4dc: 2f 83 00 00 cmpwi cr7,r3,0
ffc1c4e0: 40 bc 00 3c bge+ cr7,ffc1c51c <rtems_rfs_buffer_open+0x8c><== ALWAYS TAKEN
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_OPEN))
ffc1c4e4: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc1c4e8: 38 80 00 08 li r4,8 <== NOT EXECUTED
ffc1c4ec: 4b ff 6e 19 bl ffc13304 <rtems_rfs_trace> <== NOT EXECUTED
printf ("rtems-rfs: buffer-open: stat '%s' failed: %s\n",
name, strerror (errno));
return ENOENT;
ffc1c4f0: 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))
ffc1c4f4: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc1c4f8: 41 be 00 d4 beq+ cr7,ffc1c5cc <rtems_rfs_buffer_open+0x13c><== NOT EXECUTED
printf ("rtems-rfs: buffer-open: stat '%s' failed: %s\n",
name, strerror (errno));
ffc1c4fc: 48 00 55 09 bl ffc21a04 <__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",
ffc1c500: 80 63 00 00 lwz r3,0(r3) <== NOT EXECUTED
ffc1c504: 48 00 73 51 bl ffc23854 <strerror> <== NOT EXECUTED
ffc1c508: 7f c4 f3 78 mr r4,r30 <== NOT EXECUTED
ffc1c50c: 7c 65 1b 78 mr r5,r3 <== NOT EXECUTED
ffc1c510: 3c 60 ff c3 lis r3,-61 <== NOT EXECUTED
ffc1c514: 38 63 44 d5 addi r3,r3,17621 <== NOT EXECUTED
ffc1c518: 48 00 00 ac b ffc1c5c4 <rtems_rfs_buffer_open+0x134> <== NOT EXECUTED
#if RTEMS_RFS_USE_LIBBLOCK
/*
* Is the device a block device ?
*/
if (!S_ISBLK (st.st_mode))
ffc1c51c: 80 01 00 14 lwz r0,20(r1)
ffc1c520: 54 00 04 26 rlwinm r0,r0,0,16,19
ffc1c524: 2f 80 60 00 cmpwi cr7,r0,24576
ffc1c528: 41 9e 00 34 beq- cr7,ffc1c55c <rtems_rfs_buffer_open+0xcc><== ALWAYS TAKEN
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_OPEN))
ffc1c52c: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc1c530: 38 80 00 08 li r4,8 <== NOT EXECUTED
ffc1c534: 4b ff 6d d1 bl ffc13304 <rtems_rfs_trace> <== NOT EXECUTED
printf ("rtems-rfs: buffer-open: '%s' is not a block device\n", name);
return EIO;
ffc1c538: 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))
ffc1c53c: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc1c540: 41 be 00 8c beq+ cr7,ffc1c5cc <rtems_rfs_buffer_open+0x13c><== NOT EXECUTED
printf ("rtems-rfs: buffer-open: '%s' is not a block device\n", name);
ffc1c544: 3c 60 ff c3 lis r3,-61 <== NOT EXECUTED
ffc1c548: 7f c4 f3 78 mr r4,r30 <== NOT EXECUTED
ffc1c54c: 38 63 45 03 addi r3,r3,17667 <== NOT EXECUTED
ffc1c550: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc1c554: 48 00 65 95 bl ffc22ae8 <printf> <== NOT EXECUTED
ffc1c558: 48 00 00 74 b ffc1c5cc <rtems_rfs_buffer_open+0x13c> <== NOT EXECUTED
}
/*
* Check that device is registred as a block device and lock it.
*/
fs->disk = rtems_disk_obtain (st.st_rdev);
ffc1c55c: 80 61 00 20 lwz r3,32(r1)
ffc1c560: 80 81 00 24 lwz r4,36(r1)
ffc1c564: 4b fe a3 09 bl ffc0686c <rtems_disk_obtain>
if (!fs->disk)
ffc1c568: 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);
ffc1c56c: 90 7d 00 0c stw r3,12(r29)
if (!fs->disk)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_OPEN))
ffc1c570: 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)
ffc1c574: 40 be 00 28 bne+ cr7,ffc1c59c <rtems_rfs_buffer_open+0x10c><== ALWAYS TAKEN
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_OPEN))
ffc1c578: 38 80 00 08 li r4,8 <== NOT EXECUTED
ffc1c57c: 4b ff 6d 89 bl ffc13304 <rtems_rfs_trace> <== NOT EXECUTED
printf ("rtems-rfs: buffer-open: cannot obtain the disk\n");
return EIO;
ffc1c580: 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))
ffc1c584: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc1c588: 41 be 00 44 beq+ cr7,ffc1c5cc <rtems_rfs_buffer_open+0x13c><== NOT EXECUTED
printf ("rtems-rfs: buffer-open: cannot obtain the disk\n");
ffc1c58c: 3c 60 ff c3 lis r3,-61 <== NOT EXECUTED
ffc1c590: 38 63 45 37 addi r3,r3,17719 <== NOT EXECUTED
ffc1c594: 48 00 67 09 bl ffc22c9c <puts> <== NOT EXECUTED
ffc1c598: 48 00 00 34 b ffc1c5cc <rtems_rfs_buffer_open+0x13c> <== NOT EXECUTED
}
fs->media_size = st.st_size;
strcat (fs->name, name);
#endif
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SYNC))
ffc1c59c: 38 80 00 20 li r4,32
ffc1c5a0: 4b ff 6d 65 bl ffc13304 <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;
ffc1c5a4: 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))
ffc1c5a8: 2f 83 00 00 cmpwi cr7,r3,0
ffc1c5ac: 41 be 00 20 beq+ cr7,ffc1c5cc <rtems_rfs_buffer_open+0x13c><== ALWAYS TAKEN
printf ("rtems-rfs: buffer-open: blks=%" PRId32 ", blk-size=%" PRId32 "\n",
rtems_rfs_fs_media_blocks (fs),
ffc1c5b0: 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",
ffc1c5b4: 3c 60 ff c3 lis r3,-61 <== NOT EXECUTED
ffc1c5b8: 38 63 45 66 addi r3,r3,17766 <== NOT EXECUTED
ffc1c5bc: 80 89 00 1c lwz r4,28(r9) <== NOT EXECUTED
ffc1c5c0: 80 a9 00 24 lwz r5,36(r9) <== NOT EXECUTED
ffc1c5c4: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc1c5c8: 48 00 65 21 bl ffc22ae8 <printf> <== NOT EXECUTED
rtems_rfs_fs_media_blocks (fs),
rtems_rfs_fs_media_block_size (fs));
return 0;
}
ffc1c5cc: 39 61 00 68 addi r11,r1,104
ffc1c5d0: 7f e3 fb 78 mr r3,r31
ffc1c5d4: 4b fe 65 1c b ffc02af0 <_restgpr_29_x>
ffc1c700 <rtems_rfs_buffer_setblksize>:
return result;
}
int
rtems_rfs_buffer_setblksize (rtems_rfs_file_system* fs, size_t size)
{
ffc1c700: 94 21 ff e8 stwu r1,-24(r1)
ffc1c704: 7c 08 02 a6 mflr r0
ffc1c708: bf c1 00 10 stmw r30,16(r1)
ffc1c70c: 7c 7f 1b 78 mr r31,r3
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SETBLKSIZE))
ffc1c710: 38 60 00 00 li r3,0
return result;
}
int
rtems_rfs_buffer_setblksize (rtems_rfs_file_system* fs, size_t size)
{
ffc1c714: 90 81 00 08 stw r4,8(r1)
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SETBLKSIZE))
ffc1c718: 38 80 04 00 li r4,1024
return result;
}
int
rtems_rfs_buffer_setblksize (rtems_rfs_file_system* fs, size_t size)
{
ffc1c71c: 90 01 00 1c stw r0,28(r1)
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SETBLKSIZE))
ffc1c720: 4b ff 6b e5 bl ffc13304 <rtems_rfs_trace>
ffc1c724: 2f 83 00 00 cmpwi cr7,r3,0
ffc1c728: 41 be 00 18 beq+ cr7,ffc1c740 <rtems_rfs_buffer_setblksize+0x40><== ALWAYS TAKEN
printf ("rtems-rfs: buffer-setblksize: block size: %zu\n", size);
ffc1c72c: 3c 60 ff c3 lis r3,-61 <== NOT EXECUTED
ffc1c730: 80 81 00 08 lwz r4,8(r1) <== NOT EXECUTED
ffc1c734: 38 63 46 2f addi r3,r3,17967 <== NOT EXECUTED
ffc1c738: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc1c73c: 48 00 63 ad bl ffc22ae8 <printf> <== NOT EXECUTED
rc = rtems_rfs_buffers_release (fs);
ffc1c740: 7f e3 fb 78 mr r3,r31
ffc1c744: 4b ff ff 2d bl ffc1c670 <rtems_rfs_buffers_release>
if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SETBLKSIZE))
ffc1c748: 7c 7e 1b 79 mr. r30,r3
ffc1c74c: 40 81 00 38 ble- ffc1c784 <rtems_rfs_buffer_setblksize+0x84><== ALWAYS TAKEN
ffc1c750: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc1c754: 38 80 04 00 li r4,1024 <== NOT EXECUTED
ffc1c758: 4b ff 6b ad bl ffc13304 <rtems_rfs_trace> <== NOT EXECUTED
ffc1c75c: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc1c760: 41 be 00 24 beq+ cr7,ffc1c784 <rtems_rfs_buffer_setblksize+0x84><== NOT EXECUTED
printf ("rtems-rfs: buffer-setblksize: buffer release failed: %d: %s\n",
ffc1c764: 7f c3 f3 78 mr r3,r30 <== NOT EXECUTED
ffc1c768: 48 00 70 ed bl ffc23854 <strerror> <== NOT EXECUTED
ffc1c76c: 7f c4 f3 78 mr r4,r30 <== NOT EXECUTED
ffc1c770: 7c 65 1b 78 mr r5,r3 <== NOT EXECUTED
ffc1c774: 3c 60 ff c3 lis r3,-61 <== NOT EXECUTED
ffc1c778: 38 63 46 5e addi r3,r3,18014 <== NOT EXECUTED
ffc1c77c: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc1c780: 48 00 63 69 bl ffc22ae8 <printf> <== NOT EXECUTED
rc, strerror (rc));
rc = rtems_rfs_buffer_sync (fs);
ffc1c784: 7f e3 fb 78 mr r3,r31
ffc1c788: 4b ff fe 51 bl ffc1c5d8 <rtems_rfs_buffer_sync>
if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SETBLKSIZE))
ffc1c78c: 7c 7e 1b 79 mr. r30,r3
ffc1c790: 40 81 00 38 ble- ffc1c7c8 <rtems_rfs_buffer_setblksize+0xc8><== ALWAYS TAKEN
ffc1c794: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc1c798: 38 80 04 00 li r4,1024 <== NOT EXECUTED
ffc1c79c: 4b ff 6b 69 bl ffc13304 <rtems_rfs_trace> <== NOT EXECUTED
ffc1c7a0: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc1c7a4: 41 be 00 24 beq+ cr7,ffc1c7c8 <rtems_rfs_buffer_setblksize+0xc8><== NOT EXECUTED
printf ("rtems-rfs: buffer-setblksize: device sync failed: %d: %s\n",
ffc1c7a8: 7f c3 f3 78 mr r3,r30 <== NOT EXECUTED
ffc1c7ac: 48 00 70 a9 bl ffc23854 <strerror> <== NOT EXECUTED
ffc1c7b0: 7f c4 f3 78 mr r4,r30 <== NOT EXECUTED
ffc1c7b4: 7c 65 1b 78 mr r5,r3 <== NOT EXECUTED
ffc1c7b8: 3c 60 ff c3 lis r3,-61 <== NOT EXECUTED
ffc1c7bc: 38 63 46 9b addi r3,r3,18075 <== NOT EXECUTED
ffc1c7c0: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc1c7c4: 48 00 63 25 bl ffc22ae8 <printf> <== NOT EXECUTED
rc, strerror (rc));
#if RTEMS_RFS_USE_LIBBLOCK
rc = fs->disk->ioctl (fs->disk, RTEMS_BLKIO_SETBLKSIZE, &size);
ffc1c7c8: 80 7f 00 0c lwz r3,12(r31)
ffc1c7cc: 3c 80 80 04 lis r4,-32764
ffc1c7d0: 60 84 42 04 ori r4,r4,16900
ffc1c7d4: 80 03 00 28 lwz r0,40(r3)
ffc1c7d8: 38 a1 00 08 addi r5,r1,8
ffc1c7dc: 7c 09 03 a6 mtctr r0
ffc1c7e0: 4e 80 04 21 bctrl
if (rc < 0)
ffc1c7e4: 2c 03 00 00 cmpwi r3,0
ffc1c7e8: 40 a0 00 0c bge+ ffc1c7f4 <rtems_rfs_buffer_setblksize+0xf4><== ALWAYS TAKEN
rc = errno;
ffc1c7ec: 48 00 52 19 bl ffc21a04 <__errno> <== NOT EXECUTED
ffc1c7f0: 80 63 00 00 lwz r3,0(r3) <== NOT EXECUTED
#endif
return rc;
}
ffc1c7f4: 39 61 00 18 addi r11,r1,24
ffc1c7f8: 4b fe 62 fc b ffc02af4 <_restgpr_30_x>
ffc1c5d8 <rtems_rfs_buffer_sync>:
return rc;
}
int
rtems_rfs_buffer_sync (rtems_rfs_file_system* fs)
{
ffc1c5d8: 94 21 ff e8 stwu r1,-24(r1)
ffc1c5dc: 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))
ffc1c5e0: 38 80 00 20 li r4,32
return rc;
}
int
rtems_rfs_buffer_sync (rtems_rfs_file_system* fs)
{
ffc1c5e4: bf a1 00 0c stmw r29,12(r1)
ffc1c5e8: 7c 7e 1b 78 mr r30,r3
int result = 0;
#if RTEMS_RFS_USE_LIBBLOCK
rtems_status_code sc;
#endif
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SYNC))
ffc1c5ec: 38 60 00 00 li r3,0
return rc;
}
int
rtems_rfs_buffer_sync (rtems_rfs_file_system* fs)
{
ffc1c5f0: 90 01 00 1c stw r0,28(r1)
int result = 0;
#if RTEMS_RFS_USE_LIBBLOCK
rtems_status_code sc;
#endif
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SYNC))
ffc1c5f4: 4b ff 6d 11 bl ffc13304 <rtems_rfs_trace>
ffc1c5f8: 2f 83 00 00 cmpwi cr7,r3,0
ffc1c5fc: 41 be 00 10 beq+ cr7,ffc1c60c <rtems_rfs_buffer_sync+0x34><== ALWAYS TAKEN
printf ("rtems-rfs: buffer-sync: syncing\n");
ffc1c600: 3c 60 ff c3 lis r3,-61 <== NOT EXECUTED
ffc1c604: 38 63 45 96 addi r3,r3,17814 <== NOT EXECUTED
ffc1c608: 48 00 66 95 bl ffc22c9c <puts> <== NOT EXECUTED
/*
* @todo Split in the separate files for each type.
*/
#if RTEMS_RFS_USE_LIBBLOCK
sc = rtems_bdbuf_syncdev (rtems_rfs_fs_device (fs));
ffc1c60c: 81 3e 00 0c lwz r9,12(r30)
}
int
rtems_rfs_buffer_sync (rtems_rfs_file_system* fs)
{
int result = 0;
ffc1c610: 3b e0 00 00 li r31,0
/*
* @todo Split in the separate files for each type.
*/
#if RTEMS_RFS_USE_LIBBLOCK
sc = rtems_bdbuf_syncdev (rtems_rfs_fs_device (fs));
ffc1c614: 80 69 00 00 lwz r3,0(r9)
ffc1c618: 80 89 00 04 lwz r4,4(r9)
ffc1c61c: 4b ff 94 b1 bl ffc15acc <rtems_bdbuf_syncdev>
if (sc != RTEMS_SUCCESSFUL)
ffc1c620: 7c 7d 1b 79 mr. r29,r3
ffc1c624: 41 a2 00 38 beq+ ffc1c65c <rtems_rfs_buffer_sync+0x84> <== ALWAYS TAKEN
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SYNC))
ffc1c628: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc1c62c: 38 80 00 20 li r4,32 <== NOT EXECUTED
ffc1c630: 4b ff 6c d5 bl ffc13304 <rtems_rfs_trace> <== NOT EXECUTED
printf ("rtems-rfs: buffer-sync: device sync failed: %s\n",
rtems_status_text (sc));
result = EIO;
ffc1c634: 3b e0 00 05 li r31,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))
ffc1c638: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc1c63c: 41 be 00 20 beq+ cr7,ffc1c65c <rtems_rfs_buffer_sync+0x84><== NOT EXECUTED
printf ("rtems-rfs: buffer-sync: device sync failed: %s\n",
ffc1c640: 7f a3 eb 78 mr r3,r29 <== NOT EXECUTED
ffc1c644: 4b ff ac 79 bl ffc172bc <rtems_status_text> <== NOT EXECUTED
ffc1c648: 7c 64 1b 78 mr r4,r3 <== NOT EXECUTED
ffc1c64c: 3c 60 ff c3 lis r3,-61 <== NOT EXECUTED
ffc1c650: 38 63 45 b6 addi r3,r3,17846 <== NOT EXECUTED
ffc1c654: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc1c658: 48 00 64 91 bl ffc22ae8 <printf> <== NOT EXECUTED
rtems_status_text (sc));
result = EIO;
}
rtems_disk_release (fs->disk);
ffc1c65c: 80 7e 00 0c lwz r3,12(r30)
ffc1c660: 4b fe a2 91 bl ffc068f0 <rtems_disk_release>
printf ("rtems-rfs: buffer-sync: file sync failed: %d: %s\n",
result, strerror (result));
}
#endif
return result;
}
ffc1c664: 39 61 00 18 addi r11,r1,24
ffc1c668: 7f e3 fb 78 mr r3,r31
ffc1c66c: 4b fe 64 84 b ffc02af0 <_restgpr_29_x>
ffc1c670 <rtems_rfs_buffers_release>:
return rrc;
}
int
rtems_rfs_buffers_release (rtems_rfs_file_system* fs)
{
ffc1c670: 94 21 ff f0 stwu r1,-16(r1)
ffc1c674: 7c 08 02 a6 mflr r0
int rrc = 0;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_RELEASE))
ffc1c678: 38 80 00 40 li r4,64
return rrc;
}
int
rtems_rfs_buffers_release (rtems_rfs_file_system* fs)
{
ffc1c67c: bf c1 00 08 stmw r30,8(r1)
ffc1c680: 7c 7f 1b 78 mr r31,r3
int rrc = 0;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_RELEASE))
ffc1c684: 38 60 00 00 li r3,0
return rrc;
}
int
rtems_rfs_buffers_release (rtems_rfs_file_system* fs)
{
ffc1c688: 90 01 00 14 stw r0,20(r1)
int rrc = 0;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_RELEASE))
ffc1c68c: 4b ff 6c 79 bl ffc13304 <rtems_rfs_trace>
ffc1c690: 2f 83 00 00 cmpwi cr7,r3,0
ffc1c694: 41 be 00 20 beq+ cr7,ffc1c6b4 <rtems_rfs_buffers_release+0x44><== ALWAYS TAKEN
printf ("rtems-rfs: buffers-release: active:%" PRIu32 " "
ffc1c698: 3c 60 ff c3 lis r3,-61 <== NOT EXECUTED
ffc1c69c: 80 9f 00 4c lwz r4,76(r31) <== NOT EXECUTED
ffc1c6a0: 80 bf 00 5c lwz r5,92(r31) <== NOT EXECUTED
ffc1c6a4: 38 63 45 e6 addi r3,r3,17894 <== NOT EXECUTED
ffc1c6a8: 80 df 00 6c lwz r6,108(r31) <== NOT EXECUTED
ffc1c6ac: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc1c6b0: 48 00 64 39 bl ffc22ae8 <printf> <== NOT EXECUTED
"release:%" PRIu32 " release-modified:%" PRIu32 "\n",
fs->buffers_count, fs->release_count, fs->release_modified_count);
rc = rtems_rfs_release_chain (&fs->release,
ffc1c6b4: 38 9f 00 5c addi r4,r31,92
ffc1c6b8: 38 a0 00 00 li r5,0
ffc1c6bc: 38 7f 00 50 addi r3,r31,80
ffc1c6c0: 4b ff f7 9d bl ffc1be5c <rtems_rfs_release_chain>
&fs->release_count,
false);
if ((rc > 0) && (rrc == 0))
rrc = rc;
rc = rtems_rfs_release_chain (&fs->release_modified,
ffc1c6c4: 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,
ffc1c6c8: 7c 60 18 f8 not r0,r3
ffc1c6cc: 7c 00 fe 70 srawi r0,r0,31
ffc1c6d0: 7c 7e 00 38 and r30,r3,r0
&fs->release_count,
false);
if ((rc > 0) && (rrc == 0))
rrc = rc;
rc = rtems_rfs_release_chain (&fs->release_modified,
ffc1c6d4: 38 a0 00 01 li r5,1
ffc1c6d8: 38 7f 00 60 addi r3,r31,96
ffc1c6dc: 4b ff f7 81 bl ffc1be5c <rtems_rfs_release_chain>
&fs->release_modified_count,
true);
if ((rc > 0) && (rrc == 0))
ffc1c6e0: 2c 03 00 00 cmpwi r3,0
ffc1c6e4: 40 81 00 10 ble- ffc1c6f4 <rtems_rfs_buffers_release+0x84><== ALWAYS TAKEN
ffc1c6e8: 2f 9e 00 00 cmpwi cr7,r30,0 <== NOT EXECUTED
ffc1c6ec: 40 9e 00 08 bne- cr7,ffc1c6f4 <rtems_rfs_buffers_release+0x84><== NOT EXECUTED
ffc1c6f0: 7c 7e 1b 78 mr r30,r3 <== NOT EXECUTED
rrc = rc;
return rrc;
}
ffc1c6f4: 39 61 00 10 addi r11,r1,16
ffc1c6f8: 7f c3 f3 78 mr r3,r30
ffc1c6fc: 4b fe 63 f8 b ffc02af4 <_restgpr_30_x>
ffc1cdac <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)
{
ffc1cdac: 94 21 ff 58 stwu r1,-168(r1)
ffc1cdb0: 7c 08 02 a6 mflr r0
ffc1cdb4: be 81 00 78 stmw r20,120(r1)
ffc1cdb8: 7c 7f 1b 78 mr r31,r3
ffc1cdbc: 7c 9e 23 78 mr r30,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))
ffc1cdc0: 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)
{
ffc1cdc4: 90 01 00 ac stw r0,172(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))
ffc1cdc8: 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)
{
ffc1cdcc: 7c bc 2b 78 mr r28,r5
ffc1cdd0: 7c dd 33 78 mr r29,r6
ffc1cdd4: 7c fa 3b 78 mr r26,r7
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))
ffc1cdd8: 4b ff 65 2d bl ffc13304 <rtems_rfs_trace>
ffc1cddc: 2f 83 00 00 cmpwi cr7,r3,0
ffc1cde0: 41 be 00 48 beq+ cr7,ffc1ce28 <rtems_rfs_dir_add_entry+0x7c><== ALWAYS TAKEN
{
int c;
printf ("rtems-rfs: dir-add-entry: dir=%" PRId32 ", name=",
ffc1cde4: 3c 60 ff c3 lis r3,-61 <== NOT EXECUTED
ffc1cde8: 80 9e 00 08 lwz r4,8(r30) <== NOT EXECUTED
ffc1cdec: 38 63 49 e0 addi r3,r3,18912 <== NOT EXECUTED
ffc1cdf0: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc1cdf4: 48 00 5c f5 bl ffc22ae8 <printf> <== NOT EXECUTED
rtems_rfs_inode_ino (dir));
for (c = 0; c < length; c++)
ffc1cdf8: 3b 60 00 00 li r27,0 <== NOT EXECUTED
ffc1cdfc: 48 00 00 10 b ffc1ce0c <rtems_rfs_dir_add_entry+0x60><== NOT EXECUTED
printf ("%c", name[c]);
ffc1ce00: 7c 7c d8 ae lbzx r3,r28,r27 <== 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++)
ffc1ce04: 3b 7b 00 01 addi r27,r27,1 <== NOT EXECUTED
printf ("%c", name[c]);
ffc1ce08: 48 00 5d 9d bl ffc22ba4 <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++)
ffc1ce0c: 7f 9b e8 00 cmpw cr7,r27,r29 <== NOT EXECUTED
ffc1ce10: 40 9e ff f0 bne+ cr7,ffc1ce00 <rtems_rfs_dir_add_entry+0x54><== NOT EXECUTED
printf ("%c", name[c]);
printf (", len=%zd\n", length);
ffc1ce14: 3c 60 ff c3 lis r3,-61 <== NOT EXECUTED
ffc1ce18: 38 63 4a 09 addi r3,r3,18953 <== NOT EXECUTED
ffc1ce1c: 7f a4 eb 78 mr r4,r29 <== NOT EXECUTED
ffc1ce20: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc1ce24: 48 00 5c c5 bl ffc22ae8 <printf> <== NOT EXECUTED
}
rc = rtems_rfs_block_map_open (fs, dir, &map);
ffc1ce28: 3b 01 00 24 addi r24,r1,36
ffc1ce2c: 7f e3 fb 78 mr r3,r31
ffc1ce30: 7f c4 f3 78 mr r4,r30
ffc1ce34: 7f 05 c3 78 mr r5,r24
ffc1ce38: 4b ff e3 a5 bl ffc1b1dc <rtems_rfs_block_map_open>
if (rc > 0)
ffc1ce3c: 7c 7b 1b 79 mr. r27,r3
ffc1ce40: 41 a1 02 f4 bgt+ ffc1d134 <rtems_rfs_dir_add_entry+0x388><== NEVER TAKEN
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
ffc1ce44: 38 00 00 00 li r0,0
ffc1ce48: 98 01 00 0c stb r0,12(r1)
handle->bnum = 0;
ffc1ce4c: 38 00 00 00 li r0,0
int elength;
elength = rtems_rfs_dir_entry_length (entry);
eino = rtems_rfs_dir_entry_ino (entry);
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
ffc1ce50: 3a c0 00 00 li r22,0
ffc1ce54: 90 01 00 10 stw r0,16(r1)
ffc1ce58: 62 d6 ff ff ori r22,r22,65535
{
if ((length + RTEMS_RFS_DIR_ENTRY_SIZE) <
ffc1ce5c: 3a fd 00 0a addi r23,r29,10
handle->buffer = NULL;
ffc1ce60: 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;
ffc1ce64: 90 01 00 18 stw r0,24(r1)
bpos->boff = 0;
ffc1ce68: 90 01 00 1c stw r0,28(r1)
bpos->block = 0;
ffc1ce6c: 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);
ffc1ce70: 7f e3 fb 78 mr r3,r31
ffc1ce74: 7f 04 c3 78 mr r4,r24
ffc1ce78: 38 a1 00 18 addi r5,r1,24
ffc1ce7c: 38 c1 00 08 addi r6,r1,8
ffc1ce80: 4b ff e6 fd bl ffc1b57c <rtems_rfs_block_map_find>
if (rc > 0)
ffc1ce84: 7c 7b 1b 79 mr. r27,r3
ffc1ce88: 40 81 00 98 ble- ffc1cf20 <rtems_rfs_dir_add_entry+0x174>
{
if (rc != ENXIO)
ffc1ce8c: 2f 9b 00 06 cmpwi cr7,r27,6
ffc1ce90: 41 be 00 34 beq+ cr7,ffc1cec4 <rtems_rfs_dir_add_entry+0x118><== ALWAYS TAKEN
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_ADD_ENTRY))
ffc1ce94: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc1ce98: 3c 80 20 00 lis r4,8192 <== NOT EXECUTED
ffc1ce9c: 4b ff 64 69 bl ffc13304 <rtems_rfs_trace> <== NOT EXECUTED
ffc1cea0: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc1cea4: 41 be 02 78 beq+ cr7,ffc1d11c <rtems_rfs_dir_add_entry+0x370><== NOT EXECUTED
printf ("rtems-rfs: dir-add-entry: "
ffc1cea8: 7f 63 db 78 mr r3,r27 <== NOT EXECUTED
ffc1ceac: 83 de 00 08 lwz r30,8(r30) <== NOT EXECUTED
ffc1ceb0: 48 00 69 a5 bl ffc23854 <strerror> <== NOT EXECUTED
ffc1ceb4: 7c 66 1b 78 mr r6,r3 <== NOT EXECUTED
ffc1ceb8: 3c 60 ff c3 lis r3,-61 <== NOT EXECUTED
ffc1cebc: 38 63 4a 14 addi r3,r3,18964 <== NOT EXECUTED
ffc1cec0: 48 00 00 4c b ffc1cf0c <rtems_rfs_dir_add_entry+0x160><== NOT EXECUTED
}
/*
* We have reached the end of the directory so add a block.
*/
rc = rtems_rfs_block_map_grow (fs, &map, 1, &block);
ffc1cec4: 7f e3 fb 78 mr r3,r31
ffc1cec8: 7f 04 c3 78 mr r4,r24
ffc1cecc: 38 a0 00 01 li r5,1
ffc1ced0: 38 c1 00 08 addi r6,r1,8
ffc1ced4: 4b ff e8 d9 bl ffc1b7ac <rtems_rfs_block_map_grow>
if (rc > 0)
ffc1ced8: 7c 7b 1b 79 mr. r27,r3
ffc1cedc: 40 a1 00 4c ble+ ffc1cf28 <rtems_rfs_dir_add_entry+0x17c>
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_ADD_ENTRY))
ffc1cee0: 38 60 00 00 li r3,0
ffc1cee4: 3c 80 20 00 lis r4,8192
ffc1cee8: 4b ff 64 1d bl ffc13304 <rtems_rfs_trace>
ffc1ceec: 2f 83 00 00 cmpwi cr7,r3,0
ffc1cef0: 41 be 02 2c beq+ cr7,ffc1d11c <rtems_rfs_dir_add_entry+0x370><== ALWAYS TAKEN
printf ("rtems-rfs: dir-add-entry: "
ffc1cef4: 7f 63 db 78 mr r3,r27 <== NOT EXECUTED
ffc1cef8: 83 de 00 08 lwz r30,8(r30) <== NOT EXECUTED
ffc1cefc: 48 00 69 59 bl ffc23854 <strerror> <== NOT EXECUTED
ffc1cf00: 7c 66 1b 78 mr r6,r3 <== NOT EXECUTED
ffc1cf04: 3c 60 ff c3 lis r3,-61 <== NOT EXECUTED
ffc1cf08: 38 63 4a 59 addi r3,r3,19033 <== NOT EXECUTED
ffc1cf0c: 7f c4 f3 78 mr r4,r30 <== NOT EXECUTED
ffc1cf10: 7f 65 db 78 mr r5,r27 <== NOT EXECUTED
ffc1cf14: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc1cf18: 48 00 5b d1 bl ffc22ae8 <printf> <== NOT EXECUTED
ffc1cf1c: 48 00 02 00 b ffc1d11c <rtems_rfs_dir_add_entry+0x370><== NOT EXECUTED
while (true)
{
rtems_rfs_block_no block;
uint8_t* entry;
int offset;
bool read = true;
ffc1cf20: 3b 20 00 01 li r25,1
ffc1cf24: 48 00 00 08 b ffc1cf2c <rtems_rfs_dir_add_entry+0x180>
"block map grow failed for ino %" PRIu32 ": %d: %s\n",
rtems_rfs_inode_ino (dir), rc, strerror (rc));
break;
}
read = false;
ffc1cf28: 3b 20 00 00 li r25,0
}
bpos.bno++;
ffc1cf2c: 81 21 00 18 lwz r9,24(r1)
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, read);
ffc1cf30: 7f e3 fb 78 mr r3,r31
ffc1cf34: 80 a1 00 08 lwz r5,8(r1)
ffc1cf38: 38 81 00 0c addi r4,r1,12
}
read = false;
}
bpos.bno++;
ffc1cf3c: 38 09 00 01 addi r0,r9,1
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, read);
ffc1cf40: 7f 26 cb 78 mr r6,r25
}
read = false;
}
bpos.bno++;
ffc1cf44: 90 01 00 18 stw r0,24(r1)
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, read);
ffc1cf48: 4b ff f2 a1 bl ffc1c1e8 <rtems_rfs_buffer_handle_request>
if (rc > 0)
ffc1cf4c: 7c 7b 1b 79 mr. r27,r3
ffc1cf50: 40 a1 00 34 ble+ ffc1cf84 <rtems_rfs_dir_add_entry+0x1d8><== ALWAYS TAKEN
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_ADD_ENTRY))
ffc1cf54: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc1cf58: 3c 80 20 00 lis r4,8192 <== NOT EXECUTED
ffc1cf5c: 4b ff 63 a9 bl ffc13304 <rtems_rfs_trace> <== NOT EXECUTED
ffc1cf60: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc1cf64: 41 be 01 b8 beq+ cr7,ffc1d11c <rtems_rfs_dir_add_entry+0x370><== NOT EXECUTED
printf ("rtems-rfs: dir-add-entry: "
ffc1cf68: 7f 63 db 78 mr r3,r27 <== NOT EXECUTED
ffc1cf6c: 83 de 00 08 lwz r30,8(r30) <== NOT EXECUTED
ffc1cf70: 48 00 68 e5 bl ffc23854 <strerror> <== NOT EXECUTED
ffc1cf74: 7c 66 1b 78 mr r6,r3 <== NOT EXECUTED
ffc1cf78: 3c 60 ff c3 lis r3,-61 <== NOT EXECUTED
ffc1cf7c: 38 63 4a 9e addi r3,r3,19102 <== NOT EXECUTED
ffc1cf80: 4b ff ff 8c b ffc1cf0c <rtems_rfs_dir_add_entry+0x160><== NOT EXECUTED
break;
}
entry = rtems_rfs_buffer_data (&buffer);
if (!read)
ffc1cf84: 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);
ffc1cf88: 81 21 00 14 lwz r9,20(r1)
ffc1cf8c: 82 a9 00 24 lwz r21,36(r9)
if (!read)
ffc1cf90: 40 be 00 14 bne+ cr7,ffc1cfa4 <rtems_rfs_dir_add_entry+0x1f8>
memset (entry, 0xff, rtems_rfs_fs_block_size (fs));
ffc1cf94: 80 bf 00 08 lwz r5,8(r31)
ffc1cf98: 7e a3 ab 78 mr r3,r21
ffc1cf9c: 38 80 00 ff li r4,255
ffc1cfa0: 48 00 59 b9 bl ffc22958 <memset>
offset = 0;
while (offset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
ffc1cfa4: 81 3f 00 08 lwz r9,8(r31)
entry = rtems_rfs_buffer_data (&buffer);
if (!read)
memset (entry, 0xff, rtems_rfs_fs_block_size (fs));
offset = 0;
ffc1cfa8: 3b 60 00 00 li r27,0
while (offset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
ffc1cfac: 38 09 ff f6 addi r0,r9,-10
ffc1cfb0: 48 00 01 60 b ffc1d110 <rtems_rfs_dir_add_entry+0x364>
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
ffc1cfb4: 8a 95 00 08 lbz r20,8(r21)
ffc1cfb8: 89 75 00 09 lbz r11,9(r21)
ffc1cfbc: 56 94 40 2e rlwinm r20,r20,8,0,23
eino = rtems_rfs_dir_entry_ino (entry);
ffc1cfc0: 8b 35 00 00 lbz r25,0(r21)
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);
ffc1cfc4: 7e 94 5b 78 or r20,r20,r11
eino = rtems_rfs_dir_entry_ino (entry);
ffc1cfc8: 89 15 00 01 lbz r8,1(r21)
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
ffc1cfcc: 7f 94 b0 00 cmpw cr7,r20,r22
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
eino = rtems_rfs_dir_entry_ino (entry);
ffc1cfd0: 89 75 00 02 lbz r11,2(r21)
ffc1cfd4: 89 55 00 03 lbz r10,3(r21)
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
ffc1cfd8: 40 be 00 9c bne+ cr7,ffc1d074 <rtems_rfs_dir_add_entry+0x2c8>
{
if ((length + RTEMS_RFS_DIR_ENTRY_SIZE) <
(rtems_rfs_fs_block_size (fs) - offset))
ffc1cfdc: 7f 7b 48 50 subf r27,r27,r9
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) <
ffc1cfe0: 7f 97 d8 40 cmplw cr7,r23,r27
ffc1cfe4: 40 9c fe 8c bge+ cr7,ffc1ce70 <rtems_rfs_dir_add_entry+0xc4><== NEVER TAKEN
(rtems_rfs_fs_block_size (fs) - offset))
{
uint32_t hash;
hash = rtems_rfs_dir_hash (name, length);
ffc1cfe8: 7f a4 eb 78 mr r4,r29
ffc1cfec: 7f 83 e3 78 mr r3,r28
ffc1cff0: 48 00 47 2d bl ffc2171c <rtems_rfs_dir_hash>
rtems_rfs_dir_set_entry_hash (entry, hash);
rtems_rfs_dir_set_entry_ino (entry, ino);
ffc1cff4: 9b 55 00 03 stb r26,3(r21)
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);
ffc1cff8: 54 60 46 3e rlwinm r0,r3,8,24,31
ffc1cffc: 98 15 00 04 stb r0,4(r21)
ffc1d000: 54 60 84 3e rlwinm r0,r3,16,16,31
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);
ffc1d004: 7f a5 eb 78 mr r5,r29
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);
ffc1d008: 98 15 00 05 stb r0,5(r21)
ffc1d00c: 54 60 c2 3e rlwinm r0,r3,24,8,31
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);
ffc1d010: 7f 84 e3 78 mr r4,r28
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);
ffc1d014: 98 15 00 06 stb r0,6(r21)
rtems_rfs_dir_set_entry_ino (entry, ino);
ffc1d018: 57 40 46 3e rlwinm r0,r26,8,24,31
RTEMS_RFS_DIR_ENTRY_SIZE + length);
memcpy (entry + RTEMS_RFS_DIR_ENTRY_SIZE, name, length);
rtems_rfs_buffer_mark_dirty (&buffer);
rtems_rfs_buffer_handle_close (fs, &buffer);
rtems_rfs_block_map_close (fs, &map);
return 0;
ffc1d01c: 3b 60 00 00 li r27,0
(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);
ffc1d020: 98 15 00 00 stb r0,0(r21)
ffc1d024: 57 40 84 3e rlwinm r0,r26,16,16,31
ffc1d028: 98 15 00 01 stb r0,1(r21)
ffc1d02c: 57 40 c2 3e rlwinm r0,r26,24,8,31
ffc1d030: 98 15 00 02 stb r0,2(r21)
rtems_rfs_dir_set_entry_length (entry,
ffc1d034: 38 1d 00 0a addi r0,r29,10
ffc1d038: 54 09 c6 3e rlwinm r9,r0,24,24,31
ffc1d03c: 99 35 00 08 stb r9,8(r21)
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);
ffc1d040: 98 75 00 07 stb r3,7(r21)
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);
ffc1d044: 38 75 00 0a addi r3,r21,10
{
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,
ffc1d048: 98 15 00 09 stb r0,9(r21)
RTEMS_RFS_DIR_ENTRY_SIZE + length);
memcpy (entry + RTEMS_RFS_DIR_ENTRY_SIZE, name, length);
ffc1d04c: 48 00 56 f5 bl ffc22740 <memcpy>
rtems_rfs_buffer_mark_dirty (&buffer);
ffc1d050: 7c 24 0b 78 mr r4,r1
ffc1d054: 38 00 00 01 li r0,1
ffc1d058: 9c 04 00 0c stbu r0,12(r4)
rtems_rfs_buffer_handle_close (fs, &buffer);
ffc1d05c: 7f e3 fb 78 mr r3,r31
ffc1d060: 4b ff f8 31 bl ffc1c890 <rtems_rfs_buffer_handle_close>
rtems_rfs_block_map_close (fs, &map);
ffc1d064: 7f e3 fb 78 mr r3,r31
ffc1d068: 38 81 00 24 addi r4,r1,36
ffc1d06c: 4b ff e3 25 bl ffc1b390 <rtems_rfs_block_map_close>
return 0;
ffc1d070: 48 00 00 c4 b ffc1d134 <rtems_rfs_dir_add_entry+0x388>
}
break;
}
if (rtems_rfs_dir_entry_valid (fs, elength, eino))
ffc1d074: 2f 94 00 0a cmpwi cr7,r20,10
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
eino = rtems_rfs_dir_entry_ino (entry);
ffc1d078: 57 39 c0 0e rlwinm r25,r25,24,0,7
ffc1d07c: 55 08 80 1e rlwinm r8,r8,16,0,15
ffc1d080: 7f 39 43 78 or r25,r25,r8
ffc1d084: 7f 39 53 78 or r25,r25,r10
ffc1d088: 55 6b 40 2e rlwinm r11,r11,8,0,23
ffc1d08c: 7f 39 5b 78 or r25,r25,r11
}
break;
}
if (rtems_rfs_dir_entry_valid (fs, elength, eino))
ffc1d090: 40 9d 00 24 ble- cr7,ffc1d0b4 <rtems_rfs_dir_add_entry+0x308><== NEVER TAKEN
ffc1d094: 81 7f 00 18 lwz r11,24(r31)
ffc1d098: 7f 94 58 40 cmplw cr7,r20,r11
ffc1d09c: 40 9c 00 18 bge- cr7,ffc1d0b4 <rtems_rfs_dir_add_entry+0x308><== NEVER TAKEN
ffc1d0a0: 2f 99 00 00 cmpwi cr7,r25,0
ffc1d0a4: 41 9e 00 10 beq- cr7,ffc1d0b4 <rtems_rfs_dir_add_entry+0x308><== NEVER TAKEN
ffc1d0a8: 81 7f 00 10 lwz r11,16(r31)
ffc1d0ac: 7f 99 58 40 cmplw cr7,r25,r11
ffc1d0b0: 40 bd 00 58 ble+ cr7,ffc1d108 <rtems_rfs_dir_add_entry+0x35c><== ALWAYS TAKEN
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_ADD_ENTRY))
ffc1d0b4: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc1d0b8: 3c 80 20 00 lis r4,8192 <== NOT EXECUTED
ffc1d0bc: 4b ff 62 49 bl ffc13304 <rtems_rfs_trace> <== NOT EXECUTED
ffc1d0c0: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc1d0c4: 41 be 00 24 beq+ cr7,ffc1d0e8 <rtems_rfs_dir_add_entry+0x33c><== NOT EXECUTED
printf ("rtems-rfs: dir-add-entry: "
ffc1d0c8: 3c 60 ff c3 lis r3,-61 <== NOT EXECUTED
ffc1d0cc: 80 9e 00 08 lwz r4,8(r30) <== NOT EXECUTED
ffc1d0d0: 38 63 4a e5 addi r3,r3,19173 <== NOT EXECUTED
ffc1d0d4: 7e 85 a3 78 mr r5,r20 <== NOT EXECUTED
ffc1d0d8: 7f 26 cb 78 mr r6,r25 <== NOT EXECUTED
ffc1d0dc: 7f 67 db 78 mr r7,r27 <== NOT EXECUTED
ffc1d0e0: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc1d0e4: 48 00 5a 05 bl ffc22ae8 <printf> <== 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);
ffc1d0e8: 38 81 00 0c addi r4,r1,12 <== NOT EXECUTED
ffc1d0ec: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc1d0f0: 4b ff f7 a1 bl ffc1c890 <rtems_rfs_buffer_handle_close><== NOT EXECUTED
rtems_rfs_block_map_close (fs, &map);
ffc1d0f4: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc1d0f8: 38 81 00 24 addi r4,r1,36 <== NOT EXECUTED
ffc1d0fc: 4b ff e2 95 bl ffc1b390 <rtems_rfs_block_map_close> <== NOT EXECUTED
return EIO;
ffc1d100: 3b 60 00 05 li r27,5 <== NOT EXECUTED
ffc1d104: 48 00 00 30 b ffc1d134 <rtems_rfs_dir_add_entry+0x388><== NOT EXECUTED
}
entry += elength;
ffc1d108: 7e b5 a2 14 add r21,r21,r20
offset += elength;
ffc1d10c: 7f 7b a2 14 add r27,r27,r20
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))
ffc1d110: 7f 9b 00 40 cmplw cr7,r27,r0
ffc1d114: 41 9c fe a0 blt+ cr7,ffc1cfb4 <rtems_rfs_dir_add_entry+0x208><== ALWAYS TAKEN
ffc1d118: 4b ff fd 58 b ffc1ce70 <rtems_rfs_dir_add_entry+0xc4><== NOT EXECUTED
entry += elength;
offset += elength;
}
}
rtems_rfs_buffer_handle_close (fs, &buffer);
ffc1d11c: 38 81 00 0c addi r4,r1,12
ffc1d120: 7f e3 fb 78 mr r3,r31
ffc1d124: 4b ff f7 6d bl ffc1c890 <rtems_rfs_buffer_handle_close>
rtems_rfs_block_map_close (fs, &map);
ffc1d128: 7f e3 fb 78 mr r3,r31
ffc1d12c: 38 81 00 24 addi r4,r1,36
ffc1d130: 4b ff e2 61 bl ffc1b390 <rtems_rfs_block_map_close>
return rc;
}
ffc1d134: 39 61 00 a8 addi r11,r1,168
ffc1d138: 7f 63 db 78 mr r3,r27
ffc1d13c: 4b fe 59 90 b ffc02acc <_restgpr_20_x>
ffc1d140 <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)
{
ffc1d140: 94 21 ff 58 stwu r1,-168(r1)
ffc1d144: 7d 80 00 26 mfcr r12
ffc1d148: 7c 08 02 a6 mflr r0
ffc1d14c: be 41 00 70 stmw r18,112(r1)
ffc1d150: 7c 7f 1b 78 mr r31,r3
ffc1d154: 7c 9c 23 78 mr r28,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))
ffc1d158: 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)
{
ffc1d15c: 90 01 00 ac stw r0,172(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))
ffc1d160: 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)
{
ffc1d164: 91 81 00 6c stw r12,108(r1)
ffc1d168: 7c ba 2b 78 mr r26,r5
ffc1d16c: 7c db 33 78 mr r27,r6
rtems_rfs_block_no block;
rtems_rfs_buffer_handle buffer;
bool search;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY))
ffc1d170: 4b ff 61 95 bl ffc13304 <rtems_rfs_trace>
ffc1d174: 2f 83 00 00 cmpwi cr7,r3,0
ffc1d178: 41 be 00 20 beq+ cr7,ffc1d198 <rtems_rfs_dir_del_entry+0x58><== ALWAYS TAKEN
printf ("rtems-rfs: dir-del-entry: dir=%" PRId32 ", entry=%" PRId32 " offset=%" PRIu32 "\n",
ffc1d17c: 3c 60 ff c3 lis r3,-61 <== NOT EXECUTED
ffc1d180: 80 9c 00 08 lwz r4,8(r28) <== NOT EXECUTED
ffc1d184: 38 63 4b 2d addi r3,r3,19245 <== NOT EXECUTED
ffc1d188: 7f 45 d3 78 mr r5,r26 <== NOT EXECUTED
ffc1d18c: 7f 66 db 78 mr r6,r27 <== NOT EXECUTED
ffc1d190: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc1d194: 48 00 59 55 bl ffc22ae8 <printf> <== NOT EXECUTED
rtems_rfs_inode_ino (dir), ino, offset);
rc = rtems_rfs_block_map_open (fs, dir, &map);
ffc1d198: 3a e1 00 18 addi r23,r1,24
ffc1d19c: 7f e3 fb 78 mr r3,r31
ffc1d1a0: 7f 84 e3 78 mr r4,r28
ffc1d1a4: 7e e5 bb 78 mr r5,r23
ffc1d1a8: 4b ff e0 35 bl ffc1b1dc <rtems_rfs_block_map_open>
if (rc > 0)
ffc1d1ac: 7c 7e 1b 79 mr. r30,r3
ffc1d1b0: 41 a1 03 60 bgt+ ffc1d510 <rtems_rfs_dir_del_entry+0x3d0><== NEVER TAKEN
return rc;
rc = rtems_rfs_block_map_seek (fs, &map, offset, &block);
ffc1d1b4: 3b 01 00 08 addi r24,r1,8
ffc1d1b8: 7f e3 fb 78 mr r3,r31
ffc1d1bc: 7e e4 bb 78 mr r4,r23
ffc1d1c0: 38 a0 00 00 li r5,0
ffc1d1c4: 7f 66 db 78 mr r6,r27
ffc1d1c8: 7f 07 c3 78 mr r7,r24
ffc1d1cc: 4b ff e5 11 bl ffc1b6dc <rtems_rfs_block_map_seek>
ffc1d1d0: 3b a0 00 00 li r29,0
if (rc > 0)
ffc1d1d4: 7c 7e 1b 79 mr. r30,r3
ffc1d1d8: 40 81 00 14 ble- ffc1d1ec <rtems_rfs_dir_del_entry+0xac><== ALWAYS TAKEN
{
if (rc == ENXIO)
ffc1d1dc: 2f 9e 00 06 cmpwi cr7,r30,6 <== NOT EXECUTED
ffc1d1e0: 40 be 02 b4 bne+ cr7,ffc1d494 <rtems_rfs_dir_del_entry+0x354><== NOT EXECUTED
rc = ENOENT;
ffc1d1e4: 3b c0 00 02 li r30,2 <== NOT EXECUTED
ffc1d1e8: 48 00 02 ac b ffc1d494 <rtems_rfs_dir_del_entry+0x354><== NOT EXECUTED
}
/*
* Only search if the offset is 0 else we are at that position.
*/
search = offset ? false : true;
ffc1d1ec: 7f 60 00 34 cntlzw r0,r27
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
ffc1d1f0: 9b a1 00 0c stb r29,12(r1)
ffc1d1f4: 54 00 d9 7e rlwinm r0,r0,27,5,31
int elength;
elength = rtems_rfs_dir_entry_length (entry);
eino = rtems_rfs_dir_entry_ino (entry);
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
ffc1d1f8: 3a c0 00 00 li r22,0
handle->bnum = 0;
ffc1d1fc: 93 a1 00 10 stw r29,16(r1)
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: "
ffc1d200: 3f 20 ff c3 lis r25,-61
handle->buffer = NULL;
ffc1d204: 93 a1 00 14 stw r29,20(r1)
rc = ENOENT;
rtems_rfs_block_map_close (fs, &map);
return rc;
}
rc = rtems_rfs_buffer_handle_open (fs, &buffer);
ffc1d208: 3b c0 00 00 li r30,0
/*
* If we are searching start at the beginning of the block. If not searching
* skip to the offset in the block.
*/
if (search)
ffc1d20c: 2e 00 00 00 cmpwi cr4,r0,0
int elength;
elength = rtems_rfs_dir_entry_length (entry);
eino = rtems_rfs_dir_entry_ino (entry);
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
ffc1d210: 62 d6 ff ff ori r22,r22,65535
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: "
ffc1d214: 3b 39 4b ad addi r25,r25,19373
/*
* Only search if the offset is 0 else we are at that position.
*/
search = offset ? false : true;
while (rc == 0)
ffc1d218: 48 00 02 d0 b ffc1d4e8 <rtems_rfs_dir_del_entry+0x3a8>
{
uint8_t* entry;
int eoffset;
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, true);
ffc1d21c: 80 a1 00 08 lwz r5,8(r1)
ffc1d220: 7f e3 fb 78 mr r3,r31
ffc1d224: 38 81 00 0c addi r4,r1,12
ffc1d228: 38 c0 00 01 li r6,1
ffc1d22c: 4b ff ef bd bl ffc1c1e8 <rtems_rfs_buffer_handle_request>
if (rc > 0)
ffc1d230: 7c 75 1b 79 mr. r21,r3
ffc1d234: 40 a1 00 44 ble+ ffc1d278 <rtems_rfs_dir_del_entry+0x138><== ALWAYS TAKEN
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY))
ffc1d238: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc1d23c: 3c 80 40 00 lis r4,16384 <== NOT EXECUTED
ffc1d240: 4b ff 60 c5 bl ffc13304 <rtems_rfs_trace> <== NOT EXECUTED
ffc1d244: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc1d248: 41 be 02 ac beq+ cr7,ffc1d4f4 <rtems_rfs_dir_del_entry+0x3b4><== NOT EXECUTED
printf ("rtems-rfs: dir-del-entry: "
ffc1d24c: 7e a3 ab 78 mr r3,r21 <== NOT EXECUTED
ffc1d250: 83 dc 00 08 lwz r30,8(r28) <== NOT EXECUTED
ffc1d254: 48 00 66 01 bl ffc23854 <strerror> <== NOT EXECUTED
ffc1d258: 7e a5 ab 78 mr r5,r21 <== NOT EXECUTED
ffc1d25c: 7c 66 1b 78 mr r6,r3 <== NOT EXECUTED
ffc1d260: 3c 60 ff c3 lis r3,-61 <== NOT EXECUTED
ffc1d264: 7f c4 f3 78 mr r4,r30 <== NOT EXECUTED
ffc1d268: 38 63 4b 66 addi r3,r3,19302 <== NOT EXECUTED
ffc1d26c: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc1d270: 48 00 58 79 bl ffc22ae8 <printf> <== NOT EXECUTED
ffc1d274: 48 00 02 80 b ffc1d4f4 <rtems_rfs_dir_del_entry+0x3b4><== NOT EXECUTED
/*
* If we are searching start at the beginning of the block. If not searching
* skip to the offset in the block.
*/
if (search)
eoffset = 0;
ffc1d278: 3b a0 00 00 li r29,0
/*
* If we are searching start at the beginning of the block. If not searching
* skip to the offset in the block.
*/
if (search)
ffc1d27c: 40 92 00 14 bne- cr4,ffc1d290 <rtems_rfs_dir_del_entry+0x150><== NEVER TAKEN
eoffset = 0;
else
eoffset = offset % rtems_rfs_fs_block_size (fs);
ffc1d280: 80 1f 00 08 lwz r0,8(r31)
ffc1d284: 7f bb 03 96 divwu r29,r27,r0
ffc1d288: 7f bd 01 d6 mullw r29,r29,r0
ffc1d28c: 7f bd d8 50 subf r29,r29,r27
entry = rtems_rfs_buffer_data (&buffer) + eoffset;
ffc1d290: 81 21 00 14 lwz r9,20(r1)
ffc1d294: 82 89 00 24 lwz r20,36(r9)
while (eoffset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
ffc1d298: 81 3f 00 08 lwz r9,8(r31)
if (search)
eoffset = 0;
else
eoffset = offset % rtems_rfs_fs_block_size (fs);
entry = rtems_rfs_buffer_data (&buffer) + eoffset;
ffc1d29c: 7e 94 ea 14 add r20,r20,r29
while (eoffset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
ffc1d2a0: 38 09 ff f6 addi r0,r9,-10
ffc1d2a4: 48 00 02 0c b ffc1d4b0 <rtems_rfs_dir_del_entry+0x370>
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
ffc1d2a8: 8a 74 00 08 lbz r19,8(r20)
ffc1d2ac: 89 74 00 09 lbz r11,9(r20)
ffc1d2b0: 56 73 40 2e rlwinm r19,r19,8,0,23
eino = rtems_rfs_dir_entry_ino (entry);
ffc1d2b4: 8a 54 00 00 lbz r18,0(r20)
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);
ffc1d2b8: 7e 73 5b 78 or r19,r19,r11
eino = rtems_rfs_dir_entry_ino (entry);
ffc1d2bc: 89 14 00 01 lbz r8,1(r20)
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
ffc1d2c0: 7f 93 b0 00 cmpw cr7,r19,r22
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
eino = rtems_rfs_dir_entry_ino (entry);
ffc1d2c4: 89 74 00 02 lbz r11,2(r20)
ffc1d2c8: 89 54 00 03 lbz r10,3(r20)
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
ffc1d2cc: 41 9e 01 ec beq- cr7,ffc1d4b8 <rtems_rfs_dir_del_entry+0x378><== NEVER TAKEN
break;
if (rtems_rfs_dir_entry_valid (fs, elength, eino))
ffc1d2d0: 2f 93 00 0a cmpwi cr7,r19,10
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
eino = rtems_rfs_dir_entry_ino (entry);
ffc1d2d4: 56 52 c0 0e rlwinm r18,r18,24,0,7
ffc1d2d8: 55 08 80 1e rlwinm r8,r8,16,0,15
ffc1d2dc: 7e 52 43 78 or r18,r18,r8
ffc1d2e0: 7e 52 53 78 or r18,r18,r10
ffc1d2e4: 55 6b 40 2e rlwinm r11,r11,8,0,23
ffc1d2e8: 7e 52 5b 78 or r18,r18,r11
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
break;
if (rtems_rfs_dir_entry_valid (fs, elength, eino))
ffc1d2ec: 40 9d 00 24 ble- cr7,ffc1d310 <rtems_rfs_dir_del_entry+0x1d0><== NEVER TAKEN
ffc1d2f0: 81 7f 00 18 lwz r11,24(r31)
ffc1d2f4: 7f 93 58 40 cmplw cr7,r19,r11
ffc1d2f8: 40 9c 00 18 bge- cr7,ffc1d310 <rtems_rfs_dir_del_entry+0x1d0><== NEVER TAKEN
ffc1d2fc: 2f 92 00 00 cmpwi cr7,r18,0
ffc1d300: 41 9e 00 10 beq- cr7,ffc1d310 <rtems_rfs_dir_del_entry+0x1d0><== NEVER TAKEN
ffc1d304: 81 7f 00 10 lwz r11,16(r31)
ffc1d308: 7f 92 58 40 cmplw cr7,r18,r11
ffc1d30c: 40 bd 00 3c ble+ cr7,ffc1d348 <rtems_rfs_dir_del_entry+0x208><== ALWAYS TAKEN
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY))
ffc1d310: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc1d314: 3c 80 40 00 lis r4,16384 <== NOT EXECUTED
ffc1d318: 4b ff 5f ed bl ffc13304 <rtems_rfs_trace> <== NOT EXECUTED
ffc1d31c: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc1d320: 41 be 02 04 beq+ cr7,ffc1d524 <rtems_rfs_dir_del_entry+0x3e4><== NOT EXECUTED
printf ("rtems-rfs: dir-del-entry: "
ffc1d324: 80 9c 00 08 lwz r4,8(r28) <== NOT EXECUTED
ffc1d328: 7f 23 cb 78 mr r3,r25 <== NOT EXECUTED
ffc1d32c: 80 e1 00 08 lwz r7,8(r1) <== NOT EXECUTED
ffc1d330: 7e 65 9b 78 mr r5,r19 <== NOT EXECUTED
ffc1d334: 7e 46 93 78 mr r6,r18 <== NOT EXECUTED
ffc1d338: 7f a8 eb 78 mr r8,r29 <== NOT EXECUTED
ffc1d33c: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc1d340: 48 00 57 a9 bl ffc22ae8 <printf> <== NOT EXECUTED
ffc1d344: 48 00 01 e0 b ffc1d524 <rtems_rfs_dir_del_entry+0x3e4><== NOT EXECUTED
rtems_rfs_inode_ino (dir), elength, eino, block, eoffset);
rc = EIO;
break;
}
if (ino == rtems_rfs_dir_entry_ino (entry))
ffc1d348: 7f 9a 90 00 cmpw cr7,r26,r18
ffc1d34c: 40 be 01 58 bne+ cr7,ffc1d4a4 <rtems_rfs_dir_del_entry+0x364><== NEVER TAKEN
{
uint32_t remaining;
remaining = rtems_rfs_fs_block_size (fs) - (eoffset + elength);
ffc1d350: 7f 7d 9a 14 add r27,r29,r19
ffc1d354: 7f 7b 48 50 subf r27,r27,r9
memmove (entry, entry + elength, remaining);
ffc1d358: 7f 65 db 78 mr r5,r27
ffc1d35c: 7c 94 9a 14 add r4,r20,r19
ffc1d360: 7e 83 a3 78 mr r3,r20
ffc1d364: 48 00 54 c1 bl ffc22824 <memmove>
memset (entry + remaining, 0xff, elength);
ffc1d368: 7c 74 da 14 add r3,r20,r27
ffc1d36c: 38 80 00 ff li r4,255
ffc1d370: 7e 65 9b 78 mr r5,r19
ffc1d374: 48 00 55 e5 bl ffc22958 <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);
ffc1d378: 8b 74 00 08 lbz r27,8(r20)
ffc1d37c: 88 14 00 09 lbz r0,9(r20)
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY))
ffc1d380: 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);
ffc1d384: 57 7b 40 2e rlwinm r27,r27,8,0,23
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY))
ffc1d388: 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);
ffc1d38c: 7f 7b 03 78 or r27,r27,r0
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY))
ffc1d390: 4b ff 5f 75 bl ffc13304 <rtems_rfs_trace>
ffc1d394: 2f 83 00 00 cmpwi cr7,r3,0
ffc1d398: 41 9e 00 5c beq- cr7,ffc1d3f4 <rtems_rfs_dir_del_entry+0x2b4><== 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");
ffc1d39c: 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: "
ffc1d3a0: 80 c1 00 08 lwz r6,8(r1) <== NOT EXECUTED
ffc1d3a4: 2f 80 00 00 cmpwi cr7,r0,0 <== NOT EXECUTED
ffc1d3a8: 81 21 00 20 lwz r9,32(r1) <== NOT EXECUTED
ffc1d3ac: 40 9e 00 0c bne- cr7,ffc1d3b8 <rtems_rfs_dir_del_entry+0x278><== 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");
ffc1d3b0: 2f 89 00 00 cmpwi cr7,r9,0 <== NOT EXECUTED
ffc1d3b4: 41 9e 00 10 beq- cr7,ffc1d3c4 <rtems_rfs_dir_del_entry+0x284><== NOT EXECUTED
ffc1d3b8: 39 29 ff ff addi r9,r9,-1 <== NOT EXECUTED
ffc1d3bc: 7f 80 48 00 cmpw cr7,r0,r9 <== NOT EXECUTED
ffc1d3c0: 40 be 00 10 bne+ cr7,ffc1d3d0 <rtems_rfs_dir_del_entry+0x290><== 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: "
ffc1d3c4: 3d 00 ff c3 lis r8,-61 <== NOT EXECUTED
ffc1d3c8: 39 08 34 57 addi r8,r8,13399 <== NOT EXECUTED
ffc1d3cc: 48 00 00 0c b ffc1d3d8 <rtems_rfs_dir_del_entry+0x298><== NOT EXECUTED
ffc1d3d0: 3d 00 ff c3 lis r8,-61 <== NOT EXECUTED
ffc1d3d4: 39 08 38 ec addi r8,r8,14572 <== NOT EXECUTED
ffc1d3d8: 3c 60 ff c3 lis r3,-61 <== NOT EXECUTED
ffc1d3dc: 38 63 4b f9 addi r3,r3,19449 <== NOT EXECUTED
ffc1d3e0: 7f 44 d3 78 mr r4,r26 <== NOT EXECUTED
ffc1d3e4: 7f 65 db 78 mr r5,r27 <== NOT EXECUTED
ffc1d3e8: 7f a7 eb 78 mr r7,r29 <== NOT EXECUTED
ffc1d3ec: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc1d3f0: 48 00 56 f9 bl ffc22ae8 <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) &&
ffc1d3f4: 6f 60 ff ff xoris r0,r27,65535
ffc1d3f8: 2f 80 ff ff cmpwi cr7,r0,-1
ffc1d3fc: 40 9e 00 84 bne- cr7,ffc1d480 <rtems_rfs_dir_del_entry+0x340>
ffc1d400: 2f 9d 00 00 cmpwi cr7,r29,0
ffc1d404: 40 9e 00 7c bne- cr7,ffc1d480 <rtems_rfs_dir_del_entry+0x340><== ALWAYS TAKEN
(eoffset == 0) && rtems_rfs_block_map_last (&map))
ffc1d408: 80 01 00 28 lwz r0,40(r1) <== NOT EXECUTED
ffc1d40c: 81 21 00 20 lwz r9,32(r1) <== NOT EXECUTED
ffc1d410: 2f 80 00 00 cmpwi cr7,r0,0 <== NOT EXECUTED
ffc1d414: 40 9e 00 0c bne- cr7,ffc1d420 <rtems_rfs_dir_del_entry+0x2e0><== NOT EXECUTED
ffc1d418: 2f 89 00 00 cmpwi cr7,r9,0 <== NOT EXECUTED
ffc1d41c: 41 9e 00 10 beq- cr7,ffc1d42c <rtems_rfs_dir_del_entry+0x2ec><== NOT EXECUTED
ffc1d420: 39 29 ff ff addi r9,r9,-1 <== NOT EXECUTED
ffc1d424: 7f 80 48 00 cmpw cr7,r0,r9 <== NOT EXECUTED
ffc1d428: 40 be 00 58 bne+ cr7,ffc1d480 <rtems_rfs_dir_del_entry+0x340><== NOT EXECUTED
{
rc = rtems_rfs_block_map_shrink (fs, &map, 1);
ffc1d42c: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc1d430: 38 81 00 18 addi r4,r1,24 <== NOT EXECUTED
ffc1d434: 38 a0 00 01 li r5,1 <== NOT EXECUTED
ffc1d438: 4b ff e7 05 bl ffc1bb3c <rtems_rfs_block_map_shrink> <== NOT EXECUTED
if (rc > 0)
ffc1d43c: 7c 7d 1b 79 mr. r29,r3 <== NOT EXECUTED
ffc1d440: 40 81 00 40 ble- ffc1d480 <rtems_rfs_dir_del_entry+0x340><== NOT EXECUTED
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY))
ffc1d444: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc1d448: 3c 80 40 00 lis r4,16384 <== NOT EXECUTED
ffc1d44c: 4b ff 5e b9 bl ffc13304 <rtems_rfs_trace> <== NOT EXECUTED
ffc1d450: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc1d454: 41 be 00 2c beq+ cr7,ffc1d480 <rtems_rfs_dir_del_entry+0x340><== NOT EXECUTED
printf ("rtems-rfs: dir-del-entry: "
ffc1d458: 7f a3 eb 78 mr r3,r29 <== NOT EXECUTED
ffc1d45c: 83 9c 00 08 lwz r28,8(r28) <== NOT EXECUTED
ffc1d460: 48 00 63 f5 bl ffc23854 <strerror> <== NOT EXECUTED
ffc1d464: 7f a5 eb 78 mr r5,r29 <== NOT EXECUTED
ffc1d468: 7c 66 1b 78 mr r6,r3 <== NOT EXECUTED
ffc1d46c: 3c 60 ff c3 lis r3,-61 <== NOT EXECUTED
ffc1d470: 38 63 4c 58 addi r3,r3,19544 <== NOT EXECUTED
ffc1d474: 7f 84 e3 78 mr r4,r28 <== NOT EXECUTED
ffc1d478: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc1d47c: 48 00 56 6d bl ffc22ae8 <printf> <== NOT EXECUTED
"block map shrink failed for ino %" PRIu32 ": %d: %s\n",
rtems_rfs_inode_ino (dir), rc, strerror (rc));
}
}
rtems_rfs_buffer_mark_dirty (&buffer);
ffc1d480: 7c 24 0b 78 mr r4,r1
ffc1d484: 38 00 00 01 li r0,1
ffc1d488: 9c 04 00 0c stbu r0,12(r4)
rtems_rfs_buffer_handle_close (fs, &buffer);
ffc1d48c: 7f e3 fb 78 mr r3,r31
ffc1d490: 4b ff f4 01 bl ffc1c890 <rtems_rfs_buffer_handle_close>
rtems_rfs_block_map_close (fs, &map);
ffc1d494: 7f e3 fb 78 mr r3,r31
ffc1d498: 38 81 00 18 addi r4,r1,24
ffc1d49c: 4b ff de f5 bl ffc1b390 <rtems_rfs_block_map_close>
return 0;
ffc1d4a0: 48 00 00 70 b ffc1d510 <rtems_rfs_dir_del_entry+0x3d0>
}
if (!search)
ffc1d4a4: 41 92 00 80 beq- cr4,ffc1d524 <rtems_rfs_dir_del_entry+0x3e4><== NOT EXECUTED
{
rc = EIO;
break;
}
entry += elength;
ffc1d4a8: 7e 94 9a 14 add r20,r20,r19 <== NOT EXECUTED
eoffset += elength;
ffc1d4ac: 7f bd 9a 14 add r29,r29,r19 <== 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))
ffc1d4b0: 7f 9d 00 40 cmplw cr7,r29,r0
ffc1d4b4: 41 9c fd f4 blt+ cr7,ffc1d2a8 <rtems_rfs_dir_del_entry+0x168><== ALWAYS TAKEN
entry += elength;
eoffset += elength;
}
if (rc == 0)
ffc1d4b8: 2f 95 00 00 cmpwi cr7,r21,0 <== NOT EXECUTED
ffc1d4bc: 40 9e 00 28 bne- cr7,ffc1d4e4 <rtems_rfs_dir_del_entry+0x3a4><== NOT EXECUTED
{
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
ffc1d4c0: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc1d4c4: 7e e4 bb 78 mr r4,r23 <== NOT EXECUTED
ffc1d4c8: 7f 05 c3 78 mr r5,r24 <== NOT EXECUTED
ffc1d4cc: 4b ff e2 a1 bl ffc1b76c <rtems_rfs_block_map_next_block><== NOT EXECUTED
if (rc == ENXIO)
ffc1d4d0: 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);
ffc1d4d4: 7c 7e 1b 78 mr r30,r3 <== NOT EXECUTED
if (rc == ENXIO)
ffc1d4d8: 40 be 00 10 bne+ cr7,ffc1d4e8 <rtems_rfs_dir_del_entry+0x3a8><== NOT EXECUTED
rc = ENOENT;
ffc1d4dc: 3b c0 00 02 li r30,2 <== NOT EXECUTED
ffc1d4e0: 48 00 00 10 b ffc1d4f0 <rtems_rfs_dir_del_entry+0x3b0><== NOT EXECUTED
rc = ENOENT;
rtems_rfs_block_map_close (fs, &map);
return rc;
}
rc = rtems_rfs_buffer_handle_open (fs, &buffer);
ffc1d4e4: 7e be ab 78 mr r30,r21 <== NOT EXECUTED
/*
* Only search if the offset is 0 else we are at that position.
*/
search = offset ? false : true;
while (rc == 0)
ffc1d4e8: 2f 9e 00 00 cmpwi cr7,r30,0
ffc1d4ec: 41 9e fd 30 beq+ cr7,ffc1d21c <rtems_rfs_dir_del_entry+0xdc><== ALWAYS TAKEN
ffc1d4f0: 7f d5 f3 78 mr r21,r30 <== NOT EXECUTED
if (rc == ENXIO)
rc = ENOENT;
}
}
rtems_rfs_buffer_handle_close (fs, &buffer);
ffc1d4f4: 38 81 00 0c addi r4,r1,12 <== NOT EXECUTED
ffc1d4f8: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc1d4fc: 4b ff f3 95 bl ffc1c890 <rtems_rfs_buffer_handle_close><== NOT EXECUTED
rtems_rfs_block_map_close (fs, &map);
ffc1d500: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc1d504: 38 81 00 18 addi r4,r1,24 <== NOT EXECUTED
ffc1d508: 4b ff de 89 bl ffc1b390 <rtems_rfs_block_map_close> <== NOT EXECUTED
return rc;
ffc1d50c: 7e be ab 78 mr r30,r21 <== NOT EXECUTED
}
ffc1d510: 81 81 00 6c lwz r12,108(r1)
ffc1d514: 39 61 00 a8 addi r11,r1,168
ffc1d518: 7f c3 f3 78 mr r3,r30
ffc1d51c: 7d 80 81 20 mtcrf 8,r12
ffc1d520: 4b fe 55 a4 b ffc02ac4 <_restgpr_18_x>
rc = ENOENT;
rtems_rfs_block_map_close (fs, &map);
return rc;
}
rc = rtems_rfs_buffer_handle_open (fs, &buffer);
ffc1d524: 3a a0 00 05 li r21,5 <== NOT EXECUTED
ffc1d528: 4b ff ff bc b ffc1d4e4 <rtems_rfs_dir_del_entry+0x3a4><== NOT EXECUTED
ffc1d8a8 <rtems_rfs_dir_empty>:
int
rtems_rfs_dir_empty (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* dir)
{
ffc1d8a8: 94 21 ff 70 stwu r1,-144(r1) <== NOT EXECUTED
ffc1d8ac: 7c 08 02 a6 mflr r0 <== NOT EXECUTED
ffc1d8b0: be c1 00 68 stmw r22,104(r1) <== NOT EXECUTED
ffc1d8b4: 7c 7f 1b 78 mr r31,r3 <== NOT EXECUTED
ffc1d8b8: 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))
ffc1d8bc: 38 60 00 00 li r3,0 <== NOT EXECUTED
}
int
rtems_rfs_dir_empty (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* dir)
{
ffc1d8c0: 90 01 00 94 stw r0,148(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))
ffc1d8c4: 3c 80 80 00 lis r4,-32768 <== NOT EXECUTED
ffc1d8c8: 4b ff 5a 3d bl ffc13304 <rtems_rfs_trace> <== NOT EXECUTED
ffc1d8cc: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc1d8d0: 41 be 00 18 beq+ cr7,ffc1d8e8 <rtems_rfs_dir_empty+0x40><== NOT EXECUTED
printf ("rtems-rfs: dir-empty: dir=%" PRId32 "\n", rtems_rfs_inode_ino (dir));
ffc1d8d4: 3c 60 ff c3 lis r3,-61 <== NOT EXECUTED
ffc1d8d8: 80 9d 00 08 lwz r4,8(r29) <== NOT EXECUTED
ffc1d8dc: 38 63 4d 78 addi r3,r3,19832 <== NOT EXECUTED
ffc1d8e0: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc1d8e4: 48 00 52 05 bl ffc22ae8 <printf> <== NOT EXECUTED
empty = true;
rc = rtems_rfs_block_map_open (fs, dir, &map);
ffc1d8e8: 3b c1 00 18 addi r30,r1,24 <== NOT EXECUTED
ffc1d8ec: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc1d8f0: 7f a4 eb 78 mr r4,r29 <== NOT EXECUTED
ffc1d8f4: 7f c5 f3 78 mr r5,r30 <== NOT EXECUTED
ffc1d8f8: 4b ff d8 e5 bl ffc1b1dc <rtems_rfs_block_map_open> <== NOT EXECUTED
if (rc > 0)
ffc1d8fc: 7c 77 1b 79 mr. r23,r3 <== NOT EXECUTED
ffc1d900: 41 a1 01 b8 bgt+ ffc1dab8 <rtems_rfs_dir_empty+0x210> <== NOT EXECUTED
return rc;
rc = rtems_rfs_block_map_seek (fs, &map, 0, &block);
ffc1d904: 3b 81 00 08 addi r28,r1,8 <== NOT EXECUTED
ffc1d908: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc1d90c: 7f c4 f3 78 mr r4,r30 <== NOT EXECUTED
ffc1d910: 38 a0 00 00 li r5,0 <== NOT EXECUTED
ffc1d914: 38 c0 00 00 li r6,0 <== NOT EXECUTED
ffc1d918: 7f 87 e3 78 mr r7,r28 <== NOT EXECUTED
ffc1d91c: 4b ff dd c1 bl ffc1b6dc <rtems_rfs_block_map_seek> <== NOT EXECUTED
if (rc > 0)
ffc1d920: 7c 77 1b 79 mr. r23,r3 <== NOT EXECUTED
ffc1d924: 40 a1 00 10 ble+ ffc1d934 <rtems_rfs_dir_empty+0x8c> <== NOT EXECUTED
{
rtems_rfs_block_map_close (fs, &map);
ffc1d928: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc1d92c: 7f c4 f3 78 mr r4,r30 <== NOT EXECUTED
ffc1d930: 48 00 01 84 b ffc1dab4 <rtems_rfs_dir_empty+0x20c> <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
ffc1d934: 38 00 00 00 li r0,0 <== NOT EXECUTED
ffc1d938: 98 01 00 0c stb r0,12(r1) <== NOT EXECUTED
handle->bnum = 0;
ffc1d93c: 38 00 00 00 li r0,0 <== 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)
ffc1d940: 3b 40 00 00 li r26,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: "
ffc1d944: 3f 60 ff c3 lis r27,-61 <== NOT EXECUTED
ffc1d948: 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)
ffc1d94c: 63 5a ff ff ori r26,r26,65535 <== NOT EXECUTED
handle->buffer = NULL;
ffc1d950: 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: "
ffc1d954: 3b 7b 4d 97 addi r27,r27,19863 <== NOT EXECUTED
while (empty)
{
uint8_t* entry;
int offset;
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, true);
ffc1d958: 80 a1 00 08 lwz r5,8(r1) <== NOT EXECUTED
ffc1d95c: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc1d960: 38 81 00 0c addi r4,r1,12 <== NOT EXECUTED
ffc1d964: 38 c0 00 01 li r6,1 <== NOT EXECUTED
ffc1d968: 4b ff e8 81 bl ffc1c1e8 <rtems_rfs_buffer_handle_request><== NOT EXECUTED
if (rc > 0)
ffc1d96c: 7c 77 1b 79 mr. r23,r3 <== NOT EXECUTED
ffc1d970: 41 81 01 30 bgt- ffc1daa0 <rtems_rfs_dir_empty+0x1f8> <== NOT EXECUTED
break;
entry = rtems_rfs_buffer_data (&buffer);
ffc1d974: 81 21 00 14 lwz r9,20(r1) <== NOT EXECUTED
offset = 0;
ffc1d978: 3b 20 00 00 li r25,0 <== NOT EXECUTED
while (offset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
ffc1d97c: 81 7f 00 08 lwz r11,8(r31) <== NOT EXECUTED
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, true);
if (rc > 0)
break;
entry = rtems_rfs_buffer_data (&buffer);
ffc1d980: 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))
ffc1d984: 38 0b ff f6 addi r0,r11,-10 <== NOT EXECUTED
ffc1d988: 48 00 00 d8 b ffc1da60 <rtems_rfs_dir_empty+0x1b8> <== NOT EXECUTED
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
ffc1d98c: 8a c9 00 08 lbz r22,8(r9) <== NOT EXECUTED
ffc1d990: 89 69 00 09 lbz r11,9(r9) <== NOT EXECUTED
ffc1d994: 56 d6 40 2e rlwinm r22,r22,8,0,23 <== NOT EXECUTED
eino = rtems_rfs_dir_entry_ino (entry);
ffc1d998: 8b 09 00 00 lbz r24,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);
ffc1d99c: 7e d6 5b 78 or r22,r22,r11 <== NOT EXECUTED
eino = rtems_rfs_dir_entry_ino (entry);
ffc1d9a0: 89 09 00 01 lbz r8,1(r9) <== NOT EXECUTED
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
ffc1d9a4: 7f 96 d0 00 cmpw cr7,r22,r26 <== NOT EXECUTED
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
eino = rtems_rfs_dir_entry_ino (entry);
ffc1d9a8: 89 69 00 02 lbz r11,2(r9) <== NOT EXECUTED
ffc1d9ac: 89 49 00 03 lbz r10,3(r9) <== NOT EXECUTED
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
ffc1d9b0: 41 9e 00 b8 beq- cr7,ffc1da68 <rtems_rfs_dir_empty+0x1c0><== NOT EXECUTED
break;
if (rtems_rfs_dir_entry_valid (fs, elength, eino))
ffc1d9b4: 2f 96 00 0a cmpwi cr7,r22,10 <== NOT EXECUTED
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
eino = rtems_rfs_dir_entry_ino (entry);
ffc1d9b8: 57 18 c0 0e rlwinm r24,r24,24,0,7 <== NOT EXECUTED
ffc1d9bc: 55 08 80 1e rlwinm r8,r8,16,0,15 <== NOT EXECUTED
ffc1d9c0: 7f 18 43 78 or r24,r24,r8 <== NOT EXECUTED
ffc1d9c4: 7f 18 53 78 or r24,r24,r10 <== NOT EXECUTED
ffc1d9c8: 55 6b 40 2e rlwinm r11,r11,8,0,23 <== NOT EXECUTED
ffc1d9cc: 7f 18 5b 78 or r24,r24,r11 <== NOT EXECUTED
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
break;
if (rtems_rfs_dir_entry_valid (fs, elength, eino))
ffc1d9d0: 40 9d 00 24 ble- cr7,ffc1d9f4 <rtems_rfs_dir_empty+0x14c><== NOT EXECUTED
ffc1d9d4: 81 7f 00 18 lwz r11,24(r31) <== NOT EXECUTED
ffc1d9d8: 7f 96 58 40 cmplw cr7,r22,r11 <== NOT EXECUTED
ffc1d9dc: 40 9c 00 18 bge- cr7,ffc1d9f4 <rtems_rfs_dir_empty+0x14c><== NOT EXECUTED
ffc1d9e0: 2f 98 00 00 cmpwi cr7,r24,0 <== NOT EXECUTED
ffc1d9e4: 41 9e 00 10 beq- cr7,ffc1d9f4 <rtems_rfs_dir_empty+0x14c><== NOT EXECUTED
ffc1d9e8: 81 7f 00 10 lwz r11,16(r31) <== NOT EXECUTED
ffc1d9ec: 7f 98 58 40 cmplw cr7,r24,r11 <== NOT EXECUTED
ffc1d9f0: 40 bd 00 38 ble+ cr7,ffc1da28 <rtems_rfs_dir_empty+0x180><== NOT EXECUTED
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_EMPTY))
ffc1d9f4: 38 60 00 01 li r3,1 <== NOT EXECUTED
ffc1d9f8: 38 80 00 00 li r4,0 <== NOT EXECUTED
ffc1d9fc: 4b ff 59 09 bl ffc13304 <rtems_rfs_trace> <== NOT EXECUTED
ffc1da00: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc1da04: 41 be 00 64 beq+ cr7,ffc1da68 <rtems_rfs_dir_empty+0x1c0><== NOT EXECUTED
printf ("rtems-rfs: dir-empty: "
ffc1da08: 80 9d 00 08 lwz r4,8(r29) <== NOT EXECUTED
ffc1da0c: 7f 63 db 78 mr r3,r27 <== NOT EXECUTED
ffc1da10: 7e c5 b3 78 mr r5,r22 <== NOT EXECUTED
ffc1da14: 7f 06 c3 78 mr r6,r24 <== NOT EXECUTED
ffc1da18: 7f 27 cb 78 mr r7,r25 <== NOT EXECUTED
ffc1da1c: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc1da20: 48 00 50 c9 bl ffc22ae8 <printf> <== NOT EXECUTED
ffc1da24: 48 00 00 44 b ffc1da68 <rtems_rfs_dir_empty+0x1c0> <== NOT EXECUTED
/*
* Ignore the current (.) and parent (..) entries. Anything else means
* the directory is not empty.
*/
if (((elength != (RTEMS_RFS_DIR_ENTRY_SIZE + 1)) ||
ffc1da28: 2f 96 00 0b cmpwi cr7,r22,11 <== NOT EXECUTED
ffc1da2c: 40 be 00 0c bne+ cr7,ffc1da38 <rtems_rfs_dir_empty+0x190><== NOT EXECUTED
ffc1da30: 89 69 00 0a lbz r11,10(r9) <== NOT EXECUTED
ffc1da34: 48 00 00 1c b ffc1da50 <rtems_rfs_dir_empty+0x1a8> <== NOT EXECUTED
(entry[RTEMS_RFS_DIR_ENTRY_SIZE] != '.')) &&
ffc1da38: 2f 96 00 0c cmpwi cr7,r22,12 <== NOT EXECUTED
ffc1da3c: 40 9e 00 50 bne- cr7,ffc1da8c <rtems_rfs_dir_empty+0x1e4><== NOT EXECUTED
((elength != (RTEMS_RFS_DIR_ENTRY_SIZE + 2)) ||
ffc1da40: 89 69 00 0a lbz r11,10(r9) <== NOT EXECUTED
ffc1da44: 2f 8b 00 2e cmpwi cr7,r11,46 <== NOT EXECUTED
ffc1da48: 40 9e 00 44 bne- cr7,ffc1da8c <rtems_rfs_dir_empty+0x1e4><== NOT EXECUTED
(entry[RTEMS_RFS_DIR_ENTRY_SIZE] != '.') ||
ffc1da4c: 89 69 00 0b lbz r11,11(r9) <== NOT EXECUTED
ffc1da50: 2f 8b 00 2e cmpwi cr7,r11,46 <== NOT EXECUTED
ffc1da54: 40 9e 00 38 bne- cr7,ffc1da8c <rtems_rfs_dir_empty+0x1e4><== NOT EXECUTED
{
empty = false;
break;
}
entry += elength;
ffc1da58: 7d 29 b2 14 add r9,r9,r22 <== NOT EXECUTED
offset += elength;
ffc1da5c: 7f 39 b2 14 add r25,r25,r22 <== NOT EXECUTED
break;
entry = rtems_rfs_buffer_data (&buffer);
offset = 0;
while (offset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
ffc1da60: 7f 99 00 40 cmplw cr7,r25,r0 <== NOT EXECUTED
ffc1da64: 41 9c ff 28 blt+ cr7,ffc1d98c <rtems_rfs_dir_empty+0xe4><== NOT EXECUTED
offset += elength;
}
if (empty)
{
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
ffc1da68: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc1da6c: 7f c4 f3 78 mr r4,r30 <== NOT EXECUTED
ffc1da70: 7f 85 e3 78 mr r5,r28 <== NOT EXECUTED
ffc1da74: 4b ff dc f9 bl ffc1b76c <rtems_rfs_block_map_next_block><== NOT EXECUTED
if (rc > 0)
ffc1da78: 7c 77 1b 79 mr. r23,r3 <== NOT EXECUTED
ffc1da7c: 40 81 fe dc ble+ ffc1d958 <rtems_rfs_dir_empty+0xb0> <== NOT EXECUTED
{
if (rc == ENXIO)
ffc1da80: 2f 97 00 06 cmpwi cr7,r23,6 <== NOT EXECUTED
ffc1da84: 40 be 00 1c bne+ cr7,ffc1daa0 <rtems_rfs_dir_empty+0x1f8><== NOT EXECUTED
ffc1da88: 48 00 00 14 b ffc1da9c <rtems_rfs_dir_empty+0x1f4> <== NOT EXECUTED
break;
}
}
}
if ((rc == 0) && !empty)
ffc1da8c: 2f 97 00 00 cmpwi cr7,r23,0 <== NOT EXECUTED
ffc1da90: 40 9e 00 10 bne- cr7,ffc1daa0 <rtems_rfs_dir_empty+0x1f8><== NOT EXECUTED
rc = ENOTEMPTY;
ffc1da94: 3a e0 00 5a li r23,90 <== NOT EXECUTED
ffc1da98: 48 00 00 08 b ffc1daa0 <rtems_rfs_dir_empty+0x1f8> <== NOT EXECUTED
if (empty)
{
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
if (rc > 0)
{
if (rc == ENXIO)
ffc1da9c: 3a e0 00 00 li r23,0 <== NOT EXECUTED
}
if ((rc == 0) && !empty)
rc = ENOTEMPTY;
rtems_rfs_buffer_handle_close (fs, &buffer);
ffc1daa0: 38 81 00 0c addi r4,r1,12 <== NOT EXECUTED
ffc1daa4: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc1daa8: 4b ff ed e9 bl ffc1c890 <rtems_rfs_buffer_handle_close><== NOT EXECUTED
rtems_rfs_block_map_close (fs, &map);
ffc1daac: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc1dab0: 38 81 00 18 addi r4,r1,24 <== NOT EXECUTED
ffc1dab4: 4b ff d8 dd bl ffc1b390 <rtems_rfs_block_map_close> <== NOT EXECUTED
return rc;
}
ffc1dab8: 39 61 00 90 addi r11,r1,144 <== NOT EXECUTED
ffc1dabc: 7e e3 bb 78 mr r3,r23 <== NOT EXECUTED
ffc1dac0: 4b fe 50 14 b ffc02ad4 <_restgpr_22_x> <== NOT EXECUTED
ffc2171c <rtems_rfs_dir_hash>:
{
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;
ffc2171c: 39 04 ff ff addi r8,r4,-1
ffc21720: 39 40 00 0c li r10,12
ffc21724: 7d 48 53 96 divwu r10,r8,r10
ffc21728: 2f 84 00 00 cmpwi cr7,r4,0
ffc2172c: 3d 24 df df addis r9,r4,-8225
ffc21730: 38 09 16 9f addi r0,r9,5791
ffc21734: 7c 09 03 78 mr r9,r0
ffc21738: 7c 0b 03 78 mr r11,r0
ffc2173c: 39 4a 00 01 addi r10,r10,1
ffc21740: 40 be 00 f8 bne+ cr7,ffc21838 <rtems_rfs_dir_hash+0x11c><== ALWAYS TAKEN
ffc21744: 39 40 00 01 li r10,1 <== NOT EXECUTED
ffc21748: 48 00 00 f0 b ffc21838 <rtems_rfs_dir_hash+0x11c> <== NOT EXECUTED
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];
ffc2174c: 89 03 00 00 lbz r8,0(r3)
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;
ffc21750: 38 84 ff f4 addi r4,r4,-12
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];
ffc21754: 7d 68 5a 14 add r11,r8,r11
a += ((uint32_t)k[1])<<8;
ffc21758: 89 03 00 01 lbz r8,1(r3)
ffc2175c: 55 08 40 2e rlwinm r8,r8,8,0,23
ffc21760: 7d 6b 42 14 add r11,r11,r8
a += ((uint32_t)k[2])<<16;
ffc21764: 89 03 00 02 lbz r8,2(r3)
ffc21768: 55 08 80 1e rlwinm r8,r8,16,0,15
ffc2176c: 7d 6b 42 14 add r11,r11,r8
a += ((uint32_t)k[3])<<24;
ffc21770: 89 03 00 03 lbz r8,3(r3)
ffc21774: 55 08 c0 0e rlwinm r8,r8,24,0,7
ffc21778: 7d 6b 42 14 add r11,r11,r8
b += k[4];
ffc2177c: 89 03 00 04 lbz r8,4(r3)
ffc21780: 7d 28 4a 14 add r9,r8,r9
b += ((uint32_t)k[5])<<8;
ffc21784: 89 03 00 05 lbz r8,5(r3)
ffc21788: 55 08 40 2e rlwinm r8,r8,8,0,23
ffc2178c: 7d 29 42 14 add r9,r9,r8
b += ((uint32_t)k[6])<<16;
ffc21790: 89 03 00 06 lbz r8,6(r3)
ffc21794: 55 08 80 1e rlwinm r8,r8,16,0,15
ffc21798: 7d 29 42 14 add r9,r9,r8
b += ((uint32_t)k[7])<<24;
ffc2179c: 89 03 00 07 lbz r8,7(r3)
ffc217a0: 55 08 c0 0e rlwinm r8,r8,24,0,7
ffc217a4: 7d 29 42 14 add r9,r9,r8
c += k[8];
ffc217a8: 89 03 00 08 lbz r8,8(r3)
ffc217ac: 7c 08 02 14 add r0,r8,r0
c += ((uint32_t)k[9])<<8;
ffc217b0: 89 03 00 09 lbz r8,9(r3)
ffc217b4: 55 08 40 2e rlwinm r8,r8,8,0,23
ffc217b8: 7c 00 42 14 add r0,r0,r8
c += ((uint32_t)k[10])<<16;
ffc217bc: 89 03 00 0a lbz r8,10(r3)
ffc217c0: 55 08 80 1e rlwinm r8,r8,16,0,15
ffc217c4: 7c 00 42 14 add r0,r0,r8
c += ((uint32_t)k[11])<<24;
ffc217c8: 89 03 00 0b lbz r8,11(r3)
mix(a,b,c);
length -= 12;
k += 12;
ffc217cc: 38 63 00 0c addi r3,r3,12
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;
ffc217d0: 55 08 c0 0e rlwinm r8,r8,24,0,7
ffc217d4: 7c 00 42 14 add r0,r0,r8
mix(a,b,c);
ffc217d8: 54 08 20 3e rotlwi r8,r0,4
ffc217dc: 7d 60 58 50 subf r11,r0,r11
ffc217e0: 7d 6b 42 78 xor r11,r11,r8
ffc217e4: 7c 00 4a 14 add r0,r0,r9
ffc217e8: 55 68 30 3e rotlwi r8,r11,6
ffc217ec: 7d 2b 48 50 subf r9,r11,r9
ffc217f0: 7d 09 4a 78 xor r9,r8,r9
ffc217f4: 7d 6b 02 14 add r11,r11,r0
ffc217f8: 55 28 40 3e rotlwi r8,r9,8
ffc217fc: 7c 09 00 50 subf r0,r9,r0
ffc21800: 7d 00 02 78 xor r0,r8,r0
ffc21804: 7d 29 5a 14 add r9,r9,r11
ffc21808: 54 08 80 3e rotlwi r8,r0,16
ffc2180c: 7d 60 58 50 subf r11,r0,r11
ffc21810: 7d 0b 5a 78 xor r11,r8,r11
ffc21814: 7c 00 4a 14 add r0,r0,r9
ffc21818: 55 68 98 3e rotlwi r8,r11,19
ffc2181c: 7d 2b 48 50 subf r9,r11,r9
ffc21820: 7d 09 4a 78 xor r9,r8,r9
ffc21824: 7d 6b 02 14 add r11,r11,r0
ffc21828: 55 28 20 3e rotlwi r8,r9,4
ffc2182c: 7c 09 00 50 subf r0,r9,r0
ffc21830: 7d 00 02 78 xor r0,r8,r0
ffc21834: 7d 29 5a 14 add r9,r9,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)
ffc21838: 35 4a ff ff addic. r10,r10,-1
ffc2183c: 40 82 ff 10 bne+ ffc2174c <rtems_rfs_dir_hash+0x30>
length -= 12;
k += 12;
}
/*-------------------------------- last block: affect all 32 bits of (c) */
switch(length) /* all the case statements fall through */
ffc21840: 38 84 ff ff addi r4,r4,-1
ffc21844: 2b 84 00 0b cmplwi cr7,r4,11
ffc21848: 41 9d 00 f8 bgt- cr7,ffc21940 <rtems_rfs_dir_hash+0x224><== NEVER TAKEN
ffc2184c: 3d 40 ff c3 lis r10,-61
ffc21850: 39 4a 57 e0 addi r10,r10,22496
ffc21854: 54 84 10 3a rlwinm r4,r4,2,0,29
ffc21858: 7d 0a 20 2e lwzx r8,r10,r4
ffc2185c: 7d 48 52 14 add r10,r8,r10
ffc21860: 7d 49 03 a6 mtctr r10
ffc21864: 4e 80 04 20 bctr
{
case 12: c+=((uint32_t)k[11])<<24;
ffc21868: 89 43 00 0b lbz r10,11(r3)
ffc2186c: 55 4a c0 0e rlwinm r10,r10,24,0,7
ffc21870: 7c 0a 02 14 add r0,r10,r0
case 11: c+=((uint32_t)k[10])<<16;
ffc21874: 89 43 00 0a lbz r10,10(r3)
ffc21878: 55 4a 80 1e rlwinm r10,r10,16,0,15
ffc2187c: 7c 00 52 14 add r0,r0,r10
case 10: c+=((uint32_t)k[9])<<8;
ffc21880: 89 43 00 09 lbz r10,9(r3)
ffc21884: 55 4a 40 2e rlwinm r10,r10,8,0,23
ffc21888: 7c 00 52 14 add r0,r0,r10
case 9 : c+=k[8];
ffc2188c: 89 43 00 08 lbz r10,8(r3)
ffc21890: 7c 00 52 14 add r0,r0,r10
case 8 : b+=((uint32_t)k[7])<<24;
ffc21894: 89 43 00 07 lbz r10,7(r3)
ffc21898: 55 4a c0 0e rlwinm r10,r10,24,0,7
ffc2189c: 7d 2a 4a 14 add r9,r10,r9
case 7 : b+=((uint32_t)k[6])<<16;
ffc218a0: 89 43 00 06 lbz r10,6(r3)
ffc218a4: 55 4a 80 1e rlwinm r10,r10,16,0,15
ffc218a8: 7d 29 52 14 add r9,r9,r10
case 6 : b+=((uint32_t)k[5])<<8;
ffc218ac: 89 43 00 05 lbz r10,5(r3)
ffc218b0: 55 4a 40 2e rlwinm r10,r10,8,0,23
ffc218b4: 7d 29 52 14 add r9,r9,r10
case 5 : b+=k[4];
ffc218b8: 89 43 00 04 lbz r10,4(r3)
ffc218bc: 7d 29 52 14 add r9,r9,r10
case 4 : a+=((uint32_t)k[3])<<24;
ffc218c0: 89 43 00 03 lbz r10,3(r3)
ffc218c4: 55 4a c0 0e rlwinm r10,r10,24,0,7
ffc218c8: 7d 6a 5a 14 add r11,r10,r11
case 3 : a+=((uint32_t)k[2])<<16;
ffc218cc: 89 43 00 02 lbz r10,2(r3)
ffc218d0: 55 4a 80 1e rlwinm r10,r10,16,0,15
ffc218d4: 7d 6b 52 14 add r11,r11,r10
case 2 : a+=((uint32_t)k[1])<<8;
ffc218d8: 89 43 00 01 lbz r10,1(r3)
ffc218dc: 55 4a 40 2e rlwinm r10,r10,8,0,23
ffc218e0: 7d 6b 52 14 add r11,r11,r10
case 1 : a+=k[0];
ffc218e4: 89 43 00 00 lbz r10,0(r3)
break;
case 0 : return c;
}
}
final(a,b,c);
ffc218e8: 7c 00 4a 78 xor r0,r0,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];
ffc218ec: 7d 6b 52 14 add r11,r11,r10
break;
case 0 : return c;
}
}
final(a,b,c);
ffc218f0: 55 2a 70 3e rotlwi r10,r9,14
ffc218f4: 7c 0a 00 50 subf r0,r10,r0
ffc218f8: 54 0a 58 3e rotlwi r10,r0,11
ffc218fc: 7c 0b 5a 78 xor r11,r0,r11
ffc21900: 7d 6a 58 50 subf r11,r10,r11
ffc21904: 55 6a c8 3e rotlwi r10,r11,25
ffc21908: 7d 69 4a 78 xor r9,r11,r9
ffc2190c: 7d 2a 48 50 subf r9,r10,r9
ffc21910: 7d 20 02 78 xor r0,r9,r0
ffc21914: 55 28 80 3e rotlwi r8,r9,16
ffc21918: 7d 48 00 50 subf r10,r8,r0
ffc2191c: 55 40 20 3e rotlwi r0,r10,4
ffc21920: 7d 4b 5a 78 xor r11,r10,r11
ffc21924: 7d 60 58 50 subf r11,r0,r11
ffc21928: 7d 69 4a 78 xor r9,r11,r9
ffc2192c: 55 6b 70 3e rotlwi r11,r11,14
ffc21930: 7d 2b 48 50 subf r9,r11,r9
ffc21934: 7d 20 52 78 xor r0,r9,r10
ffc21938: 55 29 c0 3e rotlwi r9,r9,24
ffc2193c: 7c 09 00 50 subf r0,r9,r0
return c;
}
ffc21940: 7c 03 03 78 mr r3,r0
ffc21944: 4e 80 00 20 blr
ffc1c8cc <rtems_rfs_dir_lookup_ino>:
rtems_rfs_inode_handle* inode,
const char* name,
int length,
rtems_rfs_ino* ino,
uint32_t* offset)
{
ffc1c8cc: 94 21 ff 50 stwu r1,-176(r1)
ffc1c8d0: 7c 08 02 a6 mflr r0
ffc1c8d4: bd c1 00 68 stmw r14,104(r1)
ffc1c8d8: 7c 7d 1b 78 mr r29,r3
ffc1c8dc: 7c 9c 23 78 mr r28,r4
rtems_rfs_block_map map;
rtems_rfs_buffer_handle entries;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
ffc1c8e0: 38 60 00 00 li r3,0
rtems_rfs_inode_handle* inode,
const char* name,
int length,
rtems_rfs_ino* ino,
uint32_t* offset)
{
ffc1c8e4: 90 01 00 b4 stw r0,180(r1)
rtems_rfs_block_map map;
rtems_rfs_buffer_handle entries;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
ffc1c8e8: 3c 80 04 00 lis r4,1024
rtems_rfs_inode_handle* inode,
const char* name,
int length,
rtems_rfs_ino* ino,
uint32_t* offset)
{
ffc1c8ec: 7c b7 2b 78 mr r23,r5
ffc1c8f0: 7c d9 33 78 mr r25,r6
ffc1c8f4: 7c f8 3b 78 mr r24,r7
ffc1c8f8: 7d 16 43 78 mr r22,r8
rtems_rfs_block_map map;
rtems_rfs_buffer_handle entries;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
ffc1c8fc: 4b ff 6a 09 bl ffc13304 <rtems_rfs_trace>
ffc1c900: 2f 83 00 00 cmpwi cr7,r3,0
ffc1c904: 41 be 00 48 beq+ cr7,ffc1c94c <rtems_rfs_dir_lookup_ino+0x80><== ALWAYS TAKEN
{
int c;
printf ("rtems-rfs: dir-lookup-ino: lookup ino: root=%" PRId32 ", path=",
ffc1c908: 3c 60 ff c3 lis r3,-61 <== NOT EXECUTED
ffc1c90c: 80 9c 00 08 lwz r4,8(r28) <== NOT EXECUTED
ffc1c910: 38 63 47 38 addi r3,r3,18232 <== NOT EXECUTED
ffc1c914: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc1c918: 48 00 61 d1 bl ffc22ae8 <printf> <== NOT EXECUTED
inode->ino);
for (c = 0; c < length; c++)
ffc1c91c: 3b e0 00 00 li r31,0 <== NOT EXECUTED
ffc1c920: 48 00 00 10 b ffc1c930 <rtems_rfs_dir_lookup_ino+0x64><== NOT EXECUTED
printf ("%c", name[c]);
ffc1c924: 7c 77 f8 ae lbzx r3,r23,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++)
ffc1c928: 3b ff 00 01 addi r31,r31,1 <== NOT EXECUTED
printf ("%c", name[c]);
ffc1c92c: 48 00 62 79 bl ffc22ba4 <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++)
ffc1c930: 7f 9f c8 00 cmpw cr7,r31,r25 <== NOT EXECUTED
ffc1c934: 41 9c ff f0 blt+ cr7,ffc1c924 <rtems_rfs_dir_lookup_ino+0x58><== NOT EXECUTED
printf ("%c", name[c]);
printf (", len=%d\n", length);
ffc1c938: 3c 60 ff c3 lis r3,-61 <== NOT EXECUTED
ffc1c93c: 38 63 47 6f addi r3,r3,18287 <== NOT EXECUTED
ffc1c940: 7f 24 cb 78 mr r4,r25 <== NOT EXECUTED
ffc1c944: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc1c948: 48 00 61 a1 bl ffc22ae8 <printf> <== NOT EXECUTED
}
*ino = RTEMS_RFS_EMPTY_INO;
ffc1c94c: 3b c0 00 00 li r30,0
ffc1c950: 93 d8 00 00 stw r30,0(r24)
*offset = 0;
rc = rtems_rfs_block_map_open (fs, inode, &map);
ffc1c954: 3a 81 00 18 addi r20,r1,24
ffc1c958: 7f a3 eb 78 mr r3,r29
printf ("%c", name[c]);
printf (", len=%d\n", length);
}
*ino = RTEMS_RFS_EMPTY_INO;
*offset = 0;
ffc1c95c: 93 d6 00 00 stw r30,0(r22)
rc = rtems_rfs_block_map_open (fs, inode, &map);
ffc1c960: 7f 84 e3 78 mr r4,r28
ffc1c964: 7e 85 a3 78 mr r5,r20
ffc1c968: 4b ff e8 75 bl ffc1b1dc <rtems_rfs_block_map_open>
if (rc > 0)
ffc1c96c: 7c 7f 1b 79 mr. r31,r3
ffc1c970: 40 81 00 44 ble- ffc1c9b4 <rtems_rfs_dir_lookup_ino+0xe8><== ALWAYS TAKEN
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
ffc1c974: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc1c978: 3c 80 04 00 lis r4,1024 <== NOT EXECUTED
ffc1c97c: 4b ff 69 89 bl ffc13304 <rtems_rfs_trace> <== NOT EXECUTED
ffc1c980: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc1c984: 41 be 03 fc beq+ cr7,ffc1cd80 <rtems_rfs_dir_lookup_ino+0x4b4><== NOT EXECUTED
printf ("rtems-rfs: dir-lookup-ino: map open failed for ino %" PRIu32 ": %d: %s",
ffc1c988: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc1c98c: 83 dc 00 08 lwz r30,8(r28) <== NOT EXECUTED
ffc1c990: 48 00 6e c5 bl ffc23854 <strerror> <== NOT EXECUTED
ffc1c994: 7f e5 fb 78 mr r5,r31 <== NOT EXECUTED
ffc1c998: 7c 66 1b 78 mr r6,r3 <== NOT EXECUTED
ffc1c99c: 3c 60 ff c3 lis r3,-61 <== NOT EXECUTED
ffc1c9a0: 7f c4 f3 78 mr r4,r30 <== NOT EXECUTED
ffc1c9a4: 38 63 47 79 addi r3,r3,18297 <== NOT EXECUTED
ffc1c9a8: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc1c9ac: 48 00 61 3d bl ffc22ae8 <printf> <== NOT EXECUTED
ffc1c9b0: 48 00 03 d0 b ffc1cd80 <rtems_rfs_dir_lookup_ino+0x4b4><== NOT EXECUTED
uint32_t hash;
/*
* Calculate the hash of the look up string.
*/
hash = rtems_rfs_dir_hash (name, length);
ffc1c9b4: 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;
ffc1c9b8: 9b c1 00 0c stb r30,12(r1)
ffc1c9bc: 7e e3 bb 78 mr r3,r23
handle->bnum = 0;
ffc1c9c0: 93 c1 00 10 stw r30,16(r1)
/*
* 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);
ffc1c9c4: 3a a1 00 08 addi r21,r1,8
handle->buffer = NULL;
ffc1c9c8: 93 c1 00 14 stw r30,20(r1)
uint32_t hash;
/*
* Calculate the hash of the look up string.
*/
hash = rtems_rfs_dir_hash (name, length);
ffc1c9cc: 48 00 4d 51 bl ffc2171c <rtems_rfs_dir_hash>
ffc1c9d0: 7c 6f 1b 78 mr r15,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);
ffc1c9d4: 7e 84 a3 78 mr r4,r20
ffc1c9d8: 7f a3 eb 78 mr r3,r29
ffc1c9dc: 38 a0 00 00 li r5,0
ffc1c9e0: 38 c0 00 00 li r6,0
ffc1c9e4: 7e a7 ab 78 mr r7,r21
ffc1c9e8: 4b ff ec f5 bl ffc1b6dc <rtems_rfs_block_map_seek>
if (rc > 0)
ffc1c9ec: 7c 7f 1b 79 mr. r31,r3
ffc1c9f0: 40 81 03 04 ble- ffc1ccf4 <rtems_rfs_dir_lookup_ino+0x428>
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
ffc1c9f4: 38 60 00 00 li r3,0
ffc1c9f8: 3c 80 04 00 lis r4,1024
ffc1c9fc: 4b ff 69 09 bl ffc13304 <rtems_rfs_trace>
ffc1ca00: 2f 83 00 00 cmpwi cr7,r3,0
ffc1ca04: 41 be 00 24 beq+ cr7,ffc1ca28 <rtems_rfs_dir_lookup_ino+0x15c><== ALWAYS TAKEN
printf ("rtems-rfs: dir-lookup-ino: block map find failed: %d: %s\n",
ffc1ca08: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc1ca0c: 48 00 6e 49 bl ffc23854 <strerror> <== NOT EXECUTED
ffc1ca10: 7f e4 fb 78 mr r4,r31 <== NOT EXECUTED
ffc1ca14: 7c 65 1b 78 mr r5,r3 <== NOT EXECUTED
ffc1ca18: 3c 60 ff c3 lis r3,-61 <== NOT EXECUTED
ffc1ca1c: 38 63 47 b8 addi r3,r3,18360 <== NOT EXECUTED
ffc1ca20: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc1ca24: 48 00 60 c5 bl ffc22ae8 <printf> <== NOT EXECUTED
rc, strerror (rc));
if (rc == ENXIO)
ffc1ca28: 2f 9f 00 06 cmpwi cr7,r31,6
ffc1ca2c: 40 be 03 3c bne+ cr7,ffc1cd68 <rtems_rfs_dir_lookup_ino+0x49c><== NEVER TAKEN
rc = ENOENT;
ffc1ca30: 3b e0 00 02 li r31,2
ffc1ca34: 48 00 03 34 b ffc1cd68 <rtems_rfs_dir_lookup_ino+0x49c>
while ((rc == 0) && block)
{
uint8_t* entry;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
ffc1ca38: 38 60 00 00 li r3,0
ffc1ca3c: 3c 80 04 00 lis r4,1024
ffc1ca40: 4b ff 68 c5 bl ffc13304 <rtems_rfs_trace>
ffc1ca44: 2f 83 00 00 cmpwi cr7,r3,0
ffc1ca48: 41 be 00 18 beq+ cr7,ffc1ca60 <rtems_rfs_dir_lookup_ino+0x194><== ALWAYS TAKEN
printf ("rtems-rfs: dir-lookup-ino: block read, ino=%" PRIu32 " bno=%" PRId32 "\n",
ffc1ca4c: 80 9c 00 08 lwz r4,8(r28) <== NOT EXECUTED
ffc1ca50: 7e 03 83 78 mr r3,r16 <== NOT EXECUTED
ffc1ca54: 80 a1 00 28 lwz r5,40(r1) <== NOT EXECUTED
ffc1ca58: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc1ca5c: 48 00 60 8d bl ffc22ae8 <printf> <== NOT EXECUTED
rtems_rfs_inode_ino (inode), map.bpos.bno);
rc = rtems_rfs_buffer_handle_request (fs, &entries, block, true);
ffc1ca60: 80 a1 00 08 lwz r5,8(r1)
ffc1ca64: 7f a3 eb 78 mr r3,r29
ffc1ca68: 38 81 00 0c addi r4,r1,12
ffc1ca6c: 38 c0 00 01 li r6,1
ffc1ca70: 4b ff f7 79 bl ffc1c1e8 <rtems_rfs_buffer_handle_request>
if (rc > 0)
ffc1ca74: 7c 7b 1b 79 mr. r27,r3
ffc1ca78: 40 a1 00 4c ble+ ffc1cac4 <rtems_rfs_dir_lookup_ino+0x1f8><== ALWAYS TAKEN
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
ffc1ca7c: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc1ca80: 3c 80 04 00 lis r4,1024 <== NOT EXECUTED
ffc1ca84: 4b ff 68 81 bl ffc13304 <rtems_rfs_trace> <== NOT EXECUTED
ffc1ca88: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc1ca8c: 41 be 02 a8 beq+ cr7,ffc1cd34 <rtems_rfs_dir_lookup_ino+0x468><== NOT EXECUTED
printf ("rtems-rfs: dir-lookup-ino: block read, ino=%" PRIu32 " block=%" PRId32 ": %d: %s\n",
ffc1ca90: 7f 63 db 78 mr r3,r27 <== NOT EXECUTED
ffc1ca94: 83 dc 00 08 lwz r30,8(r28) <== NOT EXECUTED
ffc1ca98: 83 e1 00 08 lwz r31,8(r1) <== NOT EXECUTED
ffc1ca9c: 48 00 6d b9 bl ffc23854 <strerror> <== NOT EXECUTED
ffc1caa0: 7c 67 1b 78 mr r7,r3 <== NOT EXECUTED
ffc1caa4: 3c 60 ff c3 lis r3,-61 <== NOT EXECUTED
ffc1caa8: 7f c4 f3 78 mr r4,r30 <== NOT EXECUTED
ffc1caac: 7f e5 fb 78 mr r5,r31 <== NOT EXECUTED
ffc1cab0: 7f 66 db 78 mr r6,r27 <== NOT EXECUTED
ffc1cab4: 38 63 48 2a addi r3,r3,18474 <== NOT EXECUTED
ffc1cab8: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc1cabc: 48 00 60 2d bl ffc22ae8 <printf> <== NOT EXECUTED
ffc1cac0: 48 00 02 74 b ffc1cd34 <rtems_rfs_dir_lookup_ino+0x468><== NOT EXECUTED
/*
* 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);
ffc1cac4: 81 21 00 14 lwz r9,20(r1)
map.bpos.boff = 0;
ffc1cac8: 92 21 00 2c stw r17,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);
ffc1cacc: 83 c9 00 24 lwz r30,36(r9)
map.bpos.boff = 0;
while (map.bpos.boff < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
ffc1cad0: 48 00 01 9c b ffc1cc6c <rtems_rfs_dir_lookup_ino+0x3a0>
{
uint32_t ehash;
int elength;
ehash = rtems_rfs_dir_entry_hash (entry);
elength = rtems_rfs_dir_entry_length (entry);
ffc1cad4: 8b 5e 00 08 lbz r26,8(r30)
ffc1cad8: 88 1e 00 09 lbz r0,9(r30)
ffc1cadc: 57 5a 40 2e rlwinm r26,r26,8,0,23
*ino = rtems_rfs_dir_entry_ino (entry);
ffc1cae0: 88 fe 00 00 lbz r7,0(r30)
{
uint32_t ehash;
int elength;
ehash = rtems_rfs_dir_entry_hash (entry);
elength = rtems_rfs_dir_entry_length (entry);
ffc1cae4: 7f 5a 03 78 or r26,r26,r0
*ino = rtems_rfs_dir_entry_ino (entry);
ffc1cae8: 88 1e 00 01 lbz r0,1(r30)
ffc1caec: 54 e7 c0 0e rlwinm r7,r7,24,0,7
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);
ffc1caf0: 89 5e 00 04 lbz r10,4(r30)
elength = rtems_rfs_dir_entry_length (entry);
*ino = rtems_rfs_dir_entry_ino (entry);
ffc1caf4: 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);
ffc1caf8: 89 1e 00 05 lbz r8,5(r30)
elength = rtems_rfs_dir_entry_length (entry);
*ino = rtems_rfs_dir_entry_ino (entry);
ffc1cafc: 7c e0 03 78 or r0,r7,r0
ffc1cb00: 88 fe 00 03 lbz r7,3(r30)
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
ffc1cb04: 7f 9a 90 00 cmpw cr7,r26,r18
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);
ffc1cb08: 89 3e 00 06 lbz r9,6(r30)
elength = rtems_rfs_dir_entry_length (entry);
*ino = rtems_rfs_dir_entry_ino (entry);
ffc1cb0c: 7c 00 3b 78 or r0,r0,r7
ffc1cb10: 88 fe 00 02 lbz r7,2(r30)
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);
ffc1cb14: 89 7e 00 07 lbz r11,7(r30)
elength = rtems_rfs_dir_entry_length (entry);
*ino = rtems_rfs_dir_entry_ino (entry);
ffc1cb18: 54 e7 40 2e rlwinm r7,r7,8,0,23
ffc1cb1c: 7c 00 3b 78 or r0,r0,r7
ffc1cb20: 90 18 00 00 stw r0,0(r24)
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
ffc1cb24: 41 9e 01 5c beq- cr7,ffc1cc80 <rtems_rfs_dir_lookup_ino+0x3b4>
break;
if (rtems_rfs_dir_entry_valid (fs, elength, *ino))
ffc1cb28: 2f 9a 00 0a cmpwi cr7,r26,10
ffc1cb2c: 40 9d 00 24 ble- cr7,ffc1cb50 <rtems_rfs_dir_lookup_ino+0x284><== NEVER TAKEN
ffc1cb30: 80 fd 00 18 lwz r7,24(r29)
ffc1cb34: 7f 9a 38 40 cmplw cr7,r26,r7
ffc1cb38: 40 9c 00 18 bge- cr7,ffc1cb50 <rtems_rfs_dir_lookup_ino+0x284><== NEVER TAKEN
ffc1cb3c: 2f 80 00 00 cmpwi cr7,r0,0
ffc1cb40: 41 9e 00 10 beq- cr7,ffc1cb50 <rtems_rfs_dir_lookup_ino+0x284><== NEVER TAKEN
ffc1cb44: 80 fd 00 10 lwz r7,16(r29)
ffc1cb48: 7f 80 38 40 cmplw cr7,r0,r7
ffc1cb4c: 40 bd 00 3c ble+ cr7,ffc1cb88 <rtems_rfs_dir_lookup_ino+0x2bc><== ALWAYS TAKEN
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
ffc1cb50: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc1cb54: 3c 80 04 00 lis r4,1024 <== NOT EXECUTED
ffc1cb58: 4b ff 67 ad bl ffc13304 <rtems_rfs_trace> <== NOT EXECUTED
ffc1cb5c: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc1cb60: 41 be 02 2c beq+ cr7,ffc1cd8c <rtems_rfs_dir_lookup_ino+0x4c0><== NOT EXECUTED
printf ("rtems-rfs: dir-lookup-ino: "
ffc1cb64: 3d 20 ff c3 lis r9,-61 <== NOT EXECUTED
ffc1cb68: 80 9c 00 08 lwz r4,8(r28) <== NOT EXECUTED
ffc1cb6c: 80 69 47 34 lwz r3,18228(r9) <== NOT EXECUTED
ffc1cb70: 7f 45 d3 78 mr r5,r26 <== NOT EXECUTED
ffc1cb74: 80 d8 00 00 lwz r6,0(r24) <== NOT EXECUTED
ffc1cb78: 80 e1 00 2c lwz r7,44(r1) <== NOT EXECUTED
ffc1cb7c: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc1cb80: 48 00 5f 69 bl ffc22ae8 <printf> <== NOT EXECUTED
ffc1cb84: 48 00 02 08 b ffc1cd8c <rtems_rfs_dir_lookup_ino+0x4c0><== NOT EXECUTED
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);
ffc1cb88: 55 4a c0 0e rlwinm r10,r10,24,0,7
ffc1cb8c: 55 00 80 1e rlwinm r0,r8,16,0,15
ffc1cb90: 7d 40 03 78 or r0,r10,r0
ffc1cb94: 7c 00 5b 78 or r0,r0,r11
ffc1cb98: 55 29 40 2e rlwinm r9,r9,8,0,23
ffc1cb9c: 7c 00 4b 78 or r0,r0,r9
rtems_rfs_inode_ino (inode), elength, *ino, map.bpos.boff);
rc = EIO;
break;
}
if (ehash == hash)
ffc1cba0: 7f 80 78 00 cmpw cr7,r0,r15
ffc1cba4: 40 be 00 b8 bne+ cr7,ffc1cc5c <rtems_rfs_dir_lookup_ino+0x390>
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO_CHECK))
ffc1cba8: 38 60 00 00 li r3,0
ffc1cbac: 3c 80 08 00 lis r4,2048
ffc1cbb0: 4b ff 67 55 bl ffc13304 <rtems_rfs_trace>
ffc1cbb4: 2f 83 00 00 cmpwi cr7,r3,0
ffc1cbb8: 41 be 00 48 beq+ cr7,ffc1cc00 <rtems_rfs_dir_lookup_ino+0x334><== ALWAYS TAKEN
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));
ffc1cbbc: 89 1e 00 00 lbz r8,0(r30) <== NOT EXECUTED
}
if (ehash == hash)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO_CHECK))
printf ("rtems-rfs: dir-lookup-ino: "
ffc1cbc0: 7e 63 9b 78 mr r3,r19 <== 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));
ffc1cbc4: 88 1e 00 01 lbz r0,1(r30) <== NOT EXECUTED
}
if (ehash == hash)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO_CHECK))
printf ("rtems-rfs: dir-lookup-ino: "
ffc1cbc8: 7f 47 d3 78 mr r7,r26 <== 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));
ffc1cbcc: 55 08 c0 0e rlwinm r8,r8,24,0,7 <== NOT EXECUTED
}
if (ehash == hash)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO_CHECK))
printf ("rtems-rfs: dir-lookup-ino: "
ffc1cbd0: 80 9c 00 08 lwz r4,8(r28) <== 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));
ffc1cbd4: 54 00 80 1e rlwinm r0,r0,16,0,15 <== NOT EXECUTED
}
if (ehash == hash)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO_CHECK))
printf ("rtems-rfs: dir-lookup-ino: "
ffc1cbd8: 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));
ffc1cbdc: 7d 08 03 78 or r8,r8,r0 <== NOT EXECUTED
ffc1cbe0: 88 1e 00 03 lbz r0,3(r30) <== NOT EXECUTED
}
if (ehash == hash)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO_CHECK))
printf ("rtems-rfs: dir-lookup-ino: "
ffc1cbe4: 80 c1 00 2c lwz r6,44(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));
ffc1cbe8: 7d 08 03 78 or r8,r8,r0 <== NOT EXECUTED
ffc1cbec: 88 1e 00 02 lbz r0,2(r30) <== NOT EXECUTED
ffc1cbf0: 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: "
ffc1cbf4: 7d 08 03 78 or r8,r8,r0 <== NOT EXECUTED
ffc1cbf8: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc1cbfc: 48 00 5e ed bl ffc22ae8 <printf> <== 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));
if (memcmp (entry + RTEMS_RFS_DIR_ENTRY_SIZE, name, length) == 0)
ffc1cc00: 38 7e 00 0a addi r3,r30,10
ffc1cc04: 7e e4 bb 78 mr r4,r23
ffc1cc08: 7f 25 cb 78 mr r5,r25
ffc1cc0c: 48 00 5a 91 bl ffc2269c <memcmp>
ffc1cc10: 2f 83 00 00 cmpwi cr7,r3,0
ffc1cc14: 40 be 00 48 bne+ cr7,ffc1cc5c <rtems_rfs_dir_lookup_ino+0x390><== NEVER TAKEN
{
*offset = rtems_rfs_block_map_pos (fs, &map);
ffc1cc18: 7f a3 eb 78 mr r3,r29
ffc1cc1c: 38 81 00 28 addi r4,r1,40
ffc1cc20: 4b ff e4 e1 bl ffc1b100 <rtems_rfs_block_get_pos>
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO_FOUND))
ffc1cc24: 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);
ffc1cc28: 90 96 00 00 stw r4,0(r22)
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO_FOUND))
ffc1cc2c: 3c 80 10 00 lis r4,4096
ffc1cc30: 4b ff 66 d5 bl ffc13304 <rtems_rfs_trace>
ffc1cc34: 2f 83 00 00 cmpwi cr7,r3,0
ffc1cc38: 41 be 01 30 beq+ cr7,ffc1cd68 <rtems_rfs_dir_lookup_ino+0x49c><== ALWAYS TAKEN
printf ("rtems-rfs: dir-lookup-ino: "
ffc1cc3c: 3c 60 ff c3 lis r3,-61 <== NOT EXECUTED
ffc1cc40: 80 9c 00 08 lwz r4,8(r28) <== NOT EXECUTED
ffc1cc44: 80 b8 00 00 lwz r5,0(r24) <== NOT EXECUTED
ffc1cc48: 38 63 49 14 addi r3,r3,18708 <== NOT EXECUTED
ffc1cc4c: 80 d6 00 00 lwz r6,0(r22) <== NOT EXECUTED
ffc1cc50: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc1cc54: 48 00 5e 95 bl ffc22ae8 <printf> <== NOT EXECUTED
ffc1cc58: 48 00 01 10 b ffc1cd68 <rtems_rfs_dir_lookup_ino+0x49c><== NOT EXECUTED
rtems_rfs_block_map_close (fs, &map);
return 0;
}
}
map.bpos.boff += elength;
ffc1cc5c: 80 01 00 2c lwz r0,44(r1)
entry += elength;
ffc1cc60: 7f de d2 14 add r30,r30,r26
rtems_rfs_block_map_close (fs, &map);
return 0;
}
}
map.bpos.boff += elength;
ffc1cc64: 7c 00 d2 14 add r0,r0,r26
ffc1cc68: 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))
ffc1cc6c: 81 3d 00 08 lwz r9,8(r29)
ffc1cc70: 38 09 ff f6 addi r0,r9,-10
ffc1cc74: 81 21 00 2c lwz r9,44(r1)
ffc1cc78: 7f 89 00 40 cmplw cr7,r9,r0
ffc1cc7c: 41 9c fe 58 blt+ cr7,ffc1cad4 <rtems_rfs_dir_lookup_ino+0x208><== ALWAYS TAKEN
map.bpos.boff += elength;
entry += elength;
}
if (rc == 0)
ffc1cc80: 2f 9b 00 00 cmpwi cr7,r27,0
ffc1cc84: 40 be 00 68 bne+ cr7,ffc1ccec <rtems_rfs_dir_lookup_ino+0x420><== NEVER TAKEN
{
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
ffc1cc88: 7f a3 eb 78 mr r3,r29
ffc1cc8c: 7e 84 a3 78 mr r4,r20
ffc1cc90: 7e a5 ab 78 mr r5,r21
ffc1cc94: 4b ff ea d9 bl ffc1b76c <rtems_rfs_block_map_next_block>
if ((rc > 0) && (rc != ENXIO))
ffc1cc98: 7c 7f 1b 79 mr. r31,r3
ffc1cc9c: 40 81 00 7c ble- ffc1cd18 <rtems_rfs_dir_lookup_ino+0x44c><== NEVER TAKEN
ffc1cca0: 2f 9f 00 06 cmpwi cr7,r31,6
ffc1cca4: 41 9e 00 40 beq- cr7,ffc1cce4 <rtems_rfs_dir_lookup_ino+0x418><== ALWAYS TAKEN
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
ffc1cca8: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc1ccac: 3c 80 04 00 lis r4,1024 <== NOT EXECUTED
ffc1ccb0: 4b ff 66 55 bl ffc13304 <rtems_rfs_trace> <== NOT EXECUTED
ffc1ccb4: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc1ccb8: 41 be 00 60 beq+ cr7,ffc1cd18 <rtems_rfs_dir_lookup_ino+0x44c><== NOT EXECUTED
printf ("rtems-rfs: dir-lookup-ino: "
ffc1ccbc: 83 dc 00 08 lwz r30,8(r28) <== NOT EXECUTED
ffc1ccc0: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc1ccc4: 48 00 6b 91 bl ffc23854 <strerror> <== NOT EXECUTED
ffc1ccc8: 7f e5 fb 78 mr r5,r31 <== NOT EXECUTED
ffc1cccc: 7c 66 1b 78 mr r6,r3 <== NOT EXECUTED
ffc1ccd0: 7f c4 f3 78 mr r4,r30 <== NOT EXECUTED
ffc1ccd4: 7d c3 73 78 mr r3,r14 <== NOT EXECUTED
ffc1ccd8: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc1ccdc: 48 00 5e 0d bl ffc22ae8 <printf> <== NOT EXECUTED
ffc1cce0: 48 00 00 38 b ffc1cd18 <rtems_rfs_dir_lookup_ino+0x44c><== NOT EXECUTED
"block map next block failed in ino %" PRIu32 ": %d: %s\n",
rtems_rfs_inode_ino (inode), rc, strerror (rc));
}
if (rc == ENXIO)
rc = ENOENT;
ffc1cce4: 3b e0 00 02 li r31,2
ffc1cce8: 48 00 00 48 b ffc1cd30 <rtems_rfs_dir_lookup_ino+0x464>
ffc1ccec: 7f 7f db 78 mr r31,r27 <== NOT EXECUTED
ffc1ccf0: 48 00 00 28 b ffc1cd18 <rtems_rfs_dir_lookup_ino+0x44c><== 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",
ffc1ccf4: 3e 00 ff c3 lis r16,-61
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)
ffc1ccf8: 3a 40 00 00 li r18,0
}
if (ehash == hash)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO_CHECK))
printf ("rtems-rfs: dir-lookup-ino: "
ffc1ccfc: 3e 60 ff c3 lis r19,-61
{
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: "
ffc1cd00: 3d c0 ff c3 lis r14,-61
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",
ffc1cd04: 3a 10 47 f2 addi r16,r16,18418
* means the entry is empty.
*/
entry = rtems_rfs_buffer_data (&entries);
map.bpos.boff = 0;
ffc1cd08: 3a 20 00 00 li r17,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)
ffc1cd0c: 62 52 ff ff ori r18,r18,65535
}
if (ehash == hash)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO_CHECK))
printf ("rtems-rfs: dir-lookup-ino: "
ffc1cd10: 3a 73 48 b6 addi r19,r19,18614
{
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: "
ffc1cd14: 39 ce 49 5b addi r14,r14,18779
rtems_rfs_buffer_handle_close (fs, &entries);
rtems_rfs_block_map_close (fs, &map);
return rc;
}
while ((rc == 0) && block)
ffc1cd18: 2f 9f 00 00 cmpwi cr7,r31,0
ffc1cd1c: 40 9e 00 14 bne- cr7,ffc1cd30 <rtems_rfs_dir_lookup_ino+0x464><== NEVER TAKEN
ffc1cd20: 80 01 00 08 lwz r0,8(r1)
ffc1cd24: 2f 80 00 00 cmpwi cr7,r0,0
ffc1cd28: 40 9e fd 10 bne+ cr7,ffc1ca38 <rtems_rfs_dir_lookup_ino+0x16c><== ALWAYS TAKEN
ffc1cd2c: 48 00 00 68 b ffc1cd94 <rtems_rfs_dir_lookup_ino+0x4c8><== NOT EXECUTED
ffc1cd30: 7f fb fb 78 mr r27,r31
ffc1cd34: 7f 7f db 78 mr r31,r27
ffc1cd38: 48 00 00 30 b ffc1cd68 <rtems_rfs_dir_lookup_ino+0x49c>
if ((rc == 0) && (block == 0))
{
rc = EIO;
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",
ffc1cd3c: 38 60 00 05 li r3,5 <== NOT EXECUTED
ffc1cd40: 83 fc 00 08 lwz r31,8(r28) <== NOT EXECUTED
ffc1cd44: 48 00 6b 11 bl ffc23854 <strerror> <== NOT EXECUTED
ffc1cd48: 38 a0 00 05 li r5,5 <== NOT EXECUTED
ffc1cd4c: 7c 66 1b 78 mr r6,r3 <== NOT EXECUTED
ffc1cd50: 3c 60 ff c3 lis r3,-61 <== NOT EXECUTED
ffc1cd54: 38 63 49 a6 addi r3,r3,18854 <== NOT EXECUTED
ffc1cd58: 7f e4 fb 78 mr r4,r31 <== NOT EXECUTED
ffc1cd5c: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc1cd60: 48 00 5d 89 bl ffc22ae8 <printf> <== NOT EXECUTED
}
}
if ((rc == 0) && (block == 0))
{
rc = EIO;
ffc1cd64: 3b e0 00 05 li r31,5 <== NOT EXECUTED
printf ("rtems-rfs: dir-lookup-ino: block is 0 in ino %" PRIu32 ": %d: %s\n",
rtems_rfs_inode_ino (inode), rc, strerror (rc));
}
}
rtems_rfs_buffer_handle_close (fs, &entries);
ffc1cd68: 38 81 00 0c addi r4,r1,12
ffc1cd6c: 7f a3 eb 78 mr r3,r29
ffc1cd70: 4b ff fb 21 bl ffc1c890 <rtems_rfs_buffer_handle_close>
rtems_rfs_block_map_close (fs, &map);
ffc1cd74: 7f a3 eb 78 mr r3,r29
ffc1cd78: 38 81 00 18 addi r4,r1,24
ffc1cd7c: 4b ff e6 15 bl ffc1b390 <rtems_rfs_block_map_close>
return rc;
}
ffc1cd80: 39 61 00 b0 addi r11,r1,176
ffc1cd84: 7f e3 fb 78 mr r3,r31
ffc1cd88: 4b fe 5d 2c b ffc02ab4 <_restgpr_14_x>
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;
ffc1cd8c: 3b 60 00 05 li r27,5 <== NOT EXECUTED
ffc1cd90: 4b ff ff 5c b ffc1ccec <rtems_rfs_dir_lookup_ino+0x420><== NOT EXECUTED
}
if ((rc == 0) && (block == 0))
{
rc = EIO;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
ffc1cd94: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc1cd98: 3c 80 04 00 lis r4,1024 <== NOT EXECUTED
ffc1cd9c: 4b ff 65 69 bl ffc13304 <rtems_rfs_trace> <== NOT EXECUTED
ffc1cda0: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc1cda4: 41 9e ff c0 beq+ cr7,ffc1cd64 <rtems_rfs_dir_lookup_ino+0x498><== NOT EXECUTED
ffc1cda8: 4b ff ff 94 b ffc1cd3c <rtems_rfs_dir_lookup_ino+0x470><== NOT EXECUTED
ffc1d52c <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)
{
ffc1d52c: 94 21 ff 58 stwu r1,-168(r1) <== NOT EXECUTED
ffc1d530: 7c 08 02 a6 mflr r0 <== NOT EXECUTED
ffc1d534: be 21 00 6c stmw r17,108(r1) <== NOT EXECUTED
ffc1d538: 7c 7d 1b 78 mr r29,r3 <== NOT EXECUTED
ffc1d53c: 7c 9a 23 78 mr r26,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))
ffc1d540: 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)
{
ffc1d544: 90 01 00 ac stw r0,172(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))
ffc1d548: 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)
{
ffc1d54c: 7c df 33 78 mr r31,r6 <== NOT EXECUTED
ffc1d550: 7c be 2b 78 mr r30,r5 <== NOT EXECUTED
ffc1d554: 7c fb 3b 78 mr r27,r7 <== NOT EXECUTED
ffc1d558: 7d 17 43 78 mr r23,r8 <== 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))
ffc1d55c: 4b ff 5d a9 bl ffc13304 <rtems_rfs_trace> <== NOT EXECUTED
ffc1d560: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc1d564: 41 be 00 20 beq+ cr7,ffc1d584 <rtems_rfs_dir_read+0x58> <== NOT EXECUTED
printf ("rtems-rfs: dir-read: dir=%" PRId32 " offset=%" PRId64 "\n",
ffc1d568: 3c 60 ff c3 lis r3,-61 <== NOT EXECUTED
ffc1d56c: 80 9a 00 08 lwz r4,8(r26) <== NOT EXECUTED
ffc1d570: 38 63 4c 9f addi r3,r3,19615 <== NOT EXECUTED
ffc1d574: 7f c5 f3 78 mr r5,r30 <== NOT EXECUTED
ffc1d578: 7f e6 fb 78 mr r6,r31 <== NOT EXECUTED
ffc1d57c: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc1d580: 48 00 55 69 bl ffc22ae8 <printf> <== NOT EXECUTED
rtems_rfs_inode_ino (dir), offset);
*length = 0;
ffc1d584: 38 00 00 00 li r0,0 <== NOT EXECUTED
ffc1d588: 90 17 00 00 stw r0,0(r23) <== NOT EXECUTED
rc = rtems_rfs_block_map_open (fs, dir, &map);
ffc1d58c: 7f a3 eb 78 mr r3,r29 <== NOT EXECUTED
ffc1d590: 7f 44 d3 78 mr r4,r26 <== NOT EXECUTED
ffc1d594: 38 a1 00 18 addi r5,r1,24 <== NOT EXECUTED
ffc1d598: 4b ff dc 45 bl ffc1b1dc <rtems_rfs_block_map_open> <== NOT EXECUTED
if (rc > 0)
ffc1d59c: 7c 7c 1b 79 mr. r28,r3 <== NOT EXECUTED
ffc1d5a0: 41 a1 02 fc bgt+ ffc1d89c <rtems_rfs_dir_read+0x370> <== NOT EXECUTED
return rc;
if (((rtems_rfs_fs_block_size (fs) -
(offset % rtems_rfs_fs_block_size (fs))) <= RTEMS_RFS_DIR_ENTRY_SIZE))
ffc1d5a4: 83 3d 00 08 lwz r25,8(r29) <== NOT EXECUTED
ffc1d5a8: 3b 00 00 00 li r24,0 <== NOT EXECUTED
ffc1d5ac: 7f c3 f3 78 mr r3,r30 <== NOT EXECUTED
ffc1d5b0: 7f e4 fb 78 mr r4,r31 <== NOT EXECUTED
ffc1d5b4: 7f 05 c3 78 mr r5,r24 <== NOT EXECUTED
ffc1d5b8: 7f 26 cb 78 mr r6,r25 <== NOT EXECUTED
ffc1d5bc: 48 01 26 5d bl ffc2fc18 <__moddi3> <== NOT EXECUTED
rc = rtems_rfs_block_map_open (fs, dir, &map);
if (rc > 0)
return rc;
if (((rtems_rfs_fs_block_size (fs) -
ffc1d5c0: 7d 64 c8 10 subfc r11,r4,r25 <== NOT EXECUTED
ffc1d5c4: 7d 43 c1 10 subfe r10,r3,r24 <== NOT EXECUTED
ffc1d5c8: 2f 8a 00 00 cmpwi cr7,r10,0 <== NOT EXECUTED
ffc1d5cc: 41 9d 00 44 bgt- cr7,ffc1d610 <rtems_rfs_dir_read+0xe4> <== NOT EXECUTED
ffc1d5d0: 40 9e 00 0c bne- cr7,ffc1d5dc <rtems_rfs_dir_read+0xb0> <== NOT EXECUTED
ffc1d5d4: 2b 8b 00 0a cmplwi cr7,r11,10 <== NOT EXECUTED
ffc1d5d8: 41 9d 00 38 bgt- cr7,ffc1d610 <rtems_rfs_dir_read+0xe4> <== NOT EXECUTED
(offset % rtems_rfs_fs_block_size (fs))) <= RTEMS_RFS_DIR_ENTRY_SIZE))
offset = (((offset / rtems_rfs_fs_block_size (fs)) + 1) *
ffc1d5dc: 7f c3 f3 78 mr r3,r30 <== NOT EXECUTED
ffc1d5e0: 7f e4 fb 78 mr r4,r31 <== NOT EXECUTED
ffc1d5e4: 7f 05 c3 78 mr r5,r24 <== NOT EXECUTED
ffc1d5e8: 7f 26 cb 78 mr r6,r25 <== NOT EXECUTED
ffc1d5ec: 48 01 21 ed bl ffc2f7d8 <__divdi3> <== NOT EXECUTED
ffc1d5f0: 31 64 00 01 addic r11,r4,1 <== NOT EXECUTED
ffc1d5f4: 7d 43 01 94 addze r10,r3 <== NOT EXECUTED
ffc1d5f8: 7d 2a c9 d6 mullw r9,r10,r25 <== NOT EXECUTED
ffc1d5fc: 7c 18 59 d6 mullw r0,r24,r11 <== NOT EXECUTED
ffc1d600: 7f cb c8 16 mulhwu r30,r11,r25 <== NOT EXECUTED
ffc1d604: 7f eb c9 d6 mullw r31,r11,r25 <== NOT EXECUTED
ffc1d608: 7c 09 02 14 add r0,r9,r0 <== NOT EXECUTED
ffc1d60c: 7f c0 f2 14 add r30,r0,r30 <== NOT EXECUTED
rtems_rfs_fs_block_size (fs));
rc = rtems_rfs_block_map_seek (fs, &map, offset, &block);
ffc1d610: 3b 01 00 18 addi r24,r1,24 <== NOT EXECUTED
ffc1d614: 3b 21 00 08 addi r25,r1,8 <== NOT EXECUTED
ffc1d618: 7f a3 eb 78 mr r3,r29 <== NOT EXECUTED
ffc1d61c: 7f 04 c3 78 mr r4,r24 <== NOT EXECUTED
ffc1d620: 7f c5 f3 78 mr r5,r30 <== NOT EXECUTED
ffc1d624: 7f e6 fb 78 mr r6,r31 <== NOT EXECUTED
ffc1d628: 7f 27 cb 78 mr r7,r25 <== NOT EXECUTED
ffc1d62c: 4b ff e0 b1 bl ffc1b6dc <rtems_rfs_block_map_seek> <== NOT EXECUTED
if (rc > 0)
ffc1d630: 7c 7c 1b 79 mr. r28,r3 <== NOT EXECUTED
ffc1d634: 40 81 00 1c ble- ffc1d650 <rtems_rfs_dir_read+0x124> <== NOT EXECUTED
{
if (rc == ENXIO)
ffc1d638: 2f 9c 00 06 cmpwi cr7,r28,6 <== NOT EXECUTED
ffc1d63c: 40 be 00 08 bne+ cr7,ffc1d644 <rtems_rfs_dir_read+0x118><== NOT EXECUTED
rc = ENOENT;
ffc1d640: 3b 80 00 02 li r28,2 <== NOT EXECUTED
rtems_rfs_block_map_close (fs, &map);
ffc1d644: 7f a3 eb 78 mr r3,r29 <== NOT EXECUTED
ffc1d648: 7f 04 c3 78 mr r4,r24 <== NOT EXECUTED
ffc1d64c: 48 00 02 4c b ffc1d898 <rtems_rfs_dir_read+0x36c> <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
ffc1d650: 38 00 00 00 li r0,0 <== NOT EXECUTED
ffc1d654: 98 01 00 0c stb r0,12(r1) <== NOT EXECUTED
handle->bnum = 0;
ffc1d658: 38 00 00 00 li r0,0 <== 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)
ffc1d65c: 3a a0 00 00 li r21,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",
ffc1d660: 3e c0 ff c3 lis r22,-61 <== NOT EXECUTED
ffc1d664: 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)
ffc1d668: 62 b5 ff ff ori r21,r21,65535 <== NOT EXECUTED
handle->buffer = NULL;
ffc1d66c: 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",
ffc1d670: 3a d6 4d 42 addi r22,r22,19778 <== NOT EXECUTED
uint8_t* entry;
rtems_rfs_ino eino;
int elength;
int remaining;
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, true);
ffc1d674: 80 a1 00 08 lwz r5,8(r1) <== NOT EXECUTED
ffc1d678: 7f a3 eb 78 mr r3,r29 <== NOT EXECUTED
ffc1d67c: 38 81 00 0c addi r4,r1,12 <== NOT EXECUTED
ffc1d680: 38 c0 00 01 li r6,1 <== NOT EXECUTED
ffc1d684: 4b ff eb 65 bl ffc1c1e8 <rtems_rfs_buffer_handle_request><== NOT EXECUTED
if (rc > 0)
ffc1d688: 7c 7c 1b 79 mr. r28,r3 <== NOT EXECUTED
ffc1d68c: 41 81 01 f8 bgt- ffc1d884 <rtems_rfs_dir_read+0x358> <== NOT EXECUTED
rtems_rfs_buffer_handle_close (fs, &buffer);
rtems_rfs_block_map_close (fs, &map);
return rc;
}
entry = rtems_rfs_buffer_data (&buffer);
ffc1d690: 81 21 00 14 lwz r9,20(r1) <== NOT EXECUTED
entry += map.bpos.boff;
ffc1d694: 82 41 00 2c lwz r18,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);
ffc1d698: 81 29 00 24 lwz r9,36(r9) <== NOT EXECUTED
entry += map.bpos.boff;
ffc1d69c: 7e 89 92 14 add r20,r9,r18 <== NOT EXECUTED
elength = rtems_rfs_dir_entry_length (entry);
eino = rtems_rfs_dir_entry_ino (entry);
ffc1d6a0: 7e 29 90 ae lbzx r17,r9,r18 <== NOT EXECUTED
}
entry = rtems_rfs_buffer_data (&buffer);
entry += map.bpos.boff;
elength = rtems_rfs_dir_entry_length (entry);
ffc1d6a4: 8a 74 00 08 lbz r19,8(r20) <== NOT EXECUTED
ffc1d6a8: 88 14 00 09 lbz r0,9(r20) <== NOT EXECUTED
eino = rtems_rfs_dir_entry_ino (entry);
ffc1d6ac: 56 31 c0 0e rlwinm r17,r17,24,0,7 <== NOT EXECUTED
}
entry = rtems_rfs_buffer_data (&buffer);
entry += map.bpos.boff;
elength = rtems_rfs_dir_entry_length (entry);
ffc1d6b0: 56 73 40 2e rlwinm r19,r19,8,0,23 <== NOT EXECUTED
ffc1d6b4: 7e 73 03 78 or r19,r19,r0 <== NOT EXECUTED
eino = rtems_rfs_dir_entry_ino (entry);
ffc1d6b8: 88 14 00 01 lbz r0,1(r20) <== NOT EXECUTED
if (elength != RTEMS_RFS_DIR_ENTRY_EMPTY)
ffc1d6bc: 7f 93 a8 00 cmpw cr7,r19,r21 <== 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);
ffc1d6c0: 54 00 80 1e rlwinm r0,r0,16,0,15 <== NOT EXECUTED
ffc1d6c4: 7e 31 03 78 or r17,r17,r0 <== NOT EXECUTED
ffc1d6c8: 88 14 00 03 lbz r0,3(r20) <== NOT EXECUTED
ffc1d6cc: 7e 31 03 78 or r17,r17,r0 <== NOT EXECUTED
ffc1d6d0: 88 14 00 02 lbz r0,2(r20) <== NOT EXECUTED
ffc1d6d4: 54 00 40 2e rlwinm r0,r0,8,0,23 <== NOT EXECUTED
ffc1d6d8: 7e 31 03 78 or r17,r17,r0 <== NOT EXECUTED
if (elength != RTEMS_RFS_DIR_ENTRY_EMPTY)
ffc1d6dc: 41 be 01 3c beq+ cr7,ffc1d818 <rtems_rfs_dir_read+0x2ec><== NOT EXECUTED
{
if (rtems_rfs_dir_entry_valid (fs, elength, eino))
ffc1d6e0: 2f 93 00 0a cmpwi cr7,r19,10 <== NOT EXECUTED
ffc1d6e4: 40 9d 00 24 ble- cr7,ffc1d708 <rtems_rfs_dir_read+0x1dc><== NOT EXECUTED
ffc1d6e8: 80 1d 00 18 lwz r0,24(r29) <== NOT EXECUTED
ffc1d6ec: 7f 93 00 40 cmplw cr7,r19,r0 <== NOT EXECUTED
ffc1d6f0: 40 9c 00 18 bge- cr7,ffc1d708 <rtems_rfs_dir_read+0x1dc><== NOT EXECUTED
ffc1d6f4: 2f 91 00 00 cmpwi cr7,r17,0 <== NOT EXECUTED
ffc1d6f8: 41 9e 00 10 beq- cr7,ffc1d708 <rtems_rfs_dir_read+0x1dc><== NOT EXECUTED
ffc1d6fc: 80 1d 00 10 lwz r0,16(r29) <== NOT EXECUTED
ffc1d700: 7f 91 00 40 cmplw cr7,r17,r0 <== NOT EXECUTED
ffc1d704: 40 9d 00 40 ble- cr7,ffc1d744 <rtems_rfs_dir_read+0x218><== NOT EXECUTED
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
ffc1d708: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc1d70c: 3c 80 80 00 lis r4,-32768 <== NOT EXECUTED
ffc1d710: 4b ff 5b f5 bl ffc13304 <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;
ffc1d714: 3b 80 00 05 li r28,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))
ffc1d718: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc1d71c: 41 be 01 68 beq+ cr7,ffc1d884 <rtems_rfs_dir_read+0x358><== NOT EXECUTED
printf ("rtems-rfs: dir-read: "
ffc1d720: 3c 60 ff c3 lis r3,-61 <== NOT EXECUTED
ffc1d724: 80 9a 00 08 lwz r4,8(r26) <== NOT EXECUTED
ffc1d728: 80 e1 00 2c lwz r7,44(r1) <== NOT EXECUTED
ffc1d72c: 7e 65 9b 78 mr r5,r19 <== NOT EXECUTED
ffc1d730: 7e 26 8b 78 mr r6,r17 <== NOT EXECUTED
ffc1d734: 38 63 4c c9 addi r3,r3,19657 <== NOT EXECUTED
ffc1d738: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc1d73c: 48 00 53 ad bl ffc22ae8 <printf> <== NOT EXECUTED
ffc1d740: 48 00 01 44 b ffc1d884 <rtems_rfs_dir_read+0x358> <== NOT EXECUTED
rtems_rfs_inode_ino (dir), elength, eino, map.bpos.boff);
rc = EIO;
break;
}
memset (dirent, 0, sizeof (struct dirent));
ffc1d744: 7f 63 db 78 mr r3,r27 <== NOT EXECUTED
ffc1d748: 38 80 00 00 li r4,0 <== NOT EXECUTED
ffc1d74c: 38 a0 01 18 li r5,280 <== NOT EXECUTED
ffc1d750: 48 00 52 09 bl ffc22958 <memset> <== NOT EXECUTED
dirent->d_off = offset;
dirent->d_reclen = sizeof (struct dirent);
ffc1d754: 38 00 01 18 li r0,280 <== NOT EXECUTED
ffc1d758: b0 1b 00 10 sth r0,16(r27) <== NOT EXECUTED
*length += elength;
ffc1d75c: 80 17 00 00 lwz r0,0(r23) <== NOT EXECUTED
rc = EIO;
break;
}
memset (dirent, 0, sizeof (struct dirent));
dirent->d_off = offset;
ffc1d760: 93 db 00 08 stw r30,8(r27) <== NOT EXECUTED
dirent->d_reclen = sizeof (struct dirent);
*length += elength;
ffc1d764: 7c 13 02 14 add r0,r19,r0 <== NOT EXECUTED
rc = EIO;
break;
}
memset (dirent, 0, sizeof (struct dirent));
dirent->d_off = offset;
ffc1d768: 93 fb 00 0c stw r31,12(r27) <== NOT EXECUTED
dirent->d_reclen = sizeof (struct dirent);
*length += elength;
ffc1d76c: 90 17 00 00 stw r0,0(r23) <== NOT EXECUTED
remaining = rtems_rfs_fs_block_size (fs) - (map.bpos.boff + elength);
ffc1d770: 81 3d 00 08 lwz r9,8(r29) <== NOT EXECUTED
ffc1d774: 7e 52 48 50 subf r18,r18,r9 <== NOT EXECUTED
ffc1d778: 7e 53 90 50 subf r18,r19,r18 <== NOT EXECUTED
if (remaining <= RTEMS_RFS_DIR_ENTRY_SIZE)
ffc1d77c: 2f 92 00 0a cmpwi cr7,r18,10 <== NOT EXECUTED
ffc1d780: 41 9d 00 0c bgt- cr7,ffc1d78c <rtems_rfs_dir_read+0x260><== NOT EXECUTED
*length += remaining;
ffc1d784: 7c 12 02 14 add r0,r18,r0 <== NOT EXECUTED
ffc1d788: 90 17 00 00 stw r0,0(r23) <== NOT EXECUTED
elength -= RTEMS_RFS_DIR_ENTRY_SIZE;
ffc1d78c: 3a 73 ff f6 addi r19,r19,-10 <== NOT EXECUTED
ffc1d790: 2f 93 00 ff cmpwi cr7,r19,255 <== NOT EXECUTED
ffc1d794: 40 9d 00 08 ble- cr7,ffc1d79c <rtems_rfs_dir_read+0x270><== NOT EXECUTED
ffc1d798: 3a 60 00 ff li r19,255 <== NOT EXECUTED
if (elength > NAME_MAX)
elength = NAME_MAX;
memcpy (dirent->d_name, entry + RTEMS_RFS_DIR_ENTRY_SIZE, elength);
ffc1d79c: 3b db 00 14 addi r30,r27,20 <== NOT EXECUTED
ffc1d7a0: 38 94 00 0a addi r4,r20,10 <== NOT EXECUTED
ffc1d7a4: 7e 65 9b 78 mr r5,r19 <== NOT EXECUTED
ffc1d7a8: 7f c3 f3 78 mr r3,r30 <== NOT EXECUTED
ffc1d7ac: 48 00 4f 95 bl ffc22740 <memcpy> <== NOT EXECUTED
dirent->d_ino = rtems_rfs_dir_entry_ino (entry);
ffc1d7b0: 89 34 00 00 lbz r9,0(r20) <== NOT EXECUTED
ffc1d7b4: 88 14 00 01 lbz r0,1(r20) <== NOT EXECUTED
dirent->d_namlen = elength;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
ffc1d7b8: 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);
ffc1d7bc: 55 29 c0 0e rlwinm r9,r9,24,0,7 <== NOT EXECUTED
ffc1d7c0: 54 00 80 1e rlwinm r0,r0,16,0,15 <== NOT EXECUTED
ffc1d7c4: 7d 20 03 78 or r0,r9,r0 <== NOT EXECUTED
ffc1d7c8: 89 34 00 03 lbz r9,3(r20) <== NOT EXECUTED
dirent->d_namlen = elength;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
ffc1d7cc: 3c 80 80 00 lis r4,-32768 <== 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);
ffc1d7d0: 7c 00 4b 78 or r0,r0,r9 <== NOT EXECUTED
ffc1d7d4: 89 34 00 02 lbz r9,2(r20) <== NOT EXECUTED
dirent->d_namlen = elength;
ffc1d7d8: b2 7b 00 12 sth r19,18(r27) <== 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);
ffc1d7dc: 55 29 40 2e rlwinm r9,r9,8,0,23 <== NOT EXECUTED
ffc1d7e0: 7c 00 4b 78 or r0,r0,r9 <== NOT EXECUTED
ffc1d7e4: 90 1b 00 00 stw r0,0(r27) <== NOT EXECUTED
dirent->d_namlen = elength;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
ffc1d7e8: 4b ff 5b 1d bl ffc13304 <rtems_rfs_trace> <== NOT EXECUTED
ffc1d7ec: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc1d7f0: 41 be 00 94 beq+ cr7,ffc1d884 <rtems_rfs_dir_read+0x358><== NOT EXECUTED
printf ("rtems-rfs: dir-read: found off:%" PRIdoff_t " ino:%ld name=%s\n",
ffc1d7f4: 3c 60 ff c3 lis r3,-61 <== NOT EXECUTED
ffc1d7f8: 80 bb 00 08 lwz r5,8(r27) <== NOT EXECUTED
ffc1d7fc: 80 db 00 0c lwz r6,12(r27) <== NOT EXECUTED
ffc1d800: 7f c8 f3 78 mr r8,r30 <== NOT EXECUTED
ffc1d804: 80 fb 00 00 lwz r7,0(r27) <== NOT EXECUTED
ffc1d808: 38 63 4d 0d addi r3,r3,19725 <== NOT EXECUTED
ffc1d80c: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc1d810: 48 00 52 d9 bl ffc22ae8 <printf> <== NOT EXECUTED
ffc1d814: 48 00 00 70 b ffc1d884 <rtems_rfs_dir_read+0x358> <== NOT EXECUTED
dirent->d_off, dirent->d_ino, dirent->d_name);
break;
}
*length += rtems_rfs_fs_block_size (fs) - map.bpos.boff;
ffc1d818: 80 1d 00 08 lwz r0,8(r29) <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
ffc1d81c: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc1d820: 3c 80 80 00 lis r4,-32768 <== 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;
ffc1d824: 7e 52 00 50 subf r18,r18,r0 <== NOT EXECUTED
ffc1d828: 80 17 00 00 lwz r0,0(r23) <== NOT EXECUTED
ffc1d82c: 7e 40 92 14 add r18,r0,r18 <== NOT EXECUTED
ffc1d830: 92 57 00 00 stw r18,0(r23) <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
ffc1d834: 4b ff 5a d1 bl ffc13304 <rtems_rfs_trace> <== NOT EXECUTED
ffc1d838: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc1d83c: 41 be 00 1c beq+ cr7,ffc1d858 <rtems_rfs_dir_read+0x32c><== NOT EXECUTED
printf ("rtems-rfs: dir-read: next block: off:%" PRId64 " length:%zd\n",
ffc1d840: 80 f7 00 00 lwz r7,0(r23) <== NOT EXECUTED
ffc1d844: 7e c3 b3 78 mr r3,r22 <== NOT EXECUTED
ffc1d848: 7f c5 f3 78 mr r5,r30 <== NOT EXECUTED
ffc1d84c: 7f e6 fb 78 mr r6,r31 <== NOT EXECUTED
ffc1d850: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc1d854: 48 00 52 95 bl ffc22ae8 <printf> <== NOT EXECUTED
offset, *length);
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
ffc1d858: 7f a3 eb 78 mr r3,r29 <== NOT EXECUTED
ffc1d85c: 7f 04 c3 78 mr r4,r24 <== NOT EXECUTED
ffc1d860: 7f 25 cb 78 mr r5,r25 <== NOT EXECUTED
ffc1d864: 4b ff df 09 bl ffc1b76c <rtems_rfs_block_map_next_block><== NOT EXECUTED
if (rc == ENXIO)
ffc1d868: 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);
ffc1d86c: 7c 7c 1b 78 mr r28,r3 <== NOT EXECUTED
if (rc == ENXIO)
ffc1d870: 41 9e 00 10 beq- cr7,ffc1d880 <rtems_rfs_dir_read+0x354><== NOT EXECUTED
/*
* Look for an empty entry and if this is the last block that is the end of
* the directory.
*/
while (rc == 0)
ffc1d874: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc1d878: 41 9e fd fc beq+ cr7,ffc1d674 <rtems_rfs_dir_read+0x148><== NOT EXECUTED
ffc1d87c: 48 00 00 08 b ffc1d884 <rtems_rfs_dir_read+0x358> <== 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);
if (rc == ENXIO)
rc = ENOENT;
ffc1d880: 3b 80 00 02 li r28,2 <== NOT EXECUTED
}
rtems_rfs_buffer_handle_close (fs, &buffer);
ffc1d884: 38 81 00 0c addi r4,r1,12 <== NOT EXECUTED
ffc1d888: 7f a3 eb 78 mr r3,r29 <== NOT EXECUTED
ffc1d88c: 4b ff f0 05 bl ffc1c890 <rtems_rfs_buffer_handle_close><== NOT EXECUTED
rtems_rfs_block_map_close (fs, &map);
ffc1d890: 7f a3 eb 78 mr r3,r29 <== NOT EXECUTED
ffc1d894: 38 81 00 18 addi r4,r1,24 <== NOT EXECUTED
ffc1d898: 4b ff da f9 bl ffc1b390 <rtems_rfs_block_map_close> <== NOT EXECUTED
return rc;
}
ffc1d89c: 39 61 00 a8 addi r11,r1,168 <== NOT EXECUTED
ffc1d8a0: 7f 83 e3 78 mr r3,r28 <== NOT EXECUTED
ffc1d8a4: 4b fe 52 1c b ffc02ac0 <_restgpr_17_x> <== NOT EXECUTED
ffc1dac4 <rtems_rfs_file_close>:
}
int
rtems_rfs_file_close (rtems_rfs_file_system* fs,
rtems_rfs_file_handle* handle)
{
ffc1dac4: 94 21 ff e0 stwu r1,-32(r1)
ffc1dac8: 7c 08 02 a6 mflr r0
ffc1dacc: bf 61 00 0c stmw r27,12(r1)
ffc1dad0: 7c 7d 1b 78 mr r29,r3
ffc1dad4: 7c 9f 23 78 mr r31,r4
int rrc;
int rc;
rrc = 0;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_CLOSE))
ffc1dad8: 38 60 00 10 li r3,16
}
int
rtems_rfs_file_close (rtems_rfs_file_system* fs,
rtems_rfs_file_handle* handle)
{
ffc1dadc: 90 01 00 24 stw r0,36(r1)
int rrc;
int rc;
rrc = 0;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_CLOSE))
ffc1dae0: 38 80 00 00 li r4,0
ffc1dae4: 4b ff 58 21 bl ffc13304 <rtems_rfs_trace>
ffc1dae8: 2f 83 00 00 cmpwi cr7,r3,0
ffc1daec: 41 be 00 1c beq+ cr7,ffc1db08 <rtems_rfs_file_close+0x44><== ALWAYS TAKEN
printf ("rtems-rfs: file-close: entry: ino=%" PRId32 "\n",
handle->shared->inode.ino);
ffc1daf0: 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",
ffc1daf4: 3c 60 ff c3 lis r3,-61 <== NOT EXECUTED
ffc1daf8: 38 63 4d db addi r3,r3,19931 <== NOT EXECUTED
ffc1dafc: 80 89 00 14 lwz r4,20(r9) <== NOT EXECUTED
ffc1db00: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc1db04: 48 00 4f e5 bl ffc22ae8 <printf> <== NOT EXECUTED
handle->shared->inode.ino);
if (handle->shared->references > 0)
ffc1db08: 80 9f 00 1c lwz r4,28(r31)
ffc1db0c: 81 24 00 08 lwz r9,8(r4)
ffc1db10: 2f 89 00 00 cmpwi cr7,r9,0
ffc1db14: 40 9d 00 0c ble- cr7,ffc1db20 <rtems_rfs_file_close+0x5c><== NEVER TAKEN
handle->shared->references--;
ffc1db18: 39 29 ff ff addi r9,r9,-1
ffc1db1c: 91 24 00 08 stw r9,8(r4)
if (handle->shared->references == 0)
ffc1db20: 80 04 00 08 lwz r0,8(r4)
rtems_rfs_file_handle* handle)
{
int rrc;
int rc;
rrc = 0;
ffc1db24: 3b c0 00 00 li r30,0
handle->shared->inode.ino);
if (handle->shared->references > 0)
handle->shared->references--;
if (handle->shared->references == 0)
ffc1db28: 2f 80 00 00 cmpwi cr7,r0,0
ffc1db2c: 40 9e 01 e8 bne- cr7,ffc1dd14 <rtems_rfs_file_close+0x250><== NEVER TAKEN
{
if (!rtems_rfs_inode_is_loaded (&handle->shared->inode))
ffc1db30: 80 04 00 18 lwz r0,24(r4)
ffc1db34: 2f 80 00 00 cmpwi cr7,r0,0
ffc1db38: 40 be 00 18 bne+ cr7,ffc1db50 <rtems_rfs_file_close+0x8c><== NEVER TAKEN
rrc = rtems_rfs_inode_load (fs, &handle->shared->inode);
ffc1db3c: 7f a3 eb 78 mr r3,r29
ffc1db40: 38 84 00 0c addi r4,r4,12
ffc1db44: 4b ff 36 f9 bl ffc1123c <rtems_rfs_inode_load>
if (rrc == 0)
ffc1db48: 7c 7e 1b 79 mr. r30,r3
ffc1db4c: 40 a2 00 f0 bne+ ffc1dc3c <rtems_rfs_file_close+0x178> <== NEVER TAKEN
{
/*
* @todo This could be clever and only update if different.
*/
rtems_rfs_inode_set_atime (&handle->shared->inode,
ffc1db50: 81 3f 00 1c lwz r9,28(r31)
ffc1db54: 80 09 00 8c lwz r0,140(r9)
*/
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);
ffc1db58: 81 69 00 18 lwz r11,24(r9)
ffc1db5c: 54 0a 46 3e rlwinm r10,r0,8,24,31
ffc1db60: 99 4b 00 10 stb r10,16(r11)
ffc1db64: 54 0a 84 3e rlwinm r10,r0,16,16,31
ffc1db68: 81 69 00 18 lwz r11,24(r9)
ffc1db6c: 99 4b 00 11 stb r10,17(r11)
ffc1db70: 54 0a c2 3e rlwinm r10,r0,24,8,31
ffc1db74: 81 69 00 18 lwz r11,24(r9)
ffc1db78: 99 4b 00 12 stb r10,18(r11)
ffc1db7c: 81 69 00 18 lwz r11,24(r9)
ffc1db80: 98 0b 00 13 stb r0,19(r11)
rtems_rfs_buffer_mark_dirty (&handle->buffer);
ffc1db84: 39 60 00 01 li r11,1
ffc1db88: 99 69 00 1c stb r11,28(r9)
handle->shared->atime);
rtems_rfs_inode_set_mtime (&handle->shared->inode,
ffc1db8c: 81 3f 00 1c lwz r9,28(r31)
ffc1db90: 80 09 00 90 lwz r0,144(r9)
*/
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);
ffc1db94: 81 49 00 18 lwz r10,24(r9)
ffc1db98: 54 08 46 3e rlwinm r8,r0,8,24,31
ffc1db9c: 99 0a 00 14 stb r8,20(r10)
ffc1dba0: 54 08 84 3e rlwinm r8,r0,16,16,31
ffc1dba4: 81 49 00 18 lwz r10,24(r9)
ffc1dba8: 99 0a 00 15 stb r8,21(r10)
ffc1dbac: 54 08 c2 3e rlwinm r8,r0,24,8,31
ffc1dbb0: 81 49 00 18 lwz r10,24(r9)
ffc1dbb4: 99 0a 00 16 stb r8,22(r10)
ffc1dbb8: 81 49 00 18 lwz r10,24(r9)
ffc1dbbc: 98 0a 00 17 stb r0,23(r10)
rtems_rfs_buffer_mark_dirty (&handle->buffer);
ffc1dbc0: 99 69 00 1c stb r11,28(r9)
handle->shared->mtime);
rtems_rfs_inode_set_ctime (&handle->shared->inode,
ffc1dbc4: 81 3f 00 1c lwz r9,28(r31)
ffc1dbc8: 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);
ffc1dbcc: 81 49 00 18 lwz r10,24(r9)
ffc1dbd0: 54 08 46 3e rlwinm r8,r0,8,24,31
ffc1dbd4: 99 0a 00 18 stb r8,24(r10)
ffc1dbd8: 54 08 84 3e rlwinm r8,r0,16,16,31
ffc1dbdc: 81 49 00 18 lwz r10,24(r9)
ffc1dbe0: 99 0a 00 19 stb r8,25(r10)
ffc1dbe4: 54 08 c2 3e rlwinm r8,r0,24,8,31
ffc1dbe8: 81 49 00 18 lwz r10,24(r9)
ffc1dbec: 99 0a 00 1a stb r8,26(r10)
ffc1dbf0: 81 49 00 18 lwz r10,24(r9)
ffc1dbf4: 98 0a 00 1b stb r0,27(r10)
rtems_rfs_buffer_mark_dirty (&handle->buffer);
ffc1dbf8: 99 69 00 1c stb r11,28(r9)
handle->shared->ctime);
if (!rtems_rfs_block_size_equal (&handle->shared->size,
ffc1dbfc: 81 3f 00 1c lwz r9,28(r31)
ffc1dc00: 80 09 00 84 lwz r0,132(r9)
ffc1dc04: 81 69 00 3c lwz r11,60(r9)
ffc1dc08: 7f 80 58 00 cmpw cr7,r0,r11
ffc1dc0c: 40 be 00 18 bne+ cr7,ffc1dc24 <rtems_rfs_file_close+0x160>
ffc1dc10: 81 49 00 88 lwz r10,136(r9)
ffc1dc14: 3b c0 00 00 li r30,0
ffc1dc18: 81 69 00 40 lwz r11,64(r9)
ffc1dc1c: 7f 8a 58 00 cmpw cr7,r10,r11
ffc1dc20: 41 9e 00 1c beq- cr7,ffc1dc3c <rtems_rfs_file_close+0x178><== 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);
ffc1dc24: 90 09 00 3c stw r0,60(r9)
map->dirty = true;
ffc1dc28: 3b c0 00 00 li r30,0
*/
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);
ffc1dc2c: 80 09 00 88 lwz r0,136(r9)
ffc1dc30: 90 09 00 40 stw r0,64(r9)
map->dirty = true;
ffc1dc34: 38 00 00 01 li r0,1
ffc1dc38: 98 09 00 34 stb r0,52(r9)
&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);
ffc1dc3c: 80 9f 00 1c lwz r4,28(r31)
ffc1dc40: 7f a3 eb 78 mr r3,r29
ffc1dc44: 38 84 00 34 addi r4,r4,52
ffc1dc48: 4b ff d7 49 bl ffc1b390 <rtems_rfs_block_map_close>
if (rc > 0)
ffc1dc4c: 7c 7c 1b 79 mr. r28,r3
ffc1dc50: 40 81 00 50 ble- ffc1dca0 <rtems_rfs_file_close+0x1dc> <== ALWAYS TAKEN
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_CLOSE))
ffc1dc54: 38 60 00 10 li r3,16 <== NOT EXECUTED
ffc1dc58: 38 80 00 00 li r4,0 <== NOT EXECUTED
ffc1dc5c: 4b ff 56 a9 bl ffc13304 <rtems_rfs_trace> <== NOT EXECUTED
ffc1dc60: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc1dc64: 41 be 00 30 beq+ cr7,ffc1dc94 <rtems_rfs_file_close+0x1d0><== NOT EXECUTED
printf ("rtems-rfs: file-close: map close error: ino=%" PRId32 ": %d: %s\n",
handle->shared->inode.ino, rc, strerror (rc));
ffc1dc68: 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",
ffc1dc6c: 7f 83 e3 78 mr r3,r28 <== NOT EXECUTED
ffc1dc70: 83 69 00 14 lwz r27,20(r9) <== NOT EXECUTED
ffc1dc74: 48 00 5b e1 bl ffc23854 <strerror> <== NOT EXECUTED
ffc1dc78: 7c 66 1b 78 mr r6,r3 <== NOT EXECUTED
ffc1dc7c: 3c 60 ff c3 lis r3,-61 <== NOT EXECUTED
ffc1dc80: 38 63 4e 02 addi r3,r3,19970 <== NOT EXECUTED
ffc1dc84: 7f 64 db 78 mr r4,r27 <== NOT EXECUTED
ffc1dc88: 7f 85 e3 78 mr r5,r28 <== NOT EXECUTED
ffc1dc8c: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc1dc90: 48 00 4e 59 bl ffc22ae8 <printf> <== NOT EXECUTED
handle->shared->inode.ino, rc, strerror (rc));
if (rrc == 0)
ffc1dc94: 2f 9e 00 00 cmpwi cr7,r30,0 <== NOT EXECUTED
ffc1dc98: 40 9e 00 08 bne- cr7,ffc1dca0 <rtems_rfs_file_close+0x1dc><== NOT EXECUTED
ffc1dc9c: 7f 9e e3 78 mr r30,r28 <== NOT EXECUTED
rrc = rc;
}
rc = rtems_rfs_inode_close (fs, &handle->shared->inode);
ffc1dca0: 80 9f 00 1c lwz r4,28(r31)
ffc1dca4: 7f a3 eb 78 mr r3,r29
ffc1dca8: 38 84 00 0c addi r4,r4,12
ffc1dcac: 4b ff 38 3d bl ffc114e8 <rtems_rfs_inode_close>
if (rc > 0)
ffc1dcb0: 7c 7c 1b 79 mr. r28,r3
ffc1dcb4: 40 81 00 50 ble- ffc1dd04 <rtems_rfs_file_close+0x240> <== ALWAYS TAKEN
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_CLOSE))
ffc1dcb8: 38 60 00 10 li r3,16 <== NOT EXECUTED
ffc1dcbc: 38 80 00 00 li r4,0 <== NOT EXECUTED
ffc1dcc0: 4b ff 56 45 bl ffc13304 <rtems_rfs_trace> <== NOT EXECUTED
ffc1dcc4: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc1dcc8: 41 be 00 30 beq+ cr7,ffc1dcf8 <rtems_rfs_file_close+0x234><== NOT EXECUTED
printf ("rtems-rfs: file-close: inode close error: ino=%" PRId32 ": %d: %s\n",
handle->shared->inode.ino, rc, strerror (rc));
ffc1dccc: 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",
ffc1dcd0: 7f 83 e3 78 mr r3,r28 <== NOT EXECUTED
ffc1dcd4: 83 69 00 14 lwz r27,20(r9) <== NOT EXECUTED
ffc1dcd8: 48 00 5b 7d bl ffc23854 <strerror> <== NOT EXECUTED
ffc1dcdc: 7c 66 1b 78 mr r6,r3 <== NOT EXECUTED
ffc1dce0: 3c 60 ff c3 lis r3,-61 <== NOT EXECUTED
ffc1dce4: 38 63 4e 3b addi r3,r3,20027 <== NOT EXECUTED
ffc1dce8: 7f 64 db 78 mr r4,r27 <== NOT EXECUTED
ffc1dcec: 7f 85 e3 78 mr r5,r28 <== NOT EXECUTED
ffc1dcf0: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc1dcf4: 48 00 4d f5 bl ffc22ae8 <printf> <== NOT EXECUTED
handle->shared->inode.ino, rc, strerror (rc));
if (rrc == 0)
ffc1dcf8: 2f 9e 00 00 cmpwi cr7,r30,0 <== NOT EXECUTED
ffc1dcfc: 40 9e 00 08 bne- cr7,ffc1dd04 <rtems_rfs_file_close+0x240><== NOT EXECUTED
ffc1dd00: 7f 9e e3 78 mr r30,r28 <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
ffc1dd04: 80 7f 00 1c lwz r3,28(r31)
ffc1dd08: 4b fe ed 41 bl ffc0ca48 <_Chain_Extract>
rrc = rc;
}
rtems_chain_extract (&handle->shared->link);
free (handle->shared);
ffc1dd0c: 80 7f 00 1c lwz r3,28(r31)
ffc1dd10: 4b fe 9b d9 bl ffc078e8 <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);
ffc1dd14: 7f a3 eb 78 mr r3,r29
ffc1dd18: 38 9f 00 04 addi r4,r31,4
ffc1dd1c: 4b ff e2 ed bl ffc1c008 <rtems_rfs_buffer_handle_release>
rc = rtems_rfs_buffer_handle_close (fs, &handle->buffer);
if ((rrc == 0) && (rc > 0))
rrc = rc;
if (rrc > 0)
ffc1dd20: 2f 9e 00 00 cmpwi cr7,r30,0
handle->dirty = false;
ffc1dd24: 38 00 00 00 li r0,0
ffc1dd28: 98 1f 00 04 stb r0,4(r31)
handle->bnum = 0;
ffc1dd2c: 38 00 00 00 li r0,0
ffc1dd30: 90 1f 00 08 stw r0,8(r31)
handle->buffer = NULL;
ffc1dd34: 90 1f 00 0c stw r0,12(r31)
ffc1dd38: 40 9d 00 38 ble- cr7,ffc1dd70 <rtems_rfs_file_close+0x2ac><== ALWAYS TAKEN
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_CLOSE))
ffc1dd3c: 38 60 00 10 li r3,16 <== NOT EXECUTED
ffc1dd40: 38 80 00 00 li r4,0 <== NOT EXECUTED
ffc1dd44: 4b ff 55 c1 bl ffc13304 <rtems_rfs_trace> <== NOT EXECUTED
ffc1dd48: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc1dd4c: 41 be 00 24 beq+ cr7,ffc1dd70 <rtems_rfs_file_close+0x2ac><== NOT EXECUTED
printf ("rtems-rfs: file-close: result: %d: %s\n", rrc, strerror (rrc));
ffc1dd50: 7f c3 f3 78 mr r3,r30 <== NOT EXECUTED
ffc1dd54: 48 00 5b 01 bl ffc23854 <strerror> <== NOT EXECUTED
ffc1dd58: 7f c4 f3 78 mr r4,r30 <== NOT EXECUTED
ffc1dd5c: 7c 65 1b 78 mr r5,r3 <== NOT EXECUTED
ffc1dd60: 3c 60 ff c3 lis r3,-61 <== NOT EXECUTED
ffc1dd64: 38 63 4e 76 addi r3,r3,20086 <== NOT EXECUTED
ffc1dd68: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc1dd6c: 48 00 4d 7d bl ffc22ae8 <printf> <== NOT EXECUTED
}
free (handle);
ffc1dd70: 7f e3 fb 78 mr r3,r31
ffc1dd74: 4b fe 9b 75 bl ffc078e8 <free>
return rrc;
}
ffc1dd78: 39 61 00 20 addi r11,r1,32
ffc1dd7c: 7f c3 f3 78 mr r3,r30
ffc1dd80: 4b fe 4d 68 b ffc02ae8 <_restgpr_27_x>
ffc1e5e8 <rtems_rfs_file_get_shared>:
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
ffc1e5e8: 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));
ffc1e5ec: 38 63 00 74 addi r3,r3,116
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))
ffc1e5f0: 48 00 00 14 b ffc1e604 <rtems_rfs_file_get_shared+0x1c>
{
rtems_rfs_file_shared* shared;
shared = (rtems_rfs_file_shared*) node;
if (shared->inode.ino == ino)
ffc1e5f4: 80 09 00 14 lwz r0,20(r9) <== NOT EXECUTED
ffc1e5f8: 7f 80 20 00 cmpw cr7,r0,r4 <== NOT EXECUTED
ffc1e5fc: 41 9e 00 18 beq- cr7,ffc1e614 <rtems_rfs_file_get_shared+0x2c><== NOT EXECUTED
return shared;
node = rtems_chain_next (node);
}
return NULL;
}
ffc1e600: 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))
ffc1e604: 7f 89 18 00 cmpw cr7,r9,r3
ffc1e608: 40 9e ff ec bne+ cr7,ffc1e5f4 <rtems_rfs_file_get_shared+0xc><== NEVER TAKEN
shared = (rtems_rfs_file_shared*) node;
if (shared->inode.ino == ino)
return shared;
node = rtems_chain_next (node);
}
return NULL;
ffc1e60c: 38 60 00 00 li r3,0
ffc1e610: 4e 80 00 20 blr
node = rtems_chain_first (&fs->file_shares);
while (!rtems_chain_is_tail (&fs->file_shares, node))
{
rtems_rfs_file_shared* shared;
shared = (rtems_rfs_file_shared*) node;
if (shared->inode.ino == ino)
ffc1e614: 7d 23 4b 78 mr r3,r9 <== NOT EXECUTED
return shared;
node = rtems_chain_next (node);
}
return NULL;
}
ffc1e618: 4e 80 00 20 blr <== NOT EXECUTED
ffc1dfa8 <rtems_rfs_file_io_end>:
int
rtems_rfs_file_io_end (rtems_rfs_file_handle* handle,
size_t size,
bool read)
{
ffc1dfa8: 94 21 ff e0 stwu r1,-32(r1)
ffc1dfac: 7c 08 02 a6 mflr r0
ffc1dfb0: bf 41 00 08 stmw r26,8(r1)
ffc1dfb4: 7c 7f 1b 78 mr r31,r3
ffc1dfb8: 7c 9c 23 78 mr r28,r4
bool atime;
bool mtime;
bool length;
int rc = 0;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
ffc1dfbc: 38 60 00 20 li r3,32
int
rtems_rfs_file_io_end (rtems_rfs_file_handle* handle,
size_t size,
bool read)
{
ffc1dfc0: 90 01 00 24 stw r0,36(r1)
bool atime;
bool mtime;
bool length;
int rc = 0;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
ffc1dfc4: 38 80 00 00 li r4,0
int
rtems_rfs_file_io_end (rtems_rfs_file_handle* handle,
size_t size,
bool read)
{
ffc1dfc8: 7c be 2b 78 mr r30,r5
bool atime;
bool mtime;
bool length;
int rc = 0;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
ffc1dfcc: 4b ff 53 39 bl ffc13304 <rtems_rfs_trace>
ffc1dfd0: 2f 83 00 00 cmpwi cr7,r3,0
ffc1dfd4: 41 9e 00 34 beq- cr7,ffc1e008 <rtems_rfs_file_io_end+0x60><== ALWAYS TAKEN
printf ("rtems-rfs: file-io: end: %s size=%zu\n",
ffc1dfd8: 2f 9e 00 00 cmpwi cr7,r30,0 <== NOT EXECUTED
ffc1dfdc: 41 9e 00 10 beq- cr7,ffc1dfec <rtems_rfs_file_io_end+0x44><== NOT EXECUTED
ffc1dfe0: 3c 80 ff c3 lis r4,-61 <== NOT EXECUTED
ffc1dfe4: 38 84 39 58 addi r4,r4,14680 <== NOT EXECUTED
ffc1dfe8: 48 00 00 0c b ffc1dff4 <rtems_rfs_file_io_end+0x4c> <== NOT EXECUTED
ffc1dfec: 3c 80 ff c3 lis r4,-61 <== NOT EXECUTED
ffc1dff0: 38 84 1a 55 addi r4,r4,6741 <== NOT EXECUTED
ffc1dff4: 3c 60 ff c3 lis r3,-61 <== NOT EXECUTED
ffc1dff8: 38 63 4f 4e addi r3,r3,20302 <== NOT EXECUTED
ffc1dffc: 7f 85 e3 78 mr r5,r28 <== NOT EXECUTED
ffc1e000: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc1e004: 48 00 4a e5 bl ffc22ae8 <printf> <== NOT EXECUTED
read ? "read" : "write", size);
if (rtems_rfs_buffer_handle_has_block (&handle->buffer))
ffc1e008: 80 1f 00 0c lwz r0,12(r31)
ffc1e00c: 2f 80 00 00 cmpwi cr7,r0,0
ffc1e010: 41 9e 00 74 beq- cr7,ffc1e084 <rtems_rfs_file_io_end+0xdc><== NEVER TAKEN
{
if (!read)
ffc1e014: 2f 9e 00 00 cmpwi cr7,r30,0
ffc1e018: 40 9e 00 0c bne- cr7,ffc1e024 <rtems_rfs_file_io_end+0x7c>
rtems_rfs_buffer_mark_dirty (rtems_rfs_file_buffer (handle));
ffc1e01c: 38 00 00 01 li r0,1
ffc1e020: 98 1f 00 04 stb r0,4(r31)
rc = rtems_rfs_buffer_handle_release (rtems_rfs_file_fs (handle),
ffc1e024: 81 3f 00 1c lwz r9,28(r31)
ffc1e028: 38 9f 00 04 addi r4,r31,4
ffc1e02c: 80 69 00 98 lwz r3,152(r9)
ffc1e030: 4b ff df d9 bl ffc1c008 <rtems_rfs_buffer_handle_release>
rtems_rfs_file_buffer (handle));
if (rc > 0)
ffc1e034: 7c 7d 1b 79 mr. r29,r3
ffc1e038: 40 81 00 50 ble- ffc1e088 <rtems_rfs_file_io_end+0xe0> <== ALWAYS TAKEN
{
printf (
ffc1e03c: 2f 9e 00 00 cmpwi cr7,r30,0 <== NOT EXECUTED
ffc1e040: 41 be 00 10 beq+ cr7,ffc1e050 <rtems_rfs_file_io_end+0xa8><== NOT EXECUTED
ffc1e044: 3f e0 ff c3 lis r31,-61 <== NOT EXECUTED
ffc1e048: 3b ff 39 58 addi r31,r31,14680 <== NOT EXECUTED
ffc1e04c: 48 00 00 0c b ffc1e058 <rtems_rfs_file_io_end+0xb0> <== NOT EXECUTED
ffc1e050: 3f e0 ff c3 lis r31,-61 <== NOT EXECUTED
ffc1e054: 3b ff 1a 55 addi r31,r31,6741 <== NOT EXECUTED
ffc1e058: 7f a3 eb 78 mr r3,r29 <== NOT EXECUTED
ffc1e05c: 48 00 57 f9 bl ffc23854 <strerror> <== NOT EXECUTED
ffc1e060: 7f e4 fb 78 mr r4,r31 <== NOT EXECUTED
ffc1e064: 7c 67 1b 78 mr r7,r3 <== NOT EXECUTED
ffc1e068: 3c 60 ff c3 lis r3,-61 <== NOT EXECUTED
ffc1e06c: 7f 85 e3 78 mr r5,r28 <== NOT EXECUTED
ffc1e070: 7f a6 eb 78 mr r6,r29 <== NOT EXECUTED
ffc1e074: 38 63 4f 76 addi r3,r3,20342 <== NOT EXECUTED
ffc1e078: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc1e07c: 48 00 4a 6d bl ffc22ae8 <printf> <== NOT EXECUTED
"rtems-rfs: file-io: end: error on release: %s size=%zu: %d: %s\n",
read ? "read" : "write", size, rc, strerror (rc));
return rc;
ffc1e080: 48 00 01 94 b ffc1e214 <rtems_rfs_file_io_end+0x26c> <== NOT EXECUTED
bool read)
{
bool atime;
bool mtime;
bool length;
int rc = 0;
ffc1e084: 3b a0 00 00 li r29,0 <== NOT EXECUTED
* 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)))
ffc1e088: 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;
ffc1e08c: 80 1f 00 14 lwz r0,20(r31)
if (handle->bpos.boff >=
rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle)))
ffc1e090: 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;
ffc1e094: 7f 9c 02 14 add r28,r28,r0
if (handle->bpos.boff >=
rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle)))
ffc1e098: 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;
ffc1e09c: 93 9f 00 14 stw r28,20(r31)
if (handle->bpos.boff >=
ffc1e0a0: 7f 9c 00 40 cmplw cr7,r28,r0
ffc1e0a4: 41 9c 00 18 blt- cr7,ffc1e0bc <rtems_rfs_file_io_end+0x114><== ALWAYS TAKEN
rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle)))
{
handle->bpos.bno++;
ffc1e0a8: 81 7f 00 10 lwz r11,16(r31) <== NOT EXECUTED
handle->bpos.boff -= rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
ffc1e0ac: 7f 80 e0 50 subf r28,r0,r28 <== NOT EXECUTED
ffc1e0b0: 93 9f 00 14 stw r28,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++;
ffc1e0b4: 39 6b 00 01 addi r11,r11,1 <== NOT EXECUTED
ffc1e0b8: 91 7f 00 10 stw r11,16(r31) <== NOT EXECUTED
}
length = false;
mtime = false;
if (!read &&
ffc1e0bc: 2f 9e 00 00 cmpwi cr7,r30,0
handle->bpos.bno++;
handle->bpos.boff -= rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
}
length = false;
mtime = false;
ffc1e0c0: 38 00 00 00 li r0,0
if (!read &&
ffc1e0c4: 40 9e 00 58 bne- cr7,ffc1e11c <rtems_rfs_file_io_end+0x174>
rtems_rfs_block_map_past_end (rtems_rfs_file_map (handle),
ffc1e0c8: 81 7f 00 10 lwz r11,16(r31)
ffc1e0cc: 81 49 00 3c lwz r10,60(r9)
}
length = false;
mtime = false;
if (!read &&
ffc1e0d0: 2f 8b 00 00 cmpwi cr7,r11,0
ffc1e0d4: 41 9e 00 0c beq- cr7,ffc1e0e0 <rtems_rfs_file_io_end+0x138><== ALWAYS TAKEN
rtems_rfs_block_map_past_end (rtems_rfs_file_map (handle),
ffc1e0d8: 2f 8a 00 00 cmpwi cr7,r10,0 <== NOT EXECUTED
ffc1e0dc: 41 9e 00 2c beq- cr7,ffc1e108 <rtems_rfs_file_io_end+0x160><== NOT EXECUTED
ffc1e0e0: 7f 8b 50 40 cmplw cr7,r11,r10
ffc1e0e4: 40 9c 00 24 bge- cr7,ffc1e108 <rtems_rfs_file_io_end+0x160><== NEVER TAKEN
ffc1e0e8: 39 4a ff ff addi r10,r10,-1
ffc1e0ec: 7f 8b 50 00 cmpw cr7,r11,r10
handle->bpos.bno++;
handle->bpos.boff -= rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
}
length = false;
mtime = false;
ffc1e0f0: 38 00 00 00 li r0,0
if (!read &&
rtems_rfs_block_map_past_end (rtems_rfs_file_map (handle),
ffc1e0f4: 40 be 00 28 bne+ cr7,ffc1e11c <rtems_rfs_file_io_end+0x174><== NEVER TAKEN
ffc1e0f8: 81 5f 00 14 lwz r10,20(r31)
ffc1e0fc: 81 69 00 40 lwz r11,64(r9)
ffc1e100: 7f 8a 58 40 cmplw cr7,r10,r11
ffc1e104: 40 9d 00 18 ble- cr7,ffc1e11c <rtems_rfs_file_io_end+0x174>
*/
static inline void
rtems_rfs_block_map_set_size_offset (rtems_rfs_block_map* map,
rtems_rfs_block_off offset)
{
map->size.offset = offset;
ffc1e108: 80 1f 00 14 lwz r0,20(r31)
ffc1e10c: 90 09 00 40 stw r0,64(r9)
map->dirty = true;
ffc1e110: 38 00 00 01 li r0,1
ffc1e114: 98 09 00 34 stb r0,52(r9)
rtems_rfs_file_bpos (handle)))
{
rtems_rfs_block_map_set_size_offset (rtems_rfs_file_map (handle),
handle->bpos.boff);
length = true;
mtime = true;
ffc1e118: 38 00 00 01 li r0,1
}
atime = rtems_rfs_file_update_atime (handle);
ffc1e11c: 81 3f 00 00 lwz r9,0(r31)
mtime = rtems_rfs_file_update_mtime (handle) && mtime;
ffc1e120: 3b 80 00 00 li r28,0
handle->bpos.boff);
length = true;
mtime = true;
}
atime = rtems_rfs_file_update_atime (handle);
ffc1e124: 71 2b 00 01 andi. r11,r9,1
ffc1e128: 7f 60 00 26 mfcr r27
ffc1e12c: 57 7b 1f fe rlwinm r27,r27,3,31,31
mtime = rtems_rfs_file_update_mtime (handle) && mtime;
ffc1e130: 71 2b 00 02 andi. r11,r9,2
ffc1e134: 40 82 00 08 bne- ffc1e13c <rtems_rfs_file_io_end+0x194> <== NEVER TAKEN
ffc1e138: 7c 1c 03 78 mr r28,r0
length = rtems_rfs_file_update_length (handle) && length;
ffc1e13c: 71 2b 00 04 andi. r11,r9,4
length = true;
mtime = true;
}
atime = rtems_rfs_file_update_atime (handle);
mtime = rtems_rfs_file_update_mtime (handle) && mtime;
ffc1e140: 57 9c 06 3e clrlwi r28,r28,24
length = rtems_rfs_file_update_length (handle) && length;
ffc1e144: 3b 40 00 00 li r26,0
ffc1e148: 40 82 00 08 bne- ffc1e150 <rtems_rfs_file_io_end+0x1a8> <== NEVER TAKEN
ffc1e14c: 7c 1a 03 78 mr r26,r0
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
ffc1e150: 38 60 00 20 li r3,32
ffc1e154: 38 80 00 00 li r4,0
ffc1e158: 4b ff 51 ad bl ffc13304 <rtems_rfs_trace>
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;
ffc1e15c: 57 5a 06 3e clrlwi r26,r26,24
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
ffc1e160: 2f 83 00 00 cmpwi cr7,r3,0
ffc1e164: 41 9e 00 50 beq- cr7,ffc1e1b4 <rtems_rfs_file_io_end+0x20c><== ALWAYS TAKEN
printf ("rtems-rfs: file-io: end: pos=%" PRIu32 ":%" PRIu32 " %c %c %c\n",
ffc1e168: 30 db ff ff addic r6,r27,-1 <== NOT EXECUTED
ffc1e16c: 7c c6 31 10 subfe r6,r6,r6 <== NOT EXECUTED
ffc1e170: 80 9f 00 10 lwz r4,16(r31) <== NOT EXECUTED
ffc1e174: 80 bf 00 14 lwz r5,20(r31) <== NOT EXECUTED
ffc1e178: 38 00 ff ec li r0,-20 <== NOT EXECUTED
ffc1e17c: 30 fc ff ff addic r7,r28,-1 <== NOT EXECUTED
ffc1e180: 7c e7 39 10 subfe r7,r7,r7 <== NOT EXECUTED
ffc1e184: 31 1a ff ff addic r8,r26,-1 <== NOT EXECUTED
ffc1e188: 7d 08 41 10 subfe r8,r8,r8 <== NOT EXECUTED
ffc1e18c: 7c c6 00 38 and r6,r6,r0 <== NOT EXECUTED
ffc1e190: 54 e7 00 34 rlwinm r7,r7,0,0,26 <== NOT EXECUTED
ffc1e194: 55 08 07 f4 rlwinm r8,r8,0,31,26 <== NOT EXECUTED
ffc1e198: 3c 60 ff c3 lis r3,-61 <== NOT EXECUTED
ffc1e19c: 38 63 4f b8 addi r3,r3,20408 <== NOT EXECUTED
ffc1e1a0: 38 c6 00 41 addi r6,r6,65 <== NOT EXECUTED
ffc1e1a4: 38 e7 00 4d addi r7,r7,77 <== NOT EXECUTED
ffc1e1a8: 39 08 00 4c addi r8,r8,76 <== NOT EXECUTED
ffc1e1ac: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc1e1b0: 48 00 49 39 bl ffc22ae8 <printf> <== NOT EXECUTED
handle->bpos.bno, handle->bpos.boff,
atime ? 'A' : '-', mtime ? 'M' : '-', length ? 'L' : '-');
if (atime || mtime)
ffc1e1b4: 2f 9b 00 00 cmpwi cr7,r27,0
ffc1e1b8: 40 9e 00 0c bne- cr7,ffc1e1c4 <rtems_rfs_file_io_end+0x21c><== ALWAYS TAKEN
ffc1e1bc: 2f 9c 00 00 cmpwi cr7,r28,0 <== NOT EXECUTED
ffc1e1c0: 41 9e 00 38 beq- cr7,ffc1e1f8 <rtems_rfs_file_io_end+0x250><== NOT EXECUTED
{
time_t now = time (NULL);
ffc1e1c4: 38 60 00 00 li r3,0
ffc1e1c8: 48 00 81 a1 bl ffc26368 <time>
if (read && atime)
ffc1e1cc: 2f 9e 00 00 cmpwi cr7,r30,0
ffc1e1d0: 41 9e 00 18 beq- cr7,ffc1e1e8 <rtems_rfs_file_io_end+0x240>
ffc1e1d4: 2f 9b 00 00 cmpwi cr7,r27,0
ffc1e1d8: 41 9e 00 20 beq- cr7,ffc1e1f8 <rtems_rfs_file_io_end+0x250><== NEVER TAKEN
handle->shared->atime = now;
ffc1e1dc: 81 3f 00 1c lwz r9,28(r31)
ffc1e1e0: 90 69 00 8c stw r3,140(r9)
ffc1e1e4: 48 00 00 14 b ffc1e1f8 <rtems_rfs_file_io_end+0x250>
if (!read && mtime)
ffc1e1e8: 2f 9c 00 00 cmpwi cr7,r28,0
ffc1e1ec: 41 9e 00 0c beq- cr7,ffc1e1f8 <rtems_rfs_file_io_end+0x250>
handle->shared->mtime = now;
ffc1e1f0: 81 3f 00 1c lwz r9,28(r31)
ffc1e1f4: 90 69 00 90 stw r3,144(r9)
}
if (length)
ffc1e1f8: 2f 9a 00 00 cmpwi cr7,r26,0
ffc1e1fc: 41 9e 00 18 beq- cr7,ffc1e214 <rtems_rfs_file_io_end+0x26c>
{
handle->shared->size.count =
rtems_rfs_block_map_count (rtems_rfs_file_map (handle));
ffc1e200: 81 3f 00 1c lwz r9,28(r31)
if (!read && mtime)
handle->shared->mtime = now;
}
if (length)
{
handle->shared->size.count =
ffc1e204: 80 09 00 3c lwz r0,60(r9)
ffc1e208: 90 09 00 84 stw r0,132(r9)
rtems_rfs_block_map_count (rtems_rfs_file_map (handle));
handle->shared->size.offset =
ffc1e20c: 80 09 00 40 lwz r0,64(r9)
ffc1e210: 90 09 00 88 stw r0,136(r9)
rtems_rfs_block_map_size_offset (rtems_rfs_file_map (handle));
}
return rc;
}
ffc1e214: 39 61 00 20 addi r11,r1,32
ffc1e218: 7f a3 eb 78 mr r3,r29
ffc1e21c: 4b fe 48 c8 b ffc02ae4 <_restgpr_26_x>
ffc1e220 <rtems_rfs_file_io_release>:
int
rtems_rfs_file_io_release (rtems_rfs_file_handle* handle)
{
ffc1e220: 7c 08 02 a6 mflr r0 <== NOT EXECUTED
ffc1e224: 94 21 ff f8 stwu r1,-8(r1) <== NOT EXECUTED
ffc1e228: 7c 64 1b 78 mr r4,r3 <== NOT EXECUTED
ffc1e22c: 90 01 00 0c stw r0,12(r1) <== NOT EXECUTED
int rc = 0;
if (rtems_rfs_buffer_handle_has_block (&handle->buffer))
ffc1e230: 80 03 00 0c lwz r0,12(r3) <== NOT EXECUTED
}
int
rtems_rfs_file_io_release (rtems_rfs_file_handle* handle)
{
int rc = 0;
ffc1e234: 38 60 00 00 li r3,0 <== NOT EXECUTED
if (rtems_rfs_buffer_handle_has_block (&handle->buffer))
ffc1e238: 2f 80 00 00 cmpwi cr7,r0,0 <== NOT EXECUTED
ffc1e23c: 41 9e 00 14 beq- cr7,ffc1e250 <rtems_rfs_file_io_release+0x30><== NOT EXECUTED
rc = rtems_rfs_buffer_handle_release (rtems_rfs_file_fs (handle),
ffc1e240: 81 24 00 1c lwz r9,28(r4) <== NOT EXECUTED
ffc1e244: 38 84 00 04 addi r4,r4,4 <== NOT EXECUTED
ffc1e248: 80 69 00 98 lwz r3,152(r9) <== NOT EXECUTED
ffc1e24c: 4b ff dd bd bl ffc1c008 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
rtems_rfs_file_buffer (handle));
return rc;
}
ffc1e250: 80 01 00 0c lwz r0,12(r1) <== NOT EXECUTED
ffc1e254: 38 21 00 08 addi r1,r1,8 <== NOT EXECUTED
ffc1e258: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
ffc1e25c: 4e 80 00 20 blr <== NOT EXECUTED
ffc1dd84 <rtems_rfs_file_io_start>:
int
rtems_rfs_file_io_start (rtems_rfs_file_handle* handle,
size_t* available,
bool read)
{
ffc1dd84: 94 21 ff d0 stwu r1,-48(r1)
ffc1dd88: 7c 08 02 a6 mflr r0
ffc1dd8c: bf 61 00 1c stmw r27,28(r1)
ffc1dd90: 7c 7f 1b 78 mr r31,r3
ffc1dd94: 7c 9e 23 78 mr r30,r4
size_t size;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
ffc1dd98: 38 60 00 20 li r3,32
int
rtems_rfs_file_io_start (rtems_rfs_file_handle* handle,
size_t* available,
bool read)
{
ffc1dd9c: 90 01 00 34 stw r0,52(r1)
size_t size;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
ffc1dda0: 38 80 00 00 li r4,0
int
rtems_rfs_file_io_start (rtems_rfs_file_handle* handle,
size_t* available,
bool read)
{
ffc1dda4: 7c bd 2b 78 mr r29,r5
size_t size;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
ffc1dda8: 4b ff 55 5d bl ffc13304 <rtems_rfs_trace>
ffc1ddac: 2f 83 00 00 cmpwi cr7,r3,0
ffc1ddb0: 41 9e 00 38 beq- cr7,ffc1dde8 <rtems_rfs_file_io_start+0x64><== ALWAYS TAKEN
printf ("rtems-rfs: file-io: start: %s pos=%" PRIu32 ":%" PRIu32 "\n",
ffc1ddb4: 2f 9d 00 00 cmpwi cr7,r29,0 <== NOT EXECUTED
ffc1ddb8: 41 9e 00 10 beq- cr7,ffc1ddc8 <rtems_rfs_file_io_start+0x44><== NOT EXECUTED
ffc1ddbc: 3c 80 ff c3 lis r4,-61 <== NOT EXECUTED
ffc1ddc0: 38 84 39 58 addi r4,r4,14680 <== NOT EXECUTED
ffc1ddc4: 48 00 00 0c b ffc1ddd0 <rtems_rfs_file_io_start+0x4c><== NOT EXECUTED
ffc1ddc8: 3c 80 ff c3 lis r4,-61 <== NOT EXECUTED
ffc1ddcc: 38 84 1a 55 addi r4,r4,6741 <== NOT EXECUTED
ffc1ddd0: 3c 60 ff c3 lis r3,-61 <== NOT EXECUTED
ffc1ddd4: 80 bf 00 10 lwz r5,16(r31) <== NOT EXECUTED
ffc1ddd8: 80 df 00 14 lwz r6,20(r31) <== NOT EXECUTED
ffc1dddc: 38 63 4e 9d addi r3,r3,20125 <== NOT EXECUTED
ffc1dde0: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc1dde4: 48 00 4d 05 bl ffc22ae8 <printf> <== NOT EXECUTED
read ? "read" : "write", handle->bpos.bno, handle->bpos.boff);
if (!rtems_rfs_buffer_handle_has_block (&handle->buffer))
ffc1dde8: 83 9f 00 0c lwz r28,12(r31)
ffc1ddec: 2f 9c 00 00 cmpwi cr7,r28,0
ffc1ddf0: 40 be 01 28 bne+ cr7,ffc1df18 <rtems_rfs_file_io_start+0x194><== NEVER TAKEN
bool request_read;
int rc;
request_read = read;
rc = rtems_rfs_block_map_find (rtems_rfs_file_fs (handle),
ffc1ddf4: 80 9f 00 1c lwz r4,28(r31)
ffc1ddf8: 38 bf 00 10 addi r5,r31,16
ffc1ddfc: 38 c1 00 08 addi r6,r1,8
ffc1de00: 80 64 00 98 lwz r3,152(r4)
ffc1de04: 38 84 00 34 addi r4,r4,52
ffc1de08: 4b ff d7 75 bl ffc1b57c <rtems_rfs_block_map_find>
ffc1de0c: 2f 9d 00 00 cmpwi cr7,r29,0
rtems_rfs_file_map (handle),
rtems_rfs_file_bpos (handle),
&block);
if (rc > 0)
ffc1de10: 7c 7b 1b 79 mr. r27,r3
ffc1de14: 40 81 00 68 ble- ffc1de7c <rtems_rfs_file_io_start+0xf8><== ALWAYS TAKEN
ffc1de18: 2f 1b 00 06 cmpwi cr6,r27,6 <== NOT EXECUTED
{
/*
* Has the read reached the EOF ?
*/
if (read && (rc == ENXIO))
ffc1de1c: 41 9e 00 14 beq- cr7,ffc1de30 <rtems_rfs_file_io_start+0xac><== NOT EXECUTED
ffc1de20: 40 ba 01 7c bne+ cr6,ffc1df9c <rtems_rfs_file_io_start+0x218><== NOT EXECUTED
{
*available = 0;
ffc1de24: 93 9e 00 00 stw r28,0(r30) <== NOT EXECUTED
return 0;
ffc1de28: 3b 60 00 00 li r27,0 <== NOT EXECUTED
ffc1de2c: 48 00 01 70 b ffc1df9c <rtems_rfs_file_io_start+0x218><== NOT EXECUTED
}
if (rc != ENXIO)
ffc1de30: 40 ba 01 6c bne+ cr6,ffc1df9c <rtems_rfs_file_io_start+0x218><== NOT EXECUTED
return rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
ffc1de34: 38 60 00 20 li r3,32 <== NOT EXECUTED
ffc1de38: 38 80 00 00 li r4,0 <== NOT EXECUTED
ffc1de3c: 4b ff 54 c9 bl ffc13304 <rtems_rfs_trace> <== NOT EXECUTED
ffc1de40: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc1de44: 41 be 00 10 beq+ cr7,ffc1de54 <rtems_rfs_file_io_start+0xd0><== NOT EXECUTED
printf ("rtems-rfs: file-io: start: grow\n");
ffc1de48: 3c 60 ff c3 lis r3,-61 <== NOT EXECUTED
ffc1de4c: 38 63 4e c8 addi r3,r3,20168 <== NOT EXECUTED
ffc1de50: 48 00 4e 4d bl ffc22c9c <puts> <== NOT EXECUTED
rc = rtems_rfs_block_map_grow (rtems_rfs_file_fs (handle),
ffc1de54: 80 9f 00 1c lwz r4,28(r31) <== NOT EXECUTED
ffc1de58: 38 a0 00 01 li r5,1 <== NOT EXECUTED
ffc1de5c: 38 c1 00 08 addi r6,r1,8 <== NOT EXECUTED
ffc1de60: 80 64 00 98 lwz r3,152(r4) <== NOT EXECUTED
ffc1de64: 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;
ffc1de68: 3b 80 00 00 li r28,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),
ffc1de6c: 4b ff d9 41 bl ffc1b7ac <rtems_rfs_block_map_grow> <== NOT EXECUTED
rtems_rfs_file_map (handle),
1, &block);
if (rc > 0)
ffc1de70: 7c 7b 1b 79 mr. r27,r3 <== NOT EXECUTED
ffc1de74: 41 a1 01 28 bgt+ ffc1df9c <rtems_rfs_file_io_start+0x218><== NOT EXECUTED
ffc1de78: 48 00 00 3c b ffc1deb4 <rtems_rfs_file_io_start+0x130><== 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 &&
ffc1de7c: 40 9e 00 34 bne- cr7,ffc1deb0 <rtems_rfs_file_io_start+0x12c>
ffc1de80: 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;
ffc1de84: 3b 80 00 01 li r28,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 &&
ffc1de88: 2f 80 00 00 cmpwi cr7,r0,0
ffc1de8c: 40 9e 00 28 bne- cr7,ffc1deb4 <rtems_rfs_file_io_start+0x130><== NEVER TAKEN
(rtems_rfs_file_block_offset (handle) ||
(*available < rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle)))))
ffc1de90: 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) ||
ffc1de94: 83 9e 00 00 lwz r28,0(r30)
(*available < rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle)))))
ffc1de98: 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) ||
ffc1de9c: 80 09 00 08 lwz r0,8(r9)
ffc1dea0: 7f 80 e0 10 subfc r28,r0,r28
ffc1dea4: 7f 9c e1 10 subfe r28,r28,r28
ffc1dea8: 7f 9c 00 d0 neg r28,r28
ffc1deac: 48 00 00 08 b ffc1deb4 <rtems_rfs_file_io_start+0x130>
/*
* 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 &&
ffc1deb0: 7f bc eb 78 mr r28,r29
(rtems_rfs_file_block_offset (handle) ||
(*available < rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle)))))
request_read = true;
}
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
ffc1deb4: 38 60 00 20 li r3,32
ffc1deb8: 38 80 00 00 li r4,0
ffc1debc: 4b ff 54 49 bl ffc13304 <rtems_rfs_trace>
ffc1dec0: 2f 83 00 00 cmpwi cr7,r3,0
ffc1dec4: 41 9e 00 34 beq- cr7,ffc1def8 <rtems_rfs_file_io_start+0x174><== ALWAYS TAKEN
printf ("rtems-rfs: file-io: start: block=%" PRIu32 " request-read=%s\n",
ffc1dec8: 2f 9c 00 00 cmpwi cr7,r28,0 <== NOT EXECUTED
ffc1decc: 80 81 00 08 lwz r4,8(r1) <== NOT EXECUTED
ffc1ded0: 41 9e 00 10 beq- cr7,ffc1dee0 <rtems_rfs_file_io_start+0x15c><== NOT EXECUTED
ffc1ded4: 3c a0 ff c3 lis r5,-61 <== NOT EXECUTED
ffc1ded8: 38 a5 34 57 addi r5,r5,13399 <== NOT EXECUTED
ffc1dedc: 48 00 00 0c b ffc1dee8 <rtems_rfs_file_io_start+0x164><== NOT EXECUTED
ffc1dee0: 3c a0 ff c3 lis r5,-61 <== NOT EXECUTED
ffc1dee4: 38 a5 38 ec addi r5,r5,14572 <== NOT EXECUTED
ffc1dee8: 3c 60 ff c3 lis r3,-61 <== NOT EXECUTED
ffc1deec: 38 63 4e e8 addi r3,r3,20200 <== NOT EXECUTED
ffc1def0: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc1def4: 48 00 4b f5 bl ffc22ae8 <printf> <== NOT EXECUTED
block, request_read ? "yes" : "no");
rc = rtems_rfs_buffer_handle_request (rtems_rfs_file_fs (handle),
ffc1def8: 81 3f 00 1c lwz r9,28(r31)
ffc1defc: 38 9f 00 04 addi r4,r31,4
ffc1df00: 80 a1 00 08 lwz r5,8(r1)
ffc1df04: 7f 86 e3 78 mr r6,r28
ffc1df08: 80 69 00 98 lwz r3,152(r9)
ffc1df0c: 4b ff e2 dd bl ffc1c1e8 <rtems_rfs_buffer_handle_request>
rtems_rfs_file_buffer (handle),
block, request_read);
if (rc > 0)
ffc1df10: 7c 7b 1b 79 mr. r27,r3
ffc1df14: 41 a1 00 88 bgt+ ffc1df9c <rtems_rfs_file_io_start+0x218><== NEVER TAKEN
return rc;
}
if (read
ffc1df18: 2f 9d 00 00 cmpwi cr7,r29,0
ffc1df1c: 41 9e 00 38 beq- cr7,ffc1df54 <rtems_rfs_file_io_start+0x1d0>
&& rtems_rfs_block_map_last (rtems_rfs_file_map (handle))
ffc1df20: 81 3f 00 1c lwz r9,28(r31)
ffc1df24: 80 09 00 44 lwz r0,68(r9)
ffc1df28: 81 69 00 3c lwz r11,60(r9)
ffc1df2c: 2f 80 00 00 cmpwi cr7,r0,0
ffc1df30: 40 9e 00 0c bne- cr7,ffc1df3c <rtems_rfs_file_io_start+0x1b8><== NEVER TAKEN
ffc1df34: 2f 8b 00 00 cmpwi cr7,r11,0
ffc1df38: 41 9e 00 10 beq- cr7,ffc1df48 <rtems_rfs_file_io_start+0x1c4><== NEVER TAKEN
ffc1df3c: 39 6b ff ff addi r11,r11,-1
ffc1df40: 7f 80 58 00 cmpw cr7,r0,r11
ffc1df44: 40 be 00 10 bne+ cr7,ffc1df54 <rtems_rfs_file_io_start+0x1d0><== NEVER TAKEN
&& rtems_rfs_block_map_size_offset (rtems_rfs_file_map (handle)))
ffc1df48: 83 a9 00 40 lwz r29,64(r9)
ffc1df4c: 2f 9d 00 00 cmpwi cr7,r29,0
ffc1df50: 40 9e 00 10 bne- cr7,ffc1df60 <rtems_rfs_file_io_start+0x1dc><== ALWAYS TAKEN
size = rtems_rfs_block_map_size_offset (rtems_rfs_file_map (handle));
else
size = rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
ffc1df54: 81 3f 00 1c lwz r9,28(r31)
ffc1df58: 81 29 00 98 lwz r9,152(r9)
ffc1df5c: 83 a9 00 08 lwz r29,8(r9)
*available = size - rtems_rfs_file_block_offset (handle);
ffc1df60: 80 1f 00 14 lwz r0,20(r31)
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
ffc1df64: 38 60 00 20 li r3,32
ffc1df68: 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);
ffc1df6c: 7c 00 e8 50 subf r0,r0,r29
ffc1df70: 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;
ffc1df74: 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))
ffc1df78: 4b ff 53 8d bl ffc13304 <rtems_rfs_trace>
ffc1df7c: 2f 83 00 00 cmpwi cr7,r3,0
ffc1df80: 41 be 00 1c beq+ cr7,ffc1df9c <rtems_rfs_file_io_start+0x218><== ALWAYS TAKEN
printf ("rtems-rfs: file-io: start: available=%zu (%zu)\n",
ffc1df84: 3c 60 ff c3 lis r3,-61 <== NOT EXECUTED
ffc1df88: 80 9e 00 00 lwz r4,0(r30) <== NOT EXECUTED
ffc1df8c: 38 63 4f 1e addi r3,r3,20254 <== NOT EXECUTED
ffc1df90: 7f a5 eb 78 mr r5,r29 <== NOT EXECUTED
ffc1df94: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc1df98: 48 00 4b 51 bl ffc22ae8 <printf> <== NOT EXECUTED
*available, size);
return 0;
}
ffc1df9c: 39 61 00 30 addi r11,r1,48
ffc1dfa0: 7f 63 db 78 mr r3,r27
ffc1dfa4: 4b fe 4b 44 b ffc02ae8 <_restgpr_27_x>
ffc1e61c <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)
{
ffc1e61c: 94 21 ff d8 stwu r1,-40(r1)
ffc1e620: 7c 08 02 a6 mflr r0
ffc1e624: bf 01 00 08 stmw r24,8(r1)
ffc1e628: 7c 7d 1b 78 mr r29,r3
ffc1e62c: 7c 9c 23 78 mr r28,r4
rtems_rfs_file_handle* handle;
rtems_rfs_file_shared* shared;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_OPEN))
ffc1e630: 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)
{
ffc1e634: 90 01 00 2c stw r0,44(r1)
rtems_rfs_file_handle* handle;
rtems_rfs_file_shared* shared;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_OPEN))
ffc1e638: 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)
{
ffc1e63c: 7c b9 2b 78 mr r25,r5
ffc1e640: 7c da 33 78 mr r26,r6
rtems_rfs_file_handle* handle;
rtems_rfs_file_shared* shared;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_OPEN))
ffc1e644: 4b ff 4c c1 bl ffc13304 <rtems_rfs_trace>
ffc1e648: 2f 83 00 00 cmpwi cr7,r3,0
ffc1e64c: 41 be 00 18 beq+ cr7,ffc1e664 <rtems_rfs_file_open+0x48><== ALWAYS TAKEN
printf ("rtems-rfs: file-open: ino=%" PRId32 "\n", ino);
ffc1e650: 3c 60 ff c3 lis r3,-61 <== NOT EXECUTED
ffc1e654: 38 63 50 2e addi r3,r3,20526 <== NOT EXECUTED
ffc1e658: 7f 84 e3 78 mr r4,r28 <== NOT EXECUTED
ffc1e65c: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc1e660: 48 00 44 89 bl ffc22ae8 <printf> <== NOT EXECUTED
*file = NULL;
ffc1e664: 3b c0 00 00 li r30,0
ffc1e668: 93 da 00 00 stw r30,0(r26)
/*
* 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));
ffc1e66c: 38 60 00 20 li r3,32
if (!handle)
return ENOMEM;
ffc1e670: 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));
ffc1e674: 4b fe 99 e1 bl ffc08054 <malloc>
if (!handle)
ffc1e678: 7c 7f 1b 79 mr. r31,r3
ffc1e67c: 41 82 02 a0 beq- ffc1e91c <rtems_rfs_file_open+0x300> <== NEVER TAKEN
return ENOMEM;
memset (handle, 0, sizeof (rtems_rfs_file_handle));
ffc1e680: 38 80 00 00 li r4,0
ffc1e684: 38 a0 00 20 li r5,32
ffc1e688: 48 00 42 d1 bl ffc22958 <memset>
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
ffc1e68c: 9b df 00 04 stb r30,4(r31)
/*
* Scan the file system data list of open files for this ino. If found up
* the reference count and return the pointer to the data.
*/
shared = rtems_rfs_file_get_shared (fs, ino);
ffc1e690: 7f a3 eb 78 mr r3,r29
handle->bnum = 0;
ffc1e694: 93 df 00 08 stw r30,8(r31)
ffc1e698: 7f 84 e3 78 mr r4,r28
handle->buffer = NULL;
ffc1e69c: 93 df 00 0c stw r30,12(r31)
ffc1e6a0: 4b ff ff 49 bl ffc1e5e8 <rtems_rfs_file_get_shared>
if (shared)
ffc1e6a4: 7c 7e 1b 79 mr. r30,r3
ffc1e6a8: 41 82 00 30 beq- ffc1e6d8 <rtems_rfs_file_open+0xbc> <== ALWAYS TAKEN
{
shared->references++;
ffc1e6ac: 81 3e 00 08 lwz r9,8(r30) <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_OPEN))
ffc1e6b0: 38 60 00 08 li r3,8 <== NOT EXECUTED
ffc1e6b4: 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++;
ffc1e6b8: 38 09 00 01 addi r0,r9,1 <== NOT EXECUTED
ffc1e6bc: 90 1e 00 08 stw r0,8(r30) <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_OPEN))
ffc1e6c0: 4b ff 4c 45 bl ffc13304 <rtems_rfs_trace> <== NOT EXECUTED
ffc1e6c4: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc1e6c8: 41 be 02 44 beq+ cr7,ffc1e90c <rtems_rfs_file_open+0x2f0><== NOT EXECUTED
printf ("rtems-rfs: file-open: ino=%" PRId32 " shared\n", ino);
ffc1e6cc: 3c 60 ff c3 lis r3,-61 <== NOT EXECUTED
ffc1e6d0: 38 63 50 4d addi r3,r3,20557 <== NOT EXECUTED
ffc1e6d4: 48 00 02 2c b ffc1e900 <rtems_rfs_file_open+0x2e4> <== 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));
ffc1e6d8: 38 60 00 9c li r3,156
ffc1e6dc: 4b fe 99 79 bl ffc08054 <malloc>
if (!shared)
ffc1e6e0: 7c 7e 1b 79 mr. r30,r3
ffc1e6e4: 40 a2 00 20 bne+ ffc1e704 <rtems_rfs_file_open+0xe8> <== 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);
ffc1e6e8: 7f a3 eb 78 mr r3,r29 <== NOT EXECUTED
ffc1e6ec: 38 9f 00 04 addi r4,r31,4 <== NOT EXECUTED
ffc1e6f0: 4b ff d9 19 bl ffc1c008 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
handle->dirty = false;
ffc1e6f4: 9b df 00 04 stb r30,4(r31) <== NOT EXECUTED
handle->bnum = 0;
ffc1e6f8: 93 df 00 08 stw r30,8(r31) <== NOT EXECUTED
handle->buffer = NULL;
ffc1e6fc: 93 df 00 0c stw r30,12(r31) <== NOT EXECUTED
ffc1e700: 48 00 00 e8 b ffc1e7e8 <rtems_rfs_file_open+0x1cc> <== NOT EXECUTED
rtems_rfs_buffer_handle_close (fs, &handle->buffer);
free (handle);
return ENOMEM;
}
memset (shared, 0, sizeof (rtems_rfs_file_shared));
ffc1e704: 38 80 00 00 li r4,0
ffc1e708: 38 a0 00 9c li r5,156
rc = rtems_rfs_inode_open (fs, ino, &shared->inode, true);
ffc1e70c: 3b 7e 00 0c addi r27,r30,12
rtems_rfs_buffer_handle_close (fs, &handle->buffer);
free (handle);
return ENOMEM;
}
memset (shared, 0, sizeof (rtems_rfs_file_shared));
ffc1e710: 48 00 42 49 bl ffc22958 <memset>
rc = rtems_rfs_inode_open (fs, ino, &shared->inode, true);
ffc1e714: 7f a3 eb 78 mr r3,r29
ffc1e718: 7f 84 e3 78 mr r4,r28
ffc1e71c: 7f 65 db 78 mr r5,r27
ffc1e720: 38 c0 00 01 li r6,1
ffc1e724: 4b ff 2b d5 bl ffc112f8 <rtems_rfs_inode_open>
if (rc > 0)
ffc1e728: 7c 78 1b 79 mr. r24,r3
ffc1e72c: 40 81 00 3c ble- ffc1e768 <rtems_rfs_file_open+0x14c> <== ALWAYS TAKEN
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_OPEN))
ffc1e730: 38 60 00 08 li r3,8 <== NOT EXECUTED
ffc1e734: 38 80 00 00 li r4,0 <== NOT EXECUTED
ffc1e738: 4b ff 4b cd bl ffc13304 <rtems_rfs_trace> <== NOT EXECUTED
ffc1e73c: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc1e740: 41 be 00 80 beq+ cr7,ffc1e7c0 <rtems_rfs_file_open+0x1a4><== NOT EXECUTED
printf ("rtems-rfs: file-open: inode open failed: %d: %s\n",
ffc1e744: 7f 03 c3 78 mr r3,r24 <== NOT EXECUTED
ffc1e748: 48 00 51 0d bl ffc23854 <strerror> <== NOT EXECUTED
ffc1e74c: 7f 04 c3 78 mr r4,r24 <== NOT EXECUTED
ffc1e750: 7c 65 1b 78 mr r5,r3 <== NOT EXECUTED
ffc1e754: 3c 60 ff c3 lis r3,-61 <== NOT EXECUTED
ffc1e758: 38 63 50 73 addi r3,r3,20595 <== NOT EXECUTED
ffc1e75c: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc1e760: 48 00 43 89 bl ffc22ae8 <printf> <== NOT EXECUTED
ffc1e764: 48 00 00 5c b ffc1e7c0 <rtems_rfs_file_open+0x1a4> <== 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);
ffc1e768: 7f a3 eb 78 mr r3,r29
ffc1e76c: 7f 64 db 78 mr r4,r27
ffc1e770: 38 be 00 34 addi r5,r30,52
ffc1e774: 4b ff ca 69 bl ffc1b1dc <rtems_rfs_block_map_open>
if (rc > 0)
ffc1e778: 7c 78 1b 79 mr. r24,r3
ffc1e77c: 40 81 00 78 ble- ffc1e7f4 <rtems_rfs_file_open+0x1d8> <== ALWAYS TAKEN
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_OPEN))
ffc1e780: 38 60 00 08 li r3,8 <== NOT EXECUTED
ffc1e784: 38 80 00 00 li r4,0 <== NOT EXECUTED
ffc1e788: 4b ff 4b 7d bl ffc13304 <rtems_rfs_trace> <== NOT EXECUTED
ffc1e78c: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc1e790: 41 be 00 24 beq+ cr7,ffc1e7b4 <rtems_rfs_file_open+0x198><== NOT EXECUTED
printf ("rtems-rfs: file-open: block map open failed: %d: %s\n",
ffc1e794: 7f 03 c3 78 mr r3,r24 <== NOT EXECUTED
ffc1e798: 48 00 50 bd bl ffc23854 <strerror> <== NOT EXECUTED
ffc1e79c: 7f 04 c3 78 mr r4,r24 <== NOT EXECUTED
ffc1e7a0: 7c 65 1b 78 mr r5,r3 <== NOT EXECUTED
ffc1e7a4: 3c 60 ff c3 lis r3,-61 <== NOT EXECUTED
ffc1e7a8: 38 63 50 a4 addi r3,r3,20644 <== NOT EXECUTED
ffc1e7ac: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc1e7b0: 48 00 43 39 bl ffc22ae8 <printf> <== NOT EXECUTED
rc, strerror (rc));
rtems_rfs_inode_close (fs, &shared->inode);
ffc1e7b4: 7f a3 eb 78 mr r3,r29 <== NOT EXECUTED
ffc1e7b8: 7f 64 db 78 mr r4,r27 <== NOT EXECUTED
ffc1e7bc: 4b ff 2d 2d bl ffc114e8 <rtems_rfs_inode_close> <== NOT EXECUTED
free (shared);
ffc1e7c0: 7f c3 f3 78 mr r3,r30 <== NOT EXECUTED
ffc1e7c4: 4b fe 91 25 bl ffc078e8 <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);
ffc1e7c8: 7f a3 eb 78 mr r3,r29 <== NOT EXECUTED
ffc1e7cc: 38 9f 00 04 addi r4,r31,4 <== NOT EXECUTED
ffc1e7d0: 4b ff d8 39 bl ffc1c008 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
handle->dirty = false;
ffc1e7d4: 38 00 00 00 li r0,0 <== NOT EXECUTED
ffc1e7d8: 98 1f 00 04 stb r0,4(r31) <== NOT EXECUTED
handle->bnum = 0;
ffc1e7dc: 38 00 00 00 li r0,0 <== NOT EXECUTED
ffc1e7e0: 90 1f 00 08 stw r0,8(r31) <== NOT EXECUTED
handle->buffer = NULL;
ffc1e7e4: 90 1f 00 0c stw r0,12(r31) <== NOT EXECUTED
rtems_rfs_buffer_handle_close (fs, &handle->buffer);
free (handle);
ffc1e7e8: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc1e7ec: 4b fe 90 fd bl ffc078e8 <free> <== NOT EXECUTED
return rc;
ffc1e7f0: 48 00 01 2c b ffc1e91c <rtems_rfs_file_open+0x300> <== NOT EXECUTED
}
shared->references = 1;
ffc1e7f4: 38 00 00 01 li r0,1
if (shared->inode.ino == ino)
return shared;
node = rtems_chain_next (node);
}
return NULL;
}
ffc1e7f8: 81 3e 00 18 lwz r9,24(r30)
rtems_rfs_buffer_handle_close (fs, &handle->buffer);
free (handle);
return rc;
}
shared->references = 1;
ffc1e7fc: 90 1e 00 08 stw r0,8(r30)
RTEMS_INLINE_ROUTINE void rtems_chain_append(
rtems_chain_control *the_chain,
rtems_chain_node *the_node
)
{
_Chain_Append( the_chain, the_node );
ffc1e800: 38 7d 00 70 addi r3,r29,112
ffc1e804: 7f c4 f3 78 mr r4,r30
* @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);
ffc1e808: 89 69 00 0c lbz r11,12(r9)
ffc1e80c: 88 09 00 0d lbz r0,13(r9)
ffc1e810: 55 6b c0 0e rlwinm r11,r11,24,0,7
ffc1e814: 54 00 80 1e rlwinm r0,r0,16,0,15
ffc1e818: 7d 60 03 78 or r0,r11,r0
ffc1e81c: 89 69 00 0f lbz r11,15(r9)
ffc1e820: 7c 00 5b 78 or r0,r0,r11
ffc1e824: 89 69 00 0e lbz r11,14(r9)
ffc1e828: 55 6b 40 2e rlwinm r11,r11,8,0,23
ffc1e82c: 7c 00 5b 78 or r0,r0,r11
shared->size.count = rtems_rfs_inode_get_block_count (&shared->inode);
ffc1e830: 90 1e 00 84 stw r0,132(r30)
* @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);
ffc1e834: 88 09 00 0a lbz r0,10(r9)
ffc1e838: 89 69 00 0b lbz r11,11(r9)
ffc1e83c: 54 00 40 2e rlwinm r0,r0,8,0,23
shared->size.offset = rtems_rfs_inode_get_block_offset (&shared->inode);
ffc1e840: 7c 00 5b 78 or r0,r0,r11
ffc1e844: 90 1e 00 88 stw r0,136(r30)
* @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);
ffc1e848: 89 69 00 10 lbz r11,16(r9)
ffc1e84c: 88 09 00 11 lbz r0,17(r9)
ffc1e850: 55 6b c0 0e rlwinm r11,r11,24,0,7
ffc1e854: 54 00 80 1e rlwinm r0,r0,16,0,15
ffc1e858: 7d 60 03 78 or r0,r11,r0
ffc1e85c: 89 69 00 13 lbz r11,19(r9)
ffc1e860: 7c 00 5b 78 or r0,r0,r11
ffc1e864: 89 69 00 12 lbz r11,18(r9)
ffc1e868: 55 6b 40 2e rlwinm r11,r11,8,0,23
ffc1e86c: 7c 00 5b 78 or r0,r0,r11
shared->atime = rtems_rfs_inode_get_atime (&shared->inode);
ffc1e870: 90 1e 00 8c stw r0,140(r30)
* @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);
ffc1e874: 89 69 00 14 lbz r11,20(r9)
ffc1e878: 88 09 00 15 lbz r0,21(r9)
ffc1e87c: 55 6b c0 0e rlwinm r11,r11,24,0,7
ffc1e880: 54 00 80 1e rlwinm r0,r0,16,0,15
ffc1e884: 7d 60 03 78 or r0,r11,r0
ffc1e888: 89 69 00 17 lbz r11,23(r9)
ffc1e88c: 7c 00 5b 78 or r0,r0,r11
ffc1e890: 89 69 00 16 lbz r11,22(r9)
ffc1e894: 55 6b 40 2e rlwinm r11,r11,8,0,23
ffc1e898: 7c 00 5b 78 or r0,r0,r11
shared->mtime = rtems_rfs_inode_get_mtime (&shared->inode);
ffc1e89c: 90 1e 00 90 stw r0,144(r30)
* @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);
ffc1e8a0: 89 69 00 18 lbz r11,24(r9)
ffc1e8a4: 88 09 00 19 lbz r0,25(r9)
ffc1e8a8: 55 6b c0 0e rlwinm r11,r11,24,0,7
ffc1e8ac: 54 00 80 1e rlwinm r0,r0,16,0,15
ffc1e8b0: 7d 60 03 78 or r0,r11,r0
ffc1e8b4: 89 69 00 1b lbz r11,27(r9)
ffc1e8b8: 89 29 00 1a lbz r9,26(r9)
ffc1e8bc: 7c 00 5b 78 or r0,r0,r11
shared->ctime = rtems_rfs_inode_get_ctime (&shared->inode);
shared->fs = fs;
ffc1e8c0: 93 be 00 98 stw r29,152(r30)
ffc1e8c4: 55 29 40 2e rlwinm r9,r9,8,0,23
ffc1e8c8: 7c 00 4b 78 or r0,r0,r9
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);
ffc1e8cc: 90 1e 00 94 stw r0,148(r30)
ffc1e8d0: 4b fe e1 49 bl ffc0ca18 <_Chain_Append>
shared->fs = fs;
rtems_chain_append (&fs->file_shares, &shared->link);
rtems_rfs_inode_unload (fs, &shared->inode, false);
ffc1e8d4: 7f 64 db 78 mr r4,r27
ffc1e8d8: 38 a0 00 00 li r5,0
ffc1e8dc: 7f a3 eb 78 mr r3,r29
ffc1e8e0: 4b ff 2b 05 bl ffc113e4 <rtems_rfs_inode_unload>
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_OPEN))
ffc1e8e4: 38 60 00 08 li r3,8
ffc1e8e8: 38 80 00 00 li r4,0
ffc1e8ec: 4b ff 4a 19 bl ffc13304 <rtems_rfs_trace>
ffc1e8f0: 2f 83 00 00 cmpwi cr7,r3,0
ffc1e8f4: 41 be 00 18 beq+ cr7,ffc1e90c <rtems_rfs_file_open+0x2f0><== ALWAYS TAKEN
printf ("rtems-rfs: file-open: ino=%" PRId32 " share created\n", ino);
ffc1e8f8: 3c 60 ff c3 lis r3,-61 <== NOT EXECUTED
ffc1e8fc: 38 63 50 d9 addi r3,r3,20697 <== NOT EXECUTED
ffc1e900: 7f 84 e3 78 mr r4,r28 <== NOT EXECUTED
ffc1e904: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc1e908: 48 00 41 e1 bl ffc22ae8 <printf> <== NOT EXECUTED
}
handle->flags = flags;
ffc1e90c: 93 3f 00 00 stw r25,0(r31)
handle->shared = shared;
*file = handle;
return 0;
ffc1e910: 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;
ffc1e914: 93 df 00 1c stw r30,28(r31)
*file = handle;
ffc1e918: 93 fa 00 00 stw r31,0(r26)
return 0;
}
ffc1e91c: 39 61 00 28 addi r11,r1,40
ffc1e920: 7f 03 c3 78 mr r3,r24
ffc1e924: 4b fe 41 b8 b ffc02adc <_restgpr_24_x>
ffc1e260 <rtems_rfs_file_seek>:
int
rtems_rfs_file_seek (rtems_rfs_file_handle* handle,
rtems_rfs_pos pos,
rtems_rfs_pos* new_pos)
{
ffc1e260: 94 21 ff e8 stwu r1,-24(r1)
ffc1e264: 7c 08 02 a6 mflr r0
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
ffc1e268: 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)
{
ffc1e26c: bf 81 00 08 stmw r28,8(r1)
ffc1e270: 7c 7d 1b 78 mr r29,r3
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
ffc1e274: 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)
{
ffc1e278: 90 01 00 1c stw r0,28(r1)
ffc1e27c: 7c bf 2b 78 mr r31,r5
ffc1e280: 7c de 33 78 mr r30,r6
ffc1e284: 7c fc 3b 78 mr r28,r7
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
ffc1e288: 4b ff 50 7d bl ffc13304 <rtems_rfs_trace>
ffc1e28c: 2f 83 00 00 cmpwi cr7,r3,0
ffc1e290: 41 be 00 1c beq+ cr7,ffc1e2ac <rtems_rfs_file_seek+0x4c><== ALWAYS TAKEN
printf ("rtems-rfs: file-seek: new=%" PRIu64 "\n", pos);
ffc1e294: 3c 60 ff c3 lis r3,-61 <== NOT EXECUTED
ffc1e298: 38 63 4f e9 addi r3,r3,20457 <== NOT EXECUTED
ffc1e29c: 7f e5 fb 78 mr r5,r31 <== NOT EXECUTED
ffc1e2a0: 7f c6 f3 78 mr r6,r30 <== NOT EXECUTED
ffc1e2a4: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc1e2a8: 48 00 48 41 bl ffc22ae8 <printf> <== NOT EXECUTED
* 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),
ffc1e2ac: 80 9d 00 1c lwz r4,28(r29)
ffc1e2b0: 80 64 00 98 lwz r3,152(r4)
ffc1e2b4: 38 84 00 84 addi r4,r4,132
ffc1e2b8: 4b ff ce d5 bl ffc1b18c <rtems_rfs_block_get_size>
ffc1e2bc: 7f 83 f8 40 cmplw cr7,r3,r31
ffc1e2c0: 41 9d 00 14 bgt- cr7,ffc1e2d4 <rtems_rfs_file_seek+0x74><== NEVER TAKEN
ffc1e2c4: 7f 83 f8 00 cmpw cr7,r3,r31
ffc1e2c8: 40 be 00 24 bne+ cr7,ffc1e2ec <rtems_rfs_file_seek+0x8c><== NEVER TAKEN
ffc1e2cc: 7f 84 f0 40 cmplw cr7,r4,r30
ffc1e2d0: 40 bd 00 1c ble+ cr7,ffc1e2ec <rtems_rfs_file_seek+0x8c><== ALWAYS TAKEN
handle->shared))
rtems_rfs_file_set_bpos (handle, pos);
ffc1e2d4: 81 3d 00 1c lwz r9,28(r29) <== NOT EXECUTED
ffc1e2d8: 7f e5 fb 78 mr r5,r31 <== NOT EXECUTED
ffc1e2dc: 7f c6 f3 78 mr r6,r30 <== NOT EXECUTED
ffc1e2e0: 80 69 00 98 lwz r3,152(r9) <== NOT EXECUTED
ffc1e2e4: 38 fd 00 10 addi r7,r29,16 <== NOT EXECUTED
ffc1e2e8: 4b ff cd c1 bl ffc1b0a8 <rtems_rfs_block_get_bpos> <== NOT EXECUTED
*new_pos = pos;
return 0;
}
ffc1e2ec: 39 61 00 18 addi r11,r1,24
*/
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;
ffc1e2f0: 93 fc 00 00 stw r31,0(r28)
return 0;
}
ffc1e2f4: 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;
ffc1e2f8: 93 dc 00 04 stw r30,4(r28)
return 0;
}
ffc1e2fc: 4b fe 47 f0 b ffc02aec <_restgpr_28_x>
ffc1e300 <rtems_rfs_file_set_size>:
int
rtems_rfs_file_set_size (rtems_rfs_file_handle* handle,
rtems_rfs_pos new_size)
{
ffc1e300: 94 21 ff b0 stwu r1,-80(r1)
ffc1e304: 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))
ffc1e308: 38 80 00 00 li r4,0
}
int
rtems_rfs_file_set_size (rtems_rfs_file_handle* handle,
rtems_rfs_pos new_size)
{
ffc1e30c: 90 01 00 54 stw r0,84(r1)
ffc1e310: be 61 00 1c stmw r19,28(r1)
ffc1e314: 7c 7b 1b 78 mr r27,r3
ffc1e318: 7c df 33 78 mr r31,r6
rtems_rfs_block_map* map = rtems_rfs_file_map (handle);
ffc1e31c: 83 43 00 1c lwz r26,28(r3)
rtems_rfs_pos size;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
ffc1e320: 38 60 00 20 li r3,32
}
int
rtems_rfs_file_set_size (rtems_rfs_file_handle* handle,
rtems_rfs_pos new_size)
{
ffc1e324: 7c be 2b 78 mr r30,r5
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))
ffc1e328: 4b ff 4f dd bl ffc13304 <rtems_rfs_trace>
ffc1e32c: 2f 83 00 00 cmpwi cr7,r3,0
int
rtems_rfs_file_set_size (rtems_rfs_file_handle* handle,
rtems_rfs_pos new_size)
{
rtems_rfs_block_map* map = rtems_rfs_file_map (handle);
ffc1e330: 3a da 00 34 addi r22,r26,52
rtems_rfs_pos size;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
ffc1e334: 41 be 00 1c beq+ cr7,ffc1e350 <rtems_rfs_file_set_size+0x50><== ALWAYS TAKEN
printf ("rtems-rfs: file-set-size: size=%" PRIu64 "\n", new_size);
ffc1e338: 3c 60 ff c3 lis r3,-61 <== NOT EXECUTED
ffc1e33c: 38 63 50 09 addi r3,r3,20489 <== NOT EXECUTED
ffc1e340: 7f c5 f3 78 mr r5,r30 <== NOT EXECUTED
ffc1e344: 7f e6 fb 78 mr r6,r31 <== NOT EXECUTED
ffc1e348: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc1e34c: 48 00 47 9d bl ffc22ae8 <printf> <== NOT EXECUTED
/*
* Short cut for the common truncate on open call.
*/
if (new_size == 0)
ffc1e350: 7f c0 fb 79 or. r0,r30,r31
ffc1e354: 80 9b 00 1c lwz r4,28(r27)
{
rc = rtems_rfs_block_map_free_all (rtems_rfs_file_fs (handle), map);
ffc1e358: 80 64 00 98 lwz r3,152(r4)
printf ("rtems-rfs: file-set-size: size=%" PRIu64 "\n", new_size);
/*
* Short cut for the common truncate on open call.
*/
if (new_size == 0)
ffc1e35c: 40 82 00 18 bne- ffc1e374 <rtems_rfs_file_set_size+0x74>
{
rc = rtems_rfs_block_map_free_all (rtems_rfs_file_fs (handle), map);
ffc1e360: 7e c4 b3 78 mr r4,r22
ffc1e364: 4b ff da f1 bl ffc1be54 <rtems_rfs_block_map_free_all>
if (rc > 0)
ffc1e368: 7c 73 1b 79 mr. r19,r3
ffc1e36c: 41 a1 02 70 bgt+ ffc1e5dc <rtems_rfs_file_set_size+0x2dc><== NEVER TAKEN
ffc1e370: 48 00 02 3c b ffc1e5ac <rtems_rfs_file_set_size+0x2ac>
ffc1e374: 38 84 00 84 addi r4,r4,132
ffc1e378: 4b ff ce 15 bl ffc1b18c <rtems_rfs_block_get_size>
ffc1e37c: 7c 6a 1b 78 mr r10,r3
size = rtems_rfs_file_size (handle);
/*
* If the file is same size do nothing else grow or shrink it ?
*/
if (size != new_size)
ffc1e380: 7f 8a f0 00 cmpw cr7,r10,r30
ffc1e384: 7c 8b 23 78 mr r11,r4
ffc1e388: 40 be 00 0c bne+ cr7,ffc1e394 <rtems_rfs_file_set_size+0x94>
ffc1e38c: 7f 84 f8 00 cmpw cr7,r4,r31
ffc1e390: 41 9e 02 1c beq- cr7,ffc1e5ac <rtems_rfs_file_set_size+0x2ac>
{
if (size < new_size)
ffc1e394: 7f 9e 50 40 cmplw cr7,r30,r10
ffc1e398: 41 9d 00 14 bgt- cr7,ffc1e3ac <rtems_rfs_file_set_size+0xac>
ffc1e39c: 7f 9e 50 00 cmpw cr7,r30,r10
ffc1e3a0: 40 9e 01 4c bne- cr7,ffc1e4ec <rtems_rfs_file_set_size+0x1ec><== NEVER TAKEN
ffc1e3a4: 7f 9f 58 40 cmplw cr7,r31,r11
ffc1e3a8: 40 9d 01 44 ble- cr7,ffc1e4ec <rtems_rfs_file_set_size+0x1ec><== NEVER 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));
ffc1e3ac: 81 3b 00 1c lwz r9,28(r27)
*/
rtems_rfs_pos count;
uint32_t length;
bool read_block;
count = new_size - size;
ffc1e3b0: 7f eb f8 10 subfc r31,r11,r31
ffc1e3b4: 7f ca f1 10 subfe r30,r10,r30
length = rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
ffc1e3b8: 81 29 00 98 lwz r9,152(r9)
read_block = false;
ffc1e3bc: 3a 80 00 00 li r20,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);
ffc1e3c0: 3a e0 00 00 li r23,0
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));
ffc1e3c4: 83 29 00 08 lwz r25,8(r9)
ffc1e3c8: 3b 00 00 01 li r24,1
}
/*
* Only read the block if the length is not the block size.
*/
rc = rtems_rfs_buffer_handle_request (rtems_rfs_file_fs (handle),
ffc1e3cc: 3a bb 00 04 addi r21,r27,4
count = new_size - size;
length = rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
read_block = false;
while (count)
ffc1e3d0: 48 00 01 10 b ffc1e4e0 <rtems_rfs_file_set_size+0x1e0>
/*
* 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);
ffc1e3d4: 80 1a 00 40 lwz r0,64(r26)
ffc1e3d8: 81 3a 00 3c lwz r9,60(r26)
ffc1e3dc: 2f 80 00 00 cmpwi cr7,r0,0
ffc1e3e0: 90 01 00 10 stw r0,16(r1)
ffc1e3e4: 91 21 00 0c stw r9,12(r1)
ffc1e3e8: 92 e1 00 14 stw r23,20(r1)
ffc1e3ec: 41 9e 00 0c beq- cr7,ffc1e3f8 <rtems_rfs_file_set_size+0xf8>
ffc1e3f0: 39 29 ff ff addi r9,r9,-1
ffc1e3f4: 91 21 00 0c stw r9,12(r1)
rc = rtems_rfs_block_map_find (rtems_rfs_file_fs (handle),
ffc1e3f8: 81 3b 00 1c lwz r9,28(r27)
ffc1e3fc: 7e c4 b3 78 mr r4,r22
ffc1e400: 38 a1 00 0c addi r5,r1,12
ffc1e404: 80 69 00 98 lwz r3,152(r9)
ffc1e408: 38 c1 00 08 addi r6,r1,8
ffc1e40c: 4b ff d1 71 bl ffc1b57c <rtems_rfs_block_map_find>
map, &bpos, &block);
if (rc > 0)
ffc1e410: 7c 73 1b 79 mr. r19,r3
ffc1e414: 40 81 00 2c ble- ffc1e440 <rtems_rfs_file_set_size+0x140>
{
/*
* Have we reached the EOF ?
*/
if (rc != ENXIO)
ffc1e418: 2f 93 00 06 cmpwi cr7,r19,6
ffc1e41c: 40 9e 01 c0 bne- cr7,ffc1e5dc <rtems_rfs_file_set_size+0x2dc><== NEVER TAKEN
return rc;
rc = rtems_rfs_block_map_grow (rtems_rfs_file_fs (handle),
ffc1e420: 81 3b 00 1c lwz r9,28(r27)
ffc1e424: 7e c4 b3 78 mr r4,r22
ffc1e428: 38 a0 00 01 li r5,1
ffc1e42c: 80 69 00 98 lwz r3,152(r9)
ffc1e430: 38 c1 00 08 addi r6,r1,8
ffc1e434: 4b ff d3 79 bl ffc1b7ac <rtems_rfs_block_map_grow>
map, 1, &block);
if (rc > 0)
ffc1e438: 7c 73 1b 79 mr. r19,r3
ffc1e43c: 41 81 01 a0 bgt- ffc1e5dc <rtems_rfs_file_set_size+0x2dc>
return rc;
}
if (count < (length - bpos.boff))
ffc1e440: 7f 97 f0 00 cmpw cr7,r23,r30
ffc1e444: 80 01 00 10 lwz r0,16(r1)
ffc1e448: 7d 20 c8 50 subf r9,r0,r25
ffc1e44c: 40 9e 00 20 bne- cr7,ffc1e46c <rtems_rfs_file_set_size+0x16c>
ffc1e450: 7f 89 f8 40 cmplw cr7,r9,r31
ffc1e454: 40 9d 00 18 ble- cr7,ffc1e46c <rtems_rfs_file_set_size+0x16c><== NEVER TAKEN
{
length = count + bpos.boff;
ffc1e458: 7f 20 fa 14 add r25,r0,r31
ffc1e45c: 9b 1a 00 34 stb r24,52(r26)
read_block = true;
ffc1e460: 3a 80 00 01 li r20,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;
ffc1e464: 93 3a 00 40 stw r25,64(r26)
ffc1e468: 48 00 00 0c b ffc1e474 <rtems_rfs_file_set_size+0x174>
ffc1e46c: 92 fa 00 40 stw r23,64(r26)
map->dirty = true;
ffc1e470: 9b 1a 00 34 stb r24,52(r26)
}
/*
* Only read the block if the length is not the block size.
*/
rc = rtems_rfs_buffer_handle_request (rtems_rfs_file_fs (handle),
ffc1e474: 81 3b 00 1c lwz r9,28(r27)
ffc1e478: 7e a4 ab 78 mr r4,r21
ffc1e47c: 80 a1 00 08 lwz r5,8(r1)
ffc1e480: 7e 86 a3 78 mr r6,r20
ffc1e484: 80 69 00 98 lwz r3,152(r9)
ffc1e488: 4b ff dd 61 bl ffc1c1e8 <rtems_rfs_buffer_handle_request>
rtems_rfs_file_buffer (handle),
block, read_block);
if (rc > 0)
ffc1e48c: 7c 73 1b 79 mr. r19,r3
ffc1e490: 41 81 01 4c bgt- ffc1e5dc <rtems_rfs_file_set_size+0x2dc><== NEVER TAKEN
return rc;
dst = rtems_rfs_buffer_data (&handle->buffer);
ffc1e494: 81 3b 00 0c lwz r9,12(r27)
memset (dst + bpos.boff, 0, length - bpos.boff);
ffc1e498: 38 80 00 00 li r4,0
ffc1e49c: 80 a1 00 10 lwz r5,16(r1)
ffc1e4a0: 80 69 00 24 lwz r3,36(r9)
ffc1e4a4: 7c 63 2a 14 add r3,r3,r5
ffc1e4a8: 7c a5 c8 50 subf r5,r5,r25
ffc1e4ac: 48 00 44 ad bl ffc22958 <memset>
rtems_rfs_buffer_mark_dirty (rtems_rfs_file_buffer (handle));
rc = rtems_rfs_buffer_handle_release (rtems_rfs_file_fs (handle),
ffc1e4b0: 81 3b 00 1c lwz r9,28(r27)
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));
ffc1e4b4: 9b 1b 00 04 stb r24,4(r27)
rc = rtems_rfs_buffer_handle_release (rtems_rfs_file_fs (handle),
ffc1e4b8: 7e a4 ab 78 mr r4,r21
ffc1e4bc: 80 69 00 98 lwz r3,152(r9)
ffc1e4c0: 4b ff db 49 bl ffc1c008 <rtems_rfs_buffer_handle_release>
rtems_rfs_file_buffer (handle));
if (rc > 0)
ffc1e4c4: 7c 73 1b 79 mr. r19,r3
ffc1e4c8: 41 81 01 14 bgt- ffc1e5dc <rtems_rfs_file_set_size+0x2dc><== NEVER TAKEN
return rc;
count -= length - bpos.boff;
ffc1e4cc: 80 01 00 10 lwz r0,16(r1)
ffc1e4d0: 3b 80 00 00 li r28,0
ffc1e4d4: 7f a0 c8 50 subf r29,r0,r25
ffc1e4d8: 7f fd f8 10 subfc r31,r29,r31
ffc1e4dc: 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)
ffc1e4e0: 7f c9 fb 79 or. r9,r30,r31
ffc1e4e4: 40 82 fe f0 bne+ ffc1e3d4 <rtems_rfs_file_set_size+0xd4>
ffc1e4e8: 48 00 00 c4 b ffc1e5ac <rtems_rfs_file_set_size+0x2ac>
uint32_t offset;
blocks =
rtems_rfs_block_map_count (map) -
(((new_size - 1) /
rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle))) + 1);
ffc1e4ec: 83 3b 00 1c lwz r25,28(r27) <== NOT EXECUTED
rtems_rfs_block_no blocks;
uint32_t offset;
blocks =
rtems_rfs_block_map_count (map) -
(((new_size - 1) /
ffc1e4f0: 38 a0 00 00 li r5,0 <== NOT EXECUTED
ffc1e4f4: 30 9f ff ff addic r4,r31,-1 <== NOT EXECUTED
ffc1e4f8: 7c 7e 01 d4 addme r3,r30 <== NOT EXECUTED
rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle))) + 1);
ffc1e4fc: 83 19 00 98 lwz r24,152(r25) <== NOT EXECUTED
rtems_rfs_block_no blocks;
uint32_t offset;
blocks =
rtems_rfs_block_map_count (map) -
(((new_size - 1) /
ffc1e500: 83 98 00 08 lwz r28,8(r24) <== NOT EXECUTED
ffc1e504: 7f 86 e3 78 mr r6,r28 <== NOT EXECUTED
ffc1e508: 48 01 1b 39 bl ffc30040 <__udivdi3> <== NOT EXECUTED
* Shrink
*/
rtems_rfs_block_no blocks;
uint32_t offset;
blocks =
ffc1e50c: 80 1a 00 3c lwz r0,60(r26) <== NOT EXECUTED
ffc1e510: 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)
ffc1e514: 7c a5 02 15 add. r5,r5,r0 <== NOT EXECUTED
ffc1e518: 41 a2 00 18 beq+ ffc1e530 <rtems_rfs_file_set_size+0x230><== NOT EXECUTED
{
int rc;
rc = rtems_rfs_block_map_shrink (rtems_rfs_file_fs (handle),
ffc1e51c: 7f 03 c3 78 mr r3,r24 <== NOT EXECUTED
ffc1e520: 38 99 00 34 addi r4,r25,52 <== NOT EXECUTED
ffc1e524: 4b ff d6 19 bl ffc1bb3c <rtems_rfs_block_map_shrink> <== NOT EXECUTED
rtems_rfs_file_map (handle),
blocks);
if (rc > 0)
ffc1e528: 7c 73 1b 79 mr. r19,r3 <== NOT EXECUTED
ffc1e52c: 41 a1 00 b0 bgt+ ffc1e5dc <rtems_rfs_file_set_size+0x2dc><== 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));
ffc1e530: 7f c3 f3 78 mr r3,r30 <== NOT EXECUTED
ffc1e534: 7f e4 fb 78 mr r4,r31 <== NOT EXECUTED
ffc1e538: 38 a0 00 00 li r5,0 <== NOT EXECUTED
ffc1e53c: 7f 86 e3 78 mr r6,r28 <== NOT EXECUTED
ffc1e540: 48 01 1e f5 bl ffc30434 <__umoddi3> <== NOT EXECUTED
ffc1e544: 38 00 00 01 li r0,1 <== NOT EXECUTED
ffc1e548: 98 1a 00 34 stb r0,52(r26) <== 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),
ffc1e54c: 80 1b 00 10 lwz r0,16(r27) <== 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;
ffc1e550: 90 9a 00 40 stw r4,64(r26) <== NOT EXECUTED
ffc1e554: 2f 80 00 00 cmpwi cr7,r0,0 <== NOT EXECUTED
ffc1e558: 81 3a 00 3c lwz r9,60(r26) <== NOT EXECUTED
ffc1e55c: 41 9e 00 0c beq- cr7,ffc1e568 <rtems_rfs_file_set_size+0x268><== NOT EXECUTED
ffc1e560: 2f 89 00 00 cmpwi cr7,r9,0 <== NOT EXECUTED
ffc1e564: 41 9e 00 24 beq- cr7,ffc1e588 <rtems_rfs_file_set_size+0x288><== NOT EXECUTED
ffc1e568: 7f 80 48 40 cmplw cr7,r0,r9 <== NOT EXECUTED
ffc1e56c: 40 9c 00 1c bge- cr7,ffc1e588 <rtems_rfs_file_set_size+0x288><== NOT EXECUTED
ffc1e570: 39 29 ff ff addi r9,r9,-1 <== NOT EXECUTED
ffc1e574: 7f 80 48 00 cmpw cr7,r0,r9 <== NOT EXECUTED
ffc1e578: 40 be 00 34 bne+ cr7,ffc1e5ac <rtems_rfs_file_set_size+0x2ac><== NOT EXECUTED
ffc1e57c: 80 1b 00 14 lwz r0,20(r27) <== NOT EXECUTED
ffc1e580: 7f 80 20 40 cmplw cr7,r0,r4 <== NOT EXECUTED
ffc1e584: 40 9d 00 28 ble- cr7,ffc1e5ac <rtems_rfs_file_set_size+0x2ac><== NOT EXECUTED
rtems_rfs_block_map_size (map)))
rtems_rfs_block_size_get_bpos (rtems_rfs_block_map_size (map),
ffc1e588: 2f 84 00 00 cmpwi cr7,r4,0 <== NOT EXECUTED
ffc1e58c: 81 3a 00 3c lwz r9,60(r26) <== NOT EXECUTED
ffc1e590: 38 00 00 00 li r0,0 <== NOT EXECUTED
ffc1e594: 90 9b 00 14 stw r4,20(r27) <== NOT EXECUTED
ffc1e598: 91 3b 00 10 stw r9,16(r27) <== NOT EXECUTED
ffc1e59c: 90 1b 00 18 stw r0,24(r27) <== NOT EXECUTED
ffc1e5a0: 41 9e 00 0c beq- cr7,ffc1e5ac <rtems_rfs_file_set_size+0x2ac><== NOT EXECUTED
ffc1e5a4: 39 29 ff ff addi r9,r9,-1 <== NOT EXECUTED
ffc1e5a8: 91 3b 00 10 stw r9,16(r27) <== NOT EXECUTED
rtems_rfs_file_bpos (handle));
}
}
}
handle->shared->size.count = rtems_rfs_block_map_count (map);
ffc1e5ac: 83 db 00 1c lwz r30,28(r27)
handle->shared->size.offset = rtems_rfs_block_map_size_offset (map);
if (rtems_rfs_file_update_mtime (handle))
handle->shared->mtime = time (NULL);
return 0;
ffc1e5b0: 3a 60 00 00 li r19,0
rtems_rfs_file_bpos (handle));
}
}
}
handle->shared->size.count = rtems_rfs_block_map_count (map);
ffc1e5b4: 80 1a 00 3c lwz r0,60(r26)
ffc1e5b8: 90 1e 00 84 stw r0,132(r30)
handle->shared->size.offset = rtems_rfs_block_map_size_offset (map);
ffc1e5bc: 80 1a 00 40 lwz r0,64(r26)
ffc1e5c0: 90 1e 00 88 stw r0,136(r30)
if (rtems_rfs_file_update_mtime (handle))
ffc1e5c4: 80 1b 00 00 lwz r0,0(r27)
ffc1e5c8: 70 09 00 02 andi. r9,r0,2
ffc1e5cc: 40 a2 00 10 bne+ ffc1e5dc <rtems_rfs_file_set_size+0x2dc><== NEVER TAKEN
handle->shared->mtime = time (NULL);
ffc1e5d0: 38 60 00 00 li r3,0
ffc1e5d4: 48 00 7d 95 bl ffc26368 <time>
ffc1e5d8: 90 7e 00 90 stw r3,144(r30)
return 0;
}
ffc1e5dc: 39 61 00 50 addi r11,r1,80
ffc1e5e0: 7e 63 9b 78 mr r3,r19
ffc1e5e4: 4b fe 44 e4 b ffc02ac8 <_restgpr_19_x>
ffc0feac <rtems_rfs_format>:
return rc;
}
int
rtems_rfs_format (const char* name, const rtems_rfs_format_config* config)
{
ffc0feac: 94 21 fe d0 stwu r1,-304(r1)
ffc0feb0: 7c 08 02 a6 mflr r0
ffc0feb4: 90 01 01 34 stw r0,308(r1)
rtems_rfs_file_system fs;
int group;
int rc;
if (config->verbose)
ffc0feb8: 88 04 00 15 lbz r0,21(r4)
return rc;
}
int
rtems_rfs_format (const char* name, const rtems_rfs_format_config* config)
{
ffc0febc: bd e1 00 ec stmw r15,236(r1)
ffc0fec0: 7c 7a 1b 78 mr r26,r3
rtems_rfs_file_system fs;
int group;
int rc;
if (config->verbose)
ffc0fec4: 2f 80 00 00 cmpwi cr7,r0,0
return rc;
}
int
rtems_rfs_format (const char* name, const rtems_rfs_format_config* config)
{
ffc0fec8: 7c 9c 23 78 mr r28,r4
rtems_rfs_file_system fs;
int group;
int rc;
if (config->verbose)
ffc0fecc: 41 be 00 18 beq+ cr7,ffc0fee4 <rtems_rfs_format+0x38> <== ALWAYS TAKEN
printf ("rtems-rfs: format: %s\n", name);
ffc0fed0: 3c 60 ff c3 lis r3,-61 <== NOT EXECUTED
ffc0fed4: 38 63 2a 24 addi r3,r3,10788 <== NOT EXECUTED
ffc0fed8: 7f 44 d3 78 mr r4,r26 <== NOT EXECUTED
ffc0fedc: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc0fee0: 48 01 2c 09 bl ffc22ae8 <printf> <== NOT EXECUTED
memset (&fs, 0, sizeof (rtems_rfs_file_system));
ffc0fee4: 38 80 00 00 li r4,0
ffc0fee8: 38 a0 00 80 li r5,128
ffc0feec: 38 61 00 5c addi r3,r1,92
ffc0fef0: 48 01 2a 69 bl ffc22958 <memset>
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
ffc0fef4: 7c 29 0b 78 mr r9,r1
ffc0fef8: 38 01 00 a0 addi r0,r1,160
ffc0fefc: 94 09 00 9c stwu r0,156(r9)
ffc0ff00: 38 01 00 b0 addi r0,r1,176
fs.flags = RTEMS_RFS_FS_NO_LOCAL_CACHE;
/*
* Open the buffer interface.
*/
rc = rtems_rfs_buffer_open (name, &fs);
ffc0ff04: 7f 43 d3 78 mr r3,r26
head->previous = NULL;
tail->previous = head;
ffc0ff08: 91 21 00 a4 stw r9,164(r1)
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
ffc0ff0c: 7c 29 0b 78 mr r9,r1
ffc0ff10: 38 81 00 5c addi r4,r1,92
ffc0ff14: 94 09 00 ac stwu r0,172(r9)
ffc0ff18: 38 01 00 c0 addi r0,r1,192
head->previous = NULL;
tail->previous = head;
ffc0ff1c: 91 21 00 b4 stw r9,180(r1)
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
ffc0ff20: 7c 29 0b 78 mr r9,r1
ffc0ff24: 94 09 00 bc stwu r0,188(r9)
ffc0ff28: 38 01 00 d0 addi r0,r1,208
head->previous = NULL;
tail->previous = head;
ffc0ff2c: 91 21 00 c4 stw r9,196(r1)
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
ffc0ff30: 7c 29 0b 78 mr r9,r1
ffc0ff34: 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;
ffc0ff38: 38 00 00 05 li r0,5
ffc0ff3c: 90 01 00 98 stw r0,152(r1)
fs.release_count = 0;
fs.release_modified_count = 0;
fs.flags = RTEMS_RFS_FS_NO_LOCAL_CACHE;
ffc0ff40: 38 00 00 02 li r0,2
head->previous = NULL;
tail->previous = head;
ffc0ff44: 91 21 00 d4 stw r9,212(r1)
ffc0ff48: 90 01 00 5c stw r0,92(r1)
/*
* Open the buffer interface.
*/
rc = rtems_rfs_buffer_open (name, &fs);
ffc0ff4c: 48 00 c5 45 bl ffc1c490 <rtems_rfs_buffer_open>
if (rc > 0)
ffc0ff50: 7c 7f 1b 79 mr. r31,r3
ffc0ff54: 40 a1 00 18 ble+ ffc0ff6c <rtems_rfs_format+0xc0> <== ALWAYS TAKEN
{
printf ("rtems-rfs: format: buffer open failed: %d: %s\n",
ffc0ff58: 48 01 38 fd bl ffc23854 <strerror> <== NOT EXECUTED
ffc0ff5c: 7c 65 1b 78 mr r5,r3 <== NOT EXECUTED
ffc0ff60: 3c 60 ff c3 lis r3,-61 <== NOT EXECUTED
ffc0ff64: 38 63 2a 3b addi r3,r3,10811 <== NOT EXECUTED
ffc0ff68: 48 00 0b 1c b ffc10a84 <rtems_rfs_format+0xbd8> <== NOT EXECUTED
}
/*
* Check the media.
*/
if (rtems_rfs_fs_media_block_size (&fs) == 0)
ffc0ff6c: 81 21 00 68 lwz r9,104(r1)
ffc0ff70: 80 09 00 24 lwz r0,36(r9)
ffc0ff74: 2f 80 00 00 cmpwi cr7,r0,0
ffc0ff78: 40 be 00 14 bne+ cr7,ffc0ff8c <rtems_rfs_format+0xe0> <== ALWAYS TAKEN
{
printf ("rtems-rfs: media block is invalid: %" PRIu32 "\n",
ffc0ff7c: 3c 60 ff c3 lis r3,-61 <== NOT EXECUTED
ffc0ff80: 38 63 2a 6a addi r3,r3,10858 <== NOT EXECUTED
ffc0ff84: 38 80 00 00 li r4,0 <== NOT EXECUTED
ffc0ff88: 48 00 05 78 b ffc10500 <rtems_rfs_format+0x654> <== NOT EXECUTED
static bool
rtems_rfs_check_config (rtems_rfs_file_system* fs,
const rtems_rfs_format_config* config)
{
fs->block_size = config->block_size;
ffc0ff8c: 80 1c 00 00 lwz r0,0(r28)
if (!fs->block_size)
ffc0ff90: 2f 80 00 00 cmpwi cr7,r0,0
static bool
rtems_rfs_check_config (rtems_rfs_file_system* fs,
const rtems_rfs_format_config* config)
{
fs->block_size = config->block_size;
ffc0ff94: 90 01 00 64 stw r0,100(r1)
if (!fs->block_size)
ffc0ff98: 40 be 00 94 bne+ cr7,ffc1002c <rtems_rfs_format+0x180> <== ALWAYS TAKEN
{
uint64_t total_size = rtems_rfs_fs_media_size (fs);
ffc0ff9c: 38 61 00 5c addi r3,r1,92 <== NOT EXECUTED
ffc0ffa0: 48 00 e9 9d bl ffc1e93c <rtems_rfs_fs_media_size> <== NOT EXECUTED
if (total_size >= GIGS (1))
ffc0ffa4: 2c 03 00 00 cmpwi r3,0 <== NOT EXECUTED
ffc0ffa8: 40 82 00 14 bne- ffc0ffbc <rtems_rfs_format+0x110> <== NOT EXECUTED
ffc0ffac: 3c 00 00 0f lis r0,15 <== NOT EXECUTED
ffc0ffb0: 60 00 ff ff ori r0,r0,65535 <== NOT EXECUTED
ffc0ffb4: 7f 84 00 40 cmplw cr7,r4,r0 <== NOT EXECUTED
ffc0ffb8: 40 9d 00 4c ble- cr7,ffc10004 <rtems_rfs_format+0x158> <== NOT EXECUTED
{
uint32_t gigs = (total_size + GIGS (1)) / GIGS (1);
ffc0ffbc: 3c 04 00 10 addis r0,r4,16 <== NOT EXECUTED
int b;
for (b = 31; b > 0; b--)
ffc0ffc0: 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);
ffc0ffc4: 7c 84 00 10 subfc r4,r4,r0 <== NOT EXECUTED
ffc0ffc8: 7c 84 21 10 subfe r4,r4,r4 <== NOT EXECUTED
int b;
for (b = 31; b > 0; b--)
if ((gigs & (1 << b)) != 0)
ffc0ffcc: 7d 29 03 a6 mtctr r9 <== 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);
ffc0ffd0: 7c 84 18 50 subf r4,r4,r3 <== NOT EXECUTED
ffc0ffd4: 54 84 60 26 rlwinm r4,r4,12,0,19 <== NOT EXECUTED
ffc0ffd8: 54 00 65 3e rlwinm r0,r0,12,20,31 <== NOT EXECUTED
ffc0ffdc: 7c 84 03 78 or r4,r4,r0 <== NOT EXECUTED
int b;
for (b = 31; b > 0; b--)
if ((gigs & (1 << b)) != 0)
ffc0ffe0: 39 60 00 01 li r11,1 <== NOT EXECUTED
ffc0ffe4: 7d 60 48 30 slw r0,r11,r9 <== NOT EXECUTED
ffc0ffe8: 7c 0a 20 39 and. r10,r0,r4 <== NOT EXECUTED
ffc0ffec: 40 82 00 0c bne- ffc0fff8 <rtems_rfs_format+0x14c> <== NOT EXECUTED
if (total_size >= GIGS (1))
{
uint32_t gigs = (total_size + GIGS (1)) / GIGS (1);
int b;
for (b = 31; b > 0; b--)
ffc0fff0: 39 29 ff ff addi r9,r9,-1 <== NOT EXECUTED
ffc0fff4: 42 00 ff f0 bdnz+ ffc0ffe4 <rtems_rfs_format+0x138> <== NOT EXECUTED
if ((gigs & (1 << b)) != 0)
break;
fs->block_size = 1 << b;
ffc0fff8: 38 00 00 01 li r0,1 <== NOT EXECUTED
ffc0fffc: 7c 09 48 30 slw r9,r0,r9 <== NOT EXECUTED
ffc10000: 91 21 00 64 stw r9,100(r1) <== NOT EXECUTED
}
if (fs->block_size < 512)
ffc10004: 80 01 00 64 lwz r0,100(r1) <== NOT EXECUTED
ffc10008: 2b 80 01 ff cmplwi cr7,r0,511 <== NOT EXECUTED
ffc1000c: 41 9d 00 0c bgt- cr7,ffc10018 <rtems_rfs_format+0x16c> <== NOT EXECUTED
fs->block_size = 512;
ffc10010: 38 00 02 00 li r0,512 <== NOT EXECUTED
ffc10014: 90 01 00 64 stw r0,100(r1) <== NOT EXECUTED
if (fs->block_size > (4 * 1024))
ffc10018: 80 01 00 64 lwz r0,100(r1) <== NOT EXECUTED
ffc1001c: 2b 80 10 00 cmplwi cr7,r0,4096 <== NOT EXECUTED
ffc10020: 40 9d 00 0c ble- cr7,ffc1002c <rtems_rfs_format+0x180> <== NOT EXECUTED
fs->block_size = (4 * 1024);
ffc10024: 38 00 10 00 li r0,4096 <== NOT EXECUTED
ffc10028: 90 01 00 64 stw r0,100(r1) <== NOT EXECUTED
}
if ((fs->block_size % rtems_rfs_fs_media_block_size (fs)) != 0)
ffc1002c: 81 21 00 68 lwz r9,104(r1)
ffc10030: 80 81 00 64 lwz r4,100(r1)
ffc10034: 80 a9 00 24 lwz r5,36(r9)
ffc10038: 7c 04 2b 96 divwu r0,r4,r5
ffc1003c: 7c 00 29 d6 mullw r0,r0,r5
ffc10040: 7f 84 00 00 cmpw cr7,r4,r0
ffc10044: 41 be 00 10 beq+ cr7,ffc10054 <rtems_rfs_format+0x1a8> <== ALWAYS TAKEN
{
printf ("block size (%zd) is not a multiple of media block size (%" PRId32 ")\n",
ffc10048: 3c 60 ff c3 lis r3,-61 <== NOT EXECUTED
ffc1004c: 38 63 2a 92 addi r3,r3,10898 <== NOT EXECUTED
ffc10050: 48 00 0a 38 b ffc10a88 <rtems_rfs_format+0xbdc> <== NOT EXECUTED
fs->block_size, rtems_rfs_fs_media_block_size (fs));
return false;
}
fs->group_blocks = config->group_blocks;
ffc10054: 80 1c 00 04 lwz r0,4(r28)
ffc10058: 54 84 18 38 rlwinm r4,r4,3,0,28
if (!fs->group_blocks)
ffc1005c: 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;
ffc10060: 90 01 00 80 stw r0,128(r1)
if (!fs->group_blocks)
ffc10064: 40 9e 00 08 bne- cr7,ffc1006c <rtems_rfs_format+0x1c0> <== 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);
ffc10068: 90 81 00 80 stw r4,128(r1)
}
if (fs->group_blocks > rtems_rfs_bitmap_numof_bits (fs->block_size))
ffc1006c: 80 01 00 80 lwz r0,128(r1)
ffc10070: 7f 80 20 40 cmplw cr7,r0,r4
ffc10074: 40 bd 00 10 ble+ cr7,ffc10084 <rtems_rfs_format+0x1d8> <== ALWAYS TAKEN
{
printf ("group block count is higher than bits in block\n");
ffc10078: 3c 60 ff c3 lis r3,-61 <== NOT EXECUTED
ffc1007c: 38 63 2a d0 addi r3,r3,10960 <== NOT EXECUTED
ffc10080: 48 00 04 4c b ffc104cc <rtems_rfs_format+0x620> <== NOT EXECUTED
return false;
}
fs->blocks = rtems_rfs_fs_media_size (fs) / fs->block_size;
ffc10084: 38 61 00 5c addi r3,r1,92
ffc10088: 48 00 e8 b5 bl ffc1e93c <rtems_rfs_fs_media_size>
ffc1008c: 83 e1 00 64 lwz r31,100(r1)
ffc10090: 38 a0 00 00 li r5,0
ffc10094: 7f e6 fb 78 mr r6,r31
ffc10098: 48 01 ff a9 bl ffc30040 <__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));
ffc1009c: 57 fe 18 38 rlwinm r30,r31,3,0,28
{
printf ("group block count is higher than bits in block\n");
return false;
}
fs->blocks = rtems_rfs_fs_media_size (fs) / fs->block_size;
ffc100a0: 90 81 00 60 stw r4,96(r1)
/*
* 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),
ffc100a4: 7c 83 23 78 mr r3,r4
{
printf ("group block count is higher than bits in block\n");
return false;
}
fs->blocks = rtems_rfs_fs_media_size (fs) / fs->block_size;
ffc100a8: 7c 9d 23 78 mr r29,r4
/*
* 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),
ffc100ac: 7f c4 f3 78 mr r4,r30
ffc100b0: 4b ff fd 89 bl ffc0fe38 <rtems_rfs_rup_quotient>
rtems_rfs_bits_per_block (fs));
fs->group_inodes = config->group_inodes;
ffc100b4: 80 1c 00 08 lwz r0,8(r28)
/*
* 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),
ffc100b8: 7c 64 1b 78 mr r4,r3
ffc100bc: 90 61 00 7c stw r3,124(r1)
rtems_rfs_bits_per_block (fs));
fs->group_inodes = config->group_inodes;
if (!fs->group_inodes)
ffc100c0: 2f 80 00 00 cmpwi cr7,r0,0
* 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;
ffc100c4: 90 01 00 84 stw r0,132(r1)
if (!fs->group_inodes)
ffc100c8: 40 9e 00 38 bne- cr7,ffc10100 <rtems_rfs_format+0x254> <== NEVER TAKEN
int inode_overhead = RTEMS_RFS_INODE_OVERHEAD_PERCENTAGE;
/*
* The number of inodes per group is set as a percentage.
*/
if (config->inode_overhead)
ffc100cc: 80 1c 00 0c lwz r0,12(r28)
ffc100d0: 2f 80 00 00 cmpwi cr7,r0,0
ffc100d4: 40 9e 00 08 bne- cr7,ffc100dc <rtems_rfs_format+0x230> <== NEVER TAKEN
rtems_rfs_bits_per_block (fs));
fs->group_inodes = config->group_inodes;
if (!fs->group_inodes)
{
int inode_overhead = RTEMS_RFS_INODE_OVERHEAD_PERCENTAGE;
ffc100d8: 38 00 00 01 li r0,1
static int
rtems_rfs_inodes_from_percent (rtems_rfs_file_system* fs,
int percentage)
{
int blocks;
blocks = ((rtems_rfs_fs_blocks (fs) -
ffc100dc: 3b bd ff ff addi r29,r29,-1
RTEMS_RFS_SUPERBLOCK_SIZE) * percentage) / 100;
ffc100e0: 7c 00 e9 d6 mullw r0,r0,r29
blocks = rtems_rfs_rup_quotient (blocks, fs->group_count);
ffc100e4: 39 20 00 64 li r9,100
ffc100e8: 7c 60 4b 96 divwu r3,r0,r9
ffc100ec: 4b ff fd 4d bl ffc0fe38 <rtems_rfs_rup_quotient>
return blocks * (rtems_rfs_fs_block_size (fs) / RTEMS_RFS_INODE_SIZE);
ffc100f0: 38 00 00 38 li r0,56
ffc100f4: 7c 1f 03 96 divwu r0,r31,r0
ffc100f8: 7c 03 01 d6 mullw r0,r3,r0
* The number of inodes per group is set as a percentage.
*/
if (config->inode_overhead)
inode_overhead = config->inode_overhead;
fs->group_inodes = rtems_rfs_inodes_from_percent (fs, inode_overhead);
ffc100fc: 90 01 00 84 stw r0,132(r1)
}
/*
* 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;
ffc10100: 38 00 00 38 li r0,56
fs->group_inodes =
rtems_rfs_rup_quotient (fs->group_inodes,
ffc10104: 80 61 00 84 lwz r3,132(r1)
}
/*
* 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;
ffc10108: 7f ff 03 96 divwu r31,r31,r0
fs->group_inodes =
rtems_rfs_rup_quotient (fs->group_inodes,
ffc1010c: 7f e4 fb 78 mr r4,r31
}
/*
* 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;
ffc10110: 93 e1 00 88 stw r31,136(r1)
fs->group_inodes =
rtems_rfs_rup_quotient (fs->group_inodes,
ffc10114: 4b ff fd 25 bl ffc0fe38 <rtems_rfs_rup_quotient>
fs->inodes_per_block) * fs->inodes_per_block;
ffc10118: 7f e3 f9 d6 mullw r31,r3,r31
if (fs->group_inodes > rtems_rfs_bitmap_numof_bits (fs->block_size))
ffc1011c: 7f 9f f0 40 cmplw cr7,r31,r30
/*
* 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 =
ffc10120: 93 e1 00 84 stw r31,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))
ffc10124: 40 9d 00 08 ble- cr7,ffc1012c <rtems_rfs_format+0x280> <== ALWAYS TAKEN
fs->group_inodes = rtems_rfs_bitmap_numof_bits (fs->block_size);
ffc10128: 93 c1 00 84 stw r30,132(r1) <== NOT EXECUTED
fs->max_name_length = config->max_name_length;
ffc1012c: 80 1c 00 10 lwz r0,16(r28)
if (!fs->max_name_length)
ffc10130: 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;
ffc10134: 90 01 00 74 stw r0,116(r1)
if (!fs->max_name_length)
ffc10138: 40 9e 09 6c bne- cr7,ffc10aa4 <rtems_rfs_format+0xbf8> <== NEVER TAKEN
{
fs->max_name_length = 512;
ffc1013c: 38 00 02 00 li r0,512
ffc10140: 90 01 00 74 stw r0,116(r1)
ffc10144: 48 00 09 60 b ffc10aa4 <rtems_rfs_format+0xbf8>
if (!rtems_rfs_check_config (&fs, config))
return -1;
if (config->verbose)
{
printf ("rtems-rfs: format: media size = %" PRIu64 "\n",
ffc10148: 38 61 00 5c addi r3,r1,92 <== NOT EXECUTED
ffc1014c: 48 00 e7 f1 bl ffc1e93c <rtems_rfs_fs_media_size> <== NOT EXECUTED
ffc10150: 7c 65 1b 78 mr r5,r3 <== NOT EXECUTED
ffc10154: 3c 60 ff c3 lis r3,-61 <== NOT EXECUTED
ffc10158: 7c 86 23 78 mr r6,r4 <== NOT EXECUTED
ffc1015c: 38 63 2a ff addi r3,r3,11007 <== NOT EXECUTED
ffc10160: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc10164: 48 01 29 85 bl ffc22ae8 <printf> <== NOT EXECUTED
rtems_rfs_fs_media_size (&fs));
printf ("rtems-rfs: format: media blocks = %" PRIu32 "\n",
ffc10168: 81 21 00 68 lwz r9,104(r1) <== NOT EXECUTED
ffc1016c: 3c 60 ff c3 lis r3,-61 <== NOT EXECUTED
ffc10170: 80 89 00 1c lwz r4,28(r9) <== NOT EXECUTED
ffc10174: 38 63 2b 25 addi r3,r3,11045 <== NOT EXECUTED
ffc10178: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc1017c: 48 01 29 6d bl ffc22ae8 <printf> <== NOT EXECUTED
rtems_rfs_fs_media_blocks (&fs));
printf ("rtems-rfs: format: media block size = %" PRIu32 "\n",
ffc10180: 81 21 00 68 lwz r9,104(r1) <== NOT EXECUTED
ffc10184: 3c 60 ff c3 lis r3,-61 <== NOT EXECUTED
ffc10188: 80 89 00 24 lwz r4,36(r9) <== NOT EXECUTED
ffc1018c: 38 63 2b 4c addi r3,r3,11084 <== NOT EXECUTED
ffc10190: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc10194: 48 01 29 55 bl ffc22ae8 <printf> <== NOT EXECUTED
rtems_rfs_fs_media_block_size (&fs));
printf ("rtems-rfs: format: size = %" PRIu64 "\n",
ffc10198: 38 61 00 5c addi r3,r1,92 <== NOT EXECUTED
ffc1019c: 48 00 e7 8d bl ffc1e928 <rtems_rfs_fs_size> <== NOT EXECUTED
ffc101a0: 7c 65 1b 78 mr r5,r3 <== NOT EXECUTED
ffc101a4: 3c 60 ff c3 lis r3,-61 <== NOT EXECUTED
ffc101a8: 7c 86 23 78 mr r6,r4 <== NOT EXECUTED
ffc101ac: 38 63 2b 77 addi r3,r3,11127 <== NOT EXECUTED
ffc101b0: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc101b4: 48 01 29 35 bl ffc22ae8 <printf> <== NOT EXECUTED
rtems_rfs_fs_size (&fs));
printf ("rtems-rfs: format: blocks = %zu\n",
ffc101b8: 80 81 00 60 lwz r4,96(r1) <== NOT EXECUTED
ffc101bc: 3c 60 ff c3 lis r3,-61 <== NOT EXECUTED
ffc101c0: 38 63 2b 97 addi r3,r3,11159 <== NOT EXECUTED
ffc101c4: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc101c8: 48 01 29 21 bl ffc22ae8 <printf> <== NOT EXECUTED
rtems_rfs_fs_blocks (&fs));
printf ("rtems-rfs: format: block size = %zu\n",
ffc101cc: 80 81 00 64 lwz r4,100(r1) <== NOT EXECUTED
ffc101d0: 3c 60 ff c3 lis r3,-61 <== NOT EXECUTED
ffc101d4: 38 63 2b b8 addi r3,r3,11192 <== NOT EXECUTED
ffc101d8: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc101dc: 48 01 29 0d bl ffc22ae8 <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));
ffc101e0: 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",
ffc101e4: 3c 60 ff c3 lis r3,-61 <== NOT EXECUTED
ffc101e8: 54 84 18 38 rlwinm r4,r4,3,0,28 <== NOT EXECUTED
ffc101ec: 38 63 2b dd addi r3,r3,11229 <== NOT EXECUTED
ffc101f0: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc101f4: 48 01 28 f5 bl ffc22ae8 <printf> <== NOT EXECUTED
rtems_rfs_bits_per_block (&fs));
printf ("rtems-rfs: format: inode size = %zu\n", RTEMS_RFS_INODE_SIZE);
ffc101f8: 3c 60 ff c3 lis r3,-61 <== NOT EXECUTED
ffc101fc: 38 80 00 38 li r4,56 <== NOT EXECUTED
ffc10200: 38 63 2c 05 addi r3,r3,11269 <== NOT EXECUTED
ffc10204: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc10208: 48 01 28 e1 bl ffc22ae8 <printf> <== NOT EXECUTED
printf ("rtems-rfs: format: inodes = %zu (%d.%d%%)\n",
ffc1020c: 80 01 00 84 lwz r0,132(r1) <== NOT EXECUTED
ffc10210: 83 e1 00 7c lwz r31,124(r1) <== NOT EXECUTED
fs.group_inodes * fs.group_count,
rtems_rfs_inode_overhead (&fs) / 10,
ffc10214: 38 61 00 5c addi r3,r1,92 <== 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",
ffc10218: 7f ff 01 d6 mullw r31,r31,r0 <== NOT EXECUTED
fs.group_inodes * fs.group_count,
rtems_rfs_inode_overhead (&fs) / 10,
ffc1021c: 4b ff fc 3d bl ffc0fe58 <rtems_rfs_inode_overhead> <== 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",
ffc10220: 38 a0 00 0a li r5,10 <== NOT EXECUTED
ffc10224: 7c a3 2b d6 divw r5,r3,r5 <== NOT EXECUTED
ffc10228: 1c c5 00 0a mulli r6,r5,10 <== NOT EXECUTED
fs.group_inodes * fs.group_count,
rtems_rfs_inode_overhead (&fs) / 10,
ffc1022c: 7c 60 1b 78 mr r0,r3 <== 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",
ffc10230: 3c 60 ff c3 lis r3,-61 <== NOT EXECUTED
ffc10234: 7c c6 00 50 subf r6,r6,r0 <== NOT EXECUTED
ffc10238: 7f e4 fb 78 mr r4,r31 <== NOT EXECUTED
ffc1023c: 38 63 2c 2a addi r3,r3,11306 <== NOT EXECUTED
ffc10240: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc10244: 48 01 28 a5 bl ffc22ae8 <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);
ffc10248: 80 81 00 7c lwz r4,124(r1) <== NOT EXECUTED
ffc1024c: 3c 60 ff c3 lis r3,-61 <== NOT EXECUTED
ffc10250: 38 63 2c 55 addi r3,r3,11349 <== NOT EXECUTED
ffc10254: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc10258: 48 01 28 91 bl ffc22ae8 <printf> <== NOT EXECUTED
printf ("rtems-rfs: format: group blocks = %zu\n", fs.group_blocks);
ffc1025c: 80 81 00 80 lwz r4,128(r1) <== NOT EXECUTED
ffc10260: 3c 60 ff c3 lis r3,-61 <== NOT EXECUTED
ffc10264: 38 63 2c 75 addi r3,r3,11381 <== NOT EXECUTED
ffc10268: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc1026c: 48 01 28 7d bl ffc22ae8 <printf> <== NOT EXECUTED
printf ("rtems-rfs: format: group inodes = %zu\n", fs.group_inodes);
ffc10270: 3c 60 ff c3 lis r3,-61 <== NOT EXECUTED
ffc10274: 80 81 00 84 lwz r4,132(r1) <== NOT EXECUTED
ffc10278: 38 63 2c 9c addi r3,r3,11420 <== NOT EXECUTED
ffc1027c: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc10280: 48 01 28 69 bl ffc22ae8 <printf> <== NOT EXECUTED
}
rc = rtems_rfs_buffer_setblksize (&fs, rtems_rfs_fs_block_size (&fs));
ffc10284: 3b a1 00 5c addi r29,r1,92
ffc10288: 80 81 00 64 lwz r4,100(r1)
ffc1028c: 7f a3 eb 78 mr r3,r29
ffc10290: 48 00 c4 71 bl ffc1c700 <rtems_rfs_buffer_setblksize>
if (rc > 0)
ffc10294: 7c 7f 1b 79 mr. r31,r3
ffc10298: 40 a1 00 18 ble+ ffc102b0 <rtems_rfs_format+0x404> <== ALWAYS TAKEN
{
printf ("rtems-rfs: format: setting block size failed: %d: %s\n",
ffc1029c: 48 01 35 b9 bl ffc23854 <strerror> <== NOT EXECUTED
ffc102a0: 7c 65 1b 78 mr r5,r3 <== NOT EXECUTED
ffc102a4: 3c 60 ff c3 lis r3,-61 <== NOT EXECUTED
ffc102a8: 38 63 2c c3 addi r3,r3,11459 <== NOT EXECUTED
ffc102ac: 48 00 07 d8 b ffc10a84 <rtems_rfs_format+0xbd8> <== NOT EXECUTED
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);
ffc102b0: 3b c1 00 10 addi r30,r1,16
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
ffc102b4: 38 00 00 00 li r0,0
handle->bnum = 0;
ffc102b8: 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;
ffc102bc: 98 01 00 10 stb r0,16(r1)
ffc102c0: 7f a3 eb 78 mr r3,r29
ffc102c4: 7f c4 f3 78 mr r4,r30
handle->bnum = 0;
ffc102c8: 93 e1 00 14 stw r31,20(r1)
ffc102cc: 38 a0 00 00 li r5,0
ffc102d0: 38 c0 00 00 li r6,0
handle->buffer = NULL;
ffc102d4: 93 e1 00 18 stw r31,24(r1)
ffc102d8: 48 00 bf 11 bl ffc1c1e8 <rtems_rfs_buffer_handle_request>
if (rc > 0)
ffc102dc: 7c 7b 1b 79 mr. r27,r3
ffc102e0: 40 81 00 2c ble- ffc1030c <rtems_rfs_format+0x460> <== ALWAYS TAKEN
{
rtems_rfs_buffer_handle_close (fs, &handle);
ffc102e4: 7f c4 f3 78 mr r4,r30 <== NOT EXECUTED
ffc102e8: 7f a3 eb 78 mr r3,r29 <== NOT EXECUTED
ffc102ec: 4b ff fb 11 bl ffc0fdfc <rtems_rfs_buffer_handle_close><== NOT EXECUTED
printf ("rtems-rfs: write-superblock: request failed: %d: %s\n",
ffc102f0: 7f 63 db 78 mr r3,r27 <== NOT EXECUTED
ffc102f4: 48 01 35 61 bl ffc23854 <strerror> <== NOT EXECUTED
ffc102f8: 7f 64 db 78 mr r4,r27 <== NOT EXECUTED
ffc102fc: 7c 65 1b 78 mr r5,r3 <== NOT EXECUTED
ffc10300: 3c 60 ff c3 lis r3,-61 <== NOT EXECUTED
ffc10304: 38 63 2c f9 addi r3,r3,11513 <== NOT EXECUTED
ffc10308: 48 00 01 b4 b ffc104bc <rtems_rfs_format+0x610> <== NOT EXECUTED
rc, strerror (rc));
return false;
}
sb = rtems_rfs_buffer_data (&handle);
ffc1030c: 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));
ffc10310: 38 80 00 ff li r4,255
ffc10314: 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);
ffc10318: 83 69 00 24 lwz r27,36(r9)
#define write_sb(_o, _d) rtems_rfs_write_u32(sb + (_o), _d)
memset (sb, 0xff, rtems_rfs_fs_block_size (fs));
ffc1031c: 7f 63 db 78 mr r3,r27
ffc10320: 48 01 26 39 bl ffc22958 <memset>
write_sb (RTEMS_RFS_SB_OFFSET_MAGIC, RTEMS_RFS_SB_MAGIC);
ffc10324: 38 00 00 28 li r0,40
ffc10328: 98 1b 00 00 stb r0,0(r27)
ffc1032c: 38 00 00 09 li r0,9
ffc10330: 39 20 00 01 li r9,1
ffc10334: 98 1b 00 01 stb r0,1(r27)
ffc10338: 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);
ffc1033c: 7f c4 f3 78 mr r4,r30
#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);
ffc10340: 99 3b 00 03 stb r9,3(r27)
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);
ffc10344: 7f a3 eb 78 mr r3,r29
#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);
write_sb (RTEMS_RFS_SB_OFFSET_VERSION, RTEMS_RFS_VERSION);
ffc10348: 9b fb 00 04 stb r31,4(r27)
ffc1034c: 9b fb 00 05 stb r31,5(r27)
ffc10350: 9b fb 00 06 stb r31,6(r27)
ffc10354: 9b fb 00 07 stb r31,7(r27)
#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);
ffc10358: 98 1b 00 02 stb r0,2(r27)
write_sb (RTEMS_RFS_SB_OFFSET_VERSION, RTEMS_RFS_VERSION);
write_sb (RTEMS_RFS_SB_OFFSET_BLOCKS, rtems_rfs_fs_blocks (fs));
ffc1035c: 80 01 00 60 lwz r0,96(r1)
ffc10360: 54 0b 46 3e rlwinm r11,r0,8,24,31
ffc10364: 98 1b 00 0f stb r0,15(r27)
ffc10368: 99 7b 00 0c stb r11,12(r27)
ffc1036c: 54 0b 84 3e rlwinm r11,r0,16,16,31
ffc10370: 99 7b 00 0d stb r11,13(r27)
ffc10374: 54 0b c2 3e rlwinm r11,r0,24,8,31
write_sb (RTEMS_RFS_SB_OFFSET_BLOCK_SIZE, rtems_rfs_fs_block_size (fs));
ffc10378: 88 01 00 64 lbz 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));
ffc1037c: 99 7b 00 0e stb r11,14(r27)
write_sb (RTEMS_RFS_SB_OFFSET_BLOCK_SIZE, rtems_rfs_fs_block_size (fs));
ffc10380: 98 1b 00 08 stb r0,8(r27)
ffc10384: a0 01 00 64 lhz r0,100(r1)
ffc10388: 98 1b 00 09 stb r0,9(r27)
ffc1038c: 80 01 00 64 lwz r0,100(r1)
ffc10390: 54 00 c2 3e rlwinm r0,r0,24,8,31
ffc10394: 98 1b 00 0a stb r0,10(r27)
ffc10398: 80 01 00 64 lwz r0,100(r1)
ffc1039c: 98 1b 00 0b stb r0,11(r27)
write_sb (RTEMS_RFS_SB_OFFSET_BAD_BLOCKS, fs->bad_blocks);
ffc103a0: 88 01 00 70 lbz r0,112(r1)
ffc103a4: 98 1b 00 10 stb r0,16(r27)
ffc103a8: a0 01 00 70 lhz r0,112(r1)
ffc103ac: 98 1b 00 11 stb r0,17(r27)
ffc103b0: 80 01 00 70 lwz r0,112(r1)
ffc103b4: 54 00 c2 3e rlwinm r0,r0,24,8,31
ffc103b8: 98 1b 00 12 stb r0,18(r27)
ffc103bc: 80 01 00 70 lwz r0,112(r1)
ffc103c0: 98 1b 00 13 stb r0,19(r27)
write_sb (RTEMS_RFS_SB_OFFSET_MAX_NAME_LENGTH, fs->max_name_length);
ffc103c4: 88 01 00 74 lbz r0,116(r1)
ffc103c8: 98 1b 00 14 stb r0,20(r27)
ffc103cc: a0 01 00 74 lhz r0,116(r1)
ffc103d0: 98 1b 00 15 stb r0,21(r27)
ffc103d4: 80 01 00 74 lwz r0,116(r1)
ffc103d8: 54 00 c2 3e rlwinm r0,r0,24,8,31
ffc103dc: 98 1b 00 16 stb r0,22(r27)
ffc103e0: 80 01 00 74 lwz r0,116(r1)
ffc103e4: 98 1b 00 17 stb r0,23(r27)
write_sb (RTEMS_RFS_SB_OFFSET_GROUPS, fs->group_count);
ffc103e8: 88 01 00 7c lbz r0,124(r1)
ffc103ec: 98 1b 00 18 stb r0,24(r27)
ffc103f0: a0 01 00 7c lhz r0,124(r1)
ffc103f4: 98 1b 00 19 stb r0,25(r27)
ffc103f8: 80 01 00 7c lwz r0,124(r1)
ffc103fc: 54 00 c2 3e rlwinm r0,r0,24,8,31
ffc10400: 98 1b 00 1a stb r0,26(r27)
ffc10404: 80 01 00 7c lwz r0,124(r1)
ffc10408: 98 1b 00 1b stb r0,27(r27)
write_sb (RTEMS_RFS_SB_OFFSET_GROUP_BLOCKS, fs->group_blocks);
ffc1040c: 88 01 00 80 lbz r0,128(r1)
ffc10410: 98 1b 00 1c stb r0,28(r27)
ffc10414: a0 01 00 80 lhz r0,128(r1)
ffc10418: 98 1b 00 1d stb r0,29(r27)
ffc1041c: 80 01 00 80 lwz r0,128(r1)
ffc10420: 54 00 c2 3e rlwinm r0,r0,24,8,31
ffc10424: 98 1b 00 1e stb r0,30(r27)
ffc10428: 80 01 00 80 lwz r0,128(r1)
ffc1042c: 98 1b 00 1f stb r0,31(r27)
write_sb (RTEMS_RFS_SB_OFFSET_GROUP_INODES, fs->group_inodes);
ffc10430: 88 01 00 84 lbz r0,132(r1)
ffc10434: 98 1b 00 20 stb r0,32(r27)
ffc10438: a0 01 00 84 lhz r0,132(r1)
ffc1043c: 98 1b 00 21 stb r0,33(r27)
ffc10440: 80 01 00 84 lwz r0,132(r1)
ffc10444: 54 00 c2 3e rlwinm r0,r0,24,8,31
ffc10448: 98 1b 00 22 stb r0,34(r27)
ffc1044c: 80 01 00 84 lwz r0,132(r1)
write_sb (RTEMS_RFS_SB_OFFSET_INODE_SIZE, RTEMS_RFS_INODE_SIZE);
ffc10450: 9b fb 00 24 stb r31,36(r27)
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);
ffc10454: 98 1b 00 23 stb r0,35(r27)
write_sb (RTEMS_RFS_SB_OFFSET_INODE_SIZE, RTEMS_RFS_INODE_SIZE);
ffc10458: 38 00 00 38 li r0,56
ffc1045c: 9b fb 00 25 stb r31,37(r27)
ffc10460: 9b fb 00 26 stb r31,38(r27)
ffc10464: 98 1b 00 27 stb r0,39(r27)
rtems_rfs_buffer_mark_dirty (&handle);
ffc10468: 99 21 00 10 stb r9,16(r1)
rc = rtems_rfs_buffer_handle_release (fs, &handle);
ffc1046c: 48 00 bb 9d bl ffc1c008 <rtems_rfs_buffer_handle_release>
if (rc > 0)
ffc10470: 7c 7f 1b 79 mr. r31,r3
{
rtems_rfs_buffer_handle_close (fs, &handle);
ffc10474: 7f c4 f3 78 mr r4,r30
ffc10478: 7f a3 eb 78 mr r3,r29
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);
if (rc > 0)
ffc1047c: 40 81 00 20 ble- ffc1049c <rtems_rfs_format+0x5f0> <== ALWAYS TAKEN
{
rtems_rfs_buffer_handle_close (fs, &handle);
ffc10480: 4b ff f9 7d bl ffc0fdfc <rtems_rfs_buffer_handle_close><== NOT EXECUTED
printf ("rtems-rfs: write-superblock: buffer release failed: %d: %s\n",
ffc10484: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc10488: 48 01 33 cd bl ffc23854 <strerror> <== NOT EXECUTED
ffc1048c: 7c 65 1b 78 mr r5,r3 <== NOT EXECUTED
ffc10490: 3c 60 ff c3 lis r3,-61 <== NOT EXECUTED
ffc10494: 38 63 2d 2e addi r3,r3,11566 <== NOT EXECUTED
ffc10498: 48 00 00 20 b ffc104b8 <rtems_rfs_format+0x60c> <== NOT EXECUTED
rc, strerror (rc));
return false;
}
rc = rtems_rfs_buffer_handle_close (fs, &handle);
ffc1049c: 4b ff f9 61 bl ffc0fdfc <rtems_rfs_buffer_handle_close>
if (rc > 0)
ffc104a0: 7c 7f 1b 79 mr. r31,r3
ffc104a4: 40 81 03 7c ble- ffc10820 <rtems_rfs_format+0x974> <== ALWAYS TAKEN
{
printf ("rtems-rfs: write-superblock: buffer handle close failed: %d: %s\n",
ffc104a8: 48 01 33 ad bl ffc23854 <strerror> <== NOT EXECUTED
ffc104ac: 7c 65 1b 78 mr r5,r3 <== NOT EXECUTED
ffc104b0: 3c 60 ff c3 lis r3,-61 <== NOT EXECUTED
ffc104b4: 38 63 2d 6a addi r3,r3,11626 <== NOT EXECUTED
ffc104b8: 7f e4 fb 78 mr r4,r31 <== NOT EXECUTED
ffc104bc: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc104c0: 48 01 26 29 bl ffc22ae8 <printf> <== NOT EXECUTED
return -1;
}
if (!rtems_rfs_write_superblock (&fs))
{
printf ("rtems-rfs: format: superblock write failed\n");
ffc104c4: 3c 60 ff c3 lis r3,-61 <== NOT EXECUTED
ffc104c8: 38 63 2d ab addi r3,r3,11691 <== NOT EXECUTED
ffc104cc: 48 01 27 d1 bl ffc22c9c <puts> <== NOT EXECUTED
ffc104d0: 48 00 05 c0 b ffc10a90 <rtems_rfs_format+0xbe4> <== NOT EXECUTED
size_t group_size;
int blocks;
int b;
int rc;
group_base = rtems_rfs_fs_block (fs, group, 0);
ffc104d4: 83 61 00 80 lwz r27,128(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,
ffc104d8: 56 f7 06 3e clrlwi r23,r23,24
int b;
int rc;
group_base = rtems_rfs_fs_block (fs, group, 0);
if (group_base > rtems_rfs_fs_blocks (fs))
ffc104dc: 80 01 00 60 lwz r0,96(r1)
size_t group_size;
int blocks;
int b;
int rc;
group_base = rtems_rfs_fs_block (fs, group, 0);
ffc104e0: 7f 1f d9 d6 mullw r24,r31,r27
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,
ffc104e4: 8a 1c 00 14 lbz r16,20(r28)
size_t group_size;
int blocks;
int b;
int rc;
group_base = rtems_rfs_fs_block (fs, group, 0);
ffc104e8: 3a b8 00 01 addi r21,r24,1
if (group_base > rtems_rfs_fs_blocks (fs))
ffc104ec: 7f 95 00 40 cmplw cr7,r21,r0
ffc104f0: 40 bd 00 1c ble+ cr7,ffc1050c <rtems_rfs_format+0x660> <== ALWAYS TAKEN
{
printf ("rtems-rfs: write-group: group %d base beyond disk limit\n",
ffc104f4: 3c 60 ff c3 lis r3,-61 <== NOT EXECUTED
ffc104f8: 38 63 2d d6 addi r3,r3,11734 <== NOT EXECUTED
ffc104fc: 7f e4 fb 78 mr r4,r31 <== NOT EXECUTED
ffc10500: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc10504: 48 01 25 e5 bl ffc22ae8 <printf> <== NOT EXECUTED
ffc10508: 48 00 05 88 b ffc10a90 <rtems_rfs_format+0xbe4> <== NOT EXECUTED
/*
* 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))
ffc1050c: 7d 35 da 14 add r9,r21,r27
ffc10510: 7f 89 00 40 cmplw cr7,r9,r0
ffc10514: 40 9d 00 08 ble- cr7,ffc1051c <rtems_rfs_format+0x670> <== NEVER TAKEN
group_size = rtems_rfs_fs_blocks (fs) - group_base;
ffc10518: 7f 75 00 50 subf r27,r21,r0
if (verbose)
ffc1051c: 2f 97 00 00 cmpwi cr7,r23,0
ffc10520: 41 be 00 1c beq+ cr7,ffc1053c <rtems_rfs_format+0x690> <== ALWAYS TAKEN
printf ("\rrtems-rfs: format: group %3d: base = %" PRId32 ", size = %zd",
ffc10524: 7e 23 8b 78 mr r3,r17 <== NOT EXECUTED
ffc10528: 7f e4 fb 78 mr r4,r31 <== NOT EXECUTED
ffc1052c: 7e a5 ab 78 mr r5,r21 <== NOT EXECUTED
ffc10530: 7f 66 db 78 mr r6,r27 <== NOT EXECUTED
ffc10534: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc10538: 48 01 25 b1 bl ffc22ae8 <printf> <== NOT EXECUTED
printf ("\nrtems-rfs: write-group: handle open failed: %d: %s\n",
rc, strerror (rc));
return false;
}
if (verbose)
ffc1053c: 2f 97 00 00 cmpwi cr7,r23,0
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
ffc10540: 9a 41 00 10 stb r18,16(r1)
handle->bnum = 0;
ffc10544: 92 c1 00 14 stw r22,20(r1)
handle->buffer = NULL;
ffc10548: 92 c1 00 18 stw r22,24(r1)
ffc1054c: 41 be 00 10 beq+ cr7,ffc1055c <rtems_rfs_format+0x6b0> <== ALWAYS TAKEN
printf (", blocks");
ffc10550: 7e 63 9b 78 mr r3,r19 <== NOT EXECUTED
ffc10554: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc10558: 48 01 25 91 bl ffc22ae8 <printf> <== NOT EXECUTED
/*
* Open the block bitmap using the new buffer.
*/
rc = rtems_rfs_bitmap_open (&bitmap, fs, &handle, group_size,
ffc1055c: 7e a7 ab 78 mr r7,r21
ffc10560: 38 61 00 1c addi r3,r1,28
ffc10564: 7f a4 eb 78 mr r4,r29
ffc10568: 7f c5 f3 78 mr r5,r30
ffc1056c: 7f 66 db 78 mr r6,r27
ffc10570: 48 00 a7 a5 bl ffc1ad14 <rtems_rfs_bitmap_open>
group_base + RTEMS_RFS_GROUP_BLOCK_BITMAP_BLOCK);
if (rc > 0)
ffc10574: 7c 75 1b 79 mr. r21,r3
ffc10578: 40 81 00 28 ble- ffc105a0 <rtems_rfs_format+0x6f4> <== ALWAYS TAKEN
{
rtems_rfs_buffer_handle_close (fs, &handle);
ffc1057c: 7f c4 f3 78 mr r4,r30 <== NOT EXECUTED
ffc10580: 7f a3 eb 78 mr r3,r29 <== NOT EXECUTED
ffc10584: 4b ff f8 79 bl ffc0fdfc <rtems_rfs_buffer_handle_close><== NOT EXECUTED
printf ("\nrtems-rfs: write-group: group %3d: open block bitmap failed: %d: %s\n",
ffc10588: 7e a3 ab 78 mr r3,r21 <== NOT EXECUTED
ffc1058c: 48 01 32 c9 bl ffc23854 <strerror> <== NOT EXECUTED
ffc10590: 7c 66 1b 78 mr r6,r3 <== NOT EXECUTED
ffc10594: 3c 60 ff c3 lis r3,-61 <== NOT EXECUTED
ffc10598: 38 63 2e 4e addi r3,r3,11854 <== NOT EXECUTED
ffc1059c: 48 00 00 50 b ffc105ec <rtems_rfs_format+0x740> <== 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));
ffc105a0: 81 21 00 18 lwz r9,24(r1)
ffc105a4: 38 80 00 ff li r4,255
ffc105a8: 80 a1 00 64 lwz r5,100(r1)
ffc105ac: 80 69 00 24 lwz r3,36(r9)
ffc105b0: 48 01 23 a9 bl ffc22958 <memset>
/*
* Clear the bitmap.
*/
rc = rtems_rfs_bitmap_map_clear_all (&bitmap);
ffc105b4: 38 61 00 1c addi r3,r1,28
ffc105b8: 48 00 a4 b5 bl ffc1aa6c <rtems_rfs_bitmap_map_clear_all>
if (rc > 0)
ffc105bc: 7c 75 1b 79 mr. r21,r3
{
rtems_rfs_bitmap_close (&bitmap);
ffc105c0: 38 61 00 1c addi r3,r1,28
/*
* Clear the bitmap.
*/
rc = rtems_rfs_bitmap_map_clear_all (&bitmap);
if (rc > 0)
ffc105c4: 40 81 00 3c ble- ffc10600 <rtems_rfs_format+0x754> <== ALWAYS TAKEN
{
rtems_rfs_bitmap_close (&bitmap);
ffc105c8: 48 00 a7 b5 bl ffc1ad7c <rtems_rfs_bitmap_close> <== NOT EXECUTED
rtems_rfs_buffer_handle_close (fs, &handle);
ffc105cc: 7f c4 f3 78 mr r4,r30 <== NOT EXECUTED
ffc105d0: 7f a3 eb 78 mr r3,r29 <== NOT EXECUTED
ffc105d4: 4b ff f8 29 bl ffc0fdfc <rtems_rfs_buffer_handle_close><== NOT EXECUTED
printf ("\nrtems-rfs: write-group: group %3d: block bitmap clear all failed: %d: %s\n",
ffc105d8: 7e a3 ab 78 mr r3,r21 <== NOT EXECUTED
ffc105dc: 48 01 32 79 bl ffc23854 <strerror> <== NOT EXECUTED
ffc105e0: 7c 66 1b 78 mr r6,r3 <== NOT EXECUTED
ffc105e4: 3c 60 ff c3 lis r3,-61 <== NOT EXECUTED
ffc105e8: 38 63 2e 94 addi r3,r3,11924 <== NOT EXECUTED
ffc105ec: 7f e4 fb 78 mr r4,r31 <== NOT EXECUTED
ffc105f0: 7e a5 ab 78 mr r5,r21 <== NOT EXECUTED
ffc105f4: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc105f8: 48 01 24 f1 bl ffc22ae8 <printf> <== NOT EXECUTED
ffc105fc: 48 00 04 94 b ffc10a90 <rtems_rfs_format+0xbe4> <== NOT EXECUTED
}
/*
* Forced allocation of the block bitmap.
*/
rtems_rfs_bitmap_map_set (&bitmap, RTEMS_RFS_GROUP_BLOCK_BITMAP_BLOCK);
ffc10600: 38 80 00 00 li r4,0
ffc10604: 48 00 a2 15 bl ffc1a818 <rtems_rfs_bitmap_map_set>
/*
* Forced allocation of the inode bitmap.
*/
rtems_rfs_bitmap_map_set (&bitmap, RTEMS_RFS_GROUP_INODE_BITMAP_BLOCK);
ffc10608: 38 80 00 01 li r4,1
ffc1060c: 38 61 00 1c addi r3,r1,28
ffc10610: 48 00 a2 09 bl ffc1a818 <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);
ffc10614: 80 61 00 84 lwz r3,132(r1)
ffc10618: 80 81 00 88 lwz r4,136(r1)
/*
* Forced allocation of the inode blocks which follow the block bitmap.
*/
for (b = 0; b < blocks; b++)
ffc1061c: 39 e0 00 00 li r15,0
rtems_rfs_bitmap_map_set (&bitmap, RTEMS_RFS_GROUP_INODE_BITMAP_BLOCK);
/*
* Determine the number of inodes blocks in the group.
*/
blocks = rtems_rfs_rup_quotient (fs->group_inodes, fs->inodes_per_block);
ffc10620: 4b ff f8 19 bl ffc0fe38 <rtems_rfs_rup_quotient>
ffc10624: 7c 75 1b 78 mr r21,r3
ffc10628: 48 00 00 10 b ffc10638 <rtems_rfs_format+0x78c>
/*
* 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);
ffc1062c: 38 8f 00 02 addi r4,r15,2
ffc10630: 48 00 a1 e9 bl ffc1a818 <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++)
ffc10634: 39 ef 00 01 addi r15,r15,1
ffc10638: 7f 8f a8 00 cmpw cr7,r15,r21
rtems_rfs_bitmap_map_set (&bitmap, b + RTEMS_RFS_GROUP_INODE_BLOCK);
ffc1063c: 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++)
ffc10640: 41 9c ff ec blt+ cr7,ffc1062c <rtems_rfs_format+0x780>
rtems_rfs_bitmap_map_set (&bitmap, b + RTEMS_RFS_GROUP_INODE_BLOCK);
/*
* Close the block bitmap.
*/
rc = rtems_rfs_bitmap_close (&bitmap);
ffc10644: 48 00 a7 39 bl ffc1ad7c <rtems_rfs_bitmap_close>
if (rc > 0)
ffc10648: 7c 6f 1b 79 mr. r15,r3
ffc1064c: 40 a1 00 30 ble+ ffc1067c <rtems_rfs_format+0x7d0> <== ALWAYS TAKEN
{
rtems_rfs_buffer_handle_close (fs, &handle);
ffc10650: 38 81 00 10 addi r4,r1,16 <== NOT EXECUTED
ffc10654: 38 61 00 5c addi r3,r1,92 <== NOT EXECUTED
ffc10658: 4b ff f7 a5 bl ffc0fdfc <rtems_rfs_buffer_handle_close><== NOT EXECUTED
printf ("\nrtems-rfs: write-group: group %3d: close block bitmap failed: %d: %s\n",
ffc1065c: 7d e3 7b 78 mr r3,r15 <== NOT EXECUTED
ffc10660: 48 01 31 f5 bl ffc23854 <strerror> <== NOT EXECUTED
ffc10664: 7f e4 fb 78 mr r4,r31 <== NOT EXECUTED
ffc10668: 7c 66 1b 78 mr r6,r3 <== NOT EXECUTED
ffc1066c: 3c 60 ff c3 lis r3,-61 <== NOT EXECUTED
ffc10670: 38 63 2e df addi r3,r3,11999 <== NOT EXECUTED
ffc10674: 7d e5 7b 78 mr r5,r15 <== NOT EXECUTED
ffc10678: 4b ff ff 7c b ffc105f4 <rtems_rfs_format+0x748> <== NOT EXECUTED
return false;
}
rtems_rfs_buffer_mark_dirty (&handle);
if (verbose)
ffc1067c: 2f 97 00 00 cmpwi cr7,r23,0
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);
ffc10680: 9b 21 00 10 stb r25,16(r1)
if (verbose)
ffc10684: 41 be 00 10 beq+ cr7,ffc10694 <rtems_rfs_format+0x7e8> <== ALWAYS TAKEN
printf (", inodes");
ffc10688: 7e 83 a3 78 mr r3,r20 <== NOT EXECUTED
ffc1068c: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc10690: 48 01 24 59 bl ffc22ae8 <printf> <== NOT EXECUTED
/*
* Open the inode bitmap using the old buffer. Should release any changes.
*/
rc = rtems_rfs_bitmap_open (&bitmap, fs, &handle, group_size,
ffc10694: 7f 66 db 78 mr r6,r27
ffc10698: 38 61 00 1c addi r3,r1,28
ffc1069c: 7f a4 eb 78 mr r4,r29
ffc106a0: 7f c5 f3 78 mr r5,r30
ffc106a4: 38 f8 00 02 addi r7,r24,2
ffc106a8: 48 00 a6 6d bl ffc1ad14 <rtems_rfs_bitmap_open>
group_base + RTEMS_RFS_GROUP_INODE_BITMAP_BLOCK);
if (rc > 0)
ffc106ac: 7c 7b 1b 79 mr. r27,r3
ffc106b0: 40 81 00 28 ble- ffc106d8 <rtems_rfs_format+0x82c> <== ALWAYS TAKEN
{
rtems_rfs_buffer_handle_close (fs, &handle);
ffc106b4: 7f c4 f3 78 mr r4,r30 <== NOT EXECUTED
ffc106b8: 7f a3 eb 78 mr r3,r29 <== NOT EXECUTED
ffc106bc: 4b ff f7 41 bl ffc0fdfc <rtems_rfs_buffer_handle_close><== NOT EXECUTED
printf ("\nrtems-rfs: write-group: group %3d: open inode bitmap failed: %d: %s\n",
ffc106c0: 7f 63 db 78 mr r3,r27 <== NOT EXECUTED
ffc106c4: 48 01 31 91 bl ffc23854 <strerror> <== NOT EXECUTED
ffc106c8: 7c 66 1b 78 mr r6,r3 <== NOT EXECUTED
ffc106cc: 3c 60 ff c3 lis r3,-61 <== NOT EXECUTED
ffc106d0: 38 63 2f 2f addi r3,r3,12079 <== NOT EXECUTED
ffc106d4: 48 00 00 50 b ffc10724 <rtems_rfs_format+0x878> <== 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));
ffc106d8: 81 21 00 18 lwz r9,24(r1)
ffc106dc: 38 80 00 00 li r4,0
ffc106e0: 80 a1 00 64 lwz r5,100(r1)
ffc106e4: 80 69 00 24 lwz r3,36(r9)
ffc106e8: 48 01 22 71 bl ffc22958 <memset>
/*
* Clear the inode bitmap.
*/
rc = rtems_rfs_bitmap_map_clear_all (&bitmap);
ffc106ec: 38 61 00 1c addi r3,r1,28
ffc106f0: 48 00 a3 7d bl ffc1aa6c <rtems_rfs_bitmap_map_clear_all>
if (rc > 0)
ffc106f4: 7c 7b 1b 79 mr. r27,r3
{
rtems_rfs_bitmap_close (&bitmap);
ffc106f8: 38 61 00 1c addi r3,r1,28
/*
* Clear the inode bitmap.
*/
rc = rtems_rfs_bitmap_map_clear_all (&bitmap);
if (rc > 0)
ffc106fc: 40 81 00 34 ble- ffc10730 <rtems_rfs_format+0x884> <== ALWAYS TAKEN
{
rtems_rfs_bitmap_close (&bitmap);
ffc10700: 48 00 a6 7d bl ffc1ad7c <rtems_rfs_bitmap_close> <== NOT EXECUTED
rtems_rfs_buffer_handle_close (fs, &handle);
ffc10704: 7f c4 f3 78 mr r4,r30 <== NOT EXECUTED
ffc10708: 7f a3 eb 78 mr r3,r29 <== NOT EXECUTED
ffc1070c: 4b ff f6 f1 bl ffc0fdfc <rtems_rfs_buffer_handle_close><== NOT EXECUTED
printf ("\nrtems-rfs: write-group: group %3d: inode bitmap" \
ffc10710: 7f 63 db 78 mr r3,r27 <== NOT EXECUTED
ffc10714: 48 01 31 41 bl ffc23854 <strerror> <== NOT EXECUTED
ffc10718: 7c 66 1b 78 mr r6,r3 <== NOT EXECUTED
ffc1071c: 3c 60 ff c3 lis r3,-61 <== NOT EXECUTED
ffc10720: 38 63 2f 75 addi r3,r3,12149 <== NOT EXECUTED
ffc10724: 7f e4 fb 78 mr r4,r31 <== NOT EXECUTED
ffc10728: 7f 65 db 78 mr r5,r27 <== NOT EXECUTED
ffc1072c: 4b ff fe c8 b ffc105f4 <rtems_rfs_format+0x748> <== NOT EXECUTED
}
/*
* Close the inode bitmap.
*/
rc = rtems_rfs_bitmap_close (&bitmap);
ffc10730: 48 00 a6 4d bl ffc1ad7c <rtems_rfs_bitmap_close>
if (rc > 0)
ffc10734: 7c 7b 1b 79 mr. r27,r3
ffc10738: 40 a1 00 28 ble+ ffc10760 <rtems_rfs_format+0x8b4> <== ALWAYS TAKEN
{
rtems_rfs_buffer_handle_close (fs, &handle);
ffc1073c: 7f c4 f3 78 mr r4,r30 <== NOT EXECUTED
ffc10740: 7f a3 eb 78 mr r3,r29 <== NOT EXECUTED
ffc10744: 4b ff f6 b9 bl ffc0fdfc <rtems_rfs_buffer_handle_close><== NOT EXECUTED
printf ("\nrtems-rfs: write-group: group %3d: close inode" \
ffc10748: 7f 63 db 78 mr r3,r27 <== NOT EXECUTED
ffc1074c: 48 01 31 09 bl ffc23854 <strerror> <== NOT EXECUTED
ffc10750: 7c 66 1b 78 mr r6,r3 <== NOT EXECUTED
ffc10754: 3c 60 ff c3 lis r3,-61 <== NOT EXECUTED
ffc10758: 38 63 2f c0 addi r3,r3,12224 <== NOT EXECUTED
ffc1075c: 4b ff ff c8 b ffc10724 <rtems_rfs_format+0x878> <== NOT EXECUTED
rtems_rfs_buffer_mark_dirty (&handle);
/*
* Initialise the inode tables if required to do so.
*/
if (initialise_inodes)
ffc10760: 2f 90 00 00 cmpwi cr7,r16,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);
ffc10764: 9b 21 00 10 stb r25,16(r1)
/*
* Initialise the inode tables if required to do so.
*/
if (initialise_inodes)
ffc10768: 3b 60 00 00 li r27,0
{
for (b = 0; b < blocks; b++)
{
rc = rtems_rfs_buffer_handle_request (fs, &handle,
group_base + b + RTEMS_RFS_GROUP_INODE_BLOCK,
ffc1076c: 3b 18 00 03 addi r24,r24,3
rtems_rfs_buffer_mark_dirty (&handle);
/*
* Initialise the inode tables if required to do so.
*/
if (initialise_inodes)
ffc10770: 40 be 00 7c bne+ cr7,ffc107ec <rtems_rfs_format+0x940> <== NEVER TAKEN
ffc10774: 48 00 00 80 b ffc107f4 <rtems_rfs_format+0x948>
return rc;
}
int
rtems_rfs_format (const char* name, const rtems_rfs_format_config* config)
ffc10778: 7e f8 da 14 add r23,r24,r27 <== NOT EXECUTED
*/
if (initialise_inodes)
{
for (b = 0; b < blocks; b++)
{
rc = rtems_rfs_buffer_handle_request (fs, &handle,
ffc1077c: 7f a3 eb 78 mr r3,r29 <== NOT EXECUTED
ffc10780: 7f c4 f3 78 mr r4,r30 <== NOT EXECUTED
ffc10784: 7e e5 bb 78 mr r5,r23 <== NOT EXECUTED
ffc10788: 38 c0 00 00 li r6,0 <== NOT EXECUTED
ffc1078c: 48 00 ba 5d bl ffc1c1e8 <rtems_rfs_buffer_handle_request><== NOT EXECUTED
group_base + b + RTEMS_RFS_GROUP_INODE_BLOCK,
false);
if (rc > 0)
ffc10790: 7c 70 1b 79 mr. r16,r3 <== NOT EXECUTED
ffc10794: 40 a1 00 3c ble+ ffc107d0 <rtems_rfs_format+0x924> <== NOT EXECUTED
{
rtems_rfs_buffer_handle_close (fs, &handle);
ffc10798: 7f c4 f3 78 mr r4,r30 <== NOT EXECUTED
ffc1079c: 7f a3 eb 78 mr r3,r29 <== NOT EXECUTED
ffc107a0: 4b ff f6 5d bl ffc0fdfc <rtems_rfs_buffer_handle_close><== NOT EXECUTED
printf ("\nrtems-rfs: write-group: group %3d: block %" PRId32 " request failed: %d: %s\n",
ffc107a4: 7e 03 83 78 mr r3,r16 <== NOT EXECUTED
ffc107a8: 48 01 30 ad bl ffc23854 <strerror> <== NOT EXECUTED
ffc107ac: 7f e4 fb 78 mr r4,r31 <== NOT EXECUTED
ffc107b0: 7c 67 1b 78 mr r7,r3 <== NOT EXECUTED
ffc107b4: 3c 60 ff c3 lis r3,-61 <== NOT EXECUTED
ffc107b8: 7e e5 bb 78 mr r5,r23 <== NOT EXECUTED
ffc107bc: 7e 06 83 78 mr r6,r16 <== NOT EXECUTED
ffc107c0: 38 63 30 07 addi r3,r3,12295 <== NOT EXECUTED
ffc107c4: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc107c8: 48 01 23 21 bl ffc22ae8 <printf> <== NOT EXECUTED
ffc107cc: 48 00 02 c4 b ffc10a90 <rtems_rfs_format+0xbe4> <== 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));
ffc107d0: 81 21 00 18 lwz r9,24(r1) <== NOT EXECUTED
ffc107d4: 38 80 00 ff li r4,255 <== NOT EXECUTED
ffc107d8: 80 a1 00 64 lwz r5,100(r1) <== NOT EXECUTED
/*
* Initialise the inode tables if required to do so.
*/
if (initialise_inodes)
{
for (b = 0; b < blocks; b++)
ffc107dc: 3b 7b 00 01 addi r27,r27,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));
ffc107e0: 80 69 00 24 lwz r3,36(r9) <== NOT EXECUTED
ffc107e4: 48 01 21 75 bl ffc22958 <memset> <== NOT EXECUTED
rtems_rfs_buffer_mark_dirty (&handle);
ffc107e8: 9b 21 00 10 stb r25,16(r1) <== NOT EXECUTED
/*
* Initialise the inode tables if required to do so.
*/
if (initialise_inodes)
{
for (b = 0; b < blocks; b++)
ffc107ec: 7f 9b a8 00 cmpw cr7,r27,r21 <== NOT EXECUTED
ffc107f0: 41 9c ff 88 blt+ cr7,ffc10778 <rtems_rfs_format+0x8cc> <== NOT EXECUTED
rtems_rfs_buffer_mark_dirty (&handle);
}
}
rc = rtems_rfs_buffer_handle_close (fs, &handle);
ffc107f4: 7f a3 eb 78 mr r3,r29
ffc107f8: 7f c4 f3 78 mr r4,r30
ffc107fc: 4b ff f6 01 bl ffc0fdfc <rtems_rfs_buffer_handle_close>
if (rc > 0)
ffc10800: 7c 7b 1b 79 mr. r27,r3
ffc10804: 40 81 02 b0 ble- ffc10ab4 <rtems_rfs_format+0xc08> <== ALWAYS TAKEN
{
printf ("\nrtems-rfs: write-group: buffer handle close failed: %d: %s\n",
ffc10808: 48 01 30 4d bl ffc23854 <strerror> <== NOT EXECUTED
ffc1080c: 7f 64 db 78 mr r4,r27 <== NOT EXECUTED
ffc10810: 7c 65 1b 78 mr r5,r3 <== NOT EXECUTED
ffc10814: 3c 60 ff c3 lis r3,-61 <== NOT EXECUTED
ffc10818: 38 63 30 4d addi r3,r3,12365 <== NOT EXECUTED
ffc1081c: 48 00 02 6c b ffc10a88 <rtems_rfs_format+0xbdc> <== 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",
ffc10820: 3e 20 ff c3 lis r17,-61
rc, strerror (rc));
return false;
}
if (verbose)
printf (", blocks");
ffc10824: 3e 60 ff c3 lis r19,-61
}
rtems_rfs_buffer_mark_dirty (&handle);
if (verbose)
printf (", inodes");
ffc10828: 3e 80 ff c3 lis r20,-61
rc, strerror (rc));
return false;
}
rc = rtems_rfs_buffer_handle_close (fs, &handle);
if (rc > 0)
ffc1082c: 3b e0 00 00 li r31,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",
ffc10830: 3a 31 2e 0f addi r17,r17,11791
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
ffc10834: 3a 40 00 00 li r18,0
handle->bnum = 0;
ffc10838: 3a c0 00 00 li r22,0
rc, strerror (rc));
return false;
}
if (verbose)
printf (", blocks");
ffc1083c: 3a 73 2e 45 addi r19,r19,11845
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);
ffc10840: 3b 20 00 01 li r25,1
if (verbose)
printf (", inodes");
ffc10844: 3a 94 2f 26 addi r20,r20,12070
{
printf ("rtems-rfs: format: superblock write failed\n");
return -1;
}
for (group = 0; group < fs.group_count; group++)
ffc10848: 80 01 00 7c lwz r0,124(r1)
ffc1084c: 8a fc 00 15 lbz r23,21(r28)
ffc10850: 7f 9f 00 00 cmpw cr7,r31,r0
ffc10854: 41 9c fc 80 blt+ cr7,ffc104d4 <rtems_rfs_format+0x628>
if (!rtems_rfs_write_group (&fs, group,
config->initialise_inodes, config->verbose))
return -1;
if (config->verbose)
ffc10858: 72 e0 00 ff andi. r0,r23,255
ffc1085c: 41 a2 00 0c beq+ ffc10868 <rtems_rfs_format+0x9bc> <== ALWAYS TAKEN
printf ("\n");
ffc10860: 38 60 00 0a li r3,10 <== NOT EXECUTED
ffc10864: 48 01 23 41 bl ffc22ba4 <putchar> <== NOT EXECUTED
rc = rtems_rfs_buffer_close (&fs);
ffc10868: 38 61 00 5c addi r3,r1,92
ffc1086c: 48 00 bf 91 bl ffc1c7fc <rtems_rfs_buffer_close>
if (rc > 0)
ffc10870: 7c 7f 1b 79 mr. r31,r3
ffc10874: 40 a1 00 18 ble+ ffc1088c <rtems_rfs_format+0x9e0> <== ALWAYS TAKEN
{
printf ("rtems-rfs: format: buffer close failed: %d: %s\n",
ffc10878: 48 01 2f dd bl ffc23854 <strerror> <== NOT EXECUTED
ffc1087c: 7c 65 1b 78 mr r5,r3 <== NOT EXECUTED
ffc10880: 3c 60 ff c3 lis r3,-61 <== NOT EXECUTED
ffc10884: 38 63 30 8a addi r3,r3,12426 <== NOT EXECUTED
ffc10888: 48 00 01 fc b ffc10a84 <rtems_rfs_format+0xbd8> <== NOT EXECUTED
int rc;
/*
* External API so returns -1.
*/
rc = rtems_rfs_fs_open (name, NULL, RTEMS_RFS_FS_FORCE_OPEN, &fs);
ffc1088c: 7f 43 d3 78 mr r3,r26
ffc10890: 38 80 00 00 li r4,0
ffc10894: 38 a0 00 04 li r5,4
ffc10898: 38 c1 00 0c addi r6,r1,12
ffc1089c: 48 00 e0 b9 bl ffc1e954 <rtems_rfs_fs_open>
if (rc < 0)
ffc108a0: 2f 83 00 00 cmpwi cr7,r3,0
ffc108a4: 40 bc 00 28 bge+ cr7,ffc108cc <rtems_rfs_format+0xa20> <== ALWAYS TAKEN
{
printf ("rtems-rfs: format: file system open failed: %d: %s\n",
errno, strerror (errno));
ffc108a8: 48 01 11 5d bl ffc21a04 <__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",
ffc108ac: 83 e3 00 00 lwz r31,0(r3) <== NOT EXECUTED
errno, strerror (errno));
ffc108b0: 48 01 11 55 bl ffc21a04 <__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",
ffc108b4: 80 63 00 00 lwz r3,0(r3) <== NOT EXECUTED
ffc108b8: 48 01 2f 9d bl ffc23854 <strerror> <== NOT EXECUTED
ffc108bc: 7c 65 1b 78 mr r5,r3 <== NOT EXECUTED
ffc108c0: 3c 60 ff c3 lis r3,-61 <== NOT EXECUTED
ffc108c4: 38 63 30 ba addi r3,r3,12474 <== NOT EXECUTED
ffc108c8: 48 00 01 94 b ffc10a5c <rtems_rfs_format+0xbb0> <== NOT EXECUTED
errno, strerror (errno));
return -1;
}
rc = rtems_rfs_inode_alloc (fs, RTEMS_RFS_ROOT_INO, &ino);
ffc108cc: 80 61 00 0c lwz r3,12(r1)
ffc108d0: 38 80 00 01 li r4,1
ffc108d4: 38 a1 00 08 addi r5,r1,8
ffc108d8: 48 00 09 09 bl ffc111e0 <rtems_rfs_inode_alloc>
if (rc > 0)
ffc108dc: 7c 7f 1b 79 mr. r31,r3
ffc108e0: 40 a1 00 24 ble+ ffc10904 <rtems_rfs_format+0xa58> <== ALWAYS TAKEN
{
printf ("rtems-rfs: format: inode allocation failed: %d: %s\n",
ffc108e4: 48 01 2f 71 bl ffc23854 <strerror> <== NOT EXECUTED
ffc108e8: 7f e4 fb 78 mr r4,r31 <== NOT EXECUTED
ffc108ec: 7c 65 1b 78 mr r5,r3 <== NOT EXECUTED
ffc108f0: 3c 60 ff c3 lis r3,-61 <== NOT EXECUTED
ffc108f4: 38 63 30 ee addi r3,r3,12526 <== NOT EXECUTED
ffc108f8: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc108fc: 48 01 21 ed bl ffc22ae8 <printf> <== NOT EXECUTED
ffc10900: 48 00 00 74 b ffc10974 <rtems_rfs_format+0xac8> <== NOT EXECUTED
rc, strerror (rc));
rtems_rfs_fs_close (fs);
return rc;
}
if (ino != RTEMS_RFS_ROOT_INO)
ffc10904: 80 81 00 08 lwz r4,8(r1)
ffc10908: 2f 84 00 01 cmpwi cr7,r4,1
ffc1090c: 41 9e 00 20 beq- cr7,ffc1092c <rtems_rfs_format+0xa80> <== ALWAYS TAKEN
{
printf ("rtems-rfs: format: allocated inode not root ino: %" PRId32 "\n", ino);
ffc10910: 3c 60 ff c3 lis r3,-61 <== NOT EXECUTED
ffc10914: 38 63 31 22 addi r3,r3,12578 <== NOT EXECUTED
ffc10918: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc1091c: 48 01 21 cd bl ffc22ae8 <printf> <== NOT EXECUTED
rtems_rfs_fs_close (fs);
ffc10920: 80 61 00 0c lwz r3,12(r1) <== NOT EXECUTED
ffc10924: 48 00 e8 31 bl ffc1f154 <rtems_rfs_fs_close> <== NOT EXECUTED
ffc10928: 48 00 01 70 b ffc10a98 <rtems_rfs_format+0xbec> <== NOT EXECUTED
return rc;
}
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
ffc1092c: 80 61 00 0c lwz r3,12(r1)
ffc10930: 38 80 00 01 li r4,1
ffc10934: 38 a1 00 34 addi r5,r1,52
ffc10938: 38 c0 00 01 li r6,1
ffc1093c: 48 00 09 bd bl ffc112f8 <rtems_rfs_inode_open>
if (rc > 0)
ffc10940: 7c 7f 1b 79 mr. r31,r3
ffc10944: 40 81 00 3c ble- ffc10980 <rtems_rfs_format+0xad4> <== ALWAYS TAKEN
{
printf ("rtems-rfs: format: inode open failed: %d: %s\n",
ffc10948: 48 01 2f 0d bl ffc23854 <strerror> <== NOT EXECUTED
ffc1094c: 7f e4 fb 78 mr r4,r31 <== NOT EXECUTED
ffc10950: 7c 65 1b 78 mr r5,r3 <== NOT EXECUTED
ffc10954: 3c 60 ff c3 lis r3,-61 <== NOT EXECUTED
ffc10958: 38 63 31 58 addi r3,r3,12632 <== NOT EXECUTED
ffc1095c: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc10960: 48 01 21 89 bl ffc22ae8 <printf> <== NOT EXECUTED
rc, strerror (rc));
rtems_rfs_group_bitmap_free (fs, true, ino);
ffc10964: 80 61 00 0c lwz r3,12(r1) <== NOT EXECUTED
ffc10968: 80 a1 00 08 lwz r5,8(r1) <== NOT EXECUTED
ffc1096c: 38 80 00 01 li r4,1 <== NOT EXECUTED
ffc10970: 48 00 06 19 bl ffc10f88 <rtems_rfs_group_bitmap_free> <== NOT EXECUTED
rtems_rfs_fs_close (fs);
ffc10974: 80 61 00 0c lwz r3,12(r1) <== NOT EXECUTED
ffc10978: 48 00 e7 dd bl ffc1f154 <rtems_rfs_fs_close> <== NOT EXECUTED
ffc1097c: 48 00 00 f4 b ffc10a70 <rtems_rfs_format+0xbc4> <== NOT EXECUTED
return rc;
}
rc = rtems_rfs_inode_initialise (&inode, 0,
ffc10980: 38 61 00 34 addi r3,r1,52
ffc10984: 38 80 00 00 li r4,0
ffc10988: 38 a0 41 c9 li r5,16841
ffc1098c: 38 c0 00 00 li r6,0
ffc10990: 38 e0 00 00 li r7,0
ffc10994: 48 00 0d a1 bl ffc11734 <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)
ffc10998: 7c 7f 1b 79 mr. r31,r3
ffc1099c: 40 81 00 20 ble- ffc109bc <rtems_rfs_format+0xb10> <== ALWAYS TAKEN
printf ("rtems-rfs: format: inode initialise failed: %d: %s\n",
ffc109a0: 48 01 2e b5 bl ffc23854 <strerror> <== NOT EXECUTED
ffc109a4: 7f e4 fb 78 mr r4,r31 <== NOT EXECUTED
ffc109a8: 7c 65 1b 78 mr r5,r3 <== NOT EXECUTED
ffc109ac: 3c 60 ff c3 lis r3,-61 <== NOT EXECUTED
ffc109b0: 38 63 31 86 addi r3,r3,12678 <== NOT EXECUTED
ffc109b4: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc109b8: 48 01 21 31 bl ffc22ae8 <printf> <== NOT EXECUTED
rc, strerror (rc));
rc = rtems_rfs_dir_add_entry (fs, &inode, ".", 1, ino);
ffc109bc: 80 61 00 0c lwz r3,12(r1)
ffc109c0: 3c a0 ff c3 lis r5,-61
ffc109c4: 80 e1 00 08 lwz r7,8(r1)
ffc109c8: 38 81 00 34 addi r4,r1,52
ffc109cc: 38 a5 18 b5 addi r5,r5,6325
ffc109d0: 38 c0 00 01 li r6,1
ffc109d4: 48 00 c3 d9 bl ffc1cdac <rtems_rfs_dir_add_entry>
if (rc > 0)
ffc109d8: 7c 7f 1b 79 mr. r31,r3
ffc109dc: 40 81 00 20 ble- ffc109fc <rtems_rfs_format+0xb50> <== ALWAYS TAKEN
printf ("rtems-rfs: format: directory add failed: %d: %s\n",
ffc109e0: 48 01 2e 75 bl ffc23854 <strerror> <== NOT EXECUTED
ffc109e4: 7f e4 fb 78 mr r4,r31 <== NOT EXECUTED
ffc109e8: 7c 65 1b 78 mr r5,r3 <== NOT EXECUTED
ffc109ec: 3c 60 ff c3 lis r3,-61 <== NOT EXECUTED
ffc109f0: 38 63 31 ba addi r3,r3,12730 <== NOT EXECUTED
ffc109f4: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc109f8: 48 01 20 f1 bl ffc22ae8 <printf> <== NOT EXECUTED
rc, strerror (rc));
rc = rtems_rfs_inode_close (fs, &inode);
ffc109fc: 80 61 00 0c lwz r3,12(r1)
ffc10a00: 38 81 00 34 addi r4,r1,52
ffc10a04: 48 00 0a e5 bl ffc114e8 <rtems_rfs_inode_close>
if (rc > 0)
ffc10a08: 7c 7f 1b 79 mr. r31,r3
ffc10a0c: 40 81 00 20 ble- ffc10a2c <rtems_rfs_format+0xb80> <== ALWAYS TAKEN
printf ("rtems-rfs: format: inode close failed: %d: %s\n",
ffc10a10: 48 01 2e 45 bl ffc23854 <strerror> <== NOT EXECUTED
ffc10a14: 7f e4 fb 78 mr r4,r31 <== NOT EXECUTED
ffc10a18: 7c 65 1b 78 mr r5,r3 <== NOT EXECUTED
ffc10a1c: 3c 60 ff c3 lis r3,-61 <== NOT EXECUTED
ffc10a20: 38 63 31 eb addi r3,r3,12779 <== NOT EXECUTED
ffc10a24: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc10a28: 48 01 20 c1 bl ffc22ae8 <printf> <== NOT EXECUTED
rc, strerror (rc));
rc = rtems_rfs_fs_close (fs);
ffc10a2c: 80 61 00 0c lwz r3,12(r1)
ffc10a30: 48 00 e7 25 bl ffc1f154 <rtems_rfs_fs_close>
if (rc < 0)
ffc10a34: 7c 7f 1b 79 mr. r31,r3
ffc10a38: 40 a0 00 34 bge+ ffc10a6c <rtems_rfs_format+0xbc0> <== ALWAYS TAKEN
printf ("rtems-rfs: format: file system close failed: %d: %s\n",
errno, strerror (errno));
ffc10a3c: 48 01 0f c9 bl ffc21a04 <__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",
ffc10a40: 83 e3 00 00 lwz r31,0(r3) <== NOT EXECUTED
errno, strerror (errno));
ffc10a44: 48 01 0f c1 bl ffc21a04 <__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",
ffc10a48: 80 63 00 00 lwz r3,0(r3) <== NOT EXECUTED
ffc10a4c: 48 01 2e 09 bl ffc23854 <strerror> <== NOT EXECUTED
ffc10a50: 7c 65 1b 78 mr r5,r3 <== NOT EXECUTED
ffc10a54: 3c 60 ff c3 lis r3,-61 <== NOT EXECUTED
ffc10a58: 38 63 32 1a addi r3,r3,12826 <== NOT EXECUTED
ffc10a5c: 7f e4 fb 78 mr r4,r31 <== NOT EXECUTED
ffc10a60: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc10a64: 48 01 20 85 bl ffc22ae8 <printf> <== NOT EXECUTED
ffc10a68: 48 00 00 30 b ffc10a98 <rtems_rfs_format+0xbec> <== NOT EXECUTED
rc, strerror (rc));
return -1;
}
rc = rtems_rfs_write_root_dir (name);
if (rc > 0)
ffc10a6c: 40 a1 00 2c ble+ ffc10a98 <rtems_rfs_format+0xbec> <== ALWAYS TAKEN
{
printf ("rtems-rfs: format: writing root dir failed: %d: %s\n",
ffc10a70: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc10a74: 48 01 2d e1 bl ffc23854 <strerror> <== NOT EXECUTED
ffc10a78: 7c 65 1b 78 mr r5,r3 <== NOT EXECUTED
ffc10a7c: 3c 60 ff c3 lis r3,-61 <== NOT EXECUTED
ffc10a80: 38 63 32 4f addi r3,r3,12879 <== NOT EXECUTED
ffc10a84: 7f e4 fb 78 mr r4,r31 <== NOT EXECUTED
ffc10a88: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc10a8c: 48 01 20 5d bl ffc22ae8 <printf> <== NOT EXECUTED
rc, strerror (rc));
return -1;
ffc10a90: 38 60 ff ff li r3,-1 <== NOT EXECUTED
ffc10a94: 48 00 00 08 b ffc10a9c <rtems_rfs_format+0xbf0> <== NOT EXECUTED
}
return 0;
ffc10a98: 38 60 00 00 li r3,0
}
ffc10a9c: 39 61 01 30 addi r11,r1,304
ffc10aa0: 4b ff 20 18 b ffc02ab8 <_restgpr_15_x>
* Check the configuration data.
*/
if (!rtems_rfs_check_config (&fs, config))
return -1;
if (config->verbose)
ffc10aa4: 88 1c 00 15 lbz r0,21(r28)
ffc10aa8: 2f 80 00 00 cmpwi cr7,r0,0
ffc10aac: 41 9e f7 d8 beq+ cr7,ffc10284 <rtems_rfs_format+0x3d8> <== ALWAYS TAKEN
ffc10ab0: 4b ff f6 98 b ffc10148 <rtems_rfs_format+0x29c> <== NOT EXECUTED
{
printf ("rtems-rfs: format: superblock write failed\n");
return -1;
}
for (group = 0; group < fs.group_count; group++)
ffc10ab4: 3b ff 00 01 addi r31,r31,1
ffc10ab8: 4b ff fd 90 b ffc10848 <rtems_rfs_format+0x99c>
ffc1f154 <rtems_rfs_fs_close>:
return 0;
}
int
rtems_rfs_fs_close (rtems_rfs_file_system* fs)
{
ffc1f154: 94 21 ff f0 stwu r1,-16(r1)
ffc1f158: 7c 08 02 a6 mflr r0
int group;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_CLOSE))
ffc1f15c: 38 80 00 02 li r4,2
return 0;
}
int
rtems_rfs_fs_close (rtems_rfs_file_system* fs)
{
ffc1f160: bf c1 00 08 stmw r30,8(r1)
ffc1f164: 7c 7f 1b 78 mr r31,r3
int group;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_CLOSE))
ffc1f168: 38 60 00 00 li r3,0
return 0;
}
int
rtems_rfs_fs_close (rtems_rfs_file_system* fs)
{
ffc1f16c: 90 01 00 14 stw r0,20(r1)
int group;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_CLOSE))
ffc1f170: 4b ff 41 95 bl ffc13304 <rtems_rfs_trace>
ffc1f174: 2f 83 00 00 cmpwi cr7,r3,0
ffc1f178: 41 be 00 10 beq+ cr7,ffc1f188 <rtems_rfs_fs_close+0x34> <== ALWAYS TAKEN
printf ("rtems-rfs: close\n");
ffc1f17c: 3c 60 ff c3 lis r3,-61 <== NOT EXECUTED
ffc1f180: 38 63 54 0d addi r3,r3,21517 <== NOT EXECUTED
ffc1f184: 48 00 3b 19 bl ffc22c9c <puts> <== NOT EXECUTED
return 0;
}
int
rtems_rfs_fs_close (rtems_rfs_file_system* fs)
{
ffc1f188: 3b c0 00 00 li r30,0
ffc1f18c: 48 00 00 1c b ffc1f1a8 <rtems_rfs_fs_close+0x54>
errno = 0;
return 0;
}
int
rtems_rfs_fs_close (rtems_rfs_file_system* fs)
ffc1f190: 1c 1e 00 50 mulli r0,r30,80
if (rtems_rfs_trace (RTEMS_RFS_TRACE_CLOSE))
printf ("rtems-rfs: close\n");
for (group = 0; group < fs->group_count; group++)
rtems_rfs_group_close (fs, &fs->groups[group]);
ffc1f194: 80 9f 00 1c lwz r4,28(r31)
ffc1f198: 7f e3 fb 78 mr r3,r31
ffc1f19c: 7c 84 02 14 add r4,r4,r0
ffc1f1a0: 4b ff 1b 3d bl ffc10cdc <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++)
ffc1f1a4: 3b de 00 01 addi r30,r30,1
ffc1f1a8: 80 1f 00 20 lwz r0,32(r31)
ffc1f1ac: 7f 9e 00 00 cmpw cr7,r30,r0
ffc1f1b0: 41 9c ff e0 blt+ cr7,ffc1f190 <rtems_rfs_fs_close+0x3c>
rtems_rfs_group_close (fs, &fs->groups[group]);
rtems_rfs_buffer_close (fs);
ffc1f1b4: 7f e3 fb 78 mr r3,r31
ffc1f1b8: 4b ff d6 45 bl ffc1c7fc <rtems_rfs_buffer_close>
free (fs);
ffc1f1bc: 7f e3 fb 78 mr r3,r31
ffc1f1c0: 4b fe 87 29 bl ffc078e8 <free>
return 0;
}
ffc1f1c4: 39 61 00 10 addi r11,r1,16
ffc1f1c8: 38 60 00 00 li r3,0
ffc1f1cc: 4b fe 39 28 b ffc02af4 <_restgpr_30_x>
ffc1e954 <rtems_rfs_fs_open>:
int
rtems_rfs_fs_open (const char* name,
void* user,
uint32_t flags,
rtems_rfs_file_system** fs)
{
ffc1e954: 94 21 ff a0 stwu r1,-96(r1)
ffc1e958: 7c 08 02 a6 mflr r0
ffc1e95c: bf 61 00 4c stmw r27,76(r1)
ffc1e960: 7c 7f 1b 78 mr r31,r3
ffc1e964: 7c 9c 23 78 mr r28,r4
size_t group_base;
rtems_rfs_inode_handle inode;
uint16_t mode;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
ffc1e968: 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)
{
ffc1e96c: 90 01 00 64 stw r0,100(r1)
size_t group_base;
rtems_rfs_inode_handle inode;
uint16_t mode;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
ffc1e970: 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)
{
ffc1e974: 7c bd 2b 78 mr r29,r5
ffc1e978: 7c de 33 78 mr r30,r6
size_t group_base;
rtems_rfs_inode_handle inode;
uint16_t mode;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
ffc1e97c: 4b ff 49 89 bl ffc13304 <rtems_rfs_trace>
ffc1e980: 2f 83 00 00 cmpwi cr7,r3,0
ffc1e984: 41 be 00 18 beq+ cr7,ffc1e99c <rtems_rfs_fs_open+0x48> <== ALWAYS TAKEN
printf ("rtems-rfs: open: %s\n", name);
ffc1e988: 3c 60 ff c3 lis r3,-61 <== NOT EXECUTED
ffc1e98c: 38 63 51 06 addi r3,r3,20742 <== NOT EXECUTED
ffc1e990: 7f e4 fb 78 mr r4,r31 <== NOT EXECUTED
ffc1e994: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc1e998: 48 00 41 51 bl ffc22ae8 <printf> <== NOT EXECUTED
*fs = malloc (sizeof (rtems_rfs_file_system));
ffc1e99c: 38 60 00 80 li r3,128
ffc1e9a0: 4b fe 96 b5 bl ffc08054 <malloc>
if (!*fs)
ffc1e9a4: 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));
ffc1e9a8: 90 7e 00 00 stw r3,0(r30)
if (!*fs)
ffc1e9ac: 40 be 00 30 bne+ cr7,ffc1e9dc <rtems_rfs_fs_open+0x88> <== ALWAYS TAKEN
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
ffc1e9b0: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc1e9b4: 38 80 00 01 li r4,1 <== NOT EXECUTED
ffc1e9b8: 4b ff 49 4d bl ffc13304 <rtems_rfs_trace> <== NOT EXECUTED
ffc1e9bc: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc1e9c0: 41 be 00 10 beq+ cr7,ffc1e9d0 <rtems_rfs_fs_open+0x7c> <== NOT EXECUTED
printf ("rtems-rfs: open: no memory for file system data\n");
ffc1e9c4: 3c 60 ff c3 lis r3,-61 <== NOT EXECUTED
ffc1e9c8: 38 63 51 1b addi r3,r3,20763 <== NOT EXECUTED
ffc1e9cc: 48 00 42 d1 bl ffc22c9c <puts> <== NOT EXECUTED
errno = ENOMEM;
ffc1e9d0: 48 00 30 35 bl ffc21a04 <__errno> <== NOT EXECUTED
ffc1e9d4: 38 00 00 0c li r0,12 <== NOT EXECUTED
ffc1e9d8: 48 00 06 dc b ffc1f0b4 <rtems_rfs_fs_open+0x760> <== NOT EXECUTED
return -1;
}
memset (*fs, 0, sizeof (rtems_rfs_file_system));
ffc1e9dc: 38 80 00 00 li r4,0
ffc1e9e0: 38 a0 00 80 li r5,128
ffc1e9e4: 48 00 3f 75 bl ffc22958 <memset>
(*fs)->user = user;
ffc1e9e8: 81 3e 00 00 lwz r9,0(r30)
group_base = 0;
/*
* Open the buffer interface.
*/
rc = rtems_rfs_buffer_open (name, *fs);
ffc1e9ec: 7f e3 fb 78 mr r3,r31
return -1;
}
memset (*fs, 0, sizeof (rtems_rfs_file_system));
(*fs)->user = user;
ffc1e9f0: 93 89 00 7c stw r28,124(r9)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
head->previous = NULL;
ffc1e9f4: 3b 80 00 00 li r28,0
rtems_chain_initialize_empty (&(*fs)->buffers);
ffc1e9f8: 81 3e 00 00 lwz r9,0(r30)
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 );
ffc1e9fc: 38 09 00 40 addi r0,r9,64
head->next = tail;
head->previous = NULL;
ffc1ea00: 93 89 00 44 stw r28,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 );
ffc1ea04: 39 69 00 44 addi r11,r9,68
head->next = tail;
ffc1ea08: 91 69 00 40 stw r11,64(r9)
head->previous = NULL;
tail->previous = head;
ffc1ea0c: 90 09 00 48 stw r0,72(r9)
rtems_chain_initialize_empty (&(*fs)->release);
ffc1ea10: 81 3e 00 00 lwz r9,0(r30)
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 );
ffc1ea14: 38 09 00 50 addi r0,r9,80
head->next = tail;
head->previous = NULL;
ffc1ea18: 93 89 00 54 stw r28,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 );
ffc1ea1c: 39 69 00 54 addi r11,r9,84
head->next = tail;
ffc1ea20: 91 69 00 50 stw r11,80(r9)
head->previous = NULL;
tail->previous = head;
ffc1ea24: 90 09 00 58 stw r0,88(r9)
rtems_chain_initialize_empty (&(*fs)->release_modified);
ffc1ea28: 81 3e 00 00 lwz r9,0(r30)
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 );
ffc1ea2c: 38 09 00 60 addi r0,r9,96
head->next = tail;
head->previous = NULL;
ffc1ea30: 93 89 00 64 stw r28,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 );
ffc1ea34: 39 69 00 64 addi r11,r9,100
head->next = tail;
ffc1ea38: 91 69 00 60 stw r11,96(r9)
head->previous = NULL;
tail->previous = head;
ffc1ea3c: 90 09 00 68 stw r0,104(r9)
rtems_chain_initialize_empty (&(*fs)->file_shares);
ffc1ea40: 81 3e 00 00 lwz r9,0(r30)
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 );
ffc1ea44: 38 09 00 70 addi r0,r9,112
head->next = tail;
head->previous = NULL;
ffc1ea48: 93 89 00 74 stw r28,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 );
ffc1ea4c: 39 69 00 74 addi r11,r9,116
head->next = tail;
head->previous = NULL;
tail->previous = head;
ffc1ea50: 90 09 00 78 stw r0,120(r9)
(*fs)->max_held_buffers = RTEMS_RFS_FS_MAX_HELD_BUFFERS;
ffc1ea54: 38 00 00 05 li r0,5
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
ffc1ea58: 91 69 00 70 stw r11,112(r9)
ffc1ea5c: 80 9e 00 00 lwz r4,0(r30)
(*fs)->buffers_count = 0;
(*fs)->release_count = 0;
(*fs)->release_modified_count = 0;
(*fs)->flags = flags;
ffc1ea60: 93 a4 00 00 stw r29,0(r4)
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;
ffc1ea64: 90 04 00 3c stw r0,60(r4)
(*fs)->buffers_count = 0;
ffc1ea68: 93 84 00 4c stw r28,76(r4)
(*fs)->release_count = 0;
ffc1ea6c: 93 84 00 5c stw r28,92(r4)
(*fs)->release_modified_count = 0;
ffc1ea70: 93 84 00 6c stw r28,108(r4)
group_base = 0;
/*
* Open the buffer interface.
*/
rc = rtems_rfs_buffer_open (name, *fs);
ffc1ea74: 4b ff da 1d bl ffc1c490 <rtems_rfs_buffer_open>
ffc1ea78: 83 fe 00 00 lwz r31,0(r30)
if (rc > 0)
ffc1ea7c: 7c 7d 1b 79 mr. r29,r3
ffc1ea80: 40 a1 00 50 ble+ ffc1ead0 <rtems_rfs_fs_open+0x17c> <== ALWAYS TAKEN
{
free (*fs);
ffc1ea84: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc1ea88: 4b fe 8e 61 bl ffc078e8 <free> <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
ffc1ea8c: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc1ea90: 38 80 00 01 li r4,1 <== NOT EXECUTED
ffc1ea94: 4b ff 48 71 bl ffc13304 <rtems_rfs_trace> <== NOT EXECUTED
ffc1ea98: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc1ea9c: 41 be 00 24 beq+ cr7,ffc1eac0 <rtems_rfs_fs_open+0x16c> <== NOT EXECUTED
printf ("rtems-rfs: open: buffer open failed: %d: %s\n",
ffc1eaa0: 7f a3 eb 78 mr r3,r29 <== NOT EXECUTED
ffc1eaa4: 48 00 4d b1 bl ffc23854 <strerror> <== NOT EXECUTED
ffc1eaa8: 7f a4 eb 78 mr r4,r29 <== NOT EXECUTED
ffc1eaac: 7c 65 1b 78 mr r5,r3 <== NOT EXECUTED
ffc1eab0: 3c 60 ff c3 lis r3,-61 <== NOT EXECUTED
ffc1eab4: 38 63 51 4b addi r3,r3,20811 <== NOT EXECUTED
ffc1eab8: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc1eabc: 48 00 40 2d bl ffc22ae8 <printf> <== NOT EXECUTED
rc, strerror (rc));
errno = rc;
ffc1eac0: 48 00 2f 45 bl ffc21a04 <__errno> <== NOT EXECUTED
ffc1eac4: 93 a3 00 00 stw r29,0(r3) <== NOT EXECUTED
return -1;
ffc1eac8: 38 60 ff ff li r3,-1 <== NOT EXECUTED
ffc1eacc: 48 00 06 60 b ffc1f12c <rtems_rfs_fs_open+0x7d8> <== NOT EXECUTED
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);
ffc1ead0: 7f e3 fb 78 mr r3,r31
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
ffc1ead4: 9b 81 00 08 stb r28,8(r1)
ffc1ead8: 38 81 00 08 addi r4,r1,8
ffc1eadc: 38 a0 00 00 li r5,0
handle->bnum = 0;
ffc1eae0: 93 81 00 0c stw r28,12(r1)
ffc1eae4: 38 c0 00 01 li r6,1
handle->buffer = NULL;
ffc1eae8: 93 81 00 10 stw r28,16(r1)
ffc1eaec: 4b ff d6 fd bl ffc1c1e8 <rtems_rfs_buffer_handle_request>
if (rc > 0)
ffc1eaf0: 7c 7c 1b 79 mr. r28,r3
ffc1eaf4: 40 81 00 30 ble- ffc1eb24 <rtems_rfs_fs_open+0x1d0> <== ALWAYS TAKEN
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
ffc1eaf8: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc1eafc: 38 80 00 01 li r4,1 <== NOT EXECUTED
ffc1eb00: 4b ff 48 05 bl ffc13304 <rtems_rfs_trace> <== NOT EXECUTED
ffc1eb04: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc1eb08: 41 be 04 a4 beq+ cr7,ffc1efac <rtems_rfs_fs_open+0x658> <== NOT EXECUTED
printf ("rtems-rfs: read-superblock: request failed%d: %s\n",
ffc1eb0c: 7f 83 e3 78 mr r3,r28 <== NOT EXECUTED
ffc1eb10: 48 00 4d 45 bl ffc23854 <strerror> <== NOT EXECUTED
ffc1eb14: 7c 65 1b 78 mr r5,r3 <== NOT EXECUTED
ffc1eb18: 3c 60 ff c3 lis r3,-61 <== NOT EXECUTED
ffc1eb1c: 38 63 51 78 addi r3,r3,20856 <== NOT EXECUTED
ffc1eb20: 48 00 03 68 b ffc1ee88 <rtems_rfs_fs_open+0x534> <== NOT EXECUTED
rc, strerror (rc));
return rc;
}
sb = rtems_rfs_buffer_data (&handle);
ffc1eb24: 81 21 00 10 lwz r9,16(r1)
ffc1eb28: 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)
ffc1eb2c: 89 3d 00 00 lbz r9,0(r29)
ffc1eb30: 88 1d 00 01 lbz r0,1(r29)
ffc1eb34: 55 29 c0 0e rlwinm r9,r9,24,0,7
ffc1eb38: 54 00 80 1e rlwinm r0,r0,16,0,15
ffc1eb3c: 7d 29 03 78 or r9,r9,r0
ffc1eb40: 88 1d 00 03 lbz r0,3(r29)
ffc1eb44: 7d 29 03 78 or r9,r9,r0
ffc1eb48: 88 1d 00 02 lbz r0,2(r29)
ffc1eb4c: 54 00 40 2e rlwinm r0,r0,8,0,23
ffc1eb50: 7d 29 03 78 or r9,r9,r0
ffc1eb54: 6d 20 28 09 xoris r0,r9,10249
ffc1eb58: 2f 80 20 01 cmpwi cr7,r0,8193
ffc1eb5c: 41 9e 00 24 beq- cr7,ffc1eb80 <rtems_rfs_fs_open+0x22c> <== ALWAYS TAKEN
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
ffc1eb60: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc1eb64: 38 80 00 01 li r4,1 <== NOT EXECUTED
ffc1eb68: 4b ff 47 9d bl ffc13304 <rtems_rfs_trace> <== NOT EXECUTED
ffc1eb6c: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc1eb70: 41 be 01 40 beq+ cr7,ffc1ecb0 <rtems_rfs_fs_open+0x35c> <== NOT EXECUTED
printf ("rtems-rfs: read-superblock: invalid superblock, bad magic\n");
ffc1eb74: 3c 60 ff c3 lis r3,-61 <== NOT EXECUTED
ffc1eb78: 38 63 51 aa addi r3,r3,20906 <== NOT EXECUTED
ffc1eb7c: 48 00 00 ac b ffc1ec28 <rtems_rfs_fs_open+0x2d4> <== NOT EXECUTED
rtems_rfs_buffer_handle_close (fs, &handle);
return EIO;
}
fs->blocks = read_sb (RTEMS_RFS_SB_OFFSET_BLOCKS);
ffc1eb80: 89 7d 00 0c lbz r11,12(r29)
ffc1eb84: 88 1d 00 0d lbz r0,13(r29)
ffc1eb88: 55 6b c0 0e rlwinm r11,r11,24,0,7
ffc1eb8c: 54 00 80 1e rlwinm r0,r0,16,0,15
ffc1eb90: 7d 6b 03 78 or r11,r11,r0
ffc1eb94: 88 1d 00 0f lbz r0,15(r29)
ffc1eb98: 7d 6b 03 78 or r11,r11,r0
ffc1eb9c: 88 1d 00 0e lbz r0,14(r29)
ffc1eba0: 54 00 40 2e rlwinm r0,r0,8,0,23
ffc1eba4: 7d 6b 03 78 or r11,r11,r0
ffc1eba8: 91 7f 00 04 stw r11,4(r31)
fs->block_size = read_sb (RTEMS_RFS_SB_OFFSET_BLOCK_SIZE);
ffc1ebac: 89 3d 00 08 lbz r9,8(r29)
ffc1ebb0: 88 1d 00 09 lbz r0,9(r29)
ffc1ebb4: 55 29 c0 0e rlwinm r9,r9,24,0,7
ffc1ebb8: 54 00 80 1e rlwinm r0,r0,16,0,15
ffc1ebbc: 7d 20 03 78 or r0,r9,r0
ffc1ebc0: 89 3d 00 0b lbz r9,11(r29)
ffc1ebc4: 7c 00 4b 78 or r0,r0,r9
ffc1ebc8: 89 3d 00 0a lbz r9,10(r29)
ffc1ebcc: 55 29 40 2e rlwinm r9,r9,8,0,23
ffc1ebd0: 7c 00 4b 78 or r0,r0,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);
ffc1ebd4: 81 3f 00 0c lwz r9,12(r31)
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;
ffc1ebd8: 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);
ffc1ebdc: 90 1f 00 08 stw r0,8(r31)
}
uint64_t
rtems_rfs_fs_media_size (rtems_rfs_file_system* fs)
{
uint64_t media_blocks = (uint64_t) rtems_rfs_fs_media_blocks (fs);
ffc1ebe0: 80 e9 00 1c lwz r7,28(r9)
uint64_t media_block_size = (uint64_t) rtems_rfs_fs_media_block_size (fs);
ffc1ebe4: 80 c9 00 24 lwz r6,36(r9)
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;
ffc1ebe8: 7d 20 59 d6 mullw r9,r0,r11
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;
ffc1ebec: 7d 46 38 16 mulhwu r10,r6,r7
ffc1ebf0: 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))
ffc1ebf4: 7f 88 50 40 cmplw cr7,r8,r10
ffc1ebf8: 41 9d 00 14 bgt- cr7,ffc1ec0c <rtems_rfs_fs_open+0x2b8> <== NEVER TAKEN
ffc1ebfc: 7f 88 50 00 cmpw cr7,r8,r10
ffc1ec00: 40 9e 00 30 bne- cr7,ffc1ec30 <rtems_rfs_fs_open+0x2dc> <== NEVER TAKEN
ffc1ec04: 7f 89 58 40 cmplw cr7,r9,r11
ffc1ec08: 40 9d 00 28 ble- cr7,ffc1ec30 <rtems_rfs_fs_open+0x2dc> <== ALWAYS TAKEN
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
ffc1ec0c: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc1ec10: 38 80 00 01 li r4,1 <== NOT EXECUTED
ffc1ec14: 4b ff 46 f1 bl ffc13304 <rtems_rfs_trace> <== NOT EXECUTED
ffc1ec18: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc1ec1c: 41 be 00 94 beq+ cr7,ffc1ecb0 <rtems_rfs_fs_open+0x35c> <== NOT EXECUTED
printf ("rtems-rfs: read-superblock: invalid superblock block/size count\n");
ffc1ec20: 3c 60 ff c3 lis r3,-61 <== NOT EXECUTED
ffc1ec24: 38 63 51 e4 addi r3,r3,20964 <== NOT EXECUTED
ffc1ec28: 48 00 40 75 bl ffc22c9c <puts> <== NOT EXECUTED
ffc1ec2c: 48 00 00 84 b ffc1ecb0 <rtems_rfs_fs_open+0x35c> <== NOT EXECUTED
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)
ffc1ec30: 89 5d 00 24 lbz r10,36(r29)
ffc1ec34: 89 3d 00 25 lbz r9,37(r29)
ffc1ec38: 55 4a c0 0e rlwinm r10,r10,24,0,7
ffc1ec3c: 55 29 80 1e rlwinm r9,r9,16,0,15
ffc1ec40: 7d 4a 4b 78 or r10,r10,r9
ffc1ec44: 89 3d 00 27 lbz r9,39(r29)
ffc1ec48: 7d 4a 4b 78 or r10,r10,r9
ffc1ec4c: 89 3d 00 26 lbz r9,38(r29)
ffc1ec50: 55 29 40 2e rlwinm r9,r9,8,0,23
ffc1ec54: 7d 4a 4b 78 or r10,r10,r9
ffc1ec58: 2f 8a 00 38 cmpwi cr7,r10,56
ffc1ec5c: 41 9e 00 68 beq- cr7,ffc1ecc4 <rtems_rfs_fs_open+0x370> <== ALWAYS TAKEN
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
ffc1ec60: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc1ec64: 38 80 00 01 li r4,1 <== NOT EXECUTED
ffc1ec68: 4b ff 46 9d bl ffc13304 <rtems_rfs_trace> <== NOT EXECUTED
ffc1ec6c: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc1ec70: 41 be 00 40 beq+ cr7,ffc1ecb0 <rtems_rfs_fs_open+0x35c> <== 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);
ffc1ec74: 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",
ffc1ec78: 3c 60 ff c3 lis r3,-61 <== NOT EXECUTED
read_sb (RTEMS_RFS_SB_OFFSET_VERSION), RTEMS_RFS_VERSION_MASK);
ffc1ec7c: 88 1d 00 05 lbz r0,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",
ffc1ec80: 38 63 52 24 addi r3,r3,21028 <== NOT EXECUTED
read_sb (RTEMS_RFS_SB_OFFSET_VERSION), RTEMS_RFS_VERSION_MASK);
ffc1ec84: 54 84 c0 0e rlwinm r4,r4,24,0,7 <== NOT EXECUTED
ffc1ec88: 54 00 80 1e rlwinm r0,r0,16,0,15 <== NOT EXECUTED
ffc1ec8c: 7c 84 03 78 or r4,r4,r0 <== NOT EXECUTED
ffc1ec90: 88 1d 00 07 lbz r0,7(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",
ffc1ec94: 38 a0 00 00 li r5,0 <== NOT EXECUTED
read_sb (RTEMS_RFS_SB_OFFSET_VERSION), RTEMS_RFS_VERSION_MASK);
ffc1ec98: 7c 84 03 78 or r4,r4,r0 <== NOT EXECUTED
ffc1ec9c: 88 1d 00 06 lbz r0,6(r29) <== NOT EXECUTED
ffc1eca0: 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",
ffc1eca4: 7c 84 03 78 or r4,r4,r0 <== NOT EXECUTED
ffc1eca8: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc1ecac: 48 00 3e 3d bl ffc22ae8 <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);
ffc1ecb0: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc1ecb4: 38 81 00 08 addi r4,r1,8 <== NOT EXECUTED
ffc1ecb8: 4b ff d3 51 bl ffc1c008 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
read_sb (RTEMS_RFS_SB_OFFSET_VERSION), RTEMS_RFS_VERSION_MASK);
rtems_rfs_buffer_handle_close (fs, &handle);
return EIO;
ffc1ecbc: 3b 80 00 05 li r28,5 <== NOT EXECUTED
ffc1ecc0: 48 00 02 ec b ffc1efac <rtems_rfs_fs_open+0x658> <== NOT EXECUTED
}
fs->bad_blocks = read_sb (RTEMS_RFS_SB_OFFSET_BAD_BLOCKS);
ffc1ecc4: 89 7d 00 10 lbz r11,16(r29)
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;
ffc1ecc8: 7d 40 53 96 divwu r10,r0,r10
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);
ffc1eccc: 89 3d 00 11 lbz r9,17(r29)
ffc1ecd0: 55 6b c0 0e rlwinm r11,r11,24,0,7
ffc1ecd4: 55 29 80 1e rlwinm r9,r9,16,0,15
ffc1ecd8: 7d 69 4b 78 or r9,r11,r9
ffc1ecdc: 89 7d 00 13 lbz r11,19(r29)
ffc1ece0: 7f e3 fb 78 mr r3,r31
ffc1ece4: 7d 29 5b 78 or r9,r9,r11
ffc1ece8: 89 7d 00 12 lbz r11,18(r29)
ffc1ecec: 38 81 00 08 addi r4,r1,8
ffc1ecf0: 55 6b 40 2e rlwinm r11,r11,8,0,23
ffc1ecf4: 7d 29 5b 78 or r9,r9,r11
ffc1ecf8: 91 3f 00 14 stw r9,20(r31)
fs->max_name_length = read_sb (RTEMS_RFS_SB_OFFSET_MAX_NAME_LENGTH);
ffc1ecfc: 89 7d 00 14 lbz r11,20(r29)
ffc1ed00: 89 3d 00 15 lbz r9,21(r29)
ffc1ed04: 55 6b c0 0e rlwinm r11,r11,24,0,7
ffc1ed08: 55 29 80 1e rlwinm r9,r9,16,0,15
ffc1ed0c: 7d 69 4b 78 or r9,r11,r9
ffc1ed10: 89 7d 00 17 lbz r11,23(r29)
ffc1ed14: 7d 29 5b 78 or r9,r9,r11
ffc1ed18: 89 7d 00 16 lbz r11,22(r29)
ffc1ed1c: 55 6b 40 2e rlwinm r11,r11,8,0,23
ffc1ed20: 7d 29 5b 78 or r9,r9,r11
ffc1ed24: 91 3f 00 18 stw r9,24(r31)
fs->group_count = read_sb (RTEMS_RFS_SB_OFFSET_GROUPS);
ffc1ed28: 89 1d 00 18 lbz r8,24(r29)
ffc1ed2c: 89 3d 00 19 lbz r9,25(r29)
ffc1ed30: 55 08 c0 0e rlwinm r8,r8,24,0,7
ffc1ed34: 55 29 80 1e rlwinm r9,r9,16,0,15
ffc1ed38: 7d 08 4b 78 or r8,r8,r9
ffc1ed3c: 89 3d 00 1b lbz r9,27(r29)
ffc1ed40: 7d 08 4b 78 or r8,r8,r9
ffc1ed44: 89 3d 00 1a lbz r9,26(r29)
ffc1ed48: 55 29 40 2e rlwinm r9,r9,8,0,23
ffc1ed4c: 7d 08 4b 78 or r8,r8,r9
ffc1ed50: 91 1f 00 20 stw r8,32(r31)
fs->group_blocks = read_sb (RTEMS_RFS_SB_OFFSET_GROUP_BLOCKS);
ffc1ed54: 89 7d 00 1c lbz r11,28(r29)
ffc1ed58: 89 3d 00 1d lbz r9,29(r29)
ffc1ed5c: 55 6b c0 0e rlwinm r11,r11,24,0,7
ffc1ed60: 55 29 80 1e rlwinm r9,r9,16,0,15
ffc1ed64: 7d 6b 4b 78 or r11,r11,r9
ffc1ed68: 89 3d 00 1f lbz r9,31(r29)
ffc1ed6c: 7d 6b 4b 78 or r11,r11,r9
ffc1ed70: 89 3d 00 1e lbz r9,30(r29)
ffc1ed74: 55 29 40 2e rlwinm r9,r9,8,0,23
ffc1ed78: 7d 6b 4b 78 or r11,r11,r9
ffc1ed7c: 91 7f 00 24 stw r11,36(r31)
fs->group_inodes = read_sb (RTEMS_RFS_SB_OFFSET_GROUP_INODES);
ffc1ed80: 88 fd 00 20 lbz r7,32(r29)
ffc1ed84: 89 3d 00 21 lbz r9,33(r29)
ffc1ed88: 54 e7 c0 0e rlwinm r7,r7,24,0,7
ffc1ed8c: 55 29 80 1e rlwinm r9,r9,16,0,15
ffc1ed90: 7c e7 4b 78 or r7,r7,r9
ffc1ed94: 89 3d 00 23 lbz r9,35(r29)
ffc1ed98: 7c e7 4b 78 or r7,r7,r9
ffc1ed9c: 89 3d 00 22 lbz r9,34(r29)
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;
ffc1eda0: 91 5f 00 2c stw r10,44(r31)
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);
ffc1eda4: 55 29 40 2e rlwinm r9,r9,8,0,23
ffc1eda8: 7c e7 4b 78 or r7,r7,r9
fs->blocks_per_block =
rtems_rfs_fs_block_size (fs) / sizeof (rtems_rfs_inode_block);
ffc1edac: 54 09 f0 be rlwinm r9,r0,30,2,31
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);
ffc1edb0: 90 ff 00 28 stw r7,40(r31)
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)))
ffc1edb4: 54 00 18 38 rlwinm r0,r0,3,0,28
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;
ffc1edb8: 1c c9 00 05 mulli r6,r9,5
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);
fs->blocks_per_block =
ffc1edbc: 91 3f 00 30 stw r9,48(r31)
fs->inodes = fs->group_count * fs->group_inodes;
fs->inodes_per_block = fs->block_size / RTEMS_RFS_INODE_SIZE;
if (fs->group_blocks >
ffc1edc0: 7f 8b 00 40 cmplw cr7,r11,r0
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 =
ffc1edc4: 90 df 00 34 stw r6,52(r31)
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;
ffc1edc8: 7d 29 49 d6 mullw r9,r9,r9
fs->inodes = fs->group_count * fs->group_inodes;
ffc1edcc: 7d 07 41 d6 mullw r8,r7,r8
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;
ffc1edd0: 1d 29 00 05 mulli r9,r9,5
fs->inodes = fs->group_count * fs->group_inodes;
ffc1edd4: 91 1f 00 10 stw r8,16(r31)
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;
fs->block_map_doubly_blocks =
ffc1edd8: 91 3f 00 38 stw r9,56(r31)
fs->inodes = fs->group_count * fs->group_inodes;
fs->inodes_per_block = fs->block_size / RTEMS_RFS_INODE_SIZE;
if (fs->group_blocks >
ffc1eddc: 40 9d 00 40 ble- cr7,ffc1ee1c <rtems_rfs_fs_open+0x4c8> <== ALWAYS TAKEN
ffc1ede0: 4b ff d2 29 bl ffc1c008 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
handle->dirty = false;
ffc1ede4: 38 00 00 00 li r0,0 <== NOT EXECUTED
ffc1ede8: 98 01 00 08 stb r0,8(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))
ffc1edec: 38 60 00 00 li r3,0 <== NOT EXECUTED
handle->bnum = 0;
ffc1edf0: 38 00 00 00 li r0,0 <== NOT EXECUTED
ffc1edf4: 38 80 00 01 li r4,1 <== NOT EXECUTED
ffc1edf8: 90 01 00 0c stw r0,12(r1) <== NOT EXECUTED
printf ("rtems-rfs: read-superblock: groups blocks larger than block bits\n");
return EIO;
ffc1edfc: 3b 80 00 05 li r28,5 <== NOT EXECUTED
handle->buffer = NULL;
ffc1ee00: 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))
ffc1ee04: 4b ff 45 01 bl ffc13304 <rtems_rfs_trace> <== NOT EXECUTED
ffc1ee08: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc1ee0c: 41 be 01 a0 beq+ cr7,ffc1efac <rtems_rfs_fs_open+0x658> <== NOT EXECUTED
printf ("rtems-rfs: read-superblock: groups blocks larger than block bits\n");
ffc1ee10: 3c 60 ff c3 lis r3,-61 <== NOT EXECUTED
ffc1ee14: 38 63 52 68 addi r3,r3,21096 <== NOT EXECUTED
ffc1ee18: 48 00 00 d8 b ffc1eef0 <rtems_rfs_fs_open+0x59c> <== 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);
ffc1ee1c: 4b ff d1 ed bl ffc1c008 <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));
ffc1ee20: 80 9f 00 08 lwz r4,8(r31)
handle->dirty = false;
ffc1ee24: 38 00 00 00 li r0,0
handle->bnum = 0;
ffc1ee28: 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;
ffc1ee2c: 98 01 00 08 stb r0,8(r1)
ffc1ee30: 7f e3 fb 78 mr r3,r31
handle->bnum = 0;
ffc1ee34: 93 a1 00 0c stw r29,12(r1)
handle->buffer = NULL;
ffc1ee38: 93 a1 00 10 stw r29,16(r1)
ffc1ee3c: 4b ff d8 c5 bl ffc1c700 <rtems_rfs_buffer_setblksize>
if (rc > 0)
ffc1ee40: 7c 7c 1b 79 mr. r28,r3
ffc1ee44: 40 81 00 54 ble- ffc1ee98 <rtems_rfs_fs_open+0x544> <== 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);
ffc1ee48: 38 81 00 08 addi r4,r1,8 <== NOT EXECUTED
ffc1ee4c: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc1ee50: 4b ff d1 b9 bl ffc1c008 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
{
rtems_rfs_buffer_handle_close (fs, &handle);
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
ffc1ee54: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc1ee58: 38 80 00 01 li r4,1 <== NOT EXECUTED
handle->dirty = false;
ffc1ee5c: 9b a1 00 08 stb r29,8(r1) <== NOT EXECUTED
handle->bnum = 0;
ffc1ee60: 93 a1 00 0c stw r29,12(r1) <== NOT EXECUTED
handle->buffer = NULL;
ffc1ee64: 93 a1 00 10 stw r29,16(r1) <== NOT EXECUTED
ffc1ee68: 4b ff 44 9d bl ffc13304 <rtems_rfs_trace> <== NOT EXECUTED
ffc1ee6c: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc1ee70: 41 be 01 3c beq+ cr7,ffc1efac <rtems_rfs_fs_open+0x658> <== NOT EXECUTED
printf ("rtems-rfs: read-superblock: invalid superblock block size%d: %s\n",
ffc1ee74: 7f 83 e3 78 mr r3,r28 <== NOT EXECUTED
ffc1ee78: 48 00 49 dd bl ffc23854 <strerror> <== NOT EXECUTED
ffc1ee7c: 7c 65 1b 78 mr r5,r3 <== NOT EXECUTED
ffc1ee80: 3c 60 ff c3 lis r3,-61 <== NOT EXECUTED
ffc1ee84: 38 63 52 a9 addi r3,r3,21161 <== NOT EXECUTED
ffc1ee88: 7f 84 e3 78 mr r4,r28 <== NOT EXECUTED
ffc1ee8c: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc1ee90: 48 00 3c 59 bl ffc22ae8 <printf> <== NOT EXECUTED
ffc1ee94: 48 00 01 18 b ffc1efac <rtems_rfs_fs_open+0x658> <== NOT EXECUTED
rc, strerror (rc));
return rc;
}
fs->groups = calloc (fs->group_count, sizeof (rtems_rfs_group));
ffc1ee98: 80 7f 00 20 lwz r3,32(r31)
ffc1ee9c: 38 80 00 50 li r4,80
if (!fs->groups)
ffc1eea0: 3b a0 00 00 li r29,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));
ffc1eea4: 4b fe 85 35 bl ffc073d8 <calloc>
if (!fs->groups)
ffc1eea8: 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));
ffc1eeac: 90 7f 00 1c stw r3,28(r31)
ffc1eeb0: 7c 7c 1b 78 mr r28,r3
if (!fs->groups)
ffc1eeb4: 40 be 00 e8 bne+ cr7,ffc1ef9c <rtems_rfs_fs_open+0x648> <== 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);
ffc1eeb8: 38 81 00 08 addi r4,r1,8 <== NOT EXECUTED
ffc1eebc: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc1eec0: 4b ff d1 49 bl ffc1c008 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
{
rtems_rfs_buffer_handle_close (fs, &handle);
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
ffc1eec4: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc1eec8: 38 80 00 01 li r4,1 <== NOT EXECUTED
handle->dirty = false;
ffc1eecc: 9b 81 00 08 stb r28,8(r1) <== NOT EXECUTED
handle->bnum = 0;
ffc1eed0: 93 81 00 0c stw r28,12(r1) <== NOT EXECUTED
handle->buffer = NULL;
ffc1eed4: 93 81 00 10 stw r28,16(r1) <== NOT EXECUTED
ffc1eed8: 4b ff 44 2d bl ffc13304 <rtems_rfs_trace> <== NOT EXECUTED
ffc1eedc: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
printf ("rtems-rfs: read-superblock: no memory for group table\n");
return ENOMEM;
ffc1eee0: 3b 80 00 0c li r28,12 <== 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))
ffc1eee4: 41 be 00 c8 beq+ cr7,ffc1efac <rtems_rfs_fs_open+0x658> <== NOT EXECUTED
printf ("rtems-rfs: read-superblock: no memory for group table\n");
ffc1eee8: 3c 60 ff c3 lis r3,-61 <== NOT EXECUTED
ffc1eeec: 38 63 52 ea addi r3,r3,21226 <== NOT EXECUTED
ffc1eef0: 48 00 3d ad bl ffc22c9c <puts> <== NOT EXECUTED
ffc1eef4: 48 00 00 b8 b ffc1efac <rtems_rfs_fs_open+0x658> <== NOT EXECUTED
* close everything.
*/
for (group = 0; group < fs->group_count; group++)
{
rc = rtems_rfs_group_open (fs,
rtems_rfs_fs_block (fs, group, 0),
ffc1eef8: 80 bf 00 24 lwz r5,36(r31)
return 0;
}
int
rtems_rfs_fs_open (const char* name,
ffc1eefc: 1c 1d 00 50 mulli r0,r29,80
* 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,
ffc1ef00: 80 ff 00 1c lwz r7,28(r31)
rtems_rfs_fs_block (fs, group, 0),
ffc1ef04: 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,
ffc1ef08: 80 df 00 28 lwz r6,40(r31)
ffc1ef0c: 7f e3 fb 78 mr r3,r31
ffc1ef10: 38 84 00 01 addi r4,r4,1
ffc1ef14: 7c e7 02 14 add r7,r7,r0
ffc1ef18: 4b ff 1b a5 bl ffc10abc <rtems_rfs_group_open>
rtems_rfs_fs_block (fs, group, 0),
fs->group_blocks,
fs->group_inodes,
&fs->groups[group]);
if (rc > 0)
ffc1ef1c: 7c 7c 1b 79 mr. r28,r3
ffc1ef20: 40 a1 00 78 ble+ ffc1ef98 <rtems_rfs_fs_open+0x644> <== ALWAYS TAKEN
ffc1ef24: 3b 60 00 00 li r27,0 <== NOT EXECUTED
ffc1ef28: 48 00 00 1c b ffc1ef44 <rtems_rfs_fs_open+0x5f0> <== NOT EXECUTED
return 0;
}
int
rtems_rfs_fs_open (const char* name,
ffc1ef2c: 1c 1b 00 50 mulli r0,r27,80 <== NOT EXECUTED
&fs->groups[group]);
if (rc > 0)
{
int g;
for (g = 0; g < group; g++)
rtems_rfs_group_close (fs, &fs->groups[g]);
ffc1ef30: 80 9f 00 1c lwz r4,28(r31) <== NOT EXECUTED
ffc1ef34: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc1ef38: 7c 84 02 14 add r4,r4,r0 <== NOT EXECUTED
ffc1ef3c: 4b ff 1d a1 bl ffc10cdc <rtems_rfs_group_close> <== NOT EXECUTED
fs->group_inodes,
&fs->groups[group]);
if (rc > 0)
{
int g;
for (g = 0; g < group; g++)
ffc1ef40: 3b 7b 00 01 addi r27,r27,1 <== NOT EXECUTED
ffc1ef44: 7f 9b e8 00 cmpw cr7,r27,r29 <== NOT EXECUTED
ffc1ef48: 41 9c ff e4 blt+ cr7,ffc1ef2c <rtems_rfs_fs_open+0x5d8> <== 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);
ffc1ef4c: 38 81 00 08 addi r4,r1,8 <== NOT EXECUTED
ffc1ef50: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc1ef54: 4b ff d0 b5 bl ffc1c008 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
handle->dirty = false;
ffc1ef58: 38 00 00 00 li r0,0 <== NOT EXECUTED
ffc1ef5c: 98 01 00 08 stb r0,8(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))
ffc1ef60: 38 60 00 00 li r3,0 <== NOT EXECUTED
handle->bnum = 0;
ffc1ef64: 38 00 00 00 li r0,0 <== NOT EXECUTED
ffc1ef68: 38 80 00 01 li r4,1 <== NOT EXECUTED
ffc1ef6c: 90 01 00 0c stw r0,12(r1) <== NOT EXECUTED
handle->buffer = NULL;
ffc1ef70: 90 01 00 10 stw r0,16(r1) <== NOT EXECUTED
ffc1ef74: 4b ff 43 91 bl ffc13304 <rtems_rfs_trace> <== NOT EXECUTED
ffc1ef78: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc1ef7c: 41 be 00 30 beq+ cr7,ffc1efac <rtems_rfs_fs_open+0x658> <== NOT EXECUTED
printf ("rtems-rfs: read-superblock: no memory for group table%d: %s\n",
ffc1ef80: 7f 83 e3 78 mr r3,r28 <== NOT EXECUTED
ffc1ef84: 48 00 48 d1 bl ffc23854 <strerror> <== NOT EXECUTED
ffc1ef88: 7c 65 1b 78 mr r5,r3 <== NOT EXECUTED
ffc1ef8c: 3c 60 ff c3 lis r3,-61 <== NOT EXECUTED
ffc1ef90: 38 63 53 20 addi r3,r3,21280 <== NOT EXECUTED
ffc1ef94: 4b ff fe f4 b ffc1ee88 <rtems_rfs_fs_open+0x534> <== NOT EXECUTED
/*
* 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++)
ffc1ef98: 3b bd 00 01 addi r29,r29,1
ffc1ef9c: 80 1f 00 20 lwz r0,32(r31)
ffc1efa0: 7f 9d 00 00 cmpw cr7,r29,r0
ffc1efa4: 41 9c ff 54 blt+ cr7,ffc1eef8 <rtems_rfs_fs_open+0x5a4>
ffc1efa8: 48 00 01 8c b ffc1f134 <rtems_rfs_fs_open+0x7e0>
}
rc = rtems_rfs_fs_read_superblock (*fs);
if (rc > 0)
{
rtems_rfs_buffer_close (*fs);
ffc1efac: 80 7e 00 00 lwz r3,0(r30) <== NOT EXECUTED
ffc1efb0: 4b ff d8 4d bl ffc1c7fc <rtems_rfs_buffer_close> <== NOT EXECUTED
free (*fs);
ffc1efb4: 80 7e 00 00 lwz r3,0(r30) <== NOT EXECUTED
ffc1efb8: 4b fe 89 31 bl ffc078e8 <free> <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
ffc1efbc: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc1efc0: 38 80 00 01 li r4,1 <== NOT EXECUTED
ffc1efc4: 4b ff 43 41 bl ffc13304 <rtems_rfs_trace> <== NOT EXECUTED
ffc1efc8: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc1efcc: 41 be 00 24 beq+ cr7,ffc1eff0 <rtems_rfs_fs_open+0x69c> <== NOT EXECUTED
printf ("rtems-rfs: open: reading superblock: %d: %s\n",
ffc1efd0: 7f 83 e3 78 mr r3,r28 <== NOT EXECUTED
ffc1efd4: 48 00 48 81 bl ffc23854 <strerror> <== NOT EXECUTED
ffc1efd8: 7f 84 e3 78 mr r4,r28 <== NOT EXECUTED
ffc1efdc: 7c 65 1b 78 mr r5,r3 <== NOT EXECUTED
ffc1efe0: 3c 60 ff c3 lis r3,-61 <== NOT EXECUTED
ffc1efe4: 38 63 53 5d addi r3,r3,21341 <== NOT EXECUTED
ffc1efe8: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc1efec: 48 00 3a fd bl ffc22ae8 <printf> <== NOT EXECUTED
rc, strerror (rc));
errno = rc;
ffc1eff0: 48 00 2a 15 bl ffc21a04 <__errno> <== NOT EXECUTED
ffc1eff4: 93 83 00 00 stw r28,0(r3) <== NOT EXECUTED
ffc1eff8: 4b ff fa d0 b ffc1eac8 <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);
ffc1effc: 80 7e 00 00 lwz r3,0(r30) <== NOT EXECUTED
ffc1f000: 4b ff d7 fd bl ffc1c7fc <rtems_rfs_buffer_close> <== NOT EXECUTED
free (*fs);
ffc1f004: 80 7e 00 00 lwz r3,0(r30) <== NOT EXECUTED
ffc1f008: 4b fe 88 e1 bl ffc078e8 <free> <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
ffc1f00c: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc1f010: 38 80 00 01 li r4,1 <== NOT EXECUTED
ffc1f014: 4b ff 42 f1 bl ffc13304 <rtems_rfs_trace> <== NOT EXECUTED
ffc1f018: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc1f01c: 41 be 00 f4 beq+ cr7,ffc1f110 <rtems_rfs_fs_open+0x7bc> <== NOT EXECUTED
printf ("rtems-rfs: open: reading root inode: %d: %s\n",
ffc1f020: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc1f024: 48 00 48 31 bl ffc23854 <strerror> <== NOT EXECUTED
ffc1f028: 7c 65 1b 78 mr r5,r3 <== NOT EXECUTED
ffc1f02c: 3c 60 ff c3 lis r3,-61 <== NOT EXECUTED
ffc1f030: 38 63 53 8a addi r3,r3,21386 <== NOT EXECUTED
ffc1f034: 48 00 00 d0 b ffc1f104 <rtems_rfs_fs_open+0x7b0> <== NOT EXECUTED
rc, strerror (rc));
errno = rc;
return -1;
}
if (((*fs)->flags & RTEMS_RFS_FS_FORCE_OPEN) == 0)
ffc1f038: 80 7e 00 00 lwz r3,0(r30)
ffc1f03c: 80 03 00 00 lwz r0,0(r3)
ffc1f040: 70 09 00 04 andi. r9,r0,4
ffc1f044: 40 82 00 78 bne- ffc1f0bc <rtems_rfs_fs_open+0x768>
{
mode = rtems_rfs_inode_get_mode (&inode);
ffc1f048: 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);
ffc1f04c: 88 09 00 02 lbz r0,2(r9)
ffc1f050: 89 29 00 03 lbz r9,3(r9)
ffc1f054: 54 00 40 2e rlwinm r0,r0,8,0,23
ffc1f058: 7c 00 4b 78 or r0,r0,r9
if ((mode == 0xffff) || !RTEMS_RFS_S_ISDIR (mode))
ffc1f05c: 6c 09 ff ff xoris r9,r0,65535
ffc1f060: 2f 89 ff ff cmpwi cr7,r9,-1
ffc1f064: 41 9e 00 10 beq- cr7,ffc1f074 <rtems_rfs_fs_open+0x720> <== NEVER TAKEN
ffc1f068: 54 00 04 26 rlwinm r0,r0,0,16,19
ffc1f06c: 2f 80 40 00 cmpwi cr7,r0,16384
ffc1f070: 41 be 00 4c beq+ cr7,ffc1f0bc <rtems_rfs_fs_open+0x768> <== ALWAYS TAKEN
{
rtems_rfs_inode_close (*fs, &inode);
ffc1f074: 38 81 00 14 addi r4,r1,20 <== NOT EXECUTED
ffc1f078: 4b ff 24 71 bl ffc114e8 <rtems_rfs_inode_close> <== NOT EXECUTED
rtems_rfs_buffer_close (*fs);
ffc1f07c: 80 7e 00 00 lwz r3,0(r30) <== NOT EXECUTED
ffc1f080: 4b ff d7 7d bl ffc1c7fc <rtems_rfs_buffer_close> <== NOT EXECUTED
free (*fs);
ffc1f084: 80 7e 00 00 lwz r3,0(r30) <== NOT EXECUTED
ffc1f088: 4b fe 88 61 bl ffc078e8 <free> <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
ffc1f08c: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc1f090: 38 80 00 01 li r4,1 <== NOT EXECUTED
ffc1f094: 4b ff 42 71 bl ffc13304 <rtems_rfs_trace> <== NOT EXECUTED
ffc1f098: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc1f09c: 41 be 00 10 beq+ cr7,ffc1f0ac <rtems_rfs_fs_open+0x758> <== NOT EXECUTED
printf ("rtems-rfs: open: invalid root inode mode\n");
ffc1f0a0: 3c 60 ff c3 lis r3,-61 <== NOT EXECUTED
ffc1f0a4: 38 63 53 b7 addi r3,r3,21431 <== NOT EXECUTED
ffc1f0a8: 48 00 3b f5 bl ffc22c9c <puts> <== NOT EXECUTED
errno = EIO;
ffc1f0ac: 48 00 29 59 bl ffc21a04 <__errno> <== NOT EXECUTED
ffc1f0b0: 38 00 00 05 li r0,5 <== NOT EXECUTED
ffc1f0b4: 90 03 00 00 stw r0,0(r3) <== NOT EXECUTED
ffc1f0b8: 4b ff fa 10 b ffc1eac8 <rtems_rfs_fs_open+0x174> <== NOT EXECUTED
return -1;
}
}
rc = rtems_rfs_inode_close (*fs, &inode);
ffc1f0bc: 38 81 00 14 addi r4,r1,20
ffc1f0c0: 4b ff 24 29 bl ffc114e8 <rtems_rfs_inode_close>
if (rc > 0)
ffc1f0c4: 7c 7f 1b 79 mr. r31,r3
ffc1f0c8: 40 a1 00 54 ble+ ffc1f11c <rtems_rfs_fs_open+0x7c8> <== ALWAYS TAKEN
{
rtems_rfs_buffer_close (*fs);
ffc1f0cc: 80 7e 00 00 lwz r3,0(r30) <== NOT EXECUTED
ffc1f0d0: 4b ff d7 2d bl ffc1c7fc <rtems_rfs_buffer_close> <== NOT EXECUTED
free (*fs);
ffc1f0d4: 80 7e 00 00 lwz r3,0(r30) <== NOT EXECUTED
ffc1f0d8: 4b fe 88 11 bl ffc078e8 <free> <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
ffc1f0dc: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc1f0e0: 38 80 00 01 li r4,1 <== NOT EXECUTED
ffc1f0e4: 4b ff 42 21 bl ffc13304 <rtems_rfs_trace> <== NOT EXECUTED
ffc1f0e8: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc1f0ec: 41 be 00 24 beq+ cr7,ffc1f110 <rtems_rfs_fs_open+0x7bc> <== NOT EXECUTED
printf ("rtems-rfs: open: closing root inode: %d: %s\n", rc, strerror (rc));
ffc1f0f0: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc1f0f4: 48 00 47 61 bl ffc23854 <strerror> <== NOT EXECUTED
ffc1f0f8: 7c 65 1b 78 mr r5,r3 <== NOT EXECUTED
ffc1f0fc: 3c 60 ff c3 lis r3,-61 <== NOT EXECUTED
ffc1f100: 38 63 53 e0 addi r3,r3,21472 <== NOT EXECUTED
ffc1f104: 7f e4 fb 78 mr r4,r31 <== NOT EXECUTED
ffc1f108: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc1f10c: 48 00 39 dd bl ffc22ae8 <printf> <== NOT EXECUTED
errno = rc;
ffc1f110: 48 00 28 f5 bl ffc21a04 <__errno> <== NOT EXECUTED
ffc1f114: 93 e3 00 00 stw r31,0(r3) <== NOT EXECUTED
ffc1f118: 4b ff f9 b0 b ffc1eac8 <rtems_rfs_fs_open+0x174> <== NOT EXECUTED
return -1;
}
errno = 0;
ffc1f11c: 48 00 28 e9 bl ffc21a04 <__errno>
ffc1f120: 38 00 00 00 li r0,0
ffc1f124: 90 03 00 00 stw r0,0(r3)
return 0;
ffc1f128: 38 60 00 00 li r3,0
}
ffc1f12c: 39 61 00 60 addi r11,r1,96
ffc1f130: 4b fe 39 b8 b ffc02ae8 <_restgpr_27_x>
rc, strerror (rc));
errno = rc;
return -1;
}
rc = rtems_rfs_inode_open (*fs, RTEMS_RFS_ROOT_INO, &inode, true);
ffc1f134: 80 7e 00 00 lwz r3,0(r30)
ffc1f138: 38 80 00 01 li r4,1
ffc1f13c: 38 a1 00 14 addi r5,r1,20
ffc1f140: 38 c0 00 01 li r6,1
ffc1f144: 4b ff 21 b5 bl ffc112f8 <rtems_rfs_inode_open>
if (rc > 0)
ffc1f148: 7c 7f 1b 79 mr. r31,r3
ffc1f14c: 40 81 fe ec ble+ ffc1f038 <rtems_rfs_fs_open+0x6e4> <== ALWAYS TAKEN
ffc1f150: 4b ff fe ac b ffc1effc <rtems_rfs_fs_open+0x6a8> <== NOT EXECUTED
ffc1e928 <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);
ffc1e928: 80 03 00 04 lwz r0,4(r3) <== NOT EXECUTED
uint64_t block_size = rtems_rfs_fs_block_size (fs);
ffc1e92c: 81 23 00 08 lwz r9,8(r3) <== NOT EXECUTED
return blocks * block_size;
ffc1e930: 7c 69 00 16 mulhwu r3,r9,r0 <== NOT EXECUTED
ffc1e934: 7c 89 01 d6 mullw r4,r9,r0 <== NOT EXECUTED
}
ffc1e938: 4e 80 00 20 blr <== NOT EXECUTED
ffc10d90 <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)
{
ffc10d90: 94 21 ff b0 stwu r1,-80(r1)
ffc10d94: 7d 80 00 26 mfcr r12
ffc10d98: 7c 08 02 a6 mflr r0
ffc10d9c: be 61 00 1c stmw r19,28(r1)
rtems_rfs_bitmap_bit bit;
int offset;
bool updown;
int direction;
if (inode)
ffc10da0: 7c b8 2b 79 mr. r24,r5
int
rtems_rfs_group_bitmap_alloc (rtems_rfs_file_system* fs,
rtems_rfs_bitmap_bit goal,
bool inode,
rtems_rfs_bitmap_bit* result)
{
ffc10da4: 7c 7f 1b 78 mr r31,r3
ffc10da8: 90 01 00 54 stw r0,84(r1)
ffc10dac: 7c d9 33 78 mr r25,r6
ffc10db0: 91 81 00 18 stw r12,24(r1)
rtems_rfs_bitmap_bit bit;
int offset;
bool updown;
int direction;
if (inode)
ffc10db4: 41 82 00 10 beq- ffc10dc4 <rtems_rfs_group_bitmap_alloc+0x34>
{
size = fs->group_inodes;
ffc10db8: 83 43 00 28 lwz r26,40(r3)
goal -= RTEMS_RFS_ROOT_INO;
ffc10dbc: 38 84 ff ff addi r4,r4,-1
ffc10dc0: 48 00 00 08 b ffc10dc8 <rtems_rfs_group_bitmap_alloc+0x38>
}
else
size = fs->group_blocks;
ffc10dc4: 83 43 00 24 lwz r26,36(r3)
group_start = goal / size;
ffc10dc8: 7e a4 d3 96 divwu r21,r4,r26
bit = (rtems_rfs_bitmap_bit) (goal % size);
ffc10dcc: 7c 15 d1 d6 mullw r0,r21,r26
ffc10dd0: 7c 37 0b 78 mr r23,r1
ffc10dd4: 7c 80 20 50 subf r4,r0,r4
ffc10dd8: 94 97 00 0c stwu r4,12(r23)
offset = 0;
updown = true;
direction = 1;
ffc10ddc: 3b c0 00 01 li r30,1
size = fs->group_blocks;
group_start = goal / size;
bit = (rtems_rfs_bitmap_bit) (goal % size);
offset = 0;
updown = true;
ffc10de0: 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;
ffc10de4: 3b 80 00 00 li r28,0
*/
while (true)
{
rtems_rfs_bitmap_control* bitmap;
int group;
bool allocated = false;
ffc10de8: 3a 80 00 00 li r20,0
direction = direction > 0 ? -1 : 1;
updown = false;
continue;
}
if (inode)
ffc10dec: 2e 18 00 00 cmpwi cr4,r24,0
ffc10df0: 48 00 00 0c b ffc10dfc <rtems_rfs_group_bitmap_alloc+0x6c>
*/
if ((group < 0) || (group >= fs->group_count))
{
if (!updown)
break;
direction = direction > 0 ? -1 : 1;
ffc10df4: 3b c0 ff ff li r30,-1 <== NOT EXECUTED
updown = false;
ffc10df8: 3b 60 00 00 li r27,0
/*
* 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)
ffc10dfc: 2f 9c 00 00 cmpwi cr7,r28,0
*/
while (true)
{
rtems_rfs_bitmap_control* bitmap;
int group;
bool allocated = false;
ffc10e00: 9a 81 00 08 stb r20,8(r1)
/*
* 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);
ffc10e04: 7f be e1 d6 mullw r29,r30,r28
ffc10e08: 7f b5 ea 14 add r29,r21,r29
if (offset)
ffc10e0c: 41 9e 00 18 beq- cr7,ffc10e24 <rtems_rfs_group_bitmap_alloc+0x94>
bit = direction > 0 ? 0 : size - 1;
ffc10e10: 2f 9e 00 01 cmpwi cr7,r30,1
ffc10e14: 38 00 00 00 li r0,0
ffc10e18: 41 be 00 08 beq+ cr7,ffc10e20 <rtems_rfs_group_bitmap_alloc+0x90>
ffc10e1c: 38 1a ff ff addi r0,r26,-1
ffc10e20: 90 01 00 0c stw r0,12(r1)
/*
* 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))
ffc10e24: 2f 9d 00 00 cmpwi cr7,r29,0
ffc10e28: 41 9c 00 10 blt- cr7,ffc10e38 <rtems_rfs_group_bitmap_alloc+0xa8>
ffc10e2c: 80 1f 00 20 lwz r0,32(r31)
ffc10e30: 7f 9d 00 00 cmpw cr7,r29,r0
ffc10e34: 41 9c 00 1c blt- cr7,ffc10e50 <rtems_rfs_group_bitmap_alloc+0xc0>
{
if (!updown)
ffc10e38: 2f 9b 00 00 cmpwi cr7,r27,0
ffc10e3c: 41 9e 01 14 beq- cr7,ffc10f50 <rtems_rfs_group_bitmap_alloc+0x1c0>
break;
direction = direction > 0 ? -1 : 1;
ffc10e40: 2f 9e 00 01 cmpwi cr7,r30,1
ffc10e44: 41 9e ff b0 beq+ cr7,ffc10df4 <rtems_rfs_group_bitmap_alloc+0x64><== NEVER TAKEN
ffc10e48: 3b c0 00 01 li r30,1
ffc10e4c: 4b ff ff ac b ffc10df8 <rtems_rfs_group_bitmap_alloc+0x68>
ffc10e50: 1c 1d 00 50 mulli r0,r29,80
ffc10e54: 82 df 00 1c lwz r22,28(r31)
updown = false;
continue;
}
if (inode)
bitmap = &fs->groups[group].inode_bitmap;
ffc10e58: 7e d6 02 14 add r22,r22,r0
direction = direction > 0 ? -1 : 1;
updown = false;
continue;
}
if (inode)
ffc10e5c: 41 92 00 0c beq- cr4,ffc10e68 <rtems_rfs_group_bitmap_alloc+0xd8>
bitmap = &fs->groups[group].inode_bitmap;
ffc10e60: 3a d6 00 2c addi r22,r22,44
ffc10e64: 48 00 00 08 b ffc10e6c <rtems_rfs_group_bitmap_alloc+0xdc>
else
bitmap = &fs->groups[group].block_bitmap;
ffc10e68: 3a d6 00 08 addi r22,r22,8
rc = rtems_rfs_bitmap_map_alloc (bitmap, bit, &allocated, &bit);
ffc10e6c: 80 81 00 0c lwz r4,12(r1)
ffc10e70: 7e c3 b3 78 mr r3,r22
ffc10e74: 38 a1 00 08 addi r5,r1,8
ffc10e78: 7e e6 bb 78 mr r6,r23
ffc10e7c: 48 00 9c b9 bl ffc1ab34 <rtems_rfs_bitmap_map_alloc>
if (rc > 0)
ffc10e80: 7c 73 1b 79 mr. r19,r3
ffc10e84: 41 81 00 f0 bgt- ffc10f74 <rtems_rfs_group_bitmap_alloc+0x1e4><== NEVER TAKEN
return rc;
if (rtems_rfs_fs_release_bitmaps (fs))
ffc10e88: 80 1f 00 00 lwz r0,0(r31)
ffc10e8c: 70 09 00 01 andi. r9,r0,1
ffc10e90: 40 a2 00 10 bne+ ffc10ea0 <rtems_rfs_group_bitmap_alloc+0x110><== NEVER TAKEN
rtems_rfs_bitmap_release_buffer (fs, bitmap);
ffc10e94: 80 96 00 00 lwz r4,0(r22)
ffc10e98: 7f e3 fb 78 mr r3,r31
ffc10e9c: 48 00 b1 6d bl ffc1c008 <rtems_rfs_buffer_handle_release>
if (allocated)
ffc10ea0: 88 01 00 08 lbz r0,8(r1)
ffc10ea4: 2f 80 00 00 cmpwi cr7,r0,0
ffc10ea8: 41 be 00 88 beq+ cr7,ffc10f30 <rtems_rfs_group_bitmap_alloc+0x1a0>
{
if (inode)
ffc10eac: 2f 98 00 00 cmpwi cr7,r24,0
ffc10eb0: 81 21 00 0c lwz r9,12(r1)
ffc10eb4: 41 9e 00 18 beq- cr7,ffc10ecc <rtems_rfs_group_bitmap_alloc+0x13c>
*result = rtems_rfs_group_inode (fs, group, bit);
ffc10eb8: 80 1f 00 28 lwz r0,40(r31)
ffc10ebc: 39 29 00 01 addi r9,r9,1
ffc10ec0: 7f bd 01 d6 mullw r29,r29,r0
ffc10ec4: 7d 29 ea 14 add r9,r9,r29
ffc10ec8: 48 00 00 14 b ffc10edc <rtems_rfs_group_bitmap_alloc+0x14c>
else
*result = rtems_rfs_group_block (&fs->groups[group], bit);
ffc10ecc: 81 7f 00 1c lwz r11,28(r31)
ffc10ed0: 1f bd 00 50 mulli r29,r29,80
ffc10ed4: 7c 0b e8 2e lwzx r0,r11,r29
ffc10ed8: 7d 29 02 14 add r9,r9,r0
ffc10edc: 91 39 00 00 stw r9,0(r25)
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_BITMAPS))
ffc10ee0: 38 60 00 00 li r3,0
ffc10ee4: 3c 80 00 02 lis r4,2
ffc10ee8: 48 00 24 1d bl ffc13304 <rtems_rfs_trace>
printf ("rtems-rfs: group-bitmap-alloc: %s allocated: %" PRId32 "\n",
inode ? "inode" : "block", *result);
return 0;
ffc10eec: 3a 60 00 00 li r19,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))
ffc10ef0: 2f 83 00 00 cmpwi cr7,r3,0
ffc10ef4: 41 9e 00 80 beq- cr7,ffc10f74 <rtems_rfs_group_bitmap_alloc+0x1e4><== ALWAYS TAKEN
printf ("rtems-rfs: group-bitmap-alloc: %s allocated: %" PRId32 "\n",
ffc10ef8: 2f 98 00 00 cmpwi cr7,r24,0 <== NOT EXECUTED
ffc10efc: 41 be 00 10 beq+ cr7,ffc10f0c <rtems_rfs_group_bitmap_alloc+0x17c><== NOT EXECUTED
ffc10f00: 3c 80 ff c3 lis r4,-61 <== NOT EXECUTED
ffc10f04: 38 84 33 94 addi r4,r4,13204 <== NOT EXECUTED
ffc10f08: 48 00 00 0c b ffc10f14 <rtems_rfs_group_bitmap_alloc+0x184><== NOT EXECUTED
ffc10f0c: 3c 80 ff c3 lis r4,-61 <== NOT EXECUTED
ffc10f10: 38 84 2a f9 addi r4,r4,11001 <== NOT EXECUTED
ffc10f14: 3c 60 ff c3 lis r3,-61 <== NOT EXECUTED
ffc10f18: 80 b9 00 00 lwz r5,0(r25) <== NOT EXECUTED
ffc10f1c: 38 63 33 9a addi r3,r3,13210 <== NOT EXECUTED
ffc10f20: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc10f24: 48 01 1b c5 bl ffc22ae8 <printf> <== NOT EXECUTED
inode ? "inode" : "block", *result);
return 0;
ffc10f28: 3a 60 00 00 li r19,0 <== NOT EXECUTED
ffc10f2c: 48 00 00 48 b ffc10f74 <rtems_rfs_group_bitmap_alloc+0x1e4><== NOT EXECUTED
}
if (updown)
ffc10f30: 2f 9b 00 00 cmpwi cr7,r27,0
ffc10f34: 41 9e 00 14 beq- cr7,ffc10f48 <rtems_rfs_group_bitmap_alloc+0x1b8><== NEVER TAKEN
direction = direction > 0 ? -1 : 1;
ffc10f38: 6b de 00 01 xori r30,r30,1
ffc10f3c: 33 de ff ff addic r30,r30,-1
ffc10f40: 7f de f1 10 subfe r30,r30,r30
ffc10f44: 63 de 00 01 ori r30,r30,1
offset++;
ffc10f48: 3b 9c 00 01 addi r28,r28,1
ffc10f4c: 4b ff fe b0 b ffc10dfc <rtems_rfs_group_bitmap_alloc+0x6c>
}
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_BITMAPS))
ffc10f50: 38 60 00 00 li r3,0
ffc10f54: 3c 80 00 02 lis r4,2
ffc10f58: 48 00 23 ad bl ffc13304 <rtems_rfs_trace>
printf ("rtems-rfs: group-bitmap-alloc: no blocks available\n");
return ENOSPC;
ffc10f5c: 3a 60 00 1c li r19,28
direction = direction > 0 ? -1 : 1;
offset++;
}
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_BITMAPS))
ffc10f60: 2f 83 00 00 cmpwi cr7,r3,0
ffc10f64: 41 be 00 10 beq+ cr7,ffc10f74 <rtems_rfs_group_bitmap_alloc+0x1e4><== ALWAYS TAKEN
printf ("rtems-rfs: group-bitmap-alloc: no blocks available\n");
ffc10f68: 3c 60 ff c3 lis r3,-61 <== NOT EXECUTED
ffc10f6c: 38 63 33 cc addi r3,r3,13260 <== NOT EXECUTED
ffc10f70: 48 01 1d 2d bl ffc22c9c <puts> <== NOT EXECUTED
return ENOSPC;
}
ffc10f74: 81 81 00 18 lwz r12,24(r1)
ffc10f78: 39 61 00 50 addi r11,r1,80
ffc10f7c: 7e 63 9b 78 mr r3,r19
ffc10f80: 7d 80 81 20 mtcrf 8,r12
ffc10f84: 4b ff 1b 44 b ffc02ac8 <_restgpr_19_x>
ffc10f88 <rtems_rfs_group_bitmap_free>:
int
rtems_rfs_group_bitmap_free (rtems_rfs_file_system* fs,
bool inode,
rtems_rfs_bitmap_bit no)
{
ffc10f88: 94 21 ff e8 stwu r1,-24(r1)
ffc10f8c: 7c 08 02 a6 mflr r0
ffc10f90: bf a1 00 0c stmw r29,12(r1)
ffc10f94: 7c 7f 1b 78 mr r31,r3
ffc10f98: 7c 9e 23 78 mr r30,r4
unsigned int group;
rtems_rfs_bitmap_bit bit;
size_t size;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_BITMAPS))
ffc10f9c: 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)
{
ffc10fa0: 90 01 00 1c stw r0,28(r1)
unsigned int group;
rtems_rfs_bitmap_bit bit;
size_t size;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_BITMAPS))
ffc10fa4: 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)
{
ffc10fa8: 7c bd 2b 78 mr r29,r5
unsigned int group;
rtems_rfs_bitmap_bit bit;
size_t size;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_BITMAPS))
ffc10fac: 48 00 23 59 bl ffc13304 <rtems_rfs_trace>
ffc10fb0: 2f 83 00 00 cmpwi cr7,r3,0
ffc10fb4: 41 9e 00 34 beq- cr7,ffc10fe8 <rtems_rfs_group_bitmap_free+0x60><== ALWAYS TAKEN
printf ("rtems-rfs: group-bitmap-free: %s free: %" PRId32 "\n",
ffc10fb8: 2f 9e 00 00 cmpwi cr7,r30,0 <== NOT EXECUTED
ffc10fbc: 41 9e 00 10 beq- cr7,ffc10fcc <rtems_rfs_group_bitmap_free+0x44><== NOT EXECUTED
ffc10fc0: 3c 80 ff c3 lis r4,-61 <== NOT EXECUTED
ffc10fc4: 38 84 33 94 addi r4,r4,13204 <== NOT EXECUTED
ffc10fc8: 48 00 00 0c b ffc10fd4 <rtems_rfs_group_bitmap_free+0x4c><== NOT EXECUTED
ffc10fcc: 3c 80 ff c3 lis r4,-61 <== NOT EXECUTED
ffc10fd0: 38 84 2a f9 addi r4,r4,11001 <== NOT EXECUTED
ffc10fd4: 3c 60 ff c3 lis r3,-61 <== NOT EXECUTED
ffc10fd8: 38 63 33 ff addi r3,r3,13311 <== NOT EXECUTED
ffc10fdc: 7f a5 eb 78 mr r5,r29 <== NOT EXECUTED
ffc10fe0: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc10fe4: 48 01 1b 05 bl ffc22ae8 <printf> <== NOT EXECUTED
inode ? "inode" : "block", no);
if (inode)
ffc10fe8: 2f 9e 00 00 cmpwi cr7,r30,0
ffc10fec: 3b bd ff ff addi r29,r29,-1
ffc10ff0: 41 9e 00 0c beq- cr7,ffc10ffc <rtems_rfs_group_bitmap_free+0x74><== NEVER TAKEN
{
no -= RTEMS_RFS_ROOT_INO;
size = fs->group_inodes;
ffc10ff4: 80 1f 00 28 lwz r0,40(r31)
ffc10ff8: 48 00 00 08 b ffc11000 <rtems_rfs_group_bitmap_free+0x78>
}
else
{
no -= RTEMS_RFS_SUPERBLOCK_SIZE;
size = fs->group_blocks;
ffc10ffc: 80 1f 00 24 lwz r0,36(r31) <== NOT EXECUTED
}
group = no / size;
ffc11000: 7d 3d 03 96 divwu r9,r29,r0
bit = (rtems_rfs_bitmap_bit) (no % size);
if (inode)
ffc11004: 2f 9e 00 00 cmpwi cr7,r30,0
no -= RTEMS_RFS_SUPERBLOCK_SIZE;
size = fs->group_blocks;
}
group = no / size;
bit = (rtems_rfs_bitmap_bit) (no % size);
ffc11008: 7c 89 01 d6 mullw r4,r9,r0
ffc1100c: 80 1f 00 1c lwz r0,28(r31)
ffc11010: 1f c9 00 50 mulli r30,r9,80
ffc11014: 7c 84 e8 50 subf r4,r4,r29
if (inode)
bitmap = &fs->groups[group].inode_bitmap;
ffc11018: 7f c0 f2 14 add r30,r0,r30
}
group = no / size;
bit = (rtems_rfs_bitmap_bit) (no % size);
if (inode)
ffc1101c: 41 be 00 0c beq+ cr7,ffc11028 <rtems_rfs_group_bitmap_free+0xa0><== NEVER TAKEN
bitmap = &fs->groups[group].inode_bitmap;
ffc11020: 3b de 00 2c addi r30,r30,44
ffc11024: 48 00 00 08 b ffc1102c <rtems_rfs_group_bitmap_free+0xa4>
else
bitmap = &fs->groups[group].block_bitmap;
ffc11028: 3b de 00 08 addi r30,r30,8 <== NOT EXECUTED
rc = rtems_rfs_bitmap_map_clear (bitmap, bit);
ffc1102c: 7f c3 f3 78 mr r3,r30
ffc11030: 48 00 98 8d bl ffc1a8bc <rtems_rfs_bitmap_map_clear>
rtems_rfs_bitmap_release_buffer (fs, bitmap);
ffc11034: 80 9e 00 00 lwz r4,0(r30)
if (inode)
bitmap = &fs->groups[group].inode_bitmap;
else
bitmap = &fs->groups[group].block_bitmap;
rc = rtems_rfs_bitmap_map_clear (bitmap, bit);
ffc11038: 7c 7d 1b 78 mr r29,r3
rtems_rfs_bitmap_release_buffer (fs, bitmap);
ffc1103c: 7f e3 fb 78 mr r3,r31
ffc11040: 48 00 af c9 bl ffc1c008 <rtems_rfs_buffer_handle_release>
return rc;
}
ffc11044: 39 61 00 18 addi r11,r1,24
ffc11048: 7f a3 eb 78 mr r3,r29
ffc1104c: 4b ff 1a a4 b ffc02af0 <_restgpr_29_x>
ffc11050 <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)
{
ffc11050: 94 21 ff e0 stwu r1,-32(r1) <== NOT EXECUTED
ffc11054: 7c 08 02 a6 mflr r0 <== NOT EXECUTED
ffc11058: bf 61 00 0c stmw r27,12(r1) <== NOT EXECUTED
ffc1105c: 7c 7e 1b 78 mr r30,r3 <== NOT EXECUTED
ffc11060: 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))
ffc11064: 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)
{
ffc11068: 90 01 00 24 stw r0,36(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))
ffc1106c: 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)
{
ffc11070: 7c bf 2b 78 mr r31,r5 <== NOT EXECUTED
ffc11074: 7c dc 33 78 mr r28,r6 <== NOT EXECUTED
unsigned int group;
rtems_rfs_bitmap_bit bit;
size_t size;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_BITMAPS))
ffc11078: 48 00 22 8d bl ffc13304 <rtems_rfs_trace> <== NOT EXECUTED
ffc1107c: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc11080: 41 9e 00 34 beq- cr7,ffc110b4 <rtems_rfs_group_bitmap_test+0x64><== NOT EXECUTED
printf ("rtems-rfs: group-bitmap-test: %s test: %" PRId32 "\n",
ffc11084: 2f 9d 00 00 cmpwi cr7,r29,0 <== NOT EXECUTED
ffc11088: 41 9e 00 10 beq- cr7,ffc11098 <rtems_rfs_group_bitmap_test+0x48><== NOT EXECUTED
ffc1108c: 3c 80 ff c3 lis r4,-61 <== NOT EXECUTED
ffc11090: 38 84 33 94 addi r4,r4,13204 <== NOT EXECUTED
ffc11094: 48 00 00 0c b ffc110a0 <rtems_rfs_group_bitmap_test+0x50><== NOT EXECUTED
ffc11098: 3c 80 ff c3 lis r4,-61 <== NOT EXECUTED
ffc1109c: 38 84 2a f9 addi r4,r4,11001 <== NOT EXECUTED
ffc110a0: 3c 60 ff c3 lis r3,-61 <== NOT EXECUTED
ffc110a4: 38 63 34 2b addi r3,r3,13355 <== NOT EXECUTED
ffc110a8: 7f e5 fb 78 mr r5,r31 <== NOT EXECUTED
ffc110ac: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc110b0: 48 01 1a 39 bl ffc22ae8 <printf> <== NOT EXECUTED
inode ? "inode" : "block", no);
if (inode)
ffc110b4: 2f 9d 00 00 cmpwi cr7,r29,0 <== NOT EXECUTED
ffc110b8: 41 9e 00 28 beq- cr7,ffc110e0 <rtems_rfs_group_bitmap_test+0x90><== NOT EXECUTED
{
if ((no < RTEMS_RFS_ROOT_INO) || (no > rtems_rfs_fs_inodes (fs)))
ffc110bc: 2f 9f 00 00 cmpwi cr7,r31,0 <== NOT EXECUTED
return EINVAL;
ffc110c0: 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)))
ffc110c4: 40 9d 00 78 ble- cr7,ffc1113c <rtems_rfs_group_bitmap_test+0xec><== NOT EXECUTED
ffc110c8: 80 1e 00 10 lwz r0,16(r30) <== NOT EXECUTED
ffc110cc: 7f 9f 00 40 cmplw cr7,r31,r0 <== NOT EXECUTED
ffc110d0: 41 bd 00 6c bgt+ cr7,ffc1113c <rtems_rfs_group_bitmap_test+0xec><== NOT EXECUTED
return EINVAL;
no -= RTEMS_RFS_ROOT_INO;
ffc110d4: 3b ff ff ff addi r31,r31,-1 <== NOT EXECUTED
size = fs->group_inodes;
ffc110d8: 80 9e 00 28 lwz r4,40(r30) <== NOT EXECUTED
ffc110dc: 48 00 00 18 b ffc110f4 <rtems_rfs_group_bitmap_test+0xa4><== NOT EXECUTED
}
else
{
if (no >= rtems_rfs_fs_blocks (fs))
ffc110e0: 80 1e 00 04 lwz r0,4(r30) <== NOT EXECUTED
return EINVAL;
ffc110e4: 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))
ffc110e8: 7f 9f 00 40 cmplw cr7,r31,r0 <== NOT EXECUTED
ffc110ec: 40 bc 00 50 bge+ cr7,ffc1113c <rtems_rfs_group_bitmap_test+0xec><== NOT EXECUTED
return EINVAL;
size = fs->group_blocks;
ffc110f0: 80 9e 00 24 lwz r4,36(r30) <== NOT EXECUTED
}
group = no / size;
ffc110f4: 7c 1f 23 96 divwu r0,r31,r4 <== NOT EXECUTED
bit = (rtems_rfs_bitmap_bit) (no % size);
if (inode)
ffc110f8: 2f 9d 00 00 cmpwi cr7,r29,0 <== NOT EXECUTED
return EINVAL;
size = fs->group_blocks;
}
group = no / size;
bit = (rtems_rfs_bitmap_bit) (no % size);
ffc110fc: 7c 80 21 d6 mullw r4,r0,r4 <== NOT EXECUTED
ffc11100: 1f a0 00 50 mulli r29,r0,80 <== NOT EXECUTED
ffc11104: 80 1e 00 1c lwz r0,28(r30) <== NOT EXECUTED
ffc11108: 7c 84 f8 50 subf r4,r4,r31 <== NOT EXECUTED
if (inode)
bitmap = &fs->groups[group].inode_bitmap;
ffc1110c: 7f a0 ea 14 add r29,r0,r29 <== NOT EXECUTED
}
group = no / size;
bit = (rtems_rfs_bitmap_bit) (no % size);
if (inode)
ffc11110: 41 9e 00 0c beq- cr7,ffc1111c <rtems_rfs_group_bitmap_test+0xcc><== NOT EXECUTED
bitmap = &fs->groups[group].inode_bitmap;
ffc11114: 3b bd 00 2c addi r29,r29,44 <== NOT EXECUTED
ffc11118: 48 00 00 08 b ffc11120 <rtems_rfs_group_bitmap_test+0xd0><== NOT EXECUTED
else
bitmap = &fs->groups[group].block_bitmap;
ffc1111c: 3b bd 00 08 addi r29,r29,8 <== NOT EXECUTED
rc = rtems_rfs_bitmap_map_test (bitmap, bit, state);
ffc11120: 7f a3 eb 78 mr r3,r29 <== NOT EXECUTED
ffc11124: 7f 85 e3 78 mr r5,r28 <== NOT EXECUTED
ffc11128: 48 00 98 31 bl ffc1a958 <rtems_rfs_bitmap_map_test> <== NOT EXECUTED
rtems_rfs_bitmap_release_buffer (fs, bitmap);
ffc1112c: 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);
ffc11130: 7c 7b 1b 78 mr r27,r3 <== NOT EXECUTED
rtems_rfs_bitmap_release_buffer (fs, bitmap);
ffc11134: 7f c3 f3 78 mr r3,r30 <== NOT EXECUTED
ffc11138: 48 00 ae d1 bl ffc1c008 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
return rc;
}
ffc1113c: 39 61 00 20 addi r11,r1,32 <== NOT EXECUTED
ffc11140: 7f 63 db 78 mr r3,r27 <== NOT EXECUTED
ffc11144: 4b ff 19 a4 b ffc02ae8 <_restgpr_27_x> <== NOT EXECUTED
ffc10cdc <rtems_rfs_group_close>:
int
rtems_rfs_group_close (rtems_rfs_file_system* fs, rtems_rfs_group* group)
{
ffc10cdc: 94 21 ff e8 stwu r1,-24(r1)
ffc10ce0: 7c 08 02 a6 mflr r0
ffc10ce4: bf 81 00 08 stmw r28,8(r1)
ffc10ce8: 7c 7d 1b 78 mr r29,r3
ffc10cec: 7c 9f 23 78 mr r31,r4
int result = 0;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_CLOSE))
ffc10cf0: 38 60 00 00 li r3,0
return 0;
}
int
rtems_rfs_group_close (rtems_rfs_file_system* fs, rtems_rfs_group* group)
{
ffc10cf4: 90 01 00 1c stw r0,28(r1)
int result = 0;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_CLOSE))
ffc10cf8: 3c 80 00 01 lis r4,1
ffc10cfc: 48 00 26 09 bl ffc13304 <rtems_rfs_trace>
ffc10d00: 2f 83 00 00 cmpwi cr7,r3,0
ffc10d04: 41 be 00 18 beq+ cr7,ffc10d1c <rtems_rfs_group_close+0x40><== ALWAYS TAKEN
printf ("rtems-rfs: group-close: base=%" PRId32 "\n", group->base);
ffc10d08: 3c 60 ff c3 lis r3,-61 <== NOT EXECUTED
ffc10d0c: 80 9f 00 00 lwz r4,0(r31) <== NOT EXECUTED
ffc10d10: 38 63 33 72 addi r3,r3,13170 <== NOT EXECUTED
ffc10d14: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc10d18: 48 01 1d d1 bl ffc22ae8 <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);
ffc10d1c: 38 7f 00 2c addi r3,r31,44
ffc10d20: 48 00 a0 5d bl ffc1ad7c <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);
ffc10d24: 38 9f 00 44 addi r4,r31,68
ffc10d28: 7c 7c 1b 78 mr r28,r3
ffc10d2c: 7f a3 eb 78 mr r3,r29
ffc10d30: 48 00 b2 d9 bl ffc1c008 <rtems_rfs_buffer_handle_release>
handle->dirty = false;
ffc10d34: 38 00 00 00 li r0,0
ffc10d38: 98 1f 00 44 stb r0,68(r31)
handle->bnum = 0;
ffc10d3c: 38 00 00 00 li r0,0
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);
ffc10d40: 38 7f 00 08 addi r3,r31,8
ffc10d44: 90 1f 00 48 stw r0,72(r31)
handle->buffer = NULL;
ffc10d48: 90 1f 00 4c stw r0,76(r31)
ffc10d4c: 48 00 a0 31 bl ffc1ad7c <rtems_rfs_bitmap_close>
if (rc > 0)
ffc10d50: 7c 7e 1b 79 mr. r30,r3
ffc10d54: 41 a1 00 10 bgt+ ffc10d64 <rtems_rfs_group_close+0x88> <== NEVER TAKEN
ffc10d58: 7f 9e e0 f8 not r30,r28
ffc10d5c: 7f de fe 70 srawi r30,r30,31
ffc10d60: 7f 9e f0 38 and r30,r28,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);
ffc10d64: 7f a3 eb 78 mr r3,r29
ffc10d68: 38 9f 00 20 addi r4,r31,32
ffc10d6c: 48 00 b2 9d bl ffc1c008 <rtems_rfs_buffer_handle_release>
handle->dirty = false;
ffc10d70: 38 00 00 00 li r0,0
ffc10d74: 98 1f 00 20 stb r0,32(r31)
rc = rtems_rfs_buffer_handle_close (fs, &group->block_bitmap_buffer);
if (rc > 0)
result = rc;
return result;
}
ffc10d78: 39 61 00 18 addi r11,r1,24
handle->bnum = 0;
ffc10d7c: 38 00 00 00 li r0,0
ffc10d80: 7f c3 f3 78 mr r3,r30
ffc10d84: 90 1f 00 24 stw r0,36(r31)
handle->buffer = NULL;
ffc10d88: 90 1f 00 28 stw r0,40(r31)
ffc10d8c: 4b ff 1d 60 b ffc02aec <_restgpr_28_x>
ffc10abc <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)
{
ffc10abc: 94 21 ff d8 stwu r1,-40(r1)
ffc10ac0: 7c 08 02 a6 mflr r0
ffc10ac4: 90 01 00 2c stw r0,44(r1)
int rc;
if (base >= rtems_rfs_fs_blocks (fs))
ffc10ac8: 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)
{
ffc10acc: bf 01 00 08 stmw r24,8(r1)
ffc10ad0: 7c 7d 1b 78 mr r29,r3
int rc;
if (base >= rtems_rfs_fs_blocks (fs))
ffc10ad4: 7f 84 00 40 cmplw cr7,r4,r0
rtems_rfs_group_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_block base,
size_t size,
size_t inodes,
rtems_rfs_group* group)
{
ffc10ad8: 7c 9b 23 78 mr r27,r4
ffc10adc: 7c bc 2b 78 mr r28,r5
ffc10ae0: 7c ff 3b 78 mr r31,r7
int rc;
if (base >= rtems_rfs_fs_blocks (fs))
ffc10ae4: 41 bc 00 3c blt+ cr7,ffc10b20 <rtems_rfs_group_open+0x64><== ALWAYS TAKEN
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_OPEN))
ffc10ae8: 38 80 00 00 li r4,0 <== NOT EXECUTED
ffc10aec: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc10af0: 60 84 80 00 ori r4,r4,32768 <== NOT EXECUTED
ffc10af4: 48 00 28 11 bl ffc13304 <rtems_rfs_trace> <== NOT EXECUTED
printf ("rtems-rfs: group-open: base outside file system range: %d: %s\n",
EIO, strerror (EIO));
return EIO;
ffc10af8: 3b 60 00 05 li r27,5 <== NOT EXECUTED
{
int rc;
if (base >= rtems_rfs_fs_blocks (fs))
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_OPEN))
ffc10afc: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc10b00: 41 be 01 d0 beq+ cr7,ffc10cd0 <rtems_rfs_group_open+0x214><== NOT EXECUTED
printf ("rtems-rfs: group-open: base outside file system range: %d: %s\n",
ffc10b04: 38 60 00 05 li r3,5 <== NOT EXECUTED
ffc10b08: 48 01 2d 4d bl ffc23854 <strerror> <== NOT EXECUTED
ffc10b0c: 38 80 00 05 li r4,5 <== NOT EXECUTED
ffc10b10: 7c 65 1b 78 mr r5,r3 <== NOT EXECUTED
ffc10b14: 3c 60 ff c3 lis r3,-61 <== NOT EXECUTED
ffc10b18: 38 63 32 83 addi r3,r3,12931 <== NOT EXECUTED
ffc10b1c: 48 00 00 e4 b ffc10c00 <rtems_rfs_group_open+0x144> <== NOT EXECUTED
EIO, strerror (EIO));
return EIO;
}
if ((base + size) >= rtems_rfs_fs_blocks (fs))
ffc10b20: 7d 25 22 14 add r9,r5,r4
ffc10b24: 7f 89 00 40 cmplw cr7,r9,r0
ffc10b28: 41 9c 00 08 blt- cr7,ffc10b30 <rtems_rfs_group_open+0x74><== NEVER TAKEN
size = rtems_rfs_fs_blocks (fs) - base;
ffc10b2c: 7f 84 00 50 subf r28,r4,r0
ffc10b30: 7f 9c 30 40 cmplw cr7,r28,r6
ffc10b34: 7f 99 e3 78 mr r25,r28
ffc10b38: 40 9d 00 08 ble- cr7,ffc10b40 <rtems_rfs_group_open+0x84><== NEVER TAKEN
ffc10b3c: 7c d9 33 78 mr r25,r6
* the format configuration needs reviewing.
*/
if (inodes > size)
inodes = size;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_OPEN))
ffc10b40: 38 80 00 00 li r4,0
ffc10b44: 38 60 00 00 li r3,0
ffc10b48: 60 84 80 00 ori r4,r4,32768
ffc10b4c: 48 00 27 b9 bl ffc13304 <rtems_rfs_trace>
ffc10b50: 2f 83 00 00 cmpwi cr7,r3,0
ffc10b54: 41 be 00 20 beq+ cr7,ffc10b74 <rtems_rfs_group_open+0xb8><== ALWAYS TAKEN
printf ("rtems-rfs: group-open: base=%" PRId32 ", blocks=%zd inodes=%zd\n",
ffc10b58: 3c 60 ff c3 lis r3,-61 <== NOT EXECUTED
ffc10b5c: 38 63 32 c2 addi r3,r3,12994 <== NOT EXECUTED
ffc10b60: 7f 64 db 78 mr r4,r27 <== NOT EXECUTED
ffc10b64: 7f 85 e3 78 mr r5,r28 <== NOT EXECUTED
ffc10b68: 7f 26 cb 78 mr r6,r25 <== NOT EXECUTED
ffc10b6c: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc10b70: 48 01 1f 79 bl ffc22ae8 <printf> <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
ffc10b74: 38 00 00 00 li r0,0
base, size, inodes);
group->base = base;
ffc10b78: 93 7f 00 00 stw r27,0(r31)
handle->bnum = 0;
ffc10b7c: 3b c0 00 00 li r30,0
group->size = size;
ffc10b80: 93 9f 00 04 stw r28,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,
ffc10b84: 3b 1f 00 08 addi r24,r31,8
ffc10b88: 3b 5f 00 20 addi r26,r31,32
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
ffc10b8c: 98 1f 00 20 stb r0,32(r31)
ffc10b90: 7f 67 db 78 mr r7,r27
ffc10b94: 7f 03 c3 78 mr r3,r24
handle->bnum = 0;
ffc10b98: 93 df 00 24 stw r30,36(r31)
ffc10b9c: 7f a4 eb 78 mr r4,r29
ffc10ba0: 7f 45 d3 78 mr r5,r26
handle->buffer = NULL;
ffc10ba4: 93 df 00 28 stw r30,40(r31)
ffc10ba8: 7f 86 e3 78 mr r6,r28
ffc10bac: 48 00 a1 69 bl ffc1ad14 <rtems_rfs_bitmap_open>
&group->block_bitmap_buffer, size,
group->base + RTEMS_RFS_GROUP_BLOCK_BITMAP_BLOCK);
if (rc > 0)
ffc10bb0: 7c 7b 1b 79 mr. r27,r3
ffc10bb4: 40 81 00 58 ble- ffc10c0c <rtems_rfs_group_open+0x150> <== 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);
ffc10bb8: 7f 44 d3 78 mr r4,r26 <== NOT EXECUTED
ffc10bbc: 7f a3 eb 78 mr r3,r29 <== NOT EXECUTED
ffc10bc0: 48 00 b4 49 bl ffc1c008 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
handle->dirty = false;
ffc10bc4: 9b df 00 20 stb r30,32(r31) <== NOT EXECUTED
{
rtems_rfs_buffer_handle_close (fs, &group->block_bitmap_buffer);
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_OPEN))
ffc10bc8: 38 80 00 00 li r4,0 <== NOT EXECUTED
handle->bnum = 0;
ffc10bcc: 93 df 00 24 stw r30,36(r31) <== NOT EXECUTED
ffc10bd0: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc10bd4: 60 84 80 00 ori r4,r4,32768 <== NOT EXECUTED
handle->buffer = NULL;
ffc10bd8: 93 df 00 28 stw r30,40(r31) <== NOT EXECUTED
ffc10bdc: 48 00 27 29 bl ffc13304 <rtems_rfs_trace> <== NOT EXECUTED
ffc10be0: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc10be4: 41 be 00 ec beq+ cr7,ffc10cd0 <rtems_rfs_group_open+0x214><== NOT EXECUTED
printf ("rtems-rfs: group-open: could not open block bitmap: %d: %s\n",
ffc10be8: 7f 63 db 78 mr r3,r27 <== NOT EXECUTED
ffc10bec: 48 01 2c 69 bl ffc23854 <strerror> <== NOT EXECUTED
ffc10bf0: 7c 65 1b 78 mr r5,r3 <== NOT EXECUTED
ffc10bf4: 3c 60 ff c3 lis r3,-61 <== NOT EXECUTED
ffc10bf8: 38 63 32 fa addi r3,r3,13050 <== NOT EXECUTED
ffc10bfc: 7f 64 db 78 mr r4,r27 <== NOT EXECUTED
ffc10c00: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc10c04: 48 01 1e e5 bl ffc22ae8 <printf> <== NOT EXECUTED
ffc10c08: 48 00 00 c8 b ffc10cd0 <rtems_rfs_group_open+0x214> <== 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,
ffc10c0c: 80 ff 00 00 lwz r7,0(r31)
ffc10c10: 3b 9f 00 44 addi r28,r31,68
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
ffc10c14: 9b df 00 44 stb r30,68(r31)
ffc10c18: 38 7f 00 2c addi r3,r31,44
ffc10c1c: 7f a4 eb 78 mr r4,r29
handle->bnum = 0;
ffc10c20: 93 df 00 48 stw r30,72(r31)
ffc10c24: 7f 85 e3 78 mr r5,r28
ffc10c28: 7f 26 cb 78 mr r6,r25
handle->buffer = NULL;
ffc10c2c: 93 df 00 4c stw r30,76(r31)
ffc10c30: 38 e7 00 01 addi r7,r7,1
ffc10c34: 48 00 a0 e1 bl ffc1ad14 <rtems_rfs_bitmap_open>
&group->inode_bitmap_buffer, inodes,
group->base + RTEMS_RFS_GROUP_INODE_BITMAP_BLOCK);
if (rc > 0)
ffc10c38: 7c 7b 1b 79 mr. r27,r3
ffc10c3c: 40 81 00 6c ble- ffc10ca8 <rtems_rfs_group_open+0x1ec> <== 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);
ffc10c40: 7f 84 e3 78 mr r4,r28 <== NOT EXECUTED
ffc10c44: 7f a3 eb 78 mr r3,r29 <== NOT EXECUTED
ffc10c48: 48 00 b3 c1 bl ffc1c008 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
handle->dirty = false;
ffc10c4c: 9b df 00 44 stb r30,68(r31) <== NOT EXECUTED
{
rtems_rfs_buffer_handle_close (fs, &group->inode_bitmap_buffer);
rtems_rfs_bitmap_close (&group->block_bitmap);
ffc10c50: 7f 03 c3 78 mr r3,r24 <== NOT EXECUTED
handle->bnum = 0;
ffc10c54: 93 df 00 48 stw r30,72(r31) <== NOT EXECUTED
handle->buffer = NULL;
ffc10c58: 93 df 00 4c stw r30,76(r31) <== NOT EXECUTED
ffc10c5c: 48 00 a1 21 bl ffc1ad7c <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);
ffc10c60: 7f 44 d3 78 mr r4,r26 <== NOT EXECUTED
ffc10c64: 7f a3 eb 78 mr r3,r29 <== NOT EXECUTED
ffc10c68: 48 00 b3 a1 bl ffc1c008 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
handle->dirty = false;
ffc10c6c: 9b df 00 20 stb r30,32(r31) <== NOT EXECUTED
rtems_rfs_buffer_handle_close (fs, &group->block_bitmap_buffer);
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_OPEN))
ffc10c70: 38 80 00 00 li r4,0 <== NOT EXECUTED
handle->bnum = 0;
ffc10c74: 93 df 00 24 stw r30,36(r31) <== NOT EXECUTED
ffc10c78: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc10c7c: 60 84 80 00 ori r4,r4,32768 <== NOT EXECUTED
handle->buffer = NULL;
ffc10c80: 93 df 00 28 stw r30,40(r31) <== NOT EXECUTED
ffc10c84: 48 00 26 81 bl ffc13304 <rtems_rfs_trace> <== NOT EXECUTED
ffc10c88: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc10c8c: 41 be 00 44 beq+ cr7,ffc10cd0 <rtems_rfs_group_open+0x214><== NOT EXECUTED
printf ("rtems-rfs: group-open: could not open inode bitmap: %d: %s\n",
ffc10c90: 7f 63 db 78 mr r3,r27 <== NOT EXECUTED
ffc10c94: 48 01 2b c1 bl ffc23854 <strerror> <== NOT EXECUTED
ffc10c98: 7c 65 1b 78 mr r5,r3 <== NOT EXECUTED
ffc10c9c: 3c 60 ff c3 lis r3,-61 <== NOT EXECUTED
ffc10ca0: 38 63 33 36 addi r3,r3,13110 <== NOT EXECUTED
ffc10ca4: 4b ff ff 58 b ffc10bfc <rtems_rfs_group_open+0x140> <== NOT EXECUTED
rc, strerror (rc));
return rc;
}
if (rtems_rfs_fs_release_bitmaps (fs))
ffc10ca8: 80 1d 00 00 lwz r0,0(r29)
{
rtems_rfs_bitmap_release_buffer (fs, &group->block_bitmap);
rtems_rfs_bitmap_release_buffer (fs, &group->inode_bitmap);
}
return 0;
ffc10cac: 3b 60 00 00 li r27,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))
ffc10cb0: 70 09 00 01 andi. r9,r0,1
ffc10cb4: 40 a2 00 1c bne+ ffc10cd0 <rtems_rfs_group_open+0x214> <== NEVER TAKEN
{
rtems_rfs_bitmap_release_buffer (fs, &group->block_bitmap);
ffc10cb8: 80 9f 00 08 lwz r4,8(r31)
ffc10cbc: 7f a3 eb 78 mr r3,r29
ffc10cc0: 48 00 b3 49 bl ffc1c008 <rtems_rfs_buffer_handle_release>
rtems_rfs_bitmap_release_buffer (fs, &group->inode_bitmap);
ffc10cc4: 80 9f 00 2c lwz r4,44(r31)
ffc10cc8: 7f a3 eb 78 mr r3,r29
ffc10ccc: 48 00 b3 3d bl ffc1c008 <rtems_rfs_buffer_handle_release>
}
return 0;
}
ffc10cd0: 39 61 00 28 addi r11,r1,40
ffc10cd4: 7f 63 db 78 mr r3,r27
ffc10cd8: 4b ff 1e 04 b ffc02adc <_restgpr_24_x>
ffc11148 <rtems_rfs_group_usage>:
size_t* blocks,
size_t* inodes)
{
int g;
*blocks = 0;
ffc11148: 38 00 00 00 li r0,0 <== NOT EXECUTED
ffc1114c: 90 04 00 00 stw r0,0(r4) <== NOT EXECUTED
*inodes = 0;
for (g = 0; g < fs->group_count; g++)
ffc11150: 39 20 00 00 li r9,0 <== NOT EXECUTED
size_t* inodes)
{
int g;
*blocks = 0;
*inodes = 0;
ffc11154: 90 05 00 00 stw r0,0(r5) <== NOT EXECUTED
for (g = 0; g < fs->group_count; g++)
ffc11158: 48 00 00 44 b ffc1119c <rtems_rfs_group_usage+0x54> <== NOT EXECUTED
return rc;
}
int
rtems_rfs_group_usage (rtems_rfs_file_system* fs,
ffc1115c: 1c 09 00 50 mulli r0,r9,80 <== NOT EXECUTED
*blocks = 0;
*inodes = 0;
for (g = 0; g < fs->group_count; g++)
{
rtems_rfs_group* group = &fs->groups[g];
ffc11160: 81 63 00 1c lwz r11,28(r3) <== NOT EXECUTED
ffc11164: 7d 6b 02 14 add r11,r11,r0 <== NOT EXECUTED
*blocks +=
rtems_rfs_bitmap_map_size(&group->block_bitmap) -
ffc11168: 81 4b 00 14 lwz r10,20(r11) <== NOT EXECUTED
int g;
*blocks = 0;
*inodes = 0;
for (g = 0; g < fs->group_count; g++)
ffc1116c: 39 29 00 01 addi r9,r9,1 <== NOT EXECUTED
{
rtems_rfs_group* group = &fs->groups[g];
*blocks +=
rtems_rfs_bitmap_map_size(&group->block_bitmap) -
ffc11170: 80 0b 00 18 lwz r0,24(r11) <== NOT EXECUTED
ffc11174: 7c 00 50 50 subf r0,r0,r10 <== NOT EXECUTED
*inodes = 0;
for (g = 0; g < fs->group_count; g++)
{
rtems_rfs_group* group = &fs->groups[g];
*blocks +=
ffc11178: 81 44 00 00 lwz r10,0(r4) <== NOT EXECUTED
ffc1117c: 7c 0a 02 14 add r0,r10,r0 <== NOT EXECUTED
ffc11180: 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) -
ffc11184: 81 4b 00 38 lwz r10,56(r11) <== NOT EXECUTED
ffc11188: 80 0b 00 3c lwz r0,60(r11) <== 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 +=
ffc1118c: 81 65 00 00 lwz r11,0(r5) <== NOT EXECUTED
rtems_rfs_bitmap_map_size (&group->inode_bitmap) -
ffc11190: 7c 00 50 50 subf r0,r0,r10 <== 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 +=
ffc11194: 7c 0b 02 14 add r0,r11,r0 <== NOT EXECUTED
ffc11198: 90 05 00 00 stw r0,0(r5) <== NOT EXECUTED
int g;
*blocks = 0;
*inodes = 0;
for (g = 0; g < fs->group_count; g++)
ffc1119c: 80 03 00 20 lwz r0,32(r3) <== NOT EXECUTED
ffc111a0: 7f 89 00 00 cmpw cr7,r9,r0 <== NOT EXECUTED
ffc111a4: 41 9c ff b8 blt+ cr7,ffc1115c <rtems_rfs_group_usage+0x14><== 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))
ffc111a8: 81 23 00 04 lwz r9,4(r3) <== NOT EXECUTED
ffc111ac: 80 04 00 00 lwz r0,0(r4) <== NOT EXECUTED
ffc111b0: 7f 80 48 40 cmplw cr7,r0,r9 <== NOT EXECUTED
ffc111b4: 40 9d 00 08 ble- cr7,ffc111bc <rtems_rfs_group_usage+0x74><== NOT EXECUTED
ffc111b8: 7d 20 4b 78 mr r0,r9 <== NOT EXECUTED
ffc111bc: 90 04 00 00 stw r0,0(r4) <== NOT EXECUTED
*blocks = rtems_rfs_fs_blocks (fs);
if (*inodes > rtems_rfs_fs_inodes (fs))
ffc111c0: 81 23 00 10 lwz r9,16(r3) <== NOT EXECUTED
ffc111c4: 80 05 00 00 lwz r0,0(r5) <== NOT EXECUTED
ffc111c8: 7f 80 48 40 cmplw cr7,r0,r9 <== NOT EXECUTED
ffc111cc: 40 9d 00 08 ble- cr7,ffc111d4 <rtems_rfs_group_usage+0x8c><== NOT EXECUTED
ffc111d0: 7d 20 4b 78 mr r0,r9 <== NOT EXECUTED
ffc111d4: 90 05 00 00 stw r0,0(r5) <== NOT EXECUTED
*inodes = rtems_rfs_fs_inodes (fs);
return 0;
}
ffc111d8: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc111dc: 4e 80 00 20 blr <== NOT EXECUTED
ffc114e8 <rtems_rfs_inode_close>:
}
int
rtems_rfs_inode_close (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* handle)
{
ffc114e8: 94 21 ff f0 stwu r1,-16(r1)
ffc114ec: 7c 08 02 a6 mflr r0
ffc114f0: bf c1 00 08 stmw r30,8(r1)
ffc114f4: 7c 7e 1b 78 mr r30,r3
ffc114f8: 7c 9f 23 78 mr r31,r4
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_CLOSE))
ffc114fc: 38 60 00 00 li r3,0
}
int
rtems_rfs_inode_close (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* handle)
{
ffc11500: 90 01 00 14 stw r0,20(r1)
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_CLOSE))
ffc11504: 3c 80 00 08 lis r4,8
ffc11508: 48 00 1d fd bl ffc13304 <rtems_rfs_trace>
ffc1150c: 2f 83 00 00 cmpwi cr7,r3,0
ffc11510: 41 be 00 18 beq+ cr7,ffc11528 <rtems_rfs_inode_close+0x40><== ALWAYS TAKEN
printf ("rtems-rfs: inode-close: ino: %" PRIu32 "\n", handle->ino);
ffc11514: 3c 60 ff c3 lis r3,-61 <== NOT EXECUTED
ffc11518: 80 9f 00 08 lwz r4,8(r31) <== NOT EXECUTED
ffc1151c: 38 63 34 e4 addi r3,r3,13540 <== NOT EXECUTED
ffc11520: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc11524: 48 01 15 c5 bl ffc22ae8 <printf> <== NOT EXECUTED
rc = rtems_rfs_inode_unload (fs, handle, true);
ffc11528: 7f c3 f3 78 mr r3,r30
ffc1152c: 7f e4 fb 78 mr r4,r31
ffc11530: 38 a0 00 01 li r5,1
ffc11534: 4b ff fe b1 bl ffc113e4 <rtems_rfs_inode_unload>
if ((rc == 0) && (handle->loads > 0))
ffc11538: 7c 7e 1b 79 mr. r30,r3
ffc1153c: 40 82 00 3c bne- ffc11578 <rtems_rfs_inode_close+0x90> <== NEVER TAKEN
ffc11540: 80 1f 00 24 lwz r0,36(r31)
ffc11544: 2f 80 00 00 cmpwi cr7,r0,0
ffc11548: 40 9d 00 30 ble- cr7,ffc11578 <rtems_rfs_inode_close+0x90><== ALWAYS TAKEN
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_CLOSE))
ffc1154c: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc11550: 3c 80 00 08 lis r4,8 <== NOT EXECUTED
ffc11554: 48 00 1d b1 bl ffc13304 <rtems_rfs_trace> <== NOT EXECUTED
printf ("rtems-rfs: inode-close: bad loads number: %d\n",
handle->loads);
rc = EIO;
ffc11558: 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))
ffc1155c: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc11560: 41 be 00 18 beq+ cr7,ffc11578 <rtems_rfs_inode_close+0x90><== NOT EXECUTED
printf ("rtems-rfs: inode-close: bad loads number: %d\n",
ffc11564: 3c 60 ff c3 lis r3,-61 <== NOT EXECUTED
ffc11568: 80 9f 00 24 lwz r4,36(r31) <== NOT EXECUTED
ffc1156c: 38 63 35 06 addi r3,r3,13574 <== NOT EXECUTED
ffc11570: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc11574: 48 01 15 75 bl ffc22ae8 <printf> <== NOT EXECUTED
handle->loads);
rc = EIO;
}
handle->ino = 0;
ffc11578: 38 00 00 00 li r0,0
return rc;
}
ffc1157c: 39 61 00 10 addi r11,r1,16
printf ("rtems-rfs: inode-close: bad loads number: %d\n",
handle->loads);
rc = EIO;
}
handle->ino = 0;
ffc11580: 90 1f 00 08 stw r0,8(r31)
return rc;
}
ffc11584: 7f c3 f3 78 mr r3,r30
ffc11588: 4b ff 15 6c b ffc02af4 <_restgpr_30_x>
ffc11894 <rtems_rfs_inode_create>:
uint16_t mode,
uint16_t links,
uid_t uid,
gid_t gid,
rtems_rfs_ino* ino)
{
ffc11894: 94 21 ff 78 stwu r1,-136(r1)
ffc11898: 7c 08 02 a6 mflr r0
ffc1189c: be a1 00 5c stmw r21,92(r1)
ffc118a0: 7c 7f 1b 78 mr r31,r3
ffc118a4: 7c 9e 23 78 mr r30,r4
rtems_rfs_inode_handle parent_inode;
rtems_rfs_inode_handle inode;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_CREATE))
ffc118a8: 38 60 00 00 li r3,0
uint16_t mode,
uint16_t links,
uid_t uid,
gid_t gid,
rtems_rfs_ino* ino)
{
ffc118ac: 90 01 00 8c stw r0,140(r1)
rtems_rfs_inode_handle parent_inode;
rtems_rfs_inode_handle inode;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_CREATE))
ffc118b0: 3c 80 00 40 lis r4,64
uint16_t mode,
uint16_t links,
uid_t uid,
gid_t gid,
rtems_rfs_ino* ino)
{
ffc118b4: 7c bc 2b 78 mr r28,r5
ffc118b8: 83 21 00 90 lwz r25,144(r1)
ffc118bc: 7c dd 33 78 mr r29,r6
ffc118c0: 7c fb 3b 78 mr r27,r7
ffc118c4: 7d 1a 43 78 mr r26,r8
ffc118c8: 7d 37 4b 78 mr r23,r9
ffc118cc: 7d 56 53 78 mr r22,r10
rtems_rfs_inode_handle parent_inode;
rtems_rfs_inode_handle inode;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_CREATE))
ffc118d0: 48 00 1a 35 bl ffc13304 <rtems_rfs_trace>
ffc118d4: 2f 83 00 00 cmpwi cr7,r3,0
ffc118d8: 41 9e 00 c8 beq- cr7,ffc119a0 <rtems_rfs_inode_create+0x10c><== ALWAYS TAKEN
{
const char* type = "unknown";
int c;
if (RTEMS_RFS_S_ISDIR (mode))
ffc118dc: 57 60 04 26 rlwinm r0,r27,0,16,19 <== NOT EXECUTED
ffc118e0: 2f 80 40 00 cmpwi cr7,r0,16384 <== NOT EXECUTED
ffc118e4: 41 9e 00 38 beq- cr7,ffc1191c <rtems_rfs_inode_create+0x88><== NOT EXECUTED
type = "dir";
else if (RTEMS_RFS_S_ISCHR (mode))
ffc118e8: 2f 80 20 00 cmpwi cr7,r0,8192 <== NOT EXECUTED
ffc118ec: 41 9e 00 3c beq- cr7,ffc11928 <rtems_rfs_inode_create+0x94><== NOT EXECUTED
type = "char";
else if (RTEMS_RFS_S_ISBLK (mode))
ffc118f0: 2f 80 60 00 cmpwi cr7,r0,24576 <== NOT EXECUTED
ffc118f4: 41 9e 00 40 beq- cr7,ffc11934 <rtems_rfs_inode_create+0xa0><== NOT EXECUTED
type = "block";
else if (RTEMS_RFS_S_ISREG (mode))
ffc118f8: 6c 09 ff ff xoris r9,r0,65535 <== NOT EXECUTED
ffc118fc: 2f 89 80 00 cmpwi cr7,r9,-32768 <== NOT EXECUTED
ffc11900: 41 9e 00 40 beq- cr7,ffc11940 <rtems_rfs_inode_create+0xac><== NOT EXECUTED
type = "file";
else if (RTEMS_RFS_S_ISLNK (mode))
ffc11904: 6c 09 ff ff xoris r9,r0,65535 <== NOT EXECUTED
ffc11908: 2f 89 a0 00 cmpwi cr7,r9,-24576 <== NOT EXECUTED
ffc1190c: 41 9e 00 40 beq- cr7,ffc1194c <rtems_rfs_inode_create+0xb8><== NOT EXECUTED
rtems_rfs_inode_handle inode;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_CREATE))
{
const char* type = "unknown";
ffc11910: 3f 00 ff c3 lis r24,-61 <== NOT EXECUTED
ffc11914: 3b 18 35 65 addi r24,r24,13669 <== NOT EXECUTED
ffc11918: 48 00 00 3c b ffc11954 <rtems_rfs_inode_create+0xc0> <== NOT EXECUTED
int c;
if (RTEMS_RFS_S_ISDIR (mode))
type = "dir";
ffc1191c: 3f 00 ff c3 lis r24,-61 <== NOT EXECUTED
ffc11920: 3b 18 1a 2c addi r24,r24,6700 <== NOT EXECUTED
ffc11924: 48 00 00 30 b ffc11954 <rtems_rfs_inode_create+0xc0> <== NOT EXECUTED
else if (RTEMS_RFS_S_ISCHR (mode))
type = "char";
ffc11928: 3f 00 ff c3 lis r24,-61 <== NOT EXECUTED
ffc1192c: 3b 18 35 60 addi r24,r24,13664 <== NOT EXECUTED
ffc11930: 48 00 00 24 b ffc11954 <rtems_rfs_inode_create+0xc0> <== NOT EXECUTED
else if (RTEMS_RFS_S_ISBLK (mode))
type = "block";
ffc11934: 3f 00 ff c3 lis r24,-61 <== NOT EXECUTED
ffc11938: 3b 18 2a f9 addi r24,r24,11001 <== NOT EXECUTED
ffc1193c: 48 00 00 18 b ffc11954 <rtems_rfs_inode_create+0xc0> <== NOT EXECUTED
else if (RTEMS_RFS_S_ISREG (mode))
type = "file";
ffc11940: 3f 00 ff c3 lis r24,-61 <== NOT EXECUTED
ffc11944: 3b 18 19 a0 addi r24,r24,6560 <== NOT EXECUTED
ffc11948: 48 00 00 0c b ffc11954 <rtems_rfs_inode_create+0xc0> <== NOT EXECUTED
else if (RTEMS_RFS_S_ISLNK (mode))
type = "link";
ffc1194c: 3f 00 ff c3 lis r24,-61 <== NOT EXECUTED
ffc11950: 3b 18 39 4b addi r24,r24,14667 <== NOT EXECUTED
printf("rtems-rfs: inode-create: parent:%" PRIu32 " name:", parent);
ffc11954: 3c 60 ff c3 lis r3,-61 <== NOT EXECUTED
ffc11958: 38 63 35 6d addi r3,r3,13677 <== NOT EXECUTED
ffc1195c: 7f c4 f3 78 mr r4,r30 <== NOT EXECUTED
ffc11960: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc11964: 48 01 11 85 bl ffc22ae8 <printf> <== NOT EXECUTED
for (c = 0; c < length; c++)
ffc11968: 3a a0 00 00 li r21,0 <== NOT EXECUTED
ffc1196c: 48 00 00 10 b ffc1197c <rtems_rfs_inode_create+0xe8> <== NOT EXECUTED
printf ("%c", name[c]);
ffc11970: 7c 7c a8 ae lbzx r3,r28,r21 <== 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++)
ffc11974: 3a b5 00 01 addi r21,r21,1 <== NOT EXECUTED
printf ("%c", name[c]);
ffc11978: 48 01 12 2d bl ffc22ba4 <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++)
ffc1197c: 7f 95 e8 00 cmpw cr7,r21,r29 <== NOT EXECUTED
ffc11980: 40 9e ff f0 bne+ cr7,ffc11970 <rtems_rfs_inode_create+0xdc><== NOT EXECUTED
printf ("%c", name[c]);
printf (" type:%s mode:%04x (%03o)\n", type, mode, mode & ((1 << 10) - 1));
ffc11984: 3c 60 ff c3 lis r3,-61 <== NOT EXECUTED
ffc11988: 38 63 35 97 addi r3,r3,13719 <== NOT EXECUTED
ffc1198c: 7f 04 c3 78 mr r4,r24 <== NOT EXECUTED
ffc11990: 7f 65 db 78 mr r5,r27 <== NOT EXECUTED
ffc11994: 57 66 05 be clrlwi r6,r27,22 <== NOT EXECUTED
ffc11998: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc1199c: 48 01 11 4d bl ffc22ae8 <printf> <== NOT EXECUTED
}
/*
* The file type is field within the mode. Check we have a sane mode set.
*/
switch (mode & RTEMS_RFS_S_IFMT)
ffc119a0: 57 78 04 26 rlwinm r24,r27,0,16,19
ffc119a4: 2f 98 60 00 cmpwi cr7,r24,24576
ffc119a8: 41 9e 00 34 beq- cr7,ffc119dc <rtems_rfs_inode_create+0x148><== NEVER TAKEN
ffc119ac: 41 9d 00 14 bgt- cr7,ffc119c0 <rtems_rfs_inode_create+0x12c>
ffc119b0: 2f 98 20 00 cmpwi cr7,r24,8192
ffc119b4: 41 9e 00 28 beq- cr7,ffc119dc <rtems_rfs_inode_create+0x148><== NEVER TAKEN
ffc119b8: 2f 98 40 00 cmpwi cr7,r24,16384
ffc119bc: 48 00 00 1c b ffc119d8 <rtems_rfs_inode_create+0x144>
ffc119c0: 6f 00 ff ff xoris r0,r24,65535
ffc119c4: 2f 80 80 00 cmpwi cr7,r0,-32768
ffc119c8: 41 9e 00 14 beq- cr7,ffc119dc <rtems_rfs_inode_create+0x148>
ffc119cc: 38 00 00 00 li r0,0
ffc119d0: 60 00 a0 00 ori r0,r0,40960
ffc119d4: 7f 98 00 00 cmpw cr7,r24,r0
ffc119d8: 40 be 01 c0 bne+ cr7,ffc11b98 <rtems_rfs_inode_create+0x304><== NEVER TAKEN
break;
default:
return EINVAL;
}
rc = rtems_rfs_inode_alloc (fs, parent, ino);
ffc119dc: 7f e3 fb 78 mr r3,r31
ffc119e0: 7f c4 f3 78 mr r4,r30
ffc119e4: 7f 25 cb 78 mr r5,r25
ffc119e8: 4b ff f7 f9 bl ffc111e0 <rtems_rfs_inode_alloc>
if (rc > 0)
ffc119ec: 7c 75 1b 79 mr. r21,r3
ffc119f0: 41 a1 01 b4 bgt+ ffc11ba4 <rtems_rfs_inode_create+0x310><== NEVER TAKEN
return rc;
rc = rtems_rfs_inode_open (fs, *ino, &inode, true);
ffc119f4: 80 99 00 00 lwz r4,0(r25)
ffc119f8: 7f e3 fb 78 mr r3,r31
ffc119fc: 38 a1 00 08 addi r5,r1,8
ffc11a00: 38 c0 00 01 li r6,1
ffc11a04: 4b ff f8 f5 bl ffc112f8 <rtems_rfs_inode_open>
if (rc > 0)
ffc11a08: 7c 75 1b 79 mr. r21,r3
ffc11a0c: 41 a1 01 7c bgt+ ffc11b88 <rtems_rfs_inode_create+0x2f4><== NEVER TAKEN
{
rtems_rfs_inode_free (fs, *ino);
return rc;
}
rc = rtems_rfs_inode_initialise (&inode, links, mode, uid, gid);
ffc11a10: 38 61 00 08 addi r3,r1,8
ffc11a14: 7f 44 d3 78 mr r4,r26
ffc11a18: 7f 65 db 78 mr r5,r27
ffc11a1c: 7e e6 bb 78 mr r6,r23
ffc11a20: 7e c7 b3 78 mr r7,r22
ffc11a24: 4b ff fd 11 bl ffc11734 <rtems_rfs_inode_initialise>
if (rc > 0)
ffc11a28: 7c 75 1b 79 mr. r21,r3
ffc11a2c: 40 a1 00 14 ble+ ffc11a40 <rtems_rfs_inode_create+0x1ac><== ALWAYS TAKEN
{
rtems_rfs_inode_close (fs, &inode);
ffc11a30: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc11a34: 38 81 00 08 addi r4,r1,8 <== NOT EXECUTED
ffc11a38: 4b ff fa b1 bl ffc114e8 <rtems_rfs_inode_close> <== NOT EXECUTED
ffc11a3c: 48 00 01 4c b ffc11b88 <rtems_rfs_inode_create+0x2f4><== NOT EXECUTED
/*
* 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))
ffc11a40: 2f 98 40 00 cmpwi cr7,r24,16384
ffc11a44: 40 be 00 54 bne+ cr7,ffc11a98 <rtems_rfs_inode_create+0x204>
{
rc = rtems_rfs_dir_add_entry (fs, &inode, ".", 1, *ino);
ffc11a48: 3c a0 ff c3 lis r5,-61
ffc11a4c: 80 f9 00 00 lwz r7,0(r25)
ffc11a50: 7f e3 fb 78 mr r3,r31
ffc11a54: 38 81 00 08 addi r4,r1,8
ffc11a58: 38 a5 18 b5 addi r5,r5,6325
ffc11a5c: 38 c0 00 01 li r6,1
ffc11a60: 48 00 b3 4d bl ffc1cdac <rtems_rfs_dir_add_entry>
if (rc == 0)
ffc11a64: 7c 75 1b 79 mr. r21,r3
ffc11a68: 40 a2 00 24 bne+ ffc11a8c <rtems_rfs_inode_create+0x1f8>
rc = rtems_rfs_dir_add_entry (fs, &inode, "..", 2, parent);
ffc11a6c: 3c a0 ff c3 lis r5,-61
ffc11a70: 7f e3 fb 78 mr r3,r31
ffc11a74: 38 81 00 08 addi r4,r1,8
ffc11a78: 38 a5 18 b4 addi r5,r5,6324
ffc11a7c: 38 c0 00 02 li r6,2
ffc11a80: 7f c7 f3 78 mr r7,r30
ffc11a84: 48 00 b3 29 bl ffc1cdac <rtems_rfs_dir_add_entry>
ffc11a88: 7c 75 1b 78 mr r21,r3
if (rc > 0)
ffc11a8c: 2f 95 00 00 cmpwi cr7,r21,0
{
rtems_rfs_inode_delete (fs, &inode);
ffc11a90: 7f e3 fb 78 mr r3,r31
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);
if (rc > 0)
ffc11a94: 41 9d 00 24 bgt- cr7,ffc11ab8 <rtems_rfs_inode_create+0x224>
rtems_rfs_inode_close (fs, &inode);
return rc;
}
}
rc = rtems_rfs_inode_open (fs, parent, &parent_inode, true);
ffc11a98: 7f e3 fb 78 mr r3,r31
ffc11a9c: 7f c4 f3 78 mr r4,r30
ffc11aa0: 38 a1 00 30 addi r5,r1,48
ffc11aa4: 38 c0 00 01 li r6,1
ffc11aa8: 4b ff f8 51 bl ffc112f8 <rtems_rfs_inode_open>
if (rc > 0)
ffc11aac: 7c 75 1b 79 mr. r21,r3
{
rtems_rfs_inode_delete (fs, &inode);
ffc11ab0: 7f e3 fb 78 mr r3,r31
return rc;
}
}
rc = rtems_rfs_inode_open (fs, parent, &parent_inode, true);
if (rc > 0)
ffc11ab4: 40 81 00 0c ble- ffc11ac0 <rtems_rfs_inode_create+0x22c><== ALWAYS TAKEN
{
rtems_rfs_inode_delete (fs, &inode);
ffc11ab8: 38 81 00 08 addi r4,r1,8
ffc11abc: 48 00 00 ac b ffc11b68 <rtems_rfs_inode_create+0x2d4>
rtems_rfs_inode_close (fs, &inode);
return rc;
}
rc = rtems_rfs_dir_add_entry (fs, &parent_inode, name, length, *ino);
ffc11ac0: 80 f9 00 00 lwz r7,0(r25)
ffc11ac4: 38 81 00 30 addi r4,r1,48
ffc11ac8: 7f 85 e3 78 mr r5,r28
ffc11acc: 7f a6 eb 78 mr r6,r29
ffc11ad0: 48 00 b2 dd bl ffc1cdac <rtems_rfs_dir_add_entry>
if (rc > 0)
ffc11ad4: 7c 75 1b 79 mr. r21,r3
ffc11ad8: 40 a1 00 28 ble+ ffc11b00 <rtems_rfs_inode_create+0x26c><== ALWAYS TAKEN
{
rtems_rfs_inode_delete (fs, &inode);
ffc11adc: 38 81 00 08 addi r4,r1,8 <== NOT EXECUTED
ffc11ae0: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc11ae4: 4b ff fa a9 bl ffc1158c <rtems_rfs_inode_delete> <== NOT EXECUTED
rtems_rfs_inode_close (fs, &inode);
ffc11ae8: 38 81 00 08 addi r4,r1,8 <== NOT EXECUTED
ffc11aec: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc11af0: 4b ff f9 f9 bl ffc114e8 <rtems_rfs_inode_close> <== NOT EXECUTED
rtems_rfs_inode_close (fs, &parent_inode);
ffc11af4: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc11af8: 38 81 00 30 addi r4,r1,48 <== NOT EXECUTED
ffc11afc: 48 00 00 78 b ffc11b74 <rtems_rfs_inode_create+0x2e0><== NOT EXECUTED
/*
* 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))
ffc11b00: 2f 98 40 00 cmpwi cr7,r24,16384
ffc11b04: 40 be 00 48 bne+ cr7,ffc11b4c <rtems_rfs_inode_create+0x2b8>
rtems_rfs_inode_set_links (&parent_inode,
rtems_rfs_inode_get_links (&parent_inode) + 1);
ffc11b08: 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);
ffc11b0c: 89 69 00 00 lbz r11,0(r9)
ffc11b10: 88 09 00 01 lbz r0,1(r9)
ffc11b14: 55 6b 40 2e rlwinm r11,r11,8,0,23
ffc11b18: 7d 6b 03 78 or r11,r11,r0
if (links == 0xffff)
ffc11b1c: 6d 60 ff ff xoris r0,r11,65535
ffc11b20: 2f 80 ff ff cmpwi cr7,r0,-1
ffc11b24: 40 9e 00 08 bne- cr7,ffc11b2c <rtems_rfs_inode_create+0x298><== ALWAYS TAKEN
links = 0;
ffc11b28: 39 60 00 00 li r11,0 <== NOT EXECUTED
/*
* 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,
ffc11b2c: 39 6b 00 01 addi r11,r11,1
ffc11b30: 55 6b 04 3e clrlwi r11,r11,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);
ffc11b34: 55 60 c2 3e rlwinm r0,r11,24,8,31
ffc11b38: 98 09 00 00 stb r0,0(r9)
rtems_rfs_buffer_mark_dirty (&handle->buffer);
ffc11b3c: 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);
ffc11b40: 81 21 00 3c lwz r9,60(r1)
ffc11b44: 99 69 00 01 stb r11,1(r9)
rtems_rfs_buffer_mark_dirty (&handle->buffer);
ffc11b48: 98 01 00 40 stb r0,64(r1)
rtems_rfs_inode_get_links (&parent_inode) + 1);
rc = rtems_rfs_inode_close (fs, &parent_inode);
ffc11b4c: 38 81 00 30 addi r4,r1,48
ffc11b50: 7f e3 fb 78 mr r3,r31
ffc11b54: 4b ff f9 95 bl ffc114e8 <rtems_rfs_inode_close>
if (rc > 0)
{
rtems_rfs_inode_delete (fs, &inode);
ffc11b58: 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)
ffc11b5c: 7c 75 1b 79 mr. r21,r3
{
rtems_rfs_inode_delete (fs, &inode);
ffc11b60: 7f e3 fb 78 mr r3,r31
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)
ffc11b64: 40 81 00 18 ble- ffc11b7c <rtems_rfs_inode_create+0x2e8><== ALWAYS TAKEN
{
rtems_rfs_inode_delete (fs, &inode);
ffc11b68: 4b ff fa 25 bl ffc1158c <rtems_rfs_inode_delete>
rtems_rfs_inode_close (fs, &inode);
ffc11b6c: 7f e3 fb 78 mr r3,r31
ffc11b70: 38 81 00 08 addi r4,r1,8
ffc11b74: 4b ff f9 75 bl ffc114e8 <rtems_rfs_inode_close>
return rc;
ffc11b78: 48 00 00 2c b ffc11ba4 <rtems_rfs_inode_create+0x310>
}
rc = rtems_rfs_inode_close (fs, &inode);
ffc11b7c: 4b ff f9 6d bl ffc114e8 <rtems_rfs_inode_close>
if (rc > 0)
ffc11b80: 7c 75 1b 79 mr. r21,r3
ffc11b84: 40 81 00 1c ble- ffc11ba0 <rtems_rfs_inode_create+0x30c><== ALWAYS TAKEN
{
rtems_rfs_inode_free (fs, *ino);
ffc11b88: 80 99 00 00 lwz r4,0(r25) <== NOT EXECUTED
ffc11b8c: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc11b90: 4b ff f6 85 bl ffc11214 <rtems_rfs_inode_free> <== NOT EXECUTED
return rc;
ffc11b94: 48 00 00 10 b ffc11ba4 <rtems_rfs_inode_create+0x310><== NOT EXECUTED
case RTEMS_RFS_S_IFBLK:
case RTEMS_RFS_S_IFREG:
case RTEMS_RFS_S_IFLNK:
break;
default:
return EINVAL;
ffc11b98: 3a a0 00 16 li r21,22 <== NOT EXECUTED
ffc11b9c: 48 00 00 08 b ffc11ba4 <rtems_rfs_inode_create+0x310><== NOT EXECUTED
{
rtems_rfs_inode_free (fs, *ino);
return rc;
}
return 0;
ffc11ba0: 3a a0 00 00 li r21,0
}
ffc11ba4: 39 61 00 88 addi r11,r1,136
ffc11ba8: 7e a3 ab 78 mr r3,r21
ffc11bac: 4b ff 0f 24 b ffc02ad0 <_restgpr_21_x>
ffc1158c <rtems_rfs_inode_delete>:
}
int
rtems_rfs_inode_delete (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* handle)
{
ffc1158c: 94 21 ff a0 stwu r1,-96(r1)
ffc11590: 7c 08 02 a6 mflr r0
ffc11594: bf c1 00 58 stmw r30,88(r1)
ffc11598: 7c 7e 1b 78 mr r30,r3
ffc1159c: 7c 9f 23 78 mr r31,r4
int rc = 0;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_DELETE))
ffc115a0: 38 60 00 00 li r3,0
}
int
rtems_rfs_inode_delete (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* handle)
{
ffc115a4: 90 01 00 64 stw r0,100(r1)
int rc = 0;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_DELETE))
ffc115a8: 3c 80 00 80 lis r4,128
ffc115ac: 48 00 1d 59 bl ffc13304 <rtems_rfs_trace>
ffc115b0: 2f 83 00 00 cmpwi cr7,r3,0
ffc115b4: 41 9e 00 38 beq- cr7,ffc115ec <rtems_rfs_inode_delete+0x60><== ALWAYS TAKEN
printf("rtems-rfs: inode-delete: ino:%" PRIu32 " loaded:%s\n",
ffc115b8: 80 1f 00 0c lwz r0,12(r31) <== NOT EXECUTED
ffc115bc: 80 9f 00 08 lwz r4,8(r31) <== NOT EXECUTED
ffc115c0: 2f 80 00 00 cmpwi cr7,r0,0 <== NOT EXECUTED
ffc115c4: 41 9e 00 10 beq- cr7,ffc115d4 <rtems_rfs_inode_delete+0x48><== NOT EXECUTED
ffc115c8: 3c a0 ff c3 lis r5,-61 <== NOT EXECUTED
ffc115cc: 38 a5 34 57 addi r5,r5,13399 <== NOT EXECUTED
ffc115d0: 48 00 00 0c b ffc115dc <rtems_rfs_inode_delete+0x50> <== NOT EXECUTED
ffc115d4: 3c a0 ff c3 lis r5,-61 <== NOT EXECUTED
ffc115d8: 38 a5 38 ec addi r5,r5,14572 <== NOT EXECUTED
ffc115dc: 3c 60 ff c3 lis r3,-61 <== NOT EXECUTED
ffc115e0: 38 63 35 34 addi r3,r3,13620 <== NOT EXECUTED
ffc115e4: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc115e8: 48 01 15 01 bl ffc22ae8 <printf> <== NOT EXECUTED
rtems_rfs_inode_ino (handle),
rtems_rfs_inode_is_loaded (handle) ? "yes" : "no");
if (rtems_rfs_inode_is_loaded (handle))
ffc115ec: 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;
ffc115f0: 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))
ffc115f4: 2f 80 00 00 cmpwi cr7,r0,0
ffc115f8: 41 9e 00 78 beq- cr7,ffc11670 <rtems_rfs_inode_delete+0xe4><== NEVER TAKEN
rtems_rfs_block_map map;
/*
* Free the ino number.
*/
rc = rtems_rfs_inode_free (fs, handle->ino);
ffc115fc: 80 9f 00 08 lwz r4,8(r31)
ffc11600: 7f c3 f3 78 mr r3,r30
ffc11604: 4b ff fc 11 bl ffc11214 <rtems_rfs_inode_free>
if (rc > 0)
ffc11608: 2c 03 00 00 cmpwi r3,0
ffc1160c: 41 a1 00 64 bgt+ ffc11670 <rtems_rfs_inode_delete+0xe4> <== NEVER TAKEN
return rc;
/*
* Free the blocks the inode may have attached.
*/
rc = rtems_rfs_block_map_open (fs, handle, &map);
ffc11610: 7f c3 f3 78 mr r3,r30
ffc11614: 7f e4 fb 78 mr r4,r31
ffc11618: 38 a1 00 08 addi r5,r1,8
ffc1161c: 48 00 9b c1 bl ffc1b1dc <rtems_rfs_block_map_open>
if (rc == 0)
ffc11620: 2c 03 00 00 cmpwi r3,0
ffc11624: 40 a2 00 4c bne+ ffc11670 <rtems_rfs_inode_delete+0xe4> <== NEVER TAKEN
{
int rrc;
rrc = rtems_rfs_block_map_free_all (fs, &map);
ffc11628: 38 81 00 08 addi r4,r1,8
ffc1162c: 7f c3 f3 78 mr r3,r30
ffc11630: 48 00 a8 25 bl ffc1be54 <rtems_rfs_block_map_free_all>
rc = rtems_rfs_block_map_close (fs, &map);
ffc11634: 38 81 00 08 addi r4,r1,8
ffc11638: 7f c3 f3 78 mr r3,r30
ffc1163c: 48 00 9d 55 bl ffc1b390 <rtems_rfs_block_map_close>
if (rc > 0)
rrc = rc;
memset (handle->node, 0xff, RTEMS_RFS_INODE_SIZE);
ffc11640: 80 7f 00 0c lwz r3,12(r31)
ffc11644: 38 80 00 ff li r4,255
ffc11648: 38 a0 00 38 li r5,56
ffc1164c: 48 01 13 0d bl ffc22958 <memset>
rtems_rfs_buffer_mark_dirty (&handle->buffer);
ffc11650: 38 00 00 01 li r0,1
ffc11654: 7f e4 fb 78 mr r4,r31
ffc11658: 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);
ffc1165c: 7f c3 f3 78 mr r3,r30
ffc11660: 48 00 a9 a9 bl ffc1c008 <rtems_rfs_buffer_handle_release>
handle->loads = 0;
ffc11664: 38 00 00 00 li r0,0
ffc11668: 90 1f 00 24 stw r0,36(r31)
handle->node = NULL;
ffc1166c: 90 1f 00 0c stw r0,12(r31)
}
}
return rc;
}
ffc11670: 39 61 00 60 addi r11,r1,96
ffc11674: 4b ff 14 80 b ffc02af4 <_restgpr_30_x>
ffc1fe6c <rtems_rfs_inode_get_block.isra.0>:
* @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]);
ffc1fe6c: 54 80 10 3a rlwinm r0,r4,2,0,29 <== NOT EXECUTED
ffc1fe70: 38 84 00 04 addi r4,r4,4 <== NOT EXECUTED
ffc1fe74: 54 84 10 3a rlwinm r4,r4,2,0,29 <== NOT EXECUTED
ffc1fe78: 39 23 00 1c addi r9,r3,28 <== NOT EXECUTED
ffc1fe7c: 7c 63 22 14 add r3,r3,r4 <== NOT EXECUTED
ffc1fe80: 7d 29 02 14 add r9,r9,r0 <== NOT EXECUTED
ffc1fe84: 88 63 00 0c lbz r3,12(r3) <== NOT EXECUTED
ffc1fe88: 88 09 00 03 lbz r0,3(r9) <== NOT EXECUTED
ffc1fe8c: 54 63 c0 0e rlwinm r3,r3,24,0,7 <== NOT EXECUTED
ffc1fe90: 7c 03 1b 78 or r3,r0,r3 <== NOT EXECUTED
ffc1fe94: 88 09 00 01 lbz r0,1(r9) <== NOT EXECUTED
ffc1fe98: 54 00 80 1e rlwinm r0,r0,16,0,15 <== NOT EXECUTED
ffc1fe9c: 7c 63 03 78 or r3,r3,r0 <== NOT EXECUTED
ffc1fea0: 88 09 00 02 lbz r0,2(r9) <== NOT EXECUTED
ffc1fea4: 54 00 40 2e rlwinm r0,r0,8,0,23 <== NOT EXECUTED
}
ffc1fea8: 7c 63 03 78 or r3,r3,r0 <== NOT EXECUTED
ffc1feac: 4e 80 00 20 blr <== NOT EXECUTED
ffc11dcc <rtems_rfs_inode_get_block.isra.9>:
* @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]);
ffc11dcc: 54 80 10 3a rlwinm r0,r4,2,0,29 <== NOT EXECUTED
ffc11dd0: 38 84 00 04 addi r4,r4,4 <== NOT EXECUTED
ffc11dd4: 54 84 10 3a rlwinm r4,r4,2,0,29 <== NOT EXECUTED
ffc11dd8: 39 23 00 1c addi r9,r3,28 <== NOT EXECUTED
ffc11ddc: 7c 63 22 14 add r3,r3,r4 <== NOT EXECUTED
ffc11de0: 7d 29 02 14 add r9,r9,r0 <== NOT EXECUTED
ffc11de4: 88 63 00 0c lbz r3,12(r3) <== NOT EXECUTED
ffc11de8: 88 09 00 03 lbz r0,3(r9) <== NOT EXECUTED
ffc11dec: 54 63 c0 0e rlwinm r3,r3,24,0,7 <== NOT EXECUTED
ffc11df0: 7c 03 1b 78 or r3,r0,r3 <== NOT EXECUTED
ffc11df4: 88 09 00 01 lbz r0,1(r9) <== NOT EXECUTED
ffc11df8: 54 00 80 1e rlwinm r0,r0,16,0,15 <== NOT EXECUTED
ffc11dfc: 7c 63 03 78 or r3,r3,r0 <== NOT EXECUTED
ffc11e00: 88 09 00 02 lbz r0,2(r9) <== NOT EXECUTED
ffc11e04: 54 00 40 2e rlwinm r0,r0,8,0,23 <== NOT EXECUTED
}
ffc11e08: 7c 63 03 78 or r3,r3,r0 <== NOT EXECUTED
ffc11e0c: 4e 80 00 20 blr <== NOT EXECUTED
ffc1123c <rtems_rfs_inode_load>:
}
int
rtems_rfs_inode_load (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* handle)
{
ffc1123c: 94 21 ff f0 stwu r1,-16(r1)
ffc11240: 7c 08 02 a6 mflr r0
ffc11244: bf c1 00 08 stmw r30,8(r1)
ffc11248: 7c 7e 1b 78 mr r30,r3
ffc1124c: 7c 9f 23 78 mr r31,r4
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_LOAD))
ffc11250: 38 60 00 00 li r3,0
}
int
rtems_rfs_inode_load (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* handle)
{
ffc11254: 90 01 00 14 stw r0,20(r1)
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_LOAD))
ffc11258: 3c 80 00 10 lis r4,16
ffc1125c: 48 00 20 a9 bl ffc13304 <rtems_rfs_trace>
ffc11260: 2f 83 00 00 cmpwi cr7,r3,0
ffc11264: 41 9e 00 3c beq- cr7,ffc112a0 <rtems_rfs_inode_load+0x64><== ALWAYS TAKEN
printf ("rtems-rfs: inode-load: ino=%" PRIu32 " loads=%i loaded=%s\n",
ffc11268: 80 1f 00 0c lwz r0,12(r31) <== NOT EXECUTED
ffc1126c: 80 9f 00 08 lwz r4,8(r31) <== NOT EXECUTED
ffc11270: 2f 80 00 00 cmpwi cr7,r0,0 <== NOT EXECUTED
ffc11274: 80 bf 00 24 lwz r5,36(r31) <== NOT EXECUTED
ffc11278: 41 9e 00 10 beq- cr7,ffc11288 <rtems_rfs_inode_load+0x4c><== NOT EXECUTED
ffc1127c: 3c c0 ff c3 lis r6,-61 <== NOT EXECUTED
ffc11280: 38 c6 34 57 addi r6,r6,13399 <== NOT EXECUTED
ffc11284: 48 00 00 0c b ffc11290 <rtems_rfs_inode_load+0x54> <== NOT EXECUTED
ffc11288: 3c c0 ff c3 lis r6,-61 <== NOT EXECUTED
ffc1128c: 38 c6 38 ec addi r6,r6,14572 <== NOT EXECUTED
ffc11290: 3c 60 ff c3 lis r3,-61 <== NOT EXECUTED
ffc11294: 38 63 34 5b addi r3,r3,13403 <== NOT EXECUTED
ffc11298: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc1129c: 48 01 18 4d bl ffc22ae8 <printf> <== NOT EXECUTED
/*
* An inode does not move so once loaded no need to do again.
*/
if (!rtems_rfs_inode_is_loaded (handle))
ffc112a0: 80 1f 00 0c lwz r0,12(r31)
ffc112a4: 2f 80 00 00 cmpwi cr7,r0,0
ffc112a8: 40 be 00 38 bne+ cr7,ffc112e0 <rtems_rfs_inode_load+0xa4>
{
int rc;
rc = rtems_rfs_buffer_handle_request (fs,&handle->buffer,
ffc112ac: 80 bf 00 1c lwz r5,28(r31)
ffc112b0: 7f c3 f3 78 mr r3,r30
ffc112b4: 38 9f 00 10 addi r4,r31,16
ffc112b8: 38 c0 00 01 li r6,1
ffc112bc: 48 00 af 2d bl ffc1c1e8 <rtems_rfs_buffer_handle_request>
handle->block, true);
if (rc > 0)
ffc112c0: 2c 03 00 00 cmpwi r3,0
ffc112c4: 41 a1 00 2c bgt+ ffc112f0 <rtems_rfs_inode_load+0xb4> <== NEVER TAKEN
return rc;
handle->node = rtems_rfs_buffer_data (&handle->buffer);
ffc112c8: 81 3f 00 18 lwz r9,24(r31)
handle->node += handle->offset;
ffc112cc: 80 1f 00 20 lwz r0,32(r31)
ffc112d0: 81 29 00 24 lwz r9,36(r9)
ffc112d4: 1c 00 00 38 mulli r0,r0,56
ffc112d8: 7c 09 02 14 add r0,r9,r0
ffc112dc: 90 1f 00 0c stw r0,12(r31)
}
handle->loads++;
ffc112e0: 81 3f 00 24 lwz r9,36(r31)
return 0;
ffc112e4: 38 60 00 00 li r3,0
handle->node = rtems_rfs_buffer_data (&handle->buffer);
handle->node += handle->offset;
}
handle->loads++;
ffc112e8: 38 09 00 01 addi r0,r9,1
ffc112ec: 90 1f 00 24 stw r0,36(r31)
return 0;
}
ffc112f0: 39 61 00 10 addi r11,r1,16
ffc112f4: 4b ff 18 00 b ffc02af4 <_restgpr_30_x>
ffc112f8 <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)
{
ffc112f8: 94 21 ff e8 stwu r1,-24(r1)
ffc112fc: 7c 08 02 a6 mflr r0
ffc11300: bf 81 00 08 stmw r28,8(r1)
ffc11304: 7c 7f 1b 78 mr r31,r3
ffc11308: 7c 9e 23 78 mr r30,r4
int group;
int gino;
int index;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_OPEN))
ffc1130c: 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)
{
ffc11310: 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))
ffc11314: 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)
{
ffc11318: 7c bd 2b 78 mr r29,r5
ffc1131c: 7c dc 33 78 mr r28,r6
int group;
int gino;
int index;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_OPEN))
ffc11320: 48 00 1f e5 bl ffc13304 <rtems_rfs_trace>
ffc11324: 2f 83 00 00 cmpwi cr7,r3,0
ffc11328: 41 be 00 18 beq+ cr7,ffc11340 <rtems_rfs_inode_open+0x48><== ALWAYS TAKEN
printf ("rtems-rfs: inode-open: ino: %" PRIu32 "\n", ino);
ffc1132c: 3c 60 ff c3 lis r3,-61 <== NOT EXECUTED
ffc11330: 38 63 34 8e addi r3,r3,13454 <== NOT EXECUTED
ffc11334: 7f c4 f3 78 mr r4,r30 <== NOT EXECUTED
ffc11338: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc1133c: 48 01 17 ad bl ffc22ae8 <printf> <== NOT EXECUTED
if (ino == RTEMS_RFS_EMPTY_INO)
ffc11340: 2f 9e 00 00 cmpwi cr7,r30,0
return EINVAL;
ffc11344: 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)
ffc11348: 41 be 00 94 beq+ cr7,ffc113dc <rtems_rfs_inode_open+0xe4><== NEVER TAKEN
return EINVAL;
if ((ino - RTEMS_RFS_ROOT_INO) > rtems_rfs_fs_inodes (fs))
ffc1134c: 80 1f 00 10 lwz r0,16(r31)
ffc11350: 39 3e ff ff addi r9,r30,-1
ffc11354: 7f 89 00 40 cmplw cr7,r9,r0
ffc11358: 41 bd 00 84 bgt+ cr7,ffc113dc <rtems_rfs_inode_open+0xe4><== NEVER TAKEN
handle->ino = ino;
handle->node = NULL;
handle->loads = 0;
gino = ino - RTEMS_RFS_ROOT_INO;
group = gino / fs->group_inodes;
ffc1135c: 81 7f 00 28 lwz r11,40(r31)
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)
ffc11360: 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;
ffc11364: 81 1f 00 2c lwz r8,44(r31)
if ((ino - RTEMS_RFS_ROOT_INO) > rtems_rfs_fs_inodes (fs))
return EINVAL;
handle->ino = ino;
handle->node = NULL;
ffc11368: 38 00 00 00 li r0,0
handle->loads = 0;
gino = ino - RTEMS_RFS_ROOT_INO;
group = gino / fs->group_inodes;
gino = gino % fs->group_inodes;
ffc1136c: 7d 49 5b 96 divwu r10,r9,r11
return EINVAL;
if ((ino - RTEMS_RFS_ROOT_INO) > rtems_rfs_fs_inodes (fs))
return EINVAL;
handle->ino = ino;
ffc11370: 93 dd 00 08 stw r30,8(r29)
handle->node = NULL;
ffc11374: 90 1d 00 0c stw r0,12(r29)
handle->loads = 0;
ffc11378: 90 1d 00 24 stw r0,36(r29)
gino = ino - RTEMS_RFS_ROOT_INO;
group = gino / fs->group_inodes;
gino = gino % fs->group_inodes;
ffc1137c: 7d 6a 59 d6 mullw r11,r10,r11
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);
ffc11380: 1d 4a 00 50 mulli r10,r10,80
handle->node = NULL;
handle->loads = 0;
gino = ino - RTEMS_RFS_ROOT_INO;
group = gino / fs->group_inodes;
gino = gino % fs->group_inodes;
ffc11384: 7d 2b 48 50 subf r9,r11,r9
index = (gino / fs->inodes_per_block) + RTEMS_RFS_GROUP_INODE_BLOCK;
handle->offset = gino % fs->inodes_per_block;
ffc11388: 7d 69 43 96 divwu r11,r9,r8
ffc1138c: 7d 0b 41 d6 mullw r8,r11,r8
handle->block = rtems_rfs_group_block (&fs->groups[group], index);
rc = rtems_rfs_buffer_handle_open (fs, &handle->buffer);
ffc11390: 38 60 00 00 li r3,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;
ffc11394: 7d 28 48 50 subf r9,r8,r9
ffc11398: 91 3d 00 20 stw r9,32(r29)
handle->block = rtems_rfs_group_block (&fs->groups[group], index);
ffc1139c: 81 3f 00 1c lwz r9,28(r31)
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;
ffc113a0: 7d 29 50 2e lwzx r9,r9,r10
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
ffc113a4: 98 1d 00 10 stb r0,16(r29)
ffc113a8: 39 29 00 02 addi r9,r9,2
handle->offset = gino % fs->inodes_per_block;
handle->block = rtems_rfs_group_block (&fs->groups[group], index);
ffc113ac: 7d 69 5a 14 add r11,r9,r11
handle->bnum = 0;
ffc113b0: 90 1d 00 14 stw r0,20(r29)
ffc113b4: 91 7d 00 1c stw r11,28(r29)
handle->buffer = NULL;
ffc113b8: 90 1d 00 18 stw r0,24(r29)
rc = rtems_rfs_buffer_handle_open (fs, &handle->buffer);
if ((rc == 0) && load)
ffc113bc: 41 be 00 20 beq+ cr7,ffc113dc <rtems_rfs_inode_open+0xe4><== NEVER TAKEN
rc = rtems_rfs_inode_load (fs, handle);
return rc;
}
ffc113c0: 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);
ffc113c4: 7f e3 fb 78 mr r3,r31
ffc113c8: 7f a4 eb 78 mr r4,r29
return rc;
}
ffc113cc: bb 81 00 08 lmw r28,8(r1)
ffc113d0: 7c 08 03 a6 mtlr r0
ffc113d4: 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);
ffc113d8: 4b ff fe 64 b ffc1123c <rtems_rfs_inode_load>
return rc;
}
ffc113dc: 39 61 00 18 addi r11,r1,24 <== NOT EXECUTED
ffc113e0: 4b ff 17 0c b ffc02aec <_restgpr_28_x> <== NOT EXECUTED
ffc0fe58 <rtems_rfs_inode_overhead>:
/**
* Return the inode overhead given a number of inodes.
*/
static int
rtems_rfs_inode_overhead (rtems_rfs_file_system* fs)
{
ffc0fe58: 94 21 ff f0 stwu r1,-16(r1) <== NOT EXECUTED
ffc0fe5c: 7c 08 02 a6 mflr r0 <== NOT EXECUTED
ffc0fe60: 90 01 00 14 stw r0,20(r1) <== NOT EXECUTED
ffc0fe64: bf c1 00 08 stmw r30,8(r1) <== NOT EXECUTED
ffc0fe68: 7c 7f 1b 78 mr r31,r3 <== 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));
ffc0fe6c: 83 c3 00 08 lwz r30,8(r3) <== 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,
ffc0fe70: 80 63 00 28 lwz r3,40(r3) <== NOT EXECUTED
ffc0fe74: 7f c4 f3 78 mr r4,r30 <== NOT EXECUTED
ffc0fe78: 1c 63 00 38 mulli r3,r3,56 <== NOT EXECUTED
ffc0fe7c: 4b ff ff bd bl ffc0fe38 <rtems_rfs_rup_quotient> <== 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))
ffc0fe80: 81 3f 00 04 lwz r9,4(r31) <== 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));
ffc0fe84: 57 de 18 38 rlwinm r30,r30,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))
ffc0fe88: 38 09 ff ff addi r0,r9,-1 <== NOT EXECUTED
ffc0fe8c: 7f 9e 00 40 cmplw cr7,r30,r0 <== NOT EXECUTED
ffc0fe90: 41 bd 00 08 bgt+ cr7,ffc0fe98 <rtems_rfs_inode_overhead+0x40><== 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));
ffc0fe94: 7f c0 f3 78 mr r0,r30 <== 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))
bits_per_block = rtems_rfs_fs_blocks (fs) - RTEMS_RFS_SUPERBLOCK_SIZE;
return ((blocks + 1) * 100 * 10) / bits_per_block;
ffc0fe98: 38 63 00 01 addi r3,r3,1 <== NOT EXECUTED
ffc0fe9c: 1c 63 03 e8 mulli r3,r3,1000 <== NOT EXECUTED
}
ffc0fea0: 39 61 00 10 addi r11,r1,16 <== NOT EXECUTED
ffc0fea4: 7c 63 03 d6 divw r3,r3,r0 <== NOT EXECUTED
ffc0fea8: 4b ff 2c 4c b ffc02af4 <_restgpr_30_x> <== NOT EXECUTED
ffc11c18 <rtems_rfs_inode_set_block>:
* @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);
ffc11c18: 80 03 00 0c lwz r0,12(r3) <== NOT EXECUTED
ffc11c1c: 39 24 00 04 addi r9,r4,4 <== NOT EXECUTED
ffc11c20: 55 29 10 3a rlwinm r9,r9,2,0,29 <== NOT EXECUTED
ffc11c24: 7d 20 4a 14 add r9,r0,r9 <== NOT EXECUTED
ffc11c28: 54 a0 46 3e rlwinm r0,r5,8,24,31 <== NOT EXECUTED
ffc11c2c: 98 09 00 0c stb r0,12(r9) <== NOT EXECUTED
ffc11c30: 54 84 10 3a rlwinm r4,r4,2,0,29 <== NOT EXECUTED
ffc11c34: 54 a0 84 3e rlwinm r0,r5,16,16,31 <== NOT EXECUTED
ffc11c38: 81 23 00 0c lwz r9,12(r3) <== NOT EXECUTED
ffc11c3c: 7d 29 22 14 add r9,r9,r4 <== NOT EXECUTED
ffc11c40: 98 09 00 1d stb r0,29(r9) <== NOT EXECUTED
ffc11c44: 54 a0 c2 3e rlwinm r0,r5,24,8,31 <== NOT EXECUTED
ffc11c48: 81 23 00 0c lwz r9,12(r3) <== NOT EXECUTED
ffc11c4c: 7d 29 22 14 add r9,r9,r4 <== NOT EXECUTED
ffc11c50: 98 09 00 1e stb r0,30(r9) <== NOT EXECUTED
ffc11c54: 80 03 00 0c lwz r0,12(r3) <== NOT EXECUTED
ffc11c58: 7c 80 22 14 add r4,r0,r4 <== NOT EXECUTED
rtems_rfs_buffer_mark_dirty (&handle->buffer);
ffc11c5c: 38 00 00 01 li r0,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);
ffc11c60: 98 a4 00 1f stb r5,31(r4) <== NOT EXECUTED
rtems_rfs_buffer_mark_dirty (&handle->buffer);
ffc11c64: 98 03 00 10 stb r0,16(r3) <== NOT EXECUTED
}
ffc11c68: 4e 80 00 20 blr <== NOT EXECUTED
ffc11678 <rtems_rfs_inode_time_stamp_now>:
int
rtems_rfs_inode_time_stamp_now (rtems_rfs_inode_handle* handle,
bool atime,
bool mtime)
{
ffc11678: 94 21 ff e8 stwu r1,-24(r1)
ffc1167c: 7c 08 02 a6 mflr r0
ffc11680: 90 01 00 1c stw r0,28(r1)
time_t now;
if (!rtems_rfs_inode_is_loaded (handle))
ffc11684: 80 03 00 0c lwz r0,12(r3)
int
rtems_rfs_inode_time_stamp_now (rtems_rfs_inode_handle* handle,
bool atime,
bool mtime)
{
ffc11688: bf a1 00 0c stmw r29,12(r1)
ffc1168c: 7c 7f 1b 78 mr r31,r3
time_t now;
if (!rtems_rfs_inode_is_loaded (handle))
ffc11690: 2f 80 00 00 cmpwi cr7,r0,0
int
rtems_rfs_inode_time_stamp_now (rtems_rfs_inode_handle* handle,
bool atime,
bool mtime)
{
ffc11694: 7c 9e 23 78 mr r30,r4
ffc11698: 7c bd 2b 78 mr r29,r5
time_t now;
if (!rtems_rfs_inode_is_loaded (handle))
return ENXIO;
ffc1169c: 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))
ffc116a0: 41 9e 00 8c beq- cr7,ffc1172c <rtems_rfs_inode_time_stamp_now+0xb4><== NEVER TAKEN
return ENXIO;
now = time (NULL);
ffc116a4: 38 60 00 00 li r3,0
ffc116a8: 48 01 4c c1 bl ffc26368 <time>
if (atime)
ffc116ac: 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);
ffc116b0: 7c 60 1b 78 mr r0,r3
if (atime)
ffc116b4: 41 9e 00 38 beq- cr7,ffc116ec <rtems_rfs_inode_time_stamp_now+0x74><== 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);
ffc116b8: 81 3f 00 0c lwz r9,12(r31)
ffc116bc: 54 6b 46 3e rlwinm r11,r3,8,24,31
ffc116c0: 99 69 00 10 stb r11,16(r9)
ffc116c4: 54 6b 84 3e rlwinm r11,r3,16,16,31
ffc116c8: 81 3f 00 0c lwz r9,12(r31)
ffc116cc: 99 69 00 11 stb r11,17(r9)
ffc116d0: 54 6b c2 3e rlwinm r11,r3,24,8,31
ffc116d4: 81 3f 00 0c lwz r9,12(r31)
ffc116d8: 99 69 00 12 stb r11,18(r9)
ffc116dc: 81 3f 00 0c lwz r9,12(r31)
ffc116e0: 98 69 00 13 stb r3,19(r9)
rtems_rfs_buffer_mark_dirty (&handle->buffer);
ffc116e4: 39 20 00 01 li r9,1
ffc116e8: 99 3f 00 10 stb r9,16(r31)
rtems_rfs_inode_set_atime (handle, now);
if (mtime)
ffc116ec: 2f 9d 00 00 cmpwi cr7,r29,0
rtems_rfs_inode_set_mtime (handle, now);
return 0;
ffc116f0: 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)
ffc116f4: 41 9e 00 38 beq- cr7,ffc1172c <rtems_rfs_inode_time_stamp_now+0xb4><== 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);
ffc116f8: 81 3f 00 0c lwz r9,12(r31)
ffc116fc: 54 0b 46 3e rlwinm r11,r0,8,24,31
ffc11700: 99 69 00 14 stb r11,20(r9)
ffc11704: 54 0b 84 3e rlwinm r11,r0,16,16,31
ffc11708: 81 3f 00 0c lwz r9,12(r31)
ffc1170c: 99 69 00 15 stb r11,21(r9)
ffc11710: 54 0b c2 3e rlwinm r11,r0,24,8,31
ffc11714: 81 3f 00 0c lwz r9,12(r31)
ffc11718: 99 69 00 16 stb r11,22(r9)
ffc1171c: 81 3f 00 0c lwz r9,12(r31)
ffc11720: 98 09 00 17 stb r0,23(r9)
rtems_rfs_buffer_mark_dirty (&handle->buffer);
ffc11724: 38 00 00 01 li r0,1
ffc11728: 98 1f 00 10 stb r0,16(r31)
rtems_rfs_inode_set_mtime (handle, now);
return 0;
}
ffc1172c: 39 61 00 18 addi r11,r1,24
ffc11730: 4b ff 13 c0 b ffc02af0 <_restgpr_29_x>
ffc113e4 <rtems_rfs_inode_unload>:
int
rtems_rfs_inode_unload (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* handle,
bool update_ctime)
{
ffc113e4: 94 21 ff e8 stwu r1,-24(r1)
ffc113e8: 7c 08 02 a6 mflr r0
ffc113ec: bf a1 00 0c stmw r29,12(r1)
ffc113f0: 7c 7e 1b 78 mr r30,r3
ffc113f4: 7c 9f 23 78 mr r31,r4
int rc = 0;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_UNLOAD))
ffc113f8: 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)
{
ffc113fc: 90 01 00 1c stw r0,28(r1)
int rc = 0;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_UNLOAD))
ffc11400: 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)
{
ffc11404: 7c bd 2b 78 mr r29,r5
int rc = 0;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_UNLOAD))
ffc11408: 48 00 1e fd bl ffc13304 <rtems_rfs_trace>
ffc1140c: 2f 83 00 00 cmpwi cr7,r3,0
ffc11410: 41 9e 00 3c beq- cr7,ffc1144c <rtems_rfs_inode_unload+0x68><== ALWAYS TAKEN
printf ("rtems-rfs: inode-unload: ino=%" PRIu32 " loads=%i loaded=%s\n",
ffc11414: 80 1f 00 0c lwz r0,12(r31) <== NOT EXECUTED
ffc11418: 80 9f 00 08 lwz r4,8(r31) <== NOT EXECUTED
ffc1141c: 2f 80 00 00 cmpwi cr7,r0,0 <== NOT EXECUTED
ffc11420: 80 bf 00 24 lwz r5,36(r31) <== NOT EXECUTED
ffc11424: 41 9e 00 10 beq- cr7,ffc11434 <rtems_rfs_inode_unload+0x50><== NOT EXECUTED
ffc11428: 3c c0 ff c3 lis r6,-61 <== NOT EXECUTED
ffc1142c: 38 c6 34 57 addi r6,r6,13399 <== NOT EXECUTED
ffc11430: 48 00 00 0c b ffc1143c <rtems_rfs_inode_unload+0x58> <== NOT EXECUTED
ffc11434: 3c c0 ff c3 lis r6,-61 <== NOT EXECUTED
ffc11438: 38 c6 38 ec addi r6,r6,14572 <== NOT EXECUTED
ffc1143c: 3c 60 ff c3 lis r3,-61 <== NOT EXECUTED
ffc11440: 38 63 34 af addi r3,r3,13487 <== NOT EXECUTED
ffc11444: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc11448: 48 01 16 a1 bl ffc22ae8 <printf> <== NOT EXECUTED
handle->ino, handle->loads,
rtems_rfs_inode_is_loaded (handle) ? "yes" : "no");
if (rtems_rfs_inode_is_loaded (handle))
ffc1144c: 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;
ffc11450: 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))
ffc11454: 2f 80 00 00 cmpwi cr7,r0,0
ffc11458: 41 9e 00 88 beq- cr7,ffc114e0 <rtems_rfs_inode_unload+0xfc>
{
if (handle->loads == 0)
ffc1145c: 81 3f 00 24 lwz r9,36(r31)
return EIO;
ffc11460: 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)
ffc11464: 2f 89 00 00 cmpwi cr7,r9,0
ffc11468: 41 be 00 78 beq+ cr7,ffc114e0 <rtems_rfs_inode_unload+0xfc><== NEVER TAKEN
return EIO;
handle->loads--;
ffc1146c: 38 09 ff ff addi r0,r9,-1
if (handle->loads == 0)
ffc11470: 2f 80 00 00 cmpwi cr7,r0,0
if (rtems_rfs_inode_is_loaded (handle))
{
if (handle->loads == 0)
return EIO;
handle->loads--;
ffc11474: 90 1f 00 24 stw r0,36(r31)
int
rtems_rfs_inode_unload (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* handle,
bool update_ctime)
{
int rc = 0;
ffc11478: 38 60 00 00 li r3,0
if (handle->loads == 0)
return EIO;
handle->loads--;
if (handle->loads == 0)
ffc1147c: 40 9e 00 64 bne- cr7,ffc114e0 <rtems_rfs_inode_unload+0xfc>
{
/*
* If the buffer is dirty it will be release. Also set the ctime.
*/
if (rtems_rfs_buffer_dirty (&handle->buffer) && update_ctime)
ffc11480: 88 1f 00 10 lbz r0,16(r31)
ffc11484: 2f 80 00 00 cmpwi cr7,r0,0
ffc11488: 41 9e 00 44 beq- cr7,ffc114cc <rtems_rfs_inode_unload+0xe8>
ffc1148c: 2f 9d 00 00 cmpwi cr7,r29,0
ffc11490: 41 be 00 3c beq+ cr7,ffc114cc <rtems_rfs_inode_unload+0xe8><== NEVER TAKEN
rtems_rfs_inode_set_ctime (handle, time (NULL));
ffc11494: 48 01 4e d5 bl ffc26368 <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);
ffc11498: 81 3f 00 0c lwz r9,12(r31)
ffc1149c: 54 60 46 3e rlwinm r0,r3,8,24,31
ffc114a0: 98 09 00 18 stb r0,24(r9)
ffc114a4: 54 60 84 3e rlwinm r0,r3,16,16,31
ffc114a8: 81 3f 00 0c lwz r9,12(r31)
ffc114ac: 98 09 00 19 stb r0,25(r9)
ffc114b0: 54 60 c2 3e rlwinm r0,r3,24,8,31
ffc114b4: 81 3f 00 0c lwz r9,12(r31)
ffc114b8: 98 09 00 1a stb r0,26(r9)
rtems_rfs_buffer_mark_dirty (&handle->buffer);
ffc114bc: 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);
ffc114c0: 81 3f 00 0c lwz r9,12(r31)
ffc114c4: 98 69 00 1b stb r3,27(r9)
rtems_rfs_buffer_mark_dirty (&handle->buffer);
ffc114c8: 98 1f 00 10 stb r0,16(r31)
rc = rtems_rfs_buffer_handle_release (fs, &handle->buffer);
ffc114cc: 7f c3 f3 78 mr r3,r30
ffc114d0: 38 9f 00 10 addi r4,r31,16
ffc114d4: 48 00 ab 35 bl ffc1c008 <rtems_rfs_buffer_handle_release>
handle->node = NULL;
ffc114d8: 38 00 00 00 li r0,0
ffc114dc: 90 1f 00 0c stw r0,12(r31)
}
}
return rc;
}
ffc114e0: 39 61 00 18 addi r11,r1,24
ffc114e4: 4b ff 16 0c b ffc02af0 <_restgpr_29_x>
ffc1f1d0 <rtems_rfs_link>:
const char* name,
int length,
rtems_rfs_ino parent,
rtems_rfs_ino target,
bool link_dir)
{
ffc1f1d0: 94 21 ff 88 stwu r1,-120(r1)
ffc1f1d4: 7c 08 02 a6 mflr r0
ffc1f1d8: bf 21 00 5c stmw r25,92(r1)
ffc1f1dc: 7c 7f 1b 78 mr r31,r3
ffc1f1e0: 7c 9d 23 78 mr r29,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))
ffc1f1e4: 38 60 00 00 li r3,0
const char* name,
int length,
rtems_rfs_ino parent,
rtems_rfs_ino target,
bool link_dir)
{
ffc1f1e8: 90 01 00 7c stw r0,124(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))
ffc1f1ec: 3c 80 01 00 lis r4,256
const char* name,
int length,
rtems_rfs_ino parent,
rtems_rfs_ino target,
bool link_dir)
{
ffc1f1f0: 7c be 2b 78 mr r30,r5
ffc1f1f4: 7c dc 33 78 mr r28,r6
ffc1f1f8: 7c fb 3b 78 mr r27,r7
ffc1f1fc: 7d 1a 43 78 mr r26,r8
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))
ffc1f200: 4b ff 41 05 bl ffc13304 <rtems_rfs_trace>
ffc1f204: 2f 83 00 00 cmpwi cr7,r3,0
ffc1f208: 41 be 00 48 beq+ cr7,ffc1f250 <rtems_rfs_link+0x80> <== ALWAYS TAKEN
{
int c;
printf ("rtems-rfs: link: parent(%" PRIu32 ") -> ", parent);
ffc1f20c: 3c 60 ff c3 lis r3,-61 <== NOT EXECUTED
ffc1f210: 38 63 54 1e addi r3,r3,21534 <== NOT EXECUTED
ffc1f214: 7f 84 e3 78 mr r4,r28 <== NOT EXECUTED
ffc1f218: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc1f21c: 48 00 38 cd bl ffc22ae8 <printf> <== NOT EXECUTED
for (c = 0; c < length; c++)
ffc1f220: 3b 20 00 00 li r25,0 <== NOT EXECUTED
ffc1f224: 48 00 00 10 b ffc1f234 <rtems_rfs_link+0x64> <== NOT EXECUTED
printf ("%c", name[c]);
ffc1f228: 7c 7d c8 ae lbzx r3,r29,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++)
ffc1f22c: 3b 39 00 01 addi r25,r25,1 <== NOT EXECUTED
printf ("%c", name[c]);
ffc1f230: 48 00 39 75 bl ffc22ba4 <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++)
ffc1f234: 7f 99 f0 00 cmpw cr7,r25,r30 <== NOT EXECUTED
ffc1f238: 41 9c ff f0 blt+ cr7,ffc1f228 <rtems_rfs_link+0x58> <== NOT EXECUTED
printf ("%c", name[c]);
printf ("(%" PRIu32 ")\n", target);
ffc1f23c: 3c 60 ff c3 lis r3,-61 <== NOT EXECUTED
ffc1f240: 38 63 54 63 addi r3,r3,21603 <== NOT EXECUTED
ffc1f244: 7f 64 db 78 mr r4,r27 <== NOT EXECUTED
ffc1f248: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc1f24c: 48 00 38 9d bl ffc22ae8 <printf> <== NOT EXECUTED
}
rc = rtems_rfs_inode_open (fs, target, &target_inode, true);
ffc1f250: 7f e3 fb 78 mr r3,r31
ffc1f254: 7f 64 db 78 mr r4,r27
ffc1f258: 38 a1 00 08 addi r5,r1,8
ffc1f25c: 38 c0 00 01 li r6,1
ffc1f260: 4b ff 20 99 bl ffc112f8 <rtems_rfs_inode_open>
if (rc)
ffc1f264: 7c 79 1b 79 mr. r25,r3
ffc1f268: 40 82 01 08 bne- ffc1f370 <rtems_rfs_link+0x1a0> <== 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)))
ffc1f26c: 2f 9a 00 00 cmpwi cr7,r26,0
{
rtems_rfs_inode_close (fs, &target_inode);
ffc1f270: 7f e3 fb 78 mr r3,r31
/*
* 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)))
ffc1f274: 40 9e 00 28 bne- cr7,ffc1f29c <rtems_rfs_link+0xcc> <== NEVER TAKEN
ffc1f278: 81 21 00 14 lwz r9,20(r1)
ffc1f27c: 88 09 00 02 lbz r0,2(r9)
ffc1f280: 54 00 44 26 rlwinm r0,r0,8,16,19
ffc1f284: 2f 80 40 00 cmpwi cr7,r0,16384
ffc1f288: 40 be 00 14 bne+ cr7,ffc1f29c <rtems_rfs_link+0xcc> <== ALWAYS TAKEN
{
rtems_rfs_inode_close (fs, &target_inode);
ffc1f28c: 38 81 00 08 addi r4,r1,8 <== NOT EXECUTED
ffc1f290: 4b ff 22 59 bl ffc114e8 <rtems_rfs_inode_close> <== NOT EXECUTED
return ENOTSUP;
ffc1f294: 3b 20 00 86 li r25,134 <== NOT EXECUTED
ffc1f298: 48 00 00 d8 b ffc1f370 <rtems_rfs_link+0x1a0> <== NOT EXECUTED
}
rc = rtems_rfs_inode_open (fs, parent, &parent_inode, true);
ffc1f29c: 7f 84 e3 78 mr r4,r28
ffc1f2a0: 38 a1 00 30 addi r5,r1,48
ffc1f2a4: 38 c0 00 01 li r6,1
ffc1f2a8: 4b ff 20 51 bl ffc112f8 <rtems_rfs_inode_open>
if (rc)
ffc1f2ac: 7c 79 1b 79 mr. r25,r3
{
rtems_rfs_inode_close (fs, &target_inode);
ffc1f2b0: 7f e3 fb 78 mr r3,r31
rtems_rfs_inode_close (fs, &target_inode);
return ENOTSUP;
}
rc = rtems_rfs_inode_open (fs, parent, &parent_inode, true);
if (rc)
ffc1f2b4: 40 82 00 30 bne- ffc1f2e4 <rtems_rfs_link+0x114> <== NEVER TAKEN
{
rtems_rfs_inode_close (fs, &target_inode);
return rc;
}
rc = rtems_rfs_dir_add_entry (fs, &parent_inode, name, length, target);
ffc1f2b8: 38 81 00 30 addi r4,r1,48
ffc1f2bc: 7f a5 eb 78 mr r5,r29
ffc1f2c0: 7f c6 f3 78 mr r6,r30
ffc1f2c4: 7f 67 db 78 mr r7,r27
ffc1f2c8: 4b ff da e5 bl ffc1cdac <rtems_rfs_dir_add_entry>
if (rc > 0)
ffc1f2cc: 7c 79 1b 79 mr. r25,r3
ffc1f2d0: 40 a1 00 20 ble+ ffc1f2f0 <rtems_rfs_link+0x120> <== ALWAYS TAKEN
{
rtems_rfs_inode_close (fs, &parent_inode);
ffc1f2d4: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc1f2d8: 38 81 00 30 addi r4,r1,48 <== NOT EXECUTED
ffc1f2dc: 4b ff 22 0d bl ffc114e8 <rtems_rfs_inode_close> <== NOT EXECUTED
rtems_rfs_inode_close (fs, &target_inode);
ffc1f2e0: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc1f2e4: 38 81 00 08 addi r4,r1,8 <== NOT EXECUTED
ffc1f2e8: 4b ff 22 01 bl ffc114e8 <rtems_rfs_inode_close> <== NOT EXECUTED
return rc;
ffc1f2ec: 48 00 00 84 b ffc1f370 <rtems_rfs_link+0x1a0> <== NOT EXECUTED
}
links = rtems_rfs_inode_get_links (&target_inode) + 1;
ffc1f2f0: 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);
ffc1f2f4: 89 69 00 00 lbz r11,0(r9)
ffc1f2f8: 88 09 00 01 lbz r0,1(r9)
ffc1f2fc: 55 6b 40 2e rlwinm r11,r11,8,0,23
ffc1f300: 7d 6b 03 78 or r11,r11,r0
if (links == 0xffff)
ffc1f304: 6d 60 ff ff xoris r0,r11,65535
ffc1f308: 2f 80 ff ff cmpwi cr7,r0,-1
ffc1f30c: 40 9e 00 08 bne- cr7,ffc1f314 <rtems_rfs_link+0x144> <== ALWAYS TAKEN
links = 0;
ffc1f310: 39 60 00 00 li r11,0 <== NOT EXECUTED
ffc1f314: 39 6b 00 01 addi r11,r11,1
ffc1f318: 55 6b 04 3e clrlwi r11,r11,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);
ffc1f31c: 55 60 c2 3e rlwinm r0,r11,24,8,31
ffc1f320: 98 09 00 00 stb r0,0(r9)
rtems_rfs_inode_set_links (&target_inode, links);
rc = rtems_rfs_inode_time_stamp_now (&parent_inode, true, true);
ffc1f324: 38 80 00 01 li r4,1
rtems_rfs_buffer_mark_dirty (&handle->buffer);
ffc1f328: 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);
ffc1f32c: 81 21 00 14 lwz r9,20(r1)
ffc1f330: 38 61 00 30 addi r3,r1,48
ffc1f334: 38 a0 00 01 li r5,1
ffc1f338: 99 69 00 01 stb r11,1(r9)
rtems_rfs_buffer_mark_dirty (&handle->buffer);
ffc1f33c: 98 01 00 18 stb r0,24(r1)
ffc1f340: 4b ff 23 39 bl ffc11678 <rtems_rfs_inode_time_stamp_now>
if (rc > 0)
ffc1f344: 7c 79 1b 79 mr. r25,r3
{
rtems_rfs_inode_close (fs, &parent_inode);
ffc1f348: 38 81 00 30 addi r4,r1,48
ffc1f34c: 7f e3 fb 78 mr r3,r31
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)
ffc1f350: 41 81 ff 8c bgt+ ffc1f2dc <rtems_rfs_link+0x10c> <== NEVER TAKEN
rtems_rfs_inode_close (fs, &parent_inode);
rtems_rfs_inode_close (fs, &target_inode);
return rc;
}
rc = rtems_rfs_inode_close (fs, &parent_inode);
ffc1f354: 4b ff 21 95 bl ffc114e8 <rtems_rfs_inode_close>
if (rc > 0)
{
rtems_rfs_inode_close (fs, &target_inode);
ffc1f358: 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)
ffc1f35c: 7c 79 1b 79 mr. r25,r3
{
rtems_rfs_inode_close (fs, &target_inode);
ffc1f360: 7f e3 fb 78 mr r3,r31
rtems_rfs_inode_close (fs, &target_inode);
return rc;
}
rc = rtems_rfs_inode_close (fs, &parent_inode);
if (rc > 0)
ffc1f364: 41 81 ff 84 bgt+ ffc1f2e8 <rtems_rfs_link+0x118> <== NEVER TAKEN
{
rtems_rfs_inode_close (fs, &target_inode);
return rc;
}
rc = rtems_rfs_inode_close (fs, &target_inode);
ffc1f368: 4b ff 21 81 bl ffc114e8 <rtems_rfs_inode_close>
ffc1f36c: 7c 79 1b 78 mr r25,r3
return rc;
}
ffc1f370: 39 61 00 78 addi r11,r1,120
ffc1f374: 7f 23 cb 78 mr r3,r25
ffc1f378: 4b fe 37 68 b ffc02ae0 <_restgpr_25_x>
ffc1fb8c <rtems_rfs_mutex_create>:
RTEMS_NO_INHERIT_PRIORITY | RTEMS_NO_PRIORITY_CEILING | RTEMS_LOCAL)
#endif
int
rtems_rfs_mutex_create (rtems_rfs_mutex* mutex)
{
ffc1fb8c: 94 21 ff f0 stwu r1,-16(r1)
ffc1fb90: 7c 08 02 a6 mflr r0
ffc1fb94: 7c 67 1b 78 mr r7,r3
#if __rtems__
rtems_status_code sc;
sc = rtems_semaphore_create (rtems_build_name ('R', 'F', 'S', 'm'),
ffc1fb98: 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)
{
ffc1fb9c: bf c1 00 08 stmw r30,8(r1)
#if __rtems__
rtems_status_code sc;
sc = rtems_semaphore_create (rtems_build_name ('R', 'F', 'S', 'm'),
ffc1fba0: 60 63 53 6d ori r3,r3,21357
ffc1fba4: 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)
{
ffc1fba8: 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'),
ffc1fbac: 38 a0 00 24 li r5,36
ffc1fbb0: 38 c0 00 00 li r6,0
ffc1fbb4: 4b fe be c9 bl ffc0ba7c <rtems_semaphore_create>
printf ("rtems-rfs: mutex: open failed: %s\n",
rtems_status_text (sc));
return EIO;
}
#endif
return 0;
ffc1fbb8: 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)
ffc1fbbc: 7c 7e 1b 79 mr. r30,r3
ffc1fbc0: 41 a2 00 38 beq+ ffc1fbf8 <rtems_rfs_mutex_create+0x6c> <== ALWAYS TAKEN
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
ffc1fbc4: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc1fbc8: 38 80 00 04 li r4,4 <== NOT EXECUTED
ffc1fbcc: 4b ff 37 39 bl ffc13304 <rtems_rfs_trace> <== NOT EXECUTED
printf ("rtems-rfs: mutex: open failed: %s\n",
rtems_status_text (sc));
return EIO;
ffc1fbd0: 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))
ffc1fbd4: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc1fbd8: 41 be 00 20 beq+ cr7,ffc1fbf8 <rtems_rfs_mutex_create+0x6c><== NOT EXECUTED
printf ("rtems-rfs: mutex: open failed: %s\n",
ffc1fbdc: 7f c3 f3 78 mr r3,r30 <== NOT EXECUTED
ffc1fbe0: 4b ff 76 dd bl ffc172bc <rtems_status_text> <== NOT EXECUTED
ffc1fbe4: 7c 64 1b 78 mr r4,r3 <== NOT EXECUTED
ffc1fbe8: 3c 60 ff c3 lis r3,-61 <== NOT EXECUTED
ffc1fbec: 38 63 56 3c addi r3,r3,22076 <== NOT EXECUTED
ffc1fbf0: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc1fbf4: 48 00 2e f5 bl ffc22ae8 <printf> <== NOT EXECUTED
rtems_status_text (sc));
return EIO;
}
#endif
return 0;
}
ffc1fbf8: 39 61 00 10 addi r11,r1,16
ffc1fbfc: 7f e3 fb 78 mr r3,r31
ffc1fc00: 4b fe 2e f4 b ffc02af4 <_restgpr_30_x>
ffc1fc04 <rtems_rfs_mutex_destroy>:
int
rtems_rfs_mutex_destroy (rtems_rfs_mutex* mutex)
{
ffc1fc04: 94 21 ff f0 stwu r1,-16(r1)
ffc1fc08: 7c 08 02 a6 mflr r0
ffc1fc0c: 90 01 00 14 stw r0,20(r1)
#if __rtems__
rtems_status_code sc;
sc = rtems_semaphore_delete (*mutex);
ffc1fc10: 80 63 00 00 lwz r3,0(r3)
return 0;
}
int
rtems_rfs_mutex_destroy (rtems_rfs_mutex* mutex)
{
ffc1fc14: bf c1 00 08 stmw r30,8(r1)
printf ("rtems-rfs: mutex: close failed: %s\n",
rtems_status_text (sc));
return EIO;
}
#endif
return 0;
ffc1fc18: 3b e0 00 00 li r31,0
int
rtems_rfs_mutex_destroy (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc;
sc = rtems_semaphore_delete (*mutex);
ffc1fc1c: 4b fe c0 1d bl ffc0bc38 <rtems_semaphore_delete>
if (sc != RTEMS_SUCCESSFUL)
ffc1fc20: 7c 7e 1b 79 mr. r30,r3
ffc1fc24: 41 a2 00 38 beq+ ffc1fc5c <rtems_rfs_mutex_destroy+0x58><== ALWAYS TAKEN
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
ffc1fc28: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc1fc2c: 38 80 00 04 li r4,4 <== NOT EXECUTED
ffc1fc30: 4b ff 36 d5 bl ffc13304 <rtems_rfs_trace> <== NOT EXECUTED
printf ("rtems-rfs: mutex: close failed: %s\n",
rtems_status_text (sc));
return EIO;
ffc1fc34: 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))
ffc1fc38: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc1fc3c: 41 be 00 20 beq+ cr7,ffc1fc5c <rtems_rfs_mutex_destroy+0x58><== NOT EXECUTED
printf ("rtems-rfs: mutex: close failed: %s\n",
ffc1fc40: 7f c3 f3 78 mr r3,r30 <== NOT EXECUTED
ffc1fc44: 4b ff 76 79 bl ffc172bc <rtems_status_text> <== NOT EXECUTED
ffc1fc48: 7c 64 1b 78 mr r4,r3 <== NOT EXECUTED
ffc1fc4c: 3c 60 ff c3 lis r3,-61 <== NOT EXECUTED
ffc1fc50: 38 63 56 5f addi r3,r3,22111 <== NOT EXECUTED
ffc1fc54: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc1fc58: 48 00 2e 91 bl ffc22ae8 <printf> <== NOT EXECUTED
rtems_status_text (sc));
return EIO;
}
#endif
return 0;
}
ffc1fc5c: 39 61 00 10 addi r11,r1,16
ffc1fc60: 7f e3 fb 78 mr r3,r31
ffc1fc64: 4b fe 2e 90 b ffc02af4 <_restgpr_30_x>
ffc11e10 <rtems_rfs_mutex_lock.isra.15>:
* @param mutex The mutex to lock.
* @retval true The mutex is locked.
* @retval false The mutex could not be locked.
*/
static inline int
rtems_rfs_mutex_lock (rtems_rfs_mutex* mutex)
ffc11e10: 94 21 ff f0 stwu r1,-16(r1)
ffc11e14: 7c 08 02 a6 mflr r0
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
ffc11e18: 38 80 00 00 li r4,0
ffc11e1c: 38 a0 00 00 li r5,0
* @param mutex The mutex to lock.
* @retval true The mutex is locked.
* @retval false The mutex could not be locked.
*/
static inline int
rtems_rfs_mutex_lock (rtems_rfs_mutex* mutex)
ffc11e20: bf c1 00 08 stmw r30,8(r1)
rtems_status_text (sc));
#endif
return EIO;
}
#endif
return 0;
ffc11e24: 3b e0 00 00 li r31,0
* @param mutex The mutex to lock.
* @retval true The mutex is locked.
* @retval false The mutex could not be locked.
*/
static inline int
rtems_rfs_mutex_lock (rtems_rfs_mutex* mutex)
ffc11e28: 90 01 00 14 stw r0,20(r1)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
ffc11e2c: 4b ff 9e c5 bl ffc0bcf0 <rtems_semaphore_obtain>
if (sc != RTEMS_SUCCESSFUL)
ffc11e30: 7c 7e 1b 79 mr. r30,r3
ffc11e34: 41 a2 00 38 beq+ ffc11e6c <rtems_rfs_mutex_lock.isra.15+0x5c><== ALWAYS TAKEN
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
ffc11e38: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc11e3c: 38 80 00 04 li r4,4 <== NOT EXECUTED
ffc11e40: 48 00 14 c5 bl ffc13304 <rtems_rfs_trace> <== NOT EXECUTED
printf ("rtems-rfs: mutex: obtain failed: %s\n",
rtems_status_text (sc));
#endif
return EIO;
ffc11e44: 3b e0 00 05 li r31,5 <== 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))
ffc11e48: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc11e4c: 41 be 00 20 beq+ cr7,ffc11e6c <rtems_rfs_mutex_lock.isra.15+0x5c><== NOT EXECUTED
printf ("rtems-rfs: mutex: obtain failed: %s\n",
ffc11e50: 7f c3 f3 78 mr r3,r30 <== NOT EXECUTED
ffc11e54: 48 00 54 69 bl ffc172bc <rtems_status_text> <== NOT EXECUTED
ffc11e58: 7c 64 1b 78 mr r4,r3 <== NOT EXECUTED
ffc11e5c: 3c 60 ff c3 lis r3,-61 <== NOT EXECUTED
ffc11e60: 38 63 36 5a addi r3,r3,13914 <== NOT EXECUTED
ffc11e64: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc11e68: 48 01 0c 81 bl ffc22ae8 <printf> <== NOT EXECUTED
#endif
return EIO;
}
#endif
return 0;
}
ffc11e6c: 39 61 00 10 addi r11,r1,16
ffc11e70: 7f e3 fb 78 mr r3,r31
ffc11e74: 4b ff 0c 80 b ffc02af4 <_restgpr_30_x>
ffc1be5c <rtems_rfs_release_chain>:
static int
rtems_rfs_release_chain (rtems_chain_control* chain,
uint32_t* count,
bool modified)
{
ffc1be5c: 94 21 ff e0 stwu r1,-32(r1)
ffc1be60: 7c 08 02 a6 mflr r0
ffc1be64: bf 41 00 08 stmw r26,8(r1)
ffc1be68: 7c 7f 1b 78 mr r31,r3
ffc1be6c: 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))
ffc1be70: 38 60 00 00 li r3,0
static int
rtems_rfs_release_chain (rtems_chain_control* chain,
uint32_t* count,
bool modified)
{
ffc1be74: 90 01 00 24 stw r0,36(r1)
rtems_rfs_buffer* buffer;
int rrc = 0;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))
ffc1be78: 38 80 00 80 li r4,128
static int
rtems_rfs_release_chain (rtems_chain_control* chain,
uint32_t* count,
bool modified)
{
ffc1be7c: 7c ba 2b 78 mr r26,r5
rtems_rfs_buffer* buffer;
int rrc = 0;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))
ffc1be80: 4b ff 74 85 bl ffc13304 <rtems_rfs_trace>
ffc1be84: 2f 83 00 00 cmpwi cr7,r3,0
ffc1be88: 41 be 00 18 beq+ cr7,ffc1bea0 <rtems_rfs_release_chain+0x44><== ALWAYS TAKEN
printf ("rtems-rfs: release-chain: count=%" PRIu32 "\n", *count);
ffc1be8c: 3c 60 ff c3 lis r3,-61 <== NOT EXECUTED
ffc1be90: 80 9e 00 00 lwz r4,0(r30) <== NOT EXECUTED
ffc1be94: 38 63 42 b4 addi r3,r3,17076 <== NOT EXECUTED
ffc1be98: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc1be9c: 48 00 6c 4d bl ffc22ae8 <printf> <== NOT EXECUTED
(*count)--;
buffer->user = (void*) 0;
rc = rtems_rfs_buffer_io_release (buffer, modified);
if ((rc > 0) && (rrc == 0))
ffc1bea0: 3b a0 00 00 li r29,0
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
ffc1bea4: 3b 7f 00 04 addi r27,r31,4
while (!rtems_chain_is_empty (chain))
{
buffer = (rtems_rfs_buffer*) rtems_chain_get (chain);
(*count)--;
buffer->user = (void*) 0;
ffc1bea8: 3b 80 00 00 li r28,0
ffc1beac: 48 00 00 38 b ffc1bee4 <rtems_rfs_release_chain+0x88>
*/
RTEMS_INLINE_ROUTINE rtems_chain_node *rtems_chain_get(
rtems_chain_control *the_chain
)
{
return _Chain_Get( the_chain );
ffc1beb0: 7f e3 fb 78 mr r3,r31
ffc1beb4: 4b ff 0b bd bl ffc0ca70 <_Chain_Get>
printf ("rtems-rfs: release-chain: count=%" PRIu32 "\n", *count);
while (!rtems_chain_is_empty (chain))
{
buffer = (rtems_rfs_buffer*) rtems_chain_get (chain);
(*count)--;
ffc1beb8: 81 7e 00 00 lwz r11,0(r30)
buffer->user = (void*) 0;
rc = rtems_rfs_buffer_io_release (buffer, modified);
ffc1bebc: 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)--;
ffc1bec0: 38 0b ff ff addi r0,r11,-1
ffc1bec4: 90 1e 00 00 stw r0,0(r30)
buffer->user = (void*) 0;
ffc1bec8: 93 83 00 3c stw r28,60(r3)
rc = rtems_rfs_buffer_io_release (buffer, modified);
ffc1becc: 48 00 57 bd bl ffc21688 <rtems_rfs_buffer_bdbuf_release>
if ((rc > 0) && (rrc == 0))
ffc1bed0: 2c 03 00 00 cmpwi r3,0
ffc1bed4: 40 81 00 10 ble- ffc1bee4 <rtems_rfs_release_chain+0x88><== ALWAYS TAKEN
ffc1bed8: 2f 9d 00 00 cmpwi cr7,r29,0 <== NOT EXECUTED
ffc1bedc: 40 9e 00 08 bne- cr7,ffc1bee4 <rtems_rfs_release_chain+0x88><== NOT EXECUTED
ffc1bee0: 7c 7d 1b 78 mr r29,r3 <== 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))
ffc1bee4: 80 1f 00 00 lwz r0,0(r31)
ffc1bee8: 7f 80 d8 00 cmpw cr7,r0,r27
ffc1beec: 40 9e ff c4 bne+ cr7,ffc1beb0 <rtems_rfs_release_chain+0x54>
rc = rtems_rfs_buffer_io_release (buffer, modified);
if ((rc > 0) && (rrc == 0))
rrc = rc;
}
return rrc;
}
ffc1bef0: 39 61 00 20 addi r11,r1,32
ffc1bef4: 7f a3 eb 78 mr r3,r29
ffc1bef8: 4b fe 6b ec b ffc02ae4 <_restgpr_26_x>
ffc12364 <rtems_rfs_rtems_chown>:
static int
rtems_rfs_rtems_chown (rtems_filesystem_location_info_t *pathloc,
uid_t owner,
gid_t group)
{
ffc12364: 94 21 ff b8 stwu r1,-72(r1)
ffc12368: 7c 08 02 a6 mflr r0
ffc1236c: 90 01 00 4c stw r0,76(r1)
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
ffc12370: 81 23 00 10 lwz r9,16(r3)
static int
rtems_rfs_rtems_chown (rtems_filesystem_location_info_t *pathloc,
uid_t owner,
gid_t group)
{
ffc12374: bf 81 00 38 stmw r28,56(r1)
ffc12378: 7c 9e 23 78 mr r30,r4
ffc1237c: 7c bd 2b 78 mr r29,r5
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
ffc12380: 83 e9 00 34 lwz r31,52(r9)
rtems_rfs_ino ino = rtems_rfs_rtems_get_pathloc_ino (pathloc);
ffc12384: 83 83 00 00 lwz r28,0(r3)
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_CHOWN))
printf ("rtems-rfs-rtems: chown: in: ino:%" PRId32 " uid:%d gid:%d\n",
ino, owner, group);
rtems_rfs_rtems_lock (fs);
ffc12388: 80 7f 00 7c lwz r3,124(r31)
ffc1238c: 4b ff fb bd bl ffc11f48 <rtems_rfs_rtems_lock.isra.16>
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
ffc12390: 7f 84 e3 78 mr r4,r28
ffc12394: 7f e3 fb 78 mr r3,r31
ffc12398: 38 a1 00 08 addi r5,r1,8
ffc1239c: 38 c0 00 01 li r6,1
ffc123a0: 4b ff ef 59 bl ffc112f8 <rtems_rfs_inode_open>
if (rc > 0)
ffc123a4: 7c 7c 1b 79 mr. r28,r3
ffc123a8: 40 81 00 18 ble- ffc123c0 <rtems_rfs_rtems_chown+0x5c> <== ALWAYS TAKEN
{
rtems_rfs_rtems_unlock (fs);
ffc123ac: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc123b0: 4b ff f9 69 bl ffc11d18 <rtems_rfs_rtems_unlock> <== NOT EXECUTED
return rtems_rfs_rtems_error ("chown: opening inode", rc);
ffc123b4: 48 00 f6 51 bl ffc21a04 <__errno> <== NOT EXECUTED
ffc123b8: 93 83 00 00 stw r28,0(r3) <== NOT EXECUTED
ffc123bc: 48 00 00 50 b ffc1240c <rtems_rfs_rtems_chown+0xa8> <== NOT EXECUTED
/*
* Verify I am the owner of the node or the super user.
*/
#if defined (RTEMS_POSIX_API)
uid = geteuid();
ffc123c0: 48 00 52 e9 bl ffc176a8 <geteuid>
if ((uid != rtems_rfs_inode_get_uid (&inode)) && (uid != 0))
ffc123c4: 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;
ffc123c8: 88 09 00 06 lbz r0,6(r9)
ffc123cc: 89 69 00 07 lbz r11,7(r9)
ffc123d0: 54 00 40 2e rlwinm r0,r0,8,0,23
ffc123d4: 7c 00 5b 78 or r0,r0,r11
ffc123d8: 54 00 04 3e clrlwi r0,r0,16
ffc123dc: 7f 83 00 00 cmpw cr7,r3,r0
ffc123e0: 41 9e 00 34 beq- cr7,ffc12414 <rtems_rfs_rtems_chown+0xb0><== ALWAYS TAKEN
ffc123e4: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc123e8: 41 be 00 2c beq+ cr7,ffc12414 <rtems_rfs_rtems_chown+0xb0><== NOT EXECUTED
{
rtems_rfs_inode_close (fs, &inode);
ffc123ec: 38 81 00 08 addi r4,r1,8 <== NOT EXECUTED
ffc123f0: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc123f4: 4b ff f0 f5 bl ffc114e8 <rtems_rfs_inode_close> <== NOT EXECUTED
rtems_rfs_rtems_unlock (fs);
ffc123f8: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc123fc: 4b ff f9 1d bl ffc11d18 <rtems_rfs_rtems_unlock> <== NOT EXECUTED
return rtems_rfs_rtems_error ("chown: not able", EPERM);
ffc12400: 48 00 f6 05 bl ffc21a04 <__errno> <== NOT EXECUTED
ffc12404: 38 00 00 01 li r0,1 <== NOT EXECUTED
ffc12408: 90 03 00 00 stw r0,0(r3) <== NOT EXECUTED
ffc1240c: 38 60 ff ff li r3,-1 <== NOT EXECUTED
ffc12410: 48 00 00 6c b ffc1247c <rtems_rfs_rtems_chown+0x118> <== 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);
ffc12414: 57 bd 80 1e rlwinm r29,r29,16,0,15
ffc12418: 7f bd f3 78 or r29,r29,r30
ffc1241c: 57 a0 46 3e rlwinm r0,r29,8,24,31
ffc12420: 98 09 00 04 stb r0,4(r9)
ffc12424: 57 a0 84 3e rlwinm r0,r29,16,16,31
ffc12428: 57 bd c2 3e rlwinm r29,r29,24,8,31
ffc1242c: 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);
ffc12430: 7f e3 fb 78 mr r3,r31
ffc12434: 38 81 00 08 addi r4,r1,8
ffc12438: 98 09 00 05 stb r0,5(r9)
rtems_rfs_buffer_mark_dirty (&handle->buffer);
ffc1243c: 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);
ffc12440: 81 21 00 14 lwz r9,20(r1)
ffc12444: 9b a9 00 06 stb r29,6(r9)
ffc12448: 81 21 00 14 lwz r9,20(r1)
ffc1244c: 9b c9 00 07 stb r30,7(r9)
rtems_rfs_buffer_mark_dirty (&handle->buffer);
ffc12450: 98 01 00 18 stb r0,24(r1)
ffc12454: 4b ff f0 95 bl ffc114e8 <rtems_rfs_inode_close>
if (rc)
ffc12458: 7c 7e 1b 79 mr. r30,r3
{
rtems_rfs_rtems_unlock (fs);
ffc1245c: 7f e3 fb 78 mr r3,r31
#endif
rtems_rfs_inode_set_uid_gid (&inode, owner, group);
rc = rtems_rfs_inode_close (fs, &inode);
if (rc)
ffc12460: 41 82 00 14 beq- ffc12474 <rtems_rfs_rtems_chown+0x110> <== ALWAYS TAKEN
{
rtems_rfs_rtems_unlock (fs);
ffc12464: 4b ff f8 b5 bl ffc11d18 <rtems_rfs_rtems_unlock> <== NOT EXECUTED
return rtems_rfs_rtems_error ("chown: closing inode", rc);
ffc12468: 48 00 f5 9d bl ffc21a04 <__errno> <== NOT EXECUTED
ffc1246c: 93 c3 00 00 stw r30,0(r3) <== NOT EXECUTED
ffc12470: 4b ff ff 9c b ffc1240c <rtems_rfs_rtems_chown+0xa8> <== NOT EXECUTED
}
rtems_rfs_rtems_unlock (fs);
ffc12474: 4b ff f8 a5 bl ffc11d18 <rtems_rfs_rtems_unlock>
return 0;
ffc12478: 38 60 00 00 li r3,0
}
ffc1247c: 39 61 00 48 addi r11,r1,72
ffc12480: 4b ff 06 6c b ffc02aec <_restgpr_28_x>
ffc1fdc4 <rtems_rfs_rtems_device_close>:
* @return int
*/
static int
rtems_rfs_rtems_device_close (rtems_libio_t* iop)
{
ffc1fdc4: 94 21 ff e8 stwu r1,-24(r1) <== NOT EXECUTED
ffc1fdc8: 7c 08 02 a6 mflr r0 <== NOT EXECUTED
ffc1fdcc: 7c 69 1b 78 mr r9,r3 <== NOT EXECUTED
ffc1fdd0: 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);
ffc1fdd4: 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;
ffc1fdd8: 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;
ffc1fddc: 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;
ffc1fde0: 80 63 00 34 lwz r3,52(r3) <== NOT EXECUTED
minor = (intptr_t) iop->data1;
args.iop = iop;
args.flags = 0;
ffc1fde4: 90 01 00 0c stw r0,12(r1) <== NOT EXECUTED
args.mode = 0;
ffc1fde8: 90 01 00 10 stw r0,16(r1) <== NOT EXECUTED
int minor;
major = (int) iop->data0;
minor = (intptr_t) iop->data1;
args.iop = iop;
ffc1fdec: 91 21 00 08 stw r9,8(r1) <== NOT EXECUTED
args.flags = 0;
args.mode = 0;
status = rtems_io_close (major, minor, (void *) &args);
ffc1fdf0: 48 00 14 f9 bl ffc212e8 <rtems_io_close> <== NOT EXECUTED
return rtems_deviceio_errno (status);
ffc1fdf4: 48 00 0a bd bl ffc208b0 <rtems_deviceio_errno> <== NOT EXECUTED
}
ffc1fdf8: 80 01 00 1c lwz r0,28(r1) <== NOT EXECUTED
ffc1fdfc: 38 21 00 18 addi r1,r1,24 <== NOT EXECUTED
ffc1fe00: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
ffc1fe04: 4e 80 00 20 blr <== NOT EXECUTED
ffc1fc74 <rtems_rfs_rtems_device_ftruncate>:
static int
rtems_rfs_rtems_device_ftruncate (rtems_libio_t* iop, rtems_off64_t length)
{
return 0;
}
ffc1fc74: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc1fc78: 4e 80 00 20 blr <== NOT EXECUTED
ffc1fc7c <rtems_rfs_rtems_device_ioctl>:
static int
rtems_rfs_rtems_device_ioctl (rtems_libio_t* iop,
uint32_t command,
void* buffer)
{
ffc1fc7c: 94 21 ff e8 stwu r1,-24(r1) <== NOT EXECUTED
ffc1fc80: 7c 08 02 a6 mflr r0 <== NOT EXECUTED
ffc1fc84: 7c 69 1b 78 mr r9,r3 <== NOT EXECUTED
ffc1fc88: 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;
ffc1fc8c: 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;
ffc1fc90: 80 63 00 34 lwz r3,52(r3) <== NOT EXECUTED
minor = (intptr_t) iop->data1;
args.iop = iop;
args.command = command;
ffc1fc94: 90 81 00 0c stw r4,12(r1) <== NOT EXECUTED
args.buffer = buffer;
status = rtems_io_control (major, minor, (void *) &args);
ffc1fc98: 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;
ffc1fc9c: 90 a1 00 10 stw r5,16(r1) <== NOT EXECUTED
status = rtems_io_control (major, minor, (void *) &args);
ffc1fca0: 38 a1 00 08 addi r5,r1,8 <== NOT EXECUTED
int minor;
major = (int) iop->data0;
minor = (intptr_t) iop->data1;
args.iop = iop;
ffc1fca4: 91 21 00 08 stw r9,8(r1) <== NOT EXECUTED
args.command = command;
args.buffer = buffer;
status = rtems_io_control (major, minor, (void *) &args);
ffc1fca8: 48 00 16 a1 bl ffc21348 <rtems_io_control> <== NOT EXECUTED
if (status)
ffc1fcac: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
return rtems_deviceio_errno (status);
return args.ioctl_return;
ffc1fcb0: 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)
ffc1fcb4: 41 be 00 0c beq+ cr7,ffc1fcc0 <rtems_rfs_rtems_device_ioctl+0x44><== NOT EXECUTED
return rtems_deviceio_errno (status);
ffc1fcb8: 48 00 0b f9 bl ffc208b0 <rtems_deviceio_errno> <== NOT EXECUTED
ffc1fcbc: 7c 60 1b 78 mr r0,r3 <== NOT EXECUTED
return args.ioctl_return;
}
ffc1fcc0: 7c 03 03 78 mr r3,r0 <== NOT EXECUTED
ffc1fcc4: 80 01 00 1c lwz r0,28(r1) <== NOT EXECUTED
ffc1fcc8: 38 21 00 18 addi r1,r1,24 <== NOT EXECUTED
ffc1fccc: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
ffc1fcd0: 4e 80 00 20 blr <== NOT EXECUTED
ffc1fc68 <rtems_rfs_rtems_device_lseek>:
rtems_rfs_rtems_device_lseek (rtems_libio_t* iop,
rtems_off64_t offset,
int whence)
{
return offset;
}
ffc1fc68: 7c a3 2b 78 mr r3,r5 <== NOT EXECUTED
ffc1fc6c: 7c c4 33 78 mr r4,r6 <== NOT EXECUTED
ffc1fc70: 4e 80 00 20 blr <== NOT EXECUTED
ffc1feb0 <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)
{
ffc1feb0: 94 21 ff a0 stwu r1,-96(r1) <== NOT EXECUTED
ffc1feb4: 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);
ffc1feb8: 38 80 00 00 li r4,0 <== NOT EXECUTED
ffc1febc: 90 01 00 64 stw r0,100(r1) <== NOT EXECUTED
ffc1fec0: 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);
ffc1fec4: 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)
{
ffc1fec8: bf 41 00 48 stmw r26,72(r1) <== NOT EXECUTED
ffc1fecc: 7c 7f 1b 78 mr r31,r3 <== NOT EXECUTED
ffc1fed0: 7c dd 33 78 mr r29,r6 <== NOT EXECUTED
rtems_libio_open_close_args_t args;
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (&iop->pathinfo);
ffc1fed4: 83 c9 00 34 lwz r30,52(r9) <== NOT EXECUTED
rtems_rfs_ino ino = rtems_rfs_rtems_get_iop_ino (iop);
ffc1fed8: 83 83 00 1c lwz r28,28(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
};
ffc1fedc: 81 3e 00 7c lwz r9,124(r30) <== NOT EXECUTED
ffc1fee0: 80 69 00 00 lwz r3,0(r9) <== NOT EXECUTED
ffc1fee4: 4b fe be 0d bl ffc0bcf0 <rtems_semaphore_obtain> <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
ffc1fee8: 7c 7b 1b 79 mr. r27,r3 <== NOT EXECUTED
ffc1feec: 41 a2 00 34 beq+ ffc1ff20 <rtems_rfs_rtems_device_open+0x70><== NOT EXECUTED
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
ffc1fef0: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc1fef4: 38 80 00 04 li r4,4 <== NOT EXECUTED
ffc1fef8: 4b ff 34 0d bl ffc13304 <rtems_rfs_trace> <== NOT EXECUTED
ffc1fefc: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc1ff00: 41 be 00 20 beq+ cr7,ffc1ff20 <rtems_rfs_rtems_device_open+0x70><== NOT EXECUTED
printf ("rtems-rfs: mutex: obtain failed: %s\n",
ffc1ff04: 7f 63 db 78 mr r3,r27 <== NOT EXECUTED
ffc1ff08: 4b ff 73 b5 bl ffc172bc <rtems_status_text> <== NOT EXECUTED
ffc1ff0c: 7c 64 1b 78 mr r4,r3 <== NOT EXECUTED
ffc1ff10: 3c 60 ff c3 lis r3,-61 <== NOT EXECUTED
ffc1ff14: 38 63 36 5a addi r3,r3,13914 <== NOT EXECUTED
ffc1ff18: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc1ff1c: 48 00 2b cd bl ffc22ae8 <printf> <== NOT EXECUTED
rtems_status_code status;
int rc;
rtems_rfs_rtems_lock (fs);
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
ffc1ff20: 7f 84 e3 78 mr r4,r28 <== NOT EXECUTED
ffc1ff24: 7f c3 f3 78 mr r3,r30 <== NOT EXECUTED
ffc1ff28: 38 a1 00 14 addi r5,r1,20 <== NOT EXECUTED
ffc1ff2c: 38 c0 00 01 li r6,1 <== NOT EXECUTED
ffc1ff30: 4b ff 13 c9 bl ffc112f8 <rtems_rfs_inode_open> <== NOT EXECUTED
if (rc > 0)
ffc1ff34: 7c 7c 1b 79 mr. r28,r3 <== NOT EXECUTED
ffc1ff38: 40 81 00 18 ble- ffc1ff50 <rtems_rfs_rtems_device_open+0xa0><== NOT EXECUTED
{
rtems_rfs_rtems_unlock (fs);
ffc1ff3c: 7f c3 f3 78 mr r3,r30 <== NOT EXECUTED
ffc1ff40: 4b ff fe c9 bl ffc1fe08 <rtems_rfs_rtems_unlock> <== NOT EXECUTED
return rtems_rfs_rtems_error ("device_open: opening inode", rc);
ffc1ff44: 48 00 1a c1 bl ffc21a04 <__errno> <== NOT EXECUTED
ffc1ff48: 93 83 00 00 stw r28,0(r3) <== NOT EXECUTED
ffc1ff4c: 48 00 00 4c b ffc1ff98 <rtems_rfs_rtems_device_open+0xe8><== NOT EXECUTED
}
major = rtems_rfs_inode_get_block (&inode, 0);
ffc1ff50: 83 81 00 20 lwz r28,32(r1) <== NOT EXECUTED
ffc1ff54: 38 80 00 00 li r4,0 <== NOT EXECUTED
ffc1ff58: 7f 83 e3 78 mr r3,r28 <== NOT EXECUTED
ffc1ff5c: 4b ff ff 11 bl ffc1fe6c <rtems_rfs_inode_get_block.isra.0><== NOT EXECUTED
minor = rtems_rfs_inode_get_block (&inode, 1);
ffc1ff60: 38 80 00 01 li r4,1 <== 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);
ffc1ff64: 7c 7b 1b 78 mr r27,r3 <== NOT EXECUTED
minor = rtems_rfs_inode_get_block (&inode, 1);
ffc1ff68: 7f 83 e3 78 mr r3,r28 <== NOT EXECUTED
ffc1ff6c: 4b ff ff 01 bl ffc1fe6c <rtems_rfs_inode_get_block.isra.0><== NOT EXECUTED
rc = rtems_rfs_inode_close (fs, &inode);
ffc1ff70: 38 81 00 14 addi r4,r1,20 <== 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);
minor = rtems_rfs_inode_get_block (&inode, 1);
ffc1ff74: 7c 7c 1b 78 mr r28,r3 <== NOT EXECUTED
rc = rtems_rfs_inode_close (fs, &inode);
ffc1ff78: 7f c3 f3 78 mr r3,r30 <== NOT EXECUTED
ffc1ff7c: 4b ff 15 6d bl ffc114e8 <rtems_rfs_inode_close> <== NOT EXECUTED
if (rc > 0)
ffc1ff80: 7c 7a 1b 79 mr. r26,r3 <== NOT EXECUTED
{
rtems_rfs_rtems_unlock (fs);
ffc1ff84: 7f c3 f3 78 mr r3,r30 <== NOT EXECUTED
major = rtems_rfs_inode_get_block (&inode, 0);
minor = rtems_rfs_inode_get_block (&inode, 1);
rc = rtems_rfs_inode_close (fs, &inode);
if (rc > 0)
ffc1ff88: 40 81 00 18 ble- ffc1ffa0 <rtems_rfs_rtems_device_open+0xf0><== NOT EXECUTED
{
rtems_rfs_rtems_unlock (fs);
ffc1ff8c: 4b ff fe 7d bl ffc1fe08 <rtems_rfs_rtems_unlock> <== NOT EXECUTED
return rtems_rfs_rtems_error ("device_open: closing inode", rc);
ffc1ff90: 48 00 1a 75 bl ffc21a04 <__errno> <== NOT EXECUTED
ffc1ff94: 93 43 00 00 stw r26,0(r3) <== NOT EXECUTED
ffc1ff98: 38 60 ff ff li r3,-1 <== NOT EXECUTED
ffc1ff9c: 48 00 00 34 b ffc1ffd0 <rtems_rfs_rtems_device_open+0x120><== NOT EXECUTED
}
rtems_rfs_rtems_unlock (fs);
ffc1ffa0: 4b ff fe 69 bl ffc1fe08 <rtems_rfs_rtems_unlock> <== NOT EXECUTED
iop->data0 = major;
iop->data1 = (void*)((intptr_t) minor);
args.iop = iop;
args.flags = iop->flags;
ffc1ffa4: 80 1f 00 18 lwz r0,24(r31) <== NOT EXECUTED
return rtems_rfs_rtems_error ("device_open: closing inode", rc);
}
rtems_rfs_rtems_unlock (fs);
iop->data0 = major;
ffc1ffa8: 93 7f 00 34 stw r27,52(r31) <== NOT EXECUTED
args.iop = iop;
args.flags = iop->flags;
args.mode = mode;
status = rtems_io_open (major, minor, (void *) &args);
ffc1ffac: 7f 84 e3 78 mr r4,r28 <== NOT EXECUTED
ffc1ffb0: 38 a1 00 08 addi r5,r1,8 <== NOT EXECUTED
}
rtems_rfs_rtems_unlock (fs);
iop->data0 = major;
iop->data1 = (void*)((intptr_t) minor);
ffc1ffb4: 93 9f 00 38 stw r28,56(r31) <== NOT EXECUTED
args.iop = iop;
args.flags = iop->flags;
args.mode = mode;
status = rtems_io_open (major, minor, (void *) &args);
ffc1ffb8: 7f 63 db 78 mr r3,r27 <== NOT EXECUTED
iop->data0 = major;
iop->data1 = (void*)((intptr_t) minor);
args.iop = iop;
args.flags = iop->flags;
ffc1ffbc: 90 01 00 0c stw r0,12(r1) <== NOT EXECUTED
rtems_rfs_rtems_unlock (fs);
iop->data0 = major;
iop->data1 = (void*)((intptr_t) minor);
args.iop = iop;
ffc1ffc0: 93 e1 00 08 stw r31,8(r1) <== NOT EXECUTED
args.flags = iop->flags;
args.mode = mode;
ffc1ffc4: 93 a1 00 10 stw r29,16(r1) <== NOT EXECUTED
status = rtems_io_open (major, minor, (void *) &args);
ffc1ffc8: 48 00 13 e1 bl ffc213a8 <rtems_io_open> <== NOT EXECUTED
return rtems_deviceio_errno (status);
ffc1ffcc: 48 00 08 e5 bl ffc208b0 <rtems_deviceio_errno> <== NOT EXECUTED
}
ffc1ffd0: 39 61 00 60 addi r11,r1,96 <== NOT EXECUTED
ffc1ffd4: 4b fe 2b 10 b ffc02ae4 <_restgpr_26_x> <== NOT EXECUTED
ffc1fd4c <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)
{
ffc1fd4c: 94 21 ff d8 stwu r1,-40(r1) <== NOT EXECUTED
ffc1fd50: 7c 08 02 a6 mflr r0 <== NOT EXECUTED
ffc1fd54: 7c 69 1b 78 mr r9,r3 <== NOT EXECUTED
ffc1fd58: 90 01 00 2c stw r0,44(r1) <== NOT EXECUTED
int minor;
major = (int) iop->data0;
minor = (intptr_t) iop->data1;
args.iop = iop;
ffc1fd5c: 91 21 00 08 stw r9,8(r1) <== NOT EXECUTED
rtems_status_code status;
int major;
int minor;
major = (int) iop->data0;
minor = (intptr_t) iop->data1;
ffc1fd60: 80 09 00 38 lwz r0,56(r9) <== NOT EXECUTED
args.iop = iop;
args.offset = iop->offset;
ffc1fd64: 81 49 00 10 lwz r10,16(r9) <== NOT EXECUTED
ffc1fd68: 81 69 00 14 lwz r11,20(r9) <== NOT EXECUTED
args.buffer = buffer;
args.count = count;
args.flags = iop->flags;
ffc1fd6c: 81 29 00 18 lwz r9,24(r9) <== NOT EXECUTED
rtems_libio_rw_args_t args;
rtems_status_code status;
int major;
int minor;
major = (int) iop->data0;
ffc1fd70: 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;
ffc1fd74: 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);
ffc1fd78: 7c 04 03 78 mr r4,r0 <== NOT EXECUTED
minor = (intptr_t) iop->data1;
args.iop = iop;
args.offset = iop->offset;
args.buffer = buffer;
args.count = count;
ffc1fd7c: 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);
ffc1fd80: 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;
ffc1fd84: 91 21 00 20 stw r9,32(r1) <== NOT EXECUTED
args.bytes_moved = 0;
ffc1fd88: 39 20 00 00 li r9,0 <== NOT EXECUTED
major = (int) iop->data0;
minor = (intptr_t) iop->data1;
args.iop = iop;
args.offset = iop->offset;
ffc1fd8c: 91 41 00 10 stw r10,16(r1) <== NOT EXECUTED
ffc1fd90: 91 61 00 14 stw r11,20(r1) <== NOT EXECUTED
args.buffer = buffer;
args.count = count;
args.flags = iop->flags;
args.bytes_moved = 0;
ffc1fd94: 91 21 00 24 stw r9,36(r1) <== NOT EXECUTED
status = rtems_io_read (major, minor, (void *) &args);
ffc1fd98: 48 00 16 71 bl ffc21408 <rtems_io_read> <== NOT EXECUTED
if (status)
ffc1fd9c: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
return rtems_deviceio_errno (status);
return (ssize_t) args.bytes_moved;
ffc1fda0: 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)
ffc1fda4: 41 be 00 0c beq+ cr7,ffc1fdb0 <rtems_rfs_rtems_device_read+0x64><== NOT EXECUTED
return rtems_deviceio_errno (status);
ffc1fda8: 48 00 0b 09 bl ffc208b0 <rtems_deviceio_errno> <== NOT EXECUTED
ffc1fdac: 7c 60 1b 78 mr r0,r3 <== NOT EXECUTED
return (ssize_t) args.bytes_moved;
}
ffc1fdb0: 7c 03 03 78 mr r3,r0 <== NOT EXECUTED
ffc1fdb4: 80 01 00 2c lwz r0,44(r1) <== NOT EXECUTED
ffc1fdb8: 38 21 00 28 addi r1,r1,40 <== NOT EXECUTED
ffc1fdbc: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
ffc1fdc0: 4e 80 00 20 blr <== NOT EXECUTED
ffc1fcd4 <rtems_rfs_rtems_device_write>:
static ssize_t
rtems_rfs_rtems_device_write (rtems_libio_t* iop,
const void* buffer,
size_t count)
{
ffc1fcd4: 94 21 ff d8 stwu r1,-40(r1) <== NOT EXECUTED
ffc1fcd8: 7c 08 02 a6 mflr r0 <== NOT EXECUTED
ffc1fcdc: 7c 69 1b 78 mr r9,r3 <== NOT EXECUTED
ffc1fce0: 90 01 00 2c stw r0,44(r1) <== NOT EXECUTED
int minor;
major = (int) iop->data0;
minor = (intptr_t) iop->data1;
args.iop = iop;
ffc1fce4: 91 21 00 08 stw r9,8(r1) <== NOT EXECUTED
rtems_status_code status;
int major;
int minor;
major = (int) iop->data0;
minor = (intptr_t) iop->data1;
ffc1fce8: 80 09 00 38 lwz r0,56(r9) <== NOT EXECUTED
args.iop = iop;
args.offset = iop->offset;
ffc1fcec: 81 49 00 10 lwz r10,16(r9) <== NOT EXECUTED
ffc1fcf0: 81 69 00 14 lwz r11,20(r9) <== NOT EXECUTED
args.buffer = (void *) buffer;
args.count = count;
args.flags = iop->flags;
ffc1fcf4: 81 29 00 18 lwz r9,24(r9) <== NOT EXECUTED
rtems_libio_rw_args_t args;
rtems_status_code status;
int major;
int minor;
major = (int) iop->data0;
ffc1fcf8: 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;
ffc1fcfc: 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);
ffc1fd00: 7c 04 03 78 mr r4,r0 <== NOT EXECUTED
minor = (intptr_t) iop->data1;
args.iop = iop;
args.offset = iop->offset;
args.buffer = (void *) buffer;
args.count = count;
ffc1fd04: 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);
ffc1fd08: 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;
ffc1fd0c: 91 21 00 20 stw r9,32(r1) <== NOT EXECUTED
args.bytes_moved = 0;
ffc1fd10: 39 20 00 00 li r9,0 <== NOT EXECUTED
major = (int) iop->data0;
minor = (intptr_t) iop->data1;
args.iop = iop;
args.offset = iop->offset;
ffc1fd14: 91 41 00 10 stw r10,16(r1) <== NOT EXECUTED
ffc1fd18: 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;
ffc1fd1c: 91 21 00 24 stw r9,36(r1) <== NOT EXECUTED
status = rtems_io_write (major, minor, (void *) &args);
ffc1fd20: 48 00 17 49 bl ffc21468 <rtems_io_write> <== NOT EXECUTED
if (status)
ffc1fd24: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
return rtems_deviceio_errno (status);
return (ssize_t) args.bytes_moved;
ffc1fd28: 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)
ffc1fd2c: 41 be 00 0c beq+ cr7,ffc1fd38 <rtems_rfs_rtems_device_write+0x64><== NOT EXECUTED
return rtems_deviceio_errno (status);
ffc1fd30: 48 00 0b 81 bl ffc208b0 <rtems_deviceio_errno> <== NOT EXECUTED
ffc1fd34: 7c 60 1b 78 mr r0,r3 <== NOT EXECUTED
return (ssize_t) args.bytes_moved;
}
ffc1fd38: 7c 03 03 78 mr r3,r0 <== NOT EXECUTED
ffc1fd3c: 80 01 00 2c lwz r0,44(r1) <== NOT EXECUTED
ffc1fd40: 38 21 00 28 addi r1,r1,40 <== NOT EXECUTED
ffc1fd44: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
ffc1fd48: 4e 80 00 20 blr <== NOT EXECUTED
ffc20044 <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)
ffc20044: 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)
{
ffc20048: 94 21 ff f8 stwu r1,-8(r1) <== NOT EXECUTED
ffc2004c: 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;
ffc20050: 39 40 00 00 li r10,0 <== NOT EXECUTED
ffc20054: 39 60 00 00 li r11,0 <== NOT EXECUTED
*/
static rtems_off64_t
rtems_rfs_rtems_dir_lseek (rtems_libio_t* iop,
rtems_off64_t offset,
int whence)
{
ffc20058: 90 01 00 0c stw r0,12(r1) <== NOT EXECUTED
switch (whence)
ffc2005c: 40 9d 00 18 ble- cr7,ffc20074 <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);
ffc20060: 48 00 19 a5 bl ffc21a04 <__errno> <== NOT EXECUTED
ffc20064: 38 00 00 16 li r0,22 <== NOT EXECUTED
ffc20068: 90 03 00 00 stw r0,0(r3) <== NOT EXECUTED
ffc2006c: 39 40 ff ff li r10,-1 <== NOT EXECUTED
ffc20070: 39 60 ff ff li r11,-1 <== NOT EXECUTED
break;
}
return 0;
}
ffc20074: 80 01 00 0c lwz r0,12(r1) <== NOT EXECUTED
ffc20078: 7d 43 53 78 mr r3,r10 <== NOT EXECUTED
ffc2007c: 7d 64 5b 78 mr r4,r11 <== NOT EXECUTED
ffc20080: 7c 08 03 a6 mtlr r0 <== NOT EXECUTED
ffc20084: 38 21 00 08 addi r1,r1,8 <== NOT EXECUTED
ffc20088: 4e 80 00 20 blr <== NOT EXECUTED
ffc201f8 <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)
{
ffc201f8: 94 21 ff b8 stwu r1,-72(r1)
ffc201fc: 7c 08 02 a6 mflr r0
ffc20200: 90 01 00 4c stw r0,76(r1)
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (&iop->pathinfo);
ffc20204: 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)
{
ffc20208: bf a1 00 3c stmw r29,60(r1)
ffc2020c: 7c 7e 1b 78 mr r30,r3
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (&iop->pathinfo);
ffc20210: 83 e9 00 34 lwz r31,52(r9)
rtems_rfs_ino ino = rtems_rfs_rtems_get_iop_ino (iop);
ffc20214: 83 a3 00 1c lwz r29,28(r3)
rtems_rfs_inode_handle inode;
int rc;
rtems_rfs_rtems_lock (fs);
ffc20218: 80 7f 00 7c lwz r3,124(r31)
ffc2021c: 4b ff fe 71 bl ffc2008c <rtems_rfs_rtems_lock.isra.3>
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
ffc20220: 7f a4 eb 78 mr r4,r29
ffc20224: 7f e3 fb 78 mr r3,r31
ffc20228: 38 a1 00 08 addi r5,r1,8
ffc2022c: 38 c0 00 01 li r6,1
ffc20230: 4b ff 10 c9 bl ffc112f8 <rtems_rfs_inode_open>
if (rc)
ffc20234: 7c 7d 1b 79 mr. r29,r3
ffc20238: 41 a2 00 18 beq+ ffc20250 <rtems_rfs_rtems_dir_open+0x58><== ALWAYS TAKEN
{
rtems_rfs_rtems_unlock (fs);
ffc2023c: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc20240: 4b ff fd a1 bl ffc1ffe0 <rtems_rfs_rtems_unlock> <== NOT EXECUTED
return rtems_rfs_rtems_error ("dir_open: opening inode", rc);
ffc20244: 48 00 17 c1 bl ffc21a04 <__errno> <== NOT EXECUTED
ffc20248: 93 a3 00 00 stw r29,0(r3) <== NOT EXECUTED
ffc2024c: 48 00 00 38 b ffc20284 <rtems_rfs_rtems_dir_open+0x8c><== 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);
ffc20250: 81 21 00 14 lwz r9,20(r1)
ffc20254: 88 09 00 02 lbz r0,2(r9)
}
if (!RTEMS_RFS_S_ISDIR (rtems_rfs_inode_get_mode (&inode)))
ffc20258: 54 00 44 26 rlwinm r0,r0,8,16,19
ffc2025c: 2f 80 40 00 cmpwi cr7,r0,16384
ffc20260: 41 be 00 2c beq+ cr7,ffc2028c <rtems_rfs_rtems_dir_open+0x94><== ALWAYS TAKEN
{
rtems_rfs_inode_close (fs, &inode);
ffc20264: 38 81 00 08 addi r4,r1,8 <== NOT EXECUTED
ffc20268: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc2026c: 4b ff 12 7d bl ffc114e8 <rtems_rfs_inode_close> <== NOT EXECUTED
rtems_rfs_rtems_unlock (fs);
ffc20270: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc20274: 4b ff fd 6d bl ffc1ffe0 <rtems_rfs_rtems_unlock> <== NOT EXECUTED
return rtems_rfs_rtems_error ("dir_open: not dir", ENOTDIR);
ffc20278: 48 00 17 8d bl ffc21a04 <__errno> <== NOT EXECUTED
ffc2027c: 38 00 00 14 li r0,20 <== NOT EXECUTED
ffc20280: 90 03 00 00 stw r0,0(r3) <== NOT EXECUTED
ffc20284: 38 60 ff ff li r3,-1 <== NOT EXECUTED
ffc20288: 48 00 00 2c b ffc202b4 <rtems_rfs_rtems_dir_open+0xbc><== NOT EXECUTED
}
iop->offset = 0;
ffc2028c: 39 40 00 00 li r10,0
ffc20290: 39 60 00 00 li r11,0
ffc20294: 91 5e 00 10 stw r10,16(r30)
rtems_rfs_inode_close (fs, &inode);
ffc20298: 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;
ffc2029c: 91 7e 00 14 stw r11,20(r30)
rtems_rfs_inode_close (fs, &inode);
ffc202a0: 7f e3 fb 78 mr r3,r31
ffc202a4: 4b ff 12 45 bl ffc114e8 <rtems_rfs_inode_close>
rtems_rfs_rtems_unlock (fs);
ffc202a8: 7f e3 fb 78 mr r3,r31
ffc202ac: 4b ff fd 35 bl ffc1ffe0 <rtems_rfs_rtems_unlock>
return 0;
ffc202b0: 38 60 00 00 li r3,0
}
ffc202b4: 39 61 00 48 addi r11,r1,72
ffc202b8: 4b fe 28 38 b ffc02af0 <_restgpr_29_x>
ffc200f0 <rtems_rfs_rtems_dir_read>:
*/
static ssize_t
rtems_rfs_rtems_dir_read (rtems_libio_t* iop,
void* buffer,
size_t count)
{
ffc200f0: 94 21 ff a0 stwu r1,-96(r1) <== NOT EXECUTED
ffc200f4: 7c 08 02 a6 mflr r0 <== NOT EXECUTED
ffc200f8: 90 01 00 64 stw r0,100(r1) <== NOT EXECUTED
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (&iop->pathinfo);
ffc200fc: 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)
{
ffc20100: be c1 00 38 stmw r22,56(r1) <== NOT EXECUTED
ffc20104: 7c 7c 1b 78 mr r28,r3 <== NOT EXECUTED
struct dirent* dirent;
ssize_t bytes_transferred;
int d;
int rc;
count = count / sizeof (struct dirent);
ffc20108: 3a e0 01 18 li r23,280 <== NOT EXECUTED
static ssize_t
rtems_rfs_rtems_dir_read (rtems_libio_t* iop,
void* buffer,
size_t count)
{
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (&iop->pathinfo);
ffc2010c: 83 a9 00 34 lwz r29,52(r9) <== NOT EXECUTED
count = count / sizeof (struct dirent);
dirent = buffer;
rtems_rfs_rtems_lock (fs);
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
ffc20110: 3b 01 00 0c addi r24,r1,12 <== NOT EXECUTED
rtems_rfs_rtems_dir_read (rtems_libio_t* iop,
void* buffer,
size_t count)
{
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (&iop->pathinfo);
rtems_rfs_ino ino = rtems_rfs_rtems_get_iop_ino (iop);
ffc20114: 83 63 00 1c lwz r27,28(r3) <== NOT EXECUTED
*/
static ssize_t
rtems_rfs_rtems_dir_read (rtems_libio_t* iop,
void* buffer,
size_t count)
{
ffc20118: 7c 99 23 78 mr r25,r4 <== NOT EXECUTED
int rc;
count = count / sizeof (struct dirent);
dirent = buffer;
rtems_rfs_rtems_lock (fs);
ffc2011c: 80 7d 00 7c lwz r3,124(r29) <== NOT EXECUTED
struct dirent* dirent;
ssize_t bytes_transferred;
int d;
int rc;
count = count / sizeof (struct dirent);
ffc20120: 7e e5 bb 96 divwu r23,r5,r23 <== NOT EXECUTED
dirent = buffer;
rtems_rfs_rtems_lock (fs);
ffc20124: 4b ff ff 69 bl ffc2008c <rtems_rfs_rtems_lock.isra.3> <== NOT EXECUTED
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
ffc20128: 7f 64 db 78 mr r4,r27 <== NOT EXECUTED
ffc2012c: 7f a3 eb 78 mr r3,r29 <== NOT EXECUTED
ffc20130: 7f 05 c3 78 mr r5,r24 <== NOT EXECUTED
ffc20134: 38 c0 00 01 li r6,1 <== NOT EXECUTED
ffc20138: 4b ff 11 c1 bl ffc112f8 <rtems_rfs_inode_open> <== NOT EXECUTED
if (rc)
ffc2013c: 7c 7b 1b 79 mr. r27,r3 <== NOT EXECUTED
ffc20140: 40 82 00 0c bne- ffc2014c <rtems_rfs_rtems_dir_read+0x5c><== 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,
ffc20144: 3b 60 00 00 li r27,0 <== NOT EXECUTED
ffc20148: 48 00 00 84 b ffc201cc <rtems_rfs_rtems_dir_read+0xdc><== NOT EXECUTED
rtems_rfs_rtems_lock (fs);
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
if (rc)
{
rtems_rfs_rtems_unlock (fs);
ffc2014c: 7f a3 eb 78 mr r3,r29 <== NOT EXECUTED
ffc20150: 4b ff fe 91 bl ffc1ffe0 <rtems_rfs_rtems_unlock> <== NOT EXECUTED
return rtems_rfs_rtems_error ("dir_read: read inode", rc);
ffc20154: 3b 40 ff ff li r26,-1 <== NOT EXECUTED
ffc20158: 48 00 18 ad bl ffc21a04 <__errno> <== NOT EXECUTED
ffc2015c: 93 63 00 00 stw r27,0(r3) <== NOT EXECUTED
ffc20160: 48 00 00 8c b ffc201ec <rtems_rfs_rtems_dir_read+0xfc><== 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);
ffc20164: 80 bc 00 10 lwz r5,16(r28) <== NOT EXECUTED
ffc20168: 7f a3 eb 78 mr r3,r29 <== NOT EXECUTED
ffc2016c: 80 dc 00 14 lwz r6,20(r28) <== NOT EXECUTED
ffc20170: 7f 04 c3 78 mr r4,r24 <== NOT EXECUTED
ffc20174: 7f 27 cb 78 mr r7,r25 <== NOT EXECUTED
ffc20178: 39 01 00 08 addi r8,r1,8 <== NOT EXECUTED
ffc2017c: 4b ff d3 b1 bl ffc1d52c <rtems_rfs_dir_read> <== NOT EXECUTED
if (rc == ENOENT)
ffc20180: 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);
ffc20184: 7c 76 1b 78 mr r22,r3 <== NOT EXECUTED
if (rc == ENOENT)
ffc20188: 41 9e 00 50 beq- cr7,ffc201d8 <rtems_rfs_rtems_dir_read+0xe8><== NOT EXECUTED
{
rc = 0;
break;
}
if (rc > 0)
ffc2018c: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc20190: 40 bd 00 14 ble+ cr7,ffc201a4 <rtems_rfs_rtems_dir_read+0xb4><== NOT EXECUTED
{
bytes_transferred = rtems_rfs_rtems_error ("dir_read: dir read", rc);
ffc20194: 48 00 18 71 bl ffc21a04 <__errno> <== NOT EXECUTED
ffc20198: 3b 40 ff ff li r26,-1 <== NOT EXECUTED
ffc2019c: 92 c3 00 00 stw r22,0(r3) <== NOT EXECUTED
ffc201a0: 48 00 00 38 b ffc201d8 <rtems_rfs_rtems_dir_read+0xe8><== NOT EXECUTED
break;
}
iop->offset += size;
ffc201a4: 81 5c 00 10 lwz r10,16(r28) <== NOT EXECUTED
ffc201a8: 3b c0 00 00 li r30,0 <== NOT EXECUTED
ffc201ac: 81 7c 00 14 lwz r11,20(r28) <== NOT EXECUTED
return rtems_rfs_rtems_error ("dir_read: read inode", rc);
}
bytes_transferred = 0;
for (d = 0; d < count; d++, dirent++)
ffc201b0: 3b 7b 00 01 addi r27,r27,1 <== NOT EXECUTED
if (rc > 0)
{
bytes_transferred = rtems_rfs_rtems_error ("dir_read: dir read", rc);
break;
}
iop->offset += size;
ffc201b4: 83 e1 00 08 lwz r31,8(r1) <== NOT EXECUTED
return rtems_rfs_rtems_error ("dir_read: read inode", rc);
}
bytes_transferred = 0;
for (d = 0; d < count; d++, dirent++)
ffc201b8: 3b 39 01 18 addi r25,r25,280 <== NOT EXECUTED
if (rc > 0)
{
bytes_transferred = rtems_rfs_rtems_error ("dir_read: dir read", rc);
break;
}
iop->offset += size;
ffc201bc: 7d 6b f8 14 addc r11,r11,r31 <== NOT EXECUTED
ffc201c0: 7d 4a f1 14 adde r10,r10,r30 <== NOT EXECUTED
ffc201c4: 91 5c 00 10 stw r10,16(r28) <== NOT EXECUTED
ffc201c8: 91 7c 00 14 stw r11,20(r28) <== NOT EXECUTED
return rtems_rfs_rtems_error ("dir_read: read inode", rc);
}
bytes_transferred = 0;
for (d = 0; d < count; d++, dirent++)
ffc201cc: 7f 9b b8 00 cmpw cr7,r27,r23 <== 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,
ffc201d0: 1f 5b 01 18 mulli r26,r27,280 <== NOT EXECUTED
return rtems_rfs_rtems_error ("dir_read: read inode", rc);
}
bytes_transferred = 0;
for (d = 0; d < count; d++, dirent++)
ffc201d4: 40 9e ff 90 bne+ cr7,ffc20164 <rtems_rfs_rtems_dir_read+0x74><== NOT EXECUTED
}
iop->offset += size;
bytes_transferred += sizeof (struct dirent);
}
rtems_rfs_inode_close (fs, &inode);
ffc201d8: 7f a3 eb 78 mr r3,r29 <== NOT EXECUTED
ffc201dc: 38 81 00 0c addi r4,r1,12 <== NOT EXECUTED
ffc201e0: 4b ff 13 09 bl ffc114e8 <rtems_rfs_inode_close> <== NOT EXECUTED
rtems_rfs_rtems_unlock (fs);
ffc201e4: 7f a3 eb 78 mr r3,r29 <== NOT EXECUTED
ffc201e8: 4b ff fd f9 bl ffc1ffe0 <rtems_rfs_rtems_unlock> <== NOT EXECUTED
return bytes_transferred;
}
ffc201ec: 39 61 00 60 addi r11,r1,96 <== NOT EXECUTED
ffc201f0: 7f 43 d3 78 mr r3,r26 <== NOT EXECUTED
ffc201f4: 4b fe 28 e0 b ffc02ad4 <_restgpr_22_x> <== NOT EXECUTED
ffc202bc <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)
{
ffc202bc: 94 21 ff e8 stwu r1,-24(r1) <== NOT EXECUTED
ffc202c0: 7c 08 02 a6 mflr r0 <== NOT EXECUTED
ffc202c4: 90 01 00 1c stw r0,28(r1) <== NOT EXECUTED
ffc202c8: bf 81 00 08 stmw r28,8(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);
ffc202cc: 83 a4 00 00 lwz r29,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);
ffc202d0: 81 64 00 10 lwz r11,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)
ffc202d4: 2f 9d 00 01 cmpwi cr7,r29,1 <== 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);
rtems_rfs_ino parent = rtems_rfs_rtems_get_pathloc_ino (parent_pathloc);
ffc202d8: 83 83 00 00 lwz r28,0(r3) <== 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);
ffc202dc: 83 eb 00 34 lwz r31,52(r11) <== NOT EXECUTED
rtems_rfs_ino parent = rtems_rfs_rtems_get_pathloc_ino (parent_pathloc);
rtems_rfs_ino ino = rtems_rfs_rtems_get_pathloc_ino (pathloc);
uint32_t doff = rtems_rfs_rtems_get_pathloc_doff (pathloc);
ffc202e0: 83 c4 00 04 lwz r30,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)
ffc202e4: 40 be 00 14 bne+ cr7,ffc202f8 <rtems_rfs_rtems_dir_rmnod+0x3c><== NOT EXECUTED
return rtems_rfs_rtems_error ("dir_rmnod: root inode", EBUSY);
ffc202e8: 48 00 17 1d bl ffc21a04 <__errno> <== NOT EXECUTED
ffc202ec: 38 00 00 10 li r0,16 <== NOT EXECUTED
ffc202f0: 90 03 00 00 stw r0,0(r3) <== NOT EXECUTED
ffc202f4: 48 00 00 3c b ffc20330 <rtems_rfs_rtems_dir_rmnod+0x74><== NOT EXECUTED
rtems_rfs_rtems_lock (fs);
ffc202f8: 80 7f 00 7c lwz r3,124(r31) <== NOT EXECUTED
ffc202fc: 4b ff fd 91 bl ffc2008c <rtems_rfs_rtems_lock.isra.3> <== NOT EXECUTED
rc = rtems_rfs_unlink (fs, parent, ino, doff, rtems_rfs_unlink_dir_if_empty);
ffc20300: 7f c6 f3 78 mr r6,r30 <== NOT EXECUTED
ffc20304: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc20308: 7f 84 e3 78 mr r4,r28 <== NOT EXECUTED
ffc2030c: 7f a5 eb 78 mr r5,r29 <== NOT EXECUTED
ffc20310: 38 e0 00 01 li r7,1 <== NOT EXECUTED
ffc20314: 4b ff f0 69 bl ffc1f37c <rtems_rfs_unlink> <== NOT EXECUTED
if (rc)
ffc20318: 7c 7e 1b 79 mr. r30,r3 <== NOT EXECUTED
{
rtems_rfs_rtems_unlock (fs);
ffc2031c: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
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);
if (rc)
ffc20320: 41 82 00 18 beq- ffc20338 <rtems_rfs_rtems_dir_rmnod+0x7c><== NOT EXECUTED
{
rtems_rfs_rtems_unlock (fs);
ffc20324: 4b ff fc bd bl ffc1ffe0 <rtems_rfs_rtems_unlock> <== NOT EXECUTED
return rtems_rfs_rtems_error ("dir_rmnod: unlinking", rc);
ffc20328: 48 00 16 dd bl ffc21a04 <__errno> <== NOT EXECUTED
ffc2032c: 93 c3 00 00 stw r30,0(r3) <== NOT EXECUTED
ffc20330: 38 60 ff ff li r3,-1 <== NOT EXECUTED
ffc20334: 48 00 00 0c b ffc20340 <rtems_rfs_rtems_dir_rmnod+0x84><== NOT EXECUTED
}
rtems_rfs_rtems_unlock (fs);
ffc20338: 4b ff fc a9 bl ffc1ffe0 <rtems_rfs_rtems_unlock> <== NOT EXECUTED
return 0;
ffc2033c: 38 60 00 00 li r3,0 <== NOT EXECUTED
}
ffc20340: 39 61 00 18 addi r11,r1,24 <== NOT EXECUTED
ffc20344: 4b fe 27 a8 b ffc02aec <_restgpr_28_x> <== NOT EXECUTED
ffc126c0 <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)
{
ffc126c0: 94 21 ff 98 stwu r1,-104(r1)
ffc126c4: 7c 08 02 a6 mflr r0
ffc126c8: 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);
ffc126cc: 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);
ffc126d0: 81 24 00 10 lwz r9,16(r4)
rtems_rfs_inode_handle inode;
rtems_rfs_ino ino = rtems_rfs_rtems_get_pathloc_ino (pathloc);
ffc126d4: 90 01 00 10 stw r0,16(r1)
rtems_rfs_ino node_ino;
uint32_t doff = 0;
ffc126d8: 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)
{
ffc126dc: bf 21 00 4c stmw r25,76(r1)
ffc126e0: 7c 7a 1b 78 mr r26,r3
ffc126e4: 7c be 2b 78 mr r30,r5
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
ffc126e8: 83 89 00 34 lwz r28,52(r9)
*/
static int
rtems_rfs_rtems_eval_for_make (const char* path,
rtems_filesystem_location_info_t* pathloc,
const char** name)
{
ffc126ec: 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);
rtems_rfs_ino node_ino;
uint32_t doff = 0;
ffc126f0: 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);
ffc126f4: 48 01 11 79 bl ffc2386c <strlen>
ffc126f8: 7c 7a 1a 14 add r3,r26,r3
ffc126fc: 90 7e 00 00 stw r3,0(r30)
while (*name != path)
ffc12700: 48 00 00 2c b ffc1272c <rtems_rfs_rtems_eval_for_make+0x6c>
{
(*name)--;
ffc12704: 38 09 ff ff addi r0,r9,-1
ffc12708: 90 1e 00 00 stw r0,0(r30)
if (rtems_filesystem_is_separator (**name))
ffc1270c: 88 69 ff ff lbz r3,-1(r9)
ffc12710: 4b ff 6a e5 bl ffc091f4 <rtems_filesystem_is_separator>
ffc12714: 2f 83 00 00 cmpwi cr7,r3,0
ffc12718: 41 be 00 14 beq+ cr7,ffc1272c <rtems_rfs_rtems_eval_for_make+0x6c>
{
(*name)++;
ffc1271c: 81 3e 00 00 lwz r9,0(r30)
ffc12720: 38 09 00 01 addi r0,r9,1
ffc12724: 90 1e 00 00 stw r0,0(r30)
break;
ffc12728: 48 00 00 10 b ffc12738 <rtems_rfs_rtems_eval_for_make+0x78>
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)
ffc1272c: 81 3e 00 00 lwz r9,0(r30)
ffc12730: 7f 89 d0 00 cmpw cr7,r9,r26
ffc12734: 40 9e ff d0 bne+ cr7,ffc12704 <rtems_rfs_rtems_eval_for_make+0x44>
}
/*
* Eat any separators at start of the path.
*/
stripped = rtems_filesystem_prefix_separators (path, strlen(path));
ffc12738: 7f 43 d3 78 mr r3,r26
ffc1273c: 48 01 11 31 bl ffc2386c <strlen>
}
/*
* We need to find the parent of this node.
*/
rc = rtems_rfs_dir_lookup_ino (fs, &inode, "..", 2, &ino, &doff);
ffc12740: 3f 60 ff c3 lis r27,-61
}
/*
* Eat any separators at start of the path.
*/
stripped = rtems_filesystem_prefix_separators (path, strlen(path));
ffc12744: 7c 64 1b 78 mr r4,r3
ffc12748: 7f 43 d3 78 mr r3,r26
ffc1274c: 4b ff 50 25 bl ffc07770 <rtems_filesystem_prefix_separators>
}
/*
* We need to find the parent of this node.
*/
rc = rtems_rfs_dir_lookup_ino (fs, &inode, "..", 2, &ino, &doff);
ffc12750: 3b 7b 18 b4 addi r27,r27,6324
/*
* Eat any separators at start of the path.
*/
stripped = rtems_filesystem_prefix_separators (path, strlen(path));
path += stripped;
ffc12754: 7f 5a 1a 14 add r26,r26,r3
rtems_rfs_rtems_lock (fs);
ffc12758: 80 7c 00 7c lwz r3,124(r28)
ffc1275c: 4b ff f7 ed bl ffc11f48 <rtems_rfs_rtems_lock.isra.16>
ffc12760: 48 00 00 08 b ffc12768 <rtems_rfs_rtems_eval_for_make+0xa8>
/*
* Eat any separators at start of the new path.
*/
stripped = rtems_filesystem_prefix_separators (path, strlen (path));
path += stripped;
ffc12764: 7f ba eb 78 mr r26,r29
while (true)
{
/*
* Open and load the inode.
*/
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
ffc12768: 80 81 00 10 lwz r4,16(r1)
ffc1276c: 7f 83 e3 78 mr r3,r28
ffc12770: 38 a1 00 14 addi r5,r1,20
ffc12774: 38 c0 00 01 li r6,1
ffc12778: 4b ff eb 81 bl ffc112f8 <rtems_rfs_inode_open>
if (rc > 0)
ffc1277c: 7c 7d 1b 79 mr. r29,r3
ffc12780: 40 a1 00 18 ble+ ffc12798 <rtems_rfs_rtems_eval_for_make+0xd8><== ALWAYS TAKEN
{
rtems_rfs_rtems_unlock (fs);
ffc12784: 7f 83 e3 78 mr r3,r28 <== NOT EXECUTED
ffc12788: 4b ff f5 91 bl ffc11d18 <rtems_rfs_rtems_unlock> <== NOT EXECUTED
return rtems_rfs_rtems_error ("eval_for_make: read ino", rc);
ffc1278c: 48 00 f2 79 bl ffc21a04 <__errno> <== NOT EXECUTED
ffc12790: 93 a3 00 00 stw r29,0(r3) <== NOT EXECUTED
ffc12794: 48 00 00 4c b ffc127e0 <rtems_rfs_rtems_eval_for_make+0x120><== 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)) &&
ffc12798: 81 21 00 20 lwz r9,32(r1)
ffc1279c: 88 09 00 02 lbz r0,2(r9)
ffc127a0: 54 00 44 26 rlwinm r0,r0,8,16,19
ffc127a4: 2f 80 40 00 cmpwi cr7,r0,16384
ffc127a8: 40 be 00 40 bne+ cr7,ffc127e8 <rtems_rfs_rtems_eval_for_make+0x128>
!rtems_rfs_rtems_eval_perms (&inode, RTEMS_LIBIO_PERMS_SEARCH))
ffc127ac: 38 61 00 14 addi r3,r1,20
ffc127b0: 38 80 00 01 li r4,1
ffc127b4: 48 00 09 e1 bl ffc13194 <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)) &&
ffc127b8: 2f 83 00 00 cmpwi cr7,r3,0
ffc127bc: 40 be 00 2c bne+ cr7,ffc127e8 <rtems_rfs_rtems_eval_for_make+0x128><== ALWAYS TAKEN
!rtems_rfs_rtems_eval_perms (&inode, RTEMS_LIBIO_PERMS_SEARCH))
{
rtems_rfs_inode_close (fs, &inode);
ffc127c0: 38 81 00 14 addi r4,r1,20 <== NOT EXECUTED
ffc127c4: 7f 83 e3 78 mr r3,r28 <== NOT EXECUTED
ffc127c8: 4b ff ed 21 bl ffc114e8 <rtems_rfs_inode_close> <== NOT EXECUTED
rtems_rfs_rtems_unlock (fs);
ffc127cc: 7f 83 e3 78 mr r3,r28 <== NOT EXECUTED
ffc127d0: 4b ff f5 49 bl ffc11d18 <rtems_rfs_rtems_unlock> <== NOT EXECUTED
return rtems_rfs_rtems_error ("eval_for_make: eval perms", EACCES);
ffc127d4: 48 00 f2 31 bl ffc21a04 <__errno> <== NOT EXECUTED
ffc127d8: 38 00 00 0d li r0,13 <== NOT EXECUTED
ffc127dc: 90 03 00 00 stw r0,0(r3)
ffc127e0: 3b e0 ff ff li r31,-1
ffc127e4: 48 00 02 bc b ffc12aa0 <rtems_rfs_rtems_eval_for_make+0x3e0>
}
/*
* Is this the end of the pathname we where given ?
*/
if (path == *name)
ffc127e8: 80 1e 00 00 lwz r0,0(r30)
ffc127ec: 7f 9a 00 00 cmpw cr7,r26,r0
ffc127f0: 41 9e 01 b4 beq- cr7,ffc129a4 <rtems_rfs_rtems_eval_for_make+0x2e4>
ffc127f4: 7f 5d d3 78 mr r29,r26
ffc127f8: 3b 20 00 00 li r25,0
ffc127fc: 48 00 00 0c b ffc12808 <rtems_rfs_rtems_eval_for_make+0x148>
node_len = 0;
while (!rtems_filesystem_is_separator(*path) &&
(*path != '\0') &&
(node_len < (rtems_rfs_fs_max_name (fs) - 1)))
{
node_len++;
ffc12800: 3b 39 00 01 addi r25,r25,1
path++;
ffc12804: 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) &&
ffc12808: 88 7d 00 00 lbz r3,0(r29)
ffc1280c: 4b ff 69 e9 bl ffc091f4 <rtems_filesystem_is_separator>
ffc12810: 2f 83 00 00 cmpwi cr7,r3,0
ffc12814: 40 9e 00 20 bne- cr7,ffc12834 <rtems_rfs_rtems_eval_for_make+0x174>
ffc12818: 88 1d 00 00 lbz r0,0(r29)
ffc1281c: 2f 80 00 00 cmpwi cr7,r0,0
ffc12820: 41 9e 00 14 beq- cr7,ffc12834 <rtems_rfs_rtems_eval_for_make+0x174><== NEVER TAKEN
(*path != '\0') &&
(node_len < (rtems_rfs_fs_max_name (fs) - 1)))
ffc12824: 81 3c 00 18 lwz r9,24(r28)
ffc12828: 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') &&
ffc1282c: 7f 99 00 40 cmplw cr7,r25,r0
ffc12830: 41 9c ff d0 blt+ cr7,ffc12800 <rtems_rfs_rtems_eval_for_make+0x140><== ALWAYS TAKEN
}
/*
* Eat any separators at start of the new path.
*/
stripped = rtems_filesystem_prefix_separators (path, strlen (path));
ffc12834: 7f a3 eb 78 mr r3,r29
ffc12838: 48 01 10 35 bl ffc2386c <strlen>
ffc1283c: 7c 64 1b 78 mr r4,r3
ffc12840: 7f a3 eb 78 mr r3,r29
ffc12844: 4b ff 4f 2d bl ffc07770 <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))
ffc12848: 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;
ffc1284c: 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))
ffc12850: 2f 80 00 2e cmpwi cr7,r0,46
ffc12854: 40 be 00 38 bne+ cr7,ffc1288c <rtems_rfs_rtems_eval_for_make+0x1cc><== ALWAYS TAKEN
ffc12858: 88 7a 00 01 lbz r3,1(r26) <== NOT EXECUTED
ffc1285c: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc12860: 41 be 00 10 beq+ cr7,ffc12870 <rtems_rfs_rtems_eval_for_make+0x1b0><== NOT EXECUTED
ffc12864: 4b ff 69 91 bl ffc091f4 <rtems_filesystem_is_separator><== NOT EXECUTED
ffc12868: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc1286c: 41 9e 00 20 beq- cr7,ffc1288c <rtems_rfs_rtems_eval_for_make+0x1cc><== NOT EXECUTED
{
if (*path)
ffc12870: 88 1d 00 00 lbz r0,0(r29) <== NOT EXECUTED
ffc12874: 2f 80 00 00 cmpwi cr7,r0,0 <== NOT EXECUTED
ffc12878: 41 be 01 2c beq+ cr7,ffc129a4 <rtems_rfs_rtems_eval_for_make+0x2e4><== NOT EXECUTED
{
rtems_rfs_inode_close (fs, &inode);
ffc1287c: 7f 83 e3 78 mr r3,r28 <== NOT EXECUTED
ffc12880: 38 81 00 14 addi r4,r1,20 <== NOT EXECUTED
ffc12884: 4b ff ec 65 bl ffc114e8 <rtems_rfs_inode_close> <== NOT EXECUTED
continue;
ffc12888: 4b ff fe dc b ffc12764 <rtems_rfs_rtems_eval_for_make+0xa4><== 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))
ffc1288c: 88 1d 00 00 lbz r0,0(r29)
ffc12890: 2f 80 00 2e cmpwi cr7,r0,46
ffc12894: 40 9e 00 bc bne- cr7,ffc12950 <rtems_rfs_rtems_eval_for_make+0x290><== ALWAYS TAKEN
ffc12898: 88 1d 00 01 lbz r0,1(r29) <== NOT EXECUTED
ffc1289c: 2f 80 00 2e cmpwi cr7,r0,46 <== NOT EXECUTED
ffc128a0: 40 be 00 b0 bne+ cr7,ffc12950 <rtems_rfs_rtems_eval_for_make+0x290><== NOT EXECUTED
ffc128a4: 88 7d 00 02 lbz r3,2(r29) <== NOT EXECUTED
ffc128a8: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc128ac: 41 be 00 10 beq+ cr7,ffc128bc <rtems_rfs_rtems_eval_for_make+0x1fc><== NOT EXECUTED
ffc128b0: 4b ff 69 45 bl ffc091f4 <rtems_filesystem_is_separator><== NOT EXECUTED
ffc128b4: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc128b8: 41 9e 00 98 beq- cr7,ffc12950 <rtems_rfs_rtems_eval_for_make+0x290><== NOT EXECUTED
{
/*
* If we are at the root inode of the file system we have a crossmount
* path.
*/
if (ino == RTEMS_RFS_ROOT_INO)
ffc128bc: 80 01 00 10 lwz r0,16(r1) <== NOT EXECUTED
ffc128c0: 2f 80 00 01 cmpwi cr7,r0,1 <== NOT EXECUTED
ffc128c4: 40 be 00 4c bne+ cr7,ffc12910 <rtems_rfs_rtems_eval_for_make+0x250><== NOT EXECUTED
{
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);
ffc128c8: 38 81 00 14 addi r4,r1,20 <== NOT EXECUTED
ffc128cc: 7f 83 e3 78 mr r3,r28 <== NOT EXECUTED
ffc128d0: 4b ff ec 19 bl ffc114e8 <rtems_rfs_inode_close> <== NOT EXECUTED
rtems_rfs_rtems_unlock (fs);
ffc128d4: 7f 83 e3 78 mr r3,r28 <== NOT EXECUTED
ffc128d8: 4b ff f4 41 bl ffc11d18 <rtems_rfs_rtems_unlock> <== NOT EXECUTED
*pathloc = pathloc->mt_entry->mt_point_node;
ffc128dc: 81 7f 00 10 lwz r11,16(r31) <== NOT EXECUTED
return (*pathloc->ops->evalformake_h)(path + 2, pathloc, name);
ffc128e0: 7f e4 fb 78 mr r4,r31 <== 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;
ffc128e4: 39 6b 00 08 addi r11,r11,8 <== NOT EXECUTED
ffc128e8: 7c ab a4 aa lswi r5,r11,20 <== NOT EXECUTED
ffc128ec: 7c bf a5 aa stswi r5,r31,20 <== NOT EXECUTED
return (*pathloc->ops->evalformake_h)(path + 2, pathloc, name);
ffc128f0: 38 7d 00 02 addi r3,r29,2 <== NOT EXECUTED
ffc128f4: 7f c5 f3 78 mr r5,r30 <== NOT EXECUTED
ffc128f8: 81 3f 00 0c lwz r9,12(r31) <== NOT EXECUTED
ffc128fc: 80 09 00 04 lwz r0,4(r9) <== NOT EXECUTED
ffc12900: 7c 09 03 a6 mtctr r0 <== NOT EXECUTED
ffc12904: 4e 80 04 21 bctrl <== NOT EXECUTED
ffc12908: 7c 7f 1b 78 mr r31,r3 <== NOT EXECUTED
ffc1290c: 48 00 01 94 b ffc12aa0 <rtems_rfs_rtems_eval_for_make+0x3e0><== 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)))
ffc12910: 81 21 00 20 lwz r9,32(r1) <== NOT EXECUTED
{
rtems_rfs_inode_close (fs, &inode);
ffc12914: 7f 83 e3 78 mr r3,r28 <== NOT EXECUTED
ffc12918: 38 81 00 14 addi r4,r1,20 <== NOT EXECUTED
ffc1291c: 88 09 00 02 lbz r0,2(r9) <== 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)))
ffc12920: 54 00 44 26 rlwinm r0,r0,8,16,19 <== NOT EXECUTED
ffc12924: 2f 80 40 00 cmpwi cr7,r0,16384 <== NOT EXECUTED
ffc12928: 41 be 00 1c beq+ cr7,ffc12944 <rtems_rfs_rtems_eval_for_make+0x284><== NOT EXECUTED
{
rtems_rfs_inode_close (fs, &inode);
ffc1292c: 4b ff eb bd bl ffc114e8 <rtems_rfs_inode_close> <== NOT EXECUTED
rtems_rfs_rtems_unlock (fs);
ffc12930: 7f 83 e3 78 mr r3,r28 <== NOT EXECUTED
ffc12934: 4b ff f3 e5 bl ffc11d18 <rtems_rfs_rtems_unlock> <== NOT EXECUTED
return rtems_rfs_rtems_error ("eval_for_make: not dir", ENOTSUP);
ffc12938: 48 00 f0 cd bl ffc21a04 <__errno> <== NOT EXECUTED
ffc1293c: 38 00 00 86 li r0,134 <== NOT EXECUTED
ffc12940: 4b ff fe 9c b ffc127dc <rtems_rfs_rtems_eval_for_make+0x11c><== NOT EXECUTED
}
/*
* We need to find the parent of this node.
*/
rc = rtems_rfs_dir_lookup_ino (fs, &inode, "..", 2, &ino, &doff);
ffc12944: 7f 65 db 78 mr r5,r27 <== NOT EXECUTED
ffc12948: 38 c0 00 02 li r6,2 <== NOT EXECUTED
ffc1294c: 48 00 00 14 b ffc12960 <rtems_rfs_rtems_eval_for_make+0x2a0><== NOT EXECUTED
else
{
/*
* Read the inode so we know it exists and what type it is.
*/
rc = rtems_rfs_dir_lookup_ino (fs, &inode,
ffc12950: 7f 83 e3 78 mr r3,r28
ffc12954: 38 81 00 14 addi r4,r1,20
ffc12958: 7f 45 d3 78 mr r5,r26
ffc1295c: 7f 26 cb 78 mr r6,r25
ffc12960: 38 e1 00 10 addi r7,r1,16
ffc12964: 39 01 00 08 addi r8,r1,8
ffc12968: 48 00 9f 65 bl ffc1c8cc <rtems_rfs_dir_lookup_ino>
node, node_len - stripped, &ino, &doff);
if (rc > 0)
{
rtems_rfs_inode_close (fs, &inode);
ffc1296c: 38 81 00 14 addi r4,r1,20
/*
* Read the inode so we know it exists and what type it is.
*/
rc = rtems_rfs_dir_lookup_ino (fs, &inode,
node, node_len - stripped, &ino, &doff);
if (rc > 0)
ffc12970: 7c 7a 1b 79 mr. r26,r3
{
rtems_rfs_inode_close (fs, &inode);
ffc12974: 7f 83 e3 78 mr r3,r28
/*
* Read the inode so we know it exists and what type it is.
*/
rc = rtems_rfs_dir_lookup_ino (fs, &inode,
node, node_len - stripped, &ino, &doff);
if (rc > 0)
ffc12978: 40 a1 00 0c ble+ ffc12984 <rtems_rfs_rtems_eval_for_make+0x2c4>
{
rtems_rfs_inode_close (fs, &inode);
ffc1297c: 4b ff eb 6d bl ffc114e8 <rtems_rfs_inode_close>
ffc12980: 48 00 00 10 b ffc12990 <rtems_rfs_rtems_eval_for_make+0x2d0>
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);
ffc12984: 4b ff eb 65 bl ffc114e8 <rtems_rfs_inode_close>
if (rc > 0)
ffc12988: 7c 7a 1b 79 mr. r26,r3
ffc1298c: 40 81 fd d8 ble+ ffc12764 <rtems_rfs_rtems_eval_for_make+0xa4><== ALWAYS TAKEN
{
rtems_rfs_rtems_unlock (fs);
ffc12990: 7f 83 e3 78 mr r3,r28
ffc12994: 4b ff f3 85 bl ffc11d18 <rtems_rfs_rtems_unlock>
return rtems_rfs_rtems_error ("eval_for_make: closing node", rc);
ffc12998: 48 00 f0 6d bl ffc21a04 <__errno>
ffc1299c: 93 43 00 00 stw r26,0(r3)
ffc129a0: 4b ff fe 40 b ffc127e0 <rtems_rfs_rtems_eval_for_make+0x120>
}
}
if (!RTEMS_RFS_S_ISDIR (rtems_rfs_inode_get_mode (&inode)))
ffc129a4: 81 21 00 20 lwz r9,32(r1)
ffc129a8: 88 09 00 02 lbz r0,2(r9)
ffc129ac: 54 00 44 26 rlwinm r0,r0,8,16,19
ffc129b0: 2f 80 40 00 cmpwi cr7,r0,16384
ffc129b4: 41 be 00 24 beq+ cr7,ffc129d8 <rtems_rfs_rtems_eval_for_make+0x318>
{
rtems_rfs_inode_close (fs, &inode);
ffc129b8: 38 81 00 14 addi r4,r1,20
ffc129bc: 7f 83 e3 78 mr r3,r28
ffc129c0: 4b ff eb 29 bl ffc114e8 <rtems_rfs_inode_close>
rtems_rfs_rtems_unlock (fs);
ffc129c4: 7f 83 e3 78 mr r3,r28
ffc129c8: 4b ff f3 51 bl ffc11d18 <rtems_rfs_rtems_unlock>
return rtems_rfs_rtems_error ("eval_for_make: not dir", ENOTDIR);
ffc129cc: 48 00 f0 39 bl ffc21a04 <__errno>
ffc129d0: 38 00 00 14 li r0,20
ffc129d4: 4b ff fe 08 b ffc127dc <rtems_rfs_rtems_eval_for_make+0x11c>
}
if (!rtems_rfs_rtems_eval_perms (&inode, RTEMS_LIBIO_PERMS_WX))
ffc129d8: 38 61 00 14 addi r3,r1,20
ffc129dc: 38 80 00 03 li r4,3
ffc129e0: 48 00 07 b5 bl ffc13194 <rtems_rfs_rtems_eval_perms>
ffc129e4: 2f 83 00 00 cmpwi cr7,r3,0
ffc129e8: 41 be fd d8 beq- cr7,ffc127c0 <rtems_rfs_rtems_eval_for_make+0x100><== NEVER TAKEN
}
/*
* Make sure the name does not already exists in the directory.
*/
rc = rtems_rfs_dir_lookup_ino (fs, &inode, *name, strlen (*name),
ffc129ec: 83 de 00 00 lwz r30,0(r30)
ffc129f0: 7f c3 f3 78 mr r3,r30
ffc129f4: 48 01 0e 79 bl ffc2386c <strlen>
ffc129f8: 7f c5 f3 78 mr r5,r30
ffc129fc: 7c 66 1b 78 mr r6,r3
ffc12a00: 38 81 00 14 addi r4,r1,20
ffc12a04: 7f 83 e3 78 mr r3,r28
ffc12a08: 38 e1 00 0c addi r7,r1,12
ffc12a0c: 39 01 00 08 addi r8,r1,8
ffc12a10: 48 00 9e bd bl ffc1c8cc <rtems_rfs_dir_lookup_ino>
&node_ino, &doff);
if (rc == 0)
ffc12a14: 7c 7e 1b 79 mr. r30,r3
ffc12a18: 40 a2 00 24 bne+ ffc12a3c <rtems_rfs_rtems_eval_for_make+0x37c>
{
rtems_rfs_inode_close (fs, &inode);
ffc12a1c: 38 81 00 14 addi r4,r1,20
ffc12a20: 7f 83 e3 78 mr r3,r28
ffc12a24: 4b ff ea c5 bl ffc114e8 <rtems_rfs_inode_close>
rtems_rfs_rtems_unlock (fs);
ffc12a28: 7f 83 e3 78 mr r3,r28
ffc12a2c: 4b ff f2 ed bl ffc11d18 <rtems_rfs_rtems_unlock>
return rtems_rfs_rtems_error ("eval_for_make: found name", EEXIST);
ffc12a30: 48 00 ef d5 bl ffc21a04 <__errno>
ffc12a34: 38 00 00 11 li r0,17
ffc12a38: 4b ff fd a4 b ffc127dc <rtems_rfs_rtems_eval_for_make+0x11c>
}
if (rc != ENOENT)
ffc12a3c: 2f 9e 00 02 cmpwi cr7,r30,2
ffc12a40: 41 9e 00 24 beq- cr7,ffc12a64 <rtems_rfs_rtems_eval_for_make+0x3a4><== ALWAYS TAKEN
{
rtems_rfs_inode_close (fs, &inode);
ffc12a44: 38 81 00 14 addi r4,r1,20 <== NOT EXECUTED
ffc12a48: 7f 83 e3 78 mr r3,r28 <== NOT EXECUTED
ffc12a4c: 4b ff ea 9d bl ffc114e8 <rtems_rfs_inode_close> <== NOT EXECUTED
rtems_rfs_rtems_unlock (fs);
ffc12a50: 7f 83 e3 78 mr r3,r28 <== NOT EXECUTED
ffc12a54: 4b ff f2 c5 bl ffc11d18 <rtems_rfs_rtems_unlock> <== NOT EXECUTED
return rtems_rfs_rtems_error ("eval_for_make: look up", rc);
ffc12a58: 48 00 ef ad bl ffc21a04 <__errno> <== NOT EXECUTED
ffc12a5c: 93 c3 00 00 stw r30,0(r3) <== NOT EXECUTED
ffc12a60: 4b ff fd 80 b ffc127e0 <rtems_rfs_rtems_eval_for_make+0x120><== NOT EXECUTED
/*
* Set the parent ino in the path location.
*/
rtems_rfs_rtems_set_pathloc_ino (pathloc, ino);
ffc12a64: 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;
ffc12a68: 7f e3 fb 78 mr r3,r31
ffc12a6c: 38 81 00 14 addi r4,r1,20
/*
* Set the parent ino in the path location.
*/
rtems_rfs_rtems_set_pathloc_ino (pathloc, ino);
ffc12a70: 90 1f 00 00 stw r0,0(r31)
rtems_rfs_rtems_set_pathloc_doff (pathloc, doff);
ffc12a74: 80 01 00 08 lwz r0,8(r1)
ffc12a78: 90 1f 00 04 stw r0,4(r31)
rc = rtems_rfs_rtems_set_handlers (pathloc, &inode) ? 0 : EIO;
ffc12a7c: 48 00 07 c5 bl ffc13240 <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);
ffc12a80: 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;
ffc12a84: 30 63 ff ff addic r3,r3,-1
ffc12a88: 7c 63 19 10 subfe r3,r3,r3
ffc12a8c: 70 7f 00 05 andi. r31,r3,5
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);
ffc12a90: 7f 83 e3 78 mr r3,r28
ffc12a94: 4b ff ea 55 bl ffc114e8 <rtems_rfs_inode_close>
rtems_rfs_rtems_unlock (fs);
ffc12a98: 7f 83 e3 78 mr r3,r28
ffc12a9c: 4b ff f2 7d bl ffc11d18 <rtems_rfs_rtems_unlock>
return rc;
}
ffc12aa0: 39 61 00 68 addi r11,r1,104
ffc12aa4: 7f e3 fb 78 mr r3,r31
ffc12aa8: 4b ff 00 38 b ffc02ae0 <_restgpr_25_x>
ffc12aac <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)
{
ffc12aac: 94 21 ff a0 stwu r1,-96(r1)
ffc12ab0: 7c 08 02 a6 mflr r0
ffc12ab4: 90 01 00 64 stw r0,100(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);
ffc12ab8: 80 06 00 00 lwz r0,0(r6)
rtems_rfs_rtems_eval_path (const char* path,
size_t pathlen,
int flags,
rtems_filesystem_location_info_t* pathloc)
{
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
ffc12abc: 81 26 00 10 lwz r9,16(r6)
static int
rtems_rfs_rtems_eval_path (const char* path,
size_t pathlen,
int flags,
rtems_filesystem_location_info_t* pathloc)
{
ffc12ac0: be e1 00 3c stmw r23,60(r1)
ffc12ac4: 7c 9e 23 78 mr r30,r4
ffc12ac8: 7c 78 1b 78 mr r24,r3
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
ffc12acc: 83 49 00 34 lwz r26,52(r9)
static int
rtems_rfs_rtems_eval_path (const char* path,
size_t pathlen,
int flags,
rtems_filesystem_location_info_t* pathloc)
{
ffc12ad0: 7c bb 2b 78 mr r27,r5
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);
ffc12ad4: 90 01 00 0c stw r0,12(r1)
uint32_t doff = 0;
ffc12ad8: 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)
{
ffc12adc: 7c df 33 78 mr r31,r6
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;
ffc12ae0: 90 01 00 08 stw r0,8(r1)
path, pathlen, ino);
/*
* Eat any separators at the start of the path.
*/
stripped = rtems_filesystem_prefix_separators (path, pathlen);
ffc12ae4: 4b ff 4c 8d bl ffc07770 <rtems_filesystem_prefix_separators>
path += stripped;
ffc12ae8: 7f 18 1a 14 add r24,r24,r3
pathlen -= stripped;
ffc12aec: 7f c3 f0 50 subf r30,r3,r30
rtems_rfs_rtems_lock (fs);
ffc12af0: 80 7a 00 7c lwz r3,124(r26)
}
/*
* We need to find the parent of this node.
*/
rc = rtems_rfs_dir_lookup_ino (fs, &inode, "..", 2, &ino, &doff);
ffc12af4: 3f 20 ff c3 lis r25,-61
*/
stripped = rtems_filesystem_prefix_separators (path, pathlen);
path += stripped;
pathlen -= stripped;
rtems_rfs_rtems_lock (fs);
ffc12af8: 4b ff f4 51 bl ffc11f48 <rtems_rfs_rtems_lock.isra.16>
}
/*
* We need to find the parent of this node.
*/
rc = rtems_rfs_dir_lookup_ino (fs, &inode, "..", 2, &ino, &doff);
ffc12afc: 3b 39 18 b4 addi r25,r25,6324
ffc12b00: 48 00 00 08 b ffc12b08 <rtems_rfs_rtems_eval_path+0x5c>
/*
* Eat any separators at start of the path.
*/
stripped = rtems_filesystem_prefix_separators (path, pathlen);
path += stripped;
ffc12b04: 7f b8 eb 78 mr r24,r29
while (true)
{
/*
* Open and load the inode.
*/
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
ffc12b08: 80 81 00 0c lwz r4,12(r1)
ffc12b0c: 7f 43 d3 78 mr r3,r26
ffc12b10: 38 a1 00 10 addi r5,r1,16
ffc12b14: 38 c0 00 01 li r6,1
ffc12b18: 4b ff e7 e1 bl ffc112f8 <rtems_rfs_inode_open>
if (rc > 0)
ffc12b1c: 7c 7d 1b 79 mr. r29,r3
ffc12b20: 40 a1 00 18 ble+ ffc12b38 <rtems_rfs_rtems_eval_path+0x8c><== ALWAYS TAKEN
{
rtems_rfs_rtems_unlock (fs);
ffc12b24: 7f 43 d3 78 mr r3,r26 <== NOT EXECUTED
ffc12b28: 4b ff f1 f1 bl ffc11d18 <rtems_rfs_rtems_unlock> <== NOT EXECUTED
return rtems_rfs_rtems_error ("eval_path: opening inode", rc);
ffc12b2c: 48 00 ee d9 bl ffc21a04 <__errno> <== NOT EXECUTED
ffc12b30: 93 a3 00 00 stw r29,0(r3) <== NOT EXECUTED
ffc12b34: 48 00 00 6c b ffc12ba0 <rtems_rfs_rtems_eval_path+0xf4><== NOT EXECUTED
}
/*
* Is this the end of the pathname we where given ?
*/
if ((*path == '\0') || (pathlen == 0))
ffc12b38: 88 18 00 00 lbz r0,0(r24)
ffc12b3c: 2f 80 00 00 cmpwi cr7,r0,0
ffc12b40: 41 9e 01 ec beq- cr7,ffc12d2c <rtems_rfs_rtems_eval_path+0x280>
ffc12b44: 2f 9e 00 00 cmpwi cr7,r30,0
ffc12b48: 41 9e 01 e4 beq- cr7,ffc12d2c <rtems_rfs_rtems_eval_path+0x280>
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)) &&
ffc12b4c: 81 21 00 1c lwz r9,28(r1)
ffc12b50: 88 09 00 02 lbz r0,2(r9)
ffc12b54: 54 00 44 26 rlwinm r0,r0,8,16,19
ffc12b58: 2f 80 40 00 cmpwi cr7,r0,16384
ffc12b5c: 40 be 00 18 bne+ cr7,ffc12b74 <rtems_rfs_rtems_eval_path+0xc8>
!rtems_rfs_rtems_eval_perms (&inode, RTEMS_LIBIO_PERMS_SEARCH))
ffc12b60: 38 61 00 10 addi r3,r1,16
ffc12b64: 38 80 00 01 li r4,1
ffc12b68: 48 00 06 2d bl ffc13194 <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)) &&
ffc12b6c: 2f 83 00 00 cmpwi cr7,r3,0
ffc12b70: 41 9e 00 10 beq- cr7,ffc12b80 <rtems_rfs_rtems_eval_path+0xd4><== NEVER TAKEN
/*
* Eat any separators at start of the path.
*/
stripped = rtems_filesystem_prefix_separators (path, pathlen);
path += stripped;
ffc12b74: 7f 1d c3 78 mr r29,r24
ffc12b78: 3a e0 00 00 li r23,0
ffc12b7c: 48 00 00 38 b ffc12bb4 <rtems_rfs_rtems_eval_path+0x108>
* 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);
ffc12b80: 38 81 00 10 addi r4,r1,16 <== NOT EXECUTED
ffc12b84: 7f 43 d3 78 mr r3,r26 <== NOT EXECUTED
ffc12b88: 4b ff e9 61 bl ffc114e8 <rtems_rfs_inode_close> <== NOT EXECUTED
rtems_rfs_rtems_unlock (fs);
ffc12b8c: 7f 43 d3 78 mr r3,r26 <== NOT EXECUTED
ffc12b90: 4b ff f1 89 bl ffc11d18 <rtems_rfs_rtems_unlock> <== NOT EXECUTED
return rtems_rfs_rtems_error ("eval_path: eval perms", EACCES);
ffc12b94: 48 00 ee 71 bl ffc21a04 <__errno> <== NOT EXECUTED
ffc12b98: 38 00 00 0d li r0,13 <== NOT EXECUTED
ffc12b9c: 90 03 00 00 stw r0,0(r3) <== NOT EXECUTED
ffc12ba0: 3b e0 ff ff li r31,-1
ffc12ba4: 48 00 01 c4 b ffc12d68 <rtems_rfs_rtems_eval_path+0x2bc>
node_len = 0;
while (!rtems_filesystem_is_separator (*path) &&
(*path != '\0') && pathlen &&
((node_len + 1) < rtems_rfs_fs_max_name (fs)))
{
path++;
ffc12ba8: 3b bd 00 01 addi r29,r29,1
pathlen--;
ffc12bac: 3b de ff ff addi r30,r30,-1
ffc12bb0: 7c 17 03 78 mr r23,r0
/*
* Extract the node name we will look for this time around.
*/
node = path;
node_len = 0;
while (!rtems_filesystem_is_separator (*path) &&
ffc12bb4: 88 7d 00 00 lbz r3,0(r29)
ffc12bb8: 4b ff 66 3d bl ffc091f4 <rtems_filesystem_is_separator>
ffc12bbc: 2f 83 00 00 cmpwi cr7,r3,0
ffc12bc0: 40 9e 00 28 bne- cr7,ffc12be8 <rtems_rfs_rtems_eval_path+0x13c>
ffc12bc4: 88 1d 00 00 lbz r0,0(r29)
ffc12bc8: 2f 80 00 00 cmpwi cr7,r0,0
ffc12bcc: 41 9e 00 1c beq- cr7,ffc12be8 <rtems_rfs_rtems_eval_path+0x13c><== NEVER TAKEN
(*path != '\0') && pathlen &&
ffc12bd0: 2f 9e 00 00 cmpwi cr7,r30,0
ffc12bd4: 41 9e 00 14 beq- cr7,ffc12be8 <rtems_rfs_rtems_eval_path+0x13c><== NEVER TAKEN
ffc12bd8: 81 3a 00 18 lwz r9,24(r26)
((node_len + 1) < rtems_rfs_fs_max_name (fs)))
ffc12bdc: 38 17 00 01 addi r0,r23,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') && pathlen &&
ffc12be0: 7f 80 48 40 cmplw cr7,r0,r9
ffc12be4: 41 9c ff c4 blt+ cr7,ffc12ba8 <rtems_rfs_rtems_eval_path+0xfc><== ALWAYS TAKEN
}
/*
* Eat any separators at start of the path.
*/
stripped = rtems_filesystem_prefix_separators (path, pathlen);
ffc12be8: 7f a3 eb 78 mr r3,r29
ffc12bec: 7f c4 f3 78 mr r4,r30
ffc12bf0: 4b ff 4b 81 bl ffc07770 <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))
ffc12bf4: 88 18 00 00 lbz r0,0(r24)
/*
* Eat any separators at start of the path.
*/
stripped = rtems_filesystem_prefix_separators (path, pathlen);
path += stripped;
ffc12bf8: 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))
ffc12bfc: 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;
ffc12c00: 7f c3 f0 50 subf r30,r3,r30
node_len += stripped;
ffc12c04: 7f 83 ba 14 add r28,r3,r23
/*
* 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))
ffc12c08: 40 be 00 38 bne+ cr7,ffc12c40 <rtems_rfs_rtems_eval_path+0x194>
ffc12c0c: 88 78 00 01 lbz r3,1(r24)
ffc12c10: 2f 83 00 00 cmpwi cr7,r3,0
ffc12c14: 41 be 00 10 beq+ cr7,ffc12c24 <rtems_rfs_rtems_eval_path+0x178>
ffc12c18: 4b ff 65 dd bl ffc091f4 <rtems_filesystem_is_separator>
ffc12c1c: 2f 83 00 00 cmpwi cr7,r3,0
ffc12c20: 41 9e 00 20 beq- cr7,ffc12c40 <rtems_rfs_rtems_eval_path+0x194><== ALWAYS TAKEN
{
if (*path)
ffc12c24: 88 1d 00 00 lbz r0,0(r29)
ffc12c28: 2f 80 00 00 cmpwi cr7,r0,0
ffc12c2c: 41 be 01 00 beq+ cr7,ffc12d2c <rtems_rfs_rtems_eval_path+0x280><== ALWAYS TAKEN
{
rtems_rfs_inode_close (fs, &inode);
ffc12c30: 7f 43 d3 78 mr r3,r26 <== NOT EXECUTED
ffc12c34: 38 81 00 10 addi r4,r1,16 <== NOT EXECUTED
ffc12c38: 4b ff e8 b1 bl ffc114e8 <rtems_rfs_inode_close> <== NOT EXECUTED
continue;
ffc12c3c: 4b ff fe c8 b ffc12b04 <rtems_rfs_rtems_eval_path+0x58><== 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 (node))
ffc12c40: 88 18 00 00 lbz r0,0(r24)
ffc12c44: 2f 80 00 2e cmpwi cr7,r0,46
ffc12c48: 40 9e 00 8c bne- cr7,ffc12cd4 <rtems_rfs_rtems_eval_path+0x228>
ffc12c4c: 88 18 00 01 lbz r0,1(r24)
ffc12c50: 2f 80 00 2e cmpwi cr7,r0,46
ffc12c54: 40 be 00 80 bne+ cr7,ffc12cd4 <rtems_rfs_rtems_eval_path+0x228><== NEVER TAKEN
ffc12c58: 88 78 00 02 lbz r3,2(r24)
ffc12c5c: 2f 83 00 00 cmpwi cr7,r3,0
ffc12c60: 41 be 00 10 beq+ cr7,ffc12c70 <rtems_rfs_rtems_eval_path+0x1c4><== ALWAYS TAKEN
ffc12c64: 4b ff 65 91 bl ffc091f4 <rtems_filesystem_is_separator><== NOT EXECUTED
ffc12c68: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc12c6c: 41 9e 00 68 beq- cr7,ffc12cd4 <rtems_rfs_rtems_eval_path+0x228><== NOT EXECUTED
{
/*
* If we are at root inode of the file system we have a crossmount path.
*/
if (ino == RTEMS_RFS_ROOT_INO)
ffc12c70: 80 01 00 0c lwz r0,12(r1)
{
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);
ffc12c74: 7f 43 d3 78 mr r3,r26
ffc12c78: 38 81 00 10 addi r4,r1,16
if (rtems_rfs_parent_dir (node))
{
/*
* If we are at root inode of the file system we have a crossmount path.
*/
if (ino == RTEMS_RFS_ROOT_INO)
ffc12c7c: 2f 80 00 01 cmpwi cr7,r0,1
ffc12c80: 40 be 00 48 bne+ cr7,ffc12cc8 <rtems_rfs_rtems_eval_path+0x21c>
{
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);
ffc12c84: 4b ff e8 65 bl ffc114e8 <rtems_rfs_inode_close>
rtems_rfs_rtems_unlock (fs);
ffc12c88: 7f 43 d3 78 mr r3,r26
ffc12c8c: 4b ff f0 8d bl ffc11d18 <rtems_rfs_rtems_unlock>
*pathloc = pathloc->mt_entry->mt_point_node;
ffc12c90: 81 7f 00 10 lwz r11,16(r31)
return (*pathloc->ops->evalpath_h)(path - node_len, pathlen + node_len,
ffc12c94: 7c 7c e8 50 subf r3,r28,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;
ffc12c98: 39 6b 00 08 addi r11,r11,8
ffc12c9c: 7c ab a4 aa lswi r5,r11,20
ffc12ca0: 7c bf a5 aa stswi r5,r31,20
return (*pathloc->ops->evalpath_h)(path - node_len, pathlen + node_len,
ffc12ca4: 7c 9e e2 14 add r4,r30,r28
ffc12ca8: 7f e6 fb 78 mr r6,r31
ffc12cac: 81 3f 00 0c lwz r9,12(r31)
ffc12cb0: 7f 65 db 78 mr r5,r27
ffc12cb4: 80 09 00 00 lwz r0,0(r9)
ffc12cb8: 7c 09 03 a6 mtctr r0
ffc12cbc: 4e 80 04 21 bctrl
ffc12cc0: 7c 7f 1b 78 mr r31,r3
ffc12cc4: 48 00 00 a4 b ffc12d68 <rtems_rfs_rtems_eval_path+0x2bc>
}
/*
* We need to find the parent of this node.
*/
rc = rtems_rfs_dir_lookup_ino (fs, &inode, "..", 2, &ino, &doff);
ffc12cc8: 7f 25 cb 78 mr r5,r25
ffc12ccc: 38 c0 00 02 li r6,2
ffc12cd0: 48 00 00 14 b ffc12ce4 <rtems_rfs_rtems_eval_path+0x238>
/*
* 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,
ffc12cd4: 7f 43 d3 78 mr r3,r26
ffc12cd8: 38 81 00 10 addi r4,r1,16
ffc12cdc: 7f 05 c3 78 mr r5,r24
ffc12ce0: 7e e6 bb 78 mr r6,r23
ffc12ce4: 38 e1 00 0c addi r7,r1,12
ffc12ce8: 39 01 00 08 addi r8,r1,8
ffc12cec: 48 00 9b e1 bl ffc1c8cc <rtems_rfs_dir_lookup_ino>
node, node_len - stripped, &ino, &doff);
if (rc > 0)
ffc12cf0: 7c 7c 1b 79 mr. r28,r3
ffc12cf4: 41 81 00 18 bgt- ffc12d0c <rtems_rfs_rtems_eval_path+0x260>
}
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);
ffc12cf8: 7f 43 d3 78 mr r3,r26
ffc12cfc: 38 81 00 10 addi r4,r1,16
ffc12d00: 4b ff e7 e9 bl ffc114e8 <rtems_rfs_inode_close>
if (rc > 0)
ffc12d04: 7c 7c 1b 79 mr. r28,r3
ffc12d08: 40 81 fd fc ble+ ffc12b04 <rtems_rfs_rtems_eval_path+0x58><== ALWAYS TAKEN
{
rtems_rfs_inode_close (fs, &inode);
ffc12d0c: 38 81 00 10 addi r4,r1,16
ffc12d10: 7f 43 d3 78 mr r3,r26
ffc12d14: 4b ff e7 d5 bl ffc114e8 <rtems_rfs_inode_close>
rtems_rfs_rtems_unlock (fs);
ffc12d18: 7f 43 d3 78 mr r3,r26
ffc12d1c: 4b ff ef fd bl ffc11d18 <rtems_rfs_rtems_unlock>
return rtems_rfs_rtems_error ("eval_path: closing node", rc);
ffc12d20: 48 00 ec e5 bl ffc21a04 <__errno>
ffc12d24: 93 83 00 00 stw r28,0(r3)
ffc12d28: 4b ff fe 78 b ffc12ba0 <rtems_rfs_rtems_eval_path+0xf4>
}
}
rtems_rfs_rtems_set_pathloc_ino (pathloc, ino);
ffc12d2c: 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;
ffc12d30: 7f e3 fb 78 mr r3,r31
ffc12d34: 38 81 00 10 addi r4,r1,16
rtems_rfs_rtems_unlock (fs);
return rtems_rfs_rtems_error ("eval_path: closing node", rc);
}
}
rtems_rfs_rtems_set_pathloc_ino (pathloc, ino);
ffc12d38: 90 1f 00 00 stw r0,0(r31)
rtems_rfs_rtems_set_pathloc_doff (pathloc, doff);
ffc12d3c: 80 01 00 08 lwz r0,8(r1)
ffc12d40: 90 1f 00 04 stw r0,4(r31)
rc = rtems_rfs_rtems_set_handlers (pathloc, &inode) ? 0 : EIO;
ffc12d44: 48 00 04 fd bl ffc13240 <rtems_rfs_rtems_set_handlers>
rtems_rfs_inode_close (fs, &inode);
ffc12d48: 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;
ffc12d4c: 30 63 ff ff addic r3,r3,-1
ffc12d50: 7c 63 19 10 subfe r3,r3,r3
ffc12d54: 70 7f 00 05 andi. r31,r3,5
rtems_rfs_inode_close (fs, &inode);
ffc12d58: 7f 43 d3 78 mr r3,r26
ffc12d5c: 4b ff e7 8d bl ffc114e8 <rtems_rfs_inode_close>
rtems_rfs_rtems_unlock (fs);
ffc12d60: 7f 43 d3 78 mr r3,r26
ffc12d64: 4b ff ef b5 bl ffc11d18 <rtems_rfs_rtems_unlock>
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_EVAL_PATH))
printf("rtems-rfs-rtems: eval-path: ino:%" PRId32 "\n", ino);
return rc;
}
ffc12d68: 39 61 00 60 addi r11,r1,96
ffc12d6c: 7f e3 fb 78 mr r3,r31
ffc12d70: 4b fe fd 68 b ffc02ad8 <_restgpr_23_x>
ffc13194 <rtems_rfs_rtems_eval_perms>:
#include "rtems-rfs-rtems.h"
bool
rtems_rfs_rtems_eval_perms (rtems_rfs_inode_handle* inode, int flags)
{
ffc13194: 94 21 ff d8 stwu r1,-40(r1)
ffc13198: 7c 08 02 a6 mflr r0
ffc1319c: 90 01 00 2c stw r0,44(r1)
ffc131a0: bf 21 00 0c stmw r25,12(r1)
ffc131a4: 7c 9f 23 78 mr r31,r4
{
/*
* Mapping matches RTEMS so no need to change.
*/
return imode;
}
ffc131a8: 81 23 00 0c lwz r9,12(r3)
* @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);
ffc131ac: 8b a9 00 02 lbz r29,2(r9)
ffc131b0: 88 09 00 03 lbz r0,3(r9)
ffc131b4: 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;
ffc131b8: 8b 29 00 06 lbz r25,6(r9)
ffc131bc: 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);
ffc131c0: 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;
ffc131c4: 8b 69 00 04 lbz r27,4(r9)
ffc131c8: 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 ();
ffc131cc: 48 00 44 dd bl ffc176a8 <geteuid>
ffc131d0: 7c 7e 1b 78 mr r30,r3
st_gid = getegid ();
ffc131d4: 48 00 44 c5 bl ffc17698 <getegid>
/*
* Check if I am owner or a group member or someone else.
*/
flags_to_test = flags;
if ((st_uid == 0) || (st_uid == uid))
ffc131d8: 2f 9e 00 00 cmpwi cr7,r30,0
ffc131dc: 41 9e 00 18 beq- cr7,ffc131f4 <rtems_rfs_rtems_eval_perms+0x60><== 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;
ffc131e0: 57 39 40 2e rlwinm r25,r25,8,0,23 <== NOT EXECUTED
ffc131e4: 7f 5a cb 78 or r26,r26,r25 <== NOT EXECUTED
ffc131e8: 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;
ffc131ec: 7f e0 fb 78 mr r0,r31 <== NOT EXECUTED
if ((st_uid == 0) || (st_uid == uid))
ffc131f0: 40 be 00 14 bne+ cr7,ffc13204 <rtems_rfs_rtems_eval_perms+0x70><== NOT EXECUTED
flags_to_test |= flags << 6;
if ((st_uid == 0) || (st_gid == gid))
ffc131f4: 2f 9e 00 00 cmpwi cr7,r30,0
* 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;
ffc131f8: 57 e0 30 32 rlwinm r0,r31,6,0,25
ffc131fc: 7c 00 fb 78 or r0,r0,r31
if ((st_uid == 0) || (st_gid == gid))
ffc13200: 41 be 00 1c beq+ cr7,ffc1321c <rtems_rfs_rtems_eval_perms+0x88><== ALWAYS TAKEN
* @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;
ffc13204: 57 7b c0 0e rlwinm r27,r27,24,0,7 <== NOT EXECUTED
ffc13208: 57 9c 80 1e rlwinm r28,r28,16,0,15 <== NOT EXECUTED
ffc1320c: 7f 7c e3 78 or r28,r27,r28 <== NOT EXECUTED
ffc13210: 57 9c 84 3e rlwinm r28,r28,16,16,31 <== NOT EXECUTED
ffc13214: 7f 83 e0 00 cmpw cr7,r3,r28 <== NOT EXECUTED
ffc13218: 40 be 00 0c bne+ cr7,ffc13224 <rtems_rfs_rtems_eval_perms+0x90><== NOT EXECUTED
flags_to_test |= flags << 3;
ffc1321c: 57 ff 18 38 rlwinm r31,r31,3,0,28
ffc13220: 7c 00 fb 78 or r0,r0,r31
/*
* If all of the flags are set we have permission
* to do this.
*/
if ((flags_to_test & (mode & 0777)) != 0)
ffc13224: 57 bd 05 fe clrlwi r29,r29,23
#include <stdlib.h>
#include "rtems-rfs-rtems.h"
bool
rtems_rfs_rtems_eval_perms (rtems_rfs_inode_handle* inode, int flags)
ffc13228: 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;
}
ffc1322c: 39 61 00 28 addi r11,r1,40
#include <stdlib.h>
#include "rtems-rfs-rtems.h"
bool
rtems_rfs_rtems_eval_perms (rtems_rfs_inode_handle* inode, int flags)
ffc13230: 7c 60 00 26 mfcr r3
ffc13234: 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;
}
ffc13238: 68 63 00 01 xori r3,r3,1
ffc1323c: 4b fe f8 a4 b ffc02ae0 <_restgpr_25_x>
ffc13040 <rtems_rfs_rtems_fchmod>:
}
int
rtems_rfs_rtems_fchmod (rtems_filesystem_location_info_t* pathloc,
mode_t mode)
{
ffc13040: 94 21 ff b8 stwu r1,-72(r1) <== NOT EXECUTED
ffc13044: 7c 08 02 a6 mflr r0 <== NOT EXECUTED
ffc13048: 90 01 00 4c stw r0,76(r1) <== NOT EXECUTED
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
ffc1304c: 81 23 00 10 lwz r9,16(r3) <== NOT EXECUTED
}
int
rtems_rfs_rtems_fchmod (rtems_filesystem_location_info_t* pathloc,
mode_t mode)
{
ffc13050: bf a1 00 3c stmw r29,60(r1) <== NOT EXECUTED
ffc13054: 7c 9e 23 78 mr r30,r4 <== NOT EXECUTED
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
ffc13058: 83 e9 00 34 lwz r31,52(r9) <== NOT EXECUTED
rtems_rfs_ino ino = rtems_rfs_rtems_get_pathloc_ino (pathloc);
ffc1305c: 83 a3 00 00 lwz r29,0(r3) <== NOT EXECUTED
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_FCHMOD))
printf ("rtems-rfs-rtems: fchmod: in: ino:%" PRId32 " mode:%06" PRIomode_t "\n",
ino, mode);
rtems_rfs_rtems_lock (fs);
ffc13060: 80 7f 00 7c lwz r3,124(r31) <== NOT EXECUTED
ffc13064: 4b ff ee e5 bl ffc11f48 <rtems_rfs_rtems_lock.isra.16><== NOT EXECUTED
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
ffc13068: 7f a4 eb 78 mr r4,r29 <== NOT EXECUTED
ffc1306c: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc13070: 38 a1 00 08 addi r5,r1,8 <== NOT EXECUTED
ffc13074: 38 c0 00 01 li r6,1 <== NOT EXECUTED
ffc13078: 4b ff e2 81 bl ffc112f8 <rtems_rfs_inode_open> <== NOT EXECUTED
if (rc)
ffc1307c: 7c 7d 1b 79 mr. r29,r3 <== NOT EXECUTED
ffc13080: 41 82 00 18 beq- ffc13098 <rtems_rfs_rtems_fchmod+0x58> <== NOT EXECUTED
{
rtems_rfs_rtems_unlock (fs);
ffc13084: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc13088: 4b ff ec 91 bl ffc11d18 <rtems_rfs_rtems_unlock> <== NOT EXECUTED
return rtems_rfs_rtems_error ("fchmod: opening inode", rc);
ffc1308c: 48 00 e9 79 bl ffc21a04 <__errno> <== NOT EXECUTED
ffc13090: 93 a3 00 00 stw r29,0(r3) <== NOT EXECUTED
ffc13094: 48 00 00 58 b ffc130ec <rtems_rfs_rtems_fchmod+0xac> <== 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);
ffc13098: 81 21 00 14 lwz r9,20(r1) <== NOT EXECUTED
ffc1309c: 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();
ffc130a0: 48 00 46 09 bl ffc176a8 <geteuid> <== NOT EXECUTED
if ((uid != rtems_rfs_inode_get_uid (&inode)) && (uid != 0))
ffc130a4: 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;
ffc130a8: 88 09 00 06 lbz r0,6(r9) <== NOT EXECUTED
ffc130ac: 89 69 00 07 lbz r11,7(r9) <== NOT EXECUTED
ffc130b0: 54 00 40 2e rlwinm r0,r0,8,0,23 <== NOT EXECUTED
ffc130b4: 7c 00 5b 78 or r0,r0,r11 <== NOT EXECUTED
ffc130b8: 54 00 04 3e clrlwi r0,r0,16 <== NOT EXECUTED
ffc130bc: 7f 83 00 00 cmpw cr7,r3,r0 <== NOT EXECUTED
ffc130c0: 41 9e 00 34 beq- cr7,ffc130f4 <rtems_rfs_rtems_fchmod+0xb4><== NOT EXECUTED
ffc130c4: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc130c8: 41 be 00 2c beq+ cr7,ffc130f4 <rtems_rfs_rtems_fchmod+0xb4><== NOT EXECUTED
{
rtems_rfs_inode_close (fs, &inode);
ffc130cc: 38 81 00 08 addi r4,r1,8 <== NOT EXECUTED
ffc130d0: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc130d4: 4b ff e4 15 bl ffc114e8 <rtems_rfs_inode_close> <== NOT EXECUTED
rtems_rfs_rtems_unlock (fs);
ffc130d8: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc130dc: 4b ff ec 3d bl ffc11d18 <rtems_rfs_rtems_unlock> <== NOT EXECUTED
return rtems_rfs_rtems_error ("fchmod: checking uid", EPERM);
ffc130e0: 48 00 e9 25 bl ffc21a04 <__errno> <== NOT EXECUTED
ffc130e4: 38 00 00 01 li r0,1 <== NOT EXECUTED
ffc130e8: 90 03 00 00 stw r0,0(r3) <== NOT EXECUTED
ffc130ec: 38 60 ff ff li r3,-1 <== NOT EXECUTED
ffc130f0: 48 00 00 58 b ffc13148 <rtems_rfs_rtems_fchmod+0x108><== NOT EXECUTED
}
#endif
imode &= ~(S_IRWXU | S_IRWXG | S_IRWXO | S_ISUID | S_ISGID | S_ISVTX);
ffc130f4: 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);
ffc130f8: 57 de 05 3e clrlwi r30,r30,20 <== NOT EXECUTED
ffc130fc: 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);
ffc13100: 57 c0 c2 3e rlwinm r0,r30,24,8,31 <== NOT EXECUTED
ffc13104: 98 09 00 02 stb r0,2(r9) <== NOT EXECUTED
rtems_rfs_inode_set_mode (&inode, imode);
rc = rtems_rfs_inode_close (fs, &inode);
ffc13108: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
rtems_rfs_buffer_mark_dirty (&handle->buffer);
ffc1310c: 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);
ffc13110: 81 21 00 14 lwz r9,20(r1) <== NOT EXECUTED
ffc13114: 38 81 00 08 addi r4,r1,8 <== NOT EXECUTED
ffc13118: 9b c9 00 03 stb r30,3(r9) <== NOT EXECUTED
rtems_rfs_buffer_mark_dirty (&handle->buffer);
ffc1311c: 98 01 00 18 stb r0,24(r1) <== NOT EXECUTED
ffc13120: 4b ff e3 c9 bl ffc114e8 <rtems_rfs_inode_close> <== NOT EXECUTED
if (rc > 0)
ffc13124: 7c 7e 1b 79 mr. r30,r3 <== NOT EXECUTED
{
rtems_rfs_rtems_unlock (fs);
ffc13128: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
imode |= mode & (S_IRWXU | S_IRWXG | S_IRWXO | S_ISUID | S_ISGID | S_ISVTX);
rtems_rfs_inode_set_mode (&inode, imode);
rc = rtems_rfs_inode_close (fs, &inode);
if (rc > 0)
ffc1312c: 40 81 00 14 ble- ffc13140 <rtems_rfs_rtems_fchmod+0x100><== NOT EXECUTED
{
rtems_rfs_rtems_unlock (fs);
ffc13130: 4b ff eb e9 bl ffc11d18 <rtems_rfs_rtems_unlock> <== NOT EXECUTED
return rtems_rfs_rtems_error ("fchmod: closing inode", rc);
ffc13134: 48 00 e8 d1 bl ffc21a04 <__errno> <== NOT EXECUTED
ffc13138: 93 c3 00 00 stw r30,0(r3) <== NOT EXECUTED
ffc1313c: 4b ff ff b0 b ffc130ec <rtems_rfs_rtems_fchmod+0xac> <== NOT EXECUTED
}
rtems_rfs_rtems_unlock (fs);
ffc13140: 4b ff eb d9 bl ffc11d18 <rtems_rfs_rtems_unlock> <== NOT EXECUTED
return 0;
ffc13144: 38 60 00 00 li r3,0 <== NOT EXECUTED
}
ffc13148: 39 61 00 48 addi r11,r1,72 <== NOT EXECUTED
ffc1314c: 4b fe f9 a4 b ffc02af0 <_restgpr_29_x> <== NOT EXECUTED
ffc13150 <rtems_rfs_rtems_fdatasync>:
* @param iop
* @return int
*/
int
rtems_rfs_rtems_fdatasync (rtems_libio_t* iop)
{
ffc13150: 7c 08 02 a6 mflr r0 <== NOT EXECUTED
ffc13154: 7c 2b 0b 78 mr r11,r1 <== NOT EXECUTED
ffc13158: 94 21 ff f0 stwu r1,-16(r1) <== NOT EXECUTED
ffc1315c: 90 01 00 14 stw r0,20(r1) <== NOT EXECUTED
ffc13160: 4b fe f9 4d bl ffc02aac <_savegpr_31> <== NOT EXECUTED
int rc;
rc = rtems_rfs_buffer_sync (rtems_rfs_rtems_pathloc_dev (&iop->pathinfo));
ffc13164: 81 23 00 2c lwz r9,44(r3) <== NOT EXECUTED
ffc13168: 80 69 00 34 lwz r3,52(r9) <== NOT EXECUTED
ffc1316c: 48 00 94 6d bl ffc1c5d8 <rtems_rfs_buffer_sync> <== NOT EXECUTED
if (rc)
return rtems_rfs_rtems_error ("fdatasync: sync", rc);
return 0;
ffc13170: 38 00 00 00 li r0,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)
ffc13174: 7c 7f 1b 79 mr. r31,r3 <== NOT EXECUTED
ffc13178: 41 a2 00 10 beq+ ffc13188 <rtems_rfs_rtems_fdatasync+0x38><== NOT EXECUTED
return rtems_rfs_rtems_error ("fdatasync: sync", rc);
ffc1317c: 48 00 e8 89 bl ffc21a04 <__errno> <== NOT EXECUTED
ffc13180: 38 00 ff ff li r0,-1 <== NOT EXECUTED
ffc13184: 93 e3 00 00 stw r31,0(r3) <== NOT EXECUTED
return 0;
}
ffc13188: 39 61 00 10 addi r11,r1,16 <== NOT EXECUTED
ffc1318c: 7c 03 03 78 mr r3,r0 <== NOT EXECUTED
ffc13190: 4b fe f9 68 b ffc02af8 <_restgpr_31_x> <== NOT EXECUTED
ffc2079c <rtems_rfs_rtems_file_close>:
* @param iop
* @return int
*/
static int
rtems_rfs_rtems_file_close (rtems_libio_t* iop)
{
ffc2079c: 94 21 ff f0 stwu r1,-16(r1)
ffc207a0: 7c 08 02 a6 mflr r0
ffc207a4: 90 01 00 14 stw r0,20(r1)
ffc207a8: bf c1 00 08 stmw r30,8(r1)
rtems_rfs_file_handle* file = rtems_rfs_rtems_get_iop_file_handle (iop);
ffc207ac: 83 c3 00 20 lwz r30,32(r3)
rtems_rfs_file_system* fs = rtems_rfs_file_fs (file);
ffc207b0: 81 3e 00 1c lwz r9,28(r30)
ffc207b4: 83 e9 00 98 lwz r31,152(r9)
int rc;
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);
ffc207b8: 80 7f 00 7c lwz r3,124(r31)
ffc207bc: 4b ff fb f9 bl ffc203b4 <rtems_rfs_rtems_lock.isra.1>
rc = rtems_rfs_file_close (fs, file);
ffc207c0: 7f c4 f3 78 mr r4,r30
ffc207c4: 7f e3 fb 78 mr r3,r31
ffc207c8: 4b ff d2 fd bl ffc1dac4 <rtems_rfs_file_close>
if (rc > 0)
ffc207cc: 7c 7e 1b 79 mr. r30,r3
ffc207d0: 40 81 00 10 ble- ffc207e0 <rtems_rfs_rtems_file_close+0x44><== ALWAYS TAKEN
rc = rtems_rfs_rtems_error ("file-close: file close", rc);
ffc207d4: 48 00 12 31 bl ffc21a04 <__errno> <== NOT EXECUTED
ffc207d8: 93 c3 00 00 stw r30,0(r3) <== NOT EXECUTED
ffc207dc: 3b c0 ff ff li r30,-1 <== NOT EXECUTED
rtems_rfs_rtems_unlock (fs);
ffc207e0: 7f e3 fb 78 mr r3,r31
ffc207e4: 4b ff fb 6d bl ffc20350 <rtems_rfs_rtems_unlock>
return rc;
}
ffc207e8: 39 61 00 10 addi r11,r1,16
ffc207ec: 7f c3 f3 78 mr r3,r30
ffc207f0: 4b fe 23 04 b ffc02af4 <_restgpr_30_x>
ffc20348 <rtems_rfs_rtems_file_ioctl>:
static int
rtems_rfs_rtems_file_ioctl (rtems_libio_t* iop, uint32_t command, void* buffer)
{
return 0;
}
ffc20348: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc2034c: 4e 80 00 20 blr <== NOT EXECUTED
ffc2049c <rtems_rfs_rtems_file_lseek>:
*/
static rtems_off64_t
rtems_rfs_rtems_file_lseek (rtems_libio_t* iop,
rtems_off64_t offset,
int whence)
{
ffc2049c: 94 21 ff d8 stwu r1,-40(r1)
ffc204a0: 7c 08 02 a6 mflr r0
ffc204a4: 90 01 00 2c stw r0,44(r1)
ffc204a8: bf a1 00 1c stmw r29,28(r1)
ffc204ac: 7c 7f 1b 78 mr r31,r3
rtems_rfs_file_handle* file = rtems_rfs_rtems_get_iop_file_handle (iop);
ffc204b0: 83 c3 00 20 lwz r30,32(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));
ffc204b4: 81 3e 00 1c lwz r9,28(r30)
.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
};
ffc204b8: 81 29 00 98 lwz r9,152(r9)
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));
ffc204bc: 80 69 00 7c lwz r3,124(r9)
ffc204c0: 4b ff fe f5 bl ffc203b4 <rtems_rfs_rtems_lock.isra.1>
pos = iop->offset;
ffc204c4: 80 bf 00 10 lwz r5,16(r31)
ffc204c8: 7c 27 0b 78 mr r7,r1
ffc204cc: 80 df 00 14 lwz r6,20(r31)
ffc204d0: 94 a7 00 08 stwu r5,8(r7)
rc = rtems_rfs_file_seek (file, pos, &pos);
ffc204d4: 7f c3 f3 78 mr r3,r30
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;
ffc204d8: 90 c7 00 04 stw r6,4(r7)
rc = rtems_rfs_file_seek (file, pos, &pos);
ffc204dc: 4b ff dd 85 bl ffc1e260 <rtems_rfs_file_seek>
ffc204e0: 81 3e 00 1c lwz r9,28(r30)
if (rc)
ffc204e4: 7c 7d 1b 79 mr. r29,r3
{
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
ffc204e8: 80 69 00 98 lwz r3,152(r9)
rtems_rfs_rtems_lock (rtems_rfs_file_fs (file));
pos = iop->offset;
rc = rtems_rfs_file_seek (file, pos, &pos);
if (rc)
ffc204ec: 41 82 00 1c beq- ffc20508 <rtems_rfs_rtems_file_lseek+0x6c><== ALWAYS TAKEN
{
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
ffc204f0: 4b ff fe 61 bl ffc20350 <rtems_rfs_rtems_unlock> <== NOT EXECUTED
return rtems_rfs_rtems_error ("file_lseek: lseek", rc);
ffc204f4: 48 00 15 11 bl ffc21a04 <__errno> <== NOT EXECUTED
ffc204f8: 39 40 ff ff li r10,-1 <== NOT EXECUTED
ffc204fc: 93 a3 00 00 stw r29,0(r3) <== NOT EXECUTED
ffc20500: 39 60 ff ff li r11,-1 <== NOT EXECUTED
ffc20504: 48 00 00 10 b ffc20514 <rtems_rfs_rtems_file_lseek+0x78><== NOT EXECUTED
}
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
ffc20508: 4b ff fe 49 bl ffc20350 <rtems_rfs_rtems_unlock>
return iop->offset;
ffc2050c: 81 5f 00 10 lwz r10,16(r31)
ffc20510: 81 7f 00 14 lwz r11,20(r31)
}
ffc20514: 7d 64 5b 78 mr r4,r11
ffc20518: 39 61 00 28 addi r11,r1,40
ffc2051c: 7d 43 53 78 mr r3,r10
ffc20520: 4b fe 25 d0 b ffc02af0 <_restgpr_29_x>
ffc207f4 <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)
{
ffc207f4: 94 21 ff d8 stwu r1,-40(r1)
ffc207f8: 7c 08 02 a6 mflr r0
ffc207fc: 90 01 00 2c stw r0,44(r1)
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (&iop->pathinfo);
ffc20800: 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)
{
ffc20804: bf a1 00 1c stmw r29,28(r1)
ffc20808: 7c 7e 1b 78 mr r30,r3
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (&iop->pathinfo);
ffc2080c: 83 e9 00 34 lwz r31,52(r9)
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_FILE_OPEN))
printf("rtems-rfs: file-open: path:%s ino:%" PRId32 " flags:%04" PRIx32 " mode:%04" PRIx32 "\n",
pathname, ino, flags, mode);
rtems_rfs_rtems_lock (fs);
ffc20810: 80 7f 00 7c lwz r3,124(r31)
ffc20814: 4b ff fb a1 bl ffc203b4 <rtems_rfs_rtems_lock.isra.1>
ino = rtems_rfs_rtems_get_iop_ino (iop);
rc = rtems_rfs_file_open (fs, ino, flags, &file);
ffc20818: 80 9e 00 1c lwz r4,28(r30)
ffc2081c: 7f e3 fb 78 mr r3,r31
ffc20820: 38 a0 00 00 li r5,0
ffc20824: 38 c1 00 08 addi r6,r1,8
ffc20828: 4b ff dd f5 bl ffc1e61c <rtems_rfs_file_open>
if (rc > 0)
ffc2082c: 7c 7d 1b 79 mr. r29,r3
ffc20830: 40 81 00 1c ble- ffc2084c <rtems_rfs_rtems_file_open+0x58><== ALWAYS TAKEN
{
rtems_rfs_rtems_unlock (fs);
ffc20834: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc20838: 4b ff fb 19 bl ffc20350 <rtems_rfs_rtems_unlock> <== NOT EXECUTED
return rtems_rfs_rtems_error ("file-open: open", rc);
ffc2083c: 48 00 11 c9 bl ffc21a04 <__errno> <== NOT EXECUTED
ffc20840: 93 a3 00 00 stw r29,0(r3) <== NOT EXECUTED
ffc20844: 38 60 ff ff li r3,-1 <== NOT EXECUTED
ffc20848: 48 00 00 34 b ffc2087c <rtems_rfs_rtems_file_open+0x88><== 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);
ffc2084c: 81 21 00 08 lwz r9,8(r1)
ffc20850: 80 89 00 1c lwz r4,28(r9)
ffc20854: 80 64 00 98 lwz r3,152(r4)
ffc20858: 38 84 00 84 addi r4,r4,132
ffc2085c: 4b ff a9 31 bl ffc1b18c <rtems_rfs_block_get_size>
rtems_rfs_rtems_set_iop_file_handle (iop, file);
ffc20860: 80 01 00 08 lwz r0,8(r1)
}
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);
ffc20864: 90 7e 00 08 stw r3,8(r30)
rtems_rfs_rtems_set_iop_file_handle (iop, file);
rtems_rfs_rtems_unlock (fs);
ffc20868: 7f e3 fb 78 mr r3,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);
ffc2086c: 90 9e 00 0c stw r4,12(r30)
rtems_rfs_rtems_set_iop_file_handle (iop, file);
ffc20870: 90 1e 00 20 stw r0,32(r30)
rtems_rfs_rtems_unlock (fs);
ffc20874: 4b ff fa dd bl ffc20350 <rtems_rfs_rtems_unlock>
return 0;
ffc20878: 38 60 00 00 li r3,0
}
ffc2087c: 39 61 00 28 addi r11,r1,40
ffc20880: 4b fe 22 70 b ffc02af0 <_restgpr_29_x>
ffc2068c <rtems_rfs_rtems_file_read>:
*/
static ssize_t
rtems_rfs_rtems_file_read (rtems_libio_t* iop,
void* buffer,
size_t count)
{
ffc2068c: 94 21 ff d0 stwu r1,-48(r1)
ffc20690: 7c 08 02 a6 mflr r0
ffc20694: 90 01 00 34 stw r0,52(r1)
ffc20698: bf 61 00 1c stmw r27,28(r1)
ffc2069c: 7c 7e 1b 78 mr r30,r3
ffc206a0: 7c 9b 23 78 mr r27,r4
rtems_rfs_file_handle* file = rtems_rfs_rtems_get_iop_file_handle (iop);
ffc206a4: 83 e3 00 20 lwz r31,32(r3)
*/
static ssize_t
rtems_rfs_rtems_file_read (rtems_libio_t* iop,
void* buffer,
size_t count)
{
ffc206a8: 7c bd 2b 78 mr r29,r5
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));
ffc206ac: 81 3f 00 1c lwz r9,28(r31)
.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
};
ffc206b0: 81 29 00 98 lwz r9,152(r9)
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));
ffc206b4: 80 69 00 7c lwz r3,124(r9)
ffc206b8: 4b ff fc fd bl ffc203b4 <rtems_rfs_rtems_lock.isra.1>
pos = iop->offset;
if (pos < rtems_rfs_file_size (file))
ffc206bc: 80 9f 00 1c lwz r4,28(r31)
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;
ffc206c0: 83 9e 00 10 lwz r28,16(r30)
ffc206c4: 80 64 00 98 lwz r3,152(r4)
ffc206c8: 38 84 00 84 addi r4,r4,132
ffc206cc: 83 de 00 14 lwz r30,20(r30)
ffc206d0: 4b ff aa bd bl ffc1b18c <rtems_rfs_block_get_size>
if (pos < rtems_rfs_file_size (file))
ffc206d4: 7f 83 e0 40 cmplw cr7,r3,r28
ffc206d8: 41 bd 00 a0 bgt+ cr7,ffc20778 <rtems_rfs_rtems_file_read+0xec><== NEVER TAKEN
ffc206dc: 7f 83 e0 00 cmpw cr7,r3,r28
ffc206e0: 40 9e 00 0c bne- cr7,ffc206ec <rtems_rfs_rtems_file_read+0x60><== NEVER TAKEN
ffc206e4: 7f 84 f0 40 cmplw cr7,r4,r30
ffc206e8: 41 bd 00 90 bgt+ cr7,ffc20778 <rtems_rfs_rtems_file_read+0xec><== ALWAYS TAKEN
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;
ffc206ec: 3b c0 00 00 li r30,0 <== NOT EXECUTED
ffc206f0: 48 00 00 94 b ffc20784 <rtems_rfs_rtems_file_read+0xf8><== NOT EXECUTED
{
while (count)
{
size_t size;
rc = rtems_rfs_file_io_start (file, &size, true);
ffc206f4: 7f e3 fb 78 mr r3,r31
ffc206f8: 38 81 00 08 addi r4,r1,8
ffc206fc: 38 a0 00 01 li r5,1
ffc20700: 4b ff d6 85 bl ffc1dd84 <rtems_rfs_file_io_start>
if (rc > 0)
ffc20704: 7c 7c 1b 79 mr. r28,r3
ffc20708: 41 81 00 60 bgt- ffc20768 <rtems_rfs_rtems_file_read+0xdc><== NEVER TAKEN
{
read = rtems_rfs_rtems_error ("file-read: read: io-start", rc);
break;
}
if (size == 0)
ffc2070c: 80 01 00 08 lwz r0,8(r1)
ffc20710: 2f 80 00 00 cmpwi cr7,r0,0
ffc20714: 41 9e 00 70 beq- cr7,ffc20784 <rtems_rfs_rtems_file_read+0xf8><== NEVER TAKEN
break;
if (size > count)
ffc20718: 7f 80 e8 40 cmplw cr7,r0,r29
ffc2071c: 40 9d 00 08 ble- cr7,ffc20724 <rtems_rfs_rtems_file_read+0x98><== ALWAYS TAKEN
size = count;
ffc20720: 93 a1 00 08 stw r29,8(r1) <== NOT EXECUTED
memcpy (data, rtems_rfs_file_data (file), size);
ffc20724: 81 3f 00 0c lwz r9,12(r31)
ffc20728: 7f 63 db 78 mr r3,r27
ffc2072c: 83 81 00 08 lwz r28,8(r1)
ffc20730: 80 89 00 24 lwz r4,36(r9)
ffc20734: 80 1f 00 14 lwz r0,20(r31)
ffc20738: 7f 85 e3 78 mr r5,r28
data += size;
ffc2073c: 7f 7b e2 14 add r27,r27,r28
break;
if (size > count)
size = count;
memcpy (data, rtems_rfs_file_data (file), size);
ffc20740: 7c 84 02 14 add r4,r4,r0
ffc20744: 48 00 1f fd bl ffc22740 <memcpy>
data += size;
count -= size;
read += size;
rc = rtems_rfs_file_io_end (file, size, true);
ffc20748: 7f 84 e3 78 mr r4,r28
ffc2074c: 7f e3 fb 78 mr r3,r31
ffc20750: 38 a0 00 01 li r5,1
ffc20754: 4b ff d8 55 bl ffc1dfa8 <rtems_rfs_file_io_end>
size = count;
memcpy (data, rtems_rfs_file_data (file), size);
data += size;
count -= size;
ffc20758: 7f bc e8 50 subf r29,r28,r29
read += size;
ffc2075c: 7f de e2 14 add r30,r30,r28
rc = rtems_rfs_file_io_end (file, size, true);
if (rc > 0)
ffc20760: 7c 7c 1b 79 mr. r28,r3
ffc20764: 40 a1 00 18 ble+ ffc2077c <rtems_rfs_rtems_file_read+0xf0><== ALWAYS TAKEN
{
read = rtems_rfs_rtems_error ("file-read: read: io-end", rc);
ffc20768: 48 00 12 9d bl ffc21a04 <__errno> <== NOT EXECUTED
ffc2076c: 3b c0 ff ff li r30,-1 <== NOT EXECUTED
ffc20770: 93 83 00 00 stw r28,0(r3) <== NOT EXECUTED
ffc20774: 48 00 00 10 b ffc20784 <rtems_rfs_rtems_file_read+0xf8><== NOT EXECUTED
rtems_rfs_rtems_lock (rtems_rfs_file_fs (file));
pos = iop->offset;
if (pos < rtems_rfs_file_size (file))
ffc20778: 3b c0 00 00 li r30,0
{
while (count)
ffc2077c: 2f 9d 00 00 cmpwi cr7,r29,0
ffc20780: 40 9e ff 74 bne+ cr7,ffc206f4 <rtems_rfs_rtems_file_read+0x68>
break;
}
}
}
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
ffc20784: 81 3f 00 1c lwz r9,28(r31)
ffc20788: 80 69 00 98 lwz r3,152(r9)
ffc2078c: 4b ff fb c5 bl ffc20350 <rtems_rfs_rtems_unlock>
return read;
}
ffc20790: 39 61 00 30 addi r11,r1,48
ffc20794: 7f c3 f3 78 mr r3,r30
ffc20798: 4b fe 23 50 b ffc02ae8 <_restgpr_27_x>
ffc20524 <rtems_rfs_rtems_file_write>:
*/
static ssize_t
rtems_rfs_rtems_file_write (rtems_libio_t* iop,
const void* buffer,
size_t count)
{
ffc20524: 94 21 ff c8 stwu r1,-56(r1)
ffc20528: 7c 08 02 a6 mflr r0
ffc2052c: 90 01 00 3c stw r0,60(r1)
ffc20530: bf 21 00 1c stmw r25,28(r1)
ffc20534: 7c 7b 1b 78 mr r27,r3
ffc20538: 7c 9a 23 78 mr r26,r4
rtems_rfs_file_handle* file = rtems_rfs_rtems_get_iop_file_handle (iop);
ffc2053c: 83 e3 00 20 lwz r31,32(r3)
*/
static ssize_t
rtems_rfs_rtems_file_write (rtems_libio_t* iop,
const void* buffer,
size_t count)
{
ffc20540: 7c be 2b 78 mr r30,r5
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));
ffc20544: 81 3f 00 1c lwz r9,28(r31)
.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
};
ffc20548: 81 29 00 98 lwz r9,152(r9)
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));
ffc2054c: 80 69 00 7c lwz r3,124(r9)
ffc20550: 4b ff fe 65 bl ffc203b4 <rtems_rfs_rtems_lock.isra.1>
* 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))
ffc20554: 80 9f 00 1c lwz r4,28(r31)
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;
ffc20558: 83 9b 00 10 lwz r28,16(r27)
ffc2055c: 80 64 00 98 lwz r3,152(r4)
ffc20560: 38 84 00 84 addi r4,r4,132
ffc20564: 83 bb 00 14 lwz r29,20(r27)
ffc20568: 4b ff ac 25 bl ffc1b18c <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))
ffc2056c: 7f 83 e0 40 cmplw cr7,r3,r28
ffc20570: 41 9d 00 48 bgt- cr7,ffc205b8 <rtems_rfs_rtems_file_write+0x94><== NEVER TAKEN
ffc20574: 7f 83 e0 00 cmpw cr7,r3,r28
ffc20578: 40 9e 00 0c bne- cr7,ffc20584 <rtems_rfs_rtems_file_write+0x60><== NEVER TAKEN
ffc2057c: 7f 84 e8 40 cmplw cr7,r4,r29
ffc20580: 41 9d 00 38 bgt- cr7,ffc205b8 <rtems_rfs_rtems_file_write+0x94>
{
rc = rtems_rfs_file_set_size (file, pos + 1);
ffc20584: 7f e3 fb 78 mr r3,r31
ffc20588: 30 dd 00 01 addic r6,r29,1
ffc2058c: 7c bc 01 94 addze r5,r28
ffc20590: 4b ff dd 71 bl ffc1e300 <rtems_rfs_file_set_size>
if (rc)
ffc20594: 7c 79 1b 79 mr. r25,r3
ffc20598: 41 a2 00 20 beq+ ffc205b8 <rtems_rfs_rtems_file_write+0x94><== ALWAYS TAKEN
{
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
ffc2059c: 81 3f 00 1c lwz r9,28(r31) <== NOT EXECUTED
return rtems_rfs_rtems_error ("file-write: write extend", rc);
ffc205a0: 3b 80 ff ff li r28,-1 <== 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));
ffc205a4: 80 69 00 98 lwz r3,152(r9) <== NOT EXECUTED
ffc205a8: 4b ff fd a9 bl ffc20350 <rtems_rfs_rtems_unlock> <== NOT EXECUTED
return rtems_rfs_rtems_error ("file-write: write extend", rc);
ffc205ac: 48 00 14 59 bl ffc21a04 <__errno> <== NOT EXECUTED
ffc205b0: 93 23 00 00 stw r25,0(r3) <== NOT EXECUTED
ffc205b4: 48 00 00 cc b ffc20680 <rtems_rfs_rtems_file_write+0x15c><== NOT EXECUTED
}
}
rtems_rfs_file_set_bpos (file, pos);
ffc205b8: 81 3f 00 1c lwz r9,28(r31)
ffc205bc: 7f 85 e3 78 mr r5,r28
ffc205c0: 7f a6 eb 78 mr r6,r29
ffc205c4: 80 69 00 98 lwz r3,152(r9)
ffc205c8: 38 ff 00 10 addi r7,r31,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;
ffc205cc: 3b 80 00 00 li r28,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);
ffc205d0: 4b ff aa d9 bl ffc1b0a8 <rtems_rfs_block_get_bpos>
while (count)
ffc205d4: 48 00 00 80 b ffc20654 <rtems_rfs_rtems_file_write+0x130>
{
size_t size = count;
rc = rtems_rfs_file_io_start (file, &size, false);
ffc205d8: 7f e3 fb 78 mr r3,r31
rtems_rfs_file_set_bpos (file, pos);
while (count)
{
size_t size = count;
ffc205dc: 93 c1 00 08 stw r30,8(r1)
rc = rtems_rfs_file_io_start (file, &size, false);
ffc205e0: 38 81 00 08 addi r4,r1,8
ffc205e4: 38 a0 00 00 li r5,0
ffc205e8: 4b ff d7 9d bl ffc1dd84 <rtems_rfs_file_io_start>
if (rc)
ffc205ec: 7c 7d 1b 79 mr. r29,r3
ffc205f0: 40 82 00 54 bne- ffc20644 <rtems_rfs_rtems_file_write+0x120><== NEVER TAKEN
{
write = rtems_rfs_rtems_error ("file-write: write open", rc);
break;
}
if (size > count)
ffc205f4: 80 01 00 08 lwz r0,8(r1)
ffc205f8: 7f 80 f0 40 cmplw cr7,r0,r30
ffc205fc: 40 9d 00 08 ble- cr7,ffc20604 <rtems_rfs_rtems_file_write+0xe0><== NEVER TAKEN
size = count;
ffc20600: 93 c1 00 08 stw r30,8(r1)
memcpy (rtems_rfs_file_data (file), data, size);
ffc20604: 81 3f 00 0c lwz r9,12(r31)
ffc20608: 7f 44 d3 78 mr r4,r26
ffc2060c: 80 1f 00 14 lwz r0,20(r31)
ffc20610: 80 69 00 24 lwz r3,36(r9)
ffc20614: 80 a1 00 08 lwz r5,8(r1)
ffc20618: 7c 63 02 14 add r3,r3,r0
ffc2061c: 48 00 21 25 bl ffc22740 <memcpy>
data += size;
ffc20620: 80 81 00 08 lwz r4,8(r1)
count -= size;
write += size;
rc = rtems_rfs_file_io_end (file, size, false);
ffc20624: 7f e3 fb 78 mr r3,r31
ffc20628: 38 a0 00 00 li r5,0
if (size > count)
size = count;
memcpy (rtems_rfs_file_data (file), data, size);
data += size;
ffc2062c: 7f 5a 22 14 add r26,r26,r4
count -= size;
ffc20630: 7f c4 f0 50 subf r30,r4,r30
write += size;
ffc20634: 7f 9c 22 14 add r28,r28,r4
rc = rtems_rfs_file_io_end (file, size, false);
ffc20638: 4b ff d9 71 bl ffc1dfa8 <rtems_rfs_file_io_end>
if (rc)
ffc2063c: 7c 7d 1b 79 mr. r29,r3
ffc20640: 41 a2 00 14 beq+ ffc20654 <rtems_rfs_rtems_file_write+0x130><== ALWAYS TAKEN
{
write = rtems_rfs_rtems_error ("file-write: write close", rc);
ffc20644: 48 00 13 c1 bl ffc21a04 <__errno> <== NOT EXECUTED
ffc20648: 3b 80 ff ff li r28,-1 <== NOT EXECUTED
ffc2064c: 93 a3 00 00 stw r29,0(r3) <== NOT EXECUTED
ffc20650: 48 00 00 0c b ffc2065c <rtems_rfs_rtems_file_write+0x138><== NOT EXECUTED
}
}
rtems_rfs_file_set_bpos (file, pos);
while (count)
ffc20654: 2f 9e 00 00 cmpwi cr7,r30,0
ffc20658: 40 9e ff 80 bne+ cr7,ffc205d8 <rtems_rfs_rtems_file_write+0xb4>
write = rtems_rfs_rtems_error ("file-write: write close", rc);
break;
}
}
iop->size = rtems_rfs_file_size (file);
ffc2065c: 80 9f 00 1c lwz r4,28(r31)
ffc20660: 80 64 00 98 lwz r3,152(r4)
ffc20664: 38 84 00 84 addi r4,r4,132
ffc20668: 4b ff ab 25 bl ffc1b18c <rtems_rfs_block_get_size>
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
ffc2066c: 81 3f 00 1c lwz r9,28(r31)
write = rtems_rfs_rtems_error ("file-write: write close", rc);
break;
}
}
iop->size = rtems_rfs_file_size (file);
ffc20670: 90 7b 00 08 stw r3,8(r27)
ffc20674: 90 9b 00 0c stw r4,12(r27)
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
ffc20678: 80 69 00 98 lwz r3,152(r9)
ffc2067c: 4b ff fc d5 bl ffc20350 <rtems_rfs_rtems_unlock>
return write;
}
ffc20680: 39 61 00 38 addi r11,r1,56
ffc20684: 7f 83 e3 78 mr r3,r28
ffc20688: 4b fe 24 58 b ffc02ae0 <_restgpr_25_x>
ffc12d74 <rtems_rfs_rtems_fstat>:
}
int
rtems_rfs_rtems_fstat (rtems_filesystem_location_info_t* pathloc,
struct stat* buf)
{
ffc12d74: 94 21 ff b0 stwu r1,-80(r1)
ffc12d78: 7c 08 02 a6 mflr r0
ffc12d7c: 90 01 00 54 stw r0,84(r1)
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
ffc12d80: 81 23 00 10 lwz r9,16(r3)
}
int
rtems_rfs_rtems_fstat (rtems_filesystem_location_info_t* pathloc,
struct stat* buf)
{
ffc12d84: bf 61 00 3c stmw r27,60(r1)
ffc12d88: 7c 9f 23 78 mr r31,r4
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
ffc12d8c: 83 c9 00 34 lwz r30,52(r9)
rtems_rfs_ino ino = rtems_rfs_rtems_get_pathloc_ino (pathloc);
ffc12d90: 83 a3 00 00 lwz r29,0(r3)
int rc;
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);
ffc12d94: 80 7e 00 7c lwz r3,124(r30)
ffc12d98: 4b ff f1 b1 bl ffc11f48 <rtems_rfs_rtems_lock.isra.16>
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
ffc12d9c: 7f a4 eb 78 mr r4,r29
ffc12da0: 7f c3 f3 78 mr r3,r30
ffc12da4: 38 a1 00 08 addi r5,r1,8
ffc12da8: 38 c0 00 01 li r6,1
ffc12dac: 4b ff e5 4d bl ffc112f8 <rtems_rfs_inode_open>
if (rc)
ffc12db0: 7c 7d 1b 79 mr. r29,r3
ffc12db4: 41 a2 00 18 beq+ ffc12dcc <rtems_rfs_rtems_fstat+0x58> <== ALWAYS TAKEN
{
rtems_rfs_rtems_unlock (fs);
ffc12db8: 7f c3 f3 78 mr r3,r30 <== NOT EXECUTED
ffc12dbc: 4b ff ef 5d bl ffc11d18 <rtems_rfs_rtems_unlock> <== NOT EXECUTED
return rtems_rfs_rtems_error ("stat: opening inode", rc);
ffc12dc0: 48 00 ec 45 bl ffc21a04 <__errno> <== NOT EXECUTED
ffc12dc4: 93 a3 00 00 stw r29,0(r3) <== NOT EXECUTED
ffc12dc8: 48 00 02 60 b ffc13028 <rtems_rfs_rtems_fstat+0x2b4> <== NOT EXECUTED
}
mode = rtems_rfs_inode_get_mode (&inode);
ffc12dcc: 83 a1 00 14 lwz r29,20(r1)
ffc12dd0: 8b 9d 00 02 lbz r28,2(r29)
ffc12dd4: 88 1d 00 03 lbz r0,3(r29)
ffc12dd8: 57 9c 40 2e rlwinm r28,r28,8,0,23
if (RTEMS_RFS_S_ISCHR (mode) || RTEMS_RFS_S_ISBLK (mode))
ffc12ddc: 7f 9c 03 78 or r28,r28,r0
ffc12de0: 57 80 04 26 rlwinm r0,r28,0,16,19
ffc12de4: 2f 80 20 00 cmpwi cr7,r0,8192
ffc12de8: 41 9e 00 0c beq- cr7,ffc12df4 <rtems_rfs_rtems_fstat+0x80><== NEVER TAKEN
ffc12dec: 2f 80 60 00 cmpwi cr7,r0,24576
ffc12df0: 40 be 00 28 bne+ cr7,ffc12e18 <rtems_rfs_rtems_fstat+0xa4><== ALWAYS TAKEN
{
buf->st_rdev =
rtems_filesystem_make_dev_t (rtems_rfs_inode_get_block (&inode, 0),
ffc12df4: 38 80 00 00 li r4,0 <== NOT EXECUTED
ffc12df8: 7f a3 eb 78 mr r3,r29 <== NOT EXECUTED
ffc12dfc: 4b ff ef d1 bl ffc11dcc <rtems_rfs_inode_get_block.isra.9><== NOT EXECUTED
ffc12e00: 38 80 00 01 li r4,1 <== NOT EXECUTED
ffc12e04: 7c 7b 1b 78 mr r27,r3 <== NOT EXECUTED
ffc12e08: 7f a3 eb 78 mr r3,r29 <== NOT EXECUTED
ffc12e0c: 4b ff ef c1 bl ffc11dcc <rtems_rfs_inode_get_block.isra.9><== NOT EXECUTED
mode = rtems_rfs_inode_get_mode (&inode);
if (RTEMS_RFS_S_ISCHR (mode) || RTEMS_RFS_S_ISBLK (mode))
{
buf->st_rdev =
ffc12e10: 93 7f 00 18 stw r27,24(r31) <== NOT EXECUTED
ffc12e14: 90 7f 00 1c stw r3,28(r31) <== NOT EXECUTED
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);
ffc12e18: 81 3e 00 0c lwz r9,12(r30)
buf->st_ino = rtems_rfs_inode_ino (&inode);
buf->st_mode = rtems_rfs_rtems_mode (mode);
ffc12e1c: 7f 83 e3 78 mr r3,r28
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);
buf->st_ino = rtems_rfs_inode_ino (&inode);
ffc12e20: 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);
ffc12e24: 81 69 00 04 lwz r11,4(r9)
ffc12e28: 81 49 00 00 lwz r10,0(r9)
ffc12e2c: 91 7f 00 04 stw r11,4(r31)
buf->st_ino = rtems_rfs_inode_ino (&inode);
ffc12e30: 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);
ffc12e34: 91 5f 00 00 stw r10,0(r31)
buf->st_ino = rtems_rfs_inode_ino (&inode);
buf->st_mode = rtems_rfs_rtems_mode (mode);
ffc12e38: 48 00 04 c9 bl ffc13300 <rtems_rfs_rtems_mode>
buf->st_nlink = rtems_rfs_inode_get_links (&inode);
ffc12e3c: 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);
ffc12e40: 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);
ffc12e44: 88 09 00 00 lbz r0,0(r9)
ffc12e48: 89 69 00 01 lbz r11,1(r9)
ffc12e4c: 54 00 40 2e rlwinm r0,r0,8,0,23
ffc12e50: 7c 00 5b 78 or r0,r0,r11
if (links == 0xffff)
ffc12e54: 6c 0b ff ff xoris r11,r0,65535
ffc12e58: 2f 8b ff ff cmpwi cr7,r11,-1
ffc12e5c: 40 9e 00 08 bne- cr7,ffc12e64 <rtems_rfs_rtems_fstat+0xf0><== ALWAYS TAKEN
links = 0;
ffc12e60: 38 00 00 00 li r0,0 <== NOT EXECUTED
buf->st_nlink = rtems_rfs_inode_get_links (&inode);
ffc12e64: 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));
ffc12e68: 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;
ffc12e6c: 88 09 00 06 lbz r0,6(r9)
ffc12e70: 89 69 00 07 lbz r11,7(r9)
ffc12e74: 54 00 40 2e rlwinm r0,r0,8,0,23
ffc12e78: 80 81 00 10 lwz r4,16(r1)
ffc12e7c: 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);
ffc12e80: 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;
ffc12e84: 89 69 00 04 lbz r11,4(r9)
ffc12e88: 88 09 00 05 lbz r0,5(r9)
ffc12e8c: 55 6b c0 0e rlwinm r11,r11,24,0,7
ffc12e90: 54 00 80 1e rlwinm r0,r0,16,0,15
ffc12e94: 7d 60 03 78 or r0,r11,r0
ffc12e98: 54 00 84 3e rlwinm r0,r0,16,16,31
ffc12e9c: 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));
ffc12ea0: 48 00 b7 49 bl ffc1e5e8 <rtems_rfs_file_get_shared>
if (shared)
ffc12ea4: 7c 64 1b 79 mr. r4,r3
ffc12ea8: 41 82 00 5c beq- ffc12f04 <rtems_rfs_rtems_fstat+0x190> <== ALWAYS TAKEN
{
buf->st_atime = rtems_rfs_file_shared_get_atime (shared);
ffc12eac: 80 04 00 8c lwz r0,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))
ffc12eb0: 81 3f 00 0c lwz r9,12(r31) <== 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);
ffc12eb4: 90 1f 00 28 stw r0,40(r31) <== 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))
ffc12eb8: 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);
ffc12ebc: 80 04 00 90 lwz r0,144(r4) <== NOT EXECUTED
ffc12ec0: 90 1f 00 30 stw r0,48(r31) <== NOT EXECUTED
buf->st_ctime = rtems_rfs_file_shared_get_ctime (shared);
ffc12ec4: 80 04 00 94 lwz r0,148(r4) <== NOT EXECUTED
ffc12ec8: 90 1f 00 38 stw r0,56(r31) <== NOT EXECUTED
buf->st_blocks = rtems_rfs_file_shared_get_block_count (shared);
ffc12ecc: 80 04 00 84 lwz r0,132(r4) <== NOT EXECUTED
ffc12ed0: 90 1f 00 44 stw r0,68(r31) <== NOT EXECUTED
if (S_ISLNK (buf->st_mode))
ffc12ed4: 6d 20 ff ff xoris r0,r9,65535 <== NOT EXECUTED
ffc12ed8: 2f 80 a0 00 cmpwi cr7,r0,-24576 <== NOT EXECUTED
ffc12edc: 40 9e 00 18 bne- cr7,ffc12ef4 <rtems_rfs_rtems_fstat+0x180><== NOT EXECUTED
buf->st_size = rtems_rfs_file_shared_get_block_offset (shared);
ffc12ee0: a0 04 00 8a lhz r0,138(r4) <== NOT EXECUTED
ffc12ee4: 90 1f 00 24 stw r0,36(r31) <== NOT EXECUTED
ffc12ee8: 38 00 00 00 li r0,0 <== NOT EXECUTED
ffc12eec: 90 1f 00 20 stw r0,32(r31) <== NOT EXECUTED
ffc12ef0: 48 00 01 0c b ffc12ffc <rtems_rfs_rtems_fstat+0x288> <== 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);
ffc12ef4: 7f c3 f3 78 mr r3,r30 <== NOT EXECUTED
ffc12ef8: 38 84 00 84 addi r4,r4,132 <== NOT EXECUTED
ffc12efc: 48 00 82 91 bl ffc1b18c <rtems_rfs_block_get_size> <== NOT EXECUTED
ffc12f00: 48 00 00 f4 b ffc12ff4 <rtems_rfs_rtems_fstat+0x280> <== NOT EXECUTED
else
buf->st_size = rtems_rfs_file_shared_get_size (fs, shared);
}
else
{
buf->st_atime = rtems_rfs_inode_get_atime (&inode);
ffc12f04: 81 21 00 14 lwz r9,20(r1)
* @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);
ffc12f08: 89 69 00 10 lbz r11,16(r9)
ffc12f0c: 88 09 00 11 lbz r0,17(r9)
ffc12f10: 55 6b c0 0e rlwinm r11,r11,24,0,7
ffc12f14: 54 00 80 1e rlwinm r0,r0,16,0,15
ffc12f18: 7d 60 03 78 or r0,r11,r0
ffc12f1c: 89 69 00 13 lbz r11,19(r9)
ffc12f20: 7c 00 5b 78 or r0,r0,r11
ffc12f24: 89 69 00 12 lbz r11,18(r9)
ffc12f28: 55 6b 40 2e rlwinm r11,r11,8,0,23
ffc12f2c: 7c 00 5b 78 or r0,r0,r11
ffc12f30: 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);
ffc12f34: 89 69 00 14 lbz r11,20(r9)
ffc12f38: 88 09 00 15 lbz r0,21(r9)
ffc12f3c: 55 6b c0 0e rlwinm r11,r11,24,0,7
ffc12f40: 54 00 80 1e rlwinm r0,r0,16,0,15
ffc12f44: 7d 60 03 78 or r0,r11,r0
ffc12f48: 89 69 00 17 lbz r11,23(r9)
ffc12f4c: 7c 00 5b 78 or r0,r0,r11
ffc12f50: 89 69 00 16 lbz r11,22(r9)
ffc12f54: 55 6b 40 2e rlwinm r11,r11,8,0,23
ffc12f58: 7c 00 5b 78 or r0,r0,r11
buf->st_mtime = rtems_rfs_inode_get_mtime (&inode);
ffc12f5c: 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);
ffc12f60: 89 69 00 18 lbz r11,24(r9)
ffc12f64: 88 09 00 19 lbz r0,25(r9)
ffc12f68: 55 6b c0 0e rlwinm r11,r11,24,0,7
ffc12f6c: 54 00 80 1e rlwinm r0,r0,16,0,15
ffc12f70: 7d 60 03 78 or r0,r11,r0
ffc12f74: 89 69 00 1b lbz r11,27(r9)
ffc12f78: 7c 00 5b 78 or r0,r0,r11
ffc12f7c: 89 69 00 1a lbz r11,26(r9)
ffc12f80: 55 6b 40 2e rlwinm r11,r11,8,0,23
ffc12f84: 7c 00 5b 78 or r0,r0,r11
buf->st_ctime = rtems_rfs_inode_get_ctime (&inode);
ffc12f88: 90 1f 00 38 stw r0,56(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);
ffc12f8c: 89 69 00 0c lbz r11,12(r9)
ffc12f90: 88 09 00 0d lbz r0,13(r9)
ffc12f94: 55 6b c0 0e rlwinm r11,r11,24,0,7
ffc12f98: 54 00 80 1e rlwinm r0,r0,16,0,15
ffc12f9c: 7d 60 03 78 or r0,r11,r0
ffc12fa0: 89 69 00 0f lbz r11,15(r9)
ffc12fa4: 7c 00 5b 78 or r0,r0,r11
ffc12fa8: 89 69 00 0e lbz r11,14(r9)
ffc12fac: 55 6b 40 2e rlwinm r11,r11,8,0,23
ffc12fb0: 7c 00 5b 78 or r0,r0,r11
buf->st_blocks = rtems_rfs_inode_get_block_count (&inode);
if (S_ISLNK (buf->st_mode))
ffc12fb4: 81 7f 00 0c lwz r11,12(r31)
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);
ffc12fb8: 90 1f 00 44 stw r0,68(r31)
if (S_ISLNK (buf->st_mode))
ffc12fbc: 55 6b 04 26 rlwinm r11,r11,0,16,19
ffc12fc0: 6d 60 ff ff xoris r0,r11,65535
ffc12fc4: 2f 80 a0 00 cmpwi cr7,r0,-24576
ffc12fc8: 40 9e 00 20 bne- cr7,ffc12fe8 <rtems_rfs_rtems_fstat+0x274>
* @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);
ffc12fcc: 88 09 00 0a lbz r0,10(r9)
ffc12fd0: 89 29 00 0b lbz r9,11(r9)
ffc12fd4: 54 00 40 2e rlwinm r0,r0,8,0,23
buf->st_size = rtems_rfs_inode_get_block_offset (&inode);
ffc12fd8: 90 9f 00 20 stw r4,32(r31)
ffc12fdc: 7c 00 4b 78 or r0,r0,r9
ffc12fe0: 90 1f 00 24 stw r0,36(r31)
ffc12fe4: 48 00 00 18 b ffc12ffc <rtems_rfs_rtems_fstat+0x288>
else
buf->st_size = rtems_rfs_inode_get_size (fs, &inode);
ffc12fe8: 7f c3 f3 78 mr r3,r30
ffc12fec: 38 81 00 08 addi r4,r1,8
ffc12ff0: 4b ff eb c1 bl ffc11bb0 <rtems_rfs_inode_get_size>
ffc12ff4: 90 7f 00 20 stw r3,32(r31)
ffc12ff8: 90 9f 00 24 stw r4,36(r31)
}
buf->st_blksize = rtems_rfs_fs_block_size (fs);
ffc12ffc: 80 1e 00 08 lwz r0,8(r30)
rc = rtems_rfs_inode_close (fs, &inode);
ffc13000: 7f c3 f3 78 mr r3,r30
ffc13004: 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);
ffc13008: 90 1f 00 40 stw r0,64(r31)
rc = rtems_rfs_inode_close (fs, &inode);
ffc1300c: 4b ff e4 dd bl ffc114e8 <rtems_rfs_inode_close>
if (rc > 0)
ffc13010: 7c 7f 1b 79 mr. r31,r3
{
rtems_rfs_rtems_unlock (fs);
ffc13014: 7f c3 f3 78 mr r3,r30
}
buf->st_blksize = rtems_rfs_fs_block_size (fs);
rc = rtems_rfs_inode_close (fs, &inode);
if (rc > 0)
ffc13018: 40 81 00 18 ble- ffc13030 <rtems_rfs_rtems_fstat+0x2bc> <== ALWAYS TAKEN
{
rtems_rfs_rtems_unlock (fs);
ffc1301c: 4b ff ec fd bl ffc11d18 <rtems_rfs_rtems_unlock> <== NOT EXECUTED
return rtems_rfs_rtems_error ("stat: closing inode", rc);
ffc13020: 48 00 e9 e5 bl ffc21a04 <__errno> <== NOT EXECUTED
ffc13024: 93 e3 00 00 stw r31,0(r3) <== NOT EXECUTED
ffc13028: 38 60 ff ff li r3,-1 <== NOT EXECUTED
ffc1302c: 48 00 00 0c b ffc13038 <rtems_rfs_rtems_fstat+0x2c4> <== NOT EXECUTED
}
rtems_rfs_rtems_unlock (fs);
ffc13030: 4b ff ec e9 bl ffc11d18 <rtems_rfs_rtems_unlock>
return 0;
ffc13034: 38 60 00 00 li r3,0
}
ffc13038: 39 61 00 50 addi r11,r1,80
ffc1303c: 4b fe fa ac b ffc02ae8 <_restgpr_27_x>
ffc11e78 <rtems_rfs_rtems_initialise>:
*/
int
rtems_rfs_rtems_initialise (rtems_filesystem_mount_table_entry_t* mt_entry,
const void* data)
{
ffc11e78: 94 21 ff d8 stwu r1,-40(r1)
ffc11e7c: 7c 08 02 a6 mflr r0
ffc11e80: bf a1 00 1c stmw r29,28(r1)
ffc11e84: 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));
ffc11e88: 38 60 00 04 li r3,4
*/
int
rtems_rfs_rtems_initialise (rtems_filesystem_mount_table_entry_t* mt_entry,
const void* data)
{
ffc11e8c: 90 01 00 2c stw r0,44(r1)
rtems_rfs_rtems_private* rtems;
rtems_rfs_file_system* fs;
int rc;
rtems = malloc (sizeof (rtems_rfs_rtems_private));
ffc11e90: 4b ff 61 c5 bl ffc08054 <malloc>
if (!rtems)
ffc11e94: 7c 7f 1b 79 mr. r31,r3
ffc11e98: 40 a2 00 14 bne+ ffc11eac <rtems_rfs_rtems_initialise+0x34><== ALWAYS TAKEN
return rtems_rfs_rtems_error ("initialise: local data", ENOMEM);
ffc11e9c: 48 00 fb 69 bl ffc21a04 <__errno> <== NOT EXECUTED
ffc11ea0: 38 00 00 0c li r0,12 <== NOT EXECUTED
ffc11ea4: 90 03 00 00 stw r0,0(r3) <== NOT EXECUTED
ffc11ea8: 48 00 00 28 b ffc11ed0 <rtems_rfs_rtems_initialise+0x58><== NOT EXECUTED
memset (rtems, 0, sizeof (rtems_rfs_rtems_private));
ffc11eac: 38 00 00 00 li r0,0
ffc11eb0: 90 1f 00 00 stw r0,0(r31)
rc = rtems_rfs_mutex_create (&rtems->access);
ffc11eb4: 48 00 dc d9 bl ffc1fb8c <rtems_rfs_mutex_create>
if (rc > 0)
ffc11eb8: 7c 7d 1b 79 mr. r29,r3
ffc11ebc: 40 81 00 1c ble- ffc11ed8 <rtems_rfs_rtems_initialise+0x60><== ALWAYS TAKEN
{
free (rtems);
ffc11ec0: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc11ec4: 4b ff 5a 25 bl ffc078e8 <free> <== NOT EXECUTED
return rtems_rfs_rtems_error ("initialise: cannot create mutex", rc);
ffc11ec8: 48 00 fb 3d bl ffc21a04 <__errno> <== NOT EXECUTED
ffc11ecc: 93 a3 00 00 stw r29,0(r3) <== NOT EXECUTED
ffc11ed0: 38 60 ff ff li r3,-1 <== NOT EXECUTED
ffc11ed4: 48 00 00 6c b ffc11f40 <rtems_rfs_rtems_initialise+0xc8><== NOT EXECUTED
}
rc = rtems_rfs_mutex_lock (&rtems->access);
ffc11ed8: 80 7f 00 00 lwz r3,0(r31)
ffc11edc: 4b ff ff 35 bl ffc11e10 <rtems_rfs_mutex_lock.isra.15>
if (rc > 0)
ffc11ee0: 7c 7d 1b 79 mr. r29,r3
ffc11ee4: 40 81 00 10 ble- ffc11ef4 <rtems_rfs_rtems_initialise+0x7c><== ALWAYS TAKEN
{
rtems_rfs_mutex_destroy (&rtems->access);
ffc11ee8: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc11eec: 48 00 dd 19 bl ffc1fc04 <rtems_rfs_mutex_destroy> <== NOT EXECUTED
ffc11ef0: 4b ff ff d0 b ffc11ec0 <rtems_rfs_rtems_initialise+0x48><== NOT EXECUTED
free (rtems);
return rtems_rfs_rtems_error ("initialise: cannot lock access mutex", rc);
}
rc = rtems_rfs_fs_open (mt_entry->dev, rtems, 0, &fs);
ffc11ef4: 80 7e 00 70 lwz r3,112(r30)
ffc11ef8: 7f e4 fb 78 mr r4,r31
ffc11efc: 38 a0 00 00 li r5,0
ffc11f00: 38 c1 00 08 addi r6,r1,8
ffc11f04: 48 00 ca 51 bl ffc1e954 <rtems_rfs_fs_open>
if (rc)
ffc11f08: 7c 7d 1b 79 mr. r29,r3
ffc11f0c: 40 a2 ff b4 bne- ffc11ec0 <rtems_rfs_rtems_initialise+0x48><== NEVER TAKEN
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;
ffc11f10: 38 00 00 01 li r0,1
{
free (rtems);
return rtems_rfs_rtems_error ("initialise: open", rc);
}
mt_entry->fs_info = fs;
ffc11f14: 80 61 00 08 lwz r3,8(r1)
mt_entry->mt_fs_root.node_access = (void*) RTEMS_RFS_ROOT_INO;
mt_entry->mt_fs_root.handlers = &rtems_rfs_rtems_dir_handlers;
ffc11f18: 3d 20 ff c3 lis r9,-61
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;
ffc11f1c: 90 1e 00 1c stw r0,28(r30)
mt_entry->mt_fs_root.handlers = &rtems_rfs_rtems_dir_handlers;
ffc11f20: 38 09 56 bc addi r0,r9,22204
mt_entry->mt_fs_root.ops = &rtems_rfs_ops;
ffc11f24: 3d 20 ff c3 lis r9,-61
}
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;
ffc11f28: 90 1e 00 24 stw r0,36(r30)
mt_entry->mt_fs_root.ops = &rtems_rfs_ops;
ffc11f2c: 38 09 35 b4 addi r0,r9,13748
{
free (rtems);
return rtems_rfs_rtems_error ("initialise: open", rc);
}
mt_entry->fs_info = fs;
ffc11f30: 90 7e 00 34 stw r3,52(r30)
mt_entry->mt_fs_root.node_access = (void*) RTEMS_RFS_ROOT_INO;
mt_entry->mt_fs_root.handlers = &rtems_rfs_rtems_dir_handlers;
mt_entry->mt_fs_root.ops = &rtems_rfs_ops;
ffc11f34: 90 1e 00 28 stw r0,40(r30)
rtems_rfs_rtems_unlock (fs);
ffc11f38: 4b ff fd e1 bl ffc11d18 <rtems_rfs_rtems_unlock>
return 0;
ffc11f3c: 38 60 00 00 li r3,0
}
ffc11f40: 39 61 00 28 addi r11,r1,40
ffc11f44: 4b ff 0b ac b ffc02af0 <_restgpr_29_x>
ffc1207c <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)
{
ffc1207c: 94 21 ff e8 stwu r1,-24(r1)
ffc12080: 7c 08 02 a6 mflr r0
ffc12084: 90 01 00 1c stw r0,28(r1)
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (to_loc);
ffc12088: 81 23 00 10 lwz r9,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)
{
ffc1208c: bf 81 00 08 stmw r28,8(r1)
ffc12090: 7c bc 2b 78 mr r28,r5
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (to_loc);
ffc12094: 83 e9 00 34 lwz r31,52(r9)
rtems_rfs_ino target = rtems_rfs_rtems_get_pathloc_ino (to_loc);
ffc12098: 83 c3 00 00 lwz r30,0(r3)
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_LINK))
printf ("rtems-rfs-rtems: link: in: parent:%" PRId32 " target:%" PRId32 "\n",
parent, target);
rtems_rfs_rtems_lock (fs);
ffc1209c: 80 7f 00 7c lwz r3,124(r31)
rtems_filesystem_location_info_t* parent_loc,
const char* name)
{
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);
ffc120a0: 83 a4 00 00 lwz r29,0(r4)
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_LINK))
printf ("rtems-rfs-rtems: link: in: parent:%" PRId32 " target:%" PRId32 "\n",
parent, target);
rtems_rfs_rtems_lock (fs);
ffc120a4: 4b ff fe a5 bl ffc11f48 <rtems_rfs_rtems_lock.isra.16>
rc = rtems_rfs_link (fs, name, strlen (name), parent, target, false);
ffc120a8: 7f 83 e3 78 mr r3,r28
ffc120ac: 48 01 17 c1 bl ffc2386c <strlen>
ffc120b0: 7f c7 f3 78 mr r7,r30
ffc120b4: 7c 65 1b 78 mr r5,r3
ffc120b8: 7f 84 e3 78 mr r4,r28
ffc120bc: 7f e3 fb 78 mr r3,r31
ffc120c0: 7f a6 eb 78 mr r6,r29
ffc120c4: 39 00 00 00 li r8,0
ffc120c8: 48 00 d1 09 bl ffc1f1d0 <rtems_rfs_link>
if (rc)
ffc120cc: 7c 7e 1b 79 mr. r30,r3
{
rtems_rfs_rtems_unlock (fs);
ffc120d0: 7f e3 fb 78 mr r3,r31
parent, target);
rtems_rfs_rtems_lock (fs);
rc = rtems_rfs_link (fs, name, strlen (name), parent, target, false);
if (rc)
ffc120d4: 41 82 00 18 beq- ffc120ec <rtems_rfs_rtems_link+0x70> <== ALWAYS TAKEN
{
rtems_rfs_rtems_unlock (fs);
ffc120d8: 4b ff fc 41 bl ffc11d18 <rtems_rfs_rtems_unlock> <== NOT EXECUTED
return rtems_rfs_rtems_error ("link: linking", rc);
ffc120dc: 48 00 f9 29 bl ffc21a04 <__errno> <== NOT EXECUTED
ffc120e0: 93 c3 00 00 stw r30,0(r3) <== NOT EXECUTED
ffc120e4: 38 60 ff ff li r3,-1 <== NOT EXECUTED
ffc120e8: 48 00 00 0c b ffc120f4 <rtems_rfs_rtems_link+0x78> <== NOT EXECUTED
}
rtems_rfs_rtems_unlock (fs);
ffc120ec: 4b ff fc 2d bl ffc11d18 <rtems_rfs_rtems_unlock>
return 0;
ffc120f0: 38 60 00 00 li r3,0
}
ffc120f4: 39 61 00 18 addi r11,r1,24
ffc120f8: 4b ff 09 f4 b ffc02aec <_restgpr_28_x>
ffc203b4 <rtems_rfs_rtems_lock.isra.1>:
/**
* Lock the RFS file system.
*/
static inline void
rtems_rfs_rtems_lock (rtems_rfs_file_system* fs)
ffc203b4: 7c 2b 0b 78 mr r11,r1
ffc203b8: 7c 08 02 a6 mflr r0
ffc203bc: 94 21 ff f0 stwu r1,-16(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);
ffc203c0: 38 80 00 00 li r4,0
ffc203c4: 38 a0 00 00 li r5,0
ffc203c8: 90 01 00 14 stw r0,20(r1)
ffc203cc: 4b fe 26 e1 bl ffc02aac <_savegpr_31>
ffc203d0: 80 63 00 00 lwz r3,0(r3)
ffc203d4: 4b fe b9 1d bl ffc0bcf0 <rtems_semaphore_obtain>
if (sc != RTEMS_SUCCESSFUL)
ffc203d8: 7c 7f 1b 79 mr. r31,r3
ffc203dc: 41 a2 00 34 beq+ ffc20410 <rtems_rfs_rtems_lock.isra.1+0x5c><== ALWAYS TAKEN
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
ffc203e0: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc203e4: 38 80 00 04 li r4,4 <== NOT EXECUTED
ffc203e8: 4b ff 2f 1d bl ffc13304 <rtems_rfs_trace> <== NOT EXECUTED
ffc203ec: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc203f0: 41 be 00 20 beq+ cr7,ffc20410 <rtems_rfs_rtems_lock.isra.1+0x5c><== NOT EXECUTED
printf ("rtems-rfs: mutex: obtain failed: %s\n",
ffc203f4: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc203f8: 4b ff 6e c5 bl ffc172bc <rtems_status_text> <== NOT EXECUTED
ffc203fc: 7c 64 1b 78 mr r4,r3 <== NOT EXECUTED
ffc20400: 3c 60 ff c3 lis r3,-61 <== NOT EXECUTED
ffc20404: 38 63 36 5a addi r3,r3,13914 <== NOT EXECUTED
ffc20408: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc2040c: 48 00 26 dd bl ffc22ae8 <printf> <== NOT EXECUTED
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
rtems_rfs_mutex_lock (&rtems->access);
}
ffc20410: 39 61 00 10 addi r11,r1,16
ffc20414: 4b fe 26 e4 b ffc02af8 <_restgpr_31_x>
ffc2008c <rtems_rfs_rtems_lock.isra.3>:
/**
* Lock the RFS file system.
*/
static inline void
rtems_rfs_rtems_lock (rtems_rfs_file_system* fs)
ffc2008c: 7c 2b 0b 78 mr r11,r1
ffc20090: 7c 08 02 a6 mflr r0
ffc20094: 94 21 ff f0 stwu r1,-16(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);
ffc20098: 38 80 00 00 li r4,0
ffc2009c: 38 a0 00 00 li r5,0
ffc200a0: 90 01 00 14 stw r0,20(r1)
ffc200a4: 4b fe 2a 09 bl ffc02aac <_savegpr_31>
ffc200a8: 80 63 00 00 lwz r3,0(r3)
ffc200ac: 4b fe bc 45 bl ffc0bcf0 <rtems_semaphore_obtain>
if (sc != RTEMS_SUCCESSFUL)
ffc200b0: 7c 7f 1b 79 mr. r31,r3
ffc200b4: 41 a2 00 34 beq+ ffc200e8 <rtems_rfs_rtems_lock.isra.3+0x5c><== ALWAYS TAKEN
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
ffc200b8: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc200bc: 38 80 00 04 li r4,4 <== NOT EXECUTED
ffc200c0: 4b ff 32 45 bl ffc13304 <rtems_rfs_trace> <== NOT EXECUTED
ffc200c4: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc200c8: 41 be 00 20 beq+ cr7,ffc200e8 <rtems_rfs_rtems_lock.isra.3+0x5c><== NOT EXECUTED
printf ("rtems-rfs: mutex: obtain failed: %s\n",
ffc200cc: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc200d0: 4b ff 71 ed bl ffc172bc <rtems_status_text> <== NOT EXECUTED
ffc200d4: 7c 64 1b 78 mr r4,r3 <== NOT EXECUTED
ffc200d8: 3c 60 ff c3 lis r3,-61 <== NOT EXECUTED
ffc200dc: 38 63 36 5a addi r3,r3,13914 <== NOT EXECUTED
ffc200e0: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc200e4: 48 00 2a 05 bl ffc22ae8 <printf> <== NOT EXECUTED
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
rtems_rfs_mutex_lock (&rtems->access);
}
ffc200e8: 39 61 00 10 addi r11,r1,16
ffc200ec: 4b fe 2a 0c b ffc02af8 <_restgpr_31_x>
ffc12558 <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)
{
ffc12558: 94 21 ff 98 stwu r1,-104(r1)
ffc1255c: 7c 08 02 a6 mflr r0
ffc12560: 90 01 00 6c stw r0,108(r1)
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
ffc12564: 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)
{
ffc12568: be e1 00 44 stmw r23,68(r1)
ffc1256c: 7c 9e 23 78 mr r30,r4
ffc12570: 7c bc 2b 78 mr r28,r5
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
ffc12574: 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)
{
ffc12578: 7c dd 33 78 mr r29,r6
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
rtems_rfs_ino parent = rtems_rfs_rtems_get_pathloc_ino (pathloc);
ffc1257c: 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)
{
ffc12580: 7c 79 1b 78 mr r25,r3
uid_t uid;
gid_t gid;
int rc;
#if defined(RTEMS_POSIX_API)
uid = geteuid ();
ffc12584: 48 00 51 25 bl ffc176a8 <geteuid>
ffc12588: 7c 7a 1b 78 mr r26,r3
gid = getegid ();
ffc1258c: 48 00 51 0d bl ffc17698 <getegid>
ffc12590: 7c 7b 1b 78 mr r27,r3
#else
uid = 0;
gid = 0;
#endif
rtems_rfs_rtems_lock (fs);
ffc12594: 80 7f 00 7c lwz r3,124(r31)
ffc12598: 4b ff f9 b1 bl ffc11f48 <rtems_rfs_rtems_lock.isra.16>
rc = rtems_rfs_inode_create (fs, parent, name, strlen (name),
ffc1259c: 7f 23 cb 78 mr r3,r25
ffc125a0: 48 01 12 cd bl ffc2386c <strlen>
ffc125a4: 7c 78 1b 78 mr r24,r3
ffc125a8: 7f c3 f3 78 mr r3,r30
ffc125ac: 48 00 0d 4d bl ffc132f8 <rtems_rfs_rtems_imode>
ffc125b0: 38 01 00 10 addi r0,r1,16
ffc125b4: 7c 67 1b 78 mr r7,r3
ffc125b8: 90 01 00 08 stw r0,8(r1)
ffc125bc: 7f 6a db 78 mr r10,r27
ffc125c0: 7f e3 fb 78 mr r3,r31
ffc125c4: 7e e4 bb 78 mr r4,r23
ffc125c8: 7f 25 cb 78 mr r5,r25
ffc125cc: 7f 06 c3 78 mr r6,r24
ffc125d0: 39 00 00 01 li r8,1
ffc125d4: 7f 49 d3 78 mr r9,r26
ffc125d8: 4b ff f2 bd bl ffc11894 <rtems_rfs_inode_create>
rtems_rfs_rtems_imode (mode),
1, uid, gid, &ino);
if (rc > 0)
ffc125dc: 7c 7b 1b 79 mr. r27,r3
{
rtems_rfs_rtems_unlock (fs);
ffc125e0: 7f e3 fb 78 mr r3,r31
rtems_rfs_rtems_lock (fs);
rc = rtems_rfs_inode_create (fs, parent, name, strlen (name),
rtems_rfs_rtems_imode (mode),
1, uid, gid, &ino);
if (rc > 0)
ffc125e4: 41 a1 00 20 bgt+ ffc12604 <rtems_rfs_rtems_mknod+0xac>
{
rtems_rfs_rtems_unlock (fs);
return rtems_rfs_rtems_error ("mknod: inode create", rc);
}
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
ffc125e8: 80 81 00 10 lwz r4,16(r1)
ffc125ec: 38 a1 00 14 addi r5,r1,20
ffc125f0: 38 c0 00 01 li r6,1
ffc125f4: 4b ff ed 05 bl ffc112f8 <rtems_rfs_inode_open>
if (rc > 0)
ffc125f8: 7c 7b 1b 79 mr. r27,r3
ffc125fc: 40 81 00 1c ble- ffc12618 <rtems_rfs_rtems_mknod+0xc0> <== ALWAYS TAKEN
{
rtems_rfs_rtems_unlock (fs);
ffc12600: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc12604: 4b ff f7 15 bl ffc11d18 <rtems_rfs_rtems_unlock>
return rtems_rfs_rtems_error ("mknod: inode open", rc);
ffc12608: 48 00 f3 fd bl ffc21a04 <__errno>
ffc1260c: 93 63 00 00 stw r27,0(r3)
ffc12610: 38 60 ff ff li r3,-1
ffc12614: 48 00 00 a4 b ffc126b8 <rtems_rfs_rtems_mknod+0x160>
}
if (S_ISDIR(mode) || S_ISREG(mode))
ffc12618: 57 de 04 26 rlwinm r30,r30,0,16,19
ffc1261c: 2f 9e 40 00 cmpwi cr7,r30,16384
ffc12620: 41 9e 00 68 beq- cr7,ffc12688 <rtems_rfs_rtems_mknod+0x130>
ffc12624: 6f c0 ff ff xoris r0,r30,65535
ffc12628: 2f 80 80 00 cmpwi cr7,r0,-32768
ffc1262c: 41 9e 00 5c beq- cr7,ffc12688 <rtems_rfs_rtems_mknod+0x130><== ALWAYS TAKEN
{
}
else if (S_ISCHR (mode) || S_ISBLK (mode))
ffc12630: 2f 9e 20 00 cmpwi cr7,r30,8192 <== NOT EXECUTED
ffc12634: 41 9e 00 0c beq- cr7,ffc12640 <rtems_rfs_rtems_mknod+0xe8><== NOT EXECUTED
ffc12638: 2f 9e 60 00 cmpwi cr7,r30,24576 <== NOT EXECUTED
ffc1263c: 40 9e 00 28 bne- cr7,ffc12664 <rtems_rfs_rtems_mknod+0x10c><== NOT EXECUTED
{
int major;
int minor;
rtems_filesystem_split_dev_t (dev, major, minor);
rtems_rfs_inode_set_block (&inode, 0, major);
ffc12640: 38 61 00 14 addi r3,r1,20 <== NOT EXECUTED
ffc12644: 7f 85 e3 78 mr r5,r28 <== NOT EXECUTED
ffc12648: 38 80 00 00 li r4,0 <== NOT EXECUTED
ffc1264c: 4b ff f5 cd bl ffc11c18 <rtems_rfs_inode_set_block> <== NOT EXECUTED
rtems_rfs_inode_set_block (&inode, 1, minor);
ffc12650: 38 61 00 14 addi r3,r1,20 <== NOT EXECUTED
ffc12654: 38 80 00 01 li r4,1 <== NOT EXECUTED
ffc12658: 7f a5 eb 78 mr r5,r29 <== NOT EXECUTED
ffc1265c: 4b ff f5 bd bl ffc11c18 <rtems_rfs_inode_set_block> <== NOT EXECUTED
if (S_ISDIR(mode) || S_ISREG(mode))
{
}
else if (S_ISCHR (mode) || S_ISBLK (mode))
{
ffc12660: 48 00 00 28 b ffc12688 <rtems_rfs_rtems_mknod+0x130> <== 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);
ffc12664: 38 81 00 14 addi r4,r1,20 <== NOT EXECUTED
ffc12668: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc1266c: 4b ff ee 7d bl ffc114e8 <rtems_rfs_inode_close> <== NOT EXECUTED
rtems_rfs_rtems_unlock (fs);
ffc12670: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc12674: 4b ff f6 a5 bl ffc11d18 <rtems_rfs_rtems_unlock> <== NOT EXECUTED
return rtems_rfs_rtems_error ("mknod: bad mode", EINVAL);
ffc12678: 48 00 f3 8d bl ffc21a04 <__errno> <== NOT EXECUTED
ffc1267c: 38 00 00 16 li r0,22 <== NOT EXECUTED
ffc12680: 90 03 00 00 stw r0,0(r3) <== NOT EXECUTED
ffc12684: 4b ff ff 8c b ffc12610 <rtems_rfs_rtems_mknod+0xb8> <== NOT EXECUTED
}
rc = rtems_rfs_inode_close (fs, &inode);
ffc12688: 7f e3 fb 78 mr r3,r31
ffc1268c: 38 81 00 14 addi r4,r1,20
ffc12690: 4b ff ee 59 bl ffc114e8 <rtems_rfs_inode_close>
if (rc > 0)
ffc12694: 7c 7e 1b 79 mr. r30,r3
{
rtems_rfs_rtems_unlock (fs);
ffc12698: 7f e3 fb 78 mr r3,r31
rtems_rfs_rtems_unlock (fs);
return rtems_rfs_rtems_error ("mknod: bad mode", EINVAL);
}
rc = rtems_rfs_inode_close (fs, &inode);
if (rc > 0)
ffc1269c: 40 81 00 14 ble- ffc126b0 <rtems_rfs_rtems_mknod+0x158> <== ALWAYS TAKEN
{
rtems_rfs_rtems_unlock (fs);
ffc126a0: 4b ff f6 79 bl ffc11d18 <rtems_rfs_rtems_unlock> <== NOT EXECUTED
return rtems_rfs_rtems_error ("mknod: closing inode", rc);
ffc126a4: 48 00 f3 61 bl ffc21a04 <__errno> <== NOT EXECUTED
ffc126a8: 93 c3 00 00 stw r30,0(r3) <== NOT EXECUTED
ffc126ac: 4b ff ff 64 b ffc12610 <rtems_rfs_rtems_mknod+0xb8> <== NOT EXECUTED
}
rtems_rfs_rtems_unlock (fs);
ffc126b0: 4b ff f6 69 bl ffc11d18 <rtems_rfs_rtems_unlock>
return 0;
ffc126b4: 38 60 00 00 li r3,0
}
ffc126b8: 39 61 00 68 addi r11,r1,104
ffc126bc: 4b ff 04 1c b ffc02ad8 <_restgpr_23_x>
ffc12484 <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)
{
ffc12484: 94 21 ff b8 stwu r1,-72(r1)
ffc12488: 7c 08 02 a6 mflr r0
ffc1248c: 90 01 00 4c stw r0,76(r1)
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
ffc12490: 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)
{
ffc12494: bf a1 00 3c stmw r29,60(r1)
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
ffc12498: 83 e9 00 34 lwz r31,52(r9)
rtems_rfs_ino ino = rtems_rfs_rtems_get_pathloc_ino (pathloc);
ffc1249c: 83 c3 00 00 lwz r30,0(r3)
rtems_filesystem_node_types_t type;
rtems_rfs_inode_handle inode;
uint16_t mode;
int rc;
rtems_rfs_rtems_lock (fs);
ffc124a0: 80 7f 00 7c lwz r3,124(r31)
ffc124a4: 4b ff fa a5 bl ffc11f48 <rtems_rfs_rtems_lock.isra.16>
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
ffc124a8: 7f c4 f3 78 mr r4,r30
ffc124ac: 7f e3 fb 78 mr r3,r31
ffc124b0: 38 a1 00 08 addi r5,r1,8
ffc124b4: 38 c0 00 01 li r6,1
ffc124b8: 4b ff ee 41 bl ffc112f8 <rtems_rfs_inode_open>
if (rc > 0)
ffc124bc: 7c 7e 1b 79 mr. r30,r3
ffc124c0: 40 81 00 18 ble- ffc124d8 <rtems_rfs_rtems_node_type+0x54><== ALWAYS TAKEN
{
rtems_rfs_rtems_unlock (fs);
ffc124c4: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc124c8: 4b ff f8 51 bl ffc11d18 <rtems_rfs_rtems_unlock> <== NOT EXECUTED
return rtems_rfs_rtems_error ("node_type: opening inode", rc);
ffc124cc: 48 00 f5 39 bl ffc21a04 <__errno> <== NOT EXECUTED
ffc124d0: 93 c3 00 00 stw r30,0(r3) <== NOT EXECUTED
ffc124d4: 48 00 00 6c b ffc12540 <rtems_rfs_rtems_node_type+0xbc><== 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);
ffc124d8: 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;
ffc124dc: 3b c0 00 01 li r30,1
ffc124e0: 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))
ffc124e4: 54 00 44 26 rlwinm r0,r0,8,16,19
ffc124e8: 2f 80 40 00 cmpwi cr7,r0,16384
ffc124ec: 41 9e 00 30 beq- cr7,ffc1251c <rtems_rfs_rtems_node_type+0x98>
type = RTEMS_FILESYSTEM_DIRECTORY;
else if (RTEMS_RFS_S_ISLNK (mode))
ffc124f0: 6c 09 ff ff xoris r9,r0,65535
ffc124f4: 2f 89 a0 00 cmpwi cr7,r9,-24576
type = RTEMS_FILESYSTEM_SYM_LINK;
ffc124f8: 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))
ffc124fc: 41 9e 00 20 beq- cr7,ffc1251c <rtems_rfs_rtems_node_type+0x98>
type = RTEMS_FILESYSTEM_SYM_LINK;
else if (RTEMS_RFS_S_ISBLK (mode) || RTEMS_RFS_S_ISCHR (mode))
ffc12500: 2f 80 60 00 cmpwi cr7,r0,24576
type = RTEMS_FILESYSTEM_DEVICE;
ffc12504: 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))
ffc12508: 41 9e 00 14 beq- cr7,ffc1251c <rtems_rfs_rtems_node_type+0x98><== NEVER TAKEN
ffc1250c: 2f 80 20 00 cmpwi cr7,r0,8192
type = RTEMS_FILESYSTEM_DEVICE;
else
type = RTEMS_FILESYSTEM_MEMORY_FILE;
ffc12510: 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))
ffc12514: 40 be 00 08 bne+ cr7,ffc1251c <rtems_rfs_rtems_node_type+0x98><== ALWAYS TAKEN
type = RTEMS_FILESYSTEM_DEVICE;
ffc12518: 3b c0 00 02 li r30,2 <== NOT EXECUTED
else
type = RTEMS_FILESYSTEM_MEMORY_FILE;
rc = rtems_rfs_inode_close (fs, &inode);
ffc1251c: 7f e3 fb 78 mr r3,r31
ffc12520: 38 81 00 08 addi r4,r1,8
ffc12524: 4b ff ef c5 bl ffc114e8 <rtems_rfs_inode_close>
if (rc > 0)
ffc12528: 7c 7d 1b 79 mr. r29,r3
{
rtems_rfs_rtems_unlock (fs);
ffc1252c: 7f e3 fb 78 mr r3,r31
type = RTEMS_FILESYSTEM_DEVICE;
else
type = RTEMS_FILESYSTEM_MEMORY_FILE;
rc = rtems_rfs_inode_close (fs, &inode);
if (rc > 0)
ffc12530: 40 81 00 18 ble- ffc12548 <rtems_rfs_rtems_node_type+0xc4><== ALWAYS TAKEN
{
rtems_rfs_rtems_unlock (fs);
ffc12534: 4b ff f7 e5 bl ffc11d18 <rtems_rfs_rtems_unlock> <== NOT EXECUTED
return rtems_rfs_rtems_error ("node_type: closing inode", rc);
ffc12538: 48 00 f4 cd bl ffc21a04 <__errno> <== NOT EXECUTED
ffc1253c: 93 a3 00 00 stw r29,0(r3) <== NOT EXECUTED
ffc12540: 3b c0 ff ff li r30,-1 <== NOT EXECUTED
ffc12544: 48 00 00 08 b ffc1254c <rtems_rfs_rtems_node_type+0xc8><== NOT EXECUTED
}
rtems_rfs_rtems_unlock (fs);
ffc12548: 4b ff f7 d1 bl ffc11d18 <rtems_rfs_rtems_unlock>
return type;
}
ffc1254c: 39 61 00 48 addi r11,r1,72
ffc12550: 7f c3 f3 78 mr r3,r30
ffc12554: 4b ff 05 9c b ffc02af0 <_restgpr_29_x>
ffc11f50 <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)
{
ffc11f50: 94 21 ff e0 stwu r1,-32(r1) <== NOT EXECUTED
ffc11f54: 7c 08 02 a6 mflr r0 <== NOT EXECUTED
ffc11f58: 90 01 00 24 stw r0,36(r1) <== NOT EXECUTED
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (old_loc);
ffc11f5c: 81 64 00 10 lwz r11,16(r4) <== 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)
{
ffc11f60: bf 41 00 08 stmw r26,8(r1) <== NOT EXECUTED
ffc11f64: 7c da 33 78 mr r26,r6 <== NOT EXECUTED
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (old_loc);
ffc11f68: 83 eb 00 34 lwz r31,52(r11) <== 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);
ffc11f6c: 83 83 00 00 lwz r28,0(r3) <== NOT EXECUTED
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_RENAME))
printf ("rtems-rfs: rename: ino:%" PRId32 " doff:%" PRIu32 ", new parent:%" PRId32 " new name:%s\n",
ino, doff, new_parent, new_name);
rtems_rfs_rtems_lock (fs);
ffc11f70: 80 7f 00 7c lwz r3,124(r31) <== 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);
ffc11f74: 83 65 00 00 lwz r27,0(r5) <== NOT EXECUTED
ino = rtems_rfs_rtems_get_pathloc_ino (old_loc);
ffc11f78: 83 c4 00 00 lwz r30,0(r4) <== NOT EXECUTED
doff = rtems_rfs_rtems_get_pathloc_doff (old_loc);
ffc11f7c: 83 a4 00 04 lwz r29,4(r4) <== NOT EXECUTED
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_RENAME))
printf ("rtems-rfs: rename: ino:%" PRId32 " doff:%" PRIu32 ", new parent:%" PRId32 " new name:%s\n",
ino, doff, new_parent, new_name);
rtems_rfs_rtems_lock (fs);
ffc11f80: 4b ff ff c9 bl ffc11f48 <rtems_rfs_rtems_lock.isra.16><== 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);
ffc11f84: 7f 43 d3 78 mr r3,r26 <== NOT EXECUTED
ffc11f88: 48 01 18 e5 bl ffc2386c <strlen> <== NOT EXECUTED
ffc11f8c: 7f 66 db 78 mr r6,r27 <== NOT EXECUTED
ffc11f90: 7c 65 1b 78 mr r5,r3 <== NOT EXECUTED
ffc11f94: 7f 44 d3 78 mr r4,r26 <== NOT EXECUTED
ffc11f98: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc11f9c: 7f c7 f3 78 mr r7,r30 <== NOT EXECUTED
ffc11fa0: 39 00 00 01 li r8,1 <== NOT EXECUTED
ffc11fa4: 48 00 d2 2d bl ffc1f1d0 <rtems_rfs_link> <== NOT EXECUTED
if (rc)
ffc11fa8: 7c 7b 1b 79 mr. r27,r3 <== NOT EXECUTED
{
rtems_rfs_rtems_unlock (fs);
ffc11fac: 7f e3 fb 78 mr r3,r31 <== 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);
if (rc)
ffc11fb0: 41 82 00 14 beq- ffc11fc4 <rtems_rfs_rtems_rename+0x74> <== NOT EXECUTED
{
rtems_rfs_rtems_unlock (fs);
ffc11fb4: 4b ff fd 65 bl ffc11d18 <rtems_rfs_rtems_unlock> <== NOT EXECUTED
return rtems_rfs_rtems_error ("rename: linking", rc);
ffc11fb8: 48 00 fa 4d bl ffc21a04 <__errno> <== NOT EXECUTED
ffc11fbc: 93 63 00 00 stw r27,0(r3) <== NOT EXECUTED
ffc11fc0: 48 00 00 30 b ffc11ff0 <rtems_rfs_rtems_rename+0xa0> <== 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,
ffc11fc4: 7f c5 f3 78 mr r5,r30 <== NOT EXECUTED
ffc11fc8: 7f 84 e3 78 mr r4,r28 <== NOT EXECUTED
ffc11fcc: 7f a6 eb 78 mr r6,r29 <== NOT EXECUTED
ffc11fd0: 38 e0 00 02 li r7,2 <== NOT EXECUTED
ffc11fd4: 48 00 d3 a9 bl ffc1f37c <rtems_rfs_unlink> <== NOT EXECUTED
rtems_rfs_unlink_dir_allowed);
if (rc)
ffc11fd8: 7c 7e 1b 79 mr. r30,r3 <== NOT EXECUTED
{
rtems_rfs_rtems_unlock (fs);
ffc11fdc: 7f e3 fb 78 mr r3,r31 <== 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,
rtems_rfs_unlink_dir_allowed);
if (rc)
ffc11fe0: 41 82 00 18 beq- ffc11ff8 <rtems_rfs_rtems_rename+0xa8> <== NOT EXECUTED
{
rtems_rfs_rtems_unlock (fs);
ffc11fe4: 4b ff fd 35 bl ffc11d18 <rtems_rfs_rtems_unlock> <== NOT EXECUTED
return rtems_rfs_rtems_error ("rename: unlinking", rc);
ffc11fe8: 48 00 fa 1d bl ffc21a04 <__errno> <== NOT EXECUTED
ffc11fec: 93 c3 00 00 stw r30,0(r3) <== NOT EXECUTED
ffc11ff0: 38 60 ff ff li r3,-1 <== NOT EXECUTED
ffc11ff4: 48 00 00 0c b ffc12000 <rtems_rfs_rtems_rename+0xb0> <== NOT EXECUTED
}
rtems_rfs_rtems_unlock (fs);
ffc11ff8: 4b ff fd 21 bl ffc11d18 <rtems_rfs_rtems_unlock> <== NOT EXECUTED
return 0;
ffc11ffc: 38 60 00 00 li r3,0 <== NOT EXECUTED
}
ffc12000: 39 61 00 20 addi r11,r1,32 <== NOT EXECUTED
ffc12004: 4b ff 0a e0 b ffc02ae4 <_restgpr_26_x> <== NOT EXECUTED
ffc120fc <rtems_rfs_rtems_rmnod>:
* @return int
*/
int
rtems_rfs_rtems_rmnod (rtems_filesystem_location_info_t* parent_pathloc,
rtems_filesystem_location_info_t* pathloc)
{
ffc120fc: 94 21 ff e8 stwu r1,-24(r1) <== NOT EXECUTED
ffc12100: 7c 08 02 a6 mflr r0 <== NOT EXECUTED
ffc12104: 90 01 00 1c stw r0,28(r1) <== NOT EXECUTED
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
ffc12108: 81 64 00 10 lwz r11,16(r4) <== NOT EXECUTED
* @return int
*/
int
rtems_rfs_rtems_rmnod (rtems_filesystem_location_info_t* parent_pathloc,
rtems_filesystem_location_info_t* pathloc)
{
ffc1210c: bf 81 00 08 stmw r28,8(r1) <== NOT EXECUTED
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
ffc12110: 83 eb 00 34 lwz r31,52(r11) <== NOT EXECUTED
rtems_rfs_ino parent = rtems_rfs_rtems_get_pathloc_ino (parent_pathloc);
rtems_rfs_ino ino = rtems_rfs_rtems_get_pathloc_ino (pathloc);
uint32_t doff = rtems_rfs_rtems_get_pathloc_doff (pathloc);
ffc12114: 83 c4 00 04 lwz r30,4(r4) <== 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);
ffc12118: 83 83 00 00 lwz r28,0(r3) <== NOT EXECUTED
rtems_rfs_ino ino = rtems_rfs_rtems_get_pathloc_ino (pathloc);
ffc1211c: 83 a4 00 00 lwz r29,0(r4) <== NOT EXECUTED
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_RMNOD))
printf ("rtems-rfs: rmnod: parent:%" PRId32 " doff:%" PRIu32 ", ino:%" PRId32 "\n",
parent, doff, ino);
rtems_rfs_rtems_lock (fs);
ffc12120: 80 7f 00 7c lwz r3,124(r31) <== NOT EXECUTED
ffc12124: 4b ff fe 25 bl ffc11f48 <rtems_rfs_rtems_lock.isra.16><== NOT EXECUTED
rc = rtems_rfs_unlink (fs, parent, ino, doff, rtems_rfs_unlink_dir_denied);
ffc12128: 7f c6 f3 78 mr r6,r30 <== NOT EXECUTED
ffc1212c: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc12130: 7f 84 e3 78 mr r4,r28 <== NOT EXECUTED
ffc12134: 7f a5 eb 78 mr r5,r29 <== NOT EXECUTED
ffc12138: 38 e0 00 00 li r7,0 <== NOT EXECUTED
ffc1213c: 48 00 d2 41 bl ffc1f37c <rtems_rfs_unlink> <== NOT EXECUTED
if (rc)
ffc12140: 7c 7e 1b 79 mr. r30,r3 <== NOT EXECUTED
{
rtems_rfs_rtems_unlock (fs);
ffc12144: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
parent, doff, ino);
rtems_rfs_rtems_lock (fs);
rc = rtems_rfs_unlink (fs, parent, ino, doff, rtems_rfs_unlink_dir_denied);
if (rc)
ffc12148: 41 82 00 18 beq- ffc12160 <rtems_rfs_rtems_rmnod+0x64> <== NOT EXECUTED
{
rtems_rfs_rtems_unlock (fs);
ffc1214c: 4b ff fb cd bl ffc11d18 <rtems_rfs_rtems_unlock> <== NOT EXECUTED
return rtems_rfs_rtems_error ("rmnod: unlinking", rc);
ffc12150: 48 00 f8 b5 bl ffc21a04 <__errno> <== NOT EXECUTED
ffc12154: 93 c3 00 00 stw r30,0(r3) <== NOT EXECUTED
ffc12158: 38 60 ff ff li r3,-1 <== NOT EXECUTED
ffc1215c: 48 00 00 0c b ffc12168 <rtems_rfs_rtems_rmnod+0x6c> <== NOT EXECUTED
}
rtems_rfs_rtems_unlock (fs);
ffc12160: 4b ff fb b9 bl ffc11d18 <rtems_rfs_rtems_unlock> <== NOT EXECUTED
return 0;
ffc12164: 38 60 00 00 li r3,0 <== NOT EXECUTED
}
ffc12168: 39 61 00 18 addi r11,r1,24 <== NOT EXECUTED
ffc1216c: 4b ff 09 80 b ffc02aec <_restgpr_28_x> <== NOT EXECUTED
ffc13240 <rtems_rfs_rtems_set_handlers>:
*/
bool
rtems_rfs_rtems_set_handlers (rtems_filesystem_location_info_t* loc,
rtems_rfs_inode_handle* inode)
{
ffc13240: 94 21 ff f8 stwu r1,-8(r1)
ffc13244: 7c 08 02 a6 mflr r0
ffc13248: 90 01 00 0c stw r0,12(r1)
{
/*
* Mapping matches RTEMS so no need to change.
*/
return imode;
}
ffc1324c: 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);
ffc13250: 88 89 00 02 lbz r4,2(r9)
ffc13254: 88 09 00 03 lbz r0,3(r9)
ffc13258: 54 84 40 2e rlwinm r4,r4,8,0,23
ffc1325c: 7c 84 03 78 or r4,r4,r0
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;
ffc13260: 38 00 00 00 li r0,0
ffc13264: 90 03 00 08 stw r0,8(r3)
if (RTEMS_RFS_S_ISDIR (mode))
ffc13268: 54 80 04 26 rlwinm r0,r4,0,16,19
ffc1326c: 2f 80 40 00 cmpwi cr7,r0,16384
ffc13270: 40 be 00 10 bne+ cr7,ffc13280 <rtems_rfs_rtems_set_handlers+0x40>
loc->handlers = rtems_rfs_rtems_handlers (dir);
ffc13274: 3d 20 ff c3 lis r9,-61
ffc13278: 38 09 56 bc addi r0,r9,22204
ffc1327c: 48 00 00 1c b ffc13298 <rtems_rfs_rtems_set_handlers+0x58>
else if (RTEMS_RFS_S_ISCHR (mode) || RTEMS_RFS_S_ISBLK(mode))
ffc13280: 2f 80 20 00 cmpwi cr7,r0,8192
ffc13284: 41 9e 00 0c beq- cr7,ffc13290 <rtems_rfs_rtems_set_handlers+0x50><== NEVER TAKEN
ffc13288: 2f 80 60 00 cmpwi cr7,r0,24576
ffc1328c: 40 be 00 18 bne+ cr7,ffc132a4 <rtems_rfs_rtems_set_handlers+0x64><== ALWAYS TAKEN
loc->handlers = rtems_rfs_rtems_handlers (device);
ffc13290: 3d 20 ff c3 lis r9,-61 <== NOT EXECUTED
ffc13294: 38 09 56 84 addi r0,r9,22148 <== NOT EXECUTED
ffc13298: 90 03 00 08 stw r0,8(r3)
else
{
printf ("rtems-rfs: mode type unknown: %04x\n", mode);
return false;
}
return true;
ffc1329c: 38 60 00 01 li r3,1
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);
ffc132a0: 48 00 00 48 b ffc132e8 <rtems_rfs_rtems_set_handlers+0xa8>
else if (RTEMS_RFS_S_ISLNK (mode))
ffc132a4: 6c 09 ff ff xoris r9,r0,65535
ffc132a8: 2f 89 a0 00 cmpwi cr7,r9,-24576
ffc132ac: 40 9e 00 10 bne- cr7,ffc132bc <rtems_rfs_rtems_set_handlers+0x7c>
loc->handlers = rtems_rfs_rtems_handlers (link);
ffc132b0: 3d 20 ff c3 lis r9,-61
ffc132b4: 38 09 35 fc addi r0,r9,13820
ffc132b8: 4b ff ff e0 b ffc13298 <rtems_rfs_rtems_set_handlers+0x58>
else if (RTEMS_RFS_S_ISREG (mode))
ffc132bc: 6c 09 ff ff xoris r9,r0,65535
ffc132c0: 2f 89 80 00 cmpwi cr7,r9,-32768
ffc132c4: 40 9e 00 10 bne- cr7,ffc132d4 <rtems_rfs_rtems_set_handlers+0x94><== NEVER TAKEN
loc->handlers = rtems_rfs_rtems_handlers (file);
ffc132c8: 3d 20 ff c3 lis r9,-61
ffc132cc: 38 09 56 f4 addi r0,r9,22260
ffc132d0: 4b ff ff c8 b ffc13298 <rtems_rfs_rtems_set_handlers+0x58>
else
{
printf ("rtems-rfs: mode type unknown: %04x\n", mode);
ffc132d4: 3c 60 ff c3 lis r3,-61 <== NOT EXECUTED
ffc132d8: 38 63 36 7f addi r3,r3,13951 <== NOT EXECUTED
ffc132dc: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc132e0: 48 00 f8 09 bl ffc22ae8 <printf> <== NOT EXECUTED
return false;
ffc132e4: 38 60 00 00 li r3,0 <== NOT EXECUTED
}
return true;
}
ffc132e8: 80 01 00 0c lwz r0,12(r1)
ffc132ec: 38 21 00 08 addi r1,r1,8
ffc132f0: 7c 08 03 a6 mtlr r0
ffc132f4: 4e 80 00 20 blr
ffc11d7c <rtems_rfs_rtems_shutdown>:
/**
* Shutdown the file system.
*/
int
rtems_rfs_rtems_shutdown (rtems_filesystem_mount_table_entry_t* mt_entry)
{
ffc11d7c: 94 21 ff f0 stwu r1,-16(r1)
ffc11d80: 7c 08 02 a6 mflr r0
ffc11d84: 90 01 00 14 stw r0,20(r1)
rtems_rfs_file_system* fs = mt_entry->fs_info;
ffc11d88: 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)
{
ffc11d8c: bf c1 00 08 stmw 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);
ffc11d90: 83 c3 00 7c lwz r30,124(r3)
rc = rtems_rfs_fs_close(fs);
ffc11d94: 48 00 d3 c1 bl ffc1f154 <rtems_rfs_fs_close>
ffc11d98: 7c 7f 1b 78 mr r31,r3
rtems_rfs_mutex_destroy (&rtems->access);
ffc11d9c: 7f c3 f3 78 mr r3,r30
ffc11da0: 48 00 de 65 bl ffc1fc04 <rtems_rfs_mutex_destroy>
free (rtems);
ffc11da4: 7f c3 f3 78 mr r3,r30
ffc11da8: 4b ff 5b 41 bl ffc078e8 <free>
return rtems_rfs_rtems_error ("shutdown: close", rc);
ffc11dac: 48 00 fc 59 bl ffc21a04 <__errno>
ffc11db0: 2f 9f 00 00 cmpwi cr7,r31,0
ffc11db4: 93 e3 00 00 stw r31,0(r3)
ffc11db8: 38 60 ff ff li r3,-1
ffc11dbc: 40 9e 00 08 bne- cr7,ffc11dc4 <rtems_rfs_rtems_shutdown+0x48><== NEVER TAKEN
ffc11dc0: 38 60 00 00 li r3,0
}
ffc11dc4: 39 61 00 10 addi r11,r1,16
ffc11dc8: 4b ff 0d 2c b ffc02af4 <_restgpr_30_x>
ffc11c6c <rtems_rfs_rtems_statvfs>:
* @return int
*/
static int
rtems_rfs_rtems_statvfs (rtems_filesystem_location_info_t* pathloc,
struct statvfs* sb)
{
ffc11c6c: 94 21 ff e0 stwu r1,-32(r1) <== NOT EXECUTED
ffc11c70: 7c 08 02 a6 mflr r0 <== NOT EXECUTED
ffc11c74: 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);
ffc11c78: 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);
ffc11c7c: 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)
{
ffc11c80: bf c1 00 18 stmw r30,24(r1) <== NOT EXECUTED
ffc11c84: 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);
ffc11c88: 38 81 00 0c addi r4,r1,12 <== 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);
ffc11c8c: 83 c9 00 34 lwz r30,52(r9) <== NOT EXECUTED
size_t blocks;
size_t inodes;
rtems_rfs_group_usage (fs, &blocks, &inodes);
ffc11c90: 7f c3 f3 78 mr r3,r30 <== NOT EXECUTED
ffc11c94: 4b ff f4 b5 bl ffc11148 <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);
ffc11c98: 81 3e 00 0c lwz r9,12(r30) <== NOT EXECUTED
size_t blocks;
size_t inodes;
rtems_rfs_group_usage (fs, &blocks, &inodes);
sb->f_bsize = rtems_rfs_fs_block_size (fs);
ffc11c9c: 80 1e 00 08 lwz r0,8(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;
}
ffc11ca0: 38 60 00 00 li r3,0 <== 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;
ffc11ca4: 81 7e 00 04 lwz r11,4(r30) <== NOT EXECUTED
size_t blocks;
size_t inodes;
rtems_rfs_group_usage (fs, &blocks, &inodes);
sb->f_bsize = rtems_rfs_fs_block_size (fs);
ffc11ca8: 90 1f 00 00 stw r0,0(r31) <== NOT EXECUTED
sb->f_frsize = rtems_rfs_fs_media_block_size (fs);
ffc11cac: 80 09 00 24 lwz r0,36(r9) <== NOT EXECUTED
ffc11cb0: 90 1f 00 04 stw r0,4(r31) <== NOT EXECUTED
sb->f_blocks = rtems_rfs_fs_media_blocks (fs);
ffc11cb4: 80 09 00 1c lwz r0,28(r9) <== NOT EXECUTED
sb->f_bfree = rtems_rfs_fs_blocks (fs) - blocks;
ffc11cb8: 81 21 00 0c lwz r9,12(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);
ffc11cbc: 90 1f 00 0c stw r0,12(r31) <== NOT EXECUTED
ffc11cc0: 38 00 00 00 li r0,0 <== NOT EXECUTED
sb->f_bfree = rtems_rfs_fs_blocks (fs) - blocks;
ffc11cc4: 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);
ffc11cc8: 90 1f 00 08 stw r0,8(r31) <== 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;
}
ffc11ccc: 39 61 00 20 addi r11,r1,32 <== 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;
ffc11cd0: 90 1f 00 10 stw r0,16(r31) <== NOT EXECUTED
ffc11cd4: 91 3f 00 14 stw r9,20(r31) <== NOT EXECUTED
sb->f_bavail = sb->f_bfree;
ffc11cd8: 90 1f 00 18 stw r0,24(r31) <== NOT EXECUTED
ffc11cdc: 91 3f 00 1c stw r9,28(r31) <== NOT EXECUTED
sb->f_files = rtems_rfs_fs_inodes (fs);
ffc11ce0: 80 1e 00 10 lwz r0,16(r30) <== NOT EXECUTED
sb->f_ffree = rtems_rfs_fs_inodes (fs) - inodes;
ffc11ce4: 81 21 00 08 lwz r9,8(r1) <== NOT EXECUTED
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;
sb->f_bavail = sb->f_bfree;
sb->f_files = rtems_rfs_fs_inodes (fs);
ffc11ce8: 90 1f 00 20 stw r0,32(r31) <== NOT EXECUTED
sb->f_ffree = rtems_rfs_fs_inodes (fs) - inodes;
ffc11cec: 7c 09 00 50 subf r0,r9,r0 <== NOT EXECUTED
ffc11cf0: 90 1f 00 24 stw r0,36(r31) <== NOT EXECUTED
sb->f_favail = sb->f_ffree;
ffc11cf4: 90 1f 00 28 stw r0,40(r31) <== NOT EXECUTED
sb->f_fsid = RTEMS_RFS_SB_MAGIC;
ffc11cf8: 3c 00 28 09 lis r0,10249 <== NOT EXECUTED
ffc11cfc: 60 00 20 01 ori r0,r0,8193 <== NOT EXECUTED
ffc11d00: 90 1f 00 2c stw r0,44(r31) <== NOT EXECUTED
sb->f_flag = rtems_rfs_fs_flags (fs);
ffc11d04: 80 1e 00 00 lwz r0,0(r30) <== NOT EXECUTED
ffc11d08: 90 1f 00 30 stw r0,48(r31) <== NOT EXECUTED
sb->f_namemax = rtems_rfs_fs_max_name (fs);
ffc11d0c: 80 1e 00 18 lwz r0,24(r30) <== NOT EXECUTED
ffc11d10: 90 1f 00 34 stw r0,52(r31) <== NOT EXECUTED
return 0;
}
ffc11d14: 4b ff 0d e0 b ffc02af4 <_restgpr_30_x> <== NOT EXECUTED
ffc121e4 <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)
{
ffc121e4: 94 21 ff d8 stwu r1,-40(r1)
ffc121e8: 7c 08 02 a6 mflr r0
ffc121ec: 90 01 00 2c stw r0,44(r1)
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (parent_loc);
ffc121f0: 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)
{
ffc121f4: bf 21 00 0c stmw r25,12(r1)
ffc121f8: 7c 9b 23 78 mr r27,r4
ffc121fc: 7c b9 2b 78 mr r25,r5
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (parent_loc);
ffc12200: 83 e9 00 34 lwz r31,52(r9)
rtems_rfs_ino parent = rtems_rfs_rtems_get_pathloc_ino (parent_loc);
ffc12204: 83 c3 00 00 lwz r30,0(r3)
uid_t uid;
gid_t gid;
int rc;
#if defined(RTEMS_POSIX_API)
uid = geteuid ();
ffc12208: 48 00 54 a1 bl ffc176a8 <geteuid>
ffc1220c: 7c 7c 1b 78 mr r28,r3
gid = getegid ();
ffc12210: 48 00 54 89 bl ffc17698 <getegid>
ffc12214: 7c 7d 1b 78 mr r29,r3
#else
uid = 0;
gid = 0;
#endif
rtems_rfs_rtems_lock (fs);
ffc12218: 80 7f 00 7c lwz r3,124(r31)
ffc1221c: 4b ff fd 2d bl ffc11f48 <rtems_rfs_rtems_lock.isra.16>
rc = rtems_rfs_symlink (fs, node_name, strlen (node_name),
ffc12220: 7f 23 cb 78 mr r3,r25
ffc12224: 48 01 16 49 bl ffc2386c <strlen>
ffc12228: 7c 7a 1b 78 mr r26,r3
link_name, strlen (link_name),
ffc1222c: 7f 63 db 78 mr r3,r27
ffc12230: 48 01 16 3d bl ffc2386c <strlen>
gid = 0;
#endif
rtems_rfs_rtems_lock (fs);
rc = rtems_rfs_symlink (fs, node_name, strlen (node_name),
ffc12234: 7f ca f3 78 mr r10,r30
link_name, strlen (link_name),
ffc12238: 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),
ffc1223c: 7f 24 cb 78 mr r4,r25
ffc12240: 7f e3 fb 78 mr r3,r31
ffc12244: 7f 45 d3 78 mr r5,r26
ffc12248: 7f 66 db 78 mr r6,r27
ffc1224c: 7f 88 e3 78 mr r8,r28
ffc12250: 7f a9 eb 78 mr r9,r29
ffc12254: 48 00 d4 e9 bl ffc1f73c <rtems_rfs_symlink>
link_name, strlen (link_name),
uid, gid, parent);
if (rc)
ffc12258: 7c 7e 1b 79 mr. r30,r3
{
rtems_rfs_rtems_unlock (fs);
ffc1225c: 7f e3 fb 78 mr r3,r31
rtems_rfs_rtems_lock (fs);
rc = rtems_rfs_symlink (fs, node_name, strlen (node_name),
link_name, strlen (link_name),
uid, gid, parent);
if (rc)
ffc12260: 41 82 00 18 beq- ffc12278 <rtems_rfs_rtems_symlink+0x94><== ALWAYS TAKEN
{
rtems_rfs_rtems_unlock (fs);
ffc12264: 4b ff fa b5 bl ffc11d18 <rtems_rfs_rtems_unlock> <== NOT EXECUTED
return rtems_rfs_rtems_error ("symlink: linking", rc);
ffc12268: 48 00 f7 9d bl ffc21a04 <__errno> <== NOT EXECUTED
ffc1226c: 93 c3 00 00 stw r30,0(r3) <== NOT EXECUTED
ffc12270: 38 60 ff ff li r3,-1 <== NOT EXECUTED
ffc12274: 48 00 00 0c b ffc12280 <rtems_rfs_rtems_symlink+0x9c><== NOT EXECUTED
}
rtems_rfs_rtems_unlock (fs);
ffc12278: 4b ff fa a1 bl ffc11d18 <rtems_rfs_rtems_unlock>
return 0;
ffc1227c: 38 60 00 00 li r3,0
}
ffc12280: 39 61 00 28 addi r11,r1,40
ffc12284: 4b ff 08 5c b ffc02ae0 <_restgpr_25_x>
ffc12008 <rtems_rfs_rtems_unlink>:
*/
static int
rtems_rfs_rtems_unlink (rtems_filesystem_location_info_t* parent_loc,
rtems_filesystem_location_info_t* loc)
{
ffc12008: 94 21 ff e8 stwu r1,-24(r1)
ffc1200c: 7c 08 02 a6 mflr r0
ffc12010: 90 01 00 1c stw r0,28(r1)
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (parent_loc);
ffc12014: 81 23 00 10 lwz r9,16(r3)
*/
static int
rtems_rfs_rtems_unlink (rtems_filesystem_location_info_t* parent_loc,
rtems_filesystem_location_info_t* loc)
{
ffc12018: bf 81 00 08 stmw r28,8(r1)
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (parent_loc);
ffc1201c: 83 e9 00 34 lwz r31,52(r9)
rtems_rfs_ino parent = rtems_rfs_rtems_get_pathloc_ino (parent_loc);
rtems_rfs_ino ino = rtems_rfs_rtems_get_pathloc_ino (loc);
uint32_t doff = rtems_rfs_rtems_get_pathloc_doff (loc);
ffc12020: 83 c4 00 04 lwz r30,4(r4)
static int
rtems_rfs_rtems_unlink (rtems_filesystem_location_info_t* parent_loc,
rtems_filesystem_location_info_t* loc)
{
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (parent_loc);
rtems_rfs_ino parent = rtems_rfs_rtems_get_pathloc_ino (parent_loc);
ffc12024: 83 83 00 00 lwz r28,0(r3)
rtems_rfs_ino ino = rtems_rfs_rtems_get_pathloc_ino (loc);
ffc12028: 83 a4 00 00 lwz r29,0(r4)
uint32_t doff = rtems_rfs_rtems_get_pathloc_doff (loc);
int rc;
rtems_rfs_rtems_lock (fs);
ffc1202c: 80 7f 00 7c lwz r3,124(r31)
ffc12030: 4b ff ff 19 bl ffc11f48 <rtems_rfs_rtems_lock.isra.16>
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);
ffc12034: 7f c6 f3 78 mr r6,r30
ffc12038: 7f e3 fb 78 mr r3,r31
ffc1203c: 7f 84 e3 78 mr r4,r28
ffc12040: 7f a5 eb 78 mr r5,r29
ffc12044: 38 e0 00 00 li r7,0
ffc12048: 48 00 d3 35 bl ffc1f37c <rtems_rfs_unlink>
if (rc)
ffc1204c: 7c 7e 1b 79 mr. r30,r3
{
rtems_rfs_rtems_unlock (fs);
ffc12050: 7f e3 fb 78 mr r3,r31
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);
if (rc)
ffc12054: 41 82 00 18 beq- ffc1206c <rtems_rfs_rtems_unlink+0x64> <== ALWAYS TAKEN
{
rtems_rfs_rtems_unlock (fs);
ffc12058: 4b ff fc c1 bl ffc11d18 <rtems_rfs_rtems_unlock> <== NOT EXECUTED
return rtems_rfs_rtems_error ("unlink: unlink inode", rc);
ffc1205c: 48 00 f9 a9 bl ffc21a04 <__errno> <== NOT EXECUTED
ffc12060: 93 c3 00 00 stw r30,0(r3) <== NOT EXECUTED
ffc12064: 38 60 ff ff li r3,-1 <== NOT EXECUTED
ffc12068: 48 00 00 0c b ffc12074 <rtems_rfs_rtems_unlink+0x6c> <== NOT EXECUTED
}
rtems_rfs_rtems_unlock (fs);
ffc1206c: 4b ff fc ad bl ffc11d18 <rtems_rfs_rtems_unlock>
return 0;
ffc12070: 38 60 00 00 li r3,0
}
ffc12074: 39 61 00 18 addi r11,r1,24
ffc12078: 4b ff 0a 74 b ffc02aec <_restgpr_28_x>
ffc11d18 <rtems_rfs_rtems_unlock>:
/**
* Unlock the RFS file system.
*/
static inline void
rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)
{
ffc11d18: 7c 2b 0b 78 mr r11,r1
ffc11d1c: 7c 08 02 a6 mflr r0
ffc11d20: 94 21 ff f0 stwu r1,-16(r1)
ffc11d24: 90 01 00 14 stw r0,20(r1)
ffc11d28: 4b ff 0d 85 bl ffc02aac <_savegpr_31>
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
ffc11d2c: 83 e3 00 7c lwz r31,124(r3)
rtems_rfs_buffers_release (fs);
ffc11d30: 48 00 a9 41 bl ffc1c670 <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);
ffc11d34: 80 7f 00 00 lwz r3,0(r31)
ffc11d38: 4b ff a0 e5 bl ffc0be1c <rtems_semaphore_release>
if (sc != RTEMS_SUCCESSFUL)
ffc11d3c: 7c 7f 1b 79 mr. r31,r3
ffc11d40: 41 a2 00 34 beq+ ffc11d74 <rtems_rfs_rtems_unlock+0x5c> <== ALWAYS TAKEN
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
ffc11d44: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc11d48: 38 80 00 04 li r4,4 <== NOT EXECUTED
ffc11d4c: 48 00 15 b9 bl ffc13304 <rtems_rfs_trace> <== NOT EXECUTED
ffc11d50: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc11d54: 41 be 00 20 beq+ cr7,ffc11d74 <rtems_rfs_rtems_unlock+0x5c><== NOT EXECUTED
printf ("rtems-rfs: mutex: release failed: %s\n",
ffc11d58: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc11d5c: 48 00 55 61 bl ffc172bc <rtems_status_text> <== NOT EXECUTED
ffc11d60: 7c 64 1b 78 mr r4,r3 <== NOT EXECUTED
ffc11d64: 3c 60 ff c3 lis r3,-61 <== NOT EXECUTED
ffc11d68: 38 63 36 34 addi r3,r3,13876 <== NOT EXECUTED
ffc11d6c: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc11d70: 48 01 0d 79 bl ffc22ae8 <printf> <== NOT EXECUTED
rtems_rfs_mutex_unlock (&rtems->access);
}
ffc11d74: 39 61 00 10 addi r11,r1,16
ffc11d78: 4b ff 0d 80 b ffc02af8 <_restgpr_31_x>
ffc12288 <rtems_rfs_rtems_utime>:
static int
rtems_rfs_rtems_utime(rtems_filesystem_location_info_t* pathloc,
time_t atime,
time_t mtime)
{
ffc12288: 94 21 ff b8 stwu r1,-72(r1) <== NOT EXECUTED
ffc1228c: 7c 08 02 a6 mflr r0 <== NOT EXECUTED
ffc12290: 90 01 00 4c stw r0,76(r1) <== NOT EXECUTED
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
ffc12294: 81 23 00 10 lwz r9,16(r3) <== NOT EXECUTED
static int
rtems_rfs_rtems_utime(rtems_filesystem_location_info_t* pathloc,
time_t atime,
time_t mtime)
{
ffc12298: bf 81 00 38 stmw r28,56(r1) <== NOT EXECUTED
ffc1229c: 7c 9d 23 78 mr r29,r4 <== NOT EXECUTED
ffc122a0: 7c be 2b 78 mr r30,r5 <== NOT EXECUTED
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
ffc122a4: 83 e9 00 34 lwz r31,52(r9) <== NOT EXECUTED
rtems_rfs_ino ino = rtems_rfs_rtems_get_pathloc_ino (pathloc);
ffc122a8: 83 83 00 00 lwz r28,0(r3) <== NOT EXECUTED
rtems_rfs_inode_handle inode;
int rc;
rtems_rfs_rtems_lock (fs);
ffc122ac: 80 7f 00 7c lwz r3,124(r31) <== NOT EXECUTED
ffc122b0: 4b ff fc 99 bl ffc11f48 <rtems_rfs_rtems_lock.isra.16><== NOT EXECUTED
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
ffc122b4: 7f 84 e3 78 mr r4,r28 <== NOT EXECUTED
ffc122b8: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc122bc: 38 a1 00 08 addi r5,r1,8 <== NOT EXECUTED
ffc122c0: 38 c0 00 01 li r6,1 <== NOT EXECUTED
ffc122c4: 4b ff f0 35 bl ffc112f8 <rtems_rfs_inode_open> <== NOT EXECUTED
if (rc)
ffc122c8: 7c 7c 1b 79 mr. r28,r3 <== NOT EXECUTED
ffc122cc: 41 82 00 18 beq- ffc122e4 <rtems_rfs_rtems_utime+0x5c> <== NOT EXECUTED
{
rtems_rfs_rtems_unlock (fs);
ffc122d0: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc122d4: 4b ff fa 45 bl ffc11d18 <rtems_rfs_rtems_unlock> <== NOT EXECUTED
return rtems_rfs_rtems_error ("utime: read inode", rc);
ffc122d8: 48 00 f7 2d bl ffc21a04 <__errno> <== NOT EXECUTED
ffc122dc: 93 83 00 00 stw r28,0(r3) <== NOT EXECUTED
ffc122e0: 48 00 00 6c b ffc1234c <rtems_rfs_rtems_utime+0xc4> <== 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);
ffc122e4: 81 21 00 14 lwz r9,20(r1) <== NOT EXECUTED
ffc122e8: 57 a0 46 3e rlwinm r0,r29,8,24,31 <== NOT EXECUTED
}
rtems_rfs_inode_set_atime (&inode, atime);
rtems_rfs_inode_set_mtime (&inode, mtime);
rc = rtems_rfs_inode_close (fs, &inode);
ffc122ec: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc122f0: 98 09 00 10 stb r0,16(r9) <== NOT EXECUTED
ffc122f4: 57 a0 84 3e rlwinm r0,r29,16,16,31 <== NOT EXECUTED
ffc122f8: 38 81 00 08 addi r4,r1,8 <== NOT EXECUTED
ffc122fc: 98 09 00 11 stb r0,17(r9) <== NOT EXECUTED
ffc12300: 57 a0 c2 3e rlwinm r0,r29,24,8,31 <== NOT EXECUTED
ffc12304: 98 09 00 12 stb r0,18(r9) <== NOT EXECUTED
rtems_rfs_buffer_mark_dirty (&handle->buffer);
ffc12308: 38 00 00 01 li r0,1 <== NOT EXECUTED
ffc1230c: 98 01 00 18 stb r0,24(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);
ffc12310: 57 c0 46 3e rlwinm r0,r30,8,24,31 <== NOT EXECUTED
ffc12314: 98 09 00 14 stb r0,20(r9) <== NOT EXECUTED
ffc12318: 57 c0 84 3e rlwinm r0,r30,16,16,31 <== NOT EXECUTED
ffc1231c: 98 09 00 15 stb r0,21(r9) <== NOT EXECUTED
ffc12320: 57 c0 c2 3e rlwinm r0,r30,24,8,31 <== NOT EXECUTED
ffc12324: 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);
ffc12328: 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);
ffc1232c: 98 09 00 16 stb r0,22(r9) <== NOT EXECUTED
ffc12330: 4b ff f1 b9 bl ffc114e8 <rtems_rfs_inode_close> <== NOT EXECUTED
if (rc)
ffc12334: 7c 7e 1b 79 mr. r30,r3 <== NOT EXECUTED
{
rtems_rfs_rtems_unlock (fs);
ffc12338: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
rtems_rfs_inode_set_atime (&inode, atime);
rtems_rfs_inode_set_mtime (&inode, mtime);
rc = rtems_rfs_inode_close (fs, &inode);
if (rc)
ffc1233c: 41 82 00 18 beq- ffc12354 <rtems_rfs_rtems_utime+0xcc> <== NOT EXECUTED
{
rtems_rfs_rtems_unlock (fs);
ffc12340: 4b ff f9 d9 bl ffc11d18 <rtems_rfs_rtems_unlock> <== NOT EXECUTED
return rtems_rfs_rtems_error ("utime: closing inode", rc);
ffc12344: 48 00 f6 c1 bl ffc21a04 <__errno> <== NOT EXECUTED
ffc12348: 93 c3 00 00 stw r30,0(r3) <== NOT EXECUTED
ffc1234c: 38 60 ff ff li r3,-1 <== NOT EXECUTED
ffc12350: 48 00 00 0c b ffc1235c <rtems_rfs_rtems_utime+0xd4> <== NOT EXECUTED
}
rtems_rfs_rtems_unlock (fs);
ffc12354: 4b ff f9 c5 bl ffc11d18 <rtems_rfs_rtems_unlock> <== NOT EXECUTED
return 0;
ffc12358: 38 60 00 00 li r3,0 <== NOT EXECUTED
}
ffc1235c: 39 61 00 48 addi r11,r1,72 <== NOT EXECUTED
ffc12360: 4b ff 07 8c b ffc02aec <_restgpr_28_x> <== NOT EXECUTED
ffc0fe38 <rtems_rfs_rup_quotient>:
* "quotient = dividend / divisor"
*/
int
rtems_rfs_rup_quotient (uint32_t dividend, uint32_t divisor)
{
if (dividend == 0)
ffc0fe38: 2c 03 00 00 cmpwi r3,0
return 1;
ffc0fe3c: 38 00 00 01 li r0,1
* "quotient = dividend / divisor"
*/
int
rtems_rfs_rup_quotient (uint32_t dividend, uint32_t divisor)
{
if (dividend == 0)
ffc0fe40: 41 82 00 10 beq- ffc0fe50 <rtems_rfs_rup_quotient+0x18> <== NEVER TAKEN
return 1;
return ((dividend - 1) / divisor) + 1;
ffc0fe44: 38 03 ff ff addi r0,r3,-1
ffc0fe48: 7c 80 23 96 divwu r4,r0,r4
ffc0fe4c: 38 04 00 01 addi r0,r4,1
}
ffc0fe50: 7c 03 03 78 mr r3,r0
ffc0fe54: 4e 80 00 20 blr
ffc1befc <rtems_rfs_scan_chain>:
*/
static rtems_rfs_buffer*
rtems_rfs_scan_chain (rtems_chain_control* chain,
uint32_t* count,
rtems_rfs_buffer_block block)
{
ffc1befc: 94 21 ff e0 stwu r1,-32(r1)
ffc1bf00: 7c 08 02 a6 mflr r0
ffc1bf04: 90 01 00 24 stw r0,36(r1)
ffc1bf08: bf 61 00 0c stmw r27,12(r1)
ffc1bf0c: 7c 7d 1b 78 mr r29,r3
ffc1bf10: 7c 9e 23 78 mr r30,r4
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Last(
Chain_Control *the_chain
)
{
return _Chain_Tail( the_chain )->previous;
ffc1bf14: 83 e3 00 08 lwz r31,8(r3)
rtems_rfs_buffer* buffer;
rtems_chain_node* node;
node = rtems_chain_last (chain);
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))
ffc1bf18: 38 80 00 80 li r4,128
ffc1bf1c: 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)
{
ffc1bf20: 7c bc 2b 78 mr r28,r5
rtems_rfs_buffer* buffer;
rtems_chain_node* node;
node = rtems_chain_last (chain);
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))
ffc1bf24: 4b ff 73 e1 bl ffc13304 <rtems_rfs_trace>
ffc1bf28: 2f 83 00 00 cmpwi cr7,r3,0
ffc1bf2c: 41 be 00 9c beq+ cr7,ffc1bfc8 <rtems_rfs_scan_chain+0xcc><== ALWAYS TAKEN
printf ("rtems-rfs: buffer-scan: count=%" PRIu32 ", block=%" PRIu32 ": ", *count, block);
ffc1bf30: 3c 60 ff c3 lis r3,-61 <== NOT EXECUTED
ffc1bf34: 80 9e 00 00 lwz r4,0(r30) <== NOT EXECUTED
ffc1bf38: 7f 85 e3 78 mr r5,r28 <== NOT EXECUTED
ffc1bf3c: 38 63 42 d9 addi r3,r3,17113 <== NOT EXECUTED
ffc1bf40: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc1bf44: 48 00 6b a5 bl ffc22ae8 <printf> <== NOT EXECUTED
ffc1bf48: 48 00 00 80 b ffc1bfc8 <rtems_rfs_scan_chain+0xcc> <== NOT EXECUTED
while (!rtems_chain_is_head (chain, node))
{
buffer = (rtems_rfs_buffer*) node;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))
ffc1bf4c: 4b ff 73 b9 bl ffc13304 <rtems_rfs_trace>
ffc1bf50: 2f 83 00 00 cmpwi cr7,r3,0
ffc1bf54: 41 be 00 14 beq+ cr7,ffc1bf68 <rtems_rfs_scan_chain+0x6c><== ALWAYS TAKEN
printf ("%" PRIuPTR " ", ((intptr_t) buffer->user));
ffc1bf58: 80 9f 00 3c lwz r4,60(r31) <== NOT EXECUTED
ffc1bf5c: 7f 63 db 78 mr r3,r27 <== NOT EXECUTED
ffc1bf60: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc1bf64: 48 00 6b 85 bl ffc22ae8 <printf> <== NOT EXECUTED
if (((rtems_rfs_buffer_block) ((intptr_t)(buffer->user))) == block)
ffc1bf68: 80 1f 00 3c lwz r0,60(r31)
ffc1bf6c: 7f 80 e0 00 cmpw cr7,r0,r28
ffc1bf70: 40 be 00 50 bne+ cr7,ffc1bfc0 <rtems_rfs_scan_chain+0xc4>
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))
ffc1bf74: 38 60 00 00 li r3,0
ffc1bf78: 38 80 00 80 li r4,128
ffc1bf7c: 4b ff 73 89 bl ffc13304 <rtems_rfs_trace>
ffc1bf80: 2f 83 00 00 cmpwi cr7,r3,0
ffc1bf84: 41 be 00 18 beq+ cr7,ffc1bf9c <rtems_rfs_scan_chain+0xa0><== ALWAYS TAKEN
printf (": found block=%" PRIuPTR "\n",
ffc1bf88: 3c 60 ff c3 lis r3,-61 <== NOT EXECUTED
ffc1bf8c: 80 9f 00 3c lwz r4,60(r31) <== NOT EXECUTED
ffc1bf90: 38 63 43 0d addi r3,r3,17165 <== NOT EXECUTED
ffc1bf94: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc1bf98: 48 00 6b 51 bl ffc22ae8 <printf> <== NOT EXECUTED
((intptr_t)(buffer->user)));
(*count)--;
ffc1bf9c: 81 3e 00 00 lwz r9,0(r30)
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
ffc1bfa0: 7f e3 fb 78 mr r3,r31
ffc1bfa4: 38 09 ff ff addi r0,r9,-1
ffc1bfa8: 90 1e 00 00 stw r0,0(r30)
ffc1bfac: 4b ff 0a 9d bl ffc0ca48 <_Chain_Extract>
*/
RTEMS_INLINE_ROUTINE void _Chain_Set_off_chain(
Chain_Node *node
)
{
node->next = node->previous = NULL;
ffc1bfb0: 38 00 00 00 li r0,0
ffc1bfb4: 90 1f 00 04 stw r0,4(r31)
ffc1bfb8: 90 1f 00 00 stw r0,0(r31)
rtems_chain_extract (node);
rtems_chain_set_off_chain (node);
return buffer;
ffc1bfbc: 48 00 00 40 b ffc1bffc <rtems_rfs_scan_chain+0x100>
true);
if ((rc > 0) && (rrc == 0))
rrc = rc;
return rrc;
}
ffc1bfc0: 83 ff 00 04 lwz r31,4(r31)
ffc1bfc4: 48 00 00 0c b ffc1bfd0 <rtems_rfs_scan_chain+0xd4>
while (!rtems_chain_is_head (chain, node))
{
buffer = (rtems_rfs_buffer*) node;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))
printf ("%" PRIuPTR " ", ((intptr_t) buffer->user));
ffc1bfc8: 3f 60 ff c3 lis r27,-61
ffc1bfcc: 3b 7b 43 08 addi r27,r27,17160
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))
ffc1bfd0: 7f 9f e8 00 cmpw cr7,r31,r29
{
buffer = (rtems_rfs_buffer*) node;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))
ffc1bfd4: 38 60 00 00 li r3,0
ffc1bfd8: 38 80 00 80 li r4,128
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))
ffc1bfdc: 40 9e ff 70 bne+ cr7,ffc1bf4c <rtems_rfs_scan_chain+0x50>
return buffer;
}
node = rtems_chain_previous (node);
}
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))
ffc1bfe0: 4b ff 73 25 bl ffc13304 <rtems_rfs_trace>
printf (": not found\n");
return NULL;
ffc1bfe4: 3b e0 00 00 li r31,0
return buffer;
}
node = rtems_chain_previous (node);
}
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))
ffc1bfe8: 2f 83 00 00 cmpwi cr7,r3,0
ffc1bfec: 41 be 00 10 beq+ cr7,ffc1bffc <rtems_rfs_scan_chain+0x100><== ALWAYS TAKEN
printf (": not found\n");
ffc1bff0: 3c 60 ff c3 lis r3,-61 <== NOT EXECUTED
ffc1bff4: 38 63 43 20 addi r3,r3,17184 <== NOT EXECUTED
ffc1bff8: 48 00 6c a5 bl ffc22c9c <puts> <== NOT EXECUTED
return NULL;
}
ffc1bffc: 39 61 00 20 addi r11,r1,32
ffc1c000: 7f e3 fb 78 mr r3,r31
ffc1c004: 4b fe 6a e4 b ffc02ae8 <_restgpr_27_x>
ffc1a5dc <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,
ffc1a5dc: 94 21 ff c0 stwu r1,-64(r1)
ffc1a5e0: 7c 08 02 a6 mflr r0
ffc1a5e4: 90 01 00 44 stw r0,68(r1)
rtems_rfs_bitmap_element* map_bits;
int map_index;
int map_offset;
int rc;
*found = false;
ffc1a5e8: 38 00 00 00 li r0,0
return 0;
}
static int
rtems_rfs_search_map_for_clear_bit (rtems_rfs_bitmap_control* control,
ffc1a5ec: be c1 00 18 stmw r22,24(r1)
ffc1a5f0: 7c 9e 23 78 mr r30,r4
*found = false;
/*
* Load the bitmap.
*/
rc = rtems_rfs_bitmap_load_map (control, &map);
ffc1a5f4: 38 81 00 08 addi r4,r1,8
rtems_rfs_bitmap_element* map_bits;
int map_index;
int map_offset;
int rc;
*found = false;
ffc1a5f8: 98 05 00 00 stb r0,0(r5)
return 0;
}
static int
rtems_rfs_search_map_for_clear_bit (rtems_rfs_bitmap_control* control,
ffc1a5fc: 7c 7f 1b 78 mr r31,r3
ffc1a600: 7c bd 2b 78 mr r29,r5
ffc1a604: 7c dc 33 78 mr r28,r6
*found = false;
/*
* Load the bitmap.
*/
rc = rtems_rfs_bitmap_load_map (control, &map);
ffc1a608: 4b ff ff 71 bl ffc1a578 <rtems_rfs_bitmap_load_map>
if (rc > 0)
ffc1a60c: 2c 03 00 00 cmpwi r3,0
ffc1a610: 41 a1 01 c8 bgt+ ffc1a7d8 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x1fc><== NEVER TAKEN
return rc;
/*
* Calculate the bit we are testing plus the end point we search over.
*/
test_bit = *bit;
ffc1a614: 80 1e 00 00 lwz r0,0(r30)
end_bit = test_bit + (window * direction);
ffc1a618: 57 8a 58 28 rlwinm r10,r28,11,0,20
if (end_bit < 0)
ffc1a61c: 7d 4a 02 15 add. r10,r10,r0
ffc1a620: 41 80 00 18 blt- ffc1a638 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x5c>
end_bit = 0;
else if (end_bit >= control->size)
ffc1a624: 81 3f 00 0c lwz r9,12(r31)
ffc1a628: 7f 8a 48 40 cmplw cr7,r10,r9
ffc1a62c: 41 9c 00 10 blt- cr7,ffc1a63c <rtems_rfs_search_map_for_clear_bit.constprop.1+0x60><== NEVER TAKEN
end_bit = control->size - 1;
ffc1a630: 39 49 ff ff addi r10,r9,-1
ffc1a634: 48 00 00 08 b ffc1a63c <rtems_rfs_search_map_for_clear_bit.constprop.1+0x60>
*/
test_bit = *bit;
end_bit = test_bit + (window * direction);
if (end_bit < 0)
end_bit = 0;
ffc1a638: 39 40 00 00 li r10,0
map_offset += direction;
test_bit += direction;
}
}
map_bits += direction;
ffc1a63c: 2f 9c 00 00 cmpwi cr7,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];
ffc1a640: 80 ff 00 14 lwz r7,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);
ffc1a644: 7c 06 56 70 srawi r6,r0,10
search_offset = rtems_rfs_bitmap_map_offset (map_index);
search_bits = &control->search_bits[search_index];
map_bits = &map[map_index];
ffc1a648: 80 a1 00 08 lwz r5,8(r1)
if (end_bit < 0)
end_bit = 0;
else if (end_bit >= control->size)
end_bit = control->size - 1;
map_index = rtems_rfs_bitmap_map_index (test_bit);
ffc1a64c: 7c 08 2e 70 srawi r8,r0,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];
ffc1a650: 54 c6 10 3a rlwinm r6,r6,2,0,29
ffc1a654: 7c c7 32 14 add r6,r7,r6
map_bits = &map[map_index];
ffc1a658: 55 07 10 3a rlwinm r7,r8,2,0,29
ffc1a65c: 7c e5 3a 14 add r7,r5,r7
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);
ffc1a660: 54 0b 06 fe clrlwi r11,r0,27
search_index = rtems_rfs_bitmap_map_index (map_index);
search_offset = rtems_rfs_bitmap_map_offset (map_index);
ffc1a664: 55 09 06 fe clrlwi r9,r8,27
map_offset += direction;
test_bit += direction;
}
}
map_bits += direction;
ffc1a668: 57 99 10 3a rlwinm r25,r28,2,0,29
ffc1a66c: 38 a0 00 1f li r5,31
ffc1a670: 40 9d 00 1c ble- cr7,ffc1a68c <rtems_rfs_search_map_for_clear_bit.constprop.1+0xb0>
ffc1a674: 38 a0 00 00 li r5,0
ffc1a678: 48 00 00 14 b ffc1a68c <rtems_rfs_search_map_for_clear_bit.constprop.1+0xb0>
map_bits += direction * bits_skipped;
map_index += direction * bits_skipped;
}
search_bits += direction;
search_offset = direction > 0 ? 0 : rtems_rfs_bitmap_element_bits () - 1;
ffc1a67c: 39 20 00 1f li r9,31 <== NOT EXECUTED
ffc1a680: 48 00 00 18 b ffc1a698 <rtems_rfs_search_map_for_clear_bit.constprop.1+0xbc><== NOT EXECUTED
ffc1a684: 39 20 00 00 li r9,0 <== NOT EXECUTED
ffc1a688: 48 00 00 10 b ffc1a698 <rtems_rfs_search_map_for_clear_bit.constprop.1+0xbc><== 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);
if (direction > 0)
ffc1a68c: 2f 9c 00 00 cmpwi cr7,r28,0
return 0;
}
static int
rtems_rfs_search_map_for_clear_bit (rtems_rfs_bitmap_control* control,
ffc1a690: 57 97 28 34 rlwinm r23,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);
ffc1a694: 3b 40 00 01 li r26,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))
ffc1a698: 83 06 00 00 lwz r24,0(r6)
ffc1a69c: 2f 18 00 00 cmpwi cr6,r24,0
ffc1a6a0: 41 9a 00 cc beq- cr6,ffc1a76c <rtems_rfs_search_map_for_clear_bit.constprop.1+0x190><== NEVER TAKEN
return 0;
}
static int
rtems_rfs_search_map_for_clear_bit (rtems_rfs_bitmap_control* control,
ffc1a6a4: 7c 88 e2 14 add r4,r8,r28
ffc1a6a8: 54 84 28 34 rlwinm r4,r4,5,0,26
ffc1a6ac: 7c 84 2a 14 add r4,r4,r5
ffc1a6b0: 48 00 00 b0 b ffc1a760 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x184>
*/
static bool
rtems_rfs_bitmap_test (rtems_rfs_bitmap_element target,
rtems_rfs_bitmap_bit bit)
{
return RTEMS_RFS_BITMAP_TEST_BIT (target, bit);
ffc1a6b4: 7f 43 48 30 slw r3,r26,r9
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))
ffc1a6b8: 7c 76 c0 39 and. r22,r3,r24
ffc1a6bc: 41 82 00 70 beq- ffc1a72c <rtems_rfs_search_map_for_clear_bit.constprop.1+0x150>
ffc1a6c0: 48 00 00 64 b ffc1a724 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x148>
* 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))
ffc1a6c4: 81 87 00 00 lwz r12,0(r7)
*/
static bool
rtems_rfs_bitmap_test (rtems_rfs_bitmap_element target,
rtems_rfs_bitmap_bit bit)
{
return RTEMS_RFS_BITMAP_TEST_BIT (target, bit);
ffc1a6c8: 7f 5b 58 30 slw r27,r26,r11
* 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))
ffc1a6cc: 7f 76 60 39 and. r22,r27,r12
ffc1a6d0: 41 a2 00 44 beq+ ffc1a714 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x138>
*/
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);
ffc1a6d4: 7d 89 d8 78 andc r9,r12,r27
&& (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,
ffc1a6d8: 2f 89 00 00 cmpwi cr7,r9,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);
ffc1a6dc: 91 27 00 00 stw r9,0(r7)
if (rtems_rfs_bitmap_match(*map_bits,
ffc1a6e0: 40 9e 00 10 bne- cr7,ffc1a6f0 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x114>
*/
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);
ffc1a6e4: 81 26 00 00 lwz r9,0(r6)
ffc1a6e8: 7d 23 18 78 andc r3,r9,r3
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,
ffc1a6ec: 90 66 00 00 stw r3,0(r6)
1 << search_offset);
control->free--;
ffc1a6f0: 81 3f 00 10 lwz r9,16(r31)
ffc1a6f4: 39 29 ff ff addi r9,r9,-1
ffc1a6f8: 91 3f 00 10 stw r9,16(r31)
*bit = test_bit;
*found = true;
rtems_rfs_buffer_mark_dirty (control->buffer);
ffc1a6fc: 81 3f 00 00 lwz r9,0(r31)
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--;
*bit = test_bit;
ffc1a700: 90 1e 00 00 stw r0,0(r30)
*found = true;
ffc1a704: 38 00 00 01 li r0,1
ffc1a708: 98 1d 00 00 stb r0,0(r29)
rtems_rfs_buffer_mark_dirty (control->buffer);
ffc1a70c: 98 09 00 00 stb r0,0(r9)
ffc1a710: 48 00 00 c4 b ffc1a7d4 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x1f8>
return 0;
}
if (test_bit == end_bit)
ffc1a714: 7f 00 50 00 cmpw cr6,r0,r10
ffc1a718: 41 9a 00 14 beq- cr6,ffc1a72c <rtems_rfs_search_map_for_clear_bit.constprop.1+0x150>
return 0;
}
static int
rtems_rfs_search_map_for_clear_bit (rtems_rfs_bitmap_control* control,
ffc1a71c: 7d 6b e2 14 add r11,r11,r28
ffc1a720: 7c 00 e2 14 add r0,r0,r28
{
/*
* 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)
ffc1a724: 2b 0b 00 1f cmplwi cr6,r11,31
ffc1a728: 40 99 ff 9c ble+ cr6,ffc1a6c4 <rtems_rfs_search_map_for_clear_bit.constprop.1+0xe8><== ALWAYS TAKEN
map_offset += direction;
test_bit += direction;
}
}
map_bits += direction;
ffc1a72c: 7c e7 ca 14 add r7,r7,r25
return 0;
}
static int
rtems_rfs_search_map_for_clear_bit (rtems_rfs_bitmap_control* control,
ffc1a730: 7d 08 e2 14 add r8,r8,r28
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;
ffc1a734: 7c 80 23 78 mr r0,r4
return 0;
}
static int
rtems_rfs_search_map_for_clear_bit (rtems_rfs_bitmap_control* control,
ffc1a738: 7d 29 e2 14 add r9,r9,r28
test_bit = (map_index * rtems_rfs_bitmap_element_bits ()) + map_offset;
search_offset += direction;
if (((direction < 0) && (test_bit <= end_bit))
ffc1a73c: 40 bc 00 10 bge+ cr7,ffc1a74c <rtems_rfs_search_map_for_clear_bit.constprop.1+0x170>
ffc1a740: 7f 04 50 00 cmpw cr6,r4,r10
ffc1a744: 41 b9 00 14 bgt+ cr6,ffc1a758 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x17c><== NEVER TAKEN
ffc1a748: 48 00 00 68 b ffc1a7b0 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x1d4>
|| ((direction > 0) && (test_bit >= end_bit)))
ffc1a74c: 41 9e 00 0c beq- cr7,ffc1a758 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x17c><== NEVER TAKEN
ffc1a750: 7f 04 50 00 cmpw cr6,r4,r10
ffc1a754: 40 98 00 5c bge- cr6,ffc1a7b0 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x1d4>
ffc1a758: 7c 84 ba 14 add r4,r4,r23
map_bits += direction * bits_skipped;
map_index += direction * bits_skipped;
}
search_bits += direction;
search_offset = direction > 0 ? 0 : rtems_rfs_bitmap_element_bits () - 1;
ffc1a75c: 7c ab 2b 78 mr r11,r5
* 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)
ffc1a760: 2b 09 00 1f cmplwi cr6,r9,31
ffc1a764: 40 99 ff 50 ble+ cr6,ffc1a6b4 <rtems_rfs_search_map_for_clear_bit.constprop.1+0xd8><== ALWAYS TAKEN
ffc1a768: 48 00 00 4c b ffc1a7b4 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x1d8><== 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);
ffc1a76c: 54 00 00 34 rlwinm r0,r0,0,0,26 <== NOT EXECUTED
if (direction > 0)
ffc1a770: 40 9d 00 18 ble- cr7,ffc1a788 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x1ac><== NOT EXECUTED
{
bits_skipped = rtems_rfs_bitmap_element_bits () - search_offset;
ffc1a774: 20 89 00 20 subfic r4,r9,32 <== NOT EXECUTED
test_bit += bits_skipped * rtems_rfs_bitmap_element_bits ();
ffc1a778: 54 89 28 34 rlwinm r9,r4,5,0,26 <== NOT EXECUTED
ffc1a77c: 7c 09 02 14 add r0,r9,r0 <== NOT EXECUTED
map_offset = 0;
ffc1a780: 39 60 00 00 li r11,0 <== NOT EXECUTED
ffc1a784: 48 00 00 18 b ffc1a79c <rtems_rfs_search_map_for_clear_bit.constprop.1+0x1c0><== NOT EXECUTED
}
else
{
bits_skipped = search_offset + 1;
ffc1a788: 38 89 00 01 addi r4,r9,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;
ffc1a78c: 55 29 28 34 rlwinm r9,r9,5,0,26 <== NOT EXECUTED
ffc1a790: 7d 29 48 f8 not r9,r9 <== NOT EXECUTED
ffc1a794: 7c 09 02 14 add r0,r9,r0 <== NOT EXECUTED
map_offset = rtems_rfs_bitmap_element_bits () - 1;
ffc1a798: 39 60 00 1f li r11,31 <== NOT EXECUTED
}
map_bits += direction * bits_skipped;
ffc1a79c: 7c 9c 21 d6 mullw r4,r28,r4 <== NOT EXECUTED
ffc1a7a0: 54 89 10 3a rlwinm r9,r4,2,0,29 <== NOT EXECUTED
ffc1a7a4: 7c e7 4a 14 add r7,r7,r9 <== NOT EXECUTED
map_index += direction * bits_skipped;
ffc1a7a8: 7d 08 22 14 add r8,r8,r4 <== NOT EXECUTED
ffc1a7ac: 48 00 00 08 b ffc1a7b4 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x1d8><== 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)))
ffc1a7b0: 7c ab 2b 78 mr r11,r5
}
map_bits += direction * bits_skipped;
map_index += direction * bits_skipped;
}
search_bits += direction;
ffc1a7b4: 7c c6 ca 14 add r6,r6,r25
search_offset = direction > 0 ? 0 : rtems_rfs_bitmap_element_bits () - 1;
ffc1a7b8: 41 bd 00 14 bgt+ cr7,ffc1a7cc <rtems_rfs_search_map_for_clear_bit.constprop.1+0x1f0>
}
while (((direction < 0) && (test_bit >= end_bit))
|| ((direction > 0) && (test_bit <= end_bit)));
ffc1a7bc: 41 9e 00 18 beq- cr7,ffc1a7d4 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x1f8><== NEVER TAKEN
}
search_bits += direction;
search_offset = direction > 0 ? 0 : rtems_rfs_bitmap_element_bits () - 1;
}
while (((direction < 0) && (test_bit >= end_bit))
ffc1a7c0: 7f 00 50 00 cmpw cr6,r0,r10
ffc1a7c4: 40 b8 fe b8 bge- cr6,ffc1a67c <rtems_rfs_search_map_for_clear_bit.constprop.1+0xa0><== NEVER TAKEN
ffc1a7c8: 48 00 00 0c b ffc1a7d4 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x1f8>
|| ((direction > 0) && (test_bit <= end_bit)));
ffc1a7cc: 7f 00 50 00 cmpw cr6,r0,r10
ffc1a7d0: 40 99 fe b4 ble+ cr6,ffc1a684 <rtems_rfs_search_map_for_clear_bit.constprop.1+0xa8><== NEVER TAKEN
return 0;
ffc1a7d4: 38 60 00 00 li r3,0
}
ffc1a7d8: 39 61 00 40 addi r11,r1,64
ffc1a7dc: 4b fe 82 f8 b ffc02ad4 <_restgpr_22_x>
ffc1f73c <rtems_rfs_symlink>:
const char* link,
int link_length,
uid_t uid,
gid_t gid,
rtems_rfs_ino parent)
{
ffc1f73c: 94 21 ff 38 stwu r1,-200(r1)
ffc1f740: 7c 08 02 a6 mflr r0
ffc1f744: be e1 00 a4 stmw r23,164(r1)
ffc1f748: 7c 7f 1b 78 mr r31,r3
ffc1f74c: 7c 9c 23 78 mr r28,r4
rtems_rfs_inode_handle inode;
rtems_rfs_ino ino;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_SYMLINK))
ffc1f750: 38 60 00 02 li r3,2
const char* link,
int link_length,
uid_t uid,
gid_t gid,
rtems_rfs_ino parent)
{
ffc1f754: 90 01 00 cc stw r0,204(r1)
rtems_rfs_inode_handle inode;
rtems_rfs_ino ino;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_SYMLINK))
ffc1f758: 38 80 00 00 li r4,0
const char* link,
int link_length,
uid_t uid,
gid_t gid,
rtems_rfs_ino parent)
{
ffc1f75c: 7c b9 2b 78 mr r25,r5
ffc1f760: 7c dd 33 78 mr r29,r6
ffc1f764: 7c fe 3b 78 mr r30,r7
ffc1f768: 7d 1a 43 78 mr r26,r8
ffc1f76c: 7d 3b 4b 78 mr r27,r9
ffc1f770: 7d 58 53 78 mr r24,r10
rtems_rfs_inode_handle inode;
rtems_rfs_ino ino;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_SYMLINK))
ffc1f774: 4b ff 3b 91 bl ffc13304 <rtems_rfs_trace>
ffc1f778: 2f 83 00 00 cmpwi cr7,r3,0
ffc1f77c: 41 be 00 60 beq+ cr7,ffc1f7dc <rtems_rfs_symlink+0xa0> <== ALWAYS TAKEN
{
int c;
printf ("rtems-rfs: symlink: parent:%" PRIu32 " name:", parent);
ffc1f780: 3c 60 ff c3 lis r3,-61 <== NOT EXECUTED
ffc1f784: 38 63 55 ed addi r3,r3,21997 <== NOT EXECUTED
ffc1f788: 7f 04 c3 78 mr r4,r24 <== NOT EXECUTED
ffc1f78c: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc1f790: 48 00 33 59 bl ffc22ae8 <printf> <== NOT EXECUTED
for (c = 0; c < length; c++)
ffc1f794: 3a e0 00 00 li r23,0 <== NOT EXECUTED
ffc1f798: 48 00 00 10 b ffc1f7a8 <rtems_rfs_symlink+0x6c> <== NOT EXECUTED
printf ("%c", name[c]);
ffc1f79c: 7c 7c b8 ae lbzx r3,r28,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++)
ffc1f7a0: 3a f7 00 01 addi r23,r23,1 <== NOT EXECUTED
printf ("%c", name[c]);
ffc1f7a4: 48 00 34 01 bl ffc22ba4 <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++)
ffc1f7a8: 7f 97 c8 00 cmpw cr7,r23,r25 <== NOT EXECUTED
ffc1f7ac: 41 9c ff f0 blt+ cr7,ffc1f79c <rtems_rfs_symlink+0x60> <== NOT EXECUTED
printf ("%c", name[c]);
printf (" link:");
ffc1f7b0: 3c 60 ff c3 lis r3,-61 <== NOT EXECUTED
ffc1f7b4: 38 63 56 12 addi r3,r3,22034 <== NOT EXECUTED
ffc1f7b8: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc1f7bc: 48 00 33 2d bl ffc22ae8 <printf> <== NOT EXECUTED
for (c = 0; c < link_length; c++)
ffc1f7c0: 3b 20 00 00 li r25,0 <== NOT EXECUTED
ffc1f7c4: 48 00 00 10 b ffc1f7d4 <rtems_rfs_symlink+0x98> <== NOT EXECUTED
printf ("%c", link[c]);
ffc1f7c8: 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++)
ffc1f7cc: 3b 39 00 01 addi r25,r25,1 <== NOT EXECUTED
printf ("%c", link[c]);
ffc1f7d0: 48 00 33 d5 bl ffc22ba4 <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++)
ffc1f7d4: 7f 99 f0 00 cmpw cr7,r25,r30 <== NOT EXECUTED
ffc1f7d8: 41 9c ff f0 blt+ cr7,ffc1f7c8 <rtems_rfs_symlink+0x8c> <== NOT EXECUTED
printf ("%c", link[c]);
}
if (link_length >= rtems_rfs_fs_block_size (fs))
ffc1f7dc: 80 1f 00 08 lwz r0,8(r31)
return ENAMETOOLONG;
ffc1f7e0: 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))
ffc1f7e4: 7f 9e 00 40 cmplw cr7,r30,r0
ffc1f7e8: 40 bc 01 bc bge+ cr7,ffc1f9a4 <rtems_rfs_symlink+0x268> <== NEVER TAKEN
return ENAMETOOLONG;
rc = rtems_rfs_inode_create (fs, parent, name, strlen (name),
ffc1f7ec: 7f 83 e3 78 mr r3,r28
ffc1f7f0: 48 00 40 7d bl ffc2386c <strlen>
ffc1f7f4: 38 e0 00 00 li r7,0
ffc1f7f8: 7c 66 1b 78 mr r6,r3
ffc1f7fc: 38 01 00 14 addi r0,r1,20
ffc1f800: 7f e3 fb 78 mr r3,r31
ffc1f804: 90 01 00 08 stw r0,8(r1)
ffc1f808: 7f 04 c3 78 mr r4,r24
ffc1f80c: 7f 85 e3 78 mr r5,r28
ffc1f810: 60 e7 a1 ff ori r7,r7,41471
ffc1f814: 39 00 00 01 li r8,1
ffc1f818: 7f 49 d3 78 mr r9,r26
ffc1f81c: 7f 6a db 78 mr r10,r27
ffc1f820: 4b ff 20 75 bl ffc11894 <rtems_rfs_inode_create>
RTEMS_RFS_S_SYMLINK,
1, uid, gid, &ino);
if (rc > 0)
ffc1f824: 7c 79 1b 79 mr. r25,r3
ffc1f828: 41 a1 01 7c bgt+ ffc1f9a4 <rtems_rfs_symlink+0x268> <== NEVER TAKEN
return rc;
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
ffc1f82c: 80 81 00 14 lwz r4,20(r1)
ffc1f830: 7f e3 fb 78 mr r3,r31
ffc1f834: 38 a1 00 24 addi r5,r1,36
ffc1f838: 38 c0 00 01 li r6,1
ffc1f83c: 4b ff 1a bd bl ffc112f8 <rtems_rfs_inode_open>
if (rc > 0)
ffc1f840: 7c 79 1b 79 mr. r25,r3
ffc1f844: 41 a1 01 60 bgt+ ffc1f9a4 <rtems_rfs_symlink+0x268> <== 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)
ffc1f848: 2b 9e 00 13 cmplwi cr7,r30,19
ffc1f84c: 41 9d 00 54 bgt- cr7,ffc1f8a0 <rtems_rfs_symlink+0x164> <== NEVER TAKEN
{
memset (inode.node->data.name, 0, RTEMS_RFS_INODE_DATA_NAME_SIZE);
ffc1f850: 80 61 00 30 lwz r3,48(r1)
ffc1f854: 38 80 00 00 li r4,0
ffc1f858: 38 a0 00 14 li r5,20
ffc1f85c: 38 63 00 1c addi r3,r3,28
ffc1f860: 48 00 30 f9 bl ffc22958 <memset>
memcpy (inode.node->data.name, link, link_length);
ffc1f864: 80 61 00 30 lwz r3,48(r1)
ffc1f868: 7f a4 eb 78 mr r4,r29
ffc1f86c: 38 63 00 1c addi r3,r3,28
ffc1f870: 7f c5 f3 78 mr r5,r30
ffc1f874: 48 00 2e cd bl ffc22740 <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);
ffc1f878: 81 21 00 30 lwz r9,48(r1)
ffc1f87c: 38 00 00 00 li r0,0
ffc1f880: 98 09 00 0c stb r0,12(r9)
ffc1f884: 81 21 00 30 lwz r9,48(r1)
ffc1f888: 98 09 00 0d stb r0,13(r9)
ffc1f88c: 81 21 00 30 lwz r9,48(r1)
ffc1f890: 98 09 00 0e stb r0,14(r9)
ffc1f894: 81 21 00 30 lwz r9,48(r1)
ffc1f898: 98 09 00 0f stb r0,15(r9)
ffc1f89c: 48 00 00 d8 b ffc1f974 <rtems_rfs_symlink+0x238>
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);
ffc1f8a0: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc1f8a4: 38 81 00 24 addi r4,r1,36 <== NOT EXECUTED
ffc1f8a8: 38 a1 00 4c addi r5,r1,76 <== NOT EXECUTED
ffc1f8ac: 4b ff b9 31 bl ffc1b1dc <rtems_rfs_block_map_open> <== NOT EXECUTED
if (rc > 0)
ffc1f8b0: 7c 79 1b 79 mr. r25,r3 <== NOT EXECUTED
{
rtems_rfs_inode_close (fs, &inode);
ffc1f8b4: 7f e3 fb 78 mr r3,r31 <== 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)
ffc1f8b8: 41 a1 00 5c bgt+ ffc1f914 <rtems_rfs_symlink+0x1d8> <== NOT EXECUTED
{
rtems_rfs_inode_close (fs, &inode);
return rc;
}
rc = rtems_rfs_block_map_grow (fs, &map, 1, &block);
ffc1f8bc: 38 81 00 4c addi r4,r1,76 <== NOT EXECUTED
ffc1f8c0: 38 a0 00 01 li r5,1 <== NOT EXECUTED
ffc1f8c4: 38 c1 00 10 addi r6,r1,16 <== NOT EXECUTED
ffc1f8c8: 4b ff be e5 bl ffc1b7ac <rtems_rfs_block_map_grow> <== NOT EXECUTED
if (rc > 0)
ffc1f8cc: 7c 79 1b 79 mr. r25,r3 <== NOT EXECUTED
ffc1f8d0: 41 a1 00 34 bgt+ ffc1f904 <rtems_rfs_symlink+0x1c8> <== 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);
ffc1f8d4: 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;
ffc1f8d8: 38 00 00 00 li r0,0 <== NOT EXECUTED
handle->bnum = 0;
ffc1f8dc: 3b 80 00 00 li r28,0 <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
ffc1f8e0: 98 01 00 18 stb r0,24(r1) <== NOT EXECUTED
ffc1f8e4: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc1f8e8: 38 81 00 18 addi r4,r1,24 <== NOT EXECUTED
handle->bnum = 0;
ffc1f8ec: 93 81 00 1c stw r28,28(r1) <== NOT EXECUTED
ffc1f8f0: 38 c0 00 00 li r6,0 <== NOT EXECUTED
handle->buffer = NULL;
ffc1f8f4: 93 81 00 20 stw r28,32(r1) <== NOT EXECUTED
ffc1f8f8: 4b ff c8 f1 bl ffc1c1e8 <rtems_rfs_buffer_handle_request><== NOT EXECUTED
if (rc > 0)
ffc1f8fc: 7c 79 1b 79 mr. r25,r3 <== NOT EXECUTED
ffc1f900: 40 81 00 20 ble- ffc1f920 <rtems_rfs_symlink+0x1e4> <== NOT EXECUTED
{
rtems_rfs_block_map_close (fs, &map);
ffc1f904: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc1f908: 38 81 00 4c addi r4,r1,76 <== NOT EXECUTED
ffc1f90c: 4b ff ba 85 bl ffc1b390 <rtems_rfs_block_map_close> <== NOT EXECUTED
rtems_rfs_inode_close (fs, &inode);
ffc1f910: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc1f914: 38 81 00 24 addi r4,r1,36 <== NOT EXECUTED
ffc1f918: 4b ff 1b d1 bl ffc114e8 <rtems_rfs_inode_close> <== NOT EXECUTED
return rc;
ffc1f91c: 48 00 00 88 b ffc1f9a4 <rtems_rfs_symlink+0x268> <== NOT EXECUTED
}
data = rtems_rfs_buffer_data (&buffer);
ffc1f920: 81 21 00 20 lwz r9,32(r1) <== NOT EXECUTED
memset (data, 0xff, rtems_rfs_fs_block_size (fs));
ffc1f924: 38 80 00 ff li r4,255 <== NOT EXECUTED
ffc1f928: 80 bf 00 08 lwz r5,8(r31) <== NOT EXECUTED
rtems_rfs_block_map_close (fs, &map);
rtems_rfs_inode_close (fs, &inode);
return rc;
}
data = rtems_rfs_buffer_data (&buffer);
ffc1f92c: 83 69 00 24 lwz r27,36(r9) <== NOT EXECUTED
memset (data, 0xff, rtems_rfs_fs_block_size (fs));
ffc1f930: 7f 63 db 78 mr r3,r27 <== NOT EXECUTED
ffc1f934: 48 00 30 25 bl ffc22958 <memset> <== NOT EXECUTED
memcpy (data, link, link_length);
ffc1f938: 7f c5 f3 78 mr r5,r30 <== NOT EXECUTED
ffc1f93c: 7f a4 eb 78 mr r4,r29 <== NOT EXECUTED
ffc1f940: 7f 63 db 78 mr r3,r27 <== NOT EXECUTED
ffc1f944: 48 00 2d fd bl ffc22740 <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);
ffc1f948: 38 81 00 18 addi r4,r1,24 <== NOT EXECUTED
ffc1f94c: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc1f950: 4b ff c6 b9 bl ffc1c008 <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);
ffc1f954: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc1f958: 38 81 00 4c addi r4,r1,76 <== NOT EXECUTED
handle->dirty = false;
ffc1f95c: 9b 81 00 18 stb r28,24(r1) <== NOT EXECUTED
handle->bnum = 0;
ffc1f960: 93 81 00 1c stw r28,28(r1) <== NOT EXECUTED
handle->buffer = NULL;
ffc1f964: 93 81 00 20 stw r28,32(r1) <== NOT EXECUTED
ffc1f968: 4b ff ba 29 bl ffc1b390 <rtems_rfs_block_map_close> <== NOT EXECUTED
if (rc > 0)
ffc1f96c: 7c 79 1b 79 mr. r25,r3 <== NOT EXECUTED
ffc1f970: 41 a1 ff a0 bgt- ffc1f910 <rtems_rfs_symlink+0x1d4> <== NOT EXECUTED
*/
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);
ffc1f974: 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);
ffc1f978: 57 de 04 3e clrlwi r30,r30,16
ffc1f97c: 57 c0 c2 3e rlwinm r0,r30,24,8,31
ffc1f980: 98 09 00 0a stb r0,10(r9)
rc = rtems_rfs_inode_close (fs, &inode);
ffc1f984: 7f e3 fb 78 mr r3,r31
rtems_rfs_buffer_mark_dirty (&handle->buffer);
ffc1f988: 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);
ffc1f98c: 81 21 00 30 lwz r9,48(r1)
ffc1f990: 38 81 00 24 addi r4,r1,36
ffc1f994: 9b c9 00 0b stb r30,11(r9)
rtems_rfs_buffer_mark_dirty (&handle->buffer);
ffc1f998: 98 01 00 34 stb r0,52(r1)
ffc1f99c: 4b ff 1b 4d bl ffc114e8 <rtems_rfs_inode_close>
ffc1f9a0: 7c 79 1b 78 mr r25,r3
return rc;
}
ffc1f9a4: 39 61 00 c8 addi r11,r1,200
ffc1f9a8: 7f 23 cb 78 mr r3,r25
ffc1f9ac: 4b fe 31 2c b ffc02ad8 <_restgpr_23_x>
ffc1f9b0 <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)
{
ffc1f9b0: 94 21 ff 50 stwu r1,-176(r1)
ffc1f9b4: 7c 08 02 a6 mflr r0
ffc1f9b8: bf 41 00 98 stmw r26,152(r1)
ffc1f9bc: 7c 7f 1b 78 mr r31,r3
ffc1f9c0: 7c 9c 23 78 mr r28,r4
rtems_rfs_inode_handle inode;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_SYMLINK_READ))
ffc1f9c4: 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)
{
ffc1f9c8: 90 01 00 b4 stw r0,180(r1)
rtems_rfs_inode_handle inode;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_SYMLINK_READ))
ffc1f9cc: 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)
{
ffc1f9d0: 7c be 2b 78 mr r30,r5
ffc1f9d4: 7c db 33 78 mr r27,r6
ffc1f9d8: 7c fd 3b 78 mr r29,r7
rtems_rfs_inode_handle inode;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_SYMLINK_READ))
ffc1f9dc: 4b ff 39 29 bl ffc13304 <rtems_rfs_trace>
ffc1f9e0: 2f 83 00 00 cmpwi cr7,r3,0
ffc1f9e4: 41 be 00 18 beq+ cr7,ffc1f9fc <rtems_rfs_symlink_read+0x4c><== ALWAYS TAKEN
printf ("rtems-rfs: symlink-read: link:%" PRIu32 "\n", link);
ffc1f9e8: 3c 60 ff c3 lis r3,-61 <== NOT EXECUTED
ffc1f9ec: 38 63 56 19 addi r3,r3,22041 <== NOT EXECUTED
ffc1f9f0: 7f 84 e3 78 mr r4,r28 <== NOT EXECUTED
ffc1f9f4: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc1f9f8: 48 00 30 f1 bl ffc22ae8 <printf> <== NOT EXECUTED
rc = rtems_rfs_inode_open (fs, link, &inode, true);
ffc1f9fc: 7f e3 fb 78 mr r3,r31
ffc1fa00: 7f 84 e3 78 mr r4,r28
ffc1fa04: 38 a1 00 18 addi r5,r1,24
ffc1fa08: 38 c0 00 01 li r6,1
ffc1fa0c: 4b ff 18 ed bl ffc112f8 <rtems_rfs_inode_open>
if (rc)
ffc1fa10: 7c 7a 1b 79 mr. r26,r3
ffc1fa14: 40 82 01 6c bne- ffc1fb80 <rtems_rfs_symlink_read+0x1d0><== NEVER TAKEN
return rc;
if (!RTEMS_RFS_S_ISLNK (rtems_rfs_inode_get_mode (&inode)))
ffc1fa18: 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);
ffc1fa1c: 89 24 00 02 lbz r9,2(r4)
ffc1fa20: 55 29 44 26 rlwinm r9,r9,8,16,19
ffc1fa24: 6d 20 ff ff xoris r0,r9,65535
ffc1fa28: 2f 80 a0 00 cmpwi cr7,r0,-24576
ffc1fa2c: 40 9e 00 20 bne- cr7,ffc1fa4c <rtems_rfs_symlink_read+0x9c><== NEVER TAKEN
* @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);
ffc1fa30: 88 a4 00 0a lbz r5,10(r4)
ffc1fa34: 88 04 00 0b lbz r0,11(r4)
ffc1fa38: 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);
ffc1fa3c: 7c a5 03 78 or r5,r5,r0
if (size < *length)
ffc1fa40: 7f 9b 28 40 cmplw cr7,r27,r5
{
rtems_rfs_inode_close (fs, &inode);
return EINVAL;
}
*length = rtems_rfs_inode_get_block_offset (&inode);
ffc1fa44: 90 bd 00 00 stw r5,0(r29)
if (size < *length)
ffc1fa48: 40 9c 00 18 bge- cr7,ffc1fa60 <rtems_rfs_symlink_read+0xb0>
{
rtems_rfs_inode_close (fs, &inode);
ffc1fa4c: 7f e3 fb 78 mr r3,r31
ffc1fa50: 38 81 00 18 addi r4,r1,24
ffc1fa54: 4b ff 1a 95 bl ffc114e8 <rtems_rfs_inode_close>
return EINVAL;
ffc1fa58: 3b 40 00 16 li r26,22
ffc1fa5c: 48 00 01 24 b ffc1fb80 <rtems_rfs_symlink_read+0x1d0>
* @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);
ffc1fa60: 89 24 00 0c lbz r9,12(r4)
ffc1fa64: 88 04 00 0d lbz r0,13(r4)
ffc1fa68: 55 29 c0 0e rlwinm r9,r9,24,0,7
ffc1fa6c: 54 00 80 1e rlwinm r0,r0,16,0,15
ffc1fa70: 7d 29 03 78 or r9,r9,r0
ffc1fa74: 88 04 00 0f lbz r0,15(r4)
ffc1fa78: 7d 29 03 78 or r9,r9,r0
ffc1fa7c: 88 04 00 0e lbz r0,14(r4)
ffc1fa80: 54 00 40 2e rlwinm r0,r0,8,0,23
}
if (rtems_rfs_inode_get_block_count (&inode) == 0)
ffc1fa84: 7d 2b 03 79 or. r11,r9,r0
ffc1fa88: 40 82 00 14 bne- ffc1fa9c <rtems_rfs_symlink_read+0xec> <== NEVER TAKEN
{
memcpy (path, inode.node->data.name, *length);
ffc1fa8c: 7f c3 f3 78 mr r3,r30
ffc1fa90: 38 84 00 1c addi r4,r4,28
ffc1fa94: 48 00 2c ad bl ffc22740 <memcpy>
ffc1fa98: 48 00 00 cc b ffc1fb64 <rtems_rfs_symlink_read+0x1b4>
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);
ffc1fa9c: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc1faa0: 38 81 00 18 addi r4,r1,24 <== NOT EXECUTED
ffc1faa4: 38 a1 00 40 addi r5,r1,64 <== NOT EXECUTED
ffc1faa8: 4b ff b7 35 bl ffc1b1dc <rtems_rfs_block_map_open> <== NOT EXECUTED
if (rc > 0)
ffc1faac: 7c 7a 1b 79 mr. r26,r3 <== NOT EXECUTED
{
rtems_rfs_inode_close (fs, &inode);
ffc1fab0: 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)
ffc1fab4: 41 a1 00 a4 bgt+ ffc1fb58 <rtems_rfs_symlink_read+0x1a8><== NOT EXECUTED
{
rtems_rfs_inode_close (fs, &inode);
return rc;
}
rc = rtems_rfs_block_map_seek (fs, &map, 0, &block);
ffc1fab8: 38 81 00 40 addi r4,r1,64 <== NOT EXECUTED
ffc1fabc: 38 a0 00 00 li r5,0 <== NOT EXECUTED
ffc1fac0: 38 c0 00 00 li r6,0 <== NOT EXECUTED
ffc1fac4: 38 e1 00 08 addi r7,r1,8 <== NOT EXECUTED
ffc1fac8: 4b ff bc 15 bl ffc1b6dc <rtems_rfs_block_map_seek> <== NOT EXECUTED
if (rc > 0)
ffc1facc: 7c 7a 1b 79 mr. r26,r3 <== NOT EXECUTED
ffc1fad0: 41 a1 00 34 bgt+ ffc1fb04 <rtems_rfs_symlink_read+0x154><== 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);
ffc1fad4: 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;
ffc1fad8: 38 00 00 00 li r0,0 <== NOT EXECUTED
handle->bnum = 0;
ffc1fadc: 3b 80 00 00 li r28,0 <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
ffc1fae0: 98 01 00 0c stb r0,12(r1) <== NOT EXECUTED
ffc1fae4: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc1fae8: 38 81 00 0c addi r4,r1,12 <== NOT EXECUTED
handle->bnum = 0;
ffc1faec: 93 81 00 10 stw r28,16(r1) <== NOT EXECUTED
ffc1faf0: 38 c0 00 00 li r6,0 <== NOT EXECUTED
handle->buffer = NULL;
ffc1faf4: 93 81 00 14 stw r28,20(r1) <== NOT EXECUTED
ffc1faf8: 4b ff c6 f1 bl ffc1c1e8 <rtems_rfs_buffer_handle_request><== NOT EXECUTED
if (rc > 0)
ffc1fafc: 7c 7a 1b 79 mr. r26,r3 <== NOT EXECUTED
ffc1fb00: 40 81 00 14 ble- ffc1fb14 <rtems_rfs_symlink_read+0x164><== NOT EXECUTED
{
rtems_rfs_block_map_close (fs, &map);
ffc1fb04: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc1fb08: 38 81 00 40 addi r4,r1,64 <== NOT EXECUTED
ffc1fb0c: 4b ff b8 85 bl ffc1b390 <rtems_rfs_block_map_close> <== NOT EXECUTED
ffc1fb10: 48 00 00 44 b ffc1fb54 <rtems_rfs_symlink_read+0x1a4><== NOT EXECUTED
rtems_rfs_inode_close (fs, &inode);
return rc;
}
data = rtems_rfs_buffer_data (&buffer);
memcpy (path, data, *length);
ffc1fb14: 81 21 00 14 lwz r9,20(r1) <== NOT EXECUTED
ffc1fb18: 7f c3 f3 78 mr r3,r30 <== NOT EXECUTED
ffc1fb1c: 80 bd 00 00 lwz r5,0(r29) <== NOT EXECUTED
ffc1fb20: 80 89 00 24 lwz r4,36(r9) <== NOT EXECUTED
ffc1fb24: 48 00 2c 1d bl ffc22740 <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);
ffc1fb28: 38 81 00 0c addi r4,r1,12 <== NOT EXECUTED
ffc1fb2c: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc1fb30: 4b ff c4 d9 bl ffc1c008 <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);
ffc1fb34: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc1fb38: 38 81 00 40 addi r4,r1,64 <== NOT EXECUTED
handle->dirty = false;
ffc1fb3c: 9b 81 00 0c stb r28,12(r1) <== NOT EXECUTED
handle->bnum = 0;
ffc1fb40: 93 81 00 10 stw r28,16(r1) <== NOT EXECUTED
handle->buffer = NULL;
ffc1fb44: 93 81 00 14 stw r28,20(r1) <== NOT EXECUTED
ffc1fb48: 4b ff b8 49 bl ffc1b390 <rtems_rfs_block_map_close> <== NOT EXECUTED
if (rc > 0)
ffc1fb4c: 7c 7a 1b 79 mr. r26,r3 <== NOT EXECUTED
ffc1fb50: 40 a1 00 14 ble+ ffc1fb64 <rtems_rfs_symlink_read+0x1b4><== NOT EXECUTED
{
rtems_rfs_inode_close (fs, &inode);
ffc1fb54: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc1fb58: 38 81 00 18 addi r4,r1,24 <== NOT EXECUTED
ffc1fb5c: 4b ff 19 8d bl ffc114e8 <rtems_rfs_inode_close> <== NOT EXECUTED
return rc;
ffc1fb60: 48 00 00 20 b ffc1fb80 <rtems_rfs_symlink_read+0x1d0><== NOT EXECUTED
}
}
path[*length] = '\0';
ffc1fb64: 80 1d 00 00 lwz r0,0(r29)
ffc1fb68: 39 20 00 00 li r9,0
rc = rtems_rfs_inode_close (fs, &inode);
ffc1fb6c: 7f e3 fb 78 mr r3,r31
rtems_rfs_inode_close (fs, &inode);
return rc;
}
}
path[*length] = '\0';
ffc1fb70: 7d 3e 01 ae stbx r9,r30,r0
rc = rtems_rfs_inode_close (fs, &inode);
ffc1fb74: 38 81 00 18 addi r4,r1,24
ffc1fb78: 4b ff 19 71 bl ffc114e8 <rtems_rfs_inode_close>
ffc1fb7c: 7c 7a 1b 78 mr r26,r3
return rc;
}
ffc1fb80: 39 61 00 b0 addi r11,r1,176
ffc1fb84: 7f 43 d3 78 mr r3,r26
ffc1fb88: 4b fe 2f 5c b ffc02ae4 <_restgpr_26_x>
ffc1335c <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;
ffc1335c: 3d 20 00 00 lis r9,0 <== NOT EXECUTED
ffc13360: 39 49 2a 68 addi r10,r9,10856 <== NOT EXECUTED
ffc13364: 81 69 2a 68 lwz r11,10856(r9) <== NOT EXECUTED
ffc13368: 80 0a 00 04 lwz r0,4(r10) <== NOT EXECUTED
rtems_rfs_trace_flags &= ~mask;
ffc1336c: 7d 63 18 78 andc r3,r11,r3 <== NOT EXECUTED
ffc13370: 7c 04 20 78 andc r4,r0,r4 <== NOT EXECUTED
ffc13374: 90 69 2a 68 stw r3,10856(r9) <== NOT EXECUTED
return state;
}
ffc13378: 7d 63 5b 78 mr r3,r11 <== 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;
ffc1337c: 90 8a 00 04 stw r4,4(r10) <== NOT EXECUTED
return state;
}
ffc13380: 7c 04 03 78 mr r4,r0 <== NOT EXECUTED
ffc13384: 4e 80 00 20 blr <== NOT EXECUTED
ffc13330 <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;
ffc13330: 3d 20 00 00 lis r9,0 <== NOT EXECUTED
ffc13334: 39 49 2a 68 addi r10,r9,10856 <== NOT EXECUTED
ffc13338: 81 69 2a 68 lwz r11,10856(r9) <== NOT EXECUTED
ffc1333c: 80 0a 00 04 lwz r0,4(r10) <== NOT EXECUTED
rtems_rfs_trace_flags |= mask;
ffc13340: 7c 63 5b 78 or r3,r3,r11 <== NOT EXECUTED
ffc13344: 7c 84 03 78 or r4,r4,r0 <== NOT EXECUTED
ffc13348: 90 69 2a 68 stw r3,10856(r9) <== NOT EXECUTED
return state;
}
ffc1334c: 7d 63 5b 78 mr r3,r11 <== 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;
ffc13350: 90 8a 00 04 stw r4,4(r10) <== NOT EXECUTED
return state;
}
ffc13354: 7c 04 03 78 mr r4,r0 <== NOT EXECUTED
ffc13358: 4e 80 00 20 blr <== NOT EXECUTED
ffc13388 <rtems_rfs_trace_shell_command>:
int
rtems_rfs_trace_shell_command (int argc, char *argv[])
{
ffc13388: 94 21 ff 10 stwu r1,-240(r1) <== NOT EXECUTED
ffc1338c: 7c 08 02 a6 mflr r0 <== NOT EXECUTED
const char* table[] =
ffc13390: 38 a0 00 98 li r5,152 <== NOT EXECUTED
return state;
}
int
rtems_rfs_trace_shell_command (int argc, char *argv[])
{
ffc13394: bd e1 00 ac stmw r15,172(r1) <== NOT EXECUTED
ffc13398: 7c 9b 23 78 mr r27,r4 <== NOT EXECUTED
const char* table[] =
ffc1339c: 3c 80 ff c3 lis r4,-61 <== NOT EXECUTED
return state;
}
int
rtems_rfs_trace_shell_command (int argc, char *argv[])
{
ffc133a0: 7c 7a 1b 78 mr r26,r3 <== NOT EXECUTED
ffc133a4: 90 01 00 f4 stw r0,244(r1) <== NOT EXECUTED
const char* table[] =
ffc133a8: 38 61 00 08 addi r3,r1,8 <== NOT EXECUTED
ffc133ac: 38 84 36 a4 addi r4,r4,13988 <== NOT EXECUTED
return 1;
}
}
else
{
if (strcmp (argv[arg], "set") == 0)
ffc133b0: 3d e0 ff c3 lis r15,-61 <== NOT EXECUTED
}
int
rtems_rfs_trace_shell_command (int argc, char *argv[])
{
const char* table[] =
ffc133b4: 48 00 f3 8d bl ffc22740 <memcpy> <== NOT EXECUTED
}
else
{
if (strcmp (argv[arg], "set") == 0)
set = true;
if (strcmp (argv[arg], "clear") == 0)
ffc133b8: 3e 00 ff c3 lis r16,-61 <== NOT EXECUTED
set = false;
else if (strcmp (argv[arg], "all") == 0)
ffc133bc: 3e 20 ff c3 lis r17,-61 <== NOT EXECUTED
}
int
rtems_rfs_trace_shell_command (int argc, char *argv[])
{
const char* table[] =
ffc133c0: 7f 73 db 78 mr r19,r27 <== NOT EXECUTED
rtems_rfs_trace_mask clear_value = 0;
bool set = true;
int arg;
int t;
for (arg = 1; arg < argc; arg++)
ffc133c4: 3a a0 00 01 li r21,1 <== NOT EXECUTED
"file-io"
};
rtems_rfs_trace_mask set_value = 0;
rtems_rfs_trace_mask clear_value = 0;
bool set = true;
ffc133c8: 3a e0 00 01 li r23,1 <== NOT EXECUTED
"file-close",
"file-io"
};
rtems_rfs_trace_mask set_value = 0;
rtems_rfs_trace_mask clear_value = 0;
ffc133cc: 3b 80 00 00 li r28,0 <== NOT EXECUTED
ffc133d0: 3b a0 00 00 li r29,0 <== NOT EXECUTED
"file-open",
"file-close",
"file-io"
};
rtems_rfs_trace_mask set_value = 0;
ffc133d4: 3b c0 00 00 li r30,0 <== NOT EXECUTED
ffc133d8: 3b e0 00 00 li r31,0 <== NOT EXECUTED
return 1;
}
}
else
{
if (strcmp (argv[arg], "set") == 0)
ffc133dc: 39 ef 37 a3 addi r15,r15,14243 <== NOT EXECUTED
set = true;
ffc133e0: 3a 80 00 01 li r20,1 <== NOT EXECUTED
if (strcmp (argv[arg], "clear") == 0)
ffc133e4: 3a 10 37 a7 addi r16,r16,14247 <== NOT EXECUTED
set = false;
else if (strcmp (argv[arg], "all") == 0)
ffc133e8: 3a 31 37 ad addi r17,r17,14253 <== NOT EXECUTED
}
}
}
rtems_rfs_trace_flags |= set_value;
rtems_rfs_trace_flags &= ~clear_value;
ffc133ec: 3e c0 00 00 lis r22,0 <== NOT EXECUTED
rtems_rfs_trace_mask clear_value = 0;
bool set = true;
int arg;
int t;
for (arg = 1; arg < argc; arg++)
ffc133f0: 48 00 01 78 b ffc13568 <rtems_rfs_trace_shell_command+0x1e0><== NOT EXECUTED
{
if (argv[arg][0] == '-')
ffc133f4: 87 33 00 04 lwzu r25,4(r19) <== NOT EXECUTED
ffc133f8: 88 19 00 00 lbz r0,0(r25) <== NOT EXECUTED
ffc133fc: 2f 80 00 2d cmpwi cr7,r0,45 <== NOT EXECUTED
ffc13400: 40 be 00 8c bne+ cr7,ffc1348c <rtems_rfs_trace_shell_command+0x104><== NOT EXECUTED
{
switch (argv[arg][1])
ffc13404: 88 19 00 01 lbz r0,1(r25) <== NOT EXECUTED
ffc13408: 2f 80 00 68 cmpwi cr7,r0,104 <== NOT EXECUTED
ffc1340c: 41 9e 00 10 beq- cr7,ffc1341c <rtems_rfs_trace_shell_command+0x94><== NOT EXECUTED
ffc13410: 2f 80 00 6c cmpwi cr7,r0,108 <== NOT EXECUTED
ffc13414: 40 be 00 64 bne+ cr7,ffc13478 <rtems_rfs_trace_shell_command+0xf0><== NOT EXECUTED
ffc13418: 48 00 00 1c b ffc13434 <rtems_rfs_trace_shell_command+0xac><== NOT EXECUTED
{
case 'h':
printf ("usage: %s [-hl] [set/clear] [flags]\n", argv[0]);
ffc1341c: 3c 60 ff c3 lis r3,-61 <== NOT EXECUTED
ffc13420: 80 9b 00 00 lwz r4,0(r27) <== NOT EXECUTED
ffc13424: 38 63 37 3c addi r3,r3,14140 <== NOT EXECUTED
ffc13428: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc1342c: 48 00 f6 bd bl ffc22ae8 <printf> <== NOT EXECUTED
ffc13430: 48 00 01 40 b ffc13570 <rtems_rfs_trace_shell_command+0x1e8><== NOT EXECUTED
return 0;
case 'l':
printf ("%s: valid flags to set or clear are:\n", argv[0]);
ffc13434: 3c 60 ff c3 lis r3,-61 <== NOT EXECUTED
ffc13438: 80 9b 00 00 lwz r4,0(r27) <== NOT EXECUTED
ffc1343c: 38 63 37 61 addi r3,r3,14177 <== NOT EXECUTED
for (t = 0; t < (sizeof (table) / sizeof (const char*)); t++)
printf (" %s\n", table[t]);
ffc13440: 3f 80 ff c3 lis r28,-61 <== 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]);
ffc13444: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc13448: 48 00 f6 a1 bl ffc22ae8 <printf> <== NOT EXECUTED
ffc1344c: 3b c0 00 00 li r30,0 <== NOT EXECUTED
for (t = 0; t < (sizeof (table) / sizeof (const char*)); t++)
printf (" %s\n", table[t]);
ffc13450: 3b 9c 37 87 addi r28,r28,14215 <== NOT EXECUTED
ffc13454: 39 21 00 08 addi r9,r1,8 <== NOT EXECUTED
ffc13458: 7c 89 f0 2e lwzx r4,r9,r30 <== NOT EXECUTED
ffc1345c: 7f 83 e3 78 mr r3,r28 <== NOT EXECUTED
ffc13460: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc13464: 48 00 f6 85 bl ffc22ae8 <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++)
ffc13468: 2f 9e 00 94 cmpwi cr7,r30,148 <== NOT EXECUTED
ffc1346c: 3b de 00 04 addi r30,r30,4 <== NOT EXECUTED
ffc13470: 40 9e ff e4 bne+ cr7,ffc13454 <rtems_rfs_trace_shell_command+0xcc><== NOT EXECUTED
ffc13474: 48 00 00 fc b ffc13570 <rtems_rfs_trace_shell_command+0x1e8><== NOT EXECUTED
printf (" %s\n", table[t]);
return 0;
default:
printf ("error: unknown option\n");
ffc13478: 3c 60 ff c3 lis r3,-61 <== NOT EXECUTED
ffc1347c: 38 63 37 8d addi r3,r3,14221 <== NOT EXECUTED
ffc13480: 48 00 f8 1d bl ffc22c9c <puts> <== NOT EXECUTED
return 1;
ffc13484: 38 60 00 01 li r3,1 <== NOT EXECUTED
ffc13488: 48 00 00 ec b ffc13574 <rtems_rfs_trace_shell_command+0x1ec><== NOT EXECUTED
}
}
else
{
if (strcmp (argv[arg], "set") == 0)
ffc1348c: 7f 23 cb 78 mr r3,r25 <== NOT EXECUTED
ffc13490: 7d e4 7b 78 mr r4,r15 <== NOT EXECUTED
ffc13494: 48 00 fd fd bl ffc23290 <strcmp> <== NOT EXECUTED
ffc13498: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc1349c: 40 9e 00 08 bne- cr7,ffc134a4 <rtems_rfs_trace_shell_command+0x11c><== NOT EXECUTED
set = true;
ffc134a0: 3a e0 00 01 li r23,1 <== NOT EXECUTED
if (strcmp (argv[arg], "clear") == 0)
ffc134a4: 7f 23 cb 78 mr r3,r25 <== NOT EXECUTED
ffc134a8: 7e 04 83 78 mr r4,r16 <== NOT EXECUTED
ffc134ac: 48 00 fd e5 bl ffc23290 <strcmp> <== NOT EXECUTED
ffc134b0: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc134b4: 41 9e 00 7c beq- cr7,ffc13530 <rtems_rfs_trace_shell_command+0x1a8><== NOT EXECUTED
set = false;
else if (strcmp (argv[arg], "all") == 0)
ffc134b8: 7f 23 cb 78 mr r3,r25 <== NOT EXECUTED
ffc134bc: 7e 24 8b 78 mr r4,r17 <== NOT EXECUTED
ffc134c0: 48 00 fd d1 bl ffc23290 <strcmp> <== NOT EXECUTED
ffc134c4: 3a 41 00 04 addi r18,r1,4 <== NOT EXECUTED
ffc134c8: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc134cc: 3b 00 00 00 li r24,0 <== NOT EXECUTED
ffc134d0: 40 9e 00 18 bne- cr7,ffc134e8 <rtems_rfs_trace_shell_command+0x160><== NOT EXECUTED
{
if (set)
ffc134d4: 2f 97 00 00 cmpwi cr7,r23,0 <== NOT EXECUTED
ffc134d8: 41 9e 00 60 beq- cr7,ffc13538 <rtems_rfs_trace_shell_command+0x1b0><== NOT EXECUTED
set_value = RTEMS_RFS_TRACE_ALL;
ffc134dc: 3b c0 ff ff li r30,-1 <== NOT EXECUTED
ffc134e0: 3b e0 ff ff li r31,-1 <== NOT EXECUTED
ffc134e4: 48 00 00 5c b ffc13540 <rtems_rfs_trace_shell_command+0x1b8><== NOT EXECUTED
}
else
{
for (t = 0; t < (sizeof (table) / sizeof (const char*)); t++)
{
if (strcmp (argv[arg], table[t]) == 0)
ffc134e8: 84 92 00 04 lwzu r4,4(r18) <== NOT EXECUTED
ffc134ec: 7f 23 cb 78 mr r3,r25 <== NOT EXECUTED
ffc134f0: 48 00 fd a1 bl ffc23290 <strcmp> <== NOT EXECUTED
ffc134f4: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc134f8: 40 be 00 28 bne+ cr7,ffc13520 <rtems_rfs_trace_shell_command+0x198><== NOT EXECUTED
{
if (set)
ffc134fc: 2f 97 00 00 cmpwi cr7,r23,0 <== NOT EXECUTED
set_value = 1 << t;
ffc13500: 7e 98 c0 30 slw r24,r20,r24 <== NOT EXECUTED
{
for (t = 0; t < (sizeof (table) / sizeof (const char*)); t++)
{
if (strcmp (argv[arg], table[t]) == 0)
{
if (set)
ffc13504: 41 9e 00 10 beq- cr7,ffc13514 <rtems_rfs_trace_shell_command+0x18c><== NOT EXECUTED
set_value = 1 << t;
ffc13508: 7f 1f c3 78 mr r31,r24 <== NOT EXECUTED
ffc1350c: 7f 1e fe 70 srawi r30,r24,31 <== NOT EXECUTED
ffc13510: 48 00 00 30 b ffc13540 <rtems_rfs_trace_shell_command+0x1b8><== NOT EXECUTED
else
clear_value = 1 << t;
ffc13514: 7f 1d c3 78 mr r29,r24 <== NOT EXECUTED
ffc13518: 7f 1c fe 70 srawi r28,r24,31 <== NOT EXECUTED
ffc1351c: 48 00 00 24 b ffc13540 <rtems_rfs_trace_shell_command+0x1b8><== NOT EXECUTED
else
clear_value = RTEMS_RFS_TRACE_ALL;
}
else
{
for (t = 0; t < (sizeof (table) / sizeof (const char*)); t++)
ffc13520: 2f 98 00 25 cmpwi cr7,r24,37 <== NOT EXECUTED
ffc13524: 3b 18 00 01 addi r24,r24,1 <== NOT EXECUTED
ffc13528: 40 9e ff c0 bne+ cr7,ffc134e8 <rtems_rfs_trace_shell_command+0x160><== NOT EXECUTED
ffc1352c: 48 00 00 14 b ffc13540 <rtems_rfs_trace_shell_command+0x1b8><== NOT EXECUTED
else
{
if (strcmp (argv[arg], "set") == 0)
set = true;
if (strcmp (argv[arg], "clear") == 0)
set = false;
ffc13530: 3a e0 00 00 li r23,0 <== NOT EXECUTED
ffc13534: 48 00 00 0c b ffc13540 <rtems_rfs_trace_shell_command+0x1b8><== NOT EXECUTED
else if (strcmp (argv[arg], "all") == 0)
{
if (set)
set_value = RTEMS_RFS_TRACE_ALL;
else
clear_value = RTEMS_RFS_TRACE_ALL;
ffc13538: 3b 80 ff ff li r28,-1 <== NOT EXECUTED
ffc1353c: 3b a0 ff ff li r29,-1 <== NOT EXECUTED
}
}
}
rtems_rfs_trace_flags |= set_value;
rtems_rfs_trace_flags &= ~clear_value;
ffc13540: 39 36 2a 68 addi r9,r22,10856 <== NOT EXECUTED
break;
}
}
}
rtems_rfs_trace_flags |= set_value;
ffc13544: 81 76 2a 68 lwz r11,10856(r22) <== NOT EXECUTED
ffc13548: 80 09 00 04 lwz r0,4(r9) <== NOT EXECUTED
rtems_rfs_trace_mask clear_value = 0;
bool set = true;
int arg;
int t;
for (arg = 1; arg < argc; arg++)
ffc1354c: 3a b5 00 01 addi r21,r21,1 <== NOT EXECUTED
break;
}
}
}
rtems_rfs_trace_flags |= set_value;
ffc13550: 7d 6b f3 78 or r11,r11,r30 <== NOT EXECUTED
ffc13554: 7c 00 fb 78 or r0,r0,r31 <== NOT EXECUTED
rtems_rfs_trace_flags &= ~clear_value;
ffc13558: 7d 6b e0 78 andc r11,r11,r28 <== NOT EXECUTED
ffc1355c: 7c 00 e8 78 andc r0,r0,r29 <== NOT EXECUTED
ffc13560: 91 76 2a 68 stw r11,10856(r22) <== NOT EXECUTED
ffc13564: 90 09 00 04 stw r0,4(r9) <== NOT EXECUTED
rtems_rfs_trace_mask clear_value = 0;
bool set = true;
int arg;
int t;
for (arg = 1; arg < argc; arg++)
ffc13568: 7f 95 d0 00 cmpw cr7,r21,r26 <== NOT EXECUTED
ffc1356c: 41 9c fe 88 blt+ cr7,ffc133f4 <rtems_rfs_trace_shell_command+0x6c><== NOT EXECUTED
rtems_rfs_trace_flags |= set_value;
rtems_rfs_trace_flags &= ~clear_value;
}
}
return 0;
ffc13570: 38 60 00 00 li r3,0 <== NOT EXECUTED
}
ffc13574: 39 61 00 f0 addi r11,r1,240 <== NOT EXECUTED
ffc13578: 4b fe f5 40 b ffc02ab8 <_restgpr_15_x> <== NOT EXECUTED
ffc1f37c <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)
{
ffc1f37c: 94 21 ff 88 stwu r1,-120(r1)
ffc1f380: 7c 08 02 a6 mflr r0
ffc1f384: bf 21 00 5c stmw r25,92(r1)
ffc1f388: 7c 7f 1b 78 mr r31,r3
ffc1f38c: 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))
ffc1f390: 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)
{
ffc1f394: 90 01 00 7c stw r0,124(r1)
rtems_rfs_inode_handle target_inode;
uint16_t links;
bool dir;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
ffc1f398: 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)
{
ffc1f39c: 7c be 2b 78 mr r30,r5
ffc1f3a0: 7c dc 33 78 mr r28,r6
ffc1f3a4: 7c fa 3b 78 mr r26,r7
rtems_rfs_inode_handle target_inode;
uint16_t links;
bool dir;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
ffc1f3a8: 4b ff 3f 5d bl ffc13304 <rtems_rfs_trace>
ffc1f3ac: 2f 83 00 00 cmpwi cr7,r3,0
ffc1f3b0: 41 be 00 1c beq+ cr7,ffc1f3cc <rtems_rfs_unlink+0x50> <== ALWAYS TAKEN
printf ("rtems-rfs: unlink: parent(%" PRIu32 ") -X-> (%" PRIu32 ")\n", parent, target);
ffc1f3b4: 3c 60 ff c3 lis r3,-61 <== NOT EXECUTED
ffc1f3b8: 38 63 54 3f addi r3,r3,21567 <== NOT EXECUTED
ffc1f3bc: 7f a4 eb 78 mr r4,r29 <== NOT EXECUTED
ffc1f3c0: 7f c5 f3 78 mr r5,r30 <== NOT EXECUTED
ffc1f3c4: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc1f3c8: 48 00 37 21 bl ffc22ae8 <printf> <== NOT EXECUTED
rc = rtems_rfs_inode_open (fs, target, &target_inode, true);
ffc1f3cc: 7f e3 fb 78 mr r3,r31
ffc1f3d0: 7f c4 f3 78 mr r4,r30
ffc1f3d4: 38 a1 00 08 addi r5,r1,8
ffc1f3d8: 38 c0 00 01 li r6,1
ffc1f3dc: 4b ff 1f 1d bl ffc112f8 <rtems_rfs_inode_open>
if (rc)
ffc1f3e0: 7c 79 1b 79 mr. r25,r3
ffc1f3e4: 40 82 03 4c bne- ffc1f730 <rtems_rfs_unlink+0x3b4> <== NEVER TAKEN
* @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);
ffc1f3e8: 81 21 00 14 lwz r9,20(r1)
ffc1f3ec: 8b 69 00 02 lbz r27,2(r9)
/*
* If a directory process the unlink mode.
*/
dir = RTEMS_RFS_S_ISDIR (rtems_rfs_inode_get_mode (&target_inode));
ffc1f3f0: 57 7b 44 26 rlwinm r27,r27,8,16,19
if (dir)
ffc1f3f4: 6b 7b 40 00 xori r27,r27,16384
ffc1f3f8: 7f 7b 00 34 cntlzw r27,r27
ffc1f3fc: 57 7b d9 7f rlwinm. r27,r27,27,5,31
ffc1f400: 41 82 00 8c beq- ffc1f48c <rtems_rfs_unlink+0x110> <== ALWAYS TAKEN
{
switch (dir_mode)
ffc1f404: 2f 9a 00 00 cmpwi cr7,r26,0 <== NOT EXECUTED
ffc1f408: 41 9e 00 10 beq- cr7,ffc1f418 <rtems_rfs_unlink+0x9c> <== NOT EXECUTED
ffc1f40c: 2f 9a 00 01 cmpwi cr7,r26,1 <== NOT EXECUTED
ffc1f410: 40 be 00 7c bne+ cr7,ffc1f48c <rtems_rfs_unlink+0x110> <== NOT EXECUTED
ffc1f414: 48 00 00 38 b ffc1f44c <rtems_rfs_unlink+0xd0> <== NOT EXECUTED
{
case rtems_rfs_unlink_dir_denied:
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
ffc1f418: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc1f41c: 3c 80 02 00 lis r4,512 <== NOT EXECUTED
ffc1f420: 4b ff 3e e5 bl ffc13304 <rtems_rfs_trace> <== NOT EXECUTED
ffc1f424: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc1f428: 41 be 00 10 beq+ cr7,ffc1f438 <rtems_rfs_unlink+0xbc> <== NOT EXECUTED
printf ("rtems-rfs: link is a directory\n");
ffc1f42c: 3c 60 ff c3 lis r3,-61 <== NOT EXECUTED
ffc1f430: 38 63 54 6a addi r3,r3,21610 <== NOT EXECUTED
ffc1f434: 48 00 38 69 bl ffc22c9c <puts> <== NOT EXECUTED
rtems_rfs_inode_close (fs, &target_inode);
ffc1f438: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc1f43c: 38 81 00 08 addi r4,r1,8 <== NOT EXECUTED
ffc1f440: 4b ff 20 a9 bl ffc114e8 <rtems_rfs_inode_close> <== NOT EXECUTED
return EISDIR;
ffc1f444: 3b 20 00 15 li r25,21 <== NOT EXECUTED
ffc1f448: 48 00 02 e8 b ffc1f730 <rtems_rfs_unlink+0x3b4> <== NOT EXECUTED
case rtems_rfs_unlink_dir_if_empty:
rc = rtems_rfs_dir_empty (fs, &target_inode);
ffc1f44c: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc1f450: 38 81 00 08 addi r4,r1,8 <== NOT EXECUTED
ffc1f454: 4b ff e4 55 bl ffc1d8a8 <rtems_rfs_dir_empty> <== NOT EXECUTED
if (rc > 0)
ffc1f458: 7c 79 1b 79 mr. r25,r3 <== NOT EXECUTED
ffc1f45c: 40 81 00 30 ble- ffc1f48c <rtems_rfs_unlink+0x110> <== NOT EXECUTED
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
ffc1f460: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc1f464: 3c 80 02 00 lis r4,512 <== NOT EXECUTED
ffc1f468: 4b ff 3e 9d bl ffc13304 <rtems_rfs_trace> <== NOT EXECUTED
ffc1f46c: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc1f470: 41 be 02 68 beq+ cr7,ffc1f6d8 <rtems_rfs_unlink+0x35c> <== NOT EXECUTED
printf ("rtems-rfs: dir-empty: %d: %s\n", rc, strerror (rc));
ffc1f474: 7f 23 cb 78 mr r3,r25 <== NOT EXECUTED
ffc1f478: 48 00 43 dd bl ffc23854 <strerror> <== NOT EXECUTED
ffc1f47c: 7c 65 1b 78 mr r5,r3 <== NOT EXECUTED
ffc1f480: 3c 60 ff c3 lis r3,-61 <== NOT EXECUTED
ffc1f484: 38 63 54 89 addi r3,r3,21641 <== NOT EXECUTED
ffc1f488: 48 00 02 44 b ffc1f6cc <rtems_rfs_unlink+0x350> <== NOT EXECUTED
default:
break;
}
}
rc = rtems_rfs_inode_open (fs, parent, &parent_inode, true);
ffc1f48c: 7f e3 fb 78 mr r3,r31
ffc1f490: 7f a4 eb 78 mr r4,r29
ffc1f494: 38 a1 00 30 addi r5,r1,48
ffc1f498: 38 c0 00 01 li r6,1
ffc1f49c: 4b ff 1e 5d bl ffc112f8 <rtems_rfs_inode_open>
if (rc)
ffc1f4a0: 7c 79 1b 79 mr. r25,r3
ffc1f4a4: 41 82 00 30 beq- ffc1f4d4 <rtems_rfs_unlink+0x158> <== ALWAYS TAKEN
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
ffc1f4a8: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc1f4ac: 3c 80 02 00 lis r4,512 <== NOT EXECUTED
ffc1f4b0: 4b ff 3e 55 bl ffc13304 <rtems_rfs_trace> <== NOT EXECUTED
ffc1f4b4: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc1f4b8: 41 be 02 20 beq+ cr7,ffc1f6d8 <rtems_rfs_unlink+0x35c> <== NOT EXECUTED
printf ("rtems-rfs: link: inode-open failed: %d: %s\n",
ffc1f4bc: 7f 23 cb 78 mr r3,r25 <== NOT EXECUTED
ffc1f4c0: 48 00 43 95 bl ffc23854 <strerror> <== NOT EXECUTED
ffc1f4c4: 7c 65 1b 78 mr r5,r3 <== NOT EXECUTED
ffc1f4c8: 3c 60 ff c3 lis r3,-61 <== NOT EXECUTED
ffc1f4cc: 38 63 54 a7 addi r3,r3,21671 <== NOT EXECUTED
ffc1f4d0: 48 00 01 fc b ffc1f6cc <rtems_rfs_unlink+0x350> <== NOT EXECUTED
rc, strerror (rc));
rtems_rfs_inode_close (fs, &target_inode);
return rc;
}
rc = rtems_rfs_dir_del_entry (fs, &parent_inode, target, doff);
ffc1f4d4: 7f e3 fb 78 mr r3,r31
ffc1f4d8: 38 81 00 30 addi r4,r1,48
ffc1f4dc: 7f c5 f3 78 mr r5,r30
ffc1f4e0: 7f 86 e3 78 mr r6,r28
ffc1f4e4: 4b ff dc 5d bl ffc1d140 <rtems_rfs_dir_del_entry>
if (rc > 0)
ffc1f4e8: 7c 79 1b 79 mr. r25,r3
ffc1f4ec: 40 81 00 30 ble- ffc1f51c <rtems_rfs_unlink+0x1a0> <== ALWAYS TAKEN
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
ffc1f4f0: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc1f4f4: 3c 80 02 00 lis r4,512 <== NOT EXECUTED
ffc1f4f8: 4b ff 3e 0d bl ffc13304 <rtems_rfs_trace> <== NOT EXECUTED
ffc1f4fc: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc1f500: 41 be 01 80 beq+ cr7,ffc1f680 <rtems_rfs_unlink+0x304> <== NOT EXECUTED
printf ("rtems-rfs: unlink: dir-del failed: %d: %s\n",
ffc1f504: 7f 23 cb 78 mr r3,r25 <== NOT EXECUTED
ffc1f508: 48 00 43 4d bl ffc23854 <strerror> <== NOT EXECUTED
ffc1f50c: 7c 65 1b 78 mr r5,r3 <== NOT EXECUTED
ffc1f510: 3c 60 ff c3 lis r3,-61 <== NOT EXECUTED
ffc1f514: 38 63 54 d3 addi r3,r3,21715 <== NOT EXECUTED
ffc1f518: 48 00 01 5c b ffc1f674 <rtems_rfs_unlink+0x2f8> <== 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);
ffc1f51c: 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);
ffc1f520: 8b a9 00 00 lbz r29,0(r9)
ffc1f524: 88 09 00 01 lbz r0,1(r9)
ffc1f528: 57 bd 40 2e rlwinm r29,r29,8,0,23
ffc1f52c: 7f bd 03 78 or r29,r29,r0
if (links == 0xffff)
ffc1f530: 6f a0 ff ff xoris r0,r29,65535
ffc1f534: 2f 80 ff ff cmpwi cr7,r0,-1
ffc1f538: 40 9e 00 08 bne- cr7,ffc1f540 <rtems_rfs_unlink+0x1c4> <== ALWAYS TAKEN
links = 0;
ffc1f53c: 3b a0 00 00 li r29,0 <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
ffc1f540: 38 60 00 00 li r3,0
ffc1f544: 3c 80 02 00 lis r4,512
ffc1f548: 4b ff 3d bd bl ffc13304 <rtems_rfs_trace>
ffc1f54c: 2f 83 00 00 cmpwi cr7,r3,0
ffc1f550: 41 be 00 1c beq+ cr7,ffc1f56c <rtems_rfs_unlink+0x1f0> <== ALWAYS TAKEN
printf ("rtems-rfs: unlink: target:%" PRIu32 " links:%u\n", target, links);
ffc1f554: 3c 60 ff c3 lis r3,-61 <== NOT EXECUTED
ffc1f558: 38 63 54 fe addi r3,r3,21758 <== NOT EXECUTED
ffc1f55c: 7f c4 f3 78 mr r4,r30 <== NOT EXECUTED
ffc1f560: 7f a5 eb 78 mr r5,r29 <== NOT EXECUTED
ffc1f564: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc1f568: 48 00 35 81 bl ffc22ae8 <printf> <== NOT EXECUTED
if (links > 1)
ffc1f56c: 2b 9d 00 01 cmplwi cr7,r29,1
ffc1f570: 40 9d 00 2c ble- cr7,ffc1f59c <rtems_rfs_unlink+0x220>
{
links--;
ffc1f574: 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);
ffc1f578: 81 21 00 14 lwz r9,20(r1)
ffc1f57c: 57 bd 04 3e clrlwi r29,r29,16
ffc1f580: 57 a0 c2 3e rlwinm r0,r29,24,8,31
ffc1f584: 98 09 00 00 stb r0,0(r9)
rtems_rfs_buffer_mark_dirty (&handle->buffer);
ffc1f588: 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);
ffc1f58c: 81 21 00 14 lwz r9,20(r1)
ffc1f590: 9b a9 00 01 stb r29,1(r9)
rtems_rfs_buffer_mark_dirty (&handle->buffer);
ffc1f594: 98 01 00 18 stb r0,24(r1)
ffc1f598: 48 00 00 9c b ffc1f634 <rtems_rfs_unlink+0x2b8>
else
{
/*
* Erasing the inode releases all blocks attached to it.
*/
rc = rtems_rfs_inode_delete (fs, &target_inode);
ffc1f59c: 7f e3 fb 78 mr r3,r31
ffc1f5a0: 38 81 00 08 addi r4,r1,8
ffc1f5a4: 4b ff 1f e9 bl ffc1158c <rtems_rfs_inode_delete>
if (rc > 0)
ffc1f5a8: 7c 79 1b 79 mr. r25,r3
ffc1f5ac: 40 81 00 30 ble- ffc1f5dc <rtems_rfs_unlink+0x260> <== ALWAYS TAKEN
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
ffc1f5b0: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc1f5b4: 3c 80 02 00 lis r4,512 <== NOT EXECUTED
ffc1f5b8: 4b ff 3d 4d bl ffc13304 <rtems_rfs_trace> <== NOT EXECUTED
ffc1f5bc: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc1f5c0: 41 be 00 c0 beq+ cr7,ffc1f680 <rtems_rfs_unlink+0x304> <== NOT EXECUTED
printf ("rtems-rfs: unlink: inode-del failed: %d: %s\n",
ffc1f5c4: 7f 23 cb 78 mr r3,r25 <== NOT EXECUTED
ffc1f5c8: 48 00 42 8d bl ffc23854 <strerror> <== NOT EXECUTED
ffc1f5cc: 7c 65 1b 78 mr r5,r3 <== NOT EXECUTED
ffc1f5d0: 3c 60 ff c3 lis r3,-61 <== NOT EXECUTED
ffc1f5d4: 38 63 55 26 addi r3,r3,21798 <== NOT EXECUTED
ffc1f5d8: 48 00 00 9c b ffc1f674 <rtems_rfs_unlink+0x2f8> <== NOT EXECUTED
rtems_rfs_inode_close (fs, &parent_inode);
rtems_rfs_inode_close (fs, &target_inode);
return rc;
}
if (dir)
ffc1f5dc: 2f 9b 00 00 cmpwi cr7,r27,0
ffc1f5e0: 41 9e 00 54 beq- cr7,ffc1f634 <rtems_rfs_unlink+0x2b8> <== ALWAYS TAKEN
{
links = rtems_rfs_inode_get_links (&parent_inode);
ffc1f5e4: 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);
ffc1f5e8: 89 2b 00 00 lbz r9,0(r11) <== NOT EXECUTED
ffc1f5ec: 88 0b 00 01 lbz r0,1(r11) <== NOT EXECUTED
ffc1f5f0: 55 29 40 2e rlwinm r9,r9,8,0,23 <== NOT EXECUTED
ffc1f5f4: 7d 29 03 78 or r9,r9,r0 <== NOT EXECUTED
if (links == 0xffff)
ffc1f5f8: 6d 20 ff ff xoris r0,r9,65535 <== NOT EXECUTED
ffc1f5fc: 2f 80 ff ff cmpwi cr7,r0,-1 <== NOT EXECUTED
ffc1f600: 41 9e 00 18 beq- cr7,ffc1f618 <rtems_rfs_unlink+0x29c> <== NOT EXECUTED
if (links > 1)
ffc1f604: 2b 89 00 01 cmplwi cr7,r9,1 <== NOT EXECUTED
ffc1f608: 40 9d 00 14 ble- cr7,ffc1f61c <rtems_rfs_unlink+0x2a0> <== NOT EXECUTED
links--;
ffc1f60c: 39 29 ff ff addi r9,r9,-1 <== NOT EXECUTED
ffc1f610: 55 29 04 3e clrlwi r9,r9,16 <== NOT EXECUTED
ffc1f614: 48 00 00 08 b ffc1f61c <rtems_rfs_unlink+0x2a0> <== NOT EXECUTED
links = 0;
ffc1f618: 39 20 00 00 li r9,0 <== 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);
ffc1f61c: 55 20 c2 3e rlwinm r0,r9,24,8,31 <== NOT EXECUTED
ffc1f620: 98 0b 00 00 stb r0,0(r11) <== NOT EXECUTED
rtems_rfs_buffer_mark_dirty (&handle->buffer);
ffc1f624: 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);
ffc1f628: 81 61 00 3c lwz r11,60(r1) <== NOT EXECUTED
ffc1f62c: 99 2b 00 01 stb r9,1(r11) <== NOT EXECUTED
rtems_rfs_buffer_mark_dirty (&handle->buffer);
ffc1f630: 98 01 00 40 stb r0,64(r1) <== NOT EXECUTED
rtems_rfs_inode_set_links (&parent_inode, links);
}
}
rc = rtems_rfs_inode_time_stamp_now (&parent_inode, true, true);
ffc1f634: 38 61 00 30 addi r3,r1,48
ffc1f638: 38 80 00 01 li r4,1
ffc1f63c: 38 a0 00 01 li r5,1
ffc1f640: 4b ff 20 39 bl ffc11678 <rtems_rfs_inode_time_stamp_now>
if (rc > 0)
ffc1f644: 7c 79 1b 79 mr. r25,r3
ffc1f648: 40 81 00 48 ble- ffc1f690 <rtems_rfs_unlink+0x314> <== ALWAYS TAKEN
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
ffc1f64c: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc1f650: 3c 80 02 00 lis r4,512 <== NOT EXECUTED
ffc1f654: 4b ff 3c b1 bl ffc13304 <rtems_rfs_trace> <== NOT EXECUTED
ffc1f658: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc1f65c: 41 be 00 24 beq+ cr7,ffc1f680 <rtems_rfs_unlink+0x304> <== NOT EXECUTED
printf ("rtems-rfs: link: inode-time-stamp failed: %d: %s\n",
ffc1f660: 7f 23 cb 78 mr r3,r25 <== NOT EXECUTED
ffc1f664: 48 00 41 f1 bl ffc23854 <strerror> <== NOT EXECUTED
ffc1f668: 7c 65 1b 78 mr r5,r3 <== NOT EXECUTED
ffc1f66c: 3c 60 ff c3 lis r3,-61 <== NOT EXECUTED
ffc1f670: 38 63 55 53 addi r3,r3,21843 <== NOT EXECUTED
ffc1f674: 7f 24 cb 78 mr r4,r25 <== NOT EXECUTED
ffc1f678: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc1f67c: 48 00 34 6d bl ffc22ae8 <printf> <== NOT EXECUTED
rc, strerror (rc));
rtems_rfs_inode_close (fs, &parent_inode);
ffc1f680: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc1f684: 38 81 00 30 addi r4,r1,48 <== NOT EXECUTED
ffc1f688: 4b ff 1e 61 bl ffc114e8 <rtems_rfs_inode_close> <== NOT EXECUTED
ffc1f68c: 48 00 00 4c b ffc1f6d8 <rtems_rfs_unlink+0x35c> <== NOT EXECUTED
rtems_rfs_inode_close (fs, &target_inode);
return rc;
}
rc = rtems_rfs_inode_close (fs, &parent_inode);
ffc1f690: 7f e3 fb 78 mr r3,r31
ffc1f694: 38 81 00 30 addi r4,r1,48
ffc1f698: 4b ff 1e 51 bl ffc114e8 <rtems_rfs_inode_close>
if (rc > 0)
ffc1f69c: 7c 79 1b 79 mr. r25,r3
ffc1f6a0: 40 81 00 48 ble- ffc1f6e8 <rtems_rfs_unlink+0x36c> <== ALWAYS TAKEN
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
ffc1f6a4: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc1f6a8: 3c 80 02 00 lis r4,512 <== NOT EXECUTED
ffc1f6ac: 4b ff 3c 59 bl ffc13304 <rtems_rfs_trace> <== NOT EXECUTED
ffc1f6b0: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc1f6b4: 41 be 00 24 beq+ cr7,ffc1f6d8 <rtems_rfs_unlink+0x35c> <== NOT EXECUTED
printf ("rtems-rfs: link: parent inode-close failed: %d: %s\n",
ffc1f6b8: 7f 23 cb 78 mr r3,r25 <== NOT EXECUTED
ffc1f6bc: 48 00 41 99 bl ffc23854 <strerror> <== NOT EXECUTED
ffc1f6c0: 7c 65 1b 78 mr r5,r3 <== NOT EXECUTED
ffc1f6c4: 3c 60 ff c3 lis r3,-61 <== NOT EXECUTED
ffc1f6c8: 38 63 55 85 addi r3,r3,21893 <== NOT EXECUTED
ffc1f6cc: 7f 24 cb 78 mr r4,r25 <== NOT EXECUTED
ffc1f6d0: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc1f6d4: 48 00 34 15 bl ffc22ae8 <printf> <== NOT EXECUTED
rc, strerror (rc));
rtems_rfs_inode_close (fs, &target_inode);
ffc1f6d8: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc1f6dc: 38 81 00 08 addi r4,r1,8 <== NOT EXECUTED
ffc1f6e0: 4b ff 1e 09 bl ffc114e8 <rtems_rfs_inode_close> <== NOT EXECUTED
return rc;
ffc1f6e4: 48 00 00 4c b ffc1f730 <rtems_rfs_unlink+0x3b4> <== NOT EXECUTED
}
rc = rtems_rfs_inode_close (fs, &target_inode);
ffc1f6e8: 7f e3 fb 78 mr r3,r31
ffc1f6ec: 38 81 00 08 addi r4,r1,8
ffc1f6f0: 4b ff 1d f9 bl ffc114e8 <rtems_rfs_inode_close>
if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
ffc1f6f4: 7c 79 1b 79 mr. r25,r3
ffc1f6f8: 40 81 00 38 ble- ffc1f730 <rtems_rfs_unlink+0x3b4> <== ALWAYS TAKEN
ffc1f6fc: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc1f700: 3c 80 02 00 lis r4,512 <== NOT EXECUTED
ffc1f704: 4b ff 3c 01 bl ffc13304 <rtems_rfs_trace> <== NOT EXECUTED
ffc1f708: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc1f70c: 41 be 00 24 beq+ cr7,ffc1f730 <rtems_rfs_unlink+0x3b4> <== NOT EXECUTED
printf ("rtems-rfs: link: target inode-close failed: %d: %s\n",
ffc1f710: 7f 23 cb 78 mr r3,r25 <== NOT EXECUTED
ffc1f714: 48 00 41 41 bl ffc23854 <strerror> <== NOT EXECUTED
ffc1f718: 7f 24 cb 78 mr r4,r25 <== NOT EXECUTED
ffc1f71c: 7c 65 1b 78 mr r5,r3 <== NOT EXECUTED
ffc1f720: 3c 60 ff c3 lis r3,-61 <== NOT EXECUTED
ffc1f724: 38 63 55 b9 addi r3,r3,21945 <== NOT EXECUTED
ffc1f728: 4c c6 31 82 crclr 4*cr1+eq <== NOT EXECUTED
ffc1f72c: 48 00 33 bd bl ffc22ae8 <printf> <== NOT EXECUTED
rc, strerror (rc));
return rc;
}
ffc1f730: 39 61 00 78 addi r11,r1,120
ffc1f734: 7f 23 cb 78 mr r3,r25
ffc1f738: 4b fe 33 a8 b ffc02ae0 <_restgpr_25_x>
ffc17c98 <rtems_signal_send>:
rtems_status_code rtems_signal_send(
rtems_id id,
rtems_signal_set signal_set
)
{
ffc17c98: 7c 2b 0b 78 mr r11,r1
ffc17c9c: 94 21 ff e0 stwu r1,-32(r1)
ffc17ca0: 7c 08 02 a6 mflr r0
ffc17ca4: 48 01 74 e9 bl ffc2f18c <_savegpr_31>
register Thread_Control *the_thread;
Objects_Locations location;
RTEMS_API_Control *api;
ASR_Information *asr;
if ( !signal_set )
ffc17ca8: 7c 9f 23 79 mr. r31,r4
rtems_status_code rtems_signal_send(
rtems_id id,
rtems_signal_set signal_set
)
{
ffc17cac: 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;
ffc17cb0: 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 )
ffc17cb4: 41 a2 00 ac beq+ ffc17d60 <rtems_signal_send+0xc8>
return RTEMS_INVALID_NUMBER;
the_thread = _Thread_Get( id, &location );
ffc17cb8: 38 81 00 08 addi r4,r1,8
ffc17cbc: 48 00 4c a5 bl ffc1c960 <_Thread_Get>
switch ( location ) {
ffc17cc0: 80 01 00 08 lwz r0,8(r1)
ffc17cc4: 2f 80 00 00 cmpwi cr7,r0,0
ffc17cc8: 40 9e 00 94 bne- cr7,ffc17d5c <rtems_signal_send+0xc4>
case OBJECTS_LOCAL:
api = the_thread->API_Extensions[ THREAD_API_RTEMS ];
ffc17ccc: 81 23 01 30 lwz r9,304(r3)
asr = &api->Signal;
if ( ! _ASR_Is_null_handler( asr->handler ) ) {
ffc17cd0: 80 09 00 0c lwz r0,12(r9)
ffc17cd4: 2f 80 00 00 cmpwi cr7,r0,0
ffc17cd8: 41 9e 00 78 beq- cr7,ffc17d50 <rtems_signal_send+0xb8>
if ( asr->is_enabled ) {
ffc17cdc: 88 09 00 08 lbz r0,8(r9)
ffc17ce0: 2f 80 00 00 cmpwi cr7,r0,0
static inline uint32_t ppc_interrupt_disable( void )
{
uint32_t level;
uint32_t mask;
__asm__ volatile (
ffc17ce4: 7c 00 00 a6 mfmsr r0
ffc17ce8: 7d 70 42 a6 mfsprg r11,0
ffc17cec: 7c 0b 58 78 andc r11,r0,r11
ffc17cf0: 7d 60 01 24 mtmsr r11
ffc17cf4: 41 9e 00 40 beq- cr7,ffc17d34 <rtems_signal_send+0x9c>
)
{
ISR_Level _level;
_ISR_Disable( _level );
*signal_set |= signals;
ffc17cf8: 81 69 00 14 lwz r11,20(r9)
ffc17cfc: 7d 7f fb 78 or r31,r11,r31
ffc17d00: 93 e9 00 14 stw r31,20(r9)
return level;
}
static inline void ppc_interrupt_enable( uint32_t level )
{
__asm__ volatile (
ffc17d04: 7c 00 01 24 mtmsr r0
_ASR_Post_signals( signal_set, &asr->signals_posted );
if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
ffc17d08: 3d 20 00 00 lis r9,0
ffc17d0c: 39 29 75 44 addi r9,r9,30020
ffc17d10: 80 09 00 08 lwz r0,8(r9)
ffc17d14: 2f 80 00 00 cmpwi cr7,r0,0
ffc17d18: 41 9e 00 2c beq- cr7,ffc17d44 <rtems_signal_send+0xac>
ffc17d1c: 80 09 00 0c lwz r0,12(r9)
ffc17d20: 7f 83 00 00 cmpw cr7,r3,r0
ffc17d24: 40 be 00 20 bne+ cr7,ffc17d44 <rtems_signal_send+0xac> <== NEVER TAKEN
_Thread_Dispatch_necessary = true;
ffc17d28: 38 00 00 01 li r0,1
ffc17d2c: 98 09 00 18 stb r0,24(r9)
ffc17d30: 48 00 00 14 b ffc17d44 <rtems_signal_send+0xac>
ffc17d34: 81 69 00 18 lwz r11,24(r9)
ffc17d38: 7d 7f fb 78 or r31,r11,r31
ffc17d3c: 93 e9 00 18 stw r31,24(r9)
ffc17d40: 7c 00 01 24 mtmsr r0
} else {
_ASR_Post_signals( signal_set, &asr->signals_pending );
}
_Thread_Enable_dispatch();
ffc17d44: 48 00 4b e1 bl ffc1c924 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
ffc17d48: 38 00 00 00 li r0,0
ffc17d4c: 48 00 00 14 b ffc17d60 <rtems_signal_send+0xc8>
}
_Thread_Enable_dispatch();
ffc17d50: 48 00 4b d5 bl ffc1c924 <_Thread_Enable_dispatch>
return RTEMS_NOT_DEFINED;
ffc17d54: 38 00 00 0b li r0,11
ffc17d58: 48 00 00 08 b ffc17d60 <rtems_signal_send+0xc8>
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
ffc17d5c: 38 00 00 04 li r0,4
}
ffc17d60: 39 61 00 20 addi r11,r1,32
ffc17d64: 7c 03 03 78 mr r3,r0
ffc17d68: 4b ff 64 38 b ffc0e1a0 <_restgpr_31_x>
ffc043a4 <rtems_stack_checker_begin_extension>:
* rtems_stack_checker_Begin_extension
*/
void rtems_stack_checker_begin_extension(
Thread_Control *the_thread
)
{
ffc043a4: 7c 08 02 a6 mflr r0
ffc043a8: 94 21 ff f8 stwu r1,-8(r1)
ffc043ac: 90 01 00 0c stw r0,12(r1)
Stack_check_Control *the_pattern;
if ( the_thread->Object.id == 0 ) /* skip system tasks */
ffc043b0: 80 03 00 08 lwz r0,8(r3)
ffc043b4: 2f 80 00 00 cmpwi cr7,r0,0
ffc043b8: 41 9e 00 1c beq- cr7,ffc043d4 <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;
ffc043bc: 80 63 00 bc lwz r3,188(r3)
ffc043c0: 3c 80 00 00 lis r4,0
ffc043c4: 38 84 2b 68 addi r4,r4,11112
ffc043c8: 38 63 00 08 addi r3,r3,8
ffc043cc: 38 a0 00 80 li r5,128
ffc043d0: 48 00 fb 99 bl ffc13f68 <memcpy>
}
ffc043d4: 80 01 00 0c lwz r0,12(r1)
ffc043d8: 38 21 00 08 addi r1,r1,8
ffc043dc: 7c 08 03 a6 mtlr r0
ffc043e0: 4e 80 00 20 blr
ffc04364 <rtems_stack_checker_create_extension>:
*/
bool rtems_stack_checker_create_extension(
Thread_Control *running __attribute__((unused)),
Thread_Control *the_thread
)
{
ffc04364: 7c 2b 0b 78 mr r11,r1
ffc04368: 94 21 ff f0 stwu r1,-16(r1)
ffc0436c: 7c 08 02 a6 mflr r0
ffc04370: 4b ff c7 4d bl ffc00abc <_savegpr_31>
ffc04374: 7c 9f 23 78 mr r31,r4
ffc04378: 90 01 00 14 stw r0,20(r1)
Stack_check_Initialize();
ffc0437c: 4b ff ff 99 bl ffc04314 <Stack_check_Initialize>
if (the_thread)
ffc04380: 2f 9f 00 00 cmpwi cr7,r31,0
ffc04384: 41 9e 00 14 beq- cr7,ffc04398 <rtems_stack_checker_create_extension+0x34><== NEVER TAKEN
Stack_check_Dope_stack(&the_thread->Start.Initial_stack);
ffc04388: 80 7f 00 bc lwz r3,188(r31)
ffc0438c: 38 80 00 a5 li r4,165
ffc04390: 80 bf 00 b8 lwz r5,184(r31)
ffc04394: 48 00 fc b9 bl ffc1404c <memset>
return true;
}
ffc04398: 39 61 00 10 addi r11,r1,16
ffc0439c: 38 60 00 01 li r3,1
ffc043a0: 4b ff c7 68 b ffc00b08 <_restgpr_31_x>
ffc04530 <rtems_stack_checker_is_blown>:
/*
* Check if blown
*/
bool rtems_stack_checker_is_blown( void )
{
ffc04530: 94 21 ff f0 stwu r1,-16(r1)
ffc04534: 7c 08 02 a6 mflr r0
Stack_Control *the_stack = &_Thread_Executing->Start.Initial_stack;
ffc04538: 3d 20 00 00 lis r9,0
/*
* Check if blown
*/
bool rtems_stack_checker_is_blown( void )
{
ffc0453c: 90 01 00 14 stw r0,20(r1)
Stack_Control *the_stack = &_Thread_Executing->Start.Initial_stack;
ffc04540: 81 29 32 50 lwz r9,12880(r9)
/*
* Check if blown
*/
bool rtems_stack_checker_is_blown( void )
{
ffc04544: bf c1 00 08 stmw r30,8(r1)
ffc04548: 7c 3f 0b 78 mr r31,r1
{
#if defined(__GNUC__)
void *sp = __builtin_frame_address(0);
if ( sp < the_stack->area ) {
return false;
ffc0454c: 3b c0 00 00 li r30,0
)
{
#if defined(__GNUC__)
void *sp = __builtin_frame_address(0);
if ( sp < the_stack->area ) {
ffc04550: 80 69 00 bc lwz r3,188(r9)
ffc04554: 7f 9f 18 40 cmplw cr7,r31,r3
ffc04558: 41 9c 00 18 blt- cr7,ffc04570 <rtems_stack_checker_is_blown+0x40><== NEVER TAKEN
return false;
}
if ( sp > (the_stack->area + the_stack->size) ) {
ffc0455c: 83 c9 00 b8 lwz r30,184(r9)
ffc04560: 7f c3 f2 14 add r30,r3,r30
}
/*
* Check if blown
*/
bool rtems_stack_checker_is_blown( void )
ffc04564: 7f df f0 10 subfc r30,r31,r30
ffc04568: 3b c0 00 00 li r30,0
ffc0456c: 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 ) {
ffc04570: 3d 20 00 00 lis r9,0
ffc04574: 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;
ffc04578: 38 80 00 01 li r4,1
/*
* The stack checker must be initialized before the pattern is there
* to check.
*/
if ( Stack_check_Initialized ) {
ffc0457c: 2f 80 00 00 cmpwi cr7,r0,0
ffc04580: 41 9e 00 20 beq- cr7,ffc045a0 <rtems_stack_checker_is_blown+0x70><== NEVER TAKEN
pattern_ok = (!memcmp(
ffc04584: 3c 80 00 00 lis r4,0
ffc04588: 38 84 2b 68 addi r4,r4,11112
ffc0458c: 38 63 00 08 addi r3,r3,8
ffc04590: 38 a0 00 80 li r5,128
ffc04594: 48 00 f9 31 bl ffc13ec4 <memcmp>
ffc04598: 7c 64 00 34 cntlzw r4,r3
ffc0459c: 54 84 d9 7e rlwinm r4,r4,27,5,31
/*
* Let's report as much as we can.
*/
if ( !sp_ok || !pattern_ok ) {
ffc045a0: 2f 9e 00 00 cmpwi cr7,r30,0
ffc045a4: 41 9e 00 0c beq- cr7,ffc045b0 <rtems_stack_checker_is_blown+0x80><== NEVER TAKEN
ffc045a8: 2f 84 00 00 cmpwi cr7,r4,0
ffc045ac: 40 be 00 10 bne+ cr7,ffc045bc <rtems_stack_checker_is_blown+0x8c><== ALWAYS TAKEN
Stack_check_report_blown_task( _Thread_Executing, pattern_ok );
ffc045b0: 3d 20 00 00 lis r9,0 <== NOT EXECUTED
ffc045b4: 80 69 32 50 lwz r3,12880(r9) <== NOT EXECUTED
ffc045b8: 4b ff fe 2d bl ffc043e4 <Stack_check_report_blown_task><== NOT EXECUTED
/*
* The Stack Pointer and the Pattern Area are OK so return false.
*/
return false;
}
ffc045bc: 39 7f 00 10 addi r11,r31,16
ffc045c0: 38 60 00 00 li r3,0
ffc045c4: 4b ff c5 40 b ffc00b04 <_restgpr_30_x>
ffc045c8 <rtems_stack_checker_report_usage_with_plugin>:
void rtems_stack_checker_report_usage_with_plugin(
void *context,
rtems_printk_plugin_t print
)
{
ffc045c8: 94 21 ff e8 stwu r1,-24(r1)
ffc045cc: 7c 08 02 a6 mflr r0
ffc045d0: bf 81 00 08 stmw r28,8(r1)
if ( !print )
ffc045d4: 7c 9e 23 79 mr. r30,r4
void rtems_stack_checker_report_usage_with_plugin(
void *context,
rtems_printk_plugin_t print
)
{
ffc045d8: 7c 7c 1b 78 mr r28,r3
ffc045dc: 90 01 00 1c stw r0,28(r1)
if ( !print )
ffc045e0: 41 82 00 58 beq- ffc04638 <rtems_stack_checker_report_usage_with_plugin+0x70><== NEVER TAKEN
return;
print_context = context;
ffc045e4: 3f e0 00 00 lis r31,0
print_handler = print;
(*print)( context, "Stack usage by thread\n");
ffc045e8: 7f c9 03 a6 mtctr r30
)
{
if ( !print )
return;
print_context = context;
ffc045ec: 3b bf 28 f4 addi r29,r31,10484
print_handler = print;
ffc045f0: 93 df 28 f4 stw r30,10484(r31)
(*print)( context, "Stack usage by thread\n");
ffc045f4: 3c 80 ff c2 lis r4,-62
ffc045f8: 38 84 a1 de addi r4,r4,-24098
)
{
if ( !print )
return;
print_context = context;
ffc045fc: 90 7d 00 04 stw r3,4(r29)
print_handler = print;
(*print)( context, "Stack usage by thread\n");
ffc04600: 4c c6 31 82 crclr 4*cr1+eq
ffc04604: 4e 80 04 21 bctrl
(*print)( context,
ffc04608: 3c 80 ff c2 lis r4,-62
ffc0460c: 38 84 a1 f5 addi r4,r4,-24075
ffc04610: 7f c9 03 a6 mtctr r30
ffc04614: 7f 83 e3 78 mr r3,r28
ffc04618: 4c c6 31 82 crclr 4*cr1+eq
ffc0461c: 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 );
ffc04620: 3c 60 ff c0 lis r3,-64
ffc04624: 38 63 41 dc addi r3,r3,16860
ffc04628: 48 00 77 cd bl ffc0bdf4 <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;
ffc0462c: 38 00 00 00 li r0,0
ffc04630: 90 1d 00 04 stw r0,4(r29)
print_handler = NULL;
ffc04634: 90 1f 28 f4 stw r0,10484(r31)
}
ffc04638: 39 61 00 18 addi r11,r1,24
ffc0463c: 4b ff c4 c0 b ffc00afc <_restgpr_28_x>
ffc044b8 <rtems_stack_checker_switch_extension>:
*/
void rtems_stack_checker_switch_extension(
Thread_Control *running __attribute__((unused)),
Thread_Control *heir __attribute__((unused))
)
{
ffc044b8: 94 21 ff e8 stwu r1,-24(r1)
ffc044bc: 7c 08 02 a6 mflr r0
ffc044c0: 90 01 00 1c stw r0,28(r1)
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);
ffc044c4: 81 23 00 bc lwz r9,188(r3)
*/
void rtems_stack_checker_switch_extension(
Thread_Control *running __attribute__((unused)),
Thread_Control *heir __attribute__((unused))
)
{
ffc044c8: bf a1 00 0c stmw r29,12(r1)
ffc044cc: 7c 3f 0b 78 mr r31,r1
)
{
#if defined(__GNUC__)
void *sp = __builtin_frame_address(0);
if ( sp < the_stack->area ) {
ffc044d0: 7f 9f 48 40 cmplw cr7,r31,r9
*/
void rtems_stack_checker_switch_extension(
Thread_Control *running __attribute__((unused)),
Thread_Control *heir __attribute__((unused))
)
{
ffc044d4: 7c 7e 1b 78 mr r30,r3
{
#if defined(__GNUC__)
void *sp = __builtin_frame_address(0);
if ( sp < the_stack->area ) {
return false;
ffc044d8: 3b a0 00 00 li r29,0
Stack_Control *the_stack = &running->Start.Initial_stack;
void *pattern;
bool sp_ok;
bool pattern_ok = true;
pattern = Stack_check_Get_pattern_area(the_stack);
ffc044dc: 38 69 00 08 addi r3,r9,8
)
{
#if defined(__GNUC__)
void *sp = __builtin_frame_address(0);
if ( sp < the_stack->area ) {
ffc044e0: 41 9c 00 18 blt- cr7,ffc044f8 <rtems_stack_checker_switch_extension+0x40><== NEVER TAKEN
return false;
}
if ( sp > (the_stack->area + the_stack->size) ) {
ffc044e4: 83 be 00 b8 lwz r29,184(r30)
ffc044e8: 7f a9 ea 14 add r29,r9,r29
}
/*
* rtems_stack_checker_switch_extension
*/
void rtems_stack_checker_switch_extension(
ffc044ec: 7f bf e8 10 subfc r29,r31,r29
ffc044f0: 3b a0 00 00 li r29,0
ffc044f4: 7f bd e9 14 adde r29,r29,r29
/*
* 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,
ffc044f8: 3c 80 00 00 lis r4,0
ffc044fc: 38 84 2b 68 addi r4,r4,11112
ffc04500: 38 a0 00 80 li r5,128
ffc04504: 48 00 f9 c1 bl ffc13ec4 <memcmp>
(void *) Stack_check_Pattern.pattern, PATTERN_SIZE_BYTES));
if ( !sp_ok || !pattern_ok ) {
ffc04508: 2f 9d 00 00 cmpwi cr7,r29,0
/*
* 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,
ffc0450c: 7c 64 00 34 cntlzw r4,r3
ffc04510: 54 84 d9 7e rlwinm r4,r4,27,5,31
(void *) Stack_check_Pattern.pattern, PATTERN_SIZE_BYTES));
if ( !sp_ok || !pattern_ok ) {
ffc04514: 41 9e 00 0c beq- cr7,ffc04520 <rtems_stack_checker_switch_extension+0x68><== NEVER TAKEN
ffc04518: 2f 84 00 00 cmpwi cr7,r4,0
ffc0451c: 40 be 00 0c bne+ cr7,ffc04528 <rtems_stack_checker_switch_extension+0x70>
Stack_check_report_blown_task( running, pattern_ok );
ffc04520: 7f c3 f3 78 mr r3,r30
ffc04524: 4b ff fe c1 bl ffc043e4 <Stack_check_report_blown_task>
}
}
ffc04528: 39 7f 00 18 addi r11,r31,24
ffc0452c: 4b ff c5 d4 b ffc00b00 <_restgpr_29_x>
ffc0e27c <rtems_string_to_double>:
rtems_status_code rtems_string_to_double (
const char *s,
double *n,
char **endptr
)
{
ffc0e27c: 94 21 ff d0 stwu r1,-48(r1)
ffc0e280: 7c 08 02 a6 mflr r0
ffc0e284: bf a1 00 1c stmw r29,28(r1)
double result;
char *end;
if ( !n )
ffc0e288: 7c 9e 23 79 mr. r30,r4
rtems_status_code rtems_string_to_double (
const char *s,
double *n,
char **endptr
)
{
ffc0e28c: 7c 7f 1b 78 mr r31,r3
ffc0e290: 90 01 00 34 stw r0,52(r1)
ffc0e294: 7c bd 2b 78 mr r29,r5
double result;
char *end;
if ( !n )
return RTEMS_INVALID_ADDRESS;
ffc0e298: 38 60 00 09 li r3,9
rtems_status_code rtems_string_to_double (
const char *s,
double *n,
char **endptr
)
{
ffc0e29c: db e1 00 28 stfd f31,40(r1)
double result;
char *end;
if ( !n )
ffc0e2a0: 41 82 00 94 beq- ffc0e334 <rtems_string_to_double+0xb8>
return RTEMS_INVALID_ADDRESS;
errno = 0;
ffc0e2a4: 48 00 33 e9 bl ffc1168c <__errno>
*n = 0;
ffc0e2a8: 3d 20 ff c2 lis r9,-62
ffc0e2ac: c8 09 f4 88 lfd f0,-2936(r9)
char *end;
if ( !n )
return RTEMS_INVALID_ADDRESS;
errno = 0;
ffc0e2b0: 38 00 00 00 li r0,0
ffc0e2b4: 90 03 00 00 stw r0,0(r3)
*n = 0;
result = strtod( s, &end );
ffc0e2b8: 38 81 00 08 addi r4,r1,8
ffc0e2bc: 7f e3 fb 78 mr r3,r31
if ( !n )
return RTEMS_INVALID_ADDRESS;
errno = 0;
*n = 0;
ffc0e2c0: d8 1e 00 00 stfd f0,0(r30)
result = strtod( s, &end );
ffc0e2c4: 48 00 60 f9 bl ffc143bc <strtod>
if ( endptr )
ffc0e2c8: 2f 9d 00 00 cmpwi cr7,r29,0
return RTEMS_INVALID_ADDRESS;
errno = 0;
*n = 0;
result = strtod( s, &end );
ffc0e2cc: ff e0 08 90 fmr f31,f1
ffc0e2d0: 80 01 00 08 lwz r0,8(r1)
if ( endptr )
ffc0e2d4: 41 9e 00 08 beq- cr7,ffc0e2dc <rtems_string_to_double+0x60>
*endptr = end;
ffc0e2d8: 90 1d 00 00 stw r0,0(r29)
if ( end == s )
ffc0e2dc: 7f 80 f8 00 cmpw cr7,r0,r31
return RTEMS_NOT_DEFINED;
ffc0e2e0: 38 60 00 0b li r3,11
result = strtod( s, &end );
if ( endptr )
*endptr = end;
if ( end == s )
ffc0e2e4: 41 9e 00 50 beq- cr7,ffc0e334 <rtems_string_to_double+0xb8>
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
ffc0e2e8: 48 00 33 a5 bl ffc1168c <__errno>
ffc0e2ec: 80 03 00 00 lwz r0,0(r3)
ffc0e2f0: 2f 80 00 22 cmpwi cr7,r0,34
ffc0e2f4: 40 be 00 38 bne+ cr7,ffc0e32c <rtems_string_to_double+0xb0>
ffc0e2f8: 3d 20 ff c2 lis r9,-62
ffc0e2fc: c8 09 f4 88 lfd f0,-2936(r9)
(( result == 0 ) || ( result == HUGE_VAL ) || ( result == -HUGE_VAL )))
return RTEMS_INVALID_NUMBER;
ffc0e300: 38 60 00 0a li r3,10
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
ffc0e304: ff 9f 00 00 fcmpu cr7,f31,f0
ffc0e308: 41 be 00 2c beq+ cr7,ffc0e334 <rtems_string_to_double+0xb8><== NEVER TAKEN
(( result == 0 ) || ( result == HUGE_VAL ) || ( result == -HUGE_VAL )))
ffc0e30c: 3d 20 ff c2 lis r9,-62
ffc0e310: c8 09 1a 60 lfd f0,6752(r9)
ffc0e314: ff 9f 00 00 fcmpu cr7,f31,f0
ffc0e318: 41 bd 00 1c bgt+ cr7,ffc0e334 <rtems_string_to_double+0xb8>
ffc0e31c: 3d 20 ff c2 lis r9,-62
ffc0e320: c8 09 1a 68 lfd f0,6760(r9)
ffc0e324: ff 9f 00 00 fcmpu cr7,f31,f0
ffc0e328: 41 bc 00 0c blt+ cr7,ffc0e334 <rtems_string_to_double+0xb8><== ALWAYS TAKEN
return RTEMS_INVALID_NUMBER;
*n = result;
ffc0e32c: db fe 00 00 stfd f31,0(r30)
return RTEMS_SUCCESSFUL;
ffc0e330: 38 60 00 00 li r3,0
}
ffc0e334: 80 01 00 34 lwz r0,52(r1)
ffc0e338: bb a1 00 1c lmw r29,28(r1)
ffc0e33c: 7c 08 03 a6 mtlr r0
ffc0e340: cb e1 00 28 lfd f31,40(r1)
ffc0e344: 38 21 00 30 addi r1,r1,48
ffc0e348: 4e 80 00 20 blr
ffc0e34c <rtems_string_to_float>:
rtems_status_code rtems_string_to_float (
const char *s,
float *n,
char **endptr
)
{
ffc0e34c: 94 21 ff d0 stwu r1,-48(r1)
ffc0e350: 7c 08 02 a6 mflr r0
ffc0e354: bf a1 00 1c stmw r29,28(r1)
float result;
char *end;
if ( !n )
ffc0e358: 7c 9e 23 79 mr. r30,r4
rtems_status_code rtems_string_to_float (
const char *s,
float *n,
char **endptr
)
{
ffc0e35c: 7c 7f 1b 78 mr r31,r3
ffc0e360: 90 01 00 34 stw r0,52(r1)
ffc0e364: 7c bd 2b 78 mr r29,r5
float result;
char *end;
if ( !n )
return RTEMS_INVALID_ADDRESS;
ffc0e368: 38 60 00 09 li r3,9
rtems_status_code rtems_string_to_float (
const char *s,
float *n,
char **endptr
)
{
ffc0e36c: db e1 00 28 stfd f31,40(r1)
float result;
char *end;
if ( !n )
ffc0e370: 41 82 00 90 beq- ffc0e400 <rtems_string_to_float+0xb4>
return RTEMS_INVALID_ADDRESS;
errno = 0;
ffc0e374: 48 00 33 19 bl ffc1168c <__errno>
ffc0e378: 38 00 00 00 li r0,0
ffc0e37c: 90 03 00 00 stw r0,0(r3)
*n = 0;
ffc0e380: 38 00 00 00 li r0,0
result = strtof( s, &end );
ffc0e384: 7f e3 fb 78 mr r3,r31
if ( !n )
return RTEMS_INVALID_ADDRESS;
errno = 0;
*n = 0;
ffc0e388: 90 1e 00 00 stw r0,0(r30)
result = strtof( s, &end );
ffc0e38c: 38 81 00 08 addi r4,r1,8
ffc0e390: 48 00 60 45 bl ffc143d4 <strtof>
if ( endptr )
ffc0e394: 2f 9d 00 00 cmpwi cr7,r29,0
return RTEMS_INVALID_ADDRESS;
errno = 0;
*n = 0;
result = strtof( s, &end );
ffc0e398: ff e0 08 90 fmr f31,f1
ffc0e39c: 80 01 00 08 lwz r0,8(r1)
if ( endptr )
ffc0e3a0: 41 9e 00 08 beq- cr7,ffc0e3a8 <rtems_string_to_float+0x5c>
*endptr = end;
ffc0e3a4: 90 1d 00 00 stw r0,0(r29)
if ( end == s )
ffc0e3a8: 7f 80 f8 00 cmpw cr7,r0,r31
return RTEMS_NOT_DEFINED;
ffc0e3ac: 38 60 00 0b li r3,11
result = strtof( s, &end );
if ( endptr )
*endptr = end;
if ( end == s )
ffc0e3b0: 41 9e 00 50 beq- cr7,ffc0e400 <rtems_string_to_float+0xb4>
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
ffc0e3b4: 48 00 32 d9 bl ffc1168c <__errno>
ffc0e3b8: 80 03 00 00 lwz r0,0(r3)
ffc0e3bc: 2f 80 00 22 cmpwi cr7,r0,34
ffc0e3c0: 40 be 00 38 bne+ cr7,ffc0e3f8 <rtems_string_to_float+0xac>
ffc0e3c4: 3d 20 ff c2 lis r9,-62
ffc0e3c8: c0 09 1a 78 lfs f0,6776(r9)
(( result == 0 ) || ( result == HUGE_VALF ) || ( result == -HUGE_VALF )))
return RTEMS_INVALID_NUMBER;
ffc0e3cc: 38 60 00 0a li r3,10
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
ffc0e3d0: ff 9f 00 00 fcmpu cr7,f31,f0
ffc0e3d4: 41 be 00 2c beq+ cr7,ffc0e400 <rtems_string_to_float+0xb4><== NEVER TAKEN
(( result == 0 ) || ( result == HUGE_VALF ) || ( result == -HUGE_VALF )))
ffc0e3d8: 3d 20 ff c2 lis r9,-62
ffc0e3dc: c0 09 1a 70 lfs f0,6768(r9)
ffc0e3e0: ff 9f 00 00 fcmpu cr7,f31,f0
ffc0e3e4: 41 bd 00 1c bgt+ cr7,ffc0e400 <rtems_string_to_float+0xb4>
ffc0e3e8: 3d 20 ff c2 lis r9,-62
ffc0e3ec: c0 09 1a 74 lfs f0,6772(r9)
ffc0e3f0: ff 9f 00 00 fcmpu cr7,f31,f0
ffc0e3f4: 41 bc 00 0c blt+ cr7,ffc0e400 <rtems_string_to_float+0xb4><== ALWAYS TAKEN
return RTEMS_INVALID_NUMBER;
*n = result;
ffc0e3f8: d3 fe 00 00 stfs f31,0(r30)
return RTEMS_SUCCESSFUL;
ffc0e3fc: 38 60 00 00 li r3,0
}
ffc0e400: 80 01 00 34 lwz r0,52(r1)
ffc0e404: bb a1 00 1c lmw r29,28(r1)
ffc0e408: 7c 08 03 a6 mtlr r0
ffc0e40c: cb e1 00 28 lfd f31,40(r1)
ffc0e410: 38 21 00 30 addi r1,r1,48
ffc0e414: 4e 80 00 20 blr
ffc0e418 <rtems_string_to_int>:
const char *s,
int *n,
char **endptr,
int base
)
{
ffc0e418: 94 21 ff d8 stwu r1,-40(r1)
ffc0e41c: 7c 08 02 a6 mflr r0
ffc0e420: bf 81 00 18 stmw r28,24(r1)
long result;
char *end;
if ( !n )
ffc0e424: 7c 9d 23 79 mr. r29,r4
const char *s,
int *n,
char **endptr,
int base
)
{
ffc0e428: 7c 7f 1b 78 mr r31,r3
ffc0e42c: 90 01 00 2c stw r0,44(r1)
ffc0e430: 7c be 2b 78 mr r30,r5
ffc0e434: 7c dc 33 78 mr r28,r6
long result;
char *end;
if ( !n )
return RTEMS_INVALID_ADDRESS;
ffc0e438: 38 00 00 09 li r0,9
)
{
long result;
char *end;
if ( !n )
ffc0e43c: 41 82 00 80 beq- ffc0e4bc <rtems_string_to_int+0xa4>
return RTEMS_INVALID_ADDRESS;
errno = 0;
ffc0e440: 48 00 32 4d bl ffc1168c <__errno>
ffc0e444: 38 00 00 00 li r0,0
ffc0e448: 90 03 00 00 stw r0,0(r3)
*n = 0;
result = strtol( s, &end, base );
ffc0e44c: 7f 85 e3 78 mr r5,r28
ffc0e450: 7f e3 fb 78 mr r3,r31
if ( !n )
return RTEMS_INVALID_ADDRESS;
errno = 0;
*n = 0;
ffc0e454: 90 1d 00 00 stw r0,0(r29)
result = strtol( s, &end, base );
ffc0e458: 38 81 00 08 addi r4,r1,8
ffc0e45c: 48 00 61 f9 bl ffc14654 <strtol>
if ( endptr )
ffc0e460: 2f 9e 00 00 cmpwi cr7,r30,0
return RTEMS_INVALID_ADDRESS;
errno = 0;
*n = 0;
result = strtol( s, &end, base );
ffc0e464: 7c 7c 1b 78 mr r28,r3
ffc0e468: 81 21 00 08 lwz r9,8(r1)
if ( endptr )
ffc0e46c: 41 9e 00 08 beq- cr7,ffc0e474 <rtems_string_to_int+0x5c>
*endptr = end;
ffc0e470: 91 3e 00 00 stw r9,0(r30)
if ( end == s )
ffc0e474: 7f 89 f8 00 cmpw cr7,r9,r31
return RTEMS_NOT_DEFINED;
ffc0e478: 38 00 00 0b li r0,11
result = strtol( s, &end, base );
if ( endptr )
*endptr = end;
if ( end == s )
ffc0e47c: 41 9e 00 40 beq- cr7,ffc0e4bc <rtems_string_to_int+0xa4>
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
ffc0e480: 48 00 32 0d bl ffc1168c <__errno>
ffc0e484: 80 03 00 00 lwz r0,0(r3)
ffc0e488: 2f 80 00 22 cmpwi cr7,r0,34
ffc0e48c: 40 be 00 28 bne+ cr7,ffc0e4b4 <rtems_string_to_int+0x9c>
ffc0e490: 2f 9c 00 00 cmpwi cr7,r28,0
(( result == 0 ) || ( result == LONG_MAX ) || ( result == LONG_MIN )))
return RTEMS_INVALID_NUMBER;
ffc0e494: 38 00 00 0a li r0,10
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
ffc0e498: 41 be 00 24 beq+ cr7,ffc0e4bc <rtems_string_to_int+0xa4><== NEVER TAKEN
(( result == 0 ) || ( result == LONG_MAX ) || ( result == LONG_MIN )))
ffc0e49c: 6f 89 80 00 xoris r9,r28,32768
ffc0e4a0: 2f 89 ff ff cmpwi cr7,r9,-1
ffc0e4a4: 41 9e 00 18 beq- cr7,ffc0e4bc <rtems_string_to_int+0xa4>
ffc0e4a8: 3d 20 80 00 lis r9,-32768
ffc0e4ac: 7f 9c 48 00 cmpw cr7,r28,r9
ffc0e4b0: 41 9e 00 0c beq- cr7,ffc0e4bc <rtems_string_to_int+0xa4><== ALWAYS TAKEN
errno = ERANGE;
return RTEMS_INVALID_NUMBER;
}
#endif
*n = result;
ffc0e4b4: 93 9d 00 00 stw r28,0(r29)
return RTEMS_SUCCESSFUL;
ffc0e4b8: 38 00 00 00 li r0,0
}
ffc0e4bc: 39 61 00 28 addi r11,r1,40
ffc0e4c0: 7c 03 03 78 mr r3,r0
ffc0e4c4: 4b ff 4c 80 b ffc03144 <_restgpr_28_x>
ffc0e59c <rtems_string_to_long>:
const char *s,
long *n,
char **endptr,
int base
)
{
ffc0e59c: 94 21 ff d8 stwu r1,-40(r1)
ffc0e5a0: 7c 08 02 a6 mflr r0
ffc0e5a4: bf 81 00 18 stmw r28,24(r1)
long result;
char *end;
if ( !n )
ffc0e5a8: 7c 9d 23 79 mr. r29,r4
const char *s,
long *n,
char **endptr,
int base
)
{
ffc0e5ac: 7c 7f 1b 78 mr r31,r3
ffc0e5b0: 90 01 00 2c stw r0,44(r1)
ffc0e5b4: 7c be 2b 78 mr r30,r5
ffc0e5b8: 7c dc 33 78 mr r28,r6
long result;
char *end;
if ( !n )
return RTEMS_INVALID_ADDRESS;
ffc0e5bc: 38 00 00 09 li r0,9
)
{
long result;
char *end;
if ( !n )
ffc0e5c0: 41 82 00 80 beq- ffc0e640 <rtems_string_to_long+0xa4>
return RTEMS_INVALID_ADDRESS;
errno = 0;
ffc0e5c4: 48 00 30 c9 bl ffc1168c <__errno>
ffc0e5c8: 38 00 00 00 li r0,0
ffc0e5cc: 90 03 00 00 stw r0,0(r3)
*n = 0;
result = strtol( s, &end, base );
ffc0e5d0: 7f 85 e3 78 mr r5,r28
ffc0e5d4: 7f e3 fb 78 mr r3,r31
if ( !n )
return RTEMS_INVALID_ADDRESS;
errno = 0;
*n = 0;
ffc0e5d8: 90 1d 00 00 stw r0,0(r29)
result = strtol( s, &end, base );
ffc0e5dc: 38 81 00 08 addi r4,r1,8
ffc0e5e0: 48 00 60 75 bl ffc14654 <strtol>
if ( endptr )
ffc0e5e4: 2f 9e 00 00 cmpwi cr7,r30,0
return RTEMS_INVALID_ADDRESS;
errno = 0;
*n = 0;
result = strtol( s, &end, base );
ffc0e5e8: 7c 7c 1b 78 mr r28,r3
ffc0e5ec: 81 21 00 08 lwz r9,8(r1)
if ( endptr )
ffc0e5f0: 41 9e 00 08 beq- cr7,ffc0e5f8 <rtems_string_to_long+0x5c>
*endptr = end;
ffc0e5f4: 91 3e 00 00 stw r9,0(r30)
if ( end == s )
ffc0e5f8: 7f 89 f8 00 cmpw cr7,r9,r31
return RTEMS_NOT_DEFINED;
ffc0e5fc: 38 00 00 0b li r0,11
result = strtol( s, &end, base );
if ( endptr )
*endptr = end;
if ( end == s )
ffc0e600: 41 9e 00 40 beq- cr7,ffc0e640 <rtems_string_to_long+0xa4>
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
ffc0e604: 48 00 30 89 bl ffc1168c <__errno>
ffc0e608: 80 03 00 00 lwz r0,0(r3)
ffc0e60c: 2f 80 00 22 cmpwi cr7,r0,34
ffc0e610: 40 be 00 28 bne+ cr7,ffc0e638 <rtems_string_to_long+0x9c>
ffc0e614: 2f 9c 00 00 cmpwi cr7,r28,0
(( result == 0 ) || ( result == LONG_MAX ) || ( result == LONG_MIN )))
return RTEMS_INVALID_NUMBER;
ffc0e618: 38 00 00 0a li r0,10
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
ffc0e61c: 41 be 00 24 beq+ cr7,ffc0e640 <rtems_string_to_long+0xa4><== NEVER TAKEN
(( result == 0 ) || ( result == LONG_MAX ) || ( result == LONG_MIN )))
ffc0e620: 6f 89 80 00 xoris r9,r28,32768
ffc0e624: 2f 89 ff ff cmpwi cr7,r9,-1
ffc0e628: 41 9e 00 18 beq- cr7,ffc0e640 <rtems_string_to_long+0xa4>
ffc0e62c: 3d 20 80 00 lis r9,-32768
ffc0e630: 7f 9c 48 00 cmpw cr7,r28,r9
ffc0e634: 41 9e 00 0c beq- cr7,ffc0e640 <rtems_string_to_long+0xa4><== ALWAYS TAKEN
return RTEMS_INVALID_NUMBER;
*n = result;
ffc0e638: 93 9d 00 00 stw r28,0(r29)
return RTEMS_SUCCESSFUL;
ffc0e63c: 38 00 00 00 li r0,0
}
ffc0e640: 39 61 00 28 addi r11,r1,40
ffc0e644: 7c 03 03 78 mr r3,r0
ffc0e648: 4b ff 4a fc b ffc03144 <_restgpr_28_x>
ffc0e4c8 <rtems_string_to_long_long>:
const char *s,
long long *n,
char **endptr,
int base
)
{
ffc0e4c8: 94 21 ff d0 stwu r1,-48(r1)
ffc0e4cc: 7c 08 02 a6 mflr r0
ffc0e4d0: bf 61 00 1c stmw r27,28(r1)
long long result;
char *end;
if ( !n )
ffc0e4d4: 7c 9d 23 79 mr. r29,r4
const char *s,
long long *n,
char **endptr,
int base
)
{
ffc0e4d8: 7c 7f 1b 78 mr r31,r3
ffc0e4dc: 90 01 00 34 stw r0,52(r1)
ffc0e4e0: 7c be 2b 78 mr r30,r5
ffc0e4e4: 7c dc 33 78 mr r28,r6
long long result;
char *end;
if ( !n )
return RTEMS_INVALID_ADDRESS;
ffc0e4e8: 38 60 00 09 li r3,9
)
{
long long result;
char *end;
if ( !n )
ffc0e4ec: 41 82 00 a8 beq- ffc0e594 <rtems_string_to_long_long+0xcc>
return RTEMS_INVALID_ADDRESS;
errno = 0;
ffc0e4f0: 48 00 31 9d bl ffc1168c <__errno>
ffc0e4f4: 38 00 00 00 li r0,0
*n = 0;
ffc0e4f8: 39 40 00 00 li r10,0
char *end;
if ( !n )
return RTEMS_INVALID_ADDRESS;
errno = 0;
ffc0e4fc: 90 03 00 00 stw r0,0(r3)
*n = 0;
ffc0e500: 39 60 00 00 li r11,0
ffc0e504: 91 5d 00 00 stw r10,0(r29)
result = strtoll( s, &end, base );
ffc0e508: 7f 85 e3 78 mr r5,r28
ffc0e50c: 7f e3 fb 78 mr r3,r31
if ( !n )
return RTEMS_INVALID_ADDRESS;
errno = 0;
*n = 0;
ffc0e510: 91 7d 00 04 stw r11,4(r29)
result = strtoll( s, &end, base );
ffc0e514: 38 81 00 08 addi r4,r1,8
ffc0e518: 48 00 61 5d bl ffc14674 <strtoll>
if ( endptr )
ffc0e51c: 2f 9e 00 00 cmpwi cr7,r30,0
return RTEMS_INVALID_ADDRESS;
errno = 0;
*n = 0;
result = strtoll( s, &end, base );
ffc0e520: 7c 7c 1b 78 mr r28,r3
ffc0e524: 80 01 00 08 lwz r0,8(r1)
ffc0e528: 7c 9b 23 78 mr r27,r4
if ( endptr )
ffc0e52c: 41 9e 00 08 beq- cr7,ffc0e534 <rtems_string_to_long_long+0x6c>
*endptr = end;
ffc0e530: 90 1e 00 00 stw r0,0(r30)
if ( end == s )
ffc0e534: 7f 80 f8 00 cmpw cr7,r0,r31
return RTEMS_NOT_DEFINED;
ffc0e538: 38 60 00 0b li r3,11
result = strtoll( s, &end, base );
if ( endptr )
*endptr = end;
if ( end == s )
ffc0e53c: 41 9e 00 58 beq- cr7,ffc0e594 <rtems_string_to_long_long+0xcc>
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
ffc0e540: 48 00 31 4d bl ffc1168c <__errno>
ffc0e544: 80 03 00 00 lwz r0,0(r3)
ffc0e548: 2f 80 00 22 cmpwi cr7,r0,34
ffc0e54c: 40 be 00 3c bne+ cr7,ffc0e588 <rtems_string_to_long_long+0xc0>
ffc0e550: 7f 80 db 79 or. r0,r28,r27
(( result == 0 ) || ( result == LONG_LONG_MAX ) || ( result == LONG_LONG_MIN )))
return RTEMS_INVALID_NUMBER;
ffc0e554: 38 60 00 0a li r3,10
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
ffc0e558: 41 a2 00 3c beq+ ffc0e594 <rtems_string_to_long_long+0xcc><== NEVER TAKEN
(( result == 0 ) || ( result == LONG_LONG_MAX ) || ( result == LONG_LONG_MIN )))
ffc0e55c: 6f 80 80 00 xoris r0,r28,32768
ffc0e560: 2f 80 ff ff cmpwi cr7,r0,-1
ffc0e564: 40 9e 00 0c bne- cr7,ffc0e570 <rtems_string_to_long_long+0xa8>
ffc0e568: 2f 9b ff ff cmpwi cr7,r27,-1
ffc0e56c: 41 9e 00 28 beq- cr7,ffc0e594 <rtems_string_to_long_long+0xcc><== ALWAYS TAKEN
ffc0e570: 3c 00 80 00 lis r0,-32768
ffc0e574: 7f 9c 00 00 cmpw cr7,r28,r0
ffc0e578: 40 be 00 10 bne+ cr7,ffc0e588 <rtems_string_to_long_long+0xc0><== NEVER TAKEN
ffc0e57c: 2f 9b 00 00 cmpwi cr7,r27,0
return RTEMS_INVALID_NUMBER;
ffc0e580: 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 )))
ffc0e584: 41 9e 00 10 beq- cr7,ffc0e594 <rtems_string_to_long_long+0xcc><== ALWAYS TAKEN
return RTEMS_INVALID_NUMBER;
*n = result;
ffc0e588: 93 9d 00 00 stw r28,0(r29)
return RTEMS_SUCCESSFUL;
ffc0e58c: 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;
ffc0e590: 93 7d 00 04 stw r27,4(r29)
return RTEMS_SUCCESSFUL;
}
ffc0e594: 39 61 00 30 addi r11,r1,48
ffc0e598: 4b ff 4b a8 b ffc03140 <_restgpr_27_x>
ffc0e670 <rtems_string_to_unsigned_char>:
const char *s,
unsigned char *n,
char **endptr,
int base
)
{
ffc0e670: 94 21 ff d8 stwu r1,-40(r1)
ffc0e674: 7c 08 02 a6 mflr r0
ffc0e678: bf 81 00 18 stmw r28,24(r1)
unsigned long result;
char *end;
if ( !n )
ffc0e67c: 7c 9d 23 79 mr. r29,r4
const char *s,
unsigned char *n,
char **endptr,
int base
)
{
ffc0e680: 7c 7f 1b 78 mr r31,r3
ffc0e684: 90 01 00 2c stw r0,44(r1)
ffc0e688: 7c be 2b 78 mr r30,r5
ffc0e68c: 7c dc 33 78 mr r28,r6
unsigned long result;
char *end;
if ( !n )
return RTEMS_INVALID_ADDRESS;
ffc0e690: 38 00 00 09 li r0,9
)
{
unsigned long result;
char *end;
if ( !n )
ffc0e694: 41 82 00 8c beq- ffc0e720 <rtems_string_to_unsigned_char+0xb0>
return RTEMS_INVALID_ADDRESS;
errno = 0;
ffc0e698: 48 00 2f f5 bl ffc1168c <__errno>
ffc0e69c: 38 00 00 00 li r0,0
ffc0e6a0: 90 03 00 00 stw r0,0(r3)
*n = 0;
result = strtoul( s, &end, base );
ffc0e6a4: 7f 85 e3 78 mr r5,r28
ffc0e6a8: 7f e3 fb 78 mr r3,r31
if ( !n )
return RTEMS_INVALID_ADDRESS;
errno = 0;
*n = 0;
ffc0e6ac: 98 1d 00 00 stb r0,0(r29)
result = strtoul( s, &end, base );
ffc0e6b0: 38 81 00 08 addi r4,r1,8
ffc0e6b4: 48 00 65 2d bl ffc14be0 <strtoul>
if ( endptr )
ffc0e6b8: 2f 9e 00 00 cmpwi cr7,r30,0
return RTEMS_INVALID_ADDRESS;
errno = 0;
*n = 0;
result = strtoul( s, &end, base );
ffc0e6bc: 7c 7c 1b 78 mr r28,r3
ffc0e6c0: 81 21 00 08 lwz r9,8(r1)
if ( endptr )
ffc0e6c4: 41 9e 00 08 beq- cr7,ffc0e6cc <rtems_string_to_unsigned_char+0x5c>
*endptr = end;
ffc0e6c8: 91 3e 00 00 stw r9,0(r30)
if ( end == s )
ffc0e6cc: 7f 89 f8 00 cmpw cr7,r9,r31
return RTEMS_NOT_DEFINED;
ffc0e6d0: 38 00 00 0b li r0,11
result = strtoul( s, &end, base );
if ( endptr )
*endptr = end;
if ( end == s )
ffc0e6d4: 41 9e 00 4c beq- cr7,ffc0e720 <rtems_string_to_unsigned_char+0xb0>
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
ffc0e6d8: 48 00 2f b5 bl ffc1168c <__errno>
ffc0e6dc: 80 03 00 00 lwz r0,0(r3)
ffc0e6e0: 2f 80 00 22 cmpwi cr7,r0,34
ffc0e6e4: 40 be 00 18 bne+ cr7,ffc0e6fc <rtems_string_to_unsigned_char+0x8c>
(( result == 0 ) || ( result == ULONG_MAX )))
ffc0e6e8: 39 7c ff ff addi r11,r28,-1
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
ffc0e6ec: 39 20 ff fd li r9,-3
ffc0e6f0: 7f 8b 48 40 cmplw cr7,r11,r9
(( result == 0 ) || ( result == ULONG_MAX )))
return RTEMS_INVALID_NUMBER;
ffc0e6f4: 38 00 00 0a li r0,10
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
ffc0e6f8: 41 bd 00 28 bgt+ cr7,ffc0e720 <rtems_string_to_unsigned_char+0xb0><== ALWAYS TAKEN
(( result == 0 ) || ( result == ULONG_MAX )))
return RTEMS_INVALID_NUMBER;
#if (UCHAR_MAX < ULONG_MAX)
if ( result > UCHAR_MAX ) {
ffc0e6fc: 2b 9c 00 ff cmplwi cr7,r28,255
ffc0e700: 40 9d 00 18 ble- cr7,ffc0e718 <rtems_string_to_unsigned_char+0xa8>
errno = ERANGE;
ffc0e704: 48 00 2f 89 bl ffc1168c <__errno>
ffc0e708: 38 00 00 22 li r0,34
ffc0e70c: 90 03 00 00 stw r0,0(r3)
return RTEMS_INVALID_NUMBER;
ffc0e710: 38 00 00 0a li r0,10
ffc0e714: 48 00 00 0c b ffc0e720 <rtems_string_to_unsigned_char+0xb0>
}
#endif
*n = result;
ffc0e718: 9b 9d 00 00 stb r28,0(r29)
return RTEMS_SUCCESSFUL;
ffc0e71c: 38 00 00 00 li r0,0
}
ffc0e720: 39 61 00 28 addi r11,r1,40
ffc0e724: 7c 03 03 78 mr r3,r0
ffc0e728: 4b ff 4a 1c b ffc03144 <_restgpr_28_x>
ffc0e72c <rtems_string_to_unsigned_int>:
const char *s,
unsigned int *n,
char **endptr,
int base
)
{
ffc0e72c: 94 21 ff d8 stwu r1,-40(r1)
ffc0e730: 7c 08 02 a6 mflr r0
ffc0e734: bf 81 00 18 stmw r28,24(r1)
unsigned long result;
char *end;
if ( !n )
ffc0e738: 7c 9d 23 79 mr. r29,r4
const char *s,
unsigned int *n,
char **endptr,
int base
)
{
ffc0e73c: 7c 7f 1b 78 mr r31,r3
ffc0e740: 90 01 00 2c stw r0,44(r1)
ffc0e744: 7c be 2b 78 mr r30,r5
ffc0e748: 7c dc 33 78 mr r28,r6
unsigned long result;
char *end;
if ( !n )
return RTEMS_INVALID_ADDRESS;
ffc0e74c: 38 00 00 09 li r0,9
)
{
unsigned long result;
char *end;
if ( !n )
ffc0e750: 41 82 00 70 beq- ffc0e7c0 <rtems_string_to_unsigned_int+0x94>
return RTEMS_INVALID_ADDRESS;
errno = 0;
ffc0e754: 48 00 2f 39 bl ffc1168c <__errno>
ffc0e758: 38 00 00 00 li r0,0
ffc0e75c: 90 03 00 00 stw r0,0(r3)
*n = 0;
result = strtoul( s, &end, base );
ffc0e760: 7f 85 e3 78 mr r5,r28
ffc0e764: 7f e3 fb 78 mr r3,r31
if ( !n )
return RTEMS_INVALID_ADDRESS;
errno = 0;
*n = 0;
ffc0e768: 90 1d 00 00 stw r0,0(r29)
result = strtoul( s, &end, base );
ffc0e76c: 38 81 00 08 addi r4,r1,8
ffc0e770: 48 00 64 71 bl ffc14be0 <strtoul>
if ( endptr )
ffc0e774: 2f 9e 00 00 cmpwi cr7,r30,0
return RTEMS_INVALID_ADDRESS;
errno = 0;
*n = 0;
result = strtoul( s, &end, base );
ffc0e778: 7c 7c 1b 78 mr r28,r3
ffc0e77c: 81 21 00 08 lwz r9,8(r1)
if ( endptr )
ffc0e780: 41 9e 00 08 beq- cr7,ffc0e788 <rtems_string_to_unsigned_int+0x5c>
*endptr = end;
ffc0e784: 91 3e 00 00 stw r9,0(r30)
if ( end == s )
ffc0e788: 7f 89 f8 00 cmpw cr7,r9,r31
return RTEMS_NOT_DEFINED;
ffc0e78c: 38 00 00 0b li r0,11
result = strtoul( s, &end, base );
if ( endptr )
*endptr = end;
if ( end == s )
ffc0e790: 41 9e 00 30 beq- cr7,ffc0e7c0 <rtems_string_to_unsigned_int+0x94>
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
ffc0e794: 48 00 2e f9 bl ffc1168c <__errno>
ffc0e798: 80 03 00 00 lwz r0,0(r3)
ffc0e79c: 2f 80 00 22 cmpwi cr7,r0,34
ffc0e7a0: 40 be 00 18 bne+ cr7,ffc0e7b8 <rtems_string_to_unsigned_int+0x8c>
(( result == 0 ) || ( result == ULONG_MAX )))
ffc0e7a4: 39 7c ff ff addi r11,r28,-1
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
ffc0e7a8: 39 20 ff fd li r9,-3
ffc0e7ac: 7f 8b 48 40 cmplw cr7,r11,r9
(( result == 0 ) || ( result == ULONG_MAX )))
return RTEMS_INVALID_NUMBER;
ffc0e7b0: 38 00 00 0a li r0,10
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
ffc0e7b4: 41 bd 00 0c bgt+ cr7,ffc0e7c0 <rtems_string_to_unsigned_int+0x94><== ALWAYS TAKEN
errno = ERANGE;
return RTEMS_INVALID_NUMBER;
}
#endif
*n = result;
ffc0e7b8: 93 9d 00 00 stw r28,0(r29)
return RTEMS_SUCCESSFUL;
ffc0e7bc: 38 00 00 00 li r0,0
}
ffc0e7c0: 39 61 00 28 addi r11,r1,40
ffc0e7c4: 7c 03 03 78 mr r3,r0
ffc0e7c8: 4b ff 49 7c b ffc03144 <_restgpr_28_x>
ffc0e888 <rtems_string_to_unsigned_long>:
const char *s,
unsigned long *n,
char **endptr,
int base
)
{
ffc0e888: 94 21 ff d8 stwu r1,-40(r1)
ffc0e88c: 7c 08 02 a6 mflr r0
ffc0e890: bf 81 00 18 stmw r28,24(r1)
unsigned long result;
char *end;
if ( !n )
ffc0e894: 7c 9d 23 79 mr. r29,r4
const char *s,
unsigned long *n,
char **endptr,
int base
)
{
ffc0e898: 7c 7f 1b 78 mr r31,r3
ffc0e89c: 90 01 00 2c stw r0,44(r1)
ffc0e8a0: 7c be 2b 78 mr r30,r5
ffc0e8a4: 7c dc 33 78 mr r28,r6
unsigned long result;
char *end;
if ( !n )
return RTEMS_INVALID_ADDRESS;
ffc0e8a8: 38 00 00 09 li r0,9
)
{
unsigned long result;
char *end;
if ( !n )
ffc0e8ac: 41 82 00 70 beq- ffc0e91c <rtems_string_to_unsigned_long+0x94>
return RTEMS_INVALID_ADDRESS;
errno = 0;
ffc0e8b0: 48 00 2d dd bl ffc1168c <__errno>
ffc0e8b4: 38 00 00 00 li r0,0
ffc0e8b8: 90 03 00 00 stw r0,0(r3)
*n = 0;
result = strtoul( s, &end, base );
ffc0e8bc: 7f 85 e3 78 mr r5,r28
ffc0e8c0: 7f e3 fb 78 mr r3,r31
if ( !n )
return RTEMS_INVALID_ADDRESS;
errno = 0;
*n = 0;
ffc0e8c4: 90 1d 00 00 stw r0,0(r29)
result = strtoul( s, &end, base );
ffc0e8c8: 38 81 00 08 addi r4,r1,8
ffc0e8cc: 48 00 63 15 bl ffc14be0 <strtoul>
if ( endptr )
ffc0e8d0: 2f 9e 00 00 cmpwi cr7,r30,0
return RTEMS_INVALID_ADDRESS;
errno = 0;
*n = 0;
result = strtoul( s, &end, base );
ffc0e8d4: 7c 7c 1b 78 mr r28,r3
ffc0e8d8: 81 21 00 08 lwz r9,8(r1)
if ( endptr )
ffc0e8dc: 41 9e 00 08 beq- cr7,ffc0e8e4 <rtems_string_to_unsigned_long+0x5c>
*endptr = end;
ffc0e8e0: 91 3e 00 00 stw r9,0(r30)
if ( end == s )
ffc0e8e4: 7f 89 f8 00 cmpw cr7,r9,r31
return RTEMS_NOT_DEFINED;
ffc0e8e8: 38 00 00 0b li r0,11
result = strtoul( s, &end, base );
if ( endptr )
*endptr = end;
if ( end == s )
ffc0e8ec: 41 9e 00 30 beq- cr7,ffc0e91c <rtems_string_to_unsigned_long+0x94>
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
ffc0e8f0: 48 00 2d 9d bl ffc1168c <__errno>
ffc0e8f4: 80 03 00 00 lwz r0,0(r3)
ffc0e8f8: 2f 80 00 22 cmpwi cr7,r0,34
ffc0e8fc: 40 be 00 18 bne+ cr7,ffc0e914 <rtems_string_to_unsigned_long+0x8c>
(( result == 0 ) || ( result == ULONG_MAX )))
ffc0e900: 39 7c ff ff addi r11,r28,-1
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
ffc0e904: 39 20 ff fd li r9,-3
ffc0e908: 7f 8b 48 40 cmplw cr7,r11,r9
(( result == 0 ) || ( result == ULONG_MAX )))
return RTEMS_INVALID_NUMBER;
ffc0e90c: 38 00 00 0a li r0,10
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
ffc0e910: 41 bd 00 0c bgt+ cr7,ffc0e91c <rtems_string_to_unsigned_long+0x94><== ALWAYS TAKEN
(( result == 0 ) || ( result == ULONG_MAX )))
return RTEMS_INVALID_NUMBER;
*n = result;
ffc0e914: 93 9d 00 00 stw r28,0(r29)
return RTEMS_SUCCESSFUL;
ffc0e918: 38 00 00 00 li r0,0
}
ffc0e91c: 39 61 00 28 addi r11,r1,40
ffc0e920: 7c 03 03 78 mr r3,r0
ffc0e924: 4b ff 48 20 b ffc03144 <_restgpr_28_x>
ffc0e7cc <rtems_string_to_unsigned_long_long>:
const char *s,
unsigned long long *n,
char **endptr,
int base
)
{
ffc0e7cc: 94 21 ff d0 stwu r1,-48(r1)
ffc0e7d0: 7c 08 02 a6 mflr r0
ffc0e7d4: bf 41 00 18 stmw r26,24(r1)
unsigned long long result;
char *end;
if ( !n )
ffc0e7d8: 7c 9d 23 79 mr. r29,r4
const char *s,
unsigned long long *n,
char **endptr,
int base
)
{
ffc0e7dc: 7c 7f 1b 78 mr r31,r3
ffc0e7e0: 90 01 00 34 stw r0,52(r1)
ffc0e7e4: 7c be 2b 78 mr r30,r5
ffc0e7e8: 7c da 33 78 mr r26,r6
unsigned long long result;
char *end;
if ( !n )
return RTEMS_INVALID_ADDRESS;
ffc0e7ec: 38 60 00 09 li r3,9
)
{
unsigned long long result;
char *end;
if ( !n )
ffc0e7f0: 41 82 00 90 beq- ffc0e880 <rtems_string_to_unsigned_long_long+0xb4>
return RTEMS_INVALID_ADDRESS;
errno = 0;
ffc0e7f4: 48 00 2e 99 bl ffc1168c <__errno>
ffc0e7f8: 38 00 00 00 li r0,0
*n = 0;
ffc0e7fc: 39 40 00 00 li r10,0
char *end;
if ( !n )
return RTEMS_INVALID_ADDRESS;
errno = 0;
ffc0e800: 90 03 00 00 stw r0,0(r3)
*n = 0;
ffc0e804: 39 60 00 00 li r11,0
ffc0e808: 91 5d 00 00 stw r10,0(r29)
result = strtoull( s, &end, base );
ffc0e80c: 7f 45 d3 78 mr r5,r26
ffc0e810: 7f e3 fb 78 mr r3,r31
if ( !n )
return RTEMS_INVALID_ADDRESS;
errno = 0;
*n = 0;
ffc0e814: 91 7d 00 04 stw r11,4(r29)
result = strtoull( s, &end, base );
ffc0e818: 38 81 00 08 addi r4,r1,8
ffc0e81c: 48 00 63 e5 bl ffc14c00 <strtoull>
if ( endptr )
ffc0e820: 2f 9e 00 00 cmpwi cr7,r30,0
return RTEMS_INVALID_ADDRESS;
errno = 0;
*n = 0;
result = strtoull( s, &end, base );
ffc0e824: 7c 9b 23 78 mr r27,r4
ffc0e828: 80 01 00 08 lwz r0,8(r1)
ffc0e82c: 7c 7a 1b 78 mr r26,r3
if ( endptr )
ffc0e830: 41 9e 00 08 beq- cr7,ffc0e838 <rtems_string_to_unsigned_long_long+0x6c>
*endptr = end;
ffc0e834: 90 1e 00 00 stw r0,0(r30)
if ( end == s )
ffc0e838: 7f 80 f8 00 cmpw cr7,r0,r31
return RTEMS_NOT_DEFINED;
ffc0e83c: 38 60 00 0b li r3,11
result = strtoull( s, &end, base );
if ( endptr )
*endptr = end;
if ( end == s )
ffc0e840: 41 9e 00 40 beq- cr7,ffc0e880 <rtems_string_to_unsigned_long_long+0xb4>
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
ffc0e844: 48 00 2e 49 bl ffc1168c <__errno>
ffc0e848: 80 03 00 00 lwz r0,0(r3)
ffc0e84c: 2f 80 00 22 cmpwi cr7,r0,34
ffc0e850: 40 be 00 24 bne+ cr7,ffc0e874 <rtems_string_to_unsigned_long_long+0xa8>
(( result == 0 ) || ( result == ULONG_LONG_MAX )))
ffc0e854: 31 7b ff ff addic r11,r27,-1
ffc0e858: 7d 5a 01 d4 addme r10,r26
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
ffc0e85c: 2f 8a ff ff cmpwi cr7,r10,-1
ffc0e860: 40 9e 00 14 bne- cr7,ffc0e874 <rtems_string_to_unsigned_long_long+0xa8><== NEVER TAKEN
ffc0e864: 38 00 ff fd li r0,-3
ffc0e868: 7f 8b 00 40 cmplw cr7,r11,r0
(( result == 0 ) || ( result == ULONG_LONG_MAX )))
return RTEMS_INVALID_NUMBER;
ffc0e86c: 38 60 00 0a li r3,10
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
ffc0e870: 41 bd 00 10 bgt+ cr7,ffc0e880 <rtems_string_to_unsigned_long_long+0xb4><== ALWAYS TAKEN
(( result == 0 ) || ( result == ULONG_LONG_MAX )))
return RTEMS_INVALID_NUMBER;
*n = result;
ffc0e874: 93 5d 00 00 stw r26,0(r29)
return RTEMS_SUCCESSFUL;
ffc0e878: 38 60 00 00 li r3,0
if ( ( errno == ERANGE ) &&
(( result == 0 ) || ( result == ULONG_LONG_MAX )))
return RTEMS_INVALID_NUMBER;
*n = result;
ffc0e87c: 93 7d 00 04 stw r27,4(r29)
return RTEMS_SUCCESSFUL;
}
ffc0e880: 39 61 00 30 addi r11,r1,48
ffc0e884: 4b ff 48 b8 b ffc0313c <_restgpr_26_x>
ffc03d88 <rtems_tarfs_load>:
int rtems_tarfs_load(
char *mountpoint,
uint8_t *tar_image,
size_t tar_size
)
{
ffc03d88: 94 21 fe 30 stwu r1,-464(r1)
ffc03d8c: 7c 08 02 a6 mflr r0
ffc03d90: be 61 01 9c stmw r19,412(r1)
ffc03d94: 7c 7c 1b 78 mr r28,r3
ffc03d98: 7c 9b 23 78 mr r27,r4
ffc03d9c: 90 01 01 d4 stw r0,468(r1)
ffc03da0: 7c b7 2b 78 mr r23,r5
int offset;
unsigned long nblocks;
IMFS_jnode_t *node;
int status;
status = rtems_filesystem_evaluate_path(
ffc03da4: 48 01 1b 61 bl ffc15904 <strlen>
ffc03da8: 38 a0 00 00 li r5,0
ffc03dac: 7c 64 1b 78 mr r4,r3
ffc03db0: 38 c1 00 20 addi r6,r1,32
ffc03db4: 7f 83 e3 78 mr r3,r28
ffc03db8: 38 e0 00 00 li r7,0
ffc03dbc: 48 00 0c 69 bl ffc04a24 <rtems_filesystem_evaluate_path>
strlen(mountpoint),
0,
&root_loc,
0
);
if (status != 0)
ffc03dc0: 7c 7e 1b 79 mr. r30,r3
ffc03dc4: 40 82 01 8c bne- ffc03f50 <rtems_tarfs_load+0x1c8>
return -1;
if (root_loc.ops != &IMFS_ops && root_loc.ops != &fifoIMFS_ops)
ffc03dc8: 80 01 00 2c lwz r0,44(r1)
ffc03dcc: 3d 20 ff c2 lis r9,-62
ffc03dd0: 39 29 1f d8 addi r9,r9,8152
ffc03dd4: 7f 80 48 00 cmpw cr7,r0,r9
ffc03dd8: 41 9e 00 20 beq- cr7,ffc03df8 <rtems_tarfs_load+0x70>
ffc03ddc: 3d 20 ff c2 lis r9,-62
ffc03de0: 39 29 26 f0 addi r9,r9,9968
ffc03de4: 7f 80 48 00 cmpw cr7,r0,r9
ffc03de8: 41 be 00 10 beq+ cr7,ffc03df8 <rtems_tarfs_load+0x70> <== NEVER TAKEN
ffc03dec: 48 00 01 64 b ffc03f50 <rtems_tarfs_load+0x1c8>
ffc03df0: 7f f5 fb 78 mr r21,r31
ffc03df4: 48 00 00 1c b ffc03e10 <rtems_tarfs_load+0x88>
/*
* Read a header.
*/
hdr_ptr = (char *) &tar_image[offset];
offset += 512;
if (strncmp(&hdr_ptr[257], "ustar", 5))
ffc03df8: 3f 00 ff c2 lis r24,-62
* - 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, "/");
ffc03dfc: 3f 20 ff c2 lis r25,-62
0
);
if (status != 0)
return -1;
if (root_loc.ops != &IMFS_ops && root_loc.ops != &fifoIMFS_ops)
ffc03e00: 3a a0 00 00 li r21,0
/*
* Read a header.
*/
hdr_ptr = (char *) &tar_image[offset];
offset += 512;
if (strncmp(&hdr_ptr[257], "ustar", 5))
ffc03e04: 3b 18 20 20 addi r24,r24,8224
* should not have this path.
*/
else if (linkflag == REGTYPE) {
const char *name;
loc = root_loc;
ffc03e08: 3b a1 00 0c addi r29,r1,12
* - 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, "/");
ffc03e0c: 3b 39 eb b1 addi r25,r25,-5199
/*
* Create an IMFS node structure pointing to tar image memory.
*/
offset = 0;
while (1) {
if (offset + 512 > tar_size)
ffc03e10: 3b f5 02 00 addi r31,r21,512
ffc03e14: 7f 9f b8 40 cmplw cr7,r31,r23
ffc03e18: 41 9d 01 3c bgt- cr7,ffc03f54 <rtems_tarfs_load+0x1cc> <== NEVER TAKEN
break;
/*
* Read a header.
*/
hdr_ptr = (char *) &tar_image[offset];
ffc03e1c: 7e bb aa 14 add r21,r27,r21
offset += 512;
if (strncmp(&hdr_ptr[257], "ustar", 5))
ffc03e20: 38 75 01 01 addi r3,r21,257
ffc03e24: 7f 04 c3 78 mr r4,r24
ffc03e28: 38 a0 00 05 li r5,5
ffc03e2c: 48 01 1b 95 bl ffc159c0 <strncmp>
ffc03e30: 7c 7a 1b 79 mr. r26,r3
ffc03e34: 40 82 01 20 bne- ffc03f54 <rtems_tarfs_load+0x1cc>
break;
strncpy(filename, hdr_ptr, MAX_NAME_FIELD_SIZE);
ffc03e38: 38 a0 00 63 li r5,99
ffc03e3c: 7e a4 ab 78 mr r4,r21
ffc03e40: 38 61 00 34 addi r3,r1,52
ffc03e44: 48 01 1c c5 bl ffc15b08 <strncpy>
filename[MAX_NAME_FIELD_SIZE] = '\0';
linkflag = hdr_ptr[156];
file_mode = _rtems_octal2ulong(&hdr_ptr[100], 8);
ffc03e48: 38 80 00 08 li r4,8
ffc03e4c: 38 75 00 64 addi r3,r21,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';
ffc03e50: 9b 41 00 97 stb r26,151(r1)
linkflag = hdr_ptr[156];
ffc03e54: 8a 95 00 9c lbz r20,156(r21)
file_mode = _rtems_octal2ulong(&hdr_ptr[100], 8);
ffc03e58: 48 00 84 69 bl ffc0c2c0 <_rtems_octal2ulong>
ffc03e5c: 7c 76 1b 78 mr r22,r3
file_size = _rtems_octal2ulong(&hdr_ptr[124], 12);
ffc03e60: 38 80 00 0c li r4,12
ffc03e64: 38 75 00 7c addi r3,r21,124
ffc03e68: 48 00 84 59 bl ffc0c2c0 <_rtems_octal2ulong>
hdr_chksum = _rtems_octal2ulong(&hdr_ptr[148], 8);
ffc03e6c: 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);
ffc03e70: 7c 7a 1b 78 mr r26,r3
hdr_chksum = _rtems_octal2ulong(&hdr_ptr[148], 8);
ffc03e74: 38 75 00 94 addi r3,r21,148
ffc03e78: 48 00 84 49 bl ffc0c2c0 <_rtems_octal2ulong>
ffc03e7c: 7c 73 1b 78 mr r19,r3
if (_rtems_tar_header_checksum(hdr_ptr) != hdr_chksum)
ffc03e80: 7e a3 ab 78 mr r3,r21
ffc03e84: 48 00 84 81 bl ffc0c304 <_rtems_tar_header_checksum>
ffc03e88: 7f 83 98 00 cmpw cr7,r3,r19
ffc03e8c: 40 9e 00 c8 bne- cr7,ffc03f54 <rtems_tarfs_load+0x1cc> <== 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) {
ffc03e90: 2f 94 00 35 cmpwi cr7,r20,53
ffc03e94: 40 be 00 54 bne+ cr7,ffc03ee8 <rtems_tarfs_load+0x160>
strcpy(full_filename, mountpoint);
ffc03e98: 7f 84 e3 78 mr r4,r28
ffc03e9c: 38 61 00 98 addi r3,r1,152
ffc03ea0: 48 01 15 51 bl ffc153f0 <strcpy>
if (full_filename[strlen(full_filename)-1] != '/')
ffc03ea4: 38 61 00 98 addi r3,r1,152
ffc03ea8: 48 01 1a 5d bl ffc15904 <strlen>
ffc03eac: 38 01 00 08 addi r0,r1,8
ffc03eb0: 7c 60 1a 14 add r3,r0,r3
ffc03eb4: 88 03 00 8f lbz r0,143(r3)
ffc03eb8: 2f 80 00 2f cmpwi cr7,r0,47
ffc03ebc: 41 9e 00 10 beq- cr7,ffc03ecc <rtems_tarfs_load+0x144> <== ALWAYS TAKEN
strcat(full_filename, "/");
ffc03ec0: 38 61 00 98 addi r3,r1,152 <== NOT EXECUTED
ffc03ec4: 7f 24 cb 78 mr r4,r25 <== NOT EXECUTED
ffc03ec8: 48 01 13 c9 bl ffc15290 <strcat> <== NOT EXECUTED
strcat(full_filename, filename);
ffc03ecc: 38 81 00 34 addi r4,r1,52
ffc03ed0: 38 61 00 98 addi r3,r1,152
ffc03ed4: 48 01 13 bd bl ffc15290 <strcat>
mkdir(full_filename, S_IRWXU | S_IRWXG | S_IRWXO);
ffc03ed8: 38 61 00 98 addi r3,r1,152
ffc03edc: 38 80 01 ff li r4,511
ffc03ee0: 48 00 14 cd bl ffc053ac <mkdir>
ffc03ee4: 4b ff ff 0c b ffc03df0 <rtems_tarfs_load+0x68>
* 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) {
ffc03ee8: 2f 94 00 30 cmpwi cr7,r20,48
ffc03eec: 40 9e ff 04 bne+ cr7,ffc03df0 <rtems_tarfs_load+0x68>
const char *name;
loc = root_loc;
ffc03ef0: 39 61 00 20 addi r11,r1,32
ffc03ef4: 7c ab a4 aa lswi r5,r11,20
ffc03ef8: 7c bd a5 aa stswi r5,r29,20
if (IMFS_evaluate_for_make(filename, &loc, &name) == 0) {
ffc03efc: 38 61 00 34 addi r3,r1,52
ffc03f00: 7f a4 eb 78 mr r4,r29
ffc03f04: 38 a1 00 08 addi r5,r1,8
ffc03f08: 48 00 91 ad bl ffc0d0b4 <IMFS_evaluate_for_make>
ffc03f0c: 7c 75 1b 79 mr. r21,r3
ffc03f10: 40 a2 00 30 bne+ ffc03f40 <rtems_tarfs_load+0x1b8> <== NEVER TAKEN
node = IMFS_create_node(
&loc,
IMFS_LINEAR_FILE, (char *)name,
(file_mode & (S_IRWXU | S_IRWXG | S_IRWXO)) | S_IFREG,
ffc03f14: 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(
ffc03f18: 80 a1 00 08 lwz r5,8(r1)
ffc03f1c: 7f a3 eb 78 mr r3,r29
ffc03f20: 38 80 00 06 li r4,6
ffc03f24: 60 c6 80 00 ori r6,r6,32768
ffc03f28: 38 e0 00 00 li r7,0
ffc03f2c: 48 00 8a 15 bl ffc0c940 <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];
ffc03f30: 7c 1b fa 14 add r0,r27,r31
&loc,
IMFS_LINEAR_FILE, (char *)name,
(file_mode & (S_IRWXU | S_IRWXG | S_IRWXO)) | S_IFREG,
NULL
);
node->info.linearfile.size = file_size;
ffc03f34: 93 43 00 54 stw r26,84(r3)
ffc03f38: 92 a3 00 50 stw r21,80(r3)
node->info.linearfile.direct = &tar_image[offset];
ffc03f3c: 90 03 00 58 stw r0,88(r3)
}
nblocks = (((file_size) + 511) & ~511) / 512;
ffc03f40: 3b 5a 01 ff addi r26,r26,511
offset += 512 * nblocks;
ffc03f44: 57 5a 00 2c rlwinm r26,r26,0,0,22
ffc03f48: 7f fa fa 14 add r31,r26,r31
ffc03f4c: 4b ff fe a4 b ffc03df0 <rtems_tarfs_load+0x68>
);
if (status != 0)
return -1;
if (root_loc.ops != &IMFS_ops && root_loc.ops != &fifoIMFS_ops)
return -1;
ffc03f50: 3b c0 ff ff li r30,-1
nblocks = (((file_size) + 511) & ~511) / 512;
offset += 512 * nblocks;
}
}
return status;
}
ffc03f54: 39 61 01 d0 addi r11,r1,464
ffc03f58: 7f c3 f3 78 mr r3,r30
ffc03f5c: 4b ff c6 44 b ffc005a0 <_restgpr_19_x>
ffc105e4 <rtems_task_mode>:
ASR_Information *asr;
bool is_asr_enabled = false;
bool needs_asr_dispatching = false;
rtems_mode old_mode;
if ( !previous_mode_set )
ffc105e4: 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
)
{
ffc105e8: 7c 08 02 a6 mflr r0
ffc105ec: 94 21 ff f8 stwu r1,-8(r1)
ffc105f0: 90 01 00 0c stw r0,12(r1)
ffc105f4: 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;
ffc105f8: 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 )
ffc105fc: 41 82 01 88 beq- ffc10784 <rtems_task_mode+0x1a0>
return RTEMS_INVALID_ADDRESS;
executing = _Thread_Executing;
ffc10600: 3d 20 00 00 lis r9,0
ffc10604: 81 69 31 50 lwz r11,12624(r9)
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 )
ffc10608: 81 0b 00 7c lwz r8,124(r11)
executing = _Thread_Executing;
api = executing->API_Extensions[ THREAD_API_RTEMS ];
asr = &api->Signal;
old_mode = (executing->is_preemptible) ? RTEMS_PREEMPT : RTEMS_NO_PREEMPT;
ffc1060c: 89 4b 00 74 lbz r10,116(r11)
if ( executing->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_NONE )
ffc10610: 2f 88 00 00 cmpwi cr7,r8,0
if ( !previous_mode_set )
return RTEMS_INVALID_ADDRESS;
executing = _Thread_Executing;
api = executing->API_Extensions[ THREAD_API_RTEMS ];
ffc10614: 81 2b 01 30 lwz r9,304(r11)
asr = &api->Signal;
old_mode = (executing->is_preemptible) ? RTEMS_PREEMPT : RTEMS_NO_PREEMPT;
ffc10618: 7d 4a 00 34 cntlzw r10,r10
ffc1061c: 55 4a d9 7e rlwinm r10,r10,27,5,31
ffc10620: 55 4a 40 2e rlwinm r10,r10,8,0,23
if ( executing->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_NONE )
ffc10624: 41 9e 00 08 beq- cr7,ffc1062c <rtems_task_mode+0x48>
old_mode |= RTEMS_NO_TIMESLICE;
else
old_mode |= RTEMS_TIMESLICE;
ffc10628: 61 4a 02 00 ori r10,r10,512
old_mode |= (asr->is_enabled) ? RTEMS_ASR : RTEMS_NO_ASR;
ffc1062c: 89 09 00 08 lbz r8,8(r9)
ffc10630: 7d 08 00 34 cntlzw r8,r8
ffc10634: 55 08 d9 7e rlwinm r8,r8,27,5,31
ffc10638: 55 08 50 2a rlwinm r8,r8,10,0,21
ffc1063c: 7d 08 53 78 or r8,r8,r10
#ifndef ASM
static inline uint32_t _CPU_ISR_Get_level( void )
{
register unsigned int msr;
_CPU_MSR_GET(msr);
ffc10640: 39 40 00 00 li r10,0
ffc10644: 7d 40 00 a6 mfmsr r10
if (msr & MSR_EE) return 0;
ffc10648: 71 47 80 00 andi. r7,r10,32768
ffc1064c: 7c e0 00 26 mfcr r7
ffc10650: 54 e7 1f fe rlwinm r7,r7,3,31,31
old_mode |= _ISR_Get_level();
ffc10654: 7d 0a 3b 78 or r10,r8,r7
*previous_mode_set = old_mode;
ffc10658: 91 45 00 00 stw r10,0(r5)
/*
* These are generic thread scheduling characteristics.
*/
if ( mask & RTEMS_PREEMPT_MASK )
ffc1065c: 70 8a 01 00 andi. r10,r4,256
ffc10660: 41 82 00 14 beq- ffc10674 <rtems_task_mode+0x90>
executing->is_preemptible = _Modes_Is_preempt(mode_set) ? true : false;
ffc10664: 70 07 01 00 andi. r7,r0,256
ffc10668: 7d 40 00 26 mfcr r10
ffc1066c: 55 4a 1f fe rlwinm r10,r10,3,31,31
ffc10670: 99 4b 00 74 stb r10,116(r11)
if ( mask & RTEMS_TIMESLICE_MASK ) {
ffc10674: 70 8a 02 00 andi. r10,r4,512
ffc10678: 41 82 00 28 beq- ffc106a0 <rtems_task_mode+0xbc>
if ( _Modes_Is_timeslice(mode_set) ) {
ffc1067c: 70 0a 02 00 andi. r10,r0,512
ffc10680: 41 82 00 1c beq- ffc1069c <rtems_task_mode+0xb8>
executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE;
ffc10684: 39 40 00 01 li r10,1
ffc10688: 91 4b 00 7c stw r10,124(r11)
executing->cpu_time_budget = _Thread_Ticks_per_timeslice;
ffc1068c: 3d 40 00 00 lis r10,0
ffc10690: 81 4a 28 08 lwz r10,10248(r10)
ffc10694: 91 4b 00 78 stw r10,120(r11)
ffc10698: 48 00 00 08 b ffc106a0 <rtems_task_mode+0xbc>
} else
executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE;
ffc1069c: 91 4b 00 7c stw r10,124(r11)
}
/*
* Set the new interrupt level
*/
if ( mask & RTEMS_INTERRUPT_MASK )
ffc106a0: 70 8b 00 01 andi. r11,r4,1
ffc106a4: 41 82 00 28 beq- ffc106cc <rtems_task_mode+0xe8>
}
static inline void _CPU_ISR_Set_level( uint32_t level )
{
register unsigned int msr;
_CPU_MSR_GET(msr);
ffc106a8: 39 60 00 00 li r11,0
ffc106ac: 7d 60 00 a6 mfmsr r11
static inline uint32_t ppc_interrupt_get_disable_mask( void )
{
uint32_t mask;
__asm__ volatile (
ffc106b0: 7d 50 42 a6 mfsprg r10,0
if (!(level & CPU_MODES_INTERRUPT_MASK)) {
ffc106b4: 70 07 00 01 andi. r7,r0,1
ffc106b8: 40 82 00 0c bne- ffc106c4 <rtems_task_mode+0xe0>
msr |= ppc_interrupt_get_disable_mask();
ffc106bc: 7d 4b 5b 78 or r11,r10,r11
ffc106c0: 48 00 00 08 b ffc106c8 <rtems_task_mode+0xe4>
}
else {
msr &= ~ppc_interrupt_get_disable_mask();
ffc106c4: 7d 6b 50 78 andc r11,r11,r10
}
_CPU_MSR_SET(msr);
ffc106c8: 7d 60 01 24 mtmsr r11
* This is specific to the RTEMS API
*/
is_asr_enabled = false;
needs_asr_dispatching = false;
if ( mask & RTEMS_ASR_MASK ) {
ffc106cc: 70 8a 04 00 andi. r10,r4,1024
/*
* This is specific to the RTEMS API
*/
is_asr_enabled = false;
needs_asr_dispatching = false;
ffc106d0: 39 60 00 00 li r11,0
if ( mask & RTEMS_ASR_MASK ) {
ffc106d4: 41 82 00 58 beq- ffc1072c <rtems_task_mode+0x148>
* Output:
* *previous_mode_set - previous mode set
* always return RTEMS_SUCCESSFUL;
*/
rtems_status_code rtems_task_mode(
ffc106d8: 70 07 04 00 andi. r7,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 ) {
ffc106dc: 89 49 00 08 lbz r10,8(r9)
* Output:
* *previous_mode_set - previous mode set
* always return RTEMS_SUCCESSFUL;
*/
rtems_status_code rtems_task_mode(
ffc106e0: 7c 00 00 26 mfcr r0
ffc106e4: 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 ) {
ffc106e8: 7f 8a 00 00 cmpw cr7,r10,r0
ffc106ec: 41 9e 00 40 beq- cr7,ffc1072c <rtems_task_mode+0x148>
asr->is_enabled = is_asr_enabled;
ffc106f0: 98 09 00 08 stb r0,8(r9)
static inline uint32_t ppc_interrupt_disable( void )
{
uint32_t level;
uint32_t mask;
__asm__ volatile (
ffc106f4: 7c 00 00 a6 mfmsr r0
ffc106f8: 7d 70 42 a6 mfsprg r11,0
ffc106fc: 7c 0b 58 78 andc r11,r0,r11
ffc10700: 7d 60 01 24 mtmsr r11
{
rtems_signal_set _signals;
ISR_Level _level;
_ISR_Disable( _level );
_signals = information->signals_pending;
ffc10704: 81 69 00 18 lwz r11,24(r9)
information->signals_pending = information->signals_posted;
ffc10708: 81 49 00 14 lwz r10,20(r9)
information->signals_posted = _signals;
ffc1070c: 91 69 00 14 stw r11,20(r9)
rtems_signal_set _signals;
ISR_Level _level;
_ISR_Disable( _level );
_signals = information->signals_pending;
information->signals_pending = information->signals_posted;
ffc10710: 91 49 00 18 stw r10,24(r9)
return level;
}
static inline void ppc_interrupt_enable( uint32_t level )
{
__asm__ volatile (
ffc10714: 7c 00 01 24 mtmsr r0
_ASR_Swap_signals( asr );
if ( _ASR_Are_signals_pending( asr ) ) {
ffc10718: 80 09 00 14 lwz r0,20(r9)
needs_asr_dispatching = true;
ffc1071c: 39 60 00 01 li r11,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 ) ) {
ffc10720: 2f 80 00 00 cmpwi cr7,r0,0
ffc10724: 40 9e 00 08 bne- cr7,ffc1072c <rtems_task_mode+0x148>
/*
* This is specific to the RTEMS API
*/
is_asr_enabled = false;
needs_asr_dispatching = false;
ffc10728: 39 60 00 00 li r11,0
needs_asr_dispatching = true;
}
}
}
if ( _System_state_Is_up( _System_state_Get() ) ) {
ffc1072c: 3d 20 00 00 lis r9,0
ffc10730: 80 09 28 48 lwz r0,10312(r9)
if (_Thread_Evaluate_is_dispatch_needed( needs_asr_dispatching ) )
_Thread_Dispatch();
}
return RTEMS_SUCCESSFUL;
ffc10734: 38 60 00 00 li r3,0
needs_asr_dispatching = true;
}
}
}
if ( _System_state_Is_up( _System_state_Get() ) ) {
ffc10738: 2f 80 00 03 cmpwi cr7,r0,3
ffc1073c: 40 be 00 48 bne+ cr7,ffc10784 <rtems_task_mode+0x1a0>
{
Thread_Control *executing;
executing = _Thread_Executing;
if ( are_signals_pending ||
ffc10740: 2f 8b 00 00 cmpwi cr7,r11,0
bool are_signals_pending
)
{
Thread_Control *executing;
executing = _Thread_Executing;
ffc10744: 3d 40 00 00 lis r10,0
ffc10748: 39 4a 31 44 addi r10,r10,12612
ffc1074c: 81 2a 00 0c lwz r9,12(r10)
if ( are_signals_pending ||
ffc10750: 40 9e 00 1c bne- cr7,ffc1076c <rtems_task_mode+0x188>
ffc10754: 80 0a 00 10 lwz r0,16(r10)
ffc10758: 7f 89 00 00 cmpw cr7,r9,r0
ffc1075c: 41 9e 00 28 beq- cr7,ffc10784 <rtems_task_mode+0x1a0>
(!_Thread_Is_heir( executing ) && executing->is_preemptible) ) {
ffc10760: 88 09 00 74 lbz r0,116(r9)
ffc10764: 2f 80 00 00 cmpwi cr7,r0,0
ffc10768: 41 9e 00 1c beq- cr7,ffc10784 <rtems_task_mode+0x1a0> <== NEVER TAKEN
_Thread_Dispatch_necessary = true;
ffc1076c: 3d 20 00 00 lis r9,0
ffc10770: 38 00 00 01 li r0,1
ffc10774: 39 29 31 44 addi r9,r9,12612
ffc10778: 98 09 00 18 stb r0,24(r9)
if (_Thread_Evaluate_is_dispatch_needed( needs_asr_dispatching ) )
_Thread_Dispatch();
ffc1077c: 4b ff a1 d9 bl ffc0a954 <_Thread_Dispatch>
}
return RTEMS_SUCCESSFUL;
ffc10780: 38 60 00 00 li r3,0
}
ffc10784: 80 01 00 0c lwz r0,12(r1)
ffc10788: 38 21 00 08 addi r1,r1,8
ffc1078c: 7c 08 03 a6 mtlr r0
ffc10790: 4e 80 00 20 blr
ffc0c740 <rtems_task_set_priority>:
rtems_status_code rtems_task_set_priority(
rtems_id id,
rtems_task_priority new_priority,
rtems_task_priority *old_priority
)
{
ffc0c740: 94 21 ff e0 stwu r1,-32(r1)
ffc0c744: 7c 08 02 a6 mflr r0
ffc0c748: bf c1 00 18 stmw r30,24(r1)
register Thread_Control *the_thread;
Objects_Locations location;
if ( new_priority != RTEMS_CURRENT_PRIORITY &&
ffc0c74c: 7c 9f 23 79 mr. r31,r4
rtems_status_code rtems_task_set_priority(
rtems_id id,
rtems_task_priority new_priority,
rtems_task_priority *old_priority
)
{
ffc0c750: 7c be 2b 78 mr r30,r5
ffc0c754: 90 01 00 24 stw r0,36(r1)
register Thread_Control *the_thread;
Objects_Locations location;
if ( new_priority != RTEMS_CURRENT_PRIORITY &&
ffc0c758: 41 82 00 18 beq- ffc0c770 <rtems_task_set_priority+0x30>
RTEMS_INLINE_ROUTINE bool _RTEMS_tasks_Priority_is_valid (
rtems_task_priority the_priority
)
{
return ( ( the_priority >= RTEMS_MINIMUM_PRIORITY ) &&
( the_priority <= RTEMS_MAXIMUM_PRIORITY ) );
ffc0c75c: 3d 20 00 00 lis r9,0
ffc0c760: 89 29 27 44 lbz r9,10052(r9)
!_RTEMS_tasks_Priority_is_valid( new_priority ) )
return RTEMS_INVALID_PRIORITY;
ffc0c764: 38 00 00 13 li r0,19
)
{
register Thread_Control *the_thread;
Objects_Locations location;
if ( new_priority != RTEMS_CURRENT_PRIORITY &&
ffc0c768: 7f 9f 48 40 cmplw cr7,r31,r9
ffc0c76c: 41 bd 00 6c bgt+ cr7,ffc0c7d8 <rtems_task_set_priority+0x98>
!_RTEMS_tasks_Priority_is_valid( new_priority ) )
return RTEMS_INVALID_PRIORITY;
if ( !old_priority )
ffc0c770: 2f 9e 00 00 cmpwi cr7,r30,0
return RTEMS_INVALID_ADDRESS;
ffc0c774: 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 )
ffc0c778: 41 9e 00 60 beq- cr7,ffc0c7d8 <rtems_task_set_priority+0x98>
return RTEMS_INVALID_ADDRESS;
the_thread = _Thread_Get( id, &location );
ffc0c77c: 38 81 00 08 addi r4,r1,8
ffc0c780: 48 00 27 f9 bl ffc0ef78 <_Thread_Get>
switch ( location ) {
ffc0c784: 80 01 00 08 lwz r0,8(r1)
ffc0c788: 2f 80 00 00 cmpwi cr7,r0,0
ffc0c78c: 40 9e 00 48 bne- cr7,ffc0c7d4 <rtems_task_set_priority+0x94>
case OBJECTS_LOCAL:
/* XXX need helper to "convert" from core priority */
*old_priority = the_thread->current_priority;
if ( new_priority != RTEMS_CURRENT_PRIORITY ) {
ffc0c790: 2f 9f 00 00 cmpwi cr7,r31,0
the_thread = _Thread_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
/* XXX need helper to "convert" from core priority */
*old_priority = the_thread->current_priority;
ffc0c794: 80 03 00 14 lwz r0,20(r3)
ffc0c798: 90 1e 00 00 stw r0,0(r30)
if ( new_priority != RTEMS_CURRENT_PRIORITY ) {
ffc0c79c: 41 9e 00 2c beq- cr7,ffc0c7c8 <rtems_task_set_priority+0x88>
the_thread->real_priority = new_priority;
if ( the_thread->resource_count == 0 ||
ffc0c7a0: 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;
ffc0c7a4: 93 e3 00 18 stw r31,24(r3)
if ( the_thread->resource_count == 0 ||
ffc0c7a8: 2f 80 00 00 cmpwi cr7,r0,0
ffc0c7ac: 41 9e 00 10 beq- cr7,ffc0c7bc <rtems_task_set_priority+0x7c>
ffc0c7b0: 80 03 00 14 lwz r0,20(r3)
ffc0c7b4: 7f 80 f8 40 cmplw cr7,r0,r31
ffc0c7b8: 40 9d 00 10 ble- cr7,ffc0c7c8 <rtems_task_set_priority+0x88><== ALWAYS TAKEN
the_thread->current_priority > new_priority )
_Thread_Change_priority( the_thread, new_priority, false );
ffc0c7bc: 7f e4 fb 78 mr r4,r31
ffc0c7c0: 38 a0 00 00 li r5,0
ffc0c7c4: 48 00 22 9d bl ffc0ea60 <_Thread_Change_priority>
}
_Thread_Enable_dispatch();
ffc0c7c8: 48 00 27 75 bl ffc0ef3c <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
ffc0c7cc: 38 00 00 00 li r0,0
ffc0c7d0: 48 00 00 08 b ffc0c7d8 <rtems_task_set_priority+0x98>
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
ffc0c7d4: 38 00 00 04 li r0,4
}
ffc0c7d8: 39 61 00 20 addi r11,r1,32
ffc0c7dc: 7c 03 03 78 mr r3,r0
ffc0c7e0: 4b ff 49 4c b ffc0112c <_restgpr_30_x>
ffc05e78 <rtems_termios_close>:
}
}
rtems_status_code
rtems_termios_close (void *arg)
{
ffc05e78: 94 21 ff f0 stwu r1,-16(r1)
ffc05e7c: 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(
ffc05e80: 38 80 00 00 li r4,0
}
}
rtems_status_code
rtems_termios_close (void *arg)
{
ffc05e84: 90 01 00 14 stw r0,20(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(
ffc05e88: 38 a0 00 00 li r5,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;
ffc05e8c: 81 23 00 00 lwz r9,0(r3)
}
}
rtems_status_code
rtems_termios_close (void *arg)
{
ffc05e90: bf c1 00 08 stmw r30,8(r1)
ffc05e94: 7c 7e 1b 78 mr r30,r3
rtems_libio_open_close_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
ffc05e98: 83 e9 00 38 lwz r31,56(r9)
rtems_status_code sc;
sc = rtems_semaphore_obtain(
ffc05e9c: 3d 20 00 00 lis r9,0
ffc05ea0: 80 69 27 fc lwz r3,10236(r9)
ffc05ea4: 48 00 22 01 bl ffc080a4 <rtems_semaphore_obtain>
rtems_termios_ttyMutex, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
ffc05ea8: 2f 83 00 00 cmpwi cr7,r3,0
ffc05eac: 40 9e 00 b0 bne- cr7,ffc05f5c <rtems_termios_close+0xe4><== NEVER TAKEN
rtems_fatal_error_occurred (sc);
if (--tty->refcount == 0) {
ffc05eb0: 81 3f 00 08 lwz r9,8(r31)
ffc05eb4: 38 09 ff ff addi r0,r9,-1
ffc05eb8: 2f 80 00 00 cmpwi cr7,r0,0
ffc05ebc: 90 1f 00 08 stw r0,8(r31)
ffc05ec0: 40 9e 01 70 bne- cr7,ffc06030 <rtems_termios_close+0x1b8>
if (rtems_termios_linesw[tty->t_line].l_close != NULL) {
ffc05ec4: 80 1f 00 cc lwz r0,204(r31)
ffc05ec8: 3d 20 00 00 lis r9,0
ffc05ecc: 39 29 28 f0 addi r9,r9,10480
ffc05ed0: 54 00 28 34 rlwinm r0,r0,5,0,26
ffc05ed4: 7d 29 02 14 add r9,r9,r0
ffc05ed8: 80 09 00 04 lwz r0,4(r9)
ffc05edc: 2f 80 00 00 cmpwi cr7,r0,0
ffc05ee0: 41 9e 00 14 beq- cr7,ffc05ef4 <rtems_termios_close+0x7c>
/*
* call discipline-specific close
*/
sc = rtems_termios_linesw[tty->t_line].l_close(tty);
ffc05ee4: 7f e3 fb 78 mr r3,r31
ffc05ee8: 7c 09 03 a6 mtctr r0
ffc05eec: 4e 80 04 21 bctrl
ffc05ef0: 48 00 00 38 b ffc05f28 <rtems_termios_close+0xb0>
} else {
/*
* default: just flush output buffer
*/
sc = rtems_semaphore_obtain(tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
ffc05ef4: 80 7f 00 18 lwz r3,24(r31)
ffc05ef8: 38 80 00 00 li r4,0
ffc05efc: 38 a0 00 00 li r5,0
ffc05f00: 48 00 21 a5 bl ffc080a4 <rtems_semaphore_obtain>
if (sc != RTEMS_SUCCESSFUL) {
ffc05f04: 2f 83 00 00 cmpwi cr7,r3,0
ffc05f08: 40 9e 00 54 bne- cr7,ffc05f5c <rtems_termios_close+0xe4><== NEVER TAKEN
drainOutput (struct rtems_termios_tty *tty)
{
rtems_interrupt_level level;
rtems_status_code sc;
if (tty->device.outputUsesInterrupts != TERMIOS_POLLED) {
ffc05f0c: 80 1f 00 b4 lwz r0,180(r31)
ffc05f10: 2f 80 00 00 cmpwi cr7,r0,0
ffc05f14: 41 be 00 0c beq+ cr7,ffc05f20 <rtems_termios_close+0xa8>
ffc05f18: 7f e3 fb 78 mr r3,r31
ffc05f1c: 4b ff fa e5 bl ffc05a00 <drainOutput.part.0>
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);
ffc05f20: 80 7f 00 18 lwz r3,24(r31)
ffc05f24: 48 00 22 ad bl ffc081d0 <rtems_semaphore_release>
}
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
ffc05f28: 80 1f 00 b4 lwz r0,180(r31)
ffc05f2c: 2f 80 00 02 cmpwi cr7,r0,2
ffc05f30: 40 be 00 30 bne+ cr7,ffc05f60 <rtems_termios_close+0xe8>
/*
* send "terminate" to I/O tasks
*/
sc = rtems_event_send( tty->rxTaskId, TERMIOS_RX_TERMINATE_EVENT );
ffc05f34: 80 7f 00 c4 lwz r3,196(r31)
ffc05f38: 38 80 00 01 li r4,1
ffc05f3c: 48 00 1c b5 bl ffc07bf0 <rtems_event_send>
if (sc != RTEMS_SUCCESSFUL)
ffc05f40: 2f 83 00 00 cmpwi cr7,r3,0
ffc05f44: 40 9e 00 18 bne- cr7,ffc05f5c <rtems_termios_close+0xe4><== NEVER TAKEN
rtems_fatal_error_occurred (sc);
sc = rtems_event_send( tty->txTaskId, TERMIOS_TX_TERMINATE_EVENT );
ffc05f48: 80 7f 00 c8 lwz r3,200(r31)
ffc05f4c: 38 80 00 01 li r4,1
ffc05f50: 48 00 1c a1 bl ffc07bf0 <rtems_event_send>
if (sc != RTEMS_SUCCESSFUL)
ffc05f54: 2f 83 00 00 cmpwi cr7,r3,0
ffc05f58: 41 be 00 08 beq+ cr7,ffc05f60 <rtems_termios_close+0xe8><== ALWAYS TAKEN
rtems_fatal_error_occurred (sc);
ffc05f5c: 48 00 29 21 bl ffc0887c <rtems_fatal_error_occurred> <== NOT EXECUTED
}
if (tty->device.lastClose)
ffc05f60: 80 1f 00 9c lwz r0,156(r31)
ffc05f64: 2f 80 00 00 cmpwi cr7,r0,0
ffc05f68: 41 9e 00 18 beq- cr7,ffc05f80 <rtems_termios_close+0x108><== ALWAYS TAKEN
(*tty->device.lastClose)(tty->major, tty->minor, arg);
ffc05f6c: 80 7f 00 0c lwz r3,12(r31) <== NOT EXECUTED
ffc05f70: 7f c5 f3 78 mr r5,r30 <== NOT EXECUTED
ffc05f74: 80 9f 00 10 lwz r4,16(r31) <== NOT EXECUTED
ffc05f78: 7c 09 03 a6 mtctr r0 <== NOT EXECUTED
ffc05f7c: 4e 80 04 21 bctrl <== NOT EXECUTED
if (tty->forw == NULL) {
ffc05f80: 81 7f 00 00 lwz r11,0(r31)
ffc05f84: 81 3f 00 04 lwz r9,4(r31)
ffc05f88: 2f 8b 00 00 cmpwi cr7,r11,0
ffc05f8c: 40 be 00 1c bne+ cr7,ffc05fa8 <rtems_termios_close+0x130>
rtems_termios_ttyTail = tty->back;
if ( rtems_termios_ttyTail != NULL ) {
ffc05f90: 2f 89 00 00 cmpwi cr7,r9,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;
ffc05f94: 3d 40 00 00 lis r10,0
ffc05f98: 91 2a 28 00 stw r9,10240(r10)
if ( rtems_termios_ttyTail != NULL ) {
ffc05f9c: 41 9e 00 10 beq- cr7,ffc05fac <rtems_termios_close+0x134><== ALWAYS TAKEN
rtems_termios_ttyTail->forw = NULL;
ffc05fa0: 91 69 00 00 stw r11,0(r9) <== NOT EXECUTED
ffc05fa4: 48 00 00 08 b ffc05fac <rtems_termios_close+0x134> <== NOT EXECUTED
}
} else {
tty->forw->back = tty->back;
ffc05fa8: 91 2b 00 04 stw r9,4(r11)
}
if (tty->back == NULL) {
ffc05fac: 81 7f 00 04 lwz r11,4(r31)
ffc05fb0: 81 3f 00 00 lwz r9,0(r31)
ffc05fb4: 2f 8b 00 00 cmpwi cr7,r11,0
ffc05fb8: 40 be 00 1c bne+ cr7,ffc05fd4 <rtems_termios_close+0x15c><== NEVER TAKEN
rtems_termios_ttyHead = tty->forw;
if ( rtems_termios_ttyHead != NULL ) {
ffc05fbc: 2f 89 00 00 cmpwi cr7,r9,0
} else {
tty->forw->back = tty->back;
}
if (tty->back == NULL) {
rtems_termios_ttyHead = tty->forw;
ffc05fc0: 3d 40 00 00 lis r10,0
ffc05fc4: 91 2a 28 04 stw r9,10244(r10)
if ( rtems_termios_ttyHead != NULL ) {
ffc05fc8: 41 9e 00 10 beq- cr7,ffc05fd8 <rtems_termios_close+0x160>
rtems_termios_ttyHead->back = NULL;
ffc05fcc: 91 69 00 04 stw r11,4(r9)
ffc05fd0: 48 00 00 08 b ffc05fd8 <rtems_termios_close+0x160>
}
} else {
tty->back->forw = tty->forw;
ffc05fd4: 91 2b 00 00 stw r9,0(r11) <== NOT EXECUTED
}
rtems_semaphore_delete (tty->isem);
ffc05fd8: 80 7f 00 14 lwz r3,20(r31)
ffc05fdc: 48 00 20 11 bl ffc07fec <rtems_semaphore_delete>
rtems_semaphore_delete (tty->osem);
ffc05fe0: 80 7f 00 18 lwz r3,24(r31)
ffc05fe4: 48 00 20 09 bl ffc07fec <rtems_semaphore_delete>
rtems_semaphore_delete (tty->rawOutBuf.Semaphore);
ffc05fe8: 80 7f 00 8c lwz r3,140(r31)
ffc05fec: 48 00 20 01 bl ffc07fec <rtems_semaphore_delete>
if ((tty->device.pollRead == NULL) ||
ffc05ff0: 80 1f 00 a0 lwz r0,160(r31)
ffc05ff4: 2f 80 00 00 cmpwi cr7,r0,0
ffc05ff8: 41 9e 00 10 beq- cr7,ffc06008 <rtems_termios_close+0x190>
ffc05ffc: 80 1f 00 b4 lwz r0,180(r31)
ffc06000: 2f 80 00 02 cmpwi cr7,r0,2
ffc06004: 40 be 00 0c bne+ cr7,ffc06010 <rtems_termios_close+0x198>
(tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN))
rtems_semaphore_delete (tty->rawInBuf.Semaphore);
ffc06008: 80 7f 00 68 lwz r3,104(r31)
ffc0600c: 48 00 1f e1 bl ffc07fec <rtems_semaphore_delete>
free (tty->rawInBuf.theBuf);
ffc06010: 80 7f 00 58 lwz r3,88(r31)
ffc06014: 4b ff e9 49 bl ffc0495c <free>
free (tty->rawOutBuf.theBuf);
ffc06018: 80 7f 00 7c lwz r3,124(r31)
ffc0601c: 4b ff e9 41 bl ffc0495c <free>
free (tty->cbuf);
ffc06020: 80 7f 00 1c lwz r3,28(r31)
ffc06024: 4b ff e9 39 bl ffc0495c <free>
free (tty);
ffc06028: 7f e3 fb 78 mr r3,r31
ffc0602c: 4b ff e9 31 bl ffc0495c <free>
}
rtems_semaphore_release (rtems_termios_ttyMutex);
ffc06030: 3d 20 00 00 lis r9,0
ffc06034: 80 69 27 fc lwz r3,10236(r9)
ffc06038: 48 00 21 99 bl ffc081d0 <rtems_semaphore_release>
return RTEMS_SUCCESSFUL;
}
ffc0603c: 39 61 00 10 addi r11,r1,16
ffc06040: 38 60 00 00 li r3,0
ffc06044: 4b ff a4 fc b ffc00540 <_restgpr_30_x>
ffc075a8 <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)
{
ffc075a8: 94 21 ff f8 stwu r1,-8(r1)
ffc075ac: 7c 08 02 a6 mflr r0
ffc075b0: 90 01 00 0c stw r0,12(r1)
rtems_status_code sc;
/*
* sum up character count already sent
*/
tty->t_dqlen += len;
ffc075b4: 80 03 00 90 lwz r0,144(r3)
ffc075b8: 7c 00 22 14 add r0,r0,r4
ffc075bc: 90 03 00 90 stw r0,144(r3)
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
ffc075c0: 80 03 00 b4 lwz r0,180(r3)
ffc075c4: 2f 80 00 02 cmpwi cr7,r0,2
ffc075c8: 40 be 00 1c bne+ cr7,ffc075e4 <rtems_termios_dequeue_characters+0x3c>
/*
* send wake up to transmitter task
*/
sc = rtems_event_send(tty->txTaskId, TERMIOS_TX_START_EVENT);
ffc075cc: 80 63 00 c8 lwz r3,200(r3)
ffc075d0: 38 80 00 02 li r4,2
ffc075d4: 48 00 06 1d bl ffc07bf0 <rtems_event_send>
if (sc != RTEMS_SUCCESSFUL)
ffc075d8: 2f 83 00 00 cmpwi cr7,r3,0
ffc075dc: 41 be 00 40 beq+ cr7,ffc0761c <rtems_termios_dequeue_characters+0x74><== ALWAYS TAKEN
rtems_fatal_error_occurred (sc);
ffc075e0: 48 00 12 9d bl ffc0887c <rtems_fatal_error_occurred> <== NOT EXECUTED
return 0; /* nothing to output in IRQ... */
}
if (tty->t_line == PPPDISC ) {
ffc075e4: 80 03 00 cc lwz r0,204(r3)
ffc075e8: 2f 80 00 05 cmpwi cr7,r0,5
ffc075ec: 40 9e 00 20 bne- cr7,ffc0760c <rtems_termios_dequeue_characters+0x64>
/*
* call any line discipline start function
*/
if (rtems_termios_linesw[tty->t_line].l_start != NULL) {
ffc075f0: 3d 20 00 00 lis r9,0
ffc075f4: 80 09 29 a4 lwz r0,10660(r9)
ffc075f8: 2f 80 00 00 cmpwi cr7,r0,0
ffc075fc: 41 9e 00 20 beq- cr7,ffc0761c <rtems_termios_dequeue_characters+0x74><== NEVER TAKEN
rtems_termios_linesw[tty->t_line].l_start(tty);
ffc07600: 7c 09 03 a6 mtctr r0
ffc07604: 4e 80 04 21 bctrl
ffc07608: 48 00 00 14 b ffc0761c <rtems_termios_dequeue_characters+0x74>
}
return 0; /* nothing to output in IRQ... */
}
return rtems_termios_refill_transmitter(tty);
}
ffc0760c: 80 01 00 0c lwz r0,12(r1)
ffc07610: 38 21 00 08 addi r1,r1,8
ffc07614: 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);
ffc07618: 4b ff fd 30 b ffc07348 <rtems_termios_refill_transmitter>
}
ffc0761c: 80 01 00 0c lwz r0,12(r1)
ffc07620: 38 60 00 00 li r3,0
ffc07624: 38 21 00 08 addi r1,r1,8
ffc07628: 7c 08 03 a6 mtlr r0
ffc0762c: 4e 80 00 20 blr
ffc06ff8 <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)
{
ffc06ff8: 94 21 ff c8 stwu r1,-56(r1)
ffc06ffc: 7c 08 02 a6 mflr r0
ffc07000: 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) {
ffc07004: 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)
{
ffc07008: be a1 00 0c stmw r21,12(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) {
ffc0700c: 3f a0 00 00 lis r29,0
ffc07010: 3b bd 28 f0 addi r29,r29,10480
ffc07014: 55 29 28 34 rlwinm r9,r9,5,0,26
ffc07018: 7d 3d 4a 14 add r9,r29,r9
ffc0701c: 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)
{
ffc07020: 7c 7f 1b 78 mr r31,r3
ffc07024: 7c 99 23 78 mr r25,r4
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) {
ffc07028: 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)
{
ffc0702c: 7c b8 2b 78 mr r24,r5
* 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)
ffc07030: 3b c0 00 00 li r30,0
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) {
ffc07034: 40 be 00 3c bne+ cr7,ffc07070 <rtems_termios_enqueue_raw_characters+0x78>
* 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)
ffc07038: 3b a0 00 00 li r29,0
ffc0703c: 3b 40 00 00 li r26,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);
ffc07040: 3a c3 00 30 addi r22,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,
ffc07044: 3a e3 00 4a addi r23,r3,74
ffc07048: 48 00 02 60 b ffc072a8 <rtems_termios_enqueue_raw_characters+0x2b0>
rtems_interrupt_level level;
if (rtems_termios_linesw[tty->t_line].l_rint != NULL) {
while (len--) {
c = *buf++;
rtems_termios_linesw[tty->t_line].l_rint(c,tty);
ffc0704c: 81 3f 00 cc lwz r9,204(r31)
ffc07050: 7f e4 fb 78 mr r4,r31
ffc07054: 7c 79 f0 ae lbzx r3,r25,r30
ffc07058: 3b de 00 01 addi r30,r30,1
ffc0705c: 55 29 28 34 rlwinm r9,r9,5,0,26
ffc07060: 7d 3d 4a 14 add r9,r29,r9
ffc07064: 80 09 00 10 lwz r0,16(r9)
ffc07068: 7c 09 03 a6 mtctr r0
ffc0706c: 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--) {
ffc07070: 7f 9e c0 00 cmpw cr7,r30,r24
ffc07074: 40 9e ff d8 bne+ cr7,ffc0704c <rtems_termios_enqueue_raw_characters+0x54>
}
/*
* check to see if rcv wakeup callback was set
*/
if (( !tty->tty_rcvwakeup ) && ( tty->tty_rcv.sw_pfn != NULL )) {
ffc07078: 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;
ffc0707c: 3b c0 00 00 li r30,0
}
/*
* check to see if rcv wakeup callback was set
*/
if (( !tty->tty_rcvwakeup ) && ( tty->tty_rcv.sw_pfn != NULL )) {
ffc07080: 2f 80 00 00 cmpwi cr7,r0,0
ffc07084: 40 9e 02 40 bne- cr7,ffc072c4 <rtems_termios_enqueue_raw_characters+0x2cc><== NEVER TAKEN
ffc07088: 80 1f 00 dc lwz r0,220(r31)
ffc0708c: 2f 80 00 00 cmpwi cr7,r0,0
ffc07090: 41 9e 02 34 beq- cr7,ffc072c4 <rtems_termios_enqueue_raw_characters+0x2cc>
(*tty->tty_rcv.sw_pfn)(&tty->termios, tty->tty_rcv.sw_arg);
ffc07094: 7c 09 03 a6 mtctr r0
ffc07098: 38 7f 00 30 addi r3,r31,48
ffc0709c: 80 9f 00 e0 lwz r4,224(r31)
ffc070a0: 4e 80 04 21 bctrl
tty->tty_rcvwakeup = 1;
ffc070a4: 38 00 00 01 li r0,1
ffc070a8: 90 1f 00 e4 stw r0,228(r31)
ffc070ac: 48 00 02 18 b ffc072c4 <rtems_termios_enqueue_raw_characters+0x2cc>
while (len--) {
c = *buf++;
/* FIXME: implement IXANY: any character restarts output */
/* if incoming XON/XOFF controls outgoing stream: */
if (tty->flow_ctrl & FL_MDXON) {
ffc070b0: 80 1f 00 b8 lwz r0,184(r31)
}
return 0;
}
while (len--) {
c = *buf++;
ffc070b4: 7f 79 e8 ae lbzx r27,r25,r29
/* FIXME: implement IXANY: any character restarts output */
/* if incoming XON/XOFF controls outgoing stream: */
if (tty->flow_ctrl & FL_MDXON) {
ffc070b8: 70 09 02 00 andi. r9,r0,512
ffc070bc: 41 82 00 50 beq- ffc0710c <rtems_termios_enqueue_raw_characters+0x114>
/* if received char is V_STOP and V_START (both are equal value) */
if (c == tty->termios.c_cc[VSTOP]) {
ffc070c0: 89 3f 00 4a lbz r9,74(r31)
ffc070c4: 88 1f 00 49 lbz r0,73(r31)
ffc070c8: 7f 89 d8 00 cmpw cr7,r9,r27
if (c == tty->termios.c_cc[VSTART]) {
ffc070cc: 54 00 06 3e clrlwi r0,r0,24
c = *buf++;
/* 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]) {
ffc070d0: 40 be 00 28 bne+ cr7,ffc070f8 <rtems_termios_enqueue_raw_characters+0x100>
if (c == tty->termios.c_cc[VSTART]) {
ffc070d4: 7f 80 48 00 cmpw cr7,r0,r9
/* received VSTOP and VSTART==VSTOP? */
/* then toggle "stop output" status */
tty->flow_ctrl = tty->flow_ctrl ^ FL_ORCVXOF;
ffc070d8: 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]) {
ffc070dc: 40 be 00 0c bne+ cr7,ffc070e8 <rtems_termios_enqueue_raw_characters+0xf0><== ALWAYS TAKEN
/* received VSTOP and VSTART==VSTOP? */
/* then toggle "stop output" status */
tty->flow_ctrl = tty->flow_ctrl ^ FL_ORCVXOF;
ffc070e0: 68 00 00 10 xori r0,r0,16 <== NOT EXECUTED
ffc070e4: 48 00 00 08 b ffc070ec <rtems_termios_enqueue_raw_characters+0xf4><== NOT EXECUTED
}
else {
/* VSTOP received (other code than VSTART) */
/* stop output */
tty->flow_ctrl |= FL_ORCVXOF;
ffc070e8: 60 00 00 10 ori r0,r0,16
ffc070ec: 90 1f 00 b8 stw r0,184(r31)
* 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)
ffc070f0: 3b 40 00 01 li r26,1
ffc070f4: 48 00 00 20 b ffc07114 <rtems_termios_enqueue_raw_characters+0x11c>
/* stop output */
tty->flow_ctrl |= FL_ORCVXOF;
}
flow_rcv = true;
}
else if (c == tty->termios.c_cc[VSTART]) {
ffc070f8: 7f 80 d8 00 cmpw cr7,r0,r27
ffc070fc: 40 be 00 10 bne+ cr7,ffc0710c <rtems_termios_enqueue_raw_characters+0x114><== ALWAYS TAKEN
/* VSTART received */
/* restart output */
tty->flow_ctrl &= ~FL_ORCVXOF;
ffc07100: 80 1f 00 b8 lwz r0,184(r31) <== NOT EXECUTED
ffc07104: 54 00 07 34 rlwinm r0,r0,0,28,26 <== NOT EXECUTED
ffc07108: 4b ff ff e4 b ffc070ec <rtems_termios_enqueue_raw_characters+0xf4><== NOT EXECUTED
flow_rcv = true;
}
}
if (flow_rcv) {
ffc0710c: 2f 9a 00 00 cmpwi cr7,r26,0
ffc07110: 41 9e 00 5c beq- cr7,ffc0716c <rtems_termios_enqueue_raw_characters+0x174><== ALWAYS TAKEN
/* restart output according to FL_ORCVXOF flag */
if ((tty->flow_ctrl & (FL_ORCVXOF | FL_OSTOP)) == FL_OSTOP) {
ffc07114: 80 1f 00 b8 lwz r0,184(r31)
ffc07118: 54 00 06 b6 rlwinm r0,r0,0,26,27
ffc0711c: 2f 80 00 20 cmpwi cr7,r0,32
ffc07120: 40 be 01 84 bne+ cr7,ffc072a4 <rtems_termios_enqueue_raw_characters+0x2ac><== ALWAYS TAKEN
/* disable interrupts */
rtems_interrupt_disable(level);
ffc07124: 4b ff e8 c9 bl ffc059ec <ppc_interrupt_disable> <== NOT EXECUTED
ffc07128: 7c 7c 1b 78 mr r28,r3 <== NOT EXECUTED
tty->flow_ctrl &= ~FL_OSTOP;
ffc0712c: 80 1f 00 b8 lwz r0,184(r31) <== NOT EXECUTED
ffc07130: 54 00 06 f2 rlwinm r0,r0,0,27,25 <== NOT EXECUTED
ffc07134: 90 1f 00 b8 stw r0,184(r31) <== NOT EXECUTED
/* check for chars in output buffer (or rob_state?) */
if (tty->rawOutBufState != rob_idle) {
ffc07138: 80 1f 00 94 lwz r0,148(r31) <== NOT EXECUTED
ffc0713c: 2f 80 00 00 cmpwi cr7,r0,0 <== NOT EXECUTED
ffc07140: 41 be 00 24 beq+ cr7,ffc07164 <rtems_termios_enqueue_raw_characters+0x16c><== NOT EXECUTED
/* if chars available, call write function... */
(*tty->device.write)(
tty->minor, &tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail], 1);
ffc07144: 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)(
ffc07148: 38 a0 00 01 li r5,1 <== NOT EXECUTED
ffc0714c: 80 9f 00 7c lwz r4,124(r31) <== NOT EXECUTED
ffc07150: 80 1f 00 a4 lwz r0,164(r31) <== NOT EXECUTED
ffc07154: 80 7f 00 10 lwz r3,16(r31) <== NOT EXECUTED
ffc07158: 7c 84 4a 14 add r4,r4,r9 <== NOT EXECUTED
ffc0715c: 7c 09 03 a6 mtctr r0 <== NOT EXECUTED
ffc07160: 4e 80 04 21 bctrl <== NOT EXECUTED
ffc07164: 7f 80 01 24 mtmsr r28 <== NOT EXECUTED
ffc07168: 48 00 01 3c b ffc072a4 <rtems_termios_enqueue_raw_characters+0x2ac><== NOT EXECUTED
}
/* reenable interrupts */
rtems_interrupt_enable(level);
}
} else {
newTail = (tty->rawInBuf.Tail + 1) % tty->rawInBuf.Size;
ffc0716c: 83 9f 00 60 lwz r28,96(r31)
ffc07170: 81 3f 00 64 lwz r9,100(r31)
ffc07174: 38 1c 00 01 addi r0,r28,1
ffc07178: 7f 80 4b 96 divwu r28,r0,r9
ffc0717c: 7f 9c 49 d6 mullw r28,r28,r9
ffc07180: 7f 9c 00 50 subf r28,r28,r0
/* if chars_in_buffer > highwater */
rtems_interrupt_disable(level);
ffc07184: 4b ff e8 69 bl ffc059ec <ppc_interrupt_disable>
ffc07188: 7c 75 1b 78 mr r21,r3
if ((((newTail - tty->rawInBuf.Head + tty->rawInBuf.Size)
ffc0718c: 80 1f 00 5c lwz r0,92(r31)
ffc07190: 81 7f 00 64 lwz r11,100(r31)
% tty->rawInBuf.Size) > tty->highwater) &&
ffc07194: 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)
ffc07198: 7c 00 58 50 subf r0,r0,r11
ffc0719c: 7c 00 e2 14 add r0,r0,r28
% tty->rawInBuf.Size) > tty->highwater) &&
ffc071a0: 7d 60 4b 96 divwu r11,r0,r9
ffc071a4: 7d 2b 49 d6 mullw r9,r11,r9
}
} 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)
ffc071a8: 81 7f 00 c0 lwz r11,192(r31)
% tty->rawInBuf.Size) > tty->highwater) &&
ffc071ac: 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)
ffc071b0: 7f 80 58 40 cmplw cr7,r0,r11
ffc071b4: 40 9d 00 9c ble- cr7,ffc07250 <rtems_termios_enqueue_raw_characters+0x258><== ALWAYS TAKEN
% tty->rawInBuf.Size) > tty->highwater) &&
!(tty->flow_ctrl & FL_IREQXOF)) {
ffc071b8: 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) &&
ffc071bc: 70 09 00 01 andi. r9,r0,1 <== NOT EXECUTED
ffc071c0: 40 82 00 90 bne- ffc07250 <rtems_termios_enqueue_raw_characters+0x258><== NOT EXECUTED
!(tty->flow_ctrl & FL_IREQXOF)) {
/* incoming data stream should be stopped */
tty->flow_ctrl |= FL_IREQXOF;
ffc071c4: 80 1f 00 b8 lwz r0,184(r31) <== NOT EXECUTED
ffc071c8: 60 00 00 01 ori r0,r0,1 <== NOT EXECUTED
ffc071cc: 90 1f 00 b8 stw r0,184(r31) <== NOT EXECUTED
if ((tty->flow_ctrl & (FL_MDXOF | FL_ISNTXOF))
ffc071d0: 80 1f 00 b8 lwz r0,184(r31) <== NOT EXECUTED
ffc071d4: 70 00 04 02 andi. r0,r0,1026 <== NOT EXECUTED
ffc071d8: 2f 80 04 00 cmpwi cr7,r0,1024 <== NOT EXECUTED
== (FL_MDXOF ) ) {
if ((tty->flow_ctrl & FL_OSTOP) ||
ffc071dc: 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))
ffc071e0: 40 be 00 40 bne+ cr7,ffc07220 <rtems_termios_enqueue_raw_characters+0x228><== NOT EXECUTED
== (FL_MDXOF ) ) {
if ((tty->flow_ctrl & FL_OSTOP) ||
ffc071e4: 70 09 00 20 andi. r9,r0,32 <== NOT EXECUTED
ffc071e8: 40 82 00 10 bne- ffc071f8 <rtems_termios_enqueue_raw_characters+0x200><== NOT EXECUTED
ffc071ec: 80 1f 00 94 lwz r0,148(r31) <== NOT EXECUTED
ffc071f0: 2f 80 00 00 cmpwi cr7,r0,0 <== NOT EXECUTED
ffc071f4: 40 9e 00 5c bne- cr7,ffc07250 <rtems_termios_enqueue_raw_characters+0x258><== 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;
ffc071f8: 80 1f 00 b8 lwz r0,184(r31) <== NOT EXECUTED
(*tty->device.write)(tty->minor,
ffc071fc: 7e e4 bb 78 mr r4,r23 <== NOT EXECUTED
ffc07200: 80 7f 00 10 lwz r3,16(r31) <== NOT EXECUTED
ffc07204: 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;
ffc07208: 60 00 00 02 ori r0,r0,2 <== NOT EXECUTED
ffc0720c: 90 1f 00 b8 stw r0,184(r31) <== NOT EXECUTED
(*tty->device.write)(tty->minor,
ffc07210: 80 1f 00 a4 lwz r0,164(r31) <== NOT EXECUTED
ffc07214: 7c 09 03 a6 mtctr r0 <== NOT EXECUTED
ffc07218: 4e 80 04 21 bctrl <== NOT EXECUTED
ffc0721c: 48 00 00 34 b ffc07250 <rtems_termios_enqueue_raw_characters+0x258><== NOT EXECUTED
(void *)&(tty->termios.c_cc[VSTOP]), 1);
}
} else if ((tty->flow_ctrl & (FL_MDRTS | FL_IRTSOFF)) == (FL_MDRTS) ) {
ffc07220: 70 00 01 04 andi. r0,r0,260 <== NOT EXECUTED
ffc07224: 2f 80 01 00 cmpwi cr7,r0,256 <== NOT EXECUTED
ffc07228: 40 be 00 28 bne+ cr7,ffc07250 <rtems_termios_enqueue_raw_characters+0x258><== NOT EXECUTED
tty->flow_ctrl |= FL_IRTSOFF;
ffc0722c: 80 1f 00 b8 lwz r0,184(r31) <== NOT EXECUTED
ffc07230: 60 00 00 04 ori r0,r0,4 <== NOT EXECUTED
ffc07234: 90 1f 00 b8 stw r0,184(r31) <== NOT EXECUTED
/* deactivate RTS line */
if (tty->device.stopRemoteTx != NULL) {
ffc07238: 80 1f 00 ac lwz r0,172(r31) <== NOT EXECUTED
ffc0723c: 2f 80 00 00 cmpwi cr7,r0,0 <== NOT EXECUTED
ffc07240: 41 9e 00 10 beq- cr7,ffc07250 <rtems_termios_enqueue_raw_characters+0x258><== NOT EXECUTED
tty->device.stopRemoteTx(tty->minor);
ffc07244: 80 7f 00 10 lwz r3,16(r31) <== NOT EXECUTED
ffc07248: 7c 09 03 a6 mtctr r0 <== NOT EXECUTED
ffc0724c: 4e 80 04 21 bctrl <== NOT EXECUTED
ffc07250: 7e a0 01 24 mtmsr r21
}
/* reenable interrupts */
rtems_interrupt_enable(level);
if (newTail == tty->rawInBuf.Head) {
ffc07254: 80 1f 00 5c lwz r0,92(r31)
ffc07258: 7f 9c 00 00 cmpw cr7,r28,r0
ffc0725c: 40 be 00 0c bne+ cr7,ffc07268 <rtems_termios_enqueue_raw_characters+0x270><== ALWAYS TAKEN
dropped++;
ffc07260: 3b de 00 01 addi r30,r30,1 <== NOT EXECUTED
ffc07264: 48 00 00 40 b ffc072a4 <rtems_termios_enqueue_raw_characters+0x2ac><== NOT EXECUTED
} else {
tty->rawInBuf.theBuf[newTail] = c;
ffc07268: 81 3f 00 58 lwz r9,88(r31)
ffc0726c: 7f 69 e1 ae stbx r27,r9,r28
tty->rawInBuf.Tail = newTail;
/*
* check to see if rcv wakeup callback was set
*/
if (( !tty->tty_rcvwakeup ) && ( tty->tty_rcv.sw_pfn != NULL )) {
ffc07270: 80 1f 00 e4 lwz r0,228(r31)
if (newTail == tty->rawInBuf.Head) {
dropped++;
} else {
tty->rawInBuf.theBuf[newTail] = c;
tty->rawInBuf.Tail = newTail;
ffc07274: 93 9f 00 60 stw r28,96(r31)
/*
* check to see if rcv wakeup callback was set
*/
if (( !tty->tty_rcvwakeup ) && ( tty->tty_rcv.sw_pfn != NULL )) {
ffc07278: 2f 80 00 00 cmpwi cr7,r0,0
ffc0727c: 40 9e 00 28 bne- cr7,ffc072a4 <rtems_termios_enqueue_raw_characters+0x2ac><== NEVER TAKEN
ffc07280: 80 1f 00 dc lwz r0,220(r31)
ffc07284: 2f 80 00 00 cmpwi cr7,r0,0
ffc07288: 41 9e 00 1c beq- cr7,ffc072a4 <rtems_termios_enqueue_raw_characters+0x2ac><== ALWAYS TAKEN
(*tty->tty_rcv.sw_pfn)(&tty->termios, tty->tty_rcv.sw_arg);
ffc0728c: 7c 09 03 a6 mtctr r0 <== NOT EXECUTED
ffc07290: 7e c3 b3 78 mr r3,r22 <== NOT EXECUTED
ffc07294: 80 9f 00 e0 lwz r4,224(r31) <== NOT EXECUTED
ffc07298: 4e 80 04 21 bctrl <== NOT EXECUTED
tty->tty_rcvwakeup = 1;
ffc0729c: 38 00 00 01 li r0,1 <== NOT EXECUTED
ffc072a0: 90 1f 00 e4 stw r0,228(r31) <== NOT EXECUTED
ffc072a4: 3b bd 00 01 addi r29,r29,1
tty->tty_rcvwakeup = 1;
}
return 0;
}
while (len--) {
ffc072a8: 7f 9d c0 00 cmpw cr7,r29,r24
ffc072ac: 40 9e fe 04 bne+ cr7,ffc070b0 <rtems_termios_enqueue_raw_characters+0xb8>
}
}
}
}
tty->rawInBufDropped += dropped;
ffc072b0: 80 1f 00 78 lwz r0,120(r31)
rtems_semaphore_release (tty->rawInBuf.Semaphore);
ffc072b4: 80 7f 00 68 lwz r3,104(r31)
}
}
}
}
tty->rawInBufDropped += dropped;
ffc072b8: 7c 00 f2 14 add r0,r0,r30
ffc072bc: 90 1f 00 78 stw r0,120(r31)
rtems_semaphore_release (tty->rawInBuf.Semaphore);
ffc072c0: 48 00 0f 11 bl ffc081d0 <rtems_semaphore_release>
return dropped;
}
ffc072c4: 39 61 00 38 addi r11,r1,56
ffc072c8: 7f c3 f3 78 mr r3,r30
ffc072cc: 4b ff 92 50 b ffc0051c <_restgpr_21_x>
ffc06064 <rtems_termios_ioctl>:
}
}
rtems_status_code
rtems_termios_ioctl (void *arg)
{
ffc06064: 94 21 ff e0 stwu r1,-32(r1)
ffc06068: 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);
ffc0606c: 38 80 00 00 li r4,0
}
}
rtems_status_code
rtems_termios_ioctl (void *arg)
{
ffc06070: 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;
ffc06074: 38 00 00 00 li r0,0
sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
ffc06078: 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;
ffc0607c: 81 23 00 00 lwz r9,0(r3)
}
}
rtems_status_code
rtems_termios_ioctl (void *arg)
{
ffc06080: bf 61 00 0c stmw r27,12(r1)
ffc06084: 7c 7e 1b 78 mr r30,r3
rtems_libio_ioctl_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
ffc06088: 83 e9 00 38 lwz r31,56(r9)
struct ttywakeup *wakeup = (struct ttywakeup *)args->buffer;
ffc0608c: 83 83 00 08 lwz r28,8(r3)
rtems_status_code sc;
args->ioctl_return = 0;
ffc06090: 90 03 00 0c stw r0,12(r3)
sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
ffc06094: 80 7f 00 18 lwz r3,24(r31)
ffc06098: 48 00 20 0d bl ffc080a4 <rtems_semaphore_obtain>
if (sc != RTEMS_SUCCESSFUL) {
ffc0609c: 7c 7d 1b 79 mr. r29,r3
ffc060a0: 40 82 03 9c bne- ffc0643c <rtems_termios_ioctl+0x3d8> <== NEVER TAKEN
args->ioctl_return = sc;
return sc;
}
switch (args->command) {
ffc060a4: 80 1e 00 04 lwz r0,4(r30)
ffc060a8: 2f 80 00 04 cmpwi cr7,r0,4
ffc060ac: 41 9e 02 c8 beq- cr7,ffc06374 <rtems_termios_ioctl+0x310>
ffc060b0: 2b 80 00 04 cmplwi cr7,r0,4
ffc060b4: 41 9d 00 20 bgt- cr7,ffc060d4 <rtems_termios_ioctl+0x70>
ffc060b8: 2f 80 00 02 cmpwi cr7,r0,2
ffc060bc: 41 9e 00 a0 beq- cr7,ffc0615c <rtems_termios_ioctl+0xf8>
ffc060c0: 2b 80 00 02 cmplwi cr7,r0,2
ffc060c4: 41 9d 02 84 bgt- cr7,ffc06348 <rtems_termios_ioctl+0x2e4>
ffc060c8: 2f 80 00 01 cmpwi cr7,r0,1
ffc060cc: 40 be 00 44 bne+ cr7,ffc06110 <rtems_termios_ioctl+0xac><== NEVER TAKEN
ffc060d0: 48 00 00 78 b ffc06148 <rtems_termios_ioctl+0xe4>
ffc060d4: 3d 20 40 04 lis r9,16388
ffc060d8: 61 29 66 7f ori r9,r9,26239
ffc060dc: 7f 80 48 00 cmpw cr7,r0,r9
ffc060e0: 41 9e 03 24 beq- cr7,ffc06404 <rtems_termios_ioctl+0x3a0><== NEVER TAKEN
ffc060e4: 7f 80 48 40 cmplw cr7,r0,r9
ffc060e8: 41 9d 00 10 bgt- cr7,ffc060f8 <rtems_termios_ioctl+0x94>
ffc060ec: 2f 80 00 05 cmpwi cr7,r0,5
ffc060f0: 40 be 00 20 bne+ cr7,ffc06110 <rtems_termios_ioctl+0xac>
ffc060f4: 48 00 02 6c b ffc06360 <rtems_termios_ioctl+0x2fc>
ffc060f8: 6c 09 40 04 xoris r9,r0,16388
ffc060fc: 2f 89 74 1a cmpwi cr7,r9,29722
ffc06100: 41 9e 02 f8 beq- cr7,ffc063f8 <rtems_termios_ioctl+0x394>
ffc06104: 6c 09 80 04 xoris r9,r0,32772
ffc06108: 2f 89 74 1b cmpwi cr7,r9,29723
ffc0610c: 41 9e 02 7c beq- cr7,ffc06388 <rtems_termios_ioctl+0x324><== ALWAYS TAKEN
default:
if (rtems_termios_linesw[tty->t_line].l_ioctl != NULL) {
ffc06110: 80 1f 00 cc lwz r0,204(r31)
ffc06114: 3d 20 00 00 lis r9,0
ffc06118: 39 29 28 f0 addi r9,r9,10480
ffc0611c: 54 00 28 34 rlwinm r0,r0,5,0,26
ffc06120: 7d 29 02 14 add r9,r9,r0
ffc06124: 80 09 00 18 lwz r0,24(r9)
sc = rtems_termios_linesw[tty->t_line].l_ioctl(tty,args);
}
else {
sc = RTEMS_INVALID_NUMBER;
ffc06128: 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) {
ffc0612c: 2f 80 00 00 cmpwi cr7,r0,0
ffc06130: 41 9e 03 04 beq- cr7,ffc06434 <rtems_termios_ioctl+0x3d0><== NEVER TAKEN
sc = rtems_termios_linesw[tty->t_line].l_ioctl(tty,args);
ffc06134: 7f e3 fb 78 mr r3,r31
ffc06138: 7c 09 03 a6 mtctr r0
ffc0613c: 7f c4 f3 78 mr r4,r30
ffc06140: 4e 80 04 21 bctrl
ffc06144: 48 00 02 ac b ffc063f0 <rtems_termios_ioctl+0x38c>
sc = RTEMS_INVALID_NUMBER;
}
break;
case RTEMS_IO_GET_ATTRIBUTES:
*(struct termios *)args->buffer = tty->termios;
ffc06148: 80 7e 00 08 lwz r3,8(r30)
ffc0614c: 38 9f 00 30 addi r4,r31,48
ffc06150: 38 a0 00 24 li r5,36
ffc06154: 48 00 b7 9d bl ffc118f0 <memcpy>
break;
ffc06158: 48 00 02 dc b ffc06434 <rtems_termios_ioctl+0x3d0>
case RTEMS_IO_SET_ATTRIBUTES:
tty->termios = *(struct termios *)args->buffer;
ffc0615c: 80 9e 00 08 lwz r4,8(r30)
ffc06160: 38 7f 00 30 addi r3,r31,48
ffc06164: 38 a0 00 24 li r5,36
ffc06168: 48 00 b7 89 bl ffc118f0 <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) &&
ffc0616c: 80 1f 00 b8 lwz r0,184(r31)
ffc06170: 70 09 02 00 andi. r9,r0,512
ffc06174: 41 82 00 70 beq- ffc061e4 <rtems_termios_ioctl+0x180>
!(tty->termios.c_iflag & IXON)) {
ffc06178: 80 1f 00 30 lwz r0,48(r31)
/*
* check for flow control options to be switched off
*/
/* check for outgoing XON/XOFF flow control switched off */
if (( tty->flow_ctrl & FL_MDXON) &&
ffc0617c: 70 0b 04 00 andi. r11,r0,1024
ffc06180: 40 82 00 64 bne- ffc061e4 <rtems_termios_ioctl+0x180>
!(tty->termios.c_iflag & IXON)) {
/* clear related flags in flow_ctrl */
tty->flow_ctrl &= ~(FL_MDXON | FL_ORCVXOF);
ffc06184: 81 3f 00 b8 lwz r9,184(r31)
ffc06188: 38 00 fd ef li r0,-529
ffc0618c: 7d 20 00 38 and r0,r9,r0
ffc06190: 90 1f 00 b8 stw r0,184(r31)
/* has output been stopped due to received XOFF? */
if (tty->flow_ctrl & FL_OSTOP) {
ffc06194: 80 1f 00 b8 lwz r0,184(r31)
ffc06198: 70 09 00 20 andi. r9,r0,32
ffc0619c: 41 a2 00 48 beq+ ffc061e4 <rtems_termios_ioctl+0x180> <== ALWAYS TAKEN
/* disable interrupts */
rtems_interrupt_disable(level);
ffc061a0: 4b ff f8 4d bl ffc059ec <ppc_interrupt_disable> <== NOT EXECUTED
ffc061a4: 7c 7c 1b 78 mr r28,r3 <== NOT EXECUTED
tty->flow_ctrl &= ~FL_OSTOP;
ffc061a8: 80 1f 00 b8 lwz r0,184(r31) <== NOT EXECUTED
ffc061ac: 54 00 06 f2 rlwinm r0,r0,0,27,25 <== NOT EXECUTED
ffc061b0: 90 1f 00 b8 stw r0,184(r31) <== NOT EXECUTED
/* check for chars in output buffer (or rob_state?) */
if (tty->rawOutBufState != rob_idle) {
ffc061b4: 80 1f 00 94 lwz r0,148(r31) <== NOT EXECUTED
ffc061b8: 2f 80 00 00 cmpwi cr7,r0,0 <== NOT EXECUTED
ffc061bc: 41 be 00 24 beq+ cr7,ffc061e0 <rtems_termios_ioctl+0x17c><== NOT EXECUTED
/* if chars available, call write function... */
(*tty->device.write)(
tty->minor, &tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail],1);
ffc061c0: 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)(
ffc061c4: 38 a0 00 01 li r5,1 <== NOT EXECUTED
ffc061c8: 80 9f 00 7c lwz r4,124(r31) <== NOT EXECUTED
ffc061cc: 80 1f 00 a4 lwz r0,164(r31) <== NOT EXECUTED
ffc061d0: 80 7f 00 10 lwz r3,16(r31) <== NOT EXECUTED
ffc061d4: 7c 84 4a 14 add r4,r4,r9 <== NOT EXECUTED
ffc061d8: 7c 09 03 a6 mtctr r0 <== NOT EXECUTED
ffc061dc: 4e 80 04 21 bctrl <== NOT EXECUTED
ffc061e0: 7f 80 01 24 mtmsr r28 <== 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)) {
ffc061e4: 80 1f 00 b8 lwz r0,184(r31)
ffc061e8: 70 09 04 00 andi. r9,r0,1024
ffc061ec: 41 82 00 28 beq- ffc06214 <rtems_termios_ioctl+0x1b0>
ffc061f0: 80 1f 00 30 lwz r0,48(r31)
ffc061f4: 70 0b 10 00 andi. r11,r0,4096
ffc061f8: 40 82 00 1c bne- ffc06214 <rtems_termios_ioctl+0x1b0>
/* clear related flags in flow_ctrl */
tty->flow_ctrl &= ~(FL_MDXOF);
ffc061fc: 80 1f 00 b8 lwz r0,184(r31)
ffc06200: 54 00 05 a8 rlwinm r0,r0,0,22,20
ffc06204: 90 1f 00 b8 stw r0,184(r31)
/* FIXME: what happens, if we had sent XOFF but not yet XON? */
tty->flow_ctrl &= ~(FL_ISNTXOF);
ffc06208: 80 1f 00 b8 lwz r0,184(r31)
ffc0620c: 54 00 07 fa rlwinm r0,r0,0,31,29
ffc06210: 90 1f 00 b8 stw r0,184(r31)
}
/* check for incoming RTS/CTS flow control switched off */
if (( tty->flow_ctrl & FL_MDRTS) && !(tty->termios.c_cflag & CRTSCTS)) {
ffc06214: 80 1f 00 b8 lwz r0,184(r31)
ffc06218: 70 09 01 00 andi. r9,r0,256
ffc0621c: 41 82 00 4c beq- ffc06268 <rtems_termios_ioctl+0x204> <== ALWAYS TAKEN
ffc06220: 80 1f 00 38 lwz r0,56(r31) <== NOT EXECUTED
ffc06224: 2f 80 00 00 cmpwi cr7,r0,0 <== NOT EXECUTED
ffc06228: 41 9c 00 40 blt- cr7,ffc06268 <rtems_termios_ioctl+0x204><== NOT EXECUTED
/* clear related flags in flow_ctrl */
tty->flow_ctrl &= ~(FL_MDRTS);
ffc0622c: 80 1f 00 b8 lwz r0,184(r31) <== NOT EXECUTED
ffc06230: 54 00 06 2c rlwinm r0,r0,0,24,22 <== NOT EXECUTED
ffc06234: 90 1f 00 b8 stw r0,184(r31) <== NOT EXECUTED
/* restart remote Tx, if it was stopped */
if ((tty->flow_ctrl & FL_IRTSOFF) && (tty->device.startRemoteTx != NULL)) {
ffc06238: 80 1f 00 b8 lwz r0,184(r31) <== NOT EXECUTED
ffc0623c: 70 0b 00 04 andi. r11,r0,4 <== NOT EXECUTED
ffc06240: 41 82 00 1c beq- ffc0625c <rtems_termios_ioctl+0x1f8> <== NOT EXECUTED
ffc06244: 80 1f 00 b0 lwz r0,176(r31) <== NOT EXECUTED
ffc06248: 2f 80 00 00 cmpwi cr7,r0,0 <== NOT EXECUTED
ffc0624c: 41 9e 00 10 beq- cr7,ffc0625c <rtems_termios_ioctl+0x1f8><== NOT EXECUTED
tty->device.startRemoteTx(tty->minor);
ffc06250: 80 7f 00 10 lwz r3,16(r31) <== NOT EXECUTED
ffc06254: 7c 09 03 a6 mtctr r0 <== NOT EXECUTED
ffc06258: 4e 80 04 21 bctrl <== NOT EXECUTED
}
tty->flow_ctrl &= ~(FL_IRTSOFF);
ffc0625c: 80 1f 00 b8 lwz r0,184(r31) <== NOT EXECUTED
ffc06260: 54 00 07 b8 rlwinm r0,r0,0,30,28 <== NOT EXECUTED
ffc06264: 90 1f 00 b8 stw r0,184(r31) <== 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) {
ffc06268: 80 1f 00 38 lwz r0,56(r31)
ffc0626c: 2f 80 00 00 cmpwi cr7,r0,0
ffc06270: 40 bc 00 10 bge+ cr7,ffc06280 <rtems_termios_ioctl+0x21c><== ALWAYS TAKEN
tty->flow_ctrl |= FL_MDRTS;
ffc06274: 80 1f 00 b8 lwz r0,184(r31) <== NOT EXECUTED
ffc06278: 60 00 01 00 ori r0,r0,256 <== NOT EXECUTED
ffc0627c: 90 1f 00 b8 stw r0,184(r31) <== NOT EXECUTED
}
/* check for incoming XON/XOF flow control switched on */
if (tty->termios.c_iflag & IXOFF) {
ffc06280: 80 1f 00 30 lwz r0,48(r31)
ffc06284: 70 09 10 00 andi. r9,r0,4096
ffc06288: 41 82 00 10 beq- ffc06298 <rtems_termios_ioctl+0x234>
tty->flow_ctrl |= FL_MDXOF;
ffc0628c: 81 3f 00 b8 lwz r9,184(r31)
ffc06290: 61 29 04 00 ori r9,r9,1024
ffc06294: 91 3f 00 b8 stw r9,184(r31)
}
/* check for outgoing XON/XOF flow control switched on */
if (tty->termios.c_iflag & IXON) {
ffc06298: 70 0b 04 00 andi. r11,r0,1024
ffc0629c: 41 82 00 10 beq- ffc062ac <rtems_termios_ioctl+0x248>
tty->flow_ctrl |= FL_MDXON;
ffc062a0: 80 1f 00 b8 lwz r0,184(r31)
ffc062a4: 60 00 02 00 ori r0,r0,512
ffc062a8: 90 1f 00 b8 stw r0,184(r31)
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) {
ffc062ac: 83 9f 00 3c lwz r28,60(r31)
ffc062b0: 73 9c 00 02 andi. r28,r28,2
ffc062b4: 41 82 00 0c beq- ffc062c0 <rtems_termios_ioctl+0x25c>
tty->rawInBufSemaphoreOptions = RTEMS_WAIT;
ffc062b8: 38 00 00 00 li r0,0
ffc062bc: 48 00 00 54 b ffc06310 <rtems_termios_ioctl+0x2ac>
tty->rawInBufSemaphoreTimeout = RTEMS_NO_TIMEOUT;
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
} else {
tty->vtimeTicks = tty->termios.c_cc[VTIME] *
ffc062c0: 8b 7f 00 46 lbz r27,70(r31)
rtems_clock_get_ticks_per_second() / 10;
ffc062c4: 48 00 16 e9 bl ffc079ac <rtems_clock_get_ticks_per_second>
ffc062c8: 38 00 00 0a li r0,10
ffc062cc: 89 3f 00 47 lbz r9,71(r31)
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] *
ffc062d0: 7f 63 d9 d6 mullw r27,r3,r27
rtems_clock_get_ticks_per_second() / 10;
ffc062d4: 7f 7b 03 96 divwu r27,r27,r0
if (tty->termios.c_cc[VTIME]) {
ffc062d8: 88 1f 00 46 lbz r0,70(r31)
ffc062dc: 2f 80 00 00 cmpwi cr7,r0,0
if (tty->termios.c_lflag & ICANON) {
tty->rawInBufSemaphoreOptions = RTEMS_WAIT;
tty->rawInBufSemaphoreTimeout = RTEMS_NO_TIMEOUT;
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
} else {
tty->vtimeTicks = tty->termios.c_cc[VTIME] *
ffc062e0: 93 7f 00 54 stw r27,84(r31)
rtems_clock_get_ticks_per_second() / 10;
if (tty->termios.c_cc[VTIME]) {
ffc062e4: 41 9e 00 24 beq- cr7,ffc06308 <rtems_termios_ioctl+0x2a4>
tty->rawInBufSemaphoreOptions = RTEMS_WAIT;
tty->rawInBufSemaphoreTimeout = tty->vtimeTicks;
if (tty->termios.c_cc[VMIN])
ffc062e8: 71 20 00 ff andi. r0,r9,255
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;
ffc062ec: 93 9f 00 6c stw r28,108(r31)
tty->rawInBufSemaphoreTimeout = tty->vtimeTicks;
ffc062f0: 93 7f 00 70 stw r27,112(r31)
if (tty->termios.c_cc[VMIN])
ffc062f4: 41 82 00 0c beq- ffc06300 <rtems_termios_ioctl+0x29c>
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
ffc062f8: 93 9f 00 74 stw r28,116(r31)
ffc062fc: 48 00 00 2c b ffc06328 <rtems_termios_ioctl+0x2c4>
else
tty->rawInBufSemaphoreFirstTimeout = tty->vtimeTicks;
ffc06300: 93 7f 00 74 stw r27,116(r31)
ffc06304: 48 00 00 24 b ffc06328 <rtems_termios_ioctl+0x2c4>
} else {
if (tty->termios.c_cc[VMIN]) {
ffc06308: 71 2b 00 ff andi. r11,r9,255
ffc0630c: 41 82 00 14 beq- ffc06320 <rtems_termios_ioctl+0x2bc> <== ALWAYS TAKEN
tty->rawInBufSemaphoreOptions = RTEMS_WAIT;
ffc06310: 90 1f 00 6c stw r0,108(r31)
tty->rawInBufSemaphoreTimeout = RTEMS_NO_TIMEOUT;
ffc06314: 90 1f 00 70 stw r0,112(r31)
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
ffc06318: 90 1f 00 74 stw r0,116(r31)
ffc0631c: 48 00 00 0c b ffc06328 <rtems_termios_ioctl+0x2c4>
} else {
tty->rawInBufSemaphoreOptions = RTEMS_NO_WAIT;
ffc06320: 38 00 00 01 li r0,1
ffc06324: 90 1f 00 6c stw r0,108(r31)
}
}
}
if (tty->device.setAttributes)
ffc06328: 80 1f 00 a8 lwz r0,168(r31)
ffc0632c: 2f 80 00 00 cmpwi cr7,r0,0
ffc06330: 41 9e 01 04 beq- cr7,ffc06434 <rtems_termios_ioctl+0x3d0><== NEVER TAKEN
(*tty->device.setAttributes)(tty->minor, &tty->termios);
ffc06334: 80 7f 00 10 lwz r3,16(r31)
ffc06338: 38 9f 00 30 addi r4,r31,48
ffc0633c: 7c 09 03 a6 mtctr r0
ffc06340: 4e 80 04 21 bctrl
ffc06344: 48 00 00 f0 b ffc06434 <rtems_termios_ioctl+0x3d0>
drainOutput (struct rtems_termios_tty *tty)
{
rtems_interrupt_level level;
rtems_status_code sc;
if (tty->device.outputUsesInterrupts != TERMIOS_POLLED) {
ffc06348: 80 1f 00 b4 lwz r0,180(r31)
ffc0634c: 2f 80 00 00 cmpwi cr7,r0,0
ffc06350: 41 be 00 e4 beq+ cr7,ffc06434 <rtems_termios_ioctl+0x3d0><== ALWAYS TAKEN
ffc06354: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc06358: 4b ff f6 a9 bl ffc05a00 <drainOutput.part.0> <== NOT EXECUTED
ffc0635c: 48 00 00 d8 b ffc06434 <rtems_termios_ioctl+0x3d0> <== NOT EXECUTED
case RTEMS_IO_TCDRAIN:
drainOutput (tty);
break;
case RTEMS_IO_SNDWAKEUP:
tty->tty_snd = *wakeup;
ffc06360: 81 5c 00 00 lwz r10,0(r28)
ffc06364: 81 7c 00 04 lwz r11,4(r28)
ffc06368: 91 5f 00 d4 stw r10,212(r31)
ffc0636c: 91 7f 00 d8 stw r11,216(r31)
break;
ffc06370: 48 00 00 c4 b ffc06434 <rtems_termios_ioctl+0x3d0>
case RTEMS_IO_RCVWAKEUP:
tty->tty_rcv = *wakeup;
ffc06374: 81 5c 00 00 lwz r10,0(r28)
ffc06378: 81 7c 00 04 lwz r11,4(r28)
ffc0637c: 91 5f 00 dc stw r10,220(r31)
ffc06380: 91 7f 00 e0 stw r11,224(r31)
break;
ffc06384: 48 00 00 b0 b ffc06434 <rtems_termios_ioctl+0x3d0>
#if 1 /* FIXME */
case TIOCSETD:
/*
* close old line discipline
*/
if (rtems_termios_linesw[tty->t_line].l_close != NULL) {
ffc06388: 80 1f 00 cc lwz r0,204(r31)
ffc0638c: 3d 20 00 00 lis r9,0
ffc06390: 39 29 28 f0 addi r9,r9,10480
ffc06394: 54 00 28 34 rlwinm r0,r0,5,0,26
ffc06398: 7d 29 02 14 add r9,r9,r0
ffc0639c: 80 09 00 04 lwz r0,4(r9)
ffc063a0: 2f 80 00 00 cmpwi cr7,r0,0
ffc063a4: 41 9e 00 14 beq- cr7,ffc063b8 <rtems_termios_ioctl+0x354>
sc = rtems_termios_linesw[tty->t_line].l_close(tty);
ffc063a8: 7f e3 fb 78 mr r3,r31
ffc063ac: 7c 09 03 a6 mtctr r0
ffc063b0: 4e 80 04 21 bctrl
ffc063b4: 7c 7d 1b 78 mr r29,r3
}
tty->t_line=*(int*)(args->buffer);
ffc063b8: 81 3e 00 08 lwz r9,8(r30)
ffc063bc: 80 09 00 00 lwz r0,0(r9)
tty->t_sc = NULL; /* ensure that no more valid data */
ffc063c0: 39 20 00 00 li r9,0
ffc063c4: 91 3f 00 d0 stw r9,208(r31)
/*
* open new line discipline
*/
if (rtems_termios_linesw[tty->t_line].l_open != NULL) {
ffc063c8: 3d 20 00 00 lis r9,0
ffc063cc: 39 29 28 f0 addi r9,r9,10480
* 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);
ffc063d0: 90 1f 00 cc stw r0,204(r31)
tty->t_sc = NULL; /* ensure that no more valid data */
/*
* open new line discipline
*/
if (rtems_termios_linesw[tty->t_line].l_open != NULL) {
ffc063d4: 54 00 28 34 rlwinm r0,r0,5,0,26
ffc063d8: 7c 09 00 2e lwzx r0,r9,r0
ffc063dc: 2f 80 00 00 cmpwi cr7,r0,0
ffc063e0: 41 9e 00 54 beq- cr7,ffc06434 <rtems_termios_ioctl+0x3d0>
sc = rtems_termios_linesw[tty->t_line].l_open(tty);
ffc063e4: 7f e3 fb 78 mr r3,r31
ffc063e8: 7c 09 03 a6 mtctr r0
ffc063ec: 4e 80 04 21 bctrl
ffc063f0: 7c 7d 1b 78 mr r29,r3
ffc063f4: 48 00 00 40 b ffc06434 <rtems_termios_ioctl+0x3d0>
}
break;
case TIOCGETD:
*(int*)(args->buffer)=tty->t_line;
ffc063f8: 80 1f 00 cc lwz r0,204(r31)
ffc063fc: 81 3e 00 08 lwz r9,8(r30)
ffc06400: 48 00 00 30 b ffc06430 <rtems_termios_ioctl+0x3cc>
break;
#endif
case FIONREAD: {
int rawnc = tty->rawInBuf.Tail - tty->rawInBuf.Head;
ffc06404: 81 3f 00 60 lwz r9,96(r31) <== NOT EXECUTED
ffc06408: 80 1f 00 5c lwz r0,92(r31) <== NOT EXECUTED
if ( rawnc < 0 )
ffc0640c: 7c 00 48 51 subf. r0,r0,r9 <== NOT EXECUTED
ffc06410: 40 a0 00 0c bge+ ffc0641c <rtems_termios_ioctl+0x3b8> <== NOT EXECUTED
rawnc += tty->rawInBuf.Size;
ffc06414: 81 3f 00 64 lwz r9,100(r31) <== NOT EXECUTED
ffc06418: 7c 00 4a 14 add r0,r0,r9 <== NOT EXECUTED
/* Half guess that this is the right operation */
*(int *)args->buffer = tty->ccount - tty->cindex + rawnc;
ffc0641c: 81 5f 00 20 lwz r10,32(r31) <== NOT EXECUTED
ffc06420: 81 7f 00 24 lwz r11,36(r31) <== NOT EXECUTED
ffc06424: 81 3e 00 08 lwz r9,8(r30) <== NOT EXECUTED
ffc06428: 7d 6b 50 50 subf r11,r11,r10 <== NOT EXECUTED
ffc0642c: 7c 0b 02 14 add r0,r11,r0 <== NOT EXECUTED
ffc06430: 90 09 00 00 stw r0,0(r9)
}
break;
}
rtems_semaphore_release (tty->osem);
ffc06434: 80 7f 00 18 lwz r3,24(r31)
ffc06438: 48 00 1d 99 bl ffc081d0 <rtems_semaphore_release>
args->ioctl_return = sc;
return sc;
}
ffc0643c: 39 61 00 20 addi r11,r1,32
}
break;
}
rtems_semaphore_release (tty->osem);
args->ioctl_return = sc;
ffc06440: 93 be 00 0c stw r29,12(r30)
return sc;
}
ffc06444: 7f a3 eb 78 mr r3,r29
ffc06448: 4b ff a0 ec b ffc00534 <_restgpr_27_x>
ffc05a64 <rtems_termios_open>:
rtems_device_major_number major,
rtems_device_minor_number minor,
void *arg,
const rtems_termios_callbacks *callbacks
)
{
ffc05a64: 94 21 ff d0 stwu r1,-48(r1)
struct rtems_termios_tty *tty;
/*
* See if the device has already been opened
*/
sc = rtems_semaphore_obtain(
ffc05a68: 3d 20 00 00 lis r9,0
rtems_device_major_number major,
rtems_device_minor_number minor,
void *arg,
const rtems_termios_callbacks *callbacks
)
{
ffc05a6c: 7c 08 02 a6 mflr r0
ffc05a70: be c1 00 08 stmw r22,8(r1)
ffc05a74: 7c 7c 1b 78 mr r28,r3
ffc05a78: 7c 9b 23 78 mr r27,r4
struct rtems_termios_tty *tty;
/*
* See if the device has already been opened
*/
sc = rtems_semaphore_obtain(
ffc05a7c: 80 69 27 fc lwz r3,10236(r9)
rtems_device_major_number major,
rtems_device_minor_number minor,
void *arg,
const rtems_termios_callbacks *callbacks
)
{
ffc05a80: 7c ba 2b 78 mr r26,r5
struct rtems_termios_tty *tty;
/*
* See if the device has already been opened
*/
sc = rtems_semaphore_obtain(
ffc05a84: 38 80 00 00 li r4,0
rtems_device_major_number major,
rtems_device_minor_number minor,
void *arg,
const rtems_termios_callbacks *callbacks
)
{
ffc05a88: 90 01 00 34 stw r0,52(r1)
struct rtems_termios_tty *tty;
/*
* See if the device has already been opened
*/
sc = rtems_semaphore_obtain(
ffc05a8c: 38 a0 00 00 li r5,0
rtems_device_major_number major,
rtems_device_minor_number minor,
void *arg,
const rtems_termios_callbacks *callbacks
)
{
ffc05a90: 7c d9 33 78 mr r25,r6
struct rtems_termios_tty *tty;
/*
* See if the device has already been opened
*/
sc = rtems_semaphore_obtain(
ffc05a94: 48 00 26 11 bl ffc080a4 <rtems_semaphore_obtain>
rtems_termios_ttyMutex, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
ffc05a98: 7c 7e 1b 79 mr. r30,r3
ffc05a9c: 40 82 03 b8 bne- ffc05e54 <rtems_termios_open+0x3f0> <== NEVER TAKEN
return sc;
for (tty = rtems_termios_ttyHead ; tty != NULL ; tty = tty->forw) {
ffc05aa0: 3d 20 00 00 lis r9,0
ffc05aa4: 83 a9 28 04 lwz r29,10244(r9)
ffc05aa8: 7f bf eb 78 mr r31,r29
ffc05aac: 48 00 00 20 b ffc05acc <rtems_termios_open+0x68>
if ((tty->major == major) && (tty->minor == minor))
ffc05ab0: 80 1f 00 0c lwz r0,12(r31)
ffc05ab4: 7f 80 e0 00 cmpw cr7,r0,r28
ffc05ab8: 40 be 00 10 bne+ cr7,ffc05ac8 <rtems_termios_open+0x64>
ffc05abc: 80 1f 00 10 lwz r0,16(r31)
ffc05ac0: 7f 80 d8 00 cmpw cr7,r0,r27
ffc05ac4: 41 9e 03 00 beq- cr7,ffc05dc4 <rtems_termios_open+0x360><== ALWAYS TAKEN
sc = rtems_semaphore_obtain(
rtems_termios_ttyMutex, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
return sc;
for (tty = rtems_termios_ttyHead ; tty != NULL ; tty = tty->forw) {
ffc05ac8: 83 ff 00 00 lwz r31,0(r31)
ffc05acc: 2f 9f 00 00 cmpwi cr7,r31,0
ffc05ad0: 40 9e ff e0 bne+ cr7,ffc05ab0 <rtems_termios_open+0x4c>
ffc05ad4: 48 00 03 8c b ffc05e60 <rtems_termios_open+0x3fc>
return RTEMS_NO_MEMORY;
}
/*
* allocate raw input buffer
*/
tty->rawInBuf.Size = RAW_INPUT_BUFFER_SIZE;
ffc05ad8: 3d 20 00 00 lis r9,0
ffc05adc: 80 09 21 b0 lwz r0,8624(r9)
ffc05ae0: 3a c9 21 b0 addi r22,r9,8624
ffc05ae4: 90 1f 00 64 stw r0,100(r31)
tty->rawInBuf.theBuf = malloc (tty->rawInBuf.Size);
ffc05ae8: 80 7f 00 64 lwz r3,100(r31)
ffc05aec: 4b ff f2 19 bl ffc04d04 <malloc>
if (tty->rawInBuf.theBuf == NULL) {
ffc05af0: 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);
ffc05af4: 90 7f 00 58 stw r3,88(r31)
ffc05af8: 7c 78 1b 78 mr r24,r3
if (tty->rawInBuf.theBuf == NULL) {
ffc05afc: 40 be 00 20 bne+ cr7,ffc05b1c <rtems_termios_open+0xb8>
free(tty);
ffc05b00: 7f e3 fb 78 mr r3,r31
ffc05b04: 4b ff ee 59 bl ffc0495c <free>
rtems_semaphore_release (rtems_termios_ttyMutex);
ffc05b08: 3d 20 00 00 lis r9,0
ffc05b0c: 80 69 27 fc lwz r3,10236(r9)
return RTEMS_NO_MEMORY;
ffc05b10: 3b c0 00 1a li r30,26
*/
tty->rawInBuf.Size = RAW_INPUT_BUFFER_SIZE;
tty->rawInBuf.theBuf = malloc (tty->rawInBuf.Size);
if (tty->rawInBuf.theBuf == NULL) {
free(tty);
rtems_semaphore_release (rtems_termios_ttyMutex);
ffc05b14: 48 00 26 bd bl ffc081d0 <rtems_semaphore_release>
return RTEMS_NO_MEMORY;
ffc05b18: 48 00 03 3c b ffc05e54 <rtems_termios_open+0x3f0>
}
/*
* allocate raw output buffer
*/
tty->rawOutBuf.Size = RAW_OUTPUT_BUFFER_SIZE;
ffc05b1c: 80 16 00 04 lwz r0,4(r22)
ffc05b20: 90 1f 00 88 stw r0,136(r31)
tty->rawOutBuf.theBuf = malloc (tty->rawOutBuf.Size);
ffc05b24: 80 7f 00 88 lwz r3,136(r31)
ffc05b28: 4b ff f1 dd bl ffc04d04 <malloc>
if (tty->rawOutBuf.theBuf == NULL) {
ffc05b2c: 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);
ffc05b30: 90 7f 00 7c stw r3,124(r31)
ffc05b34: 7c 77 1b 78 mr r23,r3
if (tty->rawOutBuf.theBuf == NULL) {
ffc05b38: 41 9e 00 20 beq- cr7,ffc05b58 <rtems_termios_open+0xf4>
return RTEMS_NO_MEMORY;
}
/*
* allocate cooked buffer
*/
tty->cbuf = malloc (CBUFSIZE);
ffc05b3c: 80 76 00 08 lwz r3,8(r22)
ffc05b40: 4b ff f1 c5 bl ffc04d04 <malloc>
if (tty->cbuf == NULL) {
ffc05b44: 2f 83 00 00 cmpwi cr7,r3,0
return RTEMS_NO_MEMORY;
}
/*
* allocate cooked buffer
*/
tty->cbuf = malloc (CBUFSIZE);
ffc05b48: 90 7f 00 1c stw r3,28(r31)
if (tty->cbuf == NULL) {
ffc05b4c: 40 be 00 18 bne+ cr7,ffc05b64 <rtems_termios_open+0x100><== ALWAYS TAKEN
free((void *)(tty->rawOutBuf.theBuf));
ffc05b50: 7e e3 bb 78 mr r3,r23 <== NOT EXECUTED
ffc05b54: 4b ff ee 09 bl ffc0495c <free> <== NOT EXECUTED
free((void *)(tty->rawInBuf.theBuf));
ffc05b58: 7f 03 c3 78 mr r3,r24
ffc05b5c: 4b ff ee 01 bl ffc0495c <free>
ffc05b60: 4b ff ff a0 b ffc05b00 <rtems_termios_open+0x9c>
/*
* link tty
*/
tty->forw = rtems_termios_ttyHead;
tty->back = NULL;
if (rtems_termios_ttyHead != NULL)
ffc05b64: 2f 9d 00 00 cmpwi cr7,r29,0
tty->tty_rcvwakeup = 0;
/*
* link tty
*/
tty->forw = rtems_termios_ttyHead;
ffc05b68: 93 bf 00 00 stw r29,0(r31)
return RTEMS_NO_MEMORY;
}
/*
* Initialize wakeup callbacks
*/
tty->tty_snd.sw_pfn = NULL;
ffc05b6c: 38 00 00 00 li r0,0
ffc05b70: 90 1f 00 d4 stw r0,212(r31)
tty->tty_snd.sw_arg = NULL;
ffc05b74: 90 1f 00 d8 stw r0,216(r31)
tty->tty_rcv.sw_pfn = NULL;
ffc05b78: 90 1f 00 dc stw r0,220(r31)
tty->tty_rcv.sw_arg = NULL;
ffc05b7c: 90 1f 00 e0 stw r0,224(r31)
tty->tty_rcvwakeup = 0;
ffc05b80: 90 1f 00 e4 stw r0,228(r31)
/*
* link tty
*/
tty->forw = rtems_termios_ttyHead;
tty->back = NULL;
ffc05b84: 90 1f 00 04 stw r0,4(r31)
if (rtems_termios_ttyHead != NULL)
ffc05b88: 41 9e 00 08 beq- cr7,ffc05b90 <rtems_termios_open+0x12c>
rtems_termios_ttyHead->back = tty;
ffc05b8c: 93 fd 00 04 stw r31,4(r29)
rtems_termios_ttyHead = tty;
ffc05b90: 3d 20 00 00 lis r9,0
ffc05b94: 93 e9 28 04 stw r31,10244(r9)
if (rtems_termios_ttyTail == NULL)
ffc05b98: 3d 20 00 00 lis r9,0
ffc05b9c: 80 09 28 00 lwz r0,10240(r9)
ffc05ba0: 2f 80 00 00 cmpwi cr7,r0,0
ffc05ba4: 40 be 00 08 bne+ cr7,ffc05bac <rtems_termios_open+0x148>
rtems_termios_ttyTail = tty;
ffc05ba8: 93 e9 28 00 stw r31,10240(r9)
/*
* Set up mutex semaphores
*/
sc = rtems_semaphore_create (
rtems_build_name ('T', 'R', 'i', c),
ffc05bac: 3f a0 00 00 lis r29,0
rtems_termios_ttyHead->back = tty;
rtems_termios_ttyHead = tty;
if (rtems_termios_ttyTail == NULL)
rtems_termios_ttyTail = tty;
tty->minor = minor;
ffc05bb0: 93 7f 00 10 stw r27,16(r31)
/*
* Set up mutex semaphores
*/
sc = rtems_semaphore_create (
rtems_build_name ('T', 'R', 'i', c),
ffc05bb4: 3b bd 21 b0 addi r29,r29,8624
ffc05bb8: 88 7d 00 0c lbz r3,12(r29)
tty->major = major;
/*
* Set up mutex semaphores
*/
sc = rtems_semaphore_create (
ffc05bbc: 38 80 00 01 li r4,1
rtems_termios_ttyHead = tty;
if (rtems_termios_ttyTail == NULL)
rtems_termios_ttyTail = tty;
tty->minor = minor;
tty->major = major;
ffc05bc0: 93 9f 00 0c stw r28,12(r31)
/*
* Set up mutex semaphores
*/
sc = rtems_semaphore_create (
ffc05bc4: 38 a0 00 54 li r5,84
ffc05bc8: 64 63 54 52 oris r3,r3,21586
ffc05bcc: 60 63 69 00 ori r3,r3,26880
ffc05bd0: 38 c0 00 00 li r6,0
ffc05bd4: 38 ff 00 14 addi r7,r31,20
ffc05bd8: 48 00 22 59 bl ffc07e30 <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)
ffc05bdc: 2f 83 00 00 cmpwi cr7,r3,0
ffc05be0: 40 9e 02 64 bne- cr7,ffc05e44 <rtems_termios_open+0x3e0>
rtems_fatal_error_occurred (sc);
sc = rtems_semaphore_create (
rtems_build_name ('T', 'R', 'o', c),
ffc05be4: 88 7d 00 0c lbz r3,12(r29)
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 (
ffc05be8: 38 80 00 01 li r4,1
ffc05bec: 38 a0 00 54 li r5,84
ffc05bf0: 64 63 54 52 oris r3,r3,21586
ffc05bf4: 60 63 6f 00 ori r3,r3,28416
ffc05bf8: 38 c0 00 00 li r6,0
ffc05bfc: 38 ff 00 18 addi r7,r31,24
ffc05c00: 48 00 22 31 bl ffc07e30 <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)
ffc05c04: 2f 83 00 00 cmpwi cr7,r3,0
ffc05c08: 40 9e 02 3c bne- cr7,ffc05e44 <rtems_termios_open+0x3e0>
rtems_fatal_error_occurred (sc);
sc = rtems_semaphore_create (
rtems_build_name ('T', 'R', 'x', c),
ffc05c0c: 88 7d 00 0c lbz r3,12(r29)
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 (
ffc05c10: 38 80 00 00 li r4,0
ffc05c14: 38 a0 00 20 li r5,32
ffc05c18: 64 63 54 52 oris r3,r3,21586
ffc05c1c: 60 63 78 00 ori r3,r3,30720
ffc05c20: 38 c0 00 00 li r6,0
ffc05c24: 38 ff 00 8c addi r7,r31,140
ffc05c28: 48 00 22 09 bl ffc07e30 <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)
ffc05c2c: 7c 60 1b 79 mr. r0,r3
ffc05c30: 40 82 02 14 bne- ffc05e44 <rtems_termios_open+0x3e0>
tty->rawOutBufState = rob_idle;
/*
* Set callbacks
*/
tty->device = *callbacks;
ffc05c34: 38 9f 00 98 addi r4,r31,152
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;
ffc05c38: 90 1f 00 94 stw r0,148(r31)
/*
* Set callbacks
*/
tty->device = *callbacks;
ffc05c3c: 7c b9 04 aa lswi r5,r25,32
ffc05c40: 7c a4 05 aa stswi r5,r4,32
/*
* Create I/O tasks
*/
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
ffc05c44: 80 1f 00 b4 lwz r0,180(r31)
ffc05c48: 2f 80 00 02 cmpwi cr7,r0,2
ffc05c4c: 40 be 00 5c bne+ cr7,ffc05ca8 <rtems_termios_open+0x244>
sc = rtems_task_create (
rtems_build_name ('T', 'x', 'T', c),
ffc05c50: 88 7d 00 0c lbz r3,12(r29)
/*
* Create I/O tasks
*/
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
sc = rtems_task_create (
ffc05c54: 38 80 00 0a li r4,10
ffc05c58: 38 a0 04 00 li r5,1024
ffc05c5c: 64 63 54 78 oris r3,r3,21624
ffc05c60: 60 63 54 00 ori r3,r3,21504
ffc05c64: 38 c0 05 00 li r6,1280
ffc05c68: 38 e0 00 00 li r7,0
ffc05c6c: 39 1f 00 c8 addi r8,r31,200
ffc05c70: 48 00 26 19 bl ffc08288 <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)
ffc05c74: 2f 83 00 00 cmpwi cr7,r3,0
ffc05c78: 40 9e 01 cc bne- cr7,ffc05e44 <rtems_termios_open+0x3e0><== NEVER TAKEN
rtems_fatal_error_occurred (sc);
sc = rtems_task_create (
rtems_build_name ('R', 'x', 'T', c),
ffc05c7c: 88 7d 00 0c lbz r3,12(r29)
RTEMS_NO_ASR,
RTEMS_NO_FLOATING_POINT | RTEMS_LOCAL,
&tty->txTaskId);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
sc = rtems_task_create (
ffc05c80: 38 80 00 09 li r4,9
ffc05c84: 38 a0 04 00 li r5,1024
ffc05c88: 64 63 52 78 oris r3,r3,21112
ffc05c8c: 60 63 54 00 ori r3,r3,21504
ffc05c90: 38 c0 05 00 li r6,1280
ffc05c94: 38 e0 00 00 li r7,0
ffc05c98: 39 1f 00 c4 addi r8,r31,196
ffc05c9c: 48 00 25 ed bl ffc08288 <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)
ffc05ca0: 2f 83 00 00 cmpwi cr7,r3,0
ffc05ca4: 40 9e 01 a0 bne- cr7,ffc05e44 <rtems_termios_open+0x3e0><== NEVER TAKEN
rtems_fatal_error_occurred (sc);
}
if ((tty->device.pollRead == NULL) ||
ffc05ca8: 80 1f 00 a0 lwz r0,160(r31)
ffc05cac: 2f 80 00 00 cmpwi cr7,r0,0
ffc05cb0: 41 9e 00 10 beq- cr7,ffc05cc0 <rtems_termios_open+0x25c>
ffc05cb4: 80 1f 00 b4 lwz r0,180(r31)
ffc05cb8: 2f 80 00 02 cmpwi cr7,r0,2
ffc05cbc: 40 be 00 30 bne+ cr7,ffc05cec <rtems_termios_open+0x288>
(tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN)){
sc = rtems_semaphore_create (
rtems_build_name ('T', 'R', 'r', c),
ffc05cc0: 3d 20 00 00 lis r9,0
ffc05cc4: 88 69 21 bc lbz r3,8636(r9)
rtems_fatal_error_occurred (sc);
}
if ((tty->device.pollRead == NULL) ||
(tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN)){
sc = rtems_semaphore_create (
ffc05cc8: 38 80 00 00 li r4,0
ffc05ccc: 38 a0 00 24 li r5,36
ffc05cd0: 64 63 54 52 oris r3,r3,21586
ffc05cd4: 60 63 72 00 ori r3,r3,29184
ffc05cd8: 38 c0 00 00 li r6,0
ffc05cdc: 38 ff 00 68 addi r7,r31,104
ffc05ce0: 48 00 21 51 bl ffc07e30 <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)
ffc05ce4: 2f 83 00 00 cmpwi cr7,r3,0
ffc05ce8: 40 9e 01 5c bne- cr7,ffc05e44 <rtems_termios_open+0x3e0><== NEVER TAKEN
}
/*
* Set default parameters
*/
tty->termios.c_iflag = BRKINT | ICRNL | IXON | IMAXBEL;
ffc05cec: 38 00 25 02 li r0,9474
ffc05cf0: 90 1f 00 30 stw r0,48(r31)
tty->termios.c_oflag = OPOST | ONLCR | XTABS;
ffc05cf4: 38 00 18 05 li r0,6149
tty->lowwater = tty->rawInBuf.Size * 1/2;
tty->highwater = tty->rawInBuf.Size * 3/4;
/*
* Bump name characer
*/
if (c++ == 'z')
ffc05cf8: 3d 20 00 00 lis r9,0
/*
* Set default parameters
*/
tty->termios.c_iflag = BRKINT | ICRNL | IXON | IMAXBEL;
tty->termios.c_oflag = OPOST | ONLCR | XTABS;
ffc05cfc: 90 1f 00 34 stw r0,52(r31)
tty->termios.c_cflag = B9600 | CS8 | CREAD | CLOCAL;
ffc05d00: 38 00 08 bd li r0,2237
tty->lowwater = tty->rawInBuf.Size * 1/2;
tty->highwater = tty->rawInBuf.Size * 3/4;
/*
* Bump name characer
*/
if (c++ == 'z')
ffc05d04: 39 29 21 b0 addi r9,r9,8624
/*
* 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;
ffc05d08: 90 1f 00 38 stw r0,56(r31)
tty->termios.c_lflag =
ffc05d0c: 38 00 00 00 li r0,0
ffc05d10: 60 00 82 3b ori r0,r0,33339
ffc05d14: 90 1f 00 3c stw r0,60(r31)
ISIG | ICANON | IEXTEN | ECHO | ECHOK | ECHOE | ECHOCTL;
tty->termios.c_cc[VINTR] = '\003';
ffc05d18: 38 00 00 03 li r0,3
ffc05d1c: 98 1f 00 41 stb r0,65(r31)
tty->termios.c_cc[VQUIT] = '\034';
ffc05d20: 38 00 00 1c li r0,28
ffc05d24: 98 1f 00 42 stb r0,66(r31)
tty->termios.c_cc[VERASE] = '\177';
ffc05d28: 38 00 00 7f li r0,127
ffc05d2c: 98 1f 00 43 stb r0,67(r31)
tty->termios.c_cc[VKILL] = '\025';
ffc05d30: 38 00 00 15 li r0,21
ffc05d34: 98 1f 00 44 stb r0,68(r31)
tty->termios.c_cc[VEOF] = '\004';
ffc05d38: 38 00 00 04 li r0,4
ffc05d3c: 98 1f 00 45 stb r0,69(r31)
tty->termios.c_cc[VEOL] = '\000';
ffc05d40: 38 00 00 00 li r0,0
ffc05d44: 98 1f 00 4c stb r0,76(r31)
tty->termios.c_cc[VEOL2] = '\000';
ffc05d48: 98 1f 00 51 stb r0,81(r31)
tty->termios.c_cc[VSTART] = '\021';
ffc05d4c: 38 00 00 11 li r0,17
ffc05d50: 98 1f 00 49 stb r0,73(r31)
tty->termios.c_cc[VSTOP] = '\023';
ffc05d54: 38 00 00 13 li r0,19
ffc05d58: 98 1f 00 4a stb r0,74(r31)
tty->termios.c_cc[VSUSP] = '\032';
ffc05d5c: 38 00 00 1a li r0,26
ffc05d60: 98 1f 00 4b stb r0,75(r31)
tty->termios.c_cc[VREPRINT] = '\022';
ffc05d64: 38 00 00 12 li r0,18
ffc05d68: 98 1f 00 4d stb r0,77(r31)
tty->termios.c_cc[VDISCARD] = '\017';
ffc05d6c: 38 00 00 0f li r0,15
ffc05d70: 98 1f 00 4e stb r0,78(r31)
tty->termios.c_cc[VWERASE] = '\027';
ffc05d74: 38 00 00 17 li r0,23
ffc05d78: 98 1f 00 4f stb r0,79(r31)
tty->termios.c_cc[VLNEXT] = '\026';
ffc05d7c: 38 00 00 16 li r0,22
ffc05d80: 98 1f 00 50 stb r0,80(r31)
/* start with no flow control, clear flow control flags */
tty->flow_ctrl = 0;
ffc05d84: 38 00 00 00 li r0,0
ffc05d88: 90 1f 00 b8 stw r0,184(r31)
/*
* set low/highwater mark for XON/XOFF support
*/
tty->lowwater = tty->rawInBuf.Size * 1/2;
ffc05d8c: 80 1f 00 64 lwz r0,100(r31)
tty->highwater = tty->rawInBuf.Size * 3/4;
/*
* Bump name characer
*/
if (c++ == 'z')
ffc05d90: 89 69 00 0c lbz r11,12(r9)
/* 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;
ffc05d94: 54 00 f8 7e rlwinm r0,r0,31,1,31
ffc05d98: 90 1f 00 bc stw r0,188(r31)
tty->highwater = tty->rawInBuf.Size * 3/4;
/*
* Bump name characer
*/
if (c++ == 'z')
ffc05d9c: 2f 8b 00 7a cmpwi cr7,r11,122
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;
ffc05da0: 80 1f 00 64 lwz r0,100(r31)
ffc05da4: 1c 00 00 03 mulli r0,r0,3
ffc05da8: 54 00 f0 be rlwinm r0,r0,30,2,31
ffc05dac: 90 1f 00 c0 stw r0,192(r31)
/*
* Bump name characer
*/
if (c++ == 'z')
ffc05db0: 38 0b 00 01 addi r0,r11,1
ffc05db4: 98 09 00 0c stb r0,12(r9)
ffc05db8: 40 be 00 0c bne+ cr7,ffc05dc4 <rtems_termios_open+0x360>
c = 'a';
ffc05dbc: 38 00 00 61 li r0,97
ffc05dc0: 98 09 00 0c stb r0,12(r9)
}
args->iop->data1 = tty;
ffc05dc4: 81 3a 00 00 lwz r9,0(r26)
ffc05dc8: 93 e9 00 38 stw r31,56(r9)
if (!tty->refcount++) {
ffc05dcc: 81 3f 00 08 lwz r9,8(r31)
ffc05dd0: 2f 89 00 00 cmpwi cr7,r9,0
ffc05dd4: 38 09 00 01 addi r0,r9,1
ffc05dd8: 90 1f 00 08 stw r0,8(r31)
ffc05ddc: 40 9e 00 6c bne- cr7,ffc05e48 <rtems_termios_open+0x3e4>
if (tty->device.firstOpen)
ffc05de0: 80 1f 00 98 lwz r0,152(r31)
ffc05de4: 2f 80 00 00 cmpwi cr7,r0,0
ffc05de8: 41 9e 00 18 beq- cr7,ffc05e00 <rtems_termios_open+0x39c><== ALWAYS TAKEN
(*tty->device.firstOpen)(major, minor, arg);
ffc05dec: 7f 83 e3 78 mr r3,r28 <== NOT EXECUTED
ffc05df0: 7c 09 03 a6 mtctr r0 <== NOT EXECUTED
ffc05df4: 7f 64 db 78 mr r4,r27 <== NOT EXECUTED
ffc05df8: 7f 45 d3 78 mr r5,r26 <== NOT EXECUTED
ffc05dfc: 4e 80 04 21 bctrl <== NOT EXECUTED
/*
* start I/O tasks, if needed
*/
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
ffc05e00: 80 1f 00 b4 lwz r0,180(r31)
ffc05e04: 2f 80 00 02 cmpwi cr7,r0,2
ffc05e08: 40 be 00 40 bne+ cr7,ffc05e48 <rtems_termios_open+0x3e4>
sc = rtems_task_start(
ffc05e0c: 80 7f 00 c4 lwz r3,196(r31)
ffc05e10: 3c 80 ff c0 lis r4,-64
ffc05e14: 38 84 72 d0 addi r4,r4,29392
ffc05e18: 7f e5 fb 78 mr r5,r31
ffc05e1c: 48 00 27 35 bl ffc08550 <rtems_task_start>
tty->rxTaskId, rtems_termios_rxdaemon, (rtems_task_argument)tty);
if (sc != RTEMS_SUCCESSFUL)
ffc05e20: 2f 83 00 00 cmpwi cr7,r3,0
ffc05e24: 40 9e 00 20 bne- cr7,ffc05e44 <rtems_termios_open+0x3e0><== NEVER TAKEN
rtems_fatal_error_occurred (sc);
sc = rtems_task_start(
ffc05e28: 80 7f 00 c8 lwz r3,200(r31)
ffc05e2c: 3c 80 ff c0 lis r4,-64
ffc05e30: 38 84 75 2c addi r4,r4,29996
ffc05e34: 7f e5 fb 78 mr r5,r31
ffc05e38: 48 00 27 19 bl ffc08550 <rtems_task_start>
tty->txTaskId, rtems_termios_txdaemon, (rtems_task_argument)tty);
if (sc != RTEMS_SUCCESSFUL)
ffc05e3c: 2f 83 00 00 cmpwi cr7,r3,0
ffc05e40: 41 be 00 08 beq+ cr7,ffc05e48 <rtems_termios_open+0x3e4><== ALWAYS TAKEN
rtems_fatal_error_occurred (sc);
ffc05e44: 48 00 2a 39 bl ffc0887c <rtems_fatal_error_occurred>
}
}
rtems_semaphore_release (rtems_termios_ttyMutex);
ffc05e48: 3d 20 00 00 lis r9,0
ffc05e4c: 80 69 27 fc lwz r3,10236(r9)
ffc05e50: 48 00 23 81 bl ffc081d0 <rtems_semaphore_release>
return RTEMS_SUCCESSFUL;
}
ffc05e54: 39 61 00 30 addi r11,r1,48
ffc05e58: 7f c3 f3 78 mr r3,r30
ffc05e5c: 4b ff a6 c4 b ffc00520 <_restgpr_22_x>
static char c = 'a';
/*
* Create a new device
*/
tty = calloc (1, sizeof (struct rtems_termios_tty));
ffc05e60: 38 60 00 01 li r3,1
ffc05e64: 38 80 00 e8 li r4,232
ffc05e68: 4b ff e5 dd bl ffc04444 <calloc>
if (tty == NULL) {
ffc05e6c: 7c 7f 1b 79 mr. r31,r3
ffc05e70: 40 82 fc 68 bne+ ffc05ad8 <rtems_termios_open+0x74>
ffc05e74: 4b ff fc 94 b ffc05b08 <rtems_termios_open+0xa4>
ffc0644c <rtems_termios_puts>:
* Send characters to device-specific code
*/
void
rtems_termios_puts (
const void *_buf, int len, struct rtems_termios_tty *tty)
{
ffc0644c: 94 21 ff d8 stwu r1,-40(r1)
ffc06450: 7c 08 02 a6 mflr r0
ffc06454: 90 01 00 2c stw r0,44(r1)
const unsigned char *buf = _buf;
unsigned int newHead;
rtems_interrupt_level level;
rtems_status_code sc;
if (tty->device.outputUsesInterrupts == TERMIOS_POLLED) {
ffc06458: 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)
{
ffc0645c: bf 01 00 08 stmw r24,8(r1)
ffc06460: 7c 7b 1b 78 mr r27,r3
const unsigned char *buf = _buf;
unsigned int newHead;
rtems_interrupt_level level;
rtems_status_code sc;
if (tty->device.outputUsesInterrupts == TERMIOS_POLLED) {
ffc06464: 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)
{
ffc06468: 7c 9a 23 78 mr r26,r4
ffc0646c: 7c bf 2b 78 mr r31,r5
const unsigned char *buf = _buf;
unsigned int newHead;
rtems_interrupt_level level;
rtems_status_code sc;
if (tty->device.outputUsesInterrupts == TERMIOS_POLLED) {
ffc06470: 40 be 00 20 bne+ cr7,ffc06490 <rtems_termios_puts+0x44>
(*tty->device.write)(tty->minor, buf, len);
ffc06474: 80 05 00 a4 lwz r0,164(r5)
ffc06478: 7f 64 db 78 mr r4,r27
ffc0647c: 80 65 00 10 lwz r3,16(r5)
ffc06480: 7f 45 d3 78 mr r5,r26
ffc06484: 7c 09 03 a6 mtctr r0
ffc06488: 4e 80 04 21 bctrl
return;
ffc0648c: 48 00 00 d8 b ffc06564 <rtems_termios_puts+0x118>
}
newHead = tty->rawOutBuf.Head;
ffc06490: 83 a5 00 80 lwz r29,128(r5)
while (len) {
ffc06494: 3b c0 00 00 li r30,0
* with interrupts enabled.
*/
newHead = (newHead + 1) % tty->rawOutBuf.Size;
rtems_interrupt_disable (level);
while (newHead == tty->rawOutBuf.Tail) {
tty->rawOutBufState = rob_wait;
ffc06498: 3b 00 00 02 li r24,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;
ffc0649c: 3b 20 00 01 li r25,1
if (tty->device.outputUsesInterrupts == TERMIOS_POLLED) {
(*tty->device.write)(tty->minor, buf, len);
return;
}
newHead = tty->rawOutBuf.Head;
while (len) {
ffc064a0: 48 00 00 bc b ffc0655c <rtems_termios_puts+0x110>
* len -= ncopy
*
* To minimize latency, the memcpy should be done
* with interrupts enabled.
*/
newHead = (newHead + 1) % tty->rawOutBuf.Size;
ffc064a4: 80 1f 00 88 lwz r0,136(r31)
ffc064a8: 3b bd 00 01 addi r29,r29,1
ffc064ac: 7d 3d 03 96 divwu r9,r29,r0
ffc064b0: 7c 09 01 d6 mullw r0,r9,r0
ffc064b4: 7f a0 e8 50 subf r29,r0,r29
ffc064b8: 48 00 00 28 b ffc064e0 <rtems_termios_puts+0x94>
rtems_interrupt_disable (level);
while (newHead == tty->rawOutBuf.Tail) {
tty->rawOutBufState = rob_wait;
ffc064bc: 93 1f 00 94 stw r24,148(r31)
ffc064c0: 7f 80 01 24 mtmsr r28
rtems_interrupt_enable (level);
sc = rtems_semaphore_obtain(
ffc064c4: 80 7f 00 8c lwz r3,140(r31)
ffc064c8: 38 80 00 00 li r4,0
ffc064cc: 38 a0 00 00 li r5,0
ffc064d0: 48 00 1b d5 bl ffc080a4 <rtems_semaphore_obtain>
tty->rawOutBuf.Semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
ffc064d4: 2f 83 00 00 cmpwi cr7,r3,0
ffc064d8: 41 be 00 08 beq+ cr7,ffc064e0 <rtems_termios_puts+0x94> <== ALWAYS TAKEN
rtems_fatal_error_occurred (sc);
ffc064dc: 48 00 23 a1 bl ffc0887c <rtems_fatal_error_occurred> <== NOT EXECUTED
rtems_interrupt_disable (level);
ffc064e0: 4b ff f5 0d bl ffc059ec <ppc_interrupt_disable>
ffc064e4: 7c 7c 1b 78 mr r28,r3
* To minimize latency, the memcpy should be done
* with interrupts enabled.
*/
newHead = (newHead + 1) % tty->rawOutBuf.Size;
rtems_interrupt_disable (level);
while (newHead == tty->rawOutBuf.Tail) {
ffc064e8: 80 1f 00 84 lwz r0,132(r31)
ffc064ec: 7f 9d 00 00 cmpw cr7,r29,r0
ffc064f0: 41 9e ff cc beq+ cr7,ffc064bc <rtems_termios_puts+0x70>
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++;
ffc064f4: 80 1f 00 80 lwz r0,128(r31)
ffc064f8: 7d 7b f0 ae lbzx r11,r27,r30
ffc064fc: 81 3f 00 7c lwz r9,124(r31)
ffc06500: 7d 69 01 ae stbx r11,r9,r0
tty->rawOutBuf.Head = newHead;
if (tty->rawOutBufState == rob_idle) {
ffc06504: 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;
ffc06508: 93 bf 00 80 stw r29,128(r31)
if (tty->rawOutBufState == rob_idle) {
ffc0650c: 2f 80 00 00 cmpwi cr7,r0,0
ffc06510: 40 9e 00 44 bne- cr7,ffc06554 <rtems_termios_puts+0x108>
/* check, whether XOFF has been received */
if (!(tty->flow_ctrl & FL_ORCVXOF)) {
ffc06514: 80 1f 00 b8 lwz r0,184(r31)
ffc06518: 70 09 00 10 andi. r9,r0,16
ffc0651c: 40 a2 00 28 bne+ ffc06544 <rtems_termios_puts+0xf8> <== NEVER TAKEN
(*tty->device.write)(tty->minor,
(char *)&tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail],1);
ffc06520: 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,
ffc06524: 38 a0 00 01 li r5,1
ffc06528: 80 9f 00 7c lwz r4,124(r31)
ffc0652c: 80 1f 00 a4 lwz r0,164(r31)
ffc06530: 80 7f 00 10 lwz r3,16(r31)
ffc06534: 7c 84 4a 14 add r4,r4,r9
ffc06538: 7c 09 03 a6 mtctr r0
ffc0653c: 4e 80 04 21 bctrl
ffc06540: 48 00 00 10 b ffc06550 <rtems_termios_puts+0x104>
(char *)&tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail],1);
} else {
/* remember that output has been stopped due to flow ctrl*/
tty->flow_ctrl |= FL_OSTOP;
ffc06544: 80 1f 00 b8 lwz r0,184(r31) <== NOT EXECUTED
ffc06548: 60 00 00 20 ori r0,r0,32 <== NOT EXECUTED
ffc0654c: 90 1f 00 b8 stw r0,184(r31) <== NOT EXECUTED
}
tty->rawOutBufState = rob_busy;
ffc06550: 93 3f 00 94 stw r25,148(r31)
ffc06554: 7f 80 01 24 mtmsr r28
ffc06558: 3b de 00 01 addi r30,r30,1
if (tty->device.outputUsesInterrupts == TERMIOS_POLLED) {
(*tty->device.write)(tty->minor, buf, len);
return;
}
newHead = tty->rawOutBuf.Head;
while (len) {
ffc0655c: 7f 9e d0 00 cmpw cr7,r30,r26
ffc06560: 40 9e ff 44 bne+ cr7,ffc064a4 <rtems_termios_puts+0x58>
tty->rawOutBufState = rob_busy;
}
rtems_interrupt_enable (level);
len--;
}
}
ffc06564: 39 61 00 28 addi r11,r1,40
ffc06568: 4b ff 9f c0 b ffc00528 <_restgpr_24_x>
ffc06c5c <rtems_termios_read>:
return RTEMS_SUCCESSFUL;
}
rtems_status_code
rtems_termios_read (void *arg)
{
ffc06c5c: 94 21 ff d0 stwu r1,-48(r1)
ffc06c60: 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);
ffc06c64: 38 80 00 00 li r4,0
return RTEMS_SUCCESSFUL;
}
rtems_status_code
rtems_termios_read (void *arg)
{
ffc06c68: 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);
ffc06c6c: 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;
ffc06c70: 81 23 00 00 lwz r9,0(r3)
return RTEMS_SUCCESSFUL;
}
rtems_status_code
rtems_termios_read (void *arg)
{
ffc06c74: be e1 00 0c stmw r23,12(r1)
ffc06c78: 7c 7e 1b 78 mr r30,r3
rtems_libio_rw_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
ffc06c7c: 83 e9 00 38 lwz r31,56(r9)
uint32_t count = args->count;
ffc06c80: 83 63 00 14 lwz r27,20(r3)
char *buffer = args->buffer;
ffc06c84: 83 43 00 10 lwz r26,16(r3)
rtems_status_code sc;
sc = rtems_semaphore_obtain (tty->isem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
ffc06c88: 80 7f 00 14 lwz r3,20(r31)
ffc06c8c: 48 00 14 19 bl ffc080a4 <rtems_semaphore_obtain>
if (sc != RTEMS_SUCCESSFUL)
ffc06c90: 7c 7c 1b 79 mr. r28,r3
ffc06c94: 40 82 03 30 bne- ffc06fc4 <rtems_termios_read+0x368> <== NEVER TAKEN
return sc;
if (rtems_termios_linesw[tty->t_line].l_read != NULL) {
ffc06c98: 80 1f 00 cc lwz r0,204(r31)
ffc06c9c: 3d 20 00 00 lis r9,0
ffc06ca0: 39 29 28 f0 addi r9,r9,10480
ffc06ca4: 54 00 28 34 rlwinm r0,r0,5,0,26
ffc06ca8: 7d 29 02 14 add r9,r9,r0
ffc06cac: 80 09 00 08 lwz r0,8(r9)
ffc06cb0: 2f 80 00 00 cmpwi cr7,r0,0
ffc06cb4: 41 9e 00 1c beq- cr7,ffc06cd0 <rtems_termios_read+0x74>
sc = rtems_termios_linesw[tty->t_line].l_read(tty,args);
ffc06cb8: 7f e3 fb 78 mr r3,r31
ffc06cbc: 7c 09 03 a6 mtctr r0
ffc06cc0: 7f c4 f3 78 mr r4,r30
ffc06cc4: 4e 80 04 21 bctrl
ffc06cc8: 7c 7c 1b 78 mr r28,r3
ffc06ccc: 48 00 02 e8 b ffc06fb4 <rtems_termios_read+0x358>
tty->tty_rcvwakeup = 0;
rtems_semaphore_release (tty->isem);
return sc;
}
if (tty->cindex == tty->ccount) {
ffc06cd0: 81 3f 00 24 lwz r9,36(r31)
ffc06cd4: 80 1f 00 20 lwz r0,32(r31)
ffc06cd8: 7f 89 00 00 cmpw cr7,r9,r0
ffc06cdc: 40 be 02 b0 bne+ cr7,ffc06f8c <rtems_termios_read+0x330><== NEVER TAKEN
tty->cindex = tty->ccount = 0;
tty->read_start_column = tty->column;
ffc06ce0: 80 1f 00 28 lwz r0,40(r31)
rtems_semaphore_release (tty->isem);
return sc;
}
if (tty->cindex == tty->ccount) {
tty->cindex = tty->ccount = 0;
ffc06ce4: 93 9f 00 20 stw r28,32(r31)
tty->read_start_column = tty->column;
ffc06ce8: 90 1f 00 2c stw r0,44(r31)
if (tty->device.pollRead != NULL &&
ffc06cec: 80 1f 00 a0 lwz r0,160(r31)
rtems_semaphore_release (tty->isem);
return sc;
}
if (tty->cindex == tty->ccount) {
tty->cindex = tty->ccount = 0;
ffc06cf0: 93 9f 00 24 stw r28,36(r31)
tty->read_start_column = tty->column;
if (tty->device.pollRead != NULL &&
ffc06cf4: 2f 80 00 00 cmpwi cr7,r0,0
ffc06cf8: 41 9e 00 f8 beq- cr7,ffc06df0 <rtems_termios_read+0x194>
ffc06cfc: 80 1f 00 b4 lwz r0,180(r31)
ffc06d00: 2f 80 00 00 cmpwi cr7,r0,0
ffc06d04: 40 be 00 ec bne+ cr7,ffc06df0 <rtems_termios_read+0x194>
static rtems_status_code
fillBufferPoll (struct rtems_termios_tty *tty)
{
int n;
if (tty->termios.c_lflag & ICANON) {
ffc06d08: 80 1f 00 3c lwz r0,60(r31)
ffc06d0c: 70 09 00 02 andi. r9,r0,2
ffc06d10: 41 82 00 40 beq- ffc06d50 <rtems_termios_read+0xf4>
for (;;) {
n = (*tty->device.pollRead)(tty->minor);
ffc06d14: 80 1f 00 a0 lwz r0,160(r31)
ffc06d18: 80 7f 00 10 lwz r3,16(r31)
ffc06d1c: 7c 09 03 a6 mtctr r0
ffc06d20: 4e 80 04 21 bctrl
if (n < 0) {
ffc06d24: 2c 03 00 00 cmpwi r3,0
ffc06d28: 40 a0 00 10 bge+ ffc06d38 <rtems_termios_read+0xdc>
rtems_task_wake_after (1);
ffc06d2c: 38 60 00 01 li r3,1
ffc06d30: 48 00 18 f9 bl ffc08628 <rtems_task_wake_after>
ffc06d34: 4b ff ff e0 b ffc06d14 <rtems_termios_read+0xb8>
} else {
if (siproc (n, tty))
ffc06d38: 54 63 06 3e clrlwi r3,r3,24
ffc06d3c: 7f e4 fb 78 mr r4,r31
ffc06d40: 4b ff fd e1 bl ffc06b20 <siproc>
ffc06d44: 2f 83 00 00 cmpwi cr7,r3,0
ffc06d48: 41 9e ff cc beq+ cr7,ffc06d14 <rtems_termios_read+0xb8>
ffc06d4c: 48 00 02 40 b ffc06f8c <rtems_termios_read+0x330>
}
}
} else {
rtems_interval then, now;
then = rtems_clock_get_ticks_since_boot();
ffc06d50: 48 00 0c 75 bl ffc079c4 <rtems_clock_get_ticks_since_boot>
ffc06d54: 7c 7d 1b 78 mr r29,r3
for (;;) {
n = (*tty->device.pollRead)(tty->minor);
ffc06d58: 80 1f 00 a0 lwz r0,160(r31)
ffc06d5c: 80 7f 00 10 lwz r3,16(r31)
ffc06d60: 7c 09 03 a6 mtctr r0
ffc06d64: 4e 80 04 21 bctrl
if (n < 0) {
ffc06d68: 2c 03 00 00 cmpwi r3,0
ffc06d6c: 40 80 00 50 bge- ffc06dbc <rtems_termios_read+0x160>
if (tty->termios.c_cc[VMIN]) {
ffc06d70: 88 1f 00 47 lbz r0,71(r31)
ffc06d74: 2f 80 00 00 cmpwi cr7,r0,0
ffc06d78: 88 1f 00 46 lbz r0,70(r31)
if (tty->termios.c_cc[VTIME] && tty->ccount) {
ffc06d7c: 70 09 00 ff andi. r9,r0,255
then = rtems_clock_get_ticks_since_boot();
for (;;) {
n = (*tty->device.pollRead)(tty->minor);
if (n < 0) {
if (tty->termios.c_cc[VMIN]) {
ffc06d80: 41 9e 00 18 beq- cr7,ffc06d98 <rtems_termios_read+0x13c><== NEVER TAKEN
if (tty->termios.c_cc[VTIME] && tty->ccount) {
ffc06d84: 41 82 00 2c beq- ffc06db0 <rtems_termios_read+0x154> <== NEVER TAKEN
ffc06d88: 80 1f 00 20 lwz r0,32(r31)
ffc06d8c: 2f 80 00 00 cmpwi cr7,r0,0
ffc06d90: 41 be 00 20 beq+ cr7,ffc06db0 <rtems_termios_read+0x154>
ffc06d94: 48 00 00 08 b ffc06d9c <rtems_termios_read+0x140>
if ((now - then) > tty->vtimeTicks) {
break;
}
}
} else {
if (!tty->termios.c_cc[VTIME])
ffc06d98: 41 82 01 f4 beq- ffc06f8c <rtems_termios_read+0x330> <== NOT EXECUTED
break;
now = rtems_clock_get_ticks_since_boot();
ffc06d9c: 48 00 0c 29 bl ffc079c4 <rtems_clock_get_ticks_since_boot>
if ((now - then) > tty->vtimeTicks) {
ffc06da0: 80 1f 00 54 lwz r0,84(r31)
ffc06da4: 7c 7d 18 50 subf r3,r29,r3
ffc06da8: 7f 83 00 40 cmplw cr7,r3,r0
ffc06dac: 41 9d 01 e0 bgt- cr7,ffc06f8c <rtems_termios_read+0x330>
break;
}
}
rtems_task_wake_after (1);
ffc06db0: 38 60 00 01 li r3,1
ffc06db4: 48 00 18 75 bl ffc08628 <rtems_task_wake_after>
ffc06db8: 4b ff ff a0 b ffc06d58 <rtems_termios_read+0xfc>
} else {
siproc (n, tty);
ffc06dbc: 54 63 06 3e clrlwi r3,r3,24
ffc06dc0: 7f e4 fb 78 mr r4,r31
ffc06dc4: 4b ff fd 5d bl ffc06b20 <siproc>
if (tty->ccount >= tty->termios.c_cc[VMIN])
ffc06dc8: 88 1f 00 47 lbz r0,71(r31)
ffc06dcc: 81 3f 00 20 lwz r9,32(r31)
ffc06dd0: 7f 89 00 00 cmpw cr7,r9,r0
ffc06dd4: 40 9c 01 b8 bge- cr7,ffc06f8c <rtems_termios_read+0x330>
break;
if (tty->termios.c_cc[VMIN] && tty->termios.c_cc[VTIME])
ffc06dd8: 2f 80 00 00 cmpwi cr7,r0,0
ffc06ddc: 41 be ff 7c beq- cr7,ffc06d58 <rtems_termios_read+0xfc> <== NEVER TAKEN
ffc06de0: 88 1f 00 46 lbz r0,70(r31)
ffc06de4: 2f 80 00 00 cmpwi cr7,r0,0
ffc06de8: 41 9e ff 70 beq+ cr7,ffc06d58 <rtems_termios_read+0xfc> <== NEVER TAKEN
ffc06dec: 4b ff ff 64 b ffc06d50 <rtems_termios_read+0xf4>
* Fill the input buffer from the raw input queue
*/
static rtems_status_code
fillBufferQueue (struct rtems_termios_tty *tty)
{
rtems_interval timeout = tty->rawInBufSemaphoreFirstTimeout;
ffc06df0: 83 3f 00 74 lwz r25,116(r31)
rtems_status_code sc;
int wait = (int)1;
ffc06df4: 3b a0 00 01 li r29,1
while ( wait ) {
/*
* Process characters read from raw queue
*/
while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&
(tty->ccount < (CBUFSIZE-1))) {
ffc06df8: 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)(
ffc06dfc: 3b 1f 00 49 addi r24,r31,73
ffc06e00: 48 00 01 20 b ffc06f20 <rtems_termios_read+0x2c4>
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;
ffc06e04: 81 3f 00 5c lwz r9,92(r31)
ffc06e08: 81 7f 00 64 lwz r11,100(r31)
ffc06e0c: 39 29 00 01 addi r9,r9,1
ffc06e10: 7c 09 5b 96 divwu r0,r9,r11
ffc06e14: 7c 00 59 d6 mullw r0,r0,r11
ffc06e18: 7c 00 48 50 subf r0,r0,r9
c = tty->rawInBuf.theBuf[newHead];
ffc06e1c: 81 3f 00 58 lwz r9,88(r31)
ffc06e20: 7f 29 00 ae lbzx r25,r9,r0
tty->rawInBuf.Head = newHead;
ffc06e24: 90 1f 00 5c stw r0,92(r31)
if(((tty->rawInBuf.Tail-newHead+tty->rawInBuf.Size)
ffc06e28: 81 7f 00 60 lwz r11,96(r31)
ffc06e2c: 81 5f 00 64 lwz r10,100(r31)
% tty->rawInBuf.Size)
ffc06e30: 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)
ffc06e34: 7d 6a 5a 14 add r11,r10,r11
ffc06e38: 7c 00 58 50 subf r0,r0,r11
% tty->rawInBuf.Size)
ffc06e3c: 7d 60 4b 96 divwu r11,r0,r9
ffc06e40: 7d 2b 49 d6 mullw r9,r11,r9
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)
ffc06e44: 81 7f 00 bc lwz r11,188(r31)
% tty->rawInBuf.Size)
ffc06e48: 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)
ffc06e4c: 7f 80 58 40 cmplw cr7,r0,r11
ffc06e50: 40 9c 00 84 bge- cr7,ffc06ed4 <rtems_termios_read+0x278><== NEVER TAKEN
% tty->rawInBuf.Size)
< tty->lowwater) {
tty->flow_ctrl &= ~FL_IREQXOF;
ffc06e54: 80 1f 00 b8 lwz r0,184(r31)
ffc06e58: 54 00 00 3c rlwinm r0,r0,0,0,30
ffc06e5c: 90 1f 00 b8 stw r0,184(r31)
/* if tx stopped and XON should be sent... */
if (((tty->flow_ctrl & (FL_MDXON | FL_ISNTXOF))
ffc06e60: 80 1f 00 b8 lwz r0,184(r31)
ffc06e64: 70 00 02 02 andi. r0,r0,514
ffc06e68: 2f 80 02 02 cmpwi cr7,r0,514
ffc06e6c: 40 be 00 38 bne+ cr7,ffc06ea4 <rtems_termios_read+0x248><== ALWAYS TAKEN
== (FL_MDXON | FL_ISNTXOF))
&& ((tty->rawOutBufState == rob_idle)
ffc06e70: 80 1f 00 94 lwz r0,148(r31) <== NOT EXECUTED
ffc06e74: 2f 80 00 00 cmpwi cr7,r0,0 <== NOT EXECUTED
ffc06e78: 41 9e 00 10 beq- cr7,ffc06e88 <rtems_termios_read+0x22c><== NOT EXECUTED
|| (tty->flow_ctrl & FL_OSTOP))) {
ffc06e7c: 80 1f 00 b8 lwz r0,184(r31) <== NOT EXECUTED
ffc06e80: 70 09 00 20 andi. r9,r0,32 <== NOT EXECUTED
ffc06e84: 41 82 00 20 beq- ffc06ea4 <rtems_termios_read+0x248> <== NOT EXECUTED
/* XON should be sent now... */
(*tty->device.write)(
ffc06e88: 80 1f 00 a4 lwz r0,164(r31) <== NOT EXECUTED
ffc06e8c: 7f 04 c3 78 mr r4,r24 <== NOT EXECUTED
ffc06e90: 80 7f 00 10 lwz r3,16(r31) <== NOT EXECUTED
ffc06e94: 38 a0 00 01 li r5,1 <== NOT EXECUTED
ffc06e98: 7c 09 03 a6 mtctr r0 <== NOT EXECUTED
ffc06e9c: 4e 80 04 21 bctrl <== NOT EXECUTED
ffc06ea0: 48 00 00 34 b ffc06ed4 <rtems_termios_read+0x278> <== NOT EXECUTED
tty->minor, (void *)&(tty->termios.c_cc[VSTART]), 1);
} else if (tty->flow_ctrl & FL_MDRTS) {
ffc06ea4: 80 1f 00 b8 lwz r0,184(r31)
ffc06ea8: 70 09 01 00 andi. r9,r0,256
ffc06eac: 41 82 00 28 beq- ffc06ed4 <rtems_termios_read+0x278> <== ALWAYS TAKEN
tty->flow_ctrl &= ~FL_IRTSOFF;
ffc06eb0: 80 1f 00 b8 lwz r0,184(r31) <== NOT EXECUTED
ffc06eb4: 54 00 07 b8 rlwinm r0,r0,0,30,28 <== NOT EXECUTED
ffc06eb8: 90 1f 00 b8 stw r0,184(r31) <== NOT EXECUTED
/* activate RTS line */
if (tty->device.startRemoteTx != NULL) {
ffc06ebc: 80 1f 00 b0 lwz r0,176(r31) <== NOT EXECUTED
ffc06ec0: 2f 80 00 00 cmpwi cr7,r0,0 <== NOT EXECUTED
ffc06ec4: 41 9e 00 10 beq- cr7,ffc06ed4 <rtems_termios_read+0x278><== NOT EXECUTED
tty->device.startRemoteTx(tty->minor);
ffc06ec8: 80 7f 00 10 lwz r3,16(r31) <== NOT EXECUTED
ffc06ecc: 7c 09 03 a6 mtctr r0 <== NOT EXECUTED
ffc06ed0: 4e 80 04 21 bctrl <== NOT EXECUTED
}
}
}
/* continue processing new character */
if (tty->termios.c_lflag & ICANON) {
ffc06ed4: 80 1f 00 3c lwz r0,60(r31)
if (siproc (c, tty))
ffc06ed8: 7f 23 cb 78 mr r3,r25
ffc06edc: 7f e4 fb 78 mr r4,r31
}
}
}
/* continue processing new character */
if (tty->termios.c_lflag & ICANON) {
ffc06ee0: 70 09 00 02 andi. r9,r0,2
ffc06ee4: 41 82 00 18 beq- ffc06efc <rtems_termios_read+0x2a0> <== NEVER TAKEN
if (siproc (c, tty))
ffc06ee8: 4b ff fc 39 bl ffc06b20 <siproc>
wait = 0;
ffc06eec: 30 63 ff ff addic r3,r3,-1
ffc06ef0: 7c 63 19 10 subfe r3,r3,r3
ffc06ef4: 7f bd 18 38 and r29,r29,r3
ffc06ef8: 48 00 00 24 b ffc06f1c <rtems_termios_read+0x2c0>
} else {
siproc (c, tty);
ffc06efc: 4b ff fc 25 bl ffc06b20 <siproc> <== NOT EXECUTED
if (tty->ccount >= tty->termios.c_cc[VMIN])
ffc06f00: 88 1f 00 47 lbz r0,71(r31) <== NOT EXECUTED
ffc06f04: 81 3f 00 20 lwz r9,32(r31) <== NOT EXECUTED
wait = 0;
ffc06f08: 7f 89 00 00 cmpw cr7,r9,r0 <== NOT EXECUTED
ffc06f0c: 7c 00 00 26 mfcr r0 <== NOT EXECUTED
ffc06f10: 54 00 ef fe rlwinm r0,r0,29,31,31 <== NOT EXECUTED
ffc06f14: 7c 00 00 d0 neg r0,r0 <== NOT EXECUTED
ffc06f18: 7f bd 00 38 and r29,r29,r0 <== NOT EXECUTED
}
timeout = tty->rawInBufSemaphoreTimeout;
ffc06f1c: 83 3f 00 70 lwz r25,112(r31)
while ( wait ) {
/*
* Process characters read from raw queue
*/
while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&
ffc06f20: 81 3f 00 5c lwz r9,92(r31)
ffc06f24: 80 1f 00 60 lwz r0,96(r31)
ffc06f28: 7f 89 00 00 cmpw cr7,r9,r0
ffc06f2c: 41 9e 00 1c beq- cr7,ffc06f48 <rtems_termios_read+0x2ec>
(tty->ccount < (CBUFSIZE-1))) {
ffc06f30: 39 37 21 b0 addi r9,r23,8624
ffc06f34: 81 29 00 08 lwz r9,8(r9)
ffc06f38: 38 09 ff ff addi r0,r9,-1
while ( wait ) {
/*
* Process characters read from raw queue
*/
while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&
ffc06f3c: 81 3f 00 20 lwz r9,32(r31)
ffc06f40: 7f 89 00 00 cmpw cr7,r9,r0
ffc06f44: 41 9c fe c0 blt+ cr7,ffc06e04 <rtems_termios_read+0x1a8><== ALWAYS TAKEN
}
/*
* Wait for characters
*/
if ( wait ) {
ffc06f48: 2f 9d 00 00 cmpwi cr7,r29,0
ffc06f4c: 41 be 00 40 beq+ cr7,ffc06f8c <rtems_termios_read+0x330>
sc = rtems_semaphore_obtain(
ffc06f50: 80 7f 00 68 lwz r3,104(r31)
ffc06f54: 7f 25 cb 78 mr r5,r25
ffc06f58: 80 9f 00 6c lwz r4,108(r31)
ffc06f5c: 48 00 11 49 bl ffc080a4 <rtems_semaphore_obtain>
tty->rawInBuf.Semaphore, tty->rawInBufSemaphoreOptions, timeout);
if (sc != RTEMS_SUCCESSFUL)
ffc06f60: 2f 83 00 00 cmpwi cr7,r3,0
ffc06f64: 41 9e ff bc beq+ cr7,ffc06f20 <rtems_termios_read+0x2c4><== ALWAYS TAKEN
ffc06f68: 48 00 00 24 b ffc06f8c <rtems_termios_read+0x330> <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
tty->cindex = tty->ccount = 0;
}
while (count && (tty->cindex < tty->ccount)) {
*buffer++ = tty->cbuf[tty->cindex++];
ffc06f6c: 81 7f 00 1c lwz r11,28(r31)
count--;
ffc06f70: 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++];
ffc06f74: 7c 0b 48 ae lbzx r0,r11,r9
ffc06f78: 39 29 00 01 addi r9,r9,1
ffc06f7c: 98 1a 00 00 stb r0,0(r26)
ffc06f80: 3b 5a 00 01 addi r26,r26,1
ffc06f84: 91 3f 00 24 stw r9,36(r31)
ffc06f88: 48 00 00 0c b ffc06f94 <rtems_termios_read+0x338>
ffc06f8c: 38 1b 00 01 addi r0,r27,1
ffc06f90: 7c 09 03 a6 mtctr r0
sc = fillBufferQueue (tty);
if (sc != RTEMS_SUCCESSFUL)
tty->cindex = tty->ccount = 0;
}
while (count && (tty->cindex < tty->ccount)) {
ffc06f94: 42 40 00 14 bdz- ffc06fa8 <rtems_termios_read+0x34c>
ffc06f98: 81 3f 00 24 lwz r9,36(r31)
ffc06f9c: 80 1f 00 20 lwz r0,32(r31)
ffc06fa0: 7f 89 00 00 cmpw cr7,r9,r0
ffc06fa4: 41 9c ff c8 blt+ cr7,ffc06f6c <rtems_termios_read+0x310>
*buffer++ = tty->cbuf[tty->cindex++];
count--;
}
args->bytes_moved = args->count - count;
ffc06fa8: 80 1e 00 14 lwz r0,20(r30)
ffc06fac: 7f 7b 00 50 subf r27,r27,r0
ffc06fb0: 93 7e 00 1c stw r27,28(r30)
tty->tty_rcvwakeup = 0;
ffc06fb4: 38 00 00 00 li r0,0
rtems_semaphore_release (tty->isem);
ffc06fb8: 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;
tty->tty_rcvwakeup = 0;
ffc06fbc: 90 1f 00 e4 stw r0,228(r31)
rtems_semaphore_release (tty->isem);
ffc06fc0: 48 00 12 11 bl ffc081d0 <rtems_semaphore_release>
return sc;
}
ffc06fc4: 39 61 00 30 addi r11,r1,48
ffc06fc8: 7f 83 e3 78 mr r3,r28
ffc06fcc: 4b ff 95 58 b ffc00524 <_restgpr_23_x>
ffc07348 <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)
{
ffc07348: 94 21 ff e8 stwu r1,-24(r1)
ffc0734c: 7c 08 02 a6 mflr r0
ffc07350: 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))
ffc07354: 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)
{
ffc07358: bf a1 00 0c stmw r29,12(r1)
ffc0735c: 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))
ffc07360: 70 00 04 03 andi. r0,r0,1027
ffc07364: 2f 80 04 01 cmpwi cr7,r0,1025
ffc07368: 40 be 00 38 bne+ cr7,ffc073a0 <rtems_termios_refill_transmitter+0x58><== ALWAYS TAKEN
== (FL_MDXOF | FL_IREQXOF)) {
/* XOFF should be sent now... */
(*tty->device.write)(tty->minor, (void *)&(tty->termios.c_cc[VSTOP]), 1);
ffc0736c: 80 03 00 a4 lwz r0,164(r3) <== NOT EXECUTED
ffc07370: 38 9f 00 4a addi r4,r31,74 <== NOT EXECUTED
ffc07374: 38 a0 00 01 li r5,1 <== NOT EXECUTED
ffc07378: 80 63 00 10 lwz r3,16(r3) <== NOT EXECUTED
ffc0737c: 7c 09 03 a6 mtctr r0 <== NOT EXECUTED
ffc07380: 4e 80 04 21 bctrl <== NOT EXECUTED
rtems_interrupt_disable(level);
ffc07384: 4b ff e6 69 bl ffc059ec <ppc_interrupt_disable> <== NOT EXECUTED
tty->t_dqlen--;
ffc07388: 81 3f 00 90 lwz r9,144(r31) <== NOT EXECUTED
ffc0738c: 38 09 ff ff addi r0,r9,-1 <== NOT EXECUTED
ffc07390: 90 1f 00 90 stw r0,144(r31) <== NOT EXECUTED
tty->flow_ctrl |= FL_ISNTXOF;
ffc07394: 80 1f 00 b8 lwz r0,184(r31) <== NOT EXECUTED
ffc07398: 60 00 00 02 ori r0,r0,2 <== NOT EXECUTED
ffc0739c: 48 00 00 44 b ffc073e0 <rtems_termios_refill_transmitter+0x98><== NOT EXECUTED
rtems_interrupt_enable(level);
nToSend = 1;
} else if ((tty->flow_ctrl & (FL_IREQXOF | FL_ISNTXOF)) == FL_ISNTXOF) {
ffc073a0: 80 03 00 b8 lwz r0,184(r3)
ffc073a4: 54 00 07 be clrlwi r0,r0,30
ffc073a8: 2f 80 00 02 cmpwi cr7,r0,2
ffc073ac: 40 be 00 44 bne+ cr7,ffc073f0 <rtems_termios_refill_transmitter+0xa8><== ALWAYS TAKEN
* FIXME: this .write call will generate another
* dequeue callback. This will advance the "Tail" in the data
* buffer, although the corresponding data is not yet out!
* Therefore the dequeue "length" should be reduced by 1
*/
(*tty->device.write)(tty->minor, (void *)&(tty->termios.c_cc[VSTART]), 1);
ffc073b0: 80 03 00 a4 lwz r0,164(r3) <== NOT EXECUTED
ffc073b4: 38 9f 00 49 addi r4,r31,73 <== NOT EXECUTED
ffc073b8: 38 a0 00 01 li r5,1 <== NOT EXECUTED
ffc073bc: 80 63 00 10 lwz r3,16(r3) <== NOT EXECUTED
ffc073c0: 7c 09 03 a6 mtctr r0 <== NOT EXECUTED
ffc073c4: 4e 80 04 21 bctrl <== NOT EXECUTED
rtems_interrupt_disable(level);
ffc073c8: 4b ff e6 25 bl ffc059ec <ppc_interrupt_disable> <== NOT EXECUTED
tty->t_dqlen--;
ffc073cc: 81 3f 00 90 lwz r9,144(r31) <== NOT EXECUTED
ffc073d0: 38 09 ff ff addi r0,r9,-1 <== NOT EXECUTED
ffc073d4: 90 1f 00 90 stw r0,144(r31) <== NOT EXECUTED
tty->flow_ctrl &= ~FL_ISNTXOF;
ffc073d8: 80 1f 00 b8 lwz r0,184(r31) <== NOT EXECUTED
ffc073dc: 54 00 07 fa rlwinm r0,r0,0,31,29 <== NOT EXECUTED
ffc073e0: 90 1f 00 b8 stw r0,184(r31) <== NOT EXECUTED
ffc073e4: 7c 60 01 24 mtmsr r3 <== NOT EXECUTED
rtems_interrupt_enable(level);
nToSend = 1;
ffc073e8: 3b c0 00 01 li r30,1 <== NOT EXECUTED
ffc073ec: 48 00 01 34 b ffc07520 <rtems_termios_refill_transmitter+0x1d8><== NOT EXECUTED
} else {
if ( tty->rawOutBuf.Head == tty->rawOutBuf.Tail ) {
ffc073f0: 81 23 00 80 lwz r9,128(r3)
ffc073f4: 80 03 00 84 lwz r0,132(r3)
ffc073f8: 7f 89 00 00 cmpw cr7,r9,r0
ffc073fc: 40 9e 00 20 bne- cr7,ffc0741c <rtems_termios_refill_transmitter+0xd4>
/*
* buffer was empty
*/
if (tty->rawOutBufState == rob_wait) {
ffc07400: 80 03 00 94 lwz r0,148(r3)
/*
* this should never happen...
*/
rtems_semaphore_release (tty->rawOutBuf.Semaphore);
}
return 0;
ffc07404: 3b c0 00 00 li r30,0
} else {
if ( tty->rawOutBuf.Head == tty->rawOutBuf.Tail ) {
/*
* buffer was empty
*/
if (tty->rawOutBufState == rob_wait) {
ffc07408: 2f 80 00 02 cmpwi cr7,r0,2
ffc0740c: 40 be 01 14 bne+ cr7,ffc07520 <rtems_termios_refill_transmitter+0x1d8><== ALWAYS TAKEN
/*
* this should never happen...
*/
rtems_semaphore_release (tty->rawOutBuf.Semaphore);
ffc07410: 80 63 00 8c lwz r3,140(r3) <== NOT EXECUTED
ffc07414: 48 00 0d bd bl ffc081d0 <rtems_semaphore_release> <== NOT EXECUTED
ffc07418: 48 00 01 08 b ffc07520 <rtems_termios_refill_transmitter+0x1d8><== NOT EXECUTED
}
return 0;
}
rtems_interrupt_disable(level);
ffc0741c: 4b ff e5 d1 bl ffc059ec <ppc_interrupt_disable>
len = tty->t_dqlen;
tty->t_dqlen = 0;
ffc07420: 38 00 00 00 li r0,0
}
return 0;
}
rtems_interrupt_disable(level);
len = tty->t_dqlen;
ffc07424: 83 bf 00 90 lwz r29,144(r31)
tty->t_dqlen = 0;
ffc07428: 90 1f 00 90 stw r0,144(r31)
ffc0742c: 7c 60 01 24 mtmsr r3
rtems_interrupt_enable(level);
newTail = (tty->rawOutBuf.Tail + len) % tty->rawOutBuf.Size;
ffc07430: 80 1f 00 84 lwz r0,132(r31)
ffc07434: 81 3f 00 88 lwz r9,136(r31)
ffc07438: 7c 1d 02 14 add r0,r29,r0
ffc0743c: 7f a0 4b 96 divwu r29,r0,r9
ffc07440: 7f bd 49 d6 mullw r29,r29,r9
ffc07444: 7f bd 00 50 subf r29,r29,r0
tty->rawOutBuf.Tail = newTail;
if (tty->rawOutBufState == rob_wait) {
ffc07448: 80 1f 00 94 lwz r0,148(r31)
len = tty->t_dqlen;
tty->t_dqlen = 0;
rtems_interrupt_enable(level);
newTail = (tty->rawOutBuf.Tail + len) % tty->rawOutBuf.Size;
tty->rawOutBuf.Tail = newTail;
ffc0744c: 93 bf 00 84 stw r29,132(r31)
if (tty->rawOutBufState == rob_wait) {
ffc07450: 2f 80 00 02 cmpwi cr7,r0,2
ffc07454: 40 be 00 0c bne+ cr7,ffc07460 <rtems_termios_refill_transmitter+0x118>
/*
* wake up any pending writer task
*/
rtems_semaphore_release (tty->rawOutBuf.Semaphore);
ffc07458: 80 7f 00 8c lwz r3,140(r31)
ffc0745c: 48 00 0d 75 bl ffc081d0 <rtems_semaphore_release>
}
if (newTail == tty->rawOutBuf.Head) {
ffc07460: 80 1f 00 80 lwz r0,128(r31)
ffc07464: 7f 9d 00 00 cmpw cr7,r29,r0
ffc07468: 40 be 00 30 bne+ cr7,ffc07498 <rtems_termios_refill_transmitter+0x150>
/*
* Buffer has become empty
*/
tty->rawOutBufState = rob_idle;
ffc0746c: 38 00 00 00 li r0,0
ffc07470: 90 1f 00 94 stw r0,148(r31)
nToSend = 0;
ffc07474: 3b c0 00 00 li r30,0
/*
* check to see if snd wakeup callback was set
*/
if ( tty->tty_snd.sw_pfn != NULL) {
ffc07478: 80 1f 00 d4 lwz r0,212(r31)
ffc0747c: 2f 80 00 00 cmpwi cr7,r0,0
ffc07480: 41 9e 00 9c beq- cr7,ffc0751c <rtems_termios_refill_transmitter+0x1d4><== ALWAYS TAKEN
(*tty->tty_snd.sw_pfn)(&tty->termios, tty->tty_snd.sw_arg);
ffc07484: 38 7f 00 30 addi r3,r31,48 <== NOT EXECUTED
ffc07488: 80 9f 00 d8 lwz r4,216(r31) <== NOT EXECUTED
ffc0748c: 7c 09 03 a6 mtctr r0 <== NOT EXECUTED
ffc07490: 4e 80 04 21 bctrl <== NOT EXECUTED
ffc07494: 48 00 00 88 b ffc0751c <rtems_termios_refill_transmitter+0x1d4><== NOT EXECUTED
}
}
/* check, whether output should stop due to received XOFF */
else if ((tty->flow_ctrl & (FL_MDXON | FL_ORCVXOF))
ffc07498: 80 1f 00 b8 lwz r0,184(r31)
ffc0749c: 70 00 02 10 andi. r0,r0,528
ffc074a0: 2f 80 02 10 cmpwi cr7,r0,528
ffc074a4: 40 be 00 28 bne+ cr7,ffc074cc <rtems_termios_refill_transmitter+0x184><== ALWAYS TAKEN
== (FL_MDXON | FL_ORCVXOF)) {
/* Buffer not empty, but output stops due to XOFF */
/* set flag, that output has been stopped */
rtems_interrupt_disable(level);
ffc074a8: 4b ff e5 45 bl ffc059ec <ppc_interrupt_disable> <== NOT EXECUTED
tty->flow_ctrl |= FL_OSTOP;
ffc074ac: 80 1f 00 b8 lwz r0,184(r31) <== NOT EXECUTED
ffc074b0: 60 00 00 20 ori r0,r0,32 <== NOT EXECUTED
ffc074b4: 90 1f 00 b8 stw r0,184(r31) <== NOT EXECUTED
tty->rawOutBufState = rob_busy; /*apm*/
ffc074b8: 38 00 00 01 li r0,1 <== NOT EXECUTED
ffc074bc: 90 1f 00 94 stw r0,148(r31) <== NOT EXECUTED
ffc074c0: 7c 60 01 24 mtmsr r3 <== NOT EXECUTED
rtems_interrupt_enable(level);
nToSend = 0;
ffc074c4: 3b c0 00 00 li r30,0 <== NOT EXECUTED
ffc074c8: 48 00 00 54 b ffc0751c <rtems_termios_refill_transmitter+0x1d4><== NOT EXECUTED
} else {
/*
* Buffer not empty, start tranmitter
*/
if (newTail > tty->rawOutBuf.Head)
ffc074cc: 80 1f 00 80 lwz r0,128(r31)
ffc074d0: 7f 9d 00 40 cmplw cr7,r29,r0
ffc074d4: 40 9d 00 0c ble- cr7,ffc074e0 <rtems_termios_refill_transmitter+0x198>
nToSend = tty->rawOutBuf.Size - newTail;
ffc074d8: 83 df 00 88 lwz r30,136(r31)
ffc074dc: 48 00 00 08 b ffc074e4 <rtems_termios_refill_transmitter+0x19c>
else
nToSend = tty->rawOutBuf.Head - newTail;
ffc074e0: 83 df 00 80 lwz r30,128(r31)
/* 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)) {
ffc074e4: 80 1f 00 b8 lwz r0,184(r31)
* Buffer not empty, start tranmitter
*/
if (newTail > tty->rawOutBuf.Head)
nToSend = tty->rawOutBuf.Size - newTail;
else
nToSend = tty->rawOutBuf.Head - newTail;
ffc074e8: 7f dd f0 50 subf r30,r29,r30
/* 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)) {
ffc074ec: 70 09 06 00 andi. r9,r0,1536
ffc074f0: 41 82 00 08 beq- ffc074f8 <rtems_termios_refill_transmitter+0x1b0>
nToSend = 1;
ffc074f4: 3b c0 00 01 li r30,1
}
tty->rawOutBufState = rob_busy; /*apm*/
ffc074f8: 38 00 00 01 li r0,1
(*tty->device.write)(
ffc074fc: 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*/
ffc07500: 90 1f 00 94 stw r0,148(r31)
(*tty->device.write)(
ffc07504: 7f c5 f3 78 mr r5,r30
ffc07508: 7c 84 ea 14 add r4,r4,r29
ffc0750c: 80 1f 00 a4 lwz r0,164(r31)
ffc07510: 80 7f 00 10 lwz r3,16(r31)
ffc07514: 7c 09 03 a6 mtctr r0
ffc07518: 4e 80 04 21 bctrl
tty->minor, &tty->rawOutBuf.theBuf[newTail], nToSend);
}
tty->rawOutBuf.Tail = newTail; /*apm*/
ffc0751c: 93 bf 00 84 stw r29,132(r31)
}
return nToSend;
}
ffc07520: 39 61 00 18 addi r11,r1,24
ffc07524: 7f c3 f3 78 mr r3,r30
ffc07528: 4b ff 90 14 b ffc0053c <_restgpr_29_x>
ffc072d0 <rtems_termios_rxdaemon>:
/*
* this task actually processes any receive events
*/
static rtems_task rtems_termios_rxdaemon(rtems_task_argument argument)
{
ffc072d0: 7c 2b 0b 78 mr r11,r1
ffc072d4: 7c 08 02 a6 mflr r0
ffc072d8: 94 21 ff e0 stwu r1,-32(r1)
ffc072dc: 90 01 00 24 stw r0,36(r1)
ffc072e0: 48 01 40 6d bl ffc1b34c <_savegpr_31>
ffc072e4: 7c 7f 1b 78 mr r31,r3
while (1) {
/*
* wait for rtems event
*/
rtems_event_receive(
ffc072e8: 38 60 00 03 li r3,3
ffc072ec: 38 80 00 02 li r4,2
ffc072f0: 38 a0 00 00 li r5,0
ffc072f4: 38 c1 00 0c addi r6,r1,12
ffc072f8: 48 00 07 5d bl ffc07a54 <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) {
ffc072fc: 80 01 00 0c lwz r0,12(r1)
ffc07300: 70 09 00 01 andi. r9,r0,1
ffc07304: 41 a2 00 14 beq+ ffc07318 <rtems_termios_rxdaemon+0x48> <== ALWAYS TAKEN
tty->rxTaskId = 0;
ffc07308: 38 00 00 00 li r0,0 <== NOT EXECUTED
ffc0730c: 90 1f 00 c4 stw r0,196(r31) <== NOT EXECUTED
rtems_task_delete(RTEMS_SELF);
ffc07310: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc07314: 48 00 10 b5 bl ffc083c8 <rtems_task_delete> <== NOT EXECUTED
}
/*
* do something
*/
c = tty->device.pollRead(tty->minor);
ffc07318: 80 1f 00 a0 lwz r0,160(r31)
ffc0731c: 80 7f 00 10 lwz r3,16(r31)
ffc07320: 7c 09 03 a6 mtctr r0
ffc07324: 4e 80 04 21 bctrl
if (c != EOF) {
ffc07328: 2f 83 ff ff cmpwi cr7,r3,-1
ffc0732c: 41 9e ff bc beq+ cr7,ffc072e8 <rtems_termios_rxdaemon+0x18>
/*
* pollRead did call enqueue on its own
*/
c_buf = c;
ffc07330: 98 61 00 08 stb r3,8(r1)
rtems_termios_enqueue_raw_characters ( tty,&c_buf,1);
ffc07334: 38 81 00 08 addi r4,r1,8
ffc07338: 7f e3 fb 78 mr r3,r31
ffc0733c: 38 a0 00 01 li r5,1
ffc07340: 4b ff fc b9 bl ffc06ff8 <rtems_termios_enqueue_raw_characters>
ffc07344: 4b ff ff a4 b ffc072e8 <rtems_termios_rxdaemon+0x18>
ffc0752c <rtems_termios_txdaemon>:
/*
* this task actually processes any transmit events
*/
static rtems_task rtems_termios_txdaemon(rtems_task_argument argument)
{
ffc0752c: 94 21 ff e0 stwu r1,-32(r1)
ffc07530: 7c 08 02 a6 mflr r0
ffc07534: bf c1 00 18 stmw r30,24(r1)
}
/*
* call any line discipline start function
*/
if (rtems_termios_linesw[tty->t_line].l_start != NULL) {
ffc07538: 3f c0 00 00 lis r30,0
/*
* this task actually processes any transmit events
*/
static rtems_task rtems_termios_txdaemon(rtems_task_argument argument)
{
ffc0753c: 7c 7f 1b 78 mr r31,r3
ffc07540: 90 01 00 24 stw r0,36(r1)
}
/*
* call any line discipline start function
*/
if (rtems_termios_linesw[tty->t_line].l_start != NULL) {
ffc07544: 3b de 28 f0 addi r30,r30,10480
while (1) {
/*
* wait for rtems event
*/
rtems_event_receive(
ffc07548: 38 60 00 03 li r3,3
ffc0754c: 38 80 00 02 li r4,2
ffc07550: 38 a0 00 00 li r5,0
ffc07554: 38 c1 00 08 addi r6,r1,8
ffc07558: 48 00 04 fd bl ffc07a54 <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) {
ffc0755c: 80 01 00 08 lwz r0,8(r1)
ffc07560: 70 09 00 01 andi. r9,r0,1
ffc07564: 41 a2 00 14 beq+ ffc07578 <rtems_termios_txdaemon+0x4c> <== ALWAYS TAKEN
tty->txTaskId = 0;
ffc07568: 38 00 00 00 li r0,0 <== NOT EXECUTED
ffc0756c: 90 1f 00 c8 stw r0,200(r31) <== NOT EXECUTED
rtems_task_delete(RTEMS_SELF);
ffc07570: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc07574: 48 00 0e 55 bl ffc083c8 <rtems_task_delete> <== NOT EXECUTED
}
/*
* call any line discipline start function
*/
if (rtems_termios_linesw[tty->t_line].l_start != NULL) {
ffc07578: 81 3f 00 cc lwz r9,204(r31)
ffc0757c: 55 29 28 34 rlwinm r9,r9,5,0,26
ffc07580: 7d 3e 4a 14 add r9,r30,r9
ffc07584: 80 09 00 14 lwz r0,20(r9)
ffc07588: 2f 80 00 00 cmpwi cr7,r0,0
ffc0758c: 41 9e 00 10 beq- cr7,ffc0759c <rtems_termios_txdaemon+0x70><== ALWAYS TAKEN
rtems_termios_linesw[tty->t_line].l_start(tty);
ffc07590: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc07594: 7c 09 03 a6 mtctr r0 <== NOT EXECUTED
ffc07598: 4e 80 04 21 bctrl <== NOT EXECUTED
}
/*
* try to push further characters to device
*/
rtems_termios_refill_transmitter(tty);
ffc0759c: 7f e3 fb 78 mr r3,r31
ffc075a0: 4b ff fd a9 bl ffc07348 <rtems_termios_refill_transmitter>
}
ffc075a4: 4b ff ff a4 b ffc07548 <rtems_termios_txdaemon+0x1c>
ffc06b8c <rtems_termios_write>:
rtems_termios_puts (&c, 1, tty);
}
rtems_status_code
rtems_termios_write (void *arg)
{
ffc06b8c: 94 21 ff e0 stwu r1,-32(r1)
ffc06b90: 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);
ffc06b94: 38 80 00 00 li r4,0
rtems_termios_puts (&c, 1, tty);
}
rtems_status_code
rtems_termios_write (void *arg)
{
ffc06b98: 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);
ffc06b9c: 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;
ffc06ba0: 81 23 00 00 lwz r9,0(r3)
rtems_termios_puts (&c, 1, tty);
}
rtems_status_code
rtems_termios_write (void *arg)
{
ffc06ba4: bf 41 00 08 stmw r26,8(r1)
ffc06ba8: 7c 7e 1b 78 mr r30,r3
rtems_libio_rw_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
ffc06bac: 83 e9 00 38 lwz r31,56(r9)
rtems_status_code sc;
sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
ffc06bb0: 80 7f 00 18 lwz r3,24(r31)
ffc06bb4: 48 00 14 f1 bl ffc080a4 <rtems_semaphore_obtain>
if (sc != RTEMS_SUCCESSFUL)
ffc06bb8: 7c 7d 1b 79 mr. r29,r3
ffc06bbc: 40 82 00 94 bne- ffc06c50 <rtems_termios_write+0xc4> <== NEVER TAKEN
return sc;
if (rtems_termios_linesw[tty->t_line].l_write != NULL) {
ffc06bc0: 80 1f 00 cc lwz r0,204(r31)
ffc06bc4: 3d 20 00 00 lis r9,0
ffc06bc8: 39 29 28 f0 addi r9,r9,10480
ffc06bcc: 54 00 28 34 rlwinm r0,r0,5,0,26
ffc06bd0: 7d 29 02 14 add r9,r9,r0
ffc06bd4: 80 09 00 0c lwz r0,12(r9)
ffc06bd8: 2f 80 00 00 cmpwi cr7,r0,0
ffc06bdc: 41 9e 00 1c beq- cr7,ffc06bf8 <rtems_termios_write+0x6c>
sc = rtems_termios_linesw[tty->t_line].l_write(tty,args);
ffc06be0: 7f e3 fb 78 mr r3,r31
ffc06be4: 7c 09 03 a6 mtctr r0
ffc06be8: 7f c4 f3 78 mr r4,r30
ffc06bec: 4e 80 04 21 bctrl
ffc06bf0: 7c 7d 1b 78 mr r29,r3
ffc06bf4: 48 00 00 54 b ffc06c48 <rtems_termios_write+0xbc>
rtems_semaphore_release (tty->osem);
return sc;
}
if (tty->termios.c_oflag & OPOST) {
ffc06bf8: 80 1f 00 34 lwz r0,52(r31)
uint32_t count = args->count;
char *buffer = args->buffer;
while (count--)
ffc06bfc: 3b 80 00 00 li r28,0
ffc06c00: 83 7e 00 14 lwz r27,20(r30)
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) {
ffc06c04: 70 09 00 01 andi. r9,r0,1
ffc06c08: 83 5e 00 10 lwz r26,16(r30)
ffc06c0c: 40 a2 00 18 bne+ ffc06c24 <rtems_termios_write+0x98> <== ALWAYS TAKEN
ffc06c10: 48 00 00 20 b ffc06c30 <rtems_termios_write+0xa4> <== NOT EXECUTED
uint32_t count = args->count;
char *buffer = args->buffer;
while (count--)
oproc (*buffer++, tty);
ffc06c14: 7c 7a e0 ae lbzx r3,r26,r28
ffc06c18: 7f e4 fb 78 mr r4,r31
ffc06c1c: 3b 9c 00 01 addi r28,r28,1
ffc06c20: 4b ff f9 4d bl ffc0656c <oproc>
return sc;
}
if (tty->termios.c_oflag & OPOST) {
uint32_t count = args->count;
char *buffer = args->buffer;
while (count--)
ffc06c24: 7f 9c d8 00 cmpw cr7,r28,r27
ffc06c28: 40 9e ff ec bne+ cr7,ffc06c14 <rtems_termios_write+0x88>
ffc06c2c: 48 00 00 14 b ffc06c40 <rtems_termios_write+0xb4>
oproc (*buffer++, tty);
args->bytes_moved = args->count;
} else {
rtems_termios_puts (args->buffer, args->count, tty);
ffc06c30: 7f 43 d3 78 mr r3,r26 <== NOT EXECUTED
ffc06c34: 7f 64 db 78 mr r4,r27 <== NOT EXECUTED
ffc06c38: 7f e5 fb 78 mr r5,r31 <== NOT EXECUTED
ffc06c3c: 4b ff f8 11 bl ffc0644c <rtems_termios_puts> <== NOT EXECUTED
args->bytes_moved = args->count;
ffc06c40: 80 1e 00 14 lwz r0,20(r30)
ffc06c44: 90 1e 00 1c stw r0,28(r30)
}
rtems_semaphore_release (tty->osem);
ffc06c48: 80 7f 00 18 lwz r3,24(r31)
ffc06c4c: 48 00 15 85 bl ffc081d0 <rtems_semaphore_release>
return sc;
}
ffc06c50: 39 61 00 20 addi r11,r1,32
ffc06c54: 7f a3 eb 78 mr r3,r29
ffc06c58: 4b ff 98 d8 b ffc00530 <_restgpr_26_x>
ffc18768 <rtems_timer_cancel>:
*/
rtems_status_code rtems_timer_cancel(
rtems_id id
)
{
ffc18768: 94 21 ff e8 stwu r1,-24(r1)
ffc1876c: 7c 08 02 a6 mflr r0
ffc18770: 7c 64 1b 78 mr r4,r3
RTEMS_INLINE_ROUTINE Timer_Control *_Timer_Get (
Objects_Id id,
Objects_Locations *location
)
{
return (Timer_Control *)
ffc18774: 3c 60 00 00 lis r3,0
ffc18778: 90 01 00 1c stw r0,28(r1)
ffc1877c: 38 63 79 9c addi r3,r3,31132
ffc18780: 38 a1 00 08 addi r5,r1,8
ffc18784: 48 00 32 d5 bl ffc1ba58 <_Objects_Get>
Timer_Control *the_timer;
Objects_Locations location;
the_timer = _Timer_Get( id, &location );
switch ( location ) {
ffc18788: 80 01 00 08 lwz r0,8(r1)
ffc1878c: 2f 80 00 00 cmpwi cr7,r0,0
ffc18790: 40 9e 00 24 bne- cr7,ffc187b4 <rtems_timer_cancel+0x4c>
case OBJECTS_LOCAL:
if ( !_Timer_Is_dormant_class( the_timer->the_class ) )
ffc18794: 80 03 00 38 lwz r0,56(r3)
ffc18798: 2f 80 00 04 cmpwi cr7,r0,4
ffc1879c: 41 9e 00 0c beq- cr7,ffc187a8 <rtems_timer_cancel+0x40> <== NEVER TAKEN
(void) _Watchdog_Remove( &the_timer->Ticker );
ffc187a0: 38 63 00 10 addi r3,r3,16
ffc187a4: 48 00 55 39 bl ffc1dcdc <_Watchdog_Remove>
_Thread_Enable_dispatch();
ffc187a8: 48 00 41 7d bl ffc1c924 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
ffc187ac: 38 60 00 00 li r3,0
ffc187b0: 48 00 00 08 b ffc187b8 <rtems_timer_cancel+0x50>
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
ffc187b4: 38 60 00 04 li r3,4
}
ffc187b8: 80 01 00 1c lwz r0,28(r1)
ffc187bc: 38 21 00 18 addi r1,r1,24
ffc187c0: 7c 08 03 a6 mtlr r0
ffc187c4: 4e 80 00 20 blr
ffc18cec <rtems_timer_server_fire_when>:
rtems_id id,
rtems_time_of_day *wall_time,
rtems_timer_service_routine_entry routine,
void *user_data
)
{
ffc18cec: 94 21 ff c8 stwu r1,-56(r1)
Timer_Control *the_timer;
Objects_Locations location;
rtems_interval seconds;
Timer_server_Control *timer_server = _Timer_server;
ffc18cf0: 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
)
{
ffc18cf4: 7c 08 02 a6 mflr r0
ffc18cf8: bf 01 00 18 stmw r24,24(r1)
ffc18cfc: 7c 7f 1b 78 mr r31,r3
ffc18d00: 7c 9c 23 78 mr r28,r4
Timer_Control *the_timer;
Objects_Locations location;
rtems_interval seconds;
Timer_server_Control *timer_server = _Timer_server;
ffc18d04: 83 a9 29 34 lwz r29,10548(r9)
rtems_id id,
rtems_time_of_day *wall_time,
rtems_timer_service_routine_entry routine,
void *user_data
)
{
ffc18d08: 7c be 2b 78 mr r30,r5
ffc18d0c: 90 01 00 3c stw r0,60(r1)
ffc18d10: 7c da 33 78 mr r26,r6
Timer_Control *the_timer;
Objects_Locations location;
rtems_interval seconds;
Timer_server_Control *timer_server = _Timer_server;
if ( !timer_server )
ffc18d14: 2f 9d 00 00 cmpwi cr7,r29,0
return RTEMS_INCORRECT_STATE;
ffc18d18: 3b 20 00 0e li r25,14
Timer_Control *the_timer;
Objects_Locations location;
rtems_interval seconds;
Timer_server_Control *timer_server = _Timer_server;
if ( !timer_server )
ffc18d1c: 41 9e 00 c8 beq- cr7,ffc18de4 <rtems_timer_server_fire_when+0xf8>
return RTEMS_INCORRECT_STATE;
if ( !_TOD_Is_set )
ffc18d20: 3d 20 00 00 lis r9,0
ffc18d24: 88 09 28 e4 lbz r0,10468(r9)
return RTEMS_NOT_DEFINED;
ffc18d28: 3b 20 00 0b li r25,11
Timer_server_Control *timer_server = _Timer_server;
if ( !timer_server )
return RTEMS_INCORRECT_STATE;
if ( !_TOD_Is_set )
ffc18d2c: 2f 80 00 00 cmpwi cr7,r0,0
ffc18d30: 41 be 00 b4 beq+ cr7,ffc18de4 <rtems_timer_server_fire_when+0xf8><== NEVER TAKEN
return RTEMS_NOT_DEFINED;
if ( !routine )
ffc18d34: 2f 85 00 00 cmpwi cr7,r5,0
return RTEMS_INVALID_ADDRESS;
ffc18d38: 3b 20 00 09 li r25,9
return RTEMS_INCORRECT_STATE;
if ( !_TOD_Is_set )
return RTEMS_NOT_DEFINED;
if ( !routine )
ffc18d3c: 41 9e 00 a8 beq- cr7,ffc18de4 <rtems_timer_server_fire_when+0xf8>
return RTEMS_INVALID_ADDRESS;
if ( !_TOD_Validate( wall_time ) )
ffc18d40: 7c 83 23 78 mr r3,r4
ffc18d44: 4b ff cc 29 bl ffc1596c <_TOD_Validate>
return RTEMS_INVALID_CLOCK;
ffc18d48: 3b 20 00 14 li r25,20
return RTEMS_NOT_DEFINED;
if ( !routine )
return RTEMS_INVALID_ADDRESS;
if ( !_TOD_Validate( wall_time ) )
ffc18d4c: 2f 83 00 00 cmpwi cr7,r3,0
ffc18d50: 41 be 00 94 beq+ cr7,ffc18de4 <rtems_timer_server_fire_when+0xf8>
return RTEMS_INVALID_CLOCK;
seconds = _TOD_To_seconds( wall_time );
ffc18d54: 7f 83 e3 78 mr r3,r28
if ( seconds <= _TOD_Seconds_since_epoch() )
ffc18d58: 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 );
ffc18d5c: 4b ff cb 85 bl ffc158e0 <_TOD_To_seconds>
if ( seconds <= _TOD_Seconds_since_epoch() )
ffc18d60: 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 );
ffc18d64: 7c 7c 1b 78 mr r28,r3
if ( seconds <= _TOD_Seconds_since_epoch() )
ffc18d68: 7f 83 00 40 cmplw cr7,r3,r0
ffc18d6c: 40 bd 00 78 ble+ cr7,ffc18de4 <rtems_timer_server_fire_when+0xf8>
ffc18d70: 3c 60 00 00 lis r3,0
ffc18d74: 38 63 79 9c addi r3,r3,31132
ffc18d78: 7f e4 fb 78 mr r4,r31
ffc18d7c: 38 a1 00 08 addi r5,r1,8
ffc18d80: 48 00 2c d9 bl ffc1ba58 <_Objects_Get>
return RTEMS_INVALID_CLOCK;
the_timer = _Timer_Get( id, &location );
switch ( location ) {
ffc18d84: 83 01 00 08 lwz r24,8(r1)
ffc18d88: 7c 79 1b 78 mr r25,r3
ffc18d8c: 2f 98 00 00 cmpwi cr7,r24,0
ffc18d90: 40 9e 00 50 bne- cr7,ffc18de0 <rtems_timer_server_fire_when+0xf4>
case OBJECTS_LOCAL:
(void) _Watchdog_Remove( &the_timer->Ticker );
ffc18d94: 38 63 00 10 addi r3,r3,16
ffc18d98: 48 00 4f 45 bl ffc1dcdc <_Watchdog_Remove>
the_timer->the_class = TIMER_TIME_OF_DAY_ON_TASK;
ffc18d9c: 38 00 00 03 li r0,3
ffc18da0: 90 19 00 38 stw r0,56(r25)
_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 );
ffc18da4: 7f 24 cb 78 mr r4,r25
ffc18da8: 7f a3 eb 78 mr r3,r29
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();
ffc18dac: 80 1b 28 f8 lwz r0,10488(r27)
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
ffc18db0: 93 19 00 18 stw r24,24(r25)
ffc18db4: 7f 80 e0 50 subf r28,r0,r28
(*timer_server->schedule_operation)( timer_server, the_timer );
ffc18db8: 80 1d 00 04 lwz r0,4(r29)
the_watchdog->routine = routine;
ffc18dbc: 93 d9 00 2c stw r30,44(r25)
ffc18dc0: 7c 09 03 a6 mtctr r0
the_watchdog->id = id;
ffc18dc4: 93 f9 00 30 stw r31,48(r25)
the_watchdog->user_data = user_data;
ffc18dc8: 93 59 00 34 stw r26,52(r25)
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();
ffc18dcc: 93 99 00 1c stw r28,28(r25)
(*timer_server->schedule_operation)( timer_server, the_timer );
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
ffc18dd0: 3b 20 00 00 li r25,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 );
ffc18dd4: 4e 80 04 21 bctrl
_Thread_Enable_dispatch();
ffc18dd8: 48 00 3b 4d bl ffc1c924 <_Thread_Enable_dispatch>
return RTEMS_SUCCESSFUL;
ffc18ddc: 48 00 00 08 b ffc18de4 <rtems_timer_server_fire_when+0xf8>
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
ffc18de0: 3b 20 00 04 li r25,4
}
ffc18de4: 39 61 00 38 addi r11,r1,56
ffc18de8: 7f 23 cb 78 mr r3,r25
ffc18dec: 4b ff 53 98 b ffc0e184 <_restgpr_24_x>
ffc044cc <rtems_verror>:
static int rtems_verror(
rtems_error_code_t error_flag,
const char *printf_format,
va_list arglist
)
{
ffc044cc: 94 21 ff e0 stwu r1,-32(r1)
ffc044d0: 7c 08 02 a6 mflr r0
ffc044d4: 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) {
ffc044d8: 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
)
{
ffc044dc: bf 41 00 08 stmw r26,8(r1)
ffc044e0: 7c 7d 1b 78 mr r29,r3
ffc044e4: 7c 9a 23 78 mr r26,r4
ffc044e8: 7c bb 2b 78 mr r27,r5
int local_errno = 0;
int chars_written = 0;
rtems_status_code status;
if (error_flag & RTEMS_ERROR_PANIC) {
ffc044ec: 41 82 00 44 beq- ffc04530 <rtems_verror+0x64>
if (rtems_panic_in_progress++)
ffc044f0: 3d 60 00 00 lis r11,0
ffc044f4: 81 2b 27 ec lwz r9,10220(r11)
ffc044f8: 2f 89 00 00 cmpwi cr7,r9,0
ffc044fc: 38 09 00 01 addi r0,r9,1
ffc04500: 90 0b 27 ec stw r0,10220(r11)
ffc04504: 41 9e 00 18 beq- cr7,ffc0451c <rtems_verror+0x50> <== ALWAYS TAKEN
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
_Thread_Dispatch_disable_level++;
ffc04508: 3d 20 00 00 lis r9,0 <== NOT EXECUTED
ffc0450c: 81 69 28 0c lwz r11,10252(r9) <== NOT EXECUTED
ffc04510: 38 0b 00 01 addi r0,r11,1 <== NOT EXECUTED
ffc04514: 90 09 28 0c stw r0,10252(r9) <== NOT EXECUTED
return _Thread_Dispatch_disable_level;
ffc04518: 80 09 28 0c lwz r0,10252(r9) <== NOT EXECUTED
_Thread_Disable_dispatch(); /* disable task switches */
/* don't aggravate things */
if (rtems_panic_in_progress > 2)
ffc0451c: 3d 20 00 00 lis r9,0
ffc04520: 80 09 27 ec lwz r0,10220(r9)
return 0;
ffc04524: 3b e0 00 00 li r31,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)
ffc04528: 2f 80 00 02 cmpwi cr7,r0,2
ffc0452c: 41 9d 01 14 bgt- cr7,ffc04640 <rtems_verror+0x174> <== NEVER TAKEN
return 0;
}
(void) fflush(stdout); /* in case stdout/stderr same */
ffc04530: 3f e0 00 00 lis r31,0
ffc04534: 81 3f 27 8c lwz r9,10124(r31)
status = error_flag & ~RTEMS_ERROR_MASK;
ffc04538: 57 bc 01 00 rlwinm r28,r29,0,4,0
rtems_error_code_t error_flag,
const char *printf_format,
va_list arglist
)
{
int local_errno = 0;
ffc0453c: 3b c0 00 00 li r30,0
/* don't aggravate things */
if (rtems_panic_in_progress > 2)
return 0;
}
(void) fflush(stdout); /* in case stdout/stderr same */
ffc04540: 80 69 00 08 lwz r3,8(r9)
ffc04544: 48 00 cb 45 bl ffc11088 <fflush>
status = error_flag & ~RTEMS_ERROR_MASK;
if (error_flag & RTEMS_ERROR_ERRNO) /* include errno? */
ffc04548: 77 a0 40 00 andis. r0,r29,16384
ffc0454c: 41 a2 00 0c beq+ ffc04558 <rtems_verror+0x8c>
local_errno = errno;
ffc04550: 48 00 c6 65 bl ffc10bb4 <__errno>
ffc04554: 83 c3 00 00 lwz r30,0(r3)
#if defined(RTEMS_MULTIPROCESSING)
if (_System_state_Is_multiprocessing)
fprintf(stderr, "[%" PRIu32 "] ", _Configuration_MP_table->node);
#endif
chars_written += vfprintf(stderr, printf_format, arglist);
ffc04558: 81 3f 27 8c lwz r9,10124(r31)
ffc0455c: 7f 44 d3 78 mr r4,r26
ffc04560: 7f 65 db 78 mr r5,r27
ffc04564: 80 69 00 0c lwz r3,12(r9)
ffc04568: 48 01 22 31 bl ffc16798 <vfprintf>
if (status)
ffc0456c: 2f 9c 00 00 cmpwi cr7,r28,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);
ffc04570: 7c 7f 1b 78 mr r31,r3
if (status)
ffc04574: 41 be 00 34 beq+ cr7,ffc045a8 <rtems_verror+0xdc>
chars_written +=
fprintf(stderr, " (status: %s)", rtems_status_text(status));
ffc04578: 3d 20 00 00 lis r9,0
ffc0457c: 81 29 27 8c lwz r9,10124(r9)
ffc04580: 7f 83 e3 78 mr r3,r28
ffc04584: 83 a9 00 0c lwz r29,12(r9)
ffc04588: 4b ff ff 19 bl ffc044a0 <rtems_status_text>
ffc0458c: 3c 80 ff c2 lis r4,-62
ffc04590: 7c 65 1b 78 mr r5,r3
ffc04594: 38 84 d4 98 addi r4,r4,-11112
ffc04598: 7f a3 eb 78 mr r3,r29
ffc0459c: 4c c6 31 82 crclr 4*cr1+eq
ffc045a0: 48 00 d0 a1 bl ffc11640 <fprintf>
#endif
chars_written += vfprintf(stderr, printf_format, arglist);
if (status)
chars_written +=
ffc045a4: 7f ff 1a 14 add r31,r31,r3
fprintf(stderr, " (status: %s)", rtems_status_text(status));
if (local_errno) {
ffc045a8: 2f 9e 00 00 cmpwi cr7,r30,0
ffc045ac: 41 9e 00 68 beq- cr7,ffc04614 <rtems_verror+0x148>
if ((local_errno > 0) && *strerror(local_errno))
ffc045b0: 40 9d 00 40 ble- cr7,ffc045f0 <rtems_verror+0x124>
ffc045b4: 7f c3 f3 78 mr r3,r30
ffc045b8: 48 00 df 11 bl ffc124c8 <strerror>
ffc045bc: 88 03 00 00 lbz r0,0(r3)
ffc045c0: 2f 80 00 00 cmpwi cr7,r0,0
ffc045c4: 41 be 00 2c beq+ cr7,ffc045f0 <rtems_verror+0x124> <== NEVER TAKEN
chars_written += fprintf(stderr, " (errno: %s)", strerror(local_errno));
ffc045c8: 3d 20 00 00 lis r9,0
ffc045cc: 81 29 27 8c lwz r9,10124(r9)
ffc045d0: 7f c3 f3 78 mr r3,r30
ffc045d4: 83 a9 00 0c lwz r29,12(r9)
ffc045d8: 48 00 de f1 bl ffc124c8 <strerror>
ffc045dc: 3c 80 ff c2 lis r4,-62
ffc045e0: 7c 65 1b 78 mr r5,r3
ffc045e4: 38 84 d4 a6 addi r4,r4,-11098
ffc045e8: 7f a3 eb 78 mr r3,r29
ffc045ec: 48 00 00 1c b ffc04608 <rtems_verror+0x13c>
else
chars_written += fprintf(stderr, " (unknown errno=%d)", local_errno);
ffc045f0: 3d 20 00 00 lis r9,0
ffc045f4: 81 29 27 8c lwz r9,10124(r9)
ffc045f8: 3c 80 ff c2 lis r4,-62
ffc045fc: 38 84 d4 b3 addi r4,r4,-11085
ffc04600: 80 69 00 0c lwz r3,12(r9)
ffc04604: 7f c5 f3 78 mr r5,r30
ffc04608: 4c c6 31 82 crclr 4*cr1+eq
ffc0460c: 48 00 d0 35 bl ffc11640 <fprintf>
ffc04610: 7f ff 1a 14 add r31,r31,r3
}
chars_written += fprintf(stderr, "\n");
ffc04614: 3f c0 00 00 lis r30,0
ffc04618: 81 3e 27 8c lwz r9,10124(r30)
ffc0461c: 3c 80 ff c2 lis r4,-62
ffc04620: 38 84 d7 da addi r4,r4,-10278
ffc04624: 80 69 00 0c lwz r3,12(r9)
ffc04628: 4c c6 31 82 crclr 4*cr1+eq
ffc0462c: 48 00 d0 15 bl ffc11640 <fprintf>
(void) fflush(stderr);
ffc04630: 81 3e 27 8c lwz r9,10124(r30)
chars_written += fprintf(stderr, " (errno: %s)", strerror(local_errno));
else
chars_written += fprintf(stderr, " (unknown errno=%d)", local_errno);
}
chars_written += fprintf(stderr, "\n");
ffc04634: 7f ff 1a 14 add r31,r31,r3
(void) fflush(stderr);
ffc04638: 80 69 00 0c lwz r3,12(r9)
ffc0463c: 48 00 ca 4d bl ffc11088 <fflush>
return chars_written;
}
ffc04640: 39 61 00 20 addi r11,r1,32
ffc04644: 7f e3 fb 78 mr r3,r31
ffc04648: 4b ff be e8 b ffc00530 <_restgpr_26_x>
ffc04b90 <scanInt>:
/*
* Extract an integer value from the database
*/
static int
scanInt(FILE *fp, int *val)
{
ffc04b90: 94 21 ff d8 stwu r1,-40(r1)
ffc04b94: 7c 08 02 a6 mflr r0
ffc04b98: bf 01 00 08 stmw r24,8(r1)
int c;
unsigned int i = 0;
unsigned int limit = INT_MAX;
ffc04b9c: 3f 80 7f ff lis r28,32767
/*
* Extract an integer value from the database
*/
static int
scanInt(FILE *fp, int *val)
{
ffc04ba0: 7c 7e 1b 78 mr r30,r3
ffc04ba4: 90 01 00 2c stw r0,44(r1)
ffc04ba8: 7c 9b 23 78 mr r27,r4
int c;
unsigned int i = 0;
unsigned int limit = INT_MAX;
int sign = 0;
ffc04bac: 3b a0 00 00 li r29,0
static int
scanInt(FILE *fp, int *val)
{
int c;
unsigned int i = 0;
unsigned int limit = INT_MAX;
ffc04bb0: 63 9c ff ff ori r28,r28,65535
*/
static int
scanInt(FILE *fp, int *val)
{
int c;
unsigned int i = 0;
ffc04bb4: 3b e0 00 00 li r31,0
unsigned int limit = INT_MAX;
int sign = 0;
int d;
for (;;) {
c = getc(fp);
ffc04bb8: 3f 00 00 00 lis r24,0
limit++;
continue;
}
sign = 1;
}
if (!isdigit(c))
ffc04bbc: 3f 20 00 00 lis r25,0
return 0;
d = c - '0';
if ((i > (limit / 10))
ffc04bc0: 3b 40 00 0a li r26,10
unsigned int limit = INT_MAX;
int sign = 0;
int d;
for (;;) {
c = getc(fp);
ffc04bc4: 81 3e 00 04 lwz r9,4(r30)
ffc04bc8: 38 09 ff ff addi r0,r9,-1
ffc04bcc: 2f 80 00 00 cmpwi cr7,r0,0
ffc04bd0: 90 1e 00 04 stw r0,4(r30)
ffc04bd4: 40 bc 00 14 bge+ cr7,ffc04be8 <scanInt+0x58> <== ALWAYS TAKEN
ffc04bd8: 80 78 27 6c lwz r3,10092(r24) <== NOT EXECUTED
ffc04bdc: 7f c4 f3 78 mr r4,r30 <== NOT EXECUTED
ffc04be0: 48 00 ed 1d bl ffc138fc <__srget_r> <== NOT EXECUTED
ffc04be4: 48 00 00 14 b ffc04bf8 <scanInt+0x68> <== NOT EXECUTED
ffc04be8: 81 3e 00 00 lwz r9,0(r30)
ffc04bec: 88 69 00 00 lbz r3,0(r9)
ffc04bf0: 39 29 00 01 addi r9,r9,1
ffc04bf4: 91 3e 00 00 stw r9,0(r30)
if (c == ':')
ffc04bf8: 2f 03 00 3a cmpwi cr6,r3,58
ffc04bfc: 2f 9d 00 00 cmpwi cr7,r29,0
ffc04c00: 41 9a 00 68 beq- cr6,ffc04c68 <scanInt+0xd8>
break;
if (sign == 0) {
ffc04c04: 40 9e 00 1c bne- cr7,ffc04c20 <scanInt+0x90>
if (c == '-') {
ffc04c08: 2f 83 00 2d cmpwi cr7,r3,45
sign = -1;
limit++;
continue;
}
sign = 1;
ffc04c0c: 3b a0 00 01 li r29,1
for (;;) {
c = getc(fp);
if (c == ':')
break;
if (sign == 0) {
if (c == '-') {
ffc04c10: 40 be 00 10 bne+ cr7,ffc04c20 <scanInt+0x90>
sign = -1;
limit++;
ffc04c14: 3b 9c 00 01 addi r28,r28,1
c = getc(fp);
if (c == ':')
break;
if (sign == 0) {
if (c == '-') {
sign = -1;
ffc04c18: 3b a0 ff ff li r29,-1
limit++;
continue;
ffc04c1c: 4b ff ff a8 b ffc04bc4 <scanInt+0x34>
}
sign = 1;
}
if (!isdigit(c))
ffc04c20: 81 39 27 64 lwz r9,10084(r25)
ffc04c24: 7d 29 1a 14 add r9,r9,r3
ffc04c28: 88 09 00 01 lbz r0,1(r9)
ffc04c2c: 70 09 00 04 andi. r9,r0,4
ffc04c30: 41 82 00 4c beq- ffc04c7c <scanInt+0xec>
return 0;
d = c - '0';
if ((i > (limit / 10))
ffc04c34: 7c 1c d3 96 divwu r0,r28,r26
ffc04c38: 7f 9f 00 40 cmplw cr7,r31,r0
ffc04c3c: 41 9d 00 40 bgt- cr7,ffc04c7c <scanInt+0xec>
|| ((i == (limit / 10)) && (d > (limit % 10))))
ffc04c40: 7f 9f 00 00 cmpw cr7,r31,r0
}
sign = 1;
}
if (!isdigit(c))
return 0;
d = c - '0';
ffc04c44: 38 63 ff d0 addi r3,r3,-48
if ((i > (limit / 10))
|| ((i == (limit / 10)) && (d > (limit % 10))))
ffc04c48: 40 be 00 14 bne+ cr7,ffc04c5c <scanInt+0xcc>
ffc04c4c: 1c 1f 00 0a mulli r0,r31,10
ffc04c50: 7c 00 e0 50 subf r0,r0,r28
ffc04c54: 7f 83 00 40 cmplw cr7,r3,r0
ffc04c58: 41 9d 00 24 bgt- cr7,ffc04c7c <scanInt+0xec> <== ALWAYS TAKEN
return 0;
i = i * 10 + d;
ffc04c5c: 1f ff 00 0a mulli r31,r31,10
ffc04c60: 7f e3 fa 14 add r31,r3,r31
ffc04c64: 4b ff ff 60 b ffc04bc4 <scanInt+0x34>
}
if (sign == 0)
ffc04c68: 41 9e 00 14 beq- cr7,ffc04c7c <scanInt+0xec> <== NEVER TAKEN
return 0;
*val = i * sign;
ffc04c6c: 7f fd f9 d6 mullw r31,r29,r31
return 1;
ffc04c70: 38 60 00 01 li r3,1
return 0;
i = i * 10 + d;
}
if (sign == 0)
return 0;
*val = i * sign;
ffc04c74: 93 fb 00 00 stw r31,0(r27)
return 1;
ffc04c78: 48 00 00 08 b ffc04c80 <scanInt+0xf0>
|| ((i == (limit / 10)) && (d > (limit % 10))))
return 0;
i = i * 10 + d;
}
if (sign == 0)
return 0;
ffc04c7c: 38 60 00 00 li r3,0
*val = i * sign;
return 1;
}
ffc04c80: 39 61 00 28 addi r11,r1,40
ffc04c84: 4b ff bc 20 b ffc008a4 <_restgpr_24_x>
ffc04d88 <scangr>:
FILE *fp,
struct group *grp,
char *buffer,
size_t bufsize
)
{
ffc04d88: 94 21 ff d0 stwu r1,-48(r1)
ffc04d8c: 7c 08 02 a6 mflr r0
int grgid;
char *grmem, *cp;
int memcount;
if (!scanString(fp, &grp->gr_name, &buffer, &bufsize, 0)
ffc04d90: 38 e0 00 00 li r7,0
FILE *fp,
struct group *grp,
char *buffer,
size_t bufsize
)
{
ffc04d94: 90 a1 00 18 stw r5,24(r1)
int grgid;
char *grmem, *cp;
int memcount;
if (!scanString(fp, &grp->gr_name, &buffer, &bufsize, 0)
ffc04d98: 38 a1 00 18 addi r5,r1,24
FILE *fp,
struct group *grp,
char *buffer,
size_t bufsize
)
{
ffc04d9c: 90 c1 00 1c stw r6,28(r1)
int grgid;
char *grmem, *cp;
int memcount;
if (!scanString(fp, &grp->gr_name, &buffer, &bufsize, 0)
ffc04da0: 38 c1 00 1c addi r6,r1,28
FILE *fp,
struct group *grp,
char *buffer,
size_t bufsize
)
{
ffc04da4: bf a1 00 24 stmw r29,36(r1)
ffc04da8: 7c 7d 1b 78 mr r29,r3
ffc04dac: 7c 9f 23 78 mr r31,r4
ffc04db0: 90 01 00 34 stw r0,52(r1)
int grgid;
char *grmem, *cp;
int memcount;
if (!scanString(fp, &grp->gr_name, &buffer, &bufsize, 0)
ffc04db4: 4b ff fe d5 bl ffc04c88 <scanString>
ffc04db8: 2f 83 00 00 cmpwi cr7,r3,0
|| !scanString(fp, &grp->gr_passwd, &buffer, &bufsize, 0)
|| !scanInt(fp, &grgid)
|| !scanString(fp, &grmem, &buffer, &bufsize, 1))
return 0;
ffc04dbc: 3b c0 00 00 li r30,0
{
int grgid;
char *grmem, *cp;
int memcount;
if (!scanString(fp, &grp->gr_name, &buffer, &bufsize, 0)
ffc04dc0: 41 be 01 08 beq+ cr7,ffc04ec8 <scangr+0x140>
|| !scanString(fp, &grp->gr_passwd, &buffer, &bufsize, 0)
ffc04dc4: 7f a3 eb 78 mr r3,r29
ffc04dc8: 38 9f 00 04 addi r4,r31,4
ffc04dcc: 38 a1 00 18 addi r5,r1,24
ffc04dd0: 38 c1 00 1c addi r6,r1,28
ffc04dd4: 38 e0 00 00 li r7,0
ffc04dd8: 4b ff fe b1 bl ffc04c88 <scanString>
ffc04ddc: 2f 83 00 00 cmpwi cr7,r3,0
ffc04de0: 41 be 00 e8 beq+ cr7,ffc04ec8 <scangr+0x140> <== NEVER TAKEN
|| !scanInt(fp, &grgid)
ffc04de4: 7f a3 eb 78 mr r3,r29
ffc04de8: 38 81 00 0c addi r4,r1,12
ffc04dec: 4b ff fd a5 bl ffc04b90 <scanInt>
ffc04df0: 2f 83 00 00 cmpwi cr7,r3,0
ffc04df4: 41 be 00 d4 beq+ cr7,ffc04ec8 <scangr+0x140> <== NEVER TAKEN
|| !scanString(fp, &grmem, &buffer, &bufsize, 1))
ffc04df8: 7f a3 eb 78 mr r3,r29
ffc04dfc: 38 81 00 08 addi r4,r1,8
ffc04e00: 38 a1 00 18 addi r5,r1,24
ffc04e04: 38 c1 00 1c addi r6,r1,28
ffc04e08: 38 e0 00 01 li r7,1
ffc04e0c: 4b ff fe 7d bl ffc04c88 <scanString>
ffc04e10: 2f 83 00 00 cmpwi cr7,r3,0
ffc04e14: 41 9e 00 b4 beq- cr7,ffc04ec8 <scangr+0x140> <== NEVER TAKEN
return 0;
grp->gr_gid = grgid;
ffc04e18: 80 01 00 0c lwz r0,12(r1)
/*
* Determine number of members
*/
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
ffc04e1c: 81 61 00 08 lwz r11,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;
ffc04e20: b0 1f 00 08 sth r0,8(r31)
/*
* Determine number of members
*/
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
ffc04e24: 38 00 00 01 li r0,1
ffc04e28: 7d 69 5b 78 mr r9,r11
ffc04e2c: 48 00 00 18 b ffc04e44 <scangr+0xbc>
if(*cp == ',')
memcount++;
ffc04e30: 69 48 00 2c xori r8,r10,44
ffc04e34: 21 08 00 00 subfic r8,r8,0
ffc04e38: 7d 00 01 94 addze r8,r0
ffc04e3c: 7d 00 43 78 mr r0,r8
grp->gr_gid = grgid;
/*
* Determine number of members
*/
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
ffc04e40: 39 29 00 01 addi r9,r9,1
ffc04e44: 89 49 00 00 lbz r10,0(r9)
ffc04e48: 2f 8a 00 00 cmpwi cr7,r10,0
ffc04e4c: 40 9e ff e4 bne+ cr7,ffc04e30 <scangr+0xa8>
}
/*
* Hack to produce (hopefully) a suitably-aligned array of pointers
*/
if (bufsize < (((memcount+1)*sizeof(char *)) + 15))
ffc04e50: 54 09 10 3a rlwinm r9,r0,2,0,29
ffc04e54: 38 09 00 13 addi r0,r9,19
ffc04e58: 81 21 00 1c lwz r9,28(r1)
return 0;
ffc04e5c: 3b c0 00 00 li r30,0
}
/*
* Hack to produce (hopefully) a suitably-aligned array of pointers
*/
if (bufsize < (((memcount+1)*sizeof(char *)) + 15))
ffc04e60: 7f 89 00 40 cmplw cr7,r9,r0
ffc04e64: 41 9c 00 64 blt- cr7,ffc04ec8 <scangr+0x140> <== NEVER TAKEN
return 0;
grp->gr_mem = (char **)(((uintptr_t)buffer + 15) & ~15);
ffc04e68: 81 21 00 18 lwz r9,24(r1)
ffc04e6c: 39 29 00 0f addi r9,r9,15
ffc04e70: 55 29 00 36 rlwinm r9,r9,0,0,27
ffc04e74: 91 3f 00 0c stw r9,12(r31)
/*
* Fill in pointer array
*/
grp->gr_mem[0] = grmem;
ffc04e78: 91 69 00 00 stw r11,0(r9)
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
ffc04e7c: 39 60 00 01 li r11,1
ffc04e80: 81 21 00 08 lwz r9,8(r1)
ffc04e84: 48 00 00 28 b ffc04eac <scangr+0x124>
if(*cp == ',') {
ffc04e88: 2f 80 00 2c cmpwi cr7,r0,44
ffc04e8c: 40 be 00 1c bne+ cr7,ffc04ea8 <scangr+0x120>
*cp = '\0';
ffc04e90: 99 49 00 00 stb r10,0(r9)
grp->gr_mem[memcount++] = cp + 1;
ffc04e94: 55 60 10 3a rlwinm r0,r11,2,0,29
}
/*
* Extract a single group record from the database
*/
static int scangr(
ffc04e98: 38 e9 00 01 addi r7,r9,1
*/
grp->gr_mem[0] = grmem;
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
if(*cp == ',') {
*cp = '\0';
grp->gr_mem[memcount++] = cp + 1;
ffc04e9c: 81 1f 00 0c lwz r8,12(r31)
ffc04ea0: 39 6b 00 01 addi r11,r11,1
ffc04ea4: 7c e8 01 2e stwx r7,r8,r0
/*
* Fill in pointer array
*/
grp->gr_mem[0] = grmem;
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
ffc04ea8: 39 29 00 01 addi r9,r9,1
ffc04eac: 88 09 00 00 lbz r0,0(r9)
ffc04eb0: 2f 80 00 00 cmpwi cr7,r0,0
ffc04eb4: 40 9e ff d4 bne+ cr7,ffc04e88 <scangr+0x100>
if(*cp == ',') {
*cp = '\0';
grp->gr_mem[memcount++] = cp + 1;
}
}
grp->gr_mem[memcount] = NULL;
ffc04eb8: 81 3f 00 0c lwz r9,12(r31)
ffc04ebc: 55 6b 10 3a rlwinm r11,r11,2,0,29
return 1;
ffc04ec0: 3b c0 00 01 li r30,1
if(*cp == ',') {
*cp = '\0';
grp->gr_mem[memcount++] = cp + 1;
}
}
grp->gr_mem[memcount] = NULL;
ffc04ec4: 7c 09 59 2e stwx r0,r9,r11
return 1;
}
ffc04ec8: 39 61 00 30 addi r11,r1,48
ffc04ecc: 7f c3 f3 78 mr r3,r30
ffc04ed0: 4b ff b9 e8 b ffc008b8 <_restgpr_29_x>
ffc04ed4 <scanpw>:
FILE *fp,
struct passwd *pwd,
char *buffer,
size_t bufsize
)
{
ffc04ed4: 94 21 ff d0 stwu r1,-48(r1)
ffc04ed8: 7c 08 02 a6 mflr r0
int pwuid, pwgid;
if (!scanString(fp, &pwd->pw_name, &buffer, &bufsize, 0)
ffc04edc: 38 e0 00 00 li r7,0
FILE *fp,
struct passwd *pwd,
char *buffer,
size_t bufsize
)
{
ffc04ee0: 90 a1 00 18 stw r5,24(r1)
int pwuid, pwgid;
if (!scanString(fp, &pwd->pw_name, &buffer, &bufsize, 0)
ffc04ee4: 38 a1 00 18 addi r5,r1,24
FILE *fp,
struct passwd *pwd,
char *buffer,
size_t bufsize
)
{
ffc04ee8: 90 c1 00 1c stw r6,28(r1)
int pwuid, pwgid;
if (!scanString(fp, &pwd->pw_name, &buffer, &bufsize, 0)
ffc04eec: 38 c1 00 1c addi r6,r1,28
FILE *fp,
struct passwd *pwd,
char *buffer,
size_t bufsize
)
{
ffc04ef0: bf a1 00 24 stmw r29,36(r1)
ffc04ef4: 7c 7e 1b 78 mr r30,r3
ffc04ef8: 7c 9f 23 78 mr r31,r4
ffc04efc: 90 01 00 34 stw r0,52(r1)
int pwuid, pwgid;
if (!scanString(fp, &pwd->pw_name, &buffer, &bufsize, 0)
ffc04f00: 4b ff fd 89 bl ffc04c88 <scanString>
ffc04f04: 2f 83 00 00 cmpwi cr7,r3,0
|| !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;
ffc04f08: 3b a0 00 00 li r29,0
size_t bufsize
)
{
int pwuid, pwgid;
if (!scanString(fp, &pwd->pw_name, &buffer, &bufsize, 0)
ffc04f0c: 41 be 00 e0 beq+ cr7,ffc04fec <scanpw+0x118>
|| !scanString(fp, &pwd->pw_passwd, &buffer, &bufsize, 0)
ffc04f10: 7f c3 f3 78 mr r3,r30
ffc04f14: 38 9f 00 04 addi r4,r31,4
ffc04f18: 38 a1 00 18 addi r5,r1,24
ffc04f1c: 38 c1 00 1c addi r6,r1,28
ffc04f20: 38 e0 00 00 li r7,0
ffc04f24: 4b ff fd 65 bl ffc04c88 <scanString>
ffc04f28: 2f 83 00 00 cmpwi cr7,r3,0
ffc04f2c: 41 be 00 c0 beq+ cr7,ffc04fec <scanpw+0x118> <== NEVER TAKEN
|| !scanInt(fp, &pwuid)
ffc04f30: 7f c3 f3 78 mr r3,r30
ffc04f34: 38 81 00 0c addi r4,r1,12
ffc04f38: 4b ff fc 59 bl ffc04b90 <scanInt>
ffc04f3c: 2f 83 00 00 cmpwi cr7,r3,0
ffc04f40: 41 be 00 ac beq+ cr7,ffc04fec <scanpw+0x118>
|| !scanInt(fp, &pwgid)
ffc04f44: 7f c3 f3 78 mr r3,r30
ffc04f48: 38 81 00 08 addi r4,r1,8
ffc04f4c: 4b ff fc 45 bl ffc04b90 <scanInt>
ffc04f50: 2f 83 00 00 cmpwi cr7,r3,0
ffc04f54: 41 be 00 98 beq+ cr7,ffc04fec <scanpw+0x118>
|| !scanString(fp, &pwd->pw_comment, &buffer, &bufsize, 0)
ffc04f58: 7f c3 f3 78 mr r3,r30
ffc04f5c: 38 9f 00 0c addi r4,r31,12
ffc04f60: 38 a1 00 18 addi r5,r1,24
ffc04f64: 38 c1 00 1c addi r6,r1,28
ffc04f68: 38 e0 00 00 li r7,0
ffc04f6c: 4b ff fd 1d bl ffc04c88 <scanString>
ffc04f70: 2f 83 00 00 cmpwi cr7,r3,0
ffc04f74: 41 be 00 78 beq+ cr7,ffc04fec <scanpw+0x118> <== NEVER TAKEN
|| !scanString(fp, &pwd->pw_gecos, &buffer, &bufsize, 0)
ffc04f78: 7f c3 f3 78 mr r3,r30
ffc04f7c: 38 9f 00 10 addi r4,r31,16
ffc04f80: 38 a1 00 18 addi r5,r1,24
ffc04f84: 38 c1 00 1c addi r6,r1,28
ffc04f88: 38 e0 00 00 li r7,0
ffc04f8c: 4b ff fc fd bl ffc04c88 <scanString>
ffc04f90: 2f 83 00 00 cmpwi cr7,r3,0
ffc04f94: 41 be 00 58 beq+ cr7,ffc04fec <scanpw+0x118> <== NEVER TAKEN
|| !scanString(fp, &pwd->pw_dir, &buffer, &bufsize, 0)
ffc04f98: 7f c3 f3 78 mr r3,r30
ffc04f9c: 38 9f 00 14 addi r4,r31,20
ffc04fa0: 38 a1 00 18 addi r5,r1,24
ffc04fa4: 38 c1 00 1c addi r6,r1,28
ffc04fa8: 38 e0 00 00 li r7,0
ffc04fac: 4b ff fc dd bl ffc04c88 <scanString>
ffc04fb0: 2f 83 00 00 cmpwi cr7,r3,0
ffc04fb4: 41 be 00 38 beq+ cr7,ffc04fec <scanpw+0x118> <== NEVER TAKEN
|| !scanString(fp, &pwd->pw_shell, &buffer, &bufsize, 1))
ffc04fb8: 7f c3 f3 78 mr r3,r30
ffc04fbc: 38 9f 00 18 addi r4,r31,24
ffc04fc0: 38 a1 00 18 addi r5,r1,24
ffc04fc4: 38 c1 00 1c addi r6,r1,28
ffc04fc8: 38 e0 00 01 li r7,1
ffc04fcc: 4b ff fc bd bl ffc04c88 <scanString>
ffc04fd0: 2f 83 00 00 cmpwi cr7,r3,0
ffc04fd4: 41 9e 00 18 beq- cr7,ffc04fec <scanpw+0x118>
return 0;
pwd->pw_uid = pwuid;
ffc04fd8: 80 01 00 0c lwz r0,12(r1)
pwd->pw_gid = pwgid;
return 1;
ffc04fdc: 3b a0 00 01 li r29,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;
ffc04fe0: b0 1f 00 08 sth r0,8(r31)
pwd->pw_gid = pwgid;
ffc04fe4: 80 01 00 08 lwz r0,8(r1)
ffc04fe8: b0 1f 00 0a sth r0,10(r31)
return 1;
}
ffc04fec: 39 61 00 30 addi r11,r1,48
ffc04ff0: 7f a3 eb 78 mr r3,r29
ffc04ff4: 4b ff b8 c4 b ffc008b8 <_restgpr_29_x>
ffc0849c <sched_get_priority_max>:
int sched_get_priority_max(
int policy
)
{
switch ( policy ) {
ffc0849c: 2b 83 00 04 cmplwi cr7,r3,4
#include <rtems/posix/priority.h>
int sched_get_priority_max(
int policy
)
{
ffc084a0: 94 21 ff f8 stwu r1,-8(r1)
ffc084a4: 7c 08 02 a6 mflr r0
ffc084a8: 90 01 00 0c stw r0,12(r1)
switch ( policy ) {
ffc084ac: 41 9d 00 14 bgt- cr7,ffc084c0 <sched_get_priority_max+0x24>
ffc084b0: 38 00 00 01 li r0,1
ffc084b4: 7c 03 18 30 slw r3,r0,r3
ffc084b8: 70 60 00 17 andi. r0,r3,23
ffc084bc: 40 82 00 18 bne- ffc084d4 <sched_get_priority_max+0x38> <== ALWAYS TAKEN
case SCHED_RR:
case SCHED_SPORADIC:
break;
default:
rtems_set_errno_and_return_minus_one( EINVAL );
ffc084c0: 48 00 8f 69 bl ffc11428 <__errno>
ffc084c4: 38 00 00 16 li r0,22
ffc084c8: 90 03 00 00 stw r0,0(r3)
ffc084cc: 38 60 ff ff li r3,-1
ffc084d0: 48 00 00 10 b ffc084e0 <sched_get_priority_max+0x44>
}
return POSIX_SCHEDULER_MAXIMUM_PRIORITY;
ffc084d4: 3d 20 00 00 lis r9,0
ffc084d8: 88 69 27 24 lbz r3,10020(r9)
ffc084dc: 38 63 ff ff addi r3,r3,-1
}
ffc084e0: 80 01 00 0c lwz r0,12(r1)
ffc084e4: 38 21 00 08 addi r1,r1,8
ffc084e8: 7c 08 03 a6 mtlr r0
ffc084ec: 4e 80 00 20 blr
ffc084f0 <sched_get_priority_min>:
int sched_get_priority_min(
int policy
)
{
switch ( policy ) {
ffc084f0: 2b 83 00 04 cmplwi cr7,r3,4
#include <rtems/posix/priority.h>
int sched_get_priority_min(
int policy
)
{
ffc084f4: 94 21 ff f8 stwu r1,-8(r1)
ffc084f8: 7c 08 02 a6 mflr r0
ffc084fc: 90 01 00 0c stw r0,12(r1)
switch ( policy ) {
ffc08500: 41 9d 00 18 bgt- cr7,ffc08518 <sched_get_priority_min+0x28>
ffc08504: 38 00 00 01 li r0,1
ffc08508: 7c 00 18 30 slw r0,r0,r3
ffc0850c: 70 09 00 17 andi. r9,r0,23
default:
rtems_set_errno_and_return_minus_one( EINVAL );
}
return POSIX_SCHEDULER_MINIMUM_PRIORITY;
ffc08510: 38 60 00 01 li r3,1
int sched_get_priority_min(
int policy
)
{
switch ( policy ) {
ffc08514: 40 82 00 14 bne- ffc08528 <sched_get_priority_min+0x38> <== ALWAYS TAKEN
case SCHED_RR:
case SCHED_SPORADIC:
break;
default:
rtems_set_errno_and_return_minus_one( EINVAL );
ffc08518: 48 00 8f 11 bl ffc11428 <__errno>
ffc0851c: 38 00 00 16 li r0,22
ffc08520: 90 03 00 00 stw r0,0(r3)
ffc08524: 38 60 ff ff li r3,-1
}
return POSIX_SCHEDULER_MINIMUM_PRIORITY;
}
ffc08528: 80 01 00 0c lwz r0,12(r1)
ffc0852c: 38 21 00 08 addi r1,r1,8
ffc08530: 7c 08 03 a6 mtlr r0
ffc08534: 4e 80 00 20 blr
ffc08538 <sched_rr_get_interval>:
int sched_rr_get_interval(
pid_t pid,
struct timespec *interval
)
{
ffc08538: 7c 2b 0b 78 mr r11,r1
ffc0853c: 94 21 ff e8 stwu r1,-24(r1)
ffc08540: 7c 08 02 a6 mflr r0
ffc08544: 48 01 47 75 bl ffc1ccb8 <_savegpr_31>
/*
* Only supported for the "calling process" (i.e. this node).
*/
if ( pid && pid != getpid() )
ffc08548: 7c 7f 1b 79 mr. r31,r3
int sched_rr_get_interval(
pid_t pid,
struct timespec *interval
)
{
ffc0854c: 90 01 00 1c stw r0,28(r1)
/*
* Only supported for the "calling process" (i.e. this node).
*/
if ( pid && pid != getpid() )
ffc08550: 41 a2 00 24 beq+ ffc08574 <sched_rr_get_interval+0x3c> <== NEVER TAKEN
ffc08554: 90 81 00 08 stw r4,8(r1)
ffc08558: 4b ff c7 c9 bl ffc04d20 <getpid>
ffc0855c: 7f 9f 18 00 cmpw cr7,r31,r3
ffc08560: 80 81 00 08 lwz r4,8(r1)
ffc08564: 41 be 00 10 beq+ cr7,ffc08574 <sched_rr_get_interval+0x3c>
rtems_set_errno_and_return_minus_one( ESRCH );
ffc08568: 48 00 8e c1 bl ffc11428 <__errno>
ffc0856c: 38 00 00 03 li r0,3
ffc08570: 48 00 00 14 b ffc08584 <sched_rr_get_interval+0x4c>
if ( !interval )
ffc08574: 2f 84 00 00 cmpwi cr7,r4,0
ffc08578: 40 be 00 18 bne+ cr7,ffc08590 <sched_rr_get_interval+0x58>
rtems_set_errno_and_return_minus_one( EINVAL );
ffc0857c: 48 00 8e ad bl ffc11428 <__errno>
ffc08580: 38 00 00 16 li r0,22
ffc08584: 90 03 00 00 stw r0,0(r3)
ffc08588: 38 60 ff ff li r3,-1
ffc0858c: 48 00 00 14 b ffc085a0 <sched_rr_get_interval+0x68>
_Timespec_From_ticks( _Thread_Ticks_per_timeslice, interval );
ffc08590: 3d 20 00 00 lis r9,0
ffc08594: 80 69 28 0c lwz r3,10252(r9)
ffc08598: 48 00 3e 39 bl ffc0c3d0 <_Timespec_From_ticks>
return 0;
ffc0859c: 38 60 00 00 li r3,0
}
ffc085a0: 39 61 00 18 addi r11,r1,24
ffc085a4: 4b ff 85 c8 b ffc00b6c <_restgpr_31_x>
ffc0b06c <sem_open>:
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
_Thread_Dispatch_disable_level++;
ffc0b06c: 3d 20 00 00 lis r9,0
int oflag,
...
/* mode_t mode, */
/* unsigned int value */
)
{
ffc0b070: 94 21 ff b8 stwu r1,-72(r1)
ffc0b074: 7c 08 02 a6 mflr r0
ffc0b078: 81 69 28 08 lwz r11,10248(r9)
ffc0b07c: 90 01 00 4c stw r0,76(r1)
ffc0b080: 38 0b 00 01 addi r0,r11,1
ffc0b084: 90 09 28 08 stw r0,10248(r9)
ffc0b088: bf 61 00 34 stmw r27,52(r1)
ffc0b08c: 7c 7f 1b 78 mr r31,r3
ffc0b090: 7c 9e 23 78 mr r30,r4
ffc0b094: 90 a1 00 28 stw r5,40(r1)
ffc0b098: 90 c1 00 2c stw r6,44(r1)
return _Thread_Dispatch_disable_level;
ffc0b09c: 80 09 28 08 lwz r0,10248(r9)
POSIX_Semaphore_Control *the_semaphore;
Objects_Locations location;
_Thread_Disable_dispatch();
if ( oflag & O_CREAT ) {
ffc0b0a0: 70 9c 02 00 andi. r28,r4,512
/* unsigned int value */
)
{
va_list arg;
mode_t mode;
unsigned int value = 0;
ffc0b0a4: 3b a0 00 00 li r29,0
POSIX_Semaphore_Control *the_semaphore;
Objects_Locations location;
_Thread_Disable_dispatch();
if ( oflag & O_CREAT ) {
ffc0b0a8: 41 a2 00 20 beq+ ffc0b0c8 <sem_open+0x5c>
va_start(arg, oflag);
ffc0b0ac: 38 01 00 50 addi r0,r1,80
mode = (mode_t) va_arg( arg, unsigned int );
value = va_arg( arg, unsigned int );
ffc0b0b0: 83 a1 00 2c lwz r29,44(r1)
Objects_Locations location;
_Thread_Disable_dispatch();
if ( oflag & O_CREAT ) {
va_start(arg, oflag);
ffc0b0b4: 90 01 00 18 stw r0,24(r1)
ffc0b0b8: 39 21 00 20 addi r9,r1,32
mode = (mode_t) va_arg( arg, unsigned int );
value = va_arg( arg, unsigned int );
ffc0b0bc: 38 00 00 04 li r0,4
Objects_Locations location;
_Thread_Disable_dispatch();
if ( oflag & O_CREAT ) {
va_start(arg, oflag);
ffc0b0c0: 91 21 00 1c stw r9,28(r1)
mode = (mode_t) va_arg( arg, unsigned int );
value = va_arg( arg, unsigned int );
ffc0b0c4: 98 01 00 14 stb r0,20(r1)
va_end(arg);
}
status = _POSIX_Semaphore_Name_to_id( name, &the_semaphore_id );
ffc0b0c8: 7f e3 fb 78 mr r3,r31
ffc0b0cc: 38 81 00 10 addi r4,r1,16
ffc0b0d0: 48 00 6b f9 bl ffc11cc8 <_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 ) {
ffc0b0d4: 7c 7b 1b 79 mr. r27,r3
ffc0b0d8: 41 82 00 24 beq- ffc0b0fc <sem_open+0x90>
/*
* 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) ) ) {
ffc0b0dc: 2f 9b 00 02 cmpwi cr7,r27,2
ffc0b0e0: 40 9e 00 0c bne- cr7,ffc0b0ec <sem_open+0x80> <== NEVER TAKEN
ffc0b0e4: 2f 9c 00 00 cmpwi cr7,r28,0
ffc0b0e8: 40 9e 00 68 bne- cr7,ffc0b150 <sem_open+0xe4>
_Thread_Enable_dispatch();
ffc0b0ec: 48 00 33 a9 bl ffc0e494 <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one_cast( status, sem_t * );
ffc0b0f0: 48 00 9d 99 bl ffc14e88 <__errno>
ffc0b0f4: 93 63 00 00 stw r27,0(r3)
ffc0b0f8: 48 00 00 20 b ffc0b118 <sem_open+0xac>
/*
* Check for existence with creation.
*/
if ( (oflag & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL) ) {
ffc0b0fc: 73 de 0a 00 andi. r30,r30,2560
ffc0b100: 2f 9e 0a 00 cmpwi cr7,r30,2560
ffc0b104: 40 be 00 1c bne+ cr7,ffc0b120 <sem_open+0xb4>
_Thread_Enable_dispatch();
ffc0b108: 48 00 33 8d bl ffc0e494 <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one_cast( EEXIST, sem_t * );
ffc0b10c: 48 00 9d 7d bl ffc14e88 <__errno>
ffc0b110: 38 00 00 11 li r0,17
ffc0b114: 90 03 00 00 stw r0,0(r3)
ffc0b118: 38 60 ff ff li r3,-1
ffc0b11c: 48 00 00 64 b ffc0b180 <sem_open+0x114>
ffc0b120: 80 81 00 10 lwz r4,16(r1)
ffc0b124: 3c 60 00 00 lis r3,0
ffc0b128: 38 a1 00 08 addi r5,r1,8
ffc0b12c: 38 63 30 ac addi r3,r3,12460
ffc0b130: 48 00 23 fd bl ffc0d52c <_Objects_Get>
}
the_semaphore = _POSIX_Semaphore_Get( &the_semaphore_id, &location );
the_semaphore->open_count += 1;
ffc0b134: 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 );
ffc0b138: 90 61 00 0c stw r3,12(r1)
the_semaphore->open_count += 1;
ffc0b13c: 38 09 00 01 addi r0,r9,1
ffc0b140: 90 03 00 18 stw r0,24(r3)
_Thread_Enable_dispatch();
ffc0b144: 48 00 33 51 bl ffc0e494 <_Thread_Enable_dispatch>
_Thread_Enable_dispatch();
ffc0b148: 48 00 33 4d bl ffc0e494 <_Thread_Enable_dispatch>
goto return_id;
ffc0b14c: 48 00 00 2c b ffc0b178 <sem_open+0x10c>
/*
* At this point, the semaphore does not exist and everything has been
* checked. We should go ahead and create a semaphore.
*/
status =_POSIX_Semaphore_Create_support(
ffc0b150: 7f e3 fb 78 mr r3,r31
ffc0b154: 38 80 00 00 li r4,0
ffc0b158: 7f a5 eb 78 mr r5,r29
ffc0b15c: 38 c1 00 0c addi r6,r1,12
ffc0b160: 48 00 69 f1 bl ffc11b50 <_POSIX_Semaphore_Create_support>
ffc0b164: 7c 7f 1b 78 mr r31,r3
/*
* errno was set by Create_support, so don't set it again.
*/
_Thread_Enable_dispatch();
ffc0b168: 48 00 33 2d bl ffc0e494 <_Thread_Enable_dispatch>
if ( status == -1 )
ffc0b16c: 2f 9f ff ff cmpwi cr7,r31,-1
return SEM_FAILED;
ffc0b170: 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 )
ffc0b174: 41 9e 00 0c beq- cr7,ffc0b180 <sem_open+0x114>
the_semaphore->Semaphore_id = the_semaphore->Object.id;
id = &the_semaphore->Semaphore_id;
#else
id = (sem_t *)&the_semaphore->Object.id;
#endif
return id;
ffc0b178: 80 61 00 0c lwz r3,12(r1)
ffc0b17c: 38 63 00 08 addi r3,r3,8
}
ffc0b180: 39 61 00 48 addi r11,r1,72
ffc0b184: 4b ff 8b c0 b ffc03d44 <_restgpr_27_x>
ffc082fc <sigaction>:
struct sigaction *oact
)
{
ISR_Level level;
if ( oact )
ffc082fc: 7c a9 2b 79 mr. r9,r5
int sigaction(
int sig,
const struct sigaction *act,
struct sigaction *oact
)
{
ffc08300: 94 21 ff e8 stwu r1,-24(r1)
ffc08304: 7c 08 02 a6 mflr r0
ffc08308: bf 81 00 08 stmw r28,8(r1)
ffc0830c: 7c 7f 1b 78 mr r31,r3
ffc08310: 7c 9e 23 78 mr r30,r4
ffc08314: 90 01 00 1c stw r0,28(r1)
ISR_Level level;
if ( oact )
ffc08318: 41 82 00 1c beq- ffc08334 <sigaction+0x38>
*oact = _POSIX_signals_Vectors[ sig ];
ffc0831c: 1c 03 00 0c mulli r0,r3,12
ffc08320: 3d 60 00 00 lis r11,0
ffc08324: 39 6b 32 00 addi r11,r11,12800
ffc08328: 7d 6b 02 14 add r11,r11,r0
ffc0832c: 7c ab 64 aa lswi r5,r11,12
ffc08330: 7c a9 65 aa stswi r5,r9,12
if ( !sig )
ffc08334: 2f 9f 00 00 cmpwi cr7,r31,0
ffc08338: 41 9e 00 18 beq- cr7,ffc08350 <sigaction+0x54>
static inline bool is_valid_signo(
int signo
)
{
return ((signo) >= 1 && (signo) <= 32 );
ffc0833c: 38 1f ff ff addi r0,r31,-1
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !is_valid_signo(sig) )
ffc08340: 2b 80 00 1f cmplwi cr7,r0,31
ffc08344: 41 9d 00 0c bgt- cr7,ffc08350 <sigaction+0x54>
*
* NOTE: Solaris documentation claims to "silently enforce" this which
* contradicts the POSIX specification.
*/
if ( sig == SIGKILL )
ffc08348: 2f 9f 00 09 cmpwi cr7,r31,9
ffc0834c: 40 be 00 18 bne+ cr7,ffc08364 <sigaction+0x68>
rtems_set_errno_and_return_minus_one( EINVAL );
ffc08350: 48 00 94 a5 bl ffc117f4 <__errno>
ffc08354: 38 00 00 16 li r0,22
ffc08358: 90 03 00 00 stw r0,0(r3)
ffc0835c: 38 60 ff ff li r3,-1
ffc08360: 48 00 00 74 b ffc083d4 <sigaction+0xd8>
/*
* Evaluate the new action structure and set the global signal vector
* appropriately.
*/
if ( act ) {
ffc08364: 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;
ffc08368: 38 60 00 00 li r3,0
/*
* Evaluate the new action structure and set the global signal vector
* appropriately.
*/
if ( act ) {
ffc0836c: 41 9e 00 68 beq- cr7,ffc083d4 <sigaction+0xd8> <== NEVER TAKEN
static inline uint32_t ppc_interrupt_disable( void )
{
uint32_t level;
uint32_t mask;
__asm__ volatile (
ffc08370: 7f a0 00 a6 mfmsr r29
ffc08374: 7c 10 42 a6 mfsprg r0,0
ffc08378: 7f a0 00 78 andc r0,r29,r0
ffc0837c: 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 ) {
ffc08380: 80 1e 00 08 lwz r0,8(r30)
ffc08384: 3f 80 00 00 lis r28,0
ffc08388: 3b 9c 32 00 addi r28,r28,12800
ffc0838c: 2f 80 00 00 cmpwi cr7,r0,0
ffc08390: 40 be 00 24 bne+ cr7,ffc083b4 <sigaction+0xb8>
_POSIX_signals_Vectors[ sig ] = _POSIX_signals_Default_vectors[ sig ];
ffc08394: 1f ff 00 0c mulli r31,r31,12
ffc08398: 3d 60 ff c2 lis r11,-62
ffc0839c: 38 0b b1 c4 addi r0,r11,-20028
ffc083a0: 7d 3c fa 14 add r9,r28,r31
ffc083a4: 7f e0 fa 14 add r31,r0,r31
ffc083a8: 7c bf 64 aa lswi r5,r31,12
ffc083ac: 7c a9 65 aa stswi r5,r9,12
ffc083b0: 48 00 00 1c b ffc083cc <sigaction+0xd0>
} else {
_POSIX_signals_Clear_process_signals( sig );
ffc083b4: 7f e3 fb 78 mr r3,r31
_POSIX_signals_Vectors[ sig ] = *act;
ffc083b8: 1f ff 00 0c mulli r31,r31,12
_ISR_Disable( level );
if ( act->sa_handler == SIG_DFL ) {
_POSIX_signals_Vectors[ sig ] = _POSIX_signals_Default_vectors[ sig ];
} else {
_POSIX_signals_Clear_process_signals( sig );
ffc083bc: 48 00 62 c1 bl ffc0e67c <_POSIX_signals_Clear_process_signals>
_POSIX_signals_Vectors[ sig ] = *act;
ffc083c0: 7f fc fa 14 add r31,r28,r31
ffc083c4: 7c be 64 aa lswi r5,r30,12
ffc083c8: 7c bf 65 aa stswi r5,r31,12
return level;
}
static inline void ppc_interrupt_enable( uint32_t level )
{
__asm__ volatile (
ffc083cc: 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;
ffc083d0: 38 60 00 00 li r3,0
}
ffc083d4: 39 61 00 18 addi r11,r1,24
ffc083d8: 4b ff 85 44 b ffc0091c <_restgpr_28_x>
ffc08908 <sigtimedwait>:
int sigtimedwait(
const sigset_t *set,
siginfo_t *info,
const struct timespec *timeout
)
{
ffc08908: 94 21 ff d0 stwu r1,-48(r1)
ffc0890c: 7c 08 02 a6 mflr r0
ffc08910: bf 61 00 1c stmw r27,28(r1)
ISR_Level level;
/*
* Error check parameters before disabling interrupts.
*/
if ( !set )
ffc08914: 7c 7d 1b 79 mr. r29,r3
int sigtimedwait(
const sigset_t *set,
siginfo_t *info,
const struct timespec *timeout
)
{
ffc08918: 7c 9f 23 78 mr r31,r4
ffc0891c: 90 01 00 34 stw r0,52(r1)
ffc08920: 7c be 2b 78 mr r30,r5
ISR_Level level;
/*
* Error check parameters before disabling interrupts.
*/
if ( !set )
ffc08924: 41 82 00 2c beq- ffc08950 <sigtimedwait+0x48>
/* NOTE: This is very specifically a RELATIVE not ABSOLUTE time
* in the Open Group specification.
*/
interval = 0;
if ( timeout ) {
ffc08928: 2f 85 00 00 cmpwi cr7,r5,0
ffc0892c: 41 9e 00 30 beq- cr7,ffc0895c <sigtimedwait+0x54>
if ( !_Timespec_Is_valid( timeout ) )
ffc08930: 7c a3 2b 78 mr r3,r5
ffc08934: 48 00 3e b1 bl ffc0c7e4 <_Timespec_Is_valid>
ffc08938: 2f 83 00 00 cmpwi cr7,r3,0
ffc0893c: 41 9e 00 14 beq- cr7,ffc08950 <sigtimedwait+0x48>
rtems_set_errno_and_return_minus_one( EINVAL );
interval = _Timespec_To_ticks( timeout );
ffc08940: 7f c3 f3 78 mr r3,r30
ffc08944: 48 00 3f 21 bl ffc0c864 <_Timespec_To_ticks>
if ( !interval )
ffc08948: 7c 64 1b 79 mr. r4,r3
ffc0894c: 40 a2 00 14 bne+ ffc08960 <sigtimedwait+0x58> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( EINVAL );
ffc08950: 48 00 96 05 bl ffc11f54 <__errno>
ffc08954: 38 00 00 16 li r0,22
ffc08958: 48 00 01 80 b ffc08ad8 <sigtimedwait+0x1d0>
/* NOTE: This is very specifically a RELATIVE not ABSOLUTE time
* in the Open Group specification.
*/
interval = 0;
ffc0895c: 38 80 00 00 li r4,0
/*
* Initialize local variables.
*/
the_info = ( info ) ? info : &signal_information;
ffc08960: 2f 9f 00 00 cmpwi cr7,r31,0
ffc08964: 40 be 00 08 bne+ cr7,ffc0896c <sigtimedwait+0x64>
ffc08968: 3b e1 00 08 addi r31,r1,8
the_thread = _Thread_Executing;
ffc0896c: 3d 20 00 00 lis r9,0
ffc08970: 81 29 31 90 lwz r9,12688(r9)
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
ffc08974: 83 69 01 34 lwz r27,308(r9)
static inline uint32_t ppc_interrupt_disable( void )
{
uint32_t level;
uint32_t mask;
__asm__ volatile (
ffc08978: 7f 80 00 a6 mfmsr r28
ffc0897c: 7c 10 42 a6 mfsprg r0,0
ffc08980: 7f 80 00 78 andc r0,r28,r0
ffc08984: 7c 00 01 24 mtmsr r0
*/
/* API signals pending? */
_ISR_Disable( level );
if ( *set & api->signals_pending ) {
ffc08988: 80 1d 00 00 lwz r0,0(r29)
ffc0898c: 80 7b 00 d4 lwz r3,212(r27)
ffc08990: 7c 0b 18 39 and. r11,r0,r3
ffc08994: 41 a2 00 40 beq+ ffc089d4 <sigtimedwait+0xcc>
/* XXX real info later */
the_info->si_signo = _POSIX_signals_Get_lowest( api->signals_pending );
ffc08998: 4b ff ff 19 bl ffc088b0 <_POSIX_signals_Get_lowest>
_POSIX_signals_Clear_signals(
ffc0899c: 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 );
ffc089a0: 90 7f 00 00 stw r3,0(r31)
ffc089a4: 7c 64 1b 78 mr r4,r3
_POSIX_signals_Clear_signals(
ffc089a8: 38 c0 00 00 li r6,0
ffc089ac: 7f 63 db 78 mr r3,r27
ffc089b0: 38 e0 00 00 li r7,0
ffc089b4: 48 00 65 65 bl ffc0ef18 <_POSIX_signals_Clear_signals>
return level;
}
static inline void ppc_interrupt_enable( uint32_t level )
{
__asm__ volatile (
ffc089b8: 7f 80 01 24 mtmsr r28
false,
false
);
_ISR_Enable( level );
the_info->si_code = SI_USER;
ffc089bc: 38 00 00 01 li r0,1
the_info->si_value.sival_int = 0;
return the_info->si_signo;
ffc089c0: 83 df 00 00 lwz r30,0(r31)
false,
false
);
_ISR_Enable( level );
the_info->si_code = SI_USER;
ffc089c4: 90 1f 00 04 stw r0,4(r31)
the_info->si_value.sival_int = 0;
ffc089c8: 38 00 00 00 li r0,0
ffc089cc: 90 1f 00 08 stw r0,8(r31)
return the_info->si_signo;
ffc089d0: 48 00 01 10 b ffc08ae0 <sigtimedwait+0x1d8>
}
/* Process pending signals? */
if ( *set & _POSIX_signals_Pending ) {
ffc089d4: 3d 60 00 00 lis r11,0
ffc089d8: 80 6b 28 bc lwz r3,10428(r11)
ffc089dc: 7c 0b 18 39 and. r11,r0,r3
ffc089e0: 41 a2 00 40 beq+ ffc08a20 <sigtimedwait+0x118>
signo = _POSIX_signals_Get_lowest( _POSIX_signals_Pending );
ffc089e4: 4b ff fe cd bl ffc088b0 <_POSIX_signals_Get_lowest>
_POSIX_signals_Clear_signals( api, signo, the_info, true, false );
ffc089e8: 7f e5 fb 78 mr r5,r31
}
/* Process pending signals? */
if ( *set & _POSIX_signals_Pending ) {
signo = _POSIX_signals_Get_lowest( _POSIX_signals_Pending );
ffc089ec: 7c 7e 1b 78 mr r30,r3
_POSIX_signals_Clear_signals( api, signo, the_info, true, false );
ffc089f0: 7f c4 f3 78 mr r4,r30
ffc089f4: 7f 63 db 78 mr r3,r27
ffc089f8: 38 c0 00 01 li r6,1
ffc089fc: 38 e0 00 00 li r7,0
ffc08a00: 48 00 65 19 bl ffc0ef18 <_POSIX_signals_Clear_signals>
ffc08a04: 7f 80 01 24 mtmsr r28
_ISR_Enable( level );
the_info->si_signo = signo;
the_info->si_code = SI_USER;
ffc08a08: 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;
ffc08a0c: 93 df 00 00 stw r30,0(r31)
the_info->si_code = SI_USER;
ffc08a10: 90 1f 00 04 stw r0,4(r31)
the_info->si_value.sival_int = 0;
ffc08a14: 38 00 00 00 li r0,0
ffc08a18: 90 1f 00 08 stw r0,8(r31)
return signo;
ffc08a1c: 48 00 00 c4 b ffc08ae0 <sigtimedwait+0x1d8>
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
_Thread_Dispatch_disable_level++;
ffc08a20: 3d 60 00 00 lis r11,0
ffc08a24: 81 4b 28 78 lwz r10,10360(r11)
}
the_info->si_signo = -1;
ffc08a28: 38 00 ff ff li r0,-1
ffc08a2c: 90 1f 00 00 stw r0,0(r31)
ffc08a30: 38 0a 00 01 addi r0,r10,1
ffc08a34: 90 0b 28 78 stw r0,10360(r11)
return _Thread_Dispatch_disable_level;
ffc08a38: 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;
ffc08a3c: 38 00 00 04 li r0,4
ffc08a40: 90 09 00 34 stw r0,52(r9)
}
the_info->si_signo = -1;
_Thread_Disable_dispatch();
the_thread->Wait.queue = &_POSIX_signals_Wait_queue;
ffc08a44: 3d 60 00 00 lis r11,0
ffc08a48: 39 6b 33 8c addi r11,r11,13196
the_thread->Wait.return_code = EINTR;
the_thread->Wait.option = *set;
ffc08a4c: 80 1d 00 00 lwz r0,0(r29)
}
the_info->si_signo = -1;
_Thread_Disable_dispatch();
the_thread->Wait.queue = &_POSIX_signals_Wait_queue;
ffc08a50: 91 69 00 44 stw r11,68(r9)
the_thread->Wait.return_code = EINTR;
the_thread->Wait.option = *set;
ffc08a54: 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;
ffc08a58: 38 00 00 01 li r0,1
the_thread->Wait.return_argument = the_info;
ffc08a5c: 93 e9 00 28 stw r31,40(r9)
ffc08a60: 90 0b 00 30 stw r0,48(r11)
ffc08a64: 7f 80 01 24 mtmsr r28
_Thread_queue_Enter_critical_section( &_POSIX_signals_Wait_queue );
_ISR_Enable( level );
_Thread_queue_Enqueue( &_POSIX_signals_Wait_queue, interval );
ffc08a68: 3c 60 00 00 lis r3,0
ffc08a6c: 3c a0 ff c1 lis r5,-63
ffc08a70: 38 63 33 8c addi r3,r3,13196
ffc08a74: 38 a5 c4 d8 addi r5,r5,-15144
ffc08a78: 48 00 36 b5 bl ffc0c12c <_Thread_queue_Enqueue_with_handler>
_Thread_Enable_dispatch();
ffc08a7c: 48 00 31 61 bl ffc0bbdc <_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 );
ffc08a80: 80 9f 00 00 lwz r4,0(r31)
ffc08a84: 7f 63 db 78 mr r3,r27
ffc08a88: 7f e5 fb 78 mr r5,r31
ffc08a8c: 38 c0 00 00 li r6,0
ffc08a90: 38 e0 00 00 li r7,0
ffc08a94: 48 00 64 85 bl ffc0ef18 <_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)
ffc08a98: 3d 20 00 00 lis r9,0
ffc08a9c: 81 29 31 90 lwz r9,12688(r9)
ffc08aa0: 80 09 00 34 lwz r0,52(r9)
ffc08aa4: 2f 80 00 04 cmpwi cr7,r0,4
ffc08aa8: 40 9e 00 20 bne- cr7,ffc08ac8 <sigtimedwait+0x1c0>
|| !(*set & signo_to_mask( the_info->si_signo )) ) {
ffc08aac: 83 df 00 00 lwz r30,0(r31)
ffc08ab0: 39 20 00 01 li r9,1
ffc08ab4: 38 1e ff ff addi r0,r30,-1
ffc08ab8: 7d 29 00 30 slw r9,r9,r0
ffc08abc: 80 1d 00 00 lwz r0,0(r29)
ffc08ac0: 7d 2b 00 39 and. r11,r9,r0
ffc08ac4: 40 a2 00 1c bne+ ffc08ae0 <sigtimedwait+0x1d8>
errno = _Thread_Executing->Wait.return_code;
ffc08ac8: 48 00 94 8d bl ffc11f54 <__errno>
ffc08acc: 3d 20 00 00 lis r9,0
ffc08ad0: 81 29 31 90 lwz r9,12688(r9)
ffc08ad4: 80 09 00 34 lwz r0,52(r9)
ffc08ad8: 90 03 00 00 stw r0,0(r3)
return -1;
ffc08adc: 3b c0 ff ff li r30,-1
}
return the_info->si_signo;
}
ffc08ae0: 39 61 00 30 addi r11,r1,48
ffc08ae4: 7f c3 f3 78 mr r3,r30
ffc08ae8: 4b ff 82 30 b ffc00d18 <_restgpr_27_x>
ffc0ab3c <sigwait>:
int sigwait(
const sigset_t *set,
int *sig
)
{
ffc0ab3c: 7c 2b 0b 78 mr r11,r1
ffc0ab40: 94 21 ff f0 stwu r1,-16(r1)
ffc0ab44: 7c 08 02 a6 mflr r0
int status;
status = sigtimedwait( set, NULL, NULL );
ffc0ab48: 38 a0 00 00 li r5,0
int sigwait(
const sigset_t *set,
int *sig
)
{
ffc0ab4c: 4b ff 7c 65 bl ffc027b0 <_savegpr_31>
ffc0ab50: 7c 9f 23 78 mr r31,r4
int status;
status = sigtimedwait( set, NULL, NULL );
ffc0ab54: 38 80 00 00 li r4,0
int sigwait(
const sigset_t *set,
int *sig
)
{
ffc0ab58: 90 01 00 14 stw r0,20(r1)
int status;
status = sigtimedwait( set, NULL, NULL );
ffc0ab5c: 4b ff fd d9 bl ffc0a934 <sigtimedwait>
if ( status != -1 ) {
ffc0ab60: 2f 83 ff ff cmpwi cr7,r3,-1
ffc0ab64: 41 9e 00 18 beq- cr7,ffc0ab7c <sigwait+0x40>
if ( sig )
ffc0ab68: 2f 9f 00 00 cmpwi cr7,r31,0
*sig = status;
return 0;
ffc0ab6c: 38 00 00 00 li r0,0
int status;
status = sigtimedwait( set, NULL, NULL );
if ( status != -1 ) {
if ( sig )
ffc0ab70: 41 9e 00 14 beq- cr7,ffc0ab84 <sigwait+0x48> <== NEVER TAKEN
*sig = status;
ffc0ab74: 90 7f 00 00 stw r3,0(r31)
ffc0ab78: 48 00 00 0c b ffc0ab84 <sigwait+0x48>
return 0;
}
return errno;
ffc0ab7c: 48 00 91 3d bl ffc13cb8 <__errno>
ffc0ab80: 80 03 00 00 lwz r0,0(r3)
}
ffc0ab84: 39 61 00 10 addi r11,r1,16
ffc0ab88: 7c 03 03 78 mr r3,r0
ffc0ab8c: 4b ff 7c 70 b ffc027fc <_restgpr_31_x>
ffc06b20 <siproc>:
/*
* Process input character, with semaphore.
*/
static int
siproc (unsigned char c, struct rtems_termios_tty *tty)
{
ffc06b20: 94 21 ff f0 stwu r1,-16(r1)
ffc06b24: 7c 08 02 a6 mflr r0
ffc06b28: 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)) {
ffc06b2c: 80 04 00 3c lwz r0,60(r4)
/*
* Process input character, with semaphore.
*/
static int
siproc (unsigned char c, struct rtems_termios_tty *tty)
{
ffc06b30: bf c1 00 08 stmw r30,8(r1)
ffc06b34: 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)) {
ffc06b38: 70 09 0e 78 andi. r9,r0,3704
/*
* Process input character, with semaphore.
*/
static int
siproc (unsigned char c, struct rtems_termios_tty *tty)
{
ffc06b3c: 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)) {
ffc06b40: 41 a2 00 38 beq+ ffc06b78 <siproc+0x58> <== NEVER TAKEN
rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
ffc06b44: 80 64 00 18 lwz r3,24(r4)
ffc06b48: 38 a0 00 00 li r5,0
ffc06b4c: 38 80 00 00 li r4,0
ffc06b50: 48 00 15 55 bl ffc080a4 <rtems_semaphore_obtain>
i = iproc (c, tty);
ffc06b54: 7f c3 f3 78 mr r3,r30
ffc06b58: 7f e4 fb 78 mr r4,r31
ffc06b5c: 4b ff fe 15 bl ffc06970 <iproc>
ffc06b60: 7c 7e 1b 78 mr r30,r3
rtems_semaphore_release (tty->osem);
ffc06b64: 80 7f 00 18 lwz r3,24(r31)
ffc06b68: 48 00 16 69 bl ffc081d0 <rtems_semaphore_release>
}
else {
i = iproc (c, tty);
}
return i;
}
ffc06b6c: 39 61 00 10 addi r11,r1,16
ffc06b70: 7f c3 f3 78 mr r3,r30
ffc06b74: 4b ff 99 cc b ffc00540 <_restgpr_30_x>
ffc06b78: 80 01 00 14 lwz r0,20(r1) <== NOT EXECUTED
ffc06b7c: bb c1 00 08 lmw r30,8(r1) <== NOT EXECUTED
ffc06b80: 38 21 00 10 addi r1,r1,16 <== NOT EXECUTED
ffc06b84: 7c 08 03 a6 mtlr r0 <== 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);
ffc06b88: 4b ff fd e8 b ffc06970 <iproc> <== NOT EXECUTED
ffc07df4 <statvfs>:
#include <sys/statvfs.h>
int
statvfs (const char *path, struct statvfs *sb)
{
ffc07df4: 94 21 ff d0 stwu r1,-48(r1)
ffc07df8: 7c 08 02 a6 mflr r0
ffc07dfc: bf c1 00 28 stmw r30,40(r1)
ffc07e00: 7c 7e 1b 78 mr r30,r3
ffc07e04: 7c 9f 23 78 mr r31,r4
ffc07e08: 90 01 00 34 stw r0,52(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 ) )
ffc07e0c: 48 00 d9 45 bl ffc15750 <strlen>
ffc07e10: 7c 64 1b 78 mr r4,r3
ffc07e14: 38 a0 00 00 li r5,0
ffc07e18: 7f c3 f3 78 mr r3,r30
ffc07e1c: 38 c1 00 08 addi r6,r1,8
ffc07e20: 38 e0 00 01 li r7,1
ffc07e24: 4b ff ea 65 bl ffc06888 <rtems_filesystem_evaluate_path>
return -1;
ffc07e28: 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 ) )
ffc07e2c: 2f 83 00 00 cmpwi cr7,r3,0
ffc07e30: 40 9e 00 3c bne- cr7,ffc07e6c <statvfs+0x78> <== NEVER TAKEN
return -1;
mt_entry = loc.mt_entry;
ffc07e34: 83 c1 00 18 lwz r30,24(r1)
fs_mount_root = &mt_entry->mt_fs_root;
memset (sb, 0, sizeof (struct statvfs));
ffc07e38: 38 80 00 00 li r4,0
ffc07e3c: 38 a0 00 38 li r5,56
ffc07e40: 7f e3 fb 78 mr r3,r31
ffc07e44: 48 00 c6 49 bl ffc1448c <memset>
result = ( fs_mount_root->ops->statvfs_h )( fs_mount_root, sb );
ffc07e48: 81 3e 00 28 lwz r9,40(r30)
ffc07e4c: 38 7e 00 1c addi r3,r30,28
ffc07e50: 80 09 00 44 lwz r0,68(r9)
ffc07e54: 7f e4 fb 78 mr r4,r31
ffc07e58: 7c 09 03 a6 mtctr r0
ffc07e5c: 4e 80 04 21 bctrl
ffc07e60: 7c 7e 1b 78 mr r30,r3
rtems_filesystem_freenode( &loc );
ffc07e64: 38 61 00 08 addi r3,r1,8
ffc07e68: 4b ff eb 15 bl ffc0697c <rtems_filesystem_freenode>
return result;
}
ffc07e6c: 39 61 00 30 addi r11,r1,48
ffc07e70: 7f c3 f3 78 mr r3,r30
ffc07e74: 4b ff a8 00 b ffc02674 <_restgpr_30_x>
ffc06814 <sync_per_thread>:
fdatasync(fn);
}
/* iterate over all FILE *'s for this thread */
static void sync_per_thread(Thread_Control *t)
{
ffc06814: 94 21 ff f0 stwu r1,-16(r1)
ffc06818: 7c 08 02 a6 mflr r0
ffc0681c: 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;
ffc06820: 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)
{
ffc06824: bf c1 00 08 stmw 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 ) {
ffc06828: 2f 80 00 00 cmpwi cr7,r0,0
ffc0682c: 41 9e 00 30 beq- cr7,ffc0685c <sync_per_thread+0x48> <== NEVER TAKEN
current_reent = _Thread_Executing->libc_reent;
ffc06830: 3f e0 00 00 lis r31,0
ffc06834: 3b ff 31 24 addi r31,r31,12580
ffc06838: 81 3f 00 0c lwz r9,12(r31)
_Thread_Executing->libc_reent = this_reent;
_fwalk (t->libc_reent, sync_wrapper);
ffc0683c: 3c 80 ff c0 lis r4,-64
ffc06840: 38 84 68 64 addi r4,r4,26724
* 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;
ffc06844: 83 c9 01 2c lwz r30,300(r9)
_Thread_Executing->libc_reent = this_reent;
ffc06848: 90 09 01 2c stw r0,300(r9)
_fwalk (t->libc_reent, sync_wrapper);
ffc0684c: 80 63 01 2c lwz r3,300(r3)
ffc06850: 48 00 c1 ed bl ffc12a3c <_fwalk>
_Thread_Executing->libc_reent = current_reent;
ffc06854: 81 3f 00 0c lwz r9,12(r31)
ffc06858: 93 c9 01 2c stw r30,300(r9)
}
}
ffc0685c: 39 61 00 10 addi r11,r1,16
ffc06860: 4b ff a4 7c b ffc00cdc <_restgpr_30_x>
ffc0e82c <tcsetattr>:
int fd,
int opt,
struct termios *tp
)
{
switch (opt) {
ffc0e82c: 2c 04 00 00 cmpwi r4,0
int tcsetattr(
int fd,
int opt,
struct termios *tp
)
{
ffc0e830: 94 21 ff f0 stwu r1,-16(r1)
ffc0e834: 7c 08 02 a6 mflr r0
ffc0e838: bf c1 00 08 stmw r30,8(r1)
ffc0e83c: 7c 7e 1b 78 mr r30,r3
ffc0e840: 7c bf 2b 78 mr r31,r5
ffc0e844: 90 01 00 14 stw r0,20(r1)
switch (opt) {
ffc0e848: 41 82 00 3c beq- ffc0e884 <tcsetattr+0x58>
ffc0e84c: 2f 84 00 01 cmpwi cr7,r4,1
ffc0e850: 41 9e 00 18 beq- cr7,ffc0e868 <tcsetattr+0x3c>
default:
rtems_set_errno_and_return_minus_one( ENOTSUP );
ffc0e854: 48 00 41 19 bl ffc1296c <__errno>
ffc0e858: 38 00 00 86 li r0,134
ffc0e85c: 90 03 00 00 stw r0,0(r3)
ffc0e860: 38 00 ff ff li r0,-1
ffc0e864: 48 00 00 38 b ffc0e89c <tcsetattr+0x70>
case TCSADRAIN:
if (ioctl( fd, RTEMS_IO_TCDRAIN, NULL ) < 0)
ffc0e868: 38 80 00 03 li r4,3
ffc0e86c: 38 a0 00 00 li r5,0
ffc0e870: 4c c6 31 82 crclr 4*cr1+eq
ffc0e874: 4b ff fb 4d bl ffc0e3c0 <ioctl>
return -1;
ffc0e878: 38 00 ff ff li r0,-1
switch (opt) {
default:
rtems_set_errno_and_return_minus_one( ENOTSUP );
case TCSADRAIN:
if (ioctl( fd, RTEMS_IO_TCDRAIN, NULL ) < 0)
ffc0e87c: 2f 83 00 00 cmpwi cr7,r3,0
ffc0e880: 41 9c 00 1c blt- cr7,ffc0e89c <tcsetattr+0x70> <== NEVER TAKEN
return -1;
/*
* Fall through to....
*/
case TCSANOW:
return ioctl( fd, RTEMS_IO_SET_ATTRIBUTES, tp );
ffc0e884: 7f c3 f3 78 mr r3,r30
ffc0e888: 38 80 00 02 li r4,2
ffc0e88c: 7f e5 fb 78 mr r5,r31
ffc0e890: 4c c6 31 82 crclr 4*cr1+eq
ffc0e894: 4b ff fb 2d bl ffc0e3c0 <ioctl>
ffc0e898: 7c 60 1b 78 mr r0,r3
}
}
ffc0e89c: 39 61 00 10 addi r11,r1,16
ffc0e8a0: 7c 03 03 78 mr r3,r0
ffc0e8a4: 4b ff 21 f4 b ffc00a98 <_restgpr_30_x>
ffc07ac0 <timer_create>:
timer_t *timerid
)
{
POSIX_Timer_Control *ptimer;
if ( clock_id != CLOCK_REALTIME )
ffc07ac0: 2f 83 00 01 cmpwi cr7,r3,1
int timer_create(
clockid_t clock_id,
struct sigevent *evp,
timer_t *timerid
)
{
ffc07ac4: 94 21 ff f0 stwu r1,-16(r1)
ffc07ac8: 7c 08 02 a6 mflr r0
ffc07acc: bf c1 00 08 stmw r30,8(r1)
ffc07ad0: 7c 9f 23 78 mr r31,r4
ffc07ad4: 7c be 2b 78 mr r30,r5
ffc07ad8: 90 01 00 14 stw r0,20(r1)
POSIX_Timer_Control *ptimer;
if ( clock_id != CLOCK_REALTIME )
ffc07adc: 40 9e 00 3c bne- cr7,ffc07b18 <timer_create+0x58>
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !timerid )
ffc07ae0: 2f 85 00 00 cmpwi cr7,r5,0
ffc07ae4: 41 9e 00 34 beq- cr7,ffc07b18 <timer_create+0x58>
/*
* The data of the structure evp are checked in order to verify if they
* are coherent.
*/
if (evp != NULL) {
ffc07ae8: 2f 84 00 00 cmpwi cr7,r4,0
ffc07aec: 41 9e 00 38 beq- cr7,ffc07b24 <timer_create+0x64>
/* The structure has data */
if ( ( evp->sigev_notify != SIGEV_NONE ) &&
ffc07af0: 81 24 00 00 lwz r9,0(r4)
ffc07af4: 38 09 ff ff addi r0,r9,-1
ffc07af8: 2b 80 00 01 cmplwi cr7,r0,1
ffc07afc: 41 9d 00 1c bgt- cr7,ffc07b18 <timer_create+0x58> <== 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 )
ffc07b00: 81 24 00 04 lwz r9,4(r4)
ffc07b04: 2f 89 00 00 cmpwi cr7,r9,0
ffc07b08: 41 9e 00 10 beq- cr7,ffc07b18 <timer_create+0x58> <== NEVER TAKEN
static inline bool is_valid_signo(
int signo
)
{
return ((signo) >= 1 && (signo) <= 32 );
ffc07b0c: 39 29 ff ff addi r9,r9,-1
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !is_valid_signo(evp->sigev_signo) )
ffc07b10: 2b 89 00 1f cmplwi cr7,r9,31
ffc07b14: 40 bd 00 10 ble+ cr7,ffc07b24 <timer_create+0x64> <== ALWAYS TAKEN
rtems_set_errno_and_return_minus_one( EINVAL );
ffc07b18: 48 00 99 89 bl ffc114a0 <__errno>
ffc07b1c: 38 00 00 16 li r0,22
ffc07b20: 48 00 00 38 b ffc07b58 <timer_create+0x98>
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
_Thread_Dispatch_disable_level++;
ffc07b24: 3d 20 00 00 lis r9,0
ffc07b28: 81 69 28 54 lwz r11,10324(r9)
ffc07b2c: 38 0b 00 01 addi r0,r11,1
ffc07b30: 90 09 28 54 stw r0,10324(r9)
return _Thread_Dispatch_disable_level;
ffc07b34: 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 );
ffc07b38: 3c 60 00 00 lis r3,0
ffc07b3c: 38 63 2f 2c addi r3,r3,12076
ffc07b40: 48 00 21 71 bl ffc09cb0 <_Objects_Allocate>
/*
* Allocate a timer
*/
ptimer = _POSIX_Timer_Allocate();
if ( !ptimer ) {
ffc07b44: 2c 03 00 00 cmpwi r3,0
ffc07b48: 40 a2 00 1c bne+ ffc07b64 <timer_create+0xa4>
_Thread_Enable_dispatch();
ffc07b4c: 48 00 35 51 bl ffc0b09c <_Thread_Enable_dispatch>
rtems_set_errno_and_return_minus_one( EAGAIN );
ffc07b50: 48 00 99 51 bl ffc114a0 <__errno>
ffc07b54: 38 00 00 0b li r0,11
ffc07b58: 90 03 00 00 stw r0,0(r3)
ffc07b5c: 38 60 ff ff li r3,-1
ffc07b60: 48 00 00 88 b ffc07be8 <timer_create+0x128>
}
/* The data of the created timer are stored to use them later */
ptimer->state = POSIX_TIMER_STATE_CREATE_NEW;
ffc07b64: 38 00 00 02 li r0,2
ffc07b68: 98 03 00 3c stb r0,60(r3)
ptimer->thread_id = _Thread_Executing->Object.id;
ffc07b6c: 3d 20 00 00 lis r9,0
if ( evp != NULL ) {
ffc07b70: 2f 9f 00 00 cmpwi cr7,r31,0
}
/* The data of the created timer are stored to use them later */
ptimer->state = POSIX_TIMER_STATE_CREATE_NEW;
ptimer->thread_id = _Thread_Executing->Object.id;
ffc07b74: 81 29 31 70 lwz r9,12656(r9)
ffc07b78: 80 09 00 08 lwz r0,8(r9)
ffc07b7c: 90 03 00 38 stw r0,56(r3)
if ( evp != NULL ) {
ffc07b80: 41 9e 00 1c beq- cr7,ffc07b9c <timer_create+0xdc>
ptimer->inf.sigev_notify = evp->sigev_notify;
ffc07b84: 80 1f 00 00 lwz r0,0(r31)
ffc07b88: 90 03 00 40 stw r0,64(r3)
ptimer->inf.sigev_signo = evp->sigev_signo;
ffc07b8c: 80 1f 00 04 lwz r0,4(r31)
ffc07b90: 90 03 00 44 stw r0,68(r3)
ptimer->inf.sigev_value = evp->sigev_value;
ffc07b94: 80 1f 00 08 lwz r0,8(r31)
ffc07b98: 90 03 00 48 stw r0,72(r3)
uint32_t name
)
{
_Objects_Set_local_object(
information,
_Objects_Get_index( the_object->id ),
ffc07b9c: 81 23 00 08 lwz r9,8(r3)
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
ffc07ba0: 3d 60 00 00 lis r11,0
ffc07ba4: 81 4b 2f 48 lwz r10,12104(r11)
}
ptimer->overrun = 0;
ffc07ba8: 38 00 00 00 li r0,0
ffc07bac: 55 2b 13 ba rlwinm r11,r9,2,14,29
ffc07bb0: 90 03 00 68 stw r0,104(r3)
ptimer->timer_data.it_value.tv_sec = 0;
ffc07bb4: 90 03 00 5c stw r0,92(r3)
ptimer->timer_data.it_value.tv_nsec = 0;
ffc07bb8: 90 03 00 60 stw r0,96(r3)
ptimer->timer_data.it_interval.tv_sec = 0;
ffc07bbc: 90 03 00 54 stw r0,84(r3)
ptimer->timer_data.it_interval.tv_nsec = 0;
ffc07bc0: 90 03 00 58 stw r0,88(r3)
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
ffc07bc4: 90 03 00 18 stw r0,24(r3)
the_watchdog->routine = routine;
ffc07bc8: 90 03 00 2c stw r0,44(r3)
the_watchdog->id = id;
ffc07bcc: 90 03 00 30 stw r0,48(r3)
the_watchdog->user_data = user_data;
ffc07bd0: 90 03 00 34 stw r0,52(r3)
ffc07bd4: 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;
ffc07bd8: 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;
ffc07bdc: 91 3e 00 00 stw r9,0(r30)
_Thread_Enable_dispatch();
ffc07be0: 48 00 34 bd bl ffc0b09c <_Thread_Enable_dispatch>
return 0;
ffc07be4: 38 60 00 00 li r3,0
}
ffc07be8: 39 61 00 10 addi r11,r1,16
ffc07bec: 4b ff 8a 68 b ffc00654 <_restgpr_30_x>
ffc07bf0 <timer_settime>:
timer_t timerid,
int flags,
const struct itimerspec *value,
struct itimerspec *ovalue
)
{
ffc07bf0: 94 21 ff c8 stwu r1,-56(r1)
ffc07bf4: 7c 08 02 a6 mflr r0
ffc07bf8: bf 81 00 28 stmw r28,40(r1)
Objects_Locations location;
bool activated;
uint32_t initial_period;
struct itimerspec normalize;
if ( !value )
ffc07bfc: 7c bd 2b 79 mr. r29,r5
timer_t timerid,
int flags,
const struct itimerspec *value,
struct itimerspec *ovalue
)
{
ffc07c00: 7c 7f 1b 78 mr r31,r3
ffc07c04: 90 01 00 3c stw r0,60(r1)
ffc07c08: 7c 9c 23 78 mr r28,r4
ffc07c0c: 7c de 33 78 mr r30,r6
Objects_Locations location;
bool activated;
uint32_t initial_period;
struct itimerspec normalize;
if ( !value )
ffc07c10: 41 82 01 58 beq- ffc07d68 <timer_settime+0x178> <== 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) ) ) {
ffc07c14: 38 7d 00 08 addi r3,r29,8
ffc07c18: 48 00 40 c9 bl ffc0bce0 <_Timespec_Is_valid>
ffc07c1c: 2f 83 00 00 cmpwi cr7,r3,0
ffc07c20: 41 9e 01 48 beq- cr7,ffc07d68 <timer_settime+0x178>
rtems_set_errno_and_return_minus_one( EINVAL );
}
if ( !_Timespec_Is_valid( &(value->it_interval) ) ) {
ffc07c24: 7f a3 eb 78 mr r3,r29
ffc07c28: 48 00 40 b9 bl ffc0bce0 <_Timespec_Is_valid>
ffc07c2c: 2f 83 00 00 cmpwi cr7,r3,0
ffc07c30: 41 9e 01 38 beq- cr7,ffc07d68 <timer_settime+0x178> <== NEVER TAKEN
rtems_set_errno_and_return_minus_one( EINVAL );
}
if ( flags != TIMER_ABSTIME && flags != POSIX_TIMER_RELATIVE ) {
ffc07c34: 2f 9c 00 04 cmpwi cr7,r28,4
ffc07c38: 41 9e 00 0c beq- cr7,ffc07c44 <timer_settime+0x54>
ffc07c3c: 2f 9c 00 00 cmpwi cr7,r28,0
ffc07c40: 40 9e 01 28 bne- cr7,ffc07d68 <timer_settime+0x178>
}
normalize = *value;
/* Convert absolute to relative time */
if (flags == TIMER_ABSTIME) {
ffc07c44: 2f 9c 00 04 cmpwi cr7,r28,4
if ( flags != TIMER_ABSTIME && flags != POSIX_TIMER_RELATIVE ) {
rtems_set_errno_and_return_minus_one( EINVAL );
}
normalize = *value;
ffc07c48: 39 21 00 14 addi r9,r1,20
ffc07c4c: 7c bd 84 aa lswi r5,r29,16
ffc07c50: 7c a9 85 aa stswi r5,r9,16
/* Convert absolute to relative time */
if (flags == TIMER_ABSTIME) {
ffc07c54: 40 be 00 30 bne+ cr7,ffc07c84 <timer_settime+0x94>
struct timespec now;
_TOD_Get( &now );
ffc07c58: 38 61 00 0c addi r3,r1,12
ffc07c5c: 48 00 1a d1 bl ffc0972c <_TOD_Get>
/* Check for seconds in the past */
if ( _Timespec_Greater_than( &now, &normalize.it_value ) )
ffc07c60: 38 61 00 0c addi r3,r1,12
ffc07c64: 38 81 00 1c addi r4,r1,28
ffc07c68: 48 00 40 3d bl ffc0bca4 <_Timespec_Greater_than>
ffc07c6c: 2f 83 00 00 cmpwi cr7,r3,0
ffc07c70: 40 9e 00 f8 bne- cr7,ffc07d68 <timer_settime+0x178>
rtems_set_errno_and_return_minus_one( EINVAL );
_Timespec_Subtract( &now, &normalize.it_value, &normalize.it_value );
ffc07c74: 38 81 00 1c addi r4,r1,28
ffc07c78: 38 61 00 0c addi r3,r1,12
ffc07c7c: 7c 85 23 78 mr r5,r4
ffc07c80: 48 00 40 a1 bl ffc0bd20 <_Timespec_Subtract>
RTEMS_INLINE_ROUTINE POSIX_Timer_Control *_POSIX_Timer_Get (
timer_t id,
Objects_Locations *location
)
{
return (POSIX_Timer_Control *)
ffc07c84: 3c 60 00 00 lis r3,0
ffc07c88: 7f e4 fb 78 mr r4,r31
ffc07c8c: 38 63 2f 2c addi r3,r3,12076
ffc07c90: 38 a1 00 08 addi r5,r1,8
ffc07c94: 48 00 25 3d bl ffc0a1d0 <_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 ) {
ffc07c98: 80 01 00 08 lwz r0,8(r1)
ffc07c9c: 7c 7f 1b 78 mr r31,r3
ffc07ca0: 2f 80 00 00 cmpwi cr7,r0,0
ffc07ca4: 40 9e 00 c4 bne- cr7,ffc07d68 <timer_settime+0x178>
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 ) {
ffc07ca8: 80 01 00 1c lwz r0,28(r1)
ffc07cac: 2f 80 00 00 cmpwi cr7,r0,0
ffc07cb0: 40 9e 00 44 bne- cr7,ffc07cf4 <timer_settime+0x104>
ffc07cb4: 80 01 00 20 lwz r0,32(r1)
ffc07cb8: 2f 80 00 00 cmpwi cr7,r0,0
ffc07cbc: 40 be 00 38 bne+ cr7,ffc07cf4 <timer_settime+0x104>
/* Stop the timer */
(void) _Watchdog_Remove( &ptimer->Timer );
ffc07cc0: 38 63 00 10 addi r3,r3,16
ffc07cc4: 48 00 45 99 bl ffc0c25c <_Watchdog_Remove>
/* The old data of the timer are returned */
if ( ovalue )
ffc07cc8: 2f 9e 00 00 cmpwi cr7,r30,0
ffc07ccc: 39 3f 00 54 addi r9,r31,84
ffc07cd0: 41 9e 00 0c beq- cr7,ffc07cdc <timer_settime+0xec>
*ovalue = ptimer->timer_data;
ffc07cd4: 7c a9 84 aa lswi r5,r9,16
ffc07cd8: 7c be 85 aa stswi r5,r30,16
/* The new data are set */
ptimer->timer_data = normalize;
ffc07cdc: 39 61 00 14 addi r11,r1,20
/* Indicates that the timer is created and stopped */
ptimer->state = POSIX_TIMER_STATE_CREATE_STOP;
ffc07ce0: 38 00 00 04 li r0,4
(void) _Watchdog_Remove( &ptimer->Timer );
/* The old data of the timer are returned */
if ( ovalue )
*ovalue = ptimer->timer_data;
/* The new data are set */
ptimer->timer_data = normalize;
ffc07ce4: 7c ab 84 aa lswi r5,r11,16
ffc07ce8: 7c a9 85 aa stswi r5,r9,16
/* Indicates that the timer is created and stopped */
ptimer->state = POSIX_TIMER_STATE_CREATE_STOP;
ffc07cec: 98 1f 00 3c stb r0,60(r31)
ffc07cf0: 48 00 00 6c b ffc07d5c <timer_settime+0x16c>
_Thread_Enable_dispatch();
return 0;
}
/* Convert from seconds and nanoseconds to ticks */
ptimer->ticks = _Timespec_To_ticks( &value->it_interval );
ffc07cf4: 7f a3 eb 78 mr r3,r29
ffc07cf8: 48 00 40 69 bl ffc0bd60 <_Timespec_To_ticks>
ffc07cfc: 90 7f 00 64 stw r3,100(r31)
initial_period = _Timespec_To_ticks( &normalize.it_value );
ffc07d00: 38 61 00 1c addi r3,r1,28
ffc07d04: 48 00 40 5d bl ffc0bd60 <_Timespec_To_ticks>
activated = _POSIX_Timer_Insert_helper(
ffc07d08: 80 bf 00 08 lwz r5,8(r31)
ffc07d0c: 3c c0 ff c0 lis r6,-64
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 );
ffc07d10: 7c 64 1b 78 mr r4,r3
activated = _POSIX_Timer_Insert_helper(
ffc07d14: 38 c6 7d 80 addi r6,r6,32128
ffc07d18: 38 7f 00 10 addi r3,r31,16
ffc07d1c: 7f e7 fb 78 mr r7,r31
ffc07d20: 48 00 69 a9 bl ffc0e6c8 <_POSIX_Timer_Insert_helper>
initial_period,
ptimer->Object.id,
_POSIX_Timer_TSR,
ptimer
);
if ( !activated ) {
ffc07d24: 2f 83 00 00 cmpwi cr7,r3,0
ffc07d28: 41 9e 00 34 beq- cr7,ffc07d5c <timer_settime+0x16c>
/*
* The timer has been started and is running. So we return the
* old ones in "ovalue"
*/
if ( ovalue )
ffc07d2c: 2f 9e 00 00 cmpwi cr7,r30,0
ffc07d30: 39 3f 00 54 addi r9,r31,84
ffc07d34: 41 9e 00 0c beq- cr7,ffc07d40 <timer_settime+0x150>
*ovalue = ptimer->timer_data;
ffc07d38: 7c a9 84 aa lswi r5,r9,16
ffc07d3c: 7c be 85 aa stswi r5,r30,16
ptimer->timer_data = normalize;
ffc07d40: 39 61 00 14 addi r11,r1,20
/* Indicate that the time is running */
ptimer->state = POSIX_TIMER_STATE_CREATE_RUN;
ffc07d44: 38 00 00 03 li r0,3
* 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;
ffc07d48: 7c ab 84 aa lswi r5,r11,16
ffc07d4c: 7c a9 85 aa stswi r5,r9,16
/* Indicate that the time is running */
ptimer->state = POSIX_TIMER_STATE_CREATE_RUN;
_TOD_Get( &ptimer->time );
ffc07d50: 38 7f 00 6c addi r3,r31,108
if ( ovalue )
*ovalue = ptimer->timer_data;
ptimer->timer_data = normalize;
/* Indicate that the time is running */
ptimer->state = POSIX_TIMER_STATE_CREATE_RUN;
ffc07d54: 98 1f 00 3c stb r0,60(r31)
_TOD_Get( &ptimer->time );
ffc07d58: 48 00 19 d5 bl ffc0972c <_TOD_Get>
_Thread_Enable_dispatch();
ffc07d5c: 48 00 33 41 bl ffc0b09c <_Thread_Enable_dispatch>
return 0;
ffc07d60: 38 60 00 00 li r3,0
ffc07d64: 48 00 00 14 b ffc07d78 <timer_settime+0x188>
#endif
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EINVAL );
ffc07d68: 48 00 97 39 bl ffc114a0 <__errno>
ffc07d6c: 38 00 00 16 li r0,22
ffc07d70: 90 03 00 00 stw r0,0(r3)
ffc07d74: 38 60 ff ff li r3,-1
}
ffc07d78: 39 61 00 38 addi r11,r1,56
ffc07d7c: 4b ff 88 d0 b ffc0064c <_restgpr_28_x>
ffc079c0 <ualarm>:
useconds_t ualarm(
useconds_t useconds,
useconds_t interval
)
{
ffc079c0: 94 21 ff d8 stwu r1,-40(r1)
ffc079c4: 7c 08 02 a6 mflr r0
ffc079c8: bf a1 00 1c stmw r29,28(r1)
/*
* Initialize the timer used to implement alarm().
*/
if ( !the_timer->routine ) {
ffc079cc: 3f a0 00 00 lis r29,0
ffc079d0: 3b bd 35 74 addi r29,r29,13684
useconds_t ualarm(
useconds_t useconds,
useconds_t interval
)
{
ffc079d4: 90 01 00 2c stw r0,44(r1)
ffc079d8: 7c 7e 1b 78 mr r30,r3
/*
* Initialize the timer used to implement alarm().
*/
if ( !the_timer->routine ) {
ffc079dc: 80 1d 00 1c lwz r0,28(r29)
ffc079e0: 2f 80 00 00 cmpwi cr7,r0,0
ffc079e4: 40 be 00 24 bne+ cr7,ffc07a08 <ualarm+0x48>
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
the_watchdog->routine = routine;
ffc079e8: 3d 20 ff c0 lis r9,-64
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
ffc079ec: 90 1d 00 08 stw r0,8(r29)
the_watchdog->routine = routine;
ffc079f0: 39 29 79 78 addi r9,r9,31096
ffc079f4: 91 3d 00 1c stw r9,28(r29)
useconds_t ualarm(
useconds_t useconds,
useconds_t interval
)
{
useconds_t remaining = 0;
ffc079f8: 3b e0 00 00 li r31,0
the_watchdog->id = id;
ffc079fc: 90 1d 00 20 stw r0,32(r29)
the_watchdog->user_data = user_data;
ffc07a00: 90 1d 00 24 stw r0,36(r29)
ffc07a04: 48 00 00 58 b ffc07a5c <ualarm+0x9c>
if ( !the_timer->routine ) {
_Watchdog_Initialize( the_timer, _POSIX_signals_Ualarm_TSR, 0, NULL );
} else {
Watchdog_States state;
state = _Watchdog_Remove( the_timer );
ffc07a08: 7f a3 eb 78 mr r3,r29
ffc07a0c: 48 00 43 91 bl ffc0bd9c <_Watchdog_Remove>
useconds_t ualarm(
useconds_t useconds,
useconds_t interval
)
{
useconds_t remaining = 0;
ffc07a10: 3b e0 00 00 li r31,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) ) {
ffc07a14: 38 63 ff fe addi r3,r3,-2
ffc07a18: 2b 83 00 01 cmplwi cr7,r3,1
ffc07a1c: 41 bd 00 40 bgt+ cr7,ffc07a5c <ualarm+0x9c> <== NEVER TAKEN
* boot. Since alarm() is dealing in seconds, we must account for
* this.
*/
ticks = the_timer->initial;
ticks -= (the_timer->stop_time - the_timer->start_time);
ffc07a20: 80 1d 00 0c lwz r0,12(r29)
/* remaining is now in ticks */
_Timespec_From_ticks( ticks, &tp );
ffc07a24: 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);
ffc07a28: 80 7d 00 14 lwz r3,20(r29)
ffc07a2c: 7c 63 02 14 add r3,r3,r0
ffc07a30: 80 1d 00 18 lwz r0,24(r29)
/* remaining is now in ticks */
_Timespec_From_ticks( ticks, &tp );
ffc07a34: 7c 60 18 50 subf r3,r0,r3
ffc07a38: 48 00 3d 41 bl ffc0b778 <_Timespec_From_ticks>
remaining = tp.tv_sec * TOD_MICROSECONDS_PER_SECOND;
ffc07a3c: 81 21 00 08 lwz r9,8(r1)
ffc07a40: 3c 00 00 0f lis r0,15
remaining += tp.tv_nsec / 1000;
ffc07a44: 83 e1 00 0c lwz r31,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;
ffc07a48: 60 00 42 40 ori r0,r0,16960
ffc07a4c: 7c 00 49 d6 mullw r0,r0,r9
remaining += tp.tv_nsec / 1000;
ffc07a50: 39 20 03 e8 li r9,1000
ffc07a54: 7f ff 4b d6 divw r31,r31,r9
ffc07a58: 7f ff 02 14 add r31,r31,r0
/*
* 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 ) {
ffc07a5c: 2f 9e 00 00 cmpwi cr7,r30,0
ffc07a60: 41 be 00 4c beq+ cr7,ffc07aac <ualarm+0xec>
Watchdog_Interval ticks;
tp.tv_sec = useconds / TOD_MICROSECONDS_PER_SECOND;
ffc07a64: 3c 00 00 0f lis r0,15
ffc07a68: 60 00 42 40 ori r0,r0,16960
ffc07a6c: 7d 3e 03 96 divwu r9,r30,r0
tp.tv_nsec = (useconds % TOD_MICROSECONDS_PER_SECOND) * 1000;
ffc07a70: 7c 09 01 d6 mullw r0,r9,r0
* 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;
ffc07a74: 91 21 00 08 stw r9,8(r1)
tp.tv_nsec = (useconds % TOD_MICROSECONDS_PER_SECOND) * 1000;
ticks = _Timespec_To_ticks( &tp );
ffc07a78: 38 61 00 08 addi r3,r1,8
*/
if ( useconds ) {
Watchdog_Interval ticks;
tp.tv_sec = useconds / TOD_MICROSECONDS_PER_SECOND;
tp.tv_nsec = (useconds % TOD_MICROSECONDS_PER_SECOND) * 1000;
ffc07a7c: 7f c0 f0 50 subf r30,r0,r30
ffc07a80: 1f de 03 e8 mulli r30,r30,1000
ffc07a84: 93 c1 00 0c stw r30,12(r1)
ticks = _Timespec_To_ticks( &tp );
ffc07a88: 48 00 3d 61 bl ffc0b7e8 <_Timespec_To_ticks>
if ( ticks == 0 )
ticks = 1;
_Watchdog_Insert_ticks( the_timer, _Timespec_To_ticks( &tp ) );
ffc07a8c: 38 61 00 08 addi r3,r1,8
ffc07a90: 48 00 3d 59 bl ffc0b7e8 <_Timespec_To_ticks>
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
ffc07a94: 3c 80 00 00 lis r4,0
ffc07a98: 38 84 35 74 addi r4,r4,13684
ffc07a9c: 90 64 00 0c stw r3,12(r4)
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
ffc07aa0: 3c 60 00 00 lis r3,0
ffc07aa4: 38 63 2d a8 addi r3,r3,11688
ffc07aa8: 48 00 41 9d bl ffc0bc44 <_Watchdog_Insert>
}
return remaining;
}
ffc07aac: 39 61 00 28 addi r11,r1,40
ffc07ab0: 7f e3 fb 78 mr r3,r31
ffc07ab4: 4b ff 8a e8 b ffc0059c <_restgpr_29_x>
ffc07fe4 <unlink>:
#include <rtems/seterr.h>
int unlink(
const char *path
)
{
ffc07fe4: 94 21 ff b0 stwu r1,-80(r1)
ffc07fe8: 7c 08 02 a6 mflr r0
ffc07fec: bf 41 00 38 stmw r26,56(r1)
ffc07ff0: 7c 7c 1b 78 mr r28,r3
ffc07ff4: 90 01 00 54 stw r0,84(r1)
/*
* Get the node to be unlinked. Find the parent path first.
*/
parentpathlen = rtems_filesystem_dirname ( path );
ffc07ff8: 4b ff d1 b5 bl ffc051ac <rtems_filesystem_dirname>
if ( parentpathlen == 0 )
ffc07ffc: 7c 7b 1b 79 mr. r27,r3
rtems_filesystem_get_start_loc( path, &i, &parentloc );
ffc08000: 7f 83 e3 78 mr r3,r28
* Get the node to be unlinked. Find the parent path first.
*/
parentpathlen = rtems_filesystem_dirname ( path );
if ( parentpathlen == 0 )
ffc08004: 40 82 00 18 bne- ffc0801c <unlink+0x38>
rtems_filesystem_get_start_loc( path, &i, &parentloc );
ffc08008: 38 81 00 08 addi r4,r1,8
ffc0800c: 38 a1 00 20 addi r5,r1,32
ffc08010: 4b ff e2 b9 bl ffc062c8 <rtems_filesystem_get_start_loc>
const char *name;
rtems_filesystem_location_info_t parentloc;
rtems_filesystem_location_info_t loc;
int i;
int result;
bool free_parentloc = false;
ffc08014: 3b a0 00 00 li r29,0
ffc08018: 48 00 00 28 b ffc08040 <unlink+0x5c>
parentpathlen = rtems_filesystem_dirname ( path );
if ( parentpathlen == 0 )
rtems_filesystem_get_start_loc( path, &i, &parentloc );
else {
result = rtems_filesystem_evaluate_path( path, parentpathlen,
ffc0801c: 7f 64 db 78 mr r4,r27
ffc08020: 38 a0 00 02 li r5,2
ffc08024: 38 c1 00 20 addi r6,r1,32
ffc08028: 38 e0 00 00 li r7,0
ffc0802c: 4b ff d1 25 bl ffc05150 <rtems_filesystem_evaluate_path>
RTEMS_LIBIO_PERMS_WRITE,
&parentloc,
false );
if ( result != 0 )
return -1;
ffc08030: 3b 40 ff ff li r26,-1
else {
result = rtems_filesystem_evaluate_path( path, parentpathlen,
RTEMS_LIBIO_PERMS_WRITE,
&parentloc,
false );
if ( result != 0 )
ffc08034: 2f 83 00 00 cmpwi cr7,r3,0
ffc08038: 40 9e 00 dc bne- cr7,ffc08114 <unlink+0x130> <== NEVER TAKEN
return -1;
free_parentloc = true;
ffc0803c: 3b a0 00 01 li r29,1
/*
* Start from the parent to find the node that should be under it.
*/
loc = parentloc;
ffc08040: 3b e1 00 0c addi r31,r1,12
ffc08044: 3b c1 00 20 addi r30,r1,32
ffc08048: 7c be a4 aa lswi r5,r30,20
ffc0804c: 7c bf a5 aa stswi r5,r31,20
name = path + parentpathlen;
ffc08050: 7f 9c da 14 add r28,r28,r27
name += rtems_filesystem_prefix_separators( name, strlen( name ) );
ffc08054: 7f 83 e3 78 mr r3,r28
ffc08058: 48 00 d7 61 bl ffc157b8 <strlen>
result = rtems_filesystem_evaluate_relative_path( name , strlen( name ),
0, &loc, false );
if ( result != 0 ) {
if ( free_parentloc )
rtems_filesystem_freenode( &parentloc );
return -1;
ffc0805c: 3b 40 ff ff li r26,-1
* Start from the parent to find the node that should be under it.
*/
loc = parentloc;
name = path + parentpathlen;
name += rtems_filesystem_prefix_separators( name, strlen( name ) );
ffc08060: 7c 64 1b 78 mr r4,r3
ffc08064: 7f 83 e3 78 mr r3,r28
ffc08068: 4b ff d1 8d bl ffc051f4 <rtems_filesystem_prefix_separators>
ffc0806c: 7f 9c 1a 14 add r28,r28,r3
result = rtems_filesystem_evaluate_relative_path( name , strlen( name ),
ffc08070: 7f 83 e3 78 mr r3,r28
ffc08074: 48 00 d7 45 bl ffc157b8 <strlen>
ffc08078: 38 a0 00 00 li r5,0
ffc0807c: 7c 64 1b 78 mr r4,r3
ffc08080: 7f e6 fb 78 mr r6,r31
ffc08084: 7f 83 e3 78 mr r3,r28
ffc08088: 38 e0 00 00 li r7,0
ffc0808c: 4b ff d0 41 bl ffc050cc <rtems_filesystem_evaluate_relative_path>
0, &loc, false );
if ( result != 0 ) {
ffc08090: 2f 83 00 00 cmpwi cr7,r3,0
ffc08094: 40 be 00 70 bne+ cr7,ffc08104 <unlink+0x120>
if ( free_parentloc )
rtems_filesystem_freenode( &parentloc );
return -1;
}
if ( (*loc.ops->node_type_h)( &loc ) == RTEMS_FILESYSTEM_DIRECTORY ) {
ffc08098: 81 21 00 18 lwz r9,24(r1)
ffc0809c: 7f e3 fb 78 mr r3,r31
ffc080a0: 80 09 00 10 lwz r0,16(r9)
ffc080a4: 7c 09 03 a6 mtctr r0
ffc080a8: 4e 80 04 21 bctrl
ffc080ac: 2f 83 00 01 cmpwi cr7,r3,1
ffc080b0: 40 be 00 30 bne+ cr7,ffc080e0 <unlink+0xfc>
rtems_filesystem_freenode( &loc );
ffc080b4: 7f e3 fb 78 mr r3,r31
ffc080b8: 4b ff d1 8d bl ffc05244 <rtems_filesystem_freenode>
if ( free_parentloc )
ffc080bc: 2f 9d 00 00 cmpwi cr7,r29,0
ffc080c0: 41 be 00 0c beq+ cr7,ffc080cc <unlink+0xe8>
rtems_filesystem_freenode( &parentloc );
ffc080c4: 7f c3 f3 78 mr r3,r30
ffc080c8: 4b ff d1 7d bl ffc05244 <rtems_filesystem_freenode>
rtems_set_errno_and_return_minus_one( EISDIR );
ffc080cc: 48 00 c5 71 bl ffc1463c <__errno>
ffc080d0: 38 00 00 15 li r0,21
ffc080d4: 90 03 00 00 stw r0,0(r3)
ffc080d8: 3b 40 ff ff li r26,-1
ffc080dc: 48 00 00 38 b ffc08114 <unlink+0x130>
}
result = (*loc.ops->unlink_h)( &parentloc, &loc );
ffc080e0: 81 21 00 18 lwz r9,24(r1)
ffc080e4: 7f c3 f3 78 mr r3,r30
ffc080e8: 7f e4 fb 78 mr r4,r31
ffc080ec: 80 09 00 0c lwz r0,12(r9)
ffc080f0: 7c 09 03 a6 mtctr r0
ffc080f4: 4e 80 04 21 bctrl
ffc080f8: 7c 7a 1b 78 mr r26,r3
rtems_filesystem_freenode( &loc );
ffc080fc: 7f e3 fb 78 mr r3,r31
ffc08100: 4b ff d1 45 bl ffc05244 <rtems_filesystem_freenode>
if ( free_parentloc )
ffc08104: 2f 9d 00 00 cmpwi cr7,r29,0
ffc08108: 41 be 00 0c beq+ cr7,ffc08114 <unlink+0x130>
rtems_filesystem_freenode( &parentloc );
ffc0810c: 7f c3 f3 78 mr r3,r30
ffc08110: 4b ff d1 35 bl ffc05244 <rtems_filesystem_freenode>
return result;
}
ffc08114: 39 61 00 50 addi r11,r1,80
ffc08118: 7f 43 d3 78 mr r3,r26
ffc0811c: 48 01 13 e8 b ffc19504 <_restgpr_26_x>
ffc0b060 <unmount>:
*/
int unmount(
const char *path
)
{
ffc0b060: 94 21 ff d0 stwu r1,-48(r1)
ffc0b064: 7c 08 02 a6 mflr r0
ffc0b068: bf c1 00 28 stmw r30,40(r1)
ffc0b06c: 7c 7f 1b 78 mr r31,r3
ffc0b070: 90 01 00 34 stw r0,52(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 ) )
ffc0b074: 48 01 4c e1 bl ffc1fd54 <strlen>
ffc0b078: 7c 64 1b 78 mr r4,r3
ffc0b07c: 38 a0 00 00 li r5,0
ffc0b080: 7f e3 fb 78 mr r3,r31
ffc0b084: 38 c1 00 08 addi r6,r1,8
ffc0b088: 38 e0 00 01 li r7,1
ffc0b08c: 4b ff c6 41 bl ffc076cc <rtems_filesystem_evaluate_path>
ffc0b090: 2f 83 00 00 cmpwi cr7,r3,0
ffc0b094: 40 9e 01 18 bne- cr7,ffc0b1ac <unmount+0x14c>
return -1;
mt_entry = loc.mt_entry;
ffc0b098: 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 );
ffc0b09c: 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 ){
ffc0b0a0: 80 01 00 08 lwz r0,8(r1)
ffc0b0a4: 81 3f 00 1c lwz r9,28(r31)
ffc0b0a8: 7f 89 00 00 cmpw cr7,r9,r0
ffc0b0ac: 41 be 00 14 beq+ cr7,ffc0b0c0 <unmount+0x60>
rtems_filesystem_freenode( &loc );
ffc0b0b0: 4b ff c8 0d bl ffc078bc <rtems_filesystem_freenode>
rtems_set_errno_and_return_minus_one( EACCES );
ffc0b0b4: 48 01 31 25 bl ffc1e1d8 <__errno>
ffc0b0b8: 38 00 00 0d li r0,13
ffc0b0bc: 48 00 00 4c b ffc0b108 <unmount+0xa8>
/*
* Free the loc node and just use the nodes from the mt_entry .
*/
rtems_filesystem_freenode( &loc );
ffc0b0c0: 4b ff c7 fd bl ffc078bc <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 )
ffc0b0c4: 3d 20 00 00 lis r9,0
ffc0b0c8: 81 29 27 dc lwz r9,10204(r9)
ffc0b0cc: 80 09 00 14 lwz r0,20(r9)
ffc0b0d0: 7f 80 f8 00 cmpw cr7,r0,r31
ffc0b0d4: 41 9e 00 2c beq- cr7,ffc0b100 <unmount+0xa0>
/*
* Verify there are no file systems below the path specified
*/
if ( rtems_filesystem_mount_iterate( is_fs_below_mount_point,
ffc0b0d8: 3c 60 ff c1 lis r3,-63
ffc0b0dc: 80 9f 00 2c lwz r4,44(r31)
ffc0b0e0: 38 63 b0 4c addi r3,r3,-20404
ffc0b0e4: 4b ff d1 c5 bl ffc082a8 <rtems_filesystem_mount_iterate>
ffc0b0e8: 2f 83 00 00 cmpwi cr7,r3,0
ffc0b0ec: 40 9e 00 14 bne- cr7,ffc0b100 <unmount+0xa0>
* Run the file descriptor table to determine if there are any file
* descriptors that are currently active and reference nodes in the
* file system that we are trying to unmount
*/
if ( rtems_libio_is_open_files_in_fs( mt_entry ) == 1 )
ffc0b0f0: 7f e3 fb 78 mr r3,r31
ffc0b0f4: 4b ff cb d1 bl ffc07cc4 <rtems_libio_is_open_files_in_fs>
ffc0b0f8: 2f 83 00 01 cmpwi cr7,r3,1
ffc0b0fc: 40 be 00 14 bne+ cr7,ffc0b110 <unmount+0xb0>
rtems_set_errno_and_return_minus_one( EBUSY );
ffc0b100: 48 01 30 d9 bl ffc1e1d8 <__errno>
ffc0b104: 38 00 00 10 li r0,16
ffc0b108: 90 03 00 00 stw r0,0(r3)
ffc0b10c: 48 00 00 a0 b ffc0b1ac <unmount+0x14c>
* 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 )
ffc0b110: 81 3f 00 14 lwz r9,20(r31)
ffc0b114: 7f e3 fb 78 mr r3,r31
ffc0b118: 80 09 00 28 lwz r0,40(r9)
ffc0b11c: 7c 09 03 a6 mtctr r0
ffc0b120: 4e 80 04 21 bctrl
ffc0b124: 2f 83 00 00 cmpwi cr7,r3,0
ffc0b128: 40 9e 00 84 bne- cr7,ffc0b1ac <unmount+0x14c> <== 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){
ffc0b12c: 81 3f 00 28 lwz r9,40(r31)
ffc0b130: 7f e3 fb 78 mr r3,r31
ffc0b134: 80 09 00 2c lwz r0,44(r9)
ffc0b138: 7c 09 03 a6 mtctr r0
ffc0b13c: 4e 80 04 21 bctrl
ffc0b140: 2f 83 00 00 cmpwi cr7,r3,0
ffc0b144: 41 9e 00 2c beq- cr7,ffc0b170 <unmount+0x110> <== ALWAYS TAKEN
if (( fs_mount_loc->ops->mount_h )( mt_entry ) != 0 )
ffc0b148: 81 3f 00 14 lwz r9,20(r31) <== NOT EXECUTED
ffc0b14c: 7f e3 fb 78 mr r3,r31 <== NOT EXECUTED
ffc0b150: 80 09 00 20 lwz r0,32(r9) <== NOT EXECUTED
ffc0b154: 7c 09 03 a6 mtctr r0 <== NOT EXECUTED
ffc0b158: 4e 80 04 21 bctrl <== NOT EXECUTED
rtems_fatal_error_occurred( 0 );
return -1;
ffc0b15c: 38 00 ff ff li r0,-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 )
ffc0b160: 2f 83 00 00 cmpwi cr7,r3,0 <== NOT EXECUTED
ffc0b164: 41 be 00 4c beq+ cr7,ffc0b1b0 <unmount+0x150> <== NOT EXECUTED
rtems_fatal_error_occurred( 0 );
ffc0b168: 38 60 00 00 li r3,0 <== NOT EXECUTED
ffc0b16c: 48 00 14 61 bl ffc0c5cc <rtems_fatal_error_occurred> <== NOT EXECUTED
rtems_status_code rtems_libio_set_private_env(void);
rtems_status_code rtems_libio_share_private_env(rtems_id task_id) ;
static inline void rtems_libio_lock( void )
{
rtems_semaphore_obtain( rtems_libio_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT );
ffc0b170: 3f c0 00 00 lis r30,0
ffc0b174: 80 7e 28 5c lwz r3,10332(r30)
ffc0b178: 38 80 00 00 li r4,0
ffc0b17c: 38 a0 00 00 li r5,0
ffc0b180: 48 00 0b 71 bl ffc0bcf0 <rtems_semaphore_obtain>
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
ffc0b184: 7f e3 fb 78 mr r3,r31
ffc0b188: 48 00 18 c1 bl ffc0ca48 <_Chain_Extract>
}
static inline void rtems_libio_unlock( void )
{
rtems_semaphore_release( rtems_libio_semaphore );
ffc0b18c: 80 7e 28 5c lwz r3,10332(r30)
ffc0b190: 48 00 0c 8d bl ffc0be1c <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 );
ffc0b194: 38 7f 00 08 addi r3,r31,8
ffc0b198: 4b ff c7 25 bl ffc078bc <rtems_filesystem_freenode>
free( mt_entry );
ffc0b19c: 7f e3 fb 78 mr r3,r31
ffc0b1a0: 4b ff c7 49 bl ffc078e8 <free>
return 0;
ffc0b1a4: 38 00 00 00 li r0,0
ffc0b1a8: 48 00 00 08 b ffc0b1b0 <unmount+0x150>
* 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;
ffc0b1ac: 38 00 ff ff li r0,-1
rtems_filesystem_freenode( fs_mount_loc );
free( mt_entry );
return 0;
}
ffc0b1b0: 39 61 00 30 addi r11,r1,48
ffc0b1b4: 7c 03 03 78 mr r3,r0
ffc0b1b8: 4b ff 79 3c b ffc02af4 <_restgpr_30_x>
ffc07630 <vprintk>:
*/
void vprintk(
const char *fmt,
va_list ap
)
{
ffc07630: 94 21 ff a8 stwu r1,-88(r1)
ffc07634: 7c 08 02 a6 mflr r0
ffc07638: be a1 00 2c stmw r21,44(r1)
ffc0763c: 7c 7f 1b 78 mr r31,r3
ffc07640: 7c 9e 23 78 mr r30,r4
ffc07644: 90 01 00 5c stw r0,92(r1)
unsigned_num = n;
}
toPrint[count++] = (char) unsigned_num;
for (n=maxwidth ; n > count; n-- )
BSP_output_char(lead);
ffc07648: 3f 60 00 00 lis r27,0
for (n = 0; n < count; n++) {
BSP_output_char("0123456789ABCDEF"[(int)(toPrint[count-(n+1)])]);
ffc0764c: 3e a0 ff c2 lis r21,-62
* console is not yet initialized or in ISR's.
*
* Arguments:
* as in printf: fmt - format string, ... - unnamed arguments.
*/
void vprintk(
ffc07650: 3a e1 00 08 addi r23,r1,8
char *s, *str;
str = va_arg(ap, char *);
if ( str == NULL ) {
str = "";
ffc07654: 3e c0 ff c2 lis r22,-62
void vprintk(
const char *fmt,
va_list ap
)
{
for (; *fmt != '\0'; fmt++) {
ffc07658: 48 00 03 40 b ffc07998 <vprintk+0x368>
bool minus = false;
bool sign = false;
char lead = ' ';
char c;
if (*fmt != '%') {
ffc0765c: 2f 83 00 25 cmpwi cr7,r3,37
ffc07660: 40 9e 02 08 bne- cr7,ffc07868 <vprintk+0x238>
BSP_output_char(*fmt);
continue;
}
fmt++;
if (*fmt == '0' ) {
ffc07664: 88 1f 00 01 lbz r0,1(r31)
ffc07668: 2f 80 00 30 cmpwi cr7,r0,48
ffc0766c: 41 9e 00 10 beq- cr7,ffc0767c <vprintk+0x4c>
if (*fmt != '%') {
BSP_output_char(*fmt);
continue;
}
fmt++;
ffc07670: 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 = ' ';
ffc07674: 3b 00 00 20 li r24,32
ffc07678: 48 00 00 0c b ffc07684 <vprintk+0x54>
continue;
}
fmt++;
if (*fmt == '0' ) {
lead = '0';
fmt++;
ffc0767c: 3b ff 00 02 addi r31,r31,2
BSP_output_char(*fmt);
continue;
}
fmt++;
if (*fmt == '0' ) {
lead = '0';
ffc07680: 3b 00 00 30 li r24,48
fmt++;
}
if (*fmt == '-' ) {
ffc07684: 88 1f 00 00 lbz r0,0(r31)
{
for (; *fmt != '\0'; fmt++) {
unsigned base = 0;
unsigned width = 0;
bool lflag = false;
bool minus = false;
ffc07688: 3b 20 00 00 li r25,0
fmt++;
if (*fmt == '0' ) {
lead = '0';
fmt++;
}
if (*fmt == '-' ) {
ffc0768c: 2f 80 00 2d cmpwi cr7,r0,45
ffc07690: 40 be 00 0c bne+ cr7,ffc0769c <vprintk+0x6c>
minus = true;
fmt++;
ffc07694: 3b ff 00 01 addi r31,r31,1
if (*fmt == '0' ) {
lead = '0';
fmt++;
}
if (*fmt == '-' ) {
minus = true;
ffc07698: 3b 20 00 01 li r25,1
{
for (; *fmt != '\0'; fmt++) {
unsigned base = 0;
unsigned width = 0;
bool lflag = false;
bool minus = false;
ffc0769c: 3b 80 00 00 li r28,0
ffc076a0: 48 00 00 14 b ffc076b4 <vprintk+0x84>
if (*fmt == '-' ) {
minus = true;
fmt++;
}
while (*fmt >= '0' && *fmt <= '9' ) {
width *= 10;
ffc076a4: 1f 9c 00 0a mulli r28,r28,10
width += ((unsigned) *fmt - '0');
ffc076a8: 3b 9c ff d0 addi r28,r28,-48
ffc076ac: 7f 9c 1a 14 add r28,r28,r3
fmt++;
ffc076b0: 3b ff 00 01 addi r31,r31,1
}
if (*fmt == '-' ) {
minus = true;
fmt++;
}
while (*fmt >= '0' && *fmt <= '9' ) {
ffc076b4: 88 7f 00 00 lbz r3,0(r31)
ffc076b8: 38 03 ff d0 addi r0,r3,-48
ffc076bc: 54 00 06 3e clrlwi r0,r0,24
ffc076c0: 2b 80 00 09 cmplwi cr7,r0,9
ffc076c4: 40 9d ff e0 ble+ cr7,ffc076a4 <vprintk+0x74>
width *= 10;
width += ((unsigned) *fmt - '0');
fmt++;
}
if ((c = *fmt) == 'l') {
ffc076c8: 2f 83 00 6c cmpwi cr7,r3,108
}
if (*fmt == '-' ) {
minus = true;
fmt++;
}
while (*fmt >= '0' && *fmt <= '9' ) {
ffc076cc: 7f 9a e3 78 mr r26,r28
ffc076d0: 7f eb fb 78 mr r11,r31
width *= 10;
width += ((unsigned) *fmt - '0');
fmt++;
}
if ((c = *fmt) == 'l') {
ffc076d4: 40 be 00 0c bne+ cr7,ffc076e0 <vprintk+0xb0>
lflag = true;
c = *++fmt;
ffc076d8: 88 6b 00 01 lbz r3,1(r11)
ffc076dc: 3b ff 00 01 addi r31,r31,1
}
if ( c == 'c' ) {
ffc076e0: 2f 83 00 63 cmpwi cr7,r3,99
ffc076e4: 40 be 00 40 bne+ cr7,ffc07724 <vprintk+0xf4>
/* need a cast here since va_arg() only takes fully promoted types */
char chr = (char) va_arg(ap, int);
ffc076e8: 89 7e 00 00 lbz r11,0(r30)
ffc076ec: 2b 8b 00 08 cmplwi cr7,r11,8
ffc076f0: 40 9c 00 1c bge- cr7,ffc0770c <vprintk+0xdc> <== NEVER TAKEN
ffc076f4: 81 3e 00 08 lwz r9,8(r30)
ffc076f8: 55 60 10 3a rlwinm r0,r11,2,0,29
ffc076fc: 39 6b 00 01 addi r11,r11,1
ffc07700: 7d 29 02 14 add r9,r9,r0
ffc07704: 99 7e 00 00 stb r11,0(r30)
ffc07708: 48 00 00 10 b ffc07718 <vprintk+0xe8>
ffc0770c: 81 3e 00 04 lwz r9,4(r30) <== NOT EXECUTED
ffc07710: 38 09 00 04 addi r0,r9,4 <== NOT EXECUTED
ffc07714: 90 1e 00 04 stw r0,4(r30) <== NOT EXECUTED
BSP_output_char(chr);
ffc07718: 80 1b 27 74 lwz r0,10100(r27)
ffc0771c: 88 69 00 03 lbz r3,3(r9)
ffc07720: 48 00 01 4c b ffc0786c <vprintk+0x23c>
continue;
}
if ( c == 's' ) {
ffc07724: 2f 83 00 73 cmpwi cr7,r3,115
ffc07728: 40 be 00 e8 bne+ cr7,ffc07810 <vprintk+0x1e0>
unsigned i, len;
char *s, *str;
str = va_arg(ap, char *);
ffc0772c: 89 7e 00 00 lbz r11,0(r30)
ffc07730: 2b 8b 00 08 cmplwi cr7,r11,8
ffc07734: 40 9c 00 1c bge- cr7,ffc07750 <vprintk+0x120> <== NEVER TAKEN
ffc07738: 81 3e 00 08 lwz r9,8(r30)
ffc0773c: 55 60 10 3a rlwinm r0,r11,2,0,29
ffc07740: 39 6b 00 01 addi r11,r11,1
ffc07744: 7d 29 02 14 add r9,r9,r0
ffc07748: 99 7e 00 00 stb r11,0(r30)
ffc0774c: 48 00 00 10 b ffc0775c <vprintk+0x12c>
ffc07750: 81 3e 00 04 lwz r9,4(r30) <== NOT EXECUTED
ffc07754: 38 09 00 04 addi r0,r9,4 <== NOT EXECUTED
ffc07758: 90 1e 00 04 stw r0,4(r30) <== NOT EXECUTED
ffc0775c: 83 49 00 00 lwz r26,0(r9)
if ( str == NULL ) {
ffc07760: 2f 9a 00 00 cmpwi cr7,r26,0
ffc07764: 40 be 00 08 bne+ cr7,ffc0776c <vprintk+0x13c>
str = "";
ffc07768: 3b 56 d8 13 addi r26,r22,-10221
}
/* calculate length of string */
for ( len=0, s=str ; *s ; len++, s++ )
ffc0776c: 3b a0 00 00 li r29,0
ffc07770: 48 00 00 08 b ffc07778 <vprintk+0x148>
ffc07774: 3b bd 00 01 addi r29,r29,1
ffc07778: 7c 1a e8 ae lbzx r0,r26,r29
ffc0777c: 2f 80 00 00 cmpwi cr7,r0,0
ffc07780: 40 9e ff f4 bne+ cr7,ffc07774 <vprintk+0x144>
;
/* leading spaces */
if ( !minus )
ffc07784: 2f 99 00 00 cmpwi cr7,r25,0
ffc07788: 7f b8 eb 78 mr r24,r29
ffc0778c: 41 9e 00 1c beq- cr7,ffc077a8 <vprintk+0x178>
ffc07790: 48 00 00 20 b ffc077b0 <vprintk+0x180>
for ( i=len ; i<width ; i++ )
BSP_output_char(' ');
ffc07794: 80 1b 27 74 lwz r0,10100(r27)
ffc07798: 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++ )
ffc0779c: 3b 18 00 01 addi r24,r24,1
BSP_output_char(' ');
ffc077a0: 7c 09 03 a6 mtctr r0
ffc077a4: 4e 80 04 21 bctrl
for ( len=0, s=str ; *s ; len++, s++ )
;
/* leading spaces */
if ( !minus )
for ( i=len ; i<width ; i++ )
ffc077a8: 7f 98 e0 40 cmplw cr7,r24,r28
ffc077ac: 41 9c ff e8 blt+ cr7,ffc07794 <vprintk+0x164>
BSP_output_char(' ');
/* no width option */
if (width == 0) {
ffc077b0: 2f 9c 00 00 cmpwi cr7,r28,0
ffc077b4: 40 9e 00 24 bne- cr7,ffc077d8 <vprintk+0x1a8>
width = len;
}
/* output the string */
for ( i=0 ; i<width && *str ; str++ )
ffc077b8: 2f 9d 00 00 cmpwi cr7,r29,0
ffc077bc: 41 be 00 28 beq+ cr7,ffc077e4 <vprintk+0x1b4>
ffc077c0: 7f bc eb 78 mr r28,r29
ffc077c4: 48 00 00 14 b ffc077d8 <vprintk+0x1a8>
BSP_output_char(*str);
ffc077c8: 80 1b 27 74 lwz r0,10100(r27)
if (width == 0) {
width = len;
}
/* output the string */
for ( i=0 ; i<width && *str ; str++ )
ffc077cc: 3b 5a 00 01 addi r26,r26,1
BSP_output_char(*str);
ffc077d0: 7c 09 03 a6 mtctr r0
ffc077d4: 4e 80 04 21 bctrl
if (width == 0) {
width = len;
}
/* output the string */
for ( i=0 ; i<width && *str ; str++ )
ffc077d8: 88 7a 00 00 lbz r3,0(r26)
ffc077dc: 2f 83 00 00 cmpwi cr7,r3,0
ffc077e0: 40 9e ff e8 bne+ cr7,ffc077c8 <vprintk+0x198>
BSP_output_char(*str);
/* trailing spaces */
if ( minus )
ffc077e4: 2f 99 00 00 cmpwi cr7,r25,0
ffc077e8: 41 9e 01 ac beq- cr7,ffc07994 <vprintk+0x364>
ffc077ec: 48 00 00 18 b ffc07804 <vprintk+0x1d4>
for ( i=len ; i<width ; i++ )
BSP_output_char(' ');
ffc077f0: 80 1b 27 74 lwz r0,10100(r27)
ffc077f4: 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++ )
ffc077f8: 3b bd 00 01 addi r29,r29,1
BSP_output_char(' ');
ffc077fc: 7c 09 03 a6 mtctr r0
ffc07800: 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++ )
ffc07804: 7f 9d e0 40 cmplw cr7,r29,r28
ffc07808: 41 9c ff e8 blt+ cr7,ffc077f0 <vprintk+0x1c0>
ffc0780c: 48 00 01 88 b ffc07994 <vprintk+0x364>
continue;
}
/* must be a numeric format or something unsupported */
if ( c == 'o' || c == 'O' ) {
ffc07810: 2f 83 00 6f cmpwi cr7,r3,111
ffc07814: 41 9e 00 64 beq- cr7,ffc07878 <vprintk+0x248>
ffc07818: 2f 83 00 4f cmpwi cr7,r3,79
ffc0781c: 41 9e 00 5c beq- cr7,ffc07878 <vprintk+0x248>
base = 8; sign = false;
} else if ( c == 'i' || c == 'I' ||
ffc07820: 2f 83 00 69 cmpwi cr7,r3,105
ffc07824: 41 9e 00 60 beq- cr7,ffc07884 <vprintk+0x254>
ffc07828: 2f 83 00 49 cmpwi cr7,r3,73
ffc0782c: 41 9e 00 58 beq- cr7,ffc07884 <vprintk+0x254>
ffc07830: 2f 83 00 64 cmpwi cr7,r3,100
ffc07834: 41 9e 00 50 beq- cr7,ffc07884 <vprintk+0x254>
c == 'd' || c == 'D' ) {
ffc07838: 2f 83 00 44 cmpwi cr7,r3,68
ffc0783c: 41 9e 00 48 beq- cr7,ffc07884 <vprintk+0x254>
base = 10; sign = true;
} else if ( c == 'u' || c == 'U' ) {
ffc07840: 2f 83 00 75 cmpwi cr7,r3,117
ffc07844: 41 9e 00 48 beq- cr7,ffc0788c <vprintk+0x25c>
ffc07848: 2f 83 00 55 cmpwi cr7,r3,85
ffc0784c: 41 9e 00 40 beq- cr7,ffc0788c <vprintk+0x25c>
base = 10; sign = false;
} else if ( c == 'x' || c == 'X' ) {
ffc07850: 2f 83 00 78 cmpwi cr7,r3,120
ffc07854: 41 9e 00 44 beq- cr7,ffc07898 <vprintk+0x268>
ffc07858: 2f 83 00 58 cmpwi cr7,r3,88
ffc0785c: 41 9e 00 3c beq- cr7,ffc07898 <vprintk+0x268>
base = 16; sign = false;
} else if ( c == 'p' ) {
ffc07860: 2f 83 00 70 cmpwi cr7,r3,112
ffc07864: 41 9e 00 34 beq- cr7,ffc07898 <vprintk+0x268>
base = 16; sign = false; lflag = true;
} else {
BSP_output_char(c);
ffc07868: 80 1b 27 74 lwz r0,10100(r27)
ffc0786c: 7c 09 03 a6 mtctr r0
ffc07870: 4e 80 04 21 bctrl
continue;
ffc07874: 48 00 01 20 b ffc07994 <vprintk+0x364>
continue;
}
/* must be a numeric format or something unsupported */
if ( c == 'o' || c == 'O' ) {
base = 8; sign = false;
ffc07878: 38 00 00 00 li r0,0
ffc0787c: 3b a0 00 08 li r29,8
ffc07880: 48 00 00 20 b ffc078a0 <vprintk+0x270>
} else if ( c == 'i' || c == 'I' ||
c == 'd' || c == 'D' ) {
base = 10; sign = true;
ffc07884: 38 00 00 01 li r0,1
ffc07888: 48 00 00 08 b ffc07890 <vprintk+0x260>
} else if ( c == 'u' || c == 'U' ) {
base = 10; sign = false;
ffc0788c: 38 00 00 00 li r0,0
ffc07890: 3b a0 00 0a li r29,10
ffc07894: 48 00 00 0c b ffc078a0 <vprintk+0x270>
} else if ( c == 'x' || c == 'X' ) {
base = 16; sign = false;
} else if ( c == 'p' ) {
base = 16; sign = false; lflag = true;
ffc07898: 38 00 00 00 li r0,0
ffc0789c: 3b a0 00 10 li r29,16
BSP_output_char(c);
continue;
}
printNum(
lflag ? va_arg(ap, long) : (long) va_arg(ap, int),
ffc078a0: 89 7e 00 00 lbz r11,0(r30)
ffc078a4: 2b 8b 00 08 cmplwi cr7,r11,8
ffc078a8: 40 9c 00 1c bge- cr7,ffc078c4 <vprintk+0x294>
ffc078ac: 81 5e 00 08 lwz r10,8(r30)
ffc078b0: 55 69 10 3a rlwinm r9,r11,2,0,29
ffc078b4: 39 6b 00 01 addi r11,r11,1
ffc078b8: 7d 2a 4a 14 add r9,r10,r9
ffc078bc: 99 7e 00 00 stb r11,0(r30)
} else {
BSP_output_char(c);
continue;
}
printNum(
ffc078c0: 48 00 00 10 b ffc078d0 <vprintk+0x2a0>
lflag ? va_arg(ap, long) : (long) va_arg(ap, int),
ffc078c4: 81 3e 00 04 lwz r9,4(r30)
ffc078c8: 39 69 00 04 addi r11,r9,4
ffc078cc: 91 7e 00 04 stw r11,4(r30)
unsigned long unsigned_num;
unsigned long n;
unsigned count;
char toPrint[20];
if ( sign && (num < 0) ) {
ffc078d0: 2f 80 00 00 cmpwi cr7,r0,0
} else {
BSP_output_char(c);
continue;
}
printNum(
ffc078d4: 83 29 00 00 lwz r25,0(r9)
unsigned long unsigned_num;
unsigned long n;
unsigned count;
char toPrint[20];
if ( sign && (num < 0) ) {
ffc078d8: 41 9e 00 30 beq- cr7,ffc07908 <vprintk+0x2d8>
ffc078dc: 2f 99 00 00 cmpwi cr7,r25,0
ffc078e0: 40 bc 00 28 bge+ cr7,ffc07908 <vprintk+0x2d8>
BSP_output_char('-');
ffc078e4: 80 1b 27 74 lwz r0,10100(r27)
ffc078e8: 38 60 00 2d li r3,45
unsigned_num = (unsigned long) -num;
ffc078ec: 7f 39 00 d0 neg r25,r25
unsigned long n;
unsigned count;
char toPrint[20];
if ( sign && (num < 0) ) {
BSP_output_char('-');
ffc078f0: 7c 09 03 a6 mtctr r0
ffc078f4: 4e 80 04 21 bctrl
unsigned_num = (unsigned long) -num;
if (maxwidth) maxwidth--;
ffc078f8: 2f 9c 00 00 cmpwi cr7,r28,0
ffc078fc: 41 9e 00 10 beq- cr7,ffc0790c <vprintk+0x2dc>
ffc07900: 3b 5c ff ff addi r26,r28,-1
ffc07904: 48 00 00 08 b ffc0790c <vprintk+0x2dc>
} else {
unsigned_num = (unsigned long) num;
ffc07908: 7f 9a e3 78 mr r26,r28
}
count = 0;
ffc0790c: 3b 80 00 00 li r28,0
ffc07910: 48 00 00 18 b ffc07928 <vprintk+0x2f8>
while ((n = unsigned_num / base) > 0) {
toPrint[count++] = (char) (unsigned_num - (n * base));
ffc07914: 7d 20 e9 d6 mullw r9,r0,r29
ffc07918: 7f 29 c8 50 subf r25,r9,r25
ffc0791c: 7f 3c b9 ae stbx r25,r28,r23
ffc07920: 3b 9c 00 01 addi r28,r28,1
ffc07924: 7c 19 03 78 mr r25,r0
} else {
unsigned_num = (unsigned long) num;
}
count = 0;
while ((n = unsigned_num / base) > 0) {
ffc07928: 7c 19 eb 96 divwu r0,r25,r29
ffc0792c: 2f 80 00 00 cmpwi cr7,r0,0
ffc07930: 40 9e ff e4 bne+ cr7,ffc07914 <vprintk+0x2e4>
toPrint[count++] = (char) (unsigned_num - (n * base));
unsigned_num = n;
}
toPrint[count++] = (char) unsigned_num;
ffc07934: 7d 21 e2 14 add r9,r1,r28
ffc07938: 9b 29 00 08 stb r25,8(r9)
ffc0793c: 3b 3c 00 01 addi r25,r28,1
ffc07940: 48 00 00 18 b ffc07958 <vprintk+0x328>
for (n=maxwidth ; n > count; n-- )
BSP_output_char(lead);
ffc07944: 80 1b 27 74 lwz r0,10100(r27)
ffc07948: 7f 03 c3 78 mr r3,r24
toPrint[count++] = (char) (unsigned_num - (n * base));
unsigned_num = n;
}
toPrint[count++] = (char) unsigned_num;
for (n=maxwidth ; n > count; n-- )
ffc0794c: 3b 5a ff ff addi r26,r26,-1
BSP_output_char(lead);
ffc07950: 7c 09 03 a6 mtctr r0
ffc07954: 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-- )
ffc07958: 7f 9a c8 40 cmplw cr7,r26,r25
ffc0795c: 41 9d ff e8 bgt+ cr7,ffc07944 <vprintk+0x314>
ffc07960: 3b a0 00 00 li r29,0
ffc07964: 48 00 00 28 b ffc0798c <vprintk+0x35c>
* console is not yet initialized or in ISR's.
*
* Arguments:
* as in printf: fmt - format string, ... - unnamed arguments.
*/
void vprintk(
ffc07968: 7d 57 e2 14 add r10,r23,r28
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)])]);
ffc0796c: 80 1b 27 74 lwz r0,10100(r27)
* console is not yet initialized or in ISR's.
*
* Arguments:
* as in printf: fmt - format string, ... - unnamed arguments.
*/
void vprintk(
ffc07970: 7d 3d 00 d0 neg r9,r29
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)])]);
ffc07974: 7d 2a 48 ae lbzx r9,r10,r9
ffc07978: 39 75 d8 14 addi r11,r21,-10220
ffc0797c: 7c 09 03 a6 mtctr r0
toPrint[count++] = (char) unsigned_num;
for (n=maxwidth ; n > count; n-- )
BSP_output_char(lead);
for (n = 0; n < count; n++) {
ffc07980: 3b bd 00 01 addi r29,r29,1
BSP_output_char("0123456789ABCDEF"[(int)(toPrint[count-(n+1)])]);
ffc07984: 7c 6b 48 ae lbzx r3,r11,r9
ffc07988: 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++) {
ffc0798c: 7f 9d c8 40 cmplw cr7,r29,r25
ffc07990: 41 9c ff d8 blt+ cr7,ffc07968 <vprintk+0x338>
void vprintk(
const char *fmt,
va_list ap
)
{
for (; *fmt != '\0'; fmt++) {
ffc07994: 3b ff 00 01 addi r31,r31,1
ffc07998: 88 7f 00 00 lbz r3,0(r31)
ffc0799c: 2f 83 00 00 cmpwi cr7,r3,0
ffc079a0: 40 9e fc bc bne+ cr7,ffc0765c <vprintk+0x2c>
sign,
width,
lead
);
}
}
ffc079a4: 39 61 00 58 addi r11,r1,88
ffc079a8: 4b ff 8b 74 b ffc0051c <_restgpr_21_x>
ffc1bbd8 <write>:
ssize_t write(
int fd,
const void *buffer,
size_t count
)
{
ffc1bbd8: 7c 08 02 a6 mflr r0
ffc1bbdc: 7c 2b 0b 78 mr r11,r1
ffc1bbe0: 94 21 ff f0 stwu r1,-16(r1)
ssize_t rc;
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
ffc1bbe4: 3d 40 00 00 lis r10,0
ssize_t write(
int fd,
const void *buffer,
size_t count
)
{
ffc1bbe8: 90 01 00 14 stw r0,20(r1)
ffc1bbec: 4b ff f7 61 bl ffc1b34c <_savegpr_31>
ssize_t rc;
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
ffc1bbf0: 80 0a 27 3c lwz r0,10044(r10)
ffc1bbf4: 7f 83 00 40 cmplw cr7,r3,r0
ffc1bbf8: 40 9c 00 48 bge- cr7,ffc1bc40 <write+0x68>
iop = rtems_libio_iop( fd );
ffc1bbfc: 3d 40 00 00 lis r10,0
ffc1bc00: 83 ea 27 f0 lwz r31,10224(r10)
ffc1bc04: 54 63 30 32 rlwinm r3,r3,6,0,25
ffc1bc08: 7f ff 1a 14 add r31,r31,r3
rtems_libio_check_is_open( iop );
ffc1bc0c: 80 1f 00 18 lwz r0,24(r31)
ffc1bc10: 70 0a 01 00 andi. r10,r0,256
ffc1bc14: 41 82 00 2c beq- ffc1bc40 <write+0x68>
rtems_libio_check_buffer( buffer );
ffc1bc18: 2f 84 00 00 cmpwi cr7,r4,0
ffc1bc1c: 40 be 00 10 bne+ cr7,ffc1bc2c <write+0x54> <== ALWAYS TAKEN
ffc1bc20: 4b ff 4f 95 bl ffc10bb4 <__errno> <== NOT EXECUTED
ffc1bc24: 38 00 00 16 li r0,22 <== NOT EXECUTED
ffc1bc28: 48 00 00 20 b ffc1bc48 <write+0x70> <== NOT EXECUTED
rtems_libio_check_count( count );
ffc1bc2c: 2f 85 00 00 cmpwi cr7,r5,0
ffc1bc30: 38 60 00 00 li r3,0
ffc1bc34: 41 9e 00 5c beq- cr7,ffc1bc90 <write+0xb8>
rtems_libio_check_permissions_with_error( iop, LIBIO_FLAGS_WRITE, EBADF );
ffc1bc38: 70 09 00 04 andi. r9,r0,4
ffc1bc3c: 40 a2 00 18 bne+ ffc1bc54 <write+0x7c>
ffc1bc40: 4b ff 4f 75 bl ffc10bb4 <__errno>
ffc1bc44: 38 00 00 09 li r0,9
ffc1bc48: 90 03 00 00 stw r0,0(r3)
ffc1bc4c: 38 60 ff ff li r3,-1
ffc1bc50: 48 00 00 40 b ffc1bc90 <write+0xb8>
/*
* Now process the write() request.
*/
rc = (*iop->pathinfo.handlers->write_h)( iop, buffer, count );
ffc1bc54: 81 3f 00 24 lwz r9,36(r31)
ffc1bc58: 7f e3 fb 78 mr r3,r31
ffc1bc5c: 80 09 00 0c lwz r0,12(r9)
ffc1bc60: 7c 09 03 a6 mtctr r0
ffc1bc64: 4e 80 04 21 bctrl
if ( rc > 0 )
ffc1bc68: 2c 03 00 00 cmpwi r3,0
ffc1bc6c: 40 81 00 24 ble- ffc1bc90 <write+0xb8>
iop->offset += rc;
ffc1bc70: 81 1f 00 10 lwz r8,16(r31)
ffc1bc74: 7c 6b 1b 78 mr r11,r3
ffc1bc78: 81 3f 00 14 lwz r9,20(r31)
ffc1bc7c: 7c 6a fe 70 srawi r10,r3,31
ffc1bc80: 7d 6b 48 14 addc r11,r11,r9
ffc1bc84: 7d 4a 41 14 adde r10,r10,r8
ffc1bc88: 91 5f 00 10 stw r10,16(r31)
ffc1bc8c: 91 7f 00 14 stw r11,20(r31)
return rc;
}
ffc1bc90: 39 61 00 10 addi r11,r1,16
ffc1bc94: 4b fe 48 b0 b ffc00544 <_restgpr_31_x>
ffc087d4 <writev>:
ssize_t writev(
int fd,
const struct iovec *iov,
int iovcnt
)
{
ffc087d4: 94 21 ff d8 stwu r1,-40(r1)
ffc087d8: 7c 08 02 a6 mflr r0
int bytes;
rtems_libio_t *iop;
ssize_t old;
bool all_zeros;
rtems_libio_check_fd( fd );
ffc087dc: 3d 20 00 00 lis r9,0
ssize_t writev(
int fd,
const struct iovec *iov,
int iovcnt
)
{
ffc087e0: 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 );
ffc087e4: 80 09 27 1c lwz r0,10012(r9)
ssize_t writev(
int fd,
const struct iovec *iov,
int iovcnt
)
{
ffc087e8: bf 21 00 0c stmw r25,12(r1)
ffc087ec: 7c ba 2b 78 mr r26,r5
int bytes;
rtems_libio_t *iop;
ssize_t old;
bool all_zeros;
rtems_libio_check_fd( fd );
ffc087f0: 7f 83 00 40 cmplw cr7,r3,r0
ffc087f4: 40 9c 00 28 bge- cr7,ffc0881c <writev+0x48>
iop = rtems_libio_iop( fd );
ffc087f8: 3d 20 00 00 lis r9,0
ffc087fc: 83 69 27 cc lwz r27,10188(r9)
ffc08800: 54 63 30 32 rlwinm r3,r3,6,0,25
ffc08804: 7f 7b 1a 14 add r27,r27,r3
rtems_libio_check_is_open( iop );
ffc08808: 80 1b 00 18 lwz r0,24(r27)
ffc0880c: 70 09 01 00 andi. r9,r0,256
ffc08810: 41 82 00 0c beq- ffc0881c <writev+0x48>
rtems_libio_check_permissions_with_error( iop, LIBIO_FLAGS_WRITE, EBADF );
ffc08814: 70 09 00 04 andi. r9,r0,4
ffc08818: 40 a2 00 10 bne+ ffc08828 <writev+0x54> <== ALWAYS TAKEN
ffc0881c: 48 00 8d e9 bl ffc11604 <__errno>
ffc08820: 38 00 00 09 li r0,9
ffc08824: 48 00 00 68 b ffc0888c <writev+0xb8>
/*
* Argument validation on IO vector
*/
if ( !iov )
ffc08828: 2f 84 00 00 cmpwi cr7,r4,0
ffc0882c: 41 9e 00 58 beq- cr7,ffc08884 <writev+0xb0>
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iovcnt <= 0 )
ffc08830: 2f 85 00 00 cmpwi cr7,r5,0
ffc08834: 40 9d 00 50 ble- cr7,ffc08884 <writev+0xb0>
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iovcnt > IOV_MAX )
ffc08838: 2f 85 04 00 cmpwi cr7,r5,1024
ffc0883c: 41 9d 00 48 bgt- cr7,ffc08884 <writev+0xb0> <== NEVER TAKEN
rtems_set_errno_and_return_minus_one( EINVAL );
ffc08840: 7c 9c 23 78 mr r28,r4
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iovcnt <= 0 )
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iovcnt > IOV_MAX )
ffc08844: 7c a9 03 a6 mtctr r5
ffc08848: 7c 89 23 78 mr r9,r4
ffc0884c: 38 00 00 01 li r0,1
ffc08850: 39 60 00 00 li r11,0
ffc08854: 48 00 00 08 b ffc0885c <writev+0x88>
* 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++ ) {
ffc08858: 7d 4b 53 78 mr r11,r10
/*
* 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 )
ffc0885c: 81 49 00 00 lwz r10,0(r9)
ffc08860: 2f 8a 00 00 cmpwi cr7,r10,0
ffc08864: 41 9e 00 20 beq- cr7,ffc08884 <writev+0xb0>
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iov[v].iov_len )
ffc08868: 81 49 00 04 lwz r10,4(r9)
all_zeros = false;
ffc0886c: 31 0a ff ff addic r8,r10,-1
ffc08870: 7d 08 41 10 subfe r8,r8,r8
/* check for wrap */
old = total;
total += iov[v].iov_len;
ffc08874: 7d 4a 5a 14 add r10,r10,r11
if ( total < old || total > SSIZE_MAX )
ffc08878: 7f 8a 58 00 cmpw cr7,r10,r11
*/
if ( iov[v].iov_base == 0 )
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iov[v].iov_len )
all_zeros = false;
ffc0887c: 7c 00 40 38 and r0,r0,r8
/* check for wrap */
old = total;
total += iov[v].iov_len;
if ( total < old || total > SSIZE_MAX )
ffc08880: 40 bc 00 14 bge+ cr7,ffc08894 <writev+0xc0>
rtems_set_errno_and_return_minus_one( EINVAL );
ffc08884: 48 00 8d 81 bl ffc11604 <__errno>
ffc08888: 38 00 00 16 li r0,22
ffc0888c: 90 03 00 00 stw r0,0(r3)
ffc08890: 48 00 00 90 b ffc08920 <writev+0x14c>
* 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++ ) {
ffc08894: 39 29 00 08 addi r9,r9,8
ffc08898: 42 00 ff c0 bdnz+ ffc08858 <writev+0x84>
}
/*
* A writev with all zeros is supposed to have no effect per OpenGroup.
*/
if ( all_zeros == true ) {
ffc0889c: 2f 80 00 00 cmpwi cr7,r0,0
return 0;
ffc088a0: 3b a0 00 00 li r29,0
}
/*
* A writev with all zeros is supposed to have no effect per OpenGroup.
*/
if ( all_zeros == true ) {
ffc088a4: 40 9e 00 80 bne- cr7,ffc08924 <writev+0x150>
ffc088a8: 3b 20 00 00 li r25,0
/*
* Now process the writev().
*/
for ( total=0, v=0 ; v < iovcnt ; v++ ) {
/* all zero lengths has no effect */
if ( iov[v].iov_len == 0 )
ffc088ac: 80 bc 00 04 lwz r5,4(r28)
ffc088b0: 2f 85 00 00 cmpwi cr7,r5,0
ffc088b4: 41 be 00 58 beq+ cr7,ffc0890c <writev+0x138> <== NEVER TAKEN
continue;
bytes = (*iop->pathinfo.handlers->write_h)(
ffc088b8: 81 3b 00 24 lwz r9,36(r27)
ffc088bc: 7f 63 db 78 mr r3,r27
ffc088c0: 80 9c 00 00 lwz r4,0(r28)
ffc088c4: 80 09 00 0c lwz r0,12(r9)
ffc088c8: 7c 09 03 a6 mtctr r0
ffc088cc: 4e 80 04 21 bctrl
iop,
iov[v].iov_base,
iov[v].iov_len
);
if ( bytes < 0 )
ffc088d0: 2c 03 00 00 cmpwi r3,0
ffc088d4: 41 80 00 4c blt- ffc08920 <writev+0x14c> <== NEVER TAKEN
return -1;
if ( bytes > 0 ) {
ffc088d8: 41 82 00 28 beq- ffc08900 <writev+0x12c> <== NEVER TAKEN
iop->offset += bytes;
ffc088dc: 81 5b 00 10 lwz r10,16(r27)
ffc088e0: 7c 7f 1b 78 mr r31,r3
ffc088e4: 81 7b 00 14 lwz r11,20(r27)
ffc088e8: 7c 7e fe 70 srawi r30,r3,31
total += bytes;
ffc088ec: 7f bd 1a 14 add r29,r29,r3
if ( bytes < 0 )
return -1;
if ( bytes > 0 ) {
iop->offset += bytes;
ffc088f0: 7d 6b f8 14 addc r11,r11,r31
ffc088f4: 7d 4a f1 14 adde r10,r10,r30
ffc088f8: 91 5b 00 10 stw r10,16(r27)
ffc088fc: 91 7b 00 14 stw r11,20(r27)
total += bytes;
}
if (bytes != iov[ v ].iov_len)
ffc08900: 80 1c 00 04 lwz r0,4(r28)
ffc08904: 7f 83 00 00 cmpw cr7,r3,r0
ffc08908: 40 9e 00 1c bne- cr7,ffc08924 <writev+0x150> <== NEVER TAKEN
}
/*
* Now process the writev().
*/
for ( total=0, v=0 ; v < iovcnt ; v++ ) {
ffc0890c: 3b 39 00 01 addi r25,r25,1
ffc08910: 7f 99 d0 00 cmpw cr7,r25,r26
ffc08914: 3b 9c 00 08 addi r28,r28,8
ffc08918: 40 9e ff 94 bne+ cr7,ffc088ac <writev+0xd8>
ffc0891c: 48 00 00 08 b ffc08924 <writev+0x150>
iov[v].iov_base,
iov[v].iov_len
);
if ( bytes < 0 )
return -1;
ffc08920: 3b a0 ff ff li r29,-1
if (bytes != iov[ v ].iov_len)
break;
}
return total;
}
ffc08924: 39 61 00 28 addi r11,r1,40
ffc08928: 7f a3 eb 78 mr r3,r29
ffc0892c: 4b ff 82 4c b ffc00b78 <_restgpr_25_x>