RTEMS 4.11Annotated Report
Wed Aug 29 08:16:26 2012
0200b740 <IMFS_chown>:
int IMFS_chown(
const rtems_filesystem_location_info_t *loc,
uid_t owner,
gid_t group
)
{
200b740: 9d e3 bf 98 save %sp, -104, %sp
/*
* Verify I am the owner of the node or the super user.
*/
#if defined(RTEMS_POSIX_API)
st_uid = geteuid();
200b744: 40 00 02 4e call 200c07c <geteuid>
200b748: fa 06 20 08 ld [ %i0 + 8 ], %i5
if ( ( st_uid != jnode->st_uid ) && ( st_uid != 0 ) )
200b74c: c2 17 60 3c lduh [ %i5 + 0x3c ], %g1
200b750: 91 2a 20 10 sll %o0, 0x10, %o0
200b754: 91 32 20 10 srl %o0, 0x10, %o0
200b758: 80 a2 00 01 cmp %o0, %g1
200b75c: 02 80 00 0a be 200b784 <IMFS_chown+0x44>
200b760: 80 a2 20 00 cmp %o0, 0
200b764: 22 80 00 09 be,a 200b788 <IMFS_chown+0x48> <== NEVER TAKEN
200b768: f2 37 60 3c sth %i1, [ %i5 + 0x3c ] <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EPERM );
200b76c: 40 00 10 a9 call 200fa10 <__errno>
200b770: b0 10 3f ff mov -1, %i0
200b774: 82 10 20 01 mov 1, %g1
200b778: c2 22 00 00 st %g1, [ %o0 ]
200b77c: 81 c7 e0 08 ret
200b780: 81 e8 00 00 restore
#endif
jnode->st_uid = owner;
200b784: f2 37 60 3c sth %i1, [ %i5 + 0x3c ]
jnode->st_gid = group;
200b788: f4 37 60 3e sth %i2, [ %i5 + 0x3e ]
IMFS_update_ctime( jnode );
200b78c: 90 07 bf f8 add %fp, -8, %o0
200b790: 7f ff e0 3d call 2003884 <gettimeofday>
200b794: 92 10 20 00 clr %o1
200b798: c2 07 bf f8 ld [ %fp + -8 ], %g1
200b79c: c2 27 60 48 st %g1, [ %i5 + 0x48 ]
return 0;
}
200b7a0: 81 c7 e0 08 ret
200b7a4: 91 e8 20 00 restore %g0, 0, %o0
0200589c <IMFS_dump_directory>:
*/
static void IMFS_dump_directory(
IMFS_jnode_t *the_directory,
int level
)
{
200589c: 9d e3 bf a0 save %sp, -96, %sp
the_node = the_node->next ) {
the_jnode = (IMFS_jnode_t *) the_node;
for ( i=0 ; i<=level ; i++ )
fprintf(stdout, "...." );
20058a0: 35 00 80 88 sethi %hi(0x2022000), %i2
20058a4: 39 00 80 91 sethi %hi(0x2024400), %i4
case IMFS_FIFO:
fprintf(stdout, " FIFO not printed\n" );
return;
default:
fprintf(stdout, " bad type %d\n", IMFS_type( the_jnode ) );
20058a8: 21 00 80 88 sethi %hi(0x2022000), %l0
return;
}
puts("");
20058ac: 23 00 80 88 sethi %hi(0x2022000), %l1
case IMFS_SYM_LINK:
fprintf(stdout, " links not printed\n" );
return;
case IMFS_FIFO:
fprintf(stdout, " FIFO not printed\n" );
20058b0: 25 00 80 88 sethi %hi(0x2022000), %l2
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
20058b4: fa 06 20 50 ld [ %i0 + 0x50 ], %i5
the_node = the_node->next ) {
the_jnode = (IMFS_jnode_t *) the_node;
for ( i=0 ; i<=level ; i++ )
fprintf(stdout, "...." );
20058b8: b4 16 a2 98 or %i2, 0x298, %i2
20058bc: b8 17 20 08 or %i4, 8, %i4
case IMFS_FIFO:
fprintf(stdout, " FIFO not printed\n" );
return;
default:
fprintf(stdout, " bad type %d\n", IMFS_type( the_jnode ) );
20058c0: a0 14 23 08 or %l0, 0x308, %l0
return;
}
puts("");
20058c4: a2 14 62 30 or %l1, 0x230, %l1
IMFS_assert( level >= 0 );
IMFS_assert( IMFS_is_directory( the_directory ) );
the_chain = &the_directory->info.directory.Entries;
for ( the_node = rtems_chain_first( the_chain );
20058c8: 10 80 00 4d b 20059fc <IMFS_dump_directory+0x160>
20058cc: a4 14 a2 f0 or %l2, 0x2f0, %l2
the_node = the_node->next ) {
the_jnode = (IMFS_jnode_t *) the_node;
for ( i=0 ; i<=level ; i++ )
fprintf(stdout, "...." );
20058d0: 90 10 00 1a mov %i2, %o0
20058d4: 40 00 39 31 call 2013d98 <fputs>
20058d8: b6 06 e0 01 inc %i3
20058dc: 10 80 00 03 b 20058e8 <IMFS_dump_directory+0x4c>
20058e0: c2 07 00 00 ld [ %i4 ], %g1
20058e4: c2 07 00 00 ld [ %i4 ], %g1
!rtems_chain_is_tail( the_chain, the_node );
the_node = the_node->next ) {
the_jnode = (IMFS_jnode_t *) the_node;
for ( i=0 ; i<=level ; i++ )
20058e8: 80 a6 c0 19 cmp %i3, %i1
20058ec: 04 bf ff f9 ble 20058d0 <IMFS_dump_directory+0x34>
20058f0: d2 00 60 08 ld [ %g1 + 8 ], %o1
IMFS_jnode_t *the_jnode
)
{
IMFS_assert( the_jnode );
fprintf(stdout, "%s", the_jnode->name );
20058f4: 40 00 39 29 call 2013d98 <fputs>
20058f8: 90 07 60 0c add %i5, 0xc, %o0
rtems_chain_extract_unprotected( &node->Node );
}
static inline IMFS_jnode_types_t IMFS_type( const IMFS_jnode_t *node )
{
return node->control->imfs_type;
20058fc: c2 07 60 4c ld [ %i5 + 0x4c ], %g1
2005900: d4 00 40 00 ld [ %g1 ], %o2
switch( IMFS_type( the_jnode ) ) {
2005904: 80 a2 a0 06 cmp %o2, 6
2005908: 38 80 00 2d bgu,a 20059bc <IMFS_dump_directory+0x120> <== NEVER TAKEN
200590c: c2 07 00 00 ld [ %i4 ], %g1 <== NOT EXECUTED
2005910: 95 2a a0 02 sll %o2, 2, %o2
2005914: 03 00 80 16 sethi %hi(0x2005800), %g1
2005918: 82 10 60 80 or %g1, 0x80, %g1 ! 2005880 <bsp_interrupt_handler_default+0x18>
200591c: c2 00 40 0a ld [ %g1 + %o2 ], %g1
2005920: 81 c0 40 00 jmp %g1
2005924: 01 00 00 00 nop
case IMFS_DIRECTORY:
fprintf(stdout, "/" );
2005928: c2 07 00 00 ld [ %i4 ], %g1
200592c: 90 10 20 2f mov 0x2f, %o0
2005930: 40 00 38 e6 call 2013cc8 <fputc>
2005934: d2 00 60 08 ld [ %g1 + 8 ], %o1
2005938: 30 80 00 26 b,a 20059d0 <IMFS_dump_directory+0x134>
break;
case IMFS_DEVICE:
fprintf(stdout, " (device %" PRId32 ", %" PRId32 ")",
200593c: c2 07 00 00 ld [ %i4 ], %g1
2005940: 13 00 80 88 sethi %hi(0x2022000), %o1
2005944: d0 00 60 08 ld [ %g1 + 8 ], %o0
2005948: 92 12 62 a0 or %o1, 0x2a0, %o1
200594c: 10 80 00 08 b 200596c <IMFS_dump_directory+0xd0>
2005950: d4 1f 60 50 ldd [ %i5 + 0x50 ], %o2
the_jnode->info.device.major, the_jnode->info.device.minor );
break;
case IMFS_LINEAR_FILE:
fprintf(stdout, " (file %" PRId32 " %p)",
2005954: c2 07 00 00 ld [ %i4 ], %g1
2005958: d4 07 60 54 ld [ %i5 + 0x54 ], %o2
200595c: d0 00 60 08 ld [ %g1 + 8 ], %o0
2005960: d6 07 60 58 ld [ %i5 + 0x58 ], %o3
2005964: 13 00 80 88 sethi %hi(0x2022000), %o1
2005968: 92 12 62 b8 or %o1, 0x2b8, %o1 ! 20222b8 <rtems_filesystem_table+0x172c>
200596c: 40 00 38 bb call 2013c58 <fprintf>
2005970: 01 00 00 00 nop
2005974: 30 80 00 17 b,a 20059d0 <IMFS_dump_directory+0x134>
the_jnode->info.file.indirect,
the_jnode->info.file.doubly_indirect,
the_jnode->info.file.triply_indirect
);
#else
fprintf(stdout, " (file %" PRId32 ")",
2005978: c2 07 00 00 ld [ %i4 ], %g1
200597c: d4 07 60 54 ld [ %i5 + 0x54 ], %o2
2005980: d0 00 60 08 ld [ %g1 + 8 ], %o0
2005984: 13 00 80 88 sethi %hi(0x2022000), %o1
2005988: 40 00 38 b4 call 2013c58 <fprintf>
200598c: 92 12 62 c8 or %o1, 0x2c8, %o1 ! 20222c8 <rtems_filesystem_table+0x173c>
2005990: 30 80 00 10 b,a 20059d0 <IMFS_dump_directory+0x134>
case IMFS_HARD_LINK:
fprintf(stdout, " links not printed\n" );
return;
case IMFS_SYM_LINK:
fprintf(stdout, " links not printed\n" );
2005994: 11 00 80 88 sethi %hi(0x2022000), %o0
2005998: c2 07 00 00 ld [ %i4 ], %g1
200599c: 10 80 00 04 b 20059ac <IMFS_dump_directory+0x110>
20059a0: 90 12 22 d8 or %o0, 0x2d8, %o0
return;
case IMFS_FIFO:
fprintf(stdout, " FIFO not printed\n" );
20059a4: c2 07 00 00 ld [ %i4 ], %g1
20059a8: 90 10 00 12 mov %l2, %o0
20059ac: 40 00 38 fb call 2013d98 <fputs>
20059b0: d2 00 60 08 ld [ %g1 + 8 ], %o1
}
static inline bool IMFS_is_directory( const IMFS_jnode_t *node )
{
return node->control->imfs_type == IMFS_DIRECTORY;
20059b4: 10 80 00 0a b 20059dc <IMFS_dump_directory+0x140>
20059b8: c2 07 60 4c ld [ %i5 + 0x4c ], %g1
return;
default:
fprintf(stdout, " bad type %d\n", IMFS_type( the_jnode ) );
20059bc: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED
20059c0: 40 00 38 a6 call 2013c58 <fprintf> <== NOT EXECUTED
20059c4: d0 00 60 08 ld [ %g1 + 8 ], %o0 <== NOT EXECUTED
20059c8: 10 80 00 05 b 20059dc <IMFS_dump_directory+0x140> <== NOT EXECUTED
20059cc: c2 07 60 4c ld [ %i5 + 0x4c ], %g1 <== NOT EXECUTED
return;
}
puts("");
20059d0: 40 00 3f d7 call 201592c <puts>
20059d4: 90 10 00 11 mov %l1, %o0
20059d8: c2 07 60 4c ld [ %i5 + 0x4c ], %g1
the_jnode = (IMFS_jnode_t *) the_node;
for ( i=0 ; i<=level ; i++ )
fprintf(stdout, "...." );
IMFS_print_jnode( the_jnode );
if ( IMFS_is_directory( the_jnode ) )
20059dc: c2 00 40 00 ld [ %g1 ], %g1
20059e0: 80 a0 60 00 cmp %g1, 0
20059e4: 32 80 00 06 bne,a 20059fc <IMFS_dump_directory+0x160>
20059e8: fa 07 40 00 ld [ %i5 ], %i5
IMFS_dump_directory( the_jnode, level + 1 );
20059ec: 90 10 00 1d mov %i5, %o0
20059f0: 7f ff ff ab call 200589c <IMFS_dump_directory>
20059f4: 92 06 60 01 add %i1, 1, %o1
the_chain = &the_directory->info.directory.Entries;
for ( the_node = rtems_chain_first( the_chain );
!rtems_chain_is_tail( the_chain, the_node );
the_node = the_node->next ) {
20059f8: fa 07 40 00 ld [ %i5 ], %i5
RTEMS_INLINE_ROUTINE bool _Chain_Is_tail(
const Chain_Control *the_chain,
const Chain_Node *the_node
)
{
return (the_node == _Chain_Immutable_tail( the_chain ));
20059fc: 82 06 20 54 add %i0, 0x54, %g1
IMFS_assert( level >= 0 );
IMFS_assert( IMFS_is_directory( the_directory ) );
the_chain = &the_directory->info.directory.Entries;
for ( the_node = rtems_chain_first( the_chain );
2005a00: 80 a7 40 01 cmp %i5, %g1
2005a04: 12 bf ff b8 bne 20058e4 <IMFS_dump_directory+0x48>
2005a08: b6 10 20 00 clr %i3
fprintf(stdout, "...." );
IMFS_print_jnode( the_jnode );
if ( IMFS_is_directory( the_jnode ) )
IMFS_dump_directory( the_jnode, level + 1 );
}
}
2005a0c: 81 c7 e0 08 ret
2005a10: 81 e8 00 00 restore
0200b8e4 <IMFS_eval_token>:
rtems_filesystem_eval_path_context_t *ctx,
void *arg,
const char *token,
size_t tokenlen
)
{
200b8e4: 9d e3 bf a0 save %sp, -96, %sp
rtems_filesystem_eval_path_generic_status status =
RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_DONE;
rtems_filesystem_location_info_t *currentloc =
rtems_filesystem_eval_path_get_currentloc( ctx );
IMFS_jnode_t *dir = currentloc->node_access;
200b8e8: f8 06 20 20 ld [ %i0 + 0x20 ], %i4
bool access_ok = rtems_filesystem_eval_path_check_access(
200b8ec: 90 10 00 18 mov %i0, %o0
200b8f0: d4 07 20 30 ld [ %i4 + 0x30 ], %o2
200b8f4: d6 17 20 3c lduh [ %i4 + 0x3c ], %o3
200b8f8: d8 17 20 3e lduh [ %i4 + 0x3e ], %o4
200b8fc: 40 00 02 f7 call 200c4d8 <rtems_filesystem_eval_path_check_access>
200b900: 92 10 20 01 mov 1, %o1
dir->st_mode,
dir->st_uid,
dir->st_gid
);
if ( access_ok ) {
200b904: 80 8a 20 ff btst 0xff, %o0
200b908: 12 80 00 04 bne 200b918 <IMFS_eval_token+0x34>
200b90c: 80 a6 e0 01 cmp %i3, 1
void *arg,
const char *token,
size_t tokenlen
)
{
rtems_filesystem_eval_path_generic_status status =
200b910: 81 c7 e0 08 ret
200b914: 91 e8 20 01 restore %g0, 1, %o0
static inline bool rtems_filesystem_is_current_directory(
const char *token,
size_t tokenlen
)
{
return tokenlen == 1 && token [0] == '.';
200b918: 12 80 00 06 bne 200b930 <IMFS_eval_token+0x4c>
200b91c: 82 10 20 00 clr %g1
200b920: c2 4e 80 00 ldsb [ %i2 ], %g1
200b924: 82 18 60 2e xor %g1, 0x2e, %g1
200b928: 80 a0 00 01 cmp %g0, %g1
200b92c: 82 60 3f ff subx %g0, -1, %g1
IMFS_jnode_t *dir,
const char *token,
size_t tokenlen
)
{
if ( rtems_filesystem_is_current_directory( token, tokenlen ) ) {
200b930: 80 a0 60 00 cmp %g1, 0
200b934: 12 80 00 2b bne 200b9e0 <IMFS_eval_token+0xfc>
200b938: 80 a6 e0 02 cmp %i3, 2
static inline bool rtems_filesystem_is_parent_directory(
const char *token,
size_t tokenlen
)
{
return tokenlen == 2 && token [0] == '.' && token [1] == '.';
200b93c: 12 80 00 0b bne 200b968 <IMFS_eval_token+0x84>
200b940: 80 a0 60 00 cmp %g1, 0
200b944: c4 4e 80 00 ldsb [ %i2 ], %g2
200b948: 80 a0 a0 2e cmp %g2, 0x2e
200b94c: 12 80 00 07 bne 200b968 <IMFS_eval_token+0x84>
200b950: 80 a0 60 00 cmp %g1, 0
200b954: c2 4e a0 01 ldsb [ %i2 + 1 ], %g1
200b958: 82 18 60 2e xor %g1, 0x2e, %g1
200b95c: 80 a0 00 01 cmp %g0, %g1
200b960: 82 60 3f ff subx %g0, -1, %g1
return dir;
} else {
if ( rtems_filesystem_is_parent_directory( token, tokenlen ) ) {
200b964: 80 a0 60 00 cmp %g1, 0
200b968: 22 80 00 04 be,a 200b978 <IMFS_eval_token+0x94>
200b96c: fa 07 20 50 ld [ %i4 + 0x50 ], %i5
return dir->Parent;
200b970: 10 80 00 17 b 200b9cc <IMFS_eval_token+0xe8>
200b974: fa 07 20 08 ld [ %i4 + 8 ], %i5
} else {
rtems_chain_control *entries = &dir->info.directory.Entries;
rtems_chain_node *current = rtems_chain_first( entries );
rtems_chain_node *tail = rtems_chain_tail( entries );
200b978: 10 80 00 10 b 200b9b8 <IMFS_eval_token+0xd4>
200b97c: b2 07 20 54 add %i4, 0x54, %i1
while ( current != tail ) {
IMFS_jnode_t *entry = (IMFS_jnode_t *) current;
bool match = strncmp( entry->name, token, tokenlen ) == 0
200b980: 92 10 00 1a mov %i2, %o1
200b984: 40 00 15 d2 call 20110cc <strncmp>
200b988: 94 10 00 1b mov %i3, %o2
&& entry->name [tokenlen] == '\0';
200b98c: 80 a2 20 00 cmp %o0, 0
200b990: 12 80 00 06 bne 200b9a8 <IMFS_eval_token+0xc4>
200b994: 82 10 20 00 clr %g1
200b998: 82 07 40 1b add %i5, %i3, %g1
200b99c: c2 48 60 0c ldsb [ %g1 + 0xc ], %g1
200b9a0: 80 a0 00 01 cmp %g0, %g1
200b9a4: 82 60 3f ff subx %g0, -1, %g1
if ( match ) {
200b9a8: 80 a0 60 00 cmp %g1, 0
200b9ac: 12 80 00 09 bne 200b9d0 <IMFS_eval_token+0xec>
200b9b0: 80 a7 60 00 cmp %i5, 0
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Next(
Chain_Node *the_node
)
{
return the_node->next;
200b9b4: fa 07 40 00 ld [ %i5 ], %i5
} else {
rtems_chain_control *entries = &dir->info.directory.Entries;
rtems_chain_node *current = rtems_chain_first( entries );
rtems_chain_node *tail = rtems_chain_tail( entries );
while ( current != tail ) {
200b9b8: 80 a7 40 19 cmp %i5, %i1
200b9bc: 12 bf ff f1 bne 200b980 <IMFS_eval_token+0x9c>
200b9c0: 90 07 60 0c add %i5, 0xc, %o0
rtems_filesystem_eval_path_restart( ctx, fs_root_ptr );
}
}
}
} else {
status = RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_NO_ENTRY;
200b9c4: 81 c7 e0 08 ret
200b9c8: 91 e8 20 02 restore %g0, 2, %o0
);
if ( access_ok ) {
IMFS_jnode_t *entry = IMFS_search_in_directory( dir, token, tokenlen );
if ( entry != NULL ) {
200b9cc: 80 a7 60 00 cmp %i5, 0
200b9d0: 32 80 00 06 bne,a 200b9e8 <IMFS_eval_token+0x104>
200b9d4: c2 06 20 04 ld [ %i0 + 4 ], %g1
rtems_filesystem_eval_path_restart( ctx, fs_root_ptr );
}
}
}
} else {
status = RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_NO_ENTRY;
200b9d8: 81 c7 e0 08 ret
200b9dc: 91 e8 20 02 restore %g0, 2, %o0
IMFS_jnode_t *dir,
const char *token,
size_t tokenlen
)
{
if ( rtems_filesystem_is_current_directory( token, tokenlen ) ) {
200b9e0: ba 10 00 1c mov %i4, %i5
if ( access_ok ) {
IMFS_jnode_t *entry = IMFS_search_in_directory( dir, token, tokenlen );
if ( entry != NULL ) {
bool terminal = !rtems_filesystem_eval_path_has_path( ctx );
200b9e4: c2 06 20 04 ld [ %i0 + 4 ], %g1
static inline int rtems_filesystem_eval_path_get_flags(
const rtems_filesystem_eval_path_context_t *ctx
)
{
return ctx->flags;
200b9e8: c6 06 20 10 ld [ %i0 + 0x10 ], %g3
200b9ec: 80 a0 00 01 cmp %g0, %g1
rtems_chain_extract_unprotected( &node->Node );
}
static inline IMFS_jnode_types_t IMFS_type( const IMFS_jnode_t *node )
{
return node->control->imfs_type;
200b9f0: c2 07 60 4c ld [ %i5 + 0x4c ], %g1
200b9f4: 84 60 3f ff subx %g0, -1, %g2
200b9f8: c2 00 40 00 ld [ %g1 ], %g1
static inline void rtems_filesystem_eval_path_clear_token(
rtems_filesystem_eval_path_context_t *ctx
)
{
ctx->tokenlen = 0;
200b9fc: c0 26 20 0c clr [ %i0 + 0xc ]
bool follow_sym_link = (eval_flags & RTEMS_FS_FOLLOW_SYM_LINK) != 0;
IMFS_jnode_types_t type = IMFS_type( entry );
rtems_filesystem_eval_path_clear_token( ctx );
if ( type == IMFS_HARD_LINK && (follow_hard_link || !terminal)) {
200ba00: 80 a0 60 02 cmp %g1, 2
200ba04: 12 80 00 0a bne 200ba2c <IMFS_eval_token+0x148>
200ba08: 88 10 00 02 mov %g2, %g4
200ba0c: 80 a0 a0 00 cmp %g2, 0
200ba10: 22 80 00 2b be,a 200babc <IMFS_eval_token+0x1d8>
200ba14: fa 07 60 50 ld [ %i5 + 0x50 ], %i5
200ba18: 80 88 e0 08 btst 8, %g3
200ba1c: 22 80 00 29 be,a 200bac0 <IMFS_eval_token+0x1dc>
200ba20: c2 17 20 34 lduh [ %i4 + 0x34 ], %g1
entry = entry->info.hard_link.link_node;
200ba24: 10 80 00 26 b 200babc <IMFS_eval_token+0x1d8>
200ba28: fa 07 60 50 ld [ %i5 + 0x50 ], %i5
}
if ( type == IMFS_SYM_LINK && (follow_sym_link || !terminal)) {
200ba2c: 80 a0 60 03 cmp %g1, 3
200ba30: 12 80 00 10 bne 200ba70 <IMFS_eval_token+0x18c>
200ba34: 80 a0 60 00 cmp %g1, 0
200ba38: 80 a0 a0 00 cmp %g2, 0
200ba3c: 02 80 00 04 be 200ba4c <IMFS_eval_token+0x168>
200ba40: 80 88 e0 10 btst 0x10, %g3
200ba44: 22 80 00 1f be,a 200bac0 <IMFS_eval_token+0x1dc>
200ba48: c2 17 20 34 lduh [ %i4 + 0x34 ], %g1
const char *target = entry->info.sym_link.name;
200ba4c: fa 07 60 50 ld [ %i5 + 0x50 ], %i5
rtems_filesystem_eval_path_recursive( ctx, target, strlen( target ) );
200ba50: 40 00 15 6d call 2011004 <strlen>
200ba54: 90 10 00 1d mov %i5, %o0
200ba58: 92 10 00 1d mov %i5, %o1
200ba5c: 94 10 00 08 mov %o0, %o2
200ba60: 7f ff e4 83 call 2004c6c <rtems_filesystem_eval_path_recursive>
200ba64: 90 10 00 18 mov %i0, %o0
void *arg,
const char *token,
size_t tokenlen
)
{
rtems_filesystem_eval_path_generic_status status =
200ba68: 81 c7 e0 08 ret
200ba6c: 91 e8 20 01 restore %g0, 1, %o0
IMFS_jnode_types_t type
)
{
rtems_filesystem_global_location_t **fs_root_ptr = NULL;
if ( type == IMFS_DIRECTORY ) {
200ba70: 32 80 00 14 bne,a 200bac0 <IMFS_eval_token+0x1dc>
200ba74: c2 17 20 34 lduh [ %i4 + 0x34 ], %g1
if ( node->info.directory.mt_fs != NULL ) {
200ba78: d2 07 60 5c ld [ %i5 + 0x5c ], %o1
200ba7c: 80 a2 60 00 cmp %o1, 0
200ba80: 02 80 00 0f be 200babc <IMFS_eval_token+0x1d8>
200ba84: 90 10 00 18 mov %i0, %o0
if ( !terminal ) {
status = RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_CONTINUE;
}
} else {
access_ok = rtems_filesystem_eval_path_check_access(
200ba88: d4 07 60 30 ld [ %i5 + 0x30 ], %o2
200ba8c: d6 17 60 3c lduh [ %i5 + 0x3c ], %o3
200ba90: d8 17 60 3e lduh [ %i5 + 0x3e ], %o4
{
rtems_filesystem_global_location_t **fs_root_ptr = NULL;
if ( type == IMFS_DIRECTORY ) {
if ( node->info.directory.mt_fs != NULL ) {
fs_root_ptr = &node->info.directory.mt_fs->mt_fs_root;
200ba94: b8 02 60 24 add %o1, 0x24, %i4
if ( !terminal ) {
status = RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_CONTINUE;
}
} else {
access_ok = rtems_filesystem_eval_path_check_access(
200ba98: 40 00 02 90 call 200c4d8 <rtems_filesystem_eval_path_check_access>
200ba9c: 92 10 20 01 mov 1, %o1
RTEMS_FS_PERMS_EXEC,
entry->st_mode,
entry->st_uid,
entry->st_gid
);
if ( access_ok ) {
200baa0: 80 8a 20 ff btst 0xff, %o0
200baa4: 02 80 00 04 be 200bab4 <IMFS_eval_token+0x1d0> <== NEVER TAKEN
200baa8: 90 10 00 18 mov %i0, %o0
rtems_filesystem_eval_path_restart( ctx, fs_root_ptr );
200baac: 7f ff e4 57 call 2004c08 <rtems_filesystem_eval_path_restart>
200bab0: 92 10 00 1c mov %i4, %o1
void *arg,
const char *token,
size_t tokenlen
)
{
rtems_filesystem_eval_path_generic_status status =
200bab4: 81 c7 e0 08 ret
200bab8: 91 e8 20 01 restore %g0, 1, %o0
} else {
rtems_filesystem_global_location_t **fs_root_ptr =
IMFS_is_mount_point( entry, type );
if ( fs_root_ptr == NULL ) {
--dir->reference_count;
200babc: c2 17 20 34 lduh [ %i4 + 0x34 ], %g1
200bac0: 82 00 7f ff add %g1, -1, %g1
200bac4: c2 37 20 34 sth %g1, [ %i4 + 0x34 ]
++entry->reference_count;
200bac8: c2 17 60 34 lduh [ %i5 + 0x34 ], %g1
200bacc: 82 00 60 01 inc %g1
200bad0: c2 37 60 34 sth %g1, [ %i5 + 0x34 ]
static inline void IMFS_Set_handlers( rtems_filesystem_location_info_t *loc )
{
IMFS_jnode_t *node = (IMFS_jnode_t *) loc->node_access;
loc->handlers = node->control->handlers;
200bad4: c2 07 60 4c ld [ %i5 + 0x4c ], %g1
currentloc->node_access = entry;
200bad8: fa 26 20 20 st %i5, [ %i0 + 0x20 ]
200badc: c2 00 60 04 ld [ %g1 + 4 ], %g1
200bae0: c2 26 20 28 st %g1, [ %i0 + 0x28 ]
void *arg,
const char *token,
size_t tokenlen
)
{
rtems_filesystem_eval_path_generic_status status =
200bae4: b0 09 20 ff and %g4, 0xff, %i0
status = RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_NO_ENTRY;
}
}
return status;
}
200bae8: 81 c7 e0 08 ret
200baec: 81 e8 00 00 restore
0200bb08 <IMFS_fchmod>:
int IMFS_fchmod(
const rtems_filesystem_location_info_t *loc,
mode_t mode
)
{
200bb08: 9d e3 bf 98 save %sp, -104, %sp
/*
* Verify I am the owner of the node or the super user.
*/
#if defined(RTEMS_POSIX_API)
st_uid = geteuid();
200bb0c: 40 00 01 5c call 200c07c <geteuid>
200bb10: fa 06 20 08 ld [ %i0 + 8 ], %i5
if ( ( st_uid != jnode->st_uid ) && ( st_uid != 0 ) )
200bb14: c2 17 60 3c lduh [ %i5 + 0x3c ], %g1
200bb18: 91 2a 20 10 sll %o0, 0x10, %o0
200bb1c: 91 32 20 10 srl %o0, 0x10, %o0
200bb20: 80 a2 00 01 cmp %o0, %g1
200bb24: 02 80 00 0a be 200bb4c <IMFS_fchmod+0x44>
200bb28: 80 a2 20 00 cmp %o0, 0
200bb2c: 22 80 00 09 be,a 200bb50 <IMFS_fchmod+0x48> <== NEVER TAKEN
200bb30: c2 07 60 30 ld [ %i5 + 0x30 ], %g1 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EPERM );
200bb34: 40 00 0f b7 call 200fa10 <__errno>
200bb38: b0 10 3f ff mov -1, %i0
200bb3c: 82 10 20 01 mov 1, %g1
200bb40: c2 22 00 00 st %g1, [ %o0 ]
200bb44: 81 c7 e0 08 ret
200bb48: 81 e8 00 00 restore
/*
* 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);
200bb4c: c2 07 60 30 ld [ %i5 + 0x30 ], %g1
jnode->st_mode |= mode & (S_IRWXU | S_IRWXG | S_IRWXO | S_ISUID | S_ISGID | S_ISVTX);
IMFS_update_ctime( jnode );
200bb50: 90 07 bf f8 add %fp, -8, %o0
/*
* 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);
200bb54: 82 08 70 00 and %g1, -4096, %g1
jnode->st_mode |= mode & (S_IRWXU | S_IRWXG | S_IRWXO | S_ISUID | S_ISGID | S_ISVTX);
IMFS_update_ctime( jnode );
200bb58: 92 10 20 00 clr %o1
/*
* 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);
jnode->st_mode |= mode & (S_IRWXU | S_IRWXG | S_IRWXO | S_ISUID | S_ISGID | S_ISVTX);
200bb5c: b2 0e 6f ff and %i1, 0xfff, %i1
200bb60: b2 16 40 01 or %i1, %g1, %i1
IMFS_update_ctime( jnode );
200bb64: 7f ff df 48 call 2003884 <gettimeofday>
200bb68: f2 27 60 30 st %i1, [ %i5 + 0x30 ]
200bb6c: c2 07 bf f8 ld [ %fp + -8 ], %g1
200bb70: c2 27 60 48 st %g1, [ %i5 + 0x48 ]
return 0;
}
200bb74: 81 c7 e0 08 ret
200bb78: 91 e8 20 00 restore %g0, 0, %o0
02003ab0 <IMFS_fifo_write>:
static ssize_t IMFS_fifo_write(
rtems_libio_t *iop,
const void *buffer,
size_t count
)
{
2003ab0: 9d e3 bf 98 save %sp, -104, %sp
IMFS_jnode_t *jnode = iop->pathinfo.node_access;
2003ab4: fa 06 20 1c ld [ %i0 + 0x1c ], %i5
int err = pipe_write(JNODE2PIPE(jnode), buffer, count, iop);
2003ab8: 96 10 00 18 mov %i0, %o3
2003abc: d0 07 60 50 ld [ %i5 + 0x50 ], %o0
2003ac0: 92 10 00 19 mov %i1, %o1
2003ac4: 40 00 2a 69 call 200e468 <pipe_write>
2003ac8: 94 10 00 1a mov %i2, %o2
if (err > 0) {
2003acc: b0 92 20 00 orcc %o0, 0, %i0
2003ad0: 04 80 00 09 ble 2003af4 <IMFS_fifo_write+0x44>
2003ad4: 90 07 bf f8 add %fp, -8, %o0
IMFS_mtime_ctime_update(jnode);
2003ad8: 40 00 04 15 call 2004b2c <gettimeofday>
2003adc: 92 10 20 00 clr %o1
2003ae0: c2 07 bf f8 ld [ %fp + -8 ], %g1
2003ae4: c2 27 60 44 st %g1, [ %i5 + 0x44 ]
2003ae8: c2 27 60 48 st %g1, [ %i5 + 0x48 ]
2003aec: 81 c7 e0 08 ret
2003af0: 81 e8 00 00 restore
}
IMFS_FIFO_RETURN(err);
2003af4: 80 a6 20 00 cmp %i0, 0
2003af8: 02 80 00 06 be 2003b10 <IMFS_fifo_write+0x60> <== NEVER TAKEN
2003afc: 01 00 00 00 nop
2003b00: 40 00 37 c2 call 2011a08 <__errno>
2003b04: b0 20 00 18 neg %i0
2003b08: f0 22 00 00 st %i0, [ %o0 ]
2003b0c: b0 10 3f ff mov -1, %i0
}
2003b10: 81 c7 e0 08 ret
2003b14: 81 e8 00 00 restore
0200bb7c <IMFS_fsunmount>:
((IMFS_jnode_t *)( rtems_chain_head( jnode_get_control( jnode ) )->next))
void IMFS_fsunmount(
rtems_filesystem_mount_table_entry_t *temp_mt_entry
)
{
200bb7c: 9d e3 bf 88 save %sp, -120, %sp
/*
* Traverse tree that starts at the mt_fs_root and deallocate memory
* associated memory space
*/
loc = temp_mt_entry->mt_fs_root->location;
200bb80: f6 06 20 24 ld [ %i0 + 0x24 ], %i3
200bb84: b8 07 bf e8 add %fp, -24, %i4
200bb88: 92 10 00 1b mov %i3, %o1
200bb8c: 90 10 00 1c mov %i4, %o0
200bb90: 40 00 11 e7 call 201032c <memcpy>
200bb94: 94 10 20 18 mov 0x18, %o2
jnode = (IMFS_jnode_t *)loc.node_access;
200bb98: fa 07 bf f0 ld [ %fp + -16 ], %i5
/*
* Set this to null to indicate that it is being unmounted.
*/
temp_mt_entry->mt_fs_root->location.node_access = NULL;
200bb9c: c0 26 e0 08 clr [ %i3 + 8 ]
200bba0: b6 10 00 1c mov %i4, %i3
200bba4: c2 07 60 4c ld [ %i5 + 0x4c ], %g1
do {
next = jnode->Parent;
200bba8: f8 07 60 08 ld [ %i5 + 8 ], %i4
200bbac: c4 00 60 04 ld [ %g1 + 4 ], %g2
loc.node_access = (void *)jnode;
IMFS_Set_handlers( &loc );
if ( !IMFS_is_directory( jnode ) || jnode_has_no_children( jnode ) ) {
200bbb0: c2 00 40 00 ld [ %g1 ], %g1
temp_mt_entry->mt_fs_root->location.node_access = NULL;
do {
next = jnode->Parent;
loc.node_access = (void *)jnode;
200bbb4: fa 27 bf f0 st %i5, [ %fp + -16 ]
IMFS_Set_handlers( &loc );
if ( !IMFS_is_directory( jnode ) || jnode_has_no_children( jnode ) ) {
200bbb8: 80 a0 60 00 cmp %g1, 0
200bbbc: 12 80 00 07 bne 200bbd8 <IMFS_fsunmount+0x5c>
200bbc0: c4 27 bf f8 st %g2, [ %fp + -8 ]
200bbc4: c4 07 60 50 ld [ %i5 + 0x50 ], %g2
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
200bbc8: 82 07 60 54 add %i5, 0x54, %g1
200bbcc: 80 a0 80 01 cmp %g2, %g1
200bbd0: 32 80 00 10 bne,a 200bc10 <IMFS_fsunmount+0x94>
200bbd4: c2 07 60 4c ld [ %i5 + 0x4c ], %g1
result = IMFS_rmnod( NULL, &loc );
200bbd8: 90 10 20 00 clr %o0
200bbdc: 7f ff dd b1 call 20032a0 <IMFS_rmnod>
200bbe0: 92 10 00 1b mov %i3, %o1
if ( result != 0 )
200bbe4: 80 a2 20 00 cmp %o0, 0
200bbe8: 02 80 00 04 be 200bbf8 <IMFS_fsunmount+0x7c> <== ALWAYS TAKEN
200bbec: 11 37 ab 6f sethi %hi(0xdeadbc00), %o0
rtems_fatal_error_occurred( 0xdeadbeef );
200bbf0: 7f ff f1 02 call 2007ff8 <rtems_fatal_error_occurred> <== NOT EXECUTED
200bbf4: 90 12 22 ef or %o0, 0x2ef, %o0 ! deadbeef <RAM_END+0xdc6dbeef><== NOT EXECUTED
IMFS_node_destroy( jnode );
200bbf8: 7f ff dc d8 call 2002f58 <IMFS_node_destroy>
200bbfc: 90 10 00 1d mov %i5, %o0
jnode = next;
}
if ( jnode != NULL ) {
200bc00: 80 a7 20 00 cmp %i4, 0
200bc04: 02 80 00 0e be 200bc3c <IMFS_fsunmount+0xc0>
200bc08: ba 10 00 1c mov %i4, %i5
return node->control->imfs_type;
}
static inline bool IMFS_is_directory( const IMFS_jnode_t *node )
{
return node->control->imfs_type == IMFS_DIRECTORY;
200bc0c: c2 07 60 4c ld [ %i5 + 0x4c ], %g1
if ( IMFS_is_directory( jnode ) ) {
200bc10: c2 00 40 00 ld [ %g1 ], %g1
200bc14: 80 a0 60 00 cmp %g1, 0
200bc18: 32 bf ff e4 bne,a 200bba8 <IMFS_fsunmount+0x2c> <== NEVER TAKEN
200bc1c: c2 07 60 4c ld [ %i5 + 0x4c ], %g1 <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_head( the_chain )->next;
200bc20: c2 07 60 50 ld [ %i5 + 0x50 ], %g1
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
200bc24: 84 07 60 54 add %i5, 0x54, %g2
if ( jnode_has_children( jnode ) )
200bc28: 80 a0 40 02 cmp %g1, %g2
200bc2c: 02 bf ff de be 200bba4 <IMFS_fsunmount+0x28>
200bc30: 80 a0 60 00 cmp %g1, 0
jnode = jnode_get_first_child( jnode );
}
}
} while (jnode != NULL);
200bc34: 12 bf ff dc bne 200bba4 <IMFS_fsunmount+0x28> <== ALWAYS TAKEN
200bc38: ba 10 00 01 mov %g1, %i5
200bc3c: 81 c7 e0 08 ret
200bc40: 81 e8 00 00 restore
02002e4c <IMFS_initialize_support>:
int IMFS_initialize_support(
rtems_filesystem_mount_table_entry_t *mt_entry,
const rtems_filesystem_operations_table *op_table,
const IMFS_node_control *const node_controls [IMFS_TYPE_COUNT]
)
{
2002e4c: 9d e3 bf a0 save %sp, -96, %sp
static int imfs_instance;
int rv = 0;
IMFS_fs_info_t *fs_info = calloc( 1, sizeof( *fs_info ) );
2002e50: 90 10 20 01 mov 1, %o0
2002e54: 40 00 01 ae call 200350c <calloc>
2002e58: 92 10 20 24 mov 0x24, %o1
if ( fs_info != NULL ) {
2002e5c: ba 92 20 00 orcc %o0, 0, %i5
2002e60: 02 80 00 24 be 2002ef0 <IMFS_initialize_support+0xa4>
2002e64: 03 00 80 75 sethi %hi(0x201d400), %g1
IMFS_jnode_t *root_node;
fs_info->instance = imfs_instance++;
2002e68: c4 00 61 cc ld [ %g1 + 0x1cc ], %g2 ! 201d5cc <imfs_instance.6564>
memcpy(
2002e6c: 92 10 00 1a mov %i2, %o1
IMFS_fs_info_t *fs_info = calloc( 1, sizeof( *fs_info ) );
if ( fs_info != NULL ) {
IMFS_jnode_t *root_node;
fs_info->instance = imfs_instance++;
2002e70: c4 27 40 00 st %g2, [ %i5 ]
2002e74: 84 00 a0 01 inc %g2
memcpy(
2002e78: 94 10 20 1c mov 0x1c, %o2
IMFS_fs_info_t *fs_info = calloc( 1, sizeof( *fs_info ) );
if ( fs_info != NULL ) {
IMFS_jnode_t *root_node;
fs_info->instance = imfs_instance++;
2002e7c: c4 20 61 cc st %g2, [ %g1 + 0x1cc ]
memcpy(
2002e80: 40 00 35 2b call 201032c <memcpy>
2002e84: 90 07 60 08 add %i5, 8, %o0
fs_info->node_controls,
node_controls,
sizeof( fs_info->node_controls )
);
root_node = IMFS_allocate_node(
2002e88: d2 07 60 08 ld [ %i5 + 8 ], %o1
2002e8c: 90 10 00 1d mov %i5, %o0
2002e90: 15 00 80 6c sethi %hi(0x201b000), %o2
2002e94: 96 10 20 00 clr %o3
2002e98: 94 12 a0 f0 or %o2, 0xf0, %o2
2002e9c: 19 00 00 10 sethi %hi(0x4000), %o4
2002ea0: 9a 10 20 00 clr %o5
2002ea4: 40 00 22 41 call 200b7a8 <IMFS_allocate_node>
2002ea8: 98 13 21 ed or %o4, 0x1ed, %o4
"",
0,
(S_IFDIR | 0755),
NULL
);
if ( root_node != NULL ) {
2002eac: 80 a2 20 00 cmp %o0, 0
2002eb0: 02 80 00 10 be 2002ef0 <IMFS_initialize_support+0xa4> <== NEVER TAKEN
2002eb4: 03 00 80 6e sethi %hi(0x201b800), %g1
static inline void IMFS_Set_handlers( rtems_filesystem_location_info_t *loc )
{
IMFS_jnode_t *node = (IMFS_jnode_t *) loc->node_access;
loc->handlers = node->control->handlers;
2002eb8: c4 02 20 4c ld [ %o0 + 0x4c ], %g2
mt_entry->fs_info = fs_info;
mt_entry->ops = op_table;
mt_entry->pathconf_limits_and_options = &IMFS_LIMITS_AND_OPTIONS;
2002ebc: 82 10 61 dc or %g1, 0x1dc, %g1
2002ec0: c4 00 a0 04 ld [ %g2 + 4 ], %g2
2002ec4: c2 26 20 2c st %g1, [ %i0 + 0x2c ]
mt_entry->mt_fs_root->location.node_access = root_node;
2002ec8: c2 06 20 24 ld [ %i0 + 0x24 ], %g1
0,
(S_IFDIR | 0755),
NULL
);
if ( root_node != NULL ) {
mt_entry->fs_info = fs_info;
2002ecc: fa 26 20 08 st %i5, [ %i0 + 8 ]
mt_entry->ops = op_table;
2002ed0: f2 26 20 0c st %i1, [ %i0 + 0xc ]
2002ed4: c4 20 60 10 st %g2, [ %g1 + 0x10 ]
mt_entry->pathconf_limits_and_options = &IMFS_LIMITS_AND_OPTIONS;
mt_entry->mt_fs_root->location.node_access = root_node;
2002ed8: d0 20 60 08 st %o0, [ %g1 + 8 ]
errno = ENOMEM;
rv = -1;
}
if ( rv == 0 ) {
IMFS_determine_bytes_per_block(
2002edc: 86 10 20 06 mov 6, %g3
2002ee0: 03 00 80 73 sethi %hi(0x201cc00), %g1
int bit_mask;
/*
* check, whether requested bytes per block is valid
*/
for (bit_mask = 16; !is_valid && (bit_mask <= 512); bit_mask <<= 1) {
2002ee4: 84 10 20 10 mov 0x10, %g2
errno = ENOMEM;
rv = -1;
}
if ( rv == 0 ) {
IMFS_determine_bytes_per_block(
2002ee8: 10 80 00 08 b 2002f08 <IMFS_initialize_support+0xbc>
2002eec: c2 00 62 1c ld [ %g1 + 0x21c ], %g1
} else {
errno = ENOMEM;
rv = -1;
}
} else {
errno = ENOMEM;
2002ef0: 40 00 32 c8 call 200fa10 <__errno>
2002ef4: b0 10 3f ff mov -1, %i0
2002ef8: 82 10 20 0c mov 0xc, %g1
2002efc: c2 22 00 00 st %g1, [ %o0 ]
2002f00: 81 c7 e0 08 ret
2002f04: 81 e8 00 00 restore
/*
* check, whether requested bytes per block is valid
*/
for (bit_mask = 16; !is_valid && (bit_mask <= 512); bit_mask <<= 1) {
if (bit_mask == requested_bytes_per_block) {
2002f08: 80 a0 80 01 cmp %g2, %g1
2002f0c: 22 80 00 09 be,a 2002f30 <IMFS_initialize_support+0xe4>
2002f10: 05 00 80 75 sethi %hi(0x201d400), %g2
is_valid = true;
break;
}
if(bit_mask > requested_bytes_per_block)
2002f14: 34 80 00 06 bg,a 2002f2c <IMFS_initialize_support+0xe0>
2002f18: 82 10 20 80 mov 0x80, %g1
int bit_mask;
/*
* check, whether requested bytes per block is valid
*/
for (bit_mask = 16; !is_valid && (bit_mask <= 512); bit_mask <<= 1) {
2002f1c: 86 80 ff ff addcc %g3, -1, %g3
2002f20: 12 bf ff fa bne 2002f08 <IMFS_initialize_support+0xbc> <== ALWAYS TAKEN
2002f24: 85 28 a0 01 sll %g2, 1, %g2
if(bit_mask > requested_bytes_per_block)
break;
}
*dest_bytes_per_block = ((is_valid)
? requested_bytes_per_block
: default_bytes_per_block);
2002f28: 82 10 20 80 mov 0x80, %g1 <== NOT EXECUTED
break;
}
if(bit_mask > requested_bytes_per_block)
break;
}
*dest_bytes_per_block = ((is_valid)
2002f2c: 05 00 80 75 sethi %hi(0x201d400), %g2
2002f30: c2 20 a1 c8 st %g1, [ %g2 + 0x1c8 ] ! 201d5c8 <imfs_memfile_bytes_per_block>
2002f34: b0 10 20 00 clr %i0
IMFS_MEMFILE_DEFAULT_BYTES_PER_BLOCK
);
}
return rv;
}
2002f38: 81 c7 e0 08 ret
2002f3c: 81 e8 00 00 restore
02004a90 <IMFS_make_generic_node>:
const char *path,
mode_t mode,
const IMFS_node_control *node_control,
void *context
)
{
2004a90: 9d e3 bf 48 save %sp, -184, %sp
int rv = 0;
mode &= ~rtems_filesystem_umask;
2004a94: 03 00 80 85 sethi %hi(0x2021400), %g1
2004a98: c2 00 62 c4 ld [ %g1 + 0x2c4 ], %g1 ! 20216c4 <rtems_current_user_env>
switch (mode & S_IFMT) {
2004a9c: 05 00 00 08 sethi %hi(0x2000), %g2
void *context
)
{
int rv = 0;
mode &= ~rtems_filesystem_umask;
2004aa0: c2 00 60 08 ld [ %g1 + 8 ], %g1
2004aa4: b2 2e 40 01 andn %i1, %g1, %i1
switch (mode & S_IFMT) {
2004aa8: 03 00 00 3c sethi %hi(0xf000), %g1
2004aac: 82 0e 40 01 and %i1, %g1, %g1
2004ab0: 80 a0 40 02 cmp %g1, %g2
2004ab4: 22 80 00 3a be,a 2004b9c <IMFS_make_generic_node+0x10c>
2004ab8: c2 06 80 00 ld [ %i2 ], %g1
2004abc: 38 80 00 04 bgu,a 2004acc <IMFS_make_generic_node+0x3c> <== ALWAYS TAKEN
2004ac0: 05 00 00 18 sethi %hi(0x6000), %g2
2004ac4: 10 80 00 05 b 2004ad8 <IMFS_make_generic_node+0x48> <== NOT EXECUTED
2004ac8: 05 00 00 04 sethi %hi(0x1000), %g2 <== NOT EXECUTED
2004acc: 80 a0 40 02 cmp %g1, %g2
2004ad0: 02 80 00 32 be 2004b98 <IMFS_make_generic_node+0x108>
2004ad4: 05 00 00 20 sethi %hi(0x8000), %g2
2004ad8: 80 a0 40 02 cmp %g1, %g2
2004adc: 22 80 00 30 be,a 2004b9c <IMFS_make_generic_node+0x10c> <== NEVER TAKEN
2004ae0: c2 06 80 00 ld [ %i2 ], %g1 <== NOT EXECUTED
2004ae4: 30 80 00 27 b,a 2004b80 <IMFS_make_generic_node+0xf0>
if ( node_control->imfs_type == IMFS_GENERIC ) {
rtems_filesystem_eval_path_context_t ctx;
int eval_flags = RTEMS_FS_FOLLOW_LINK
| RTEMS_FS_MAKE
| RTEMS_FS_EXCLUSIVE;
const rtems_filesystem_location_info_t *currentloc =
2004ae8: 94 10 20 78 mov 0x78, %o2
2004aec: 40 00 08 11 call 2006b30 <rtems_filesystem_eval_path_start>
2004af0: 90 07 bf c8 add %fp, -56, %o0
rtems_filesystem_eval_path_start( &ctx, path, eval_flags );
if ( IMFS_is_imfs_instance( currentloc ) ) {
2004af4: 7f ff ff d5 call 2004a48 <IMFS_is_imfs_instance>
2004af8: ba 10 00 08 mov %o0, %i5
2004afc: 80 8a 20 ff btst 0xff, %o0
2004b00: 02 80 00 19 be 2004b64 <IMFS_make_generic_node+0xd4>
2004b04: 90 07 bf c8 add %fp, -56, %o0
IMFS_types_union info;
IMFS_jnode_t *new_node;
info.generic.context = context;
new_node = IMFS_create_node_with_control(
2004b08: d4 1f bf d0 ldd [ %fp + -48 ], %o2
if ( IMFS_is_imfs_instance( currentloc ) ) {
IMFS_types_union info;
IMFS_jnode_t *new_node;
info.generic.context = context;
2004b0c: f6 27 bf b0 st %i3, [ %fp + -80 ]
new_node = IMFS_create_node_with_control(
2004b10: 90 10 00 1d mov %i5, %o0
2004b14: 92 10 00 1a mov %i2, %o1
2004b18: 98 10 00 19 mov %i1, %o4
2004b1c: 9a 07 bf b0 add %fp, -80, %o5
2004b20: 40 00 2d 48 call 2010040 <IMFS_create_node_with_control>
2004b24: b0 10 3f ff mov -1, %i0
rtems_filesystem_eval_path_get_tokenlen( &ctx ),
mode,
&info
);
if ( new_node != NULL ) {
2004b28: 80 a2 20 00 cmp %o0, 0
2004b2c: 02 80 00 11 be 2004b70 <IMFS_make_generic_node+0xe0>
2004b30: 92 10 20 00 clr %o1
IMFS_jnode_t *parent = currentloc->node_access;
2004b34: fa 07 60 08 ld [ %i5 + 8 ], %i5
IMFS_update_ctime( parent );
2004b38: 40 00 02 93 call 2005584 <gettimeofday>
2004b3c: 90 07 bf a8 add %fp, -88, %o0
2004b40: c2 07 bf a8 ld [ %fp + -88 ], %g1
IMFS_update_mtime( parent );
2004b44: 90 07 bf a8 add %fp, -88, %o0
);
if ( new_node != NULL ) {
IMFS_jnode_t *parent = currentloc->node_access;
IMFS_update_ctime( parent );
2004b48: c2 27 60 48 st %g1, [ %i5 + 0x48 ]
IMFS_update_mtime( parent );
2004b4c: 40 00 02 8e call 2005584 <gettimeofday>
2004b50: 92 10 20 00 clr %o1
2004b54: c2 07 bf a8 ld [ %fp + -88 ], %g1
2004b58: b0 10 20 00 clr %i0
2004b5c: 10 80 00 05 b 2004b70 <IMFS_make_generic_node+0xe0>
2004b60: c2 27 60 44 st %g1, [ %i5 + 0x44 ]
} else {
rv = -1;
}
} else {
rtems_filesystem_eval_path_error( &ctx, ENOTSUP );
2004b64: 92 10 20 86 mov 0x86, %o1
2004b68: 40 00 07 5c call 20068d8 <rtems_filesystem_eval_path_error>
2004b6c: b0 10 3f ff mov -1, %i0
rv = -1;
}
rtems_filesystem_eval_path_cleanup( &ctx );
2004b70: 40 00 08 2c call 2006c20 <rtems_filesystem_eval_path_cleanup>
2004b74: 90 07 bf c8 add %fp, -56, %o0
2004b78: 81 c7 e0 08 ret
2004b7c: 81 e8 00 00 restore
} else {
errno = EINVAL;
2004b80: 40 00 3d 83 call 201418c <__errno>
2004b84: b0 10 3f ff mov -1, %i0
2004b88: 82 10 20 16 mov 0x16, %g1
2004b8c: c2 22 00 00 st %g1, [ %o0 ]
2004b90: 81 c7 e0 08 ret
2004b94: 81 e8 00 00 restore
rv = -1;
break;
}
if ( rv == 0 ) {
if ( node_control->imfs_type == IMFS_GENERIC ) {
2004b98: c2 06 80 00 ld [ %i2 ], %g1
2004b9c: 80 a0 60 07 cmp %g1, 7
2004ba0: 02 bf ff d2 be 2004ae8 <IMFS_make_generic_node+0x58>
2004ba4: 92 10 00 18 mov %i0, %o1
2004ba8: 30 bf ff f6 b,a 2004b80 <IMFS_make_generic_node+0xf0>
0200e3c4 <IMFS_memfile_addblock>:
*/
MEMFILE_STATIC int IMFS_memfile_addblock(
IMFS_jnode_t *the_jnode,
unsigned int block
)
{
200e3c4: 9d e3 bf a0 save %sp, -96, %sp
IMFS_assert( IMFS_type( the_jnode ) == IMFS_MEMORY_FILE );
/*
* Obtain the pointer for the specified block number
*/
block_entry_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 1 );
200e3c8: 94 10 20 01 mov 1, %o2
200e3cc: 90 10 00 18 mov %i0, %o0
200e3d0: 7f ff fe d6 call 200df28 <IMFS_memfile_get_block_pointer>
200e3d4: 92 10 00 19 mov %i1, %o1
if ( *block_entry_ptr )
200e3d8: c2 02 00 00 ld [ %o0 ], %g1
IMFS_assert( IMFS_type( the_jnode ) == IMFS_MEMORY_FILE );
/*
* Obtain the pointer for the specified block number
*/
block_entry_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 1 );
200e3dc: ba 10 00 08 mov %o0, %i5
if ( *block_entry_ptr )
200e3e0: 80 a0 60 00 cmp %g1, 0
200e3e4: 12 80 00 08 bne 200e404 <IMFS_memfile_addblock+0x40>
200e3e8: b0 10 20 00 clr %i0
return 0;
/*
* There is no memory for this block number so allocate it.
*/
memory = memfile_alloc_block();
200e3ec: 7f ff fe c2 call 200def4 <memfile_alloc_block>
200e3f0: 01 00 00 00 nop
if ( !memory )
200e3f4: 80 a2 20 00 cmp %o0, 0
200e3f8: 22 80 00 03 be,a 200e404 <IMFS_memfile_addblock+0x40> <== NEVER TAKEN
200e3fc: b0 10 20 01 mov 1, %i0 <== NOT EXECUTED
return 1;
*block_entry_ptr = memory;
200e400: d0 27 40 00 st %o0, [ %i5 ]
return 0;
200e404: 81 c7 e0 08 ret
200e408: 81 e8 00 00 restore
0200e5d8 <IMFS_memfile_extend>:
MEMFILE_STATIC int IMFS_memfile_extend(
IMFS_jnode_t *the_jnode,
bool zero_fill,
off_t new_length
)
{
200e5d8: 9d e3 bf 98 save %sp, -104, %sp
IMFS_assert( IMFS_type( the_jnode ) == IMFS_MEMORY_FILE );
/*
* Verify new file size is supported
*/
if ( new_length >= IMFS_MEMFILE_MAXIMUM_SIZE )
200e5dc: 03 00 80 75 sethi %hi(0x201d400), %g1
200e5e0: fa 00 61 c8 ld [ %g1 + 0x1c8 ], %i5 ! 201d5c8 <imfs_memfile_bytes_per_block>
200e5e4: b9 37 60 02 srl %i5, 2, %i4
200e5e8: 92 10 00 1c mov %i4, %o1
200e5ec: 40 00 28 6f call 20187a8 <.umul>
200e5f0: 90 07 20 01 add %i4, 1, %o0
200e5f4: 92 10 00 1c mov %i4, %o1
200e5f8: 40 00 28 6c call 20187a8 <.umul>
200e5fc: 90 02 20 01 inc %o0
200e600: 92 10 00 1d mov %i5, %o1
200e604: 40 00 28 69 call 20187a8 <.umul>
200e608: 90 02 3f ff add %o0, -1, %o0
200e60c: 82 10 20 00 clr %g1
200e610: 80 a0 40 1a cmp %g1, %i2
200e614: 34 80 00 0b bg,a 200e640 <IMFS_memfile_extend+0x68> <== NEVER TAKEN
200e618: f8 06 20 50 ld [ %i0 + 0x50 ], %i4 <== NOT EXECUTED
200e61c: 80 a0 40 1a cmp %g1, %i2
200e620: 12 80 00 04 bne 200e630 <IMFS_memfile_extend+0x58> <== NEVER TAKEN
200e624: 80 a2 00 1b cmp %o0, %i3
200e628: 38 80 00 06 bgu,a 200e640 <IMFS_memfile_extend+0x68>
200e62c: f8 06 20 50 ld [ %i0 + 0x50 ], %i4
rtems_set_errno_and_return_minus_one( EFBIG );
200e630: 40 00 04 f8 call 200fa10 <__errno>
200e634: 01 00 00 00 nop
200e638: 10 80 00 3c b 200e728 <IMFS_memfile_extend+0x150>
200e63c: 82 10 20 1b mov 0x1b, %g1 ! 1b <PROM_START+0x1b>
/*
* Verify new file size is actually larger than current size
*/
if ( new_length <= the_jnode->info.file.size )
200e640: 80 a6 80 1c cmp %i2, %i4
200e644: 14 80 00 07 bg 200e660 <IMFS_memfile_extend+0x88> <== NEVER TAKEN
200e648: e0 06 20 54 ld [ %i0 + 0x54 ], %l0
200e64c: 80 a6 80 1c cmp %i2, %i4
200e650: 12 80 00 48 bne 200e770 <IMFS_memfile_extend+0x198> <== NEVER TAKEN
200e654: 80 a6 c0 10 cmp %i3, %l0
200e658: 08 80 00 46 bleu 200e770 <IMFS_memfile_extend+0x198> <== NEVER TAKEN
200e65c: 01 00 00 00 nop
return 0;
/*
* Calculate the number of range of blocks to allocate
*/
new_blocks = new_length / IMFS_MEMFILE_BYTES_PER_BLOCK;
200e660: a3 3f 60 1f sra %i5, 0x1f, %l1
200e664: 96 10 00 1d mov %i5, %o3
200e668: 94 10 00 11 mov %l1, %o2
200e66c: 90 10 00 1a mov %i2, %o0
200e670: 40 00 29 e0 call 2018df0 <__divdi3>
200e674: 92 10 00 1b mov %i3, %o1
old_blocks = the_jnode->info.file.size / IMFS_MEMFILE_BYTES_PER_BLOCK;
200e678: 94 10 00 11 mov %l1, %o2
200e67c: 90 10 00 1c mov %i4, %o0
200e680: 96 10 00 1d mov %i5, %o3
return 0;
/*
* Calculate the number of range of blocks to allocate
*/
new_blocks = new_length / IMFS_MEMFILE_BYTES_PER_BLOCK;
200e684: a4 10 00 09 mov %o1, %l2
old_blocks = the_jnode->info.file.size / IMFS_MEMFILE_BYTES_PER_BLOCK;
200e688: 40 00 29 da call 2018df0 <__divdi3>
200e68c: 92 10 00 10 mov %l0, %o1
offset = the_jnode->info.file.size - old_blocks * IMFS_MEMFILE_BYTES_PER_BLOCK;
/*
* Now allocate each of those blocks.
*/
for ( block=old_blocks ; block<=new_blocks ; block++ ) {
200e690: a2 10 20 00 clr %l1
/*
* Calculate the number of range of blocks to allocate
*/
new_blocks = new_length / IMFS_MEMFILE_BYTES_PER_BLOCK;
old_blocks = the_jnode->info.file.size / IMFS_MEMFILE_BYTES_PER_BLOCK;
offset = the_jnode->info.file.size - old_blocks * IMFS_MEMFILE_BYTES_PER_BLOCK;
200e694: 90 10 00 09 mov %o1, %o0
/*
* Calculate the number of range of blocks to allocate
*/
new_blocks = new_length / IMFS_MEMFILE_BYTES_PER_BLOCK;
old_blocks = the_jnode->info.file.size / IMFS_MEMFILE_BYTES_PER_BLOCK;
200e698: b8 10 00 09 mov %o1, %i4
* Now allocate each of those blocks.
*/
for ( block=old_blocks ; block<=new_blocks ; block++ ) {
if ( !IMFS_memfile_addblock( the_jnode, block ) ) {
if ( zero_fill ) {
size_t count = IMFS_MEMFILE_BYTES_PER_BLOCK - offset;
200e69c: 27 00 80 75 sethi %hi(0x201d400), %l3
/*
* Calculate the number of range of blocks to allocate
*/
new_blocks = new_length / IMFS_MEMFILE_BYTES_PER_BLOCK;
old_blocks = the_jnode->info.file.size / IMFS_MEMFILE_BYTES_PER_BLOCK;
offset = the_jnode->info.file.size - old_blocks * IMFS_MEMFILE_BYTES_PER_BLOCK;
200e6a0: 40 00 28 42 call 20187a8 <.umul>
200e6a4: 92 10 00 1d mov %i5, %o1
/*
* Now allocate each of those blocks.
*/
for ( block=old_blocks ; block<=new_blocks ; block++ ) {
200e6a8: 10 80 00 23 b 200e734 <IMFS_memfile_extend+0x15c>
200e6ac: a0 24 00 08 sub %l0, %o0, %l0
if ( !IMFS_memfile_addblock( the_jnode, block ) ) {
200e6b0: 7f ff ff 45 call 200e3c4 <IMFS_memfile_addblock>
200e6b4: 92 10 00 1d mov %i5, %o1
200e6b8: 80 a2 20 00 cmp %o0, 0
200e6bc: 12 80 00 15 bne 200e710 <IMFS_memfile_extend+0x138> <== NEVER TAKEN
200e6c0: 80 a6 60 00 cmp %i1, 0
if ( zero_fill ) {
200e6c4: 22 80 00 1c be,a 200e734 <IMFS_memfile_extend+0x15c>
200e6c8: a2 04 60 01 inc %l1
size_t count = IMFS_MEMFILE_BYTES_PER_BLOCK - offset;
200e6cc: e8 04 e1 c8 ld [ %l3 + 0x1c8 ], %l4
block_p *block_ptr =
200e6d0: 92 10 00 1d mov %i5, %o1
200e6d4: 94 10 20 00 clr %o2
200e6d8: 7f ff fe 14 call 200df28 <IMFS_memfile_get_block_pointer>
200e6dc: 90 10 00 18 mov %i0, %o0
IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
memset( &(*block_ptr) [offset], 0, count);
200e6e0: d0 02 00 00 ld [ %o0 ], %o0
* Now allocate each of those blocks.
*/
for ( block=old_blocks ; block<=new_blocks ; block++ ) {
if ( !IMFS_memfile_addblock( the_jnode, block ) ) {
if ( zero_fill ) {
size_t count = IMFS_MEMFILE_BYTES_PER_BLOCK - offset;
200e6e4: a8 25 00 10 sub %l4, %l0, %l4
block_p *block_ptr =
IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
memset( &(*block_ptr) [offset], 0, count);
200e6e8: 90 02 00 10 add %o0, %l0, %o0
200e6ec: 92 10 20 00 clr %o1
200e6f0: 94 10 00 14 mov %l4, %o2
200e6f4: 40 00 07 4b call 2010420 <memset>
200e6f8: a0 10 20 00 clr %l0
200e6fc: 10 80 00 0e b 200e734 <IMFS_memfile_extend+0x15c>
200e700: a2 04 60 01 inc %l1
offset = 0;
}
} else {
for ( ; block>=old_blocks ; block-- ) {
IMFS_memfile_remove_block( the_jnode, block );
200e704: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
200e708: 7f ff ff a8 call 200e5a8 <IMFS_memfile_remove_block> <== NOT EXECUTED
200e70c: ba 07 7f ff add %i5, -1, %i5 <== NOT EXECUTED
memset( &(*block_ptr) [offset], 0, count);
offset = 0;
}
} else {
for ( ; block>=old_blocks ; block-- ) {
200e710: 80 a7 40 1c cmp %i5, %i4 <== NOT EXECUTED
200e714: 1a bf ff fc bcc 200e704 <IMFS_memfile_extend+0x12c> <== NOT EXECUTED
200e718: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
IMFS_memfile_remove_block( the_jnode, block );
}
rtems_set_errno_and_return_minus_one( ENOSPC );
200e71c: 40 00 04 bd call 200fa10 <__errno> <== NOT EXECUTED
200e720: 01 00 00 00 nop <== NOT EXECUTED
200e724: 82 10 20 1c mov 0x1c, %g1 ! 1c <PROM_START+0x1c> <== NOT EXECUTED
200e728: c2 22 00 00 st %g1, [ %o0 ]
200e72c: 81 c7 e0 08 ret
200e730: 91 e8 3f ff restore %g0, -1, %o0
*
* This routine insures that the in-memory file is of the length
* specified. If necessary, it will allocate memory blocks to
* extend the file.
*/
MEMFILE_STATIC int IMFS_memfile_extend(
200e734: ba 04 40 1c add %l1, %i4, %i5
offset = the_jnode->info.file.size - old_blocks * IMFS_MEMFILE_BYTES_PER_BLOCK;
/*
* Now allocate each of those blocks.
*/
for ( block=old_blocks ; block<=new_blocks ; block++ ) {
200e738: 80 a7 40 12 cmp %i5, %l2
200e73c: 08 bf ff dd bleu 200e6b0 <IMFS_memfile_extend+0xd8>
200e740: 90 10 00 18 mov %i0, %o0
/*
* Set the new length of the file.
*/
the_jnode->info.file.size = new_length;
IMFS_update_ctime(the_jnode);
200e744: 92 10 20 00 clr %o1
}
/*
* Set the new length of the file.
*/
the_jnode->info.file.size = new_length;
200e748: f4 3e 20 50 std %i2, [ %i0 + 0x50 ]
IMFS_update_ctime(the_jnode);
200e74c: 7f ff d4 4e call 2003884 <gettimeofday>
200e750: 90 07 bf f8 add %fp, -8, %o0
200e754: c2 07 bf f8 ld [ %fp + -8 ], %g1
IMFS_update_mtime(the_jnode);
200e758: 90 07 bf f8 add %fp, -8, %o0
/*
* Set the new length of the file.
*/
the_jnode->info.file.size = new_length;
IMFS_update_ctime(the_jnode);
200e75c: c2 26 20 48 st %g1, [ %i0 + 0x48 ]
IMFS_update_mtime(the_jnode);
200e760: 7f ff d4 49 call 2003884 <gettimeofday>
200e764: 92 10 20 00 clr %o1
200e768: c2 07 bf f8 ld [ %fp + -8 ], %g1
200e76c: c2 26 20 44 st %g1, [ %i0 + 0x44 ]
return 0;
}
200e770: 81 c7 e0 08 ret
200e774: 91 e8 20 00 restore %g0, 0, %o0
0200df28 <IMFS_memfile_get_block_pointer>:
#endif
IMFS_jnode_t *the_jnode,
unsigned int block,
int malloc_it
)
{
200df28: 9d e3 bf a0 save %sp, -96, %sp
my_block = block;
/*
* Is the block number in the simple indirect portion?
*/
if ( my_block <= LAST_INDIRECT ) {
200df2c: 03 00 80 75 sethi %hi(0x201d400), %g1
200df30: fa 00 61 c8 ld [ %g1 + 0x1c8 ], %i5 ! 201d5c8 <imfs_memfile_bytes_per_block>
200df34: bb 37 60 02 srl %i5, 2, %i5
200df38: 82 07 7f ff add %i5, -1, %g1
200df3c: 80 a6 40 01 cmp %i1, %g1
200df40: 18 80 00 18 bgu 200dfa0 <IMFS_memfile_get_block_pointer+0x78>
200df44: 90 07 60 01 add %i5, 1, %o0
p = info->indirect;
if ( malloc_it ) {
200df48: 80 a6 a0 00 cmp %i2, 0
200df4c: 02 80 00 10 be 200df8c <IMFS_memfile_get_block_pointer+0x64>
200df50: c2 06 20 58 ld [ %i0 + 0x58 ], %g1
if ( !p ) {
200df54: 80 a0 60 00 cmp %g1, 0
200df58: 32 80 00 0a bne,a 200df80 <IMFS_memfile_get_block_pointer+0x58>
200df5c: f0 06 20 58 ld [ %i0 + 0x58 ], %i0
p = memfile_alloc_block();
200df60: 7f ff ff e5 call 200def4 <memfile_alloc_block>
200df64: 01 00 00 00 nop
if ( !p )
200df68: 80 a2 20 00 cmp %o0, 0
200df6c: 32 80 00 04 bne,a 200df7c <IMFS_memfile_get_block_pointer+0x54><== ALWAYS TAKEN
200df70: d0 26 20 58 st %o0, [ %i0 + 0x58 ]
return 0;
200df74: 81 c7 e0 08 ret <== NOT EXECUTED
200df78: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED
info->indirect = p;
}
return &info->indirect[ my_block ];
200df7c: f0 06 20 58 ld [ %i0 + 0x58 ], %i0
200df80: b3 2e 60 02 sll %i1, 2, %i1
200df84: 81 c7 e0 08 ret
200df88: 91 ee 00 19 restore %i0, %i1, %o0
}
if ( !p )
200df8c: 80 a0 60 00 cmp %g1, 0
200df90: 02 bf ff f9 be 200df74 <IMFS_memfile_get_block_pointer+0x4c><== NEVER TAKEN
200df94: b3 2e 60 02 sll %i1, 2, %i1
return 0;
return &info->indirect[ my_block ];
200df98: 81 c7 e0 08 ret
200df9c: 91 e8 40 19 restore %g1, %i1, %o0
/*
* Is the block number in the doubly indirect portion?
*/
if ( my_block <= LAST_DOUBLY_INDIRECT ) {
200dfa0: 40 00 2a 02 call 20187a8 <.umul>
200dfa4: 92 10 00 1d mov %i5, %o1
200dfa8: 82 02 3f ff add %o0, -1, %g1
200dfac: 80 a6 40 01 cmp %i1, %g1
200dfb0: 18 80 00 2c bgu 200e060 <IMFS_memfile_get_block_pointer+0x138>
200dfb4: b8 10 00 08 mov %o0, %i4
my_block -= FIRST_DOUBLY_INDIRECT;
200dfb8: b2 26 40 1d sub %i1, %i5, %i1
singly = my_block % IMFS_MEMFILE_BLOCK_SLOTS;
200dfbc: 92 10 00 1d mov %i5, %o1
200dfc0: 40 00 2a e0 call 2018b40 <.urem>
200dfc4: 90 10 00 19 mov %i1, %o0
doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS;
200dfc8: 92 10 00 1d mov %i5, %o1
*/
if ( my_block <= LAST_DOUBLY_INDIRECT ) {
my_block -= FIRST_DOUBLY_INDIRECT;
singly = my_block % IMFS_MEMFILE_BLOCK_SLOTS;
200dfcc: b8 10 00 08 mov %o0, %i4
doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS;
200dfd0: 40 00 2a 30 call 2018890 <.udiv>
200dfd4: 90 10 00 19 mov %i1, %o0
p = info->doubly_indirect;
if ( malloc_it ) {
200dfd8: 80 a6 a0 00 cmp %i2, 0
if ( my_block <= LAST_DOUBLY_INDIRECT ) {
my_block -= FIRST_DOUBLY_INDIRECT;
singly = my_block % IMFS_MEMFILE_BLOCK_SLOTS;
doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS;
200dfdc: ba 10 00 08 mov %o0, %i5
p = info->doubly_indirect;
if ( malloc_it ) {
200dfe0: 02 80 00 17 be 200e03c <IMFS_memfile_get_block_pointer+0x114>
200dfe4: d0 06 20 5c ld [ %i0 + 0x5c ], %o0
if ( !p ) {
200dfe8: 80 a2 20 00 cmp %o0, 0
200dfec: 12 80 00 08 bne 200e00c <IMFS_memfile_get_block_pointer+0xe4>
200dff0: bb 2f 60 02 sll %i5, 2, %i5
p = memfile_alloc_block();
200dff4: 7f ff ff c0 call 200def4 <memfile_alloc_block>
200dff8: 01 00 00 00 nop
if ( !p )
200dffc: 80 a2 20 00 cmp %o0, 0
200e000: 02 bf ff dd be 200df74 <IMFS_memfile_get_block_pointer+0x4c><== NEVER TAKEN
200e004: 01 00 00 00 nop
return 0;
info->doubly_indirect = p;
200e008: d0 26 20 5c st %o0, [ %i0 + 0x5c ]
}
p1 = (block_p *)p[ doubly ];
200e00c: b6 02 00 1d add %o0, %i5, %i3
200e010: d0 02 00 1d ld [ %o0 + %i5 ], %o0
if ( !p1 ) {
200e014: 80 a2 20 00 cmp %o0, 0
200e018: 12 80 00 4a bne 200e140 <IMFS_memfile_get_block_pointer+0x218>
200e01c: b1 2f 20 02 sll %i4, 2, %i0
p1 = memfile_alloc_block();
200e020: 7f ff ff b5 call 200def4 <memfile_alloc_block>
200e024: 01 00 00 00 nop
if ( !p1 )
200e028: 80 a2 20 00 cmp %o0, 0
200e02c: 02 bf ff d2 be 200df74 <IMFS_memfile_get_block_pointer+0x4c><== NEVER TAKEN
200e030: 01 00 00 00 nop
return 0;
p[ doubly ] = (block_p) p1;
200e034: 10 80 00 43 b 200e140 <IMFS_memfile_get_block_pointer+0x218>
200e038: d0 26 c0 00 st %o0, [ %i3 ]
}
return (block_p *)&p1[ singly ];
}
if ( !p )
200e03c: 80 a2 20 00 cmp %o0, 0
200e040: 02 bf ff cd be 200df74 <IMFS_memfile_get_block_pointer+0x4c><== NEVER TAKEN
200e044: bb 2f 60 02 sll %i5, 2, %i5
return 0;
p = (block_p *)p[ doubly ];
200e048: c2 02 00 1d ld [ %o0 + %i5 ], %g1
if ( !p )
200e04c: 80 a0 60 00 cmp %g1, 0
200e050: 02 bf ff c9 be 200df74 <IMFS_memfile_get_block_pointer+0x4c><== NEVER TAKEN
200e054: 01 00 00 00 nop
return 0;
return (block_p *)&p[ singly ];
200e058: 10 80 00 48 b 200e178 <IMFS_memfile_get_block_pointer+0x250>
200e05c: b1 2f 20 02 sll %i4, 2, %i0
}
/*
* Is the block number in the triply indirect portion?
*/
if ( my_block <= LAST_TRIPLY_INDIRECT ) {
200e060: 90 02 20 01 inc %o0
200e064: 40 00 29 d1 call 20187a8 <.umul>
200e068: 92 10 00 1d mov %i5, %o1
200e06c: 90 02 3f ff add %o0, -1, %o0
200e070: 80 a6 40 08 cmp %i1, %o0
200e074: 18 bf ff c0 bgu 200df74 <IMFS_memfile_get_block_pointer+0x4c><== NEVER TAKEN
200e078: b2 26 40 1c sub %i1, %i4, %i1
my_block -= FIRST_TRIPLY_INDIRECT;
singly = my_block % IMFS_MEMFILE_BLOCK_SLOTS;
200e07c: 92 10 00 1d mov %i5, %o1
200e080: 40 00 2a b0 call 2018b40 <.urem>
200e084: 90 10 00 19 mov %i1, %o0
doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS;
200e088: 92 10 00 1d mov %i5, %o1
* 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;
200e08c: b6 10 00 08 mov %o0, %i3
doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS;
200e090: 40 00 2a 00 call 2018890 <.udiv>
200e094: 90 10 00 19 mov %i1, %o0
triply = doubly / IMFS_MEMFILE_BLOCK_SLOTS;
200e098: 92 10 00 1d mov %i5, %o1
200e09c: 40 00 29 fd call 2018890 <.udiv>
200e0a0: b2 10 00 08 mov %o0, %i1
doubly %= IMFS_MEMFILE_BLOCK_SLOTS;
200e0a4: 92 10 00 1d mov %i5, %o1
if ( my_block <= LAST_TRIPLY_INDIRECT ) {
my_block -= FIRST_TRIPLY_INDIRECT;
singly = my_block % IMFS_MEMFILE_BLOCK_SLOTS;
doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS;
triply = doubly / IMFS_MEMFILE_BLOCK_SLOTS;
200e0a8: b8 10 00 08 mov %o0, %i4
doubly %= IMFS_MEMFILE_BLOCK_SLOTS;
200e0ac: 40 00 2a a5 call 2018b40 <.urem>
200e0b0: 90 10 00 19 mov %i1, %o0
p = info->triply_indirect;
if ( malloc_it ) {
200e0b4: 80 a6 a0 00 cmp %i2, 0
my_block -= FIRST_TRIPLY_INDIRECT;
singly = my_block % IMFS_MEMFILE_BLOCK_SLOTS;
doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS;
triply = doubly / IMFS_MEMFILE_BLOCK_SLOTS;
doubly %= IMFS_MEMFILE_BLOCK_SLOTS;
200e0b8: ba 10 00 08 mov %o0, %i5
p = info->triply_indirect;
if ( malloc_it ) {
200e0bc: 02 80 00 23 be 200e148 <IMFS_memfile_get_block_pointer+0x220>
200e0c0: d0 06 20 60 ld [ %i0 + 0x60 ], %o0
if ( !p ) {
200e0c4: 80 a2 20 00 cmp %o0, 0
200e0c8: 12 80 00 08 bne 200e0e8 <IMFS_memfile_get_block_pointer+0x1c0>
200e0cc: b9 2f 20 02 sll %i4, 2, %i4
p = memfile_alloc_block();
200e0d0: 7f ff ff 89 call 200def4 <memfile_alloc_block>
200e0d4: 01 00 00 00 nop
if ( !p )
200e0d8: 80 a2 20 00 cmp %o0, 0
200e0dc: 02 bf ff a6 be 200df74 <IMFS_memfile_get_block_pointer+0x4c><== NEVER TAKEN
200e0e0: 01 00 00 00 nop
return 0;
info->triply_indirect = p;
200e0e4: d0 26 20 60 st %o0, [ %i0 + 0x60 ]
}
p1 = (block_p *) p[ triply ];
200e0e8: b4 02 00 1c add %o0, %i4, %i2
200e0ec: d0 02 00 1c ld [ %o0 + %i4 ], %o0
if ( !p1 ) {
200e0f0: 80 a2 20 00 cmp %o0, 0
200e0f4: 12 80 00 08 bne 200e114 <IMFS_memfile_get_block_pointer+0x1ec>
200e0f8: bb 2f 60 02 sll %i5, 2, %i5
p1 = memfile_alloc_block();
200e0fc: 7f ff ff 7e call 200def4 <memfile_alloc_block>
200e100: 01 00 00 00 nop
if ( !p1 )
200e104: 80 a2 20 00 cmp %o0, 0
200e108: 02 bf ff 9b be 200df74 <IMFS_memfile_get_block_pointer+0x4c><== NEVER TAKEN
200e10c: 01 00 00 00 nop
return 0;
p[ triply ] = (block_p) p1;
200e110: d0 26 80 00 st %o0, [ %i2 ]
}
p2 = (block_p *)p1[ doubly ];
200e114: b8 02 00 1d add %o0, %i5, %i4
200e118: d0 02 00 1d ld [ %o0 + %i5 ], %o0
if ( !p2 ) {
200e11c: 80 a2 20 00 cmp %o0, 0
200e120: 12 80 00 08 bne 200e140 <IMFS_memfile_get_block_pointer+0x218>
200e124: b1 2e e0 02 sll %i3, 2, %i0
p2 = memfile_alloc_block();
200e128: 7f ff ff 73 call 200def4 <memfile_alloc_block>
200e12c: 01 00 00 00 nop
if ( !p2 )
200e130: 80 a2 20 00 cmp %o0, 0
200e134: 02 bf ff 90 be 200df74 <IMFS_memfile_get_block_pointer+0x4c><== NEVER TAKEN
200e138: 01 00 00 00 nop
return 0;
p1[ doubly ] = (block_p) p2;
200e13c: d0 27 00 00 st %o0, [ %i4 ]
}
return (block_p *)&p2[ singly ];
200e140: 81 c7 e0 08 ret
200e144: 91 ea 00 18 restore %o0, %i0, %o0
}
if ( !p )
200e148: 80 a2 20 00 cmp %o0, 0
200e14c: 02 bf ff 8a be 200df74 <IMFS_memfile_get_block_pointer+0x4c><== NEVER TAKEN
200e150: b9 2f 20 02 sll %i4, 2, %i4
return 0;
p1 = (block_p *) p[ triply ];
200e154: c2 02 00 1c ld [ %o0 + %i4 ], %g1
if ( !p1 )
200e158: 80 a0 60 00 cmp %g1, 0
200e15c: 02 bf ff 86 be 200df74 <IMFS_memfile_get_block_pointer+0x4c><== NEVER TAKEN
200e160: bb 2f 60 02 sll %i5, 2, %i5
return 0;
p2 = (block_p *)p1[ doubly ];
200e164: c2 00 40 1d ld [ %g1 + %i5 ], %g1
if ( !p2 )
200e168: 80 a0 60 00 cmp %g1, 0
200e16c: 02 bf ff 82 be 200df74 <IMFS_memfile_get_block_pointer+0x4c><== NEVER TAKEN
200e170: 01 00 00 00 nop
return 0;
return (block_p *)&p2[ singly ];
200e174: b1 2e e0 02 sll %i3, 2, %i0
/*
* This means the requested block number is out of range.
*/
return 0;
}
200e178: 81 c7 e0 08 ret
200e17c: 91 e8 40 18 restore %g1, %i0, %o0
0200e180 <IMFS_memfile_read>:
IMFS_jnode_t *the_jnode,
off_t start,
unsigned char *destination,
unsigned int length
)
{
200e180: 9d e3 bf 98 save %sp, -104, %sp
rtems_chain_extract_unprotected( &node->Node );
}
static inline IMFS_jnode_types_t IMFS_type( const IMFS_jnode_t *node )
{
return node->control->imfs_type;
200e184: c2 06 20 4c ld [ %i0 + 0x4c ], %g1
200e188: ba 10 00 18 mov %i0, %i5
* Linear files (as created from a tar file are easier to handle
* than block files).
*/
my_length = length;
if ( IMFS_type( the_jnode ) == IMFS_LINEAR_FILE ) {
200e18c: c2 00 40 00 ld [ %g1 ], %g1
IMFS_jnode_t *the_jnode,
off_t start,
unsigned char *destination,
unsigned int length
)
{
200e190: a0 10 00 19 mov %i1, %l0
200e194: a2 10 00 1a mov %i2, %l1
* Linear files (as created from a tar file are easier to handle
* than block files).
*/
my_length = length;
if ( IMFS_type( the_jnode ) == IMFS_LINEAR_FILE ) {
200e198: 80 a0 60 05 cmp %g1, 5
200e19c: 12 80 00 17 bne 200e1f8 <IMFS_memfile_read+0x78>
200e1a0: a4 10 00 1b mov %i3, %l2
unsigned char *file_ptr;
file_ptr = (unsigned char *)the_jnode->info.linearfile.direct;
if (my_length > (the_jnode->info.linearfile.size - start))
200e1a4: f4 1e 20 50 ldd [ %i0 + 0x50 ], %i2
200e1a8: 82 10 20 00 clr %g1
200e1ac: 86 a6 c0 11 subcc %i3, %l1, %g3
200e1b0: 84 66 80 19 subx %i2, %i1, %g2
200e1b4: 80 a0 40 02 cmp %g1, %g2
200e1b8: 14 80 00 07 bg 200e1d4 <IMFS_memfile_read+0x54> <== NEVER TAKEN
200e1bc: d2 06 20 58 ld [ %i0 + 0x58 ], %o1
200e1c0: 80 a0 40 02 cmp %g1, %g2
200e1c4: 12 80 00 06 bne 200e1dc <IMFS_memfile_read+0x5c> <== NEVER TAKEN
200e1c8: 80 a7 00 03 cmp %i4, %g3
200e1cc: 28 80 00 05 bleu,a 200e1e0 <IMFS_memfile_read+0x60> <== NEVER TAKEN
200e1d0: b0 10 00 1c mov %i4, %i0 <== NOT EXECUTED
my_length = the_jnode->info.linearfile.size - start;
200e1d4: 10 80 00 03 b 200e1e0 <IMFS_memfile_read+0x60>
200e1d8: b0 26 c0 11 sub %i3, %l1, %i0
/*
* Linear files (as created from a tar file are easier to handle
* than block files).
*/
my_length = length;
200e1dc: b0 10 00 1c mov %i4, %i0 <== 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);
200e1e0: 90 10 00 12 mov %l2, %o0
200e1e4: 92 02 40 11 add %o1, %l1, %o1
200e1e8: 40 00 08 51 call 201032c <memcpy>
200e1ec: 94 10 00 18 mov %i0, %o2
return copied;
memcpy( dest, &(*block_ptr)[ 0 ], my_length );
copied += my_length;
}
IMFS_update_atime( the_jnode );
200e1f0: 10 80 00 5d b 200e364 <IMFS_memfile_read+0x1e4>
200e1f4: 90 07 bf f8 add %fp, -8, %o0
/*
* 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 )
200e1f8: c6 06 20 50 ld [ %i0 + 0x50 ], %g3
200e1fc: 88 10 20 00 clr %g4
/*
* 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;
200e200: 82 10 00 1a mov %i2, %g1
if ( last_byte > the_jnode->info.file.size )
200e204: c4 06 20 54 ld [ %i0 + 0x54 ], %g2
200e208: 80 a1 00 03 cmp %g4, %g3
200e20c: 14 80 00 08 bg 200e22c <IMFS_memfile_read+0xac> <== NEVER TAKEN
200e210: b6 07 00 1a add %i4, %i2, %i3
200e214: 80 a1 00 03 cmp %g4, %g3
200e218: 32 80 00 07 bne,a 200e234 <IMFS_memfile_read+0xb4> <== NEVER TAKEN
200e21c: 03 00 80 75 sethi %hi(0x201d400), %g1 <== NOT EXECUTED
200e220: 80 a6 c0 02 cmp %i3, %g2
200e224: 28 80 00 04 bleu,a 200e234 <IMFS_memfile_read+0xb4>
200e228: 03 00 80 75 sethi %hi(0x201d400), %g1
my_length = the_jnode->info.file.size - start;
200e22c: b8 20 80 01 sub %g2, %g1, %i4
*/
/*
* Phase 1: possibly the last part of one block
*/
start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;
200e230: 03 00 80 75 sethi %hi(0x201d400), %g1
200e234: f6 00 61 c8 ld [ %g1 + 0x1c8 ], %i3 ! 201d5c8 <imfs_memfile_bytes_per_block>
200e238: 90 10 00 10 mov %l0, %o0
200e23c: b5 3e e0 1f sra %i3, 0x1f, %i2
200e240: 96 10 00 1b mov %i3, %o3
200e244: 94 10 00 1a mov %i2, %o2
200e248: 40 00 2b d5 call 201919c <__moddi3>
200e24c: 92 10 00 11 mov %l1, %o1
block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;
200e250: 94 10 00 1a mov %i2, %o2
*/
/*
* Phase 1: possibly the last part of one block
*/
start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;
200e254: a6 10 00 09 mov %o1, %l3
block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;
200e258: 90 10 00 10 mov %l0, %o0
200e25c: 92 10 00 11 mov %l1, %o1
200e260: 40 00 2a e4 call 2018df0 <__divdi3>
200e264: 96 10 00 1b mov %i3, %o3
if ( start_offset ) {
200e268: 80 a4 e0 00 cmp %l3, 0
200e26c: 02 80 00 18 be 200e2cc <IMFS_memfile_read+0x14c>
200e270: b4 10 00 09 mov %o1, %i2
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK - start_offset;
200e274: b6 26 c0 13 sub %i3, %l3, %i3
200e278: 80 a7 00 1b cmp %i4, %i3
200e27c: 08 80 00 03 bleu 200e288 <IMFS_memfile_read+0x108>
200e280: b2 10 00 1c mov %i4, %i1
200e284: b2 10 00 1b mov %i3, %i1
if ( to_copy > my_length )
to_copy = my_length;
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
200e288: 90 10 00 1d mov %i5, %o0
200e28c: 92 10 00 1a mov %i2, %o1
200e290: 94 10 20 00 clr %o2
200e294: 7f ff ff 25 call 200df28 <IMFS_memfile_get_block_pointer>
200e298: b0 10 20 00 clr %i0
if ( !block_ptr )
200e29c: 80 a2 20 00 cmp %o0, 0
200e2a0: 02 80 00 35 be 200e374 <IMFS_memfile_read+0x1f4> <== NEVER TAKEN
200e2a4: 94 10 00 19 mov %i1, %o2
return copied;
memcpy( dest, &(*block_ptr)[ start_offset ], to_copy );
200e2a8: d2 02 00 00 ld [ %o0 ], %o1
200e2ac: 90 10 00 12 mov %l2, %o0
200e2b0: 92 02 40 13 add %o1, %l3, %o1
200e2b4: 40 00 08 1e call 201032c <memcpy>
200e2b8: a4 04 80 19 add %l2, %i1, %l2
dest += to_copy;
block++;
200e2bc: b4 06 a0 01 inc %i2
my_length -= to_copy;
200e2c0: b8 27 00 19 sub %i4, %i1, %i4
copied += to_copy;
200e2c4: 10 80 00 03 b 200e2d0 <IMFS_memfile_read+0x150>
200e2c8: b0 10 00 19 mov %i1, %i0
*/
last_byte = start + length;
if ( last_byte > the_jnode->info.file.size )
my_length = the_jnode->info.file.size - start;
copied = 0;
200e2cc: b0 10 20 00 clr %i0
}
/*
* Phase 2: all of zero of more blocks
*/
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;
200e2d0: 03 00 80 75 sethi %hi(0x201d400), %g1
* is considered an error. Read from an offset for more bytes than
* are between the offset and the end of the file will result in
* reading the data between offset and the end of the file (truncated
* read).
*/
MEMFILE_STATIC ssize_t IMFS_memfile_read(
200e2d4: a4 24 80 18 sub %l2, %i0, %l2
}
/*
* Phase 2: all of zero of more blocks
*/
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;
200e2d8: f6 00 61 c8 ld [ %g1 + 0x1c8 ], %i3
while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {
200e2dc: 10 80 00 0f b 200e318 <IMFS_memfile_read+0x198>
200e2e0: a0 10 00 01 mov %g1, %l0
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
200e2e4: 90 10 00 1d mov %i5, %o0
200e2e8: 92 10 00 1a mov %i2, %o1
200e2ec: 7f ff ff 0f call 200df28 <IMFS_memfile_get_block_pointer>
200e2f0: 94 10 20 00 clr %o2
if ( !block_ptr )
200e2f4: 82 92 20 00 orcc %o0, 0, %g1
200e2f8: 02 80 00 1f be 200e374 <IMFS_memfile_read+0x1f4> <== NEVER TAKEN
200e2fc: 90 10 00 19 mov %i1, %o0
return copied;
memcpy( dest, &(*block_ptr)[ 0 ], to_copy );
200e300: d2 00 40 00 ld [ %g1 ], %o1
200e304: 94 10 00 1b mov %i3, %o2
200e308: 40 00 08 09 call 201032c <memcpy>
200e30c: b4 06 a0 01 inc %i2
dest += to_copy;
block++;
my_length -= to_copy;
200e310: b8 27 00 1b sub %i4, %i3, %i4
copied += to_copy;
200e314: b0 06 00 1b add %i0, %i3, %i0
/*
* Phase 2: all of zero of more blocks
*/
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;
while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {
200e318: c2 04 21 c8 ld [ %l0 + 0x1c8 ], %g1
200e31c: 80 a7 00 01 cmp %i4, %g1
200e320: 1a bf ff f1 bcc 200e2e4 <IMFS_memfile_read+0x164>
200e324: b2 04 80 18 add %l2, %i0, %i1
/*
* Phase 3: possibly the first part of one block
*/
IMFS_assert( my_length < IMFS_MEMFILE_BYTES_PER_BLOCK );
if ( my_length ) {
200e328: 80 a7 20 00 cmp %i4, 0
200e32c: 02 80 00 0e be 200e364 <IMFS_memfile_read+0x1e4>
200e330: 90 07 bf f8 add %fp, -8, %o0
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
200e334: 90 10 00 1d mov %i5, %o0
200e338: 92 10 00 1a mov %i2, %o1
200e33c: 7f ff fe fb call 200df28 <IMFS_memfile_get_block_pointer>
200e340: 94 10 20 00 clr %o2
if ( !block_ptr )
200e344: 82 92 20 00 orcc %o0, 0, %g1
200e348: 02 80 00 0b be 200e374 <IMFS_memfile_read+0x1f4> <== NEVER TAKEN
200e34c: 90 10 00 19 mov %i1, %o0
return copied;
memcpy( dest, &(*block_ptr)[ 0 ], my_length );
200e350: d2 00 40 00 ld [ %g1 ], %o1
200e354: 94 10 00 1c mov %i4, %o2
200e358: 40 00 07 f5 call 201032c <memcpy>
200e35c: b0 07 00 18 add %i4, %i0, %i0
copied += my_length;
}
IMFS_update_atime( the_jnode );
200e360: 90 07 bf f8 add %fp, -8, %o0
200e364: 7f ff d5 48 call 2003884 <gettimeofday>
200e368: 92 10 20 00 clr %o1
200e36c: c2 07 bf f8 ld [ %fp + -8 ], %g1
200e370: c2 27 60 40 st %g1, [ %i5 + 0x40 ]
return copied;
}
200e374: 81 c7 e0 08 ret
200e378: 81 e8 00 00 restore
0200e47c <IMFS_memfile_remove>:
* is better to stick to simple, easy to understand algorithms.
*/
IMFS_jnode_t *IMFS_memfile_remove(
IMFS_jnode_t *the_jnode
)
{
200e47c: 9d e3 bf a0 save %sp, -96, %sp
/*
* 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;
200e480: 03 00 80 75 sethi %hi(0x201d400), %g1
200e484: fa 00 61 c8 ld [ %g1 + 0x1c8 ], %i5 ! 201d5c8 <imfs_memfile_bytes_per_block>
* + doubly indirect
* + triply indirect
*/
info = &the_jnode->info.file;
if ( info->indirect ) {
200e488: c2 06 20 58 ld [ %i0 + 0x58 ], %g1
200e48c: 80 a0 60 00 cmp %g1, 0
200e490: 02 80 00 05 be 200e4a4 <IMFS_memfile_remove+0x28>
200e494: bb 37 60 02 srl %i5, 2, %i5
memfile_free_blocks_in_table( &info->indirect, to_free );
200e498: 90 06 20 58 add %i0, 0x58, %o0
200e49c: 7f ff ff e5 call 200e430 <memfile_free_blocks_in_table>
200e4a0: 92 10 00 1d mov %i5, %o1
}
if ( info->doubly_indirect ) {
200e4a4: c2 06 20 5c ld [ %i0 + 0x5c ], %g1
200e4a8: b8 10 20 00 clr %i4
200e4ac: 80 a0 60 00 cmp %g1, 0
200e4b0: 12 80 00 0d bne 200e4e4 <IMFS_memfile_remove+0x68>
200e4b4: 37 00 80 75 sethi %hi(0x201d400), %i3
}
memfile_free_blocks_in_table( &info->doubly_indirect, to_free );
}
if ( info->triply_indirect ) {
200e4b8: 10 80 00 15 b 200e50c <IMFS_memfile_remove+0x90>
200e4bc: c2 06 20 60 ld [ %i0 + 0x60 ], %g1
* 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.
*/
IMFS_jnode_t *IMFS_memfile_remove(
200e4c0: 83 2f 20 02 sll %i4, 2, %g1
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] ) {
200e4c4: 90 00 80 01 add %g2, %g1, %o0
200e4c8: c2 00 80 01 ld [ %g2 + %g1 ], %g1
200e4cc: 80 a0 60 00 cmp %g1, 0
200e4d0: 22 80 00 05 be,a 200e4e4 <IMFS_memfile_remove+0x68> <== NEVER TAKEN
200e4d4: b8 07 20 01 inc %i4 <== NOT EXECUTED
memfile_free_blocks_in_table(
200e4d8: 7f ff ff d6 call 200e430 <memfile_free_blocks_in_table>
200e4dc: 92 10 00 1d mov %i5, %o1
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++ ) {
200e4e0: b8 07 20 01 inc %i4
200e4e4: c2 06 e1 c8 ld [ %i3 + 0x1c8 ], %g1
200e4e8: 83 30 60 02 srl %g1, 2, %g1
200e4ec: 80 a7 00 01 cmp %i4, %g1
200e4f0: 2a bf ff f4 bcs,a 200e4c0 <IMFS_memfile_remove+0x44>
200e4f4: c4 06 20 5c ld [ %i0 + 0x5c ], %g2
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 );
200e4f8: 90 06 20 5c add %i0, 0x5c, %o0
200e4fc: 7f ff ff cd call 200e430 <memfile_free_blocks_in_table>
200e500: 92 10 00 1d mov %i5, %o1
}
if ( info->triply_indirect ) {
200e504: c2 06 20 60 ld [ %i0 + 0x60 ], %g1
200e508: b8 10 20 00 clr %i4
200e50c: 80 a0 60 00 cmp %g1, 0
200e510: 12 80 00 1c bne 200e580 <IMFS_memfile_remove+0x104>
200e514: 33 00 80 75 sethi %hi(0x201d400), %i1
200e518: 81 c7 e0 08 ret
200e51c: 81 e8 00 00 restore
* 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.
*/
IMFS_jnode_t *IMFS_memfile_remove(
200e520: a1 2f 20 02 sll %i4, 2, %l0
}
if ( info->triply_indirect ) {
for ( i=0 ; i<IMFS_MEMFILE_BLOCK_SLOTS ; i++ ) {
p = (block_p *) info->triply_indirect[i];
200e524: f6 00 40 10 ld [ %g1 + %l0 ], %i3
if ( !p ) /* ensure we have a valid pointer */
200e528: 80 a6 e0 00 cmp %i3, 0
200e52c: 02 80 00 1b be 200e598 <IMFS_memfile_remove+0x11c> <== NEVER TAKEN
200e530: 90 06 20 60 add %i0, 0x60, %o0
200e534: 10 80 00 09 b 200e558 <IMFS_memfile_remove+0xdc>
200e538: b4 10 20 00 clr %i2
break;
for ( j=0 ; j<IMFS_MEMFILE_BLOCK_SLOTS ; j++ ) {
if ( p[j] ) {
200e53c: 80 a0 60 00 cmp %g1, 0
200e540: 02 80 00 04 be 200e550 <IMFS_memfile_remove+0xd4> <== NEVER TAKEN
200e544: 90 10 00 1b mov %i3, %o0
memfile_free_blocks_in_table( (block_p **)&p[j], to_free);
200e548: 7f ff ff ba call 200e430 <memfile_free_blocks_in_table>
200e54c: 92 10 00 1d mov %i5, %o1
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++ ) {
200e550: b4 06 a0 01 inc %i2
200e554: b6 06 e0 04 add %i3, 4, %i3
200e558: c2 06 61 c8 ld [ %i1 + 0x1c8 ], %g1
200e55c: 83 30 60 02 srl %g1, 2, %g1
200e560: 80 a6 80 01 cmp %i2, %g1
200e564: 2a bf ff f6 bcs,a 200e53c <IMFS_memfile_remove+0xc0>
200e568: c2 06 c0 00 ld [ %i3 ], %g1
if ( p[j] ) {
memfile_free_blocks_in_table( (block_p **)&p[j], to_free);
}
}
memfile_free_blocks_in_table(
200e56c: d0 06 20 60 ld [ %i0 + 0x60 ], %o0
200e570: 92 10 00 1d mov %i5, %o1
200e574: 90 02 00 10 add %o0, %l0, %o0
200e578: 7f ff ff ae call 200e430 <memfile_free_blocks_in_table>
200e57c: b8 07 20 01 inc %i4
memfile_free_blocks_in_table( &info->doubly_indirect, to_free );
}
if ( info->triply_indirect ) {
for ( i=0 ; i<IMFS_MEMFILE_BLOCK_SLOTS ; i++ ) {
200e580: c2 06 61 c8 ld [ %i1 + 0x1c8 ], %g1
200e584: 83 30 60 02 srl %g1, 2, %g1
200e588: 80 a7 00 01 cmp %i4, %g1
200e58c: 2a bf ff e5 bcs,a 200e520 <IMFS_memfile_remove+0xa4>
200e590: c2 06 20 60 ld [ %i0 + 0x60 ], %g1
}
}
memfile_free_blocks_in_table(
(block_p **)&info->triply_indirect[i], to_free );
}
memfile_free_blocks_in_table(
200e594: 90 06 20 60 add %i0, 0x60, %o0
200e598: 7f ff ff a6 call 200e430 <memfile_free_blocks_in_table>
200e59c: 92 10 00 1d mov %i5, %o1
(block_p **)&info->triply_indirect, to_free );
}
return the_jnode;
}
200e5a0: 81 c7 e0 08 ret
200e5a4: 81 e8 00 00 restore
0200e5a8 <IMFS_memfile_remove_block>:
*/
MEMFILE_STATIC int IMFS_memfile_remove_block(
IMFS_jnode_t *the_jnode,
unsigned int block
)
{
200e5a8: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED
block_p *block_ptr;
block_p ptr;
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
200e5ac: 94 10 20 00 clr %o2 <== NOT EXECUTED
200e5b0: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
200e5b4: 7f ff fe 5d call 200df28 <IMFS_memfile_get_block_pointer> <== NOT EXECUTED
200e5b8: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
200e5bc: 82 10 00 08 mov %o0, %g1 <== NOT EXECUTED
IMFS_assert( block_ptr );
ptr = *block_ptr;
200e5c0: d0 02 00 00 ld [ %o0 ], %o0 <== NOT EXECUTED
*block_ptr = 0;
memfile_free_block( ptr );
return 1;
}
200e5c4: b0 10 20 01 mov 1, %i0 <== NOT EXECUTED
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
IMFS_assert( block_ptr );
ptr = *block_ptr;
*block_ptr = 0;
memfile_free_block( ptr );
200e5c8: 7f ff ff 91 call 200e40c <memfile_free_block> <== NOT EXECUTED
200e5cc: c0 20 40 00 clr [ %g1 ] <== NOT EXECUTED
return 1;
}
200e5d0: 81 c7 e0 08 ret <== NOT EXECUTED
200e5d4: 81 e8 00 00 restore <== NOT EXECUTED
0200e778 <IMFS_memfile_write>:
IMFS_jnode_t *the_jnode,
off_t start,
const unsigned char *source,
unsigned int length
)
{
200e778: 9d e3 bf 98 save %sp, -104, %sp
* 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 ) {
200e77c: c2 06 20 50 ld [ %i0 + 0x50 ], %g1
200e780: 86 10 20 00 clr %g3
/*
* 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;
200e784: 96 07 00 1a add %i4, %i2, %o3
if ( last_byte > the_jnode->info.file.size ) {
200e788: 80 a0 c0 01 cmp %g3, %g1
200e78c: 14 80 00 1b bg 200e7f8 <IMFS_memfile_write+0x80> <== NEVER TAKEN
200e790: c4 06 20 54 ld [ %i0 + 0x54 ], %g2
200e794: 80 a0 c0 01 cmp %g3, %g1
200e798: 32 80 00 06 bne,a 200e7b0 <IMFS_memfile_write+0x38> <== NEVER TAKEN
200e79c: 03 00 80 75 sethi %hi(0x201d400), %g1 <== NOT EXECUTED
200e7a0: 80 a2 c0 02 cmp %o3, %g2
200e7a4: 18 80 00 16 bgu 200e7fc <IMFS_memfile_write+0x84>
200e7a8: 80 a6 40 01 cmp %i1, %g1
*/
/*
* Phase 1: possibly the last part of one block
*/
start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;
200e7ac: 03 00 80 75 sethi %hi(0x201d400), %g1
200e7b0: fa 00 61 c8 ld [ %g1 + 0x1c8 ], %i5 ! 201d5c8 <imfs_memfile_bytes_per_block>
200e7b4: 92 10 00 1a mov %i2, %o1
200e7b8: a3 3f 60 1f sra %i5, 0x1f, %l1
200e7bc: 96 10 00 1d mov %i5, %o3
200e7c0: 94 10 00 11 mov %l1, %o2
200e7c4: 40 00 2a 76 call 201919c <__moddi3>
200e7c8: 90 10 00 19 mov %i1, %o0
block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;
200e7cc: 90 10 00 19 mov %i1, %o0
*/
/*
* Phase 1: possibly the last part of one block
*/
start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;
200e7d0: a0 10 00 09 mov %o1, %l0
block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;
200e7d4: 94 10 00 11 mov %l1, %o2
200e7d8: 92 10 00 1a mov %i2, %o1
200e7dc: 40 00 29 85 call 2018df0 <__divdi3>
200e7e0: 96 10 00 1d mov %i5, %o3
if ( start_offset ) {
200e7e4: 80 a4 20 00 cmp %l0, 0
200e7e8: 12 80 00 17 bne 200e844 <IMFS_memfile_write+0xcc>
200e7ec: b4 10 00 09 mov %o1, %i2
status = IMFS_memfile_extend( the_jnode, zero_fill, last_byte );
if ( status )
return status;
}
copied = 0;
200e7f0: 10 80 00 28 b 200e890 <IMFS_memfile_write+0x118>
200e7f4: ba 10 20 00 clr %i5
* in memory file, then extend the length.
*/
last_byte = start + my_length;
if ( last_byte > the_jnode->info.file.size ) {
bool zero_fill = start > the_jnode->info.file.size;
200e7f8: 80 a6 40 01 cmp %i1, %g1 <== NOT EXECUTED
200e7fc: 14 80 00 09 bg 200e820 <IMFS_memfile_write+0xa8> <== NEVER TAKEN
200e800: 92 10 20 01 mov 1, %o1
200e804: 80 a6 40 01 cmp %i1, %g1
200e808: 32 80 00 06 bne,a 200e820 <IMFS_memfile_write+0xa8> <== NEVER TAKEN
200e80c: 92 10 20 00 clr %o1 <== NOT EXECUTED
200e810: 80 a6 80 02 cmp %i2, %g2
200e814: 18 80 00 04 bgu 200e824 <IMFS_memfile_write+0xac>
200e818: 90 10 00 18 mov %i0, %o0
200e81c: 92 10 20 00 clr %o1
status = IMFS_memfile_extend( the_jnode, zero_fill, last_byte );
200e820: 90 10 00 18 mov %i0, %o0
200e824: 92 0a 60 01 and %o1, 1, %o1
200e828: 7f ff ff 6c call 200e5d8 <IMFS_memfile_extend>
200e82c: 94 10 20 00 clr %o2
if ( status )
200e830: 82 92 20 00 orcc %o0, 0, %g1
200e834: 22 bf ff df be,a 200e7b0 <IMFS_memfile_write+0x38>
200e838: 03 00 80 75 sethi %hi(0x201d400), %g1
}
IMFS_mtime_ctime_update( the_jnode );
return copied;
}
200e83c: 81 c7 e0 08 ret
200e840: 91 e8 00 01 restore %g0, %g1, %o0
* 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;
200e844: ba 27 40 10 sub %i5, %l0, %i5
200e848: 80 a7 40 1c cmp %i5, %i4
200e84c: 38 80 00 02 bgu,a 200e854 <IMFS_memfile_write+0xdc>
200e850: ba 10 00 1c mov %i4, %i5
if ( to_copy > my_length )
to_copy = my_length;
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
200e854: 90 10 00 18 mov %i0, %o0
200e858: 92 10 00 1a mov %i2, %o1
200e85c: 7f ff fd b3 call 200df28 <IMFS_memfile_get_block_pointer>
200e860: 94 10 20 00 clr %o2
if ( !block_ptr )
200e864: 80 a2 20 00 cmp %o0, 0
200e868: 02 80 00 36 be 200e940 <IMFS_memfile_write+0x1c8> <== NEVER TAKEN
200e86c: 82 10 20 00 clr %g1
block,
to_copy,
src
);
#endif
memcpy( &(*block_ptr)[ start_offset ], src, to_copy );
200e870: d0 02 00 00 ld [ %o0 ], %o0
200e874: 92 10 00 1b mov %i3, %o1
200e878: 90 02 00 10 add %o0, %l0, %o0
200e87c: 94 10 00 1d mov %i5, %o2
200e880: 40 00 06 ab call 201032c <memcpy>
200e884: b6 06 c0 1d add %i3, %i5, %i3
src += to_copy;
block++;
200e888: b4 06 a0 01 inc %i2
my_length -= to_copy;
200e88c: b8 27 00 1d sub %i4, %i5, %i4
/*
* Phase 2: all of zero of more blocks
*/
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;
200e890: 03 00 80 75 sethi %hi(0x201d400), %g1
* 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(
200e894: b6 26 c0 1d sub %i3, %i5, %i3
/*
* Phase 2: all of zero of more blocks
*/
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;
200e898: f2 00 61 c8 ld [ %g1 + 0x1c8 ], %i1
while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {
200e89c: 10 80 00 0f b 200e8d8 <IMFS_memfile_write+0x160>
200e8a0: a2 10 00 01 mov %g1, %l1
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
200e8a4: 90 10 00 18 mov %i0, %o0
200e8a8: 92 10 00 1a mov %i2, %o1
200e8ac: 7f ff fd 9f call 200df28 <IMFS_memfile_get_block_pointer>
200e8b0: 94 10 20 00 clr %o2
if ( !block_ptr )
200e8b4: 80 a2 20 00 cmp %o0, 0
200e8b8: 02 80 00 21 be 200e93c <IMFS_memfile_write+0x1c4> <== NEVER TAKEN
200e8bc: 94 10 00 19 mov %i1, %o2
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 );
200e8c0: d0 02 00 00 ld [ %o0 ], %o0
200e8c4: 92 10 00 10 mov %l0, %o1
200e8c8: 40 00 06 99 call 201032c <memcpy>
200e8cc: b4 06 a0 01 inc %i2
src += to_copy;
block++;
my_length -= to_copy;
200e8d0: b8 27 00 19 sub %i4, %i1, %i4
* 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(
200e8d4: ba 07 40 19 add %i5, %i1, %i5
/*
* Phase 2: all of zero of more blocks
*/
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;
while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {
200e8d8: c2 04 61 c8 ld [ %l1 + 0x1c8 ], %g1
200e8dc: 80 a7 00 01 cmp %i4, %g1
200e8e0: 1a bf ff f1 bcc 200e8a4 <IMFS_memfile_write+0x12c>
200e8e4: a0 06 c0 1d add %i3, %i5, %l0
* 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 ) {
200e8e8: 80 a7 20 00 cmp %i4, 0
200e8ec: 02 80 00 0f be 200e928 <IMFS_memfile_write+0x1b0>
200e8f0: 90 07 bf f8 add %fp, -8, %o0
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
200e8f4: 90 10 00 18 mov %i0, %o0
200e8f8: 92 10 00 1a mov %i2, %o1
200e8fc: 7f ff fd 8b call 200df28 <IMFS_memfile_get_block_pointer>
200e900: 94 10 20 00 clr %o2
if ( !block_ptr )
200e904: 80 a2 20 00 cmp %o0, 0
200e908: 02 80 00 0e be 200e940 <IMFS_memfile_write+0x1c8> <== NEVER TAKEN
200e90c: 82 10 00 1d mov %i5, %g1
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 );
200e910: d0 02 00 00 ld [ %o0 ], %o0
200e914: 92 10 00 10 mov %l0, %o1
200e918: 94 10 00 1c mov %i4, %o2
200e91c: 40 00 06 84 call 201032c <memcpy>
200e920: ba 07 40 1c add %i5, %i4, %i5
my_length = 0;
copied += to_copy;
}
IMFS_mtime_ctime_update( the_jnode );
200e924: 90 07 bf f8 add %fp, -8, %o0
200e928: 7f ff d3 d7 call 2003884 <gettimeofday>
200e92c: 92 10 20 00 clr %o1
200e930: c2 07 bf f8 ld [ %fp + -8 ], %g1
200e934: c2 26 20 44 st %g1, [ %i0 + 0x44 ]
200e938: c2 26 20 48 st %g1, [ %i0 + 0x48 ]
*/
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;
while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
if ( !block_ptr )
200e93c: 82 10 00 1d mov %i5, %g1
}
IMFS_mtime_ctime_update( the_jnode );
return copied;
}
200e940: b0 10 00 01 mov %g1, %i0
200e944: 81 c7 e0 08 ret
200e948: 81 e8 00 00 restore
02003040 <IMFS_mknod>:
const char *name,
size_t namelen,
mode_t mode,
dev_t dev
)
{
2003040: 9d e3 bf 80 save %sp, -128, %sp
dev_t dev,
IMFS_jnode_types_t *type,
IMFS_types_union *info
)
{
if ( S_ISDIR( mode ) ) {
2003044: 05 00 00 3c sethi %hi(0xf000), %g2
2003048: 07 00 00 10 sethi %hi(0x4000), %g3
200304c: 84 0e c0 02 and %i3, %g2, %g2
2003050: 80 a0 80 03 cmp %g2, %g3
2003054: 02 80 00 12 be 200309c <IMFS_mknod+0x5c>
2003058: 07 00 00 20 sethi %hi(0x8000), %g3
*type = IMFS_DIRECTORY;
} else if ( S_ISREG( mode ) ) {
200305c: 80 a0 80 03 cmp %g2, %g3
2003060: 02 80 00 11 be 20030a4 <IMFS_mknod+0x64>
2003064: 09 00 00 2c sethi %hi(0xb000), %g4
*type = IMFS_MEMORY_FILE;
} else if ( S_ISBLK( mode ) || S_ISCHR( mode ) ) {
2003068: 07 00 00 08 sethi %hi(0x2000), %g3
200306c: 88 0e c0 04 and %i3, %g4, %g4
2003070: 80 a1 00 03 cmp %g4, %g3
2003074: 12 80 00 05 bne 2003088 <IMFS_mknod+0x48>
2003078: 07 00 00 04 sethi %hi(0x1000), %g3
*type = IMFS_DEVICE;
rtems_filesystem_split_dev_t(
200307c: f8 3f bf e8 std %i4, [ %fp + -24 ]
if ( S_ISDIR( mode ) ) {
*type = IMFS_DIRECTORY;
} else if ( S_ISREG( mode ) ) {
*type = IMFS_MEMORY_FILE;
} else if ( S_ISBLK( mode ) || S_ISCHR( mode ) ) {
*type = IMFS_DEVICE;
2003080: 10 80 00 0a b 20030a8 <IMFS_mknod+0x68>
2003084: 82 10 20 01 mov 1, %g1
rtems_filesystem_split_dev_t(
dev,
info->device.major,
info->device.minor
);
} else if (S_ISFIFO( mode )) {
2003088: 80 a0 80 03 cmp %g2, %g3
200308c: 32 80 00 08 bne,a 20030ac <IMFS_mknod+0x6c> <== NEVER TAKEN
2003090: c4 06 20 14 ld [ %i0 + 0x14 ], %g2 <== NOT EXECUTED
*type = IMFS_FIFO;
2003094: 10 80 00 05 b 20030a8 <IMFS_mknod+0x68>
2003098: 82 10 20 06 mov 6, %g1
IMFS_jnode_types_t *type,
IMFS_types_union *info
)
{
if ( S_ISDIR( mode ) ) {
*type = IMFS_DIRECTORY;
200309c: 10 80 00 03 b 20030a8 <IMFS_mknod+0x68>
20030a0: 82 10 20 00 clr %g1
20030a4: 82 10 20 04 mov 4, %g1
size_t namelen,
mode_t mode,
const IMFS_types_union *info
)
{
const IMFS_fs_info_t *fs_info =
20030a8: c4 06 20 14 ld [ %i0 + 0x14 ], %g2
(const IMFS_fs_info_t *) parentloc->mt_entry->fs_info;
return IMFS_create_node_with_control(
20030ac: 82 00 60 02 add %g1, 2, %g1
20030b0: c4 00 a0 08 ld [ %g2 + 8 ], %g2
20030b4: 83 28 60 02 sll %g1, 2, %g1
20030b8: d2 00 80 01 ld [ %g2 + %g1 ], %o1
20030bc: 90 10 00 18 mov %i0, %o0
20030c0: 94 10 00 19 mov %i1, %o2
20030c4: 96 10 00 1a mov %i2, %o3
20030c8: 98 10 00 1b mov %i3, %o4
20030cc: 40 00 21 ea call 200b874 <IMFS_create_node_with_control>
20030d0: 9a 07 bf e8 add %fp, -24, %o5
IMFS_jnode_t *new_node;
get_type_and_info_by_mode_and_dev( mode, dev, &type, &info );
new_node = IMFS_create_node( parentloc, type, name, namelen, mode, &info );
if ( new_node != NULL ) {
20030d4: 80 a2 20 00 cmp %o0, 0
20030d8: 02 80 00 0e be 2003110 <IMFS_mknod+0xd0>
20030dc: 90 07 bf e0 add %fp, -32, %o0
IMFS_jnode_t *parent = parentloc->node_access;
20030e0: fa 06 20 08 ld [ %i0 + 8 ], %i5
IMFS_update_ctime( parent );
20030e4: 40 00 01 e8 call 2003884 <gettimeofday>
20030e8: 92 10 20 00 clr %o1
20030ec: c2 07 bf e0 ld [ %fp + -32 ], %g1
IMFS_update_mtime( parent );
20030f0: 90 07 bf e0 add %fp, -32, %o0
new_node = IMFS_create_node( parentloc, type, name, namelen, mode, &info );
if ( new_node != NULL ) {
IMFS_jnode_t *parent = parentloc->node_access;
IMFS_update_ctime( parent );
20030f4: c2 27 60 48 st %g1, [ %i5 + 0x48 ]
IMFS_update_mtime( parent );
20030f8: 40 00 01 e3 call 2003884 <gettimeofday>
20030fc: 92 10 20 00 clr %o1
2003100: c2 07 bf e0 ld [ %fp + -32 ], %g1
2003104: c2 27 60 44 st %g1, [ %i5 + 0x44 ]
size_t namelen,
mode_t mode,
dev_t dev
)
{
int rv = 0;
2003108: 81 c7 e0 08 ret
200310c: 91 e8 20 00 restore %g0, 0, %o0
} else {
rv = -1;
}
return rv;
}
2003110: 81 c7 e0 08 ret
2003114: 91 e8 3f ff restore %g0, -1, %o0
02003118 <IMFS_mount>:
#endif
#include "imfs.h"
int IMFS_mount( rtems_filesystem_mount_table_entry_t *mt_entry )
{
2003118: 9d e3 bf a0 save %sp, -96, %sp
int rv = 0;
IMFS_jnode_t *node = mt_entry->mt_point_node->location.node_access;
200311c: c2 06 20 20 ld [ %i0 + 0x20 ], %g1
2003120: c2 00 60 08 ld [ %g1 + 8 ], %g1
return node->control->imfs_type;
}
static inline bool IMFS_is_directory( const IMFS_jnode_t *node )
{
return node->control->imfs_type == IMFS_DIRECTORY;
2003124: c4 00 60 4c ld [ %g1 + 0x4c ], %g2
if ( IMFS_is_directory( node ) ) {
2003128: c4 00 80 00 ld [ %g2 ], %g2
200312c: 80 a0 a0 00 cmp %g2, 0
2003130: 12 80 00 0d bne 2003164 <IMFS_mount+0x4c>
2003134: 01 00 00 00 nop
if ( node->info.directory.mt_fs == NULL ) {
2003138: c4 00 60 5c ld [ %g1 + 0x5c ], %g2
200313c: 80 a0 a0 00 cmp %g2, 0
2003140: 12 80 00 05 bne 2003154 <IMFS_mount+0x3c> <== NEVER TAKEN
2003144: 01 00 00 00 nop
node->info.directory.mt_fs = mt_entry;
2003148: f0 20 60 5c st %i0, [ %g1 + 0x5c ]
#include "imfs.h"
int IMFS_mount( rtems_filesystem_mount_table_entry_t *mt_entry )
{
int rv = 0;
200314c: 81 c7 e0 08 ret
2003150: 91 e8 20 00 restore %g0, 0, %o0
if ( IMFS_is_directory( node ) ) {
if ( node->info.directory.mt_fs == NULL ) {
node->info.directory.mt_fs = mt_entry;
} else {
errno = EBUSY;
2003154: 40 00 32 2f call 200fa10 <__errno> <== NOT EXECUTED
2003158: 01 00 00 00 nop <== NOT EXECUTED
200315c: 10 80 00 05 b 2003170 <IMFS_mount+0x58> <== NOT EXECUTED
2003160: 82 10 20 10 mov 0x10, %g1 ! 10 <PROM_START+0x10> <== NOT EXECUTED
rv = -1;
}
} else {
errno = ENOTDIR;
2003164: 40 00 32 2b call 200fa10 <__errno>
2003168: 01 00 00 00 nop
200316c: 82 10 20 14 mov 0x14, %g1 ! 14 <PROM_START+0x14>
2003170: c2 22 00 00 st %g1, [ %o0 ]
rv = -1;
}
return rv;
}
2003174: 81 c7 e0 08 ret
2003178: 91 e8 3f ff restore %g0, -1, %o0
0200bcc4 <IMFS_node_remove_directory>:
static IMFS_jnode_t *IMFS_node_remove_directory(
IMFS_jnode_t *node,
const IMFS_jnode_t *root_node
)
{
200bcc4: 9d e3 bf a0 save %sp, -96, %sp
if ( !rtems_chain_is_empty( &node->info.directory.Entries ) ) {
200bcc8: c4 06 20 50 ld [ %i0 + 0x50 ], %g2
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
200bccc: 82 06 20 54 add %i0, 0x54, %g1
200bcd0: 80 a0 80 01 cmp %g2, %g1
200bcd4: 02 80 00 06 be 200bcec <IMFS_node_remove_directory+0x28>
200bcd8: 80 a6 00 19 cmp %i0, %i1
errno = ENOTEMPTY;
200bcdc: 40 00 0f 4d call 200fa10 <__errno>
200bce0: 01 00 00 00 nop
200bce4: 10 80 00 0b b 200bd10 <IMFS_node_remove_directory+0x4c>
200bce8: 82 10 20 5a mov 0x5a, %g1 ! 5a <PROM_START+0x5a>
node = NULL;
} else if ( node == root_node || IMFS_is_mount_point( node ) ) {
200bcec: 02 80 00 06 be 200bd04 <IMFS_node_remove_directory+0x40>
200bcf0: 01 00 00 00 nop
200bcf4: c2 06 20 5c ld [ %i0 + 0x5c ], %g1
200bcf8: 80 a0 60 00 cmp %g1, 0
200bcfc: 02 80 00 07 be 200bd18 <IMFS_node_remove_directory+0x54> <== ALWAYS TAKEN
200bd00: 01 00 00 00 nop
errno = EBUSY;
200bd04: 40 00 0f 43 call 200fa10 <__errno>
200bd08: 01 00 00 00 nop
200bd0c: 82 10 20 10 mov 0x10, %g1 ! 10 <PROM_START+0x10>
200bd10: c2 22 00 00 st %g1, [ %o0 ]
node = NULL;
200bd14: b0 10 20 00 clr %i0
}
return node;
}
200bd18: 81 c7 e0 08 ret
200bd1c: 81 e8 00 00 restore
0200317c <IMFS_node_type>:
rtems_filesystem_node_types_t IMFS_node_type(
const rtems_filesystem_location_info_t *loc
)
{
const IMFS_jnode_t *node = loc->node_access;
200317c: c4 02 20 08 ld [ %o0 + 8 ], %g2
rtems_chain_extract_unprotected( &node->Node );
}
static inline IMFS_jnode_types_t IMFS_type( const IMFS_jnode_t *node )
{
return node->control->imfs_type;
2003180: c2 00 a0 4c ld [ %g2 + 0x4c ], %g1
2003184: c2 00 40 00 ld [ %g1 ], %g1
IMFS_jnode_types_t imfs_type = IMFS_type( node );
rtems_filesystem_node_types_t type;
switch ( imfs_type ) {
2003188: 80 a0 60 02 cmp %g1, 2
200318c: 02 80 00 06 be 20031a4 <IMFS_node_type+0x28>
2003190: 80 a0 60 05 cmp %g1, 5
2003194: 12 80 00 08 bne 20031b4 <IMFS_node_type+0x38> <== ALWAYS TAKEN
2003198: 90 10 20 04 mov 4, %o0
200319c: 81 c3 e0 08 retl <== NOT EXECUTED
20031a0: 01 00 00 00 nop <== NOT EXECUTED
20031a4: c2 00 a0 50 ld [ %g2 + 0x50 ], %g1
20031a8: c2 00 60 4c ld [ %g1 + 0x4c ], %g1
case IMFS_HARD_LINK:
type = IMFS_type( node->info.hard_link.link_node );
break;
20031ac: 81 c3 e0 08 retl
20031b0: d0 00 40 00 ld [ %g1 ], %o0
type = imfs_type;
break;
}
return type;
}
20031b4: 81 c3 e0 08 retl
20031b8: 90 10 00 01 mov %g1, %o0
020031f8 <IMFS_rename>:
const rtems_filesystem_location_info_t *oldloc,
const rtems_filesystem_location_info_t *newparentloc,
const char *name,
size_t namelen
)
{
20031f8: 9d e3 bf 98 save %sp, -104, %sp
int rv = 0;
IMFS_jnode_t *node = oldloc->node_access;
20031fc: fa 06 60 08 ld [ %i1 + 8 ], %i5
/*
* FIXME: Due to insufficient checks we can create inaccessible nodes with
* this operation.
*/
if ( node->Parent != NULL ) {
2003200: c2 07 60 08 ld [ %i5 + 8 ], %g1
2003204: 80 a0 60 00 cmp %g1, 0
2003208: 02 80 00 20 be 2003288 <IMFS_rename+0x90> <== NEVER TAKEN
200320c: f4 06 a0 08 ld [ %i2 + 8 ], %i2
if ( namelen < IMFS_NAME_MAX ) {
2003210: 80 a7 20 1f cmp %i4, 0x1f
2003214: 18 80 00 19 bgu 2003278 <IMFS_rename+0x80> <== NEVER TAKEN
2003218: 94 10 00 1c mov %i4, %o2
memcpy( node->name, name, namelen );
200321c: 92 10 00 1b mov %i3, %o1
2003220: 40 00 34 43 call 201032c <memcpy>
2003224: 90 07 60 0c add %i5, 0xc, %o0
node->name [namelen] = '\0';
2003228: b8 07 40 1c add %i5, %i4, %i4
200322c: c0 2f 20 0c clrb [ %i4 + 0xc ]
)
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
2003230: c4 07 40 00 ld [ %i5 ], %g2
previous = the_node->previous;
2003234: c2 07 60 04 ld [ %i5 + 4 ], %g1
IMFS_remove_from_directory( node );
IMFS_add_to_directory( new_parent, node );
IMFS_update_ctime( node );
2003238: 90 07 bf f8 add %fp, -8, %o0
next->previous = previous;
200323c: c2 20 a0 04 st %g1, [ %g2 + 4 ]
previous->next = next;
2003240: c4 20 40 00 st %g2, [ %g1 ]
static inline void IMFS_add_to_directory(
IMFS_jnode_t *dir,
IMFS_jnode_t *node
)
{
node->Parent = dir;
2003244: f4 27 60 08 st %i2, [ %i5 + 8 ]
Chain_Control *the_chain,
Chain_Node *the_node
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
2003248: c2 06 a0 58 ld [ %i2 + 0x58 ], %g1
RTEMS_INLINE_ROUTINE void _Chain_Append_unprotected(
Chain_Control *the_chain,
Chain_Node *the_node
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
200324c: 84 06 a0 54 add %i2, 0x54, %g2
Chain_Node *old_last = tail->previous;
the_node->next = tail;
tail->previous = the_node;
2003250: fa 26 a0 58 st %i5, [ %i2 + 0x58 ]
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
the_node->next = tail;
2003254: c4 27 40 00 st %g2, [ %i5 ]
tail->previous = the_node;
old_last->next = the_node;
2003258: fa 20 40 00 st %i5, [ %g1 ]
the_node->previous = old_last;
200325c: c2 27 60 04 st %g1, [ %i5 + 4 ]
2003260: 40 00 01 89 call 2003884 <gettimeofday>
2003264: 92 10 20 00 clr %o1
2003268: c2 07 bf f8 ld [ %fp + -8 ], %g1
200326c: c2 27 60 48 st %g1, [ %i5 + 0x48 ]
const rtems_filesystem_location_info_t *newparentloc,
const char *name,
size_t namelen
)
{
int rv = 0;
2003270: 81 c7 e0 08 ret
2003274: 91 e8 20 00 restore %g0, 0, %o0
IMFS_remove_from_directory( node );
IMFS_add_to_directory( new_parent, node );
IMFS_update_ctime( node );
} else {
errno = ENAMETOOLONG;
2003278: 40 00 31 e6 call 200fa10 <__errno> <== NOT EXECUTED
200327c: 01 00 00 00 nop <== NOT EXECUTED
2003280: 10 80 00 05 b 2003294 <IMFS_rename+0x9c> <== NOT EXECUTED
2003284: 82 10 20 5b mov 0x5b, %g1 ! 5b <PROM_START+0x5b> <== NOT EXECUTED
rv = -1;
}
} else {
errno = EINVAL;
2003288: 40 00 31 e2 call 200fa10 <__errno> <== NOT EXECUTED
200328c: 01 00 00 00 nop <== NOT EXECUTED
2003290: 82 10 20 16 mov 0x16, %g1 ! 16 <PROM_START+0x16> <== NOT EXECUTED
2003294: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
rv = -1;
}
return rv;
}
2003298: 81 c7 e0 08 ret <== NOT EXECUTED
200329c: 91 e8 3f ff restore %g0, -1, %o0 <== NOT EXECUTED
02003380 <IMFS_unmount>:
#endif
#include "imfs.h"
int IMFS_unmount( rtems_filesystem_mount_table_entry_t *mt_entry )
{
2003380: 9d e3 bf a0 save %sp, -96, %sp
int rv = 0;
IMFS_jnode_t *node = mt_entry->mt_point_node->location.node_access;
2003384: c2 06 20 20 ld [ %i0 + 0x20 ], %g1
2003388: c2 00 60 08 ld [ %g1 + 8 ], %g1
return node->control->imfs_type;
}
static inline bool IMFS_is_directory( const IMFS_jnode_t *node )
{
return node->control->imfs_type == IMFS_DIRECTORY;
200338c: c4 00 60 4c ld [ %g1 + 0x4c ], %g2
if ( IMFS_is_directory( node ) ) {
2003390: c4 00 80 00 ld [ %g2 ], %g2
2003394: 80 a0 a0 00 cmp %g2, 0
2003398: 12 80 00 0d bne 20033cc <IMFS_unmount+0x4c> <== NEVER TAKEN
200339c: 01 00 00 00 nop
if ( node->info.directory.mt_fs == mt_entry ) {
20033a0: c4 00 60 5c ld [ %g1 + 0x5c ], %g2
20033a4: 80 a0 80 18 cmp %g2, %i0
20033a8: 12 80 00 05 bne 20033bc <IMFS_unmount+0x3c> <== NEVER TAKEN
20033ac: 01 00 00 00 nop
node->info.directory.mt_fs = NULL;
20033b0: c0 20 60 5c clr [ %g1 + 0x5c ]
#include "imfs.h"
int IMFS_unmount( rtems_filesystem_mount_table_entry_t *mt_entry )
{
int rv = 0;
20033b4: 81 c7 e0 08 ret
20033b8: 91 e8 20 00 restore %g0, 0, %o0
if ( IMFS_is_directory( node ) ) {
if ( node->info.directory.mt_fs == mt_entry ) {
node->info.directory.mt_fs = NULL;
} else {
errno = EINVAL;
20033bc: 40 00 31 95 call 200fa10 <__errno> <== NOT EXECUTED
20033c0: 01 00 00 00 nop <== NOT EXECUTED
20033c4: 10 80 00 05 b 20033d8 <IMFS_unmount+0x58> <== NOT EXECUTED
20033c8: 82 10 20 16 mov 0x16, %g1 ! 16 <PROM_START+0x16> <== NOT EXECUTED
rv = -1;
}
} else {
errno = ENOTDIR;
20033cc: 40 00 31 91 call 200fa10 <__errno> <== NOT EXECUTED
20033d0: 01 00 00 00 nop <== NOT EXECUTED
20033d4: 82 10 20 14 mov 0x14, %g1 ! 14 <PROM_START+0x14> <== NOT EXECUTED
20033d8: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
rv = -1;
}
return rv;
}
20033dc: 81 c7 e0 08 ret <== NOT EXECUTED
20033e0: 91 e8 3f ff restore %g0, -1, %o0 <== NOT EXECUTED
02007260 <Stack_check_Dump_threads_usage>:
static rtems_printk_plugin_t print_handler;
static void Stack_check_Dump_threads_usage(
Thread_Control *the_thread
)
{
2007260: 9d e3 bf 98 save %sp, -104, %sp
/*
* Obtain interrupt stack information
*/
#if (CPU_ALLOCATE_INTERRUPT_STACK == TRUE)
if (the_thread == (Thread_Control *) -1) {
2007264: 80 a6 3f ff cmp %i0, -1
2007268: 32 80 00 0a bne,a 2007290 <Stack_check_Dump_threads_usage+0x30>
200726c: e0 06 21 40 ld [ %i0 + 0x140 ], %l0
if (!Stack_check_Interrupt_stack.area)
2007270: 3b 00 81 bd sethi %hi(0x206f400), %i5
2007274: ba 17 61 d4 or %i5, 0x1d4, %i5 ! 206f5d4 <Stack_check_Interrupt_stack>
2007278: c2 07 60 04 ld [ %i5 + 4 ], %g1
200727c: 80 a0 60 00 cmp %g1, 0
2007280: 02 80 00 4c be 20073b0 <Stack_check_Dump_threads_usage+0x150><== NEVER TAKEN
2007284: a0 10 20 00 clr %l0
return;
stack = &Stack_check_Interrupt_stack;
the_thread = 0;
2007288: 10 80 00 04 b 2007298 <Stack_check_Dump_threads_usage+0x38>
200728c: b0 10 20 00 clr %i0
current = 0;
} else
#endif
{
stack = &the_thread->Start.Initial_stack;
2007290: ba 06 20 b4 add %i0, 0xb4, %i5
current = (void *)_CPU_Context_Get_SP( &the_thread->Registers );
}
low = Stack_check_usable_stack_start(stack);
2007294: c2 07 60 04 ld [ %i5 + 4 ], %g1
size = Stack_check_usable_stack_size(stack);
2007298: f2 07 40 00 ld [ %i5 ], %i1
{
stack = &the_thread->Start.Initial_stack;
current = (void *)_CPU_Context_Get_SP( &the_thread->Registers );
}
low = Stack_check_usable_stack_start(stack);
200729c: 84 00 60 10 add %g1, 0x10, %g2
size = Stack_check_usable_stack_size(stack);
20072a0: b2 06 7f f0 add %i1, -16, %i1
/*
* start at lower memory and find first word that does not
* match pattern
*/
base += PATTERN_SIZE_WORDS;
20072a4: 82 00 60 20 add %g1, 0x20, %g1
for (ebase = base + length; base < ebase; base++)
20072a8: 86 0e 7f fc and %i1, -4, %g3
if (*base != U32_PATTERN)
20072ac: 09 29 69 69 sethi %hi(0xa5a5a400), %g4
* start at lower memory and find first word that does not
* match pattern
*/
base += PATTERN_SIZE_WORDS;
for (ebase = base + length; base < ebase; base++)
20072b0: 86 00 40 03 add %g1, %g3, %g3
if (*base != U32_PATTERN)
20072b4: 10 80 00 06 b 20072cc <Stack_check_Dump_threads_usage+0x6c>
20072b8: 88 11 21 a5 or %g4, 0x1a5, %g4
20072bc: 80 a7 00 04 cmp %i4, %g4
20072c0: 12 80 00 08 bne 20072e0 <Stack_check_Dump_threads_usage+0x80>
20072c4: 80 a0 60 00 cmp %g1, 0
* start at lower memory and find first word that does not
* match pattern
*/
base += PATTERN_SIZE_WORDS;
for (ebase = base + length; base < ebase; base++)
20072c8: 82 00 60 04 add %g1, 4, %g1
20072cc: 80 a0 40 03 cmp %g1, %g3
20072d0: 2a bf ff fb bcs,a 20072bc <Stack_check_Dump_threads_usage+0x5c><== ALWAYS TAKEN
20072d4: f8 00 40 00 ld [ %g1 ], %i4
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;
20072d8: 10 80 00 06 b 20072f0 <Stack_check_Dump_threads_usage+0x90><== NOT EXECUTED
20072dc: b8 10 20 00 clr %i4 <== 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 )
20072e0: 02 80 00 04 be 20072f0 <Stack_check_Dump_threads_usage+0x90><== NEVER TAKEN
20072e4: b8 10 20 00 clr %i4
used = Stack_check_Calculate_used( low, size, high_water_mark );
20072e8: b8 00 80 19 add %g2, %i1, %i4
20072ec: b8 27 00 01 sub %i4, %g1, %i4
else
used = 0;
#if (CPU_ALLOCATE_INTERRUPT_STACK == TRUE)
if ( the_thread )
20072f0: 80 a6 20 00 cmp %i0, 0
20072f4: 02 80 00 12 be 200733c <Stack_check_Dump_threads_usage+0xdc>
20072f8: 03 00 81 b2 sethi %hi(0x206c800), %g1
#endif
{
(*print_handler)(
20072fc: f6 06 20 08 ld [ %i0 + 8 ], %i3
2007300: f4 00 60 70 ld [ %g1 + 0x70 ], %i2
2007304: 03 00 81 b2 sethi %hi(0x206c800), %g1
2007308: e2 00 60 6c ld [ %g1 + 0x6c ], %l1 ! 206c86c <print_context>
200730c: 94 07 bf f8 add %fp, -8, %o2
2007310: 90 10 00 1b mov %i3, %o0
2007314: 40 00 17 ad call 200d1c8 <rtems_object_get_name>
2007318: 92 10 20 05 mov 5, %o1
200731c: 13 00 81 7b sethi %hi(0x205ec00), %o1
2007320: 96 10 00 08 mov %o0, %o3
2007324: 92 12 62 48 or %o1, 0x248, %o1
2007328: 90 10 00 11 mov %l1, %o0
200732c: 9f c6 80 00 call %i2
2007330: 94 10 00 1b mov %i3, %o2
(*print_handler)(
print_context,
" %010p - %010p %010p %8" PRId32 " ",
stack->area,
stack->area + stack->size - 1,
2007334: 10 80 00 0a b 200735c <Stack_check_Dump_threads_usage+0xfc>
2007338: d4 07 60 04 ld [ %i5 + 4 ], %o2
rtems_object_get_name( the_thread->Object.id, sizeof(name), name )
);
}
#if (CPU_ALLOCATE_INTERRUPT_STACK == TRUE)
else {
(*print_handler)( print_context, "0x%08" PRIx32 " INTR", ~0 );
200733c: 05 00 81 b2 sethi %hi(0x206c800), %g2
2007340: c2 00 60 70 ld [ %g1 + 0x70 ], %g1
2007344: d0 00 a0 6c ld [ %g2 + 0x6c ], %o0
2007348: 13 00 81 7b sethi %hi(0x205ec00), %o1
200734c: 94 10 3f ff mov -1, %o2
2007350: 9f c0 40 00 call %g1
2007354: 92 12 62 58 or %o1, 0x258, %o1
(*print_handler)(
print_context,
" %010p - %010p %010p %8" PRId32 " ",
stack->area,
stack->area + stack->size - 1,
2007358: d4 07 60 04 ld [ %i5 + 4 ], %o2
else {
(*print_handler)( print_context, "0x%08" PRIx32 " INTR", ~0 );
}
#endif
(*print_handler)(
200735c: 35 00 81 b2 sethi %hi(0x206c800), %i2
2007360: 37 00 81 b2 sethi %hi(0x206c800), %i3
print_context,
" %010p - %010p %010p %8" PRId32 " ",
stack->area,
stack->area + stack->size - 1,
2007364: d6 07 40 00 ld [ %i5 ], %o3
else {
(*print_handler)( print_context, "0x%08" PRIx32 " INTR", ~0 );
}
#endif
(*print_handler)(
2007368: c2 06 a0 70 ld [ %i2 + 0x70 ], %g1
200736c: d0 06 e0 6c ld [ %i3 + 0x6c ], %o0
print_context,
" %010p - %010p %010p %8" PRId32 " ",
stack->area,
stack->area + stack->size - 1,
2007370: 96 02 ff ff add %o3, -1, %o3
else {
(*print_handler)( print_context, "0x%08" PRIx32 " INTR", ~0 );
}
#endif
(*print_handler)(
2007374: 13 00 81 7b sethi %hi(0x205ec00), %o1
2007378: 96 02 80 0b add %o2, %o3, %o3
200737c: 92 12 62 68 or %o1, 0x268, %o1
2007380: 98 10 00 10 mov %l0, %o4
2007384: 9f c0 40 00 call %g1
2007388: 9a 10 00 19 mov %i1, %o5
stack->area + stack->size - 1,
current,
size
);
if (Stack_check_Initialized == 0) {
200738c: 03 00 81 b2 sethi %hi(0x206c800), %g1
2007390: c2 00 60 68 ld [ %g1 + 0x68 ], %g1 ! 206c868 <Stack_check_Initialized>
(*print_handler)( print_context, "Unavailable\n" );
2007394: d0 06 e0 6c ld [ %i3 + 0x6c ], %o0
stack->area + stack->size - 1,
current,
size
);
if (Stack_check_Initialized == 0) {
2007398: 80 a0 60 00 cmp %g1, 0
200739c: 12 80 00 07 bne 20073b8 <Stack_check_Dump_threads_usage+0x158><== ALWAYS TAKEN
20073a0: c2 06 a0 70 ld [ %i2 + 0x70 ], %g1
(*print_handler)( print_context, "Unavailable\n" );
20073a4: 13 00 81 7b sethi %hi(0x205ec00), %o1 <== NOT EXECUTED
20073a8: 9f c0 40 00 call %g1 <== NOT EXECUTED
20073ac: 92 12 62 88 or %o1, 0x288, %o1 ! 205ee88 <write_block_string.9494+0x5b8><== NOT EXECUTED
20073b0: 81 c7 e0 08 ret <== NOT EXECUTED
20073b4: 81 e8 00 00 restore <== NOT EXECUTED
} else {
(*print_handler)( print_context, "%8" PRId32 "\n", used );
20073b8: 13 00 81 7b sethi %hi(0x205ec00), %o1
20073bc: 94 10 00 1c mov %i4, %o2
20073c0: 9f c0 40 00 call %g1
20073c4: 92 12 62 98 or %o1, 0x298, %o1
20073c8: 81 c7 e0 08 ret
20073cc: 81 e8 00 00 restore
020074b8 <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)
{
20074b8: 9d e3 bf 80 save %sp, -128, %sp
Stack_Control *stack = &running->Start.Initial_stack;
void *pattern_area = Stack_check_Get_pattern(stack);
char name[32];
printk("BLOWN STACK!!!\n");
20074bc: 11 00 81 7b sethi %hi(0x205ec00), %o0
) RTEMS_COMPILER_NO_RETURN_ATTRIBUTE;
void Stack_check_report_blown_task(Thread_Control *running, bool pattern_ok)
{
Stack_Control *stack = &running->Start.Initial_stack;
void *pattern_area = Stack_check_Get_pattern(stack);
20074c0: fa 06 20 b8 ld [ %i0 + 0xb8 ], %i5
char name[32];
printk("BLOWN STACK!!!\n");
20074c4: 40 00 0a 17 call 2009d20 <printk>
20074c8: 90 12 22 a0 or %o0, 0x2a0, %o0
printk("task control block: 0x%08" PRIxPTR "\n", running);
20074cc: 92 10 00 18 mov %i0, %o1
20074d0: 11 00 81 7b sethi %hi(0x205ec00), %o0
20074d4: 40 00 0a 13 call 2009d20 <printk>
20074d8: 90 12 22 b0 or %o0, 0x2b0, %o0 ! 205eeb0 <write_block_string.9494+0x5e0>
printk("task ID: 0x%08lx\n", (unsigned long) running->Object.id);
20074dc: d2 06 20 08 ld [ %i0 + 8 ], %o1
20074e0: 11 00 81 7b sethi %hi(0x205ec00), %o0
20074e4: 40 00 0a 0f call 2009d20 <printk>
20074e8: 90 12 22 d0 or %o0, 0x2d0, %o0 ! 205eed0 <write_block_string.9494+0x600>
printk(
20074ec: d2 06 20 0c ld [ %i0 + 0xc ], %o1
20074f0: 11 00 81 7b sethi %hi(0x205ec00), %o0
20074f4: 40 00 0a 0b call 2009d20 <printk>
20074f8: 90 12 22 e8 or %o0, 0x2e8, %o0 ! 205eee8 <write_block_string.9494+0x618>
"task name: 0x%08" PRIx32 "\n",
running->Object.name.name_u32
);
printk(
20074fc: d0 06 20 08 ld [ %i0 + 8 ], %o0
2007500: 94 07 bf e0 add %fp, -32, %o2
2007504: 40 00 17 31 call 200d1c8 <rtems_object_get_name>
2007508: 92 10 20 20 mov 0x20, %o1
200750c: 92 10 00 08 mov %o0, %o1
2007510: 11 00 81 7b sethi %hi(0x205ec00), %o0
2007514: 40 00 0a 03 call 2009d20 <printk>
2007518: 90 12 23 00 or %o0, 0x300, %o0 ! 205ef00 <write_block_string.9494+0x630>
);
printk(
"task stack area (%lu Bytes): 0x%08" PRIxPTR " .. 0x%08" PRIxPTR "\n",
(unsigned long) stack->size,
stack->area,
((char *) stack->area + stack->size)
200751c: d4 06 20 b8 ld [ %i0 + 0xb8 ], %o2
2007520: d2 06 20 b4 ld [ %i0 + 0xb4 ], %o1
);
printk(
"task name string: %s\n",
rtems_object_get_name(running->Object.id, sizeof(name), name)
);
printk(
2007524: 11 00 81 7b sethi %hi(0x205ec00), %o0
2007528: 96 02 80 09 add %o2, %o1, %o3
200752c: 40 00 09 fd call 2009d20 <printk>
2007530: 90 12 23 18 or %o0, 0x318, %o0
"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) {
2007534: 80 a6 60 00 cmp %i1, 0
2007538: 12 80 00 07 bne 2007554 <Stack_check_report_blown_task+0x9c><== NEVER TAKEN
200753c: 11 00 81 7b sethi %hi(0x205ec00), %o0
printk(
2007540: 92 10 20 10 mov 0x10, %o1
2007544: 90 12 23 48 or %o0, 0x348, %o0
2007548: 94 07 60 08 add %i5, 8, %o2
200754c: 40 00 09 f5 call 2009d20 <printk>
2007550: 96 07 60 18 add %i5, 0x18, %o3
rtems_configuration_get_user_multiprocessing_table()->node
);
}
#endif
rtems_fatal_error_occurred(0x81);
2007554: 40 00 19 e7 call 200dcf0 <rtems_fatal_error_occurred>
2007558: 90 10 20 81 mov 0x81, %o0
0200a930 <_CORE_RWLock_Release>:
*/
CORE_RWLock_Status _CORE_RWLock_Release(
CORE_RWLock_Control *the_rwlock
)
{
200a930: 9d e3 bf a0 save %sp, -96, %sp
ISR_Level level;
Thread_Control *executing = _Thread_Executing;
200a934: 03 00 80 84 sethi %hi(0x2021000), %g1
* Otherwise, we have to block.
* If locked for reading and no waiters, then OK to read.
* If any thread is waiting, then we wait.
*/
_ISR_Disable( level );
200a938: 7f ff e4 aa call 2003be0 <sparc_disable_interrupts>
200a93c: fa 00 61 2c ld [ %g1 + 0x12c ], %i5 ! 202112c <_Per_CPU_Information+0xc>
200a940: 84 10 00 08 mov %o0, %g2
if ( the_rwlock->current_state == CORE_RWLOCK_UNLOCKED){
200a944: c2 06 20 44 ld [ %i0 + 0x44 ], %g1
200a948: 80 a0 60 00 cmp %g1, 0
200a94c: 12 80 00 08 bne 200a96c <_CORE_RWLock_Release+0x3c>
200a950: 80 a0 60 01 cmp %g1, 1
_ISR_Enable( level );
200a954: 7f ff e4 a7 call 2003bf0 <sparc_enable_interrupts>
200a958: b0 10 20 00 clr %i0
executing->Wait.return_code = CORE_RWLOCK_UNAVAILABLE;
200a95c: 82 10 20 02 mov 2, %g1
200a960: c2 27 60 34 st %g1, [ %i5 + 0x34 ]
200a964: 81 c7 e0 08 ret
200a968: 81 e8 00 00 restore
return CORE_RWLOCK_SUCCESSFUL;
}
if ( the_rwlock->current_state == CORE_RWLOCK_LOCKED_FOR_READING ) {
200a96c: 32 80 00 0b bne,a 200a998 <_CORE_RWLock_Release+0x68>
200a970: c0 27 60 34 clr [ %i5 + 0x34 ]
the_rwlock->number_of_readers -= 1;
200a974: c2 06 20 48 ld [ %i0 + 0x48 ], %g1
200a978: 82 00 7f ff add %g1, -1, %g1
if ( the_rwlock->number_of_readers != 0 ) {
200a97c: 80 a0 60 00 cmp %g1, 0
200a980: 02 80 00 05 be 200a994 <_CORE_RWLock_Release+0x64>
200a984: c2 26 20 48 st %g1, [ %i0 + 0x48 ]
/* must be unlocked again */
_ISR_Enable( level );
200a988: 7f ff e4 9a call 2003bf0 <sparc_enable_interrupts>
200a98c: b0 10 20 00 clr %i0
return CORE_RWLOCK_SUCCESSFUL;
200a990: 30 80 00 24 b,a 200aa20 <_CORE_RWLock_Release+0xf0>
}
}
/* CORE_RWLOCK_LOCKED_FOR_WRITING or READING with readers */
executing->Wait.return_code = CORE_RWLOCK_SUCCESSFUL;
200a994: c0 27 60 34 clr [ %i5 + 0x34 ]
/*
* Implicitly transition to "unlocked" and find another thread interested
* in obtaining this rwlock.
*/
the_rwlock->current_state = CORE_RWLOCK_UNLOCKED;
200a998: c0 26 20 44 clr [ %i0 + 0x44 ]
_ISR_Enable( level );
200a99c: 7f ff e4 95 call 2003bf0 <sparc_enable_interrupts>
200a9a0: 90 10 00 02 mov %g2, %o0
next = _Thread_queue_Dequeue( &the_rwlock->Wait_queue );
200a9a4: 40 00 07 9d call 200c818 <_Thread_queue_Dequeue>
200a9a8: 90 10 00 18 mov %i0, %o0
if ( next ) {
200a9ac: 80 a2 20 00 cmp %o0, 0
200a9b0: 22 80 00 1c be,a 200aa20 <_CORE_RWLock_Release+0xf0>
200a9b4: b0 10 20 00 clr %i0
if ( next->Wait.option == CORE_RWLOCK_THREAD_WAITING_FOR_WRITE ) {
200a9b8: c2 02 20 30 ld [ %o0 + 0x30 ], %g1
200a9bc: 80 a0 60 01 cmp %g1, 1
200a9c0: 32 80 00 05 bne,a 200a9d4 <_CORE_RWLock_Release+0xa4>
200a9c4: c2 06 20 48 ld [ %i0 + 0x48 ], %g1
the_rwlock->current_state = CORE_RWLOCK_LOCKED_FOR_WRITING;
200a9c8: 82 10 20 02 mov 2, %g1
return CORE_RWLOCK_SUCCESSFUL;
200a9cc: 10 80 00 14 b 200aa1c <_CORE_RWLock_Release+0xec>
200a9d0: c2 26 20 44 st %g1, [ %i0 + 0x44 ]
}
/*
* Must be CORE_RWLOCK_THREAD_WAITING_FOR_READING
*/
the_rwlock->number_of_readers += 1;
200a9d4: 82 00 60 01 inc %g1
200a9d8: c2 26 20 48 st %g1, [ %i0 + 0x48 ]
the_rwlock->current_state = CORE_RWLOCK_LOCKED_FOR_READING;
200a9dc: 82 10 20 01 mov 1, %g1
200a9e0: c2 26 20 44 st %g1, [ %i0 + 0x44 ]
/*
* Now see if more readers can be let go.
*/
while ( 1 ) {
next = _Thread_queue_First( &the_rwlock->Wait_queue );
200a9e4: 40 00 08 c9 call 200cd08 <_Thread_queue_First>
200a9e8: 90 10 00 18 mov %i0, %o0
if ( !next ||
200a9ec: 92 92 20 00 orcc %o0, 0, %o1
200a9f0: 22 80 00 0c be,a 200aa20 <_CORE_RWLock_Release+0xf0>
200a9f4: b0 10 20 00 clr %i0
200a9f8: c2 02 60 30 ld [ %o1 + 0x30 ], %g1
200a9fc: 80 a0 60 01 cmp %g1, 1
200aa00: 02 80 00 07 be 200aa1c <_CORE_RWLock_Release+0xec> <== NEVER TAKEN
200aa04: 90 10 00 18 mov %i0, %o0
next->Wait.option == CORE_RWLOCK_THREAD_WAITING_FOR_WRITE )
return CORE_RWLOCK_SUCCESSFUL;
the_rwlock->number_of_readers += 1;
200aa08: c2 06 20 48 ld [ %i0 + 0x48 ], %g1
200aa0c: 82 00 60 01 inc %g1
_Thread_queue_Extract( &the_rwlock->Wait_queue, next );
200aa10: 40 00 08 6f call 200cbcc <_Thread_queue_Extract>
200aa14: c2 26 20 48 st %g1, [ %i0 + 0x48 ]
}
200aa18: 30 bf ff f3 b,a 200a9e4 <_CORE_RWLock_Release+0xb4>
}
/* indentation is to match _ISR_Disable at top */
return CORE_RWLOCK_SUCCESSFUL;
}
200aa1c: b0 10 20 00 clr %i0
200aa20: 81 c7 e0 08 ret
200aa24: 81 e8 00 00 restore
0200aa28 <_CORE_RWLock_Timeout>:
void _CORE_RWLock_Timeout(
Objects_Id id,
void *ignored
)
{
200aa28: 9d e3 bf 98 save %sp, -104, %sp
Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
200aa2c: 90 10 00 18 mov %i0, %o0
200aa30: 40 00 06 a2 call 200c4b8 <_Thread_Get>
200aa34: 92 07 bf fc add %fp, -4, %o1
switch ( location ) {
200aa38: c2 07 bf fc ld [ %fp + -4 ], %g1
200aa3c: 80 a0 60 00 cmp %g1, 0
200aa40: 12 80 00 09 bne 200aa64 <_CORE_RWLock_Timeout+0x3c> <== NEVER TAKEN
200aa44: 01 00 00 00 nop
#if defined(RTEMS_MULTIPROCESSING)
case OBJECTS_REMOTE: /* impossible */
#endif
break;
case OBJECTS_LOCAL:
_Thread_queue_Process_timeout( the_thread );
200aa48: 40 00 08 ed call 200cdfc <_Thread_queue_Process_timeout>
200aa4c: 01 00 00 00 nop
*
* This routine decrements the thread dispatch level.
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_decrement_disable_level(void)
{
_Thread_Dispatch_disable_level--;
200aa50: 03 00 80 82 sethi %hi(0x2020800), %g1
200aa54: c4 00 63 f0 ld [ %g1 + 0x3f0 ], %g2 ! 2020bf0 <_Thread_Dispatch_disable_level>
200aa58: 84 00 bf ff add %g2, -1, %g2
200aa5c: c4 20 63 f0 st %g2, [ %g1 + 0x3f0 ]
return _Thread_Dispatch_disable_level;
200aa60: c2 00 63 f0 ld [ %g1 + 0x3f0 ], %g1
200aa64: 81 c7 e0 08 ret
200aa68: 81 e8 00 00 restore
0200877c <_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
)
{
200877c: 9d e3 bf a0 save %sp, -96, %sp
ISR_Level level;
CORE_semaphore_Status status;
status = CORE_SEMAPHORE_STATUS_SUCCESSFUL;
if ( (the_thread = _Thread_queue_Dequeue(&the_semaphore->Wait_queue)) ) {
2008780: 90 10 00 18 mov %i0, %o0
2008784: 40 00 07 6e call 200a53c <_Thread_queue_Dequeue>
2008788: ba 10 00 18 mov %i0, %i5
200878c: 80 a2 20 00 cmp %o0, 0
2008790: 12 80 00 0e bne 20087c8 <_CORE_semaphore_Surrender+0x4c>
2008794: b0 10 20 00 clr %i0
if ( !_Objects_Is_local_id( the_thread->Object.id ) )
(*api_semaphore_mp_support) ( the_thread, id );
#endif
} else {
_ISR_Disable( level );
2008798: 7f ff e7 cb call 20026c4 <sparc_disable_interrupts>
200879c: 01 00 00 00 nop
if ( the_semaphore->count < the_semaphore->Attributes.maximum_count )
20087a0: c2 07 60 48 ld [ %i5 + 0x48 ], %g1
20087a4: c4 07 60 40 ld [ %i5 + 0x40 ], %g2
20087a8: 80 a0 40 02 cmp %g1, %g2
20087ac: 1a 80 00 05 bcc 20087c0 <_CORE_semaphore_Surrender+0x44> <== NEVER TAKEN
20087b0: b0 10 20 04 mov 4, %i0
the_semaphore->count += 1;
20087b4: 82 00 60 01 inc %g1
{
Thread_Control *the_thread;
ISR_Level level;
CORE_semaphore_Status status;
status = CORE_SEMAPHORE_STATUS_SUCCESSFUL;
20087b8: b0 10 20 00 clr %i0
#endif
} else {
_ISR_Disable( level );
if ( the_semaphore->count < the_semaphore->Attributes.maximum_count )
the_semaphore->count += 1;
20087bc: c2 27 60 48 st %g1, [ %i5 + 0x48 ]
else
status = CORE_SEMAPHORE_MAXIMUM_COUNT_EXCEEDED;
_ISR_Enable( level );
20087c0: 7f ff e7 c5 call 20026d4 <sparc_enable_interrupts>
20087c4: 01 00 00 00 nop
}
return status;
}
20087c8: 81 c7 e0 08 ret
20087cc: 81 e8 00 00 restore
02007464 <_Event_Surrender>:
*/
void _Event_Surrender(
Thread_Control *the_thread
)
{
2007464: 9d e3 bf a0 save %sp, -96, %sp
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 ];
2007468: f8 06 21 58 ld [ %i0 + 0x158 ], %i4
option_set = (rtems_option) the_thread->Wait.option;
200746c: f6 06 20 30 ld [ %i0 + 0x30 ], %i3
_ISR_Disable( level );
2007470: 7f ff ec 95 call 20026c4 <sparc_disable_interrupts>
2007474: ba 10 00 18 mov %i0, %i5
2007478: b0 10 00 08 mov %o0, %i0
pending_events = api->pending_events;
200747c: c4 07 00 00 ld [ %i4 ], %g2
event_condition = (rtems_event_set) the_thread->Wait.count;
2007480: c6 07 60 24 ld [ %i5 + 0x24 ], %g3
seized_events = _Event_sets_Get( pending_events, event_condition );
/*
* No events were seized in this operation
*/
if ( _Event_sets_Is_empty( seized_events ) ) {
2007484: 82 88 c0 02 andcc %g3, %g2, %g1
2007488: 02 80 00 42 be 2007590 <_Event_Surrender+0x12c>
200748c: 09 00 80 78 sethi %hi(0x201e000), %g4
/*
* 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() &&
2007490: 88 11 20 10 or %g4, 0x10, %g4 ! 201e010 <_Per_CPU_Information>
2007494: f4 01 20 08 ld [ %g4 + 8 ], %i2
2007498: 80 a6 a0 00 cmp %i2, 0
200749c: 22 80 00 1d be,a 2007510 <_Event_Surrender+0xac>
20074a0: c8 07 60 10 ld [ %i5 + 0x10 ], %g4
20074a4: c8 01 20 0c ld [ %g4 + 0xc ], %g4
20074a8: 80 a7 40 04 cmp %i5, %g4
20074ac: 32 80 00 19 bne,a 2007510 <_Event_Surrender+0xac>
20074b0: c8 07 60 10 ld [ %i5 + 0x10 ], %g4
_Thread_Is_executing( the_thread ) &&
((_Event_Sync_state == THREAD_BLOCKING_OPERATION_TIMEOUT) ||
20074b4: 09 00 80 79 sethi %hi(0x201e400), %g4
20074b8: f4 01 20 10 ld [ %g4 + 0x10 ], %i2 ! 201e410 <_Event_Sync_state>
/*
* 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 ) &&
20074bc: 80 a6 a0 02 cmp %i2, 2
20074c0: 02 80 00 07 be 20074dc <_Event_Surrender+0x78> <== NEVER TAKEN
20074c4: 80 a0 40 03 cmp %g1, %g3
((_Event_Sync_state == THREAD_BLOCKING_OPERATION_TIMEOUT) ||
(_Event_Sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED)) ) {
20074c8: c8 01 20 10 ld [ %g4 + 0x10 ], %g4
* 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) ||
20074cc: 80 a1 20 01 cmp %g4, 1
20074d0: 32 80 00 10 bne,a 2007510 <_Event_Surrender+0xac>
20074d4: c8 07 60 10 ld [ %i5 + 0x10 ], %g4
(_Event_Sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED)) ) {
if ( seized_events == event_condition || _Options_Is_any(option_set) ) {
20074d8: 80 a0 40 03 cmp %g1, %g3
20074dc: 02 80 00 04 be 20074ec <_Event_Surrender+0x88>
20074e0: 80 8e e0 02 btst 2, %i3
20074e4: 02 80 00 2b be 2007590 <_Event_Surrender+0x12c> <== NEVER TAKEN
20074e8: 01 00 00 00 nop
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) );
20074ec: 84 28 80 01 andn %g2, %g1, %g2
api->pending_events = _Event_sets_Clear( pending_events,seized_events );
20074f0: c4 27 00 00 st %g2, [ %i4 ]
the_thread->Wait.count = 0;
*(rtems_event_set *)the_thread->Wait.return_argument = seized_events;
20074f4: c4 07 60 28 ld [ %i5 + 0x28 ], %g2
_Thread_Is_executing( the_thread ) &&
((_Event_Sync_state == THREAD_BLOCKING_OPERATION_TIMEOUT) ||
(_Event_Sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED)) ) {
if ( seized_events == event_condition || _Options_Is_any(option_set) ) {
api->pending_events = _Event_sets_Clear( pending_events,seized_events );
the_thread->Wait.count = 0;
20074f8: c0 27 60 24 clr [ %i5 + 0x24 ]
*(rtems_event_set *)the_thread->Wait.return_argument = seized_events;
20074fc: c2 20 80 00 st %g1, [ %g2 ]
_Event_Sync_state = THREAD_BLOCKING_OPERATION_SATISFIED;
2007500: 84 10 20 03 mov 3, %g2
2007504: 03 00 80 79 sethi %hi(0x201e400), %g1
2007508: c4 20 60 10 st %g2, [ %g1 + 0x10 ] ! 201e410 <_Event_Sync_state>
200750c: 30 80 00 21 b,a 2007590 <_Event_Surrender+0x12c>
}
/*
* Otherwise, this is a normal send to another thread
*/
if ( _States_Is_waiting_for_event( the_thread->current_state ) ) {
2007510: 80 89 21 00 btst 0x100, %g4
2007514: 02 80 00 1f be 2007590 <_Event_Surrender+0x12c>
2007518: 80 a0 40 03 cmp %g1, %g3
if ( seized_events == event_condition || _Options_Is_any( option_set ) ) {
200751c: 02 80 00 04 be 200752c <_Event_Surrender+0xc8>
2007520: 80 8e e0 02 btst 2, %i3
2007524: 02 80 00 1b be 2007590 <_Event_Surrender+0x12c> <== NEVER TAKEN
2007528: 01 00 00 00 nop
200752c: 84 28 80 01 andn %g2, %g1, %g2
api->pending_events = _Event_sets_Clear( pending_events, seized_events );
2007530: c4 27 00 00 st %g2, [ %i4 ]
the_thread->Wait.count = 0;
*(rtems_event_set *)the_thread->Wait.return_argument = seized_events;
2007534: c4 07 60 28 ld [ %i5 + 0x28 ], %g2
* Otherwise, this is a normal send to another thread
*/
if ( _States_Is_waiting_for_event( the_thread->current_state ) ) {
if ( seized_events == event_condition || _Options_Is_any( option_set ) ) {
api->pending_events = _Event_sets_Clear( pending_events, seized_events );
the_thread->Wait.count = 0;
2007538: c0 27 60 24 clr [ %i5 + 0x24 ]
*(rtems_event_set *)the_thread->Wait.return_argument = seized_events;
200753c: c2 20 80 00 st %g1, [ %g2 ]
_ISR_Flash( level );
2007540: 7f ff ec 65 call 20026d4 <sparc_enable_interrupts>
2007544: 90 10 00 18 mov %i0, %o0
2007548: 7f ff ec 5f call 20026c4 <sparc_disable_interrupts>
200754c: 01 00 00 00 nop
if ( !_Watchdog_Is_active( &the_thread->Timer ) ) {
2007550: c2 07 60 50 ld [ %i5 + 0x50 ], %g1
2007554: 80 a0 60 02 cmp %g1, 2
2007558: 02 80 00 06 be 2007570 <_Event_Surrender+0x10c>
200755c: 82 10 20 03 mov 3, %g1
_ISR_Enable( level );
2007560: 7f ff ec 5d call 20026d4 <sparc_enable_interrupts>
2007564: 33 04 00 ff sethi %hi(0x1003fc00), %i1
RTEMS_INLINE_ROUTINE void _Thread_Unblock (
Thread_Control *the_thread
)
{
_Thread_Clear_state( the_thread, STATES_BLOCKED );
2007568: 10 80 00 08 b 2007588 <_Event_Surrender+0x124>
200756c: b2 16 63 f8 or %i1, 0x3f8, %i1 ! 1003fff8 <RAM_END+0xdc3fff8>
RTEMS_INLINE_ROUTINE void _Watchdog_Deactivate(
Watchdog_Control *the_watchdog
)
{
the_watchdog->state = WATCHDOG_REMOVE_IT;
2007570: c2 27 60 50 st %g1, [ %i5 + 0x50 ]
_Thread_Unblock( the_thread );
} else {
_Watchdog_Deactivate( &the_thread->Timer );
_ISR_Enable( level );
2007574: 7f ff ec 58 call 20026d4 <sparc_enable_interrupts>
2007578: 33 04 00 ff sethi %hi(0x1003fc00), %i1
(void) _Watchdog_Remove( &the_thread->Timer );
200757c: 40 00 0e ae call 200b034 <_Watchdog_Remove>
2007580: 90 07 60 48 add %i5, 0x48, %o0
2007584: b2 16 63 f8 or %i1, 0x3f8, %i1
2007588: 40 00 0a 28 call 2009e28 <_Thread_Clear_state>
200758c: 91 e8 00 1d restore %g0, %i5, %o0
_Thread_Unblock( the_thread );
}
return;
}
}
_ISR_Enable( level );
2007590: 7f ff ec 51 call 20026d4 <sparc_enable_interrupts>
2007594: 81 e8 00 00 restore
02007598 <_Event_Timeout>:
void _Event_Timeout(
Objects_Id id,
void *ignored
)
{
2007598: 9d e3 bf 98 save %sp, -104, %sp
Thread_Control *the_thread;
Objects_Locations location;
ISR_Level level;
the_thread = _Thread_Get( id, &location );
200759c: 90 10 00 18 mov %i0, %o0
20075a0: 40 00 0b 0f call 200a1dc <_Thread_Get>
20075a4: 92 07 bf fc add %fp, -4, %o1
switch ( location ) {
20075a8: c2 07 bf fc ld [ %fp + -4 ], %g1
20075ac: 80 a0 60 00 cmp %g1, 0
20075b0: 12 80 00 1d bne 2007624 <_Event_Timeout+0x8c> <== NEVER TAKEN
20075b4: ba 10 00 08 mov %o0, %i5
*
* If it is not satisfied, then it is "nothing happened" and
* this is the "timeout" transition. After a request is satisfied,
* a timeout is not allowed to occur.
*/
_ISR_Disable( level );
20075b8: 7f ff ec 43 call 20026c4 <sparc_disable_interrupts>
20075bc: 01 00 00 00 nop
RTEMS_INLINE_ROUTINE bool _Thread_Is_executing (
const Thread_Control *the_thread
)
{
return ( the_thread == _Thread_Executing );
20075c0: 03 00 80 78 sethi %hi(0x201e000), %g1
return;
}
#endif
the_thread->Wait.count = 0;
if ( _Thread_Is_executing( the_thread ) ) {
20075c4: c2 00 60 1c ld [ %g1 + 0x1c ], %g1 ! 201e01c <_Per_CPU_Information+0xc>
20075c8: 80 a7 40 01 cmp %i5, %g1
20075cc: 12 80 00 09 bne 20075f0 <_Event_Timeout+0x58>
20075d0: c0 27 60 24 clr [ %i5 + 0x24 ]
if ( _Event_Sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED )
20075d4: 03 00 80 79 sethi %hi(0x201e400), %g1
20075d8: c4 00 60 10 ld [ %g1 + 0x10 ], %g2 ! 201e410 <_Event_Sync_state>
20075dc: 80 a0 a0 01 cmp %g2, 1
20075e0: 32 80 00 05 bne,a 20075f4 <_Event_Timeout+0x5c>
20075e4: 82 10 20 06 mov 6, %g1
_Event_Sync_state = THREAD_BLOCKING_OPERATION_TIMEOUT;
20075e8: 84 10 20 02 mov 2, %g2
20075ec: c4 20 60 10 st %g2, [ %g1 + 0x10 ]
}
the_thread->Wait.return_code = RTEMS_TIMEOUT;
20075f0: 82 10 20 06 mov 6, %g1
20075f4: c2 27 60 34 st %g1, [ %i5 + 0x34 ]
_ISR_Enable( level );
20075f8: 7f ff ec 37 call 20026d4 <sparc_enable_interrupts>
20075fc: 01 00 00 00 nop
RTEMS_INLINE_ROUTINE void _Thread_Unblock (
Thread_Control *the_thread
)
{
_Thread_Clear_state( the_thread, STATES_BLOCKED );
2007600: 90 10 00 1d mov %i5, %o0
2007604: 13 04 00 ff sethi %hi(0x1003fc00), %o1
2007608: 40 00 0a 08 call 2009e28 <_Thread_Clear_state>
200760c: 92 12 63 f8 or %o1, 0x3f8, %o1 ! 1003fff8 <RAM_END+0xdc3fff8>
*
* This routine decrements the thread dispatch level.
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_decrement_disable_level(void)
{
_Thread_Dispatch_disable_level--;
2007610: 03 00 80 76 sethi %hi(0x201d800), %g1
2007614: c4 00 62 e0 ld [ %g1 + 0x2e0 ], %g2 ! 201dae0 <_Thread_Dispatch_disable_level>
2007618: 84 00 bf ff add %g2, -1, %g2
200761c: c4 20 62 e0 st %g2, [ %g1 + 0x2e0 ]
return _Thread_Dispatch_disable_level;
2007620: c2 00 62 e0 ld [ %g1 + 0x2e0 ], %g1
2007624: 81 c7 e0 08 ret
2007628: 81 e8 00 00 restore
0200d750 <_Heap_Extend>:
Heap_Control *heap,
void *extend_area_begin_ptr,
uintptr_t extend_area_size,
uintptr_t *extended_size_ptr
)
{
200d750: 9d e3 bf 90 save %sp, -112, %sp
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;
200d754: c0 27 bf f8 clr [ %fp + -8 ]
Heap_Block *extend_last_block = NULL;
200d758: c0 27 bf fc clr [ %fp + -4 ]
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;
200d75c: ba 06 40 1a add %i1, %i2, %i5
uintptr_t extend_area_size,
uintptr_t *extended_size_ptr
)
{
Heap_Statistics *const stats = &heap->stats;
Heap_Block *const first_block = heap->first_block;
200d760: ea 06 20 20 ld [ %i0 + 0x20 ], %l5
Heap_Block *merge_above_block = NULL;
Heap_Block *link_below_block = NULL;
Heap_Block *link_above_block = NULL;
Heap_Block *extend_first_block = NULL;
Heap_Block *extend_last_block = NULL;
uintptr_t const page_size = heap->page_size;
200d764: ec 06 20 10 ld [ %i0 + 0x10 ], %l6
uintptr_t const min_block_size = heap->min_block_size;
200d768: d6 06 20 14 ld [ %i0 + 0x14 ], %o3
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 ) {
200d76c: 80 a7 40 19 cmp %i5, %i1
200d770: 1a 80 00 04 bcc 200d780 <_Heap_Extend+0x30>
200d774: e6 06 20 30 ld [ %i0 + 0x30 ], %l3
return false;
200d778: 10 80 00 a2 b 200da00 <_Heap_Extend+0x2b0>
200d77c: b0 10 20 00 clr %i0
}
extend_area_ok = _Heap_Get_first_and_last_block(
200d780: 90 10 00 19 mov %i1, %o0
200d784: 92 10 00 1a mov %i2, %o1
200d788: 94 10 00 16 mov %l6, %o2
200d78c: 98 07 bf f8 add %fp, -8, %o4
200d790: 7f ff ec 97 call 20089ec <_Heap_Get_first_and_last_block>
200d794: 9a 07 bf fc add %fp, -4, %o5
page_size,
min_block_size,
&extend_first_block,
&extend_last_block
);
if (!extend_area_ok ) {
200d798: 80 8a 20 ff btst 0xff, %o0
200d79c: 02 bf ff f7 be 200d778 <_Heap_Extend+0x28>
200d7a0: a4 10 20 00 clr %l2
200d7a4: b4 10 00 15 mov %l5, %i2
200d7a8: a8 10 20 00 clr %l4
200d7ac: b8 10 20 00 clr %i4
200d7b0: a2 10 20 00 clr %l1
200d7b4: ee 06 20 18 ld [ %i0 + 0x18 ], %l7
}
do {
uintptr_t const sub_area_begin = (start_block != first_block) ?
(uintptr_t) start_block : heap->area_begin;
uintptr_t const sub_area_end = start_block->prev_size;
200d7b8: e0 06 80 00 ld [ %i2 ], %l0
200d7bc: 92 10 00 16 mov %l6, %o1
200d7c0: 82 04 3f f8 add %l0, -8, %g1
200d7c4: 90 10 00 10 mov %l0, %o0
200d7c8: 40 00 2d 82 call 2018dd0 <.urem>
200d7cc: c2 27 bf f4 st %g1, [ %fp + -12 ]
uintptr_t alloc_begin,
uintptr_t page_size
)
{
return (Heap_Block *) (_Heap_Align_down( alloc_begin, page_size )
- HEAP_BLOCK_HEADER_SIZE);
200d7d0: c2 07 bf f4 ld [ %fp + -12 ], %g1
Heap_Block *const end_block =
_Heap_Block_of_alloc_area( sub_area_end, page_size );
if (
200d7d4: 80 a5 c0 1d cmp %l7, %i5
200d7d8: 1a 80 00 05 bcc 200d7ec <_Heap_Extend+0x9c>
200d7dc: 90 20 40 08 sub %g1, %o0, %o0
200d7e0: 80 a6 40 10 cmp %i1, %l0
200d7e4: 2a 80 00 87 bcs,a 200da00 <_Heap_Extend+0x2b0>
200d7e8: b0 10 20 00 clr %i0
sub_area_end > extend_area_begin && extend_area_end > sub_area_begin
) {
return false;
}
if ( extend_area_end == sub_area_begin ) {
200d7ec: 80 a7 40 17 cmp %i5, %l7
200d7f0: 02 80 00 06 be 200d808 <_Heap_Extend+0xb8>
200d7f4: 80 a7 40 10 cmp %i5, %l0
merge_below_block = start_block;
} else if ( extend_area_end < sub_area_end ) {
200d7f8: 2a 80 00 05 bcs,a 200d80c <_Heap_Extend+0xbc>
200d7fc: a8 10 00 1a mov %i2, %l4
link_below_block = start_block;
}
if ( sub_area_end == extend_area_begin ) {
200d800: 10 80 00 04 b 200d810 <_Heap_Extend+0xc0>
200d804: 80 a4 00 19 cmp %l0, %i1
200d808: a2 10 00 1a mov %i2, %l1
200d80c: 80 a4 00 19 cmp %l0, %i1
200d810: 12 80 00 05 bne 200d824 <_Heap_Extend+0xd4>
200d814: 80 a4 00 19 cmp %l0, %i1
start_block->prev_size = extend_area_end;
200d818: fa 26 80 00 st %i5, [ %i2 ]
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 )
200d81c: 10 80 00 04 b 200d82c <_Heap_Extend+0xdc>
200d820: b8 10 00 08 mov %o0, %i4
merge_above_block = end_block;
} else if ( sub_area_end < extend_area_begin ) {
200d824: 2a 80 00 02 bcs,a 200d82c <_Heap_Extend+0xdc>
200d828: a4 10 00 08 mov %o0, %l2
- 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;
200d82c: f4 02 20 04 ld [ %o0 + 4 ], %i2
200d830: b4 0e bf fe and %i2, -2, %i2
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
const Heap_Block *block,
uintptr_t offset
)
{
return (Heap_Block *) ((uintptr_t) block + offset);
200d834: b4 02 00 1a add %o0, %i2, %i2
link_above_block = end_block;
}
start_block = _Heap_Block_at( end_block, _Heap_Block_size( end_block ) );
} while ( start_block != first_block );
200d838: 80 a6 80 15 cmp %i2, %l5
200d83c: 12 bf ff df bne 200d7b8 <_Heap_Extend+0x68>
200d840: ae 10 00 1a mov %i2, %l7
if ( extend_area_begin < heap->area_begin ) {
200d844: c2 06 20 18 ld [ %i0 + 0x18 ], %g1
200d848: 80 a6 40 01 cmp %i1, %g1
200d84c: 3a 80 00 04 bcc,a 200d85c <_Heap_Extend+0x10c>
200d850: c2 06 20 1c ld [ %i0 + 0x1c ], %g1
heap->area_begin = extend_area_begin;
200d854: 10 80 00 05 b 200d868 <_Heap_Extend+0x118>
200d858: f2 26 20 18 st %i1, [ %i0 + 0x18 ]
} else if ( heap->area_end < extend_area_end ) {
200d85c: 80 a0 40 1d cmp %g1, %i5
200d860: 2a 80 00 02 bcs,a 200d868 <_Heap_Extend+0x118>
200d864: fa 26 20 1c st %i5, [ %i0 + 0x1c ]
heap->area_end = extend_area_end;
}
extend_first_block_size =
(uintptr_t) extend_last_block - (uintptr_t) extend_first_block;
200d868: c4 07 bf f8 ld [ %fp + -8 ], %g2
200d86c: c2 07 bf fc ld [ %fp + -4 ], %g1
extend_first_block->prev_size = extend_area_end;
200d870: fa 20 80 00 st %i5, [ %g2 ]
heap->area_begin = extend_area_begin;
} else if ( heap->area_end < extend_area_end ) {
heap->area_end = extend_area_end;
}
extend_first_block_size =
200d874: 86 20 40 02 sub %g1, %g2, %g3
(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;
200d878: 88 10 e0 01 or %g3, 1, %g4
_Heap_Protection_block_initialize( heap, extend_first_block );
extend_last_block->prev_size = extend_first_block_size;
200d87c: c6 20 40 00 st %g3, [ %g1 ]
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 =
200d880: c8 20 a0 04 st %g4, [ %g2 + 4 ]
extend_last_block->prev_size = extend_first_block_size;
extend_last_block->size_and_flag = 0;
_Heap_Protection_block_initialize( heap, extend_last_block );
if ( (uintptr_t) extend_first_block < (uintptr_t) heap->first_block ) {
200d884: c6 06 20 20 ld [ %i0 + 0x20 ], %g3
200d888: 80 a0 c0 02 cmp %g3, %g2
200d88c: 08 80 00 04 bleu 200d89c <_Heap_Extend+0x14c>
200d890: c0 20 60 04 clr [ %g1 + 4 ]
heap->first_block = extend_first_block;
200d894: 10 80 00 06 b 200d8ac <_Heap_Extend+0x15c>
200d898: c4 26 20 20 st %g2, [ %i0 + 0x20 ]
} else if ( (uintptr_t) extend_last_block > (uintptr_t) heap->last_block ) {
200d89c: c4 06 20 24 ld [ %i0 + 0x24 ], %g2
200d8a0: 80 a0 80 01 cmp %g2, %g1
200d8a4: 2a 80 00 02 bcs,a 200d8ac <_Heap_Extend+0x15c>
200d8a8: c2 26 20 24 st %g1, [ %i0 + 0x24 ]
heap->last_block = extend_last_block;
}
if ( merge_below_block != NULL ) {
200d8ac: 80 a4 60 00 cmp %l1, 0
200d8b0: 02 80 00 14 be 200d900 <_Heap_Extend+0x1b0>
200d8b4: b2 06 60 08 add %i1, 8, %i1
Heap_Control *heap,
uintptr_t extend_area_begin,
Heap_Block *first_block
)
{
uintptr_t const page_size = heap->page_size;
200d8b8: f4 06 20 10 ld [ %i0 + 0x10 ], %i2
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_up(
uintptr_t value,
uintptr_t alignment
)
{
uintptr_t remainder = value % alignment;
200d8bc: 92 10 00 1a mov %i2, %o1
200d8c0: 40 00 2d 44 call 2018dd0 <.urem>
200d8c4: 90 10 00 19 mov %i1, %o0
if ( remainder != 0 ) {
200d8c8: 80 a2 20 00 cmp %o0, 0
200d8cc: 02 80 00 04 be 200d8dc <_Heap_Extend+0x18c>
200d8d0: c2 04 40 00 ld [ %l1 ], %g1
return value - remainder + alignment;
200d8d4: b2 06 40 1a add %i1, %i2, %i1
200d8d8: b2 26 40 08 sub %i1, %o0, %i1
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 =
200d8dc: 92 06 7f f8 add %i1, -8, %o1
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;
200d8e0: c2 26 7f f8 st %g1, [ %i1 + -8 ]
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 =
200d8e4: 82 24 40 09 sub %l1, %o1, %g1
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;
200d8e8: 82 10 60 01 or %g1, 1, %g1
_Heap_Free_block( heap, new_first_block );
200d8ec: 90 10 00 18 mov %i0, %o0
200d8f0: 7f ff ff 8e call 200d728 <_Heap_Free_block>
200d8f4: c2 22 60 04 st %g1, [ %o1 + 4 ]
link_below_block,
extend_last_block
);
}
if ( merge_above_block != NULL ) {
200d8f8: 10 80 00 08 b 200d918 <_Heap_Extend+0x1c8>
200d8fc: 80 a7 20 00 cmp %i4, 0
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 ) {
200d900: 80 a5 20 00 cmp %l4, 0
200d904: 02 80 00 04 be 200d914 <_Heap_Extend+0x1c4>
200d908: a8 25 00 01 sub %l4, %g1, %l4
{
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;
200d90c: a8 15 20 01 or %l4, 1, %l4
)
{
uintptr_t const last_block_begin = (uintptr_t) last_block;
uintptr_t const link_begin = (uintptr_t) link;
last_block->size_and_flag =
200d910: e8 20 60 04 st %l4, [ %g1 + 4 ]
link_below_block,
extend_last_block
);
}
if ( merge_above_block != NULL ) {
200d914: 80 a7 20 00 cmp %i4, 0
200d918: 02 80 00 15 be 200d96c <_Heap_Extend+0x21c>
200d91c: ba 07 7f f8 add %i5, -8, %i5
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(
uintptr_t value,
uintptr_t alignment
)
{
return value - (value % alignment);
200d920: d2 06 20 10 ld [ %i0 + 0x10 ], %o1
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(
200d924: ba 27 40 1c sub %i5, %i4, %i5
200d928: 40 00 2d 2a call 2018dd0 <.urem>
200d92c: 90 10 00 1d mov %i5, %o0
);
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)
200d930: c4 07 20 04 ld [ %i4 + 4 ], %g2
200d934: 90 27 40 08 sub %i5, %o0, %o0
page_size
);
Heap_Block *const new_last_block =
_Heap_Block_at( last_block, last_block_new_size );
new_last_block->size_and_flag =
200d938: 82 02 00 1c add %o0, %i4, %g1
(last_block->size_and_flag - last_block_new_size)
200d93c: 84 20 80 08 sub %g2, %o0, %g2
| HEAP_PREV_BLOCK_USED;
200d940: 84 10 a0 01 or %g2, 1, %g2
page_size
);
Heap_Block *const new_last_block =
_Heap_Block_at( last_block, last_block_new_size );
new_last_block->size_and_flag =
200d944: c4 20 60 04 st %g2, [ %g1 + 4 ]
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;
200d948: c2 07 20 04 ld [ %i4 + 4 ], %g1
(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 );
200d94c: 92 10 00 1c mov %i4, %o1
200d950: 82 08 60 01 and %g1, 1, %g1
block->size_and_flag = size | flag;
200d954: 90 12 00 01 or %o0, %g1, %o0
200d958: d0 27 20 04 st %o0, [ %i4 + 4 ]
200d95c: 7f ff ff 73 call 200d728 <_Heap_Free_block>
200d960: 90 10 00 18 mov %i0, %o0
extend_first_block,
extend_last_block
);
}
if ( merge_below_block == NULL && merge_above_block == NULL ) {
200d964: 10 80 00 0f b 200d9a0 <_Heap_Extend+0x250>
200d968: 80 a7 20 00 cmp %i4, 0
);
}
if ( merge_above_block != NULL ) {
_Heap_Merge_above( heap, merge_above_block, extend_area_end );
} else if ( link_above_block != NULL ) {
200d96c: 80 a4 a0 00 cmp %l2, 0
200d970: 02 80 00 0b be 200d99c <_Heap_Extend+0x24c>
200d974: c6 07 bf f8 ld [ %fp + -8 ], %g3
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;
200d978: c4 04 a0 04 ld [ %l2 + 4 ], %g2
_Heap_Link_above(
200d97c: c2 07 bf fc ld [ %fp + -4 ], %g1
)
{
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 );
200d980: 86 20 c0 12 sub %g3, %l2, %g3
200d984: 84 08 a0 01 and %g2, 1, %g2
block->size_and_flag = size | flag;
200d988: 84 10 c0 02 or %g3, %g2, %g2
200d98c: c4 24 a0 04 st %g2, [ %l2 + 4 ]
last_block->size_and_flag |= HEAP_PREV_BLOCK_USED;
200d990: c4 00 60 04 ld [ %g1 + 4 ], %g2
200d994: 84 10 a0 01 or %g2, 1, %g2
200d998: c4 20 60 04 st %g2, [ %g1 + 4 ]
extend_first_block,
extend_last_block
);
}
if ( merge_below_block == NULL && merge_above_block == NULL ) {
200d99c: 80 a7 20 00 cmp %i4, 0
200d9a0: 32 80 00 09 bne,a 200d9c4 <_Heap_Extend+0x274>
200d9a4: c2 06 20 24 ld [ %i0 + 0x24 ], %g1
200d9a8: 80 a4 60 00 cmp %l1, 0
200d9ac: 32 80 00 06 bne,a 200d9c4 <_Heap_Extend+0x274>
200d9b0: c2 06 20 24 ld [ %i0 + 0x24 ], %g1
_Heap_Free_block( heap, extend_first_block );
200d9b4: d2 07 bf f8 ld [ %fp + -8 ], %o1
200d9b8: 7f ff ff 5c call 200d728 <_Heap_Free_block>
200d9bc: 90 10 00 18 mov %i0, %o0
*/
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
200d9c0: c2 06 20 24 ld [ %i0 + 0x24 ], %g1
* 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(
200d9c4: c6 06 20 20 ld [ %i0 + 0x20 ], %g3
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;
200d9c8: c4 00 60 04 ld [ %g1 + 4 ], %g2
* 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(
200d9cc: 86 20 c0 01 sub %g3, %g1, %g3
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;
200d9d0: 84 08 a0 01 and %g2, 1, %g2
block->size_and_flag = size | flag;
200d9d4: 84 10 c0 02 or %g3, %g2, %g2
200d9d8: c4 20 60 04 st %g2, [ %g1 + 4 ]
}
_Heap_Set_last_block_size( heap );
extended_size = stats->free_size - free_size;
200d9dc: c2 06 20 30 ld [ %i0 + 0x30 ], %g1
/* Statistics */
stats->size += extended_size;
if ( extended_size_ptr != NULL )
200d9e0: 80 a6 e0 00 cmp %i3, 0
_Heap_Free_block( heap, extend_first_block );
}
_Heap_Set_last_block_size( heap );
extended_size = stats->free_size - free_size;
200d9e4: a6 20 40 13 sub %g1, %l3, %l3
/* Statistics */
stats->size += extended_size;
200d9e8: c2 06 20 2c ld [ %i0 + 0x2c ], %g1
200d9ec: 82 00 40 13 add %g1, %l3, %g1
if ( extended_size_ptr != NULL )
200d9f0: 02 80 00 03 be 200d9fc <_Heap_Extend+0x2ac> <== NEVER TAKEN
200d9f4: c2 26 20 2c st %g1, [ %i0 + 0x2c ]
*extended_size_ptr = extended_size;
200d9f8: e6 26 c0 00 st %l3, [ %i3 ]
return true;
200d9fc: b0 10 20 01 mov 1, %i0
}
200da00: b0 0e 20 01 and %i0, 1, %i0
200da04: 81 c7 e0 08 ret
200da08: 81 e8 00 00 restore
0200d77c <_Heap_Free>:
return do_free;
}
#endif
bool _Heap_Free( Heap_Control *heap, void *alloc_begin_ptr )
{
200d77c: 9d e3 bf a0 save %sp, -96, %sp
/*
* 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 ) {
200d780: 80 a6 60 00 cmp %i1, 0
200d784: 02 80 00 7a be 200d96c <_Heap_Free+0x1f0>
200d788: 88 10 20 01 mov 1, %g4
200d78c: d2 06 20 10 ld [ %i0 + 0x10 ], %o1
200d790: 40 00 2c ec call 2018b40 <.urem>
200d794: 90 10 00 19 mov %i1, %o0
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
200d798: f6 06 20 20 ld [ %i0 + 0x20 ], %i3
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(
uintptr_t value,
uintptr_t alignment
)
{
return value - (value % alignment);
200d79c: ba 06 7f f8 add %i1, -8, %i5
uintptr_t alloc_begin,
uintptr_t page_size
)
{
return (Heap_Block *) (_Heap_Align_down( alloc_begin, page_size )
- HEAP_BLOCK_HEADER_SIZE);
200d7a0: 90 27 40 08 sub %i5, %o0, %o0
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;
200d7a4: 80 a2 00 1b cmp %o0, %i3
200d7a8: 0a 80 00 05 bcs 200d7bc <_Heap_Free+0x40>
200d7ac: 82 10 20 00 clr %g1
200d7b0: c2 06 20 24 ld [ %i0 + 0x24 ], %g1
200d7b4: 80 a0 40 08 cmp %g1, %o0
200d7b8: 82 60 3f ff subx %g0, -1, %g1
}
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 ) ) {
200d7bc: 80 a0 60 00 cmp %g1, 0
200d7c0: 02 80 00 6b be 200d96c <_Heap_Free+0x1f0>
200d7c4: 88 10 20 00 clr %g4
- 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;
200d7c8: f8 02 20 04 ld [ %o0 + 4 ], %i4
200d7cc: 84 0f 3f fe and %i4, -2, %g2
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
const Heap_Block *block,
uintptr_t offset
)
{
return (Heap_Block *) ((uintptr_t) block + offset);
200d7d0: 82 02 00 02 add %o0, %g2, %g1
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;
200d7d4: 80 a0 40 1b cmp %g1, %i3
200d7d8: 0a 80 00 05 bcs 200d7ec <_Heap_Free+0x70> <== NEVER TAKEN
200d7dc: 86 10 20 00 clr %g3
200d7e0: c6 06 20 24 ld [ %i0 + 0x24 ], %g3
200d7e4: 80 a0 c0 01 cmp %g3, %g1
200d7e8: 86 60 3f ff subx %g0, -1, %g3
_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 ) ) {
200d7ec: 80 a0 e0 00 cmp %g3, 0
200d7f0: 02 80 00 5f be 200d96c <_Heap_Free+0x1f0> <== NEVER TAKEN
200d7f4: 88 10 20 00 clr %g4
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;
200d7f8: fa 00 60 04 ld [ %g1 + 4 ], %i5
return false;
}
_Heap_Protection_block_check( heap, next_block );
if ( !_Heap_Is_prev_used( next_block ) ) {
200d7fc: 80 8f 60 01 btst 1, %i5
200d800: 22 80 00 5c be,a 200d970 <_Heap_Free+0x1f4> <== NEVER TAKEN
200d804: b0 09 20 01 and %g4, 1, %i0 <== NOT EXECUTED
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
200d808: c8 06 20 24 ld [ %i0 + 0x24 ], %g4
&& !_Heap_Is_prev_used( _Heap_Block_at( next_block, next_block_size ));
200d80c: 80 a0 40 04 cmp %g1, %g4
200d810: 02 80 00 07 be 200d82c <_Heap_Free+0xb0>
200d814: ba 0f 7f fe and %i5, -2, %i5
200d818: 86 00 40 1d add %g1, %i5, %g3
200d81c: f4 00 e0 04 ld [ %g3 + 4 ], %i2
200d820: b4 1e a0 01 xor %i2, 1, %i2
200d824: 10 80 00 03 b 200d830 <_Heap_Free+0xb4>
200d828: b4 0e a0 01 and %i2, 1, %i2
200d82c: b4 10 20 00 clr %i2
if ( !_Heap_Is_prev_used( block ) ) {
200d830: 80 8f 20 01 btst 1, %i4
200d834: 12 80 00 26 bne 200d8cc <_Heap_Free+0x150>
200d838: 80 8e a0 ff btst 0xff, %i2
uintptr_t const prev_size = block->prev_size;
200d83c: f8 02 00 00 ld [ %o0 ], %i4
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
const Heap_Block *block,
uintptr_t offset
)
{
return (Heap_Block *) ((uintptr_t) block + offset);
200d840: 86 22 00 1c sub %o0, %i4, %g3
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;
200d844: 80 a0 c0 1b cmp %g3, %i3
200d848: 0a 80 00 04 bcs 200d858 <_Heap_Free+0xdc> <== NEVER TAKEN
200d84c: b2 10 20 00 clr %i1
200d850: 80 a1 00 03 cmp %g4, %g3
200d854: b2 60 3f ff subx %g0, -1, %i1
Heap_Block * const prev_block = _Heap_Block_at( block, -prev_size );
if ( !_Heap_Is_block_in_heap( heap, prev_block ) ) {
200d858: 80 a6 60 00 cmp %i1, 0
200d85c: 02 80 00 44 be 200d96c <_Heap_Free+0x1f0> <== NEVER TAKEN
200d860: 88 10 20 00 clr %g4
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;
200d864: f6 00 e0 04 ld [ %g3 + 4 ], %i3
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) ) {
200d868: 80 8e e0 01 btst 1, %i3
200d86c: 02 80 00 40 be 200d96c <_Heap_Free+0x1f0> <== NEVER TAKEN
200d870: 80 8e a0 ff btst 0xff, %i2
_HAssert( false );
return( false );
}
if ( next_is_free ) { /* coalesce both */
200d874: 22 80 00 0f be,a 200d8b0 <_Heap_Free+0x134>
200d878: b8 00 80 1c add %g2, %i4, %i4
return _Heap_Free_list_tail(heap)->prev;
}
RTEMS_INLINE_ROUTINE void _Heap_Free_list_remove( Heap_Block *block )
{
Heap_Block *next = block->next;
200d87c: c8 00 60 08 ld [ %g1 + 8 ], %g4
Heap_Block *prev = block->prev;
200d880: c2 00 60 0c ld [ %g1 + 0xc ], %g1
uintptr_t const size = block_size + prev_size + next_block_size;
200d884: ba 00 80 1d add %g2, %i5, %i5
prev->next = next;
200d888: c8 20 60 08 st %g4, [ %g1 + 8 ]
next->prev = prev;
200d88c: c2 21 20 0c st %g1, [ %g4 + 0xc ]
_Heap_Free_list_remove( next_block );
stats->free_blocks -= 1;
200d890: c2 06 20 38 ld [ %i0 + 0x38 ], %g1
_HAssert( false );
return( false );
}
if ( next_is_free ) { /* coalesce both */
uintptr_t const size = block_size + prev_size + next_block_size;
200d894: b8 07 40 1c add %i5, %i4, %i4
_Heap_Free_list_remove( next_block );
stats->free_blocks -= 1;
200d898: 82 00 7f ff add %g1, -1, %g1
200d89c: c2 26 20 38 st %g1, [ %i0 + 0x38 ]
prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
next_block = _Heap_Block_at( prev_block, size );
_HAssert(!_Heap_Is_prev_used( next_block));
next_block->prev_size = size;
200d8a0: f8 20 c0 1c st %i4, [ %g3 + %i4 ]
if ( next_is_free ) { /* coalesce both */
uintptr_t const size = block_size + prev_size + next_block_size;
_Heap_Free_list_remove( next_block );
stats->free_blocks -= 1;
prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
200d8a4: 82 17 20 01 or %i4, 1, %g1
200d8a8: 10 80 00 27 b 200d944 <_Heap_Free+0x1c8>
200d8ac: c2 20 e0 04 st %g1, [ %g3 + 4 ]
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;
200d8b0: 88 17 20 01 or %i4, 1, %g4
200d8b4: c8 20 e0 04 st %g4, [ %g3 + 4 ]
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
200d8b8: c6 00 60 04 ld [ %g1 + 4 ], %g3
next_block->prev_size = size;
200d8bc: f8 22 00 02 st %i4, [ %o0 + %g2 ]
_HAssert(!_Heap_Is_prev_used( next_block));
next_block->prev_size = size;
} else { /* coalesce prev */
uintptr_t const size = block_size + prev_size;
prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
200d8c0: 86 08 ff fe and %g3, -2, %g3
200d8c4: 10 80 00 20 b 200d944 <_Heap_Free+0x1c8>
200d8c8: c6 20 60 04 st %g3, [ %g1 + 4 ]
next_block->prev_size = size;
}
} else if ( next_is_free ) { /* coalesce next */
200d8cc: 22 80 00 0d be,a 200d900 <_Heap_Free+0x184>
200d8d0: c6 06 20 08 ld [ %i0 + 8 ], %g3
RTEMS_INLINE_ROUTINE void _Heap_Free_list_replace(
Heap_Block *old_block,
Heap_Block *new_block
)
{
Heap_Block *next = old_block->next;
200d8d4: c8 00 60 08 ld [ %g1 + 8 ], %g4
Heap_Block *prev = old_block->prev;
200d8d8: c2 00 60 0c ld [ %g1 + 0xc ], %g1
new_block->next = next;
200d8dc: c8 22 20 08 st %g4, [ %o0 + 8 ]
new_block->prev = prev;
200d8e0: c2 22 20 0c st %g1, [ %o0 + 0xc ]
uintptr_t const size = block_size + next_block_size;
200d8e4: 86 07 40 02 add %i5, %g2, %g3
next->prev = new_block;
prev->next = new_block;
200d8e8: d0 20 60 08 st %o0, [ %g1 + 8 ]
Heap_Block *prev = old_block->prev;
new_block->next = next;
new_block->prev = prev;
next->prev = new_block;
200d8ec: d0 21 20 0c st %o0, [ %g4 + 0xc ]
_Heap_Free_list_replace( next_block, block );
block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
200d8f0: 82 10 e0 01 or %g3, 1, %g1
next_block = _Heap_Block_at( block, size );
next_block->prev_size = size;
200d8f4: c6 22 00 03 st %g3, [ %o0 + %g3 ]
next_block->prev_size = size;
}
} else if ( next_is_free ) { /* coalesce next */
uintptr_t const size = block_size + next_block_size;
_Heap_Free_list_replace( next_block, block );
block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
200d8f8: 10 80 00 13 b 200d944 <_Heap_Free+0x1c8>
200d8fc: c2 22 20 04 st %g1, [ %o0 + 4 ]
)
{
Heap_Block *next = block_before->next;
new_block->next = next;
new_block->prev = block_before;
200d900: f0 22 20 0c st %i0, [ %o0 + 0xc ]
Heap_Block *new_block
)
{
Heap_Block *next = block_before->next;
new_block->next = next;
200d904: c6 22 20 08 st %g3, [ %o0 + 8 ]
new_block->prev = block_before;
block_before->next = new_block;
next->prev = new_block;
200d908: d0 20 e0 0c st %o0, [ %g3 + 0xc ]
next_block->prev_size = size;
} else { /* no coalesce */
/* Add 'block' to the head of the free blocks list as it tends to
produce less fragmentation than adding to the tail. */
_Heap_Free_list_insert_after( _Heap_Free_list_head( heap), block );
block->size_and_flag = block_size | HEAP_PREV_BLOCK_USED;
200d90c: 86 10 a0 01 or %g2, 1, %g3
200d910: c6 22 20 04 st %g3, [ %o0 + 4 ]
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
200d914: c6 00 60 04 ld [ %g1 + 4 ], %g3
next_block->prev_size = block_size;
200d918: c4 22 00 02 st %g2, [ %o0 + %g2 ]
} 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;
200d91c: 86 08 ff fe and %g3, -2, %g3
200d920: c6 20 60 04 st %g3, [ %g1 + 4 ]
next_block->prev_size = block_size;
/* Statistics */
++stats->free_blocks;
200d924: c2 06 20 38 ld [ %i0 + 0x38 ], %g1
if ( stats->max_free_blocks < stats->free_blocks ) {
200d928: c6 06 20 3c ld [ %i0 + 0x3c ], %g3
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;
200d92c: 82 00 60 01 inc %g1
{
Heap_Block *next = block_before->next;
new_block->next = next;
new_block->prev = block_before;
block_before->next = new_block;
200d930: d0 26 20 08 st %o0, [ %i0 + 8 ]
if ( stats->max_free_blocks < stats->free_blocks ) {
200d934: 80 a0 c0 01 cmp %g3, %g1
200d938: 1a 80 00 03 bcc 200d944 <_Heap_Free+0x1c8>
200d93c: c2 26 20 38 st %g1, [ %i0 + 0x38 ]
stats->max_free_blocks = stats->free_blocks;
200d940: c2 26 20 3c st %g1, [ %i0 + 0x3c ]
}
}
/* Statistics */
--stats->used_blocks;
200d944: c2 06 20 40 ld [ %i0 + 0x40 ], %g1
200d948: 82 00 7f ff add %g1, -1, %g1
200d94c: c2 26 20 40 st %g1, [ %i0 + 0x40 ]
++stats->frees;
200d950: c2 06 20 50 ld [ %i0 + 0x50 ], %g1
200d954: 82 00 60 01 inc %g1
200d958: c2 26 20 50 st %g1, [ %i0 + 0x50 ]
stats->free_size += block_size;
200d95c: c2 06 20 30 ld [ %i0 + 0x30 ], %g1
200d960: 84 00 40 02 add %g1, %g2, %g2
200d964: c4 26 20 30 st %g2, [ %i0 + 0x30 ]
* 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;
200d968: 88 10 20 01 mov 1, %g4
--stats->used_blocks;
++stats->frees;
stats->free_size += block_size;
return( true );
}
200d96c: b0 09 20 01 and %g4, 1, %i0
200d970: 81 c7 e0 08 ret
200d974: 81 e8 00 00 restore
0200a8c4 <_Heap_Greedy_allocate>:
Heap_Block *_Heap_Greedy_allocate(
Heap_Control *heap,
const uintptr_t *block_sizes,
size_t block_count
)
{
200a8c4: 9d e3 bf a0 save %sp, -96, %sp
Heap_Block *allocated_blocks = NULL;
Heap_Block *blocks = NULL;
Heap_Block *current;
size_t i;
for (i = 0; i < block_count; ++i) {
200a8c8: b6 10 20 00 clr %i3
Heap_Block *_Heap_Greedy_allocate(
Heap_Control *heap,
const uintptr_t *block_sizes,
size_t block_count
)
{
200a8cc: ba 10 00 18 mov %i0, %i5
Heap_Block *allocated_blocks = NULL;
Heap_Block *blocks = NULL;
Heap_Block *current;
size_t i;
for (i = 0; i < block_count; ++i) {
200a8d0: 10 80 00 11 b 200a914 <_Heap_Greedy_allocate+0x50>
200a8d4: b8 10 20 00 clr %i4
* @brief See _Heap_Allocate_aligned_with_boundary() with alignment and
* boundary equals zero.
*/
RTEMS_INLINE_ROUTINE void *_Heap_Allocate( Heap_Control *heap, uintptr_t size )
{
return _Heap_Allocate_aligned_with_boundary( heap, size, 0, 0 );
200a8d8: d2 06 40 01 ld [ %i1 + %g1 ], %o1
200a8dc: 90 10 00 1d mov %i5, %o0
200a8e0: 94 10 20 00 clr %o2
200a8e4: 40 00 1d 88 call 2011f04 <_Heap_Allocate_aligned_with_boundary>
200a8e8: 96 10 20 00 clr %o3
void *next = _Heap_Allocate( heap, block_sizes [i] );
if ( next != NULL ) {
200a8ec: 82 92 20 00 orcc %o0, 0, %g1
200a8f0: 22 80 00 09 be,a 200a914 <_Heap_Greedy_allocate+0x50> <== NEVER TAKEN
200a8f4: b6 06 e0 01 inc %i3 <== NOT EXECUTED
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(
uintptr_t value,
uintptr_t alignment
)
{
return value - (value % alignment);
200a8f8: d2 07 60 10 ld [ %i5 + 0x10 ], %o1
200a8fc: 40 00 4a 97 call 201d358 <.urem>
200a900: b0 00 7f f8 add %g1, -8, %i0
uintptr_t alloc_begin,
uintptr_t page_size
)
{
return (Heap_Block *) (_Heap_Align_down( alloc_begin, page_size )
- HEAP_BLOCK_HEADER_SIZE);
200a904: 90 26 00 08 sub %i0, %o0, %o0
Heap_Block *next_block = _Heap_Block_of_alloc_area(
(uintptr_t) next,
heap->page_size
);
next_block->next = allocated_blocks;
200a908: f8 22 20 08 st %i4, [ %o0 + 8 ]
200a90c: b8 10 00 08 mov %o0, %i4
Heap_Block *allocated_blocks = NULL;
Heap_Block *blocks = NULL;
Heap_Block *current;
size_t i;
for (i = 0; i < block_count; ++i) {
200a910: b6 06 e0 01 inc %i3
200a914: 80 a6 c0 1a cmp %i3, %i2
200a918: 12 bf ff f0 bne 200a8d8 <_Heap_Greedy_allocate+0x14>
200a91c: 83 2e e0 02 sll %i3, 2, %g1
200a920: 10 80 00 0a b 200a948 <_Heap_Greedy_allocate+0x84>
200a924: b0 10 20 00 clr %i0
allocated_blocks = next_block;
}
}
while ( (current = _Heap_Free_list_first( heap )) != free_list_tail ) {
_Heap_Block_allocate(
200a928: 90 10 00 1d mov %i5, %o0
}
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block )
{
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
200a92c: 96 0a ff fe and %o3, -2, %o3
200a930: 92 10 00 1b mov %i3, %o1
200a934: 94 06 e0 08 add %i3, 8, %o2
200a938: 40 00 00 cb call 200ac64 <_Heap_Block_allocate>
200a93c: 96 02 ff f8 add %o3, -8, %o3
current,
_Heap_Alloc_area_of_block( current ),
_Heap_Block_size( current ) - HEAP_BLOCK_HEADER_SIZE
);
current->next = blocks;
200a940: f0 26 e0 08 st %i0, [ %i3 + 8 ]
200a944: b0 10 00 1b mov %i3, %i0
return &heap->free_list;
}
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Free_list_first( Heap_Control *heap )
{
return _Heap_Free_list_head(heap)->next;
200a948: f6 07 60 08 ld [ %i5 + 8 ], %i3
next_block->next = allocated_blocks;
allocated_blocks = next_block;
}
}
while ( (current = _Heap_Free_list_first( heap )) != free_list_tail ) {
200a94c: 80 a6 c0 1d cmp %i3, %i5
200a950: 32 bf ff f6 bne,a 200a928 <_Heap_Greedy_allocate+0x64>
200a954: d6 06 e0 04 ld [ %i3 + 4 ], %o3
current->next = blocks;
blocks = current;
}
while ( allocated_blocks != NULL ) {
200a958: 10 80 00 07 b 200a974 <_Heap_Greedy_allocate+0xb0>
200a95c: 80 a7 20 00 cmp %i4, 0
current = allocated_blocks;
allocated_blocks = allocated_blocks->next;
_Heap_Free( heap, (void *) _Heap_Alloc_area_of_block( current ) );
200a960: 92 07 20 08 add %i4, 8, %o1
200a964: 90 10 00 1d mov %i5, %o0
200a968: 40 00 1d d8 call 20120c8 <_Heap_Free>
200a96c: b8 10 00 1b mov %i3, %i4
current->next = blocks;
blocks = current;
}
while ( allocated_blocks != NULL ) {
200a970: 80 a7 20 00 cmp %i4, 0
200a974: 32 bf ff fb bne,a 200a960 <_Heap_Greedy_allocate+0x9c>
200a978: f6 07 20 08 ld [ %i4 + 8 ], %i3
allocated_blocks = allocated_blocks->next;
_Heap_Free( heap, (void *) _Heap_Alloc_area_of_block( current ) );
}
return blocks;
}
200a97c: 81 c7 e0 08 ret
200a980: 81 e8 00 00 restore
0203f744 <_Heap_Iterate>:
void _Heap_Iterate(
Heap_Control *heap,
Heap_Block_visitor visitor,
void *visitor_arg
)
{
203f744: 9d e3 bf a0 save %sp, -96, %sp
Heap_Block *current = heap->first_block;
Heap_Block *end = heap->last_block;
bool stop = false;
203f748: 90 10 20 00 clr %o0
Heap_Control *heap,
Heap_Block_visitor visitor,
void *visitor_arg
)
{
Heap_Block *current = heap->first_block;
203f74c: c2 06 20 20 ld [ %i0 + 0x20 ], %g1
Heap_Block *end = heap->last_block;
bool stop = false;
while ( !stop && current != end ) {
203f750: 10 80 00 0a b 203f778 <_Heap_Iterate+0x34>
203f754: f8 06 20 24 ld [ %i0 + 0x24 ], %i4
uintptr_t size = _Heap_Block_size( current );
Heap_Block *next = _Heap_Block_at( current, size );
bool used = _Heap_Is_prev_used( next );
stop = (*visitor)( current, size, used, visitor_arg );
203f758: 90 10 00 01 mov %g1, %o0
- 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;
203f75c: 92 0a 7f fe and %o1, -2, %o1
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
const Heap_Block *block,
uintptr_t offset
)
{
return (Heap_Block *) ((uintptr_t) block + offset);
203f760: ba 00 40 09 add %g1, %o1, %i5
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;
203f764: d4 07 60 04 ld [ %i5 + 4 ], %o2
203f768: 96 10 00 1a mov %i2, %o3
203f76c: 9f c6 40 00 call %i1
203f770: 94 0a a0 01 and %o2, 1, %o2
203f774: 82 10 00 1d mov %i5, %g1
{
Heap_Block *current = heap->first_block;
Heap_Block *end = heap->last_block;
bool stop = false;
while ( !stop && current != end ) {
203f778: 80 a0 40 1c cmp %g1, %i4
203f77c: 02 80 00 05 be 203f790 <_Heap_Iterate+0x4c>
203f780: 90 1a 20 01 xor %o0, 1, %o0
203f784: 80 8a 20 ff btst 0xff, %o0
203f788: 32 bf ff f4 bne,a 203f758 <_Heap_Iterate+0x14> <== ALWAYS TAKEN
203f78c: d2 00 60 04 ld [ %g1 + 4 ], %o1
203f790: 81 c7 e0 08 ret
203f794: 81 e8 00 00 restore
0200daa0 <_Heap_Size_of_alloc_area>:
bool _Heap_Size_of_alloc_area(
Heap_Control *heap,
void *alloc_begin_ptr,
uintptr_t *alloc_size
)
{
200daa0: 9d e3 bf a0 save %sp, -96, %sp
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(
uintptr_t value,
uintptr_t alignment
)
{
return value - (value % alignment);
200daa4: d2 06 20 10 ld [ %i0 + 0x10 ], %o1
200daa8: 40 00 2c 26 call 2018b40 <.urem>
200daac: 90 10 00 19 mov %i1, %o0
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
200dab0: c8 06 20 20 ld [ %i0 + 0x20 ], %g4
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(
uintptr_t value,
uintptr_t alignment
)
{
return value - (value % alignment);
200dab4: ba 06 7f f8 add %i1, -8, %i5
uintptr_t alloc_begin,
uintptr_t page_size
)
{
return (Heap_Block *) (_Heap_Align_down( alloc_begin, page_size )
- HEAP_BLOCK_HEADER_SIZE);
200dab8: 90 27 40 08 sub %i5, %o0, %o0
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;
200dabc: 80 a2 00 04 cmp %o0, %g4
200dac0: 0a 80 00 05 bcs 200dad4 <_Heap_Size_of_alloc_area+0x34>
200dac4: 82 10 20 00 clr %g1
200dac8: c2 06 20 24 ld [ %i0 + 0x24 ], %g1
200dacc: 80 a0 40 08 cmp %g1, %o0
200dad0: 82 60 3f ff subx %g0, -1, %g1
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 ) ) {
200dad4: 80 a0 60 00 cmp %g1, 0
200dad8: 02 80 00 15 be 200db2c <_Heap_Size_of_alloc_area+0x8c>
200dadc: 86 10 20 00 clr %g3
- 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;
200dae0: c2 02 20 04 ld [ %o0 + 4 ], %g1
200dae4: 82 08 7f fe and %g1, -2, %g1
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
const Heap_Block *block,
uintptr_t offset
)
{
return (Heap_Block *) ((uintptr_t) block + offset);
200dae8: 82 02 00 01 add %o0, %g1, %g1
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;
200daec: 80 a0 40 04 cmp %g1, %g4
200daf0: 0a 80 00 05 bcs 200db04 <_Heap_Size_of_alloc_area+0x64> <== NEVER TAKEN
200daf4: 84 10 20 00 clr %g2
200daf8: c4 06 20 24 ld [ %i0 + 0x24 ], %g2
200dafc: 80 a0 80 01 cmp %g2, %g1
200db00: 84 60 3f ff subx %g0, -1, %g2
}
block_size = _Heap_Block_size( block );
next_block = _Heap_Block_at( block, block_size );
if (
200db04: 80 a0 a0 00 cmp %g2, 0
200db08: 02 80 00 09 be 200db2c <_Heap_Size_of_alloc_area+0x8c> <== NEVER TAKEN
200db0c: 86 10 20 00 clr %g3
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;
200db10: c4 00 60 04 ld [ %g1 + 4 ], %g2
!_Heap_Is_block_in_heap( heap, next_block )
|| !_Heap_Is_prev_used( next_block )
200db14: 80 88 a0 01 btst 1, %g2
200db18: 02 80 00 05 be 200db2c <_Heap_Size_of_alloc_area+0x8c> <== NEVER TAKEN
200db1c: 82 20 40 19 sub %g1, %i1, %g1
return false;
}
*alloc_size = (uintptr_t) next_block + HEAP_ALLOC_BONUS - alloc_begin;
return true;
200db20: 86 10 20 01 mov 1, %g3
|| !_Heap_Is_prev_used( next_block )
) {
return false;
}
*alloc_size = (uintptr_t) next_block + HEAP_ALLOC_BONUS - alloc_begin;
200db24: 82 00 60 04 add %g1, 4, %g1
200db28: c2 26 80 00 st %g1, [ %i2 ]
return true;
}
200db2c: b0 08 e0 01 and %g3, 1, %i0
200db30: 81 c7 e0 08 ret
200db34: 81 e8 00 00 restore
020098b4 <_Heap_Walk>:
bool _Heap_Walk(
Heap_Control *heap,
int source,
bool dump
)
{
20098b4: 9d e3 bf 80 save %sp, -128, %sp
20098b8: ac 10 00 19 mov %i1, %l6
uintptr_t const page_size = heap->page_size;
20098bc: f8 06 20 10 ld [ %i0 + 0x10 ], %i4
uintptr_t const min_block_size = heap->min_block_size;
20098c0: f6 06 20 14 ld [ %i0 + 0x14 ], %i3
Heap_Block *const first_block = heap->first_block;
20098c4: f2 06 20 20 ld [ %i0 + 0x20 ], %i1
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;
20098c8: 80 a6 a0 00 cmp %i2, 0
20098cc: 02 80 00 05 be 20098e0 <_Heap_Walk+0x2c>
20098d0: e0 06 20 24 ld [ %i0 + 0x24 ], %l0
20098d4: 3b 00 80 26 sethi %hi(0x2009800), %i5
20098d8: 10 80 00 04 b 20098e8 <_Heap_Walk+0x34>
20098dc: ba 17 60 64 or %i5, 0x64, %i5 ! 2009864 <_Heap_Walk_print>
20098e0: 3b 00 80 26 sethi %hi(0x2009800), %i5
20098e4: ba 17 60 5c or %i5, 0x5c, %i5 ! 200985c <_Heap_Walk_print_nothing>
if ( !_System_state_Is_up( _System_state_Get() ) ) {
20098e8: 05 00 80 80 sethi %hi(0x2020000), %g2
20098ec: c4 00 a0 10 ld [ %g2 + 0x10 ], %g2 ! 2020010 <_System_state_Current>
20098f0: 80 a0 a0 03 cmp %g2, 3
20098f4: 22 80 00 04 be,a 2009904 <_Heap_Walk+0x50>
20098f8: c4 06 20 1c ld [ %i0 + 0x1c ], %g2
return true;
20098fc: 10 80 01 2a b 2009da4 <_Heap_Walk+0x4f0>
2009900: b0 10 20 01 mov 1, %i0
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)(
2009904: da 06 20 18 ld [ %i0 + 0x18 ], %o5
2009908: c4 23 a0 5c st %g2, [ %sp + 0x5c ]
200990c: f2 23 a0 60 st %i1, [ %sp + 0x60 ]
2009910: e0 23 a0 64 st %l0, [ %sp + 0x64 ]
2009914: c4 06 20 08 ld [ %i0 + 8 ], %g2
2009918: 90 10 00 16 mov %l6, %o0
200991c: c4 23 a0 68 st %g2, [ %sp + 0x68 ]
2009920: c4 06 20 0c ld [ %i0 + 0xc ], %g2
2009924: 92 10 20 00 clr %o1
2009928: c4 23 a0 6c st %g2, [ %sp + 0x6c ]
200992c: 15 00 80 72 sethi %hi(0x201c800), %o2
2009930: 96 10 00 1c mov %i4, %o3
2009934: 94 12 a0 f8 or %o2, 0xf8, %o2
2009938: 9f c7 40 00 call %i5
200993c: 98 10 00 1b mov %i3, %o4
heap->area_begin, heap->area_end,
first_block, last_block,
first_free_block, last_free_block
);
if ( page_size == 0 ) {
2009940: 80 a7 20 00 cmp %i4, 0
2009944: 12 80 00 07 bne 2009960 <_Heap_Walk+0xac>
2009948: 80 8f 20 07 btst 7, %i4
(*printer)( source, true, "page size is zero\n" );
200994c: 15 00 80 72 sethi %hi(0x201c800), %o2
2009950: 90 10 00 16 mov %l6, %o0
2009954: 92 10 20 01 mov 1, %o1
2009958: 10 80 00 37 b 2009a34 <_Heap_Walk+0x180>
200995c: 94 12 a1 90 or %o2, 0x190, %o2
return false;
}
if ( !_Addresses_Is_aligned( (void *) page_size ) ) {
2009960: 22 80 00 08 be,a 2009980 <_Heap_Walk+0xcc>
2009964: 90 10 00 1b mov %i3, %o0
(*printer)(
2009968: 15 00 80 72 sethi %hi(0x201c800), %o2
200996c: 90 10 00 16 mov %l6, %o0
2009970: 92 10 20 01 mov 1, %o1
2009974: 94 12 a1 a8 or %o2, 0x1a8, %o2
2009978: 10 80 01 12 b 2009dc0 <_Heap_Walk+0x50c>
200997c: 96 10 00 1c mov %i4, %o3
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
2009980: 7f ff e0 81 call 2001b84 <.urem>
2009984: 92 10 00 1c mov %i4, %o1
);
return false;
}
if ( !_Heap_Is_aligned( min_block_size, page_size ) ) {
2009988: 80 a2 20 00 cmp %o0, 0
200998c: 22 80 00 08 be,a 20099ac <_Heap_Walk+0xf8>
2009990: 90 06 60 08 add %i1, 8, %o0
(*printer)(
2009994: 15 00 80 72 sethi %hi(0x201c800), %o2
2009998: 90 10 00 16 mov %l6, %o0
200999c: 92 10 20 01 mov 1, %o1
20099a0: 94 12 a1 c8 or %o2, 0x1c8, %o2
20099a4: 10 80 01 07 b 2009dc0 <_Heap_Walk+0x50c>
20099a8: 96 10 00 1b mov %i3, %o3
20099ac: 7f ff e0 76 call 2001b84 <.urem>
20099b0: 92 10 00 1c mov %i4, %o1
);
return false;
}
if (
20099b4: 80 a2 20 00 cmp %o0, 0
20099b8: 22 80 00 07 be,a 20099d4 <_Heap_Walk+0x120>
20099bc: c4 06 60 04 ld [ %i1 + 4 ], %g2
!_Heap_Is_aligned( _Heap_Alloc_area_of_block( first_block ), page_size )
) {
(*printer)(
20099c0: 15 00 80 72 sethi %hi(0x201c800), %o2
20099c4: 90 10 00 16 mov %l6, %o0
20099c8: 92 10 20 01 mov 1, %o1
20099cc: 10 80 00 fc b 2009dbc <_Heap_Walk+0x508>
20099d0: 94 12 a1 f0 or %o2, 0x1f0, %o2
);
return false;
}
if ( !_Heap_Is_prev_used( first_block ) ) {
20099d4: 80 88 a0 01 btst 1, %g2
20099d8: 32 80 00 07 bne,a 20099f4 <_Heap_Walk+0x140>
20099dc: f4 04 20 04 ld [ %l0 + 4 ], %i2
(*printer)(
20099e0: 15 00 80 72 sethi %hi(0x201c800), %o2
20099e4: 90 10 00 16 mov %l6, %o0
20099e8: 92 10 20 01 mov 1, %o1
20099ec: 10 80 00 12 b 2009a34 <_Heap_Walk+0x180>
20099f0: 94 12 a2 28 or %o2, 0x228, %o2
- 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;
20099f4: b4 0e bf fe and %i2, -2, %i2
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
const Heap_Block *block,
uintptr_t offset
)
{
return (Heap_Block *) ((uintptr_t) block + offset);
20099f8: b4 04 00 1a add %l0, %i2, %i2
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;
20099fc: c4 06 a0 04 ld [ %i2 + 4 ], %g2
);
return false;
}
if ( _Heap_Is_free( last_block ) ) {
2009a00: 80 88 a0 01 btst 1, %g2
2009a04: 12 80 00 07 bne 2009a20 <_Heap_Walk+0x16c>
2009a08: 80 a6 80 19 cmp %i2, %i1
(*printer)(
2009a0c: 15 00 80 72 sethi %hi(0x201c800), %o2
2009a10: 90 10 00 16 mov %l6, %o0
2009a14: 92 10 20 01 mov 1, %o1
2009a18: 10 80 00 07 b 2009a34 <_Heap_Walk+0x180>
2009a1c: 94 12 a2 58 or %o2, 0x258, %o2
);
return false;
}
if (
2009a20: 02 80 00 0a be 2009a48 <_Heap_Walk+0x194>
2009a24: 15 00 80 72 sethi %hi(0x201c800), %o2
_Heap_Block_at( last_block, _Heap_Block_size( last_block ) ) != first_block
) {
(*printer)(
2009a28: 90 10 00 16 mov %l6, %o0
2009a2c: 92 10 20 01 mov 1, %o1
2009a30: 94 12 a2 70 or %o2, 0x270, %o2
2009a34: 9f c7 40 00 call %i5
2009a38: b0 10 20 00 clr %i0
2009a3c: b0 0e 20 ff and %i0, 0xff, %i0
2009a40: 81 c7 e0 08 ret
2009a44: 81 e8 00 00 restore
int source,
Heap_Walk_printer printer,
Heap_Control *heap
)
{
uintptr_t const page_size = heap->page_size;
2009a48: e2 06 20 10 ld [ %i0 + 0x10 ], %l1
return &heap->free_list;
}
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Free_list_first( Heap_Control *heap )
{
return _Heap_Free_list_head(heap)->next;
2009a4c: d6 06 20 08 ld [ %i0 + 8 ], %o3
const Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap );
2009a50: 10 80 00 30 b 2009b10 <_Heap_Walk+0x25c>
2009a54: b2 10 00 18 mov %i0, %i1
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;
2009a58: 80 a0 c0 0b cmp %g3, %o3
2009a5c: 18 80 00 05 bgu 2009a70 <_Heap_Walk+0x1bc>
2009a60: 84 10 20 00 clr %g2
2009a64: c4 06 20 24 ld [ %i0 + 0x24 ], %g2
2009a68: 80 a0 80 0b cmp %g2, %o3
2009a6c: 84 60 3f ff subx %g0, -1, %g2
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 ) ) {
2009a70: 80 a0 a0 00 cmp %g2, 0
2009a74: 32 80 00 07 bne,a 2009a90 <_Heap_Walk+0x1dc>
2009a78: 90 02 e0 08 add %o3, 8, %o0
(*printer)(
2009a7c: 15 00 80 72 sethi %hi(0x201c800), %o2
2009a80: 90 10 00 16 mov %l6, %o0
2009a84: 92 10 20 01 mov 1, %o1
2009a88: 10 80 00 ce b 2009dc0 <_Heap_Walk+0x50c>
2009a8c: 94 12 a2 a0 or %o2, 0x2a0, %o2
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
2009a90: d6 27 bf fc st %o3, [ %fp + -4 ]
2009a94: 7f ff e0 3c call 2001b84 <.urem>
2009a98: 92 10 00 11 mov %l1, %o1
);
return false;
}
if (
2009a9c: 80 a2 20 00 cmp %o0, 0
2009aa0: 02 80 00 07 be 2009abc <_Heap_Walk+0x208>
2009aa4: d6 07 bf fc ld [ %fp + -4 ], %o3
!_Heap_Is_aligned( _Heap_Alloc_area_of_block( free_block ), page_size )
) {
(*printer)(
2009aa8: 15 00 80 72 sethi %hi(0x201c800), %o2
2009aac: 90 10 00 16 mov %l6, %o0
2009ab0: 92 10 20 01 mov 1, %o1
2009ab4: 10 80 00 c3 b 2009dc0 <_Heap_Walk+0x50c>
2009ab8: 94 12 a2 c0 or %o2, 0x2c0, %o2
- 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;
2009abc: c4 02 e0 04 ld [ %o3 + 4 ], %g2
2009ac0: 84 08 bf fe and %g2, -2, %g2
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;
2009ac4: 84 02 c0 02 add %o3, %g2, %g2
2009ac8: c4 00 a0 04 ld [ %g2 + 4 ], %g2
);
return false;
}
if ( _Heap_Is_used( free_block ) ) {
2009acc: 80 88 a0 01 btst 1, %g2
2009ad0: 22 80 00 07 be,a 2009aec <_Heap_Walk+0x238>
2009ad4: d8 02 e0 0c ld [ %o3 + 0xc ], %o4
(*printer)(
2009ad8: 15 00 80 72 sethi %hi(0x201c800), %o2
2009adc: 90 10 00 16 mov %l6, %o0
2009ae0: 92 10 20 01 mov 1, %o1
2009ae4: 10 80 00 b7 b 2009dc0 <_Heap_Walk+0x50c>
2009ae8: 94 12 a2 f0 or %o2, 0x2f0, %o2
);
return false;
}
if ( free_block->prev != prev_block ) {
2009aec: 80 a3 00 19 cmp %o4, %i1
2009af0: 02 80 00 07 be 2009b0c <_Heap_Walk+0x258>
2009af4: b2 10 00 0b mov %o3, %i1
(*printer)(
2009af8: 15 00 80 72 sethi %hi(0x201c800), %o2
2009afc: 90 10 00 16 mov %l6, %o0
2009b00: 92 10 20 01 mov 1, %o1
2009b04: 10 80 00 4d b 2009c38 <_Heap_Walk+0x384>
2009b08: 94 12 a3 10 or %o2, 0x310, %o2
return false;
}
prev_block = free_block;
free_block = free_block->next;
2009b0c: d6 02 e0 08 ld [ %o3 + 8 ], %o3
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 ) {
2009b10: 80 a2 c0 18 cmp %o3, %i0
2009b14: 32 bf ff d1 bne,a 2009a58 <_Heap_Walk+0x1a4>
2009b18: c6 06 20 20 ld [ %i0 + 0x20 ], %g3
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)(
2009b1c: 2b 00 80 73 sethi %hi(0x201cc00), %l5
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 ) {
2009b20: b2 10 00 1a mov %i2, %i1
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)(
2009b24: aa 15 60 10 or %l5, 0x10, %l5
" (= first free)"
: (block->prev == free_list_head ? " (= head)" : ""),
block->next,
block->next == last_free_block ?
" (= last free)"
: (block->next == free_list_tail ? " (= tail)" : "")
2009b28: 23 00 80 73 sethi %hi(0x201cc00), %l1
2009b2c: 2f 00 80 72 sethi %hi(0x201c800), %l7
- 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;
2009b30: e4 06 60 04 ld [ %i1 + 4 ], %l2
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;
2009b34: d8 06 20 20 ld [ %i0 + 0x20 ], %o4
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;
2009b38: 9e 1e 40 10 xor %i1, %l0, %o7
2009b3c: 80 a0 00 0f cmp %g0, %o7
- 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;
2009b40: a8 0c bf fe and %l2, -2, %l4
2009b44: 9a 40 20 00 addx %g0, 0, %o5
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
const Heap_Block *block,
uintptr_t offset
)
{
return (Heap_Block *) ((uintptr_t) block + offset);
2009b48: a6 06 40 14 add %i1, %l4, %l3
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;
2009b4c: a4 0c a0 01 and %l2, 1, %l2
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;
2009b50: 80 a3 00 13 cmp %o4, %l3
2009b54: 18 80 00 05 bgu 2009b68 <_Heap_Walk+0x2b4> <== NEVER TAKEN
2009b58: 9e 10 20 00 clr %o7
2009b5c: de 06 20 24 ld [ %i0 + 0x24 ], %o7
2009b60: 80 a3 c0 13 cmp %o7, %l3
2009b64: 9e 60 3f ff subx %g0, -1, %o7
if ( !_Heap_Is_block_in_heap( heap, next_block ) ) {
2009b68: 80 a3 e0 00 cmp %o7, 0
2009b6c: 32 80 00 07 bne,a 2009b88 <_Heap_Walk+0x2d4>
2009b70: da 27 bf f8 st %o5, [ %fp + -8 ]
(*printer)(
2009b74: 15 00 80 72 sethi %hi(0x201c800), %o2
2009b78: 90 10 00 16 mov %l6, %o0
2009b7c: 92 10 20 01 mov 1, %o1
2009b80: 10 80 00 2c b 2009c30 <_Heap_Walk+0x37c>
2009b84: 94 12 a3 48 or %o2, 0x348, %o2
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
2009b88: 90 10 00 14 mov %l4, %o0
2009b8c: 7f ff df fe call 2001b84 <.urem>
2009b90: 92 10 00 1c mov %i4, %o1
2009b94: da 07 bf f8 ld [ %fp + -8 ], %o5
);
return false;
}
if ( !_Heap_Is_aligned( block_size, page_size ) && is_not_last_block ) {
2009b98: 80 a2 20 00 cmp %o0, 0
2009b9c: 02 80 00 0c be 2009bcc <_Heap_Walk+0x318>
2009ba0: 9e 0b 60 ff and %o5, 0xff, %o7
2009ba4: 80 a3 e0 00 cmp %o7, 0
2009ba8: 02 80 00 19 be 2009c0c <_Heap_Walk+0x358>
2009bac: 80 a6 40 13 cmp %i1, %l3
(*printer)(
2009bb0: 15 00 80 72 sethi %hi(0x201c800), %o2
2009bb4: 90 10 00 16 mov %l6, %o0
2009bb8: 92 10 20 01 mov 1, %o1
2009bbc: 94 12 a3 78 or %o2, 0x378, %o2
2009bc0: 96 10 00 19 mov %i1, %o3
2009bc4: 10 80 00 1d b 2009c38 <_Heap_Walk+0x384>
2009bc8: 98 10 00 14 mov %l4, %o4
);
return false;
}
if ( block_size < min_block_size && is_not_last_block ) {
2009bcc: 80 a3 e0 00 cmp %o7, 0
2009bd0: 02 80 00 0f be 2009c0c <_Heap_Walk+0x358>
2009bd4: 80 a6 40 13 cmp %i1, %l3
2009bd8: 80 a5 00 1b cmp %l4, %i3
2009bdc: 1a 80 00 0c bcc 2009c0c <_Heap_Walk+0x358>
2009be0: 80 a6 40 13 cmp %i1, %l3
(*printer)(
2009be4: 90 10 00 16 mov %l6, %o0
2009be8: 92 10 20 01 mov 1, %o1
2009bec: 15 00 80 72 sethi %hi(0x201c800), %o2
2009bf0: 96 10 00 19 mov %i1, %o3
2009bf4: 94 12 a3 a8 or %o2, 0x3a8, %o2
2009bf8: 98 10 00 14 mov %l4, %o4
2009bfc: 9f c7 40 00 call %i5
2009c00: 9a 10 00 1b mov %i3, %o5
"block 0x%08x: next block 0x%08x is not a successor\n",
block,
next_block
);
return false;
2009c04: 10 80 00 68 b 2009da4 <_Heap_Walk+0x4f0>
2009c08: b0 10 20 00 clr %i0
);
return false;
}
if ( next_block_begin <= block_begin && is_not_last_block ) {
2009c0c: 2a 80 00 10 bcs,a 2009c4c <_Heap_Walk+0x398>
2009c10: de 04 e0 04 ld [ %l3 + 4 ], %o7
2009c14: 80 8b 60 ff btst 0xff, %o5
2009c18: 22 80 00 0d be,a 2009c4c <_Heap_Walk+0x398>
2009c1c: de 04 e0 04 ld [ %l3 + 4 ], %o7
(*printer)(
2009c20: 15 00 80 72 sethi %hi(0x201c800), %o2
2009c24: 90 10 00 16 mov %l6, %o0
2009c28: 92 10 20 01 mov 1, %o1
2009c2c: 94 12 a3 d8 or %o2, 0x3d8, %o2
2009c30: 96 10 00 19 mov %i1, %o3
2009c34: 98 10 00 13 mov %l3, %o4
2009c38: 9f c7 40 00 call %i5
2009c3c: b0 10 20 00 clr %i0
2009c40: b0 0e 20 ff and %i0, 0xff, %i0
2009c44: 81 c7 e0 08 ret
2009c48: 81 e8 00 00 restore
);
return false;
}
if ( !_Heap_Is_prev_used( next_block ) ) {
2009c4c: 80 8b e0 01 btst 1, %o7
2009c50: 12 80 00 3f bne 2009d4c <_Heap_Walk+0x498>
2009c54: 90 10 00 16 mov %l6, %o0
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 ?
2009c58: da 06 60 0c ld [ %i1 + 0xc ], %o5
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)(
2009c5c: d8 06 20 08 ld [ %i0 + 8 ], %o4
2009c60: 80 a3 40 0c cmp %o5, %o4
2009c64: 02 80 00 08 be 2009c84 <_Heap_Walk+0x3d0>
2009c68: de 06 20 0c ld [ %i0 + 0xc ], %o7
block,
block_size,
block->prev,
block->prev == first_free_block ?
" (= first free)"
: (block->prev == free_list_head ? " (= head)" : ""),
2009c6c: 80 a3 40 18 cmp %o5, %i0
2009c70: 12 80 00 07 bne 2009c8c <_Heap_Walk+0x3d8>
2009c74: 96 14 60 80 or %l1, 0x80, %o3
2009c78: 17 00 80 72 sethi %hi(0x201c800), %o3
2009c7c: 10 80 00 04 b 2009c8c <_Heap_Walk+0x3d8>
2009c80: 96 12 e0 c8 or %o3, 0xc8, %o3 ! 201c8c8 <__log2table+0x130>
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)(
2009c84: 03 00 80 72 sethi %hi(0x201c800), %g1
2009c88: 96 10 60 b8 or %g1, 0xb8, %o3 ! 201c8b8 <__log2table+0x120>
block->prev,
block->prev == first_free_block ?
" (= first free)"
: (block->prev == free_list_head ? " (= head)" : ""),
block->next,
block->next == last_free_block ?
2009c8c: d8 06 60 08 ld [ %i1 + 8 ], %o4
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)(
2009c90: 80 a3 00 0f cmp %o4, %o7
2009c94: 02 80 00 06 be 2009cac <_Heap_Walk+0x3f8>
2009c98: 80 a3 00 18 cmp %o4, %i0
" (= first free)"
: (block->prev == free_list_head ? " (= head)" : ""),
block->next,
block->next == last_free_block ?
" (= last free)"
: (block->next == free_list_tail ? " (= tail)" : "")
2009c9c: 12 80 00 06 bne 2009cb4 <_Heap_Walk+0x400>
2009ca0: 9e 14 60 80 or %l1, 0x80, %o7
2009ca4: 10 80 00 04 b 2009cb4 <_Heap_Walk+0x400>
2009ca8: 9e 15 e0 e8 or %l7, 0xe8, %o7
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)(
2009cac: 03 00 80 72 sethi %hi(0x201c800), %g1
2009cb0: 9e 10 60 d8 or %g1, 0xd8, %o7 ! 201c8d8 <__log2table+0x140>
2009cb4: d6 23 a0 5c st %o3, [ %sp + 0x5c ]
2009cb8: d8 23 a0 60 st %o4, [ %sp + 0x60 ]
2009cbc: de 23 a0 64 st %o7, [ %sp + 0x64 ]
2009cc0: 90 10 00 16 mov %l6, %o0
2009cc4: 92 10 20 00 clr %o1
2009cc8: 94 10 00 15 mov %l5, %o2
2009ccc: 96 10 00 19 mov %i1, %o3
2009cd0: 9f c7 40 00 call %i5
2009cd4: 98 10 00 14 mov %l4, %o4
block->next == last_free_block ?
" (= last free)"
: (block->next == free_list_tail ? " (= tail)" : "")
);
if ( block_size != next_block->prev_size ) {
2009cd8: da 04 c0 00 ld [ %l3 ], %o5
2009cdc: 80 a5 00 0d cmp %l4, %o5
2009ce0: 02 80 00 0c be 2009d10 <_Heap_Walk+0x45c>
2009ce4: 80 a4 a0 00 cmp %l2, 0
(*printer)(
2009ce8: e6 23 a0 5c st %l3, [ %sp + 0x5c ]
2009cec: 90 10 00 16 mov %l6, %o0
2009cf0: 92 10 20 01 mov 1, %o1
2009cf4: 15 00 80 73 sethi %hi(0x201cc00), %o2
2009cf8: 96 10 00 19 mov %i1, %o3
2009cfc: 94 12 a0 48 or %o2, 0x48, %o2
2009d00: 9f c7 40 00 call %i5
2009d04: 98 10 00 14 mov %l4, %o4
"block 0x%08x: next block 0x%08x is not a successor\n",
block,
next_block
);
return false;
2009d08: 10 bf ff ce b 2009c40 <_Heap_Walk+0x38c>
2009d0c: b0 10 20 00 clr %i0
);
return false;
}
if ( !prev_used ) {
2009d10: 32 80 00 0a bne,a 2009d38 <_Heap_Walk+0x484>
2009d14: c6 06 20 08 ld [ %i0 + 8 ], %g3
(*printer)(
2009d18: 15 00 80 73 sethi %hi(0x201cc00), %o2
2009d1c: 90 10 00 16 mov %l6, %o0
2009d20: 92 10 20 01 mov 1, %o1
2009d24: 10 80 00 26 b 2009dbc <_Heap_Walk+0x508>
2009d28: 94 12 a0 88 or %o2, 0x88, %o2
{
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 ) {
2009d2c: 22 80 00 19 be,a 2009d90 <_Heap_Walk+0x4dc>
2009d30: b2 10 00 13 mov %l3, %i1
return true;
}
free_block = free_block->next;
2009d34: c6 00 e0 08 ld [ %g3 + 8 ], %g3
)
{
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 ) {
2009d38: 80 a0 c0 18 cmp %g3, %i0
2009d3c: 12 bf ff fc bne 2009d2c <_Heap_Walk+0x478>
2009d40: 80 a0 c0 19 cmp %g3, %i1
return false;
}
if ( !_Heap_Walk_is_in_free_list( heap, block ) ) {
(*printer)(
2009d44: 10 80 00 1b b 2009db0 <_Heap_Walk+0x4fc>
2009d48: 15 00 80 73 sethi %hi(0x201cc00), %o2
if ( !_Heap_Is_prev_used( next_block ) ) {
if ( !_Heap_Walk_check_free_block( source, printer, heap, block ) ) {
return false;
}
} else if (prev_used) {
2009d4c: 80 a4 a0 00 cmp %l2, 0
2009d50: 02 80 00 09 be 2009d74 <_Heap_Walk+0x4c0>
2009d54: 92 10 20 00 clr %o1
(*printer)(
2009d58: 15 00 80 73 sethi %hi(0x201cc00), %o2
2009d5c: 96 10 00 19 mov %i1, %o3
2009d60: 94 12 a0 b8 or %o2, 0xb8, %o2
2009d64: 9f c7 40 00 call %i5
2009d68: 98 10 00 14 mov %l4, %o4
2009d6c: 10 80 00 09 b 2009d90 <_Heap_Walk+0x4dc>
2009d70: b2 10 00 13 mov %l3, %i1
"block 0x%08x: size %u\n",
block,
block_size
);
} else {
(*printer)(
2009d74: da 06 40 00 ld [ %i1 ], %o5
2009d78: 15 00 80 73 sethi %hi(0x201cc00), %o2
2009d7c: 96 10 00 19 mov %i1, %o3
2009d80: 94 12 a0 d0 or %o2, 0xd0, %o2
2009d84: 9f c7 40 00 call %i5
2009d88: 98 10 00 14 mov %l4, %o4
2009d8c: b2 10 00 13 mov %l3, %i1
block->prev_size
);
}
block = next_block;
} while ( block != first_block );
2009d90: 80 a4 c0 1a cmp %l3, %i2
2009d94: 32 bf ff 68 bne,a 2009b34 <_Heap_Walk+0x280>
2009d98: e4 06 60 04 ld [ %i1 + 4 ], %l2
2009d9c: 10 80 00 02 b 2009da4 <_Heap_Walk+0x4f0>
2009da0: b0 10 20 01 mov 1, %i0
2009da4: b0 0e 20 ff and %i0, 0xff, %i0
2009da8: 81 c7 e0 08 ret
2009dac: 81 e8 00 00 restore
return false;
}
if ( !_Heap_Walk_is_in_free_list( heap, block ) ) {
(*printer)(
2009db0: 90 10 00 16 mov %l6, %o0
2009db4: 92 10 20 01 mov 1, %o1
2009db8: 94 12 a0 f8 or %o2, 0xf8, %o2
2009dbc: 96 10 00 19 mov %i1, %o3
2009dc0: 9f c7 40 00 call %i5
2009dc4: b0 10 20 00 clr %i0
2009dc8: b0 0e 20 ff and %i0, 0xff, %i0
2009dcc: 81 c7 e0 08 ret
2009dd0: 81 e8 00 00 restore
02008d58 <_Objects_Allocate>:
*/
Objects_Control *_Objects_Allocate(
Objects_Information *information
)
{
2008d58: 9d e3 bf a0 save %sp, -96, %sp
* 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 )
2008d5c: c2 06 20 18 ld [ %i0 + 0x18 ], %g1
2008d60: 80 a0 60 00 cmp %g1, 0
2008d64: 12 80 00 04 bne 2008d74 <_Objects_Allocate+0x1c> <== ALWAYS TAKEN
2008d68: ba 10 00 18 mov %i0, %i5
return NULL;
2008d6c: 81 c7 e0 08 ret
2008d70: 91 e8 20 00 restore %g0, 0, %o0
/*
* 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 );
2008d74: b8 06 20 20 add %i0, 0x20, %i4
2008d78: 7f ff fd 83 call 2008384 <_Chain_Get>
2008d7c: 90 10 00 1c mov %i4, %o0
if ( information->auto_extend ) {
2008d80: c2 0f 60 12 ldub [ %i5 + 0x12 ], %g1
2008d84: 80 a0 60 00 cmp %g1, 0
2008d88: 02 80 00 1d be 2008dfc <_Objects_Allocate+0xa4>
2008d8c: b0 10 00 08 mov %o0, %i0
/*
* If the list is empty then we are out of objects and need to
* extend information base.
*/
if ( !the_object ) {
2008d90: 80 a2 20 00 cmp %o0, 0
2008d94: 32 80 00 0a bne,a 2008dbc <_Objects_Allocate+0x64>
2008d98: c4 07 60 08 ld [ %i5 + 8 ], %g2
_Objects_Extend_information( information );
2008d9c: 40 00 00 21 call 2008e20 <_Objects_Extend_information>
2008da0: 90 10 00 1d mov %i5, %o0
the_object = (Objects_Control *) _Chain_Get( &information->Inactive );
2008da4: 7f ff fd 78 call 2008384 <_Chain_Get>
2008da8: 90 10 00 1c mov %i4, %o0
}
if ( the_object ) {
2008dac: b0 92 20 00 orcc %o0, 0, %i0
2008db0: 02 bf ff ef be 2008d6c <_Objects_Allocate+0x14>
2008db4: 01 00 00 00 nop
uint32_t block;
block = (uint32_t) _Objects_Get_index( the_object->id ) -
2008db8: c4 07 60 08 ld [ %i5 + 8 ], %g2
2008dbc: d0 06 20 08 ld [ %i0 + 8 ], %o0
_Objects_Get_index( information->minimum_id );
block /= information->allocation_size;
2008dc0: d2 17 60 14 lduh [ %i5 + 0x14 ], %o1
}
if ( the_object ) {
uint32_t block;
block = (uint32_t) _Objects_Get_index( the_object->id ) -
2008dc4: 03 00 00 3f sethi %hi(0xfc00), %g1
2008dc8: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff <PROM_START+0xffff>
2008dcc: 90 0a 00 01 and %o0, %g1, %o0
2008dd0: 82 08 80 01 and %g2, %g1, %g1
_Objects_Get_index( information->minimum_id );
block /= information->allocation_size;
2008dd4: 40 00 3e af call 2018890 <.udiv>
2008dd8: 90 22 00 01 sub %o0, %g1, %o0
information->inactive_per_block[ block ]--;
2008ddc: c2 07 60 30 ld [ %i5 + 0x30 ], %g1
2008de0: 91 2a 20 02 sll %o0, 2, %o0
2008de4: c4 00 40 08 ld [ %g1 + %o0 ], %g2
2008de8: 84 00 bf ff add %g2, -1, %g2
2008dec: c4 20 40 08 st %g2, [ %g1 + %o0 ]
information->inactive--;
2008df0: c2 17 60 2c lduh [ %i5 + 0x2c ], %g1
2008df4: 82 00 7f ff add %g1, -1, %g1
2008df8: c2 37 60 2c sth %g1, [ %i5 + 0x2c ]
);
}
#endif
return the_object;
}
2008dfc: 81 c7 e0 08 ret
2008e00: 81 e8 00 00 restore
02009168 <_Objects_Get_information>:
Objects_Information *_Objects_Get_information(
Objects_APIs the_api,
uint16_t the_class
)
{
2009168: 9d e3 bf a0 save %sp, -96, %sp
Objects_Information *info;
int the_class_api_maximum;
if ( !the_class )
200916c: 80 a6 60 00 cmp %i1, 0
2009170: 12 80 00 04 bne 2009180 <_Objects_Get_information+0x18>
2009174: 01 00 00 00 nop
return NULL;
2009178: 81 c7 e0 08 ret
200917c: 91 e8 20 00 restore %g0, 0, %o0
/*
* 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 );
2009180: 40 00 12 6e call 200db38 <_Objects_API_maximum_class>
2009184: 90 10 00 18 mov %i0, %o0
if ( the_class_api_maximum == 0 )
2009188: 80 a2 20 00 cmp %o0, 0
200918c: 02 bf ff fb be 2009178 <_Objects_Get_information+0x10>
2009190: 80 a6 40 08 cmp %i1, %o0
return NULL;
if ( the_class > (uint32_t) the_class_api_maximum )
2009194: 18 bf ff f9 bgu 2009178 <_Objects_Get_information+0x10>
2009198: 03 00 80 76 sethi %hi(0x201d800), %g1
return NULL;
if ( !_Objects_Information_table[ the_api ] )
200919c: b1 2e 20 02 sll %i0, 2, %i0
20091a0: 82 10 62 44 or %g1, 0x244, %g1
20091a4: c2 00 40 18 ld [ %g1 + %i0 ], %g1
20091a8: 80 a0 60 00 cmp %g1, 0
20091ac: 02 bf ff f3 be 2009178 <_Objects_Get_information+0x10> <== NEVER TAKEN
20091b0: b3 2e 60 02 sll %i1, 2, %i1
return NULL;
info = _Objects_Information_table[ the_api ][ the_class ];
20091b4: f0 00 40 19 ld [ %g1 + %i1 ], %i0
if ( !info )
20091b8: 80 a6 20 00 cmp %i0, 0
20091bc: 02 bf ff ef be 2009178 <_Objects_Get_information+0x10> <== NEVER TAKEN
20091c0: 01 00 00 00 nop
* 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 )
20091c4: c2 16 20 10 lduh [ %i0 + 0x10 ], %g1
20091c8: 80 a0 60 00 cmp %g1, 0
20091cc: 02 bf ff eb be 2009178 <_Objects_Get_information+0x10>
20091d0: 01 00 00 00 nop
return NULL;
#endif
return info;
}
20091d4: 81 c7 e0 08 ret
20091d8: 81 e8 00 00 restore
0201b4ec <_Objects_Get_no_protection>:
/*
* You can't just extract the index portion or you can get tricked
* by a value between 1 and maximum.
*/
index = id - information->minimum_id + 1;
201b4ec: c2 02 20 08 ld [ %o0 + 8 ], %g1
201b4f0: 92 22 40 01 sub %o1, %g1, %o1
if ( information->maximum >= index ) {
201b4f4: c2 12 20 10 lduh [ %o0 + 0x10 ], %g1
/*
* You can't just extract the index portion or you can get tricked
* by a value between 1 and maximum.
*/
index = id - information->minimum_id + 1;
201b4f8: 92 02 60 01 inc %o1
if ( information->maximum >= index ) {
201b4fc: 80 a0 40 09 cmp %g1, %o1
201b500: 0a 80 00 09 bcs 201b524 <_Objects_Get_no_protection+0x38>
201b504: 93 2a 60 02 sll %o1, 2, %o1
if ( (the_object = information->local_table[ index ]) != NULL ) {
201b508: c2 02 20 1c ld [ %o0 + 0x1c ], %g1
201b50c: d0 00 40 09 ld [ %g1 + %o1 ], %o0
201b510: 80 a2 20 00 cmp %o0, 0
201b514: 02 80 00 05 be 201b528 <_Objects_Get_no_protection+0x3c> <== NEVER TAKEN
201b518: 82 10 20 01 mov 1, %g1
*location = OBJECTS_LOCAL;
return the_object;
201b51c: 81 c3 e0 08 retl
201b520: c0 22 80 00 clr [ %o2 ]
/*
* This isn't supported or required yet for Global objects so
* if it isn't local, we don't find it.
*/
*location = OBJECTS_ERROR;
201b524: 82 10 20 01 mov 1, %g1
return NULL;
201b528: 90 10 20 00 clr %o0
}
201b52c: 81 c3 e0 08 retl
201b530: c2 22 80 00 st %g1, [ %o2 ]
0200d26c <_Objects_Id_to_name>:
*/
Objects_Name_or_id_lookup_errors _Objects_Id_to_name (
Objects_Id id,
Objects_Name *name
)
{
200d26c: 9d e3 bf 98 save %sp, -104, %sp
/*
* Caller is trusted for name != NULL.
*/
tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Executing->Object.id : id;
200d270: 80 a6 20 00 cmp %i0, 0
200d274: 12 80 00 06 bne 200d28c <_Objects_Id_to_name+0x20>
200d278: 83 36 20 18 srl %i0, 0x18, %g1
200d27c: 03 00 80 b8 sethi %hi(0x202e000), %g1
200d280: c2 00 62 ec ld [ %g1 + 0x2ec ], %g1 ! 202e2ec <_Per_CPU_Information+0xc>
200d284: f0 00 60 08 ld [ %g1 + 8 ], %i0
200d288: 83 36 20 18 srl %i0, 0x18, %g1
200d28c: 82 08 60 07 and %g1, 7, %g1
*/
RTEMS_INLINE_ROUTINE bool _Objects_Is_api_valid(
uint32_t the_api
)
{
if ( !the_api || the_api > OBJECTS_APIS_LAST )
200d290: 84 00 7f ff add %g1, -1, %g2
200d294: 80 a0 a0 02 cmp %g2, 2
200d298: 08 80 00 18 bleu 200d2f8 <_Objects_Id_to_name+0x8c>
200d29c: 83 28 60 02 sll %g1, 2, %g1
the_api = _Objects_Get_API( tmpId );
if ( !_Objects_Is_api_valid( the_api ) )
return OBJECTS_INVALID_ID;
200d2a0: 81 c7 e0 08 ret
200d2a4: 91 e8 20 03 restore %g0, 3, %o0
if ( !_Objects_Information_table[ the_api ] )
return OBJECTS_INVALID_ID;
the_class = _Objects_Get_class( tmpId );
information = _Objects_Information_table[ the_api ][ the_class ];
200d2a8: 85 28 a0 02 sll %g2, 2, %g2
200d2ac: d0 00 40 02 ld [ %g1 + %g2 ], %o0
if ( !information )
200d2b0: 80 a2 20 00 cmp %o0, 0
200d2b4: 02 bf ff fb be 200d2a0 <_Objects_Id_to_name+0x34> <== NEVER TAKEN
200d2b8: 01 00 00 00 nop
return OBJECTS_INVALID_ID;
#if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES)
if ( information->is_string )
200d2bc: c2 0a 20 38 ldub [ %o0 + 0x38 ], %g1
200d2c0: 80 a0 60 00 cmp %g1, 0
200d2c4: 12 bf ff f7 bne 200d2a0 <_Objects_Id_to_name+0x34> <== NEVER TAKEN
200d2c8: 92 10 00 18 mov %i0, %o1
return OBJECTS_INVALID_ID;
#endif
the_object = _Objects_Get( information, tmpId, &ignored_location );
200d2cc: 7f ff ff ca call 200d1f4 <_Objects_Get>
200d2d0: 94 07 bf fc add %fp, -4, %o2
if ( !the_object )
200d2d4: 80 a2 20 00 cmp %o0, 0
200d2d8: 02 bf ff f2 be 200d2a0 <_Objects_Id_to_name+0x34>
200d2dc: 01 00 00 00 nop
return OBJECTS_INVALID_ID;
*name = the_object->name;
200d2e0: c2 02 20 0c ld [ %o0 + 0xc ], %g1
_Thread_Enable_dispatch();
return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL;
200d2e4: b0 10 20 00 clr %i0
the_object = _Objects_Get( information, tmpId, &ignored_location );
if ( !the_object )
return OBJECTS_INVALID_ID;
*name = the_object->name;
_Thread_Enable_dispatch();
200d2e8: 40 00 03 c3 call 200e1f4 <_Thread_Enable_dispatch>
200d2ec: c2 26 40 00 st %g1, [ %i1 ]
200d2f0: 81 c7 e0 08 ret
200d2f4: 81 e8 00 00 restore
the_api = _Objects_Get_API( tmpId );
if ( !_Objects_Is_api_valid( the_api ) )
return OBJECTS_INVALID_ID;
if ( !_Objects_Information_table[ the_api ] )
200d2f8: 05 00 80 b7 sethi %hi(0x202dc00), %g2
200d2fc: 84 10 a0 d4 or %g2, 0xd4, %g2 ! 202dcd4 <_Objects_Information_table>
200d300: c2 00 80 01 ld [ %g2 + %g1 ], %g1
200d304: 80 a0 60 00 cmp %g1, 0
200d308: 12 bf ff e8 bne 200d2a8 <_Objects_Id_to_name+0x3c>
200d30c: 85 36 20 1b srl %i0, 0x1b, %g2
200d310: 30 bf ff e4 b,a 200d2a0 <_Objects_Id_to_name+0x34>
0200f0bc <_POSIX_Keys_Run_destructors>:
*/
void _POSIX_Keys_Run_destructors(
Thread_Control *thread
)
{
200f0bc: 9d e3 bf a0 save %sp, -96, %sp
Objects_Maximum thread_index = _Objects_Get_index( thread->Object.id );
200f0c0: c2 06 20 08 ld [ %i0 + 8 ], %g1
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 ];
200f0c4: 39 00 00 3f sethi %hi(0xfc00), %i4
200f0c8: b5 30 60 18 srl %g1, 0x18, %i2
200f0cc: b8 17 23 ff or %i4, 0x3ff, %i4
200f0d0: b4 0e a0 07 and %i2, 7, %i2
200f0d4: b8 08 40 1c and %g1, %i4, %i4
200f0d8: b4 06 a0 04 add %i2, 4, %i2
200f0dc: b9 2f 20 02 sll %i4, 2, %i4
*
* 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;
200f0e0: 37 00 80 77 sethi %hi(0x201dc00), %i3
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 ];
200f0e4: b5 2e a0 02 sll %i2, 2, %i2
*
* 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;
200f0e8: 82 16 e2 e8 or %i3, 0x2e8, %g1
done = true;
for ( index = 1 ; index <= max ; ++index ) {
200f0ec: ba 10 20 01 mov 1, %i5
*/
while ( !done ) {
Objects_Maximum index = 0;
Objects_Maximum max = _POSIX_Keys_Information.maximum;
done = true;
200f0f0: 84 10 20 01 mov 1, %g2
for ( index = 1 ; index <= max ; ++index ) {
200f0f4: 10 80 00 18 b 200f154 <_POSIX_Keys_Run_destructors+0x98>
200f0f8: f2 10 60 10 lduh [ %g1 + 0x10 ], %i1
POSIX_Keys_Control *key = (POSIX_Keys_Control *)
_POSIX_Keys_Information.local_table [ index ];
200f0fc: 86 16 e2 e8 or %i3, 0x2e8, %g3
Objects_Maximum max = _POSIX_Keys_Information.maximum;
done = true;
for ( index = 1 ; index <= max ; ++index ) {
POSIX_Keys_Control *key = (POSIX_Keys_Control *)
200f100: c6 00 e0 1c ld [ %g3 + 0x1c ], %g3
200f104: 83 28 60 02 sll %g1, 2, %g1
200f108: c2 00 c0 01 ld [ %g3 + %g1 ], %g1
_POSIX_Keys_Information.local_table [ index ];
if ( key != NULL && key->destructor != NULL ) {
200f10c: 80 a0 60 00 cmp %g1, 0
200f110: 22 80 00 11 be,a 200f154 <_POSIX_Keys_Run_destructors+0x98>
200f114: ba 07 60 01 inc %i5
200f118: c6 00 60 10 ld [ %g1 + 0x10 ], %g3
200f11c: 80 a0 e0 00 cmp %g3, 0
200f120: 02 80 00 0c be 200f150 <_POSIX_Keys_Run_destructors+0x94>
200f124: 86 00 40 1a add %g1, %i2, %g3
void *value = key->Values [ thread_api ][ thread_index ];
200f128: c6 00 e0 04 ld [ %g3 + 4 ], %g3
200f12c: d0 00 c0 1c ld [ %g3 + %i4 ], %o0
if ( value != NULL ) {
200f130: 80 a2 20 00 cmp %o0, 0
200f134: 22 80 00 08 be,a 200f154 <_POSIX_Keys_Run_destructors+0x98><== ALWAYS TAKEN
200f138: ba 07 60 01 inc %i5
key->Values [ thread_api ][ thread_index ] = NULL;
200f13c: c0 20 c0 1c clr [ %g3 + %i4 ] <== NOT EXECUTED
(*key->destructor)( value );
200f140: c2 00 60 10 ld [ %g1 + 0x10 ], %g1 <== NOT EXECUTED
200f144: 9f c0 40 00 call %g1 <== NOT EXECUTED
200f148: 01 00 00 00 nop <== NOT EXECUTED
done = false;
200f14c: 84 10 20 00 clr %g2 ! 0 <PROM_START> <== NOT EXECUTED
Objects_Maximum index = 0;
Objects_Maximum max = _POSIX_Keys_Information.maximum;
done = true;
for ( index = 1 ; index <= max ; ++index ) {
200f150: ba 07 60 01 inc %i5
200f154: 83 2f 60 10 sll %i5, 0x10, %g1
200f158: 83 30 60 10 srl %g1, 0x10, %g1
200f15c: 80 a0 40 19 cmp %g1, %i1
200f160: 08 bf ff e7 bleu 200f0fc <_POSIX_Keys_Run_destructors+0x40>
200f164: 80 88 a0 ff btst 0xff, %g2
* 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 ) {
200f168: 02 bf ff e1 be 200f0ec <_POSIX_Keys_Run_destructors+0x30> <== NEVER TAKEN
200f16c: 82 16 e2 e8 or %i3, 0x2e8, %g1
done = false;
}
}
}
}
}
200f170: 81 c7 e0 08 ret
200f174: 81 e8 00 00 restore
0200ca40 <_POSIX_Message_queue_Receive_support>:
size_t msg_len,
unsigned int *msg_prio,
bool wait,
Watchdog_Interval timeout
)
{
200ca40: 9d e3 bf 98 save %sp, -104, %sp
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(
200ca44: 11 00 80 ab sethi %hi(0x202ac00), %o0
200ca48: 92 10 00 18 mov %i0, %o1
200ca4c: 90 12 21 3c or %o0, 0x13c, %o0
200ca50: 40 00 0c bc call 200fd40 <_Objects_Get>
200ca54: 94 07 bf f8 add %fp, -8, %o2
Objects_Locations location;
size_t length_out;
bool do_wait;
the_mq_fd = _POSIX_Message_queue_Get_fd( mqdes, &location );
switch ( location ) {
200ca58: c2 07 bf f8 ld [ %fp + -8 ], %g1
200ca5c: 80 a0 60 00 cmp %g1, 0
200ca60: 12 80 00 40 bne 200cb60 <_POSIX_Message_queue_Receive_support+0x120>
200ca64: 01 00 00 00 nop
case OBJECTS_LOCAL:
if ( (the_mq_fd->oflag & O_ACCMODE) == O_WRONLY ) {
200ca68: c2 02 20 14 ld [ %o0 + 0x14 ], %g1
200ca6c: 84 08 60 03 and %g1, 3, %g2
200ca70: 80 a0 a0 01 cmp %g2, 1
200ca74: 32 80 00 05 bne,a 200ca88 <_POSIX_Message_queue_Receive_support+0x48>
200ca78: d0 02 20 10 ld [ %o0 + 0x10 ], %o0
_Thread_Enable_dispatch();
200ca7c: 40 00 10 83 call 2010c88 <_Thread_Enable_dispatch>
200ca80: 01 00 00 00 nop
200ca84: 30 80 00 37 b,a 200cb60 <_POSIX_Message_queue_Receive_support+0x120>
rtems_set_errno_and_return_minus_one( EBADF );
}
the_mq = the_mq_fd->Queue;
if ( msg_len < the_mq->Message_queue.maximum_message_size ) {
200ca88: c4 02 20 68 ld [ %o0 + 0x68 ], %g2
200ca8c: 80 a6 80 02 cmp %i2, %g2
200ca90: 1a 80 00 08 bcc 200cab0 <_POSIX_Message_queue_Receive_support+0x70>
200ca94: 84 10 3f ff mov -1, %g2
_Thread_Enable_dispatch();
200ca98: 40 00 10 7c call 2010c88 <_Thread_Enable_dispatch>
200ca9c: 01 00 00 00 nop
rtems_set_errno_and_return_minus_one( EMSGSIZE );
200caa0: 40 00 28 86 call 2016cb8 <__errno>
200caa4: 01 00 00 00 nop
200caa8: 10 80 00 31 b 200cb6c <_POSIX_Message_queue_Receive_support+0x12c>
200caac: 82 10 20 7a mov 0x7a, %g1 ! 7a <PROM_START+0x7a>
/*
* Now if something goes wrong, we return a "length" of -1
* to indicate an error.
*/
length_out = -1;
200cab0: c4 27 bf fc st %g2, [ %fp + -4 ]
/*
* A timed receive with a bad time will do a poll regardless.
*/
if ( wait )
200cab4: 80 a7 20 00 cmp %i4, 0
200cab8: 02 80 00 05 be 200cacc <_POSIX_Message_queue_Receive_support+0x8c>
200cabc: 98 10 20 00 clr %o4
do_wait = (the_mq_fd->oflag & O_NONBLOCK) ? false : true;
200cac0: 99 30 60 0e srl %g1, 0xe, %o4
200cac4: 98 1b 20 01 xor %o4, 1, %o4
200cac8: 98 0b 20 01 and %o4, 1, %o4
do_wait = wait;
/*
* Now perform the actual message receive
*/
_CORE_message_queue_Seize(
200cacc: 90 02 20 1c add %o0, 0x1c, %o0
200cad0: 92 10 00 18 mov %i0, %o1
200cad4: 94 10 00 19 mov %i1, %o2
200cad8: 96 07 bf fc add %fp, -4, %o3
200cadc: 98 0b 20 01 and %o4, 1, %o4
200cae0: 40 00 08 6d call 200ec94 <_CORE_message_queue_Seize>
200cae4: 9a 10 00 1d mov %i5, %o5
&length_out,
do_wait,
timeout
);
_Thread_Enable_dispatch();
200cae8: 40 00 10 68 call 2010c88 <_Thread_Enable_dispatch>
200caec: 01 00 00 00 nop
if (msg_prio) {
200caf0: 80 a6 e0 00 cmp %i3, 0
200caf4: 02 80 00 08 be 200cb14 <_POSIX_Message_queue_Receive_support+0xd4><== NEVER TAKEN
200caf8: 03 00 80 ab sethi %hi(0x202ac00), %g1
*msg_prio = _POSIX_Message_queue_Priority_from_core(
_Thread_Executing->Wait.count
200cafc: c2 00 61 bc ld [ %g1 + 0x1bc ], %g1 ! 202adbc <_Per_CPU_Information+0xc>
RTEMS_INLINE_ROUTINE unsigned int _POSIX_Message_queue_Priority_from_core(
CORE_message_queue_Submit_types priority
)
{
/* absolute value without a library dependency */
return (unsigned int) ((priority >= 0) ? priority : -priority);
200cb00: c4 00 60 24 ld [ %g1 + 0x24 ], %g2
200cb04: 83 38 a0 1f sra %g2, 0x1f, %g1
200cb08: 84 18 40 02 xor %g1, %g2, %g2
200cb0c: 82 20 80 01 sub %g2, %g1, %g1
timeout
);
_Thread_Enable_dispatch();
if (msg_prio) {
*msg_prio = _POSIX_Message_queue_Priority_from_core(
200cb10: c2 26 c0 00 st %g1, [ %i3 ]
_Thread_Executing->Wait.count
);
}
if ( !_Thread_Executing->Wait.return_code )
200cb14: 3b 00 80 ab sethi %hi(0x202ac00), %i5
200cb18: ba 17 61 b0 or %i5, 0x1b0, %i5 ! 202adb0 <_Per_CPU_Information>
200cb1c: c2 07 60 0c ld [ %i5 + 0xc ], %g1
200cb20: c2 00 60 34 ld [ %g1 + 0x34 ], %g1
200cb24: 80 a0 60 00 cmp %g1, 0
200cb28: 12 80 00 05 bne 200cb3c <_POSIX_Message_queue_Receive_support+0xfc>
200cb2c: 01 00 00 00 nop
return length_out;
200cb30: f0 07 bf fc ld [ %fp + -4 ], %i0
200cb34: 81 c7 e0 08 ret
200cb38: 81 e8 00 00 restore
rtems_set_errno_and_return_minus_one(
200cb3c: 40 00 28 5f call 2016cb8 <__errno>
200cb40: b0 10 3f ff mov -1, %i0
200cb44: c2 07 60 0c ld [ %i5 + 0xc ], %g1
200cb48: b8 10 00 08 mov %o0, %i4
200cb4c: 40 00 00 96 call 200cda4 <_POSIX_Message_queue_Translate_core_message_queue_return_code>
200cb50: d0 00 60 34 ld [ %g1 + 0x34 ], %o0
200cb54: d0 27 00 00 st %o0, [ %i4 ]
200cb58: 81 c7 e0 08 ret
200cb5c: 81 e8 00 00 restore
#endif
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EBADF );
200cb60: 40 00 28 56 call 2016cb8 <__errno>
200cb64: 01 00 00 00 nop
200cb68: 82 10 20 09 mov 9, %g1 ! 9 <PROM_START+0x9>
200cb6c: c2 22 00 00 st %g1, [ %o0 ]
200cb70: b0 10 3f ff mov -1, %i0
}
200cb74: 81 c7 e0 08 ret
200cb78: 81 e8 00 00 restore
0200ee18 <_POSIX_Semaphore_Create_support>:
size_t name_len,
int pshared,
unsigned int value,
POSIX_Semaphore_Control **the_sem
)
{
200ee18: 9d e3 bf a0 save %sp, -96, %sp
POSIX_Semaphore_Control *the_semaphore;
CORE_semaphore_Attributes *the_sem_attr;
char *name;
/* Sharing semaphores among processes is not currently supported */
if (pshared != 0)
200ee1c: 80 a6 a0 00 cmp %i2, 0
200ee20: 22 80 00 06 be,a 200ee38 <_POSIX_Semaphore_Create_support+0x20>
200ee24: 03 00 80 89 sethi %hi(0x2022400), %g1
rtems_set_errno_and_return_minus_one( ENOSYS );
200ee28: 40 00 0a d2 call 2011970 <__errno>
200ee2c: 01 00 00 00 nop
200ee30: 10 80 00 11 b 200ee74 <_POSIX_Semaphore_Create_support+0x5c>
200ee34: 82 10 20 58 mov 0x58, %g1 ! 58 <PROM_START+0x58>
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
_Thread_Dispatch_disable_level++;
200ee38: c4 00 61 f0 ld [ %g1 + 0x1f0 ], %g2
200ee3c: 84 00 a0 01 inc %g2
200ee40: c4 20 61 f0 st %g2, [ %g1 + 0x1f0 ]
return _Thread_Dispatch_disable_level;
200ee44: c2 00 61 f0 ld [ %g1 + 0x1f0 ], %g1
* _POSIX_Semaphore_Allocate
*/
RTEMS_INLINE_ROUTINE POSIX_Semaphore_Control *_POSIX_Semaphore_Allocate( void )
{
return (POSIX_Semaphore_Control *)
200ee48: 21 00 80 8a sethi %hi(0x2022800), %l0
200ee4c: 7f ff ee e7 call 200a9e8 <_Objects_Allocate>
200ee50: 90 14 20 e0 or %l0, 0xe0, %o0 ! 20228e0 <_POSIX_Semaphore_Information>
_Thread_Disable_dispatch();
the_semaphore = _POSIX_Semaphore_Allocate();
if ( !the_semaphore ) {
200ee54: ba 92 20 00 orcc %o0, 0, %i5
200ee58: 12 80 00 0a bne 200ee80 <_POSIX_Semaphore_Create_support+0x68>
200ee5c: 80 a6 20 00 cmp %i0, 0
_Thread_Enable_dispatch();
200ee60: 7f ff f4 05 call 200be74 <_Thread_Enable_dispatch>
200ee64: 01 00 00 00 nop
rtems_set_errno_and_return_minus_one( ENOSPC );
200ee68: 40 00 0a c2 call 2011970 <__errno>
200ee6c: 01 00 00 00 nop
200ee70: 82 10 20 1c mov 0x1c, %g1 ! 1c <PROM_START+0x1c>
200ee74: c2 22 00 00 st %g1, [ %o0 ]
200ee78: 81 c7 e0 08 ret
200ee7c: 91 e8 3f ff restore %g0, -1, %o0
/*
* Make a copy of the user's string for name just in case it was
* dynamically constructed.
*/
if ( name_arg != NULL ) {
200ee80: 02 80 00 10 be 200eec0 <_POSIX_Semaphore_Create_support+0xa8>
200ee84: 90 10 00 18 mov %i0, %o0
name = _Workspace_String_duplicate( name_arg, name_len );
200ee88: 40 00 04 78 call 2010068 <_Workspace_String_duplicate>
200ee8c: 92 10 00 19 mov %i1, %o1
if ( !name ) {
200ee90: b4 92 20 00 orcc %o0, 0, %i2
200ee94: 12 80 00 0d bne 200eec8 <_POSIX_Semaphore_Create_support+0xb0><== ALWAYS TAKEN
200ee98: 80 a6 a0 00 cmp %i2, 0
RTEMS_INLINE_ROUTINE void _POSIX_Semaphore_Free (
POSIX_Semaphore_Control *the_semaphore
)
{
_Objects_Free( &_POSIX_Semaphore_Information, &the_semaphore->Object );
200ee9c: 90 14 20 e0 or %l0, 0xe0, %o0 <== NOT EXECUTED
200eea0: 7f ff ef a9 call 200ad44 <_Objects_Free> <== NOT EXECUTED
200eea4: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
_POSIX_Semaphore_Free( the_semaphore );
_Thread_Enable_dispatch();
200eea8: 7f ff f3 f3 call 200be74 <_Thread_Enable_dispatch> <== NOT EXECUTED
200eeac: 01 00 00 00 nop <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOMEM );
200eeb0: 40 00 0a b0 call 2011970 <__errno> <== NOT EXECUTED
200eeb4: 01 00 00 00 nop <== NOT EXECUTED
200eeb8: 10 bf ff ef b 200ee74 <_POSIX_Semaphore_Create_support+0x5c><== NOT EXECUTED
200eebc: 82 10 20 0c mov 0xc, %g1 ! c <PROM_START+0xc> <== NOT EXECUTED
}
} else {
name = NULL;
200eec0: b4 10 20 00 clr %i2
}
the_semaphore->process_shared = pshared;
if ( name ) {
200eec4: 80 a6 a0 00 cmp %i2, 0
200eec8: 02 80 00 08 be 200eee8 <_POSIX_Semaphore_Create_support+0xd0>
200eecc: c0 27 60 10 clr [ %i5 + 0x10 ]
the_semaphore->named = true;
200eed0: 82 10 20 01 mov 1, %g1
200eed4: c2 2f 60 14 stb %g1, [ %i5 + 0x14 ]
the_semaphore->open_count = 1;
200eed8: 82 10 20 01 mov 1, %g1
200eedc: c2 27 60 18 st %g1, [ %i5 + 0x18 ]
the_semaphore->linked = true;
200eee0: 10 80 00 05 b 200eef4 <_POSIX_Semaphore_Create_support+0xdc>
200eee4: c2 2f 60 15 stb %g1, [ %i5 + 0x15 ]
} else {
the_semaphore->named = false;
200eee8: c0 2f 60 14 clrb [ %i5 + 0x14 ]
the_semaphore->open_count = 0;
200eeec: c0 27 60 18 clr [ %i5 + 0x18 ]
the_semaphore->linked = false;
200eef0: c0 2f 60 15 clrb [ %i5 + 0x15 ]
the_sem_attr->discipline = CORE_SEMAPHORE_DISCIPLINES_FIFO;
/*
* This effectively disables limit checking.
*/
the_sem_attr->maximum_count = 0xFFFFFFFF;
200eef4: 82 10 3f ff mov -1, %g1
_CORE_semaphore_Initialize( &the_semaphore->Semaphore, the_sem_attr, value );
200eef8: 90 07 60 1c add %i5, 0x1c, %o0
the_sem_attr->discipline = CORE_SEMAPHORE_DISCIPLINES_FIFO;
/*
* This effectively disables limit checking.
*/
the_sem_attr->maximum_count = 0xFFFFFFFF;
200eefc: c2 27 60 5c st %g1, [ %i5 + 0x5c ]
_CORE_semaphore_Initialize( &the_semaphore->Semaphore, the_sem_attr, value );
200ef00: 92 07 60 5c add %i5, 0x5c, %o1
200ef04: 94 10 00 1b mov %i3, %o2
200ef08: 7f ff ed 2c call 200a3b8 <_CORE_semaphore_Initialize>
200ef0c: c0 27 60 60 clr [ %i5 + 0x60 ]
Objects_Information *information,
Objects_Control *the_object,
const char *name
)
{
_Objects_Set_local_object(
200ef10: c2 17 60 0a lduh [ %i5 + 0xa ], %g1
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
200ef14: 05 00 80 8a sethi %hi(0x2022800), %g2
200ef18: c4 00 a0 fc ld [ %g2 + 0xfc ], %g2 ! 20228fc <_POSIX_Semaphore_Information+0x1c>
200ef1c: 83 28 60 02 sll %g1, 2, %g1
200ef20: fa 20 80 01 st %i5, [ %g2 + %g1 ]
the_object
);
#if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES)
/* ASSERT: information->is_string */
the_object->name.name_p = name;
200ef24: f4 27 60 0c st %i2, [ %i5 + 0xc ]
&_POSIX_Semaphore_Information,
&the_semaphore->Object,
name
);
*the_sem = the_semaphore;
200ef28: fa 27 00 00 st %i5, [ %i4 ]
_Thread_Enable_dispatch();
200ef2c: 7f ff f3 d2 call 200be74 <_Thread_Enable_dispatch>
200ef30: b0 10 20 00 clr %i0
return 0;
}
200ef34: 81 c7 e0 08 ret
200ef38: 81 e8 00 00 restore
0200c8d0 <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch>:
Thread_Control *the_thread
)
{
POSIX_API_Control *thread_support;
thread_support = the_thread->API_Extensions[ THREAD_API_POSIX ];
200c8d0: c2 02 21 5c ld [ %o0 + 0x15c ], %g1
if ( thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE &&
200c8d4: c4 00 60 d8 ld [ %g1 + 0xd8 ], %g2
200c8d8: 80 a0 a0 00 cmp %g2, 0
200c8dc: 12 80 00 13 bne 200c928 <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch+0x58><== NEVER TAKEN
200c8e0: 01 00 00 00 nop
200c8e4: c4 00 60 dc ld [ %g1 + 0xdc ], %g2
200c8e8: 80 a0 a0 01 cmp %g2, 1
200c8ec: 12 80 00 0f bne 200c928 <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch+0x58>
200c8f0: 01 00 00 00 nop
thread_support->cancelability_type == PTHREAD_CANCEL_ASYNCHRONOUS &&
200c8f4: c2 00 60 e0 ld [ %g1 + 0xe0 ], %g1
200c8f8: 80 a0 60 00 cmp %g1, 0
200c8fc: 02 80 00 0b be 200c928 <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch+0x58>
200c900: 01 00 00 00 nop
*
* This routine decrements the thread dispatch level.
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_decrement_disable_level(void)
{
_Thread_Dispatch_disable_level--;
200c904: 03 00 80 77 sethi %hi(0x201dc00), %g1
200c908: c4 00 63 50 ld [ %g1 + 0x350 ], %g2 ! 201df50 <_Thread_Dispatch_disable_level>
thread_support->cancelation_requested ) {
_Thread_Unnest_dispatch();
_POSIX_Thread_Exit( the_thread, PTHREAD_CANCELED );
200c90c: 92 10 3f ff mov -1, %o1
200c910: 84 00 bf ff add %g2, -1, %g2
200c914: c4 20 63 50 st %g2, [ %g1 + 0x350 ]
return _Thread_Dispatch_disable_level;
200c918: c2 00 63 50 ld [ %g1 + 0x350 ], %g1
200c91c: 82 13 c0 00 mov %o7, %g1
200c920: 40 00 01 b5 call 200cff4 <_POSIX_Thread_Exit>
200c924: 9e 10 40 00 mov %g1, %o7
} else
_Thread_Enable_dispatch();
200c928: 82 13 c0 00 mov %o7, %g1
200c92c: 7f ff f6 51 call 200a270 <_Thread_Enable_dispatch>
200c930: 9e 10 40 00 mov %g1, %o7
0200dc78 <_POSIX_Thread_Translate_sched_param>:
int policy,
struct sched_param *param,
Thread_CPU_budget_algorithms *budget_algorithm,
Thread_CPU_budget_algorithm_callout *budget_callout
)
{
200dc78: 9d e3 bf a0 save %sp, -96, %sp
if ( !_POSIX_Priority_Is_valid( param->sched_priority ) )
200dc7c: 7f ff ff f4 call 200dc4c <_POSIX_Priority_Is_valid>
200dc80: d0 06 40 00 ld [ %i1 ], %o0
200dc84: 80 8a 20 ff btst 0xff, %o0
200dc88: 32 80 00 04 bne,a 200dc98 <_POSIX_Thread_Translate_sched_param+0x20><== ALWAYS TAKEN
200dc8c: c0 26 80 00 clr [ %i2 ]
return EINVAL;
200dc90: 81 c7 e0 08 ret
200dc94: 91 e8 20 16 restore %g0, 0x16, %o0
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE;
*budget_callout = NULL;
if ( policy == SCHED_OTHER ) {
200dc98: 80 a6 20 00 cmp %i0, 0
200dc9c: 12 80 00 06 bne 200dcb4 <_POSIX_Thread_Translate_sched_param+0x3c>
200dca0: c0 26 c0 00 clr [ %i3 ]
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE;
200dca4: 82 10 20 01 mov 1, %g1
200dca8: c2 26 80 00 st %g1, [ %i2 ]
return 0;
200dcac: 81 c7 e0 08 ret
200dcb0: 81 e8 00 00 restore
}
if ( policy == SCHED_FIFO ) {
200dcb4: 80 a6 20 01 cmp %i0, 1
200dcb8: 02 80 00 29 be 200dd5c <_POSIX_Thread_Translate_sched_param+0xe4>
200dcbc: 80 a6 20 02 cmp %i0, 2
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE;
return 0;
}
if ( policy == SCHED_RR ) {
200dcc0: 12 80 00 04 bne 200dcd0 <_POSIX_Thread_Translate_sched_param+0x58>
200dcc4: 80 a6 20 04 cmp %i0, 4
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_EXHAUST_TIMESLICE;
200dcc8: 10 80 00 25 b 200dd5c <_POSIX_Thread_Translate_sched_param+0xe4>
200dccc: f0 26 80 00 st %i0, [ %i2 ]
return 0;
}
if ( policy == SCHED_SPORADIC ) {
200dcd0: 12 bf ff f0 bne 200dc90 <_POSIX_Thread_Translate_sched_param+0x18>
200dcd4: 01 00 00 00 nop
if ( (param->sched_ss_repl_period.tv_sec == 0) &&
200dcd8: c2 06 60 08 ld [ %i1 + 8 ], %g1
200dcdc: 80 a0 60 00 cmp %g1, 0
200dce0: 32 80 00 07 bne,a 200dcfc <_POSIX_Thread_Translate_sched_param+0x84>
200dce4: c2 06 60 10 ld [ %i1 + 0x10 ], %g1
200dce8: c2 06 60 0c ld [ %i1 + 0xc ], %g1
200dcec: 80 a0 60 00 cmp %g1, 0
200dcf0: 02 bf ff e8 be 200dc90 <_POSIX_Thread_Translate_sched_param+0x18>
200dcf4: 01 00 00 00 nop
(param->sched_ss_repl_period.tv_nsec == 0) )
return EINVAL;
if ( (param->sched_ss_init_budget.tv_sec == 0) &&
200dcf8: c2 06 60 10 ld [ %i1 + 0x10 ], %g1
200dcfc: 80 a0 60 00 cmp %g1, 0
200dd00: 12 80 00 06 bne 200dd18 <_POSIX_Thread_Translate_sched_param+0xa0>
200dd04: 01 00 00 00 nop
200dd08: c2 06 60 14 ld [ %i1 + 0x14 ], %g1
200dd0c: 80 a0 60 00 cmp %g1, 0
200dd10: 02 bf ff e0 be 200dc90 <_POSIX_Thread_Translate_sched_param+0x18>
200dd14: 01 00 00 00 nop
(param->sched_ss_init_budget.tv_nsec == 0) )
return EINVAL;
if ( _Timespec_To_ticks( ¶m->sched_ss_repl_period ) <
200dd18: 7f ff f7 66 call 200bab0 <_Timespec_To_ticks>
200dd1c: 90 06 60 08 add %i1, 8, %o0
200dd20: ba 10 00 08 mov %o0, %i5
_Timespec_To_ticks( ¶m->sched_ss_init_budget ) )
200dd24: 7f ff f7 63 call 200bab0 <_Timespec_To_ticks>
200dd28: 90 06 60 10 add %i1, 0x10, %o0
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 ) <
200dd2c: 80 a7 40 08 cmp %i5, %o0
200dd30: 0a bf ff d8 bcs 200dc90 <_POSIX_Thread_Translate_sched_param+0x18>
200dd34: 01 00 00 00 nop
_Timespec_To_ticks( ¶m->sched_ss_init_budget ) )
return EINVAL;
if ( !_POSIX_Priority_Is_valid( param->sched_ss_low_priority ) )
200dd38: 7f ff ff c5 call 200dc4c <_POSIX_Priority_Is_valid>
200dd3c: d0 06 60 04 ld [ %i1 + 4 ], %o0
200dd40: 80 8a 20 ff btst 0xff, %o0
200dd44: 02 bf ff d3 be 200dc90 <_POSIX_Thread_Translate_sched_param+0x18>
200dd48: 82 10 20 03 mov 3, %g1
return EINVAL;
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_CALLOUT;
200dd4c: c2 26 80 00 st %g1, [ %i2 ]
*budget_callout = _POSIX_Threads_Sporadic_budget_callout;
200dd50: 03 00 80 1f sethi %hi(0x2007c00), %g1
200dd54: 82 10 61 f0 or %g1, 0x1f0, %g1 ! 2007df0 <_POSIX_Threads_Sporadic_budget_callout>
200dd58: c2 26 c0 00 st %g1, [ %i3 ]
return 0;
}
return EINVAL;
}
200dd5c: 81 c7 e0 08 ret
200dd60: 91 e8 20 00 restore %g0, 0, %o0
0200cc28 <_POSIX_Threads_Delete_extension>:
*/
static void _POSIX_Threads_Delete_extension(
Thread_Control *executing __attribute__((unused)),
Thread_Control *deleted
)
{
200cc28: 9d e3 bf a0 save %sp, -96, %sp
Thread_Control *the_thread;
POSIX_API_Control *api;
void **value_ptr;
api = deleted->API_Extensions[ THREAD_API_POSIX ];
200cc2c: f0 06 61 5c ld [ %i1 + 0x15c ], %i0
/*
* Run the POSIX cancellation handlers
*/
_POSIX_Threads_cancel_run( deleted );
200cc30: 40 00 09 09 call 200f054 <_POSIX_Threads_cancel_run>
200cc34: 90 10 00 19 mov %i1, %o0
/*
* Run all the key destructors
*/
_POSIX_Keys_Run_destructors( deleted );
200cc38: 90 10 00 19 mov %i1, %o0
200cc3c: 40 00 09 20 call 200f0bc <_POSIX_Keys_Run_destructors>
200cc40: ba 06 20 44 add %i0, 0x44, %i5
/*
* 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 )) )
200cc44: 10 80 00 03 b 200cc50 <_POSIX_Threads_Delete_extension+0x28>
200cc48: f8 06 60 28 ld [ %i1 + 0x28 ], %i4
*(void **)the_thread->Wait.return_argument = value_ptr;
200cc4c: f8 20 40 00 st %i4, [ %g1 ] <== 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 )) )
200cc50: 7f ff f6 3b call 200a53c <_Thread_queue_Dequeue>
200cc54: 90 10 00 1d mov %i5, %o0
200cc58: 80 a2 20 00 cmp %o0, 0
200cc5c: 32 bf ff fc bne,a 200cc4c <_POSIX_Threads_Delete_extension+0x24><== NEVER TAKEN
200cc60: c2 02 20 28 ld [ %o0 + 0x28 ], %g1 <== NOT EXECUTED
*(void **)the_thread->Wait.return_argument = value_ptr;
if ( api->schedpolicy == SCHED_SPORADIC )
200cc64: c2 06 20 84 ld [ %i0 + 0x84 ], %g1
200cc68: 80 a0 60 04 cmp %g1, 4
200cc6c: 32 80 00 05 bne,a 200cc80 <_POSIX_Threads_Delete_extension+0x58>
200cc70: c0 26 61 5c clr [ %i1 + 0x15c ]
(void) _Watchdog_Remove( &api->Sporadic_timer );
200cc74: 7f ff f8 f0 call 200b034 <_Watchdog_Remove>
200cc78: 90 06 20 a8 add %i0, 0xa8, %o0
deleted->API_Extensions[ THREAD_API_POSIX ] = NULL;
200cc7c: c0 26 61 5c clr [ %i1 + 0x15c ]
_Workspace_Free( api );
200cc80: 7f ff f9 66 call 200b218 <_Workspace_Free>
200cc84: 81 e8 00 00 restore
02007b4c <_POSIX_Threads_Initialize_user_threads_body>:
*
* Output parameters: NONE
*/
void _POSIX_Threads_Initialize_user_threads_body(void)
{
2007b4c: 9d e3 bf 58 save %sp, -168, %sp
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;
2007b50: 03 00 80 86 sethi %hi(0x2021800), %g1
2007b54: 82 10 62 50 or %g1, 0x250, %g1 ! 2021a50 <Configuration_POSIX_API>
maximum = Configuration_POSIX_API.number_of_initialization_threads;
2007b58: f6 00 60 30 ld [ %g1 + 0x30 ], %i3
if ( !user_threads || maximum == 0 )
2007b5c: 80 a6 e0 00 cmp %i3, 0
2007b60: 02 80 00 1d be 2007bd4 <_POSIX_Threads_Initialize_user_threads_body+0x88><== NEVER TAKEN
2007b64: fa 00 60 34 ld [ %g1 + 0x34 ], %i5
2007b68: 80 a7 60 00 cmp %i5, 0
2007b6c: 02 80 00 1a be 2007bd4 <_POSIX_Threads_Initialize_user_threads_body+0x88><== NEVER TAKEN
2007b70: b8 10 20 00 clr %i4
for ( index=0 ; index < maximum ; index++ ) {
/*
* There is no way for these calls to fail in this situation.
*/
(void) pthread_attr_init( &attr );
2007b74: 40 00 18 7c call 200dd64 <pthread_attr_init>
2007b78: 90 07 bf c0 add %fp, -64, %o0
(void) pthread_attr_setinheritsched( &attr, PTHREAD_EXPLICIT_SCHED );
2007b7c: 92 10 20 02 mov 2, %o1
2007b80: 40 00 18 85 call 200dd94 <pthread_attr_setinheritsched>
2007b84: 90 07 bf c0 add %fp, -64, %o0
(void) pthread_attr_setstacksize(&attr, user_threads[ index ].stack_size);
2007b88: d2 07 60 04 ld [ %i5 + 4 ], %o1
2007b8c: 40 00 18 91 call 200ddd0 <pthread_attr_setstacksize>
2007b90: 90 07 bf c0 add %fp, -64, %o0
status = pthread_create(
2007b94: d4 07 40 00 ld [ %i5 ], %o2
2007b98: 90 07 bf bc add %fp, -68, %o0
2007b9c: 92 07 bf c0 add %fp, -64, %o1
2007ba0: 96 10 20 00 clr %o3
2007ba4: 7f ff ff 16 call 20077fc <pthread_create>
2007ba8: ba 07 60 08 add %i5, 8, %i5
&thread_id,
&attr,
user_threads[ index ].thread_entry,
NULL
);
if ( status )
2007bac: 80 a2 20 00 cmp %o0, 0
2007bb0: 02 80 00 05 be 2007bc4 <_POSIX_Threads_Initialize_user_threads_body+0x78>
2007bb4: 94 10 00 08 mov %o0, %o2
_Internal_error_Occurred( INTERNAL_ERROR_POSIX_API, true, status );
2007bb8: 90 10 20 02 mov 2, %o0
2007bbc: 40 00 07 f9 call 2009ba0 <_Internal_error_Occurred>
2007bc0: 92 10 20 01 mov 1, %o1
*
* Setting the attributes explicitly is critical, since we don't want
* to inherit the idle tasks attributes.
*/
for ( index=0 ; index < maximum ; index++ ) {
2007bc4: b8 07 20 01 inc %i4
2007bc8: 80 a7 00 1b cmp %i4, %i3
2007bcc: 12 bf ff ea bne 2007b74 <_POSIX_Threads_Initialize_user_threads_body+0x28><== NEVER TAKEN
2007bd0: 01 00 00 00 nop
2007bd4: 81 c7 e0 08 ret
2007bd8: 81 e8 00 00 restore
0200cd7c <_POSIX_Threads_Sporadic_budget_TSR>:
*/
void _POSIX_Threads_Sporadic_budget_TSR(
Objects_Id id __attribute__((unused)),
void *argument
)
{
200cd7c: 9d e3 bf a0 save %sp, -96, %sp
Thread_Control *the_thread;
POSIX_API_Control *api;
the_thread = argument;
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
200cd80: fa 06 61 5c ld [ %i1 + 0x15c ], %i5
/* ticks is guaranteed to be at least one */
ticks = _Timespec_To_ticks( &api->schedparam.sched_ss_init_budget );
200cd84: 40 00 04 30 call 200de44 <_Timespec_To_ticks>
200cd88: 90 07 60 98 add %i5, 0x98, %o0
RTEMS_INLINE_ROUTINE Priority_Control _POSIX_Priority_To_core(
int priority
)
{
return (Priority_Control) (POSIX_SCHEDULER_MAXIMUM_PRIORITY - priority + 1);
200cd8c: 03 00 80 73 sethi %hi(0x201cc00), %g1
200cd90: d2 08 61 38 ldub [ %g1 + 0x138 ], %o1 ! 201cd38 <rtems_maximum_priority>
200cd94: c2 07 60 88 ld [ %i5 + 0x88 ], %g1
the_thread->cpu_time_budget = ticks;
200cd98: d0 26 60 74 st %o0, [ %i1 + 0x74 ]
200cd9c: 92 22 40 01 sub %o1, %g1, %o1
*/
#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 ) {
200cda0: c2 06 60 1c ld [ %i1 + 0x1c ], %g1
200cda4: 80 a0 60 00 cmp %g1, 0
200cda8: 12 80 00 09 bne 200cdcc <_POSIX_Threads_Sporadic_budget_TSR+0x50><== NEVER TAKEN
200cdac: d2 26 60 18 st %o1, [ %i1 + 0x18 ]
/*
* If this would make them less important, then do not change it.
*/
if ( the_thread->current_priority > new_priority ) {
200cdb0: c2 06 60 14 ld [ %i1 + 0x14 ], %g1
200cdb4: 80 a0 40 09 cmp %g1, %o1
200cdb8: 08 80 00 06 bleu 200cdd0 <_POSIX_Threads_Sporadic_budget_TSR+0x54>
200cdbc: 90 07 60 90 add %i5, 0x90, %o0
_Thread_Change_priority( the_thread, new_priority, true );
200cdc0: 90 10 00 19 mov %i1, %o0
200cdc4: 7f ff f3 d4 call 2009d14 <_Thread_Change_priority>
200cdc8: 94 10 20 01 mov 1, %o2
#endif
}
}
/* ticks is guaranteed to be at least one */
ticks = _Timespec_To_ticks( &api->schedparam.sched_ss_repl_period );
200cdcc: 90 07 60 90 add %i5, 0x90, %o0
200cdd0: 40 00 04 1d call 200de44 <_Timespec_To_ticks>
200cdd4: 31 00 80 76 sethi %hi(0x201d800), %i0
)
{
the_watchdog->initial = units;
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
200cdd8: b0 16 23 88 or %i0, 0x388, %i0 ! 201db88 <_Watchdog_Ticks_chain>
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
200cddc: d0 27 60 b4 st %o0, [ %i5 + 0xb4 ]
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
200cde0: 7f ff f8 3d call 200aed4 <_Watchdog_Insert>
200cde4: 93 ef 60 a8 restore %i5, 0xa8, %o1
0200cde8 <_POSIX_Threads_Sporadic_budget_callout>:
)
{
POSIX_API_Control *api;
uint32_t new_priority;
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
200cde8: c4 02 21 5c ld [ %o0 + 0x15c ], %g2
/*
* 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 */
200cdec: 86 10 3f ff mov -1, %g3
200cdf0: c4 00 a0 8c ld [ %g2 + 0x8c ], %g2
200cdf4: c6 22 20 74 st %g3, [ %o0 + 0x74 ]
200cdf8: 07 00 80 73 sethi %hi(0x201cc00), %g3
200cdfc: d2 08 e1 38 ldub [ %g3 + 0x138 ], %o1 ! 201cd38 <rtems_maximum_priority>
200ce00: 92 22 40 02 sub %o1, %g2, %o1
*/
#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 ) {
200ce04: c4 02 20 1c ld [ %o0 + 0x1c ], %g2
200ce08: 80 a0 a0 00 cmp %g2, 0
200ce0c: 12 80 00 09 bne 200ce30 <_POSIX_Threads_Sporadic_budget_callout+0x48><== NEVER TAKEN
200ce10: d2 22 20 18 st %o1, [ %o0 + 0x18 ]
/*
* 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 ) {
200ce14: c2 02 20 14 ld [ %o0 + 0x14 ], %g1
200ce18: 80 a0 40 09 cmp %g1, %o1
200ce1c: 1a 80 00 05 bcc 200ce30 <_POSIX_Threads_Sporadic_budget_callout+0x48><== NEVER TAKEN
200ce20: 94 10 20 01 mov 1, %o2
_Thread_Change_priority( the_thread, new_priority, true );
200ce24: 82 13 c0 00 mov %o7, %g1
200ce28: 7f ff f3 bb call 2009d14 <_Thread_Change_priority>
200ce2c: 9e 10 40 00 mov %g1, %o7
200ce30: 81 c3 e0 08 retl <== NOT EXECUTED
020075f0 <_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)
{
20075f0: 9d e3 bf 98 save %sp, -104, %sp
bool activated;
ptimer = (POSIX_Timer_Control *)data;
/* Increment the number of expirations. */
ptimer->overrun = ptimer->overrun + 1;
20075f4: c2 06 60 68 ld [ %i1 + 0x68 ], %g1
20075f8: 82 00 60 01 inc %g1
20075fc: c2 26 60 68 st %g1, [ %i1 + 0x68 ]
/* The timer must be reprogrammed */
if ( ( ptimer->timer_data.it_interval.tv_sec != 0 ) ||
2007600: c2 06 60 54 ld [ %i1 + 0x54 ], %g1
2007604: 80 a0 60 00 cmp %g1, 0
2007608: 32 80 00 07 bne,a 2007624 <_POSIX_Timer_TSR+0x34>
200760c: d2 06 60 64 ld [ %i1 + 0x64 ], %o1
2007610: c2 06 60 58 ld [ %i1 + 0x58 ], %g1
2007614: 80 a0 60 00 cmp %g1, 0
2007618: 02 80 00 1e be 2007690 <_POSIX_Timer_TSR+0xa0> <== NEVER TAKEN
200761c: 82 10 20 04 mov 4, %g1
( ptimer->timer_data.it_interval.tv_nsec != 0 ) ) {
activated = _POSIX_Timer_Insert_helper(
2007620: d2 06 60 64 ld [ %i1 + 0x64 ], %o1
2007624: d4 06 60 08 ld [ %i1 + 8 ], %o2
2007628: 90 06 60 10 add %i1, 0x10, %o0
200762c: 17 00 80 1d sethi %hi(0x2007400), %o3
2007630: 98 10 00 19 mov %i1, %o4
2007634: 40 00 18 12 call 200d67c <_POSIX_Timer_Insert_helper>
2007638: 96 12 e1 f0 or %o3, 0x1f0, %o3
ptimer->ticks,
ptimer->Object.id,
_POSIX_Timer_TSR,
ptimer
);
if ( !activated )
200763c: 80 8a 20 ff btst 0xff, %o0
2007640: 02 80 00 19 be 20076a4 <_POSIX_Timer_TSR+0xb4> <== NEVER TAKEN
2007644: 01 00 00 00 nop
struct timespec *tod_as_timespec
)
{
Timestamp_Control tod_as_timestamp;
_TOD_Get_as_timestamp( &tod_as_timestamp );
2007648: 40 00 05 da call 2008db0 <_TOD_Get_as_timestamp>
200764c: 90 07 bf f8 add %fp, -8, %o0
_Timestamp_To_timespec( &tod_as_timestamp, tod_as_timespec );
2007650: f8 1f bf f8 ldd [ %fp + -8 ], %i4
static inline void _Timestamp64_implementation_To_timespec(
const Timestamp64_Control *_timestamp,
struct timespec *_timespec
)
{
_timespec->tv_sec = (time_t) (*_timestamp / 1000000000L);
2007654: 94 10 20 00 clr %o2
2007658: 90 10 00 1c mov %i4, %o0
200765c: 92 10 00 1d mov %i5, %o1
2007660: 17 0e e6 b2 sethi %hi(0x3b9ac800), %o3
2007664: 40 00 48 d0 call 20199a4 <__divdi3>
2007668: 96 12 e2 00 or %o3, 0x200, %o3 ! 3b9aca00 <RAM_END+0x395aca00>
_timespec->tv_nsec = (long) (*_timestamp % 1000000000L);
200766c: 90 10 00 1c mov %i4, %o0
static inline void _Timestamp64_implementation_To_timespec(
const Timestamp64_Control *_timestamp,
struct timespec *_timespec
)
{
_timespec->tv_sec = (time_t) (*_timestamp / 1000000000L);
2007670: d2 26 60 6c st %o1, [ %i1 + 0x6c ]
_timespec->tv_nsec = (long) (*_timestamp % 1000000000L);
2007674: 94 10 20 00 clr %o2
2007678: 92 10 00 1d mov %i5, %o1
200767c: 17 0e e6 b2 sethi %hi(0x3b9ac800), %o3
2007680: 40 00 49 b4 call 2019d50 <__moddi3>
2007684: 96 12 e2 00 or %o3, 0x200, %o3 ! 3b9aca00 <RAM_END+0x395aca00>
/* Store the time when the timer was started again */
_TOD_Get( &ptimer->time );
/* The state really did not change but just to be safe */
ptimer->state = POSIX_TIMER_STATE_CREATE_RUN;
2007688: 82 10 20 03 mov 3, %g1
200768c: d2 26 60 70 st %o1, [ %i1 + 0x70 ]
/*
* 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 ) ) {
2007690: d0 06 60 38 ld [ %i1 + 0x38 ], %o0
2007694: d2 06 60 44 ld [ %i1 + 0x44 ], %o1
2007698: 40 00 16 ec call 200d248 <pthread_kill>
200769c: c2 2e 60 3c stb %g1, [ %i1 + 0x3c ]
}
/* After the signal handler returns, the count of expirations of the
* timer must be set to 0.
*/
ptimer->overrun = 0;
20076a0: c0 26 60 68 clr [ %i1 + 0x68 ]
20076a4: 81 c7 e0 08 ret
20076a8: 81 e8 00 00 restore
0200f178 <_POSIX_signals_Check_signal>:
bool _POSIX_signals_Check_signal(
POSIX_API_Control *api,
int signo,
bool is_global
)
{
200f178: 9d e3 bf 68 save %sp, -152, %sp
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,
200f17c: 98 10 20 01 mov 1, %o4
200f180: 90 10 00 18 mov %i0, %o0
200f184: 92 10 00 19 mov %i1, %o1
200f188: 94 07 bf cc add %fp, -52, %o2
200f18c: 40 00 00 2e call 200f244 <_POSIX_signals_Clear_signals>
200f190: 96 10 00 1a mov %i2, %o3
200f194: 80 8a 20 ff btst 0xff, %o0
200f198: 02 80 00 28 be 200f238 <_POSIX_signals_Check_signal+0xc0>
200f19c: 82 10 20 00 clr %g1
#endif
/*
* Just to prevent sending a signal which is currently being ignored.
*/
if ( _POSIX_signals_Vectors[ signo ].sa_handler == SIG_IGN )
200f1a0: 85 2e 60 02 sll %i1, 2, %g2
200f1a4: 35 00 80 78 sethi %hi(0x201e000), %i2
200f1a8: b7 2e 60 04 sll %i1, 4, %i3
200f1ac: b4 16 a0 70 or %i2, 0x70, %i2
200f1b0: b6 26 c0 02 sub %i3, %g2, %i3
200f1b4: 84 06 80 1b add %i2, %i3, %g2
200f1b8: fa 00 a0 08 ld [ %g2 + 8 ], %i5
200f1bc: 80 a7 60 01 cmp %i5, 1
200f1c0: 02 80 00 1e be 200f238 <_POSIX_signals_Check_signal+0xc0> <== NEVER TAKEN
200f1c4: 90 07 bf d8 add %fp, -40, %o0
return false;
/*
* Block the signals requested in sa_mask
*/
saved_signals_blocked = api->signals_blocked;
200f1c8: f8 06 20 d0 ld [ %i0 + 0xd0 ], %i4
api->signals_blocked |= _POSIX_signals_Vectors[ signo ].sa_mask;
200f1cc: c2 00 a0 04 ld [ %g2 + 4 ], %g1
200f1d0: 82 10 40 1c or %g1, %i4, %g1
200f1d4: c2 26 20 d0 st %g1, [ %i0 + 0xd0 ]
/*
* 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,
200f1d8: 03 00 80 78 sethi %hi(0x201e000), %g1
200f1dc: d2 00 60 1c ld [ %g1 + 0x1c ], %o1 ! 201e01c <_Per_CPU_Information+0xc>
200f1e0: 94 10 20 28 mov 0x28, %o2
200f1e4: 40 00 04 52 call 201032c <memcpy>
200f1e8: 92 02 60 20 add %o1, 0x20, %o1
sizeof( Thread_Wait_information ));
/*
* Here, the signal handler function executes
*/
switch ( _POSIX_signals_Vectors[ signo ].sa_flags ) {
200f1ec: c2 06 80 1b ld [ %i2 + %i3 ], %g1
200f1f0: 80 a0 60 02 cmp %g1, 2
200f1f4: 12 80 00 07 bne 200f210 <_POSIX_signals_Check_signal+0x98>
200f1f8: 90 10 00 19 mov %i1, %o0
case SA_SIGINFO:
(*_POSIX_signals_Vectors[ signo ].sa_sigaction)(
200f1fc: 92 07 bf cc add %fp, -52, %o1
200f200: 9f c7 40 00 call %i5
200f204: 94 10 20 00 clr %o2
signo,
&siginfo_struct,
NULL /* context is undefined per 1003.1b-1993, p. 66 */
);
break;
200f208: 10 80 00 05 b 200f21c <_POSIX_signals_Check_signal+0xa4>
200f20c: 03 00 80 78 sethi %hi(0x201e000), %g1
default:
(*_POSIX_signals_Vectors[ signo ].sa_handler)( signo );
200f210: 9f c7 40 00 call %i5
200f214: 01 00 00 00 nop
}
/*
* Restore the blocking information
*/
memcpy( &_Thread_Executing->Wait, &stored_thread_wait_information,
200f218: 03 00 80 78 sethi %hi(0x201e000), %g1
200f21c: d0 00 60 1c ld [ %g1 + 0x1c ], %o0 ! 201e01c <_Per_CPU_Information+0xc>
200f220: 92 07 bf d8 add %fp, -40, %o1
200f224: 90 02 20 20 add %o0, 0x20, %o0
200f228: 40 00 04 41 call 201032c <memcpy>
200f22c: 94 10 20 28 mov 0x28, %o2
/*
* Restore the previous set of blocked signals
*/
api->signals_blocked = saved_signals_blocked;
return true;
200f230: 82 10 20 01 mov 1, %g1
sizeof( Thread_Wait_information ));
/*
* Restore the previous set of blocked signals
*/
api->signals_blocked = saved_signals_blocked;
200f234: f8 26 20 d0 st %i4, [ %i0 + 0xd0 ]
return true;
}
200f238: b0 08 60 01 and %g1, 1, %i0
200f23c: 81 c7 e0 08 ret
200f240: 81 e8 00 00 restore
0200f96c <_POSIX_signals_Clear_process_signals>:
*/
void _POSIX_signals_Clear_process_signals(
int signo
)
{
200f96c: 9d e3 bf a0 save %sp, -96, %sp
200f970: 82 06 3f ff add %i0, -1, %g1
200f974: ba 10 20 01 mov 1, %i5
clear_signal = true;
mask = signo_to_mask( signo );
ISR_Level level;
_ISR_Disable( level );
200f978: 7f ff cb 53 call 20026c4 <sparc_disable_interrupts>
200f97c: bb 2f 40 01 sll %i5, %g1, %i5
if ( _POSIX_signals_Vectors[ signo ].sa_flags == SA_SIGINFO ) {
200f980: 05 00 80 78 sethi %hi(0x201e000), %g2
200f984: 83 2e 20 02 sll %i0, 2, %g1
200f988: 84 10 a0 70 or %g2, 0x70, %g2
200f98c: b1 2e 20 04 sll %i0, 4, %i0
200f990: 82 26 00 01 sub %i0, %g1, %g1
200f994: c4 00 80 01 ld [ %g2 + %g1 ], %g2
200f998: 80 a0 a0 02 cmp %g2, 2
200f99c: 32 80 00 0c bne,a 200f9cc <_POSIX_signals_Clear_process_signals+0x60>
200f9a0: 03 00 80 78 sethi %hi(0x201e000), %g1
if ( !_Chain_Is_empty( &_POSIX_signals_Siginfo[ signo ] ) )
200f9a4: 05 00 80 78 sethi %hi(0x201e000), %g2
200f9a8: 84 10 a2 68 or %g2, 0x268, %g2 ! 201e268 <_POSIX_signals_Siginfo>
200f9ac: 86 00 40 02 add %g1, %g2, %g3
200f9b0: c2 00 40 02 ld [ %g1 + %g2 ], %g1
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
200f9b4: 86 00 e0 04 add %g3, 4, %g3
200f9b8: 80 a0 40 03 cmp %g1, %g3
200f9bc: 02 80 00 04 be 200f9cc <_POSIX_signals_Clear_process_signals+0x60><== ALWAYS TAKEN
200f9c0: 03 00 80 78 sethi %hi(0x201e000), %g1
clear_signal = false;
}
if ( clear_signal ) {
_POSIX_signals_Pending &= ~mask;
}
_ISR_Enable( level );
200f9c4: 7f ff cb 44 call 20026d4 <sparc_enable_interrupts>
200f9c8: 91 e8 00 08 restore %g0, %o0, %o0
if ( _POSIX_signals_Vectors[ signo ].sa_flags == SA_SIGINFO ) {
if ( !_Chain_Is_empty( &_POSIX_signals_Siginfo[ signo ] ) )
clear_signal = false;
}
if ( clear_signal ) {
_POSIX_signals_Pending &= ~mask;
200f9cc: c4 00 62 64 ld [ %g1 + 0x264 ], %g2
200f9d0: ba 28 80 1d andn %g2, %i5, %i5
200f9d4: 10 bf ff fc b 200f9c4 <_POSIX_signals_Clear_process_signals+0x58>
200f9d8: fa 20 62 64 st %i5, [ %g1 + 0x264 ]
020083e8 <_POSIX_signals_Get_lowest>:
sigset_t set
)
{
int signo;
for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) {
20083e8: 82 10 20 1b mov 0x1b, %g1
20083ec: 84 10 20 01 mov 1, %g2
#include <rtems/posix/psignal.h>
#include <rtems/seterr.h>
#include <rtems/posix/time.h>
#include <rtems/score/isr.h>
static int _POSIX_signals_Get_lowest(
20083f0: 86 00 7f ff add %g1, -1, %g3
20083f4: 87 28 80 03 sll %g2, %g3, %g3
)
{
int signo;
for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) {
if ( set & signo_to_mask( signo ) ) {
20083f8: 80 88 c0 08 btst %g3, %o0
20083fc: 12 80 00 11 bne 2008440 <_POSIX_signals_Get_lowest+0x58> <== NEVER TAKEN
2008400: 01 00 00 00 nop
sigset_t set
)
{
int signo;
for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) {
2008404: 82 00 60 01 inc %g1
2008408: 80 a0 60 20 cmp %g1, 0x20
200840c: 12 bf ff fa bne 20083f4 <_POSIX_signals_Get_lowest+0xc>
2008410: 86 00 7f ff add %g1, -1, %g3
2008414: 82 10 20 01 mov 1, %g1
2008418: 84 10 20 01 mov 1, %g2
#include <rtems/posix/psignal.h>
#include <rtems/seterr.h>
#include <rtems/posix/time.h>
#include <rtems/score/isr.h>
static int _POSIX_signals_Get_lowest(
200841c: 86 00 7f ff add %g1, -1, %g3
2008420: 87 28 80 03 sll %g2, %g3, %g3
#if (SIGHUP != 1)
#error "Assumption that SIGHUP==1 violated!!"
#endif
for ( signo = SIGHUP ; signo <= __SIGLASTNOTRT ; signo++ ) {
if ( set & signo_to_mask( signo ) ) {
2008424: 80 88 c0 08 btst %g3, %o0
2008428: 12 80 00 06 bne 2008440 <_POSIX_signals_Get_lowest+0x58>
200842c: 01 00 00 00 nop
*/
#if (SIGHUP != 1)
#error "Assumption that SIGHUP==1 violated!!"
#endif
for ( signo = SIGHUP ; signo <= __SIGLASTNOTRT ; signo++ ) {
2008430: 82 00 60 01 inc %g1
2008434: 80 a0 60 1b cmp %g1, 0x1b
2008438: 12 bf ff fa bne 2008420 <_POSIX_signals_Get_lowest+0x38> <== ALWAYS TAKEN
200843c: 86 00 7f ff add %g1, -1, %g3
* a return 0. This routine will NOT be called unless a signal
* is pending in the set passed in.
*/
found_it:
return signo;
}
2008440: 81 c3 e0 08 retl
2008444: 90 10 00 01 mov %g1, %o0
0201a64c <_POSIX_signals_Unblock_thread>:
bool _POSIX_signals_Unblock_thread(
Thread_Control *the_thread,
int signo,
siginfo_t *info
)
{
201a64c: 9d e3 bf a0 save %sp, -96, %sp
/*
* Is the thread is specifically waiting for a signal?
*/
if ( _States_Is_interruptible_signal( the_thread->current_state ) ) {
201a650: c2 06 20 10 ld [ %i0 + 0x10 ], %g1
201a654: 3b 04 00 20 sethi %hi(0x10008000), %i5
201a658: 84 06 7f ff add %i1, -1, %g2
201a65c: 86 10 20 01 mov 1, %g3
201a660: b8 08 40 1d and %g1, %i5, %i4
{
POSIX_API_Control *api;
sigset_t mask;
siginfo_t *the_info = NULL;
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
201a664: c8 06 21 5c ld [ %i0 + 0x15c ], %g4
/*
* Is the thread is specifically waiting for a signal?
*/
if ( _States_Is_interruptible_signal( the_thread->current_state ) ) {
201a668: 80 a7 00 1d cmp %i4, %i5
201a66c: 12 80 00 1e bne 201a6e4 <_POSIX_signals_Unblock_thread+0x98>
201a670: 85 28 c0 02 sll %g3, %g2, %g2
if ( (the_thread->Wait.option & mask) || (~api->signals_blocked & mask) ) {
201a674: c2 06 20 30 ld [ %i0 + 0x30 ], %g1
201a678: 80 88 80 01 btst %g2, %g1
201a67c: 12 80 00 08 bne 201a69c <_POSIX_signals_Unblock_thread+0x50>
201a680: 82 10 20 04 mov 4, %g1
201a684: c2 01 20 d0 ld [ %g4 + 0xd0 ], %g1
201a688: 80 a8 80 01 andncc %g2, %g1, %g0
201a68c: 32 80 00 04 bne,a 201a69c <_POSIX_signals_Unblock_thread+0x50>
201a690: 82 10 20 04 mov 4, %g1
} else if ( the_thread->current_state == STATES_READY ) {
if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
_Thread_Dispatch_necessary = true;
}
}
return false;
201a694: 10 80 00 3d b 201a788 <_POSIX_signals_Unblock_thread+0x13c>
201a698: b0 10 20 00 clr %i0
*/
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;
201a69c: c2 26 20 34 st %g1, [ %i0 + 0x34 ]
the_info = (siginfo_t *) the_thread->Wait.return_argument;
if ( !info ) {
201a6a0: 80 a6 a0 00 cmp %i2, 0
201a6a4: 12 80 00 07 bne 201a6c0 <_POSIX_signals_Unblock_thread+0x74>
201a6a8: d0 06 20 28 ld [ %i0 + 0x28 ], %o0
the_info->si_signo = signo;
the_info->si_code = SI_USER;
201a6ac: 82 10 20 01 mov 1, %g1
the_thread->Wait.return_code = EINTR;
the_info = (siginfo_t *) the_thread->Wait.return_argument;
if ( !info ) {
the_info->si_signo = signo;
201a6b0: f2 22 00 00 st %i1, [ %o0 ]
the_info->si_code = SI_USER;
201a6b4: c2 22 20 04 st %g1, [ %o0 + 4 ]
the_info->si_value.sival_int = 0;
201a6b8: 10 80 00 05 b 201a6cc <_POSIX_signals_Unblock_thread+0x80>
201a6bc: c0 22 20 08 clr [ %o0 + 8 ]
} else {
*the_info = *info;
201a6c0: 92 10 00 1a mov %i2, %o1
201a6c4: 7f ff d7 1a call 201032c <memcpy>
201a6c8: 94 10 20 0c mov 0xc, %o2
}
_Thread_queue_Extract_with_proxy( the_thread );
201a6cc: 90 10 00 18 mov %i0, %o0
201a6d0: 7f ff c0 88 call 200a8f0 <_Thread_queue_Extract_with_proxy>
201a6d4: b0 10 20 01 mov 1, %i0
201a6d8: b0 0e 20 01 and %i0, 1, %i0
201a6dc: 81 c7 e0 08 ret
201a6e0: 81 e8 00 00 restore
}
/*
* Thread is not waiting due to a sigwait.
*/
if ( ~api->signals_blocked & mask ) {
201a6e4: c8 01 20 d0 ld [ %g4 + 0xd0 ], %g4
201a6e8: 80 a8 80 04 andncc %g2, %g4, %g0
201a6ec: 02 80 00 26 be 201a784 <_POSIX_signals_Unblock_thread+0x138>
201a6f0: 05 04 00 00 sethi %hi(0x10000000), %g2
* 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 ) ) {
201a6f4: 80 88 40 02 btst %g1, %g2
201a6f8: 02 80 00 17 be 201a754 <_POSIX_signals_Unblock_thread+0x108>
201a6fc: 80 a0 60 00 cmp %g1, 0
the_thread->Wait.return_code = EINTR;
201a700: 84 10 20 04 mov 4, %g2
201a704: c4 26 20 34 st %g2, [ %i0 + 0x34 ]
/*
* In pthread_cond_wait, a thread will be blocking on a thread
* queue, but is also interruptible by a POSIX signal.
*/
if ( _States_Is_waiting_on_thread_queue(the_thread->current_state) )
201a708: 05 00 00 ef sethi %hi(0x3bc00), %g2
201a70c: 84 10 a2 e0 or %g2, 0x2e0, %g2 ! 3bee0 <PROM_START+0x3bee0>
201a710: 80 88 40 02 btst %g1, %g2
201a714: 02 80 00 06 be 201a72c <_POSIX_signals_Unblock_thread+0xe0>
201a718: 80 88 60 08 btst 8, %g1
_Thread_queue_Extract_with_proxy( the_thread );
201a71c: 7f ff c0 75 call 200a8f0 <_Thread_queue_Extract_with_proxy>
201a720: 90 10 00 18 mov %i0, %o0
} else if ( the_thread->current_state == STATES_READY ) {
if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
_Thread_Dispatch_necessary = true;
}
}
return false;
201a724: 10 80 00 19 b 201a788 <_POSIX_signals_Unblock_thread+0x13c>
201a728: b0 10 20 00 clr %i0
* In pthread_cond_wait, a thread will be blocking on a thread
* queue, but is also interruptible by a POSIX signal.
*/
if ( _States_Is_waiting_on_thread_queue(the_thread->current_state) )
_Thread_queue_Extract_with_proxy( the_thread );
else if ( _States_Is_delaying(the_thread->current_state) ) {
201a72c: 22 80 00 17 be,a 201a788 <_POSIX_signals_Unblock_thread+0x13c><== NEVER TAKEN
201a730: b0 10 20 00 clr %i0 <== NOT EXECUTED
(void) _Watchdog_Remove( &the_thread->Timer );
201a734: 7f ff c2 40 call 200b034 <_Watchdog_Remove>
201a738: 90 06 20 48 add %i0, 0x48, %o0
RTEMS_INLINE_ROUTINE void _Thread_Unblock (
Thread_Control *the_thread
)
{
_Thread_Clear_state( the_thread, STATES_BLOCKED );
201a73c: 90 10 00 18 mov %i0, %o0
201a740: 13 04 00 ff sethi %hi(0x1003fc00), %o1
201a744: 7f ff bd b9 call 2009e28 <_Thread_Clear_state>
201a748: 92 12 63 f8 or %o1, 0x3f8, %o1 ! 1003fff8 <RAM_END+0xdc3fff8>
} else if ( the_thread->current_state == STATES_READY ) {
if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
_Thread_Dispatch_necessary = true;
}
}
return false;
201a74c: 10 80 00 0f b 201a788 <_POSIX_signals_Unblock_thread+0x13c>
201a750: b0 10 20 00 clr %i0
else if ( _States_Is_delaying(the_thread->current_state) ) {
(void) _Watchdog_Remove( &the_thread->Timer );
_Thread_Unblock( the_thread );
}
} else if ( the_thread->current_state == STATES_READY ) {
201a754: 32 80 00 0d bne,a 201a788 <_POSIX_signals_Unblock_thread+0x13c><== NEVER TAKEN
201a758: b0 10 20 00 clr %i0 <== NOT EXECUTED
if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
201a75c: 03 00 80 78 sethi %hi(0x201e000), %g1
201a760: 82 10 60 10 or %g1, 0x10, %g1 ! 201e010 <_Per_CPU_Information>
201a764: c4 00 60 08 ld [ %g1 + 8 ], %g2
201a768: 80 a0 a0 00 cmp %g2, 0
201a76c: 22 80 00 07 be,a 201a788 <_POSIX_signals_Unblock_thread+0x13c>
201a770: b0 10 20 00 clr %i0
201a774: c4 00 60 0c ld [ %g1 + 0xc ], %g2
201a778: 80 a6 00 02 cmp %i0, %g2
201a77c: 22 80 00 02 be,a 201a784 <_POSIX_signals_Unblock_thread+0x138><== ALWAYS TAKEN
201a780: c6 28 60 18 stb %g3, [ %g1 + 0x18 ]
_Thread_Dispatch_necessary = true;
}
}
return false;
201a784: b0 10 20 00 clr %i0
}
201a788: b0 0e 20 01 and %i0, 1, %i0
201a78c: 81 c7 e0 08 ret
201a790: 81 e8 00 00 restore
0200a37c <_RBTree_Extract_unprotected>:
*/
void _RBTree_Extract_unprotected(
RBTree_Control *the_rbtree,
RBTree_Node *the_node
)
{
200a37c: 9d e3 bf a0 save %sp, -96, %sp
RBTree_Node *leaf, *target;
RBTree_Color victim_color;
RBTree_Direction dir;
if (!the_node) return;
200a380: 80 a6 60 00 cmp %i1, 0
200a384: 02 80 00 69 be 200a528 <_RBTree_Extract_unprotected+0x1ac>
200a388: 01 00 00 00 nop
/* check if min needs to be updated */
if (the_node == the_rbtree->first[RBT_LEFT]) {
200a38c: c2 06 20 08 ld [ %i0 + 8 ], %g1
200a390: 80 a6 40 01 cmp %i1, %g1
200a394: 32 80 00 07 bne,a 200a3b0 <_RBTree_Extract_unprotected+0x34>
200a398: c2 06 20 0c ld [ %i0 + 0xc ], %g1
*/
RTEMS_INLINE_ROUTINE RBTree_Node *_RBTree_Successor_unprotected(
const RBTree_Node *node
)
{
return _RBTree_Next_unprotected( node, RBT_RIGHT );
200a39c: 90 10 00 19 mov %i1, %o0
200a3a0: 40 00 01 31 call 200a864 <_RBTree_Next_unprotected>
200a3a4: 92 10 20 01 mov 1, %o1
RBTree_Node *next;
next = _RBTree_Successor_unprotected(the_node);
the_rbtree->first[RBT_LEFT] = next;
200a3a8: d0 26 20 08 st %o0, [ %i0 + 8 ]
}
/* Check if max needs to be updated. min=max for 1 element trees so
* do not use else if here. */
if (the_node == the_rbtree->first[RBT_RIGHT]) {
200a3ac: c2 06 20 0c ld [ %i0 + 0xc ], %g1
200a3b0: 80 a6 40 01 cmp %i1, %g1
200a3b4: 32 80 00 07 bne,a 200a3d0 <_RBTree_Extract_unprotected+0x54>
200a3b8: fa 06 60 04 ld [ %i1 + 4 ], %i5
*/
RTEMS_INLINE_ROUTINE RBTree_Node *_RBTree_Predecessor_unprotected(
const RBTree_Node *node
)
{
return _RBTree_Next_unprotected( node, RBT_LEFT );
200a3bc: 90 10 00 19 mov %i1, %o0
200a3c0: 40 00 01 29 call 200a864 <_RBTree_Next_unprotected>
200a3c4: 92 10 20 00 clr %o1
RBTree_Node *previous;
previous = _RBTree_Predecessor_unprotected(the_node);
the_rbtree->first[RBT_RIGHT] = previous;
200a3c8: d0 26 20 0c st %o0, [ %i0 + 0xc ]
* 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]) {
200a3cc: fa 06 60 04 ld [ %i1 + 4 ], %i5
200a3d0: 80 a7 60 00 cmp %i5, 0
200a3d4: 02 80 00 36 be 200a4ac <_RBTree_Extract_unprotected+0x130>
200a3d8: f8 06 60 08 ld [ %i1 + 8 ], %i4
200a3dc: 80 a7 20 00 cmp %i4, 0
200a3e0: 32 80 00 05 bne,a 200a3f4 <_RBTree_Extract_unprotected+0x78>
200a3e4: c2 07 60 08 ld [ %i5 + 8 ], %g1
200a3e8: 10 80 00 35 b 200a4bc <_RBTree_Extract_unprotected+0x140>
200a3ec: b8 10 00 1d mov %i5, %i4
target = the_node->child[RBT_LEFT]; /* find max in node->child[RBT_LEFT] */
while (target->child[RBT_RIGHT]) target = target->child[RBT_RIGHT];
200a3f0: c2 07 60 08 ld [ %i5 + 8 ], %g1
200a3f4: 80 a0 60 00 cmp %g1, 0
200a3f8: 32 bf ff fe bne,a 200a3f0 <_RBTree_Extract_unprotected+0x74>
200a3fc: ba 10 00 01 mov %g1, %i5
* 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];
200a400: f8 07 60 04 ld [ %i5 + 4 ], %i4
if(leaf) {
200a404: 80 a7 20 00 cmp %i4, 0
200a408: 02 80 00 05 be 200a41c <_RBTree_Extract_unprotected+0xa0>
200a40c: 01 00 00 00 nop
leaf->parent = target->parent;
200a410: c2 07 40 00 ld [ %i5 ], %g1
200a414: 10 80 00 04 b 200a424 <_RBTree_Extract_unprotected+0xa8>
200a418: c2 27 00 00 st %g1, [ %i4 ]
} else {
/* fix the tree here if the child is a null leaf. */
_RBTree_Extract_validate_unprotected(target);
200a41c: 7f ff ff 73 call 200a1e8 <_RBTree_Extract_validate_unprotected>
200a420: 90 10 00 1d mov %i5, %o0
}
victim_color = target->color;
dir = target != target->parent->child[0];
200a424: c4 07 40 00 ld [ %i5 ], %g2
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;
200a428: c2 07 60 0c ld [ %i5 + 0xc ], %g1
dir = target != target->parent->child[0];
200a42c: c6 00 a0 04 ld [ %g2 + 4 ], %g3
200a430: 86 1f 40 03 xor %i5, %g3, %g3
200a434: 80 a0 00 03 cmp %g0, %g3
200a438: 86 40 20 00 addx %g0, 0, %g3
target->parent->child[dir] = leaf;
200a43c: 87 28 e0 02 sll %g3, 2, %g3
200a440: 84 00 80 03 add %g2, %g3, %g2
200a444: f8 20 a0 04 st %i4, [ %g2 + 4 ]
/* now replace the_node with target */
dir = the_node != the_node->parent->child[0];
200a448: c4 06 40 00 ld [ %i1 ], %g2
200a44c: c6 00 a0 04 ld [ %g2 + 4 ], %g3
200a450: 86 1e 40 03 xor %i1, %g3, %g3
200a454: 80 a0 00 03 cmp %g0, %g3
200a458: 86 40 20 00 addx %g0, 0, %g3
the_node->parent->child[dir] = target;
200a45c: 87 28 e0 02 sll %g3, 2, %g3
200a460: 84 00 80 03 add %g2, %g3, %g2
200a464: fa 20 a0 04 st %i5, [ %g2 + 4 ]
/* set target's new children to the original node's children */
target->child[RBT_RIGHT] = the_node->child[RBT_RIGHT];
200a468: c4 06 60 08 ld [ %i1 + 8 ], %g2
200a46c: c4 27 60 08 st %g2, [ %i5 + 8 ]
if (the_node->child[RBT_RIGHT])
200a470: c4 06 60 08 ld [ %i1 + 8 ], %g2
200a474: 80 a0 a0 00 cmp %g2, 0
200a478: 32 80 00 02 bne,a 200a480 <_RBTree_Extract_unprotected+0x104><== ALWAYS TAKEN
200a47c: fa 20 80 00 st %i5, [ %g2 ]
the_node->child[RBT_RIGHT]->parent = target;
target->child[RBT_LEFT] = the_node->child[RBT_LEFT];
200a480: c4 06 60 04 ld [ %i1 + 4 ], %g2
200a484: c4 27 60 04 st %g2, [ %i5 + 4 ]
if (the_node->child[RBT_LEFT])
200a488: c4 06 60 04 ld [ %i1 + 4 ], %g2
200a48c: 80 a0 a0 00 cmp %g2, 0
200a490: 32 80 00 02 bne,a 200a498 <_RBTree_Extract_unprotected+0x11c>
200a494: fa 20 80 00 st %i5, [ %g2 ]
/* 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;
200a498: c4 06 40 00 ld [ %i1 ], %g2
200a49c: c4 27 40 00 st %g2, [ %i5 ]
target->color = the_node->color;
200a4a0: c4 06 60 0c ld [ %i1 + 0xc ], %g2
200a4a4: 10 80 00 14 b 200a4f4 <_RBTree_Extract_unprotected+0x178>
200a4a8: c4 27 60 0c st %g2, [ %i5 + 0xc ]
* 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 ) {
200a4ac: 80 a7 20 00 cmp %i4, 0
200a4b0: 32 80 00 04 bne,a 200a4c0 <_RBTree_Extract_unprotected+0x144>
200a4b4: c2 06 40 00 ld [ %i1 ], %g1
200a4b8: 30 80 00 04 b,a 200a4c8 <_RBTree_Extract_unprotected+0x14c>
leaf->parent = the_node->parent;
200a4bc: c2 06 40 00 ld [ %i1 ], %g1
200a4c0: 10 80 00 04 b 200a4d0 <_RBTree_Extract_unprotected+0x154>
200a4c4: c2 27 00 00 st %g1, [ %i4 ]
} else {
/* fix the tree here if the child is a null leaf. */
_RBTree_Extract_validate_unprotected(the_node);
200a4c8: 7f ff ff 48 call 200a1e8 <_RBTree_Extract_validate_unprotected>
200a4cc: 90 10 00 19 mov %i1, %o0
}
victim_color = the_node->color;
/* remove the_node from the tree */
dir = the_node != the_node->parent->child[0];
200a4d0: c4 06 40 00 ld [ %i1 ], %g2
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;
200a4d4: c2 06 60 0c ld [ %i1 + 0xc ], %g1
/* remove the_node from the tree */
dir = the_node != the_node->parent->child[0];
200a4d8: c6 00 a0 04 ld [ %g2 + 4 ], %g3
200a4dc: 86 1e 40 03 xor %i1, %g3, %g3
200a4e0: 80 a0 00 03 cmp %g0, %g3
200a4e4: 86 40 20 00 addx %g0, 0, %g3
the_node->parent->child[dir] = leaf;
200a4e8: 87 28 e0 02 sll %g3, 2, %g3
200a4ec: 84 00 80 03 add %g2, %g3, %g2
200a4f0: f8 20 a0 04 st %i4, [ %g2 + 4 ]
/* 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 */
200a4f4: 80 a0 60 00 cmp %g1, 0
200a4f8: 32 80 00 06 bne,a 200a510 <_RBTree_Extract_unprotected+0x194>
200a4fc: c2 06 20 04 ld [ %i0 + 4 ], %g1
if (leaf) {
200a500: 80 a7 20 00 cmp %i4, 0
200a504: 32 80 00 02 bne,a 200a50c <_RBTree_Extract_unprotected+0x190>
200a508: c0 27 20 0c clr [ %i4 + 0xc ]
/* 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;
200a50c: c2 06 20 04 ld [ %i0 + 4 ], %g1
*/
RTEMS_INLINE_ROUTINE void _RBTree_Set_off_rbtree(
RBTree_Node *node
)
{
node->parent = node->child[RBT_LEFT] = node->child[RBT_RIGHT] = NULL;
200a510: c0 26 60 08 clr [ %i1 + 8 ]
200a514: c0 26 60 04 clr [ %i1 + 4 ]
200a518: 80 a0 60 00 cmp %g1, 0
200a51c: 02 80 00 03 be 200a528 <_RBTree_Extract_unprotected+0x1ac>
200a520: c0 26 40 00 clr [ %i1 ]
200a524: c0 20 60 0c clr [ %g1 + 0xc ]
200a528: 81 c7 e0 08 ret
200a52c: 81 e8 00 00 restore
0200b570 <_RBTree_Initialize>:
void *starting_address,
size_t number_nodes,
size_t node_size,
bool is_unique
)
{
200b570: 9d e3 bf a0 save %sp, -96, %sp
size_t count;
RBTree_Node *next;
/* TODO: Error message? */
if (!the_rbtree) return;
200b574: 80 a6 20 00 cmp %i0, 0
200b578: 02 80 00 10 be 200b5b8 <_RBTree_Initialize+0x48> <== NEVER TAKEN
200b57c: 01 00 00 00 nop
RBTree_Control *the_rbtree,
RBTree_Compare_function compare_function,
bool is_unique
)
{
the_rbtree->permanent_null = NULL;
200b580: c0 26 00 00 clr [ %i0 ]
the_rbtree->root = NULL;
200b584: c0 26 20 04 clr [ %i0 + 4 ]
the_rbtree->first[0] = NULL;
200b588: c0 26 20 08 clr [ %i0 + 8 ]
the_rbtree->first[1] = NULL;
200b58c: c0 26 20 0c clr [ %i0 + 0xc ]
the_rbtree->compare_function = compare_function;
200b590: f2 26 20 10 st %i1, [ %i0 + 0x10 ]
/* could do sanity checks here */
_RBTree_Initialize_empty(the_rbtree, compare_function, is_unique);
count = number_nodes;
next = starting_address;
while ( count-- ) {
200b594: 10 80 00 06 b 200b5ac <_RBTree_Initialize+0x3c>
200b598: fa 2e 20 14 stb %i5, [ %i0 + 0x14 ]
_RBTree_Insert_unprotected(the_rbtree, next);
200b59c: 90 10 00 18 mov %i0, %o0
200b5a0: 7f ff ff 2e call 200b258 <_RBTree_Insert_unprotected>
200b5a4: b4 06 80 1c add %i2, %i4, %i2
200b5a8: b6 06 ff ff add %i3, -1, %i3
/* could do sanity checks here */
_RBTree_Initialize_empty(the_rbtree, compare_function, is_unique);
count = number_nodes;
next = starting_address;
while ( count-- ) {
200b5ac: 80 a6 e0 00 cmp %i3, 0
200b5b0: 12 bf ff fb bne 200b59c <_RBTree_Initialize+0x2c>
200b5b4: 92 10 00 1a mov %i2, %o1
200b5b8: 81 c7 e0 08 ret
200b5bc: 81 e8 00 00 restore
0200a5d0 <_RBTree_Insert_unprotected>:
*/
RBTree_Node *_RBTree_Insert_unprotected(
RBTree_Control *the_rbtree,
RBTree_Node *the_node
)
{
200a5d0: 9d e3 bf a0 save %sp, -96, %sp
if(!the_node) return (RBTree_Node*)-1;
200a5d4: 80 a6 60 00 cmp %i1, 0
200a5d8: 02 80 00 7c be 200a7c8 <_RBTree_Insert_unprotected+0x1f8>
200a5dc: ba 10 00 18 mov %i0, %i5
RBTree_Node *iter_node = the_rbtree->root;
200a5e0: f0 06 20 04 ld [ %i0 + 4 ], %i0
int compare_result;
if (!iter_node) { /* special case: first node inserted */
200a5e4: b6 96 20 00 orcc %i0, 0, %i3
200a5e8: 32 80 00 0c bne,a 200a618 <_RBTree_Insert_unprotected+0x48>
200a5ec: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
the_node->color = RBT_BLACK;
200a5f0: c0 26 60 0c clr [ %i1 + 0xc ]
the_rbtree->root = the_node;
200a5f4: f2 27 60 04 st %i1, [ %i5 + 4 ]
the_rbtree->first[0] = the_rbtree->first[1] = the_node;
200a5f8: f2 27 60 0c st %i1, [ %i5 + 0xc ]
200a5fc: f2 27 60 08 st %i1, [ %i5 + 8 ]
the_node->parent = (RBTree_Node *) the_rbtree;
200a600: fa 26 40 00 st %i5, [ %i1 ]
the_node->child[RBT_LEFT] = the_node->child[RBT_RIGHT] = NULL;
200a604: c0 26 60 08 clr [ %i1 + 8 ]
200a608: c0 26 60 04 clr [ %i1 + 4 ]
200a60c: 81 c7 e0 08 ret
200a610: 81 e8 00 00 restore
} else {
/* typical binary search tree insert, descend tree to leaf and insert */
while (iter_node) {
compare_result = the_rbtree->compare_function(the_node, iter_node);
200a614: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
200a618: 90 10 00 19 mov %i1, %o0
200a61c: 9f c0 40 00 call %g1
200a620: 92 10 00 18 mov %i0, %o1
if ( the_rbtree->is_unique && _RBTree_Is_equal( compare_result ) )
200a624: c2 0f 60 14 ldub [ %i5 + 0x14 ], %g1
200a628: 80 a0 60 00 cmp %g1, 0
200a62c: 02 80 00 05 be 200a640 <_RBTree_Insert_unprotected+0x70>
200a630: b8 38 00 08 xnor %g0, %o0, %i4
200a634: 80 a2 20 00 cmp %o0, 0
200a638: 02 80 00 65 be 200a7cc <_RBTree_Insert_unprotected+0x1fc>
200a63c: 01 00 00 00 nop
return iter_node;
RBTree_Direction dir = !_RBTree_Is_lesser( compare_result );
200a640: b9 37 20 1f srl %i4, 0x1f, %i4
if (!iter_node->child[dir]) {
200a644: 83 2f 20 02 sll %i4, 2, %g1
200a648: 82 06 00 01 add %i0, %g1, %g1
200a64c: f0 00 60 04 ld [ %g1 + 4 ], %i0
200a650: 80 a6 20 00 cmp %i0, 0
200a654: 32 bf ff f0 bne,a 200a614 <_RBTree_Insert_unprotected+0x44>
200a658: b6 10 00 18 mov %i0, %i3
the_node->child[RBT_LEFT] = the_node->child[RBT_RIGHT] = NULL;
200a65c: c0 26 60 08 clr [ %i1 + 8 ]
200a660: c0 26 60 04 clr [ %i1 + 4 ]
the_node->color = RBT_RED;
200a664: 84 10 20 01 mov 1, %g2
iter_node->child[dir] = the_node;
200a668: f2 20 60 04 st %i1, [ %g1 + 4 ]
if ( the_rbtree->is_unique && _RBTree_Is_equal( compare_result ) )
return iter_node;
RBTree_Direction dir = !_RBTree_Is_lesser( compare_result );
if (!iter_node->child[dir]) {
the_node->child[RBT_LEFT] = the_node->child[RBT_RIGHT] = NULL;
the_node->color = RBT_RED;
200a66c: c4 26 60 0c st %g2, [ %i1 + 0xc ]
iter_node->child[dir] = the_node;
the_node->parent = iter_node;
200a670: f6 26 40 00 st %i3, [ %i1 ]
/* update min/max */
compare_result = the_rbtree->compare_function(
200a674: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
RTEMS_INLINE_ROUTINE RBTree_Node *_RBTree_First(
const RBTree_Control *the_rbtree,
RBTree_Direction dir
)
{
return the_rbtree->first[dir];
200a678: b6 07 20 02 add %i4, 2, %i3
200a67c: 85 2e e0 02 sll %i3, 2, %g2
200a680: d2 07 40 02 ld [ %i5 + %g2 ], %o1
200a684: 9f c0 40 00 call %g1
200a688: 90 10 00 19 mov %i1, %o0
the_node,
_RBTree_First(the_rbtree, dir)
);
if ( (!dir && _RBTree_Is_lesser(compare_result)) ||
200a68c: 80 a7 20 00 cmp %i4, 0
200a690: 12 80 00 06 bne 200a6a8 <_RBTree_Insert_unprotected+0xd8>
200a694: 80 a2 20 00 cmp %o0, 0
200a698: 36 80 00 3c bge,a 200a788 <_RBTree_Insert_unprotected+0x1b8>
200a69c: d0 06 40 00 ld [ %i1 ], %o0
(dir && _RBTree_Is_greater(compare_result)) ) {
the_rbtree->first[dir] = the_node;
200a6a0: 10 80 00 04 b 200a6b0 <_RBTree_Insert_unprotected+0xe0>
200a6a4: b7 2e e0 02 sll %i3, 2, %i3
compare_result = the_rbtree->compare_function(
the_node,
_RBTree_First(the_rbtree, dir)
);
if ( (!dir && _RBTree_Is_lesser(compare_result)) ||
(dir && _RBTree_Is_greater(compare_result)) ) {
200a6a8: 04 80 00 37 ble 200a784 <_RBTree_Insert_unprotected+0x1b4>
200a6ac: b7 2e e0 02 sll %i3, 2, %i3
the_rbtree->first[dir] = the_node;
200a6b0: 10 80 00 35 b 200a784 <_RBTree_Insert_unprotected+0x1b4>
200a6b4: f2 27 40 1b st %i1, [ %i5 + %i3 ]
const RBTree_Node *the_node
)
{
if(!the_node) return NULL;
if(!(the_node->parent)) return NULL;
if(!(the_node->parent->parent)) return NULL;
200a6b8: 02 80 00 13 be 200a704 <_RBTree_Insert_unprotected+0x134> <== NEVER TAKEN
200a6bc: 82 10 20 00 clr %g1
if(!(the_node->parent->parent->parent)) return NULL;
200a6c0: c2 07 40 00 ld [ %i5 ], %g1
200a6c4: 80 a0 60 00 cmp %g1, 0
200a6c8: 02 80 00 0f be 200a704 <_RBTree_Insert_unprotected+0x134> <== NEVER TAKEN
200a6cc: 82 10 20 00 clr %g1
{
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])
200a6d0: c2 07 60 04 ld [ %i5 + 4 ], %g1
200a6d4: 80 a2 00 01 cmp %o0, %g1
200a6d8: 22 80 00 02 be,a 200a6e0 <_RBTree_Insert_unprotected+0x110>
200a6dc: c2 07 60 08 ld [ %i5 + 8 ], %g1
*/
RTEMS_INLINE_ROUTINE bool _RBTree_Is_red(
const RBTree_Node *the_node
)
{
return (the_node && the_node->color == RBT_RED);
200a6e0: 80 a0 60 00 cmp %g1, 0
200a6e4: 02 80 00 09 be 200a708 <_RBTree_Insert_unprotected+0x138>
200a6e8: 84 10 20 00 clr %g2
200a6ec: c4 00 60 0c ld [ %g1 + 0xc ], %g2
200a6f0: 80 a0 a0 01 cmp %g2, 1
200a6f4: 32 80 00 05 bne,a 200a708 <_RBTree_Insert_unprotected+0x138>
200a6f8: 84 10 20 00 clr %g2
200a6fc: 10 80 00 03 b 200a708 <_RBTree_Insert_unprotected+0x138>
200a700: 84 10 20 01 mov 1, %g2
200a704: 84 10 20 00 clr %g2 <== NOT EXECUTED
while (_RBTree_Is_red(_RBTree_Parent(the_node))) {
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)) {
200a708: 80 a0 a0 00 cmp %g2, 0
200a70c: 22 80 00 08 be,a 200a72c <_RBTree_Insert_unprotected+0x15c>
200a710: c2 07 60 04 ld [ %i5 + 4 ], %g1
the_node->parent->color = RBT_BLACK;
200a714: c0 22 20 0c clr [ %o0 + 0xc ]
u->color = RBT_BLACK;
200a718: c0 20 60 0c clr [ %g1 + 0xc ]
g->color = RBT_RED;
200a71c: b2 10 00 1d mov %i5, %i1
200a720: 82 10 20 01 mov 1, %g1
200a724: 10 80 00 18 b 200a784 <_RBTree_Insert_unprotected+0x1b4>
200a728: c2 27 60 0c st %g1, [ %i5 + 0xc ]
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];
200a72c: 82 1a 00 01 xor %o0, %g1, %g1
200a730: 80 a0 00 01 cmp %g0, %g1
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];
200a734: c2 02 20 04 ld [ %o0 + 4 ], %g1
RBTree_Direction pdir = the_node->parent != g->child[0];
200a738: b8 40 20 00 addx %g0, 0, %i4
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];
200a73c: 82 1e 40 01 xor %i1, %g1, %g1
200a740: 80 a0 00 01 cmp %g0, %g1
200a744: 82 40 20 00 addx %g0, 0, %g1
RBTree_Direction pdir = the_node->parent != g->child[0];
/* ensure node is on the same branch direction as parent */
if (dir != pdir) {
200a748: 80 a0 40 1c cmp %g1, %i4
200a74c: 22 80 00 08 be,a 200a76c <_RBTree_Insert_unprotected+0x19c>
200a750: c2 06 40 00 ld [ %i1 ], %g1
_RBTree_Rotate(the_node->parent, pdir);
200a754: 7f ff ff 80 call 200a554 <_RBTree_Rotate>
200a758: 92 10 00 1c mov %i4, %o1
the_node = the_node->child[pdir];
200a75c: 83 2f 20 02 sll %i4, 2, %g1
200a760: b2 06 40 01 add %i1, %g1, %i1
200a764: f2 06 60 04 ld [ %i1 + 4 ], %i1
}
the_node->parent->color = RBT_BLACK;
200a768: c2 06 40 00 ld [ %i1 ], %g1
g->color = RBT_RED;
200a76c: 92 10 20 01 mov 1, %o1
/* 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;
200a770: c0 20 60 0c clr [ %g1 + 0xc ]
g->color = RBT_RED;
200a774: d2 27 60 0c st %o1, [ %i5 + 0xc ]
/* now rotate grandparent in the other branch direction (toward uncle) */
_RBTree_Rotate(g, (1-pdir));
200a778: 90 10 00 1d mov %i5, %o0
200a77c: 7f ff ff 76 call 200a554 <_RBTree_Rotate>
200a780: 92 22 40 1c sub %o1, %i4, %o1
*/
RTEMS_INLINE_ROUTINE RBTree_Node *_RBTree_Parent(
const RBTree_Node *the_node
)
{
if (!the_node->parent->parent) return NULL;
200a784: d0 06 40 00 ld [ %i1 ], %o0
200a788: fa 02 00 00 ld [ %o0 ], %i5
200a78c: 80 a7 60 00 cmp %i5, 0
200a790: 22 80 00 06 be,a 200a7a8 <_RBTree_Insert_unprotected+0x1d8>
200a794: 82 10 20 00 clr %g1
*/
RTEMS_INLINE_ROUTINE bool _RBTree_Is_red(
const RBTree_Node *the_node
)
{
return (the_node && the_node->color == RBT_RED);
200a798: c2 02 20 0c ld [ %o0 + 0xc ], %g1
200a79c: 82 18 60 01 xor %g1, 1, %g1
200a7a0: 80 a0 00 01 cmp %g0, %g1
200a7a4: 82 60 3f ff subx %g0, -1, %g1
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))) {
200a7a8: 80 a0 60 00 cmp %g1, 0
200a7ac: 12 bf ff c3 bne 200a6b8 <_RBTree_Insert_unprotected+0xe8>
200a7b0: 80 a7 60 00 cmp %i5, 0
/* 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;
200a7b4: 12 80 00 06 bne 200a7cc <_RBTree_Insert_unprotected+0x1fc>
200a7b8: 01 00 00 00 nop
200a7bc: c0 26 60 0c clr [ %i1 + 0xc ]
200a7c0: 81 c7 e0 08 ret
200a7c4: 81 e8 00 00 restore
RBTree_Node *_RBTree_Insert_unprotected(
RBTree_Control *the_rbtree,
RBTree_Node *the_node
)
{
if(!the_node) return (RBTree_Node*)-1;
200a7c8: b0 10 3f ff mov -1, %i0
/* verify red-black properties */
_RBTree_Validate_insert_unprotected(the_node);
}
return (RBTree_Node*)0;
}
200a7cc: 81 c7 e0 08 ret
200a7d0: 81 e8 00 00 restore
0200a804 <_RBTree_Iterate_unprotected>:
const RBTree_Control *rbtree,
RBTree_Direction dir,
RBTree_Visitor visitor,
void *visitor_arg
)
{
200a804: 9d e3 bf a0 save %sp, -96, %sp
RBTree_Direction opp_dir = _RBTree_Opposite_direction( dir );
const RBTree_Node *current = _RBTree_First( rbtree, opp_dir );
bool stop = false;
200a808: b8 10 20 00 clr %i4
*/
RTEMS_INLINE_ROUTINE RBTree_Direction _RBTree_Opposite_direction(
RBTree_Direction the_dir
)
{
return (RBTree_Direction) !((int) the_dir);
200a80c: 80 a0 00 19 cmp %g0, %i1
200a810: 82 60 3f ff subx %g0, -1, %g1
RTEMS_INLINE_ROUTINE RBTree_Node *_RBTree_First(
const RBTree_Control *the_rbtree,
RBTree_Direction dir
)
{
return the_rbtree->first[dir];
200a814: 82 00 60 02 add %g1, 2, %g1
200a818: 83 28 60 02 sll %g1, 2, %g1
while ( !stop && current != NULL ) {
200a81c: 10 80 00 0a b 200a844 <_RBTree_Iterate_unprotected+0x40>
200a820: fa 06 00 01 ld [ %i0 + %g1 ], %i5
stop = (*visitor)( current, dir, visitor_arg );
200a824: 92 10 00 19 mov %i1, %o1
200a828: 9f c6 80 00 call %i2
200a82c: 94 10 00 1b mov %i3, %o2
current = _RBTree_Next_unprotected( current, dir );
200a830: 92 10 00 19 mov %i1, %o1
RBTree_Direction opp_dir = _RBTree_Opposite_direction( dir );
const RBTree_Node *current = _RBTree_First( rbtree, opp_dir );
bool stop = false;
while ( !stop && current != NULL ) {
stop = (*visitor)( current, dir, visitor_arg );
200a834: b8 10 00 08 mov %o0, %i4
current = _RBTree_Next_unprotected( current, dir );
200a838: 40 00 00 0b call 200a864 <_RBTree_Next_unprotected>
200a83c: 90 10 00 1d mov %i5, %o0
200a840: ba 10 00 08 mov %o0, %i5
{
RBTree_Direction opp_dir = _RBTree_Opposite_direction( dir );
const RBTree_Node *current = _RBTree_First( rbtree, opp_dir );
bool stop = false;
while ( !stop && current != NULL ) {
200a844: 80 a7 60 00 cmp %i5, 0
200a848: 02 80 00 05 be 200a85c <_RBTree_Iterate_unprotected+0x58>
200a84c: b8 1f 20 01 xor %i4, 1, %i4
200a850: 80 8f 20 ff btst 0xff, %i4
200a854: 12 bf ff f4 bne 200a824 <_RBTree_Iterate_unprotected+0x20><== ALWAYS TAKEN
200a858: 90 10 00 1d mov %i5, %o0
200a85c: 81 c7 e0 08 ret
200a860: 81 e8 00 00 restore
0200a16c <_RBTree_Rotate>:
RBTree_Node *the_node,
RBTree_Direction dir
)
{
RBTree_Node *c;
if (the_node == NULL) return;
200a16c: 80 a2 20 00 cmp %o0, 0
200a170: 02 80 00 1c be 200a1e0 <_RBTree_Rotate+0x74> <== NEVER TAKEN
200a174: 80 a0 00 09 cmp %g0, %o1
*/
RTEMS_INLINE_ROUTINE RBTree_Direction _RBTree_Opposite_direction(
RBTree_Direction the_dir
)
{
return (RBTree_Direction) !((int) the_dir);
200a178: 86 60 3f ff subx %g0, -1, %g3
RBTree_Direction dir
)
{
RBTree_Node *c;
if (the_node == NULL) return;
if (the_node->child[_RBTree_Opposite_direction(dir)] == NULL) return;
200a17c: 87 28 e0 02 sll %g3, 2, %g3
200a180: 86 02 00 03 add %o0, %g3, %g3
200a184: c2 00 e0 04 ld [ %g3 + 4 ], %g1
200a188: 80 a0 60 00 cmp %g1, 0
200a18c: 02 80 00 15 be 200a1e0 <_RBTree_Rotate+0x74> <== NEVER TAKEN
200a190: 93 2a 60 02 sll %o1, 2, %o1
c = the_node->child[_RBTree_Opposite_direction(dir)];
the_node->child[_RBTree_Opposite_direction(dir)] = c->child[dir];
200a194: 84 00 40 09 add %g1, %o1, %g2
200a198: c8 00 a0 04 ld [ %g2 + 4 ], %g4
200a19c: c8 20 e0 04 st %g4, [ %g3 + 4 ]
if (c->child[dir])
200a1a0: c4 00 a0 04 ld [ %g2 + 4 ], %g2
200a1a4: 80 a0 a0 00 cmp %g2, 0
200a1a8: 32 80 00 02 bne,a 200a1b0 <_RBTree_Rotate+0x44>
200a1ac: d0 20 80 00 st %o0, [ %g2 ]
c->child[dir]->parent = the_node;
c->child[dir] = the_node;
the_node->parent->child[the_node != the_node->parent->child[0]] = c;
200a1b0: c4 02 00 00 ld [ %o0 ], %g2
the_node->child[_RBTree_Opposite_direction(dir)] = c->child[dir];
if (c->child[dir])
c->child[dir]->parent = the_node;
c->child[dir] = the_node;
200a1b4: 92 00 40 09 add %g1, %o1, %o1
200a1b8: d0 22 60 04 st %o0, [ %o1 + 4 ]
the_node->parent->child[the_node != the_node->parent->child[0]] = c;
200a1bc: c6 00 a0 04 ld [ %g2 + 4 ], %g3
c->parent = the_node->parent;
200a1c0: c4 20 40 00 st %g2, [ %g1 ]
if (c->child[dir])
c->child[dir]->parent = the_node;
c->child[dir] = the_node;
the_node->parent->child[the_node != the_node->parent->child[0]] = c;
200a1c4: 86 1a 00 03 xor %o0, %g3, %g3
c->parent = the_node->parent;
the_node->parent = c;
200a1c8: c2 22 00 00 st %g1, [ %o0 ]
if (c->child[dir])
c->child[dir]->parent = the_node;
c->child[dir] = the_node;
the_node->parent->child[the_node != the_node->parent->child[0]] = c;
200a1cc: 80 a0 00 03 cmp %g0, %g3
200a1d0: 86 40 20 00 addx %g0, 0, %g3
200a1d4: 87 28 e0 02 sll %g3, 2, %g3
200a1d8: 86 00 80 03 add %g2, %g3, %g3
200a1dc: c2 20 e0 04 st %g1, [ %g3 + 4 ]
200a1e0: 81 c3 e0 08 retl
0200a11c <_RBTree_Sibling>:
*/
RTEMS_INLINE_ROUTINE RBTree_Node *_RBTree_Sibling(
const RBTree_Node *the_node
)
{
if(!the_node) return NULL;
200a11c: 80 a2 20 00 cmp %o0, 0
200a120: 02 80 00 10 be 200a160 <_RBTree_Sibling+0x44> <== NEVER TAKEN
200a124: 82 10 20 00 clr %g1
if(!(the_node->parent)) return NULL;
200a128: c4 02 00 00 ld [ %o0 ], %g2
200a12c: 80 a0 a0 00 cmp %g2, 0
200a130: 22 80 00 0d be,a 200a164 <_RBTree_Sibling+0x48> <== NEVER TAKEN
200a134: 90 10 00 01 mov %g1, %o0 <== NOT EXECUTED
if(!(the_node->parent->parent)) return NULL;
200a138: c2 00 80 00 ld [ %g2 ], %g1
200a13c: 80 a0 60 00 cmp %g1, 0
200a140: 02 80 00 08 be 200a160 <_RBTree_Sibling+0x44>
200a144: 82 10 20 00 clr %g1
if(the_node == the_node->parent->child[RBT_LEFT])
200a148: c2 00 a0 04 ld [ %g2 + 4 ], %g1
200a14c: 80 a2 00 01 cmp %o0, %g1
200a150: 22 80 00 04 be,a 200a160 <_RBTree_Sibling+0x44>
200a154: c2 00 a0 08 ld [ %g2 + 8 ], %g1
return the_node->parent->child[RBT_RIGHT];
200a158: 81 c3 e0 08 retl
200a15c: 90 10 00 01 mov %g1, %o0
else
return the_node->parent->child[RBT_LEFT];
}
200a160: 90 10 00 01 mov %g1, %o0
200a164: 81 c3 e0 08 retl
0203f044 <_Rate_monotonic_Get_status>:
bool _Rate_monotonic_Get_status(
Rate_monotonic_Control *the_period,
Rate_monotonic_Period_time_t *wall_since_last_period,
Thread_CPU_usage_t *cpu_since_last_period
)
{
203f044: 9d e3 bf 98 save %sp, -104, %sp
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
Timestamp_Control uptime;
#endif
Thread_Control *owning_thread = the_period->owner;
203f048: f6 06 20 40 ld [ %i0 + 0x40 ], %i3
/*
* Determine elapsed wall time since period initiated.
*/
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
_TOD_Get_uptime( &uptime );
203f04c: 7f ff b0 d9 call 202b3b0 <_TOD_Get_uptime>
203f050: 90 07 bf f8 add %fp, -8, %o0
const Timestamp64_Control *_start,
const Timestamp64_Control *_end,
Timestamp64_Control *_result
)
{
*_result = *_end - *_start;
203f054: c4 1e 20 50 ldd [ %i0 + 0x50 ], %g2
_Timestamp_Subtract(
203f058: d8 1f bf f8 ldd [ %fp + -8 ], %o4
if (used < the_period->cpu_usage_period_initiated)
return false;
*cpu_since_last_period = used - the_period->cpu_usage_period_initiated;
#endif
return true;
203f05c: 82 10 20 01 mov 1, %g1
203f060: 86 a3 40 03 subcc %o5, %g3, %g3
203f064: 84 63 00 02 subx %o4, %g2, %g2
203f068: c4 3e 40 00 std %g2, [ %i1 ]
* Determine cpu usage since period initiated.
*/
used = owning_thread->cpu_time_used;
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
if (owning_thread == _Thread_Executing) {
203f06c: 05 00 81 bf sethi %hi(0x206fc00), %g2
203f070: 84 10 a0 b0 or %g2, 0xb0, %g2 ! 206fcb0 <_Per_CPU_Information>
203f074: c6 00 a0 0c ld [ %g2 + 0xc ], %g3
203f078: 80 a6 c0 03 cmp %i3, %g3
203f07c: 12 80 00 15 bne 203f0d0 <_Rate_monotonic_Get_status+0x8c>
203f080: f8 1e e0 80 ldd [ %i3 + 0x80 ], %i4
203f084: c4 18 a0 20 ldd [ %g2 + 0x20 ], %g2
203f088: 9a a3 40 03 subcc %o5, %g3, %o5
203f08c: 98 63 00 02 subx %o4, %g2, %o4
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
203f090: c4 1e 20 48 ldd [ %i0 + 0x48 ], %g2
static inline void _Timestamp64_implementation_Add_to(
Timestamp64_Control *_time,
const Timestamp64_Control *_add
)
{
*_time += *_add;
203f094: ba 87 40 0d addcc %i5, %o5, %i5
203f098: b8 47 00 0c addx %i4, %o4, %i4
/*
* The cpu usage info was reset while executing. Can't
* determine a status.
*/
if (_Timestamp_Less_than(&used, &the_period->cpu_usage_period_initiated))
203f09c: 80 a0 80 1c cmp %g2, %i4
203f0a0: 34 80 00 0c bg,a 203f0d0 <_Rate_monotonic_Get_status+0x8c><== NEVER TAKEN
203f0a4: 82 10 20 00 clr %g1 <== NOT EXECUTED
203f0a8: 32 80 00 06 bne,a 203f0c0 <_Rate_monotonic_Get_status+0x7c>
203f0ac: 86 a7 40 03 subcc %i5, %g3, %g3
203f0b0: 80 a0 c0 1d cmp %g3, %i5
203f0b4: 18 80 00 06 bgu 203f0cc <_Rate_monotonic_Get_status+0x88>
203f0b8: 86 a7 40 03 subcc %i5, %g3, %g3
if (used < the_period->cpu_usage_period_initiated)
return false;
*cpu_since_last_period = used - the_period->cpu_usage_period_initiated;
#endif
return true;
203f0bc: 82 10 20 01 mov 1, %g1
const Timestamp64_Control *_start,
const Timestamp64_Control *_end,
Timestamp64_Control *_result
)
{
*_result = *_end - *_start;
203f0c0: 84 67 00 02 subx %i4, %g2, %g2
203f0c4: 10 80 00 03 b 203f0d0 <_Rate_monotonic_Get_status+0x8c>
203f0c8: c4 3e 80 00 std %g2, [ %i2 ]
/*
* The cpu usage info was reset while executing. Can't
* determine a status.
*/
if (_Timestamp_Less_than(&used, &the_period->cpu_usage_period_initiated))
return false;
203f0cc: 82 10 20 00 clr %g1
return false;
*cpu_since_last_period = used - the_period->cpu_usage_period_initiated;
#endif
return true;
}
203f0d0: b0 08 60 01 and %g1, 1, %i0
203f0d4: 81 c7 e0 08 ret
203f0d8: 81 e8 00 00 restore
0203f43c <_Rate_monotonic_Timeout>:
void _Rate_monotonic_Timeout(
Objects_Id id,
void *ignored
)
{
203f43c: 9d e3 bf 98 save %sp, -104, %sp
203f440: 11 00 81 c0 sethi %hi(0x2070000), %o0
203f444: 92 10 00 18 mov %i0, %o1
203f448: 90 12 23 20 or %o0, 0x320, %o0
203f44c: 7f ff 3f 84 call 200f25c <_Objects_Get>
203f450: 94 07 bf fc add %fp, -4, %o2
/*
* 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 ) {
203f454: c2 07 bf fc ld [ %fp + -4 ], %g1
203f458: 80 a0 60 00 cmp %g1, 0
203f45c: 12 80 00 25 bne 203f4f0 <_Rate_monotonic_Timeout+0xb4> <== NEVER TAKEN
203f460: ba 10 00 08 mov %o0, %i5
case OBJECTS_LOCAL:
the_thread = the_period->owner;
203f464: d0 02 20 40 ld [ %o0 + 0x40 ], %o0
if ( _States_Is_waiting_for_period( the_thread->current_state ) &&
203f468: 03 00 00 10 sethi %hi(0x4000), %g1
*/
RTEMS_INLINE_ROUTINE bool _States_Is_waiting_for_period (
States_Control the_states
)
{
return (the_states & STATES_WAITING_FOR_PERIOD);
203f46c: c4 02 20 10 ld [ %o0 + 0x10 ], %g2
203f470: 80 88 80 01 btst %g2, %g1
203f474: 22 80 00 0b be,a 203f4a0 <_Rate_monotonic_Timeout+0x64>
203f478: c2 07 60 38 ld [ %i5 + 0x38 ], %g1
203f47c: c4 02 20 20 ld [ %o0 + 0x20 ], %g2
203f480: c2 07 60 08 ld [ %i5 + 8 ], %g1
203f484: 80 a0 80 01 cmp %g2, %g1
203f488: 32 80 00 06 bne,a 203f4a0 <_Rate_monotonic_Timeout+0x64>
203f48c: c2 07 60 38 ld [ %i5 + 0x38 ], %g1
RTEMS_INLINE_ROUTINE void _Thread_Unblock (
Thread_Control *the_thread
)
{
_Thread_Clear_state( the_thread, STATES_BLOCKED );
203f490: 13 04 00 ff sethi %hi(0x1003fc00), %o1
203f494: 7f ff 42 4a call 200fdbc <_Thread_Clear_state>
203f498: 92 12 63 f8 or %o1, 0x3f8, %o1 ! 1003fff8 <RAM_END+0xdc3fff8>
203f49c: 30 80 00 06 b,a 203f4b4 <_Rate_monotonic_Timeout+0x78>
_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 ) {
203f4a0: 80 a0 60 01 cmp %g1, 1
203f4a4: 12 80 00 0d bne 203f4d8 <_Rate_monotonic_Timeout+0x9c>
203f4a8: 82 10 20 04 mov 4, %g1
the_period->state = RATE_MONOTONIC_EXPIRED_WHILE_BLOCKING;
203f4ac: 82 10 20 03 mov 3, %g1
203f4b0: c2 27 60 38 st %g1, [ %i5 + 0x38 ]
_Rate_monotonic_Initiate_statistics( the_period );
203f4b4: 7f ff ff 53 call 203f200 <_Rate_monotonic_Initiate_statistics>
203f4b8: 90 10 00 1d mov %i5, %o0
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
203f4bc: c2 07 60 3c ld [ %i5 + 0x3c ], %g1
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
203f4c0: 11 00 81 be sethi %hi(0x206f800), %o0
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
203f4c4: c2 27 60 1c st %g1, [ %i5 + 0x1c ]
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
203f4c8: 90 12 20 28 or %o0, 0x28, %o0
203f4cc: 7f ff 46 67 call 2010e68 <_Watchdog_Insert>
203f4d0: 92 07 60 10 add %i5, 0x10, %o1
203f4d4: 30 80 00 02 b,a 203f4dc <_Rate_monotonic_Timeout+0xa0>
_Watchdog_Insert_ticks( &the_period->Timer, the_period->next_length );
} else
the_period->state = RATE_MONOTONIC_EXPIRED;
203f4d8: c2 27 60 38 st %g1, [ %i5 + 0x38 ]
*
* This routine decrements the thread dispatch level.
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_decrement_disable_level(void)
{
_Thread_Dispatch_disable_level--;
203f4dc: 03 00 81 bd sethi %hi(0x206f400), %g1
203f4e0: c4 00 63 80 ld [ %g1 + 0x380 ], %g2 ! 206f780 <_Thread_Dispatch_disable_level>
203f4e4: 84 00 bf ff add %g2, -1, %g2
203f4e8: c4 20 63 80 st %g2, [ %g1 + 0x380 ]
return _Thread_Dispatch_disable_level;
203f4ec: c2 00 63 80 ld [ %g1 + 0x380 ], %g1
203f4f0: 81 c7 e0 08 ret
203f4f4: 81 e8 00 00 restore
0203f0dc <_Rate_monotonic_Update_statistics>:
}
static void _Rate_monotonic_Update_statistics(
Rate_monotonic_Control *the_period
)
{
203f0dc: 9d e3 bf 90 save %sp, -112, %sp
/*
* Update the counts.
*/
stats = &the_period->Statistics;
stats->count++;
203f0e0: c2 06 20 58 ld [ %i0 + 0x58 ], %g1
203f0e4: 82 00 60 01 inc %g1
203f0e8: c2 26 20 58 st %g1, [ %i0 + 0x58 ]
if ( the_period->state == RATE_MONOTONIC_EXPIRED )
203f0ec: c2 06 20 38 ld [ %i0 + 0x38 ], %g1
203f0f0: 80 a0 60 04 cmp %g1, 4
203f0f4: 12 80 00 05 bne 203f108 <_Rate_monotonic_Update_statistics+0x2c>
203f0f8: 90 10 00 18 mov %i0, %o0
stats->missed_count++;
203f0fc: c2 06 20 5c ld [ %i0 + 0x5c ], %g1
203f100: 82 00 60 01 inc %g1
203f104: c2 26 20 5c st %g1, [ %i0 + 0x5c ]
/*
* Grab status for time statistics.
*/
valid_status =
203f108: 92 07 bf f8 add %fp, -8, %o1
203f10c: 7f ff ff ce call 203f044 <_Rate_monotonic_Get_status>
203f110: 94 07 bf f0 add %fp, -16, %o2
_Rate_monotonic_Get_status( the_period, &since_last_period, &executed );
if (!valid_status)
203f114: 80 8a 20 ff btst 0xff, %o0
203f118: 02 80 00 38 be 203f1f8 <_Rate_monotonic_Update_statistics+0x11c>
203f11c: c4 1f bf f0 ldd [ %fp + -16 ], %g2
static inline void _Timestamp64_implementation_Add_to(
Timestamp64_Control *_time,
const Timestamp64_Control *_add
)
{
*_time += *_add;
203f120: f8 1e 20 70 ldd [ %i0 + 0x70 ], %i4
* Update CPU time
*/
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
_Timestamp_Add_to( &stats->total_cpu_time, &executed );
if ( _Timestamp_Less_than( &executed, &stats->min_cpu_time ) )
203f124: c2 06 20 60 ld [ %i0 + 0x60 ], %g1
203f128: ba 87 40 03 addcc %i5, %g3, %i5
203f12c: b8 47 00 02 addx %i4, %g2, %i4
203f130: 80 a0 40 02 cmp %g1, %g2
203f134: 14 80 00 09 bg 203f158 <_Rate_monotonic_Update_statistics+0x7c>
203f138: f8 3e 20 70 std %i4, [ %i0 + 0x70 ]
203f13c: 80 a0 40 02 cmp %g1, %g2
203f140: 32 80 00 08 bne,a 203f160 <_Rate_monotonic_Update_statistics+0x84><== NEVER TAKEN
203f144: c2 06 20 68 ld [ %i0 + 0x68 ], %g1 <== NOT EXECUTED
203f148: c2 06 20 64 ld [ %i0 + 0x64 ], %g1
203f14c: 80 a0 40 03 cmp %g1, %g3
203f150: 28 80 00 04 bleu,a 203f160 <_Rate_monotonic_Update_statistics+0x84>
203f154: c2 06 20 68 ld [ %i0 + 0x68 ], %g1
stats->min_cpu_time = executed;
203f158: c4 3e 20 60 std %g2, [ %i0 + 0x60 ]
if ( _Timestamp_Greater_than( &executed, &stats->max_cpu_time ) )
203f15c: c2 06 20 68 ld [ %i0 + 0x68 ], %g1
203f160: 80 a0 40 02 cmp %g1, %g2
203f164: 26 80 00 0a bl,a 203f18c <_Rate_monotonic_Update_statistics+0xb0><== NEVER TAKEN
203f168: c4 3e 20 68 std %g2, [ %i0 + 0x68 ] <== NOT EXECUTED
203f16c: 80 a0 40 02 cmp %g1, %g2
203f170: 32 80 00 08 bne,a 203f190 <_Rate_monotonic_Update_statistics+0xb4><== NEVER TAKEN
203f174: c4 1f bf f8 ldd [ %fp + -8 ], %g2 <== NOT EXECUTED
203f178: c2 06 20 6c ld [ %i0 + 0x6c ], %g1
203f17c: 80 a0 40 03 cmp %g1, %g3
203f180: 3a 80 00 04 bcc,a 203f190 <_Rate_monotonic_Update_statistics+0xb4>
203f184: c4 1f bf f8 ldd [ %fp + -8 ], %g2
stats->max_cpu_time = executed;
203f188: c4 3e 20 68 std %g2, [ %i0 + 0x68 ]
/*
* Update Wall time
*/
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
_Timestamp_Add_to( &stats->total_wall_time, &since_last_period );
203f18c: c4 1f bf f8 ldd [ %fp + -8 ], %g2
203f190: f8 1e 20 88 ldd [ %i0 + 0x88 ], %i4
if ( _Timestamp_Less_than( &since_last_period, &stats->min_wall_time ) )
203f194: c2 06 20 78 ld [ %i0 + 0x78 ], %g1
203f198: ba 87 40 03 addcc %i5, %g3, %i5
203f19c: b8 47 00 02 addx %i4, %g2, %i4
203f1a0: 80 a0 40 02 cmp %g1, %g2
203f1a4: 14 80 00 09 bg 203f1c8 <_Rate_monotonic_Update_statistics+0xec>
203f1a8: f8 3e 20 88 std %i4, [ %i0 + 0x88 ]
203f1ac: 80 a0 40 02 cmp %g1, %g2
203f1b0: 32 80 00 08 bne,a 203f1d0 <_Rate_monotonic_Update_statistics+0xf4><== NEVER TAKEN
203f1b4: c2 06 20 80 ld [ %i0 + 0x80 ], %g1 <== NOT EXECUTED
203f1b8: c2 06 20 7c ld [ %i0 + 0x7c ], %g1
203f1bc: 80 a0 40 03 cmp %g1, %g3
203f1c0: 28 80 00 04 bleu,a 203f1d0 <_Rate_monotonic_Update_statistics+0xf4>
203f1c4: c2 06 20 80 ld [ %i0 + 0x80 ], %g1
stats->min_wall_time = since_last_period;
203f1c8: c4 3e 20 78 std %g2, [ %i0 + 0x78 ]
if ( _Timestamp_Greater_than( &since_last_period, &stats->max_wall_time ) )
203f1cc: c2 06 20 80 ld [ %i0 + 0x80 ], %g1
203f1d0: 80 a0 40 02 cmp %g1, %g2
203f1d4: 26 80 00 09 bl,a 203f1f8 <_Rate_monotonic_Update_statistics+0x11c><== NEVER TAKEN
203f1d8: c4 3e 20 80 std %g2, [ %i0 + 0x80 ] <== NOT EXECUTED
203f1dc: 80 a0 40 02 cmp %g1, %g2
203f1e0: 12 80 00 06 bne 203f1f8 <_Rate_monotonic_Update_statistics+0x11c><== NEVER TAKEN
203f1e4: 01 00 00 00 nop
203f1e8: c2 06 20 84 ld [ %i0 + 0x84 ], %g1
203f1ec: 80 a0 40 03 cmp %g1, %g3
203f1f0: 2a 80 00 02 bcs,a 203f1f8 <_Rate_monotonic_Update_statistics+0x11c>
203f1f4: c4 3e 20 80 std %g2, [ %i0 + 0x80 ]
203f1f8: 81 c7 e0 08 ret
203f1fc: 81 e8 00 00 restore
0200a19c <_Scheduler_CBS_Allocate>:
#include <rtems/score/wkspace.h>
void *_Scheduler_CBS_Allocate(
Thread_Control *the_thread
)
{
200a19c: 9d e3 bf a0 save %sp, -96, %sp
void *sched;
Scheduler_CBS_Per_thread *schinfo;
sched = _Workspace_Allocate(sizeof(Scheduler_CBS_Per_thread));
200a1a0: 40 00 06 ac call 200bc50 <_Workspace_Allocate>
200a1a4: 90 10 20 1c mov 0x1c, %o0
if ( sched ) {
200a1a8: 80 a2 20 00 cmp %o0, 0
200a1ac: 02 80 00 06 be 200a1c4 <_Scheduler_CBS_Allocate+0x28> <== NEVER TAKEN
200a1b0: 82 10 20 02 mov 2, %g1
the_thread->scheduler_info = sched;
200a1b4: d0 26 20 88 st %o0, [ %i0 + 0x88 ]
schinfo = (Scheduler_CBS_Per_thread *)(the_thread->scheduler_info);
schinfo->edf_per_thread.thread = the_thread;
200a1b8: f0 22 00 00 st %i0, [ %o0 ]
schinfo->edf_per_thread.queue_state = SCHEDULER_EDF_QUEUE_STATE_NEVER_HAS_BEEN;
200a1bc: c2 22 20 14 st %g1, [ %o0 + 0x14 ]
schinfo->cbs_server = NULL;
200a1c0: c0 22 20 18 clr [ %o0 + 0x18 ]
}
return sched;
}
200a1c4: 81 c7 e0 08 ret
200a1c8: 91 e8 00 08 restore %g0, %o0, %o0
0200b518 <_Scheduler_CBS_Budget_callout>:
Scheduler_CBS_Server **_Scheduler_CBS_Server_list;
void _Scheduler_CBS_Budget_callout(
Thread_Control *the_thread
)
{
200b518: 9d e3 bf 98 save %sp, -104, %sp
Priority_Control new_priority;
Scheduler_CBS_Per_thread *sched_info;
Scheduler_CBS_Server_id server_id;
/* Put violating task to background until the end of period. */
new_priority = the_thread->Start.initial_priority;
200b51c: d2 06 20 ac ld [ %i0 + 0xac ], %o1
if ( the_thread->real_priority != new_priority )
200b520: c2 06 20 18 ld [ %i0 + 0x18 ], %g1
200b524: 80 a0 40 09 cmp %g1, %o1
200b528: 32 80 00 02 bne,a 200b530 <_Scheduler_CBS_Budget_callout+0x18><== ALWAYS TAKEN
200b52c: d2 26 20 18 st %o1, [ %i0 + 0x18 ]
the_thread->real_priority = new_priority;
if ( the_thread->current_priority != new_priority )
200b530: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
200b534: 80 a0 40 09 cmp %g1, %o1
200b538: 02 80 00 04 be 200b548 <_Scheduler_CBS_Budget_callout+0x30><== NEVER TAKEN
200b53c: 90 10 00 18 mov %i0, %o0
_Thread_Change_priority(the_thread, new_priority, true);
200b540: 40 00 01 83 call 200bb4c <_Thread_Change_priority>
200b544: 94 10 20 01 mov 1, %o2
/* Invoke callback function if any. */
sched_info = (Scheduler_CBS_Per_thread *) the_thread->scheduler_info;
200b548: fa 06 20 88 ld [ %i0 + 0x88 ], %i5
if ( sched_info->cbs_server->cbs_budget_overrun ) {
200b54c: c2 07 60 18 ld [ %i5 + 0x18 ], %g1
200b550: c4 00 60 0c ld [ %g1 + 0xc ], %g2
200b554: 80 a0 a0 00 cmp %g2, 0
200b558: 02 80 00 09 be 200b57c <_Scheduler_CBS_Budget_callout+0x64><== NEVER TAKEN
200b55c: 01 00 00 00 nop
_Scheduler_CBS_Get_server_id(
200b560: d0 00 40 00 ld [ %g1 ], %o0
200b564: 7f ff ff d7 call 200b4c0 <_Scheduler_CBS_Get_server_id>
200b568: 92 07 bf fc add %fp, -4, %o1
sched_info->cbs_server->task_id,
&server_id
);
sched_info->cbs_server->cbs_budget_overrun( server_id );
200b56c: c2 07 60 18 ld [ %i5 + 0x18 ], %g1
200b570: c2 00 60 0c ld [ %g1 + 0xc ], %g1
200b574: 9f c0 40 00 call %g1
200b578: d0 07 bf fc ld [ %fp + -4 ], %o0
200b57c: 81 c7 e0 08 ret
200b580: 81 e8 00 00 restore
0200b120 <_Scheduler_CBS_Create_server>:
int _Scheduler_CBS_Create_server (
Scheduler_CBS_Parameters *params,
Scheduler_CBS_Budget_overrun budget_overrun_callback,
rtems_id *server_id
)
{
200b120: 9d e3 bf a0 save %sp, -96, %sp
unsigned int i;
Scheduler_CBS_Server *the_server;
if ( params->budget <= 0 ||
200b124: c2 06 20 04 ld [ %i0 + 4 ], %g1
200b128: 80 a0 60 00 cmp %g1, 0
200b12c: 04 80 00 1d ble 200b1a0 <_Scheduler_CBS_Create_server+0x80>
200b130: 01 00 00 00 nop
200b134: c2 06 00 00 ld [ %i0 ], %g1
200b138: 80 a0 60 00 cmp %g1, 0
200b13c: 04 80 00 19 ble 200b1a0 <_Scheduler_CBS_Create_server+0x80>
200b140: 03 00 80 81 sethi %hi(0x2020400), %g1
params->deadline <= 0 ||
params->budget >= SCHEDULER_EDF_PRIO_MSB ||
params->deadline >= SCHEDULER_EDF_PRIO_MSB )
return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;
for ( i = 0; i<_Scheduler_CBS_Maximum_servers; i++ ) {
200b144: c4 00 60 bc ld [ %g1 + 0xbc ], %g2 ! 20204bc <_Scheduler_CBS_Maximum_servers>
if ( !_Scheduler_CBS_Server_list[i] )
200b148: 03 00 80 85 sethi %hi(0x2021400), %g1
200b14c: c6 00 63 88 ld [ %g1 + 0x388 ], %g3 ! 2021788 <_Scheduler_CBS_Server_list>
200b150: 10 80 00 07 b 200b16c <_Scheduler_CBS_Create_server+0x4c>
200b154: 82 10 20 00 clr %g1
200b158: c8 00 c0 1c ld [ %g3 + %i4 ], %g4
200b15c: 80 a1 20 00 cmp %g4, 0
200b160: 02 80 00 14 be 200b1b0 <_Scheduler_CBS_Create_server+0x90>
200b164: 3b 00 80 85 sethi %hi(0x2021400), %i5
params->deadline <= 0 ||
params->budget >= SCHEDULER_EDF_PRIO_MSB ||
params->deadline >= SCHEDULER_EDF_PRIO_MSB )
return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;
for ( i = 0; i<_Scheduler_CBS_Maximum_servers; i++ ) {
200b168: 82 00 60 01 inc %g1
200b16c: 80 a0 40 02 cmp %g1, %g2
200b170: 12 bf ff fa bne 200b158 <_Scheduler_CBS_Create_server+0x38>
200b174: b9 28 60 02 sll %g1, 2, %i4
if ( !_Scheduler_CBS_Server_list[i] )
break;
}
if ( i == _Scheduler_CBS_Maximum_servers )
return SCHEDULER_CBS_ERROR_FULL;
200b178: 81 c7 e0 08 ret
200b17c: 91 e8 3f e6 restore %g0, -26, %o0
_Workspace_Allocate( sizeof(Scheduler_CBS_Server) );
the_server = _Scheduler_CBS_Server_list[*server_id];
if ( !the_server )
return SCHEDULER_CBS_ERROR_NO_MEMORY;
the_server->parameters = *params;
200b180: c4 20 60 04 st %g2, [ %g1 + 4 ]
200b184: c4 06 20 04 ld [ %i0 + 4 ], %g2
the_server->task_id = -1;
the_server->cbs_budget_overrun = budget_overrun_callback;
200b188: f2 20 60 0c st %i1, [ %g1 + 0xc ]
_Workspace_Allocate( sizeof(Scheduler_CBS_Server) );
the_server = _Scheduler_CBS_Server_list[*server_id];
if ( !the_server )
return SCHEDULER_CBS_ERROR_NO_MEMORY;
the_server->parameters = *params;
200b18c: c4 20 60 08 st %g2, [ %g1 + 8 ]
the_server->task_id = -1;
200b190: 84 10 3f ff mov -1, %g2
200b194: c4 20 40 00 st %g2, [ %g1 ]
the_server->cbs_budget_overrun = budget_overrun_callback;
return SCHEDULER_CBS_OK;
200b198: 81 c7 e0 08 ret
200b19c: 91 e8 20 00 restore %g0, 0, %o0
if ( params->budget <= 0 ||
params->deadline <= 0 ||
params->budget >= SCHEDULER_EDF_PRIO_MSB ||
params->deadline >= SCHEDULER_EDF_PRIO_MSB )
return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;
200b1a0: 81 c7 e0 08 ret
200b1a4: 91 e8 3f ee restore %g0, -18, %o0
*server_id = i;
_Scheduler_CBS_Server_list[*server_id] = (Scheduler_CBS_Server *)
_Workspace_Allocate( sizeof(Scheduler_CBS_Server) );
the_server = _Scheduler_CBS_Server_list[*server_id];
if ( !the_server )
return SCHEDULER_CBS_ERROR_NO_MEMORY;
200b1a8: 81 c7 e0 08 ret <== NOT EXECUTED
200b1ac: 91 e8 3f ef restore %g0, -17, %o0 <== NOT EXECUTED
if ( i == _Scheduler_CBS_Maximum_servers )
return SCHEDULER_CBS_ERROR_FULL;
*server_id = i;
_Scheduler_CBS_Server_list[*server_id] = (Scheduler_CBS_Server *)
200b1b0: f6 07 63 88 ld [ %i5 + 0x388 ], %i3
}
if ( i == _Scheduler_CBS_Maximum_servers )
return SCHEDULER_CBS_ERROR_FULL;
*server_id = i;
200b1b4: c2 26 80 00 st %g1, [ %i2 ]
_Scheduler_CBS_Server_list[*server_id] = (Scheduler_CBS_Server *)
_Workspace_Allocate( sizeof(Scheduler_CBS_Server) );
200b1b8: 40 00 07 9e call 200d030 <_Workspace_Allocate>
200b1bc: 90 10 20 10 mov 0x10, %o0
the_server = _Scheduler_CBS_Server_list[*server_id];
200b1c0: c2 06 80 00 ld [ %i2 ], %g1
if ( i == _Scheduler_CBS_Maximum_servers )
return SCHEDULER_CBS_ERROR_FULL;
*server_id = i;
_Scheduler_CBS_Server_list[*server_id] = (Scheduler_CBS_Server *)
200b1c4: d0 26 c0 1c st %o0, [ %i3 + %i4 ]
_Workspace_Allocate( sizeof(Scheduler_CBS_Server) );
the_server = _Scheduler_CBS_Server_list[*server_id];
200b1c8: c4 07 63 88 ld [ %i5 + 0x388 ], %g2
200b1cc: 83 28 60 02 sll %g1, 2, %g1
200b1d0: c2 00 80 01 ld [ %g2 + %g1 ], %g1
if ( !the_server )
200b1d4: 80 a0 60 00 cmp %g1, 0
200b1d8: 32 bf ff ea bne,a 200b180 <_Scheduler_CBS_Create_server+0x60><== ALWAYS TAKEN
200b1dc: c4 06 00 00 ld [ %i0 ], %g2
200b1e0: 30 bf ff f2 b,a 200b1a8 <_Scheduler_CBS_Create_server+0x88><== NOT EXECUTED
0200b258 <_Scheduler_CBS_Detach_thread>:
int _Scheduler_CBS_Detach_thread (
Scheduler_CBS_Server_id server_id,
rtems_id task_id
)
{
200b258: 9d e3 bf 98 save %sp, -104, %sp
Objects_Locations location;
Thread_Control *the_thread;
Scheduler_CBS_Per_thread *sched_info;
the_thread = _Thread_Get(task_id, &location);
200b25c: 90 10 00 19 mov %i1, %o0
200b260: 40 00 03 6d call 200c014 <_Thread_Get>
200b264: 92 07 bf fc add %fp, -4, %o1
/* The routine _Thread_Get may disable dispatch and not enable again. */
if ( the_thread ) {
200b268: ba 92 20 00 orcc %o0, 0, %i5
200b26c: 02 80 00 05 be 200b280 <_Scheduler_CBS_Detach_thread+0x28>
200b270: 03 00 80 81 sethi %hi(0x2020400), %g1
_Thread_Enable_dispatch();
200b274: 40 00 03 5b call 200bfe0 <_Thread_Enable_dispatch>
200b278: 01 00 00 00 nop
}
if ( server_id >= _Scheduler_CBS_Maximum_servers )
200b27c: 03 00 80 81 sethi %hi(0x2020400), %g1
200b280: c2 00 60 bc ld [ %g1 + 0xbc ], %g1 ! 20204bc <_Scheduler_CBS_Maximum_servers>
200b284: 80 a6 00 01 cmp %i0, %g1
200b288: 1a 80 00 1b bcc 200b2f4 <_Scheduler_CBS_Detach_thread+0x9c>
200b28c: 80 a7 60 00 cmp %i5, 0
return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;
if ( !the_thread )
200b290: 02 80 00 19 be 200b2f4 <_Scheduler_CBS_Detach_thread+0x9c>
200b294: 03 00 80 85 sethi %hi(0x2021400), %g1
return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;
/* Server is not valid. */
if ( !_Scheduler_CBS_Server_list[server_id] )
200b298: c2 00 63 88 ld [ %g1 + 0x388 ], %g1 ! 2021788 <_Scheduler_CBS_Server_list>
200b29c: b1 2e 20 02 sll %i0, 2, %i0
200b2a0: c2 00 40 18 ld [ %g1 + %i0 ], %g1
200b2a4: 80 a0 60 00 cmp %g1, 0
200b2a8: 02 80 00 11 be 200b2ec <_Scheduler_CBS_Detach_thread+0x94>
200b2ac: 01 00 00 00 nop
return SCHEDULER_CBS_ERROR_NOSERVER;
/* Thread and server are not attached. */
if ( _Scheduler_CBS_Server_list[server_id]->task_id != task_id )
200b2b0: c4 00 40 00 ld [ %g1 ], %g2
200b2b4: 80 a0 80 19 cmp %g2, %i1
200b2b8: 12 80 00 0f bne 200b2f4 <_Scheduler_CBS_Detach_thread+0x9c><== NEVER TAKEN
200b2bc: 84 10 3f ff mov -1, %g2
return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;
_Scheduler_CBS_Server_list[server_id]->task_id = -1;
200b2c0: c4 20 40 00 st %g2, [ %g1 ]
sched_info = (Scheduler_CBS_Per_thread *) the_thread->scheduler_info;
sched_info->cbs_server = NULL;
200b2c4: c2 07 60 88 ld [ %i5 + 0x88 ], %g1
200b2c8: c0 20 60 18 clr [ %g1 + 0x18 ]
the_thread->budget_algorithm = the_thread->Start.budget_algorithm;
200b2cc: c2 07 60 a0 ld [ %i5 + 0xa0 ], %g1
200b2d0: c2 27 60 78 st %g1, [ %i5 + 0x78 ]
the_thread->budget_callout = the_thread->Start.budget_callout;
200b2d4: c2 07 60 a4 ld [ %i5 + 0xa4 ], %g1
200b2d8: c2 27 60 7c st %g1, [ %i5 + 0x7c ]
the_thread->is_preemptible = the_thread->Start.is_preemptible;
200b2dc: c2 0f 60 9c ldub [ %i5 + 0x9c ], %g1
200b2e0: c2 2f 60 70 stb %g1, [ %i5 + 0x70 ]
return SCHEDULER_CBS_OK;
200b2e4: 81 c7 e0 08 ret
200b2e8: 91 e8 20 00 restore %g0, 0, %o0
return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;
if ( !the_thread )
return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;
/* Server is not valid. */
if ( !_Scheduler_CBS_Server_list[server_id] )
return SCHEDULER_CBS_ERROR_NOSERVER;
200b2ec: 81 c7 e0 08 ret
200b2f0: 91 e8 3f e7 restore %g0, -25, %o0
the_thread->budget_algorithm = the_thread->Start.budget_algorithm;
the_thread->budget_callout = the_thread->Start.budget_callout;
the_thread->is_preemptible = the_thread->Start.is_preemptible;
return SCHEDULER_CBS_OK;
}
200b2f4: 81 c7 e0 08 ret
200b2f8: 91 e8 3f ee restore %g0, -18, %o0
0200b584 <_Scheduler_CBS_Initialize>:
}
}
int _Scheduler_CBS_Initialize(void)
{
200b584: 9d e3 bf a0 save %sp, -96, %sp
unsigned int i;
_Scheduler_CBS_Server_list = (Scheduler_CBS_Server **) _Workspace_Allocate(
_Scheduler_CBS_Maximum_servers * sizeof(Scheduler_CBS_Server*) );
200b588: 3b 00 80 81 sethi %hi(0x2020400), %i5
200b58c: d0 07 60 bc ld [ %i5 + 0xbc ], %o0 ! 20204bc <_Scheduler_CBS_Maximum_servers>
}
int _Scheduler_CBS_Initialize(void)
{
unsigned int i;
_Scheduler_CBS_Server_list = (Scheduler_CBS_Server **) _Workspace_Allocate(
200b590: 40 00 06 a8 call 200d030 <_Workspace_Allocate>
200b594: 91 2a 20 02 sll %o0, 2, %o0
200b598: 05 00 80 85 sethi %hi(0x2021400), %g2
_Scheduler_CBS_Maximum_servers * sizeof(Scheduler_CBS_Server*) );
if ( !_Scheduler_CBS_Server_list )
200b59c: 80 a2 20 00 cmp %o0, 0
200b5a0: 02 80 00 0d be 200b5d4 <_Scheduler_CBS_Initialize+0x50> <== NEVER TAKEN
200b5a4: d0 20 a3 88 st %o0, [ %g2 + 0x388 ]
return SCHEDULER_CBS_ERROR_NO_MEMORY;
for (i = 0; i<_Scheduler_CBS_Maximum_servers; i++) {
200b5a8: c6 07 60 bc ld [ %i5 + 0xbc ], %g3
200b5ac: 10 80 00 05 b 200b5c0 <_Scheduler_CBS_Initialize+0x3c>
200b5b0: 82 10 20 00 clr %g1
_Scheduler_CBS_Server_list[i] = NULL;
200b5b4: 89 28 60 02 sll %g1, 2, %g4
unsigned int i;
_Scheduler_CBS_Server_list = (Scheduler_CBS_Server **) _Workspace_Allocate(
_Scheduler_CBS_Maximum_servers * sizeof(Scheduler_CBS_Server*) );
if ( !_Scheduler_CBS_Server_list )
return SCHEDULER_CBS_ERROR_NO_MEMORY;
for (i = 0; i<_Scheduler_CBS_Maximum_servers; i++) {
200b5b8: 82 00 60 01 inc %g1
_Scheduler_CBS_Server_list[i] = NULL;
200b5bc: c0 27 40 04 clr [ %i5 + %g4 ]
unsigned int i;
_Scheduler_CBS_Server_list = (Scheduler_CBS_Server **) _Workspace_Allocate(
_Scheduler_CBS_Maximum_servers * sizeof(Scheduler_CBS_Server*) );
if ( !_Scheduler_CBS_Server_list )
return SCHEDULER_CBS_ERROR_NO_MEMORY;
for (i = 0; i<_Scheduler_CBS_Maximum_servers; i++) {
200b5c0: 80 a0 40 03 cmp %g1, %g3
200b5c4: 12 bf ff fc bne 200b5b4 <_Scheduler_CBS_Initialize+0x30>
200b5c8: fa 00 a3 88 ld [ %g2 + 0x388 ], %i5
_Scheduler_CBS_Server_list[i] = NULL;
}
return SCHEDULER_CBS_OK;
200b5cc: 81 c7 e0 08 ret
200b5d0: 91 e8 20 00 restore %g0, 0, %o0
}
200b5d4: 81 c7 e0 08 ret <== NOT EXECUTED
200b5d8: 91 e8 3f ef restore %g0, -17, %o0 <== NOT EXECUTED
0200a1cc <_Scheduler_CBS_Release_job>:
{
Priority_Control new_priority;
Scheduler_CBS_Per_thread *sched_info =
(Scheduler_CBS_Per_thread *) the_thread->scheduler_info;
Scheduler_CBS_Server *serv_info =
(Scheduler_CBS_Server *) sched_info->cbs_server;
200a1cc: c2 02 20 88 ld [ %o0 + 0x88 ], %g1
if (deadline) {
200a1d0: 80 a2 60 00 cmp %o1, 0
200a1d4: 02 80 00 10 be 200a214 <_Scheduler_CBS_Release_job+0x48>
200a1d8: c2 00 60 18 ld [ %g1 + 0x18 ], %g1
/* Initializing or shifting deadline. */
if (serv_info)
200a1dc: 80 a0 60 00 cmp %g1, 0
200a1e0: 02 80 00 08 be 200a200 <_Scheduler_CBS_Release_job+0x34>
200a1e4: 05 00 80 7d sethi %hi(0x201f400), %g2
new_priority = (_Watchdog_Ticks_since_boot + serv_info->parameters.deadline)
200a1e8: d2 00 a3 e8 ld [ %g2 + 0x3e8 ], %o1 ! 201f7e8 <_Watchdog_Ticks_since_boot>
200a1ec: c4 00 60 04 ld [ %g1 + 4 ], %g2
200a1f0: 92 02 40 02 add %o1, %g2, %o1
200a1f4: 05 20 00 00 sethi %hi(0x80000000), %g2
200a1f8: 10 80 00 0a b 200a220 <_Scheduler_CBS_Release_job+0x54>
200a1fc: 92 2a 40 02 andn %o1, %g2, %o1
& ~SCHEDULER_EDF_PRIO_MSB;
else
new_priority = (_Watchdog_Ticks_since_boot + deadline)
200a200: c2 00 a3 e8 ld [ %g2 + 0x3e8 ], %g1
200a204: 92 02 40 01 add %o1, %g1, %o1
200a208: 03 20 00 00 sethi %hi(0x80000000), %g1
200a20c: 10 80 00 07 b 200a228 <_Scheduler_CBS_Release_job+0x5c>
200a210: 92 2a 40 01 andn %o1, %g1, %o1
/* Switch back to background priority. */
new_priority = the_thread->Start.initial_priority;
}
/* Budget replenishment for the next job. */
if (serv_info)
200a214: 80 a0 60 00 cmp %g1, 0
200a218: 02 80 00 04 be 200a228 <_Scheduler_CBS_Release_job+0x5c> <== NEVER TAKEN
200a21c: d2 02 20 ac ld [ %o0 + 0xac ], %o1
the_thread->cpu_time_budget = serv_info->parameters.budget;
200a220: c2 00 60 08 ld [ %g1 + 8 ], %g1
200a224: c2 22 20 74 st %g1, [ %o0 + 0x74 ]
the_thread->real_priority = new_priority;
200a228: d2 22 20 18 st %o1, [ %o0 + 0x18 ]
_Thread_Change_priority(the_thread, new_priority, true);
200a22c: 94 10 20 01 mov 1, %o2
200a230: 82 13 c0 00 mov %o7, %g1
200a234: 40 00 01 26 call 200a6cc <_Thread_Change_priority>
200a238: 9e 10 40 00 mov %g1, %o7
0200a23c <_Scheduler_CBS_Unblock>:
#include <rtems/score/schedulercbs.h>
void _Scheduler_CBS_Unblock(
Thread_Control *the_thread
)
{
200a23c: 9d e3 bf a0 save %sp, -96, %sp
Scheduler_CBS_Per_thread *sched_info;
Scheduler_CBS_Server *serv_info;
Priority_Control new_priority;
_Scheduler_EDF_Enqueue(the_thread);
200a240: 40 00 00 4c call 200a370 <_Scheduler_EDF_Enqueue>
200a244: 90 10 00 18 mov %i0, %o0
/* TODO: flash critical section? */
sched_info = (Scheduler_CBS_Per_thread *) the_thread->scheduler_info;
serv_info = (Scheduler_CBS_Server *) sched_info->cbs_server;
200a248: c2 06 20 88 ld [ %i0 + 0x88 ], %g1
200a24c: fa 00 60 18 ld [ %g1 + 0x18 ], %i5
* Late unblock rule for deadline-driven tasks. The remaining time to
* deadline must be sufficient to serve the remaining computation time
* without increased utilization of this task. It might cause a deadline
* miss of another task.
*/
if (serv_info) {
200a250: 80 a7 60 00 cmp %i5, 0
200a254: 02 80 00 18 be 200a2b4 <_Scheduler_CBS_Unblock+0x78>
200a258: 03 00 80 7d sethi %hi(0x201f400), %g1
time_t budget = serv_info->parameters.budget;
time_t deadline_left = the_thread->cpu_time_budget;
time_t budget_left = the_thread->real_priority -
_Watchdog_Ticks_since_boot;
if ( deadline*budget_left > budget*deadline_left ) {
200a25c: d2 07 60 04 ld [ %i5 + 4 ], %o1
*/
if (serv_info) {
time_t deadline = serv_info->parameters.deadline;
time_t budget = serv_info->parameters.budget;
time_t deadline_left = the_thread->cpu_time_budget;
time_t budget_left = the_thread->real_priority -
200a260: d0 00 63 e8 ld [ %g1 + 0x3e8 ], %o0
200a264: f8 06 20 18 ld [ %i0 + 0x18 ], %i4
_Watchdog_Ticks_since_boot;
if ( deadline*budget_left > budget*deadline_left ) {
200a268: 40 00 3f bd call 201a15c <.umul>
200a26c: 90 27 00 08 sub %i4, %o0, %o0
200a270: d2 06 20 74 ld [ %i0 + 0x74 ], %o1
200a274: b6 10 00 08 mov %o0, %i3
200a278: 40 00 3f b9 call 201a15c <.umul>
200a27c: d0 07 60 08 ld [ %i5 + 8 ], %o0
200a280: 80 a6 c0 08 cmp %i3, %o0
200a284: 24 80 00 0d ble,a 200a2b8 <_Scheduler_CBS_Unblock+0x7c>
200a288: 3b 00 80 7f sethi %hi(0x201fc00), %i5
/* Put late unblocked task to background until the end of period. */
new_priority = the_thread->Start.initial_priority;
200a28c: d2 06 20 ac ld [ %i0 + 0xac ], %o1
if ( the_thread->real_priority != new_priority )
200a290: 80 a7 00 09 cmp %i4, %o1
200a294: 32 80 00 02 bne,a 200a29c <_Scheduler_CBS_Unblock+0x60>
200a298: d2 26 20 18 st %o1, [ %i0 + 0x18 ]
the_thread->real_priority = new_priority;
if ( the_thread->current_priority != new_priority )
200a29c: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
200a2a0: 80 a0 40 09 cmp %g1, %o1
200a2a4: 02 80 00 04 be 200a2b4 <_Scheduler_CBS_Unblock+0x78>
200a2a8: 90 10 00 18 mov %i0, %o0
_Thread_Change_priority(the_thread, new_priority, true);
200a2ac: 40 00 01 08 call 200a6cc <_Thread_Change_priority>
200a2b0: 94 10 20 01 mov 1, %o2
* 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_higher_than( the_thread->current_priority,
200a2b4: 3b 00 80 7f sethi %hi(0x201fc00), %i5
200a2b8: ba 17 60 20 or %i5, 0x20, %i5 ! 201fc20 <_Per_CPU_Information>
200a2bc: c4 07 60 10 ld [ %i5 + 0x10 ], %g2
200a2c0: 03 00 80 7a sethi %hi(0x201e800), %g1
200a2c4: d0 06 20 14 ld [ %i0 + 0x14 ], %o0
200a2c8: c2 00 61 b0 ld [ %g1 + 0x1b0 ], %g1
200a2cc: 9f c0 40 00 call %g1
200a2d0: d2 00 a0 14 ld [ %g2 + 0x14 ], %o1
200a2d4: 80 a2 20 00 cmp %o0, 0
200a2d8: 04 80 00 0f ble 200a314 <_Scheduler_CBS_Unblock+0xd8>
200a2dc: 01 00 00 00 nop
_Thread_Heir->current_priority)) {
_Thread_Heir = the_thread;
if ( _Thread_Executing->is_preemptible ||
200a2e0: c2 07 60 0c ld [ %i5 + 0xc ], %g1
* 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_higher_than( the_thread->current_priority,
_Thread_Heir->current_priority)) {
_Thread_Heir = the_thread;
200a2e4: f0 27 60 10 st %i0, [ %i5 + 0x10 ]
if ( _Thread_Executing->is_preemptible ||
200a2e8: c2 08 60 70 ldub [ %g1 + 0x70 ], %g1
200a2ec: 80 a0 60 00 cmp %g1, 0
200a2f0: 12 80 00 06 bne 200a308 <_Scheduler_CBS_Unblock+0xcc>
200a2f4: 84 10 20 01 mov 1, %g2
200a2f8: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
200a2fc: 80 a0 60 00 cmp %g1, 0
200a300: 12 80 00 05 bne 200a314 <_Scheduler_CBS_Unblock+0xd8> <== ALWAYS TAKEN
200a304: 01 00 00 00 nop
the_thread->current_priority == 0 )
_Thread_Dispatch_necessary = true;
200a308: 03 00 80 7f sethi %hi(0x201fc00), %g1
200a30c: 82 10 60 20 or %g1, 0x20, %g1 ! 201fc20 <_Per_CPU_Information>
200a310: c4 28 60 18 stb %g2, [ %g1 + 0x18 ]
200a314: 81 c7 e0 08 ret
200a318: 81 e8 00 00 restore
0200a19c <_Scheduler_EDF_Allocate>:
#include <rtems/score/wkspace.h>
void *_Scheduler_EDF_Allocate(
Thread_Control *the_thread
)
{
200a19c: 9d e3 bf a0 save %sp, -96, %sp
void *sched;
Scheduler_EDF_Per_thread *schinfo;
sched = _Workspace_Allocate( sizeof(Scheduler_EDF_Per_thread) );
200a1a0: 40 00 06 81 call 200bba4 <_Workspace_Allocate>
200a1a4: 90 10 20 18 mov 0x18, %o0
if ( sched ) {
200a1a8: 80 a2 20 00 cmp %o0, 0
200a1ac: 02 80 00 05 be 200a1c0 <_Scheduler_EDF_Allocate+0x24> <== NEVER TAKEN
200a1b0: 82 10 20 02 mov 2, %g1
the_thread->scheduler_info = sched;
200a1b4: d0 26 20 88 st %o0, [ %i0 + 0x88 ]
schinfo = (Scheduler_EDF_Per_thread *)(the_thread->scheduler_info);
schinfo->thread = the_thread;
200a1b8: f0 22 00 00 st %i0, [ %o0 ]
schinfo->queue_state = SCHEDULER_EDF_QUEUE_STATE_NEVER_HAS_BEEN;
200a1bc: c2 22 20 14 st %g1, [ %o0 + 0x14 ]
}
return sched;
}
200a1c0: 81 c7 e0 08 ret
200a1c4: 91 e8 00 08 restore %g0, %o0, %o0
0200a364 <_Scheduler_EDF_Unblock>:
#include <rtems/score/scheduleredf.h>
void _Scheduler_EDF_Unblock(
Thread_Control *the_thread
)
{
200a364: 9d e3 bf a0 save %sp, -96, %sp
_Scheduler_EDF_Enqueue(the_thread);
200a368: 7f ff ff ad call 200a21c <_Scheduler_EDF_Enqueue>
200a36c: 90 10 00 18 mov %i0, %o0
* 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(
200a370: 3b 00 80 7e sethi %hi(0x201f800), %i5
200a374: ba 17 63 70 or %i5, 0x370, %i5 ! 201fb70 <_Per_CPU_Information>
200a378: c4 07 60 10 ld [ %i5 + 0x10 ], %g2
200a37c: 03 00 80 7a sethi %hi(0x201e800), %g1
200a380: d0 00 a0 14 ld [ %g2 + 0x14 ], %o0
200a384: c2 00 61 00 ld [ %g1 + 0x100 ], %g1
200a388: 9f c0 40 00 call %g1
200a38c: d2 06 20 14 ld [ %i0 + 0x14 ], %o1
200a390: 80 a2 20 00 cmp %o0, 0
200a394: 16 80 00 0f bge 200a3d0 <_Scheduler_EDF_Unblock+0x6c>
200a398: 01 00 00 00 nop
_Thread_Heir->current_priority,
the_thread->current_priority )) {
_Thread_Heir = the_thread;
if ( _Thread_Executing->is_preemptible ||
200a39c: c2 07 60 0c ld [ %i5 + 0xc ], %g1
* 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;
200a3a0: f0 27 60 10 st %i0, [ %i5 + 0x10 ]
if ( _Thread_Executing->is_preemptible ||
200a3a4: c2 08 60 70 ldub [ %g1 + 0x70 ], %g1
200a3a8: 80 a0 60 00 cmp %g1, 0
200a3ac: 12 80 00 06 bne 200a3c4 <_Scheduler_EDF_Unblock+0x60>
200a3b0: 84 10 20 01 mov 1, %g2
200a3b4: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
200a3b8: 80 a0 60 00 cmp %g1, 0
200a3bc: 12 80 00 05 bne 200a3d0 <_Scheduler_EDF_Unblock+0x6c> <== ALWAYS TAKEN
200a3c0: 01 00 00 00 nop
the_thread->current_priority == 0 )
_Thread_Dispatch_necessary = true;
200a3c4: 03 00 80 7e sethi %hi(0x201f800), %g1
200a3c8: 82 10 63 70 or %g1, 0x370, %g1 ! 201fb70 <_Per_CPU_Information>
200a3cc: c4 28 60 18 stb %g2, [ %g1 + 0x18 ]
200a3d0: 81 c7 e0 08 ret
200a3d4: 81 e8 00 00 restore
02009a58 <_Scheduler_priority_Tick>:
#include <rtems/system.h>
#include <rtems/score/schedulerpriority.h>
void _Scheduler_priority_Tick( void )
{
2009a58: 9d e3 bf a0 save %sp, -96, %sp
Thread_Control *executing;
executing = _Thread_Executing;
2009a5c: 03 00 80 78 sethi %hi(0x201e000), %g1
2009a60: fa 00 60 1c ld [ %g1 + 0x1c ], %i5 ! 201e01c <_Per_CPU_Information+0xc>
/*
* If the thread is not preemptible or is not ready, then
* just return.
*/
if ( !executing->is_preemptible )
2009a64: c2 0f 60 70 ldub [ %i5 + 0x70 ], %g1
2009a68: 80 a0 60 00 cmp %g1, 0
2009a6c: 02 80 00 25 be 2009b00 <_Scheduler_priority_Tick+0xa8>
2009a70: 01 00 00 00 nop
return;
if ( !_States_Is_ready( executing->current_state ) )
2009a74: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
2009a78: 80 a0 60 00 cmp %g1, 0
2009a7c: 12 80 00 21 bne 2009b00 <_Scheduler_priority_Tick+0xa8>
2009a80: 01 00 00 00 nop
/*
* The cpu budget algorithm determines what happens next.
*/
switch ( executing->budget_algorithm ) {
2009a84: c2 07 60 78 ld [ %i5 + 0x78 ], %g1
2009a88: 80 a0 60 01 cmp %g1, 1
2009a8c: 0a 80 00 14 bcs 2009adc <_Scheduler_priority_Tick+0x84>
2009a90: 80 a0 60 02 cmp %g1, 2
2009a94: 28 80 00 07 bleu,a 2009ab0 <_Scheduler_priority_Tick+0x58>
2009a98: c2 07 60 74 ld [ %i5 + 0x74 ], %g1
2009a9c: 80 a0 60 03 cmp %g1, 3
2009aa0: 12 80 00 18 bne 2009b00 <_Scheduler_priority_Tick+0xa8> <== NEVER TAKEN
2009aa4: 01 00 00 00 nop
}
break;
#if defined(RTEMS_SCORE_THREAD_ENABLE_SCHEDULER_CALLOUT)
case THREAD_CPU_BUDGET_ALGORITHM_CALLOUT:
if ( --executing->cpu_time_budget == 0 )
2009aa8: 10 80 00 0f b 2009ae4 <_Scheduler_priority_Tick+0x8c>
2009aac: c2 07 60 74 ld [ %i5 + 0x74 ], %g1
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 ) {
2009ab0: 82 00 7f ff add %g1, -1, %g1
2009ab4: 80 a0 60 00 cmp %g1, 0
2009ab8: 14 80 00 09 bg 2009adc <_Scheduler_priority_Tick+0x84>
2009abc: c2 27 60 74 st %g1, [ %i5 + 0x74 ]
* always operates on the scheduler that 'owns' the currently executing
* thread.
*/
RTEMS_INLINE_ROUTINE void _Scheduler_Yield( void )
{
_Scheduler.Operations.yield();
2009ac0: 03 00 80 73 sethi %hi(0x201cc00), %g1
2009ac4: c2 00 61 ec ld [ %g1 + 0x1ec ], %g1 ! 201cdec <_Scheduler+0xc>
2009ac8: 9f c0 40 00 call %g1
2009acc: 01 00 00 00 nop
* 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;
2009ad0: 03 00 80 76 sethi %hi(0x201d800), %g1
2009ad4: c2 00 62 40 ld [ %g1 + 0x240 ], %g1 ! 201da40 <_Thread_Ticks_per_timeslice>
2009ad8: c2 27 60 74 st %g1, [ %i5 + 0x74 ]
2009adc: 81 c7 e0 08 ret
2009ae0: 81 e8 00 00 restore
}
break;
#if defined(RTEMS_SCORE_THREAD_ENABLE_SCHEDULER_CALLOUT)
case THREAD_CPU_BUDGET_ALGORITHM_CALLOUT:
if ( --executing->cpu_time_budget == 0 )
2009ae4: 82 00 7f ff add %g1, -1, %g1
2009ae8: 80 a0 60 00 cmp %g1, 0
2009aec: 12 bf ff fc bne 2009adc <_Scheduler_priority_Tick+0x84>
2009af0: c2 27 60 74 st %g1, [ %i5 + 0x74 ]
(*executing->budget_callout)( executing );
2009af4: c2 07 60 7c ld [ %i5 + 0x7c ], %g1
2009af8: 9f c0 40 00 call %g1
2009afc: 90 10 00 1d mov %i5, %o0
2009b00: 81 c7 e0 08 ret
2009b04: 81 e8 00 00 restore
02008688 <_TOD_Validate>:
*/
bool _TOD_Validate(
const rtems_time_of_day *the_tod
)
{
2008688: 9d e3 bf a0 save %sp, -96, %sp
uint32_t days_in_month;
uint32_t ticks_per_second;
ticks_per_second = TOD_MICROSECONDS_PER_SECOND /
200868c: 03 00 80 7d sethi %hi(0x201f400), %g1
2008690: d2 00 60 1c ld [ %g1 + 0x1c ], %o1 ! 201f41c <Configuration+0x10>
2008694: 11 00 03 d0 sethi %hi(0xf4000), %o0
2008698: 40 00 48 97 call 201a8f4 <.udiv>
200869c: 90 12 22 40 or %o0, 0x240, %o0 ! f4240 <PROM_START+0xf4240>
rtems_configuration_get_microseconds_per_tick();
if ((!the_tod) ||
20086a0: 80 a6 20 00 cmp %i0, 0
20086a4: 02 80 00 28 be 2008744 <_TOD_Validate+0xbc> <== NEVER TAKEN
20086a8: 84 10 20 00 clr %g2
20086ac: c2 06 20 18 ld [ %i0 + 0x18 ], %g1
20086b0: 80 a0 40 08 cmp %g1, %o0
20086b4: 3a 80 00 25 bcc,a 2008748 <_TOD_Validate+0xc0>
20086b8: b0 08 a0 01 and %g2, 1, %i0
(the_tod->ticks >= ticks_per_second) ||
20086bc: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
20086c0: 80 a0 60 3b cmp %g1, 0x3b
20086c4: 38 80 00 21 bgu,a 2008748 <_TOD_Validate+0xc0>
20086c8: b0 08 a0 01 and %g2, 1, %i0
(the_tod->second >= TOD_SECONDS_PER_MINUTE) ||
20086cc: c2 06 20 10 ld [ %i0 + 0x10 ], %g1
20086d0: 80 a0 60 3b cmp %g1, 0x3b
20086d4: 38 80 00 1d bgu,a 2008748 <_TOD_Validate+0xc0>
20086d8: b0 08 a0 01 and %g2, 1, %i0
(the_tod->minute >= TOD_MINUTES_PER_HOUR) ||
20086dc: c2 06 20 0c ld [ %i0 + 0xc ], %g1
20086e0: 80 a0 60 17 cmp %g1, 0x17
20086e4: 38 80 00 19 bgu,a 2008748 <_TOD_Validate+0xc0>
20086e8: b0 08 a0 01 and %g2, 1, %i0
(the_tod->hour >= TOD_HOURS_PER_DAY) ||
(the_tod->month == 0) ||
20086ec: c2 06 20 04 ld [ %i0 + 4 ], %g1
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) ||
20086f0: 80 a0 60 00 cmp %g1, 0
20086f4: 02 80 00 14 be 2008744 <_TOD_Validate+0xbc> <== NEVER TAKEN
20086f8: 80 a0 60 0c cmp %g1, 0xc
(the_tod->month == 0) ||
20086fc: 38 80 00 13 bgu,a 2008748 <_TOD_Validate+0xc0>
2008700: b0 08 a0 01 and %g2, 1, %i0
(the_tod->month > TOD_MONTHS_PER_YEAR) ||
(the_tod->year < TOD_BASE_YEAR) ||
2008704: c8 06 00 00 ld [ %i0 ], %g4
(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) ||
2008708: 80 a1 27 c3 cmp %g4, 0x7c3
200870c: 28 80 00 0f bleu,a 2008748 <_TOD_Validate+0xc0>
2008710: b0 08 a0 01 and %g2, 1, %i0
(the_tod->year < TOD_BASE_YEAR) ||
(the_tod->day == 0) )
2008714: c6 06 20 08 ld [ %i0 + 8 ], %g3
(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) ||
2008718: 80 a0 e0 00 cmp %g3, 0
200871c: 02 80 00 0a be 2008744 <_TOD_Validate+0xbc> <== NEVER TAKEN
2008720: 80 89 20 03 btst 3, %g4
2008724: 05 00 80 77 sethi %hi(0x201dc00), %g2
(the_tod->day == 0) )
return false;
if ( (the_tod->year % 4) == 0 )
2008728: 12 80 00 03 bne 2008734 <_TOD_Validate+0xac>
200872c: 84 10 a2 58 or %g2, 0x258, %g2 ! 201de58 <_TOD_Days_per_month>
days_in_month = _TOD_Days_per_month[ 1 ][ the_tod->month ];
2008730: 82 00 60 0d add %g1, 0xd, %g1
else
days_in_month = _TOD_Days_per_month[ 0 ][ the_tod->month ];
2008734: 83 28 60 02 sll %g1, 2, %g1
2008738: c2 00 80 01 ld [ %g2 + %g1 ], %g1
if ( the_tod->day > days_in_month )
200873c: 80 a0 40 03 cmp %g1, %g3
2008740: 84 60 3f ff subx %g0, -1, %g2
return false;
return true;
}
2008744: b0 08 a0 01 and %g2, 1, %i0
2008748: 81 c7 e0 08 ret
200874c: 81 e8 00 00 restore
02009d14 <_Thread_Change_priority>:
void _Thread_Change_priority(
Thread_Control *the_thread,
Priority_Control new_priority,
bool prepend_it
)
{
2009d14: 9d e3 bf a0 save %sp, -96, %sp
2009d18: ba 10 00 18 mov %i0, %i5
States_Control state, original_state;
/*
* Save original state
*/
original_state = the_thread->current_state;
2009d1c: f0 06 20 10 ld [ %i0 + 0x10 ], %i0
/*
* 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 );
2009d20: 40 00 03 6a call 200aac8 <_Thread_Set_transient>
2009d24: 90 10 00 1d mov %i5, %o0
/*
* Do not bother recomputing all the priority related information if
* we are not REALLY changing priority.
*/
if ( the_thread->current_priority != new_priority )
2009d28: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
2009d2c: 80 a0 40 19 cmp %g1, %i1
2009d30: 02 80 00 04 be 2009d40 <_Thread_Change_priority+0x2c>
2009d34: 90 10 00 1d mov %i5, %o0
_Thread_Set_priority( the_thread, new_priority );
2009d38: 40 00 03 4b call 200aa64 <_Thread_Set_priority>
2009d3c: 92 10 00 19 mov %i1, %o1
_ISR_Disable( level );
2009d40: 7f ff e2 61 call 20026c4 <sparc_disable_interrupts>
2009d44: 01 00 00 00 nop
2009d48: b6 10 00 08 mov %o0, %i3
/*
* 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;
2009d4c: f8 07 60 10 ld [ %i5 + 0x10 ], %i4
if ( state != STATES_TRANSIENT ) {
2009d50: 80 a7 20 04 cmp %i4, 4
2009d54: 02 80 00 10 be 2009d94 <_Thread_Change_priority+0x80>
2009d58: 82 0e 20 04 and %i0, 4, %g1
/* Only clear the transient state if it wasn't set already */
if ( ! _States_Is_transient( original_state ) )
2009d5c: 80 a0 60 00 cmp %g1, 0
2009d60: 12 80 00 03 bne 2009d6c <_Thread_Change_priority+0x58> <== NEVER TAKEN
2009d64: 82 0f 3f fb and %i4, -5, %g1
the_thread->current_state = _States_Clear( STATES_TRANSIENT, state );
2009d68: c2 27 60 10 st %g1, [ %i5 + 0x10 ]
_ISR_Enable( level );
2009d6c: 7f ff e2 5a call 20026d4 <sparc_enable_interrupts>
2009d70: 90 10 00 1b mov %i3, %o0
if ( _States_Is_waiting_on_thread_queue( state ) ) {
2009d74: 03 00 00 ef sethi %hi(0x3bc00), %g1
2009d78: 82 10 62 e0 or %g1, 0x2e0, %g1 ! 3bee0 <PROM_START+0x3bee0>
2009d7c: 80 8f 00 01 btst %i4, %g1
2009d80: 02 80 00 28 be 2009e20 <_Thread_Change_priority+0x10c>
2009d84: 01 00 00 00 nop
_Thread_queue_Requeue( the_thread->Wait.queue, the_thread );
2009d88: f0 07 60 44 ld [ %i5 + 0x44 ], %i0
2009d8c: 40 00 03 08 call 200a9ac <_Thread_queue_Requeue>
2009d90: 93 e8 00 1d restore %g0, %i5, %o1
}
return;
}
/* Only clear the transient state if it wasn't set already */
if ( ! _States_Is_transient( original_state ) ) {
2009d94: 80 a0 60 00 cmp %g1, 0
2009d98: 12 80 00 0b bne 2009dc4 <_Thread_Change_priority+0xb0> <== NEVER TAKEN
2009d9c: 03 00 80 73 sethi %hi(0x201cc00), %g1
* 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 );
2009da0: c0 27 60 10 clr [ %i5 + 0x10 ]
if ( prepend_it )
2009da4: 80 a6 a0 00 cmp %i2, 0
2009da8: 02 80 00 04 be 2009db8 <_Thread_Change_priority+0xa4>
2009dac: 82 10 61 e0 or %g1, 0x1e0, %g1
*/
RTEMS_INLINE_ROUTINE void _Scheduler_Enqueue_first(
Thread_Control *the_thread
)
{
_Scheduler.Operations.enqueue_first( the_thread );
2009db0: 10 80 00 03 b 2009dbc <_Thread_Change_priority+0xa8>
2009db4: c2 00 60 28 ld [ %g1 + 0x28 ], %g1
*/
RTEMS_INLINE_ROUTINE void _Scheduler_Enqueue(
Thread_Control *the_thread
)
{
_Scheduler.Operations.enqueue( the_thread );
2009db8: c2 00 60 24 ld [ %g1 + 0x24 ], %g1
2009dbc: 9f c0 40 00 call %g1
2009dc0: 90 10 00 1d mov %i5, %o0
_Scheduler_Enqueue_first( the_thread );
else
_Scheduler_Enqueue( the_thread );
}
_ISR_Flash( level );
2009dc4: 7f ff e2 44 call 20026d4 <sparc_enable_interrupts>
2009dc8: 90 10 00 1b mov %i3, %o0
2009dcc: 7f ff e2 3e call 20026c4 <sparc_disable_interrupts>
2009dd0: 01 00 00 00 nop
2009dd4: b0 10 00 08 mov %o0, %i0
* 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();
2009dd8: 03 00 80 73 sethi %hi(0x201cc00), %g1
2009ddc: c2 00 61 e8 ld [ %g1 + 0x1e8 ], %g1 ! 201cde8 <_Scheduler+0x8>
2009de0: 9f c0 40 00 call %g1
2009de4: 01 00 00 00 nop
* is also the heir thread, and false otherwise.
*/
RTEMS_INLINE_ROUTINE bool _Thread_Is_executing_also_the_heir( void )
{
return ( _Thread_Executing == _Thread_Heir );
2009de8: 03 00 80 78 sethi %hi(0x201e000), %g1
2009dec: 82 10 60 10 or %g1, 0x10, %g1 ! 201e010 <_Per_CPU_Information>
2009df0: c4 00 60 0c ld [ %g1 + 0xc ], %g2
* 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() &&
2009df4: c6 00 60 10 ld [ %g1 + 0x10 ], %g3
2009df8: 80 a0 80 03 cmp %g2, %g3
2009dfc: 02 80 00 07 be 2009e18 <_Thread_Change_priority+0x104>
2009e00: 01 00 00 00 nop
2009e04: c4 08 a0 70 ldub [ %g2 + 0x70 ], %g2
2009e08: 80 a0 a0 00 cmp %g2, 0
2009e0c: 02 80 00 03 be 2009e18 <_Thread_Change_priority+0x104>
2009e10: 84 10 20 01 mov 1, %g2
_Thread_Executing->is_preemptible )
_Thread_Dispatch_necessary = true;
2009e14: c4 28 60 18 stb %g2, [ %g1 + 0x18 ]
_ISR_Enable( level );
2009e18: 7f ff e2 2f call 20026d4 <sparc_enable_interrupts>
2009e1c: 81 e8 00 00 restore
2009e20: 81 c7 e0 08 ret
2009e24: 81 e8 00 00 restore
0200a014 <_Thread_Delay_ended>:
void _Thread_Delay_ended(
Objects_Id id,
void *ignored __attribute__((unused))
)
{
200a014: 9d e3 bf 98 save %sp, -104, %sp
Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
200a018: 90 10 00 18 mov %i0, %o0
200a01c: 40 00 00 70 call 200a1dc <_Thread_Get>
200a020: 92 07 bf fc add %fp, -4, %o1
switch ( location ) {
200a024: c2 07 bf fc ld [ %fp + -4 ], %g1
200a028: 80 a0 60 00 cmp %g1, 0
200a02c: 12 80 00 09 bne 200a050 <_Thread_Delay_ended+0x3c> <== NEVER TAKEN
200a030: 13 04 00 00 sethi %hi(0x10000000), %o1
#if defined(RTEMS_MULTIPROCESSING)
case OBJECTS_REMOTE: /* impossible */
#endif
break;
case OBJECTS_LOCAL:
_Thread_Clear_state(
200a034: 7f ff ff 7d call 2009e28 <_Thread_Clear_state>
200a038: 92 12 60 18 or %o1, 0x18, %o1 ! 10000018 <RAM_END+0xdc00018>
*
* This routine decrements the thread dispatch level.
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_decrement_disable_level(void)
{
_Thread_Dispatch_disable_level--;
200a03c: 03 00 80 76 sethi %hi(0x201d800), %g1
200a040: c4 00 62 e0 ld [ %g1 + 0x2e0 ], %g2 ! 201dae0 <_Thread_Dispatch_disable_level>
200a044: 84 00 bf ff add %g2, -1, %g2
200a048: c4 20 62 e0 st %g2, [ %g1 + 0x2e0 ]
return _Thread_Dispatch_disable_level;
200a04c: c2 00 62 e0 ld [ %g1 + 0x2e0 ], %g1
200a050: 81 c7 e0 08 ret
200a054: 81 e8 00 00 restore
0200a058 <_Thread_Dispatch>:
* INTERRUPT LATENCY:
* dispatch thread
* no dispatch thread
*/
void _Thread_Dispatch( void )
{
200a058: 9d e3 bf 98 save %sp, -104, %sp
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
_Thread_Dispatch_disable_level++;
200a05c: 03 00 80 76 sethi %hi(0x201d800), %g1
200a060: c4 00 62 e0 ld [ %g1 + 0x2e0 ], %g2 ! 201dae0 <_Thread_Dispatch_disable_level>
200a064: 84 00 a0 01 inc %g2
200a068: c4 20 62 e0 st %g2, [ %g1 + 0x2e0 ]
return _Thread_Dispatch_disable_level;
200a06c: c2 00 62 e0 ld [ %g1 + 0x2e0 ], %g1
#endif
/*
* Now determine if we need to perform a dispatch on the current CPU.
*/
executing = _Thread_Executing;
200a070: 21 00 80 78 sethi %hi(0x201e000), %l0
200a074: 82 14 20 10 or %l0, 0x10, %g1 ! 201e010 <_Per_CPU_Information>
_ISR_Disable( level );
200a078: 7f ff e1 93 call 20026c4 <sparc_disable_interrupts>
200a07c: f2 00 60 0c ld [ %g1 + 0xc ], %i1
#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;
200a080: 25 00 80 76 sethi %hi(0x201d800), %l2
#endif
/*
* Switch libc's task specific data.
*/
if ( _Thread_libc_reent ) {
200a084: 27 00 80 76 sethi %hi(0x201d800), %l3
/*
* Now determine if we need to perform a dispatch on the current CPU.
*/
executing = _Thread_Executing;
_ISR_Disable( level );
while ( _Thread_Dispatch_necessary == true ) {
200a088: 10 80 00 42 b 200a190 <_Thread_Dispatch+0x138>
200a08c: 23 00 80 76 sethi %hi(0x201d800), %l1
heir = _Thread_Heir;
_Thread_Dispatch_necessary = false;
200a090: c0 28 60 18 clrb [ %g1 + 0x18 ]
/*
* 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 )
200a094: 80 a6 00 19 cmp %i0, %i1
200a098: 12 80 00 0d bne 200a0cc <_Thread_Dispatch+0x74>
200a09c: f0 20 60 0c st %i0, [ %g1 + 0xc ]
_ISR_Disable( level );
}
post_switch:
_ISR_Enable( level );
200a0a0: 7f ff e1 8d call 20026d4 <sparc_enable_interrupts>
200a0a4: 01 00 00 00 nop
*
* This routine decrements the thread dispatch level.
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_decrement_disable_level(void)
{
_Thread_Dispatch_disable_level--;
200a0a8: 03 00 80 76 sethi %hi(0x201d800), %g1
200a0ac: c4 00 62 e0 ld [ %g1 + 0x2e0 ], %g2 ! 201dae0 <_Thread_Dispatch_disable_level>
200a0b0: 84 00 bf ff add %g2, -1, %g2
200a0b4: c4 20 62 e0 st %g2, [ %g1 + 0x2e0 ]
return _Thread_Dispatch_disable_level;
200a0b8: c2 00 62 e0 ld [ %g1 + 0x2e0 ], %g1
_Thread_Unnest_dispatch();
_API_extensions_Run_postswitch();
200a0bc: 7f ff f8 5d call 2008230 <_API_extensions_Run_postswitch>
200a0c0: 01 00 00 00 nop
200a0c4: 81 c7 e0 08 ret
200a0c8: 81 e8 00 00 restore
*/
#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 )
200a0cc: c2 06 20 78 ld [ %i0 + 0x78 ], %g1
200a0d0: 80 a0 60 01 cmp %g1, 1
200a0d4: 12 80 00 03 bne 200a0e0 <_Thread_Dispatch+0x88>
200a0d8: c2 04 a2 40 ld [ %l2 + 0x240 ], %g1
heir->cpu_time_budget = _Thread_Ticks_per_timeslice;
200a0dc: c2 26 20 74 st %g1, [ %i0 + 0x74 ]
_ISR_Enable( level );
200a0e0: 7f ff e1 7d call 20026d4 <sparc_enable_interrupts>
200a0e4: 01 00 00 00 nop
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
{
Timestamp_Control uptime, ran;
_TOD_Get_uptime( &uptime );
200a0e8: 40 00 0d 21 call 200d56c <_TOD_Get_uptime>
200a0ec: 90 07 bf f8 add %fp, -8, %o0
_Timestamp_Subtract(
200a0f0: c4 1f bf f8 ldd [ %fp + -8 ], %g2
200a0f4: 82 14 20 10 or %l0, 0x10, %g1
const Timestamp64_Control *_start,
const Timestamp64_Control *_end,
Timestamp64_Control *_result
)
{
*_result = *_end - *_start;
200a0f8: f8 18 60 20 ldd [ %g1 + 0x20 ], %i4
200a0fc: b6 a0 c0 1d subcc %g3, %i5, %i3
200a100: b4 60 80 1c subx %g2, %i4, %i2
static inline void _Timestamp64_implementation_Add_to(
Timestamp64_Control *_time,
const Timestamp64_Control *_add
)
{
*_time += *_add;
200a104: f8 1e 60 80 ldd [ %i1 + 0x80 ], %i4
200a108: ba 87 40 1b addcc %i5, %i3, %i5
200a10c: b8 47 00 1a addx %i4, %i2, %i4
200a110: f8 3e 60 80 std %i4, [ %i1 + 0x80 ]
&_Thread_Time_of_last_context_switch,
&uptime,
&ran
);
_Timestamp_Add_to( &executing->cpu_time_used, &ran );
_Thread_Time_of_last_context_switch = uptime;
200a114: c4 38 60 20 std %g2, [ %g1 + 0x20 ]
#endif
/*
* Switch libc's task specific data.
*/
if ( _Thread_libc_reent ) {
200a118: c2 04 e3 5c ld [ %l3 + 0x35c ], %g1
200a11c: 80 a0 60 00 cmp %g1, 0
200a120: 02 80 00 06 be 200a138 <_Thread_Dispatch+0xe0> <== NEVER TAKEN
200a124: 90 10 00 19 mov %i1, %o0
executing->libc_reent = *_Thread_libc_reent;
200a128: c4 00 40 00 ld [ %g1 ], %g2
200a12c: c4 26 61 54 st %g2, [ %i1 + 0x154 ]
*_Thread_libc_reent = heir->libc_reent;
200a130: c4 06 21 54 ld [ %i0 + 0x154 ], %g2
200a134: c4 20 40 00 st %g2, [ %g1 ]
}
_User_extensions_Thread_switch( executing, heir );
200a138: 40 00 03 58 call 200ae98 <_User_extensions_Thread_switch>
200a13c: 92 10 00 18 mov %i0, %o1
if ( executing->fp_context != NULL )
_Context_Save_fp( &executing->fp_context );
#endif
#endif
_Context_Switch( &executing->Registers, &heir->Registers );
200a140: 90 06 60 c8 add %i1, 0xc8, %o0
200a144: 40 00 04 83 call 200b350 <_CPU_Context_switch>
200a148: 92 06 20 c8 add %i0, 0xc8, %o1
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
#if ( CPU_USE_DEFERRED_FP_SWITCH == TRUE )
if ( (executing->fp_context != NULL) &&
200a14c: c2 06 61 50 ld [ %i1 + 0x150 ], %g1
200a150: 80 a0 60 00 cmp %g1, 0
200a154: 02 80 00 0c be 200a184 <_Thread_Dispatch+0x12c>
200a158: d0 04 63 58 ld [ %l1 + 0x358 ], %o0
200a15c: 80 a6 40 08 cmp %i1, %o0
200a160: 02 80 00 09 be 200a184 <_Thread_Dispatch+0x12c>
200a164: 80 a2 20 00 cmp %o0, 0
!_Thread_Is_allocated_fp( executing ) ) {
if ( _Thread_Allocated_fp != NULL )
200a168: 02 80 00 04 be 200a178 <_Thread_Dispatch+0x120>
200a16c: 01 00 00 00 nop
_Context_Save_fp( &_Thread_Allocated_fp->fp_context );
200a170: 40 00 04 3e call 200b268 <_CPU_Context_save_fp>
200a174: 90 02 21 50 add %o0, 0x150, %o0
_Context_Restore_fp( &executing->fp_context );
200a178: 40 00 04 59 call 200b2dc <_CPU_Context_restore_fp>
200a17c: 90 06 61 50 add %i1, 0x150, %o0
_Thread_Allocated_fp = executing;
200a180: f2 24 63 58 st %i1, [ %l1 + 0x358 ]
if ( executing->fp_context != NULL )
_Context_Restore_fp( &executing->fp_context );
#endif
#endif
executing = _Thread_Executing;
200a184: 82 14 20 10 or %l0, 0x10, %g1
_ISR_Disable( level );
200a188: 7f ff e1 4f call 20026c4 <sparc_disable_interrupts>
200a18c: f2 00 60 0c ld [ %g1 + 0xc ], %i1
/*
* Now determine if we need to perform a dispatch on the current CPU.
*/
executing = _Thread_Executing;
_ISR_Disable( level );
while ( _Thread_Dispatch_necessary == true ) {
200a190: 82 14 20 10 or %l0, 0x10, %g1
200a194: c4 08 60 18 ldub [ %g1 + 0x18 ], %g2
200a198: 80 a0 a0 00 cmp %g2, 0
200a19c: 32 bf ff bd bne,a 200a090 <_Thread_Dispatch+0x38>
200a1a0: f0 00 60 10 ld [ %g1 + 0x10 ], %i0
200a1a4: 30 bf ff bf b,a 200a0a0 <_Thread_Dispatch+0x48>
0200f7c4 <_Thread_Handler>:
* Input parameters: NONE
*
* Output parameters: NONE
*/
void _Thread_Handler( void )
{
200f7c4: 9d e3 bf a0 save %sp, -96, %sp
#if defined(EXECUTE_GLOBAL_CONSTRUCTORS)
static bool doneConstructors;
bool doCons;
#endif
executing = _Thread_Executing;
200f7c8: 03 00 80 78 sethi %hi(0x201e000), %g1
200f7cc: fa 00 60 1c ld [ %g1 + 0x1c ], %i5 ! 201e01c <_Per_CPU_Information+0xc>
/*
* Some CPUs need to tinker with the call frame or registers when the
* thread actually begins to execute for the first time. This is a
* hook point where the port gets a shot at doing whatever it requires.
*/
_Context_Initialization_at_thread_begin();
200f7d0: 3f 00 80 3d sethi %hi(0x200f400), %i7
200f7d4: be 17 e3 c4 or %i7, 0x3c4, %i7 ! 200f7c4 <_Thread_Handler>
/*
* have to put level into a register for those cpu's that use
* inline asm here
*/
level = executing->Start.isr_level;
200f7d8: d0 07 60 a8 ld [ %i5 + 0xa8 ], %o0
_ISR_Set_level(level);
200f7dc: 7f ff cb be call 20026d4 <sparc_enable_interrupts>
200f7e0: 91 2a 20 08 sll %o0, 8, %o0
doCons = !doneConstructors
&& _Objects_Get_API( executing->Object.id ) != OBJECTS_INTERNAL_API;
if (doCons)
doneConstructors = true;
#else
doCons = !doneConstructors;
200f7e4: 03 00 80 75 sethi %hi(0x201d400), %g1
doneConstructors = true;
200f7e8: 84 10 20 01 mov 1, %g2
doCons = !doneConstructors
&& _Objects_Get_API( executing->Object.id ) != OBJECTS_INTERNAL_API;
if (doCons)
doneConstructors = true;
#else
doCons = !doneConstructors;
200f7ec: f8 08 62 e0 ldub [ %g1 + 0x2e0 ], %i4
doneConstructors = true;
200f7f0: c4 28 62 e0 stb %g2, [ %g1 + 0x2e0 ]
#endif
#endif
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
#if ( CPU_USE_DEFERRED_FP_SWITCH == TRUE )
if ( (executing->fp_context != NULL) &&
200f7f4: c2 07 61 50 ld [ %i5 + 0x150 ], %g1
200f7f8: 80 a0 60 00 cmp %g1, 0
200f7fc: 02 80 00 0c be 200f82c <_Thread_Handler+0x68>
200f800: 03 00 80 76 sethi %hi(0x201d800), %g1
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
RTEMS_INLINE_ROUTINE bool _Thread_Is_allocated_fp (
const Thread_Control *the_thread
)
{
return ( the_thread == _Thread_Allocated_fp );
200f804: d0 00 63 58 ld [ %g1 + 0x358 ], %o0 ! 201db58 <_Thread_Allocated_fp>
200f808: 80 a7 40 08 cmp %i5, %o0
200f80c: 02 80 00 08 be 200f82c <_Thread_Handler+0x68>
200f810: 80 a2 20 00 cmp %o0, 0
!_Thread_Is_allocated_fp( executing ) ) {
if ( _Thread_Allocated_fp != NULL )
200f814: 22 80 00 06 be,a 200f82c <_Thread_Handler+0x68>
200f818: fa 20 63 58 st %i5, [ %g1 + 0x358 ]
_Context_Save_fp( &_Thread_Allocated_fp->fp_context );
200f81c: 7f ff ee 93 call 200b268 <_CPU_Context_save_fp>
200f820: 90 02 21 50 add %o0, 0x150, %o0
_Thread_Allocated_fp = executing;
200f824: 03 00 80 76 sethi %hi(0x201d800), %g1
200f828: fa 20 63 58 st %i5, [ %g1 + 0x358 ] ! 201db58 <_Thread_Allocated_fp>
/*
* 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 );
200f82c: 7f ff ed 26 call 200acc4 <_User_extensions_Thread_begin>
200f830: 90 10 00 1d mov %i5, %o0
/*
* At this point, the dispatch disable level BETTER be 1.
*/
_Thread_Enable_dispatch();
200f834: 7f ff ea 5d call 200a1a8 <_Thread_Enable_dispatch>
200f838: 01 00 00 00 nop
/*
* _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) */ {
200f83c: 80 8f 20 ff btst 0xff, %i4
200f840: 32 80 00 05 bne,a 200f854 <_Thread_Handler+0x90>
200f844: c2 07 60 90 ld [ %i5 + 0x90 ], %g1
INIT_NAME ();
200f848: 40 00 35 18 call 201cca8 <_init>
200f84c: 01 00 00 00 nop
_Thread_Enable_dispatch();
#endif
}
#endif
if ( executing->Start.prototype == THREAD_START_NUMERIC ) {
200f850: c2 07 60 90 ld [ %i5 + 0x90 ], %g1
200f854: 80 a0 60 00 cmp %g1, 0
200f858: 12 80 00 05 bne 200f86c <_Thread_Handler+0xa8>
200f85c: 80 a0 60 01 cmp %g1, 1
executing->Wait.return_argument =
(*(Thread_Entry_numeric) executing->Start.entry_point)(
200f860: c2 07 60 8c ld [ %i5 + 0x8c ], %g1
200f864: 10 80 00 06 b 200f87c <_Thread_Handler+0xb8>
200f868: d0 07 60 98 ld [ %i5 + 0x98 ], %o0
executing->Start.numeric_argument
);
}
#if defined(RTEMS_POSIX_API)
else if ( executing->Start.prototype == THREAD_START_POINTER ) {
200f86c: 12 80 00 07 bne 200f888 <_Thread_Handler+0xc4> <== NEVER TAKEN
200f870: 01 00 00 00 nop
executing->Wait.return_argument =
(*(Thread_Entry_pointer) executing->Start.entry_point)(
200f874: c2 07 60 8c ld [ %i5 + 0x8c ], %g1
200f878: d0 07 60 94 ld [ %i5 + 0x94 ], %o0
200f87c: 9f c0 40 00 call %g1
200f880: 01 00 00 00 nop
executing->Start.numeric_argument
);
}
#if defined(RTEMS_POSIX_API)
else if ( executing->Start.prototype == THREAD_START_POINTER ) {
executing->Wait.return_argument =
200f884: d0 27 60 28 st %o0, [ %i5 + 0x28 ]
* 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 );
200f888: 7f ff ed 20 call 200ad08 <_User_extensions_Thread_exitted>
200f88c: 90 10 00 1d mov %i5, %o0
_Internal_error_Occurred(
200f890: 90 10 20 00 clr %o0
200f894: 92 10 20 01 mov 1, %o1
200f898: 7f ff e5 04 call 2008ca8 <_Internal_error_Occurred>
200f89c: 94 10 20 05 mov 5, %o2
0200a48c <_Thread_Handler_initialization>:
*
* Output parameters: NONE
*/
void _Thread_Handler_initialization(void)
{
200a48c: 9d e3 bf 98 save %sp, -104, %sp
uint32_t ticks_per_timeslice =
200a490: 03 00 80 73 sethi %hi(0x201cc00), %g1
200a494: 82 10 60 ec or %g1, 0xec, %g1 ! 201ccec <Configuration>
#if defined(RTEMS_MULTIPROCESSING)
uint32_t maximum_proxies =
_Configuration_MP_table->maximum_proxies;
#endif
if ( rtems_configuration_get_stack_allocate_hook() == NULL ||
200a498: c6 00 60 2c ld [ %g1 + 0x2c ], %g3
* Output parameters: NONE
*/
void _Thread_Handler_initialization(void)
{
uint32_t ticks_per_timeslice =
200a49c: fa 00 60 18 ld [ %g1 + 0x18 ], %i5
rtems_configuration_get_ticks_per_timeslice();
uint32_t maximum_extensions =
200a4a0: f8 00 60 0c ld [ %g1 + 0xc ], %i4
#if defined(RTEMS_MULTIPROCESSING)
uint32_t maximum_proxies =
_Configuration_MP_table->maximum_proxies;
#endif
if ( rtems_configuration_get_stack_allocate_hook() == NULL ||
200a4a4: 80 a0 e0 00 cmp %g3, 0
200a4a8: 02 80 00 06 be 200a4c0 <_Thread_Handler_initialization+0x34>
200a4ac: c4 00 60 28 ld [ %g1 + 0x28 ], %g2
200a4b0: c6 00 60 30 ld [ %g1 + 0x30 ], %g3
200a4b4: 80 a0 e0 00 cmp %g3, 0
200a4b8: 12 80 00 06 bne 200a4d0 <_Thread_Handler_initialization+0x44><== ALWAYS TAKEN
200a4bc: 80 a0 a0 00 cmp %g2, 0
rtems_configuration_get_stack_free_hook() == NULL)
_Internal_error_Occurred(
200a4c0: 90 10 20 00 clr %o0
200a4c4: 92 10 20 01 mov 1, %o1
200a4c8: 7f ff f9 f8 call 2008ca8 <_Internal_error_Occurred>
200a4cc: 94 10 20 0e mov 0xe, %o2
INTERNAL_ERROR_CORE,
true,
INTERNAL_ERROR_BAD_STACK_HOOK
);
if ( stack_allocate_init_hook != NULL )
200a4d0: 22 80 00 05 be,a 200a4e4 <_Thread_Handler_initialization+0x58>
200a4d4: 03 00 80 78 sethi %hi(0x201e000), %g1
(*stack_allocate_init_hook)( rtems_configuration_get_stack_space_size() );
200a4d8: 9f c0 80 00 call %g2
200a4dc: d0 00 60 08 ld [ %g1 + 8 ], %o0 ! 201e008 <_RTEMS_Objects+0x2c>
_Thread_Dispatch_necessary = false;
200a4e0: 03 00 80 78 sethi %hi(0x201e000), %g1
200a4e4: 82 10 60 10 or %g1, 0x10, %g1 ! 201e010 <_Per_CPU_Information>
200a4e8: c0 28 60 18 clrb [ %g1 + 0x18 ]
_Thread_Executing = NULL;
200a4ec: c0 20 60 0c clr [ %g1 + 0xc ]
_Thread_Heir = NULL;
200a4f0: c0 20 60 10 clr [ %g1 + 0x10 ]
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
_Thread_Allocated_fp = NULL;
200a4f4: 03 00 80 76 sethi %hi(0x201d800), %g1
200a4f8: c0 20 63 58 clr [ %g1 + 0x358 ] ! 201db58 <_Thread_Allocated_fp>
#endif
_Thread_Maximum_extensions = maximum_extensions;
200a4fc: 03 00 80 76 sethi %hi(0x201d800), %g1
200a500: f8 20 63 60 st %i4, [ %g1 + 0x360 ] ! 201db60 <_Thread_Maximum_extensions>
_Thread_Ticks_per_timeslice = ticks_per_timeslice;
200a504: 03 00 80 76 sethi %hi(0x201d800), %g1
200a508: fa 20 62 40 st %i5, [ %g1 + 0x240 ] ! 201da40 <_Thread_Ticks_per_timeslice>
#if defined(RTEMS_MULTIPROCESSING)
if ( _System_state_Is_multiprocessing )
maximum_internal_threads += 1;
#endif
_Objects_Initialize_information(
200a50c: 82 10 20 08 mov 8, %g1
200a510: 11 00 80 76 sethi %hi(0x201d800), %o0
200a514: c2 23 a0 5c st %g1, [ %sp + 0x5c ]
200a518: 90 12 23 e0 or %o0, 0x3e0, %o0
200a51c: 92 10 20 01 mov 1, %o1
200a520: 94 10 20 01 mov 1, %o2
200a524: 96 10 20 01 mov 1, %o3
200a528: 98 10 21 68 mov 0x168, %o4
200a52c: 7f ff fb 67 call 20092c8 <_Objects_Initialize_information>
200a530: 9a 10 20 00 clr %o5
200a534: 81 c7 e0 08 ret
200a538: 81 e8 00 00 restore
0200a290 <_Thread_Initialize>:
Thread_CPU_budget_algorithms budget_algorithm,
Thread_CPU_budget_algorithm_callout budget_callout,
uint32_t isr_level,
Objects_Name name
)
{
200a290: 9d e3 bf a0 save %sp, -96, %sp
200a294: c2 07 a0 6c ld [ %fp + 0x6c ], %g1
/*
* Zero out all the allocated memory fields
*/
for ( i=0 ; i <= THREAD_API_LAST ; i++ )
the_thread->API_Extensions[i] = NULL;
200a298: c0 26 61 58 clr [ %i1 + 0x158 ]
200a29c: c0 26 61 5c clr [ %i1 + 0x15c ]
extensions_area = NULL;
the_thread->libc_reent = NULL;
200a2a0: c0 26 61 54 clr [ %i1 + 0x154 ]
Thread_CPU_budget_algorithms budget_algorithm,
Thread_CPU_budget_algorithm_callout budget_callout,
uint32_t isr_level,
Objects_Name name
)
{
200a2a4: e0 07 a0 60 ld [ %fp + 0x60 ], %l0
200a2a8: e2 00 40 00 ld [ %g1 ], %l1
if ( !actual_stack_size || actual_stack_size < stack_size )
return false; /* stack allocation failed */
stack = the_thread->Start.stack;
#else
if ( !stack_area ) {
200a2ac: 80 a6 a0 00 cmp %i2, 0
200a2b0: 12 80 00 0d bne 200a2e4 <_Thread_Initialize+0x54>
200a2b4: e4 0f a0 5f ldub [ %fp + 0x5f ], %l2
actual_stack_size = _Thread_Stack_Allocate( the_thread, stack_size );
200a2b8: 90 10 00 19 mov %i1, %o0
200a2bc: 40 00 02 12 call 200ab04 <_Thread_Stack_Allocate>
200a2c0: 92 10 00 1b mov %i3, %o1
if ( !actual_stack_size || actual_stack_size < stack_size )
200a2c4: 80 a2 00 1b cmp %o0, %i3
200a2c8: 0a 80 00 6d bcs 200a47c <_Thread_Initialize+0x1ec>
200a2cc: 80 a2 20 00 cmp %o0, 0
200a2d0: 02 80 00 6b be 200a47c <_Thread_Initialize+0x1ec> <== NEVER TAKEN
200a2d4: 82 10 20 01 mov 1, %g1
return false; /* stack allocation failed */
stack = the_thread->Start.stack;
200a2d8: f4 06 60 c0 ld [ %i1 + 0xc0 ], %i2
the_thread->Start.core_allocated_stack = true;
200a2dc: 10 80 00 04 b 200a2ec <_Thread_Initialize+0x5c>
200a2e0: c2 2e 60 b0 stb %g1, [ %i1 + 0xb0 ]
} else {
stack = stack_area;
actual_stack_size = stack_size;
the_thread->Start.core_allocated_stack = false;
200a2e4: c0 2e 60 b0 clrb [ %i1 + 0xb0 ]
200a2e8: 90 10 00 1b mov %i3, %o0
Stack_Control *the_stack,
void *starting_address,
size_t size
)
{
the_stack->area = starting_address;
200a2ec: f4 26 60 b8 st %i2, [ %i1 + 0xb8 ]
the_stack->size = size;
200a2f0: d0 26 60 b4 st %o0, [ %i1 + 0xb4 ]
/*
* Allocate the floating point area for this thread
*/
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
if ( is_fp ) {
200a2f4: 80 a7 20 00 cmp %i4, 0
200a2f8: 02 80 00 07 be 200a314 <_Thread_Initialize+0x84>
200a2fc: b6 10 20 00 clr %i3
fp_area = _Workspace_Allocate( CONTEXT_FP_SIZE );
200a300: 40 00 03 be call 200b1f8 <_Workspace_Allocate>
200a304: 90 10 20 88 mov 0x88, %o0
if ( !fp_area )
200a308: b6 92 20 00 orcc %o0, 0, %i3
200a30c: 22 80 00 4d be,a 200a440 <_Thread_Initialize+0x1b0>
200a310: b8 10 20 00 clr %i4
#endif
/*
* Allocate the extensions area for this thread
*/
if ( _Thread_Maximum_extensions ) {
200a314: 03 00 80 76 sethi %hi(0x201d800), %g1
200a318: d0 00 63 60 ld [ %g1 + 0x360 ], %o0 ! 201db60 <_Thread_Maximum_extensions>
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;
200a31c: f6 26 61 50 st %i3, [ %i1 + 0x150 ]
the_thread->Start.fp_context = fp_area;
200a320: f6 26 60 bc st %i3, [ %i1 + 0xbc ]
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
200a324: c0 26 60 50 clr [ %i1 + 0x50 ]
the_watchdog->routine = routine;
200a328: c0 26 60 64 clr [ %i1 + 0x64 ]
the_watchdog->id = id;
200a32c: c0 26 60 68 clr [ %i1 + 0x68 ]
the_watchdog->user_data = user_data;
200a330: c0 26 60 6c clr [ %i1 + 0x6c ]
#endif
/*
* Allocate the extensions area for this thread
*/
if ( _Thread_Maximum_extensions ) {
200a334: 80 a2 20 00 cmp %o0, 0
200a338: 02 80 00 08 be 200a358 <_Thread_Initialize+0xc8>
200a33c: b8 10 20 00 clr %i4
extensions_area = _Workspace_Allocate(
200a340: 90 02 20 01 inc %o0
200a344: 40 00 03 ad call 200b1f8 <_Workspace_Allocate>
200a348: 91 2a 20 02 sll %o0, 2, %o0
(_Thread_Maximum_extensions + 1) * sizeof( void * )
);
if ( !extensions_area )
200a34c: b8 92 20 00 orcc %o0, 0, %i4
200a350: 02 80 00 3d be 200a444 <_Thread_Initialize+0x1b4>
200a354: b4 10 20 00 clr %i2
* 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 ) {
200a358: 80 a7 20 00 cmp %i4, 0
200a35c: 12 80 00 0a bne 200a384 <_Thread_Initialize+0xf4>
200a360: f8 26 61 60 st %i4, [ %i1 + 0x160 ]
* General initialization
*/
the_thread->Start.is_preemptible = is_preemptible;
the_thread->Start.budget_algorithm = budget_algorithm;
the_thread->Start.budget_callout = budget_callout;
200a364: c2 07 a0 64 ld [ %fp + 0x64 ], %g1
/*
* General initialization
*/
the_thread->Start.is_preemptible = is_preemptible;
200a368: e4 2e 60 9c stb %l2, [ %i1 + 0x9c ]
the_thread->Start.budget_algorithm = budget_algorithm;
200a36c: e0 26 60 a0 st %l0, [ %i1 + 0xa0 ]
the_thread->Start.budget_callout = budget_callout;
switch ( budget_algorithm ) {
200a370: 80 a4 20 02 cmp %l0, 2
200a374: 12 80 00 12 bne 200a3bc <_Thread_Initialize+0x12c>
200a378: c2 26 60 a4 st %g1, [ %i1 + 0xa4 ]
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;
200a37c: 10 80 00 0e b 200a3b4 <_Thread_Initialize+0x124>
200a380: 03 00 80 76 sethi %hi(0x201d800), %g1
* 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++ )
200a384: 03 00 80 76 sethi %hi(0x201d800), %g1
200a388: c4 00 63 60 ld [ %g1 + 0x360 ], %g2 ! 201db60 <_Thread_Maximum_extensions>
200a38c: 10 80 00 05 b 200a3a0 <_Thread_Initialize+0x110>
200a390: 82 10 20 00 clr %g1
the_thread->extensions[i] = NULL;
200a394: 87 28 60 02 sll %g1, 2, %g3
* 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++ )
200a398: 82 00 60 01 inc %g1
the_thread->extensions[i] = NULL;
200a39c: c0 21 00 03 clr [ %g4 + %g3 ]
* 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++ )
200a3a0: 80 a0 40 02 cmp %g1, %g2
200a3a4: 28 bf ff fc bleu,a 200a394 <_Thread_Initialize+0x104>
200a3a8: c8 06 61 60 ld [ %i1 + 0x160 ], %g4
* General initialization
*/
the_thread->Start.is_preemptible = is_preemptible;
the_thread->Start.budget_algorithm = budget_algorithm;
the_thread->Start.budget_callout = budget_callout;
200a3ac: 10 bf ff ef b 200a368 <_Thread_Initialize+0xd8>
200a3b0: c2 07 a0 64 ld [ %fp + 0x64 ], %g1
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;
200a3b4: c2 00 62 40 ld [ %g1 + 0x240 ], %g1
200a3b8: c2 26 60 74 st %g1, [ %i1 + 0x74 ]
case THREAD_CPU_BUDGET_ALGORITHM_CALLOUT:
break;
#endif
}
the_thread->Start.isr_level = isr_level;
200a3bc: c2 07 a0 68 ld [ %fp + 0x68 ], %g1
the_thread->current_state = STATES_DORMANT;
the_thread->Wait.queue = NULL;
200a3c0: c0 26 60 44 clr [ %i1 + 0x44 ]
case THREAD_CPU_BUDGET_ALGORITHM_CALLOUT:
break;
#endif
}
the_thread->Start.isr_level = isr_level;
200a3c4: c2 26 60 a8 st %g1, [ %i1 + 0xa8 ]
the_thread->current_state = STATES_DORMANT;
200a3c8: 82 10 20 01 mov 1, %g1
200a3cc: c2 26 60 10 st %g1, [ %i1 + 0x10 ]
*/
RTEMS_INLINE_ROUTINE void* _Scheduler_Allocate(
Thread_Control *the_thread
)
{
return _Scheduler.Operations.allocate( the_thread );
200a3d0: 03 00 80 73 sethi %hi(0x201cc00), %g1
200a3d4: c2 00 61 f8 ld [ %g1 + 0x1f8 ], %g1 ! 201cdf8 <_Scheduler+0x18>
the_thread->Wait.queue = NULL;
the_thread->resource_count = 0;
200a3d8: c0 26 60 1c clr [ %i1 + 0x1c ]
the_thread->real_priority = priority;
200a3dc: fa 26 60 18 st %i5, [ %i1 + 0x18 ]
the_thread->Start.initial_priority = priority;
200a3e0: fa 26 60 ac st %i5, [ %i1 + 0xac ]
200a3e4: 9f c0 40 00 call %g1
200a3e8: 90 10 00 19 mov %i1, %o0
sched =_Scheduler_Allocate( the_thread );
if ( !sched )
200a3ec: b4 92 20 00 orcc %o0, 0, %i2
200a3f0: 02 80 00 15 be 200a444 <_Thread_Initialize+0x1b4>
200a3f4: 90 10 00 19 mov %i1, %o0
goto failed;
_Thread_Set_priority( the_thread, priority );
200a3f8: 40 00 01 9b call 200aa64 <_Thread_Set_priority>
200a3fc: 92 10 00 1d mov %i5, %o1
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
200a400: c4 06 20 1c ld [ %i0 + 0x1c ], %g2
Objects_Information *information,
Objects_Control *the_object,
Objects_Name name
)
{
_Objects_Set_local_object(
200a404: c2 16 60 0a lduh [ %i1 + 0xa ], %g1
static inline void _Timestamp64_implementation_Set_to_zero(
Timestamp64_Control *_time
)
{
*_time = 0;
200a408: c0 26 60 80 clr [ %i1 + 0x80 ]
200a40c: c0 26 60 84 clr [ %i1 + 0x84 ]
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
200a410: 83 28 60 02 sll %g1, 2, %g1
200a414: f2 20 80 01 st %i1, [ %g2 + %g1 ]
information,
_Objects_Get_index( the_object->id ),
the_object
);
the_object->name = name;
200a418: e2 26 60 0c st %l1, [ %i1 + 0xc ]
* 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 );
200a41c: 90 10 00 19 mov %i1, %o0
200a420: 40 00 02 5d call 200ad94 <_User_extensions_Thread_create>
200a424: b0 10 20 01 mov 1, %i0
if ( extension_status )
200a428: 80 8a 20 ff btst 0xff, %o0
200a42c: 02 80 00 06 be 200a444 <_Thread_Initialize+0x1b4>
200a430: 01 00 00 00 nop
200a434: b0 0e 20 01 and %i0, 1, %i0
200a438: 81 c7 e0 08 ret
200a43c: 81 e8 00 00 restore
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;
200a440: b4 10 20 00 clr %i2
extension_status = _User_extensions_Thread_create( the_thread );
if ( extension_status )
return true;
failed:
_Workspace_Free( the_thread->libc_reent );
200a444: 40 00 03 75 call 200b218 <_Workspace_Free>
200a448: d0 06 61 54 ld [ %i1 + 0x154 ], %o0
for ( i=0 ; i <= THREAD_API_LAST ; i++ )
_Workspace_Free( the_thread->API_Extensions[i] );
200a44c: 40 00 03 73 call 200b218 <_Workspace_Free>
200a450: d0 06 61 58 ld [ %i1 + 0x158 ], %o0
200a454: 40 00 03 71 call 200b218 <_Workspace_Free>
200a458: d0 06 61 5c ld [ %i1 + 0x15c ], %o0
_Workspace_Free( extensions_area );
200a45c: 40 00 03 6f call 200b218 <_Workspace_Free>
200a460: 90 10 00 1c mov %i4, %o0
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
_Workspace_Free( fp_area );
200a464: 40 00 03 6d call 200b218 <_Workspace_Free>
200a468: 90 10 00 1b mov %i3, %o0
#endif
_Workspace_Free( sched );
200a46c: 40 00 03 6b call 200b218 <_Workspace_Free>
200a470: 90 10 00 1a mov %i2, %o0
_Thread_Stack_Free( the_thread );
200a474: 40 00 01 b4 call 200ab44 <_Thread_Stack_Free>
200a478: 90 10 00 19 mov %i1, %o0
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 )
return false; /* stack allocation failed */
200a47c: b0 10 20 00 clr %i0
_Workspace_Free( sched );
_Thread_Stack_Free( the_thread );
return false;
}
200a480: b0 0e 20 01 and %i0, 1, %i0
200a484: 81 c7 e0 08 ret
200a488: 81 e8 00 00 restore
0200ab44 <_Thread_Stack_Free>:
*/
void _Thread_Stack_Free(
Thread_Control *the_thread
)
{
200ab44: 9d e3 bf a0 save %sp, -96, %sp
#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 )
200ab48: c4 0e 20 b0 ldub [ %i0 + 0xb0 ], %g2
void _Thread_Stack_Free(
Thread_Control *the_thread
)
{
rtems_stack_free_hook stack_free_hook =
200ab4c: 03 00 80 73 sethi %hi(0x201cc00), %g1
#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 )
200ab50: 80 a0 a0 00 cmp %g2, 0
200ab54: 02 80 00 04 be 200ab64 <_Thread_Stack_Free+0x20> <== NEVER TAKEN
200ab58: c2 00 61 1c ld [ %g1 + 0x11c ], %g1
* 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.
*/
(*stack_free_hook)( the_thread->Start.Initial_stack.area );
200ab5c: 9f c0 40 00 call %g1
200ab60: d0 06 20 b8 ld [ %i0 + 0xb8 ], %o0
200ab64: 81 c7 e0 08 ret
200ab68: 81 e8 00 00 restore
0200a9ac <_Thread_queue_Requeue>:
void _Thread_queue_Requeue(
Thread_queue_Control *the_thread_queue,
Thread_Control *the_thread
)
{
200a9ac: 9d e3 bf 98 save %sp, -104, %sp
/*
* Just in case the thread really wasn't blocked on a thread queue
* when we get here.
*/
if ( !the_thread_queue )
200a9b0: 80 a6 20 00 cmp %i0, 0
200a9b4: 02 80 00 19 be 200aa18 <_Thread_queue_Requeue+0x6c> <== NEVER TAKEN
200a9b8: 01 00 00 00 nop
/*
* 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 ) {
200a9bc: fa 06 20 34 ld [ %i0 + 0x34 ], %i5
200a9c0: 80 a7 60 01 cmp %i5, 1
200a9c4: 12 80 00 15 bne 200aa18 <_Thread_queue_Requeue+0x6c> <== NEVER TAKEN
200a9c8: 01 00 00 00 nop
Thread_queue_Control *tq = the_thread_queue;
ISR_Level level;
ISR_Level level_ignored;
_ISR_Disable( level );
200a9cc: 7f ff df 3e call 20026c4 <sparc_disable_interrupts>
200a9d0: 01 00 00 00 nop
200a9d4: b8 10 00 08 mov %o0, %i4
200a9d8: c4 06 60 10 ld [ %i1 + 0x10 ], %g2
if ( _States_Is_waiting_on_thread_queue( the_thread->current_state ) ) {
200a9dc: 03 00 00 ef sethi %hi(0x3bc00), %g1
200a9e0: 82 10 62 e0 or %g1, 0x2e0, %g1 ! 3bee0 <PROM_START+0x3bee0>
200a9e4: 80 88 80 01 btst %g2, %g1
200a9e8: 02 80 00 0a be 200aa10 <_Thread_queue_Requeue+0x64> <== NEVER TAKEN
200a9ec: 90 10 00 18 mov %i0, %o0
_Thread_queue_Enter_critical_section( tq );
_Thread_queue_Extract_priority_helper( tq, the_thread, true );
200a9f0: 92 10 00 19 mov %i1, %o1
200a9f4: 94 10 20 01 mov 1, %o2
200a9f8: 40 00 0c b8 call 200dcd8 <_Thread_queue_Extract_priority_helper>
200a9fc: fa 26 20 30 st %i5, [ %i0 + 0x30 ]
(void) _Thread_queue_Enqueue_priority( tq, the_thread, &level_ignored );
200aa00: 90 10 00 18 mov %i0, %o0
200aa04: 92 10 00 19 mov %i1, %o1
200aa08: 7f ff ff 50 call 200a748 <_Thread_queue_Enqueue_priority>
200aa0c: 94 07 bf fc add %fp, -4, %o2
}
_ISR_Enable( level );
200aa10: 7f ff df 31 call 20026d4 <sparc_enable_interrupts>
200aa14: 90 10 00 1c mov %i4, %o0
200aa18: 81 c7 e0 08 ret
200aa1c: 81 e8 00 00 restore
0200aa20 <_Thread_queue_Timeout>:
void _Thread_queue_Timeout(
Objects_Id id,
void *ignored __attribute__((unused))
)
{
200aa20: 9d e3 bf 98 save %sp, -104, %sp
Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
200aa24: 90 10 00 18 mov %i0, %o0
200aa28: 7f ff fd ed call 200a1dc <_Thread_Get>
200aa2c: 92 07 bf fc add %fp, -4, %o1
switch ( location ) {
200aa30: c2 07 bf fc ld [ %fp + -4 ], %g1
200aa34: 80 a0 60 00 cmp %g1, 0
200aa38: 12 80 00 09 bne 200aa5c <_Thread_queue_Timeout+0x3c> <== NEVER TAKEN
200aa3c: 01 00 00 00 nop
#if defined(RTEMS_MULTIPROCESSING)
case OBJECTS_REMOTE: /* impossible */
#endif
break;
case OBJECTS_LOCAL:
_Thread_queue_Process_timeout( the_thread );
200aa40: 40 00 0c dd call 200ddb4 <_Thread_queue_Process_timeout>
200aa44: 01 00 00 00 nop
*
* This routine decrements the thread dispatch level.
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_decrement_disable_level(void)
{
_Thread_Dispatch_disable_level--;
200aa48: 03 00 80 76 sethi %hi(0x201d800), %g1
200aa4c: c4 00 62 e0 ld [ %g1 + 0x2e0 ], %g2 ! 201dae0 <_Thread_Dispatch_disable_level>
200aa50: 84 00 bf ff add %g2, -1, %g2
200aa54: c4 20 62 e0 st %g2, [ %g1 + 0x2e0 ]
return _Thread_Dispatch_disable_level;
200aa58: c2 00 62 e0 ld [ %g1 + 0x2e0 ], %g1
200aa5c: 81 c7 e0 08 ret
200aa60: 81 e8 00 00 restore
02018c78 <_Timer_server_Body>:
* @a arg points to the corresponding timer server control block.
*/
static rtems_task _Timer_server_Body(
rtems_task_argument arg
)
{
2018c78: 9d e3 bf 88 save %sp, -120, %sp
static void _Timer_server_Process_interval_watchdogs(
Timer_server_Watchdogs *watchdogs,
Chain_Control *fire_chain
)
{
Watchdog_Interval snapshot = _Watchdog_Ticks_since_boot;
2018c7c: 27 00 80 f3 sethi %hi(0x203cc00), %l3
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
2018c80: a4 07 bf e8 add %fp, -24, %l2
2018c84: aa 07 bf ec add %fp, -20, %l5
2018c88: b8 07 bf f4 add %fp, -12, %i4
2018c8c: b2 07 bf f8 add %fp, -8, %i1
2018c90: ea 27 bf e8 st %l5, [ %fp + -24 ]
head->previous = NULL;
2018c94: c0 27 bf ec clr [ %fp + -20 ]
tail->previous = head;
2018c98: e4 27 bf f0 st %l2, [ %fp + -16 ]
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
2018c9c: f2 27 bf f4 st %i1, [ %fp + -12 ]
head->previous = NULL;
2018ca0: c0 27 bf f8 clr [ %fp + -8 ]
tail->previous = head;
2018ca4: f8 27 bf fc st %i4, [ %fp + -4 ]
*/
Watchdog_Interval delta = snapshot - watchdogs->last_snapshot;
watchdogs->last_snapshot = snapshot;
_Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
2018ca8: b4 06 20 30 add %i0, 0x30, %i2
static void _Timer_server_Process_tod_watchdogs(
Timer_server_Watchdogs *watchdogs,
Chain_Control *fire_chain
)
{
Watchdog_Interval snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch();
2018cac: 29 00 80 f3 sethi %hi(0x203cc00), %l4
/*
* 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 );
2018cb0: b6 06 20 68 add %i0, 0x68, %i3
static void _Timer_server_Stop_interval_system_watchdog(
Timer_server_Control *ts
)
{
_Watchdog_Remove( &ts->Interval_watchdogs.System_watchdog );
2018cb4: a2 06 20 08 add %i0, 8, %l1
static void _Timer_server_Stop_tod_system_watchdog(
Timer_server_Control *ts
)
{
_Watchdog_Remove( &ts->TOD_watchdogs.System_watchdog );
2018cb8: a0 06 20 40 add %i0, 0x40, %l0
{
/*
* 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;
2018cbc: e4 26 20 78 st %l2, [ %i0 + 0x78 ]
static void _Timer_server_Process_interval_watchdogs(
Timer_server_Watchdogs *watchdogs,
Chain_Control *fire_chain
)
{
Watchdog_Interval snapshot = _Watchdog_Ticks_since_boot;
2018cc0: c2 04 e2 68 ld [ %l3 + 0x268 ], %g1
/*
* We assume adequate unsigned arithmetic here.
*/
Watchdog_Interval delta = snapshot - watchdogs->last_snapshot;
2018cc4: d2 06 20 3c ld [ %i0 + 0x3c ], %o1
watchdogs->last_snapshot = snapshot;
_Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
2018cc8: 90 10 00 1a mov %i2, %o0
2018ccc: 92 20 40 09 sub %g1, %o1, %o1
/*
* We assume adequate unsigned arithmetic here.
*/
Watchdog_Interval delta = snapshot - watchdogs->last_snapshot;
watchdogs->last_snapshot = snapshot;
2018cd0: c2 26 20 3c st %g1, [ %i0 + 0x3c ]
_Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
2018cd4: 40 00 11 97 call 201d330 <_Watchdog_Adjust_to_chain>
2018cd8: 94 10 00 1c mov %i4, %o2
2018cdc: d0 1d 20 b8 ldd [ %l4 + 0xb8 ], %o0
2018ce0: 94 10 20 00 clr %o2
2018ce4: 17 0e e6 b2 sethi %hi(0x3b9ac800), %o3
2018ce8: 40 00 4f 49 call 202ca0c <__divdi3>
2018cec: 96 12 e2 00 or %o3, 0x200, %o3 ! 3b9aca00 <RAM_END+0x395aca00>
Timer_server_Watchdogs *watchdogs,
Chain_Control *fire_chain
)
{
Watchdog_Interval snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch();
Watchdog_Interval last_snapshot = watchdogs->last_snapshot;
2018cf0: d4 06 20 74 ld [ %i0 + 0x74 ], %o2
/*
* 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 ) {
2018cf4: 80 a2 40 0a cmp %o1, %o2
2018cf8: 08 80 00 07 bleu 2018d14 <_Timer_server_Body+0x9c>
2018cfc: ba 10 00 09 mov %o1, %i5
/*
* 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 );
2018d00: 92 22 40 0a sub %o1, %o2, %o1
2018d04: 90 10 00 1b mov %i3, %o0
2018d08: 40 00 11 8a call 201d330 <_Watchdog_Adjust_to_chain>
2018d0c: 94 10 00 1c mov %i4, %o2
2018d10: 30 80 00 06 b,a 2018d28 <_Timer_server_Body+0xb0>
} else if ( snapshot < last_snapshot ) {
2018d14: 1a 80 00 05 bcc 2018d28 <_Timer_server_Body+0xb0>
2018d18: 90 10 00 1b mov %i3, %o0
/*
* 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 );
2018d1c: 92 10 20 01 mov 1, %o1
2018d20: 40 00 11 5c call 201d290 <_Watchdog_Adjust>
2018d24: 94 22 80 1d sub %o2, %i5, %o2
}
watchdogs->last_snapshot = snapshot;
2018d28: fa 26 20 74 st %i5, [ %i0 + 0x74 ]
}
static void _Timer_server_Process_insertions( Timer_server_Control *ts )
{
while ( true ) {
Timer_Control *timer = (Timer_Control *) _Chain_Get( ts->insert_chain );
2018d2c: d0 06 20 78 ld [ %i0 + 0x78 ], %o0
2018d30: 40 00 02 8c call 2019760 <_Chain_Get>
2018d34: 01 00 00 00 nop
if ( timer == NULL ) {
2018d38: 92 92 20 00 orcc %o0, 0, %o1
2018d3c: 02 80 00 0c be 2018d6c <_Timer_server_Body+0xf4>
2018d40: 01 00 00 00 nop
static void _Timer_server_Insert_timer(
Timer_server_Control *ts,
Timer_Control *timer
)
{
if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) {
2018d44: c2 02 60 38 ld [ %o1 + 0x38 ], %g1
2018d48: 80 a0 60 01 cmp %g1, 1
2018d4c: 02 80 00 05 be 2018d60 <_Timer_server_Body+0xe8>
2018d50: 90 10 00 1a mov %i2, %o0
_Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker );
} else if ( timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) {
2018d54: 80 a0 60 03 cmp %g1, 3
2018d58: 12 bf ff f5 bne 2018d2c <_Timer_server_Body+0xb4> <== NEVER TAKEN
2018d5c: 90 10 00 1b mov %i3, %o0
_Watchdog_Insert( &ts->TOD_watchdogs.Chain, &timer->Ticker );
2018d60: 40 00 11 a6 call 201d3f8 <_Watchdog_Insert>
2018d64: 92 02 60 10 add %o1, 0x10, %o1
2018d68: 30 bf ff f1 b,a 2018d2c <_Timer_server_Body+0xb4>
* of zero it will be processed in the next iteration of the timer server
* body loop.
*/
_Timer_server_Process_insertions( ts );
_ISR_Disable( level );
2018d6c: 7f ff de a1 call 20107f0 <sparc_disable_interrupts>
2018d70: 01 00 00 00 nop
if ( _Chain_Is_empty( insert_chain ) ) {
2018d74: c2 07 bf e8 ld [ %fp + -24 ], %g1
2018d78: 80 a0 40 15 cmp %g1, %l5
2018d7c: 12 80 00 0a bne 2018da4 <_Timer_server_Body+0x12c> <== NEVER TAKEN
2018d80: 01 00 00 00 nop
ts->insert_chain = NULL;
2018d84: c0 26 20 78 clr [ %i0 + 0x78 ]
_ISR_Enable( level );
2018d88: 7f ff de 9e call 2010800 <sparc_enable_interrupts>
2018d8c: 01 00 00 00 nop
_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 ) ) {
2018d90: c2 07 bf f4 ld [ %fp + -12 ], %g1
2018d94: 80 a0 40 19 cmp %g1, %i1
2018d98: 12 80 00 06 bne 2018db0 <_Timer_server_Body+0x138>
2018d9c: 01 00 00 00 nop
2018da0: 30 80 00 18 b,a 2018e00 <_Timer_server_Body+0x188>
ts->insert_chain = NULL;
_ISR_Enable( level );
break;
} else {
_ISR_Enable( level );
2018da4: 7f ff de 97 call 2010800 <sparc_enable_interrupts> <== NOT EXECUTED
2018da8: 01 00 00 00 nop <== NOT EXECUTED
2018dac: 30 bf ff c5 b,a 2018cc0 <_Timer_server_Body+0x48> <== 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 );
2018db0: 7f ff de 90 call 20107f0 <sparc_disable_interrupts>
2018db4: 01 00 00 00 nop
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_head( the_chain )->next;
2018db8: fa 07 bf f4 ld [ %fp + -12 ], %i5
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Get_unprotected(
Chain_Control *the_chain
)
{
if ( !_Chain_Is_empty(the_chain))
2018dbc: 80 a7 40 19 cmp %i5, %i1
2018dc0: 02 80 00 0d be 2018df4 <_Timer_server_Body+0x17c>
2018dc4: 01 00 00 00 nop
Chain_Control *the_chain
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *old_first = head->next;
Chain_Node *new_first = old_first->next;
2018dc8: c2 07 40 00 ld [ %i5 ], %g1
head->next = new_first;
new_first->previous = head;
2018dcc: f8 20 60 04 st %i4, [ %g1 + 4 ]
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *old_first = head->next;
Chain_Node *new_first = old_first->next;
head->next = new_first;
2018dd0: c2 27 bf f4 st %g1, [ %fp + -12 ]
watchdog = (Watchdog_Control *) _Chain_Get_unprotected( &fire_chain );
if ( watchdog != NULL ) {
watchdog->state = WATCHDOG_INACTIVE;
2018dd4: c0 27 60 08 clr [ %i5 + 8 ]
_ISR_Enable( level );
2018dd8: 7f ff de 8a call 2010800 <sparc_enable_interrupts>
2018ddc: 01 00 00 00 nop
/*
* 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 );
2018de0: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
2018de4: d0 07 60 20 ld [ %i5 + 0x20 ], %o0
2018de8: 9f c0 40 00 call %g1
2018dec: d2 07 60 24 ld [ %i5 + 0x24 ], %o1
}
2018df0: 30 bf ff f0 b,a 2018db0 <_Timer_server_Body+0x138>
watchdog = (Watchdog_Control *) _Chain_Get_unprotected( &fire_chain );
if ( watchdog != NULL ) {
watchdog->state = WATCHDOG_INACTIVE;
_ISR_Enable( level );
} else {
_ISR_Enable( level );
2018df4: 7f ff de 83 call 2010800 <sparc_enable_interrupts>
2018df8: 01 00 00 00 nop
2018dfc: 30 bf ff b0 b,a 2018cbc <_Timer_server_Body+0x44>
* the active flag of the timer server is true.
*/
(*watchdog->routine)( watchdog->id, watchdog->user_data );
}
} else {
ts->active = false;
2018e00: c0 2e 20 7c clrb [ %i0 + 0x7c ]
2018e04: 7f ff ff 19 call 2018a68 <_Thread_Dispatch_increment_disable_level>
2018e08: 01 00 00 00 nop
/*
* Block until there is something to do.
*/
_Thread_Disable_dispatch();
_Thread_Set_state( ts->thread, STATES_DELAYING );
2018e0c: d0 06 00 00 ld [ %i0 ], %o0
2018e10: 40 00 0f f9 call 201cdf4 <_Thread_Set_state>
2018e14: 92 10 20 08 mov 8, %o1
_Timer_server_Reset_interval_system_watchdog( ts );
2018e18: 7f ff ff 1b call 2018a84 <_Timer_server_Reset_interval_system_watchdog>
2018e1c: 90 10 00 18 mov %i0, %o0
_Timer_server_Reset_tod_system_watchdog( ts );
2018e20: 7f ff ff 2d call 2018ad4 <_Timer_server_Reset_tod_system_watchdog>
2018e24: 90 10 00 18 mov %i0, %o0
_Thread_Enable_dispatch();
2018e28: 40 00 0d 99 call 201c48c <_Thread_Enable_dispatch>
2018e2c: 01 00 00 00 nop
ts->active = true;
2018e30: 82 10 20 01 mov 1, %g1 ! 1 <PROM_START+0x1>
static void _Timer_server_Stop_interval_system_watchdog(
Timer_server_Control *ts
)
{
_Watchdog_Remove( &ts->Interval_watchdogs.System_watchdog );
2018e34: 90 10 00 11 mov %l1, %o0
_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;
2018e38: c2 2e 20 7c stb %g1, [ %i0 + 0x7c ]
static void _Timer_server_Stop_interval_system_watchdog(
Timer_server_Control *ts
)
{
_Watchdog_Remove( &ts->Interval_watchdogs.System_watchdog );
2018e3c: 40 00 11 c7 call 201d558 <_Watchdog_Remove>
2018e40: 01 00 00 00 nop
static void _Timer_server_Stop_tod_system_watchdog(
Timer_server_Control *ts
)
{
_Watchdog_Remove( &ts->TOD_watchdogs.System_watchdog );
2018e44: 40 00 11 c5 call 201d558 <_Watchdog_Remove>
2018e48: 90 10 00 10 mov %l0, %o0
2018e4c: 30 bf ff 9c b,a 2018cbc <_Timer_server_Body+0x44>
02018b24 <_Timer_server_Schedule_operation_method>:
static void _Timer_server_Schedule_operation_method(
Timer_server_Control *ts,
Timer_Control *timer
)
{
2018b24: 9d e3 bf a0 save %sp, -96, %sp
if ( ts->insert_chain == NULL ) {
2018b28: c2 06 20 78 ld [ %i0 + 0x78 ], %g1
2018b2c: 80 a0 60 00 cmp %g1, 0
2018b30: 12 80 00 4f bne 2018c6c <_Timer_server_Schedule_operation_method+0x148>
2018b34: ba 10 00 19 mov %i1, %i5
#if defined ( __THREAD_DO_NOT_INLINE_DISABLE_DISPATCH__ )
void _Thread_Disable_dispatch( void );
#else
RTEMS_INLINE_ROUTINE void _Thread_Disable_dispatch( void )
{
_Thread_Dispatch_increment_disable_level();
2018b38: 7f ff ff cc call 2018a68 <_Thread_Dispatch_increment_disable_level>
2018b3c: 01 00 00 00 nop
* being inserted. This could result in an integer overflow.
*/
_Thread_Disable_dispatch();
if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) {
2018b40: c2 06 60 38 ld [ %i1 + 0x38 ], %g1
2018b44: 80 a0 60 01 cmp %g1, 1
2018b48: 12 80 00 1f bne 2018bc4 <_Timer_server_Schedule_operation_method+0xa0>
2018b4c: 80 a0 60 03 cmp %g1, 3
/*
* We have to advance the last known ticks value of the server and update
* the watchdog chain accordingly.
*/
_ISR_Disable( level );
2018b50: 7f ff df 28 call 20107f0 <sparc_disable_interrupts>
2018b54: 01 00 00 00 nop
snapshot = _Watchdog_Ticks_since_boot;
2018b58: 03 00 80 f3 sethi %hi(0x203cc00), %g1
2018b5c: c4 00 62 68 ld [ %g1 + 0x268 ], %g2 ! 203ce68 <_Watchdog_Ticks_since_boot>
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_head( the_chain )->next;
2018b60: c2 06 20 30 ld [ %i0 + 0x30 ], %g1
last_snapshot = ts->Interval_watchdogs.last_snapshot;
2018b64: c8 06 20 3c ld [ %i0 + 0x3c ], %g4
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
2018b68: 86 06 20 34 add %i0, 0x34, %g3
if ( !_Chain_Is_empty( &ts->Interval_watchdogs.Chain ) ) {
2018b6c: 80 a0 40 03 cmp %g1, %g3
2018b70: 02 80 00 08 be 2018b90 <_Timer_server_Schedule_operation_method+0x6c>
2018b74: 88 20 80 04 sub %g2, %g4, %g4
/*
* We assume adequate unsigned arithmetic here.
*/
delta = snapshot - last_snapshot;
delta_interval = first_watchdog->delta_interval;
2018b78: f8 00 60 10 ld [ %g1 + 0x10 ], %i4
if (delta_interval > delta) {
2018b7c: 80 a7 00 04 cmp %i4, %g4
2018b80: 08 80 00 03 bleu 2018b8c <_Timer_server_Schedule_operation_method+0x68>
2018b84: 86 10 20 00 clr %g3
delta_interval -= delta;
2018b88: 86 27 00 04 sub %i4, %g4, %g3
} else {
delta_interval = 0;
}
first_watchdog->delta_interval = delta_interval;
2018b8c: c6 20 60 10 st %g3, [ %g1 + 0x10 ]
}
ts->Interval_watchdogs.last_snapshot = snapshot;
2018b90: c4 26 20 3c st %g2, [ %i0 + 0x3c ]
_ISR_Enable( level );
2018b94: 7f ff df 1b call 2010800 <sparc_enable_interrupts>
2018b98: 01 00 00 00 nop
_Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker );
2018b9c: 90 06 20 30 add %i0, 0x30, %o0
2018ba0: 40 00 12 16 call 201d3f8 <_Watchdog_Insert>
2018ba4: 92 07 60 10 add %i5, 0x10, %o1
if ( !ts->active ) {
2018ba8: c2 0e 20 7c ldub [ %i0 + 0x7c ], %g1
2018bac: 80 a0 60 00 cmp %g1, 0
2018bb0: 12 80 00 2d bne 2018c64 <_Timer_server_Schedule_operation_method+0x140>
2018bb4: 01 00 00 00 nop
_Timer_server_Reset_interval_system_watchdog( ts );
2018bb8: 7f ff ff b3 call 2018a84 <_Timer_server_Reset_interval_system_watchdog>
2018bbc: 90 10 00 18 mov %i0, %o0
2018bc0: 30 80 00 29 b,a 2018c64 <_Timer_server_Schedule_operation_method+0x140>
}
} else if ( timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) {
2018bc4: 12 80 00 28 bne 2018c64 <_Timer_server_Schedule_operation_method+0x140>
2018bc8: 01 00 00 00 nop
/*
* We have to advance the last known seconds value of the server and update
* the watchdog chain accordingly.
*/
_ISR_Disable( level );
2018bcc: 7f ff df 09 call 20107f0 <sparc_disable_interrupts>
2018bd0: 01 00 00 00 nop
2018bd4: b8 10 00 08 mov %o0, %i4
2018bd8: 03 00 80 f3 sethi %hi(0x203cc00), %g1
2018bdc: d0 18 60 b8 ldd [ %g1 + 0xb8 ], %o0 ! 203ccb8 <_TOD>
2018be0: 94 10 20 00 clr %o2
2018be4: 17 0e e6 b2 sethi %hi(0x3b9ac800), %o3
2018be8: 40 00 4f 89 call 202ca0c <__divdi3>
2018bec: 96 12 e2 00 or %o3, 0x200, %o3 ! 3b9aca00 <RAM_END+0x395aca00>
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_head( the_chain )->next;
2018bf0: c2 06 20 68 ld [ %i0 + 0x68 ], %g1
snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch();
last_snapshot = ts->TOD_watchdogs.last_snapshot;
2018bf4: c4 06 20 74 ld [ %i0 + 0x74 ], %g2
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
2018bf8: 86 06 20 6c add %i0, 0x6c, %g3
if ( !_Chain_Is_empty( &ts->TOD_watchdogs.Chain ) ) {
2018bfc: 80 a0 40 03 cmp %g1, %g3
2018c00: 02 80 00 0d be 2018c34 <_Timer_server_Schedule_operation_method+0x110>
2018c04: 80 a2 40 02 cmp %o1, %g2
first_watchdog = _Watchdog_First( &ts->TOD_watchdogs.Chain );
delta_interval = first_watchdog->delta_interval;
if ( snapshot > last_snapshot ) {
2018c08: 08 80 00 08 bleu 2018c28 <_Timer_server_Schedule_operation_method+0x104>
2018c0c: c6 00 60 10 ld [ %g1 + 0x10 ], %g3
/*
* We advanced in time.
*/
delta = snapshot - last_snapshot;
2018c10: 88 22 40 02 sub %o1, %g2, %g4
if (delta_interval > delta) {
2018c14: 80 a0 c0 04 cmp %g3, %g4
2018c18: 08 80 00 06 bleu 2018c30 <_Timer_server_Schedule_operation_method+0x10c><== NEVER TAKEN
2018c1c: 84 10 20 00 clr %g2
delta_interval -= delta;
2018c20: 10 80 00 04 b 2018c30 <_Timer_server_Schedule_operation_method+0x10c>
2018c24: 84 20 c0 04 sub %g3, %g4, %g2
}
} else {
/*
* Someone put us in the past.
*/
delta = last_snapshot - snapshot;
2018c28: 84 00 c0 02 add %g3, %g2, %g2
delta_interval += delta;
2018c2c: 84 20 80 09 sub %g2, %o1, %g2
}
first_watchdog->delta_interval = delta_interval;
2018c30: c4 20 60 10 st %g2, [ %g1 + 0x10 ]
}
ts->TOD_watchdogs.last_snapshot = snapshot;
2018c34: d2 26 20 74 st %o1, [ %i0 + 0x74 ]
_ISR_Enable( level );
2018c38: 7f ff de f2 call 2010800 <sparc_enable_interrupts>
2018c3c: 90 10 00 1c mov %i4, %o0
_Watchdog_Insert( &ts->TOD_watchdogs.Chain, &timer->Ticker );
2018c40: 90 06 20 68 add %i0, 0x68, %o0
2018c44: 40 00 11 ed call 201d3f8 <_Watchdog_Insert>
2018c48: 92 07 60 10 add %i5, 0x10, %o1
if ( !ts->active ) {
2018c4c: c2 0e 20 7c ldub [ %i0 + 0x7c ], %g1
2018c50: 80 a0 60 00 cmp %g1, 0
2018c54: 12 80 00 04 bne 2018c64 <_Timer_server_Schedule_operation_method+0x140>
2018c58: 01 00 00 00 nop
_Timer_server_Reset_tod_system_watchdog( ts );
2018c5c: 7f ff ff 9e call 2018ad4 <_Timer_server_Reset_tod_system_watchdog>
2018c60: 90 10 00 18 mov %i0, %o0
}
}
_Thread_Enable_dispatch();
2018c64: 40 00 0e 0a call 201c48c <_Thread_Enable_dispatch>
2018c68: 81 e8 00 00 restore
* 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 );
2018c6c: f0 06 20 78 ld [ %i0 + 0x78 ], %i0
2018c70: 40 00 02 b0 call 2019730 <_Chain_Append>
2018c74: 81 e8 00 00 restore
0200c558 <_Timestamp64_Divide>:
const Timestamp64_Control *_lhs,
const Timestamp64_Control *_rhs,
uint32_t *_ival_percentage,
uint32_t *_fval_percentage
)
{
200c558: 9d e3 bf a0 save %sp, -96, %sp
Timestamp64_Control answer;
if ( *_rhs == 0 ) {
200c55c: d4 1e 40 00 ldd [ %i1 ], %o2
200c560: 80 92 80 0b orcc %o2, %o3, %g0
200c564: 32 80 00 06 bne,a 200c57c <_Timestamp64_Divide+0x24> <== ALWAYS TAKEN
200c568: f8 1e 00 00 ldd [ %i0 ], %i4
*_ival_percentage = 0;
200c56c: c0 26 80 00 clr [ %i2 ] <== NOT EXECUTED
*_fval_percentage = 0;
200c570: c0 26 c0 00 clr [ %i3 ] <== NOT EXECUTED
return;
200c574: 81 c7 e0 08 ret <== NOT EXECUTED
200c578: 81 e8 00 00 restore <== NOT EXECUTED
* This looks odd but gives the results the proper precision.
*
* TODO: Rounding on the last digit of the fval.
*/
answer = (*_lhs * 100000) / *_rhs;
200c57c: 83 2f 20 02 sll %i4, 2, %g1
200c580: 89 37 60 1e srl %i5, 0x1e, %g4
200c584: 87 2f 60 02 sll %i5, 2, %g3
200c588: 84 11 00 01 or %g4, %g1, %g2
200c58c: 83 30 e0 1b srl %g3, 0x1b, %g1
200c590: b1 28 a0 05 sll %g2, 5, %i0
200c594: b3 28 e0 05 sll %g3, 5, %i1
200c598: b0 10 40 18 or %g1, %i0, %i0
200c59c: 92 a6 40 03 subcc %i1, %g3, %o1
200c5a0: 90 66 00 02 subx %i0, %g2, %o0
200c5a4: 92 82 40 1d addcc %o1, %i5, %o1
200c5a8: 83 32 60 1e srl %o1, 0x1e, %g1
200c5ac: 90 42 00 1c addx %o0, %i4, %o0
200c5b0: bb 2a 60 02 sll %o1, 2, %i5
200c5b4: b9 2a 20 02 sll %o0, 2, %i4
200c5b8: 92 82 40 1d addcc %o1, %i5, %o1
200c5bc: b8 10 40 1c or %g1, %i4, %i4
200c5c0: 83 32 60 1e srl %o1, 0x1e, %g1
200c5c4: 90 42 00 1c addx %o0, %i4, %o0
200c5c8: bb 2a 60 02 sll %o1, 2, %i5
200c5cc: b9 2a 20 02 sll %o0, 2, %i4
200c5d0: 92 82 40 1d addcc %o1, %i5, %o1
200c5d4: b8 10 40 1c or %g1, %i4, %i4
200c5d8: 87 32 60 1b srl %o1, 0x1b, %g3
200c5dc: 90 42 00 1c addx %o0, %i4, %o0
200c5e0: 83 2a 60 05 sll %o1, 5, %g1
200c5e4: 85 2a 20 05 sll %o0, 5, %g2
200c5e8: 92 10 00 01 mov %g1, %o1
200c5ec: 40 00 3a 1a call 201ae54 <__divdi3>
200c5f0: 90 10 c0 02 or %g3, %g2, %o0
*_ival_percentage = answer / 1000;
200c5f4: 94 10 20 00 clr %o2
* This looks odd but gives the results the proper precision.
*
* TODO: Rounding on the last digit of the fval.
*/
answer = (*_lhs * 100000) / *_rhs;
200c5f8: b8 10 00 08 mov %o0, %i4
200c5fc: ba 10 00 09 mov %o1, %i5
*_ival_percentage = answer / 1000;
200c600: 40 00 3a 15 call 201ae54 <__divdi3>
200c604: 96 10 23 e8 mov 0x3e8, %o3
*_fval_percentage = answer % 1000;
200c608: 90 10 00 1c mov %i4, %o0
* TODO: Rounding on the last digit of the fval.
*/
answer = (*_lhs * 100000) / *_rhs;
*_ival_percentage = answer / 1000;
200c60c: d2 26 80 00 st %o1, [ %i2 ]
*_fval_percentage = answer % 1000;
200c610: 94 10 20 00 clr %o2
200c614: 92 10 00 1d mov %i5, %o1
200c618: 40 00 3a fa call 201b200 <__moddi3>
200c61c: 96 10 23 e8 mov 0x3e8, %o3
200c620: d2 26 c0 00 st %o1, [ %i3 ]
200c624: 81 c7 e0 08 ret
200c628: 81 e8 00 00 restore
0200ac0c <_User_extensions_Handler_initialization>:
#include <rtems/score/userext.h>
#include <rtems/score/wkspace.h>
#include <string.h>
void _User_extensions_Handler_initialization(void)
{
200ac0c: 9d e3 bf a0 save %sp, -96, %sp
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;
200ac10: 03 00 80 73 sethi %hi(0x201cc00), %g1
200ac14: 82 10 60 ec or %g1, 0xec, %g1 ! 201ccec <Configuration>
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
200ac18: 05 00 80 77 sethi %hi(0x201dc00), %g2
initial_extensions = Configuration.User_extension_table;
200ac1c: f4 00 60 48 ld [ %g1 + 0x48 ], %i2
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;
200ac20: f8 00 60 44 ld [ %g1 + 0x44 ], %i4
200ac24: 82 10 a0 b8 or %g2, 0xb8, %g1
200ac28: 86 00 60 04 add %g1, 4, %g3
head->previous = NULL;
200ac2c: c0 20 60 04 clr [ %g1 + 4 ]
tail->previous = head;
200ac30: c2 20 60 08 st %g1, [ %g1 + 8 ]
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
200ac34: c6 20 a0 b8 st %g3, [ %g2 + 0xb8 ]
200ac38: 05 00 80 76 sethi %hi(0x201d800), %g2
200ac3c: 82 10 a2 e4 or %g2, 0x2e4, %g1 ! 201dae4 <_User_extensions_Switches_list>
200ac40: 86 00 60 04 add %g1, 4, %g3
head->previous = NULL;
200ac44: c0 20 60 04 clr [ %g1 + 4 ]
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
200ac48: c6 20 a2 e4 st %g3, [ %g2 + 0x2e4 ]
initial_extensions = Configuration.User_extension_table;
_Chain_Initialize_empty( &_User_extensions_List );
_Chain_Initialize_empty( &_User_extensions_Switches_list );
if ( initial_extensions ) {
200ac4c: 80 a6 a0 00 cmp %i2, 0
200ac50: 02 80 00 1b be 200acbc <_User_extensions_Handler_initialization+0xb0><== NEVER TAKEN
200ac54: c2 20 60 08 st %g1, [ %g1 + 8 ]
extension = (User_extensions_Control *)
_Workspace_Allocate_or_fatal_error(
number_of_extensions * sizeof( User_extensions_Control )
200ac58: 83 2f 20 02 sll %i4, 2, %g1
200ac5c: b7 2f 20 04 sll %i4, 4, %i3
200ac60: b6 26 c0 01 sub %i3, %g1, %i3
200ac64: b6 06 c0 1c add %i3, %i4, %i3
200ac68: b7 2e e0 02 sll %i3, 2, %i3
_Chain_Initialize_empty( &_User_extensions_List );
_Chain_Initialize_empty( &_User_extensions_Switches_list );
if ( initial_extensions ) {
extension = (User_extensions_Control *)
200ac6c: 40 00 01 71 call 200b230 <_Workspace_Allocate_or_fatal_error>
200ac70: 90 10 00 1b mov %i3, %o0
_Workspace_Allocate_or_fatal_error(
number_of_extensions * sizeof( User_extensions_Control )
);
memset (
200ac74: 94 10 00 1b mov %i3, %o2
_Chain_Initialize_empty( &_User_extensions_List );
_Chain_Initialize_empty( &_User_extensions_Switches_list );
if ( initial_extensions ) {
extension = (User_extensions_Control *)
200ac78: ba 10 00 08 mov %o0, %i5
_Workspace_Allocate_or_fatal_error(
number_of_extensions * sizeof( User_extensions_Control )
);
memset (
200ac7c: 92 10 20 00 clr %o1
200ac80: 40 00 15 e8 call 2010420 <memset>
200ac84: b6 10 20 00 clr %i3
extension,
0,
number_of_extensions * sizeof( User_extensions_Control )
);
for ( i = 0 ; i < number_of_extensions ; i++ ) {
200ac88: 10 80 00 0b b 200acb4 <_User_extensions_Handler_initialization+0xa8>
200ac8c: 80 a6 c0 1c cmp %i3, %i4
RTEMS_INLINE_ROUTINE void _User_extensions_Add_set_with_table(
User_extensions_Control *extension,
const User_extensions_Table *extension_table
)
{
extension->Callouts = *extension_table;
200ac90: 90 07 60 14 add %i5, 0x14, %o0
200ac94: 92 06 80 09 add %i2, %o1, %o1
200ac98: 40 00 15 a5 call 201032c <memcpy>
200ac9c: 94 10 20 20 mov 0x20, %o2
_User_extensions_Add_set( extension );
200aca0: 90 10 00 1d mov %i5, %o0
200aca4: 40 00 0c 84 call 200deb4 <_User_extensions_Add_set>
200aca8: b6 06 e0 01 inc %i3
_User_extensions_Add_set_with_table (extension, &initial_extensions[i]);
extension++;
200acac: ba 07 60 34 add %i5, 0x34, %i5
extension,
0,
number_of_extensions * sizeof( User_extensions_Control )
);
for ( i = 0 ; i < number_of_extensions ; i++ ) {
200acb0: 80 a6 c0 1c cmp %i3, %i4
200acb4: 12 bf ff f7 bne 200ac90 <_User_extensions_Handler_initialization+0x84>
200acb8: 93 2e e0 05 sll %i3, 5, %o1
200acbc: 81 c7 e0 08 ret
200acc0: 81 e8 00 00 restore
0200c934 <_Watchdog_Adjust>:
void _Watchdog_Adjust(
Chain_Control *header,
Watchdog_Adjust_directions direction,
Watchdog_Interval units
)
{
200c934: 9d e3 bf a0 save %sp, -96, %sp
ISR_Level level;
_ISR_Disable( level );
200c938: 7f ff da f5 call 200350c <sparc_disable_interrupts>
200c93c: 01 00 00 00 nop
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_head( the_chain )->next;
200c940: c2 06 00 00 ld [ %i0 ], %g1
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
200c944: b8 06 20 04 add %i0, 4, %i4
* hence the compiler must not assume *header to remain
* unmodified across that call.
*
* Till Straumann, 7/2003
*/
if ( !_Chain_Is_empty( header ) ) {
200c948: 80 a0 40 1c cmp %g1, %i4
200c94c: 02 80 00 20 be 200c9cc <_Watchdog_Adjust+0x98>
200c950: 80 a6 60 00 cmp %i1, 0
switch ( direction ) {
200c954: 02 80 00 1b be 200c9c0 <_Watchdog_Adjust+0x8c>
200c958: b6 10 20 01 mov 1, %i3
200c95c: 80 a6 60 01 cmp %i1, 1
200c960: 12 80 00 1b bne 200c9cc <_Watchdog_Adjust+0x98> <== NEVER TAKEN
200c964: 01 00 00 00 nop
case WATCHDOG_BACKWARD:
_Watchdog_First( header )->delta_interval += units;
200c968: c4 00 60 10 ld [ %g1 + 0x10 ], %g2
200c96c: 10 80 00 07 b 200c988 <_Watchdog_Adjust+0x54>
200c970: b4 00 80 1a add %g2, %i2, %i2
break;
case WATCHDOG_FORWARD:
while ( units ) {
if ( units < _Watchdog_First( header )->delta_interval ) {
200c974: c4 00 60 10 ld [ %g1 + 0x10 ], %g2
200c978: 80 a6 80 02 cmp %i2, %g2
200c97c: 3a 80 00 05 bcc,a 200c990 <_Watchdog_Adjust+0x5c>
200c980: f6 20 60 10 st %i3, [ %g1 + 0x10 ]
_Watchdog_First( header )->delta_interval -= units;
200c984: b4 20 80 1a sub %g2, %i2, %i2
break;
200c988: 10 80 00 11 b 200c9cc <_Watchdog_Adjust+0x98>
200c98c: f4 20 60 10 st %i2, [ %g1 + 0x10 ]
} else {
units -= _Watchdog_First( header )->delta_interval;
200c990: b4 26 80 02 sub %i2, %g2, %i2
_Watchdog_First( header )->delta_interval = 1;
_ISR_Enable( level );
200c994: 7f ff da e2 call 200351c <sparc_enable_interrupts>
200c998: 01 00 00 00 nop
_Watchdog_Tickle( header );
200c99c: 40 00 00 90 call 200cbdc <_Watchdog_Tickle>
200c9a0: 90 10 00 18 mov %i0, %o0
_ISR_Disable( level );
200c9a4: 7f ff da da call 200350c <sparc_disable_interrupts>
200c9a8: 01 00 00 00 nop
if ( _Chain_Is_empty( header ) )
200c9ac: c2 06 00 00 ld [ %i0 ], %g1
200c9b0: 80 a0 40 1c cmp %g1, %i4
200c9b4: 12 80 00 04 bne 200c9c4 <_Watchdog_Adjust+0x90>
200c9b8: 80 a6 a0 00 cmp %i2, 0
200c9bc: 30 80 00 04 b,a 200c9cc <_Watchdog_Adjust+0x98>
switch ( direction ) {
case WATCHDOG_BACKWARD:
_Watchdog_First( header )->delta_interval += units;
break;
case WATCHDOG_FORWARD:
while ( units ) {
200c9c0: 80 a6 a0 00 cmp %i2, 0
200c9c4: 32 bf ff ec bne,a 200c974 <_Watchdog_Adjust+0x40> <== ALWAYS TAKEN
200c9c8: c2 06 00 00 ld [ %i0 ], %g1
}
break;
}
}
_ISR_Enable( level );
200c9cc: 7f ff da d4 call 200351c <sparc_enable_interrupts>
200c9d0: 91 e8 00 08 restore %g0, %o0, %o0
0200b034 <_Watchdog_Remove>:
*/
Watchdog_States _Watchdog_Remove(
Watchdog_Control *the_watchdog
)
{
200b034: 9d e3 bf a0 save %sp, -96, %sp
ISR_Level level;
Watchdog_States previous_state;
Watchdog_Control *next_watchdog;
_ISR_Disable( level );
200b038: 7f ff dd a3 call 20026c4 <sparc_disable_interrupts>
200b03c: ba 10 00 18 mov %i0, %i5
previous_state = the_watchdog->state;
200b040: f0 06 20 08 ld [ %i0 + 8 ], %i0
switch ( previous_state ) {
200b044: 80 a6 20 01 cmp %i0, 1
200b048: 22 80 00 1e be,a 200b0c0 <_Watchdog_Remove+0x8c>
200b04c: c0 27 60 08 clr [ %i5 + 8 ]
200b050: 0a 80 00 1d bcs 200b0c4 <_Watchdog_Remove+0x90>
200b054: 03 00 80 76 sethi %hi(0x201d800), %g1
200b058: 80 a6 20 03 cmp %i0, 3
200b05c: 18 80 00 1a bgu 200b0c4 <_Watchdog_Remove+0x90> <== NEVER TAKEN
200b060: 01 00 00 00 nop
RTEMS_INLINE_ROUTINE Watchdog_Control *_Watchdog_Next(
Watchdog_Control *the_watchdog
)
{
return ( (Watchdog_Control *) the_watchdog->Node.next );
200b064: 10 80 00 02 b 200b06c <_Watchdog_Remove+0x38>
200b068: c2 07 40 00 ld [ %i5 ], %g1
break;
case WATCHDOG_ACTIVE:
case WATCHDOG_REMOVE_IT:
the_watchdog->state = WATCHDOG_INACTIVE;
200b06c: c0 27 60 08 clr [ %i5 + 8 ]
next_watchdog = _Watchdog_Next( the_watchdog );
if ( _Watchdog_Next(next_watchdog) )
200b070: c4 00 40 00 ld [ %g1 ], %g2
200b074: 80 a0 a0 00 cmp %g2, 0
200b078: 02 80 00 07 be 200b094 <_Watchdog_Remove+0x60>
200b07c: 05 00 80 76 sethi %hi(0x201d800), %g2
next_watchdog->delta_interval += the_watchdog->delta_interval;
200b080: c6 00 60 10 ld [ %g1 + 0x10 ], %g3
200b084: c4 07 60 10 ld [ %i5 + 0x10 ], %g2
200b088: 84 00 c0 02 add %g3, %g2, %g2
200b08c: c4 20 60 10 st %g2, [ %g1 + 0x10 ]
if ( _Watchdog_Sync_count )
200b090: 05 00 80 76 sethi %hi(0x201d800), %g2
200b094: c4 00 a3 d4 ld [ %g2 + 0x3d4 ], %g2 ! 201dbd4 <_Watchdog_Sync_count>
200b098: 80 a0 a0 00 cmp %g2, 0
200b09c: 22 80 00 07 be,a 200b0b8 <_Watchdog_Remove+0x84>
200b0a0: c4 07 60 04 ld [ %i5 + 4 ], %g2
_Watchdog_Sync_level = _ISR_Nest_level;
200b0a4: 05 00 80 78 sethi %hi(0x201e000), %g2
200b0a8: c6 00 a0 18 ld [ %g2 + 0x18 ], %g3 ! 201e018 <_Per_CPU_Information+0x8>
200b0ac: 05 00 80 76 sethi %hi(0x201d800), %g2
200b0b0: c6 20 a3 74 st %g3, [ %g2 + 0x374 ] ! 201db74 <_Watchdog_Sync_level>
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
previous = the_node->previous;
200b0b4: c4 07 60 04 ld [ %i5 + 4 ], %g2
next->previous = previous;
200b0b8: c4 20 60 04 st %g2, [ %g1 + 4 ]
previous->next = next;
200b0bc: c2 20 80 00 st %g1, [ %g2 ]
_Chain_Extract_unprotected( &the_watchdog->Node );
break;
}
the_watchdog->stop_time = _Watchdog_Ticks_since_boot;
200b0c0: 03 00 80 76 sethi %hi(0x201d800), %g1
200b0c4: c2 00 63 d8 ld [ %g1 + 0x3d8 ], %g1 ! 201dbd8 <_Watchdog_Ticks_since_boot>
200b0c8: c2 27 60 18 st %g1, [ %i5 + 0x18 ]
_ISR_Enable( level );
200b0cc: 7f ff dd 82 call 20026d4 <sparc_enable_interrupts>
200b0d0: 01 00 00 00 nop
return( previous_state );
}
200b0d4: 81 c7 e0 08 ret
200b0d8: 81 e8 00 00 restore
0200c2a4 <_Watchdog_Report_chain>:
void _Watchdog_Report_chain(
const char *name,
Chain_Control *header
)
{
200c2a4: 9d e3 bf a0 save %sp, -96, %sp
ISR_Level level;
Chain_Node *node;
_ISR_Disable( level );
200c2a8: 7f ff db 76 call 2003080 <sparc_disable_interrupts>
200c2ac: b8 10 00 18 mov %i0, %i4
200c2b0: b0 10 00 08 mov %o0, %i0
printk( "Watchdog Chain: %s %p\n", name, header );
200c2b4: 11 00 80 76 sethi %hi(0x201d800), %o0
200c2b8: 94 10 00 19 mov %i1, %o2
200c2bc: 90 12 20 50 or %o0, 0x50, %o0
200c2c0: 7f ff e3 5a call 2005028 <printk>
200c2c4: 92 10 00 1c mov %i4, %o1
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_head( the_chain )->next;
200c2c8: fa 06 40 00 ld [ %i1 ], %i5
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
200c2cc: b2 06 60 04 add %i1, 4, %i1
if ( !_Chain_Is_empty( header ) ) {
200c2d0: 80 a7 40 19 cmp %i5, %i1
200c2d4: 12 80 00 04 bne 200c2e4 <_Watchdog_Report_chain+0x40>
200c2d8: 92 10 00 1d mov %i5, %o1
_Watchdog_Report( NULL, watch );
}
printk( "== end of %s \n", name );
} else {
printk( "Chain is empty\n" );
200c2dc: 10 80 00 0d b 200c310 <_Watchdog_Report_chain+0x6c>
200c2e0: 11 00 80 76 sethi %hi(0x201d800), %o0
node != _Chain_Tail(header) ;
node = node->next )
{
Watchdog_Control *watch = (Watchdog_Control *) node;
_Watchdog_Report( NULL, watch );
200c2e4: 40 00 00 0f call 200c320 <_Watchdog_Report>
200c2e8: 90 10 20 00 clr %o0
_ISR_Disable( level );
printk( "Watchdog Chain: %s %p\n", name, header );
if ( !_Chain_Is_empty( header ) ) {
for ( node = _Chain_First( header ) ;
node != _Chain_Tail(header) ;
node = node->next )
200c2ec: fa 07 40 00 ld [ %i5 ], %i5
Chain_Node *node;
_ISR_Disable( level );
printk( "Watchdog Chain: %s %p\n", name, header );
if ( !_Chain_Is_empty( header ) ) {
for ( node = _Chain_First( header ) ;
200c2f0: 80 a7 40 19 cmp %i5, %i1
200c2f4: 12 bf ff fc bne 200c2e4 <_Watchdog_Report_chain+0x40> <== NEVER TAKEN
200c2f8: 92 10 00 1d mov %i5, %o1
{
Watchdog_Control *watch = (Watchdog_Control *) node;
_Watchdog_Report( NULL, watch );
}
printk( "== end of %s \n", name );
200c2fc: 11 00 80 76 sethi %hi(0x201d800), %o0
200c300: 92 10 00 1c mov %i4, %o1
200c304: 7f ff e3 49 call 2005028 <printk>
200c308: 90 12 20 68 or %o0, 0x68, %o0
200c30c: 30 80 00 03 b,a 200c318 <_Watchdog_Report_chain+0x74>
} else {
printk( "Chain is empty\n" );
200c310: 7f ff e3 46 call 2005028 <printk>
200c314: 90 12 20 78 or %o0, 0x78, %o0
}
_ISR_Enable( level );
200c318: 7f ff db 5e call 2003090 <sparc_enable_interrupts>
200c31c: 81 e8 00 00 restore
02026450 <_fat_block_read>:
uint32_t start,
uint32_t offset,
uint32_t count,
void *buff
)
{
2026450: 9d e3 bf 98 save %sp, -104, %sp
int rc = RC_OK;
ssize_t cmpltd = 0;
2026454: ba 10 20 00 clr %i5
uint32_t blk = start;
uint32_t ofs = offset;
rtems_bdbuf_buffer *block = NULL;
uint32_t c = 0;
while (count > 0)
2026458: 10 80 00 18 b 20264b8 <_fat_block_read+0x68>
202645c: c0 27 bf fc clr [ %fp + -4 ]
{
rc = fat_buf_access(fs_info, blk, FAT_OP_TYPE_READ, &block);
2026460: 92 10 00 19 mov %i1, %o1
2026464: 94 10 20 01 mov 1, %o2
2026468: 7f ff ff 25 call 20260fc <fat_buf_access>
202646c: 96 07 bf fc add %fp, -4, %o3
if (rc != RC_OK)
2026470: 80 a2 20 00 cmp %o0, 0
2026474: 32 80 00 16 bne,a 20264cc <_fat_block_read+0x7c> <== NEVER TAKEN
2026478: ba 10 3f ff mov -1, %i5 <== NOT EXECUTED
return -1;
c = MIN(count, (fs_info->vol.bps - ofs));
202647c: e0 16 00 00 lduh [ %i0 ], %l0
2026480: a0 24 00 1a sub %l0, %i2, %l0
2026484: 80 a4 00 1b cmp %l0, %i3
2026488: 38 80 00 02 bgu,a 2026490 <_fat_block_read+0x40>
202648c: a0 10 00 1b mov %i3, %l0
memcpy((buff + cmpltd), (block->buffer + ofs), c);
2026490: c2 07 bf fc ld [ %fp + -4 ], %g1
2026494: 90 07 00 1d add %i4, %i5, %o0
2026498: d2 00 60 1c ld [ %g1 + 0x1c ], %o1
202649c: 94 10 00 10 mov %l0, %o2
20264a0: 92 02 40 1a add %o1, %i2, %o1
20264a4: 40 00 7c 91 call 20456e8 <memcpy>
20264a8: b6 26 c0 10 sub %i3, %l0, %i3
count -= c;
cmpltd += c;
20264ac: ba 04 00 1d add %l0, %i5, %i5
blk++;
20264b0: b2 06 60 01 inc %i1
ofs = 0;
20264b4: b4 10 20 00 clr %i2
uint32_t blk = start;
uint32_t ofs = offset;
rtems_bdbuf_buffer *block = NULL;
uint32_t c = 0;
while (count > 0)
20264b8: 80 a6 e0 00 cmp %i3, 0
20264bc: 12 bf ff e9 bne 2026460 <_fat_block_read+0x10>
20264c0: 90 10 00 18 mov %i0, %o0
cmpltd += c;
blk++;
ofs = 0;
}
return cmpltd;
}
20264c4: 81 c7 e0 08 ret
20264c8: 91 e8 00 1d restore %g0, %i5, %o0
20264cc: b0 10 00 1d mov %i5, %i0 <== NOT EXECUTED
20264d0: 81 c7 e0 08 ret <== NOT EXECUTED
20264d4: 81 e8 00 00 restore <== NOT EXECUTED
020264d8 <_fat_block_write>:
fat_fs_info_t *fs_info,
uint32_t start,
uint32_t offset,
uint32_t count,
const void *buff)
{
20264d8: 9d e3 bf 98 save %sp, -104, %sp
}
static inline void
fat_buf_mark_modified(fat_fs_info_t *fs_info)
{
fs_info->c.modified = true;
20264dc: a2 10 20 01 mov 1, %l1
20264e0: a0 10 00 18 mov %i0, %l0
int rc = RC_OK;
ssize_t cmpltd = 0;
uint32_t blk = start;
uint32_t ofs = offset;
rtems_bdbuf_buffer *block = NULL;
20264e4: c0 27 bf fc clr [ %fp + -4 ]
uint32_t c = 0;
while(count > 0)
20264e8: 10 80 00 1b b 2026554 <_fat_block_write+0x7c>
20264ec: b0 10 20 00 clr %i0
{
c = MIN(count, (fs_info->vol.bps - ofs));
20264f0: ba 20 40 1a sub %g1, %i2, %i5
20264f4: 80 a7 40 1b cmp %i5, %i3
20264f8: 38 80 00 02 bgu,a 2026500 <_fat_block_write+0x28>
20264fc: ba 10 00 1b mov %i3, %i5
if (c == fs_info->vol.bps)
rc = fat_buf_access(fs_info, blk, FAT_OP_TYPE_GET, &block);
2026500: 90 10 00 10 mov %l0, %o0
2026504: 92 10 00 19 mov %i1, %o1
while(count > 0)
{
c = MIN(count, (fs_info->vol.bps - ofs));
if (c == fs_info->vol.bps)
2026508: 80 a7 40 01 cmp %i5, %g1
202650c: 02 80 00 03 be 2026518 <_fat_block_write+0x40>
2026510: 94 10 20 02 mov 2, %o2
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);
2026514: 94 10 20 01 mov 1, %o2
2026518: 7f ff fe f9 call 20260fc <fat_buf_access>
202651c: 96 07 bf fc add %fp, -4, %o3
if (rc != RC_OK)
2026520: 80 a2 20 00 cmp %o0, 0
2026524: 12 80 00 11 bne 2026568 <_fat_block_write+0x90> <== NEVER TAKEN
2026528: c2 07 bf fc ld [ %fp + -4 ], %g1
return -1;
memcpy((block->buffer + ofs), (buff + cmpltd), c);
202652c: 92 07 00 18 add %i4, %i0, %o1
2026530: d0 00 60 1c ld [ %g1 + 0x1c ], %o0
2026534: 94 10 00 1d mov %i5, %o2
2026538: 90 02 00 1a add %o0, %i2, %o0
202653c: 40 00 7c 6b call 20456e8 <memcpy>
2026540: b6 26 c0 1d sub %i3, %i5, %i3
fat_buf_mark_modified(fs_info);
count -= c;
cmpltd +=c;
2026544: b0 07 40 18 add %i5, %i0, %i0
2026548: e2 2c 20 7c stb %l1, [ %l0 + 0x7c ]
blk++;
202654c: b2 06 60 01 inc %i1
ofs = 0;
2026550: b4 10 20 00 clr %i2
uint32_t blk = start;
uint32_t ofs = offset;
rtems_bdbuf_buffer *block = NULL;
uint32_t c = 0;
while(count > 0)
2026554: 80 a6 e0 00 cmp %i3, 0
2026558: 32 bf ff e6 bne,a 20264f0 <_fat_block_write+0x18>
202655c: c2 14 00 00 lduh [ %l0 ], %g1
2026560: 81 c7 e0 08 ret
2026564: 81 e8 00 00 restore
cmpltd +=c;
blk++;
ofs = 0;
}
return cmpltd;
}
2026568: 81 c7 e0 08 ret <== NOT EXECUTED
202656c: 91 e8 3f ff restore %g0, -1, %o0 <== NOT EXECUTED
02026570 <_fat_block_zero>:
_fat_block_zero(
fat_fs_info_t *fs_info,
uint32_t start,
uint32_t offset,
uint32_t count)
{
2026570: 9d e3 bf 98 save %sp, -104, %sp
2026574: b8 10 20 01 mov 1, %i4
uint32_t blk = start;
uint32_t ofs = offset;
rtems_bdbuf_buffer *block = NULL;
uint32_t c = 0;
while(count > 0)
2026578: 10 80 00 1a b 20265e0 <_fat_block_zero+0x70>
202657c: c0 27 bf fc clr [ %fp + -4 ]
{
c = MIN(count, (fs_info->vol.bps - ofs));
2026580: ba 20 40 1a sub %g1, %i2, %i5
2026584: 80 a7 40 1b cmp %i5, %i3
2026588: 38 80 00 02 bgu,a 2026590 <_fat_block_zero+0x20> <== NEVER TAKEN
202658c: ba 10 00 1b mov %i3, %i5 <== NOT EXECUTED
if (c == fs_info->vol.bps)
rc = fat_buf_access(fs_info, blk, FAT_OP_TYPE_GET, &block);
2026590: 90 10 00 18 mov %i0, %o0
2026594: 92 10 00 19 mov %i1, %o1
while(count > 0)
{
c = MIN(count, (fs_info->vol.bps - ofs));
if (c == fs_info->vol.bps)
2026598: 80 a7 40 01 cmp %i5, %g1
202659c: 02 80 00 03 be 20265a8 <_fat_block_zero+0x38>
20265a0: 94 10 20 02 mov 2, %o2
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);
20265a4: 94 10 20 01 mov 1, %o2
20265a8: 7f ff fe d5 call 20260fc <fat_buf_access>
20265ac: 96 07 bf fc add %fp, -4, %o3
if (rc != RC_OK)
20265b0: 80 a2 20 00 cmp %o0, 0
20265b4: 12 80 00 10 bne 20265f4 <_fat_block_zero+0x84> <== NEVER TAKEN
20265b8: c2 07 bf fc ld [ %fp + -4 ], %g1
return -1;
memset((block->buffer + ofs), 0, c);
20265bc: 92 10 20 00 clr %o1
20265c0: d0 00 60 1c ld [ %g1 + 0x1c ], %o0
20265c4: 94 10 00 1d mov %i5, %o2
20265c8: 90 02 00 1a add %o0, %i2, %o0
20265cc: 40 00 7c d6 call 2045924 <memset>
20265d0: b6 26 c0 1d sub %i3, %i5, %i3
fat_buf_mark_modified(fs_info);
count -= c;
blk++;
20265d4: b2 06 60 01 inc %i1
20265d8: f8 2e 20 7c stb %i4, [ %i0 + 0x7c ]
ofs = 0;
20265dc: b4 10 20 00 clr %i2
uint32_t blk = start;
uint32_t ofs = offset;
rtems_bdbuf_buffer *block = NULL;
uint32_t c = 0;
while(count > 0)
20265e0: 80 a6 e0 00 cmp %i3, 0
20265e4: 32 bf ff e7 bne,a 2026580 <_fat_block_zero+0x10>
20265e8: c2 16 00 00 lduh [ %i0 ], %g1
count -= c;
blk++;
ofs = 0;
}
return 0;
20265ec: 81 c7 e0 08 ret
20265f0: 91 e8 20 00 restore %g0, 0, %o0
}
20265f4: 81 c7 e0 08 ret <== NOT EXECUTED
20265f8: 91 e8 3f ff restore %g0, -1, %o0 <== NOT EXECUTED
02028c40 <_lstat_r>:
struct _reent *ptr __attribute__((unused)),
const char *path,
struct stat *buf
)
{
return _STAT_NAME( path, buf );
2028c40: 90 10 00 09 mov %o1, %o0 <== NOT EXECUTED
2028c44: 92 10 00 0a mov %o2, %o1 <== NOT EXECUTED
2028c48: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED
2028c4c: 7f ff ff e9 call 2028bf0 <lstat> <== NOT EXECUTED
2028c50: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED
02004820 <_stat_r>:
struct _reent *ptr __attribute__((unused)),
const char *path,
struct stat *buf
)
{
return _STAT_NAME( path, buf );
2004820: 90 10 00 09 mov %o1, %o0 <== NOT EXECUTED
2004824: 92 10 00 0a mov %o2, %o1 <== NOT EXECUTED
2004828: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED
200482c: 7f ff ff e9 call 20047d0 <stat> <== NOT EXECUTED
2004830: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED
02007944 <aio_cancel>:
* operation(s) cannot be canceled
*/
int aio_cancel(int fildes, struct aiocb *aiocbp)
{
2007944: 9d e3 bf a0 save %sp, -96, %sp
rtems_aio_request_chain *r_chain;
int result;
pthread_mutex_lock (&aio_request_queue.mutex);
2007948: 3b 00 80 7f sethi %hi(0x201fc00), %i5
200794c: 40 00 04 68 call 2008aec <pthread_mutex_lock>
2007950: 90 17 62 bc or %i5, 0x2bc, %o0 ! 201febc <aio_request_queue>
if (fcntl (fildes, F_GETFD) < 0) {
2007954: 90 10 00 18 mov %i0, %o0
2007958: 40 00 1a ae call 200e410 <fcntl>
200795c: 92 10 20 01 mov 1, %o1
2007960: 80 a2 20 00 cmp %o0, 0
2007964: 16 80 00 08 bge 2007984 <aio_cancel+0x40>
2007968: 80 a6 60 00 cmp %i1, 0
pthread_mutex_unlock(&aio_request_queue.mutex);
200796c: 40 00 04 81 call 2008b70 <pthread_mutex_unlock>
2007970: 90 17 62 bc or %i5, 0x2bc, %o0
rtems_set_errno_and_return_minus_one (EBADF);
2007974: 40 00 28 ed call 2011d28 <__errno>
2007978: 01 00 00 00 nop
200797c: 10 80 00 54 b 2007acc <aio_cancel+0x188>
2007980: 82 10 20 09 mov 9, %g1 ! 9 <PROM_START+0x9>
}
/* if aiocbp is NULL remove all request for given file descriptor */
if (aiocbp == NULL) {
2007984: 32 80 00 35 bne,a 2007a58 <aio_cancel+0x114>
2007988: f8 06 40 00 ld [ %i1 ], %i4
AIO_printf ("Cancel all requests\n");
r_chain = rtems_aio_search_fd (&aio_request_queue.work_req, fildes, 0);
200798c: 11 00 80 7f sethi %hi(0x201fc00), %o0
2007990: 92 10 00 18 mov %i0, %o1
2007994: 90 12 23 04 or %o0, 0x304, %o0
2007998: 40 00 01 71 call 2007f5c <rtems_aio_search_fd>
200799c: 94 10 20 00 clr %o2
if (r_chain == NULL) {
20079a0: b8 92 20 00 orcc %o0, 0, %i4
20079a4: 12 80 00 20 bne 2007a24 <aio_cancel+0xe0>
20079a8: b6 07 20 1c add %i4, 0x1c, %i3
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_head( the_chain )->next;
20079ac: ba 17 62 bc or %i5, 0x2bc, %i5
AIO_printf ("Request chain not on [WQ]\n");
if (!rtems_chain_is_empty (&aio_request_queue.idle_req)) {
20079b0: c4 07 60 54 ld [ %i5 + 0x54 ], %g2
20079b4: 82 07 60 58 add %i5, 0x58, %g1
20079b8: 80 a0 80 01 cmp %g2, %g1
20079bc: 02 80 00 08 be 20079dc <aio_cancel+0x98> <== NEVER TAKEN
20079c0: 92 10 00 18 mov %i0, %o1
r_chain = rtems_aio_search_fd (&aio_request_queue.idle_req, fildes, 0);
20079c4: 90 07 60 54 add %i5, 0x54, %o0
20079c8: 40 00 01 65 call 2007f5c <rtems_aio_search_fd>
20079cc: 94 10 20 00 clr %o2
if (r_chain == NULL) {
20079d0: b8 92 20 00 orcc %o0, 0, %i4
20079d4: 12 80 00 08 bne 20079f4 <aio_cancel+0xb0>
20079d8: 01 00 00 00 nop
pthread_mutex_unlock(&aio_request_queue.mutex);
20079dc: 11 00 80 7f sethi %hi(0x201fc00), %o0
return AIO_ALLDONE;
20079e0: b0 10 20 02 mov 2, %i0
AIO_printf ("Request chain not on [WQ]\n");
if (!rtems_chain_is_empty (&aio_request_queue.idle_req)) {
r_chain = rtems_aio_search_fd (&aio_request_queue.idle_req, fildes, 0);
if (r_chain == NULL) {
pthread_mutex_unlock(&aio_request_queue.mutex);
20079e4: 40 00 04 63 call 2008b70 <pthread_mutex_unlock>
20079e8: 90 12 22 bc or %o0, 0x2bc, %o0
return AIO_ALLDONE;
20079ec: 81 c7 e0 08 ret
20079f0: 81 e8 00 00 restore
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
20079f4: 40 00 0a cb call 200a520 <_Chain_Extract>
20079f8: b6 07 20 1c add %i4, 0x1c, %i3
}
AIO_printf ("Request chain on [IQ]\n");
rtems_chain_extract (&r_chain->next_fd);
rtems_aio_remove_fd (r_chain);
20079fc: 40 00 01 80 call 2007ffc <rtems_aio_remove_fd>
2007a00: 90 10 00 1c mov %i4, %o0
pthread_mutex_destroy (&r_chain->mutex);
2007a04: 40 00 03 8c call 2008834 <pthread_mutex_destroy>
2007a08: 90 10 00 1b mov %i3, %o0
pthread_cond_destroy (&r_chain->mutex);
2007a0c: 40 00 02 ac call 20084bc <pthread_cond_destroy>
2007a10: 90 10 00 1b mov %i3, %o0
free (r_chain);
2007a14: 7f ff f0 d3 call 2003d60 <free>
2007a18: 90 10 00 1c mov %i4, %o0
pthread_mutex_unlock (&aio_request_queue.mutex);
2007a1c: 10 80 00 0b b 2007a48 <aio_cancel+0x104>
2007a20: 90 10 00 1d mov %i5, %o0
return AIO_ALLDONE;
}
AIO_printf ("Request chain on [WQ]\n");
pthread_mutex_lock (&r_chain->mutex);
2007a24: 40 00 04 32 call 2008aec <pthread_mutex_lock>
2007a28: 90 10 00 1b mov %i3, %o0
2007a2c: 40 00 0a bd call 200a520 <_Chain_Extract>
2007a30: 90 10 00 1c mov %i4, %o0
rtems_chain_extract (&r_chain->next_fd);
rtems_aio_remove_fd (r_chain);
2007a34: 40 00 01 72 call 2007ffc <rtems_aio_remove_fd>
2007a38: 90 10 00 1c mov %i4, %o0
pthread_mutex_unlock (&r_chain->mutex);
2007a3c: 40 00 04 4d call 2008b70 <pthread_mutex_unlock>
2007a40: 90 10 00 1b mov %i3, %o0
pthread_mutex_unlock (&aio_request_queue.mutex);
2007a44: 90 17 62 bc or %i5, 0x2bc, %o0
2007a48: 40 00 04 4a call 2008b70 <pthread_mutex_unlock>
2007a4c: b0 10 20 00 clr %i0
return AIO_CANCELED;
2007a50: 81 c7 e0 08 ret
2007a54: 81 e8 00 00 restore
} else {
AIO_printf ("Cancel request\n");
if (aiocbp->aio_fildes != fildes) {
2007a58: 80 a7 00 18 cmp %i4, %i0
2007a5c: 12 80 00 17 bne 2007ab8 <aio_cancel+0x174>
2007a60: 90 17 62 bc or %i5, 0x2bc, %o0
pthread_mutex_unlock (&aio_request_queue.mutex);
rtems_set_errno_and_return_minus_one (EINVAL);
}
r_chain = rtems_aio_search_fd (&aio_request_queue.work_req, fildes, 0);
2007a64: 11 00 80 7f sethi %hi(0x201fc00), %o0
2007a68: 92 10 00 1c mov %i4, %o1
2007a6c: 90 12 23 04 or %o0, 0x304, %o0
2007a70: 40 00 01 3b call 2007f5c <rtems_aio_search_fd>
2007a74: 94 10 20 00 clr %o2
if (r_chain == NULL) {
2007a78: b6 92 20 00 orcc %o0, 0, %i3
2007a7c: 32 80 00 1c bne,a 2007aec <aio_cancel+0x1a8>
2007a80: b8 06 e0 1c add %i3, 0x1c, %i4
2007a84: ba 17 62 bc or %i5, 0x2bc, %i5
if (!rtems_chain_is_empty (&aio_request_queue.idle_req)) {
2007a88: c4 07 60 54 ld [ %i5 + 0x54 ], %g2
2007a8c: 82 07 60 58 add %i5, 0x58, %g1
2007a90: 80 a0 80 01 cmp %g2, %g1
2007a94: 02 bf ff d2 be 20079dc <aio_cancel+0x98> <== NEVER TAKEN
2007a98: 92 10 00 1c mov %i4, %o1
r_chain = rtems_aio_search_fd (&aio_request_queue.idle_req, fildes, 0);
2007a9c: 90 07 60 54 add %i5, 0x54, %o0
2007aa0: 40 00 01 2f call 2007f5c <rtems_aio_search_fd>
2007aa4: 94 10 20 00 clr %o2
if (r_chain == NULL) {
2007aa8: 80 a2 20 00 cmp %o0, 0
2007aac: 12 80 00 0b bne 2007ad8 <aio_cancel+0x194>
2007ab0: 90 02 20 08 add %o0, 8, %o0
pthread_mutex_unlock (&aio_request_queue.mutex);
2007ab4: 90 10 00 1d mov %i5, %o0
2007ab8: 40 00 04 2e call 2008b70 <pthread_mutex_unlock>
2007abc: 01 00 00 00 nop
rtems_set_errno_and_return_minus_one (EINVAL);
2007ac0: 40 00 28 9a call 2011d28 <__errno>
2007ac4: 01 00 00 00 nop
2007ac8: 82 10 20 16 mov 0x16, %g1 ! 16 <PROM_START+0x16>
2007acc: c2 22 00 00 st %g1, [ %o0 ]
2007ad0: 81 c7 e0 08 ret
2007ad4: 91 e8 3f ff restore %g0, -1, %o0
}
AIO_printf ("Request on [IQ]\n");
result = rtems_aio_remove_req (&r_chain->perfd, aiocbp);
2007ad8: 40 00 01 5d call 200804c <rtems_aio_remove_req>
2007adc: 92 10 00 19 mov %i1, %o1
2007ae0: b0 10 00 08 mov %o0, %i0
pthread_mutex_unlock (&aio_request_queue.mutex);
2007ae4: 10 80 00 0b b 2007b10 <aio_cancel+0x1cc>
2007ae8: 90 10 00 1d mov %i5, %o0
return AIO_ALLDONE;
}
}
AIO_printf ("Request on [WQ]\n");
pthread_mutex_lock (&r_chain->mutex);
2007aec: 40 00 04 00 call 2008aec <pthread_mutex_lock>
2007af0: 90 10 00 1c mov %i4, %o0
result = rtems_aio_remove_req (&r_chain->perfd, aiocbp);
2007af4: 92 10 00 19 mov %i1, %o1
2007af8: 40 00 01 55 call 200804c <rtems_aio_remove_req>
2007afc: 90 06 e0 08 add %i3, 8, %o0
2007b00: b0 10 00 08 mov %o0, %i0
pthread_mutex_unlock (&r_chain->mutex);
2007b04: 40 00 04 1b call 2008b70 <pthread_mutex_unlock>
2007b08: 90 10 00 1c mov %i4, %o0
pthread_mutex_unlock (&aio_request_queue.mutex);
2007b0c: 90 17 62 bc or %i5, 0x2bc, %o0
2007b10: 40 00 04 18 call 2008b70 <pthread_mutex_unlock>
2007b14: 01 00 00 00 nop
return result;
}
return AIO_ALLDONE;
}
2007b18: 81 c7 e0 08 ret
2007b1c: 81 e8 00 00 restore
02007b28 <aio_fsync>:
int aio_fsync(
int op,
struct aiocb *aiocbp
)
{
2007b28: 9d e3 bf a0 save %sp, -96, %sp
rtems_aio_request *req;
int mode;
if (op != O_SYNC)
2007b2c: 03 00 00 08 sethi %hi(0x2000), %g1
2007b30: 80 a6 00 01 cmp %i0, %g1
2007b34: 12 80 00 10 bne 2007b74 <aio_fsync+0x4c>
2007b38: ba 10 20 16 mov 0x16, %i5
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
2007b3c: d0 06 40 00 ld [ %i1 ], %o0
2007b40: 40 00 1a 34 call 200e410 <fcntl>
2007b44: 92 10 20 03 mov 3, %o1
if (!(((mode & O_ACCMODE) == O_WRONLY) || ((mode & O_ACCMODE) == O_RDWR)))
2007b48: 90 0a 20 03 and %o0, 3, %o0
2007b4c: 90 02 3f ff add %o0, -1, %o0
2007b50: 80 a2 20 01 cmp %o0, 1
2007b54: 18 80 00 08 bgu 2007b74 <aio_fsync+0x4c>
2007b58: ba 10 20 09 mov 9, %i5
rtems_aio_set_errno_return_minus_one (EBADF, aiocbp);
req = malloc (sizeof (rtems_aio_request));
2007b5c: 7f ff f1 b6 call 2004234 <malloc>
2007b60: 90 10 20 18 mov 0x18, %o0
if (req == NULL)
2007b64: b0 92 20 00 orcc %o0, 0, %i0
2007b68: 32 80 00 09 bne,a 2007b8c <aio_fsync+0x64> <== ALWAYS TAKEN
2007b6c: f2 26 20 14 st %i1, [ %i0 + 0x14 ]
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
2007b70: ba 10 20 0b mov 0xb, %i5 <== NOT EXECUTED
2007b74: 82 10 3f ff mov -1, %g1
2007b78: fa 26 60 34 st %i5, [ %i1 + 0x34 ]
2007b7c: 40 00 28 6b call 2011d28 <__errno>
2007b80: c2 26 60 38 st %g1, [ %i1 + 0x38 ]
2007b84: 10 80 00 06 b 2007b9c <aio_fsync+0x74>
2007b88: fa 22 00 00 st %i5, [ %o0 ]
req->aiocbp = aiocbp;
req->aiocbp->aio_lio_opcode = LIO_SYNC;
2007b8c: 82 10 20 03 mov 3, %g1
2007b90: c2 26 60 30 st %g1, [ %i1 + 0x30 ]
return rtems_aio_enqueue (req);
2007b94: 40 00 01 4e call 20080cc <rtems_aio_enqueue>
2007b98: 81 e8 00 00 restore
}
2007b9c: 81 c7 e0 08 ret
2007ba0: 91 e8 3f ff restore %g0, -1, %o0
020082e4 <aio_read>:
* 0 - otherwise
*/
int
aio_read (struct aiocb *aiocbp)
{
20082e4: 9d e3 bf a0 save %sp, -96, %sp
rtems_aio_request *req;
int mode;
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
20082e8: d0 06 00 00 ld [ %i0 ], %o0
20082ec: 92 10 20 03 mov 3, %o1
20082f0: 40 00 18 48 call 200e410 <fcntl>
20082f4: ba 10 00 18 mov %i0, %i5
if (!(((mode & O_ACCMODE) == O_RDONLY) || ((mode & O_ACCMODE) == O_RDWR)))
20082f8: 80 8a 20 01 btst 1, %o0
20082fc: 12 80 00 11 bne 2008340 <aio_read+0x5c>
2008300: b8 10 20 09 mov 9, %i4
rtems_aio_set_errno_return_minus_one (EBADF, aiocbp);
if (aiocbp->aio_reqprio < 0 || aiocbp->aio_reqprio > AIO_PRIO_DELTA_MAX)
2008304: c2 06 20 18 ld [ %i0 + 0x18 ], %g1
2008308: 80 a0 60 00 cmp %g1, 0
200830c: 22 80 00 04 be,a 200831c <aio_read+0x38>
2008310: c2 06 20 08 ld [ %i0 + 8 ], %g1
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
if (aiocbp->aio_offset < 0)
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
2008314: 10 80 00 0b b 2008340 <aio_read+0x5c>
2008318: b8 10 20 16 mov 0x16, %i4
rtems_aio_set_errno_return_minus_one (EBADF, aiocbp);
if (aiocbp->aio_reqprio < 0 || aiocbp->aio_reqprio > AIO_PRIO_DELTA_MAX)
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
if (aiocbp->aio_offset < 0)
200831c: 80 a0 60 00 cmp %g1, 0
2008320: 06 80 00 08 bl 2008340 <aio_read+0x5c>
2008324: b8 10 20 16 mov 0x16, %i4
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
req = malloc (sizeof (rtems_aio_request));
2008328: 7f ff ef c3 call 2004234 <malloc>
200832c: 90 10 20 18 mov 0x18, %o0
if (req == NULL)
2008330: b0 92 20 00 orcc %o0, 0, %i0
2008334: 32 80 00 09 bne,a 2008358 <aio_read+0x74> <== ALWAYS TAKEN
2008338: fa 26 20 14 st %i5, [ %i0 + 0x14 ]
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
200833c: b8 10 20 0b mov 0xb, %i4 <== NOT EXECUTED
2008340: 82 10 3f ff mov -1, %g1
2008344: f8 27 60 34 st %i4, [ %i5 + 0x34 ]
2008348: 40 00 26 78 call 2011d28 <__errno>
200834c: c2 27 60 38 st %g1, [ %i5 + 0x38 ]
2008350: 10 80 00 06 b 2008368 <aio_read+0x84>
2008354: f8 22 00 00 st %i4, [ %o0 ]
req->aiocbp = aiocbp;
req->aiocbp->aio_lio_opcode = LIO_READ;
2008358: 82 10 20 01 mov 1, %g1
200835c: c2 27 60 30 st %g1, [ %i5 + 0x30 ]
return rtems_aio_enqueue (req);
2008360: 7f ff ff 5b call 20080cc <rtems_aio_enqueue>
2008364: 81 e8 00 00 restore
}
2008368: 81 c7 e0 08 ret
200836c: 91 e8 3f ff restore %g0, -1, %o0
02008378 <aio_write>:
* 0 - otherwise
*/
int
aio_write (struct aiocb *aiocbp)
{
2008378: 9d e3 bf a0 save %sp, -96, %sp
rtems_aio_request *req;
int mode;
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
200837c: d0 06 00 00 ld [ %i0 ], %o0
2008380: 40 00 18 24 call 200e410 <fcntl>
2008384: 92 10 20 03 mov 3, %o1
* 0 - otherwise
*/
int
aio_write (struct aiocb *aiocbp)
{
2008388: ba 10 00 18 mov %i0, %i5
rtems_aio_request *req;
int mode;
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
if (!(((mode & O_ACCMODE) == O_WRONLY) || ((mode & O_ACCMODE) == O_RDWR)))
200838c: 90 0a 20 03 and %o0, 3, %o0
2008390: 90 02 3f ff add %o0, -1, %o0
2008394: 80 a2 20 01 cmp %o0, 1
2008398: 18 80 00 11 bgu 20083dc <aio_write+0x64>
200839c: b8 10 20 09 mov 9, %i4
rtems_aio_set_errno_return_minus_one (EBADF, aiocbp);
if (aiocbp->aio_reqprio < 0 || aiocbp->aio_reqprio > AIO_PRIO_DELTA_MAX)
20083a0: c2 06 20 18 ld [ %i0 + 0x18 ], %g1
20083a4: 80 a0 60 00 cmp %g1, 0
20083a8: 22 80 00 04 be,a 20083b8 <aio_write+0x40>
20083ac: c2 06 20 08 ld [ %i0 + 8 ], %g1
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
if (aiocbp->aio_offset < 0)
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
20083b0: 10 80 00 0b b 20083dc <aio_write+0x64>
20083b4: b8 10 20 16 mov 0x16, %i4
rtems_aio_set_errno_return_minus_one (EBADF, aiocbp);
if (aiocbp->aio_reqprio < 0 || aiocbp->aio_reqprio > AIO_PRIO_DELTA_MAX)
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
if (aiocbp->aio_offset < 0)
20083b8: 80 a0 60 00 cmp %g1, 0
20083bc: 06 80 00 08 bl 20083dc <aio_write+0x64>
20083c0: b8 10 20 16 mov 0x16, %i4
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
req = malloc (sizeof (rtems_aio_request));
20083c4: 7f ff ef 9c call 2004234 <malloc>
20083c8: 90 10 20 18 mov 0x18, %o0
if (req == NULL)
20083cc: b0 92 20 00 orcc %o0, 0, %i0
20083d0: 32 80 00 09 bne,a 20083f4 <aio_write+0x7c> <== ALWAYS TAKEN
20083d4: fa 26 20 14 st %i5, [ %i0 + 0x14 ]
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
20083d8: b8 10 20 0b mov 0xb, %i4 <== NOT EXECUTED
20083dc: 82 10 3f ff mov -1, %g1
20083e0: f8 27 60 34 st %i4, [ %i5 + 0x34 ]
20083e4: 40 00 26 51 call 2011d28 <__errno>
20083e8: c2 27 60 38 st %g1, [ %i5 + 0x38 ]
20083ec: 10 80 00 06 b 2008404 <aio_write+0x8c>
20083f0: f8 22 00 00 st %i4, [ %o0 ]
req->aiocbp = aiocbp;
req->aiocbp->aio_lio_opcode = LIO_WRITE;
20083f4: 82 10 20 02 mov 2, %g1
20083f8: c2 27 60 30 st %g1, [ %i5 + 0x30 ]
return rtems_aio_enqueue (req);
20083fc: 7f ff ff 34 call 20080cc <rtems_aio_enqueue>
2008400: 81 e8 00 00 restore
}
2008404: 81 c7 e0 08 ret
2008408: 91 e8 3f ff restore %g0, -1, %o0
02027be8 <chroot>:
#include <unistd.h>
#include <rtems/libio_.h>
int chroot( const char *path )
{
2027be8: 9d e3 bf 48 save %sp, -184, %sp
/*
* We use the global environment for path evaluation. This makes it possible
* to escape from a chroot environment referencing an unmounted file system.
*/
rtems_filesystem_eval_path_start_with_root_and_current(
2027bec: 94 10 20 19 mov 0x19, %o2
2027bf0: 92 10 00 18 mov %i0, %o1
2027bf4: 90 07 bf c8 add %fp, -56, %o0
2027bf8: 17 00 81 ad sethi %hi(0x206b400), %o3
2027bfc: 96 12 e1 64 or %o3, 0x164, %o3 ! 206b564 <rtems_global_user_env+0x4>
2027c00: 7f ff 8a 33 call 200a4cc <rtems_filesystem_eval_path_start_with_root_and_current>
2027c04: 98 02 ff fc add %o3, -4, %o4
2027c08: 90 07 bf b0 add %fp, -80, %o0
2027c0c: 7f ff 8b 34 call 200a8dc <rtems_filesystem_location_copy_and_detach>
2027c10: 92 07 bf e0 add %fp, -32, %o1
&rtems_global_user_env.root_directory,
&rtems_global_user_env.current_directory
);
rtems_filesystem_eval_path_extract_currentloc( &ctx, &loc );
new_current_loc = rtems_filesystem_location_transform_to_global( &loc );
2027c14: 7f ff 8b ab call 200aac0 <rtems_filesystem_location_transform_to_global>
2027c18: 90 07 bf b0 add %fp, -80, %o0
if ( !rtems_filesystem_global_location_is_null( new_current_loc ) ) {
2027c1c: c2 02 20 10 ld [ %o0 + 0x10 ], %g1
2027c20: 39 00 81 7d sethi %hi(0x205f400), %i4
2027c24: b8 17 23 34 or %i4, 0x334, %i4 ! 205f734 <rtems_filesystem_null_handlers>
2027c28: 80 a0 40 1c cmp %g1, %i4
2027c2c: 02 80 00 29 be 2027cd0 <chroot+0xe8>
2027c30: d0 27 bf ac st %o0, [ %fp + -84 ]
rtems_filesystem_global_location_t *new_root_loc =
2027c34: 7f ff 8b 70 call 200a9f4 <rtems_filesystem_global_location_obtain>
2027c38: 90 07 bf ac add %fp, -84, %o0
rtems_filesystem_global_location_obtain( &new_current_loc );
rtems_filesystem_node_types_t type =
(*new_root_loc->location.mt_entry->ops->node_type_h)(
2027c3c: c2 02 20 14 ld [ %o0 + 0x14 ], %g1
2027c40: c2 00 60 0c ld [ %g1 + 0xc ], %g1
rtems_filesystem_eval_path_extract_currentloc( &ctx, &loc );
new_current_loc = rtems_filesystem_location_transform_to_global( &loc );
if ( !rtems_filesystem_global_location_is_null( new_current_loc ) ) {
rtems_filesystem_global_location_t *new_root_loc =
rtems_filesystem_global_location_obtain( &new_current_loc );
rtems_filesystem_node_types_t type =
2027c44: c2 00 60 14 ld [ %g1 + 0x14 ], %g1
2027c48: 9f c0 40 00 call %g1
2027c4c: ba 10 00 08 mov %o0, %i5
(*new_root_loc->location.mt_entry->ops->node_type_h)(
&new_root_loc->location
);
if ( type == RTEMS_FILESYSTEM_DIRECTORY ) {
2027c50: 80 a2 20 00 cmp %o0, 0
2027c54: 32 80 00 17 bne,a 2027cb0 <chroot+0xc8>
2027c58: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
sc = rtems_libio_set_private_env();
2027c5c: 40 00 05 10 call 202909c <rtems_libio_set_private_env>
2027c60: 01 00 00 00 nop
if (sc == RTEMS_SUCCESSFUL) {
2027c64: 80 a2 20 00 cmp %o0, 0
2027c68: 12 80 00 0c bne 2027c98 <chroot+0xb0>
2027c6c: 80 a2 20 0d cmp %o0, 0xd
rtems_filesystem_global_location_assign(
2027c70: 39 00 81 ad sethi %hi(0x206b400), %i4
2027c74: d0 07 21 5c ld [ %i4 + 0x15c ], %o0 ! 206b55c <rtems_current_user_env>
2027c78: 92 10 00 1d mov %i5, %o1
2027c7c: 7f ff 8b 55 call 200a9d0 <rtems_filesystem_global_location_assign>
2027c80: 90 02 20 04 add %o0, 4, %o0
&rtems_filesystem_root,
new_root_loc
);
rtems_filesystem_global_location_assign(
2027c84: d0 07 21 5c ld [ %i4 + 0x15c ], %o0
2027c88: d2 07 bf ac ld [ %fp + -84 ], %o1
2027c8c: 7f ff 8b 51 call 200a9d0 <rtems_filesystem_global_location_assign>
2027c90: b0 10 20 00 clr %i0
2027c94: 30 80 00 10 b,a 2027cd4 <chroot+0xec>
&rtems_filesystem_current,
new_current_loc
);
} else {
if (sc != RTEMS_UNSATISFIED) {
2027c98: 02 80 00 18 be 2027cf8 <chroot+0x110> <== NEVER TAKEN
2027c9c: 01 00 00 00 nop
errno = ENOMEM;
2027ca0: 40 00 69 53 call 20421ec <__errno>
2027ca4: 01 00 00 00 nop
2027ca8: 10 80 00 08 b 2027cc8 <chroot+0xe0>
2027cac: 82 10 20 0c mov 0xc, %g1 ! c <PROM_START+0xc>
static inline void rtems_filesystem_location_error(
const rtems_filesystem_location_info_t *loc,
int eno
)
{
if ( !rtems_filesystem_location_is_null( loc ) ) {
2027cb0: 80 a0 40 1c cmp %g1, %i4
2027cb4: 02 80 00 11 be 2027cf8 <chroot+0x110> <== NEVER TAKEN
2027cb8: 01 00 00 00 nop
errno = eno;
2027cbc: 40 00 69 4c call 20421ec <__errno>
2027cc0: 01 00 00 00 nop
2027cc4: 82 10 20 14 mov 0x14, %g1 ! 14 <PROM_START+0x14>
2027cc8: 10 80 00 0c b 2027cf8 <chroot+0x110>
2027ccc: c2 22 00 00 st %g1, [ %o0 ]
if ( rv != 0 ) {
rtems_filesystem_global_location_release( new_root_loc );
}
} else {
rv = -1;
2027cd0: b0 10 3f ff mov -1, %i0
}
rtems_filesystem_eval_path_cleanup( &ctx );
2027cd4: 7f ff 8a 44 call 200a5e4 <rtems_filesystem_eval_path_cleanup>
2027cd8: 90 07 bf c8 add %fp, -56, %o0
if ( rv != 0 ) {
2027cdc: 80 a6 20 00 cmp %i0, 0
2027ce0: 02 80 00 0a be 2027d08 <chroot+0x120>
2027ce4: 01 00 00 00 nop
rtems_filesystem_global_location_release( new_current_loc );
2027ce8: 7f ff 8b 22 call 200a970 <rtems_filesystem_global_location_release>
2027cec: d0 07 bf ac ld [ %fp + -84 ], %o0
2027cf0: 81 c7 e0 08 ret
2027cf4: 81 e8 00 00 restore
rtems_filesystem_location_error( &new_root_loc->location, ENOTDIR );
rv = -1;
}
if ( rv != 0 ) {
rtems_filesystem_global_location_release( new_root_loc );
2027cf8: 7f ff 8b 1e call 200a970 <rtems_filesystem_global_location_release>
2027cfc: 90 10 00 1d mov %i5, %o0
}
} else {
rv = -1;
2027d00: 10 bf ff f5 b 2027cd4 <chroot+0xec>
2027d04: b0 10 3f ff mov -1, %i0
if ( rv != 0 ) {
rtems_filesystem_global_location_release( new_current_loc );
}
return rv;
}
2027d08: 81 c7 e0 08 ret
2027d0c: 81 e8 00 00 restore
02007560 <clock_gettime>:
int clock_gettime(
clockid_t clock_id,
struct timespec *tp
)
{
2007560: 9d e3 bf 98 save %sp, -104, %sp
if ( !tp )
2007564: 80 a6 60 00 cmp %i1, 0
2007568: 02 80 00 24 be 20075f8 <clock_gettime+0x98>
200756c: 80 a6 20 01 cmp %i0, 1
rtems_set_errno_and_return_minus_one( EINVAL );
if ( clock_id == CLOCK_REALTIME ) {
2007570: 12 80 00 14 bne 20075c0 <clock_gettime+0x60>
2007574: 80 a6 20 04 cmp %i0, 4
struct timespec *tod_as_timespec
)
{
Timestamp_Control tod_as_timestamp;
_TOD_Get_as_timestamp( &tod_as_timestamp );
2007578: 40 00 08 19 call 20095dc <_TOD_Get_as_timestamp>
200757c: 90 07 bf f8 add %fp, -8, %o0
_Timestamp_To_timespec( &tod_as_timestamp, tod_as_timespec );
2007580: f8 1f bf f8 ldd [ %fp + -8 ], %i4
static inline void _Timestamp64_implementation_To_timespec(
const Timestamp64_Control *_timestamp,
struct timespec *_timespec
)
{
_timespec->tv_sec = (time_t) (*_timestamp / 1000000000L);
2007584: 94 10 20 00 clr %o2
2007588: 90 10 00 1c mov %i4, %o0
200758c: 92 10 00 1d mov %i5, %o1
2007590: 17 0e e6 b2 sethi %hi(0x3b9ac800), %o3
2007594: 40 00 53 b5 call 201c468 <__divdi3>
2007598: 96 12 e2 00 or %o3, 0x200, %o3 ! 3b9aca00 <RAM_END+0x395aca00>
_timespec->tv_nsec = (long) (*_timestamp % 1000000000L);
200759c: 90 10 00 1c mov %i4, %o0
static inline void _Timestamp64_implementation_To_timespec(
const Timestamp64_Control *_timestamp,
struct timespec *_timespec
)
{
_timespec->tv_sec = (time_t) (*_timestamp / 1000000000L);
20075a0: d2 26 40 00 st %o1, [ %i1 ]
_timespec->tv_nsec = (long) (*_timestamp % 1000000000L);
20075a4: 94 10 20 00 clr %o2
20075a8: 92 10 00 1d mov %i5, %o1
20075ac: 17 0e e6 b2 sethi %hi(0x3b9ac800), %o3
20075b0: 40 00 54 99 call 201c814 <__moddi3>
20075b4: 96 12 e2 00 or %o3, 0x200, %o3 ! 3b9aca00 <RAM_END+0x395aca00>
20075b8: 10 80 00 06 b 20075d0 <clock_gettime+0x70>
20075bc: d2 26 60 04 st %o1, [ %i1 + 4 ]
_TOD_Get(tp);
return 0;
}
#ifdef CLOCK_MONOTONIC
if ( clock_id == CLOCK_MONOTONIC ) {
20075c0: 12 80 00 06 bne 20075d8 <clock_gettime+0x78> <== ALWAYS TAKEN
20075c4: 80 a6 20 02 cmp %i0, 2
_TOD_Get_uptime_as_timespec( tp );
20075c8: 40 00 08 18 call 2009628 <_TOD_Get_uptime_as_timespec>
20075cc: 90 10 00 19 mov %i1, %o0
return 0;
20075d0: 81 c7 e0 08 ret
20075d4: 91 e8 20 00 restore %g0, 0, %o0
}
#endif
#ifdef _POSIX_CPUTIME
if ( clock_id == CLOCK_PROCESS_CPUTIME_ID ) {
20075d8: 02 bf ff fc be 20075c8 <clock_gettime+0x68>
20075dc: 80 a6 20 03 cmp %i0, 3
return 0;
}
#endif
#ifdef _POSIX_THREAD_CPUTIME
if ( clock_id == CLOCK_THREAD_CPUTIME_ID )
20075e0: 12 80 00 06 bne 20075f8 <clock_gettime+0x98>
20075e4: 01 00 00 00 nop
rtems_set_errno_and_return_minus_one( ENOSYS );
20075e8: 40 00 25 41 call 2010aec <__errno>
20075ec: 01 00 00 00 nop
20075f0: 10 80 00 05 b 2007604 <clock_gettime+0xa4>
20075f4: 82 10 20 58 mov 0x58, %g1 ! 58 <PROM_START+0x58>
#endif
rtems_set_errno_and_return_minus_one( EINVAL );
20075f8: 40 00 25 3d call 2010aec <__errno>
20075fc: 01 00 00 00 nop
2007600: 82 10 20 16 mov 0x16, %g1 ! 16 <PROM_START+0x16>
2007604: c2 22 00 00 st %g1, [ %o0 ]
return 0;
}
2007608: 81 c7 e0 08 ret
200760c: 91 e8 3f ff restore %g0, -1, %o0
02029a8c <clock_settime>:
int clock_settime(
clockid_t clock_id,
const struct timespec *tp
)
{
2029a8c: 9d e3 bf 98 save %sp, -104, %sp
if ( !tp )
2029a90: 80 a6 60 00 cmp %i1, 0
2029a94: 02 80 00 4c be 2029bc4 <clock_settime+0x138> <== NEVER TAKEN
2029a98: 80 a6 20 01 cmp %i0, 1
rtems_set_errno_and_return_minus_one( EINVAL );
if ( clock_id == CLOCK_REALTIME ) {
2029a9c: 12 80 00 42 bne 2029ba4 <clock_settime+0x118>
2029aa0: 80 a6 20 02 cmp %i0, 2
if ( tp->tv_sec < TOD_SECONDS_1970_THROUGH_1988 )
2029aa4: c4 06 40 00 ld [ %i1 ], %g2
2029aa8: 03 08 76 b9 sethi %hi(0x21dae400), %g1
2029aac: 82 10 60 ff or %g1, 0xff, %g1 ! 21dae4ff <RAM_END+0x1f9ae4ff>
2029ab0: 80 a0 80 01 cmp %g2, %g1
2029ab4: 08 80 00 44 bleu 2029bc4 <clock_settime+0x138>
2029ab8: 03 00 81 bd sethi %hi(0x206f400), %g1
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
_Thread_Dispatch_disable_level++;
2029abc: c4 00 63 80 ld [ %g1 + 0x380 ], %g2 ! 206f780 <_Thread_Dispatch_disable_level>
2029ac0: 84 00 a0 01 inc %g2
2029ac4: c4 20 63 80 st %g2, [ %g1 + 0x380 ]
return _Thread_Dispatch_disable_level;
2029ac8: c2 00 63 80 ld [ %g1 + 0x380 ], %g1
const struct timespec *tod_as_timespec
)
{
Timestamp_Control tod_as_timestamp;
_Timestamp_Set(
2029acc: c6 06 40 00 ld [ %i1 ], %g3
&tod_as_timestamp,
tod_as_timespec->tv_sec,
tod_as_timespec->tv_nsec
);
_TOD_Set_with_timestamp( &tod_as_timestamp );
2029ad0: 90 07 bf f8 add %fp, -8, %o0
const struct timespec *tod_as_timespec
)
{
Timestamp_Control tod_as_timestamp;
_Timestamp_Set(
2029ad4: 85 38 e0 1f sra %g3, 0x1f, %g2
Timestamp64_Control *_time,
Timestamp64_Control _seconds,
Timestamp64_Control _nanoseconds
)
{
*_time = _seconds * 1000000000L + _nanoseconds;
2029ad8: 83 28 a0 03 sll %g2, 3, %g1
2029adc: bb 28 e0 03 sll %g3, 3, %i5
2029ae0: 89 30 e0 1d srl %g3, 0x1d, %g4
2029ae4: b7 2f 60 05 sll %i5, 5, %i3
2029ae8: b8 11 00 01 or %g4, %g1, %i4
2029aec: 83 37 60 1b srl %i5, 0x1b, %g1
2029af0: b5 2f 20 05 sll %i4, 5, %i2
2029af4: ba a6 c0 1d subcc %i3, %i5, %i5
2029af8: b4 10 40 1a or %g1, %i2, %i2
2029afc: b7 2f 60 06 sll %i5, 6, %i3
2029b00: b8 66 80 1c subx %i2, %i4, %i4
2029b04: 83 37 60 1a srl %i5, 0x1a, %g1
2029b08: b6 a6 c0 1d subcc %i3, %i5, %i3
2029b0c: b5 2f 20 06 sll %i4, 6, %i2
2029b10: b4 10 40 1a or %g1, %i2, %i2
2029b14: b4 66 80 1c subx %i2, %i4, %i2
2029b18: 86 86 c0 03 addcc %i3, %g3, %g3
2029b1c: 83 30 e0 1e srl %g3, 0x1e, %g1
2029b20: b7 28 e0 02 sll %g3, 2, %i3
2029b24: 84 46 80 02 addx %i2, %g2, %g2
2029b28: 86 80 c0 1b addcc %g3, %i3, %g3
2029b2c: b5 28 a0 02 sll %g2, 2, %i2
2029b30: b7 28 e0 02 sll %g3, 2, %i3
2029b34: b4 10 40 1a or %g1, %i2, %i2
2029b38: 83 30 e0 1e srl %g3, 0x1e, %g1
2029b3c: 84 40 80 1a addx %g2, %i2, %g2
2029b40: b6 80 c0 1b addcc %g3, %i3, %i3
2029b44: bb 2e e0 02 sll %i3, 2, %i5
2029b48: b5 28 a0 02 sll %g2, 2, %i2
2029b4c: b4 10 40 1a or %g1, %i2, %i2
2029b50: 83 36 e0 1e srl %i3, 0x1e, %g1
2029b54: b4 40 80 1a addx %g2, %i2, %i2
2029b58: 86 86 c0 1d addcc %i3, %i5, %g3
2029b5c: b9 2e a0 02 sll %i2, 2, %i4
2029b60: bb 30 e0 17 srl %g3, 0x17, %i5
2029b64: b8 10 40 1c or %g1, %i4, %i4
2029b68: 84 46 80 1c addx %i2, %i4, %g2
2029b6c: 89 28 a0 09 sll %g2, 9, %g4
2029b70: 84 17 40 04 or %i5, %g4, %g2
2029b74: fa 06 60 04 ld [ %i1 + 4 ], %i5
2029b78: 83 28 e0 09 sll %g3, 9, %g1
2029b7c: b9 3f 60 1f sra %i5, 0x1f, %i4
2029b80: 86 80 40 1d addcc %g1, %i5, %g3
2029b84: 84 40 80 1c addx %g2, %i4, %g2
rtems_set_errno_and_return_minus_one( ENOSYS );
#endif
else
rtems_set_errno_and_return_minus_one( EINVAL );
return 0;
2029b88: b0 10 20 00 clr %i0
&tod_as_timestamp,
tod_as_timespec->tv_sec,
tod_as_timespec->tv_nsec
);
_TOD_Set_with_timestamp( &tod_as_timestamp );
2029b8c: 40 00 06 30 call 202b44c <_TOD_Set_with_timestamp>
2029b90: c4 3f bf f8 std %g2, [ %fp + -8 ]
if ( tp->tv_sec < TOD_SECONDS_1970_THROUGH_1988 )
rtems_set_errno_and_return_minus_one( EINVAL );
_Thread_Disable_dispatch();
_TOD_Set( tp );
_Thread_Enable_dispatch();
2029b94: 7f ff 99 6a call 201013c <_Thread_Enable_dispatch>
2029b98: 01 00 00 00 nop
rtems_set_errno_and_return_minus_one( ENOSYS );
#endif
else
rtems_set_errno_and_return_minus_one( EINVAL );
return 0;
2029b9c: 81 c7 e0 08 ret
2029ba0: 81 e8 00 00 restore
_Thread_Disable_dispatch();
_TOD_Set( tp );
_Thread_Enable_dispatch();
}
#ifdef _POSIX_CPUTIME
else if ( clock_id == CLOCK_PROCESS_CPUTIME_ID )
2029ba4: 02 80 00 04 be 2029bb4 <clock_settime+0x128>
2029ba8: 80 a6 20 03 cmp %i0, 3
rtems_set_errno_and_return_minus_one( ENOSYS );
#endif
#ifdef _POSIX_THREAD_CPUTIME
else if ( clock_id == CLOCK_THREAD_CPUTIME_ID )
2029bac: 12 80 00 06 bne 2029bc4 <clock_settime+0x138>
2029bb0: 01 00 00 00 nop
rtems_set_errno_and_return_minus_one( ENOSYS );
2029bb4: 40 00 61 8e call 20421ec <__errno>
2029bb8: 01 00 00 00 nop
2029bbc: 10 80 00 05 b 2029bd0 <clock_settime+0x144>
2029bc0: 82 10 20 58 mov 0x58, %g1 ! 58 <PROM_START+0x58>
#endif
else
rtems_set_errno_and_return_minus_one( EINVAL );
2029bc4: 40 00 61 8a call 20421ec <__errno>
2029bc8: 01 00 00 00 nop
2029bcc: 82 10 20 16 mov 0x16, %g1 ! 16 <PROM_START+0x16>
2029bd0: c2 22 00 00 st %g1, [ %o0 ]
return 0;
}
2029bd4: 81 c7 e0 08 ret
2029bd8: 91 e8 3f ff restore %g0, -1, %o0
02003844 <create_disk>:
dev_t dev,
const char *name,
rtems_disk_device **dd_ptr,
char **alloc_name_ptr
)
{
2003844: 9d e3 bf a0 save %sp, -96, %sp
rtems_device_major_number major = 0;
rtems_device_minor_number minor = 0;
rtems_filesystem_split_dev_t(dev, major, minor);
if (major >= disktab_size) {
2003848: 03 00 80 85 sethi %hi(0x2021400), %g1
200384c: e0 00 63 60 ld [ %g1 + 0x360 ], %l0 ! 2021760 <disktab_size>
2003850: 80 a6 00 10 cmp %i0, %l0
2003854: 0a 80 00 16 bcs 20038ac <create_disk+0x68>
2003858: 03 00 80 85 sethi %hi(0x2021400), %g1
rtems_disk_device_table *table = disktab;
rtems_device_major_number old_size = disktab_size;
rtems_device_major_number new_size = 2 * old_size;
200385c: bb 2c 20 01 sll %l0, 1, %i5
if (major >= new_size) {
2003860: 80 a6 00 1d cmp %i0, %i5
2003864: 0a 80 00 03 bcs 2003870 <create_disk+0x2c> <== NEVER TAKEN
2003868: d0 00 63 64 ld [ %g1 + 0x364 ], %o0
new_size = major + 1;
200386c: ba 06 20 01 add %i0, 1, %i5
}
table = realloc(table, new_size * sizeof(*table));
2003870: 40 00 08 93 call 2005abc <realloc>
2003874: 93 2f 60 03 sll %i5, 3, %o1
if (table == NULL) {
2003878: a2 92 20 00 orcc %o0, 0, %l1
200387c: 02 80 00 58 be 20039dc <create_disk+0x198> <== ALWAYS TAKEN
2003880: 94 27 40 10 sub %i5, %l0, %o2
return NULL;
}
memset(table + old_size, 0, (new_size - old_size) * sizeof(*table));
2003884: 91 2c 20 03 sll %l0, 3, %o0 <== NOT EXECUTED
2003888: 92 10 20 00 clr %o1 <== NOT EXECUTED
200388c: 90 04 40 08 add %l1, %o0, %o0 <== NOT EXECUTED
2003890: 40 00 43 45 call 20145a4 <memset> <== NOT EXECUTED
2003894: 95 2a a0 03 sll %o2, 3, %o2 <== NOT EXECUTED
disktab = table;
2003898: 03 00 80 85 sethi %hi(0x2021400), %g1 <== NOT EXECUTED
200389c: e2 20 63 64 st %l1, [ %g1 + 0x364 ] ! 2021764 <disktab> <== NOT EXECUTED
disktab_size = new_size;
20038a0: 03 00 80 85 sethi %hi(0x2021400), %g1 <== NOT EXECUTED
20038a4: fa 20 63 60 st %i5, [ %g1 + 0x360 ] ! 2021760 <disktab_size><== NOT EXECUTED
}
if (disktab [major].minor == NULL || minor >= disktab[major].size) {
20038a8: 03 00 80 85 sethi %hi(0x2021400), %g1 <== NOT EXECUTED
20038ac: e4 00 63 64 ld [ %g1 + 0x364 ], %l2 ! 2021764 <disktab>
20038b0: a3 2e 20 03 sll %i0, 3, %l1
20038b4: d0 04 80 11 ld [ %l2 + %l1 ], %o0
20038b8: a8 04 80 11 add %l2, %l1, %l4
20038bc: 80 a2 20 00 cmp %o0, 0
20038c0: 02 80 00 05 be 20038d4 <create_disk+0x90>
20038c4: e0 05 20 04 ld [ %l4 + 4 ], %l0
20038c8: 80 a6 40 10 cmp %i1, %l0
20038cc: 2a 80 00 16 bcs,a 2003924 <create_disk+0xe0>
20038d0: e2 04 80 11 ld [ %l2 + %l1 ], %l1
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) {
20038d4: 80 a4 20 00 cmp %l0, 0
20038d8: 02 80 00 03 be 20038e4 <create_disk+0xa0>
20038dc: ba 10 20 08 mov 8, %i5
new_size = DISKTAB_INITIAL_SIZE;
} else {
new_size = 2 * old_size;
20038e0: bb 2c 20 01 sll %l0, 1, %i5
}
if (minor >= new_size) {
20038e4: 80 a6 40 1d cmp %i1, %i5
20038e8: 3a 80 00 02 bcc,a 20038f0 <create_disk+0xac>
20038ec: ba 06 60 01 add %i1, 1, %i5
new_size = minor + 1;
}
table = realloc(table, new_size * sizeof(*table));
20038f0: 40 00 08 73 call 2005abc <realloc>
20038f4: 93 2f 60 02 sll %i5, 2, %o1
if (table == NULL) {
20038f8: a6 92 20 00 orcc %o0, 0, %l3
20038fc: 02 80 00 38 be 20039dc <create_disk+0x198>
2003900: 94 27 40 10 sub %i5, %l0, %o2
return NULL;
}
memset(table + old_size, 0, (new_size - old_size) * sizeof(*table));
2003904: 91 2c 20 02 sll %l0, 2, %o0
2003908: 92 10 20 00 clr %o1
200390c: 90 04 c0 08 add %l3, %o0, %o0
2003910: 40 00 43 25 call 20145a4 <memset>
2003914: 95 2a a0 02 sll %o2, 2, %o2
disktab [major].minor = table;
2003918: e6 24 80 11 st %l3, [ %l2 + %l1 ]
disktab [major].size = new_size;
200391c: fa 25 20 04 st %i5, [ %l4 + 4 ]
}
return disktab [major].minor + minor;
2003920: e2 04 80 11 ld [ %l2 + %l1 ], %l1
2003924: a1 2e 60 02 sll %i1, 2, %l0
2003928: 82 04 40 10 add %l1, %l0, %g1
{
rtems_disk_device **dd_entry = create_disk_table_entry(dev);
rtems_disk_device *dd = NULL;
char *alloc_name = NULL;
if (dd_entry == NULL) {
200392c: 80 a0 60 00 cmp %g1, 0
2003930: 32 80 00 04 bne,a 2003940 <create_disk+0xfc> <== ALWAYS TAKEN
2003934: c4 04 40 10 ld [ %l1 + %l0 ], %g2
return RTEMS_NO_MEMORY;
2003938: 10 80 00 2a b 20039e0 <create_disk+0x19c> <== NOT EXECUTED
200393c: 82 10 20 1a mov 0x1a, %g1 <== NOT EXECUTED
}
if (*dd_entry != NULL) {
2003940: 80 a0 a0 00 cmp %g2, 0
2003944: 12 80 00 27 bne 20039e0 <create_disk+0x19c>
2003948: 82 10 20 0c mov 0xc, %g1
return RTEMS_RESOURCE_IN_USE;
}
dd = malloc(sizeof(*dd));
200394c: 40 00 05 95 call 2004fa0 <malloc>
2003950: 90 10 20 78 mov 0x78, %o0
if (dd == NULL) {
2003954: ba 92 20 00 orcc %o0, 0, %i5
2003958: 02 80 00 21 be 20039dc <create_disk+0x198> <== NEVER TAKEN
200395c: 80 a6 a0 00 cmp %i2, 0
return RTEMS_NO_MEMORY;
}
if (name != NULL) {
2003960: 02 80 00 11 be 20039a4 <create_disk+0x160>
2003964: a4 10 20 00 clr %l2
alloc_name = strdup(name);
2003968: 40 00 44 68 call 2014b08 <strdup>
200396c: 90 10 00 1a mov %i2, %o0
if (alloc_name == NULL) {
2003970: a4 92 20 00 orcc %o0, 0, %l2
2003974: 12 80 00 11 bne 20039b8 <create_disk+0x174> <== ALWAYS TAKEN
2003978: b4 10 00 08 mov %o0, %i2
free(dd);
200397c: 40 00 04 33 call 2004a48 <free> <== NOT EXECUTED
2003980: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
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;
2003984: 10 80 00 17 b 20039e0 <create_disk+0x19c> <== NOT EXECUTED
2003988: 82 10 20 1a mov 0x1a, %g1 <== NOT EXECUTED
}
}
if (name != NULL) {
if (mknod(alloc_name, 0777 | S_IFBLK, dev) < 0) {
free(alloc_name);
200398c: 40 00 04 2f call 2004a48 <free> <== NOT EXECUTED
2003990: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
free(dd);
2003994: 40 00 04 2d call 2004a48 <free> <== NOT EXECUTED
2003998: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
return RTEMS_UNSATISFIED;
200399c: 10 80 00 11 b 20039e0 <create_disk+0x19c> <== NOT EXECUTED
20039a0: 82 10 20 0d mov 0xd, %g1 <== NOT EXECUTED
}
}
*dd_entry = dd;
20039a4: fa 24 40 10 st %i5, [ %l1 + %l0 ]
*dd_ptr = dd;
20039a8: fa 26 c0 00 st %i5, [ %i3 ]
*alloc_name_ptr = alloc_name;
20039ac: e4 27 00 00 st %l2, [ %i4 ]
return RTEMS_SUCCESSFUL;
20039b0: 10 80 00 0c b 20039e0 <create_disk+0x19c>
20039b4: 82 10 20 00 clr %g1
return RTEMS_NO_MEMORY;
}
}
if (name != NULL) {
if (mknod(alloc_name, 0777 | S_IFBLK, dev) < 0) {
20039b8: 13 00 00 18 sethi %hi(0x6000), %o1
20039bc: 94 10 00 18 mov %i0, %o2
20039c0: 92 12 61 ff or %o1, 0x1ff, %o1
20039c4: 40 00 05 ea call 200516c <mknod>
20039c8: 96 10 00 19 mov %i1, %o3
20039cc: 80 a2 20 00 cmp %o0, 0
20039d0: 36 bf ff f6 bge,a 20039a8 <create_disk+0x164> <== ALWAYS TAKEN
20039d4: fa 24 40 10 st %i5, [ %l1 + %l0 ]
20039d8: 30 bf ff ed b,a 200398c <create_disk+0x148> <== NOT EXECUTED
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;
20039dc: 82 10 20 1a mov 0x1a, %g1
*dd_entry = dd;
*dd_ptr = dd;
*alloc_name_ptr = alloc_name;
return RTEMS_SUCCESSFUL;
}
20039e0: 81 c7 e0 08 ret
20039e4: 91 e8 00 01 restore %g0, %g1, %o0
02004b2c <data_to_part_desc.part.1>:
* RTEMS_SUCCESSFUL, if success;
* RTEMS_NO_MEMOTY, if cannot allocate memory for part_desc_t strucure;
* RTEMS_INTERNAL_ERROR, if other error occurs.
*/
static rtems_status_code
data_to_part_desc(uint8_t *data, rtems_part_desc_t **new_part_desc)
2004b2c: 9d e3 bf 98 save %sp, -104, %sp
return RTEMS_INTERNAL_ERROR;
}
*new_part_desc = NULL;
if ((part_desc = calloc(1, sizeof(rtems_part_desc_t))) == NULL)
2004b30: 90 10 20 01 mov 1, %o0
* RTEMS_SUCCESSFUL, if success;
* RTEMS_NO_MEMOTY, if cannot allocate memory for part_desc_t strucure;
* RTEMS_INTERNAL_ERROR, if other error occurs.
*/
static rtems_status_code
data_to_part_desc(uint8_t *data, rtems_part_desc_t **new_part_desc)
2004b34: b8 10 00 18 mov %i0, %i4
if (new_part_desc == NULL)
{
return RTEMS_INTERNAL_ERROR;
}
*new_part_desc = NULL;
2004b38: c0 26 40 00 clr [ %i1 ]
if ((part_desc = calloc(1, sizeof(rtems_part_desc_t))) == NULL)
2004b3c: 92 10 20 28 mov 0x28, %o1
2004b40: 40 00 03 08 call 2005760 <calloc>
2004b44: b0 10 20 1a mov 0x1a, %i0
2004b48: 80 a2 20 00 cmp %o0, 0
2004b4c: 02 80 00 27 be 2004be8 <data_to_part_desc.part.1+0xbc> <== NEVER TAKEN
2004b50: ba 10 00 08 mov %o0, %i5
{
return RTEMS_NO_MEMORY;
}
part_desc->bootable = *(data + RTEMS_IDE_PARTITION_BOOTABLE_OFFSET);
2004b54: c2 0f 00 00 ldub [ %i4 ], %g1
part_desc->sys_type = *(data + RTEMS_IDE_PARTITION_SYS_TYPE_OFFSET);
/* read the offset start position and partition size in sectors */
/* due to incorrect data alignment one have to align data first */
memcpy(&temp, data + RTEMS_IDE_PARTITION_START_OFFSET, sizeof(uint32_t));
2004b58: 92 07 20 08 add %i4, 8, %o1
if ((part_desc = calloc(1, sizeof(rtems_part_desc_t))) == NULL)
{
return RTEMS_NO_MEMORY;
}
part_desc->bootable = *(data + RTEMS_IDE_PARTITION_BOOTABLE_OFFSET);
2004b5c: c2 2a 00 00 stb %g1, [ %o0 ]
part_desc->sys_type = *(data + RTEMS_IDE_PARTITION_SYS_TYPE_OFFSET);
2004b60: f6 0f 20 04 ldub [ %i4 + 4 ], %i3
/* read the offset start position and partition size in sectors */
/* due to incorrect data alignment one have to align data first */
memcpy(&temp, data + RTEMS_IDE_PARTITION_START_OFFSET, sizeof(uint32_t));
2004b64: 94 10 20 04 mov 4, %o2
{
return RTEMS_NO_MEMORY;
}
part_desc->bootable = *(data + RTEMS_IDE_PARTITION_BOOTABLE_OFFSET);
part_desc->sys_type = *(data + RTEMS_IDE_PARTITION_SYS_TYPE_OFFSET);
2004b68: f6 2a 20 01 stb %i3, [ %o0 + 1 ]
/* read the offset start position and partition size in sectors */
/* due to incorrect data alignment one have to align data first */
memcpy(&temp, data + RTEMS_IDE_PARTITION_START_OFFSET, sizeof(uint32_t));
2004b6c: 40 00 43 1e call 20157e4 <memcpy>
2004b70: 90 07 bf fc add %fp, -4, %o0
part_desc->start = LE_TO_CPU_U32(temp);
2004b74: 7f ff ff ac call 2004a24 <CPU_swap_u32>
2004b78: d0 07 bf fc ld [ %fp + -4 ], %o0
memcpy(&temp, data + RTEMS_IDE_PARTITION_SIZE_OFFSET, sizeof(uint32_t));
2004b7c: 92 07 20 0c add %i4, 0xc, %o1
/* read the offset start position and partition size in sectors */
/* due to incorrect data alignment one have to align data first */
memcpy(&temp, data + RTEMS_IDE_PARTITION_START_OFFSET, sizeof(uint32_t));
part_desc->start = LE_TO_CPU_U32(temp);
2004b80: d0 27 60 04 st %o0, [ %i5 + 4 ]
memcpy(&temp, data + RTEMS_IDE_PARTITION_SIZE_OFFSET, sizeof(uint32_t));
2004b84: 94 10 20 04 mov 4, %o2
2004b88: 40 00 43 17 call 20157e4 <memcpy>
2004b8c: 90 07 bf fc add %fp, -4, %o0
part_desc->size = LE_TO_CPU_U32(temp);
2004b90: 7f ff ff a5 call 2004a24 <CPU_swap_u32>
2004b94: d0 07 bf fc ld [ %fp + -4 ], %o0
2004b98: d0 27 60 08 st %o0, [ %i5 + 8 ]
* use partitions that are
* - extended
* or
* - FAT type and non-zero
*/
if (is_extended(part_desc->sys_type) ||
2004b9c: 82 0e e0 7f and %i3, 0x7f, %g1
2004ba0: 80 a0 60 05 cmp %g1, 5
2004ba4: 02 80 00 0c be 2004bd4 <data_to_part_desc.part.1+0xa8>
2004ba8: b8 10 00 08 mov %o0, %i4
DOS_P32MB_PARTITION,
FAT32_PARTITION ,FAT32_LBA_PARTITION,
FAT16_LBA_PARTITION
};
return (NULL != memchr(fat_part_types,type,sizeof(fat_part_types)));
2004bac: 11 00 80 91 sethi %hi(0x2024400), %o0
2004bb0: 92 0e e0 ff and %i3, 0xff, %o1
2004bb4: 90 12 21 30 or %o0, 0x130, %o0
2004bb8: 40 00 42 9d call 201562c <memchr>
2004bbc: 94 10 20 06 mov 6, %o2
* use partitions that are
* - extended
* or
* - FAT type and non-zero
*/
if (is_extended(part_desc->sys_type) ||
2004bc0: 80 a2 20 00 cmp %o0, 0
2004bc4: 02 80 00 06 be 2004bdc <data_to_part_desc.part.1+0xb0>
2004bc8: 80 a7 20 00 cmp %i4, 0
((is_fat_partition(part_desc->sys_type)) && (part_desc->size != 0))) {
2004bcc: 02 80 00 04 be 2004bdc <data_to_part_desc.part.1+0xb0> <== NEVER TAKEN
2004bd0: 01 00 00 00 nop
*new_part_desc = part_desc;
2004bd4: 10 80 00 04 b 2004be4 <data_to_part_desc.part.1+0xb8>
2004bd8: fa 26 40 00 st %i5, [ %i1 ]
}
else {
/* empty partition */
free(part_desc);
2004bdc: 40 00 03 b6 call 2005ab4 <free>
2004be0: 90 10 00 1d mov %i5, %o0
}
return RTEMS_SUCCESSFUL;
2004be4: b0 10 20 00 clr %i0
}
2004be8: 81 c7 e0 08 ret
2004bec: 81 e8 00 00 restore
02002c5c <devFS_Show>:
#endif
#include "devfs.h"
void devFS_Show(void)
{
2002c5c: 9d e3 bf a0 save %sp, -96, %sp
rtems_filesystem_location_info_t *rootloc = &rtems_filesystem_root->location;
2002c60: 03 00 80 69 sethi %hi(0x201a400), %g1
2002c64: c2 00 60 24 ld [ %g1 + 0x24 ], %g1 ! 201a424 <rtems_current_user_env>
if (rootloc->mt_entry->ops == &devFS_ops) {
2002c68: 05 00 80 62 sethi %hi(0x2018800), %g2
2002c6c: c2 00 60 04 ld [ %g1 + 4 ], %g1
2002c70: 84 10 a0 34 or %g2, 0x34, %g2
2002c74: c2 00 60 14 ld [ %g1 + 0x14 ], %g1
2002c78: c6 00 60 0c ld [ %g1 + 0xc ], %g3
2002c7c: 80 a0 c0 02 cmp %g3, %g2
2002c80: 12 80 00 25 bne 2002d14 <devFS_Show+0xb8> <== NEVER TAKEN
2002c84: 33 00 80 62 sethi %hi(0x2018800), %i1
static inline const devFS_data *devFS_get_data(
const rtems_filesystem_location_info_t *loc
)
{
return (const devFS_data *) loc->mt_entry->immutable_fs_info;
2002c88: c2 00 60 10 ld [ %g1 + 0x10 ], %g1
size_t j = 0;
size_t m = current->namelen;
printk("/");
for (j = 0; j < m; ++j) {
printk("%c", current->name [j]);
2002c8c: 31 00 80 62 sethi %hi(0x2018800), %i0
}
printk(
2002c90: 21 00 80 62 sethi %hi(0x2018800), %l0
rtems_filesystem_location_info_t *rootloc = &rtems_filesystem_root->location;
if (rootloc->mt_entry->ops == &devFS_ops) {
const devFS_data *data = devFS_get_data(rootloc);
size_t i = 0;
size_t n = data->count;
2002c94: f4 00 60 04 ld [ %g1 + 4 ], %i2
2002c98: fa 00 40 00 ld [ %g1 ], %i5
devFS_node *nodes = data->nodes;
for (i = 0; i < n; ++i) {
2002c9c: b6 10 20 00 clr %i3
if (current->name != NULL) {
size_t j = 0;
size_t m = current->namelen;
printk("/");
2002ca0: b2 16 60 88 or %i1, 0x88, %i1
for (j = 0; j < m; ++j) {
printk("%c", current->name [j]);
2002ca4: b0 16 20 90 or %i0, 0x90, %i0
const devFS_data *data = devFS_get_data(rootloc);
size_t i = 0;
size_t n = data->count;
devFS_node *nodes = data->nodes;
for (i = 0; i < n; ++i) {
2002ca8: 10 80 00 18 b 2002d08 <devFS_Show+0xac>
2002cac: a0 14 20 98 or %l0, 0x98, %l0
devFS_node *current = nodes + i;
if (current->name != NULL) {
2002cb0: 80 a0 60 00 cmp %g1, 0
2002cb4: 22 80 00 14 be,a 2002d04 <devFS_Show+0xa8>
2002cb8: b6 06 e0 01 inc %i3
size_t j = 0;
size_t m = current->namelen;
2002cbc: e2 07 60 04 ld [ %i5 + 4 ], %l1
printk("/");
2002cc0: 90 10 00 19 mov %i1, %o0
2002cc4: 40 00 04 a7 call 2003f60 <printk>
2002cc8: b8 10 20 00 clr %i4
for (j = 0; j < m; ++j) {
2002ccc: 10 80 00 07 b 2002ce8 <devFS_Show+0x8c>
2002cd0: 80 a7 00 11 cmp %i4, %l1
printk("%c", current->name [j]);
2002cd4: 90 10 00 18 mov %i0, %o0
2002cd8: d2 48 40 1c ldsb [ %g1 + %i4 ], %o1
2002cdc: 40 00 04 a1 call 2003f60 <printk>
2002ce0: b8 07 20 01 inc %i4
if (current->name != NULL) {
size_t j = 0;
size_t m = current->namelen;
printk("/");
for (j = 0; j < m; ++j) {
2002ce4: 80 a7 00 11 cmp %i4, %l1
2002ce8: 32 bf ff fb bne,a 2002cd4 <devFS_Show+0x78>
2002cec: c2 07 40 00 ld [ %i5 ], %g1
printk("%c", current->name [j]);
}
printk(
2002cf0: d2 07 60 08 ld [ %i5 + 8 ], %o1
2002cf4: d4 07 60 0c ld [ %i5 + 0xc ], %o2
2002cf8: 40 00 04 9a call 2003f60 <printk>
2002cfc: 90 10 00 10 mov %l0, %o0
const devFS_data *data = devFS_get_data(rootloc);
size_t i = 0;
size_t n = data->count;
devFS_node *nodes = data->nodes;
for (i = 0; i < n; ++i) {
2002d00: b6 06 e0 01 inc %i3
2002d04: ba 07 60 14 add %i5, 0x14, %i5
2002d08: 80 a6 c0 1a cmp %i3, %i2
2002d0c: 32 bf ff e9 bne,a 2002cb0 <devFS_Show+0x54>
2002d10: c2 07 40 00 ld [ %i5 ], %g1
2002d14: 81 c7 e0 08 ret
2002d18: 81 e8 00 00 restore
0200bd28 <devFS_eval_path>:
}
void devFS_eval_path(
rtems_filesystem_eval_path_context_t *ctx
)
{
200bd28: 9d e3 bf a0 save %sp, -96, %sp
static inline const devFS_data *devFS_get_data(
const rtems_filesystem_location_info_t *loc
)
{
return (const devFS_data *) loc->mt_entry->immutable_fs_info;
200bd2c: c2 06 20 2c ld [ %i0 + 0x2c ], %g1
static inline const char *rtems_filesystem_eval_path_get_path(
rtems_filesystem_eval_path_context_t *ctx
)
{
return ctx->path;
200bd30: f2 06 00 00 ld [ %i0 ], %i1
200bd34: c2 00 60 10 ld [ %g1 + 0x10 ], %g1
static inline size_t rtems_filesystem_eval_path_get_pathlen(
rtems_filesystem_eval_path_context_t *ctx
)
{
return ctx->pathlen;
200bd38: f6 06 20 04 ld [ %i0 + 4 ], %i3
size_t pathlen,
devFS_node **free_node_ptr
)
{
size_t i = 0;
size_t n = data->count;
200bd3c: e2 00 60 04 ld [ %g1 + 4 ], %l1
200bd40: fa 00 40 00 ld [ %g1 ], %i5
devFS_node *nodes = data->nodes;
devFS_node *node = NULL;
200bd44: b8 10 20 00 clr %i4
devFS_node *free_node = NULL;
200bd48: 82 10 20 00 clr %g1
for (i = 0; (free_node == NULL || node == NULL) && i < n; ++i) {
200bd4c: 10 80 00 12 b 200bd94 <devFS_eval_path+0x6c>
200bd50: b4 10 20 00 clr %i2
devFS_node *current = nodes + i;
if (current->name != NULL) {
200bd54: 80 a2 20 00 cmp %o0, 0
200bd58: 02 80 00 0c be 200bd88 <devFS_eval_path+0x60>
200bd5c: a0 10 00 1d mov %i5, %l0
if (
200bd60: c4 07 60 04 ld [ %i5 + 4 ], %g2
200bd64: 80 a0 80 1b cmp %g2, %i3
200bd68: 12 80 00 08 bne 200bd88 <devFS_eval_path+0x60>
200bd6c: a0 10 00 01 mov %g1, %l0
current->namelen == pathlen
&& memcmp(current->name, path, pathlen) == 0
200bd70: 92 10 00 19 mov %i1, %o1
200bd74: 40 00 0d f3 call 200f540 <memcmp>
200bd78: 94 10 00 1b mov %i3, %o2
200bd7c: 80 a2 20 00 cmp %o0, 0
200bd80: 22 80 00 02 be,a 200bd88 <devFS_eval_path+0x60>
200bd84: b8 10 00 1d mov %i5, %i4
size_t n = data->count;
devFS_node *nodes = data->nodes;
devFS_node *node = NULL;
devFS_node *free_node = NULL;
for (i = 0; (free_node == NULL || node == NULL) && i < n; ++i) {
200bd88: b4 06 a0 01 inc %i2
200bd8c: ba 07 60 14 add %i5, 0x14, %i5
200bd90: 82 10 00 10 mov %l0, %g1
200bd94: 80 a7 20 00 cmp %i4, 0
200bd98: 02 80 00 0a be 200bdc0 <devFS_eval_path+0x98>
200bd9c: 80 a6 80 11 cmp %i2, %l1
200bda0: 80 a0 60 00 cmp %g1, 0
200bda4: 02 80 00 07 be 200bdc0 <devFS_eval_path+0x98>
200bda8: 80 a6 80 11 cmp %i2, %l1
rtems_filesystem_eval_path_get_pathlen(ctx),
&free_node
);
int eval_flags = rtems_filesystem_eval_path_get_flags(ctx);
if (node != NULL) {
200bdac: 80 a7 20 00 cmp %i4, 0
200bdb0: 12 80 00 08 bne 200bdd0 <devFS_eval_path+0xa8>
200bdb4: c4 06 20 10 ld [ %i0 + 0x10 ], %g2
rtems_filesystem_eval_path_clear_path(ctx);
} else {
rtems_filesystem_eval_path_error(ctx, EEXIST);
}
} else {
if ((eval_flags & RTEMS_FS_MAKE) != 0) {
200bdb8: 10 80 00 0b b 200bde4 <devFS_eval_path+0xbc>
200bdbc: 80 88 a0 20 btst 0x20, %g2
size_t n = data->count;
devFS_node *nodes = data->nodes;
devFS_node *node = NULL;
devFS_node *free_node = NULL;
for (i = 0; (free_node == NULL || node == NULL) && i < n; ++i) {
200bdc0: 32 bf ff e5 bne,a 200bd54 <devFS_eval_path+0x2c>
200bdc4: d0 07 40 00 ld [ %i5 ], %o0
rtems_filesystem_eval_path_get_pathlen(ctx),
&free_node
);
int eval_flags = rtems_filesystem_eval_path_get_flags(ctx);
if (node != NULL) {
200bdc8: 10 bf ff fa b 200bdb0 <devFS_eval_path+0x88>
200bdcc: 80 a7 20 00 cmp %i4, 0
if ((eval_flags & RTEMS_FS_EXCLUSIVE) == 0) {
200bdd0: 80 88 a0 40 btst 0x40, %g2
200bdd4: 12 80 00 12 bne 200be1c <devFS_eval_path+0xf4>
200bdd8: b2 10 20 11 mov 0x11, %i1
currentloc->node_access = node;
200bddc: 10 80 00 0a b 200be04 <devFS_eval_path+0xdc>
200bde0: f8 26 20 20 st %i4, [ %i0 + 0x20 ]
rtems_filesystem_eval_path_clear_path(ctx);
} else {
rtems_filesystem_eval_path_error(ctx, EEXIST);
}
} else {
if ((eval_flags & RTEMS_FS_MAKE) != 0) {
200bde4: 02 80 00 0d be 200be18 <devFS_eval_path+0xf0> <== NEVER TAKEN
200bde8: 80 a0 60 00 cmp %g1, 0
if (free_node != NULL) {
200bdec: 02 80 00 09 be 200be10 <devFS_eval_path+0xe8>
200bdf0: 84 10 21 ff mov 0x1ff, %g2
free_node->mode = S_IRWXU | S_IRWXG | S_IRWXO;
200bdf4: c4 20 60 10 st %g2, [ %g1 + 0x10 ]
currentloc->node_access = free_node;
200bdf8: c2 26 20 20 st %g1, [ %i0 + 0x20 ]
rtems_filesystem_eval_path_context_t *ctx,
const char *token,
size_t tokenlen
)
{
ctx->token = token;
200bdfc: f2 26 20 08 st %i1, [ %i0 + 8 ]
ctx->tokenlen = tokenlen;
200be00: f6 26 20 0c st %i3, [ %i0 + 0xc ]
static inline void rtems_filesystem_eval_path_clear_path(
rtems_filesystem_eval_path_context_t *ctx
)
{
ctx->pathlen = 0;
200be04: c0 26 20 04 clr [ %i0 + 4 ]
200be08: 81 c7 e0 08 ret
200be0c: 81 e8 00 00 restore
rtems_filesystem_eval_path_get_path(ctx),
rtems_filesystem_eval_path_get_pathlen(ctx)
);
rtems_filesystem_eval_path_clear_path(ctx);
} else {
rtems_filesystem_eval_path_error(ctx, ENOSPC);
200be10: 10 80 00 03 b 200be1c <devFS_eval_path+0xf4>
200be14: b2 10 20 1c mov 0x1c, %i1
}
} else {
rtems_filesystem_eval_path_error(ctx, ENOENT);
200be18: b2 10 20 02 mov 2, %i1 <== NOT EXECUTED
200be1c: 7f ff e4 28 call 2004ebc <rtems_filesystem_eval_path_error>
200be20: 81 e8 00 00 restore
0200381c <devFS_mknod>:
const char *name,
size_t namelen,
mode_t mode,
dev_t dev
)
{
200381c: 9d e3 bf a0 save %sp, -96, %sp
int rv = 0;
if (namelen != 3 || name [0] != 'd' || name [1] != 'e' || name [2] != 'v') {
2003820: 80 a6 a0 03 cmp %i2, 3
2003824: 12 80 00 0e bne 200385c <devFS_mknod+0x40>
2003828: 05 00 00 2c sethi %hi(0xb000), %g2
200382c: c2 4e 40 00 ldsb [ %i1 ], %g1
2003830: 80 a0 60 64 cmp %g1, 0x64
2003834: 12 80 00 0b bne 2003860 <devFS_mknod+0x44> <== NEVER TAKEN
2003838: 03 00 00 08 sethi %hi(0x2000), %g1
200383c: c2 4e 60 01 ldsb [ %i1 + 1 ], %g1
2003840: 80 a0 60 65 cmp %g1, 0x65
2003844: 12 80 00 07 bne 2003860 <devFS_mknod+0x44> <== NEVER TAKEN
2003848: 03 00 00 08 sethi %hi(0x2000), %g1
200384c: c2 4e 60 02 ldsb [ %i1 + 2 ], %g1
2003850: 80 a0 60 76 cmp %g1, 0x76
2003854: 02 80 00 1b be 20038c0 <devFS_mknod+0xa4> <== ALWAYS TAKEN
2003858: 03 00 00 3c sethi %hi(0xf000), %g1
if (S_ISBLK(mode) || S_ISCHR(mode)) {
200385c: 03 00 00 08 sethi %hi(0x2000), %g1
2003860: 84 0e c0 02 and %i3, %g2, %g2
2003864: 80 a0 80 01 cmp %g2, %g1
2003868: 12 80 00 1b bne 20038d4 <devFS_mknod+0xb8>
200386c: 01 00 00 00 nop
char *dupname = malloc(namelen);
2003870: 40 00 01 f8 call 2004050 <malloc>
2003874: 90 10 00 1a mov %i2, %o0
if (dupname != NULL) {
2003878: 84 92 20 00 orcc %o0, 0, %g2
200387c: 02 80 00 0d be 20038b0 <devFS_mknod+0x94>
2003880: 92 10 00 19 mov %i1, %o1
devFS_node *node = parentloc->node_access;
2003884: c2 06 20 08 ld [ %i0 + 8 ], %g1
node->name = dupname;
2003888: c4 20 40 00 st %g2, [ %g1 ]
node->namelen = namelen;
200388c: f4 20 60 04 st %i2, [ %g1 + 4 ]
node->major = rtems_filesystem_dev_major_t(dev);
2003890: f8 20 60 08 st %i4, [ %g1 + 8 ]
node->minor = rtems_filesystem_dev_minor_t(dev);
2003894: fa 20 60 0c st %i5, [ %g1 + 0xc ]
node->mode = mode;
2003898: f6 20 60 10 st %i3, [ %g1 + 0x10 ]
memcpy(dupname, name, namelen);
200389c: 94 10 00 1a mov %i2, %o2
20038a0: 40 00 2f 52 call 200f5e8 <memcpy>
20038a4: b0 10 20 00 clr %i0
20038a8: 81 c7 e0 08 ret
20038ac: 81 e8 00 00 restore
} else {
errno = ENOMEM;
20038b0: 40 00 2b 53 call 200e5fc <__errno>
20038b4: 01 00 00 00 nop
20038b8: 10 80 00 0a b 20038e0 <devFS_mknod+0xc4>
20038bc: 82 10 20 0c mov 0xc, %g1 ! c <PROM_START+0xc>
} else {
errno = ENOTSUP;
rv = -1;
}
} else {
if (!S_ISDIR(mode)) {
20038c0: b6 0e c0 01 and %i3, %g1, %i3
20038c4: 03 00 00 10 sethi %hi(0x4000), %g1
20038c8: 80 a6 c0 01 cmp %i3, %g1
20038cc: 02 bf ff f7 be 20038a8 <devFS_mknod+0x8c> <== ALWAYS TAKEN
20038d0: b0 10 20 00 clr %i0
errno = ENOTSUP;
20038d4: 40 00 2b 4a call 200e5fc <__errno>
20038d8: 01 00 00 00 nop
20038dc: 82 10 20 86 mov 0x86, %g1 ! 86 <PROM_START+0x86>
20038e0: c2 22 00 00 st %g1, [ %o0 ]
rv = -1;
20038e4: b0 10 3f ff mov -1, %i0
}
}
return rv;
}
20038e8: 81 c7 e0 08 ret
20038ec: 81 e8 00 00 restore
020037d4 <disk_lock>:
*/
static volatile bool diskdevs_protected;
static rtems_status_code
disk_lock(void)
{
20037d4: 9d e3 bf a0 save %sp, -96, %sp
rtems_status_code sc = RTEMS_SUCCESSFUL;
sc = rtems_semaphore_obtain(diskdevs_mutex, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
20037d8: 03 00 80 85 sethi %hi(0x2021400), %g1
20037dc: d0 00 63 5c ld [ %g1 + 0x35c ], %o0 ! 202175c <diskdevs_mutex>
20037e0: 92 10 20 00 clr %o1
20037e4: 94 10 20 00 clr %o2
20037e8: 40 00 15 3f call 2008ce4 <rtems_semaphore_obtain>
20037ec: b0 10 20 16 mov 0x16, %i0
if (sc == RTEMS_SUCCESSFUL) {
20037f0: 80 a2 20 00 cmp %o0, 0
20037f4: 12 80 00 05 bne 2003808 <disk_lock+0x34> <== NEVER TAKEN
20037f8: 84 10 20 01 mov 1, %g2
diskdevs_protected = true;
20037fc: 03 00 80 85 sethi %hi(0x2021400), %g1
return RTEMS_SUCCESSFUL;
2003800: b0 10 20 00 clr %i0
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
sc = rtems_semaphore_obtain(diskdevs_mutex, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc == RTEMS_SUCCESSFUL) {
diskdevs_protected = true;
2003804: c4 28 63 58 stb %g2, [ %g1 + 0x358 ]
return RTEMS_SUCCESSFUL;
} else {
return RTEMS_NOT_CONFIGURED;
}
}
2003808: 81 c7 e0 08 ret
200380c: 81 e8 00 00 restore
02003810 <disk_unlock>:
static void
disk_unlock(void)
{
2003810: 9d e3 bf a0 save %sp, -96, %sp
rtems_status_code sc = RTEMS_SUCCESSFUL;
diskdevs_protected = false;
2003814: 03 00 80 85 sethi %hi(0x2021400), %g1
2003818: c0 28 63 58 clrb [ %g1 + 0x358 ] ! 2021758 <diskdevs_protected>
sc = rtems_semaphore_release(diskdevs_mutex);
200381c: 03 00 80 85 sethi %hi(0x2021400), %g1
2003820: 40 00 15 7b call 2008e0c <rtems_semaphore_release>
2003824: d0 00 63 5c ld [ %g1 + 0x35c ], %o0 ! 202175c <diskdevs_mutex>
if (sc != RTEMS_SUCCESSFUL) {
2003828: 80 a2 20 00 cmp %o0, 0
200382c: 02 80 00 04 be 200383c <disk_unlock+0x2c> <== ALWAYS TAKEN
2003830: 11 37 ab 6f sethi %hi(0xdeadbc00), %o0
/* FIXME: Error number */
rtems_fatal_error_occurred(0xdeadbeef);
2003834: 40 00 16 d9 call 2009398 <rtems_fatal_error_occurred> <== NOT EXECUTED
2003838: 90 12 22 ef or %o0, 0x2ef, %o0 ! deadbeef <RAM_END+0xdc6dbeef><== NOT EXECUTED
200383c: 81 c7 e0 08 ret
2003840: 81 e8 00 00 restore
020053a4 <drainOutput.part.0>:
/*
* Drain output queue
*/
static void
drainOutput (struct rtems_termios_tty *tty)
20053a4: 9d e3 bf a0 save %sp, -96, %sp
{
rtems_interrupt_level level;
rtems_status_code sc;
if (tty->device.outputUsesInterrupts != TERMIOS_POLLED) {
rtems_interrupt_disable (level);
20053a8: 7f ff f4 c7 call 20026c4 <sparc_disable_interrupts>
20053ac: 01 00 00 00 nop
while (tty->rawOutBuf.Tail != tty->rawOutBuf.Head) {
tty->rawOutBufState = rob_wait;
20053b0: 10 80 00 0f b 20053ec <drainOutput.part.0+0x48>
20053b4: b8 10 20 02 mov 2, %i4 ! 2 <PROM_START+0x2>
rtems_interrupt_enable (level);
20053b8: 7f ff f4 c7 call 20026d4 <sparc_enable_interrupts> <== NOT EXECUTED
20053bc: 01 00 00 00 nop <== NOT EXECUTED
sc = rtems_semaphore_obtain(
20053c0: d0 06 20 8c ld [ %i0 + 0x8c ], %o0 <== NOT EXECUTED
20053c4: 92 10 20 00 clr %o1 <== NOT EXECUTED
20053c8: 40 00 09 47 call 20078e4 <rtems_semaphore_obtain> <== NOT EXECUTED
20053cc: 94 10 20 00 clr %o2 <== NOT EXECUTED
tty->rawOutBuf.Semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
20053d0: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
20053d4: 02 80 00 04 be 20053e4 <drainOutput.part.0+0x40> <== NOT EXECUTED
20053d8: 01 00 00 00 nop <== NOT EXECUTED
rtems_fatal_error_occurred (sc);
20053dc: 40 00 0b 07 call 2007ff8 <rtems_fatal_error_occurred> <== NOT EXECUTED
20053e0: 01 00 00 00 nop <== NOT EXECUTED
rtems_interrupt_disable (level);
20053e4: 7f ff f4 b8 call 20026c4 <sparc_disable_interrupts> <== NOT EXECUTED
20053e8: 01 00 00 00 nop <== 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) {
20053ec: c4 06 20 84 ld [ %i0 + 0x84 ], %g2
20053f0: c2 06 20 80 ld [ %i0 + 0x80 ], %g1
20053f4: 80 a0 80 01 cmp %g2, %g1
20053f8: 32 bf ff f0 bne,a 20053b8 <drainOutput.part.0+0x14> <== NEVER TAKEN
20053fc: f8 26 20 94 st %i4, [ %i0 + 0x94 ] <== NOT EXECUTED
tty->rawOutBuf.Semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
rtems_interrupt_disable (level);
}
rtems_interrupt_enable (level);
2005400: 7f ff f4 b5 call 20026d4 <sparc_enable_interrupts>
2005404: 91 e8 00 08 restore %g0, %o0, %o0
02003c68 <dup2>:
int dup2(
int fildes,
int fildes2
)
{
2003c68: 9d e3 bf 58 save %sp, -168, %sp
/*
* If fildes is not valid, then fildes2 should not be closed.
*/
status = fstat( fildes, &buf );
2003c6c: 90 10 00 18 mov %i0, %o0
2003c70: 40 00 01 e3 call 20043fc <fstat>
2003c74: 92 07 bf b8 add %fp, -72, %o1
if ( status == -1 )
2003c78: 80 a2 3f ff cmp %o0, -1
2003c7c: 12 80 00 04 bne 2003c8c <dup2+0x24>
2003c80: 90 10 00 19 mov %i1, %o0
return -1;
2003c84: 81 c7 e0 08 ret
2003c88: 91 e8 3f ff restore %g0, -1, %o0
/*
* If fildes2 is not valid, then we should not do anything either.
*/
status = fstat( fildes2, &buf );
2003c8c: 40 00 01 dc call 20043fc <fstat>
2003c90: 92 07 bf b8 add %fp, -72, %o1
if ( status == -1 )
2003c94: 80 a2 3f ff cmp %o0, -1
2003c98: 02 bf ff fb be 2003c84 <dup2+0x1c> <== NEVER TAKEN
2003c9c: 90 10 00 18 mov %i0, %o0
/*
* This fcntl handles everything else.
*/
return fcntl( fildes, F_DUPFD, fildes2 );
2003ca0: 92 10 20 00 clr %o1
2003ca4: 40 00 00 b0 call 2003f64 <fcntl>
2003ca8: 94 10 00 19 mov %i1, %o2
}
2003cac: 81 c7 e0 08 ret
2003cb0: 91 e8 00 08 restore %g0, %o0, %o0
02006104 <echo>:
/*
* Echo a typed character
*/
static void
echo (unsigned char c, struct rtems_termios_tty *tty)
{
2006104: 9d e3 bf 98 save %sp, -104, %sp
if ((tty->termios.c_lflag & ECHOCTL) &&
2006108: c2 06 60 3c ld [ %i1 + 0x3c ], %g1
200610c: 80 88 62 00 btst 0x200, %g1
2006110: 02 80 00 19 be 2006174 <echo+0x70> <== NEVER TAKEN
2006114: 03 00 80 74 sethi %hi(0x201d000), %g1
iscntrl(c) && (c != '\t') && (c != '\n')) {
2006118: c2 00 60 60 ld [ %g1 + 0x60 ], %g1 ! 201d060 <__ctype_ptr__>
200611c: 82 00 40 18 add %g1, %i0, %g1
2006120: c2 08 60 01 ldub [ %g1 + 1 ], %g1
* Echo a typed character
*/
static void
echo (unsigned char c, struct rtems_termios_tty *tty)
{
if ((tty->termios.c_lflag & ECHOCTL) &&
2006124: 80 88 60 20 btst 0x20, %g1
2006128: 02 80 00 14 be 2006178 <echo+0x74>
200612c: 90 10 00 18 mov %i0, %o0
iscntrl(c) && (c != '\t') && (c != '\n')) {
2006130: 82 06 3f f7 add %i0, -9, %g1
2006134: 82 08 60 ff and %g1, 0xff, %g1
2006138: 80 a0 60 01 cmp %g1, 1
200613c: 08 80 00 0f bleu 2006178 <echo+0x74>
2006140: 82 10 20 5e mov 0x5e, %g1
char echobuf[2];
echobuf[0] = '^';
echobuf[1] = c ^ 0x40;
2006144: b0 1e 20 40 xor %i0, 0x40, %i0
{
if ((tty->termios.c_lflag & ECHOCTL) &&
iscntrl(c) && (c != '\t') && (c != '\n')) {
char echobuf[2];
echobuf[0] = '^';
2006148: c2 2f bf f8 stb %g1, [ %fp + -8 ]
echobuf[1] = c ^ 0x40;
200614c: f0 2f bf f9 stb %i0, [ %fp + -7 ]
rtems_termios_puts (echobuf, 2, tty);
2006150: 90 07 bf f8 add %fp, -8, %o0
2006154: 92 10 20 02 mov 2, %o1
2006158: 7f ff ff 43 call 2005e64 <rtems_termios_puts>
200615c: 94 10 00 19 mov %i1, %o2
tty->column += 2;
2006160: c2 06 60 28 ld [ %i1 + 0x28 ], %g1
2006164: 82 00 60 02 add %g1, 2, %g1
2006168: c2 26 60 28 st %g1, [ %i1 + 0x28 ]
200616c: 81 c7 e0 08 ret
2006170: 81 e8 00 00 restore
} else {
oproc (c, tty);
2006174: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
2006178: 7f ff ff 84 call 2005f88 <oproc>
200617c: 92 10 00 19 mov %i1, %o1
2006180: 81 c7 e0 08 ret
2006184: 81 e8 00 00 restore
02028a94 <endgrent>:
}
void endgrent(void)
{
if (group_fp != NULL)
2028a94: 03 00 81 bc sethi %hi(0x206f000), %g1
2028a98: d0 00 61 b8 ld [ %g1 + 0x1b8 ], %o0 ! 206f1b8 <group_fp>
2028a9c: 80 a2 20 00 cmp %o0, 0
2028aa0: 02 80 00 05 be 2028ab4 <endgrent+0x20> <== NEVER TAKEN
2028aa4: 01 00 00 00 nop
fclose(group_fp);
2028aa8: 82 13 c0 00 mov %o7, %g1
2028aac: 40 00 66 22 call 2042334 <fclose>
2028ab0: 9e 10 40 00 mov %g1, %o7
2028ab4: 81 c3 e0 08 retl <== NOT EXECUTED
020288f0 <endpwent>:
}
void endpwent(void)
{
if (passwd_fp != NULL)
20288f0: 03 00 81 bc sethi %hi(0x206f000), %g1
20288f4: d0 00 60 d8 ld [ %g1 + 0xd8 ], %o0 ! 206f0d8 <passwd_fp>
20288f8: 80 a2 20 00 cmp %o0, 0
20288fc: 02 80 00 05 be 2028910 <endpwent+0x20> <== NEVER TAKEN
2028900: 01 00 00 00 nop
fclose(passwd_fp);
2028904: 82 13 c0 00 mov %o7, %g1
2028908: 40 00 66 8b call 2042334 <fclose>
202890c: 9e 10 40 00 mov %g1, %o7
2028910: 81 c3 e0 08 retl <== NOT EXECUTED
02006188 <erase.part.2>:
* Erase a character or line
* FIXME: Needs support for WERASE and ECHOPRT.
* FIXME: Some of the tests should check for IEXTEN, too.
*/
static void
erase (struct rtems_termios_tty *tty, int lineFlag)
2006188: 9d e3 bf a0 save %sp, -96, %sp
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);
200618c: 35 00 80 6d sethi %hi(0x201b400), %i2
* Erase a character or line
* FIXME: Needs support for WERASE and ECHOPRT.
* FIXME: Some of the tests should check for IEXTEN, too.
*/
static void
erase (struct rtems_termios_tty *tty, int lineFlag)
2006190: ba 10 00 18 mov %i0, %i5
2006194: 37 00 80 74 sethi %hi(0x201d000), %i3
/*
* Back up over the tab
*/
while (tty->column > col) {
rtems_termios_puts ("\b", 1, tty);
2006198: 31 00 80 6d sethi %hi(0x201b400), %i0
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);
200619c: b4 16 a3 80 or %i2, 0x380, %i2
/*
* Back up over the tab
*/
while (tty->column > col) {
rtems_termios_puts ("\b", 1, tty);
20061a0: 10 80 00 62 b 2006328 <erase.part.2+0x1a0>
20061a4: b0 16 23 78 or %i0, 0x378, %i0
}
while (tty->ccount) {
unsigned char c = tty->cbuf[--tty->ccount];
if (tty->termios.c_lflag & ECHO) {
20061a8: c2 07 60 3c ld [ %i5 + 0x3c ], %g1
return;
}
}
while (tty->ccount) {
unsigned char c = tty->cbuf[--tty->ccount];
20061ac: 86 00 ff ff add %g3, -1, %g3
20061b0: c6 27 60 20 st %g3, [ %i5 + 0x20 ]
if (tty->termios.c_lflag & ECHO) {
20061b4: 80 88 60 08 btst 8, %g1
20061b8: 02 80 00 59 be 200631c <erase.part.2+0x194> <== NEVER TAKEN
20061bc: f8 09 00 03 ldub [ %g4 + %g3 ], %i4
if (!lineFlag && !(tty->termios.c_lflag & ECHOE)) {
20061c0: 80 a6 60 00 cmp %i1, 0
20061c4: 32 80 00 08 bne,a 20061e4 <erase.part.2+0x5c>
20061c8: b8 0f 20 ff and %i4, 0xff, %i4
20061cc: 80 88 60 10 btst 0x10, %g1
20061d0: 32 80 00 05 bne,a 20061e4 <erase.part.2+0x5c> <== ALWAYS TAKEN
20061d4: b8 0f 20 ff and %i4, 0xff, %i4
echo (tty->termios.c_cc[VERASE], tty);
20061d8: f0 0f 60 43 ldub [ %i5 + 0x43 ], %i0 <== NOT EXECUTED
20061dc: 7f ff ff ca call 2006104 <echo> <== NOT EXECUTED
20061e0: 93 e8 00 1d restore %g0, %i5, %o1 <== NOT EXECUTED
} else if (c == '\t') {
20061e4: 80 a7 20 09 cmp %i4, 9
20061e8: 32 80 00 28 bne,a 2006288 <erase.part.2+0x100>
20061ec: c4 06 e0 60 ld [ %i3 + 0x60 ], %g2
int col = tty->read_start_column;
20061f0: f8 07 60 2c ld [ %i5 + 0x2c ], %i4
*/
while (i != tty->ccount) {
c = tty->cbuf[i++];
if (c == '\t') {
col = (col | 7) + 1;
} else if (iscntrl (c)) {
20061f4: da 06 e0 60 ld [ %i3 + 0x60 ], %o5
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;
20061f8: 84 10 20 00 clr %g2
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)
20061fc: 10 80 00 12 b 2006244 <erase.part.2+0xbc>
2006200: 82 08 62 00 and %g1, 0x200, %g1
/*
* Find the character before the tab
*/
while (i != tty->ccount) {
c = tty->cbuf[i++];
if (c == '\t') {
2006204: 80 a3 e0 09 cmp %o7, 9
2006208: 12 80 00 04 bne 2006218 <erase.part.2+0x90>
200620c: 84 00 a0 01 inc %g2
col = (col | 7) + 1;
2006210: 10 80 00 0c b 2006240 <erase.part.2+0xb8>
2006214: b8 17 20 07 or %i4, 7, %i4
} else if (iscntrl (c)) {
2006218: 9e 03 40 0f add %o5, %o7, %o7
200621c: de 0b e0 01 ldub [ %o7 + 1 ], %o7
2006220: 80 8b e0 20 btst 0x20, %o7
2006224: 22 80 00 08 be,a 2006244 <erase.part.2+0xbc> <== ALWAYS TAKEN
2006228: b8 07 20 01 inc %i4
if (tty->termios.c_lflag & ECHOCTL)
200622c: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
2006230: 32 80 00 05 bne,a 2006244 <erase.part.2+0xbc> <== NOT EXECUTED
2006234: b8 07 20 02 add %i4, 2, %i4 <== NOT EXECUTED
int i = 0;
/*
* Find the character before the tab
*/
while (i != tty->ccount) {
2006238: 10 80 00 04 b 2006248 <erase.part.2+0xc0> <== NOT EXECUTED
200623c: 80 a0 80 03 cmp %g2, %g3 <== NOT EXECUTED
col = (col | 7) + 1;
} else if (iscntrl (c)) {
if (tty->termios.c_lflag & ECHOCTL)
col += 2;
} else {
col++;
2006240: b8 07 20 01 inc %i4
int i = 0;
/*
* Find the character before the tab
*/
while (i != tty->ccount) {
2006244: 80 a0 80 03 cmp %g2, %g3
2006248: 32 bf ff ef bne,a 2006204 <erase.part.2+0x7c>
200624c: de 09 00 02 ldub [ %g4 + %g2 ], %o7
}
/*
* Back up over the tab
*/
while (tty->column > col) {
2006250: 10 80 00 09 b 2006274 <erase.part.2+0xec>
2006254: c2 07 60 28 ld [ %i5 + 0x28 ], %g1
rtems_termios_puts ("\b", 1, tty);
2006258: 92 10 20 01 mov 1, %o1
200625c: 7f ff ff 02 call 2005e64 <rtems_termios_puts>
2006260: 94 10 00 1d mov %i5, %o2
tty->column--;
2006264: c2 07 60 28 ld [ %i5 + 0x28 ], %g1
2006268: 82 00 7f ff add %g1, -1, %g1
200626c: c2 27 60 28 st %g1, [ %i5 + 0x28 ]
}
/*
* Back up over the tab
*/
while (tty->column > col) {
2006270: c2 07 60 28 ld [ %i5 + 0x28 ], %g1
2006274: 80 a0 40 1c cmp %g1, %i4
2006278: 14 bf ff f8 bg 2006258 <erase.part.2+0xd0>
200627c: 90 10 00 18 mov %i0, %o0
if (tty->column)
tty->column--;
}
}
}
if (!lineFlag)
2006280: 10 80 00 28 b 2006320 <erase.part.2+0x198>
2006284: 80 a6 60 00 cmp %i1, 0
rtems_termios_puts ("\b", 1, tty);
tty->column--;
}
}
else {
if (iscntrl (c) && (tty->termios.c_lflag & ECHOCTL)) {
2006288: b8 07 20 01 inc %i4
200628c: c4 08 80 1c ldub [ %g2 + %i4 ], %g2
2006290: 80 88 a0 20 btst 0x20, %g2
2006294: 22 80 00 10 be,a 20062d4 <erase.part.2+0x14c> <== ALWAYS TAKEN
2006298: c2 06 e0 60 ld [ %i3 + 0x60 ], %g1
200629c: 80 88 62 00 btst 0x200, %g1 <== NOT EXECUTED
20062a0: 02 80 00 0d be 20062d4 <erase.part.2+0x14c> <== NOT EXECUTED
20062a4: c2 06 e0 60 ld [ %i3 + 0x60 ], %g1 <== NOT EXECUTED
rtems_termios_puts ("\b \b", 3, tty);
20062a8: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
20062ac: 92 10 20 03 mov 3, %o1 <== NOT EXECUTED
20062b0: 7f ff fe ed call 2005e64 <rtems_termios_puts> <== NOT EXECUTED
20062b4: 94 10 00 1d mov %i5, %o2 <== NOT EXECUTED
if (tty->column)
20062b8: c2 07 60 28 ld [ %i5 + 0x28 ], %g1 <== NOT EXECUTED
20062bc: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
20062c0: 22 80 00 05 be,a 20062d4 <erase.part.2+0x14c> <== NOT EXECUTED
20062c4: c2 06 e0 60 ld [ %i3 + 0x60 ], %g1 <== NOT EXECUTED
tty->column--;
20062c8: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED
20062cc: c2 27 60 28 st %g1, [ %i5 + 0x28 ] <== NOT EXECUTED
}
if (!iscntrl (c) || (tty->termios.c_lflag & ECHOCTL)) {
20062d0: c2 06 e0 60 ld [ %i3 + 0x60 ], %g1 <== NOT EXECUTED
20062d4: c2 08 40 1c ldub [ %g1 + %i4 ], %g1
20062d8: 80 88 60 20 btst 0x20, %g1
20062dc: 02 80 00 07 be 20062f8 <erase.part.2+0x170> <== ALWAYS TAKEN
20062e0: 90 10 00 1a mov %i2, %o0
20062e4: c2 07 60 3c ld [ %i5 + 0x3c ], %g1 <== NOT EXECUTED
20062e8: 80 88 62 00 btst 0x200, %g1 <== NOT EXECUTED
20062ec: 02 80 00 0d be 2006320 <erase.part.2+0x198> <== NOT EXECUTED
20062f0: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED
rtems_termios_puts ("\b \b", 3, tty);
20062f4: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
20062f8: 92 10 20 03 mov 3, %o1
20062fc: 7f ff fe da call 2005e64 <rtems_termios_puts>
2006300: 94 10 00 1d mov %i5, %o2
if (tty->column)
2006304: c2 07 60 28 ld [ %i5 + 0x28 ], %g1
2006308: 80 a0 60 00 cmp %g1, 0
200630c: 02 80 00 05 be 2006320 <erase.part.2+0x198> <== NEVER TAKEN
2006310: 80 a6 60 00 cmp %i1, 0
tty->column--;
2006314: 82 00 7f ff add %g1, -1, %g1
2006318: c2 27 60 28 st %g1, [ %i5 + 0x28 ]
}
}
}
if (!lineFlag)
200631c: 80 a6 60 00 cmp %i1, 0
2006320: 02 80 00 06 be 2006338 <erase.part.2+0x1b0>
2006324: 01 00 00 00 nop
echo ('\n', tty);
return;
}
}
while (tty->ccount) {
2006328: c6 07 60 20 ld [ %i5 + 0x20 ], %g3
200632c: 80 a0 e0 00 cmp %g3, 0
2006330: 32 bf ff 9e bne,a 20061a8 <erase.part.2+0x20>
2006334: c8 07 60 1c ld [ %i5 + 0x1c ], %g4
2006338: 81 c7 e0 08 ret
200633c: 81 e8 00 00 restore
020049bc <eval_path_start>:
size_t pathlen,
int eval_flags,
rtems_filesystem_global_location_t *const *global_root_ptr,
rtems_filesystem_global_location_t *const *global_current_ptr
)
{
20049bc: 9d e3 bf 98 save %sp, -104, %sp
memset(ctx, 0, sizeof(*ctx));
20049c0: 92 10 20 00 clr %o1
20049c4: 90 10 00 18 mov %i0, %o0
20049c8: 40 00 2e 96 call 2010420 <memset>
20049cc: 94 10 20 38 mov 0x38, %o2
ctx->path = path;
20049d0: f2 26 00 00 st %i1, [ %i0 ]
ctx->pathlen = pathlen;
20049d4: f4 26 20 04 st %i2, [ %i0 + 4 ]
rtems_filesystem_eval_path_context_t *ctx,
rtems_filesystem_global_location_t *const *global_root_ptr,
rtems_filesystem_global_location_t *const *global_current_ptr
)
{
if (ctx->pathlen > 0) {
20049d8: 80 a6 a0 00 cmp %i2, 0
20049dc: 02 80 00 19 be 2004a40 <eval_path_start+0x84>
20049e0: f6 26 20 10 st %i3, [ %i0 + 0x10 ]
char c = ctx->path [0];
20049e4: f6 0e 40 00 ldub [ %i1 ], %i3
ctx->rootloc = rtems_filesystem_global_location_obtain(global_root_ptr);
20049e8: 40 00 01 79 call 2004fcc <rtems_filesystem_global_location_obtain>
20049ec: 90 10 00 1c mov %i4, %o0
gid_t node_gid
);
static inline bool rtems_filesystem_is_delimiter(char c)
{
return c == '/' || c == '\\';
20049f0: 83 2e e0 18 sll %i3, 0x18, %g1
20049f4: 83 38 60 18 sra %g1, 0x18, %g1
if (rtems_filesystem_is_delimiter(c)) {
20049f8: 80 a0 60 5c cmp %g1, 0x5c
20049fc: 02 80 00 05 be 2004a10 <eval_path_start+0x54> <== NEVER TAKEN
2004a00: d0 26 20 30 st %o0, [ %i0 + 0x30 ]
2004a04: 80 a0 60 2f cmp %g1, 0x2f
2004a08: 12 80 00 0a bne 2004a30 <eval_path_start+0x74>
2004a0c: 90 10 00 1d mov %i5, %o0
++ctx->path;
2004a10: c2 06 00 00 ld [ %i0 ], %g1
--ctx->pathlen;
ctx->startloc = rtems_filesystem_global_location_obtain(
2004a14: 90 06 20 30 add %i0, 0x30, %o0
char c = ctx->path [0];
ctx->rootloc = rtems_filesystem_global_location_obtain(global_root_ptr);
if (rtems_filesystem_is_delimiter(c)) {
++ctx->path;
2004a18: 82 00 60 01 inc %g1
2004a1c: c2 26 00 00 st %g1, [ %i0 ]
--ctx->pathlen;
2004a20: c2 06 20 04 ld [ %i0 + 4 ], %g1
2004a24: 82 00 7f ff add %g1, -1, %g1
2004a28: 10 80 00 02 b 2004a30 <eval_path_start+0x74>
2004a2c: c2 26 20 04 st %g1, [ %i0 + 4 ]
ctx->startloc = rtems_filesystem_global_location_obtain(
&ctx->rootloc
);
} else {
ctx->startloc = rtems_filesystem_global_location_obtain(
2004a30: 40 00 01 67 call 2004fcc <rtems_filesystem_global_location_obtain>
2004a34: 01 00 00 00 nop
2004a38: 10 80 00 0d b 2004a6c <eval_path_start+0xb0>
2004a3c: d0 26 20 34 st %o0, [ %i0 + 0x34 ]
);
static inline rtems_filesystem_global_location_t *
rtems_filesystem_global_location_obtain_null(void)
{
rtems_filesystem_global_location_t *global_loc = NULL;
2004a40: c0 27 bf fc clr [ %fp + -4 ]
return rtems_filesystem_global_location_obtain( &global_loc );
2004a44: 40 00 01 62 call 2004fcc <rtems_filesystem_global_location_obtain>
2004a48: 90 07 bf fc add %fp, -4, %o0
);
static inline rtems_filesystem_global_location_t *
rtems_filesystem_global_location_obtain_null(void)
{
rtems_filesystem_global_location_t *global_loc = NULL;
2004a4c: c0 27 bf fc clr [ %fp + -4 ]
global_current_ptr
);
}
} else {
ctx->rootloc = rtems_filesystem_global_location_obtain_null();
2004a50: d0 26 20 30 st %o0, [ %i0 + 0x30 ]
return rtems_filesystem_global_location_obtain( &global_loc );
2004a54: 40 00 01 5e call 2004fcc <rtems_filesystem_global_location_obtain>
2004a58: 90 07 bf fc add %fp, -4, %o0
ctx->startloc = rtems_filesystem_global_location_obtain_null();
errno = ENOENT;
2004a5c: 40 00 2b ed call 200fa10 <__errno>
2004a60: d0 26 20 34 st %o0, [ %i0 + 0x34 ]
2004a64: 82 10 20 02 mov 2, %g1
2004a68: c2 22 00 00 st %g1, [ %o0 ]
static inline void rtems_filesystem_instance_lock(
const rtems_filesystem_location_info_t *loc
)
{
const rtems_filesystem_mount_table_entry_t *mt_entry = loc->mt_entry;
2004a6c: c2 06 20 34 ld [ %i0 + 0x34 ], %g1
2004a70: d0 00 60 14 ld [ %g1 + 0x14 ], %o0
(*mt_entry->ops->lock_h)( mt_entry );
2004a74: c2 02 20 0c ld [ %o0 + 0xc ], %g1
2004a78: c2 00 40 00 ld [ %g1 ], %g1
2004a7c: 9f c0 40 00 call %g1
2004a80: ba 06 20 18 add %i0, 0x18, %i5
set_startloc(ctx, global_root_ptr, global_current_ptr);
rtems_filesystem_instance_lock(&ctx->startloc->location);
rtems_filesystem_location_clone(
2004a84: d2 06 20 34 ld [ %i0 + 0x34 ], %o1
2004a88: 40 00 1d 30 call 200bf48 <rtems_filesystem_location_clone>
2004a8c: 90 10 00 1d mov %i5, %o0
&ctx->currentloc,
&ctx->startloc->location
);
rtems_filesystem_eval_path_continue(ctx);
2004a90: 90 10 00 18 mov %i0, %o0
2004a94: 7f ff ff b0 call 2004954 <rtems_filesystem_eval_path_continue>
2004a98: b0 10 00 1d mov %i5, %i0
return &ctx->currentloc;
}
2004a9c: 81 c7 e0 08 ret
2004aa0: 81 e8 00 00 restore
020260fc <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)
{
20260fc: 9d e3 bf 98 save %sp, -104, %sp
rtems_status_code sc = RTEMS_SUCCESSFUL;
uint8_t i;
bool sec_of_fat;
if (fs_info->c.state == FAT_CACHE_EMPTY)
2026100: c2 0e 20 7d ldub [ %i0 + 0x7d ], %g1
2026104: 80 a0 60 00 cmp %g1, 0
2026108: 32 80 00 14 bne,a 2026158 <fat_buf_access+0x5c>
202610c: c2 06 20 78 ld [ %i0 + 0x78 ], %g1
{
if (op_type == FAT_OP_TYPE_READ)
sc = rtems_bdbuf_read(fs_info->vol.dd, blk, &fs_info->c.buf);
2026110: 92 10 00 19 mov %i1, %o1
bool sec_of_fat;
if (fs_info->c.state == FAT_CACHE_EMPTY)
{
if (op_type == FAT_OP_TYPE_READ)
2026114: 80 a6 a0 01 cmp %i2, 1
2026118: d0 06 20 58 ld [ %i0 + 0x58 ], %o0
202611c: 12 80 00 06 bne 2026134 <fat_buf_access+0x38>
2026120: 94 06 20 80 add %i0, 0x80, %o2
sc = rtems_bdbuf_read(fs_info->vol.dd, blk, &fs_info->c.buf);
2026124: 7f ff 81 55 call 2006678 <rtems_bdbuf_read>
2026128: 01 00 00 00 nop
else
sc = rtems_bdbuf_get(fs_info->vol.dd, blk, &fs_info->c.buf);
if (sc != RTEMS_SUCCESSFUL)
202612c: 10 80 00 05 b 2026140 <fat_buf_access+0x44>
2026130: 80 a2 20 00 cmp %o0, 0
if (fs_info->c.state == FAT_CACHE_EMPTY)
{
if (op_type == FAT_OP_TYPE_READ)
sc = rtems_bdbuf_read(fs_info->vol.dd, blk, &fs_info->c.buf);
else
sc = rtems_bdbuf_get(fs_info->vol.dd, blk, &fs_info->c.buf);
2026134: 7f ff 81 20 call 20065b4 <rtems_bdbuf_get>
2026138: 01 00 00 00 nop
if (sc != RTEMS_SUCCESSFUL)
202613c: 80 a2 20 00 cmp %o0, 0
2026140: 12 80 00 60 bne 20262c0 <fat_buf_access+0x1c4> <== NEVER TAKEN
2026144: 82 10 20 01 mov 1, %g1
rtems_set_errno_and_return_minus_one(EIO);
fs_info->c.blk_num = blk;
2026148: f2 26 20 78 st %i1, [ %i0 + 0x78 ]
fs_info->c.modified = 0;
202614c: c0 2e 20 7c clrb [ %i0 + 0x7c ]
fs_info->c.state = FAT_CACHE_ACTUAL;
2026150: c2 2e 20 7d stb %g1, [ %i0 + 0x7d ]
}
sec_of_fat = ((fs_info->c.blk_num >= fs_info->vol.fat_loc) &&
2026154: c2 06 20 78 ld [ %i0 + 0x78 ], %g1
2026158: c4 16 20 14 lduh [ %i0 + 0x14 ], %g2
202615c: 80 a0 40 02 cmp %g1, %g2
2026160: 0a 80 00 05 bcs 2026174 <fat_buf_access+0x78> <== NEVER TAKEN
2026164: ba 10 20 00 clr %i5
2026168: c4 06 20 1c ld [ %i0 + 0x1c ], %g2
202616c: 80 a0 40 02 cmp %g1, %g2
2026170: ba 40 20 00 addx %g0, 0, %i5
(fs_info->c.blk_num < fs_info->vol.rdir_loc));
if (fs_info->c.blk_num != blk)
2026174: 80 a0 40 19 cmp %g1, %i1
2026178: 22 80 00 5b be,a 20262e4 <fat_buf_access+0x1e8>
202617c: c2 06 20 80 ld [ %i0 + 0x80 ], %g1
{
if (fs_info->c.modified)
2026180: c2 0e 20 7c ldub [ %i0 + 0x7c ], %g1
2026184: 80 a0 60 00 cmp %g1, 0
2026188: 02 80 00 3b be 2026274 <fat_buf_access+0x178>
202618c: 80 8f 60 ff btst 0xff, %i5
{
if (sec_of_fat && !fs_info->vol.mirror)
2026190: 02 80 00 0b be 20261bc <fat_buf_access+0xc0>
2026194: 01 00 00 00 nop
2026198: c2 0e 20 48 ldub [ %i0 + 0x48 ], %g1
202619c: 80 a0 60 00 cmp %g1, 0
20261a0: 12 80 00 07 bne 20261bc <fat_buf_access+0xc0> <== NEVER TAKEN
20261a4: 01 00 00 00 nop
memcpy(fs_info->sec_buf, fs_info->c.buf->buffer,
20261a8: c2 06 20 80 ld [ %i0 + 0x80 ], %g1
20261ac: d0 06 20 84 ld [ %i0 + 0x84 ], %o0
20261b0: d2 00 60 1c ld [ %g1 + 0x1c ], %o1
20261b4: 40 00 7d 4d call 20456e8 <memcpy>
20261b8: d4 16 00 00 lduh [ %i0 ], %o2
fs_info->vol.bps);
sc = rtems_bdbuf_release_modified(fs_info->c.buf);
20261bc: 7f ff 81 e1 call 2006940 <rtems_bdbuf_release_modified>
20261c0: d0 06 20 80 ld [ %i0 + 0x80 ], %o0
fs_info->c.state = FAT_CACHE_EMPTY;
20261c4: c0 2e 20 7d clrb [ %i0 + 0x7d ]
fs_info->c.modified = 0;
if (sc != RTEMS_SUCCESSFUL)
20261c8: 80 a2 20 00 cmp %o0, 0
20261cc: 12 80 00 3d bne 20262c0 <fat_buf_access+0x1c4> <== NEVER TAKEN
20261d0: c0 2e 20 7c clrb [ %i0 + 0x7c ]
rtems_set_errno_and_return_minus_one(EIO);
if (sec_of_fat && !fs_info->vol.mirror)
20261d4: 80 8f 60 ff btst 0xff, %i5
20261d8: 02 80 00 2d be 202628c <fat_buf_access+0x190>
20261dc: 92 10 00 19 mov %i1, %o1
20261e0: c2 0e 20 48 ldub [ %i0 + 0x48 ], %g1
20261e4: 80 a0 60 00 cmp %g1, 0
20261e8: 02 80 00 1c be 2026258 <fat_buf_access+0x15c> <== ALWAYS TAKEN
20261ec: ba 10 20 01 mov 1, %i5
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)
20261f0: 10 80 00 28 b 2026290 <fat_buf_access+0x194> <== NOT EXECUTED
20261f4: 80 a6 a0 01 cmp %i2, 1 <== NOT EXECUTED
for (i = 1; i < fs_info->vol.fats; i++)
{
sc = rtems_bdbuf_get(fs_info->vol.dd,
fs_info->c.blk_num +
fs_info->vol.fat_length * i,
20261f8: 7f ff 73 1b call 2002e64 <.umul>
20261fc: f8 06 20 58 ld [ %i0 + 0x58 ], %i4
{
rtems_bdbuf_buffer *b;
for (i = 1; i < fs_info->vol.fats; i++)
{
sc = rtems_bdbuf_get(fs_info->vol.dd,
2026200: d2 06 20 78 ld [ %i0 + 0x78 ], %o1
2026204: 94 07 bf fc add %fp, -4, %o2
2026208: 92 02 00 09 add %o0, %o1, %o1
202620c: 7f ff 80 ea call 20065b4 <rtems_bdbuf_get>
2026210: 90 10 00 1c mov %i4, %o0
fs_info->c.blk_num +
fs_info->vol.fat_length * i,
&b);
if ( sc != RTEMS_SUCCESSFUL)
2026214: 80 a2 20 00 cmp %o0, 0
2026218: 22 80 00 03 be,a 2026224 <fat_buf_access+0x128> <== ALWAYS TAKEN
202621c: c2 07 bf fc ld [ %fp + -4 ], %g1
2026220: 30 80 00 0a b,a 2026248 <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);
2026224: d2 06 20 84 ld [ %i0 + 0x84 ], %o1
2026228: d0 00 60 1c ld [ %g1 + 0x1c ], %o0
202622c: 40 00 7d 2f call 20456e8 <memcpy>
2026230: d4 16 00 00 lduh [ %i0 ], %o2
sc = rtems_bdbuf_release_modified(b);
2026234: 7f ff 81 c3 call 2006940 <rtems_bdbuf_release_modified>
2026238: d0 07 bf fc ld [ %fp + -4 ], %o0
if ( sc != RTEMS_SUCCESSFUL)
202623c: 80 a2 20 00 cmp %o0, 0
2026240: 22 80 00 06 be,a 2026258 <fat_buf_access+0x15c> <== ALWAYS TAKEN
2026244: ba 07 60 01 inc %i5
rtems_set_errno_and_return_minus_one(ENOMEM);
2026248: 40 00 6f e9 call 20421ec <__errno> <== NOT EXECUTED
202624c: 01 00 00 00 nop <== NOT EXECUTED
2026250: 10 80 00 1f b 20262cc <fat_buf_access+0x1d0> <== NOT EXECUTED
2026254: 82 10 20 0c mov 0xc, %g1 ! c <PROM_START+0xc> <== NOT EXECUTED
if (sec_of_fat && !fs_info->vol.mirror)
{
rtems_bdbuf_buffer *b;
for (i = 1; i < fs_info->vol.fats; i++)
2026258: c4 0e 20 09 ldub [ %i0 + 9 ], %g2
202625c: 90 0f 60 ff and %i5, 0xff, %o0
2026260: 80 a2 00 02 cmp %o0, %g2
2026264: 2a bf ff e5 bcs,a 20261f8 <fat_buf_access+0xfc>
2026268: d2 06 20 18 ld [ %i0 + 0x18 ], %o1
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(EIO);
}
if (op_type == FAT_OP_TYPE_READ)
sc = rtems_bdbuf_read(fs_info->vol.dd, blk, &fs_info->c.buf);
202626c: 10 80 00 08 b 202628c <fat_buf_access+0x190>
2026270: 92 10 00 19 mov %i1, %o1
}
}
}
else
{
sc = rtems_bdbuf_release(fs_info->c.buf);
2026274: 7f ff 81 7e call 200686c <rtems_bdbuf_release>
2026278: d0 06 20 80 ld [ %i0 + 0x80 ], %o0
fs_info->c.state = FAT_CACHE_EMPTY;
if (sc != RTEMS_SUCCESSFUL)
202627c: 80 a2 20 00 cmp %o0, 0
2026280: 12 80 00 10 bne 20262c0 <fat_buf_access+0x1c4> <== NEVER TAKEN
2026284: c0 2e 20 7d clrb [ %i0 + 0x7d ]
rtems_set_errno_and_return_minus_one(EIO);
}
if (op_type == FAT_OP_TYPE_READ)
sc = rtems_bdbuf_read(fs_info->vol.dd, blk, &fs_info->c.buf);
2026288: 92 10 00 19 mov %i1, %o1
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)
202628c: 80 a6 a0 01 cmp %i2, 1
2026290: d0 06 20 58 ld [ %i0 + 0x58 ], %o0
2026294: 12 80 00 06 bne 20262ac <fat_buf_access+0x1b0>
2026298: 94 06 20 80 add %i0, 0x80, %o2
sc = rtems_bdbuf_read(fs_info->vol.dd, blk, &fs_info->c.buf);
202629c: 7f ff 80 f7 call 2006678 <rtems_bdbuf_read>
20262a0: 01 00 00 00 nop
else
sc = rtems_bdbuf_get(fs_info->vol.dd, blk, &fs_info->c.buf);
if (sc != RTEMS_SUCCESSFUL)
20262a4: 10 80 00 05 b 20262b8 <fat_buf_access+0x1bc>
20262a8: 80 a2 20 00 cmp %o0, 0
}
if (op_type == FAT_OP_TYPE_READ)
sc = rtems_bdbuf_read(fs_info->vol.dd, blk, &fs_info->c.buf);
else
sc = rtems_bdbuf_get(fs_info->vol.dd, blk, &fs_info->c.buf);
20262ac: 7f ff 80 c2 call 20065b4 <rtems_bdbuf_get>
20262b0: 01 00 00 00 nop
if (sc != RTEMS_SUCCESSFUL)
20262b4: 80 a2 20 00 cmp %o0, 0
20262b8: 02 80 00 08 be 20262d8 <fat_buf_access+0x1dc> <== ALWAYS TAKEN
20262bc: 82 10 20 01 mov 1, %g1
rtems_set_errno_and_return_minus_one(EIO);
20262c0: 40 00 6f cb call 20421ec <__errno> <== NOT EXECUTED
20262c4: 01 00 00 00 nop <== NOT EXECUTED
20262c8: 82 10 20 05 mov 5, %g1 ! 5 <PROM_START+0x5> <== NOT EXECUTED
20262cc: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
20262d0: 81 c7 e0 08 ret <== NOT EXECUTED
20262d4: 91 e8 3f ff restore %g0, -1, %o0 <== NOT EXECUTED
fs_info->c.blk_num = blk;
20262d8: f2 26 20 78 st %i1, [ %i0 + 0x78 ]
fs_info->c.state = FAT_CACHE_ACTUAL;
20262dc: c2 2e 20 7d stb %g1, [ %i0 + 0x7d ]
}
*buf = fs_info->c.buf;
20262e0: c2 06 20 80 ld [ %i0 + 0x80 ], %g1
20262e4: c2 26 c0 00 st %g1, [ %i3 ]
return RC_OK;
}
20262e8: 81 c7 e0 08 ret
20262ec: 91 e8 20 00 restore %g0, 0, %o0
020262f0 <fat_buf_release>:
int
fat_buf_release(fat_fs_info_t *fs_info)
{
20262f0: 9d e3 bf 98 save %sp, -104, %sp
rtems_status_code sc = RTEMS_SUCCESSFUL;
uint8_t i;
bool sec_of_fat;
if (fs_info->c.state == FAT_CACHE_EMPTY)
20262f4: c2 0e 20 7d ldub [ %i0 + 0x7d ], %g1
return RC_OK;
}
int
fat_buf_release(fat_fs_info_t *fs_info)
{
20262f8: ba 10 00 18 mov %i0, %i5
rtems_status_code sc = RTEMS_SUCCESSFUL;
uint8_t i;
bool sec_of_fat;
if (fs_info->c.state == FAT_CACHE_EMPTY)
20262fc: 80 a0 60 00 cmp %g1, 0
2026300: 02 80 00 52 be 2026448 <fat_buf_release+0x158>
2026304: b0 10 20 00 clr %i0
return RC_OK;
sec_of_fat = ((fs_info->c.blk_num >= fs_info->vol.fat_loc) &&
2026308: c2 07 60 78 ld [ %i5 + 0x78 ], %g1
202630c: c4 17 60 14 lduh [ %i5 + 0x14 ], %g2
2026310: 80 a0 40 02 cmp %g1, %g2
2026314: 0a 80 00 05 bcs 2026328 <fat_buf_release+0x38> <== NEVER TAKEN
2026318: b8 10 20 00 clr %i4
202631c: c4 07 60 1c ld [ %i5 + 0x1c ], %g2
2026320: 80 a0 40 02 cmp %g1, %g2
2026324: b8 40 20 00 addx %g0, 0, %i4
(fs_info->c.blk_num < fs_info->vol.rdir_loc));
if (fs_info->c.modified)
2026328: c2 0f 60 7c ldub [ %i5 + 0x7c ], %g1
202632c: 80 a0 60 00 cmp %g1, 0
2026330: 02 80 00 39 be 2026414 <fat_buf_release+0x124>
2026334: 80 8f 20 ff btst 0xff, %i4
{
if (sec_of_fat && !fs_info->vol.mirror)
2026338: 02 80 00 0b be 2026364 <fat_buf_release+0x74>
202633c: 01 00 00 00 nop
2026340: c2 0f 60 48 ldub [ %i5 + 0x48 ], %g1
2026344: 80 a0 60 00 cmp %g1, 0
2026348: 12 80 00 07 bne 2026364 <fat_buf_release+0x74> <== NEVER TAKEN
202634c: 01 00 00 00 nop
memcpy(fs_info->sec_buf, fs_info->c.buf->buffer, fs_info->vol.bps);
2026350: c2 07 60 80 ld [ %i5 + 0x80 ], %g1
2026354: d0 07 60 84 ld [ %i5 + 0x84 ], %o0
2026358: d2 00 60 1c ld [ %g1 + 0x1c ], %o1
202635c: 40 00 7c e3 call 20456e8 <memcpy>
2026360: d4 17 40 00 lduh [ %i5 ], %o2
sc = rtems_bdbuf_release_modified(fs_info->c.buf);
2026364: 7f ff 81 77 call 2006940 <rtems_bdbuf_release_modified>
2026368: d0 07 60 80 ld [ %i5 + 0x80 ], %o0
if (sc != RTEMS_SUCCESSFUL)
202636c: 80 a2 20 00 cmp %o0, 0
2026370: 12 80 00 2e bne 2026428 <fat_buf_release+0x138> <== NEVER TAKEN
2026374: 80 8f 20 ff btst 0xff, %i4
rtems_set_errno_and_return_minus_one(EIO);
fs_info->c.modified = 0;
if (sec_of_fat && !fs_info->vol.mirror)
2026378: 02 80 00 32 be 2026440 <fat_buf_release+0x150>
202637c: c0 2f 60 7c clrb [ %i5 + 0x7c ]
2026380: c2 0f 60 48 ldub [ %i5 + 0x48 ], %g1
2026384: 80 a0 60 00 cmp %g1, 0
2026388: 22 80 00 1c be,a 20263f8 <fat_buf_release+0x108> <== ALWAYS TAKEN
202638c: b8 10 20 01 mov 1, %i4
{
sc = rtems_bdbuf_release(fs_info->c.buf);
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(EIO);
}
fs_info->c.state = FAT_CACHE_EMPTY;
2026390: 10 80 00 2d b 2026444 <fat_buf_release+0x154> <== NOT EXECUTED
2026394: c0 2f 60 7d clrb [ %i5 + 0x7d ] <== NOT EXECUTED
for (i = 1; i < fs_info->vol.fats; i++)
{
sc = rtems_bdbuf_get(fs_info->vol.dd,
fs_info->c.blk_num +
fs_info->vol.fat_length * i,
2026398: 7f ff 72 b3 call 2002e64 <.umul>
202639c: f6 07 60 58 ld [ %i5 + 0x58 ], %i3
{
rtems_bdbuf_buffer *b;
for (i = 1; i < fs_info->vol.fats; i++)
{
sc = rtems_bdbuf_get(fs_info->vol.dd,
20263a0: d2 07 60 78 ld [ %i5 + 0x78 ], %o1
20263a4: 94 07 bf fc add %fp, -4, %o2
20263a8: 92 02 00 09 add %o0, %o1, %o1
20263ac: 7f ff 80 82 call 20065b4 <rtems_bdbuf_get>
20263b0: 90 10 00 1b mov %i3, %o0
fs_info->c.blk_num +
fs_info->vol.fat_length * i,
&b);
if ( sc != RTEMS_SUCCESSFUL)
20263b4: 80 a2 20 00 cmp %o0, 0
20263b8: 22 80 00 03 be,a 20263c4 <fat_buf_release+0xd4> <== ALWAYS TAKEN
20263bc: c2 07 bf fc ld [ %fp + -4 ], %g1
20263c0: 30 80 00 0a b,a 20263e8 <fat_buf_release+0xf8> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(ENOMEM);
memcpy(b->buffer, fs_info->sec_buf, fs_info->vol.bps);
20263c4: d2 07 60 84 ld [ %i5 + 0x84 ], %o1
20263c8: d0 00 60 1c ld [ %g1 + 0x1c ], %o0
20263cc: 40 00 7c c7 call 20456e8 <memcpy>
20263d0: d4 17 40 00 lduh [ %i5 ], %o2
sc = rtems_bdbuf_release_modified(b);
20263d4: 7f ff 81 5b call 2006940 <rtems_bdbuf_release_modified>
20263d8: d0 07 bf fc ld [ %fp + -4 ], %o0
if ( sc != RTEMS_SUCCESSFUL)
20263dc: 80 a2 20 00 cmp %o0, 0
20263e0: 22 80 00 06 be,a 20263f8 <fat_buf_release+0x108> <== ALWAYS TAKEN
20263e4: b8 07 20 01 inc %i4
rtems_set_errno_and_return_minus_one(ENOMEM);
20263e8: 40 00 6f 81 call 20421ec <__errno> <== NOT EXECUTED
20263ec: 01 00 00 00 nop <== NOT EXECUTED
20263f0: 10 80 00 11 b 2026434 <fat_buf_release+0x144> <== NOT EXECUTED
20263f4: 82 10 20 0c mov 0xc, %g1 ! c <PROM_START+0xc> <== NOT EXECUTED
if (sec_of_fat && !fs_info->vol.mirror)
{
rtems_bdbuf_buffer *b;
for (i = 1; i < fs_info->vol.fats; i++)
20263f8: c4 0f 60 09 ldub [ %i5 + 9 ], %g2
20263fc: 90 0f 20 ff and %i4, 0xff, %o0
2026400: 80 a2 00 02 cmp %o0, %g2
2026404: 2a bf ff e5 bcs,a 2026398 <fat_buf_release+0xa8>
2026408: d2 07 60 18 ld [ %i5 + 0x18 ], %o1
{
sc = rtems_bdbuf_release(fs_info->c.buf);
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(EIO);
}
fs_info->c.state = FAT_CACHE_EMPTY;
202640c: 10 80 00 0e b 2026444 <fat_buf_release+0x154>
2026410: c0 2f 60 7d clrb [ %i5 + 0x7d ]
}
}
}
else
{
sc = rtems_bdbuf_release(fs_info->c.buf);
2026414: 7f ff 81 16 call 200686c <rtems_bdbuf_release>
2026418: d0 07 60 80 ld [ %i5 + 0x80 ], %o0
if (sc != RTEMS_SUCCESSFUL)
202641c: 80 a2 20 00 cmp %o0, 0
2026420: 22 80 00 09 be,a 2026444 <fat_buf_release+0x154> <== ALWAYS TAKEN
2026424: c0 2f 60 7d clrb [ %i5 + 0x7d ]
rtems_set_errno_and_return_minus_one(EIO);
2026428: 40 00 6f 71 call 20421ec <__errno> <== NOT EXECUTED
202642c: 01 00 00 00 nop <== NOT EXECUTED
2026430: 82 10 20 05 mov 5, %g1 ! 5 <PROM_START+0x5> <== NOT EXECUTED
2026434: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
2026438: 81 c7 e0 08 ret <== NOT EXECUTED
202643c: 91 e8 3f ff restore %g0, -1, %o0 <== NOT EXECUTED
}
fs_info->c.state = FAT_CACHE_EMPTY;
2026440: c0 2f 60 7d clrb [ %i5 + 0x7d ]
return RC_OK;
2026444: b0 10 20 00 clr %i0
}
2026448: 81 c7 e0 08 ret
202644c: 81 e8 00 00 restore
02025470 <fat_cluster_num_to_sector_num>:
fat_cluster_num_to_sector_num(
const fat_fs_info_t *fs_info,
uint32_t cln
)
{
if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
2025470: 80 a2 60 00 cmp %o1, 0
2025474: 32 80 00 08 bne,a 2025494 <fat_cluster_num_to_sector_num+0x24>
2025478: c2 0a 20 05 ldub [ %o0 + 5 ], %g1
202547c: c2 0a 20 0a ldub [ %o0 + 0xa ], %g1
2025480: 80 88 60 03 btst 3, %g1
2025484: 22 80 00 04 be,a 2025494 <fat_cluster_num_to_sector_num+0x24><== NEVER TAKEN
2025488: c2 0a 20 05 ldub [ %o0 + 5 ], %g1 <== NOT EXECUTED
return fs_info->vol.rdir_loc;
202548c: 81 c3 e0 08 retl
2025490: d0 02 20 1c ld [ %o0 + 0x1c ], %o0
return (((cln - FAT_RSRVD_CLN) << fs_info->vol.spc_log2) +
2025494: 92 02 7f fe add %o1, -2, %o1
2025498: 93 2a 40 01 sll %o1, %g1, %o1
202549c: c2 02 20 30 ld [ %o0 + 0x30 ], %g1
fs_info->vol.data_fsec);
}
20254a0: 81 c3 e0 08 retl
20254a4: 90 02 40 01 add %o1, %g1, %o0
02026608 <fat_cluster_read>:
fat_cluster_num_to_sector_num(
const fat_fs_info_t *fs_info,
uint32_t cln
)
{
if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
2026608: 80 a2 60 00 cmp %o1, 0 <== NOT EXECUTED
202660c: 12 80 00 08 bne 202662c <fat_cluster_read+0x24> <== NOT EXECUTED
2026610: 98 10 00 0a mov %o2, %o4 <== NOT EXECUTED
2026614: c2 0a 20 0a ldub [ %o0 + 0xa ], %g1 <== NOT EXECUTED
2026618: 80 88 60 03 btst 3, %g1 <== NOT EXECUTED
202661c: 22 80 00 05 be,a 2026630 <fat_cluster_read+0x28> <== NOT EXECUTED
2026620: c2 0a 20 05 ldub [ %o0 + 5 ], %g1 <== NOT EXECUTED
return fs_info->vol.rdir_loc;
2026624: 10 80 00 07 b 2026640 <fat_cluster_read+0x38> <== NOT EXECUTED
2026628: d2 02 20 1c ld [ %o0 + 0x1c ], %o1 <== NOT EXECUTED
return (((cln - FAT_RSRVD_CLN) << fs_info->vol.spc_log2) +
202662c: c2 0a 20 05 ldub [ %o0 + 5 ], %g1 <== NOT EXECUTED
2026630: 92 02 7f fe add %o1, -2, %o1 <== NOT EXECUTED
2026634: 93 2a 40 01 sll %o1, %g1, %o1 <== NOT EXECUTED
2026638: c2 02 20 30 ld [ %o0 + 0x30 ], %g1 <== NOT EXECUTED
202663c: 92 02 40 01 add %o1, %g1, %o1 <== NOT EXECUTED
uint32_t fsec = 0;
fsec = fat_cluster_num_to_sector_num(fs_info, cln);
return _fat_block_read(fs_info, fsec, 0,
fs_info->vol.spc << fs_info->vol.sec_log2, buff);
2026640: d6 0a 20 04 ldub [ %o0 + 4 ], %o3 <== NOT EXECUTED
2026644: c2 0a 20 02 ldub [ %o0 + 2 ], %g1 <== NOT EXECUTED
{
uint32_t fsec = 0;
fsec = fat_cluster_num_to_sector_num(fs_info, cln);
return _fat_block_read(fs_info, fsec, 0,
2026648: 94 10 20 00 clr %o2 <== NOT EXECUTED
202664c: 97 2a c0 01 sll %o3, %g1, %o3 <== NOT EXECUTED
2026650: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED
2026654: 7f ff ff 7f call 2026450 <_fat_block_read> <== NOT EXECUTED
2026658: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED
0202665c <fat_cluster_write>:
fat_cluster_num_to_sector_num(
const fat_fs_info_t *fs_info,
uint32_t cln
)
{
if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
202665c: 80 a2 60 00 cmp %o1, 0
2026660: 12 80 00 08 bne 2026680 <fat_cluster_write+0x24> <== ALWAYS TAKEN
2026664: 98 10 00 0a mov %o2, %o4
2026668: c2 0a 20 0a ldub [ %o0 + 0xa ], %g1 <== NOT EXECUTED
202666c: 80 88 60 03 btst 3, %g1 <== NOT EXECUTED
2026670: 22 80 00 05 be,a 2026684 <fat_cluster_write+0x28> <== NOT EXECUTED
2026674: c2 0a 20 05 ldub [ %o0 + 5 ], %g1 <== NOT EXECUTED
return fs_info->vol.rdir_loc;
2026678: 10 80 00 07 b 2026694 <fat_cluster_write+0x38> <== NOT EXECUTED
202667c: d2 02 20 1c ld [ %o0 + 0x1c ], %o1 <== NOT EXECUTED
return (((cln - FAT_RSRVD_CLN) << fs_info->vol.spc_log2) +
2026680: c2 0a 20 05 ldub [ %o0 + 5 ], %g1
2026684: 92 02 7f fe add %o1, -2, %o1
2026688: 93 2a 40 01 sll %o1, %g1, %o1
202668c: c2 02 20 30 ld [ %o0 + 0x30 ], %g1
2026690: 92 02 40 01 add %o1, %g1, %o1
uint32_t fsec = 0;
fsec = fat_cluster_num_to_sector_num(fs_info, cln);
return _fat_block_write(fs_info, fsec, 0,
fs_info->vol.spc << fs_info->vol.sec_log2, buff);
2026694: d6 0a 20 04 ldub [ %o0 + 4 ], %o3
2026698: c2 0a 20 02 ldub [ %o0 + 2 ], %g1
{
uint32_t fsec = 0;
fsec = fat_cluster_num_to_sector_num(fs_info, cln);
return _fat_block_write(fs_info, fsec, 0,
202669c: 94 10 20 00 clr %o2
20266a0: 97 2a c0 01 sll %o3, %g1, %o3
20266a4: 82 13 c0 00 mov %o7, %g1
20266a8: 7f ff ff 8c call 20264d8 <_fat_block_write>
20266ac: 9e 10 40 00 mov %g1, %o7
02026860 <fat_fat32_update_fsinfo_sector>:
fat_fat32_update_fsinfo_sector(
fat_fs_info_t *fs_info,
uint32_t free_count,
uint32_t next_free
)
{
2026860: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED
ssize_t ret1 = 0, ret2 = 0;
uint32_t le_free_count = 0;
uint32_t le_next_free = 0;
le_free_count = CT_LE_L(free_count);
2026864: 7f ff fe 1a call 20260cc <CPU_swap_u32> <== NOT EXECUTED
2026868: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
202686c: d0 27 bf f8 st %o0, [ %fp + -8 ] <== NOT EXECUTED
le_next_free = CT_LE_L(next_free);
2026870: 7f ff fe 17 call 20260cc <CPU_swap_u32> <== NOT EXECUTED
2026874: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
ret1 = _fat_block_write(fs_info,
2026878: d2 16 20 3c lduh [ %i0 + 0x3c ], %o1 <== NOT EXECUTED
ssize_t ret1 = 0, ret2 = 0;
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);
202687c: d0 27 bf fc st %o0, [ %fp + -4 ] <== NOT EXECUTED
ret1 = _fat_block_write(fs_info,
2026880: 94 10 21 e8 mov 0x1e8, %o2 <== NOT EXECUTED
2026884: 96 10 20 04 mov 4, %o3 <== NOT EXECUTED
2026888: 98 07 bf f8 add %fp, -8, %o4 <== NOT EXECUTED
202688c: 7f ff ff 13 call 20264d8 <_fat_block_write> <== NOT EXECUTED
2026890: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
fs_info->vol.info_sec,
FAT_FSINFO_FREE_CLUSTER_COUNT_OFFSET,
4,
(char *)(&le_free_count));
ret2 = _fat_block_write(fs_info,
2026894: d2 16 20 3c lduh [ %i0 + 0x3c ], %o1 <== 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(fs_info,
2026898: ba 10 00 08 mov %o0, %i5 <== NOT EXECUTED
fs_info->vol.info_sec,
FAT_FSINFO_FREE_CLUSTER_COUNT_OFFSET,
4,
(char *)(&le_free_count));
ret2 = _fat_block_write(fs_info,
202689c: 94 10 21 ec mov 0x1ec, %o2 <== NOT EXECUTED
20268a0: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
20268a4: 96 10 20 04 mov 4, %o3 <== NOT EXECUTED
20268a8: 7f ff ff 0c call 20264d8 <_fat_block_write> <== NOT EXECUTED
20268ac: 98 07 bf fc add %fp, -4, %o4 <== NOT EXECUTED
fs_info->vol.info_sec,
FAT_FSINFO_NEXT_FREE_CLUSTER_OFFSET,
4,
(char *)(&le_next_free));
if ( (ret1 < 0) || (ret2 < 0) )
20268b0: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
20268b4: 06 80 00 04 bl 20268c4 <fat_fat32_update_fsinfo_sector+0x64><== NOT EXECUTED
20268b8: 80 a7 60 00 cmp %i5, 0 <== NOT EXECUTED
20268bc: 16 80 00 03 bge 20268c8 <fat_fat32_update_fsinfo_sector+0x68><== NOT EXECUTED
20268c0: b0 10 20 00 clr %i0 <== NOT EXECUTED
return -1;
20268c4: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
return RC_OK;
}
20268c8: 81 c7 e0 08 ret <== NOT EXECUTED
20268cc: 81 e8 00 00 restore <== NOT EXECUTED
020259dc <fat_file_close>:
int
fat_file_close(
fat_fs_info_t *fs_info,
fat_file_fd_t *fat_fd
)
{
20259dc: 9d e3 bf a0 save %sp, -96, %sp
/*
* 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)
20259e0: c2 06 60 08 ld [ %i1 + 8 ], %g1
20259e4: 80 a0 60 01 cmp %g1, 1
20259e8: 08 80 00 05 bleu 20259fc <fat_file_close+0x20>
20259ec: 82 00 7f ff add %g1, -1, %g1
{
fat_fd->links_num--;
return rc;
20259f0: 90 10 20 00 clr %o0
20259f4: 10 80 00 25 b 2025a88 <fat_file_close+0xac>
20259f8: c2 26 60 08 st %g1, [ %i1 + 8 ]
}
key = fat_construct_key(fs_info, &fat_fd->dir_pos.sname);
if (fat_fd->flags & FAT_FILE_REMOVED)
20259fc: c2 0e 60 30 ldub [ %i1 + 0x30 ], %g1
2025a00: 80 88 60 01 btst 1, %g1
2025a04: 02 80 00 14 be 2025a54 <fat_file_close+0x78>
2025a08: 90 10 00 18 mov %i0, %o0
{
rc = fat_file_truncate(fs_info, fat_fd, 0);
2025a0c: 92 10 00 19 mov %i1, %o1
2025a10: 7f ff ff ae call 20258c8 <fat_file_truncate>
2025a14: 94 10 20 00 clr %o2
if ( rc != RC_OK )
2025a18: 80 a2 20 00 cmp %o0, 0
2025a1c: 12 80 00 1b bne 2025a88 <fat_file_close+0xac> <== NEVER TAKEN
2025a20: 01 00 00 00 nop
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
2025a24: 40 00 16 10 call 202b264 <_Chain_Extract>
2025a28: 90 10 00 19 mov %i1, %o0
return rc;
_hash_delete(fs_info->rhash, key, fat_fd->ino, fat_fd);
if ( fat_ino_is_unique(fs_info, fat_fd->ino) )
2025a2c: d2 06 60 0c ld [ %i1 + 0xc ], %o1
2025a30: 40 00 03 88 call 2026850 <fat_ino_is_unique>
2025a34: 90 10 00 18 mov %i0, %o0
2025a38: 80 8a 20 ff btst 0xff, %o0
2025a3c: 02 80 00 0f be 2025a78 <fat_file_close+0x9c> <== ALWAYS TAKEN
2025a40: 01 00 00 00 nop
fat_free_unique_ino(fs_info, fat_fd->ino);
2025a44: d2 06 60 0c ld [ %i1 + 0xc ], %o1 <== NOT EXECUTED
2025a48: 40 00 03 77 call 2026824 <fat_free_unique_ino> <== NOT EXECUTED
2025a4c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
2025a50: 30 80 00 0a b,a 2025a78 <fat_file_close+0x9c> <== NOT EXECUTED
free(fat_fd);
}
else
{
if (fat_ino_is_unique(fs_info, fat_fd->ino))
2025a54: 40 00 03 7f call 2026850 <fat_ino_is_unique>
2025a58: d2 06 60 0c ld [ %i1 + 0xc ], %o1
2025a5c: 80 8a 20 ff btst 0xff, %o0
2025a60: 02 80 00 04 be 2025a70 <fat_file_close+0x94> <== ALWAYS TAKEN
2025a64: 01 00 00 00 nop
{
fat_fd->links_num = 0;
2025a68: 10 80 00 06 b 2025a80 <fat_file_close+0xa4> <== NOT EXECUTED
2025a6c: c0 26 60 08 clr [ %i1 + 8 ] <== NOT EXECUTED
2025a70: 40 00 15 fd call 202b264 <_Chain_Extract>
2025a74: 90 10 00 19 mov %i1, %o0
}
else
{
_hash_delete(fs_info->vhash, key, fat_fd->ino, fat_fd);
free(fat_fd);
2025a78: 7f ff 8c 61 call 2008bfc <free>
2025a7c: 90 10 00 19 mov %i1, %o0
}
}
/*
* flush any modified "cached" buffer back to disk
*/
rc = fat_buf_release(fs_info);
2025a80: 40 00 02 1c call 20262f0 <fat_buf_release>
2025a84: 81 e8 00 00 restore
return rc;
}
2025a88: 81 c7 e0 08 ret
2025a8c: 91 e8 00 08 restore %g0, %o0, %o0
02025b60 <fat_file_extend>:
fat_file_fd_t *fat_fd,
bool zero_fill,
uint32_t new_length,
uint32_t *a_length
)
{
2025b60: 9d e3 bf 90 save %sp, -112, %sp
uint32_t old_last_cl;
uint32_t last_cl = 0;
uint32_t bytes_remain = 0;
uint32_t cls_added;
*a_length = new_length;
2025b64: f6 27 00 00 st %i3, [ %i4 ]
if (new_length <= fat_fd->fat_file_size)
2025b68: c2 06 60 18 ld [ %i1 + 0x18 ], %g1
uint32_t new_length,
uint32_t *a_length
)
{
int rc = RC_OK;
uint32_t chain = 0;
2025b6c: c0 27 bf f0 clr [ %fp + -16 ]
uint32_t bytes2add = 0;
uint32_t cls2add = 0;
uint32_t old_last_cl;
uint32_t last_cl = 0;
2025b70: c0 27 bf f8 clr [ %fp + -8 ]
uint32_t bytes_remain = 0;
uint32_t cls_added;
*a_length = new_length;
if (new_length <= fat_fd->fat_file_size)
2025b74: 80 a6 c0 01 cmp %i3, %g1
2025b78: 18 80 00 04 bgu 2025b88 <fat_file_extend+0x28>
2025b7c: ba 10 00 18 mov %i0, %i5
return RC_OK;
2025b80: 81 c7 e0 08 ret
2025b84: 91 e8 20 00 restore %g0, 0, %o0
if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&
2025b88: c4 06 60 20 ld [ %i1 + 0x20 ], %g2
2025b8c: 80 a0 a0 01 cmp %g2, 1
2025b90: 32 80 00 0b bne,a 2025bbc <fat_file_extend+0x5c> <== ALWAYS TAKEN
2025b94: e0 17 60 06 lduh [ %i5 + 6 ], %l0
2025b98: c4 06 60 24 ld [ %i1 + 0x24 ], %g2 <== NOT EXECUTED
2025b9c: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED
2025ba0: 32 80 00 07 bne,a 2025bbc <fat_file_extend+0x5c> <== NOT EXECUTED
2025ba4: e0 17 60 06 lduh [ %i5 + 6 ], %l0 <== NOT EXECUTED
(fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))
2025ba8: c4 0e 20 0a ldub [ %i0 + 0xa ], %g2 <== 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)) &&
2025bac: 80 88 a0 03 btst 3, %g2 <== NOT EXECUTED
2025bb0: 22 80 00 03 be,a 2025bbc <fat_file_extend+0x5c> <== NOT EXECUTED
2025bb4: e0 17 60 06 lduh [ %i5 + 6 ], %l0 <== NOT EXECUTED
2025bb8: 30 80 00 39 b,a 2025c9c <fat_file_extend+0x13c> <== NOT EXECUTED
(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))) &
2025bbc: 84 04 3f ff add %l0, -1, %g2
2025bc0: a4 08 80 01 and %g2, %g1, %l2
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 -
2025bc4: a0 24 00 12 sub %l0, %l2, %l0
2025bc8: a0 0c 00 02 and %l0, %g2, %l0
(fat_fd->fat_file_size & (fs_info->vol.bpc - 1))) &
(fs_info->vol.bpc - 1);
bytes2add = new_length - fat_fd->fat_file_size;
2025bcc: 84 26 c0 01 sub %i3, %g1, %g2
if (bytes2add > bytes_remain)
2025bd0: 80 a0 80 10 cmp %g2, %l0
2025bd4: 08 80 00 03 bleu 2025be0 <fat_file_extend+0x80>
2025bd8: a2 10 20 00 clr %l1
bytes2add -= bytes_remain;
2025bdc: a2 20 80 10 sub %g2, %l0, %l1
else
bytes2add = 0;
if (zero_fill && bytes_remain > 0) {
2025be0: 80 a4 20 00 cmp %l0, 0
2025be4: 02 80 00 1c be 2025c54 <fat_file_extend+0xf4>
2025be8: 80 a4 60 00 cmp %l1, 0
2025bec: 80 a6 a0 00 cmp %i2, 0
2025bf0: 02 80 00 19 be 2025c54 <fat_file_extend+0xf4>
2025bf4: 80 a4 60 00 cmp %l1, 0
uint32_t start = fat_fd->fat_file_size;
uint32_t cl_start = start >> fs_info->vol.bpc_log2;
2025bf8: d4 0f 60 08 ldub [ %i5 + 8 ], %o2
uint32_t ofs = start & (fs_info->vol.bpc - 1);
uint32_t cur_cln;
uint32_t sec;
uint32_t byte;
rc = fat_file_lseek(fs_info, fat_fd, cl_start, &cur_cln);
2025bfc: 90 10 00 1d mov %i5, %o0
2025c00: 92 10 00 19 mov %i1, %o1
2025c04: 95 30 40 0a srl %g1, %o2, %o2
2025c08: 7f ff fe 39 call 20254ec <fat_file_lseek>
2025c0c: 96 07 bf fc add %fp, -4, %o3
if (rc != RC_OK)
2025c10: b0 92 60 00 orcc %o1, 0, %i0
2025c14: 12 80 00 26 bne 2025cac <fat_file_extend+0x14c> <== NEVER TAKEN
2025c18: d2 07 bf fc ld [ %fp + -4 ], %o1
return rc;
sec = fat_cluster_num_to_sector_num(fs_info, cur_cln);
2025c1c: 7f ff fe 15 call 2025470 <fat_cluster_num_to_sector_num>
2025c20: 90 10 00 1d mov %i5, %o0
sec += ofs >> fs_info->vol.sec_log2;
2025c24: d2 0f 60 02 ldub [ %i5 + 2 ], %o1
byte = ofs & (fs_info->vol.bps - 1);
2025c28: d4 17 40 00 lduh [ %i5 ], %o2
rc = fat_file_lseek(fs_info, fat_fd, cl_start, &cur_cln);
if (rc != RC_OK)
return rc;
sec = fat_cluster_num_to_sector_num(fs_info, cur_cln);
sec += ofs >> fs_info->vol.sec_log2;
2025c2c: 93 34 80 09 srl %l2, %o1, %o1
byte = ofs & (fs_info->vol.bps - 1);
2025c30: 94 02 bf ff add %o2, -1, %o2
rc = fat_file_lseek(fs_info, fat_fd, cl_start, &cur_cln);
if (rc != RC_OK)
return rc;
sec = fat_cluster_num_to_sector_num(fs_info, cur_cln);
sec += ofs >> fs_info->vol.sec_log2;
2025c34: 92 02 00 09 add %o0, %o1, %o1
byte = ofs & (fs_info->vol.bps - 1);
rc = _fat_block_zero(fs_info, sec, byte, bytes_remain);
2025c38: 94 0c 80 0a and %l2, %o2, %o2
2025c3c: 90 10 00 1d mov %i5, %o0
2025c40: 40 00 02 4c call 2026570 <_fat_block_zero>
2025c44: 96 10 00 10 mov %l0, %o3
if (rc != RC_OK)
2025c48: b0 92 20 00 orcc %o0, 0, %i0
2025c4c: 12 80 00 18 bne 2025cac <fat_file_extend+0x14c> <== NEVER TAKEN
2025c50: 80 a4 60 00 cmp %l1, 0
/*
* 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)
2025c54: 02 bf ff cb be 2025b80 <fat_file_extend+0x20>
2025c58: a4 04 7f ff add %l1, -1, %l2
return RC_OK;
cls2add = ((bytes2add - 1) >> fs_info->vol.bpc_log2) + 1;
2025c5c: c2 0f 60 08 ldub [ %i5 + 8 ], %g1
rc = fat_scan_fat_for_free_clusters(fs_info, &chain, cls2add,
2025c60: 90 10 00 1d mov %i5, %o0
* file ) - return
*/
if (bytes2add == 0)
return RC_OK;
cls2add = ((bytes2add - 1) >> fs_info->vol.bpc_log2) + 1;
2025c64: a5 34 80 01 srl %l2, %g1, %l2
rc = fat_scan_fat_for_free_clusters(fs_info, &chain, cls2add,
2025c68: 92 07 bf f0 add %fp, -16, %o1
* file ) - return
*/
if (bytes2add == 0)
return RC_OK;
cls2add = ((bytes2add - 1) >> fs_info->vol.bpc_log2) + 1;
2025c6c: a4 04 a0 01 inc %l2
rc = fat_scan_fat_for_free_clusters(fs_info, &chain, cls2add,
2025c70: 96 07 bf fc add %fp, -4, %o3
2025c74: 94 10 00 12 mov %l2, %o2
2025c78: 98 07 bf f8 add %fp, -8, %o4
2025c7c: 40 00 61 26 call 203e114 <fat_scan_fat_for_free_clusters>
2025c80: 9a 10 00 1a mov %i2, %o5
&cls_added, &last_cl, zero_fill);
/* this means that low level I/O error occured */
if (rc != RC_OK)
2025c84: b0 92 20 00 orcc %o0, 0, %i0
2025c88: 12 80 00 09 bne 2025cac <fat_file_extend+0x14c> <== NEVER TAKEN
2025c8c: c2 07 bf fc ld [ %fp + -4 ], %g1
return rc;
/* this means that no space left on device */
if ((cls_added == 0) && (bytes_remain == 0))
2025c90: 80 94 00 01 orcc %l0, %g1, %g0
2025c94: 12 80 00 08 bne 2025cb4 <fat_file_extend+0x154> <== ALWAYS TAKEN
2025c98: 80 a4 80 01 cmp %l2, %g1
rtems_set_errno_and_return_minus_one(ENOSPC);
2025c9c: 40 00 71 54 call 20421ec <__errno> <== NOT EXECUTED
2025ca0: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
2025ca4: 82 10 20 1c mov 0x1c, %g1 <== NOT EXECUTED
2025ca8: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
2025cac: 81 c7 e0 08 ret <== NOT EXECUTED
2025cb0: 81 e8 00 00 restore <== NOT EXECUTED
/* check wether we satisfied request for 'cls2add' clusters */
if (cls2add != cls_added)
2025cb4: 02 80 00 09 be 2025cd8 <fat_file_extend+0x178> <== ALWAYS TAKEN
2025cb8: 82 24 80 01 sub %l2, %g1, %g1
{
new_length -= bytes2add & (fs_info->vol.bpc - 1);
2025cbc: c4 17 60 06 lduh [ %i5 + 6 ], %g2 <== NOT EXECUTED
2025cc0: 84 00 bf ff add %g2, -1, %g2 <== NOT EXECUTED
2025cc4: a2 0c 40 02 and %l1, %g2, %l1 <== NOT EXECUTED
new_length -= (cls2add - cls_added) << fs_info->vol.bpc_log2;
2025cc8: c4 0f 60 08 ldub [ %i5 + 8 ], %g2 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(ENOSPC);
/* check wether we satisfied request for 'cls2add' clusters */
if (cls2add != cls_added)
{
new_length -= bytes2add & (fs_info->vol.bpc - 1);
2025ccc: b6 26 c0 11 sub %i3, %l1, %i3 <== NOT EXECUTED
new_length -= (cls2add - cls_added) << fs_info->vol.bpc_log2;
2025cd0: 83 28 40 02 sll %g1, %g2, %g1 <== NOT EXECUTED
2025cd4: b6 26 c0 01 sub %i3, %g1, %i3 <== NOT EXECUTED
}
/* add new chain to the end of existed */
if ( fat_fd->fat_file_size == 0 )
2025cd8: d6 06 60 18 ld [ %i1 + 0x18 ], %o3
2025cdc: 80 a2 e0 00 cmp %o3, 0
2025ce0: 32 80 00 07 bne,a 2025cfc <fat_file_extend+0x19c>
2025ce4: c2 06 60 3c ld [ %i1 + 0x3c ], %g1
{
fat_fd->map.disk_cln = fat_fd->cln = chain;
2025ce8: c2 07 bf f0 ld [ %fp + -16 ], %g1
fat_fd->map.file_cln = 0;
2025cec: c0 26 60 34 clr [ %i1 + 0x34 ]
}
/* add new chain to the end of existed */
if ( fat_fd->fat_file_size == 0 )
{
fat_fd->map.disk_cln = fat_fd->cln = chain;
2025cf0: c2 26 60 1c st %g1, [ %i1 + 0x1c ]
2025cf4: 10 80 00 1d b 2025d68 <fat_file_extend+0x208>
2025cf8: c2 26 60 38 st %g1, [ %i1 + 0x38 ]
fat_fd->map.file_cln = 0;
}
else
{
if (fat_fd->map.last_cln != FAT_UNDEFINED_VALUE)
2025cfc: 80 a0 7f ff cmp %g1, -1
2025d00: 22 80 00 04 be,a 2025d10 <fat_file_extend+0x1b0> <== NEVER TAKEN
2025d04: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
{
old_last_cl = fat_fd->map.last_cln;
2025d08: 10 80 00 0c b 2025d38 <fat_file_extend+0x1d8>
2025d0c: c2 27 bf f4 st %g1, [ %fp + -12 ]
}
else
{
rc = fat_file_ioctl(fs_info, fat_fd, F_CLU_NUM,
2025d10: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
2025d14: 94 10 20 01 mov 1, %o2 <== NOT EXECUTED
2025d18: 96 02 ff ff add %o3, -1, %o3 <== NOT EXECUTED
2025d1c: 7f ff ff 5d call 2025a90 <fat_file_ioctl> <== NOT EXECUTED
2025d20: 98 07 bf f4 add %fp, -12, %o4 <== NOT EXECUTED
(fat_fd->fat_file_size - 1), &old_last_cl);
if ( rc != RC_OK )
2025d24: b4 92 20 00 orcc %o0, 0, %i2 <== NOT EXECUTED
2025d28: 02 80 00 05 be 2025d3c <fat_file_extend+0x1dc> <== NOT EXECUTED
2025d2c: d2 07 bf f4 ld [ %fp + -12 ], %o1 <== NOT EXECUTED
if (fat_fd->fat_file_type == FAT_DIRECTORY)
{
rc = fat_init_clusters_chain(fs_info, chain);
if ( rc != RC_OK )
{
fat_free_fat_clusters_chain(fs_info, chain);
2025d30: 10 80 00 1f b 2025dac <fat_file_extend+0x24c> <== NOT EXECUTED
2025d34: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
fat_free_fat_clusters_chain(fs_info, chain);
return rc;
}
}
rc = fat_set_fat_cluster(fs_info, old_last_cl, chain);
2025d38: d2 07 bf f4 ld [ %fp + -12 ], %o1
2025d3c: d4 07 bf f0 ld [ %fp + -16 ], %o2
2025d40: 40 00 60 17 call 203dd9c <fat_set_fat_cluster>
2025d44: 90 10 00 1d mov %i5, %o0
2025d48: b4 10 00 08 mov %o0, %i2
if ( rc != RC_OK )
2025d4c: 80 a6 a0 00 cmp %i2, 0
2025d50: 02 80 00 04 be 2025d60 <fat_file_extend+0x200> <== ALWAYS TAKEN
2025d54: 90 10 00 1d mov %i5, %o0
if (fat_fd->fat_file_type == FAT_DIRECTORY)
{
rc = fat_init_clusters_chain(fs_info, chain);
if ( rc != RC_OK )
{
fat_free_fat_clusters_chain(fs_info, chain);
2025d58: 10 80 00 16 b 2025db0 <fat_file_extend+0x250> <== NOT EXECUTED
2025d5c: d2 07 bf f0 ld [ %fp + -16 ], %o1 <== NOT EXECUTED
if ( rc != RC_OK )
{
fat_free_fat_clusters_chain(fs_info, chain);
return rc;
}
fat_buf_release(fs_info);
2025d60: 40 00 01 64 call 20262f0 <fat_buf_release>
2025d64: 01 00 00 00 nop
}
/* update number of the last cluster of the file if it changed */
if (cls_added != 0)
2025d68: c2 07 bf fc ld [ %fp + -4 ], %g1
2025d6c: 80 a0 60 00 cmp %g1, 0
2025d70: 22 80 00 14 be,a 2025dc0 <fat_file_extend+0x260> <== NEVER TAKEN
2025d74: f6 27 00 00 st %i3, [ %i4 ] <== NOT EXECUTED
{
fat_fd->map.last_cln = last_cl;
2025d78: c2 07 bf f8 ld [ %fp + -8 ], %g1
2025d7c: c2 26 60 3c st %g1, [ %i1 + 0x3c ]
if (fat_fd->fat_file_type == FAT_DIRECTORY)
2025d80: c2 06 60 10 ld [ %i1 + 0x10 ], %g1
2025d84: 80 a0 60 00 cmp %g1, 0
2025d88: 32 80 00 0e bne,a 2025dc0 <fat_file_extend+0x260>
2025d8c: f6 27 00 00 st %i3, [ %i4 ]
{
rc = fat_init_clusters_chain(fs_info, chain);
2025d90: d2 07 bf f0 ld [ %fp + -16 ], %o1
2025d94: 40 00 02 47 call 20266b0 <fat_init_clusters_chain>
2025d98: 90 10 00 1d mov %i5, %o0
if ( rc != RC_OK )
2025d9c: b4 92 20 00 orcc %o0, 0, %i2
2025da0: 22 80 00 08 be,a 2025dc0 <fat_file_extend+0x260> <== ALWAYS TAKEN
2025da4: f6 27 00 00 st %i3, [ %i4 ]
{
fat_free_fat_clusters_chain(fs_info, chain);
2025da8: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
2025dac: d2 07 bf f0 ld [ %fp + -16 ], %o1 <== NOT EXECUTED
2025db0: 40 00 60 aa call 203e058 <fat_free_fat_clusters_chain> <== NOT EXECUTED
2025db4: b0 10 00 1a mov %i2, %i0 <== NOT EXECUTED
2025db8: 81 c7 e0 08 ret <== NOT EXECUTED
2025dbc: 81 e8 00 00 restore <== NOT EXECUTED
}
}
}
*a_length = new_length;
fat_fd->fat_file_size = new_length;
2025dc0: f6 26 60 18 st %i3, [ %i1 + 0x18 ]
return RC_OK;
}
2025dc4: 81 c7 e0 08 ret
2025dc8: 81 e8 00 00 restore
02025a90 <fat_file_ioctl>:
fat_file_ioctl(
fat_fs_info_t *fs_info,
fat_file_fd_t *fat_fd,
int cmd,
...)
{
2025a90: 9d e3 bf 98 save %sp, -104, %sp
uint32_t cl_start = 0;
uint32_t pos = 0;
uint32_t *ret;
va_list ap;
va_start(ap, cmd);
2025a94: 82 07 a0 50 add %fp, 0x50, %g1
2025a98: f6 27 a0 50 st %i3, [ %fp + 0x50 ]
2025a9c: f8 27 a0 54 st %i4, [ %fp + 0x54 ]
2025aa0: fa 27 a0 58 st %i5, [ %fp + 0x58 ]
fat_file_fd_t *fat_fd,
int cmd,
...)
{
int rc = RC_OK;
uint32_t cur_cln = 0;
2025aa4: c0 27 bf f8 clr [ %fp + -8 ]
uint32_t *ret;
va_list ap;
va_start(ap, cmd);
switch (cmd)
2025aa8: 80 a6 a0 01 cmp %i2, 1
2025aac: 12 80 00 26 bne 2025b44 <fat_file_ioctl+0xb4> <== NEVER TAKEN
2025ab0: c2 27 bf fc st %g1, [ %fp + -4 ]
{
case F_CLU_NUM:
pos = va_arg(ap, uint32_t);
ret = va_arg(ap, uint32_t *);
2025ab4: 82 07 a0 58 add %fp, 0x58, %g1
2025ab8: c2 27 bf fc st %g1, [ %fp + -4 ]
/* sanity check */
if ( pos >= fat_fd->fat_file_size ) {
2025abc: c2 06 60 18 ld [ %i1 + 0x18 ], %g1
2025ac0: 80 a6 c0 01 cmp %i3, %g1
2025ac4: 0a 80 00 06 bcs 2025adc <fat_file_ioctl+0x4c> <== ALWAYS TAKEN
2025ac8: ba 10 00 1c mov %i4, %i5
va_end(ap);
rtems_set_errno_and_return_minus_one( EIO );
2025acc: 40 00 71 c8 call 20421ec <__errno> <== NOT EXECUTED
2025ad0: 01 00 00 00 nop <== NOT EXECUTED
2025ad4: 10 80 00 1f b 2025b50 <fat_file_ioctl+0xc0> <== NOT EXECUTED
2025ad8: 82 10 20 05 mov 5, %g1 ! 5 <PROM_START+0x5> <== NOT EXECUTED
}
if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&
2025adc: c2 06 60 20 ld [ %i1 + 0x20 ], %g1
2025ae0: 80 a0 60 01 cmp %g1, 1
2025ae4: 32 80 00 0d bne,a 2025b18 <fat_file_ioctl+0x88>
2025ae8: d4 0e 20 08 ldub [ %i0 + 8 ], %o2
2025aec: c2 06 60 24 ld [ %i1 + 0x24 ], %g1
2025af0: 80 a0 60 00 cmp %g1, 0
2025af4: 32 80 00 09 bne,a 2025b18 <fat_file_ioctl+0x88> <== NEVER TAKEN
2025af8: d4 0e 20 08 ldub [ %i0 + 8 ], %o2 <== NOT EXECUTED
(fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))
2025afc: c2 0e 20 0a ldub [ %i0 + 0xa ], %g1
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)) &&
2025b00: 80 88 60 03 btst 3, %g1
2025b04: 22 80 00 05 be,a 2025b18 <fat_file_ioctl+0x88> <== NEVER TAKEN
2025b08: d4 0e 20 08 ldub [ %i0 + 8 ], %o2 <== NOT EXECUTED
(fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))
{
/* cluster 0 (zero) reserved for root dir */
*ret = 0;
2025b0c: c0 27 00 00 clr [ %i4 ]
rc = RC_OK;
break;
2025b10: 81 c7 e0 08 ret
2025b14: 91 e8 20 00 restore %g0, 0, %o0
}
cl_start = pos >> fs_info->vol.bpc_log2;
rc = fat_file_lseek(fs_info, fat_fd, cl_start, &cur_cln);
2025b18: 90 10 00 18 mov %i0, %o0
2025b1c: 92 10 00 19 mov %i1, %o1
2025b20: 95 36 c0 0a srl %i3, %o2, %o2
2025b24: 7f ff fe 72 call 20254ec <fat_file_lseek>
2025b28: 96 07 bf f8 add %fp, -8, %o3
if ( rc != RC_OK )
2025b2c: b0 92 60 00 orcc %o1, 0, %i0
2025b30: 12 80 00 03 bne 2025b3c <fat_file_ioctl+0xac> <== NEVER TAKEN
2025b34: c2 07 bf f8 ld [ %fp + -8 ], %g1
break;
*ret = cur_cln;
2025b38: c2 27 40 00 st %g1, [ %i5 ]
break;
2025b3c: 81 c7 e0 08 ret
2025b40: 81 e8 00 00 restore
default:
errno = EINVAL;
2025b44: 40 00 71 aa call 20421ec <__errno> <== NOT EXECUTED
2025b48: 01 00 00 00 nop <== NOT EXECUTED
2025b4c: 82 10 20 16 mov 0x16, %g1 ! 16 <PROM_START+0x16> <== NOT EXECUTED
2025b50: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
rc = -1;
2025b54: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
break;
}
va_end(ap);
return rc;
}
2025b58: 81 c7 e0 08 ret <== NOT EXECUTED
2025b5c: 81 e8 00 00 restore <== NOT EXECUTED
020254ec <fat_file_lseek>:
fat_fs_info_t *fs_info,
fat_file_fd_t *fat_fd,
uint32_t file_cln,
uint32_t *disk_cln
)
{
20254ec: 9d e3 bf 98 save %sp, -104, %sp
int rc = RC_OK;
if (file_cln == fat_fd->map.file_cln)
20254f0: c2 06 60 34 ld [ %i1 + 0x34 ], %g1
20254f4: 80 a6 80 01 cmp %i2, %g1
20254f8: 12 80 00 05 bne 202550c <fat_file_lseek+0x20>
20254fc: 01 00 00 00 nop
*disk_cln = fat_fd->map.disk_cln;
2025500: c2 06 60 38 ld [ %i1 + 0x38 ], %g1
2025504: 10 80 00 1b b 2025570 <fat_file_lseek+0x84>
2025508: c2 26 c0 00 st %g1, [ %i3 ]
{
uint32_t cur_cln;
uint32_t count;
uint32_t i;
if (file_cln > fat_fd->map.file_cln)
202550c: 28 80 00 06 bleu,a 2025524 <fat_file_lseek+0x38>
2025510: c2 06 60 1c ld [ %i1 + 0x1c ], %g1
{
cur_cln = fat_fd->map.disk_cln;
2025514: c4 06 60 38 ld [ %i1 + 0x38 ], %g2
count = file_cln - fat_fd->map.file_cln;
2025518: b8 26 80 01 sub %i2, %g1, %i4
uint32_t count;
uint32_t i;
if (file_cln > fat_fd->map.file_cln)
{
cur_cln = fat_fd->map.disk_cln;
202551c: 10 80 00 04 b 202552c <fat_file_lseek+0x40>
2025520: c4 27 bf fc st %g2, [ %fp + -4 ]
count = file_cln - fat_fd->map.file_cln;
}
else
{
cur_cln = fat_fd->cln;
2025524: b8 10 00 1a mov %i2, %i4
2025528: c2 27 bf fc st %g1, [ %fp + -4 ]
count = file_cln;
}
/* skip over the clusters */
for (i = 0; i < count; i++)
202552c: 10 80 00 0b b 2025558 <fat_file_lseek+0x6c>
2025530: ba 10 20 00 clr %i5
{
rc = fat_get_fat_cluster(fs_info, cur_cln, &cur_cln);
2025534: 90 10 00 18 mov %i0, %o0
2025538: 40 00 61 a2 call 203dbc0 <fat_get_fat_cluster>
202553c: 94 07 bf fc add %fp, -4, %o2
if ( rc != RC_OK )
2025540: 80 a2 20 00 cmp %o0, 0
2025544: 22 80 00 05 be,a 2025558 <fat_file_lseek+0x6c> <== ALWAYS TAKEN
2025548: ba 07 60 01 inc %i5
return rc;
202554c: 86 10 00 08 mov %o0, %g3 <== NOT EXECUTED
2025550: 10 80 00 0a b 2025578 <fat_file_lseek+0x8c> <== NOT EXECUTED
2025554: 85 3a 20 1f sra %o0, 0x1f, %g2 <== NOT EXECUTED
cur_cln = fat_fd->cln;
count = file_cln;
}
/* skip over the clusters */
for (i = 0; i < count; i++)
2025558: 80 a7 40 1c cmp %i5, %i4
202555c: 12 bf ff f6 bne 2025534 <fat_file_lseek+0x48>
2025560: d2 07 bf fc ld [ %fp + -4 ], %o1
if ( rc != RC_OK )
return rc;
}
/* update cache */
fat_fd->map.file_cln = file_cln;
2025564: f4 26 60 34 st %i2, [ %i1 + 0x34 ]
fat_fd->map.disk_cln = cur_cln;
2025568: d2 26 60 38 st %o1, [ %i1 + 0x38 ]
*disk_cln = cur_cln;
202556c: d2 26 c0 00 st %o1, [ %i3 ]
}
return RC_OK;
2025570: 84 10 20 00 clr %g2
2025574: 86 10 20 00 clr %g3
}
2025578: b0 10 00 02 mov %g2, %i0
202557c: 81 c7 e0 08 ret
2025580: 93 e8 00 03 restore %g0, %g3, %o1
02025584 <fat_file_open>:
fat_file_open(
fat_fs_info_t *fs_info,
fat_dir_pos_t *dir_pos,
fat_file_fd_t **fat_fd
)
{
2025584: 9d e3 bf a0 save %sp, -96, %sp
int rc = RC_OK;
fat_file_fd_t *lfat_fd = NULL;
uint32_t key = 0;
/* construct key */
key = fat_construct_key(fs_info, &dir_pos->sname);
2025588: 90 10 00 18 mov %i0, %o0
202558c: 7f ff ff c7 call 20254a8 <fat_construct_key>
2025590: 92 10 00 19 mov %i1, %o1
uint32_t key1,
uint32_t key2,
fat_file_fd_t **ret
)
{
uint32_t mod = (key1) % FAT_HASH_MODULE;
2025594: 82 0a 20 01 and %o0, 1, %g1
rtems_chain_node *the_node = rtems_chain_first(hash + mod);
2025598: 85 28 60 02 sll %g1, 2, %g2
202559c: b7 28 60 04 sll %g1, 4, %i3
20255a0: c2 06 20 60 ld [ %i0 + 0x60 ], %g1
20255a4: b6 26 c0 02 sub %i3, %g2, %i3
int rc = RC_OK;
fat_file_fd_t *lfat_fd = NULL;
uint32_t key = 0;
/* construct key */
key = fat_construct_key(fs_info, &dir_pos->sname);
20255a8: b8 10 00 08 mov %o0, %i4
uint32_t key2,
fat_file_fd_t **ret
)
{
uint32_t mod = (key1) % FAT_HASH_MODULE;
rtems_chain_node *the_node = rtems_chain_first(hash + mod);
20255ac: a0 00 40 1b add %g1, %i3, %l0
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
20255b0: fa 00 40 1b ld [ %g1 + %i3 ], %i5
RTEMS_INLINE_ROUTINE bool _Chain_Is_tail(
const Chain_Control *the_chain,
const Chain_Node *the_node
)
{
return (the_node == _Chain_Immutable_tail( the_chain ));
20255b4: 10 80 00 0c b 20255e4 <fat_file_open+0x60>
20255b8: a0 04 20 04 add %l0, 4, %l0
for ( ; !rtems_chain_is_tail((hash) + mod, the_node) ; )
{
fat_file_fd_t *ffd = (fat_file_fd_t *)the_node;
uint32_t ck = fat_construct_key(fs_info, &ffd->dir_pos.sname);
20255bc: 7f ff ff bb call 20254a8 <fat_construct_key>
20255c0: 92 07 60 20 add %i5, 0x20, %o1
if ( (key1) == ck)
20255c4: 80 a7 00 08 cmp %i4, %o0
20255c8: 32 80 00 07 bne,a 20255e4 <fat_file_open+0x60>
20255cc: fa 07 40 00 ld [ %i5 ], %i5
rc = _hash_search(fs_info, fs_info->vhash, key, 0, &lfat_fd);
if ( rc == RC_OK )
{
/* return pointer to fat_file_descriptor allocated before */
(*fat_fd) = lfat_fd;
lfat_fd->links_num++;
20255d0: c2 07 60 08 ld [ %i5 + 8 ], %g1
/* access "valid" hash table */
rc = _hash_search(fs_info, fs_info->vhash, key, 0, &lfat_fd);
if ( rc == RC_OK )
{
/* return pointer to fat_file_descriptor allocated before */
(*fat_fd) = lfat_fd;
20255d4: fa 26 80 00 st %i5, [ %i2 ]
lfat_fd->links_num++;
20255d8: 82 00 60 01 inc %g1
20255dc: 10 80 00 42 b 20256e4 <fat_file_open+0x160>
20255e0: c2 27 60 08 st %g1, [ %i5 + 8 ]
)
{
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) ; )
20255e4: 80 a7 40 10 cmp %i5, %l0
20255e8: 12 bf ff f5 bne 20255bc <fat_file_open+0x38>
20255ec: 90 10 00 18 mov %i0, %o0
uint32_t key2,
fat_file_fd_t **ret
)
{
uint32_t mod = (key1) % FAT_HASH_MODULE;
rtems_chain_node *the_node = rtems_chain_first(hash + mod);
20255f0: 10 80 00 3f b 20256ec <fat_file_open+0x168>
20255f4: c2 06 20 64 ld [ %i0 + 0x64 ], %g1
for ( ; !rtems_chain_is_tail((hash) + mod, the_node) ; )
{
fat_file_fd_t *ffd = (fat_file_fd_t *)the_node;
uint32_t ck = fat_construct_key(fs_info, &ffd->dir_pos.sname);
20255f8: 7f ff ff ac call 20254a8 <fat_construct_key> <== NOT EXECUTED
20255fc: 92 07 60 20 add %i5, 0x20, %o1 <== NOT EXECUTED
if ( (key1) == ck)
2025600: 80 a7 00 08 cmp %i4, %o0 <== NOT EXECUTED
2025604: 32 80 00 0a bne,a 202562c <fat_file_open+0xa8> <== NOT EXECUTED
2025608: fa 07 40 00 ld [ %i5 ], %i5 <== NOT EXECUTED
{
if ( ((key2) == 0) || ((key2) == ffd->ino) )
202560c: 80 a7 20 00 cmp %i4, 0 <== NOT EXECUTED
2025610: 22 80 00 0b be,a 202563c <fat_file_open+0xb8> <== NOT EXECUTED
2025614: a0 10 20 00 clr %l0 <== NOT EXECUTED
2025618: c2 07 60 0c ld [ %i5 + 0xc ], %g1 <== NOT EXECUTED
202561c: 80 a7 00 01 cmp %i4, %g1 <== NOT EXECUTED
2025620: 22 80 00 07 be,a 202563c <fat_file_open+0xb8> <== NOT EXECUTED
2025624: a0 10 20 00 clr %l0 <== NOT EXECUTED
{
*ret = (void *)the_node;
return 0;
}
}
the_node = the_node->next;
2025628: fa 07 40 00 ld [ %i5 ], %i5 <== NOT EXECUTED
)
{
uint32_t mod = (key1) % FAT_HASH_MODULE;
rtems_chain_node *the_node = rtems_chain_first(hash + mod);
for ( ; !rtems_chain_is_tail((hash) + mod, the_node) ; )
202562c: 80 a7 40 10 cmp %i5, %l0
2025630: 12 bf ff f2 bne 20255f8 <fat_file_open+0x74> <== NEVER TAKEN
2025634: 90 10 00 18 mov %i0, %o0
2025638: a0 10 3f ff mov -1, %l0
}
/* access "removed-but-still-open" hash table */
rc = _hash_search(fs_info, fs_info->rhash, key, key, &lfat_fd);
lfat_fd = (*fat_fd) = (fat_file_fd_t*)malloc(sizeof(fat_file_fd_t));
202563c: 7f ff 8e ce call 2009174 <malloc>
2025640: 90 10 20 44 mov 0x44, %o0
2025644: d0 26 80 00 st %o0, [ %i2 ]
if ( lfat_fd == NULL )
2025648: 80 a2 20 00 cmp %o0, 0
202564c: 02 80 00 1c be 20256bc <fat_file_open+0x138> <== NEVER TAKEN
2025650: ba 10 00 08 mov %o0, %i5
rtems_set_errno_and_return_minus_one( ENOMEM );
memset(lfat_fd, 0, sizeof(fat_file_fd_t));
2025654: 92 10 20 00 clr %o1
2025658: 40 00 80 b3 call 2045924 <memset>
202565c: 94 10 20 44 mov 0x44, %o2
lfat_fd->links_num = 1;
2025660: 82 10 20 01 mov 1, %g1
2025664: c2 27 60 08 st %g1, [ %i5 + 8 ]
lfat_fd->flags &= ~FAT_FILE_REMOVED;
2025668: c2 0f 60 30 ldub [ %i5 + 0x30 ], %g1
lfat_fd->map.last_cln = FAT_UNDEFINED_VALUE;
lfat_fd->dir_pos = *dir_pos;
202566c: 90 07 60 20 add %i5, 0x20, %o0
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;
2025670: 82 08 7f fe and %g1, -2, %g1
2025674: c2 2f 60 30 stb %g1, [ %i5 + 0x30 ]
lfat_fd->map.last_cln = FAT_UNDEFINED_VALUE;
2025678: 82 10 3f ff mov -1, %g1
lfat_fd->dir_pos = *dir_pos;
202567c: 92 10 00 19 mov %i1, %o1
memset(lfat_fd, 0, sizeof(fat_file_fd_t));
lfat_fd->links_num = 1;
lfat_fd->flags &= ~FAT_FILE_REMOVED;
lfat_fd->map.last_cln = FAT_UNDEFINED_VALUE;
2025680: c2 27 60 3c st %g1, [ %i5 + 0x3c ]
lfat_fd->dir_pos = *dir_pos;
2025684: 40 00 80 19 call 20456e8 <memcpy>
2025688: 94 10 20 10 mov 0x10, %o2
if ( rc != RC_OK )
202568c: 80 a4 20 00 cmp %l0, 0
2025690: 02 80 00 04 be 20256a0 <fat_file_open+0x11c> <== NEVER TAKEN
2025694: 01 00 00 00 nop
lfat_fd->ino = key;
2025698: 10 80 00 0f b 20256d4 <fat_file_open+0x150>
202569c: f8 27 60 0c st %i4, [ %i5 + 0xc ]
else
{
lfat_fd->ino = fat_get_unique_ino(fs_info);
20256a0: 40 00 04 31 call 2026764 <fat_get_unique_ino> <== NOT EXECUTED
20256a4: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
if ( lfat_fd->ino == 0 )
20256a8: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
20256ac: 12 80 00 0a bne 20256d4 <fat_file_open+0x150> <== NOT EXECUTED
20256b0: d0 27 60 0c st %o0, [ %i5 + 0xc ] <== NOT EXECUTED
{
free((*fat_fd));
20256b4: 7f ff 8d 52 call 2008bfc <free> <== NOT EXECUTED
20256b8: d0 06 80 00 ld [ %i2 ], %o0 <== 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 );
20256bc: 40 00 72 cc call 20421ec <__errno> <== NOT EXECUTED
20256c0: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
20256c4: 82 10 20 0c mov 0xc, %g1 <== NOT EXECUTED
20256c8: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
20256cc: 81 c7 e0 08 ret <== NOT EXECUTED
20256d0: 81 e8 00 00 restore <== 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);
20256d4: d0 06 20 60 ld [ %i0 + 0x60 ], %o0
RTEMS_INLINE_ROUTINE void rtems_chain_append(
rtems_chain_control *the_chain,
rtems_chain_node *the_node
)
{
_Chain_Append( the_chain, the_node );
20256d8: 92 10 00 1d mov %i5, %o1
20256dc: 7f ff a2 bc call 200e1cc <_Chain_Append>
20256e0: 90 02 00 1b add %o0, %i3, %o0
/*
* other fields of fat-file descriptor will be initialized on upper
* level
*/
return RC_OK;
20256e4: 81 c7 e0 08 ret
20256e8: 91 e8 20 00 restore %g0, 0, %o0
uint32_t key2,
fat_file_fd_t **ret
)
{
uint32_t mod = (key1) % FAT_HASH_MODULE;
rtems_chain_node *the_node = rtems_chain_first(hash + mod);
20256ec: a0 00 40 1b add %g1, %i3, %l0
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
20256f0: fa 00 40 1b ld [ %g1 + %i3 ], %i5
RTEMS_INLINE_ROUTINE bool _Chain_Is_tail(
const Chain_Control *the_chain,
const Chain_Node *the_node
)
{
return (the_node == _Chain_Immutable_tail( the_chain ));
20256f4: 10 bf ff ce b 202562c <fat_file_open+0xa8>
20256f8: a0 04 20 04 add %l0, 4, %l0
02025710 <fat_file_read>:
fat_file_fd_t *fat_fd,
uint32_t start,
uint32_t count,
uint8_t *buf
)
{
2025710: 9d e3 bf 98 save %sp, -104, %sp
int rc = RC_OK;
ssize_t ret = 0;
uint32_t cmpltd = 0;
uint32_t cur_cln = 0;
2025714: c0 27 bf fc clr [ %fp + -4 ]
fat_file_fd_t *fat_fd,
uint32_t start,
uint32_t count,
uint8_t *buf
)
{
2025718: ba 10 00 18 mov %i0, %i5
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)
202571c: 80 a6 e0 00 cmp %i3, 0
2025720: 02 80 00 68 be 20258c0 <fat_file_read+0x1b0> <== NEVER TAKEN
2025724: 90 10 20 00 clr %o0
/*
* >= because start is offset and computed from 0 and file_size
* computed from 1
*/
if ( start >= fat_fd->fat_file_size )
2025728: c2 06 60 18 ld [ %i1 + 0x18 ], %g1
202572c: 80 a6 80 01 cmp %i2, %g1
2025730: 1a 80 00 64 bcc 20258c0 <fat_file_read+0x1b0>
2025734: 80 a6 c0 01 cmp %i3, %g1
return FAT_EOF;
if ((count > fat_fd->fat_file_size) ||
2025738: 38 80 00 07 bgu,a 2025754 <fat_file_read+0x44> <== NEVER TAKEN
202573c: b6 20 40 1a sub %g1, %i2, %i3 <== NOT EXECUTED
(start > fat_fd->fat_file_size - count))
2025740: 84 20 40 1b sub %g1, %i3, %g2
* computed from 1
*/
if ( start >= fat_fd->fat_file_size )
return FAT_EOF;
if ((count > fat_fd->fat_file_size) ||
2025744: 80 a6 80 02 cmp %i2, %g2
2025748: 28 80 00 04 bleu,a 2025758 <fat_file_read+0x48>
202574c: c2 06 60 20 ld [ %i1 + 0x20 ], %g1
(start > fat_fd->fat_file_size - count))
count = fat_fd->fat_file_size - start;
2025750: b6 20 40 1a sub %g1, %i2, %i3
if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&
2025754: c2 06 60 20 ld [ %i1 + 0x20 ], %g1
2025758: 80 a0 60 01 cmp %g1, 1
202575c: 32 80 00 1c bne,a 20257cc <fat_file_read+0xbc>
2025760: e4 0f 60 08 ldub [ %i5 + 8 ], %l2
2025764: c2 06 60 24 ld [ %i1 + 0x24 ], %g1
2025768: 80 a0 60 00 cmp %g1, 0
202576c: 32 80 00 18 bne,a 20257cc <fat_file_read+0xbc> <== NEVER TAKEN
2025770: e4 0f 60 08 ldub [ %i5 + 8 ], %l2 <== NOT EXECUTED
(fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))
2025774: c2 0f 60 0a ldub [ %i5 + 0xa ], %g1
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)) &&
2025778: 80 88 60 03 btst 3, %g1
202577c: 22 80 00 14 be,a 20257cc <fat_file_read+0xbc> <== NEVER TAKEN
2025780: e4 0f 60 08 ldub [ %i5 + 8 ], %l2 <== NOT EXECUTED
(fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))
{
sec = fat_cluster_num_to_sector_num(fs_info, fat_fd->cln);
2025784: d2 06 60 1c ld [ %i1 + 0x1c ], %o1
2025788: 7f ff ff 3a call 2025470 <fat_cluster_num_to_sector_num>
202578c: 90 10 00 1d mov %i5, %o0
sec += (start >> fs_info->vol.sec_log2);
2025790: d2 0f 60 02 ldub [ %i5 + 2 ], %o1
byte = start & (fs_info->vol.bps - 1);
2025794: d4 17 40 00 lduh [ %i5 ], %o2
if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&
(fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))
{
sec = fat_cluster_num_to_sector_num(fs_info, fat_fd->cln);
sec += (start >> fs_info->vol.sec_log2);
2025798: 93 36 80 09 srl %i2, %o1, %o1
byte = start & (fs_info->vol.bps - 1);
202579c: 94 02 bf ff add %o2, -1, %o2
if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&
(fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))
{
sec = fat_cluster_num_to_sector_num(fs_info, fat_fd->cln);
sec += (start >> fs_info->vol.sec_log2);
20257a0: 92 02 00 09 add %o0, %o1, %o1
byte = start & (fs_info->vol.bps - 1);
ret = _fat_block_read(fs_info, sec, byte, count, buf);
20257a4: 94 0e 80 0a and %i2, %o2, %o2
20257a8: 90 10 00 1d mov %i5, %o0
20257ac: 96 10 00 1b mov %i3, %o3
20257b0: 40 00 03 28 call 2026450 <_fat_block_read>
20257b4: 98 10 00 1c mov %i4, %o4
if ( ret < 0 )
20257b8: 80 a2 20 00 cmp %o0, 0
20257bc: 16 80 00 41 bge 20258c0 <fat_file_read+0x1b0> <== ALWAYS TAKEN
20257c0: 01 00 00 00 nop
sec += (ofs >> fs_info->vol.sec_log2);
byte = ofs & (fs_info->vol.bps - 1);
ret = _fat_block_read(fs_info, sec, byte, c, buf + cmpltd);
if ( ret < 0 )
return -1;
20257c4: 10 80 00 3f b 20258c0 <fat_file_read+0x1b0> <== NOT EXECUTED
20257c8: 90 10 3f ff mov -1, %o0 ! ffffffff <RAM_END+0xfdbfffff> <== NOT EXECUTED
return ret;
}
cl_start = start >> fs_info->vol.bpc_log2;
save_ofs = ofs = start & (fs_info->vol.bpc - 1);
20257cc: f0 17 60 06 lduh [ %i5 + 6 ], %i0
return -1;
return ret;
}
cl_start = start >> fs_info->vol.bpc_log2;
20257d0: a5 36 80 12 srl %i2, %l2, %l2
save_ofs = ofs = start & (fs_info->vol.bpc - 1);
rc = fat_file_lseek(fs_info, fat_fd, cl_start, &cur_cln);
20257d4: a6 07 bf fc add %fp, -4, %l3
20257d8: 90 10 00 1d mov %i5, %o0
20257dc: 92 10 00 19 mov %i1, %o1
20257e0: 94 10 00 12 mov %l2, %o2
20257e4: 7f ff ff 42 call 20254ec <fat_file_lseek>
20257e8: 96 10 00 13 mov %l3, %o3
if (rc != RC_OK)
20257ec: 90 92 60 00 orcc %o1, 0, %o0
20257f0: 12 80 00 34 bne 20258c0 <fat_file_read+0x1b0> <== NEVER TAKEN
20257f4: a0 10 20 00 clr %l0
return ret;
}
cl_start = start >> fs_info->vol.bpc_log2;
save_ofs = ofs = start & (fs_info->vol.bpc - 1);
20257f8: b1 2e 20 10 sll %i0, 0x10, %i0
20257fc: b1 36 20 10 srl %i0, 0x10, %i0
2025800: b0 06 3f ff add %i0, -1, %i0
2025804: b4 0e 80 18 and %i2, %i0, %i2
2025808: b0 10 20 00 clr %i0
202580c: 10 80 00 20 b 202588c <fat_file_read+0x17c>
2025810: a2 10 00 1a mov %i2, %l1
if (rc != RC_OK)
return rc;
while (count > 0)
{
c = MIN(count, (fs_info->vol.bpc - ofs));
2025814: a0 24 00 11 sub %l0, %l1, %l0
2025818: 80 a4 00 1b cmp %l0, %i3
202581c: 38 80 00 02 bgu,a 2025824 <fat_file_read+0x114>
2025820: a0 10 00 1b mov %i3, %l0
sec = fat_cluster_num_to_sector_num(fs_info, cur_cln);
2025824: d2 07 bf fc ld [ %fp + -4 ], %o1
2025828: 7f ff ff 12 call 2025470 <fat_cluster_num_to_sector_num>
202582c: 90 10 00 1d mov %i5, %o0
sec += (ofs >> fs_info->vol.sec_log2);
2025830: d2 0f 60 02 ldub [ %i5 + 2 ], %o1
byte = ofs & (fs_info->vol.bps - 1);
2025834: d4 17 40 00 lduh [ %i5 ], %o2
while (count > 0)
{
c = MIN(count, (fs_info->vol.bpc - ofs));
sec = fat_cluster_num_to_sector_num(fs_info, cur_cln);
sec += (ofs >> fs_info->vol.sec_log2);
2025838: 93 34 40 09 srl %l1, %o1, %o1
byte = ofs & (fs_info->vol.bps - 1);
202583c: 94 02 bf ff add %o2, -1, %o2
while (count > 0)
{
c = MIN(count, (fs_info->vol.bpc - ofs));
sec = fat_cluster_num_to_sector_num(fs_info, cur_cln);
sec += (ofs >> fs_info->vol.sec_log2);
2025840: 92 02 00 09 add %o0, %o1, %o1
byte = ofs & (fs_info->vol.bps - 1);
ret = _fat_block_read(fs_info, sec, byte, c, buf + cmpltd);
2025844: 94 0c 40 0a and %l1, %o2, %o2
2025848: 90 10 00 1d mov %i5, %o0
202584c: 96 10 00 10 mov %l0, %o3
2025850: 40 00 03 00 call 2026450 <_fat_block_read>
2025854: 98 07 00 18 add %i4, %i0, %o4
if ( ret < 0 )
2025858: 80 a2 20 00 cmp %o0, 0
202585c: 06 80 00 18 bl 20258bc <fat_file_read+0x1ac> <== NEVER TAKEN
2025860: b6 26 c0 10 sub %i3, %l0, %i3
return -1;
count -= c;
cmpltd += c;
2025864: b0 06 00 10 add %i0, %l0, %i0
save_cln = cur_cln;
2025868: e0 07 bf fc ld [ %fp + -4 ], %l0
rc = fat_get_fat_cluster(fs_info, cur_cln, &cur_cln);
202586c: 90 10 00 1d mov %i5, %o0
2025870: 92 10 00 10 mov %l0, %o1
2025874: 94 10 00 13 mov %l3, %o2
2025878: 40 00 60 d2 call 203dbc0 <fat_get_fat_cluster>
202587c: a2 10 20 00 clr %l1
if ( rc != RC_OK )
2025880: 80 a2 20 00 cmp %o0, 0
2025884: 12 80 00 0f bne 20258c0 <fat_file_read+0x1b0> <== NEVER TAKEN
2025888: 01 00 00 00 nop
rc = fat_file_lseek(fs_info, fat_fd, cl_start, &cur_cln);
if (rc != RC_OK)
return rc;
while (count > 0)
202588c: 80 a6 e0 00 cmp %i3, 0
2025890: 32 bf ff e1 bne,a 2025814 <fat_file_read+0x104>
2025894: e0 17 60 06 lduh [ %i5 + 6 ], %l0
}
/* 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);
2025898: c2 0f 60 08 ldub [ %i5 + 8 ], %g1
202589c: b4 06 bf ff add %i2, -1, %i2
fat_fd->map.disk_cln = save_cln;
20258a0: e0 26 60 38 st %l0, [ %i1 + 0x38 ]
}
/* 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);
20258a4: b4 06 80 18 add %i2, %i0, %i2
fat_fd->map.disk_cln = save_cln;
return cmpltd;
20258a8: 90 10 00 18 mov %i0, %o0
}
/* 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);
20258ac: b5 36 80 01 srl %i2, %g1, %i2
ofs = 0;
}
/* update cache */
/* XXX: check this - I'm not sure :( */
fat_fd->map.file_cln = cl_start +
20258b0: a4 06 80 12 add %i2, %l2, %l2
20258b4: 10 80 00 03 b 20258c0 <fat_file_read+0x1b0>
20258b8: e4 26 60 34 st %l2, [ %i1 + 0x34 ]
sec += (ofs >> fs_info->vol.sec_log2);
byte = ofs & (fs_info->vol.bps - 1);
ret = _fat_block_read(fs_info, sec, byte, c, buf + cmpltd);
if ( ret < 0 )
return -1;
20258bc: 90 10 3f ff mov -1, %o0 <== 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;
}
20258c0: 81 c7 e0 08 ret
20258c4: 91 e8 00 08 restore %g0, %o0, %o0
02026020 <fat_file_size>:
int
fat_file_size(
fat_fs_info_t *fs_info,
fat_file_fd_t *fat_fd
)
{
2026020: 9d e3 bf 98 save %sp, -104, %sp
int rc = RC_OK;
uint32_t cur_cln = fat_fd->cln;
2026024: c2 06 60 1c ld [ %i1 + 0x1c ], %g1
2026028: c2 27 bf fc st %g1, [ %fp + -4 ]
uint32_t save_cln = 0;
/* Have we requested root dir size for FAT12/16? */
if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&
202602c: c2 06 60 20 ld [ %i1 + 0x20 ], %g1
2026030: 80 a0 60 01 cmp %g1, 1
2026034: 12 80 00 0d bne 2026068 <fat_file_size+0x48> <== ALWAYS TAKEN
2026038: ba 10 00 18 mov %i0, %i5
202603c: c2 06 60 24 ld [ %i1 + 0x24 ], %g1 <== NOT EXECUTED
2026040: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
2026044: 32 80 00 0a bne,a 202606c <fat_file_size+0x4c> <== NOT EXECUTED
2026048: c0 26 60 18 clr [ %i1 + 0x18 ] <== NOT EXECUTED
(fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))
202604c: c2 0e 20 0a ldub [ %i0 + 0xa ], %g1 <== NOT EXECUTED
int rc = RC_OK;
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)) &&
2026050: 80 88 60 03 btst 3, %g1 <== NOT EXECUTED
2026054: 22 80 00 06 be,a 202606c <fat_file_size+0x4c> <== NOT EXECUTED
2026058: c0 26 60 18 clr [ %i1 + 0x18 ] <== NOT EXECUTED
(fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))
{
fat_fd->fat_file_size = fs_info->vol.rdir_size;
202605c: c2 06 20 28 ld [ %i0 + 0x28 ], %g1 <== NOT EXECUTED
2026060: 10 80 00 18 b 20260c0 <fat_file_size+0xa0> <== NOT EXECUTED
2026064: c2 26 60 18 st %g1, [ %i1 + 0x18 ] <== NOT EXECUTED
return rc;
}
fat_fd->fat_file_size = 0;
2026068: c0 26 60 18 clr [ %i1 + 0x18 ]
while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)
202606c: 10 80 00 0d b 20260a0 <fat_file_size+0x80>
2026070: 82 10 20 00 clr %g1
{
save_cln = cur_cln;
rc = fat_get_fat_cluster(fs_info, cur_cln, &cur_cln);
2026074: 92 10 00 1c mov %i4, %o1
2026078: 40 00 5e d2 call 203dbc0 <fat_get_fat_cluster>
202607c: 94 07 bf fc add %fp, -4, %o2
if ( rc != RC_OK )
2026080: b0 92 20 00 orcc %o0, 0, %i0
2026084: 12 80 00 10 bne 20260c4 <fat_file_size+0xa4> <== NEVER TAKEN
2026088: 01 00 00 00 nop
return rc;
fat_fd->fat_file_size += fs_info->vol.bpc;
202608c: c2 17 60 06 lduh [ %i5 + 6 ], %g1
2026090: c4 06 60 18 ld [ %i1 + 0x18 ], %g2
2026094: 82 00 80 01 add %g2, %g1, %g1
2026098: c2 26 60 18 st %g1, [ %i1 + 0x18 ]
fat_fd->fat_file_size = 0;
while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)
{
save_cln = cur_cln;
202609c: 82 10 00 1c mov %i4, %g1
return rc;
}
fat_fd->fat_file_size = 0;
while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)
20260a0: f8 07 bf fc ld [ %fp + -4 ], %i4
20260a4: c6 07 60 0c ld [ %i5 + 0xc ], %g3
20260a8: c4 07 60 10 ld [ %i5 + 0x10 ], %g2
20260ac: 86 0f 00 03 and %i4, %g3, %g3
20260b0: 80 a0 c0 02 cmp %g3, %g2
20260b4: 0a bf ff f0 bcs 2026074 <fat_file_size+0x54>
20260b8: 90 10 00 1d mov %i5, %o0
if ( rc != RC_OK )
return rc;
fat_fd->fat_file_size += fs_info->vol.bpc;
}
fat_fd->map.last_cln = save_cln;
20260bc: c2 26 60 3c st %g1, [ %i1 + 0x3c ]
20260c0: b0 10 20 00 clr %i0
return rc;
}
20260c4: 81 c7 e0 08 ret
20260c8: 81 e8 00 00 restore
020258c8 <fat_file_truncate>:
fat_file_truncate(
fat_fs_info_t *fs_info,
fat_file_fd_t *fat_fd,
uint32_t new_length
)
{
20258c8: 9d e3 bf 98 save %sp, -104, %sp
int rc = RC_OK;
uint32_t cur_cln = 0;
uint32_t cl_start = 0;
uint32_t new_last_cln = FAT_UNDEFINED_VALUE;
20258cc: 82 10 3f ff mov -1, %g1
20258d0: c2 27 bf fc st %g1, [ %fp + -4 ]
if ( new_length >= fat_fd->fat_file_size )
20258d4: c2 06 60 18 ld [ %i1 + 0x18 ], %g1
20258d8: 80 a6 80 01 cmp %i2, %g1
20258dc: 0a 80 00 04 bcs 20258ec <fat_file_truncate+0x24>
20258e0: c0 27 bf f8 clr [ %fp + -8 ]
return rc;
20258e4: 10 80 00 3b b 20259d0 <fat_file_truncate+0x108>
20258e8: 92 10 20 00 clr %o1
assert(fat_fd->fat_file_size);
20258ec: 80 a0 60 00 cmp %g1, 0
20258f0: 32 80 00 0a bne,a 2025918 <fat_file_truncate+0x50> <== ALWAYS TAKEN
20258f4: c4 0e 20 08 ldub [ %i0 + 8 ], %g2
20258f8: 11 00 81 90 sethi %hi(0x2064000), %o0 <== NOT EXECUTED
20258fc: 15 00 81 90 sethi %hi(0x2064000), %o2 <== NOT EXECUTED
2025900: 17 00 81 90 sethi %hi(0x2064000), %o3 <== NOT EXECUTED
2025904: 90 12 20 80 or %o0, 0x80, %o0 <== NOT EXECUTED
2025908: 92 10 22 7d mov 0x27d, %o1 <== NOT EXECUTED
202590c: 94 12 a0 e0 or %o2, 0xe0, %o2 <== NOT EXECUTED
2025910: 40 00 08 09 call 2027934 <__assert_func> <== NOT EXECUTED
2025914: 96 12 e0 c8 or %o3, 0xc8, %o3 <== NOT EXECUTED
cl_start = (new_length + fs_info->vol.bpc - 1) >> fs_info->vol.bpc_log2;
2025918: c6 16 20 06 lduh [ %i0 + 6 ], %g3
202591c: 86 00 ff ff add %g3, -1, %g3
2025920: b4 00 c0 1a add %g3, %i2, %i2
2025924: b5 36 80 02 srl %i2, %g2, %i2
if ((cl_start << fs_info->vol.bpc_log2) >= fat_fd->fat_file_size)
2025928: 85 2e 80 02 sll %i2, %g2, %g2
202592c: 80 a0 80 01 cmp %g2, %g1
2025930: 1a bf ff ed bcc 20258e4 <fat_file_truncate+0x1c>
2025934: 80 a6 a0 00 cmp %i2, 0
return RC_OK;
if (cl_start != 0)
2025938: 12 80 00 0b bne 2025964 <fat_file_truncate+0x9c>
202593c: 90 10 00 18 mov %i0, %o0
if (rc != RC_OK)
return rc;
}
rc = fat_file_lseek(fs_info, fat_fd, cl_start, &cur_cln);
2025940: 92 10 00 19 mov %i1, %o1
2025944: 94 10 00 1a mov %i2, %o2
2025948: 7f ff fe e9 call 20254ec <fat_file_lseek>
202594c: 96 07 bf f8 add %fp, -8, %o3
if (rc != RC_OK)
2025950: 80 a2 60 00 cmp %o1, 0
2025954: 32 80 00 20 bne,a 20259d4 <fat_file_truncate+0x10c> <== NEVER TAKEN
2025958: b0 10 00 09 mov %o1, %i0 <== NOT EXECUTED
return rc;
rc = fat_free_fat_clusters_chain(fs_info, cur_cln);
202595c: 10 80 00 0b b 2025988 <fat_file_truncate+0xc0>
2025960: d2 07 bf f8 ld [ %fp + -8 ], %o1
if ((cl_start << fs_info->vol.bpc_log2) >= fat_fd->fat_file_size)
return RC_OK;
if (cl_start != 0)
{
rc = fat_file_lseek(fs_info, fat_fd, cl_start - 1, &new_last_cln);
2025964: 92 10 00 19 mov %i1, %o1
2025968: 94 06 bf ff add %i2, -1, %o2
202596c: 7f ff fe e0 call 20254ec <fat_file_lseek>
2025970: 96 07 bf fc add %fp, -4, %o3
if (rc != RC_OK)
2025974: 80 a2 60 00 cmp %o1, 0
2025978: 02 bf ff f2 be 2025940 <fat_file_truncate+0x78> <== ALWAYS TAKEN
202597c: 90 10 00 18 mov %i0, %o0
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;
}
2025980: 81 c7 e0 08 ret <== NOT EXECUTED
2025984: 91 e8 00 09 restore %g0, %o1, %o0 <== NOT EXECUTED
rc = fat_file_lseek(fs_info, fat_fd, cl_start, &cur_cln);
if (rc != RC_OK)
return rc;
rc = fat_free_fat_clusters_chain(fs_info, cur_cln);
2025988: 40 00 61 b4 call 203e058 <fat_free_fat_clusters_chain>
202598c: 90 10 00 18 mov %i0, %o0
if (rc != RC_OK)
2025990: 92 92 20 00 orcc %o0, 0, %o1
2025994: 12 80 00 0f bne 20259d0 <fat_file_truncate+0x108> <== NEVER TAKEN
2025998: 80 a6 a0 00 cmp %i2, 0
return rc;
if (cl_start != 0)
202599c: 02 80 00 0d be 20259d0 <fat_file_truncate+0x108>
20259a0: 92 10 20 00 clr %o1
{
rc = fat_set_fat_cluster(fs_info, new_last_cln, FAT_GENFAT_EOC);
20259a4: d2 07 bf fc ld [ %fp + -4 ], %o1
20259a8: 90 10 00 18 mov %i0, %o0
20259ac: 40 00 60 fc call 203dd9c <fat_set_fat_cluster>
20259b0: 94 10 3f ff mov -1, %o2
if ( rc != RC_OK )
20259b4: 92 92 20 00 orcc %o0, 0, %o1
20259b8: 12 80 00 06 bne 20259d0 <fat_file_truncate+0x108> <== NEVER TAKEN
20259bc: c2 07 bf fc ld [ %fp + -4 ], %g1
return rc;
fat_fd->map.file_cln = cl_start - 1;
20259c0: b4 06 bf ff add %i2, -1, %i2
fat_fd->map.disk_cln = new_last_cln;
20259c4: c2 26 60 38 st %g1, [ %i1 + 0x38 ]
if (cl_start != 0)
{
rc = fat_set_fat_cluster(fs_info, new_last_cln, FAT_GENFAT_EOC);
if ( rc != RC_OK )
return rc;
fat_fd->map.file_cln = cl_start - 1;
20259c8: f4 26 60 34 st %i2, [ %i1 + 0x34 ]
fat_fd->map.disk_cln = new_last_cln;
fat_fd->map.last_cln = new_last_cln;
20259cc: c2 26 60 3c st %g1, [ %i1 + 0x3c ]
}
return RC_OK;
}
20259d0: b0 10 00 09 mov %o1, %i0
20259d4: 81 c7 e0 08 ret
20259d8: 81 e8 00 00 restore
02025dcc <fat_file_write>:
fat_file_fd_t *fat_fd,
uint32_t start,
uint32_t count,
const uint8_t *buf
)
{
2025dcc: 9d e3 bf 98 save %sp, -104, %sp
int rc = 0;
ssize_t ret = 0;
uint32_t cmpltd = 0;
uint32_t cur_cln = 0;
2025dd0: c0 27 bf f8 clr [ %fp + -8 ]
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;
2025dd4: c0 27 bf fc clr [ %fp + -4 ]
fat_file_fd_t *fat_fd,
uint32_t start,
uint32_t count,
const uint8_t *buf
)
{
2025dd8: ba 10 00 18 mov %i0, %i5
uint32_t ofs = 0;
uint32_t save_ofs;
uint32_t sec = 0;
uint32_t byte = 0;
uint32_t c = 0;
bool zero_fill = start > fat_fd->fat_file_size;
2025ddc: c2 06 60 18 ld [ %i1 + 0x18 ], %g1
if ( count == 0 )
2025de0: 80 a6 e0 00 cmp %i3, 0
2025de4: 02 80 00 79 be 2025fc8 <fat_file_write+0x1fc> <== NEVER TAKEN
2025de8: 90 10 20 00 clr %o0
return cmpltd;
if (start >= fat_fd->size_limit)
2025dec: f0 06 60 14 ld [ %i1 + 0x14 ], %i0
2025df0: 80 a6 80 18 cmp %i2, %i0
2025df4: 2a 80 00 07 bcs,a 2025e10 <fat_file_write+0x44> <== ALWAYS TAKEN
2025df8: b0 26 00 1a sub %i0, %i2, %i0
rtems_set_errno_and_return_minus_one(EFBIG);
2025dfc: 40 00 70 fc call 20421ec <__errno> <== NOT EXECUTED
2025e00: 01 00 00 00 nop <== NOT EXECUTED
2025e04: 82 10 20 1b mov 0x1b, %g1 ! 1b <PROM_START+0x1b> <== NOT EXECUTED
2025e08: 10 80 00 6f b 2025fc4 <fat_file_write+0x1f8> <== NOT EXECUTED
2025e0c: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
2025e10: 80 a6 00 1b cmp %i0, %i3
2025e14: 38 80 00 02 bgu,a 2025e1c <fat_file_write+0x50> <== ALWAYS TAKEN
2025e18: b0 10 00 1b mov %i3, %i0
uint32_t ofs = 0;
uint32_t save_ofs;
uint32_t sec = 0;
uint32_t byte = 0;
uint32_t c = 0;
bool zero_fill = start > fat_fd->fat_file_size;
2025e1c: 80 a0 40 1a cmp %g1, %i2
rtems_set_errno_and_return_minus_one(EFBIG);
if (count > fat_fd->size_limit - start)
count = fat_fd->size_limit - start;
rc = fat_file_extend(fs_info, fat_fd, zero_fill, start + count, &c);
2025e20: b6 06 00 1a add %i0, %i2, %i3
2025e24: 94 40 20 00 addx %g0, 0, %o2
2025e28: 90 10 00 1d mov %i5, %o0
2025e2c: 92 10 00 19 mov %i1, %o1
2025e30: 96 10 00 1b mov %i3, %o3
2025e34: 7f ff ff 4b call 2025b60 <fat_file_extend>
2025e38: 98 07 bf fc add %fp, -4, %o4
if (rc != RC_OK)
2025e3c: 80 a2 20 00 cmp %o0, 0
2025e40: 12 80 00 62 bne 2025fc8 <fat_file_write+0x1fc> <== NEVER TAKEN
2025e44: c2 07 bf fc ld [ %fp + -4 ], %g1
/*
* check whether there was enough room on device to locate
* file of 'start + count' bytes
*/
if (c != (start + count))
2025e48: 80 a0 40 1b cmp %g1, %i3
2025e4c: 32 80 00 02 bne,a 2025e54 <fat_file_write+0x88> <== NEVER TAKEN
2025e50: b0 20 40 1a sub %g1, %i2, %i0 <== NOT EXECUTED
count = c - start;
if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&
2025e54: c2 06 60 20 ld [ %i1 + 0x20 ], %g1
2025e58: 80 a0 60 01 cmp %g1, 1
2025e5c: 32 80 00 1c bne,a 2025ecc <fat_file_write+0x100>
2025e60: e4 0f 60 08 ldub [ %i5 + 8 ], %l2
2025e64: c2 06 60 24 ld [ %i1 + 0x24 ], %g1
2025e68: 80 a0 60 00 cmp %g1, 0
2025e6c: 32 80 00 18 bne,a 2025ecc <fat_file_write+0x100> <== NEVER TAKEN
2025e70: e4 0f 60 08 ldub [ %i5 + 8 ], %l2 <== NOT EXECUTED
(fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))
2025e74: c2 0f 60 0a ldub [ %i5 + 0xa ], %g1
* file of 'start + count' bytes
*/
if (c != (start + count))
count = c - start;
if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&
2025e78: 80 88 60 03 btst 3, %g1
2025e7c: 22 80 00 14 be,a 2025ecc <fat_file_write+0x100> <== NEVER TAKEN
2025e80: e4 0f 60 08 ldub [ %i5 + 8 ], %l2 <== NOT EXECUTED
(fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))
{
sec = fat_cluster_num_to_sector_num(fs_info, fat_fd->cln);
2025e84: d2 06 60 1c ld [ %i1 + 0x1c ], %o1
2025e88: 7f ff fd 7a call 2025470 <fat_cluster_num_to_sector_num>
2025e8c: 90 10 00 1d mov %i5, %o0
sec += (start >> fs_info->vol.sec_log2);
2025e90: d2 0f 60 02 ldub [ %i5 + 2 ], %o1
byte = start & (fs_info->vol.bps - 1);
2025e94: d4 17 40 00 lduh [ %i5 ], %o2
if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&
(fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))
{
sec = fat_cluster_num_to_sector_num(fs_info, fat_fd->cln);
sec += (start >> fs_info->vol.sec_log2);
2025e98: 93 36 80 09 srl %i2, %o1, %o1
byte = start & (fs_info->vol.bps - 1);
2025e9c: 94 02 bf ff add %o2, -1, %o2
if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&
(fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))
{
sec = fat_cluster_num_to_sector_num(fs_info, fat_fd->cln);
sec += (start >> fs_info->vol.sec_log2);
2025ea0: 92 02 00 09 add %o0, %o1, %o1
byte = start & (fs_info->vol.bps - 1);
ret = _fat_block_write(fs_info, sec, byte, count, buf);
2025ea4: 94 0e 80 0a and %i2, %o2, %o2
2025ea8: 90 10 00 1d mov %i5, %o0
2025eac: 96 10 00 18 mov %i0, %o3
2025eb0: 40 00 01 8a call 20264d8 <_fat_block_write>
2025eb4: 98 10 00 1c mov %i4, %o4
if ( ret < 0 )
2025eb8: 80 a2 20 00 cmp %o0, 0
2025ebc: 16 80 00 43 bge 2025fc8 <fat_file_write+0x1fc> <== ALWAYS TAKEN
2025ec0: 01 00 00 00 nop
sec += (ofs >> fs_info->vol.sec_log2);
byte = ofs & (fs_info->vol.bps - 1);
ret = _fat_block_write(fs_info, sec, byte, c, buf + cmpltd);
if ( ret < 0 )
return -1;
2025ec4: 10 80 00 41 b 2025fc8 <fat_file_write+0x1fc> <== NOT EXECUTED
2025ec8: 90 10 3f ff mov -1, %o0 ! ffffffff <RAM_END+0xfdbfffff> <== NOT EXECUTED
return ret;
}
cl_start = start >> fs_info->vol.bpc_log2;
save_ofs = ofs = start & (fs_info->vol.bpc - 1);
2025ecc: f6 17 60 06 lduh [ %i5 + 6 ], %i3
return -1;
return ret;
}
cl_start = start >> fs_info->vol.bpc_log2;
2025ed0: a5 36 80 12 srl %i2, %l2, %l2
save_ofs = ofs = start & (fs_info->vol.bpc - 1);
rc = fat_file_lseek(fs_info, fat_fd, cl_start, &cur_cln);
2025ed4: a6 07 bf f8 add %fp, -8, %l3
2025ed8: 90 10 00 1d mov %i5, %o0
2025edc: 92 10 00 19 mov %i1, %o1
2025ee0: 94 10 00 12 mov %l2, %o2
2025ee4: 7f ff fd 82 call 20254ec <fat_file_lseek>
2025ee8: 96 10 00 13 mov %l3, %o3
if (rc != RC_OK)
2025eec: 90 92 60 00 orcc %o1, 0, %o0
2025ef0: 12 80 00 36 bne 2025fc8 <fat_file_write+0x1fc> <== NEVER TAKEN
2025ef4: b7 2e e0 10 sll %i3, 0x10, %i3
return ret;
}
cl_start = start >> fs_info->vol.bpc_log2;
save_ofs = ofs = start & (fs_info->vol.bpc - 1);
2025ef8: b7 36 e0 10 srl %i3, 0x10, %i3
2025efc: b6 06 ff ff add %i3, -1, %i3
2025f00: a0 10 20 00 clr %l0
2025f04: b4 0e 80 1b and %i2, %i3, %i2
2025f08: b6 10 20 00 clr %i3
2025f0c: 10 80 00 22 b 2025f94 <fat_file_write+0x1c8>
2025f10: a2 10 00 1a mov %i2, %l1
if (rc != RC_OK)
return rc;
while (count > 0)
{
c = MIN(count, (fs_info->vol.bpc - ofs));
2025f14: a0 24 00 11 sub %l0, %l1, %l0
2025f18: 80 a4 00 18 cmp %l0, %i0
2025f1c: 38 80 00 02 bgu,a 2025f24 <fat_file_write+0x158>
2025f20: a0 10 00 18 mov %i0, %l0
sec = fat_cluster_num_to_sector_num(fs_info, cur_cln);
2025f24: d2 07 bf f8 ld [ %fp + -8 ], %o1
if (rc != RC_OK)
return rc;
while (count > 0)
{
c = MIN(count, (fs_info->vol.bpc - ofs));
2025f28: e0 27 bf fc st %l0, [ %fp + -4 ]
sec = fat_cluster_num_to_sector_num(fs_info, cur_cln);
2025f2c: 7f ff fd 51 call 2025470 <fat_cluster_num_to_sector_num>
2025f30: 90 10 00 1d mov %i5, %o0
sec += (ofs >> fs_info->vol.sec_log2);
2025f34: d2 0f 60 02 ldub [ %i5 + 2 ], %o1
byte = ofs & (fs_info->vol.bps - 1);
2025f38: d4 17 40 00 lduh [ %i5 ], %o2
while (count > 0)
{
c = MIN(count, (fs_info->vol.bpc - ofs));
sec = fat_cluster_num_to_sector_num(fs_info, cur_cln);
sec += (ofs >> fs_info->vol.sec_log2);
2025f3c: 93 34 40 09 srl %l1, %o1, %o1
byte = ofs & (fs_info->vol.bps - 1);
2025f40: 94 02 bf ff add %o2, -1, %o2
while (count > 0)
{
c = MIN(count, (fs_info->vol.bpc - ofs));
sec = fat_cluster_num_to_sector_num(fs_info, cur_cln);
sec += (ofs >> fs_info->vol.sec_log2);
2025f44: 92 02 00 09 add %o0, %o1, %o1
byte = ofs & (fs_info->vol.bps - 1);
ret = _fat_block_write(fs_info, sec, byte, c, buf + cmpltd);
2025f48: 94 0c 40 0a and %l1, %o2, %o2
2025f4c: 90 10 00 1d mov %i5, %o0
2025f50: 96 10 00 10 mov %l0, %o3
2025f54: 40 00 01 61 call 20264d8 <_fat_block_write>
2025f58: 98 07 00 1b add %i4, %i3, %o4
if ( ret < 0 )
2025f5c: 80 a2 20 00 cmp %o0, 0
2025f60: 06 80 00 19 bl 2025fc4 <fat_file_write+0x1f8> <== NEVER TAKEN
2025f64: c2 07 bf fc ld [ %fp + -4 ], %g1
return -1;
count -= c;
cmpltd += c;
save_cln = cur_cln;
2025f68: e0 07 bf f8 ld [ %fp + -8 ], %l0
ret = _fat_block_write(fs_info, sec, byte, c, buf + cmpltd);
if ( ret < 0 )
return -1;
count -= c;
2025f6c: b0 26 00 01 sub %i0, %g1, %i0
cmpltd += c;
2025f70: b6 06 c0 01 add %i3, %g1, %i3
save_cln = cur_cln;
rc = fat_get_fat_cluster(fs_info, cur_cln, &cur_cln);
2025f74: 90 10 00 1d mov %i5, %o0
2025f78: 92 10 00 10 mov %l0, %o1
2025f7c: 94 10 00 13 mov %l3, %o2
2025f80: 40 00 5f 10 call 203dbc0 <fat_get_fat_cluster>
2025f84: a2 10 20 00 clr %l1
if ( rc != RC_OK )
2025f88: 80 a2 20 00 cmp %o0, 0
2025f8c: 12 80 00 0f bne 2025fc8 <fat_file_write+0x1fc> <== NEVER TAKEN
2025f90: 01 00 00 00 nop
rc = fat_file_lseek(fs_info, fat_fd, cl_start, &cur_cln);
if (rc != RC_OK)
return rc;
while (count > 0)
2025f94: 80 a6 20 00 cmp %i0, 0
2025f98: 32 bf ff df bne,a 2025f14 <fat_file_write+0x148>
2025f9c: e0 17 60 06 lduh [ %i5 + 6 ], %l0
}
/* 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);
2025fa0: c2 0f 60 08 ldub [ %i5 + 8 ], %g1
2025fa4: b4 06 bf ff add %i2, -1, %i2
fat_fd->map.disk_cln = save_cln;
2025fa8: e0 26 60 38 st %l0, [ %i1 + 0x38 ]
}
/* 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);
2025fac: b4 06 80 1b add %i2, %i3, %i2
fat_fd->map.disk_cln = save_cln;
return cmpltd;
2025fb0: 90 10 00 1b mov %i3, %o0
}
/* 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);
2025fb4: b5 36 80 01 srl %i2, %g1, %i2
ofs = 0;
}
/* update cache */
/* XXX: check this - I'm not sure :( */
fat_fd->map.file_cln = cl_start +
2025fb8: a4 06 80 12 add %i2, %l2, %l2
2025fbc: 10 80 00 03 b 2025fc8 <fat_file_write+0x1fc>
2025fc0: e4 26 60 34 st %l2, [ %i1 + 0x34 ]
sec += (ofs >> fs_info->vol.sec_log2);
byte = ofs & (fs_info->vol.bps - 1);
ret = _fat_block_write(fs_info, sec, byte, c, buf + cmpltd);
if ( ret < 0 )
return -1;
2025fc4: 90 10 3f ff mov -1, %o0 <== 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;
}
2025fc8: 81 c7 e0 08 ret
2025fcc: 91 e8 00 08 restore %g0, %o0, %o0
0203e058 <fat_free_fat_clusters_chain>:
int
fat_free_fat_clusters_chain(
fat_fs_info_t *fs_info,
uint32_t chain
)
{
203e058: 9d e3 bf 98 save %sp, -104, %sp
int rc = RC_OK, rc1 = RC_OK;
uint32_t cur_cln = chain;
uint32_t next_cln = 0;
uint32_t freed_cls_cnt = 0;
203e05c: b8 10 20 00 clr %i4
int
fat_free_fat_clusters_chain(
fat_fs_info_t *fs_info,
uint32_t chain
)
{
203e060: ba 10 00 18 mov %i0, %i5
int rc = RC_OK, rc1 = RC_OK;
uint32_t cur_cln = chain;
uint32_t next_cln = 0;
203e064: c0 27 bf fc clr [ %fp + -4 ]
fat_fs_info_t *fs_info,
uint32_t chain
)
{
int rc = RC_OK, rc1 = RC_OK;
uint32_t cur_cln = chain;
203e068: b6 10 00 19 mov %i1, %i3
uint32_t next_cln = 0;
uint32_t freed_cls_cnt = 0;
while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)
203e06c: 10 80 00 19 b 203e0d0 <fat_free_fat_clusters_chain+0x78>
203e070: b4 10 20 00 clr %i2
{
rc = fat_get_fat_cluster(fs_info, cur_cln, &next_cln);
203e074: 92 10 00 1b mov %i3, %o1
203e078: 7f ff fe d2 call 203dbc0 <fat_get_fat_cluster>
203e07c: 94 07 bf fc add %fp, -4, %o2
if ( rc != RC_OK )
203e080: b0 92 20 00 orcc %o0, 0, %i0
203e084: 02 80 00 0b be 203e0b0 <fat_free_fat_clusters_chain+0x58> <== ALWAYS TAKEN
203e088: 90 10 00 1d mov %i5, %o0
{
if(fs_info->vol.free_cls != FAT_UNDEFINED_VALUE)
203e08c: c2 07 60 40 ld [ %i5 + 0x40 ], %g1 <== NOT EXECUTED
203e090: 80 a0 7f ff cmp %g1, -1 <== NOT EXECUTED
203e094: 02 80 00 03 be 203e0a0 <fat_free_fat_clusters_chain+0x48> <== NOT EXECUTED
203e098: b8 07 00 01 add %i4, %g1, %i4 <== NOT EXECUTED
fs_info->vol.free_cls += freed_cls_cnt;
203e09c: f8 27 60 40 st %i4, [ %i5 + 0x40 ] <== NOT EXECUTED
fat_buf_release(fs_info);
203e0a0: 7f ff a0 94 call 20262f0 <fat_buf_release> <== NOT EXECUTED
203e0a4: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
203e0a8: 81 c7 e0 08 ret <== NOT EXECUTED
203e0ac: 81 e8 00 00 restore <== NOT EXECUTED
return rc;
}
rc = fat_set_fat_cluster(fs_info, cur_cln, FAT_GENFAT_FREE);
203e0b0: 92 10 00 1b mov %i3, %o1
203e0b4: 7f ff ff 3a call 203dd9c <fat_set_fat_cluster>
203e0b8: 94 10 20 00 clr %o2
if ( rc != RC_OK )
203e0bc: 80 a2 20 00 cmp %o0, 0
203e0c0: 32 80 00 02 bne,a 203e0c8 <fat_free_fat_clusters_chain+0x70><== NEVER TAKEN
203e0c4: b4 10 00 08 mov %o0, %i2 <== NOT EXECUTED
rc1 = rc;
freed_cls_cnt++;
cur_cln = next_cln;
203e0c8: f6 07 bf fc ld [ %fp + -4 ], %i3
rc = fat_set_fat_cluster(fs_info, cur_cln, FAT_GENFAT_FREE);
if ( rc != RC_OK )
rc1 = rc;
freed_cls_cnt++;
203e0cc: b8 07 20 01 inc %i4
int rc = RC_OK, rc1 = RC_OK;
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)
203e0d0: c4 07 60 0c ld [ %i5 + 0xc ], %g2
203e0d4: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
203e0d8: 84 0e c0 02 and %i3, %g2, %g2
203e0dc: 80 a0 80 01 cmp %g2, %g1
203e0e0: 0a bf ff e5 bcs 203e074 <fat_free_fat_clusters_chain+0x1c>
203e0e4: 90 10 00 1d mov %i5, %o0
freed_cls_cnt++;
cur_cln = next_cln;
}
fs_info->vol.next_cl = chain;
if (fs_info->vol.free_cls != FAT_UNDEFINED_VALUE)
203e0e8: c2 07 60 40 ld [ %i5 + 0x40 ], %g1
203e0ec: 80 a0 7f ff cmp %g1, -1
203e0f0: 02 80 00 05 be 203e104 <fat_free_fat_clusters_chain+0xac> <== ALWAYS TAKEN
203e0f4: f2 27 60 44 st %i1, [ %i5 + 0x44 ]
fs_info->vol.free_cls += freed_cls_cnt;
203e0f8: b8 07 00 01 add %i4, %g1, %i4 <== NOT EXECUTED
203e0fc: f8 27 60 40 st %i4, [ %i5 + 0x40 ] <== NOT EXECUTED
fat_buf_release(fs_info);
203e100: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
203e104: 7f ff a0 7b call 20262f0 <fat_buf_release>
203e108: b0 10 00 1a mov %i2, %i0
if (rc1 != RC_OK)
return rc1;
return RC_OK;
}
203e10c: 81 c7 e0 08 ret
203e110: 81 e8 00 00 restore
02026824 <fat_free_unique_ino>:
fat_free_unique_ino(
fat_fs_info_t *fs_info,
uint32_t ino
)
{
FAT_SET_UNIQ_INO_FREE((ino - fs_info->uino_base), fs_info->uino);
2026824: c2 02 20 74 ld [ %o0 + 0x74 ], %g1 <== NOT EXECUTED
2026828: c4 02 20 68 ld [ %o0 + 0x68 ], %g2 <== NOT EXECUTED
202682c: 86 10 20 01 mov 1, %g3 <== NOT EXECUTED
2026830: 92 22 40 01 sub %o1, %g1, %o1 <== NOT EXECUTED
2026834: 83 32 60 03 srl %o1, 3, %g1 <== NOT EXECUTED
2026838: 92 0a 60 07 and %o1, 7, %o1 <== NOT EXECUTED
202683c: 93 28 c0 09 sll %g3, %o1, %o1 <== NOT EXECUTED
2026840: c6 08 80 01 ldub [ %g2 + %g1 ], %g3 <== NOT EXECUTED
2026844: 92 28 c0 09 andn %g3, %o1, %o1 <== NOT EXECUTED
2026848: 81 c3 e0 08 retl <== NOT EXECUTED
202684c: d2 28 80 01 stb %o1, [ %g2 + %g1 ] <== NOT EXECUTED
0203dbc0 <fat_get_fat_cluster>:
fat_get_fat_cluster(
fat_fs_info_t *fs_info,
uint32_t cln,
uint32_t *ret_val
)
{
203dbc0: 9d e3 bf 98 save %sp, -104, %sp
int rc = RC_OK;
rtems_bdbuf_buffer *block0 = NULL;
203dbc4: c0 27 bf fc clr [ %fp + -4 ]
uint32_t sec = 0;
uint32_t ofs = 0;
/* sanity check */
if ( (cln < 2) || (cln > (fs_info->vol.data_cls + 1)) )
203dbc8: 80 a6 60 01 cmp %i1, 1
203dbcc: 08 80 00 6b bleu 203dd78 <fat_get_fat_cluster+0x1b8> <== NEVER TAKEN
203dbd0: ba 10 00 18 mov %i0, %i5
203dbd4: c2 06 20 34 ld [ %i0 + 0x34 ], %g1
203dbd8: 82 00 60 01 inc %g1
203dbdc: 80 a6 40 01 cmp %i1, %g1
203dbe0: 28 80 00 03 bleu,a 203dbec <fat_get_fat_cluster+0x2c> <== ALWAYS TAKEN
203dbe4: c2 0e 20 0a ldub [ %i0 + 0xa ], %g1
203dbe8: 30 80 00 64 b,a 203dd78 <fat_get_fat_cluster+0x1b8> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
sec = (FAT_FAT_OFFSET(fs_info->vol.type, cln) >> fs_info->vol.sec_log2) +
203dbec: 86 08 60 01 and %g1, 1, %g3
203dbf0: 80 88 e0 ff btst 0xff, %g3
203dbf4: 02 80 00 05 be 203dc08 <fat_get_fat_cluster+0x48> <== NEVER TAKEN
203dbf8: 88 08 60 02 and %g1, 2, %g4
203dbfc: 85 36 60 01 srl %i1, 1, %g2
203dc00: 10 80 00 06 b 203dc18 <fat_get_fat_cluster+0x58>
203dc04: 84 00 80 19 add %g2, %i1, %g2
203dc08: 80 89 20 ff btst 0xff, %g4 <== NOT EXECUTED
203dc0c: 02 80 00 03 be 203dc18 <fat_get_fat_cluster+0x58> <== NOT EXECUTED
203dc10: 85 2e 60 02 sll %i1, 2, %g2 <== NOT EXECUTED
203dc14: 85 2e 60 01 sll %i1, 1, %g2 <== NOT EXECUTED
203dc18: f6 0f 60 02 ldub [ %i5 + 2 ], %i3
203dc1c: c8 07 60 4c ld [ %i5 + 0x4c ], %g4
203dc20: 85 30 80 1b srl %g2, %i3, %g2
fs_info->vol.afat_loc;
ofs = FAT_FAT_OFFSET(fs_info->vol.type, cln) & (fs_info->vol.bps - 1);
203dc24: 80 88 e0 ff btst 0xff, %g3
203dc28: 02 80 00 05 be 203dc3c <fat_get_fat_cluster+0x7c> <== NEVER TAKEN
203dc2c: b6 00 80 04 add %g2, %g4, %i3
203dc30: b9 36 60 01 srl %i1, 1, %i4
203dc34: 10 80 00 07 b 203dc50 <fat_get_fat_cluster+0x90>
203dc38: b8 07 00 19 add %i4, %i1, %i4
203dc3c: 82 08 60 02 and %g1, 2, %g1 <== NOT EXECUTED
203dc40: 80 88 60 ff btst 0xff, %g1 <== NOT EXECUTED
203dc44: 02 80 00 03 be 203dc50 <fat_get_fat_cluster+0x90> <== NOT EXECUTED
203dc48: b9 2e 60 02 sll %i1, 2, %i4 <== NOT EXECUTED
203dc4c: b9 2e 60 01 sll %i1, 1, %i4 <== NOT EXECUTED
203dc50: e0 17 40 00 lduh [ %i5 ], %l0
rc = fat_buf_access(fs_info, sec, FAT_OP_TYPE_READ, &block0);
203dc54: 90 10 00 1d mov %i5, %o0
203dc58: 92 10 00 1b mov %i3, %o1
203dc5c: 94 10 20 01 mov 1, %o2
203dc60: 7f ff a1 27 call 20260fc <fat_buf_access>
203dc64: 96 07 bf fc add %fp, -4, %o3
if (rc != RC_OK)
203dc68: b0 92 20 00 orcc %o0, 0, %i0
203dc6c: 12 80 00 3a bne 203dd54 <fat_get_fat_cluster+0x194> <== NEVER TAKEN
203dc70: 83 2c 20 10 sll %l0, 0x10, %g1
return rc;
switch ( fs_info->vol.type )
203dc74: c4 0f 60 0a ldub [ %i5 + 0xa ], %g2
203dc78: 80 a0 a0 02 cmp %g2, 2
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);
203dc7c: 83 30 60 10 srl %g1, 0x10, %g1
203dc80: 82 00 7f ff add %g1, -1, %g1
rc = fat_buf_access(fs_info, sec, FAT_OP_TYPE_READ, &block0);
if (rc != RC_OK)
return rc;
switch ( fs_info->vol.type )
203dc84: 02 80 00 29 be 203dd28 <fat_get_fat_cluster+0x168> <== NEVER TAKEN
203dc88: 82 0f 00 01 and %i4, %g1, %g1
203dc8c: 80 a0 a0 04 cmp %g2, 4
203dc90: 02 80 00 33 be 203dd5c <fat_get_fat_cluster+0x19c> <== NEVER TAKEN
203dc94: 80 a0 a0 01 cmp %g2, 1
203dc98: 12 80 00 38 bne 203dd78 <fat_get_fat_cluster+0x1b8> <== NEVER TAKEN
203dc9c: c4 07 bf fc ld [ %fp + -4 ], %g2
/*
* we are enforced in complex computations for FAT12 to escape CPU
* align problems for some architectures
*/
*ret_val = (*((uint8_t *)(block0->buffer + ofs)));
if ( ofs == (fs_info->vol.bps - 1) )
203dca0: c8 17 40 00 lduh [ %i5 ], %g4
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)));
203dca4: c6 00 a0 1c ld [ %g2 + 0x1c ], %g3
if ( ofs == (fs_info->vol.bps - 1) )
203dca8: 88 01 3f ff add %g4, -1, %g4
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)));
203dcac: c4 08 c0 01 ldub [ %g3 + %g1 ], %g2
if ( ofs == (fs_info->vol.bps - 1) )
203dcb0: 80 a0 40 04 cmp %g1, %g4
203dcb4: 12 80 00 11 bne 203dcf8 <fat_get_fat_cluster+0x138> <== ALWAYS TAKEN
203dcb8: c4 26 80 00 st %g2, [ %i2 ]
{
rc = fat_buf_access(fs_info, sec + 1, FAT_OP_TYPE_READ,
203dcbc: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
203dcc0: 92 06 e0 01 add %i3, 1, %o1 <== NOT EXECUTED
203dcc4: 94 10 20 01 mov 1, %o2 <== NOT EXECUTED
203dcc8: 7f ff a1 0d call 20260fc <fat_buf_access> <== NOT EXECUTED
203dccc: 96 07 bf fc add %fp, -4, %o3 <== NOT EXECUTED
&block0);
if (rc != RC_OK)
203dcd0: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
203dcd4: 12 80 00 2f bne 203dd90 <fat_get_fat_cluster+0x1d0> <== NOT EXECUTED
203dcd8: c2 07 bf fc ld [ %fp + -4 ], %g1 <== NOT EXECUTED
return rc;
*ret_val |= (*((uint8_t *)(block0->buffer)))<<8;
203dcdc: c4 06 80 00 ld [ %i2 ], %g2 <== NOT EXECUTED
203dce0: c2 00 60 1c ld [ %g1 + 0x1c ], %g1 <== NOT EXECUTED
203dce4: c2 08 40 00 ldub [ %g1 ], %g1 <== NOT EXECUTED
203dce8: 83 28 60 08 sll %g1, 8, %g1 <== NOT EXECUTED
203dcec: 82 10 80 01 or %g2, %g1, %g1 <== NOT EXECUTED
203dcf0: 10 80 00 07 b 203dd0c <fat_get_fat_cluster+0x14c> <== NOT EXECUTED
203dcf4: c2 26 80 00 st %g1, [ %i2 ] <== NOT EXECUTED
}
else
{
*ret_val |= (*((uint8_t *)(block0->buffer + ofs + 1)))<<8;
203dcf8: 82 00 c0 01 add %g3, %g1, %g1
203dcfc: c2 08 60 01 ldub [ %g1 + 1 ], %g1
203dd00: 83 28 60 08 sll %g1, 8, %g1
203dd04: 84 10 40 02 or %g1, %g2, %g2
203dd08: c4 26 80 00 st %g2, [ %i2 ]
}
if ( FAT_CLUSTER_IS_ODD(cln) )
203dd0c: 80 8e 60 01 btst 1, %i1
203dd10: 02 80 00 04 be 203dd20 <fat_get_fat_cluster+0x160>
203dd14: c2 06 80 00 ld [ %i2 ], %g1
*ret_val = (*ret_val) >> FAT12_SHIFT;
203dd18: 10 80 00 0e b 203dd50 <fat_get_fat_cluster+0x190>
203dd1c: 83 30 60 04 srl %g1, 4, %g1
else
*ret_val = (*ret_val) & FAT_FAT12_MASK;
203dd20: 10 80 00 0c b 203dd50 <fat_get_fat_cluster+0x190>
203dd24: 82 08 6f ff and %g1, 0xfff, %g1
break;
case FAT_FAT16:
*ret_val = *((uint16_t *)(block0->buffer + ofs));
203dd28: c4 07 bf fc ld [ %fp + -4 ], %g2 <== NOT EXECUTED
*ret_val = CF_LE_W(*ret_val);
203dd2c: 07 00 00 3f sethi %hi(0xfc00), %g3 <== NOT EXECUTED
else
*ret_val = (*ret_val) & FAT_FAT12_MASK;
break;
case FAT_FAT16:
*ret_val = *((uint16_t *)(block0->buffer + ofs));
203dd30: c4 00 a0 1c ld [ %g2 + 0x1c ], %g2 <== NOT EXECUTED
*ret_val = CF_LE_W(*ret_val);
203dd34: 86 10 e3 ff or %g3, 0x3ff, %g3 <== NOT EXECUTED
else
*ret_val = (*ret_val) & FAT_FAT12_MASK;
break;
case FAT_FAT16:
*ret_val = *((uint16_t *)(block0->buffer + ofs));
203dd38: c2 10 80 01 lduh [ %g2 + %g1 ], %g1 <== NOT EXECUTED
*ret_val = CF_LE_W(*ret_val);
203dd3c: 83 28 60 10 sll %g1, 0x10, %g1 <== NOT EXECUTED
203dd40: 85 30 60 18 srl %g1, 0x18, %g2 <== NOT EXECUTED
203dd44: 83 30 60 08 srl %g1, 8, %g1 <== NOT EXECUTED
203dd48: 82 08 40 03 and %g1, %g3, %g1 <== NOT EXECUTED
203dd4c: 82 10 80 01 or %g2, %g1, %g1 <== NOT EXECUTED
203dd50: c2 26 80 00 st %g1, [ %i2 ]
break;
203dd54: 81 c7 e0 08 ret
203dd58: 81 e8 00 00 restore
case FAT_FAT32:
*ret_val = *((uint32_t *)(block0->buffer + ofs));
203dd5c: c4 07 bf fc ld [ %fp + -4 ], %g2 <== NOT EXECUTED
203dd60: c4 00 a0 1c ld [ %g2 + 0x1c ], %g2 <== NOT EXECUTED
*ret_val = CF_LE_L(*ret_val);
203dd64: 7f ff ff 8b call 203db90 <CPU_swap_u32> <== NOT EXECUTED
203dd68: d0 00 80 01 ld [ %g2 + %g1 ], %o0 <== NOT EXECUTED
203dd6c: d0 26 80 00 st %o0, [ %i2 ] <== NOT EXECUTED
break;
203dd70: 81 c7 e0 08 ret <== NOT EXECUTED
203dd74: 81 e8 00 00 restore <== NOT EXECUTED
default:
rtems_set_errno_and_return_minus_one(EIO);
203dd78: 40 00 11 1d call 20421ec <__errno> <== NOT EXECUTED
203dd7c: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
203dd80: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
203dd84: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
203dd88: 81 c7 e0 08 ret <== NOT EXECUTED
203dd8c: 81 e8 00 00 restore <== 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)
203dd90: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
break;
}
return RC_OK;
}
203dd94: 81 c7 e0 08 ret <== NOT EXECUTED
203dd98: 81 e8 00 00 restore <== NOT EXECUTED
02026764 <fat_get_unique_ino>:
* 0 means FAILED !!!
*
*/
uint32_t
fat_get_unique_ino(fat_fs_info_t *fs_info)
{
2026764: 9d e3 bf a0 save %sp, -96, %sp <== 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))
2026768: 39 03 ff ff sethi %hi(0xffffc00), %i4 <== NOT EXECUTED
fat_get_unique_ino(fat_fs_info_t *fs_info)
{
uint32_t j = 0;
bool resrc_unsuff = false;
while (!resrc_unsuff)
202676c: 10 80 00 2b b 2026818 <fat_get_unique_ino+0xb4> <== NOT EXECUTED
2026770: b8 17 23 ff or %i4, 0x3ff, %i4 ! fffffff <RAM_END+0xdbfffff><== NOT EXECUTED
{
for (j = 0; j < fs_info->uino_pool_size; j++)
{
if (!FAT_UNIQ_INO_IS_BUSY(fs_info->index, fs_info->uino))
2026774: c2 06 20 6c ld [ %i0 + 0x6c ], %g1 <== NOT EXECUTED
2026778: 85 30 60 03 srl %g1, 3, %g2 <== NOT EXECUTED
202677c: b6 00 c0 02 add %g3, %g2, %i3 <== NOT EXECUTED
2026780: f4 08 c0 02 ldub [ %g3 + %g2 ], %i2 <== NOT EXECUTED
2026784: c4 48 c0 02 ldsb [ %g3 + %g2 ], %g2 <== NOT EXECUTED
2026788: ba 08 60 07 and %g1, 7, %i5 <== NOT EXECUTED
202678c: 85 38 80 1d sra %g2, %i5, %g2 <== NOT EXECUTED
2026790: 80 88 a0 01 btst 1, %g2 <== NOT EXECUTED
2026794: 12 80 00 0a bne 20267bc <fat_get_unique_ino+0x58> <== NOT EXECUTED
2026798: 82 00 60 01 inc %g1 <== NOT EXECUTED
{
FAT_SET_UNIQ_INO_BUSY(fs_info->index, fs_info->uino);
202679c: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED
20267a0: bb 28 40 1d sll %g1, %i5, %i5 <== NOT EXECUTED
20267a4: ba 17 40 1a or %i5, %i2, %i5 <== NOT EXECUTED
20267a8: fa 2e c0 00 stb %i5, [ %i3 ] <== NOT EXECUTED
return (fs_info->uino_base + fs_info->index);
20267ac: c4 06 20 6c ld [ %i0 + 0x6c ], %g2 <== NOT EXECUTED
20267b0: c2 06 20 74 ld [ %i0 + 0x74 ], %g1 <== NOT EXECUTED
20267b4: 81 c7 e0 08 ret <== NOT EXECUTED
20267b8: 91 e8 80 01 restore %g2, %g1, %o0 <== NOT EXECUTED
}
fs_info->index++;
if (fs_info->index >= fs_info->uino_pool_size)
20267bc: 80 a0 40 04 cmp %g1, %g4 <== NOT EXECUTED
20267c0: 3a 80 00 03 bcc,a 20267cc <fat_get_unique_ino+0x68> <== NOT EXECUTED
20267c4: c0 26 20 6c clr [ %i0 + 0x6c ] <== NOT EXECUTED
20267c8: c2 26 20 6c st %g1, [ %i0 + 0x6c ] <== NOT EXECUTED
uint32_t j = 0;
bool resrc_unsuff = false;
while (!resrc_unsuff)
{
for (j = 0; j < fs_info->uino_pool_size; j++)
20267cc: 92 02 60 01 inc %o1 <== NOT EXECUTED
20267d0: 80 a2 40 04 cmp %o1, %g4 <== NOT EXECUTED
20267d4: 32 bf ff e8 bne,a 2026774 <fat_get_unique_ino+0x10> <== NOT EXECUTED
20267d8: c6 06 20 68 ld [ %i0 + 0x68 ], %g3 <== 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))
20267dc: c2 06 20 74 ld [ %i0 + 0x74 ], %g1 <== NOT EXECUTED
20267e0: 93 2a 60 01 sll %o1, 1, %o1 <== NOT EXECUTED
20267e4: 82 27 00 01 sub %i4, %g1, %g1 <== NOT EXECUTED
20267e8: 80 a2 40 01 cmp %o1, %g1 <== NOT EXECUTED
20267ec: 2a 80 00 04 bcs,a 20267fc <fat_get_unique_ino+0x98> <== NOT EXECUTED
20267f0: d0 06 20 68 ld [ %i0 + 0x68 ], %o0 <== NOT EXECUTED
resrc_unsuff = true;
}
else
resrc_unsuff = true;
}
return 0;
20267f4: 81 c7 e0 08 ret <== NOT EXECUTED
20267f8: 91 e8 20 00 restore %g0, 0, %o0 <== 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);
20267fc: 7f ff 8d 8e call 2009e34 <realloc> <== NOT EXECUTED
2026800: d2 26 20 70 st %o1, [ %i0 + 0x70 ] <== NOT EXECUTED
if (fs_info->uino != NULL)
2026804: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2026808: 02 bf ff fb be 20267f4 <fat_get_unique_ino+0x90> <== NOT EXECUTED
202680c: d0 26 20 68 st %o0, [ %i0 + 0x68 ] <== NOT EXECUTED
fs_info->index = fs_info->uino_pool_size;
2026810: c2 06 20 70 ld [ %i0 + 0x70 ], %g1 <== NOT EXECUTED
2026814: c2 26 20 6c st %g1, [ %i0 + 0x6c ] <== NOT EXECUTED
uint32_t j = 0;
bool resrc_unsuff = false;
while (!resrc_unsuff)
{
for (j = 0; j < fs_info->uino_pool_size; j++)
2026818: c8 06 20 70 ld [ %i0 + 0x70 ], %g4 <== NOT EXECUTED
202681c: 10 bf ff ed b 20267d0 <fat_get_unique_ino+0x6c> <== NOT EXECUTED
2026820: 92 10 20 00 clr %o1 <== NOT EXECUTED
020266b0 <fat_init_clusters_chain>:
int
fat_init_clusters_chain(
fat_fs_info_t *fs_info,
uint32_t start_cln
)
{
20266b0: 9d e3 bf 98 save %sp, -104, %sp
int rc = RC_OK;
ssize_t ret = 0;
uint32_t cur_cln = start_cln;
char *buf;
buf = calloc(fs_info->vol.bpc, sizeof(char));
20266b4: d0 16 20 06 lduh [ %i0 + 6 ], %o0
uint32_t start_cln
)
{
int rc = RC_OK;
ssize_t ret = 0;
uint32_t cur_cln = start_cln;
20266b8: f2 27 bf fc st %i1, [ %fp + -4 ]
char *buf;
buf = calloc(fs_info->vol.bpc, sizeof(char));
20266bc: 92 10 20 01 mov 1, %o1
20266c0: 7f ff 88 6b call 200886c <calloc>
20266c4: ba 10 00 18 mov %i0, %i5
if ( buf == NULL )
20266c8: b8 92 20 00 orcc %o0, 0, %i4
20266cc: 12 80 00 1b bne 2026738 <fat_init_clusters_chain+0x88> <== ALWAYS TAKEN
20266d0: d2 07 bf fc ld [ %fp + -4 ], %o1
rtems_set_errno_and_return_minus_one( EIO );
20266d4: 40 00 6e c6 call 20421ec <__errno> <== NOT EXECUTED
20266d8: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
20266dc: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
20266e0: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
20266e4: 81 c7 e0 08 ret <== NOT EXECUTED
20266e8: 81 e8 00 00 restore <== NOT EXECUTED
while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)
{
ret = fat_cluster_write(fs_info, cur_cln, buf);
20266ec: 7f ff ff dc call 202665c <fat_cluster_write>
20266f0: 94 10 00 1c mov %i4, %o2
if ( ret == -1 )
20266f4: 80 a2 3f ff cmp %o0, -1
20266f8: 12 80 00 06 bne 2026710 <fat_init_clusters_chain+0x60> <== ALWAYS TAKEN
20266fc: d2 07 bf fc ld [ %fp + -4 ], %o1
{
free(buf);
2026700: 7f ff 89 3f call 2008bfc <free> <== NOT EXECUTED
2026704: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
return -1;
2026708: 81 c7 e0 08 ret <== NOT EXECUTED
202670c: 91 e8 3f ff restore %g0, -1, %o0 <== NOT EXECUTED
}
rc = fat_get_fat_cluster(fs_info, cur_cln, &cur_cln);
2026710: 90 10 00 1d mov %i5, %o0
2026714: 40 00 5d 2b call 203dbc0 <fat_get_fat_cluster>
2026718: 94 07 bf fc add %fp, -4, %o2
if ( rc != RC_OK )
202671c: b0 92 20 00 orcc %o0, 0, %i0
2026720: 02 80 00 06 be 2026738 <fat_init_clusters_chain+0x88> <== ALWAYS TAKEN
2026724: d2 07 bf fc ld [ %fp + -4 ], %o1
{
free(buf);
2026728: 7f ff 89 35 call 2008bfc <free> <== NOT EXECUTED
202672c: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
2026730: 81 c7 e0 08 ret <== NOT EXECUTED
2026734: 81 e8 00 00 restore <== 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)
2026738: c4 07 60 0c ld [ %i5 + 0xc ], %g2
202673c: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
2026740: 84 0a 40 02 and %o1, %g2, %g2
2026744: 80 a0 80 01 cmp %g2, %g1
2026748: 0a bf ff e9 bcs 20266ec <fat_init_clusters_chain+0x3c>
202674c: 90 10 00 1d mov %i5, %o0
free(buf);
return rc;
}
}
free(buf);
2026750: 90 10 00 1c mov %i4, %o0
2026754: 7f ff 89 2a call 2008bfc <free>
2026758: b0 10 20 00 clr %i0
return rc;
}
202675c: 81 c7 e0 08 ret
2026760: 81 e8 00 00 restore
020269e8 <fat_init_volume_info>:
* RC_OK on success, or -1 if error occured
* and errno set appropriately
*/
int
fat_init_volume_info(fat_fs_info_t *fs_info, const char *device)
{
20269e8: 9d e3 bf 10 save %sp, -240, %sp
ssize_t ret = 0;
struct stat stat_buf;
int i = 0;
rtems_bdbuf_buffer *block = NULL;
vol->fd = open(device, O_RDWR);
20269ec: 92 10 20 02 mov 2, %o1
* RC_OK on success, or -1 if error occured
* and errno set appropriately
*/
int
fat_init_volume_info(fat_fs_info_t *fs_info, const char *device)
{
20269f0: a0 10 00 18 mov %i0, %l0
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;
20269f4: c0 27 bf a4 clr [ %fp + -92 ]
vol->fd = open(device, O_RDWR);
20269f8: 7f ff 8c 3b call 2009ae4 <open>
20269fc: 90 10 00 19 mov %i1, %o0
if (vol->fd < 0)
2026a00: 80 a2 20 00 cmp %o0, 0
2026a04: 06 80 00 09 bl 2026a28 <fat_init_volume_info+0x40> <== NEVER TAKEN
2026a08: d0 24 20 54 st %o0, [ %l0 + 0x54 ]
{
rtems_set_errno_and_return_minus_one(ENXIO);
}
rc = fstat(vol->fd, &stat_buf);
2026a0c: 40 00 05 46 call 2027f24 <fstat>
2026a10: 92 07 bf b8 add %fp, -72, %o1
if (rc != 0)
2026a14: 80 a2 20 00 cmp %o0, 0
2026a18: 02 80 00 08 be 2026a38 <fat_init_volume_info+0x50> <== ALWAYS TAKEN
2026a1c: d0 06 20 54 ld [ %i0 + 0x54 ], %o0
{
close(vol->fd);
2026a20: 7f ff 87 b9 call 2008904 <close> <== NOT EXECUTED
2026a24: 01 00 00 00 nop <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(ENXIO);
2026a28: 40 00 6d f1 call 20421ec <__errno> <== NOT EXECUTED
2026a2c: 01 00 00 00 nop <== NOT EXECUTED
2026a30: 10 80 01 c3 b 202713c <fat_init_volume_info+0x754> <== NOT EXECUTED
2026a34: 82 10 20 06 mov 6, %g1 ! 6 <PROM_START+0x6> <== NOT EXECUTED
}
/* Must be a block device. */
if (!S_ISBLK(stat_buf.st_mode))
2026a38: c6 07 bf c4 ld [ %fp + -60 ], %g3
2026a3c: 05 00 00 3c sethi %hi(0xf000), %g2
2026a40: 86 08 c0 02 and %g3, %g2, %g3
2026a44: 05 00 00 18 sethi %hi(0x6000), %g2
2026a48: 80 a0 c0 02 cmp %g3, %g2
2026a4c: 12 bf ff f5 bne 2026a20 <fat_init_volume_info+0x38> <== NEVER TAKEN
2026a50: 13 10 01 10 sethi %hi(0x40044000), %o1
static inline int rtems_disk_fd_get_disk_device(
int fd,
rtems_disk_device **dd_ptr
)
{
return ioctl(fd, RTEMS_BLKIO_GETDISKDEV, dd_ptr);
2026a54: 94 06 20 58 add %i0, 0x58, %o2
2026a58: 7f ff 88 c0 call 2008d58 <ioctl>
2026a5c: 92 12 62 09 or %o1, 0x209, %o1
rtems_set_errno_and_return_minus_one(ENXIO);
}
/* check that device is registred as block device and lock it */
rc = rtems_disk_fd_get_disk_device(vol->fd, &vol->dd);
if (rc != 0) {
2026a60: ba 92 20 00 orcc %o0, 0, %i5
2026a64: 22 80 00 04 be,a 2026a74 <fat_init_volume_info+0x8c> <== ALWAYS TAKEN
2026a68: d0 06 20 58 ld [ %i0 + 0x58 ], %o0
close(vol->fd);
2026a6c: 10 bf ff ed b 2026a20 <fat_init_volume_info+0x38> <== NOT EXECUTED
2026a70: d0 06 20 54 ld [ %i0 + 0x54 ], %o0 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(ENXIO);
}
/* Read boot record */
/* FIXME: Asserts FAT_MAX_BPB_SIZE < bdbuf block size */
sc = rtems_bdbuf_read( vol->dd, 0, &block);
2026a74: 92 10 20 00 clr %o1
2026a78: 7f ff 7f 00 call 2006678 <rtems_bdbuf_read>
2026a7c: 94 07 bf a4 add %fp, -92, %o2
if (sc != RTEMS_SUCCESSFUL)
2026a80: 80 a2 20 00 cmp %o0, 0
2026a84: 22 80 00 03 be,a 2026a90 <fat_init_volume_info+0xa8> <== ALWAYS TAKEN
2026a88: d0 07 bf a4 ld [ %fp + -92 ], %o0
2026a8c: 30 80 00 32 b,a 2026b54 <fat_init_volume_info+0x16c> <== NOT EXECUTED
{
close(vol->fd);
rtems_set_errno_and_return_minus_one( EIO);
}
memcpy( boot_rec, block->buffer, FAT_MAX_BPB_SIZE);
2026a90: de 02 20 1c ld [ %o0 + 0x1c ], %o7
2026a94: c2 0b e0 20 ldub [ %o7 + 0x20 ], %g1
2026a98: c4 0b e0 0b ldub [ %o7 + 0xb ], %g2
2026a9c: c2 2f bf 99 stb %g1, [ %fp + -103 ]
2026aa0: c2 0b e0 21 ldub [ %o7 + 0x21 ], %g1
2026aa4: d6 0b e0 0c ldub [ %o7 + 0xc ], %o3
2026aa8: c2 2f bf 9a stb %g1, [ %fp + -102 ]
2026aac: c2 0b e0 23 ldub [ %o7 + 0x23 ], %g1
2026ab0: da 0b e0 0e ldub [ %o7 + 0xe ], %o5
2026ab4: c2 2f bf 8f stb %g1, [ %fp + -113 ]
2026ab8: c2 0b e0 2c ldub [ %o7 + 0x2c ], %g1
2026abc: d8 0b e0 0f ldub [ %o7 + 0xf ], %o4
2026ac0: c2 2f bf 9f stb %g1, [ %fp + -97 ]
2026ac4: c2 0b e0 2d ldub [ %o7 + 0x2d ], %g1
2026ac8: c6 0b e0 11 ldub [ %o7 + 0x11 ], %g3
2026acc: c2 2f bf 9e stb %g1, [ %fp + -98 ]
2026ad0: c2 0b e0 2e ldub [ %o7 + 0x2e ], %g1
2026ad4: c8 0b e0 12 ldub [ %o7 + 0x12 ], %g4
2026ad8: c2 2f bf 9d stb %g1, [ %fp + -99 ]
2026adc: c2 0b e0 2f ldub [ %o7 + 0x2f ], %g1
2026ae0: f8 0b e0 0d ldub [ %o7 + 0xd ], %i4
2026ae4: f4 0b e0 10 ldub [ %o7 + 0x10 ], %i2
2026ae8: e2 0b e0 13 ldub [ %o7 + 0x13 ], %l1
2026aec: e4 0b e0 14 ldub [ %o7 + 0x14 ], %l2
2026af0: ee 0b e0 16 ldub [ %o7 + 0x16 ], %l7
2026af4: f0 0b e0 17 ldub [ %o7 + 0x17 ], %i0
2026af8: f2 0b e0 22 ldub [ %o7 + 0x22 ], %i1
2026afc: e8 0b e0 24 ldub [ %o7 + 0x24 ], %l4
2026b00: ec 0b e0 25 ldub [ %o7 + 0x25 ], %l6
2026b04: ea 0b e0 26 ldub [ %o7 + 0x26 ], %l5
2026b08: e6 0b e0 27 ldub [ %o7 + 0x27 ], %l3
2026b0c: f6 0b e0 28 ldub [ %o7 + 0x28 ], %i3
2026b10: c2 2f bf 97 stb %g1, [ %fp + -105 ]
2026b14: c2 0b e0 30 ldub [ %o7 + 0x30 ], %g1
2026b18: de 0b e0 31 ldub [ %o7 + 0x31 ], %o7
2026b1c: c2 2f bf 9c stb %g1, [ %fp + -100 ]
sc = rtems_bdbuf_release( block);
2026b20: c4 3f bf 80 std %g2, [ %fp + -128 ]
2026b24: c8 27 bf 7c st %g4, [ %fp + -132 ]
2026b28: d6 27 bf 78 st %o3, [ %fp + -136 ]
2026b2c: d8 3f bf 70 std %o4, [ %fp + -144 ]
{
close(vol->fd);
rtems_set_errno_and_return_minus_one( EIO);
}
memcpy( boot_rec, block->buffer, FAT_MAX_BPB_SIZE);
2026b30: de 2f bf 9b stb %o7, [ %fp + -101 ]
sc = rtems_bdbuf_release( block);
2026b34: 7f ff 7f 4e call 200686c <rtems_bdbuf_release>
2026b38: 01 00 00 00 nop
if (sc != RTEMS_SUCCESSFUL)
2026b3c: c4 1f bf 80 ldd [ %fp + -128 ], %g2
2026b40: 80 a2 20 00 cmp %o0, 0
2026b44: c8 07 bf 7c ld [ %fp + -132 ], %g4
2026b48: d6 07 bf 78 ld [ %fp + -136 ], %o3
2026b4c: 02 80 00 08 be 2026b6c <fat_init_volume_info+0x184> <== ALWAYS TAKEN
2026b50: d8 1f bf 70 ldd [ %fp + -144 ], %o4
{
close(vol->fd);
2026b54: 7f ff 87 6c call 2008904 <close> <== NOT EXECUTED
2026b58: d0 04 20 54 ld [ %l0 + 0x54 ], %o0 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EIO );
2026b5c: 40 00 6d a4 call 20421ec <__errno> <== NOT EXECUTED
2026b60: 01 00 00 00 nop <== NOT EXECUTED
2026b64: 10 80 01 76 b 202713c <fat_init_volume_info+0x754> <== NOT EXECUTED
2026b68: 82 10 20 05 mov 5, %g1 ! 5 <PROM_START+0x5> <== NOT EXECUTED
}
/* Evaluate boot record */
vol->bps = FAT_GET_BR_BYTES_PER_SECTOR(boot_rec);
2026b6c: 96 0a e0 ff and %o3, 0xff, %o3
2026b70: 84 08 a0 ff and %g2, 0xff, %g2
2026b74: 97 2a e0 08 sll %o3, 8, %o3
2026b78: 84 12 c0 02 or %o3, %g2, %g2
if ( (vol->bps != 512) &&
2026b7c: 9f 28 a0 10 sll %g2, 0x10, %o7
2026b80: 9f 33 e0 10 srl %o7, 0x10, %o7
2026b84: 80 a3 e4 00 cmp %o7, 0x400
2026b88: 02 80 00 0c be 2026bb8 <fat_init_volume_info+0x1d0> <== NEVER TAKEN
2026b8c: c4 34 00 00 sth %g2, [ %l0 ]
2026b90: 80 a3 e2 00 cmp %o7, 0x200
2026b94: 22 80 00 0a be,a 2026bbc <fat_init_volume_info+0x1d4> <== ALWAYS TAKEN
2026b98: 9f 28 a0 10 sll %g2, 0x10, %o7
(vol->bps != 1024) &&
2026b9c: 80 a3 e8 00 cmp %o7, 0x800 <== NOT EXECUTED
2026ba0: 02 80 00 06 be 2026bb8 <fat_init_volume_info+0x1d0> <== NOT EXECUTED
2026ba4: 17 00 00 04 sethi %hi(0x1000), %o3 <== NOT EXECUTED
(vol->bps != 2048) &&
2026ba8: 80 a3 c0 0b cmp %o7, %o3 <== NOT EXECUTED
2026bac: 02 80 00 04 be 2026bbc <fat_init_volume_info+0x1d4> <== NOT EXECUTED
2026bb0: 9f 28 a0 10 sll %g2, 0x10, %o7 <== NOT EXECUTED
2026bb4: 30 80 00 d1 b,a 2026ef8 <fat_init_volume_info+0x510> <== NOT EXECUTED
{
close(vol->fd);
rtems_set_errno_and_return_minus_one( EINVAL );
}
for (vol->sec_mul = 0, i = (vol->bps >> FAT_SECTOR512_BITS); (i & 1) == 0;
2026bb8: 9f 28 a0 10 sll %g2, 0x10, %o7 <== NOT EXECUTED
2026bbc: c0 2c 20 03 clrb [ %l0 + 3 ]
2026bc0: 10 80 00 05 b 2026bd4 <fat_init_volume_info+0x1ec>
2026bc4: 9f 33 e0 19 srl %o7, 0x19, %o7
i >>= 1, vol->sec_mul++);
2026bc8: 9f 3b e0 01 sra %o7, 1, %o7 <== NOT EXECUTED
2026bcc: 96 02 e0 01 inc %o3 <== NOT EXECUTED
2026bd0: d6 2c 20 03 stb %o3, [ %l0 + 3 ] <== NOT EXECUTED
{
close(vol->fd);
rtems_set_errno_and_return_minus_one( EINVAL );
}
for (vol->sec_mul = 0, i = (vol->bps >> FAT_SECTOR512_BITS); (i & 1) == 0;
2026bd4: 80 8b e0 01 btst 1, %o7
2026bd8: 22 bf ff fc be,a 2026bc8 <fat_init_volume_info+0x1e0> <== NEVER TAKEN
2026bdc: d6 0c 20 03 ldub [ %l0 + 3 ], %o3 <== NOT EXECUTED
i >>= 1, vol->sec_mul++);
for (vol->sec_log2 = 0, i = vol->bps; (i & 1) == 0;
2026be0: 85 28 a0 10 sll %g2, 0x10, %g2
2026be4: c0 2c 20 02 clrb [ %l0 + 2 ]
2026be8: 93 30 a0 10 srl %g2, 0x10, %o1
2026bec: 10 80 00 05 b 2026c00 <fat_init_volume_info+0x218>
2026bf0: 84 10 00 09 mov %o1, %g2
i >>= 1, vol->sec_log2++);
2026bf4: 85 38 a0 01 sra %g2, 1, %g2
2026bf8: 9e 03 e0 01 inc %o7
2026bfc: de 2c 20 02 stb %o7, [ %l0 + 2 ]
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;
2026c00: 80 88 a0 01 btst 1, %g2
2026c04: 22 bf ff fc be,a 2026bf4 <fat_init_volume_info+0x20c>
2026c08: de 0c 20 02 ldub [ %l0 + 2 ], %o7
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)
2026c0c: 9e 8f 20 ff andcc %i4, 0xff, %o7
2026c10: 02 80 00 ba be 2026ef8 <fat_init_volume_info+0x510> <== NEVER TAKEN
2026c14: f8 2c 20 04 stb %i4, [ %l0 + 4 ]
{
close(vol->fd);
rtems_set_errno_and_return_minus_one(EINVAL);
}
for (vol->spc_log2 = 0, i = vol->spc; (i & 1) == 0;
2026c18: 10 80 00 05 b 2026c2c <fat_init_volume_info+0x244>
2026c1c: c0 2c 20 05 clrb [ %l0 + 5 ]
i >>= 1, vol->spc_log2++);
2026c20: 84 00 a0 01 inc %g2
2026c24: 9f 3b e0 01 sra %o7, 1, %o7
2026c28: c4 2c 20 05 stb %g2, [ %l0 + 5 ]
{
close(vol->fd);
rtems_set_errno_and_return_minus_one(EINVAL);
}
for (vol->spc_log2 = 0, i = vol->spc; (i & 1) == 0;
2026c2c: 80 8b e0 01 btst 1, %o7
2026c30: 02 bf ff fc be 2026c20 <fat_init_volume_info+0x238>
2026c34: c4 0c 20 05 ldub [ %l0 + 5 ], %g2
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)
2026c38: 85 2a 40 02 sll %o1, %g2, %g2
2026c3c: 97 28 a0 10 sll %g2, 0x10, %o3
2026c40: 1f 20 00 00 sethi %hi(0x80000000), %o7
2026c44: 80 a2 c0 0f cmp %o3, %o7
2026c48: 18 80 00 ac bgu 2026ef8 <fat_init_volume_info+0x510> <== NEVER TAKEN
2026c4c: c4 34 20 06 sth %g2, [ %l0 + 6 ]
{
close(vol->fd);
rtems_set_errno_and_return_minus_one(EINVAL);
}
for (vol->bpc_log2 = 0, i = vol->bpc; (i & 1) == 0;
2026c50: 1f 00 00 3f sethi %hi(0xfc00), %o7
2026c54: c0 2c 20 08 clrb [ %l0 + 8 ]
2026c58: 9e 13 e3 ff or %o7, 0x3ff, %o7
2026c5c: 10 80 00 05 b 2026c70 <fat_init_volume_info+0x288>
2026c60: 84 08 80 0f and %g2, %o7, %g2
i >>= 1, vol->bpc_log2++);
2026c64: 85 38 a0 01 sra %g2, 1, %g2
2026c68: 9e 03 e0 01 inc %o7
2026c6c: de 2c 20 08 stb %o7, [ %l0 + 8 ]
{
close(vol->fd);
rtems_set_errno_and_return_minus_one(EINVAL);
}
for (vol->bpc_log2 = 0, i = vol->bpc; (i & 1) == 0;
2026c70: 80 88 a0 01 btst 1, %g2
2026c74: 22 bf ff fc be,a 2026c64 <fat_init_volume_info+0x27c>
2026c78: de 0c 20 08 ldub [ %l0 + 8 ], %o7
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)) /
2026c7c: 84 02 7f ff add %o1, -1, %g2
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);
2026c80: 98 0b 20 ff and %o4, 0xff, %o4
2026c84: 9a 0b 60 ff and %o5, 0xff, %o5
2026c88: 99 2b 20 08 sll %o4, 8, %o4
vol->rdir_entrs = FAT_GET_BR_FILES_PER_ROOT_DIR(boot_rec);
2026c8c: 88 09 20 ff and %g4, 0xff, %g4
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);
2026c90: 9a 13 00 0d or %o4, %o5, %o5
vol->rdir_entrs = FAT_GET_BR_FILES_PER_ROOT_DIR(boot_rec);
2026c94: 89 29 20 08 sll %g4, 8, %g4
2026c98: 86 08 e0 ff and %g3, 0xff, %g3
2026c9c: 86 11 00 03 or %g4, %g3, %g3
2026ca0: c6 34 20 20 sth %g3, [ %l0 + 0x20 ]
/* calculate the count of sectors occupied by the root directory */
vol->rdir_secs = ((vol->rdir_entrs * FAT_DIRENTRY_SIZE) + (vol->bps - 1)) /
2026ca4: 87 28 e0 10 sll %g3, 0x10, %g3
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);
2026ca8: da 34 20 14 sth %o5, [ %l0 + 0x14 ]
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)) /
2026cac: 91 30 e0 0b srl %g3, 0xb, %o0
2026cb0: da 27 bf 74 st %o5, [ %fp + -140 ]
2026cb4: 90 02 00 02 add %o0, %g2, %o0
2026cb8: 40 00 d2 34 call 205b588 <.div>
2026cbc: f4 2c 20 09 stb %i2, [ %l0 + 9 ]
vol->bps;
vol->rdir_size = vol->rdir_secs << vol->sec_log2;
2026cc0: c6 0c 20 02 ldub [ %l0 + 2 ], %g3
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)) /
2026cc4: d0 24 20 24 st %o0, [ %l0 + 0x24 ]
vol->bps;
vol->rdir_size = vol->rdir_secs << vol->sec_log2;
2026cc8: 87 2a 00 03 sll %o0, %g3, %g3
2026ccc: c6 24 20 28 st %g3, [ %l0 + 0x28 ]
if ( (FAT_GET_BR_SECTORS_PER_FAT(boot_rec)) != 0)
2026cd0: b0 0e 20 ff and %i0, 0xff, %i0
2026cd4: ae 0d e0 ff and %l7, 0xff, %l7
2026cd8: b1 2e 20 08 sll %i0, 8, %i0
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)) /
2026cdc: 84 10 00 08 mov %o0, %g2
vol->bps;
vol->rdir_size = vol->rdir_secs << vol->sec_log2;
if ( (FAT_GET_BR_SECTORS_PER_FAT(boot_rec)) != 0)
2026ce0: ae 16 00 17 or %i0, %l7, %l7
2026ce4: af 2d e0 10 sll %l7, 0x10, %l7
2026ce8: 80 a5 e0 00 cmp %l7, 0
2026cec: 02 80 00 05 be 2026d00 <fat_init_volume_info+0x318> <== NEVER TAKEN
2026cf0: da 07 bf 74 ld [ %fp + -140 ], %o5
vol->fat_length = FAT_GET_BR_SECTORS_PER_FAT(boot_rec);
2026cf4: af 35 e0 10 srl %l7, 0x10, %l7
2026cf8: 10 80 00 0c b 2026d28 <fat_init_volume_info+0x340>
2026cfc: ee 24 20 18 st %l7, [ %l0 + 0x18 ]
else
vol->fat_length = FAT_GET_BR_SECTORS_PER_FAT32(boot_rec);
2026d00: ac 0d a0 ff and %l6, 0xff, %l6 <== NOT EXECUTED
2026d04: aa 0d 60 ff and %l5, 0xff, %l5 <== NOT EXECUTED
2026d08: ad 2d a0 08 sll %l6, 8, %l6 <== NOT EXECUTED
2026d0c: ab 2d 60 10 sll %l5, 0x10, %l5 <== NOT EXECUTED
2026d10: a8 0d 20 ff and %l4, 0xff, %l4 <== NOT EXECUTED
2026d14: aa 15 80 15 or %l6, %l5, %l5 <== NOT EXECUTED
2026d18: a7 2c e0 18 sll %l3, 0x18, %l3 <== NOT EXECUTED
2026d1c: a8 15 40 14 or %l5, %l4, %l4 <== NOT EXECUTED
2026d20: a6 15 00 13 or %l4, %l3, %l3 <== NOT EXECUTED
2026d24: e6 24 20 18 st %l3, [ %l0 + 0x18 ] <== NOT EXECUTED
vol->data_fsec = vol->fat_loc + vol->fats * vol->fat_length +
2026d28: d2 04 20 18 ld [ %l0 + 0x18 ], %o1
2026d2c: 9b 2b 60 10 sll %o5, 0x10, %o5
2026d30: c4 27 bf 80 st %g2, [ %fp + -128 ]
2026d34: b1 33 60 10 srl %o5, 0x10, %i0
2026d38: 7f ff 70 4b call 2002e64 <.umul>
2026d3c: 90 0e a0 ff and %i2, 0xff, %o0
2026d40: c4 07 bf 80 ld [ %fp + -128 ], %g2
2026d44: 90 06 00 08 add %i0, %o0, %o0
2026d48: 84 00 80 08 add %g2, %o0, %g2
vol->rdir_secs;
/* for FAT12/16 root dir starts at(sector) */
vol->rdir_loc = vol->fat_loc + vol->fats * vol->fat_length;
2026d4c: d0 24 20 1c st %o0, [ %l0 + 0x1c ]
if ( (FAT_GET_BR_TOTAL_SECTORS_NUM16(boot_rec)) != 0)
2026d50: a4 0c a0 ff and %l2, 0xff, %l2
2026d54: a2 0c 60 ff and %l1, 0xff, %l1
2026d58: a5 2c a0 08 sll %l2, 8, %l2
2026d5c: a2 14 80 11 or %l2, %l1, %l1
2026d60: a3 2c 60 10 sll %l1, 0x10, %l1
2026d64: 80 a4 60 00 cmp %l1, 0
2026d68: 02 80 00 05 be 2026d7c <fat_init_volume_info+0x394> <== NEVER TAKEN
2026d6c: c4 24 20 30 st %g2, [ %l0 + 0x30 ]
vol->tot_secs = FAT_GET_BR_TOTAL_SECTORS_NUM16(boot_rec);
2026d70: a3 34 60 10 srl %l1, 0x10, %l1
2026d74: 10 80 00 0d b 2026da8 <fat_init_volume_info+0x3c0>
2026d78: e2 24 20 2c st %l1, [ %l0 + 0x2c ]
else
vol->tot_secs = FAT_GET_BR_TOTAL_SECTORS_NUM32(boot_rec);
2026d7c: c8 0f bf 99 ldub [ %fp + -103 ], %g4 <== NOT EXECUTED
2026d80: c6 0f bf 9a ldub [ %fp + -102 ], %g3 <== NOT EXECUTED
2026d84: c2 0f bf 8f ldub [ %fp + -113 ], %g1 <== NOT EXECUTED
2026d88: 87 28 e0 08 sll %g3, 8, %g3 <== NOT EXECUTED
2026d8c: b2 0e 60 ff and %i1, 0xff, %i1 <== NOT EXECUTED
2026d90: b3 2e 60 10 sll %i1, 0x10, %i1 <== NOT EXECUTED
2026d94: 86 10 c0 19 or %g3, %i1, %g3 <== NOT EXECUTED
2026d98: 86 10 c0 04 or %g3, %g4, %g3 <== NOT EXECUTED
2026d9c: 89 28 60 18 sll %g1, 0x18, %g4 <== NOT EXECUTED
2026da0: 86 10 c0 04 or %g3, %g4, %g3 <== NOT EXECUTED
2026da4: c6 24 20 2c st %g3, [ %l0 + 0x2c ] <== NOT EXECUTED
data_secs = vol->tot_secs - vol->data_fsec;
2026da8: d0 04 20 2c ld [ %l0 + 0x2c ], %o0
vol->data_cls = data_secs / vol->spc;
2026dac: 92 0f 20 ff and %i4, 0xff, %o1
2026db0: 40 00 d1 f4 call 205b580 <.udiv>
2026db4: 90 22 00 02 sub %o0, %g2, %o0
/* determine FAT type at least */
if ( vol->data_cls < FAT_FAT12_MAX_CLN)
2026db8: 80 a2 2f f4 cmp %o0, 0xff4
2026dbc: 18 80 00 08 bgu 2026ddc <fat_init_volume_info+0x3f4> <== NEVER TAKEN
2026dc0: d0 24 20 34 st %o0, [ %l0 + 0x34 ]
{
vol->type = FAT_FAT12;
2026dc4: 84 10 20 01 mov 1, %g2
2026dc8: c4 2c 20 0a stb %g2, [ %l0 + 0xa ]
vol->mask = FAT_FAT12_MASK;
2026dcc: 84 10 2f ff mov 0xfff, %g2
2026dd0: c4 24 20 0c st %g2, [ %l0 + 0xc ]
vol->eoc_val = FAT_FAT12_EOC;
2026dd4: 10 80 00 0f b 2026e10 <fat_init_volume_info+0x428>
2026dd8: 84 10 2f f8 mov 0xff8, %g2
}
else
{
if ( vol->data_cls < FAT_FAT16_MAX_CLN)
2026ddc: 05 00 00 3f sethi %hi(0xfc00), %g2 <== NOT EXECUTED
2026de0: 86 10 a3 f4 or %g2, 0x3f4, %g3 ! fff4 <PROM_START+0xfff4> <== NOT EXECUTED
2026de4: 80 a2 00 03 cmp %o0, %g3 <== NOT EXECUTED
2026de8: 38 80 00 05 bgu,a 2026dfc <fat_init_volume_info+0x414> <== NOT EXECUTED
2026dec: 84 10 20 04 mov 4, %g2 <== NOT EXECUTED
{
vol->type = FAT_FAT16;
2026df0: 86 10 20 02 mov 2, %g3 <== NOT EXECUTED
2026df4: 10 80 00 04 b 2026e04 <fat_init_volume_info+0x41c> <== NOT EXECUTED
2026df8: c6 2c 20 0a stb %g3, [ %l0 + 0xa ] <== NOT EXECUTED
vol->mask = FAT_FAT16_MASK;
vol->eoc_val = FAT_FAT16_EOC;
}
else
{
vol->type = FAT_FAT32;
2026dfc: c4 2c 20 0a stb %g2, [ %l0 + 0xa ] <== NOT EXECUTED
vol->mask = FAT_FAT32_MASK;
2026e00: 05 03 ff ff sethi %hi(0xffffc00), %g2 <== NOT EXECUTED
2026e04: 86 10 a3 ff or %g2, 0x3ff, %g3 ! fffffff <RAM_END+0xdbfffff><== NOT EXECUTED
vol->eoc_val = FAT_FAT32_EOC;
2026e08: 84 10 a3 f8 or %g2, 0x3f8, %g2 <== NOT EXECUTED
vol->eoc_val = FAT_FAT16_EOC;
}
else
{
vol->type = FAT_FAT32;
vol->mask = FAT_FAT32_MASK;
2026e0c: c6 24 20 0c st %g3, [ %l0 + 0xc ] <== NOT EXECUTED
vol->eoc_val = FAT_FAT32_EOC;
2026e10: c4 24 20 10 st %g2, [ %l0 + 0x10 ]
}
}
if (vol->type == FAT_FAT32)
2026e14: c4 0c 20 0a ldub [ %l0 + 0xa ], %g2
2026e18: 80 a0 a0 04 cmp %g2, 4
2026e1c: 12 80 00 6e bne 2026fd4 <fat_init_volume_info+0x5ec> <== ALWAYS TAKEN
2026e20: 82 10 3f ff mov -1, %g1
{
vol->rdir_cl = FAT_GET_BR_FAT32_ROOT_CLUSTER(boot_rec);
2026e24: c6 0f bf 9e ldub [ %fp + -98 ], %g3 <== NOT EXECUTED
2026e28: c4 0f bf 9d ldub [ %fp + -99 ], %g2 <== NOT EXECUTED
2026e2c: 87 28 e0 08 sll %g3, 8, %g3 <== NOT EXECUTED
2026e30: 85 28 a0 10 sll %g2, 0x10, %g2 <== NOT EXECUTED
2026e34: c2 0f bf 97 ldub [ %fp + -105 ], %g1 <== NOT EXECUTED
2026e38: 84 10 c0 02 or %g3, %g2, %g2 <== NOT EXECUTED
2026e3c: c6 0f bf 9f ldub [ %fp + -97 ], %g3 <== NOT EXECUTED
2026e40: 84 10 80 03 or %g2, %g3, %g2 <== NOT EXECUTED
2026e44: 87 28 60 18 sll %g1, 0x18, %g3 <== NOT EXECUTED
2026e48: 84 10 80 03 or %g2, %g3, %g2 <== NOT EXECUTED
2026e4c: c4 24 20 38 st %g2, [ %l0 + 0x38 ] <== NOT EXECUTED
vol->mirror = FAT_GET_BR_EXT_FLAGS(boot_rec) & FAT_BR_EXT_FLAGS_MIRROR;
2026e50: 84 0e ff 80 and %i3, -128, %g2 <== NOT EXECUTED
if (vol->mirror)
2026e54: 80 88 a0 80 btst 0x80, %g2 <== NOT EXECUTED
2026e58: 02 80 00 05 be 2026e6c <fat_init_volume_info+0x484> <== NOT EXECUTED
2026e5c: c4 2c 20 48 stb %g2, [ %l0 + 0x48 ] <== NOT EXECUTED
vol->afat = FAT_GET_BR_EXT_FLAGS(boot_rec) & FAT_BR_EXT_FLAGS_FAT_NUM;
2026e60: b6 0e e0 0f and %i3, 0xf, %i3 <== NOT EXECUTED
2026e64: 10 80 00 03 b 2026e70 <fat_init_volume_info+0x488> <== NOT EXECUTED
2026e68: f6 2c 20 50 stb %i3, [ %l0 + 0x50 ] <== NOT EXECUTED
else
vol->afat = 0;
2026e6c: c0 2c 20 50 clrb [ %l0 + 0x50 ] <== NOT EXECUTED
vol->info_sec = FAT_GET_BR_FAT32_FS_INFO_SECTOR(boot_rec);
2026e70: d2 0f bf 9b ldub [ %fp + -101 ], %o1 <== NOT EXECUTED
2026e74: c4 0f bf 9c ldub [ %fp + -100 ], %g2 <== NOT EXECUTED
2026e78: 93 2a 60 08 sll %o1, 8, %o1 <== NOT EXECUTED
2026e7c: 92 12 40 02 or %o1, %g2, %o1 <== NOT EXECUTED
2026e80: d2 34 20 3c sth %o1, [ %l0 + 0x3c ] <== NOT EXECUTED
if( vol->info_sec == 0 )
2026e84: 93 2a 60 10 sll %o1, 0x10, %o1 <== NOT EXECUTED
2026e88: 93 32 60 10 srl %o1, 0x10, %o1 <== NOT EXECUTED
2026e8c: 80 a2 60 00 cmp %o1, 0 <== NOT EXECUTED
2026e90: 32 80 00 03 bne,a 2026e9c <fat_init_volume_info+0x4b4> <== NOT EXECUTED
2026e94: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
2026e98: 30 80 00 18 b,a 2026ef8 <fat_init_volume_info+0x510> <== NOT EXECUTED
close(vol->fd);
rtems_set_errno_and_return_minus_one( EINVAL );
}
else
{
ret = _fat_block_read(fs_info, vol->info_sec , 0,
2026e9c: 94 10 20 00 clr %o2 <== NOT EXECUTED
2026ea0: 96 10 20 04 mov 4, %o3 <== NOT EXECUTED
2026ea4: 7f ff fd 6b call 2026450 <_fat_block_read> <== NOT EXECUTED
2026ea8: 98 07 bf a8 add %fp, -88, %o4 <== NOT EXECUTED
FAT_FSI_LEADSIG_SIZE, fs_info_sector);
if ( ret < 0 )
2026eac: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2026eb0: 06 80 00 22 bl 2026f38 <fat_init_volume_info+0x550> <== NOT EXECUTED
2026eb4: c4 0f bf aa ldub [ %fp + -86 ], %g2 <== NOT EXECUTED
{
close(vol->fd);
return -1;
}
if (FAT_GET_FSINFO_LEAD_SIGNATURE(fs_info_sector) !=
2026eb8: c6 0f bf a9 ldub [ %fp + -87 ], %g3 <== NOT EXECUTED
2026ebc: 85 28 a0 10 sll %g2, 0x10, %g2 <== NOT EXECUTED
2026ec0: 87 28 e0 08 sll %g3, 8, %g3 <== NOT EXECUTED
2026ec4: 86 10 c0 02 or %g3, %g2, %g3 <== NOT EXECUTED
2026ec8: c4 0f bf a8 ldub [ %fp + -88 ], %g2 <== NOT EXECUTED
2026ecc: 86 10 c0 02 or %g3, %g2, %g3 <== NOT EXECUTED
2026ed0: c4 0f bf ab ldub [ %fp + -85 ], %g2 <== NOT EXECUTED
2026ed4: 85 28 a0 18 sll %g2, 0x18, %g2 <== NOT EXECUTED
2026ed8: 86 10 c0 02 or %g3, %g2, %g3 <== NOT EXECUTED
2026edc: 05 10 58 54 sethi %hi(0x41615000), %g2 <== NOT EXECUTED
2026ee0: 84 10 a2 52 or %g2, 0x252, %g2 ! 41615252 <RAM_END+0x3f215252><== NOT EXECUTED
2026ee4: 80 a0 c0 02 cmp %g3, %g2 <== NOT EXECUTED
2026ee8: 02 80 00 0a be 2026f10 <fat_init_volume_info+0x528> <== NOT EXECUTED
2026eec: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
FAT_FSINFO_LEAD_SIGNATURE_VALUE)
{
_fat_block_release(fs_info);
2026ef0: 7f ff fd c3 call 20265fc <_fat_block_release> <== NOT EXECUTED
2026ef4: 01 00 00 00 nop <== NOT EXECUTED
close(vol->fd);
2026ef8: 7f ff 86 83 call 2008904 <close> <== NOT EXECUTED
2026efc: d0 04 20 54 ld [ %l0 + 0x54 ], %o0 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
2026f00: 40 00 6c bb call 20421ec <__errno> <== NOT EXECUTED
2026f04: 01 00 00 00 nop <== NOT EXECUTED
2026f08: 10 80 00 8d b 202713c <fat_init_volume_info+0x754> <== NOT EXECUTED
2026f0c: 82 10 20 16 mov 0x16, %g1 ! 16 <PROM_START+0x16> <== NOT EXECUTED
}
else
{
ret = _fat_block_read(fs_info, vol->info_sec , FAT_FSI_INFO,
2026f10: d2 14 20 3c lduh [ %l0 + 0x3c ], %o1 <== NOT EXECUTED
2026f14: 94 10 21 e4 mov 0x1e4, %o2 <== NOT EXECUTED
2026f18: 96 10 20 0c mov 0xc, %o3 <== NOT EXECUTED
2026f1c: 7f ff fd 4d call 2026450 <_fat_block_read> <== NOT EXECUTED
2026f20: 98 07 bf a8 add %fp, -88, %o4 <== NOT EXECUTED
FAT_USEFUL_INFO_SIZE, fs_info_sector);
if ( ret < 0 )
2026f24: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2026f28: 16 80 00 08 bge 2026f48 <fat_init_volume_info+0x560> <== NOT EXECUTED
2026f2c: c6 0f bf ad ldub [ %fp + -83 ], %g3 <== NOT EXECUTED
{
_fat_block_release(fs_info);
2026f30: 7f ff fd b3 call 20265fc <_fat_block_release> <== NOT EXECUTED
2026f34: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
close(vol->fd);
2026f38: 7f ff 86 73 call 2008904 <close> <== NOT EXECUTED
2026f3c: d0 04 20 54 ld [ %l0 + 0x54 ], %o0 <== NOT EXECUTED
{
close(vol->fd);
free(fs_info->vhash);
free(fs_info->rhash);
free(fs_info->uino);
rtems_set_errno_and_return_minus_one( ENOMEM );
2026f40: 10 80 00 81 b 2027144 <fat_init_volume_info+0x75c> <== NOT EXECUTED
2026f44: ba 10 3f ff mov -1, %i5 <== NOT EXECUTED
_fat_block_release(fs_info);
close(vol->fd);
return -1;
}
vol->free_cls = FAT_GET_FSINFO_FREE_CLUSTER_COUNT(fs_info_sector);
2026f48: c4 0f bf ae ldub [ %fp + -82 ], %g2 <== NOT EXECUTED
2026f4c: 87 28 e0 08 sll %g3, 8, %g3 <== NOT EXECUTED
2026f50: 85 28 a0 10 sll %g2, 0x10, %g2 <== NOT EXECUTED
2026f54: 84 10 c0 02 or %g3, %g2, %g2 <== NOT EXECUTED
2026f58: c6 0f bf ac ldub [ %fp + -84 ], %g3 <== NOT EXECUTED
vol->next_cl = FAT_GET_FSINFO_NEXT_FREE_CLUSTER(fs_info_sector);
rc = fat_fat32_update_fsinfo_sector(fs_info, 0xFFFFFFFF,
2026f5c: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
_fat_block_release(fs_info);
close(vol->fd);
return -1;
}
vol->free_cls = FAT_GET_FSINFO_FREE_CLUSTER_COUNT(fs_info_sector);
2026f60: 84 10 80 03 or %g2, %g3, %g2 <== NOT EXECUTED
2026f64: c6 0f bf af ldub [ %fp + -81 ], %g3 <== NOT EXECUTED
vol->next_cl = FAT_GET_FSINFO_NEXT_FREE_CLUSTER(fs_info_sector);
rc = fat_fat32_update_fsinfo_sector(fs_info, 0xFFFFFFFF,
2026f68: 92 10 3f ff mov -1, %o1 <== NOT EXECUTED
_fat_block_release(fs_info);
close(vol->fd);
return -1;
}
vol->free_cls = FAT_GET_FSINFO_FREE_CLUSTER_COUNT(fs_info_sector);
2026f6c: 87 28 e0 18 sll %g3, 0x18, %g3 <== NOT EXECUTED
2026f70: 84 10 80 03 or %g2, %g3, %g2 <== NOT EXECUTED
vol->next_cl = FAT_GET_FSINFO_NEXT_FREE_CLUSTER(fs_info_sector);
2026f74: c6 0f bf b1 ldub [ %fp + -79 ], %g3 <== NOT EXECUTED
_fat_block_release(fs_info);
close(vol->fd);
return -1;
}
vol->free_cls = FAT_GET_FSINFO_FREE_CLUSTER_COUNT(fs_info_sector);
2026f78: c4 24 20 40 st %g2, [ %l0 + 0x40 ] <== NOT EXECUTED
vol->next_cl = FAT_GET_FSINFO_NEXT_FREE_CLUSTER(fs_info_sector);
2026f7c: c4 0f bf b2 ldub [ %fp + -78 ], %g2 <== NOT EXECUTED
2026f80: 87 28 e0 08 sll %g3, 8, %g3 <== NOT EXECUTED
2026f84: 85 28 a0 10 sll %g2, 0x10, %g2 <== NOT EXECUTED
2026f88: 84 10 c0 02 or %g3, %g2, %g2 <== NOT EXECUTED
2026f8c: c6 0f bf b0 ldub [ %fp + -80 ], %g3 <== NOT EXECUTED
rc = fat_fat32_update_fsinfo_sector(fs_info, 0xFFFFFFFF,
2026f90: 94 10 3f ff mov -1, %o2 <== NOT EXECUTED
close(vol->fd);
return -1;
}
vol->free_cls = FAT_GET_FSINFO_FREE_CLUSTER_COUNT(fs_info_sector);
vol->next_cl = FAT_GET_FSINFO_NEXT_FREE_CLUSTER(fs_info_sector);
2026f94: 84 10 80 03 or %g2, %g3, %g2 <== NOT EXECUTED
2026f98: c6 0f bf b3 ldub [ %fp + -77 ], %g3 <== NOT EXECUTED
2026f9c: 87 28 e0 18 sll %g3, 0x18, %g3 <== NOT EXECUTED
2026fa0: 84 10 80 03 or %g2, %g3, %g2 <== NOT EXECUTED
rc = fat_fat32_update_fsinfo_sector(fs_info, 0xFFFFFFFF,
2026fa4: 7f ff fe 2f call 2026860 <fat_fat32_update_fsinfo_sector> <== NOT EXECUTED
2026fa8: c4 24 20 44 st %g2, [ %l0 + 0x44 ] <== NOT EXECUTED
0xFFFFFFFF);
if ( rc != RC_OK )
2026fac: b8 92 20 00 orcc %o0, 0, %i4 <== NOT EXECUTED
2026fb0: 02 80 00 0e be 2026fe8 <fat_init_volume_info+0x600> <== NOT EXECUTED
2026fb4: 01 00 00 00 nop <== NOT EXECUTED
{
_fat_block_release(fs_info);
2026fb8: 7f ff fd 91 call 20265fc <_fat_block_release> <== NOT EXECUTED
2026fbc: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
close(vol->fd);
2026fc0: d0 04 20 54 ld [ %l0 + 0x54 ], %o0 <== NOT EXECUTED
2026fc4: 7f ff 86 50 call 2008904 <close> <== NOT EXECUTED
2026fc8: ba 10 00 1c mov %i4, %i5 <== NOT EXECUTED
free(fs_info->uino);
rtems_set_errno_and_return_minus_one( ENOMEM );
}
return RC_OK;
}
2026fcc: 81 c7 e0 08 ret <== NOT EXECUTED
2026fd0: 91 e8 00 1d restore %g0, %i5, %o0 <== NOT EXECUTED
}
}
}
else
{
vol->rdir_cl = 0;
2026fd4: c0 24 20 38 clr [ %l0 + 0x38 ]
vol->mirror = 0;
2026fd8: c0 2c 20 48 clrb [ %l0 + 0x48 ]
vol->afat = 0;
2026fdc: c0 2c 20 50 clrb [ %l0 + 0x50 ]
vol->free_cls = 0xFFFFFFFF;
2026fe0: c2 24 20 40 st %g1, [ %l0 + 0x40 ]
vol->next_cl = 0xFFFFFFFF;
2026fe4: c2 24 20 44 st %g1, [ %l0 + 0x44 ]
}
_fat_block_release(fs_info);
2026fe8: 7f ff fd 85 call 20265fc <_fat_block_release>
2026fec: 90 10 00 10 mov %l0, %o0
vol->afat_loc = vol->fat_loc + vol->fat_length * vol->afat;
2026ff0: d2 04 20 18 ld [ %l0 + 0x18 ], %o1
2026ff4: 7f ff 6f 9c call 2002e64 <.umul>
2026ff8: d0 0c 20 50 ldub [ %l0 + 0x50 ], %o0
2026ffc: c4 14 20 14 lduh [ %l0 + 0x14 ], %g2
/* set up collection of fat-files fd */
fs_info->vhash = calloc(FAT_HASH_SIZE, sizeof(rtems_chain_control));
2027000: 92 10 20 0c mov 0xc, %o1
vol->next_cl = 0xFFFFFFFF;
}
_fat_block_release(fs_info);
vol->afat_loc = vol->fat_loc + vol->fat_length * vol->afat;
2027004: 90 02 00 02 add %o0, %g2, %o0
2027008: d0 24 20 4c st %o0, [ %l0 + 0x4c ]
/* set up collection of fat-files fd */
fs_info->vhash = calloc(FAT_HASH_SIZE, sizeof(rtems_chain_control));
202700c: 7f ff 86 18 call 200886c <calloc>
2027010: 90 10 20 02 mov 2, %o0
if ( fs_info->vhash == NULL )
2027014: 80 a2 20 00 cmp %o0, 0
2027018: 02 80 00 12 be 2027060 <fat_init_volume_info+0x678> <== NEVER TAKEN
202701c: d0 24 20 60 st %o0, [ %l0 + 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 );
2027020: 84 02 20 04 add %o0, 4, %g2
2027024: 86 02 20 10 add %o0, 0x10, %g3
head->next = tail;
2027028: c4 22 00 00 st %g2, [ %o0 ]
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 );
202702c: 84 02 20 0c add %o0, 0xc, %g2
head->next = tail;
head->previous = NULL;
2027030: c0 22 20 04 clr [ %o0 + 4 ]
tail->previous = head;
2027034: d0 22 20 08 st %o0, [ %o0 + 8 ]
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
2027038: c6 22 20 0c st %g3, [ %o0 + 0xc ]
head->previous = NULL;
202703c: c0 22 20 10 clr [ %o0 + 0x10 ]
tail->previous = head;
2027040: c4 22 20 14 st %g2, [ %o0 + 0x14 ]
}
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));
2027044: 92 10 20 0c mov 0xc, %o1
2027048: 7f ff 86 09 call 200886c <calloc>
202704c: 90 10 20 02 mov 2, %o0
if ( fs_info->rhash == NULL )
2027050: 80 a2 20 00 cmp %o0, 0
2027054: 12 80 00 06 bne 202706c <fat_init_volume_info+0x684> <== ALWAYS TAKEN
2027058: d0 24 20 64 st %o0, [ %l0 + 0x64 ]
202705c: 30 80 00 1c b,a 20270cc <fat_init_volume_info+0x6e4> <== 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 )
{
close(vol->fd);
2027060: 7f ff 86 29 call 2008904 <close> <== NOT EXECUTED
2027064: d0 04 20 54 ld [ %l0 + 0x54 ], %o0 <== NOT EXECUTED
2027068: 30 80 00 32 b,a 2027130 <fat_init_volume_info+0x748> <== 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 );
202706c: 84 02 20 04 add %o0, 4, %g2
head->next = tail;
2027070: c4 22 00 00 st %g2, [ %o0 ]
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 );
2027074: 84 02 20 0c add %o0, 0xc, %g2
head->next = tail;
head->previous = NULL;
2027078: c0 22 20 04 clr [ %o0 + 4 ]
tail->previous = head;
202707c: c4 22 20 14 st %g2, [ %o0 + 0x14 ]
2027080: d0 22 20 08 st %o0, [ %o0 + 8 ]
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
head->previous = NULL;
2027084: c0 22 20 10 clr [ %o0 + 0x10 ]
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 );
2027088: 86 02 20 10 add %o0, 0x10, %g3
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;
202708c: 84 10 21 00 mov 0x100, %g2
head->next = tail;
2027090: c6 22 20 0c st %g3, [ %o0 + 0xc ]
2027094: c4 24 20 70 st %g2, [ %l0 + 0x70 ]
fs_info->uino_base = (vol->tot_secs << vol->sec_mul) << 4;
2027098: c6 04 20 2c ld [ %l0 + 0x2c ], %g3
202709c: c4 0c 20 03 ldub [ %l0 + 3 ], %g2
fs_info->index = 0;
20270a0: c0 24 20 6c clr [ %l0 + 0x6c ]
}
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;
20270a4: 85 28 c0 02 sll %g3, %g2, %g2
20270a8: 85 28 a0 04 sll %g2, 4, %g2
fs_info->index = 0;
fs_info->uino = (char *)calloc(fs_info->uino_pool_size, sizeof(char));
20270ac: 90 10 21 00 mov 0x100, %o0
}
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;
20270b0: c4 24 20 74 st %g2, [ %l0 + 0x74 ]
fs_info->index = 0;
fs_info->uino = (char *)calloc(fs_info->uino_pool_size, sizeof(char));
20270b4: 7f ff 85 ee call 200886c <calloc>
20270b8: 92 10 20 01 mov 1, %o1
if ( fs_info->uino == NULL )
20270bc: 80 a2 20 00 cmp %o0, 0
20270c0: 12 80 00 0d bne 20270f4 <fat_init_volume_info+0x70c> <== ALWAYS TAKEN
20270c4: d0 24 20 68 st %o0, [ %l0 + 0x68 ]
20270c8: 30 80 00 05 b,a 20270dc <fat_init_volume_info+0x6f4> <== 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 )
{
close(vol->fd);
20270cc: 7f ff 86 0e call 2008904 <close> <== NOT EXECUTED
20270d0: d0 04 20 54 ld [ %l0 + 0x54 ], %o0 <== NOT EXECUTED
free(fs_info->vhash);
20270d4: 10 80 00 15 b 2027128 <fat_init_volume_info+0x740> <== NOT EXECUTED
20270d8: d0 04 20 60 ld [ %l0 + 0x60 ], %o0 <== 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 )
{
close(vol->fd);
20270dc: 7f ff 86 0a call 2008904 <close> <== NOT EXECUTED
20270e0: d0 04 20 54 ld [ %l0 + 0x54 ], %o0 <== NOT EXECUTED
free(fs_info->vhash);
20270e4: 7f ff 86 c6 call 2008bfc <free> <== NOT EXECUTED
20270e8: d0 04 20 60 ld [ %l0 + 0x60 ], %o0 <== NOT EXECUTED
free(fs_info->rhash);
20270ec: 10 80 00 0f b 2027128 <fat_init_volume_info+0x740> <== NOT EXECUTED
20270f0: d0 04 20 64 ld [ %l0 + 0x64 ], %o0 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOMEM );
}
fs_info->sec_buf = (uint8_t *)calloc(vol->bps, sizeof(uint8_t));
20270f4: d0 14 00 00 lduh [ %l0 ], %o0
20270f8: 7f ff 85 dd call 200886c <calloc>
20270fc: 92 10 20 01 mov 1, %o1
if (fs_info->sec_buf == NULL)
2027100: 80 a2 20 00 cmp %o0, 0
2027104: 12 80 00 10 bne 2027144 <fat_init_volume_info+0x75c> <== ALWAYS TAKEN
2027108: d0 24 20 84 st %o0, [ %l0 + 0x84 ]
{
close(vol->fd);
202710c: 7f ff 85 fe call 2008904 <close> <== NOT EXECUTED
2027110: d0 04 20 54 ld [ %l0 + 0x54 ], %o0 <== NOT EXECUTED
free(fs_info->vhash);
2027114: 7f ff 86 ba call 2008bfc <free> <== NOT EXECUTED
2027118: d0 04 20 60 ld [ %l0 + 0x60 ], %o0 <== NOT EXECUTED
free(fs_info->rhash);
202711c: 7f ff 86 b8 call 2008bfc <free> <== NOT EXECUTED
2027120: d0 04 20 64 ld [ %l0 + 0x64 ], %o0 <== NOT EXECUTED
free(fs_info->uino);
2027124: d0 04 20 68 ld [ %l0 + 0x68 ], %o0 <== NOT EXECUTED
2027128: 7f ff 86 b5 call 2008bfc <free> <== NOT EXECUTED
202712c: 01 00 00 00 nop <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOMEM );
2027130: 40 00 6c 2f call 20421ec <__errno> <== NOT EXECUTED
2027134: 01 00 00 00 nop <== NOT EXECUTED
2027138: 82 10 20 0c mov 0xc, %g1 ! c <PROM_START+0xc> <== NOT EXECUTED
202713c: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
2027140: ba 10 3f ff mov -1, %i5 <== NOT EXECUTED
}
return RC_OK;
}
2027144: b0 10 00 1d mov %i5, %i0
2027148: 81 c7 e0 08 ret
202714c: 81 e8 00 00 restore
0203e114 <fat_scan_fat_for_free_clusters>:
uint32_t count,
uint32_t *cls_added,
uint32_t *last_cl,
bool zero_fill
)
{
203e114: 9d e3 bf 98 save %sp, -104, %sp
int rc = RC_OK;
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;
203e118: e8 06 20 34 ld [ %i0 + 0x34 ], %l4
bool zero_fill
)
{
int rc = RC_OK;
uint32_t cl4find = 2;
uint32_t next_cln = 0;
203e11c: c0 27 bf fc clr [ %fp + -4 ]
uint32_t save_cln = 0;
uint32_t data_cls_val = fs_info->vol.data_cls + 2;
uint32_t i = 2;
*cls_added = 0;
203e120: c0 26 c0 00 clr [ %i3 ]
if (count == 0)
203e124: 80 a6 a0 00 cmp %i2, 0
203e128: 02 80 00 87 be 203e344 <fat_scan_fat_for_free_clusters+0x230><== NEVER TAKEN
203e12c: a2 10 20 00 clr %l1
return rc;
if (fs_info->vol.next_cl != FAT_UNDEFINED_VALUE)
203e130: e0 06 20 44 ld [ %i0 + 0x44 ], %l0
203e134: 80 a4 3f ff cmp %l0, -1
203e138: 22 80 00 02 be,a 203e140 <fat_scan_fat_for_free_clusters+0x2c>
203e13c: a0 10 20 02 mov 2, %l0
{
int rc = RC_OK;
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;
203e140: a8 05 20 02 add %l4, 2, %l4
203e144: a6 10 20 02 mov 2, %l3
203e148: 10 80 00 64 b 203e2d8 <fat_scan_fat_for_free_clusters+0x1c4>
203e14c: a4 10 20 00 clr %l2
* 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(fs_info, cl4find, &next_cln);
203e150: 92 10 00 10 mov %l0, %o1
203e154: 7f ff fe 9b call 203dbc0 <fat_get_fat_cluster>
203e158: 94 07 bf fc add %fp, -4, %o2
if ( rc != RC_OK )
203e15c: a2 92 20 00 orcc %o0, 0, %l1
203e160: 02 80 00 0b be 203e18c <fat_scan_fat_for_free_clusters+0x78><== ALWAYS TAKEN
203e164: c2 07 bf fc ld [ %fp + -4 ], %g1
{
if (*cls_added != 0)
203e168: c2 06 c0 00 ld [ %i3 ], %g1 <== NOT EXECUTED
203e16c: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
203e170: 22 80 00 76 be,a 203e348 <fat_scan_fat_for_free_clusters+0x234><== NOT EXECUTED
203e174: b0 10 00 11 mov %l1, %i0 <== NOT EXECUTED
fat_free_fat_clusters_chain(fs_info, (*chain));
203e178: d2 06 40 00 ld [ %i1 ], %o1 <== NOT EXECUTED
203e17c: 7f ff ff b7 call 203e058 <fat_free_fat_clusters_chain> <== NOT EXECUTED
203e180: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
fat_free_fat_clusters_chain(fs_info, (*chain));
/* trying to save last allocated cluster for future use */
fat_set_fat_cluster(fs_info, cl4find, FAT_GENFAT_FREE);
fat_buf_release(fs_info);
return rc;
}
203e184: 81 c7 e0 08 ret <== NOT EXECUTED
203e188: 91 e8 00 11 restore %g0, %l1, %o0 <== NOT EXECUTED
if (*cls_added != 0)
fat_free_fat_clusters_chain(fs_info, (*chain));
return rc;
}
if (next_cln == FAT_GENFAT_FREE)
203e18c: 80 a0 60 00 cmp %g1, 0
203e190: 32 80 00 4e bne,a 203e2c8 <fat_scan_fat_for_free_clusters+0x1b4>
203e194: a0 04 20 01 inc %l0
/*
* 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)
203e198: c2 06 c0 00 ld [ %i3 ], %g1
203e19c: 80 a0 60 00 cmp %g1, 0
203e1a0: 12 80 00 0e bne 203e1d8 <fat_scan_fat_for_free_clusters+0xc4>
203e1a4: 90 10 00 18 mov %i0, %o0
{
*chain = cl4find;
203e1a8: e0 26 40 00 st %l0, [ %i1 ]
rc = fat_set_fat_cluster(fs_info, cl4find, FAT_GENFAT_EOC);
203e1ac: 92 10 00 10 mov %l0, %o1
203e1b0: 7f ff fe fb call 203dd9c <fat_set_fat_cluster>
203e1b4: 94 10 3f ff mov -1, %o2
if ( rc != RC_OK )
203e1b8: 80 a2 20 00 cmp %o0, 0
203e1bc: 32 80 00 62 bne,a 203e344 <fat_scan_fat_for_free_clusters+0x230><== NEVER TAKEN
203e1c0: a2 10 00 08 mov %o0, %l1 <== NOT EXECUTED
rc = fat_set_fat_cluster(fs_info, save_cln, cl4find);
if ( rc != RC_OK )
goto cleanup;
}
if (zero_fill) {
203e1c4: 80 a7 60 00 cmp %i5, 0
203e1c8: 22 80 00 18 be,a 203e228 <fat_scan_fat_for_free_clusters+0x114>
203e1cc: c2 06 c0 00 ld [ %i3 ], %g1
fat_cluster_num_to_sector_num(
const fat_fs_info_t *fs_info,
uint32_t cln
)
{
if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
203e1d0: 10 80 00 1c b 203e240 <fat_scan_fat_for_free_clusters+0x12c>
203e1d4: 80 a4 20 00 cmp %l0, 0
}
}
else
{
/* set EOC value to new allocated cluster */
rc = fat_set_fat_cluster(fs_info, cl4find, FAT_GENFAT_EOC);
203e1d8: 92 10 00 10 mov %l0, %o1
203e1dc: 7f ff fe f0 call 203dd9c <fat_set_fat_cluster>
203e1e0: 94 10 3f ff mov -1, %o2
203e1e4: aa 10 00 08 mov %o0, %l5
if ( rc != RC_OK )
203e1e8: 80 a5 60 00 cmp %l5, 0
203e1ec: 02 80 00 07 be 203e208 <fat_scan_fat_for_free_clusters+0xf4><== ALWAYS TAKEN
203e1f0: 90 10 00 18 mov %i0, %o0
{
/* cleanup activity */
fat_free_fat_clusters_chain(fs_info, (*chain));
203e1f4: d2 06 40 00 ld [ %i1 ], %o1 <== NOT EXECUTED
203e1f8: 7f ff ff 98 call 203e058 <fat_free_fat_clusters_chain> <== NOT EXECUTED
203e1fc: a2 10 00 15 mov %l5, %l1 <== NOT EXECUTED
fat_free_fat_clusters_chain(fs_info, (*chain));
/* trying to save last allocated cluster for future use */
fat_set_fat_cluster(fs_info, cl4find, FAT_GENFAT_FREE);
fat_buf_release(fs_info);
return rc;
}
203e200: 81 c7 e0 08 ret <== NOT EXECUTED
203e204: 91 e8 00 11 restore %g0, %l1, %o0 <== NOT EXECUTED
/* cleanup activity */
fat_free_fat_clusters_chain(fs_info, (*chain));
return rc;
}
rc = fat_set_fat_cluster(fs_info, save_cln, cl4find);
203e208: 92 10 00 12 mov %l2, %o1
203e20c: 7f ff fe e4 call 203dd9c <fat_set_fat_cluster>
203e210: 94 10 00 10 mov %l0, %o2
if ( rc != RC_OK )
203e214: a4 92 20 00 orcc %o0, 0, %l2
203e218: 02 bf ff ec be 203e1c8 <fat_scan_fat_for_free_clusters+0xb4><== ALWAYS TAKEN
203e21c: 80 a7 60 00 cmp %i5, 0
return RC_OK;
cleanup:
/* cleanup activity */
fat_free_fat_clusters_chain(fs_info, (*chain));
203e220: 10 80 00 3e b 203e318 <fat_scan_fat_for_free_clusters+0x204><== NOT EXECUTED
203e224: d2 06 40 00 ld [ %i1 ], %o1 <== NOT EXECUTED
if ( rc != RC_OK )
goto cleanup;
}
save_cln = cl4find;
(*cls_added)++;
203e228: 82 00 60 01 inc %g1
/* have we satisfied request ? */
if (*cls_added == count)
203e22c: 80 a0 40 1a cmp %g1, %i2
203e230: 02 80 00 19 be 203e294 <fat_scan_fat_for_free_clusters+0x180>
203e234: c2 26 c0 00 st %g1, [ %i3 ]
203e238: 10 80 00 23 b 203e2c4 <fat_scan_fat_for_free_clusters+0x1b0>
203e23c: a4 10 00 10 mov %l0, %l2
203e240: 32 80 00 08 bne,a 203e260 <fat_scan_fat_for_free_clusters+0x14c><== ALWAYS TAKEN
203e244: c2 0e 20 05 ldub [ %i0 + 5 ], %g1
203e248: c2 0e 20 0a ldub [ %i0 + 0xa ], %g1 <== NOT EXECUTED
203e24c: 80 88 60 03 btst 3, %g1 <== NOT EXECUTED
203e250: 22 80 00 04 be,a 203e260 <fat_scan_fat_for_free_clusters+0x14c><== NOT EXECUTED
203e254: c2 0e 20 05 ldub [ %i0 + 5 ], %g1 <== NOT EXECUTED
return fs_info->vol.rdir_loc;
203e258: 10 80 00 06 b 203e270 <fat_scan_fat_for_free_clusters+0x15c><== NOT EXECUTED
203e25c: d2 06 20 1c ld [ %i0 + 0x1c ], %o1 <== NOT EXECUTED
return (((cln - FAT_RSRVD_CLN) << fs_info->vol.spc_log2) +
203e260: 92 04 3f fe add %l0, -2, %o1
203e264: 93 2a 40 01 sll %o1, %g1, %o1
203e268: c2 06 20 30 ld [ %i0 + 0x30 ], %g1
203e26c: 92 02 40 01 add %o1, %g1, %o1
if (zero_fill) {
uint32_t sec = fat_cluster_num_to_sector_num(fs_info,
cl4find);
rc = _fat_block_zero(fs_info, sec, 0, fs_info->vol.bpc);
203e270: d6 16 20 06 lduh [ %i0 + 6 ], %o3
203e274: 90 10 00 18 mov %i0, %o0
203e278: 7f ff a0 be call 2026570 <_fat_block_zero>
203e27c: 94 10 20 00 clr %o2
if ( rc != RC_OK )
203e280: a4 92 20 00 orcc %o0, 0, %l2
203e284: 22 bf ff e9 be,a 203e228 <fat_scan_fat_for_free_clusters+0x114><== ALWAYS TAKEN
203e288: c2 06 c0 00 ld [ %i3 ], %g1
return RC_OK;
cleanup:
/* cleanup activity */
fat_free_fat_clusters_chain(fs_info, (*chain));
203e28c: 10 80 00 23 b 203e318 <fat_scan_fat_for_free_clusters+0x204><== NOT EXECUTED
203e290: d2 06 40 00 ld [ %i1 ], %o1 <== NOT EXECUTED
/* have we satisfied request ? */
if (*cls_added == count)
{
fs_info->vol.next_cl = save_cln;
if (fs_info->vol.free_cls != 0xFFFFFFFF)
203e294: c2 06 20 40 ld [ %i0 + 0x40 ], %g1
203e298: 80 a0 7f ff cmp %g1, -1
203e29c: 02 80 00 05 be 203e2b0 <fat_scan_fat_for_free_clusters+0x19c><== ALWAYS TAKEN
203e2a0: e0 26 20 44 st %l0, [ %i0 + 0x44 ]
fs_info->vol.free_cls -= (*cls_added);
203e2a4: c4 06 c0 00 ld [ %i3 ], %g2 <== NOT EXECUTED
203e2a8: 82 20 40 02 sub %g1, %g2, %g1 <== NOT EXECUTED
203e2ac: c2 26 20 40 st %g1, [ %i0 + 0x40 ] <== NOT EXECUTED
*last_cl = save_cln;
203e2b0: e0 27 00 00 st %l0, [ %i4 ]
fat_buf_release(fs_info);
203e2b4: 7f ff a0 0f call 20262f0 <fat_buf_release>
203e2b8: 90 10 00 18 mov %i0, %o0
fat_free_fat_clusters_chain(fs_info, (*chain));
/* trying to save last allocated cluster for future use */
fat_set_fat_cluster(fs_info, cl4find, FAT_GENFAT_FREE);
fat_buf_release(fs_info);
return rc;
}
203e2bc: 81 c7 e0 08 ret
203e2c0: 91 e8 00 11 restore %g0, %l1, %o0
fat_buf_release(fs_info);
return rc;
}
}
i++;
cl4find++;
203e2c4: a0 04 20 01 inc %l0
if (cl4find >= data_cls_val)
203e2c8: 80 a4 00 14 cmp %l0, %l4
203e2cc: 0a 80 00 03 bcs 203e2d8 <fat_scan_fat_for_free_clusters+0x1c4><== ALWAYS TAKEN
203e2d0: a6 04 e0 01 inc %l3
cl4find = 2;
203e2d4: a0 10 20 02 mov 2, %l0 <== 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)
203e2d8: 80 a4 c0 14 cmp %l3, %l4
203e2dc: 0a bf ff 9d bcs 203e150 <fat_scan_fat_for_free_clusters+0x3c><== ALWAYS TAKEN
203e2e0: 90 10 00 18 mov %i0, %o0
if (cl4find >= data_cls_val)
cl4find = 2;
}
fs_info->vol.next_cl = save_cln;
if (fs_info->vol.free_cls != 0xFFFFFFFF)
203e2e4: c2 06 20 40 ld [ %i0 + 0x40 ], %g1 <== NOT EXECUTED
203e2e8: 80 a0 7f ff cmp %g1, -1 <== NOT EXECUTED
203e2ec: 02 80 00 05 be 203e300 <fat_scan_fat_for_free_clusters+0x1ec><== NOT EXECUTED
203e2f0: e4 26 20 44 st %l2, [ %i0 + 0x44 ] <== NOT EXECUTED
fs_info->vol.free_cls -= (*cls_added);
203e2f4: c4 06 c0 00 ld [ %i3 ], %g2 <== NOT EXECUTED
203e2f8: 82 20 40 02 sub %g1, %g2, %g1 <== NOT EXECUTED
203e2fc: c2 26 20 40 st %g1, [ %i0 + 0x40 ] <== NOT EXECUTED
*last_cl = save_cln;
203e300: e4 27 00 00 st %l2, [ %i4 ] <== NOT EXECUTED
fat_buf_release(fs_info);
203e304: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
203e308: 7f ff 9f fa call 20262f0 <fat_buf_release> <== NOT EXECUTED
203e30c: a2 10 20 00 clr %l1 <== NOT EXECUTED
fat_free_fat_clusters_chain(fs_info, (*chain));
/* trying to save last allocated cluster for future use */
fat_set_fat_cluster(fs_info, cl4find, FAT_GENFAT_FREE);
fat_buf_release(fs_info);
return rc;
}
203e310: 81 c7 e0 08 ret <== NOT EXECUTED
203e314: 91 e8 00 11 restore %g0, %l1, %o0 <== NOT EXECUTED
return RC_OK;
cleanup:
/* cleanup activity */
fat_free_fat_clusters_chain(fs_info, (*chain));
203e318: 7f ff ff 50 call 203e058 <fat_free_fat_clusters_chain> <== NOT EXECUTED
203e31c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
/* trying to save last allocated cluster for future use */
fat_set_fat_cluster(fs_info, cl4find, FAT_GENFAT_FREE);
203e320: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED
203e324: 94 10 20 00 clr %o2 <== NOT EXECUTED
203e328: 7f ff fe 9d call 203dd9c <fat_set_fat_cluster> <== NOT EXECUTED
203e32c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
fat_buf_release(fs_info);
203e330: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
203e334: 7f ff 9f ef call 20262f0 <fat_buf_release> <== NOT EXECUTED
203e338: a2 10 00 12 mov %l2, %l1 <== NOT EXECUTED
return rc;
}
203e33c: 81 c7 e0 08 ret <== NOT EXECUTED
203e340: 91 e8 00 11 restore %g0, %l1, %o0 <== NOT EXECUTED
203e344: b0 10 00 11 mov %l1, %i0 <== NOT EXECUTED
203e348: 81 c7 e0 08 ret <== NOT EXECUTED
203e34c: 81 e8 00 00 restore <== NOT EXECUTED
0203dd9c <fat_set_fat_cluster>:
fat_set_fat_cluster(
fat_fs_info_t *fs_info,
uint32_t cln,
uint32_t in_val
)
{
203dd9c: 9d e3 bf 98 save %sp, -104, %sp
int rc = RC_OK;
uint32_t sec = 0;
uint32_t ofs = 0;
uint16_t fat16_clv = 0;
uint32_t fat32_clv = 0;
rtems_bdbuf_buffer *block0 = NULL;
203dda0: c0 27 bf fc clr [ %fp + -4 ]
/* sanity check */
if ( (cln < 2) || (cln > (fs_info->vol.data_cls + 1)) )
203dda4: 80 a6 60 01 cmp %i1, 1
203dda8: 08 80 00 a6 bleu 203e040 <fat_set_fat_cluster+0x2a4> <== NEVER TAKEN
203ddac: ba 10 00 18 mov %i0, %i5
203ddb0: c2 06 20 34 ld [ %i0 + 0x34 ], %g1
203ddb4: 82 00 60 01 inc %g1
203ddb8: 80 a6 40 01 cmp %i1, %g1
203ddbc: 28 80 00 03 bleu,a 203ddc8 <fat_set_fat_cluster+0x2c> <== ALWAYS TAKEN
203ddc0: c2 0e 20 0a ldub [ %i0 + 0xa ], %g1
203ddc4: 30 80 00 9f b,a 203e040 <fat_set_fat_cluster+0x2a4> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
sec = (FAT_FAT_OFFSET(fs_info->vol.type, cln) >> fs_info->vol.sec_log2) +
203ddc8: 84 08 60 01 and %g1, 1, %g2
203ddcc: 80 88 a0 ff btst 0xff, %g2
203ddd0: 02 80 00 05 be 203dde4 <fat_set_fat_cluster+0x48> <== NEVER TAKEN
203ddd4: 86 08 60 02 and %g1, 2, %g3
203ddd8: a1 36 60 01 srl %i1, 1, %l0
203dddc: 10 80 00 06 b 203ddf4 <fat_set_fat_cluster+0x58>
203dde0: a0 04 00 19 add %l0, %i1, %l0
203dde4: 80 88 e0 ff btst 0xff, %g3 <== NOT EXECUTED
203dde8: 02 80 00 03 be 203ddf4 <fat_set_fat_cluster+0x58> <== NOT EXECUTED
203ddec: a1 2e 60 02 sll %i1, 2, %l0 <== NOT EXECUTED
203ddf0: a1 2e 60 01 sll %i1, 1, %l0 <== NOT EXECUTED
203ddf4: c6 0f 60 02 ldub [ %i5 + 2 ], %g3
fs_info->vol.afat_loc;
ofs = FAT_FAT_OFFSET(fs_info->vol.type, cln) & (fs_info->vol.bps - 1);
203ddf8: 80 88 a0 ff btst 0xff, %g2
/* 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) +
203ddfc: a1 34 00 03 srl %l0, %g3, %l0
203de00: c6 07 60 4c ld [ %i5 + 0x4c ], %g3
fs_info->vol.afat_loc;
ofs = FAT_FAT_OFFSET(fs_info->vol.type, cln) & (fs_info->vol.bps - 1);
203de04: 02 80 00 05 be 203de18 <fat_set_fat_cluster+0x7c> <== NEVER TAKEN
203de08: a0 04 00 03 add %l0, %g3, %l0
203de0c: b7 36 60 01 srl %i1, 1, %i3
203de10: 10 80 00 07 b 203de2c <fat_set_fat_cluster+0x90>
203de14: b6 06 c0 19 add %i3, %i1, %i3
203de18: 82 08 60 02 and %g1, 2, %g1 <== NOT EXECUTED
203de1c: 80 88 60 ff btst 0xff, %g1 <== NOT EXECUTED
203de20: 02 80 00 03 be 203de2c <fat_set_fat_cluster+0x90> <== NOT EXECUTED
203de24: b7 2e 60 02 sll %i1, 2, %i3 <== NOT EXECUTED
203de28: b7 2e 60 01 sll %i1, 1, %i3 <== NOT EXECUTED
203de2c: f8 17 40 00 lduh [ %i5 ], %i4
rc = fat_buf_access(fs_info, sec, FAT_OP_TYPE_READ, &block0);
203de30: 90 10 00 1d mov %i5, %o0
203de34: 92 10 00 10 mov %l0, %o1
203de38: 94 10 20 01 mov 1, %o2
203de3c: 7f ff a0 b0 call 20260fc <fat_buf_access>
203de40: 96 07 bf fc add %fp, -4, %o3
if (rc != RC_OK)
203de44: b0 92 20 00 orcc %o0, 0, %i0
203de48: 12 80 00 56 bne 203dfa0 <fat_set_fat_cluster+0x204> <== NEVER TAKEN
203de4c: b9 2f 20 10 sll %i4, 0x10, %i4
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);
203de50: b9 37 20 10 srl %i4, 0x10, %i4
203de54: b8 07 3f ff add %i4, -1, %i4
203de58: b8 0e c0 1c and %i3, %i4, %i4
rc = fat_buf_access(fs_info, sec, FAT_OP_TYPE_READ, &block0);
if (rc != RC_OK)
return rc;
switch ( fs_info->vol.type )
203de5c: f6 0f 60 0a ldub [ %i5 + 0xa ], %i3
203de60: 80 a6 e0 02 cmp %i3, 2
203de64: 02 80 00 5f be 203dfe0 <fat_set_fat_cluster+0x244> <== NEVER TAKEN
203de68: 80 a6 e0 04 cmp %i3, 4
203de6c: 02 80 00 68 be 203e00c <fat_set_fat_cluster+0x270> <== NEVER TAKEN
203de70: 80 a6 e0 01 cmp %i3, 1
203de74: 12 80 00 73 bne 203e040 <fat_set_fat_cluster+0x2a4> <== NEVER TAKEN
203de78: 80 8e 60 01 btst 1, %i1
{
case FAT_FAT12:
if ( FAT_CLUSTER_IS_ODD(cln) )
203de7c: 02 80 00 29 be 203df20 <fat_set_fat_cluster+0x184>
203de80: c2 07 bf fc ld [ %fp + -4 ], %g1
{
fat16_clv = ((uint16_t )in_val) << FAT_FAT12_SHIFT;
*((uint8_t *)(block0->buffer + ofs)) =
(*((uint8_t *)(block0->buffer + ofs))) & 0x0F;
203de84: c2 00 60 1c ld [ %g1 + 0x1c ], %g1
{
case FAT_FAT12:
if ( FAT_CLUSTER_IS_ODD(cln) )
{
fat16_clv = ((uint16_t )in_val) << FAT_FAT12_SHIFT;
*((uint8_t *)(block0->buffer + ofs)) =
203de88: c4 08 40 1c ldub [ %g1 + %i4 ], %g2
203de8c: 84 08 a0 0f and %g2, 0xf, %g2
203de90: c4 28 40 1c stb %g2, [ %g1 + %i4 ]
(*((uint8_t *)(block0->buffer + ofs))) & 0x0F;
*((uint8_t *)(block0->buffer + ofs)) =
(*((uint8_t *)(block0->buffer + ofs))) |
203de94: c2 07 bf fc ld [ %fp + -4 ], %g1
{
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)) =
203de98: 85 2e a0 04 sll %i2, 4, %g2
(*((uint8_t *)(block0->buffer + ofs))) |
203de9c: c2 00 60 1c ld [ %g1 + 0x1c ], %g1
{
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)) =
203dea0: c6 08 40 1c ldub [ %g1 + %i4 ], %g3
203dea4: 84 10 c0 02 or %g3, %g2, %g2
203dea8: c4 28 40 1c stb %g2, [ %g1 + %i4 ]
(*((uint8_t *)(block0->buffer + ofs))) |
(uint8_t )(fat16_clv & 0x00FF);
fat_buf_mark_modified(fs_info);
if ( ofs == (fs_info->vol.bps - 1) )
203deac: c2 17 40 00 lduh [ %i5 ], %g1
203deb0: 82 00 7f ff add %g1, -1, %g1
203deb4: 80 a7 00 01 cmp %i4, %g1
203deb8: 12 80 00 11 bne 203defc <fat_set_fat_cluster+0x160> <== ALWAYS TAKEN
203debc: f6 2f 60 7c stb %i3, [ %i5 + 0x7c ]
{
rc = fat_buf_access(fs_info, sec + 1, FAT_OP_TYPE_READ,
203dec0: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
203dec4: 92 04 20 01 add %l0, 1, %o1 <== NOT EXECUTED
203dec8: 94 10 20 01 mov 1, %o2 <== NOT EXECUTED
203decc: 7f ff a0 8c call 20260fc <fat_buf_access> <== NOT EXECUTED
203ded0: 96 07 bf fc add %fp, -4, %o3 <== NOT EXECUTED
&block0);
if (rc != RC_OK)
203ded4: b0 92 20 00 orcc %o0, 0, %i0 <== NOT EXECUTED
203ded8: 12 80 00 32 bne 203dfa0 <fat_set_fat_cluster+0x204> <== NOT EXECUTED
203dedc: c2 07 bf fc ld [ %fp + -4 ], %g1 <== NOT EXECUTED
*((uint8_t *)(block0->buffer)) &= 0x00;
*((uint8_t *)(block0->buffer)) =
(*((uint8_t *)(block0->buffer))) |
(uint8_t )((fat16_clv & 0xFF00)>>8);
203dee0: b5 2e a0 14 sll %i2, 0x14, %i2 <== NOT EXECUTED
rc = fat_buf_access(fs_info, sec + 1, FAT_OP_TYPE_READ,
&block0);
if (rc != RC_OK)
return rc;
*((uint8_t *)(block0->buffer)) &= 0x00;
203dee4: c2 00 60 1c ld [ %g1 + 0x1c ], %g1 <== NOT EXECUTED
*((uint8_t *)(block0->buffer)) =
(*((uint8_t *)(block0->buffer))) |
(uint8_t )((fat16_clv & 0xFF00)>>8);
203dee8: b5 36 a0 18 srl %i2, 0x18, %i2 <== NOT EXECUTED
rc = fat_buf_access(fs_info, sec + 1, FAT_OP_TYPE_READ,
&block0);
if (rc != RC_OK)
return rc;
*((uint8_t *)(block0->buffer)) &= 0x00;
203deec: c0 28 40 00 clrb [ %g1 ] <== NOT EXECUTED
*((uint8_t *)(block0->buffer)) =
(*((uint8_t *)(block0->buffer))) |
203def0: c2 07 bf fc ld [ %fp + -4 ], %g1 <== NOT EXECUTED
203def4: 10 80 00 27 b 203df90 <fat_set_fat_cluster+0x1f4> <== NOT EXECUTED
203def8: c2 00 60 1c ld [ %g1 + 0x1c ], %g1 <== NOT EXECUTED
fat_buf_mark_modified(fs_info);
}
else
{
*((uint8_t *)(block0->buffer + ofs + 1)) &= 0x00;
203defc: c2 07 bf fc ld [ %fp + -4 ], %g1
203df00: b8 07 20 01 inc %i4
203df04: c2 00 60 1c ld [ %g1 + 0x1c ], %g1
*((uint8_t *)(block0->buffer + ofs + 1)) =
(*((uint8_t *)(block0->buffer + ofs + 1))) |
(uint8_t )((fat16_clv & 0xFF00)>>8);
203df08: b5 2e a0 14 sll %i2, 0x14, %i2
fat_buf_mark_modified(fs_info);
}
else
{
*((uint8_t *)(block0->buffer + ofs + 1)) &= 0x00;
203df0c: c0 28 40 1c clrb [ %g1 + %i4 ]
*((uint8_t *)(block0->buffer + ofs + 1)) =
(*((uint8_t *)(block0->buffer + ofs + 1))) |
203df10: c2 07 bf fc ld [ %fp + -4 ], %g1
(uint8_t )((fat16_clv & 0xFF00)>>8);
203df14: b5 36 a0 18 srl %i2, 0x18, %i2
else
{
*((uint8_t *)(block0->buffer + ofs + 1)) &= 0x00;
*((uint8_t *)(block0->buffer + ofs + 1)) =
(*((uint8_t *)(block0->buffer + ofs + 1))) |
203df18: 10 80 00 2d b 203dfcc <fat_set_fat_cluster+0x230>
203df1c: c2 00 60 1c ld [ %g1 + 0x1c ], %g1
}
}
else
{
fat16_clv = ((uint16_t )in_val) & FAT_FAT12_MASK;
*((uint8_t *)(block0->buffer + ofs)) &= 0x00;
203df20: c2 00 60 1c ld [ %g1 + 0x1c ], %g1
(uint8_t )((fat16_clv & 0xFF00)>>8);
}
}
else
{
fat16_clv = ((uint16_t )in_val) & FAT_FAT12_MASK;
203df24: b4 0e af ff and %i2, 0xfff, %i2
*((uint8_t *)(block0->buffer + ofs)) &= 0x00;
203df28: c0 28 40 1c clrb [ %g1 + %i4 ]
*((uint8_t *)(block0->buffer + ofs)) =
(*((uint8_t *)(block0->buffer + ofs))) |
203df2c: c2 07 bf fc ld [ %fp + -4 ], %g1
203df30: c2 00 60 1c ld [ %g1 + 0x1c ], %g1
else
{
fat16_clv = ((uint16_t )in_val) & FAT_FAT12_MASK;
*((uint8_t *)(block0->buffer + ofs)) &= 0x00;
*((uint8_t *)(block0->buffer + ofs)) =
203df34: c4 08 40 1c ldub [ %g1 + %i4 ], %g2
203df38: 84 10 80 1a or %g2, %i2, %g2
203df3c: c4 28 40 1c stb %g2, [ %g1 + %i4 ]
(*((uint8_t *)(block0->buffer + ofs))) |
(uint8_t )(fat16_clv & 0x00FF);
fat_buf_mark_modified(fs_info);
if ( ofs == (fs_info->vol.bps - 1) )
203df40: c2 17 40 00 lduh [ %i5 ], %g1
203df44: 82 00 7f ff add %g1, -1, %g1
203df48: 80 a7 00 01 cmp %i4, %g1
203df4c: 12 80 00 17 bne 203dfa8 <fat_set_fat_cluster+0x20c> <== ALWAYS TAKEN
203df50: f6 2f 60 7c stb %i3, [ %i5 + 0x7c ]
{
rc = fat_buf_access(fs_info, sec + 1, FAT_OP_TYPE_READ,
203df54: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
203df58: 92 04 20 01 add %l0, 1, %o1 <== NOT EXECUTED
203df5c: 94 10 20 01 mov 1, %o2 <== NOT EXECUTED
203df60: 7f ff a0 67 call 20260fc <fat_buf_access> <== NOT EXECUTED
203df64: 96 07 bf fc add %fp, -4, %o3 <== NOT EXECUTED
&block0);
if (rc != RC_OK)
203df68: b0 92 20 00 orcc %o0, 0, %i0 <== NOT EXECUTED
203df6c: 12 80 00 0d bne 203dfa0 <fat_set_fat_cluster+0x204> <== NOT EXECUTED
203df70: c2 07 bf fc ld [ %fp + -4 ], %g1 <== NOT EXECUTED
*((uint8_t *)(block0->buffer)) =
(*((uint8_t *)(block0->buffer))) & 0xF0;
*((uint8_t *)(block0->buffer)) =
(*((uint8_t *)(block0->buffer))) |
(uint8_t )((fat16_clv & 0xFF00)>>8);
203df74: b5 36 a0 08 srl %i2, 8, %i2 <== NOT EXECUTED
&block0);
if (rc != RC_OK)
return rc;
*((uint8_t *)(block0->buffer)) =
(*((uint8_t *)(block0->buffer))) & 0xF0;
203df78: c2 00 60 1c ld [ %g1 + 0x1c ], %g1 <== 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)) =
203df7c: c4 08 40 00 ldub [ %g1 ], %g2 <== NOT EXECUTED
203df80: 84 08 bf f0 and %g2, -16, %g2 <== NOT EXECUTED
203df84: c4 28 40 00 stb %g2, [ %g1 ] <== NOT EXECUTED
(*((uint8_t *)(block0->buffer))) & 0xF0;
*((uint8_t *)(block0->buffer)) =
(*((uint8_t *)(block0->buffer))) |
203df88: c2 07 bf fc ld [ %fp + -4 ], %g1 <== NOT EXECUTED
203df8c: c2 00 60 1c ld [ %g1 + 0x1c ], %g1 <== NOT EXECUTED
return rc;
*((uint8_t *)(block0->buffer)) =
(*((uint8_t *)(block0->buffer))) & 0xF0;
*((uint8_t *)(block0->buffer)) =
203df90: c4 08 40 00 ldub [ %g1 ], %g2 <== NOT EXECUTED
203df94: b4 16 80 02 or %i2, %g2, %i2 <== NOT EXECUTED
203df98: f4 28 40 00 stb %i2, [ %g1 ] <== NOT EXECUTED
}
static inline void
fat_buf_mark_modified(fat_fs_info_t *fs_info)
{
fs_info->c.modified = true;
203df9c: f6 2f 60 7c stb %i3, [ %i5 + 0x7c ] <== NOT EXECUTED
203dfa0: 81 c7 e0 08 ret <== NOT EXECUTED
203dfa4: 81 e8 00 00 restore <== NOT EXECUTED
fat_buf_mark_modified(fs_info);
}
else
{
*((uint8_t *)(block0->buffer + ofs + 1)) =
(*((uint8_t *)(block0->buffer + ofs + 1))) & 0xF0;
203dfa8: c2 07 bf fc ld [ %fp + -4 ], %g1
203dfac: b8 07 20 01 inc %i4
203dfb0: c2 00 60 1c ld [ %g1 + 0x1c ], %g1
*((uint8_t *)(block0->buffer + ofs+1)) =
(*((uint8_t *)(block0->buffer + ofs+1))) |
(uint8_t )((fat16_clv & 0xFF00)>>8);
203dfb4: b5 36 a0 08 srl %i2, 8, %i2
fat_buf_mark_modified(fs_info);
}
else
{
*((uint8_t *)(block0->buffer + ofs + 1)) =
203dfb8: c4 08 40 1c ldub [ %g1 + %i4 ], %g2
203dfbc: 84 08 bf f0 and %g2, -16, %g2
203dfc0: c4 28 40 1c stb %g2, [ %g1 + %i4 ]
(*((uint8_t *)(block0->buffer + ofs + 1))) & 0xF0;
*((uint8_t *)(block0->buffer + ofs+1)) =
(*((uint8_t *)(block0->buffer + ofs+1))) |
203dfc4: c2 07 bf fc ld [ %fp + -4 ], %g1
203dfc8: c2 00 60 1c ld [ %g1 + 0x1c ], %g1
else
{
*((uint8_t *)(block0->buffer + ofs + 1)) =
(*((uint8_t *)(block0->buffer + ofs + 1))) & 0xF0;
*((uint8_t *)(block0->buffer + ofs+1)) =
203dfcc: c4 08 40 1c ldub [ %g1 + %i4 ], %g2
203dfd0: b4 10 80 1a or %g2, %i2, %i2
203dfd4: f4 28 40 1c stb %i2, [ %g1 + %i4 ]
203dfd8: 81 c7 e0 08 ret
203dfdc: 81 e8 00 00 restore
}
}
break;
case FAT_FAT16:
*((uint16_t *)(block0->buffer + ofs)) =
203dfe0: c2 07 bf fc ld [ %fp + -4 ], %g1 <== NOT EXECUTED
break;
}
return RC_OK;
}
203dfe4: 05 00 00 3f sethi %hi(0xfc00), %g2 <== NOT EXECUTED
}
}
break;
case FAT_FAT16:
*((uint16_t *)(block0->buffer + ofs)) =
203dfe8: c2 00 60 1c ld [ %g1 + 0x1c ], %g1 <== NOT EXECUTED
break;
}
return RC_OK;
}
203dfec: 84 10 a3 ff or %g2, 0x3ff, %g2 <== NOT EXECUTED
203dff0: 84 0e 80 02 and %i2, %g2, %g2 <== NOT EXECUTED
}
break;
case FAT_FAT16:
*((uint16_t *)(block0->buffer + ofs)) =
(uint16_t )(CT_LE_W(in_val));
203dff4: b5 2e a0 10 sll %i2, 0x10, %i2 <== NOT EXECUTED
203dff8: 85 28 a0 08 sll %g2, 8, %g2 <== NOT EXECUTED
203dffc: b5 36 a0 18 srl %i2, 0x18, %i2 <== NOT EXECUTED
203e000: b4 10 80 1a or %g2, %i2, %i2 <== NOT EXECUTED
}
}
break;
case FAT_FAT16:
*((uint16_t *)(block0->buffer + ofs)) =
203e004: 10 80 00 0b b 203e030 <fat_set_fat_cluster+0x294> <== NOT EXECUTED
203e008: f4 30 40 1c sth %i2, [ %g1 + %i4 ] <== 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));
203e00c: 11 3c 00 00 sethi %hi(0xf0000000), %o0 <== NOT EXECUTED
203e010: 7f ff fe e0 call 203db90 <CPU_swap_u32> <== NOT EXECUTED
203e014: 90 2e 80 08 andn %i2, %o0, %o0 <== NOT EXECUTED
*((uint32_t *)(block0->buffer + ofs)) =
(*((uint32_t *)(block0->buffer + ofs))) & (CT_LE_L(0xF0000000));
203e018: c2 07 bf fc ld [ %fp + -4 ], %g1 <== NOT EXECUTED
203e01c: c2 00 60 1c ld [ %g1 + 0x1c ], %g1 <== NOT EXECUTED
203e020: c4 00 40 1c ld [ %g1 + %i4 ], %g2 <== NOT EXECUTED
203e024: 84 08 a0 f0 and %g2, 0xf0, %g2 <== NOT EXECUTED
*((uint32_t *)(block0->buffer + ofs)) =
fat32_clv | (*((uint32_t *)(block0->buffer + ofs)));
203e028: 90 12 00 02 or %o0, %g2, %o0 <== 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)) =
203e02c: d0 20 40 1c st %o0, [ %g1 + %i4 ] <== NOT EXECUTED
203e030: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED
203e034: c2 2f 60 7c stb %g1, [ %i5 + 0x7c ] <== NOT EXECUTED
203e038: 81 c7 e0 08 ret <== NOT EXECUTED
203e03c: 81 e8 00 00 restore <== NOT EXECUTED
fat_buf_mark_modified(fs_info);
break;
default:
rtems_set_errno_and_return_minus_one(EIO);
203e040: 40 00 10 6b call 20421ec <__errno> <== NOT EXECUTED
203e044: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
203e048: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
203e04c: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
break;
}
return RC_OK;
}
203e050: 81 c7 e0 08 ret <== NOT EXECUTED
203e054: 81 e8 00 00 restore <== NOT EXECUTED
020268d0 <fat_shutdown_drive>:
* RC_OK on success, or -1 if error occured
* and errno set appropriately
*/
int
fat_shutdown_drive(fat_fs_info_t *fs_info)
{
20268d0: 9d e3 bf a0 save %sp, -96, %sp
int rc = RC_OK;
int i = 0;
if (fs_info->vol.type & FAT_FAT32)
20268d4: c2 0e 20 0a ldub [ %i0 + 0xa ], %g1
* RC_OK on success, or -1 if error occured
* and errno set appropriately
*/
int
fat_shutdown_drive(fat_fs_info_t *fs_info)
{
20268d8: ba 10 00 18 mov %i0, %i5
int rc = RC_OK;
int i = 0;
if (fs_info->vol.type & FAT_FAT32)
20268dc: 82 08 60 04 and %g1, 4, %g1
20268e0: 80 88 60 ff btst 0xff, %g1
20268e4: 02 80 00 09 be 2026908 <fat_shutdown_drive+0x38> <== ALWAYS TAKEN
20268e8: b0 10 20 00 clr %i0
{
rc = fat_fat32_update_fsinfo_sector(fs_info, fs_info->vol.free_cls,
20268ec: d2 07 60 40 ld [ %i5 + 0x40 ], %o1 <== NOT EXECUTED
20268f0: d4 07 60 44 ld [ %i5 + 0x44 ], %o2 <== NOT EXECUTED
20268f4: 7f ff ff db call 2026860 <fat_fat32_update_fsinfo_sector> <== NOT EXECUTED
20268f8: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
fs_info->vol.next_cl);
if ( rc != RC_OK )
20268fc: b0 92 20 00 orcc %o0, 0, %i0 <== NOT EXECUTED
2026900: 32 80 00 02 bne,a 2026908 <fat_shutdown_drive+0x38> <== NOT EXECUTED
2026904: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
rc = -1;
}
fat_buf_release(fs_info);
2026908: 7f ff fe 7a call 20262f0 <fat_buf_release>
202690c: 90 10 00 1d mov %i5, %o0
if (rtems_bdbuf_syncdev(fs_info->vol.dd) != RTEMS_SUCCESSFUL)
2026910: 7f ff 80 7a call 2006af8 <rtems_bdbuf_syncdev>
2026914: d0 07 60 58 ld [ %i5 + 0x58 ], %o0
2026918: 80 a2 20 00 cmp %o0, 0
202691c: 32 80 00 02 bne,a 2026924 <fat_shutdown_drive+0x54> <== NEVER TAKEN
2026920: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
rc = -1;
2026924: b8 10 20 00 clr %i4
for (i = 0; i < FAT_HASH_SIZE; i++)
{
rtems_chain_node *node = NULL;
rtems_chain_control *the_chain = fs_info->vhash + i;
2026928: f6 07 60 60 ld [ %i5 + 0x60 ], %i3
while ( (node = rtems_chain_get(the_chain)) != NULL )
202692c: 10 80 00 04 b 202693c <fat_shutdown_drive+0x6c>
2026930: b6 06 c0 1c add %i3, %i4, %i3
free(node);
2026934: 7f ff 88 b2 call 2008bfc <free> <== NOT EXECUTED
2026938: 01 00 00 00 nop <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE rtems_chain_node *rtems_chain_get(
rtems_chain_control *the_chain
)
{
return _Chain_Get( the_chain );
202693c: 7f ff 9e 30 call 200e1fc <_Chain_Get>
2026940: 90 10 00 1b mov %i3, %o0
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 )
2026944: 80 a2 20 00 cmp %o0, 0
2026948: 12 bf ff fb bne 2026934 <fat_shutdown_drive+0x64> <== NEVER TAKEN
202694c: 01 00 00 00 nop
2026950: b8 07 20 0c add %i4, 0xc, %i4
fat_buf_release(fs_info);
if (rtems_bdbuf_syncdev(fs_info->vol.dd) != RTEMS_SUCCESSFUL)
rc = -1;
for (i = 0; i < FAT_HASH_SIZE; i++)
2026954: 80 a7 20 18 cmp %i4, 0x18
2026958: 32 bf ff f5 bne,a 202692c <fat_shutdown_drive+0x5c>
202695c: f6 07 60 60 ld [ %i5 + 0x60 ], %i3
2026960: b8 10 20 00 clr %i4
}
for (i = 0; i < FAT_HASH_SIZE; i++)
{
rtems_chain_node *node = NULL;
rtems_chain_control *the_chain = fs_info->rhash + i;
2026964: f6 07 60 64 ld [ %i5 + 0x64 ], %i3
while ( (node = rtems_chain_get(the_chain)) != NULL )
2026968: 10 80 00 04 b 2026978 <fat_shutdown_drive+0xa8>
202696c: b6 06 c0 1c add %i3, %i4, %i3
free(node);
2026970: 7f ff 88 a3 call 2008bfc <free> <== NOT EXECUTED
2026974: 01 00 00 00 nop <== NOT EXECUTED
2026978: 7f ff 9e 21 call 200e1fc <_Chain_Get>
202697c: 90 10 00 1b mov %i3, %o0
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 )
2026980: 80 a2 20 00 cmp %o0, 0
2026984: 12 bf ff fb bne 2026970 <fat_shutdown_drive+0xa0> <== NEVER TAKEN
2026988: 01 00 00 00 nop
202698c: b8 07 20 0c add %i4, 0xc, %i4
while ( (node = rtems_chain_get(the_chain)) != NULL )
free(node);
}
for (i = 0; i < FAT_HASH_SIZE; i++)
2026990: 80 a7 20 18 cmp %i4, 0x18
2026994: 32 bf ff f5 bne,a 2026968 <fat_shutdown_drive+0x98>
2026998: f6 07 60 64 ld [ %i5 + 0x64 ], %i3
while ( (node = rtems_chain_get(the_chain)) != NULL )
free(node);
}
free(fs_info->vhash);
202699c: 7f ff 88 98 call 2008bfc <free>
20269a0: d0 07 60 60 ld [ %i5 + 0x60 ], %o0
free(fs_info->rhash);
20269a4: 7f ff 88 96 call 2008bfc <free>
20269a8: d0 07 60 64 ld [ %i5 + 0x64 ], %o0
free(fs_info->uino);
20269ac: 7f ff 88 94 call 2008bfc <free>
20269b0: d0 07 60 68 ld [ %i5 + 0x68 ], %o0
free(fs_info->sec_buf);
20269b4: 7f ff 88 92 call 2008bfc <free>
20269b8: d0 07 60 84 ld [ %i5 + 0x84 ], %o0
close(fs_info->vol.fd);
20269bc: 7f ff 87 d2 call 2008904 <close>
20269c0: d0 07 60 54 ld [ %i5 + 0x54 ], %o0
if (rc)
20269c4: 80 a6 20 00 cmp %i0, 0
20269c8: 02 80 00 06 be 20269e0 <fat_shutdown_drive+0x110> <== ALWAYS TAKEN
20269cc: 01 00 00 00 nop
errno = EIO;
20269d0: 40 00 6e 07 call 20421ec <__errno> <== NOT EXECUTED
20269d4: 01 00 00 00 nop <== NOT EXECUTED
20269d8: 82 10 20 05 mov 5, %g1 ! 5 <PROM_START+0x5> <== NOT EXECUTED
20269dc: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
return rc;
}
20269e0: 81 c7 e0 08 ret
20269e4: 81 e8 00 00 restore
0203e488 <fchdir>:
#include <unistd.h>
#include <rtems/libio_.h>
int fchdir( int fd )
{
203e488: 9d e3 bf 40 save %sp, -192, %sp
st.st_mode = 0;
st.st_uid = 0;
st.st_gid = 0;
rtems_libio_check_fd( fd );
203e48c: 03 00 81 ad sethi %hi(0x206b400), %g1
203e490: c2 00 60 48 ld [ %g1 + 0x48 ], %g1 ! 206b448 <rtems_libio_number_iops>
int rv = 0;
rtems_libio_t *iop;
struct stat st;
rtems_filesystem_location_info_t loc;
st.st_mode = 0;
203e494: c0 27 bf c4 clr [ %fp + -60 ]
st.st_uid = 0;
203e498: c0 37 bf ca clrh [ %fp + -54 ]
st.st_gid = 0;
rtems_libio_check_fd( fd );
203e49c: 80 a6 00 01 cmp %i0, %g1
203e4a0: 1a 80 00 0c bcc 203e4d0 <fchdir+0x48>
203e4a4: c0 37 bf cc clrh [ %fp + -52 ]
iop = rtems_libio_iop( fd );
203e4a8: 83 2e 20 03 sll %i0, 3, %g1
203e4ac: b1 2e 20 06 sll %i0, 6, %i0
203e4b0: b0 26 00 01 sub %i0, %g1, %i0
203e4b4: 03 00 81 bd sethi %hi(0x206f400), %g1
203e4b8: fa 00 61 e0 ld [ %g1 + 0x1e0 ], %i5 ! 206f5e0 <rtems_libio_iops>
203e4bc: ba 07 40 18 add %i5, %i0, %i5
rtems_libio_check_is_open( iop );
203e4c0: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
203e4c4: 80 88 61 00 btst 0x100, %g1
203e4c8: 32 80 00 08 bne,a 203e4e8 <fchdir+0x60>
203e4cc: d0 07 60 28 ld [ %i5 + 0x28 ], %o0
203e4d0: 40 00 0f 47 call 20421ec <__errno>
203e4d4: b0 10 3f ff mov -1, %i0
203e4d8: 82 10 20 09 mov 9, %g1
203e4dc: c2 22 00 00 st %g1, [ %o0 ]
203e4e0: 81 c7 e0 08 ret
203e4e4: 81 e8 00 00 restore
const rtems_filesystem_location_info_t *loc
)
{
const rtems_filesystem_mount_table_entry_t *mt_entry = loc->mt_entry;
(*mt_entry->ops->lock_h)( mt_entry );
203e4e8: c2 02 20 0c ld [ %o0 + 0xc ], %g1
203e4ec: c2 00 40 00 ld [ %g1 ], %g1
203e4f0: 9f c0 40 00 call %g1
203e4f4: b8 07 60 14 add %i5, 0x14, %i4
rtems_filesystem_instance_lock( &iop->pathinfo );
rv = (*iop->pathinfo.handlers->fstat_h)( &iop->pathinfo, &st );
203e4f8: c2 07 60 24 ld [ %i5 + 0x24 ], %g1
203e4fc: 90 10 00 1c mov %i4, %o0
203e500: c2 00 60 18 ld [ %g1 + 0x18 ], %g1
203e504: 9f c0 40 00 call %g1
203e508: 92 07 bf b8 add %fp, -72, %o1
if ( rv == 0 ) {
203e50c: b0 92 20 00 orcc %o0, 0, %i0
203e510: 32 80 00 13 bne,a 203e55c <fchdir+0xd4> <== NEVER TAKEN
203e514: d0 07 60 28 ld [ %i5 + 0x28 ], %o0 <== NOT EXECUTED
bool access_ok = rtems_filesystem_check_access(
203e518: d2 07 bf c4 ld [ %fp + -60 ], %o1
203e51c: d4 17 bf ca lduh [ %fp + -54 ], %o2
203e520: d6 17 bf cc lduh [ %fp + -52 ], %o3
203e524: 7f ff ab b8 call 2029404 <rtems_filesystem_check_access>
203e528: 90 10 20 01 mov 1, %o0
st.st_mode,
st.st_uid,
st.st_gid
);
if ( access_ok ) {
203e52c: 80 8a 20 ff btst 0xff, %o0
203e530: 02 80 00 06 be 203e548 <fchdir+0xc0>
203e534: 90 07 bf a0 add %fp, -96, %o0
rtems_filesystem_location_clone( &loc, &iop->pathinfo );
203e538: 7f ff a5 f6 call 2027d10 <rtems_filesystem_location_clone>
203e53c: 92 10 00 1c mov %i4, %o1
static inline void rtems_filesystem_instance_unlock(
const rtems_filesystem_location_info_t *loc
)
{
const rtems_filesystem_mount_table_entry_t *mt_entry = loc->mt_entry;
203e540: 10 80 00 07 b 203e55c <fchdir+0xd4>
203e544: d0 07 60 28 ld [ %i5 + 0x28 ], %o0
} else {
errno = EACCES;
203e548: 40 00 0f 29 call 20421ec <__errno>
203e54c: b0 10 3f ff mov -1, %i0
203e550: 82 10 20 0d mov 0xd, %g1
203e554: c2 22 00 00 st %g1, [ %o0 ]
203e558: d0 07 60 28 ld [ %i5 + 0x28 ], %o0
(*mt_entry->ops->unlock_h)( mt_entry );
203e55c: c2 02 20 0c ld [ %o0 + 0xc ], %g1
203e560: c2 00 60 04 ld [ %g1 + 4 ], %g1
203e564: 9f c0 40 00 call %g1
203e568: 01 00 00 00 nop
rv = -1;
}
}
rtems_filesystem_instance_unlock( &iop->pathinfo );
if ( rv == 0 ) {
203e56c: 80 a6 20 00 cmp %i0, 0
203e570: 12 80 00 05 bne 203e584 <fchdir+0xfc>
203e574: 01 00 00 00 nop
rv = rtems_filesystem_chdir( &loc );
203e578: 7f ff a5 5c call 2027ae8 <rtems_filesystem_chdir>
203e57c: 90 07 bf a0 add %fp, -96, %o0
203e580: b0 10 00 08 mov %o0, %i0
}
return rv;
}
203e584: 81 c7 e0 08 ret
203e588: 81 e8 00 00 restore
02027d58 <fchmod>:
#include <sys/stat.h>
#include <rtems/libio_.h>
int fchmod( int fd, mode_t mode )
{
2027d58: 9d e3 bf a0 save %sp, -96, %sp
int rv;
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
2027d5c: 03 00 81 ad sethi %hi(0x206b400), %g1
2027d60: c2 00 60 48 ld [ %g1 + 0x48 ], %g1 ! 206b448 <rtems_libio_number_iops>
2027d64: 80 a6 00 01 cmp %i0, %g1
2027d68: 2a 80 00 03 bcs,a 2027d74 <fchmod+0x1c>
2027d6c: 83 2e 20 03 sll %i0, 3, %g1
2027d70: 30 80 00 0a b,a 2027d98 <fchmod+0x40>
iop = rtems_libio_iop( fd );
2027d74: b1 2e 20 06 sll %i0, 6, %i0
2027d78: b0 26 00 01 sub %i0, %g1, %i0
2027d7c: 03 00 81 bd sethi %hi(0x206f400), %g1
2027d80: fa 00 61 e0 ld [ %g1 + 0x1e0 ], %i5 ! 206f5e0 <rtems_libio_iops>
2027d84: ba 07 40 18 add %i5, %i0, %i5
rtems_libio_check_is_open(iop);
2027d88: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
2027d8c: 80 88 61 00 btst 0x100, %g1
2027d90: 32 80 00 06 bne,a 2027da8 <fchmod+0x50>
2027d94: d0 07 60 28 ld [ %i5 + 0x28 ], %o0
2027d98: 40 00 69 15 call 20421ec <__errno>
2027d9c: 01 00 00 00 nop
2027da0: 10 80 00 1b b 2027e0c <fchmod+0xb4>
2027da4: 82 10 20 09 mov 9, %g1 ! 9 <PROM_START+0x9>
if (iop->pathinfo.mt_entry->writeable) {
2027da8: c2 0a 20 29 ldub [ %o0 + 0x29 ], %g1
2027dac: 80 a0 60 00 cmp %g1, 0
2027db0: 02 80 00 14 be 2027e00 <fchmod+0xa8> <== NEVER TAKEN
2027db4: 01 00 00 00 nop
const rtems_filesystem_location_info_t *loc
)
{
const rtems_filesystem_mount_table_entry_t *mt_entry = loc->mt_entry;
(*mt_entry->ops->lock_h)( mt_entry );
2027db8: c2 02 20 0c ld [ %o0 + 0xc ], %g1
2027dbc: c2 00 40 00 ld [ %g1 ], %g1
2027dc0: 9f c0 40 00 call %g1
2027dc4: 01 00 00 00 nop
rtems_filesystem_instance_lock( &iop->pathinfo );
rv = (*iop->pathinfo.mt_entry->ops->fchmod_h)( &iop->pathinfo, mode );
2027dc8: c2 07 60 28 ld [ %i5 + 0x28 ], %g1
2027dcc: 90 07 60 14 add %i5, 0x14, %o0
2027dd0: c2 00 60 0c ld [ %g1 + 0xc ], %g1
2027dd4: c2 00 60 20 ld [ %g1 + 0x20 ], %g1
2027dd8: 9f c0 40 00 call %g1
2027ddc: 92 10 00 19 mov %i1, %o1
2027de0: b0 10 00 08 mov %o0, %i0
static inline void rtems_filesystem_instance_unlock(
const rtems_filesystem_location_info_t *loc
)
{
const rtems_filesystem_mount_table_entry_t *mt_entry = loc->mt_entry;
2027de4: d0 07 60 28 ld [ %i5 + 0x28 ], %o0
(*mt_entry->ops->unlock_h)( mt_entry );
2027de8: c2 02 20 0c ld [ %o0 + 0xc ], %g1
2027dec: c2 00 60 04 ld [ %g1 + 4 ], %g1
2027df0: 9f c0 40 00 call %g1
2027df4: 01 00 00 00 nop
2027df8: 81 c7 e0 08 ret
2027dfc: 81 e8 00 00 restore
rtems_filesystem_instance_unlock( &iop->pathinfo );
} else {
errno = EROFS;
2027e00: 40 00 68 fb call 20421ec <__errno> <== NOT EXECUTED
2027e04: 01 00 00 00 nop <== NOT EXECUTED
2027e08: 82 10 20 1e mov 0x1e, %g1 ! 1e <PROM_START+0x1e> <== NOT EXECUTED
2027e0c: c2 22 00 00 st %g1, [ %o0 ]
rv = -1;
}
return rv;
}
2027e10: 81 c7 e0 08 ret
2027e14: 91 e8 3f ff restore %g0, -1, %o0
02027e18 <fchown>:
#include <unistd.h>
#include <rtems/libio_.h>
int fchown( int fd, uid_t owner, gid_t group )
{
2027e18: 9d e3 bf a0 save %sp, -96, %sp
int rv = 0;
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
2027e1c: 03 00 81 ad sethi %hi(0x206b400), %g1
2027e20: c2 00 60 48 ld [ %g1 + 0x48 ], %g1 ! 206b448 <rtems_libio_number_iops>
2027e24: 80 a6 00 01 cmp %i0, %g1
2027e28: 2a 80 00 03 bcs,a 2027e34 <fchown+0x1c>
2027e2c: 83 2e 20 03 sll %i0, 3, %g1
2027e30: 30 80 00 0a b,a 2027e58 <fchown+0x40>
iop = rtems_libio_iop( fd );
2027e34: b1 2e 20 06 sll %i0, 6, %i0
2027e38: b0 26 00 01 sub %i0, %g1, %i0
2027e3c: 03 00 81 bd sethi %hi(0x206f400), %g1
2027e40: fa 00 61 e0 ld [ %g1 + 0x1e0 ], %i5 ! 206f5e0 <rtems_libio_iops>
2027e44: ba 07 40 18 add %i5, %i0, %i5
rtems_libio_check_is_open(iop);
2027e48: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
2027e4c: 80 88 61 00 btst 0x100, %g1
2027e50: 32 80 00 06 bne,a 2027e68 <fchown+0x50>
2027e54: d0 07 60 28 ld [ %i5 + 0x28 ], %o0
2027e58: 40 00 68 e5 call 20421ec <__errno>
2027e5c: 01 00 00 00 nop
2027e60: 10 80 00 1c b 2027ed0 <fchown+0xb8>
2027e64: 82 10 20 09 mov 9, %g1 ! 9 <PROM_START+0x9>
if (iop->pathinfo.mt_entry->writeable) {
2027e68: c2 0a 20 29 ldub [ %o0 + 0x29 ], %g1
2027e6c: 80 a0 60 00 cmp %g1, 0
2027e70: 02 80 00 15 be 2027ec4 <fchown+0xac> <== NEVER TAKEN
2027e74: 01 00 00 00 nop
const rtems_filesystem_location_info_t *loc
)
{
const rtems_filesystem_mount_table_entry_t *mt_entry = loc->mt_entry;
(*mt_entry->ops->lock_h)( mt_entry );
2027e78: c2 02 20 0c ld [ %o0 + 0xc ], %g1
2027e7c: c2 00 40 00 ld [ %g1 ], %g1
2027e80: 9f c0 40 00 call %g1
2027e84: 01 00 00 00 nop
rtems_filesystem_instance_lock( &iop->pathinfo );
rv = (*iop->pathinfo.mt_entry->ops->chown_h)(
2027e88: c2 07 60 28 ld [ %i5 + 0x28 ], %g1
2027e8c: 90 07 60 14 add %i5, 0x14, %o0
2027e90: c2 00 60 0c ld [ %g1 + 0xc ], %g1
2027e94: 92 10 00 19 mov %i1, %o1
2027e98: c2 00 60 24 ld [ %g1 + 0x24 ], %g1
2027e9c: 9f c0 40 00 call %g1
2027ea0: 94 10 00 1a mov %i2, %o2
2027ea4: b0 10 00 08 mov %o0, %i0
static inline void rtems_filesystem_instance_unlock(
const rtems_filesystem_location_info_t *loc
)
{
const rtems_filesystem_mount_table_entry_t *mt_entry = loc->mt_entry;
2027ea8: d0 07 60 28 ld [ %i5 + 0x28 ], %o0
(*mt_entry->ops->unlock_h)( mt_entry );
2027eac: c2 02 20 0c ld [ %o0 + 0xc ], %g1
2027eb0: c2 00 60 04 ld [ %g1 + 4 ], %g1
2027eb4: 9f c0 40 00 call %g1
2027eb8: 01 00 00 00 nop
2027ebc: 81 c7 e0 08 ret
2027ec0: 81 e8 00 00 restore
owner,
group
);
rtems_filesystem_instance_unlock( &iop->pathinfo );
} else {
errno = EROFS;
2027ec4: 40 00 68 ca call 20421ec <__errno> <== NOT EXECUTED
2027ec8: 01 00 00 00 nop <== NOT EXECUTED
2027ecc: 82 10 20 1e mov 0x1e, %g1 ! 1e <PROM_START+0x1e> <== NOT EXECUTED
2027ed0: c2 22 00 00 st %g1, [ %o0 ]
rv = -1;
}
return rv;
}
2027ed4: 81 c7 e0 08 ret
2027ed8: 91 e8 3f ff restore %g0, -1, %o0
0203e5b4 <fcntl>:
int fcntl(
int fd,
int cmd,
...
)
{
203e5b4: 9d e3 bf 98 save %sp, -104, %sp
int fd2;
int flags;
int mask;
int ret = 0;
rtems_libio_check_fd( fd );
203e5b8: 05 00 81 ad sethi %hi(0x206b400), %g2
203e5bc: c4 00 a0 48 ld [ %g2 + 0x48 ], %g2 ! 206b448 <rtems_libio_number_iops>
...
)
{
int ret;
va_list ap;
va_start( ap, cmd );
203e5c0: 82 07 a0 4c add %fp, 0x4c, %g1
203e5c4: f4 27 a0 4c st %i2, [ %fp + 0x4c ]
203e5c8: f6 27 a0 50 st %i3, [ %fp + 0x50 ]
203e5cc: f8 27 a0 54 st %i4, [ %fp + 0x54 ]
203e5d0: fa 27 a0 58 st %i5, [ %fp + 0x58 ]
int fd2;
int flags;
int mask;
int ret = 0;
rtems_libio_check_fd( fd );
203e5d4: 80 a6 00 02 cmp %i0, %g2
203e5d8: 1a 80 00 0c bcc 203e608 <fcntl+0x54>
203e5dc: c2 27 bf fc st %g1, [ %fp + -4 ]
iop = rtems_libio_iop( fd );
203e5e0: 85 2e 20 03 sll %i0, 3, %g2
203e5e4: b1 2e 20 06 sll %i0, 6, %i0
203e5e8: b0 26 00 02 sub %i0, %g2, %i0
203e5ec: 05 00 81 bd sethi %hi(0x206f400), %g2
203e5f0: fa 00 a1 e0 ld [ %g2 + 0x1e0 ], %i5 ! 206f5e0 <rtems_libio_iops>
203e5f4: ba 07 40 18 add %i5, %i0, %i5
rtems_libio_check_is_open(iop);
203e5f8: d0 07 60 10 ld [ %i5 + 0x10 ], %o0
203e5fc: 80 8a 21 00 btst 0x100, %o0
203e600: 12 80 00 06 bne 203e618 <fcntl+0x64>
203e604: 80 a6 60 09 cmp %i1, 9
203e608: 40 00 0e f9 call 20421ec <__errno>
203e60c: 01 00 00 00 nop
203e610: 10 80 00 5d b 203e784 <fcntl+0x1d0>
203e614: 82 10 20 09 mov 9, %g1 ! 9 <PROM_START+0x9>
/*
* This switch should contain all the cases from POSIX.
*/
switch ( cmd ) {
203e618: 18 80 00 58 bgu 203e778 <fcntl+0x1c4>
203e61c: 85 2e 60 02 sll %i1, 2, %g2
203e620: 07 00 80 f9 sethi %hi(0x203e400), %g3
203e624: 86 10 e1 8c or %g3, 0x18c, %g3 ! 203e58c <fchdir+0x104>
203e628: c4 00 c0 02 ld [ %g3 + %g2 ], %g2
203e62c: 81 c0 80 00 jmp %g2
203e630: 01 00 00 00 nop
/*
* FIXME: We ignore the start value fd2 for the file descriptor search. This
* is not POSIX conform.
*/
rtems_libio_t *diop = rtems_libio_allocate();
203e634: 7f ff 2a 40 call 2008f34 <rtems_libio_allocate>
203e638: 01 00 00 00 nop
if (diop != NULL) {
203e63c: b8 92 20 00 orcc %o0, 0, %i4
203e640: 02 80 00 62 be 203e7c8 <fcntl+0x214>
203e644: b0 10 3f ff mov -1, %i0
int oflag = rtems_libio_to_fcntl_flags( iop->flags );
203e648: 7f ff 2a 25 call 2008edc <rtems_libio_to_fcntl_flags>
203e64c: d0 07 60 10 ld [ %i5 + 0x10 ], %o0
oflag &= ~O_CREAT;
diop->flags |= rtems_libio_fcntl_flags( oflag );
203e650: f4 07 20 10 ld [ %i4 + 0x10 ], %i2
rtems_libio_t *diop = rtems_libio_allocate();
if (diop != NULL) {
int oflag = rtems_libio_to_fcntl_flags( iop->flags );
oflag &= ~O_CREAT;
203e654: b6 0a 3d ff and %o0, -513, %i3
diop->flags |= rtems_libio_fcntl_flags( oflag );
203e658: 7f ff 2a 14 call 2008ea8 <rtems_libio_fcntl_flags>
203e65c: 90 10 00 1b mov %i3, %o0
203e660: 90 12 00 1a or %o0, %i2, %o0
203e664: d0 27 20 10 st %o0, [ %i4 + 0x10 ]
static inline void rtems_filesystem_instance_lock(
const rtems_filesystem_location_info_t *loc
)
{
const rtems_filesystem_mount_table_entry_t *mt_entry = loc->mt_entry;
203e668: d0 07 60 28 ld [ %i5 + 0x28 ], %o0
(*mt_entry->ops->lock_h)( mt_entry );
203e66c: c2 02 20 0c ld [ %o0 + 0xc ], %g1
203e670: c2 00 40 00 ld [ %g1 ], %g1
203e674: 9f c0 40 00 call %g1
203e678: 01 00 00 00 nop
rtems_filesystem_instance_lock( &iop->pathinfo );
rtems_filesystem_location_clone( &diop->pathinfo, &iop->pathinfo );
203e67c: 92 07 60 14 add %i5, 0x14, %o1
203e680: 7f ff a5 a4 call 2027d10 <rtems_filesystem_location_clone>
203e684: 90 07 20 14 add %i4, 0x14, %o0
static inline void rtems_filesystem_instance_unlock(
const rtems_filesystem_location_info_t *loc
)
{
const rtems_filesystem_mount_table_entry_t *mt_entry = loc->mt_entry;
203e688: d0 07 60 28 ld [ %i5 + 0x28 ], %o0
(*mt_entry->ops->unlock_h)( mt_entry );
203e68c: c2 02 20 0c ld [ %o0 + 0xc ], %g1
203e690: c2 00 60 04 ld [ %g1 + 4 ], %g1
203e694: 9f c0 40 00 call %g1
203e698: 01 00 00 00 nop
/*
* XXX: We call the open handler here to have a proper open and close pair.
*
* FIXME: What to do with the path?
*/
rv = (*diop->pathinfo.handlers->open_h)( diop, NULL, oflag, 0 );
203e69c: c2 07 20 24 ld [ %i4 + 0x24 ], %g1
203e6a0: 90 10 00 1c mov %i4, %o0
203e6a4: c2 00 40 00 ld [ %g1 ], %g1
203e6a8: 92 10 20 00 clr %o1
203e6ac: 94 10 00 1b mov %i3, %o2
203e6b0: 9f c0 40 00 call %g1
203e6b4: 96 10 20 00 clr %o3
if ( rv == 0 ) {
203e6b8: b0 92 20 00 orcc %o0, 0, %i0
203e6bc: 12 80 00 11 bne 203e700 <fcntl+0x14c> <== NEVER TAKEN
203e6c0: 03 00 81 bd sethi %hi(0x206f400), %g1
rv = diop - rtems_libio_iops;
203e6c4: f0 00 61 e0 ld [ %g1 + 0x1e0 ], %i0 ! 206f5e0 <rtems_libio_iops>
203e6c8: b8 27 00 18 sub %i4, %i0, %i4
203e6cc: b9 3f 20 03 sra %i4, 3, %i4
203e6d0: 85 2f 20 03 sll %i4, 3, %g2
203e6d4: 83 2f 20 06 sll %i4, 6, %g1
203e6d8: 82 00 80 01 add %g2, %g1, %g1
203e6dc: 85 28 60 06 sll %g1, 6, %g2
203e6e0: 82 00 40 02 add %g1, %g2, %g1
203e6e4: 82 00 40 1c add %g1, %i4, %g1
203e6e8: b1 28 60 0f sll %g1, 0xf, %i0
203e6ec: 82 00 40 18 add %g1, %i0, %g1
203e6f0: 83 28 60 03 sll %g1, 3, %g1
203e6f4: b8 00 40 1c add %g1, %i4, %i4
203e6f8: 10 80 00 25 b 203e78c <fcntl+0x1d8>
203e6fc: b0 20 00 1c neg %i4, %i0
} else {
rtems_libio_free( diop );
203e700: 7f ff 2a 24 call 2008f90 <rtems_libio_free> <== NOT EXECUTED
203e704: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
/*
* If we got this far successfully, then we give the optional
* filesystem specific handler a chance to process this.
*/
if (ret >= 0) {
203e708: 10 80 00 22 b 203e790 <fcntl+0x1dc> <== NOT EXECUTED
203e70c: 80 a6 20 00 cmp %i0, 0 <== NOT EXECUTED
fd2 = va_arg( ap, int );
ret = duplicate_iop( iop, fd2 );
break;
case F_GETFD: /* get f_flags */
ret = ((iop->flags & LIBIO_FLAGS_CLOSE_ON_EXEC) != 0);
203e710: b1 32 20 0b srl %o0, 0xb, %i0
203e714: 10 80 00 21 b 203e798 <fcntl+0x1e4>
203e718: b0 0e 20 01 and %i0, 1, %i0
* 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 ) )
203e71c: c2 00 40 00 ld [ %g1 ], %g1
203e720: 80 a0 60 00 cmp %g1, 0
203e724: 22 80 00 0e be,a 203e75c <fcntl+0x1a8>
203e728: 90 0a 37 ff and %o0, -2049, %o0
iop->flags |= LIBIO_FLAGS_CLOSE_ON_EXEC;
203e72c: 10 80 00 0c b 203e75c <fcntl+0x1a8>
203e730: 90 12 28 00 or %o0, 0x800, %o0
else
iop->flags &= ~LIBIO_FLAGS_CLOSE_ON_EXEC;
break;
case F_GETFL: /* more flags (cloexec) */
ret = rtems_libio_to_fcntl_flags( iop->flags );
203e734: 7f ff 29 ea call 2008edc <rtems_libio_to_fcntl_flags>
203e738: 01 00 00 00 nop
203e73c: 10 80 00 14 b 203e78c <fcntl+0x1d8>
203e740: b0 10 00 08 mov %o0, %i0
break;
case F_SETFL:
flags = rtems_libio_fcntl_flags( va_arg( ap, int ) );
203e744: 7f ff 29 d9 call 2008ea8 <rtems_libio_fcntl_flags>
203e748: d0 00 40 00 ld [ %g1 ], %o0
/*
* XXX If we are turning on append, should we seek to the end?
*/
iop->flags = (iop->flags & ~mask) | (flags & mask);
203e74c: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
203e750: 90 0a 22 01 and %o0, 0x201, %o0
203e754: 82 08 7d fe and %g1, -514, %g1
203e758: 90 12 00 01 or %o0, %g1, %o0
203e75c: d0 27 60 10 st %o0, [ %i5 + 0x10 ]
{
rtems_libio_t *iop;
int fd2;
int flags;
int mask;
int ret = 0;
203e760: 10 80 00 0e b 203e798 <fcntl+0x1e4>
203e764: b0 10 20 00 clr %i0
errno = ENOTSUP;
ret = -1;
break;
case F_GETOWN: /* for sockets. */
errno = ENOTSUP;
203e768: 40 00 0e a1 call 20421ec <__errno>
203e76c: 01 00 00 00 nop
203e770: 10 80 00 05 b 203e784 <fcntl+0x1d0>
203e774: 82 10 20 86 mov 0x86, %g1 ! 86 <PROM_START+0x86>
ret = -1;
break;
default:
errno = EINVAL;
203e778: 40 00 0e 9d call 20421ec <__errno>
203e77c: 01 00 00 00 nop
203e780: 82 10 20 16 mov 0x16, %g1 ! 16 <PROM_START+0x16>
203e784: 10 80 00 10 b 203e7c4 <fcntl+0x210>
203e788: c2 22 00 00 st %g1, [ %o0 ]
/*
* If we got this far successfully, then we give the optional
* filesystem specific handler a chance to process this.
*/
if (ret >= 0) {
203e78c: 80 a6 20 00 cmp %i0, 0
203e790: 06 80 00 0e bl 203e7c8 <fcntl+0x214> <== NEVER TAKEN
203e794: 01 00 00 00 nop
int err = (*iop->pathinfo.handlers->fcntl_h)( iop, cmd );
203e798: c2 07 60 24 ld [ %i5 + 0x24 ], %g1
203e79c: 90 10 00 1d mov %i5, %o0
203e7a0: c2 00 60 28 ld [ %g1 + 0x28 ], %g1
203e7a4: 9f c0 40 00 call %g1
203e7a8: 92 10 00 19 mov %i1, %o1
if (err) {
203e7ac: ba 92 20 00 orcc %o0, 0, %i5
203e7b0: 02 80 00 06 be 203e7c8 <fcntl+0x214> <== ALWAYS TAKEN
203e7b4: 01 00 00 00 nop
errno = err;
203e7b8: 40 00 0e 8d call 20421ec <__errno> <== NOT EXECUTED
203e7bc: 01 00 00 00 nop <== NOT EXECUTED
203e7c0: fa 22 00 00 st %i5, [ %o0 ] <== NOT EXECUTED
int mask;
int ret = 0;
rtems_libio_check_fd( fd );
iop = rtems_libio_iop( fd );
rtems_libio_check_is_open(iop);
203e7c4: b0 10 3f ff mov -1, %i0
va_list ap;
va_start( ap, cmd );
ret = vfcntl(fd,cmd,ap);
va_end(ap);
return ret;
}
203e7c8: 81 c7 e0 08 ret
203e7cc: 81 e8 00 00 restore
0200de74 <fifo_open>:
*/
int fifo_open(
pipe_control_t **pipep,
rtems_libio_t *iop
)
{
200de74: 9d e3 bf 98 save %sp, -104, %sp
static int pipe_lock(void)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
if (pipe_semaphore == RTEMS_ID_NONE) {
200de78: 3b 00 80 8d sethi %hi(0x2023400), %i5
200de7c: c2 07 61 d0 ld [ %i5 + 0x1d0 ], %g1 ! 20235d0 <pipe_semaphore>
*/
int fifo_open(
pipe_control_t **pipep,
rtems_libio_t *iop
)
{
200de80: b6 10 00 18 mov %i0, %i3
static int pipe_lock(void)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
if (pipe_semaphore == RTEMS_ID_NONE) {
200de84: 80 a0 60 00 cmp %g1, 0
200de88: 02 80 00 0c be 200deb8 <fifo_open+0x44>
200de8c: b8 17 61 d0 or %i5, 0x1d0, %i4
rtems_libio_unlock();
}
if (sc == RTEMS_SUCCESSFUL) {
sc = rtems_semaphore_obtain(pipe_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
200de90: 03 00 80 8d sethi %hi(0x2023400), %g1
200de94: d0 00 61 d0 ld [ %g1 + 0x1d0 ], %o0 ! 20235d0 <pipe_semaphore>
200de98: 92 10 20 00 clr %o1
200de9c: 7f ff ec ba call 2009184 <rtems_semaphore_obtain>
200dea0: 94 10 20 00 clr %o2
}
if (sc == RTEMS_SUCCESSFUL) {
200dea4: 80 a2 20 00 cmp %o0, 0
200dea8: 22 80 01 00 be,a 200e2a8 <fifo_open+0x434> <== ALWAYS TAKEN
200deac: fa 06 c0 00 ld [ %i3 ], %i5
return 0;
} else {
return -ENOMEM;
200deb0: 81 c7 e0 08 ret <== NOT EXECUTED
200deb4: 91 e8 3f f4 restore %g0, -12, %o0 <== NOT EXECUTED
*/
#include <rtems/userenv.h>
static inline void rtems_libio_lock( void )
{
rtems_semaphore_obtain( rtems_libio_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT );
200deb8: 03 00 80 8e sethi %hi(0x2023800), %g1
200debc: d0 00 60 3c ld [ %g1 + 0x3c ], %o0 ! 202383c <rtems_libio_semaphore>
200dec0: 92 10 20 00 clr %o1
200dec4: 7f ff ec b0 call 2009184 <rtems_semaphore_obtain>
200dec8: 94 10 20 00 clr %o2
rtems_status_code sc = RTEMS_SUCCESSFUL;
if (pipe_semaphore == RTEMS_ID_NONE) {
rtems_libio_lock();
if (pipe_semaphore == RTEMS_ID_NONE) {
200decc: c2 07 61 d0 ld [ %i5 + 0x1d0 ], %g1
200ded0: 80 a0 60 00 cmp %g1, 0
200ded4: 12 80 00 0a bne 200defc <fifo_open+0x88> <== NEVER TAKEN
200ded8: ba 10 20 00 clr %i5
sc = rtems_semaphore_create(
200dedc: 11 14 12 54 sethi %hi(0x50495000), %o0
200dee0: 92 10 20 01 mov 1, %o1
200dee4: 90 12 20 45 or %o0, 0x45, %o0
200dee8: 94 10 20 54 mov 0x54, %o2
200deec: 96 10 20 00 clr %o3
200def0: 7f ff ec 07 call 2008f0c <rtems_semaphore_create>
200def4: 98 10 00 1c mov %i4, %o4
200def8: ba 10 00 08 mov %o0, %i5
}
static inline void rtems_libio_unlock( void )
{
rtems_semaphore_release( rtems_libio_semaphore );
200defc: 03 00 80 8e sethi %hi(0x2023800), %g1
200df00: 7f ff ec eb call 20092ac <rtems_semaphore_release>
200df04: d0 00 60 3c ld [ %g1 + 0x3c ], %o0 ! 202383c <rtems_libio_semaphore>
}
rtems_libio_unlock();
}
if (sc == RTEMS_SUCCESSFUL) {
200df08: 80 a7 60 00 cmp %i5, 0
200df0c: 02 bf ff e1 be 200de90 <fifo_open+0x1c>
200df10: b0 10 3f f4 mov -12, %i0
200df14: 81 c7 e0 08 ret
200df18: 81 e8 00 00 restore
{
static char c = 'a';
pipe_control_t *pipe;
int err = -ENOMEM;
pipe = malloc(sizeof(pipe_control_t));
200df1c: 7f ff db ff call 2004f18 <malloc>
200df20: 90 10 20 34 mov 0x34, %o0
if (pipe == NULL)
200df24: ba 92 20 00 orcc %o0, 0, %i5
200df28: 02 80 00 e4 be 200e2b8 <fifo_open+0x444> <== NEVER TAKEN
200df2c: 92 10 20 00 clr %o1
return err;
memset(pipe, 0, sizeof(pipe_control_t));
200df30: 40 00 13 4e call 2012c68 <memset>
200df34: 94 10 20 34 mov 0x34, %o2
pipe->Size = PIPE_BUF;
200df38: 82 10 22 00 mov 0x200, %g1
pipe->Buffer = malloc(pipe->Size);
200df3c: 90 10 22 00 mov 0x200, %o0
200df40: 7f ff db f6 call 2004f18 <malloc>
200df44: c2 27 60 04 st %g1, [ %i5 + 4 ]
if (! pipe->Buffer)
200df48: 80 a2 20 00 cmp %o0, 0
200df4c: 02 80 00 40 be 200e04c <fifo_open+0x1d8> <== NEVER TAKEN
200df50: d0 27 40 00 st %o0, [ %i5 ]
goto err_buf;
err = -ENOMEM;
if (rtems_barrier_create(
rtems_build_name ('P', 'I', 'r', c),
200df54: 39 00 80 8b sethi %hi(0x2022c00), %i4
200df58: d0 4f 22 80 ldsb [ %i4 + 0x280 ], %o0 ! 2022e80 <c.7113>
if (! pipe->Buffer)
goto err_buf;
err = -ENOMEM;
if (rtems_barrier_create(
200df5c: 35 14 12 5c sethi %hi(0x50497000), %i2
200df60: 82 16 a2 00 or %i2, 0x200, %g1 ! 50497200 <RAM_END+0x4e097200>
200df64: 92 10 20 00 clr %o1
200df68: 90 12 00 01 or %o0, %g1, %o0
200df6c: 94 10 20 00 clr %o2
200df70: 40 00 05 f1 call 200f734 <rtems_barrier_create>
200df74: 96 07 60 2c add %i5, 0x2c, %o3
200df78: 80 a2 20 00 cmp %o0, 0
200df7c: 12 80 00 32 bne 200e044 <fifo_open+0x1d0>
200df80: d0 4f 22 80 ldsb [ %i4 + 0x280 ], %o0
rtems_build_name ('P', 'I', 'r', c),
RTEMS_BARRIER_MANUAL_RELEASE, 0,
&pipe->readBarrier) != RTEMS_SUCCESSFUL)
goto err_rbar;
if (rtems_barrier_create(
200df84: 03 14 12 5d sethi %hi(0x50497400), %g1
200df88: 82 10 63 00 or %g1, 0x300, %g1 ! 50497700 <RAM_END+0x4e097700>
200df8c: 92 10 20 00 clr %o1
200df90: 90 12 00 01 or %o0, %g1, %o0
200df94: 94 10 20 00 clr %o2
200df98: 40 00 05 e7 call 200f734 <rtems_barrier_create>
200df9c: 96 07 60 30 add %i5, 0x30, %o3
200dfa0: 80 a2 20 00 cmp %o0, 0
200dfa4: 12 80 00 26 bne 200e03c <fifo_open+0x1c8>
200dfa8: d0 4f 22 80 ldsb [ %i4 + 0x280 ], %o0
rtems_build_name ('P', 'I', 'w', c),
RTEMS_BARRIER_MANUAL_RELEASE, 0,
&pipe->writeBarrier) != RTEMS_SUCCESSFUL)
goto err_wbar;
if (rtems_semaphore_create(
200dfac: b4 16 a3 00 or %i2, 0x300, %i2
200dfb0: 92 10 20 01 mov 1, %o1
200dfb4: 90 12 00 1a or %o0, %i2, %o0
200dfb8: 94 10 20 10 mov 0x10, %o2
200dfbc: 96 10 20 00 clr %o3
200dfc0: 7f ff eb d3 call 2008f0c <rtems_semaphore_create>
200dfc4: 98 07 60 28 add %i5, 0x28, %o4
200dfc8: 80 a2 20 00 cmp %o0, 0
200dfcc: 12 80 00 1a bne 200e034 <fifo_open+0x1c0>
200dfd0: 94 07 bf fc add %fp, -4, %o2
RTEMS_INLINE_ROUTINE Barrier_Control *_Barrier_Get (
Objects_Id id,
Objects_Locations *location
)
{
return (Barrier_Control *)
200dfd4: d2 07 60 2c ld [ %i5 + 0x2c ], %o1
200dfd8: 31 00 80 90 sethi %hi(0x2024000), %i0
200dfdc: 7f ff f2 e9 call 200ab80 <_Objects_Get>
200dfe0: 90 16 23 00 or %i0, 0x300, %o0 ! 2024300 <_Barrier_Information>
static void pipe_interruptible(pipe_control_t *pipe)
{
Objects_Locations location;
_Barrier_Get(pipe->readBarrier, &location)->Barrier.Wait_queue.state
|= STATES_INTERRUPTIBLE_BY_SIGNAL;
200dfe4: c2 02 20 4c ld [ %o0 + 0x4c ], %g1
200dfe8: 35 04 00 00 sethi %hi(0x10000000), %i2
200dfec: 82 10 40 1a or %g1, %i2, %g1
_Thread_Enable_dispatch();
200dff0: 7f ff f6 90 call 200ba30 <_Thread_Enable_dispatch>
200dff4: c2 22 20 4c st %g1, [ %o0 + 0x4c ]
200dff8: d2 07 60 30 ld [ %i5 + 0x30 ], %o1
200dffc: 94 07 bf fc add %fp, -4, %o2
200e000: 7f ff f2 e0 call 200ab80 <_Objects_Get>
200e004: 90 16 23 00 or %i0, 0x300, %o0
_Barrier_Get(pipe->writeBarrier, &location)->Barrier.Wait_queue.state
|= STATES_INTERRUPTIBLE_BY_SIGNAL;
200e008: c2 02 20 4c ld [ %o0 + 0x4c ], %g1
200e00c: b4 10 40 1a or %g1, %i2, %i2
_Thread_Enable_dispatch();
200e010: 7f ff f6 88 call 200ba30 <_Thread_Enable_dispatch>
200e014: f4 22 20 4c st %i2, [ %o0 + 0x4c ]
#ifdef RTEMS_POSIX_API
pipe_interruptible(pipe);
#endif
*pipep = pipe;
if (c ++ == 'z')
200e018: c2 0f 22 80 ldub [ %i4 + 0x280 ], %g1
200e01c: c4 4f 22 80 ldsb [ %i4 + 0x280 ], %g2
200e020: 80 a0 a0 7a cmp %g2, 0x7a
200e024: 12 80 00 a7 bne 200e2c0 <fifo_open+0x44c>
200e028: 82 00 60 01 inc %g1
c = 'a';
200e02c: 10 80 00 a5 b 200e2c0 <fifo_open+0x44c>
200e030: 82 10 20 61 mov 0x61, %g1
return 0;
err_sem:
rtems_barrier_delete(pipe->writeBarrier);
200e034: 40 00 05 f0 call 200f7f4 <rtems_barrier_delete>
200e038: d0 07 60 30 ld [ %i5 + 0x30 ], %o0
err_wbar:
rtems_barrier_delete(pipe->readBarrier);
200e03c: 40 00 05 ee call 200f7f4 <rtems_barrier_delete>
200e040: d0 07 60 2c ld [ %i5 + 0x2c ], %o0
err_rbar:
free(pipe->Buffer);
200e044: 7f ff da 8c call 2004a74 <free>
200e048: d0 07 40 00 ld [ %i5 ], %o0
err_buf:
free(pipe);
200e04c: 7f ff da 8a call 2004a74 <free>
200e050: 90 10 00 1d mov %i5, %o0
if (err)
goto out;
}
if (! PIPE_LOCK(pipe))
err = -EINTR;
200e054: 10 80 00 13 b 200e0a0 <fifo_open+0x22c>
200e058: b0 10 3f f4 mov -12, %i0
err = pipe_alloc(&pipe);
if (err)
goto out;
}
if (! PIPE_LOCK(pipe))
200e05c: d0 07 60 28 ld [ %i5 + 0x28 ], %o0
200e060: 92 10 20 00 clr %o1
200e064: 7f ff ec 48 call 2009184 <rtems_semaphore_obtain>
200e068: 94 10 20 00 clr %o2
err = -EINTR;
if (*pipep == NULL) {
200e06c: c2 06 c0 00 ld [ %i3 ], %g1
err = pipe_alloc(&pipe);
if (err)
goto out;
}
if (! PIPE_LOCK(pipe))
200e070: 80 a0 00 08 cmp %g0, %o0
200e074: b0 60 20 00 subx %g0, 0, %i0
err = -EINTR;
if (*pipep == NULL) {
200e078: 80 a0 60 00 cmp %g1, 0
200e07c: 12 80 00 09 bne 200e0a0 <fifo_open+0x22c>
200e080: b0 0e 3f fc and %i0, -4, %i0
if (err)
200e084: 80 a6 20 00 cmp %i0, 0
200e088: 22 80 00 06 be,a 200e0a0 <fifo_open+0x22c> <== ALWAYS TAKEN
200e08c: fa 26 c0 00 st %i5, [ %i3 ]
pipe_free(pipe);
200e090: 7f ff ff 41 call 200dd94 <pipe_free> <== NOT EXECUTED
200e094: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
#ifdef RTEMS_DEBUG
rtems_status_code sc = RTEMS_SUCCESSFUL;
sc =
#endif
rtems_semaphore_release(pipe_semaphore);
200e098: 10 80 00 03 b 200e0a4 <fifo_open+0x230> <== NOT EXECUTED
200e09c: 03 00 80 8d sethi %hi(0x2023400), %g1 <== NOT EXECUTED
200e0a0: 03 00 80 8d sethi %hi(0x2023400), %g1
200e0a4: 7f ff ec 82 call 20092ac <rtems_semaphore_release>
200e0a8: d0 00 61 d0 ld [ %g1 + 0x1d0 ], %o0 ! 20235d0 <pipe_semaphore>
pipe_control_t *pipe;
unsigned int prevCounter;
int err;
err = pipe_new(pipep);
if (err)
200e0ac: 80 a6 20 00 cmp %i0, 0
200e0b0: 12 80 00 86 bne 200e2c8 <fifo_open+0x454>
200e0b4: 01 00 00 00 nop
return err;
pipe = *pipep;
switch (LIBIO_ACCMODE(iop)) {
200e0b8: c2 06 60 10 ld [ %i1 + 0x10 ], %g1
200e0bc: 82 08 60 06 and %g1, 6, %g1
200e0c0: 80 a0 60 04 cmp %g1, 4
200e0c4: 02 80 00 2e be 200e17c <fifo_open+0x308>
200e0c8: fa 06 c0 00 ld [ %i3 ], %i5
200e0cc: 80 a0 60 06 cmp %g1, 6
200e0d0: 02 80 00 56 be 200e228 <fifo_open+0x3b4>
200e0d4: 80 a0 60 02 cmp %g1, 2
200e0d8: 12 80 00 6a bne 200e280 <fifo_open+0x40c> <== NEVER TAKEN
200e0dc: 01 00 00 00 nop
case LIBIO_FLAGS_READ:
pipe->readerCounter ++;
200e0e0: c2 07 60 20 ld [ %i5 + 0x20 ], %g1
200e0e4: 82 00 60 01 inc %g1
200e0e8: c2 27 60 20 st %g1, [ %i5 + 0x20 ]
if (pipe->Readers ++ == 0)
200e0ec: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
200e0f0: 84 00 60 01 add %g1, 1, %g2
200e0f4: 80 a0 60 00 cmp %g1, 0
200e0f8: 12 80 00 05 bne 200e10c <fifo_open+0x298> <== NEVER TAKEN
200e0fc: c4 27 60 10 st %g2, [ %i5 + 0x10 ]
PIPE_WAKEUPWRITERS(pipe);
200e100: d0 07 60 30 ld [ %i5 + 0x30 ], %o0
200e104: 40 00 05 e5 call 200f898 <rtems_barrier_release>
200e108: 92 07 bf f8 add %fp, -8, %o1
if (pipe->Writers == 0) {
200e10c: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
200e110: 80 a0 60 00 cmp %g1, 0
200e114: 12 80 00 5b bne 200e280 <fifo_open+0x40c>
200e118: 01 00 00 00 nop
/* Not an error */
if (LIBIO_NODELAY(iop))
200e11c: c2 06 60 10 ld [ %i1 + 0x10 ], %g1
200e120: 80 88 60 01 btst 1, %g1
200e124: 12 80 00 57 bne 200e280 <fifo_open+0x40c>
200e128: 01 00 00 00 nop
break;
prevCounter = pipe->writerCounter;
200e12c: f8 07 60 24 ld [ %i5 + 0x24 ], %i4
err = -EINTR;
/* Wait until a writer opens the pipe */
do {
PIPE_UNLOCK(pipe);
200e130: 7f ff ec 5f call 20092ac <rtems_semaphore_release>
200e134: d0 07 60 28 ld [ %i5 + 0x28 ], %o0
if (! PIPE_READWAIT(pipe))
200e138: d0 07 60 2c ld [ %i5 + 0x2c ], %o0
200e13c: 40 00 05 ed call 200f8f0 <rtems_barrier_wait>
200e140: 92 10 20 00 clr %o1
200e144: 80 a2 20 00 cmp %o0, 0
200e148: 12 80 00 52 bne 200e290 <fifo_open+0x41c> <== NEVER TAKEN
200e14c: 92 10 20 00 clr %o1
goto out_error;
if (! PIPE_LOCK(pipe))
200e150: d0 07 60 28 ld [ %i5 + 0x28 ], %o0
200e154: 7f ff ec 0c call 2009184 <rtems_semaphore_obtain>
200e158: 94 10 20 00 clr %o2
200e15c: 80 a2 20 00 cmp %o0, 0
200e160: 32 80 00 4d bne,a 200e294 <fifo_open+0x420> <== NEVER TAKEN
200e164: b0 10 3f fc mov -4, %i0 <== NOT EXECUTED
goto out_error;
} while (prevCounter == pipe->writerCounter);
200e168: c2 07 60 24 ld [ %i5 + 0x24 ], %g1
200e16c: 80 a7 00 01 cmp %i4, %g1
200e170: 02 bf ff f0 be 200e130 <fifo_open+0x2bc> <== NEVER TAKEN
200e174: 01 00 00 00 nop
200e178: 30 80 00 42 b,a 200e280 <fifo_open+0x40c>
}
break;
case LIBIO_FLAGS_WRITE:
pipe->writerCounter ++;
200e17c: c2 07 60 24 ld [ %i5 + 0x24 ], %g1
200e180: 82 00 60 01 inc %g1
200e184: c2 27 60 24 st %g1, [ %i5 + 0x24 ]
if (pipe->Writers ++ == 0)
200e188: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
200e18c: 84 00 60 01 add %g1, 1, %g2
200e190: 80 a0 60 00 cmp %g1, 0
200e194: 12 80 00 05 bne 200e1a8 <fifo_open+0x334> <== NEVER TAKEN
200e198: c4 27 60 14 st %g2, [ %i5 + 0x14 ]
PIPE_WAKEUPREADERS(pipe);
200e19c: d0 07 60 2c ld [ %i5 + 0x2c ], %o0
200e1a0: 40 00 05 be call 200f898 <rtems_barrier_release>
200e1a4: 92 07 bf f8 add %fp, -8, %o1
if (pipe->Readers == 0 && LIBIO_NODELAY(iop)) {
200e1a8: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
200e1ac: 80 a0 60 00 cmp %g1, 0
200e1b0: 12 80 00 34 bne 200e280 <fifo_open+0x40c>
200e1b4: 01 00 00 00 nop
200e1b8: c2 06 60 10 ld [ %i1 + 0x10 ], %g1
200e1bc: 80 88 60 01 btst 1, %g1
200e1c0: 22 80 00 07 be,a 200e1dc <fifo_open+0x368>
200e1c4: f8 07 60 20 ld [ %i5 + 0x20 ], %i4
PIPE_UNLOCK(pipe);
200e1c8: d0 07 60 28 ld [ %i5 + 0x28 ], %o0
200e1cc: 7f ff ec 38 call 20092ac <rtems_semaphore_release>
200e1d0: b0 10 3f fa mov -6, %i0
err = -ENXIO;
goto out_error;
200e1d4: 10 80 00 31 b 200e298 <fifo_open+0x424>
200e1d8: 90 10 00 1b mov %i3, %o0
if (pipe->Readers == 0) {
prevCounter = pipe->readerCounter;
err = -EINTR;
do {
PIPE_UNLOCK(pipe);
200e1dc: 7f ff ec 34 call 20092ac <rtems_semaphore_release>
200e1e0: d0 07 60 28 ld [ %i5 + 0x28 ], %o0
if (! PIPE_WRITEWAIT(pipe))
200e1e4: d0 07 60 30 ld [ %i5 + 0x30 ], %o0
200e1e8: 40 00 05 c2 call 200f8f0 <rtems_barrier_wait>
200e1ec: 92 10 20 00 clr %o1
200e1f0: 80 a2 20 00 cmp %o0, 0
200e1f4: 12 80 00 27 bne 200e290 <fifo_open+0x41c> <== NEVER TAKEN
200e1f8: 92 10 20 00 clr %o1
goto out_error;
if (! PIPE_LOCK(pipe))
200e1fc: d0 07 60 28 ld [ %i5 + 0x28 ], %o0
200e200: 7f ff eb e1 call 2009184 <rtems_semaphore_obtain>
200e204: 94 10 20 00 clr %o2
200e208: 80 a2 20 00 cmp %o0, 0
200e20c: 32 80 00 22 bne,a 200e294 <fifo_open+0x420> <== NEVER TAKEN
200e210: b0 10 3f fc mov -4, %i0 <== NOT EXECUTED
goto out_error;
} while (prevCounter == pipe->readerCounter);
200e214: c2 07 60 20 ld [ %i5 + 0x20 ], %g1
200e218: 80 a7 00 01 cmp %i4, %g1
200e21c: 02 bf ff f0 be 200e1dc <fifo_open+0x368> <== NEVER TAKEN
200e220: 01 00 00 00 nop
200e224: 30 80 00 17 b,a 200e280 <fifo_open+0x40c>
}
break;
case LIBIO_FLAGS_READ_WRITE:
pipe->readerCounter ++;
200e228: c2 07 60 20 ld [ %i5 + 0x20 ], %g1
200e22c: 82 00 60 01 inc %g1
200e230: c2 27 60 20 st %g1, [ %i5 + 0x20 ]
if (pipe->Readers ++ == 0)
200e234: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
200e238: 84 00 60 01 add %g1, 1, %g2
200e23c: 80 a0 60 00 cmp %g1, 0
200e240: 12 80 00 05 bne 200e254 <fifo_open+0x3e0> <== NEVER TAKEN
200e244: c4 27 60 10 st %g2, [ %i5 + 0x10 ]
PIPE_WAKEUPWRITERS(pipe);
200e248: d0 07 60 30 ld [ %i5 + 0x30 ], %o0
200e24c: 40 00 05 93 call 200f898 <rtems_barrier_release>
200e250: 92 07 bf f8 add %fp, -8, %o1
pipe->writerCounter ++;
200e254: c2 07 60 24 ld [ %i5 + 0x24 ], %g1
200e258: 82 00 60 01 inc %g1
200e25c: c2 27 60 24 st %g1, [ %i5 + 0x24 ]
if (pipe->Writers ++ == 0)
200e260: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
200e264: 84 00 60 01 add %g1, 1, %g2
200e268: 80 a0 60 00 cmp %g1, 0
200e26c: 12 80 00 05 bne 200e280 <fifo_open+0x40c> <== NEVER TAKEN
200e270: c4 27 60 14 st %g2, [ %i5 + 0x14 ]
PIPE_WAKEUPREADERS(pipe);
200e274: d0 07 60 2c ld [ %i5 + 0x2c ], %o0
200e278: 40 00 05 88 call 200f898 <rtems_barrier_release>
200e27c: 92 07 bf f8 add %fp, -8, %o1
break;
}
PIPE_UNLOCK(pipe);
200e280: 7f ff ec 0b call 20092ac <rtems_semaphore_release>
200e284: d0 07 60 28 ld [ %i5 + 0x28 ], %o0
return 0;
200e288: 81 c7 e0 08 ret
200e28c: 81 e8 00 00 restore
/* Not an error */
if (LIBIO_NODELAY(iop))
break;
prevCounter = pipe->writerCounter;
err = -EINTR;
200e290: b0 10 3f fc mov -4, %i0 <== NOT EXECUTED
PIPE_UNLOCK(pipe);
return 0;
out_error:
pipe_release(pipep, iop);
200e294: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
200e298: 7f ff fe ca call 200ddc0 <pipe_release>
200e29c: 92 10 00 19 mov %i1, %o1
return err;
200e2a0: 81 c7 e0 08 ret
200e2a4: 81 e8 00 00 restore
err = pipe_lock();
if (err)
return err;
pipe = *pipep;
if (pipe == NULL) {
200e2a8: 80 a7 60 00 cmp %i5, 0
200e2ac: 32 bf ff 6d bne,a 200e060 <fifo_open+0x1ec>
200e2b0: d0 07 60 28 ld [ %i5 + 0x28 ], %o0
200e2b4: 30 bf ff 1a b,a 200df1c <fifo_open+0xa8>
if (err)
goto out;
}
if (! PIPE_LOCK(pipe))
err = -EINTR;
200e2b8: 10 bf ff 7a b 200e0a0 <fifo_open+0x22c> <== NOT EXECUTED
200e2bc: b0 10 3f f4 mov -12, %i0 <== NOT EXECUTED
#ifdef RTEMS_POSIX_API
pipe_interruptible(pipe);
#endif
*pipep = pipe;
if (c ++ == 'z')
200e2c0: 10 bf ff 67 b 200e05c <fifo_open+0x1e8>
200e2c4: c2 2f 22 80 stb %g1, [ %i4 + 0x280 ]
return 0;
out_error:
pipe_release(pipep, iop);
return err;
}
200e2c8: 81 c7 e0 08 ret
200e2cc: 81 e8 00 00 restore
020099ac <fpathconf>:
long fpathconf(
int fd,
int name
)
{
20099ac: 9d e3 bf a0 save %sp, -96, %sp
long return_value;
rtems_libio_t *iop;
const rtems_filesystem_limits_and_options_t *the_limits;
rtems_libio_check_fd(fd);
20099b0: 03 00 80 49 sethi %hi(0x2012400), %g1
20099b4: c2 00 63 e4 ld [ %g1 + 0x3e4 ], %g1 ! 20127e4 <rtems_libio_number_iops>
20099b8: 80 a6 00 01 cmp %i0, %g1
20099bc: 2a 80 00 03 bcs,a 20099c8 <fpathconf+0x1c> <== NEVER TAKEN
20099c0: 83 2e 20 03 sll %i0, 3, %g1 <== NOT EXECUTED
20099c4: 30 80 00 0a b,a 20099ec <fpathconf+0x40>
iop = rtems_libio_iop(fd);
20099c8: b1 2e 20 06 sll %i0, 6, %i0 <== NOT EXECUTED
20099cc: b0 26 00 01 sub %i0, %g1, %i0 <== NOT EXECUTED
20099d0: 03 00 80 4c sethi %hi(0x2013000), %g1 <== NOT EXECUTED
20099d4: c2 00 60 d4 ld [ %g1 + 0xd4 ], %g1 ! 20130d4 <rtems_libio_iops><== NOT EXECUTED
20099d8: b0 00 40 18 add %g1, %i0, %i0 <== NOT EXECUTED
rtems_libio_check_is_open(iop);
20099dc: c2 06 20 10 ld [ %i0 + 0x10 ], %g1 <== NOT EXECUTED
20099e0: 80 88 61 00 btst 0x100, %g1 <== NOT EXECUTED
20099e4: 32 80 00 06 bne,a 20099fc <fpathconf+0x50> <== NOT EXECUTED
20099e8: c2 06 20 28 ld [ %i0 + 0x28 ], %g1 <== NOT EXECUTED
20099ec: 40 00 09 30 call 200beac <__errno>
20099f0: 01 00 00 00 nop
20099f4: 10 80 00 32 b 2009abc <fpathconf+0x110>
20099f8: 82 10 20 09 mov 9, %g1 ! 9 <PROM_START+0x9>
* Now process the information request.
*/
the_limits = iop->pathinfo.mt_entry->pathconf_limits_and_options;
switch ( name ) {
20099fc: 80 a6 60 0b cmp %i1, 0xb <== NOT EXECUTED
2009a00: 18 80 00 2c bgu 2009ab0 <fpathconf+0x104> <== NOT EXECUTED
2009a04: c2 00 60 2c ld [ %g1 + 0x2c ], %g1 <== NOT EXECUTED
2009a08: b3 2e 60 02 sll %i1, 2, %i1 <== NOT EXECUTED
2009a0c: 05 00 80 26 sethi %hi(0x2009800), %g2 <== NOT EXECUTED
2009a10: 84 10 a1 7c or %g2, 0x17c, %g2 ! 200997c <_close_r+0x10> <== NOT EXECUTED
2009a14: c4 00 80 19 ld [ %g2 + %i1 ], %g2 <== NOT EXECUTED
2009a18: 81 c0 80 00 jmp %g2 <== NOT EXECUTED
2009a1c: 01 00 00 00 nop <== NOT EXECUTED
case _PC_LINK_MAX:
return_value = the_limits->link_max;
2009a20: f0 00 40 00 ld [ %g1 ], %i0 <== NOT EXECUTED
break;
2009a24: 81 c7 e0 08 ret <== NOT EXECUTED
2009a28: 81 e8 00 00 restore <== NOT EXECUTED
case _PC_MAX_CANON:
return_value = the_limits->max_canon;
2009a2c: f0 00 60 04 ld [ %g1 + 4 ], %i0 <== NOT EXECUTED
break;
2009a30: 81 c7 e0 08 ret <== NOT EXECUTED
2009a34: 81 e8 00 00 restore <== NOT EXECUTED
case _PC_MAX_INPUT:
return_value = the_limits->max_input;
2009a38: f0 00 60 08 ld [ %g1 + 8 ], %i0 <== NOT EXECUTED
break;
2009a3c: 81 c7 e0 08 ret <== NOT EXECUTED
2009a40: 81 e8 00 00 restore <== NOT EXECUTED
case _PC_NAME_MAX:
return_value = the_limits->name_max;
2009a44: f0 00 60 0c ld [ %g1 + 0xc ], %i0 <== NOT EXECUTED
break;
2009a48: 81 c7 e0 08 ret <== NOT EXECUTED
2009a4c: 81 e8 00 00 restore <== NOT EXECUTED
case _PC_PATH_MAX:
return_value = the_limits->path_max;
2009a50: f0 00 60 10 ld [ %g1 + 0x10 ], %i0 <== NOT EXECUTED
break;
2009a54: 81 c7 e0 08 ret <== NOT EXECUTED
2009a58: 81 e8 00 00 restore <== NOT EXECUTED
case _PC_PIPE_BUF:
return_value = the_limits->pipe_buf;
2009a5c: f0 00 60 14 ld [ %g1 + 0x14 ], %i0 <== NOT EXECUTED
break;
2009a60: 81 c7 e0 08 ret <== NOT EXECUTED
2009a64: 81 e8 00 00 restore <== NOT EXECUTED
case _PC_CHOWN_RESTRICTED:
return_value = the_limits->posix_chown_restrictions;
2009a68: f0 00 60 1c ld [ %g1 + 0x1c ], %i0 <== NOT EXECUTED
break;
2009a6c: 81 c7 e0 08 ret <== NOT EXECUTED
2009a70: 81 e8 00 00 restore <== NOT EXECUTED
case _PC_NO_TRUNC:
return_value = the_limits->posix_no_trunc;
2009a74: f0 00 60 20 ld [ %g1 + 0x20 ], %i0 <== NOT EXECUTED
break;
2009a78: 81 c7 e0 08 ret <== NOT EXECUTED
2009a7c: 81 e8 00 00 restore <== NOT EXECUTED
case _PC_VDISABLE:
return_value = the_limits->posix_vdisable;
2009a80: f0 00 60 2c ld [ %g1 + 0x2c ], %i0 <== NOT EXECUTED
break;
2009a84: 81 c7 e0 08 ret <== NOT EXECUTED
2009a88: 81 e8 00 00 restore <== NOT EXECUTED
case _PC_ASYNC_IO:
return_value = the_limits->posix_async_io;
2009a8c: f0 00 60 18 ld [ %g1 + 0x18 ], %i0 <== NOT EXECUTED
break;
2009a90: 81 c7 e0 08 ret <== NOT EXECUTED
2009a94: 81 e8 00 00 restore <== NOT EXECUTED
case _PC_PRIO_IO:
return_value = the_limits->posix_prio_io;
2009a98: f0 00 60 24 ld [ %g1 + 0x24 ], %i0 <== NOT EXECUTED
break;
2009a9c: 81 c7 e0 08 ret <== NOT EXECUTED
2009aa0: 81 e8 00 00 restore <== NOT EXECUTED
case _PC_SYNC_IO:
return_value = the_limits->posix_sync_io;
2009aa4: f0 00 60 28 ld [ %g1 + 0x28 ], %i0 <== NOT EXECUTED
break;
2009aa8: 81 c7 e0 08 ret <== NOT EXECUTED
2009aac: 81 e8 00 00 restore <== NOT EXECUTED
default:
rtems_set_errno_and_return_minus_one( EINVAL );
2009ab0: 40 00 08 ff call 200beac <__errno> <== NOT EXECUTED
2009ab4: 01 00 00 00 nop <== NOT EXECUTED
2009ab8: 82 10 20 16 mov 0x16, %g1 ! 16 <PROM_START+0x16> <== NOT EXECUTED
2009abc: c2 22 00 00 st %g1, [ %o0 ]
break;
}
return return_value;
}
2009ac0: 81 c7 e0 08 ret
2009ac4: 91 e8 3f ff restore %g0, -1, %o0
020037dc <free>:
#include <stdlib.h>
void free(
void *ptr
)
{
20037dc: 9d e3 bf a0 save %sp, -96, %sp
MSBUMP(free_calls, 1);
20037e0: 03 00 80 76 sethi %hi(0x201d800), %g1
20037e4: 82 10 61 58 or %g1, 0x158, %g1 ! 201d958 <rtems_malloc_statistics>
20037e8: c4 00 60 0c ld [ %g1 + 0xc ], %g2
#include <stdlib.h>
void free(
void *ptr
)
{
20037ec: b2 10 00 18 mov %i0, %i1
MSBUMP(free_calls, 1);
20037f0: 84 00 a0 01 inc %g2
if ( !ptr )
20037f4: 80 a6 20 00 cmp %i0, 0
20037f8: 02 80 00 21 be 200387c <free+0xa0>
20037fc: c4 20 60 0c st %g2, [ %g1 + 0xc ]
return;
/*
* Do not attempt to free memory if in a critical section or ISR.
*/
if ( _System_state_Is_up(_System_state_Get()) &&
2003800: 03 00 80 77 sethi %hi(0x201dc00), %g1
2003804: c2 00 60 20 ld [ %g1 + 0x20 ], %g1 ! 201dc20 <_System_state_Current>
2003808: 80 a0 60 03 cmp %g1, 3
200380c: 12 80 00 09 bne 2003830 <free+0x54> <== NEVER TAKEN
2003810: 03 00 80 75 sethi %hi(0x201d400), %g1
!malloc_is_system_state_OK() ) {
2003814: 40 00 00 7c call 2003a04 <malloc_is_system_state_OK>
2003818: 01 00 00 00 nop
return;
/*
* Do not attempt to free memory if in a critical section or ISR.
*/
if ( _System_state_Is_up(_System_state_Get()) &&
200381c: 80 8a 20 ff btst 0xff, %o0
2003820: 12 80 00 04 bne 2003830 <free+0x54>
2003824: 03 00 80 75 sethi %hi(0x201d400), %g1
!malloc_is_system_state_OK() ) {
malloc_deferred_free(ptr);
2003828: 40 00 00 97 call 2003a84 <malloc_deferred_free>
200382c: 81 e8 00 00 restore
}
/*
* If configured, update the statistics
*/
if ( rtems_malloc_statistics_helpers )
2003830: c2 00 61 94 ld [ %g1 + 0x194 ], %g1
2003834: 80 a0 60 00 cmp %g1, 0
2003838: 02 80 00 06 be 2003850 <free+0x74>
200383c: 3b 00 80 73 sethi %hi(0x201cc00), %i5
(*rtems_malloc_statistics_helpers->at_free)(ptr);
2003840: c2 00 60 08 ld [ %g1 + 8 ], %g1
2003844: 9f c0 40 00 call %g1
2003848: 90 10 00 19 mov %i1, %o0
if ( !_Protected_heap_Free( RTEMS_Malloc_Heap, ptr ) ) {
200384c: 3b 00 80 73 sethi %hi(0x201cc00), %i5
2003850: d0 07 61 dc ld [ %i5 + 0x1dc ], %o0 ! 201cddc <RTEMS_Malloc_Heap>
2003854: 40 00 17 4a call 200957c <_Protected_heap_Free>
2003858: 92 10 00 19 mov %i1, %o1
200385c: 80 8a 20 ff btst 0xff, %o0
2003860: 12 80 00 07 bne 200387c <free+0xa0>
2003864: c2 07 61 dc ld [ %i5 + 0x1dc ], %g1
printk( "Program heap: free of bad pointer %p -- range %p - %p \n",
2003868: 31 00 80 6d sethi %hi(0x201b400), %i0
200386c: f4 00 60 18 ld [ %g1 + 0x18 ], %i2
2003870: f6 00 60 1c ld [ %g1 + 0x1c ], %i3
2003874: 40 00 03 7e call 200466c <printk>
2003878: 91 ee 22 d0 restore %i0, 0x2d0, %o0
200387c: 81 c7 e0 08 ret
2003880: 81 e8 00 00 restore
0201a034 <fstat>:
int fstat(
int fd,
struct stat *sbuf
)
{
201a034: 9d e3 bf a0 save %sp, -96, %sp
rtems_libio_t *iop;
/*
* Check to see if we were passed a valid pointer.
*/
if ( !sbuf )
201a038: 80 a6 60 00 cmp %i1, 0
201a03c: 32 80 00 06 bne,a 201a054 <fstat+0x20> <== ALWAYS TAKEN
201a040: 03 00 80 73 sethi %hi(0x201cc00), %g1
rtems_set_errno_and_return_minus_one( EFAULT );
201a044: 7f ff d6 73 call 200fa10 <__errno> <== NOT EXECUTED
201a048: 01 00 00 00 nop <== NOT EXECUTED
201a04c: 10 80 00 12 b 201a094 <fstat+0x60> <== NOT EXECUTED
201a050: 82 10 20 0e mov 0xe, %g1 ! e <PROM_START+0xe> <== NOT EXECUTED
/*
* Now process the stat() request.
*/
iop = rtems_libio_iop( fd );
201a054: c2 00 62 20 ld [ %g1 + 0x220 ], %g1
201a058: 80 a6 00 01 cmp %i0, %g1
201a05c: 1a 80 00 0b bcc 201a088 <fstat+0x54>
201a060: 83 2e 20 03 sll %i0, 3, %g1
201a064: b1 2e 20 06 sll %i0, 6, %i0
201a068: b0 26 00 01 sub %i0, %g1, %i0
201a06c: 03 00 80 76 sethi %hi(0x201d800), %g1
201a070: c2 00 61 40 ld [ %g1 + 0x140 ], %g1 ! 201d940 <rtems_libio_iops>
201a074: b0 00 40 18 add %g1, %i0, %i0
rtems_libio_check_fd( fd );
rtems_libio_check_is_open(iop);
201a078: c2 06 20 10 ld [ %i0 + 0x10 ], %g1
201a07c: 80 88 61 00 btst 0x100, %g1
201a080: 12 80 00 08 bne 201a0a0 <fstat+0x6c>
201a084: 94 10 20 48 mov 0x48, %o2
/*
* Now process the stat() request.
*/
iop = rtems_libio_iop( fd );
rtems_libio_check_fd( fd );
201a088: 7f ff d6 62 call 200fa10 <__errno>
201a08c: 01 00 00 00 nop
201a090: 82 10 20 09 mov 9, %g1 ! 9 <PROM_START+0x9>
201a094: c2 22 00 00 st %g1, [ %o0 ]
201a098: 81 c7 e0 08 ret
201a09c: 91 e8 3f ff restore %g0, -1, %o0
/*
* Zero out the stat structure so the various support
* versions of stat don't have to.
*/
memset( sbuf, 0, sizeof(struct stat) );
201a0a0: 90 10 00 19 mov %i1, %o0
201a0a4: 7f ff d8 df call 2010420 <memset>
201a0a8: 92 10 20 00 clr %o1
return (*iop->pathinfo.handlers->fstat_h)( &iop->pathinfo, sbuf );
201a0ac: c2 06 20 24 ld [ %i0 + 0x24 ], %g1
201a0b0: 90 06 20 14 add %i0, 0x14, %o0
201a0b4: c2 00 60 18 ld [ %g1 + 0x18 ], %g1
201a0b8: 9f c0 40 00 call %g1
201a0bc: 92 10 00 19 mov %i1, %o1
}
201a0c0: 81 c7 e0 08 ret
201a0c4: 91 e8 00 08 restore %g0, %o0, %o0
020036e8 <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) {
20036e8: 03 00 80 85 sethi %hi(0x2021400), %g1
20036ec: c2 00 63 60 ld [ %g1 + 0x360 ], %g1 ! 2021760 <disktab_size>
20036f0: 80 a2 00 01 cmp %o0, %g1
20036f4: 1a 80 00 1e bcc 200376c <get_disk_entry+0x84> <== NEVER TAKEN
20036f8: 03 00 80 85 sethi %hi(0x2021400), %g1
20036fc: c2 00 63 64 ld [ %g1 + 0x364 ], %g1 ! 2021764 <disktab>
2003700: 80 a0 60 00 cmp %g1, 0
2003704: 22 80 00 1b be,a 2003770 <get_disk_entry+0x88> <== NEVER TAKEN
2003708: 90 10 20 00 clr %o0 <== NOT EXECUTED
rtems_disk_device_table *dtab = disktab + major;
200370c: 91 2a 20 03 sll %o0, 3, %o0
2003710: 84 00 40 08 add %g1, %o0, %g2
if (minor < dtab->size && dtab->minor != NULL) {
2003714: c4 00 a0 04 ld [ %g2 + 4 ], %g2
2003718: 80 a2 40 02 cmp %o1, %g2
200371c: 3a 80 00 15 bcc,a 2003770 <get_disk_entry+0x88> <== NEVER TAKEN
2003720: 90 10 20 00 clr %o0 <== NOT EXECUTED
2003724: c2 00 40 08 ld [ %g1 + %o0 ], %g1
2003728: 80 a0 60 00 cmp %g1, 0
200372c: 02 80 00 10 be 200376c <get_disk_entry+0x84> <== NEVER TAKEN
2003730: 93 2a 60 02 sll %o1, 2, %o1
rtems_disk_device *dd = dtab->minor [minor];
if (dd != NULL && !lookup_only) {
2003734: 80 a2 a0 01 cmp %o2, 1
2003738: 02 80 00 0e be 2003770 <get_disk_entry+0x88>
200373c: d0 00 40 09 ld [ %g1 + %o1 ], %o0
2003740: 80 a2 20 00 cmp %o0, 0
2003744: 02 80 00 0b be 2003770 <get_disk_entry+0x88> <== NEVER TAKEN
2003748: 01 00 00 00 nop
if (!dd->deleted) {
200374c: c2 0a 20 40 ldub [ %o0 + 0x40 ], %g1
2003750: 80 a0 60 00 cmp %g1, 0
2003754: 32 80 00 07 bne,a 2003770 <get_disk_entry+0x88>
2003758: 90 10 20 00 clr %o0
++dd->uses;
200375c: c2 02 20 14 ld [ %o0 + 0x14 ], %g1
2003760: 82 00 60 01 inc %g1
2003764: 81 c3 e0 08 retl
2003768: c2 22 20 14 st %g1, [ %o0 + 0x14 ]
return dd;
}
}
return NULL;
200376c: 90 10 20 00 clr %o0 <== NOT EXECUTED
}
2003770: 81 c3 e0 08 retl
02004ad4 <get_sector.part.0>:
* NOTES:
* get_sector() operates with device via bdbuf library,
* and does not support devices with sector size other than 512 bytes
*/
static rtems_status_code
get_sector(int fd,
2004ad4: 9d e3 bf a0 save %sp, -96, %sp
new_off = lseek(fd, off, SEEK_SET);
if (new_off != off) {
return RTEMS_IO_ERROR;
}
s = (rtems_sector_data_t *) malloc(sizeof(rtems_sector_data_t) + RTEMS_IDE_SECTOR_SIZE);
2004ad8: 40 00 05 9d call 200614c <malloc>
2004adc: 90 10 22 04 mov 0x204, %o0
if (s == NULL)
{
return RTEMS_NO_MEMORY;
2004ae0: 82 10 20 1a mov 0x1a, %g1
if (new_off != off) {
return RTEMS_IO_ERROR;
}
s = (rtems_sector_data_t *) malloc(sizeof(rtems_sector_data_t) + RTEMS_IDE_SECTOR_SIZE);
if (s == NULL)
2004ae4: 80 a2 20 00 cmp %o0, 0
2004ae8: 02 80 00 0f be 2004b24 <get_sector.part.0+0x50> <== NEVER TAKEN
2004aec: ba 10 00 08 mov %o0, %i5
{
return RTEMS_NO_MEMORY;
}
n = read(fd, s->data, RTEMS_IDE_SECTOR_SIZE);
2004af0: 90 10 00 18 mov %i0, %o0
2004af4: 92 07 60 04 add %i5, 4, %o1
2004af8: 40 00 08 5c call 2006c68 <read>
2004afc: 94 10 22 00 mov 0x200, %o2
if (n != RTEMS_IDE_SECTOR_SIZE)
2004b00: 80 a2 22 00 cmp %o0, 0x200
2004b04: 22 80 00 06 be,a 2004b1c <get_sector.part.0+0x48> <== ALWAYS TAKEN
2004b08: f2 27 40 00 st %i1, [ %i5 ]
{
free(s);
2004b0c: 40 00 03 ea call 2005ab4 <free> <== NOT EXECUTED
2004b10: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
return RTEMS_IO_ERROR;
2004b14: 10 80 00 04 b 2004b24 <get_sector.part.0+0x50> <== NOT EXECUTED
2004b18: 82 10 20 1b mov 0x1b, %g1 <== NOT EXECUTED
}
s->sector_num = sector_num;
*sector = s;
2004b1c: fa 26 80 00 st %i5, [ %i2 ]
return RTEMS_SUCCESSFUL;
2004b20: 82 10 20 00 clr %g1
}
2004b24: 81 c7 e0 08 ret
2004b28: 91 e8 00 01 restore %g0, %g1, %o0
0205cec4 <getdents>:
int getdents(
int dd_fd,
char *dd_buf,
int dd_len
)
{
205cec4: 9d e3 bf a0 save %sp, -96, %sp
rtems_filesystem_node_types_t type;
/*
* Get the file control block structure associated with the file descriptor
*/
iop = rtems_libio_iop( dd_fd );
205cec8: 03 00 81 ad sethi %hi(0x206b400), %g1
205cecc: c2 00 60 48 ld [ %g1 + 0x48 ], %g1 ! 206b448 <rtems_libio_number_iops>
205ced0: 80 a6 00 01 cmp %i0, %g1
205ced4: 1a 80 00 08 bcc 205cef4 <getdents+0x30> <== NEVER TAKEN
205ced8: ba 10 20 00 clr %i5
205cedc: 83 2e 20 03 sll %i0, 3, %g1
205cee0: b1 2e 20 06 sll %i0, 6, %i0
205cee4: b0 26 00 01 sub %i0, %g1, %i0
205cee8: 03 00 81 bd sethi %hi(0x206f400), %g1
205ceec: fa 00 61 e0 ld [ %g1 + 0x1e0 ], %i5 ! 206f5e0 <rtems_libio_iops>
205cef0: ba 07 40 18 add %i5, %i0, %i5
/*
* Make sure we are working on a directory
*/
type = rtems_filesystem_node_type( &iop->pathinfo );
205cef4: 7f ff 32 3d call 20297e8 <rtems_filesystem_node_type>
205cef8: 90 07 60 14 add %i5, 0x14, %o0
if ( type != RTEMS_FILESYSTEM_DIRECTORY )
205cefc: 80 a2 20 00 cmp %o0, 0
205cf00: 22 80 00 08 be,a 205cf20 <getdents+0x5c>
205cf04: c2 07 60 24 ld [ %i5 + 0x24 ], %g1
rtems_set_errno_and_return_minus_one( ENOTDIR );
205cf08: 7f ff 94 b9 call 20421ec <__errno>
205cf0c: b0 10 3f ff mov -1, %i0
205cf10: 82 10 20 14 mov 0x14, %g1
205cf14: c2 22 00 00 st %g1, [ %o0 ]
205cf18: 81 c7 e0 08 ret
205cf1c: 81 e8 00 00 restore
/*
* 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 );
205cf20: 90 10 00 1d mov %i5, %o0
205cf24: c2 00 60 08 ld [ %g1 + 8 ], %g1
205cf28: 92 10 00 19 mov %i1, %o1
205cf2c: 9f c0 40 00 call %g1
205cf30: 94 10 00 1a mov %i2, %o2
}
205cf34: 81 c7 e0 08 ret
205cf38: 91 e8 00 08 restore %g0, %o0, %o0
02028540 <init_etc_passwd_group>:
/*
* Initialize useable but dummy databases
*/
void init_etc_passwd_group(void)
{
2028540: 9d e3 bf a0 save %sp, -96, %sp
FILE *fp;
static char etc_passwd_initted = 0;
if (etc_passwd_initted)
2028544: 03 00 81 bb sethi %hi(0x206ec00), %g1
2028548: c4 48 63 f0 ldsb [ %g1 + 0x3f0 ], %g2 ! 206eff0 <etc_passwd_initted.7009>
202854c: 80 a0 a0 00 cmp %g2, 0
2028550: 12 80 00 2f bne 202860c <init_etc_passwd_group+0xcc>
2028554: 84 10 20 01 mov 1, %g2
return;
etc_passwd_initted = 1;
mkdir("/etc", 0777);
2028558: 92 10 21 ff mov 0x1ff, %o1
FILE *fp;
static char etc_passwd_initted = 0;
if (etc_passwd_initted)
return;
etc_passwd_initted = 1;
202855c: c4 28 63 f0 stb %g2, [ %g1 + 0x3f0 ]
mkdir("/etc", 0777);
2028560: 11 00 81 78 sethi %hi(0x205e000), %o0
2028564: 7f ff 83 76 call 200933c <mkdir>
2028568: 90 12 21 80 or %o0, 0x180, %o0 ! 205e180 <_rodata_start+0xb10>
/*
* Initialize /etc/passwd
*/
if ((fp = fopen("/etc/passwd", "r")) != NULL) {
202856c: 3b 00 81 78 sethi %hi(0x205e000), %i5
2028570: 13 00 81 aa sethi %hi(0x206a800), %o1
2028574: 90 17 62 08 or %i5, 0x208, %o0
2028578: 40 00 69 c3 call 2042c84 <fopen>
202857c: 92 12 62 10 or %o1, 0x210, %o1
2028580: 80 a2 20 00 cmp %o0, 0
2028584: 22 80 00 03 be,a 2028590 <init_etc_passwd_group+0x50>
2028588: 90 17 62 08 or %i5, 0x208, %o0
202858c: 30 80 00 0b b,a 20285b8 <init_etc_passwd_group+0x78>
fclose(fp);
}
else if ((fp = fopen("/etc/passwd", "w")) != NULL) {
2028590: 13 00 81 88 sethi %hi(0x2062000), %o1
2028594: 40 00 69 bc call 2042c84 <fopen>
2028598: 92 12 60 18 or %o1, 0x18, %o1 ! 2062018 <rtems_rtc_shell_usage+0x4e8>
202859c: ba 92 20 00 orcc %o0, 0, %i5
20285a0: 02 80 00 08 be 20285c0 <init_etc_passwd_group+0x80> <== NEVER TAKEN
20285a4: 11 00 81 90 sethi %hi(0x2064000), %o0
fprintf(fp, "root:*:0:0:root::/:/bin/sh\n"
20285a8: 92 10 00 1d mov %i5, %o1
20285ac: 40 00 6a 19 call 2042e10 <fputs>
20285b0: 90 12 22 a8 or %o0, 0x2a8, %o0
"rtems:*:1:1:RTEMS Application::/:/bin/sh\n"
"tty:!:2:2:tty owner::/:/bin/false\n" );
fclose(fp);
20285b4: 90 10 00 1d mov %i5, %o0
20285b8: 40 00 67 5f call 2042334 <fclose>
20285bc: 01 00 00 00 nop
}
/*
* Initialize /etc/group
*/
if ((fp = fopen("/etc/group", "r")) != NULL) {
20285c0: 3b 00 81 78 sethi %hi(0x205e000), %i5
20285c4: 13 00 81 aa sethi %hi(0x206a800), %o1
20285c8: 90 17 62 c0 or %i5, 0x2c0, %o0
20285cc: 40 00 69 ae call 2042c84 <fopen>
20285d0: 92 12 62 10 or %o1, 0x210, %o1
20285d4: b0 92 20 00 orcc %o0, 0, %i0
20285d8: 12 80 00 0b bne 2028604 <init_etc_passwd_group+0xc4>
20285dc: 90 17 62 c0 or %i5, 0x2c0, %o0
fclose(fp);
}
else if ((fp = fopen("/etc/group", "w")) != NULL) {
20285e0: 13 00 81 88 sethi %hi(0x2062000), %o1
20285e4: 40 00 69 a8 call 2042c84 <fopen>
20285e8: 92 12 60 18 or %o1, 0x18, %o1 ! 2062018 <rtems_rtc_shell_usage+0x4e8>
20285ec: b0 92 20 00 orcc %o0, 0, %i0
20285f0: 02 80 00 07 be 202860c <init_etc_passwd_group+0xcc> <== NEVER TAKEN
20285f4: 11 00 81 90 sethi %hi(0x2064000), %o0
fprintf( fp, "root:x:0:root\n"
20285f8: 92 10 00 18 mov %i0, %o1
20285fc: 40 00 6a 05 call 2042e10 <fputs>
2028600: 90 12 23 10 or %o0, 0x310, %o0
"rtems:x:1:rtems\n"
"tty:x:2:tty\n" );
fclose(fp);
2028604: 40 00 67 4c call 2042334 <fclose>
2028608: 81 e8 00 00 restore
202860c: 81 c7 e0 08 ret
2028610: 81 e8 00 00 restore
02006340 <iproc>:
/*
* Process a single input character
*/
static int
iproc (unsigned char c, struct rtems_termios_tty *tty)
{
2006340: 9d e3 bf a0 save %sp, -96, %sp
if (tty->termios.c_iflag & ISTRIP)
2006344: c2 06 60 30 ld [ %i1 + 0x30 ], %g1
2006348: 80 88 60 20 btst 0x20, %g1
200634c: 32 80 00 02 bne,a 2006354 <iproc+0x14> <== NEVER TAKEN
2006350: b0 0e 20 7f and %i0, 0x7f, %i0 <== NOT EXECUTED
c &= 0x7f;
if (tty->termios.c_iflag & IUCLC)
2006354: 80 88 62 00 btst 0x200, %g1
2006358: 02 80 00 0c be 2006388 <iproc+0x48>
200635c: 80 a6 20 0d cmp %i0, 0xd
c = tolower (c);
2006360: 05 00 80 74 sethi %hi(0x201d000), %g2
2006364: c4 00 a0 60 ld [ %g2 + 0x60 ], %g2 ! 201d060 <__ctype_ptr__>
2006368: 84 00 80 18 add %g2, %i0, %g2
200636c: c4 08 a0 01 ldub [ %g2 + 1 ], %g2
2006370: 84 08 a0 03 and %g2, 3, %g2
2006374: 80 a0 a0 01 cmp %g2, 1
2006378: 22 80 00 02 be,a 2006380 <iproc+0x40>
200637c: b0 06 20 20 add %i0, 0x20, %i0
2006380: b0 0e 20 ff and %i0, 0xff, %i0
if (c == '\r') {
2006384: 80 a6 20 0d cmp %i0, 0xd
2006388: 12 80 00 0b bne 20063b4 <iproc+0x74>
200638c: 80 a6 20 0a cmp %i0, 0xa
if (tty->termios.c_iflag & IGNCR)
2006390: 80 88 60 80 btst 0x80, %g1
2006394: 02 80 00 04 be 20063a4 <iproc+0x64> <== ALWAYS TAKEN
2006398: 80 88 61 00 btst 0x100, %g1
if (tty->ccount < (CBUFSIZE-1)) {
if (tty->termios.c_lflag & ECHO)
echo (c, tty);
tty->cbuf[tty->ccount++] = c;
}
return 0;
200639c: 81 c7 e0 08 ret <== NOT EXECUTED
20063a0: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED
c = tolower (c);
if (c == '\r') {
if (tty->termios.c_iflag & IGNCR)
return 0;
if (tty->termios.c_iflag & ICRNL)
20063a4: 32 80 00 0d bne,a 20063d8 <iproc+0x98> <== ALWAYS TAKEN
20063a8: b0 10 20 0a mov 0xa, %i0
c = '\n';
} else if ((c == '\n') && (tty->termios.c_iflag & INLCR)) {
c = '\r';
}
if ((c != '\0') && (tty->termios.c_lflag & ICANON)) {
20063ac: 10 80 00 0c b 20063dc <iproc+0x9c> <== NOT EXECUTED
20063b0: c2 06 60 3c ld [ %i1 + 0x3c ], %g1 <== NOT EXECUTED
if (c == '\r') {
if (tty->termios.c_iflag & IGNCR)
return 0;
if (tty->termios.c_iflag & ICRNL)
c = '\n';
} else if ((c == '\n') && (tty->termios.c_iflag & INLCR)) {
20063b4: 12 80 00 07 bne 20063d0 <iproc+0x90>
20063b8: 80 a6 20 00 cmp %i0, 0
20063bc: 80 88 60 40 btst 0x40, %g1
20063c0: 32 80 00 06 bne,a 20063d8 <iproc+0x98> <== NEVER TAKEN
20063c4: b0 10 20 0d mov 0xd, %i0 <== NOT EXECUTED
c = '\r';
}
if ((c != '\0') && (tty->termios.c_lflag & ICANON)) {
20063c8: 10 80 00 05 b 20063dc <iproc+0x9c>
20063cc: c2 06 60 3c ld [ %i1 + 0x3c ], %g1
20063d0: 02 80 00 51 be 2006514 <iproc+0x1d4> <== NEVER TAKEN
20063d4: 03 00 80 73 sethi %hi(0x201cc00), %g1
20063d8: c2 06 60 3c ld [ %i1 + 0x3c ], %g1
20063dc: 80 88 60 02 btst 2, %g1
20063e0: 22 80 00 4d be,a 2006514 <iproc+0x1d4>
20063e4: 03 00 80 73 sethi %hi(0x201cc00), %g1
if (c == tty->termios.c_cc[VERASE]) {
20063e8: c4 0e 60 43 ldub [ %i1 + 0x43 ], %g2
20063ec: 80 a0 80 18 cmp %g2, %i0
20063f0: 32 80 00 08 bne,a 2006410 <iproc+0xd0>
20063f4: c4 0e 60 44 ldub [ %i1 + 0x44 ], %g2
* FIXME: Some of the tests should check for IEXTEN, too.
*/
static void
erase (struct rtems_termios_tty *tty, int lineFlag)
{
if (tty->ccount == 0)
20063f8: c2 06 60 20 ld [ %i1 + 0x20 ], %g1
20063fc: 80 a0 60 00 cmp %g1, 0
2006400: 02 80 00 57 be 200655c <iproc+0x21c>
2006404: 90 10 00 19 mov %i1, %o0
2006408: 10 80 00 1d b 200647c <iproc+0x13c>
200640c: 92 10 20 00 clr %o1
if ((c != '\0') && (tty->termios.c_lflag & ICANON)) {
if (c == tty->termios.c_cc[VERASE]) {
erase (tty, 0);
return 0;
}
else if (c == tty->termios.c_cc[VKILL]) {
2006410: 80 a0 80 18 cmp %g2, %i0
2006414: 32 80 00 1d bne,a 2006488 <iproc+0x148>
2006418: c4 0e 60 45 ldub [ %i1 + 0x45 ], %g2
* FIXME: Some of the tests should check for IEXTEN, too.
*/
static void
erase (struct rtems_termios_tty *tty, int lineFlag)
{
if (tty->ccount == 0)
200641c: c4 06 60 20 ld [ %i1 + 0x20 ], %g2
2006420: 80 a0 a0 00 cmp %g2, 0
2006424: 02 80 00 4e be 200655c <iproc+0x21c> <== NEVER TAKEN
2006428: 80 88 60 08 btst 8, %g1
return;
if (lineFlag) {
if (!(tty->termios.c_lflag & ECHO)) {
200642c: 12 80 00 04 bne 200643c <iproc+0xfc> <== ALWAYS TAKEN
2006430: 90 10 00 19 mov %i1, %o0
tty->ccount = 0;
2006434: 10 80 00 4a b 200655c <iproc+0x21c> <== NOT EXECUTED
2006438: c0 26 60 20 clr [ %i1 + 0x20 ] <== NOT EXECUTED
return;
}
if (!(tty->termios.c_lflag & ECHOE)) {
200643c: 80 88 60 10 btst 0x10, %g1
2006440: 12 80 00 0f bne 200647c <iproc+0x13c> <== ALWAYS TAKEN
2006444: 92 10 20 01 mov 1, %o1
tty->ccount = 0;
2006448: c0 26 60 20 clr [ %i1 + 0x20 ] <== NOT EXECUTED
echo (tty->termios.c_cc[VKILL], tty);
200644c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
2006450: 7f ff ff 2d call 2006104 <echo> <== NOT EXECUTED
2006454: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
if (tty->termios.c_lflag & ECHOK)
2006458: c2 06 60 3c ld [ %i1 + 0x3c ], %g1 <== NOT EXECUTED
200645c: 80 88 60 20 btst 0x20, %g1 <== NOT EXECUTED
2006460: 22 80 00 42 be,a 2006568 <iproc+0x228> <== NOT EXECUTED
2006464: b0 10 20 00 clr %i0 <== NOT EXECUTED
echo ('\n', tty);
2006468: 90 10 20 0a mov 0xa, %o0 <== NOT EXECUTED
200646c: 7f ff ff 26 call 2006104 <echo> <== NOT EXECUTED
2006470: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
if (tty->ccount < (CBUFSIZE-1)) {
if (tty->termios.c_lflag & ECHO)
echo (c, tty);
tty->cbuf[tty->ccount++] = c;
}
return 0;
2006474: 81 c7 e0 08 ret <== NOT EXECUTED
2006478: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED
200647c: 7f ff ff 43 call 2006188 <erase.part.2>
2006480: b0 10 20 00 clr %i0
2006484: 30 80 00 39 b,a 2006568 <iproc+0x228>
}
else if (c == tty->termios.c_cc[VKILL]) {
erase (tty, 1);
return 0;
}
else if (c == tty->termios.c_cc[VEOF]) {
2006488: 80 a0 80 18 cmp %g2, %i0
200648c: 02 80 00 36 be 2006564 <iproc+0x224> <== NEVER TAKEN
2006490: 80 a6 20 0a cmp %i0, 0xa
return 1;
} else if (c == '\n') {
2006494: 32 80 00 0d bne,a 20064c8 <iproc+0x188>
2006498: c4 0e 60 4c ldub [ %i1 + 0x4c ], %g2
if (tty->termios.c_lflag & (ECHO | ECHONL))
200649c: 80 88 60 48 btst 0x48, %g1
20064a0: 22 80 00 06 be,a 20064b8 <iproc+0x178> <== NEVER TAKEN
20064a4: c2 06 60 20 ld [ %i1 + 0x20 ], %g1 <== NOT EXECUTED
echo (c, tty);
20064a8: 90 10 20 0a mov 0xa, %o0
20064ac: 7f ff ff 16 call 2006104 <echo>
20064b0: 92 10 00 19 mov %i1, %o1
tty->cbuf[tty->ccount++] = c;
20064b4: c2 06 60 20 ld [ %i1 + 0x20 ], %g1
20064b8: c4 06 60 1c ld [ %i1 + 0x1c ], %g2
20064bc: 86 10 20 0a mov 0xa, %g3
20064c0: 10 80 00 12 b 2006508 <iproc+0x1c8>
20064c4: c6 28 80 01 stb %g3, [ %g2 + %g1 ]
return 1;
} else if ((c == tty->termios.c_cc[VEOL]) ||
20064c8: 80 a0 80 18 cmp %g2, %i0
20064cc: 02 80 00 07 be 20064e8 <iproc+0x1a8> <== NEVER TAKEN
20064d0: 80 88 60 08 btst 8, %g1
20064d4: c4 0e 60 51 ldub [ %i1 + 0x51 ], %g2
20064d8: 80 a0 80 18 cmp %g2, %i0
20064dc: 32 80 00 0e bne,a 2006514 <iproc+0x1d4> <== ALWAYS TAKEN
20064e0: 03 00 80 73 sethi %hi(0x201cc00), %g1
(c == tty->termios.c_cc[VEOL2])) {
if (tty->termios.c_lflag & ECHO)
20064e4: 80 88 60 08 btst 8, %g1 <== NOT EXECUTED
20064e8: 22 80 00 06 be,a 2006500 <iproc+0x1c0> <== NOT EXECUTED
20064ec: c2 06 60 20 ld [ %i1 + 0x20 ], %g1 <== NOT EXECUTED
echo (c, tty);
20064f0: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
20064f4: 7f ff ff 04 call 2006104 <echo> <== NOT EXECUTED
20064f8: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
tty->cbuf[tty->ccount++] = c;
20064fc: c2 06 60 20 ld [ %i1 + 0x20 ], %g1 <== NOT EXECUTED
2006500: c4 06 60 1c ld [ %i1 + 0x1c ], %g2 <== NOT EXECUTED
2006504: f0 28 80 01 stb %i0, [ %g2 + %g1 ] <== NOT EXECUTED
2006508: 82 00 60 01 inc %g1
200650c: 10 80 00 16 b 2006564 <iproc+0x224>
2006510: c2 26 60 20 st %g1, [ %i1 + 0x20 ]
}
/*
* FIXME: Should do IMAXBEL handling somehow
*/
if (tty->ccount < (CBUFSIZE-1)) {
2006514: c4 06 60 20 ld [ %i1 + 0x20 ], %g2
2006518: c2 00 63 00 ld [ %g1 + 0x300 ], %g1
200651c: 82 00 7f ff add %g1, -1, %g1
2006520: 80 a0 80 01 cmp %g2, %g1
2006524: 3a 80 00 11 bcc,a 2006568 <iproc+0x228> <== NEVER TAKEN
2006528: b0 10 20 00 clr %i0 <== NOT EXECUTED
if (tty->termios.c_lflag & ECHO)
200652c: c2 06 60 3c ld [ %i1 + 0x3c ], %g1
2006530: 80 88 60 08 btst 8, %g1
2006534: 22 80 00 06 be,a 200654c <iproc+0x20c> <== NEVER TAKEN
2006538: c2 06 60 20 ld [ %i1 + 0x20 ], %g1 <== NOT EXECUTED
echo (c, tty);
200653c: 90 10 00 18 mov %i0, %o0
2006540: 7f ff fe f1 call 2006104 <echo>
2006544: 92 10 00 19 mov %i1, %o1
tty->cbuf[tty->ccount++] = c;
2006548: c2 06 60 20 ld [ %i1 + 0x20 ], %g1
200654c: c4 06 60 1c ld [ %i1 + 0x1c ], %g2
2006550: f0 28 80 01 stb %i0, [ %g2 + %g1 ]
2006554: 82 00 60 01 inc %g1
2006558: c2 26 60 20 st %g1, [ %i1 + 0x20 ]
}
return 0;
200655c: 81 c7 e0 08 ret
2006560: 91 e8 20 00 restore %g0, 0, %o0
else if (c == tty->termios.c_cc[VKILL]) {
erase (tty, 1);
return 0;
}
else if (c == tty->termios.c_cc[VEOF]) {
return 1;
2006564: b0 10 20 01 mov 1, %i0
if (tty->termios.c_lflag & ECHO)
echo (c, tty);
tty->cbuf[tty->ccount++] = c;
}
return 0;
}
2006568: 81 c7 e0 08 ret
200656c: 81 e8 00 00 restore
0201a338 <killinfo>:
int killinfo(
pid_t pid,
int sig,
const union sigval *value
)
{
201a338: 9d e3 bf 90 save %sp, -112, %sp
POSIX_signals_Siginfo_node *psiginfo;
/*
* Only supported for the "calling process" (i.e. this node).
*/
if ( pid != getpid() )
201a33c: 7f ff ff 68 call 201a0dc <getpid>
201a340: 01 00 00 00 nop
201a344: 80 a6 00 08 cmp %i0, %o0
201a348: 02 80 00 06 be 201a360 <killinfo+0x28>
201a34c: 80 a6 60 00 cmp %i1, 0
rtems_set_errno_and_return_minus_one( ESRCH );
201a350: 7f ff d5 b0 call 200fa10 <__errno>
201a354: 01 00 00 00 nop
201a358: 10 80 00 a4 b 201a5e8 <killinfo+0x2b0>
201a35c: 82 10 20 03 mov 3, %g1 ! 3 <PROM_START+0x3>
/*
* Validate the signal passed.
*/
if ( !sig )
201a360: 32 80 00 03 bne,a 201a36c <killinfo+0x34>
201a364: ba 06 7f ff add %i1, -1, %i5
201a368: 30 80 00 04 b,a 201a378 <killinfo+0x40>
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !is_valid_signo(sig) )
201a36c: 80 a7 60 1f cmp %i5, 0x1f
201a370: 28 80 00 06 bleu,a 201a388 <killinfo+0x50>
201a374: 83 2e 60 02 sll %i1, 2, %g1
rtems_set_errno_and_return_minus_one( EINVAL );
201a378: 7f ff d5 a6 call 200fa10 <__errno>
201a37c: 01 00 00 00 nop
201a380: 10 80 00 9a b 201a5e8 <killinfo+0x2b0>
201a384: 82 10 20 16 mov 0x16, %g1 ! 16 <PROM_START+0x16>
/*
* If the signal is being ignored, then we are out of here.
*/
if ( _POSIX_signals_Vectors[ sig ].sa_handler == SIG_IGN )
201a388: 85 2e 60 04 sll %i1, 4, %g2
201a38c: 84 20 80 01 sub %g2, %g1, %g2
201a390: 03 00 80 78 sethi %hi(0x201e000), %g1
201a394: 82 10 60 70 or %g1, 0x70, %g1 ! 201e070 <_POSIX_signals_Vectors>
201a398: 82 00 40 02 add %g1, %g2, %g1
201a39c: c2 00 60 08 ld [ %g1 + 8 ], %g1
201a3a0: 80 a0 60 01 cmp %g1, 1
201a3a4: 02 80 00 9d be 201a618 <killinfo+0x2e0>
201a3a8: 80 a6 60 04 cmp %i1, 4
/*
* 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 ) )
201a3ac: 02 80 00 06 be 201a3c4 <killinfo+0x8c>
201a3b0: 80 a6 60 08 cmp %i1, 8
201a3b4: 02 80 00 04 be 201a3c4 <killinfo+0x8c>
201a3b8: 80 a6 60 0b cmp %i1, 0xb
201a3bc: 12 80 00 08 bne 201a3dc <killinfo+0xa4>
201a3c0: 82 10 20 01 mov 1, %g1
return pthread_kill( pthread_self(), sig );
201a3c4: 40 00 01 2d call 201a878 <pthread_self>
201a3c8: 01 00 00 00 nop
201a3cc: 40 00 00 f2 call 201a794 <pthread_kill>
201a3d0: 92 10 00 19 mov %i1, %o1
201a3d4: 81 c7 e0 08 ret
201a3d8: 91 e8 00 08 restore %g0, %o0, %o0
/*
* Build up a siginfo structure
*/
siginfo = &siginfo_struct;
siginfo->si_signo = sig;
201a3dc: f2 27 bf f4 st %i1, [ %fp + -12 ]
siginfo->si_code = SI_USER;
201a3e0: c2 27 bf f8 st %g1, [ %fp + -8 ]
if ( !value ) {
201a3e4: 80 a6 a0 00 cmp %i2, 0
201a3e8: 12 80 00 04 bne 201a3f8 <killinfo+0xc0>
201a3ec: bb 28 40 1d sll %g1, %i5, %i5
siginfo->si_value.sival_int = 0;
201a3f0: 10 80 00 04 b 201a400 <killinfo+0xc8>
201a3f4: c0 27 bf fc clr [ %fp + -4 ]
} else {
siginfo->si_value = *value;
201a3f8: c2 06 80 00 ld [ %i2 ], %g1
201a3fc: c2 27 bf fc st %g1, [ %fp + -4 ]
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
_Thread_Dispatch_disable_level++;
201a400: 03 00 80 76 sethi %hi(0x201d800), %g1
201a404: c4 00 62 e0 ld [ %g1 + 0x2e0 ], %g2 ! 201dae0 <_Thread_Dispatch_disable_level>
201a408: 84 00 a0 01 inc %g2
201a40c: c4 20 62 e0 st %g2, [ %g1 + 0x2e0 ]
return _Thread_Dispatch_disable_level;
201a410: c2 00 62 e0 ld [ %g1 + 0x2e0 ], %g1
/*
* 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;
201a414: 03 00 80 78 sethi %hi(0x201e000), %g1
201a418: d0 00 60 1c ld [ %g1 + 0x1c ], %o0 ! 201e01c <_Per_CPU_Information+0xc>
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
if ( _POSIX_signals_Is_interested( api, mask ) ) {
201a41c: c4 02 21 5c ld [ %o0 + 0x15c ], %g2
201a420: c4 00 a0 d0 ld [ %g2 + 0xd0 ], %g2
201a424: 80 af 40 02 andncc %i5, %g2, %g0
201a428: 12 80 00 52 bne 201a570 <killinfo+0x238>
201a42c: 03 00 80 78 sethi %hi(0x201e000), %g1
/* 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 );
201a430: 05 00 80 78 sethi %hi(0x201e000), %g2
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
201a434: c2 00 61 fc ld [ %g1 + 0x1fc ], %g1
201a438: 10 80 00 0a b 201a460 <killinfo+0x128>
201a43c: 84 10 a2 00 or %g2, 0x200, %g2
#endif
/*
* Is this thread is actually blocked waiting for the signal?
*/
if (the_thread->Wait.option & mask)
201a440: 80 8f 40 04 btst %i5, %g4
201a444: 12 80 00 4a bne 201a56c <killinfo+0x234>
201a448: c6 00 61 5c ld [ %g1 + 0x15c ], %g3
/*
* Is this thread is blocked waiting for another signal but has
* not blocked this one?
*/
if (~api->signals_blocked & mask)
201a44c: c6 00 e0 d0 ld [ %g3 + 0xd0 ], %g3
201a450: 80 af 40 03 andncc %i5, %g3, %g0
201a454: 12 80 00 47 bne 201a570 <killinfo+0x238>
201a458: 90 10 00 01 mov %g1, %o0
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 ) {
201a45c: c2 00 40 00 ld [ %g1 ], %g1
/* 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 );
201a460: 80 a0 40 02 cmp %g1, %g2
201a464: 32 bf ff f7 bne,a 201a440 <killinfo+0x108>
201a468: c8 00 60 30 ld [ %g1 + 0x30 ], %g4
* NOTES:
*
* + rtems internal threads do not receive signals.
*/
interested = NULL;
interested_priority = PRIORITY_MAXIMUM + 1;
201a46c: 03 00 80 73 sethi %hi(0x201cc00), %g1
201a470: c6 08 61 38 ldub [ %g1 + 0x138 ], %g3 ! 201cd38 <rtems_maximum_priority>
for (the_api = OBJECTS_CLASSIC_API; the_api <= OBJECTS_APIS_LAST; the_api++) {
201a474: b8 10 20 02 mov 2, %i4
* NOTES:
*
* + rtems internal threads do not receive signals.
*/
interested = NULL;
interested_priority = PRIORITY_MAXIMUM + 1;
201a478: 86 00 e0 01 inc %g3
*
* NOTES:
*
* + rtems internal threads do not receive signals.
*/
interested = NULL;
201a47c: 82 10 20 00 clr %g1
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 ] )
201a480: 1b 00 80 76 sethi %hi(0x201d800), %o5
*/
RTEMS_INLINE_ROUTINE bool _States_Is_interruptible_by_signal (
States_Control the_states
)
{
return (the_states & STATES_INTERRUPTIBLE_BY_SIGNAL);
201a484: 35 04 00 00 sethi %hi(0x10000000), %i2
*/
#define _POSIX_signals_Is_interested( _api, _mask ) \
( ~(_api)->signals_blocked & (_mask) )
int killinfo(
201a488: 85 2f 20 02 sll %i4, 2, %g2
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 ] )
201a48c: 88 13 62 44 or %o5, 0x244, %g4
201a490: c4 01 00 02 ld [ %g4 + %g2 ], %g2
201a494: 80 a0 a0 00 cmp %g2, 0
201a498: 22 80 00 2f be,a 201a554 <killinfo+0x21c> <== NEVER TAKEN
201a49c: b8 07 20 01 inc %i4 <== NOT EXECUTED
continue;
the_info = _Objects_Information_table[ the_api ][ 1 ];
201a4a0: c4 00 a0 04 ld [ %g2 + 4 ], %g2
#endif
maximum = the_info->maximum;
object_table = the_info->local_table;
for ( index = 1 ; index <= maximum ; index++ ) {
201a4a4: b6 10 20 01 mov 1, %i3
*/
if ( !the_info )
continue;
#endif
maximum = the_info->maximum;
201a4a8: d8 10 a0 10 lduh [ %g2 + 0x10 ], %o4
object_table = the_info->local_table;
for ( index = 1 ; index <= maximum ; index++ ) {
201a4ac: 10 80 00 26 b 201a544 <killinfo+0x20c>
201a4b0: d6 00 a0 1c ld [ %g2 + 0x1c ], %o3
the_thread = (Thread_Control *) object_table[ index ];
201a4b4: c4 02 c0 02 ld [ %o3 + %g2 ], %g2
if ( !the_thread )
201a4b8: 80 a0 a0 00 cmp %g2, 0
201a4bc: 22 80 00 22 be,a 201a544 <killinfo+0x20c>
201a4c0: b6 06 e0 01 inc %i3
/*
* If this thread is of lower priority than the interested thread,
* go on to the next thread.
*/
if ( the_thread->current_priority > interested_priority )
201a4c4: c8 00 a0 14 ld [ %g2 + 0x14 ], %g4
201a4c8: 80 a1 00 03 cmp %g4, %g3
201a4cc: 38 80 00 1e bgu,a 201a544 <killinfo+0x20c>
201a4d0: b6 06 e0 01 inc %i3
#if defined(RTEMS_DEBUG)
if ( !api )
continue;
#endif
if ( !_POSIX_signals_Is_interested( api, mask ) )
201a4d4: f0 00 a1 5c ld [ %g2 + 0x15c ], %i0
201a4d8: f0 06 20 d0 ld [ %i0 + 0xd0 ], %i0
201a4dc: 80 af 40 18 andncc %i5, %i0, %g0
201a4e0: 22 80 00 19 be,a 201a544 <killinfo+0x20c>
201a4e4: b6 06 e0 01 inc %i3
*
* 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 ) {
201a4e8: 80 a1 00 03 cmp %g4, %g3
201a4ec: 2a 80 00 14 bcs,a 201a53c <killinfo+0x204>
201a4f0: 86 10 00 04 mov %g4, %g3
* and blocking interruptibutable by signal.
*
* If the interested thread is ready, don't think about changing.
*/
if ( interested && !_States_Is_ready( interested->current_state ) ) {
201a4f4: 80 a0 60 00 cmp %g1, 0
201a4f8: 22 80 00 13 be,a 201a544 <killinfo+0x20c> <== NEVER TAKEN
201a4fc: b6 06 e0 01 inc %i3 <== NOT EXECUTED
201a500: de 00 60 10 ld [ %g1 + 0x10 ], %o7
201a504: 80 a3 e0 00 cmp %o7, 0
201a508: 22 80 00 0f be,a 201a544 <killinfo+0x20c> <== NEVER TAKEN
201a50c: b6 06 e0 01 inc %i3 <== NOT EXECUTED
/* preferred ready over blocked */
DEBUG_STEP("5");
if ( _States_Is_ready( the_thread->current_state ) ) {
201a510: f0 00 a0 10 ld [ %g2 + 0x10 ], %i0
201a514: 80 a6 20 00 cmp %i0, 0
201a518: 22 80 00 09 be,a 201a53c <killinfo+0x204>
201a51c: 86 10 00 04 mov %g4, %g3
continue;
}
DEBUG_STEP("6");
/* prefer blocked/interruptible over blocked/not interruptible */
if ( !_States_Is_interruptible_by_signal(interested->current_state) ) {
201a520: 80 8b c0 1a btst %o7, %i2
201a524: 32 80 00 08 bne,a 201a544 <killinfo+0x20c>
201a528: b6 06 e0 01 inc %i3
DEBUG_STEP("7");
if ( _States_Is_interruptible_by_signal(the_thread->current_state) ) {
201a52c: 80 8e 00 1a btst %i0, %i2
201a530: 22 80 00 05 be,a 201a544 <killinfo+0x20c>
201a534: b6 06 e0 01 inc %i3
*/
if ( interested && !_States_Is_ready( interested->current_state ) ) {
/* preferred ready over blocked */
DEBUG_STEP("5");
if ( _States_Is_ready( the_thread->current_state ) ) {
201a538: 86 10 00 04 mov %g4, %g3
201a53c: 82 10 00 02 mov %g2, %g1
#endif
maximum = the_info->maximum;
object_table = the_info->local_table;
for ( index = 1 ; index <= maximum ; index++ ) {
201a540: b6 06 e0 01 inc %i3
201a544: 80 a6 c0 0c cmp %i3, %o4
201a548: 08 bf ff db bleu 201a4b4 <killinfo+0x17c>
201a54c: 85 2e e0 02 sll %i3, 2, %g2
* + 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++) {
201a550: b8 07 20 01 inc %i4
201a554: 80 a7 20 04 cmp %i4, 4
201a558: 12 bf ff cd bne 201a48c <killinfo+0x154>
201a55c: 85 2f 20 02 sll %i4, 2, %g2
}
}
}
}
if ( interested ) {
201a560: 80 a0 60 00 cmp %g1, 0
201a564: 02 80 00 0c be 201a594 <killinfo+0x25c>
201a568: 01 00 00 00 nop
/*
* Is this thread is blocked waiting for another signal but has
* not blocked this one?
*/
if (~api->signals_blocked & mask)
201a56c: 90 10 00 01 mov %g1, %o0
/*
* 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 ) ) {
201a570: 92 10 00 19 mov %i1, %o1
201a574: 40 00 00 36 call 201a64c <_POSIX_signals_Unblock_thread>
201a578: 94 07 bf f4 add %fp, -12, %o2
201a57c: 80 8a 20 ff btst 0xff, %o0
201a580: 02 80 00 05 be 201a594 <killinfo+0x25c>
201a584: 01 00 00 00 nop
_Thread_Enable_dispatch();
201a588: 7f ff bf 08 call 200a1a8 <_Thread_Enable_dispatch>
201a58c: b0 10 20 00 clr %i0 ! 0 <PROM_START>
201a590: 30 80 00 23 b,a 201a61c <killinfo+0x2e4>
/*
* 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 );
201a594: 40 00 00 24 call 201a624 <_POSIX_signals_Set_process_signals>
201a598: 90 10 00 1d mov %i5, %o0
if ( _POSIX_signals_Vectors[ sig ].sa_flags == SA_SIGINFO ) {
201a59c: 83 2e 60 02 sll %i1, 2, %g1
201a5a0: b3 2e 60 04 sll %i1, 4, %i1
201a5a4: b2 26 40 01 sub %i1, %g1, %i1
201a5a8: 03 00 80 78 sethi %hi(0x201e000), %g1
201a5ac: 82 10 60 70 or %g1, 0x70, %g1 ! 201e070 <_POSIX_signals_Vectors>
201a5b0: c2 00 40 19 ld [ %g1 + %i1 ], %g1
201a5b4: 80 a0 60 02 cmp %g1, 2
201a5b8: 12 bf ff f4 bne 201a588 <killinfo+0x250>
201a5bc: 11 00 80 78 sethi %hi(0x201e000), %o0
psiginfo = (POSIX_signals_Siginfo_node *)
201a5c0: 7f ff b7 71 call 2008384 <_Chain_Get>
201a5c4: 90 12 21 f0 or %o0, 0x1f0, %o0 ! 201e1f0 <_POSIX_signals_Inactive_siginfo>
_Chain_Get( &_POSIX_signals_Inactive_siginfo );
if ( !psiginfo ) {
201a5c8: ba 92 20 00 orcc %o0, 0, %i5
201a5cc: 12 80 00 0a bne 201a5f4 <killinfo+0x2bc>
201a5d0: 92 07 bf f4 add %fp, -12, %o1
_Thread_Enable_dispatch();
201a5d4: 7f ff be f5 call 200a1a8 <_Thread_Enable_dispatch>
201a5d8: 01 00 00 00 nop
rtems_set_errno_and_return_minus_one( EAGAIN );
201a5dc: 7f ff d5 0d call 200fa10 <__errno>
201a5e0: 01 00 00 00 nop
201a5e4: 82 10 20 0b mov 0xb, %g1 ! b <PROM_START+0xb>
201a5e8: c2 22 00 00 st %g1, [ %o0 ]
201a5ec: 81 c7 e0 08 ret
201a5f0: 91 e8 3f ff restore %g0, -1, %o0
}
psiginfo->Info = *siginfo;
201a5f4: 90 07 60 08 add %i5, 8, %o0
201a5f8: 7f ff d7 4d call 201032c <memcpy>
201a5fc: 94 10 20 0c mov 0xc, %o2
_Chain_Append( &_POSIX_signals_Siginfo[ sig ], &psiginfo->Node );
201a600: 11 00 80 78 sethi %hi(0x201e000), %o0
201a604: 92 10 00 1d mov %i5, %o1
201a608: 90 12 22 68 or %o0, 0x268, %o0
201a60c: 7f ff b7 52 call 2008354 <_Chain_Append>
201a610: 90 02 00 19 add %o0, %i1, %o0
201a614: 30 bf ff dd b,a 201a588 <killinfo+0x250>
/*
* If the signal is being ignored, then we are out of here.
*/
if ( _POSIX_signals_Vectors[ sig ].sa_handler == SIG_IGN )
return 0;
201a618: b0 10 20 00 clr %i0
}
DEBUG_STEP("\n");
_Thread_Enable_dispatch();
return 0;
}
201a61c: 81 c7 e0 08 ret
201a620: 81 e8 00 00 restore
020040b4 <libc_wrapup>:
extern void _wrapup_reent(struct _reent *);
extern void _reclaim_reent(struct _reent *);
void libc_wrapup(void)
{
20040b4: 9d e3 bf a0 save %sp, -96, %sp
/*
* In case RTEMS is already down, don't do this. It could be
* dangerous.
*/
if (!_System_state_Is_up(_System_state_Get()))
20040b8: 03 00 80 77 sethi %hi(0x201dc00), %g1
20040bc: c2 00 60 20 ld [ %g1 + 0x20 ], %g1 ! 201dc20 <_System_state_Current>
20040c0: 80 a0 60 03 cmp %g1, 3
20040c4: 12 80 00 16 bne 200411c <libc_wrapup+0x68> <== NEVER TAKEN
20040c8: 03 00 80 70 sethi %hi(0x201c000), %g1
/*
* This was already done if the user called exit() directly .
_wrapup_reent(0);
*/
if (_REENT != _global_impure_ptr) {
20040cc: 39 00 80 74 sethi %hi(0x201d000), %i4
20040d0: fa 00 62 68 ld [ %g1 + 0x268 ], %i5
20040d4: c2 07 20 68 ld [ %i4 + 0x68 ], %g1
20040d8: 80 a0 40 1d cmp %g1, %i5
20040dc: 22 80 00 06 be,a 20040f4 <libc_wrapup+0x40>
20040e0: 3b 00 80 74 sethi %hi(0x201d000), %i5
_wrapup_reent(_global_impure_ptr);
20040e4: 40 00 31 70 call 20106a4 <_wrapup_reent>
20040e8: 90 10 00 1d mov %i5, %o0
/* 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;
20040ec: fa 27 20 68 st %i5, [ %i4 + 0x68 ]
*
* Should this be changed to do *all* file streams?
* _fwalk (_REENT, fclose);
*/
fclose (stdin);
20040f0: 3b 00 80 74 sethi %hi(0x201d000), %i5
20040f4: c2 07 60 68 ld [ %i5 + 0x68 ], %g1 ! 201d068 <_impure_ptr>
20040f8: 40 00 2e 98 call 200fb58 <fclose>
20040fc: d0 00 60 04 ld [ %g1 + 4 ], %o0
fclose (stdout);
2004100: c2 07 60 68 ld [ %i5 + 0x68 ], %g1
2004104: 40 00 2e 95 call 200fb58 <fclose>
2004108: d0 00 60 08 ld [ %g1 + 8 ], %o0
fclose (stderr);
200410c: c2 07 60 68 ld [ %i5 + 0x68 ], %g1
2004110: f0 00 60 0c ld [ %g1 + 0xc ], %i0
2004114: 40 00 2e 91 call 200fb58 <fclose>
2004118: 81 e8 00 00 restore
200411c: 81 c7 e0 08 ret <== NOT EXECUTED
2004120: 81 e8 00 00 restore <== NOT EXECUTED
02003b80 <malloc>:
#include "malloc_p.h"
void *malloc(
size_t size
)
{
2003b80: 9d e3 bf a0 save %sp, -96, %sp
void *return_this;
MSBUMP(malloc_calls, 1);
2003b84: 03 00 80 76 sethi %hi(0x201d800), %g1
2003b88: 82 10 61 58 or %g1, 0x158, %g1 ! 201d958 <rtems_malloc_statistics>
2003b8c: c4 00 60 04 ld [ %g1 + 4 ], %g2
#include "malloc_p.h"
void *malloc(
size_t size
)
{
2003b90: ba 10 00 18 mov %i0, %i5
void *return_this;
MSBUMP(malloc_calls, 1);
2003b94: 84 00 a0 01 inc %g2
/*
* If some free's have been deferred, then do them now.
*/
malloc_deferred_frees_process();
2003b98: 7f ff ff ae call 2003a50 <malloc_deferred_frees_process>
2003b9c: c4 20 60 04 st %g2, [ %g1 + 4 ]
/*
* Validate the parameters
*/
if ( !size )
2003ba0: 80 a6 20 00 cmp %i0, 0
2003ba4: 12 80 00 04 bne 2003bb4 <malloc+0x34>
2003ba8: 03 00 80 77 sethi %hi(0x201dc00), %g1
if ( !return_this ) {
if (rtems_malloc_sbrk_helpers)
return_this = (*rtems_malloc_sbrk_helpers->extend)( size );
if ( !return_this ) {
errno = ENOMEM;
return (void *) 0;
2003bac: 81 c7 e0 08 ret
2003bb0: 91 e8 20 00 restore %g0, 0, %o0
return (void *) 0;
/*
* Do not attempt to allocate memory if not in correct system state.
*/
if ( _System_state_Is_up(_System_state_Get()) &&
2003bb4: c2 00 60 20 ld [ %g1 + 0x20 ], %g1
2003bb8: 80 a0 60 03 cmp %g1, 3
2003bbc: 02 80 00 0c be 2003bec <malloc+0x6c>
2003bc0: 03 00 80 73 sethi %hi(0x201cc00), %g1
RTEMS_INLINE_ROUTINE void *_Protected_heap_Allocate(
Heap_Control *heap,
uintptr_t size
)
{
return _Protected_heap_Allocate_aligned_with_boundary( heap, size, 0, 0 );
2003bc4: d0 00 61 dc ld [ %g1 + 0x1dc ], %o0 ! 201cddc <RTEMS_Malloc_Heap>
2003bc8: 92 10 00 1d mov %i5, %o1
2003bcc: 94 10 20 00 clr %o2
2003bd0: 40 00 16 5d call 2009544 <_Protected_heap_Allocate_aligned_with_boundary>
2003bd4: 96 10 20 00 clr %o3
* If this fails then return a NULL pointer.
*/
return_this = _Protected_heap_Allocate( RTEMS_Malloc_Heap, size );
if ( !return_this ) {
2003bd8: 80 a2 20 00 cmp %o0, 0
2003bdc: 02 80 00 0b be 2003c08 <malloc+0x88>
2003be0: b0 10 00 08 mov %o0, %i0
}
/*
* If the user wants us to dirty the allocated memory, then do it.
*/
if ( rtems_malloc_dirty_helper )
2003be4: 10 80 00 19 b 2003c48 <malloc+0xc8>
2003be8: 03 00 80 75 sethi %hi(0x201d400), %g1
/*
* Do not attempt to allocate memory if not in correct system state.
*/
if ( _System_state_Is_up(_System_state_Get()) &&
!malloc_is_system_state_OK() )
2003bec: 7f ff ff 86 call 2003a04 <malloc_is_system_state_OK>
2003bf0: 01 00 00 00 nop
return (void *) 0;
/*
* Do not attempt to allocate memory if not in correct system state.
*/
if ( _System_state_Is_up(_System_state_Get()) &&
2003bf4: 80 8a 20 ff btst 0xff, %o0
2003bf8: 12 bf ff f3 bne 2003bc4 <malloc+0x44> <== ALWAYS TAKEN
2003bfc: 03 00 80 73 sethi %hi(0x201cc00), %g1
if ( !return_this ) {
if (rtems_malloc_sbrk_helpers)
return_this = (*rtems_malloc_sbrk_helpers->extend)( size );
if ( !return_this ) {
errno = ENOMEM;
return (void *) 0;
2003c00: 81 c7 e0 08 ret <== NOT EXECUTED
2003c04: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED
*/
return_this = _Protected_heap_Allocate( RTEMS_Malloc_Heap, size );
if ( !return_this ) {
if (rtems_malloc_sbrk_helpers)
2003c08: 03 00 80 75 sethi %hi(0x201d400), %g1
2003c0c: c2 00 61 90 ld [ %g1 + 0x190 ], %g1 ! 201d590 <rtems_malloc_sbrk_helpers>
2003c10: 80 a0 60 00 cmp %g1, 0
2003c14: 32 80 00 08 bne,a 2003c34 <malloc+0xb4>
2003c18: c2 00 60 04 ld [ %g1 + 4 ], %g1
return_this = (*rtems_malloc_sbrk_helpers->extend)( size );
if ( !return_this ) {
errno = ENOMEM;
2003c1c: 40 00 2f 7d call 200fa10 <__errno>
2003c20: 01 00 00 00 nop
2003c24: 82 10 20 0c mov 0xc, %g1 ! c <PROM_START+0xc>
2003c28: c2 22 00 00 st %g1, [ %o0 ]
return (void *) 0;
2003c2c: 81 c7 e0 08 ret
2003c30: 91 e8 20 00 restore %g0, 0, %o0
return_this = _Protected_heap_Allocate( RTEMS_Malloc_Heap, size );
if ( !return_this ) {
if (rtems_malloc_sbrk_helpers)
return_this = (*rtems_malloc_sbrk_helpers->extend)( size );
2003c34: 9f c0 40 00 call %g1
2003c38: 90 10 00 1d mov %i5, %o0
if ( !return_this ) {
2003c3c: b0 92 20 00 orcc %o0, 0, %i0
2003c40: 02 bf ff f7 be 2003c1c <malloc+0x9c>
2003c44: 03 00 80 75 sethi %hi(0x201d400), %g1
}
/*
* If the user wants us to dirty the allocated memory, then do it.
*/
if ( rtems_malloc_dirty_helper )
2003c48: c2 00 61 8c ld [ %g1 + 0x18c ], %g1 ! 201d58c <rtems_malloc_dirty_helper>
2003c4c: 80 a0 60 00 cmp %g1, 0
2003c50: 02 80 00 04 be 2003c60 <malloc+0xe0>
2003c54: 90 10 00 18 mov %i0, %o0
(*rtems_malloc_dirty_helper)( return_this, size );
2003c58: 9f c0 40 00 call %g1
2003c5c: 92 10 00 1d mov %i5, %o1
/*
* If configured, update the statistics
*/
if ( rtems_malloc_statistics_helpers )
2003c60: 03 00 80 75 sethi %hi(0x201d400), %g1
2003c64: c2 00 61 94 ld [ %g1 + 0x194 ], %g1 ! 201d594 <rtems_malloc_statistics_helpers>
2003c68: 80 a0 60 00 cmp %g1, 0
2003c6c: 02 80 00 05 be 2003c80 <malloc+0x100>
2003c70: 01 00 00 00 nop
(*rtems_malloc_statistics_helpers->at_malloc)(return_this);
2003c74: c2 00 60 04 ld [ %g1 + 4 ], %g1
2003c78: 9f c0 40 00 call %g1
2003c7c: 90 10 00 18 mov %i0, %o0
return return_this;
}
2003c80: 81 c7 e0 08 ret
2003c84: 81 e8 00 00 restore
02003c04 <malloc_sbrk_extend_and_allocate>:
}
static void *malloc_sbrk_extend_and_allocate(
size_t size
)
{
2003c04: 9d e3 bf a0 save %sp, -96, %sp
* 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;
2003c08: 03 00 80 77 sethi %hi(0x201dc00), %g1
2003c0c: fa 00 60 d8 ld [ %g1 + 0xd8 ], %i5 ! 201dcd8 <RTEMS_Malloc_Sbrk_amount>
if ( sbrk_amount == 0 )
2003c10: 80 a7 60 00 cmp %i5, 0
2003c14: 02 80 00 22 be 2003c9c <malloc_sbrk_extend_and_allocate+0x98><== NEVER TAKEN
2003c18: b2 10 00 18 mov %i0, %i1
return (void *) 0;
the_size = ((size + sbrk_amount) / sbrk_amount * sbrk_amount);
2003c1c: 92 10 00 1d mov %i5, %o1
2003c20: 40 00 53 c0 call 2018b20 <.udiv>
2003c24: 90 06 00 1d add %i0, %i5, %o0
2003c28: 40 00 53 84 call 2018a38 <.umul>
2003c2c: 92 10 00 1d mov %i5, %o1
starting_address = (void *) sbrk(the_size);
2003c30: 7f ff f6 22 call 20014b8 <sbrk>
2003c34: ba 10 00 08 mov %o0, %i5
if ( starting_address == (void*) -1 )
2003c38: 80 a2 3f ff cmp %o0, -1
2003c3c: 02 80 00 18 be 2003c9c <malloc_sbrk_extend_and_allocate+0x98>
2003c40: 92 10 00 08 mov %o0, %o1
return (void *) 0;
if ( !_Protected_heap_Extend(
2003c44: 39 00 80 73 sethi %hi(0x201cc00), %i4
2003c48: d0 07 23 cc ld [ %i4 + 0x3cc ], %o0 ! 201cfcc <RTEMS_Malloc_Heap>
2003c4c: 40 00 16 28 call 20094ec <_Protected_heap_Extend>
2003c50: 94 10 00 1d mov %i5, %o2
2003c54: 80 8a 20 ff btst 0xff, %o0
2003c58: 12 80 00 0a bne 2003c80 <malloc_sbrk_extend_and_allocate+0x7c>
2003c5c: 03 00 80 77 sethi %hi(0x201dc00), %g1
RTEMS_Malloc_Heap, starting_address, the_size) ) {
sbrk(-the_size);
2003c60: 7f ff f6 16 call 20014b8 <sbrk>
2003c64: 90 20 00 1d neg %i5, %o0
errno = ENOMEM;
2003c68: 40 00 30 0e call 200fca0 <__errno>
2003c6c: b0 10 20 00 clr %i0
2003c70: 82 10 20 0c mov 0xc, %g1
2003c74: c2 22 00 00 st %g1, [ %o0 ]
2003c78: 81 c7 e0 08 ret
2003c7c: 81 e8 00 00 restore
2003c80: f0 07 23 cc ld [ %i4 + 0x3cc ], %i0
return (void *) 0;
}
MSBUMP(space_available, the_size);
2003c84: c4 00 60 a8 ld [ %g1 + 0xa8 ], %g2
2003c88: b4 10 20 00 clr %i2
2003c8c: ba 07 40 02 add %i5, %g2, %i5
2003c90: fa 20 60 a8 st %i5, [ %g1 + 0xa8 ]
2003c94: 40 00 16 08 call 20094b4 <_Protected_heap_Allocate_aligned_with_boundary>
2003c98: 97 e8 20 00 restore %g0, 0, %o3
return_this = _Protected_heap_Allocate( RTEMS_Malloc_Heap, size );
return return_this;
}
2003c9c: b0 10 20 00 clr %i0
2003ca0: 81 c7 e0 08 ret
2003ca4: 81 e8 00 00 restore
02003ca8 <malloc_sbrk_initialize>:
static void *malloc_sbrk_initialize(
void *starting_address,
size_t length
)
{
2003ca8: 9d e3 bf a0 save %sp, -96, %sp
uintptr_t old_address;
uintptr_t uaddress;
RTEMS_Malloc_Sbrk_amount = length;
2003cac: 03 00 80 77 sethi %hi(0x201dc00), %g1
* 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) {
2003cb0: 80 a6 20 00 cmp %i0, 0
2003cb4: 12 80 00 0e bne 2003cec <malloc_sbrk_initialize+0x44>
2003cb8: f2 20 60 d8 st %i1, [ %g1 + 0xd8 ]
uaddress = (uintptr_t)sbrk(length);
2003cbc: 7f ff f5 ff call 20014b8 <sbrk>
2003cc0: 90 10 00 19 mov %i1, %o0
if (uaddress == (uintptr_t) -1) {
2003cc4: 80 a2 3f ff cmp %o0, -1
2003cc8: 12 80 00 04 bne 2003cd8 <malloc_sbrk_initialize+0x30> <== NEVER TAKEN
2003ccc: 80 8a 20 07 btst 7, %o0
rtems_fatal_error_occurred( RTEMS_NO_MEMORY );
2003cd0: 40 00 10 d0 call 2008010 <rtems_fatal_error_occurred>
2003cd4: 90 10 20 1a mov 0x1a, %o0
/* DOES NOT RETURN!!! */
}
if (uaddress & (CPU_HEAP_ALIGNMENT-1)) {
2003cd8: 22 80 00 05 be,a 2003cec <malloc_sbrk_initialize+0x44> <== NOT EXECUTED
2003cdc: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED
old_address = uaddress;
uaddress = (uaddress + CPU_HEAP_ALIGNMENT) & ~(CPU_HEAP_ALIGNMENT-1);
2003ce0: 90 02 20 08 add %o0, 8, %o0 <== NOT EXECUTED
2003ce4: 90 0a 3f f8 and %o0, -8, %o0 <== NOT EXECUTED
* adjust the length by whatever we aligned by
*/
length -= uaddress - old_address;
}
starting_address = (void *)uaddress;
2003ce8: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED
}
return starting_address;
}
2003cec: 81 c7 e0 08 ret
2003cf0: 81 e8 00 00 restore
0200def4 <memfile_alloc_block>:
* Allocate a block for an in-memory file.
*/
int memfile_blocks_allocated = 0;
void *memfile_alloc_block(void)
{
200def4: 9d e3 bf a0 save %sp, -96, %sp
void *memory;
memory = (void *)calloc(1, IMFS_MEMFILE_BYTES_PER_BLOCK);
200def8: 03 00 80 75 sethi %hi(0x201d400), %g1
200defc: d2 00 61 c8 ld [ %g1 + 0x1c8 ], %o1 ! 201d5c8 <imfs_memfile_bytes_per_block>
200df00: 7f ff d5 83 call 200350c <calloc>
200df04: 90 10 20 01 mov 1, %o0
if ( memory )
200df08: b0 92 20 00 orcc %o0, 0, %i0
200df0c: 02 80 00 05 be 200df20 <memfile_alloc_block+0x2c> <== NEVER TAKEN
200df10: 03 00 80 75 sethi %hi(0x201d400), %g1
memfile_blocks_allocated++;
200df14: c4 00 62 dc ld [ %g1 + 0x2dc ], %g2 ! 201d6dc <memfile_blocks_allocated>
200df18: 84 00 a0 01 inc %g2
200df1c: c4 20 62 dc st %g2, [ %g1 + 0x2dc ]
return memory;
}
200df20: 81 c7 e0 08 ret
200df24: 81 e8 00 00 restore
0200ea24 <memfile_ftruncate>:
*/
int memfile_ftruncate(
rtems_libio_t *iop,
off_t length
)
{
200ea24: 9d e3 bf 98 save %sp, -104, %sp
IMFS_jnode_t *the_jnode;
the_jnode = iop->pathinfo.node_access;
200ea28: fa 06 20 1c ld [ %i0 + 0x1c ], %i5
* 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 )
200ea2c: c2 07 60 50 ld [ %i5 + 0x50 ], %g1
200ea30: 80 a0 40 19 cmp %g1, %i1
200ea34: 06 80 00 09 bl 200ea58 <memfile_ftruncate+0x34> <== NEVER TAKEN
200ea38: 90 10 00 1d mov %i5, %o0
200ea3c: 32 80 00 0d bne,a 200ea70 <memfile_ftruncate+0x4c> <== NEVER TAKEN
200ea40: f2 27 60 50 st %i1, [ %i5 + 0x50 ] <== NOT EXECUTED
200ea44: c2 07 60 54 ld [ %i5 + 0x54 ], %g1
200ea48: 80 a0 40 1a cmp %g1, %i2
200ea4c: 3a 80 00 09 bcc,a 200ea70 <memfile_ftruncate+0x4c>
200ea50: f2 27 60 50 st %i1, [ %i5 + 0x50 ]
return IMFS_memfile_extend( the_jnode, true, length );
200ea54: 90 10 00 1d mov %i5, %o0
200ea58: 92 10 20 01 mov 1, %o1
200ea5c: 94 10 00 19 mov %i1, %o2
200ea60: 7f ff fe de call 200e5d8 <IMFS_memfile_extend>
200ea64: 96 10 00 1a mov %i2, %o3
200ea68: 81 c7 e0 08 ret
200ea6c: 91 e8 00 08 restore %g0, %o0, %o0
/*
* 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;
200ea70: f4 27 60 54 st %i2, [ %i5 + 0x54 ]
IMFS_update_atime( the_jnode );
200ea74: 90 07 bf f8 add %fp, -8, %o0
200ea78: 7f ff d3 83 call 2003884 <gettimeofday>
200ea7c: 92 10 20 00 clr %o1
200ea80: c2 07 bf f8 ld [ %fp + -8 ], %g1
200ea84: c2 27 60 40 st %g1, [ %i5 + 0x40 ]
return 0;
}
200ea88: 81 c7 e0 08 ret
200ea8c: 91 e8 20 00 restore %g0, 0, %o0
0200e9a8 <memfile_open>:
rtems_libio_t *iop,
const char *pathname,
int oflag,
mode_t mode
)
{
200e9a8: 9d e3 bf a0 save %sp, -96, %sp
the_jnode = iop->pathinfo.node_access;
/*
* Perform 'copy on write' for linear files
*/
if ((iop->flags & LIBIO_FLAGS_WRITE)
200e9ac: c2 06 20 10 ld [ %i0 + 0x10 ], %g1
200e9b0: 80 88 60 04 btst 4, %g1
200e9b4: 12 80 00 04 bne 200e9c4 <memfile_open+0x1c>
200e9b8: d0 06 20 1c ld [ %i0 + 0x1c ], %o0
if ((count != 0)
&& (IMFS_memfile_write(the_jnode, 0, buffer, count) == -1))
return -1;
}
return 0;
200e9bc: 81 c7 e0 08 ret
200e9c0: 91 e8 20 00 restore %g0, 0, %o0
200e9c4: c2 02 20 4c ld [ %o0 + 0x4c ], %g1
/*
* Perform 'copy on write' for linear files
*/
if ((iop->flags & LIBIO_FLAGS_WRITE)
&& (IMFS_type( the_jnode ) == IMFS_LINEAR_FILE)) {
200e9c8: c2 00 40 00 ld [ %g1 ], %g1
200e9cc: 80 a0 60 05 cmp %g1, 5
200e9d0: 12 bf ff fb bne 200e9bc <memfile_open+0x14> <== ALWAYS TAKEN
200e9d4: 03 00 80 6e sethi %hi(0x201b800), %g1
uint32_t count = the_jnode->info.linearfile.size;
200e9d8: d8 02 20 54 ld [ %o0 + 0x54 ], %o4 <== NOT EXECUTED
const unsigned char *buffer = the_jnode->info.linearfile.direct;
200e9dc: d6 02 20 58 ld [ %o0 + 0x58 ], %o3 <== NOT EXECUTED
the_jnode->control = &IMFS_node_control_memfile;
the_jnode->info.file.size = 0;
200e9e0: c0 22 20 50 clr [ %o0 + 0x50 ] <== NOT EXECUTED
if ((iop->flags & LIBIO_FLAGS_WRITE)
&& (IMFS_type( the_jnode ) == IMFS_LINEAR_FILE)) {
uint32_t count = the_jnode->info.linearfile.size;
const unsigned char *buffer = the_jnode->info.linearfile.direct;
the_jnode->control = &IMFS_node_control_memfile;
200e9e4: 82 10 62 fc or %g1, 0x2fc, %g1 <== NOT EXECUTED
the_jnode->info.file.size = 0;
200e9e8: c0 22 20 54 clr [ %o0 + 0x54 ] <== NOT EXECUTED
if ((iop->flags & LIBIO_FLAGS_WRITE)
&& (IMFS_type( the_jnode ) == IMFS_LINEAR_FILE)) {
uint32_t count = the_jnode->info.linearfile.size;
const unsigned char *buffer = the_jnode->info.linearfile.direct;
the_jnode->control = &IMFS_node_control_memfile;
200e9ec: c2 22 20 4c st %g1, [ %o0 + 0x4c ] <== NOT EXECUTED
the_jnode->info.file.size = 0;
the_jnode->info.file.indirect = 0;
200e9f0: c0 22 20 58 clr [ %o0 + 0x58 ] <== NOT EXECUTED
the_jnode->info.file.doubly_indirect = 0;
200e9f4: c0 22 20 5c clr [ %o0 + 0x5c ] <== NOT EXECUTED
the_jnode->info.file.triply_indirect = 0;
if ((count != 0)
200e9f8: 80 a3 20 00 cmp %o4, 0 <== NOT EXECUTED
200e9fc: 02 bf ff f0 be 200e9bc <memfile_open+0x14> <== NOT EXECUTED
200ea00: c0 22 20 60 clr [ %o0 + 0x60 ] <== NOT EXECUTED
&& (IMFS_memfile_write(the_jnode, 0, buffer, count) == -1))
200ea04: 92 10 20 00 clr %o1 <== NOT EXECUTED
200ea08: 7f ff ff 5c call 200e778 <IMFS_memfile_write> <== NOT EXECUTED
200ea0c: 94 10 20 00 clr %o2 <== NOT EXECUTED
return -1;
200ea10: 90 38 00 08 xnor %g0, %o0, %o0 <== NOT EXECUTED
200ea14: 80 a0 00 08 cmp %g0, %o0 <== NOT EXECUTED
200ea18: b0 40 3f ff addx %g0, -1, %i0 <== NOT EXECUTED
}
return 0;
}
200ea1c: 81 c7 e0 08 ret <== NOT EXECUTED
200ea20: 81 e8 00 00 restore <== NOT EXECUTED
02003da8 <mount>:
const char *target,
const char *filesystemtype,
rtems_filesystem_options_t options,
const void *data
)
{
2003da8: 9d e3 bf 50 save %sp, -176, %sp
int rv = 0;
if (
2003dac: 80 a6 e0 01 cmp %i3, 1
2003db0: 18 80 00 b2 bgu 2004078 <mount+0x2d0>
2003db4: 01 00 00 00 nop
options == RTEMS_FILESYSTEM_READ_ONLY
|| options == RTEMS_FILESYSTEM_READ_WRITE
) {
rtems_filesystem_fsmount_me_t fsmount_me_h =
2003db8: 40 00 21 45 call 200c2cc <rtems_filesystem_get_mount_handler>
2003dbc: 90 10 00 1a mov %i2, %o0
rtems_filesystem_get_mount_handler( filesystemtype );
if ( fsmount_me_h != NULL ) {
2003dc0: a6 92 20 00 orcc %o0, 0, %l3
2003dc4: 02 80 00 ad be 2004078 <mount+0x2d0>
2003dc8: a2 96 60 00 orcc %i1, 0, %l1
const char *target_or_null,
const char *filesystemtype,
size_t *target_length_ptr
)
{
const char *target = target_or_null != NULL ? target_or_null : "/";
2003dcc: 12 80 00 04 bne 2003ddc <mount+0x34>
2003dd0: 01 00 00 00 nop
2003dd4: 23 00 80 6d sethi %hi(0x201b400), %l1
2003dd8: a2 14 63 08 or %l1, 0x308, %l1 ! 201b708 <rtems_status_assoc+0x1a0>
size_t filesystemtype_size = strlen( filesystemtype ) + 1;
2003ddc: 40 00 34 8a call 2011004 <strlen>
2003de0: 90 10 00 1a mov %i2, %o0
size_t source_size = source_or_null != NULL ?
strlen( source_or_null ) + 1 : 0;
2003de4: 80 a6 20 00 cmp %i0, 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;
2003de8: ba 10 00 08 mov %o0, %i5
size_t source_size = source_or_null != NULL ?
strlen( source_or_null ) + 1 : 0;
2003dec: 02 80 00 06 be 2003e04 <mount+0x5c>
2003df0: aa 02 20 01 add %o0, 1, %l5
2003df4: 40 00 34 84 call 2011004 <strlen>
2003df8: 90 10 00 18 mov %i0, %o0
2003dfc: 10 80 00 03 b 2003e08 <mount+0x60>
2003e00: a0 02 20 01 add %o0, 1, %l0
2003e04: a0 10 20 00 clr %l0
size_t target_size = strlen( target ) + 1;
size_t size = sizeof( rtems_filesystem_mount_table_entry_t )
+ filesystemtype_size + source_size + target_size
2003e08: ba 07 60 65 add %i5, 0x65, %i5
{
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;
2003e0c: 40 00 34 7e call 2011004 <strlen>
2003e10: 90 10 00 11 mov %l1, %o0
size_t size = sizeof( rtems_filesystem_mount_table_entry_t )
+ filesystemtype_size + source_size + target_size
2003e14: 92 07 40 10 add %i5, %l0, %o1
{
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;
2003e18: a8 02 20 01 add %o0, 1, %l4
size_t size = sizeof( rtems_filesystem_mount_table_entry_t )
+ filesystemtype_size + source_size + target_size
+ sizeof( rtems_filesystem_global_location_t );
rtems_filesystem_mount_table_entry_t *mt_entry = calloc( 1, size );
2003e1c: 90 10 20 01 mov 1, %o0
2003e20: 7f ff fd bb call 200350c <calloc>
2003e24: 92 02 40 14 add %o1, %l4, %o1
if ( mt_entry != NULL ) {
2003e28: ba 92 20 00 orcc %o0, 0, %i5
2003e2c: 02 80 00 9b be 2004098 <mount+0x2f0> <== NEVER TAKEN
2003e30: a4 07 60 64 add %i5, 0x64, %l2
rtems_filesystem_global_location_t *mt_fs_root =
(rtems_filesystem_global_location_t *)
((char *) mt_entry + sizeof( *mt_entry ));
char *str = (char *) mt_fs_root + sizeof( *mt_fs_root );
memcpy( str, filesystemtype, filesystemtype_size );
2003e34: 92 10 00 1a mov %i2, %o1
2003e38: 94 10 00 15 mov %l5, %o2
2003e3c: 40 00 31 3c call 201032c <memcpy>
2003e40: 90 10 00 12 mov %l2, %o0
mt_entry->type = str;
str += filesystemtype_size;
2003e44: b4 04 80 15 add %l2, %l5, %i2
memcpy( str, source_or_null, source_size );
2003e48: 92 10 00 18 mov %i0, %o1
2003e4c: 94 10 00 10 mov %l0, %o2
(rtems_filesystem_global_location_t *)
((char *) mt_entry + sizeof( *mt_entry ));
char *str = (char *) mt_fs_root + sizeof( *mt_fs_root );
memcpy( str, filesystemtype, filesystemtype_size );
mt_entry->type = str;
2003e50: e4 27 60 34 st %l2, [ %i5 + 0x34 ]
str += filesystemtype_size;
memcpy( str, source_or_null, source_size );
2003e54: 40 00 31 36 call 201032c <memcpy>
2003e58: 90 10 00 1a mov %i2, %o0
mt_entry->dev = str;
str += source_size;
2003e5c: a0 06 80 10 add %i2, %l0, %l0
memcpy( str, target, target_size );
2003e60: 92 10 00 11 mov %l1, %o1
2003e64: 94 10 00 14 mov %l4, %o2
memcpy( str, filesystemtype, filesystemtype_size );
mt_entry->type = str;
str += filesystemtype_size;
memcpy( str, source_or_null, source_size );
mt_entry->dev = str;
2003e68: f4 27 60 38 st %i2, [ %i5 + 0x38 ]
str += source_size;
memcpy( str, target, target_size );
2003e6c: 40 00 31 30 call 201032c <memcpy>
2003e70: 90 10 00 10 mov %l0, %o0
mt_entry->target = str;
str += target_size;
mt_entry->mounted = true;
2003e74: 82 10 20 01 mov 1, %g1
2003e78: c2 2f 60 28 stb %g1, [ %i5 + 0x28 ]
mt_entry->mt_fs_root = mt_fs_root;
mt_entry->pathconf_limits_and_options = &rtems_filesystem_default_pathconf;
2003e7c: 03 00 80 6d sethi %hi(0x201b400), %g1
2003e80: 82 10 63 0c or %g1, 0x30c, %g1 ! 201b70c <rtems_filesystem_default_pathconf>
2003e84: c2 27 60 2c st %g1, [ %i5 + 0x2c ]
mt_fs_root->location.mt_entry = mt_entry;
mt_fs_root->reference_count = 1;
2003e88: 82 10 20 01 mov 1, %g1
+ filesystemtype_size + source_size + target_size
+ sizeof( rtems_filesystem_global_location_t );
rtems_filesystem_mount_table_entry_t *mt_entry = calloc( 1, size );
if ( mt_entry != NULL ) {
rtems_filesystem_global_location_t *mt_fs_root =
2003e8c: ac 07 60 40 add %i5, 0x40, %l6
mt_entry->mounted = true;
mt_entry->mt_fs_root = mt_fs_root;
mt_entry->pathconf_limits_and_options = &rtems_filesystem_default_pathconf;
mt_fs_root->location.mt_entry = mt_entry;
mt_fs_root->reference_count = 1;
2003e90: c2 27 60 58 st %g1, [ %i5 + 0x58 ]
void *starting_address,
size_t number_nodes,
size_t node_size
)
{
_Chain_Initialize( the_chain, starting_address, number_nodes, node_size );
2003e94: 90 07 60 14 add %i5, 0x14, %o0
2003e98: 92 10 00 16 mov %l6, %o1
2003e9c: 94 10 20 01 mov 1, %o2
2003ea0: 96 10 20 24 mov 0x24, %o3
memcpy( str, source_or_null, source_size );
mt_entry->dev = str;
str += source_size;
memcpy( str, target, target_size );
mt_entry->target = str;
2003ea4: e0 27 60 30 st %l0, [ %i5 + 0x30 ]
str += target_size;
mt_entry->mounted = true;
mt_entry->mt_fs_root = mt_fs_root;
2003ea8: ec 27 60 24 st %l6, [ %i5 + 0x24 ]
2003eac: 40 00 11 45 call 20083c0 <_Chain_Initialize>
2003eb0: fa 27 60 54 st %i5, [ %i5 + 0x54 ]
filesystemtype,
&target_length
);
if ( mt_entry != NULL ) {
mt_entry->writeable = options == RTEMS_FILESYSTEM_READ_WRITE;
2003eb4: b6 0e e0 01 and %i3, 1, %i3
rv = (*fsmount_me_h)( mt_entry, data );
2003eb8: 90 10 00 1d mov %i5, %o0
filesystemtype,
&target_length
);
if ( mt_entry != NULL ) {
mt_entry->writeable = options == RTEMS_FILESYSTEM_READ_WRITE;
2003ebc: f6 2f 60 29 stb %i3, [ %i5 + 0x29 ]
rv = (*fsmount_me_h)( mt_entry, data );
2003ec0: 9f c4 c0 00 call %l3
2003ec4: 92 10 00 1c mov %i4, %o1
if ( rv == 0 ) {
2003ec8: b0 92 20 00 orcc %o0, 0, %i0
2003ecc: 12 80 00 6f bne 2004088 <mount+0x2e0>
2003ed0: 80 a6 60 00 cmp %i1, 0
if ( target != NULL ) {
2003ed4: 02 80 00 38 be 2003fb4 <mount+0x20c>
2003ed8: 92 10 00 19 mov %i1, %o1
{
int rv = 0;
rtems_filesystem_eval_path_context_t ctx;
int eval_flags = RTEMS_FS_PERMS_RWX
| RTEMS_FS_FOLLOW_LINK;
rtems_filesystem_location_info_t *currentloc =
2003edc: 94 10 20 1f mov 0x1f, %o2
2003ee0: 40 00 02 fb call 2004acc <rtems_filesystem_eval_path_start>
2003ee4: 90 07 bf c8 add %fp, -56, %o0
static inline bool rtems_filesystem_location_is_root(
const rtems_filesystem_location_info_t *loc
)
{
const rtems_filesystem_mount_table_entry_t *mt_entry = loc->mt_entry;
2003ee8: c2 02 20 14 ld [ %o0 + 0x14 ], %g1
return (*mt_entry->ops->are_nodes_equal_h)(
2003eec: c4 00 60 0c ld [ %g1 + 0xc ], %g2
2003ef0: c4 00 a0 10 ld [ %g2 + 0x10 ], %g2
2003ef4: 9f c0 80 00 call %g2
2003ef8: d2 00 60 24 ld [ %g1 + 0x24 ], %o1
rtems_filesystem_eval_path_start( &ctx, target, eval_flags );
if ( !rtems_filesystem_location_is_root( currentloc ) ) {
2003efc: 80 8a 20 ff btst 0xff, %o0
2003f00: 12 80 00 22 bne 2003f88 <mount+0x1e0>
2003f04: 92 07 bf e0 add %fp, -32, %o1
static inline void rtems_filesystem_eval_path_extract_currentloc(
rtems_filesystem_eval_path_context_t *ctx,
rtems_filesystem_location_info_t *get
)
{
rtems_filesystem_location_copy_and_detach(
2003f08: 40 00 03 eb call 2004eb4 <rtems_filesystem_location_copy_and_detach>
2003f0c: 90 07 bf b0 add %fp, -80, %o0
rtems_filesystem_location_info_t targetloc;
rtems_filesystem_global_location_t *mt_point_node;
rtems_filesystem_eval_path_extract_currentloc( &ctx, &targetloc );
mt_point_node = rtems_filesystem_location_transform_to_global( &targetloc );
2003f10: 40 00 04 62 call 2005098 <rtems_filesystem_location_transform_to_global>
2003f14: 90 07 bf b0 add %fp, -80, %o0
mt_entry->mt_point_node = mt_point_node;
rv = (*mt_point_node->location.mt_entry->ops->mount_h)( mt_entry );
2003f18: c2 02 20 14 ld [ %o0 + 0x14 ], %g1
rtems_filesystem_location_info_t targetloc;
rtems_filesystem_global_location_t *mt_point_node;
rtems_filesystem_eval_path_extract_currentloc( &ctx, &targetloc );
mt_point_node = rtems_filesystem_location_transform_to_global( &targetloc );
mt_entry->mt_point_node = mt_point_node;
2003f1c: d0 27 60 20 st %o0, [ %i5 + 0x20 ]
rv = (*mt_point_node->location.mt_entry->ops->mount_h)( mt_entry );
2003f20: c2 00 60 0c ld [ %g1 + 0xc ], %g1
if ( !rtems_filesystem_location_is_root( currentloc ) ) {
rtems_filesystem_location_info_t targetloc;
rtems_filesystem_global_location_t *mt_point_node;
rtems_filesystem_eval_path_extract_currentloc( &ctx, &targetloc );
mt_point_node = rtems_filesystem_location_transform_to_global( &targetloc );
2003f24: b8 10 00 08 mov %o0, %i4
mt_entry->mt_point_node = mt_point_node;
rv = (*mt_point_node->location.mt_entry->ops->mount_h)( mt_entry );
2003f28: c2 00 60 30 ld [ %g1 + 0x30 ], %g1
2003f2c: 9f c0 40 00 call %g1
2003f30: 90 10 00 1d mov %i5, %o0
if ( rv == 0 ) {
2003f34: b0 92 20 00 orcc %o0, 0, %i0
2003f38: 12 80 00 11 bne 2003f7c <mount+0x1d4>
2003f3c: 92 10 20 00 clr %o1
*/
#include <rtems/userenv.h>
static inline void rtems_libio_lock( void )
{
rtems_semaphore_obtain( rtems_libio_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT );
2003f40: 39 00 80 76 sethi %hi(0x201d800), %i4
2003f44: d0 07 21 48 ld [ %i4 + 0x148 ], %o0 ! 201d948 <rtems_libio_semaphore>
2003f48: 40 00 0e 67 call 20078e4 <rtems_semaphore_obtain>
2003f4c: 94 10 20 00 clr %o2
Chain_Control *the_chain,
Chain_Node *the_node
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
2003f50: 03 00 80 73 sethi %hi(0x201cc00), %g1
}
static inline void rtems_libio_unlock( void )
{
rtems_semaphore_release( rtems_libio_semaphore );
2003f54: d0 07 21 48 ld [ %i4 + 0x148 ], %o0
2003f58: 82 10 62 e8 or %g1, 0x2e8, %g1
2003f5c: c4 00 60 08 ld [ %g1 + 8 ], %g2
the_node->next = tail;
2003f60: 86 00 60 04 add %g1, 4, %g3
2003f64: c6 27 40 00 st %g3, [ %i5 ]
tail->previous = the_node;
2003f68: fa 20 60 08 st %i5, [ %g1 + 8 ]
old_last->next = the_node;
2003f6c: fa 20 80 00 st %i5, [ %g2 ]
2003f70: 40 00 0e a7 call 2007a0c <rtems_semaphore_release>
2003f74: c4 27 60 04 st %g2, [ %i5 + 4 ]
2003f78: 30 80 00 08 b,a 2003f98 <mount+0x1f0>
&rtems_filesystem_mount_table,
&mt_entry->mt_node
);
rtems_filesystem_mt_unlock();
} else {
rtems_filesystem_global_location_release( mt_point_node );
2003f7c: 40 00 03 f3 call 2004f48 <rtems_filesystem_global_location_release>
2003f80: 90 10 00 1c mov %i4, %o0
2003f84: 30 80 00 05 b,a 2003f98 <mount+0x1f0>
}
} else {
rtems_filesystem_eval_path_error( &ctx, EBUSY );
2003f88: 90 07 bf c8 add %fp, -56, %o0
2003f8c: 92 10 20 10 mov 0x10, %o1
2003f90: 40 00 02 39 call 2004874 <rtems_filesystem_eval_path_error>
2003f94: b0 10 3f ff mov -1, %i0
rv = -1;
}
rtems_filesystem_eval_path_cleanup( &ctx );
2003f98: 40 00 03 09 call 2004bbc <rtems_filesystem_eval_path_cleanup>
2003f9c: 90 07 bf c8 add %fp, -56, %o0
rv = register_subordinate_file_system( mt_entry, target );
} else {
rv = register_root_file_system( mt_entry );
}
if ( rv != 0 ) {
2003fa0: 80 a6 20 00 cmp %i0, 0
2003fa4: 02 80 00 42 be 20040ac <mount+0x304>
2003fa8: 01 00 00 00 nop
(*mt_entry->ops->fsunmount_me_h)( mt_entry );
2003fac: 10 80 00 2f b 2004068 <mount+0x2c0>
2003fb0: c2 07 60 0c ld [ %i5 + 0xc ], %g1
*/
#include <rtems/userenv.h>
static inline void rtems_libio_lock( void )
{
rtems_semaphore_obtain( rtems_libio_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT );
2003fb4: 03 00 80 76 sethi %hi(0x201d800), %g1
2003fb8: d0 00 61 48 ld [ %g1 + 0x148 ], %o0 ! 201d948 <rtems_libio_semaphore>
2003fbc: 92 10 20 00 clr %o1
2003fc0: 40 00 0e 49 call 20078e4 <rtems_semaphore_obtain>
2003fc4: 94 10 20 00 clr %o2
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_head( the_chain )->next;
2003fc8: 05 00 80 73 sethi %hi(0x201cc00), %g2
)
{
int rv = 0;
rtems_filesystem_mt_lock();
if ( rtems_chain_is_empty( &rtems_filesystem_mount_table ) ) {
2003fcc: c6 00 a2 e8 ld [ %g2 + 0x2e8 ], %g3 ! 201cee8 <rtems_filesystem_mount_table>
2003fd0: 82 10 a2 e8 or %g2, 0x2e8, %g1
2003fd4: 84 00 60 04 add %g1, 4, %g2
2003fd8: 80 a0 c0 02 cmp %g3, %g2
2003fdc: 12 80 00 08 bne 2003ffc <mount+0x254> <== NEVER TAKEN
2003fe0: 01 00 00 00 nop
Chain_Control *the_chain,
Chain_Node *the_node
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
2003fe4: c4 00 60 08 ld [ %g1 + 8 ], %g2
the_node->next = tail;
2003fe8: c6 27 40 00 st %g3, [ %i5 ]
tail->previous = the_node;
2003fec: fa 20 60 08 st %i5, [ %g1 + 8 ]
old_last->next = the_node;
2003ff0: fa 20 80 00 st %i5, [ %g2 ]
the_node->previous = old_last;
2003ff4: 10 80 00 06 b 200400c <mount+0x264>
2003ff8: c4 27 60 04 st %g2, [ %i5 + 4 ]
rtems_chain_append_unprotected(
&rtems_filesystem_mount_table,
&mt_entry->mt_node
);
} else {
errno = EINVAL;
2003ffc: 40 00 2e 85 call 200fa10 <__errno> <== NOT EXECUTED
2004000: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
2004004: 82 10 20 16 mov 0x16, %g1 <== NOT EXECUTED
2004008: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
}
static inline void rtems_libio_unlock( void )
{
rtems_semaphore_release( rtems_libio_semaphore );
200400c: 03 00 80 76 sethi %hi(0x201d800), %g1
2004010: 40 00 0e 7f call 2007a0c <rtems_semaphore_release>
2004014: d0 00 61 48 ld [ %g1 + 0x148 ], %o0 ! 201d948 <rtems_libio_semaphore>
rv = -1;
}
rtems_filesystem_mt_unlock();
if ( rv == 0 ) {
2004018: 80 a6 20 00 cmp %i0, 0
200401c: 32 80 00 13 bne,a 2004068 <mount+0x2c0> <== NEVER TAKEN
2004020: c2 07 60 0c ld [ %i5 + 0xc ], %g1 <== NOT EXECUTED
rtems_filesystem_global_location_t *new_fs_root =
rtems_filesystem_global_location_obtain( &mt_entry->mt_fs_root );
2004024: ba 07 60 24 add %i5, 0x24, %i5
rv = -1;
}
rtems_filesystem_mt_unlock();
if ( rv == 0 ) {
rtems_filesystem_global_location_t *new_fs_root =
2004028: 40 00 03 e9 call 2004fcc <rtems_filesystem_global_location_obtain>
200402c: 90 10 00 1d mov %i5, %o0
2004030: b6 10 00 08 mov %o0, %i3
rtems_filesystem_global_location_obtain( &mt_entry->mt_fs_root );
rtems_filesystem_global_location_t *new_fs_current =
2004034: 40 00 03 e6 call 2004fcc <rtems_filesystem_global_location_obtain>
2004038: 90 10 00 1d mov %i5, %o0
rtems_filesystem_global_location_obtain( &mt_entry->mt_fs_root );
rtems_filesystem_global_location_assign(
200403c: 3b 00 80 73 sethi %hi(0x201cc00), %i5
rtems_filesystem_mt_unlock();
if ( rv == 0 ) {
rtems_filesystem_global_location_t *new_fs_root =
rtems_filesystem_global_location_obtain( &mt_entry->mt_fs_root );
rtems_filesystem_global_location_t *new_fs_current =
2004040: b8 10 00 08 mov %o0, %i4
rtems_filesystem_global_location_obtain( &mt_entry->mt_fs_root );
rtems_filesystem_global_location_assign(
2004044: d0 07 63 08 ld [ %i5 + 0x308 ], %o0
2004048: 92 10 00 1b mov %i3, %o1
200404c: 40 00 03 d7 call 2004fa8 <rtems_filesystem_global_location_assign>
2004050: 90 02 20 04 add %o0, 4, %o0
&rtems_filesystem_root,
new_fs_root
);
rtems_filesystem_global_location_assign(
2004054: d0 07 63 08 ld [ %i5 + 0x308 ], %o0
2004058: 40 00 03 d4 call 2004fa8 <rtems_filesystem_global_location_assign>
200405c: 92 10 00 1c mov %i4, %o1
2004060: 81 c7 e0 08 ret
2004064: 81 e8 00 00 restore
} else {
rv = register_root_file_system( mt_entry );
}
if ( rv != 0 ) {
(*mt_entry->ops->fsunmount_me_h)( mt_entry );
2004068: c2 00 60 3c ld [ %g1 + 0x3c ], %g1
200406c: 9f c0 40 00 call %g1
2004070: 90 10 00 1d mov %i5, %o0
2004074: 30 80 00 05 b,a 2004088 <mount+0x2e0>
} else {
errno = EINVAL;
rv = -1;
}
} else {
errno = EINVAL;
2004078: 40 00 2e 66 call 200fa10 <__errno>
200407c: 01 00 00 00 nop
2004080: 10 80 00 09 b 20040a4 <mount+0x2fc>
2004084: 82 10 20 16 mov 0x16, %g1 ! 16 <PROM_START+0x16>
(*mt_entry->ops->fsunmount_me_h)( mt_entry );
}
}
if ( rv != 0 ) {
free( mt_entry );
2004088: 7f ff fd d5 call 20037dc <free>
200408c: 90 10 00 1d mov %i5, %o0
2004090: 81 c7 e0 08 ret
2004094: 81 e8 00 00 restore
}
} else {
errno = ENOMEM;
2004098: 40 00 2e 5e call 200fa10 <__errno> <== NOT EXECUTED
200409c: 01 00 00 00 nop <== NOT EXECUTED
20040a0: 82 10 20 0c mov 0xc, %g1 ! c <PROM_START+0xc> <== NOT EXECUTED
20040a4: c2 22 00 00 st %g1, [ %o0 ]
rv = -1;
20040a8: b0 10 3f ff mov -1, %i0
errno = EINVAL;
rv = -1;
}
return rv;
}
20040ac: 81 c7 e0 08 ret
20040b0: 81 e8 00 00 restore
02008ae8 <mount_and_make_target_path>:
const char *target,
const char *filesystemtype,
rtems_filesystem_options_t options,
const void *data
)
{
2008ae8: 9d e3 bf a0 save %sp, -96, %sp
int rv = -1;
if (target != NULL) {
2008aec: 90 96 60 00 orcc %i1, 0, %o0
2008af0: 02 80 00 09 be 2008b14 <mount_and_make_target_path+0x2c>
2008af4: 01 00 00 00 nop
rv = rtems_mkdir(target, S_IRWXU | S_IRWXG | S_IRWXO);
2008af8: 40 00 02 e2 call 2009680 <rtems_mkdir>
2008afc: 92 10 21 ff mov 0x1ff, %o1 ! 1ff <PROM_START+0x1ff>
if (rv == 0) {
2008b00: 80 a2 20 00 cmp %o0, 0
2008b04: 12 80 00 09 bne 2008b28 <mount_and_make_target_path+0x40> <== NEVER TAKEN
2008b08: 01 00 00 00 nop
rv = mount(
2008b0c: 40 00 00 09 call 2008b30 <mount>
2008b10: 81 e8 00 00 restore
options,
data
);
}
} else {
errno = EINVAL;
2008b14: 40 00 60 28 call 2020bb4 <__errno>
2008b18: 01 00 00 00 nop
2008b1c: 82 10 20 16 mov 0x16, %g1 ! 16 <PROM_START+0x16>
2008b20: c2 22 00 00 st %g1, [ %o0 ]
const char *filesystemtype,
rtems_filesystem_options_t options,
const void *data
)
{
int rv = -1;
2008b24: 90 10 3f ff mov -1, %o0
} else {
errno = EINVAL;
}
return rv;
}
2008b28: 81 c7 e0 08 ret
2008b2c: 91 e8 00 08 restore %g0, %o0, %o0
02034438 <msdos_creat_node>:
msdos_node_type_t type,
const char *name,
int name_len,
mode_t mode,
const fat_file_fd_t *link_fd)
{
2034438: 9d e3 bf 00 save %sp, -256, %sp
int rc = RC_OK;
ssize_t ret = 0;
msdos_fs_info_t *fs_info = parent_loc->mt_entry->fs_info;
203443c: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
uint32_t sec = 0;
uint32_t byte = 0;
fat_dir_pos_init(&dir_pos);
memset(short_node, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
2034440: 92 10 20 00 clr %o1
mode_t mode,
const fat_file_fd_t *link_fd)
{
int rc = RC_OK;
ssize_t ret = 0;
msdos_fs_info_t *fs_info = parent_loc->mt_entry->fs_info;
2034444: f8 00 60 08 ld [ %g1 + 8 ], %i4
fat_dir_pos_t *dir_pos
)
{
dir_pos->sname.cln = 0;
dir_pos->sname.ofs = 0;
dir_pos->lname.cln = FAT_FILE_SHORT_NAME;
2034448: 82 10 3f ff mov -1, %g1
uint32_t sec = 0;
uint32_t byte = 0;
fat_dir_pos_init(&dir_pos);
memset(short_node, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
203444c: 94 10 20 20 mov 0x20, %o2
2034450: c2 27 bf 78 st %g1, [ %fp + -136 ]
dir_pos->lname.ofs = FAT_FILE_SHORT_NAME;
2034454: c2 27 bf 7c st %g1, [ %fp + -132 ]
const fat_file_fd_t *link_fd)
{
int rc = RC_OK;
ssize_t ret = 0;
msdos_fs_info_t *fs_info = parent_loc->mt_entry->fs_info;
fat_file_fd_t *parent_fat_fd = parent_loc->node_access;
2034458: e0 06 20 08 ld [ %i0 + 8 ], %l0
fat_file_fd_t *fat_fd = NULL;
203445c: c0 27 bf 6c clr [ %fp + -148 ]
time_t time_ret = 0;
uint16_t time_val = 0;
2034460: c0 37 bf 68 clrh [ %fp + -152 ]
uint16_t date = 0;
2034464: c0 37 bf 6a clrh [ %fp + -150 ]
static inline void
fat_dir_pos_init(
fat_dir_pos_t *dir_pos
)
{
dir_pos->sname.cln = 0;
2034468: c0 27 bf 70 clr [ %fp + -144 ]
dir_pos->sname.ofs = 0;
203446c: c0 27 bf 74 clr [ %fp + -140 ]
uint32_t sec = 0;
uint32_t byte = 0;
fat_dir_pos_init(&dir_pos);
memset(short_node, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
2034470: 40 00 45 2d call 2045924 <memset>
2034474: 90 07 bf 80 add %fp, -128, %o0
memset(dot_dotdot, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE * 2);
2034478: 90 07 bf c0 add %fp, -64, %o0
203447c: 92 10 20 00 clr %o1
2034480: 40 00 45 29 call 2045924 <memset>
2034484: 94 10 20 40 mov 0x40, %o2
if (name_len > MSDOS_NAME_MAX_LFN_WITH_DOT) {
2034488: 80 a6 e1 04 cmp %i3, 0x104
203448c: 24 80 00 06 ble,a 20344a4 <msdos_creat_node+0x6c> <== ALWAYS TAKEN
2034490: 90 10 00 1a mov %i2, %o0
rtems_set_errno_and_return_minus_one(ENAMETOOLONG);
2034494: 40 00 37 56 call 20421ec <__errno> <== NOT EXECUTED
2034498: 01 00 00 00 nop <== NOT EXECUTED
203449c: 10 80 00 0c b 20344cc <msdos_creat_node+0x94> <== NOT EXECUTED
20344a0: 82 10 20 5b mov 0x5b, %g1 ! 5b <PROM_START+0x5b> <== NOT EXECUTED
}
name_type = msdos_long_to_short (name, name_len,
20344a4: 92 10 00 1b mov %i3, %o1
20344a8: 94 07 bf 80 add %fp, -128, %o2
20344ac: 40 00 01 45 call 20349c0 <msdos_long_to_short>
20344b0: 96 10 20 0b mov 0xb, %o3
MSDOS_DIR_NAME(short_node),
MSDOS_NAME_MAX);
if (name_type == MSDOS_NAME_INVALID) {
20344b4: a4 92 20 00 orcc %o0, 0, %l2
20344b8: 32 80 00 08 bne,a 20344d8 <msdos_creat_node+0xa0> <== ALWAYS TAKEN
20344bc: c0 2f bf 8c clrb [ %fp + -116 ]
rtems_set_errno_and_return_minus_one(EINVAL);
20344c0: 40 00 37 4b call 20421ec <__errno> <== NOT EXECUTED
20344c4: 01 00 00 00 nop <== NOT EXECUTED
20344c8: 82 10 20 16 mov 0x16, %g1 ! 16 <PROM_START+0x16> <== NOT EXECUTED
20344cc: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
20344d0: 10 80 00 ce b 2034808 <msdos_creat_node+0x3d0> <== NOT EXECUTED
20344d4: ba 10 3f ff mov -1, %i5 <== NOT EXECUTED
/* fill reserved field */
*MSDOS_DIR_NT_RES(short_node) = MSDOS_RES_NT_VALUE;
/* set up last write date and time */
time_ret = time(NULL);
20344d8: 40 00 69 b3 call 204eba4 <time>
20344dc: 90 10 20 00 clr %o0
if ( time_ret == -1 )
20344e0: 80 a2 3f ff cmp %o0, -1
20344e4: 12 80 00 04 bne 20344f4 <msdos_creat_node+0xbc> <== ALWAYS TAKEN
20344e8: 92 07 bf 6a add %fp, -150, %o1
20344ec: 10 80 00 c7 b 2034808 <msdos_creat_node+0x3d0> <== NOT EXECUTED
20344f0: ba 10 3f ff mov -1, %i5 <== NOT EXECUTED
return -1;
msdos_date_unix2dos(time_ret, &date, &time_val);
20344f4: 40 00 30 01 call 20404f8 <msdos_date_unix2dos>
20344f8: 94 07 bf 68 add %fp, -152, %o2
*MSDOS_DIR_CRT_TIME(short_node) = CT_LE_W(time_val);
20344fc: c2 17 bf 68 lduh [ %fp + -152 ], %g1
*MSDOS_DIR_CRT_DATE(short_node) = CT_LE_W(date);
2034500: c6 17 bf 6a lduh [ %fp + -150 ], %g3
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);
2034504: 83 28 60 10 sll %g1, 0x10, %g1
2034508: 85 30 60 08 srl %g1, 8, %g2
203450c: 83 30 60 18 srl %g1, 0x18, %g1
*MSDOS_DIR_CRT_DATE(short_node) = CT_LE_W(date);
2034510: 87 28 e0 10 sll %g3, 0x10, %g3
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);
2034514: 84 10 80 01 or %g2, %g1, %g2
*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;
2034518: c0 27 bf 9c clr [ %fp + -100 ]
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);
203451c: 83 30 e0 08 srl %g3, 8, %g1
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);
2034520: c4 37 bf 8e sth %g2, [ %fp + -114 ]
*MSDOS_DIR_CRT_DATE(short_node) = CT_LE_W(date);
2034524: 87 30 e0 18 srl %g3, 0x18, %g3
*MSDOS_DIR_WRITE_TIME(short_node) = CT_LE_W(time_val);
2034528: c4 37 bf 96 sth %g2, [ %fp + -106 ]
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);
203452c: 82 10 40 03 or %g1, %g3, %g1
2034530: c2 37 bf 90 sth %g1, [ %fp + -112 ]
*MSDOS_DIR_WRITE_TIME(short_node) = CT_LE_W(time_val);
*MSDOS_DIR_WRITE_DATE(short_node) = CT_LE_W(date);
2034534: c2 37 bf 98 sth %g1, [ %fp + -104 ]
*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) {
2034538: 80 a6 60 00 cmp %i1, 0
203453c: 12 80 00 05 bne 2034550 <msdos_creat_node+0x118>
2034540: c2 37 bf 92 sth %g1, [ %fp + -110 ]
*MSDOS_DIR_ATTR(short_node) |= MSDOS_ATTR_DIRECTORY;
2034544: c2 0f bf 8b ldub [ %fp + -117 ], %g1
2034548: 10 80 00 2f b 2034604 <msdos_creat_node+0x1cc>
203454c: 82 10 60 10 or %g1, 0x10, %g1
}
else if (type == MSDOS_HARD_LINK) {
2034550: 80 a6 60 02 cmp %i1, 2
2034554: 12 80 00 2b bne 2034600 <msdos_creat_node+0x1c8> <== ALWAYS TAKEN
2034558: c2 0f bf 8b ldub [ %fp + -117 ], %g1
* node to the newly created
*/
/*
* read the original directory entry
*/
sec = fat_cluster_num_to_sector_num(&fs_info->fat,
203455c: c4 07 60 20 ld [ %i5 + 0x20 ], %g2 <== NOT EXECUTED
fat_cluster_num_to_sector_num(
const fat_fs_info_t *fs_info,
uint32_t cln
)
{
if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
2034560: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED
2034564: 32 80 00 08 bne,a 2034584 <msdos_creat_node+0x14c> <== NOT EXECUTED
2034568: c2 0f 20 05 ldub [ %i4 + 5 ], %g1 <== NOT EXECUTED
203456c: c2 0f 20 0a ldub [ %i4 + 0xa ], %g1 <== NOT EXECUTED
2034570: 80 88 60 03 btst 3, %g1 <== NOT EXECUTED
2034574: 22 80 00 04 be,a 2034584 <msdos_creat_node+0x14c> <== NOT EXECUTED
2034578: c2 0f 20 05 ldub [ %i4 + 5 ], %g1 <== NOT EXECUTED
return fs_info->vol.rdir_loc;
203457c: 10 80 00 06 b 2034594 <msdos_creat_node+0x15c> <== NOT EXECUTED
2034580: c4 07 20 1c ld [ %i4 + 0x1c ], %g2 <== NOT EXECUTED
return (((cln - FAT_RSRVD_CLN) << fs_info->vol.spc_log2) +
2034584: 84 00 bf fe add %g2, -2, %g2 <== NOT EXECUTED
2034588: 85 28 80 01 sll %g2, %g1, %g2 <== NOT EXECUTED
203458c: c2 07 20 30 ld [ %i4 + 0x30 ], %g1 <== NOT EXECUTED
2034590: 84 00 80 01 add %g2, %g1, %g2 <== NOT EXECUTED
link_fd->dir_pos.sname.cln);
sec += (link_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);
2034594: c2 07 60 24 ld [ %i5 + 0x24 ], %g1 <== NOT EXECUTED
2034598: d2 0f 20 02 ldub [ %i4 + 2 ], %o1 <== NOT EXECUTED
byte = (link_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1));
203459c: d4 17 00 00 lduh [ %i4 ], %o2 <== NOT EXECUTED
/*
* read the original directory entry
*/
sec = fat_cluster_num_to_sector_num(&fs_info->fat,
link_fd->dir_pos.sname.cln);
sec += (link_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);
20345a0: 93 30 40 09 srl %g1, %o1, %o1 <== NOT EXECUTED
byte = (link_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1));
20345a4: 94 02 bf ff add %o2, -1, %o2 <== NOT EXECUTED
ret = _fat_block_read(&fs_info->fat,
20345a8: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
20345ac: 92 00 80 09 add %g2, %o1, %o1 <== NOT EXECUTED
20345b0: 94 0a 80 01 and %o2, %g1, %o2 <== NOT EXECUTED
20345b4: 96 10 20 20 mov 0x20, %o3 <== NOT EXECUTED
20345b8: 7f ff c7 a6 call 2026450 <_fat_block_read> <== NOT EXECUTED
20345bc: 98 07 bf a0 add %fp, -96, %o4 <== NOT EXECUTED
sec, byte, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE,
link_node);
if (ret < 0) {
20345c0: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
20345c4: 06 bf ff c3 bl 20344d0 <msdos_creat_node+0x98> <== NOT EXECUTED
20345c8: c2 0f bf ad ldub [ %fp + -83 ], %g1 <== 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);
20345cc: c2 2f bf 8d stb %g1, [ %fp + -115 ] <== NOT EXECUTED
*MSDOS_DIR_CRT_TIME(short_node) =*MSDOS_DIR_CRT_TIME(link_node);
20345d0: c2 17 bf ae lduh [ %fp + -82 ], %g1 <== NOT EXECUTED
20345d4: c2 37 bf 8e sth %g1, [ %fp + -114 ] <== NOT EXECUTED
*MSDOS_DIR_CRT_DATE(short_node) =*MSDOS_DIR_CRT_DATE(link_node);
20345d8: c2 17 bf b0 lduh [ %fp + -80 ], %g1 <== NOT EXECUTED
20345dc: c2 37 bf 90 sth %g1, [ %fp + -112 ] <== NOT EXECUTED
/*
* copy/set "file size", "first cluster"
*/
*MSDOS_DIR_FILE_SIZE(short_node) =*MSDOS_DIR_FILE_SIZE(link_node);
20345e0: c2 07 bf bc ld [ %fp + -68 ], %g1 <== NOT EXECUTED
20345e4: c2 27 bf 9c st %g1, [ %fp + -100 ] <== NOT EXECUTED
*MSDOS_DIR_FIRST_CLUSTER_LOW(short_node) =
20345e8: c2 17 bf ba lduh [ %fp + -70 ], %g1 <== NOT EXECUTED
20345ec: c2 37 bf 9a sth %g1, [ %fp + -102 ] <== NOT EXECUTED
*MSDOS_DIR_FIRST_CLUSTER_LOW(link_node);
*MSDOS_DIR_FIRST_CLUSTER_HI(short_node) =
20345f0: c2 17 bf b4 lduh [ %fp + -76 ], %g1 <== NOT EXECUTED
20345f4: c2 37 bf 94 sth %g1, [ %fp + -108 ] <== NOT EXECUTED
*MSDOS_DIR_FIRST_CLUSTER_HI(link_node);
/*
* set "archive bit" due to changes
*/
*MSDOS_DIR_ATTR(short_node) |= MSDOS_ATTR_ARCHIVE;
20345f8: 10 80 00 02 b 2034600 <msdos_creat_node+0x1c8> <== NOT EXECUTED
20345fc: c2 0f bf ab ldub [ %fp + -85 ], %g1 <== NOT EXECUTED
}
else { /* regular file... */
*MSDOS_DIR_ATTR(short_node) |= MSDOS_ATTR_ARCHIVE;
2034600: 82 10 60 20 or %g1, 0x20, %g1
2034604: c2 2f bf 8b stb %g1, [ %fp + -117 ]
/*
* 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);
2034608: a2 07 bf 80 add %fp, -128, %l1
/*
* 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,
203460c: 90 10 00 18 mov %i0, %o0
2034610: e2 23 a0 5c st %l1, [ %sp + 0x5c ]
2034614: 92 10 20 01 mov 1, %o1
2034618: 94 10 00 1a mov %i2, %o2
203461c: 96 10 00 1b mov %i3, %o3
2034620: 98 10 00 12 mov %l2, %o4
2034624: 40 00 05 fc call 2035e14 <msdos_get_name_node>
2034628: 9a 07 bf 70 add %fp, -144, %o5
name_type, &dir_pos, short_node);
if ( rc != RC_OK )
203462c: ba 92 20 00 orcc %o0, 0, %i5
2034630: 12 80 00 76 bne 2034808 <msdos_creat_node+0x3d0> <== NEVER TAKEN
2034634: 80 a6 60 00 cmp %i1, 0
/*
* if we create a new file we are done, if directory there are more steps
* to do
*/
if (type == MSDOS_DIRECTORY)
2034638: 32 80 00 75 bne,a 203480c <msdos_creat_node+0x3d4>
203463c: b0 10 00 1d mov %i5, %i0
{
/* open new directory as fat-file */
rc = fat_file_open(&fs_info->fat, &dir_pos, &fat_fd);
2034640: 90 10 00 1c mov %i4, %o0
2034644: 92 07 bf 70 add %fp, -144, %o1
2034648: 7f ff c3 cf call 2025584 <fat_file_open>
203464c: 94 07 bf 6c add %fp, -148, %o2
if (rc != RC_OK)
2034650: ba 92 20 00 orcc %o0, 0, %i5
2034654: 32 80 00 6a bne,a 20347fc <msdos_creat_node+0x3c4> <== NEVER TAKEN
2034658: d0 06 20 14 ld [ %i0 + 0x14 ], %o0 <== NOT EXECUTED
/*
* we opened fat-file for node we just created, so initialize fat-file
* descritor
*/
fat_fd->fat_file_size = 0;
203465c: fa 07 bf 6c ld [ %fp + -148 ], %i5
fat_fd->fat_file_type = FAT_DIRECTORY;
fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
2034660: 03 00 08 00 sethi %hi(0x200000), %g1
/*
* dot and dotdot entries are identical to new node except the
* names
*/
memcpy(DOT_NODE_P(dot_dotdot), short_node,
2034664: 92 10 00 11 mov %l1, %o1
* 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;
2034668: c2 27 60 14 st %g1, [ %i5 + 0x14 ]
/*
* dot and dotdot entries are identical to new node except the
* names
*/
memcpy(DOT_NODE_P(dot_dotdot), short_node,
203466c: 94 10 20 20 mov 0x20, %o2
/*
* we opened fat-file for node we just created, so initialize fat-file
* descritor
*/
fat_fd->fat_file_size = 0;
2034670: c0 27 60 18 clr [ %i5 + 0x18 ]
fat_fd->fat_file_type = FAT_DIRECTORY;
2034674: c0 27 60 10 clr [ %i5 + 0x10 ]
/*
* dot and dotdot entries are identical to new node except the
* names
*/
memcpy(DOT_NODE_P(dot_dotdot), short_node,
2034678: 40 00 44 1c call 20456e8 <memcpy>
203467c: 90 07 bf c0 add %fp, -64, %o0
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
memcpy(DOTDOT_NODE_P(dot_dotdot), short_node,
2034680: 92 10 00 11 mov %l1, %o1
2034684: 94 10 20 20 mov 0x20, %o2
2034688: 40 00 44 18 call 20456e8 <memcpy>
203468c: 90 07 bf e0 add %fp, -32, %o0
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
memcpy(MSDOS_DIR_NAME(DOT_NODE_P(dot_dotdot)), MSDOS_DOT_NAME,
2034690: 03 00 81 9c sethi %hi(0x2067000), %g1
2034694: d2 00 60 b4 ld [ %g1 + 0xb4 ], %o1 ! 20670b4 <MSDOS_DOT_NAME>
2034698: 94 10 20 0b mov 0xb, %o2
203469c: 40 00 44 13 call 20456e8 <memcpy>
20346a0: 90 07 bf c0 add %fp, -64, %o0
MSDOS_NAME_MAX);
memcpy(MSDOS_DIR_NAME(DOTDOT_NODE_P(dot_dotdot)), MSDOS_DOTDOT_NAME,
20346a4: 03 00 81 9c sethi %hi(0x2067000), %g1
20346a8: d2 00 60 b0 ld [ %g1 + 0xb0 ], %o1 ! 20670b0 <MSDOS_DOTDOT_NAME>
20346ac: 90 07 bf e0 add %fp, -32, %o0
20346b0: 40 00 44 0e call 20456e8 <memcpy>
20346b4: 94 10 20 0b mov 0xb, %o2
/*
* 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)) &&
20346b8: c2 04 20 20 ld [ %l0 + 0x20 ], %g1
20346bc: 80 a0 60 01 cmp %g1, 1
20346c0: 32 80 00 0e bne,a 20346f8 <msdos_creat_node+0x2c0>
20346c4: c2 04 20 1c ld [ %l0 + 0x1c ], %g1
20346c8: c2 04 20 24 ld [ %l0 + 0x24 ], %g1
20346cc: 80 a0 60 00 cmp %g1, 0
20346d0: 32 80 00 0a bne,a 20346f8 <msdos_creat_node+0x2c0> <== NEVER TAKEN
20346d4: c2 04 20 1c ld [ %l0 + 0x1c ], %g1 <== NOT EXECUTED
(fs_info->fat.vol.type & FAT_FAT32))
20346d8: c2 0f 20 0a ldub [ %i4 + 0xa ], %g1
/*
* 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)) &&
20346dc: 82 08 60 04 and %g1, 4, %g1
20346e0: 80 88 60 ff btst 0xff, %g1
20346e4: 22 80 00 05 be,a 20346f8 <msdos_creat_node+0x2c0> <== ALWAYS TAKEN
20346e8: c2 04 20 1c ld [ %l0 + 0x1c ], %g1
(fs_info->fat.vol.type & FAT_FAT32))
{
*MSDOS_DIR_FIRST_CLUSTER_LOW(DOTDOT_NODE_P(dot_dotdot)) = 0x0000;
20346ec: c0 37 bf fa clrh [ %fp + -6 ] <== NOT EXECUTED
*MSDOS_DIR_FIRST_CLUSTER_HI(DOTDOT_NODE_P(dot_dotdot)) = 0x0000;
20346f0: 10 80 00 10 b 2034730 <msdos_creat_node+0x2f8> <== NOT EXECUTED
20346f4: c0 37 bf f4 clrh [ %fp + -12 ] <== 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;
}
20346f8: 05 00 00 3f sethi %hi(0xfc00), %g2
*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)) =
20346fc: 87 28 60 10 sll %g1, 0x10, %g3
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;
}
2034700: 84 10 a3 ff or %g2, 0x3ff, %g2
*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)) =
2034704: 87 30 e0 18 srl %g3, 0x18, %g3
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;
}
2034708: 88 08 40 02 and %g1, %g2, %g4
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)) =
CT_LE_W((uint16_t )(((parent_fat_fd->cln) & 0xFFFF0000)>>16));
203470c: 83 30 60 10 srl %g1, 0x10, %g1
*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));
2034710: 89 29 20 08 sll %g4, 8, %g4
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;
}
2034714: 84 08 40 02 and %g1, %g2, %g2
*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)) =
2034718: 86 11 00 03 or %g4, %g3, %g3
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));
203471c: 85 28 a0 08 sll %g2, 8, %g2
}
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)) =
2034720: 83 30 60 08 srl %g1, 8, %g1
*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)) =
2034724: c6 37 bf fa sth %g3, [ %fp + -6 ]
CT_LE_W((uint16_t )((parent_fat_fd->cln) & 0x0000FFFF));
*MSDOS_DIR_FIRST_CLUSTER_HI(DOTDOT_NODE_P(dot_dotdot)) =
2034728: 82 10 80 01 or %g2, %g1, %g1
203472c: c2 37 bf f4 sth %g1, [ %fp + -12 ]
/*
* 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(&fs_info->fat, fat_fd, 0,
2034730: 90 10 00 1c mov %i4, %o0
2034734: 92 10 00 1d mov %i5, %o1
2034738: 94 10 20 00 clr %o2
203473c: 96 10 20 40 mov 0x40, %o3
2034740: 7f ff c5 a3 call 2025dcc <fat_file_write>
2034744: 98 07 bf c0 add %fp, -64, %o4
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE * 2,
(uint8_t *)dot_dotdot);
if (ret < 0)
2034748: 80 a2 20 00 cmp %o0, 0
203474c: 06 80 00 27 bl 20347e8 <msdos_creat_node+0x3b0> <== NEVER TAKEN
2034750: d2 07 bf 6c ld [ %fp + -148 ], %o1
rc = -1;
goto error;
}
/* increment fat-file size by cluster size */
fat_fd->fat_file_size += fs_info->fat.vol.bpc;
2034754: c2 17 20 06 lduh [ %i4 + 6 ], %g1
2034758: c4 02 60 18 ld [ %o1 + 0x18 ], %g2
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(&fs_info->fat, fat_fd, 0,
203475c: 90 10 00 1c mov %i4, %o0
rc = -1;
goto error;
}
/* increment fat-file size by cluster size */
fat_fd->fat_file_size += fs_info->fat.vol.bpc;
2034760: 82 00 80 01 add %g2, %g1, %g1
2034764: c2 22 60 18 st %g1, [ %o1 + 0x18 ]
/* 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));
2034768: c2 02 60 1c ld [ %o1 + 0x1c ], %g1
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;
}
203476c: 05 00 00 3f sethi %hi(0xfc00), %g2
/* 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)) =
2034770: 87 28 60 10 sll %g1, 0x10, %g3
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;
}
2034774: 84 10 a3 ff or %g2, 0x3ff, %g2
/* 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)) =
2034778: 87 30 e0 18 srl %g3, 0x18, %g3
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;
}
203477c: 88 08 40 02 and %g1, %g2, %g4
/* set up cluster num for dot entry */
*MSDOS_DIR_FIRST_CLUSTER_LOW(DOT_NODE_P(dot_dotdot)) =
CT_LE_W((uint16_t )((fat_fd->cln) & 0x0000FFFF));
*MSDOS_DIR_FIRST_CLUSTER_HI(DOT_NODE_P(dot_dotdot)) =
CT_LE_W((uint16_t )(((fat_fd->cln) & 0xFFFF0000) >> 16));
2034780: 83 30 60 10 srl %g1, 0x10, %g1
/* increment fat-file size by cluster size */
fat_fd->fat_file_size += fs_info->fat.vol.bpc;
/* set up cluster num for dot entry */
*MSDOS_DIR_FIRST_CLUSTER_LOW(DOT_NODE_P(dot_dotdot)) =
CT_LE_W((uint16_t )((fat_fd->cln) & 0x0000FFFF));
2034784: 89 29 20 08 sll %g4, 8, %g4
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;
}
2034788: 84 08 40 02 and %g1, %g2, %g2
/* 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)) =
203478c: 86 11 00 03 or %g4, %g3, %g3
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));
2034790: 85 28 a0 08 sll %g2, 8, %g2
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)) =
2034794: 83 30 60 08 srl %g1, 8, %g1
2034798: 82 10 80 01 or %g2, %g1, %g1
/* 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)) =
203479c: c6 37 bf da sth %g3, [ %fp + -38 ]
CT_LE_W((uint16_t )((fat_fd->cln) & 0x0000FFFF));
*MSDOS_DIR_FIRST_CLUSTER_HI(DOT_NODE_P(dot_dotdot)) =
20347a0: c2 37 bf d4 sth %g1, [ %fp + -44 ]
CT_LE_W((uint16_t )(((fat_fd->cln) & 0xFFFF0000) >> 16));
/* rewrite dot entry */
ret = fat_file_write(&fs_info->fat, fat_fd, 0,
20347a4: 94 10 20 00 clr %o2
20347a8: 96 10 20 20 mov 0x20, %o3
20347ac: 7f ff c5 88 call 2025dcc <fat_file_write>
20347b0: 98 07 bf c0 add %fp, -64, %o4
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE,
(uint8_t *)DOT_NODE_P(dot_dotdot));
if (ret < 0)
20347b4: 80 a2 20 00 cmp %o0, 0
20347b8: 06 80 00 0d bl 20347ec <msdos_creat_node+0x3b4> <== NEVER TAKEN
20347bc: ba 10 3f ff mov -1, %i5
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);
20347c0: d0 06 20 14 ld [ %i0 + 0x14 ], %o0
20347c4: 40 00 01 45 call 2034cd8 <msdos_set_first_cluster_num>
20347c8: d2 07 bf 6c ld [ %fp + -148 ], %o1
if (rc != RC_OK)
20347cc: ba 92 20 00 orcc %o0, 0, %i5
20347d0: 12 80 00 08 bne 20347f0 <msdos_creat_node+0x3b8> <== NEVER TAKEN
20347d4: d2 07 bf 6c ld [ %fp + -148 ], %o1
goto error;
fat_file_close(&fs_info->fat, fat_fd);
20347d8: 7f ff c4 81 call 20259dc <fat_file_close>
20347dc: 90 10 00 1c mov %i4, %o0
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;
}
20347e0: 81 c7 e0 08 ret
20347e4: 91 e8 00 1d restore %g0, %i5, %o0
ret = fat_file_write(&fs_info->fat, fat_fd, 0,
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE * 2,
(uint8_t *)dot_dotdot);
if (ret < 0)
{
rc = -1;
20347e8: ba 10 3f ff mov -1, %i5 <== NOT EXECUTED
fat_file_close(&fs_info->fat, fat_fd);
}
return RC_OK;
error:
fat_file_close(&fs_info->fat, fat_fd);
20347ec: d2 07 bf 6c ld [ %fp + -148 ], %o1 <== NOT EXECUTED
20347f0: 7f ff c4 7b call 20259dc <fat_file_close> <== NOT EXECUTED
20347f4: 90 10 00 1c mov %i4, %o0 <== 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);
20347f8: d0 06 20 14 ld [ %i0 + 0x14 ], %o0 <== NOT EXECUTED
20347fc: 92 07 bf 70 add %fp, -144, %o1 <== NOT EXECUTED
2034800: 40 00 01 81 call 2034e04 <msdos_set_first_char4file_name> <== NOT EXECUTED
2034804: 94 10 20 e5 mov 0xe5, %o2 <== NOT EXECUTED
return rc;
}
2034808: b0 10 00 1d mov %i5, %i0 <== NOT EXECUTED
203480c: 81 c7 e0 08 ret
2034810: 81 e8 00 00 restore
02040644 <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;
2040644: 85 32 60 0b srl %o1, 0xb, %g2
2040648: 84 08 a0 1f and %g2, 0x1f, %g2
204064c: 87 28 a0 03 sll %g2, 3, %g3
2040650: 83 28 a0 07 sll %g2, 7, %g1
2040654: 82 20 40 03 sub %g1, %g3, %g1
2040658: 85 28 60 04 sll %g1, 4, %g2
204065c: 84 20 80 01 sub %g2, %g1, %g2
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
2040660: 82 0a 67 e0 and %o1, 0x7e0, %g1
2040664: 87 30 60 04 srl %g1, 4, %g3
2040668: 82 20 40 03 sub %g1, %g3, %g1
+ ((dt & MSDOS_DT_HOURS_MASK) >> MSDOS_DT_HOURS_SHIFT) * 3600;
204066c: 82 00 80 01 add %g2, %g1, %g1
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)
2040670: 92 0a 60 1f and %o1, 0x1f, %o1
+ ((dt & MSDOS_DT_MINUTES_MASK) >> MSDOS_DT_MINUTES_SHIFT) * 60
+ ((dt & MSDOS_DT_HOURS_MASK) >> MSDOS_DT_HOURS_SHIFT) * 3600;
2040674: 92 00 40 09 add %g1, %o1, %o1
/*
* If the year, month, and day from the last conversion are the
* same then use the saved value.
*/
if (lastdosdate != dd) {
2040678: 03 00 81 bc sethi %hi(0x206f000), %g1
204067c: c4 10 61 f2 lduh [ %g1 + 0x1f2 ], %g2 ! 206f1f2 <lastdosdate>
2040680: 80 a0 80 08 cmp %g2, %o0
2040684: 02 80 00 34 be 2040754 <msdos_date_dos2unix+0x110>
2040688: 93 2a 60 01 sll %o1, 1, %o1
lastdosdate = dd;
204068c: d0 30 61 f2 sth %o0, [ %g1 + 0x1f2 ]
days = 0;
year = (dd & MSDOS_DD_YEAR_MASK) >> MSDOS_DD_YEAR_SHIFT;
2040690: 89 32 20 09 srl %o0, 9, %g4
* 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;
2040694: 82 10 20 00 clr %g1
year = (dd & MSDOS_DD_YEAR_MASK) >> MSDOS_DD_YEAR_SHIFT;
2040698: 88 09 20 7f and %g4, 0x7f, %g4
for (y = 0; y < year; y++)
204069c: 10 80 00 07 b 20406b8 <msdos_date_dos2unix+0x74>
20406a0: 84 10 20 00 clr %g2
days += y & 0x03 ? 365 : 366;
20406a4: 80 a0 00 03 cmp %g0, %g3
*/
if (lastdosdate != dd) {
lastdosdate = dd;
days = 0;
year = (dd & MSDOS_DD_YEAR_MASK) >> MSDOS_DD_YEAR_SHIFT;
for (y = 0; y < year; y++)
20406a8: 84 00 a0 01 inc %g2
days += y & 0x03 ? 365 : 366;
20406ac: 86 60 3f ff subx %g0, -1, %g3
20406b0: 86 00 e1 6d add %g3, 0x16d, %g3
20406b4: 82 00 40 03 add %g1, %g3, %g1
*/
if (lastdosdate != dd) {
lastdosdate = dd;
days = 0;
year = (dd & MSDOS_DD_YEAR_MASK) >> MSDOS_DD_YEAR_SHIFT;
for (y = 0; y < year; y++)
20406b8: 80 a0 80 04 cmp %g2, %g4
20406bc: 12 bf ff fa bne 20406a4 <msdos_date_dos2unix+0x60>
20406c0: 86 08 a0 03 and %g2, 3, %g3
days += y & 0x03 ? 365 : 366;
months = year & 0x03 ? regyear : leapyear;
20406c4: 80 a0 e0 00 cmp %g3, 0
20406c8: 22 80 00 05 be,a 20406dc <msdos_date_dos2unix+0x98> <== ALWAYS TAKEN
20406cc: 09 00 81 af sethi %hi(0x206bc00), %g4
20406d0: 09 00 81 af sethi %hi(0x206bc00), %g4 <== NOT EXECUTED
20406d4: 10 80 00 03 b 20406e0 <msdos_date_dos2unix+0x9c> <== NOT EXECUTED
20406d8: 88 11 21 a0 or %g4, 0x1a0, %g4 ! 206bda0 <regyear> <== NOT EXECUTED
20406dc: 88 11 21 b8 or %g4, 0x1b8, %g4
/*
* Prevent going from 0 to 0xffffffff in the following
* loop.
*/
month = (dd & MSDOS_DD_MONTH_MASK) >> MSDOS_DD_MONTH_SHIFT;
20406e0: 86 0a 21 e0 and %o0, 0x1e0, %g3
20406e4: 87 30 e0 05 srl %g3, 5, %g3
if (month == 0) {
20406e8: 80 a0 e0 00 cmp %g3, 0
20406ec: 22 80 00 02 be,a 20406f4 <msdos_date_dos2unix+0xb0> <== NEVER TAKEN
20406f0: 86 10 20 01 mov 1, %g3 <== NOT EXECUTED
month = 1;
}
for (m = 0; m < month - 1; m++)
20406f4: 84 10 20 00 clr %g2
20406f8: 10 80 00 05 b 204070c <msdos_date_dos2unix+0xc8>
20406fc: 86 00 ff ff add %g3, -1, %g3
days += months[m];
2040700: da 11 00 0d lduh [ %g4 + %o5 ], %o5 <== NOT EXECUTED
*/
month = (dd & MSDOS_DD_MONTH_MASK) >> MSDOS_DD_MONTH_SHIFT;
if (month == 0) {
month = 1;
}
for (m = 0; m < month - 1; m++)
2040704: 84 00 a0 01 inc %g2 <== NOT EXECUTED
days += months[m];
2040708: 82 00 40 0d add %g1, %o5, %g1 <== NOT EXECUTED
*/
month = (dd & MSDOS_DD_MONTH_MASK) >> MSDOS_DD_MONTH_SHIFT;
if (month == 0) {
month = 1;
}
for (m = 0; m < month - 1; m++)
204070c: 80 a0 80 03 cmp %g2, %g3
2040710: 0a bf ff fc bcs 2040700 <msdos_date_dos2unix+0xbc> <== NEVER TAKEN
2040714: 9b 28 a0 01 sll %g2, 1, %o5
days += months[m];
days += ((dd & MSDOS_DD_DAY_MASK) >> MSDOS_DD_DAY_SHIFT) - 1;
2040718: 90 0a 20 1f and %o0, 0x1f, %o0
204071c: 90 02 3f ff add %o0, -1, %o0
2040720: 82 02 00 01 add %o0, %g1, %g1
lastseconds = (days + DAYSTO1980) * SECONDSPERDAY;
2040724: 85 28 60 07 sll %g1, 7, %g2
2040728: 83 28 60 09 sll %g1, 9, %g1
204072c: 82 20 40 02 sub %g1, %g2, %g1
2040730: 85 28 60 04 sll %g1, 4, %g2
2040734: 82 20 80 01 sub %g2, %g1, %g1
2040738: 85 28 60 04 sll %g1, 4, %g2
204073c: 82 20 80 01 sub %g2, %g1, %g1
2040740: 05 04 b3 a9 sethi %hi(0x12cea400), %g2
2040744: 84 10 a2 00 or %g2, 0x200, %g2 ! 12cea600 <RAM_END+0x108ea600>
2040748: 82 00 40 02 add %g1, %g2, %g1
204074c: 05 00 81 bc sethi %hi(0x206f000), %g2
2040750: c2 20 a1 f4 st %g1, [ %g2 + 0x1f4 ] ! 206f1f4 <lastseconds>
}
return seconds + lastseconds;
2040754: 03 00 81 bc sethi %hi(0x206f000), %g1
2040758: d0 00 61 f4 ld [ %g1 + 0x1f4 ], %o0 ! 206f1f4 <lastseconds>
}
204075c: 81 c3 e0 08 retl
2040760: 90 02 40 08 add %o1, %o0, %o0
020404f8 <msdos_date_unix2dos>:
* file timestamps. The passed in unix time is assumed to be in GMT.
*/
void
msdos_date_unix2dos(unsigned int t, uint16_t *ddp,
uint16_t *dtp)
{
20404f8: 9d e3 bf a0 save %sp, -96, %sp
/*
* If the time from the last conversion is the same as now, then
* skip the computations and use the saved result.
*/
if (lasttime != t) {
20404fc: 03 00 81 bc sethi %hi(0x206f000), %g1
2040500: c4 00 61 e4 ld [ %g1 + 0x1e4 ], %g2 ! 206f1e4 <lasttime>
2040504: 80 a0 80 18 cmp %g2, %i0
2040508: 02 80 00 47 be 2040624 <msdos_date_unix2dos+0x12c>
204050c: 92 10 20 3c mov 0x3c, %o1
lasttime = t;
2040510: f0 20 61 e4 st %i0, [ %g1 + 0x1e4 ]
lastdtime = (((t % 60) >> 1) << MSDOS_DT_2SECONDS_SHIFT)
+ (((t / 60) % 60) << MSDOS_DT_MINUTES_SHIFT)
2040514: 40 00 6c 1b call 205b580 <.udiv>
2040518: 90 10 00 18 mov %i0, %o0
204051c: 40 00 6c c5 call 205b830 <.urem>
2040520: 92 10 20 3c mov 0x3c, %o1
+ (((t / 3600) % 24) << MSDOS_DT_HOURS_SHIFT);
2040524: 92 10 2e 10 mov 0xe10, %o1
* 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)
2040528: bb 2a 20 05 sll %o0, 5, %i5
+ (((t / 60) % 60) << MSDOS_DT_MINUTES_SHIFT)
+ (((t / 3600) % 24) << MSDOS_DT_HOURS_SHIFT);
204052c: 40 00 6c 15 call 205b580 <.udiv>
2040530: 90 10 00 18 mov %i0, %o0
2040534: 40 00 6c bf call 205b830 <.urem>
2040538: 92 10 20 18 mov 0x18, %o1
* 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)
204053c: 91 2a 20 0b sll %o0, 0xb, %o0
2040540: 92 10 20 3c mov 0x3c, %o1
2040544: ba 07 40 08 add %i5, %o0, %i5
2040548: 40 00 6c ba call 205b830 <.urem>
204054c: 90 10 00 18 mov %i0, %o0
2040550: 03 00 81 bc sethi %hi(0x206f000), %g1
2040554: 91 32 20 01 srl %o0, 1, %o0
/*
* 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);
2040558: 13 00 00 54 sethi %hi(0x15000), %o1
* 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)
204055c: ba 07 40 08 add %i5, %o0, %i5
/*
* 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);
2040560: 92 12 61 80 or %o1, 0x180, %o1
* 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)
2040564: fa 30 61 e8 sth %i5, [ %g1 + 0x1e8 ]
/*
* 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);
2040568: 40 00 6c 06 call 205b580 <.udiv>
204056c: 90 10 00 18 mov %i0, %o0
if (days != lastday) {
2040570: 03 00 81 bc sethi %hi(0x206f000), %g1
2040574: c4 00 61 ec ld [ %g1 + 0x1ec ], %g2 ! 206f1ec <lastday>
2040578: 80 a2 00 02 cmp %o0, %g2
204057c: 22 80 00 2b be,a 2040628 <msdos_date_unix2dos+0x130>
2040580: 03 00 81 bc sethi %hi(0x206f000), %g1
lastday = days;
2040584: d0 20 61 ec st %o0, [ %g1 + 0x1ec ] ! 206f1ec <lastday>
for (year = 1970;; year++) {
2040588: 82 10 27 b2 mov 0x7b2, %g1
inc = year & 0x03 ? 365 : 366;
204058c: 84 08 60 03 and %g1, 3, %g2
2040590: 80 a0 00 02 cmp %g0, %g2
2040594: 86 60 3f ff subx %g0, -1, %g3
2040598: 86 00 e1 6d add %g3, 0x16d, %g3
if (days < inc)
204059c: 80 a2 00 03 cmp %o0, %g3
20405a0: 0a 80 00 05 bcs 20405b4 <msdos_date_unix2dos+0xbc>
20405a4: 80 a0 a0 00 cmp %g2, 0
break;
days -= inc;
20405a8: 90 22 00 03 sub %o0, %g3, %o0
}
20405ac: 10 bf ff f8 b 204058c <msdos_date_unix2dos+0x94>
20405b0: 82 00 60 01 inc %g1
months = year & 0x03 ? regyear : leapyear;
20405b4: 22 80 00 05 be,a 20405c8 <msdos_date_unix2dos+0xd0> <== ALWAYS TAKEN
20405b8: 09 00 81 af sethi %hi(0x206bc00), %g4
20405bc: 09 00 81 af sethi %hi(0x206bc00), %g4 <== NOT EXECUTED
20405c0: 10 80 00 03 b 20405cc <msdos_date_unix2dos+0xd4> <== NOT EXECUTED
20405c4: 88 11 21 a0 or %g4, 0x1a0, %g4 ! 206bda0 <regyear> <== NOT EXECUTED
20405c8: 88 11 21 b8 or %g4, 0x1b8, %g4
for (month = 0; month < 12; month++) {
20405cc: 84 10 20 00 clr %g2
/*
* 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,
20405d0: 87 28 a0 01 sll %g2, 1, %g3
break;
days -= inc;
}
months = year & 0x03 ? regyear : leapyear;
for (month = 0; month < 12; month++) {
if (days < months[month])
20405d4: c6 11 00 03 lduh [ %g4 + %g3 ], %g3
20405d8: 80 a2 00 03 cmp %o0, %g3
20405dc: 2a 80 00 07 bcs,a 20405f8 <msdos_date_unix2dos+0x100> <== ALWAYS TAKEN
20405e0: 90 02 20 01 inc %o0
if (days < inc)
break;
days -= inc;
}
months = year & 0x03 ? regyear : leapyear;
for (month = 0; month < 12; month++) {
20405e4: 84 00 a0 01 inc %g2 <== NOT EXECUTED
20405e8: 80 a0 a0 0c cmp %g2, 0xc <== NOT EXECUTED
20405ec: 12 bf ff f9 bne 20405d0 <msdos_date_unix2dos+0xd8> <== NOT EXECUTED
20405f0: 90 22 00 03 sub %o0, %g3, %o0 <== NOT EXECUTED
if (days < months[month])
break;
days -= months[month];
}
lastddate = ((days + 1) << MSDOS_DD_DAY_SHIFT)
20405f4: 90 02 20 01 inc %o0 <== NOT EXECUTED
20405f8: 84 00 a0 01 inc %g2
20405fc: 07 00 81 bc sethi %hi(0x206f000), %g3
2040600: 85 28 a0 05 sll %g2, 5, %g2
2040604: 90 02 00 02 add %o0, %g2, %o0
* 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)
2040608: 80 a0 67 bc cmp %g1, 0x7bc
204060c: 08 80 00 06 bleu 2040624 <msdos_date_unix2dos+0x12c> <== NEVER TAKEN
2040610: d0 30 e1 f0 sth %o0, [ %g3 + 0x1f0 ]
lastddate += (year - 1980) <<
2040614: 82 00 78 44 add %g1, -1980, %g1
2040618: 83 28 60 09 sll %g1, 9, %g1
204061c: 90 02 00 01 add %o0, %g1, %o0
2040620: d0 30 e1 f0 sth %o0, [ %g3 + 0x1f0 ]
MSDOS_DD_YEAR_SHIFT;
}
}
*dtp = lastdtime;
2040624: 03 00 81 bc sethi %hi(0x206f000), %g1
2040628: c2 10 61 e8 lduh [ %g1 + 0x1e8 ], %g1 ! 206f1e8 <lastdtime>
204062c: c2 36 80 00 sth %g1, [ %i2 ]
*ddp = lastddate;
2040630: 03 00 81 bc sethi %hi(0x206f000), %g1
2040634: c2 10 61 f0 lduh [ %g1 + 0x1f0 ], %g1 ! 206f1f0 <lastddate>
2040638: c2 36 40 00 sth %g1, [ %i1 ]
204063c: 81 c7 e0 08 ret
2040640: 81 e8 00 00 restore
02034f38 <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
)
{
2034f38: 9d e3 bf a0 save %sp, -96, %sp
*/
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,
2034f3c: 23 00 81 9c sethi %hi(0x2067000), %l1
fat_file_fd_t *fat_fd,
bool *ret_val
)
{
ssize_t ret = 0;
msdos_fs_info_t *fs_info = mt_entry->fs_info;
2034f40: fa 06 20 08 ld [ %i0 + 8 ], %i5
MSDOS_THIS_DIR_ENTRY_EMPTY) ||
((*MSDOS_DIR_ATTR(entry) & MSDOS_ATTR_LFN_MASK) ==
MSDOS_ATTR_LFN) ||
(strncmp(MSDOS_DIR_NAME((entry)), MSDOS_DOT_NAME,
MSDOS_SHORT_NAME_LEN) == 0) ||
(strncmp(MSDOS_DIR_NAME((entry)),
2034f44: 25 00 81 9c sethi %hi(0x2067000), %l2
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;
2034f48: c0 2e 80 00 clrb [ %i2 ]
bool *ret_val
)
{
ssize_t ret = 0;
msdos_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t j = 0, i = 0;
2034f4c: b6 10 20 00 clr %i3
*/
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,
2034f50: a2 14 60 70 or %l1, 0x70, %l1
uint32_t j = 0, i = 0;
/* dir is not empty */
*ret_val = false;
while ((ret = fat_file_read(&fs_info->fat, fat_fd, j * fs_info->fat.vol.bps,
2034f54: 10 80 00 33 b 2035020 <msdos_dir_is_empty+0xe8>
2034f58: a4 14 a0 80 or %l2, 0x80, %l2
fs_info->fat.vol.bps,
fs_info->cl_buf)) != FAT_EOF)
{
if (ret < MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
2034f5c: 04 80 00 2a ble 2035004 <msdos_dir_is_empty+0xcc> <== NEVER TAKEN
2034f60: b0 10 3f ff mov -1, %i0
return -1;
assert(ret == fs_info->fat.vol.bps);
2034f64: c2 17 40 00 lduh [ %i5 ], %g1
2034f68: 80 a2 00 01 cmp %o0, %g1
2034f6c: 02 80 00 28 be 203500c <msdos_dir_is_empty+0xd4> <== ALWAYS TAKEN
2034f70: b8 10 20 00 clr %i4
2034f74: 11 00 81 9c sethi %hi(0x2067000), %o0 <== NOT EXECUTED
2034f78: 15 00 81 9c sethi %hi(0x2067000), %o2 <== NOT EXECUTED
2034f7c: 17 00 81 9c sethi %hi(0x2067000), %o3 <== NOT EXECUTED
2034f80: 90 12 20 00 mov %o0, %o0 <== NOT EXECUTED
2034f84: 92 10 23 60 mov 0x360, %o1 <== NOT EXECUTED
2034f88: 94 12 a0 b8 or %o2, 0xb8, %o2 <== NOT EXECUTED
2034f8c: 7f ff ca 6a call 2027934 <__assert_func> <== NOT EXECUTED
2034f90: 96 12 e0 50 or %o3, 0x50, %o3 <== 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)) ==
2034f94: e0 08 40 1c ldub [ %g1 + %i4 ], %l0
2034f98: 80 a4 20 e5 cmp %l0, 0xe5
2034f9c: 02 80 00 14 be 2034fec <msdos_dir_is_empty+0xb4> <== NEVER TAKEN
2034fa0: b0 00 40 1c add %g1, %i4, %i0
MSDOS_THIS_DIR_ENTRY_EMPTY) ||
((*MSDOS_DIR_ATTR(entry) & MSDOS_ATTR_LFN_MASK) ==
2034fa4: c2 0e 20 0b ldub [ %i0 + 0xb ], %g1
*
* 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) ||
2034fa8: 82 08 60 3f and %g1, 0x3f, %g1
2034fac: 80 a0 60 0f cmp %g1, 0xf
2034fb0: 02 80 00 0f be 2034fec <msdos_dir_is_empty+0xb4> <== NEVER TAKEN
2034fb4: 90 10 00 18 mov %i0, %o0
((*MSDOS_DIR_ATTR(entry) & MSDOS_ATTR_LFN_MASK) ==
MSDOS_ATTR_LFN) ||
(strncmp(MSDOS_DIR_NAME((entry)), MSDOS_DOT_NAME,
2034fb8: 92 10 00 11 mov %l1, %o1
2034fbc: 40 00 50 d7 call 2049318 <strncmp>
2034fc0: 94 10 20 0b mov 0xb, %o2
* be valid.
*/
if (((*MSDOS_DIR_ENTRY_TYPE(entry)) ==
MSDOS_THIS_DIR_ENTRY_EMPTY) ||
((*MSDOS_DIR_ATTR(entry) & MSDOS_ATTR_LFN_MASK) ==
MSDOS_ATTR_LFN) ||
2034fc4: 80 a2 20 00 cmp %o0, 0
2034fc8: 22 80 00 12 be,a 2035010 <msdos_dir_is_empty+0xd8>
2034fcc: b8 07 20 20 add %i4, 0x20, %i4
(strncmp(MSDOS_DIR_NAME((entry)), MSDOS_DOT_NAME,
MSDOS_SHORT_NAME_LEN) == 0) ||
(strncmp(MSDOS_DIR_NAME((entry)),
2034fd0: 90 10 00 18 mov %i0, %o0
2034fd4: 92 10 00 12 mov %l2, %o1
2034fd8: 40 00 50 d0 call 2049318 <strncmp>
2034fdc: 94 10 20 0b mov 0xb, %o2
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) ||
2034fe0: 80 a2 20 00 cmp %o0, 0
2034fe4: 12 80 00 04 bne 2034ff4 <msdos_dir_is_empty+0xbc>
2034fe8: 80 a4 20 00 cmp %l0, 0
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)
2034fec: 10 80 00 09 b 2035010 <msdos_dir_is_empty+0xd8>
2034ff0: b8 07 20 20 add %i4, 0x20, %i4
continue;
/*
* Nothing more to look at.
*/
if ((*MSDOS_DIR_NAME(entry)) ==
2034ff4: 12 80 00 04 bne 2035004 <msdos_dir_is_empty+0xcc>
2034ff8: b0 10 20 00 clr %i0
MSDOS_THIS_DIR_ENTRY_AND_REST_EMPTY)
{
*ret_val = true;
2034ffc: 82 10 20 01 mov 1, %g1
2035000: c2 2e 80 00 stb %g1, [ %i2 ]
return RC_OK;
2035004: 81 c7 e0 08 ret
2035008: 81 e8 00 00 restore
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;
203500c: a6 10 00 08 mov %o0, %l3
return -1;
assert(ret == fs_info->fat.vol.bps);
/* have to look at the DIR_NAME as "raw" 8-bit data */
for (i = 0;
2035010: 80 a7 00 13 cmp %i4, %l3
2035014: 2a bf ff e0 bcs,a 2034f94 <msdos_dir_is_empty+0x5c> <== ALWAYS TAKEN
2035018: c2 07 60 94 ld [ %i5 + 0x94 ], %g1
/*
* Short file name entries mean not empty.
*/
return RC_OK;
}
j++;
203501c: b6 06 e0 01 inc %i3 <== NOT EXECUTED
uint32_t j = 0, i = 0;
/* dir is not empty */
*ret_val = false;
while ((ret = fat_file_read(&fs_info->fat, fat_fd, j * fs_info->fat.vol.bps,
2035020: f8 17 40 00 lduh [ %i5 ], %i4
2035024: 90 10 00 1b mov %i3, %o0
2035028: 7f ff 37 8f call 2002e64 <.umul>
203502c: 92 10 00 1c mov %i4, %o1
2035030: d8 07 60 94 ld [ %i5 + 0x94 ], %o4
2035034: 94 10 00 08 mov %o0, %o2
2035038: 92 10 00 19 mov %i1, %o1
203503c: 90 10 00 1d mov %i5, %o0
2035040: 7f ff c1 b4 call 2025710 <fat_file_read>
2035044: 96 10 00 1c mov %i4, %o3
2035048: 80 a2 20 00 cmp %o0, 0
203504c: 32 bf ff c4 bne,a 2034f5c <msdos_dir_is_empty+0x24> <== ALWAYS TAKEN
2035050: 80 a2 20 1f cmp %o0, 0x1f
*/
return RC_OK;
}
j++;
}
*ret_val = true;
2035054: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED
2035058: c2 2e 80 00 stb %g1, [ %i2 ] <== NOT EXECUTED
203505c: b0 10 20 00 clr %i0 <== NOT EXECUTED
return RC_OK;
}
2035060: 81 c7 e0 08 ret <== NOT EXECUTED
2035064: 81 e8 00 00 restore <== NOT EXECUTED
020408e0 <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)
{
20408e0: 9d e3 be 68 save %sp, -408, %sp <== NOT EXECUTED
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
20408e4: c2 06 20 28 ld [ %i0 + 0x28 ], %g1 <== 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);
20408e8: d0 1e 20 08 ldd [ %i0 + 8 ], %o0 <== 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;
20408ec: ec 00 60 08 ld [ %g1 + 8 ], %l6 <== 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);
20408f0: 94 10 20 00 clr %o2 <== NOT EXECUTED
20408f4: 96 10 21 18 mov 0x118, %o3 <== 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)
{
20408f8: f2 27 a0 48 st %i1, [ %fp + 0x48 ] <== 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;
20408fc: c0 27 be d0 clr [ %fp + -304 ] <== 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);
2040900: 40 00 6d 01 call 205bd04 <__divdi3> <== NOT EXECUTED
2040904: c0 27 be d4 clr [ %fp + -300 ] <== NOT EXECUTED
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;
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
2040908: e0 06 20 1c ld [ %i0 + 0x1c ], %l0 <== 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);
204090c: a6 10 00 09 mov %o1, %l3 <== NOT EXECUTED
count = (count / sizeof(struct dirent)) * sizeof(struct dirent);
2040910: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
2040914: 40 00 6b 1b call 205b580 <.udiv> <== NOT EXECUTED
2040918: 92 10 21 18 mov 0x118, %o1 <== NOT EXECUTED
204091c: a5 2a 20 03 sll %o0, 3, %l2 <== NOT EXECUTED
2040920: 91 2a 20 05 sll %o0, 5, %o0 <== NOT EXECUTED
2040924: a4 04 80 08 add %l2, %o0, %l2 <== NOT EXECUTED
2040928: 85 2c a0 03 sll %l2, 3, %g2 <== NOT EXECUTED
204092c: a4 20 80 12 sub %g2, %l2, %l2 <== 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 :
2040930: c4 04 20 20 ld [ %l0 + 0x20 ], %g2 <== NOT EXECUTED
2040934: 80 a0 a0 01 cmp %g2, 1 <== NOT EXECUTED
2040938: 32 80 00 0b bne,a 2040964 <msdos_dir_read+0x84> <== NOT EXECUTED
204093c: ea 15 a0 06 lduh [ %l6 + 6 ], %l5 <== 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) &&
2040940: c4 04 20 24 ld [ %l0 + 0x24 ], %g2 <== NOT EXECUTED
2040944: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED
2040948: 32 80 00 07 bne,a 2040964 <msdos_dir_read+0x84> <== NOT EXECUTED
204094c: ea 15 a0 06 lduh [ %l6 + 6 ], %l5 <== NOT EXECUTED
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16))) ?
2040950: c4 0d a0 0a ldub [ %l6 + 0xa ], %g2 <== 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) &&
2040954: 80 88 a0 03 btst 3, %g2 <== NOT EXECUTED
2040958: 22 80 00 03 be,a 2040964 <msdos_dir_read+0x84> <== NOT EXECUTED
204095c: ea 15 a0 06 lduh [ %l6 + 6 ], %l5 <== NOT EXECUTED
2040960: ea 04 20 18 ld [ %l0 + 0x18 ], %l5 <== NOT EXECUTED
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16))) ?
fat_fd->fat_file_size :
fs_info->fat.vol.bpc;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
2040964: d0 05 a0 90 ld [ %l6 + 0x90 ], %o0 <== NOT EXECUTED
2040968: 92 10 20 00 clr %o1 <== NOT EXECUTED
204096c: 7f ff 32 d2 call 200d4b4 <rtems_semaphore_obtain> <== NOT EXECUTED
2040970: 94 10 20 00 clr %o2 <== NOT EXECUTED
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
2040974: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2040978: 22 80 00 fe be,a 2040d70 <msdos_dir_read+0x490> <== NOT EXECUTED
204097c: a2 10 20 00 clr %l1 <== NOT EXECUTED
2040980: 30 80 00 0b b,a 20409ac <msdos_dir_read+0xcc> <== 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(&fs_info->fat, fat_fd, (j * bts2rd),
2040984: 90 10 00 16 mov %l6, %o0 <== NOT EXECUTED
2040988: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED
204098c: 94 10 00 11 mov %l1, %o2 <== NOT EXECUTED
2040990: 7f ff 93 60 call 2025710 <fat_file_read> <== NOT EXECUTED
2040994: 96 10 00 15 mov %l5, %o3 <== NOT EXECUTED
bts2rd, fs_info->cl_buf);
if (ret < MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
2040998: 80 a2 20 1f cmp %o0, 0x1f <== NOT EXECUTED
204099c: 14 80 00 ee bg 2040d54 <msdos_dir_read+0x474> <== NOT EXECUTED
20409a0: d0 27 be cc st %o0, [ %fp + -308 ] <== NOT EXECUTED
{
rtems_semaphore_release(fs_info->vol_sema);
20409a4: 7f ff 33 0e call 200d5dc <rtems_semaphore_release> <== NOT EXECUTED
20409a8: d0 05 a0 90 ld [ %l6 + 0x90 ], %o0 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
20409ac: 40 00 06 10 call 20421ec <__errno> <== NOT EXECUTED
20409b0: b2 10 3f ff mov -1, %i1 <== NOT EXECUTED
20409b4: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
20409b8: 10 80 01 07 b 2040dd4 <msdos_dir_read+0x4f4> <== NOT EXECUTED
20409bc: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
}
for (i = 0; i < ret; i += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
{
char* entry = (char*) fs_info->cl_buf + i;
20409c0: ae 00 c0 1c add %g3, %i4, %l7 <== NOT EXECUTED
/*
* Is this directory from here on empty ?
*/
if ((*MSDOS_DIR_ENTRY_TYPE(entry)) ==
20409c4: c6 08 c0 1c ldub [ %g3 + %i4 ], %g3 <== NOT EXECUTED
20409c8: 88 88 e0 ff andcc %g3, 0xff, %g4 <== NOT EXECUTED
20409cc: 12 80 00 04 bne 20409dc <msdos_dir_read+0xfc> <== NOT EXECUTED
20409d0: 80 a1 20 e5 cmp %g4, 0xe5 <== NOT EXECUTED
break;
}
j++;
}
rtems_semaphore_release(fs_info->vol_sema);
20409d4: 10 80 00 ef b 2040d90 <msdos_dir_read+0x4b0> <== NOT EXECUTED
20409d8: d0 05 a0 90 ld [ %l6 + 0x90 ], %o0 <== 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)
20409dc: 22 80 00 df be,a 2040d58 <msdos_dir_read+0x478> <== NOT EXECUTED
20409e0: b8 07 20 20 add %i4, 0x20, %i4 <== NOT EXECUTED
continue;
/* Is the directory entry empty a volume label */
if (((*MSDOS_DIR_ATTR(entry)) & MSDOS_ATTR_VOLUME_ID) &&
20409e4: c8 0d e0 0b ldub [ %l7 + 0xb ], %g4 <== NOT EXECUTED
20409e8: 9e 09 20 08 and %g4, 8, %o7 <== NOT EXECUTED
20409ec: 80 8b e0 ff btst 0xff, %o7 <== NOT EXECUTED
20409f0: 22 80 00 07 be,a 2040a0c <msdos_dir_read+0x12c> <== NOT EXECUTED
20409f4: 88 09 20 3f and %g4, 0x3f, %g4 <== NOT EXECUTED
20409f8: 9e 09 20 3f and %g4, 0x3f, %o7 <== NOT EXECUTED
20409fc: 80 a3 e0 0f cmp %o7, 0xf <== NOT EXECUTED
2040a00: 32 80 00 d6 bne,a 2040d58 <msdos_dir_read+0x478> <== NOT EXECUTED
2040a04: b8 07 20 20 add %i4, 0x20, %i4 <== 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) ==
2040a08: 88 09 20 3f and %g4, 0x3f, %g4 <== NOT EXECUTED
2040a0c: 80 a1 20 0f cmp %g4, 0xf <== NOT EXECUTED
2040a10: 12 80 00 3e bne 2040b08 <msdos_dir_read+0x228> <== NOT EXECUTED
2040a14: 80 a4 e0 00 cmp %l3, 0 <== NOT EXECUTED
int q;
/*
* Is this is the first entry of a LFN ?
*/
if (lfn_start == FAT_FILE_SHORT_NAME)
2040a18: 80 a6 ff ff cmp %i3, -1 <== NOT EXECUTED
2040a1c: 32 80 00 0f bne,a 2040a58 <msdos_dir_read+0x178> <== NOT EXECUTED
2040a20: c6 0d c0 00 ldub [ %l7 ], %g3 <== NOT EXECUTED
{
/*
* The first entry must have the last long entry flag set.
*/
if ((*MSDOS_DIR_ENTRY_TYPE(entry) &
2040a24: 88 08 e0 40 and %g3, 0x40, %g4 <== NOT EXECUTED
2040a28: 80 89 20 ff btst 0xff, %g4 <== NOT EXECUTED
2040a2c: 22 80 00 cb be,a 2040d58 <msdos_dir_read+0x478> <== NOT EXECUTED
2040a30: b8 07 20 20 add %i4, 0x20, %i4 <== 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)
2040a34: b6 07 00 11 add %i4, %l1, %i3 <== 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) &
2040a38: ba 08 e0 3f and %g3, 0x3f, %i5 <== NOT EXECUTED
continue;
/*
* Remember the start location of the long file name.
*/
lfn_start =
2040a3c: b7 36 e0 05 srl %i3, 5, %i3 <== 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);
2040a40: e8 0d e0 0d ldub [ %l7 + 0xd ], %l4 <== NOT EXECUTED
memset (tmp_dirent.d_name, 0, sizeof(tmp_dirent.d_name));
2040a44: 90 07 be fc add %fp, -260, %o0 <== NOT EXECUTED
2040a48: 92 10 20 00 clr %o1 <== NOT EXECUTED
2040a4c: 40 00 13 b6 call 2045924 <memset> <== NOT EXECUTED
2040a50: 94 10 21 00 mov 0x100, %o2 <== 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) &
2040a54: c6 0d c0 00 ldub [ %l7 ], %g3 <== NOT EXECUTED
2040a58: 86 08 e0 3f and %g3, 0x3f, %g3 <== NOT EXECUTED
2040a5c: 80 a7 40 03 cmp %i5, %g3 <== NOT EXECUTED
2040a60: 32 80 00 bb bne,a 2040d4c <msdos_dir_read+0x46c> <== NOT EXECUTED
2040a64: b6 10 3f ff mov -1, %i3 <== NOT EXECUTED
MSDOS_LAST_LONG_ENTRY_MASK)) ||
2040a68: c6 0d e0 0d ldub [ %l7 + 0xd ], %g3 <== NOT EXECUTED
2040a6c: 88 0d 20 ff and %l4, 0xff, %g4 <== NOT EXECUTED
2040a70: 80 a1 00 03 cmp %g4, %g3 <== NOT EXECUTED
2040a74: 32 80 00 b6 bne,a 2040d4c <msdos_dir_read+0x46c> <== NOT EXECUTED
2040a78: b6 10 3f ff mov -1, %i3 <== 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--;
2040a7c: ba 07 7f ff add %i5, -1, %i5 <== NOT EXECUTED
p = entry + 1;
o = lfn_entries * MSDOS_LFN_LEN_PER_ENTRY;
2040a80: 87 2f 60 02 sll %i5, 2, %g3 <== NOT EXECUTED
2040a84: 89 2f 60 04 sll %i5, 4, %g4 <== 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)
2040a88: 82 07 be e8 add %fp, -280, %g1 <== NOT EXECUTED
* fit in the directory entry name field.
*/
lfn_entries--;
p = entry + 1;
o = lfn_entries * MSDOS_LFN_LEN_PER_ENTRY;
2040a8c: 88 21 00 03 sub %g4, %g3, %g4 <== 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;
2040a90: 84 05 e0 01 add %l7, 1, %g2 <== NOT EXECUTED
o = lfn_entries * MSDOS_LFN_LEN_PER_ENTRY;
2040a94: 88 01 00 1d add %g4, %i5, %g4 <== NOT EXECUTED
for (q = 0; q < MSDOS_LFN_LEN_PER_ENTRY; q++)
2040a98: 86 10 20 00 clr %g3 <== 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)
2040a9c: 9e 00 40 04 add %g1, %g4, %o7 <== NOT EXECUTED
p = entry + 1;
o = lfn_entries * MSDOS_LFN_LEN_PER_ENTRY;
for (q = 0; q < MSDOS_LFN_LEN_PER_ENTRY; q++)
{
if (o >= (sizeof(tmp_dirent.d_name) - 1))
2040aa0: 9a 00 c0 04 add %g3, %g4, %o5 <== NOT EXECUTED
2040aa4: 80 a3 60 fe cmp %o5, 0xfe <== NOT EXECUTED
2040aa8: 18 80 00 a3 bgu 2040d34 <msdos_dir_read+0x454> <== NOT EXECUTED
2040aac: 9a 03 c0 03 add %o7, %g3, %o5 <== NOT EXECUTED
break;
tmp_dirent.d_name[o++] = *p;
2040ab0: d8 08 80 00 ldub [ %g2 ], %o4 <== NOT EXECUTED
2040ab4: d8 2b 60 14 stb %o4, [ %o5 + 0x14 ] <== NOT EXECUTED
if (*p == '\0')
2040ab8: da 48 80 00 ldsb [ %g2 ], %o5 <== NOT EXECUTED
2040abc: 80 a3 60 00 cmp %o5, 0 <== NOT EXECUTED
2040ac0: 02 80 00 9d be 2040d34 <msdos_dir_read+0x454> <== NOT EXECUTED
2040ac4: 80 a0 e0 04 cmp %g3, 4 <== NOT EXECUTED
break;
switch (q)
2040ac8: 02 80 00 06 be 2040ae0 <msdos_dir_read+0x200> <== NOT EXECUTED
2040acc: 80 a0 e0 0a cmp %g3, 0xa <== NOT EXECUTED
2040ad0: 32 80 00 08 bne,a 2040af0 <msdos_dir_read+0x210> <== NOT EXECUTED
2040ad4: 84 00 a0 02 add %g2, 2, %g2 <== NOT EXECUTED
{
case 4:
p += 5;
break;
case 10:
p += 4;
2040ad8: 10 80 00 04 b 2040ae8 <msdos_dir_read+0x208> <== NOT EXECUTED
2040adc: 84 00 a0 04 add %g2, 4, %g2 <== NOT EXECUTED
switch (q)
{
case 4:
p += 5;
break;
2040ae0: 10 80 00 04 b 2040af0 <msdos_dir_read+0x210> <== NOT EXECUTED
2040ae4: 84 00 a0 05 add %g2, 5, %g2 <== NOT EXECUTED
case 10:
p += 4;
break;
2040ae8: 10 80 00 03 b 2040af4 <msdos_dir_read+0x214> <== NOT EXECUTED
2040aec: 86 00 e0 01 inc %g3 <== 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++)
2040af0: 86 00 e0 01 inc %g3 <== NOT EXECUTED
2040af4: 80 a0 e0 0d cmp %g3, 0xd <== NOT EXECUTED
2040af8: 12 bf ff eb bne 2040aa4 <msdos_dir_read+0x1c4> <== NOT EXECUTED
2040afc: 9a 00 c0 04 add %g3, %g4, %o5 <== NOT EXECUTED
rtems_semaphore_release(fs_info->vol_sema);
return rc;
}
}
if (count <= 0)
2040b00: 10 80 00 8e b 2040d38 <msdos_dir_read+0x458> <== NOT EXECUTED
2040b04: 80 a4 a0 00 cmp %l2, 0 <== NOT EXECUTED
fat_dir_pos_t dir_pos;
/*
* Skip active entries until get the entry to start from.
*/
if (start)
2040b08: 02 80 00 04 be 2040b18 <msdos_dir_read+0x238> <== NOT EXECUTED
2040b0c: 90 10 00 16 mov %l6, %o0 <== NOT EXECUTED
{
lfn_start = FAT_FILE_SHORT_NAME;
start--;
2040b10: 10 80 00 8e b 2040d48 <msdos_dir_read+0x468> <== NOT EXECUTED
2040b14: a6 04 ff ff add %l3, -1, %l3 <== 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(&fs_info->fat, fat_fd, F_CLU_NUM,
2040b18: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED
2040b1c: 94 10 20 01 mov 1, %o2 <== NOT EXECUTED
2040b20: 96 10 00 11 mov %l1, %o3 <== NOT EXECUTED
2040b24: 7f ff 93 db call 2025a90 <fat_file_ioctl> <== NOT EXECUTED
2040b28: 98 07 be d4 add %fp, -300, %o4 <== NOT EXECUTED
j * bts2rd, &cur_cln);
if (rc != RC_OK)
2040b2c: b2 92 20 00 orcc %o0, 0, %i1 <== NOT EXECUTED
2040b30: 12 80 00 7d bne 2040d24 <msdos_dir_read+0x444> <== NOT EXECUTED
2040b34: c6 07 be d4 ld [ %fp + -300 ], %g3 <== 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;
2040b38: 82 10 3f ff mov -1, %g1 <== NOT EXECUTED
rtems_semaphore_release(fs_info->vol_sema);
return rc;
}
fat_dir_pos_init(&dir_pos);
dir_pos.sname.cln = cur_cln;
2040b3c: c6 27 be d8 st %g3, [ %fp + -296 ] <== NOT EXECUTED
2040b40: c2 27 be e0 st %g1, [ %fp + -288 ] <== NOT EXECUTED
dir_pos->lname.ofs = FAT_FILE_SHORT_NAME;
2040b44: c2 27 be e4 st %g1, [ %fp + -284 ] <== NOT EXECUTED
dir_pos.sname.ofs = i;
2040b48: f8 27 be dc st %i4, [ %fp + -292 ] <== NOT EXECUTED
rc = fat_file_open(&fs_info->fat, &dir_pos, &tmp_fat_fd);
2040b4c: 90 10 00 16 mov %l6, %o0 <== NOT EXECUTED
2040b50: 92 07 be d8 add %fp, -296, %o1 <== NOT EXECUTED
2040b54: 7f ff 92 8c call 2025584 <fat_file_open> <== NOT EXECUTED
2040b58: 94 07 be d0 add %fp, -304, %o2 <== NOT EXECUTED
if (rc != RC_OK)
2040b5c: b2 92 20 00 orcc %o0, 0, %i1 <== NOT EXECUTED
2040b60: 12 80 00 71 bne 2040d24 <msdos_dir_read+0x444> <== NOT EXECUTED
2040b64: c6 07 be d0 ld [ %fp + -304 ], %g3 <== 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);
2040b68: 82 10 21 18 mov 0x118, %g1 <== NOT EXECUTED
tmp_dirent.d_ino = tmp_fat_fd->ino;
2040b6c: c6 00 e0 0c ld [ %g3 + 0xc ], %g3 <== 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;
2040b70: c0 27 be f0 clr [ %fp + -272 ] <== NOT EXECUTED
2040b74: f4 27 be f4 st %i2, [ %fp + -268 ] <== NOT EXECUTED
tmp_dirent.d_reclen = sizeof(struct dirent);
2040b78: c2 37 be f8 sth %g1, [ %fp + -264 ] <== 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)
2040b7c: 80 a6 ff ff cmp %i3, -1 <== NOT EXECUTED
2040b80: 02 80 00 1d be 2040bf4 <msdos_dir_read+0x314> <== NOT EXECUTED
2040b84: c6 27 be e8 st %g3, [ %fp + -280 ] <== NOT EXECUTED
2040b88: 88 10 20 00 clr %g4 <== NOT EXECUTED
2040b8c: 86 10 20 00 clr %g3 <== 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;
2040b90: da 0d c0 04 ldub [ %l7 + %g4 ], %o5 <== NOT EXECUTED
2040b94: 9e 08 e0 01 and %g3, 1, %o7 <== NOT EXECUTED
2040b98: 80 a0 00 0f cmp %g0, %o7 <== NOT EXECUTED
2040b9c: 86 08 e0 ff and %g3, 0xff, %g3 <== NOT EXECUTED
2040ba0: 9e 40 3f ff addx %g0, -1, %o7 <== NOT EXECUTED
2040ba4: 87 30 e0 01 srl %g3, 1, %g3 <== NOT EXECUTED
2040ba8: 9e 0b e0 80 and %o7, 0x80, %o7 <== NOT EXECUTED
2040bac: 86 03 40 03 add %o5, %g3, %g3 <== NOT EXECUTED
2040bb0: 9e 03 ff 80 add %o7, -128, %o7 <== NOT EXECUTED
{
uint8_t cs = 0;
uint8_t* p = (uint8_t*) entry;
int i;
for (i = 0; i < 11; i++, p++)
2040bb4: 88 01 20 01 inc %g4 <== NOT EXECUTED
2040bb8: 80 a1 20 0b cmp %g4, 0xb <== NOT EXECUTED
2040bbc: 12 bf ff f5 bne 2040b90 <msdos_dir_read+0x2b0> <== NOT EXECUTED
2040bc0: 86 00 c0 0f add %g3, %o7, %g3 <== NOT EXECUTED
cs = ((cs & 1) ? 0x80 : 0) + (cs >> 1) + *p;
if (lfn_entries || (lfn_checksum != cs))
2040bc4: 86 18 c0 14 xor %g3, %l4, %g3 <== NOT EXECUTED
2040bc8: 80 88 e0 ff btst 0xff, %g3 <== NOT EXECUTED
2040bcc: 12 80 00 0b bne 2040bf8 <msdos_dir_read+0x318> <== NOT EXECUTED
2040bd0: 86 10 20 08 mov 8, %g3 <== NOT EXECUTED
2040bd4: 80 a7 60 00 cmp %i5, 0 <== NOT EXECUTED
2040bd8: 12 80 00 09 bne 2040bfc <msdos_dir_read+0x31c> <== NOT EXECUTED
2040bdc: 88 05 c0 03 add %l7, %g3, %g4 <== NOT EXECUTED
2040be0: 30 80 00 70 b,a 2040da0 <msdos_dir_read+0x4c0> <== NOT EXECUTED
const char *src_tmp;
/*
* find last non-blank character of base name
*/
for ((i = MSDOS_SHORT_BASE_LEN ,
2040be4: 32 80 00 06 bne,a 2040bfc <msdos_dir_read+0x31c> <== NOT EXECUTED
2040be8: 88 05 c0 03 add %l7, %g3, %g4 <== NOT EXECUTED
* copy base name to destination
*/
src_tmp = src;
len = i;
while (i-- > 0) {
*dst++ = tolower((unsigned char)(*src_tmp++));
2040bec: 10 80 00 09 b 2040c10 <msdos_dir_read+0x330> <== NOT EXECUTED
2040bf0: 03 00 81 af sethi %hi(0x206bc00), %g1 <== NOT EXECUTED
const char *src_tmp;
/*
* find last non-blank character of base name
*/
for ((i = MSDOS_SHORT_BASE_LEN ,
2040bf4: 86 10 20 08 mov 8, %g3 <== 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)
2040bf8: 88 05 c0 03 add %l7, %g3, %g4 <== 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) &&
2040bfc: c8 49 3f ff ldsb [ %g4 + -1 ], %g4 <== NOT EXECUTED
2040c00: 80 a1 20 20 cmp %g4, 0x20 <== NOT EXECUTED
2040c04: 22 bf ff f8 be,a 2040be4 <msdos_dir_read+0x304> <== NOT EXECUTED
2040c08: 86 80 ff ff addcc %g3, -1, %g3 <== NOT EXECUTED
* copy base name to destination
*/
src_tmp = src;
len = i;
while (i-- > 0) {
*dst++ = tolower((unsigned char)(*src_tmp++));
2040c0c: 03 00 81 af sethi %hi(0x206bc00), %g1 <== NOT EXECUTED
2040c10: b6 10 20 00 clr %i3 <== NOT EXECUTED
2040c14: da 00 61 d0 ld [ %g1 + 0x1d0 ], %o5 <== 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(
2040c18: 10 80 00 0b b 2040c44 <msdos_dir_read+0x364> <== NOT EXECUTED
2040c1c: 88 07 be fc add %fp, -260, %g4 <== NOT EXECUTED
* copy base name to destination
*/
src_tmp = src;
len = i;
while (i-- > 0) {
*dst++ = tolower((unsigned char)(*src_tmp++));
2040c20: 98 03 40 0f add %o5, %o7, %o4 <== NOT EXECUTED
2040c24: d8 0b 20 01 ldub [ %o4 + 1 ], %o4 <== NOT EXECUTED
2040c28: 98 0b 20 03 and %o4, 3, %o4 <== NOT EXECUTED
2040c2c: 80 a3 20 01 cmp %o4, 1 <== NOT EXECUTED
2040c30: 22 80 00 02 be,a 2040c38 <msdos_dir_read+0x358> <== NOT EXECUTED
2040c34: 9e 03 e0 20 add %o7, 0x20, %o7 <== NOT EXECUTED
2040c38: de 29 00 00 stb %o7, [ %g4 ] <== NOT EXECUTED
2040c3c: b6 06 e0 01 inc %i3 <== NOT EXECUTED
2040c40: 88 01 20 01 inc %g4 <== 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)
2040c44: 9e 20 c0 1b sub %g3, %i3, %o7 <== NOT EXECUTED
/*
* copy base name to destination
*/
src_tmp = src;
len = i;
while (i-- > 0) {
2040c48: 80 a3 e0 00 cmp %o7, 0 <== NOT EXECUTED
2040c4c: 34 bf ff f5 bg,a 2040c20 <msdos_dir_read+0x340> <== NOT EXECUTED
2040c50: de 0d c0 1b ldub [ %l7 + %i3 ], %o7 <== 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) &&
2040c54: f6 4d e0 0a ldsb [ %l7 + 0xa ], %i3 <== NOT EXECUTED
2040c58: 80 a6 e0 20 cmp %i3, 0x20 <== NOT EXECUTED
2040c5c: 12 80 00 55 bne 2040db0 <msdos_dir_read+0x4d0> <== NOT EXECUTED
2040c60: b6 10 20 03 mov 3, %i3 <== NOT EXECUTED
2040c64: f6 4d e0 09 ldsb [ %l7 + 9 ], %i3 <== NOT EXECUTED
2040c68: 80 a6 e0 20 cmp %i3, 0x20 <== NOT EXECUTED
2040c6c: 12 80 00 51 bne 2040db0 <msdos_dir_read+0x4d0> <== NOT EXECUTED
2040c70: b6 10 20 02 mov 2, %i3 <== NOT EXECUTED
2040c74: f6 4d e0 08 ldsb [ %l7 + 8 ], %i3 <== NOT EXECUTED
2040c78: 80 a6 e0 20 cmp %i3, 0x20 <== NOT EXECUTED
2040c7c: 22 80 00 18 be,a 2040cdc <msdos_dir_read+0x3fc> <== NOT EXECUTED
2040c80: c0 29 00 00 clrb [ %g4 ] <== NOT EXECUTED
2040c84: 10 80 00 4b b 2040db0 <msdos_dir_read+0x4d0> <== NOT EXECUTED
2040c88: b6 10 20 01 mov 1, %i3 <== 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++));
2040c8c: da 0b 60 08 ldub [ %o5 + 8 ], %o5 <== NOT EXECUTED
2040c90: 94 03 00 0d add %o4, %o5, %o2 <== NOT EXECUTED
2040c94: d4 0a a0 01 ldub [ %o2 + 1 ], %o2 <== NOT EXECUTED
2040c98: 94 0a a0 03 and %o2, 3, %o2 <== NOT EXECUTED
2040c9c: 80 a2 a0 01 cmp %o2, 1 <== NOT EXECUTED
2040ca0: 22 80 00 02 be,a 2040ca8 <msdos_dir_read+0x3c8> <== NOT EXECUTED
2040ca4: 9a 03 60 20 add %o5, 0x20, %o5 <== 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)
2040ca8: 94 01 00 0f add %g4, %o7, %o2 <== NOT EXECUTED
2040cac: 9e 03 e0 01 inc %o7 <== 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++));
2040cb0: da 2a a0 01 stb %o5, [ %o2 + 1 ] <== NOT EXECUTED
* RETURNS:
* the number of bytes read on success, or -1 if error occured (errno
* set apropriately).
*/
ssize_t
msdos_dir_read(rtems_libio_t *iop, void *buffer, size_t count)
2040cb4: 9a 26 c0 0f sub %i3, %o7, %o5 <== NOT EXECUTED
*/
if (i > 0) {
*dst++ = '.'; /* append dot */
len += i + 1; /* extension + dot */
src_tmp = src + MSDOS_SHORT_BASE_LEN;
while (i-- > 0) {
2040cb8: 80 a3 60 00 cmp %o5, 0 <== NOT EXECUTED
2040cbc: 14 bf ff f4 bg 2040c8c <msdos_dir_read+0x3ac> <== NOT EXECUTED
2040cc0: 9a 05 c0 0f add %l7, %o7, %o5 <== 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)
2040cc4: 84 38 00 1b xnor %g0, %i3, %g2 <== NOT EXECUTED
2040cc8: 85 38 a0 1f sra %g2, 0x1f, %g2 <== NOT EXECUTED
2040ccc: b6 0e c0 02 and %i3, %g2, %i3 <== NOT EXECUTED
2040cd0: 88 02 c0 1b add %o3, %i3, %g4 <== NOT EXECUTED
2040cd4: 86 00 c0 1b add %g3, %i3, %g3 <== NOT EXECUTED
while (i-- > 0) {
*dst++ = tolower((unsigned char)(*src_tmp++));
len++;
}
}
*dst = '\0'; /* terminate string */
2040cd8: c0 29 00 00 clrb [ %g4 ] <== 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(
2040cdc: c6 37 be fa sth %g3, [ %fp + -262 ] <== NOT EXECUTED
2040ce0: b6 10 3f ff mov -1, %i3 <== NOT EXECUTED
else
{
tmp_dirent.d_namlen = strlen(tmp_dirent.d_name);
}
memcpy(buffer + cmpltd, &tmp_dirent, sizeof(struct dirent));
2040ce4: c2 07 a0 48 ld [ %fp + 0x48 ], %g1 <== NOT EXECUTED
2040ce8: 92 07 be e8 add %fp, -280, %o1 <== NOT EXECUTED
2040cec: 90 00 40 1a add %g1, %i2, %o0 <== NOT EXECUTED
2040cf0: 40 00 12 7e call 20456e8 <memcpy> <== NOT EXECUTED
2040cf4: 94 10 21 18 mov 0x118, %o2 <== NOT EXECUTED
iop->offset = iop->offset + sizeof(struct dirent);
2040cf8: c4 1e 20 08 ldd [ %i0 + 8 ], %g2 <== NOT EXECUTED
cmpltd += (sizeof(struct dirent));
count -= (sizeof(struct dirent));
/* inode number extracted, close fat-file */
rc = fat_file_close(&fs_info->fat, tmp_fat_fd);
2040cfc: d2 07 be d0 ld [ %fp + -304 ], %o1 <== 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);
2040d00: 86 80 e1 18 addcc %g3, 0x118, %g3 <== NOT EXECUTED
2040d04: 84 40 a0 00 addx %g2, 0, %g2 <== NOT EXECUTED
cmpltd += (sizeof(struct dirent));
count -= (sizeof(struct dirent));
/* inode number extracted, close fat-file */
rc = fat_file_close(&fs_info->fat, tmp_fat_fd);
2040d08: 90 10 00 16 mov %l6, %o0 <== 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);
2040d0c: c4 3e 20 08 std %g2, [ %i0 + 8 ] <== NOT EXECUTED
cmpltd += (sizeof(struct dirent));
count -= (sizeof(struct dirent));
/* inode number extracted, close fat-file */
rc = fat_file_close(&fs_info->fat, tmp_fat_fd);
2040d10: 7f ff 93 33 call 20259dc <fat_file_close> <== NOT EXECUTED
2040d14: b4 06 a1 18 add %i2, 0x118, %i2 <== NOT EXECUTED
if (rc != RC_OK)
2040d18: b2 92 20 00 orcc %o0, 0, %i1 <== NOT EXECUTED
2040d1c: 02 80 00 06 be 2040d34 <msdos_dir_read+0x454> <== NOT EXECUTED
2040d20: a4 04 be e8 add %l2, -280, %l2 <== NOT EXECUTED
{
rtems_semaphore_release(fs_info->vol_sema);
2040d24: 7f ff 32 2e call 200d5dc <rtems_semaphore_release> <== NOT EXECUTED
2040d28: d0 05 a0 90 ld [ %l6 + 0x90 ], %o0 <== NOT EXECUTED
j++;
}
rtems_semaphore_release(fs_info->vol_sema);
return cmpltd;
}
2040d2c: 81 c7 e0 08 ret <== NOT EXECUTED
2040d30: 91 e8 00 19 restore %g0, %i1, %o0 <== NOT EXECUTED
rtems_semaphore_release(fs_info->vol_sema);
return rc;
}
}
if (count <= 0)
2040d34: 80 a4 a0 00 cmp %l2, 0 <== NOT EXECUTED
2040d38: 32 80 00 08 bne,a 2040d58 <msdos_dir_read+0x478> <== NOT EXECUTED
2040d3c: b8 07 20 20 add %i4, 0x20, %i4 <== NOT EXECUTED
2040d40: 10 80 00 10 b 2040d80 <msdos_dir_read+0x4a0> <== NOT EXECUTED
2040d44: a2 04 40 15 add %l1, %l5, %l1 <== 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;
2040d48: b6 10 3f ff mov -1, %i3 <== 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)
2040d4c: 10 80 00 03 b 2040d58 <msdos_dir_read+0x478> <== NOT EXECUTED
2040d50: b8 07 20 20 add %i4, 0x20, %i4 <== NOT EXECUTED
* directories feature :( - we should count elements currently
* present in the directory because there may be holes :)
*/
ret = fat_file_read(&fs_info->fat, fat_fd, (j * bts2rd),
bts2rd, fs_info->cl_buf);
if (ret < MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
2040d54: b8 10 20 00 clr %i4 <== 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)
2040d58: c2 07 be cc ld [ %fp + -308 ], %g1 <== NOT EXECUTED
2040d5c: 80 a7 00 01 cmp %i4, %g1 <== NOT EXECUTED
2040d60: 2a bf ff 18 bcs,a 20409c0 <msdos_dir_read+0xe0> <== NOT EXECUTED
2040d64: c6 05 a0 94 ld [ %l6 + 0x94 ], %g3 <== NOT EXECUTED
2040d68: 10 80 00 06 b 2040d80 <msdos_dir_read+0x4a0> <== NOT EXECUTED
2040d6c: a2 04 40 15 add %l1, %l5, %l1 <== NOT EXECUTED
fat_fd->fat_file_size :
fs_info->fat.vol.bpc;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
2040d70: ba 10 20 00 clr %i5 <== NOT EXECUTED
2040d74: a8 10 20 00 clr %l4 <== NOT EXECUTED
2040d78: b6 10 3f ff mov -1, %i3 <== NOT EXECUTED
2040d7c: b4 10 20 00 clr %i2 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
while (count > 0)
2040d80: 80 a4 a0 00 cmp %l2, 0 <== NOT EXECUTED
2040d84: 32 bf ff 00 bne,a 2040984 <msdos_dir_read+0xa4> <== NOT EXECUTED
2040d88: d8 05 a0 94 ld [ %l6 + 0x94 ], %o4 <== NOT EXECUTED
break;
}
j++;
}
rtems_semaphore_release(fs_info->vol_sema);
2040d8c: d0 05 a0 90 ld [ %l6 + 0x90 ], %o0 <== NOT EXECUTED
2040d90: 7f ff 32 13 call 200d5dc <rtems_semaphore_release> <== NOT EXECUTED
2040d94: b2 10 00 1a mov %i2, %i1 <== NOT EXECUTED
return cmpltd;
}
2040d98: 81 c7 e0 08 ret <== NOT EXECUTED
2040d9c: 91 e8 00 19 restore %g0, %i1, %o0 <== 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);
2040da0: 40 00 20 f8 call 2049180 <strlen> <== NOT EXECUTED
2040da4: 90 07 be fc add %fp, -260, %o0 <== NOT EXECUTED
2040da8: 10 bf ff cf b 2040ce4 <msdos_dir_read+0x404> <== NOT EXECUTED
2040dac: d0 37 be fa sth %o0, [ %fp + -262 ] <== NOT EXECUTED
{};
/*
* extension is not empty
*/
if (i > 0) {
*dst++ = '.'; /* append dot */
2040db0: 82 10 20 2e mov 0x2e, %g1 <== NOT EXECUTED
len += i + 1; /* extension + dot */
2040db4: 9e 06 e0 01 add %i3, 1, %o7 <== NOT EXECUTED
{};
/*
* extension is not empty
*/
if (i > 0) {
*dst++ = '.'; /* append dot */
2040db8: c2 29 00 00 stb %g1, [ %g4 ] <== NOT EXECUTED
len += i + 1; /* extension + dot */
2040dbc: 86 00 c0 0f add %g3, %o7, %g3 <== NOT EXECUTED
src_tmp = src + MSDOS_SHORT_BASE_LEN;
while (i-- > 0) {
*dst++ = tolower((unsigned char)(*src_tmp++));
2040dc0: 03 00 81 af sethi %hi(0x206bc00), %g1 <== NOT EXECUTED
{};
/*
* extension is not empty
*/
if (i > 0) {
*dst++ = '.'; /* append dot */
2040dc4: 96 01 20 01 add %g4, 1, %o3 <== NOT EXECUTED
len += i + 1; /* extension + dot */
src_tmp = src + MSDOS_SHORT_BASE_LEN;
while (i-- > 0) {
*dst++ = tolower((unsigned char)(*src_tmp++));
2040dc8: d8 00 61 d0 ld [ %g1 + 0x1d0 ], %o4 <== NOT EXECUTED
2040dcc: 10 bf ff ba b 2040cb4 <msdos_dir_read+0x3d4> <== NOT EXECUTED
2040dd0: 9e 10 20 00 clr %o7 <== NOT EXECUTED
j++;
}
rtems_semaphore_release(fs_info->vol_sema);
return cmpltd;
}
2040dd4: b0 10 00 19 mov %i1, %i0 <== NOT EXECUTED
2040dd8: 81 c7 e0 08 ret <== NOT EXECUTED
2040ddc: 81 e8 00 00 restore <== NOT EXECUTED
02040de0 <msdos_dir_stat>:
int
msdos_dir_stat(
const rtems_filesystem_location_info_t *loc,
struct stat *buf
)
{
2040de0: 9d e3 bf a0 save %sp, -96, %sp
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = loc->mt_entry->fs_info;
2040de4: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
fat_file_fd_t *fat_fd = loc->node_access;
2040de8: f8 06 20 08 ld [ %i0 + 8 ], %i4
const 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;
2040dec: fa 00 60 08 ld [ %g1 + 8 ], %i5
fat_file_fd_t *fat_fd = loc->node_access;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
2040df0: 92 10 20 00 clr %o1
2040df4: d0 07 60 90 ld [ %i5 + 0x90 ], %o0
2040df8: 7f ff 31 af call 200d4b4 <rtems_semaphore_obtain>
2040dfc: 94 10 20 00 clr %o2
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
2040e00: 80 a2 20 00 cmp %o0, 0
2040e04: 22 80 00 08 be,a 2040e24 <msdos_dir_stat+0x44> <== ALWAYS TAKEN
2040e08: c2 07 60 58 ld [ %i5 + 0x58 ], %g1
rtems_set_errno_and_return_minus_one(EIO);
2040e0c: 40 00 04 f8 call 20421ec <__errno> <== NOT EXECUTED
2040e10: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
2040e14: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
2040e18: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
2040e1c: 81 c7 e0 08 ret <== NOT EXECUTED
2040e20: 81 e8 00 00 restore <== NOT EXECUTED
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;
rtems_semaphore_release(fs_info->vol_sema);
2040e24: d0 07 60 90 ld [ %i5 + 0x90 ], %o0
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 = rtems_disk_get_device_identifier(fs_info->fat.vol.dd);
2040e28: c4 18 40 00 ldd [ %g1 ], %g2
buf->st_ino = fat_fd->ino;
2040e2c: c2 07 20 0c ld [ %i4 + 0xc ], %g1
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 = rtems_disk_get_device_identifier(fs_info->fat.vol.dd);
2040e30: c4 3e 40 00 std %g2, [ %i1 ]
buf->st_ino = fat_fd->ino;
2040e34: c2 26 60 08 st %g1, [ %i1 + 8 ]
buf->st_mode = S_IFDIR | S_IRWXU | S_IRWXG | S_IRWXO;
2040e38: 03 00 00 10 sethi %hi(0x4000), %g1
2040e3c: 82 10 61 ff or %g1, 0x1ff, %g1 ! 41ff <PROM_START+0x41ff>
2040e40: c2 26 60 0c st %g1, [ %i1 + 0xc ]
buf->st_rdev = 0ll;
buf->st_size = fat_fd->fat_file_size;
2040e44: c2 07 20 18 ld [ %i4 + 0x18 ], %g1
rtems_set_errno_and_return_minus_one(EIO);
buf->st_dev = rtems_disk_get_device_identifier(fs_info->fat.vol.dd);
buf->st_ino = fat_fd->ino;
buf->st_mode = S_IFDIR | S_IRWXU | S_IRWXG | S_IRWXO;
buf->st_rdev = 0ll;
2040e48: c0 26 60 18 clr [ %i1 + 0x18 ]
buf->st_size = fat_fd->fat_file_size;
2040e4c: c2 26 60 24 st %g1, [ %i1 + 0x24 ]
buf->st_blocks = fat_fd->fat_file_size >> FAT_SECTOR512_BITS;
2040e50: 83 30 60 09 srl %g1, 9, %g1
2040e54: c2 26 60 44 st %g1, [ %i1 + 0x44 ]
buf->st_blksize = fs_info->fat.vol.bps;
2040e58: c2 17 40 00 lduh [ %i5 ], %g1
rtems_set_errno_and_return_minus_one(EIO);
buf->st_dev = rtems_disk_get_device_identifier(fs_info->fat.vol.dd);
buf->st_ino = fat_fd->ino;
buf->st_mode = S_IFDIR | S_IRWXU | S_IRWXG | S_IRWXO;
buf->st_rdev = 0ll;
2040e5c: c0 26 60 1c clr [ %i1 + 0x1c ]
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;
2040e60: c2 26 60 40 st %g1, [ %i1 + 0x40 ]
buf->st_mtime = fat_fd->mtime;
2040e64: c2 07 20 40 ld [ %i4 + 0x40 ], %g1
buf->st_dev = rtems_disk_get_device_identifier(fs_info->fat.vol.dd);
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;
2040e68: c0 26 60 20 clr [ %i1 + 0x20 ]
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;
2040e6c: c2 26 60 30 st %g1, [ %i1 + 0x30 ]
rtems_semaphore_release(fs_info->vol_sema);
2040e70: 7f ff 31 db call 200d5dc <rtems_semaphore_release>
2040e74: b0 10 20 00 clr %i0
return RC_OK;
}
2040e78: 81 c7 e0 08 ret
2040e7c: 81 e8 00 00 restore
02034828 <msdos_eval_token>:
rtems_filesystem_eval_path_context_t *ctx,
void *arg,
const char *token,
size_t tokenlen
)
{
2034828: 9d e3 bf a0 save %sp, -96, %sp
static inline bool rtems_filesystem_is_current_directory(
const char *token,
size_t tokenlen
)
{
return tokenlen == 1 && token [0] == '.';
203482c: 82 10 20 00 clr %g1
2034830: 80 a6 e0 01 cmp %i3, 1
2034834: 12 80 00 06 bne 203484c <msdos_eval_token+0x24>
2034838: ba 10 00 18 mov %i0, %i5
203483c: c2 4e 80 00 ldsb [ %i2 ], %g1
2034840: 82 18 60 2e xor %g1, 0x2e, %g1
2034844: 80 a0 00 01 cmp %g0, %g1
2034848: 82 60 3f ff subx %g0, -1, %g1
rtems_filesystem_eval_path_generic_status status =
RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_DONE;
if (rtems_filesystem_is_current_directory(token, tokenlen)) {
203484c: 80 a0 60 00 cmp %g1, 0
2034850: 02 80 00 05 be 2034864 <msdos_eval_token+0x3c>
2034854: b0 10 20 00 clr %i0
static inline void rtems_filesystem_eval_path_clear_token(
rtems_filesystem_eval_path_context_t *ctx
)
{
ctx->tokenlen = 0;
2034858: c0 27 60 0c clr [ %i5 + 0xc ]
203485c: 81 c7 e0 08 ret
2034860: 81 e8 00 00 restore
rtems_filesystem_eval_path_clear_token(ctx);
status = RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_CONTINUE;
} else {
rtems_filesystem_location_info_t *currentloc =
rtems_filesystem_eval_path_get_currentloc(ctx);
int rc = msdos_find_name(currentloc, token, tokenlen);
2034864: 90 07 60 18 add %i5, 0x18, %o0
2034868: 92 10 00 1a mov %i2, %o1
203486c: 40 00 05 aa call 2035f14 <msdos_find_name>
2034870: 94 10 00 1b mov %i3, %o2
if (rc == RC_OK) {
2034874: 80 a2 20 00 cmp %o0, 0
2034878: 12 80 00 12 bne 20348c0 <msdos_eval_token+0x98>
203487c: 03 00 00 1f sethi %hi(0x7c00), %g1
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)
2034880: c4 07 60 20 ld [ %i5 + 0x20 ], %g2
* None
*/
static void
msdos_set_handlers(rtems_filesystem_location_info_t *loc)
{
msdos_fs_info_t *fs_info = loc->mt_entry->fs_info;
2034884: c2 07 60 2c ld [ %i5 + 0x2c ], %g1
fat_file_fd_t *fat_fd = loc->node_access;
if (fat_fd->fat_file_type == FAT_DIRECTORY)
2034888: c4 00 a0 10 ld [ %g2 + 0x10 ], %g2
203488c: c0 27 60 0c clr [ %i5 + 0xc ]
2034890: 80 a0 a0 00 cmp %g2, 0
2034894: 12 80 00 04 bne 20348a4 <msdos_eval_token+0x7c>
2034898: c2 00 60 08 ld [ %g1 + 8 ], %g1
loc->handlers = fs_info->directory_handlers;
203489c: 10 80 00 03 b 20348a8 <msdos_eval_token+0x80>
20348a0: c2 00 60 88 ld [ %g1 + 0x88 ], %g1
else
loc->handlers = fs_info->file_handlers;
20348a4: c2 00 60 8c ld [ %g1 + 0x8c ], %g1
20348a8: c2 27 60 28 st %g1, [ %i5 + 0x28 ]
int rc = msdos_find_name(currentloc, token, tokenlen);
if (rc == RC_OK) {
rtems_filesystem_eval_path_clear_token(ctx);
msdos_set_handlers(currentloc);
if (rtems_filesystem_eval_path_has_path(ctx)) {
20348ac: c2 07 60 04 ld [ %i5 + 4 ], %g1
void *arg,
const char *token,
size_t tokenlen
)
{
rtems_filesystem_eval_path_generic_status status =
20348b0: 80 a0 00 01 cmp %g0, %g1
20348b4: b0 60 3f ff subx %g0, -1, %i0
20348b8: 81 c7 e0 08 ret
20348bc: 81 e8 00 00 restore
rtems_filesystem_eval_path_clear_token(ctx);
msdos_set_handlers(currentloc);
if (rtems_filesystem_eval_path_has_path(ctx)) {
status = RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_CONTINUE;
}
} else if (rc == MSDOS_NAME_NOT_FOUND_ERR) {
20348c0: 82 10 61 01 or %g1, 0x101, %g1
20348c4: 80 a2 00 01 cmp %o0, %g1
20348c8: 02 bf ff e5 be 203485c <msdos_eval_token+0x34> <== ALWAYS TAKEN
20348cc: b0 10 20 02 mov 2, %i0
status = RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_NO_ENTRY;
} else {
rtems_filesystem_eval_path_error(ctx, 0);
20348d0: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
20348d4: 92 10 20 00 clr %o1 <== NOT EXECUTED
20348d8: 7f ff 56 71 call 200a29c <rtems_filesystem_eval_path_error><== NOT EXECUTED
20348dc: b0 10 20 01 mov 1, %i0 <== NOT EXECUTED
}
}
return status;
}
20348e0: 81 c7 e0 08 ret <== NOT EXECUTED
20348e4: 81 e8 00 00 restore <== NOT EXECUTED
02040edc <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)
{
2040edc: 9d e3 bf a0 save %sp, -96, %sp
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
2040ee0: c2 06 20 28 ld [ %i0 + 0x28 ], %g1
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
2040ee4: 92 10 20 00 clr %o1
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;
2040ee8: fa 00 60 08 ld [ %g1 + 8 ], %i5
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
2040eec: 94 10 20 00 clr %o2
2040ef0: 7f ff 31 71 call 200d4b4 <rtems_semaphore_obtain>
2040ef4: d0 07 60 90 ld [ %i5 + 0x90 ], %o0
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
2040ef8: 80 a2 20 00 cmp %o0, 0
2040efc: 02 80 00 08 be 2040f1c <msdos_file_close+0x40> <== ALWAYS TAKEN
2040f00: 01 00 00 00 nop
rtems_set_errno_and_return_minus_one(EIO);
2040f04: 40 00 04 ba call 20421ec <__errno> <== NOT EXECUTED
2040f08: b0 10 3f ff mov -1, %i0 ! ffffffff <RAM_END+0xfdbfffff> <== NOT EXECUTED
2040f0c: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
2040f10: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
2040f14: 81 c7 e0 08 ret <== NOT EXECUTED
2040f18: 81 e8 00 00 restore <== NOT EXECUTED
rc = msdos_file_update(iop);
2040f1c: 7f ff ff d9 call 2040e80 <msdos_file_update>
2040f20: 90 10 00 18 mov %i0, %o0
2040f24: b0 10 00 08 mov %o0, %i0
rtems_semaphore_release(fs_info->vol_sema);
2040f28: 7f ff 31 ad call 200d5dc <rtems_semaphore_release>
2040f2c: d0 07 60 90 ld [ %i5 + 0x90 ], %o0
return rc;
}
2040f30: 81 c7 e0 08 ret
2040f34: 81 e8 00 00 restore
02041138 <msdos_file_ftruncate>:
* RETURNS:
* RC_OK on success, or -1 if error occured (errno set appropriately).
*/
int
msdos_file_ftruncate(rtems_libio_t *iop, off_t length)
{
2041138: 9d e3 bf 98 save %sp, -104, %sp
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
204113c: c2 06 20 28 ld [ %i0 + 0x28 ], %g1
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
2041140: f8 06 20 1c ld [ %i0 + 0x1c ], %i4
int
msdos_file_ftruncate(rtems_libio_t *iop, off_t length)
{
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
2041144: fa 00 60 08 ld [ %g1 + 8 ], %i5
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
uint32_t old_length;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
2041148: 92 10 20 00 clr %o1
204114c: d0 07 60 90 ld [ %i5 + 0x90 ], %o0
2041150: 7f ff 30 d9 call 200d4b4 <rtems_semaphore_obtain>
2041154: 94 10 20 00 clr %o2
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
2041158: 80 a2 20 00 cmp %o0, 0
204115c: 02 80 00 08 be 204117c <msdos_file_ftruncate+0x44> <== ALWAYS TAKEN
2041160: 80 a2 00 19 cmp %o0, %i1
rtems_set_errno_and_return_minus_one(EIO);
2041164: 40 00 04 22 call 20421ec <__errno> <== NOT EXECUTED
2041168: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
204116c: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
2041170: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
2041174: 81 c7 e0 08 ret <== NOT EXECUTED
2041178: 81 e8 00 00 restore <== NOT EXECUTED
old_length = fat_fd->fat_file_size;
if (length < old_length) {
204117c: 14 80 00 08 bg 204119c <msdos_file_ftruncate+0x64> <== NEVER TAKEN
2041180: f6 07 20 18 ld [ %i4 + 0x18 ], %i3
2041184: 80 a2 00 19 cmp %o0, %i1
2041188: 12 80 00 0d bne 20411bc <msdos_file_ftruncate+0x84> <== NEVER TAKEN
204118c: 90 10 00 1d mov %i5, %o0
2041190: 80 a6 c0 1a cmp %i3, %i2
2041194: 08 80 00 0b bleu 20411c0 <msdos_file_ftruncate+0x88>
2041198: 92 10 00 1c mov %i4, %o1
rc = fat_file_truncate(&fs_info->fat, fat_fd, length);
204119c: 90 10 00 1d mov %i5, %o0
20411a0: 92 10 00 1c mov %i4, %o1
20411a4: 7f ff 91 c9 call 20258c8 <fat_file_truncate>
20411a8: 94 10 00 1a mov %i2, %o2
errno = ENOSPC;
rc = -1;
}
}
if (rc == RC_OK) {
20411ac: b0 92 20 00 orcc %o0, 0, %i0
20411b0: 22 80 00 18 be,a 2041210 <msdos_file_ftruncate+0xd8> <== ALWAYS TAKEN
20411b4: f4 27 20 18 st %i2, [ %i4 + 0x18 ]
20411b8: 30 80 00 16 b,a 2041210 <msdos_file_ftruncate+0xd8> <== NOT EXECUTED
if (length < old_length) {
rc = fat_file_truncate(&fs_info->fat, fat_fd, length);
} else {
uint32_t new_length;
rc = fat_file_extend(&fs_info->fat,
20411bc: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
20411c0: 94 10 20 01 mov 1, %o2
20411c4: 96 10 00 1a mov %i2, %o3
20411c8: 7f ff 92 66 call 2025b60 <fat_file_extend>
20411cc: 98 07 bf fc add %fp, -4, %o4
fat_fd,
true,
length,
&new_length);
if (rc == RC_OK && length != new_length) {
20411d0: b0 92 20 00 orcc %o0, 0, %i0
20411d4: 12 80 00 0f bne 2041210 <msdos_file_ftruncate+0xd8> <== NEVER TAKEN
20411d8: 80 a6 60 00 cmp %i1, 0
20411dc: 12 80 00 05 bne 20411f0 <msdos_file_ftruncate+0xb8> <== NEVER TAKEN
20411e0: c2 07 bf fc ld [ %fp + -4 ], %g1
20411e4: 80 a6 80 01 cmp %i2, %g1
20411e8: 22 80 00 0a be,a 2041210 <msdos_file_ftruncate+0xd8> <== ALWAYS TAKEN
20411ec: f4 27 20 18 st %i2, [ %i4 + 0x18 ]
fat_file_truncate(&fs_info->fat, fat_fd, old_length);
20411f0: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
20411f4: 94 10 00 1b mov %i3, %o2 <== NOT EXECUTED
20411f8: 7f ff 91 b4 call 20258c8 <fat_file_truncate> <== NOT EXECUTED
20411fc: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
errno = ENOSPC;
2041200: 40 00 03 fb call 20421ec <__errno> <== NOT EXECUTED
2041204: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
2041208: 82 10 20 1c mov 0x1c, %g1 <== NOT EXECUTED
204120c: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
if (rc == RC_OK) {
fat_fd->fat_file_size = length;
}
rtems_semaphore_release(fs_info->vol_sema);
2041210: 7f ff 30 f3 call 200d5dc <rtems_semaphore_release>
2041214: d0 07 60 90 ld [ %i5 + 0x90 ], %o0
return rc;
}
2041218: 81 c7 e0 08 ret
204121c: 81 e8 00 00 restore
02040f38 <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)
{
2040f38: 9d e3 bf a0 save %sp, -96, %sp
ssize_t ret = 0;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
2040f3c: c2 06 20 28 ld [ %i0 + 0x28 ], %g1
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
2040f40: fa 06 20 1c ld [ %i0 + 0x1c ], %i5
ssize_t
msdos_file_read(rtems_libio_t *iop, void *buffer, size_t count)
{
ssize_t ret = 0;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
2040f44: e0 00 60 08 ld [ %g1 + 8 ], %l0
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
2040f48: 92 10 20 00 clr %o1
2040f4c: d0 04 20 90 ld [ %l0 + 0x90 ], %o0
2040f50: 94 10 20 00 clr %o2
2040f54: 7f ff 31 58 call 200d4b4 <rtems_semaphore_obtain>
2040f58: b6 10 00 18 mov %i0, %i3
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
2040f5c: 80 a2 20 00 cmp %o0, 0
2040f60: 22 80 00 08 be,a 2040f80 <msdos_file_read+0x48> <== ALWAYS TAKEN
2040f64: d4 06 20 0c ld [ %i0 + 0xc ], %o2
rtems_set_errno_and_return_minus_one(EIO);
2040f68: 40 00 04 a1 call 20421ec <__errno> <== NOT EXECUTED
2040f6c: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
2040f70: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
2040f74: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
2040f78: 81 c7 e0 08 ret <== NOT EXECUTED
2040f7c: 81 e8 00 00 restore <== NOT EXECUTED
ret = fat_file_read(&fs_info->fat, fat_fd, iop->offset, count,
2040f80: 90 10 00 10 mov %l0, %o0
2040f84: 92 10 00 1d mov %i5, %o1
2040f88: 96 10 00 1a mov %i2, %o3
2040f8c: 7f ff 91 e1 call 2025710 <fat_file_read>
2040f90: 98 10 00 19 mov %i1, %o4
buffer);
if (ret > 0)
2040f94: b0 92 20 00 orcc %o0, 0, %i0
2040f98: 04 80 00 06 ble 2040fb0 <msdos_file_read+0x78>
2040f9c: 85 3e 20 1f sra %i0, 0x1f, %g2
iop->offset += ret;
2040fa0: f8 1e e0 08 ldd [ %i3 + 8 ], %i4
2040fa4: 86 87 40 18 addcc %i5, %i0, %g3
2040fa8: 84 47 00 02 addx %i4, %g2, %g2
2040fac: c4 3e e0 08 std %g2, [ %i3 + 8 ]
rtems_semaphore_release(fs_info->vol_sema);
2040fb0: 7f ff 31 8b call 200d5dc <rtems_semaphore_release>
2040fb4: d0 04 20 90 ld [ %l0 + 0x90 ], %o0
return ret;
}
2040fb8: 81 c7 e0 08 ret
2040fbc: 81 e8 00 00 restore
02041098 <msdos_file_stat>:
int
msdos_file_stat(
const rtems_filesystem_location_info_t *loc,
struct stat *buf
)
{
2041098: 9d e3 bf a0 save %sp, -96, %sp
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = loc->mt_entry->fs_info;
204109c: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
fat_file_fd_t *fat_fd = loc->node_access;
20410a0: f8 06 20 08 ld [ %i0 + 8 ], %i4
const 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;
20410a4: fa 00 60 08 ld [ %g1 + 8 ], %i5
fat_file_fd_t *fat_fd = loc->node_access;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
20410a8: 92 10 20 00 clr %o1
20410ac: d0 07 60 90 ld [ %i5 + 0x90 ], %o0
20410b0: 7f ff 31 01 call 200d4b4 <rtems_semaphore_obtain>
20410b4: 94 10 20 00 clr %o2
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
20410b8: 80 a2 20 00 cmp %o0, 0
20410bc: 22 80 00 08 be,a 20410dc <msdos_file_stat+0x44> <== ALWAYS TAKEN
20410c0: c2 07 60 58 ld [ %i5 + 0x58 ], %g1
rtems_set_errno_and_return_minus_one(EIO);
20410c4: 40 00 04 4a call 20421ec <__errno> <== NOT EXECUTED
20410c8: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
20410cc: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
20410d0: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
20410d4: 81 c7 e0 08 ret <== NOT EXECUTED
20410d8: 81 e8 00 00 restore <== NOT EXECUTED
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;
rtems_semaphore_release(fs_info->vol_sema);
20410dc: d0 07 60 90 ld [ %i5 + 0x90 ], %o0
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 = rtems_disk_get_device_identifier(fs_info->fat.vol.dd);
20410e0: c4 18 40 00 ldd [ %g1 ], %g2
buf->st_ino = fat_fd->ino;
20410e4: c2 07 20 0c ld [ %i4 + 0xc ], %g1
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 = rtems_disk_get_device_identifier(fs_info->fat.vol.dd);
20410e8: c4 3e 40 00 std %g2, [ %i1 ]
buf->st_ino = fat_fd->ino;
20410ec: c2 26 60 08 st %g1, [ %i1 + 8 ]
buf->st_mode = S_IFREG | S_IRWXU | S_IRWXG | S_IRWXO;
20410f0: 03 00 00 20 sethi %hi(0x8000), %g1
20410f4: 82 10 61 ff or %g1, 0x1ff, %g1 ! 81ff <PROM_START+0x81ff>
20410f8: c2 26 60 0c st %g1, [ %i1 + 0xc ]
buf->st_rdev = 0ll;
buf->st_size = fat_fd->fat_file_size;
20410fc: c2 07 20 18 ld [ %i4 + 0x18 ], %g1
rtems_set_errno_and_return_minus_one(EIO);
buf->st_dev = rtems_disk_get_device_identifier(fs_info->fat.vol.dd);
buf->st_ino = fat_fd->ino;
buf->st_mode = S_IFREG | S_IRWXU | S_IRWXG | S_IRWXO;
buf->st_rdev = 0ll;
2041100: c0 26 60 18 clr [ %i1 + 0x18 ]
buf->st_size = fat_fd->fat_file_size;
2041104: c2 26 60 24 st %g1, [ %i1 + 0x24 ]
buf->st_blocks = fat_fd->fat_file_size >> FAT_SECTOR512_BITS;
2041108: 83 30 60 09 srl %g1, 9, %g1
204110c: c2 26 60 44 st %g1, [ %i1 + 0x44 ]
buf->st_blksize = fs_info->fat.vol.bps;
2041110: c2 17 40 00 lduh [ %i5 ], %g1
rtems_set_errno_and_return_minus_one(EIO);
buf->st_dev = rtems_disk_get_device_identifier(fs_info->fat.vol.dd);
buf->st_ino = fat_fd->ino;
buf->st_mode = S_IFREG | S_IRWXU | S_IRWXG | S_IRWXO;
buf->st_rdev = 0ll;
2041114: c0 26 60 1c clr [ %i1 + 0x1c ]
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;
2041118: c2 26 60 40 st %g1, [ %i1 + 0x40 ]
buf->st_mtime = fat_fd->mtime;
204111c: c2 07 20 40 ld [ %i4 + 0x40 ], %g1
buf->st_dev = rtems_disk_get_device_identifier(fs_info->fat.vol.dd);
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;
2041120: c0 26 60 20 clr [ %i1 + 0x20 ]
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;
2041124: c2 26 60 30 st %g1, [ %i1 + 0x30 ]
rtems_semaphore_release(fs_info->vol_sema);
2041128: 7f ff 31 2d call 200d5dc <rtems_semaphore_release>
204112c: b0 10 20 00 clr %i0
return RC_OK;
}
2041130: 81 c7 e0 08 ret
2041134: 81 e8 00 00 restore
02041220 <msdos_file_sync>:
* RETURNS:
* RC_OK on success, or -1 if error occured (errno set appropriately)
*/
int
msdos_file_sync(rtems_libio_t *iop)
{
2041220: 9d e3 bf a0 save %sp, -96, %sp
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
2041224: c2 06 20 28 ld [ %i0 + 0x28 ], %g1
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
2041228: 92 10 20 00 clr %o1
int
msdos_file_sync(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;
204122c: fa 00 60 08 ld [ %g1 + 8 ], %i5
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
2041230: 94 10 20 00 clr %o2
2041234: 7f ff 30 a0 call 200d4b4 <rtems_semaphore_obtain>
2041238: d0 07 60 90 ld [ %i5 + 0x90 ], %o0
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
204123c: 80 a2 20 00 cmp %o0, 0
2041240: 02 80 00 08 be 2041260 <msdos_file_sync+0x40> <== ALWAYS TAKEN
2041244: 01 00 00 00 nop
rtems_set_errno_and_return_minus_one(EIO);
2041248: 40 00 03 e9 call 20421ec <__errno> <== NOT EXECUTED
204124c: b0 10 3f ff mov -1, %i0 ! ffffffff <RAM_END+0xfdbfffff> <== NOT EXECUTED
2041250: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
2041254: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
2041258: 81 c7 e0 08 ret <== NOT EXECUTED
204125c: 81 e8 00 00 restore <== NOT EXECUTED
rc = msdos_file_update(iop);
2041260: 7f ff ff 08 call 2040e80 <msdos_file_update>
2041264: 90 10 00 18 mov %i0, %o0
if (rc != RC_OK)
2041268: b0 92 20 00 orcc %o0, 0, %i0
204126c: 12 80 00 04 bne 204127c <msdos_file_sync+0x5c> <== NEVER TAKEN
2041270: 01 00 00 00 nop
{
rtems_semaphore_release(fs_info->vol_sema);
return rc;
}
rc = msdos_sync_unprotected(fs_info);
2041274: 7f ff d3 ad call 2036128 <msdos_sync_unprotected>
2041278: 90 10 00 1d mov %i5, %o0
rtems_semaphore_release(fs_info->vol_sema);
204127c: 7f ff 30 d8 call 200d5dc <rtems_semaphore_release>
2041280: d0 07 60 90 ld [ %i5 + 0x90 ], %o0
return RC_OK;
}
2041284: 81 c7 e0 08 ret
2041288: 81 e8 00 00 restore
02040e80 <msdos_file_update>:
#include "msdos.h"
static int
msdos_file_update(rtems_libio_t *iop)
{
2040e80: 9d e3 bf a0 save %sp, -96, %sp
int rc = RC_OK;
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
2040e84: f2 06 20 1c ld [ %i0 + 0x1c ], %i1
/*
* 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))
2040e88: c2 0e 60 30 ldub [ %i1 + 0x30 ], %g1
2040e8c: 80 88 60 01 btst 1, %g1
2040e90: 12 80 00 11 bne 2040ed4 <msdos_file_update+0x54> <== NEVER TAKEN
2040e94: 90 10 20 00 clr %o0
{
rc = msdos_set_first_cluster_num(iop->pathinfo.mt_entry, fat_fd);
2040e98: d0 06 20 28 ld [ %i0 + 0x28 ], %o0
2040e9c: 7f ff cf 8f call 2034cd8 <msdos_set_first_cluster_num>
2040ea0: 92 10 00 19 mov %i1, %o1
if (rc != RC_OK)
2040ea4: 80 a2 20 00 cmp %o0, 0
2040ea8: 12 80 00 0b bne 2040ed4 <msdos_file_update+0x54> <== NEVER TAKEN
2040eac: 01 00 00 00 nop
{
return rc;
}
rc = msdos_set_file_size(iop->pathinfo.mt_entry, fat_fd);
2040eb0: d0 06 20 28 ld [ %i0 + 0x28 ], %o0
2040eb4: 7f ff cf bb call 2034da0 <msdos_set_file_size>
2040eb8: 92 10 00 19 mov %i1, %o1
if (rc != RC_OK)
2040ebc: 80 a2 20 00 cmp %o0, 0
2040ec0: 12 80 00 05 bne 2040ed4 <msdos_file_update+0x54> <== NEVER TAKEN
2040ec4: 01 00 00 00 nop
{
return rc;
}
rc = msdos_set_dir_wrt_time_and_date(iop->pathinfo.mt_entry, fat_fd);
2040ec8: f0 06 20 28 ld [ %i0 + 0x28 ], %i0
2040ecc: 7f ff cf 48 call 2034bec <msdos_set_dir_wrt_time_and_date>
2040ed0: 81 e8 00 00 restore
return rc;
}
}
return rc;
}
2040ed4: 81 c7 e0 08 ret <== NOT EXECUTED
2040ed8: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED
02040fc0 <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)
{
2040fc0: 9d e3 bf a0 save %sp, -96, %sp
ssize_t ret = 0;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
2040fc4: c2 06 20 28 ld [ %i0 + 0x28 ], %g1
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
2040fc8: e2 06 20 1c ld [ %i0 + 0x1c ], %l1
ssize_t
msdos_file_write(rtems_libio_t *iop,const void *buffer, size_t count)
{
ssize_t ret = 0;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
2040fcc: e0 00 60 08 ld [ %g1 + 8 ], %l0
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
2040fd0: 92 10 20 00 clr %o1
2040fd4: d0 04 20 90 ld [ %l0 + 0x90 ], %o0
2040fd8: 94 10 20 00 clr %o2
2040fdc: 7f ff 31 36 call 200d4b4 <rtems_semaphore_obtain>
2040fe0: b6 10 00 18 mov %i0, %i3
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
2040fe4: 80 a2 20 00 cmp %o0, 0
2040fe8: 22 80 00 08 be,a 2041008 <msdos_file_write+0x48> <== ALWAYS TAKEN
2040fec: c2 06 20 10 ld [ %i0 + 0x10 ], %g1
rtems_set_errno_and_return_minus_one(EIO);
2040ff0: 40 00 04 7f call 20421ec <__errno> <== NOT EXECUTED
2040ff4: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
2040ff8: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
2040ffc: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
2041000: 81 c7 e0 08 ret <== NOT EXECUTED
2041004: 81 e8 00 00 restore <== NOT EXECUTED
if ((iop->flags & LIBIO_FLAGS_APPEND) != 0)
2041008: 80 88 62 00 btst 0x200, %g1
204100c: 22 80 00 06 be,a 2041024 <msdos_file_write+0x64>
2041010: d4 06 e0 0c ld [ %i3 + 0xc ], %o2
iop->offset = fat_fd->fat_file_size;
2041014: c2 04 60 18 ld [ %l1 + 0x18 ], %g1
2041018: c0 26 20 08 clr [ %i0 + 8 ]
204101c: c2 26 20 0c st %g1, [ %i0 + 0xc ]
ret = fat_file_write(&fs_info->fat, fat_fd, iop->offset, count,
2041020: d4 06 e0 0c ld [ %i3 + 0xc ], %o2
2041024: 90 10 00 10 mov %l0, %o0
2041028: 92 10 00 11 mov %l1, %o1
204102c: 96 10 00 1a mov %i2, %o3
2041030: 7f ff 93 67 call 2025dcc <fat_file_write>
2041034: 98 10 00 19 mov %i1, %o4
buffer);
if (ret < 0)
2041038: b0 92 20 00 orcc %o0, 0, %i0
204103c: 36 80 00 06 bge,a 2041054 <msdos_file_write+0x94> <== ALWAYS TAKEN
2041040: f8 1e e0 08 ldd [ %i3 + 8 ], %i4
{
rtems_semaphore_release(fs_info->vol_sema);
2041044: 7f ff 31 66 call 200d5dc <rtems_semaphore_release> <== NOT EXECUTED
2041048: d0 04 20 90 ld [ %l0 + 0x90 ], %o0 <== NOT EXECUTED
return -1;
204104c: 81 c7 e0 08 ret <== NOT EXECUTED
2041050: 91 e8 3f ff restore %g0, -1, %o0 <== NOT EXECUTED
/*
* update file size in both fat-file descriptor and file control block if
* file was extended
*/
iop->offset += ret;
2041054: 85 3e 20 1f sra %i0, 0x1f, %g2
2041058: 86 86 00 1d addcc %i0, %i5, %g3
204105c: 84 40 80 1c addx %g2, %i4, %g2
2041060: c4 3e e0 08 std %g2, [ %i3 + 8 ]
if (iop->offset > fat_fd->fat_file_size)
2041064: 80 a0 a0 00 cmp %g2, 0
2041068: 14 80 00 07 bg 2041084 <msdos_file_write+0xc4> <== NEVER TAKEN
204106c: c2 04 60 18 ld [ %l1 + 0x18 ], %g1
2041070: 80 a0 a0 00 cmp %g2, 0
2041074: 12 80 00 05 bne 2041088 <msdos_file_write+0xc8> <== NEVER TAKEN
2041078: 80 a0 c0 01 cmp %g3, %g1
204107c: 08 80 00 03 bleu 2041088 <msdos_file_write+0xc8>
2041080: 01 00 00 00 nop
fat_fd->fat_file_size = iop->offset;
2041084: c6 24 60 18 st %g3, [ %l1 + 0x18 ]
rtems_semaphore_release(fs_info->vol_sema);
2041088: 7f ff 31 55 call 200d5dc <rtems_semaphore_release>
204108c: d0 04 20 90 ld [ %l0 + 0x90 ], %o0
return ret;
}
2041090: 81 c7 e0 08 ret
2041094: 81 e8 00 00 restore
02040764 <msdos_filename_unix2dos>:
/*
* Fill the dos filename string with blanks. These are DOS's pad
* characters.
*/
for (i = 0; i <= 10; i++)
2040764: 82 10 20 00 clr %g1
dn[i] = ' ';
2040768: 84 10 20 20 mov 0x20, %g2
204076c: c4 2a 80 01 stb %g2, [ %o2 + %g1 ]
/*
* Fill the dos filename string with blanks. These are DOS's pad
* characters.
*/
for (i = 0; i <= 10; i++)
2040770: 82 00 60 01 inc %g1
2040774: 80 a0 60 0b cmp %g1, 0xb
2040778: 32 bf ff fe bne,a 2040770 <msdos_filename_unix2dos+0xc>
204077c: c4 2a 80 01 stb %g2, [ %o2 + %g1 ]
/*
* The filenames "." and ".." are handled specially, since they
* don't follow dos filename rules.
*/
if (un[0] == '.' && unlen == 1) {
2040780: c2 4a 00 00 ldsb [ %o0 ], %g1
2040784: 80 a0 60 2e cmp %g1, 0x2e
2040788: 12 80 00 12 bne 20407d0 <msdos_filename_unix2dos+0x6c> <== ALWAYS TAKEN
204078c: 80 a2 60 00 cmp %o1, 0
2040790: 80 a2 60 01 cmp %o1, 1 <== NOT EXECUTED
2040794: 32 80 00 04 bne,a 20407a4 <msdos_filename_unix2dos+0x40> <== NOT EXECUTED
2040798: c2 4a 20 01 ldsb [ %o0 + 1 ], %g1 <== NOT EXECUTED
dn[0] = '.';
return 0;
204079c: 10 80 00 4f b 20408d8 <msdos_filename_unix2dos+0x174> <== NOT EXECUTED
20407a0: c2 2a 80 00 stb %g1, [ %o2 ] <== NOT EXECUTED
}
if (un[0] == '.' && un[1] == '.' && unlen == 2) {
20407a4: 80 a0 60 2e cmp %g1, 0x2e <== NOT EXECUTED
20407a8: 12 80 00 0a bne 20407d0 <msdos_filename_unix2dos+0x6c> <== NOT EXECUTED
20407ac: 80 a2 60 00 cmp %o1, 0 <== NOT EXECUTED
20407b0: 80 a2 60 02 cmp %o1, 2 <== NOT EXECUTED
20407b4: 12 80 00 07 bne 20407d0 <msdos_filename_unix2dos+0x6c> <== NOT EXECUTED
20407b8: 80 a2 60 00 cmp %o1, 0 <== NOT EXECUTED
dn[0] = '.';
20407bc: c2 2a 80 00 stb %g1, [ %o2 ] <== NOT EXECUTED
dn[1] = '.';
return 0;
20407c0: 10 80 00 46 b 20408d8 <msdos_filename_unix2dos+0x174> <== NOT EXECUTED
20407c4: c2 2a a0 01 stb %g1, [ %o2 + 1 ] <== NOT EXECUTED
/*
* Remove any dots from the start of a file name.
*/
while (unlen && (*un == '.')) {
un++;
unlen--;
20407c8: 92 02 7f ff add %o1, -1, %o1 <== NOT EXECUTED
}
/*
* Remove any dots from the start of a file name.
*/
while (unlen && (*un == '.')) {
20407cc: 80 a2 60 00 cmp %o1, 0 <== NOT EXECUTED
20407d0: 32 80 00 05 bne,a 20407e4 <msdos_filename_unix2dos+0x80> <== ALWAYS TAKEN
20407d4: c2 4a 00 00 ldsb [ %o0 ], %g1
/*
* Fill the dos filename string with blanks. These are DOS's pad
* characters.
*/
for (i = 0; i <= 10; i++)
20407d8: 82 10 20 00 clr %g1 <== NOT EXECUTED
* 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)
20407dc: 10 80 00 0d b 2040810 <msdos_filename_unix2dos+0xac>
20407e0: 1b 00 81 a6 sethi %hi(0x2069800), %o5
}
/*
* Remove any dots from the start of a file name.
*/
while (unlen && (*un == '.')) {
20407e4: 80 a0 60 2e cmp %g1, 0x2e
20407e8: 22 bf ff f8 be,a 20407c8 <msdos_filename_unix2dos+0x64> <== NEVER TAKEN
20407ec: 90 02 20 01 inc %o0 <== NOT EXECUTED
/*
* Fill the dos filename string with blanks. These are DOS's pad
* characters.
*/
for (i = 0; i <= 10; i++)
20407f0: 10 bf ff fb b 20407dc <msdos_filename_unix2dos+0x78>
20407f4: 82 10 20 00 clr %g1
* 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)
20407f8: c8 0b 00 04 ldub [ %o4 + %g4 ], %g4
20407fc: 80 89 20 ff btst 0xff, %g4
2040800: 02 80 00 1a be 2040868 <msdos_filename_unix2dos+0x104>
2040804: 80 a0 a0 00 cmp %g2, 0
break;
dn[i] = msdos_map[c];
2040808: c8 2a 80 01 stb %g4, [ %o2 + %g1 ]
* 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++) {
204080c: 82 00 60 01 inc %g1
2040810: 84 a2 40 01 subcc %o1, %g1, %g2
2040814: 02 80 00 14 be 2040864 <msdos_filename_unix2dos+0x100>
2040818: 86 02 00 01 add %o0, %g1, %g3
204081c: 80 a0 60 07 cmp %g1, 7
2040820: 04 80 00 03 ble 204082c <msdos_filename_unix2dos+0xc8>
2040824: 88 10 20 01 mov 1, %g4
2040828: 88 10 20 00 clr %g4
204082c: 80 89 20 ff btst 0xff, %g4
2040830: 02 80 00 0e be 2040868 <msdos_filename_unix2dos+0x104>
2040834: 80 a0 a0 00 cmp %g2, 0
2040838: c8 0a 00 01 ldub [ %o0 + %g1 ], %g4
204083c: 80 a1 20 00 cmp %g4, 0
2040840: 02 80 00 09 be 2040864 <msdos_filename_unix2dos+0x100> <== NEVER TAKEN
2040844: 80 a1 20 2e cmp %g4, 0x2e
2040848: 12 bf ff ec bne 20407f8 <msdos_filename_unix2dos+0x94>
204084c: 98 13 63 e8 or %o5, 0x3e8, %o4
/*
* Strip any further characters up to a '.' or the end of the
* string.
*/
while (unlen && (c = *un)) {
2040850: 10 80 00 06 b 2040868 <msdos_filename_unix2dos+0x104>
2040854: 80 a0 a0 00 cmp %g2, 0
un++;
unlen--;
/* Make sure we've skipped over the dot before stopping. */
if (c == '.')
2040858: 80 a0 60 2e cmp %g1, 0x2e
204085c: 02 80 00 09 be 2040880 <msdos_filename_unix2dos+0x11c>
2040860: 84 00 bf ff add %g2, -1, %g2
/*
* Strip any further characters up to a '.' or the end of the
* string.
*/
while (unlen && (c = *un)) {
2040864: 80 a0 a0 00 cmp %g2, 0
2040868: 02 80 00 07 be 2040884 <msdos_filename_unix2dos+0x120>
204086c: 82 10 20 08 mov 8, %g1
2040870: c2 08 c0 00 ldub [ %g3 ], %g1
2040874: 80 a0 60 00 cmp %g1, 0
2040878: 32 bf ff f8 bne,a 2040858 <msdos_filename_unix2dos+0xf4> <== ALWAYS TAKEN
204087c: 86 00 e0 01 inc %g3
/*
* Fill the dos filename string with blanks. These are DOS's pad
* characters.
*/
for (i = 0; i <= 10; i++)
2040880: 82 10 20 08 mov 8, %g1
* 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)
2040884: 10 80 00 08 b 20408a4 <msdos_filename_unix2dos+0x140>
2040888: 1b 00 81 a6 sethi %hi(0x2069800), %o5
204088c: c8 0b 00 04 ldub [ %o4 + %g4 ], %g4
2040890: 80 89 20 ff btst 0xff, %g4
2040894: 02 80 00 11 be 20408d8 <msdos_filename_unix2dos+0x174> <== ALWAYS TAKEN
2040898: 84 00 bf ff add %g2, -1, %g2
break;
dn[i] = msdos_map[c];
204089c: c8 2a 80 01 stb %g4, [ %o2 + %g1 ] <== 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++) {
20408a0: 82 00 60 01 inc %g1 <== NOT EXECUTED
20408a4: 80 a0 a0 00 cmp %g2, 0
20408a8: 02 80 00 0c be 20408d8 <msdos_filename_unix2dos+0x174>
20408ac: 80 a0 60 0a cmp %g1, 0xa
20408b0: 04 80 00 03 ble 20408bc <msdos_filename_unix2dos+0x158> <== ALWAYS TAKEN
20408b4: 88 10 20 01 mov 1, %g4
20408b8: 88 10 20 00 clr %g4 <== NOT EXECUTED
20408bc: 80 89 20 ff btst 0xff, %g4
20408c0: 02 80 00 06 be 20408d8 <msdos_filename_unix2dos+0x174> <== NEVER TAKEN
20408c4: 88 00 c0 01 add %g3, %g1, %g4
20408c8: c8 09 3f f8 ldub [ %g4 + -8 ], %g4
20408cc: 80 a1 20 00 cmp %g4, 0
20408d0: 12 bf ff ef bne 204088c <msdos_filename_unix2dos+0x128> <== ALWAYS TAKEN
20408d4: 98 13 63 e8 or %o5, 0x3e8, %o4
dn[i] = msdos_map[c];
un++;
unlen--;
}
return 0;
}
20408d8: 81 c3 e0 08 retl
20408dc: 90 10 20 00 clr %o0
02035f14 <msdos_find_name>:
msdos_find_name(
rtems_filesystem_location_info_t *parent_loc,
const char *name,
int name_len
)
{
2035f14: 9d e3 bf 60 save %sp, -160, %sp
int rc = RC_OK;
msdos_fs_info_t *fs_info = parent_loc->mt_entry->fs_info;
2035f18: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
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);
2035f1c: b8 07 bf e0 add %fp, -32, %i4
const char *name,
int name_len
)
{
int rc = RC_OK;
msdos_fs_info_t *fs_info = parent_loc->mt_entry->fs_info;
2035f20: fa 00 60 08 ld [ %g1 + 8 ], %i5
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);
2035f24: 92 10 20 00 clr %o1
2035f28: 94 10 20 20 mov 0x20, %o2
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;
2035f2c: c0 27 bf cc clr [ %fp + -52 ]
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);
2035f30: 40 00 3e 7d call 2045924 <memset>
2035f34: 90 10 00 1c mov %i4, %o0
name_type = msdos_long_to_short (name,
2035f38: 92 10 00 1a mov %i2, %o1
2035f3c: 94 10 00 1c mov %i4, %o2
2035f40: 96 10 20 0b mov 0xb, %o3
2035f44: 7f ff fa 9f call 20349c0 <msdos_long_to_short>
2035f48: 90 10 00 19 mov %i1, %o0
msdos_find_name(
rtems_filesystem_location_info_t *parent_loc,
const char *name,
int name_len
)
{
2035f4c: b6 10 00 18 mov %i0, %i3
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,
2035f50: 98 10 00 08 mov %o0, %o4
/*
* 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,
2035f54: f8 23 a0 5c st %i4, [ %sp + 0x5c ]
2035f58: 90 10 00 18 mov %i0, %o0
2035f5c: 92 10 20 00 clr %o1
2035f60: 94 10 00 19 mov %i1, %o2
2035f64: 96 10 00 1a mov %i2, %o3
2035f68: 7f ff ff ab call 2035e14 <msdos_get_name_node>
2035f6c: 9a 07 bf d0 add %fp, -48, %o5
&dir_pos, node_entry);
if (rc != RC_OK)
2035f70: b0 92 20 00 orcc %o0, 0, %i0
2035f74: 12 80 00 68 bne 2036114 <msdos_find_name+0x200>
2035f78: c2 0f bf eb ldub [ %fp + -21 ], %g1
return rc;
if (((*MSDOS_DIR_ATTR(node_entry)) & MSDOS_ATTR_VOLUME_ID) ||
((*MSDOS_DIR_ATTR(node_entry) & MSDOS_ATTR_LFN_MASK) == MSDOS_ATTR_LFN))
return MSDOS_NAME_NOT_FOUND_ERR;
2035f7c: 31 00 00 1f sethi %hi(0x7c00), %i0
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) ||
2035f80: 84 08 60 08 and %g1, 8, %g2
2035f84: 80 88 a0 ff btst 0xff, %g2
2035f88: 12 80 00 63 bne 2036114 <msdos_find_name+0x200> <== NEVER TAKEN
2035f8c: b0 16 21 01 or %i0, 0x101, %i0
2035f90: 82 08 60 3f and %g1, 0x3f, %g1
2035f94: 80 a0 60 0f cmp %g1, 0xf
2035f98: 02 80 00 5f be 2036114 <msdos_find_name+0x200> <== NEVER TAKEN
2035f9c: 90 10 00 1d mov %i5, %o0
((*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(&fs_info->fat, &dir_pos, &fat_fd);
2035fa0: 92 07 bf d0 add %fp, -48, %o1
2035fa4: 7f ff bd 78 call 2025584 <fat_file_open>
2035fa8: 94 07 bf cc add %fp, -52, %o2
if (rc != RC_OK)
2035fac: b0 92 20 00 orcc %o0, 0, %i0
2035fb0: 12 80 00 59 bne 2036114 <msdos_find_name+0x200> <== NEVER TAKEN
2035fb4: f8 07 bf cc ld [ %fp + -52 ], %i4
return rc;
fat_fd->dir_pos = dir_pos;
2035fb8: 92 07 bf d0 add %fp, -48, %o1
2035fbc: 90 07 20 20 add %i4, 0x20, %o0
2035fc0: 40 00 3d ca call 20456e8 <memcpy>
2035fc4: 94 10 20 10 mov 0x10, %o2
* 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)
2035fc8: c2 07 20 08 ld [ %i4 + 8 ], %g1
2035fcc: 80 a0 60 01 cmp %g1, 1
2035fd0: 32 80 00 49 bne,a 20360f4 <msdos_find_name+0x1e0>
2035fd4: d2 06 e0 08 ld [ %i3 + 8 ], %o1
{
fat_fd->cln = MSDOS_EXTRACT_CLUSTER_NUM(node_entry);
2035fd8: c2 17 bf f4 lduh [ %fp + -12 ], %g1
2035fdc: 83 28 60 10 sll %g1, 0x10, %g1
2035fe0: 85 30 60 18 srl %g1, 0x18, %g2
2035fe4: 87 30 60 08 srl %g1, 8, %g3
2035fe8: 03 00 00 3f sethi %hi(0xfc00), %g1
2035fec: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff <PROM_START+0xffff>
2035ff0: 86 08 c0 01 and %g3, %g1, %g3
2035ff4: 86 10 80 03 or %g2, %g3, %g3
2035ff8: c4 17 bf fa lduh [ %fp + -6 ], %g2
2035ffc: 87 28 e0 10 sll %g3, 0x10, %g3
2036000: 85 28 a0 10 sll %g2, 0x10, %g2
2036004: 89 30 a0 18 srl %g2, 0x18, %g4
2036008: 85 30 a0 08 srl %g2, 8, %g2
203600c: 84 08 80 01 and %g2, %g1, %g2
2036010: 84 11 00 02 or %g4, %g2, %g2
2036014: 84 10 c0 02 or %g3, %g2, %g2
2036018: c4 27 20 1c st %g2, [ %i4 + 0x1c ]
time_val = *MSDOS_DIR_WRITE_TIME(node_entry);
date = *MSDOS_DIR_WRITE_DATE(node_entry);
203601c: c4 17 bf f8 lduh [ %fp + -8 ], %g2
fat_fd->mtime = msdos_date_dos2unix(CF_LE_W(date), CF_LE_W(time_val));
2036020: 85 28 a0 10 sll %g2, 0x10, %g2
2036024: 91 30 a0 18 srl %g2, 0x18, %o0
2036028: 85 30 a0 08 srl %g2, 8, %g2
203602c: 86 08 80 01 and %g2, %g1, %g3
2036030: c4 17 bf f6 lduh [ %fp + -10 ], %g2
2036034: 90 12 00 03 or %o0, %g3, %o0
2036038: 85 28 a0 10 sll %g2, 0x10, %g2
203603c: 93 30 a0 18 srl %g2, 0x18, %o1
2036040: 85 30 a0 08 srl %g2, 8, %g2
2036044: 82 08 80 01 and %g2, %g1, %g1
2036048: 40 00 29 7f call 2040644 <msdos_date_dos2unix>
203604c: 92 12 40 01 or %o1, %g1, %o1
if ((*MSDOS_DIR_ATTR(node_entry)) & MSDOS_ATTR_DIRECTORY)
2036050: c2 0f bf eb ldub [ %fp + -21 ], %g1
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));
2036054: d0 27 20 40 st %o0, [ %i4 + 0x40 ]
if ((*MSDOS_DIR_ATTR(node_entry)) & MSDOS_ATTR_DIRECTORY)
2036058: 82 08 60 10 and %g1, 0x10, %g1
203605c: 80 88 60 ff btst 0xff, %g1
2036060: 02 80 00 0e be 2036098 <msdos_find_name+0x184>
2036064: f8 07 bf cc ld [ %fp + -52 ], %i4
{
fat_fd->fat_file_type = FAT_DIRECTORY;
fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
2036068: 03 00 08 00 sethi %hi(0x200000), %g1
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;
203606c: c0 27 20 10 clr [ %i4 + 0x10 ]
fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
2036070: c2 27 20 14 st %g1, [ %i4 + 0x14 ]
rc = fat_file_size(&fs_info->fat, fat_fd);
2036074: 90 10 00 1d mov %i5, %o0
2036078: 7f ff bf ea call 2026020 <fat_file_size>
203607c: 92 10 00 1c mov %i4, %o1
if (rc != RC_OK)
2036080: b0 92 20 00 orcc %o0, 0, %i0
2036084: 02 80 00 0d be 20360b8 <msdos_find_name+0x1a4> <== ALWAYS TAKEN
2036088: c2 07 bf cc ld [ %fp + -52 ], %g1
{
fat_file_close(&fs_info->fat, fat_fd);
203608c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
2036090: 10 80 00 1f b 203610c <msdos_find_name+0x1f8> <== NOT EXECUTED
2036094: d2 07 bf cc ld [ %fp + -52 ], %o1 <== NOT EXECUTED
return rc;
}
}
else
{
fat_fd->fat_file_size = CF_LE_L(*MSDOS_DIR_FILE_SIZE(node_entry));
2036098: 7f ff fa 30 call 2034958 <CPU_swap_u32>
203609c: d0 07 bf fc ld [ %fp + -4 ], %o0
fat_fd->fat_file_type = FAT_FILE;
20360a0: 82 10 20 04 mov 4, %g1
return rc;
}
}
else
{
fat_fd->fat_file_size = CF_LE_L(*MSDOS_DIR_FILE_SIZE(node_entry));
20360a4: d0 27 20 18 st %o0, [ %i4 + 0x18 ]
fat_fd->fat_file_type = FAT_FILE;
20360a8: c2 27 20 10 st %g1, [ %i4 + 0x10 ]
fat_fd->size_limit = MSDOS_MAX_FILE_SIZE;
20360ac: 82 10 3f ff mov -1, %g1
20360b0: c2 27 20 14 st %g1, [ %i4 + 0x14 ]
}
/* these data is not actual for zero-length fat-file */
fat_fd->map.file_cln = 0;
20360b4: c2 07 bf cc ld [ %fp + -52 ], %g1
fat_fd->map.disk_cln = fat_fd->cln;
20360b8: c4 00 60 1c ld [ %g1 + 0x1c ], %g2
if ((fat_fd->fat_file_size != 0) &&
20360bc: c6 00 60 18 ld [ %g1 + 0x18 ], %g3
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;
20360c0: c0 20 60 34 clr [ %g1 + 0x34 ]
fat_fd->map.disk_cln = fat_fd->cln;
if ((fat_fd->fat_file_size != 0) &&
20360c4: 80 a0 e0 00 cmp %g3, 0
20360c8: 02 80 00 08 be 20360e8 <msdos_find_name+0x1d4>
20360cc: c4 20 60 38 st %g2, [ %g1 + 0x38 ]
(fat_fd->fat_file_size <= fs_info->fat.vol.bpc))
20360d0: c8 17 60 06 lduh [ %i5 + 6 ], %g4
/* 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) &&
20360d4: 80 a0 c0 04 cmp %g3, %g4
20360d8: 38 80 00 05 bgu,a 20360ec <msdos_find_name+0x1d8>
20360dc: 84 10 3f ff mov -1, %g2
{
fat_fd->map.last_cln = fat_fd->cln;
}
else
{
fat_fd->map.last_cln = FAT_UNDEFINED_VALUE;
20360e0: 10 80 00 04 b 20360f0 <msdos_find_name+0x1dc>
20360e4: c4 20 60 3c st %g2, [ %g1 + 0x3c ]
20360e8: 84 10 3f ff mov -1, %g2
20360ec: c4 20 60 3c st %g2, [ %g1 + 0x3c ]
}
}
/* close fat-file corresponded to the node we searched in */
rc = fat_file_close(&fs_info->fat, parent_loc->node_access);
20360f0: d2 06 e0 08 ld [ %i3 + 8 ], %o1
20360f4: 7f ff be 3a call 20259dc <fat_file_close>
20360f8: 90 10 00 1d mov %i5, %o0
if (rc != RC_OK)
20360fc: b0 92 20 00 orcc %o0, 0, %i0
2036100: 02 80 00 07 be 203611c <msdos_find_name+0x208> <== ALWAYS TAKEN
2036104: d2 07 bf cc ld [ %fp + -52 ], %o1
{
fat_file_close(&fs_info->fat, fat_fd);
2036108: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
203610c: 7f ff be 34 call 20259dc <fat_file_close> <== NOT EXECUTED
2036110: 01 00 00 00 nop <== NOT EXECUTED
2036114: 81 c7 e0 08 ret
2036118: 81 e8 00 00 restore
return rc;
}
/* update node_info_ptr field */
parent_loc->node_access = fat_fd;
203611c: d2 26 e0 08 st %o1, [ %i3 + 8 ]
return rc;
}
2036120: 81 c7 e0 08 ret
2036124: 81 e8 00 00 restore
02035068 <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
)
{
2035068: 9d e3 bf 60 save %sp, -160, %sp
203506c: f6 27 a0 50 st %i3, [ %fp + 0x50 ]
2035070: 84 10 00 1a mov %i2, %g2
2035074: e4 07 a0 5c ld [ %fp + 0x5c ], %l2
2035078: e8 07 a0 60 ld [ %fp + 0x60 ], %l4
uint32_t empty_space_count = 0;
bool empty_space_found = false;
uint32_t entries_per_block;
bool read_cluster = false;
assert(name_len > 0);
203507c: 80 a7 20 00 cmp %i4, 0
2035080: 14 80 00 0a bg 20350a8 <msdos_find_name_in_fat_file+0x40> <== ALWAYS TAKEN
2035084: e0 06 20 08 ld [ %i0 + 8 ], %l0
2035088: 11 00 81 9c sethi %hi(0x2067000), %o0 <== NOT EXECUTED
203508c: 15 00 81 9c sethi %hi(0x2067000), %o2 <== NOT EXECUTED
2035090: 17 00 81 9c sethi %hi(0x2067000), %o3 <== NOT EXECUTED
2035094: 90 12 20 00 mov %o0, %o0 <== NOT EXECUTED
2035098: 92 10 23 c4 mov 0x3c4, %o1 <== NOT EXECUTED
203509c: 94 12 a0 d0 or %o2, 0xd0, %o2 <== NOT EXECUTED
20350a0: 10 80 00 3e b 2035198 <msdos_find_name_in_fat_file+0x130> <== NOT EXECUTED
20350a4: 96 12 e0 90 or %o3, 0x90, %o3 <== 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;
20350a8: 82 10 3f ff mov -1, %g1
static inline void
fat_dir_pos_init(
fat_dir_pos_t *dir_pos
)
{
dir_pos->sname.cln = 0;
20350ac: c0 24 80 00 clr [ %l2 ]
dir_pos->sname.ofs = 0;
dir_pos->lname.cln = FAT_FILE_SHORT_NAME;
20350b0: c2 24 a0 08 st %g1, [ %l2 + 8 ]
dir_pos->lname.ofs = FAT_FILE_SHORT_NAME;
20350b4: c2 24 a0 0c st %g1, [ %l2 + 0xc ]
fat_dir_pos_init(dir_pos);
lfn_start.cln = lfn_start.ofs = FAT_FILE_SHORT_NAME;
20350b8: c2 27 bf fc st %g1, [ %fp + -4 ]
20350bc: c2 27 bf f8 st %g1, [ %fp + -8 ]
* 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))
20350c0: 82 1f 60 01 xor %i5, 1, %g1
20350c4: 80 a0 00 01 cmp %g0, %g1
20350c8: b4 60 3f ff subx %g0, -1, %i2
20350cc: 80 8e a0 ff btst 0xff, %i2
20350d0: 02 80 00 05 be 20350e4 <msdos_find_name_in_fat_file+0x7c>
20350d4: c0 24 a0 04 clr [ %l2 + 4 ]
20350d8: 80 a0 a0 00 cmp %g2, 0
20350dc: 12 80 00 08 bne 20350fc <msdos_find_name_in_fat_file+0x94>
20350e0: a6 10 20 00 clr %l3
lfn_entries = 0;
else
lfn_entries =
20350e4: c4 27 bf d0 st %g2, [ %fp + -48 ]
20350e8: 90 07 20 0c add %i4, 0xc, %o0
20350ec: 40 00 99 27 call 205b588 <.div>
20350f0: 92 10 20 0d mov 0xd, %o1
20350f4: c4 07 bf d0 ld [ %fp + -48 ], %g2
20350f8: a6 10 00 08 mov %o0, %l3
((name_len - 1) + MSDOS_LFN_LEN_PER_ENTRY) / MSDOS_LFN_LEN_PER_ENTRY;
if (FAT_FD_OF_ROOT_DIR(fat_fd) &&
20350fc: c2 06 60 20 ld [ %i1 + 0x20 ], %g1
2035100: 80 a0 60 01 cmp %g1, 1
2035104: 32 80 00 0b bne,a 2035130 <msdos_find_name_in_fat_file+0xc8>
2035108: e2 14 20 06 lduh [ %l0 + 6 ], %l1
203510c: c2 06 60 24 ld [ %i1 + 0x24 ], %g1
2035110: 80 a0 60 00 cmp %g1, 0
2035114: 32 80 00 07 bne,a 2035130 <msdos_find_name_in_fat_file+0xc8><== NEVER TAKEN
2035118: e2 14 20 06 lduh [ %l0 + 6 ], %l1 <== NOT EXECUTED
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))
203511c: c2 0c 20 0a ldub [ %l0 + 0xa ], %g1
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) &&
2035120: 80 88 60 03 btst 3, %g1
2035124: 22 80 00 03 be,a 2035130 <msdos_find_name_in_fat_file+0xc8><== NEVER TAKEN
2035128: e2 14 20 06 lduh [ %l0 + 6 ], %l1 <== NOT EXECUTED
203512c: e2 06 60 18 ld [ %i1 + 0x18 ], %l1
* 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 ||
2035130: b4 0e a0 ff and %i2, 0xff, %i2
/*
* Remainder is not empty so is this entry empty ?
*/
empty_space_count++;
if (empty_space_count == (lfn_entries + 1))
2035134: 82 04 e0 01 add %l3, 1, %g1
/*
* 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(&fs_info->fat, fat_fd, (dir_offset * bts2rd),
2035138: 88 10 20 00 clr %g4
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;
203513c: c0 2f bf e7 clrb [ %fp + -25 ]
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;
2035140: b0 10 20 00 clr %i0
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;
2035144: ae 10 20 00 clr %l7
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;
2035148: ac 10 20 00 clr %l6
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;
203514c: 86 10 20 00 clr %g3
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;
2035150: c0 2f bf ef clrb [ %fp + -17 ]
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;
2035154: 9a 10 20 00 clr %o5
char *name_dir_entry
)
{
ssize_t ret = 0;
msdos_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t dir_offset = 0;
2035158: b6 10 20 00 clr %i3
* 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 ||
203515c: f4 27 bf dc st %i2, [ %fp + -36 ]
/*
* 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(&fs_info->fat, fat_fd, (dir_offset * bts2rd),
2035160: 10 80 00 eb b 203550c <msdos_find_name_in_fat_file+0x4a4>
2035164: c2 27 bf d8 st %g1, [ %fp + -40 ]
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)
2035168: 80 a2 20 1f cmp %o0, 0x1f
203516c: 04 80 02 02 ble 2035974 <msdos_find_name_in_fat_file+0x90c><== NEVER TAKEN
2035170: 80 a2 00 11 cmp %o0, %l1
rtems_set_errno_and_return_minus_one(EIO);
assert(ret == bts2rd);
2035174: 22 80 00 0b be,a 20351a0 <msdos_find_name_in_fat_file+0x138><== ALWAYS TAKEN
2035178: ea 04 20 94 ld [ %l0 + 0x94 ], %l5
203517c: 11 00 81 9c sethi %hi(0x2067000), %o0 <== NOT EXECUTED
2035180: 15 00 81 9c sethi %hi(0x2067000), %o2 <== NOT EXECUTED
2035184: 17 00 81 9c sethi %hi(0x2067000), %o3 <== NOT EXECUTED
2035188: 90 12 20 00 mov %o0, %o0 <== NOT EXECUTED
203518c: 92 10 23 f4 mov 0x3f4, %o1 <== NOT EXECUTED
2035190: 94 12 a0 d0 or %o2, 0xd0, %o2 <== NOT EXECUTED
2035194: 96 12 e0 a0 or %o3, 0xa0, %o3 <== NOT EXECUTED
2035198: 7f ff c9 e7 call 2027934 <__assert_func> <== NOT EXECUTED
203519c: 01 00 00 00 nop <== NOT EXECUTED
/* 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;
20351a0: b4 10 20 00 clr %i2 ! 0 <PROM_START>
* 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)
20351a4: 80 a6 20 00 cmp %i0, 0
20351a8: 12 80 00 04 bne 20351b8 <msdos_find_name_in_fat_file+0x150>
20351ac: de 0d 40 00 ldub [ %l5 ], %o7
20351b0: ae 10 00 1a mov %i2, %l7
20351b4: ac 10 00 1b mov %i3, %l6
{
empty_space_entry = dir_entry;
empty_space_offset = dir_offset;
}
if (remainder_empty)
20351b8: 98 8b e0 ff andcc %o7, 0xff, %o4
20351bc: 12 80 00 11 bne 2035200 <msdos_find_name_in_fat_file+0x198>
20351c0: 80 a3 20 e5 cmp %o4, 0xe5
#endif
/*
* If just looking and there is no more entries in the
* directory - return name-not-found
*/
if (!create_node)
20351c4: 80 a0 a0 00 cmp %g2, 0
20351c8: 12 80 00 06 bne 20351e0 <msdos_find_name_in_fat_file+0x178>
20351cc: c4 0f bf e7 ldub [ %fp + -25 ], %g2
return MSDOS_NAME_NOT_FOUND_ERR;
20351d0: 31 00 00 1f sethi %hi(0x7c00), %i0
20351d4: b0 16 21 01 or %i0, 0x101, %i0 ! 7d01 <PROM_START+0x7d01>
20351d8: 81 c7 e0 08 ret
20351dc: 81 e8 00 00 restore
* 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)
20351e0: 80 88 a0 ff btst 0xff, %g2
20351e4: 12 80 00 dc bne 2035554 <msdos_find_name_in_fat_file+0x4ec>
20351e8: 80 a7 60 02 cmp %i5, 2
(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;
20351ec: 85 34 60 05 srl %l1, 5, %g2
* 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);
20351f0: b5 36 a0 05 srl %i2, 5, %i2
20351f4: b0 06 00 02 add %i0, %g2, %i0
* 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 +=
20351f8: 10 80 00 d7 b 2035554 <msdos_find_name_in_fat_file+0x4ec>
20351fc: b0 26 00 1a sub %i0, %i2, %i0
printf ("MSFS:[3.2] esf:%i esc%i\n", empty_space_found, empty_space_count);
#endif
}
break;
}
else if (entry_empty)
2035200: 12 80 00 0c bne 2035230 <msdos_find_name_in_fat_file+0x1c8>
2035204: c2 0f bf e7 ldub [ %fp + -25 ], %g1
{
if (create_node)
2035208: 80 a0 a0 00 cmp %g2, 0
203520c: 22 80 00 bb be,a 20354f8 <msdos_find_name_in_fat_file+0x490>
2035210: b4 06 a0 20 add %i2, 0x20, %i2
/*
* Remainder is not empty so is this entry empty ?
*/
empty_space_count++;
if (empty_space_count == (lfn_entries + 1))
2035214: c2 07 bf d8 ld [ %fp + -40 ], %g1
if (create_node)
{
/*
* Remainder is not empty so is this entry empty ?
*/
empty_space_count++;
2035218: b0 06 20 01 inc %i0
if (empty_space_count == (lfn_entries + 1))
203521c: 80 a6 00 01 cmp %i0, %g1
2035220: 32 80 00 b6 bne,a 20354f8 <msdos_find_name_in_fat_file+0x490>
2035224: b4 06 a0 20 add %i2, 0x20, %i2
empty_space_found = true;
2035228: 10 80 00 b2 b 20354f0 <msdos_find_name_in_fat_file+0x488>
203522c: 82 10 20 01 mov 1, %g1
* 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)
2035230: 98 18 60 01 xor %g1, 1, %o4
2035234: 80 8b 20 ff btst 0xff, %o4
2035238: 02 80 00 07 be 2035254 <msdos_find_name_in_fat_file+0x1ec><== NEVER TAKEN
203523c: d8 0d 60 0b ldub [ %l5 + 0xb ], %o4
2035240: 80 a0 a0 00 cmp %g2, 0
2035244: 02 80 00 04 be 2035254 <msdos_find_name_in_fat_file+0x1ec>
2035248: 01 00 00 00 nop
{
empty_space_entry = 0;
empty_space_count = 0;
203524c: b0 10 20 00 clr %i0 ! 0 <PROM_START>
* If empty space has not been found we need to start the
* count again.
*/
if (create_node && !empty_space_found)
{
empty_space_entry = 0;
2035250: ae 10 20 00 clr %l7
/*
* Check the attribute to see if the entry is for a long
* file name.
*/
if ((*MSDOS_DIR_ATTR(entry) & MSDOS_ATTR_LFN_MASK) ==
2035254: 98 0b 20 3f and %o4, 0x3f, %o4
2035258: 80 a3 20 0f cmp %o4, 0xf
203525c: 12 80 00 54 bne 20353ac <msdos_find_name_in_fat_file+0x344>
2035260: 80 8b 60 ff btst 0xff, %o5
#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)
2035264: d8 07 bf f8 ld [ %fp + -8 ], %o4
2035268: 80 a3 3f ff cmp %o4, -1
203526c: 32 80 00 10 bne,a 20352ac <msdos_find_name_in_fat_file+0x244>
2035270: de 0d 40 00 ldub [ %l5 ], %o7
/*
* The first entry must have the last long entry
* flag set.
*/
if ((*MSDOS_DIR_ENTRY_TYPE(entry) &
2035274: 98 0b e0 40 and %o7, 0x40, %o4
2035278: 80 8b 20 ff btst 0xff, %o4
203527c: 02 80 00 9e be 20354f4 <msdos_find_name_in_fat_file+0x48c>
2035280: 9a 10 20 00 clr %o5
* 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) &
2035284: 9e 0b e0 3f and %o7, 0x3f, %o7
2035288: 80 a4 c0 0f cmp %l3, %o7
203528c: 32 80 00 9b bne,a 20354f8 <msdos_find_name_in_fat_file+0x490>
2035290: b4 06 a0 20 add %i2, 0x20, %i2
continue;
/*
* Get the checksum of the short entry.
*/
lfn_start.cln = dir_offset;
2035294: f6 27 bf f8 st %i3, [ %fp + -8 ]
lfn_start.ofs = dir_entry;
2035298: f4 27 bf fc st %i2, [ %fp + -4 ]
lfn_entry = lfn_entries;
lfn_checksum = *MSDOS_DIR_LFN_CHECKSUM(entry);
203529c: c6 0d 60 0d ldub [ %l5 + 0xd ], %g3
20352a0: c6 2f bf ef stb %g3, [ %fp + -17 ]
20352a4: 86 10 00 13 mov %l3, %g3
* 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) &
20352a8: de 0d 40 00 ldub [ %l5 ], %o7
20352ac: 9e 0b e0 3f and %o7, 0x3f, %o7
20352b0: 80 a0 c0 0f cmp %g3, %o7
20352b4: 12 80 00 07 bne 20352d0 <msdos_find_name_in_fat_file+0x268><== NEVER TAKEN
20352b8: 82 10 3f ff mov -1, %g1
MSDOS_LAST_LONG_ENTRY_MASK)) ||
20352bc: d8 0f bf ef ldub [ %fp + -17 ], %o4
20352c0: de 0d 60 0d ldub [ %l5 + 0xd ], %o7
20352c4: 80 a3 00 0f cmp %o4, %o7
20352c8: 02 80 00 04 be 20352d8 <msdos_find_name_in_fat_file+0x270><== ALWAYS TAKEN
20352cc: 98 00 ff ff add %g3, -1, %o4
{
#if MSDOS_FIND_PRINT
printf ("MSFS:[4.4] no match\n");
#endif
lfn_start.cln = FAT_FILE_SHORT_NAME;
continue;
20352d0: 10 80 00 89 b 20354f4 <msdos_find_name_in_fat_file+0x48c> <== NOT EXECUTED
20352d4: c2 27 bf f8 st %g1, [ %fp + -8 ] <== NOT EXECUTED
}
lfn_entry--;
o = lfn_entry * MSDOS_LFN_LEN_PER_ENTRY;
20352d8: 9f 2b 20 02 sll %o4, 2, %o7
20352dc: 97 2b 20 04 sll %o4, 4, %o3
* 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(
20352e0: 9a 05 60 01 add %l5, 1, %o5
lfn_start.cln = FAT_FILE_SHORT_NAME;
continue;
}
lfn_entry--;
o = lfn_entry * MSDOS_LFN_LEN_PER_ENTRY;
20352e4: 96 22 c0 0f sub %o3, %o7, %o3
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++)
20352e8: 9e 10 20 00 clr %o7
lfn_start.cln = FAT_FILE_SHORT_NAME;
continue;
}
lfn_entry--;
o = lfn_entry * MSDOS_LFN_LEN_PER_ENTRY;
20352ec: 96 02 c0 0c add %o3, %o4, %o3
{
#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')
20352f0: d4 4b 40 00 ldsb [ %o5 ], %o2
20352f4: 80 a2 a0 00 cmp %o2, 0
20352f8: 12 80 00 0b bne 2035324 <msdos_find_name_in_fat_file+0x2bc>
20352fc: 92 03 c0 0b add %o7, %o3, %o1
/*
* 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) &&
2035300: 80 a0 c0 13 cmp %g3, %l3
2035304: 12 80 00 22 bne 203538c <msdos_find_name_in_fat_file+0x324><== NEVER TAKEN
2035308: 80 a3 20 00 cmp %o4, 0
((o + i) != name_len))
203530c: 9e 02 c0 0f add %o3, %o7, %o7
/*
* 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) &&
2035310: 80 a3 c0 1c cmp %o7, %i4
2035314: 02 80 00 1e be 203538c <msdos_find_name_in_fat_file+0x324><== ALWAYS TAKEN
2035318: 80 a3 20 00 cmp %o4, 0
break;
}
if (((o + i) >= name_len) || (*p != name[o + i]))
{
lfn_start.cln = FAT_FILE_SHORT_NAME;
203531c: 10 80 00 0b b 2035348 <msdos_find_name_in_fat_file+0x2e0> <== NOT EXECUTED
2035320: 86 10 3f ff mov -1, %g3 <== NOT EXECUTED
((o + i) != name_len))
lfn_start.cln = FAT_FILE_SHORT_NAME;
break;
}
if (((o + i) >= name_len) || (*p != name[o + i]))
2035324: 80 a2 40 1c cmp %o1, %i4
2035328: 16 80 00 07 bge 2035344 <msdos_find_name_in_fat_file+0x2dc>
203532c: c2 07 a0 50 ld [ %fp + 0x50 ], %g1
* 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(
2035330: 92 00 40 0b add %g1, %o3, %o1
((o + i) != name_len))
lfn_start.cln = FAT_FILE_SHORT_NAME;
break;
}
if (((o + i) >= name_len) || (*p != name[o + i]))
2035334: d2 4a 40 0f ldsb [ %o1 + %o7 ], %o1
2035338: 80 a2 80 09 cmp %o2, %o1
203533c: 02 80 00 05 be 2035350 <msdos_find_name_in_fat_file+0x2e8>
2035340: 80 a3 e0 04 cmp %o7, 4
{
lfn_start.cln = FAT_FILE_SHORT_NAME;
2035344: 86 10 3f ff mov -1, %g3
break;
2035348: 10 80 00 10 b 2035388 <msdos_find_name_in_fat_file+0x320>
203534c: c6 27 bf f8 st %g3, [ %fp + -8 ]
}
switch (i)
2035350: 02 80 00 06 be 2035368 <msdos_find_name_in_fat_file+0x300>
2035354: 80 a3 e0 0a cmp %o7, 0xa
2035358: 32 80 00 08 bne,a 2035378 <msdos_find_name_in_fat_file+0x310>
203535c: 9a 03 60 02 add %o5, 2, %o5
{
case 4:
p += 5;
break;
case 10:
p += 4;
2035360: 10 80 00 04 b 2035370 <msdos_find_name_in_fat_file+0x308>
2035364: 9a 03 60 04 add %o5, 4, %o5
switch (i)
{
case 4:
p += 5;
break;
2035368: 10 80 00 04 b 2035378 <msdos_find_name_in_fat_file+0x310>
203536c: 9a 03 60 05 add %o5, 5, %o5
case 10:
p += 4;
break;
2035370: 10 80 00 03 b 203537c <msdos_find_name_in_fat_file+0x314>
2035374: 9e 03 e0 01 inc %o7
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++)
2035378: 9e 03 e0 01 inc %o7
203537c: 80 a3 e0 0d cmp %o7, 0xd
2035380: 32 bf ff dd bne,a 20352f4 <msdos_find_name_in_fat_file+0x28c>
2035384: d4 4b 40 00 ldsb [ %o5 ], %o2
p += 2;
break;
}
}
lfn_matched = ((lfn_entry == 0) &&
2035388: 80 a3 20 00 cmp %o4, 0
203538c: 12 80 00 06 bne 20353a4 <msdos_find_name_in_fat_file+0x33c>
2035390: 9a 10 20 00 clr %o5
2035394: c6 07 bf f8 ld [ %fp + -8 ], %g3
2035398: 86 38 00 03 xnor %g0, %g3, %g3
203539c: 80 a0 00 03 cmp %g0, %g3
20353a0: 9a 40 20 00 addx %g0, 0, %o5
#endif
lfn_start.cln = FAT_FILE_SHORT_NAME;
continue;
}
lfn_entry--;
20353a4: 10 80 00 54 b 20354f4 <msdos_find_name_in_fat_file+0x48c>
20353a8: 86 10 00 0c mov %o4, %g3
* 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)
20353ac: 02 80 01 85 be 20359c0 <msdos_find_name_in_fat_file+0x958>
20353b0: c2 07 bf dc ld [ %fp + -36 ], %g1
20353b4: 9a 10 20 00 clr %o5
20353b8: 9e 10 20 00 clr %o7
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;
20353bc: d6 0d 40 0d ldub [ %l5 + %o5 ], %o3
20353c0: 98 0b e0 01 and %o7, 1, %o4
20353c4: 80 a0 00 0c cmp %g0, %o4
20353c8: 9e 0b e0 ff and %o7, 0xff, %o7
20353cc: 98 40 3f ff addx %g0, -1, %o4
20353d0: 9f 33 e0 01 srl %o7, 1, %o7
20353d4: 98 0b 20 80 and %o4, 0x80, %o4
20353d8: 9e 02 c0 0f add %o3, %o7, %o7
20353dc: 98 03 3f 80 add %o4, -128, %o4
{
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++)
20353e0: 9a 03 60 01 inc %o5
20353e4: 80 a3 60 0b cmp %o5, 0xb
20353e8: 12 bf ff f5 bne 20353bc <msdos_find_name_in_fat_file+0x354>
20353ec: 9e 03 c0 0c add %o7, %o4, %o7
cs = ((cs & 1) ? 0x80 : 0) + (cs >> 1) + *p;
if (lfn_entry || (lfn_checksum != cs))
20353f0: c2 0f bf ef ldub [ %fp + -17 ], %g1
20353f4: 9e 1b c0 01 xor %o7, %g1, %o7
20353f8: 80 8b e0 ff btst 0xff, %o7
20353fc: 12 80 01 71 bne 20359c0 <msdos_find_name_in_fat_file+0x958><== NEVER TAKEN
2035400: c2 07 bf dc ld [ %fp + -36 ], %g1
2035404: 80 a0 e0 00 cmp %g3, 0
2035408: 12 80 01 6f bne 20359c4 <msdos_find_name_in_fat_file+0x95c><== NEVER TAKEN
203540c: 80 a0 60 00 cmp %g1, 0
#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(&fs_info->fat, fat_fd, F_CLU_NUM,
2035410: 90 10 00 10 mov %l0, %o0
2035414: 92 10 00 19 mov %i1, %o1
2035418: 94 10 20 01 mov 1, %o2
203541c: 96 10 00 04 mov %g4, %o3
2035420: 7f ff c1 9c call 2025a90 <fat_file_ioctl>
2035424: 98 10 00 12 mov %l2, %o4
dir_offset * bts2rd,
&dir_pos->sname.cln);
if (rc != RC_OK)
2035428: b0 92 20 00 orcc %o0, 0, %i0
203542c: 02 80 00 13 be 2035478 <msdos_find_name_in_fat_file+0x410><== ALWAYS TAKEN
2035430: d2 07 bf f8 ld [ %fp + -8 ], %o1
2035434: 81 c7 e0 08 ret <== NOT EXECUTED
2035438: 81 e8 00 00 restore <== NOT EXECUTED
* match a long file name against a short file name because
* a long file name that generates a matching short file
* name is not a long file name.
*/
if (lfn_matched ||
((name_type == MSDOS_NAME_SHORT) &&
203543c: 80 a3 ff ff cmp %o7, -1
2035440: 12 80 00 29 bne 20354e4 <msdos_find_name_in_fat_file+0x47c><== NEVER TAKEN
2035444: 82 10 3f ff mov -1, %g1
(lfn_start.cln == FAT_FILE_SHORT_NAME) &&
(memcmp(MSDOS_DIR_NAME(entry),
2035448: c4 3f bf d0 std %g2, [ %fp + -48 ]
203544c: c8 27 bf cc st %g4, [ %fp + -52 ]
2035450: 90 10 00 15 mov %l5, %o0
2035454: 92 10 00 14 mov %l4, %o1
2035458: 40 00 40 7a call 2045640 <memcmp>
203545c: 94 10 20 0b mov 0xb, %o2
* 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) &&
2035460: c4 1f bf d0 ldd [ %fp + -48 ], %g2
2035464: 80 a2 20 00 cmp %o0, 0
2035468: 12 80 00 1e bne 20354e0 <msdos_find_name_in_fat_file+0x478>
203546c: c8 07 bf cc ld [ %fp + -52 ], %g4
#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(&fs_info->fat, fat_fd, F_CLU_NUM,
2035470: 10 bf ff e9 b 2035414 <msdos_find_name_in_fat_file+0x3ac>
2035474: 90 10 00 10 mov %l0, %o0
if (rc != RC_OK)
return rc;
dir_pos->sname.ofs = dir_entry;
if (lfn_start.cln != FAT_FILE_SHORT_NAME)
2035478: 80 a2 7f ff cmp %o1, -1
203547c: 12 80 00 0c bne 20354ac <msdos_find_name_in_fat_file+0x444>
2035480: f4 24 a0 04 st %i2, [ %l2 + 4 ]
&lfn_start.cln);
if (rc != RC_OK)
return rc;
}
dir_pos->lname.cln = lfn_start.cln;
2035484: c2 07 bf f8 ld [ %fp + -8 ], %g1
dir_pos->lname.ofs = lfn_start.ofs;
memcpy(name_dir_entry, entry,
2035488: 90 10 00 14 mov %l4, %o0
&lfn_start.cln);
if (rc != RC_OK)
return rc;
}
dir_pos->lname.cln = lfn_start.cln;
203548c: c2 24 a0 08 st %g1, [ %l2 + 8 ]
dir_pos->lname.ofs = lfn_start.ofs;
2035490: c2 07 bf fc ld [ %fp + -4 ], %g1
memcpy(name_dir_entry, entry,
2035494: 92 10 00 15 mov %l5, %o1
if (rc != RC_OK)
return rc;
}
dir_pos->lname.cln = lfn_start.cln;
dir_pos->lname.ofs = lfn_start.ofs;
2035498: c2 24 a0 0c st %g1, [ %l2 + 0xc ]
memcpy(name_dir_entry, entry,
203549c: 40 00 40 93 call 20456e8 <memcpy>
20354a0: 94 10 20 20 mov 0x20, %o2
20354a4: 81 c7 e0 08 ret
20354a8: 81 e8 00 00 restore
dir_pos->sname.ofs = dir_entry;
if (lfn_start.cln != FAT_FILE_SHORT_NAME)
{
rc = fat_file_ioctl(&fs_info->fat, fat_fd, F_CLU_NUM,
20354ac: 7f ff 36 6e call 2002e64 <.umul>
20354b0: 90 10 00 11 mov %l1, %o0
20354b4: 92 10 00 19 mov %i1, %o1
20354b8: 96 10 00 08 mov %o0, %o3
20354bc: 94 10 20 01 mov 1, %o2
20354c0: 90 10 00 10 mov %l0, %o0
20354c4: 7f ff c1 73 call 2025a90 <fat_file_ioctl>
20354c8: 98 07 bf f8 add %fp, -8, %o4
lfn_start.cln * bts2rd,
&lfn_start.cln);
if (rc != RC_OK)
20354cc: 80 a2 20 00 cmp %o0, 0
20354d0: 12 80 01 37 bne 20359ac <msdos_find_name_in_fat_file+0x944><== NEVER TAKEN
20354d4: c2 07 bf f8 ld [ %fp + -8 ], %g1
}
dir_pos->lname.cln = lfn_start.cln;
dir_pos->lname.ofs = lfn_start.ofs;
memcpy(name_dir_entry, entry,
20354d8: 10 bf ff ed b 203548c <msdos_find_name_in_fat_file+0x424>
20354dc: 90 10 00 14 mov %l4, %o0
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
return RC_OK;
}
lfn_start.cln = FAT_FILE_SHORT_NAME;
20354e0: 82 10 3f ff mov -1, %g1
lfn_matched = false;
20354e4: 9a 10 20 00 clr %o5
memcpy(name_dir_entry, entry,
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
return RC_OK;
}
lfn_start.cln = FAT_FILE_SHORT_NAME;
20354e8: 10 80 00 03 b 20354f4 <msdos_find_name_in_fat_file+0x48c>
20354ec: c2 27 bf f8 st %g1, [ %fp + -8 ]
* Remainder is not empty so is this entry empty ?
*/
empty_space_count++;
if (empty_space_count == (lfn_entries + 1))
empty_space_found = true;
20354f0: c2 2f bf e7 stb %g1, [ %fp + -25 ]
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)
20354f4: b4 06 a0 20 add %i2, 0x20, %i2
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;
20354f8: 80 a6 80 11 cmp %i2, %l1
20354fc: 0a bf ff 2a bcs 20351a4 <msdos_find_name_in_fat_file+0x13c><== ALWAYS TAKEN
2035500: aa 05 60 20 add %l5, 0x20, %l5
}
if (remainder_empty)
break;
dir_offset++;
2035504: b6 06 e0 01 inc %i3 <== NOT EXECUTED
2035508: 88 01 00 11 add %g4, %l1, %g4 <== 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(&fs_info->fat, fat_fd, (dir_offset * bts2rd),
203550c: d8 04 20 94 ld [ %l0 + 0x94 ], %o4
2035510: 94 10 00 04 mov %g4, %o2
2035514: c4 3f bf d0 std %g2, [ %fp + -48 ]
2035518: c8 27 bf cc st %g4, [ %fp + -52 ]
203551c: da 27 bf c4 st %o5, [ %fp + -60 ]
2035520: 90 10 00 10 mov %l0, %o0
2035524: 92 10 00 19 mov %i1, %o1
2035528: 7f ff c0 7a call 2025710 <fat_file_read>
203552c: 96 10 00 11 mov %l1, %o3
2035530: c4 1f bf d0 ldd [ %fp + -48 ], %g2
2035534: 80 a2 20 00 cmp %o0, 0
2035538: c8 07 bf cc ld [ %fp + -52 ], %g4
203553c: 12 bf ff 0b bne 2035168 <msdos_find_name_in_fat_file+0x100><== ALWAYS TAKEN
2035540: da 07 bf c4 ld [ %fp + -60 ], %o5
}
/*
* If we are not to create the entry return a not found error.
*/
if (!create_node)
2035544: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED
2035548: 22 bf ff 23 be,a 20351d4 <msdos_find_name_in_fat_file+0x16c><== NOT EXECUTED
203554c: 31 00 00 1f sethi %hi(0x7c00), %i0 <== 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)
2035550: 80 a7 60 02 cmp %i5, 2 <== NOT EXECUTED
2035554: 12 80 00 2e bne 203560c <msdos_find_name_in_fat_file+0x5a4>
2035558: 80 a4 e0 00 cmp %l3, 0
{
int slot = (((empty_space_offset * bts2rd) + empty_space_entry) /
203555c: 90 10 00 16 mov %l6, %o0
2035560: 7f ff 36 41 call 2002e64 <.umul>
2035564: 92 10 00 11 mov %l1, %o1
{
static const char* hex = "0123456789ABCDEF";
char* c = MSDOS_DIR_NAME(sfn);
int i;
for (i = 0; i < 2; i++, c++)
if ((*c == ' ') || (*c == '.'))
2035568: c4 4d 00 00 ldsb [ %l4 ], %g2
*/
lfn_checksum = 0;
if (name_type == MSDOS_NAME_LONG)
{
int slot = (((empty_space_offset * bts2rd) + empty_space_entry) /
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE) + lfn_entries + 1;
203556c: ba 04 e0 01 add %l3, 1, %i5
* in this directory.
*/
lfn_checksum = 0;
if (name_type == MSDOS_NAME_LONG)
{
int slot = (((empty_space_offset * bts2rd) + empty_space_entry) /
2035570: 90 02 00 17 add %o0, %l7, %o0
{
static const char* hex = "0123456789ABCDEF";
char* c = MSDOS_DIR_NAME(sfn);
int i;
for (i = 0; i < 2; i++, c++)
if ((*c == ' ') || (*c == '.'))
2035574: 80 a0 a0 2e cmp %g2, 0x2e
* in this directory.
*/
lfn_checksum = 0;
if (name_type == MSDOS_NAME_LONG)
{
int slot = (((empty_space_offset * bts2rd) + empty_space_entry) /
2035578: 91 32 20 05 srl %o0, 5, %o0
{
static const char* hex = "0123456789ABCDEF";
char* c = MSDOS_DIR_NAME(sfn);
int i;
for (i = 0; i < 2; i++, c++)
if ((*c == ' ') || (*c == '.'))
203557c: 02 80 00 05 be 2035590 <msdos_find_name_in_fat_file+0x528><== NEVER TAKEN
2035580: ba 07 40 08 add %i5, %o0, %i5
2035584: 80 a0 a0 20 cmp %g2, 0x20
2035588: 32 80 00 05 bne,a 203559c <msdos_find_name_in_fat_file+0x534>
203558c: c4 4d 20 01 ldsb [ %l4 + 1 ], %g2
*c = '_';
2035590: 84 10 20 5f mov 0x5f, %g2
2035594: c4 2d 00 00 stb %g2, [ %l4 ]
{
static const char* hex = "0123456789ABCDEF";
char* c = MSDOS_DIR_NAME(sfn);
int i;
for (i = 0; i < 2; i++, c++)
if ((*c == ' ') || (*c == '.'))
2035598: c4 4d 20 01 ldsb [ %l4 + 1 ], %g2
203559c: 80 a0 a0 2e cmp %g2, 0x2e
20355a0: 22 80 00 06 be,a 20355b8 <msdos_find_name_in_fat_file+0x550><== NEVER TAKEN
20355a4: 84 10 20 5f mov 0x5f, %g2 <== NOT EXECUTED
20355a8: 80 a0 a0 20 cmp %g2, 0x20
20355ac: 12 80 00 05 bne 20355c0 <msdos_find_name_in_fat_file+0x558>
20355b0: 86 05 20 02 add %l4, 2, %g3
*c = '_';
20355b4: 84 10 20 5f mov 0x5f, %g2
20355b8: c4 2d 20 01 stb %g2, [ %l4 + 1 ]
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++)
20355bc: 86 05 20 02 add %l4, 2, %g3
20355c0: 84 10 20 00 clr %g2
if ((*c == ' ') || (*c == '.'))
*c = '_';
for (i = 0; i < 4; i++, c++)
*c = hex[(num >> ((3 - i) * 4)) & 0xf];
20355c4: 35 00 81 7d sethi %hi(0x205f400), %i2
* 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(
20355c8: 88 20 00 02 neg %g2, %g4
int i;
for (i = 0; i < 2; i++, c++)
if ((*c == ' ') || (*c == '.'))
*c = '_';
for (i = 0; i < 4; i++, c++)
*c = hex[(num >> ((3 - i) * 4)) & 0xf];
20355cc: b8 16 a3 b8 or %i2, 0x3b8, %i4
* 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(
20355d0: 89 29 20 02 sll %g4, 2, %g4
20355d4: 88 01 20 0c add %g4, 0xc, %g4
int i;
for (i = 0; i < 2; i++, c++)
if ((*c == ' ') || (*c == '.'))
*c = '_';
for (i = 0; i < 4; i++, c++)
*c = hex[(num >> ((3 - i) * 4)) & 0xf];
20355d8: 89 3f 40 04 sra %i5, %g4, %g4
20355dc: 88 09 20 0f and %g4, 0xf, %g4
20355e0: c8 0f 00 04 ldub [ %i4 + %g4 ], %g4
20355e4: c8 28 c0 02 stb %g4, [ %g3 + %g2 ]
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++)
20355e8: 84 00 a0 01 inc %g2
20355ec: 80 a0 a0 04 cmp %g2, 4
20355f0: 12 bf ff f8 bne 20355d0 <msdos_find_name_in_fat_file+0x568>
20355f4: 88 20 00 02 neg %g2, %g4
*c = hex[(num >> ((3 - i) * 4)) & 0xf];
*c++ = '~';
20355f8: 84 10 20 7e mov 0x7e, %g2
20355fc: c4 2d 20 06 stb %g2, [ %l4 + 6 ]
*c++ = '1';
2035600: 84 10 20 31 mov 0x31, %g2
2035604: c4 2d 20 07 stb %g2, [ %l4 + 7 ]
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)
2035608: 80 a4 e0 00 cmp %l3, 0
203560c: 02 80 00 10 be 203564c <msdos_find_name_in_fat_file+0x5e4>
2035610: b8 10 20 00 clr %i4
2035614: 84 10 20 00 clr %g2
{
uint8_t* p = (uint8_t*) MSDOS_DIR_NAME(name_dir_entry);
int i;
for (i = 0; i < 11; i++, p++)
lfn_checksum =
2035618: c8 0d 00 02 ldub [ %l4 + %g2 ], %g4
203561c: 86 0f 20 01 and %i4, 1, %g3
2035620: 80 a0 00 03 cmp %g0, %g3
2035624: b8 0f 20 ff and %i4, 0xff, %i4
2035628: 86 40 3f ff addx %g0, -1, %g3
203562c: b9 37 20 01 srl %i4, 1, %i4
2035630: 86 08 e0 80 and %g3, 0x80, %g3
2035634: b8 01 00 1c add %g4, %i4, %i4
2035638: 86 00 ff 80 add %g3, -128, %g3
if (lfn_entries)
{
uint8_t* p = (uint8_t*) MSDOS_DIR_NAME(name_dir_entry);
int i;
for (i = 0; i < 11; i++, p++)
203563c: 84 00 a0 01 inc %g2
2035640: 80 a0 a0 0b cmp %g2, 0xb
2035644: 12 bf ff f5 bne 2035618 <msdos_find_name_in_fat_file+0x5b0>
2035648: b8 07 00 03 add %i4, %g3, %i4
* 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)
203564c: 80 a6 20 00 cmp %i0, 0
2035650: 22 80 00 06 be,a 2035668 <msdos_find_name_in_fat_file+0x600><== NEVER TAKEN
2035654: ac 10 00 1b mov %i3, %l6 <== NOT EXECUTED
uint32_t empty_space_offset = 0;
uint32_t empty_space_entry = 0;
uint32_t empty_space_count = 0;
bool empty_space_found = false;
uint32_t entries_per_block;
bool read_cluster = false;
2035658: 82 1e c0 16 xor %i3, %l6, %g1
203565c: 80 a0 00 01 cmp %g0, %g1
2035660: 10 80 00 04 b 2035670 <msdos_find_name_in_fat_file+0x608>
2035664: b4 40 20 00 addx %g0, 0, %i2
* be at the next cluster so we can just make empty_space_offset
* that value.
*/
if (empty_space_count == 0)
{
read_cluster = true;
2035668: b4 10 20 01 mov 1, %i2 <== NOT EXECUTED
empty_space_offset = dir_offset;
empty_space_entry = 0;
203566c: ae 10 20 00 clr %l7 <== NOT EXECUTED
read_cluster = true;
/*
* Handle the entry writes.
*/
lfn_start.cln = lfn_start.ofs = FAT_FILE_SHORT_NAME;
2035670: 84 10 3f ff mov -1, %g2
2035674: 90 10 00 16 mov %l6, %o0
2035678: c4 27 bf fc st %g2, [ %fp + -4 ]
203567c: c4 27 bf f8 st %g2, [ %fp + -8 ]
2035680: 7f ff 35 f9 call 2002e64 <.umul>
2035684: 92 10 00 11 mov %l1, %o1
* 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(
2035688: c6 07 a0 50 ld [ %fp + 0x50 ], %g3
203568c: 83 2c e0 02 sll %l3, 2, %g1
2035690: 85 2c e0 04 sll %l3, 4, %g2
2035694: 82 20 80 01 sub %g2, %g1, %g1
2035698: 82 00 40 13 add %g1, %l3, %g1
203569c: 82 00 c0 01 add %g3, %g1, %g1
20356a0: ba 10 00 08 mov %o0, %i5
20356a4: c2 27 bf e4 st %g1, [ %fp + -28 ]
/*
* Handle the entry writes.
*/
lfn_start.cln = lfn_start.ofs = FAT_FILE_SHORT_NAME;
lfn_entry = 0;
20356a8: b0 10 20 00 clr %i0
length, lfn_entry);
#endif
/*
* Time to write the short file name entry.
*/
if (lfn_entry == (lfn_entries + 1))
20356ac: 82 04 e0 01 add %l3, 1, %g1
#endif
/*
* The one more is the short entry.
*/
while (lfn_entry < (lfn_entries + 1))
20356b0: 10 80 00 ba b 2035998 <msdos_find_name_in_fat_file+0x930>
20356b4: c2 27 bf ec st %g1, [ %fp + -20 ]
{
int length = 0;
if (read_cluster)
20356b8: 02 80 00 2f be 2035774 <msdos_find_name_in_fat_file+0x70c><== ALWAYS TAKEN
20356bc: c6 07 bf e4 ld [ %fp + -28 ], %g3
{
uint32_t new_length;
#if MSDOS_FIND_PRINT
printf ("MSFS:[9.1] eso:%li\n", empty_space_offset);
#endif
ret = fat_file_read(&fs_info->fat, fat_fd,
20356c0: d8 04 20 94 ld [ %l0 + 0x94 ], %o4 <== NOT EXECUTED
20356c4: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
20356c8: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
20356cc: 94 10 00 1d mov %i5, %o2 <== NOT EXECUTED
20356d0: 7f ff c0 10 call 2025710 <fat_file_read> <== NOT EXECUTED
20356d4: 96 10 00 11 mov %l1, %o3 <== NOT EXECUTED
(empty_space_offset * bts2rd), bts2rd,
fs_info->cl_buf);
if (ret != bts2rd)
20356d8: 80 a2 00 11 cmp %o0, %l1 <== NOT EXECUTED
20356dc: 02 80 00 25 be 2035770 <msdos_find_name_in_fat_file+0x708><== NOT EXECUTED
20356e0: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
{
if (ret != FAT_EOF)
20356e4: 22 80 00 03 be,a 20356f0 <msdos_find_name_in_fat_file+0x688><== NOT EXECUTED
20356e8: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
20356ec: 30 80 00 1b b,a 2035758 <msdos_find_name_in_fat_file+0x6f0><== 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 (&fs_info->fat, fat_fd, false,
20356f0: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
20356f4: 94 10 20 00 clr %o2 <== NOT EXECUTED
20356f8: 96 10 00 1d mov %i5, %o3 <== NOT EXECUTED
20356fc: 7f ff c1 19 call 2025b60 <fat_file_extend> <== NOT EXECUTED
2035700: 98 07 bf f4 add %fp, -12, %o4 <== NOT EXECUTED
empty_space_offset * bts2rd, &new_length);
if (ret != RC_OK)
2035704: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2035708: 12 80 00 a9 bne 20359ac <msdos_find_name_in_fat_file+0x944><== NOT EXECUTED
203570c: c2 07 bf f4 ld [ %fp + -12 ], %g1 <== 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))
2035710: 80 a0 40 1d cmp %g1, %i5 <== NOT EXECUTED
2035714: 22 80 00 03 be,a 2035720 <msdos_find_name_in_fat_file+0x6b8><== NOT EXECUTED
2035718: d0 04 20 94 ld [ %l0 + 0x94 ], %o0 <== NOT EXECUTED
203571c: 30 80 00 0f b,a 2035758 <msdos_find_name_in_fat_file+0x6f0><== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
memset(fs_info->cl_buf, 0, bts2rd);
2035720: 92 10 20 00 clr %o1 <== NOT EXECUTED
2035724: 40 00 40 80 call 2045924 <memset> <== NOT EXECUTED
2035728: 94 10 00 11 mov %l1, %o2 <== NOT EXECUTED
ret = fat_file_write(&fs_info->fat, fat_fd,
203572c: d8 04 20 94 ld [ %l0 + 0x94 ], %o4 <== NOT EXECUTED
2035730: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
2035734: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
2035738: 94 10 00 1d mov %i5, %o2 <== NOT EXECUTED
203573c: 7f ff c1 a4 call 2025dcc <fat_file_write> <== NOT EXECUTED
2035740: 96 10 00 11 mov %l1, %o3 <== 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)
2035744: 80 a2 3f ff cmp %o0, -1 <== NOT EXECUTED
2035748: 02 80 00 99 be 20359ac <msdos_find_name_in_fat_file+0x944><== NOT EXECUTED
203574c: 80 a2 00 11 cmp %o0, %l1 <== NOT EXECUTED
return ret;
else if (ret != bts2rd)
2035750: 02 80 00 09 be 2035774 <msdos_find_name_in_fat_file+0x70c><== NOT EXECUTED
2035754: c6 07 bf e4 ld [ %fp + -28 ], %g3 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
2035758: 40 00 32 a5 call 20421ec <__errno> <== NOT EXECUTED
203575c: 01 00 00 00 nop <== NOT EXECUTED
2035760: 82 10 20 05 mov 5, %g1 ! 5 <PROM_START+0x5> <== NOT EXECUTED
2035764: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
2035768: 10 80 00 91 b 20359ac <msdos_find_name_in_fat_file+0x944> <== NOT EXECUTED
203576c: 90 10 3f ff mov -1, %o0 <== 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(
2035770: c6 07 bf e4 ld [ %fp + -28 ], %g3 <== NOT EXECUTED
2035774: 83 2e 20 02 sll %i0, 2, %g1
2035778: 97 2e 20 04 sll %i0, 4, %o3
203577c: 84 06 20 01 add %i0, 1, %g2
2035780: 96 22 c0 01 sub %o3, %g1, %o3
2035784: 9a 10 20 00 clr %o5
2035788: 96 02 c0 18 add %o3, %i0, %o3
203578c: b4 10 20 00 clr %i2
2035790: 96 20 c0 0b sub %g3, %o3, %o3
2035794: 10 80 00 68 b 2035934 <msdos_find_name_in_fat_file+0x8cc>
2035798: 96 02 ff f3 add %o3, -13, %o3
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;
203579c: d8 04 20 94 ld [ %l0 + 0x94 ], %o4
length, lfn_entry);
#endif
/*
* Time to write the short file name entry.
*/
if (lfn_entry == (lfn_entries + 1))
20357a0: c2 07 bf ec ld [ %fp + -20 ], %g1
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;
20357a4: aa 03 00 1b add %o4, %i3, %l5
char* p;
const char* n;
int i;
char fill = 0;
length += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE;
20357a8: b4 06 a0 20 add %i2, 0x20, %i2
length, lfn_entry);
#endif
/*
* Time to write the short file name entry.
*/
if (lfn_entry == (lfn_entries + 1))
20357ac: 80 a0 80 01 cmp %g2, %g1
20357b0: 12 80 00 25 bne 2035844 <msdos_find_name_in_fat_file+0x7dc>
20357b4: b0 10 00 02 mov %g2, %i0
{
/* get current cluster number */
int rc = fat_file_ioctl(&fs_info->fat, fat_fd, F_CLU_NUM,
20357b8: 90 10 00 10 mov %l0, %o0
20357bc: 92 10 00 19 mov %i1, %o1
20357c0: 94 10 20 01 mov 1, %o2
20357c4: 96 10 00 1d mov %i5, %o3
20357c8: 7f ff c0 b2 call 2025a90 <fat_file_ioctl>
20357cc: 98 10 00 12 mov %l2, %o4
empty_space_offset * bts2rd,
&dir_pos->sname.cln);
if (rc != RC_OK)
20357d0: 80 a2 20 00 cmp %o0, 0
20357d4: 12 80 00 76 bne 20359ac <msdos_find_name_in_fat_file+0x944><== NEVER TAKEN
20357d8: d2 07 bf f8 ld [ %fp + -8 ], %o1
return rc;
dir_pos->sname.ofs = dir_entry;
if (lfn_start.cln != FAT_FILE_SHORT_NAME)
20357dc: 80 a2 7f ff cmp %o1, -1
20357e0: 12 80 00 0c bne 2035810 <msdos_find_name_in_fat_file+0x7a8>
20357e4: f6 24 a0 04 st %i3, [ %l2 + 4 ]
&lfn_start.cln);
if (rc != RC_OK)
return rc;
}
dir_pos->lname.cln = lfn_start.cln;
20357e8: c2 07 bf f8 ld [ %fp + -8 ], %g1
dir_pos->lname.ofs = lfn_start.ofs;
/* write new node entry */
memcpy (entry, (uint8_t *) name_dir_entry,
20357ec: 90 10 00 15 mov %l5, %o0
&lfn_start.cln);
if (rc != RC_OK)
return rc;
}
dir_pos->lname.cln = lfn_start.cln;
20357f0: c2 24 a0 08 st %g1, [ %l2 + 8 ]
dir_pos->lname.ofs = lfn_start.ofs;
20357f4: c2 07 bf fc ld [ %fp + -4 ], %g1
/* write new node entry */
memcpy (entry, (uint8_t *) name_dir_entry,
20357f8: 92 10 00 14 mov %l4, %o1
if (rc != RC_OK)
return rc;
}
dir_pos->lname.cln = lfn_start.cln;
dir_pos->lname.ofs = lfn_start.ofs;
20357fc: c2 24 a0 0c st %g1, [ %l2 + 0xc ]
/* write new node entry */
memcpy (entry, (uint8_t *) name_dir_entry,
2035800: 40 00 3f ba call 20456e8 <memcpy>
2035804: 94 10 20 20 mov 0x20, %o2
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
break;
2035808: 10 80 00 50 b 2035948 <msdos_find_name_in_fat_file+0x8e0>
203580c: d8 04 20 94 ld [ %l0 + 0x94 ], %o4
dir_pos->sname.ofs = dir_entry;
if (lfn_start.cln != FAT_FILE_SHORT_NAME)
{
rc = fat_file_ioctl(&fs_info->fat, fat_fd, F_CLU_NUM,
2035810: 7f ff 35 95 call 2002e64 <.umul>
2035814: 90 10 00 11 mov %l1, %o0
2035818: 92 10 00 19 mov %i1, %o1
203581c: 96 10 00 08 mov %o0, %o3
2035820: 94 10 20 01 mov 1, %o2
2035824: 90 10 00 10 mov %l0, %o0
2035828: 7f ff c0 9a call 2025a90 <fat_file_ioctl>
203582c: 98 07 bf f8 add %fp, -8, %o4
lfn_start.cln * bts2rd,
&lfn_start.cln);
if (rc != RC_OK)
2035830: 80 a2 20 00 cmp %o0, 0
2035834: 02 bf ff ee be 20357ec <msdos_find_name_in_fat_file+0x784><== ALWAYS TAKEN
2035838: c2 07 bf f8 ld [ %fp + -8 ], %g1
dir_pos->sname.ofs = dir_entry;
if (lfn_start.cln != FAT_FILE_SHORT_NAME)
{
rc = fat_file_ioctl(&fs_info->fat, fat_fd, F_CLU_NUM,
203583c: 81 c7 e0 08 ret <== NOT EXECUTED
2035840: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED
* 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)
2035844: c2 07 bf f8 ld [ %fp + -8 ], %g1
2035848: 80 a0 7f ff cmp %g1, -1
203584c: 32 80 00 05 bne,a 2035860 <msdos_find_name_in_fat_file+0x7f8>
2035850: d8 3f bf c0 std %o4, [ %fp + -64 ]
{
lfn_start.cln = empty_space_offset;
2035854: ec 27 bf f8 st %l6, [ %fp + -8 ]
lfn_start.ofs = dir_entry;
2035858: f6 27 bf fc st %i3, [ %fp + -4 ]
}
/*
* Clear the entry before loading the data.
*/
memset (entry, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
203585c: d8 3f bf c0 std %o4, [ %fp + -64 ]
2035860: 94 10 20 20 mov 0x20, %o2
2035864: c4 27 bf d0 st %g2, [ %fp + -48 ]
2035868: d6 27 bf c8 st %o3, [ %fp + -56 ]
203586c: 90 10 00 15 mov %l5, %o0
2035870: 40 00 40 2d call 2045924 <memset>
2035874: 92 10 20 00 clr %o1
*MSDOS_DIR_LFN_CHECKSUM(entry) = lfn_checksum;
2035878: f8 2d 60 0d stb %i4, [ %l5 + 0xd ]
* 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(
203587c: d6 07 bf c8 ld [ %fp + -56 ], %o3
2035880: da 07 bf c4 ld [ %fp + -60 ], %o5
*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++)
2035884: d8 07 bf c0 ld [ %fp + -64 ], %o4
2035888: c4 07 bf d0 ld [ %fp + -48 ], %g2
*/
memset (entry, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
*MSDOS_DIR_LFN_CHECKSUM(entry) = lfn_checksum;
p = entry + 1;
203588c: 82 05 60 01 add %l5, 1, %g1
* 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(
2035890: 9e 02 c0 0d add %o3, %o5, %o7
{
char* entry = (char*) fs_info->cl_buf + dir_entry;
char* p;
const char* n;
int i;
char fill = 0;
2035894: 94 10 20 00 clr %o2
*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++)
2035898: b0 10 20 00 clr %i0
{
if (*n != 0)
203589c: d0 4b c0 00 ldsb [ %o7 ], %o0
20358a0: 80 a2 20 00 cmp %o0, 0
20358a4: 02 80 00 05 be 20358b8 <msdos_find_name_in_fat_file+0x850>
20358a8: d2 0b c0 00 ldub [ %o7 ], %o1
{
*p = *n;
20358ac: d2 28 40 00 stb %o1, [ %g1 ]
n++;
20358b0: 10 80 00 05 b 20358c4 <msdos_find_name_in_fat_file+0x85c>
20358b4: 9e 03 e0 01 inc %o7
}
else
{
p [0] = fill;
20358b8: d4 28 40 00 stb %o2, [ %g1 ]
p [1] = fill;
20358bc: d4 28 60 01 stb %o2, [ %g1 + 1 ]
fill = 0xff;
20358c0: 94 10 3f ff mov -1, %o2
}
switch (i)
20358c4: 80 a6 20 04 cmp %i0, 4
20358c8: 02 80 00 06 be 20358e0 <msdos_find_name_in_fat_file+0x878>
20358cc: 80 a6 20 0a cmp %i0, 0xa
20358d0: 32 80 00 08 bne,a 20358f0 <msdos_find_name_in_fat_file+0x888>
20358d4: 82 00 60 02 add %g1, 2, %g1
{
case 4:
p += 5;
break;
case 10:
p += 4;
20358d8: 10 80 00 04 b 20358e8 <msdos_find_name_in_fat_file+0x880>
20358dc: 82 00 60 04 add %g1, 4, %g1
switch (i)
{
case 4:
p += 5;
break;
20358e0: 10 80 00 04 b 20358f0 <msdos_find_name_in_fat_file+0x888>
20358e4: 82 00 60 05 add %g1, 5, %g1
case 10:
p += 4;
break;
20358e8: 10 80 00 03 b 20358f4 <msdos_find_name_in_fat_file+0x88c>
20358ec: b0 06 20 01 inc %i0
*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++)
20358f0: b0 06 20 01 inc %i0
20358f4: 80 a6 20 0d cmp %i0, 0xd
20358f8: 32 bf ff ea bne,a 20358a0 <msdos_find_name_in_fat_file+0x838>
20358fc: d0 4b c0 00 ldsb [ %o7 ], %o0
* 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(
2035900: c6 07 bf ec ld [ %fp + -20 ], %g3
break;
}
}
*MSDOS_DIR_ENTRY_TYPE(entry) = (lfn_entries - lfn_entry) + 1;
if (lfn_entry == 1)
2035904: 80 a0 a0 01 cmp %g2, 1
2035908: 02 80 00 04 be 2035918 <msdos_find_name_in_fat_file+0x8b0>
203590c: 82 20 c0 02 sub %g3, %g2, %g1
*MSDOS_DIR_ENTRY_TYPE(entry) |= MSDOS_LAST_LONG_ENTRY;
2035910: 10 80 00 04 b 2035920 <msdos_find_name_in_fat_file+0x8b8>
2035914: c2 2b 00 1b stb %g1, [ %o4 + %i3 ]
2035918: 82 10 60 40 or %g1, 0x40, %g1
203591c: c2 2b 00 1b stb %g1, [ %o4 + %i3 ]
*MSDOS_DIR_ATTR(entry) |= MSDOS_ATTR_LFN;
2035920: c2 0d 60 0b ldub [ %l5 + 0xb ], %g1
2035924: 84 00 a0 01 inc %g2
2035928: 82 10 60 0f or %g1, 0xf, %g1
203592c: 9a 03 7f f3 add %o5, -13, %o5
2035930: c2 2d 60 0b stb %g1, [ %l5 + 0xb ]
* 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(
2035934: b6 06 80 17 add %i2, %l7, %i3
#if MSDOS_FIND_PRINT
printf ("MSFS:[10] eso:%li\n", empty_space_offset);
#endif
for (dir_entry = empty_space_entry;
2035938: 80 a6 c0 11 cmp %i3, %l1
203593c: 0a bf ff 98 bcs 203579c <msdos_find_name_in_fat_file+0x734><== ALWAYS TAKEN
2035940: b0 00 bf ff add %g2, -1, %i0
if (lfn_entry == 1)
*MSDOS_DIR_ENTRY_TYPE(entry) |= MSDOS_LAST_LONG_ENTRY;
*MSDOS_DIR_ATTR(entry) |= MSDOS_ATTR_LFN;
}
ret = fat_file_write(&fs_info->fat, fat_fd,
2035944: d8 04 20 94 ld [ %l0 + 0x94 ], %o4 <== NOT EXECUTED
2035948: 90 10 00 10 mov %l0, %o0
203594c: 92 10 00 19 mov %i1, %o1
2035950: 94 07 40 17 add %i5, %l7, %o2
2035954: 96 10 00 1a mov %i2, %o3
2035958: 7f ff c1 1d call 2025dcc <fat_file_write>
203595c: 98 03 00 17 add %o4, %l7, %o4
(empty_space_offset * bts2rd) + empty_space_entry,
length, fs_info->cl_buf + empty_space_entry);
if (ret == -1)
2035960: 80 a2 3f ff cmp %o0, -1
2035964: 02 80 00 14 be 20359b4 <msdos_find_name_in_fat_file+0x94c><== NEVER TAKEN
2035968: 80 a2 00 1a cmp %o0, %i2
return ret;
else if (ret != length)
203596c: 02 80 00 08 be 203598c <msdos_find_name_in_fat_file+0x924><== ALWAYS TAKEN
2035970: ba 07 40 11 add %i5, %l1, %i5
rtems_set_errno_and_return_minus_one(EIO);
2035974: 40 00 32 1e call 20421ec <__errno> <== NOT EXECUTED
2035978: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
203597c: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
2035980: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
2035984: 81 c7 e0 08 ret <== NOT EXECUTED
2035988: 81 e8 00 00 restore <== NOT EXECUTED
empty_space_offset++;
203598c: ac 05 a0 01 inc %l6
empty_space_entry = 0;
2035990: ae 10 20 00 clr %l7
read_cluster = true;
2035994: b4 10 20 01 mov 1, %i2
#endif
/*
* The one more is the short entry.
*/
while (lfn_entry < (lfn_entries + 1))
2035998: 80 a4 c0 18 cmp %l3, %i0
203599c: 16 bf ff 47 bge 20356b8 <msdos_find_name_in_fat_file+0x650>
20359a0: 80 8e a0 ff btst 0xff, %i2
empty_space_offset++;
empty_space_entry = 0;
read_cluster = true;
}
return 0;
20359a4: 81 c7 e0 08 ret
20359a8: 91 e8 20 00 restore %g0, 0, %o0
dir_pos->sname.ofs = dir_entry;
if (lfn_start.cln != FAT_FILE_SHORT_NAME)
{
rc = fat_file_ioctl(&fs_info->fat, fat_fd, F_CLU_NUM,
20359ac: 81 c7 e0 08 ret <== NOT EXECUTED
20359b0: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED
}
ret = fat_file_write(&fs_info->fat, fat_fd,
(empty_space_offset * bts2rd) + empty_space_entry,
length, fs_info->cl_buf + empty_space_entry);
if (ret == -1)
20359b4: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
20359b8: 81 c7 e0 08 ret <== NOT EXECUTED
20359bc: 81 e8 00 00 restore <== NOT EXECUTED
* 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 ||
20359c0: 80 a0 60 00 cmp %g1, 0
20359c4: 02 bf fe c8 be 20354e4 <msdos_find_name_in_fat_file+0x47c>
20359c8: 82 10 3f ff mov -1, %g1
((name_type == MSDOS_NAME_SHORT) &&
20359cc: 10 bf fe 9c b 203543c <msdos_find_name_in_fat_file+0x3d4>
20359d0: de 07 bf f8 ld [ %fp + -8 ], %o7
020359d4 <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
)
{
20359d4: 9d e3 bf a0 save %sp, -96, %sp
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) &&
20359d8: c2 06 60 20 ld [ %i1 + 0x20 ], %g1
20359dc: 80 a0 60 01 cmp %g1, 1
20359e0: 12 80 00 0f bne 2035a1c <msdos_find_node_by_cluster_num_in_fat_file+0x48><== ALWAYS TAKEN
20359e4: fa 06 20 08 ld [ %i0 + 8 ], %i5
20359e8: c2 06 60 24 ld [ %i1 + 0x24 ], %g1 <== NOT EXECUTED
20359ec: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
20359f0: 32 80 00 07 bne,a 2035a0c <msdos_find_node_by_cluster_num_in_fat_file+0x38><== NOT EXECUTED
20359f4: f0 17 60 06 lduh [ %i5 + 6 ], %i0 <== NOT EXECUTED
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))
20359f8: c2 0f 60 0a ldub [ %i5 + 0xa ], %g1 <== 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) &&
20359fc: 80 88 60 03 btst 3, %g1 <== NOT EXECUTED
2035a00: 22 80 00 03 be,a 2035a0c <msdos_find_node_by_cluster_num_in_fat_file+0x38><== NOT EXECUTED
2035a04: f0 17 60 06 lduh [ %i5 + 6 ], %i0 <== NOT EXECUTED
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))
bts2rd = fat_fd->fat_file_size;
2035a08: f0 06 60 18 ld [ %i1 + 0x18 ], %i0 <== NOT EXECUTED
if ((*MSDOS_DIR_ENTRY_TYPE(entry)) ==
MSDOS_THIS_DIR_ENTRY_EMPTY)
continue;
/* if get a non-empty entry - compare clusters num */
if (MSDOS_EXTRACT_CLUSTER_NUM(entry) == cl4find)
2035a0c: 27 00 00 3f sethi %hi(0xfc00), %l3
assert(ret == bts2rd);
for (i = 0; i < bts2rd; i += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
{
char* entry = (char*) fs_info->cl_buf + i;
2035a10: a2 10 20 00 clr %l1
if ((*MSDOS_DIR_ENTRY_TYPE(entry)) ==
MSDOS_THIS_DIR_ENTRY_EMPTY)
continue;
/* if get a non-empty entry - compare clusters num */
if (MSDOS_EXTRACT_CLUSTER_NUM(entry) == cl4find)
2035a14: 10 80 00 44 b 2035b24 <msdos_find_node_by_cluster_num_in_fat_file+0x150>
2035a18: a6 14 e3 ff or %l3, 0x3ff, %l3
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;
2035a1c: 10 bf ff fc b 2035a0c <msdos_find_node_by_cluster_num_in_fat_file+0x38>
2035a20: f0 17 60 06 lduh [ %i5 + 6 ], %i0
while ((ret = fat_file_read(&fs_info->fat, fat_fd, j * bts2rd, bts2rd,
fs_info->cl_buf)) != FAT_EOF)
{
if ( ret < MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE )
2035a24: 14 80 00 08 bg 2035a44 <msdos_find_node_by_cluster_num_in_fat_file+0x70><== ALWAYS TAKEN
2035a28: 80 a2 00 18 cmp %o0, %i0
rtems_set_errno_and_return_minus_one( EIO );
2035a2c: 40 00 31 f0 call 20421ec <__errno> <== NOT EXECUTED
2035a30: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
2035a34: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
2035a38: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
2035a3c: 81 c7 e0 08 ret <== NOT EXECUTED
2035a40: 81 e8 00 00 restore <== NOT EXECUTED
assert(ret == bts2rd);
2035a44: 22 80 00 0a be,a 2035a6c <msdos_find_node_by_cluster_num_in_fat_file+0x98><== ALWAYS TAKEN
2035a48: e0 07 60 94 ld [ %i5 + 0x94 ], %l0
2035a4c: 11 00 81 9c sethi %hi(0x2067000), %o0 <== NOT EXECUTED
2035a50: 15 00 81 9c sethi %hi(0x2067000), %o2 <== NOT EXECUTED
2035a54: 17 00 81 9c sethi %hi(0x2067000), %o3 <== NOT EXECUTED
2035a58: 90 12 20 00 mov %o0, %o0 <== NOT EXECUTED
2035a5c: 92 10 26 49 mov 0x649, %o1 <== NOT EXECUTED
2035a60: 94 12 a0 f0 or %o2, 0xf0, %o2 <== NOT EXECUTED
2035a64: 7f ff c7 b4 call 2027934 <__assert_func> <== NOT EXECUTED
2035a68: 96 12 e0 a0 or %o3, 0xa0, %o3 <== NOT EXECUTED
for (i = 0; i < bts2rd; i += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
{
char* entry = (char*) fs_info->cl_buf + i;
2035a6c: a4 10 20 00 clr %l2
/* if this and all rest entries are empty - return not-found */
if ((*MSDOS_DIR_ENTRY_TYPE(entry)) ==
2035a70: c2 0c 00 00 ldub [ %l0 ], %g1
2035a74: 80 a0 60 00 cmp %g1, 0
2035a78: 02 80 00 34 be 2035b48 <msdos_find_node_by_cluster_num_in_fat_file+0x174><== NEVER TAKEN
2035a7c: 80 a0 60 e5 cmp %g1, 0xe5
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)) ==
2035a80: 22 80 00 25 be,a 2035b14 <msdos_find_node_by_cluster_num_in_fat_file+0x140><== NEVER TAKEN
2035a84: a4 04 a0 20 add %l2, 0x20, %l2 <== NOT EXECUTED
MSDOS_THIS_DIR_ENTRY_EMPTY)
continue;
/* if get a non-empty entry - compare clusters num */
if (MSDOS_EXTRACT_CLUSTER_NUM(entry) == cl4find)
2035a88: c4 14 20 14 lduh [ %l0 + 0x14 ], %g2
2035a8c: c2 14 20 1a lduh [ %l0 + 0x1a ], %g1
2035a90: 85 28 a0 10 sll %g2, 0x10, %g2
2035a94: 87 30 a0 18 srl %g2, 0x18, %g3
2035a98: 83 28 60 10 sll %g1, 0x10, %g1
2035a9c: 85 30 a0 08 srl %g2, 8, %g2
2035aa0: 84 08 80 13 and %g2, %l3, %g2
2035aa4: 84 10 c0 02 or %g3, %g2, %g2
2035aa8: 87 30 60 18 srl %g1, 0x18, %g3
2035aac: 85 28 a0 10 sll %g2, 0x10, %g2
2035ab0: 83 30 60 08 srl %g1, 8, %g1
2035ab4: 82 08 40 13 and %g1, %l3, %g1
2035ab8: 82 10 c0 01 or %g3, %g1, %g1
2035abc: 82 10 80 01 or %g2, %g1, %g1
2035ac0: 80 a0 40 1a cmp %g1, %i2
2035ac4: 32 80 00 14 bne,a 2035b14 <msdos_find_node_by_cluster_num_in_fat_file+0x140>
2035ac8: a4 04 a0 20 add %l2, 0x20, %l2
{
/* on success fill aux structure and copy all 32 bytes */
rc = fat_file_ioctl(&fs_info->fat, fat_fd, F_CLU_NUM, j * bts2rd,
2035acc: 90 10 00 1d mov %i5, %o0
2035ad0: 92 10 00 19 mov %i1, %o1
2035ad4: 94 10 20 01 mov 1, %o2
2035ad8: 96 10 00 11 mov %l1, %o3
2035adc: 7f ff bf ed call 2025a90 <fat_file_ioctl>
2035ae0: 98 10 00 1b mov %i3, %o4
&dir_pos->sname.cln);
if (rc != RC_OK)
2035ae4: b0 92 20 00 orcc %o0, 0, %i0
2035ae8: 12 bf ff d5 bne 2035a3c <msdos_find_node_by_cluster_num_in_fat_file+0x68><== NEVER TAKEN
2035aec: 82 10 3f ff mov -1, %g1
return rc;
dir_pos->sname.ofs = i;
2035af0: e4 26 e0 04 st %l2, [ %i3 + 4 ]
dir_pos->lname.cln = FAT_FILE_SHORT_NAME;
2035af4: c2 26 e0 08 st %g1, [ %i3 + 8 ]
dir_pos->lname.ofs = FAT_FILE_SHORT_NAME;
2035af8: c2 26 e0 0c st %g1, [ %i3 + 0xc ]
memcpy(dir_entry, entry,
2035afc: 90 10 00 1c mov %i4, %o0
2035b00: 92 10 00 10 mov %l0, %o1
2035b04: 40 00 3e f9 call 20456e8 <memcpy>
2035b08: 94 10 20 20 mov 0x20, %o2
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
return RC_OK;
2035b0c: 81 c7 e0 08 ret
2035b10: 81 e8 00 00 restore
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)
2035b14: 80 a4 80 18 cmp %l2, %i0
2035b18: 0a bf ff d6 bcs 2035a70 <msdos_find_node_by_cluster_num_in_fat_file+0x9c><== ALWAYS TAKEN
2035b1c: a0 04 20 20 add %l0, 0x20, %l0
2035b20: a2 04 40 18 add %l1, %i0, %l1 <== 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(&fs_info->fat, fat_fd, j * bts2rd, bts2rd,
2035b24: d8 07 60 94 ld [ %i5 + 0x94 ], %o4
2035b28: 90 10 00 1d mov %i5, %o0
2035b2c: 92 10 00 19 mov %i1, %o1
2035b30: 94 10 00 11 mov %l1, %o2
2035b34: 7f ff be f7 call 2025710 <fat_file_read>
2035b38: 96 10 00 18 mov %i0, %o3
2035b3c: 80 a2 20 00 cmp %o0, 0
2035b40: 12 bf ff b9 bne 2035a24 <msdos_find_node_by_cluster_num_in_fat_file+0x50><== ALWAYS TAKEN
2035b44: 80 a2 20 1f cmp %o0, 0x1f
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;
2035b48: 31 00 00 1f sethi %hi(0x7c00), %i0 <== NOT EXECUTED
2035b4c: b0 16 21 01 or %i0, 0x101, %i0 ! 7d01 <PROM_START+0x7d01> <== NOT EXECUTED
}
}
j++;
}
return MSDOS_NAME_NOT_FOUND_ERR;
}
2035b50: 81 c7 e0 08 ret <== NOT EXECUTED
2035b54: 81 e8 00 00 restore <== NOT EXECUTED
0201f920 <msdos_format>:
)
/*-------------------------------------------------------------------------*\
| Return Value: |
| 0, if success, -1 and errno if failed |
\*=========================================================================*/
{
201f920: 9d e3 bc e8 save %sp, -792, %sp
msdos_format_param_t fmt_params;
/*
* open device for writing
*/
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL, "open device\n");
201f924: 92 10 20 02 mov 2, %o1
201f928: 90 10 00 19 mov %i1, %o0
201f92c: 15 00 81 89 sethi %hi(0x2062400), %o2
201f930: 7f ff ff 84 call 201f740 <msdos_format_printf>
201f934: 94 12 a3 d0 or %o2, 0x3d0, %o2 ! 20627d0 <rtems_rtc_shell_usage+0xca0>
fd = open(devname, O_RDWR);
201f938: 92 10 20 02 mov 2, %o1
201f93c: 7f ff a8 6a call 2009ae4 <open>
201f940: 90 10 00 18 mov %i0, %o0
\*=========================================================================*/
{
char tmp_sec[FAT_TOTAL_MBR_SIZE];
int rc;
struct stat stat_buf;
int ret_val = 0;
201f944: 82 38 00 08 xnor %g0, %o0, %g1
201f948: 80 a0 00 01 cmp %g0, %g1
/*
* open device for writing
*/
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL, "open device\n");
fd = open(devname, O_RDWR);
201f94c: b4 10 00 08 mov %o0, %i2
\*=========================================================================*/
{
char tmp_sec[FAT_TOTAL_MBR_SIZE];
int rc;
struct stat stat_buf;
int ret_val = 0;
201f950: ba 40 3f ff addx %g0, -1, %i5
}
/*
* sanity check on device
*/
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
201f954: 90 10 00 19 mov %i1, %o0
201f958: 92 10 20 02 mov 2, %o1
201f95c: 15 00 81 89 sethi %hi(0x2062400), %o2
201f960: 96 10 00 18 mov %i0, %o3
201f964: 7f ff ff 77 call 201f740 <msdos_format_printf>
201f968: 94 12 a3 e0 or %o2, 0x3e0, %o2
"stat check: %s\n", devname);
if (ret_val == 0) {
201f96c: 80 a7 60 00 cmp %i5, 0
201f970: 12 80 00 06 bne 201f988 <msdos_format+0x68> <== NEVER TAKEN
201f974: b6 10 3f ff mov -1, %i3
rc = fstat(fd, &stat_buf);
201f978: 90 10 00 1a mov %i2, %o0
201f97c: 40 00 21 6a call 2027f24 <fstat>
201f980: 92 07 bd 68 add %fp, -664, %o1
201f984: b6 10 00 08 mov %o0, %i3
ret_val = rc;
}
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_INFO,
201f988: 90 10 00 19 mov %i1, %o0
201f98c: 92 10 20 01 mov 1, %o1
201f990: 15 00 81 89 sethi %hi(0x2062400), %o2
201f994: 96 10 00 18 mov %i0, %o3
201f998: 7f ff ff 6a call 201f740 <msdos_format_printf>
201f99c: 94 12 a3 f0 or %o2, 0x3f0, %o2
"formating: %s\n", devname);
/* rtems feature: no block devices, all are character devices */
if ((ret_val == 0) && (!S_ISBLK(stat_buf.st_mode))) {
201f9a0: 80 a6 e0 00 cmp %i3, 0
201f9a4: 12 80 01 9b bne 2020010 <msdos_format+0x6f0> <== NEVER TAKEN
201f9a8: c4 07 bd 74 ld [ %fp + -652 ], %g2
201f9ac: 03 00 00 3c sethi %hi(0xf000), %g1
201f9b0: 84 08 80 01 and %g2, %g1, %g2
201f9b4: 03 00 00 18 sethi %hi(0x6000), %g1
201f9b8: 80 a0 80 01 cmp %g2, %g1
201f9bc: 02 80 02 f4 be 202058c <msdos_format+0xc6c> <== ALWAYS TAKEN
201f9c0: 92 10 20 00 clr %o1
errno = ENOTTY;
201f9c4: 40 00 8a 0a call 20421ec <__errno> <== NOT EXECUTED
201f9c8: b6 10 3f ff mov -1, %i3 <== NOT EXECUTED
201f9cc: 82 10 20 19 mov 0x19, %g1 <== NOT EXECUTED
201f9d0: 10 80 03 15 b 2020624 <msdos_format+0xd04> <== NOT EXECUTED
201f9d4: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
static inline int rtems_disk_fd_get_block_count(
int fd,
rtems_blkdev_bnum *block_count
)
{
return ioctl(fd, RTEMS_BLKIO_GETSIZE, block_count);
201f9d8: 92 17 62 05 or %i5, 0x205, %o1
201f9dc: 7f ff a4 df call 2008d58 <ioctl>
201f9e0: 94 07 bd b4 add %fp, -588, %o2
ret_val = rtems_disk_fd_get_block_size(fd, &fmt_params->bytes_per_sector);
}
if (ret_val == 0) {
ret_val = rtems_disk_fd_get_block_count(fd, &fmt_params->totl_sector_cnt);
}
if (ret_val == 0) {
201f9e4: b0 92 20 00 orcc %o0, 0, %i0
201f9e8: 12 80 01 2e bne 201fea0 <msdos_format+0x580> <== NEVER TAKEN
201f9ec: e2 07 bd b0 ld [ %fp + -592 ], %l1
total_size = fmt_params->bytes_per_sector * fmt_params->totl_sector_cnt;
201f9f0: e0 07 bd b4 ld [ %fp + -588 ], %l0
201f9f4: 92 10 00 11 mov %l1, %o1
201f9f8: 7f ff 8d 1b call 2002e64 <.umul>
201f9fc: 90 10 00 10 mov %l0, %o0
201fa00: b8 10 20 00 clr %i4
201fa04: ba 10 00 08 mov %o0, %i5
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
201fa08: d0 23 a0 5c st %o0, [ %sp + 0x5c ]
201fa0c: f8 3f bd 60 std %i4, [ %fp + -672 ]
201fa10: 9a 10 20 00 clr %o5
201fa14: 90 10 00 19 mov %i1, %o0
201fa18: 92 10 20 02 mov 2, %o1
201fa1c: 15 00 81 8a sethi %hi(0x2062800), %o2
201fa20: 96 10 00 11 mov %l1, %o3
201fa24: 94 12 a0 00 mov %o2, %o2
201fa28: 7f ff ff 46 call 201f740 <msdos_format_printf>
201fa2c: 98 10 00 10 mov %l0, %o4
/*
* determine number of FATs
*/
if (ret_val == 0) {
if ((rqdata == NULL) ||
201fa30: 80 a6 60 00 cmp %i1, 0
201fa34: 02 80 00 0a be 201fa5c <msdos_format+0x13c>
201fa38: 82 10 20 02 mov 2, %g1
(rqdata->fat_num == 0)) {
201fa3c: c2 06 60 0c ld [ %i1 + 0xc ], %g1
/*
* determine number of FATs
*/
if (ret_val == 0) {
if ((rqdata == NULL) ||
201fa40: 80 a0 60 00 cmp %g1, 0
201fa44: 12 80 00 04 bne 201fa54 <msdos_format+0x134> <== NEVER TAKEN
201fa48: 80 a0 60 06 cmp %g1, 6
(rqdata->fat_num == 0)) {
fmt_params->fat_num = 2;
201fa4c: 10 80 00 04 b 201fa5c <msdos_format+0x13c>
201fa50: 82 10 20 02 mov 2, %g1
}
else if (rqdata->fat_num <= 6) {
201fa54: 38 80 01 13 bgu,a 201fea0 <msdos_format+0x580> <== NOT EXECUTED
201fa58: b0 10 20 16 mov 0x16, %i0 <== NOT EXECUTED
fmt_params->fat_num = rqdata->fat_num;
201fa5c: 10 80 02 d9 b 20205c0 <msdos_format+0xca0>
201fa60: c2 2f bd e0 stb %g1, [ %fp + -544 ]
* determine FAT type and sectors per cluster
* depends on
*/
if (ret_val == 0) {
fmt_params->sectors_per_cluster = 1;
if ((rqdata != NULL) &&
201fa64: c2 0e 60 14 ldub [ %i1 + 0x14 ], %g1
201fa68: 80 a0 60 01 cmp %g1, 1
201fa6c: 12 80 00 04 bne 201fa7c <msdos_format+0x15c> <== ALWAYS TAKEN
201fa70: 80 a0 60 02 cmp %g1, 2
(rqdata->fattype == MSDOS_FMT_FAT16)) {
fmt_params->fattype = FAT_FAT16;
}
else if ((rqdata != NULL) &&
(rqdata->fattype == MSDOS_FMT_FAT32)) {
fmt_params->fattype = FAT_FAT32;
201fa74: 10 80 00 45 b 201fb88 <msdos_format+0x268> <== NOT EXECUTED
201fa78: c2 2f bd e2 stb %g1, [ %fp + -542 ] <== NOT EXECUTED
fmt_params->sectors_per_cluster = 1;
if ((rqdata != NULL) &&
(rqdata->fattype == MSDOS_FMT_FAT12)) {
fmt_params->fattype = FAT_FAT12;
}
else if ((rqdata != NULL) &&
201fa7c: 12 80 00 04 bne 201fa8c <msdos_format+0x16c> <== ALWAYS TAKEN
201fa80: 80 a0 60 03 cmp %g1, 3
(rqdata->fattype == MSDOS_FMT_FAT16)) {
fmt_params->fattype = FAT_FAT16;
}
else if ((rqdata != NULL) &&
(rqdata->fattype == MSDOS_FMT_FAT32)) {
fmt_params->fattype = FAT_FAT32;
201fa84: 10 80 00 41 b 201fb88 <msdos_format+0x268> <== NOT EXECUTED
201fa88: c2 2f bd e2 stb %g1, [ %fp + -542 ] <== NOT EXECUTED
}
else if ((rqdata != NULL) &&
(rqdata->fattype == MSDOS_FMT_FAT16)) {
fmt_params->fattype = FAT_FAT16;
}
else if ((rqdata != NULL) &&
201fa8c: 12 80 00 05 bne 201faa0 <msdos_format+0x180> <== ALWAYS TAKEN
201fa90: 80 a0 60 00 cmp %g1, 0
(rqdata->fattype == MSDOS_FMT_FAT32)) {
fmt_params->fattype = FAT_FAT32;
201fa94: 82 10 20 04 mov 4, %g1 <== NOT EXECUTED
201fa98: 10 80 00 3c b 201fb88 <msdos_format+0x268> <== NOT EXECUTED
201fa9c: c2 2f bd e2 stb %g1, [ %fp + -542 ] <== NOT EXECUTED
}
else if ((rqdata != NULL) &&
201faa0: 22 80 00 07 be,a 201fabc <msdos_format+0x19c> <== ALWAYS TAKEN
201faa4: c2 06 60 08 ld [ %i1 + 8 ], %g1
(rqdata->fattype != MSDOS_FMT_FATANY)) {
ret_val = -1;
errno = EINVAL;
201faa8: 40 00 89 d1 call 20421ec <__errno> <== NOT EXECUTED
201faac: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
201fab0: 82 10 20 16 mov 0x16, %g1 <== NOT EXECUTED
201fab4: 10 80 00 35 b 201fb88 <msdos_format+0x268> <== NOT EXECUTED
201fab8: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
* are a compromise concerning capacity and efficency
*/
uint32_t fat12_sect_per_clust = 8;
uint32_t fat16_sect_per_clust = 32;
if (rqdata != NULL && rqdata->sectors_per_cluster != 0) {
201fabc: 84 90 60 00 orcc %g1, 0, %g2
201fac0: 12 80 00 05 bne 201fad4 <msdos_format+0x1b4> <== NEVER TAKEN
201fac4: c6 07 bd b4 ld [ %fp + -588 ], %g3
* 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
*/
uint32_t fat12_sect_per_clust = 8;
uint32_t fat16_sect_per_clust = 32;
201fac8: 84 10 20 20 mov 0x20, %g2
/*
* 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
*/
uint32_t fat12_sect_per_clust = 8;
201facc: 82 10 20 08 mov 8, %g1
if (rqdata != NULL && rqdata->sectors_per_cluster != 0) {
fat12_sect_per_clust = rqdata->sectors_per_cluster;
fat16_sect_per_clust = rqdata->sectors_per_cluster;
}
if (fmt_params->totl_sector_cnt
201fad0: c6 07 bd b4 ld [ %fp + -588 ], %g3
< FAT_FAT12_MAX_CLN * fat12_sect_per_clust) {
201fad4: 89 28 60 02 sll %g1, 2, %g4
201fad8: 9f 28 60 0a sll %g1, 0xa, %o7
201fadc: 88 23 c0 04 sub %o7, %g4, %g4
201fae0: 88 01 00 01 add %g4, %g1, %g4
201fae4: 89 29 20 02 sll %g4, 2, %g4
201fae8: 82 01 00 01 add %g4, %g1, %g1
if (rqdata != NULL && rqdata->sectors_per_cluster != 0) {
fat12_sect_per_clust = rqdata->sectors_per_cluster;
fat16_sect_per_clust = rqdata->sectors_per_cluster;
}
if (fmt_params->totl_sector_cnt
201faec: 80 a0 c0 01 cmp %g3, %g1
201faf0: 3a 80 00 04 bcc,a 201fb00 <msdos_format+0x1e0> <== NEVER TAKEN
201faf4: 83 28 a0 02 sll %g2, 2, %g1 <== NOT EXECUTED
< FAT_FAT12_MAX_CLN * fat12_sect_per_clust) {
fmt_params->fattype = FAT_FAT12;
201faf8: 10 80 00 0b b 201fb24 <msdos_format+0x204>
201fafc: 82 10 20 01 mov 1, %g1
/* start trying with small clusters */
fmt_params->sectors_per_cluster = 2;
}
else if (fmt_params->totl_sector_cnt
< FAT_FAT16_MAX_CLN * fat16_sect_per_clust) {
201fb00: 89 28 a0 0e sll %g2, 0xe, %g4 <== NOT EXECUTED
201fb04: 82 21 00 01 sub %g4, %g1, %g1 <== NOT EXECUTED
201fb08: 82 00 40 02 add %g1, %g2, %g1 <== NOT EXECUTED
201fb0c: 83 28 60 02 sll %g1, 2, %g1 <== NOT EXECUTED
201fb10: 84 00 40 02 add %g1, %g2, %g2 <== NOT EXECUTED
< FAT_FAT12_MAX_CLN * fat12_sect_per_clust) {
fmt_params->fattype = FAT_FAT12;
/* start trying with small clusters */
fmt_params->sectors_per_cluster = 2;
}
else if (fmt_params->totl_sector_cnt
201fb14: 80 a0 c0 02 cmp %g3, %g2 <== NOT EXECUTED
201fb18: 1a 80 00 06 bcc 201fb30 <msdos_format+0x210> <== NOT EXECUTED
201fb1c: 84 10 20 00 clr %g2 <== NOT EXECUTED
< FAT_FAT16_MAX_CLN * fat16_sect_per_clust) {
fmt_params->fattype = FAT_FAT16;
201fb20: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED
201fb24: c2 2f bd e2 stb %g1, [ %fp + -542 ]
/* start trying with small clusters */
fmt_params->sectors_per_cluster = 2;
201fb28: 10 80 00 15 b 201fb7c <msdos_format+0x25c>
201fb2c: 82 10 20 02 mov 2, %g1
}
else {
#define ONE_GB (1024L * 1024L * 1024L)
uint32_t gigs = (total_size + ONE_GB) / ONE_GB;
201fb30: 07 10 00 00 sethi %hi(0x40000000), %g3 <== NOT EXECUTED
201fb34: ba 87 40 03 addcc %i5, %g3, %i5 <== NOT EXECUTED
201fb38: 83 37 60 1e srl %i5, 0x1e, %g1 <== NOT EXECUTED
201fb3c: b8 47 00 02 addx %i4, %g2, %i4 <== NOT EXECUTED
201fb40: 85 2f 20 02 sll %i4, 2, %g2 <== NOT EXECUTED
201fb44: 84 10 80 01 or %g2, %g1, %g2 <== NOT EXECUTED
int b;
fmt_params->fattype = FAT_FAT32;
201fb48: 82 10 20 04 mov 4, %g1 <== NOT EXECUTED
/* scale with the size of disk... */
for (b = 31; b > 0; b--)
if ((gigs & (1 << b)) != 0)
201fb4c: 86 10 20 01 mov 1, %g3 <== NOT EXECUTED
}
else {
#define ONE_GB (1024L * 1024L * 1024L)
uint32_t gigs = (total_size + ONE_GB) / ONE_GB;
int b;
fmt_params->fattype = FAT_FAT32;
201fb50: c2 2f bd e2 stb %g1, [ %fp + -542 ] <== NOT EXECUTED
/* scale with the size of disk... */
for (b = 31; b > 0; b--)
201fb54: 82 10 20 1f mov 0x1f, %g1 <== NOT EXECUTED
if ((gigs & (1 << b)) != 0)
201fb58: 89 28 c0 01 sll %g3, %g1, %g4 <== NOT EXECUTED
201fb5c: 80 89 00 02 btst %g4, %g2 <== NOT EXECUTED
201fb60: 32 80 00 06 bne,a 201fb78 <msdos_format+0x258> <== NOT EXECUTED
201fb64: 84 10 20 01 mov 1, %g2 <== 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--)
201fb68: 82 80 7f ff addcc %g1, -1, %g1 <== NOT EXECUTED
201fb6c: 12 bf ff fc bne 201fb5c <msdos_format+0x23c> <== NOT EXECUTED
201fb70: 89 28 c0 01 sll %g3, %g1, %g4 <== NOT EXECUTED
if ((gigs & (1 << b)) != 0)
break;
fmt_params->sectors_per_cluster = 1 << b;
201fb74: 84 10 20 01 mov 1, %g2 <== NOT EXECUTED
201fb78: 83 28 80 01 sll %g2, %g1, %g1 <== NOT EXECUTED
}
}
/*
* try to use user requested cluster size
*/
if ((rqdata != NULL) &&
201fb7c: 80 a6 60 00 cmp %i1, 0
201fb80: 02 80 00 06 be 201fb98 <msdos_format+0x278>
201fb84: c2 27 bd bc st %g1, [ %fp + -580 ]
(rqdata->sectors_per_cluster > 0)) {
201fb88: c2 06 60 08 ld [ %i1 + 8 ], %g1
}
}
/*
* try to use user requested cluster size
*/
if ((rqdata != NULL) &&
201fb8c: 80 a0 60 00 cmp %g1, 0
201fb90: 32 80 00 02 bne,a 201fb98 <msdos_format+0x278> <== NEVER TAKEN
201fb94: c2 27 bd bc st %g1, [ %fp + -580 ] <== 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) {
201fb98: f8 07 bd b0 ld [ %fp + -592 ], %i4
201fb9c: d6 07 bd bc ld [ %fp + -580 ], %o3
201fba0: ba 10 20 80 mov 0x80, %i5
* 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) {
201fba4: 80 a2 c0 1d cmp %o3, %i5
201fba8: 2a 80 00 0c bcs,a 201fbd8 <msdos_format+0x2b8>
201fbac: bb 37 60 01 srl %i5, 1, %i5
fmt_params->sectors_per_cluster = onebit;
if (fmt_params->sectors_per_cluster
<= 32768L/fmt_params->bytes_per_sector) {
201fbb0: 11 00 00 20 sethi %hi(0x8000), %o0
201fbb4: 40 00 ee 73 call 205b580 <.udiv>
201fbb8: 92 10 00 1c mov %i4, %o1
* 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
201fbbc: 80 a7 40 08 cmp %i5, %o0
201fbc0: 08 80 00 04 bleu 201fbd0 <msdos_format+0x2b0> <== ALWAYS TAKEN
201fbc4: 96 10 00 1d mov %i5, %o3
* 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) {
201fbc8: 10 80 00 04 b 201fbd8 <msdos_format+0x2b8> <== NOT EXECUTED
201fbcc: bb 37 60 01 srl %i5, 1, %i5 <== NOT EXECUTED
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) {
/* value is small enough so this value is ok */
onebit = 1;
201fbd0: ba 10 20 01 mov 1, %i5
* 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) {
201fbd4: bb 37 60 01 srl %i5, 1, %i5
201fbd8: 80 a7 60 00 cmp %i5, 0
201fbdc: 12 bf ff f3 bne 201fba8 <msdos_format+0x288>
201fbe0: 80 a2 c0 1d cmp %o3, %i5
}
}
}
}
if (ret_val == 0) {
201fbe4: 80 a6 20 00 cmp %i0, 0
201fbe8: 12 80 00 ad bne 201fe9c <msdos_format+0x57c> <== NEVER TAKEN
201fbec: d6 27 bd bc st %o3, [ %fp + -580 ]
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
201fbf0: 90 10 00 19 mov %i1, %o0
201fbf4: 92 10 20 02 mov 2, %o1
201fbf8: 15 00 81 8a sethi %hi(0x2062800), %o2
201fbfc: 7f ff fe d1 call 201f740 <msdos_format_printf>
201fc00: 94 12 a0 40 or %o2, 0x40, %o2 ! 2062840 <rtems_rtc_shell_usage+0xd10>
"sectors per cluster: %d\n", fmt_params->sectors_per_cluster);
if (fmt_params->fattype == FAT_FAT32) {
201fc04: f8 0f bd e2 ldub [ %fp + -542 ], %i4
201fc08: 82 0f 20 ff and %i4, 0xff, %g1
201fc0c: 80 a0 60 04 cmp %g1, 4
201fc10: 12 80 00 0a bne 201fc38 <msdos_format+0x318> <== ALWAYS TAKEN
201fc14: 82 10 20 01 mov 1, %g1
/* recommended: for FAT32, always set reserved sector count to 32 */
fmt_params->rsvd_sector_cnt = 32;
201fc18: 82 10 20 20 mov 0x20, %g1 <== NOT EXECUTED
201fc1c: c2 27 bd b8 st %g1, [ %fp + -584 ] <== 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;
201fc20: 82 10 20 06 mov 6, %g1 <== NOT EXECUTED
if (fmt_params->fattype == FAT_FAT32) {
/* recommended: for FAT32, always set reserved sector count to 32 */
fmt_params->rsvd_sector_cnt = 32;
/* for FAT32, always set files per root directory 0 */
fmt_params->files_per_root_dir = 0;
201fc24: c0 27 bd c8 clr [ %fp + -568 ] <== NOT EXECUTED
/* location of copy of MBR */
fmt_params->mbr_copy_sec = 6;
201fc28: c2 27 bd d8 st %g1, [ %fp + -552 ] <== NOT EXECUTED
/* location of fsinfo sector */
fmt_params->fsinfo_sec = 1;
201fc2c: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED
201fc30: 10 80 00 1b b 201fc9c <msdos_format+0x37c> <== NOT EXECUTED
201fc34: c2 27 bd dc st %g1, [ %fp + -548 ] <== 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) &&
201fc38: 80 a6 60 00 cmp %i1, 0
201fc3c: 02 80 00 08 be 201fc5c <msdos_format+0x33c>
201fc40: c2 27 bd b8 st %g1, [ %fp + -584 ]
(rqdata->files_per_root_dir > 0)) {
201fc44: c2 06 60 10 ld [ %i1 + 0x10 ], %g1
/* 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) &&
201fc48: 80 a0 60 00 cmp %g1, 0
201fc4c: 22 80 00 05 be,a 201fc60 <msdos_format+0x340> <== ALWAYS TAKEN
201fc50: 82 0f 20 ff and %i4, 0xff, %g1
else {
if (fmt_params->fattype == FAT_FAT16) {
fmt_params->files_per_root_dir = 512;
}
else {
fmt_params->files_per_root_dir = 64;
201fc54: 10 80 00 08 b 201fc74 <msdos_format+0x354> <== NOT EXECUTED
201fc58: c2 27 bd c8 st %g1, [ %fp + -568 ] <== NOT EXECUTED
if ((rqdata != NULL) &&
(rqdata->files_per_root_dir > 0)) {
fmt_params->files_per_root_dir = rqdata->files_per_root_dir;
}
else {
if (fmt_params->fattype == FAT_FAT16) {
201fc5c: 82 0f 20 ff and %i4, 0xff, %g1
201fc60: 80 a0 60 02 cmp %g1, 2
201fc64: 32 80 00 03 bne,a 201fc70 <msdos_format+0x350> <== ALWAYS TAKEN
201fc68: 82 10 20 40 mov 0x40, %g1
201fc6c: 82 10 22 00 mov 0x200, %g1 <== NOT EXECUTED
fmt_params->files_per_root_dir = 512;
}
else {
fmt_params->files_per_root_dir = 64;
201fc70: c2 27 bd c8 st %g1, [ %fp + -568 ]
}
}
fmt_params->files_per_root_dir = (fmt_params->files_per_root_dir +
(2*fmt_params->bytes_per_sector/
201fc74: d2 07 bd b0 ld [ %fp + -592 ], %o1
}
else {
fmt_params->files_per_root_dir = 64;
}
}
fmt_params->files_per_root_dir = (fmt_params->files_per_root_dir +
201fc78: fa 07 bd c8 ld [ %fp + -568 ], %i5
(2*fmt_params->bytes_per_sector/
201fc7c: 93 2a 60 01 sll %o1, 1, %o1
}
else {
fmt_params->files_per_root_dir = 64;
}
}
fmt_params->files_per_root_dir = (fmt_params->files_per_root_dir +
201fc80: ba 07 7f ff add %i5, -1, %i5
(2*fmt_params->bytes_per_sector/
201fc84: 93 32 60 05 srl %o1, 5, %o1
}
else {
fmt_params->files_per_root_dir = 64;
}
}
fmt_params->files_per_root_dir = (fmt_params->files_per_root_dir +
201fc88: ba 07 40 09 add %i5, %o1, %i5
(2*fmt_params->bytes_per_sector/
FAT_DIRENTRY_SIZE-1));
fmt_params->files_per_root_dir -= (fmt_params->files_per_root_dir %
201fc8c: 40 00 ee e9 call 205b830 <.urem>
201fc90: 90 10 00 1d mov %i5, %o0
201fc94: 90 27 40 08 sub %i5, %o0, %o0
201fc98: d0 27 bd c8 st %o0, [ %fp + -568 ]
(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)
201fc9c: fa 07 bd b0 ld [ %fp + -592 ], %i5
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)
201fca0: d0 07 bd c8 ld [ %fp + -568 ], %o0
+ fmt_params->bytes_per_sector - 1)
/ fmt_params->bytes_per_sector);
201fca4: 92 10 00 1d mov %i5, %o1
(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)
201fca8: a0 07 7f ff add %i5, -1, %l0
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)
201fcac: 91 2a 20 05 sll %o0, 5, %o0
+ fmt_params->bytes_per_sector - 1)
/ fmt_params->bytes_per_sector);
201fcb0: 40 00 ee 34 call 205b580 <.udiv>
201fcb4: 90 04 00 08 add %l0, %o0, %o0
}
if (ret_val == 0) {
fatdata_sect_cnt = (fmt_params->totl_sector_cnt -
201fcb8: c2 07 bd b8 ld [ %fp + -584 ], %g1
201fcbc: e4 07 bd b4 ld [ %fp + -588 ], %l2
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 =
201fcc0: d0 27 bd cc st %o0, [ %fp + -564 ]
(((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 -
201fcc4: a4 24 80 01 sub %l2, %g1, %l2
/*
* check values to get legal arrangement of FAT type and cluster count
*/
ret_val = msdos_format_eval_sectors_per_cluster
(fmt_params->fattype,
201fcc8: b8 0f 20 ff and %i4, 0xff, %i4
(((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 -
201fccc: a4 24 80 08 sub %l2, %o0, %l2
/*
* check values to get legal arrangement of FAT type and cluster count
*/
ret_val = msdos_format_eval_sectors_per_cluster
(fmt_params->fattype,
201fcd0: e6 0f bd e0 ldub [ %fp + -544 ], %l3
201fcd4: e2 07 bd bc ld [ %fp + -580 ], %l1
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) {
201fcd8: 92 10 00 1d mov %i5, %o1
201fcdc: 40 00 ee 29 call 205b580 <.udiv>
201fce0: 11 00 00 20 sethi %hi(0x8000), %o0
201fce4: 10 80 00 03 b 201fcf0 <msdos_format+0x3d0>
201fce8: 80 a2 00 11 cmp %o0, %l1
201fcec: 80 a2 00 11 cmp %o0, %l1 <== NOT EXECUTED
201fcf0: 2a bf ff ff bcs,a 201fcec <msdos_format+0x3cc> <== NEVER TAKEN
201fcf4: a3 34 60 01 srl %l1, 1, %l1 <== NOT EXECUTED
/ sectors_per_cluster));
/*
* data cluster count too big? then make sectors bigger
*/
if (((fattype == FAT_FAT12) && (data_cluster_cnt > FAT_FAT12_MAX_CLN)) ||
((fattype == FAT_FAT16) && (data_cluster_cnt > FAT_FAT16_MAX_CLN))) {
201fcf8: 84 1f 20 02 xor %i4, 2, %g2
+ (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)) ||
201fcfc: 80 a0 00 02 cmp %g0, %g2
((fattype == FAT_FAT16) && (data_cluster_cnt > FAT_FAT16_MAX_CLN))) {
201fd00: 29 00 00 3f sethi %hi(0xfc00), %l4
+ (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)) ||
201fd04: aa 60 3f ff subx %g0, -1, %l5
201fd08: 84 1f 20 01 xor %i4, 1, %g2
sectors_per_fat = ((fat_capacity
+ (bytes_per_sector - 1))
/ bytes_per_sector);
data_cluster_cnt = (fatdata_cluster_cnt -
(((sectors_per_fat * fat_num)
201fd0c: a6 0c e0 ff and %l3, 0xff, %l3
+ (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)) ||
201fd10: 80 a0 00 02 cmp %g0, %g2
((fattype == FAT_FAT16) && (data_cluster_cnt > FAT_FAT16_MAX_CLN))) {
201fd14: a8 15 23 f5 or %l4, 0x3f5, %l4
+ (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)) ||
201fd18: ac 60 3f ff subx %g0, -1, %l6
finished = true;
}
/*
* when maximum cluster size is exceeded, we have invalid data, abort...
*/
if ((sectors_per_cluster * bytes_per_sector)
201fd1c: 2f 00 00 20 sethi %hi(0x8000), %l7
* 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;
201fd20: 90 10 00 12 mov %l2, %o0
201fd24: 40 00 ee 17 call 205b580 <.udiv>
201fd28: 92 10 00 11 mov %l1, %o1
if (fattype == FAT_FAT12) {
201fd2c: 80 a7 20 01 cmp %i4, 1
201fd30: 12 80 00 06 bne 201fd48 <msdos_format+0x428> <== NEVER TAKEN
201fd34: 84 10 00 08 mov %o0, %g2
fat_capacity = fatdata_cluster_cnt * 3 / 2;
201fd38: 91 2a 20 01 sll %o0, 1, %o0
201fd3c: 90 02 00 02 add %o0, %g2, %o0
201fd40: 10 80 00 06 b 201fd58 <msdos_format+0x438>
201fd44: 91 32 20 01 srl %o0, 1, %o0
}
else if (fattype == FAT_FAT16) {
201fd48: 80 a7 20 02 cmp %i4, 2 <== NOT EXECUTED
201fd4c: 12 80 00 03 bne 201fd58 <msdos_format+0x438> <== NOT EXECUTED
201fd50: 91 2a 20 02 sll %o0, 2, %o0 <== NOT EXECUTED
fat_capacity = fatdata_cluster_cnt * 2;
201fd54: 91 28 a0 01 sll %g2, 1, %o0 <== NOT EXECUTED
}
else { /* FAT32 */
fat_capacity = fatdata_cluster_cnt * 4;
}
sectors_per_fat = ((fat_capacity
201fd58: c4 27 bd 50 st %g2, [ %fp + -688 ]
201fd5c: 92 10 00 1d mov %i5, %o1
201fd60: 40 00 ee 08 call 205b580 <.udiv>
201fd64: 90 02 00 10 add %o0, %l0, %o0
+ (bytes_per_sector - 1))
/ bytes_per_sector);
data_cluster_cnt = (fatdata_cluster_cnt -
(((sectors_per_fat * fat_num)
+ (sectors_per_cluster - 1))
201fd68: 86 04 7f ff add %l1, -1, %g3
sectors_per_fat = ((fat_capacity
+ (bytes_per_sector - 1))
/ bytes_per_sector);
data_cluster_cnt = (fatdata_cluster_cnt -
(((sectors_per_fat * fat_num)
201fd6c: 92 10 00 13 mov %l3, %o1
201fd70: c6 27 bd 54 st %g3, [ %fp + -684 ]
201fd74: 7f ff 8c 3c call 2002e64 <.umul>
201fd78: d0 27 bd 5c st %o0, [ %fp + -676 ]
+ (sectors_per_cluster - 1))
/ sectors_per_cluster));
201fd7c: c6 07 bd 54 ld [ %fp + -684 ], %g3
201fd80: 92 10 00 11 mov %l1, %o1
201fd84: 40 00 ed ff call 205b580 <.udiv>
201fd88: 90 00 c0 08 add %g3, %o0, %o0
sectors_per_fat = ((fat_capacity
+ (bytes_per_sector - 1))
/ bytes_per_sector);
data_cluster_cnt = (fatdata_cluster_cnt -
201fd8c: c4 07 bd 50 ld [ %fp + -688 ], %g2
201fd90: 90 20 80 08 sub %g2, %o0, %o0
+ (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)) ||
201fd94: 80 a2 2f f5 cmp %o0, 0xff5
201fd98: 18 80 00 03 bgu 201fda4 <msdos_format+0x484> <== NEVER TAKEN
201fd9c: 86 10 20 01 mov 1, %g3
201fda0: 86 10 20 00 clr %g3
201fda4: 80 88 e0 ff btst 0xff, %g3
201fda8: 02 80 00 06 be 201fdc0 <msdos_format+0x4a0> <== ALWAYS TAKEN
201fdac: 80 a5 00 08 cmp %l4, %o0
201fdb0: 80 a5 a0 00 cmp %l6, 0 <== NOT EXECUTED
201fdb4: 32 80 00 09 bne,a 201fdd8 <msdos_format+0x4b8> <== NOT EXECUTED
201fdb8: a3 2c 60 01 sll %l1, 1, %l1 <== NOT EXECUTED
201fdbc: 80 a5 00 08 cmp %l4, %o0 <== NOT EXECUTED
201fdc0: 1a 80 00 08 bcc 201fde0 <msdos_format+0x4c0> <== ALWAYS TAKEN
201fdc4: 84 10 20 01 mov 1, %g2
201fdc8: 80 a5 60 00 cmp %l5, 0 <== NOT EXECUTED
201fdcc: 22 80 00 06 be,a 201fde4 <msdos_format+0x4c4> <== NOT EXECUTED
201fdd0: c4 27 bd 50 st %g2, [ %fp + -688 ] <== NOT EXECUTED
((fattype == FAT_FAT16) && (data_cluster_cnt > FAT_FAT16_MAX_CLN))) {
sectors_per_cluster *= 2;
201fdd4: a3 2c 60 01 sll %l1, 1, %l1 <== NOT EXECUTED
201fdd8: 10 80 00 02 b 201fde0 <msdos_format+0x4c0> <== NOT EXECUTED
201fddc: 84 10 20 00 clr %g2 <== NOT EXECUTED
finished = true;
}
/*
* when maximum cluster size is exceeded, we have invalid data, abort...
*/
if ((sectors_per_cluster * bytes_per_sector)
201fde0: c4 27 bd 50 st %g2, [ %fp + -688 ]
201fde4: 90 10 00 11 mov %l1, %o0
201fde8: 7f ff 8c 1f call 2002e64 <.umul>
201fdec: 92 10 00 1d mov %i5, %o1
201fdf0: 80 a2 00 17 cmp %o0, %l7
201fdf4: 18 80 00 08 bgu 201fe14 <msdos_format+0x4f4> <== NEVER TAKEN
201fdf8: c4 07 bd 50 ld [ %fp + -688 ], %g2
> MS_BYTES_PER_CLUSTER_LIMIT) {
ret_val = EINVAL;
finished = true;
}
} while (!finished);
201fdfc: 80 88 a0 ff btst 0xff, %g2
201fe00: 02 bf ff c9 be 201fd24 <msdos_format+0x404> <== NEVER TAKEN
201fe04: 90 10 00 12 mov %l2, %o0
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;
201fe08: c2 07 bd 5c ld [ %fp + -676 ], %g1
201fe0c: 10 80 00 07 b 201fe28 <msdos_format+0x508>
201fe10: c2 27 bd c0 st %g1, [ %fp + -576 ]
finished = true;
}
} while (!finished);
if (ret_val != 0) {
rtems_set_errno_and_return_minus_one(ret_val);
201fe14: 40 00 88 f6 call 20421ec <__errno> <== NOT EXECUTED
201fe18: a2 10 20 00 clr %l1 <== NOT EXECUTED
201fe1c: 82 10 20 16 mov 0x16, %g1 <== NOT EXECUTED
201fe20: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
201fe24: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
}
/*
* determine media code
*/
if (ret_val == 0) {
201fe28: 80 a6 20 00 cmp %i0, 0
201fe2c: 12 80 00 1c bne 201fe9c <msdos_format+0x57c> <== NEVER TAKEN
201fe30: e2 27 bd bc st %l1, [ %fp + -580 ]
if ((rqdata != NULL) &&
201fe34: 80 a6 60 00 cmp %i1, 0
201fe38: 02 80 00 17 be 201fe94 <msdos_format+0x574>
201fe3c: 82 10 3f f8 mov -8, %g1
(rqdata->media != 0)) {
201fe40: fa 0e 60 15 ldub [ %i1 + 0x15 ], %i5
/*
* determine media code
*/
if (ret_val == 0) {
if ((rqdata != NULL) &&
201fe44: b8 8f 60 ff andcc %i5, 0xff, %i4
201fe48: 22 80 00 16 be,a 201fea0 <msdos_format+0x580> <== ALWAYS TAKEN
201fe4c: c2 2f bd e1 stb %g1, [ %fp + -543 ]
(rqdata->media != 0)) {
const char valid_media_codes[] =
201fe50: 94 10 20 09 mov 9, %o2 <== NOT EXECUTED
201fe54: 90 07 be 00 add %fp, -512, %o0 <== NOT EXECUTED
201fe58: 13 00 81 8a sethi %hi(0x2062800), %o1 <== NOT EXECUTED
201fe5c: 40 00 96 23 call 20456e8 <memcpy> <== NOT EXECUTED
201fe60: 92 12 60 f0 or %o1, 0xf0, %o1 ! 20628f0 <rtems_rtc_shell_usage+0xdc0><== NOT EXECUTED
{0xF0,0xF8,0xF9,0xFA,0xFB,0xFC,0xFD,0xFE,0xFF};
if (NULL==memchr(valid_media_codes,
201fe64: 90 07 be 00 add %fp, -512, %o0 <== NOT EXECUTED
201fe68: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
201fe6c: 40 00 95 b1 call 2045530 <memchr> <== NOT EXECUTED
201fe70: 94 10 20 09 mov 9, %o2 <== NOT EXECUTED
201fe74: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
201fe78: 32 80 00 0a bne,a 201fea0 <msdos_format+0x580> <== NOT EXECUTED
201fe7c: fa 2f bd e1 stb %i5, [ %fp + -543 ] <== NOT EXECUTED
rqdata->media,
sizeof(valid_media_codes))) {
ret_val = -1;
errno = EINVAL;
201fe80: 40 00 88 db call 20421ec <__errno> <== NOT EXECUTED
201fe84: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
201fe88: 82 10 20 16 mov 0x16, %g1 <== NOT EXECUTED
201fe8c: 10 80 00 05 b 201fea0 <msdos_format+0x580> <== NOT EXECUTED
201fe90: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
else {
fmt_params->media_code = rqdata->media;
}
}
else {
fmt_params->media_code = FAT_BR_MEDIA_FIXED;
201fe94: 10 80 00 03 b 201fea0 <msdos_format+0x580>
201fe98: c2 2f bd e1 stb %g1, [ %fp + -543 ]
}
/*
* determine media code
*/
if (ret_val == 0) {
201fe9c: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
}
/*
* determine location and size of root directory
* for formatting
*/
if (fmt_params->root_dir_sectors > 0) {
201fea0: f8 07 bd cc ld [ %fp + -564 ], %i4
201fea4: d0 0f bd e0 ldub [ %fp + -544 ], %o0
201fea8: 80 a7 20 00 cmp %i4, 0
201feac: fa 07 bd b8 ld [ %fp + -584 ], %i5
fmt_params->root_dir_start_sec =
fmt_params->rsvd_sector_cnt
+ (fmt_params-> fat_num*fmt_params->sectors_per_fat);
201feb0: 90 0a 20 ff and %o0, 0xff, %o0
}
/*
* determine location and size of root directory
* for formatting
*/
if (fmt_params->root_dir_sectors > 0) {
201feb4: 02 80 00 08 be 201fed4 <msdos_format+0x5b4> <== NEVER TAKEN
201feb8: d2 07 bd c0 ld [ %fp + -576 ], %o1
fmt_params->root_dir_start_sec =
fmt_params->rsvd_sector_cnt
+ (fmt_params-> fat_num*fmt_params->sectors_per_fat);
201febc: 7f ff 8b ea call 2002e64 <.umul>
201fec0: 01 00 00 00 nop
fmt_params->root_dir_fmt_sec_cnt = fmt_params->root_dir_sectors;
201fec4: f8 27 bd d4 st %i4, [ %fp + -556 ]
* for formatting
*/
if (fmt_params->root_dir_sectors > 0) {
fmt_params->root_dir_start_sec =
fmt_params->rsvd_sector_cnt
+ (fmt_params-> fat_num*fmt_params->sectors_per_fat);
201fec8: 90 02 00 1d add %o0, %i5, %o0
/*
* determine location and size of root directory
* for formatting
*/
if (fmt_params->root_dir_sectors > 0) {
fmt_params->root_dir_start_sec =
201fecc: 10 80 00 08 b 201feec <msdos_format+0x5cc>
201fed0: d0 27 bd d0 st %o0, [ %fp + -560 ]
/*
* 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);
201fed4: 7f ff 8b e4 call 2002e64 <.umul> <== NOT EXECUTED
201fed8: 01 00 00 00 nop <== NOT EXECUTED
fmt_params->root_dir_fmt_sec_cnt = fmt_params->sectors_per_cluster;
201fedc: c2 07 bd bc ld [ %fp + -580 ], %g1 <== NOT EXECUTED
/*
* for FAT32: root directory is in cluster 2
*/
fmt_params->root_dir_start_sec =
fmt_params->rsvd_sector_cnt
+ (fmt_params-> fat_num*fmt_params->sectors_per_fat);
201fee0: 90 02 00 1d add %o0, %i5, %o0 <== NOT EXECUTED
fmt_params->root_dir_fmt_sec_cnt = fmt_params->sectors_per_cluster;
201fee4: c2 27 bd d4 st %g1, [ %fp + -556 ] <== NOT EXECUTED
}
else {
/*
* for FAT32: root directory is in cluster 2
*/
fmt_params->root_dir_start_sec =
201fee8: d0 27 bd d0 st %o0, [ %fp + -560 ] <== NOT EXECUTED
fmt_params->root_dir_fmt_sec_cnt = fmt_params->sectors_per_cluster;
}
/*
* determine usable OEMName
*/
if (ret_val == 0) {
201feec: 80 a6 20 00 cmp %i0, 0
201fef0: 12 80 01 ca bne 2020618 <msdos_format+0xcf8> <== NEVER TAKEN
201fef4: 01 00 00 00 nop
const char *from;
char *to = fmt_params->OEMName;
int cnt;
from = "RTEMS"; /* default: make "from" point to OS Name */
if ((rqdata != NULL) &&
201fef8: 80 a6 60 00 cmp %i1, 0
201fefc: 02 80 00 07 be 201ff18 <msdos_format+0x5f8>
201ff00: 03 00 81 84 sethi %hi(0x2061000), %g1
(rqdata->OEMName != NULL)) {
201ff04: c2 06 40 00 ld [ %i1 ], %g1
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) &&
201ff08: 80 a0 60 00 cmp %g1, 0
201ff0c: 32 80 00 05 bne,a 201ff20 <msdos_format+0x600> <== ALWAYS TAKEN
201ff10: 05 00 81 af sethi %hi(0x206bc00), %g2
*/
if (ret_val == 0) {
const char *from;
char *to = fmt_params->OEMName;
int cnt;
from = "RTEMS"; /* default: make "from" point to OS Name */
201ff14: 03 00 81 84 sethi %hi(0x2061000), %g1 <== NOT EXECUTED
201ff18: 82 10 63 e0 or %g1, 0x3e0, %g1 ! 20613e0 <iMinorError+0x400>
from = rqdata->OEMName;
}
for (cnt = 0;
cnt < (sizeof(fmt_params->OEMName)-1);
cnt++) {
if (isprint((unsigned char)*from)) {
201ff1c: 05 00 81 af sethi %hi(0x206bc00), %g2
201ff20: 86 10 20 09 mov 9, %g3
201ff24: f8 00 a1 d0 ld [ %g2 + 0x1d0 ], %i4
/*
* non-printable character in given name, so keep stuck
* at that character and replace all following characters
* with a ' '
*/
*to++=' ';
201ff28: b0 10 20 20 mov 0x20, %i0
/*
* determine usable OEMName
*/
if (ret_val == 0) {
const char *from;
char *to = fmt_params->OEMName;
201ff2c: 10 80 00 0f b 201ff68 <msdos_format+0x648>
201ff30: 84 07 bd e3 add %fp, -541, %g2
from = rqdata->OEMName;
}
for (cnt = 0;
cnt < (sizeof(fmt_params->OEMName)-1);
cnt++) {
if (isprint((unsigned char)*from)) {
201ff34: 88 0f 60 ff and %i5, 0xff, %g4
201ff38: 88 07 00 04 add %i4, %g4, %g4
201ff3c: c8 49 20 01 ldsb [ %g4 + 1 ], %g4
201ff40: 80 89 20 97 btst 0x97, %g4
201ff44: 02 80 00 06 be 201ff5c <msdos_format+0x63c>
201ff48: 88 00 a0 01 add %g2, 1, %g4
*to++ = *from++;
201ff4c: fa 28 80 00 stb %i5, [ %g2 ]
201ff50: 82 00 60 01 inc %g1
201ff54: 10 80 00 04 b 201ff64 <msdos_format+0x644>
201ff58: 84 10 00 04 mov %g4, %g2
/*
* non-printable character in given name, so keep stuck
* at that character and replace all following characters
* with a ' '
*/
*to++=' ';
201ff5c: f0 28 80 00 stb %i0, [ %g2 ]
201ff60: 84 10 00 04 mov %g4, %g2
}
*to = '\0';
201ff64: c0 29 00 00 clrb [ %g4 ]
from = "RTEMS"; /* default: make "from" point to OS Name */
if ((rqdata != NULL) &&
(rqdata->OEMName != NULL)) {
from = rqdata->OEMName;
}
for (cnt = 0;
201ff68: 86 80 ff ff addcc %g3, -1, %g3
201ff6c: 32 bf ff f2 bne,a 201ff34 <msdos_format+0x614>
201ff70: fa 08 40 00 ldub [ %g1 ], %i5
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) &&
201ff74: 10 80 01 9f b 20205f0 <msdos_format+0xcd0>
201ff78: 80 a6 60 00 cmp %i1, 0
201ff7c: 80 a0 60 00 cmp %g1, 0
201ff80: 22 80 00 05 be,a 201ff94 <msdos_format+0x674> <== NEVER TAKEN
201ff84: 03 00 81 82 sethi %hi(0x2060800), %g1 <== NOT EXECUTED
(rqdata->VolLabel != NULL)) {
from = rqdata->VolLabel;
fmt_params->VolLabel_present = true;
201ff88: 84 10 20 01 mov 1, %g2
201ff8c: 10 80 00 03 b 201ff98 <msdos_format+0x678>
201ff90: c4 2f bd f8 stb %g2, [ %fp + -520 ]
*/
if (ret_val == 0) {
const char *from;
char *to = fmt_params->VolLabel;
int cnt;
from = ""; /* default: make "from" point to empty string */
201ff94: 82 10 60 10 or %g1, 0x10, %g1
fmt_params->VolLabel_present = true;
}
for (cnt = 0;
cnt < (sizeof(fmt_params->VolLabel)-1);
cnt++) {
if (isprint((unsigned char)*from)) {
201ff98: 05 00 81 af sethi %hi(0x206bc00), %g2
201ff9c: 86 10 20 0c mov 0xc, %g3
201ffa0: f8 00 a1 d0 ld [ %g2 + 0x1d0 ], %i4
/*
* non-printable character in given name, so keep stuck
* at that character and replace all following characters
* with a ' '
*/
*to++=' ';
201ffa4: b0 10 20 20 mov 0x20, %i0
/*
* determine usable Volume Label
*/
if (ret_val == 0) {
const char *from;
char *to = fmt_params->VolLabel;
201ffa8: 10 80 00 0f b 201ffe4 <msdos_format+0x6c4>
201ffac: 84 07 bd ec add %fp, -532, %g2
fmt_params->VolLabel_present = true;
}
for (cnt = 0;
cnt < (sizeof(fmt_params->VolLabel)-1);
cnt++) {
if (isprint((unsigned char)*from)) {
201ffb0: 88 0f 60 ff and %i5, 0xff, %g4
201ffb4: 88 07 00 04 add %i4, %g4, %g4
201ffb8: c8 49 20 01 ldsb [ %g4 + 1 ], %g4
201ffbc: 80 89 20 97 btst 0x97, %g4
201ffc0: 02 80 00 06 be 201ffd8 <msdos_format+0x6b8>
201ffc4: 88 00 a0 01 add %g2, 1, %g4
*to++ = *from++;
201ffc8: fa 28 80 00 stb %i5, [ %g2 ]
201ffcc: 82 00 60 01 inc %g1
201ffd0: 10 80 00 04 b 201ffe0 <msdos_format+0x6c0>
201ffd4: 84 10 00 04 mov %g4, %g2
/*
* non-printable character in given name, so keep stuck
* at that character and replace all following characters
* with a ' '
*/
*to++=' ';
201ffd8: f0 28 80 00 stb %i0, [ %g2 ]
201ffdc: 84 10 00 04 mov %g4, %g2
}
*to = '\0';
201ffe0: c0 29 00 00 clrb [ %g4 ]
if ((rqdata != NULL) &&
(rqdata->VolLabel != NULL)) {
from = rqdata->VolLabel;
fmt_params->VolLabel_present = true;
}
for (cnt = 0;
201ffe4: 86 80 ff ff addcc %g3, -1, %g3
201ffe8: 32 bf ff f2 bne,a 201ffb0 <msdos_format+0x690>
201ffec: fa 08 40 00 ldub [ %g1 ], %i5
201fff0: 30 80 01 84 b,a 2020600 <msdos_format+0xce0>
int rc;
struct timeval time_value;
rc = rtems_clock_get_tod_timeval(&time_value);
if (rc == RTEMS_SUCCESSFUL) {
*volid_ptr = time_value.tv_sec + time_value.tv_sec;
201fff4: 83 28 60 01 sll %g1, 1, %g1 <== NOT EXECUTED
201fff8: 10 80 00 05 b 202000c <msdos_format+0x6ec> <== NOT EXECUTED
201fffc: c2 27 bd fc st %g1, [ %fp + -516 ] <== NOT EXECUTED
}
else {
*volid_ptr = rand();
2020000: 40 00 9d 9d call 2047674 <rand>
2020004: 01 00 00 00 nop
2020008: d0 27 bd fc st %o0, [ %fp + -516 ]
ret_val = msdos_format_determine_fmt_params(fd,rqdata,&fmt_params);
}
/*
* if requested, write whole disk/partition with 0xe5
*/
if ((ret_val == 0) &&
202000c: 80 a6 e0 00 cmp %i3, 0
2020010: 12 80 00 20 bne 2020090 <msdos_format+0x770> <== NEVER TAKEN
2020014: 80 a6 e0 00 cmp %i3, 0
2020018: 80 a6 60 00 cmp %i1, 0
202001c: 02 80 00 1d be 2020090 <msdos_format+0x770>
2020020: 80 a6 e0 00 cmp %i3, 0
(rqdata != NULL) &&
2020024: c2 0e 60 16 ldub [ %i1 + 0x16 ], %g1
2020028: 80 a0 60 00 cmp %g1, 0
202002c: 02 80 00 11 be 2020070 <msdos_format+0x750> <== ALWAYS TAKEN
2020030: 90 10 00 19 mov %i1, %o0
*/
if (ret_val == 0) {
/*
* Read the current MBR to obtain the partition table.
*/
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
2020034: 92 10 20 02 mov 2, %o1
2020038: 15 00 81 8a sethi %hi(0x2062800), %o2
202003c: 7f ff fd c1 call 201f740 <msdos_format_printf>
2020040: 94 12 a0 60 or %o2, 0x60, %o2 ! 2062860 <rtems_rtc_shell_usage+0xd30>
| 0, if success, -1 and errno if failed |
\*=========================================================================*/
{
int ret_val = 0;
if (0 > lseek(fd,((off_t)start_sector)*sector_size,SEEK_SET)) {
2020044: 90 10 00 1a mov %i2, %o0
/*
* 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,
2020048: fa 07 bd b0 ld [ %fp + -592 ], %i5
| 0, if success, -1 and errno if failed |
\*=========================================================================*/
{
int ret_val = 0;
if (0 > lseek(fd,((off_t)start_sector)*sector_size,SEEK_SET)) {
202004c: 92 10 20 00 clr %o1
2020050: 94 10 20 00 clr %o2
2020054: 40 00 22 c1 call 2028b58 <lseek>
2020058: 96 10 20 00 clr %o3
202005c: 80 a2 20 00 cmp %o0, 0
2020060: 16 80 01 73 bge 202062c <msdos_format+0xd0c> <== ALWAYS TAKEN
2020064: 90 10 00 1a mov %i2, %o0
}
}
}
}
if (ret_val == 0) {
2020068: 10 80 01 42 b 2020570 <msdos_format+0xc50> <== NOT EXECUTED
202006c: b6 10 3f ff mov -1, %i3 <== NOT EXECUTED
* if requested, write whole disk/partition with 0xe5
*/
if ((ret_val == 0) &&
(rqdata != NULL) &&
!(rqdata->quick_format)) {
ret_val = msdos_format_fill_sectors
2020070: d6 07 bd b4 ld [ %fp + -588 ], %o3
2020074: d8 07 bd b0 ld [ %fp + -592 ], %o4
2020078: 92 10 00 1a mov %i2, %o1
202007c: 94 10 20 00 clr %o2
2020080: 7f ff fd dd call 201f7f4 <msdos_format_fill_sectors>
2020084: 9a 10 3f e5 mov -27, %o5
2020088: b6 10 00 08 mov %o0, %i3
}
/*
* create master boot record
*/
if (ret_val == 0) {
202008c: 80 a6 e0 00 cmp %i3, 0
2020090: 12 80 01 39 bne 2020574 <msdos_format+0xc54> <== NEVER TAKEN
2020094: 80 a6 bf ff cmp %i2, -1
/*
* Read the current MBR to obtain the partition table.
*/
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
2020098: 10 bf ff e7 b 2020034 <msdos_format+0x714>
202009c: 90 10 00 19 mov %i1, %o0
| Return Value: |
| 0, if success, -1 and errno if failed |
\*=========================================================================*/
{
uint32_t total_sectors_num16 = 0;
uint32_t total_sectors_num32 = 0;
20200a0: ba 10 20 00 clr %i5
* 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);
20200a4: 92 10 20 00 clr %o1
20200a8: 94 10 21 be mov 0x1be, %o2
20200ac: 40 00 96 1e call 2045924 <memset>
20200b0: 90 07 be 00 add %fp, -512, %o0
* with 0xEB,....
*/
/*
* fill OEMName
*/
memcpy(FAT_GET_ADDR_BR_OEMNAME(mbr),
20200b4: 90 07 be 03 add %fp, -509, %o0
* 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,
20200b8: c0 37 bf fe clrh [ %fp + -2 ]
* with 0xEB,....
*/
/*
* fill OEMName
*/
memcpy(FAT_GET_ADDR_BR_OEMNAME(mbr),
20200bc: 92 07 bd e3 add %fp, -541, %o1
20200c0: 40 00 95 8a call 20456e8 <memcpy>
20200c4: 94 10 20 08 mov 8, %o2
fmt_params->OEMName,
FAT_BR_OEMNAME_SIZE);
FAT_SET_BR_BYTES_PER_SECTOR(mbr , fmt_params->bytes_per_sector);
20200c8: c2 07 bd b0 ld [ %fp + -592 ], %g1
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);
20200cc: 05 00 00 3f sethi %hi(0xfc00), %g2
* 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);
20200d0: c2 2f be 0b stb %g1, [ %fp + -501 ]
20200d4: 83 30 60 08 srl %g1, 8, %g1
20200d8: c2 2f be 0c stb %g1, [ %fp + -500 ]
FAT_SET_BR_SECTORS_PER_CLUSTER(mbr , fmt_params->sectors_per_cluster);
20200dc: c2 07 bd bc ld [ %fp + -580 ], %g1
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);
20200e0: 84 10 a3 ff or %g2, 0x3ff, %g2
*/
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);
20200e4: c2 2f be 0d stb %g1, [ %fp + -499 ]
FAT_SET_BR_RESERVED_SECTORS_NUM(mbr, fmt_params->rsvd_sector_cnt);
20200e8: c2 07 bd b8 ld [ %fp + -584 ], %g1
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);
20200ec: fa 2f be 20 stb %i5, [ %fp + -480 ]
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);
20200f0: c2 2f be 0e stb %g1, [ %fp + -498 ]
20200f4: 83 30 60 08 srl %g1, 8, %g1
20200f8: c2 2f be 0f stb %g1, [ %fp + -497 ]
/* 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);
20200fc: c2 07 bd c8 ld [ %fp + -568 ], %g1
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 */
2020100: 88 10 20 02 mov 2, %g4
FAT_SET_BR_FILES_PER_ROOT_DIR(mbr , fmt_params->files_per_root_dir);
2020104: c2 2f be 11 stb %g1, [ %fp + -495 ]
2020108: 83 30 60 08 srl %g1, 8, %g1
202010c: c2 2f be 12 stb %g1, [ %fp + -494 ]
FAT_SET_BR_TOTAL_SECTORS_NUM16(mbr , total_sectors_num16);
FAT_SET_BR_MEDIA(mbr , fmt_params->media_code);
2020110: c2 0f bd e1 ldub [ %fp + -543 ], %g1
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);
FAT_SET_BR_TOTAL_SECTORS_NUM16(mbr , total_sectors_num16);
2020114: f8 2f be 13 stb %i4, [ %fp + -493 ]
FAT_SET_BR_MEDIA(mbr , fmt_params->media_code);
2020118: c2 2f be 15 stb %g1, [ %fp + -491 ]
FAT_SET_BR_SECTORS_PER_TRACK(mbr , 255); /* only needed for INT13... */
202011c: 82 10 3f ff mov -1, %g1
2020120: c2 2f be 18 stb %g1, [ %fp + -488 ]
FAT_SET_BR_NUMBER_OF_HEADS(mbr , 6); /* only needed for INT13... */
2020124: 82 10 20 06 mov 6, %g1
2020128: c2 2f be 1a stb %g1, [ %fp + -486 ]
FAT_SET_BR_HIDDEN_SECTORS(mbr , 1); /* only needed for INT13... */
FAT_SET_BR_TOTAL_SECTORS_NUM32(mbr , total_sectors_num32);
202012c: 82 0f 40 02 and %i5, %g2, %g1
2020130: 83 30 60 08 srl %g1, 8, %g1
2020134: c2 2f be 21 stb %g1, [ %fp + -479 ]
2020138: 83 37 60 10 srl %i5, 0x10, %g1
202013c: bb 37 60 18 srl %i5, 0x18, %i5
2020140: fa 2f be 23 stb %i5, [ %fp + -477 ]
if (fmt_params->fattype != FAT_FAT32) {
2020144: fa 0f bd e2 ldub [ %fp + -542 ], %i5
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);
FAT_SET_BR_TOTAL_SECTORS_NUM16(mbr , total_sectors_num16);
2020148: b9 37 20 08 srl %i4, 8, %i4
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... */
202014c: 86 10 20 01 mov 1, %g3
FAT_SET_BR_TOTAL_SECTORS_NUM32(mbr , total_sectors_num32);
2020150: c2 2f be 22 stb %g1, [ %fp + -478 ]
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 */
2020154: c8 2f be 10 stb %g4, [ %fp + -496 ]
FAT_SET_BR_FILES_PER_ROOT_DIR(mbr , fmt_params->files_per_root_dir);
FAT_SET_BR_TOTAL_SECTORS_NUM16(mbr , total_sectors_num16);
2020158: f8 2f be 14 stb %i4, [ %fp + -492 ]
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... */
202015c: c6 2f be 1c stb %g3, [ %fp + -484 ]
FAT_SET_BR_TOTAL_SECTORS_NUM32(mbr , total_sectors_num32);
if (fmt_params->fattype != FAT_FAT32) {
2020160: 80 a7 60 04 cmp %i5, 4
2020164: 02 80 00 1c be 20201d4 <msdos_format+0x8b4> <== NEVER TAKEN
2020168: c2 07 bd c0 ld [ %fp + -576 ], %g1
FAT_SET_BR_SECTORS_PER_FAT(mbr ,fmt_params->sectors_per_fat);
202016c: c2 2f be 16 stb %g1, [ %fp + -490 ]
2020170: 83 30 60 08 srl %g1, 8, %g1
2020174: c2 2f be 17 stb %g1, [ %fp + -489 ]
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);
2020178: 82 10 20 29 mov 0x29, %g1
202017c: c2 2f be 26 stb %g1, [ %fp + -474 ]
FAT_SET_BR_VOLID(mbr , fmt_params->vol_id); /* volume id */
2020180: c2 07 bd fc ld [ %fp + -516 ], %g1
memcpy(FAT_GET_ADDR_BR_VOLLAB(mbr),
2020184: 92 07 bd ec add %fp, -532, %o1
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 */
2020188: 84 08 40 02 and %g1, %g2, %g2
202018c: 85 30 a0 08 srl %g2, 8, %g2
2020190: c2 2f be 27 stb %g1, [ %fp + -473 ]
2020194: c4 2f be 28 stb %g2, [ %fp + -472 ]
2020198: 85 30 60 10 srl %g1, 0x10, %g2
202019c: 83 30 60 18 srl %g1, 0x18, %g1
20201a0: c4 2f be 29 stb %g2, [ %fp + -471 ]
20201a4: c2 2f be 2a stb %g1, [ %fp + -470 ]
memcpy(FAT_GET_ADDR_BR_VOLLAB(mbr),
20201a8: 90 07 be 2b add %fp, -469, %o0
20201ac: 40 00 95 4f call 20456e8 <memcpy>
20201b0: 94 10 20 0b mov 0xb, %o2
fmt_params->VolLabel,
FAT_BR_VOLLAB_SIZE);
memcpy(FAT_GET_ADDR_BR_FILSYSTYPE(mbr),
20201b4: 13 00 81 89 sethi %hi(0x2062400), %o1
20201b8: 80 a7 60 01 cmp %i5, 1
20201bc: 12 80 00 04 bne 20201cc <msdos_format+0x8ac> <== NEVER TAKEN
20201c0: 92 12 63 c0 or %o1, 0x3c0, %o1
20201c4: 13 00 81 89 sethi %hi(0x2062400), %o1
20201c8: 92 12 63 b0 or %o1, 0x3b0, %o1 ! 20627b0 <rtems_rtc_shell_usage+0xc80>
20201cc: 10 80 00 1d b 2020240 <msdos_format+0x920>
20201d0: 90 07 be 36 add %fp, -458, %o0
? "FAT12 "
: "FAT16 ",
FAT_BR_FILSYSTYPE_SIZE);
}
else {
FAT_SET_BR_SECTORS_PER_FAT32(mbr ,fmt_params->sectors_per_fat);
20201d4: 84 08 40 02 and %g1, %g2, %g2 <== NOT EXECUTED
20201d8: 85 30 a0 08 srl %g2, 8, %g2 <== NOT EXECUTED
20201dc: c2 2f be 24 stb %g1, [ %fp + -476 ] <== NOT EXECUTED
20201e0: c4 2f be 25 stb %g2, [ %fp + -475 ] <== NOT EXECUTED
20201e4: 85 30 60 10 srl %g1, 0x10, %g2 <== NOT EXECUTED
20201e8: 83 30 60 18 srl %g1, 0x18, %g1 <== NOT EXECUTED
20201ec: c2 2f be 27 stb %g1, [ %fp + -473 ] <== 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 */
20201f0: c2 07 bd d8 ld [ %fp + -552 ], %g1 <== NOT EXECUTED
? "FAT12 "
: "FAT16 ",
FAT_BR_FILSYSTYPE_SIZE);
}
else {
FAT_SET_BR_SECTORS_PER_FAT32(mbr ,fmt_params->sectors_per_fat);
20201f4: c4 2f be 26 stb %g2, [ %fp + -474 ] <== 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 */
20201f8: c2 2f be 32 stb %g1, [ %fp + -462 ] <== NOT EXECUTED
20201fc: 83 30 60 08 srl %g1, 8, %g1 <== 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 */
2020200: c8 2f be 2c stb %g4, [ %fp + -468 ] <== NOT EXECUTED
FAT_SET_BR_FAT32_FS_INFO_SECTOR(mbr, 1); /* Put fsinfo to rsrvd sec 1*/
2020204: c6 2f be 30 stb %g3, [ %fp + -464 ] <== NOT EXECUTED
FAT_SET_BR_FAT32_BK_BOOT_SECTOR(mbr, fmt_params->mbr_copy_sec ); /* Put MBR copy to rsrvd sec */
2020208: c2 2f be 33 stb %g1, [ %fp + -461 ] <== NOT EXECUTED
memset(FAT_GET_ADDR_BR_FAT32_RESERVED(mbr),0,FAT_BR_FAT32_RESERVED_SIZE);
202020c: 92 10 20 00 clr %o1 <== NOT EXECUTED
2020210: 94 10 20 0c mov 0xc, %o2 <== NOT EXECUTED
2020214: 40 00 95 c4 call 2045924 <memset> <== NOT EXECUTED
2020218: 90 07 be 34 add %fp, -460, %o0 <== 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);
202021c: 82 10 20 29 mov 0x29, %g1 <== NOT EXECUTED
FAT_SET_BR_FAT32_VOLID(mbr , 0); /* not set */
memset(FAT_GET_ADDR_BR_FAT32_VOLLAB(mbr) ,0,FAT_BR_VOLLAB_SIZE);
2020220: 92 10 20 00 clr %o1 <== 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);
2020224: c2 2f be 42 stb %g1, [ %fp + -446 ] <== NOT EXECUTED
FAT_SET_BR_FAT32_VOLID(mbr , 0); /* not set */
memset(FAT_GET_ADDR_BR_FAT32_VOLLAB(mbr) ,0,FAT_BR_VOLLAB_SIZE);
2020228: 90 07 be 47 add %fp, -441, %o0 <== NOT EXECUTED
202022c: 40 00 95 be call 2045924 <memset> <== NOT EXECUTED
2020230: 94 10 20 0b mov 0xb, %o2 <== NOT EXECUTED
memcpy(FAT_GET_ADDR_BR_FAT32_FILSYSTYPE(mbr),
2020234: 13 00 81 8a sethi %hi(0x2062800), %o1 <== NOT EXECUTED
2020238: 90 07 be 52 add %fp, -430, %o0 <== NOT EXECUTED
202023c: 92 12 60 78 or %o1, 0x78, %o1 <== NOT EXECUTED
2020240: 40 00 95 2a call 20456e8 <memcpy>
2020244: 94 10 20 08 mov 8, %o2
FAT_BR_FILSYSTYPE_SIZE);
}
/*
* add boot record signature
*/
FAT_SET_BR_SIGNATURE(mbr, FAT_BR_SIGNATURE_VAL);
2020248: 82 10 20 55 mov 0x55, %g1
202024c: c2 2f bf fe stb %g1, [ %fp + -2 ]
2020250: 82 10 3f aa mov -86, %g1
2020254: c2 2f bf ff stb %g1, [ %fp + -1 ]
/*
* add jump to boot loader at start of sector
*/
FAT_SET_VAL8(mbr,0,0xeb);
2020258: 82 10 3f eb mov -21, %g1
202025c: c2 2f be 00 stb %g1, [ %fp + -512 ]
FAT_SET_VAL8(mbr,1,0x3c);
2020260: 82 10 20 3c mov 0x3c, %g1
2020264: c2 2f be 01 stb %g1, [ %fp + -511 ]
FAT_SET_VAL8(mbr,2,0x90);
2020268: 82 10 3f 90 mov -112, %g1
/*
* 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,
202026c: 90 10 00 19 mov %i1, %o0
/*
* 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);
2020270: c2 2f be 02 stb %g1, [ %fp + -510 ]
/*
* 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,
2020274: 92 10 20 02 mov 2, %o1
2020278: 15 00 81 8a sethi %hi(0x2062800), %o2
202027c: 7f ff fd 31 call 201f740 <msdos_format_printf>
2020280: 94 12 a0 88 or %o2, 0x88, %o2 ! 2062888 <rtems_rtc_shell_usage+0xd58>
"write MRB sector\n");
ret_val = msdos_format_write_sec(fd,
2020284: d4 07 bd b0 ld [ %fp + -592 ], %o2
2020288: 90 10 00 1a mov %i2, %o0
202028c: 92 10 20 00 clr %o1
2020290: 7f ff fd 41 call 201f794 <msdos_format_write_sec>
2020294: 96 07 be 00 add %fp, -512, %o3
0,
fmt_params.bytes_per_sector,
tmp_sec);
}
if ((ret_val == 0) &&
2020298: b6 92 20 00 orcc %o0, 0, %i3
202029c: 12 80 00 b5 bne 2020570 <msdos_format+0xc50> <== NEVER TAKEN
20202a0: c2 07 bd d8 ld [ %fp + -552 ], %g1
20202a4: 80 a0 60 00 cmp %g1, 0
20202a8: 12 80 00 08 bne 20202c8 <msdos_format+0x9a8> <== NEVER TAKEN
20202ac: 90 10 00 19 mov %i1, %o0
}
/*
* for FAT32: initialize info sector on disk
*/
if ((ret_val == 0) &&
(fmt_params.fsinfo_sec != 0)) {
20202b0: fa 07 bd dc ld [ %fp + -548 ], %i5
}
}
/*
* for FAT32: initialize info sector on disk
*/
if ((ret_val == 0) &&
20202b4: 80 a7 60 00 cmp %i5, 0
20202b8: 22 80 00 37 be,a 2020394 <msdos_format+0xa74> <== ALWAYS TAKEN
20202bc: d2 07 bd c0 ld [ %fp + -576 ], %o1
\*=========================================================================*/
{
/*
* clear fsinfo sector data
*/
memset(fsinfo,0,FAT_TOTAL_FSINFO_SIZE);
20202c0: 10 80 00 10 b 2020300 <msdos_format+0x9e0> <== NOT EXECUTED
20202c4: 92 10 20 00 clr %o1 <== NOT EXECUTED
if ((ret_val == 0) &&
(fmt_params.mbr_copy_sec != 0)) {
/*
* write copy of MBR
*/
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
20202c8: 92 10 20 02 mov 2, %o1 <== NOT EXECUTED
20202cc: 15 00 81 8a sethi %hi(0x2062800), %o2 <== NOT EXECUTED
20202d0: 7f ff fd 1c call 201f740 <msdos_format_printf> <== NOT EXECUTED
20202d4: 94 12 a0 a0 or %o2, 0xa0, %o2 ! 20628a0 <rtems_rtc_shell_usage+0xd70><== NOT EXECUTED
"write back up MRB sector\n");
ret_val = msdos_format_write_sec(fd,
20202d8: d2 07 bd d8 ld [ %fp + -552 ], %o1 <== NOT EXECUTED
20202dc: d4 07 bd b0 ld [ %fp + -592 ], %o2 <== NOT EXECUTED
20202e0: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
20202e4: 7f ff fd 2c call 201f794 <msdos_format_write_sec> <== NOT EXECUTED
20202e8: 96 07 be 00 add %fp, -512, %o3 <== NOT EXECUTED
}
}
/*
* for FAT32: initialize info sector on disk
*/
if ((ret_val == 0) &&
20202ec: b6 92 20 00 orcc %o0, 0, %i3 <== NOT EXECUTED
20202f0: 22 bf ff f1 be,a 20202b4 <msdos_format+0x994> <== NOT EXECUTED
20202f4: fa 07 bd dc ld [ %fp + -548 ], %i5 <== NOT EXECUTED
/*
* cleanup:
* sync and unlock disk
* free any data structures (not needed now)
*/
if (fd != -1) {
20202f8: 10 80 00 9f b 2020574 <msdos_format+0xc54> <== NOT EXECUTED
20202fc: 80 a6 bf ff cmp %i2, -1 <== NOT EXECUTED
\*=========================================================================*/
{
/*
* clear fsinfo sector data
*/
memset(fsinfo,0,FAT_TOTAL_FSINFO_SIZE);
2020300: 94 10 22 00 mov 0x200, %o2 <== NOT EXECUTED
2020304: 40 00 95 88 call 2045924 <memset> <== NOT EXECUTED
2020308: 90 07 be 00 add %fp, -512, %o0 <== NOT EXECUTED
/*
* write LEADSIG, STRUCTSIG, TRAILSIG
*/
FAT_SET_FSINFO_LEAD_SIGNATURE (fsinfo,FAT_FSINFO_LEAD_SIGNATURE_VALUE );
202030c: 82 10 20 52 mov 0x52, %g1 <== NOT EXECUTED
2020310: c2 2f be 00 stb %g1, [ %fp + -512 ] <== NOT EXECUTED
2020314: c2 2f be 01 stb %g1, [ %fp + -511 ] <== NOT EXECUTED
2020318: 82 10 20 61 mov 0x61, %g1 <== NOT EXECUTED
202031c: c2 2f be 02 stb %g1, [ %fp + -510 ] <== NOT EXECUTED
FAT_SET_FSINFO_STRUC_SIGNATURE(fsinfo,FAT_FSINFO_STRUC_SIGNATURE_VALUE);
2020320: c2 2f bf e7 stb %g1, [ %fp + -25 ] <== NOT EXECUTED
FAT_SET_FSINFO_TRAIL_SIGNATURE(fsinfo,FAT_FSINFO_TRAIL_SIGNATURE_VALUE);
2020324: 82 10 20 55 mov 0x55, %g1 <== NOT EXECUTED
/*
* write fsinfo sector
*/
if ((ret_val == 0) &&
(fmt_params.fsinfo_sec != 0)) {
ret_val = msdos_format_write_sec(fd,
2020328: d4 07 bd b0 ld [ %fp + -592 ], %o2 <== 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);
202032c: c2 2f bf fe stb %g1, [ %fp + -2 ] <== NOT EXECUTED
2020330: 82 10 3f aa mov -86, %g1 <== NOT EXECUTED
*/
memset(fsinfo,0,FAT_TOTAL_FSINFO_SIZE);
/*
* write LEADSIG, STRUCTSIG, TRAILSIG
*/
FAT_SET_FSINFO_LEAD_SIGNATURE (fsinfo,FAT_FSINFO_LEAD_SIGNATURE_VALUE );
2020334: 84 10 20 41 mov 0x41, %g2 <== NOT EXECUTED
FAT_SET_FSINFO_STRUC_SIGNATURE(fsinfo,FAT_FSINFO_STRUC_SIGNATURE_VALUE);
2020338: 86 10 20 72 mov 0x72, %g3 <== NOT EXECUTED
FAT_SET_FSINFO_TRAIL_SIGNATURE(fsinfo,FAT_FSINFO_TRAIL_SIGNATURE_VALUE);
202033c: c2 2f bf ff stb %g1, [ %fp + -1 ] <== NOT EXECUTED
/*
* write "empty" values for free cluster count and next cluster number
*/
FAT_SET_FSINFO_FREE_CLUSTER_COUNT(fsinfo+FAT_FSI_INFO,
2020340: 82 10 3f ff mov -1, %g1 <== NOT EXECUTED
*/
memset(fsinfo,0,FAT_TOTAL_FSINFO_SIZE);
/*
* write LEADSIG, STRUCTSIG, TRAILSIG
*/
FAT_SET_FSINFO_LEAD_SIGNATURE (fsinfo,FAT_FSINFO_LEAD_SIGNATURE_VALUE );
2020344: c4 2f be 03 stb %g2, [ %fp + -509 ] <== NOT EXECUTED
FAT_SET_FSINFO_STRUC_SIGNATURE(fsinfo,FAT_FSINFO_STRUC_SIGNATURE_VALUE);
2020348: c6 2f bf e4 stb %g3, [ %fp + -28 ] <== NOT EXECUTED
202034c: c6 2f bf e5 stb %g3, [ %fp + -27 ] <== NOT EXECUTED
2020350: c4 2f bf e6 stb %g2, [ %fp + -26 ] <== 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,
2020354: c2 2f bf e8 stb %g1, [ %fp + -24 ] <== NOT EXECUTED
2020358: c2 2f bf e9 stb %g1, [ %fp + -23 ] <== NOT EXECUTED
202035c: c2 2f bf ea stb %g1, [ %fp + -22 ] <== NOT EXECUTED
2020360: c2 2f bf eb stb %g1, [ %fp + -21 ] <== NOT EXECUTED
0xffffffff);
FAT_SET_FSINFO_NEXT_FREE_CLUSTER (fsinfo+FAT_FSI_INFO,
2020364: c2 2f bf ec stb %g1, [ %fp + -20 ] <== NOT EXECUTED
2020368: c2 2f bf ed stb %g1, [ %fp + -19 ] <== NOT EXECUTED
202036c: c2 2f bf ee stb %g1, [ %fp + -18 ] <== NOT EXECUTED
2020370: c2 2f bf ef stb %g1, [ %fp + -17 ] <== NOT EXECUTED
/*
* write fsinfo sector
*/
if ((ret_val == 0) &&
(fmt_params.fsinfo_sec != 0)) {
ret_val = msdos_format_write_sec(fd,
2020374: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
2020378: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
202037c: 7f ff fd 06 call 201f794 <msdos_format_write_sec> <== NOT EXECUTED
2020380: 96 07 be 00 add %fp, -512, %o3 <== NOT EXECUTED
}
/*
* write FAT as all empty
* -> write all FAT sectors as zero
*/
if (ret_val == 0) {
2020384: b6 92 20 00 orcc %o0, 0, %i3 <== NOT EXECUTED
2020388: 12 80 00 7b bne 2020574 <msdos_format+0xc54> <== NOT EXECUTED
202038c: 80 a6 bf ff cmp %i2, -1 <== NOT EXECUTED
ret_val = msdos_format_fill_sectors
(rqdata,
2020390: d2 07 bd c0 ld [ %fp + -576 ], %o1 <== NOT EXECUTED
2020394: d0 0f bd e0 ldub [ %fp + -544 ], %o0
2020398: 7f ff 8a b3 call 2002e64 <.umul>
202039c: fa 07 bd b8 ld [ %fp + -584 ], %i5
/*
* write FAT as all empty
* -> write all FAT sectors as zero
*/
if (ret_val == 0) {
ret_val = msdos_format_fill_sectors
20203a0: d8 07 bd b0 ld [ %fp + -592 ], %o4
(rqdata,
20203a4: 96 10 00 08 mov %o0, %o3
/*
* write FAT as all empty
* -> write all FAT sectors as zero
*/
if (ret_val == 0) {
ret_val = msdos_format_fill_sectors
20203a8: 92 10 00 1a mov %i2, %o1
20203ac: 90 10 00 19 mov %i1, %o0
20203b0: 94 10 00 1d mov %i5, %o2
20203b4: 7f ff fd 10 call 201f7f4 <msdos_format_fill_sectors>
20203b8: 9a 10 20 00 clr %o5
}
/*
* clear/init root directory
* -> write all directory sectors as 0x00
*/
if (ret_val == 0) {
20203bc: b6 92 20 00 orcc %o0, 0, %i3
20203c0: 12 80 00 6c bne 2020570 <msdos_format+0xc50> <== NEVER TAKEN
20203c4: d4 1f bd d0 ldd [ %fp + -560 ], %o2
ret_val = msdos_format_fill_sectors
20203c8: d8 07 bd b0 ld [ %fp + -592 ], %o4
20203cc: 90 10 00 19 mov %i1, %o0
20203d0: 92 10 00 1a mov %i2, %o1
20203d4: 7f ff fd 08 call 201f7f4 <msdos_format_fill_sectors>
20203d8: 9a 10 20 00 clr %o5
0x00);
}
/*
* write volume label to first entry of directory
*/
if ((ret_val == 0) && fmt_params.VolLabel_present) {
20203dc: b6 92 20 00 orcc %o0, 0, %i3
20203e0: 12 80 00 64 bne 2020570 <msdos_format+0xc50> <== NEVER TAKEN
20203e4: c2 0f bd f8 ldub [ %fp + -520 ], %g1
20203e8: 80 a0 60 00 cmp %g1, 0
20203ec: 12 80 00 08 bne 202040c <msdos_format+0xaec>
20203f0: 92 10 20 00 clr %o1
/*
* 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){
20203f4: c2 0f bd f8 ldub [ %fp + -520 ], %g1
20203f8: 80 a0 60 00 cmp %g1, 0
20203fc: 02 80 00 5e be 2020574 <msdos_format+0xc54>
2020400: 80 a6 bf ff cmp %i2, -1
/*
* empty sector: all clusters are free/do not link further on
*/
memset(tmp_sec,0,sizeof(tmp_sec));
2020404: 10 80 00 15 b 2020458 <msdos_format+0xb38>
2020408: 90 07 be 00 add %fp, -512, %o0
}
/*
* write volume label to first entry of directory
*/
if ((ret_val == 0) && fmt_params.VolLabel_present) {
memset(tmp_sec,0,sizeof(tmp_sec));
202040c: 94 10 22 00 mov 0x200, %o2
2020410: 40 00 95 45 call 2045924 <memset>
2020414: 90 07 be 00 add %fp, -512, %o0
memcpy(MSDOS_DIR_NAME(tmp_sec),fmt_params.VolLabel,MSDOS_SHORT_NAME_LEN);
2020418: 92 07 bd ec add %fp, -532, %o1
202041c: 94 10 20 0b mov 0xb, %o2
2020420: 40 00 94 b2 call 20456e8 <memcpy>
2020424: 90 07 be 00 add %fp, -512, %o0
*MSDOS_DIR_ATTR(tmp_sec) = MSDOS_ATTR_VOLUME_ID;
ret_val = msdos_format_write_sec
2020428: d2 07 bd d0 ld [ %fp + -560 ], %o1
202042c: d4 07 bd b0 ld [ %fp + -592 ], %o2
* 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;
2020430: 82 10 20 08 mov 8, %g1
ret_val = msdos_format_write_sec
2020434: 90 10 00 1a mov %i2, %o0
* 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;
2020438: c2 2f be 0b stb %g1, [ %fp + -501 ]
ret_val = msdos_format_write_sec
202043c: 7f ff fc d6 call 201f794 <msdos_format_write_sec>
2020440: 96 07 be 00 add %fp, -512, %o3
/*
* 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){
2020444: 80 a2 20 00 cmp %o0, 0
2020448: 02 bf ff ec be 20203f8 <msdos_format+0xad8> <== ALWAYS TAKEN
202044c: c2 0f bd f8 ldub [ %fp + -520 ], %g1
2020450: 10 80 00 48 b 2020570 <msdos_format+0xc50> <== NOT EXECUTED
2020454: b6 10 00 08 mov %o0, %i3 <== NOT EXECUTED
/*
* empty sector: all clusters are free/do not link further on
*/
memset(tmp_sec,0,sizeof(tmp_sec));
2020458: 92 10 20 00 clr %o1
202045c: 40 00 95 32 call 2045924 <memset>
2020460: 94 10 22 00 mov 0x200, %o2
switch(fmt_params.fattype) {
2020464: c2 0f bd e2 ldub [ %fp + -542 ], %g1
2020468: 80 a0 60 02 cmp %g1, 2
202046c: 02 80 00 0c be 202049c <msdos_format+0xb7c> <== NEVER TAKEN
2020470: 80 a0 60 04 cmp %g1, 4
2020474: 02 80 00 12 be 20204bc <msdos_format+0xb9c> <== NEVER TAKEN
2020478: 80 a0 60 01 cmp %g1, 1
202047c: 12 80 00 1d bne 20204f0 <msdos_format+0xbd0> <== NEVER TAKEN
2020480: c2 0f bd e1 ldub [ %fp + -543 ], %g1
case FAT_FAT12:
/* LSBits of FAT entry 0: media_type */
FAT_SET_VAL8(tmp_sec,0,(fmt_params.media_code));
2020484: c2 2f be 00 stb %g1, [ %fp + -512 ]
/* 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)));
2020488: 82 10 3f 8f mov -113, %g1
202048c: c2 2f be 01 stb %g1, [ %fp + -511 ]
/* MSBits of FAT entry 1: MSBits of EOC */
FAT_SET_VAL8(tmp_sec,2,(FAT_FAT12_EOC >> 4));
2020490: 82 10 3f ff mov -1, %g1
break;
2020494: 10 80 00 1b b 2020500 <msdos_format+0xbe0>
2020498: c2 2f be 02 stb %g1, [ %fp + -510 ]
case FAT_FAT16:
/* FAT entry 0: 0xff00|media_type */
FAT_SET_VAL8(tmp_sec,0,fmt_params.media_code);
202049c: c2 0f bd e1 ldub [ %fp + -543 ], %g1 <== NOT EXECUTED
FAT_SET_VAL8(tmp_sec,1,0xff);
/* FAT entry 1: EOC */
FAT_SET_VAL16(tmp_sec,2,FAT_FAT16_EOC);
20204a0: 84 10 3f f8 mov -8, %g2 <== 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);
20204a4: c2 2f be 00 stb %g1, [ %fp + -512 ] <== NOT EXECUTED
FAT_SET_VAL8(tmp_sec,1,0xff);
/* FAT entry 1: EOC */
FAT_SET_VAL16(tmp_sec,2,FAT_FAT16_EOC);
20204a8: c4 2f be 02 stb %g2, [ %fp + -510 ] <== NOT EXECUTED
break;
case FAT_FAT16:
/* FAT entry 0: 0xff00|media_type */
FAT_SET_VAL8(tmp_sec,0,fmt_params.media_code);
FAT_SET_VAL8(tmp_sec,1,0xff);
20204ac: 82 10 3f ff mov -1, %g1 <== NOT EXECUTED
20204b0: c2 2f be 01 stb %g1, [ %fp + -511 ] <== NOT EXECUTED
/* FAT entry 1: EOC */
FAT_SET_VAL16(tmp_sec,2,FAT_FAT16_EOC);
break;
20204b4: 10 80 00 13 b 2020500 <msdos_format+0xbe0> <== NOT EXECUTED
20204b8: c2 2f be 03 stb %g1, [ %fp + -509 ] <== NOT EXECUTED
case FAT_FAT32:
/* FAT entry 0: 0xffffff00|media_type */
FAT_SET_VAL32(tmp_sec,0,0xffffff00|fmt_params.media_code);
20204bc: c2 0f bd e1 ldub [ %fp + -543 ], %g1 <== NOT EXECUTED
/* FAT entry 1: EOC */
FAT_SET_VAL32(tmp_sec,4,FAT_FAT32_EOC);
20204c0: 84 10 3f f8 mov -8, %g2 <== 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);
20204c4: c2 2f be 00 stb %g1, [ %fp + -512 ] <== NOT EXECUTED
20204c8: 82 10 3f ff mov -1, %g1 <== NOT EXECUTED
/* FAT entry 1: EOC */
FAT_SET_VAL32(tmp_sec,4,FAT_FAT32_EOC);
20204cc: c4 2f be 04 stb %g2, [ %fp + -508 ] <== 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);
20204d0: c2 2f be 01 stb %g1, [ %fp + -511 ] <== NOT EXECUTED
20204d4: c2 2f be 02 stb %g1, [ %fp + -510 ] <== NOT EXECUTED
20204d8: c2 2f be 03 stb %g1, [ %fp + -509 ] <== NOT EXECUTED
/* FAT entry 1: EOC */
FAT_SET_VAL32(tmp_sec,4,FAT_FAT32_EOC);
20204dc: c2 2f be 05 stb %g1, [ %fp + -507 ] <== NOT EXECUTED
20204e0: c2 2f be 06 stb %g1, [ %fp + -506 ] <== NOT EXECUTED
20204e4: 82 10 20 0f mov 0xf, %g1 <== NOT EXECUTED
break;
20204e8: 10 80 00 06 b 2020500 <msdos_format+0xbe0> <== NOT EXECUTED
20204ec: c2 2f be 07 stb %g1, [ %fp + -505 ] <== NOT EXECUTED
default:
ret_val = -1;
errno = EINVAL;
20204f0: 40 00 87 3f call 20421ec <__errno> <== NOT EXECUTED
20204f4: b6 10 3f ff mov -1, %i3 <== NOT EXECUTED
20204f8: 82 10 20 16 mov 0x16, %g1 <== NOT EXECUTED
20204fc: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
}
if (fmt_params.fattype == FAT_FAT32) {
2020500: c2 0f bd e2 ldub [ %fp + -542 ], %g1
2020504: 80 a0 60 04 cmp %g1, 4
2020508: 12 80 00 14 bne 2020558 <msdos_format+0xc38> <== ALWAYS TAKEN
202050c: ba 10 20 00 clr %i5
/*
* 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);
2020510: 82 10 3f f8 mov -8, %g1 <== NOT EXECUTED
2020514: c2 2f be 08 stb %g1, [ %fp + -504 ] <== NOT EXECUTED
2020518: 82 10 3f ff mov -1, %g1 <== NOT EXECUTED
202051c: c2 2f be 09 stb %g1, [ %fp + -503 ] <== NOT EXECUTED
2020520: c2 2f be 0a stb %g1, [ %fp + -502 ] <== NOT EXECUTED
2020524: 82 10 20 0f mov 0xf, %g1 <== NOT EXECUTED
2020528: 10 80 00 0c b 2020558 <msdos_format+0xc38> <== NOT EXECUTED
202052c: c2 2f be 0b stb %g1, [ %fp + -501 ] <== NOT EXECUTED
(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),
2020530: 7f ff 8a 4d call 2002e64 <.umul>
2020534: 90 10 00 1d mov %i5, %o0
}
for (i = 0;
(i < fmt_params.fat_num) && (ret_val == 0);
i++) {
ret_val = msdos_format_write_sec
(fd,
2020538: d2 07 bd b8 ld [ %fp + -584 ], %o1
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
202053c: d4 07 bd b0 ld [ %fp + -592 ], %o2
(fd,
2020540: 92 02 00 09 add %o0, %o1, %o1
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
2020544: 96 07 be 00 add %fp, -512, %o3
2020548: 90 10 00 1a mov %i2, %o0
202054c: 7f ff fc 92 call 201f794 <msdos_format_write_sec>
2020550: ba 07 60 01 inc %i5
2020554: b6 10 00 08 mov %o0, %i3
* mark this in every copy of the FAT
*/
FAT_SET_VAL32(tmp_sec,8,FAT_FAT32_EOC);
}
for (i = 0;
(i < fmt_params.fat_num) && (ret_val == 0);
2020558: c2 0f bd e0 ldub [ %fp + -544 ], %g1
* 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;
202055c: 80 a7 40 01 cmp %i5, %g1
2020560: 16 80 00 04 bge 2020570 <msdos_format+0xc50>
2020564: 80 a6 e0 00 cmp %i3, 0
(i < fmt_params.fat_num) && (ret_val == 0);
2020568: 02 bf ff f2 be 2020530 <msdos_format+0xc10> <== ALWAYS TAKEN
202056c: d2 07 bd c0 ld [ %fp + -576 ], %o1
/*
* cleanup:
* sync and unlock disk
* free any data structures (not needed now)
*/
if (fd != -1) {
2020570: 80 a6 bf ff cmp %i2, -1
2020574: 22 80 00 42 be,a 202067c <msdos_format+0xd5c> <== NEVER TAKEN
2020578: b0 10 00 1b mov %i3, %i0 <== NOT EXECUTED
close(fd);
202057c: 7f ff a0 e2 call 2008904 <close>
2020580: 90 10 00 1a mov %i2, %o0
}
return ret_val;
}
2020584: 81 c7 e0 08 ret
2020588: 91 e8 00 1b restore %g0, %i3, %o0
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));
202058c: 94 10 20 50 mov 0x50, %o2
2020590: 40 00 94 e5 call 2045924 <memset>
2020594: 90 07 bd b0 add %fp, -592, %o0
return ioctl(fd, RTEMS_BLKIO_GETMEDIABLKSIZE, media_block_size);
}
static inline int rtems_disk_fd_get_block_size(int fd, uint32_t *block_size)
{
return ioctl(fd, RTEMS_BLKIO_GETBLKSIZE, block_size);
2020598: 90 10 00 1a mov %i2, %o0
202059c: 3b 10 01 10 sethi %hi(0x40044000), %i5
20205a0: 94 07 bd b0 add %fp, -592, %o2
20205a4: 7f ff a1 ed call 2008d58 <ioctl>
20205a8: 92 17 62 03 or %i5, 0x203, %o1
* At least one thing we don't have to magically guess...
*/
if (ret_val == 0) {
ret_val = rtems_disk_fd_get_block_size(fd, &fmt_params->bytes_per_sector);
}
if (ret_val == 0) {
20205ac: b0 92 20 00 orcc %o0, 0, %i0
20205b0: 12 bf fe 3d bne 201fea4 <msdos_format+0x584> <== NEVER TAKEN
20205b4: f8 07 bd cc ld [ %fp + -564 ], %i4
static inline int rtems_disk_fd_get_block_count(
int fd,
rtems_blkdev_bnum *block_count
)
{
return ioctl(fd, RTEMS_BLKIO_GETSIZE, block_count);
20205b8: 10 bf fd 08 b 201f9d8 <msdos_format+0xb8>
20205bc: 90 10 00 1a mov %i2, %o0
ret_val = EINVAL;
}
}
if (ret_val == 0)
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
20205c0: d6 0f bd e0 ldub [ %fp + -544 ], %o3
20205c4: 90 10 00 19 mov %i1, %o0
20205c8: 92 10 20 02 mov 2, %o1
20205cc: 15 00 81 8a sethi %hi(0x2062800), %o2
20205d0: 7f ff fc 5c call 201f740 <msdos_format_printf>
20205d4: 94 12 a0 c0 or %o2, 0xc0, %o2 ! 20628c0 <rtems_rtc_shell_usage+0xd90>
/*
* determine FAT type and sectors per cluster
* depends on
*/
if (ret_val == 0) {
fmt_params->sectors_per_cluster = 1;
20205d8: 82 10 20 01 mov 1, %g1
if ((rqdata != NULL) &&
20205dc: 80 a6 60 00 cmp %i1, 0
20205e0: 12 bf fd 21 bne 201fa64 <msdos_format+0x144>
20205e4: c2 27 bd bc st %g1, [ %fp + -580 ]
* 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
*/
uint32_t fat12_sect_per_clust = 8;
uint32_t fat16_sect_per_clust = 32;
20205e8: 10 bf fd 39 b 201facc <msdos_format+0x1ac>
20205ec: 84 10 20 20 mov 0x20, %g2
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) &&
20205f0: 32 bf fe 63 bne,a 201ff7c <msdos_format+0x65c>
20205f4: c2 06 60 04 ld [ %i1 + 4 ], %g1
*/
if (ret_val == 0) {
const char *from;
char *to = fmt_params->VolLabel;
int cnt;
from = ""; /* default: make "from" point to empty string */
20205f8: 10 bf fe 67 b 201ff94 <msdos_format+0x674>
20205fc: 03 00 81 82 sethi %hi(0x2060800), %g1
{
int ret_val = 0;
int rc;
struct timeval time_value;
rc = rtems_clock_get_tod_timeval(&time_value);
2020600: 40 00 27 d2 call 202a548 <rtems_clock_get_tod_timeval>
2020604: 90 07 be 00 add %fp, -512, %o0
if (rc == RTEMS_SUCCESSFUL) {
2020608: 80 a2 20 00 cmp %o0, 0
202060c: 02 bf fe 7a be 201fff4 <msdos_format+0x6d4> <== NEVER TAKEN
2020610: c2 07 be 00 ld [ %fp + -512 ], %g1
2020614: 30 bf fe 7b b,a 2020000 <msdos_format+0x6e0>
}
/*
* Phuuu.... That's it.
*/
if (ret_val != 0) {
rtems_set_errno_and_return_minus_one(ret_val);
2020618: 40 00 86 f5 call 20421ec <__errno> <== NOT EXECUTED
202061c: b6 10 3f ff mov -1, %i3 <== NOT EXECUTED
2020620: f0 22 00 00 st %i0, [ %o0 ] <== NOT EXECUTED
ret_val = msdos_format_determine_fmt_params(fd,rqdata,&fmt_params);
}
/*
* if requested, write whole disk/partition with 0xe5
*/
if ((ret_val == 0) &&
2020624: 10 bf fe 7b b 2020010 <msdos_format+0x6f0> <== NOT EXECUTED
2020628: 80 a6 e0 00 cmp %i3, 0 <== NOT EXECUTED
if (0 > lseek(fd,((off_t)start_sector)*sector_size,SEEK_SET)) {
ret_val = -1;
}
if (ret_val == 0) {
if (0 > read(fd,buffer,sector_size)) {
202062c: 92 07 be 00 add %fp, -512, %o1
2020630: 7f ff a5 d4 call 2009d80 <read>
2020634: 94 10 00 1d mov %i5, %o2
2020638: 80 a2 20 00 cmp %o0, 0
202063c: 06 80 00 0e bl 2020674 <msdos_format+0xd54> <== NEVER TAKEN
2020640: 90 10 00 19 mov %i1, %o0
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,
2020644: 92 10 20 02 mov 2, %o1
2020648: 15 00 81 8a sethi %hi(0x2062800), %o2
202064c: 7f ff fc 3d call 201f740 <msdos_format_printf>
2020650: 94 12 a0 d8 or %o2, 0xd8, %o2 ! 20628d8 <rtems_rtc_shell_usage+0xda8>
{
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) {
2020654: fa 07 bd b4 ld [ %fp + -588 ], %i5
2020658: 03 00 00 3f sethi %hi(0xfc00), %g1
202065c: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff <PROM_START+0xffff>
2020660: 80 a7 40 01 cmp %i5, %g1
2020664: 18 bf fe 90 bgu 20200a4 <msdos_format+0x784> <== NEVER TAKEN
2020668: b8 10 20 00 clr %i4
202066c: 10 bf fe 8d b 20200a0 <msdos_format+0x780>
2020670: b8 10 00 1d mov %i5, %i4
}
}
}
}
if (ret_val == 0) {
2020674: 10 bf ff bf b 2020570 <msdos_format+0xc50> <== NOT EXECUTED
2020678: b6 10 3f ff mov -1, %i3 <== NOT EXECUTED
if (fd != -1) {
close(fd);
}
return ret_val;
}
202067c: 81 c7 e0 08 ret <== NOT EXECUTED
2020680: 81 e8 00 00 restore <== NOT EXECUTED
0201f7f4 <msdos_format_fill_sectors>:
)
/*-------------------------------------------------------------------------*\
| Return Value: |
| 0, if success, -1 and errno if failed |
\*=========================================================================*/
{
201f7f4: 9d e3 bf a0 save %sp, -96, %sp
/*
* allocate and fill buffer
*/
if (ret_val == 0) {
fill_buffer = malloc(sector_size);
201f7f8: 7f ff a6 5f call 2009174 <malloc>
201f7fc: 90 10 00 1c mov %i4, %o0
if (fill_buffer == NULL) {
201f800: a0 92 20 00 orcc %o0, 0, %l0
201f804: 12 80 00 07 bne 201f820 <msdos_format_fill_sectors+0x2c> <== ALWAYS TAKEN
201f808: 92 10 00 1d mov %i5, %o1
errno = ENOMEM;
201f80c: 40 00 8a 78 call 20421ec <__errno> <== NOT EXECUTED
201f810: ba 10 3f ff mov -1, %i5 <== NOT EXECUTED
201f814: 82 10 20 0c mov 0xc, %g1 <== NOT EXECUTED
201f818: 10 80 00 05 b 201f82c <msdos_format_fill_sectors+0x38> <== NOT EXECUTED
201f81c: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
ret_val = -1;
}
else {
memset(fill_buffer,fill_byte,sector_size);
201f820: 94 10 00 1c mov %i4, %o2
201f824: 40 00 98 40 call 2045924 <memset>
201f828: ba 10 20 00 clr %i5
}
}
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
201f82c: 90 10 00 18 mov %i0, %o0
201f830: 92 10 20 02 mov 2, %o1
201f834: 15 00 81 89 sethi %hi(0x2062400), %o2
201f838: 7f ff ff c2 call 201f740 <msdos_format_printf>
201f83c: 94 12 a3 80 or %o2, 0x380, %o2 ! 2062780 <rtems_rtc_shell_usage+0xc50>
}
/*=========================================================================* \
| Function: |
\*-------------------------------------------------------------------------*/
static int msdos_format_fill_sectors
201f840: 85 2e e0 02 sll %i3, 2, %g2
201f844: 83 2e e0 04 sll %i3, 4, %g1
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, ".");
201f848: 2b 00 81 82 sethi %hi(0x2060800), %l5
}
/*=========================================================================* \
| Function: |
\*-------------------------------------------------------------------------*/
static int msdos_format_fill_sectors
201f84c: 82 00 80 01 add %g2, %g1, %g1
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
"Filling : ");
/*
* write to consecutive sectors
*/
while ((ret_val == 0) &&
201f850: a4 10 20 00 clr %l2
}
/*=========================================================================* \
| Function: |
\*-------------------------------------------------------------------------*/
static int msdos_format_fill_sectors
201f854: a7 28 60 02 sll %g1, 2, %l3
\*=========================================================================*/
{
int ret_val = 0;
char *fill_buffer = NULL;
uint32_t total_sectors = sector_cnt;
int last_percent = -1;
201f858: a2 10 3f ff mov -1, %l1
}
/*=========================================================================* \
| Function: |
\*-------------------------------------------------------------------------*/
static int msdos_format_fill_sectors
201f85c: a6 00 40 13 add %g1, %l3, %l3
201f860: a8 06 c0 1a add %i3, %i2, %l4
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
"Filling : ");
/*
* write to consecutive sectors
*/
while ((ret_val == 0) &&
201f864: 10 80 00 15 b 201f8b8 <msdos_format_fill_sectors+0xc4>
201f868: aa 15 61 10 or %l5, 0x110, %l5
(sector_cnt > 0)) {
int percent = (sector_cnt * 100) / total_sectors;
201f86c: 40 00 ef 45 call 205b580 <.udiv>
201f870: 92 10 00 1b mov %i3, %o1
if (percent != last_percent) {
201f874: 80 a2 00 11 cmp %o0, %l1
201f878: 02 80 00 08 be 201f898 <msdos_format_fill_sectors+0xa4>
201f87c: 80 8a 20 01 btst 1, %o0
if ((percent & 1) == 0)
201f880: 12 80 00 06 bne 201f898 <msdos_format_fill_sectors+0xa4>
201f884: a2 10 00 08 mov %o0, %l1
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL, ".");
201f888: 90 10 00 18 mov %i0, %o0
201f88c: 92 10 20 02 mov 2, %o1
201f890: 7f ff ff ac call 201f740 <msdos_format_printf>
201f894: 94 10 00 15 mov %l5, %o2
last_percent = percent;
}
ret_val = msdos_format_write_sec(fd,start_sector,sector_size,fill_buffer);
201f898: 92 10 00 1a mov %i2, %o1
201f89c: 90 10 00 19 mov %i1, %o0
201f8a0: 94 10 00 1c mov %i4, %o2
201f8a4: 96 10 00 10 mov %l0, %o3
201f8a8: 7f ff ff bb call 201f794 <msdos_format_write_sec>
201f8ac: b4 06 a0 01 inc %i2
201f8b0: a4 04 bf 9c add %l2, -100, %l2
201f8b4: ba 10 00 08 mov %o0, %i5
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
"Filling : ");
/*
* write to consecutive sectors
*/
while ((ret_val == 0) &&
201f8b8: 80 a5 00 1a cmp %l4, %i2
201f8bc: 02 80 00 04 be 201f8cc <msdos_format_fill_sectors+0xd8>
201f8c0: 80 a7 60 00 cmp %i5, 0
201f8c4: 02 bf ff ea be 201f86c <msdos_format_fill_sectors+0x78> <== ALWAYS TAKEN
201f8c8: 90 04 80 13 add %l2, %l3, %o0
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");
201f8cc: 90 10 00 18 mov %i0, %o0
201f8d0: 92 10 20 02 mov 2, %o1
201f8d4: 15 00 81 97 sethi %hi(0x2065c00), %o2
201f8d8: 7f ff ff 9a call 201f740 <msdos_format_printf>
201f8dc: 94 12 a0 40 or %o2, 0x40, %o2 ! 2065c40 <e2a_32V+0x810>
if (ret_val)
201f8e0: 80 a7 60 00 cmp %i5, 0
201f8e4: 02 80 00 09 be 201f908 <msdos_format_fill_sectors+0x114> <== ALWAYS TAKEN
201f8e8: 80 a4 20 00 cmp %l0, 0
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_INFO,
201f8ec: 15 00 81 89 sethi %hi(0x2062400), %o2 <== NOT EXECUTED
201f8f0: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
201f8f4: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
201f8f8: 94 12 a3 90 or %o2, 0x390, %o2 <== NOT EXECUTED
201f8fc: 7f ff ff 91 call 201f740 <msdos_format_printf> <== NOT EXECUTED
201f900: 96 10 00 1a mov %i2, %o3 <== NOT EXECUTED
"filling error on sector: %d\n", start_sector);
/*
* cleanup
*/
if (fill_buffer != NULL) {
201f904: 80 a4 20 00 cmp %l0, 0 <== NOT EXECUTED
201f908: 02 80 00 04 be 201f918 <msdos_format_fill_sectors+0x124> <== NEVER TAKEN
201f90c: 01 00 00 00 nop
free(fill_buffer);
201f910: 7f ff a4 bb call 2008bfc <free>
201f914: 90 10 00 10 mov %l0, %o0
fill_buffer = NULL;
}
return ret_val;
}
201f918: 81 c7 e0 08 ret
201f91c: 91 e8 00 1d restore %g0, %i5, %o0
0201f740 <msdos_format_printf>:
*/
static void
msdos_format_printf (const msdos_format_request_param_t *rqdata,
int info_level,
const char *format, ...)
{
201f740: 9d e3 bf 98 save %sp, -104, %sp
va_list args;
va_start (args, format);
201f744: 94 07 a0 50 add %fp, 0x50, %o2
201f748: f6 27 a0 50 st %i3, [ %fp + 0x50 ]
201f74c: f8 27 a0 54 st %i4, [ %fp + 0x54 ]
201f750: fa 27 a0 58 st %i5, [ %fp + 0x58 ]
if (rqdata != NULL && rqdata->info_level >= info_level)
201f754: 80 a6 20 00 cmp %i0, 0
201f758: 02 80 00 0d be 201f78c <msdos_format_printf+0x4c>
201f75c: d4 27 bf fc st %o2, [ %fp + -4 ]
201f760: c2 06 20 1c ld [ %i0 + 0x1c ], %g1
201f764: 80 a0 40 19 cmp %g1, %i1
201f768: 06 80 00 09 bl 201f78c <msdos_format_printf+0x4c> <== ALWAYS TAKEN
201f76c: 3b 00 81 af sethi %hi(0x206bc00), %i5
{
vfprintf (stdout, format, args);
201f770: c2 07 61 e0 ld [ %i5 + 0x1e0 ], %g1 ! 206bde0 <_impure_ptr><== NOT EXECUTED
201f774: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED
201f778: 40 00 ce 9f call 20531f4 <vfprintf> <== NOT EXECUTED
201f77c: d0 00 60 08 ld [ %g1 + 8 ], %o0 <== NOT EXECUTED
fflush (stdout);
201f780: c2 07 61 e0 ld [ %i5 + 0x1e0 ], %g1 <== NOT EXECUTED
201f784: 40 00 8b 9d call 20425f8 <fflush> <== NOT EXECUTED
201f788: d0 00 60 08 ld [ %g1 + 8 ], %o0 <== NOT EXECUTED
201f78c: 81 c7 e0 08 ret
201f790: 81 e8 00 00 restore
0201f794 <msdos_format_write_sec>:
)
/*-------------------------------------------------------------------------*\
| Return Value: |
| 0, if success, -1 and errno if failed |
\*=========================================================================*/
{
201f794: 9d e3 bf a0 save %sp, -96, %sp
int ret_val = 0;
if (0 > lseek(fd,((off_t)start_sector)*sector_size,SEEK_SET)) {
201f798: 94 10 20 00 clr %o2
201f79c: 96 10 00 1a mov %i2, %o3
201f7a0: 90 10 20 00 clr %o0
201f7a4: 40 00 f0 cf call 205bae0 <__muldi3>
201f7a8: 92 10 00 19 mov %i1, %o1
201f7ac: 84 10 00 08 mov %o0, %g2
201f7b0: 86 10 00 09 mov %o1, %g3
201f7b4: 90 10 00 18 mov %i0, %o0
201f7b8: 92 10 00 02 mov %g2, %o1
201f7bc: 94 10 00 03 mov %g3, %o2
201f7c0: 40 00 24 e6 call 2028b58 <lseek>
201f7c4: 96 10 20 00 clr %o3
201f7c8: 80 a2 20 00 cmp %o0, 0
201f7cc: 16 80 00 04 bge 201f7dc <msdos_format_write_sec+0x48> <== ALWAYS TAKEN
201f7d0: 90 10 00 18 mov %i0, %o0
201f7d4: 81 c7 e0 08 ret <== NOT EXECUTED
201f7d8: 91 e8 3f ff restore %g0, -1, %o0 <== NOT EXECUTED
ret_val = -1;
}
if (ret_val == 0) {
if (0 > write(fd,buffer,sector_size)) {
201f7dc: 92 10 00 1b mov %i3, %o1
201f7e0: 7f ff b5 2c call 200cc90 <write>
201f7e4: 94 10 00 1a mov %i2, %o2
201f7e8: b1 3a 20 1f sra %o0, 0x1f, %i0
ret_val = -1;
}
}
return ret_val;
}
201f7ec: 81 c7 e0 08 ret
201f7f0: 81 e8 00 00 restore
02035b58 <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
)
{
2035b58: 9d e3 bf 50 save %sp, -176, %sp
int rc = RC_OK;
msdos_fs_info_t *fs_info = mt_entry->fs_info;
2035b5c: f8 06 20 08 ld [ %i0 + 8 ], %i4
fat_file_fd_t *fat_fd = NULL;
2035b60: c0 27 bf bc clr [ %fp + -68 ]
uint32_t cl4find = 0;
/*
* open fat-file corresponded to ".."
*/
rc = fat_file_open(&fs_info->fat, dir_pos, &fat_fd);
2035b64: 90 10 00 1c mov %i4, %o0
2035b68: 92 10 00 1a mov %i2, %o1
2035b6c: 7f ff be 86 call 2025584 <fat_file_open>
2035b70: 94 07 bf bc add %fp, -68, %o2
if (rc != RC_OK)
2035b74: ba 92 20 00 orcc %o0, 0, %i5
2035b78: 32 80 00 a5 bne,a 2035e0c <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x2b4><== NEVER TAKEN
2035b7c: b0 10 00 1d mov %i5, %i0 <== NOT EXECUTED
return rc;
fat_fd->cln = cln;
2035b80: d2 07 bf bc ld [ %fp + -68 ], %o1
fat_fd->fat_file_type = FAT_DIRECTORY;
fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
2035b84: 03 00 08 00 sethi %hi(0x200000), %g1
*/
rc = fat_file_open(&fs_info->fat, dir_pos, &fat_fd);
if (rc != RC_OK)
return rc;
fat_fd->cln = cln;
2035b88: f2 22 60 1c st %i1, [ %o1 + 0x1c ]
fat_fd->fat_file_type = FAT_DIRECTORY;
2035b8c: c0 22 60 10 clr [ %o1 + 0x10 ]
fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
2035b90: c2 22 60 14 st %g1, [ %o1 + 0x14 ]
fat_fd->map.file_cln = 0;
2035b94: c0 22 60 34 clr [ %o1 + 0x34 ]
fat_fd->map.disk_cln = fat_fd->cln;
2035b98: f2 22 60 38 st %i1, [ %o1 + 0x38 ]
rc = fat_file_size(&fs_info->fat, fat_fd);
2035b9c: 7f ff c1 21 call 2026020 <fat_file_size>
2035ba0: 90 10 00 1c mov %i4, %o0
if (rc != RC_OK)
2035ba4: ba 92 20 00 orcc %o0, 0, %i5
2035ba8: 22 80 00 04 be,a 2035bb8 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x60><== ALWAYS TAKEN
2035bac: ba 07 bf c0 add %fp, -64, %i5
rc = msdos_find_name_in_fat_file(mt_entry, fat_fd, false, ".", 1,
MSDOS_NAME_SHORT, dir_pos, dot_node);
if (rc != RC_OK)
{
fat_file_close(&fs_info->fat, fat_fd);
2035bb0: 10 80 00 19 b 2035c14 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0xbc><== NOT EXECUTED
2035bb4: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
fat_file_close(&fs_info->fat, fat_fd);
return rc;
}
/* find "." node in opened directory */
memset(dot_node, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
2035bb8: 92 10 20 00 clr %o1
2035bbc: 90 10 00 1d mov %i5, %o0
2035bc0: 40 00 3f 59 call 2045924 <memset>
2035bc4: 94 10 20 20 mov 0x20, %o2
msdos_long_to_short(".", 1, dot_node, MSDOS_SHORT_NAME_LEN);
2035bc8: 94 10 00 1d mov %i5, %o2
2035bcc: 33 00 81 82 sethi %hi(0x2060800), %i1
2035bd0: 92 10 20 01 mov 1, %o1
2035bd4: 96 10 20 0b mov 0xb, %o3
2035bd8: 7f ff fb 7a call 20349c0 <msdos_long_to_short>
2035bdc: 90 16 61 10 or %i1, 0x110, %o0
rc = msdos_find_name_in_fat_file(mt_entry, fat_fd, false, ".", 1,
2035be0: d2 07 bf bc ld [ %fp + -68 ], %o1
2035be4: fa 23 a0 60 st %i5, [ %sp + 0x60 ]
2035be8: f4 23 a0 5c st %i2, [ %sp + 0x5c ]
2035bec: 90 10 00 18 mov %i0, %o0
2035bf0: 94 10 20 00 clr %o2
2035bf4: 96 16 61 10 or %i1, 0x110, %o3
2035bf8: 98 10 20 01 mov 1, %o4
2035bfc: 7f ff fd 1b call 2035068 <msdos_find_name_in_fat_file>
2035c00: 9a 10 20 01 mov 1, %o5
MSDOS_NAME_SHORT, dir_pos, dot_node);
if (rc != RC_OK)
2035c04: ba 92 20 00 orcc %o0, 0, %i5
2035c08: 22 80 00 05 be,a 2035c1c <msdos_get_dotdot_dir_info_cluster_num_and_offset+0xc4><== ALWAYS TAKEN
2035c0c: ba 07 bf e0 add %fp, -32, %i5
{
fat_file_close(&fs_info->fat, fat_fd);
2035c10: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
2035c14: 10 80 00 77 b 2035df0 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x298><== NOT EXECUTED
2035c18: d2 07 bf bc ld [ %fp + -68 ], %o1 <== NOT EXECUTED
return rc;
}
/* find ".." node in opened directory */
memset(dotdot_node, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
2035c1c: 92 10 20 00 clr %o1
2035c20: 90 10 00 1d mov %i5, %o0
2035c24: 40 00 3f 40 call 2045924 <memset>
2035c28: 94 10 20 20 mov 0x20, %o2
msdos_long_to_short("..", 2, dotdot_node, MSDOS_SHORT_NAME_LEN);
2035c2c: 94 10 00 1d mov %i5, %o2
2035c30: 33 00 81 80 sethi %hi(0x2060000), %i1
2035c34: 92 10 20 02 mov 2, %o1
2035c38: 96 10 20 0b mov 0xb, %o3
2035c3c: 7f ff fb 61 call 20349c0 <msdos_long_to_short>
2035c40: 90 16 62 38 or %i1, 0x238, %o0
rc = msdos_find_name_in_fat_file(mt_entry, fat_fd, false, "..", 2,
2035c44: d2 07 bf bc ld [ %fp + -68 ], %o1
2035c48: fa 23 a0 60 st %i5, [ %sp + 0x60 ]
2035c4c: f4 23 a0 5c st %i2, [ %sp + 0x5c ]
2035c50: 90 10 00 18 mov %i0, %o0
2035c54: 94 10 20 00 clr %o2
2035c58: 96 16 62 38 or %i1, 0x238, %o3
2035c5c: 98 10 20 02 mov 2, %o4
2035c60: 7f ff fd 02 call 2035068 <msdos_find_name_in_fat_file>
2035c64: 9a 10 20 01 mov 1, %o5
MSDOS_NAME_SHORT, dir_pos,
dotdot_node);
if (rc != RC_OK)
2035c68: ba 92 20 00 orcc %o0, 0, %i5
2035c6c: 02 80 00 04 be 2035c7c <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x124><== ALWAYS TAKEN
2035c70: d2 07 bf bc ld [ %fp + -68 ], %o1
fat_fd->map.disk_cln = fat_fd->cln;
rc = fat_file_size(&fs_info->fat, fat_fd);
if (rc != RC_OK)
{
fat_file_close(&fs_info->fat, fat_fd);
2035c74: 10 80 00 5f b 2035df0 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x298><== NOT EXECUTED
2035c78: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
{
fat_file_close(&fs_info->fat, fat_fd);
return rc;
}
cl4find = MSDOS_EXTRACT_CLUSTER_NUM(dot_node);
2035c7c: e0 17 bf da lduh [ %fp + -38 ], %l0
2035c80: e2 17 bf d4 lduh [ %fp + -44 ], %l1
/* close fat-file corresponded to ".." directory */
rc = fat_file_close(&fs_info->fat, fat_fd);
2035c84: 7f ff bf 56 call 20259dc <fat_file_close>
2035c88: 90 10 00 1c mov %i4, %o0
if ( rc != RC_OK )
2035c8c: ba 92 20 00 orcc %o0, 0, %i5
2035c90: 12 80 00 5e bne 2035e08 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x2b0><== NEVER TAKEN
2035c94: c2 17 bf f4 lduh [ %fp + -12 ], %g1
return rc;
if ( (MSDOS_EXTRACT_CLUSTER_NUM(dotdot_node)) == 0)
2035c98: 83 28 60 10 sll %g1, 0x10, %g1
2035c9c: 85 30 60 18 srl %g1, 0x18, %g2
2035ca0: 87 30 60 08 srl %g1, 8, %g3
2035ca4: 03 00 00 3f sethi %hi(0xfc00), %g1
2035ca8: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff <PROM_START+0xffff>
2035cac: 86 08 c0 01 and %g3, %g1, %g3
2035cb0: 86 10 80 03 or %g2, %g3, %g3
2035cb4: c4 17 bf fa lduh [ %fp + -6 ], %g2
2035cb8: 87 28 e0 10 sll %g3, 0x10, %g3
2035cbc: 85 28 a0 10 sll %g2, 0x10, %g2
2035cc0: 89 30 a0 18 srl %g2, 0x18, %g4
2035cc4: 85 30 a0 08 srl %g2, 8, %g2
2035cc8: 82 08 80 01 and %g2, %g1, %g1
2035ccc: 82 11 00 01 or %g4, %g1, %g1
2035cd0: 80 90 c0 01 orcc %g3, %g1, %g0
2035cd4: 12 80 00 08 bne 2035cf4 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x19c><== ALWAYS TAKEN
2035cd8: 90 10 00 1c mov %i4, %o0
fat_dir_pos_t *dir_pos
)
{
dir_pos->sname.cln = 0;
dir_pos->sname.ofs = 0;
dir_pos->lname.cln = FAT_FILE_SHORT_NAME;
2035cdc: 82 10 3f ff mov -1, %g1 <== NOT EXECUTED
fat_dir_pos_init(
fat_dir_pos_t *dir_pos
)
{
dir_pos->sname.cln = 0;
dir_pos->sname.ofs = 0;
2035ce0: c0 26 a0 04 clr [ %i2 + 4 ] <== NOT EXECUTED
dir_pos->lname.cln = FAT_FILE_SHORT_NAME;
2035ce4: c2 26 a0 08 st %g1, [ %i2 + 8 ] <== NOT EXECUTED
dir_pos->lname.ofs = FAT_FILE_SHORT_NAME;
2035ce8: c2 26 a0 0c st %g1, [ %i2 + 0xc ] <== 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;
2035cec: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED
2035cf0: c2 26 80 00 st %g1, [ %i2 ] <== NOT EXECUTED
}
/* open fat-file corresponded to second ".." */
rc = fat_file_open(&fs_info->fat, dir_pos, &fat_fd);
2035cf4: 92 10 00 1a mov %i2, %o1
2035cf8: 7f ff be 23 call 2025584 <fat_file_open>
2035cfc: 94 07 bf bc add %fp, -68, %o2
if (rc != RC_OK)
2035d00: ba 92 20 00 orcc %o0, 0, %i5
2035d04: 12 80 00 41 bne 2035e08 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x2b0><== NEVER TAKEN
2035d08: c2 17 bf f4 lduh [ %fp + -12 ], %g1
return rc;
if ((MSDOS_EXTRACT_CLUSTER_NUM(dotdot_node)) == 0)
2035d0c: 33 00 00 3f sethi %hi(0xfc00), %i1
2035d10: 83 28 60 10 sll %g1, 0x10, %g1
2035d14: b2 16 63 ff or %i1, 0x3ff, %i1
2035d18: bb 30 60 18 srl %g1, 0x18, %i5
2035d1c: 83 30 60 08 srl %g1, 8, %g1
2035d20: 82 08 40 19 and %g1, %i1, %g1
2035d24: ba 17 40 01 or %i5, %g1, %i5
2035d28: c2 17 bf fa lduh [ %fp + -6 ], %g1
2035d2c: bb 2f 60 10 sll %i5, 0x10, %i5
2035d30: 83 28 60 10 sll %g1, 0x10, %g1
2035d34: 89 30 60 18 srl %g1, 0x18, %g4
2035d38: 83 30 60 08 srl %g1, 8, %g1
2035d3c: b2 08 40 19 and %g1, %i1, %i1
2035d40: 88 11 00 19 or %g4, %i1, %g4
2035d44: 88 97 40 04 orcc %i5, %g4, %g4
2035d48: 12 80 00 05 bne 2035d5c <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x204><== ALWAYS TAKEN
2035d4c: d2 07 bf bc ld [ %fp + -68 ], %o1
fat_fd->cln = fs_info->fat.vol.rdir_cl;
2035d50: c2 07 20 38 ld [ %i4 + 0x38 ], %g1 <== NOT EXECUTED
2035d54: 10 80 00 03 b 2035d60 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x208><== NOT EXECUTED
2035d58: c2 22 60 1c st %g1, [ %o1 + 0x1c ] <== NOT EXECUTED
else
fat_fd->cln = MSDOS_EXTRACT_CLUSTER_NUM(dotdot_node);
2035d5c: c8 22 60 1c st %g4, [ %o1 + 0x1c ]
fat_fd->fat_file_type = FAT_DIRECTORY;
fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
2035d60: 03 00 08 00 sethi %hi(0x200000), %g1
2035d64: c2 22 60 14 st %g1, [ %o1 + 0x14 ]
fat_fd->map.file_cln = 0;
fat_fd->map.disk_cln = fat_fd->cln;
2035d68: c2 02 60 1c ld [ %o1 + 0x1c ], %g1
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;
2035d6c: c0 22 60 10 clr [ %o1 + 0x10 ]
fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
fat_fd->map.file_cln = 0;
2035d70: c0 22 60 34 clr [ %o1 + 0x34 ]
fat_fd->map.disk_cln = fat_fd->cln;
2035d74: c2 22 60 38 st %g1, [ %o1 + 0x38 ]
rc = fat_file_size(&fs_info->fat, fat_fd);
2035d78: 7f ff c0 aa call 2026020 <fat_file_size>
2035d7c: 90 10 00 1c mov %i4, %o0
if (rc != RC_OK)
2035d80: ba 92 20 00 orcc %o0, 0, %i5
2035d84: 02 80 00 04 be 2035d94 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x23c><== ALWAYS TAKEN
2035d88: d2 07 bf bc ld [ %fp + -68 ], %o1
{
fat_file_close(&fs_info->fat, fat_fd);
2035d8c: 10 80 00 19 b 2035df0 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x298><== NOT EXECUTED
2035d90: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
{
fat_file_close(&fs_info->fat, fat_fd);
return rc;
}
cl4find = MSDOS_EXTRACT_CLUSTER_NUM(dot_node);
2035d94: 87 2c 60 10 sll %l1, 0x10, %g3
2035d98: 03 00 00 3f sethi %hi(0xfc00), %g1
2035d9c: 95 30 e0 18 srl %g3, 0x18, %o2
2035da0: 82 10 63 ff or %g1, 0x3ff, %g1
2035da4: 87 30 e0 08 srl %g3, 8, %g3
2035da8: 86 08 c0 01 and %g3, %g1, %g3
2035dac: 85 2c 20 10 sll %l0, 0x10, %g2
2035db0: 94 12 80 03 or %o2, %g3, %o2
2035db4: 87 30 a0 18 srl %g2, 0x18, %g3
2035db8: 85 30 a0 08 srl %g2, 8, %g2
2035dbc: 82 08 80 01 and %g2, %g1, %g1
2035dc0: 82 10 c0 01 or %g3, %g1, %g1
2035dc4: 95 2a a0 10 sll %o2, 0x10, %o2
fat_file_close(&fs_info->fat, 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,
2035dc8: 90 10 00 18 mov %i0, %o0
2035dcc: 94 12 80 01 or %o2, %g1, %o2
2035dd0: 96 10 00 1a mov %i2, %o3
2035dd4: 7f ff ff 00 call 20359d4 <msdos_find_node_by_cluster_num_in_fat_file>
2035dd8: 98 10 00 1b mov %i3, %o4
2035ddc: d2 07 bf bc ld [ %fp + -68 ], %o1
2035de0: ba 10 00 08 mov %o0, %i5
dir_pos, dir_entry);
if (rc != RC_OK)
2035de4: 80 a7 60 00 cmp %i5, 0
2035de8: 02 80 00 05 be 2035dfc <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x2a4><== ALWAYS TAKEN
2035dec: 90 10 00 1c mov %i4, %o0
{
fat_file_close(&fs_info->fat, fat_fd);
2035df0: 7f ff be fb call 20259dc <fat_file_close> <== NOT EXECUTED
2035df4: b0 10 00 1d mov %i5, %i0 <== NOT EXECUTED
2035df8: 30 80 00 05 b,a 2035e0c <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x2b4><== NOT EXECUTED
return rc;
}
rc = fat_file_close(&fs_info->fat, fat_fd);
2035dfc: 7f ff be f8 call 20259dc <fat_file_close>
2035e00: 01 00 00 00 nop
2035e04: ba 10 00 08 mov %o0, %i5
return rc;
}
2035e08: b0 10 00 1d mov %i5, %i0
2035e0c: 81 c7 e0 08 ret
2035e10: 81 e8 00 00 restore
02035e14 <msdos_get_name_node>:
int name_len,
msdos_name_type_t name_type,
fat_dir_pos_t *dir_pos,
char *name_dir_entry
)
{
2035e14: 9d e3 bf 98 save %sp, -104, %sp
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,
2035e18: d0 06 20 14 ld [ %i0 + 0x14 ], %o0
2035e1c: d2 06 20 08 ld [ %i0 + 8 ], %o1
int name_len,
msdos_name_type_t name_type,
fat_dir_pos_t *dir_pos,
char *name_dir_entry
)
{
2035e20: e0 07 a0 5c ld [ %fp + 0x5c ], %l0
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,
2035e24: 9a 10 00 1c mov %i4, %o5
2035e28: fa 23 a0 5c st %i5, [ %sp + 0x5c ]
2035e2c: e0 23 a0 60 st %l0, [ %sp + 0x60 ]
2035e30: 94 10 00 19 mov %i1, %o2
2035e34: 96 10 00 1a mov %i2, %o3
2035e38: 7f ff fc 8c call 2035068 <msdos_find_name_in_fat_file>
2035e3c: 98 10 00 1b mov %i3, %o4
create_node, name, name_len, name_type,
dir_pos, name_dir_entry);
if ((rc != RC_OK) && (rc != MSDOS_NAME_NOT_FOUND_ERR))
2035e40: 03 00 00 1f sethi %hi(0x7c00), %g1
2035e44: 82 10 61 01 or %g1, 0x101, %g1 ! 7d01 <PROM_START+0x7d01>
2035e48: 80 a2 00 01 cmp %o0, %g1
2035e4c: 02 80 00 05 be 2035e60 <msdos_get_name_node+0x4c>
2035e50: b8 10 00 08 mov %o0, %i4
2035e54: 80 a2 20 00 cmp %o0, 0
2035e58: 12 80 00 2d bne 2035f0c <msdos_get_name_node+0xf8> <== NEVER TAKEN
2035e5c: 01 00 00 00 nop
return rc;
if (!create_node)
2035e60: 80 a6 60 00 cmp %i1, 0
2035e64: 12 80 00 2a bne 2035f0c <msdos_get_name_node+0xf8>
2035e68: 03 00 00 1f sethi %hi(0x7c00), %g1
{
/* if we search for valid name and name not found -> return */
if (rc == MSDOS_NAME_NOT_FOUND_ERR)
2035e6c: 82 10 61 01 or %g1, 0x101, %g1 ! 7d01 <PROM_START+0x7d01>
2035e70: 80 a7 00 01 cmp %i4, %g1
2035e74: 02 80 00 26 be 2035f0c <msdos_get_name_node+0xf8>
2035e78: 80 a7 20 00 cmp %i4, 0
* 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)
2035e7c: 12 80 00 24 bne 2035f0c <msdos_get_name_node+0xf8> <== NEVER TAKEN
2035e80: 90 10 00 1a mov %i2, %o0
{
if (strncmp(name, "..", 2) == 0)
2035e84: 13 00 81 80 sethi %hi(0x2060000), %o1
2035e88: 94 10 20 02 mov 2, %o2
2035e8c: 40 00 4d 23 call 2049318 <strncmp>
2035e90: 92 12 62 38 or %o1, 0x238, %o1
2035e94: 80 a2 20 00 cmp %o0, 0
2035e98: 12 80 00 1d bne 2035f0c <msdos_get_name_node+0xf8>
2035e9c: 05 00 00 3f sethi %hi(0xfc00), %g2
{
dotdot_cln = MSDOS_EXTRACT_CLUSTER_NUM((name_dir_entry));
2035ea0: c6 14 20 1a lduh [ %l0 + 0x1a ], %g3
2035ea4: c8 14 20 14 lduh [ %l0 + 0x14 ], %g4
2035ea8: 87 28 e0 10 sll %g3, 0x10, %g3
2035eac: 89 29 20 10 sll %g4, 0x10, %g4
2035eb0: 83 30 e0 18 srl %g3, 0x18, %g1
2035eb4: b3 31 20 18 srl %g4, 0x18, %i1
2035eb8: 89 31 20 08 srl %g4, 8, %g4
2035ebc: 84 10 a3 ff or %g2, 0x3ff, %g2
2035ec0: 87 30 e0 08 srl %g3, 8, %g3
2035ec4: 88 09 00 02 and %g4, %g2, %g4
2035ec8: 84 08 c0 02 and %g3, %g2, %g2
2035ecc: b2 16 40 04 or %i1, %g4, %i1
2035ed0: 82 10 40 02 or %g1, %g2, %g1
2035ed4: b3 2e 60 10 sll %i1, 0x10, %i1
/* are we right under root dir ? */
if (dotdot_cln == 0)
2035ed8: b2 96 40 01 orcc %i1, %g1, %i1
2035edc: 12 80 00 08 bne 2035efc <msdos_get_name_node+0xe8>
2035ee0: 82 10 3f ff mov -1, %g1
fat_dir_pos_init(
fat_dir_pos_t *dir_pos
)
{
dir_pos->sname.cln = 0;
dir_pos->sname.ofs = 0;
2035ee4: c0 27 60 04 clr [ %i5 + 4 ]
dir_pos->lname.cln = FAT_FILE_SHORT_NAME;
2035ee8: c2 27 60 08 st %g1, [ %i5 + 8 ]
dir_pos->lname.ofs = FAT_FILE_SHORT_NAME;
2035eec: c2 27 60 0c st %g1, [ %i5 + 0xc ]
/*
* 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;
2035ef0: 82 10 20 01 mov 1, %g1
2035ef4: 10 80 00 06 b 2035f0c <msdos_get_name_node+0xf8>
2035ef8: c2 27 40 00 st %g1, [ %i5 ]
}
else
{
rc =
2035efc: f0 06 20 14 ld [ %i0 + 0x14 ], %i0
2035f00: b4 10 00 1d mov %i5, %i2
2035f04: 7f ff ff 15 call 2035b58 <msdos_get_dotdot_dir_info_cluster_num_and_offset>
2035f08: 97 e8 00 10 restore %g0, %l0, %o3
}
}
}
}
return rc;
}
2035f0c: 81 c7 e0 08 ret
2035f10: 91 e8 00 1c restore %g0, %i4, %o0
02020718 <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
)
{
2020718: 9d e3 bf 88 save %sp, -120, %sp
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));
202071c: 90 10 20 01 mov 1, %o0
)
{
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = NULL;
fat_file_fd_t *fat_fd = NULL;
2020720: c0 27 bf ec clr [ %fp + -20 ]
fat_dir_pos_t root_pos;
uint32_t cl_buf_size;
fs_info = (msdos_fs_info_t *)calloc(1, sizeof(msdos_fs_info_t));
2020724: 7f ff a0 52 call 200886c <calloc>
2020728: 92 10 20 98 mov 0x98, %o1
if (!fs_info)
202072c: ba 92 20 00 orcc %o0, 0, %i5
2020730: 32 80 00 03 bne,a 202073c <msdos_initialize_support+0x24><== ALWAYS TAKEN
2020734: d2 06 20 38 ld [ %i0 + 0x38 ], %o1
2020738: 30 80 00 45 b,a 202084c <msdos_initialize_support+0x134> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(ENOMEM);
temp_mt_entry->fs_info = fs_info;
rc = fat_init_volume_info(&fs_info->fat, temp_mt_entry->dev);
202073c: 40 00 18 ab call 20269e8 <fat_init_volume_info>
2020740: fa 26 20 08 st %i5, [ %i0 + 8 ]
if (rc != RC_OK)
2020744: b8 92 20 00 orcc %o0, 0, %i4
2020748: 12 80 00 12 bne 2020790 <msdos_initialize_support+0x78> <== NEVER TAKEN
202074c: 82 10 3f ff mov -1, %g1
fat_dir_pos_t *dir_pos
)
{
dir_pos->sname.cln = 0;
dir_pos->sname.ofs = 0;
dir_pos->lname.cln = FAT_FILE_SHORT_NAME;
2020750: c2 27 bf f8 st %g1, [ %fp + -8 ]
dir_pos->lname.ofs = FAT_FILE_SHORT_NAME;
2020754: c2 27 bf fc st %g1, [ %fp + -4 ]
/*
* 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;
2020758: 82 10 20 01 mov 1, %g1
{
free(fs_info);
return rc;
}
fs_info->file_handlers = file_handlers;
202075c: f4 27 60 8c st %i2, [ %i5 + 0x8c ]
fs_info->directory_handlers = directory_handlers;
2020760: f6 27 60 88 st %i3, [ %i5 + 0x88 ]
fat_dir_pos_init(
fat_dir_pos_t *dir_pos
)
{
dir_pos->sname.cln = 0;
dir_pos->sname.ofs = 0;
2020764: c0 27 bf f4 clr [ %fp + -12 ]
/*
* 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;
2020768: c2 27 bf f0 st %g1, [ %fp + -16 ]
rc = fat_file_open(&fs_info->fat, &root_pos, &fat_fd);
202076c: 90 10 00 1d mov %i5, %o0
2020770: 92 07 bf f0 add %fp, -16, %o1
2020774: 40 00 13 84 call 2025584 <fat_file_open>
2020778: 94 07 bf ec add %fp, -20, %o2
if (rc != RC_OK)
202077c: b8 92 20 00 orcc %o0, 0, %i4
2020780: 02 80 00 08 be 20207a0 <msdos_initialize_support+0x88> <== ALWAYS TAKEN
2020784: d2 07 bf ec ld [ %fp + -20 ], %o1
{
fat_shutdown_drive(&fs_info->fat);
2020788: 40 00 18 52 call 20268d0 <fat_shutdown_drive> <== NOT EXECUTED
202078c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
free(fs_info);
2020790: 7f ff a1 1b call 2008bfc <free> <== NOT EXECUTED
2020794: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
temp_mt_entry->mt_fs_root->location.node_access = fat_fd;
temp_mt_entry->mt_fs_root->location.handlers = directory_handlers;
temp_mt_entry->ops = op_table;
return rc;
}
2020798: 81 c7 e0 08 ret <== NOT EXECUTED
202079c: 91 e8 00 1c restore %g0, %i4, %o0 <== NOT EXECUTED
return rc;
}
/* again: unfortunately "fat-file" is just almost fat file :( */
fat_fd->fat_file_type = FAT_DIRECTORY;
fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
20207a0: 03 00 08 00 sethi %hi(0x200000), %g1
20207a4: c2 22 60 14 st %g1, [ %o1 + 0x14 ]
fat_fd->cln = fs_info->fat.vol.rdir_cl;
20207a8: c2 07 60 38 ld [ %i5 + 0x38 ], %g1
free(fs_info);
return rc;
}
/* again: unfortunately "fat-file" is just almost fat file :( */
fat_fd->fat_file_type = FAT_DIRECTORY;
20207ac: c0 22 60 10 clr [ %o1 + 0x10 ]
fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
fat_fd->cln = fs_info->fat.vol.rdir_cl;
20207b0: c2 22 60 1c st %g1, [ %o1 + 0x1c ]
fat_fd->map.file_cln = 0;
20207b4: c0 22 60 34 clr [ %o1 + 0x34 ]
fat_fd->map.disk_cln = fat_fd->cln;
/* if we have FAT12/16 */
if ( fat_fd->cln == 0 )
20207b8: 80 a0 60 00 cmp %g1, 0
20207bc: 12 80 00 09 bne 20207e0 <msdos_initialize_support+0xc8> <== NEVER TAKEN
20207c0: c2 22 60 38 st %g1, [ %o1 + 0x38 ]
{
fat_fd->fat_file_size = fs_info->fat.vol.rdir_size;
20207c4: c2 07 60 28 ld [ %i5 + 0x28 ], %g1
cl_buf_size = (fs_info->fat.vol.bpc > fs_info->fat.vol.rdir_size) ?
fs_info->fat.vol.bpc :
20207c8: d0 17 60 06 lduh [ %i5 + 6 ], %o0
/* if we have FAT12/16 */
if ( fat_fd->cln == 0 )
{
fat_fd->fat_file_size = fs_info->fat.vol.rdir_size;
cl_buf_size = (fs_info->fat.vol.bpc > fs_info->fat.vol.rdir_size) ?
20207cc: 80 a2 00 01 cmp %o0, %g1
20207d0: 1a 80 00 13 bcc 202081c <msdos_initialize_support+0x104> <== NEVER TAKEN
20207d4: c2 22 60 18 st %g1, [ %o1 + 0x18 ]
20207d8: 10 80 00 11 b 202081c <msdos_initialize_support+0x104>
20207dc: 90 10 00 01 mov %g1, %o0
fs_info->fat.vol.bpc :
fs_info->fat.vol.rdir_size;
}
else
{
rc = fat_file_size(&fs_info->fat, fat_fd);
20207e0: 40 00 16 10 call 2026020 <fat_file_size> <== NOT EXECUTED
20207e4: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
if ( rc != RC_OK )
20207e8: b4 92 20 00 orcc %o0, 0, %i2 <== NOT EXECUTED
20207ec: 22 80 00 0c be,a 202081c <msdos_initialize_support+0x104><== NOT EXECUTED
20207f0: d0 17 60 06 lduh [ %i5 + 6 ], %o0 <== NOT EXECUTED
{
fat_file_close(&fs_info->fat, fat_fd);
20207f4: d2 07 bf ec ld [ %fp + -20 ], %o1 <== NOT EXECUTED
20207f8: 40 00 14 79 call 20259dc <fat_file_close> <== NOT EXECUTED
20207fc: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
fat_shutdown_drive(&fs_info->fat);
2020800: 40 00 18 34 call 20268d0 <fat_shutdown_drive> <== NOT EXECUTED
2020804: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
free(fs_info);
2020808: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
202080c: 7f ff a0 fc call 2008bfc <free> <== NOT EXECUTED
2020810: b8 10 00 1a mov %i2, %i4 <== NOT EXECUTED
temp_mt_entry->mt_fs_root->location.node_access = fat_fd;
temp_mt_entry->mt_fs_root->location.handlers = directory_handlers;
temp_mt_entry->ops = op_table;
return rc;
}
2020814: 81 c7 e0 08 ret <== NOT EXECUTED
2020818: 91 e8 00 1c restore %g0, %i4, %o0 <== NOT EXECUTED
return rc;
}
cl_buf_size = fs_info->fat.vol.bpc;
}
fs_info->cl_buf = (uint8_t *)calloc(cl_buf_size, sizeof(char));
202081c: 7f ff a0 14 call 200886c <calloc>
2020820: 92 10 20 01 mov 1, %o1
if (fs_info->cl_buf == NULL)
2020824: 80 a2 20 00 cmp %o0, 0
2020828: 12 80 00 0f bne 2020864 <msdos_initialize_support+0x14c> <== ALWAYS TAKEN
202082c: d0 27 60 94 st %o0, [ %i5 + 0x94 ]
{
fat_file_close(&fs_info->fat, fat_fd);
2020830: d2 07 bf ec ld [ %fp + -20 ], %o1 <== NOT EXECUTED
2020834: 40 00 14 6a call 20259dc <fat_file_close> <== NOT EXECUTED
2020838: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
fat_shutdown_drive(&fs_info->fat);
202083c: 40 00 18 25 call 20268d0 <fat_shutdown_drive> <== NOT EXECUTED
2020840: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
free(fs_info);
2020844: 7f ff a0 ee call 2008bfc <free> <== NOT EXECUTED
2020848: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(ENOMEM);
202084c: 40 00 86 68 call 20421ec <__errno> <== NOT EXECUTED
2020850: 01 00 00 00 nop <== NOT EXECUTED
2020854: 82 10 20 0c mov 0xc, %g1 ! c <PROM_START+0xc> <== NOT EXECUTED
2020858: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
202085c: 10 80 00 1b b 20208c8 <msdos_initialize_support+0x1b0> <== NOT EXECUTED
2020860: b8 10 3f ff mov -1, %i4 <== NOT EXECUTED
}
sc = rtems_semaphore_create(3,
2020864: 92 10 20 01 mov 1, %o1
2020868: 90 10 20 03 mov 3, %o0
202086c: 94 10 20 10 mov 0x10, %o2
2020870: 96 10 20 00 clr %o3
2020874: 7f ff b2 58 call 200d1d4 <rtems_semaphore_create>
2020878: 98 07 60 90 add %i5, 0x90, %o4
1,
RTEMS_BINARY_SEMAPHORE | RTEMS_FIFO,
0,
&fs_info->vol_sema);
if (sc != RTEMS_SUCCESSFUL)
202087c: 80 a2 20 00 cmp %o0, 0
2020880: 02 80 00 0e be 20208b8 <msdos_initialize_support+0x1a0> <== ALWAYS TAKEN
2020884: d2 07 bf ec ld [ %fp + -20 ], %o1
{
fat_file_close(&fs_info->fat, fat_fd);
2020888: 40 00 14 55 call 20259dc <fat_file_close> <== NOT EXECUTED
202088c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
fat_shutdown_drive(&fs_info->fat);
2020890: 40 00 18 10 call 20268d0 <fat_shutdown_drive> <== NOT EXECUTED
2020894: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
free(fs_info->cl_buf);
2020898: 7f ff a0 d9 call 2008bfc <free> <== NOT EXECUTED
202089c: d0 07 60 94 ld [ %i5 + 0x94 ], %o0 <== NOT EXECUTED
free(fs_info);
20208a0: 7f ff a0 d7 call 2008bfc <free> <== NOT EXECUTED
20208a4: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EIO );
20208a8: 40 00 86 51 call 20421ec <__errno> <== NOT EXECUTED
20208ac: 01 00 00 00 nop <== NOT EXECUTED
20208b0: 10 bf ff ea b 2020858 <msdos_initialize_support+0x140> <== NOT EXECUTED
20208b4: 82 10 20 05 mov 5, %g1 ! 5 <PROM_START+0x5> <== NOT EXECUTED
}
temp_mt_entry->mt_fs_root->location.node_access = fat_fd;
20208b8: c2 06 20 24 ld [ %i0 + 0x24 ], %g1
20208bc: d2 20 60 08 st %o1, [ %g1 + 8 ]
temp_mt_entry->mt_fs_root->location.handlers = directory_handlers;
20208c0: f6 20 60 10 st %i3, [ %g1 + 0x10 ]
temp_mt_entry->ops = op_table;
20208c4: f2 26 20 0c st %i1, [ %i0 + 0xc ]
return rc;
}
20208c8: b0 10 00 1c mov %i4, %i0
20208cc: 81 c7 e0 08 ret
20208d0: 81 e8 00 00 restore
020206e4 <msdos_lock>:
.rename_h = msdos_rename,
.statvfs_h = rtems_filesystem_default_statvfs
};
void msdos_lock(const rtems_filesystem_mount_table_entry_t *mt_entry)
{
20206e4: 9d e3 bf a0 save %sp, -96, %sp
msdos_fs_info_t *fs_info = mt_entry->fs_info;
rtems_status_code sc = rtems_semaphore_obtain(
fs_info->vol_sema,
20206e8: c2 06 20 08 ld [ %i0 + 8 ], %g1
};
void msdos_lock(const rtems_filesystem_mount_table_entry_t *mt_entry)
{
msdos_fs_info_t *fs_info = mt_entry->fs_info;
rtems_status_code sc = rtems_semaphore_obtain(
20206ec: 92 10 20 00 clr %o1
20206f0: d0 00 60 90 ld [ %g1 + 0x90 ], %o0
20206f4: 7f ff b3 70 call 200d4b4 <rtems_semaphore_obtain>
20206f8: 94 10 20 00 clr %o2
fs_info->vol_sema,
RTEMS_WAIT,
RTEMS_NO_TIMEOUT
);
if (sc != RTEMS_SUCCESSFUL) {
20206fc: 80 a2 20 00 cmp %o0, 0
2020700: 02 80 00 04 be 2020710 <msdos_lock+0x2c> <== ALWAYS TAKEN
2020704: 11 37 ab 6f sethi %hi(0xdeadbc00), %o0
rtems_fatal_error_occurred(0xdeadbeef);
2020708: 7f ff b5 7a call 200dcf0 <rtems_fatal_error_occurred> <== NOT EXECUTED
202070c: 90 12 22 ef or %o0, 0x2ef, %o0 ! deadbeef <RAM_END+0xdc6dbeef><== NOT EXECUTED
2020710: 81 c7 e0 08 ret
2020714: 81 e8 00 00 restore
020349c0 <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)
{
20349c0: 9d e3 bf 98 save %sp, -104, %sp
int i;
/*
* Fill with spaces. This is how a short directory entry is padded.
*/
memset (sfn, ' ', sfn_len);
20349c4: 92 10 20 20 mov 0x20, %o1
20349c8: 90 10 00 1a mov %i2, %o0
20349cc: 40 00 43 d6 call 2045924 <memset>
20349d0: 94 10 00 1b mov %i3, %o2
/*
* Handle '.' and '..' specially.
*/
if ((lfn[0] == '.') && (lfn_len == 1))
20349d4: c2 4e 00 00 ldsb [ %i0 ], %g1
20349d8: 80 a0 60 2e cmp %g1, 0x2e
20349dc: 12 80 00 23 bne 2034a68 <msdos_long_to_short+0xa8>
20349e0: 84 10 20 00 clr %g2
20349e4: 80 a6 60 01 cmp %i1, 1
20349e8: 32 80 00 04 bne,a 20349f8 <msdos_long_to_short+0x38>
20349ec: c2 4e 20 01 ldsb [ %i0 + 1 ], %g1
return MSDOS_NAME_SHORT;
}
if ((lfn[0] == '.') && (lfn[1] == '.') && (lfn_len == 2))
{
sfn[0] = sfn[1] = '.';
20349f0: 10 80 00 0a b 2034a18 <msdos_long_to_short+0x58>
20349f4: c2 2e 80 00 stb %g1, [ %i2 ]
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))
20349f8: 80 a0 60 2e cmp %g1, 0x2e
20349fc: 12 80 00 1c bne 2034a6c <msdos_long_to_short+0xac> <== NEVER TAKEN
2034a00: 80 a0 80 19 cmp %g2, %i1
2034a04: 80 a6 60 02 cmp %i1, 2
2034a08: 12 80 00 19 bne 2034a6c <msdos_long_to_short+0xac> <== NEVER TAKEN
2034a0c: 80 a0 80 19 cmp %g2, %i1
{
sfn[0] = sfn[1] = '.';
2034a10: c2 2e a0 01 stb %g1, [ %i2 + 1 ]
2034a14: c2 2e 80 00 stb %g1, [ %i2 ]
#if MSDOS_L2S_PRINT
printf ("MSDOS_L2S: SHORT[2]: lfn:'%s' SFN:'%s'\n", lfn, sfn);
#endif
return MSDOS_NAME_SHORT;
2034a18: 10 80 00 72 b 2034be0 <msdos_long_to_short+0x220>
2034a1c: 82 10 20 01 mov 1, %g1
/*
* Filenames with only blanks and dots are not allowed!
*/
for (i = 0; i < lfn_len; i++)
if ((lfn[i] != ' ') && (lfn[i] != '.'))
2034a20: 80 a0 60 2e cmp %g1, 0x2e
2034a24: 22 80 00 11 be,a 2034a68 <msdos_long_to_short+0xa8> <== NEVER TAKEN
2034a28: 84 00 a0 01 inc %g2 <== NOT EXECUTED
2034a2c: 80 a0 60 20 cmp %g1, 0x20
2034a30: 22 80 00 0e be,a 2034a68 <msdos_long_to_short+0xa8>
2034a34: 84 00 a0 01 inc %g2
msdos_is_valid_name_char(const char ch)
{
if (strchr(" +,;=[]", ch) != NULL)
return MSDOS_NAME_LONG;
if ((ch == '.') || isalnum((unsigned char)ch) ||
2034a38: 03 00 81 af sethi %hi(0x206bc00), %g1
2034a3c: c2 00 61 d0 ld [ %g1 + 0x1d0 ], %g1 ! 206bdd0 <__ctype_ptr__>
*
*/
static msdos_name_type_t
msdos_is_valid_name_char(const char ch)
{
if (strchr(" +,;=[]", ch) != NULL)
2034a40: 2d 00 81 9b sethi %hi(0x2066c00), %l6
return MSDOS_NAME_LONG;
if ((ch == '.') || isalnum((unsigned char)ch) ||
(strchr("$%'-_@~`!(){}^#&", ch) != NULL))
2034a44: 2f 00 81 9b sethi %hi(0x2066c00), %l7
msdos_is_valid_name_char(const char ch)
{
if (strchr(" +,;=[]", ch) != NULL)
return MSDOS_NAME_LONG;
if ((ch == '.') || isalnum((unsigned char)ch) ||
2034a48: c2 27 bf fc st %g1, [ %fp + -4 ]
2034a4c: b8 10 20 00 clr %i4
2034a50: a2 10 3f ff mov -1, %l1
2034a54: a4 10 20 00 clr %l2
2034a58: a6 10 20 00 clr %l3
*
*/
static msdos_name_type_t
msdos_is_valid_name_char(const char ch)
{
if (strchr(" +,;=[]", ch) != NULL)
2034a5c: ac 15 a3 e0 or %l6, 0x3e0, %l6
return MSDOS_NAME_LONG;
if ((ch == '.') || isalnum((unsigned char)ch) ||
(strchr("$%'-_@~`!(){}^#&", ch) != NULL))
2034a60: 10 80 00 45 b 2034b74 <msdos_long_to_short+0x1b4>
2034a64: ae 15 e3 e8 or %l7, 0x3e8, %l7
}
/*
* Filenames with only blanks and dots are not allowed!
*/
for (i = 0; i < lfn_len; i++)
2034a68: 80 a0 80 19 cmp %g2, %i1
2034a6c: 26 bf ff ed bl,a 2034a20 <msdos_long_to_short+0x60> <== ALWAYS TAKEN
2034a70: c2 4e 00 02 ldsb [ %i0 + %g2 ], %g1
if ((lfn[i] != ' ') && (lfn[i] != '.'))
break;
if (i == lfn_len)
2034a74: 80 a0 80 19 cmp %g2, %i1 <== NOT EXECUTED
2034a78: 12 bf ff f0 bne 2034a38 <msdos_long_to_short+0x78> <== NOT EXECUTED
2034a7c: 82 10 20 00 clr %g1 <== NOT EXECUTED
#if MSDOS_L2S_PRINT
printf ("MSDOS_L2S: TYPE:%d lfn:'%s' SFN:'%s'\n", type, lfn, sfn);
#endif
return type;
}
2034a80: 81 c7 e0 08 ret <== NOT EXECUTED
2034a84: 91 e8 00 01 restore %g0, %g1, %o0 <== NOT EXECUTED
int dot_at = -1;
int count = 0;
while (*name && (count < name_len))
{
bool is_dot = *name == '.';
2034a88: 80 a0 00 01 cmp %g0, %g1
*
*/
static msdos_name_type_t
msdos_is_valid_name_char(const char ch)
{
if (strchr(" +,;=[]", ch) != NULL)
2034a8c: 90 10 00 16 mov %l6, %o0
int dot_at = -1;
int count = 0;
while (*name && (count < name_len))
{
bool is_dot = *name == '.';
2034a90: a8 60 3f ff subx %g0, -1, %l4
*
*/
static msdos_name_type_t
msdos_is_valid_name_char(const char ch)
{
if (strchr(" +,;=[]", ch) != NULL)
2034a94: 92 10 00 1b mov %i3, %o1
2034a98: 40 00 4f 50 call 20487d8 <strchr>
2034a9c: aa 10 00 14 mov %l4, %l5
2034aa0: 80 a2 20 00 cmp %o0, 0
2034aa4: 12 80 00 12 bne 2034aec <msdos_long_to_short+0x12c>
2034aa8: ba 10 20 02 mov 2, %i5
return MSDOS_NAME_LONG;
if ((ch == '.') || isalnum((unsigned char)ch) ||
2034aac: 80 8d 20 ff btst 0xff, %l4
2034ab0: 12 80 00 0e bne 2034ae8 <msdos_long_to_short+0x128>
2034ab4: c2 07 bf fc ld [ %fp + -4 ], %g1
2034ab8: 84 0c 20 ff and %l0, 0xff, %g2
2034abc: 84 00 40 02 add %g1, %g2, %g2
2034ac0: c4 08 a0 01 ldub [ %g2 + 1 ], %g2
2034ac4: 80 88 a0 07 btst 7, %g2
2034ac8: 12 80 00 09 bne 2034aec <msdos_long_to_short+0x12c>
2034acc: ba 10 20 01 mov 1, %i5
(strchr("$%'-_@~`!(){}^#&", ch) != NULL))
2034ad0: 90 10 00 17 mov %l7, %o0
2034ad4: 40 00 4f 41 call 20487d8 <strchr>
2034ad8: 92 10 00 1b mov %i3, %o1
*/
static msdos_name_type_t
msdos_is_valid_name_char(const char ch)
{
if (strchr(" +,;=[]", ch) != NULL)
return MSDOS_NAME_LONG;
2034adc: 80 a0 00 08 cmp %g0, %o0
2034ae0: 10 80 00 03 b 2034aec <msdos_long_to_short+0x12c>
2034ae4: ba 40 20 00 addx %g0, 0, %i5
if ((ch == '.') || isalnum((unsigned char)ch) ||
(strchr("$%'-_@~`!(){}^#&", ch) != NULL))
return MSDOS_NAME_SHORT;
2034ae8: ba 10 20 01 mov 1, %i5
#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))
2034aec: 80 8f 60 01 btst 1, %i5
2034af0: 02 80 00 2f be 2034bac <msdos_long_to_short+0x1ec>
2034af4: 80 a4 7f ff cmp %l1, -1
return type;
if (dot_at >= 0)
2034af8: 02 80 00 0a be 2034b20 <msdos_long_to_short+0x160>
2034afc: 80 8d 60 ff btst 0xff, %l5
{
if (is_dot || ((count - dot_at) > 3))
2034b00: 32 80 00 2e bne,a 2034bb8 <msdos_long_to_short+0x1f8> <== ALWAYS TAKEN
2034b04: ba 10 20 02 mov 2, %i5
2034b08: 82 27 00 11 sub %i4, %l1, %g1 <== NOT EXECUTED
2034b0c: 80 a0 60 03 cmp %g1, 3 <== NOT EXECUTED
2034b10: 24 80 00 0d ble,a 2034b44 <msdos_long_to_short+0x184> <== NOT EXECUTED
2034b14: 82 04 3f bf add %l0, -65, %g1 <== NOT EXECUTED
{
#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;
2034b18: 10 80 00 28 b 2034bb8 <msdos_long_to_short+0x1f8> <== NOT EXECUTED
2034b1c: ba 10 20 02 mov 2, %i5 <== NOT EXECUTED
return MSDOS_NAME_LONG;
}
}
else
{
if (count == 8 && !is_dot)
2034b20: 80 a5 20 00 cmp %l4, 0
2034b24: 12 80 00 05 bne 2034b38 <msdos_long_to_short+0x178>
2034b28: 80 8d 60 ff btst 0xff, %l5
2034b2c: 80 a7 20 08 cmp %i4, 8
2034b30: 02 80 00 28 be 2034bd0 <msdos_long_to_short+0x210>
2034b34: 80 8d 60 ff btst 0xff, %l5
#endif
return MSDOS_NAME_LONG;
}
}
if (is_dot)
2034b38: 32 80 00 0e bne,a 2034b70 <msdos_long_to_short+0x1b0>
2034b3c: a2 10 00 1c mov %i4, %l1
dot_at = count;
else if ((*name >= 'A') && (*name <= 'Z'))
2034b40: 82 04 3f bf add %l0, -65, %g1
2034b44: 82 08 60 ff and %g1, 0xff, %g1
2034b48: 80 a0 60 19 cmp %g1, 0x19
2034b4c: 28 80 00 09 bleu,a 2034b70 <msdos_long_to_short+0x1b0>
2034b50: a4 10 20 01 mov 1, %l2
uppercase = true;
else if ((*name >= 'a') && (*name <= 'z'))
2034b54: a0 04 3f 9f add %l0, -97, %l0
2034b58: a0 0c 20 ff and %l0, 0xff, %l0
2034b5c: 80 a4 20 19 cmp %l0, 0x19
2034b60: 28 80 00 04 bleu,a 2034b70 <msdos_long_to_short+0x1b0>
2034b64: a6 10 20 01 mov 1, %l3
lowercase = true;
count++;
2034b68: 10 80 00 03 b 2034b74 <msdos_long_to_short+0x1b4>
2034b6c: b8 07 20 01 inc %i4
2034b70: b8 07 20 01 inc %i4
bool lowercase = false;
bool uppercase = false;
int dot_at = -1;
int count = 0;
while (*name && (count < name_len))
2034b74: f6 4e 00 1c ldsb [ %i0 + %i4 ], %i3
2034b78: 80 a6 e0 00 cmp %i3, 0
2034b7c: 02 80 00 05 be 2034b90 <msdos_long_to_short+0x1d0>
2034b80: e0 0e 00 1c ldub [ %i0 + %i4 ], %l0
2034b84: 80 a7 00 19 cmp %i4, %i1
2034b88: 06 bf ff c0 bl 2034a88 <msdos_long_to_short+0xc8>
2034b8c: 82 1e e0 2e xor %i3, 0x2e, %g1
count++;
name++;
}
if (lowercase && uppercase)
2034b90: 80 8c e0 ff btst 0xff, %l3
2034b94: 02 80 00 11 be 2034bd8 <msdos_long_to_short+0x218>
2034b98: 80 8c a0 ff btst 0xff, %l2
2034b9c: 22 80 00 07 be,a 2034bb8 <msdos_long_to_short+0x1f8> <== ALWAYS TAKEN
2034ba0: ba 10 20 01 mov 1, %i5
{
#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;
2034ba4: 10 80 00 05 b 2034bb8 <msdos_long_to_short+0x1f8> <== NOT EXECUTED
2034ba8: ba 10 20 02 mov 2, %i5 <== NOT EXECUTED
* Is this a short name ?
*/
type = msdos_name_type (lfn, lfn_len);
if (type == MSDOS_NAME_INVALID)
2034bac: 82 97 60 00 orcc %i5, 0, %g1
2034bb0: 22 80 00 0d be,a 2034be4 <msdos_long_to_short+0x224> <== NEVER TAKEN
2034bb4: b0 10 00 01 mov %g1, %i0 <== NOT EXECUTED
printf ("MSDOS_L2S: INVALID[2]: lfn:'%s' SFN:'%s'\n", lfn, sfn);
#endif
return MSDOS_NAME_INVALID;
}
msdos_filename_unix2dos (lfn, lfn_len, sfn);
2034bb8: 90 10 00 18 mov %i0, %o0
2034bbc: 92 10 00 19 mov %i1, %o1
2034bc0: 40 00 2e e9 call 2040764 <msdos_filename_unix2dos>
2034bc4: 94 10 00 1a mov %i2, %o2
#if MSDOS_L2S_PRINT
printf ("MSDOS_L2S: TYPE:%d lfn:'%s' SFN:'%s'\n", type, lfn, sfn);
#endif
return type;
2034bc8: 10 80 00 06 b 2034be0 <msdos_long_to_short+0x220>
2034bcc: 82 10 00 1d mov %i5, %g1
{
#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;
2034bd0: 10 bf ff fa b 2034bb8 <msdos_long_to_short+0x1f8>
2034bd4: ba 10 20 02 mov 2, %i5
}
#if MSDOS_NAME_TYPE_PRINT
printf ("MSDOS_NAME_TYPE: SHORT[1]\n");
#endif
return MSDOS_NAME_SHORT;
2034bd8: 10 bf ff f8 b 2034bb8 <msdos_long_to_short+0x1f8>
2034bdc: ba 10 20 01 mov 1, %i5
#if MSDOS_L2S_PRINT
printf ("MSDOS_L2S: TYPE:%d lfn:'%s' SFN:'%s'\n", type, lfn, sfn);
#endif
return type;
}
2034be0: b0 10 00 01 mov %g1, %i0
2034be4: 81 c7 e0 08 ret
2034be8: 81 e8 00 00 restore
020208d4 <msdos_mknod>:
const char *name,
size_t namelen,
mode_t mode,
dev_t dev
)
{
20208d4: 9d e3 bf a0 save %sp, -96, %sp
msdos_node_type_t type = 0;
/*
* Figure out what type of msdos node this is.
*/
if (S_ISDIR(mode))
20208d8: 05 00 00 3c sethi %hi(0xf000), %g2
20208dc: 03 00 00 10 sethi %hi(0x4000), %g1
20208e0: 84 0e c0 02 and %i3, %g2, %g2
const char *name,
size_t namelen,
mode_t mode,
dev_t dev
)
{
20208e4: 88 10 00 19 mov %i1, %g4
20208e8: 86 10 00 1a mov %i2, %g3
msdos_node_type_t type = 0;
/*
* Figure out what type of msdos node this is.
*/
if (S_ISDIR(mode))
20208ec: 80 a0 80 01 cmp %g2, %g1
20208f0: 02 80 00 07 be 202090c <msdos_mknod+0x38>
20208f4: b8 10 00 1b mov %i3, %i4
{
type = MSDOS_DIRECTORY;
}
else if (S_ISREG(mode))
20208f8: 3b 00 00 20 sethi %hi(0x8000), %i5
20208fc: 80 a0 80 1d cmp %g2, %i5
2020900: 02 80 00 04 be 2020910 <msdos_mknod+0x3c> <== ALWAYS TAKEN
2020904: b2 10 20 04 mov 4, %i1
2020908: 30 80 00 06 b,a 2020920 <msdos_mknod+0x4c> <== NOT EXECUTED
/*
* Figure out what type of msdos node this is.
*/
if (S_ISDIR(mode))
{
type = MSDOS_DIRECTORY;
202090c: b2 10 20 00 clr %i1
}
else
rtems_set_errno_and_return_minus_one(EINVAL);
/* Create an MSDOS node */
rc = msdos_creat_node(parentloc, type, name, namelen, mode, NULL);
2020910: b4 10 00 04 mov %g4, %i2
2020914: b6 10 00 03 mov %g3, %i3
2020918: 40 00 4e c8 call 2034438 <msdos_creat_node>
202091c: 9b e8 20 00 restore %g0, 0, %o5
else if (S_ISREG(mode))
{
type = MSDOS_REGULAR_FILE;
}
else
rtems_set_errno_and_return_minus_one(EINVAL);
2020920: 40 00 86 33 call 20421ec <__errno> <== NOT EXECUTED
2020924: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
2020928: 82 10 20 16 mov 0x16, %g1 <== NOT EXECUTED
202092c: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
/* Create an MSDOS node */
rc = msdos_creat_node(parentloc, type, name, namelen, mode, NULL);
return rc;
}
2020930: 81 c7 e0 08 ret <== NOT EXECUTED
2020934: 81 e8 00 00 restore <== NOT EXECUTED
02020944 <msdos_rename>:
const rtems_filesystem_location_info_t *old_loc,
const rtems_filesystem_location_info_t *new_parent_loc,
const char *new_name,
size_t new_namelen
)
{
2020944: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED
int rc = RC_OK;
fat_file_fd_t *old_fat_fd = old_loc->node_access;
2020948: fa 06 60 08 ld [ %i1 + 8 ], %i5 <== NOT EXECUTED
/*
* create new directory entry as "hard link", copying relevant info from
* existing file
*/
rc = msdos_creat_node(new_parent_loc,
202094c: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
2020950: 92 10 20 02 mov 2, %o1 <== NOT EXECUTED
2020954: 94 10 00 1b mov %i3, %o2 <== NOT EXECUTED
2020958: 96 10 00 1c mov %i4, %o3 <== NOT EXECUTED
202095c: 19 00 00 20 sethi %hi(0x8000), %o4 <== NOT EXECUTED
2020960: 40 00 4e b6 call 2034438 <msdos_creat_node> <== NOT EXECUTED
2020964: 9a 10 00 1d mov %i5, %o5 <== NOT EXECUTED
MSDOS_HARD_LINK,new_name,new_namelen,S_IFREG,
old_fat_fd);
if (rc != RC_OK)
2020968: b0 92 20 00 orcc %o0, 0, %i0 <== NOT EXECUTED
202096c: 12 80 00 05 bne 2020980 <msdos_rename+0x3c> <== NOT EXECUTED
2020970: b4 10 20 e5 mov 0xe5, %i2 <== NOT EXECUTED
}
/*
* mark file removed
*/
rc = msdos_set_first_char4file_name(old_loc->mt_entry,
2020974: f0 06 60 14 ld [ %i1 + 0x14 ], %i0 <== NOT EXECUTED
2020978: 40 00 51 23 call 2034e04 <msdos_set_first_char4file_name> <== NOT EXECUTED
202097c: 93 ef 60 20 restore %i5, 0x20, %o1 <== NOT EXECUTED
&old_fat_fd->dir_pos,
MSDOS_THIS_DIR_ENTRY_EMPTY);
return rc;
}
2020980: 81 c7 e0 08 ret <== NOT EXECUTED
2020984: 81 e8 00 00 restore <== NOT EXECUTED
02020988 <msdos_rmnod>:
#include "msdos.h"
int
msdos_rmnod(const rtems_filesystem_location_info_t *parent_pathloc,
const rtems_filesystem_location_info_t *pathloc)
{
2020988: 9d e3 bf 98 save %sp, -104, %sp
int rc = RC_OK;
msdos_fs_info_t *fs_info = pathloc->mt_entry->fs_info;
fat_file_fd_t *fat_fd = pathloc->node_access;
202098c: fa 06 60 08 ld [ %i1 + 8 ], %i5
int
msdos_rmnod(const rtems_filesystem_location_info_t *parent_pathloc,
const rtems_filesystem_location_info_t *pathloc)
{
int rc = RC_OK;
msdos_fs_info_t *fs_info = pathloc->mt_entry->fs_info;
2020990: d0 06 60 14 ld [ %i1 + 0x14 ], %o0
fat_file_fd_t *fat_fd = pathloc->node_access;
if (fat_fd->fat_file_type == MSDOS_DIRECTORY)
2020994: c4 07 60 10 ld [ %i5 + 0x10 ], %g2
2020998: 80 a0 a0 00 cmp %g2, 0
202099c: 12 80 00 22 bne 2020a24 <msdos_rmnod+0x9c>
20209a0: f8 02 20 08 ld [ %o0 + 8 ], %i4
{
bool is_empty = false;
20209a4: c0 2f bf ff clrb [ %fp + -1 ]
/*
* You cannot remove a node that still has children
*/
rc = msdos_dir_is_empty(pathloc->mt_entry, fat_fd, &is_empty);
20209a8: 92 10 00 1d mov %i5, %o1
20209ac: 40 00 51 63 call 2034f38 <msdos_dir_is_empty>
20209b0: 94 07 bf ff add %fp, -1, %o2
if (rc != RC_OK)
20209b4: b0 92 20 00 orcc %o0, 0, %i0
20209b8: 12 80 00 23 bne 2020a44 <msdos_rmnod+0xbc> <== NEVER TAKEN
20209bc: c2 0f bf ff ldub [ %fp + -1 ], %g1
{
return rc;
}
if (!is_empty)
20209c0: 80 a0 60 00 cmp %g1, 0
20209c4: 32 80 00 06 bne,a 20209dc <msdos_rmnod+0x54>
20209c8: c2 07 60 08 ld [ %i5 + 8 ], %g1
{
rtems_set_errno_and_return_minus_one(ENOTEMPTY);
20209cc: 40 00 86 08 call 20421ec <__errno>
20209d0: 01 00 00 00 nop
20209d4: 10 80 00 11 b 2020a18 <msdos_rmnod+0x90>
20209d8: 82 10 20 5a mov 0x5a, %g1 ! 5a <PROM_START+0x5a>
/*
* We deny attempts to delete open directory (if directory is current
* directory we assume it is open one)
*/
if (fat_fd->links_num > 1)
20209dc: 80 a0 60 01 cmp %g1, 1
20209e0: 28 80 00 03 bleu,a 20209ec <msdos_rmnod+0x64> <== ALWAYS TAKEN
20209e4: c2 06 60 14 ld [ %i1 + 0x14 ], %g1
20209e8: 30 80 00 09 b,a 2020a0c <msdos_rmnod+0x84> <== NOT EXECUTED
const rtems_filesystem_location_info_t *loc
)
{
const rtems_filesystem_mount_table_entry_t *mt_entry = loc->mt_entry;
return (*mt_entry->ops->are_nodes_equal_h)(
20209ec: 90 10 00 19 mov %i1, %o0
20209f0: c4 00 60 0c ld [ %g1 + 0xc ], %g2
20209f4: c4 00 a0 10 ld [ %g2 + 0x10 ], %g2
20209f8: 9f c0 80 00 call %g2
20209fc: d2 00 60 24 ld [ %g1 + 0x24 ], %o1
}
/*
* You cannot remove the file system root node.
*/
if (rtems_filesystem_location_is_root(pathloc))
2020a00: 80 8a 20 ff btst 0xff, %o0
2020a04: 22 80 00 08 be,a 2020a24 <msdos_rmnod+0x9c> <== ALWAYS TAKEN
2020a08: d0 06 60 14 ld [ %i1 + 0x14 ], %o0
{
rtems_set_errno_and_return_minus_one(EBUSY);
2020a0c: 40 00 85 f8 call 20421ec <__errno> <== NOT EXECUTED
2020a10: 01 00 00 00 nop <== NOT EXECUTED
2020a14: 82 10 20 10 mov 0x10, %g1 ! 10 <PROM_START+0x10> <== NOT EXECUTED
2020a18: c2 22 00 00 st %g1, [ %o0 ]
2020a1c: 81 c7 e0 08 ret
2020a20: 91 e8 3f ff restore %g0, -1, %o0
* not used - mount() not implemenetd yet.
*/
}
/* mark file removed */
rc = msdos_set_first_char4file_name(pathloc->mt_entry, &fat_fd->dir_pos,
2020a24: 92 07 60 20 add %i5, 0x20, %o1
2020a28: 40 00 50 f7 call 2034e04 <msdos_set_first_char4file_name>
2020a2c: 94 10 20 e5 mov 0xe5, %o2
MSDOS_THIS_DIR_ENTRY_EMPTY);
if (rc != RC_OK)
2020a30: b0 92 20 00 orcc %o0, 0, %i0
2020a34: 12 80 00 04 bne 2020a44 <msdos_rmnod+0xbc> <== NEVER TAKEN
2020a38: 90 10 00 1c mov %i4, %o0
{
return rc;
}
fat_file_mark_removed(&fs_info->fat, fat_fd);
2020a3c: 40 00 15 65 call 2025fd0 <fat_file_mark_removed>
2020a40: 92 10 00 1d mov %i5, %o1
return rc;
}
2020a44: 81 c7 e0 08 ret
2020a48: 81 e8 00 00 restore
02034bec <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
)
{
2034bec: 9d e3 bf 98 save %sp, -104, %sp
uint16_t time_val;
uint16_t date;
uint32_t sec = 0;
uint32_t byte = 0;
msdos_date_unix2dos(fat_fd->mtime, &date, &time_val);
2034bf0: d0 06 60 40 ld [ %i1 + 0x40 ], %o0
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_file_fd_t *fat_fd
)
{
ssize_t ret1 = 0, ret2 = 0, ret3 = 0;
msdos_fs_info_t *fs_info = mt_entry->fs_info;
2034bf4: fa 06 20 08 ld [ %i0 + 8 ], %i5
uint16_t time_val;
uint16_t date;
uint32_t sec = 0;
uint32_t byte = 0;
msdos_date_unix2dos(fat_fd->mtime, &date, &time_val);
2034bf8: 94 07 bf fc add %fp, -4, %o2
2034bfc: 40 00 2e 3f call 20404f8 <msdos_date_unix2dos>
2034c00: 92 07 bf fe add %fp, -2, %o1
/*
* calculate input for _fat_block_write: convert (cluster num, offset) to
* (sector num, new offset)
*/
sec = fat_cluster_num_to_sector_num(&fs_info->fat, fat_fd->dir_pos.sname.cln);
2034c04: d2 06 60 20 ld [ %i1 + 0x20 ], %o1
2034c08: 7f ff ff 60 call 2034988 <fat_cluster_num_to_sector_num>
2034c0c: 90 10 00 1d mov %i5, %o0
sec += (fat_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);
2034c10: c2 06 60 24 ld [ %i1 + 0x24 ], %g1
/* byte points to start of 32bytes structure */
byte = fat_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1);
2034c14: f8 17 40 00 lduh [ %i5 ], %i4
/*
* calculate input for _fat_block_write: convert (cluster num, offset) to
* (sector num, new offset)
*/
sec = fat_cluster_num_to_sector_num(&fs_info->fat, fat_fd->dir_pos.sname.cln);
sec += (fat_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);
2034c18: f6 0f 60 02 ldub [ %i5 + 2 ], %i3
/* byte points to start of 32bytes structure */
byte = fat_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1);
2034c1c: b8 07 3f ff add %i4, -1, %i4
/*
* calculate input for _fat_block_write: convert (cluster num, offset) to
* (sector num, new offset)
*/
sec = fat_cluster_num_to_sector_num(&fs_info->fat, fat_fd->dir_pos.sname.cln);
sec += (fat_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);
2034c20: b7 30 40 1b srl %g1, %i3, %i3
/* byte points to start of 32bytes structure */
byte = fat_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1);
2034c24: b8 0f 00 01 and %i4, %g1, %i4
time_val = CT_LE_W(time_val);
2034c28: c2 17 bf fc lduh [ %fp + -4 ], %g1
/*
* calculate input for _fat_block_write: convert (cluster num, offset) to
* (sector num, new offset)
*/
sec = fat_cluster_num_to_sector_num(&fs_info->fat, fat_fd->dir_pos.sname.cln);
sec += (fat_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);
2034c2c: b6 02 00 1b add %o0, %i3, %i3
/* 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);
2034c30: 83 28 60 10 sll %g1, 0x10, %g1
2034c34: 85 30 60 08 srl %g1, 8, %g2
2034c38: 83 30 60 18 srl %g1, 0x18, %g1
2034c3c: 82 10 80 01 or %g2, %g1, %g1
ret1 = _fat_block_write(&fs_info->fat, sec, byte + MSDOS_FILE_WTIME_OFFSET,
2034c40: 92 10 00 1b mov %i3, %o1
sec = fat_cluster_num_to_sector_num(&fs_info->fat, 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);
2034c44: c2 37 bf fc sth %g1, [ %fp + -4 ]
ret1 = _fat_block_write(&fs_info->fat, sec, byte + MSDOS_FILE_WTIME_OFFSET,
2034c48: 94 07 20 16 add %i4, 0x16, %o2
2034c4c: 96 10 20 02 mov 2, %o3
2034c50: 98 07 bf fc add %fp, -4, %o4
2034c54: 7f ff c6 21 call 20264d8 <_fat_block_write>
2034c58: 90 10 00 1d mov %i5, %o0
2, (char *)(&time_val));
date = CT_LE_W(date);
2034c5c: c2 17 bf fe lduh [ %fp + -2 ], %g1
ret2 = _fat_block_write(&fs_info->fat, sec, byte + MSDOS_FILE_WDATE_OFFSET,
2034c60: 92 10 00 1b mov %i3, %o1
byte = fat_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1);
time_val = CT_LE_W(time_val);
ret1 = _fat_block_write(&fs_info->fat, sec, byte + MSDOS_FILE_WTIME_OFFSET,
2, (char *)(&time_val));
date = CT_LE_W(date);
2034c64: 83 28 60 10 sll %g1, 0x10, %g1
2034c68: 85 30 60 08 srl %g1, 8, %g2
2034c6c: 83 30 60 18 srl %g1, 0x18, %g1
2034c70: 82 10 80 01 or %g2, %g1, %g1
ret2 = _fat_block_write(&fs_info->fat, sec, byte + MSDOS_FILE_WDATE_OFFSET,
2034c74: 94 07 20 18 add %i4, 0x18, %o2
byte = fat_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1);
time_val = CT_LE_W(time_val);
ret1 = _fat_block_write(&fs_info->fat, sec, byte + MSDOS_FILE_WTIME_OFFSET,
2, (char *)(&time_val));
date = CT_LE_W(date);
2034c78: c2 37 bf fe sth %g1, [ %fp + -2 ]
ret2 = _fat_block_write(&fs_info->fat, sec, byte + MSDOS_FILE_WDATE_OFFSET,
2034c7c: 96 10 20 02 mov 2, %o3
2034c80: 98 07 bf fe add %fp, -2, %o4
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(&fs_info->fat, sec, byte + MSDOS_FILE_WTIME_OFFSET,
2034c84: b4 10 00 08 mov %o0, %i2
2, (char *)(&time_val));
date = CT_LE_W(date);
ret2 = _fat_block_write(&fs_info->fat, sec, byte + MSDOS_FILE_WDATE_OFFSET,
2034c88: 7f ff c6 14 call 20264d8 <_fat_block_write>
2034c8c: 90 10 00 1d mov %i5, %o0
2, (char *)(&date));
ret3 = _fat_block_write(&fs_info->fat, sec, byte + MSDOS_FILE_ADATE_OFFSET,
2034c90: 92 10 00 1b mov %i3, %o1
time_val = CT_LE_W(time_val);
ret1 = _fat_block_write(&fs_info->fat, sec, byte + MSDOS_FILE_WTIME_OFFSET,
2, (char *)(&time_val));
date = CT_LE_W(date);
ret2 = _fat_block_write(&fs_info->fat, sec, byte + MSDOS_FILE_WDATE_OFFSET,
2034c94: b2 10 00 08 mov %o0, %i1
2, (char *)(&date));
ret3 = _fat_block_write(&fs_info->fat, sec, byte + MSDOS_FILE_ADATE_OFFSET,
2034c98: 94 07 20 12 add %i4, 0x12, %o2
2034c9c: 90 10 00 1d mov %i5, %o0
2034ca0: 96 10 20 02 mov 2, %o3
2034ca4: 7f ff c6 0d call 20264d8 <_fat_block_write>
2034ca8: 98 07 bf fe add %fp, -2, %o4
2, (char *)(&date));
if ( (ret1 < 0) || (ret2 < 0) || (ret3 < 0) )
2034cac: 80 a6 60 00 cmp %i1, 0
2034cb0: 06 80 00 04 bl 2034cc0 <msdos_set_dir_wrt_time_and_date+0xd4><== NEVER TAKEN
2034cb4: 80 a6 a0 00 cmp %i2, 0
2034cb8: 16 80 00 04 bge 2034cc8 <msdos_set_dir_wrt_time_and_date+0xdc><== ALWAYS TAKEN
2034cbc: 80 a2 20 00 cmp %o0, 0
return -1;
2034cc0: 81 c7 e0 08 ret <== NOT EXECUTED
2034cc4: 91 e8 3f ff restore %g0, -1, %o0 <== NOT EXECUTED
ret2 = _fat_block_write(&fs_info->fat, sec, byte + MSDOS_FILE_WDATE_OFFSET,
2, (char *)(&date));
ret3 = _fat_block_write(&fs_info->fat, sec, byte + MSDOS_FILE_ADATE_OFFSET,
2, (char *)(&date));
if ( (ret1 < 0) || (ret2 < 0) || (ret3 < 0) )
2034cc8: 06 bf ff fe bl 2034cc0 <msdos_set_dir_wrt_time_and_date+0xd4><== NEVER TAKEN
2034ccc: 01 00 00 00 nop
return -1;
return RC_OK;
}
2034cd0: 81 c7 e0 08 ret
2034cd4: 91 e8 20 00 restore %g0, 0, %o0
02034e04 <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
)
{
2034e04: 9d e3 bf 90 save %sp, -112, %sp
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;
2034e08: c2 06 60 08 ld [ %i1 + 8 ], %g1
fat_dir_pos_t *dir_pos,
unsigned char fchar
)
{
ssize_t ret;
msdos_fs_info_t *fs_info = mt_entry->fs_info;
2034e0c: fa 06 20 08 ld [ %i0 + 8 ], %i5
uint32_t dir_block_size;
fat_pos_t start = dir_pos->lname;
2034e10: c2 27 bf f0 st %g1, [ %fp + -16 ]
2034e14: c2 06 60 0c ld [ %i1 + 0xc ], %g1
fat_pos_t end = dir_pos->sname;
2034e18: f8 06 40 00 ld [ %i1 ], %i4
)
{
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;
2034e1c: c2 27 bf f4 st %g1, [ %fp + -12 ]
fat_pos_t end = dir_pos->sname;
2034e20: c2 06 60 04 ld [ %i1 + 4 ], %g1
msdos_set_first_char4file_name(
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_dir_pos_t *dir_pos,
unsigned char fchar
)
{
2034e24: f4 2f a0 4c stb %i2, [ %fp + 0x4c ]
ssize_t ret;
msdos_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t dir_block_size;
fat_pos_t start = dir_pos->lname;
fat_pos_t end = dir_pos->sname;
2034e28: c2 27 bf fc st %g1, [ %fp + -4 ]
if ((end.cln == fs_info->fat.vol.rdir_cl) &&
2034e2c: c2 07 60 38 ld [ %i5 + 0x38 ], %g1
2034e30: 80 a7 00 01 cmp %i4, %g1
2034e34: 12 80 00 08 bne 2034e54 <msdos_set_first_char4file_name+0x50><== NEVER TAKEN
2034e38: f8 27 bf f8 st %i4, [ %fp + -8 ]
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))
2034e3c: c2 0f 60 0a ldub [ %i5 + 0xa ], %g1
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) &&
2034e40: 80 88 60 03 btst 3, %g1
2034e44: 22 80 00 05 be,a 2034e58 <msdos_set_first_char4file_name+0x54><== NEVER TAKEN
2034e48: f6 17 60 06 lduh [ %i5 + 6 ], %i3 <== NOT EXECUTED
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))
dir_block_size = fs_info->fat.vol.rdir_size;
2034e4c: 10 80 00 03 b 2034e58 <msdos_set_first_char4file_name+0x54>
2034e50: f6 07 60 28 ld [ %i5 + 0x28 ], %i3
else
dir_block_size = fs_info->fat.vol.bpc;
2034e54: f6 17 60 06 lduh [ %i5 + 6 ], %i3 <== NOT EXECUTED
if (dir_pos->lname.cln == FAT_FILE_SHORT_NAME)
2034e58: c2 06 60 08 ld [ %i1 + 8 ], %g1
2034e5c: 80 a0 7f ff cmp %g1, -1
2034e60: 12 80 00 07 bne 2034e7c <msdos_set_first_char4file_name+0x78>
2034e64: d2 07 bf f0 ld [ %fp + -16 ], %o1
start = dir_pos->sname;
2034e68: c2 06 40 00 ld [ %i1 ], %g1
2034e6c: c2 27 bf f0 st %g1, [ %fp + -16 ]
2034e70: c2 06 60 04 ld [ %i1 + 4 ], %g1
2034e74: c2 27 bf f4 st %g1, [ %fp + -12 ]
* name code was written rather than use the fat_file_write
* interface.
*/
while (true)
{
uint32_t sec = (fat_cluster_num_to_sector_num(&fs_info->fat, start.cln) +
2034e78: d2 07 bf f0 ld [ %fp + -16 ], %o1
2034e7c: 7f ff fe c3 call 2034988 <fat_cluster_num_to_sector_num>
2034e80: 90 10 00 1d mov %i5, %o0
(start.ofs >> fs_info->fat.vol.sec_log2));
2034e84: c2 07 bf f4 ld [ %fp + -12 ], %g1
2034e88: d2 0f 60 02 ldub [ %i5 + 2 ], %o1
uint32_t byte = (start.ofs & (fs_info->fat.vol.bps - 1));
2034e8c: d4 17 40 00 lduh [ %i5 ], %o2
* interface.
*/
while (true)
{
uint32_t sec = (fat_cluster_num_to_sector_num(&fs_info->fat, start.cln) +
(start.ofs >> fs_info->fat.vol.sec_log2));
2034e90: 93 30 40 09 srl %g1, %o1, %o1
uint32_t byte = (start.ofs & (fs_info->fat.vol.bps - 1));
2034e94: 94 02 bf ff add %o2, -1, %o2
* name code was written rather than use the fat_file_write
* interface.
*/
while (true)
{
uint32_t sec = (fat_cluster_num_to_sector_num(&fs_info->fat, start.cln) +
2034e98: 92 02 00 09 add %o0, %o1, %o1
(start.ofs >> fs_info->fat.vol.sec_log2));
uint32_t byte = (start.ofs & (fs_info->fat.vol.bps - 1));
ret = _fat_block_write(&fs_info->fat, sec, byte + MSDOS_FILE_NAME_OFFSET,
2034e9c: 94 0a 80 01 and %o2, %g1, %o2
2034ea0: 90 10 00 1d mov %i5, %o0
2034ea4: 96 10 20 01 mov 1, %o3
2034ea8: 7f ff c5 8c call 20264d8 <_fat_block_write>
2034eac: 98 07 a0 4c add %fp, 0x4c, %o4
1, &fchar);
if (ret < 0)
2034eb0: 80 a2 20 00 cmp %o0, 0
2034eb4: 06 80 00 1e bl 2034f2c <msdos_set_first_char4file_name+0x128><== NEVER TAKEN
2034eb8: d2 07 bf f0 ld [ %fp + -16 ], %o1
return -1;
if ((start.cln == end.cln) && (start.ofs == end.ofs))
2034ebc: 80 a2 40 1c cmp %o1, %i4
2034ec0: 12 80 00 08 bne 2034ee0 <msdos_set_first_char4file_name+0xdc><== NEVER TAKEN
2034ec4: c2 07 bf f4 ld [ %fp + -12 ], %g1
2034ec8: c4 07 bf fc ld [ %fp + -4 ], %g2
2034ecc: 80 a0 40 02 cmp %g1, %g2
2034ed0: 12 80 00 05 bne 2034ee4 <msdos_set_first_char4file_name+0xe0>
2034ed4: 82 00 60 20 add %g1, 0x20, %g1
return rc;
start.ofs = 0;
}
}
return RC_OK;
2034ed8: 81 c7 e0 08 ret
2034edc: 91 e8 20 00 restore %g0, 0, %o0
return -1;
if ((start.cln == end.cln) && (start.ofs == end.ofs))
break;
start.ofs += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE;
2034ee0: 82 00 60 20 add %g1, 0x20, %g1 <== NOT EXECUTED
if (start.ofs >= dir_block_size)
2034ee4: 80 a0 40 1b cmp %g1, %i3
2034ee8: 0a bf ff e4 bcs 2034e78 <msdos_set_first_char4file_name+0x74><== ALWAYS TAKEN
2034eec: c2 27 bf f4 st %g1, [ %fp + -12 ]
{
int rc;
if ((end.cln == fs_info->fat.vol.rdir_cl) &&
2034ef0: c2 07 60 38 ld [ %i5 + 0x38 ], %g1 <== NOT EXECUTED
2034ef4: 80 a7 00 01 cmp %i4, %g1 <== NOT EXECUTED
2034ef8: 12 80 00 06 bne 2034f10 <msdos_set_first_char4file_name+0x10c><== NOT EXECUTED
2034efc: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))
2034f00: c2 0f 60 0a ldub [ %i5 + 0xa ], %g1 <== 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) &&
2034f04: 80 88 60 03 btst 3, %g1 <== NOT EXECUTED
2034f08: 12 bf ff f4 bne 2034ed8 <msdos_set_first_char4file_name+0xd4><== NOT EXECUTED
2034f0c: 01 00 00 00 nop <== NOT EXECUTED
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))
break;
rc = fat_get_fat_cluster(&fs_info->fat, start.cln, &start.cln);
2034f10: 40 00 23 2c call 203dbc0 <fat_get_fat_cluster> <== NOT EXECUTED
2034f14: 94 07 bf f0 add %fp, -16, %o2 <== NOT EXECUTED
if ( rc != RC_OK )
2034f18: b0 92 20 00 orcc %o0, 0, %i0 <== NOT EXECUTED
2034f1c: 12 80 00 05 bne 2034f30 <msdos_set_first_char4file_name+0x12c><== NOT EXECUTED
2034f20: 01 00 00 00 nop <== NOT EXECUTED
return rc;
start.ofs = 0;
2034f24: 10 bf ff d5 b 2034e78 <msdos_set_first_char4file_name+0x74><== NOT EXECUTED
2034f28: c0 27 bf f4 clr [ %fp + -12 ] <== NOT EXECUTED
uint32_t byte = (start.ofs & (fs_info->fat.vol.bps - 1));
ret = _fat_block_write(&fs_info->fat, sec, byte + MSDOS_FILE_NAME_OFFSET,
1, &fchar);
if (ret < 0)
return -1;
2034f2c: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
start.ofs = 0;
}
}
return RC_OK;
}
2034f30: 81 c7 e0 08 ret <== NOT EXECUTED
2034f34: 81 e8 00 00 restore <== NOT EXECUTED
02034cd8 <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
)
{
2034cd8: 9d e3 bf 98 save %sp, -104, %sp
ssize_t ret1 = 0, ret2 = 0;
msdos_fs_info_t *fs_info = mt_entry->fs_info;
2034cdc: fa 06 20 08 ld [ %i0 + 8 ], %i5
/*
* calculate input for _fat_block_write: convert (cluster num, offset) to
* (sector num, new offset)
*/
sec = fat_cluster_num_to_sector_num(&fs_info->fat, fat_fd->dir_pos.sname.cln);
2034ce0: d2 06 60 20 ld [ %i1 + 0x20 ], %o1
)
{
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;
2034ce4: c0 37 bf fc clrh [ %fp + -4 ]
uint16_t le_cl_hi = 0;
2034ce8: c0 37 bf fe clrh [ %fp + -2 ]
/*
* calculate input for _fat_block_write: convert (cluster num, offset) to
* (sector num, new offset)
*/
sec = fat_cluster_num_to_sector_num(&fs_info->fat, fat_fd->dir_pos.sname.cln);
2034cec: 7f ff ff 27 call 2034988 <fat_cluster_num_to_sector_num>
2034cf0: 90 10 00 1d mov %i5, %o0
fat_file_fd_t *fat_fd
)
{
ssize_t ret1 = 0, ret2 = 0;
msdos_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t new_cln = fat_fd->cln;
2034cf4: f8 06 60 1c ld [ %i1 + 0x1c ], %i4
/*
* calculate input for _fat_block_write: convert (cluster num, offset) to
* (sector num, new offset)
*/
sec = fat_cluster_num_to_sector_num(&fs_info->fat, fat_fd->dir_pos.sname.cln);
sec += (fat_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);
2034cf8: c2 06 60 24 ld [ %i1 + 0x24 ], %g1
/* byte from points to start of 32bytes structure */
byte = fat_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1);
2034cfc: f6 17 40 00 lduh [ %i5 ], %i3
/*
* calculate input for _fat_block_write: convert (cluster num, offset) to
* (sector num, new offset)
*/
sec = fat_cluster_num_to_sector_num(&fs_info->fat, fat_fd->dir_pos.sname.cln);
sec += (fat_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);
2034d00: f4 0f 60 02 ldub [ %i5 + 2 ], %i2
/* byte from points to start of 32bytes structure */
byte = fat_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1);
2034d04: b6 06 ff ff add %i3, -1, %i3
/*
* calculate input for _fat_block_write: convert (cluster num, offset) to
* (sector num, new offset)
*/
sec = fat_cluster_num_to_sector_num(&fs_info->fat, fat_fd->dir_pos.sname.cln);
sec += (fat_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);
2034d08: b5 30 40 1a srl %g1, %i2, %i2
/* byte from points to start of 32bytes structure */
byte = fat_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1);
2034d0c: b6 0e c0 01 and %i3, %g1, %i3
rc = msdos_sync_unprotected(fs_info);
rtems_semaphore_release(fs_info->vol_sema);
return rc;
}
2034d10: 33 00 00 3f sethi %hi(0xfc00), %i1
sec = fat_cluster_num_to_sector_num(&fs_info->fat, 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);
le_cl_low = CT_LE_W((uint16_t )(new_cln & 0x0000FFFF));
2034d14: 83 2f 20 10 sll %i4, 0x10, %g1
rc = msdos_sync_unprotected(fs_info);
rtems_semaphore_release(fs_info->vol_sema);
return rc;
}
2034d18: b2 16 63 ff or %i1, 0x3ff, %i1
sec = fat_cluster_num_to_sector_num(&fs_info->fat, 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);
le_cl_low = CT_LE_W((uint16_t )(new_cln & 0x0000FFFF));
2034d1c: 83 30 60 18 srl %g1, 0x18, %g1
rc = msdos_sync_unprotected(fs_info);
rtems_semaphore_release(fs_info->vol_sema);
return rc;
}
2034d20: 84 0f 00 19 and %i4, %i1, %g2
sec = fat_cluster_num_to_sector_num(&fs_info->fat, 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);
le_cl_low = CT_LE_W((uint16_t )(new_cln & 0x0000FFFF));
2034d24: 85 28 a0 08 sll %g2, 8, %g2
2034d28: 82 10 80 01 or %g2, %g1, %g1
/*
* calculate input for _fat_block_write: convert (cluster num, offset) to
* (sector num, new offset)
*/
sec = fat_cluster_num_to_sector_num(&fs_info->fat, fat_fd->dir_pos.sname.cln);
sec += (fat_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);
2034d2c: b4 02 00 1a add %o0, %i2, %i2
/* 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));
2034d30: c2 37 bf fc sth %g1, [ %fp + -4 ]
ret1 = _fat_block_write(&fs_info->fat, sec,
2034d34: 92 10 00 1a mov %i2, %o1
2034d38: 94 06 e0 1a add %i3, 0x1a, %o2
2034d3c: 96 10 20 02 mov 2, %o3
2034d40: 98 07 bf fc add %fp, -4, %o4
2034d44: 7f ff c5 e5 call 20264d8 <_fat_block_write>
2034d48: 90 10 00 1d mov %i5, %o0
byte + MSDOS_FIRST_CLUSTER_LOW_OFFSET, 2,
(char *)(&le_cl_low));
le_cl_hi = CT_LE_W((uint16_t )((new_cln & 0xFFFF0000) >> 16));
2034d4c: b9 37 20 10 srl %i4, 0x10, %i4
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(&fs_info->fat, sec,
2034d50: a0 10 00 08 mov %o0, %l0
rc = msdos_sync_unprotected(fs_info);
rtems_semaphore_release(fs_info->vol_sema);
return rc;
}
2034d54: b2 0f 00 19 and %i4, %i1, %i1
le_cl_low = CT_LE_W((uint16_t )(new_cln & 0x0000FFFF));
ret1 = _fat_block_write(&fs_info->fat, sec,
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(&fs_info->fat, sec,
2034d58: 90 10 00 1d mov %i5, %o0
le_cl_low = CT_LE_W((uint16_t )(new_cln & 0x0000FFFF));
ret1 = _fat_block_write(&fs_info->fat, sec,
byte + MSDOS_FIRST_CLUSTER_LOW_OFFSET, 2,
(char *)(&le_cl_low));
le_cl_hi = CT_LE_W((uint16_t )((new_cln & 0xFFFF0000) >> 16));
2034d5c: b3 2e 60 08 sll %i1, 8, %i1
2034d60: b9 37 20 08 srl %i4, 8, %i4
ret2 = _fat_block_write(&fs_info->fat, sec,
2034d64: 92 10 00 1a mov %i2, %o1
le_cl_low = CT_LE_W((uint16_t )(new_cln & 0x0000FFFF));
ret1 = _fat_block_write(&fs_info->fat, sec,
byte + MSDOS_FIRST_CLUSTER_LOW_OFFSET, 2,
(char *)(&le_cl_low));
le_cl_hi = CT_LE_W((uint16_t )((new_cln & 0xFFFF0000) >> 16));
2034d68: b8 16 40 1c or %i1, %i4, %i4
ret2 = _fat_block_write(&fs_info->fat, sec,
2034d6c: 94 06 e0 14 add %i3, 0x14, %o2
le_cl_low = CT_LE_W((uint16_t )(new_cln & 0x0000FFFF));
ret1 = _fat_block_write(&fs_info->fat, sec,
byte + MSDOS_FIRST_CLUSTER_LOW_OFFSET, 2,
(char *)(&le_cl_low));
le_cl_hi = CT_LE_W((uint16_t )((new_cln & 0xFFFF0000) >> 16));
2034d70: f8 37 bf fe sth %i4, [ %fp + -2 ]
ret2 = _fat_block_write(&fs_info->fat, sec,
2034d74: 96 10 20 02 mov 2, %o3
2034d78: 7f ff c5 d8 call 20264d8 <_fat_block_write>
2034d7c: 98 07 bf fe add %fp, -2, %o4
byte + MSDOS_FIRST_CLUSTER_HI_OFFSET, 2,
(char *)(&le_cl_hi));
if ( (ret1 < 0) || (ret2 < 0) )
2034d80: 80 a2 20 00 cmp %o0, 0
2034d84: 06 80 00 04 bl 2034d94 <msdos_set_first_cluster_num+0xbc> <== NEVER TAKEN
2034d88: 80 a4 20 00 cmp %l0, 0
2034d8c: 16 80 00 03 bge 2034d98 <msdos_set_first_cluster_num+0xc0><== ALWAYS TAKEN
2034d90: b0 10 20 00 clr %i0
return -1;
2034d94: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
return RC_OK;
}
2034d98: 81 c7 e0 08 ret
2034d9c: 81 e8 00 00 restore
02036164 <msdos_sync>:
int
msdos_sync(rtems_libio_t *iop)
{
2036164: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
2036168: c2 06 20 28 ld [ %i0 + 0x28 ], %g1 <== NOT EXECUTED
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
203616c: 92 10 20 00 clr %o1 <== NOT EXECUTED
int
msdos_sync(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;
2036170: fa 00 60 08 ld [ %g1 + 8 ], %i5 <== NOT EXECUTED
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
2036174: 94 10 20 00 clr %o2 <== NOT EXECUTED
2036178: 7f ff 5c cf call 200d4b4 <rtems_semaphore_obtain> <== NOT EXECUTED
203617c: d0 07 60 90 ld [ %i5 + 0x90 ], %o0 <== NOT EXECUTED
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
2036180: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2036184: 02 80 00 08 be 20361a4 <msdos_sync+0x40> <== NOT EXECUTED
2036188: 01 00 00 00 nop <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
203618c: 40 00 30 18 call 20421ec <__errno> <== NOT EXECUTED
2036190: b0 10 3f ff mov -1, %i0 ! ffffffff <RAM_END+0xfdbfffff> <== NOT EXECUTED
2036194: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
2036198: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
203619c: 81 c7 e0 08 ret <== NOT EXECUTED
20361a0: 81 e8 00 00 restore <== NOT EXECUTED
rc = msdos_sync_unprotected(fs_info);
20361a4: 7f ff ff e1 call 2036128 <msdos_sync_unprotected> <== NOT EXECUTED
20361a8: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
20361ac: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED
rtems_semaphore_release(fs_info->vol_sema);
20361b0: 7f ff 5d 0b call 200d5dc <rtems_semaphore_release> <== NOT EXECUTED
20361b4: d0 07 60 90 ld [ %i5 + 0x90 ], %o0 <== NOT EXECUTED
return rc;
}
20361b8: 81 c7 e0 08 ret <== NOT EXECUTED
20361bc: 81 e8 00 00 restore <== NOT EXECUTED
02036128 <msdos_sync_unprotected>:
return MSDOS_NAME_NOT_FOUND_ERR;
}
int
msdos_sync_unprotected(msdos_fs_info_t *fs_info)
{
2036128: 9d e3 bf a0 save %sp, -96, %sp
int rc = fat_buf_release(&fs_info->fat);
203612c: 7f ff c0 71 call 20262f0 <fat_buf_release>
2036130: 90 10 00 18 mov %i0, %o0
2036134: ba 10 00 08 mov %o0, %i5
rtems_status_code sc = rtems_bdbuf_syncdev(fs_info->fat.vol.dd);
2036138: 7f ff 42 70 call 2006af8 <rtems_bdbuf_syncdev>
203613c: d0 06 20 58 ld [ %i0 + 0x58 ], %o0
if (sc != RTEMS_SUCCESSFUL) {
2036140: 80 a2 20 00 cmp %o0, 0
2036144: 02 80 00 06 be 203615c <msdos_sync_unprotected+0x34> <== ALWAYS TAKEN
2036148: 01 00 00 00 nop
errno = EIO;
203614c: 40 00 30 28 call 20421ec <__errno> <== NOT EXECUTED
2036150: ba 10 3f ff mov -1, %i5 ! ffffffff <RAM_END+0xfdbfffff> <== NOT EXECUTED
2036154: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
2036158: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
rc = -1;
}
return rc;
}
203615c: 81 c7 e0 08 ret
2036160: 91 e8 00 1d restore %g0, %i5, %o0
020206b8 <msdos_unlock>:
rtems_fatal_error_occurred(0xdeadbeef);
}
}
void msdos_unlock(const rtems_filesystem_mount_table_entry_t *mt_entry)
{
20206b8: 9d e3 bf a0 save %sp, -96, %sp
msdos_fs_info_t *fs_info = mt_entry->fs_info;
rtems_status_code sc = rtems_semaphore_release(fs_info->vol_sema);
20206bc: c2 06 20 08 ld [ %i0 + 8 ], %g1
20206c0: 7f ff b3 c7 call 200d5dc <rtems_semaphore_release>
20206c4: d0 00 60 90 ld [ %g1 + 0x90 ], %o0
if (sc != RTEMS_SUCCESSFUL) {
20206c8: 80 a2 20 00 cmp %o0, 0
20206cc: 02 80 00 04 be 20206dc <msdos_unlock+0x24> <== ALWAYS TAKEN
20206d0: 11 37 ab 6f sethi %hi(0xdeadbc00), %o0
rtems_fatal_error_occurred(0xdeadbeef);
20206d4: 7f ff b5 87 call 200dcf0 <rtems_fatal_error_occurred> <== NOT EXECUTED
20206d8: 90 12 22 ef or %o0, 0x2ef, %o0 ! deadbeef <RAM_END+0xdc6dbeef><== NOT EXECUTED
20206dc: 81 c7 e0 08 ret
20206e0: 81 e8 00 00 restore
02004358 <newlib_delete_hook>:
void newlib_delete_hook(
rtems_tcb *current_task,
rtems_tcb *deleted_task
)
{
2004358: 9d e3 bf a0 save %sp, -96, %sp
/*
* The reentrancy structure was allocated by newlib using malloc()
*/
if (current_task == deleted_task) {
ptr = _REENT;
200435c: 03 00 80 74 sethi %hi(0x201d000), %g1
/*
* The reentrancy structure was allocated by newlib using malloc()
*/
if (current_task == deleted_task) {
2004360: 80 a6 00 19 cmp %i0, %i1
2004364: 02 80 00 03 be 2004370 <newlib_delete_hook+0x18>
2004368: fa 00 60 68 ld [ %g1 + 0x68 ], %i5
ptr = _REENT;
} else {
ptr = deleted_task->libc_reent;
200436c: fa 06 61 54 ld [ %i1 + 0x154 ], %i5
}
if (ptr && ptr != _global_impure_ptr) {
2004370: 80 a7 60 00 cmp %i5, 0
2004374: 02 80 00 0b be 20043a0 <newlib_delete_hook+0x48> <== NEVER TAKEN
2004378: 03 00 80 70 sethi %hi(0x201c000), %g1
200437c: c2 00 62 68 ld [ %g1 + 0x268 ], %g1 ! 201c268 <_global_impure_ptr>
2004380: 80 a7 40 01 cmp %i5, %g1
2004384: 02 80 00 07 be 20043a0 <newlib_delete_hook+0x48>
2004388: 13 00 80 10 sethi %hi(0x2004000), %o1
_reclaim_reent(ptr);
*/
/*
* Just in case there are some buffers lying around.
*/
_fwalk(ptr, newlib_free_buffers);
200438c: 90 10 00 1d mov %i5, %o0
2004390: 40 00 2f a3 call 201021c <_fwalk>
2004394: 92 12 61 4c or %o1, 0x14c, %o1
#if REENT_MALLOCED
free(ptr);
#else
_Workspace_Free(ptr);
2004398: 40 00 1b a0 call 200b218 <_Workspace_Free>
200439c: 90 10 00 1d mov %i5, %o0
/*
* Require the switch back to another task to install its own
*/
if ( current_task == deleted_task ) {
20043a0: 80 a6 00 19 cmp %i0, %i1
20043a4: 12 80 00 04 bne 20043b4 <newlib_delete_hook+0x5c>
20043a8: c0 26 61 54 clr [ %i1 + 0x154 ]
_REENT = 0;
20043ac: 03 00 80 74 sethi %hi(0x201d000), %g1
20043b0: c0 20 60 68 clr [ %g1 + 0x68 ] ! 201d068 <_impure_ptr>
20043b4: 81 c7 e0 08 ret
20043b8: 81 e8 00 00 restore
0200414c <newlib_free_buffers>:
*/
int newlib_free_buffers(
FILE *fp
)
{
200414c: 9d e3 bf a0 save %sp, -96, %sp
switch ( fileno(fp) ) {
2004150: 40 00 2f 42 call 200fe58 <fileno>
2004154: 90 10 00 18 mov %i0, %o0
2004158: 80 a2 20 02 cmp %o0, 2
200415c: 18 80 00 0e bgu 2004194 <newlib_free_buffers+0x48> <== NEVER TAKEN
2004160: 01 00 00 00 nop
case 0:
case 1:
case 2:
if (fp->_flags & __SMBF) {
2004164: c2 16 20 0c lduh [ %i0 + 0xc ], %g1
2004168: 80 88 60 80 btst 0x80, %g1
200416c: 02 80 00 0c be 200419c <newlib_free_buffers+0x50> <== ALWAYS TAKEN
2004170: 01 00 00 00 nop
free( fp->_bf._base );
2004174: 7f ff fd 9a call 20037dc <free> <== NOT EXECUTED
2004178: d0 06 20 10 ld [ %i0 + 0x10 ], %o0 <== NOT EXECUTED
fp->_flags &= ~__SMBF;
200417c: c2 16 20 0c lduh [ %i0 + 0xc ], %g1 <== NOT EXECUTED
fp->_bf._base = fp->_p = (unsigned char *) NULL;
2004180: c0 26 00 00 clr [ %i0 ] <== NOT EXECUTED
case 0:
case 1:
case 2:
if (fp->_flags & __SMBF) {
free( fp->_bf._base );
fp->_flags &= ~__SMBF;
2004184: 82 08 7f 7f and %g1, -129, %g1 <== NOT EXECUTED
fp->_bf._base = fp->_p = (unsigned char *) NULL;
2004188: c0 26 20 10 clr [ %i0 + 0x10 ] <== NOT EXECUTED
case 0:
case 1:
case 2:
if (fp->_flags & __SMBF) {
free( fp->_bf._base );
fp->_flags &= ~__SMBF;
200418c: 10 80 00 04 b 200419c <newlib_free_buffers+0x50> <== NOT EXECUTED
2004190: c2 36 20 0c sth %g1, [ %i0 + 0xc ] <== NOT EXECUTED
fp->_bf._base = fp->_p = (unsigned char *) NULL;
}
break;
default:
fclose(fp);
2004194: 40 00 2e 71 call 200fb58 <fclose> <== NOT EXECUTED
2004198: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
}
return 0;
}
200419c: 81 c7 e0 08 ret
20041a0: 91 e8 20 00 restore %g0, 0, %o0
02001ca8 <notify>:
}
void
notify (s)
char *s;
{
2001ca8: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED
printf ("%s test appears to be inconsistent...\n", s);
2001cac: 11 00 80 8b sethi %hi(0x2022c00), %o0 <== NOT EXECUTED
2001cb0: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
2001cb4: 90 12 22 20 or %o0, 0x220, %o0 <== NOT EXECUTED
2001cb8: 40 00 59 4e call 20181f0 <printf> <== NOT EXECUTED
2001cbc: 31 00 80 8b sethi %hi(0x2022c00), %i0 <== NOT EXECUTED
printf (" PLEASE NOTIFY KARPINKSI!\n");
2001cc0: 40 00 59 8d call 20182f4 <puts> <== NOT EXECUTED
2001cc4: 91 ee 22 48 restore %i0, 0x248, %o0 <== NOT EXECUTED
02006ea0 <null_op_fsmount_me>:
rtems_filesystem_mount_table_entry_t *mt_entry,
const void *data
)
{
return -1;
}
2006ea0: 81 c3 e0 08 retl <== NOT EXECUTED
2006ea4: 90 10 3f ff mov -1, %o0 <== NOT EXECUTED
02006eb0 <null_op_fsunmount_me>:
static void null_op_fsunmount_me(
rtems_filesystem_mount_table_entry_t *mt_entry
)
{
2006eb0: 81 c3 e0 08 retl <== NOT EXECUTED
02006e78 <null_op_link>:
const char *name,
size_t namelen
)
{
return -1;
}
2006e78: 81 c3 e0 08 retl <== NOT EXECUTED
2006e7c: 90 10 3f ff mov -1, %o0 <== NOT EXECUTED
02006e98 <null_op_mount>:
static int null_op_mount(
rtems_filesystem_mount_table_entry_t *mt_entry
)
{
return -1;
}
2006e98: 81 c3 e0 08 retl <== NOT EXECUTED
2006e9c: 90 10 3f ff mov -1, %o0 <== NOT EXECUTED
02006ec8 <null_op_readlink>:
char *buf,
size_t bufsize
)
{
return -1;
}
2006ec8: 81 c3 e0 08 retl <== NOT EXECUTED
2006ecc: 90 10 3f ff mov -1, %o0 <== NOT EXECUTED
02006ed0 <null_op_rename>:
const char *name,
size_t namelen
)
{
return -1;
}
2006ed0: 81 c3 e0 08 retl <== NOT EXECUTED
2006ed4: 90 10 3f ff mov -1, %o0 <== NOT EXECUTED
02005f88 <oproc>:
/*
* Handle output processing
*/
static void
oproc (unsigned char c, struct rtems_termios_tty *tty)
{
2005f88: 9d e3 bf a0 save %sp, -96, %sp
int i;
if (tty->termios.c_oflag & OPOST) {
2005f8c: c2 06 60 34 ld [ %i1 + 0x34 ], %g1
2005f90: 80 88 60 01 btst 1, %g1
2005f94: 02 80 00 56 be 20060ec <oproc+0x164> <== NEVER TAKEN
2005f98: f0 2f a0 44 stb %i0, [ %fp + 0x44 ]
switch (c) {
2005f9c: 84 0e 20 ff and %i0, 0xff, %g2
2005fa0: 80 a0 a0 09 cmp %g2, 9
2005fa4: 22 80 00 2a be,a 200604c <oproc+0xc4>
2005fa8: c4 06 60 28 ld [ %i1 + 0x28 ], %g2
2005fac: 18 80 00 07 bgu 2005fc8 <oproc+0x40> <== ALWAYS TAKEN
2005fb0: 80 a0 a0 0a cmp %g2, 0xa
2005fb4: 80 a0 a0 08 cmp %g2, 8 <== NOT EXECUTED
2005fb8: 12 80 00 36 bne 2006090 <oproc+0x108> <== NOT EXECUTED
2005fbc: 80 88 60 02 btst 2, %g1 <== NOT EXECUTED
}
tty->column += i;
break;
case '\b':
if (tty->column > 0)
2005fc0: 10 80 00 2f b 200607c <oproc+0xf4> <== NOT EXECUTED
2005fc4: c2 06 60 28 ld [ %i1 + 0x28 ], %g1 <== NOT EXECUTED
oproc (unsigned char c, struct rtems_termios_tty *tty)
{
int i;
if (tty->termios.c_oflag & OPOST) {
switch (c) {
2005fc8: 02 80 00 06 be 2005fe0 <oproc+0x58>
2005fcc: 80 a0 a0 0d cmp %g2, 0xd
2005fd0: 32 80 00 30 bne,a 2006090 <oproc+0x108> <== ALWAYS TAKEN
2005fd4: 80 88 60 02 btst 2, %g1
tty->column = 0;
}
break;
case '\r':
if ((tty->termios.c_oflag & ONOCR) && (tty->column == 0))
2005fd8: 10 80 00 0f b 2006014 <oproc+0x8c> <== NOT EXECUTED
2005fdc: 80 88 60 10 btst 0x10, %g1 <== NOT EXECUTED
int i;
if (tty->termios.c_oflag & OPOST) {
switch (c) {
case '\n':
if (tty->termios.c_oflag & ONLRET)
2005fe0: 80 88 60 20 btst 0x20, %g1
2005fe4: 32 80 00 02 bne,a 2005fec <oproc+0x64> <== NEVER TAKEN
2005fe8: c0 26 60 28 clr [ %i1 + 0x28 ] <== NOT EXECUTED
tty->column = 0;
if (tty->termios.c_oflag & ONLCR) {
2005fec: 80 88 60 04 btst 4, %g1
2005ff0: 02 80 00 40 be 20060f0 <oproc+0x168> <== NEVER TAKEN
2005ff4: 90 07 a0 44 add %fp, 0x44, %o0
rtems_termios_puts ("\r", 1, tty);
2005ff8: 11 00 80 6d sethi %hi(0x201b400), %o0
2005ffc: 92 10 20 01 mov 1, %o1
2006000: 90 12 23 60 or %o0, 0x360, %o0
2006004: 7f ff ff 98 call 2005e64 <rtems_termios_puts>
2006008: 94 10 00 19 mov %i1, %o2
c = '\n';
if (tty->termios.c_oflag & ONLRET)
tty->column = 0;
break;
}
tty->column = 0;
200600c: 10 80 00 38 b 20060ec <oproc+0x164>
2006010: c0 26 60 28 clr [ %i1 + 0x28 ]
tty->column = 0;
}
break;
case '\r':
if ((tty->termios.c_oflag & ONOCR) && (tty->column == 0))
2006014: 02 80 00 06 be 200602c <oproc+0xa4> <== NOT EXECUTED
2006018: 80 88 60 08 btst 8, %g1 <== NOT EXECUTED
200601c: c4 06 60 28 ld [ %i1 + 0x28 ], %g2 <== NOT EXECUTED
2006020: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED
2006024: 02 80 00 36 be 20060fc <oproc+0x174> <== NOT EXECUTED
2006028: 80 88 60 08 btst 8, %g1 <== NOT EXECUTED
return;
if (tty->termios.c_oflag & OCRNL) {
200602c: 22 80 00 30 be,a 20060ec <oproc+0x164> <== NOT EXECUTED
2006030: c0 26 60 28 clr [ %i1 + 0x28 ] <== NOT EXECUTED
c = '\n';
2006034: 84 10 20 0a mov 0xa, %g2 <== NOT EXECUTED
if (tty->termios.c_oflag & ONLRET)
2006038: 80 88 60 20 btst 0x20, %g1 <== NOT EXECUTED
200603c: 02 80 00 2c be 20060ec <oproc+0x164> <== NOT EXECUTED
2006040: c4 2f a0 44 stb %g2, [ %fp + 0x44 ] <== NOT EXECUTED
tty->column = 0;
break;
}
tty->column = 0;
break;
2006044: 10 80 00 2a b 20060ec <oproc+0x164> <== NOT EXECUTED
2006048: c0 26 60 28 clr [ %i1 + 0x28 ] <== NOT EXECUTED
case '\t':
i = 8 - (tty->column & 7);
200604c: 92 10 20 08 mov 8, %o1
2006050: 86 08 a0 07 and %g2, 7, %g3
2006054: 92 22 40 03 sub %o1, %g3, %o1
if ((tty->termios.c_oflag & TABDLY) == XTABS) {
2006058: 07 00 00 06 sethi %hi(0x1800), %g3
200605c: 82 08 40 03 and %g1, %g3, %g1
2006060: 80 a0 40 03 cmp %g1, %g3
2006064: 82 00 80 09 add %g2, %o1, %g1
2006068: 12 80 00 21 bne 20060ec <oproc+0x164> <== NEVER TAKEN
200606c: c2 26 60 28 st %g1, [ %i1 + 0x28 ]
tty->column += i;
rtems_termios_puts ( " ", i, tty);
2006070: 11 00 80 6d sethi %hi(0x201b400), %o0
2006074: 10 80 00 20 b 20060f4 <oproc+0x16c>
2006078: 90 12 23 68 or %o0, 0x368, %o0 ! 201b768 <rtems_filesystem_default_pathconf+0x5c>
}
tty->column += i;
break;
case '\b':
if (tty->column > 0)
200607c: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
2006080: 04 80 00 1b ble 20060ec <oproc+0x164> <== NOT EXECUTED
2006084: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED
default:
if (tty->termios.c_oflag & OLCUC)
c = toupper(c);
if (!iscntrl(c))
tty->column++;
2006088: 10 80 00 19 b 20060ec <oproc+0x164> <== NOT EXECUTED
200608c: c2 26 60 28 st %g1, [ %i1 + 0x28 ] <== NOT EXECUTED
if (tty->column > 0)
tty->column--;
break;
default:
if (tty->termios.c_oflag & OLCUC)
2006090: 02 80 00 0d be 20060c4 <oproc+0x13c> <== ALWAYS TAKEN
2006094: c2 0f a0 44 ldub [ %fp + 0x44 ], %g1
c = toupper(c);
2006098: 03 00 80 74 sethi %hi(0x201d000), %g1 <== NOT EXECUTED
200609c: c2 00 60 60 ld [ %g1 + 0x60 ], %g1 ! 201d060 <__ctype_ptr__><== NOT EXECUTED
20060a0: b0 0e 20 ff and %i0, 0xff, %i0 <== NOT EXECUTED
20060a4: 82 00 40 18 add %g1, %i0, %g1 <== NOT EXECUTED
20060a8: c2 08 60 01 ldub [ %g1 + 1 ], %g1 <== NOT EXECUTED
20060ac: 82 08 60 03 and %g1, 3, %g1 <== NOT EXECUTED
20060b0: 80 a0 60 02 cmp %g1, 2 <== NOT EXECUTED
20060b4: 22 80 00 02 be,a 20060bc <oproc+0x134> <== NOT EXECUTED
20060b8: b0 06 3f e0 add %i0, -32, %i0 <== NOT EXECUTED
20060bc: f0 2f a0 44 stb %i0, [ %fp + 0x44 ] <== NOT EXECUTED
if (!iscntrl(c))
20060c0: c2 0f a0 44 ldub [ %fp + 0x44 ], %g1 <== NOT EXECUTED
20060c4: 05 00 80 74 sethi %hi(0x201d000), %g2
20060c8: c4 00 a0 60 ld [ %g2 + 0x60 ], %g2 ! 201d060 <__ctype_ptr__>
20060cc: 82 00 80 01 add %g2, %g1, %g1
20060d0: c2 08 60 01 ldub [ %g1 + 1 ], %g1
20060d4: 80 88 60 20 btst 0x20, %g1
20060d8: 12 80 00 06 bne 20060f0 <oproc+0x168> <== NEVER TAKEN
20060dc: 90 07 a0 44 add %fp, 0x44, %o0
tty->column++;
20060e0: c2 06 60 28 ld [ %i1 + 0x28 ], %g1
20060e4: 82 00 60 01 inc %g1
20060e8: c2 26 60 28 st %g1, [ %i1 + 0x28 ]
break;
}
}
rtems_termios_puts (&c, 1, tty);
20060ec: 90 07 a0 44 add %fp, 0x44, %o0
20060f0: 92 10 20 01 mov 1, %o1
20060f4: 7f ff ff 5c call 2005e64 <rtems_termios_puts>
20060f8: 94 10 00 19 mov %i1, %o2
20060fc: 81 c7 e0 08 ret
2006100: 81 e8 00 00 restore
02004a54 <partition_free>:
* RETURNS:
* N/A
*/
static void
partition_free(rtems_part_desc_t *part_desc)
{
2004a54: 9d e3 bf a0 save %sp, -96, %sp
int part_num;
if (part_desc == NULL)
2004a58: 80 a6 20 00 cmp %i0, 0
2004a5c: 02 80 00 11 be 2004aa0 <partition_free+0x4c>
2004a60: 01 00 00 00 nop
* true if partition type is extended, false otherwise
*/
static bool
is_extended(uint8_t type)
{
return ((type == EXTENDED_PARTITION) || (type == LINUX_EXTENDED));
2004a64: c2 0e 20 01 ldub [ %i0 + 1 ], %g1
int part_num;
if (part_desc == NULL)
return;
if (is_extended(part_desc->sys_type))
2004a68: 82 08 60 7f and %g1, 0x7f, %g1
2004a6c: 80 a0 60 05 cmp %g1, 5
2004a70: 22 80 00 04 be,a 2004a80 <partition_free+0x2c> <== NEVER TAKEN
2004a74: ba 10 20 00 clr %i5 <== NOT EXECUTED
{
partition_free(part_desc->sub_part[part_num]);
}
}
free(part_desc);
2004a78: 40 00 04 0f call 2005ab4 <free>
2004a7c: 81 e8 00 00 restore
*
* RETURNS:
* N/A
*/
static void
partition_free(rtems_part_desc_t *part_desc)
2004a80: 82 06 00 1d add %i0, %i5, %g1 <== NOT EXECUTED
{
for (part_num = 0;
part_num < RTEMS_IDE_PARTITION_MAX_SUB_PARTITION_NUMBER;
part_num++)
{
partition_free(part_desc->sub_part[part_num]);
2004a84: d0 00 60 18 ld [ %g1 + 0x18 ], %o0 <== NOT EXECUTED
2004a88: 7f ff ff f3 call 2004a54 <partition_free> <== NOT EXECUTED
2004a8c: ba 07 60 04 add %i5, 4, %i5 <== NOT EXECUTED
if (part_desc == NULL)
return;
if (is_extended(part_desc->sys_type))
{
for (part_num = 0;
2004a90: 80 a7 60 10 cmp %i5, 0x10 <== NOT EXECUTED
2004a94: 12 bf ff fc bne 2004a84 <partition_free+0x30> <== NOT EXECUTED
2004a98: 82 06 00 1d add %i0, %i5, %g1 <== NOT EXECUTED
2004a9c: 30 bf ff f7 b,a 2004a78 <partition_free+0x24> <== NOT EXECUTED
2004aa0: 81 c7 e0 08 ret
2004aa4: 81 e8 00 00 restore
02004d8c <partition_table_get>:
* RTEMS_SUCCESSFUL if success,
* RTEMS_INTERNAL_ERROR otherwise
*/
static rtems_status_code
partition_table_get(const char *dev_name, rtems_disk_desc_t *disk_desc)
{
2004d8c: 9d e3 bf 50 save %sp, -176, %sp
struct stat dev_stat;
rtems_status_code rc;
int fd;
fd = open(dev_name, O_RDONLY);
2004d90: 92 10 20 00 clr %o1
2004d94: 90 10 00 18 mov %i0, %o0
2004d98: 40 00 07 19 call 20069fc <open>
2004d9c: ba 10 20 19 mov 0x19, %i5
if (fd < 0)
2004da0: 80 a2 20 00 cmp %o0, 0
2004da4: 06 80 00 6d bl 2004f58 <partition_table_get+0x1cc> <== NEVER TAKEN
2004da8: b8 10 00 08 mov %o0, %i4
{
return RTEMS_INTERNAL_ERROR;
}
rc = fstat(fd, &dev_stat);
2004dac: 40 00 03 6c call 2005b5c <fstat>
2004db0: 92 07 bf b8 add %fp, -72, %o1
if (rc != RTEMS_SUCCESSFUL)
2004db4: 80 a2 20 00 cmp %o0, 0
2004db8: 12 80 00 66 bne 2004f50 <partition_table_get+0x1c4> <== NEVER TAKEN
2004dbc: 90 06 60 08 add %i1, 8, %o0
{
close(fd);
return RTEMS_INTERNAL_ERROR;
}
strncpy (disk_desc->dev_name, dev_name, 15);
2004dc0: 92 10 00 18 mov %i0, %o1
2004dc4: 40 00 47 2c call 2016a74 <strncpy>
2004dc8: 94 10 20 0f mov 0xf, %o2
disk_desc->dev = dev_stat.st_rdev;
2004dcc: c4 1f bf d0 ldd [ %fp + -48 ], %g2
2004dd0: c4 3e 40 00 std %g2, [ %i1 ]
disk_desc->sector_size = (dev_stat.st_blksize) ? dev_stat.st_blksize :
2004dd4: c4 07 bf f8 ld [ %fp + -8 ], %g2
2004dd8: 80 a0 a0 00 cmp %g2, 0
2004ddc: 02 80 00 03 be 2004de8 <partition_table_get+0x5c> <== ALWAYS TAKEN
2004de0: 82 10 22 00 mov 0x200, %g1
2004de4: 82 10 00 02 mov %g2, %g1 <== NOT EXECUTED
2004de8: c2 26 60 18 st %g1, [ %i1 + 0x18 ]
*/
static rtems_status_code
read_mbr(int fd, rtems_disk_desc_t *disk_desc)
{
int part_num;
rtems_sector_data_t *sector = NULL;
2004dec: c0 27 bf b0 clr [ %fp + -80 ]
{
return RTEMS_INTERNAL_ERROR;
}
off = sector_num * RTEMS_IDE_SECTOR_SIZE;
new_off = lseek(fd, off, SEEK_SET);
2004df0: 90 10 00 1c mov %i4, %o0
2004df4: 92 10 20 00 clr %o1
2004df8: 94 10 20 00 clr %o2
2004dfc: 96 10 20 00 clr %o3
2004e00: 40 00 04 4e call 2005f38 <lseek>
2004e04: ba 10 20 1b mov 0x1b, %i5
if (new_off != off) {
2004e08: 80 92 00 09 orcc %o0, %o1, %g0
2004e0c: 12 80 00 09 bne 2004e30 <partition_table_get+0xa4> <== NEVER TAKEN
2004e10: d0 07 bf b0 ld [ %fp + -80 ], %o0
2004e14: 90 10 00 1c mov %i4, %o0
2004e18: 92 10 20 00 clr %o1
2004e1c: 7f ff ff 2e call 2004ad4 <get_sector.part.0>
2004e20: 94 07 bf b0 add %fp, -80, %o2
uint8_t *data;
rtems_status_code rc;
/* get MBR sector */
rc = get_sector(fd, 0, §or);
if (rc != RTEMS_SUCCESSFUL)
2004e24: ba 92 20 00 orcc %o0, 0, %i5
2004e28: 02 80 00 06 be 2004e40 <partition_table_get+0xb4> <== ALWAYS TAKEN
2004e2c: d0 07 bf b0 ld [ %fp + -80 ], %o0
{
if (sector)
2004e30: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2004e34: 02 80 00 47 be 2004f50 <partition_table_get+0x1c4> <== NOT EXECUTED
2004e38: 01 00 00 00 nop <== NOT EXECUTED
2004e3c: 30 80 00 19 b,a 2004ea0 <partition_table_get+0x114> <== NOT EXECUTED
static bool
msdos_signature_check (rtems_sector_data_t *sector)
{
uint8_t *p = sector->data + RTEMS_IDE_PARTITION_MSDOS_SIGNATURE_OFFSET;
return ((p[0] == RTEMS_IDE_PARTITION_MSDOS_SIGNATURE_DATA1) &&
2004e40: c4 0a 22 02 ldub [ %o0 + 0x202 ], %g2
2004e44: 80 a0 a0 55 cmp %g2, 0x55
2004e48: 12 80 00 06 bne 2004e60 <partition_table_get+0xd4> <== NEVER TAKEN
2004e4c: 82 10 20 00 clr %g1
2004e50: c2 0a 22 03 ldub [ %o0 + 0x203 ], %g1
2004e54: 82 18 60 aa xor %g1, 0xaa, %g1
2004e58: 80 a0 00 01 cmp %g0, %g1
2004e5c: 82 60 3f ff subx %g0, -1, %g1
free(sector);
return rc;
}
/* check if the partition table structure is MS-DOS style */
if (!msdos_signature_check(sector))
2004e60: 80 a0 60 00 cmp %g1, 0
2004e64: 32 80 00 05 bne,a 2004e78 <partition_table_get+0xec> <== ALWAYS TAKEN
2004e68: b0 02 21 c2 add %o0, 0x1c2, %i0
{
free(sector);
2004e6c: 40 00 03 12 call 2005ab4 <free> <== NOT EXECUTED
2004e70: ba 10 20 19 mov 0x19, %i5 <== NOT EXECUTED
2004e74: 30 80 00 37 b,a 2004f50 <partition_table_get+0x1c4> <== NOT EXECUTED
2004e78: b4 10 00 19 mov %i1, %i2
/* read and process 4 primary partition descriptors */
data = sector->data + RTEMS_IDE_PARTITION_TABLE_OFFSET;
for (part_num = 0;
2004e7c: b6 10 20 00 clr %i3
* RETURNS:
* RTEMS_SUCCESSFUL if success,
* RTEMS_INTERNAL_ERROR otherwise
*/
static rtems_status_code
partition_table_get(const char *dev_name, rtems_disk_desc_t *disk_desc)
2004e80: 91 2e e0 04 sll %i3, 4, %o0
2004e84: 92 07 bf b4 add %fp, -76, %o1
2004e88: 7f ff ff 29 call 2004b2c <data_to_part_desc.part.1>
2004e8c: 90 06 00 08 add %i0, %o0, %o0
for (part_num = 0;
part_num < RTEMS_IDE_PARTITION_MAX_SUB_PARTITION_NUMBER;
part_num++)
{
rc = data_to_part_desc(data, &part_desc);
if (rc != RTEMS_SUCCESSFUL)
2004e90: ba 92 20 00 orcc %o0, 0, %i5
2004e94: 02 80 00 06 be 2004eac <partition_table_get+0x120> <== ALWAYS TAKEN
2004e98: c2 07 bf b4 ld [ %fp + -76 ], %g1
{
free(sector);
2004e9c: d0 07 bf b0 ld [ %fp + -80 ], %o0 <== NOT EXECUTED
2004ea0: 40 00 03 05 call 2005ab4 <free> <== NOT EXECUTED
2004ea4: 01 00 00 00 nop <== NOT EXECUTED
2004ea8: 30 80 00 2a b,a 2004f50 <partition_table_get+0x1c4> <== NOT EXECUTED
return rc;
}
if (part_desc != NULL)
2004eac: 80 a0 60 00 cmp %g1, 0
2004eb0: 02 80 00 0b be 2004edc <partition_table_get+0x150> <== NEVER TAKEN
2004eb4: 84 06 e0 01 add %i3, 1, %g2
{
part_desc->log_id = part_num + 1;
part_desc->disk_desc = disk_desc;
part_desc->end = part_desc->start + part_desc->size - 1;
2004eb8: c6 00 60 04 ld [ %g1 + 4 ], %g3
return rc;
}
if (part_desc != NULL)
{
part_desc->log_id = part_num + 1;
2004ebc: c4 28 60 02 stb %g2, [ %g1 + 2 ]
part_desc->disk_desc = disk_desc;
part_desc->end = part_desc->start + part_desc->size - 1;
2004ec0: c4 00 60 08 ld [ %g1 + 8 ], %g2
}
if (part_desc != NULL)
{
part_desc->log_id = part_num + 1;
part_desc->disk_desc = disk_desc;
2004ec4: f2 20 60 10 st %i1, [ %g1 + 0x10 ]
part_desc->end = part_desc->start + part_desc->size - 1;
2004ec8: 84 00 c0 02 add %g3, %g2, %g2
2004ecc: 84 00 bf ff add %g2, -1, %g2
2004ed0: c4 20 60 0c st %g2, [ %g1 + 0xc ]
disk_desc->partitions[part_num] = part_desc;
2004ed4: 10 80 00 03 b 2004ee0 <partition_table_get+0x154>
2004ed8: c2 26 a0 28 st %g1, [ %i2 + 0x28 ]
}
else
{
disk_desc->partitions[part_num] = NULL;
2004edc: c0 26 a0 28 clr [ %i2 + 0x28 ] <== NOT EXECUTED
data = sector->data + RTEMS_IDE_PARTITION_TABLE_OFFSET;
for (part_num = 0;
part_num < RTEMS_IDE_PARTITION_MAX_SUB_PARTITION_NUMBER;
part_num++)
2004ee0: b6 06 e0 01 inc %i3
/* read and process 4 primary partition descriptors */
data = sector->data + RTEMS_IDE_PARTITION_TABLE_OFFSET;
for (part_num = 0;
2004ee4: 80 a6 e0 04 cmp %i3, 4
2004ee8: 12 bf ff e6 bne 2004e80 <partition_table_get+0xf4>
2004eec: b4 06 a0 04 add %i2, 4, %i2
}
data += RTEMS_IDE_PARTITION_DESCRIPTOR_SIZE;
}
free(sector);
2004ef0: 40 00 02 f1 call 2005ab4 <free>
2004ef4: d0 07 bf b0 ld [ %fp + -80 ], %o0
disk_desc->last_log_id = RTEMS_IDE_PARTITION_MAX_SUB_PARTITION_NUMBER;
2004ef8: f6 26 60 24 st %i3, [ %i1 + 0x24 ]
2004efc: b6 10 20 00 clr %i3
* RETURNS:
* RTEMS_SUCCESSFUL if success,
* RTEMS_INTERNAL_ERROR otherwise
*/
static rtems_status_code
partition_table_get(const char *dev_name, rtems_disk_desc_t *disk_desc)
2004f00: b4 06 40 1b add %i1, %i3, %i2
but we are to process each primary partition */
for (part_num = 0;
part_num < RTEMS_IDE_PARTITION_MAX_SUB_PARTITION_NUMBER;
part_num++)
{
part_desc = disk_desc->partitions[part_num];
2004f04: d4 06 a0 28 ld [ %i2 + 0x28 ], %o2
if (part_desc != NULL && is_extended(part_desc->sys_type))
2004f08: 80 a2 a0 00 cmp %o2, 0
2004f0c: 02 80 00 0d be 2004f40 <partition_table_get+0x1b4> <== NEVER TAKEN
2004f10: d4 27 bf b4 st %o2, [ %fp + -76 ]
* true if partition type is extended, false otherwise
*/
static bool
is_extended(uint8_t type)
{
return ((type == EXTENDED_PARTITION) || (type == LINUX_EXTENDED));
2004f14: c2 0a a0 01 ldub [ %o2 + 1 ], %g1
for (part_num = 0;
part_num < RTEMS_IDE_PARTITION_MAX_SUB_PARTITION_NUMBER;
part_num++)
{
part_desc = disk_desc->partitions[part_num];
if (part_desc != NULL && is_extended(part_desc->sys_type))
2004f18: 82 08 60 7f and %g1, 0x7f, %g1
2004f1c: 80 a0 60 05 cmp %g1, 5
2004f20: 32 80 00 09 bne,a 2004f44 <partition_table_get+0x1b8>
2004f24: b6 06 e0 04 add %i3, 4, %i3
{
read_extended_partition(fd, part_desc->start, part_desc);
2004f28: d2 02 a0 04 ld [ %o2 + 4 ], %o1
2004f2c: 7f ff ff 31 call 2004bf0 <read_extended_partition>
2004f30: 90 10 00 1c mov %i4, %o0
free(part_desc);
2004f34: 40 00 02 e0 call 2005ab4 <free>
2004f38: d0 07 bf b4 ld [ %fp + -76 ], %o0
disk_desc->partitions[part_num] = NULL;
2004f3c: c0 26 a0 28 clr [ %i2 + 0x28 ]
2004f40: b6 06 e0 04 add %i3, 4, %i3
disk_desc->last_log_id = RTEMS_IDE_PARTITION_MAX_SUB_PARTITION_NUMBER;
/* There cannot be more than one extended partition,
but we are to process each primary partition */
for (part_num = 0;
2004f44: 80 a6 e0 10 cmp %i3, 0x10
2004f48: 12 bf ff ef bne 2004f04 <partition_table_get+0x178>
2004f4c: b4 06 40 1b add %i1, %i3, %i2
disk_desc->sector_size = (dev_stat.st_blksize) ? dev_stat.st_blksize :
RTEMS_IDE_SECTOR_SIZE;
rc = read_mbr(fd, disk_desc);
close(fd);
2004f50: 40 00 02 1b call 20057bc <close>
2004f54: 90 10 00 1c mov %i4, %o0
return rc;
}
2004f58: 81 c7 e0 08 ret
2004f5c: 91 e8 00 1d restore %g0, %i5, %o0
02004808 <pathconf>:
long pathconf(
const char *path,
int name
)
{
2004808: 9d e3 bf a0 save %sp, -96, %sp
int status;
int fd;
fd = open( path, O_RDONLY );
200480c: 92 10 20 00 clr %o1
2004810: 7f ff ff 6f call 20045cc <open>
2004814: 90 10 00 18 mov %i0, %o0
if ( fd == -1 )
2004818: 80 a2 3f ff cmp %o0, -1
200481c: 02 80 00 09 be 2004840 <pathconf+0x38> <== ALWAYS TAKEN
2004820: ba 10 00 08 mov %o0, %i5
return -1;
status = fpathconf( fd, name );
2004824: 40 00 14 62 call 20099ac <fpathconf> <== NOT EXECUTED
2004828: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
200482c: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED
(void) close( fd );
2004830: 40 00 14 32 call 20098f8 <close> <== NOT EXECUTED
2004834: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
return status;
2004838: 81 c7 e0 08 ret <== NOT EXECUTED
200483c: 81 e8 00 00 restore <== NOT EXECUTED
}
2004840: 81 c7 e0 08 ret
2004844: 91 e8 3f ff restore %g0, -1, %o0
0200d0e0 <pipe_create>:
* Called by pipe() to create an anonymous pipe.
*/
int pipe_create(
int filsdes[2]
)
{
200d0e0: 9d e3 bf 90 save %sp, -112, %sp
rtems_libio_t *iop;
int err = 0;
if (rtems_mkdir("/tmp", S_IRWXU | S_IRWXG | S_IRWXO) != 0)
200d0e4: 11 00 80 82 sethi %hi(0x2020800), %o0
200d0e8: 92 10 21 ff mov 0x1ff, %o1
200d0ec: 40 00 05 4e call 200e624 <rtems_mkdir>
200d0f0: 90 12 23 08 or %o0, 0x308, %o0
200d0f4: 80 a2 20 00 cmp %o0, 0
200d0f8: 12 80 00 47 bne 200d214 <pipe_create+0x134>
200d0fc: 03 00 00 19 sethi %hi(0x6400), %g1
return -1;
/* /tmp/.fifoXXXX */
char fifopath[15];
memcpy(fifopath, "/tmp/.fifo", 10);
200d100: 82 10 62 6f or %g1, 0x26f, %g1 ! 666f <PROM_START+0x666f>
200d104: c2 37 bf f8 sth %g1, [ %fp + -8 ]
sprintf(fifopath + 10, "%04x", rtems_pipe_no ++);
200d108: 03 00 80 89 sethi %hi(0x2022400), %g1
200d10c: d4 10 62 c0 lduh [ %g1 + 0x2c0 ], %o2 ! 20226c0 <rtems_pipe_no>
if (rtems_mkdir("/tmp", S_IRWXU | S_IRWXG | S_IRWXO) != 0)
return -1;
/* /tmp/.fifoXXXX */
char fifopath[15];
memcpy(fifopath, "/tmp/.fifo", 10);
200d110: 05 0b dd 1b sethi %hi(0x2f746c00), %g2
200d114: 84 10 a1 70 or %g2, 0x170, %g2 ! 2f746d70 <RAM_END+0x2d346d70>
200d118: 07 0b cb 99 sethi %hi(0x2f2e6400), %g3
200d11c: 86 10 e2 69 or %g3, 0x269, %g3 ! 2f2e6669 <RAM_END+0x2cee6669>
200d120: c4 3f bf f0 std %g2, [ %fp + -16 ]
sprintf(fifopath + 10, "%04x", rtems_pipe_no ++);
200d124: 84 02 a0 01 add %o2, 1, %g2
200d128: 90 07 bf fa add %fp, -6, %o0
200d12c: c4 30 62 c0 sth %g2, [ %g1 + 0x2c0 ]
200d130: 95 2a a0 10 sll %o2, 0x10, %o2
200d134: 13 00 80 82 sethi %hi(0x2020800), %o1
200d138: 95 32 a0 10 srl %o2, 0x10, %o2
200d13c: 40 00 13 d7 call 2012098 <sprintf>
200d140: 92 12 63 10 or %o1, 0x310, %o1
/* Try creating FIFO file until find an available file name */
while (mkfifo(fifopath, S_IRUSR|S_IWUSR) != 0) {
200d144: 90 07 bf f0 add %fp, -16, %o0
200d148: 40 00 04 8d call 200e37c <mkfifo>
200d14c: 92 10 21 80 mov 0x180, %o1
200d150: 80 a2 20 00 cmp %o0, 0
200d154: 02 80 00 05 be 200d168 <pipe_create+0x88> <== ALWAYS TAKEN
200d158: 90 07 bf f0 add %fp, -16, %o0
if (errno != EEXIST){
200d15c: 40 00 10 6e call 2011314 <__errno> <== NOT EXECUTED
200d160: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
200d164: 30 80 00 2d b,a 200d218 <pipe_create+0x138> <== NOT EXECUTED
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);
200d168: 7f ff df 6d call 2004f1c <open>
200d16c: 13 00 00 10 sethi %hi(0x4000), %o1
if (filsdes[0] < 0) {
200d170: 80 a2 20 00 cmp %o0, 0
200d174: 16 80 00 06 bge 200d18c <pipe_create+0xac>
200d178: d0 26 00 00 st %o0, [ %i0 ]
err = errno;
200d17c: 40 00 10 66 call 2011314 <__errno>
200d180: 01 00 00 00 nop
200d184: 10 80 00 1c b 200d1f4 <pipe_create+0x114>
200d188: fa 02 00 00 ld [ %o0 ], %i5
the file node will be deleted after it is closed by all. */
unlink(fifopath);
}
else {
/* Reset open file to blocking mode */
iop = rtems_libio_iop(filsdes[0]);
200d18c: 03 00 80 87 sethi %hi(0x2021c00), %g1
200d190: c4 00 61 f0 ld [ %g1 + 0x1f0 ], %g2 ! 2021df0 <rtems_libio_number_iops>
200d194: 80 a2 00 02 cmp %o0, %g2
200d198: 1a 80 00 08 bcc 200d1b8 <pipe_create+0xd8> <== NEVER TAKEN
200d19c: 82 10 20 00 clr %g1
200d1a0: 83 2a 20 03 sll %o0, 3, %g1
200d1a4: 91 2a 20 06 sll %o0, 6, %o0
200d1a8: 90 22 00 01 sub %o0, %g1, %o0
200d1ac: 03 00 80 8a sethi %hi(0x2022800), %g1
200d1b0: c2 00 61 28 ld [ %g1 + 0x128 ], %g1 ! 2022928 <rtems_libio_iops>
200d1b4: 82 00 40 08 add %g1, %o0, %g1
iop->flags &= ~LIBIO_FLAGS_NO_DELAY;
200d1b8: c4 00 60 10 ld [ %g1 + 0x10 ], %g2
filsdes[1] = open(fifopath, O_WRONLY);
200d1bc: 90 07 bf f0 add %fp, -16, %o0
unlink(fifopath);
}
else {
/* Reset open file to blocking mode */
iop = rtems_libio_iop(filsdes[0]);
iop->flags &= ~LIBIO_FLAGS_NO_DELAY;
200d1c0: 84 08 bf fe and %g2, -2, %g2
filsdes[1] = open(fifopath, O_WRONLY);
200d1c4: 92 10 20 01 mov 1, %o1
200d1c8: 7f ff df 55 call 2004f1c <open>
200d1cc: c4 20 60 10 st %g2, [ %g1 + 0x10 ]
200d1d0: d0 26 20 04 st %o0, [ %i0 + 4 ]
if (filsdes[1] < 0) {
200d1d4: 80 a2 20 00 cmp %o0, 0
200d1d8: 16 80 00 07 bge 200d1f4 <pipe_create+0x114>
200d1dc: ba 10 20 00 clr %i5
err = errno;
200d1e0: 40 00 10 4d call 2011314 <__errno>
200d1e4: 01 00 00 00 nop
200d1e8: fa 02 00 00 ld [ %o0 ], %i5
close(filsdes[0]);
200d1ec: 7f ff db 29 call 2003e90 <close>
200d1f0: d0 06 00 00 ld [ %i0 ], %o0
}
unlink(fifopath);
200d1f4: 7f ff ea da call 2007d5c <unlink>
200d1f8: 90 07 bf f0 add %fp, -16, %o0
}
if(err != 0)
200d1fc: 80 a7 60 00 cmp %i5, 0
200d200: 02 80 00 06 be 200d218 <pipe_create+0x138>
200d204: b0 10 20 00 clr %i0
rtems_set_errno_and_return_minus_one(err);
200d208: 40 00 10 43 call 2011314 <__errno>
200d20c: 01 00 00 00 nop
200d210: fa 22 00 00 st %i5, [ %o0 ]
{
rtems_libio_t *iop;
int err = 0;
if (rtems_mkdir("/tmp", S_IRWXU | S_IRWXG | S_IRWXO) != 0)
return -1;
200d214: b0 10 3f ff mov -1, %i0
unlink(fifopath);
}
if(err != 0)
rtems_set_errno_and_return_minus_one(err);
return 0;
}
200d218: 81 c7 e0 08 ret
200d21c: 81 e8 00 00 restore
0200e63c <pipe_ioctl>:
pipe_control_t *pipe,
ioctl_command_t cmd,
void *buffer,
rtems_libio_t *iop
)
{
200e63c: 9d e3 bf a0 save %sp, -96, %sp
if (cmd == FIONREAD) {
200e640: 03 10 01 19 sethi %hi(0x40046400), %g1
200e644: 82 10 62 7f or %g1, 0x27f, %g1 ! 4004667f <RAM_END+0x3dc4667f>
200e648: 80 a6 40 01 cmp %i1, %g1
200e64c: 12 80 00 11 bne 200e690 <pipe_ioctl+0x54>
200e650: 80 a6 a0 00 cmp %i2, 0
if (buffer == NULL)
200e654: 02 80 00 11 be 200e698 <pipe_ioctl+0x5c>
200e658: 92 10 20 00 clr %o1
return -EFAULT;
if (! PIPE_LOCK(pipe))
200e65c: d0 06 20 28 ld [ %i0 + 0x28 ], %o0
200e660: 7f ff ea c9 call 2009184 <rtems_semaphore_obtain>
200e664: 94 10 20 00 clr %o2
200e668: 80 a2 20 00 cmp %o0, 0
200e66c: 12 80 00 0d bne 200e6a0 <pipe_ioctl+0x64> <== NEVER TAKEN
200e670: 01 00 00 00 nop
return -EINTR;
/* Return length of pipe */
*(unsigned int *)buffer = pipe->Length;
200e674: c2 06 20 0c ld [ %i0 + 0xc ], %g1
PIPE_UNLOCK(pipe);
200e678: d0 06 20 28 ld [ %i0 + 0x28 ], %o0
if (! PIPE_LOCK(pipe))
return -EINTR;
/* Return length of pipe */
*(unsigned int *)buffer = pipe->Length;
200e67c: c2 26 80 00 st %g1, [ %i2 ]
PIPE_UNLOCK(pipe);
200e680: 7f ff eb 0b call 20092ac <rtems_semaphore_release>
200e684: b0 10 20 00 clr %i0
return 0;
200e688: 81 c7 e0 08 ret
200e68c: 81 e8 00 00 restore
}
return -EINVAL;
200e690: 81 c7 e0 08 ret
200e694: 91 e8 3f ea restore %g0, -22, %o0
rtems_libio_t *iop
)
{
if (cmd == FIONREAD) {
if (buffer == NULL)
return -EFAULT;
200e698: 81 c7 e0 08 ret
200e69c: 91 e8 3f f2 restore %g0, -14, %o0
PIPE_UNLOCK(pipe);
return 0;
}
return -EINVAL;
}
200e6a0: 81 c7 e0 08 ret <== NOT EXECUTED
200e6a4: 91 e8 3f fc restore %g0, -4, %o0 <== NOT EXECUTED
0200e2d0 <pipe_read>:
pipe_control_t *pipe,
void *buffer,
size_t count,
rtems_libio_t *iop
)
{
200e2d0: 9d e3 bf 98 save %sp, -104, %sp
int chunk, chunk1, read = 0, ret = 0;
if (! PIPE_LOCK(pipe))
200e2d4: d0 06 20 28 ld [ %i0 + 0x28 ], %o0
200e2d8: 92 10 20 00 clr %o1
200e2dc: 94 10 20 00 clr %o2
200e2e0: 7f ff eb a9 call 2009184 <rtems_semaphore_obtain>
200e2e4: ba 10 00 18 mov %i0, %i5
200e2e8: 80 a2 20 00 cmp %o0, 0
200e2ec: 32 80 00 5d bne,a 200e460 <pipe_read+0x190> <== NEVER TAKEN
200e2f0: b0 10 3f fc mov -4, %i0 <== NOT EXECUTED
200e2f4: 10 80 00 4d b 200e428 <pipe_read+0x158>
200e2f8: b0 10 20 00 clr %i0
return -EINTR;
while (read < count) {
while (PIPE_EMPTY(pipe)) {
/* Not an error */
if (pipe->Writers == 0)
200e2fc: 80 a0 60 00 cmp %g1, 0
200e300: 32 80 00 04 bne,a 200e310 <pipe_read+0x40>
200e304: c2 06 e0 10 ld [ %i3 + 0x10 ], %g1
rtems_libio_t *iop
)
{
int chunk, chunk1, read = 0, ret = 0;
if (! PIPE_LOCK(pipe))
200e308: 10 80 00 4c b 200e438 <pipe_read+0x168>
200e30c: b8 10 20 00 clr %i4
while (PIPE_EMPTY(pipe)) {
/* Not an error */
if (pipe->Writers == 0)
goto out_locked;
if (LIBIO_NODELAY(iop)) {
200e310: 80 88 60 01 btst 1, %g1
200e314: 32 80 00 49 bne,a 200e438 <pipe_read+0x168>
200e318: b8 10 3f f5 mov -11, %i4
ret = -EAGAIN;
goto out_locked;
}
/* Wait until pipe is no more empty or no writer exists */
pipe->waitingReaders ++;
200e31c: c2 07 60 18 ld [ %i5 + 0x18 ], %g1
PIPE_UNLOCK(pipe);
200e320: d0 07 60 28 ld [ %i5 + 0x28 ], %o0
ret = -EAGAIN;
goto out_locked;
}
/* Wait until pipe is no more empty or no writer exists */
pipe->waitingReaders ++;
200e324: 82 00 60 01 inc %g1
PIPE_UNLOCK(pipe);
200e328: 7f ff eb e1 call 20092ac <rtems_semaphore_release>
200e32c: c2 27 60 18 st %g1, [ %i5 + 0x18 ]
if (! PIPE_READWAIT(pipe))
200e330: d0 07 60 2c ld [ %i5 + 0x2c ], %o0
200e334: 40 00 05 6f call 200f8f0 <rtems_barrier_wait>
200e338: 92 10 20 00 clr %o1
200e33c: 80 a0 00 08 cmp %g0, %o0
ret = -EINTR;
if (! PIPE_LOCK(pipe)) {
200e340: d0 07 60 28 ld [ %i5 + 0x28 ], %o0
}
/* Wait until pipe is no more empty or no writer exists */
pipe->waitingReaders ++;
PIPE_UNLOCK(pipe);
if (! PIPE_READWAIT(pipe))
200e344: b8 60 20 00 subx %g0, 0, %i4
ret = -EINTR;
if (! PIPE_LOCK(pipe)) {
200e348: 92 10 20 00 clr %o1
200e34c: 94 10 20 00 clr %o2
200e350: 7f ff eb 8d call 2009184 <rtems_semaphore_obtain>
200e354: b8 0f 3f fc and %i4, -4, %i4
200e358: 80 a2 20 00 cmp %o0, 0
200e35c: 12 80 00 3b bne 200e448 <pipe_read+0x178> <== NEVER TAKEN
200e360: 80 a7 20 00 cmp %i4, 0
/* WARN waitingReaders not restored! */
ret = -EINTR;
goto out_nolock;
}
pipe->waitingReaders --;
200e364: c2 07 60 18 ld [ %i5 + 0x18 ], %g1
200e368: 82 00 7f ff add %g1, -1, %g1
if (ret != 0)
200e36c: 12 80 00 33 bne 200e438 <pipe_read+0x168> <== NEVER TAKEN
200e370: c2 27 60 18 st %g1, [ %i5 + 0x18 ]
if (! PIPE_LOCK(pipe))
return -EINTR;
while (read < count) {
while (PIPE_EMPTY(pipe)) {
200e374: f8 07 60 0c ld [ %i5 + 0xc ], %i4
200e378: 80 a7 20 00 cmp %i4, 0
200e37c: 22 bf ff e0 be,a 200e2fc <pipe_read+0x2c>
200e380: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
if (ret != 0)
goto out_locked;
}
/* Read chunk bytes */
chunk = MIN(count - read, pipe->Length);
200e384: 82 26 80 18 sub %i2, %i0, %g1
200e388: 80 a7 00 01 cmp %i4, %g1
200e38c: 38 80 00 02 bgu,a 200e394 <pipe_read+0xc4>
200e390: b8 10 00 01 mov %g1, %i4
chunk1 = pipe->Size - pipe->Start;
200e394: c2 07 60 08 ld [ %i5 + 8 ], %g1
200e398: e0 07 60 04 ld [ %i5 + 4 ], %l0
200e39c: d2 07 40 00 ld [ %i5 ], %o1
200e3a0: a0 24 00 01 sub %l0, %g1, %l0
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);
200e3a4: 94 10 00 1c mov %i4, %o2
}
/* Read chunk bytes */
chunk = MIN(count - read, pipe->Length);
chunk1 = pipe->Size - pipe->Start;
if (chunk > chunk1) {
200e3a8: 80 a7 00 10 cmp %i4, %l0
200e3ac: 90 06 40 18 add %i1, %i0, %o0
200e3b0: 04 80 00 09 ble 200e3d4 <pipe_read+0x104>
200e3b4: 92 02 40 01 add %o1, %g1, %o1
memcpy(buffer + read, pipe->Buffer + pipe->Start, chunk1);
200e3b8: 40 00 11 9d call 2012a2c <memcpy>
200e3bc: 94 10 00 10 mov %l0, %o2
memcpy(buffer + read + chunk1, pipe->Buffer, chunk - chunk1);
200e3c0: 90 06 00 10 add %i0, %l0, %o0
200e3c4: d2 07 40 00 ld [ %i5 ], %o1
200e3c8: 90 06 40 08 add %i1, %o0, %o0
200e3cc: 10 80 00 02 b 200e3d4 <pipe_read+0x104>
200e3d0: 94 27 00 10 sub %i4, %l0, %o2
}
else
memcpy(buffer + read, pipe->Buffer + pipe->Start, chunk);
200e3d4: 40 00 11 96 call 2012a2c <memcpy>
200e3d8: 01 00 00 00 nop
pipe->Start += chunk;
200e3dc: d0 07 60 08 ld [ %i5 + 8 ], %o0
pipe->Start %= pipe->Size;
200e3e0: d2 07 60 04 ld [ %i5 + 4 ], %o1
200e3e4: 40 00 41 ab call 201ea90 <.urem>
200e3e8: 90 07 00 08 add %i4, %o0, %o0
pipe->Length -= chunk;
200e3ec: c2 07 60 0c ld [ %i5 + 0xc ], %g1
}
else
memcpy(buffer + read, pipe->Buffer + pipe->Start, chunk);
pipe->Start += chunk;
pipe->Start %= pipe->Size;
200e3f0: d0 27 60 08 st %o0, [ %i5 + 8 ]
pipe->Length -= chunk;
200e3f4: 82 20 40 1c sub %g1, %i4, %g1
/* For buffering optimization */
if (PIPE_EMPTY(pipe))
200e3f8: 80 a0 60 00 cmp %g1, 0
200e3fc: 12 80 00 03 bne 200e408 <pipe_read+0x138>
200e400: c2 27 60 0c st %g1, [ %i5 + 0xc ]
pipe->Start = 0;
200e404: c0 27 60 08 clr [ %i5 + 8 ]
if (pipe->waitingWriters > 0)
200e408: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
200e40c: 80 a0 60 00 cmp %g1, 0
200e410: 22 80 00 06 be,a 200e428 <pipe_read+0x158>
200e414: b0 06 00 1c add %i0, %i4, %i0
PIPE_WAKEUPWRITERS(pipe);
200e418: d0 07 60 30 ld [ %i5 + 0x30 ], %o0
200e41c: 40 00 05 1f call 200f898 <rtems_barrier_release>
200e420: 92 07 bf fc add %fp, -4, %o1
read += chunk;
200e424: b0 06 00 1c add %i0, %i4, %i0
int chunk, chunk1, read = 0, ret = 0;
if (! PIPE_LOCK(pipe))
return -EINTR;
while (read < count) {
200e428: 80 a6 00 1a cmp %i0, %i2
200e42c: 2a bf ff d3 bcs,a 200e378 <pipe_read+0xa8>
200e430: f8 07 60 0c ld [ %i5 + 0xc ], %i4
200e434: b8 10 20 00 clr %i4
PIPE_WAKEUPWRITERS(pipe);
read += chunk;
}
out_locked:
PIPE_UNLOCK(pipe);
200e438: 7f ff eb 9d call 20092ac <rtems_semaphore_release>
200e43c: d0 07 60 28 ld [ %i5 + 0x28 ], %o0
out_nolock:
if (read > 0)
200e440: 10 80 00 04 b 200e450 <pipe_read+0x180>
200e444: 80 a6 20 00 cmp %i0, 0
PIPE_UNLOCK(pipe);
if (! PIPE_READWAIT(pipe))
ret = -EINTR;
if (! PIPE_LOCK(pipe)) {
/* WARN waitingReaders not restored! */
ret = -EINTR;
200e448: b8 10 3f fc mov -4, %i4 <== NOT EXECUTED
out_locked:
PIPE_UNLOCK(pipe);
out_nolock:
if (read > 0)
200e44c: 80 a6 20 00 cmp %i0, 0 <== NOT EXECUTED
200e450: 14 80 00 04 bg 200e460 <pipe_read+0x190>
200e454: 01 00 00 00 nop
return read;
return ret;
200e458: 81 c7 e0 08 ret
200e45c: 91 e8 00 1c restore %g0, %i4, %o0
}
200e460: 81 c7 e0 08 ret
200e464: 81 e8 00 00 restore
0200ddc0 <pipe_release>:
*/
void pipe_release(
pipe_control_t **pipep,
rtems_libio_t *iop
)
{
200ddc0: 9d e3 bf 98 save %sp, -104, %sp
/* WARN pipe not released! */
if (!PIPE_LOCK(pipe))
rtems_fatal_error_occurred(0xdeadbeef);
#endif
mode = LIBIO_ACCMODE(iop);
200ddc4: c2 06 60 10 ld [ %i1 + 0x10 ], %g1
void pipe_release(
pipe_control_t **pipep,
rtems_libio_t *iop
)
{
pipe_control_t *pipe = *pipep;
200ddc8: fa 06 00 00 ld [ %i0 ], %i5
if (!PIPE_LOCK(pipe))
rtems_fatal_error_occurred(0xdeadbeef);
#endif
mode = LIBIO_ACCMODE(iop);
if (mode & LIBIO_FLAGS_READ)
200ddcc: 80 88 60 02 btst 2, %g1
200ddd0: 02 80 00 05 be 200dde4 <pipe_release+0x24>
200ddd4: b8 08 60 06 and %g1, 6, %i4
pipe->Readers --;
200ddd8: c4 07 60 10 ld [ %i5 + 0x10 ], %g2
200dddc: 84 00 bf ff add %g2, -1, %g2
200dde0: c4 27 60 10 st %g2, [ %i5 + 0x10 ]
if (mode & LIBIO_FLAGS_WRITE)
200dde4: 80 88 60 04 btst 4, %g1
200dde8: 02 80 00 05 be 200ddfc <pipe_release+0x3c>
200ddec: 01 00 00 00 nop
pipe->Writers --;
200ddf0: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
200ddf4: 82 00 7f ff add %g1, -1, %g1
200ddf8: c2 27 60 14 st %g1, [ %i5 + 0x14 ]
PIPE_UNLOCK(pipe);
200ddfc: 7f ff ed 2c call 20092ac <rtems_semaphore_release>
200de00: d0 07 60 28 ld [ %i5 + 0x28 ], %o0
if (pipe->Readers == 0 && pipe->Writers == 0) {
200de04: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
200de08: 80 a0 60 00 cmp %g1, 0
200de0c: 12 80 00 0d bne 200de40 <pipe_release+0x80>
200de10: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
200de14: 80 a0 60 00 cmp %g1, 0
200de18: 12 80 00 06 bne 200de30 <pipe_release+0x70>
200de1c: 80 a7 20 04 cmp %i4, 4
#if 0
/* To delete an anonymous pipe file when all users closed it */
if (pipe->Anonymous)
delfile = TRUE;
#endif
pipe_free(pipe);
200de20: 7f ff ff dd call 200dd94 <pipe_free>
200de24: 90 10 00 1d mov %i5, %o0
*pipep = NULL;
200de28: 10 80 00 0e b 200de60 <pipe_release+0xa0>
200de2c: c0 26 00 00 clr [ %i0 ]
}
else if (pipe->Readers == 0 && mode != LIBIO_FLAGS_WRITE)
200de30: 02 80 00 05 be 200de44 <pipe_release+0x84> <== NEVER TAKEN
200de34: 80 a0 60 00 cmp %g1, 0
/* Notify waiting Writers that all their partners left */
PIPE_WAKEUPWRITERS(pipe);
200de38: 10 80 00 08 b 200de58 <pipe_release+0x98>
200de3c: d0 07 60 30 ld [ %i5 + 0x30 ], %o0
else if (pipe->Writers == 0 && mode != LIBIO_FLAGS_READ)
200de40: 80 a0 60 00 cmp %g1, 0
200de44: 12 80 00 07 bne 200de60 <pipe_release+0xa0> <== NEVER TAKEN
200de48: 80 a7 20 02 cmp %i4, 2
200de4c: 02 80 00 06 be 200de64 <pipe_release+0xa4> <== NEVER TAKEN
200de50: 03 00 80 8d sethi %hi(0x2023400), %g1
PIPE_WAKEUPREADERS(pipe);
200de54: d0 07 60 2c ld [ %i5 + 0x2c ], %o0
200de58: 40 00 06 90 call 200f898 <rtems_barrier_release>
200de5c: 92 07 bf fc add %fp, -4, %o1
#ifdef RTEMS_DEBUG
rtems_status_code sc = RTEMS_SUCCESSFUL;
sc =
#endif
rtems_semaphore_release(pipe_semaphore);
200de60: 03 00 80 8d sethi %hi(0x2023400), %g1
200de64: 7f ff ed 12 call 20092ac <rtems_semaphore_release>
200de68: d0 00 61 d0 ld [ %g1 + 0x1d0 ], %o0 ! 20235d0 <pipe_semaphore>
200de6c: 81 c7 e0 08 ret
200de70: 81 e8 00 00 restore
0200e468 <pipe_write>:
pipe_control_t *pipe,
const void *buffer,
size_t count,
rtems_libio_t *iop
)
{
200e468: 9d e3 bf 98 save %sp, -104, %sp
200e46c: ba 10 00 18 mov %i0, %i5
int chunk, chunk1, written = 0, ret = 0;
/* Write nothing */
if (count == 0)
200e470: 80 a6 a0 00 cmp %i2, 0
200e474: 02 80 00 70 be 200e634 <pipe_write+0x1cc> <== NEVER TAKEN
200e478: b0 10 20 00 clr %i0
return 0;
if (! PIPE_LOCK(pipe))
200e47c: d0 07 60 28 ld [ %i5 + 0x28 ], %o0
200e480: 92 10 20 00 clr %o1
200e484: 7f ff eb 40 call 2009184 <rtems_semaphore_obtain>
200e488: 94 10 20 00 clr %o2
200e48c: 80 a2 20 00 cmp %o0, 0
200e490: 32 80 00 69 bne,a 200e634 <pipe_write+0x1cc> <== NEVER TAKEN
200e494: b0 10 3f fc mov -4, %i0 <== NOT EXECUTED
return -EINTR;
if (pipe->Readers == 0) {
200e498: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
200e49c: 80 a0 60 00 cmp %g1, 0
200e4a0: 02 80 00 54 be 200e5f0 <pipe_write+0x188>
200e4a4: b8 10 3f e0 mov -32, %i4
ret = -EPIPE;
goto out_locked;
}
/* Write of PIPE_BUF bytes or less shall not be interleaved */
chunk = count <= pipe->Size ? count : 1;
200e4a8: c2 07 60 04 ld [ %i5 + 4 ], %g1
200e4ac: 80 a6 80 01 cmp %i2, %g1
200e4b0: 18 80 00 03 bgu 200e4bc <pipe_write+0x54> <== NEVER TAKEN
200e4b4: a2 10 20 01 mov 1, %l1
200e4b8: a2 10 00 1a mov %i2, %l1
/* Wait until there is chunk bytes space or no reader exists */
pipe->waitingWriters ++;
PIPE_UNLOCK(pipe);
if (! PIPE_WRITEWAIT(pipe))
ret = -EINTR;
200e4bc: 10 80 00 49 b 200e5e0 <pipe_write+0x178>
200e4c0: b0 10 20 00 clr %i0
/* 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)) {
200e4c4: 80 88 60 01 btst 1, %g1
200e4c8: 32 80 00 4a bne,a 200e5f0 <pipe_write+0x188>
200e4cc: b8 10 3f f5 mov -11, %i4
ret = -EAGAIN;
goto out_locked;
}
/* Wait until there is chunk bytes space or no reader exists */
pipe->waitingWriters ++;
200e4d0: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
PIPE_UNLOCK(pipe);
200e4d4: d0 07 60 28 ld [ %i5 + 0x28 ], %o0
ret = -EAGAIN;
goto out_locked;
}
/* Wait until there is chunk bytes space or no reader exists */
pipe->waitingWriters ++;
200e4d8: 82 00 60 01 inc %g1
PIPE_UNLOCK(pipe);
200e4dc: 7f ff eb 74 call 20092ac <rtems_semaphore_release>
200e4e0: c2 27 60 1c st %g1, [ %i5 + 0x1c ]
if (! PIPE_WRITEWAIT(pipe))
200e4e4: d0 07 60 30 ld [ %i5 + 0x30 ], %o0
200e4e8: 40 00 05 02 call 200f8f0 <rtems_barrier_wait>
200e4ec: 92 10 20 00 clr %o1
200e4f0: 80 a0 00 08 cmp %g0, %o0
ret = -EINTR;
if (! PIPE_LOCK(pipe)) {
200e4f4: d0 07 60 28 ld [ %i5 + 0x28 ], %o0
}
/* Wait until there is chunk bytes space or no reader exists */
pipe->waitingWriters ++;
PIPE_UNLOCK(pipe);
if (! PIPE_WRITEWAIT(pipe))
200e4f8: b8 60 20 00 subx %g0, 0, %i4
ret = -EINTR;
if (! PIPE_LOCK(pipe)) {
200e4fc: 92 10 20 00 clr %o1
200e500: 94 10 20 00 clr %o2
200e504: 7f ff eb 20 call 2009184 <rtems_semaphore_obtain>
200e508: b8 0f 3f fc and %i4, -4, %i4
200e50c: 80 a2 20 00 cmp %o0, 0
200e510: 12 80 00 43 bne 200e61c <pipe_write+0x1b4> <== NEVER TAKEN
200e514: 80 a7 20 00 cmp %i4, 0
/* WARN waitingWriters not restored! */
ret = -EINTR;
goto out_nolock;
}
pipe->waitingWriters --;
200e518: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
200e51c: 82 00 7f ff add %g1, -1, %g1
if (ret != 0)
200e520: 12 80 00 34 bne 200e5f0 <pipe_write+0x188> <== NEVER TAKEN
200e524: c2 27 60 1c st %g1, [ %i5 + 0x1c ]
goto out_locked;
if (pipe->Readers == 0) {
200e528: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
200e52c: 80 a0 60 00 cmp %g1, 0
200e530: 02 80 00 30 be 200e5f0 <pipe_write+0x188> <== NEVER TAKEN
200e534: b8 10 3f e0 mov -32, %i4
/* 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) {
200e538: e0 07 60 04 ld [ %i5 + 4 ], %l0
200e53c: c2 07 60 0c ld [ %i5 + 0xc ], %g1
200e540: b8 24 00 01 sub %l0, %g1, %i4
200e544: 80 a7 00 11 cmp %i4, %l1
200e548: 2a bf ff df bcs,a 200e4c4 <pipe_write+0x5c>
200e54c: c2 06 e0 10 ld [ %i3 + 0x10 ], %g1
ret = -EPIPE;
goto out_locked;
}
}
chunk = MIN(count - written, PIPE_SPACE(pipe));
200e550: 84 26 80 18 sub %i2, %i0, %g2
200e554: 80 a7 00 02 cmp %i4, %g2
200e558: 38 80 00 02 bgu,a 200e560 <pipe_write+0xf8>
200e55c: b8 10 00 02 mov %g2, %i4
chunk1 = pipe->Size - PIPE_WSTART(pipe);
200e560: d0 07 60 08 ld [ %i5 + 8 ], %o0
200e564: 92 10 00 10 mov %l0, %o1
200e568: 40 00 41 4a call 201ea90 <.urem>
200e56c: 90 00 40 08 add %g1, %o0, %o0
200e570: c2 07 40 00 ld [ %i5 ], %g1
200e574: a0 24 00 08 sub %l0, %o0, %l0
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);
200e578: 94 10 00 1c mov %i4, %o2
}
}
chunk = MIN(count - written, PIPE_SPACE(pipe));
chunk1 = pipe->Size - PIPE_WSTART(pipe);
if (chunk > chunk1) {
200e57c: 80 a7 00 10 cmp %i4, %l0
200e580: 92 06 40 18 add %i1, %i0, %o1
200e584: 04 80 00 09 ble 200e5a8 <pipe_write+0x140>
200e588: 90 00 40 08 add %g1, %o0, %o0
memcpy(pipe->Buffer + PIPE_WSTART(pipe), buffer + written, chunk1);
200e58c: 40 00 11 28 call 2012a2c <memcpy>
200e590: 94 10 00 10 mov %l0, %o2
memcpy(pipe->Buffer, buffer + written + chunk1, chunk - chunk1);
200e594: 92 04 00 18 add %l0, %i0, %o1
200e598: d0 07 40 00 ld [ %i5 ], %o0
200e59c: 92 06 40 09 add %i1, %o1, %o1
200e5a0: 10 80 00 02 b 200e5a8 <pipe_write+0x140>
200e5a4: 94 27 00 10 sub %i4, %l0, %o2
}
else
memcpy(pipe->Buffer + PIPE_WSTART(pipe), buffer + written, chunk);
200e5a8: 40 00 11 21 call 2012a2c <memcpy>
200e5ac: 01 00 00 00 nop
pipe->Length += chunk;
200e5b0: c2 07 60 0c ld [ %i5 + 0xc ], %g1
200e5b4: 82 00 40 1c add %g1, %i4, %g1
200e5b8: c2 27 60 0c st %g1, [ %i5 + 0xc ]
if (pipe->waitingReaders > 0)
200e5bc: c2 07 60 18 ld [ %i5 + 0x18 ], %g1
200e5c0: 80 a0 60 00 cmp %g1, 0
200e5c4: 22 80 00 06 be,a 200e5dc <pipe_write+0x174>
200e5c8: b0 06 00 1c add %i0, %i4, %i0
PIPE_WAKEUPREADERS(pipe);
200e5cc: d0 07 60 2c ld [ %i5 + 0x2c ], %o0
200e5d0: 40 00 04 b2 call 200f898 <rtems_barrier_release>
200e5d4: 92 07 bf fc add %fp, -4, %o1
written += chunk;
200e5d8: b0 06 00 1c add %i0, %i4, %i0
/* Write of more than PIPE_BUF bytes can be interleaved */
chunk = 1;
200e5dc: a2 10 20 01 mov 1, %l1
}
/* Write of PIPE_BUF bytes or less shall not be interleaved */
chunk = count <= pipe->Size ? count : 1;
while (written < count) {
200e5e0: 80 a6 00 1a cmp %i0, %i2
200e5e4: 2a bf ff d6 bcs,a 200e53c <pipe_write+0xd4>
200e5e8: e0 07 60 04 ld [ %i5 + 4 ], %l0
200e5ec: b8 10 20 00 clr %i4
/* Write of more than PIPE_BUF bytes can be interleaved */
chunk = 1;
}
out_locked:
PIPE_UNLOCK(pipe);
200e5f0: 7f ff eb 2f call 20092ac <rtems_semaphore_release>
200e5f4: d0 07 60 28 ld [ %i5 + 0x28 ], %o0
out_nolock:
#ifdef RTEMS_POSIX_API
/* Signal SIGPIPE */
if (ret == -EPIPE)
200e5f8: 80 a7 3f e0 cmp %i4, -32
200e5fc: 32 80 00 0a bne,a 200e624 <pipe_write+0x1bc>
200e600: 80 a6 20 00 cmp %i0, 0
kill(getpid(), SIGPIPE);
200e604: 40 00 01 23 call 200ea90 <getpid>
200e608: 01 00 00 00 nop
200e60c: 40 00 02 9b call 200f078 <kill>
200e610: 92 10 20 0d mov 0xd, %o1 ! d <PROM_START+0xd>
#endif
if (written > 0)
200e614: 10 80 00 04 b 200e624 <pipe_write+0x1bc>
200e618: 80 a6 20 00 cmp %i0, 0
PIPE_UNLOCK(pipe);
if (! PIPE_WRITEWAIT(pipe))
ret = -EINTR;
if (! PIPE_LOCK(pipe)) {
/* WARN waitingWriters not restored! */
ret = -EINTR;
200e61c: b8 10 3f fc mov -4, %i4 <== NOT EXECUTED
/* Signal SIGPIPE */
if (ret == -EPIPE)
kill(getpid(), SIGPIPE);
#endif
if (written > 0)
200e620: 80 a6 20 00 cmp %i0, 0 <== NOT EXECUTED
200e624: 14 80 00 04 bg 200e634 <pipe_write+0x1cc>
200e628: 01 00 00 00 nop
200e62c: 81 c7 e0 08 ret
200e630: 91 e8 00 1c restore %g0, %i4, %o0
return written;
return ret;
}
200e634: 81 c7 e0 08 ret
200e638: 81 e8 00 00 restore
02007c60 <posix_memalign>:
)
{
/*
* Update call statistics
*/
MSBUMP(memalign_calls, 1);
2007c60: 05 00 80 91 sethi %hi(0x2024400), %g2
2007c64: 84 10 a0 c0 or %g2, 0xc0, %g2 ! 20244c0 <rtems_malloc_statistics>
2007c68: c6 00 a0 08 ld [ %g2 + 8 ], %g3
2007c6c: 86 00 e0 01 inc %g3
2007c70: c6 20 a0 08 st %g3, [ %g2 + 8 ]
if (((alignment - 1) & alignment) != 0 || (alignment < sizeof(void *)))
2007c74: 84 02 7f ff add %o1, -1, %g2
2007c78: 80 88 80 09 btst %g2, %o1
2007c7c: 12 80 00 07 bne 2007c98 <posix_memalign+0x38> <== NEVER TAKEN
2007c80: 80 a2 60 03 cmp %o1, 3
2007c84: 08 80 00 05 bleu 2007c98 <posix_memalign+0x38>
2007c88: 01 00 00 00 nop
/*
* rtems_memalign does all of the error checking work EXCEPT
* for adding restrictionso on the alignment.
*/
return rtems_memalign( pointer, alignment, size );
2007c8c: 82 13 c0 00 mov %o7, %g1
2007c90: 40 00 00 83 call 2007e9c <rtems_memalign>
2007c94: 9e 10 40 00 mov %g1, %o7
}
2007c98: 81 c3 e0 08 retl
2007c9c: 90 10 20 16 mov 0x16, %o0
0200c3e0 <pthread_attr_setschedpolicy>:
int pthread_attr_setschedpolicy(
pthread_attr_t *attr,
int policy
)
{
200c3e0: 82 10 00 08 mov %o0, %g1
if ( !attr || !attr->is_initialized )
200c3e4: 80 a0 60 00 cmp %g1, 0
200c3e8: 02 80 00 0f be 200c424 <pthread_attr_setschedpolicy+0x44>
200c3ec: 90 10 20 16 mov 0x16, %o0
200c3f0: c4 00 40 00 ld [ %g1 ], %g2
200c3f4: 80 a0 a0 00 cmp %g2, 0
200c3f8: 02 80 00 0b be 200c424 <pthread_attr_setschedpolicy+0x44>
200c3fc: 80 a2 60 04 cmp %o1, 4
return EINVAL;
switch ( policy ) {
200c400: 38 80 00 09 bgu,a 200c424 <pthread_attr_setschedpolicy+0x44>
200c404: 90 10 20 86 mov 0x86, %o0
200c408: 84 10 20 01 mov 1, %g2
200c40c: 85 28 80 09 sll %g2, %o1, %g2
200c410: 80 88 a0 17 btst 0x17, %g2
200c414: 22 80 00 04 be,a 200c424 <pthread_attr_setschedpolicy+0x44><== NEVER TAKEN
200c418: 90 10 20 86 mov 0x86, %o0 <== NOT EXECUTED
case SCHED_OTHER:
case SCHED_FIFO:
case SCHED_RR:
case SCHED_SPORADIC:
attr->schedpolicy = policy;
200c41c: d2 20 60 14 st %o1, [ %g1 + 0x14 ]
200c420: 90 10 20 00 clr %o0
return 0;
default:
return ENOTSUP;
}
}
200c424: 81 c3 e0 08 retl
02007b34 <pthread_barrier_init>:
int pthread_barrier_init(
pthread_barrier_t *barrier,
const pthread_barrierattr_t *attr,
unsigned int count
)
{
2007b34: 9d e3 bf 90 save %sp, -112, %sp
const pthread_barrierattr_t *the_attr;
/*
* Error check parameters
*/
if ( !barrier )
2007b38: 80 a6 20 00 cmp %i0, 0
2007b3c: 12 80 00 04 bne 2007b4c <pthread_barrier_init+0x18>
2007b40: 80 a6 a0 00 cmp %i2, 0
switch ( the_attr->process_shared ) {
case PTHREAD_PROCESS_PRIVATE: /* only supported values */
break;
case PTHREAD_PROCESS_SHARED:
default:
return EINVAL;
2007b44: 81 c7 e0 08 ret
2007b48: 91 e8 20 16 restore %g0, 0x16, %o0
* Error check parameters
*/
if ( !barrier )
return EINVAL;
if ( count == 0 )
2007b4c: 22 80 00 1f be,a 2007bc8 <pthread_barrier_init+0x94>
2007b50: b0 10 20 16 mov 0x16, %i0
return EINVAL;
/*
* If the user passed in NULL, use the default attributes
*/
if ( attr ) {
2007b54: 80 a6 60 00 cmp %i1, 0
2007b58: 32 80 00 06 bne,a 2007b70 <pthread_barrier_init+0x3c>
2007b5c: c2 06 40 00 ld [ %i1 ], %g1
the_attr = attr;
} else {
(void) pthread_barrierattr_init( &my_attr );
2007b60: 90 07 bf f8 add %fp, -8, %o0
2007b64: 7f ff ff bc call 2007a54 <pthread_barrierattr_init>
2007b68: b2 07 bf f8 add %fp, -8, %i1
}
/*
* Now start error checking the attributes that we are going to use
*/
if ( !the_attr->is_initialized )
2007b6c: c2 06 40 00 ld [ %i1 ], %g1
2007b70: 80 a0 60 00 cmp %g1, 0
2007b74: 22 80 00 15 be,a 2007bc8 <pthread_barrier_init+0x94>
2007b78: b0 10 20 16 mov 0x16, %i0
return EINVAL;
switch ( the_attr->process_shared ) {
2007b7c: c2 06 60 04 ld [ %i1 + 4 ], %g1
2007b80: 80 a0 60 00 cmp %g1, 0
2007b84: 32 80 00 11 bne,a 2007bc8 <pthread_barrier_init+0x94> <== NEVER TAKEN
2007b88: b0 10 20 16 mov 0x16, %i0 <== NOT EXECUTED
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
_Thread_Dispatch_disable_level++;
2007b8c: 03 00 80 7c sethi %hi(0x201f000), %g1
2007b90: c4 00 60 f0 ld [ %g1 + 0xf0 ], %g2 ! 201f0f0 <_Thread_Dispatch_disable_level>
}
/*
* Convert from POSIX attributes to Core Barrier attributes
*/
the_attributes.discipline = CORE_BARRIER_AUTOMATIC_RELEASE;
2007b94: c0 27 bf f0 clr [ %fp + -16 ]
the_attributes.maximum_count = count;
2007b98: f4 27 bf f4 st %i2, [ %fp + -12 ]
2007b9c: 84 00 a0 01 inc %g2
2007ba0: c4 20 60 f0 st %g2, [ %g1 + 0xf0 ]
return _Thread_Dispatch_disable_level;
2007ba4: c2 00 60 f0 ld [ %g1 + 0xf0 ], %g1
* 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 *)
2007ba8: 39 00 80 7d sethi %hi(0x201f400), %i4
2007bac: 40 00 08 67 call 2009d48 <_Objects_Allocate>
2007bb0: 90 17 20 a0 or %i4, 0xa0, %o0 ! 201f4a0 <_POSIX_Barrier_Information>
*/
_Thread_Disable_dispatch(); /* prevents deletion */
the_barrier = _POSIX_Barrier_Allocate();
if ( !the_barrier ) {
2007bb4: ba 92 20 00 orcc %o0, 0, %i5
2007bb8: 12 80 00 06 bne 2007bd0 <pthread_barrier_init+0x9c>
2007bbc: 90 07 60 10 add %i5, 0x10, %o0
_Thread_Enable_dispatch();
2007bc0: 40 00 0d 4c call 200b0f0 <_Thread_Enable_dispatch>
2007bc4: b0 10 20 0b mov 0xb, %i0
2007bc8: 81 c7 e0 08 ret
2007bcc: 81 e8 00 00 restore
return EAGAIN;
}
_CORE_barrier_Initialize( &the_barrier->Barrier, &the_attributes );
2007bd0: 40 00 05 d9 call 2009334 <_CORE_barrier_Initialize>
2007bd4: 92 07 bf f0 add %fp, -16, %o1
Objects_Information *information,
Objects_Control *the_object,
uint32_t name
)
{
_Objects_Set_local_object(
2007bd8: c4 17 60 0a lduh [ %i5 + 0xa ], %g2
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
2007bdc: b8 17 20 a0 or %i4, 0xa0, %i4
2007be0: c6 07 20 1c ld [ %i4 + 0x1c ], %g3
Objects_Information *information,
Objects_Control *the_object,
uint32_t name
)
{
_Objects_Set_local_object(
2007be4: c2 07 60 08 ld [ %i5 + 8 ], %g1
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
2007be8: 85 28 a0 02 sll %g2, 2, %g2
2007bec: fa 20 c0 02 st %i5, [ %g3 + %g2 ]
_Objects_Get_index( the_object->id ),
the_object
);
/* ASSERT: information->is_string == false */
the_object->name.name_u32 = name;
2007bf0: c0 27 60 0c clr [ %i5 + 0xc ]
);
/*
* Exit the critical section and return the user an operational barrier
*/
*barrier = the_barrier->Object.id;
2007bf4: c2 26 00 00 st %g1, [ %i0 ]
_Thread_Enable_dispatch();
2007bf8: 40 00 0d 3e call 200b0f0 <_Thread_Enable_dispatch>
2007bfc: b0 10 20 00 clr %i0
2007c00: 81 c7 e0 08 ret
2007c04: 81 e8 00 00 restore
02007424 <pthread_cleanup_push>:
void pthread_cleanup_push(
void (*routine)( void * ),
void *arg
)
{
2007424: 9d e3 bf a0 save %sp, -96, %sp
/*
* 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 )
2007428: 80 a6 20 00 cmp %i0, 0
200742c: 02 80 00 13 be 2007478 <pthread_cleanup_push+0x54>
2007430: 03 00 80 7a sethi %hi(0x201e800), %g1
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
_Thread_Dispatch_disable_level++;
2007434: c4 00 61 50 ld [ %g1 + 0x150 ], %g2 ! 201e950 <_Thread_Dispatch_disable_level>
2007438: 84 00 a0 01 inc %g2
200743c: c4 20 61 50 st %g2, [ %g1 + 0x150 ]
return _Thread_Dispatch_disable_level;
2007440: c2 00 61 50 ld [ %g1 + 0x150 ], %g1
return;
_Thread_Disable_dispatch();
handler = _Workspace_Allocate( sizeof( POSIX_Cancel_Handler_control ) );
2007444: 40 00 11 d5 call 200bb98 <_Workspace_Allocate>
2007448: 90 10 20 10 mov 0x10, %o0
if ( handler ) {
200744c: 92 92 20 00 orcc %o0, 0, %o1
2007450: 02 80 00 08 be 2007470 <pthread_cleanup_push+0x4c> <== NEVER TAKEN
2007454: 03 00 80 7b sethi %hi(0x201ec00), %g1
thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ];
2007458: c2 00 62 8c ld [ %g1 + 0x28c ], %g1 ! 201ee8c <_Per_CPU_Information+0xc>
handler_stack = &thread_support->Cancellation_Handlers;
200745c: d0 00 61 5c ld [ %g1 + 0x15c ], %o0
handler->routine = routine;
2007460: f0 22 60 08 st %i0, [ %o1 + 8 ]
handler->arg = arg;
2007464: f2 22 60 0c st %i1, [ %o1 + 0xc ]
_Chain_Append( handler_stack, &handler->Node );
2007468: 40 00 06 21 call 2008cec <_Chain_Append>
200746c: 90 02 20 e4 add %o0, 0xe4, %o0
}
_Thread_Enable_dispatch();
2007470: 40 00 0d 8a call 200aa98 <_Thread_Enable_dispatch>
2007474: 81 e8 00 00 restore
2007478: 81 c7 e0 08 ret
200747c: 81 e8 00 00 restore
020083fc <pthread_cond_init>:
int pthread_cond_init(
pthread_cond_t *cond,
const pthread_condattr_t *attr
)
{
20083fc: 9d e3 bf a0 save %sp, -96, %sp
POSIX_Condition_variables_Control *the_cond;
const pthread_condattr_t *the_attr;
if ( attr ) the_attr = attr;
2008400: 80 a6 60 00 cmp %i1, 0
2008404: 32 80 00 05 bne,a 2008418 <pthread_cond_init+0x1c>
2008408: c4 06 60 04 ld [ %i1 + 4 ], %g2
else the_attr = &_POSIX_Condition_variables_Default_attributes;
200840c: 33 00 80 78 sethi %hi(0x201e000), %i1
2008410: b2 16 60 84 or %i1, 0x84, %i1 ! 201e084 <_POSIX_Condition_variables_Default_attributes>
/*
* Be careful about attributes when global!!!
*/
if ( the_attr->process_shared == PTHREAD_PROCESS_SHARED )
2008414: c4 06 60 04 ld [ %i1 + 4 ], %g2
2008418: 80 a0 a0 01 cmp %g2, 1
200841c: 02 80 00 26 be 20084b4 <pthread_cond_init+0xb8> <== NEVER TAKEN
2008420: 82 10 20 16 mov 0x16, %g1
return EINVAL;
if ( !the_attr->is_initialized )
2008424: c4 06 40 00 ld [ %i1 ], %g2
2008428: 80 a0 a0 00 cmp %g2, 0
200842c: 02 80 00 22 be 20084b4 <pthread_cond_init+0xb8>
2008430: 01 00 00 00 nop
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
_Thread_Dispatch_disable_level++;
2008434: 03 00 80 80 sethi %hi(0x2020000), %g1
2008438: c4 00 63 60 ld [ %g1 + 0x360 ], %g2 ! 2020360 <_Thread_Dispatch_disable_level>
200843c: 84 00 a0 01 inc %g2
2008440: c4 20 63 60 st %g2, [ %g1 + 0x360 ]
return _Thread_Dispatch_disable_level;
2008444: c2 00 63 60 ld [ %g1 + 0x360 ], %g1
*/
RTEMS_INLINE_ROUTINE POSIX_Condition_variables_Control
*_POSIX_Condition_variables_Allocate( void )
{
return (POSIX_Condition_variables_Control *)
2008448: 39 00 80 81 sethi %hi(0x2020400), %i4
200844c: 40 00 0a 10 call 200ac8c <_Objects_Allocate>
2008450: 90 17 23 a8 or %i4, 0x3a8, %o0 ! 20207a8 <_POSIX_Condition_variables_Information>
_Thread_Disable_dispatch();
the_cond = _POSIX_Condition_variables_Allocate();
if ( !the_cond ) {
2008454: ba 92 20 00 orcc %o0, 0, %i5
2008458: 32 80 00 06 bne,a 2008470 <pthread_cond_init+0x74>
200845c: c2 06 60 04 ld [ %i1 + 4 ], %g1
_Thread_Enable_dispatch();
2008460: 40 00 0e f5 call 200c034 <_Thread_Enable_dispatch>
2008464: 01 00 00 00 nop
return ENOMEM;
2008468: 10 80 00 13 b 20084b4 <pthread_cond_init+0xb8>
200846c: 82 10 20 0c mov 0xc, %g1 ! c <PROM_START+0xc>
the_cond->process_shared = the_attr->process_shared;
the_cond->Mutex = POSIX_CONDITION_VARIABLES_NO_MUTEX;
_Thread_queue_Initialize(
2008470: 90 07 60 18 add %i5, 0x18, %o0
if ( !the_cond ) {
_Thread_Enable_dispatch();
return ENOMEM;
}
the_cond->process_shared = the_attr->process_shared;
2008474: c2 27 60 10 st %g1, [ %i5 + 0x10 ]
the_cond->Mutex = POSIX_CONDITION_VARIABLES_NO_MUTEX;
_Thread_queue_Initialize(
2008478: 92 10 20 00 clr %o1
200847c: 15 04 00 02 sethi %hi(0x10000800), %o2
2008480: 96 10 20 74 mov 0x74, %o3
2008484: 40 00 10 f0 call 200c844 <_Thread_queue_Initialize>
2008488: c0 27 60 14 clr [ %i5 + 0x14 ]
Objects_Information *information,
Objects_Control *the_object,
uint32_t name
)
{
_Objects_Set_local_object(
200848c: c4 17 60 0a lduh [ %i5 + 0xa ], %g2
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
2008490: b8 17 23 a8 or %i4, 0x3a8, %i4
2008494: c6 07 20 1c ld [ %i4 + 0x1c ], %g3
Objects_Information *information,
Objects_Control *the_object,
uint32_t name
)
{
_Objects_Set_local_object(
2008498: c2 07 60 08 ld [ %i5 + 8 ], %g1
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
200849c: 85 28 a0 02 sll %g2, 2, %g2
20084a0: fa 20 c0 02 st %i5, [ %g3 + %g2 ]
_Objects_Get_index( the_object->id ),
the_object
);
/* ASSERT: information->is_string == false */
the_object->name.name_u32 = name;
20084a4: c0 27 60 0c clr [ %i5 + 0xc ]
0
);
*cond = the_cond->Object.id;
_Thread_Enable_dispatch();
20084a8: 40 00 0e e3 call 200c034 <_Thread_Enable_dispatch>
20084ac: c2 26 00 00 st %g1, [ %i0 ]
return 0;
20084b0: 82 10 20 00 clr %g1
}
20084b4: 81 c7 e0 08 ret
20084b8: 91 e8 00 01 restore %g0, %g1, %o0
0200825c <pthread_condattr_destroy>:
*/
int pthread_condattr_destroy(
pthread_condattr_t *attr
)
{
200825c: 82 10 00 08 mov %o0, %g1
if ( !attr || attr->is_initialized == false )
2008260: 80 a0 60 00 cmp %g1, 0
2008264: 02 80 00 08 be 2008284 <pthread_condattr_destroy+0x28>
2008268: 90 10 20 16 mov 0x16, %o0
200826c: c4 00 40 00 ld [ %g1 ], %g2
2008270: 80 a0 a0 00 cmp %g2, 0
2008274: 02 80 00 04 be 2008284 <pthread_condattr_destroy+0x28> <== NEVER TAKEN
2008278: 01 00 00 00 nop
return EINVAL;
attr->is_initialized = false;
200827c: c0 20 40 00 clr [ %g1 ]
return 0;
2008280: 90 10 20 00 clr %o0
}
2008284: 81 c3 e0 08 retl
020077fc <pthread_create>:
pthread_t *thread,
const pthread_attr_t *attr,
void *(*start_routine)( void * ),
void *arg
)
{
20077fc: 9d e3 bf 58 save %sp, -168, %sp
int schedpolicy = SCHED_RR;
struct sched_param schedparam;
Objects_Name name;
int rc;
if ( !start_routine )
2007800: 80 a6 a0 00 cmp %i2, 0
2007804: 02 80 00 8c be 2007a34 <pthread_create+0x238>
2007808: ba 10 20 0e mov 0xe, %i5
return EFAULT;
the_attr = (attr) ? attr : &_POSIX_Threads_Default_attributes;
200780c: 80 a6 60 00 cmp %i1, 0
2007810: 32 80 00 05 bne,a 2007824 <pthread_create+0x28>
2007814: c2 06 40 00 ld [ %i1 ], %g1
2007818: 33 00 80 81 sethi %hi(0x2020400), %i1
200781c: b2 16 60 fc or %i1, 0xfc, %i1 ! 20204fc <_POSIX_Threads_Default_attributes>
if ( !the_attr->is_initialized )
2007820: c2 06 40 00 ld [ %i1 ], %g1
2007824: 80 a0 60 00 cmp %g1, 0
2007828: 02 80 00 83 be 2007a34 <pthread_create+0x238>
200782c: ba 10 20 16 mov 0x16, %i5
* 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) )
2007830: c2 06 60 04 ld [ %i1 + 4 ], %g1
2007834: 80 a0 60 00 cmp %g1, 0
2007838: 02 80 00 07 be 2007854 <pthread_create+0x58>
200783c: 03 00 80 86 sethi %hi(0x2021800), %g1
2007840: c4 06 60 08 ld [ %i1 + 8 ], %g2
2007844: c2 00 62 4c ld [ %g1 + 0x24c ], %g1
2007848: 80 a0 80 01 cmp %g2, %g1
200784c: 2a 80 00 7b bcs,a 2007a38 <pthread_create+0x23c>
2007850: b0 10 00 1d mov %i5, %i0
* 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 ) {
2007854: c2 06 60 10 ld [ %i1 + 0x10 ], %g1
2007858: 80 a0 60 01 cmp %g1, 1
200785c: 02 80 00 06 be 2007874 <pthread_create+0x78>
2007860: 80 a0 60 02 cmp %g1, 2
2007864: 32 80 00 74 bne,a 2007a34 <pthread_create+0x238>
2007868: ba 10 20 16 mov 0x16, %i5
schedpolicy = api->schedpolicy;
schedparam = api->schedparam;
break;
case PTHREAD_EXPLICIT_SCHED:
schedpolicy = the_attr->schedpolicy;
200786c: 10 80 00 09 b 2007890 <pthread_create+0x94>
2007870: e2 06 60 14 ld [ %i1 + 0x14 ], %l1
* PTHREAD_EXPLICIT_SCHED, then scheduling parameters come from the
* attributes structure.
*/
switch ( the_attr->inheritsched ) {
case PTHREAD_INHERIT_SCHED:
api = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ];
2007874: 03 00 80 8b sethi %hi(0x2022c00), %g1
2007878: c2 00 61 1c ld [ %g1 + 0x11c ], %g1 ! 2022d1c <_Per_CPU_Information+0xc>
schedpolicy = api->schedpolicy;
schedparam = api->schedparam;
200787c: 90 07 bf e4 add %fp, -28, %o0
* PTHREAD_EXPLICIT_SCHED, then scheduling parameters come from the
* attributes structure.
*/
switch ( the_attr->inheritsched ) {
case PTHREAD_INHERIT_SCHED:
api = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ];
2007880: d2 00 61 5c ld [ %g1 + 0x15c ], %o1
schedpolicy = api->schedpolicy;
2007884: e2 02 60 84 ld [ %o1 + 0x84 ], %l1
schedparam = api->schedparam;
2007888: 10 80 00 04 b 2007898 <pthread_create+0x9c>
200788c: 92 02 60 88 add %o1, 0x88, %o1
break;
case PTHREAD_EXPLICIT_SCHED:
schedpolicy = the_attr->schedpolicy;
schedparam = the_attr->schedparam;
2007890: 90 07 bf e4 add %fp, -28, %o0
2007894: 92 06 60 18 add %i1, 0x18, %o1
2007898: 40 00 25 77 call 2010e74 <memcpy>
200789c: 94 10 20 1c mov 0x1c, %o2
/*
* Check the contentionscope since rtems only supports PROCESS wide
* contention (i.e. no system wide contention).
*/
if ( the_attr->contentionscope != PTHREAD_SCOPE_PROCESS )
20078a0: c2 06 60 0c ld [ %i1 + 0xc ], %g1
20078a4: 80 a0 60 00 cmp %g1, 0
20078a8: 12 80 00 63 bne 2007a34 <pthread_create+0x238>
20078ac: ba 10 20 86 mov 0x86, %i5
return ENOTSUP;
/*
* Interpret the scheduling parameters.
*/
if ( !_POSIX_Priority_Is_valid( schedparam.sched_priority ) )
20078b0: 40 00 18 e7 call 200dc4c <_POSIX_Priority_Is_valid>
20078b4: d0 07 bf e4 ld [ %fp + -28 ], %o0
20078b8: 80 8a 20 ff btst 0xff, %o0
20078bc: 02 80 00 5e be 2007a34 <pthread_create+0x238> <== NEVER TAKEN
20078c0: ba 10 20 16 mov 0x16, %i5
RTEMS_INLINE_ROUTINE Priority_Control _POSIX_Priority_To_core(
int priority
)
{
return (Priority_Control) (POSIX_SCHEDULER_MAXIMUM_PRIORITY - priority + 1);
20078c4: 03 00 80 86 sethi %hi(0x2021800), %g1
return EINVAL;
core_priority = _POSIX_Priority_To_core( schedparam.sched_priority );
20078c8: e4 07 bf e4 ld [ %fp + -28 ], %l2
20078cc: e6 08 62 48 ldub [ %g1 + 0x248 ], %l3
/*
* Set the core scheduling policy information.
*/
rc = _POSIX_Thread_Translate_sched_param(
20078d0: 90 10 00 11 mov %l1, %o0
20078d4: 92 07 bf e4 add %fp, -28, %o1
20078d8: 94 07 bf dc add %fp, -36, %o2
20078dc: 40 00 18 e7 call 200dc78 <_POSIX_Thread_Translate_sched_param>
20078e0: 96 07 bf e0 add %fp, -32, %o3
schedpolicy,
&schedparam,
&budget_algorithm,
&budget_callout
);
if ( rc )
20078e4: ba 92 20 00 orcc %o0, 0, %i5
20078e8: 32 80 00 54 bne,a 2007a38 <pthread_create+0x23c>
20078ec: b0 10 00 1d mov %i5, %i0
#endif
/*
* Lock the allocator mutex for protection
*/
_RTEMS_Lock_allocator();
20078f0: 39 00 80 8a sethi %hi(0x2022800), %i4
20078f4: 40 00 06 35 call 20091c8 <_API_Mutex_Lock>
20078f8: d0 07 20 70 ld [ %i4 + 0x70 ], %o0 ! 2022870 <_RTEMS_Allocator_Mutex>
* _POSIX_Threads_Allocate
*/
RTEMS_INLINE_ROUTINE Thread_Control *_POSIX_Threads_Allocate( void )
{
return (Thread_Control *) _Objects_Allocate( &_POSIX_Threads_Information );
20078fc: 11 00 80 8a sethi %hi(0x2022800), %o0
2007900: 40 00 08 d4 call 2009c50 <_Objects_Allocate>
2007904: 90 12 22 10 or %o0, 0x210, %o0 ! 2022a10 <_POSIX_Threads_Information>
* Allocate the thread control block.
*
* NOTE: Global threads are not currently supported.
*/
the_thread = _POSIX_Threads_Allocate();
if ( !the_thread ) {
2007908: a0 92 20 00 orcc %o0, 0, %l0
200790c: 32 80 00 04 bne,a 200791c <pthread_create+0x120>
2007910: c2 06 60 08 ld [ %i1 + 8 ], %g1
_RTEMS_Unlock_allocator();
2007914: 10 80 00 21 b 2007998 <pthread_create+0x19c>
2007918: d0 07 20 70 ld [ %i4 + 0x70 ], %o0
static inline size_t _POSIX_Threads_Ensure_minimum_stack (
size_t size
)
{
if ( size >= PTHREAD_MINIMUM_STACK_SIZE )
200791c: 05 00 80 86 sethi %hi(0x2021800), %g2
2007920: d6 00 a2 4c ld [ %g2 + 0x24c ], %o3 ! 2021a4c <rtems_minimum_stack_size>
/*
* Initialize the core thread for this task.
*/
name.name_p = NULL; /* posix threads don't have a name by default */
status = _Thread_Initialize(
2007924: c0 27 bf d4 clr [ %fp + -44 ]
2007928: 97 2a e0 01 sll %o3, 1, %o3
200792c: 80 a2 c0 01 cmp %o3, %g1
2007930: 1a 80 00 03 bcc 200793c <pthread_create+0x140>
2007934: d4 06 60 04 ld [ %i1 + 4 ], %o2
2007938: 96 10 00 01 mov %g1, %o3
200793c: 82 10 20 01 mov 1, %g1
2007940: c2 23 a0 5c st %g1, [ %sp + 0x5c ]
2007944: c2 07 bf dc ld [ %fp + -36 ], %g1
2007948: 9a 0c e0 ff and %l3, 0xff, %o5
200794c: c2 23 a0 60 st %g1, [ %sp + 0x60 ]
2007950: c2 07 bf e0 ld [ %fp + -32 ], %g1
2007954: c0 23 a0 68 clr [ %sp + 0x68 ]
2007958: c2 23 a0 64 st %g1, [ %sp + 0x64 ]
200795c: 82 07 bf d4 add %fp, -44, %g1
2007960: 39 00 80 8a sethi %hi(0x2022800), %i4
2007964: c2 23 a0 6c st %g1, [ %sp + 0x6c ]
2007968: 90 17 22 10 or %i4, 0x210, %o0
200796c: 92 10 00 10 mov %l0, %o1
2007970: 98 10 20 01 mov 1, %o4
2007974: 40 00 0d db call 200b0e0 <_Thread_Initialize>
2007978: 9a 23 40 12 sub %o5, %l2, %o5
budget_callout,
0, /* isr level */
name /* posix threads don't have a name */
);
if ( !status ) {
200797c: 80 8a 20 ff btst 0xff, %o0
2007980: 12 80 00 0a bne 20079a8 <pthread_create+0x1ac>
2007984: 90 17 22 10 or %i4, 0x210, %o0
RTEMS_INLINE_ROUTINE void _POSIX_Threads_Free (
Thread_Control *the_pthread
)
{
_Objects_Free( &_POSIX_Threads_Information, &the_pthread->Object );
2007988: 40 00 09 89 call 2009fac <_Objects_Free>
200798c: 92 10 00 10 mov %l0, %o1
_POSIX_Threads_Free( the_thread );
_RTEMS_Unlock_allocator();
2007990: 03 00 80 8a sethi %hi(0x2022800), %g1
2007994: d0 00 60 70 ld [ %g1 + 0x70 ], %o0 ! 2022870 <_RTEMS_Allocator_Mutex>
2007998: 40 00 06 21 call 200921c <_API_Mutex_Unlock>
200799c: ba 10 20 0b mov 0xb, %i5
*/
*thread = the_thread->Object.id;
_RTEMS_Unlock_allocator();
return 0;
}
20079a0: 81 c7 e0 08 ret
20079a4: 91 e8 00 1d restore %g0, %i5, %o0
}
/*
* finish initializing the per API structure
*/
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
20079a8: f8 04 21 5c ld [ %l0 + 0x15c ], %i4
api->Attributes = *the_attr;
20079ac: 92 10 00 19 mov %i1, %o1
20079b0: 94 10 20 40 mov 0x40, %o2
20079b4: 40 00 25 30 call 2010e74 <memcpy>
20079b8: 90 10 00 1c mov %i4, %o0
api->detachstate = the_attr->detachstate;
20079bc: c2 06 60 3c ld [ %i1 + 0x3c ], %g1
api->schedpolicy = schedpolicy;
api->schedparam = schedparam;
20079c0: 92 07 bf e4 add %fp, -28, %o1
* finish initializing the per API structure
*/
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
api->Attributes = *the_attr;
api->detachstate = the_attr->detachstate;
20079c4: c2 27 20 40 st %g1, [ %i4 + 0x40 ]
api->schedpolicy = schedpolicy;
api->schedparam = schedparam;
20079c8: 94 10 20 1c mov 0x1c, %o2
*/
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
api->Attributes = *the_attr;
api->detachstate = the_attr->detachstate;
api->schedpolicy = schedpolicy;
20079cc: e2 27 20 84 st %l1, [ %i4 + 0x84 ]
api->schedparam = schedparam;
20079d0: 40 00 25 29 call 2010e74 <memcpy>
20079d4: 90 07 20 88 add %i4, 0x88, %o0
/*
* POSIX threads are allocated and started in one operation.
*/
status = _Thread_Start(
20079d8: 90 10 00 10 mov %l0, %o0
20079dc: 92 10 20 01 mov 1, %o1
20079e0: 94 10 00 1a mov %i2, %o2
20079e4: 96 10 00 1b mov %i3, %o3
20079e8: 40 00 10 0a call 200ba10 <_Thread_Start>
20079ec: 98 10 20 00 clr %o4
_RTEMS_Unlock_allocator();
return EINVAL;
}
#endif
if ( schedpolicy == SCHED_SPORADIC ) {
20079f0: 80 a4 60 04 cmp %l1, 4
20079f4: 32 80 00 0a bne,a 2007a1c <pthread_create+0x220>
20079f8: c2 04 20 08 ld [ %l0 + 8 ], %g1
_Watchdog_Insert_ticks(
20079fc: 40 00 10 2d call 200bab0 <_Timespec_To_ticks>
2007a00: 90 07 20 90 add %i4, 0x90, %o0
)
{
the_watchdog->initial = units;
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
2007a04: 92 07 20 a8 add %i4, 0xa8, %o1
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
2007a08: d0 27 20 b4 st %o0, [ %i4 + 0xb4 ]
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
2007a0c: 11 00 80 8a sethi %hi(0x2022800), %o0
2007a10: 40 00 11 06 call 200be28 <_Watchdog_Insert>
2007a14: 90 12 20 88 or %o0, 0x88, %o0 ! 2022888 <_Watchdog_Ticks_chain>
}
/*
* Return the id and indicate we successfully created the thread
*/
*thread = the_thread->Object.id;
2007a18: c2 04 20 08 ld [ %l0 + 8 ], %g1
2007a1c: c2 26 00 00 st %g1, [ %i0 ]
_RTEMS_Unlock_allocator();
2007a20: 03 00 80 8a sethi %hi(0x2022800), %g1
2007a24: 40 00 05 fe call 200921c <_API_Mutex_Unlock>
2007a28: d0 00 60 70 ld [ %g1 + 0x70 ], %o0 ! 2022870 <_RTEMS_Allocator_Mutex>
return 0;
}
2007a2c: 81 c7 e0 08 ret
2007a30: 91 e8 00 1d restore %g0, %i5, %o0
2007a34: b0 10 00 1d mov %i5, %i0
2007a38: 81 c7 e0 08 ret
2007a3c: 81 e8 00 00 restore
0201a794 <pthread_kill>:
int pthread_kill(
pthread_t thread,
int sig
)
{
201a794: 9d e3 bf 98 save %sp, -104, %sp
POSIX_API_Control *api;
Thread_Control *the_thread;
Objects_Locations location;
if ( !sig )
201a798: 80 a6 60 00 cmp %i1, 0
201a79c: 32 80 00 03 bne,a 201a7a8 <pthread_kill+0x14>
201a7a0: b6 06 7f ff add %i1, -1, %i3
201a7a4: 30 80 00 04 b,a 201a7b4 <pthread_kill+0x20>
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !is_valid_signo(sig) )
201a7a8: 80 a6 e0 1f cmp %i3, 0x1f
201a7ac: 28 80 00 06 bleu,a 201a7c4 <pthread_kill+0x30>
201a7b0: 90 10 00 18 mov %i0, %o0
rtems_set_errno_and_return_minus_one( EINVAL );
201a7b4: 7f ff d4 97 call 200fa10 <__errno>
201a7b8: 01 00 00 00 nop
201a7bc: 10 80 00 2c b 201a86c <pthread_kill+0xd8>
201a7c0: 82 10 20 16 mov 0x16, %g1 ! 16 <PROM_START+0x16>
the_thread = _Thread_Get( thread, &location );
201a7c4: 7f ff be 86 call 200a1dc <_Thread_Get>
201a7c8: 92 07 bf fc add %fp, -4, %o1
switch ( location ) {
201a7cc: c2 07 bf fc ld [ %fp + -4 ], %g1
201a7d0: 80 a0 60 00 cmp %g1, 0
201a7d4: 12 80 00 23 bne 201a860 <pthread_kill+0xcc> <== NEVER TAKEN
201a7d8: b8 10 00 08 mov %o0, %i4
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
if ( sig ) {
if ( _POSIX_signals_Vectors[ sig ].sa_handler == SIG_IGN ) {
201a7dc: 85 2e 60 02 sll %i1, 2, %g2
201a7e0: 87 2e 60 04 sll %i1, 4, %g3
201a7e4: 86 20 c0 02 sub %g3, %g2, %g3
201a7e8: 05 00 80 78 sethi %hi(0x201e000), %g2
201a7ec: 84 10 a0 70 or %g2, 0x70, %g2 ! 201e070 <_POSIX_signals_Vectors>
201a7f0: 84 00 80 03 add %g2, %g3, %g2
201a7f4: c4 00 a0 08 ld [ %g2 + 8 ], %g2
201a7f8: 80 a0 a0 01 cmp %g2, 1
201a7fc: 12 80 00 06 bne 201a814 <pthread_kill+0x80>
201a800: c2 02 21 5c ld [ %o0 + 0x15c ], %g1
_Thread_Enable_dispatch();
201a804: 7f ff be 69 call 200a1a8 <_Thread_Enable_dispatch>
201a808: b0 10 20 00 clr %i0
201a80c: 81 c7 e0 08 ret
201a810: 81 e8 00 00 restore
return 0;
}
/* XXX critical section */
api->signals_pending |= signo_to_mask( sig );
201a814: c4 00 60 d4 ld [ %g1 + 0xd4 ], %g2
201a818: ba 10 20 01 mov 1, %i5
(void) _POSIX_signals_Unblock_thread( the_thread, sig, NULL );
201a81c: 92 10 00 19 mov %i1, %o1
201a820: b7 2f 40 1b sll %i5, %i3, %i3
201a824: 94 10 20 00 clr %o2
return 0;
}
/* XXX critical section */
api->signals_pending |= signo_to_mask( sig );
201a828: b6 10 80 1b or %g2, %i3, %i3
(void) _POSIX_signals_Unblock_thread( the_thread, sig, NULL );
201a82c: 7f ff ff 88 call 201a64c <_POSIX_signals_Unblock_thread>
201a830: f6 20 60 d4 st %i3, [ %g1 + 0xd4 ]
if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
201a834: 03 00 80 78 sethi %hi(0x201e000), %g1
201a838: 82 10 60 10 or %g1, 0x10, %g1 ! 201e010 <_Per_CPU_Information>
201a83c: c4 00 60 08 ld [ %g1 + 8 ], %g2
201a840: 80 a0 a0 00 cmp %g2, 0
201a844: 02 bf ff f0 be 201a804 <pthread_kill+0x70>
201a848: 01 00 00 00 nop
201a84c: c4 00 60 0c ld [ %g1 + 0xc ], %g2
201a850: 80 a7 00 02 cmp %i4, %g2
201a854: 22 bf ff ec be,a 201a804 <pthread_kill+0x70>
201a858: fa 28 60 18 stb %i5, [ %g1 + 0x18 ]
201a85c: 30 bf ff ea b,a 201a804 <pthread_kill+0x70>
#endif
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( ESRCH );
201a860: 7f ff d4 6c call 200fa10 <__errno> <== NOT EXECUTED
201a864: 01 00 00 00 nop <== NOT EXECUTED
201a868: 82 10 20 03 mov 3, %g1 ! 3 <PROM_START+0x3> <== NOT EXECUTED
201a86c: c2 22 00 00 st %g1, [ %o0 ]
}
201a870: 81 c7 e0 08 ret
201a874: 91 e8 3f ff restore %g0, -1, %o0
020099e0 <pthread_mutex_timedlock>:
int pthread_mutex_timedlock(
pthread_mutex_t *mutex,
const struct timespec *abstime
)
{
20099e0: 9d e3 bf 98 save %sp, -104, %sp
*
* 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 );
20099e4: 92 07 bf fc add %fp, -4, %o1
20099e8: 40 00 00 37 call 2009ac4 <_POSIX_Absolute_timeout_to_ticks>
20099ec: 90 10 00 19 mov %i1, %o0
if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE )
do_wait = false;
lock_status = _POSIX_Mutex_Lock_support( mutex, do_wait, ticks );
20099f0: d4 07 bf fc ld [ %fp + -4 ], %o2
* If the status is POSIX_ABSOLUTE_TIMEOUT_INVALID,
* POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST, or POSIX_ABSOLUTE_TIMEOUT_IS_NOW,
* then we should not wait.
*/
status = _POSIX_Absolute_timeout_to_ticks( abstime, &ticks );
if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE )
20099f4: 82 1a 20 03 xor %o0, 3, %g1
20099f8: 80 a0 00 01 cmp %g0, %g1
*
* 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 );
20099fc: ba 10 00 08 mov %o0, %i5
if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE )
2009a00: b8 60 3f ff subx %g0, -1, %i4
do_wait = false;
lock_status = _POSIX_Mutex_Lock_support( mutex, do_wait, ticks );
2009a04: 90 10 00 18 mov %i0, %o0
2009a08: 7f ff ff b7 call 20098e4 <_POSIX_Mutex_Lock_support>
2009a0c: 92 10 00 1c mov %i4, %o1
* 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) ) {
2009a10: 80 a7 20 00 cmp %i4, 0
2009a14: 12 80 00 0c bne 2009a44 <pthread_mutex_timedlock+0x64>
2009a18: b0 10 00 08 mov %o0, %i0
2009a1c: 80 a2 20 10 cmp %o0, 0x10
2009a20: 12 80 00 09 bne 2009a44 <pthread_mutex_timedlock+0x64>
2009a24: 80 a7 60 00 cmp %i5, 0
if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID )
2009a28: 02 80 00 07 be 2009a44 <pthread_mutex_timedlock+0x64> <== NEVER TAKEN
2009a2c: b0 10 20 16 mov 0x16, %i0
return EINVAL;
if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST ||
2009a30: ba 07 7f ff add %i5, -1, %i5
2009a34: 80 a7 60 01 cmp %i5, 1
2009a38: 18 80 00 03 bgu 2009a44 <pthread_mutex_timedlock+0x64> <== NEVER TAKEN
2009a3c: b0 10 20 10 mov 0x10, %i0
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
return ETIMEDOUT;
2009a40: b0 10 20 74 mov 0x74, %i0
}
return lock_status;
}
2009a44: 81 c7 e0 08 ret
2009a48: 81 e8 00 00 restore
020070e0 <pthread_mutexattr_gettype>:
#if defined(_UNIX98_THREAD_MUTEX_ATTRIBUTES)
int pthread_mutexattr_gettype(
const pthread_mutexattr_t *attr,
int *type
)
{
20070e0: 82 10 00 08 mov %o0, %g1
if ( !attr )
20070e4: 80 a0 60 00 cmp %g1, 0
20070e8: 02 80 00 0b be 2007114 <pthread_mutexattr_gettype+0x34>
20070ec: 90 10 20 16 mov 0x16, %o0
return EINVAL;
if ( !attr->is_initialized )
20070f0: c4 00 40 00 ld [ %g1 ], %g2
20070f4: 80 a0 a0 00 cmp %g2, 0
20070f8: 02 80 00 07 be 2007114 <pthread_mutexattr_gettype+0x34>
20070fc: 80 a2 60 00 cmp %o1, 0
return EINVAL;
if ( !type )
2007100: 02 80 00 05 be 2007114 <pthread_mutexattr_gettype+0x34> <== NEVER TAKEN
2007104: 01 00 00 00 nop
return EINVAL;
*type = attr->type;
2007108: c2 00 60 10 ld [ %g1 + 0x10 ], %g1
return 0;
200710c: 90 10 20 00 clr %o0
return EINVAL;
if ( !type )
return EINVAL;
*type = attr->type;
2007110: c2 22 40 00 st %g1, [ %o1 ]
return 0;
}
2007114: 81 c3 e0 08 retl
02009594 <pthread_mutexattr_setpshared>:
int pthread_mutexattr_setpshared(
pthread_mutexattr_t *attr,
int pshared
)
{
2009594: 82 10 00 08 mov %o0, %g1
if ( !attr || !attr->is_initialized )
2009598: 80 a0 60 00 cmp %g1, 0
200959c: 02 80 00 0a be 20095c4 <pthread_mutexattr_setpshared+0x30>
20095a0: 90 10 20 16 mov 0x16, %o0
20095a4: c4 00 40 00 ld [ %g1 ], %g2
20095a8: 80 a0 a0 00 cmp %g2, 0
20095ac: 02 80 00 06 be 20095c4 <pthread_mutexattr_setpshared+0x30>
20095b0: 80 a2 60 01 cmp %o1, 1
return EINVAL;
switch ( pshared ) {
20095b4: 18 80 00 04 bgu 20095c4 <pthread_mutexattr_setpshared+0x30><== NEVER TAKEN
20095b8: 01 00 00 00 nop
case PTHREAD_PROCESS_SHARED:
case PTHREAD_PROCESS_PRIVATE:
attr->process_shared = pshared;
20095bc: d2 20 60 04 st %o1, [ %g1 + 4 ]
return 0;
20095c0: 90 10 20 00 clr %o0
default:
return EINVAL;
}
}
20095c4: 81 c3 e0 08 retl
0200714c <pthread_mutexattr_settype>:
#if defined(_UNIX98_THREAD_MUTEX_ATTRIBUTES)
int pthread_mutexattr_settype(
pthread_mutexattr_t *attr,
int type
)
{
200714c: 82 10 00 08 mov %o0, %g1
if ( !attr || !attr->is_initialized )
2007150: 80 a0 60 00 cmp %g1, 0
2007154: 02 80 00 0a be 200717c <pthread_mutexattr_settype+0x30>
2007158: 90 10 20 16 mov 0x16, %o0
200715c: c4 00 40 00 ld [ %g1 ], %g2
2007160: 80 a0 a0 00 cmp %g2, 0
2007164: 02 80 00 06 be 200717c <pthread_mutexattr_settype+0x30> <== NEVER TAKEN
2007168: 80 a2 60 03 cmp %o1, 3
return EINVAL;
switch ( type ) {
200716c: 18 80 00 04 bgu 200717c <pthread_mutexattr_settype+0x30>
2007170: 01 00 00 00 nop
case PTHREAD_MUTEX_NORMAL:
case PTHREAD_MUTEX_RECURSIVE:
case PTHREAD_MUTEX_ERRORCHECK:
case PTHREAD_MUTEX_DEFAULT:
attr->type = type;
2007174: d2 20 60 10 st %o1, [ %g1 + 0x10 ]
return 0;
2007178: 90 10 20 00 clr %o0
default:
return EINVAL;
}
}
200717c: 81 c3 e0 08 retl
02007e8c <pthread_once>:
int pthread_once(
pthread_once_t *once_control,
void (*init_routine)(void)
)
{
2007e8c: 9d e3 bf 98 save %sp, -104, %sp
if ( !once_control || !init_routine )
2007e90: 80 a6 60 00 cmp %i1, 0
2007e94: 02 80 00 1c be 2007f04 <pthread_once+0x78>
2007e98: ba 10 00 18 mov %i0, %i5
2007e9c: 80 a6 20 00 cmp %i0, 0
2007ea0: 22 80 00 17 be,a 2007efc <pthread_once+0x70>
2007ea4: b0 10 20 16 mov 0x16, %i0
return EINVAL;
if ( !once_control->init_executed ) {
2007ea8: c2 06 20 04 ld [ %i0 + 4 ], %g1
2007eac: 80 a0 60 00 cmp %g1, 0
2007eb0: 12 80 00 13 bne 2007efc <pthread_once+0x70>
2007eb4: b0 10 20 00 clr %i0
rtems_mode saveMode;
rtems_task_mode(RTEMS_NO_PREEMPT, RTEMS_PREEMPT_MASK, &saveMode);
2007eb8: 90 10 21 00 mov 0x100, %o0
2007ebc: 92 10 21 00 mov 0x100, %o1
2007ec0: 40 00 03 05 call 2008ad4 <rtems_task_mode>
2007ec4: 94 07 bf fc add %fp, -4, %o2
if ( !once_control->init_executed ) {
2007ec8: c2 07 60 04 ld [ %i5 + 4 ], %g1
2007ecc: 80 a0 60 00 cmp %g1, 0
2007ed0: 12 80 00 07 bne 2007eec <pthread_once+0x60> <== NEVER TAKEN
2007ed4: d0 07 bf fc ld [ %fp + -4 ], %o0
once_control->is_initialized = true;
2007ed8: 82 10 20 01 mov 1, %g1
2007edc: c2 27 40 00 st %g1, [ %i5 ]
once_control->init_executed = true;
(*init_routine)();
2007ee0: 9f c6 40 00 call %i1
2007ee4: c2 27 60 04 st %g1, [ %i5 + 4 ]
}
rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode);
2007ee8: d0 07 bf fc ld [ %fp + -4 ], %o0
2007eec: 92 10 21 00 mov 0x100, %o1
2007ef0: 94 07 bf fc add %fp, -4, %o2
2007ef4: 40 00 02 f8 call 2008ad4 <rtems_task_mode>
2007ef8: b0 10 20 00 clr %i0
2007efc: 81 c7 e0 08 ret
2007f00: 81 e8 00 00 restore
pthread_once_t *once_control,
void (*init_routine)(void)
)
{
if ( !once_control || !init_routine )
return EINVAL;
2007f04: b0 10 20 16 mov 0x16, %i0
(*init_routine)();
}
rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode);
}
return 0;
}
2007f08: 81 c7 e0 08 ret
2007f0c: 81 e8 00 00 restore
02007fb8 <pthread_rwlock_init>:
int pthread_rwlock_init(
pthread_rwlock_t *rwlock,
const pthread_rwlockattr_t *attr
)
{
2007fb8: 9d e3 bf 90 save %sp, -112, %sp
const pthread_rwlockattr_t *the_attr;
/*
* Error check parameters
*/
if ( !rwlock )
2007fbc: 80 a6 20 00 cmp %i0, 0
2007fc0: 12 80 00 04 bne 2007fd0 <pthread_rwlock_init+0x18>
2007fc4: 80 a6 60 00 cmp %i1, 0
switch ( the_attr->process_shared ) {
case PTHREAD_PROCESS_PRIVATE: /* only supported values */
break;
case PTHREAD_PROCESS_SHARED:
default:
return EINVAL;
2007fc8: 81 c7 e0 08 ret
2007fcc: 91 e8 20 16 restore %g0, 0x16, %o0
return EINVAL;
/*
* If the user passed in NULL, use the default attributes
*/
if ( attr ) {
2007fd0: 32 80 00 06 bne,a 2007fe8 <pthread_rwlock_init+0x30>
2007fd4: c2 06 40 00 ld [ %i1 ], %g1
the_attr = attr;
} else {
(void) pthread_rwlockattr_init( &default_attr );
2007fd8: 90 07 bf f8 add %fp, -8, %o0
2007fdc: 40 00 01 b2 call 20086a4 <pthread_rwlockattr_init>
2007fe0: b2 07 bf f8 add %fp, -8, %i1
}
/*
* Now start error checking the attributes that we are going to use
*/
if ( !the_attr->is_initialized )
2007fe4: c2 06 40 00 ld [ %i1 ], %g1
2007fe8: 80 a0 60 00 cmp %g1, 0
2007fec: 22 80 00 14 be,a 200803c <pthread_rwlock_init+0x84> <== NEVER TAKEN
2007ff0: b0 10 20 16 mov 0x16, %i0 <== NOT EXECUTED
return EINVAL;
switch ( the_attr->process_shared ) {
2007ff4: c2 06 60 04 ld [ %i1 + 4 ], %g1
2007ff8: 80 a0 60 00 cmp %g1, 0
2007ffc: 32 80 00 10 bne,a 200803c <pthread_rwlock_init+0x84> <== NEVER TAKEN
2008000: b0 10 20 16 mov 0x16, %i0 <== NOT EXECUTED
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
_Thread_Dispatch_disable_level++;
2008004: 03 00 80 89 sethi %hi(0x2022400), %g1
2008008: c4 00 61 f0 ld [ %g1 + 0x1f0 ], %g2 ! 20225f0 <_Thread_Dispatch_disable_level>
*/
RTEMS_INLINE_ROUTINE void _CORE_RWLock_Initialize_attributes(
CORE_RWLock_Attributes *the_attributes
)
{
the_attributes->XXX = 0;
200800c: c0 27 bf f4 clr [ %fp + -12 ]
2008010: 84 00 a0 01 inc %g2
2008014: c4 20 61 f0 st %g2, [ %g1 + 0x1f0 ]
return _Thread_Dispatch_disable_level;
2008018: c2 00 61 f0 ld [ %g1 + 0x1f0 ], %g1
* 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 *)
200801c: 39 00 80 8a sethi %hi(0x2022800), %i4
2008020: 40 00 0a 72 call 200a9e8 <_Objects_Allocate>
2008024: 90 17 20 20 or %i4, 0x20, %o0 ! 2022820 <_POSIX_RWLock_Information>
*/
_Thread_Disable_dispatch(); /* prevents deletion */
the_rwlock = _POSIX_RWLock_Allocate();
if ( !the_rwlock ) {
2008028: ba 92 20 00 orcc %o0, 0, %i5
200802c: 12 80 00 06 bne 2008044 <pthread_rwlock_init+0x8c>
2008030: 90 07 60 10 add %i5, 0x10, %o0
_Thread_Enable_dispatch();
2008034: 40 00 0f 90 call 200be74 <_Thread_Enable_dispatch>
2008038: b0 10 20 0b mov 0xb, %i0
200803c: 81 c7 e0 08 ret
2008040: 81 e8 00 00 restore
return EAGAIN;
}
_CORE_RWLock_Initialize( &the_rwlock->RWLock, &the_attributes );
2008044: 40 00 08 d0 call 200a384 <_CORE_RWLock_Initialize>
2008048: 92 07 bf f4 add %fp, -12, %o1
Objects_Information *information,
Objects_Control *the_object,
uint32_t name
)
{
_Objects_Set_local_object(
200804c: c4 17 60 0a lduh [ %i5 + 0xa ], %g2
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
2008050: b8 17 20 20 or %i4, 0x20, %i4
2008054: c6 07 20 1c ld [ %i4 + 0x1c ], %g3
Objects_Information *information,
Objects_Control *the_object,
uint32_t name
)
{
_Objects_Set_local_object(
2008058: c2 07 60 08 ld [ %i5 + 8 ], %g1
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
200805c: 85 28 a0 02 sll %g2, 2, %g2
2008060: fa 20 c0 02 st %i5, [ %g3 + %g2 ]
_Objects_Get_index( the_object->id ),
the_object
);
/* ASSERT: information->is_string == false */
the_object->name.name_u32 = name;
2008064: c0 27 60 0c clr [ %i5 + 0xc ]
&_POSIX_RWLock_Information,
&the_rwlock->Object,
0
);
*rwlock = the_rwlock->Object.id;
2008068: c2 26 00 00 st %g1, [ %i0 ]
_Thread_Enable_dispatch();
200806c: 40 00 0f 82 call 200be74 <_Thread_Enable_dispatch>
2008070: b0 10 20 00 clr %i0
2008074: 81 c7 e0 08 ret
2008078: 81 e8 00 00 restore
02008954 <pthread_rwlock_timedrdlock>:
int pthread_rwlock_timedrdlock(
pthread_rwlock_t *rwlock,
const struct timespec *abstime
)
{
2008954: 9d e3 bf 98 save %sp, -104, %sp
Objects_Locations location;
Watchdog_Interval ticks;
bool do_wait = true;
POSIX_Absolute_timeout_conversion_results_t status;
if ( !rwlock )
2008958: 80 a6 20 00 cmp %i0, 0
200895c: 12 80 00 04 bne 200896c <pthread_rwlock_timedrdlock+0x18>
2008960: 92 07 bf fc add %fp, -4, %o1
#endif
case OBJECTS_ERROR:
break;
}
return EINVAL;
2008964: 81 c7 e0 08 ret
2008968: 91 e8 20 16 restore %g0, 0x16, %o0
*
* 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 );
200896c: 40 00 19 a6 call 200f004 <_POSIX_Absolute_timeout_to_ticks>
2008970: 90 10 00 19 mov %i1, %o0
2008974: d2 06 00 00 ld [ %i0 ], %o1
2008978: ba 10 00 08 mov %o0, %i5
200897c: 94 07 bf f8 add %fp, -8, %o2
2008980: 11 00 80 83 sethi %hi(0x2020c00), %o0
2008984: 40 00 0b 14 call 200b5d4 <_Objects_Get>
2008988: 90 12 21 e0 or %o0, 0x1e0, %o0 ! 2020de0 <_POSIX_RWLock_Information>
if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE )
do_wait = false;
the_rwlock = _POSIX_RWLock_Get( rwlock, &location );
switch ( location ) {
200898c: c2 07 bf f8 ld [ %fp + -8 ], %g1
2008990: 80 a0 60 00 cmp %g1, 0
2008994: 32 80 00 21 bne,a 2008a18 <pthread_rwlock_timedrdlock+0xc4>
2008998: b0 10 20 16 mov 0x16, %i0
case OBJECTS_LOCAL:
_CORE_RWLock_Obtain_for_reading(
200899c: d2 06 00 00 ld [ %i0 ], %o1
20089a0: d6 07 bf fc ld [ %fp + -4 ], %o3
* If the status is POSIX_ABSOLUTE_TIMEOUT_INVALID,
* POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST, or POSIX_ABSOLUTE_TIMEOUT_IS_NOW,
* then we should not wait.
*/
status = _POSIX_Absolute_timeout_to_ticks( abstime, &ticks );
if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE )
20089a4: 82 1f 60 03 xor %i5, 3, %g1
the_rwlock = _POSIX_RWLock_Get( rwlock, &location );
switch ( location ) {
case OBJECTS_LOCAL:
_CORE_RWLock_Obtain_for_reading(
20089a8: 90 02 20 10 add %o0, 0x10, %o0
20089ac: 80 a0 00 01 cmp %g0, %g1
20089b0: 98 10 20 00 clr %o4
20089b4: b8 60 3f ff subx %g0, -1, %i4
20089b8: 40 00 07 8a call 200a7e0 <_CORE_RWLock_Obtain_for_reading>
20089bc: 94 10 00 1c mov %i4, %o2
do_wait,
ticks,
NULL
);
_Thread_Enable_dispatch();
20089c0: 40 00 0e b1 call 200c484 <_Thread_Enable_dispatch>
20089c4: 01 00 00 00 nop
if ( !do_wait ) {
20089c8: 80 a7 20 00 cmp %i4, 0
20089cc: 12 80 00 0e bne 2008a04 <pthread_rwlock_timedrdlock+0xb0>
20089d0: 03 00 80 84 sethi %hi(0x2021000), %g1
if ( _Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE ) {
20089d4: c2 00 61 2c ld [ %g1 + 0x12c ], %g1 ! 202112c <_Per_CPU_Information+0xc>
20089d8: c2 00 60 34 ld [ %g1 + 0x34 ], %g1
20089dc: 80 a0 60 02 cmp %g1, 2
20089e0: 32 80 00 0a bne,a 2008a08 <pthread_rwlock_timedrdlock+0xb4>
20089e4: 03 00 80 84 sethi %hi(0x2021000), %g1
if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID )
20089e8: 80 a7 60 00 cmp %i5, 0
20089ec: 22 80 00 0b be,a 2008a18 <pthread_rwlock_timedrdlock+0xc4><== NEVER TAKEN
20089f0: b0 10 20 16 mov 0x16, %i0 <== NOT EXECUTED
return EINVAL;
if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST ||
20089f4: ba 07 7f ff add %i5, -1, %i5
20089f8: 80 a7 60 01 cmp %i5, 1
20089fc: 08 80 00 07 bleu 2008a18 <pthread_rwlock_timedrdlock+0xc4><== ALWAYS TAKEN
2008a00: b0 10 20 74 mov 0x74, %i0
return ETIMEDOUT;
}
}
return _POSIX_RWLock_Translate_core_RWLock_return_code(
(CORE_RWLock_Status) _Thread_Executing->Wait.return_code
2008a04: 03 00 80 84 sethi %hi(0x2021000), %g1
2008a08: c2 00 61 2c ld [ %g1 + 0x12c ], %g1 ! 202112c <_Per_CPU_Information+0xc>
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
return ETIMEDOUT;
}
}
return _POSIX_RWLock_Translate_core_RWLock_return_code(
2008a0c: 40 00 00 38 call 2008aec <_POSIX_RWLock_Translate_core_RWLock_return_code>
2008a10: d0 00 60 34 ld [ %g1 + 0x34 ], %o0
2008a14: b0 10 00 08 mov %o0, %i0
case OBJECTS_ERROR:
break;
}
return EINVAL;
}
2008a18: 81 c7 e0 08 ret
2008a1c: 81 e8 00 00 restore
02008a20 <pthread_rwlock_timedwrlock>:
int pthread_rwlock_timedwrlock(
pthread_rwlock_t *rwlock,
const struct timespec *abstime
)
{
2008a20: 9d e3 bf 98 save %sp, -104, %sp
Objects_Locations location;
Watchdog_Interval ticks;
bool do_wait = true;
POSIX_Absolute_timeout_conversion_results_t status;
if ( !rwlock )
2008a24: 80 a6 20 00 cmp %i0, 0
2008a28: 12 80 00 04 bne 2008a38 <pthread_rwlock_timedwrlock+0x18>
2008a2c: 92 07 bf fc add %fp, -4, %o1
#endif
case OBJECTS_ERROR:
break;
}
return EINVAL;
2008a30: 81 c7 e0 08 ret
2008a34: 91 e8 20 16 restore %g0, 0x16, %o0
*
* 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 );
2008a38: 40 00 19 73 call 200f004 <_POSIX_Absolute_timeout_to_ticks>
2008a3c: 90 10 00 19 mov %i1, %o0
2008a40: d2 06 00 00 ld [ %i0 ], %o1
2008a44: ba 10 00 08 mov %o0, %i5
2008a48: 94 07 bf f8 add %fp, -8, %o2
2008a4c: 11 00 80 83 sethi %hi(0x2020c00), %o0
2008a50: 40 00 0a e1 call 200b5d4 <_Objects_Get>
2008a54: 90 12 21 e0 or %o0, 0x1e0, %o0 ! 2020de0 <_POSIX_RWLock_Information>
if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE )
do_wait = false;
the_rwlock = _POSIX_RWLock_Get( rwlock, &location );
switch ( location ) {
2008a58: c2 07 bf f8 ld [ %fp + -8 ], %g1
2008a5c: 80 a0 60 00 cmp %g1, 0
2008a60: 32 80 00 21 bne,a 2008ae4 <pthread_rwlock_timedwrlock+0xc4>
2008a64: b0 10 20 16 mov 0x16, %i0
case OBJECTS_LOCAL:
_CORE_RWLock_Obtain_for_writing(
2008a68: d2 06 00 00 ld [ %i0 ], %o1
2008a6c: d6 07 bf fc ld [ %fp + -4 ], %o3
* If the status is POSIX_ABSOLUTE_TIMEOUT_INVALID,
* POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST, or POSIX_ABSOLUTE_TIMEOUT_IS_NOW,
* then we should not wait.
*/
status = _POSIX_Absolute_timeout_to_ticks( abstime, &ticks );
if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE )
2008a70: 82 1f 60 03 xor %i5, 3, %g1
the_rwlock = _POSIX_RWLock_Get( rwlock, &location );
switch ( location ) {
case OBJECTS_LOCAL:
_CORE_RWLock_Obtain_for_writing(
2008a74: 90 02 20 10 add %o0, 0x10, %o0
2008a78: 80 a0 00 01 cmp %g0, %g1
2008a7c: 98 10 20 00 clr %o4
2008a80: b8 60 3f ff subx %g0, -1, %i4
2008a84: 40 00 07 8a call 200a8ac <_CORE_RWLock_Obtain_for_writing>
2008a88: 94 10 00 1c mov %i4, %o2
do_wait,
ticks,
NULL
);
_Thread_Enable_dispatch();
2008a8c: 40 00 0e 7e call 200c484 <_Thread_Enable_dispatch>
2008a90: 01 00 00 00 nop
if ( !do_wait &&
2008a94: 80 a7 20 00 cmp %i4, 0
2008a98: 12 80 00 0e bne 2008ad0 <pthread_rwlock_timedwrlock+0xb0>
2008a9c: 03 00 80 84 sethi %hi(0x2021000), %g1
(_Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE) ) {
2008aa0: c2 00 61 2c ld [ %g1 + 0x12c ], %g1 ! 202112c <_Per_CPU_Information+0xc>
ticks,
NULL
);
_Thread_Enable_dispatch();
if ( !do_wait &&
2008aa4: c2 00 60 34 ld [ %g1 + 0x34 ], %g1
2008aa8: 80 a0 60 02 cmp %g1, 2
2008aac: 32 80 00 0a bne,a 2008ad4 <pthread_rwlock_timedwrlock+0xb4>
2008ab0: 03 00 80 84 sethi %hi(0x2021000), %g1
(_Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE) ) {
if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID )
2008ab4: 80 a7 60 00 cmp %i5, 0
2008ab8: 22 80 00 0b be,a 2008ae4 <pthread_rwlock_timedwrlock+0xc4><== NEVER TAKEN
2008abc: b0 10 20 16 mov 0x16, %i0 <== NOT EXECUTED
return EINVAL;
if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST ||
2008ac0: ba 07 7f ff add %i5, -1, %i5
2008ac4: 80 a7 60 01 cmp %i5, 1
2008ac8: 08 80 00 07 bleu 2008ae4 <pthread_rwlock_timedwrlock+0xc4><== ALWAYS TAKEN
2008acc: b0 10 20 74 mov 0x74, %i0
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
return ETIMEDOUT;
}
return _POSIX_RWLock_Translate_core_RWLock_return_code(
(CORE_RWLock_Status) _Thread_Executing->Wait.return_code
2008ad0: 03 00 80 84 sethi %hi(0x2021000), %g1
2008ad4: c2 00 61 2c ld [ %g1 + 0x12c ], %g1 ! 202112c <_Per_CPU_Information+0xc>
if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST ||
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
return ETIMEDOUT;
}
return _POSIX_RWLock_Translate_core_RWLock_return_code(
2008ad8: 40 00 00 05 call 2008aec <_POSIX_RWLock_Translate_core_RWLock_return_code>
2008adc: d0 00 60 34 ld [ %g1 + 0x34 ], %o0
2008ae0: b0 10 00 08 mov %o0, %i0
case OBJECTS_ERROR:
break;
}
return EINVAL;
}
2008ae4: 81 c7 e0 08 ret
2008ae8: 81 e8 00 00 restore
02009278 <pthread_rwlockattr_setpshared>:
int pthread_rwlockattr_setpshared(
pthread_rwlockattr_t *attr,
int pshared
)
{
2009278: 82 10 00 08 mov %o0, %g1
if ( !attr )
200927c: 80 a0 60 00 cmp %g1, 0
2009280: 02 80 00 0a be 20092a8 <pthread_rwlockattr_setpshared+0x30>
2009284: 90 10 20 16 mov 0x16, %o0
return EINVAL;
if ( !attr->is_initialized )
2009288: c4 00 40 00 ld [ %g1 ], %g2
200928c: 80 a0 a0 00 cmp %g2, 0
2009290: 02 80 00 06 be 20092a8 <pthread_rwlockattr_setpshared+0x30>
2009294: 80 a2 60 01 cmp %o1, 1
return EINVAL;
switch ( pshared ) {
2009298: 18 80 00 04 bgu 20092a8 <pthread_rwlockattr_setpshared+0x30><== NEVER TAKEN
200929c: 01 00 00 00 nop
case PTHREAD_PROCESS_SHARED:
case PTHREAD_PROCESS_PRIVATE:
attr->process_shared = pshared;
20092a0: d2 20 60 04 st %o1, [ %g1 + 4 ]
return 0;
20092a4: 90 10 20 00 clr %o0
default:
return EINVAL;
}
}
20092a8: 81 c3 e0 08 retl
0200a2b0 <pthread_setschedparam>:
int pthread_setschedparam(
pthread_t thread,
int policy,
struct sched_param *param
)
{
200a2b0: 9d e3 bf 90 save %sp, -112, %sp
int rc;
/*
* Check all the parameters
*/
if ( !param )
200a2b4: 80 a6 a0 00 cmp %i2, 0
200a2b8: 02 80 00 40 be 200a3b8 <pthread_setschedparam+0x108>
200a2bc: b6 10 20 16 mov 0x16, %i3
return EINVAL;
rc = _POSIX_Thread_Translate_sched_param(
200a2c0: 90 10 00 19 mov %i1, %o0
200a2c4: 92 10 00 1a mov %i2, %o1
200a2c8: 94 07 bf f4 add %fp, -12, %o2
200a2cc: 40 00 17 6a call 2010074 <_POSIX_Thread_Translate_sched_param>
200a2d0: 96 07 bf f8 add %fp, -8, %o3
policy,
param,
&budget_algorithm,
&budget_callout
);
if ( rc )
200a2d4: b6 92 20 00 orcc %o0, 0, %i3
200a2d8: 32 80 00 39 bne,a 200a3bc <pthread_setschedparam+0x10c>
200a2dc: b0 10 00 1b mov %i3, %i0
return rc;
/*
* Actually change the scheduling policy and parameters
*/
the_thread = _Thread_Get( thread, &location );
200a2e0: 90 10 00 18 mov %i0, %o0
200a2e4: 40 00 0c 16 call 200d33c <_Thread_Get>
200a2e8: 92 07 bf fc add %fp, -4, %o1
switch ( location ) {
200a2ec: c2 07 bf fc ld [ %fp + -4 ], %g1
200a2f0: 80 a0 60 00 cmp %g1, 0
200a2f4: 12 80 00 30 bne 200a3b4 <pthread_setschedparam+0x104>
200a2f8: b8 10 00 08 mov %o0, %i4
case OBJECTS_LOCAL:
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
200a2fc: fa 02 21 5c ld [ %o0 + 0x15c ], %i5
if ( api->schedpolicy == SCHED_SPORADIC )
200a300: c2 07 60 84 ld [ %i5 + 0x84 ], %g1
200a304: 80 a0 60 04 cmp %g1, 4
200a308: 32 80 00 05 bne,a 200a31c <pthread_setschedparam+0x6c>
200a30c: f2 27 60 84 st %i1, [ %i5 + 0x84 ]
(void) _Watchdog_Remove( &api->Sporadic_timer );
200a310: 40 00 10 28 call 200e3b0 <_Watchdog_Remove>
200a314: 90 07 60 a8 add %i5, 0xa8, %o0
api->schedpolicy = policy;
200a318: f2 27 60 84 st %i1, [ %i5 + 0x84 ]
api->schedparam = *param;
200a31c: 90 07 60 88 add %i5, 0x88, %o0
200a320: 92 10 00 1a mov %i2, %o1
200a324: 40 00 24 31 call 20133e8 <memcpy>
200a328: 94 10 20 1c mov 0x1c, %o2
the_thread->budget_algorithm = budget_algorithm;
200a32c: c2 07 bf f4 ld [ %fp + -12 ], %g1
the_thread->budget_callout = budget_callout;
switch ( api->schedpolicy ) {
200a330: 80 a6 60 00 cmp %i1, 0
if ( api->schedpolicy == SCHED_SPORADIC )
(void) _Watchdog_Remove( &api->Sporadic_timer );
api->schedpolicy = policy;
api->schedparam = *param;
the_thread->budget_algorithm = budget_algorithm;
200a334: c2 27 20 78 st %g1, [ %i4 + 0x78 ]
the_thread->budget_callout = budget_callout;
200a338: c2 07 bf f8 ld [ %fp + -8 ], %g1
switch ( api->schedpolicy ) {
200a33c: 06 80 00 1b bl 200a3a8 <pthread_setschedparam+0xf8> <== NEVER TAKEN
200a340: c2 27 20 7c st %g1, [ %i4 + 0x7c ]
200a344: 80 a6 60 02 cmp %i1, 2
200a348: 04 80 00 07 ble 200a364 <pthread_setschedparam+0xb4>
200a34c: 03 00 80 8c sethi %hi(0x2023000), %g1
200a350: 80 a6 60 04 cmp %i1, 4
200a354: 12 80 00 15 bne 200a3a8 <pthread_setschedparam+0xf8> <== NEVER TAKEN
200a358: 01 00 00 00 nop
true
);
break;
case SCHED_SPORADIC:
api->ss_high_priority = api->schedparam.sched_priority;
200a35c: 10 80 00 0d b 200a390 <pthread_setschedparam+0xe0>
200a360: c2 07 60 88 ld [ %i5 + 0x88 ], %g1
switch ( api->schedpolicy ) {
case SCHED_OTHER:
case SCHED_FIFO:
case SCHED_RR:
the_thread->cpu_time_budget = _Thread_Ticks_per_timeslice;
200a364: c2 00 60 30 ld [ %g1 + 0x30 ], %g1
the_thread->real_priority =
_POSIX_Priority_To_core( api->schedparam.sched_priority );
_Thread_Change_priority(
200a368: 90 10 00 1c mov %i4, %o0
switch ( api->schedpolicy ) {
case SCHED_OTHER:
case SCHED_FIFO:
case SCHED_RR:
the_thread->cpu_time_budget = _Thread_Ticks_per_timeslice;
200a36c: c2 27 20 74 st %g1, [ %i4 + 0x74 ]
200a370: 03 00 80 88 sethi %hi(0x2022000), %g1
200a374: d2 08 62 c8 ldub [ %g1 + 0x2c8 ], %o1 ! 20222c8 <rtems_maximum_priority>
200a378: c2 07 60 88 ld [ %i5 + 0x88 ], %g1
the_thread->real_priority =
_POSIX_Priority_To_core( api->schedparam.sched_priority );
_Thread_Change_priority(
200a37c: 94 10 20 01 mov 1, %o2
200a380: 92 22 40 01 sub %o1, %g1, %o1
200a384: 40 00 0a bc call 200ce74 <_Thread_Change_priority>
200a388: d2 27 20 18 st %o1, [ %i4 + 0x18 ]
the_thread,
the_thread->real_priority,
true
);
break;
200a38c: 30 80 00 07 b,a 200a3a8 <pthread_setschedparam+0xf8>
case SCHED_SPORADIC:
api->ss_high_priority = api->schedparam.sched_priority;
_Watchdog_Remove( &api->Sporadic_timer );
200a390: 90 07 60 a8 add %i5, 0xa8, %o0
200a394: 40 00 10 07 call 200e3b0 <_Watchdog_Remove>
200a398: c2 27 60 a4 st %g1, [ %i5 + 0xa4 ]
_POSIX_Threads_Sporadic_budget_TSR( 0, the_thread );
200a39c: 90 10 20 00 clr %o0
200a3a0: 7f ff ff 7e call 200a198 <_POSIX_Threads_Sporadic_budget_TSR>
200a3a4: 92 10 00 1c mov %i4, %o1
break;
}
_Thread_Enable_dispatch();
200a3a8: 40 00 0b d8 call 200d308 <_Thread_Enable_dispatch>
200a3ac: b0 10 00 1b mov %i3, %i0
200a3b0: 30 80 00 03 b,a 200a3bc <pthread_setschedparam+0x10c>
#endif
case OBJECTS_ERROR:
break;
}
return ESRCH;
200a3b4: b6 10 20 03 mov 3, %i3
}
200a3b8: b0 10 00 1b mov %i3, %i0
200a3bc: 81 c7 e0 08 ret
200a3c0: 81 e8 00 00 restore
02007bdc <pthread_testcancel>:
/*
* 18.2.2 Setting Cancelability State, P1003.1c/Draft 10, p. 183
*/
void pthread_testcancel( void )
{
2007bdc: 9d e3 bf a0 save %sp, -96, %sp
* 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() )
2007be0: 03 00 80 7b sethi %hi(0x201ec00), %g1
2007be4: 82 10 62 80 or %g1, 0x280, %g1 ! 201ee80 <_Per_CPU_Information>
2007be8: c4 00 60 08 ld [ %g1 + 8 ], %g2
2007bec: 80 a0 a0 00 cmp %g2, 0
2007bf0: 12 80 00 18 bne 2007c50 <pthread_testcancel+0x74> <== NEVER TAKEN
2007bf4: 01 00 00 00 nop
return;
thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ];
2007bf8: c2 00 60 0c ld [ %g1 + 0xc ], %g1
2007bfc: c4 00 61 5c ld [ %g1 + 0x15c ], %g2
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
_Thread_Dispatch_disable_level++;
2007c00: 03 00 80 7a sethi %hi(0x201e800), %g1
2007c04: c6 00 61 50 ld [ %g1 + 0x150 ], %g3 ! 201e950 <_Thread_Dispatch_disable_level>
2007c08: 86 00 e0 01 inc %g3
2007c0c: c6 20 61 50 st %g3, [ %g1 + 0x150 ]
return _Thread_Dispatch_disable_level;
2007c10: c2 00 61 50 ld [ %g1 + 0x150 ], %g1
_Thread_Disable_dispatch();
if ( thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE &&
2007c14: c2 00 a0 d8 ld [ %g2 + 0xd8 ], %g1
2007c18: 80 a0 60 00 cmp %g1, 0
2007c1c: 12 80 00 05 bne 2007c30 <pthread_testcancel+0x54> <== NEVER TAKEN
2007c20: ba 10 20 00 clr %i5
2007c24: c2 00 a0 e0 ld [ %g2 + 0xe0 ], %g1
2007c28: 80 a0 00 01 cmp %g0, %g1
2007c2c: ba 40 20 00 addx %g0, 0, %i5
thread_support->cancelation_requested )
cancel = true;
_Thread_Enable_dispatch();
2007c30: 40 00 0b 9a call 200aa98 <_Thread_Enable_dispatch>
2007c34: 01 00 00 00 nop
if ( cancel )
2007c38: 80 8f 60 ff btst 0xff, %i5
2007c3c: 02 80 00 05 be 2007c50 <pthread_testcancel+0x74>
2007c40: 03 00 80 7b sethi %hi(0x201ec00), %g1
_POSIX_Thread_Exit( _Thread_Executing, PTHREAD_CANCELED );
2007c44: f0 00 62 8c ld [ %g1 + 0x28c ], %i0 ! 201ee8c <_Per_CPU_Information+0xc>
2007c48: 40 00 17 1f call 200d8c4 <_POSIX_Thread_Exit>
2007c4c: 93 e8 3f ff restore %g0, -1, %o1
2007c50: 81 c7 e0 08 ret
2007c54: 81 e8 00 00 restore
0200c960 <ramdisk_allocate>:
void *area_begin,
uint32_t block_size,
rtems_blkdev_bnum block_count,
bool trace
)
{
200c960: 9d e3 bf a0 save %sp, -96, %sp
struct ramdisk *rd = malloc(sizeof(struct ramdisk));
200c964: 7f ff e1 8f call 2004fa0 <malloc>
200c968: 90 10 20 10 mov 0x10, %o0
if (rd == NULL) {
200c96c: ba 92 20 00 orcc %o0, 0, %i5
200c970: 02 80 00 16 be 200c9c8 <ramdisk_allocate+0x68> <== NEVER TAKEN
200c974: 80 a6 20 00 cmp %i0, 0
return NULL;
}
if (area_begin == NULL) {
200c978: 32 80 00 0e bne,a 200c9b0 <ramdisk_allocate+0x50>
200c97c: c0 2f 60 0d clrb [ %i5 + 0xd ]
area_begin = calloc(block_count, block_size);
200c980: 90 10 00 1a mov %i2, %o0
200c984: 7f ff df 5c call 20046f4 <calloc>
200c988: 92 10 00 19 mov %i1, %o1
if (area_begin == NULL) {
200c98c: b0 92 20 00 orcc %o0, 0, %i0
200c990: 12 80 00 07 bne 200c9ac <ramdisk_allocate+0x4c> <== ALWAYS TAKEN
200c994: 82 10 20 01 mov 1, %g1
free(rd);
200c998: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
200c99c: 7f ff e0 2b call 2004a48 <free> <== NOT EXECUTED
200c9a0: ba 10 20 00 clr %i5 <== NOT EXECUTED
return NULL;
200c9a4: 81 c7 e0 08 ret <== NOT EXECUTED
200c9a8: 91 e8 00 1d restore %g0, %i5, %o0 <== NOT EXECUTED
200c9ac: c2 2f 60 0d stb %g1, [ %i5 + 0xd ]
}
rd->block_size = block_size;
rd->block_num = block_count;
rd->area = area_begin;
rd->trace = trace;
rd->initialized = true;
200c9b0: 82 10 20 01 mov 1, %g1
}
rd->malloced = true;
} else {
rd->malloced = false;
}
rd->block_size = block_size;
200c9b4: f2 27 40 00 st %i1, [ %i5 ]
rd->block_num = block_count;
200c9b8: f4 27 60 04 st %i2, [ %i5 + 4 ]
rd->area = area_begin;
200c9bc: f0 27 60 08 st %i0, [ %i5 + 8 ]
rd->trace = trace;
200c9c0: f6 2f 60 0e stb %i3, [ %i5 + 0xe ]
rd->initialized = true;
200c9c4: c2 2f 60 0c stb %g1, [ %i5 + 0xc ]
return rd;
}
200c9c8: b0 10 00 1d mov %i5, %i0
200c9cc: 81 c7 e0 08 ret
200c9d0: 81 e8 00 00 restore
0200c9d4 <ramdisk_free>:
void ramdisk_free(ramdisk *rd)
{
200c9d4: 9d e3 bf a0 save %sp, -96, %sp
if (rd != NULL) {
200c9d8: 80 a6 20 00 cmp %i0, 0
200c9dc: 02 80 00 0a be 200ca04 <ramdisk_free+0x30> <== NEVER TAKEN
200c9e0: 01 00 00 00 nop
if (rd->malloced) {
200c9e4: c2 0e 20 0d ldub [ %i0 + 0xd ], %g1
200c9e8: 80 a0 60 00 cmp %g1, 0
200c9ec: 02 80 00 04 be 200c9fc <ramdisk_free+0x28>
200c9f0: 01 00 00 00 nop
free(rd->area);
200c9f4: 7f ff e0 15 call 2004a48 <free>
200c9f8: d0 06 20 08 ld [ %i0 + 8 ], %o0
}
free(rd);
200c9fc: 7f ff e0 13 call 2004a48 <free>
200ca00: 81 e8 00 00 restore
200ca04: 81 c7 e0 08 ret <== NOT EXECUTED
200ca08: 81 e8 00 00 restore <== NOT EXECUTED
020213cc <ramdisk_initialize>:
rtems_device_driver
ramdisk_initialize(
rtems_device_major_number major,
rtems_device_minor_number minor __attribute__((unused)),
void *arg __attribute__((unused)))
{
20213cc: 9d e3 bf 88 save %sp, -120, %sp
rtems_device_minor_number i;
rtems_ramdisk_config *c = rtems_ramdisk_configuration;
struct ramdisk *r;
rtems_status_code rc;
rc = rtems_disk_io_initialize();
20213d0: 7f ff 9a b1 call 2007e94 <rtems_disk_io_initialize>
20213d4: a8 10 00 18 mov %i0, %l4
if (rc != RTEMS_SUCCESSFUL)
20213d8: b0 92 20 00 orcc %o0, 0, %i0
20213dc: 12 80 00 46 bne 20214f4 <ramdisk_initialize+0x128> <== NEVER TAKEN
20213e0: 3b 00 81 ac sethi %hi(0x206b000), %i5
* This is allocating memory for a RAM disk which will persist for
* the life of the system. RTEMS has no "de-initialize" driver call
* so there is no corresponding free(r). Coverity is correct that
* it is never freed but this is not a problem.
*/
r = calloc(rtems_ramdisk_configuration_size, sizeof(struct ramdisk));
20213e4: d0 07 62 dc ld [ %i5 + 0x2dc ], %o0 ! 206b2dc <rtems_ramdisk_configuration_size>
20213e8: 92 10 20 10 mov 0x10, %o1
20213ec: 7f ff 9d 20 call 200886c <calloc>
20213f0: 33 00 81 ac sethi %hi(0x206b000), %i1
r->trace = false;
for (i = 0; i < rtems_ramdisk_configuration_size; i++, c++, r++)
20213f4: a6 10 00 1d mov %i5, %l3
{
dev_t dev = rtems_filesystem_make_dev_t(major, i);
char name [] = RAMDISK_DEVICE_BASE_NAME "a";
20213f8: 39 0b d9 19 sethi %hi(0x2f646400), %i4
20213fc: 3b 0b dc 99 sethi %hi(0x2f726400), %i5
{
r->malloced = false;
r->initialized = true;
r->area = c->location;
}
rc = rtems_disk_create_phys(dev, c->block_size, c->block_num,
2021400: 2b 00 80 85 sethi %hi(0x2021400), %l5
* This is allocating memory for a RAM disk which will persist for
* the life of the system. RTEMS has no "de-initialize" driver call
* so there is no corresponding free(r). Coverity is correct that
* it is never freed but this is not a problem.
*/
r = calloc(rtems_ramdisk_configuration_size, sizeof(struct ramdisk));
2021404: b6 10 00 08 mov %o0, %i3
r->trace = false;
2021408: c0 2a 20 0e clrb [ %o0 + 0xe ]
rtems_device_major_number major,
rtems_device_minor_number minor __attribute__((unused)),
void *arg __attribute__((unused)))
{
rtems_device_minor_number i;
rtems_ramdisk_config *c = rtems_ramdisk_configuration;
202140c: b2 16 62 e0 or %i1, 0x2e0, %i1
* so there is no corresponding free(r). Coverity is correct that
* it is never freed but this is not a problem.
*/
r = calloc(rtems_ramdisk_configuration_size, sizeof(struct ramdisk));
r->trace = false;
for (i = 0; i < rtems_ramdisk_configuration_size; i++, c++, r++)
2021410: b4 10 20 00 clr %i2
{
dev_t dev = rtems_filesystem_make_dev_t(major, i);
char name [] = RAMDISK_DEVICE_BASE_NAME "a";
2021414: b8 17 21 76 or %i4, 0x176, %i4
2021418: ba 17 60 61 or %i5, 0x61, %i5
r->malloced = false;
r->initialized = true;
r->area = c->location;
}
rc = rtems_disk_create_phys(dev, c->block_size, c->block_num,
ramdisk_ioctl, r, name);
202141c: b0 07 bf f0 add %fp, -16, %i0
{
r->malloced = false;
r->initialized = true;
r->area = c->location;
}
rc = rtems_disk_create_phys(dev, c->block_size, c->block_num,
2021420: aa 15 60 fc or %l5, 0xfc, %l5
* so there is no corresponding free(r). Coverity is correct that
* it is never freed but this is not a problem.
*/
r = calloc(rtems_ramdisk_configuration_size, sizeof(struct ramdisk));
r->trace = false;
for (i = 0; i < rtems_ramdisk_configuration_size; i++, c++, r++)
2021424: 10 80 00 2f b 20214e0 <ramdisk_initialize+0x114>
2021428: a0 10 20 01 mov 1, %l0
{
dev_t dev = rtems_filesystem_make_dev_t(major, i);
char name [] = RAMDISK_DEVICE_BASE_NAME "a";
name [sizeof(RAMDISK_DEVICE_BASE_NAME)] += i;
202142c: f4 2f bf f8 stb %i2, [ %fp + -8 ]
r->block_size = c->block_size;
2021430: e4 06 40 00 ld [ %i1 ], %l2
r->block_num = c->block_num;
2021434: e2 06 60 04 ld [ %i1 + 4 ], %l1
if (c->location == NULL)
2021438: c2 06 60 08 ld [ %i1 + 8 ], %g1
for (i = 0; i < rtems_ramdisk_configuration_size; i++, c++, r++)
{
dev_t dev = rtems_filesystem_make_dev_t(major, i);
char name [] = RAMDISK_DEVICE_BASE_NAME "a";
name [sizeof(RAMDISK_DEVICE_BASE_NAME)] += i;
r->block_size = c->block_size;
202143c: e4 26 c0 00 st %l2, [ %i3 ]
r->block_num = c->block_num;
if (c->location == NULL)
2021440: 80 a0 60 00 cmp %g1, 0
2021444: 12 80 00 0f bne 2021480 <ramdisk_initialize+0xb4> <== NEVER TAKEN
2021448: e2 26 e0 04 st %l1, [ %i3 + 4 ]
{
r->malloced = true;
r->area = malloc(r->block_size * r->block_num);
202144c: 92 10 00 12 mov %l2, %o1
name [sizeof(RAMDISK_DEVICE_BASE_NAME)] += i;
r->block_size = c->block_size;
r->block_num = c->block_num;
if (c->location == NULL)
{
r->malloced = true;
2021450: e0 2e e0 0d stb %l0, [ %i3 + 0xd ]
r->area = malloc(r->block_size * r->block_num);
2021454: 7f ff 86 84 call 2002e64 <.umul>
2021458: 90 10 00 11 mov %l1, %o0
202145c: 7f ff 9f 46 call 2009174 <malloc>
2021460: 01 00 00 00 nop
if (r->area == NULL) /* No enough memory for this disk */
2021464: 80 a2 20 00 cmp %o0, 0
2021468: 12 80 00 04 bne 2021478 <ramdisk_initialize+0xac> <== ALWAYS TAKEN
202146c: d0 26 e0 08 st %o0, [ %i3 + 8 ]
{
if (r->malloced)
{
free(r->area);
}
r->initialized = false;
2021470: 10 80 00 19 b 20214d4 <ramdisk_initialize+0x108> <== NOT EXECUTED
2021474: c0 2e e0 0c clrb [ %i3 + 0xc ] <== NOT EXECUTED
r->initialized = false;
continue;
}
else
{
r->initialized = true;
2021478: 10 80 00 05 b 202148c <ramdisk_initialize+0xc0>
202147c: e0 2e e0 0c stb %l0, [ %i3 + 0xc ]
}
}
else
{
r->malloced = false;
2021480: c0 2e e0 0d clrb [ %i3 + 0xd ] <== NOT EXECUTED
r->initialized = true;
2021484: e0 2e e0 0c stb %l0, [ %i3 + 0xc ] <== NOT EXECUTED
r->area = c->location;
2021488: c2 26 e0 08 st %g1, [ %i3 + 8 ] <== NOT EXECUTED
}
rc = rtems_disk_create_phys(dev, c->block_size, c->block_num,
202148c: f0 23 a0 5c st %i0, [ %sp + 0x5c ]
2021490: 90 10 00 14 mov %l4, %o0
2021494: 92 10 00 1a mov %i2, %o1
2021498: 94 10 00 12 mov %l2, %o2
202149c: 96 10 00 11 mov %l1, %o3
20214a0: 98 10 00 15 mov %l5, %o4
20214a4: 7f ff 99 e6 call 2007c3c <rtems_disk_create_phys>
20214a8: 9a 10 00 1b mov %i3, %o5
ramdisk_ioctl, r, name);
if (rc != RTEMS_SUCCESSFUL)
20214ac: 80 a2 20 00 cmp %o0, 0
20214b0: 22 80 00 0a be,a 20214d8 <ramdisk_initialize+0x10c> <== ALWAYS TAKEN
20214b4: b4 06 a0 01 inc %i2
{
if (r->malloced)
20214b8: c2 0e e0 0d ldub [ %i3 + 0xd ], %g1 <== NOT EXECUTED
20214bc: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
20214c0: 22 80 00 05 be,a 20214d4 <ramdisk_initialize+0x108> <== NOT EXECUTED
20214c4: c0 2e e0 0c clrb [ %i3 + 0xc ] <== NOT EXECUTED
{
free(r->area);
20214c8: 7f ff 9d cd call 2008bfc <free> <== NOT EXECUTED
20214cc: d0 06 e0 08 ld [ %i3 + 8 ], %o0 <== NOT EXECUTED
}
r->initialized = false;
20214d0: c0 2e e0 0c clrb [ %i3 + 0xc ] <== NOT EXECUTED
* so there is no corresponding free(r). Coverity is correct that
* it is never freed but this is not a problem.
*/
r = calloc(rtems_ramdisk_configuration_size, sizeof(struct ramdisk));
r->trace = false;
for (i = 0; i < rtems_ramdisk_configuration_size; i++, c++, r++)
20214d4: b4 06 a0 01 inc %i2 <== NOT EXECUTED
20214d8: b2 06 60 0c add %i1, 0xc, %i1
20214dc: b6 06 e0 10 add %i3, 0x10, %i3
20214e0: c2 04 e2 dc ld [ %l3 + 0x2dc ], %g1
20214e4: 80 a6 80 01 cmp %i2, %g1
20214e8: 2a bf ff d1 bcs,a 202142c <ramdisk_initialize+0x60>
20214ec: f8 3f bf f0 std %i4, [ %fp + -16 ]
free(r->area);
}
r->initialized = false;
}
}
return RTEMS_SUCCESSFUL;
20214f0: b0 10 20 00 clr %i0
}
20214f4: 81 c7 e0 08 ret
20214f8: 81 e8 00 00 restore
0200c830 <ramdisk_ioctl>:
return 0;
}
int
ramdisk_ioctl(rtems_disk_device *dd, uint32_t req, void *argp)
{
200c830: 9d e3 bf a0 save %sp, -96, %sp
struct ramdisk *rd = rtems_disk_get_driver_data(dd);
switch (req)
200c834: 05 08 00 10 sethi %hi(0x20004000), %g2
return 0;
}
int
ramdisk_ioctl(rtems_disk_device *dd, uint32_t req, void *argp)
{
200c838: ba 10 00 1a mov %i2, %i5
struct ramdisk *rd = rtems_disk_get_driver_data(dd);
switch (req)
200c83c: 84 10 a2 07 or %g2, 0x207, %g2
200c840: 80 a6 40 02 cmp %i1, %g2
200c844: 02 80 00 38 be 200c924 <ramdisk_ioctl+0xf4>
200c848: f8 06 20 3c ld [ %i0 + 0x3c ], %i4
200c84c: 05 30 06 10 sethi %hi(0xc0184000), %g2
200c850: 84 10 a2 01 or %g2, 0x201, %g2 ! c0184201 <RAM_END+0xbdd84201>
200c854: 80 a6 40 02 cmp %i1, %g2
200c858: 12 80 00 3a bne 200c940 <ramdisk_ioctl+0x110>
200c85c: 01 00 00 00 nop
{
case RTEMS_BLKIO_REQUEST:
{
rtems_blkdev_request *r = argp;
switch (r->req)
200c860: c2 06 80 00 ld [ %i2 ], %g1
200c864: 80 a0 60 00 cmp %g1, 0
200c868: 02 80 00 07 be 200c884 <ramdisk_ioctl+0x54>
200c86c: b6 06 a0 18 add %i2, 0x18, %i3
200c870: 80 a0 60 01 cmp %g1, 1
200c874: 12 80 00 35 bne 200c948 <ramdisk_ioctl+0x118> <== NEVER TAKEN
200c878: 01 00 00 00 nop
}
static int
ramdisk_write(struct ramdisk *rd, rtems_blkdev_request *req)
{
uint8_t *to = rd->area;
200c87c: 10 80 00 14 b 200c8cc <ramdisk_ioctl+0x9c>
200c880: f2 07 20 08 ld [ %i4 + 8 ], %i1
#endif
static int
ramdisk_read(struct ramdisk *rd, rtems_blkdev_request *req)
{
uint8_t *from = rd->area;
200c884: f2 07 20 08 ld [ %i4 + 8 ], %i1
#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++)
200c888: 10 80 00 0b b 200c8b4 <ramdisk_ioctl+0x84>
200c88c: b4 10 20 00 clr %i2
#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);
200c890: d2 07 00 00 ld [ %i4 ], %o1
200c894: 40 00 3f ec call 201c844 <.umul>
200c898: f0 06 e0 08 ld [ %i3 + 8 ], %i0
200c89c: d4 06 e0 04 ld [ %i3 + 4 ], %o2
200c8a0: 92 06 40 08 add %i1, %o0, %o1
#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++)
200c8a4: b4 06 a0 01 inc %i2
#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);
200c8a8: 90 10 00 18 mov %i0, %o0
200c8ac: 40 00 1f 01 call 20144b0 <memcpy>
200c8b0: b6 06 e0 10 add %i3, 0x10, %i3
#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++)
200c8b4: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
200c8b8: 80 a6 80 01 cmp %i2, %g1
200c8bc: 2a bf ff f5 bcs,a 200c890 <ramdisk_ioctl+0x60>
200c8c0: d0 06 c0 00 ld [ %i3 ], %o0
to + (sg->block * rd->block_size));
#endif
memcpy(to + (sg->block * rd->block_size), sg->buffer, sg->length);
}
req->status = RTEMS_SUCCESSFUL;
req->req_done(req->done_arg, RTEMS_SUCCESSFUL);
200c8c4: 10 80 00 11 b 200c908 <ramdisk_ioctl+0xd8>
200c8c8: c2 07 60 04 ld [ %i5 + 4 ], %g1
#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++)
200c8cc: 10 80 00 0a b 200c8f4 <ramdisk_ioctl+0xc4>
200c8d0: b4 10 20 00 clr %i2
#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);
200c8d4: d2 07 00 00 ld [ %i4 ], %o1
200c8d8: 40 00 3f db call 201c844 <.umul>
200c8dc: b4 06 a0 01 inc %i2
200c8e0: d2 06 e0 08 ld [ %i3 + 8 ], %o1
200c8e4: d4 06 e0 04 ld [ %i3 + 4 ], %o2
200c8e8: 90 06 40 08 add %i1, %o0, %o0
200c8ec: 40 00 1e f1 call 20144b0 <memcpy>
200c8f0: b6 06 e0 10 add %i3, 0x10, %i3
#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++)
200c8f4: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
200c8f8: 80 a6 80 01 cmp %i2, %g1
200c8fc: 2a bf ff f6 bcs,a 200c8d4 <ramdisk_ioctl+0xa4>
200c900: d0 06 c0 00 ld [ %i3 ], %o0
to + (sg->block * rd->block_size));
#endif
memcpy(to + (sg->block * rd->block_size), sg->buffer, sg->length);
}
req->status = RTEMS_SUCCESSFUL;
req->req_done(req->done_arg, RTEMS_SUCCESSFUL);
200c904: c2 07 60 04 ld [ %i5 + 4 ], %g1
200c908: d0 07 60 08 ld [ %i5 + 8 ], %o0
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;
200c90c: c0 27 60 0c clr [ %i5 + 0xc ]
req->req_done(req->done_arg, RTEMS_SUCCESSFUL);
200c910: 92 10 20 00 clr %o1
200c914: 9f c0 40 00 call %g1
200c918: b0 10 20 00 clr %i0
{
case RTEMS_BLKDEV_REQ_READ:
return ramdisk_read(rd, r);
case RTEMS_BLKDEV_REQ_WRITE:
return ramdisk_write(rd, r);
200c91c: 81 c7 e0 08 ret
200c920: 81 e8 00 00 restore
}
break;
}
case RTEMS_BLKIO_DELETED:
if (rd->free_at_delete_request) {
200c924: c2 0f 20 0f ldub [ %i4 + 0xf ], %g1
200c928: 80 a0 60 00 cmp %g1, 0
200c92c: 02 80 00 07 be 200c948 <ramdisk_ioctl+0x118>
200c930: 01 00 00 00 nop
ramdisk_free(rd);
200c934: 40 00 00 28 call 200c9d4 <ramdisk_free>
200c938: 90 10 00 1c mov %i4, %o0
200c93c: 30 80 00 03 b,a 200c948 <ramdisk_ioctl+0x118>
}
break;
default:
return rtems_blkdev_ioctl (dd, req, argp);
200c940: 40 00 0a 0d call 200f174 <rtems_blkdev_ioctl>
200c944: 81 e8 00 00 restore
break;
}
errno = EINVAL;
200c948: 40 00 1c 93 call 2013b94 <__errno>
200c94c: b0 10 3f ff mov -1, %i0
200c950: 82 10 20 16 mov 0x16, %g1
200c954: c2 22 00 00 st %g1, [ %o0 ]
return -1;
}
200c958: 81 c7 e0 08 ret
200c95c: 81 e8 00 00 restore
0200ca0c <ramdisk_register>:
rtems_blkdev_bnum block_count,
bool trace,
const char *disk,
dev_t *dev_ptr
)
{
200ca0c: 9d e3 bf 90 save %sp, -112, %sp
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);
200ca10: 90 10 20 00 clr %o0
const char *disk,
dev_t *dev_ptr
)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_device_major_number major = 0;
200ca14: c0 27 bf fc clr [ %fp + -4 ]
ramdisk *rd = NULL;
dev_t dev = 0;
sc = rtems_io_register_driver(0, &ramdisk_ops, &major);
200ca18: 13 00 80 7e sethi %hi(0x201f800), %o1
200ca1c: 94 07 bf fc add %fp, -4, %o2
200ca20: 92 12 63 e0 or %o1, 0x3e0, %o1
200ca24: 7f ff f2 9c call 2009494 <rtems_io_register_driver>
200ca28: a0 10 20 0d mov 0xd, %l0
if (sc != RTEMS_SUCCESSFUL) {
200ca2c: 80 a2 20 00 cmp %o0, 0
200ca30: 32 80 00 20 bne,a 200cab0 <ramdisk_register+0xa4> <== NEVER TAKEN
200ca34: b0 10 00 10 mov %l0, %i0 <== NOT EXECUTED
return RTEMS_UNSATISFIED;
}
rd = ramdisk_allocate(NULL, block_size, block_count, trace);
200ca38: 96 10 00 1a mov %i2, %o3
200ca3c: 92 10 00 18 mov %i0, %o1
200ca40: 7f ff ff c8 call 200c960 <ramdisk_allocate>
200ca44: 94 10 00 19 mov %i1, %o2
if (rd == NULL) {
200ca48: b4 92 20 00 orcc %o0, 0, %i2
200ca4c: 12 80 00 04 bne 200ca5c <ramdisk_register+0x50> <== ALWAYS TAKEN
200ca50: fa 07 bf fc ld [ %fp + -4 ], %i5
rtems_io_unregister_driver(major);
200ca54: 10 80 00 11 b 200ca98 <ramdisk_register+0x8c> <== NOT EXECUTED
200ca58: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
return RTEMS_UNSATISFIED;
}
dev = rtems_filesystem_make_dev_t(major, 0);
sc = rtems_disk_create_phys(
200ca5c: f6 23 a0 5c st %i3, [ %sp + 0x5c ]
200ca60: 90 10 00 1d mov %i5, %o0
200ca64: 92 10 20 00 clr %o1
200ca68: 94 10 00 18 mov %i0, %o2
200ca6c: 96 10 00 19 mov %i1, %o3
200ca70: 19 00 80 32 sethi %hi(0x200c800), %o4
200ca74: 9a 10 00 1a mov %i2, %o5
200ca78: 7f ff dc 76 call 2003c50 <rtems_disk_create_phys>
200ca7c: 98 13 20 30 or %o4, 0x30, %o4
block_count,
ramdisk_ioctl,
rd,
disk
);
if (sc != RTEMS_SUCCESSFUL) {
200ca80: 80 a2 20 00 cmp %o0, 0
200ca84: 22 80 00 08 be,a 200caa4 <ramdisk_register+0x98> <== ALWAYS TAKEN
200ca88: fa 27 00 00 st %i5, [ %i4 ]
ramdisk_free(rd);
200ca8c: 7f ff ff d2 call 200c9d4 <ramdisk_free> <== NOT EXECUTED
200ca90: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
rtems_io_unregister_driver(major);
200ca94: d0 07 bf fc ld [ %fp + -4 ], %o0 <== NOT EXECUTED
200ca98: 7f ff f2 df call 2009614 <rtems_io_unregister_driver> <== NOT EXECUTED
200ca9c: b0 10 00 10 mov %l0, %i0 <== NOT EXECUTED
200caa0: 30 80 00 04 b,a 200cab0 <ramdisk_register+0xa4> <== NOT EXECUTED
return RTEMS_UNSATISFIED;
}
*dev_ptr = dev;
200caa4: c0 27 20 04 clr [ %i4 + 4 ]
return RTEMS_SUCCESSFUL;
200caa8: a0 10 20 00 clr %l0
}
200caac: b0 10 00 10 mov %l0, %i0
200cab0: 81 c7 e0 08 ret
200cab4: 81 e8 00 00 restore
0201a1a4 <read>:
ssize_t read(
int fd,
void *buffer,
size_t count
)
{
201a1a4: 9d e3 bf a0 save %sp, -96, %sp
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
201a1a8: 03 00 80 73 sethi %hi(0x201cc00), %g1
201a1ac: c2 00 62 20 ld [ %g1 + 0x220 ], %g1 ! 201ce20 <rtems_libio_number_iops>
201a1b0: 80 a6 00 01 cmp %i0, %g1
201a1b4: 1a 80 00 16 bcc 201a20c <read+0x68>
201a1b8: 83 2e 20 03 sll %i0, 3, %g1
iop = rtems_libio_iop( fd );
201a1bc: b1 2e 20 06 sll %i0, 6, %i0
201a1c0: b0 26 00 01 sub %i0, %g1, %i0
201a1c4: 03 00 80 76 sethi %hi(0x201d800), %g1
201a1c8: d0 00 61 40 ld [ %g1 + 0x140 ], %o0 ! 201d940 <rtems_libio_iops>
201a1cc: 90 02 00 18 add %o0, %i0, %o0
rtems_libio_check_is_open( iop );
201a1d0: c2 02 20 10 ld [ %o0 + 0x10 ], %g1
201a1d4: 80 88 61 00 btst 0x100, %g1
201a1d8: 02 80 00 0d be 201a20c <read+0x68>
201a1dc: 80 a6 60 00 cmp %i1, 0
rtems_libio_check_buffer( buffer );
201a1e0: 12 80 00 06 bne 201a1f8 <read+0x54> <== ALWAYS TAKEN
201a1e4: 80 a6 a0 00 cmp %i2, 0
201a1e8: 7f ff d6 0a call 200fa10 <__errno> <== NOT EXECUTED
201a1ec: 01 00 00 00 nop <== NOT EXECUTED
201a1f0: 10 80 00 0a b 201a218 <read+0x74> <== NOT EXECUTED
201a1f4: 82 10 20 16 mov 0x16, %g1 ! 16 <PROM_START+0x16> <== NOT EXECUTED
rtems_libio_check_count( count );
201a1f8: 02 80 00 10 be 201a238 <read+0x94>
201a1fc: b0 10 20 00 clr %i0
rtems_libio_check_permissions_with_error( iop, LIBIO_FLAGS_READ, EBADF );
201a200: 80 88 60 02 btst 2, %g1
201a204: 32 80 00 08 bne,a 201a224 <read+0x80>
201a208: c2 02 20 24 ld [ %o0 + 0x24 ], %g1
201a20c: 7f ff d6 01 call 200fa10 <__errno>
201a210: 01 00 00 00 nop
201a214: 82 10 20 09 mov 9, %g1 ! 9 <PROM_START+0x9>
201a218: c2 22 00 00 st %g1, [ %o0 ]
201a21c: 81 c7 e0 08 ret
201a220: 91 e8 3f ff restore %g0, -1, %o0
/*
* Now process the read().
*/
return (*iop->pathinfo.handlers->read_h)( iop, buffer, count );
201a224: 92 10 00 19 mov %i1, %o1
201a228: c2 00 60 08 ld [ %g1 + 8 ], %g1
201a22c: 9f c0 40 00 call %g1
201a230: 94 10 00 1a mov %i2, %o2
201a234: b0 10 00 08 mov %o0, %i0
}
201a238: 81 c7 e0 08 ret
201a23c: 81 e8 00 00 restore
02004bf0 <read_extended_partition>:
* RTEMS_NO_MEMOTY if cannot allocate memory for part_desc_t strucure,
* RTEMS_INTERNAL_ERROR if other error occurs.
*/
static rtems_status_code
read_extended_partition(int fd, uint32_t start, rtems_part_desc_t *ext_part)
{
2004bf0: 9d e3 bf 98 save %sp, -104, %sp
int i;
rtems_sector_data_t *sector = NULL;
2004bf4: c0 27 bf f8 clr [ %fp + -8 ]
uint32_t here;
uint8_t *data;
rtems_part_desc_t *new_part_desc;
rtems_status_code rc;
if ((ext_part == NULL) || (ext_part->disk_desc == NULL))
2004bf8: 80 a6 a0 00 cmp %i2, 0
2004bfc: 02 80 00 61 be 2004d80 <read_extended_partition+0x190> <== NEVER TAKEN
2004c00: ba 10 20 19 mov 0x19, %i5
2004c04: c2 06 a0 10 ld [ %i2 + 0x10 ], %g1
2004c08: 80 a0 60 00 cmp %g1, 0
2004c0c: 02 80 00 5d be 2004d80 <read_extended_partition+0x190> <== NEVER TAKEN
2004c10: 90 10 00 18 mov %i0, %o0
{
return RTEMS_INTERNAL_ERROR;
}
/* get start sector of current extended partition */
here = ext_part->start;
2004c14: f6 06 a0 04 ld [ %i2 + 4 ], %i3
if (sector == NULL)
{
return RTEMS_INTERNAL_ERROR;
}
off = sector_num * RTEMS_IDE_SECTOR_SIZE;
2004c18: bb 2e e0 09 sll %i3, 9, %i5
new_off = lseek(fd, off, SEEK_SET);
2004c1c: 92 10 20 00 clr %o1
2004c20: 94 10 00 1d mov %i5, %o2
2004c24: 40 00 04 c5 call 2005f38 <lseek>
2004c28: 96 10 20 00 clr %o3
if (new_off != off) {
2004c2c: 80 a2 20 00 cmp %o0, 0
2004c30: 32 80 00 0e bne,a 2004c68 <read_extended_partition+0x78> <== NEVER TAKEN
2004c34: ba 10 20 1b mov 0x1b, %i5 <== NOT EXECUTED
2004c38: 80 a2 40 1d cmp %o1, %i5
2004c3c: 12 80 00 0b bne 2004c68 <read_extended_partition+0x78> <== NEVER TAKEN
2004c40: ba 10 20 1b mov 0x1b, %i5
2004c44: 90 10 00 18 mov %i0, %o0
2004c48: 92 10 00 1b mov %i3, %o1
2004c4c: 7f ff ff a2 call 2004ad4 <get_sector.part.0>
2004c50: 94 07 bf f8 add %fp, -8, %o2
here = ext_part->start;
/* get first extended partition sector */
rc = get_sector(fd, here, §or);
if (rc != RTEMS_SUCCESSFUL)
2004c54: ba 92 20 00 orcc %o0, 0, %i5
2004c58: 02 80 00 09 be 2004c7c <read_extended_partition+0x8c> <== ALWAYS TAKEN
2004c5c: d0 07 bf f8 ld [ %fp + -8 ], %o0
{
if (sector)
2004c60: 10 80 00 04 b 2004c70 <read_extended_partition+0x80> <== NOT EXECUTED
2004c64: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2004c68: d0 07 bf f8 ld [ %fp + -8 ], %o0 <== NOT EXECUTED
2004c6c: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2004c70: 22 80 00 45 be,a 2004d84 <read_extended_partition+0x194> <== NOT EXECUTED
2004c74: b0 10 00 1d mov %i5, %i0 <== NOT EXECUTED
2004c78: 30 80 00 40 b,a 2004d78 <read_extended_partition+0x188> <== NOT EXECUTED
static bool
msdos_signature_check (rtems_sector_data_t *sector)
{
uint8_t *p = sector->data + RTEMS_IDE_PARTITION_MSDOS_SIGNATURE_OFFSET;
return ((p[0] == RTEMS_IDE_PARTITION_MSDOS_SIGNATURE_DATA1) &&
2004c7c: c6 0a 22 02 ldub [ %o0 + 0x202 ], %g3
2004c80: 80 a0 e0 55 cmp %g3, 0x55
2004c84: 12 80 00 06 bne 2004c9c <read_extended_partition+0xac> <== NEVER TAKEN
2004c88: 84 10 20 00 clr %g2
2004c8c: c4 0a 22 03 ldub [ %o0 + 0x203 ], %g2
2004c90: 84 18 a0 aa xor %g2, 0xaa, %g2
2004c94: 80 a0 00 02 cmp %g0, %g2
2004c98: 84 60 3f ff subx %g0, -1, %g2
if (sector)
free(sector);
return rc;
}
if (!msdos_signature_check(sector))
2004c9c: 80 a0 a0 00 cmp %g2, 0
2004ca0: 12 80 00 06 bne 2004cb8 <read_extended_partition+0xc8> <== ALWAYS TAKEN
2004ca4: a0 02 21 d2 add %o0, 0x1d2, %l0
{
free(sector);
2004ca8: 40 00 03 83 call 2005ab4 <free> <== NOT EXECUTED
2004cac: ba 10 20 19 mov 0x19, %i5 <== NOT EXECUTED
}
free(sector);
return RTEMS_SUCCESSFUL;
}
2004cb0: 81 c7 e0 08 ret <== NOT EXECUTED
2004cb4: 91 e8 00 1d restore %g0, %i5, %o0 <== NOT EXECUTED
2004cb8: b8 10 00 1a mov %i2, %i4
* RTEMS_SUCCESSFUL if success,
* RTEMS_NO_MEMOTY if cannot allocate memory for part_desc_t strucure,
* RTEMS_INTERNAL_ERROR if other error occurs.
*/
static rtems_status_code
read_extended_partition(int fd, uint32_t start, rtems_part_desc_t *ext_part)
2004cbc: a2 06 a0 10 add %i2, 0x10, %l1
2004cc0: 90 04 3f f0 add %l0, -16, %o0
2004cc4: 7f ff ff 9a call 2004b2c <data_to_part_desc.part.1>
2004cc8: 92 07 bf fc add %fp, -4, %o1
{
/* if data_to_part_desc fails skip this partition
* and parse the next one
*/
rc = data_to_part_desc(data, &new_part_desc);
if (rc != RTEMS_SUCCESSFUL)
2004ccc: ba 92 20 00 orcc %o0, 0, %i5
2004cd0: 02 80 00 04 be 2004ce0 <read_extended_partition+0xf0> <== ALWAYS TAKEN
2004cd4: d4 07 bf fc ld [ %fp + -4 ], %o2
new_part_desc->end = new_part_desc->start + new_part_desc->size - 1;
}
data += RTEMS_IDE_PARTITION_DESCRIPTOR_SIZE;
}
free(sector);
2004cd8: 10 80 00 28 b 2004d78 <read_extended_partition+0x188> <== NOT EXECUTED
2004cdc: d0 07 bf f8 ld [ %fp + -8 ], %o0 <== NOT EXECUTED
{
free(sector);
return rc;
}
if (new_part_desc == NULL)
2004ce0: 80 a2 a0 00 cmp %o2, 0
2004ce4: 22 80 00 21 be,a 2004d68 <read_extended_partition+0x178>
2004ce8: b8 07 20 04 add %i4, 4, %i4
{
data += RTEMS_IDE_PARTITION_DESCRIPTOR_SIZE;
continue;
}
ext_part->sub_part[i] = new_part_desc;
2004cec: d4 27 20 18 st %o2, [ %i4 + 0x18 ]
new_part_desc->ext_part = ext_part;
new_part_desc->disk_desc = ext_part->disk_desc;
2004cf0: c2 06 a0 10 ld [ %i2 + 0x10 ], %g1
* true if partition type is extended, false otherwise
*/
static bool
is_extended(uint8_t type)
{
return ((type == EXTENDED_PARTITION) || (type == LINUX_EXTENDED));
2004cf4: c4 0a a0 01 ldub [ %o2 + 1 ], %g2
data += RTEMS_IDE_PARTITION_DESCRIPTOR_SIZE;
continue;
}
ext_part->sub_part[i] = new_part_desc;
new_part_desc->ext_part = ext_part;
2004cf8: f4 22 a0 14 st %i2, [ %o2 + 0x14 ]
new_part_desc->disk_desc = ext_part->disk_desc;
if (is_extended(new_part_desc->sys_type))
2004cfc: 84 08 a0 7f and %g2, 0x7f, %g2
continue;
}
ext_part->sub_part[i] = new_part_desc;
new_part_desc->ext_part = ext_part;
new_part_desc->disk_desc = ext_part->disk_desc;
2004d00: c2 22 a0 10 st %g1, [ %o2 + 0x10 ]
if (is_extended(new_part_desc->sys_type))
2004d04: 80 a0 a0 05 cmp %g2, 5
2004d08: 12 80 00 0a bne 2004d30 <read_extended_partition+0x140>
2004d0c: c4 02 a0 04 ld [ %o2 + 4 ], %g2
{
new_part_desc->log_id = EMPTY_PARTITION;
new_part_desc->start += start;
2004d10: 84 00 80 19 add %g2, %i1, %g2
new_part_desc->ext_part = ext_part;
new_part_desc->disk_desc = ext_part->disk_desc;
if (is_extended(new_part_desc->sys_type))
{
new_part_desc->log_id = EMPTY_PARTITION;
2004d14: c0 2a a0 02 clrb [ %o2 + 2 ]
new_part_desc->start += start;
2004d18: c4 22 a0 04 st %g2, [ %o2 + 4 ]
read_extended_partition(fd, start, new_part_desc);
2004d1c: 90 10 00 18 mov %i0, %o0
2004d20: 7f ff ff b4 call 2004bf0 <read_extended_partition>
2004d24: 92 10 00 19 mov %i1, %o1
2004d28: 10 80 00 10 b 2004d68 <read_extended_partition+0x178>
2004d2c: b8 07 20 04 add %i4, 4, %i4
}
else
{
rtems_disk_desc_t *disk_desc = new_part_desc->disk_desc;
disk_desc->partitions[disk_desc->last_log_id] = new_part_desc;
2004d30: c6 00 60 24 ld [ %g1 + 0x24 ], %g3
2004d34: 88 00 e0 0a add %g3, 0xa, %g4
new_part_desc->log_id = ++disk_desc->last_log_id;
2004d38: 86 00 e0 01 inc %g3
read_extended_partition(fd, start, new_part_desc);
}
else
{
rtems_disk_desc_t *disk_desc = new_part_desc->disk_desc;
disk_desc->partitions[disk_desc->last_log_id] = new_part_desc;
2004d3c: 89 29 20 02 sll %g4, 2, %g4
new_part_desc->log_id = ++disk_desc->last_log_id;
2004d40: c6 20 60 24 st %g3, [ %g1 + 0x24 ]
read_extended_partition(fd, start, new_part_desc);
}
else
{
rtems_disk_desc_t *disk_desc = new_part_desc->disk_desc;
disk_desc->partitions[disk_desc->last_log_id] = new_part_desc;
2004d44: d4 20 40 04 st %o2, [ %g1 + %g4 ]
new_part_desc->log_id = ++disk_desc->last_log_id;
new_part_desc->start += here;
2004d48: 82 06 c0 02 add %i3, %g2, %g1
new_part_desc->end = new_part_desc->start + new_part_desc->size - 1;
2004d4c: c4 02 a0 08 ld [ %o2 + 8 ], %g2
else
{
rtems_disk_desc_t *disk_desc = new_part_desc->disk_desc;
disk_desc->partitions[disk_desc->last_log_id] = new_part_desc;
new_part_desc->log_id = ++disk_desc->last_log_id;
new_part_desc->start += here;
2004d50: c2 22 a0 04 st %g1, [ %o2 + 4 ]
new_part_desc->end = new_part_desc->start + new_part_desc->size - 1;
2004d54: 84 00 bf ff add %g2, -1, %g2
}
else
{
rtems_disk_desc_t *disk_desc = new_part_desc->disk_desc;
disk_desc->partitions[disk_desc->last_log_id] = new_part_desc;
new_part_desc->log_id = ++disk_desc->last_log_id;
2004d58: c6 2a a0 02 stb %g3, [ %o2 + 2 ]
new_part_desc->start += here;
new_part_desc->end = new_part_desc->start + new_part_desc->size - 1;
2004d5c: 82 00 80 01 add %g2, %g1, %g1
2004d60: c2 22 a0 0c st %g1, [ %o2 + 0xc ]
2004d64: b8 07 20 04 add %i4, 4, %i4
/* read and process up to 4 logical partition descriptors */
data = sector->data + RTEMS_IDE_PARTITION_TABLE_OFFSET;
for (i = 0; i < RTEMS_IDE_PARTITION_MAX_SUB_PARTITION_NUMBER; i++)
2004d68: 80 a7 00 11 cmp %i4, %l1
2004d6c: 12 bf ff d5 bne 2004cc0 <read_extended_partition+0xd0>
2004d70: a0 04 20 10 add %l0, 0x10, %l0
new_part_desc->end = new_part_desc->start + new_part_desc->size - 1;
}
data += RTEMS_IDE_PARTITION_DESCRIPTOR_SIZE;
}
free(sector);
2004d74: d0 07 bf f8 ld [ %fp + -8 ], %o0
2004d78: 40 00 03 4f call 2005ab4 <free>
2004d7c: 01 00 00 00 nop
return RTEMS_SUCCESSFUL;
}
2004d80: b0 10 00 1d mov %i5, %i0
2004d84: 81 c7 e0 08 ret
2004d88: 81 e8 00 00 restore
02005364 <readv>:
ssize_t readv(
int fd,
const struct iovec *iov,
int iovcnt
)
{
2005364: 9d e3 bf a0 save %sp, -96, %sp
int v;
int bytes;
rtems_libio_t *iop;
bool all_zeros;
rtems_libio_check_fd( fd );
2005368: 03 00 80 76 sethi %hi(0x201d800), %g1
200536c: c2 00 61 30 ld [ %g1 + 0x130 ], %g1 ! 201d930 <rtems_libio_number_iops>
2005370: 80 a6 00 01 cmp %i0, %g1
2005374: 2a 80 00 03 bcs,a 2005380 <readv+0x1c>
2005378: 83 2e 20 03 sll %i0, 3, %g1
200537c: 30 80 00 0c b,a 20053ac <readv+0x48>
iop = rtems_libio_iop( fd );
2005380: b1 2e 20 06 sll %i0, 6, %i0
2005384: b0 26 00 01 sub %i0, %g1, %i0
2005388: 03 00 80 79 sethi %hi(0x201e400), %g1
200538c: f8 00 60 50 ld [ %g1 + 0x50 ], %i4 ! 201e450 <rtems_libio_iops>
2005390: b8 07 00 18 add %i4, %i0, %i4
rtems_libio_check_is_open( iop );
2005394: c2 07 20 10 ld [ %i4 + 0x10 ], %g1
2005398: 80 88 61 00 btst 0x100, %g1
200539c: 02 80 00 04 be 20053ac <readv+0x48>
20053a0: 80 88 60 02 btst 2, %g1
rtems_libio_check_permissions_with_error( iop, LIBIO_FLAGS_READ, EBADF );
20053a4: 12 80 00 06 bne 20053bc <readv+0x58> <== ALWAYS TAKEN
20053a8: 80 a6 60 00 cmp %i1, 0
20053ac: 40 00 2c e8 call 201074c <__errno>
20053b0: 01 00 00 00 nop
20053b4: 10 80 00 1a b 200541c <readv+0xb8>
20053b8: 82 10 20 09 mov 9, %g1 ! 9 <PROM_START+0x9>
/*
* Argument validation on IO vector
*/
if ( !iov )
20053bc: 02 80 00 15 be 2005410 <readv+0xac>
20053c0: 80 a6 a0 00 cmp %i2, 0
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iovcnt <= 0 )
20053c4: 04 80 00 13 ble 2005410 <readv+0xac>
20053c8: 80 a6 a4 00 cmp %i2, 0x400
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iovcnt > IOV_MAX )
20053cc: 24 80 00 03 ble,a 20053d8 <readv+0x74> <== ALWAYS TAKEN
20053d0: b5 2e a0 03 sll %i2, 3, %i2
20053d4: 30 80 00 0f b,a 2005410 <readv+0xac> <== NOT EXECUTED
#include <sys/uio.h>
#include <rtems/libio_.h>
#include <rtems/seterr.h>
ssize_t readv(
20053d8: 82 10 20 00 clr %g1
20053dc: 84 10 20 01 mov 1, %g2
20053e0: 10 80 00 03 b 20053ec <readv+0x88>
20053e4: 86 10 20 00 clr %g3
if ( iov[v].iov_base == 0 )
rtems_set_errno_and_return_minus_one( EINVAL );
/* check for wrap */
old = total;
total += iov[v].iov_len;
20053e8: 86 10 00 1d mov %i5, %g3
/*
* 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 )
20053ec: c8 06 40 01 ld [ %i1 + %g1 ], %g4
20053f0: 80 a1 20 00 cmp %g4, 0
20053f4: 02 80 00 07 be 2005410 <readv+0xac>
20053f8: 88 06 40 01 add %i1, %g1, %g4
rtems_set_errno_and_return_minus_one( EINVAL );
/* check for wrap */
old = total;
total += iov[v].iov_len;
20053fc: c8 01 20 04 ld [ %g4 + 4 ], %g4
2005400: ba 01 00 03 add %g4, %g3, %i5
if ( total < old )
2005404: 80 a7 40 03 cmp %i5, %g3
2005408: 16 80 00 07 bge 2005424 <readv+0xc0>
200540c: 80 a0 00 04 cmp %g0, %g4
rtems_set_errno_and_return_minus_one( EINVAL );
2005410: 40 00 2c cf call 201074c <__errno>
2005414: 01 00 00 00 nop
2005418: 82 10 20 16 mov 0x16, %g1 ! 16 <PROM_START+0x16>
200541c: 10 80 00 20 b 200549c <readv+0x138>
2005420: c2 22 00 00 st %g1, [ %o0 ]
2005424: 82 00 60 08 add %g1, 8, %g1
if ( iov[v].iov_len )
all_zeros = false;
2005428: 86 40 3f ff addx %g0, -1, %g3
* 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++ ) {
200542c: 80 a0 40 1a cmp %g1, %i2
2005430: 12 bf ff ee bne 20053e8 <readv+0x84>
2005434: 84 08 80 03 and %g2, %g3, %g2
/*
* 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 ) {
2005438: 80 88 a0 ff btst 0xff, %g2
200543c: 12 80 00 16 bne 2005494 <readv+0x130>
2005440: b0 10 20 00 clr %i0
2005444: ba 10 20 00 clr %i5
/*
* Now process the readv().
*/
for ( total=0, v=0 ; v < iovcnt ; v++ ) {
bytes = (*iop->pathinfo.handlers->read_h)(
2005448: c2 07 20 24 ld [ %i4 + 0x24 ], %g1
#include <sys/uio.h>
#include <rtems/libio_.h>
#include <rtems/seterr.h>
ssize_t readv(
200544c: b6 06 40 1d add %i1, %i5, %i3
/*
* Now process the readv().
*/
for ( total=0, v=0 ; v < iovcnt ; v++ ) {
bytes = (*iop->pathinfo.handlers->read_h)(
2005450: c2 00 60 08 ld [ %g1 + 8 ], %g1
2005454: d2 06 40 1d ld [ %i1 + %i5 ], %o1
2005458: d4 06 e0 04 ld [ %i3 + 4 ], %o2
200545c: 9f c0 40 00 call %g1
2005460: 90 10 00 1c mov %i4, %o0
iop,
iov[v].iov_base,
iov[v].iov_len
);
if ( bytes < 0 )
2005464: 80 a2 20 00 cmp %o0, 0
2005468: 26 80 00 0b bl,a 2005494 <readv+0x130> <== NEVER TAKEN
200546c: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
return -1;
if ( bytes > 0 ) {
2005470: 32 80 00 02 bne,a 2005478 <readv+0x114> <== ALWAYS TAKEN
2005474: b0 06 00 08 add %i0, %o0, %i0
total += bytes;
}
if (bytes != iov[ v ].iov_len)
2005478: c2 06 e0 04 ld [ %i3 + 4 ], %g1
200547c: 80 a2 00 01 cmp %o0, %g1
2005480: 12 80 00 05 bne 2005494 <readv+0x130> <== NEVER TAKEN
2005484: ba 07 60 08 add %i5, 8, %i5
}
/*
* Now process the readv().
*/
for ( total=0, v=0 ; v < iovcnt ; v++ ) {
2005488: 80 a7 40 1a cmp %i5, %i2
200548c: 32 bf ff f0 bne,a 200544c <readv+0xe8>
2005490: c2 07 20 24 ld [ %i4 + 0x24 ], %g1
2005494: 81 c7 e0 08 ret
2005498: 81 e8 00 00 restore
iov[v].iov_base,
iov[v].iov_len
);
if ( bytes < 0 )
return -1;
200549c: b0 10 3f ff mov -1, %i0
if (bytes != iov[ v ].iov_len)
break;
}
return total;
}
20054a0: 81 c7 e0 08 ret
20054a4: 81 e8 00 00 restore
0200469c <realloc>:
void *realloc(
void *ptr,
size_t size
)
{
200469c: 9d e3 bf 98 save %sp, -104, %sp
uintptr_t old_size;
char *new_area;
MSBUMP(realloc_calls, 1);
20046a0: 03 00 80 76 sethi %hi(0x201d800), %g1
20046a4: 82 10 61 58 or %g1, 0x158, %g1 ! 201d958 <rtems_malloc_statistics>
20046a8: c4 00 60 10 ld [ %g1 + 0x10 ], %g2
20046ac: 84 00 a0 01 inc %g2
20046b0: c4 20 60 10 st %g2, [ %g1 + 0x10 ]
/*
* Do not attempt to allocate memory if in a critical section or ISR.
*/
if (_System_state_Is_up(_System_state_Get())) {
20046b4: 03 00 80 77 sethi %hi(0x201dc00), %g1
20046b8: c2 00 60 20 ld [ %g1 + 0x20 ], %g1 ! 201dc20 <_System_state_Current>
20046bc: 80 a0 60 03 cmp %g1, 3
20046c0: 12 80 00 09 bne 20046e4 <realloc+0x48>
20046c4: 80 a6 20 00 cmp %i0, 0
* 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 )
20046c8: 03 00 80 76 sethi %hi(0x201d800), %g1
20046cc: c2 00 62 e0 ld [ %g1 + 0x2e0 ], %g1 ! 201dae0 <_Thread_Dispatch_disable_level>
20046d0: 80 a0 60 00 cmp %g1, 0
20046d4: 02 80 00 38 be 20047b4 <realloc+0x118> <== ALWAYS TAKEN
20046d8: 03 00 80 78 sethi %hi(0x201e000), %g1
return (void *) 0;
}
if ( !_Protected_heap_Get_block_size(RTEMS_Malloc_Heap, ptr, &old_size) ) {
errno = EINVAL;
return (void *) 0;
20046dc: 81 c7 e0 08 ret <== NOT EXECUTED
20046e0: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED
}
/*
* Continue with realloc().
*/
if ( !ptr )
20046e4: 12 80 00 04 bne 20046f4 <realloc+0x58>
20046e8: 80 a6 60 00 cmp %i1, 0
return malloc( size );
20046ec: 7f ff fd 25 call 2003b80 <malloc>
20046f0: 91 e8 00 19 restore %g0, %i1, %o0
if ( !size ) {
20046f4: 12 80 00 06 bne 200470c <realloc+0x70> <== ALWAYS TAKEN
20046f8: 3b 00 80 73 sethi %hi(0x201cc00), %i5
free( ptr );
20046fc: 7f ff fc 38 call 20037dc <free> <== NOT EXECUTED
2004700: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
return (void *) 0;
}
if ( !_Protected_heap_Get_block_size(RTEMS_Malloc_Heap, ptr, &old_size) ) {
errno = EINVAL;
return (void *) 0;
2004704: 81 c7 e0 08 ret <== NOT EXECUTED
2004708: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED
if ( !size ) {
free( ptr );
return (void *) 0;
}
if ( !_Protected_heap_Get_block_size(RTEMS_Malloc_Heap, ptr, &old_size) ) {
200470c: d0 07 61 dc ld [ %i5 + 0x1dc ], %o0
2004710: 92 10 00 18 mov %i0, %o1
2004714: 40 00 13 a7 call 20095b0 <_Protected_heap_Get_block_size>
2004718: 94 07 bf fc add %fp, -4, %o2
200471c: 80 8a 20 ff btst 0xff, %o0
2004720: 12 80 00 08 bne 2004740 <realloc+0xa4>
2004724: d0 07 61 dc ld [ %i5 + 0x1dc ], %o0
errno = EINVAL;
2004728: 40 00 2c ba call 200fa10 <__errno>
200472c: 01 00 00 00 nop
2004730: 82 10 20 16 mov 0x16, %g1 ! 16 <PROM_START+0x16>
2004734: c2 22 00 00 st %g1, [ %o0 ]
return (void *) 0;
2004738: 81 c7 e0 08 ret
200473c: 91 e8 20 00 restore %g0, 0, %o0
}
/*
* Now resize it.
*/
if ( _Protected_heap_Resize_block( RTEMS_Malloc_Heap, ptr, size ) ) {
2004740: 92 10 00 18 mov %i0, %o1
2004744: 40 00 13 ab call 20095f0 <_Protected_heap_Resize_block>
2004748: 94 10 00 19 mov %i1, %o2
200474c: 80 8a 20 ff btst 0xff, %o0
2004750: 12 80 00 1e bne 20047c8 <realloc+0x12c>
2004754: 01 00 00 00 nop
* 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 );
2004758: 7f ff fd 0a call 2003b80 <malloc>
200475c: 90 10 00 19 mov %i1, %o0
MSBUMP(malloc_calls, (uint32_t) -1); /* subtract off the malloc */
2004760: 03 00 80 76 sethi %hi(0x201d800), %g1
2004764: 82 10 61 58 or %g1, 0x158, %g1 ! 201d958 <rtems_malloc_statistics>
2004768: c4 00 60 04 ld [ %g1 + 4 ], %g2
* 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 );
200476c: ba 10 00 08 mov %o0, %i5
MSBUMP(malloc_calls, (uint32_t) -1); /* subtract off the malloc */
2004770: 84 00 bf ff add %g2, -1, %g2
if ( !new_area ) {
2004774: 80 a2 20 00 cmp %o0, 0
2004778: 02 bf ff f0 be 2004738 <realloc+0x9c>
200477c: c4 20 60 04 st %g2, [ %g1 + 4 ]
return (void *) 0;
}
memcpy( new_area, ptr, (size < old_size) ? size : old_size );
2004780: c2 07 bf fc ld [ %fp + -4 ], %g1
2004784: 80 a6 40 01 cmp %i1, %g1
2004788: 08 80 00 03 bleu 2004794 <realloc+0xf8> <== NEVER TAKEN
200478c: 94 10 00 19 mov %i1, %o2
2004790: 94 10 00 01 mov %g1, %o2
2004794: 92 10 00 18 mov %i0, %o1
2004798: 40 00 2e e5 call 201032c <memcpy>
200479c: 90 10 00 1d mov %i5, %o0
free( ptr );
20047a0: 90 10 00 18 mov %i0, %o0
20047a4: 7f ff fc 0e call 20037dc <free>
20047a8: b0 10 00 1d mov %i5, %i0
20047ac: 81 c7 e0 08 ret
20047b0: 81 e8 00 00 restore
if (_System_state_Is_up(_System_state_Get())) {
if (_Thread_Dispatch_in_critical_section())
return (void *) 0;
if (_ISR_Nest_level > 0)
20047b4: c2 00 60 18 ld [ %g1 + 0x18 ], %g1
20047b8: 80 a0 60 00 cmp %g1, 0
20047bc: 02 bf ff ca be 20046e4 <realloc+0x48> <== ALWAYS TAKEN
20047c0: 80 a6 20 00 cmp %i0, 0
20047c4: 30 bf ff dd b,a 2004738 <realloc+0x9c> <== NOT EXECUTED
memcpy( new_area, ptr, (size < old_size) ? size : old_size );
free( ptr );
return new_area;
}
20047c8: 81 c7 e0 08 ret
20047cc: 81 e8 00 00 restore
020080cc <rtems_aio_enqueue>:
* errno - otherwise
*/
int
rtems_aio_enqueue (rtems_aio_request *req)
{
20080cc: 9d e3 bf 78 save %sp, -136, %sp
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);
20080d0: 37 00 80 7f sethi %hi(0x201fc00), %i3
* errno - otherwise
*/
int
rtems_aio_enqueue (rtems_aio_request *req)
{
20080d4: ba 10 00 18 mov %i0, %i5
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);
20080d8: 40 00 02 85 call 2008aec <pthread_mutex_lock>
20080dc: 90 16 e2 bc or %i3, 0x2bc, %o0
if (result != 0) {
20080e0: b0 92 20 00 orcc %o0, 0, %i0
20080e4: 02 80 00 06 be 20080fc <rtems_aio_enqueue+0x30> <== ALWAYS TAKEN
20080e8: 01 00 00 00 nop
free (req);
20080ec: 7f ff ef 1d call 2003d60 <free> <== NOT EXECUTED
20080f0: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
20080f4: 81 c7 e0 08 ret <== NOT EXECUTED
20080f8: 81 e8 00 00 restore <== NOT EXECUTED
return result;
}
/* _POSIX_PRIORITIZED_IO and _POSIX_PRIORITY_SCHEDULING are defined,
we can use aio_reqprio to lower the priority of the request */
pthread_getschedparam (pthread_self(), &policy, ¶m);
20080fc: 40 00 04 8f call 2009338 <pthread_self>
2008100: b6 16 e2 bc or %i3, 0x2bc, %i3
2008104: 92 07 bf e0 add %fp, -32, %o1
2008108: 40 00 03 9c call 2008f78 <pthread_getschedparam>
200810c: 94 07 bf e4 add %fp, -28, %o2
req->caller_thread = pthread_self ();
2008110: 40 00 04 8a call 2009338 <pthread_self>
2008114: 01 00 00 00 nop
req->priority = param.sched_priority - req->aiocbp->aio_reqprio;
2008118: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
200811c: c6 07 bf e4 ld [ %fp + -28 ], %g3
2008120: c4 00 60 18 ld [ %g1 + 0x18 ], %g2
/* _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 ();
2008124: d0 27 60 10 st %o0, [ %i5 + 0x10 ]
req->priority = param.sched_priority - req->aiocbp->aio_reqprio;
2008128: 84 20 c0 02 sub %g3, %g2, %g2
200812c: c4 27 60 0c st %g2, [ %i5 + 0xc ]
req->policy = policy;
2008130: c4 07 bf e0 ld [ %fp + -32 ], %g2
2008134: c4 27 60 08 st %g2, [ %i5 + 8 ]
req->aiocbp->error_code = EINPROGRESS;
2008138: 84 10 20 77 mov 0x77, %g2
200813c: c4 20 60 34 st %g2, [ %g1 + 0x34 ]
req->aiocbp->return_value = 0;
if ((aio_request_queue.idle_threads == 0) &&
2008140: c4 06 e0 68 ld [ %i3 + 0x68 ], %g2
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;
2008144: c0 20 60 38 clr [ %g1 + 0x38 ]
if ((aio_request_queue.idle_threads == 0) &&
2008148: 80 a0 a0 00 cmp %g2, 0
200814c: 12 80 00 2e bne 2008204 <rtems_aio_enqueue+0x138> <== NEVER TAKEN
2008150: d2 00 40 00 ld [ %g1 ], %o1
2008154: c2 06 e0 64 ld [ %i3 + 0x64 ], %g1
2008158: 80 a0 60 04 cmp %g1, 4
200815c: 14 80 00 2b bg 2008208 <rtems_aio_enqueue+0x13c>
2008160: 11 00 80 7f sethi %hi(0x201fc00), %o0
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);
2008164: 90 06 e0 48 add %i3, 0x48, %o0
2008168: 7f ff ff 7d call 2007f5c <rtems_aio_search_fd>
200816c: 94 10 20 01 mov 1, %o2
if (r_chain->new_fd == 1) {
2008170: c2 02 20 18 ld [ %o0 + 0x18 ], %g1
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);
2008174: b8 10 00 08 mov %o0, %i4
if (r_chain->new_fd == 1) {
2008178: 80 a0 60 01 cmp %g1, 1
200817c: 12 80 00 1d bne 20081f0 <rtems_aio_enqueue+0x124>
2008180: b4 02 20 08 add %o0, 8, %i2
RTEMS_INLINE_ROUTINE void _Chain_Prepend(
Chain_Control *the_chain,
Chain_Node *the_node
)
{
_Chain_Insert(_Chain_Head(the_chain), the_node);
2008184: 92 10 00 1d mov %i5, %o1
2008188: 40 00 08 ff call 200a584 <_Chain_Insert>
200818c: 90 10 00 1a mov %i2, %o0
rtems_chain_prepend (&r_chain->perfd, &req->next_prio);
r_chain->new_fd = 0;
pthread_mutex_init (&r_chain->mutex, NULL);
2008190: 92 10 20 00 clr %o1
chain = &aio_request_queue.work_req;
r_chain = rtems_aio_search_fd (chain, req->aiocbp->aio_fildes, 1);
if (r_chain->new_fd == 1) {
rtems_chain_prepend (&r_chain->perfd, &req->next_prio);
r_chain->new_fd = 0;
2008194: c0 27 20 18 clr [ %i4 + 0x18 ]
pthread_mutex_init (&r_chain->mutex, NULL);
2008198: 40 00 01 fc call 2008988 <pthread_mutex_init>
200819c: 90 07 20 1c add %i4, 0x1c, %o0
pthread_cond_init (&r_chain->cond, NULL);
20081a0: 92 10 20 00 clr %o1
20081a4: 40 00 00 fd call 2008598 <pthread_cond_init>
20081a8: 90 07 20 20 add %i4, 0x20, %o0
AIO_printf ("New thread \n");
result = pthread_create (&thid, &aio_request_queue.attr,
20081ac: 90 07 bf dc add %fp, -36, %o0
20081b0: 92 06 e0 08 add %i3, 8, %o1
20081b4: 15 00 80 1e sethi %hi(0x2007800), %o2
20081b8: 96 10 00 1c mov %i4, %o3
20081bc: 40 00 02 de call 2008d34 <pthread_create>
20081c0: 94 12 a3 a4 or %o2, 0x3a4, %o2
rtems_aio_handle, (void *) r_chain);
if (result != 0) {
20081c4: ba 92 20 00 orcc %o0, 0, %i5
20081c8: 22 80 00 07 be,a 20081e4 <rtems_aio_enqueue+0x118> <== ALWAYS TAKEN
20081cc: c2 06 e0 64 ld [ %i3 + 0x64 ], %g1
pthread_mutex_unlock (&aio_request_queue.mutex);
20081d0: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
20081d4: 40 00 02 67 call 2008b70 <pthread_mutex_unlock> <== NOT EXECUTED
20081d8: b0 10 00 1d mov %i5, %i0 <== NOT EXECUTED
20081dc: 81 c7 e0 08 ret <== NOT EXECUTED
20081e0: 81 e8 00 00 restore <== NOT EXECUTED
return result;
}
++aio_request_queue.active_threads;
20081e4: 82 00 60 01 inc %g1
20081e8: 10 80 00 3a b 20082d0 <rtems_aio_enqueue+0x204>
20081ec: c2 26 e0 64 st %g1, [ %i3 + 0x64 ]
}
else {
/* put request in the fd chain it belongs to */
pthread_mutex_lock (&r_chain->mutex);
20081f0: b6 02 20 1c add %o0, 0x1c, %i3
20081f4: 40 00 02 3e call 2008aec <pthread_mutex_lock>
20081f8: 90 10 00 1b mov %i3, %o0
rtems_aio_insert_prio (&r_chain->perfd, req);
20081fc: 10 80 00 0c b 200822c <rtems_aio_enqueue+0x160>
2008200: 90 10 00 1a mov %i2, %o0
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,
2008204: 11 00 80 7f sethi %hi(0x201fc00), %o0 <== NOT EXECUTED
2008208: 94 10 20 00 clr %o2
200820c: 7f ff ff 54 call 2007f5c <rtems_aio_search_fd>
2008210: 90 12 23 04 or %o0, 0x304, %o0
req->aiocbp->aio_fildes, 0);
if (r_chain != NULL)
2008214: b8 92 20 00 orcc %o0, 0, %i4
2008218: 02 80 00 0d be 200824c <rtems_aio_enqueue+0x180>
200821c: b6 07 20 1c add %i4, 0x1c, %i3
{
pthread_mutex_lock (&r_chain->mutex);
2008220: 40 00 02 33 call 2008aec <pthread_mutex_lock>
2008224: 90 10 00 1b mov %i3, %o0
rtems_aio_insert_prio (&r_chain->perfd, req);
2008228: 90 07 20 08 add %i4, 8, %o0
200822c: 7f ff fe fc call 2007e1c <rtems_aio_insert_prio>
2008230: 92 10 00 1d mov %i5, %o1
pthread_cond_signal (&r_chain->cond);
2008234: 40 00 01 09 call 2008658 <pthread_cond_signal>
2008238: 90 07 20 20 add %i4, 0x20, %o0
pthread_mutex_unlock (&r_chain->mutex);
200823c: 40 00 02 4d call 2008b70 <pthread_mutex_unlock>
2008240: 90 10 00 1b mov %i3, %o0
if (aio_request_queue.idle_threads > 0)
pthread_cond_signal (&aio_request_queue.new_req);
}
}
pthread_mutex_unlock (&aio_request_queue.mutex);
2008244: 10 80 00 24 b 20082d4 <rtems_aio_enqueue+0x208>
2008248: 11 00 80 7f sethi %hi(0x201fc00), %o0
} else {
/* or to the idle chain */
chain = &aio_request_queue.idle_req;
r_chain = rtems_aio_search_fd (chain, req->aiocbp->aio_fildes, 1);
200824c: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
2008250: 11 00 80 7f sethi %hi(0x201fc00), %o0
2008254: d2 00 40 00 ld [ %g1 ], %o1
2008258: 90 12 23 10 or %o0, 0x310, %o0
200825c: 7f ff ff 40 call 2007f5c <rtems_aio_search_fd>
2008260: 94 10 20 01 mov 1, %o2
if (r_chain->new_fd == 1) {
2008264: c2 02 20 18 ld [ %o0 + 0x18 ], %g1
} else {
/* or to the idle chain */
chain = &aio_request_queue.idle_req;
r_chain = rtems_aio_search_fd (chain, req->aiocbp->aio_fildes, 1);
2008268: b8 10 00 08 mov %o0, %i4
200826c: 92 10 00 1d mov %i5, %o1
if (r_chain->new_fd == 1) {
2008270: 80 a0 60 01 cmp %g1, 1
2008274: 12 80 00 0d bne 20082a8 <rtems_aio_enqueue+0x1dc>
2008278: 90 02 20 08 add %o0, 8, %o0
200827c: 40 00 08 c2 call 200a584 <_Chain_Insert>
2008280: 01 00 00 00 nop
/* If this is a new fd chain we signal the idle threads that
might be waiting for requests */
AIO_printf (" New chain on waiting queue \n ");
rtems_chain_prepend (&r_chain->perfd, &req->next_prio);
r_chain->new_fd = 0;
pthread_mutex_init (&r_chain->mutex, NULL);
2008284: 90 07 20 1c add %i4, 0x1c, %o0
if (r_chain->new_fd == 1) {
/* If this is a new fd chain we signal the idle threads that
might be waiting for requests */
AIO_printf (" New chain on waiting queue \n ");
rtems_chain_prepend (&r_chain->perfd, &req->next_prio);
r_chain->new_fd = 0;
2008288: c0 27 20 18 clr [ %i4 + 0x18 ]
pthread_mutex_init (&r_chain->mutex, NULL);
200828c: 40 00 01 bf call 2008988 <pthread_mutex_init>
2008290: 92 10 20 00 clr %o1
pthread_cond_init (&r_chain->cond, NULL);
2008294: 90 07 20 20 add %i4, 0x20, %o0
2008298: 40 00 00 c0 call 2008598 <pthread_cond_init>
200829c: 92 10 20 00 clr %o1
} else
/* just insert the request in the existing fd chain */
rtems_aio_insert_prio (&r_chain->perfd, req);
if (aio_request_queue.idle_threads > 0)
20082a0: 10 80 00 05 b 20082b4 <rtems_aio_enqueue+0x1e8>
20082a4: 11 00 80 7f sethi %hi(0x201fc00), %o0
r_chain->new_fd = 0;
pthread_mutex_init (&r_chain->mutex, NULL);
pthread_cond_init (&r_chain->cond, NULL);
} else
/* just insert the request in the existing fd chain */
rtems_aio_insert_prio (&r_chain->perfd, req);
20082a8: 7f ff fe dd call 2007e1c <rtems_aio_insert_prio>
20082ac: 01 00 00 00 nop
if (aio_request_queue.idle_threads > 0)
20082b0: 11 00 80 7f sethi %hi(0x201fc00), %o0
20082b4: 90 12 22 bc or %o0, 0x2bc, %o0 ! 201febc <aio_request_queue>
20082b8: c2 02 20 68 ld [ %o0 + 0x68 ], %g1
20082bc: 80 a0 60 00 cmp %g1, 0
20082c0: 24 80 00 05 ble,a 20082d4 <rtems_aio_enqueue+0x208> <== ALWAYS TAKEN
20082c4: 11 00 80 7f sethi %hi(0x201fc00), %o0
pthread_cond_signal (&aio_request_queue.new_req);
20082c8: 40 00 00 e4 call 2008658 <pthread_cond_signal> <== NOT EXECUTED
20082cc: 90 02 20 04 add %o0, 4, %o0 ! 201fc04 <_PathLocale> <== NOT EXECUTED
}
}
pthread_mutex_unlock (&aio_request_queue.mutex);
20082d0: 11 00 80 7f sethi %hi(0x201fc00), %o0
20082d4: 40 00 02 27 call 2008b70 <pthread_mutex_unlock>
20082d8: 90 12 22 bc or %o0, 0x2bc, %o0 ! 201febc <aio_request_queue>
return 0;
}
20082dc: 81 c7 e0 08 ret
20082e0: 81 e8 00 00 restore
02007ba4 <rtems_aio_handle>:
* NULL - if error
*/
static void *
rtems_aio_handle (void *arg)
{
2007ba4: 9d e3 bf 78 save %sp, -136, %sp
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);
2007ba8: 3b 00 80 7f sethi %hi(0x201fc00), %i5
2007bac: ba 17 62 bc or %i5, 0x2bc, %i5 ! 201febc <aio_request_queue>
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)) {
2007bb0: b4 07 60 58 add %i5, 0x58, %i2
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 &&
2007bb4: b2 07 60 4c add %i5, 0x4c, %i1
--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,
2007bb8: a0 07 60 04 add %i5, 4, %l0
/* 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);
2007bbc: b6 06 20 1c add %i0, 0x1c, %i3
2007bc0: 40 00 03 cb call 2008aec <pthread_mutex_lock>
2007bc4: 90 10 00 1b mov %i3, %o0
if (result != 0)
2007bc8: 80 a2 20 00 cmp %o0, 0
2007bcc: 12 80 00 91 bne 2007e10 <rtems_aio_handle+0x26c> <== NEVER TAKEN
2007bd0: 82 06 20 0c add %i0, 0xc, %g1
2007bd4: f8 06 20 08 ld [ %i0 + 8 ], %i4
/* 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)) {
2007bd8: 80 a7 00 01 cmp %i4, %g1
2007bdc: 02 80 00 3b be 2007cc8 <rtems_aio_handle+0x124>
2007be0: 01 00 00 00 nop
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);
2007be4: 40 00 05 d5 call 2009338 <pthread_self>
2007be8: 01 00 00 00 nop
2007bec: 92 07 bf d8 add %fp, -40, %o1
2007bf0: 40 00 04 e2 call 2008f78 <pthread_getschedparam>
2007bf4: 94 07 bf e4 add %fp, -28, %o2
param.sched_priority = req->priority;
2007bf8: c2 07 20 0c ld [ %i4 + 0xc ], %g1
pthread_setschedparam (pthread_self(), req->policy, ¶m);
2007bfc: 40 00 05 cf call 2009338 <pthread_self>
2007c00: c2 27 bf e4 st %g1, [ %fp + -28 ]
2007c04: d2 07 20 08 ld [ %i4 + 8 ], %o1
2007c08: 40 00 05 d0 call 2009348 <pthread_setschedparam>
2007c0c: 94 07 bf e4 add %fp, -28, %o2
2007c10: 40 00 0a 44 call 200a520 <_Chain_Extract>
2007c14: 90 10 00 1c mov %i4, %o0
rtems_chain_extract (node);
pthread_mutex_unlock (&r_chain->mutex);
2007c18: 40 00 03 d6 call 2008b70 <pthread_mutex_unlock>
2007c1c: 90 10 00 1b mov %i3, %o0
switch (req->aiocbp->aio_lio_opcode) {
2007c20: c2 07 20 14 ld [ %i4 + 0x14 ], %g1
2007c24: c4 00 60 30 ld [ %g1 + 0x30 ], %g2
2007c28: 80 a0 a0 02 cmp %g2, 2
2007c2c: 22 80 00 10 be,a 2007c6c <rtems_aio_handle+0xc8>
2007c30: c4 18 60 08 ldd [ %g1 + 8 ], %g2
2007c34: 80 a0 a0 03 cmp %g2, 3
2007c38: 02 80 00 15 be 2007c8c <rtems_aio_handle+0xe8> <== NEVER TAKEN
2007c3c: 80 a0 a0 01 cmp %g2, 1
2007c40: 32 80 00 19 bne,a 2007ca4 <rtems_aio_handle+0x100> <== NEVER TAKEN
2007c44: f8 07 20 14 ld [ %i4 + 0x14 ], %i4 <== NOT EXECUTED
case LIO_READ:
AIO_printf ("read\n");
result = pread (req->aiocbp->aio_fildes,
2007c48: c4 18 60 08 ldd [ %g1 + 8 ], %g2
2007c4c: d0 00 40 00 ld [ %g1 ], %o0
2007c50: d2 00 60 10 ld [ %g1 + 0x10 ], %o1
2007c54: d4 00 60 14 ld [ %g1 + 0x14 ], %o2
2007c58: 96 10 00 02 mov %g2, %o3
2007c5c: 40 00 2b 2f call 2012918 <pread>
2007c60: 98 10 00 03 mov %g3, %o4
(void *) req->aiocbp->aio_buf,
req->aiocbp->aio_nbytes, req->aiocbp->aio_offset);
break;
2007c64: 10 80 00 0d b 2007c98 <rtems_aio_handle+0xf4>
2007c68: 80 a2 3f ff cmp %o0, -1
case LIO_WRITE:
AIO_printf ("write\n");
result = pwrite (req->aiocbp->aio_fildes,
2007c6c: d0 00 40 00 ld [ %g1 ], %o0
2007c70: d2 00 60 10 ld [ %g1 + 0x10 ], %o1
2007c74: d4 00 60 14 ld [ %g1 + 0x14 ], %o2
2007c78: 96 10 00 02 mov %g2, %o3
2007c7c: 40 00 2b 65 call 2012a10 <pwrite>
2007c80: 98 10 00 03 mov %g3, %o4
(void *) req->aiocbp->aio_buf,
req->aiocbp->aio_nbytes, req->aiocbp->aio_offset);
break;
2007c84: 10 80 00 05 b 2007c98 <rtems_aio_handle+0xf4>
2007c88: 80 a2 3f ff cmp %o0, -1
case LIO_SYNC:
AIO_printf ("sync\n");
result = fsync (req->aiocbp->aio_fildes);
2007c8c: 40 00 1a 80 call 200e68c <fsync> <== NOT EXECUTED
2007c90: d0 00 40 00 ld [ %g1 ], %o0 <== NOT EXECUTED
break;
default:
result = -1;
}
if (result == -1) {
2007c94: 80 a2 3f ff cmp %o0, -1 <== NOT EXECUTED
2007c98: 32 80 00 09 bne,a 2007cbc <rtems_aio_handle+0x118> <== ALWAYS TAKEN
2007c9c: c2 07 20 14 ld [ %i4 + 0x14 ], %g1
req->aiocbp->return_value = -1;
2007ca0: f8 07 20 14 ld [ %i4 + 0x14 ], %i4 <== NOT EXECUTED
2007ca4: 82 10 3f ff mov -1, %g1 <== NOT EXECUTED
req->aiocbp->error_code = errno;
2007ca8: 40 00 28 20 call 2011d28 <__errno> <== NOT EXECUTED
2007cac: c2 27 20 38 st %g1, [ %i4 + 0x38 ] <== NOT EXECUTED
2007cb0: c2 02 00 00 ld [ %o0 ], %g1 <== NOT EXECUTED
2007cb4: 10 bf ff c2 b 2007bbc <rtems_aio_handle+0x18> <== NOT EXECUTED
2007cb8: c2 27 20 34 st %g1, [ %i4 + 0x34 ] <== NOT EXECUTED
} else {
req->aiocbp->return_value = result;
2007cbc: d0 20 60 38 st %o0, [ %g1 + 0x38 ]
req->aiocbp->error_code = 0;
2007cc0: 10 bf ff bf b 2007bbc <rtems_aio_handle+0x18>
2007cc4: c0 20 60 34 clr [ %g1 + 0x34 ]
struct timespec timeout;
AIO_printf ("Chain is empty [WQ], wait for work\n");
pthread_mutex_unlock (&r_chain->mutex);
2007cc8: 40 00 03 aa call 2008b70 <pthread_mutex_unlock>
2007ccc: 90 10 00 1b mov %i3, %o0
pthread_mutex_lock (&aio_request_queue.mutex);
2007cd0: 40 00 03 87 call 2008aec <pthread_mutex_lock>
2007cd4: 90 10 00 1d mov %i5, %o0
if (rtems_chain_is_empty (chain))
2007cd8: c2 06 20 08 ld [ %i0 + 8 ], %g1
2007cdc: 80 a0 40 1c cmp %g1, %i4
2007ce0: 12 80 00 48 bne 2007e00 <rtems_aio_handle+0x25c> <== NEVER TAKEN
2007ce4: 92 07 bf dc add %fp, -36, %o1
{
clock_gettime (CLOCK_REALTIME, &timeout);
2007ce8: 40 00 01 c9 call 200840c <clock_gettime>
2007cec: 90 10 20 01 mov 1, %o0
timeout.tv_sec += 3;
2007cf0: c2 07 bf dc ld [ %fp + -36 ], %g1
timeout.tv_nsec = 0;
2007cf4: c0 27 bf e0 clr [ %fp + -32 ]
pthread_mutex_lock (&aio_request_queue.mutex);
if (rtems_chain_is_empty (chain))
{
clock_gettime (CLOCK_REALTIME, &timeout);
timeout.tv_sec += 3;
2007cf8: 82 00 60 03 add %g1, 3, %g1
timeout.tv_nsec = 0;
result = pthread_cond_timedwait (&r_chain->cond,
2007cfc: b8 06 20 20 add %i0, 0x20, %i4
pthread_mutex_lock (&aio_request_queue.mutex);
if (rtems_chain_is_empty (chain))
{
clock_gettime (CLOCK_REALTIME, &timeout);
timeout.tv_sec += 3;
2007d00: c2 27 bf dc st %g1, [ %fp + -36 ]
timeout.tv_nsec = 0;
result = pthread_cond_timedwait (&r_chain->cond,
2007d04: 90 10 00 1c mov %i4, %o0
2007d08: 92 10 00 1d mov %i5, %o1
2007d0c: 40 00 02 70 call 20086cc <pthread_cond_timedwait>
2007d10: 94 07 bf dc add %fp, -36, %o2
&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) {
2007d14: 80 a2 20 74 cmp %o0, 0x74
2007d18: 12 80 00 3a bne 2007e00 <rtems_aio_handle+0x25c> <== NEVER TAKEN
2007d1c: 01 00 00 00 nop
2007d20: 40 00 0a 00 call 200a520 <_Chain_Extract>
2007d24: 90 10 00 18 mov %i0, %o0
rtems_chain_extract (&r_chain->next_fd);
pthread_mutex_destroy (&r_chain->mutex);
2007d28: 40 00 02 c3 call 2008834 <pthread_mutex_destroy>
2007d2c: 90 10 00 1b mov %i3, %o0
pthread_cond_destroy (&r_chain->cond);
2007d30: 40 00 01 e3 call 20084bc <pthread_cond_destroy>
2007d34: 90 10 00 1c mov %i4, %o0
free (r_chain);
2007d38: 7f ff f0 0a call 2003d60 <free>
2007d3c: 90 10 00 18 mov %i0, %o0
/* 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)) {
2007d40: c2 07 60 54 ld [ %i5 + 0x54 ], %g1
2007d44: 80 a0 40 1a cmp %g1, %i2
2007d48: 12 80 00 1b bne 2007db4 <rtems_aio_handle+0x210>
2007d4c: c2 07 60 68 ld [ %i5 + 0x68 ], %g1
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);
2007d50: 92 07 bf dc add %fp, -36, %o1
/* 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;
2007d54: 82 00 60 01 inc %g1
2007d58: c2 27 60 68 st %g1, [ %i5 + 0x68 ]
--aio_request_queue.active_threads;
2007d5c: c2 07 60 64 ld [ %i5 + 0x64 ], %g1
clock_gettime (CLOCK_REALTIME, &timeout);
2007d60: 90 10 20 01 mov 1, %o0
signal. The thread now becomes idle. */
if (rtems_chain_is_empty (&aio_request_queue.idle_req)) {
AIO_printf ("Chain is empty [IQ], wait for work\n");
++aio_request_queue.idle_threads;
--aio_request_queue.active_threads;
2007d64: 82 00 7f ff add %g1, -1, %g1
clock_gettime (CLOCK_REALTIME, &timeout);
2007d68: 40 00 01 a9 call 200840c <clock_gettime>
2007d6c: c2 27 60 64 st %g1, [ %i5 + 0x64 ]
timeout.tv_sec += 3;
2007d70: c2 07 bf dc ld [ %fp + -36 ], %g1
timeout.tv_nsec = 0;
2007d74: c0 27 bf e0 clr [ %fp + -32 ]
AIO_printf ("Chain is empty [IQ], wait for work\n");
++aio_request_queue.idle_threads;
--aio_request_queue.active_threads;
clock_gettime (CLOCK_REALTIME, &timeout);
timeout.tv_sec += 3;
2007d78: 82 00 60 03 add %g1, 3, %g1
timeout.tv_nsec = 0;
result = pthread_cond_timedwait (&aio_request_queue.new_req,
2007d7c: 90 10 00 10 mov %l0, %o0
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;
2007d80: c2 27 bf dc st %g1, [ %fp + -36 ]
timeout.tv_nsec = 0;
result = pthread_cond_timedwait (&aio_request_queue.new_req,
2007d84: 92 10 00 1d mov %i5, %o1
2007d88: 40 00 02 51 call 20086cc <pthread_cond_timedwait>
2007d8c: 94 07 bf dc add %fp, -36, %o2
&aio_request_queue.mutex,
&timeout);
/* If no new fd chain was added in the idle requests
then this thread is finished */
if (result == ETIMEDOUT) {
2007d90: 80 a2 20 74 cmp %o0, 0x74
2007d94: 12 80 00 08 bne 2007db4 <rtems_aio_handle+0x210> <== NEVER TAKEN
2007d98: c2 07 60 68 ld [ %i5 + 0x68 ], %g1
AIO_printf ("Etimeout\n");
--aio_request_queue.idle_threads;
pthread_mutex_unlock (&aio_request_queue.mutex);
2007d9c: 90 10 00 1d mov %i5, %o0
/* 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;
2007da0: 82 00 7f ff add %g1, -1, %g1
pthread_mutex_unlock (&aio_request_queue.mutex);
2007da4: 40 00 03 73 call 2008b70 <pthread_mutex_unlock>
2007da8: c2 27 60 68 st %g1, [ %i5 + 0x68 ]
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
2007dac: 81 c7 e0 08 ret
2007db0: 91 e8 20 00 restore %g0, 0, %o0
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
2007db4: f0 07 60 54 ld [ %i5 + 0x54 ], %i0
}
}
/* 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;
2007db8: 82 00 7f ff add %g1, -1, %g1
2007dbc: c2 27 60 68 st %g1, [ %i5 + 0x68 ]
++aio_request_queue.active_threads;
2007dc0: c2 07 60 64 ld [ %i5 + 0x64 ], %g1
2007dc4: 90 10 00 18 mov %i0, %o0
2007dc8: 82 00 60 01 inc %g1
2007dcc: 40 00 09 d5 call 200a520 <_Chain_Extract>
2007dd0: c2 27 60 64 st %g1, [ %i5 + 0x64 ]
2007dd4: c2 07 60 48 ld [ %i5 + 0x48 ], %g1
2007dd8: c4 06 20 14 ld [ %i0 + 0x14 ], %g2
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 &&
2007ddc: c6 00 60 14 ld [ %g1 + 0x14 ], %g3
2007de0: 80 a0 c0 02 cmp %g3, %g2
2007de4: 16 80 00 04 bge 2007df4 <rtems_aio_handle+0x250>
2007de8: 80 a0 40 19 cmp %g1, %i1
2007dec: 32 bf ff fc bne,a 2007ddc <rtems_aio_handle+0x238> <== ALWAYS TAKEN
2007df0: c2 00 40 00 ld [ %g1 ], %g1
RTEMS_INLINE_ROUTINE void rtems_chain_insert(
rtems_chain_node *after_node,
rtems_chain_node *the_node
)
{
_Chain_Insert( after_node, the_node );
2007df4: d0 00 60 04 ld [ %g1 + 4 ], %o0
2007df8: 40 00 09 e3 call 200a584 <_Chain_Insert>
2007dfc: 92 10 00 18 mov %i0, %o1
}
}
/* 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);
2007e00: 40 00 03 5c call 2008b70 <pthread_mutex_unlock>
2007e04: 90 10 00 1d mov %i5, %o0
/* 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);
2007e08: 10 bf ff 6e b 2007bc0 <rtems_aio_handle+0x1c>
2007e0c: b6 06 20 1c add %i0, 0x1c, %i3
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
2007e10: b0 10 20 00 clr %i0 <== NOT EXECUTED
2007e14: 81 c7 e0 08 ret <== NOT EXECUTED
2007e18: 81 e8 00 00 restore <== NOT EXECUTED
02007e7c <rtems_aio_init>:
* 0 - if initialization succeeded
*/
int
rtems_aio_init (void)
{
2007e7c: 9d e3 bf a0 save %sp, -96, %sp
int result = 0;
result = pthread_attr_init (&aio_request_queue.attr);
2007e80: 3b 00 80 7f sethi %hi(0x201fc00), %i5
2007e84: 40 00 03 92 call 2008ccc <pthread_attr_init>
2007e88: 90 17 62 c4 or %i5, 0x2c4, %o0 ! 201fec4 <aio_request_queue+0x8>
if (result != 0)
2007e8c: b0 92 20 00 orcc %o0, 0, %i0
2007e90: 12 80 00 31 bne 2007f54 <rtems_aio_init+0xd8> <== NEVER TAKEN
2007e94: 90 17 62 c4 or %i5, 0x2c4, %o0
return result;
result =
2007e98: 40 00 03 99 call 2008cfc <pthread_attr_setdetachstate>
2007e9c: 92 10 20 00 clr %o1
pthread_attr_setdetachstate (&aio_request_queue.attr,
PTHREAD_CREATE_DETACHED);
if (result != 0)
2007ea0: 80 a2 20 00 cmp %o0, 0
2007ea4: 22 80 00 05 be,a 2007eb8 <rtems_aio_init+0x3c> <== ALWAYS TAKEN
2007ea8: 11 00 80 7f sethi %hi(0x201fc00), %o0
pthread_attr_destroy (&aio_request_queue.attr);
2007eac: 40 00 03 7c call 2008c9c <pthread_attr_destroy> <== NOT EXECUTED
2007eb0: 90 17 62 c4 or %i5, 0x2c4, %o0 <== NOT EXECUTED
result = pthread_mutex_init (&aio_request_queue.mutex, NULL);
2007eb4: 11 00 80 7f sethi %hi(0x201fc00), %o0 <== NOT EXECUTED
2007eb8: 92 10 20 00 clr %o1
2007ebc: 40 00 02 b3 call 2008988 <pthread_mutex_init>
2007ec0: 90 12 22 bc or %o0, 0x2bc, %o0
if (result != 0)
2007ec4: 80 a2 20 00 cmp %o0, 0
2007ec8: 22 80 00 06 be,a 2007ee0 <rtems_aio_init+0x64> <== ALWAYS TAKEN
2007ecc: 11 00 80 7f sethi %hi(0x201fc00), %o0
pthread_attr_destroy (&aio_request_queue.attr);
2007ed0: 11 00 80 7f sethi %hi(0x201fc00), %o0 <== NOT EXECUTED
2007ed4: 40 00 03 72 call 2008c9c <pthread_attr_destroy> <== NOT EXECUTED
2007ed8: 90 12 22 c4 or %o0, 0x2c4, %o0 ! 201fec4 <aio_request_queue+0x8><== NOT EXECUTED
result = pthread_cond_init (&aio_request_queue.new_req, NULL);
2007edc: 11 00 80 7f sethi %hi(0x201fc00), %o0 <== NOT EXECUTED
2007ee0: 92 10 20 00 clr %o1
2007ee4: 40 00 01 ad call 2008598 <pthread_cond_init>
2007ee8: 90 12 22 c0 or %o0, 0x2c0, %o0
if (result != 0) {
2007eec: b0 92 20 00 orcc %o0, 0, %i0
2007ef0: 02 80 00 09 be 2007f14 <rtems_aio_init+0x98> <== ALWAYS TAKEN
2007ef4: 03 00 80 7f sethi %hi(0x201fc00), %g1
pthread_mutex_destroy (&aio_request_queue.mutex);
2007ef8: 11 00 80 7f sethi %hi(0x201fc00), %o0 <== NOT EXECUTED
2007efc: 40 00 02 4e call 2008834 <pthread_mutex_destroy> <== NOT EXECUTED
2007f00: 90 12 22 bc or %o0, 0x2bc, %o0 ! 201febc <aio_request_queue><== NOT EXECUTED
pthread_attr_destroy (&aio_request_queue.attr);
2007f04: 11 00 80 7f sethi %hi(0x201fc00), %o0 <== NOT EXECUTED
2007f08: 40 00 03 65 call 2008c9c <pthread_attr_destroy> <== NOT EXECUTED
2007f0c: 90 12 22 c4 or %o0, 0x2c4, %o0 ! 201fec4 <aio_request_queue+0x8><== NOT EXECUTED
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
2007f10: 03 00 80 7f sethi %hi(0x201fc00), %g1 <== NOT EXECUTED
2007f14: 82 10 62 bc or %g1, 0x2bc, %g1 ! 201febc <aio_request_queue>
2007f18: 84 00 60 4c add %g1, 0x4c, %g2
2007f1c: c4 20 60 48 st %g2, [ %g1 + 0x48 ]
head->previous = NULL;
tail->previous = head;
2007f20: 84 00 60 48 add %g1, 0x48, %g2
2007f24: c4 20 60 50 st %g2, [ %g1 + 0x50 ]
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
2007f28: 84 00 60 58 add %g1, 0x58, %g2
2007f2c: c4 20 60 54 st %g2, [ %g1 + 0x54 ]
head->previous = NULL;
tail->previous = head;
2007f30: 84 00 60 54 add %g1, 0x54, %g2
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
head->previous = NULL;
2007f34: c0 20 60 4c clr [ %g1 + 0x4c ]
tail->previous = head;
2007f38: c4 20 60 5c st %g2, [ %g1 + 0x5c ]
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
head->previous = NULL;
2007f3c: c0 20 60 58 clr [ %g1 + 0x58 ]
rtems_chain_initialize_empty (&aio_request_queue.work_req);
rtems_chain_initialize_empty (&aio_request_queue.idle_req);
aio_request_queue.active_threads = 0;
aio_request_queue.idle_threads = 0;
aio_request_queue.initialized = AIO_QUEUE_INITIALIZED;
2007f40: 05 00 00 2c sethi %hi(0xb000), %g2
}
rtems_chain_initialize_empty (&aio_request_queue.work_req);
rtems_chain_initialize_empty (&aio_request_queue.idle_req);
aio_request_queue.active_threads = 0;
2007f44: c0 20 60 64 clr [ %g1 + 0x64 ]
aio_request_queue.idle_threads = 0;
aio_request_queue.initialized = AIO_QUEUE_INITIALIZED;
2007f48: 84 10 a0 0b or %g2, 0xb, %g2
rtems_chain_initialize_empty (&aio_request_queue.work_req);
rtems_chain_initialize_empty (&aio_request_queue.idle_req);
aio_request_queue.active_threads = 0;
aio_request_queue.idle_threads = 0;
2007f4c: c0 20 60 68 clr [ %g1 + 0x68 ]
aio_request_queue.initialized = AIO_QUEUE_INITIALIZED;
2007f50: c4 20 60 60 st %g2, [ %g1 + 0x60 ]
return result;
}
2007f54: 81 c7 e0 08 ret
2007f58: 81 e8 00 00 restore
02007e1c <rtems_aio_insert_prio>:
2007e1c: c2 02 00 00 ld [ %o0 ], %g1
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
2007e20: 86 02 20 04 add %o0, 4, %g3
rtems_chain_node *node;
AIO_printf ("FD exists \n");
node = rtems_chain_first (chain);
if (rtems_chain_is_empty (chain)) {
2007e24: 80 a0 40 03 cmp %g1, %g3
2007e28: 02 80 00 0e be 2007e60 <rtems_aio_insert_prio+0x44> <== NEVER TAKEN
2007e2c: 84 10 00 09 mov %o1, %g2
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;
2007e30: c8 00 60 14 ld [ %g1 + 0x14 ], %g4
while (req->aiocbp->aio_reqprio > prio &&
2007e34: da 02 60 14 ld [ %o1 + 0x14 ], %o5
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;
2007e38: c8 01 20 18 ld [ %g4 + 0x18 ], %g4
while (req->aiocbp->aio_reqprio > prio &&
2007e3c: 10 80 00 04 b 2007e4c <rtems_aio_insert_prio+0x30>
2007e40: da 03 60 18 ld [ %o5 + 0x18 ], %o5
!rtems_chain_is_tail (chain, node)) {
node = rtems_chain_next (node);
prio = ((rtems_aio_request *) node)->aiocbp->aio_reqprio;
2007e44: c8 00 60 14 ld [ %g1 + 0x14 ], %g4 <== NOT EXECUTED
2007e48: c8 01 20 18 ld [ %g4 + 0x18 ], %g4 <== 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 &&
2007e4c: 80 a3 40 04 cmp %o5, %g4
2007e50: 14 80 00 07 bg 2007e6c <rtems_aio_insert_prio+0x50> <== NEVER TAKEN
2007e54: 80 a0 40 03 cmp %g1, %g3
2007e58: d0 00 60 04 ld [ %g1 + 4 ], %o0
2007e5c: 92 10 00 02 mov %g2, %o1
2007e60: 82 13 c0 00 mov %o7, %g1
2007e64: 40 00 09 c8 call 200a584 <_Chain_Insert>
2007e68: 9e 10 40 00 mov %g1, %o7
2007e6c: 32 bf ff f6 bne,a 2007e44 <rtems_aio_insert_prio+0x28> <== NOT EXECUTED
2007e70: c2 00 40 00 ld [ %g1 ], %g1 <== NOT EXECUTED
2007e74: 10 bf ff fa b 2007e5c <rtems_aio_insert_prio+0x40> <== NOT EXECUTED
2007e78: d0 00 60 04 ld [ %g1 + 4 ], %o0 <== NOT EXECUTED
0200804c <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)
{
200804c: 9d e3 bf a0 save %sp, -96, %sp
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_head( the_chain )->next;
2008050: fa 06 00 00 ld [ %i0 ], %i5
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
2008054: 82 06 20 04 add %i0, 4, %g1
if (rtems_chain_is_empty (chain))
2008058: 80 a7 40 01 cmp %i5, %g1
200805c: 12 80 00 09 bne 2008080 <rtems_aio_remove_req+0x34>
2008060: b0 10 20 02 mov 2, %i0
2008064: 81 c7 e0 08 ret
2008068: 81 e8 00 00 restore
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) {
200806c: 80 a7 40 01 cmp %i5, %g1 <== NOT EXECUTED
2008070: 32 80 00 05 bne,a 2008084 <rtems_aio_remove_req+0x38> <== NOT EXECUTED
2008074: c4 07 60 14 ld [ %i5 + 0x14 ], %g2 <== NOT EXECUTED
node = rtems_chain_next (node);
current = (rtems_aio_request *) node;
}
if (rtems_chain_is_tail (chain, node))
return AIO_NOTCANCELED;
2008078: 81 c7 e0 08 ret <== NOT EXECUTED
200807c: 91 e8 20 01 restore %g0, 1, %o0 <== 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) {
2008080: c4 07 60 14 ld [ %i5 + 0x14 ], %g2
2008084: 80 a0 80 19 cmp %g2, %i1
2008088: 32 bf ff f9 bne,a 200806c <rtems_aio_remove_req+0x20> <== NEVER TAKEN
200808c: fa 07 40 00 ld [ %i5 ], %i5 <== NOT EXECUTED
node = rtems_chain_next (node);
current = (rtems_aio_request *) node;
}
if (rtems_chain_is_tail (chain, node))
2008090: 80 a7 40 01 cmp %i5, %g1
2008094: 02 bf ff f4 be 2008064 <rtems_aio_remove_req+0x18> <== NEVER TAKEN
2008098: b0 10 20 01 mov 1, %i0
200809c: 40 00 09 21 call 200a520 <_Chain_Extract>
20080a0: 90 10 00 1d mov %i5, %o0
return AIO_NOTCANCELED;
else
{
rtems_chain_extract (node);
current->aiocbp->error_code = ECANCELED;
20080a4: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
20080a8: 84 10 20 8c mov 0x8c, %g2
20080ac: c4 20 60 34 st %g2, [ %g1 + 0x34 ]
current->aiocbp->return_value = -1;
20080b0: 84 10 3f ff mov -1, %g2
free (current);
20080b4: 90 10 00 1d mov %i5, %o0
return AIO_NOTCANCELED;
else
{
rtems_chain_extract (node);
current->aiocbp->error_code = ECANCELED;
current->aiocbp->return_value = -1;
20080b8: c4 20 60 38 st %g2, [ %g1 + 0x38 ]
free (current);
20080bc: 7f ff ef 29 call 2003d60 <free>
20080c0: b0 10 20 00 clr %i0
}
return AIO_CANCELED;
}
20080c4: 81 c7 e0 08 ret
20080c8: 81 e8 00 00 restore
0200d2b4 <rtems_bdbuf_add_to_modified_list_after_access>:
}
}
static void
rtems_bdbuf_add_to_modified_list_after_access (rtems_bdbuf_buffer *bd)
{
200d2b4: 9d e3 bf a0 save %sp, -96, %sp
if (bdbuf_cache.sync_active && bdbuf_cache.sync_device == bd->dd)
200d2b8: 3b 00 80 86 sethi %hi(0x2021800), %i5
200d2bc: ba 17 60 7c or %i5, 0x7c, %i5 ! 202187c <bdbuf_cache>
200d2c0: c2 0f 60 30 ldub [ %i5 + 0x30 ], %g1
200d2c4: 80 a0 60 00 cmp %g1, 0
200d2c8: 22 80 00 12 be,a 200d310 <rtems_bdbuf_add_to_modified_list_after_access+0x5c><== ALWAYS TAKEN
200d2cc: c2 06 20 20 ld [ %i0 + 0x20 ], %g1
200d2d0: c4 07 60 38 ld [ %i5 + 0x38 ], %g2 <== NOT EXECUTED
200d2d4: c2 06 20 14 ld [ %i0 + 0x14 ], %g1 <== NOT EXECUTED
200d2d8: 80 a0 80 01 cmp %g2, %g1 <== NOT EXECUTED
200d2dc: 32 80 00 0d bne,a 200d310 <rtems_bdbuf_add_to_modified_list_after_access+0x5c><== NOT EXECUTED
200d2e0: c2 06 20 20 ld [ %i0 + 0x20 ], %g1 <== NOT EXECUTED
{
rtems_bdbuf_unlock_cache ();
200d2e4: 7f ff fe 4b call 200cc10 <rtems_bdbuf_unlock_cache> <== NOT EXECUTED
200d2e8: 39 10 80 00 sethi %hi(0x42000000), %i4 <== NOT EXECUTED
* Lock the cache's sync. A single task can nest calls.
*/
static void
rtems_bdbuf_lock_sync (void)
{
rtems_bdbuf_lock (bdbuf_cache.sync_lock, RTEMS_BLKDEV_FATAL_BDBUF_SYNC_LOCK);
200d2ec: d0 07 60 2c ld [ %i5 + 0x2c ], %o0 <== NOT EXECUTED
200d2f0: 7f ff fe 26 call 200cb88 <rtems_bdbuf_lock> <== NOT EXECUTED
200d2f4: 92 17 20 0b or %i4, 0xb, %o1 <== NOT EXECUTED
* Unlock the cache's sync lock. Any blocked writers are woken.
*/
static void
rtems_bdbuf_unlock_sync (void)
{
rtems_bdbuf_unlock (bdbuf_cache.sync_lock,
200d2f8: d0 07 60 2c ld [ %i5 + 0x2c ], %o0 <== NOT EXECUTED
200d2fc: 7f ff fe 3b call 200cbe8 <rtems_bdbuf_unlock> <== NOT EXECUTED
200d300: 92 17 20 0c or %i4, 0xc, %o1 <== NOT EXECUTED
* Wait for the sync lock.
*/
rtems_bdbuf_lock_sync ();
rtems_bdbuf_unlock_sync ();
rtems_bdbuf_lock_cache ();
200d304: 7f ff fe 2d call 200cbb8 <rtems_bdbuf_lock_cache> <== NOT EXECUTED
200d308: 01 00 00 00 nop <== 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
200d30c: c2 06 20 20 ld [ %i0 + 0x20 ], %g1 <== NOT EXECUTED
200d310: 80 a0 60 05 cmp %g1, 5
200d314: 22 80 00 06 be,a 200d32c <rtems_bdbuf_add_to_modified_list_after_access+0x78>
200d318: 03 00 80 7b sethi %hi(0x201ec00), %g1
200d31c: 80 a0 60 03 cmp %g1, 3
200d320: 12 80 00 06 bne 200d338 <rtems_bdbuf_add_to_modified_list_after_access+0x84>
200d324: 82 10 20 07 mov 7, %g1
|| bd->state == RTEMS_BDBUF_STATE_ACCESS_EMPTY)
bd->hold_timer = bdbuf_config.swap_block_hold;
200d328: 03 00 80 7b sethi %hi(0x201ec00), %g1
200d32c: c2 00 61 50 ld [ %g1 + 0x150 ], %g1 ! 201ed50 <rtems_bdbuf_configuration+0x10>
200d330: c2 26 20 2c st %g1, [ %i0 + 0x2c ]
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
200d334: 82 10 20 07 mov 7, %g1
200d338: c2 26 20 20 st %g1, [ %i0 + 0x20 ]
Chain_Control *the_chain,
Chain_Node *the_node
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
200d33c: 03 00 80 86 sethi %hi(0x2021800), %g1
200d340: 82 10 60 7c or %g1, 0x7c, %g1 ! 202187c <bdbuf_cache>
200d344: c4 00 60 54 ld [ %g1 + 0x54 ], %g2
the_node->next = tail;
200d348: 86 00 60 50 add %g1, 0x50, %g3
tail->previous = the_node;
200d34c: f0 20 60 54 st %i0, [ %g1 + 0x54 ]
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
the_node->next = tail;
200d350: c6 26 00 00 st %g3, [ %i0 ]
tail->previous = the_node;
old_last->next = the_node;
200d354: f0 20 80 00 st %i0, [ %g2 ]
the_node->previous = old_last;
200d358: c4 26 20 04 st %g2, [ %i0 + 4 ]
bd->hold_timer = bdbuf_config.swap_block_hold;
rtems_bdbuf_set_state (bd, RTEMS_BDBUF_STATE_MODIFIED);
rtems_chain_append_unprotected (&bdbuf_cache.modified, &bd->link);
if (bd->waiters)
200d35c: c4 06 20 24 ld [ %i0 + 0x24 ], %g2
200d360: 80 a0 a0 00 cmp %g2, 0
200d364: 22 80 00 04 be,a 200d374 <rtems_bdbuf_add_to_modified_list_after_access+0xc0>
200d368: c2 00 60 74 ld [ %g1 + 0x74 ], %g1
rtems_bdbuf_wake (&bdbuf_cache.access_waiters);
200d36c: 7f ff fe ca call 200ce94 <rtems_bdbuf_wake>
200d370: 91 e8 60 64 restore %g1, 0x64, %o0
else if (rtems_bdbuf_has_buffer_waiters ())
200d374: 80 a0 60 00 cmp %g1, 0
200d378: 02 80 00 04 be 200d388 <rtems_bdbuf_add_to_modified_list_after_access+0xd4>
200d37c: 01 00 00 00 nop
rtems_bdbuf_wake_swapper ();
200d380: 7f ff fe 2b call 200cc2c <rtems_bdbuf_wake_swapper>
200d384: 81 e8 00 00 restore
200d388: 81 c7 e0 08 ret
200d38c: 81 e8 00 00 restore
0200cd2c <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)
{
200cd2c: 9d e3 bf a0 save %sp, -96, %sp
rtems_mode prev_mode;
/*
* Indicate we are waiting.
*/
++waiters->count;
200cd30: c2 06 00 00 ld [ %i0 ], %g1
200cd34: 82 00 60 01 inc %g1
* 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 ();
200cd38: 7f ff ff e1 call 200ccbc <rtems_bdbuf_disable_preemption>
200cd3c: c2 26 00 00 st %g1, [ %i0 ]
/*
* Unlock the cache, wait, and lock the cache when we return.
*/
rtems_bdbuf_unlock_cache ();
200cd40: 7f ff ff b4 call 200cc10 <rtems_bdbuf_unlock_cache>
200cd44: ba 10 00 08 mov %o0, %i5
sc = rtems_semaphore_obtain (waiters->sema, RTEMS_WAIT, RTEMS_BDBUF_WAIT_TIMEOUT);
200cd48: d0 06 20 04 ld [ %i0 + 4 ], %o0
200cd4c: 92 10 20 00 clr %o1
200cd50: 7f ff ef e5 call 2008ce4 <rtems_semaphore_obtain>
200cd54: 94 10 20 00 clr %o2
if (sc == RTEMS_TIMEOUT)
200cd58: 80 a2 20 06 cmp %o0, 6
200cd5c: 12 80 00 05 bne 200cd70 <rtems_bdbuf_anonymous_wait+0x44> <== ALWAYS TAKEN
200cd60: 80 a2 20 0d cmp %o0, 0xd
rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_CACHE_WAIT_TO);
200cd64: 11 10 80 00 sethi %hi(0x42000000), %o0 <== NOT EXECUTED
200cd68: 10 80 00 05 b 200cd7c <rtems_bdbuf_anonymous_wait+0x50> <== NOT EXECUTED
200cd6c: 90 12 20 12 or %o0, 0x12, %o0 ! 42000012 <RAM_END+0x3fc00012><== NOT EXECUTED
if (sc != RTEMS_UNSATISFIED)
200cd70: 02 80 00 05 be 200cd84 <rtems_bdbuf_anonymous_wait+0x58> <== ALWAYS TAKEN
200cd74: 11 10 80 00 sethi %hi(0x42000000), %o0
rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_CACHE_WAIT_2);
200cd78: 90 12 20 10 or %o0, 0x10, %o0 ! 42000010 <RAM_END+0x3fc00010><== NOT EXECUTED
200cd7c: 7f ff f1 87 call 2009398 <rtems_fatal_error_occurred> <== NOT EXECUTED
200cd80: 01 00 00 00 nop <== NOT EXECUTED
rtems_bdbuf_lock_cache ();
200cd84: 7f ff ff 8d call 200cbb8 <rtems_bdbuf_lock_cache>
200cd88: 01 00 00 00 nop
rtems_bdbuf_restore_preemption (prev_mode);
200cd8c: 7f ff ff da call 200ccf4 <rtems_bdbuf_restore_preemption>
200cd90: 90 10 00 1d mov %i5, %o0
--waiters->count;
200cd94: c2 06 00 00 ld [ %i0 ], %g1
200cd98: 82 00 7f ff add %g1, -1, %g1
200cd9c: c2 26 00 00 st %g1, [ %i0 ]
200cda0: 81 c7 e0 08 ret
200cda4: 81 e8 00 00 restore
0200cecc <rtems_bdbuf_create_task.constprop.10>:
return NULL;
}
static rtems_status_code
rtems_bdbuf_create_task(
200cecc: 9d e3 bf a0 save %sp, -96, %sp
rtems_task_argument arg,
rtems_id *id
)
{
rtems_status_code sc;
size_t stack_size = bdbuf_config.task_stack_size ?
200ced0: 03 00 80 7b sethi %hi(0x201ec00), %g1
200ced4: d4 00 61 5c ld [ %g1 + 0x15c ], %o2 ! 201ed5c <rtems_bdbuf_configuration+0x1c>
bdbuf_config.task_stack_size : RTEMS_BDBUF_TASK_STACK_SIZE_DEFAULT;
200ced8: 80 a2 a0 00 cmp %o2, 0
200cedc: 12 80 00 03 bne 200cee8 <rtems_bdbuf_create_task.constprop.10+0x1c><== ALWAYS TAKEN
200cee0: 92 10 00 19 mov %i1, %o1
200cee4: 15 00 00 04 sethi %hi(0x1000), %o2 <== NOT EXECUTED
priority = priority != 0 ? priority : default_priority;
200cee8: 80 a2 60 00 cmp %o1, 0
200ceec: 22 80 00 02 be,a 200cef4 <rtems_bdbuf_create_task.constprop.10+0x28><== NEVER TAKEN
200cef0: 92 10 20 0f mov 0xf, %o1 <== NOT EXECUTED
sc = rtems_task_create (name,
200cef4: 90 10 00 18 mov %i0, %o0
200cef8: 96 10 24 00 mov 0x400, %o3
200cefc: 98 10 20 00 clr %o4
200cf00: 7f ff ef f0 call 2008ec0 <rtems_task_create>
200cf04: 9a 10 00 1c mov %i4, %o5
stack_size,
RTEMS_PREEMPT | RTEMS_NO_TIMESLICE | RTEMS_NO_ASR,
RTEMS_LOCAL | RTEMS_NO_FLOATING_POINT,
id);
if (sc == RTEMS_SUCCESSFUL)
200cf08: b0 92 20 00 orcc %o0, 0, %i0
200cf0c: 12 80 00 05 bne 200cf20 <rtems_bdbuf_create_task.constprop.10+0x54><== NEVER TAKEN
200cf10: b2 10 00 1a mov %i2, %i1
sc = rtems_task_start (*id, entry, arg);
200cf14: f0 07 00 00 ld [ %i4 ], %i0
200cf18: 7f ff f0 77 call 20090f4 <rtems_task_start>
200cf1c: 95 e8 00 1b restore %g0, %i3, %o2
return sc;
}
200cf20: 81 c7 e0 08 ret <== NOT EXECUTED
200cf24: 81 e8 00 00 restore <== NOT EXECUTED
0200ccbc <rtems_bdbuf_disable_preemption>:
--bd->group->users;
}
static rtems_mode
rtems_bdbuf_disable_preemption (void)
{
200ccbc: 9d e3 bf 98 save %sp, -104, %sp
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_mode prev_mode = 0;
sc = rtems_task_mode (RTEMS_NO_PREEMPT, RTEMS_PREEMPT_MASK, &prev_mode);
200ccc0: 90 10 21 00 mov 0x100, %o0
static rtems_mode
rtems_bdbuf_disable_preemption (void)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_mode prev_mode = 0;
200ccc4: c0 27 bf fc clr [ %fp + -4 ]
sc = rtems_task_mode (RTEMS_NO_PREEMPT, RTEMS_PREEMPT_MASK, &prev_mode);
200ccc8: 92 10 21 00 mov 0x100, %o1
200cccc: 40 00 11 44 call 20111dc <rtems_task_mode>
200ccd0: 94 07 bf fc add %fp, -4, %o2
if (sc != RTEMS_SUCCESSFUL)
200ccd4: 80 a2 20 00 cmp %o0, 0
200ccd8: 22 80 00 05 be,a 200ccec <rtems_bdbuf_disable_preemption+0x30><== ALWAYS TAKEN
200ccdc: f0 07 bf fc ld [ %fp + -4 ], %i0
rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_PREEMPT_DIS);
200cce0: 11 10 80 00 sethi %hi(0x42000000), %o0 <== NOT EXECUTED
200cce4: 7f ff f1 ad call 2009398 <rtems_fatal_error_occurred> <== NOT EXECUTED
200cce8: 90 12 20 0f or %o0, 0xf, %o0 ! 4200000f <RAM_END+0x3fc0000f><== NOT EXECUTED
return prev_mode;
}
200ccec: 81 c7 e0 08 ret
200ccf0: 81 e8 00 00 restore
0200e1f8 <rtems_bdbuf_execute_read_request>:
static rtems_status_code
rtems_bdbuf_execute_read_request (rtems_disk_device *dd,
rtems_bdbuf_buffer *bd,
uint32_t transfer_count)
{
200e1f8: 9d e3 bf a0 save %sp, -96, %sp
/*
* 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) +
200e1fc: 83 2e a0 04 sll %i2, 4, %g1
200e200: 82 00 60 20 add %g1, 0x20, %g1
200e204: 9c 23 80 01 sub %sp, %g1, %sp
sizeof (rtems_blkdev_sg_buffer) * transfer_count);
req->req = RTEMS_BLKDEV_REQ_READ;
req->req_done = rtems_bdbuf_transfer_done;
200e208: 03 00 80 33 sethi %hi(0x200cc00), %g1
200e20c: 82 10 60 5c or %g1, 0x5c, %g1 ! 200cc5c <rtems_bdbuf_transfer_done>
/*
* 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) +
200e210: ba 03 a0 60 add %sp, 0x60, %i5
rtems_bdbuf_execute_read_request (rtems_disk_device *dd,
rtems_bdbuf_buffer *bd,
uint32_t transfer_count)
{
rtems_blkdev_request *req = NULL;
rtems_blkdev_bnum media_block = bd->block;
200e214: f6 06 60 18 ld [ %i1 + 0x18 ], %i3
uint32_t media_blocks_per_block = dd->media_blocks_per_block;
uint32_t block_size = dd->block_size;
200e218: e0 06 20 24 ld [ %i0 + 0x24 ], %l0
rtems_bdbuf_buffer *bd,
uint32_t transfer_count)
{
rtems_blkdev_request *req = NULL;
rtems_blkdev_bnum media_block = bd->block;
uint32_t media_blocks_per_block = dd->media_blocks_per_block;
200e21c: e2 06 20 2c ld [ %i0 + 0x2c ], %l1
req = bdbuf_alloc (sizeof (rtems_blkdev_request) +
sizeof (rtems_blkdev_sg_buffer) * transfer_count);
req->req = RTEMS_BLKDEV_REQ_READ;
req->req_done = rtems_bdbuf_transfer_done;
200e220: c2 27 60 04 st %g1, [ %i5 + 4 ]
#define bdbuf_alloc(size) __builtin_alloca (size)
req = bdbuf_alloc (sizeof (rtems_blkdev_request) +
sizeof (rtems_blkdev_sg_buffer) * transfer_count);
req->req = RTEMS_BLKDEV_REQ_READ;
200e224: c0 27 40 00 clr [ %i5 ]
req->req_done = rtems_bdbuf_transfer_done;
req->done_arg = req;
req->io_task = rtems_task_self ();
200e228: 40 00 0c 4b call 2011354 <rtems_task_self>
200e22c: fa 27 60 08 st %i5, [ %i5 + 8 ]
req->status = RTEMS_RESOURCE_IN_USE;
200e230: 82 10 20 0c mov 0xc, %g1
sizeof (rtems_blkdev_sg_buffer) * transfer_count);
req->req = RTEMS_BLKDEV_REQ_READ;
req->req_done = rtems_bdbuf_transfer_done;
req->done_arg = req;
req->io_task = rtems_task_self ();
200e234: d0 27 60 14 st %o0, [ %i5 + 0x14 ]
req->status = RTEMS_RESOURCE_IN_USE;
200e238: c2 27 60 0c st %g1, [ %i5 + 0xc ]
req->bufnum = 0;
200e23c: c0 27 60 10 clr [ %i5 + 0x10 ]
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
200e240: 82 10 20 09 mov 9, %g1
200e244: c2 26 60 20 st %g1, [ %i1 + 0x20 ]
req->status = RTEMS_RESOURCE_IN_USE;
req->bufnum = 0;
rtems_bdbuf_set_state (bd, RTEMS_BDBUF_STATE_TRANSFER);
req->bufs [0].user = bd;
200e248: f2 27 60 24 st %i1, [ %i5 + 0x24 ]
req->bufs [0].block = media_block;
req->bufs [0].length = block_size;
req->bufs [0].buffer = bd->buffer;
200e24c: c2 06 60 1c ld [ %i1 + 0x1c ], %g1
req->bufnum = 0;
rtems_bdbuf_set_state (bd, RTEMS_BDBUF_STATE_TRANSFER);
req->bufs [0].user = bd;
req->bufs [0].block = media_block;
200e250: f6 27 60 18 st %i3, [ %i5 + 0x18 ]
req->bufs [0].length = block_size;
200e254: e0 27 60 1c st %l0, [ %i5 + 0x1c ]
req->bufs [0].buffer = bd->buffer;
200e258: c2 27 60 20 st %g1, [ %i5 + 0x20 ]
200e25c: b8 10 00 1d mov %i5, %i4
{
rtems_blkdev_request *req = NULL;
rtems_blkdev_bnum media_block = bd->block;
uint32_t media_blocks_per_block = dd->media_blocks_per_block;
uint32_t block_size = dd->block_size;
uint32_t transfer_index = 1;
200e260: b2 10 20 01 mov 1, %i1
req->bufs [0].buffer = bd->buffer;
if (rtems_bdbuf_tracer)
rtems_bdbuf_show_users ("read", bd);
while (transfer_index < transfer_count)
200e264: 10 80 00 16 b 200e2bc <rtems_bdbuf_execute_read_request+0xc4>
200e268: a4 10 20 09 mov 9, %l2
{
media_block += media_blocks_per_block;
bd = rtems_bdbuf_get_buffer_for_read_ahead (dd, media_block);
200e26c: 90 10 00 18 mov %i0, %o0
200e270: 92 10 00 1b mov %i3, %o1
200e274: 7f ff fd 43 call 200d780 <rtems_bdbuf_get_buffer_for_read_ahead>
200e278: b8 07 20 10 add %i4, 0x10, %i4
if (bd == NULL)
200e27c: 80 a2 20 00 cmp %o0, 0
200e280: 32 80 00 09 bne,a 200e2a4 <rtems_bdbuf_execute_read_request+0xac><== ALWAYS TAKEN
200e284: e4 22 20 20 st %l2, [ %o0 + 0x20 ]
rtems_bdbuf_show_users ("read", bd);
++transfer_index;
}
req->bufnum = transfer_index;
200e288: f2 27 60 10 st %i1, [ %i5 + 0x10 ] <== NOT EXECUTED
return rtems_bdbuf_execute_transfer_request (dd, req, true);
200e28c: 90 10 00 18 mov %i0, %o0
200e290: 92 10 00 1d mov %i5, %o1
200e294: 7f ff fe 20 call 200db14 <rtems_bdbuf_execute_transfer_request>
200e298: 94 10 20 01 mov 1, %o2
200e29c: 81 c7 e0 08 ret
200e2a0: 91 e8 00 08 restore %g0, %o0, %o0
if (bd == NULL)
break;
rtems_bdbuf_set_state (bd, RTEMS_BDBUF_STATE_TRANSFER);
req->bufs [transfer_index].user = bd;
200e2a4: d0 27 20 24 st %o0, [ %i4 + 0x24 ]
req->bufs [transfer_index].block = media_block;
200e2a8: f6 27 20 18 st %i3, [ %i4 + 0x18 ]
req->bufs [transfer_index].length = block_size;
200e2ac: e0 27 20 1c st %l0, [ %i4 + 0x1c ]
req->bufs [transfer_index].buffer = bd->buffer;
200e2b0: c2 02 20 1c ld [ %o0 + 0x1c ], %g1
if (rtems_bdbuf_tracer)
rtems_bdbuf_show_users ("read", bd);
++transfer_index;
200e2b4: b2 06 60 01 inc %i1
rtems_bdbuf_set_state (bd, RTEMS_BDBUF_STATE_TRANSFER);
req->bufs [transfer_index].user = bd;
req->bufs [transfer_index].block = media_block;
req->bufs [transfer_index].length = block_size;
req->bufs [transfer_index].buffer = bd->buffer;
200e2b8: c2 27 20 20 st %g1, [ %i4 + 0x20 ]
req->bufs [0].buffer = bd->buffer;
if (rtems_bdbuf_tracer)
rtems_bdbuf_show_users ("read", bd);
while (transfer_index < transfer_count)
200e2bc: 80 a6 40 1a cmp %i1, %i2
200e2c0: 2a bf ff eb bcs,a 200e26c <rtems_bdbuf_execute_read_request+0x74>
200e2c4: b6 06 c0 11 add %i3, %l1, %i3
rtems_bdbuf_show_users ("read", bd);
++transfer_index;
}
req->bufnum = transfer_index;
200e2c8: 10 bf ff f1 b 200e28c <rtems_bdbuf_execute_read_request+0x94>
200e2cc: f2 27 60 10 st %i1, [ %i5 + 0x10 ]
0200cbd4 <rtems_bdbuf_fatal>:
#define RTEMS_BDBUF_AVL_MAX_HEIGHT (32)
#endif
static void
rtems_bdbuf_fatal (rtems_bdbuf_buf_state state, uint32_t error)
{
200cbd4: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED
rtems_fatal_error_occurred ((((uint32_t) state) << 16) | error);
200cbd8: b1 2e 20 10 sll %i0, 0x10, %i0 <== NOT EXECUTED
200cbdc: 7f ff f1 ef call 2009398 <rtems_fatal_error_occurred> <== NOT EXECUTED
200cbe0: 90 16 40 18 or %i1, %i0, %o0 <== NOT EXECUTED
0200e8e8 <rtems_bdbuf_get>:
rtems_status_code
rtems_bdbuf_get (rtems_disk_device *dd,
rtems_blkdev_bnum block,
rtems_bdbuf_buffer **bd_ptr)
{
200e8e8: 9d e3 bf a0 save %sp, -96, %sp
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_bdbuf_buffer *bd = NULL;
rtems_blkdev_bnum media_block;
rtems_bdbuf_lock_cache ();
200e8ec: 7f ff f8 b3 call 200cbb8 <rtems_bdbuf_lock_cache>
200e8f0: ba 10 00 18 mov %i0, %i5
rtems_blkdev_bnum block,
rtems_blkdev_bnum *media_block_ptr)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
if (block < dd->block_count)
200e8f4: c2 06 20 28 ld [ %i0 + 0x28 ], %g1
rtems_bdbuf_get (rtems_disk_device *dd,
rtems_blkdev_bnum block,
rtems_bdbuf_buffer **bd_ptr)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_bdbuf_buffer *bd = NULL;
200e8f8: b8 10 20 00 clr %i4
rtems_blkdev_bnum block,
rtems_blkdev_bnum *media_block_ptr)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
if (block < dd->block_count)
200e8fc: 80 a6 40 01 cmp %i1, %g1
200e900: 1a 80 00 26 bcc 200e998 <rtems_bdbuf_get+0xb0> <== NEVER TAKEN
200e904: b0 10 20 04 mov 4, %i0
}
static rtems_blkdev_bnum
rtems_bdbuf_media_block (const rtems_disk_device *dd, rtems_blkdev_bnum block)
{
if (dd->block_to_media_block_shift >= 0)
200e908: d2 07 60 30 ld [ %i5 + 0x30 ], %o1
200e90c: 80 a2 60 00 cmp %o1, 0
200e910: 26 80 00 04 bl,a 200e920 <rtems_bdbuf_get+0x38> <== NEVER TAKEN
200e914: d6 07 60 24 ld [ %i5 + 0x24 ], %o3 <== NOT EXECUTED
return block << dd->block_to_media_block_shift;
200e918: 10 80 00 09 b 200e93c <rtems_bdbuf_get+0x54>
200e91c: 93 2e 40 09 sll %i1, %o1, %o1
/*
* Change the block number for the block size to the block number for the media
* block size. We have to use 64bit maths. There is no short cut here.
*/
return (rtems_blkdev_bnum)
((((uint64_t) block) * dd->block_size) / dd->media_block_size);
200e920: 94 10 20 00 clr %o2 <== NOT EXECUTED
200e924: 90 10 20 00 clr %o0 <== NOT EXECUTED
200e928: 40 00 39 59 call 201ce8c <__muldi3> <== NOT EXECUTED
200e92c: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
200e930: d6 07 60 20 ld [ %i5 + 0x20 ], %o3 <== NOT EXECUTED
200e934: 40 00 3b 67 call 201d6d0 <__udivdi3> <== NOT EXECUTED
200e938: 94 10 20 00 clr %o2 <== NOT EXECUTED
/*
* 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.
*/
*media_block_ptr = rtems_bdbuf_media_block (dd, block) + dd->start;
200e93c: c2 07 60 18 ld [ %i5 + 0x18 ], %g1
*/
if (rtems_bdbuf_tracer)
printf ("bdbuf:get: %" PRIu32 " (%" PRIu32 ") (dev = %08x)\n",
media_block, block, (unsigned) dd->dev);
bd = rtems_bdbuf_get_buffer_for_access (dd, media_block);
200e940: 90 10 00 1d mov %i5, %o0
200e944: 7f ff fb a2 call 200d7cc <rtems_bdbuf_get_buffer_for_access>
200e948: 92 02 40 01 add %o1, %g1, %o1
200e94c: b8 10 00 08 mov %o0, %i4
switch (bd->state)
200e950: d0 02 20 20 ld [ %o0 + 0x20 ], %o0
200e954: 80 a2 20 02 cmp %o0, 2
200e958: 02 80 00 08 be 200e978 <rtems_bdbuf_get+0x90>
200e95c: 80 a2 20 07 cmp %o0, 7
200e960: 02 80 00 0a be 200e988 <rtems_bdbuf_get+0xa0>
200e964: 80 a2 20 01 cmp %o0, 1
200e968: 12 80 00 0a bne 200e990 <rtems_bdbuf_get+0xa8> <== NEVER TAKEN
200e96c: 13 10 80 00 sethi %hi(0x42000000), %o1
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
200e970: 10 80 00 03 b 200e97c <rtems_bdbuf_get+0x94>
200e974: 82 10 20 05 mov 5, %g1
200e978: 82 10 20 03 mov 3, %g1
200e97c: c2 27 20 20 st %g1, [ %i4 + 0x20 ]
200e980: 10 80 00 06 b 200e998 <rtems_bdbuf_get+0xb0>
200e984: b0 10 20 00 clr %i0
200e988: 10 bf ff fd b 200e97c <rtems_bdbuf_get+0x94>
200e98c: 82 10 20 04 mov 4, %g1
* record of this 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);
200e990: 7f ff f8 91 call 200cbd4 <rtems_bdbuf_fatal> <== NOT EXECUTED
200e994: 92 12 60 1e or %o1, 0x1e, %o1 <== NOT EXECUTED
rtems_bdbuf_show_users ("get", bd);
rtems_bdbuf_show_usage ();
}
}
rtems_bdbuf_unlock_cache ();
200e998: 7f ff f8 9e call 200cc10 <rtems_bdbuf_unlock_cache>
200e99c: 01 00 00 00 nop
*bd_ptr = bd;
200e9a0: f8 26 80 00 st %i4, [ %i2 ]
return sc;
}
200e9a4: 81 c7 e0 08 ret
200e9a8: 81 e8 00 00 restore
0200d7cc <rtems_bdbuf_get_buffer_for_access>:
static rtems_bdbuf_buffer *
rtems_bdbuf_get_buffer_for_access (rtems_disk_device *dd,
rtems_blkdev_bnum block)
{
200d7cc: 9d e3 bf a0 save %sp, -96, %sp
rtems_bdbuf_buffer *bd = NULL;
do
{
bd = rtems_bdbuf_avl_search (&bdbuf_cache.tree, dd, block);
200d7d0: 39 00 80 86 sethi %hi(0x2021800), %i4
static bool
rtems_bdbuf_wait_for_recycle (rtems_bdbuf_buffer *bd)
{
while (true)
{
switch (bd->state)
200d7d4: 35 00 80 32 sethi %hi(0x200c800), %i2
{
rtems_bdbuf_buffer *bd = NULL;
do
{
bd = rtems_bdbuf_avl_search (&bdbuf_cache.tree, dd, block);
200d7d8: b8 17 20 7c or %i4, 0x7c, %i4
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);
200d7dc: a0 07 20 6c add %i4, 0x6c, %l0
}
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);
200d7e0: a2 07 20 64 add %i4, 0x64, %l1
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
the_node->next = tail;
200d7e4: a4 07 20 5c add %i4, 0x5c, %l2
{
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);
200d7e8: b6 07 20 74 add %i4, 0x74, %i3
}
static void
rtems_bdbuf_wait_for_buffer (void)
{
if (!rtems_chain_is_empty (&bdbuf_cache.modified))
200d7ec: a6 07 20 50 add %i4, 0x50, %l3
{
rtems_bdbuf_buffer *bd = NULL;
do
{
bd = rtems_bdbuf_avl_search (&bdbuf_cache.tree, dd, block);
200d7f0: d0 07 20 3c ld [ %i4 + 0x3c ], %o0
200d7f4: 92 10 00 18 mov %i0, %o1
200d7f8: 7f ff fd 8e call 200ce30 <rtems_bdbuf_avl_search.isra.0>
200d7fc: 94 10 00 19 mov %i1, %o2
if (bd != NULL)
200d800: ba 92 20 00 orcc %o0, 0, %i5
200d804: 02 80 00 31 be 200d8c8 <rtems_bdbuf_get_buffer_for_access+0xfc>
200d808: 90 10 00 18 mov %i0, %o0
{
if (bd->group->bds_per_group != dd->bds_per_group)
200d80c: c2 07 60 28 ld [ %i5 + 0x28 ], %g1
200d810: c4 00 60 08 ld [ %g1 + 8 ], %g2
200d814: c2 06 20 34 ld [ %i0 + 0x34 ], %g1
200d818: 80 a0 80 01 cmp %g2, %g1
200d81c: 02 80 00 37 be 200d8f8 <rtems_bdbuf_get_buffer_for_access+0x12c>
200d820: a8 10 20 08 mov 8, %l4
static bool
rtems_bdbuf_wait_for_recycle (rtems_bdbuf_buffer *bd)
{
while (true)
{
switch (bd->state)
200d824: d0 07 60 20 ld [ %i5 + 0x20 ], %o0
200d828: 80 a2 20 0a cmp %o0, 0xa
200d82c: 18 80 00 25 bgu 200d8c0 <rtems_bdbuf_get_buffer_for_access+0xf4><== NEVER TAKEN
200d830: 13 10 80 00 sethi %hi(0x42000000), %o1
200d834: 82 16 a2 e0 or %i2, 0x2e0, %g1
200d838: 91 2a 20 02 sll %o0, 2, %o0
200d83c: c2 00 40 08 ld [ %g1 + %o0 ], %g1
200d840: 81 c0 40 00 jmp %g1
200d844: 01 00 00 00 nop
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
previous = the_node->previous;
200d848: c2 07 60 04 ld [ %i5 + 4 ], %g1 <== NOT EXECUTED
)
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
200d84c: c4 07 40 00 ld [ %i5 ], %g2 <== NOT EXECUTED
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
200d850: e8 27 60 20 st %l4, [ %i5 + 0x20 ] <== NOT EXECUTED
previous = the_node->previous;
next->previous = previous;
200d854: c2 20 a0 04 st %g1, [ %g2 + 4 ] <== NOT EXECUTED
previous->next = next;
200d858: c4 20 40 00 st %g2, [ %g1 ] <== NOT EXECUTED
Chain_Control *the_chain,
Chain_Node *the_node
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
200d85c: c2 07 20 60 ld [ %i4 + 0x60 ], %g1 <== NOT EXECUTED
the_node->next = tail;
200d860: e4 27 40 00 st %l2, [ %i5 ] <== NOT EXECUTED
tail->previous = the_node;
200d864: fa 27 20 60 st %i5, [ %i4 + 0x60 ] <== NOT EXECUTED
old_last->next = the_node;
200d868: fa 20 40 00 st %i5, [ %g1 ] <== 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_unprotected (&bd->link);
rtems_chain_append_unprotected (&bdbuf_cache.sync, &bd->link);
rtems_bdbuf_wake_swapper ();
200d86c: 7f ff fc f0 call 200cc2c <rtems_bdbuf_wake_swapper> <== NOT EXECUTED
200d870: c2 27 60 04 st %g1, [ %i5 + 4 ] <== NOT EXECUTED
static bool
rtems_bdbuf_wait_for_recycle (rtems_bdbuf_buffer *bd)
{
while (true)
{
switch (bd->state)
200d874: 10 bf ff ed b 200d828 <rtems_bdbuf_get_buffer_for_access+0x5c><== NOT EXECUTED
200d878: d0 07 60 20 ld [ %i5 + 0x20 ], %o0 <== 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)
200d87c: c2 07 60 24 ld [ %i5 + 0x24 ], %g1
200d880: 80 a0 60 00 cmp %g1, 0
200d884: 02 80 00 3e be 200d97c <rtems_bdbuf_get_buffer_for_access+0x1b0><== NEVER TAKEN
200d888: 01 00 00 00 nop
* 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);
200d88c: 7f ff fd 28 call 200cd2c <rtems_bdbuf_anonymous_wait>
200d890: 90 10 00 1b mov %i3, %o0
{
rtems_bdbuf_buffer *bd = NULL;
do
{
bd = rtems_bdbuf_avl_search (&bdbuf_cache.tree, dd, block);
200d894: 10 bf ff d8 b 200d7f4 <rtems_bdbuf_get_buffer_for_access+0x28>
200d898: d0 07 20 3c ld [ %i4 + 0x3c ], %o0
}
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);
200d89c: 90 10 00 1d mov %i5, %o0
200d8a0: 10 80 00 04 b 200d8b0 <rtems_bdbuf_get_buffer_for_access+0xe4>
200d8a4: 92 10 00 11 mov %l1, %o1
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);
200d8a8: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
200d8ac: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED
200d8b0: 7f ff fd 3e call 200cda8 <rtems_bdbuf_wait>
200d8b4: 01 00 00 00 nop
static bool
rtems_bdbuf_wait_for_recycle (rtems_bdbuf_buffer *bd)
{
while (true)
{
switch (bd->state)
200d8b8: 10 bf ff dc b 200d828 <rtems_bdbuf_get_buffer_for_access+0x5c>
200d8bc: d0 07 60 20 ld [ %i5 + 0x20 ], %o0
case RTEMS_BDBUF_STATE_TRANSFER:
case RTEMS_BDBUF_STATE_TRANSFER_PURGED:
rtems_bdbuf_wait (bd, &bdbuf_cache.transfer_waiters);
break;
default:
rtems_bdbuf_fatal (bd->state, RTEMS_BLKDEV_FATAL_BDBUF_STATE_8);
200d8c0: 10 80 00 2d b 200d974 <rtems_bdbuf_get_buffer_for_access+0x1a8><== NOT EXECUTED
200d8c4: 92 12 60 06 or %o1, 6, %o1 <== NOT EXECUTED
bd = NULL;
}
}
else
{
bd = rtems_bdbuf_get_buffer_from_lru_list (dd, block);
200d8c8: 7f ff fe c5 call 200d3dc <rtems_bdbuf_get_buffer_from_lru_list>
200d8cc: 92 10 00 19 mov %i1, %o1
if (bd == NULL)
200d8d0: ba 92 20 00 orcc %o0, 0, %i5
200d8d4: 32 80 00 0a bne,a 200d8fc <rtems_bdbuf_get_buffer_for_access+0x130>
200d8d8: 39 00 80 86 sethi %hi(0x2021800), %i4
}
static void
rtems_bdbuf_wait_for_buffer (void)
{
if (!rtems_chain_is_empty (&bdbuf_cache.modified))
200d8dc: c2 07 20 4c ld [ %i4 + 0x4c ], %g1 ! 202184c <rtems_termios_linesw+0xd8>
200d8e0: 80 a0 40 13 cmp %g1, %l3
200d8e4: 02 bf ff ea be 200d88c <rtems_bdbuf_get_buffer_for_access+0xc0>
200d8e8: 01 00 00 00 nop
rtems_bdbuf_wake_swapper ();
200d8ec: 7f ff fc d0 call 200cc2c <rtems_bdbuf_wake_swapper>
200d8f0: 01 00 00 00 nop
200d8f4: 30 bf ff e6 b,a 200d88c <rtems_bdbuf_get_buffer_for_access+0xc0>
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);
200d8f8: 39 00 80 86 sethi %hi(0x2021800), %i4
static void
rtems_bdbuf_wait_for_access (rtems_bdbuf_buffer *bd)
{
while (true)
{
switch (bd->state)
200d8fc: 37 00 80 32 sethi %hi(0x200c800), %i3
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);
200d900: b8 17 20 e8 or %i4, 0xe8, %i4
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);
200d904: b4 07 3f f8 add %i4, -8, %i2
static void
rtems_bdbuf_wait_for_access (rtems_bdbuf_buffer *bd)
{
while (true)
{
switch (bd->state)
200d908: d0 07 60 20 ld [ %i5 + 0x20 ], %o0
200d90c: 82 02 3f ff add %o0, -1, %g1
200d910: 80 a0 60 09 cmp %g1, 9
200d914: 18 80 00 17 bgu 200d970 <rtems_bdbuf_get_buffer_for_access+0x1a4><== NEVER TAKEN
200d918: 13 10 80 00 sethi %hi(0x42000000), %o1
200d91c: 84 16 e2 b8 or %i3, 0x2b8, %g2
200d920: 83 28 60 02 sll %g1, 2, %g1
200d924: c2 00 80 01 ld [ %g2 + %g1 ], %g1
200d928: 81 c0 40 00 jmp %g1
200d92c: 01 00 00 00 nop
{
case RTEMS_BDBUF_STATE_MODIFIED:
rtems_bdbuf_group_release (bd);
200d930: 7f ff fc 91 call 200cb74 <rtems_bdbuf_group_release>
200d934: 90 10 00 1d mov %i5, %o0
)
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
200d938: c4 07 40 00 ld [ %i5 ], %g2
previous = the_node->previous;
200d93c: c2 07 60 04 ld [ %i5 + 4 ], %g1
next->previous = previous;
200d940: c2 20 a0 04 st %g1, [ %g2 + 4 ]
previous->next = next;
200d944: 10 80 00 16 b 200d99c <rtems_bdbuf_get_buffer_for_access+0x1d0>
200d948: c4 20 40 00 st %g2, [ %g1 ]
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);
200d94c: 90 10 00 1d mov %i5, %o0
200d950: 10 80 00 04 b 200d960 <rtems_bdbuf_get_buffer_for_access+0x194>
200d954: 92 10 00 1a mov %i2, %o1
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);
200d958: 90 10 00 1d mov %i5, %o0
200d95c: 92 10 00 1c mov %i4, %o1
200d960: 7f ff fd 12 call 200cda8 <rtems_bdbuf_wait>
200d964: 01 00 00 00 nop
static void
rtems_bdbuf_wait_for_access (rtems_bdbuf_buffer *bd)
{
while (true)
{
switch (bd->state)
200d968: 10 bf ff e9 b 200d90c <rtems_bdbuf_get_buffer_for_access+0x140>
200d96c: d0 07 60 20 ld [ %i5 + 0x20 ], %o0
case RTEMS_BDBUF_STATE_TRANSFER:
case RTEMS_BDBUF_STATE_TRANSFER_PURGED:
rtems_bdbuf_wait (bd, &bdbuf_cache.transfer_waiters);
break;
default:
rtems_bdbuf_fatal (bd->state, RTEMS_BLKDEV_FATAL_BDBUF_STATE_7);
200d970: 92 12 60 05 or %o1, 5, %o1 <== NOT EXECUTED
200d974: 7f ff fc 98 call 200cbd4 <rtems_bdbuf_fatal> <== NOT EXECUTED
200d978: 01 00 00 00 nop <== NOT EXECUTED
{
if (bd->group->bds_per_group != dd->bds_per_group)
{
if (rtems_bdbuf_wait_for_recycle (bd))
{
rtems_bdbuf_remove_from_tree_and_lru_list (bd);
200d97c: 7f ff fe 85 call 200d390 <rtems_bdbuf_remove_from_tree_and_lru_list><== NOT EXECUTED
200d980: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
rtems_bdbuf_make_free_and_add_to_lru_list (bd);
200d984: 7f ff fe 43 call 200d290 <rtems_bdbuf_make_free_and_add_to_lru_list><== NOT EXECUTED
200d988: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
rtems_bdbuf_wake (&bdbuf_cache.buffer_waiters);
200d98c: 7f ff fd 42 call 200ce94 <rtems_bdbuf_wake> <== NOT EXECUTED
200d990: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
{
rtems_bdbuf_buffer *bd = NULL;
do
{
bd = rtems_bdbuf_avl_search (&bdbuf_cache.tree, dd, block);
200d994: 10 bf ff 98 b 200d7f4 <rtems_bdbuf_get_buffer_for_access+0x28><== NOT EXECUTED
200d998: d0 07 20 3c ld [ %i4 + 0x3c ], %o0 <== NOT EXECUTED
}
}
while (bd == NULL);
rtems_bdbuf_wait_for_access (bd);
rtems_bdbuf_group_obtain (bd);
200d99c: 90 10 00 1d mov %i5, %o0
200d9a0: 7f ff fc 70 call 200cb60 <rtems_bdbuf_group_obtain>
200d9a4: b0 10 00 1d mov %i5, %i0
return bd;
}
200d9a8: 81 c7 e0 08 ret
200d9ac: 81 e8 00 00 restore
0200d780 <rtems_bdbuf_get_buffer_for_read_ahead>:
}
static rtems_bdbuf_buffer *
rtems_bdbuf_get_buffer_for_read_ahead (rtems_disk_device *dd,
rtems_blkdev_bnum block)
{
200d780: 9d e3 bf a0 save %sp, -96, %sp
rtems_bdbuf_buffer *bd = NULL;
bd = rtems_bdbuf_avl_search (&bdbuf_cache.tree, dd, block);
200d784: 03 00 80 86 sethi %hi(0x2021800), %g1
200d788: d0 00 60 b8 ld [ %g1 + 0xb8 ], %o0 ! 20218b8 <bdbuf_cache+0x3c>
200d78c: 92 10 00 18 mov %i0, %o1
200d790: 94 10 00 19 mov %i1, %o2
200d794: 7f ff fd a7 call 200ce30 <rtems_bdbuf_avl_search.isra.0>
200d798: ba 10 20 00 clr %i5
if (bd == NULL)
200d79c: 80 a2 20 00 cmp %o0, 0
200d7a0: 12 80 00 09 bne 200d7c4 <rtems_bdbuf_get_buffer_for_read_ahead+0x44><== NEVER TAKEN
200d7a4: 90 10 00 18 mov %i0, %o0
{
bd = rtems_bdbuf_get_buffer_from_lru_list (dd, block);
200d7a8: 7f ff ff 0d call 200d3dc <rtems_bdbuf_get_buffer_from_lru_list>
200d7ac: 92 10 00 19 mov %i1, %o1
if (bd != NULL)
200d7b0: ba 92 20 00 orcc %o0, 0, %i5
200d7b4: 02 80 00 04 be 200d7c4 <rtems_bdbuf_get_buffer_for_read_ahead+0x44><== NEVER TAKEN
200d7b8: 01 00 00 00 nop
rtems_bdbuf_group_obtain (bd);
200d7bc: 7f ff fc e9 call 200cb60 <rtems_bdbuf_group_obtain>
200d7c0: 01 00 00 00 nop
* thus no need for a read ahead.
*/
bd = NULL;
return bd;
}
200d7c4: 81 c7 e0 08 ret
200d7c8: 91 e8 00 1d restore %g0, %i5, %o0
0200d3dc <rtems_bdbuf_get_buffer_from_lru_list>:
}
static rtems_bdbuf_buffer *
rtems_bdbuf_get_buffer_from_lru_list (rtems_disk_device *dd,
rtems_blkdev_bnum block)
{
200d3dc: 9d e3 bf 20 save %sp, -224, %sp
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
200d3e0: 25 00 80 86 sethi %hi(0x2021800), %l2
200d3e4: 90 14 a0 7c or %l2, 0x7c, %o0 ! 202187c <bdbuf_cache>
200d3e8: f8 02 20 40 ld [ %o0 + 0x40 ], %i4
rtems_chain_node *node = rtems_chain_first (&bdbuf_cache.lru);
while (!rtems_chain_is_tail (&bdbuf_cache.lru, node))
200d3ec: a2 02 20 44 add %o0, 0x44, %l1
200d3f0: 10 80 00 de b 200d768 <rtems_bdbuf_get_buffer_from_lru_list+0x38c>
200d3f4: a6 02 20 74 add %o0, 0x74, %l3
bd->group->bds_per_group, dd->bds_per_group);
/*
* If nobody waits for this BD, we may recycle it.
*/
if (bd->waiters == 0)
200d3f8: 80 a0 60 00 cmp %g1, 0
200d3fc: 32 80 00 db bne,a 200d768 <rtems_bdbuf_get_buffer_from_lru_list+0x38c>
200d400: f8 07 00 00 ld [ %i4 ], %i4
{
if (bd->group->bds_per_group == dd->bds_per_group)
200d404: fa 07 20 28 ld [ %i4 + 0x28 ], %i5
200d408: f6 06 20 34 ld [ %i0 + 0x34 ], %i3
200d40c: d2 07 60 08 ld [ %i5 + 8 ], %o1
200d410: 80 a2 40 1b cmp %o1, %i3
200d414: 32 80 00 06 bne,a 200d42c <rtems_bdbuf_get_buffer_from_lru_list+0x50>
200d418: c2 07 60 0c ld [ %i5 + 0xc ], %g1
{
rtems_bdbuf_remove_from_tree_and_lru_list (bd);
200d41c: 7f ff ff dd call 200d390 <rtems_bdbuf_remove_from_tree_and_lru_list>
200d420: 90 10 00 1c mov %i4, %o0
200d424: 10 80 00 30 b 200d4e4 <rtems_bdbuf_get_buffer_from_lru_list+0x108>
200d428: 84 10 00 1c mov %i4, %g2
empty_bd = bd;
}
else if (bd->group->users == 0)
200d42c: 80 a0 60 00 cmp %g1, 0
200d430: 32 80 00 ce bne,a 200d768 <rtems_bdbuf_get_buffer_from_lru_list+0x38c>
200d434: f8 07 00 00 ld [ %i4 ], %i4
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;
200d438: d0 04 7f dc ld [ %l1 + -36 ], %o0
200d43c: 40 00 3d 3c call 201c92c <.udiv>
200d440: f4 07 60 10 ld [ %i5 + 0x10 ], %i2
for (b = 0, bd = group->bdbuf;
200d444: a0 10 20 00 clr %l0
b < group->bds_per_group;
b++, bd += bufs_per_bd)
200d448: 83 2a 20 03 sll %o0, 3, %g1
200d44c: 91 2a 20 06 sll %o0, 6, %o0
200d450: 10 80 00 05 b 200d464 <rtems_bdbuf_get_buffer_from_lru_list+0x88>
200d454: a8 22 00 01 sub %o0, %g1, %l4
rtems_bdbuf_remove_from_tree_and_lru_list (bd);
200d458: 7f ff ff ce call 200d390 <rtems_bdbuf_remove_from_tree_and_lru_list>
200d45c: a0 04 20 01 inc %l0
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)
200d460: b4 06 80 14 add %i2, %l4, %i2
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;
200d464: c2 07 60 08 ld [ %i5 + 8 ], %g1
200d468: 80 a4 00 01 cmp %l0, %g1
200d46c: 0a bf ff fb bcs 200d458 <rtems_bdbuf_get_buffer_from_lru_list+0x7c>
200d470: 90 10 00 1a mov %i2, %o0
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;
200d474: 82 14 a0 7c or %l2, 0x7c, %g1
200d478: d0 00 60 20 ld [ %g1 + 0x20 ], %o0
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;
200d47c: f6 27 60 08 st %i3, [ %i5 + 8 ]
bufs_per_bd = bdbuf_cache.max_bds_per_group / new_bds_per_group;
200d480: 40 00 3d 2b call 201c92c <.udiv>
200d484: 92 10 00 1b mov %i3, %o1
for (b = 1, bd = group->bdbuf + bufs_per_bd;
200d488: f4 07 60 10 ld [ %i5 + 0x10 ], %i2
200d48c: 83 2a 20 03 sll %o0, 3, %g1
200d490: a1 2a 20 06 sll %o0, 6, %l0
200d494: b6 10 20 01 mov 1, %i3
200d498: a0 24 00 01 sub %l0, %g1, %l0
200d49c: 10 80 00 05 b 200d4b0 <rtems_bdbuf_get_buffer_from_lru_list+0xd4>
200d4a0: b4 06 80 10 add %i2, %l0, %i2
b < group->bds_per_group;
b++, bd += bufs_per_bd)
rtems_bdbuf_make_free_and_add_to_lru_list (bd);
200d4a4: 7f ff ff 7b call 200d290 <rtems_bdbuf_make_free_and_add_to_lru_list>
200d4a8: b6 06 e0 01 inc %i3
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)
200d4ac: b4 06 80 10 add %i2, %l0, %i2
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;
200d4b0: c2 07 60 08 ld [ %i5 + 8 ], %g1
200d4b4: 80 a6 c0 01 cmp %i3, %g1
200d4b8: 0a bf ff fb bcs 200d4a4 <rtems_bdbuf_get_buffer_from_lru_list+0xc8>
200d4bc: 90 10 00 1a mov %i2, %o0
b < group->bds_per_group;
b++, bd += bufs_per_bd)
rtems_bdbuf_make_free_and_add_to_lru_list (bd);
if (b > 1)
200d4c0: 80 a6 e0 01 cmp %i3, 1
200d4c4: 28 80 00 05 bleu,a 200d4d8 <rtems_bdbuf_get_buffer_from_lru_list+0xfc>
200d4c8: c4 07 60 10 ld [ %i5 + 0x10 ], %g2
rtems_bdbuf_wake (&bdbuf_cache.buffer_waiters);
200d4cc: 7f ff fe 72 call 200ce94 <rtems_bdbuf_wake>
200d4d0: 90 10 00 13 mov %l3, %o0
return group->bdbuf;
200d4d4: c4 07 60 10 ld [ %i5 + 0x10 ], %g2
}
else if (bd->group->users == 0)
empty_bd = rtems_bdbuf_group_realloc (bd->group, dd->bds_per_group);
}
if (empty_bd != NULL)
200d4d8: 80 a0 a0 00 cmp %g2, 0
200d4dc: 22 80 00 a3 be,a 200d768 <rtems_bdbuf_get_buffer_from_lru_list+0x38c><== NEVER TAKEN
200d4e0: f8 07 00 00 ld [ %i4 ], %i4 <== NOT EXECUTED
static void
rtems_bdbuf_setup_empty_buffer (rtems_bdbuf_buffer *bd,
rtems_disk_device *dd,
rtems_blkdev_bnum block)
{
bd->dd = dd ;
200d4e4: f0 20 a0 14 st %i0, [ %g2 + 0x14 ]
bd->block = block;
bd->avl.left = NULL;
200d4e8: c0 20 a0 08 clr [ %g2 + 8 ]
bd->avl.right = NULL;
200d4ec: c0 20 a0 0c clr [ %g2 + 0xc ]
rtems_bdbuf_buffer* node)
{
const rtems_disk_device *dd = node->dd;
rtems_blkdev_bnum block = node->block;
rtems_bdbuf_buffer* p = *root;
200d4f0: 07 00 80 86 sethi %hi(0x2021800), %g3
200d4f4: 86 10 e0 7c or %g3, 0x7c, %g3 ! 202187c <bdbuf_cache>
200d4f8: c2 00 e0 3c ld [ %g3 + 0x3c ], %g1
rtems_bdbuf_setup_empty_buffer (rtems_bdbuf_buffer *bd,
rtems_disk_device *dd,
rtems_blkdev_bnum block)
{
bd->dd = dd ;
bd->block = block;
200d4fc: f2 20 a0 18 st %i1, [ %g2 + 0x18 ]
bd->avl.left = NULL;
bd->avl.right = NULL;
bd->waiters = 0;
200d500: c0 20 a0 24 clr [ %g2 + 0x24 ]
rtems_bdbuf_buffer* p = *root;
rtems_bdbuf_buffer* q;
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;
200d504: ba 07 bf 80 add %fp, -128, %i5
break;
}
}
else if ((p->dd != dd) || (p->block != block))
{
p->avl.cache = -1;
200d508: b8 10 3f ff mov -1, %i4
rtems_bdbuf_buffer* buf_stack[RTEMS_BDBUF_AVL_MAX_HEIGHT];
rtems_bdbuf_buffer** buf_prev = buf_stack;
bool modified = false;
if (p == NULL)
200d50c: 80 a0 60 00 cmp %g1, 0
200d510: 12 80 00 1d bne 200d584 <rtems_bdbuf_get_buffer_from_lru_list+0x1a8>
200d514: b6 10 20 01 mov 1, %i3
{
*root = node;
200d518: c4 20 e0 3c st %g2, [ %g3 + 0x3c ]
node->avl.left = NULL;
200d51c: c0 20 a0 08 clr [ %g2 + 8 ]
node->avl.right = NULL;
200d520: c0 20 a0 0c clr [ %g2 + 0xc ]
node->avl.bal = 0;
200d524: 10 80 00 8e b 200d75c <rtems_bdbuf_get_buffer_from_lru_list+0x380>
200d528: c0 28 a0 11 clrb [ %g2 + 0x11 ]
while (p != NULL)
{
*buf_prev++ = p;
if (((uintptr_t) p->dd < (uintptr_t) dd)
|| ((p->dd == dd) && (p->block < block)))
200d52c: 32 80 00 0f bne,a 200d568 <rtems_bdbuf_get_buffer_from_lru_list+0x18c><== NEVER TAKEN
200d530: c6 00 60 08 ld [ %g1 + 8 ], %g3 <== NOT EXECUTED
200d534: c6 00 60 18 ld [ %g1 + 0x18 ], %g3
200d538: 80 a0 c0 19 cmp %g3, %i1
200d53c: 1a 80 00 08 bcc 200d55c <rtems_bdbuf_get_buffer_from_lru_list+0x180>
200d540: 01 00 00 00 nop
{
p->avl.cache = 1;
q = p->avl.right;
200d544: c6 00 60 0c ld [ %g1 + 0xc ], %g3
if (q == NULL)
200d548: 80 a0 e0 00 cmp %g3, 0
200d54c: 12 80 00 0c bne 200d57c <rtems_bdbuf_get_buffer_from_lru_list+0x1a0>
200d550: f6 28 60 10 stb %i3, [ %g1 + 0x10 ]
{
q = node;
p->avl.right = q = node;
200d554: 10 80 00 12 b 200d59c <rtems_bdbuf_get_buffer_from_lru_list+0x1c0>
200d558: c4 20 60 0c st %g2, [ %g1 + 0xc ]
break;
}
}
else if ((p->dd != dd) || (p->block != block))
200d55c: 02 80 00 7e be 200d754 <rtems_bdbuf_get_buffer_from_lru_list+0x378><== NEVER TAKEN
200d560: 11 10 80 00 sethi %hi(0x42000000), %o0
{
p->avl.cache = -1;
q = p->avl.left;
200d564: c6 00 60 08 ld [ %g1 + 8 ], %g3
if (q == NULL)
200d568: 80 a0 e0 00 cmp %g3, 0
200d56c: 12 80 00 04 bne 200d57c <rtems_bdbuf_get_buffer_from_lru_list+0x1a0>
200d570: f8 28 60 10 stb %i4, [ %g1 + 0x10 ]
{
q = node;
p->avl.left = q;
200d574: 10 80 00 0a b 200d59c <rtems_bdbuf_get_buffer_from_lru_list+0x1c0>
200d578: c4 20 60 08 st %g2, [ %g1 + 8 ]
rtems_bdbuf_buffer* buf_stack[RTEMS_BDBUF_AVL_MAX_HEIGHT];
rtems_bdbuf_buffer** buf_prev = buf_stack;
bool modified = false;
if (p == NULL)
200d57c: ba 10 00 04 mov %g4, %i5
200d580: 82 10 00 03 mov %g3, %g1
while (p != NULL)
{
*buf_prev++ = p;
if (((uintptr_t) p->dd < (uintptr_t) dd)
200d584: c6 00 60 14 ld [ %g1 + 0x14 ], %g3
return 0;
}
while (p != NULL)
{
*buf_prev++ = p;
200d588: c2 27 40 00 st %g1, [ %i5 ]
if (((uintptr_t) p->dd < (uintptr_t) dd)
200d58c: 80 a0 c0 18 cmp %g3, %i0
200d590: 0a bf ff ed bcs 200d544 <rtems_bdbuf_get_buffer_from_lru_list+0x168><== NEVER TAKEN
200d594: 88 07 60 04 add %i5, 4, %g4
200d598: 30 bf ff e5 b,a 200d52c <rtems_bdbuf_get_buffer_from_lru_list+0x150>
}
p = q;
}
q->avl.left = q->avl.right = NULL;
200d59c: c0 20 a0 0c clr [ %g2 + 0xc ]
200d5a0: c0 20 a0 08 clr [ %g2 + 8 ]
q->avl.bal = 0;
200d5a4: c0 28 a0 11 clrb [ %g2 + 0x11 ]
p->avl.bal = 0;
modified = false;
break;
case 0:
p->avl.bal = 1;
200d5a8: b8 10 20 01 mov 1, %i4
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;
200d5ac: b4 10 3f ff mov -1, %i2
default:
break;
}
}
q = p;
if (buf_prev > buf_stack)
200d5b0: 10 80 00 03 b 200d5bc <rtems_bdbuf_get_buffer_from_lru_list+0x1e0>
200d5b4: b2 07 bf 80 add %fp, -128, %i1
q->avl.left = q->avl.right = NULL;
q->avl.bal = 0;
modified = true;
buf_prev--;
while (modified)
200d5b8: 82 10 00 04 mov %g4, %g1
{
if (p->avl.cache == -1)
200d5bc: c8 48 60 10 ldsb [ %g1 + 0x10 ], %g4
200d5c0: c6 08 60 11 ldub [ %g1 + 0x11 ], %g3
200d5c4: 80 a1 3f ff cmp %g4, -1
{
switch (p->avl.bal)
200d5c8: 87 28 e0 18 sll %g3, 0x18, %g3
modified = true;
buf_prev--;
while (modified)
{
if (p->avl.cache == -1)
200d5cc: 12 80 00 26 bne 200d664 <rtems_bdbuf_get_buffer_from_lru_list+0x288>
200d5d0: 87 38 e0 18 sra %g3, 0x18, %g3
{
switch (p->avl.bal)
200d5d4: 80 a0 e0 00 cmp %g3, 0
200d5d8: 22 80 00 4d be,a 200d70c <rtems_bdbuf_get_buffer_from_lru_list+0x330>
200d5dc: c8 28 60 11 stb %g4, [ %g1 + 0x11 ]
200d5e0: 80 a0 e0 01 cmp %g3, 1
200d5e4: 02 80 00 28 be 200d684 <rtems_bdbuf_get_buffer_from_lru_list+0x2a8>
200d5e8: 80 a0 ff ff cmp %g3, -1
200d5ec: 32 80 00 49 bne,a 200d710 <rtems_bdbuf_get_buffer_from_lru_list+0x334><== NEVER TAKEN
200d5f0: 86 10 20 01 mov 1, %g3 <== NOT EXECUTED
case 0:
p->avl.bal = -1;
break;
case -1:
p1 = p->avl.left;
200d5f4: 10 80 00 02 b 200d5fc <rtems_bdbuf_get_buffer_from_lru_list+0x220>
200d5f8: c6 00 60 08 ld [ %g1 + 8 ], %g3
if (p1->avl.bal == -1) /* simple LL-turn */
200d5fc: c8 48 e0 11 ldsb [ %g3 + 0x11 ], %g4
200d600: 80 a1 3f ff cmp %g4, -1
200d604: 12 80 00 05 bne 200d618 <rtems_bdbuf_get_buffer_from_lru_list+0x23c>
200d608: c8 00 e0 0c ld [ %g3 + 0xc ], %g4
{
p->avl.left = p1->avl.right;
200d60c: c8 20 60 08 st %g4, [ %g1 + 8 ]
p1->avl.right = p;
200d610: 10 80 00 26 b 200d6a8 <rtems_bdbuf_get_buffer_from_lru_list+0x2cc>
200d614: c2 20 e0 0c st %g1, [ %g3 + 0xc ]
p = p1;
}
else /* double LR-turn */
{
p2 = p1->avl.right;
p1->avl.right = p2->avl.left;
200d618: f0 01 20 08 ld [ %g4 + 8 ], %i0
p2->avl.left = p1;
200d61c: c6 21 20 08 st %g3, [ %g4 + 8 ]
p = p1;
}
else /* double LR-turn */
{
p2 = p1->avl.right;
p1->avl.right = p2->avl.left;
200d620: f0 20 e0 0c st %i0, [ %g3 + 0xc ]
p2->avl.left = p1;
p->avl.left = p2->avl.right;
200d624: f0 01 20 0c ld [ %g4 + 0xc ], %i0
p2->avl.right = p;
200d628: c2 21 20 0c st %g1, [ %g4 + 0xc ]
else /* double LR-turn */
{
p2 = p1->avl.right;
p1->avl.right = p2->avl.left;
p2->avl.left = p1;
p->avl.left = p2->avl.right;
200d62c: f0 20 60 08 st %i0, [ %g1 + 8 ]
p2->avl.right = p;
if (p2->avl.bal == -1) p->avl.bal = +1; else p->avl.bal = 0;
200d630: f0 49 20 11 ldsb [ %g4 + 0x11 ], %i0
200d634: 80 a6 3f ff cmp %i0, -1
200d638: 12 80 00 04 bne 200d648 <rtems_bdbuf_get_buffer_from_lru_list+0x26c><== ALWAYS TAKEN
200d63c: b6 10 00 04 mov %g4, %i3
200d640: 10 80 00 03 b 200d64c <rtems_bdbuf_get_buffer_from_lru_list+0x270><== NOT EXECUTED
200d644: f8 28 60 11 stb %i4, [ %g1 + 0x11 ] <== NOT EXECUTED
200d648: c0 28 60 11 clrb [ %g1 + 0x11 ]
if (p2->avl.bal == +1) p1->avl.bal = -1; else p1->avl.bal = 0;
200d64c: c2 49 20 11 ldsb [ %g4 + 0x11 ], %g1
200d650: 80 a0 60 01 cmp %g1, 1
200d654: 32 80 00 2a bne,a 200d6fc <rtems_bdbuf_get_buffer_from_lru_list+0x320>
200d658: c0 28 e0 11 clrb [ %g3 + 0x11 ]
200d65c: 10 80 00 28 b 200d6fc <rtems_bdbuf_get_buffer_from_lru_list+0x320>
200d660: f4 28 e0 11 stb %i2, [ %g3 + 0x11 ]
break;
}
}
else
{
switch (p->avl.bal)
200d664: 80 a0 e0 00 cmp %g3, 0
200d668: 22 80 00 29 be,a 200d70c <rtems_bdbuf_get_buffer_from_lru_list+0x330>
200d66c: f8 28 60 11 stb %i4, [ %g1 + 0x11 ]
200d670: 80 a0 e0 01 cmp %g3, 1
200d674: 02 80 00 06 be 200d68c <rtems_bdbuf_get_buffer_from_lru_list+0x2b0>
200d678: 80 a0 ff ff cmp %g3, -1
200d67c: 32 80 00 25 bne,a 200d710 <rtems_bdbuf_get_buffer_from_lru_list+0x334><== NEVER TAKEN
200d680: 86 10 20 01 mov 1, %g3 <== NOT EXECUTED
{
case -1:
p->avl.bal = 0;
200d684: 10 80 00 20 b 200d704 <rtems_bdbuf_get_buffer_from_lru_list+0x328>
200d688: c0 28 60 11 clrb [ %g1 + 0x11 ]
case 0:
p->avl.bal = 1;
break;
case 1:
p1 = p->avl.right;
200d68c: c6 00 60 0c ld [ %g1 + 0xc ], %g3
if (p1->avl.bal == 1) /* simple RR-turn */
200d690: c8 48 e0 11 ldsb [ %g3 + 0x11 ], %g4
200d694: 80 a1 20 01 cmp %g4, 1
200d698: 12 80 00 07 bne 200d6b4 <rtems_bdbuf_get_buffer_from_lru_list+0x2d8>
200d69c: c8 00 e0 08 ld [ %g3 + 8 ], %g4
{
p->avl.right = p1->avl.left;
200d6a0: c8 20 60 0c st %g4, [ %g1 + 0xc ]
p1->avl.left = p;
200d6a4: c2 20 e0 08 st %g1, [ %g3 + 8 ]
p->avl.bal = 0;
200d6a8: c0 28 60 11 clrb [ %g1 + 0x11 ]
200d6ac: 10 80 00 14 b 200d6fc <rtems_bdbuf_get_buffer_from_lru_list+0x320>
200d6b0: b6 10 00 03 mov %g3, %i3
p = p1;
}
else /* double RL-turn */
{
p2 = p1->avl.left;
p1->avl.left = p2->avl.right;
200d6b4: f0 01 20 0c ld [ %g4 + 0xc ], %i0
p2->avl.right = p1;
200d6b8: c6 21 20 0c st %g3, [ %g4 + 0xc ]
p = p1;
}
else /* double RL-turn */
{
p2 = p1->avl.left;
p1->avl.left = p2->avl.right;
200d6bc: f0 20 e0 08 st %i0, [ %g3 + 8 ]
p2->avl.right = p1;
p->avl.right = p2->avl.left;
200d6c0: f0 01 20 08 ld [ %g4 + 8 ], %i0
p2->avl.left = p;
200d6c4: c2 21 20 08 st %g1, [ %g4 + 8 ]
else /* double RL-turn */
{
p2 = p1->avl.left;
p1->avl.left = p2->avl.right;
p2->avl.right = p1;
p->avl.right = p2->avl.left;
200d6c8: f0 20 60 0c st %i0, [ %g1 + 0xc ]
p2->avl.left = p;
if (p2->avl.bal == +1) p->avl.bal = -1; else p->avl.bal = 0;
200d6cc: f0 49 20 11 ldsb [ %g4 + 0x11 ], %i0
200d6d0: 80 a6 20 01 cmp %i0, 1
200d6d4: 12 80 00 04 bne 200d6e4 <rtems_bdbuf_get_buffer_from_lru_list+0x308><== ALWAYS TAKEN
200d6d8: b6 10 00 04 mov %g4, %i3
200d6dc: 10 80 00 03 b 200d6e8 <rtems_bdbuf_get_buffer_from_lru_list+0x30c><== NOT EXECUTED
200d6e0: f4 28 60 11 stb %i2, [ %g1 + 0x11 ] <== NOT EXECUTED
200d6e4: c0 28 60 11 clrb [ %g1 + 0x11 ]
if (p2->avl.bal == -1) p1->avl.bal = +1; else p1->avl.bal = 0;
200d6e8: c2 49 20 11 ldsb [ %g4 + 0x11 ], %g1
200d6ec: 80 a0 7f ff cmp %g1, -1
200d6f0: 32 80 00 03 bne,a 200d6fc <rtems_bdbuf_get_buffer_from_lru_list+0x320>
200d6f4: c0 28 e0 11 clrb [ %g3 + 0x11 ]
200d6f8: f8 28 e0 11 stb %i4, [ %g3 + 0x11 ]
p = p2;
}
p->avl.bal = 0;
200d6fc: c0 2e e0 11 clrb [ %i3 + 0x11 ]
200d700: 82 10 00 1b mov %i3, %g1
modified = false;
200d704: 10 80 00 03 b 200d710 <rtems_bdbuf_get_buffer_from_lru_list+0x334>
200d708: 86 10 20 00 clr %g3
break;
}
}
else
{
switch (p->avl.bal)
200d70c: 86 10 20 01 mov 1, %g3
default:
break;
}
}
q = p;
if (buf_prev > buf_stack)
200d710: 80 a7 40 19 cmp %i5, %i1
200d714: 28 80 00 09 bleu,a 200d738 <rtems_bdbuf_get_buffer_from_lru_list+0x35c>
200d718: 07 00 80 86 sethi %hi(0x2021800), %g3
{
p = *--buf_prev;
200d71c: c8 07 7f fc ld [ %i5 + -4 ], %g4
if (p->avl.cache == -1)
200d720: f6 49 20 10 ldsb [ %g4 + 0x10 ], %i3
200d724: 80 a6 ff ff cmp %i3, -1
200d728: 32 80 00 06 bne,a 200d740 <rtems_bdbuf_get_buffer_from_lru_list+0x364>
200d72c: c2 21 20 0c st %g1, [ %g4 + 0xc ]
{
p->avl.left = q;
200d730: 10 80 00 04 b 200d740 <rtems_bdbuf_get_buffer_from_lru_list+0x364>
200d734: c2 21 20 08 st %g1, [ %g4 + 8 ]
p->avl.right = q;
}
}
else
{
*root = p;
200d738: 10 80 00 09 b 200d75c <rtems_bdbuf_get_buffer_from_lru_list+0x380>
200d73c: c2 20 e0 b8 st %g1, [ %g3 + 0xb8 ]
q->avl.left = q->avl.right = NULL;
q->avl.bal = 0;
modified = true;
buf_prev--;
while (modified)
200d740: 80 88 e0 ff btst 0xff, %g3
200d744: 12 bf ff 9d bne 200d5b8 <rtems_bdbuf_get_buffer_from_lru_list+0x1dc>
200d748: ba 07 7f fc add %i5, -4, %i5
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
200d74c: 10 80 00 05 b 200d760 <rtems_bdbuf_get_buffer_from_lru_list+0x384>
200d750: 82 10 20 01 mov 1, %g1
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);
200d754: 7f ff ef 11 call 2009398 <rtems_fatal_error_occurred> <== NOT EXECUTED
200d758: 90 12 20 1b or %o0, 0x1b, %o0 <== NOT EXECUTED
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
200d75c: 82 10 20 01 mov 1, %g1
200d760: 10 80 00 06 b 200d778 <rtems_bdbuf_get_buffer_from_lru_list+0x39c>
200d764: c2 20 a0 20 st %g1, [ %g2 + 0x20 ]
rtems_bdbuf_get_buffer_from_lru_list (rtems_disk_device *dd,
rtems_blkdev_bnum block)
{
rtems_chain_node *node = rtems_chain_first (&bdbuf_cache.lru);
while (!rtems_chain_is_tail (&bdbuf_cache.lru, node))
200d768: 80 a7 00 11 cmp %i4, %l1
200d76c: 32 bf ff 23 bne,a 200d3f8 <rtems_bdbuf_get_buffer_from_lru_list+0x1c>
200d770: c2 07 20 24 ld [ %i4 + 0x24 ], %g1
}
node = rtems_chain_next (node);
}
return NULL;
200d774: 84 10 20 00 clr %g2
}
200d778: 81 c7 e0 08 ret
200d77c: 91 e8 00 02 restore %g0, %g2, %o0
0200e4a0 <rtems_bdbuf_init>:
*
* @return rtems_status_code The initialisation status.
*/
rtems_status_code
rtems_bdbuf_init (void)
{
200e4a0: 9d e3 bf a0 save %sp, -96, %sp
rtems_mode prev_mode;
if (rtems_bdbuf_tracer)
printf ("bdbuf:init\n");
if (rtems_interrupt_is_in_progress())
200e4a4: 03 00 80 88 sethi %hi(0x2022000), %g1
200e4a8: c2 00 62 48 ld [ %g1 + 0x248 ], %g1 ! 2022248 <_Per_CPU_Information+0x8>
200e4ac: 80 a0 60 00 cmp %g1, 0
200e4b0: 12 80 00 16 bne 200e508 <rtems_bdbuf_init+0x68> <== NEVER TAKEN
200e4b4: b0 10 20 12 mov 0x12, %i0
return RTEMS_CALLED_FROM_ISR;
/*
* Check the configuration table values.
*/
if ((bdbuf_config.buffer_max % bdbuf_config.buffer_min) != 0)
200e4b8: 35 00 80 7b sethi %hi(0x201ec00), %i2
200e4bc: b4 16 a1 40 or %i2, 0x140, %i2 ! 201ed40 <rtems_bdbuf_configuration>
200e4c0: f2 06 a0 28 ld [ %i2 + 0x28 ], %i1
200e4c4: f8 06 a0 24 ld [ %i2 + 0x24 ], %i4
200e4c8: 90 10 00 19 mov %i1, %o0
200e4cc: 92 10 00 1c mov %i4, %o1
200e4d0: 40 00 39 c3 call 201cbdc <.urem>
200e4d4: b0 10 20 0a mov 0xa, %i0
200e4d8: 80 a2 20 00 cmp %o0, 0
200e4dc: 12 80 01 01 bne 200e8e0 <rtems_bdbuf_init+0x440> <== NEVER TAKEN
200e4e0: 01 00 00 00 nop
/*
* 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 ();
200e4e4: 7f ff f9 f6 call 200ccbc <rtems_bdbuf_disable_preemption>
200e4e8: 3b 00 80 86 sethi %hi(0x2021800), %i5
if (bdbuf_cache.initialised)
200e4ec: ba 17 60 7c or %i5, 0x7c, %i5 ! 202187c <bdbuf_cache>
200e4f0: c2 0f 60 95 ldub [ %i5 + 0x95 ], %g1
200e4f4: 80 a0 60 00 cmp %g1, 0
200e4f8: 02 80 00 06 be 200e510 <rtems_bdbuf_init+0x70> <== ALWAYS TAKEN
200e4fc: b6 10 00 08 mov %o0, %i3
{
rtems_bdbuf_restore_preemption (prev_mode);
200e500: 7f ff f9 fd call 200ccf4 <rtems_bdbuf_restore_preemption> <== NOT EXECUTED
200e504: b0 10 20 0c mov 0xc, %i0 <== NOT EXECUTED
return RTEMS_RESOURCE_IN_USE;
200e508: 81 c7 e0 08 ret <== NOT EXECUTED
200e50c: 81 e8 00 00 restore <== NOT EXECUTED
}
memset(&bdbuf_cache, 0, sizeof(bdbuf_cache));
200e510: 92 10 20 00 clr %o1
200e514: 94 10 20 98 mov 0x98, %o2
200e518: 40 00 18 23 call 20145a4 <memset>
200e51c: 90 10 00 1d mov %i5, %o0
bdbuf_cache.initialised = true;
200e520: 82 10 20 01 mov 1, %g1
rtems_bdbuf_restore_preemption (prev_mode);
200e524: 90 10 00 1b mov %i3, %o0
200e528: 7f ff f9 f3 call 200ccf4 <rtems_bdbuf_restore_preemption>
200e52c: c2 2f 60 95 stb %g1, [ %i5 + 0x95 ]
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
200e530: 82 07 60 0c add %i5, 0xc, %g1
200e534: c2 27 60 08 st %g1, [ %i5 + 8 ]
head->previous = NULL;
tail->previous = head;
200e538: 82 07 60 08 add %i5, 8, %g1
200e53c: c2 27 60 10 st %g1, [ %i5 + 0x10 ]
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
200e540: 82 07 60 44 add %i5, 0x44, %g1
200e544: c2 27 60 40 st %g1, [ %i5 + 0x40 ]
head->previous = NULL;
tail->previous = head;
200e548: 82 07 60 40 add %i5, 0x40, %g1
200e54c: c2 27 60 48 st %g1, [ %i5 + 0x48 ]
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
200e550: 82 07 60 50 add %i5, 0x50, %g1
200e554: c2 27 60 4c st %g1, [ %i5 + 0x4c ]
head->previous = NULL;
tail->previous = head;
200e558: 82 07 60 4c add %i5, 0x4c, %g1
200e55c: c2 27 60 54 st %g1, [ %i5 + 0x54 ]
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
200e560: 82 07 60 5c add %i5, 0x5c, %g1
200e564: c2 27 60 58 st %g1, [ %i5 + 0x58 ]
head->previous = NULL;
tail->previous = head;
200e568: 82 07 60 58 add %i5, 0x58, %g1
200e56c: c2 27 60 60 st %g1, [ %i5 + 0x60 ]
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
200e570: 82 07 60 8c add %i5, 0x8c, %g1
200e574: c2 27 60 88 st %g1, [ %i5 + 0x88 ]
head->previous = NULL;
tail->previous = head;
200e578: 82 07 60 88 add %i5, 0x88, %g1
*/
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;
200e57c: c0 27 60 38 clr [ %i5 + 0x38 ]
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
head->previous = NULL;
200e580: c0 27 60 0c clr [ %i5 + 0xc ]
200e584: c0 27 60 44 clr [ %i5 + 0x44 ]
200e588: c0 27 60 50 clr [ %i5 + 0x50 ]
200e58c: c0 27 60 5c clr [ %i5 + 0x5c ]
200e590: c0 27 60 8c clr [ %i5 + 0x8c ]
tail->previous = head;
200e594: c2 27 60 90 st %g1, [ %i5 + 0x90 ]
rtems_chain_initialize_empty (&bdbuf_cache.read_ahead_chain);
/*
* Create the locks for the cache.
*/
sc = rtems_semaphore_create (rtems_build_name ('B', 'D', 'C', 'l'),
200e598: 37 10 91 10 sethi %hi(0x42444000), %i3
200e59c: 92 10 20 01 mov 1, %o1
200e5a0: 90 16 e3 6c or %i3, 0x36c, %o0
200e5a4: 94 10 20 54 mov 0x54, %o2
200e5a8: 96 10 20 00 clr %o3
200e5ac: 7f ff e9 30 call 2008a6c <rtems_semaphore_create>
200e5b0: 98 07 60 28 add %i5, 0x28, %o4
1, RTEMS_BDBUF_CACHE_LOCK_ATTRIBS, 0,
&bdbuf_cache.lock);
if (sc != RTEMS_SUCCESSFUL)
200e5b4: 80 a2 20 00 cmp %o0, 0
200e5b8: 12 80 00 a3 bne 200e844 <rtems_bdbuf_init+0x3a4> <== NEVER TAKEN
200e5bc: 03 00 80 86 sethi %hi(0x2021800), %g1
goto error;
rtems_bdbuf_lock_cache ();
200e5c0: 7f ff f9 7e call 200cbb8 <rtems_bdbuf_lock_cache>
200e5c4: 01 00 00 00 nop
sc = rtems_semaphore_create (rtems_build_name ('B', 'D', 'C', 's'),
200e5c8: 90 16 e3 73 or %i3, 0x373, %o0
200e5cc: 92 10 20 01 mov 1, %o1
200e5d0: 94 10 20 54 mov 0x54, %o2
200e5d4: 96 10 20 00 clr %o3
200e5d8: 7f ff e9 25 call 2008a6c <rtems_semaphore_create>
200e5dc: 98 07 60 2c add %i5, 0x2c, %o4
1, RTEMS_BDBUF_CACHE_LOCK_ATTRIBS, 0,
&bdbuf_cache.sync_lock);
if (sc != RTEMS_SUCCESSFUL)
200e5e0: 80 a2 20 00 cmp %o0, 0
200e5e4: 12 80 00 98 bne 200e844 <rtems_bdbuf_init+0x3a4> <== NEVER TAKEN
200e5e8: 03 00 80 86 sethi %hi(0x2021800), %g1
goto error;
sc = rtems_semaphore_create (rtems_build_name ('B', 'D', 'C', 'a'),
200e5ec: 90 16 e3 61 or %i3, 0x361, %o0
200e5f0: 92 10 20 00 clr %o1
200e5f4: 94 10 20 24 mov 0x24, %o2
200e5f8: 96 10 20 00 clr %o3
200e5fc: 7f ff e9 1c call 2008a6c <rtems_semaphore_create>
200e600: 98 07 60 68 add %i5, 0x68, %o4
0, RTEMS_BDBUF_CACHE_WAITER_ATTRIBS, 0,
&bdbuf_cache.access_waiters.sema);
if (sc != RTEMS_SUCCESSFUL)
200e604: 80 a2 20 00 cmp %o0, 0
200e608: 12 80 00 8f bne 200e844 <rtems_bdbuf_init+0x3a4> <== NEVER TAKEN
200e60c: 03 00 80 86 sethi %hi(0x2021800), %g1
goto error;
sc = rtems_semaphore_create (rtems_build_name ('B', 'D', 'C', 't'),
200e610: 90 16 e3 74 or %i3, 0x374, %o0
200e614: 92 10 20 00 clr %o1
200e618: 94 10 20 24 mov 0x24, %o2
200e61c: 96 10 20 00 clr %o3
200e620: 7f ff e9 13 call 2008a6c <rtems_semaphore_create>
200e624: 98 07 60 70 add %i5, 0x70, %o4
0, RTEMS_BDBUF_CACHE_WAITER_ATTRIBS, 0,
&bdbuf_cache.transfer_waiters.sema);
if (sc != RTEMS_SUCCESSFUL)
200e628: 80 a2 20 00 cmp %o0, 0
200e62c: 12 80 00 86 bne 200e844 <rtems_bdbuf_init+0x3a4> <== NEVER TAKEN
200e630: 03 00 80 86 sethi %hi(0x2021800), %g1
goto error;
sc = rtems_semaphore_create (rtems_build_name ('B', 'D', 'C', 'b'),
200e634: 90 16 e3 62 or %i3, 0x362, %o0
200e638: 92 10 20 00 clr %o1
200e63c: 94 10 20 24 mov 0x24, %o2
200e640: 96 10 20 00 clr %o3
200e644: 7f ff e9 0a call 2008a6c <rtems_semaphore_create>
200e648: 98 07 60 78 add %i5, 0x78, %o4
0, RTEMS_BDBUF_CACHE_WAITER_ATTRIBS, 0,
&bdbuf_cache.buffer_waiters.sema);
if (sc != RTEMS_SUCCESSFUL)
200e64c: 80 a2 20 00 cmp %o0, 0
200e650: 12 80 00 7d bne 200e844 <rtems_bdbuf_init+0x3a4> <== NEVER TAKEN
200e654: 03 00 80 86 sethi %hi(0x2021800), %g1
/*
* Compute the various number of elements in the cache.
*/
bdbuf_cache.buffer_min_count =
bdbuf_config.size / bdbuf_config.buffer_min;
200e658: d0 06 a0 20 ld [ %i2 + 0x20 ], %o0
200e65c: 40 00 38 b4 call 201c92c <.udiv>
200e660: 92 10 00 1c mov %i4, %o1
bdbuf_cache.max_bds_per_group =
bdbuf_config.buffer_max / bdbuf_config.buffer_min;
200e664: 92 10 00 1c mov %i4, %o1
/*
* Compute the various number of elements in the cache.
*/
bdbuf_cache.buffer_min_count =
bdbuf_config.size / bdbuf_config.buffer_min;
200e668: b6 10 00 08 mov %o0, %i3
goto error;
/*
* Compute the various number of elements in the cache.
*/
bdbuf_cache.buffer_min_count =
200e66c: d0 27 60 1c st %o0, [ %i5 + 0x1c ]
bdbuf_config.size / bdbuf_config.buffer_min;
bdbuf_cache.max_bds_per_group =
bdbuf_config.buffer_max / bdbuf_config.buffer_min;
200e670: 40 00 38 af call 201c92c <.udiv>
200e674: 90 10 00 19 mov %i1, %o0
200e678: 92 10 00 08 mov %o0, %o1
/*
* 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 =
200e67c: d0 27 60 20 st %o0, [ %i5 + 0x20 ]
bdbuf_config.buffer_max / bdbuf_config.buffer_min;
bdbuf_cache.group_count =
bdbuf_cache.buffer_min_count / bdbuf_cache.max_bds_per_group;
200e680: 40 00 38 ab call 201c92c <.udiv>
200e684: 90 10 00 1b mov %i3, %o0
/*
* Allocate the memory for the buffer descriptors.
*/
bdbuf_cache.bds = calloc (sizeof (rtems_bdbuf_buffer),
200e688: 92 10 00 1b mov %i3, %o1
*/
bdbuf_cache.buffer_min_count =
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 =
200e68c: d0 27 60 7c st %o0, [ %i5 + 0x7c ]
bdbuf_cache.buffer_min_count / bdbuf_cache.max_bds_per_group;
200e690: b4 10 00 08 mov %o0, %i2
/*
* Allocate the memory for the buffer descriptors.
*/
bdbuf_cache.bds = calloc (sizeof (rtems_bdbuf_buffer),
200e694: 7f ff d8 18 call 20046f4 <calloc>
200e698: 90 10 20 38 mov 0x38, %o0
bdbuf_cache.buffer_min_count);
if (!bdbuf_cache.bds)
200e69c: 80 a2 20 00 cmp %o0, 0
200e6a0: 02 80 00 68 be 200e840 <rtems_bdbuf_init+0x3a0> <== NEVER TAKEN
200e6a4: d0 27 60 14 st %o0, [ %i5 + 0x14 ]
goto error;
/*
* Allocate the memory for the buffer descriptors.
*/
bdbuf_cache.groups = calloc (sizeof (rtems_bdbuf_group),
200e6a8: 90 10 20 14 mov 0x14, %o0
200e6ac: 7f ff d8 12 call 20046f4 <calloc>
200e6b0: 92 10 00 1a mov %i2, %o1
bdbuf_cache.group_count);
if (!bdbuf_cache.groups)
200e6b4: 80 a2 20 00 cmp %o0, 0
200e6b8: 02 80 00 62 be 200e840 <rtems_bdbuf_init+0x3a0> <== NEVER TAKEN
200e6bc: d0 27 60 80 st %o0, [ %i5 + 0x80 ]
*
* The memory allocate allows a
*/
if (rtems_memalign ((void **) &bdbuf_cache.buffers,
cache_aligment,
bdbuf_cache.buffer_min_count * bdbuf_config.buffer_min) != 0)
200e6c0: 92 10 00 1c mov %i4, %o1
200e6c4: 40 00 38 60 call 201c844 <.umul>
200e6c8: 90 10 00 1b mov %i3, %o0
* 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,
200e6cc: 92 10 20 20 mov 0x20, %o1
cache_aligment,
bdbuf_cache.buffer_min_count * bdbuf_config.buffer_min) != 0)
200e6d0: 94 10 00 08 mov %o0, %o2
* 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,
200e6d4: 11 00 80 86 sethi %hi(0x2021800), %o0
200e6d8: 40 00 07 50 call 2010418 <rtems_memalign>
200e6dc: 90 12 20 94 or %o0, 0x94, %o0 ! 2021894 <bdbuf_cache+0x18>
200e6e0: 80 a2 20 00 cmp %o0, 0
200e6e4: 12 80 00 58 bne 200e844 <rtems_bdbuf_init+0x3a4> <== NEVER TAKEN
200e6e8: 03 00 80 86 sethi %hi(0x2021800), %g1
/*
* 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,
200e6ec: 03 00 80 86 sethi %hi(0x2021800), %g1
200e6f0: 82 10 60 7c or %g1, 0x7c, %g1 ! 202187c <bdbuf_cache>
200e6f4: f6 00 60 80 ld [ %g1 + 0x80 ], %i3
bd = bdbuf_cache.bds, buffer = bdbuf_cache.buffers;
200e6f8: f4 00 60 14 ld [ %g1 + 0x14 ], %i2
bd->group = group;
bd->buffer = buffer;
rtems_chain_append_unprotected (&bdbuf_cache.lru, &bd->link);
if ((b % bdbuf_cache.max_bds_per_group) ==
200e6fc: e4 00 60 20 ld [ %g1 + 0x20 ], %l2
/*
* 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;
200e700: e0 00 60 18 ld [ %g1 + 0x18 ], %l0
b < bdbuf_cache.buffer_min_count;
200e704: e6 00 60 1c ld [ %g1 + 0x1c ], %l3
bd->buffer = buffer;
rtems_chain_append_unprotected (&bdbuf_cache.lru, &bd->link);
if ((b % bdbuf_cache.max_bds_per_group) ==
(bdbuf_cache.max_bds_per_group - 1))
200e708: a8 04 bf ff add %l2, -1, %l4
/*
* 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;
200e70c: ba 10 00 1a mov %i2, %i5
/*
* 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,
200e710: b0 10 00 1b mov %i3, %i0
200e714: b2 10 20 00 clr %i1
Chain_Control *the_chain,
Chain_Node *the_node
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
200e718: a2 10 00 01 mov %g1, %l1
200e71c: 10 80 00 12 b 200e764 <rtems_bdbuf_init+0x2c4>
200e720: aa 00 60 44 add %g1, 0x44, %l5
bd = bdbuf_cache.bds, buffer = bdbuf_cache.buffers;
b < bdbuf_cache.buffer_min_count;
b++, bd++, buffer += bdbuf_config.buffer_min)
{
bd->dd = BDBUF_INVALID_DEV;
bd->group = group;
200e724: f0 27 60 28 st %i0, [ %i5 + 0x28 ]
bd->buffer = buffer;
200e728: e0 27 60 1c st %l0, [ %i5 + 0x1c ]
200e72c: c2 04 60 48 ld [ %l1 + 0x48 ], %g1
the_node->next = tail;
200e730: ea 27 40 00 st %l5, [ %i5 ]
tail->previous = the_node;
200e734: fa 24 60 48 st %i5, [ %l1 + 0x48 ]
old_last->next = the_node;
200e738: fa 20 40 00 st %i5, [ %g1 ]
the_node->previous = old_last;
200e73c: c2 27 60 04 st %g1, [ %i5 + 4 ]
rtems_chain_append_unprotected (&bdbuf_cache.lru, &bd->link);
if ((b % bdbuf_cache.max_bds_per_group) ==
200e740: 90 10 00 19 mov %i1, %o0
200e744: 40 00 39 26 call 201cbdc <.urem>
200e748: 92 10 00 12 mov %l2, %o1
200e74c: 80 a2 00 14 cmp %o0, %l4
200e750: 22 80 00 02 be,a 200e758 <rtems_bdbuf_init+0x2b8>
200e754: b0 06 20 14 add %i0, 0x14, %i0
* 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)
200e758: b2 06 60 01 inc %i1
200e75c: ba 07 60 38 add %i5, 0x38, %i5
200e760: a0 04 00 1c add %l0, %i4, %l0
/*
* 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,
200e764: 80 a6 40 13 cmp %i1, %l3
200e768: 32 bf ff ef bne,a 200e724 <rtems_bdbuf_init+0x284>
200e76c: c0 27 60 14 clr [ %i5 + 0x14 ]
}
for (b = 0,
group = bdbuf_cache.groups,
bd = bdbuf_cache.bds;
b < bdbuf_cache.group_count;
200e770: 03 00 80 86 sethi %hi(0x2021800), %g1
200e774: 82 10 60 7c or %g1, 0x7c, %g1 ! 202187c <bdbuf_cache>
b++,
group++,
bd += bdbuf_cache.max_bds_per_group)
{
group->bds_per_group = bdbuf_cache.max_bds_per_group;
200e778: c4 00 60 20 ld [ %g1 + 0x20 ], %g2
}
for (b = 0,
group = bdbuf_cache.groups,
bd = bdbuf_cache.bds;
b < bdbuf_cache.group_count;
200e77c: c6 00 60 7c ld [ %g1 + 0x7c ], %g3
b++,
group++,
bd += bdbuf_cache.max_bds_per_group)
200e780: 83 28 a0 03 sll %g2, 3, %g1
200e784: 89 28 a0 06 sll %g2, 6, %g4
200e788: 88 21 00 01 sub %g4, %g1, %g4
200e78c: 10 80 00 06 b 200e7a4 <rtems_bdbuf_init+0x304>
200e790: 82 10 20 00 clr %g1
{
group->bds_per_group = bdbuf_cache.max_bds_per_group;
200e794: c4 26 e0 08 st %g2, [ %i3 + 8 ]
for (b = 0,
group = bdbuf_cache.groups,
bd = bdbuf_cache.bds;
b < bdbuf_cache.group_count;
b++,
200e798: 82 00 60 01 inc %g1
group++,
200e79c: b6 06 e0 14 add %i3, 0x14, %i3
bd += bdbuf_cache.max_bds_per_group)
200e7a0: b4 06 80 04 add %i2, %g4, %i2
if ((b % bdbuf_cache.max_bds_per_group) ==
(bdbuf_cache.max_bds_per_group - 1))
group++;
}
for (b = 0,
200e7a4: 80 a0 40 03 cmp %g1, %g3
200e7a8: 32 bf ff fb bne,a 200e794 <rtems_bdbuf_init+0x2f4>
200e7ac: f4 26 e0 10 st %i2, [ %i3 + 0x10 ]
* Create and start swapout task. This task will create and manage the worker
* threads.
*/
bdbuf_cache.swapout_enabled = true;
sc = rtems_bdbuf_create_task (rtems_build_name('B', 'S', 'W', 'P'),
200e7b0: 35 00 80 7b sethi %hi(0x201ec00), %i2
200e7b4: b8 16 a1 40 or %i2, 0x140, %i4 ! 201ed40 <rtems_bdbuf_configuration>
200e7b8: d2 07 20 08 ld [ %i4 + 8 ], %o1
/*
* Create and start swapout task. This task will create and manage the worker
* threads.
*/
bdbuf_cache.swapout_enabled = true;
200e7bc: 3b 00 80 86 sethi %hi(0x2021800), %i5
200e7c0: b6 10 20 01 mov 1, %i3
200e7c4: ba 17 60 7c or %i5, 0x7c, %i5
sc = rtems_bdbuf_create_task (rtems_build_name('B', 'S', 'W', 'P'),
200e7c8: 11 10 94 d5 sethi %hi(0x42535400), %o0
/*
* Create and start swapout task. This task will create and manage the worker
* threads.
*/
bdbuf_cache.swapout_enabled = true;
200e7cc: f6 2f 60 04 stb %i3, [ %i5 + 4 ]
sc = rtems_bdbuf_create_task (rtems_build_name('B', 'S', 'W', 'P'),
200e7d0: 90 12 23 50 or %o0, 0x350, %o0
200e7d4: 15 00 80 37 sethi %hi(0x200dc00), %o2
200e7d8: 96 10 20 00 clr %o3
200e7dc: 94 12 a2 38 or %o2, 0x238, %o2
200e7e0: 7f ff f9 bb call 200cecc <rtems_bdbuf_create_task.constprop.10>
200e7e4: 98 10 00 1d mov %i5, %o4
bdbuf_config.swapout_priority,
RTEMS_BDBUF_SWAPOUT_TASK_PRIORITY_DEFAULT,
rtems_bdbuf_swapout_task,
0,
&bdbuf_cache.swapout);
if (sc != RTEMS_SUCCESSFUL)
200e7e8: 80 a2 20 00 cmp %o0, 0
200e7ec: 12 80 00 16 bne 200e844 <rtems_bdbuf_init+0x3a4> <== NEVER TAKEN
200e7f0: 03 00 80 86 sethi %hi(0x2021800), %g1
goto error;
if (bdbuf_config.max_read_ahead_blocks > 0)
200e7f4: c2 06 a1 40 ld [ %i2 + 0x140 ], %g1
200e7f8: 80 a0 60 00 cmp %g1, 0
200e7fc: 32 80 00 06 bne,a 200e814 <rtems_bdbuf_init+0x374>
200e800: d2 07 20 2c ld [ %i4 + 0x2c ], %o1
&bdbuf_cache.read_ahead_task);
if (sc != RTEMS_SUCCESSFUL)
goto error;
}
rtems_bdbuf_unlock_cache ();
200e804: 7f ff f9 03 call 200cc10 <rtems_bdbuf_unlock_cache>
200e808: b0 10 20 00 clr %i0
return RTEMS_SUCCESSFUL;
200e80c: 81 c7 e0 08 ret
200e810: 81 e8 00 00 restore
if (sc != RTEMS_SUCCESSFUL)
goto error;
if (bdbuf_config.max_read_ahead_blocks > 0)
{
bdbuf_cache.read_ahead_enabled = true;
200e814: f6 2f 60 94 stb %i3, [ %i5 + 0x94 ]
sc = rtems_bdbuf_create_task (rtems_build_name('B', 'R', 'D', 'A'),
200e818: 11 10 94 91 sethi %hi(0x42524400), %o0
200e81c: 15 00 80 38 sethi %hi(0x200e000), %o2
200e820: 90 12 20 41 or %o0, 0x41, %o0
200e824: 94 12 a2 d0 or %o2, 0x2d0, %o2
200e828: 96 10 20 00 clr %o3
200e82c: 7f ff f9 a8 call 200cecc <rtems_bdbuf_create_task.constprop.10>
200e830: 98 07 60 84 add %i5, 0x84, %o4
bdbuf_config.read_ahead_priority,
RTEMS_BDBUF_READ_AHEAD_TASK_PRIORITY_DEFAULT,
rtems_bdbuf_read_ahead_task,
0,
&bdbuf_cache.read_ahead_task);
if (sc != RTEMS_SUCCESSFUL)
200e834: 80 a2 20 00 cmp %o0, 0
200e838: 02 bf ff f3 be 200e804 <rtems_bdbuf_init+0x364> <== ALWAYS TAKEN
200e83c: 01 00 00 00 nop
return RTEMS_SUCCESSFUL;
error:
if (bdbuf_cache.read_ahead_task != 0)
200e840: 03 00 80 86 sethi %hi(0x2021800), %g1 <== NOT EXECUTED
200e844: d0 00 61 00 ld [ %g1 + 0x100 ], %o0 ! 2021900 <bdbuf_cache+0x84><== NOT EXECUTED
200e848: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
200e84c: 02 80 00 05 be 200e860 <rtems_bdbuf_init+0x3c0> <== NOT EXECUTED
200e850: 03 00 80 86 sethi %hi(0x2021800), %g1 <== NOT EXECUTED
rtems_task_delete (bdbuf_cache.read_ahead_task);
200e854: 7f ff e9 e5 call 2008fe8 <rtems_task_delete> <== NOT EXECUTED
200e858: 01 00 00 00 nop <== NOT EXECUTED
if (bdbuf_cache.swapout != 0)
200e85c: 03 00 80 86 sethi %hi(0x2021800), %g1 <== NOT EXECUTED
200e860: d0 00 60 7c ld [ %g1 + 0x7c ], %o0 ! 202187c <bdbuf_cache><== NOT EXECUTED
200e864: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
200e868: 02 80 00 04 be 200e878 <rtems_bdbuf_init+0x3d8> <== NOT EXECUTED
200e86c: 3b 00 80 86 sethi %hi(0x2021800), %i5 <== NOT EXECUTED
rtems_task_delete (bdbuf_cache.swapout);
200e870: 7f ff e9 de call 2008fe8 <rtems_task_delete> <== NOT EXECUTED
200e874: 01 00 00 00 nop <== NOT EXECUTED
free (bdbuf_cache.buffers);
200e878: ba 17 60 7c or %i5, 0x7c, %i5 <== NOT EXECUTED
200e87c: 7f ff d8 73 call 2004a48 <free> <== NOT EXECUTED
200e880: d0 07 60 18 ld [ %i5 + 0x18 ], %o0 <== NOT EXECUTED
free (bdbuf_cache.groups);
200e884: 7f ff d8 71 call 2004a48 <free> <== NOT EXECUTED
200e888: d0 07 60 80 ld [ %i5 + 0x80 ], %o0 <== NOT EXECUTED
free (bdbuf_cache.bds);
200e88c: 7f ff d8 6f call 2004a48 <free> <== NOT EXECUTED
200e890: d0 07 60 14 ld [ %i5 + 0x14 ], %o0 <== NOT EXECUTED
rtems_semaphore_delete (bdbuf_cache.buffer_waiters.sema);
200e894: 7f ff e8 e5 call 2008c28 <rtems_semaphore_delete> <== NOT EXECUTED
200e898: d0 07 60 78 ld [ %i5 + 0x78 ], %o0 <== NOT EXECUTED
rtems_semaphore_delete (bdbuf_cache.access_waiters.sema);
200e89c: 7f ff e8 e3 call 2008c28 <rtems_semaphore_delete> <== NOT EXECUTED
200e8a0: d0 07 60 68 ld [ %i5 + 0x68 ], %o0 <== NOT EXECUTED
rtems_semaphore_delete (bdbuf_cache.transfer_waiters.sema);
200e8a4: 7f ff e8 e1 call 2008c28 <rtems_semaphore_delete> <== NOT EXECUTED
200e8a8: d0 07 60 70 ld [ %i5 + 0x70 ], %o0 <== NOT EXECUTED
rtems_semaphore_delete (bdbuf_cache.sync_lock);
200e8ac: 7f ff e8 df call 2008c28 <rtems_semaphore_delete> <== NOT EXECUTED
200e8b0: d0 07 60 2c ld [ %i5 + 0x2c ], %o0 <== NOT EXECUTED
if (bdbuf_cache.lock != 0)
200e8b4: c2 07 60 28 ld [ %i5 + 0x28 ], %g1 <== NOT EXECUTED
200e8b8: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
200e8bc: 02 80 00 07 be 200e8d8 <rtems_bdbuf_init+0x438> <== NOT EXECUTED
200e8c0: 03 00 80 86 sethi %hi(0x2021800), %g1 <== NOT EXECUTED
{
rtems_bdbuf_unlock_cache ();
200e8c4: 7f ff f8 d3 call 200cc10 <rtems_bdbuf_unlock_cache> <== NOT EXECUTED
200e8c8: 01 00 00 00 nop <== NOT EXECUTED
rtems_semaphore_delete (bdbuf_cache.lock);
200e8cc: 7f ff e8 d7 call 2008c28 <rtems_semaphore_delete> <== NOT EXECUTED
200e8d0: d0 07 60 28 ld [ %i5 + 0x28 ], %o0 <== NOT EXECUTED
}
bdbuf_cache.initialised = false;
200e8d4: 03 00 80 86 sethi %hi(0x2021800), %g1 <== NOT EXECUTED
return RTEMS_UNSATISFIED;
200e8d8: b0 10 20 0d mov 0xd, %i0 <== NOT EXECUTED
{
rtems_bdbuf_unlock_cache ();
rtems_semaphore_delete (bdbuf_cache.lock);
}
bdbuf_cache.initialised = false;
200e8dc: c0 28 61 11 clrb [ %g1 + 0x111 ] <== NOT EXECUTED
return RTEMS_UNSATISFIED;
}
200e8e0: 81 c7 e0 08 ret <== NOT EXECUTED
200e8e4: 81 e8 00 00 restore <== NOT EXECUTED
0200cb88 <rtems_bdbuf_lock>:
* @param lock The mutex to lock.
* @param fatal_error_code The error code if the call fails.
*/
static void
rtems_bdbuf_lock (rtems_id lock, uint32_t fatal_error_code)
{
200cb88: 9d e3 bf a0 save %sp, -96, %sp
rtems_status_code sc = rtems_semaphore_obtain (lock,
200cb8c: 92 10 20 00 clr %o1
200cb90: 90 10 00 18 mov %i0, %o0
200cb94: 7f ff f0 54 call 2008ce4 <rtems_semaphore_obtain>
200cb98: 94 10 20 00 clr %o2
RTEMS_WAIT,
RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
200cb9c: 80 a2 20 00 cmp %o0, 0
200cba0: 02 80 00 04 be 200cbb0 <rtems_bdbuf_lock+0x28> <== ALWAYS TAKEN
200cba4: 01 00 00 00 nop
rtems_fatal_error_occurred (fatal_error_code);
200cba8: 7f ff f1 fc call 2009398 <rtems_fatal_error_occurred> <== NOT EXECUTED
200cbac: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
200cbb0: 81 c7 e0 08 ret
200cbb4: 81 e8 00 00 restore
0200ee8c <rtems_bdbuf_purge_dev>:
}
}
void
rtems_bdbuf_purge_dev (rtems_disk_device *dd)
{
200ee8c: 9d e3 bf 10 save %sp, -240, %sp
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
head->previous = NULL;
tail->previous = head;
200ee90: 82 07 bf 74 add %fp, -140, %g1
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
200ee94: b6 07 bf 78 add %fp, -136, %i3
head->previous = NULL;
tail->previous = head;
200ee98: c2 27 bf 7c st %g1, [ %fp + -132 ]
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
200ee9c: f6 27 bf 74 st %i3, [ %fp + -140 ]
rtems_chain_control purge_list;
rtems_chain_initialize_empty (&purge_list);
rtems_bdbuf_lock_cache ();
200eea0: 7f ff f7 46 call 200cbb8 <rtems_bdbuf_lock_cache>
200eea4: c0 27 bf 78 clr [ %fp + -136 ]
}
static void
rtems_bdbuf_read_ahead_reset (rtems_disk_device *dd)
{
rtems_bdbuf_read_ahead_cancel (dd);
200eea8: 7f ff fd 56 call 200e400 <rtems_bdbuf_read_ahead_cancel>
200eeac: 90 10 00 18 mov %i0, %o0
dd->read_ahead.trigger = RTEMS_DISK_READ_AHEAD_NO_TRIGGER;
200eeb0: 82 10 3f ff mov -1, %g1
rtems_bdbuf_gather_for_purge (rtems_chain_control *purge_list,
const rtems_disk_device *dd)
{
rtems_bdbuf_buffer *stack [RTEMS_BDBUF_AVL_MAX_HEIGHT];
rtems_bdbuf_buffer **prev = stack;
rtems_bdbuf_buffer *cur = bdbuf_cache.tree;
200eeb4: 11 00 80 86 sethi %hi(0x2021800), %o0
while (cur != NULL)
{
if (cur->dd == dd)
{
switch (cur->state)
200eeb8: 35 00 80 32 sethi %hi(0x200c800), %i2
rtems_bdbuf_gather_for_purge (rtems_chain_control *purge_list,
const rtems_disk_device *dd)
{
rtems_bdbuf_buffer *stack [RTEMS_BDBUF_AVL_MAX_HEIGHT];
rtems_bdbuf_buffer **prev = stack;
rtems_bdbuf_buffer *cur = bdbuf_cache.tree;
200eebc: 90 12 20 7c or %o0, 0x7c, %o0
static void
rtems_bdbuf_read_ahead_reset (rtems_disk_device *dd)
{
rtems_bdbuf_read_ahead_cancel (dd);
dd->read_ahead.trigger = RTEMS_DISK_READ_AHEAD_NO_TRIGGER;
200eec0: c2 26 20 6c st %g1, [ %i0 + 0x6c ]
rtems_bdbuf_gather_for_purge (rtems_chain_control *purge_list,
const rtems_disk_device *dd)
{
rtems_bdbuf_buffer *stack [RTEMS_BDBUF_AVL_MAX_HEIGHT];
rtems_bdbuf_buffer **prev = stack;
rtems_bdbuf_buffer *cur = bdbuf_cache.tree;
200eec4: fa 02 20 3c ld [ %o0 + 0x3c ], %i5
*prev = NULL;
200eec8: c0 27 bf 80 clr [ %fp + -128 ]
static void
rtems_bdbuf_gather_for_purge (rtems_chain_control *purge_list,
const rtems_disk_device *dd)
{
rtems_bdbuf_buffer *stack [RTEMS_BDBUF_AVL_MAX_HEIGHT];
rtems_bdbuf_buffer **prev = stack;
200eecc: b8 07 bf 80 add %fp, -128, %i4
while (cur != NULL)
{
if (cur->dd == dd)
{
switch (cur->state)
200eed0: b4 16 a3 0c or %i2, 0x30c, %i2
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
200eed4: b2 10 20 06 mov 6, %i1
200eed8: a0 10 20 0a mov 0xa, %l0
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);
200eedc: 10 80 00 3b b 200efc8 <rtems_bdbuf_purge_dev+0x13c>
200eee0: a2 02 20 6c add %o0, 0x6c, %l1
*prev = NULL;
while (cur != NULL)
{
if (cur->dd == dd)
200eee4: 80 a0 40 18 cmp %g1, %i0
200eee8: 32 80 00 1f bne,a 200ef64 <rtems_bdbuf_purge_dev+0xd8> <== NEVER TAKEN
200eeec: c2 07 60 08 ld [ %i5 + 8 ], %g1 <== NOT EXECUTED
{
switch (cur->state)
200eef0: c2 07 60 20 ld [ %i5 + 0x20 ], %g1
200eef4: 80 a0 60 0a cmp %g1, 0xa
200eef8: 18 80 00 18 bgu 200ef58 <rtems_bdbuf_purge_dev+0xcc> <== NEVER TAKEN
200eefc: 11 10 80 00 sethi %hi(0x42000000), %o0
200ef00: 83 28 60 02 sll %g1, 2, %g1
200ef04: c2 06 80 01 ld [ %i2 + %g1 ], %g1
200ef08: 81 c0 40 00 jmp %g1
200ef0c: 01 00 00 00 nop
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);
200ef10: 7f ff f7 e1 call 200ce94 <rtems_bdbuf_wake>
200ef14: 90 10 00 11 mov %l1, %o0
/* Fall through */
case RTEMS_BDBUF_STATE_MODIFIED:
rtems_bdbuf_group_release (cur);
200ef18: 7f ff f7 17 call 200cb74 <rtems_bdbuf_group_release>
200ef1c: 90 10 00 1d mov %i5, %o0
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
previous = the_node->previous;
200ef20: c2 07 60 04 ld [ %i5 + 4 ], %g1
)
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
200ef24: c4 07 40 00 ld [ %i5 ], %g2
previous = the_node->previous;
next->previous = previous;
200ef28: c2 20 a0 04 st %g1, [ %g2 + 4 ]
previous->next = next;
200ef2c: c4 20 40 00 st %g2, [ %g1 ]
Chain_Control *the_chain,
Chain_Node *the_node
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
200ef30: c2 07 bf 7c ld [ %fp + -132 ], %g1
the_node->next = tail;
200ef34: f6 27 40 00 st %i3, [ %i5 ]
tail->previous = the_node;
200ef38: fa 27 bf 7c st %i5, [ %fp + -132 ]
old_last->next = the_node;
200ef3c: fa 20 40 00 st %i5, [ %g1 ]
the_node->previous = old_last;
200ef40: 10 80 00 08 b 200ef60 <rtems_bdbuf_purge_dev+0xd4>
200ef44: c2 27 60 04 st %g1, [ %i5 + 4 ]
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
200ef48: 10 80 00 06 b 200ef60 <rtems_bdbuf_purge_dev+0xd4>
200ef4c: e0 27 60 20 st %l0, [ %i5 + 0x20 ]
200ef50: 10 80 00 04 b 200ef60 <rtems_bdbuf_purge_dev+0xd4>
200ef54: f2 27 60 20 st %i1, [ %i5 + 0x20 ]
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);
200ef58: 7f ff e9 10 call 2009398 <rtems_fatal_error_occurred> <== NOT EXECUTED
200ef5c: 90 12 20 01 or %o0, 1, %o0 <== NOT EXECUTED
}
}
if (cur->avl.left != NULL)
200ef60: c2 07 60 08 ld [ %i5 + 8 ], %g1
200ef64: 80 a0 60 00 cmp %g1, 0
200ef68: 22 80 00 04 be,a 200ef78 <rtems_bdbuf_purge_dev+0xec>
200ef6c: c2 07 60 0c ld [ %i5 + 0xc ], %g1
}
else if (cur->avl.right != NULL)
{
/* Right */
++prev;
*prev = cur;
200ef70: 10 80 00 06 b 200ef88 <rtems_bdbuf_purge_dev+0xfc>
200ef74: fa 27 20 04 st %i5, [ %i4 + 4 ]
/* Left */
++prev;
*prev = cur;
cur = cur->avl.left;
}
else if (cur->avl.right != NULL)
200ef78: 80 a0 60 00 cmp %g1, 0
200ef7c: 22 80 00 08 be,a 200ef9c <rtems_bdbuf_purge_dev+0x110>
200ef80: c2 07 00 00 ld [ %i4 ], %g1
{
/* Right */
++prev;
*prev = cur;
200ef84: fa 27 20 04 st %i5, [ %i4 + 4 ]
cur = cur->avl.left;
}
else if (cur->avl.right != NULL)
{
/* Right */
++prev;
200ef88: 10 80 00 0f b 200efc4 <rtems_bdbuf_purge_dev+0x138>
200ef8c: b8 07 20 04 add %i4, 4, %i4
while (*prev != NULL
&& (cur == (*prev)->avl.right || (*prev)->avl.right == NULL))
{
/* Up */
cur = *prev;
--prev;
200ef90: b8 07 3f fc add %i4, -4, %i4
200ef94: ba 10 00 01 mov %g1, %i5
*prev = cur;
cur = cur->avl.right;
}
else
{
while (*prev != NULL
200ef98: c2 07 00 00 ld [ %i4 ], %g1
200ef9c: 80 a0 60 00 cmp %g1, 0
200efa0: 22 80 00 0a be,a 200efc8 <rtems_bdbuf_purge_dev+0x13c>
200efa4: ba 10 00 01 mov %g1, %i5
&& (cur == (*prev)->avl.right || (*prev)->avl.right == NULL))
200efa8: c4 00 60 0c ld [ %g1 + 0xc ], %g2
200efac: 80 a7 40 02 cmp %i5, %g2
200efb0: 02 bf ff f8 be 200ef90 <rtems_bdbuf_purge_dev+0x104>
200efb4: 80 a0 a0 00 cmp %g2, 0
200efb8: 22 bf ff f7 be,a 200ef94 <rtems_bdbuf_purge_dev+0x108>
200efbc: b8 07 3f fc add %i4, -4, %i4
cur = *prev;
--prev;
}
if (*prev != NULL)
/* Right */
cur = (*prev)->avl.right;
200efc0: 82 10 00 02 mov %g2, %g1
200efc4: ba 10 00 01 mov %g1, %i5
rtems_bdbuf_buffer **prev = stack;
rtems_bdbuf_buffer *cur = bdbuf_cache.tree;
*prev = NULL;
while (cur != NULL)
200efc8: 80 a7 60 00 cmp %i5, 0
200efcc: 32 bf ff c6 bne,a 200eee4 <rtems_bdbuf_purge_dev+0x58>
200efd0: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
}
static void
rtems_bdbuf_purge_list (rtems_chain_control *purge_list)
{
bool wake_buffer_waiters = false;
200efd4: b8 10 20 00 clr %i4
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
200efd8: 10 80 00 0c b 200f008 <rtems_bdbuf_purge_dev+0x17c>
200efdc: b6 10 20 01 mov 1, %i3
while ((node = rtems_chain_get_unprotected (purge_list)) != NULL)
{
rtems_bdbuf_buffer *bd = (rtems_bdbuf_buffer *) node;
if (bd->waiters == 0)
200efe0: 80 a0 60 00 cmp %g1, 0
200efe4: 22 80 00 02 be,a 200efec <rtems_bdbuf_purge_dev+0x160>
200efe8: b8 10 20 01 mov 1, %i4
static void
rtems_bdbuf_discard_buffer (rtems_bdbuf_buffer *bd)
{
rtems_bdbuf_make_empty (bd);
if (bd->waiters == 0)
200efec: 80 a0 60 00 cmp %g1, 0
200eff0: 12 80 00 06 bne 200f008 <rtems_bdbuf_purge_dev+0x17c>
200eff4: f6 27 60 20 st %i3, [ %i5 + 0x20 ]
{
rtems_bdbuf_remove_from_tree (bd);
200eff8: 7f ff f7 cc call 200cf28 <rtems_bdbuf_remove_from_tree>
200effc: 90 10 00 1d mov %i5, %o0
rtems_bdbuf_make_free_and_add_to_lru_list (bd);
200f000: 7f ff f8 a4 call 200d290 <rtems_bdbuf_make_free_and_add_to_lru_list>
200f004: 90 10 00 1d mov %i5, %o0
200f008: 7f ff f6 cc call 200cb38 <_Chain_Get_unprotected>
200f00c: 90 07 bf 74 add %fp, -140, %o0
rtems_bdbuf_purge_list (rtems_chain_control *purge_list)
{
bool wake_buffer_waiters = false;
rtems_chain_node *node = NULL;
while ((node = rtems_chain_get_unprotected (purge_list)) != NULL)
200f010: ba 92 20 00 orcc %o0, 0, %i5
200f014: 32 bf ff f3 bne,a 200efe0 <rtems_bdbuf_purge_dev+0x154>
200f018: c2 07 60 24 ld [ %i5 + 0x24 ], %g1
wake_buffer_waiters = true;
rtems_bdbuf_discard_buffer (bd);
}
if (wake_buffer_waiters)
200f01c: 80 8f 20 ff btst 0xff, %i4
200f020: 02 80 00 04 be 200f030 <rtems_bdbuf_purge_dev+0x1a4>
200f024: 11 00 80 86 sethi %hi(0x2021800), %o0
rtems_bdbuf_wake (&bdbuf_cache.buffer_waiters);
200f028: 7f ff f7 9b call 200ce94 <rtems_bdbuf_wake>
200f02c: 90 12 20 f0 or %o0, 0xf0, %o0 ! 20218f0 <bdbuf_cache+0x74>
rtems_chain_initialize_empty (&purge_list);
rtems_bdbuf_lock_cache ();
rtems_bdbuf_read_ahead_reset (dd);
rtems_bdbuf_gather_for_purge (&purge_list, dd);
rtems_bdbuf_purge_list (&purge_list);
rtems_bdbuf_unlock_cache ();
200f030: 7f ff f6 f8 call 200cc10 <rtems_bdbuf_unlock_cache>
200f034: 01 00 00 00 nop
200f038: 81 c7 e0 08 ret
200f03c: 81 e8 00 00 restore
0200e9ac <rtems_bdbuf_read>:
rtems_status_code
rtems_bdbuf_read (rtems_disk_device *dd,
rtems_blkdev_bnum block,
rtems_bdbuf_buffer **bd_ptr)
{
200e9ac: 9d e3 bf a0 save %sp, -96, %sp
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_bdbuf_buffer *bd = NULL;
rtems_blkdev_bnum media_block;
rtems_bdbuf_lock_cache ();
200e9b0: 7f ff f8 82 call 200cbb8 <rtems_bdbuf_lock_cache>
200e9b4: ba 10 00 18 mov %i0, %i5
rtems_blkdev_bnum block,
rtems_blkdev_bnum *media_block_ptr)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
if (block < dd->block_count)
200e9b8: c2 06 20 28 ld [ %i0 + 0x28 ], %g1
rtems_bdbuf_read (rtems_disk_device *dd,
rtems_blkdev_bnum block,
rtems_bdbuf_buffer **bd_ptr)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_bdbuf_buffer *bd = NULL;
200e9bc: b8 10 20 00 clr %i4
rtems_blkdev_bnum block,
rtems_blkdev_bnum *media_block_ptr)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
if (block < dd->block_count)
200e9c0: 80 a6 40 01 cmp %i1, %g1
200e9c4: 1a 80 00 72 bcc 200eb8c <rtems_bdbuf_read+0x1e0> <== NEVER TAKEN
200e9c8: b0 10 20 04 mov 4, %i0
}
static rtems_blkdev_bnum
rtems_bdbuf_media_block (const rtems_disk_device *dd, rtems_blkdev_bnum block)
{
if (dd->block_to_media_block_shift >= 0)
200e9cc: d2 07 60 30 ld [ %i5 + 0x30 ], %o1
200e9d0: 80 a2 60 00 cmp %o1, 0
200e9d4: 26 80 00 04 bl,a 200e9e4 <rtems_bdbuf_read+0x38> <== NEVER TAKEN
200e9d8: d6 07 60 24 ld [ %i5 + 0x24 ], %o3 <== NOT EXECUTED
return block << dd->block_to_media_block_shift;
200e9dc: 10 80 00 09 b 200ea00 <rtems_bdbuf_read+0x54>
200e9e0: 93 2e 40 09 sll %i1, %o1, %o1
/*
* Change the block number for the block size to the block number for the media
* block size. We have to use 64bit maths. There is no short cut here.
*/
return (rtems_blkdev_bnum)
((((uint64_t) block) * dd->block_size) / dd->media_block_size);
200e9e4: 94 10 20 00 clr %o2 <== NOT EXECUTED
200e9e8: 90 10 20 00 clr %o0 <== NOT EXECUTED
200e9ec: 40 00 39 28 call 201ce8c <__muldi3> <== NOT EXECUTED
200e9f0: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
200e9f4: d6 07 60 20 ld [ %i5 + 0x20 ], %o3 <== NOT EXECUTED
200e9f8: 40 00 3b 36 call 201d6d0 <__udivdi3> <== NOT EXECUTED
200e9fc: 94 10 20 00 clr %o2 <== NOT EXECUTED
/*
* 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.
*/
*media_block_ptr = rtems_bdbuf_media_block (dd, block) + dd->start;
200ea00: c2 07 60 18 ld [ %i5 + 0x18 ], %g1
{
if (rtems_bdbuf_tracer)
printf ("bdbuf:read: %" PRIu32 " (%" PRIu32 ") (dev = %08x)\n",
media_block + dd->start, block, (unsigned) dd->dev);
bd = rtems_bdbuf_get_buffer_for_access (dd, media_block);
200ea04: 90 10 00 1d mov %i5, %o0
200ea08: 7f ff fb 71 call 200d7cc <rtems_bdbuf_get_buffer_for_access>
200ea0c: 92 02 40 01 add %o1, %g1, %o1
200ea10: b8 10 00 08 mov %o0, %i4
switch (bd->state)
200ea14: d0 02 20 20 ld [ %o0 + 0x20 ], %o0
200ea18: 80 a2 20 02 cmp %o0, 2
200ea1c: 02 80 00 08 be 200ea3c <rtems_bdbuf_read+0x90>
200ea20: 80 a2 20 07 cmp %o0, 7
200ea24: 02 80 00 0b be 200ea50 <rtems_bdbuf_read+0xa4>
200ea28: 80 a2 20 01 cmp %o0, 1
200ea2c: 12 80 00 2d bne 200eae0 <rtems_bdbuf_read+0x134> <== NEVER TAKEN
200ea30: 13 10 80 00 sethi %hi(0x42000000), %o1
case RTEMS_BDBUF_STATE_MODIFIED:
++dd->stats.read_hits;
rtems_bdbuf_set_state (bd, RTEMS_BDBUF_STATE_ACCESS_MODIFIED);
break;
case RTEMS_BDBUF_STATE_EMPTY:
++dd->stats.read_misses;
200ea34: 10 80 00 0e b 200ea6c <rtems_bdbuf_read+0xc0>
200ea38: c2 07 60 48 ld [ %i5 + 0x48 ], %g1
bd = rtems_bdbuf_get_buffer_for_access (dd, media_block);
switch (bd->state)
{
case RTEMS_BDBUF_STATE_CACHED:
++dd->stats.read_hits;
200ea3c: c2 07 60 44 ld [ %i5 + 0x44 ], %g1
200ea40: 82 00 60 01 inc %g1
200ea44: c2 27 60 44 st %g1, [ %i5 + 0x44 ]
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
200ea48: 10 80 00 06 b 200ea60 <rtems_bdbuf_read+0xb4>
200ea4c: 82 10 20 03 mov 3, %g1
case RTEMS_BDBUF_STATE_CACHED:
++dd->stats.read_hits;
rtems_bdbuf_set_state (bd, RTEMS_BDBUF_STATE_ACCESS_CACHED);
break;
case RTEMS_BDBUF_STATE_MODIFIED:
++dd->stats.read_hits;
200ea50: c2 07 60 44 ld [ %i5 + 0x44 ], %g1
200ea54: 82 00 60 01 inc %g1
200ea58: c2 27 60 44 st %g1, [ %i5 + 0x44 ]
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
200ea5c: 82 10 20 04 mov 4, %g1
200ea60: c2 27 20 20 st %g1, [ %i4 + 0x20 ]
200ea64: 10 80 00 21 b 200eae8 <rtems_bdbuf_read+0x13c>
200ea68: b0 10 20 00 clr %i0
case RTEMS_BDBUF_STATE_MODIFIED:
++dd->stats.read_hits;
rtems_bdbuf_set_state (bd, RTEMS_BDBUF_STATE_ACCESS_MODIFIED);
break;
case RTEMS_BDBUF_STATE_EMPTY:
++dd->stats.read_misses;
200ea6c: 82 00 60 01 inc %g1
200ea70: c2 27 60 48 st %g1, [ %i5 + 0x48 ]
static void
rtems_bdbuf_set_read_ahead_trigger (rtems_disk_device *dd,
rtems_blkdev_bnum block)
{
if (dd->read_ahead.trigger != block)
200ea74: c2 07 60 6c ld [ %i5 + 0x6c ], %g1
200ea78: 80 a0 40 19 cmp %g1, %i1
200ea7c: 02 80 00 09 be 200eaa0 <rtems_bdbuf_read+0xf4>
200ea80: 90 10 00 1d mov %i5, %o0
{
rtems_bdbuf_read_ahead_cancel (dd);
200ea84: 7f ff fe 5f call 200e400 <rtems_bdbuf_read_ahead_cancel>
200ea88: 90 10 00 1d mov %i5, %o0
dd->read_ahead.trigger = block + 1;
200ea8c: 82 06 60 01 add %i1, 1, %g1
200ea90: c2 27 60 6c st %g1, [ %i5 + 0x6c ]
dd->read_ahead.next = block + 2;
200ea94: 82 06 60 02 add %i1, 2, %g1
200ea98: c2 27 60 70 st %g1, [ %i5 + 0x70 ]
rtems_bdbuf_set_state (bd, RTEMS_BDBUF_STATE_ACCESS_MODIFIED);
break;
case RTEMS_BDBUF_STATE_EMPTY:
++dd->stats.read_misses;
rtems_bdbuf_set_read_ahead_trigger (dd, block);
sc = rtems_bdbuf_execute_read_request (dd, bd, 1);
200ea9c: 90 10 00 1d mov %i5, %o0
200eaa0: 92 10 00 1c mov %i4, %o1
200eaa4: 7f ff fd d5 call 200e1f8 <rtems_bdbuf_execute_read_request>
200eaa8: 94 10 20 01 mov 1, %o2
if (sc == RTEMS_SUCCESSFUL)
200eaac: b0 92 20 00 orcc %o0, 0, %i0
200eab0: 32 80 00 0e bne,a 200eae8 <rtems_bdbuf_read+0x13c>
200eab4: b8 10 20 00 clr %i4
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
200eab8: 82 10 20 03 mov 3, %g1
)
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
200eabc: c4 07 00 00 ld [ %i4 ], %g2
200eac0: c2 27 20 20 st %g1, [ %i4 + 0x20 ]
previous = the_node->previous;
200eac4: c2 07 20 04 ld [ %i4 + 4 ], %g1
sc = rtems_bdbuf_execute_read_request (dd, bd, 1);
if (sc == RTEMS_SUCCESSFUL)
{
rtems_bdbuf_set_state (bd, RTEMS_BDBUF_STATE_ACCESS_CACHED);
rtems_chain_extract_unprotected (&bd->link);
rtems_bdbuf_group_obtain (bd);
200eac8: 90 10 00 1c mov %i4, %o0
next->previous = previous;
200eacc: c2 20 a0 04 st %g1, [ %g2 + 4 ]
200ead0: 7f ff f8 24 call 200cb60 <rtems_bdbuf_group_obtain>
200ead4: c4 20 40 00 st %g2, [ %g1 ]
static void
rtems_bdbuf_check_read_ahead_trigger (rtems_disk_device *dd,
rtems_blkdev_bnum block)
{
if (bdbuf_cache.read_ahead_task != 0
200ead8: 10 80 00 05 b 200eaec <rtems_bdbuf_read+0x140>
200eadc: 03 00 80 86 sethi %hi(0x2021800), %g1
{
bd = NULL;
}
break;
default:
rtems_bdbuf_fatal (bd->state, RTEMS_BLKDEV_FATAL_BDBUF_STATE_4);
200eae0: 7f ff f8 3d call 200cbd4 <rtems_bdbuf_fatal> <== NOT EXECUTED
200eae4: 92 12 60 02 or %o1, 2, %o1 <== NOT EXECUTED
static void
rtems_bdbuf_check_read_ahead_trigger (rtems_disk_device *dd,
rtems_blkdev_bnum block)
{
if (bdbuf_cache.read_ahead_task != 0
200eae8: 03 00 80 86 sethi %hi(0x2021800), %g1
200eaec: d0 00 61 00 ld [ %g1 + 0x100 ], %o0 ! 2021900 <bdbuf_cache+0x84>
200eaf0: 80 a2 20 00 cmp %o0, 0
200eaf4: 02 80 00 26 be 200eb8c <rtems_bdbuf_read+0x1e0>
200eaf8: 01 00 00 00 nop
&& dd->read_ahead.trigger == block
200eafc: c2 07 60 6c ld [ %i5 + 0x6c ], %g1
200eb00: 80 a0 40 19 cmp %g1, %i1
200eb04: 12 80 00 22 bne 200eb8c <rtems_bdbuf_read+0x1e0>
200eb08: 01 00 00 00 nop
*/
RTEMS_INLINE_ROUTINE bool _Chain_Is_node_off_chain(
const Chain_Node *node
)
{
return (node->next == NULL) && (node->previous == NULL);
200eb0c: c4 07 60 64 ld [ %i5 + 0x64 ], %g2
200eb10: 80 a0 a0 00 cmp %g2, 0
200eb14: 12 80 00 05 bne 200eb28 <rtems_bdbuf_read+0x17c> <== NEVER TAKEN
200eb18: 82 10 20 00 clr %g1
200eb1c: c2 07 60 68 ld [ %i5 + 0x68 ], %g1
200eb20: 80 a0 00 01 cmp %g0, %g1
200eb24: 82 60 3f ff subx %g0, -1, %g1
&& !rtems_bdbuf_is_read_ahead_active (dd))
200eb28: 80 a0 60 00 cmp %g1, 0
200eb2c: 02 80 00 18 be 200eb8c <rtems_bdbuf_read+0x1e0> <== NEVER TAKEN
200eb30: 03 00 80 86 sethi %hi(0x2021800), %g1
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_head( the_chain )->next;
200eb34: 82 10 60 7c or %g1, 0x7c, %g1 ! 202187c <bdbuf_cache>
{
rtems_status_code sc;
rtems_chain_control *chain = &bdbuf_cache.read_ahead_chain;
if (rtems_chain_is_empty (chain))
200eb38: c4 00 60 88 ld [ %g1 + 0x88 ], %g2
200eb3c: 82 00 60 8c add %g1, 0x8c, %g1
200eb40: 80 a0 80 01 cmp %g2, %g1
200eb44: 12 80 00 0a bne 200eb6c <rtems_bdbuf_read+0x1c0> <== NEVER TAKEN
200eb48: 03 00 80 86 sethi %hi(0x2021800), %g1
{
sc = rtems_event_send (bdbuf_cache.read_ahead_task,
200eb4c: 7f ff e7 2f call 2008808 <rtems_event_send>
200eb50: 92 10 20 02 mov 2, %o1
RTEMS_BDBUF_READ_AHEAD_WAKE_UP);
if (sc != RTEMS_SUCCESSFUL)
200eb54: 80 a2 20 00 cmp %o0, 0
200eb58: 02 80 00 05 be 200eb6c <rtems_bdbuf_read+0x1c0> <== ALWAYS TAKEN
200eb5c: 03 00 80 86 sethi %hi(0x2021800), %g1
rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_RA_WAKE_UP);
200eb60: 11 10 80 00 sethi %hi(0x42000000), %o0 <== NOT EXECUTED
200eb64: 7f ff ea 0d call 2009398 <rtems_fatal_error_occurred> <== NOT EXECUTED
200eb68: 90 12 20 1f or %o0, 0x1f, %o0 ! 4200001f <RAM_END+0x3fc0001f><== NOT EXECUTED
Chain_Control *the_chain,
Chain_Node *the_node
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
200eb6c: 82 10 60 7c or %g1, 0x7c, %g1
200eb70: c4 00 60 90 ld [ %g1 + 0x90 ], %g2
}
rtems_chain_append_unprotected (chain, &dd->read_ahead.node);
200eb74: 86 07 60 64 add %i5, 0x64, %g3
the_node->next = tail;
200eb78: 88 00 60 8c add %g1, 0x8c, %g4
tail->previous = the_node;
200eb7c: c6 20 60 90 st %g3, [ %g1 + 0x90 ]
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
the_node->next = tail;
200eb80: c8 27 60 64 st %g4, [ %i5 + 0x64 ]
tail->previous = the_node;
old_last->next = the_node;
200eb84: c6 20 80 00 st %g3, [ %g2 ]
the_node->previous = old_last;
200eb88: c4 27 60 68 st %g2, [ %i5 + 0x68 ]
}
rtems_bdbuf_check_read_ahead_trigger (dd, block);
}
rtems_bdbuf_unlock_cache ();
200eb8c: 7f ff f8 21 call 200cc10 <rtems_bdbuf_unlock_cache>
200eb90: 01 00 00 00 nop
*bd_ptr = bd;
200eb94: f8 26 80 00 st %i4, [ %i2 ]
return sc;
}
200eb98: 81 c7 e0 08 ret
200eb9c: 81 e8 00 00 restore
0200e400 <rtems_bdbuf_read_ahead_cancel>:
*/
RTEMS_INLINE_ROUTINE bool _Chain_Is_node_off_chain(
const Chain_Node *node
)
{
return (node->next == NULL) && (node->previous == NULL);
200e400: c2 02 20 64 ld [ %o0 + 0x64 ], %g1
200e404: 80 a0 60 00 cmp %g1, 0
200e408: 12 80 00 05 bne 200e41c <rtems_bdbuf_read_ahead_cancel+0x1c><== NEVER TAKEN
200e40c: 84 10 20 00 clr %g2
200e410: c4 02 20 68 ld [ %o0 + 0x68 ], %g2
200e414: 80 a0 00 02 cmp %g0, %g2
200e418: 84 60 3f ff subx %g0, -1, %g2
}
static void
rtems_bdbuf_read_ahead_cancel (rtems_disk_device *dd)
{
if (rtems_bdbuf_is_read_ahead_active (dd))
200e41c: 80 a0 a0 00 cmp %g2, 0
200e420: 12 80 00 07 bne 200e43c <rtems_bdbuf_read_ahead_cancel+0x3c><== ALWAYS TAKEN
200e424: 01 00 00 00 nop
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
previous = the_node->previous;
200e428: c4 02 20 68 ld [ %o0 + 0x68 ], %g2 <== NOT EXECUTED
next->previous = previous;
200e42c: c4 20 60 04 st %g2, [ %g1 + 4 ] <== NOT EXECUTED
previous->next = next;
200e430: c2 20 80 00 st %g1, [ %g2 ] <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE void _Chain_Set_off_chain(
Chain_Node *node
)
{
node->next = node->previous = NULL;
200e434: c0 22 20 68 clr [ %o0 + 0x68 ] <== NOT EXECUTED
200e438: c0 22 20 64 clr [ %o0 + 0x64 ] <== NOT EXECUTED
200e43c: 81 c3 e0 08 retl
0200e2d0 <rtems_bdbuf_read_ahead_task>:
return sc;
}
static rtems_task
rtems_bdbuf_read_ahead_task (rtems_task_argument arg)
{
200e2d0: 9d e3 bf a0 save %sp, -96, %sp
200e2d4: 33 00 80 86 sethi %hi(0x2021800), %i1
rtems_chain_control *chain = &bdbuf_cache.read_ahead_chain;
while (bdbuf_cache.read_ahead_enabled)
200e2d8: 35 00 80 86 sethi %hi(0x2021800), %i2
200e2dc: b2 16 61 04 or %i1, 0x104, %i1
200e2e0: 10 80 00 41 b 200e3e4 <rtems_bdbuf_read_ahead_task+0x114>
200e2e4: 31 00 80 7b sethi %hi(0x201ec00), %i0
{
rtems_chain_node *node;
rtems_bdbuf_wait_for_event (RTEMS_BDBUF_READ_AHEAD_WAKE_UP);
200e2e8: 7f ff fa 63 call 200cc74 <rtems_bdbuf_wait_for_event>
200e2ec: 90 10 20 02 mov 2, %o0
rtems_bdbuf_lock_cache ();
200e2f0: 7f ff fa 32 call 200cbb8 <rtems_bdbuf_lock_cache>
200e2f4: 01 00 00 00 nop
while ((node = rtems_chain_get_unprotected (chain)) != NULL)
200e2f8: 30 80 00 34 b,a 200e3c8 <rtems_bdbuf_read_ahead_task+0xf8>
rtems_blkdev_bnum block,
rtems_blkdev_bnum *media_block_ptr)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
if (block < dd->block_count)
200e2fc: c4 07 7f c4 ld [ %i5 + -60 ], %g2
while ((node = rtems_chain_get_unprotected (chain)) != NULL)
{
rtems_disk_device *dd = (rtems_disk_device *)
((char *) node - offsetof (rtems_disk_device, read_ahead.node));
rtems_blkdev_bnum block = dd->read_ahead.next;
rtems_blkdev_bnum media_block = 0;
200e300: 92 10 20 00 clr %o1
rtems_blkdev_bnum block,
rtems_blkdev_bnum *media_block_ptr)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
if (block < dd->block_count)
200e304: 80 a7 00 02 cmp %i4, %g2
200e308: 1a 80 00 11 bcc 200e34c <rtems_bdbuf_read_ahead_task+0x7c>
200e30c: 82 10 20 04 mov 4, %g1
}
static rtems_blkdev_bnum
rtems_bdbuf_media_block (const rtems_disk_device *dd, rtems_blkdev_bnum block)
{
if (dd->block_to_media_block_shift >= 0)
200e310: d2 07 7f cc ld [ %i5 + -52 ], %o1
200e314: 80 a2 60 00 cmp %o1, 0
200e318: 16 80 00 0a bge 200e340 <rtems_bdbuf_read_ahead_task+0x70><== ALWAYS TAKEN
200e31c: 93 2f 00 09 sll %i4, %o1, %o1
/*
* Change the block number for the block size to the block number for the media
* block size. We have to use 64bit maths. There is no short cut here.
*/
return (rtems_blkdev_bnum)
((((uint64_t) block) * dd->block_size) / dd->media_block_size);
200e320: d2 07 7f c0 ld [ %i5 + -64 ], %o1 <== NOT EXECUTED
200e324: 94 10 20 00 clr %o2 <== NOT EXECUTED
200e328: 96 10 00 1c mov %i4, %o3 <== NOT EXECUTED
200e32c: 40 00 3a d8 call 201ce8c <__muldi3> <== NOT EXECUTED
200e330: 90 10 20 00 clr %o0 <== NOT EXECUTED
200e334: d6 07 7f bc ld [ %i5 + -68 ], %o3 <== NOT EXECUTED
200e338: 40 00 3c e6 call 201d6d0 <__udivdi3> <== NOT EXECUTED
200e33c: 94 10 20 00 clr %o2 <== NOT EXECUTED
/*
* 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.
*/
*media_block_ptr = rtems_bdbuf_media_block (dd, block) + dd->start;
200e340: c2 07 7f b4 ld [ %i5 + -76 ], %g1
200e344: 92 02 40 01 add %o1, %g1, %o1
200e348: 82 10 20 00 clr %g1
*/
RTEMS_INLINE_ROUTINE void _Chain_Set_off_chain(
Chain_Node *node
)
{
node->next = node->previous = NULL;
200e34c: c0 27 60 04 clr [ %i5 + 4 ]
rtems_status_code sc =
rtems_bdbuf_get_media_block (dd, block, &media_block);
rtems_chain_set_off_chain (&dd->read_ahead.node);
if (sc == RTEMS_SUCCESSFUL)
200e350: 80 a0 60 00 cmp %g1, 0
200e354: 12 80 00 1b bne 200e3c0 <rtems_bdbuf_read_ahead_task+0xf0>
200e358: c0 27 40 00 clr [ %i5 ]
rtems_bdbuf_wait_for_event (RTEMS_BDBUF_READ_AHEAD_WAKE_UP);
rtems_bdbuf_lock_cache ();
while ((node = rtems_chain_get_unprotected (chain)) != NULL)
{
rtems_disk_device *dd = (rtems_disk_device *)
200e35c: b6 07 7f 9c add %i5, -100, %i3
rtems_chain_set_off_chain (&dd->read_ahead.node);
if (sc == RTEMS_SUCCESSFUL)
{
rtems_bdbuf_buffer *bd =
200e360: 7f ff fd 08 call 200d780 <rtems_bdbuf_get_buffer_for_read_ahead>
200e364: 90 10 00 1b mov %i3, %o0
rtems_bdbuf_get_buffer_for_read_ahead (dd, media_block);
if (bd != NULL)
200e368: 92 92 20 00 orcc %o0, 0, %o1
200e36c: 02 80 00 17 be 200e3c8 <rtems_bdbuf_read_ahead_task+0xf8> <== NEVER TAKEN
200e370: c2 06 21 40 ld [ %i0 + 0x140 ], %g1
{
uint32_t transfer_count = dd->block_count - block;
200e374: d4 07 7f c4 ld [ %i5 + -60 ], %o2
200e378: 94 22 80 1c sub %o2, %i4, %o2
uint32_t max_transfer_count = bdbuf_config.max_read_ahead_blocks;
if (transfer_count >= max_transfer_count)
200e37c: 80 a2 80 01 cmp %o2, %g1
200e380: 2a 80 00 09 bcs,a 200e3a4 <rtems_bdbuf_read_ahead_task+0xd4>
200e384: 82 10 3f ff mov -1, %g1
{
transfer_count = max_transfer_count;
dd->read_ahead.trigger = block + transfer_count / 2;
200e388: 85 30 60 01 srl %g1, 1, %g2
dd->read_ahead.next = block + transfer_count;
200e38c: 94 10 00 01 mov %g1, %o2
uint32_t max_transfer_count = bdbuf_config.max_read_ahead_blocks;
if (transfer_count >= max_transfer_count)
{
transfer_count = max_transfer_count;
dd->read_ahead.trigger = block + transfer_count / 2;
200e390: 84 00 80 1c add %g2, %i4, %g2
dd->read_ahead.next = block + transfer_count;
200e394: b8 00 40 1c add %g1, %i4, %i4
uint32_t max_transfer_count = bdbuf_config.max_read_ahead_blocks;
if (transfer_count >= max_transfer_count)
{
transfer_count = max_transfer_count;
dd->read_ahead.trigger = block + transfer_count / 2;
200e398: c4 27 60 08 st %g2, [ %i5 + 8 ]
dd->read_ahead.next = block + transfer_count;
200e39c: 10 80 00 03 b 200e3a8 <rtems_bdbuf_read_ahead_task+0xd8>
200e3a0: f8 27 60 0c st %i4, [ %i5 + 0xc ]
}
else
{
dd->read_ahead.trigger = RTEMS_DISK_READ_AHEAD_NO_TRIGGER;
200e3a4: c2 27 60 08 st %g1, [ %i5 + 8 ]
}
++dd->stats.read_ahead_transfers;
200e3a8: c2 07 7f e8 ld [ %i5 + -24 ], %g1
rtems_bdbuf_execute_read_request (dd, bd, transfer_count);
200e3ac: 90 10 00 1b mov %i3, %o0
else
{
dd->read_ahead.trigger = RTEMS_DISK_READ_AHEAD_NO_TRIGGER;
}
++dd->stats.read_ahead_transfers;
200e3b0: 82 00 60 01 inc %g1
rtems_bdbuf_execute_read_request (dd, bd, transfer_count);
200e3b4: 7f ff ff 91 call 200e1f8 <rtems_bdbuf_execute_read_request>
200e3b8: c2 27 7f e8 st %g1, [ %i5 + -24 ]
200e3bc: 30 80 00 03 b,a 200e3c8 <rtems_bdbuf_read_ahead_task+0xf8>
}
}
else
{
dd->read_ahead.trigger = RTEMS_DISK_READ_AHEAD_NO_TRIGGER;
200e3c0: 82 10 3f ff mov -1, %g1
200e3c4: c2 27 60 08 st %g1, [ %i5 + 8 ]
200e3c8: 7f ff f9 dc call 200cb38 <_Chain_Get_unprotected>
200e3cc: 90 10 00 19 mov %i1, %o0
rtems_chain_node *node;
rtems_bdbuf_wait_for_event (RTEMS_BDBUF_READ_AHEAD_WAKE_UP);
rtems_bdbuf_lock_cache ();
while ((node = rtems_chain_get_unprotected (chain)) != NULL)
200e3d0: ba 92 20 00 orcc %o0, 0, %i5
200e3d4: 32 bf ff ca bne,a 200e2fc <rtems_bdbuf_read_ahead_task+0x2c>
200e3d8: f8 07 60 0c ld [ %i5 + 0xc ], %i4
{
dd->read_ahead.trigger = RTEMS_DISK_READ_AHEAD_NO_TRIGGER;
}
}
rtems_bdbuf_unlock_cache ();
200e3dc: 7f ff fa 0d call 200cc10 <rtems_bdbuf_unlock_cache>
200e3e0: 01 00 00 00 nop
static rtems_task
rtems_bdbuf_read_ahead_task (rtems_task_argument arg)
{
rtems_chain_control *chain = &bdbuf_cache.read_ahead_chain;
while (bdbuf_cache.read_ahead_enabled)
200e3e4: 82 16 a0 7c or %i2, 0x7c, %g1
200e3e8: c2 08 60 94 ldub [ %g1 + 0x94 ], %g1
200e3ec: 80 a0 60 00 cmp %g1, 0
200e3f0: 12 bf ff be bne 200e2e8 <rtems_bdbuf_read_ahead_task+0x18><== ALWAYS TAKEN
200e3f4: 01 00 00 00 nop
}
rtems_bdbuf_unlock_cache ();
}
rtems_task_delete (RTEMS_SELF);
200e3f8: 7f ff ea fc call 2008fe8 <rtems_task_delete> <== NOT EXECUTED
200e3fc: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED
0200eba0 <rtems_bdbuf_release>:
return RTEMS_SUCCESSFUL;
}
rtems_status_code
rtems_bdbuf_release (rtems_bdbuf_buffer *bd)
{
200eba0: 9d e3 bf a0 save %sp, -96, %sp
}
static rtems_status_code
rtems_bdbuf_check_bd_and_lock_cache (rtems_bdbuf_buffer *bd, const char *kind)
{
if (bd == NULL)
200eba4: 80 a6 20 00 cmp %i0, 0
200eba8: 02 80 00 31 be 200ec6c <rtems_bdbuf_release+0xcc> <== NEVER TAKEN
200ebac: 01 00 00 00 nop
if (rtems_bdbuf_tracer)
{
printf ("bdbuf:%s: %" PRIu32 "\n", kind, bd->block);
rtems_bdbuf_show_users (kind, bd);
}
rtems_bdbuf_lock_cache();
200ebb0: 7f ff f8 02 call 200cbb8 <rtems_bdbuf_lock_cache>
200ebb4: 01 00 00 00 nop
sc = rtems_bdbuf_check_bd_and_lock_cache (bd, "release");
if (sc != RTEMS_SUCCESSFUL)
return sc;
switch (bd->state)
200ebb8: d0 06 20 20 ld [ %i0 + 0x20 ], %o0
200ebbc: 80 a2 20 04 cmp %o0, 4
200ebc0: 02 80 00 22 be 200ec48 <rtems_bdbuf_release+0xa8>
200ebc4: 01 00 00 00 nop
200ebc8: 18 80 00 06 bgu 200ebe0 <rtems_bdbuf_release+0x40>
200ebcc: 80 a2 20 06 cmp %o0, 6
200ebd0: 80 a2 20 03 cmp %o0, 3
200ebd4: 12 80 00 20 bne 200ec54 <rtems_bdbuf_release+0xb4> <== NEVER TAKEN
200ebd8: 13 10 80 00 sethi %hi(0x42000000), %o1
200ebdc: 30 80 00 04 b,a 200ebec <rtems_bdbuf_release+0x4c>
200ebe0: 18 80 00 1d bgu 200ec54 <rtems_bdbuf_release+0xb4> <== NEVER TAKEN
200ebe4: 13 10 80 00 sethi %hi(0x42000000), %o1
200ebe8: 30 80 00 15 b,a 200ec3c <rtems_bdbuf_release+0x9c>
}
static void
rtems_bdbuf_add_to_lru_list_after_access (rtems_bdbuf_buffer *bd)
{
rtems_bdbuf_group_release (bd);
200ebec: 7f ff f7 e2 call 200cb74 <rtems_bdbuf_group_release>
200ebf0: 90 10 00 18 mov %i0, %o0
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
200ebf4: 82 10 20 02 mov 2, %g1
Chain_Control *the_chain,
Chain_Node *the_node
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
200ebf8: 11 00 80 86 sethi %hi(0x2021800), %o0
200ebfc: c2 26 20 20 st %g1, [ %i0 + 0x20 ]
200ec00: 90 12 20 7c or %o0, 0x7c, %o0
200ec04: c2 02 20 48 ld [ %o0 + 0x48 ], %g1
the_node->next = tail;
200ec08: 84 02 20 44 add %o0, 0x44, %g2
tail->previous = the_node;
200ec0c: f0 22 20 48 st %i0, [ %o0 + 0x48 ]
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
the_node->next = tail;
200ec10: c4 26 00 00 st %g2, [ %i0 ]
tail->previous = the_node;
old_last->next = the_node;
200ec14: f0 20 40 00 st %i0, [ %g1 ]
the_node->previous = old_last;
200ec18: c2 26 20 04 st %g1, [ %i0 + 4 ]
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)
200ec1c: c2 06 20 24 ld [ %i0 + 0x24 ], %g1
200ec20: 80 a0 60 00 cmp %g1, 0
200ec24: 22 80 00 03 be,a 200ec30 <rtems_bdbuf_release+0x90>
200ec28: 90 02 20 74 add %o0, 0x74, %o0
200ec2c: 90 02 20 64 add %o0, 0x64, %o0
rtems_bdbuf_wake (&bdbuf_cache.access_waiters);
else
rtems_bdbuf_wake (&bdbuf_cache.buffer_waiters);
200ec30: 7f ff f8 99 call 200ce94 <rtems_bdbuf_wake>
200ec34: 01 00 00 00 nop
200ec38: 30 80 00 09 b,a 200ec5c <rtems_bdbuf_release+0xbc>
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);
200ec3c: 7f ff fe 02 call 200e444 <rtems_bdbuf_discard_buffer_after_access>
200ec40: 90 10 00 18 mov %i0, %o0
break;
200ec44: 30 80 00 06 b,a 200ec5c <rtems_bdbuf_release+0xbc>
case RTEMS_BDBUF_STATE_ACCESS_MODIFIED:
rtems_bdbuf_add_to_modified_list_after_access (bd);
200ec48: 7f ff f9 9b call 200d2b4 <rtems_bdbuf_add_to_modified_list_after_access>
200ec4c: 90 10 00 18 mov %i0, %o0
break;
200ec50: 30 80 00 03 b,a 200ec5c <rtems_bdbuf_release+0xbc>
default:
rtems_bdbuf_fatal (bd->state, RTEMS_BLKDEV_FATAL_BDBUF_STATE_0);
200ec54: 7f ff f7 e0 call 200cbd4 <rtems_bdbuf_fatal> <== NOT EXECUTED
200ec58: 92 12 60 1c or %o1, 0x1c, %o1 <== NOT EXECUTED
}
if (rtems_bdbuf_tracer)
rtems_bdbuf_show_usage ();
rtems_bdbuf_unlock_cache ();
200ec5c: 7f ff f7 ed call 200cc10 <rtems_bdbuf_unlock_cache>
200ec60: b0 10 20 00 clr %i0
return RTEMS_SUCCESSFUL;
200ec64: 81 c7 e0 08 ret
200ec68: 81 e8 00 00 restore
}
200ec6c: 81 c7 e0 08 ret <== NOT EXECUTED
200ec70: 91 e8 20 09 restore %g0, 9, %o0 <== NOT EXECUTED
0200ec74 <rtems_bdbuf_release_modified>:
rtems_status_code
rtems_bdbuf_release_modified (rtems_bdbuf_buffer *bd)
{
200ec74: 9d e3 bf a0 save %sp, -96, %sp
}
static rtems_status_code
rtems_bdbuf_check_bd_and_lock_cache (rtems_bdbuf_buffer *bd, const char *kind)
{
if (bd == NULL)
200ec78: 80 a6 20 00 cmp %i0, 0
200ec7c: 02 80 00 1a be 200ece4 <rtems_bdbuf_release_modified+0x70><== NEVER TAKEN
200ec80: 01 00 00 00 nop
if (rtems_bdbuf_tracer)
{
printf ("bdbuf:%s: %" PRIu32 "\n", kind, bd->block);
rtems_bdbuf_show_users (kind, bd);
}
rtems_bdbuf_lock_cache();
200ec84: 7f ff f7 cd call 200cbb8 <rtems_bdbuf_lock_cache>
200ec88: 01 00 00 00 nop
sc = rtems_bdbuf_check_bd_and_lock_cache (bd, "release modified");
if (sc != RTEMS_SUCCESSFUL)
return sc;
switch (bd->state)
200ec8c: d0 06 20 20 ld [ %i0 + 0x20 ], %o0
200ec90: 80 a2 20 03 cmp %o0, 3
200ec94: 0a 80 00 0e bcs 200eccc <rtems_bdbuf_release_modified+0x58><== NEVER TAKEN
200ec98: 13 10 80 00 sethi %hi(0x42000000), %o1
200ec9c: 80 a2 20 05 cmp %o0, 5
200eca0: 08 80 00 05 bleu 200ecb4 <rtems_bdbuf_release_modified+0x40>
200eca4: 80 a2 20 06 cmp %o0, 6
200eca8: 12 80 00 09 bne 200eccc <rtems_bdbuf_release_modified+0x58><== NEVER TAKEN
200ecac: 01 00 00 00 nop
200ecb0: 30 80 00 04 b,a 200ecc0 <rtems_bdbuf_release_modified+0x4c>
{
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);
200ecb4: 7f ff f9 80 call 200d2b4 <rtems_bdbuf_add_to_modified_list_after_access>
200ecb8: 90 10 00 18 mov %i0, %o0
break;
200ecbc: 30 80 00 06 b,a 200ecd4 <rtems_bdbuf_release_modified+0x60>
case RTEMS_BDBUF_STATE_ACCESS_PURGED:
rtems_bdbuf_discard_buffer_after_access (bd);
200ecc0: 7f ff fd e1 call 200e444 <rtems_bdbuf_discard_buffer_after_access>
200ecc4: 90 10 00 18 mov %i0, %o0
break;
200ecc8: 30 80 00 03 b,a 200ecd4 <rtems_bdbuf_release_modified+0x60>
default:
rtems_bdbuf_fatal (bd->state, RTEMS_BLKDEV_FATAL_BDBUF_STATE_6);
200eccc: 7f ff f7 c2 call 200cbd4 <rtems_bdbuf_fatal> <== NOT EXECUTED
200ecd0: 92 12 60 04 or %o1, 4, %o1 <== NOT EXECUTED
}
if (rtems_bdbuf_tracer)
rtems_bdbuf_show_usage ();
rtems_bdbuf_unlock_cache ();
200ecd4: 7f ff f7 cf call 200cc10 <rtems_bdbuf_unlock_cache>
200ecd8: b0 10 20 00 clr %i0
return RTEMS_SUCCESSFUL;
200ecdc: 81 c7 e0 08 ret
200ece0: 81 e8 00 00 restore
}
200ece4: 81 c7 e0 08 ret <== NOT EXECUTED
200ece8: 91 e8 20 09 restore %g0, 9, %o0 <== NOT EXECUTED
0200cf28 <rtems_bdbuf_remove_from_tree>:
return bdbuf_cache.buffer_waiters.count;
}
static void
rtems_bdbuf_remove_from_tree (rtems_bdbuf_buffer *bd)
{
200cf28: 9d e3 bf 20 save %sp, -224, %sp
const rtems_bdbuf_buffer* node)
{
const rtems_disk_device *dd = node->dd;
rtems_blkdev_bnum block = node->block;
rtems_bdbuf_buffer* p = *root;
200cf2c: 03 00 80 86 sethi %hi(0x2021800), %g1
*/
static int
rtems_bdbuf_avl_remove(rtems_bdbuf_buffer** root,
const rtems_bdbuf_buffer* node)
{
const rtems_disk_device *dd = node->dd;
200cf30: f8 06 20 14 ld [ %i0 + 0x14 ], %i4
rtems_blkdev_bnum block = node->block;
200cf34: f6 06 20 18 ld [ %i0 + 0x18 ], %i3
rtems_bdbuf_buffer* p = *root;
200cf38: fa 00 60 b8 ld [ %g1 + 0xb8 ], %i5
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));
200cf3c: 90 07 bf 80 add %fp, -128, %o0
200cf40: 92 10 20 00 clr %o1
200cf44: 40 00 1d 98 call 20145a4 <memset>
200cf48: 94 10 20 80 mov 0x80, %o2
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;
200cf4c: 86 07 bf 80 add %fp, -128, %g3
*buf_prev++ = p;
if (((uintptr_t) p->dd < (uintptr_t) dd)
|| ((p->dd == dd) && (p->block < block)))
{
p->avl.cache = 1;
200cf50: 84 10 20 01 mov 1, %g2
p = p->avl.right;
}
else if ((p->dd != dd) || (p->block != block))
{
p->avl.cache = -1;
200cf54: 10 80 00 15 b 200cfa8 <rtems_bdbuf_remove_from_tree+0x80>
200cf58: b4 10 3f ff mov -1, %i2
memset (buf_stack, 0, sizeof(buf_stack));
while (p != NULL)
{
*buf_prev++ = p;
200cf5c: fa 20 c0 00 st %i5, [ %g3 ]
if (((uintptr_t) p->dd < (uintptr_t) dd)
200cf60: 80 a0 40 1c cmp %g1, %i4
200cf64: 0a 80 00 09 bcs 200cf88 <rtems_bdbuf_remove_from_tree+0x60><== NEVER TAKEN
200cf68: 88 00 e0 04 add %g3, 4, %g4
|| ((p->dd == dd) && (p->block < block)))
200cf6c: 80 a0 40 1c cmp %g1, %i4
200cf70: 32 80 00 0c bne,a 200cfa0 <rtems_bdbuf_remove_from_tree+0x78><== NEVER TAKEN
200cf74: f4 2f 60 10 stb %i2, [ %i5 + 0x10 ] <== NOT EXECUTED
200cf78: c2 07 60 18 ld [ %i5 + 0x18 ], %g1
200cf7c: 80 a0 40 1b cmp %g1, %i3
200cf80: 1a 80 00 05 bcc 200cf94 <rtems_bdbuf_remove_from_tree+0x6c>
200cf84: 01 00 00 00 nop
{
p->avl.cache = 1;
200cf88: c4 2f 60 10 stb %g2, [ %i5 + 0x10 ]
p = p->avl.right;
200cf8c: 10 80 00 06 b 200cfa4 <rtems_bdbuf_remove_from_tree+0x7c>
200cf90: fa 07 60 0c ld [ %i5 + 0xc ], %i5
}
else if ((p->dd != dd) || (p->block != block))
200cf94: 02 80 00 ba be 200d27c <rtems_bdbuf_remove_from_tree+0x354>
200cf98: 82 07 bf 80 add %fp, -128, %g1
{
p->avl.cache = -1;
200cf9c: f4 2f 60 10 stb %i2, [ %i5 + 0x10 ]
p = p->avl.left;
200cfa0: fa 07 60 08 ld [ %i5 + 8 ], %i5
memset (buf_stack, 0, sizeof(buf_stack));
while (p != NULL)
{
*buf_prev++ = p;
200cfa4: 86 10 00 04 mov %g4, %g3
bool modified = false;
memset (buf_stack, 0, sizeof(buf_stack));
while (p != NULL)
200cfa8: 80 a7 60 00 cmp %i5, 0
200cfac: 32 bf ff ec bne,a 200cf5c <rtems_bdbuf_remove_from_tree+0x34><== ALWAYS TAKEN
200cfb0: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
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);
200cfb4: d0 06 20 20 ld [ %i0 + 0x20 ], %o0 <== NOT EXECUTED
200cfb8: 13 10 80 00 sethi %hi(0x42000000), %o1 <== NOT EXECUTED
200cfbc: 7f ff ff 06 call 200cbd4 <rtems_bdbuf_fatal> <== NOT EXECUTED
200cfc0: 92 12 60 09 or %o1, 9, %o1 ! 42000009 <RAM_END+0x3fc00009><== NOT EXECUTED
{
p = NULL;
}
/* at this moment q - is a node to delete, p is q's parent */
if (q->avl.right == NULL)
200cfc4: c2 07 60 0c ld [ %i5 + 0xc ], %g1
200cfc8: 80 a0 60 00 cmp %g1, 0
200cfcc: 32 80 00 08 bne,a 200cfec <rtems_bdbuf_remove_from_tree+0xc4>
200cfd0: c4 00 60 08 ld [ %g1 + 8 ], %g2
{
r = q->avl.left;
200cfd4: c2 07 60 08 ld [ %i5 + 8 ], %g1
if (r != NULL)
200cfd8: 80 a0 60 00 cmp %g1, 0
200cfdc: 32 80 00 27 bne,a 200d078 <rtems_bdbuf_remove_from_tree+0x150>
200cfe0: c0 28 60 11 clrb [ %g1 + 0x11 ]
*t = q = s;
}
}
if (p != NULL)
200cfe4: 10 80 00 26 b 200d07c <rtems_bdbuf_remove_from_tree+0x154>
200cfe8: 80 a7 20 00 cmp %i4, 0
{
rtems_bdbuf_buffer **t;
r = q->avl.right;
if (r->avl.left == NULL)
200cfec: 80 a0 a0 00 cmp %g2, 0
200cff0: 02 80 00 06 be 200d008 <rtems_bdbuf_remove_from_tree+0xe0>
200cff4: 84 10 00 01 mov %g1, %g2
200cff8: b6 10 00 01 mov %g1, %i3
200cffc: 86 10 00 04 mov %g4, %g3
while (s->avl.left != NULL)
{
*buf_prev++ = r = s;
s = r->avl.left;
r->avl.cache = -1;
200d000: 10 80 00 0f b 200d03c <rtems_bdbuf_remove_from_tree+0x114>
200d004: b2 10 3f ff mov -1, %i1
r = q->avl.right;
if (r->avl.left == NULL)
{
r->avl.left = q->avl.left;
200d008: c4 07 60 08 ld [ %i5 + 8 ], %g2
r->avl.bal = q->avl.bal;
r->avl.cache = 1;
*buf_prev++ = q = r;
200d00c: c2 21 3f fc st %g1, [ %g4 + -4 ]
r = q->avl.right;
if (r->avl.left == NULL)
{
r->avl.left = q->avl.left;
200d010: c4 20 60 08 st %g2, [ %g1 + 8 ]
r->avl.bal = q->avl.bal;
200d014: c4 0f 60 11 ldub [ %i5 + 0x11 ], %g2
r->avl.cache = 1;
*buf_prev++ = q = r;
200d018: 86 10 00 04 mov %g4, %g3
r = q->avl.right;
if (r->avl.left == NULL)
{
r->avl.left = q->avl.left;
r->avl.bal = q->avl.bal;
200d01c: c4 28 60 11 stb %g2, [ %g1 + 0x11 ]
r->avl.cache = 1;
200d020: 84 10 20 01 mov 1, %g2
200d024: 10 80 00 15 b 200d078 <rtems_bdbuf_remove_from_tree+0x150>
200d028: c4 28 60 10 stb %g2, [ %g1 + 0x10 ]
while (s->avl.left != NULL)
{
*buf_prev++ = r = s;
s = r->avl.left;
r->avl.cache = -1;
200d02c: f2 28 a0 10 stb %i1, [ %g2 + 0x10 ]
s = r;
while (s->avl.left != NULL)
{
*buf_prev++ = r = s;
s = r->avl.left;
200d030: b6 10 00 02 mov %g2, %i3
t = buf_prev++;
s = r;
while (s->avl.left != NULL)
{
*buf_prev++ = r = s;
200d034: 86 00 e0 04 add %g3, 4, %g3
s = r->avl.left;
200d038: 84 10 00 1a mov %i2, %g2
else
{
t = buf_prev++;
s = r;
while (s->avl.left != NULL)
200d03c: f4 00 a0 08 ld [ %g2 + 8 ], %i2
200d040: 80 a6 a0 00 cmp %i2, 0
200d044: 32 bf ff fa bne,a 200d02c <rtems_bdbuf_remove_from_tree+0x104>
200d048: c4 20 c0 00 st %g2, [ %g3 ]
*buf_prev++ = r = s;
s = r->avl.left;
r->avl.cache = -1;
}
s->avl.left = q->avl.left;
200d04c: f4 07 60 08 ld [ %i5 + 8 ], %i2
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;
200d050: c4 21 3f fc st %g2, [ %g4 + -4 ]
*buf_prev++ = r = s;
s = r->avl.left;
r->avl.cache = -1;
}
s->avl.left = q->avl.left;
200d054: f4 20 a0 08 st %i2, [ %g2 + 8 ]
r->avl.left = s->avl.right;
200d058: f4 00 a0 0c ld [ %g2 + 0xc ], %i2
s->avl.right = q->avl.right;
200d05c: c2 20 a0 0c st %g1, [ %g2 + 0xc ]
s->avl.bal = q->avl.bal;
200d060: c2 0f 60 11 ldub [ %i5 + 0x11 ], %g1
s = r->avl.left;
r->avl.cache = -1;
}
s->avl.left = q->avl.left;
r->avl.left = s->avl.right;
200d064: f4 26 e0 08 st %i2, [ %i3 + 8 ]
s->avl.right = q->avl.right;
s->avl.bal = q->avl.bal;
200d068: c2 28 a0 11 stb %g1, [ %g2 + 0x11 ]
s->avl.cache = 1;
200d06c: 82 10 20 01 mov 1, %g1
200d070: c2 28 a0 10 stb %g1, [ %g2 + 0x10 ]
*t = q = s;
200d074: 82 10 00 02 mov %g2, %g1
}
}
if (p != NULL)
200d078: 80 a7 20 00 cmp %i4, 0
200d07c: 02 80 00 0d be 200d0b0 <rtems_bdbuf_remove_from_tree+0x188>
200d080: 05 00 80 86 sethi %hi(0x2021800), %g2
{
if (p->avl.cache == -1)
200d084: c4 4f 20 10 ldsb [ %i4 + 0x10 ], %g2
200d088: 80 a0 bf ff cmp %g2, -1
200d08c: 32 80 00 03 bne,a 200d098 <rtems_bdbuf_remove_from_tree+0x170>
200d090: c2 27 20 0c st %g1, [ %i4 + 0xc ]
{
p->avl.left = q;
200d094: c2 27 20 08 st %g1, [ %i4 + 8 ]
modified = true;
while (modified)
{
if (buf_prev > buf_stack)
200d098: 82 07 bf 80 add %fp, -128, %g1
200d09c: 80 a0 c0 01 cmp %g3, %g1
200d0a0: 18 80 00 06 bgu 200d0b8 <rtems_bdbuf_remove_from_tree+0x190>
200d0a4: ba 10 20 01 mov 1, %i5
200d0a8: 81 c7 e0 08 ret
200d0ac: 81 e8 00 00 restore
p->avl.right = q;
}
}
else
{
*root = q;
200d0b0: 10 bf ff fa b 200d098 <rtems_bdbuf_remove_from_tree+0x170>
200d0b4: c2 20 a0 b8 st %g1, [ %g2 + 0xb8 ]
case +1:
p->avl.bal = 0;
break;
case 0:
p->avl.bal = -1;
200d0b8: b6 10 3f ff mov -1, %i3
default:
break;
}
}
if (buf_prev > buf_stack)
200d0bc: b2 10 00 01 mov %g1, %i1
while (modified)
{
if (buf_prev > buf_stack)
{
p = *--buf_prev;
200d0c0: c2 00 ff fc ld [ %g3 + -4 ], %g1
else
{
break;
}
if (p->avl.cache == -1)
200d0c4: f8 48 60 10 ldsb [ %g1 + 0x10 ], %i4
200d0c8: c4 08 60 11 ldub [ %g1 + 0x11 ], %g2
200d0cc: 80 a7 3f ff cmp %i4, -1
{
/* rebalance left branch */
switch (p->avl.bal)
200d0d0: 85 28 a0 18 sll %g2, 0x18, %g2
else
{
break;
}
if (p->avl.cache == -1)
200d0d4: 12 80 00 2a bne 200d17c <rtems_bdbuf_remove_from_tree+0x254>
200d0d8: 85 38 a0 18 sra %g2, 0x18, %g2
{
/* rebalance left branch */
switch (p->avl.bal)
200d0dc: 80 a0 a0 00 cmp %g2, 0
200d0e0: 22 80 00 14 be,a 200d130 <rtems_bdbuf_remove_from_tree+0x208>
200d0e4: fa 28 60 11 stb %i5, [ %g1 + 0x11 ]
200d0e8: 80 a0 a0 01 cmp %g2, 1
200d0ec: 02 80 00 06 be 200d104 <rtems_bdbuf_remove_from_tree+0x1dc>
200d0f0: 80 a0 bf ff cmp %g2, -1
200d0f4: 12 80 00 4f bne 200d230 <rtems_bdbuf_remove_from_tree+0x308><== NEVER TAKEN
200d0f8: 84 10 20 01 mov 1, %g2
{
/* rebalance right branch */
switch (p->avl.bal)
{
case +1:
p->avl.bal = 0;
200d0fc: 10 80 00 4d b 200d230 <rtems_bdbuf_remove_from_tree+0x308>
200d100: c0 28 60 11 clrb [ %g1 + 0x11 ]
p->avl.bal = 1;
modified = false;
break;
case +1:
p1 = p->avl.right;
200d104: c4 00 60 0c ld [ %g1 + 0xc ], %g2
if (p1->avl.bal >= 0) /* simple RR-turn */
200d108: f4 48 a0 11 ldsb [ %g2 + 0x11 ], %i2
200d10c: 80 a6 a0 00 cmp %i2, 0
200d110: 06 80 00 0a bl 200d138 <rtems_bdbuf_remove_from_tree+0x210>
200d114: c8 00 a0 08 ld [ %g2 + 8 ], %g4
{
p->avl.right = p1->avl.left;
200d118: c8 20 60 0c st %g4, [ %g1 + 0xc ]
p1->avl.left = p;
if (p1->avl.bal == 0)
200d11c: 80 a6 a0 00 cmp %i2, 0
200d120: 12 80 00 2d bne 200d1d4 <rtems_bdbuf_remove_from_tree+0x2ac>
200d124: c2 20 a0 08 st %g1, [ %g2 + 8 ]
{
p1->avl.bal = -1;
200d128: f8 28 a0 11 stb %i4, [ %g2 + 0x11 ]
200d12c: 82 10 00 02 mov %g2, %g1
modified = false;
200d130: 10 80 00 40 b 200d230 <rtems_bdbuf_remove_from_tree+0x308>
200d134: 84 10 20 00 clr %g2
}
else /* double RL-turn */
{
p2 = p1->avl.left;
p1->avl.left = p2->avl.right;
200d138: f4 01 20 0c ld [ %g4 + 0xc ], %i2
p2->avl.right = p1;
200d13c: c4 21 20 0c st %g2, [ %g4 + 0xc ]
}
else /* double RL-turn */
{
p2 = p1->avl.left;
p1->avl.left = p2->avl.right;
200d140: f4 20 a0 08 st %i2, [ %g2 + 8 ]
p2->avl.right = p1;
p->avl.right = p2->avl.left;
200d144: f4 01 20 08 ld [ %g4 + 8 ], %i2
p2->avl.left = p;
200d148: c2 21 20 08 st %g1, [ %g4 + 8 ]
{
p2 = p1->avl.left;
p1->avl.left = p2->avl.right;
p2->avl.right = p1;
p->avl.right = p2->avl.left;
200d14c: f4 20 60 0c st %i2, [ %g1 + 0xc ]
p2->avl.left = p;
if (p2->avl.bal == +1) p->avl.bal = -1; else p->avl.bal = 0;
200d150: f4 49 20 11 ldsb [ %g4 + 0x11 ], %i2
200d154: 80 a6 a0 01 cmp %i2, 1
200d158: 32 80 00 03 bne,a 200d164 <rtems_bdbuf_remove_from_tree+0x23c>
200d15c: c0 28 60 11 clrb [ %g1 + 0x11 ]
200d160: f8 28 60 11 stb %i4, [ %g1 + 0x11 ]
if (p2->avl.bal == -1) p1->avl.bal = 1; else p1->avl.bal = 0;
200d164: c2 49 20 11 ldsb [ %g4 + 0x11 ], %g1
200d168: 80 a0 7f ff cmp %g1, -1
200d16c: 32 80 00 2e bne,a 200d224 <rtems_bdbuf_remove_from_tree+0x2fc><== ALWAYS TAKEN
200d170: c0 28 a0 11 clrb [ %g2 + 0x11 ]
200d174: 10 80 00 2c b 200d224 <rtems_bdbuf_remove_from_tree+0x2fc><== NOT EXECUTED
200d178: fa 28 a0 11 stb %i5, [ %g2 + 0x11 ] <== NOT EXECUTED
}
}
else
{
/* rebalance right branch */
switch (p->avl.bal)
200d17c: 80 a0 a0 00 cmp %g2, 0
200d180: 22 bf ff ec be,a 200d130 <rtems_bdbuf_remove_from_tree+0x208>
200d184: f6 28 60 11 stb %i3, [ %g1 + 0x11 ]
200d188: 80 a0 a0 01 cmp %g2, 1
200d18c: 02 80 00 06 be 200d1a4 <rtems_bdbuf_remove_from_tree+0x27c>
200d190: 80 a0 bf ff cmp %g2, -1
200d194: 32 80 00 27 bne,a 200d230 <rtems_bdbuf_remove_from_tree+0x308><== NEVER TAKEN
200d198: 84 10 20 01 mov 1, %g2 <== NOT EXECUTED
p->avl.bal = -1;
modified = false;
break;
case -1:
p1 = p->avl.left;
200d19c: 10 80 00 04 b 200d1ac <rtems_bdbuf_remove_from_tree+0x284>
200d1a0: c4 00 60 08 ld [ %g1 + 8 ], %g2
{
/* rebalance right branch */
switch (p->avl.bal)
{
case +1:
p->avl.bal = 0;
200d1a4: 10 80 00 22 b 200d22c <rtems_bdbuf_remove_from_tree+0x304>
200d1a8: c0 28 60 11 clrb [ %g1 + 0x11 ]
break;
case -1:
p1 = p->avl.left;
if (p1->avl.bal <= 0) /* simple LL-turn */
200d1ac: f8 48 a0 11 ldsb [ %g2 + 0x11 ], %i4
200d1b0: 80 a7 20 00 cmp %i4, 0
200d1b4: 14 80 00 0c bg 200d1e4 <rtems_bdbuf_remove_from_tree+0x2bc>
200d1b8: c8 00 a0 0c ld [ %g2 + 0xc ], %g4
{
p->avl.left = p1->avl.right;
200d1bc: c8 20 60 08 st %g4, [ %g1 + 8 ]
p1->avl.right = p;
if (p1->avl.bal == 0)
200d1c0: 80 a7 20 00 cmp %i4, 0
200d1c4: 12 80 00 04 bne 200d1d4 <rtems_bdbuf_remove_from_tree+0x2ac><== NEVER TAKEN
200d1c8: c2 20 a0 0c st %g1, [ %g2 + 0xc ]
{
p1->avl.bal = 1;
200d1cc: 10 bf ff d8 b 200d12c <rtems_bdbuf_remove_from_tree+0x204>
200d1d0: fa 28 a0 11 stb %i5, [ %g2 + 0x11 ]
modified = false;
}
else
{
p->avl.bal = 0;
200d1d4: c0 28 60 11 clrb [ %g1 + 0x11 ]
p1->avl.bal = 0;
200d1d8: c0 28 a0 11 clrb [ %g2 + 0x11 ]
200d1dc: 10 80 00 14 b 200d22c <rtems_bdbuf_remove_from_tree+0x304>
200d1e0: 82 10 00 02 mov %g2, %g1
}
else /* double LR-turn */
{
p2 = p1->avl.right;
p1->avl.right = p2->avl.left;
200d1e4: f8 01 20 08 ld [ %g4 + 8 ], %i4
p2->avl.left = p1;
200d1e8: c4 21 20 08 st %g2, [ %g4 + 8 ]
}
else /* double LR-turn */
{
p2 = p1->avl.right;
p1->avl.right = p2->avl.left;
200d1ec: f8 20 a0 0c st %i4, [ %g2 + 0xc ]
p2->avl.left = p1;
p->avl.left = p2->avl.right;
200d1f0: f8 01 20 0c ld [ %g4 + 0xc ], %i4
p2->avl.right = p;
200d1f4: c2 21 20 0c st %g1, [ %g4 + 0xc ]
{
p2 = p1->avl.right;
p1->avl.right = p2->avl.left;
p2->avl.left = p1;
p->avl.left = p2->avl.right;
200d1f8: f8 20 60 08 st %i4, [ %g1 + 8 ]
p2->avl.right = p;
if (p2->avl.bal == -1) p->avl.bal = 1; else p->avl.bal = 0;
200d1fc: f8 49 20 11 ldsb [ %g4 + 0x11 ], %i4
200d200: 80 a7 3f ff cmp %i4, -1
200d204: 32 80 00 03 bne,a 200d210 <rtems_bdbuf_remove_from_tree+0x2e8>
200d208: c0 28 60 11 clrb [ %g1 + 0x11 ]
200d20c: fa 28 60 11 stb %i5, [ %g1 + 0x11 ]
if (p2->avl.bal == +1) p1->avl.bal = -1; else p1->avl.bal = 0;
200d210: c2 49 20 11 ldsb [ %g4 + 0x11 ], %g1
200d214: 80 a0 60 01 cmp %g1, 1
200d218: 32 80 00 03 bne,a 200d224 <rtems_bdbuf_remove_from_tree+0x2fc>
200d21c: c0 28 a0 11 clrb [ %g2 + 0x11 ]
200d220: f6 28 a0 11 stb %i3, [ %g2 + 0x11 ]
p = p2;
p2->avl.bal = 0;
200d224: c0 29 20 11 clrb [ %g4 + 0x11 ]
200d228: 82 10 00 04 mov %g4, %g1
}
}
else
{
/* rebalance right branch */
switch (p->avl.bal)
200d22c: 84 10 20 01 mov 1, %g2
{
return bdbuf_cache.buffer_waiters.count;
}
static void
rtems_bdbuf_remove_from_tree (rtems_bdbuf_buffer *bd)
200d230: 88 00 ff fc add %g3, -4, %g4
default:
break;
}
}
if (buf_prev > buf_stack)
200d234: 80 a1 00 19 cmp %g4, %i1
200d238: 28 80 00 09 bleu,a 200d25c <rtems_bdbuf_remove_from_tree+0x334>
200d23c: 05 00 80 86 sethi %hi(0x2021800), %g2
{
q = *(buf_prev - 1);
200d240: c8 00 ff f8 ld [ %g3 + -8 ], %g4
if (q->avl.cache == -1)
200d244: f8 49 20 10 ldsb [ %g4 + 0x10 ], %i4
200d248: 80 a7 3f ff cmp %i4, -1
200d24c: 32 80 00 07 bne,a 200d268 <rtems_bdbuf_remove_from_tree+0x340>
200d250: c2 21 20 0c st %g1, [ %g4 + 0xc ]
{
q->avl.left = p;
200d254: 10 80 00 05 b 200d268 <rtems_bdbuf_remove_from_tree+0x340>
200d258: c2 21 20 08 st %g1, [ %g4 + 8 ]
q->avl.right = p;
}
}
else
{
*root = p;
200d25c: c2 20 a0 b8 st %g1, [ %g2 + 0xb8 ]
200d260: 81 c7 e0 08 ret
200d264: 81 e8 00 00 restore
*root = q;
}
modified = true;
while (modified)
200d268: 80 88 a0 ff btst 0xff, %g2
200d26c: 12 bf ff 95 bne 200d0c0 <rtems_bdbuf_remove_from_tree+0x198>
200d270: 86 00 ff fc add %g3, -4, %g3
200d274: 81 c7 e0 08 ret
200d278: 81 e8 00 00 restore
}
q = p;
buf_prev--;
if (buf_prev > buf_stack)
200d27c: 80 a0 c0 01 cmp %g3, %g1
200d280: 08 bf ff 51 bleu 200cfc4 <rtems_bdbuf_remove_from_tree+0x9c>
200d284: b8 10 20 00 clr %i4
{
p = *(buf_prev - 1);
200d288: 10 bf ff 4f b 200cfc4 <rtems_bdbuf_remove_from_tree+0x9c>
200d28c: f8 01 3f f8 ld [ %g4 + -8 ], %i4
0200d390 <rtems_bdbuf_remove_from_tree_and_lru_list>:
rtems_bdbuf_fatal (bd->state, RTEMS_BLKDEV_FATAL_BDBUF_TREE_RM);
}
static void
rtems_bdbuf_remove_from_tree_and_lru_list (rtems_bdbuf_buffer *bd)
{
200d390: 9d e3 bf a0 save %sp, -96, %sp
switch (bd->state)
200d394: d0 06 20 20 ld [ %i0 + 0x20 ], %o0
200d398: 80 a2 20 00 cmp %o0, 0
200d39c: 22 80 00 0b be,a 200d3c8 <rtems_bdbuf_remove_from_tree_and_lru_list+0x38>
200d3a0: c4 06 00 00 ld [ %i0 ], %g2
200d3a4: 80 a2 20 02 cmp %o0, 2
200d3a8: 12 80 00 06 bne 200d3c0 <rtems_bdbuf_remove_from_tree_and_lru_list+0x30><== NEVER TAKEN
200d3ac: 13 10 80 00 sethi %hi(0x42000000), %o1
{
case RTEMS_BDBUF_STATE_FREE:
break;
case RTEMS_BDBUF_STATE_CACHED:
rtems_bdbuf_remove_from_tree (bd);
200d3b0: 7f ff fe de call 200cf28 <rtems_bdbuf_remove_from_tree>
200d3b4: 90 10 00 18 mov %i0, %o0
break;
200d3b8: 10 80 00 04 b 200d3c8 <rtems_bdbuf_remove_from_tree_and_lru_list+0x38>
200d3bc: c4 06 00 00 ld [ %i0 ], %g2
default:
rtems_bdbuf_fatal (bd->state, RTEMS_BLKDEV_FATAL_BDBUF_STATE_10);
200d3c0: 7f ff fe 05 call 200cbd4 <rtems_bdbuf_fatal> <== NOT EXECUTED
200d3c4: 92 12 60 08 or %o1, 8, %o1 <== NOT EXECUTED
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
previous = the_node->previous;
200d3c8: c2 06 20 04 ld [ %i0 + 4 ], %g1
next->previous = previous;
200d3cc: c2 20 a0 04 st %g1, [ %g2 + 4 ]
previous->next = next;
200d3d0: c4 20 40 00 st %g2, [ %g1 ]
200d3d4: 81 c7 e0 08 ret
200d3d8: 81 e8 00 00 restore
0200f150 <rtems_bdbuf_reset_device_stats>:
}
void rtems_bdbuf_reset_device_stats (rtems_disk_device *dd)
{
200f150: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED
rtems_bdbuf_lock_cache ();
200f154: 7f ff f6 99 call 200cbb8 <rtems_bdbuf_lock_cache> <== NOT EXECUTED
200f158: 01 00 00 00 nop <== NOT EXECUTED
memset (&dd->stats, 0, sizeof(dd->stats));
200f15c: 90 06 20 44 add %i0, 0x44, %o0 <== NOT EXECUTED
200f160: 92 10 20 00 clr %o1 <== NOT EXECUTED
200f164: 40 00 15 10 call 20145a4 <memset> <== NOT EXECUTED
200f168: 94 10 20 20 mov 0x20, %o2 <== NOT EXECUTED
rtems_bdbuf_unlock_cache ();
200f16c: 7f ff f6 a9 call 200cc10 <rtems_bdbuf_unlock_cache> <== NOT EXECUTED
200f170: 81 e8 00 00 restore <== NOT EXECUTED
0200ccf4 <rtems_bdbuf_restore_preemption>:
static void
rtems_bdbuf_restore_preemption (rtems_mode prev_mode)
{
200ccf4: 9d e3 bf a0 save %sp, -96, %sp
rtems_status_code sc = RTEMS_SUCCESSFUL;
sc = rtems_task_mode (prev_mode, RTEMS_ALL_MODE_MASKS, &prev_mode);
200ccf8: 13 00 00 3f sethi %hi(0xfc00), %o1
return prev_mode;
}
static void
rtems_bdbuf_restore_preemption (rtems_mode prev_mode)
{
200ccfc: f0 27 a0 44 st %i0, [ %fp + 0x44 ]
rtems_status_code sc = RTEMS_SUCCESSFUL;
sc = rtems_task_mode (prev_mode, RTEMS_ALL_MODE_MASKS, &prev_mode);
200cd00: 90 10 00 18 mov %i0, %o0
200cd04: 92 12 63 ff or %o1, 0x3ff, %o1
200cd08: 40 00 11 35 call 20111dc <rtems_task_mode>
200cd0c: 94 07 a0 44 add %fp, 0x44, %o2
if (sc != RTEMS_SUCCESSFUL)
200cd10: 80 a2 20 00 cmp %o0, 0
200cd14: 02 80 00 04 be 200cd24 <rtems_bdbuf_restore_preemption+0x30><== ALWAYS TAKEN
200cd18: 11 10 80 00 sethi %hi(0x42000000), %o0
rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_PREEMPT_RST);
200cd1c: 7f ff f1 9f call 2009398 <rtems_fatal_error_occurred> <== NOT EXECUTED
200cd20: 90 12 20 11 or %o0, 0x11, %o0 ! 42000011 <RAM_END+0x3fc00011><== NOT EXECUTED
200cd24: 81 c7 e0 08 ret
200cd28: 81 e8 00 00 restore
0200f040 <rtems_bdbuf_set_block_size>:
}
rtems_status_code
rtems_bdbuf_set_block_size (rtems_disk_device *dd, uint32_t block_size)
{
200f040: 9d e3 bf a0 save %sp, -96, %sp
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_bdbuf_lock_cache ();
200f044: 7f ff f6 dd call 200cbb8 <rtems_bdbuf_lock_cache>
200f048: ba 10 00 18 mov %i0, %i5
if (block_size > 0)
200f04c: 80 a6 60 00 cmp %i1, 0
200f050: 02 80 00 33 be 200f11c <rtems_bdbuf_set_block_size+0xdc>
200f054: b0 10 20 0a mov 0xa, %i0
rtems_bdbuf_bds_per_group (size_t size)
{
size_t bufs_per_size;
size_t bds_per_size;
if (size > bdbuf_config.buffer_max)
200f058: 03 00 80 7b sethi %hi(0x201ec00), %g1
200f05c: 82 10 61 40 or %g1, 0x140, %g1 ! 201ed40 <rtems_bdbuf_configuration>
200f060: c4 00 60 28 ld [ %g1 + 0x28 ], %g2
200f064: 80 a6 40 02 cmp %i1, %g2
200f068: 18 80 00 2d bgu 200f11c <rtems_bdbuf_set_block_size+0xdc> <== NEVER TAKEN
200f06c: 01 00 00 00 nop
return 0;
bufs_per_size = ((size - 1) / bdbuf_config.buffer_min) + 1;
200f070: d2 00 60 24 ld [ %g1 + 0x24 ], %o1
200f074: 40 00 36 2e call 201c92c <.udiv>
200f078: 90 06 7f ff add %i1, -1, %o0
for (bds_per_size = 1;
200f07c: 92 10 20 01 mov 1, %o1
200f080: 90 02 20 01 inc %o0
200f084: 80 a2 40 08 cmp %o1, %o0
200f088: 2a bf ff ff bcs,a 200f084 <rtems_bdbuf_set_block_size+0x44>
200f08c: 93 2a 60 01 sll %o1, 1, %o1
bds_per_size < bufs_per_size;
bds_per_size <<= 1)
;
return bdbuf_cache.max_bds_per_group / bds_per_size;
200f090: 03 00 80 86 sethi %hi(0x2021800), %g1
200f094: d0 00 60 9c ld [ %g1 + 0x9c ], %o0 ! 202189c <bdbuf_cache+0x20>
200f098: 40 00 36 25 call 201c92c <.udiv>
200f09c: b0 10 20 0a mov 0xa, %i0
if (block_size > 0)
{
size_t bds_per_group = rtems_bdbuf_bds_per_group (block_size);
if (bds_per_group != 0)
200f0a0: 80 a2 20 00 cmp %o0, 0
200f0a4: 02 80 00 1e be 200f11c <rtems_bdbuf_set_block_size+0xdc> <== NEVER TAKEN
200f0a8: b4 10 00 08 mov %o0, %i2
{
int block_to_media_block_shift = 0;
uint32_t media_blocks_per_block = block_size / dd->media_block_size;
200f0ac: f0 07 60 20 ld [ %i5 + 0x20 ], %i0
200f0b0: 90 10 00 19 mov %i1, %o0
200f0b4: 40 00 36 1e call 201c92c <.udiv>
200f0b8: 92 10 00 18 mov %i0, %o1
{
size_t bds_per_group = rtems_bdbuf_bds_per_group (block_size);
if (bds_per_group != 0)
{
int block_to_media_block_shift = 0;
200f0bc: b8 10 20 00 clr %i4
uint32_t media_blocks_per_block = block_size / dd->media_block_size;
200f0c0: b6 10 00 08 mov %o0, %i3
200f0c4: 84 10 20 01 mov 1, %g2
uint32_t one = 1;
while ((one << block_to_media_block_shift) < media_blocks_per_block)
200f0c8: 83 28 80 1c sll %g2, %i4, %g1
200f0cc: 80 a0 40 1b cmp %g1, %i3
200f0d0: 2a bf ff fe bcs,a 200f0c8 <rtems_bdbuf_set_block_size+0x88>
200f0d4: b8 07 20 01 inc %i4
{
++block_to_media_block_shift;
}
if ((dd->media_block_size << block_to_media_block_shift) != block_size)
200f0d8: b1 2e 00 1c sll %i0, %i4, %i0
200f0dc: 80 a6 00 19 cmp %i0, %i1
200f0e0: 32 80 00 02 bne,a 200f0e8 <rtems_bdbuf_set_block_size+0xa8><== NEVER TAKEN
200f0e4: b8 10 3f ff mov -1, %i4 <== NOT EXECUTED
block_to_media_block_shift = -1;
dd->block_size = block_size;
dd->block_count = dd->size / media_blocks_per_block;
200f0e8: d0 07 60 1c ld [ %i5 + 0x1c ], %o0
200f0ec: 92 10 00 1b mov %i3, %o1
200f0f0: 40 00 36 0f call 201c92c <.udiv>
200f0f4: f2 27 60 24 st %i1, [ %i5 + 0x24 ]
dd->media_blocks_per_block = media_blocks_per_block;
200f0f8: f6 27 60 2c st %i3, [ %i5 + 0x2c ]
if ((dd->media_block_size << block_to_media_block_shift) != block_size)
block_to_media_block_shift = -1;
dd->block_size = block_size;
dd->block_count = dd->size / media_blocks_per_block;
200f0fc: d0 27 60 28 st %o0, [ %i5 + 0x28 ]
dd->media_blocks_per_block = media_blocks_per_block;
dd->block_to_media_block_shift = block_to_media_block_shift;
200f100: f8 27 60 30 st %i4, [ %i5 + 0x30 ]
dd->bds_per_group = bds_per_group;
200f104: f4 27 60 34 st %i2, [ %i5 + 0x34 ]
}
static void
rtems_bdbuf_read_ahead_reset (rtems_disk_device *dd)
{
rtems_bdbuf_read_ahead_cancel (dd);
200f108: 7f ff fc be call 200e400 <rtems_bdbuf_read_ahead_cancel>
200f10c: 90 10 00 1d mov %i5, %o0
dd->read_ahead.trigger = RTEMS_DISK_READ_AHEAD_NO_TRIGGER;
200f110: 82 10 3f ff mov -1, %g1
}
rtems_status_code
rtems_bdbuf_set_block_size (rtems_disk_device *dd, uint32_t block_size)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
200f114: b0 10 20 00 clr %i0
static void
rtems_bdbuf_read_ahead_reset (rtems_disk_device *dd)
{
rtems_bdbuf_read_ahead_cancel (dd);
dd->read_ahead.trigger = RTEMS_DISK_READ_AHEAD_NO_TRIGGER;
200f118: c2 27 60 6c st %g1, [ %i5 + 0x6c ]
else
{
sc = RTEMS_INVALID_NUMBER;
}
rtems_bdbuf_unlock_cache ();
200f11c: 7f ff f6 bd call 200cc10 <rtems_bdbuf_unlock_cache>
200f120: 01 00 00 00 nop
return sc;
}
200f124: 81 c7 e0 08 ret
200f128: 81 e8 00 00 restore
0200d9b0 <rtems_bdbuf_swapout_modified_processing>:
rtems_chain_control* chain,
rtems_chain_control* transfer,
bool sync_active,
bool update_timers,
uint32_t timer_delta)
{
200d9b0: 9d e3 bf a0 save %sp, -96, %sp
*/
RTEMS_INLINE_ROUTINE const Chain_Node *_Chain_Immutable_first(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_head( the_chain )->next;
200d9b4: c2 06 40 00 ld [ %i1 ], %g1
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
200d9b8: b2 06 60 04 add %i1, 4, %i1
if (!rtems_chain_is_empty (chain))
200d9bc: 80 a0 40 19 cmp %g1, %i1
200d9c0: 02 80 00 4e be 200daf8 <rtems_bdbuf_swapout_modified_processing+0x148>
200d9c4: 80 a6 e0 00 cmp %i3, 0
node = node->next;
/*
* A sync active with no valid dev means sync all.
*/
if (sync_active && (*dd_ptr == BDBUF_INVALID_DEV))
200d9c8: 02 80 00 05 be 200d9dc <rtems_bdbuf_swapout_modified_processing+0x2c>
200d9cc: 84 10 20 00 clr %g2
200d9d0: c4 06 00 00 ld [ %i0 ], %g2
200d9d4: 80 a0 00 02 cmp %g0, %g2
200d9d8: 84 60 3f ff subx %g0, -1, %g2
}
static bool
rtems_bdbuf_has_buffer_waiters (void)
{
return bdbuf_cache.buffer_waiters.count;
200d9dc: 07 00 80 86 sethi %hi(0x2021800), %g3
200d9e0: de 00 e0 f0 ld [ %g3 + 0xf0 ], %o7 ! 20218f0 <bdbuf_cache+0x74>
* 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 && (*dd_ptr == bd->dd))
200d9e4: 9a 08 a0 ff and %g2, 0xff, %o5
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
200d9e8: 98 10 20 09 mov 9, %o4
* 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 && (*dd_ptr == bd->dd))
200d9ec: 80 a3 60 00 cmp %o5, 0
200d9f0: 32 80 00 0d bne,a 200da24 <rtems_bdbuf_swapout_modified_processing+0x74>
200d9f4: c0 20 60 2c clr [ %g1 + 0x2c ]
200d9f8: 80 a6 e0 00 cmp %i3, 0
200d9fc: 02 80 00 07 be 200da18 <rtems_bdbuf_swapout_modified_processing+0x68>
200da00: 80 a3 e0 00 cmp %o7, 0
200da04: c6 06 00 00 ld [ %i0 ], %g3
200da08: c4 00 60 14 ld [ %g1 + 0x14 ], %g2
200da0c: 80 a0 c0 02 cmp %g3, %g2
200da10: 02 80 00 04 be 200da20 <rtems_bdbuf_swapout_modified_processing+0x70>
200da14: 80 a3 e0 00 cmp %o7, 0
|| rtems_bdbuf_has_buffer_waiters ())
200da18: 22 80 00 04 be,a 200da28 <rtems_bdbuf_swapout_modified_processing+0x78>
200da1c: c4 00 60 2c ld [ %g1 + 0x2c ], %g2
bd->hold_timer = 0;
200da20: c0 20 60 2c clr [ %g1 + 0x2c ]
if (bd->hold_timer)
200da24: c4 00 60 2c ld [ %g1 + 0x2c ], %g2
200da28: 80 a0 a0 00 cmp %g2, 0
200da2c: 22 80 00 10 be,a 200da6c <rtems_bdbuf_swapout_modified_processing+0xbc>
200da30: c4 06 00 00 ld [ %i0 ], %g2
{
if (update_timers)
200da34: 80 a7 20 00 cmp %i4, 0
200da38: 22 80 00 08 be,a 200da58 <rtems_bdbuf_swapout_modified_processing+0xa8>
200da3c: c4 00 60 2c ld [ %g1 + 0x2c ], %g2
{
if (bd->hold_timer > timer_delta)
200da40: 80 a0 80 1d cmp %g2, %i5
200da44: 28 80 00 04 bleu,a 200da54 <rtems_bdbuf_swapout_modified_processing+0xa4>
200da48: c0 20 60 2c clr [ %g1 + 0x2c ]
bd->hold_timer -= timer_delta;
200da4c: 84 20 80 1d sub %g2, %i5, %g2
200da50: c4 20 60 2c st %g2, [ %g1 + 0x2c ]
else
bd->hold_timer = 0;
}
if (bd->hold_timer)
200da54: c4 00 60 2c ld [ %g1 + 0x2c ], %g2
200da58: 80 a0 a0 00 cmp %g2, 0
200da5c: 22 80 00 04 be,a 200da6c <rtems_bdbuf_swapout_modified_processing+0xbc>
200da60: c4 06 00 00 ld [ %i0 ], %g2
{
node = node->next;
continue;
200da64: 10 80 00 22 b 200daec <rtems_bdbuf_swapout_modified_processing+0x13c>
200da68: c2 00 40 00 ld [ %g1 ], %g1
/*
* This assumes we can set it 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 (*dd_ptr == BDBUF_INVALID_DEV)
200da6c: 80 a0 a0 00 cmp %g2, 0
200da70: 32 80 00 05 bne,a 200da84 <rtems_bdbuf_swapout_modified_processing+0xd4>
200da74: c6 00 60 14 ld [ %g1 + 0x14 ], %g3
*dd_ptr = bd->dd;
200da78: c4 00 60 14 ld [ %g1 + 0x14 ], %g2
200da7c: c4 26 00 00 st %g2, [ %i0 ]
if (bd->dd == *dd_ptr)
200da80: c6 00 60 14 ld [ %g1 + 0x14 ], %g3
200da84: c4 06 00 00 ld [ %i0 ], %g2
200da88: 80 a0 c0 02 cmp %g3, %g2
200da8c: 12 80 00 17 bne 200dae8 <rtems_bdbuf_swapout_modified_processing+0x138><== NEVER TAKEN
200da90: c6 00 40 00 ld [ %g1 ], %g3
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
previous = the_node->previous;
200da94: c4 00 60 04 ld [ %g1 + 4 ], %g2
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
200da98: d8 20 60 20 st %o4, [ %g1 + 0x20 ]
next->previous = previous;
200da9c: c4 20 e0 04 st %g2, [ %g3 + 4 ]
previous->next = next;
200daa0: c6 20 80 00 st %g3, [ %g2 ]
rtems_bdbuf_set_state (bd, RTEMS_BDBUF_STATE_TRANSFER);
rtems_chain_extract_unprotected (node);
tnode = tnode->previous;
200daa4: 10 80 00 0c b 200dad4 <rtems_bdbuf_swapout_modified_processing+0x124>
200daa8: c4 06 a0 08 ld [ %i2 + 8 ], %g2
while (node && !rtems_chain_is_head (transfer, tnode))
{
rtems_bdbuf_buffer* tbd = (rtems_bdbuf_buffer*) tnode;
if (bd->block > tbd->block)
200daac: c8 00 a0 18 ld [ %g2 + 0x18 ], %g4
200dab0: 80 a2 c0 04 cmp %o3, %g4
200dab4: 28 80 00 08 bleu,a 200dad4 <rtems_bdbuf_swapout_modified_processing+0x124>
200dab8: c4 00 a0 04 ld [ %g2 + 4 ], %g2
)
{
Chain_Node *before_node;
the_node->previous = after_node;
before_node = after_node->next;
200dabc: c8 00 80 00 ld [ %g2 ], %g4
Chain_Node *the_node
)
{
Chain_Node *before_node;
the_node->previous = after_node;
200dac0: c4 20 60 04 st %g2, [ %g1 + 4 ]
before_node = after_node->next;
after_node->next = the_node;
200dac4: c2 20 80 00 st %g1, [ %g2 ]
the_node->next = before_node;
200dac8: c8 20 40 00 st %g4, [ %g1 ]
before_node->previous = the_node;
200dacc: 10 80 00 07 b 200dae8 <rtems_bdbuf_swapout_modified_processing+0x138>
200dad0: c2 21 20 04 st %g1, [ %g4 + 4 ]
rtems_chain_extract_unprotected (node);
tnode = tnode->previous;
while (node && !rtems_chain_is_head (transfer, tnode))
200dad4: 80 a0 80 1a cmp %g2, %i2
200dad8: 32 bf ff f5 bne,a 200daac <rtems_bdbuf_swapout_modified_processing+0xfc>
200dadc: d6 00 60 18 ld [ %g1 + 0x18 ], %o3
)
{
Chain_Node *before_node;
the_node->previous = after_node;
before_node = after_node->next;
200dae0: 10 80 00 08 b 200db00 <rtems_bdbuf_swapout_modified_processing+0x150>
200dae4: c4 06 80 00 ld [ %i2 ], %g2
node = next_node;
}
else
{
node = node->next;
200dae8: 82 10 00 03 mov %g3, %g1
if (sync_active && (*dd_ptr == BDBUF_INVALID_DEV))
sync_all = true;
else
sync_all = false;
while (!rtems_chain_is_tail (chain, node))
200daec: 80 a0 40 19 cmp %g1, %i1
200daf0: 12 bf ff c0 bne 200d9f0 <rtems_bdbuf_swapout_modified_processing+0x40>
200daf4: 80 a3 60 00 cmp %o5, 0
200daf8: 81 c7 e0 08 ret
200dafc: 81 e8 00 00 restore
Chain_Node *the_node
)
{
Chain_Node *before_node;
the_node->previous = after_node;
200db00: f4 20 60 04 st %i2, [ %g1 + 4 ]
before_node = after_node->next;
after_node->next = the_node;
200db04: c2 26 80 00 st %g1, [ %i2 ]
the_node->next = before_node;
200db08: c4 20 40 00 st %g2, [ %g1 ]
before_node->previous = the_node;
200db0c: 10 bf ff f7 b 200dae8 <rtems_bdbuf_swapout_modified_processing+0x138>
200db10: c2 20 a0 04 st %g1, [ %g2 + 4 ]
0200de38 <rtems_bdbuf_swapout_task>:
* not this.
* @return rtems_task Not used.
*/
static rtems_task
rtems_bdbuf_swapout_task (rtems_task_argument arg)
{
200de38: 9d e3 bf 80 save %sp, -128, %sp
rtems_bdbuf_swapout_transfer transfer;
uint32_t period_in_ticks;
const uint32_t period_in_msecs = bdbuf_config.swapout_period;
200de3c: 33 00 80 7b sethi %hi(0x201ec00), %i1
200de40: b2 16 61 40 or %i1, 0x140, %i1 ! 201ed40 <rtems_bdbuf_configuration>
uint32_t timer_delta;
transfer.write_req = rtems_bdbuf_swapout_writereq_alloc ();
200de44: 7f ff fb e6 call 200cddc <rtems_bdbuf_swapout_writereq_alloc>
200de48: f6 06 60 0c ld [ %i1 + 0xc ], %i3
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
200de4c: 82 07 bf ec add %fp, -20, %g1
200de50: c2 27 bf e8 st %g1, [ %fp + -24 ]
head->previous = NULL;
tail->previous = head;
200de54: 82 07 bf e8 add %fp, -24, %g1
200de58: c2 27 bf f0 st %g1, [ %fp + -16 ]
transfer.syncing = false;
/*
* Localise the period.
*/
period_in_ticks = RTEMS_MICROSECONDS_TO_TICKS (period_in_msecs * 1000);
200de5c: 83 2e e0 02 sll %i3, 2, %g1
rtems_bdbuf_swapout_transfer transfer;
uint32_t period_in_ticks;
const uint32_t period_in_msecs = bdbuf_config.swapout_period;
uint32_t timer_delta;
transfer.write_req = rtems_bdbuf_swapout_writereq_alloc ();
200de60: d0 27 bf fc st %o0, [ %fp + -4 ]
transfer.syncing = false;
/*
* Localise the period.
*/
period_in_ticks = RTEMS_MICROSECONDS_TO_TICKS (period_in_msecs * 1000);
200de64: 91 2e e0 07 sll %i3, 7, %o0
200de68: 90 22 00 01 sub %o0, %g1, %o0
200de6c: 03 00 80 83 sethi %hi(0x2020c00), %g1
200de70: d2 00 62 9c ld [ %g1 + 0x29c ], %o1 ! 2020e9c <Configuration+0x10>
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
head->previous = NULL;
200de74: c0 27 bf ec clr [ %fp + -20 ]
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.dd = BDBUF_INVALID_DEV;
200de78: c0 27 bf f4 clr [ %fp + -12 ]
transfer.syncing = false;
200de7c: c0 2f bf f8 clrb [ %fp + -8 ]
/*
* Localise the period.
*/
period_in_ticks = RTEMS_MICROSECONDS_TO_TICKS (period_in_msecs * 1000);
200de80: 90 02 00 1b add %o0, %i3, %o0
200de84: 40 00 3a aa call 201c92c <.udiv>
200de88: 91 2a 20 03 sll %o0, 3, %o0
Chain_Control *the_chain,
Chain_Node *the_node
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
200de8c: 35 00 80 86 sethi %hi(0x2021800), %i2
200de90: a0 10 00 08 mov %o0, %l0
rtems_bdbuf_swapout_workers_open (void)
{
rtems_status_code sc;
size_t w;
rtems_bdbuf_lock_cache ();
200de94: 7f ff fb 49 call 200cbb8 <rtems_bdbuf_lock_cache>
200de98: b4 16 a0 7c or %i2, 0x7c, %i2
worker->transfer.write_req = rtems_bdbuf_swapout_writereq_alloc ();
rtems_chain_initialize_empty (&worker->transfer.bds);
worker->transfer.dd = BDBUF_INVALID_DEV;
sc = rtems_bdbuf_create_task (rtems_build_name('B', 'D', 'o', 'a' + w),
200de9c: 27 10 91 1b sethi %hi(0x42446c00), %l3
200dea0: 29 00 80 38 sethi %hi(0x200e000), %l4
rtems_status_code sc;
size_t w;
rtems_bdbuf_lock_cache ();
for (w = 0; w < bdbuf_config.swapout_workers; w++)
200dea4: b8 10 20 00 clr %i4
200dea8: f0 06 60 14 ld [ %i1 + 0x14 ], %i0
the_node->next = tail;
200deac: a2 06 a0 0c add %i2, 0xc, %l1
worker = malloc (sizeof (rtems_bdbuf_swapout_worker));
if (!worker)
rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_SO_NOMEM);
rtems_chain_append_unprotected (&bdbuf_cache.swapout_workers, &worker->link);
worker->enabled = true;
200deb0: a4 10 20 01 mov 1, %l2
worker->transfer.write_req = rtems_bdbuf_swapout_writereq_alloc ();
rtems_chain_initialize_empty (&worker->transfer.bds);
worker->transfer.dd = BDBUF_INVALID_DEV;
sc = rtems_bdbuf_create_task (rtems_build_name('B', 'D', 'o', 'a' + w),
200deb4: a6 14 e3 00 or %l3, 0x300, %l3
200deb8: 10 80 00 25 b 200df4c <rtems_bdbuf_swapout_task+0x114>
200debc: a8 15 21 70 or %l4, 0x170, %l4
for (w = 0; w < bdbuf_config.swapout_workers; w++)
{
rtems_bdbuf_swapout_worker* worker;
worker = malloc (sizeof (rtems_bdbuf_swapout_worker));
200dec0: 7f ff dc 38 call 2004fa0 <malloc> <== NOT EXECUTED
200dec4: 90 10 20 28 mov 0x28, %o0 <== NOT EXECUTED
if (!worker)
200dec8: ba 92 20 00 orcc %o0, 0, %i5 <== NOT EXECUTED
200decc: 32 80 00 05 bne,a 200dee0 <rtems_bdbuf_swapout_task+0xa8><== NOT EXECUTED
200ded0: c2 06 a0 10 ld [ %i2 + 0x10 ], %g1 <== NOT EXECUTED
rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_SO_NOMEM);
200ded4: 11 10 80 00 sethi %hi(0x42000000), %o0 <== NOT EXECUTED
200ded8: 10 80 00 1b b 200df44 <rtems_bdbuf_swapout_task+0x10c> <== NOT EXECUTED
200dedc: 90 12 20 15 or %o0, 0x15, %o0 ! 42000015 <RAM_END+0x3fc00015><== NOT EXECUTED
200dee0: e2 27 40 00 st %l1, [ %i5 ] <== NOT EXECUTED
tail->previous = the_node;
old_last->next = the_node;
200dee4: fa 20 40 00 st %i5, [ %g1 ] <== NOT EXECUTED
the_node->previous = old_last;
200dee8: c2 27 60 04 st %g1, [ %i5 + 4 ] <== NOT EXECUTED
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
the_node->next = tail;
tail->previous = the_node;
200deec: fa 26 a0 10 st %i5, [ %i2 + 0x10 ] <== NOT EXECUTED
rtems_chain_append_unprotected (&bdbuf_cache.swapout_workers, &worker->link);
worker->enabled = true;
worker->transfer.write_req = rtems_bdbuf_swapout_writereq_alloc ();
200def0: 7f ff fb bb call 200cddc <rtems_bdbuf_swapout_writereq_alloc><== NOT EXECUTED
200def4: e4 2f 60 0c stb %l2, [ %i5 + 0xc ] <== NOT EXECUTED
rtems_chain_initialize_empty (&worker->transfer.bds);
worker->transfer.dd = BDBUF_INVALID_DEV;
sc = rtems_bdbuf_create_task (rtems_build_name('B', 'D', 'o', 'a' + w),
200def8: d2 06 60 18 ld [ %i1 + 0x18 ], %o1 <== 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 );
200defc: 82 07 60 10 add %i5, 0x10, %g1 <== NOT EXECUTED
200df00: 84 07 60 14 add %i5, 0x14, %g2 <== NOT EXECUTED
if (!worker)
rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_SO_NOMEM);
rtems_chain_append_unprotected (&bdbuf_cache.swapout_workers, &worker->link);
worker->enabled = true;
worker->transfer.write_req = rtems_bdbuf_swapout_writereq_alloc ();
200df04: d0 27 60 24 st %o0, [ %i5 + 0x24 ] <== NOT EXECUTED
head->next = tail;
200df08: c4 27 60 10 st %g2, [ %i5 + 0x10 ] <== NOT EXECUTED
head->previous = NULL;
200df0c: c0 27 60 14 clr [ %i5 + 0x14 ] <== NOT EXECUTED
tail->previous = head;
200df10: c2 27 60 18 st %g1, [ %i5 + 0x18 ] <== NOT EXECUTED
rtems_chain_initialize_empty (&worker->transfer.bds);
worker->transfer.dd = BDBUF_INVALID_DEV;
200df14: c0 27 60 1c clr [ %i5 + 0x1c ] <== NOT EXECUTED
* @param arg A pointer to the global cache data. Use the global variable and
* not this.
* @return rtems_task Not used.
*/
static rtems_task
rtems_bdbuf_swapout_task (rtems_task_argument arg)
200df18: 90 07 20 61 add %i4, 0x61, %o0 <== NOT EXECUTED
worker->transfer.write_req = rtems_bdbuf_swapout_writereq_alloc ();
rtems_chain_initialize_empty (&worker->transfer.bds);
worker->transfer.dd = BDBUF_INVALID_DEV;
sc = rtems_bdbuf_create_task (rtems_build_name('B', 'D', 'o', 'a' + w),
200df1c: 94 10 00 14 mov %l4, %o2 <== NOT EXECUTED
200df20: 90 12 00 13 or %o0, %l3, %o0 <== NOT EXECUTED
200df24: 96 10 00 1d mov %i5, %o3 <== NOT EXECUTED
200df28: 7f ff fb e9 call 200cecc <rtems_bdbuf_create_task.constprop.10><== NOT EXECUTED
200df2c: 98 07 60 08 add %i5, 8, %o4 <== NOT EXECUTED
bdbuf_config.swapout_worker_priority,
RTEMS_BDBUF_SWAPOUT_WORKER_TASK_PRIORITY_DEFAULT,
rtems_bdbuf_swapout_worker_task,
(rtems_task_argument) worker,
&worker->id);
if (sc != RTEMS_SUCCESSFUL)
200df30: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
200df34: 22 80 00 06 be,a 200df4c <rtems_bdbuf_swapout_task+0x114><== NOT EXECUTED
200df38: b8 07 20 01 inc %i4 <== NOT EXECUTED
rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_SO_WK_CREATE);
200df3c: 11 10 80 00 sethi %hi(0x42000000), %o0 <== NOT EXECUTED
200df40: 90 12 20 16 or %o0, 0x16, %o0 ! 42000016 <RAM_END+0x3fc00016><== NOT EXECUTED
200df44: 7f ff ed 15 call 2009398 <rtems_fatal_error_occurred> <== NOT EXECUTED
200df48: 01 00 00 00 nop <== NOT EXECUTED
rtems_status_code sc;
size_t w;
rtems_bdbuf_lock_cache ();
for (w = 0; w < bdbuf_config.swapout_workers; w++)
200df4c: 80 a7 00 18 cmp %i4, %i0
200df50: 0a bf ff dc bcs 200dec0 <rtems_bdbuf_swapout_task+0x88> <== NEVER TAKEN
200df54: 01 00 00 00 nop
&worker->id);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_SO_WK_CREATE);
}
rtems_bdbuf_unlock_cache ();
200df58: 7f ff fb 2e call 200cc10 <rtems_bdbuf_unlock_cache>
200df5c: 39 00 80 86 sethi %hi(0x2021800), %i4
/*
* Create the worker threads.
*/
rtems_bdbuf_swapout_workers_open ();
while (bdbuf_cache.swapout_enabled)
200df60: b8 17 20 7c or %i4, 0x7c, %i4 ! 202187c <bdbuf_cache>
200df64: a2 07 20 08 add %i4, 8, %l1
/*
* 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->dd,
200df68: a4 07 20 58 add %i4, 0x58, %l2
timer_delta);
/*
* Process the cache's modified list.
*/
rtems_bdbuf_swapout_modified_processing (&transfer->dd,
200df6c: 10 80 00 5d b 200e0e0 <rtems_bdbuf_swapout_task+0x2a8>
200df70: a6 07 20 4c add %i4, 0x4c, %l3
rtems_bdbuf_swapout_transfer* transfer)
{
rtems_bdbuf_swapout_worker* worker;
bool transfered_buffers = false;
rtems_bdbuf_lock_cache ();
200df74: 7f ff fb 11 call 200cbb8 <rtems_bdbuf_lock_cache>
200df78: 01 00 00 00 nop
* 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)
200df7c: c2 0f 20 30 ldub [ %i4 + 0x30 ], %g1
200df80: 80 a0 60 00 cmp %g1, 0
200df84: 02 80 00 04 be 200df94 <rtems_bdbuf_swapout_task+0x15c>
200df88: b4 10 20 00 clr %i2
/*
* 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,
200df8c: 10 80 00 08 b 200dfac <rtems_bdbuf_swapout_task+0x174>
200df90: ba 07 bf e8 add %fp, -24, %i5
200df94: 7f ff fa e9 call 200cb38 <_Chain_Get_unprotected>
200df98: 90 10 00 11 mov %l1, %o0
worker = NULL;
else
{
worker = (rtems_bdbuf_swapout_worker*)
rtems_chain_get_unprotected (&bdbuf_cache.swapout_workers);
if (worker)
200df9c: b4 92 20 00 orcc %o0, 0, %i2
200dfa0: 22 bf ff fb be,a 200df8c <rtems_bdbuf_swapout_task+0x154><== ALWAYS TAKEN
200dfa4: b4 10 20 00 clr %i2
transfer = &worker->transfer;
200dfa8: ba 06 a0 10 add %i2, 0x10, %i5 <== 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 );
200dfac: 82 07 60 04 add %i5, 4, %g1
head->next = tail;
200dfb0: c2 27 40 00 st %g1, [ %i5 ]
}
rtems_chain_initialize_empty (&transfer->bds);
transfer->dd = BDBUF_INVALID_DEV;
transfer->syncing = bdbuf_cache.sync_active;
200dfb4: c2 0f 20 30 ldub [ %i4 + 0x30 ], %g1
head->previous = NULL;
200dfb8: c0 27 60 04 clr [ %i5 + 4 ]
tail->previous = head;
200dfbc: fa 27 60 08 st %i5, [ %i5 + 8 ]
if (worker)
transfer = &worker->transfer;
}
rtems_chain_initialize_empty (&transfer->bds);
transfer->dd = BDBUF_INVALID_DEV;
200dfc0: c0 27 60 0c clr [ %i5 + 0xc ]
/*
* 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)
200dfc4: 80 88 60 ff btst 0xff, %g1
200dfc8: 02 80 00 04 be 200dfd8 <rtems_bdbuf_swapout_task+0x1a0>
200dfcc: c2 2f 60 10 stb %g1, [ %i5 + 0x10 ]
transfer->dd = bdbuf_cache.sync_device;
200dfd0: c2 07 20 38 ld [ %i4 + 0x38 ], %g1
200dfd4: c2 27 60 0c st %g1, [ %i5 + 0xc ]
/*
* 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->dd,
200dfd8: b0 07 60 0c add %i5, 0xc, %i0
200dfdc: 92 10 00 12 mov %l2, %o1
200dfe0: 90 10 00 18 mov %i0, %o0
200dfe4: 94 10 00 1d mov %i5, %o2
200dfe8: 96 10 20 01 mov 1, %o3
200dfec: 98 10 20 00 clr %o4
200dff0: 7f ff fe 70 call 200d9b0 <rtems_bdbuf_swapout_modified_processing>
200dff4: 9a 10 00 1b mov %i3, %o5
timer_delta);
/*
* Process the cache's modified list.
*/
rtems_bdbuf_swapout_modified_processing (&transfer->dd,
200dff8: d6 0f 20 30 ldub [ %i4 + 0x30 ], %o3
200dffc: 90 10 00 18 mov %i0, %o0
200e000: 92 10 00 13 mov %l3, %o1
200e004: 94 10 00 1d mov %i5, %o2
200e008: 98 0e 60 01 and %i1, 1, %o4
200e00c: 7f ff fe 69 call 200d9b0 <rtems_bdbuf_swapout_modified_processing>
200e010: 9a 10 00 1b mov %i3, %o5
/*
* 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 ();
200e014: 7f ff fa ff call 200cc10 <rtems_bdbuf_unlock_cache>
200e018: 01 00 00 00 nop
/*
* If there are buffers to transfer to the media transfer them.
*/
if (!rtems_chain_is_empty (&transfer->bds))
200e01c: c4 07 40 00 ld [ %i5 ], %g2
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
200e020: 82 07 60 04 add %i5, 4, %g1
200e024: 80 a0 80 01 cmp %g2, %g1
200e028: 02 80 00 11 be 200e06c <rtems_bdbuf_swapout_task+0x234>
200e02c: 80 a6 a0 00 cmp %i2, 0
{
if (worker)
200e030: 02 80 00 0b be 200e05c <rtems_bdbuf_swapout_task+0x224> <== ALWAYS TAKEN
200e034: 01 00 00 00 nop
{
rtems_status_code sc = rtems_event_send (worker->id,
200e038: d0 06 a0 08 ld [ %i2 + 8 ], %o0 <== NOT EXECUTED
200e03c: 7f ff e9 f3 call 2008808 <rtems_event_send> <== NOT EXECUTED
200e040: 92 10 20 04 mov 4, %o1 <== NOT EXECUTED
RTEMS_BDBUF_SWAPOUT_SYNC);
if (sc != RTEMS_SUCCESSFUL)
200e044: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
200e048: 02 80 00 0a be 200e070 <rtems_bdbuf_swapout_task+0x238> <== NOT EXECUTED
200e04c: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED
rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_SO_WAKE);
200e050: 11 10 80 00 sethi %hi(0x42000000), %o0 <== NOT EXECUTED
200e054: 10 bf ff bc b 200df44 <rtems_bdbuf_swapout_task+0x10c> <== NOT EXECUTED
200e058: 90 12 20 14 or %o0, 0x14, %o0 ! 42000014 <RAM_END+0x3fc00014><== NOT EXECUTED
}
else
{
rtems_bdbuf_swapout_write (transfer);
200e05c: 7f ff ff 1f call 200dcd8 <rtems_bdbuf_swapout_write>
200e060: 90 10 00 1d mov %i5, %o0
}
transfered_buffers = true;
200e064: 10 80 00 03 b 200e070 <rtems_bdbuf_swapout_task+0x238>
200e068: 82 10 20 01 mov 1, %g1
200e06c: 82 10 20 00 clr %g1
}
if (bdbuf_cache.sync_active && !transfered_buffers)
200e070: c4 0f 20 30 ldub [ %i4 + 0x30 ], %g2
200e074: b2 10 20 00 clr %i1
200e078: 80 a0 a0 00 cmp %g2, 0
200e07c: 02 80 00 13 be 200e0c8 <rtems_bdbuf_swapout_task+0x290>
200e080: 82 08 60 ff and %g1, 0xff, %g1
200e084: 80 a0 60 00 cmp %g1, 0
200e088: 12 bf ff bb bne 200df74 <rtems_bdbuf_swapout_task+0x13c>
200e08c: 01 00 00 00 nop
{
rtems_id sync_requester;
rtems_bdbuf_lock_cache ();
200e090: 7f ff fa ca call 200cbb8 <rtems_bdbuf_lock_cache>
200e094: 01 00 00 00 nop
sync_requester = bdbuf_cache.sync_requester;
200e098: fa 07 20 34 ld [ %i4 + 0x34 ], %i5
bdbuf_cache.sync_active = false;
200e09c: c0 2f 20 30 clrb [ %i4 + 0x30 ]
bdbuf_cache.sync_requester = 0;
rtems_bdbuf_unlock_cache ();
200e0a0: 7f ff fa dc call 200cc10 <rtems_bdbuf_unlock_cache>
200e0a4: c0 27 20 34 clr [ %i4 + 0x34 ]
if (sync_requester)
200e0a8: 80 a7 60 00 cmp %i5, 0
200e0ac: 22 80 00 25 be,a 200e140 <rtems_bdbuf_swapout_task+0x308><== NEVER TAKEN
200e0b0: 90 10 20 04 mov 4, %o0 <== NOT EXECUTED
rtems_event_send (sync_requester, RTEMS_BDBUF_TRANSFER_SYNC);
200e0b4: 90 10 00 1d mov %i5, %o0
200e0b8: 7f ff e9 d4 call 2008808 <rtems_event_send>
200e0bc: 92 10 20 02 mov 2, %o1
*/
update_timers = false;
}
while (transfered_buffers);
sc = rtems_event_receive (RTEMS_BDBUF_SWAPOUT_SYNC,
200e0c0: 10 80 00 20 b 200e140 <rtems_bdbuf_swapout_task+0x308>
200e0c4: 90 10 20 04 mov 4, %o0
/*
* 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,
200e0c8: 80 a0 60 00 cmp %g1, 0
200e0cc: 02 80 00 1d be 200e140 <rtems_bdbuf_swapout_task+0x308>
200e0d0: 90 10 20 04 mov 4, %o0
200e0d4: 30 bf ff a8 b,a 200df74 <rtems_bdbuf_swapout_task+0x13c>
RTEMS_EVENT_ALL | RTEMS_WAIT,
period_in_ticks,
&out);
if ((sc != RTEMS_SUCCESSFUL) && (sc != RTEMS_TIMEOUT))
rtems_fatal_error_occurred (BLKDEV_FATAL_BDBUF_SWAPOUT_RE);
200e0d8: 10 bf ff 9b b 200df44 <rtems_bdbuf_swapout_task+0x10c> <== NOT EXECUTED
200e0dc: 90 12 20 18 or %o0, 0x18, %o0 <== NOT EXECUTED
/*
* Create the worker threads.
*/
rtems_bdbuf_swapout_workers_open ();
while (bdbuf_cache.swapout_enabled)
200e0e0: c2 0f 20 04 ldub [ %i4 + 4 ], %g1
200e0e4: 80 a0 60 00 cmp %g1, 0
200e0e8: 12 bf ff a3 bne 200df74 <rtems_bdbuf_swapout_task+0x13c> <== ALWAYS TAKEN
200e0ec: b2 10 20 01 mov 1, %i1
static void
rtems_bdbuf_swapout_workers_close (void)
{
rtems_chain_node* node;
rtems_bdbuf_lock_cache ();
200e0f0: 7f ff fa b2 call 200cbb8 <rtems_bdbuf_lock_cache> <== NOT EXECUTED
200e0f4: 01 00 00 00 nop <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
200e0f8: fa 07 20 08 ld [ %i4 + 8 ], %i5 <== NOT EXECUTED
node = rtems_chain_first (&bdbuf_cache.swapout_workers);
while (!rtems_chain_is_tail (&bdbuf_cache.swapout_workers, node))
200e0fc: 10 80 00 06 b 200e114 <rtems_bdbuf_swapout_task+0x2dc> <== NOT EXECUTED
200e100: b8 07 20 0c add %i4, 0xc, %i4 <== NOT EXECUTED
{
rtems_bdbuf_swapout_worker* worker = (rtems_bdbuf_swapout_worker*) node;
worker->enabled = false;
200e104: c0 2f 60 0c clrb [ %i5 + 0xc ] <== NOT EXECUTED
rtems_event_send (worker->id, RTEMS_BDBUF_SWAPOUT_SYNC);
200e108: 7f ff e9 c0 call 2008808 <rtems_event_send> <== NOT EXECUTED
200e10c: 92 10 20 04 mov 4, %o1 <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Next(
Chain_Node *the_node
)
{
return the_node->next;
200e110: fa 07 40 00 ld [ %i5 ], %i5 <== 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))
200e114: 80 a7 40 1c cmp %i5, %i4 <== NOT EXECUTED
200e118: 32 bf ff fb bne,a 200e104 <rtems_bdbuf_swapout_task+0x2cc><== NOT EXECUTED
200e11c: d0 07 60 08 ld [ %i5 + 8 ], %o0 <== NOT EXECUTED
worker->enabled = false;
rtems_event_send (worker->id, RTEMS_BDBUF_SWAPOUT_SYNC);
node = rtems_chain_next (node);
}
rtems_bdbuf_unlock_cache ();
200e120: 7f ff fa bc call 200cc10 <rtems_bdbuf_unlock_cache> <== NOT EXECUTED
200e124: 01 00 00 00 nop <== NOT EXECUTED
rtems_fatal_error_occurred (BLKDEV_FATAL_BDBUF_SWAPOUT_RE);
}
rtems_bdbuf_swapout_workers_close ();
free (transfer.write_req);
200e128: 7f ff da 48 call 2004a48 <free> <== NOT EXECUTED
200e12c: d0 07 bf fc ld [ %fp + -4 ], %o0 <== NOT EXECUTED
rtems_task_delete (RTEMS_SELF);
200e130: 7f ff eb ae call 2008fe8 <rtems_task_delete> <== NOT EXECUTED
200e134: 90 10 20 00 clr %o0 <== NOT EXECUTED
200e138: 81 c7 e0 08 ret <== NOT EXECUTED
200e13c: 81 e8 00 00 restore <== NOT EXECUTED
*/
update_timers = false;
}
while (transfered_buffers);
sc = rtems_event_receive (RTEMS_BDBUF_SWAPOUT_SYNC,
200e140: 92 10 20 00 clr %o1
200e144: 94 10 00 10 mov %l0, %o2
200e148: 7f ff e9 4d call 200867c <rtems_event_receive>
200e14c: 96 07 bf e4 add %fp, -28, %o3
RTEMS_EVENT_ALL | RTEMS_WAIT,
period_in_ticks,
&out);
if ((sc != RTEMS_SUCCESSFUL) && (sc != RTEMS_TIMEOUT))
200e150: 80 a2 20 06 cmp %o0, 6
200e154: 22 bf ff e4 be,a 200e0e4 <rtems_bdbuf_swapout_task+0x2ac>
200e158: c2 0f 20 04 ldub [ %i4 + 4 ], %g1
200e15c: 80 a2 20 00 cmp %o0, 0
200e160: 22 bf ff e1 be,a 200e0e4 <rtems_bdbuf_swapout_task+0x2ac><== ALWAYS TAKEN
200e164: c2 0f 20 04 ldub [ %i4 + 4 ], %g1
rtems_fatal_error_occurred (BLKDEV_FATAL_BDBUF_SWAPOUT_RE);
200e168: 10 bf ff dc b 200e0d8 <rtems_bdbuf_swapout_task+0x2a0> <== NOT EXECUTED
200e16c: 11 10 80 00 sethi %hi(0x42000000), %o0 <== NOT EXECUTED
0200e170 <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)
{
200e170: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED
Chain_Control *the_chain,
Chain_Node *the_node
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
200e174: 3b 00 80 86 sethi %hi(0x2021800), %i5 <== NOT EXECUTED
while (worker->enabled)
{
rtems_bdbuf_wait_for_event (RTEMS_BDBUF_SWAPOUT_SYNC);
rtems_bdbuf_swapout_write (&worker->transfer);
200e178: b8 06 20 10 add %i0, 0x10, %i4 <== NOT EXECUTED
200e17c: ba 17 60 7c or %i5, 0x7c, %i5 <== 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 );
200e180: b6 06 20 14 add %i0, 0x14, %i3 <== 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)
200e184: 10 80 00 12 b 200e1cc <rtems_bdbuf_swapout_worker_task+0x5c><== NOT EXECUTED
200e188: b4 07 60 0c add %i5, 0xc, %i2 <== NOT EXECUTED
{
rtems_bdbuf_wait_for_event (RTEMS_BDBUF_SWAPOUT_SYNC);
200e18c: 7f ff fa ba call 200cc74 <rtems_bdbuf_wait_for_event> <== NOT EXECUTED
200e190: 90 10 20 04 mov 4, %o0 <== NOT EXECUTED
rtems_bdbuf_swapout_write (&worker->transfer);
200e194: 7f ff fe d1 call 200dcd8 <rtems_bdbuf_swapout_write> <== NOT EXECUTED
200e198: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
rtems_bdbuf_lock_cache ();
200e19c: 7f ff fa 87 call 200cbb8 <rtems_bdbuf_lock_cache> <== NOT EXECUTED
200e1a0: 01 00 00 00 nop <== NOT EXECUTED
Chain_Control *the_chain,
Chain_Node *the_node
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
200e1a4: c2 07 60 10 ld [ %i5 + 0x10 ], %g1 <== NOT EXECUTED
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
200e1a8: f6 26 20 10 st %i3, [ %i0 + 0x10 ] <== NOT EXECUTED
rtems_chain_initialize_empty (&worker->transfer.bds);
worker->transfer.dd = BDBUF_INVALID_DEV;
200e1ac: c0 26 20 1c clr [ %i0 + 0x1c ] <== NOT EXECUTED
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
the_node->next = tail;
200e1b0: f4 26 00 00 st %i2, [ %i0 ] <== NOT EXECUTED
tail->previous = the_node;
200e1b4: f0 27 60 10 st %i0, [ %i5 + 0x10 ] <== NOT EXECUTED
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
head->previous = NULL;
200e1b8: c0 26 20 14 clr [ %i0 + 0x14 ] <== NOT EXECUTED
tail->previous = head;
200e1bc: f8 26 20 18 st %i4, [ %i0 + 0x18 ] <== NOT EXECUTED
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
the_node->next = tail;
tail->previous = the_node;
old_last->next = the_node;
200e1c0: f0 20 40 00 st %i0, [ %g1 ] <== NOT EXECUTED
rtems_chain_append_unprotected (&bdbuf_cache.swapout_workers, &worker->link);
rtems_bdbuf_unlock_cache ();
200e1c4: 7f ff fa 93 call 200cc10 <rtems_bdbuf_unlock_cache> <== NOT EXECUTED
200e1c8: c2 26 20 04 st %g1, [ %i0 + 4 ] <== 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)
200e1cc: c2 0e 20 0c ldub [ %i0 + 0xc ], %g1 <== NOT EXECUTED
200e1d0: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
200e1d4: 12 bf ff ee bne 200e18c <rtems_bdbuf_swapout_worker_task+0x1c><== NOT EXECUTED
200e1d8: 01 00 00 00 nop <== NOT EXECUTED
rtems_chain_append_unprotected (&bdbuf_cache.swapout_workers, &worker->link);
rtems_bdbuf_unlock_cache ();
}
free (worker->transfer.write_req);
200e1dc: 7f ff da 1b call 2004a48 <free> <== NOT EXECUTED
200e1e0: d0 06 20 24 ld [ %i0 + 0x24 ], %o0 <== NOT EXECUTED
free (worker);
200e1e4: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
200e1e8: 7f ff da 18 call 2004a48 <free> <== NOT EXECUTED
200e1ec: b0 10 20 00 clr %i0 <== NOT EXECUTED
rtems_task_delete (RTEMS_SELF);
200e1f0: 7f ff eb 7e call 2008fe8 <rtems_task_delete> <== NOT EXECUTED
200e1f4: 81 e8 00 00 restore <== NOT EXECUTED
0200dcd8 <rtems_bdbuf_swapout_write>:
*
* @param transfer The transfer transaction.
*/
static void
rtems_bdbuf_swapout_write (rtems_bdbuf_swapout_transfer* transfer)
{
200dcd8: 9d e3 bf a0 save %sp, -96, %sp
printf ("bdbuf:swapout transfer: %08x\n", (unsigned) transfer->dd->dev);
/*
* If there are buffers to transfer to the media transfer them.
*/
if (!rtems_chain_is_empty (&transfer->bds))
200dcdc: c2 06 00 00 ld [ %i0 ], %g1
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
const Chain_Control *the_chain
)
{
return _Chain_Immutable_first( the_chain )
== _Chain_Immutable_tail( the_chain );
200dce0: b6 06 20 04 add %i0, 4, %i3
200dce4: 80 a0 40 1b cmp %g1, %i3
200dce8: 02 80 00 52 be 200de30 <rtems_bdbuf_swapout_write+0x158> <== NEVER TAKEN
200dcec: 84 10 20 0c mov 0xc, %g2
* The last block number used when the driver only supports
* continuous blocks in a single request.
*/
uint32_t last_block = 0;
rtems_disk_device *dd = transfer->dd;
200dcf0: fa 06 20 0c ld [ %i0 + 0xc ], %i5
uint32_t media_blocks_per_block = dd->media_blocks_per_block;
bool need_continuous_blocks =
(dd->phys_dev->capabilities & RTEMS_BLKDEV_CAP_MULTISECTOR_CONT) != 0;
200dcf4: c2 07 60 08 ld [ %i5 + 8 ], %g1
* continuous blocks in a single request.
*/
uint32_t last_block = 0;
rtems_disk_device *dd = transfer->dd;
uint32_t media_blocks_per_block = dd->media_blocks_per_block;
200dcf8: f4 07 60 2c ld [ %i5 + 0x2c ], %i2
bool need_continuous_blocks =
(dd->phys_dev->capabilities & RTEMS_BLKDEV_CAP_MULTISECTOR_CONT) != 0;
200dcfc: f2 00 60 0c ld [ %g1 + 0xc ], %i1
* 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;
200dd00: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
uint32_t last_block = 0;
rtems_disk_device *dd = transfer->dd;
uint32_t media_blocks_per_block = dd->media_blocks_per_block;
bool need_continuous_blocks =
(dd->phys_dev->capabilities & RTEMS_BLKDEV_CAP_MULTISECTOR_CONT) != 0;
200dd04: b2 0e 60 01 and %i1, 1, %i1
* 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;
200dd08: c4 20 60 0c st %g2, [ %g1 + 0xc ]
transfer->write_req->bufnum = 0;
200dd0c: c0 20 60 10 clr [ %g1 + 0x10 ]
{
/*
* The last block number used when the driver only supports
* continuous blocks in a single request.
*/
uint32_t last_block = 0;
200dd10: b8 10 20 00 clr %i4
if (write)
{
rtems_bdbuf_execute_transfer_request (dd, transfer->write_req, false);
transfer->write_req->status = RTEMS_RESOURCE_IN_USE;
200dd14: a0 10 20 0c mov 0xc, %l0
* trouble waiting to happen.
*/
transfer->write_req->status = RTEMS_RESOURCE_IN_USE;
transfer->write_req->bufnum = 0;
while ((node = rtems_chain_get_unprotected(&transfer->bds)) != NULL)
200dd18: 10 80 00 35 b 200ddec <rtems_bdbuf_swapout_write+0x114>
200dd1c: 23 00 80 7b sethi %hi(0x201ec00), %l1
if (rtems_bdbuf_tracer)
printf ("bdbuf:swapout write: bd:%" PRIu32 ", bufnum:%" PRIu32 " mode:%s\n",
bd->block, transfer->write_req->bufnum,
need_continuous_blocks ? "MULTI" : "SCAT");
if (need_continuous_blocks && transfer->write_req->bufnum &&
200dd20: 02 80 00 12 be 200dd68 <rtems_bdbuf_swapout_write+0x90>
200dd24: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
200dd28: c4 00 60 10 ld [ %g1 + 0x10 ], %g2
200dd2c: 80 a0 a0 00 cmp %g2, 0
200dd30: 22 80 00 0f be,a 200dd6c <rtems_bdbuf_swapout_write+0x94>
200dd34: c8 00 60 10 ld [ %g1 + 0x10 ], %g4
200dd38: c6 02 20 18 ld [ %o0 + 0x18 ], %g3
bd->block != last_block + media_blocks_per_block)
200dd3c: 84 07 00 1a add %i4, %i2, %g2
if (rtems_bdbuf_tracer)
printf ("bdbuf:swapout write: bd:%" PRIu32 ", bufnum:%" PRIu32 " mode:%s\n",
bd->block, transfer->write_req->bufnum,
need_continuous_blocks ? "MULTI" : "SCAT");
if (need_continuous_blocks && transfer->write_req->bufnum &&
200dd40: 80 a0 c0 02 cmp %g3, %g2
200dd44: 22 80 00 0a be,a 200dd6c <rtems_bdbuf_swapout_write+0x94>
200dd48: c8 00 60 10 ld [ %g1 + 0x10 ], %g4
)
{
Chain_Node *before_node;
the_node->previous = after_node;
before_node = after_node->next;
200dd4c: c2 06 00 00 ld [ %i0 ], %g1
Chain_Node *the_node
)
{
Chain_Node *before_node;
the_node->previous = after_node;
200dd50: f0 22 20 04 st %i0, [ %o0 + 4 ]
before_node = after_node->next;
after_node->next = the_node;
200dd54: d0 26 00 00 st %o0, [ %i0 ]
the_node->next = before_node;
200dd58: c2 22 00 00 st %g1, [ %o0 ]
before_node->previous = the_node;
200dd5c: d0 20 60 04 st %o0, [ %g1 + 4 ]
bd->block != last_block + media_blocks_per_block)
{
rtems_chain_prepend_unprotected (&transfer->bds, &bd->link);
write = true;
200dd60: 10 80 00 10 b 200dda0 <rtems_bdbuf_swapout_write+0xc8>
200dd64: 82 10 20 01 mov 1, %g1
}
else
{
rtems_blkdev_sg_buffer* buf;
buf = &transfer->write_req->bufs[transfer->write_req->bufnum];
200dd68: c8 00 60 10 ld [ %g1 + 0x10 ], %g4
transfer->write_req->bufnum++;
buf->user = bd;
buf->block = bd->block;
200dd6c: f8 02 20 18 ld [ %o0 + 0x18 ], %i4
write = true;
}
else
{
rtems_blkdev_sg_buffer* buf;
buf = &transfer->write_req->bufs[transfer->write_req->bufnum];
200dd70: 87 29 20 04 sll %g4, 4, %g3
transfer->write_req->bufnum++;
200dd74: 88 01 20 01 inc %g4
200dd78: c8 20 60 10 st %g4, [ %g1 + 0x10 ]
write = true;
}
else
{
rtems_blkdev_sg_buffer* buf;
buf = &transfer->write_req->bufs[transfer->write_req->bufnum];
200dd7c: 86 00 e0 18 add %g3, 0x18, %g3
200dd80: 84 00 40 03 add %g1, %g3, %g2
transfer->write_req->bufnum++;
buf->user = bd;
buf->block = bd->block;
200dd84: f8 20 40 03 st %i4, [ %g1 + %g3 ]
buf->length = dd->block_size;
200dd88: c2 07 60 24 ld [ %i5 + 0x24 ], %g1
else
{
rtems_blkdev_sg_buffer* buf;
buf = &transfer->write_req->bufs[transfer->write_req->bufnum];
transfer->write_req->bufnum++;
buf->user = bd;
200dd8c: d0 20 a0 0c st %o0, [ %g2 + 0xc ]
buf->block = bd->block;
buf->length = dd->block_size;
200dd90: c2 20 a0 04 st %g1, [ %g2 + 4 ]
buf->buffer = bd->buffer;
200dd94: c2 02 20 1c ld [ %o0 + 0x1c ], %g1
200dd98: c2 20 a0 08 st %g1, [ %g2 + 8 ]
transfer->write_req->bufnum = 0;
while ((node = rtems_chain_get_unprotected(&transfer->bds)) != NULL)
{
rtems_bdbuf_buffer* bd = (rtems_bdbuf_buffer*) node;
bool write = false;
200dd9c: 82 10 20 00 clr %g1
/*
* 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) ||
200dda0: c4 06 00 00 ld [ %i0 ], %g2
200dda4: 80 a0 80 1b cmp %g2, %i3
200dda8: 02 80 00 0b be 200ddd4 <rtems_bdbuf_swapout_write+0xfc>
200ddac: d2 06 20 14 ld [ %i0 + 0x14 ], %o1
(transfer->write_req->bufnum >= bdbuf_config.max_write_blocks))
200ddb0: 84 14 61 40 or %l1, 0x140, %g2
/*
* 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) ||
200ddb4: c6 02 60 10 ld [ %o1 + 0x10 ], %g3
200ddb8: c4 00 a0 04 ld [ %g2 + 4 ], %g2
200ddbc: 80 a0 c0 02 cmp %g3, %g2
200ddc0: 1a 80 00 06 bcc 200ddd8 <rtems_bdbuf_swapout_write+0x100>
200ddc4: 90 10 00 1d mov %i5, %o0
(transfer->write_req->bufnum >= bdbuf_config.max_write_blocks))
write = true;
if (write)
200ddc8: 80 88 60 ff btst 0xff, %g1
200ddcc: 02 80 00 08 be 200ddec <rtems_bdbuf_swapout_write+0x114>
200ddd0: 01 00 00 00 nop
{
rtems_bdbuf_execute_transfer_request (dd, transfer->write_req, false);
200ddd4: 90 10 00 1d mov %i5, %o0
200ddd8: 7f ff ff 4f call 200db14 <rtems_bdbuf_execute_transfer_request>
200dddc: 94 10 20 00 clr %o2
transfer->write_req->status = RTEMS_RESOURCE_IN_USE;
200dde0: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
200dde4: e0 20 60 0c st %l0, [ %g1 + 0xc ]
transfer->write_req->bufnum = 0;
200dde8: c0 20 60 10 clr [ %g1 + 0x10 ]
*/
RTEMS_INLINE_ROUTINE rtems_chain_node *rtems_chain_get_unprotected(
rtems_chain_control *the_chain
)
{
return _Chain_Get_unprotected( the_chain );
200ddec: 7f ff fb 53 call 200cb38 <_Chain_Get_unprotected>
200ddf0: 90 10 00 18 mov %i0, %o0
* trouble waiting to happen.
*/
transfer->write_req->status = RTEMS_RESOURCE_IN_USE;
transfer->write_req->bufnum = 0;
while ((node = rtems_chain_get_unprotected(&transfer->bds)) != NULL)
200ddf4: 80 a2 20 00 cmp %o0, 0
200ddf8: 12 bf ff ca bne 200dd20 <rtems_bdbuf_swapout_write+0x48>
200ddfc: 80 a6 60 00 cmp %i1, 0
/*
* If sync'ing and the deivce is capability of handling a sync IO control
* call perform the call.
*/
if (transfer->syncing &&
200de00: c2 0e 20 10 ldub [ %i0 + 0x10 ], %g1
200de04: 80 a0 60 00 cmp %g1, 0
200de08: 02 80 00 0a be 200de30 <rtems_bdbuf_swapout_write+0x158>
200de0c: 01 00 00 00 nop
(dd->phys_dev->capabilities & RTEMS_BLKDEV_CAP_SYNC))
200de10: d0 07 60 08 ld [ %i5 + 8 ], %o0
200de14: c2 02 20 0c ld [ %o0 + 0xc ], %g1
/*
* If sync'ing and the deivce is capability of handling a sync IO control
* call perform the call.
*/
if (transfer->syncing &&
200de18: 80 88 60 02 btst 2, %g1
200de1c: 02 80 00 05 be 200de30 <rtems_bdbuf_swapout_write+0x158> <== ALWAYS TAKEN
200de20: 92 10 20 02 mov 2, %o1
(dd->phys_dev->capabilities & RTEMS_BLKDEV_CAP_SYNC))
{
/* int result = */ dd->ioctl (dd->phys_dev, RTEMS_BLKDEV_REQ_SYNC, NULL);
200de24: c2 07 60 38 ld [ %i5 + 0x38 ], %g1 <== NOT EXECUTED
200de28: 9f c0 40 00 call %g1 <== NOT EXECUTED
200de2c: 94 10 20 00 clr %o2 <== NOT EXECUTED
200de30: 81 c7 e0 08 ret
200de34: 81 e8 00 00 restore
0200cddc <rtems_bdbuf_swapout_writereq_alloc>:
*
* @return rtems_blkdev_request* The write reference memory.
*/
static rtems_blkdev_request*
rtems_bdbuf_swapout_writereq_alloc (void)
{
200cddc: 9d e3 bf a0 save %sp, -96, %sp
* 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)));
200cde0: 03 00 80 7b sethi %hi(0x201ec00), %g1
200cde4: d0 00 61 44 ld [ %g1 + 0x144 ], %o0 ! 201ed44 <rtems_bdbuf_configuration+0x4>
200cde8: 91 2a 20 04 sll %o0, 4, %o0
* @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 =
200cdec: 7f ff e0 6d call 2004fa0 <malloc>
200cdf0: 90 02 20 18 add %o0, 0x18, %o0
malloc (sizeof (rtems_blkdev_request) +
(bdbuf_config.max_write_blocks * sizeof (rtems_blkdev_sg_buffer)));
if (!write_req)
200cdf4: b0 92 20 00 orcc %o0, 0, %i0
200cdf8: 12 80 00 05 bne 200ce0c <rtems_bdbuf_swapout_writereq_alloc+0x30><== ALWAYS TAKEN
200cdfc: 82 10 20 01 mov 1, %g1
rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_SO_NOMEM);
200ce00: 11 10 80 00 sethi %hi(0x42000000), %o0 <== NOT EXECUTED
200ce04: 7f ff f1 65 call 2009398 <rtems_fatal_error_occurred> <== NOT EXECUTED
200ce08: 90 12 20 15 or %o0, 0x15, %o0 ! 42000015 <RAM_END+0x3fc00015><== NOT EXECUTED
write_req->req = RTEMS_BLKDEV_REQ_WRITE;
200ce0c: c2 26 00 00 st %g1, [ %i0 ]
write_req->req_done = rtems_bdbuf_transfer_done;
200ce10: 03 00 80 33 sethi %hi(0x200cc00), %g1
200ce14: 82 10 60 5c or %g1, 0x5c, %g1 ! 200cc5c <rtems_bdbuf_transfer_done>
write_req->done_arg = write_req;
200ce18: f0 26 20 08 st %i0, [ %i0 + 8 ]
write_req->io_task = rtems_task_self ();
200ce1c: 40 00 11 4e call 2011354 <rtems_task_self>
200ce20: c2 26 20 04 st %g1, [ %i0 + 4 ]
200ce24: d0 26 20 14 st %o0, [ %i0 + 0x14 ]
return write_req;
}
200ce28: 81 c7 e0 08 ret
200ce2c: 81 e8 00 00 restore
0200ecec <rtems_bdbuf_sync>:
rtems_status_code
rtems_bdbuf_sync (rtems_bdbuf_buffer *bd)
{
200ecec: 9d e3 bf a0 save %sp, -96, %sp
}
static rtems_status_code
rtems_bdbuf_check_bd_and_lock_cache (rtems_bdbuf_buffer *bd, const char *kind)
{
if (bd == NULL)
200ecf0: 80 a6 20 00 cmp %i0, 0
200ecf4: 02 80 00 4c be 200ee24 <rtems_bdbuf_sync+0x138> <== NEVER TAKEN
200ecf8: 01 00 00 00 nop
if (rtems_bdbuf_tracer)
{
printf ("bdbuf:%s: %" PRIu32 "\n", kind, bd->block);
rtems_bdbuf_show_users (kind, bd);
}
rtems_bdbuf_lock_cache();
200ecfc: 7f ff f7 af call 200cbb8 <rtems_bdbuf_lock_cache>
200ed00: 01 00 00 00 nop
sc = rtems_bdbuf_check_bd_and_lock_cache (bd, "sync");
if (sc != RTEMS_SUCCESSFUL)
return sc;
switch (bd->state)
200ed04: d0 06 20 20 ld [ %i0 + 0x20 ], %o0
200ed08: 80 a2 20 03 cmp %o0, 3
200ed0c: 0a 80 00 3f bcs 200ee08 <rtems_bdbuf_sync+0x11c> <== NEVER TAKEN
200ed10: 13 10 80 00 sethi %hi(0x42000000), %o1
200ed14: 80 a2 20 05 cmp %o0, 5
200ed18: 08 80 00 06 bleu 200ed30 <rtems_bdbuf_sync+0x44>
200ed1c: 82 10 20 08 mov 8, %g1
200ed20: 80 a2 20 06 cmp %o0, 6
200ed24: 12 80 00 3a bne 200ee0c <rtems_bdbuf_sync+0x120> <== NEVER TAKEN
200ed28: 92 12 60 03 or %o1, 3, %o1
200ed2c: 30 80 00 34 b,a 200edfc <rtems_bdbuf_sync+0x110>
Chain_Control *the_chain,
Chain_Node *the_node
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
200ed30: 11 00 80 86 sethi %hi(0x2021800), %o0
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
200ed34: c2 26 20 20 st %g1, [ %i0 + 0x20 ]
200ed38: 90 12 20 7c or %o0, 0x7c, %o0
200ed3c: c2 02 20 60 ld [ %o0 + 0x60 ], %g1
the_node->next = tail;
200ed40: 84 02 20 5c add %o0, 0x5c, %g2
tail->previous = the_node;
200ed44: f0 22 20 60 st %i0, [ %o0 + 0x60 ]
)
{
Chain_Node *tail = _Chain_Tail( the_chain );
Chain_Node *old_last = tail->previous;
the_node->next = tail;
200ed48: c4 26 00 00 st %g2, [ %i0 ]
tail->previous = the_node;
old_last->next = the_node;
200ed4c: f0 20 40 00 st %i0, [ %g1 ]
the_node->previous = old_last;
200ed50: c2 26 20 04 st %g1, [ %i0 + 4 ]
{
rtems_bdbuf_set_state (bd, RTEMS_BDBUF_STATE_SYNC);
rtems_chain_append_unprotected (&bdbuf_cache.sync, &bd->link);
if (bd->waiters)
200ed54: c2 06 20 24 ld [ %i0 + 0x24 ], %g1
200ed58: 80 a0 60 00 cmp %g1, 0
200ed5c: 02 80 00 04 be 200ed6c <rtems_bdbuf_sync+0x80>
200ed60: 01 00 00 00 nop
rtems_bdbuf_wake (&bdbuf_cache.access_waiters);
200ed64: 7f ff f8 4c call 200ce94 <rtems_bdbuf_wake>
200ed68: 90 02 20 64 add %o0, 0x64, %o0
rtems_bdbuf_wake_swapper ();
200ed6c: 7f ff f7 b0 call 200cc2c <rtems_bdbuf_wake_swapper>
200ed70: 3b 00 80 86 sethi %hi(0x2021800), %i5
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);
200ed74: ba 17 60 e8 or %i5, 0xe8, %i5 ! 20218e8 <bdbuf_cache+0x6c>
static void
rtems_bdbuf_wait_for_sync_done (rtems_bdbuf_buffer *bd)
{
while (true)
{
switch (bd->state)
200ed78: d0 06 20 20 ld [ %i0 + 0x20 ], %o0
200ed7c: 80 a2 20 01 cmp %o0, 1
200ed80: 0a 80 00 0d bcs 200edb4 <rtems_bdbuf_sync+0xc8> <== NEVER TAKEN
200ed84: 13 10 80 00 sethi %hi(0x42000000), %o1
200ed88: 80 a2 20 07 cmp %o0, 7
200ed8c: 28 80 00 0c bleu,a 200edbc <rtems_bdbuf_sync+0xd0>
200ed90: c2 06 20 24 ld [ %i0 + 0x24 ], %g1
200ed94: 80 a2 20 0a cmp %o0, 0xa
200ed98: 18 80 00 1d bgu 200ee0c <rtems_bdbuf_sync+0x120> <== NEVER TAKEN
200ed9c: 92 12 60 07 or %o1, 7, %o1
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);
200eda0: 90 10 00 18 mov %i0, %o0
200eda4: 7f ff f8 01 call 200cda8 <rtems_bdbuf_wait>
200eda8: 92 10 00 1d mov %i5, %o1
static void
rtems_bdbuf_wait_for_sync_done (rtems_bdbuf_buffer *bd)
{
while (true)
{
switch (bd->state)
200edac: 10 bf ff f4 b 200ed7c <rtems_bdbuf_sync+0x90>
200edb0: d0 06 20 20 ld [ %i0 + 0x20 ], %o0
case RTEMS_BDBUF_STATE_TRANSFER:
case RTEMS_BDBUF_STATE_TRANSFER_PURGED:
rtems_bdbuf_wait (bd, &bdbuf_cache.transfer_waiters);
break;
default:
rtems_bdbuf_fatal (bd->state, RTEMS_BLKDEV_FATAL_BDBUF_STATE_9);
200edb4: 10 80 00 16 b 200ee0c <rtems_bdbuf_sync+0x120> <== NOT EXECUTED
200edb8: 92 12 60 07 or %o1, 7, %o1 <== 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
200edbc: 80 a0 60 00 cmp %g1, 0
200edc0: 12 80 00 15 bne 200ee14 <rtems_bdbuf_sync+0x128>
200edc4: 82 02 3f ff add %o0, -1, %g1
&& (bd->state == RTEMS_BDBUF_STATE_CACHED
200edc8: 80 a0 60 01 cmp %g1, 1
200edcc: 18 80 00 12 bgu 200ee14 <rtems_bdbuf_sync+0x128> <== NEVER TAKEN
200edd0: 80 a2 20 01 cmp %o0, 1
|| bd->state == RTEMS_BDBUF_STATE_EMPTY))
{
if (bd->state == RTEMS_BDBUF_STATE_EMPTY)
200edd4: 32 80 00 07 bne,a 200edf0 <rtems_bdbuf_sync+0x104>
200edd8: 11 00 80 86 sethi %hi(0x2021800), %o0
{
rtems_bdbuf_remove_from_tree (bd);
200eddc: 7f ff f8 53 call 200cf28 <rtems_bdbuf_remove_from_tree>
200ede0: 90 10 00 18 mov %i0, %o0
rtems_bdbuf_make_free_and_add_to_lru_list (bd);
200ede4: 7f ff f9 2b call 200d290 <rtems_bdbuf_make_free_and_add_to_lru_list>
200ede8: 90 10 00 18 mov %i0, %o0
}
rtems_bdbuf_wake (&bdbuf_cache.buffer_waiters);
200edec: 11 00 80 86 sethi %hi(0x2021800), %o0
200edf0: 7f ff f8 29 call 200ce94 <rtems_bdbuf_wake>
200edf4: 90 12 20 f0 or %o0, 0xf0, %o0 ! 20218f0 <bdbuf_cache+0x74>
200edf8: 30 80 00 07 b,a 200ee14 <rtems_bdbuf_sync+0x128>
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);
200edfc: 7f ff fd 92 call 200e444 <rtems_bdbuf_discard_buffer_after_access>
200ee00: 90 10 00 18 mov %i0, %o0
break;
200ee04: 30 80 00 04 b,a 200ee14 <rtems_bdbuf_sync+0x128>
default:
rtems_bdbuf_fatal (bd->state, RTEMS_BLKDEV_FATAL_BDBUF_STATE_5);
200ee08: 92 12 60 03 or %o1, 3, %o1 <== NOT EXECUTED
200ee0c: 7f ff f7 72 call 200cbd4 <rtems_bdbuf_fatal> <== NOT EXECUTED
200ee10: 01 00 00 00 nop <== NOT EXECUTED
}
if (rtems_bdbuf_tracer)
rtems_bdbuf_show_usage ();
rtems_bdbuf_unlock_cache ();
200ee14: 7f ff f7 7f call 200cc10 <rtems_bdbuf_unlock_cache>
200ee18: b0 10 20 00 clr %i0 ! 0 <PROM_START>
return RTEMS_SUCCESSFUL;
200ee1c: 81 c7 e0 08 ret
200ee20: 81 e8 00 00 restore
}
200ee24: 81 c7 e0 08 ret <== NOT EXECUTED
200ee28: 91 e8 20 09 restore %g0, 9, %o0 <== NOT EXECUTED
0200cbe8 <rtems_bdbuf_unlock>:
* @param lock The mutex to unlock.
* @param fatal_error_code The error code if the call fails.
*/
static void
rtems_bdbuf_unlock (rtems_id lock, uint32_t fatal_error_code)
{
200cbe8: 9d e3 bf a0 save %sp, -96, %sp
rtems_status_code sc = rtems_semaphore_release (lock);
200cbec: 7f ff f0 88 call 2008e0c <rtems_semaphore_release>
200cbf0: 90 10 00 18 mov %i0, %o0
if (sc != RTEMS_SUCCESSFUL)
200cbf4: 80 a2 20 00 cmp %o0, 0
200cbf8: 02 80 00 04 be 200cc08 <rtems_bdbuf_unlock+0x20> <== ALWAYS TAKEN
200cbfc: 01 00 00 00 nop
rtems_fatal_error_occurred (fatal_error_code);
200cc00: 7f ff f1 e6 call 2009398 <rtems_fatal_error_occurred> <== NOT EXECUTED
200cc04: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
200cc08: 81 c7 e0 08 ret
200cc0c: 81 e8 00 00 restore
0200cc74 <rtems_bdbuf_wait_for_event>:
return RTEMS_UNSATISFIED;
}
static void
rtems_bdbuf_wait_for_event (rtems_event_set event)
{
200cc74: 9d e3 bf 98 save %sp, -104, %sp
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_event_set out = 0;
sc = rtems_event_receive (event,
200cc78: 92 10 20 00 clr %o1
static void
rtems_bdbuf_wait_for_event (rtems_event_set event)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_event_set out = 0;
200cc7c: c0 27 bf fc clr [ %fp + -4 ]
sc = rtems_event_receive (event,
200cc80: 90 10 00 18 mov %i0, %o0
200cc84: 94 10 20 00 clr %o2
200cc88: 7f ff ee 7d call 200867c <rtems_event_receive>
200cc8c: 96 07 bf fc add %fp, -4, %o3
RTEMS_EVENT_ALL | RTEMS_WAIT,
RTEMS_NO_TIMEOUT,
&out);
if (sc != RTEMS_SUCCESSFUL || out != event)
200cc90: 80 a2 20 00 cmp %o0, 0
200cc94: 12 80 00 05 bne 200cca8 <rtems_bdbuf_wait_for_event+0x34> <== NEVER TAKEN
200cc98: c2 07 bf fc ld [ %fp + -4 ], %g1
200cc9c: 80 a0 40 18 cmp %g1, %i0
200cca0: 02 80 00 05 be 200ccb4 <rtems_bdbuf_wait_for_event+0x40> <== ALWAYS TAKEN
200cca4: 01 00 00 00 nop
rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_WAIT_EVNT);
200cca8: 11 10 80 00 sethi %hi(0x42000000), %o0 <== NOT EXECUTED
200ccac: 7f ff f1 bb call 2009398 <rtems_fatal_error_occurred> <== NOT EXECUTED
200ccb0: 90 12 20 1a or %o0, 0x1a, %o0 ! 4200001a <RAM_END+0x3fc0001a><== NOT EXECUTED
200ccb4: 81 c7 e0 08 ret
200ccb8: 81 e8 00 00 restore
0200ce94 <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)
{
200ce94: 9d e3 bf a0 save %sp, -96, %sp
rtems_status_code sc = RTEMS_SUCCESSFUL;
if (waiters->count > 0)
200ce98: c2 06 00 00 ld [ %i0 ], %g1
200ce9c: 80 a0 60 00 cmp %g1, 0
200cea0: 02 80 00 09 be 200cec4 <rtems_bdbuf_wake+0x30>
200cea4: 01 00 00 00 nop
{
sc = rtems_semaphore_flush (waiters->sema);
200cea8: 40 00 10 a3 call 2011134 <rtems_semaphore_flush>
200ceac: d0 06 20 04 ld [ %i0 + 4 ], %o0
if (sc != RTEMS_SUCCESSFUL)
200ceb0: 80 a2 20 00 cmp %o0, 0
200ceb4: 02 80 00 04 be 200cec4 <rtems_bdbuf_wake+0x30> <== ALWAYS TAKEN
200ceb8: 11 10 80 00 sethi %hi(0x42000000), %o0
rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_CACHE_WAKE);
200cebc: 7f ff f1 37 call 2009398 <rtems_fatal_error_occurred> <== NOT EXECUTED
200cec0: 90 12 20 13 or %o0, 0x13, %o0 ! 42000013 <RAM_END+0x3fc00013><== NOT EXECUTED
200cec4: 81 c7 e0 08 ret
200cec8: 81 e8 00 00 restore
0200cc2c <rtems_bdbuf_wake_swapper>:
}
}
static void
rtems_bdbuf_wake_swapper (void)
{
200cc2c: 9d e3 bf a0 save %sp, -96, %sp
rtems_status_code sc = rtems_event_send (bdbuf_cache.swapout,
200cc30: 03 00 80 86 sethi %hi(0x2021800), %g1
200cc34: d0 00 60 7c ld [ %g1 + 0x7c ], %o0 ! 202187c <bdbuf_cache>
200cc38: 7f ff ee f4 call 2008808 <rtems_event_send>
200cc3c: 92 10 20 04 mov 4, %o1
RTEMS_BDBUF_SWAPOUT_SYNC);
if (sc != RTEMS_SUCCESSFUL)
200cc40: 80 a2 20 00 cmp %o0, 0
200cc44: 02 80 00 04 be 200cc54 <rtems_bdbuf_wake_swapper+0x28> <== ALWAYS TAKEN
200cc48: 11 10 80 00 sethi %hi(0x42000000), %o0
rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_SO_WAKE);
200cc4c: 7f ff f1 d3 call 2009398 <rtems_fatal_error_occurred> <== NOT EXECUTED
200cc50: 90 12 20 14 or %o0, 0x14, %o0 ! 42000014 <RAM_END+0x3fc00014><== NOT EXECUTED
200cc54: 81 c7 e0 08 ret
200cc58: 81 e8 00 00 restore
02023ca4 <rtems_bdpart_create>:
const rtems_bdpart_format *format,
rtems_bdpart_partition *pt,
const unsigned *dist,
size_t count
)
{
2023ca4: 9d e3 bf 98 save %sp, -104, %sp
rtems_status_code sc = RTEMS_SUCCESSFUL;
bool dos_compatibility = format != NULL
&& format->type == RTEMS_BDPART_FORMAT_MBR
&& format->mbr.dos_compatibility;
2023ca8: 80 a6 60 00 cmp %i1, 0
2023cac: 02 80 00 08 be 2023ccc <rtems_bdpart_create+0x28> <== NEVER TAKEN
2023cb0: 90 10 00 18 mov %i0, %o0
size_t count
)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
bool dos_compatibility = format != NULL
&& format->type == RTEMS_BDPART_FORMAT_MBR
2023cb4: c2 06 40 00 ld [ %i1 ], %g1
2023cb8: 80 a0 60 00 cmp %g1, 0
2023cbc: 12 80 00 05 bne 2023cd0 <rtems_bdpart_create+0x2c> <== NEVER TAKEN
2023cc0: a0 10 20 00 clr %l0
&& format->mbr.dos_compatibility;
2023cc4: 10 80 00 03 b 2023cd0 <rtems_bdpart_create+0x2c>
2023cc8: e0 0e 60 08 ldub [ %i1 + 8 ], %l0
2023ccc: a0 10 20 00 clr %l0 <== NOT EXECUTED
const unsigned *dist,
size_t count
)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
bool dos_compatibility = format != NULL
2023cd0: a0 0c 20 01 and %l0, 1, %l0
&& format->type == RTEMS_BDPART_FORMAT_MBR
&& format->mbr.dos_compatibility;
rtems_blkdev_bnum disk_end = 0;
2023cd4: c0 27 bf fc clr [ %fp + -4 ]
rtems_blkdev_bnum pos = 0;
rtems_blkdev_bnum dist_sum = 0;
rtems_blkdev_bnum record_space =
2023cd8: 82 0c 20 ff and %l0, 0xff, %g1
2023cdc: 80 a0 00 01 cmp %g0, %g1
size_t i = 0;
/* Check if we have something to do */
if (count == 0) {
/* Nothing to do */
return RTEMS_SUCCESSFUL;
2023ce0: b0 10 20 00 clr %i0
&& format->type == RTEMS_BDPART_FORMAT_MBR
&& format->mbr.dos_compatibility;
rtems_blkdev_bnum disk_end = 0;
rtems_blkdev_bnum pos = 0;
rtems_blkdev_bnum dist_sum = 0;
rtems_blkdev_bnum record_space =
2023ce4: ba 40 3f ff addx %g0, -1, %i5
rtems_blkdev_bnum overhead = 0;
rtems_blkdev_bnum free_space = 0;
size_t i = 0;
/* Check if we have something to do */
if (count == 0) {
2023ce8: 80 a7 20 00 cmp %i4, 0
&& format->type == RTEMS_BDPART_FORMAT_MBR
&& format->mbr.dos_compatibility;
rtems_blkdev_bnum disk_end = 0;
rtems_blkdev_bnum pos = 0;
rtems_blkdev_bnum dist_sum = 0;
rtems_blkdev_bnum record_space =
2023cec: ba 0f 7f c2 and %i5, -62, %i5
rtems_blkdev_bnum overhead = 0;
rtems_blkdev_bnum free_space = 0;
size_t i = 0;
/* Check if we have something to do */
if (count == 0) {
2023cf0: 02 80 00 70 be 2023eb0 <rtems_bdpart_create+0x20c> <== NEVER TAKEN
2023cf4: ba 07 60 3f add %i5, 0x3f, %i5
/* Nothing to do */
return RTEMS_SUCCESSFUL;
}
/* Check parameter */
if (format == NULL || pt == NULL || dist == NULL) {
2023cf8: 80 a6 a0 00 cmp %i2, 0
2023cfc: 02 80 00 6d be 2023eb0 <rtems_bdpart_create+0x20c> <== NEVER TAKEN
2023d00: b0 10 20 09 mov 9, %i0
2023d04: 80 a6 60 00 cmp %i1, 0
2023d08: 02 80 00 6a be 2023eb0 <rtems_bdpart_create+0x20c> <== NEVER TAKEN
2023d0c: 80 a6 e0 00 cmp %i3, 0
2023d10: 02 80 00 68 be 2023eb0 <rtems_bdpart_create+0x20c> <== NEVER TAKEN
2023d14: 92 10 20 00 clr %o1
return RTEMS_INVALID_ADDRESS;
}
/* Get disk data */
sc = rtems_bdpart_get_disk_data( disk_name, NULL, NULL, &disk_end);
2023d18: 94 10 20 00 clr %o2
2023d1c: 40 00 01 cc call 202444c <rtems_bdpart_get_disk_data>
2023d20: 96 07 bf fc add %fp, -4, %o3
if (sc != RTEMS_SUCCESSFUL) {
2023d24: b0 92 20 00 orcc %o0, 0, %i0
2023d28: 12 80 00 62 bne 2023eb0 <rtems_bdpart_create+0x20c> <== NEVER TAKEN
2023d2c: 82 10 20 00 clr %g1
2023d30: 84 10 20 00 clr %g2
#endif
#include <rtems.h>
#include <rtems/bdpart.h>
rtems_status_code rtems_bdpart_create(
2023d34: 87 28 60 02 sll %g1, 2, %g3
/* Get distribution sum and check for overflow */
for (i = 0; i < count; ++i) {
unsigned prev_sum = dist_sum;
dist_sum += dist [i];
2023d38: c6 06 c0 03 ld [ %i3 + %g3 ], %g3
2023d3c: a8 00 c0 02 add %g3, %g2, %l4
if (dist_sum < prev_sum) {
2023d40: 80 a5 00 02 cmp %l4, %g2
2023d44: 1a 80 00 04 bcc 2023d54 <rtems_bdpart_create+0xb0> <== ALWAYS TAKEN
2023d48: 80 a0 e0 00 cmp %g3, 0
return RTEMS_INVALID_NUMBER;
2023d4c: 81 c7 e0 08 ret <== NOT EXECUTED
2023d50: 91 e8 20 0a restore %g0, 0xa, %o0 <== NOT EXECUTED
}
if (dist [i] == 0) {
2023d54: 02 bf ff fe be 2023d4c <rtems_bdpart_create+0xa8> <== NEVER TAKEN
2023d58: 82 00 60 01 inc %g1
if (sc != RTEMS_SUCCESSFUL) {
return sc;
}
/* Get distribution sum and check for overflow */
for (i = 0; i < count; ++i) {
2023d5c: 80 a0 40 1c cmp %g1, %i4
2023d60: 12 bf ff f5 bne 2023d34 <rtems_bdpart_create+0x90>
2023d64: 84 10 00 14 mov %l4, %g2
return RTEMS_INVALID_NUMBER;
}
}
/* Check format */
if (format->type != RTEMS_BDPART_FORMAT_MBR) {
2023d68: c2 06 40 00 ld [ %i1 ], %g1
2023d6c: 80 a0 60 00 cmp %g1, 0
2023d70: 12 80 00 52 bne 2023eb8 <rtems_bdpart_create+0x214> <== NEVER TAKEN
2023d74: 80 8c 20 ff btst 0xff, %l0
return RTEMS_NOT_IMPLEMENTED;
}
/* Align end of disk on cylinder boundary if necessary */
if (dos_compatibility) {
2023d78: 02 80 00 09 be 2023d9c <rtems_bdpart_create+0xf8> <== NEVER TAKEN
2023d7c: 80 a7 20 04 cmp %i4, 4
disk_end -= (disk_end % record_space);
2023d80: f2 07 bf fc ld [ %fp + -4 ], %i1
2023d84: 92 10 00 1d mov %i5, %o1
2023d88: 40 00 de aa call 205b830 <.urem>
2023d8c: 90 10 00 19 mov %i1, %o0
2023d90: 90 26 40 08 sub %i1, %o0, %o0
2023d94: d0 27 bf fc st %o0, [ %fp + -4 ]
/*
* In case we need an extended partition and logical partitions we have to
* account for the space of each EBR.
*/
if (count > 4) {
2023d98: 80 a7 20 04 cmp %i4, 4
2023d9c: 08 80 00 06 bleu 2023db4 <rtems_bdpart_create+0x110> <== NEVER TAKEN
2023da0: b2 10 00 1d mov %i5, %i1
overhead += (count - 3) * record_space;
2023da4: 90 10 00 1d mov %i5, %o0
2023da8: 7f ff 7c 2f call 2002e64 <.umul>
2023dac: 92 07 3f fd add %i4, -3, %o1
2023db0: b2 02 00 1d add %o0, %i5, %i1
/*
* Account space to align every partition on cylinder boundaries if
* necessary.
*/
if (dos_compatibility) {
2023db4: 80 8c 20 ff btst 0xff, %l0
2023db8: 02 80 00 07 be 2023dd4 <rtems_bdpart_create+0x130> <== NEVER TAKEN
2023dbc: e6 07 bf fc ld [ %fp + -4 ], %l3
overhead += (count - 1) * record_space;
2023dc0: 90 10 00 1d mov %i5, %o0
2023dc4: 7f ff 7c 28 call 2002e64 <.umul>
2023dc8: 92 07 3f ff add %i4, -1, %o1
2023dcc: b2 06 40 08 add %i1, %o0, %i1
}
/* Check disk space */
if ((overhead + count) > disk_end) {
2023dd0: e6 07 bf fc ld [ %fp + -4 ], %l3
2023dd4: 82 06 40 1c add %i1, %i4, %g1
2023dd8: 80 a0 40 13 cmp %g1, %l3
2023ddc: 38 80 00 35 bgu,a 2023eb0 <rtems_bdpart_create+0x20c> <== NEVER TAKEN
2023de0: b0 10 20 1b mov 0x1b, %i0 <== NOT EXECUTED
/* Begin of first primary partition */
pos = record_space;
/* Space for partitions */
free_space = disk_end - overhead;
2023de4: aa 24 c0 19 sub %l3, %i1, %l5
2023de8: a2 10 00 1a mov %i2, %l1
if ((overhead + count) > disk_end) {
return RTEMS_IO_ERROR;
}
/* Begin of first primary partition */
pos = record_space;
2023dec: a0 10 00 1d mov %i5, %l0
/* Space for partitions */
free_space = disk_end - overhead;
for (i = 0; i < count; ++i) {
2023df0: b2 10 20 00 clr %i1
#endif
#include <rtems.h>
#include <rtems/bdpart.h>
rtems_status_code rtems_bdpart_create(
2023df4: 83 2e 60 02 sll %i1, 2, %g1
for (i = 0; i < count; ++i) {
rtems_bdpart_partition *p = pt + i;
/* Partition size */
rtems_blkdev_bnum s = free_space * dist [i];
2023df8: e4 06 c0 01 ld [ %i3 + %g1 ], %l2
2023dfc: 92 10 00 15 mov %l5, %o1
2023e00: 7f ff 7c 19 call 2002e64 <.umul>
2023e04: 90 10 00 12 mov %l2, %o0
if (s < free_space || s < dist [i]) {
2023e08: 80 a2 00 15 cmp %o0, %l5
2023e0c: 0a bf ff d0 bcs 2023d4c <rtems_bdpart_create+0xa8> <== NEVER TAKEN
2023e10: 80 a2 00 12 cmp %o0, %l2
2023e14: 0a bf ff ce bcs 2023d4c <rtems_bdpart_create+0xa8> <== NEVER TAKEN
2023e18: 01 00 00 00 nop
/* TODO: Calculate without overflow */
return RTEMS_INVALID_NUMBER;
}
s /= dist_sum;
2023e1c: 40 00 dd d9 call 205b580 <.udiv>
2023e20: 92 10 00 14 mov %l4, %o1
/* Ensure that the partition is not empty */
if (s == 0) {
2023e24: a4 92 20 00 orcc %o0, 0, %l2
2023e28: 22 80 00 02 be,a 2023e30 <rtems_bdpart_create+0x18c> <== NEVER TAKEN
2023e2c: a4 10 20 01 mov 1, %l2 <== NOT EXECUTED
s = 1;
}
/* Align partition upwards */
s += record_space - (s % record_space);
2023e30: 90 10 00 12 mov %l2, %o0
2023e34: 40 00 de 7f call 205b830 <.urem>
2023e38: 92 10 00 1d mov %i5, %o1
2023e3c: a4 04 80 1d add %l2, %i5, %l2
/* Reserve space for the EBR if necessary */
if (count > 4 && i > 2) {
2023e40: 82 10 20 01 mov 1, %g1
2023e44: 80 a6 60 02 cmp %i1, 2
2023e48: 18 80 00 03 bgu 2023e54 <rtems_bdpart_create+0x1b0>
2023e4c: 90 24 80 08 sub %l2, %o0, %o0
2023e50: 82 10 20 00 clr %g1
2023e54: 80 88 60 ff btst 0xff, %g1
2023e58: 22 80 00 0a be,a 2023e80 <rtems_bdpart_create+0x1dc>
2023e5c: e0 24 40 00 st %l0, [ %l1 ]
2023e60: 80 a7 20 04 cmp %i4, 4
2023e64: 18 80 00 03 bgu 2023e70 <rtems_bdpart_create+0x1cc> <== ALWAYS TAKEN
2023e68: 82 10 20 01 mov 1, %g1
2023e6c: 82 10 20 00 clr %g1 <== NOT EXECUTED
2023e70: 80 88 60 ff btst 0xff, %g1
2023e74: 32 80 00 02 bne,a 2023e7c <rtems_bdpart_create+0x1d8> <== ALWAYS TAKEN
2023e78: a0 04 00 1d add %l0, %i5, %l0
pos += record_space;
}
/* Partition begin and end */
p->begin = pos;
2023e7c: e0 24 40 00 st %l0, [ %l1 ]
pos += s;
2023e80: a0 04 00 08 add %l0, %o0, %l0
p->end = pos;
2023e84: e0 24 60 04 st %l0, [ %l1 + 4 ]
pos = record_space;
/* Space for partitions */
free_space = disk_end - overhead;
for (i = 0; i < count; ++i) {
2023e88: b2 06 60 01 inc %i1
2023e8c: 80 a6 40 1c cmp %i1, %i4
2023e90: 12 bf ff d9 bne 2023df4 <rtems_bdpart_create+0x150>
2023e94: a2 04 60 30 add %l1, 0x30, %l1
pos += s;
p->end = pos;
}
/* Expand the last partition to the disk end */
pt [count - 1].end = disk_end;
2023e98: b2 06 7f ff add %i1, -1, %i1
2023e9c: 83 2e 60 04 sll %i1, 4, %g1
2023ea0: b3 2e 60 06 sll %i1, 6, %i1
2023ea4: b2 26 40 01 sub %i1, %g1, %i1
2023ea8: b4 06 80 19 add %i2, %i1, %i2
2023eac: e6 26 a0 04 st %l3, [ %i2 + 4 ]
2023eb0: 81 c7 e0 08 ret
2023eb4: 81 e8 00 00 restore
2023eb8: b0 10 20 18 mov 0x18, %i0 <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
}
2023ebc: 81 c7 e0 08 ret <== NOT EXECUTED
2023ec0: 81 e8 00 00 restore <== NOT EXECUTED
02023ec4 <rtems_bdpart_dump>:
{
uuid_unparse_lower( type, str);
}
void rtems_bdpart_dump( const rtems_bdpart_partition *pt, size_t count)
{
2023ec4: 9d e3 bf 60 save %sp, -160, %sp
size_t i = 0;
printf(
2023ec8: 11 00 81 8e sethi %hi(0x2063800), %o0
break;
case RTEMS_BDPART_MBR_DATA:
type = "DATA";
break;
default:
snprintf( type_buffer, sizeof( type_buffer), "0x%02" PRIx8, type_mbr);
2023ecc: 35 00 81 8e sethi %hi(0x2063800), %i2
void rtems_bdpart_dump( const rtems_bdpart_partition *pt, size_t count)
{
size_t i = 0;
printf(
2023ed0: 90 12 21 98 or %o0, 0x198, %o0
2023ed4: 40 00 8b 9d call 2046d48 <puts>
2023ed8: 27 00 81 8e sethi %hi(0x2063800), %l3
"------------+------------+-----------------------------------------------------\n"
" BEGIN | END | TYPE\n"
"------------+------------+-----------------------------------------------------\n"
);
for (i = 0; i < count; ++i) {
2023edc: ba 10 20 00 clr %i5
break;
case RTEMS_BDPART_MBR_FAT_16_LBA:
type = "FAT 16 LBA";
break;
case RTEMS_BDPART_MBR_FAT_32:
type = "FAT 32";
2023ee0: 37 00 81 8e sethi %hi(0x2063800), %i3
break;
case RTEMS_BDPART_MBR_DATA:
type = "DATA";
break;
default:
snprintf( type_buffer, sizeof( type_buffer), "0x%02" PRIx8, type_mbr);
2023ee4: b4 16 a2 d8 or %i2, 0x2d8, %i2
break;
case RTEMS_BDPART_MBR_FAT_16:
type = "FAT 16";
break;
case RTEMS_BDPART_MBR_FAT_16_LBA:
type = "FAT 16 LBA";
2023ee8: 21 00 81 8e sethi %hi(0x2063800), %l0
break;
case RTEMS_BDPART_MBR_FAT_32_LBA:
type = "FAT 32 LBA";
break;
case RTEMS_BDPART_MBR_DATA:
type = "DATA";
2023eec: 23 00 81 8e sethi %hi(0x2063800), %l1
break;
case RTEMS_BDPART_MBR_FAT_32:
type = "FAT 32";
break;
case RTEMS_BDPART_MBR_FAT_32_LBA:
type = "FAT 32 LBA";
2023ef0: 25 00 81 8e sethi %hi(0x2063800), %l2
"------------+------------+-----------------------------------------------------\n"
" BEGIN | END | TYPE\n"
"------------+------------+-----------------------------------------------------\n"
);
for (i = 0; i < count; ++i) {
2023ef4: 10 80 00 39 b 2023fd8 <rtems_bdpart_dump+0x114>
2023ef8: a6 14 e2 e0 or %l3, 0x2e0, %l3
const rtems_bdpart_partition *p = pt + i;
const char *type = NULL;
char type_buffer [52];
uint8_t type_mbr = 0;
if (rtems_bdpart_to_mbr_partition_type( p->type, &type_mbr)) {
2023efc: b8 06 20 08 add %i0, 8, %i4
2023f00: 92 07 bf c7 add %fp, -57, %o1
2023f04: 40 00 01 46 call 202441c <rtems_bdpart_to_mbr_partition_type>
2023f08: 90 10 00 1c mov %i4, %o0
2023f0c: 80 8a 20 ff btst 0xff, %o0
2023f10: 22 80 00 27 be,a 2023fac <rtems_bdpart_dump+0xe8> <== NEVER TAKEN
2023f14: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
switch (type_mbr) {
2023f18: d6 0f bf c7 ldub [ %fp + -57 ], %o3
2023f1c: 82 0a e0 ff and %o3, 0xff, %g1
2023f20: 80 a0 60 0b cmp %g1, 0xb
2023f24: 22 80 00 27 be,a 2023fc0 <rtems_bdpart_dump+0xfc> <== ALWAYS TAKEN
2023f28: 96 16 e1 80 or %i3, 0x180, %o3
2023f2c: 18 80 00 09 bgu 2023f50 <rtems_bdpart_dump+0x8c> <== NOT EXECUTED
2023f30: 80 a0 60 0e cmp %g1, 0xe <== NOT EXECUTED
2023f34: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED
2023f38: 02 80 00 0e be 2023f70 <rtems_bdpart_dump+0xac> <== NOT EXECUTED
2023f3c: 80 a0 60 04 cmp %g1, 4 <== NOT EXECUTED
2023f40: 12 80 00 15 bne 2023f94 <rtems_bdpart_dump+0xd0> <== NOT EXECUTED
2023f44: 90 07 bf c8 add %fp, -56, %o0 <== NOT EXECUTED
case RTEMS_BDPART_MBR_FAT_12:
type = "FAT 12";
break;
case RTEMS_BDPART_MBR_FAT_16:
type = "FAT 16";
2023f48: 10 80 00 1d b 2023fbc <rtems_bdpart_dump+0xf8> <== NOT EXECUTED
2023f4c: 17 00 81 8e sethi %hi(0x2063800), %o3 <== NOT EXECUTED
const char *type = NULL;
char type_buffer [52];
uint8_t type_mbr = 0;
if (rtems_bdpart_to_mbr_partition_type( p->type, &type_mbr)) {
switch (type_mbr) {
2023f50: 02 80 00 0b be 2023f7c <rtems_bdpart_dump+0xb8> <== NOT EXECUTED
2023f54: 80 a0 60 da cmp %g1, 0xda <== NOT EXECUTED
2023f58: 02 80 00 0d be 2023f8c <rtems_bdpart_dump+0xc8> <== NOT EXECUTED
2023f5c: 80 a0 60 0c cmp %g1, 0xc <== NOT EXECUTED
2023f60: 12 80 00 0d bne 2023f94 <rtems_bdpart_dump+0xd0> <== NOT EXECUTED
2023f64: 90 07 bf c8 add %fp, -56, %o0 <== NOT EXECUTED
break;
case RTEMS_BDPART_MBR_FAT_32:
type = "FAT 32";
break;
case RTEMS_BDPART_MBR_FAT_32_LBA:
type = "FAT 32 LBA";
2023f68: 10 80 00 07 b 2023f84 <rtems_bdpart_dump+0xc0> <== NOT EXECUTED
2023f6c: 96 14 a1 70 or %l2, 0x170, %o3 <== NOT EXECUTED
uint8_t type_mbr = 0;
if (rtems_bdpart_to_mbr_partition_type( p->type, &type_mbr)) {
switch (type_mbr) {
case RTEMS_BDPART_MBR_FAT_12:
type = "FAT 12";
2023f70: 17 00 81 8e sethi %hi(0x2063800), %o3 <== NOT EXECUTED
2023f74: 10 80 00 13 b 2023fc0 <rtems_bdpart_dump+0xfc> <== NOT EXECUTED
2023f78: 96 12 e1 60 or %o3, 0x160, %o3 ! 2063960 <rtems_rfs_rtems_eval_config+0xe28><== NOT EXECUTED
case RTEMS_BDPART_MBR_FAT_16:
type = "FAT 16";
break;
case RTEMS_BDPART_MBR_FAT_16_LBA:
type = "FAT 16 LBA";
break;
2023f7c: 10 80 00 11 b 2023fc0 <rtems_bdpart_dump+0xfc> <== NOT EXECUTED
2023f80: 96 14 21 88 or %l0, 0x188, %o3 <== NOT EXECUTED
case RTEMS_BDPART_MBR_FAT_32:
type = "FAT 32";
break;
case RTEMS_BDPART_MBR_FAT_32_LBA:
type = "FAT 32 LBA";
break;
2023f84: 10 80 00 10 b 2023fc4 <rtems_bdpart_dump+0x100> <== NOT EXECUTED
2023f88: d2 06 00 00 ld [ %i0 ], %o1 <== NOT EXECUTED
case RTEMS_BDPART_MBR_DATA:
type = "DATA";
break;
2023f8c: 10 80 00 0d b 2023fc0 <rtems_bdpart_dump+0xfc> <== NOT EXECUTED
2023f90: 96 14 61 68 or %l1, 0x168, %o3 <== NOT EXECUTED
default:
snprintf( type_buffer, sizeof( type_buffer), "0x%02" PRIx8, type_mbr);
2023f94: 92 10 20 34 mov 0x34, %o1 <== NOT EXECUTED
2023f98: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED
2023f9c: 40 00 90 db call 2048308 <snprintf> <== NOT EXECUTED
2023fa0: 96 0a e0 ff and %o3, 0xff, %o3 <== NOT EXECUTED
type = type_buffer;
break;
}
} else {
rtems_bdpart_type_to_string( p->type, type_buffer);
type = type_buffer;
2023fa4: 10 80 00 07 b 2023fc0 <rtems_bdpart_dump+0xfc> <== NOT EXECUTED
2023fa8: 96 07 bf c8 add %fp, -56, %o3 <== NOT EXECUTED
static void rtems_bdpart_type_to_string(
const uuid_t type,
char str [37]
)
{
uuid_unparse_lower( type, str);
2023fac: 40 00 66 5a call 203d914 <uuid_unparse_lower> <== NOT EXECUTED
2023fb0: 92 07 bf c8 add %fp, -56, %o1 <== NOT EXECUTED
type = type_buffer;
break;
}
} else {
rtems_bdpart_type_to_string( p->type, type_buffer);
type = type_buffer;
2023fb4: 10 80 00 03 b 2023fc0 <rtems_bdpart_dump+0xfc> <== NOT EXECUTED
2023fb8: 96 07 bf c8 add %fp, -56, %o3 <== NOT EXECUTED
switch (type_mbr) {
case RTEMS_BDPART_MBR_FAT_12:
type = "FAT 12";
break;
case RTEMS_BDPART_MBR_FAT_16:
type = "FAT 16";
2023fbc: 96 12 e1 58 or %o3, 0x158, %o3 <== NOT EXECUTED
} else {
rtems_bdpart_type_to_string( p->type, type_buffer);
type = type_buffer;
}
printf(
2023fc0: d2 06 00 00 ld [ %i0 ], %o1
2023fc4: d4 06 20 04 ld [ %i0 + 4 ], %o2
2023fc8: 90 10 00 13 mov %l3, %o0
2023fcc: 40 00 8a c7 call 2046ae8 <printf>
2023fd0: ba 07 60 01 inc %i5
2023fd4: b0 06 20 30 add %i0, 0x30, %i0
"------------+------------+-----------------------------------------------------\n"
" BEGIN | END | TYPE\n"
"------------+------------+-----------------------------------------------------\n"
);
for (i = 0; i < count; ++i) {
2023fd8: 80 a7 40 19 cmp %i5, %i1
2023fdc: 32 bf ff c8 bne,a 2023efc <rtems_bdpart_dump+0x38>
2023fe0: c0 2f bf c7 clrb [ %fp + -57 ]
p->end,
type
);
}
puts( "------------+------------+-----------------------------------------------------");
2023fe4: 11 00 81 8e sethi %hi(0x2063800), %o0
2023fe8: 40 00 8b 58 call 2046d48 <puts>
2023fec: 90 12 22 88 or %o0, 0x288, %o0 ! 2063a88 <rtems_rfs_rtems_eval_config+0xf50>
2023ff0: 81 c7 e0 08 ret
2023ff4: 81 e8 00 00 restore
0202444c <rtems_bdpart_get_disk_data>:
const char *disk_name,
int *fd_ptr,
rtems_disk_device **dd_ptr,
rtems_blkdev_bnum *disk_end
)
{
202444c: 9d e3 bf 98 save %sp, -104, %sp
rtems_disk_device *dd = NULL;
rtems_blkdev_bnum disk_begin = 0;
rtems_blkdev_bnum block_size = 0;
/* Open device file */
fd = open( disk_name, O_RDWR);
2024450: 92 10 20 02 mov 2, %o1
)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
int rv = 0;
int fd = -1;
rtems_disk_device *dd = NULL;
2024454: c0 27 bf fc clr [ %fp + -4 ]
rtems_blkdev_bnum disk_begin = 0;
rtems_blkdev_bnum block_size = 0;
/* Open device file */
fd = open( disk_name, O_RDWR);
2024458: 7f ff 95 a3 call 2009ae4 <open>
202445c: 90 10 00 18 mov %i0, %o0
if (fd < 0) {
2024460: ba 92 20 00 orcc %o0, 0, %i5
2024464: 36 80 00 04 bge,a 2024474 <rtems_bdpart_get_disk_data+0x28><== ALWAYS TAKEN
2024468: 13 10 01 10 sethi %hi(0x40044000), %o1
sc = RTEMS_INVALID_NAME;
202446c: 10 80 00 12 b 20244b4 <rtems_bdpart_get_disk_data+0x68> <== NOT EXECUTED
2024470: b0 10 20 03 mov 3, %i0 <== NOT EXECUTED
static inline int rtems_disk_fd_get_disk_device(
int fd,
rtems_disk_device **dd_ptr
)
{
return ioctl(fd, RTEMS_BLKIO_GETDISKDEV, dd_ptr);
2024474: 94 07 bf fc add %fp, -4, %o2
2024478: 7f ff 92 38 call 2008d58 <ioctl>
202447c: 92 12 62 09 or %o1, 0x209, %o1
goto error;
}
/* Get disk handle */
rv = rtems_disk_fd_get_disk_device( fd, &dd);
if (rv != 0) {
2024480: 80 a2 20 00 cmp %o0, 0
2024484: 32 80 00 0c bne,a 20244b4 <rtems_bdpart_get_disk_data+0x68><== NEVER TAKEN
2024488: b0 10 20 03 mov 3, %i0 <== NOT EXECUTED
sc = RTEMS_INVALID_NAME;
goto error;
}
/* Get disk begin, end and block size */
disk_begin = dd->start;
202448c: c2 07 bf fc ld [ %fp + -4 ], %g1
*disk_end = dd->size;
2024490: c4 18 60 18 ldd [ %g1 + 0x18 ], %g2
2024494: c6 26 c0 00 st %g3, [ %i3 ]
block_size = dd->block_size;
/* Check block size */
if (block_size < RTEMS_BDPART_BLOCK_SIZE) {
2024498: c2 00 60 24 ld [ %g1 + 0x24 ], %g1
202449c: 80 a0 61 ff cmp %g1, 0x1ff
20244a0: 08 80 00 05 bleu 20244b4 <rtems_bdpart_get_disk_data+0x68><== NEVER TAKEN
20244a4: b0 10 20 1b mov 0x1b, %i0
int *fd_ptr,
rtems_disk_device **dd_ptr,
rtems_blkdev_bnum *disk_end
)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
20244a8: 80 a0 00 02 cmp %g0, %g2
20244ac: b0 60 20 00 subx %g0, 0, %i0
20244b0: b0 0e 20 1b and %i0, 0x1b, %i0
goto error;
}
error:
if (sc == RTEMS_SUCCESSFUL && fd_ptr != NULL && dd_ptr != NULL) {
20244b4: 80 a6 20 00 cmp %i0, 0
20244b8: 12 80 00 0a bne 20244e0 <rtems_bdpart_get_disk_data+0x94> <== NEVER TAKEN
20244bc: 80 a6 60 00 cmp %i1, 0
20244c0: 02 80 00 08 be 20244e0 <rtems_bdpart_get_disk_data+0x94>
20244c4: 80 a6 a0 00 cmp %i2, 0
20244c8: 02 80 00 06 be 20244e0 <rtems_bdpart_get_disk_data+0x94> <== NEVER TAKEN
20244cc: c2 07 bf fc ld [ %fp + -4 ], %g1
*fd_ptr = fd;
20244d0: fa 26 40 00 st %i5, [ %i1 ]
*dd_ptr = dd;
20244d4: c2 26 80 00 st %g1, [ %i2 ]
20244d8: 81 c7 e0 08 ret
20244dc: 81 e8 00 00 restore
} else {
close( fd);
20244e0: 7f ff 91 09 call 2008904 <close>
20244e4: 90 10 00 1d mov %i5, %o0
}
return sc;
}
20244e8: 81 c7 e0 08 ret
20244ec: 81 e8 00 00 restore
02023ff8 <rtems_bdpart_mount>:
const char *disk_name,
const rtems_bdpart_partition *pt __attribute__((unused)),
size_t count,
const char *mount_base
)
{
2023ff8: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED
rtems_status_code esc = RTEMS_SUCCESSFUL;
const char *disk_file_name = strrchr( disk_name, '/');
2023ffc: 92 10 20 2f mov 0x2f, %o1 <== NOT EXECUTED
2024000: 40 00 98 82 call 204a208 <strrchr> <== NOT EXECUTED
2024004: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
2024008: ba 10 00 08 mov %o0, %i5 <== NOT EXECUTED
char *logical_disk_name = NULL;
char *logical_disk_marker = NULL;
char *mount_point = NULL;
char *mount_marker = NULL;
size_t disk_file_name_size = 0;
size_t disk_name_size = strlen( disk_name);
202400c: 40 00 94 5d call 2049180 <strlen> <== NOT EXECUTED
2024010: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
2024014: a0 10 00 08 mov %o0, %l0 <== NOT EXECUTED
size_t mount_base_size = strlen( mount_base);
2024018: 40 00 94 5a call 2049180 <strlen> <== NOT EXECUTED
202401c: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
size_t i = 0;
/* Create logical disk name base */
logical_disk_name = malloc( disk_name_size + RTEMS_BDPART_NUMBER_SIZE);
if (logical_disk_name == NULL) {
return RTEMS_NO_MEMORY;
2024020: b8 10 20 1a mov 0x1a, %i4 <== NOT EXECUTED
char *logical_disk_marker = NULL;
char *mount_point = NULL;
char *mount_marker = NULL;
size_t disk_file_name_size = 0;
size_t disk_name_size = strlen( disk_name);
size_t mount_base_size = strlen( mount_base);
2024024: a2 10 00 08 mov %o0, %l1 <== NOT EXECUTED
size_t i = 0;
/* Create logical disk name base */
logical_disk_name = malloc( disk_name_size + RTEMS_BDPART_NUMBER_SIZE);
2024028: 7f ff 94 53 call 2009174 <malloc> <== NOT EXECUTED
202402c: 90 04 20 04 add %l0, 4, %o0 <== NOT EXECUTED
if (logical_disk_name == NULL) {
2024030: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2024034: 02 80 00 4d be 2024168 <rtems_bdpart_mount+0x170> <== NOT EXECUTED
2024038: b2 10 00 08 mov %o0, %i1 <== NOT EXECUTED
return RTEMS_NO_MEMORY;
}
strncpy( logical_disk_name, disk_name, disk_name_size);
202403c: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
2024040: 40 00 95 0c call 2049470 <strncpy> <== NOT EXECUTED
2024044: 94 10 00 10 mov %l0, %o2 <== NOT EXECUTED
/* Get disk file name */
if (disk_file_name != NULL) {
2024048: 80 a7 60 00 cmp %i5, 0 <== NOT EXECUTED
202404c: 22 80 00 06 be,a 2024064 <rtems_bdpart_mount+0x6c> <== NOT EXECUTED
2024050: a4 10 00 10 mov %l0, %l2 <== NOT EXECUTED
disk_file_name += 1;
2024054: b0 07 60 01 add %i5, 1, %i0 <== NOT EXECUTED
disk_file_name_size = strlen( disk_file_name);
2024058: 40 00 94 4a call 2049180 <strlen> <== NOT EXECUTED
202405c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
2024060: a4 10 00 08 mov %o0, %l2 <== NOT EXECUTED
disk_file_name = disk_name;
disk_file_name_size = disk_name_size;
}
/* Create mount point base */
mount_point = malloc( mount_base_size + 1 + disk_file_name_size + RTEMS_BDPART_NUMBER_SIZE);
2024064: a6 04 80 11 add %l2, %l1, %l3 <== NOT EXECUTED
if (mount_point == NULL) {
esc = RTEMS_NO_MEMORY;
2024068: b8 10 20 1a mov 0x1a, %i4 <== NOT EXECUTED
disk_file_name = disk_name;
disk_file_name_size = disk_name_size;
}
/* Create mount point base */
mount_point = malloc( mount_base_size + 1 + disk_file_name_size + RTEMS_BDPART_NUMBER_SIZE);
202406c: 7f ff 94 42 call 2009174 <malloc> <== NOT EXECUTED
2024070: 90 04 e0 05 add %l3, 5, %o0 <== NOT EXECUTED
if (mount_point == NULL) {
2024074: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2024078: 02 80 00 38 be 2024158 <rtems_bdpart_mount+0x160> <== NOT EXECUTED
202407c: ba 10 00 08 mov %o0, %i5 <== NOT EXECUTED
esc = RTEMS_NO_MEMORY;
goto cleanup;
}
strncpy( mount_point, mount_base, mount_base_size);
2024080: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
2024084: 40 00 94 fb call 2049470 <strncpy> <== NOT EXECUTED
2024088: 94 10 00 11 mov %l1, %o2 <== NOT EXECUTED
mount_point [mount_base_size] = '/';
202408c: 82 10 20 2f mov 0x2f, %g1 <== NOT EXECUTED
strncpy( mount_point + mount_base_size + 1, disk_file_name, disk_file_name_size);
2024090: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
if (mount_point == NULL) {
esc = RTEMS_NO_MEMORY;
goto cleanup;
}
strncpy( mount_point, mount_base, mount_base_size);
mount_point [mount_base_size] = '/';
2024094: c2 2f 40 11 stb %g1, [ %i5 + %l1 ] <== NOT EXECUTED
strncpy( mount_point + mount_base_size + 1, disk_file_name, disk_file_name_size);
2024098: 90 04 60 01 add %l1, 1, %o0 <== NOT EXECUTED
202409c: 94 10 00 12 mov %l2, %o2 <== NOT EXECUTED
20240a0: 90 07 40 08 add %i5, %o0, %o0 <== NOT EXECUTED
/* Markers */
logical_disk_marker = logical_disk_name + disk_name_size;
mount_marker = mount_point + mount_base_size + 1 + disk_file_name_size;
20240a4: a6 04 e0 01 inc %l3 <== NOT EXECUTED
/* Mount supported file systems for each partition */
for (i = 0; i < count; ++i) {
/* Create logical disk name */
int rv = snprintf( logical_disk_marker, RTEMS_BDPART_NUMBER_SIZE, "%zu", i + 1);
20240a8: 37 00 81 95 sethi %hi(0x2065400), %i3 <== NOT EXECUTED
esc = RTEMS_NO_MEMORY;
goto cleanup;
}
strncpy( mount_point, mount_base, mount_base_size);
mount_point [mount_base_size] = '/';
strncpy( mount_point + mount_base_size + 1, disk_file_name, disk_file_name_size);
20240ac: 40 00 94 f1 call 2049470 <strncpy> <== NOT EXECUTED
20240b0: 31 00 81 8e sethi %hi(0x2063800), %i0 <== NOT EXECUTED
/* Markers */
logical_disk_marker = logical_disk_name + disk_name_size;
20240b4: a0 06 40 10 add %i1, %l0, %l0 <== NOT EXECUTED
mount_marker = mount_point + mount_base_size + 1 + disk_file_name_size;
20240b8: a6 07 40 13 add %i5, %l3, %l3 <== NOT EXECUTED
/* Mount supported file systems for each partition */
for (i = 0; i < count; ++i) {
20240bc: b8 10 20 00 clr %i4 <== NOT EXECUTED
/* Create logical disk name */
int rv = snprintf( logical_disk_marker, RTEMS_BDPART_NUMBER_SIZE, "%zu", i + 1);
20240c0: b6 16 e3 48 or %i3, 0x348, %i3 <== NOT EXECUTED
/* Markers */
logical_disk_marker = logical_disk_name + disk_name_size;
mount_marker = mount_point + mount_base_size + 1 + disk_file_name_size;
/* Mount supported file systems for each partition */
for (i = 0; i < count; ++i) {
20240c4: 10 80 00 1d b 2024138 <rtems_bdpart_mount+0x140> <== NOT EXECUTED
20240c8: b0 16 22 f8 or %i0, 0x2f8, %i0 <== NOT EXECUTED
/* Create logical disk name */
int rv = snprintf( logical_disk_marker, RTEMS_BDPART_NUMBER_SIZE, "%zu", i + 1);
20240cc: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
20240d0: 92 10 20 04 mov 4, %o1 <== NOT EXECUTED
20240d4: 94 10 00 1b mov %i3, %o2 <== NOT EXECUTED
20240d8: 40 00 90 8c call 2048308 <snprintf> <== NOT EXECUTED
20240dc: 96 10 00 1c mov %i4, %o3 <== NOT EXECUTED
if (rv >= RTEMS_BDPART_NUMBER_SIZE) {
20240e0: 80 a2 20 03 cmp %o0, 3 <== NOT EXECUTED
20240e4: 14 80 00 1a bg 202414c <rtems_bdpart_mount+0x154> <== NOT EXECUTED
20240e8: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED
esc = RTEMS_INVALID_NAME;
goto cleanup;
}
/* Create mount point */
strncpy( mount_marker, logical_disk_marker, RTEMS_BDPART_NUMBER_SIZE);
20240ec: 94 10 20 04 mov 4, %o2 <== NOT EXECUTED
20240f0: 40 00 94 e0 call 2049470 <strncpy> <== NOT EXECUTED
20240f4: 90 10 00 13 mov %l3, %o0 <== NOT EXECUTED
rv = rtems_mkdir( mount_point, S_IRWXU | S_IRWXG | S_IRWXO);
20240f8: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
20240fc: 7f ff 97 c3 call 200a008 <rtems_mkdir> <== NOT EXECUTED
2024100: 92 10 21 ff mov 0x1ff, %o1 <== NOT EXECUTED
if (rv != 0) {
2024104: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2024108: 12 80 00 13 bne 2024154 <rtems_bdpart_mount+0x15c> <== NOT EXECUTED
202410c: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
esc = RTEMS_IO_ERROR;
goto cleanup;
}
/* Mount */
rv = mount(
2024110: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
2024114: 94 10 00 18 mov %i0, %o2 <== NOT EXECUTED
2024118: 96 10 20 00 clr %o3 <== NOT EXECUTED
202411c: 7f ff 94 d0 call 200945c <mount> <== NOT EXECUTED
2024120: 98 10 20 00 clr %o4 <== NOT EXECUTED
mount_point,
"msdos",
0,
NULL
);
if (rv != 0) {
2024124: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2024128: 02 80 00 05 be 202413c <rtems_bdpart_mount+0x144> <== NOT EXECUTED
202412c: 80 a7 00 1a cmp %i4, %i2 <== NOT EXECUTED
rmdir( mount_point);
2024130: 40 00 14 77 call 202930c <rmdir> <== NOT EXECUTED
2024134: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
/* Markers */
logical_disk_marker = logical_disk_name + disk_name_size;
mount_marker = mount_point + mount_base_size + 1 + disk_file_name_size;
/* Mount supported file systems for each partition */
for (i = 0; i < count; ++i) {
2024138: 80 a7 00 1a cmp %i4, %i2 <== NOT EXECUTED
202413c: 32 bf ff e4 bne,a 20240cc <rtems_bdpart_mount+0xd4> <== NOT EXECUTED
2024140: b8 07 20 01 inc %i4 <== NOT EXECUTED
const rtems_bdpart_partition *pt __attribute__((unused)),
size_t count,
const char *mount_base
)
{
rtems_status_code esc = RTEMS_SUCCESSFUL;
2024144: 10 80 00 05 b 2024158 <rtems_bdpart_mount+0x160> <== NOT EXECUTED
2024148: b8 10 20 00 clr %i4 <== NOT EXECUTED
/* Mount supported file systems for each partition */
for (i = 0; i < count; ++i) {
/* Create logical disk name */
int rv = snprintf( logical_disk_marker, RTEMS_BDPART_NUMBER_SIZE, "%zu", i + 1);
if (rv >= RTEMS_BDPART_NUMBER_SIZE) {
esc = RTEMS_INVALID_NAME;
202414c: 10 80 00 03 b 2024158 <rtems_bdpart_mount+0x160> <== NOT EXECUTED
2024150: b8 10 20 03 mov 3, %i4 <== NOT EXECUTED
/* Create mount point */
strncpy( mount_marker, logical_disk_marker, RTEMS_BDPART_NUMBER_SIZE);
rv = rtems_mkdir( mount_point, S_IRWXU | S_IRWXG | S_IRWXO);
if (rv != 0) {
esc = RTEMS_IO_ERROR;
2024154: b8 10 20 1b mov 0x1b, %i4 <== NOT EXECUTED
}
}
cleanup:
free( logical_disk_name);
2024158: 7f ff 92 a9 call 2008bfc <free> <== NOT EXECUTED
202415c: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
free( mount_point);
2024160: 7f ff 92 a7 call 2008bfc <free> <== NOT EXECUTED
2024164: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
return esc;
}
2024168: 81 c7 e0 08 ret <== NOT EXECUTED
202416c: 91 e8 00 1c restore %g0, %i4, %o0 <== NOT EXECUTED
02024770 <rtems_bdpart_new_record>:
static rtems_status_code rtems_bdpart_new_record(
rtems_disk_device *dd,
rtems_blkdev_bnum index,
rtems_bdbuf_buffer **block
)
{
2024770: 9d e3 bf a0 save %sp, -96, %sp
rtems_status_code sc = RTEMS_SUCCESSFUL;
/* Synchronize previous block if necessary */
if (*block != NULL) {
2024774: d0 06 80 00 ld [ %i2 ], %o0
2024778: 80 a2 20 00 cmp %o0, 0
202477c: 12 80 00 0b bne 20247a8 <rtems_bdpart_new_record+0x38>
2024780: 01 00 00 00 nop
return sc;
}
}
/* Read the new record block (this accounts for disk block sizes > 512) */
sc = rtems_bdbuf_read( dd, index, block);
2024784: 90 10 00 18 mov %i0, %o0
2024788: 92 10 00 19 mov %i1, %o1
202478c: 7f ff 87 bb call 2006678 <rtems_bdbuf_read>
2024790: 94 10 00 1a mov %i2, %o2
if (sc != RTEMS_SUCCESSFUL) {
2024794: ba 92 20 00 orcc %o0, 0, %i5
2024798: 22 80 00 0b be,a 20247c4 <rtems_bdpart_new_record+0x54> <== ALWAYS TAKEN
202479c: c2 06 80 00 ld [ %i2 ], %g1
RTEMS_BDPART_MBR_SIGNATURE_0;
(*block)->buffer [RTEMS_BDPART_MBR_OFFSET_SIGNATURE_1] =
RTEMS_BDPART_MBR_SIGNATURE_1;
return RTEMS_SUCCESSFUL;
}
20247a0: 81 c7 e0 08 ret <== NOT EXECUTED
20247a4: 91 e8 00 1d restore %g0, %i5, %o0 <== NOT EXECUTED
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
/* Synchronize previous block if necessary */
if (*block != NULL) {
sc = rtems_bdbuf_sync( *block);
20247a8: 7f ff 88 84 call 20069b8 <rtems_bdbuf_sync>
20247ac: 01 00 00 00 nop
if (sc != RTEMS_SUCCESSFUL) {
20247b0: ba 92 20 00 orcc %o0, 0, %i5
20247b4: 02 bf ff f5 be 2024788 <rtems_bdpart_new_record+0x18> <== ALWAYS TAKEN
20247b8: 90 10 00 18 mov %i0, %o0
RTEMS_BDPART_MBR_SIGNATURE_0;
(*block)->buffer [RTEMS_BDPART_MBR_OFFSET_SIGNATURE_1] =
RTEMS_BDPART_MBR_SIGNATURE_1;
return RTEMS_SUCCESSFUL;
}
20247bc: 81 c7 e0 08 ret <== NOT EXECUTED
20247c0: 91 e8 00 1d restore %g0, %i5, %o0 <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL) {
return sc;
}
/* just in case block did not get filled in */
if ( *block == NULL ) {
20247c4: 80 a0 60 00 cmp %g1, 0
20247c8: 02 80 00 0e be 2024800 <rtems_bdpart_new_record+0x90> <== NEVER TAKEN
20247cc: 92 10 20 00 clr %o1
return RTEMS_INVALID_ADDRESS;
}
/* Clear record */
memset( (*block)->buffer, 0, RTEMS_BDPART_BLOCK_SIZE);
20247d0: d0 00 60 1c ld [ %g1 + 0x1c ], %o0
20247d4: 40 00 84 54 call 2045924 <memset>
20247d8: 94 10 22 00 mov 0x200, %o2
/* Write signature */
(*block)->buffer [RTEMS_BDPART_MBR_OFFSET_SIGNATURE_0] =
20247dc: c2 06 80 00 ld [ %i2 ], %g1
20247e0: 84 10 20 55 mov 0x55, %g2
20247e4: c2 00 60 1c ld [ %g1 + 0x1c ], %g1
20247e8: c4 28 61 fe stb %g2, [ %g1 + 0x1fe ]
RTEMS_BDPART_MBR_SIGNATURE_0;
(*block)->buffer [RTEMS_BDPART_MBR_OFFSET_SIGNATURE_1] =
20247ec: c2 06 80 00 ld [ %i2 ], %g1
20247f0: 84 10 3f aa mov -86, %g2
20247f4: c2 00 60 1c ld [ %g1 + 0x1c ], %g1
20247f8: 10 80 00 03 b 2024804 <rtems_bdpart_new_record+0x94>
20247fc: c4 28 61 ff stb %g2, [ %g1 + 0x1ff ]
return sc;
}
/* just in case block did not get filled in */
if ( *block == NULL ) {
return RTEMS_INVALID_ADDRESS;
2024800: ba 10 20 09 mov 9, %i5 <== NOT EXECUTED
RTEMS_BDPART_MBR_SIGNATURE_0;
(*block)->buffer [RTEMS_BDPART_MBR_OFFSET_SIGNATURE_1] =
RTEMS_BDPART_MBR_SIGNATURE_1;
return RTEMS_SUCCESSFUL;
}
2024804: b0 10 00 1d mov %i5, %i0
2024808: 81 c7 e0 08 ret
202480c: 81 e8 00 00 restore
020244f0 <rtems_bdpart_read>:
const char *disk_name,
rtems_bdpart_format *format,
rtems_bdpart_partition *pt,
size_t *count
)
{
20244f0: 9d e3 bf 88 save %sp, -120, %sp
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_status_code esc = RTEMS_SUCCESSFUL;
rtems_bdbuf_buffer *block = NULL;
rtems_bdpart_partition *p = pt - 1;
20244f4: 82 06 bf d0 add %i2, -48, %g1
size_t *count
)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_status_code esc = RTEMS_SUCCESSFUL;
rtems_bdbuf_buffer *block = NULL;
20244f8: c0 27 bf e8 clr [ %fp + -24 ]
rtems_bdpart_partition *p = pt - 1;
20244fc: c2 27 bf ec st %g1, [ %fp + -20 ]
const rtems_bdpart_partition *p_end = pt + (count != NULL ? *count : 0);
2024500: 80 a6 e0 00 cmp %i3, 0
2024504: 02 80 00 07 be 2024520 <rtems_bdpart_read+0x30> <== NEVER TAKEN
2024508: 90 10 00 18 mov %i0, %o0
202450c: c2 06 c0 00 ld [ %i3 ], %g1
2024510: 85 28 60 04 sll %g1, 4, %g2
2024514: b9 28 60 06 sll %g1, 6, %i4
2024518: 10 80 00 03 b 2024524 <rtems_bdpart_read+0x34>
202451c: b8 27 00 02 sub %i4, %g2, %i4
2024520: b8 10 20 00 clr %i4 <== NOT EXECUTED
rtems_blkdev_bnum ep_begin = 0; /* Extended partition begin */
rtems_blkdev_bnum ebr = 0; /* Extended boot record block index */
rtems_blkdev_bnum disk_end = 0;
size_t i = 0;
const uint8_t *data = NULL;
int fd = -1;
2024524: 82 10 3f ff mov -1, %g1
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_status_code esc = RTEMS_SUCCESSFUL;
rtems_bdbuf_buffer *block = NULL;
rtems_bdpart_partition *p = pt - 1;
const rtems_bdpart_partition *p_end = pt + (count != NULL ? *count : 0);
rtems_blkdev_bnum ep_begin = 0; /* Extended partition begin */
2024528: c0 27 bf f0 clr [ %fp + -16 ]
rtems_blkdev_bnum ebr = 0; /* Extended boot record block index */
rtems_blkdev_bnum disk_end = 0;
202452c: c0 27 bf f4 clr [ %fp + -12 ]
size_t i = 0;
const uint8_t *data = NULL;
int fd = -1;
2024530: c2 27 bf f8 st %g1, [ %fp + -8 ]
rtems_disk_device *dd = NULL;
2024534: c0 27 bf fc clr [ %fp + -4 ]
/* Check parameter */
if (format == NULL || pt == NULL || count == NULL) {
2024538: 80 a6 a0 00 cmp %i2, 0
202453c: 02 80 00 89 be 2024760 <rtems_bdpart_read+0x270> <== NEVER TAKEN
2024540: b0 10 20 09 mov 9, %i0
2024544: 80 a6 60 00 cmp %i1, 0
2024548: 02 80 00 86 be 2024760 <rtems_bdpart_read+0x270> <== NEVER TAKEN
202454c: 80 a6 e0 00 cmp %i3, 0
2024550: 02 80 00 84 be 2024760 <rtems_bdpart_read+0x270> <== NEVER TAKEN
2024554: 92 07 bf f8 add %fp, -8, %o1
return RTEMS_INVALID_ADDRESS;
}
/* Set count to a save value */
*count = 0;
2024558: c0 26 c0 00 clr [ %i3 ]
/* Get disk data */
sc = rtems_bdpart_get_disk_data( disk_name, &fd, &dd, &disk_end);
202455c: 94 07 bf fc add %fp, -4, %o2
2024560: 7f ff ff bb call 202444c <rtems_bdpart_get_disk_data>
2024564: 96 07 bf f4 add %fp, -12, %o3
if (sc != RTEMS_SUCCESSFUL) {
2024568: b0 92 20 00 orcc %o0, 0, %i0
202456c: 12 80 00 7d bne 2024760 <rtems_bdpart_read+0x270> <== NEVER TAKEN
2024570: d0 07 bf fc ld [ %fp + -4 ], %o0
return sc;
}
/* Read MBR */
sc = rtems_bdpart_read_record( dd, 0, &block);
2024574: 92 10 20 00 clr %o1
2024578: 7f ff ff 4d call 20242ac <rtems_bdpart_read_record>
202457c: 94 07 bf e8 add %fp, -24, %o2
if (sc != RTEMS_SUCCESSFUL) {
2024580: b0 92 20 00 orcc %o0, 0, %i0
2024584: 12 80 00 6c bne 2024734 <rtems_bdpart_read+0x244> <== NEVER TAKEN
2024588: d0 07 bf f8 ld [ %fp + -8 ], %o0
esc = sc;
goto cleanup;
}
/* Read the first partition entry */
data = block->buffer + RTEMS_BDPART_MBR_OFFSET_TABLE_0;
202458c: c2 07 bf e8 ld [ %fp + -24 ], %g1
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_status_code esc = RTEMS_SUCCESSFUL;
rtems_bdbuf_buffer *block = NULL;
rtems_bdpart_partition *p = pt - 1;
const rtems_bdpart_partition *p_end = pt + (count != NULL ? *count : 0);
2024590: b8 06 80 1c add %i2, %i4, %i4
esc = sc;
goto cleanup;
}
/* Read the first partition entry */
data = block->buffer + RTEMS_BDPART_MBR_OFFSET_TABLE_0;
2024594: e4 00 60 1c ld [ %g1 + 0x1c ], %l2
sc = rtems_bdpart_read_mbr_partition( data, &p, p_end, &ep_begin);
2024598: a2 07 bf ec add %fp, -20, %l1
esc = sc;
goto cleanup;
}
/* Read the first partition entry */
data = block->buffer + RTEMS_BDPART_MBR_OFFSET_TABLE_0;
202459c: ba 04 a1 be add %l2, 0x1be, %i5
sc = rtems_bdpart_read_mbr_partition( data, &p, p_end, &ep_begin);
20245a0: a0 07 bf f0 add %fp, -16, %l0
20245a4: 90 10 00 1d mov %i5, %o0
20245a8: 92 10 00 11 mov %l1, %o1
20245ac: 94 10 00 1c mov %i4, %o2
20245b0: 7f ff ff 70 call 2024370 <rtems_bdpart_read_mbr_partition>
20245b4: 96 10 00 10 mov %l0, %o3
if (sc != RTEMS_SUCCESSFUL) {
20245b8: b0 92 20 00 orcc %o0, 0, %i0
20245bc: 32 80 00 5e bne,a 2024734 <rtems_bdpart_read+0x244> <== NEVER TAKEN
20245c0: d0 07 bf f8 ld [ %fp + -8 ], %o0 <== NOT EXECUTED
esc = sc;
goto cleanup;
}
/* Determine if we have a MBR or GPT format */
if (rtems_bdpart_mbr_partition_type( p->type) == RTEMS_BDPART_MBR_GPT) {
20245c4: c2 07 bf ec ld [ %fp + -20 ], %g1
20245c8: c2 08 60 08 ldub [ %g1 + 8 ], %g1
20245cc: 80 a0 60 ee cmp %g1, 0xee
20245d0: 02 80 00 58 be 2024730 <rtems_bdpart_read+0x240> <== NEVER TAKEN
20245d4: b0 10 20 18 mov 0x18, %i0
}
/* Set format */
format->type = RTEMS_BDPART_FORMAT_MBR;
format->mbr.disk_id = rtems_uint32_from_little_endian(
block->buffer + RTEMS_BDPART_MBR_OFFSET_DISK_ID
20245d8: c2 07 bf e8 ld [ %fp + -24 ], %g1
esc = RTEMS_NOT_IMPLEMENTED;
goto cleanup;
}
/* Set format */
format->type = RTEMS_BDPART_FORMAT_MBR;
20245dc: c0 26 40 00 clr [ %i1 ]
format->mbr.disk_id = rtems_uint32_from_little_endian(
20245e0: d0 00 60 1c ld [ %g1 + 0x1c ], %o0
}
return RTEMS_SUCCESSFUL;
}
rtems_status_code rtems_bdpart_read(
20245e4: a4 04 a1 ee add %l2, 0x1ee, %l2
goto cleanup;
}
/* Set format */
format->type = RTEMS_BDPART_FORMAT_MBR;
format->mbr.disk_id = rtems_uint32_from_little_endian(
20245e8: 7f ff ff 26 call 2024280 <rtems_uint32_from_little_endian>
20245ec: 90 02 21 b8 add %o0, 0x1b8, %o0
block->buffer + RTEMS_BDPART_MBR_OFFSET_DISK_ID
);
format->mbr.dos_compatibility = true;
20245f0: 82 10 20 01 mov 1, %g1
goto cleanup;
}
/* Set format */
format->type = RTEMS_BDPART_FORMAT_MBR;
format->mbr.disk_id = rtems_uint32_from_little_endian(
20245f4: d0 26 60 04 st %o0, [ %i1 + 4 ]
block->buffer + RTEMS_BDPART_MBR_OFFSET_DISK_ID
);
format->mbr.dos_compatibility = true;
20245f8: c2 2e 60 08 stb %g1, [ %i1 + 8 ]
/* Iterate through the rest of the primary partition table */
for (i = 1; i < 4; ++i) {
data += RTEMS_BDPART_MBR_TABLE_ENTRY_SIZE;
20245fc: ba 07 60 10 add %i5, 0x10, %i5
sc = rtems_bdpart_read_mbr_partition( data, &p, p_end, &ep_begin);
2024600: 92 10 00 11 mov %l1, %o1
2024604: 90 10 00 1d mov %i5, %o0
2024608: 94 10 00 1c mov %i4, %o2
202460c: 7f ff ff 59 call 2024370 <rtems_bdpart_read_mbr_partition>
2024610: 96 10 00 10 mov %l0, %o3
if (sc != RTEMS_SUCCESSFUL) {
2024614: 80 a2 20 00 cmp %o0, 0
2024618: 12 80 00 45 bne 202472c <rtems_bdpart_read+0x23c> <== NEVER TAKEN
202461c: 80 a7 40 12 cmp %i5, %l2
block->buffer + RTEMS_BDPART_MBR_OFFSET_DISK_ID
);
format->mbr.dos_compatibility = true;
/* Iterate through the rest of the primary partition table */
for (i = 1; i < 4; ++i) {
2024620: 32 bf ff f8 bne,a 2024600 <rtems_bdpart_read+0x110>
2024624: ba 07 60 10 add %i5, 0x10, %i5
}
}
/* Iterate through the logical partitions within the extended partition */
ebr = ep_begin;
while (ebr != 0) {
2024628: 10 80 00 2e b 20246e0 <rtems_bdpart_read+0x1f0>
202462c: fa 07 bf f0 ld [ %fp + -16 ], %i5
rtems_blkdev_bnum tmp = 0;
/* Read EBR */
sc = rtems_bdpart_read_record( dd, ebr, &block);
2024630: 92 10 00 1d mov %i5, %o1
2024634: 7f ff ff 1e call 20242ac <rtems_bdpart_read_record>
2024638: 94 07 bf e8 add %fp, -24, %o2
if (sc != RTEMS_SUCCESSFUL) {
202463c: 80 a2 20 00 cmp %o0, 0
2024640: 12 80 00 3b bne 202472c <rtems_bdpart_read+0x23c> <== NEVER TAKEN
2024644: c2 07 bf e8 ld [ %fp + -24 ], %g1
esc = sc;
goto cleanup;
}
/* Read first partition entry */
sc = rtems_bdpart_read_mbr_partition(
2024648: 92 10 00 11 mov %l1, %o1
202464c: d0 00 60 1c ld [ %g1 + 0x1c ], %o0
2024650: 94 10 00 1c mov %i4, %o2
2024654: 90 02 21 be add %o0, 0x1be, %o0
2024658: 7f ff ff 46 call 2024370 <rtems_bdpart_read_mbr_partition>
202465c: 96 10 20 00 clr %o3
block->buffer + RTEMS_BDPART_MBR_OFFSET_TABLE_0,
&p,
p_end,
NULL
);
if (sc != RTEMS_SUCCESSFUL) {
2024660: 80 a2 20 00 cmp %o0, 0
2024664: 12 80 00 32 bne 202472c <rtems_bdpart_read+0x23c> <== NEVER TAKEN
2024668: c2 07 bf ec ld [ %fp + -20 ], %g1
esc = sc;
goto cleanup;
}
/* Adjust partition begin */
tmp = p->begin + ebr;
202466c: c6 00 40 00 ld [ %g1 ], %g3
2024670: 84 07 40 03 add %i5, %g3, %g2
if (tmp > p->begin) {
2024674: 80 a0 80 03 cmp %g2, %g3
2024678: 38 80 00 04 bgu,a 2024688 <rtems_bdpart_read+0x198> <== ALWAYS TAKEN
202467c: c4 20 40 00 st %g2, [ %g1 ]
p->begin = tmp;
} else {
esc = RTEMS_IO_ERROR;
2024680: 10 80 00 2c b 2024730 <rtems_bdpart_read+0x240> <== NOT EXECUTED
2024684: b0 10 20 1b mov 0x1b, %i0 <== NOT EXECUTED
goto cleanup;
}
/* Adjust partition end */
tmp = p->end + ebr;
2024688: c4 00 60 04 ld [ %g1 + 4 ], %g2
202468c: ba 07 40 02 add %i5, %g2, %i5
if (tmp > p->end) {
2024690: 80 a7 40 02 cmp %i5, %g2
2024694: 08 80 00 27 bleu 2024730 <rtems_bdpart_read+0x240> <== NEVER TAKEN
2024698: b0 10 20 1b mov 0x1b, %i0
p->end = tmp;
202469c: fa 20 60 04 st %i5, [ %g1 + 4 ]
goto cleanup;
}
/* Read second partition entry for next EBR block */
ebr = rtems_bdpart_next_ebr(
block->buffer + RTEMS_BDPART_MBR_OFFSET_TABLE_1
20246a0: c2 07 bf e8 ld [ %fp + -24 ], %g1
20246a4: f2 00 60 1c ld [ %g1 + 0x1c ], %i1
== RTEMS_BDPART_MBR_SIGNATURE_1;
}
static rtems_blkdev_bnum rtems_bdpart_next_ebr( const uint8_t *data)
{
rtems_blkdev_bnum begin =
20246a8: 7f ff fe f6 call 2024280 <rtems_uint32_from_little_endian>
20246ac: 90 06 61 d6 add %i1, 0x1d6, %o0
rtems_uint32_from_little_endian( data + RTEMS_BDPART_MBR_OFFSET_BEGIN);
uint8_t type = data [RTEMS_BDPART_MBR_OFFSET_TYPE];
if (type == RTEMS_BDPART_MBR_EXTENDED) {
20246b0: c2 0e 61 d2 ldub [ %i1 + 0x1d2 ], %g1
20246b4: 80 a0 60 05 cmp %g1, 5
20246b8: 12 80 00 0e bne 20246f0 <rtems_bdpart_read+0x200>
20246bc: c2 07 bf ec ld [ %fp + -20 ], %g1
/* Read second partition entry for next EBR block */
ebr = rtems_bdpart_next_ebr(
block->buffer + RTEMS_BDPART_MBR_OFFSET_TABLE_1
);
if (ebr != 0) {
20246c0: 80 a2 20 00 cmp %o0, 0
20246c4: 02 80 00 0a be 20246ec <rtems_bdpart_read+0x1fc> <== NEVER TAKEN
20246c8: c2 07 bf f0 ld [ %fp + -16 ], %g1
/* Adjust partition EBR block index */
tmp = ebr + ep_begin;
20246cc: 82 02 00 01 add %o0, %g1, %g1
if (tmp > ebr) {
20246d0: 80 a0 40 08 cmp %g1, %o0
20246d4: 08 80 00 17 bleu 2024730 <rtems_bdpart_read+0x240> <== NEVER TAKEN
20246d8: b0 10 20 1b mov 0x1b, %i0
20246dc: ba 10 00 01 mov %g1, %i5
}
}
/* Iterate through the logical partitions within the extended partition */
ebr = ep_begin;
while (ebr != 0) {
20246e0: 80 a7 60 00 cmp %i5, 0
20246e4: 12 bf ff d3 bne 2024630 <rtems_bdpart_read+0x140> <== ALWAYS TAKEN
20246e8: d0 07 bf fc ld [ %fp + -4 ], %o0
}
}
}
/* Return partition count */
*count = (size_t) (p - pt + 1);
20246ec: c2 07 bf ec ld [ %fp + -20 ], %g1 <== NOT EXECUTED
rtems_bdpart_partition *pt,
size_t *count
)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_status_code esc = RTEMS_SUCCESSFUL;
20246f0: b0 10 20 00 clr %i0
}
}
}
/* Return partition count */
*count = (size_t) (p - pt + 1);
20246f4: b4 20 40 1a sub %g1, %i2, %i2
20246f8: b5 3e a0 04 sra %i2, 4, %i2
20246fc: 83 2e a0 02 sll %i2, 2, %g1
2024700: 82 00 40 1a add %g1, %i2, %g1
2024704: 85 28 60 04 sll %g1, 4, %g2
2024708: 82 00 40 02 add %g1, %g2, %g1
202470c: 85 28 60 08 sll %g1, 8, %g2
2024710: 82 00 40 02 add %g1, %g2, %g1
2024714: 85 28 60 10 sll %g1, 0x10, %g2
2024718: 82 00 40 02 add %g1, %g2, %g1
202471c: 82 20 00 01 neg %g1
2024720: 82 00 60 01 inc %g1
2024724: 10 80 00 03 b 2024730 <rtems_bdpart_read+0x240>
2024728: c2 26 c0 00 st %g1, [ %i3 ]
esc = sc;
goto cleanup;
}
/* Read first partition entry */
sc = rtems_bdpart_read_mbr_partition(
202472c: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED
/* Return partition count */
*count = (size_t) (p - pt + 1);
cleanup:
if (fd >= 0) {
2024730: d0 07 bf f8 ld [ %fp + -8 ], %o0
2024734: 80 a2 20 00 cmp %o0, 0
2024738: 26 80 00 05 bl,a 202474c <rtems_bdpart_read+0x25c> <== NEVER TAKEN
202473c: d0 07 bf e8 ld [ %fp + -24 ], %o0 <== NOT EXECUTED
close( fd);
2024740: 7f ff 90 71 call 2008904 <close>
2024744: 01 00 00 00 nop
}
if (block != NULL) {
2024748: d0 07 bf e8 ld [ %fp + -24 ], %o0
202474c: 80 a2 20 00 cmp %o0, 0
2024750: 02 80 00 06 be 2024768 <rtems_bdpart_read+0x278> <== NEVER TAKEN
2024754: 01 00 00 00 nop
rtems_bdbuf_release( block);
2024758: 7f ff 88 45 call 200686c <rtems_bdbuf_release>
202475c: 01 00 00 00 nop
2024760: 81 c7 e0 08 ret
2024764: 81 e8 00 00 restore
}
return esc;
}
2024768: 81 c7 e0 08 ret <== NOT EXECUTED
202476c: 81 e8 00 00 restore <== NOT EXECUTED
02024370 <rtems_bdpart_read_mbr_partition>:
const uint8_t *data,
rtems_bdpart_partition **p,
const rtems_bdpart_partition *p_end,
rtems_blkdev_bnum *ep_begin
)
{
2024370: 9d e3 bf a0 save %sp, -96, %sp
rtems_blkdev_bnum begin =
2024374: 7f ff ff c3 call 2024280 <rtems_uint32_from_little_endian>
2024378: 90 06 20 08 add %i0, 8, %o0
202437c: ba 10 00 08 mov %o0, %i5
rtems_uint32_from_little_endian( data + RTEMS_BDPART_MBR_OFFSET_BEGIN);
rtems_blkdev_bnum size =
2024380: 7f ff ff c0 call 2024280 <rtems_uint32_from_little_endian>
2024384: 90 06 20 0c add %i0, 0xc, %o0
rtems_uint32_from_little_endian( data + RTEMS_BDPART_MBR_OFFSET_SIZE);
rtems_blkdev_bnum end = begin + size;
uint8_t type = data [RTEMS_BDPART_MBR_OFFSET_TYPE];
if (type == RTEMS_BDPART_MBR_EMPTY) {
2024388: f8 0e 20 04 ldub [ %i0 + 4 ], %i4
202438c: 80 a7 20 00 cmp %i4, 0
2024390: 02 80 00 21 be 2024414 <rtems_bdpart_read_mbr_partition+0xa4><== NEVER TAKEN
2024394: 82 10 20 00 clr %g1
return RTEMS_SUCCESSFUL;
} else if (*p == p_end) {
2024398: c4 06 40 00 ld [ %i1 ], %g2
202439c: 80 a0 80 1a cmp %g2, %i2
20243a0: 02 80 00 1d be 2024414 <rtems_bdpart_read_mbr_partition+0xa4><== NEVER TAKEN
20243a4: 82 10 20 05 mov 5, %g1
{
rtems_blkdev_bnum begin =
rtems_uint32_from_little_endian( data + RTEMS_BDPART_MBR_OFFSET_BEGIN);
rtems_blkdev_bnum size =
rtems_uint32_from_little_endian( data + RTEMS_BDPART_MBR_OFFSET_SIZE);
rtems_blkdev_bnum end = begin + size;
20243a8: b4 02 00 1d add %o0, %i5, %i2
if (type == RTEMS_BDPART_MBR_EMPTY) {
return RTEMS_SUCCESSFUL;
} else if (*p == p_end) {
return RTEMS_TOO_MANY;
} else if (begin >= end) {
20243ac: 80 a7 40 1a cmp %i5, %i2
20243b0: 1a 80 00 19 bcc 2024414 <rtems_bdpart_read_mbr_partition+0xa4><== NEVER TAKEN
20243b4: 82 10 20 1b mov 0x1b, %g1
return RTEMS_IO_ERROR;
} else if (type == RTEMS_BDPART_MBR_EXTENDED) {
20243b8: 80 a7 20 05 cmp %i4, 5
20243bc: 32 80 00 07 bne,a 20243d8 <rtems_bdpart_read_mbr_partition+0x68>
20243c0: 90 00 a0 30 add %g2, 0x30, %o0
if (ep_begin != NULL) {
20243c4: 80 a6 e0 00 cmp %i3, 0
20243c8: 32 80 00 12 bne,a 2024410 <rtems_bdpart_read_mbr_partition+0xa0><== ALWAYS TAKEN
20243cc: fa 26 c0 00 st %i5, [ %i3 ]
rtems_uint32_from_little_endian( data + RTEMS_BDPART_MBR_OFFSET_SIZE);
rtems_blkdev_bnum end = begin + size;
uint8_t type = data [RTEMS_BDPART_MBR_OFFSET_TYPE];
if (type == RTEMS_BDPART_MBR_EMPTY) {
return RTEMS_SUCCESSFUL;
20243d0: 10 80 00 11 b 2024414 <rtems_bdpart_read_mbr_partition+0xa4><== NOT EXECUTED
20243d4: 82 10 20 00 clr %g1 <== NOT EXECUTED
} else {
/* Increment partition index */
++(*p);
/* Clear partition */
memset( *p, 0, sizeof( rtems_bdpart_partition));
20243d8: 92 10 20 00 clr %o1
20243dc: 94 10 20 30 mov 0x30, %o2
20243e0: 40 00 85 51 call 2045924 <memset>
20243e4: d0 26 40 00 st %o0, [ %i1 ]
/* Set values */
(*p)->begin = begin;
20243e8: d2 06 40 00 ld [ %i1 ], %o1
(*p)->end = end;
rtems_bdpart_to_partition_type( type, (*p)->type);
20243ec: 90 10 00 1c mov %i4, %o0
/* Clear partition */
memset( *p, 0, sizeof( rtems_bdpart_partition));
/* Set values */
(*p)->begin = begin;
20243f0: fa 22 40 00 st %i5, [ %o1 ]
(*p)->end = end;
20243f4: f4 22 60 04 st %i2, [ %o1 + 4 ]
rtems_bdpart_to_partition_type( type, (*p)->type);
20243f8: 7f ff ff d6 call 2024350 <rtems_bdpart_to_partition_type>
20243fc: 92 02 60 08 add %o1, 8, %o1
(*p)->flags = data [RTEMS_BDPART_MBR_OFFSET_FLAGS];
2024400: c2 06 40 00 ld [ %i1 ], %g1
2024404: c4 0e 00 00 ldub [ %i0 ], %g2
2024408: c0 20 60 28 clr [ %g1 + 0x28 ]
202440c: c4 20 60 2c st %g2, [ %g1 + 0x2c ]
rtems_uint32_from_little_endian( data + RTEMS_BDPART_MBR_OFFSET_SIZE);
rtems_blkdev_bnum end = begin + size;
uint8_t type = data [RTEMS_BDPART_MBR_OFFSET_TYPE];
if (type == RTEMS_BDPART_MBR_EMPTY) {
return RTEMS_SUCCESSFUL;
2024410: 82 10 20 00 clr %g1
rtems_bdpart_to_partition_type( type, (*p)->type);
(*p)->flags = data [RTEMS_BDPART_MBR_OFFSET_FLAGS];
}
return RTEMS_SUCCESSFUL;
}
2024414: 81 c7 e0 08 ret
2024418: 91 e8 00 01 restore %g0, %g1, %o0
020242ac <rtems_bdpart_read_record>:
static rtems_status_code rtems_bdpart_read_record(
rtems_disk_device *dd,
rtems_blkdev_bnum index,
rtems_bdbuf_buffer **block
)
{
20242ac: 9d e3 bf a0 save %sp, -96, %sp
rtems_status_code sc = RTEMS_SUCCESSFUL;
/* Release previous block if necessary */
if (*block != NULL) {
20242b0: d0 06 80 00 ld [ %i2 ], %o0
20242b4: 80 a2 20 00 cmp %o0, 0
20242b8: 12 80 00 0b bne 20242e4 <rtems_bdpart_read_record+0x38>
20242bc: 01 00 00 00 nop
return sc;
}
}
/* Read the record block */
sc = rtems_bdbuf_read( dd, index, block);
20242c0: 90 10 00 18 mov %i0, %o0
20242c4: 92 10 00 19 mov %i1, %o1
20242c8: 7f ff 88 ec call 2006678 <rtems_bdbuf_read>
20242cc: 94 10 00 1a mov %i2, %o2
if (sc != RTEMS_SUCCESSFUL) {
20242d0: 80 a2 20 00 cmp %o0, 0
20242d4: 22 80 00 0b be,a 2024300 <rtems_bdpart_read_record+0x54> <== ALWAYS TAKEN
20242d8: c2 06 80 00 ld [ %i2 ], %g1
if (!rtems_bdpart_is_valid_record( (*block)->buffer)) {
return RTEMS_IO_ERROR;
}
return RTEMS_SUCCESSFUL;
}
20242dc: 81 c7 e0 08 ret <== NOT EXECUTED
20242e0: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
/* Release previous block if necessary */
if (*block != NULL) {
sc = rtems_bdbuf_release( *block);
20242e4: 7f ff 89 62 call 200686c <rtems_bdbuf_release>
20242e8: 01 00 00 00 nop
if (sc != RTEMS_SUCCESSFUL) {
20242ec: 80 a2 20 00 cmp %o0, 0
20242f0: 22 bf ff f5 be,a 20242c4 <rtems_bdpart_read_record+0x18> <== ALWAYS TAKEN
20242f4: 90 10 00 18 mov %i0, %o0
if (!rtems_bdpart_is_valid_record( (*block)->buffer)) {
return RTEMS_IO_ERROR;
}
return RTEMS_SUCCESSFUL;
}
20242f8: 81 c7 e0 08 ret <== NOT EXECUTED
20242fc: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL) {
return sc;
}
/* just in case block did not get filled in */
if ( *block == NULL ) {
2024300: 80 a0 60 00 cmp %g1, 0
2024304: 22 80 00 10 be,a 2024344 <rtems_bdpart_read_record+0x98> <== NEVER TAKEN
2024308: 90 10 20 09 mov 9, %o0 <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
}
/* Check MBR signature */
if (!rtems_bdpart_is_valid_record( (*block)->buffer)) {
202430c: c4 00 60 1c ld [ %g1 + 0x1c ], %g2
static bool rtems_bdpart_is_valid_record( const uint8_t *data)
{
return data [RTEMS_BDPART_MBR_OFFSET_SIGNATURE_0]
== RTEMS_BDPART_MBR_SIGNATURE_0
&& data [RTEMS_BDPART_MBR_OFFSET_SIGNATURE_1]
2024310: c6 08 a1 fe ldub [ %g2 + 0x1fe ], %g3
2024314: 80 a0 e0 55 cmp %g3, 0x55
2024318: 12 80 00 06 bne 2024330 <rtems_bdpart_read_record+0x84> <== NEVER TAKEN
202431c: 82 10 20 00 clr %g1
2024320: c2 08 a1 ff ldub [ %g2 + 0x1ff ], %g1
2024324: 82 18 60 aa xor %g1, 0xaa, %g1
2024328: 80 a0 00 01 cmp %g0, %g1
202432c: 82 60 3f ff subx %g0, -1, %g1
if ( *block == NULL ) {
return RTEMS_INVALID_ADDRESS;
}
/* Check MBR signature */
if (!rtems_bdpart_is_valid_record( (*block)->buffer)) {
2024330: 80 a0 60 00 cmp %g1, 0
2024334: 22 80 00 04 be,a 2024344 <rtems_bdpart_read_record+0x98> <== NEVER TAKEN
2024338: 90 10 20 1b mov 0x1b, %o0 <== NOT EXECUTED
return RTEMS_IO_ERROR;
}
return RTEMS_SUCCESSFUL;
}
202433c: 81 c7 e0 08 ret
2024340: 91 e8 00 08 restore %g0, %o0, %o0
2024344: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED
2024348: 81 c7 e0 08 ret <== NOT EXECUTED
202434c: 81 e8 00 00 restore <== NOT EXECUTED
02006e40 <rtems_bdpart_register>:
rtems_status_code rtems_bdpart_register(
const char *disk_name,
const rtems_bdpart_partition *pt,
size_t count
)
{
2006e40: 9d e3 bf 88 save %sp, -120, %sp
rtems_blkdev_bnum disk_end = 0;
dev_t disk = 0;
dev_t logical_disk = 0;
char *logical_disk_name = NULL;
char *logical_disk_marker = NULL;
size_t disk_name_size = strlen( disk_name);
2006e44: 90 10 00 18 mov %i0, %o0
2006e48: 40 01 08 ce call 2049180 <strlen>
2006e4c: c0 27 bf f4 clr [ %fp + -12 ]
size_t i = 0;
int fd = -1;
2006e50: 82 10 3f ff mov -1, %g1
rtems_status_code rtems_bdpart_register(
const char *disk_name,
const rtems_bdpart_partition *pt,
size_t count
)
{
2006e54: ba 10 00 18 mov %i0, %i5
rtems_blkdev_bnum disk_end = 0;
dev_t disk = 0;
dev_t logical_disk = 0;
char *logical_disk_name = NULL;
char *logical_disk_marker = NULL;
size_t disk_name_size = strlen( disk_name);
2006e58: a0 10 00 08 mov %o0, %l0
size_t i = 0;
int fd = -1;
2006e5c: c2 27 bf f8 st %g1, [ %fp + -8 ]
rtems_disk_device *dd = NULL;
/* Get disk data */
sc = rtems_bdpart_get_disk_data( disk_name, &fd, &dd, &disk_end);
2006e60: 90 10 00 18 mov %i0, %o0
char *logical_disk_name = NULL;
char *logical_disk_marker = NULL;
size_t disk_name_size = strlen( disk_name);
size_t i = 0;
int fd = -1;
rtems_disk_device *dd = NULL;
2006e64: c0 27 bf fc clr [ %fp + -4 ]
/* Get disk data */
sc = rtems_bdpart_get_disk_data( disk_name, &fd, &dd, &disk_end);
2006e68: 92 07 bf f8 add %fp, -8, %o1
2006e6c: 94 07 bf fc add %fp, -4, %o2
2006e70: 40 00 75 77 call 202444c <rtems_bdpart_get_disk_data>
2006e74: 96 07 bf f4 add %fp, -12, %o3
if (sc != RTEMS_SUCCESSFUL) {
2006e78: b0 92 20 00 orcc %o0, 0, %i0
2006e7c: 12 80 00 31 bne 2006f40 <rtems_bdpart_register+0x100> <== NEVER TAKEN
2006e80: c2 07 bf fc ld [ %fp + -4 ], %g1
return sc;
}
disk = rtems_disk_get_device_identifier( dd);
close( fd);
2006e84: d0 07 bf f8 ld [ %fp + -8 ], %o0
static inline dev_t rtems_disk_get_device_identifier(
const rtems_disk_device *dd
)
{
return dd->dev;
2006e88: e2 00 40 00 ld [ %g1 ], %l1
2006e8c: 40 00 06 9e call 2008904 <close>
2006e90: f6 00 60 04 ld [ %g1 + 4 ], %i3
/* Get the disk device identifier */
rtems_filesystem_split_dev_t( disk, major, minor);
/* Create logical disk name */
logical_disk_name = malloc( disk_name_size + RTEMS_BDPART_NUMBER_SIZE);
2006e94: 90 04 20 04 add %l0, 4, %o0
2006e98: 40 00 08 b7 call 2009174 <malloc>
2006e9c: b0 10 20 1a mov 0x1a, %i0
if (logical_disk_name == NULL) {
2006ea0: 80 a2 20 00 cmp %o0, 0
2006ea4: 02 80 00 27 be 2006f40 <rtems_bdpart_register+0x100> <== NEVER TAKEN
2006ea8: b8 10 00 08 mov %o0, %i4
return RTEMS_NO_MEMORY;
}
strncpy( logical_disk_name, disk_name, disk_name_size);
2006eac: 92 10 00 1d mov %i5, %o1
2006eb0: 94 10 00 10 mov %l0, %o2
2006eb4: 40 01 09 6f call 2049470 <strncpy>
2006eb8: 25 00 81 95 sethi %hi(0x2065400), %l2
logical_disk_marker = logical_disk_name + disk_name_size;
2006ebc: a0 07 00 10 add %i4, %l0, %l0
#include <string.h>
#include <rtems.h>
#include <rtems/bdpart.h>
rtems_status_code rtems_bdpart_register(
2006ec0: b4 06 80 1b add %i2, %i3, %i2
}
disk = rtems_disk_get_device_identifier( dd);
close( fd);
/* Get the disk device identifier */
rtems_filesystem_split_dev_t( disk, major, minor);
2006ec4: ba 10 00 1b mov %i3, %i5
}
strncpy( logical_disk_name, disk_name, disk_name_size);
logical_disk_marker = logical_disk_name + disk_name_size;
/* Create a logical disk for each partition */
for (i = 0; i < count; ++i) {
2006ec8: 10 80 00 16 b 2006f20 <rtems_bdpart_register+0xe0>
2006ecc: a4 14 a3 48 or %l2, 0x348, %l2
/* Create a new device identifier */
logical_disk = rtems_filesystem_make_dev_t( major, minor);
/* Set partition number for logical disk name */
rv = snprintf( logical_disk_marker, RTEMS_BDPART_NUMBER_SIZE, "%zu", i + 1);
2006ed0: 90 10 00 10 mov %l0, %o0
2006ed4: 92 10 20 04 mov 4, %o1
2006ed8: 94 10 00 12 mov %l2, %o2
2006edc: 40 01 05 0b call 2048308 <snprintf>
2006ee0: 96 27 40 1b sub %i5, %i3, %o3
if (rv >= RTEMS_BDPART_NUMBER_SIZE) {
2006ee4: 80 a2 20 03 cmp %o0, 3
2006ee8: 14 80 00 13 bg 2006f34 <rtems_bdpart_register+0xf4> <== NEVER TAKEN
2006eec: 90 10 00 11 mov %l1, %o0
esc = RTEMS_INVALID_NAME;
goto cleanup;
}
/* Create logical disk */
sc = rtems_disk_create_log(
2006ef0: da 06 60 04 ld [ %i1 + 4 ], %o5
logical_disk,
disk,
p->begin,
p->end - p->begin,
2006ef4: d8 06 40 00 ld [ %i1 ], %o4
esc = RTEMS_INVALID_NAME;
goto cleanup;
}
/* Create logical disk */
sc = rtems_disk_create_log(
2006ef8: f8 23 a0 5c st %i4, [ %sp + 0x5c ]
2006efc: 92 10 00 1d mov %i5, %o1
2006f00: 94 10 00 11 mov %l1, %o2
2006f04: 96 10 00 1b mov %i3, %o3
2006f08: 9a 23 40 0c sub %o5, %o4, %o5
2006f0c: 40 00 03 1a call 2007b74 <rtems_disk_create_log>
2006f10: b2 06 60 30 add %i1, 0x30, %i1
disk,
p->begin,
p->end - p->begin,
logical_disk_name
);
if (sc != RTEMS_SUCCESSFUL) {
2006f14: 80 a2 20 00 cmp %o0, 0
2006f18: 12 80 00 08 bne 2006f38 <rtems_bdpart_register+0xf8> <== NEVER TAKEN
2006f1c: b0 10 00 08 mov %o0, %i0
}
strncpy( logical_disk_name, disk_name, disk_name_size);
logical_disk_marker = logical_disk_name + disk_name_size;
/* Create a logical disk for each partition */
for (i = 0; i < count; ++i) {
2006f20: 80 a7 40 1a cmp %i5, %i2
2006f24: 32 bf ff eb bne,a 2006ed0 <rtems_bdpart_register+0x90>
2006f28: ba 07 60 01 inc %i5
const rtems_bdpart_partition *pt,
size_t count
)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_status_code esc = RTEMS_SUCCESSFUL;
2006f2c: 10 80 00 03 b 2006f38 <rtems_bdpart_register+0xf8>
2006f30: b0 10 20 00 clr %i0
2006f34: b0 10 20 03 mov 3, %i0 <== NOT EXECUTED
}
}
cleanup:
free( logical_disk_name);
2006f38: 40 00 07 31 call 2008bfc <free>
2006f3c: 90 10 00 1c mov %i4, %o0
return esc;
}
2006f40: 81 c7 e0 08 ret
2006f44: 81 e8 00 00 restore
02006f48 <rtems_bdpart_register_from_disk>:
rtems_status_code rtems_bdpart_register_from_disk( const char *disk_name)
{
2006f48: 9d e3 bc 88 save %sp, -888, %sp
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_bdpart_format format;
rtems_bdpart_partition pt [RTEMS_BDPART_PARTITION_NUMBER_HINT];
size_t count = RTEMS_BDPART_PARTITION_NUMBER_HINT;
2006f4c: 82 10 20 10 mov 0x10, %g1
/* Read partitions */
sc = rtems_bdpart_read( disk_name, &format, pt, &count);
2006f50: 90 10 00 18 mov %i0, %o0
rtems_status_code rtems_bdpart_register_from_disk( const char *disk_name)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_bdpart_format format;
rtems_bdpart_partition pt [RTEMS_BDPART_PARTITION_NUMBER_HINT];
size_t count = RTEMS_BDPART_PARTITION_NUMBER_HINT;
2006f54: c2 27 bc e8 st %g1, [ %fp + -792 ]
/* Read partitions */
sc = rtems_bdpart_read( disk_name, &format, pt, &count);
2006f58: 92 07 bc ec add %fp, -788, %o1
2006f5c: 94 07 bd 00 add %fp, -768, %o2
2006f60: 40 00 75 64 call 20244f0 <rtems_bdpart_read>
2006f64: 96 07 bc e8 add %fp, -792, %o3
if (sc != RTEMS_SUCCESSFUL) {
2006f68: 80 a2 20 00 cmp %o0, 0
2006f6c: 12 80 00 05 bne 2006f80 <rtems_bdpart_register_from_disk+0x38><== NEVER TAKEN
2006f70: d4 07 bc e8 ld [ %fp + -792 ], %o2
return sc;
}
/* Register partitions */
return rtems_bdpart_register( disk_name, pt, count);
2006f74: 90 10 00 18 mov %i0, %o0
2006f78: 7f ff ff b2 call 2006e40 <rtems_bdpart_register>
2006f7c: 92 07 bd 00 add %fp, -768, %o1
}
2006f80: 81 c7 e0 08 ret
2006f84: 91 e8 00 08 restore %g0, %o0, %o0
02024170 <rtems_bdpart_unmount>:
const char *disk_name,
const rtems_bdpart_partition *pt __attribute__((unused)),
size_t count,
const char *mount_base
)
{
2024170: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED
rtems_status_code esc = RTEMS_SUCCESSFUL;
const char *disk_file_name = strrchr( disk_name, '/');
2024174: 92 10 20 2f mov 0x2f, %o1 <== NOT EXECUTED
2024178: 40 00 98 24 call 204a208 <strrchr> <== NOT EXECUTED
202417c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
2024180: b2 10 00 08 mov %o0, %i1 <== NOT EXECUTED
char *mount_point = NULL;
char *mount_marker = NULL;
size_t disk_file_name_size = 0;
size_t disk_name_size = strlen( disk_name);
2024184: 40 00 93 ff call 2049180 <strlen> <== NOT EXECUTED
2024188: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
202418c: a0 10 00 08 mov %o0, %l0 <== NOT EXECUTED
size_t mount_base_size = strlen( mount_base);
2024190: 40 00 93 fc call 2049180 <strlen> <== NOT EXECUTED
2024194: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
size_t i = 0;
/* Get disk file name */
if (disk_file_name != NULL) {
2024198: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED
202419c: 02 80 00 07 be 20241b8 <rtems_bdpart_unmount+0x48> <== NOT EXECUTED
20241a0: b8 10 00 08 mov %o0, %i4 <== NOT EXECUTED
disk_file_name += 1;
20241a4: b2 06 60 01 inc %i1 <== NOT EXECUTED
disk_file_name_size = strlen( disk_file_name);
20241a8: 40 00 93 f6 call 2049180 <strlen> <== NOT EXECUTED
20241ac: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
20241b0: 10 80 00 03 b 20241bc <rtems_bdpart_unmount+0x4c> <== NOT EXECUTED
20241b4: a0 10 00 08 mov %o0, %l0 <== NOT EXECUTED
} else {
disk_file_name = disk_name;
20241b8: b2 10 00 18 mov %i0, %i1 <== NOT EXECUTED
disk_file_name_size = disk_name_size;
}
/* Create mount point base */
mount_point = malloc( mount_base_size + 1 + disk_file_name_size + RTEMS_BDPART_NUMBER_SIZE);
20241bc: a2 04 00 1c add %l0, %i4, %l1 <== NOT EXECUTED
if (mount_point == NULL) {
esc = RTEMS_NO_MEMORY;
20241c0: b0 10 20 1a mov 0x1a, %i0 <== NOT EXECUTED
disk_file_name = disk_name;
disk_file_name_size = disk_name_size;
}
/* Create mount point base */
mount_point = malloc( mount_base_size + 1 + disk_file_name_size + RTEMS_BDPART_NUMBER_SIZE);
20241c4: 7f ff 93 ec call 2009174 <malloc> <== NOT EXECUTED
20241c8: 90 04 60 05 add %l1, 5, %o0 <== NOT EXECUTED
if (mount_point == NULL) {
20241cc: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
20241d0: 02 80 00 28 be 2024270 <rtems_bdpart_unmount+0x100> <== NOT EXECUTED
20241d4: ba 10 00 08 mov %o0, %i5 <== NOT EXECUTED
esc = RTEMS_NO_MEMORY;
goto cleanup;
}
strncpy( mount_point, mount_base, mount_base_size);
20241d8: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
20241dc: 40 00 94 a5 call 2049470 <strncpy> <== NOT EXECUTED
20241e0: 94 10 00 1c mov %i4, %o2 <== NOT EXECUTED
mount_point [mount_base_size] = '/';
20241e4: 82 10 20 2f mov 0x2f, %g1 <== NOT EXECUTED
strncpy( mount_point + mount_base_size + 1, disk_file_name, disk_file_name_size);
20241e8: 90 07 20 01 add %i4, 1, %o0 <== NOT EXECUTED
if (mount_point == NULL) {
esc = RTEMS_NO_MEMORY;
goto cleanup;
}
strncpy( mount_point, mount_base, mount_base_size);
mount_point [mount_base_size] = '/';
20241ec: c2 2f 40 1c stb %g1, [ %i5 + %i4 ] <== NOT EXECUTED
strncpy( mount_point + mount_base_size + 1, disk_file_name, disk_file_name_size);
20241f0: 90 07 40 08 add %i5, %o0, %o0 <== NOT EXECUTED
20241f4: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
20241f8: 94 10 00 10 mov %l0, %o2 <== NOT EXECUTED
/* Marker */
mount_marker = mount_point + mount_base_size + 1 + disk_file_name_size;
20241fc: a2 04 60 01 inc %l1 <== NOT EXECUTED
esc = RTEMS_NO_MEMORY;
goto cleanup;
}
strncpy( mount_point, mount_base, mount_base_size);
mount_point [mount_base_size] = '/';
strncpy( mount_point + mount_base_size + 1, disk_file_name, disk_file_name_size);
2024200: 40 00 94 9c call 2049470 <strncpy> <== NOT EXECUTED
2024204: 37 00 81 95 sethi %hi(0x2065400), %i3 <== NOT EXECUTED
/* Marker */
mount_marker = mount_point + mount_base_size + 1 + disk_file_name_size;
2024208: a2 07 40 11 add %i5, %l1, %l1 <== NOT EXECUTED
/* Mount supported file systems for each partition */
for (i = 0; i < count; ++i) {
202420c: b8 10 20 00 clr %i4 <== NOT EXECUTED
2024210: 10 80 00 14 b 2024260 <rtems_bdpart_unmount+0xf0> <== NOT EXECUTED
2024214: b6 16 e3 48 or %i3, 0x348, %i3 <== NOT EXECUTED
/* Create mount point */
int rv = snprintf( mount_marker, RTEMS_BDPART_NUMBER_SIZE, "%zu", i + 1);
2024218: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED
202421c: 92 10 20 04 mov 4, %o1 <== NOT EXECUTED
2024220: 94 10 00 1b mov %i3, %o2 <== NOT EXECUTED
2024224: 40 00 90 39 call 2048308 <snprintf> <== NOT EXECUTED
2024228: 96 10 00 1c mov %i4, %o3 <== NOT EXECUTED
if (rv >= RTEMS_BDPART_NUMBER_SIZE) {
202422c: 80 a2 20 03 cmp %o0, 3 <== NOT EXECUTED
2024230: 14 80 00 10 bg 2024270 <rtems_bdpart_unmount+0x100> <== NOT EXECUTED
2024234: b0 10 20 03 mov 3, %i0 <== NOT EXECUTED
esc = RTEMS_INVALID_NAME;
goto cleanup;
}
/* Unmount */
rv = unmount( mount_point);
2024238: 40 00 15 b6 call 2029910 <unmount> <== NOT EXECUTED
202423c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
if (rv == 0) {
2024240: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2024244: 12 80 00 08 bne 2024264 <rtems_bdpart_unmount+0xf4> <== NOT EXECUTED
2024248: 80 a7 00 1a cmp %i4, %i2 <== NOT EXECUTED
/* Remove mount point */
rv = rmdir( mount_point);
202424c: 40 00 14 30 call 202930c <rmdir> <== NOT EXECUTED
2024250: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
if (rv != 0) {
2024254: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2024258: 12 80 00 06 bne 2024270 <rtems_bdpart_unmount+0x100> <== NOT EXECUTED
202425c: b0 10 20 1b mov 0x1b, %i0 <== NOT EXECUTED
/* Marker */
mount_marker = mount_point + mount_base_size + 1 + disk_file_name_size;
/* Mount supported file systems for each partition */
for (i = 0; i < count; ++i) {
2024260: 80 a7 00 1a cmp %i4, %i2 <== NOT EXECUTED
2024264: 32 bf ff ed bne,a 2024218 <rtems_bdpart_unmount+0xa8> <== NOT EXECUTED
2024268: b8 07 20 01 inc %i4 <== NOT EXECUTED
202426c: b0 10 20 00 clr %i0 <== NOT EXECUTED
}
}
cleanup:
free( mount_point);
2024270: 7f ff 92 63 call 2008bfc <free> <== NOT EXECUTED
2024274: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
return esc;
}
2024278: 81 c7 e0 08 ret <== NOT EXECUTED
202427c: 81 e8 00 00 restore <== NOT EXECUTED
02006f88 <rtems_bdpart_unregister>:
rtems_status_code rtems_bdpart_unregister(
const char *disk_name,
const rtems_bdpart_partition *pt __attribute__((unused)),
size_t count
)
{
2006f88: 9d e3 bf 90 save %sp, -112, %sp
rtems_device_minor_number minor = 0;
rtems_blkdev_bnum disk_end = 0;
dev_t disk = 0;
dev_t logical_disk = 0;
size_t i = 0;
int fd = -1;
2006f8c: 82 10 3f ff mov -1, %g1
rtems_disk_device *dd = NULL;
/* Get disk data */
sc = rtems_bdpart_get_disk_data( disk_name, &fd, &dd, &disk_end);
2006f90: 90 10 00 18 mov %i0, %o0
)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_device_major_number major = 0;
rtems_device_minor_number minor = 0;
rtems_blkdev_bnum disk_end = 0;
2006f94: c0 27 bf f4 clr [ %fp + -12 ]
dev_t disk = 0;
dev_t logical_disk = 0;
size_t i = 0;
int fd = -1;
2006f98: c2 27 bf f8 st %g1, [ %fp + -8 ]
rtems_disk_device *dd = NULL;
2006f9c: c0 27 bf fc clr [ %fp + -4 ]
/* Get disk data */
sc = rtems_bdpart_get_disk_data( disk_name, &fd, &dd, &disk_end);
2006fa0: 92 07 bf f8 add %fp, -8, %o1
2006fa4: 94 07 bf fc add %fp, -4, %o2
2006fa8: 40 00 75 29 call 202444c <rtems_bdpart_get_disk_data>
2006fac: 96 07 bf f4 add %fp, -12, %o3
if (sc != RTEMS_SUCCESSFUL) {
2006fb0: b0 92 20 00 orcc %o0, 0, %i0
2006fb4: 12 80 00 10 bne 2006ff4 <rtems_bdpart_unregister+0x6c> <== NEVER TAKEN
2006fb8: c2 07 bf fc ld [ %fp + -4 ], %g1
return sc;
}
disk = rtems_disk_get_device_identifier( dd);
close( fd);
2006fbc: d0 07 bf f8 ld [ %fp + -8 ], %o0
2006fc0: 40 00 06 51 call 2008904 <close>
2006fc4: f8 18 40 00 ldd [ %g1 ], %i4
/* Get the disk device identifier */
rtems_filesystem_split_dev_t( disk, major, minor);
/* Create a logical disk for each partition */
for (i = 0; i < count; ++i) {
2006fc8: 10 80 00 08 b 2006fe8 <rtems_bdpart_unregister+0x60>
2006fcc: b4 06 80 1d add %i2, %i5, %i2
/* Get the device identifier */
logical_disk = rtems_filesystem_make_dev_t( major, minor);
/* Delete logical disk */
sc = rtems_disk_delete( logical_disk);
2006fd0: 90 10 00 1c mov %i4, %o0
2006fd4: 40 00 02 80 call 20079d4 <rtems_disk_delete>
2006fd8: 92 10 00 1d mov %i5, %o1
if (sc != RTEMS_SUCCESSFUL) {
2006fdc: 80 a2 20 00 cmp %o0, 0
2006fe0: 32 80 00 05 bne,a 2006ff4 <rtems_bdpart_unregister+0x6c> <== NEVER TAKEN
2006fe4: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED
/* Get the disk device identifier */
rtems_filesystem_split_dev_t( disk, major, minor);
/* Create a logical disk for each partition */
for (i = 0; i < count; ++i) {
2006fe8: 80 a7 40 1a cmp %i5, %i2
2006fec: 12 bf ff f9 bne 2006fd0 <rtems_bdpart_unregister+0x48>
2006ff0: ba 07 60 01 inc %i5
2006ff4: 81 c7 e0 08 ret
2006ff8: 81 e8 00 00 restore
02024854 <rtems_bdpart_write>:
const char *disk_name,
const rtems_bdpart_format *format,
const rtems_bdpart_partition *pt,
size_t count
)
{
2024854: 9d e3 bf 88 save %sp, -120, %sp
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_status_code esc = RTEMS_SUCCESSFUL;
bool dos_compatibility = format != NULL
&& format->type == RTEMS_BDPART_FORMAT_MBR
&& format->mbr.dos_compatibility;
2024858: 80 a6 60 00 cmp %i1, 0
202485c: 02 80 00 08 be 202487c <rtems_bdpart_write+0x28> <== NEVER TAKEN
2024860: 90 10 00 18 mov %i0, %o0
)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_status_code esc = RTEMS_SUCCESSFUL;
bool dos_compatibility = format != NULL
&& format->type == RTEMS_BDPART_FORMAT_MBR
2024864: c4 06 40 00 ld [ %i1 ], %g2
2024868: 80 a0 a0 00 cmp %g2, 0
202486c: 12 80 00 05 bne 2024880 <rtems_bdpart_write+0x2c> <== NEVER TAKEN
2024870: 82 10 20 00 clr %g1
&& format->mbr.dos_compatibility;
2024874: 10 80 00 03 b 2024880 <rtems_bdpart_write+0x2c>
2024878: c2 0e 60 08 ldub [ %i1 + 8 ], %g1
202487c: 82 10 20 00 clr %g1 <== NOT EXECUTED
size_t count
)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_status_code esc = RTEMS_SUCCESSFUL;
bool dos_compatibility = format != NULL
2024880: a2 08 60 01 and %g1, 1, %l1
&& format->type == RTEMS_BDPART_FORMAT_MBR
&& format->mbr.dos_compatibility;
rtems_bdbuf_buffer *block = NULL;
2024884: c0 27 bf f0 clr [ %fp + -16 ]
rtems_blkdev_bnum disk_end = 0;
rtems_blkdev_bnum record_space =
2024888: ba 0c 60 ff and %l1, 0xff, %i5
dos_compatibility ? RTEMS_BDPART_MBR_CYLINDER_SIZE : 1;
size_t ppc = 0; /* Primary partition count */
size_t i = 0;
uint8_t *data = NULL;
int fd = -1;
202488c: 82 10 3f ff mov -1, %g1
bool dos_compatibility = format != NULL
&& format->type == RTEMS_BDPART_FORMAT_MBR
&& format->mbr.dos_compatibility;
rtems_bdbuf_buffer *block = NULL;
rtems_blkdev_bnum disk_end = 0;
rtems_blkdev_bnum record_space =
2024890: 80 a0 00 1d cmp %g0, %i5
rtems_status_code esc = RTEMS_SUCCESSFUL;
bool dos_compatibility = format != NULL
&& format->type == RTEMS_BDPART_FORMAT_MBR
&& format->mbr.dos_compatibility;
rtems_bdbuf_buffer *block = NULL;
rtems_blkdev_bnum disk_end = 0;
2024894: c0 27 bf f4 clr [ %fp + -12 ]
rtems_blkdev_bnum record_space =
dos_compatibility ? RTEMS_BDPART_MBR_CYLINDER_SIZE : 1;
size_t ppc = 0; /* Primary partition count */
size_t i = 0;
uint8_t *data = NULL;
int fd = -1;
2024898: c2 27 bf f8 st %g1, [ %fp + -8 ]
rtems_disk_device *dd = NULL;
202489c: c0 27 bf fc clr [ %fp + -4 ]
bool dos_compatibility = format != NULL
&& format->type == RTEMS_BDPART_FORMAT_MBR
&& format->mbr.dos_compatibility;
rtems_bdbuf_buffer *block = NULL;
rtems_blkdev_bnum disk_end = 0;
rtems_blkdev_bnum record_space =
20248a0: b8 40 3f ff addx %g0, -1, %i4
rtems_disk_device *dd = NULL;
/* Check if we have something to do */
if (count == 0) {
/* Nothing to do */
return RTEMS_SUCCESSFUL;
20248a4: b0 10 20 00 clr %i0
bool dos_compatibility = format != NULL
&& format->type == RTEMS_BDPART_FORMAT_MBR
&& format->mbr.dos_compatibility;
rtems_bdbuf_buffer *block = NULL;
rtems_blkdev_bnum disk_end = 0;
rtems_blkdev_bnum record_space =
20248a8: b8 0f 3f c2 and %i4, -62, %i4
uint8_t *data = NULL;
int fd = -1;
rtems_disk_device *dd = NULL;
/* Check if we have something to do */
if (count == 0) {
20248ac: 80 a6 e0 00 cmp %i3, 0
20248b0: 02 80 00 cd be 2024be4 <rtems_bdpart_write+0x390> <== NEVER TAKEN
20248b4: b8 07 20 3f add %i4, 0x3f, %i4
/* Nothing to do */
return RTEMS_SUCCESSFUL;
}
/* Check parameter */
if (format == NULL || pt == NULL) {
20248b8: 80 a6 a0 00 cmp %i2, 0
20248bc: 02 80 00 ca be 2024be4 <rtems_bdpart_write+0x390> <== NEVER TAKEN
20248c0: b0 10 20 09 mov 9, %i0
20248c4: 80 a6 60 00 cmp %i1, 0
20248c8: 02 80 00 c7 be 2024be4 <rtems_bdpart_write+0x390> <== NEVER TAKEN
20248cc: 92 07 bf f8 add %fp, -8, %o1
return RTEMS_INVALID_ADDRESS;
}
/* Get disk data */
sc = rtems_bdpart_get_disk_data( disk_name, &fd, &dd, &disk_end);
20248d0: 94 07 bf fc add %fp, -4, %o2
20248d4: 7f ff fe de call 202444c <rtems_bdpart_get_disk_data>
20248d8: 96 07 bf f4 add %fp, -12, %o3
if (sc != RTEMS_SUCCESSFUL) {
20248dc: b0 92 20 00 orcc %o0, 0, %i0
20248e0: 12 80 00 c1 bne 2024be4 <rtems_bdpart_write+0x390> <== NEVER TAKEN
20248e4: 80 a7 60 00 cmp %i5, 0
return sc;
}
/* Align end of disk on cylinder boundary if necessary */
if (dos_compatibility) {
20248e8: 02 80 00 09 be 202490c <rtems_bdpart_write+0xb8> <== NEVER TAKEN
20248ec: c8 07 bf f4 ld [ %fp + -12 ], %g4
disk_end -= (disk_end % record_space);
20248f0: fa 07 bf f4 ld [ %fp + -12 ], %i5
20248f4: 92 10 00 1c mov %i4, %o1
20248f8: 40 00 db ce call 205b830 <.urem>
20248fc: 90 10 00 1d mov %i5, %o0
2024900: 90 27 40 08 sub %i5, %o0, %o0
2024904: d0 27 bf f4 st %o0, [ %fp + -12 ]
/* Check that we have a consistent partition table */
for (i = 0; i < count; ++i) {
const rtems_bdpart_partition *p = pt + i;
/* Check that begin and end are proper within the disk */
if (p->begin >= disk_end || p->end > disk_end) {
2024908: c8 07 bf f4 ld [ %fp + -12 ], %g4
202490c: a0 10 00 1a mov %i2, %l0
2024910: 82 10 00 1a mov %i2, %g1
if (dos_compatibility) {
disk_end -= (disk_end % record_space);
}
/* Check that we have a consistent partition table */
for (i = 0; i < count; ++i) {
2024914: 84 10 20 00 clr %g2
const rtems_bdpart_partition *p = pt + i;
/* Check that begin and end are proper within the disk */
if (p->begin >= disk_end || p->end > disk_end) {
2024918: c6 00 40 00 ld [ %g1 ], %g3
202491c: 80 a0 c0 04 cmp %g3, %g4
2024920: 3a 80 00 a5 bcc,a 2024bb4 <rtems_bdpart_write+0x360> <== NEVER TAKEN
2024924: b0 10 20 0a mov 0xa, %i0 <== NOT EXECUTED
2024928: fa 00 60 04 ld [ %g1 + 4 ], %i5
202492c: 80 a7 40 04 cmp %i5, %g4
2024930: 18 80 00 9e bgu 2024ba8 <rtems_bdpart_write+0x354> <== NEVER TAKEN
2024934: 80 a0 c0 1d cmp %g3, %i5
esc = RTEMS_INVALID_NUMBER;
goto cleanup;
}
/* Check that begin and end are valid */
if (p->begin >= p->end) {
2024938: 1a 80 00 9c bcc 2024ba8 <rtems_bdpart_write+0x354> <== NEVER TAKEN
202493c: 80 a0 a0 00 cmp %g2, 0
esc = RTEMS_INVALID_NUMBER;
goto cleanup;
}
/* Check that partitions do not overlap */
if (i > 0 && pt [i - 1].end > p->begin) {
2024940: 02 80 00 06 be 2024958 <rtems_bdpart_write+0x104>
2024944: 84 00 a0 01 inc %g2
2024948: fa 00 7f d4 ld [ %g1 + -44 ], %i5
202494c: 80 a7 40 03 cmp %i5, %g3
2024950: 38 80 00 99 bgu,a 2024bb4 <rtems_bdpart_write+0x360> <== NEVER TAKEN
2024954: b0 10 20 0a mov 0xa, %i0 <== NOT EXECUTED
if (dos_compatibility) {
disk_end -= (disk_end % record_space);
}
/* Check that we have a consistent partition table */
for (i = 0; i < count; ++i) {
2024958: 80 a0 80 1b cmp %g2, %i3
202495c: 12 bf ff ef bne 2024918 <rtems_bdpart_write+0xc4>
2024960: 82 00 60 30 add %g1, 0x30, %g1
goto cleanup;
}
}
/* Check format */
if (format->type != RTEMS_BDPART_FORMAT_MBR) {
2024964: c2 06 40 00 ld [ %i1 ], %g1
2024968: 80 a0 60 00 cmp %g1, 0
202496c: 12 80 00 92 bne 2024bb4 <rtems_bdpart_write+0x360> <== NEVER TAKEN
2024970: b0 10 20 18 mov 0x18, %i0
* Set primary partition count. If we have more than four partitions we need
* an extended partition which will contain the partitions of number four and
* above as logical partitions. If we have four or less partitions we can
* use the primary partition table.
*/
ppc = count <= 4 ? count : 3;
2024974: 80 a6 e0 04 cmp %i3, 4
2024978: 08 80 00 03 bleu 2024984 <rtems_bdpart_write+0x130> <== NEVER TAKEN
202497c: ba 10 00 1b mov %i3, %i5
2024980: ba 10 20 03 mov 3, %i5
/*
* Check that the first primary partition starts at head one and sector one
* under the virtual one head and 63 sectors geometry if necessary.
*/
if (dos_compatibility && pt [0].begin != RTEMS_BDPART_MBR_CYLINDER_SIZE) {
2024984: 80 8c 60 ff btst 0xff, %l1
2024988: 32 80 00 09 bne,a 20249ac <rtems_bdpart_write+0x158> <== ALWAYS TAKEN
202498c: c2 06 80 00 ld [ %i2 ], %g1
RTEMS_BDPART_MBR_SIGNATURE_1;
return RTEMS_SUCCESSFUL;
}
rtems_status_code rtems_bdpart_write(
2024990: 83 2f 60 04 sll %i5, 4, %g1 <== NOT EXECUTED
2024994: a5 2f 60 06 sll %i5, 6, %l2
2024998: 84 10 00 1d mov %i5, %g2
202499c: a4 24 80 01 sub %l2, %g1, %l2
20249a0: 82 10 20 00 clr %g1
20249a4: 10 80 00 0e b 20249dc <rtems_bdpart_write+0x188>
20249a8: a2 06 80 12 add %i2, %l2, %l1
/*
* Check that the first primary partition starts at head one and sector one
* under the virtual one head and 63 sectors geometry if necessary.
*/
if (dos_compatibility && pt [0].begin != RTEMS_BDPART_MBR_CYLINDER_SIZE) {
20249ac: 80 a0 60 3f cmp %g1, 0x3f
20249b0: 12 80 00 81 bne 2024bb4 <rtems_bdpart_write+0x360> <== NEVER TAKEN
20249b4: b0 10 20 0a mov 0xa, %i0
RTEMS_BDPART_MBR_SIGNATURE_1;
return RTEMS_SUCCESSFUL;
}
rtems_status_code rtems_bdpart_write(
20249b8: 10 bf ff f7 b 2024994 <rtems_bdpart_write+0x140>
20249bc: 83 2f 60 04 sll %i5, 4, %g1
* The space for the EBR and maybe some space which is needed for DOS
* compatibility resides between the partitions. So there have to be gaps of
* the appropriate size between the partitions.
*/
for (i = ppc; i < count; ++i) {
if ((pt [i].begin - pt [i - 1].end) < record_space) {
20249c0: c8 04 40 01 ld [ %l1 + %g1 ], %g4
20249c4: c6 00 ff d4 ld [ %g3 + -44 ], %g3
20249c8: 86 21 00 03 sub %g4, %g3, %g3
20249cc: 80 a0 c0 1c cmp %g3, %i4
20249d0: 0a 80 00 76 bcs 2024ba8 <rtems_bdpart_write+0x354> <== NEVER TAKEN
20249d4: 82 00 60 30 add %g1, 0x30, %g1
* Each logical partition is described via one EBR preceding the partition.
* The space for the EBR and maybe some space which is needed for DOS
* compatibility resides between the partitions. So there have to be gaps of
* the appropriate size between the partitions.
*/
for (i = ppc; i < count; ++i) {
20249d8: 84 00 a0 01 inc %g2
20249dc: 80 a0 80 1b cmp %g2, %i3
20249e0: 0a bf ff f8 bcs 20249c0 <rtems_bdpart_write+0x16c>
20249e4: 86 04 40 01 add %l1, %g1, %g3
20249e8: b0 10 00 1a mov %i2, %i0
20249ec: a6 10 20 00 clr %l3
}
}
/* Check that we can convert the parition descriptions to the MBR format */
for (i = 0; i < count; ++i) {
uint8_t type = 0;
20249f0: c0 2f bf ef clrb [ %fp + -17 ]
const rtems_bdpart_partition *p = pt + i;
/* Check type */
if (!rtems_bdpart_to_mbr_partition_type( p->type, &type)) {
20249f4: 90 06 20 08 add %i0, 8, %o0
20249f8: 7f ff fe 89 call 202441c <rtems_bdpart_to_mbr_partition_type>
20249fc: 92 07 bf ef add %fp, -17, %o1
2024a00: 80 8a 20 ff btst 0xff, %o0
2024a04: 22 80 00 6c be,a 2024bb4 <rtems_bdpart_write+0x360> <== NEVER TAKEN
2024a08: b0 10 20 04 mov 4, %i0 <== NOT EXECUTED
2024a0c: b0 06 20 30 add %i0, 0x30, %i0
esc = RTEMS_INVALID_ID;
goto cleanup;
}
/* Check flags */
if (p->flags > 0xffU) {
2024a10: c2 06 3f f8 ld [ %i0 + -8 ], %g1
2024a14: 80 a0 60 00 cmp %g1, 0
2024a18: 32 80 00 67 bne,a 2024bb4 <rtems_bdpart_write+0x360> <== NEVER TAKEN
2024a1c: b0 10 20 04 mov 4, %i0 <== NOT EXECUTED
2024a20: c2 06 3f fc ld [ %i0 + -4 ], %g1
2024a24: 80 a0 60 ff cmp %g1, 0xff
2024a28: 18 80 00 07 bgu 2024a44 <rtems_bdpart_write+0x1f0> <== NEVER TAKEN
2024a2c: a6 04 e0 01 inc %l3
goto cleanup;
}
}
/* Check that we can convert the parition descriptions to the MBR format */
for (i = 0; i < count; ++i) {
2024a30: 80 a4 c0 1b cmp %l3, %i3
2024a34: 32 bf ff f0 bne,a 20249f4 <rtems_bdpart_write+0x1a0>
2024a38: c0 2f bf ef clrb [ %fp + -17 ]
/* Check ID */
/* TODO */
}
/* New MBR */
sc = rtems_bdpart_new_record( dd, 0, &block);
2024a3c: 10 80 00 04 b 2024a4c <rtems_bdpart_write+0x1f8>
2024a40: d0 07 bf fc ld [ %fp + -4 ], %o0
2024a44: 10 80 00 5c b 2024bb4 <rtems_bdpart_write+0x360> <== NOT EXECUTED
2024a48: b0 10 20 04 mov 4, %i0 <== NOT EXECUTED
2024a4c: 92 10 20 00 clr %o1
2024a50: 7f ff ff 48 call 2024770 <rtems_bdpart_new_record>
2024a54: 94 07 bf f0 add %fp, -16, %o2
if (sc != RTEMS_SUCCESSFUL) {
2024a58: b0 92 20 00 orcc %o0, 0, %i0
2024a5c: 12 80 00 57 bne 2024bb8 <rtems_bdpart_write+0x364> <== NEVER TAKEN
2024a60: d0 07 bf f8 ld [ %fp + -8 ], %o0
}
/* Write disk ID */
rtems_uint32_to_little_endian(
format->mbr.disk_id,
block->buffer + RTEMS_BDPART_MBR_OFFSET_DISK_ID
2024a64: c2 07 bf f0 ld [ %fp + -16 ], %g1
esc = sc;
goto cleanup;
}
/* Write disk ID */
rtems_uint32_to_little_endian(
2024a68: c4 06 60 04 ld [ %i1 + 4 ], %g2
format->mbr.disk_id,
block->buffer + RTEMS_BDPART_MBR_OFFSET_DISK_ID
2024a6c: c8 00 60 1c ld [ %g1 + 0x1c ], %g4
2024a70: 82 10 20 00 clr %g1
RTEMS_BDPART_MBR_SIGNATURE_1;
return RTEMS_SUCCESSFUL;
}
rtems_status_code rtems_bdpart_write(
2024a74: 86 01 00 01 add %g4, %g1, %g3
data [i] = (uint8_t) value;
2024a78: c4 28 e1 b8 stb %g2, [ %g3 + 0x1b8 ]
static inline void rtems_uint32_to_little_endian( uint32_t value, uint8_t *data)
{
size_t i = 0;
for (i = 0; i < 4; ++i) {
2024a7c: 82 00 60 01 inc %g1
2024a80: 80 a0 60 04 cmp %g1, 4
2024a84: 12 bf ff fc bne 2024a74 <rtems_bdpart_write+0x220>
2024a88: 85 30 a0 08 srl %g2, 8, %g2
format->mbr.disk_id,
block->buffer + RTEMS_BDPART_MBR_OFFSET_DISK_ID
);
/* Write primary partition table */
data = block->buffer + RTEMS_BDPART_MBR_OFFSET_TABLE_0;
2024a8c: c2 07 bf f0 ld [ %fp + -16 ], %g1
for (i = 0; i < ppc; ++i) {
2024a90: b2 10 20 00 clr %i1
format->mbr.disk_id,
block->buffer + RTEMS_BDPART_MBR_OFFSET_DISK_ID
);
/* Write primary partition table */
data = block->buffer + RTEMS_BDPART_MBR_OFFSET_TABLE_0;
2024a94: e6 00 60 1c ld [ %g1 + 0x1c ], %l3
2024a98: a6 04 e1 be add %l3, 0x1be, %l3
for (i = 0; i < ppc; ++i) {
2024a9c: 10 80 00 0b b 2024ac8 <rtems_bdpart_write+0x274>
2024aa0: b0 10 00 13 mov %l3, %i0
const rtems_bdpart_partition *p = pt + i;
/* Write partition entry */
rtems_bdpart_write_mbr_partition(
2024aa4: d4 04 20 04 ld [ %l0 + 4 ], %o2
2024aa8: d6 0c 20 08 ldub [ %l0 + 8 ], %o3
2024aac: d8 0c 20 2f ldub [ %l0 + 0x2f ], %o4
2024ab0: 90 10 00 18 mov %i0, %o0
2024ab4: 94 22 80 09 sub %o2, %o1, %o2
2024ab8: 7f ff ff 56 call 2024810 <rtems_bdpart_write_mbr_partition>
2024abc: b0 06 20 10 add %i0, 0x10, %i0
block->buffer + RTEMS_BDPART_MBR_OFFSET_DISK_ID
);
/* Write primary partition table */
data = block->buffer + RTEMS_BDPART_MBR_OFFSET_TABLE_0;
for (i = 0; i < ppc; ++i) {
2024ac0: b2 06 60 01 inc %i1
2024ac4: a0 04 20 30 add %l0, 0x30, %l0
2024ac8: 80 a6 40 1d cmp %i1, %i5
2024acc: 32 bf ff f6 bne,a 2024aa4 <rtems_bdpart_write+0x250>
2024ad0: d2 04 00 00 ld [ %l0 ], %o1
RTEMS_BDPART_MBR_SIGNATURE_1;
return RTEMS_SUCCESSFUL;
}
rtems_status_code rtems_bdpart_write(
2024ad4: 91 2f 60 04 sll %i5, 4, %o0
const rtems_bdpart_partition *pt,
size_t count
)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_status_code esc = RTEMS_SUCCESSFUL;
2024ad8: b0 10 20 00 clr %i0
data += RTEMS_BDPART_MBR_TABLE_ENTRY_SIZE;
}
/* Write extended partition with logical partitions if necessary */
if (ppc != count) {
2024adc: 80 a7 40 1b cmp %i5, %i3
2024ae0: 02 80 00 35 be 2024bb4 <rtems_bdpart_write+0x360> <== NEVER TAKEN
2024ae4: 90 04 c0 08 add %l3, %o0, %o0
rtems_blkdev_bnum ebr = 0; /* Extended boot record block index */
/* Begin of extended partition */
rtems_blkdev_bnum ep_begin = pt [ppc].begin - record_space;
2024ae8: e0 06 80 12 ld [ %i2 + %l2 ], %l0
/* Write extended partition */
rtems_bdpart_write_mbr_partition(
2024aec: d4 07 bf f4 ld [ %fp + -12 ], %o2
/* Write extended partition with logical partitions if necessary */
if (ppc != count) {
rtems_blkdev_bnum ebr = 0; /* Extended boot record block index */
/* Begin of extended partition */
rtems_blkdev_bnum ep_begin = pt [ppc].begin - record_space;
2024af0: a0 24 00 1c sub %l0, %i4, %l0
/* Write extended partition */
rtems_bdpart_write_mbr_partition(
2024af4: 96 10 20 05 mov 5, %o3
2024af8: 92 10 00 10 mov %l0, %o1
2024afc: 94 22 80 10 sub %o2, %l0, %o2
2024b00: 98 10 20 00 clr %o4
2024b04: 7f ff ff 43 call 2024810 <rtems_bdpart_write_mbr_partition>
2024b08: b4 10 00 11 mov %l1, %i2
RTEMS_BDPART_MBR_EXTENDED,
0
);
/* Write logical partitions */
for (i = ppc; i < count; ++i) {
2024b0c: 10 80 00 22 b 2024b94 <rtems_bdpart_write+0x340>
2024b10: b2 10 00 1d mov %i5, %i1
const rtems_bdpart_partition *p = pt + i;
/* Write second partition entry */
if (i > ppc) {
2024b14: 28 80 00 0e bleu,a 2024b4c <rtems_bdpart_write+0x2f8>
2024b18: d2 06 80 00 ld [ %i2 ], %o1
rtems_blkdev_bnum begin = p->begin - record_space;
rtems_bdpart_write_mbr_partition(
block->buffer + RTEMS_BDPART_MBR_OFFSET_TABLE_1,
2024b1c: c4 07 bf f0 ld [ %fp + -16 ], %g2
for (i = ppc; i < count; ++i) {
const rtems_bdpart_partition *p = pt + i;
/* Write second partition entry */
if (i > ppc) {
rtems_blkdev_bnum begin = p->begin - record_space;
2024b20: c2 06 80 00 ld [ %i2 ], %g1
rtems_bdpart_write_mbr_partition(
2024b24: d0 00 a0 1c ld [ %g2 + 0x1c ], %o0
2024b28: d4 07 bf f4 ld [ %fp + -12 ], %o2
for (i = ppc; i < count; ++i) {
const rtems_bdpart_partition *p = pt + i;
/* Write second partition entry */
if (i > ppc) {
rtems_blkdev_bnum begin = p->begin - record_space;
2024b2c: 82 20 40 1c sub %g1, %i4, %g1
rtems_bdpart_write_mbr_partition(
2024b30: 90 02 21 ce add %o0, 0x1ce, %o0
2024b34: 92 20 40 10 sub %g1, %l0, %o1
2024b38: 94 22 80 01 sub %o2, %g1, %o2
2024b3c: 96 10 20 05 mov 5, %o3
2024b40: 7f ff ff 34 call 2024810 <rtems_bdpart_write_mbr_partition>
2024b44: 98 10 20 00 clr %o4
0
);
}
/* New EBR */
ebr = p->begin - record_space;
2024b48: d2 06 80 00 ld [ %i2 ], %o1
sc = rtems_bdpart_new_record( dd, ebr, &block);
2024b4c: d0 07 bf fc ld [ %fp + -4 ], %o0
2024b50: 92 22 40 1c sub %o1, %i4, %o1
2024b54: 7f ff ff 07 call 2024770 <rtems_bdpart_new_record>
2024b58: 94 07 bf f0 add %fp, -16, %o2
if (sc != RTEMS_SUCCESSFUL) {
2024b5c: 80 a2 20 00 cmp %o0, 0
2024b60: 12 80 00 14 bne 2024bb0 <rtems_bdpart_write+0x35c> <== NEVER TAKEN
2024b64: c2 07 bf f0 ld [ %fp + -16 ], %g1
esc = sc;
goto cleanup;
}
/* Write first partition entry */
rtems_bdpart_write_mbr_partition(
2024b68: d4 06 a0 04 ld [ %i2 + 4 ], %o2
2024b6c: d0 00 60 1c ld [ %g1 + 0x1c ], %o0
2024b70: d6 0e a0 08 ldub [ %i2 + 8 ], %o3
2024b74: c2 06 80 00 ld [ %i2 ], %g1
2024b78: d8 0e a0 2f ldub [ %i2 + 0x2f ], %o4
2024b7c: 90 02 21 be add %o0, 0x1be, %o0
2024b80: 92 10 00 1c mov %i4, %o1
2024b84: 94 22 80 01 sub %o2, %g1, %o2
2024b88: 7f ff ff 22 call 2024810 <rtems_bdpart_write_mbr_partition>
2024b8c: b2 06 60 01 inc %i1
2024b90: b4 06 a0 30 add %i2, 0x30, %i2
RTEMS_BDPART_MBR_EXTENDED,
0
);
/* Write logical partitions */
for (i = ppc; i < count; ++i) {
2024b94: 80 a6 40 1b cmp %i1, %i3
2024b98: 0a bf ff df bcs 2024b14 <rtems_bdpart_write+0x2c0>
2024b9c: 80 a6 40 1d cmp %i1, %i5
const rtems_bdpart_partition *pt,
size_t count
)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_status_code esc = RTEMS_SUCCESSFUL;
2024ba0: 10 80 00 05 b 2024bb4 <rtems_bdpart_write+0x360>
2024ba4: b0 10 20 00 clr %i0
* compatibility resides between the partitions. So there have to be gaps of
* the appropriate size between the partitions.
*/
for (i = ppc; i < count; ++i) {
if ((pt [i].begin - pt [i - 1].end) < record_space) {
esc = RTEMS_INVALID_NUMBER;
2024ba8: 10 80 00 03 b 2024bb4 <rtems_bdpart_write+0x360> <== NOT EXECUTED
2024bac: b0 10 20 0a mov 0xa, %i0 <== NOT EXECUTED
}
/* New EBR */
ebr = p->begin - record_space;
sc = rtems_bdpart_new_record( dd, ebr, &block);
if (sc != RTEMS_SUCCESSFUL) {
2024bb0: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED
}
}
cleanup:
if (fd >= 0) {
2024bb4: d0 07 bf f8 ld [ %fp + -8 ], %o0
2024bb8: 80 a2 20 00 cmp %o0, 0
2024bbc: 26 80 00 05 bl,a 2024bd0 <rtems_bdpart_write+0x37c> <== NEVER TAKEN
2024bc0: d0 07 bf f0 ld [ %fp + -16 ], %o0 <== NOT EXECUTED
close( fd);
2024bc4: 7f ff 8f 50 call 2008904 <close>
2024bc8: 01 00 00 00 nop
}
if (block != NULL) {
2024bcc: d0 07 bf f0 ld [ %fp + -16 ], %o0
2024bd0: 80 a2 20 00 cmp %o0, 0
2024bd4: 02 80 00 06 be 2024bec <rtems_bdpart_write+0x398> <== NEVER TAKEN
2024bd8: 01 00 00 00 nop
rtems_bdbuf_sync( block);
2024bdc: 7f ff 87 77 call 20069b8 <rtems_bdbuf_sync>
2024be0: 01 00 00 00 nop
2024be4: 81 c7 e0 08 ret
2024be8: 81 e8 00 00 restore
}
return esc;
}
2024bec: 81 c7 e0 08 ret <== NOT EXECUTED
2024bf0: 81 e8 00 00 restore <== NOT EXECUTED
02003ba8 <rtems_blkdev_create_partition>:
const char *partition,
const char *device,
rtems_blkdev_bnum block_begin,
rtems_blkdev_bnum block_count
)
{
2003ba8: 9d e3 bf 50 save %sp, -176, %sp
rtems_status_code sc = RTEMS_SUCCESSFUL;
int fd = open(device, O_RDWR);
2003bac: 92 10 20 02 mov 2, %o1
2003bb0: 90 10 00 19 mov %i1, %o0
2003bb4: 40 00 09 f2 call 200637c <open>
2003bb8: ba 10 20 04 mov 4, %i5
if (fd >= 0) {
2003bbc: 80 a2 20 00 cmp %o0, 0
2003bc0: 06 80 00 33 bl 2003c8c <rtems_blkdev_create_partition+0xe4>
2003bc4: b2 10 00 08 mov %o0, %i1
int rv;
struct stat st;
rv = fstat(fd, &st);
2003bc8: 40 00 06 45 call 20054dc <fstat>
2003bcc: 92 07 bf b8 add %fp, -72, %o1
if (rv == 0 && S_ISBLK(st.st_mode)) {
2003bd0: 80 a2 20 00 cmp %o0, 0
2003bd4: 12 80 00 2c bne 2003c84 <rtems_blkdev_create_partition+0xdc><== NEVER TAKEN
2003bd8: ba 10 20 15 mov 0x15, %i5
2003bdc: e0 07 bf c4 ld [ %fp + -60 ], %l0
2003be0: 03 00 00 3c sethi %hi(0xf000), %g1
2003be4: a0 0c 00 01 and %l0, %g1, %l0
2003be8: 03 00 00 18 sethi %hi(0x6000), %g1
2003bec: 80 a4 00 01 cmp %l0, %g1
2003bf0: 12 80 00 25 bne 2003c84 <rtems_blkdev_create_partition+0xdc>
2003bf4: 90 10 00 19 mov %i1, %o0
static inline int rtems_disk_fd_get_disk_device(
int fd,
rtems_disk_device **dd_ptr
)
{
return ioctl(fd, RTEMS_BLKIO_GETDISKDEV, dd_ptr);
2003bf8: 13 10 01 10 sethi %hi(0x40044000), %o1
2003bfc: 94 07 bf b4 add %fp, -76, %o2
2003c00: 92 12 62 09 or %o1, 0x209, %o1
2003c04: 40 00 06 8d call 2005638 <ioctl>
2003c08: ba 10 20 18 mov 0x18, %i5
rtems_disk_device *phys_dd;
rv = rtems_disk_fd_get_disk_device(fd, &phys_dd);
if (rv == 0) {
2003c0c: 80 a2 20 00 cmp %o0, 0
2003c10: 12 80 00 1d bne 2003c84 <rtems_blkdev_create_partition+0xdc>
2003c14: 01 00 00 00 nop
rtems_blkdev_imfs_context *ctx = malloc(sizeof(*ctx));
2003c18: 40 00 07 ad call 2005acc <malloc>
2003c1c: 90 10 20 80 mov 0x80, %o0 ! 80 <PROM_START+0x80>
if (ctx != NULL) {
2003c20: b8 92 20 00 orcc %o0, 0, %i4
2003c24: 02 80 00 17 be 2003c80 <rtems_blkdev_create_partition+0xd8>
2003c28: d2 07 bf b4 ld [ %fp + -76 ], %o1
sc = rtems_disk_init_log(
2003c2c: 94 10 00 1a mov %i2, %o2
2003c30: 40 00 00 90 call 2003e70 <rtems_disk_init_log>
2003c34: 96 10 00 1b mov %i3, %o3
phys_dd,
block_begin,
block_count
);
if (sc == RTEMS_SUCCESSFUL) {
2003c38: ba 92 20 00 orcc %o0, 0, %i5
2003c3c: 12 80 00 0e bne 2003c74 <rtems_blkdev_create_partition+0xcc>
2003c40: 90 10 00 18 mov %i0, %o0
ctx->fd = fd;
2003c44: f2 27 20 78 st %i1, [ %i4 + 0x78 ]
rv = IMFS_make_generic_node(
2003c48: 92 14 21 ff or %l0, 0x1ff, %o1
2003c4c: 15 00 80 7e sethi %hi(0x201f800), %o2
2003c50: 96 10 00 1c mov %i4, %o3
2003c54: 40 00 03 8f call 2004a90 <IMFS_make_generic_node>
2003c58: 94 12 a0 e8 or %o2, 0xe8, %o2
S_IFBLK | S_IRWXU | S_IRWXG | S_IRWXO,
&rtems_blkdev_imfs_control,
ctx
);
if (rv != 0) {
2003c5c: 80 a2 20 00 cmp %o0, 0
2003c60: 02 80 00 0b be 2003c8c <rtems_blkdev_create_partition+0xe4>
2003c64: 90 10 00 1c mov %i4, %o0
free(ctx);
2003c68: 40 00 05 f3 call 2005434 <free>
2003c6c: ba 10 20 0d mov 0xd, %i5
2003c70: 30 80 00 05 b,a 2003c84 <rtems_blkdev_create_partition+0xdc>
sc = RTEMS_UNSATISFIED;
}
} else {
free(ctx);
2003c74: 40 00 05 f0 call 2005434 <free>
2003c78: 90 10 00 1c mov %i4, %o0
2003c7c: 30 80 00 02 b,a 2003c84 <rtems_blkdev_create_partition+0xdc>
2003c80: ba 10 20 1a mov 0x1a, %i5
} else {
sc = RTEMS_INVALID_NODE;
}
if (sc != RTEMS_SUCCESSFUL) {
close(fd);
2003c84: 40 00 05 2e call 200513c <close>
2003c88: 90 10 00 19 mov %i1, %o0
} else {
sc = RTEMS_INVALID_ID;
}
return sc;
}
2003c8c: 81 c7 e0 08 ret
2003c90: 91 e8 00 1d restore %g0, %i5, %o0
0200f4e8 <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)
{
200f4e8: 9d e3 bf a0 save %sp, -96, %sp
rtems_libio_ioctl_args_t *args = arg;
rtems_libio_t *iop = args->iop;
rtems_disk_device *dd = iop->data1;
200f4ec: c2 06 80 00 ld [ %i2 ], %g1
if (args->command != RTEMS_BLKIO_REQUEST)
200f4f0: d2 06 a0 04 ld [ %i2 + 4 ], %o1
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;
200f4f4: d0 00 60 30 ld [ %g1 + 0x30 ], %o0
if (args->command != RTEMS_BLKIO_REQUEST)
200f4f8: 03 30 06 10 sethi %hi(0xc0184000), %g1
200f4fc: 82 10 62 01 or %g1, 0x201, %g1 ! c0184201 <RAM_END+0xbdd84201>
200f500: 80 a2 40 01 cmp %o1, %g1
200f504: 02 80 00 07 be 200f520 <rtems_blkdev_generic_ioctl+0x38> <== NEVER TAKEN
200f508: 82 10 3f ff mov -1, %g1
{
args->ioctl_return = dd->ioctl(dd,
200f50c: c2 02 20 38 ld [ %o0 + 0x38 ], %g1
200f510: 9f c0 40 00 call %g1
200f514: d4 06 a0 08 ld [ %i2 + 8 ], %o2
200f518: 10 80 00 03 b 200f524 <rtems_blkdev_generic_ioctl+0x3c>
200f51c: d0 26 a0 0c st %o0, [ %i2 + 0xc ]
{
/*
* It is not allowed to directly access the driver circumventing the
* cache.
*/
args->ioctl_return = -1;
200f520: c2 26 a0 0c st %g1, [ %i2 + 0xc ] <== NOT EXECUTED
}
return RTEMS_SUCCESSFUL;
}
200f524: 81 c7 e0 08 ret
200f528: 91 e8 20 00 restore %g0, 0, %o0
0200f2c8 <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)
{
200f2c8: 9d e3 bf 98 save %sp, -104, %sp
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;
200f2cc: c2 06 80 00 ld [ %i2 ], %g1
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);
200f2d0: f8 1e a0 08 ldd [ %i2 + 8 ], %i4
void * arg)
{
rtems_status_code rc = RTEMS_SUCCESSFUL;
rtems_libio_rw_args_t *args = arg;
rtems_libio_t *iop = args->iop;
rtems_disk_device *dd = iop->data1;
200f2d4: e4 00 60 30 ld [ %g1 + 0x30 ], %l2
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);
200f2d8: 90 10 00 1c mov %i4, %o0
{
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;
200f2dc: e0 04 a0 24 ld [ %l2 + 0x24 ], %l0
char *buf = args->buffer;
uint32_t count = args->count;
rtems_blkdev_bnum block = (rtems_blkdev_bnum) (args->offset / block_size);
200f2e0: 94 10 20 00 clr %o2
200f2e4: 96 10 00 10 mov %l0, %o3
200f2e8: 40 00 37 1b call 201cf54 <__divdi3>
200f2ec: 92 10 00 1d mov %i5, %o1
uint32_t blkofs = (uint32_t) (args->offset % block_size);
200f2f0: 90 10 00 1c mov %i4, %o0
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);
200f2f4: a6 10 00 09 mov %o1, %l3
uint32_t blkofs = (uint32_t) (args->offset % block_size);
200f2f8: 94 10 20 00 clr %o2
200f2fc: 92 10 00 1d mov %i5, %o1
200f300: 96 10 00 10 mov %l0, %o3
200f304: 40 00 37 ff call 201d300 <__moddi3>
200f308: f2 06 a0 10 ld [ %i2 + 0x10 ], %i1
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;
200f30c: f6 06 a0 14 ld [ %i2 + 0x14 ], %i3
rtems_blkdev_bnum block = (rtems_blkdev_bnum) (args->offset / block_size);
uint32_t blkofs = (uint32_t) (args->offset % block_size);
200f310: a2 10 00 09 mov %o1, %l1
args->bytes_moved = 0;
200f314: c0 26 a0 1c clr [ %i2 + 0x1c ]
while (count > 0)
200f318: 10 80 00 1c b 200f388 <rtems_blkdev_generic_read+0xc0>
200f31c: b8 10 20 00 clr %i4
{
rtems_bdbuf_buffer *diskbuf;
uint32_t copy;
rc = rtems_bdbuf_read(dd, block, &diskbuf);
200f320: 90 10 00 12 mov %l2, %o0
200f324: 7f ff fd a2 call 200e9ac <rtems_bdbuf_read>
200f328: 94 07 bf fc add %fp, -4, %o2
if (rc != RTEMS_SUCCESSFUL)
200f32c: 80 a2 20 00 cmp %o0, 0
200f330: 12 80 00 1a bne 200f398 <rtems_blkdev_generic_read+0xd0> <== NEVER TAKEN
200f334: ba 24 00 11 sub %l0, %l1, %i5
200f338: 80 a7 40 1b cmp %i5, %i3
200f33c: 38 80 00 02 bgu,a 200f344 <rtems_blkdev_generic_read+0x7c><== NEVER TAKEN
200f340: ba 10 00 1b mov %i3, %i5 <== NOT EXECUTED
break;
copy = block_size - blkofs;
if (copy > count)
copy = count;
memcpy(buf, (char *)diskbuf->buffer + blkofs, copy);
200f344: c2 07 bf fc ld [ %fp + -4 ], %g1
200f348: 94 10 00 1d mov %i5, %o2
200f34c: d2 00 60 1c ld [ %g1 + 0x1c ], %o1
200f350: 90 10 00 19 mov %i1, %o0
200f354: 40 00 14 57 call 20144b0 <memcpy>
200f358: 92 02 40 11 add %o1, %l1, %o1
rc = rtems_bdbuf_release(diskbuf);
200f35c: d0 07 bf fc ld [ %fp + -4 ], %o0
200f360: 7f ff fe 10 call 200eba0 <rtems_bdbuf_release>
200f364: b8 07 20 01 inc %i4
args->bytes_moved += copy;
200f368: c2 06 a0 1c ld [ %i2 + 0x1c ], %g1
if (rc != RTEMS_SUCCESSFUL)
200f36c: 80 a2 20 00 cmp %o0, 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;
200f370: 82 00 40 1d add %g1, %i5, %g1
if (rc != RTEMS_SUCCESSFUL)
200f374: 12 80 00 09 bne 200f398 <rtems_blkdev_generic_read+0xd0> <== NEVER TAKEN
200f378: c2 26 a0 1c st %g1, [ %i2 + 0x1c ]
break;
count -= copy;
200f37c: b6 26 c0 1d sub %i3, %i5, %i3
buf += copy;
200f380: b2 06 40 1d add %i1, %i5, %i1
blkofs = 0;
200f384: a2 10 20 00 clr %l1
rtems_blkdev_bnum block = (rtems_blkdev_bnum) (args->offset / block_size);
uint32_t blkofs = (uint32_t) (args->offset % block_size);
args->bytes_moved = 0;
while (count > 0)
200f388: 80 a6 e0 00 cmp %i3, 0
200f38c: 12 bf ff e5 bne 200f320 <rtems_blkdev_generic_read+0x58>
200f390: 92 07 00 13 add %i4, %l3, %o1
200f394: 90 10 20 00 clr %o0
blkofs = 0;
block++;
}
return rc;
}
200f398: 81 c7 e0 08 ret
200f39c: 91 e8 00 08 restore %g0, %o0, %o0
0200f3a0 <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)
{
200f3a0: 9d e3 bf 98 save %sp, -104, %sp
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;
200f3a4: c2 06 80 00 ld [ %i2 ], %g1
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);
200f3a8: f8 1e a0 08 ldd [ %i2 + 8 ], %i4
void * arg)
{
rtems_status_code rc = RTEMS_SUCCESSFUL;
rtems_libio_rw_args_t *args = arg;
rtems_libio_t *iop = args->iop;
rtems_disk_device *dd = iop->data1;
200f3ac: e2 00 60 30 ld [ %g1 + 0x30 ], %l1
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);
200f3b0: 90 10 00 1c mov %i4, %o0
{
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;
200f3b4: f2 04 60 24 ld [ %l1 + 0x24 ], %i1
char *buf = args->buffer;
uint32_t count = args->count;
rtems_blkdev_bnum block = (rtems_blkdev_bnum) (args->offset / block_size);
200f3b8: 94 10 20 00 clr %o2
200f3bc: 96 10 00 19 mov %i1, %o3
200f3c0: 40 00 36 e5 call 201cf54 <__divdi3>
200f3c4: 92 10 00 1d mov %i5, %o1
uint32_t blkofs = (uint32_t) (args->offset % block_size);
200f3c8: 90 10 00 1c mov %i4, %o0
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);
200f3cc: a4 10 00 09 mov %o1, %l2
uint32_t blkofs = (uint32_t) (args->offset % block_size);
200f3d0: 94 10 20 00 clr %o2
200f3d4: 92 10 00 1d mov %i5, %o1
200f3d8: 96 10 00 19 mov %i1, %o3
200f3dc: 40 00 37 c9 call 201d300 <__moddi3>
200f3e0: e0 06 a0 10 ld [ %i2 + 0x10 ], %l0
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;
200f3e4: f6 06 a0 14 ld [ %i2 + 0x14 ], %i3
rtems_blkdev_bnum block = (rtems_blkdev_bnum) (args->offset / block_size);
uint32_t blkofs = (uint32_t) (args->offset % block_size);
200f3e8: b8 10 00 09 mov %o1, %i4
args->bytes_moved = 0;
200f3ec: c0 26 a0 1c clr [ %i2 + 0x1c ]
while (count > 0)
200f3f0: 10 80 00 26 b 200f488 <rtems_blkdev_generic_write+0xe8>
200f3f4: b0 10 20 00 clr %i0
{
rtems_bdbuf_buffer *diskbuf;
uint32_t copy;
if ((blkofs == 0) && (count >= block_size))
rc = rtems_bdbuf_get(dd, block, &diskbuf);
200f3f8: 90 10 00 11 mov %l1, %o0
while (count > 0)
{
rtems_bdbuf_buffer *diskbuf;
uint32_t copy;
if ((blkofs == 0) && (count >= block_size))
200f3fc: 80 a6 c0 19 cmp %i3, %i1
200f400: 0a 80 00 09 bcs 200f424 <rtems_blkdev_generic_write+0x84> <== NEVER TAKEN
200f404: 94 07 bf fc add %fp, -4, %o2
200f408: 80 a7 20 00 cmp %i4, 0
200f40c: 12 80 00 06 bne 200f424 <rtems_blkdev_generic_write+0x84> <== NEVER TAKEN
200f410: 01 00 00 00 nop
rc = rtems_bdbuf_get(dd, block, &diskbuf);
200f414: 7f ff fd 35 call 200e8e8 <rtems_bdbuf_get>
200f418: 01 00 00 00 nop
else
rc = rtems_bdbuf_read(dd, block, &diskbuf);
if (rc != RTEMS_SUCCESSFUL)
200f41c: 10 80 00 05 b 200f430 <rtems_blkdev_generic_write+0x90>
200f420: 80 a2 20 00 cmp %o0, 0
uint32_t copy;
if ((blkofs == 0) && (count >= block_size))
rc = rtems_bdbuf_get(dd, block, &diskbuf);
else
rc = rtems_bdbuf_read(dd, block, &diskbuf);
200f424: 7f ff fd 62 call 200e9ac <rtems_bdbuf_read> <== NOT EXECUTED
200f428: 01 00 00 00 nop <== NOT EXECUTED
if (rc != RTEMS_SUCCESSFUL)
200f42c: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
200f430: 12 80 00 1a bne 200f498 <rtems_blkdev_generic_write+0xf8> <== NEVER TAKEN
200f434: ba 26 40 1c sub %i1, %i4, %i5
200f438: 80 a7 40 1b cmp %i5, %i3
200f43c: 38 80 00 02 bgu,a 200f444 <rtems_blkdev_generic_write+0xa4><== NEVER TAKEN
200f440: ba 10 00 1b mov %i3, %i5 <== NOT EXECUTED
break;
copy = block_size - blkofs;
if (copy > count)
copy = count;
memcpy((char *)diskbuf->buffer + blkofs, buf, copy);
200f444: c2 07 bf fc ld [ %fp + -4 ], %g1
200f448: 92 10 00 10 mov %l0, %o1
200f44c: d0 00 60 1c ld [ %g1 + 0x1c ], %o0
200f450: 94 10 00 1d mov %i5, %o2
200f454: 40 00 14 17 call 20144b0 <memcpy>
200f458: 90 02 00 1c add %o0, %i4, %o0
args->bytes_moved += copy;
200f45c: c2 06 a0 1c ld [ %i2 + 0x1c ], %g1
rc = rtems_bdbuf_release_modified(diskbuf);
200f460: d0 07 bf fc ld [ %fp + -4 ], %o0
copy = block_size - blkofs;
if (copy > count)
copy = count;
memcpy((char *)diskbuf->buffer + blkofs, buf, copy);
args->bytes_moved += copy;
200f464: 82 00 40 1d add %g1, %i5, %g1
200f468: b0 06 20 01 inc %i0
rc = rtems_bdbuf_release_modified(diskbuf);
200f46c: 7f ff fe 02 call 200ec74 <rtems_bdbuf_release_modified>
200f470: c2 26 a0 1c st %g1, [ %i2 + 0x1c ]
if (rc != RTEMS_SUCCESSFUL)
200f474: 80 a2 20 00 cmp %o0, 0
200f478: 12 80 00 08 bne 200f498 <rtems_blkdev_generic_write+0xf8> <== NEVER TAKEN
200f47c: b6 26 c0 1d sub %i3, %i5, %i3
break;
count -= copy;
buf += copy;
200f480: a0 04 00 1d add %l0, %i5, %l0
blkofs = 0;
200f484: b8 10 20 00 clr %i4
rtems_blkdev_bnum block = (rtems_blkdev_bnum) (args->offset / block_size);
uint32_t blkofs = (uint32_t) (args->offset % block_size);
args->bytes_moved = 0;
while (count > 0)
200f488: 80 a6 e0 00 cmp %i3, 0
200f48c: 12 bf ff db bne 200f3f8 <rtems_blkdev_generic_write+0x58>
200f490: 92 06 00 12 add %i0, %l2, %o1
200f494: 90 10 20 00 clr %o0
blkofs = 0;
block++;
}
return rc;
}
200f498: 81 c7 e0 08 ret
200f49c: 91 e8 00 08 restore %g0, %o0, %o0
02003a94 <rtems_blkdev_imfs_fsync_or_fdatasync>:
}
static int rtems_blkdev_imfs_fsync_or_fdatasync(
rtems_libio_t *iop
)
{
2003a94: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED
static inline void *IMFS_generic_get_context_by_node(
const IMFS_jnode_t *node
)
{
return node->info.generic.context;
2003a98: c2 06 20 1c ld [ %i0 + 0x1c ], %g1 <== NOT EXECUTED
int rv = 0;
2003a9c: b0 10 20 00 clr %i0 <== NOT EXECUTED
rtems_blkdev_imfs_context *ctx = IMFS_generic_get_context_by_iop(iop);
rtems_disk_device *dd = &ctx->dd;
rtems_status_code sc = rtems_bdbuf_syncdev(dd);
2003aa0: 40 00 2f ae call 200f958 <rtems_bdbuf_syncdev> <== NOT EXECUTED
2003aa4: d0 00 60 50 ld [ %g1 + 0x50 ], %o0 <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL) {
2003aa8: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2003aac: 02 80 00 06 be 2003ac4 <rtems_blkdev_imfs_fsync_or_fdatasync+0x30><== NOT EXECUTED
2003ab0: 01 00 00 00 nop <== NOT EXECUTED
errno = EIO;
2003ab4: 40 00 41 b6 call 201418c <__errno> <== NOT EXECUTED
2003ab8: b0 10 3f ff mov -1, %i0 ! ffffffff <RAM_END+0xfdbfffff> <== NOT EXECUTED
2003abc: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
2003ac0: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
rv = -1;
}
return rv;
}
2003ac4: 81 c7 e0 08 ret <== NOT EXECUTED
2003ac8: 81 e8 00 00 restore <== NOT EXECUTED
02003acc <rtems_blkdev_imfs_ioctl>:
static int rtems_blkdev_imfs_ioctl(
rtems_libio_t *iop,
uint32_t request,
void *buffer
)
{
2003acc: 9d e3 bf a0 save %sp, -96, %sp
int rv = 0;
if (request != RTEMS_BLKIO_REQUEST) {
2003ad0: 03 30 06 10 sethi %hi(0xc0184000), %g1
2003ad4: 82 10 62 01 or %g1, 0x201, %g1 ! c0184201 <RAM_END+0xbdd84201>
2003ad8: 80 a6 40 01 cmp %i1, %g1
2003adc: 02 80 00 09 be 2003b00 <rtems_blkdev_imfs_ioctl+0x34> <== NEVER TAKEN
2003ae0: 92 10 00 19 mov %i1, %o1
2003ae4: c2 06 20 1c ld [ %i0 + 0x1c ], %g1
2003ae8: d0 00 60 50 ld [ %g1 + 0x50 ], %o0
rtems_blkdev_imfs_context *ctx = IMFS_generic_get_context_by_iop(iop);
rtems_disk_device *dd = &ctx->dd;
rv = (*dd->ioctl)(dd, request, buffer);
2003aec: c2 02 20 38 ld [ %o0 + 0x38 ], %g1
2003af0: 9f c0 40 00 call %g1
2003af4: 94 10 00 1a mov %i2, %o2
2003af8: 81 c7 e0 08 ret
2003afc: 91 e8 00 08 restore %g0, %o0, %o0
} else {
/*
* It is not allowed to directly access the driver circumventing the cache.
*/
errno = EINVAL;
2003b00: 40 00 41 a3 call 201418c <__errno> <== NOT EXECUTED
2003b04: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
2003b08: 82 10 20 16 mov 0x16, %g1 <== NOT EXECUTED
2003b0c: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
rv = -1;
}
return rv;
}
2003b10: 81 c7 e0 08 ret <== NOT EXECUTED
2003b14: 81 e8 00 00 restore <== NOT EXECUTED
02003918 <rtems_blkdev_imfs_read>:
static ssize_t rtems_blkdev_imfs_read(
rtems_libio_t *iop,
void *buffer,
size_t count
)
{
2003918: 9d e3 bf 98 save %sp, -104, %sp
200391c: c2 06 20 1c ld [ %i0 + 0x1c ], %g1
int rv;
rtems_blkdev_imfs_context *ctx = IMFS_generic_get_context_by_iop(iop);
rtems_disk_device *dd = &ctx->dd;
ssize_t remaining = (ssize_t) count;
off_t offset = iop->offset;
2003920: f8 1e 20 08 ldd [ %i0 + 8 ], %i4
2003924: e4 00 60 50 ld [ %g1 + 0x50 ], %l2
ssize_t block_size = (ssize_t) rtems_disk_get_block_size(dd);
rtems_blkdev_bnum block = (rtems_blkdev_bnum) (offset / block_size);
2003928: 92 10 00 1d mov %i5, %o1
int rv;
rtems_blkdev_imfs_context *ctx = IMFS_generic_get_context_by_iop(iop);
rtems_disk_device *dd = &ctx->dd;
ssize_t remaining = (ssize_t) count;
off_t offset = iop->offset;
ssize_t block_size = (ssize_t) rtems_disk_get_block_size(dd);
200392c: f6 04 a0 24 ld [ %l2 + 0x24 ], %i3
rtems_blkdev_bnum block = (rtems_blkdev_bnum) (offset / block_size);
2003930: 90 10 00 1c mov %i4, %o0
2003934: a3 3e e0 1f sra %i3, 0x1f, %l1
2003938: 96 10 00 1b mov %i3, %o3
200393c: 40 00 67 65 call 201d6d0 <__divdi3>
2003940: 94 10 00 11 mov %l1, %o2
ssize_t block_offset = (ssize_t) (offset % block_size);
2003944: 94 10 00 11 mov %l1, %o2
rtems_blkdev_imfs_context *ctx = IMFS_generic_get_context_by_iop(iop);
rtems_disk_device *dd = &ctx->dd;
ssize_t remaining = (ssize_t) count;
off_t offset = iop->offset;
ssize_t block_size = (ssize_t) rtems_disk_get_block_size(dd);
rtems_blkdev_bnum block = (rtems_blkdev_bnum) (offset / block_size);
2003948: a0 10 00 09 mov %o1, %l0
ssize_t block_offset = (ssize_t) (offset % block_size);
200394c: 90 10 00 1c mov %i4, %o0
2003950: 92 10 00 1d mov %i5, %o1
2003954: 96 10 00 1b mov %i3, %o3
2003958: 40 00 68 49 call 201da7c <__moddi3>
200395c: ba 10 00 1a mov %i2, %i5
char *dst = buffer;
while (remaining > 0) {
2003960: 10 80 00 19 b 20039c4 <rtems_blkdev_imfs_read+0xac>
2003964: a2 10 00 09 mov %o1, %l1
rtems_bdbuf_buffer *bd;
rtems_status_code sc = rtems_bdbuf_read(dd, block, &bd);
2003968: 92 10 00 10 mov %l0, %o1
200396c: 40 00 2e db call 200f4d8 <rtems_bdbuf_read>
2003970: 94 07 bf fc add %fp, -4, %o2
if (sc == RTEMS_SUCCESSFUL) {
2003974: 80 a2 20 00 cmp %o0, 0
2003978: 12 80 00 1f bne 20039f4 <rtems_blkdev_imfs_read+0xdc> <== NEVER TAKEN
200397c: b8 26 c0 11 sub %i3, %l1, %i4
2003980: 80 a7 00 1d cmp %i4, %i5
2003984: 34 80 00 02 bg,a 200398c <rtems_blkdev_imfs_read+0x74>
2003988: b8 10 00 1d mov %i5, %i4
if (copy > remaining) {
copy = remaining;
}
memcpy(dst, (char *) bd->buffer + block_offset, (size_t) copy);
200398c: c2 07 bf fc ld [ %fp + -4 ], %g1
2003990: 94 10 00 1c mov %i4, %o2
2003994: d2 00 60 1c ld [ %g1 + 0x1c ], %o1
2003998: 90 10 00 19 mov %i1, %o0
200399c: 40 00 44 6d call 2014b50 <memcpy>
20039a0: 92 02 40 11 add %o1, %l1, %o1
sc = rtems_bdbuf_release(bd);
20039a4: 40 00 2f 4a call 200f6cc <rtems_bdbuf_release>
20039a8: d0 07 bf fc ld [ %fp + -4 ], %o0
if (sc == RTEMS_SUCCESSFUL) {
20039ac: 80 a2 20 00 cmp %o0, 0
20039b0: 12 80 00 11 bne 20039f4 <rtems_blkdev_imfs_read+0xdc> <== NEVER TAKEN
20039b4: ba 27 40 1c sub %i5, %i4, %i5
block_offset = 0;
remaining -= copy;
dst += copy;
20039b8: b2 06 40 1c add %i1, %i4, %i1
++block;
20039bc: a0 04 20 01 inc %l0
memcpy(dst, (char *) bd->buffer + block_offset, (size_t) copy);
sc = rtems_bdbuf_release(bd);
if (sc == RTEMS_SUCCESSFUL) {
block_offset = 0;
20039c0: a2 10 20 00 clr %l1
ssize_t block_size = (ssize_t) rtems_disk_get_block_size(dd);
rtems_blkdev_bnum block = (rtems_blkdev_bnum) (offset / block_size);
ssize_t block_offset = (ssize_t) (offset % block_size);
char *dst = buffer;
while (remaining > 0) {
20039c4: 80 a7 60 00 cmp %i5, 0
20039c8: 14 bf ff e8 bg 2003968 <rtems_blkdev_imfs_read+0x50>
20039cc: 90 10 00 12 mov %l2, %o0
} else {
remaining = -1;
}
}
if (remaining >= 0) {
20039d0: 80 a7 60 00 cmp %i5, 0
20039d4: 12 80 00 08 bne 20039f4 <rtems_blkdev_imfs_read+0xdc> <== NEVER TAKEN
20039d8: 01 00 00 00 nop
iop->offset += count;
20039dc: c4 1e 20 08 ldd [ %i0 + 8 ], %g2
20039e0: 86 80 c0 1a addcc %g3, %i2, %g3
20039e4: 84 40 a0 00 addx %g2, 0, %g2
20039e8: c4 3e 20 08 std %g2, [ %i0 + 8 ]
rv = (ssize_t) count;
20039ec: 81 c7 e0 08 ret
20039f0: 91 e8 00 1a restore %g0, %i2, %o0
} else {
errno = EIO;
20039f4: 40 00 41 e6 call 201418c <__errno> <== NOT EXECUTED
20039f8: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
20039fc: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
2003a00: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
rv = -1;
}
return rv;
}
2003a04: 81 c7 e0 08 ret <== NOT EXECUTED
2003a08: 81 e8 00 00 restore <== NOT EXECUTED
020037ec <rtems_blkdev_imfs_write>:
static ssize_t rtems_blkdev_imfs_write(
rtems_libio_t *iop,
const void *buffer,
size_t count
)
{
20037ec: 9d e3 bf 98 save %sp, -104, %sp
20037f0: c2 06 20 1c ld [ %i0 + 0x1c ], %g1
int rv;
rtems_blkdev_imfs_context *ctx = IMFS_generic_get_context_by_iop(iop);
rtems_disk_device *dd = &ctx->dd;
ssize_t remaining = (ssize_t) count;
off_t offset = iop->offset;
20037f4: f8 1e 20 08 ldd [ %i0 + 8 ], %i4
20037f8: e4 00 60 50 ld [ %g1 + 0x50 ], %l2
ssize_t block_size = (ssize_t) rtems_disk_get_block_size(dd);
rtems_blkdev_bnum block = (rtems_blkdev_bnum) (offset / block_size);
20037fc: 92 10 00 1d mov %i5, %o1
int rv;
rtems_blkdev_imfs_context *ctx = IMFS_generic_get_context_by_iop(iop);
rtems_disk_device *dd = &ctx->dd;
ssize_t remaining = (ssize_t) count;
off_t offset = iop->offset;
ssize_t block_size = (ssize_t) rtems_disk_get_block_size(dd);
2003800: f6 04 a0 24 ld [ %l2 + 0x24 ], %i3
rtems_blkdev_bnum block = (rtems_blkdev_bnum) (offset / block_size);
2003804: 90 10 00 1c mov %i4, %o0
2003808: a3 3e e0 1f sra %i3, 0x1f, %l1
200380c: 96 10 00 1b mov %i3, %o3
2003810: 40 00 67 b0 call 201d6d0 <__divdi3>
2003814: 94 10 00 11 mov %l1, %o2
ssize_t block_offset = (ssize_t) (offset % block_size);
2003818: 94 10 00 11 mov %l1, %o2
rtems_blkdev_imfs_context *ctx = IMFS_generic_get_context_by_iop(iop);
rtems_disk_device *dd = &ctx->dd;
ssize_t remaining = (ssize_t) count;
off_t offset = iop->offset;
ssize_t block_size = (ssize_t) rtems_disk_get_block_size(dd);
rtems_blkdev_bnum block = (rtems_blkdev_bnum) (offset / block_size);
200381c: a0 10 00 09 mov %o1, %l0
ssize_t block_offset = (ssize_t) (offset % block_size);
2003820: 90 10 00 1c mov %i4, %o0
2003824: 92 10 00 1d mov %i5, %o1
2003828: 96 10 00 1b mov %i3, %o3
200382c: 40 00 68 94 call 201da7c <__moddi3>
2003830: ba 10 00 1a mov %i2, %i5
const char *src = buffer;
while (remaining > 0) {
2003834: 10 80 00 27 b 20038d0 <rtems_blkdev_imfs_write+0xe4>
2003838: a2 10 00 09 mov %o1, %l1
rtems_status_code sc;
rtems_bdbuf_buffer *bd;
if (block_offset == 0 && remaining >= block_size) {
200383c: 16 80 00 03 bge 2003848 <rtems_blkdev_imfs_write+0x5c>
2003840: 82 10 20 01 mov 1, %g1
2003844: 82 10 20 00 clr %g1
sc = rtems_bdbuf_get(dd, block, &bd);
2003848: 90 10 00 12 mov %l2, %o0
200384c: 92 10 00 10 mov %l0, %o1
while (remaining > 0) {
rtems_status_code sc;
rtems_bdbuf_buffer *bd;
if (block_offset == 0 && remaining >= block_size) {
2003850: 80 88 60 ff btst 0xff, %g1
2003854: 02 80 00 09 be 2003878 <rtems_blkdev_imfs_write+0x8c>
2003858: 94 07 bf fc add %fp, -4, %o2
200385c: 80 a4 60 00 cmp %l1, 0
2003860: 12 80 00 06 bne 2003878 <rtems_blkdev_imfs_write+0x8c>
2003864: 01 00 00 00 nop
sc = rtems_bdbuf_get(dd, block, &bd);
2003868: 40 00 2e eb call 200f414 <rtems_bdbuf_get>
200386c: 01 00 00 00 nop
} else {
sc = rtems_bdbuf_read(dd, block, &bd);
}
if (sc == RTEMS_SUCCESSFUL) {
2003870: 10 80 00 05 b 2003884 <rtems_blkdev_imfs_write+0x98>
2003874: 80 a2 20 00 cmp %o0, 0
rtems_bdbuf_buffer *bd;
if (block_offset == 0 && remaining >= block_size) {
sc = rtems_bdbuf_get(dd, block, &bd);
} else {
sc = rtems_bdbuf_read(dd, block, &bd);
2003878: 40 00 2f 18 call 200f4d8 <rtems_bdbuf_read>
200387c: 01 00 00 00 nop
}
if (sc == RTEMS_SUCCESSFUL) {
2003880: 80 a2 20 00 cmp %o0, 0
2003884: 12 80 00 1f bne 2003900 <rtems_blkdev_imfs_write+0x114> <== NEVER TAKEN
2003888: b8 26 c0 11 sub %i3, %l1, %i4
200388c: 80 a7 00 1d cmp %i4, %i5
2003890: 34 80 00 02 bg,a 2003898 <rtems_blkdev_imfs_write+0xac>
2003894: b8 10 00 1d mov %i5, %i4
if (copy > remaining) {
copy = remaining;
}
memcpy((char *) bd->buffer + block_offset, src, (size_t) copy);
2003898: c2 07 bf fc ld [ %fp + -4 ], %g1
200389c: 92 10 00 19 mov %i1, %o1
20038a0: d0 00 60 1c ld [ %g1 + 0x1c ], %o0
20038a4: 94 10 00 1c mov %i4, %o2
20038a8: 40 00 44 aa call 2014b50 <memcpy>
20038ac: 90 02 00 11 add %o0, %l1, %o0
sc = rtems_bdbuf_release_modified(bd);
20038b0: 40 00 2f bc call 200f7a0 <rtems_bdbuf_release_modified>
20038b4: d0 07 bf fc ld [ %fp + -4 ], %o0
if (sc == RTEMS_SUCCESSFUL) {
20038b8: 80 a2 20 00 cmp %o0, 0
20038bc: 12 80 00 11 bne 2003900 <rtems_blkdev_imfs_write+0x114> <== NEVER TAKEN
20038c0: ba 27 40 1c sub %i5, %i4, %i5
block_offset = 0;
remaining -= copy;
src += copy;
20038c4: b2 06 40 1c add %i1, %i4, %i1
++block;
20038c8: a0 04 20 01 inc %l0
memcpy((char *) bd->buffer + block_offset, src, (size_t) copy);
sc = rtems_bdbuf_release_modified(bd);
if (sc == RTEMS_SUCCESSFUL) {
block_offset = 0;
20038cc: a2 10 20 00 clr %l1
ssize_t block_size = (ssize_t) rtems_disk_get_block_size(dd);
rtems_blkdev_bnum block = (rtems_blkdev_bnum) (offset / block_size);
ssize_t block_offset = (ssize_t) (offset % block_size);
const char *src = buffer;
while (remaining > 0) {
20038d0: 80 a7 60 00 cmp %i5, 0
20038d4: 14 bf ff da bg 200383c <rtems_blkdev_imfs_write+0x50>
20038d8: 80 a7 40 1b cmp %i5, %i3
} else {
remaining = -1;
}
}
if (remaining >= 0) {
20038dc: 80 a7 60 00 cmp %i5, 0
20038e0: 12 80 00 08 bne 2003900 <rtems_blkdev_imfs_write+0x114> <== NEVER TAKEN
20038e4: 01 00 00 00 nop
iop->offset += count;
20038e8: c4 1e 20 08 ldd [ %i0 + 8 ], %g2
20038ec: 86 80 c0 1a addcc %g3, %i2, %g3
20038f0: 84 40 a0 00 addx %g2, 0, %g2
20038f4: c4 3e 20 08 std %g2, [ %i0 + 8 ]
rv = (ssize_t) count;
20038f8: 81 c7 e0 08 ret
20038fc: 91 e8 00 1a restore %g0, %i2, %o0
} else {
errno = EIO;
2003900: 40 00 42 23 call 201418c <__errno> <== NOT EXECUTED
2003904: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
2003908: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
200390c: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
rv = -1;
}
return rv;
}
2003910: 81 c7 e0 08 ret <== NOT EXECUTED
2003914: 81 e8 00 00 restore <== NOT EXECUTED
0200f174 <rtems_blkdev_ioctl>:
#include <rtems/blkdev.h>
#include <rtems/bdbuf.h>
int
rtems_blkdev_ioctl(rtems_disk_device *dd, uint32_t req, void *argp)
{
200f174: 9d e3 bf a0 save %sp, -96, %sp
rtems_status_code sc;
int rc = 0;
switch (req)
200f178: 03 10 01 10 sethi %hi(0x40044000), %g1
200f17c: 84 10 62 03 or %g1, 0x203, %g2 ! 40044203 <RAM_END+0x3dc44203>
200f180: 80 a6 40 02 cmp %i1, %g2
200f184: 02 80 00 2e be 200f23c <rtems_blkdev_ioctl+0xc8>
200f188: 90 10 00 18 mov %i0, %o0
200f18c: 80 a6 40 02 cmp %i1, %g2
200f190: 18 80 00 16 bgu 200f1e8 <rtems_blkdev_ioctl+0x74>
200f194: 84 10 62 09 or %g1, 0x209, %g2
200f198: 05 08 00 10 sethi %hi(0x20004000), %g2
200f19c: 86 10 a2 0a or %g2, 0x20a, %g3 ! 2000420a <RAM_END+0x1dc0420a>
200f1a0: 80 a6 40 03 cmp %i1, %g3
200f1a4: 02 80 00 37 be 200f280 <rtems_blkdev_ioctl+0x10c>
200f1a8: 01 00 00 00 nop
200f1ac: 38 80 00 07 bgu,a 200f1c8 <rtems_blkdev_ioctl+0x54>
200f1b0: 84 10 a2 0c or %g2, 0x20c, %g2
200f1b4: 84 10 a2 06 or %g2, 0x206, %g2
200f1b8: 80 a6 40 02 cmp %i1, %g2
200f1bc: 12 80 00 3c bne 200f2ac <rtems_blkdev_ioctl+0x138>
200f1c0: 01 00 00 00 nop
200f1c4: 30 80 00 26 b,a 200f25c <rtems_blkdev_ioctl+0xe8>
200f1c8: 80 a6 40 02 cmp %i1, %g2
200f1cc: 02 80 00 34 be 200f29c <rtems_blkdev_ioctl+0x128> <== NEVER TAKEN
200f1d0: 82 10 62 02 or %g1, 0x202, %g1
200f1d4: 80 a6 40 01 cmp %i1, %g1
200f1d8: 12 80 00 35 bne 200f2ac <rtems_blkdev_ioctl+0x138> <== NEVER TAKEN
200f1dc: 01 00 00 00 nop
{
case RTEMS_BLKIO_GETMEDIABLKSIZE:
*(uint32_t *) argp = dd->media_block_size;
200f1e0: 10 80 00 15 b 200f234 <rtems_blkdev_ioctl+0xc0>
200f1e4: c2 06 20 20 ld [ %i0 + 0x20 ], %g1
rtems_blkdev_ioctl(rtems_disk_device *dd, uint32_t req, void *argp)
{
rtems_status_code sc;
int rc = 0;
switch (req)
200f1e8: 80 a6 40 02 cmp %i1, %g2
200f1ec: 22 80 00 2e be,a 200f2a4 <rtems_blkdev_ioctl+0x130>
200f1f0: f0 26 80 00 st %i0, [ %i2 ]
200f1f4: 38 80 00 08 bgu,a 200f214 <rtems_blkdev_ioctl+0xa0>
200f1f8: 82 10 62 0b or %g1, 0x20b, %g1
200f1fc: 82 10 62 05 or %g1, 0x205, %g1
200f200: 80 a6 40 01 cmp %i1, %g1
200f204: 12 80 00 2a bne 200f2ac <rtems_blkdev_ioctl+0x138> <== NEVER TAKEN
200f208: 01 00 00 00 nop
rc = -1;
}
break;
case RTEMS_BLKIO_GETSIZE:
*(rtems_blkdev_bnum *) argp = dd->size;
200f20c: 10 80 00 12 b 200f254 <rtems_blkdev_ioctl+0xe0>
200f210: c2 06 20 1c ld [ %i0 + 0x1c ], %g1
rtems_blkdev_ioctl(rtems_disk_device *dd, uint32_t req, void *argp)
{
rtems_status_code sc;
int rc = 0;
switch (req)
200f214: 80 a6 40 01 cmp %i1, %g1
200f218: 02 80 00 1d be 200f28c <rtems_blkdev_ioctl+0x118> <== NEVER TAKEN
200f21c: 03 20 01 10 sethi %hi(0x80044000), %g1
200f220: 82 10 62 04 or %g1, 0x204, %g1 ! 80044204 <RAM_END+0x7dc44204>
200f224: 80 a6 40 01 cmp %i1, %g1
200f228: 12 80 00 21 bne 200f2ac <rtems_blkdev_ioctl+0x138> <== NEVER TAKEN
200f22c: 01 00 00 00 nop
200f230: 30 80 00 05 b,a 200f244 <rtems_blkdev_ioctl+0xd0>
rc = -1;
}
break;
case RTEMS_BLKIO_GETSIZE:
*(rtems_blkdev_bnum *) argp = dd->size;
200f234: 10 80 00 1c b 200f2a4 <rtems_blkdev_ioctl+0x130>
200f238: c2 26 80 00 st %g1, [ %i2 ]
case RTEMS_BLKIO_GETMEDIABLKSIZE:
*(uint32_t *) argp = dd->media_block_size;
break;
case RTEMS_BLKIO_GETBLKSIZE:
*(uint32_t *) argp = dd->block_size;
200f23c: 10 80 00 06 b 200f254 <rtems_blkdev_ioctl+0xe0>
200f240: c2 06 20 24 ld [ %i0 + 0x24 ], %g1
break;
case RTEMS_BLKIO_SETBLKSIZE:
sc = rtems_bdbuf_set_block_size(dd, *(uint32_t *) argp);
200f244: 7f ff ff 7f call 200f040 <rtems_bdbuf_set_block_size>
200f248: d2 06 80 00 ld [ %i2 ], %o1
*(rtems_blkdev_bnum *) argp = dd->size;
break;
case RTEMS_BLKIO_SYNCDEV:
sc = rtems_bdbuf_syncdev(dd);
if (sc != RTEMS_SUCCESSFUL) {
200f24c: 10 80 00 07 b 200f268 <rtems_blkdev_ioctl+0xf4>
200f250: 80 a2 20 00 cmp %o0, 0
rc = -1;
}
break;
case RTEMS_BLKIO_GETSIZE:
*(rtems_blkdev_bnum *) argp = dd->size;
200f254: 10 80 00 14 b 200f2a4 <rtems_blkdev_ioctl+0x130>
200f258: c2 26 80 00 st %g1, [ %i2 ]
break;
case RTEMS_BLKIO_SYNCDEV:
sc = rtems_bdbuf_syncdev(dd);
200f25c: 7f ff fe f4 call 200ee2c <rtems_bdbuf_syncdev>
200f260: 01 00 00 00 nop
if (sc != RTEMS_SUCCESSFUL) {
200f264: 80 a2 20 00 cmp %o0, 0
200f268: 22 80 00 16 be,a 200f2c0 <rtems_blkdev_ioctl+0x14c> <== ALWAYS TAKEN
200f26c: b0 10 20 00 clr %i0
errno = EIO;
200f270: 40 00 12 49 call 2013b94 <__errno> <== NOT EXECUTED
200f274: 01 00 00 00 nop <== NOT EXECUTED
200f278: 10 80 00 10 b 200f2b8 <rtems_blkdev_ioctl+0x144> <== NOT EXECUTED
200f27c: 82 10 20 05 mov 5, %g1 ! 5 <PROM_START+0x5> <== NOT EXECUTED
case RTEMS_BLKIO_GETDISKDEV:
*(rtems_disk_device **) argp = dd;
break;
case RTEMS_BLKIO_PURGEDEV:
rtems_bdbuf_purge_dev(dd);
200f280: 7f ff ff 03 call 200ee8c <rtems_bdbuf_purge_dev>
200f284: b0 10 20 00 clr %i0
200f288: 30 80 00 0e b,a 200f2c0 <rtems_blkdev_ioctl+0x14c>
break;
case RTEMS_BLKIO_GETDEVSTATS:
rtems_bdbuf_get_device_stats(dd, (rtems_blkdev_stats *) argp);
200f28c: 7f ff ff a8 call 200f12c <rtems_bdbuf_get_device_stats> <== NOT EXECUTED
200f290: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED
int
rtems_blkdev_ioctl(rtems_disk_device *dd, uint32_t req, void *argp)
{
rtems_status_code sc;
int rc = 0;
200f294: 81 c7 e0 08 ret <== NOT EXECUTED
200f298: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED
case RTEMS_BLKIO_GETDEVSTATS:
rtems_bdbuf_get_device_stats(dd, (rtems_blkdev_stats *) argp);
break;
case RTEMS_BLKIO_RESETDEVSTATS:
rtems_bdbuf_reset_device_stats(dd);
200f29c: 7f ff ff ad call 200f150 <rtems_bdbuf_reset_device_stats> <== NOT EXECUTED
200f2a0: 01 00 00 00 nop <== NOT EXECUTED
break;
200f2a4: 81 c7 e0 08 ret
200f2a8: 91 e8 20 00 restore %g0, 0, %o0
default:
errno = EINVAL;
200f2ac: 40 00 12 3a call 2013b94 <__errno>
200f2b0: 01 00 00 00 nop
200f2b4: 82 10 20 16 mov 0x16, %g1 ! 16 <PROM_START+0x16>
200f2b8: c2 22 00 00 st %g1, [ %o0 ]
rc = -1;
200f2bc: b0 10 3f ff mov -1, %i0
break;
}
return rc;
}
200f2c0: 81 c7 e0 08 ret
200f2c4: 81 e8 00 00 restore
02024bf4 <rtems_blkstats>:
#include <fcntl.h>
#include <unistd.h>
#include <errno.h>
void rtems_blkstats(FILE *output, const char *device, bool reset)
{
2024bf4: 9d e3 bf 38 save %sp, -200, %sp <== NOT EXECUTED
int fd = open(device, O_RDONLY);
2024bf8: 92 10 20 00 clr %o1 <== NOT EXECUTED
2024bfc: 7f ff 93 ba call 2009ae4 <open> <== NOT EXECUTED
2024c00: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
if (fd >= 0) {
2024c04: ba 92 20 00 orcc %o0, 0, %i5 <== NOT EXECUTED
2024c08: 06 80 00 51 bl 2024d4c <rtems_blkstats+0x158> <== NOT EXECUTED
2024c0c: 01 00 00 00 nop <== NOT EXECUTED
struct stat st;
int rv;
rv = fstat(fd, &st);
2024c10: 40 00 0c c5 call 2027f24 <fstat> <== NOT EXECUTED
2024c14: 92 07 bf b8 add %fp, -72, %o1 <== NOT EXECUTED
if (rv == 0) {
2024c18: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2024c1c: 12 80 00 34 bne 2024cec <rtems_blkstats+0xf8> <== NOT EXECUTED
2024c20: c4 07 bf c4 ld [ %fp + -60 ], %g2 <== NOT EXECUTED
if (S_ISBLK(st.st_mode)) {
2024c24: 03 00 00 3c sethi %hi(0xf000), %g1 <== NOT EXECUTED
2024c28: 84 08 80 01 and %g2, %g1, %g2 <== NOT EXECUTED
2024c2c: 03 00 00 18 sethi %hi(0x6000), %g1 <== NOT EXECUTED
2024c30: 80 a0 80 01 cmp %g2, %g1 <== NOT EXECUTED
2024c34: 32 80 00 2a bne,a 2024cdc <rtems_blkstats+0xe8> <== NOT EXECUTED
2024c38: 11 00 81 8e sethi %hi(0x2063800), %o0 <== NOT EXECUTED
if (reset) {
2024c3c: 80 a6 a0 00 cmp %i2, 0 <== NOT EXECUTED
2024c40: 02 80 00 11 be 2024c84 <rtems_blkstats+0x90> <== NOT EXECUTED
2024c44: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
return ioctl(fd, RTEMS_BLKIO_GETDEVSTATS, stats);
}
static inline int rtems_disk_fd_reset_device_stats(int fd)
{
return ioctl(fd, RTEMS_BLKIO_RESETDEVSTATS);
2024c48: 13 08 00 10 sethi %hi(0x20004000), %o1 <== NOT EXECUTED
2024c4c: 7f ff 90 43 call 2008d58 <ioctl> <== NOT EXECUTED
2024c50: 92 12 62 0c or %o1, 0x20c, %o1 ! 2000420c <RAM_END+0x1dc0420c><== NOT EXECUTED
rv = rtems_disk_fd_reset_device_stats(fd);
if (rv != 0) {
2024c54: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2024c58: 02 80 00 2f be 2024d14 <rtems_blkstats+0x120> <== NOT EXECUTED
2024c5c: 01 00 00 00 nop <== NOT EXECUTED
fprintf(output, "error: reset stats: %s\n", strerror(errno));
2024c60: 40 00 75 63 call 20421ec <__errno> <== NOT EXECUTED
2024c64: 01 00 00 00 nop <== NOT EXECUTED
2024c68: 40 00 91 1f call 20490e4 <strerror> <== NOT EXECUTED
2024c6c: d0 02 00 00 ld [ %o0 ], %o0 <== NOT EXECUTED
2024c70: 13 00 81 8e sethi %hi(0x2063800), %o1 <== NOT EXECUTED
2024c74: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
2024c78: 92 12 63 10 or %o1, 0x310, %o1 <== NOT EXECUTED
2024c7c: 10 80 00 24 b 2024d0c <rtems_blkstats+0x118> <== NOT EXECUTED
2024c80: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
static inline int rtems_disk_fd_get_device_stats(
int fd,
rtems_blkdev_stats *stats
)
{
return ioctl(fd, RTEMS_BLKIO_GETDEVSTATS, stats);
2024c84: 13 10 01 10 sethi %hi(0x40044000), %o1 <== NOT EXECUTED
2024c88: 94 07 bf 98 add %fp, -104, %o2 <== NOT EXECUTED
2024c8c: 7f ff 90 33 call 2008d58 <ioctl> <== NOT EXECUTED
2024c90: 92 12 62 0b or %o1, 0x20b, %o1 <== NOT EXECUTED
}
} else {
rtems_blkdev_stats stats;
rv = rtems_disk_fd_get_device_stats(fd, &stats);
if (rv == 0) {
2024c94: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2024c98: 12 80 00 08 bne 2024cb8 <rtems_blkstats+0xc4> <== NOT EXECUTED
2024c9c: 01 00 00 00 nop <== NOT EXECUTED
rtems_blkdev_print_stats(
2024ca0: 90 07 bf 98 add %fp, -104, %o0 <== NOT EXECUTED
2024ca4: 13 00 81 0b sethi %hi(0x2042c00), %o1 <== NOT EXECUTED
2024ca8: 94 10 00 18 mov %i0, %o2 <== NOT EXECUTED
2024cac: 40 00 00 89 call 2024ed0 <rtems_blkdev_print_stats> <== NOT EXECUTED
2024cb0: 92 12 60 d0 or %o1, 0xd0, %o1 <== NOT EXECUTED
2024cb4: 30 80 00 18 b,a 2024d14 <rtems_blkstats+0x120> <== NOT EXECUTED
&stats,
(rtems_printk_plugin_t) fprintf,
output
);
} else {
fprintf(output, "error: get stats: %s\n", strerror(errno));
2024cb8: 40 00 75 4d call 20421ec <__errno> <== NOT EXECUTED
2024cbc: 01 00 00 00 nop <== NOT EXECUTED
2024cc0: 40 00 91 09 call 20490e4 <strerror> <== NOT EXECUTED
2024cc4: d0 02 00 00 ld [ %o0 ], %o0 <== NOT EXECUTED
2024cc8: 13 00 81 8e sethi %hi(0x2063800), %o1 <== NOT EXECUTED
2024ccc: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
2024cd0: 92 12 63 28 or %o1, 0x328, %o1 <== NOT EXECUTED
2024cd4: 10 80 00 0e b 2024d0c <rtems_blkstats+0x118> <== NOT EXECUTED
2024cd8: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
}
}
} else {
fprintf(output, "error: not a block device\n");
2024cdc: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
2024ce0: 40 00 78 4c call 2042e10 <fputs> <== NOT EXECUTED
2024ce4: 90 12 23 40 or %o0, 0x340, %o0 <== NOT EXECUTED
2024ce8: 30 80 00 0b b,a 2024d14 <rtems_blkstats+0x120> <== NOT EXECUTED
}
} else {
fprintf(output, "error: get file stats: %s\n", strerror(errno));
2024cec: 40 00 75 40 call 20421ec <__errno> <== NOT EXECUTED
2024cf0: 01 00 00 00 nop <== NOT EXECUTED
2024cf4: 40 00 90 fc call 20490e4 <strerror> <== NOT EXECUTED
2024cf8: d0 02 00 00 ld [ %o0 ], %o0 <== NOT EXECUTED
2024cfc: 13 00 81 8e sethi %hi(0x2063800), %o1 <== NOT EXECUTED
2024d00: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
2024d04: 92 12 63 60 or %o1, 0x360, %o1 <== NOT EXECUTED
2024d08: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
2024d0c: 40 00 77 f1 call 2042cd0 <fprintf> <== NOT EXECUTED
2024d10: 01 00 00 00 nop <== NOT EXECUTED
}
rv = close(fd);
2024d14: 7f ff 8e fc call 2008904 <close> <== NOT EXECUTED
2024d18: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
if (rv != 0) {
2024d1c: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2024d20: 02 80 00 15 be 2024d74 <rtems_blkstats+0x180> <== NOT EXECUTED
2024d24: 01 00 00 00 nop <== NOT EXECUTED
fprintf(output, "error: close device: %s\n", strerror(errno));
2024d28: 40 00 75 31 call 20421ec <__errno> <== NOT EXECUTED
2024d2c: 01 00 00 00 nop <== NOT EXECUTED
2024d30: 40 00 90 ed call 20490e4 <strerror> <== NOT EXECUTED
2024d34: d0 02 00 00 ld [ %o0 ], %o0 <== NOT EXECUTED
2024d38: 13 00 81 8e sethi %hi(0x2063800), %o1 <== NOT EXECUTED
2024d3c: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
2024d40: 92 12 63 80 or %o1, 0x380, %o1 <== NOT EXECUTED
2024d44: 10 80 00 0a b 2024d6c <rtems_blkstats+0x178> <== NOT EXECUTED
2024d48: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
}
} else {
fprintf(output, "error: open device: %s\n", strerror(errno));
2024d4c: 40 00 75 28 call 20421ec <__errno> <== NOT EXECUTED
2024d50: 01 00 00 00 nop <== NOT EXECUTED
2024d54: 40 00 90 e4 call 20490e4 <strerror> <== NOT EXECUTED
2024d58: d0 02 00 00 ld [ %o0 ], %o0 <== NOT EXECUTED
2024d5c: 13 00 81 8e sethi %hi(0x2063800), %o1 <== NOT EXECUTED
2024d60: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
2024d64: 92 12 63 a0 or %o1, 0x3a0, %o1 <== NOT EXECUTED
2024d68: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
2024d6c: 40 00 77 d9 call 2042cd0 <fprintf> <== NOT EXECUTED
2024d70: 01 00 00 00 nop <== NOT EXECUTED
2024d74: 81 c7 e0 08 ret <== NOT EXECUTED
2024d78: 81 e8 00 00 restore <== NOT EXECUTED
0200850c <rtems_chain_get_with_wait>:
rtems_chain_control *chain,
rtems_event_set events,
rtems_interval timeout,
rtems_chain_node **node_ptr
)
{
200850c: 9d e3 bf 98 save %sp, -104, %sp
2008510: 30 80 00 08 b,a 2008530 <rtems_chain_get_with_wait+0x24>
while (
sc == RTEMS_SUCCESSFUL
&& (node = rtems_chain_get( chain )) == NULL
) {
rtems_event_set out;
sc = rtems_event_receive(
2008514: 92 10 20 00 clr %o1
2008518: 94 10 00 1a mov %i2, %o2
200851c: 7f ff fd 03 call 2007928 <rtems_event_receive>
2008520: 96 07 bf fc add %fp, -4, %o3
)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_chain_node *node = NULL;
while (
2008524: 80 a2 20 00 cmp %o0, 0
2008528: 32 80 00 09 bne,a 200854c <rtems_chain_get_with_wait+0x40><== ALWAYS TAKEN
200852c: fa 26 c0 00 st %i5, [ %i3 ]
*/
RTEMS_INLINE_ROUTINE rtems_chain_node *rtems_chain_get(
rtems_chain_control *the_chain
)
{
return _Chain_Get( the_chain );
2008530: 40 00 01 88 call 2008b50 <_Chain_Get>
2008534: 90 10 00 18 mov %i0, %o0
sc == RTEMS_SUCCESSFUL
&& (node = rtems_chain_get( chain )) == NULL
2008538: ba 92 20 00 orcc %o0, 0, %i5
200853c: 02 bf ff f6 be 2008514 <rtems_chain_get_with_wait+0x8>
2008540: 90 10 00 19 mov %i1, %o0
2008544: 90 10 20 00 clr %o0
timeout,
&out
);
}
*node_ptr = node;
2008548: fa 26 c0 00 st %i5, [ %i3 ]
return sc;
}
200854c: 81 c7 e0 08 ret
2008550: 91 e8 00 08 restore %g0, %o0, %o0
02003c60 <rtems_cpu_usage_report_with_plugin>:
*/
void rtems_cpu_usage_report_with_plugin(
void *context,
rtems_printk_plugin_t print
)
{
2003c60: 9d e3 bf 70 save %sp, -144, %sp
uint32_t seconds, nanoseconds;
#else
uint32_t total_units = 0;
#endif
if ( !print )
2003c64: 80 a6 60 00 cmp %i1, 0
2003c68: 02 80 00 7a be 2003e50 <rtems_cpu_usage_report_with_plugin+0x1f0><== NEVER TAKEN
2003c6c: 03 00 80 82 sethi %hi(0x2020800), %g1
static inline void _Timestamp64_implementation_Set_to_zero(
Timestamp64_Control *_time
)
{
*_time = 0;
2003c70: c0 27 bf e0 clr [ %fp + -32 ]
2003c74: c0 27 bf e4 clr [ %fp + -28 ]
* 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;
2003c78: f4 18 63 a0 ldd [ %g1 + 0x3a0 ], %i2
}
}
}
#endif
(*print)(
2003c7c: 90 10 00 18 mov %i0, %o0
2003c80: 13 00 80 75 sethi %hi(0x201d400), %o1
if ( !the_thread )
continue;
rtems_object_get_name( the_thread->Object.id, sizeof(name), name );
(*print)(
2003c84: 27 00 80 75 sethi %hi(0x201d400), %l3
}
}
}
#endif
(*print)(
2003c88: 92 12 60 c8 or %o1, 0xc8, %o1
2003c8c: 9f c6 40 00 call %i1
2003c90: 29 00 80 75 sethi %hi(0x201d400), %l4
" ID | NAME | TICKS | PERCENT\n"
#endif
"------------+----------------------------------------+---------------+---------\n"
);
for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; api_index++ ) {
2003c94: a2 10 20 01 mov 1, %l1
if ( !the_thread )
continue;
rtems_object_get_name( the_thread->Object.id, sizeof(name), name );
(*print)(
2003c98: a6 14 e2 40 or %l3, 0x240, %l3
*/
seconds = _Timestamp_Get_seconds( &ran );
nanoseconds = _Timestamp_Get_nanoseconds( &ran ) /
TOD_NANOSECONDS_PER_MICROSECOND;
(*print)( context,
2003c9c: a8 15 22 58 or %l4, 0x258, %l4
#endif
/*
* rtems_cpu_usage_report
*/
void rtems_cpu_usage_report_with_plugin(
2003ca0: 83 2c 60 02 sll %l1, 2, %g1
#if !defined(RTEMS_POSIX_API) || defined(RTEMS_DEBUG)
if ( !_Objects_Information_table[ api_index ] )
continue;
#endif
information = _Objects_Information_table[ api_index ][ 1 ];
2003ca4: 05 00 80 81 sethi %hi(0x2020400), %g2
2003ca8: 84 10 a1 34 or %g2, 0x134, %g2 ! 2020534 <_Objects_Information_table>
2003cac: c2 00 80 01 ld [ %g2 + %g1 ], %g1
2003cb0: e4 00 60 04 ld [ %g1 + 4 ], %l2
if ( information ) {
2003cb4: 80 a4 a0 00 cmp %l2, 0
2003cb8: 12 80 00 4a bne 2003de0 <rtems_cpu_usage_report_with_plugin+0x180><== ALWAYS TAKEN
2003cbc: a0 10 20 01 mov 1, %l0
" ID | NAME | TICKS | PERCENT\n"
#endif
"------------+----------------------------------------+---------------+---------\n"
);
for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; api_index++ ) {
2003cc0: a2 04 60 01 inc %l1 <== NOT EXECUTED
2003cc4: 80 a4 60 04 cmp %l1, 4
2003cc8: 12 bf ff f7 bne 2003ca4 <rtems_cpu_usage_report_with_plugin+0x44>
2003ccc: 83 2c 60 02 sll %l1, 2, %g1
}
}
}
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
seconds = _Timestamp_Get_seconds( &total );
2003cd0: 10 80 00 4a b 2003df8 <rtems_cpu_usage_report_with_plugin+0x198>
2003cd4: f8 1f bf e0 ldd [ %fp + -32 ], %i4
#endif
information = _Objects_Information_table[ api_index ][ 1 ];
if ( information ) {
for ( i=1 ; i <= information->maximum ; i++ ) {
the_thread = (Thread_Control *)information->local_table[ i ];
2003cd8: 83 2c 20 02 sll %l0, 2, %g1
2003cdc: fa 00 80 01 ld [ %g2 + %g1 ], %i5
if ( !the_thread )
2003ce0: 80 a7 60 00 cmp %i5, 0
2003ce4: 02 80 00 3e be 2003ddc <rtems_cpu_usage_report_with_plugin+0x17c><== NEVER TAKEN
2003ce8: 92 10 20 0d mov 0xd, %o1
continue;
rtems_object_get_name( the_thread->Object.id, sizeof(name), name );
2003cec: d0 07 60 08 ld [ %i5 + 8 ], %o0
2003cf0: 40 00 13 94 call 2008b40 <rtems_object_get_name>
2003cf4: 94 07 bf f0 add %fp, -16, %o2
(*print)(
2003cf8: d4 07 60 08 ld [ %i5 + 8 ], %o2
2003cfc: 90 10 00 18 mov %i0, %o0
2003d00: 92 10 00 13 mov %l3, %o1
2003d04: 9f c6 40 00 call %i1
2003d08: 96 07 bf f0 add %fp, -16, %o3
/*
* If this is the currently executing thread, account for time
* since the last context switch.
*/
ran = the_thread->cpu_time_used;
2003d0c: c4 1f 60 80 ldd [ %i5 + 0x80 ], %g2
Thread_Control *the_thread,
Timestamp_Control *time_of_context_switch
)
{
#ifndef RTEMS_SMP
if ( _Thread_Executing->Object.id == the_thread->Object.id ) {
2003d10: 03 00 80 82 sethi %hi(0x2020800), %g1
/*
* If this is the currently executing thread, account for time
* since the last context switch.
*/
ran = the_thread->cpu_time_used;
2003d14: c4 3f bf e8 std %g2, [ %fp + -24 ]
Thread_Control *the_thread,
Timestamp_Control *time_of_context_switch
)
{
#ifndef RTEMS_SMP
if ( _Thread_Executing->Object.id == the_thread->Object.id ) {
2003d18: 82 10 63 40 or %g1, 0x340, %g1
2003d1c: c4 00 60 0c ld [ %g1 + 0xc ], %g2
2003d20: c6 00 a0 08 ld [ %g2 + 8 ], %g3
2003d24: c4 07 60 08 ld [ %i5 + 8 ], %g2
2003d28: 80 a0 c0 02 cmp %g3, %g2
2003d2c: 12 80 00 4b bne 2003e58 <rtems_cpu_usage_report_with_plugin+0x1f8>
2003d30: 01 00 00 00 nop
*time_of_context_switch = _Thread_Time_of_last_context_switch;
2003d34: f8 18 60 20 ldd [ %g1 + 0x20 ], %i4
* 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 );
2003d38: 40 00 18 8e call 2009f70 <_TOD_Get_uptime>
2003d3c: 90 07 bf d8 add %fp, -40, %o0
const Timestamp64_Control *_start,
const Timestamp64_Control *_end,
Timestamp64_Control *_result
)
{
*_result = *_end - *_start;
2003d40: c4 1f bf d8 ldd [ %fp + -40 ], %g2
2003d44: ba a0 c0 1d subcc %g3, %i5, %i5
2003d48: b8 60 80 1c subx %g2, %i4, %i4
static inline void _Timestamp64_implementation_Add_to(
Timestamp64_Control *_time,
const Timestamp64_Control *_add
)
{
*_time += *_add;
2003d4c: c4 1f bf e8 ldd [ %fp + -24 ], %g2
2003d50: 86 80 c0 1d addcc %g3, %i5, %g3
2003d54: 84 40 80 1c addx %g2, %i4, %g2
2003d58: c4 3f bf e8 std %g2, [ %fp + -24 ]
const Timestamp64_Control *_start,
const Timestamp64_Control *_end,
Timestamp64_Control *_result
)
{
*_result = *_end - *_start;
2003d5c: c4 1f bf d8 ldd [ %fp + -40 ], %g2
_Timestamp_Add_to( &ran, &used );
} else {
_TOD_Get_uptime( &uptime );
}
_Timestamp_Subtract( &uptime_at_last_reset, &uptime, &total );
_Timestamp_Divide( &ran, &total, &ival, &fval );
2003d60: 90 07 bf e8 add %fp, -24, %o0
2003d64: 86 a0 c0 1b subcc %g3, %i3, %g3
2003d68: 84 60 80 1a subx %g2, %i2, %g2
2003d6c: 92 07 bf e0 add %fp, -32, %o1
2003d70: c4 3f bf e0 std %g2, [ %fp + -32 ]
2003d74: 94 07 bf d0 add %fp, -48, %o2
2003d78: 40 00 21 f8 call 200c558 <_Timestamp64_Divide>
2003d7c: 96 07 bf d4 add %fp, -44, %o3
/*
* Print the information
*/
seconds = _Timestamp_Get_seconds( &ran );
2003d80: f8 1f bf e8 ldd [ %fp + -24 ], %i4
static inline uint32_t _Timestamp64_implementation_Get_seconds(
const Timestamp64_Control *_time
)
{
return (uint32_t) (*_time / 1000000000L);
2003d84: 94 10 20 00 clr %o2
2003d88: 90 10 00 1c mov %i4, %o0
2003d8c: 92 10 00 1d mov %i5, %o1
2003d90: 17 0e e6 b2 sethi %hi(0x3b9ac800), %o3
2003d94: 40 00 5c 30 call 201ae54 <__divdi3>
2003d98: 96 12 e2 00 or %o3, 0x200, %o3 ! 3b9aca00 <RAM_END+0x395aca00>
static inline uint32_t _Timestamp64_implementation_Get_nanoseconds(
const Timestamp64_Control *_time
)
{
return (uint32_t) (*_time % 1000000000L);
2003d9c: 94 10 20 00 clr %o2
static inline uint32_t _Timestamp64_implementation_Get_seconds(
const Timestamp64_Control *_time
)
{
return (uint32_t) (*_time / 1000000000L);
2003da0: aa 10 00 09 mov %o1, %l5
static inline uint32_t _Timestamp64_implementation_Get_nanoseconds(
const Timestamp64_Control *_time
)
{
return (uint32_t) (*_time % 1000000000L);
2003da4: 90 10 00 1c mov %i4, %o0
2003da8: 92 10 00 1d mov %i5, %o1
2003dac: 17 0e e6 b2 sethi %hi(0x3b9ac800), %o3
2003db0: 40 00 5d 14 call 201b200 <__moddi3>
2003db4: 96 12 e2 00 or %o3, 0x200, %o3 ! 3b9aca00 <RAM_END+0x395aca00>
nanoseconds = _Timestamp_Get_nanoseconds( &ran ) /
2003db8: 90 10 00 09 mov %o1, %o0
2003dbc: 40 00 5a ce call 201a8f4 <.udiv>
2003dc0: 92 10 23 e8 mov 0x3e8, %o1
TOD_NANOSECONDS_PER_MICROSECOND;
(*print)( context,
2003dc4: d8 1f bf d0 ldd [ %fp + -48 ], %o4
/*
* Print the information
*/
seconds = _Timestamp_Get_seconds( &ran );
nanoseconds = _Timestamp_Get_nanoseconds( &ran ) /
2003dc8: 96 10 00 08 mov %o0, %o3
TOD_NANOSECONDS_PER_MICROSECOND;
(*print)( context,
2003dcc: 92 10 00 14 mov %l4, %o1
2003dd0: 90 10 00 18 mov %i0, %o0
2003dd4: 9f c6 40 00 call %i1
2003dd8: 94 10 00 15 mov %l5, %o2
continue;
#endif
information = _Objects_Information_table[ api_index ][ 1 ];
if ( information ) {
for ( i=1 ; i <= information->maximum ; i++ ) {
2003ddc: a0 04 20 01 inc %l0
2003de0: c2 14 a0 10 lduh [ %l2 + 0x10 ], %g1
2003de4: 80 a4 00 01 cmp %l0, %g1
2003de8: 28 bf ff bc bleu,a 2003cd8 <rtems_cpu_usage_report_with_plugin+0x78>
2003dec: c4 04 a0 1c ld [ %l2 + 0x1c ], %g2
" ID | NAME | TICKS | PERCENT\n"
#endif
"------------+----------------------------------------+---------------+---------\n"
);
for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; api_index++ ) {
2003df0: 10 bf ff b5 b 2003cc4 <rtems_cpu_usage_report_with_plugin+0x64>
2003df4: a2 04 60 01 inc %l1
static inline uint32_t _Timestamp64_implementation_Get_seconds(
const Timestamp64_Control *_time
)
{
return (uint32_t) (*_time / 1000000000L);
2003df8: 94 10 20 00 clr %o2
2003dfc: 90 10 00 1c mov %i4, %o0
2003e00: 92 10 00 1d mov %i5, %o1
2003e04: 17 0e e6 b2 sethi %hi(0x3b9ac800), %o3
2003e08: 40 00 5c 13 call 201ae54 <__divdi3>
2003e0c: 96 12 e2 00 or %o3, 0x200, %o3 ! 3b9aca00 <RAM_END+0x395aca00>
static inline uint32_t _Timestamp64_implementation_Get_nanoseconds(
const Timestamp64_Control *_time
)
{
return (uint32_t) (*_time % 1000000000L);
2003e10: 94 10 20 00 clr %o2
static inline uint32_t _Timestamp64_implementation_Get_seconds(
const Timestamp64_Control *_time
)
{
return (uint32_t) (*_time / 1000000000L);
2003e14: b6 10 00 09 mov %o1, %i3
static inline uint32_t _Timestamp64_implementation_Get_nanoseconds(
const Timestamp64_Control *_time
)
{
return (uint32_t) (*_time % 1000000000L);
2003e18: 90 10 00 1c mov %i4, %o0
2003e1c: 92 10 00 1d mov %i5, %o1
2003e20: 17 0e e6 b2 sethi %hi(0x3b9ac800), %o3
2003e24: 40 00 5c f7 call 201b200 <__moddi3>
2003e28: 96 12 e2 00 or %o3, 0x200, %o3 ! 3b9aca00 <RAM_END+0x395aca00>
}
}
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
seconds = _Timestamp_Get_seconds( &total );
nanoseconds = _Timestamp_Get_nanoseconds( &total ) /
2003e2c: 90 10 00 09 mov %o1, %o0
2003e30: 40 00 5a b1 call 201a8f4 <.udiv>
2003e34: 92 10 23 e8 mov 0x3e8, %o1
TOD_NANOSECONDS_PER_MICROSECOND;
(*print)(
2003e38: 13 00 80 75 sethi %hi(0x201d400), %o1
}
}
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
seconds = _Timestamp_Get_seconds( &total );
nanoseconds = _Timestamp_Get_nanoseconds( &total ) /
2003e3c: 96 10 00 08 mov %o0, %o3
TOD_NANOSECONDS_PER_MICROSECOND;
(*print)(
2003e40: 92 12 62 70 or %o1, 0x270, %o1
2003e44: 90 10 00 18 mov %i0, %o0
2003e48: 9f c6 40 00 call %i1
2003e4c: 94 10 00 1b mov %i3, %o2
2003e50: 81 c7 e0 08 ret
2003e54: 81 e8 00 00 restore
Timestamp_Control used;
_TOD_Get_uptime( &uptime );
_Timestamp_Subtract( &last, &uptime, &used );
_Timestamp_Add_to( &ran, &used );
} else {
_TOD_Get_uptime( &uptime );
2003e58: 40 00 18 46 call 2009f70 <_TOD_Get_uptime>
2003e5c: 90 07 bf d8 add %fp, -40, %o0
const Timestamp64_Control *_start,
const Timestamp64_Control *_end,
Timestamp64_Control *_result
)
{
*_result = *_end - *_start;
2003e60: 10 bf ff c0 b 2003d60 <rtems_cpu_usage_report_with_plugin+0x100>
2003e64: c4 1f bf d8 ldd [ %fp + -40 ], %g2
0200f928 <rtems_deviceio_errno>:
[RTEMS_IO_ERROR] = EIO,
[RTEMS_PROXY_BLOCKING] = EIO
};
int rtems_deviceio_errno(rtems_status_code sc)
{
200f928: 9d e3 bf a0 save %sp, -96, %sp
if (sc == RTEMS_SUCCESSFUL) {
200f92c: 80 a6 20 00 cmp %i0, 0
200f930: 02 80 00 0d be 200f964 <rtems_deviceio_errno+0x3c>
200f934: 82 10 20 00 clr %g1
return 0;
} else {
int eno = EINVAL;
if ((unsigned) sc <= RTEMS_STATUS_CODES_LAST) {
200f938: 80 a6 20 1c cmp %i0, 0x1c
200f93c: 18 80 00 06 bgu 200f954 <rtems_deviceio_errno+0x2c> <== NEVER TAKEN
200f940: ba 10 20 16 mov 0x16, %i5
eno = status_code_to_errno [sc];
200f944: b1 2e 20 02 sll %i0, 2, %i0
200f948: 03 00 80 6f sethi %hi(0x201bc00), %g1
200f94c: 82 10 63 6c or %g1, 0x36c, %g1 ! 201bf6c <status_code_to_errno>
200f950: fa 00 40 18 ld [ %g1 + %i0 ], %i5
}
errno = eno;
200f954: 40 00 00 2f call 200fa10 <__errno>
200f958: 01 00 00 00 nop
return -1;
200f95c: 82 10 3f ff mov -1, %g1 ! ffffffff <RAM_END+0xfdbfffff>
if ((unsigned) sc <= RTEMS_STATUS_CODES_LAST) {
eno = status_code_to_errno [sc];
}
errno = eno;
200f960: fa 22 00 00 st %i5, [ %o0 ]
return -1;
}
}
200f964: 81 c7 e0 08 ret
200f968: 91 e8 00 01 restore %g0, %g1, %o0
02003b88 <rtems_disk_create_log>:
dev_t phys,
rtems_blkdev_bnum block_begin,
rtems_blkdev_bnum block_count,
const char *name
)
{
2003b88: 9d e3 bf 98 save %sp, -104, %sp
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_disk_device *phys_dd = NULL;
rtems_disk_device *dd = NULL;
2003b8c: c0 27 bf f8 clr [ %fp + -8 ]
char *alloc_name = NULL;
sc = disk_lock();
2003b90: 7f ff ff 11 call 20037d4 <disk_lock>
2003b94: c0 27 bf fc clr [ %fp + -4 ]
if (sc != RTEMS_SUCCESSFUL) {
2003b98: a0 92 20 00 orcc %o0, 0, %l0
2003b9c: 32 80 00 2b bne,a 2003c48 <rtems_disk_create_log+0xc0> <== NEVER TAKEN
2003ba0: b0 10 00 10 mov %l0, %i0 <== NOT EXECUTED
return sc;
}
phys_dd = get_disk_entry(phys, true);
2003ba4: 92 10 00 1b mov %i3, %o1
2003ba8: 90 10 00 1a mov %i2, %o0
2003bac: 7f ff fe cf call 20036e8 <get_disk_entry>
2003bb0: 94 10 20 01 mov 1, %o2
if (phys_dd == NULL) {
2003bb4: b6 92 20 00 orcc %o0, 0, %i3
2003bb8: 12 80 00 06 bne 2003bd0 <rtems_disk_create_log+0x48>
2003bbc: d4 07 a0 5c ld [ %fp + 0x5c ], %o2
disk_unlock();
2003bc0: 7f ff ff 14 call 2003810 <disk_unlock>
2003bc4: a0 10 20 04 mov 4, %l0
}
disk_unlock();
return RTEMS_SUCCESSFUL;
}
2003bc8: 81 c7 e0 08 ret
2003bcc: 91 e8 00 10 restore %g0, %l0, %o0
disk_unlock();
return RTEMS_INVALID_ID;
}
sc = create_disk(dev, name, &dd, &alloc_name);
2003bd0: 90 10 00 18 mov %i0, %o0
2003bd4: 92 10 00 19 mov %i1, %o1
2003bd8: 96 07 bf f8 add %fp, -8, %o3
2003bdc: 7f ff ff 1a call 2003844 <create_disk>
2003be0: 98 07 bf fc add %fp, -4, %o4
if (sc != RTEMS_SUCCESSFUL) {
2003be4: a0 92 20 00 orcc %o0, 0, %l0
2003be8: 12 80 00 16 bne 2003c40 <rtems_disk_create_log+0xb8>
2003bec: d0 07 bf f8 ld [ %fp + -8 ], %o0
disk_unlock();
return sc;
}
sc = rtems_disk_init_log(
2003bf0: 92 10 00 1b mov %i3, %o1
2003bf4: 94 10 00 1c mov %i4, %o2
2003bf8: 40 00 2e ba call 200f6e0 <rtems_disk_init_log>
2003bfc: 96 10 00 1d mov %i5, %o3
phys_dd,
block_begin,
block_count
);
dd->dev = dev;
2003c00: c2 07 bf f8 ld [ %fp + -8 ], %g1
dd->name = alloc_name;
2003c04: c4 07 bf fc ld [ %fp + -4 ], %g2
phys_dd,
block_begin,
block_count
);
dd->dev = dev;
2003c08: f0 38 40 00 std %i0, [ %g1 ]
dd->name = alloc_name;
2003c0c: c4 20 60 10 st %g2, [ %g1 + 0x10 ]
++phys_dd->uses;
2003c10: c4 06 e0 14 ld [ %i3 + 0x14 ], %g2
disk_unlock();
return sc;
}
sc = rtems_disk_init_log(
2003c14: a0 10 00 08 mov %o0, %l0
);
dd->dev = dev;
dd->name = alloc_name;
++phys_dd->uses;
2003c18: 84 00 a0 01 inc %g2
if (sc != RTEMS_SUCCESSFUL) {
2003c1c: 80 a2 20 00 cmp %o0, 0
2003c20: 02 80 00 08 be 2003c40 <rtems_disk_create_log+0xb8>
2003c24: c4 26 e0 14 st %g2, [ %i3 + 0x14 ]
dd->ioctl = null_handler;
2003c28: 05 00 80 0d sethi %hi(0x2003400), %g2
2003c2c: 84 10 a3 78 or %g2, 0x378, %g2 ! 2003778 <null_handler>
rtems_disk_delete(dev);
2003c30: 90 10 00 18 mov %i0, %o0
dd->name = alloc_name;
++phys_dd->uses;
if (sc != RTEMS_SUCCESSFUL) {
dd->ioctl = null_handler;
2003c34: c4 20 60 38 st %g2, [ %g1 + 0x38 ]
rtems_disk_delete(dev);
2003c38: 7f ff ff 6c call 20039e8 <rtems_disk_delete>
2003c3c: 92 10 00 19 mov %i1, %o1
disk_unlock();
return sc;
}
disk_unlock();
2003c40: 7f ff fe f4 call 2003810 <disk_unlock>
2003c44: b0 10 00 10 mov %l0, %i0
return RTEMS_SUCCESSFUL;
}
2003c48: 81 c7 e0 08 ret
2003c4c: 81 e8 00 00 restore
02003c50 <rtems_disk_create_phys>:
rtems_blkdev_bnum block_count,
rtems_block_device_ioctl handler,
void *driver_data,
const char *name
)
{
2003c50: 9d e3 bf 98 save %sp, -104, %sp
rtems_disk_device *dd = NULL;
2003c54: c0 27 bf f8 clr [ %fp + -8 ]
rtems_status_code sc = RTEMS_SUCCESSFUL;
char *alloc_name = NULL;
2003c58: c0 27 bf fc clr [ %fp + -4 ]
if (handler == NULL) {
2003c5c: 80 a7 20 00 cmp %i4, 0
2003c60: 02 80 00 23 be 2003cec <rtems_disk_create_phys+0x9c>
2003c64: a0 10 20 09 mov 9, %l0
return RTEMS_INVALID_ADDRESS;
}
sc = disk_lock();
2003c68: 7f ff fe db call 20037d4 <disk_lock>
2003c6c: 01 00 00 00 nop
if (sc != RTEMS_SUCCESSFUL) {
2003c70: a0 92 20 00 orcc %o0, 0, %l0
2003c74: 12 80 00 1e bne 2003cec <rtems_disk_create_phys+0x9c> <== NEVER TAKEN
2003c78: d4 07 a0 5c ld [ %fp + 0x5c ], %o2
return sc;
}
sc = create_disk(dev, name, &dd, &alloc_name);
2003c7c: 90 10 00 18 mov %i0, %o0
2003c80: 92 10 00 19 mov %i1, %o1
2003c84: 96 07 bf f8 add %fp, -8, %o3
2003c88: 7f ff fe ef call 2003844 <create_disk>
2003c8c: 98 07 bf fc add %fp, -4, %o4
if (sc != RTEMS_SUCCESSFUL) {
2003c90: a0 92 20 00 orcc %o0, 0, %l0
2003c94: 12 80 00 14 bne 2003ce4 <rtems_disk_create_phys+0x94>
2003c98: d0 07 bf f8 ld [ %fp + -8 ], %o0
disk_unlock();
return sc;
}
sc = rtems_disk_init_phys(
2003c9c: 92 10 00 1a mov %i2, %o1
2003ca0: 94 10 00 1b mov %i3, %o2
2003ca4: 96 10 00 1c mov %i4, %o3
2003ca8: 40 00 2e 74 call 200f678 <rtems_disk_init_phys>
2003cac: 98 10 00 1d mov %i5, %o4
block_count,
handler,
driver_data
);
dd->dev = dev;
2003cb0: c2 07 bf f8 ld [ %fp + -8 ], %g1
dd->name = alloc_name;
2003cb4: c4 07 bf fc ld [ %fp + -4 ], %g2
block_count,
handler,
driver_data
);
dd->dev = dev;
2003cb8: f0 38 40 00 std %i0, [ %g1 ]
dd->name = alloc_name;
2003cbc: c4 20 60 10 st %g2, [ %g1 + 0x10 ]
if (sc != RTEMS_SUCCESSFUL) {
2003cc0: 80 a2 20 00 cmp %o0, 0
2003cc4: 02 80 00 08 be 2003ce4 <rtems_disk_create_phys+0x94>
2003cc8: a0 10 00 08 mov %o0, %l0
dd->ioctl = null_handler;
2003ccc: 05 00 80 0d sethi %hi(0x2003400), %g2
2003cd0: 84 10 a3 78 or %g2, 0x378, %g2 ! 2003778 <null_handler>
rtems_disk_delete(dev);
2003cd4: 90 10 00 18 mov %i0, %o0
dd->dev = dev;
dd->name = alloc_name;
if (sc != RTEMS_SUCCESSFUL) {
dd->ioctl = null_handler;
2003cd8: c4 20 60 38 st %g2, [ %g1 + 0x38 ]
rtems_disk_delete(dev);
2003cdc: 7f ff ff 43 call 20039e8 <rtems_disk_delete>
2003ce0: 92 10 00 19 mov %i1, %o1
disk_unlock();
return sc;
}
disk_unlock();
2003ce4: 7f ff fe cb call 2003810 <disk_unlock>
2003ce8: 01 00 00 00 nop
return RTEMS_SUCCESSFUL;
}
2003cec: 81 c7 e0 08 ret
2003cf0: 91 e8 00 10 restore %g0, %l0, %o0
020039e8 <rtems_disk_delete>:
}
}
rtems_status_code
rtems_disk_delete(dev_t dev)
{
20039e8: 9d e3 bf a0 save %sp, -96, %sp
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_disk_device *dd = NULL;
sc = disk_lock();
20039ec: 7f ff ff 7a call 20037d4 <disk_lock>
20039f0: b8 10 00 18 mov %i0, %i4
if (sc != RTEMS_SUCCESSFUL) {
20039f4: b0 92 20 00 orcc %o0, 0, %i0
20039f8: 12 80 00 0a bne 2003a20 <rtems_disk_delete+0x38> <== NEVER TAKEN
20039fc: 90 10 00 1c mov %i4, %o0
return sc;
}
dd = get_disk_entry(dev, true);
2003a00: 92 10 00 19 mov %i1, %o1
2003a04: 7f ff ff 39 call 20036e8 <get_disk_entry>
2003a08: 94 10 20 01 mov 1, %o2
if (dd == NULL) {
2003a0c: 82 92 20 00 orcc %o0, 0, %g1
2003a10: 32 80 00 06 bne,a 2003a28 <rtems_disk_delete+0x40> <== ALWAYS TAKEN
2003a14: fa 00 60 08 ld [ %g1 + 8 ], %i5
disk_unlock();
2003a18: 7f ff ff 7e call 2003810 <disk_unlock> <== NOT EXECUTED
2003a1c: b0 10 20 04 mov 4, %i0 <== NOT EXECUTED
2003a20: 81 c7 e0 08 ret <== NOT EXECUTED
2003a24: 81 e8 00 00 restore <== NOT EXECUTED
return RTEMS_INVALID_ID;
}
dd->deleted = true;
2003a28: 84 10 20 01 mov 1, %g2
2003a2c: c4 28 60 40 stb %g2, [ %g1 + 0x40 ]
{
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) {
2003a30: c4 0f 60 40 ldub [ %i5 + 0x40 ], %g2
2003a34: 80 a0 a0 00 cmp %g2, 0
2003a38: 22 80 00 41 be,a 2003b3c <rtems_disk_delete+0x154>
2003a3c: c4 00 60 14 ld [ %g1 + 0x14 ], %g2
dev_t dev = physical_disk->dev;
2003a40: e2 07 40 00 ld [ %i5 ], %l1
2003a44: e4 07 60 04 ld [ %i5 + 4 ], %l2
unsigned deleted_count = 0;
2003a48: b4 10 20 00 clr %i2
for (major = 0; major < disktab_size; ++major) {
2003a4c: b8 10 20 00 clr %i4
2003a50: 21 00 80 85 sethi %hi(0x2021400), %l0
rtems_disk_device_table *dtab = disktab + major;
2003a54: 27 00 80 85 sethi %hi(0x2021400), %l3
if (dd->uses == 0) {
++deleted_count;
dtab->minor [minor] = NULL;
free_disk_device(dd);
} else {
dd->deleted = true;
2003a58: 10 80 00 26 b 2003af0 <rtems_disk_delete+0x108>
2003a5c: a8 10 20 01 mov 1, %l4
}
}
}
rtems_status_code
rtems_disk_delete(dev_t dev)
2003a60: 83 2f 20 03 sll %i4, 3, %g1
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) {
2003a64: b6 10 20 00 clr %i3
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;
2003a68: 10 80 00 1d b 2003adc <rtems_disk_delete+0xf4>
2003a6c: b2 06 40 01 add %i1, %g1, %i1
}
}
}
rtems_status_code
rtems_disk_delete(dev_t dev)
2003a70: 85 2e e0 02 sll %i3, 2, %g2
for (major = 0; major < disktab_size; ++major) {
rtems_disk_device_table *dtab = disktab + major;
for (minor = 0; minor < dtab->size; ++minor) {
rtems_disk_device *dd = dtab->minor [minor];
2003a74: d0 00 c0 02 ld [ %g3 + %g2 ], %o0
if (dd != NULL && dd->phys_dev->dev == dev && dd != physical_disk) {
2003a78: 80 a2 20 00 cmp %o0, 0
2003a7c: 22 80 00 18 be,a 2003adc <rtems_disk_delete+0xf4>
2003a80: b6 06 e0 01 inc %i3
2003a84: c8 02 20 08 ld [ %o0 + 8 ], %g4
2003a88: de 01 00 00 ld [ %g4 ], %o7
2003a8c: 80 a3 c0 11 cmp %o7, %l1
2003a90: 32 80 00 13 bne,a 2003adc <rtems_disk_delete+0xf4> <== NEVER TAKEN
2003a94: b6 06 e0 01 inc %i3 <== NOT EXECUTED
2003a98: c8 01 20 04 ld [ %g4 + 4 ], %g4
2003a9c: 80 a1 00 12 cmp %g4, %l2
2003aa0: 32 80 00 0f bne,a 2003adc <rtems_disk_delete+0xf4> <== NEVER TAKEN
2003aa4: b6 06 e0 01 inc %i3 <== NOT EXECUTED
2003aa8: 80 a2 00 1d cmp %o0, %i5
2003aac: 22 80 00 0c be,a 2003adc <rtems_disk_delete+0xf4>
2003ab0: b6 06 e0 01 inc %i3
if (dd->uses == 0) {
2003ab4: c8 02 20 14 ld [ %o0 + 0x14 ], %g4
2003ab8: 80 a1 20 00 cmp %g4, 0
2003abc: 32 80 00 07 bne,a 2003ad8 <rtems_disk_delete+0xf0>
2003ac0: e8 2a 20 40 stb %l4, [ %o0 + 0x40 ]
++deleted_count;
2003ac4: b4 06 a0 01 inc %i2
dtab->minor [minor] = NULL;
free_disk_device(dd);
2003ac8: 7f ff ff 2e call 2003780 <free_disk_device>
2003acc: c0 20 c0 02 clr [ %g3 + %g2 ]
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) {
2003ad0: 10 80 00 03 b 2003adc <rtems_disk_delete+0xf4>
2003ad4: b6 06 e0 01 inc %i3
2003ad8: b6 06 e0 01 inc %i3
2003adc: c2 06 60 04 ld [ %i1 + 4 ], %g1
2003ae0: 80 a6 c0 01 cmp %i3, %g1
2003ae4: 2a bf ff e3 bcs,a 2003a70 <rtems_disk_delete+0x88>
2003ae8: c6 06 40 00 ld [ %i1 ], %g3
if (physical_disk->deleted) {
dev_t dev = physical_disk->dev;
unsigned deleted_count = 0;
for (major = 0; major < disktab_size; ++major) {
2003aec: b8 07 20 01 inc %i4
2003af0: c2 04 23 60 ld [ %l0 + 0x360 ], %g1
2003af4: 80 a7 00 01 cmp %i4, %g1
2003af8: 2a bf ff da bcs,a 2003a60 <rtems_disk_delete+0x78>
2003afc: f2 04 e3 64 ld [ %l3 + 0x364 ], %i1
}
}
}
}
physical_disk->uses -= deleted_count;
2003b00: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
2003b04: b4 20 40 1a sub %g1, %i2, %i2
if (physical_disk->uses == 0) {
2003b08: 80 a6 a0 00 cmp %i2, 0
2003b0c: 12 80 00 1b bne 2003b78 <rtems_disk_delete+0x190>
2003b10: f4 27 60 14 st %i2, [ %i5 + 0x14 ]
rtems_filesystem_split_dev_t(physical_disk->dev, major, minor);
2003b14: c4 07 40 00 ld [ %i5 ], %g2
disktab [major].minor [minor] = NULL;
2003b18: 07 00 80 85 sethi %hi(0x2021400), %g3
2003b1c: c6 00 e3 64 ld [ %g3 + 0x364 ], %g3 ! 2021764 <disktab>
}
}
physical_disk->uses -= deleted_count;
if (physical_disk->uses == 0) {
rtems_filesystem_split_dev_t(physical_disk->dev, major, minor);
2003b20: c2 07 60 04 ld [ %i5 + 4 ], %g1
disktab [major].minor [minor] = NULL;
2003b24: 85 28 a0 03 sll %g2, 3, %g2
2003b28: c4 00 c0 02 ld [ %g3 + %g2 ], %g2
2003b2c: 83 28 60 02 sll %g1, 2, %g1
free_disk_device(physical_disk);
2003b30: 90 10 00 1d mov %i5, %o0
}
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;
2003b34: 10 80 00 0f b 2003b70 <rtems_disk_delete+0x188>
2003b38: c0 20 80 01 clr [ %g2 + %g1 ]
free_disk_device(physical_disk);
}
} else {
if (disk_to_remove->uses == 0) {
2003b3c: 80 a0 a0 00 cmp %g2, 0
2003b40: 12 80 00 0e bne 2003b78 <rtems_disk_delete+0x190> <== NEVER TAKEN
2003b44: 07 00 80 85 sethi %hi(0x2021400), %g3
--physical_disk->uses;
2003b48: c4 07 60 14 ld [ %i5 + 0x14 ], %g2
2003b4c: 84 00 bf ff add %g2, -1, %g2
rtems_filesystem_split_dev_t(disk_to_remove->dev, major, minor);
disktab [major].minor [minor] = NULL;
2003b50: c6 00 e3 64 ld [ %g3 + 0x364 ], %g3
disktab [major].minor [minor] = NULL;
free_disk_device(physical_disk);
}
} else {
if (disk_to_remove->uses == 0) {
--physical_disk->uses;
2003b54: c4 27 60 14 st %g2, [ %i5 + 0x14 ]
rtems_filesystem_split_dev_t(disk_to_remove->dev, major, minor);
2003b58: c4 00 40 00 ld [ %g1 ], %g2
2003b5c: c2 00 60 04 ld [ %g1 + 4 ], %g1
disktab [major].minor [minor] = NULL;
2003b60: 85 28 a0 03 sll %g2, 3, %g2
2003b64: c4 00 c0 02 ld [ %g3 + %g2 ], %g2
2003b68: 83 28 60 02 sll %g1, 2, %g1
2003b6c: c0 20 80 01 clr [ %g2 + %g1 ]
free_disk_device(disk_to_remove);
2003b70: 7f ff ff 04 call 2003780 <free_disk_device>
2003b74: 01 00 00 00 nop
}
dd->deleted = true;
rtems_disk_cleanup(dd);
disk_unlock();
2003b78: 7f ff ff 26 call 2003810 <disk_unlock>
2003b7c: 01 00 00 00 nop
return RTEMS_SUCCESSFUL;
}
2003b80: 81 c7 e0 08 ret
2003b84: 81 e8 00 00 restore
02003ea8 <rtems_disk_io_initialize>:
rtems_status_code
rtems_disk_io_initialize(void)
{
2003ea8: 9d e3 bf a0 save %sp, -96, %sp
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_device_major_number size = DISKTAB_INITIAL_SIZE;
if (disktab_size > 0) {
2003eac: 39 00 80 85 sethi %hi(0x2021400), %i4
2003eb0: c2 07 23 60 ld [ %i4 + 0x360 ], %g1 ! 2021760 <disktab_size>
2003eb4: 80 a0 60 00 cmp %g1, 0
2003eb8: 12 80 00 19 bne 2003f1c <rtems_disk_io_initialize+0x74>
2003ebc: b0 10 20 00 clr %i0
return RTEMS_SUCCESSFUL;
}
disktab = calloc(size, sizeof(rtems_disk_device_table));
2003ec0: 90 10 20 08 mov 8, %o0
2003ec4: 92 10 20 08 mov 8, %o1
2003ec8: 40 00 02 0b call 20046f4 <calloc>
2003ecc: 3b 00 80 85 sethi %hi(0x2021400), %i5
2003ed0: d0 27 63 64 st %o0, [ %i5 + 0x364 ] ! 2021764 <disktab>
if (disktab == NULL) {
2003ed4: 80 a2 20 00 cmp %o0, 0
2003ed8: 02 80 00 11 be 2003f1c <rtems_disk_io_initialize+0x74> <== NEVER TAKEN
2003edc: b0 10 20 1a mov 0x1a, %i0
return RTEMS_NO_MEMORY;
}
diskdevs_protected = false;
2003ee0: 03 00 80 85 sethi %hi(0x2021400), %g1
sc = rtems_semaphore_create(
2003ee4: 11 11 11 11 sethi %hi(0x44444400), %o0
disktab = calloc(size, sizeof(rtems_disk_device_table));
if (disktab == NULL) {
return RTEMS_NO_MEMORY;
}
diskdevs_protected = false;
2003ee8: c0 28 63 58 clrb [ %g1 + 0x358 ]
sc = rtems_semaphore_create(
2003eec: 90 12 21 56 or %o0, 0x156, %o0
2003ef0: 92 10 20 01 mov 1, %o1
2003ef4: 94 10 20 10 mov 0x10, %o2
2003ef8: 96 10 20 00 clr %o3
2003efc: 37 00 80 85 sethi %hi(0x2021400), %i3
2003f00: 40 00 12 db call 2008a6c <rtems_semaphore_create>
2003f04: 98 16 e3 5c or %i3, 0x35c, %o4 ! 202175c <diskdevs_mutex>
RTEMS_FIFO | RTEMS_BINARY_SEMAPHORE | RTEMS_NO_INHERIT_PRIORITY
| RTEMS_NO_PRIORITY_CEILING | RTEMS_LOCAL,
0,
&diskdevs_mutex
);
if (sc != RTEMS_SUCCESSFUL) {
2003f08: 80 a2 20 00 cmp %o0, 0
2003f0c: 02 80 00 06 be 2003f24 <rtems_disk_io_initialize+0x7c> <== ALWAYS TAKEN
2003f10: 01 00 00 00 nop
free(disktab);
2003f14: 40 00 02 cd call 2004a48 <free> <== NOT EXECUTED
2003f18: d0 07 63 64 ld [ %i5 + 0x364 ], %o0 <== NOT EXECUTED
return RTEMS_NO_MEMORY;
2003f1c: 81 c7 e0 08 ret
2003f20: 81 e8 00 00 restore
}
sc = rtems_bdbuf_init();
2003f24: 40 00 29 5f call 200e4a0 <rtems_bdbuf_init>
2003f28: 01 00 00 00 nop
if (sc != RTEMS_SUCCESSFUL) {
2003f2c: 80 a2 20 00 cmp %o0, 0
2003f30: 02 80 00 09 be 2003f54 <rtems_disk_io_initialize+0xac> <== ALWAYS TAKEN
2003f34: 82 10 20 08 mov 8, %g1
rtems_semaphore_delete(diskdevs_mutex);
2003f38: d0 06 e3 5c ld [ %i3 + 0x35c ], %o0 <== NOT EXECUTED
2003f3c: 40 00 13 3b call 2008c28 <rtems_semaphore_delete> <== NOT EXECUTED
2003f40: b0 10 20 0d mov 0xd, %i0 <== NOT EXECUTED
free(disktab);
2003f44: 40 00 02 c1 call 2004a48 <free> <== NOT EXECUTED
2003f48: d0 07 63 64 ld [ %i5 + 0x364 ], %o0 <== NOT EXECUTED
return RTEMS_UNSATISFIED;
2003f4c: 81 c7 e0 08 ret <== NOT EXECUTED
2003f50: 81 e8 00 00 restore <== NOT EXECUTED
}
disktab_size = size;
return RTEMS_SUCCESSFUL;
2003f54: b0 10 20 00 clr %i0
free(disktab);
return RTEMS_UNSATISFIED;
}
disktab_size = size;
2003f58: c2 27 23 60 st %g1, [ %i4 + 0x360 ]
return RTEMS_SUCCESSFUL;
}
2003f5c: 81 c7 e0 08 ret
2003f60: 81 e8 00 00 restore
02003db8 <rtems_disk_next>:
rtems_disk_device *
rtems_disk_next(dev_t dev)
{
2003db8: 9d e3 bf a0 save %sp, -96, %sp
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) {
2003dbc: 80 a6 3f ff cmp %i0, -1
2003dc0: 12 80 00 05 bne 2003dd4 <rtems_disk_next+0x1c>
2003dc4: b8 06 60 01 add %i1, 1, %i4
2003dc8: 80 a6 7f ff cmp %i1, -1
2003dcc: 22 80 00 0b be,a 2003df8 <rtems_disk_next+0x40> <== ALWAYS TAKEN
2003dd0: b8 10 20 00 clr %i4
rtems_filesystem_split_dev_t(dev, major, minor);
/* If minor wraps around */
if ((minor + 1) < minor) {
2003dd4: 80 a7 00 19 cmp %i4, %i1
2003dd8: 1a 80 00 09 bcc 2003dfc <rtems_disk_next+0x44> <== ALWAYS TAKEN
2003ddc: ba 10 00 18 mov %i0, %i5
/* If major wraps around */
if ((major + 1) < major) {
2003de0: ba 06 20 01 add %i0, 1, %i5 <== NOT EXECUTED
2003de4: 80 a7 40 18 cmp %i5, %i0 <== NOT EXECUTED
2003de8: 1a 80 00 05 bcc 2003dfc <rtems_disk_next+0x44> <== NOT EXECUTED
2003dec: b8 10 20 00 clr %i4 <== NOT EXECUTED
}
if (major >= disktab_size) {
disk_unlock();
return NULL;
2003df0: 81 c7 e0 08 ret <== NOT EXECUTED
2003df4: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED
2003df8: ba 10 20 00 clr %i5
} else {
++minor;
}
}
sc = disk_lock();
2003dfc: 7f ff fe 76 call 20037d4 <disk_lock>
2003e00: 01 00 00 00 nop
if (sc != RTEMS_SUCCESSFUL) {
2003e04: 80 a2 20 00 cmp %o0, 0
2003e08: 12 80 00 08 bne 2003e28 <rtems_disk_next+0x70> <== NEVER TAKEN
2003e0c: 03 00 80 85 sethi %hi(0x2021400), %g1
return NULL;
}
if (major >= disktab_size) {
2003e10: c4 00 63 60 ld [ %g1 + 0x360 ], %g2 ! 2021760 <disktab_size>
2003e14: 80 a7 40 02 cmp %i5, %g2
2003e18: 0a 80 00 06 bcs 2003e30 <rtems_disk_next+0x78> <== ALWAYS TAKEN
2003e1c: 03 00 80 85 sethi %hi(0x2021400), %g1
disk_unlock();
2003e20: 7f ff fe 7c call 2003810 <disk_unlock>
2003e24: 01 00 00 00 nop
return NULL;
2003e28: 81 c7 e0 08 ret
2003e2c: 91 e8 20 00 restore %g0, 0, %o0
}
dtab = disktab + major;
2003e30: c6 00 63 64 ld [ %g1 + 0x364 ], %g3
2003e34: b7 2f 60 03 sll %i5, 3, %i3
2003e38: b6 00 c0 1b add %g3, %i3, %i3
while (true) {
if (dtab->minor == NULL || minor >= dtab->size) {
2003e3c: c2 06 c0 00 ld [ %i3 ], %g1
2003e40: 80 a0 60 00 cmp %g1, 0
2003e44: 22 80 00 07 be,a 2003e60 <rtems_disk_next+0xa8>
2003e48: ba 07 60 01 inc %i5
2003e4c: c8 06 e0 04 ld [ %i3 + 4 ], %g4
2003e50: 80 a7 00 04 cmp %i4, %g4
2003e54: 0a 80 00 09 bcs 2003e78 <rtems_disk_next+0xc0>
2003e58: b5 2f 20 02 sll %i4, 2, %i2
minor = 0;
++major;
2003e5c: ba 07 60 01 inc %i5
if (major >= disktab_size) {
2003e60: 80 a7 40 02 cmp %i5, %g2
2003e64: 1a bf ff ef bcc 2003e20 <rtems_disk_next+0x68>
2003e68: b7 2f 60 03 sll %i5, 3, %i3
}
dtab = disktab + major;
while (true) {
if (dtab->minor == NULL || minor >= dtab->size) {
minor = 0;
2003e6c: b8 10 20 00 clr %i4
if (major >= disktab_size) {
disk_unlock();
return NULL;
}
dtab = disktab + major;
2003e70: 10 bf ff f3 b 2003e3c <rtems_disk_next+0x84>
2003e74: b6 00 c0 1b add %g3, %i3, %i3
} else if (dtab->minor [minor] == NULL) {
2003e78: c2 00 40 1a ld [ %g1 + %i2 ], %g1
2003e7c: 80 a0 60 00 cmp %g1, 0
2003e80: 02 bf ff ef be 2003e3c <rtems_disk_next+0x84>
2003e84: b8 07 20 01 inc %i4
++minor;
} else {
++dtab->minor [minor]->uses;
2003e88: c4 00 60 14 ld [ %g1 + 0x14 ], %g2
2003e8c: 84 00 a0 01 inc %g2
disk_unlock();
2003e90: 7f ff fe 60 call 2003810 <disk_unlock>
2003e94: c4 20 60 14 st %g2, [ %g1 + 0x14 ]
return dtab->minor [minor];
2003e98: c2 06 c0 00 ld [ %i3 ], %g1
2003e9c: f0 00 40 1a ld [ %g1 + %i2 ], %i0
}
}
}
2003ea0: 81 c7 e0 08 ret
2003ea4: 81 e8 00 00 restore
02003cf4 <rtems_disk_obtain>:
return RTEMS_SUCCESSFUL;
}
rtems_disk_device *
rtems_disk_obtain(dev_t dev)
{
2003cf4: 9d e3 bf a0 save %sp, -96, %sp
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_disk_device *dd = NULL;
rtems_interrupt_level level;
rtems_interrupt_disable(level);
2003cf8: 7f ff fc 85 call 2002f0c <sparc_disable_interrupts>
2003cfc: b8 10 00 18 mov %i0, %i4
2003d00: b6 10 00 08 mov %o0, %i3
if (!diskdevs_protected) {
2003d04: 03 00 80 85 sethi %hi(0x2021400), %g1
2003d08: c2 08 63 58 ldub [ %g1 + 0x358 ], %g1 ! 2021758 <diskdevs_protected>
2003d0c: 80 a0 60 00 cmp %g1, 0
2003d10: 12 80 00 0a bne 2003d38 <rtems_disk_obtain+0x44> <== NEVER TAKEN
2003d14: 92 10 00 19 mov %i1, %o1
/* Frequent and quickest case */
dd = get_disk_entry(dev, false);
2003d18: 90 10 00 18 mov %i0, %o0
2003d1c: 7f ff fe 73 call 20036e8 <get_disk_entry>
2003d20: 94 10 20 00 clr %o2
2003d24: b0 10 00 08 mov %o0, %i0
rtems_interrupt_enable(level);
2003d28: 7f ff fc 7d call 2002f1c <sparc_enable_interrupts>
2003d2c: 90 10 00 1b mov %i3, %o0
2003d30: 81 c7 e0 08 ret
2003d34: 81 e8 00 00 restore
} else {
rtems_interrupt_enable(level);
2003d38: 7f ff fc 79 call 2002f1c <sparc_enable_interrupts> <== NOT EXECUTED
2003d3c: b0 10 20 00 clr %i0 <== NOT EXECUTED
sc = disk_lock();
2003d40: 7f ff fe a5 call 20037d4 <disk_lock> <== NOT EXECUTED
2003d44: 01 00 00 00 nop <== NOT EXECUTED
if (sc == RTEMS_SUCCESSFUL) {
2003d48: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2003d4c: 12 bf ff f9 bne 2003d30 <rtems_disk_obtain+0x3c> <== NOT EXECUTED
2003d50: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
dd = get_disk_entry(dev, false);
2003d54: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
2003d58: 7f ff fe 64 call 20036e8 <get_disk_entry> <== NOT EXECUTED
2003d5c: 94 10 20 00 clr %o2 <== NOT EXECUTED
disk_unlock();
2003d60: 7f ff fe ac call 2003810 <disk_unlock> <== NOT EXECUTED
2003d64: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED
}
}
return dd;
}
2003d68: 81 c7 e0 08 ret <== NOT EXECUTED
2003d6c: 81 e8 00 00 restore <== NOT EXECUTED
02007670 <rtems_fdisk_abort.constprop.0>:
*
* @param format The format string. See printf for details.
* @param ... The arguments for the format text.
*/
static void
rtems_fdisk_abort (const char *format, ...)
2007670: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED
{
va_list args;
va_start (args, format);
2007674: 82 07 a0 48 add %fp, 0x48, %g1 <== NOT EXECUTED
2007678: fa 27 a0 58 st %i5, [ %fp + 0x58 ] <== NOT EXECUTED
200767c: c2 27 bf fc st %g1, [ %fp + -4 ] <== NOT EXECUTED
fprintf (stderr, "fdisk:abort:");
2007680: 3b 00 80 d8 sethi %hi(0x2036000), %i5 <== NOT EXECUTED
2007684: c2 07 61 40 ld [ %i5 + 0x140 ], %g1 ! 2036140 <_impure_ptr><== NOT EXECUTED
*/
static void
rtems_fdisk_abort (const char *format, ...)
{
va_list args;
va_start (args, format);
2007688: f2 27 a0 48 st %i1, [ %fp + 0x48 ] <== NOT EXECUTED
200768c: f4 27 a0 4c st %i2, [ %fp + 0x4c ] <== NOT EXECUTED
2007690: f6 27 a0 50 st %i3, [ %fp + 0x50 ] <== NOT EXECUTED
2007694: f8 27 a0 54 st %i4, [ %fp + 0x54 ] <== NOT EXECUTED
fprintf (stderr, "fdisk:abort:");
2007698: d2 00 60 0c ld [ %g1 + 0xc ], %o1 <== NOT EXECUTED
200769c: 11 00 80 c3 sethi %hi(0x2030c00), %o0 <== NOT EXECUTED
20076a0: 40 00 67 8a call 20214c8 <fputs> <== NOT EXECUTED
20076a4: 90 12 21 a8 or %o0, 0x1a8, %o0 ! 2030da8 <__FUNCTION__.7063+0x588><== NOT EXECUTED
vfprintf (stderr, format, args);
20076a8: c2 07 61 40 ld [ %i5 + 0x140 ], %g1 <== NOT EXECUTED
20076ac: 11 00 80 c3 sethi %hi(0x2030c00), %o0 <== NOT EXECUTED
20076b0: d2 00 60 0c ld [ %g1 + 0xc ], %o1 <== NOT EXECUTED
20076b4: 40 00 67 85 call 20214c8 <fputs> <== NOT EXECUTED
20076b8: 90 12 21 b8 or %o0, 0x1b8, %o0 <== NOT EXECUTED
fprintf (stderr, "\n");
20076bc: c2 07 61 40 ld [ %i5 + 0x140 ], %g1 <== NOT EXECUTED
20076c0: 90 10 20 0a mov 0xa, %o0 <== NOT EXECUTED
20076c4: 40 00 67 4d call 20213f8 <fputc> <== NOT EXECUTED
20076c8: d2 00 60 0c ld [ %g1 + 0xc ], %o1 <== NOT EXECUTED
fflush (stderr);
20076cc: c2 07 61 40 ld [ %i5 + 0x140 ], %g1 <== NOT EXECUTED
20076d0: 40 00 66 3c call 2020fc0 <fflush> <== NOT EXECUTED
20076d4: d0 00 60 0c ld [ %g1 + 0xc ], %o0 <== NOT EXECUTED
va_end (args);
exit (1);
20076d8: 40 00 65 3a call 2020bc0 <exit> <== NOT EXECUTED
20076dc: 90 10 20 01 mov 1, %o0 <== NOT EXECUTED
02005d90 <rtems_fdisk_compact>:
* used segments that will fit. The used queue is sorted on the least
* number of active pages.
*/
static int
rtems_fdisk_compact (rtems_flashdisk* fd)
{
2005d90: 9d e3 bf 98 save %sp, -104, %sp
static bool
rtems_fdisk_is_erased_blocks_starvation (rtems_flashdisk* fd)
{
bool starvation = fd->erased_blocks < fd->starvation_threshold;
if (starvation)
2005d94: c4 06 20 28 ld [ %i0 + 0x28 ], %g2
2005d98: c2 06 20 24 ld [ %i0 + 0x24 ], %g1
2005d9c: 80 a0 80 01 cmp %g2, %g1
2005da0: 1a 80 00 72 bcc 2005f68 <rtems_fdisk_compact+0x1d8>
2005da4: ba 10 00 18 mov %i0, %i5
fd->starvations++;
2005da8: c2 06 20 70 ld [ %i0 + 0x70 ], %g1
uint32_t pages;
if (rtems_fdisk_is_erased_blocks_starvation (fd))
{
#if RTEMS_FDISK_TRACE
rtems_fdisk_printf (fd, " resolve starvation");
2005dac: 90 10 00 18 mov %i0, %o0
rtems_fdisk_is_erased_blocks_starvation (rtems_flashdisk* fd)
{
bool starvation = fd->erased_blocks < fd->starvation_threshold;
if (starvation)
fd->starvations++;
2005db0: 82 00 60 01 inc %g1
uint32_t pages;
if (rtems_fdisk_is_erased_blocks_starvation (fd))
{
#if RTEMS_FDISK_TRACE
rtems_fdisk_printf (fd, " resolve starvation");
2005db4: 13 00 80 c4 sethi %hi(0x2031000), %o1
rtems_fdisk_is_erased_blocks_starvation (rtems_flashdisk* fd)
{
bool starvation = fd->erased_blocks < fd->starvation_threshold;
if (starvation)
fd->starvations++;
2005db8: c2 26 20 70 st %g1, [ %i0 + 0x70 ]
uint32_t pages;
if (rtems_fdisk_is_erased_blocks_starvation (fd))
{
#if RTEMS_FDISK_TRACE
rtems_fdisk_printf (fd, " resolve starvation");
2005dbc: 7f ff fc ac call 200506c <rtems_fdisk_printf>
2005dc0: 92 12 61 80 or %o1, 0x180, %o1
#endif
ssc = rtems_fdisk_segment_queue_pop_head (&fd->used);
2005dc4: 7f ff fb d6 call 2004d1c <rtems_fdisk_segment_queue_pop_head>
2005dc8: 90 06 20 40 add %i0, 0x40, %o0
if (!ssc)
2005dcc: b8 92 20 00 orcc %o0, 0, %i4
2005dd0: 12 80 00 07 bne 2005dec <rtems_fdisk_compact+0x5c> <== ALWAYS TAKEN
2005dd4: 01 00 00 00 nop
ssc = rtems_fdisk_segment_queue_pop_head (&fd->available);
2005dd8: 7f ff fb d1 call 2004d1c <rtems_fdisk_segment_queue_pop_head><== NOT EXECUTED
2005ddc: 90 06 20 34 add %i0, 0x34, %o0 <== NOT EXECUTED
if (ssc)
2005de0: b8 92 20 00 orcc %o0, 0, %i4 <== NOT EXECUTED
2005de4: 02 80 00 12 be 2005e2c <rtems_fdisk_compact+0x9c> <== NOT EXECUTED
2005de8: 11 00 80 c4 sethi %hi(0x2031000), %o0 <== NOT EXECUTED
{
dsc = rtems_fdisk_seg_most_available (&fd->available);
2005dec: 7f ff fc 6e call 2004fa4 <rtems_fdisk_seg_most_available>
2005df0: 90 07 60 34 add %i5, 0x34, %o0
if (dsc)
2005df4: 94 92 20 00 orcc %o0, 0, %o2
2005df8: 02 80 00 0a be 2005e20 <rtems_fdisk_compact+0x90> <== NEVER TAKEN
2005dfc: 92 10 00 1c mov %i4, %o1
{
ret = rtems_fdisk_recycle_segment (fd, ssc, dsc, &pages);
2005e00: 90 10 00 1d mov %i5, %o0
2005e04: 7f ff ff 02 call 2005a0c <rtems_fdisk_recycle_segment>
2005e08: 96 07 bf fc add %fp, -4, %o3
if (ret)
2005e0c: 80 a2 20 00 cmp %o0, 0
2005e10: 02 80 00 57 be 2005f6c <rtems_fdisk_compact+0x1dc> <== ALWAYS TAKEN
2005e14: 21 00 80 c4 sethi %hi(0x2031000), %l0
compacted_segs += segments;
}
return 0;
}
2005e18: 81 c7 e0 08 ret <== NOT EXECUTED
2005e1c: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED
if (ret)
return ret;
}
else
{
rtems_fdisk_error ("compacting: starvation");
2005e20: 11 00 80 c4 sethi %hi(0x2031000), %o0 <== NOT EXECUTED
2005e24: 10 80 00 03 b 2005e30 <rtems_fdisk_compact+0xa0> <== NOT EXECUTED
2005e28: 90 12 21 98 or %o0, 0x198, %o0 ! 2031198 <__FUNCTION__.7063+0x978><== NOT EXECUTED
return EIO;
}
}
else
{
rtems_fdisk_error ("compacting: nothing to recycle");
2005e2c: 90 12 21 b0 or %o0, 0x1b0, %o0 <== NOT EXECUTED
2005e30: 7f ff fc cf call 200516c <rtems_fdisk_error> <== NOT EXECUTED
2005e34: 01 00 00 00 nop <== NOT EXECUTED
return EIO;
2005e38: 10 80 00 61 b 2005fbc <rtems_fdisk_compact+0x22c> <== NOT EXECUTED
2005e3c: 90 10 20 05 mov 5, %o0 ! 5 <PROM_START+0x5> <== NOT EXECUTED
{
uint32_t dst_pages;
uint32_t segments;
#if RTEMS_FDISK_TRACE
rtems_fdisk_printf (fd, " compacting");
2005e40: 7f ff fc 8b call 200506c <rtems_fdisk_printf>
2005e44: 90 10 00 1d mov %i5, %o0
#endif
dsc = rtems_fdisk_seg_most_available (&fd->available);
2005e48: 7f ff fc 57 call 2004fa4 <rtems_fdisk_seg_most_available>
2005e4c: 90 10 00 19 mov %i1, %o0
if (dsc == 0)
2005e50: b6 92 20 00 orcc %o0, 0, %i3
2005e54: 12 80 00 05 bne 2005e68 <rtems_fdisk_compact+0xd8> <== ALWAYS TAKEN
2005e58: 01 00 00 00 nop
{
rtems_fdisk_error ("compacting: no available segments to compact too");
2005e5c: 11 00 80 c4 sethi %hi(0x2031000), %o0 <== NOT EXECUTED
2005e60: 10 bf ff f4 b 2005e30 <rtems_fdisk_compact+0xa0> <== NOT EXECUTED
2005e64: 90 12 21 e0 or %o0, 0x1e0, %o0 ! 20311e0 <__FUNCTION__.7063+0x9c0><== NOT EXECUTED
return EIO;
}
ssc = fd->used.head;
dst_pages = rtems_fdisk_seg_pages_available (dsc);
2005e68: 7f ff fc 47 call 2004f84 <rtems_fdisk_seg_pages_available>
2005e6c: 01 00 00 00 nop
segments = 0;
pages = 0;
#if RTEMS_FDISK_TRACE
rtems_fdisk_printf (fd, " dsc:%02d-%03d: most available",
2005e70: d4 06 e0 08 ld [ %i3 + 8 ], %o2
2005e74: d6 06 e0 0c ld [ %i3 + 0xc ], %o3
{
rtems_fdisk_error ("compacting: no available segments to compact too");
return EIO;
}
ssc = fd->used.head;
2005e78: f8 07 60 40 ld [ %i5 + 0x40 ], %i4
dst_pages = rtems_fdisk_seg_pages_available (dsc);
2005e7c: b0 10 00 08 mov %o0, %i0
segments = 0;
pages = 0;
2005e80: c0 27 bf fc clr [ %fp + -4 ]
#if RTEMS_FDISK_TRACE
rtems_fdisk_printf (fd, " dsc:%02d-%03d: most available",
2005e84: 90 10 00 1d mov %i5, %o0
2005e88: 7f ff fc 79 call 200506c <rtems_fdisk_printf>
2005e8c: 92 10 00 11 mov %l1, %o1
2005e90: d8 07 bf fc ld [ %fp + -4 ], %o4
* we handle during one compaction. A lower number means less aggressive
* compaction or less delay when compacting but it may mean the disk
* will fill.
*/
while (ssc &&
2005e94: 10 80 00 04 b 2005ea4 <rtems_fdisk_compact+0x114>
2005e98: 9a 10 20 00 clr %o5
((pages + ssc->pages_active) < dst_pages) &&
((compacted_segs + segments) < fd->compact_segs))
{
pages += ssc->pages_active;
segments++;
2005e9c: 9a 03 60 01 inc %o5
while (ssc &&
((pages + ssc->pages_active) < dst_pages) &&
((compacted_segs + segments) < fd->compact_segs))
{
pages += ssc->pages_active;
2005ea0: 98 10 00 01 mov %g1, %o4
* we handle during one compaction. A lower number means less aggressive
* compaction or less delay when compacting but it may mean the disk
* will fill.
*/
while (ssc &&
2005ea4: 80 a7 20 00 cmp %i4, 0
2005ea8: 32 80 00 09 bne,a 2005ecc <rtems_fdisk_compact+0x13c>
2005eac: c2 07 20 1c ld [ %i4 + 0x1c ], %g1
2005eb0: d8 27 bf fc st %o4, [ %fp + -4 ]
*/
if (!ssc || (pages == 0) || ((compacted_segs + segments) == 1))
{
#if RTEMS_FDISK_TRACE
rtems_fdisk_printf (fd, " nothing to compact");
2005eb4: 90 10 00 1d mov %i5, %o0
2005eb8: 13 00 80 c4 sethi %hi(0x2031000), %o1
2005ebc: 7f ff fc 6c call 200506c <rtems_fdisk_printf>
2005ec0: 92 12 62 38 or %o1, 0x238, %o1 ! 2031238 <__FUNCTION__.7063+0xa18>
}
compacted_segs += segments;
}
return 0;
2005ec4: 10 80 00 3e b 2005fbc <rtems_fdisk_compact+0x22c>
2005ec8: 90 10 20 00 clr %o0
* compaction or less delay when compacting but it may mean the disk
* will fill.
*/
while (ssc &&
((pages + ssc->pages_active) < dst_pages) &&
2005ecc: 82 03 00 01 add %o4, %g1, %g1
* we handle during one compaction. A lower number means less aggressive
* compaction or less delay when compacting but it may mean the disk
* will fill.
*/
while (ssc &&
2005ed0: 80 a0 40 18 cmp %g1, %i0
2005ed4: 1a 80 00 34 bcc 2005fa4 <rtems_fdisk_compact+0x214>
2005ed8: 86 03 40 1a add %o5, %i2, %g3
((pages + ssc->pages_active) < dst_pages) &&
2005edc: c4 07 60 0c ld [ %i5 + 0xc ], %g2
2005ee0: 80 a0 c0 02 cmp %g3, %g2
2005ee4: 2a bf ff ee bcs,a 2005e9c <rtems_fdisk_compact+0x10c> <== ALWAYS TAKEN
2005ee8: f8 07 00 00 ld [ %i4 ], %i4
2005eec: 10 80 00 2f b 2005fa8 <rtems_fdisk_compact+0x218> <== NOT EXECUTED
2005ef0: d8 27 bf fc st %o4, [ %fp + -4 ] <== NOT EXECUTED
* We need a source segment and have pages to copy and
* compacting one segment to another is silly. Compaction needs
* to free at least one more segment.
*/
if (!ssc || (pages == 0) || ((compacted_segs + segments) == 1))
2005ef4: 80 a6 a0 01 cmp %i2, 1
2005ef8: 22 bf ff f0 be,a 2005eb8 <rtems_fdisk_compact+0x128>
2005efc: 90 10 00 1d mov %i5, %o0
#endif
break;
}
#if RTEMS_FDISK_TRACE
rtems_fdisk_printf (fd, " ssc scan: %d-%d: p=%ld, seg=%ld",
2005f00: d4 07 20 08 ld [ %i4 + 8 ], %o2
2005f04: d6 07 20 0c ld [ %i4 + 0xc ], %o3
2005f08: 92 10 00 12 mov %l2, %o1
2005f0c: 7f ff fc 58 call 200506c <rtems_fdisk_printf>
2005f10: 90 10 00 1d mov %i5, %o0
ssc->device, ssc->segment,
pages, segments);
#endif
rtems_fdisk_segment_queue_remove (&fd->available, dsc);
2005f14: 90 10 00 19 mov %i1, %o0
2005f18: 7f ff fb a3 call 2004da4 <rtems_fdisk_segment_queue_remove>
2005f1c: 92 10 00 1b mov %i3, %o1
/*
* We now copy the pages to the new segment.
*/
while (pages)
2005f20: 10 80 00 0e b 2005f58 <rtems_fdisk_compact+0x1c8>
2005f24: c2 07 bf fc ld [ %fp + -4 ], %g1
{
ssc = rtems_fdisk_segment_queue_pop_head (&fd->used);
2005f28: 7f ff fb 7d call 2004d1c <rtems_fdisk_segment_queue_pop_head>
2005f2c: 90 10 00 13 mov %l3, %o0
if (ssc)
2005f30: 92 92 20 00 orcc %o0, 0, %o1
2005f34: 02 80 00 09 be 2005f58 <rtems_fdisk_compact+0x1c8> <== NEVER TAKEN
2005f38: c2 07 bf fc ld [ %fp + -4 ], %g1
{
ret = rtems_fdisk_recycle_segment (fd, ssc, dsc, &pages);
2005f3c: 90 10 00 1d mov %i5, %o0
2005f40: 94 10 00 1b mov %i3, %o2
2005f44: 7f ff fe b2 call 2005a0c <rtems_fdisk_recycle_segment>
2005f48: 96 07 bf fc add %fp, -4, %o3
if (ret)
2005f4c: 80 a2 20 00 cmp %o0, 0
2005f50: 12 80 00 1b bne 2005fbc <rtems_fdisk_compact+0x22c> <== NEVER TAKEN
2005f54: c2 07 bf fc ld [ %fp + -4 ], %g1
/*
* We now copy the pages to the new segment.
*/
while (pages)
2005f58: 80 a0 60 00 cmp %g1, 0
2005f5c: 22 80 00 0d be,a 2005f90 <rtems_fdisk_compact+0x200>
2005f60: c2 07 60 40 ld [ %i5 + 0x40 ], %g1
2005f64: 30 bf ff f1 b,a 2005f28 <rtems_fdisk_compact+0x198>
{
uint32_t dst_pages;
uint32_t segments;
#if RTEMS_FDISK_TRACE
rtems_fdisk_printf (fd, " compacting");
2005f68: 21 00 80 c4 sethi %hi(0x2031000), %l0
dst_pages = rtems_fdisk_seg_pages_available (dsc);
segments = 0;
pages = 0;
#if RTEMS_FDISK_TRACE
rtems_fdisk_printf (fd, " dsc:%02d-%03d: most available",
2005f6c: 23 00 80 c4 sethi %hi(0x2031000), %l1
#endif
break;
}
#if RTEMS_FDISK_TRACE
rtems_fdisk_printf (fd, " ssc scan: %d-%d: p=%ld, seg=%ld",
2005f70: 25 00 80 c4 sethi %hi(0x2031000), %l2
* compaction or less delay when compacting but it may mean the disk
* will fill.
*/
while (ssc &&
((pages + ssc->pages_active) < dst_pages) &&
2005f74: b4 10 20 00 clr %i2
{
uint32_t dst_pages;
uint32_t segments;
#if RTEMS_FDISK_TRACE
rtems_fdisk_printf (fd, " compacting");
2005f78: a0 14 21 d0 or %l0, 0x1d0, %l0
#endif
dsc = rtems_fdisk_seg_most_available (&fd->available);
2005f7c: b2 07 60 34 add %i5, 0x34, %i1
dst_pages = rtems_fdisk_seg_pages_available (dsc);
segments = 0;
pages = 0;
#if RTEMS_FDISK_TRACE
rtems_fdisk_printf (fd, " dsc:%02d-%03d: most available",
2005f80: a2 14 62 18 or %l1, 0x218, %l1
#endif
break;
}
#if RTEMS_FDISK_TRACE
rtems_fdisk_printf (fd, " ssc scan: %d-%d: p=%ld, seg=%ld",
2005f84: a4 14 a2 50 or %l2, 0x250, %l2
* We now copy the pages to the new segment.
*/
while (pages)
{
ssc = rtems_fdisk_segment_queue_pop_head (&fd->used);
2005f88: a6 07 60 40 add %i5, 0x40, %l3
rtems_fdisk_error ("compacting: nothing to recycle");
return EIO;
}
}
while (fd->used.head)
2005f8c: c2 07 60 40 ld [ %i5 + 0x40 ], %g1
2005f90: 80 a0 60 00 cmp %g1, 0
2005f94: 12 bf ff ab bne 2005e40 <rtems_fdisk_compact+0xb0>
2005f98: 92 10 00 10 mov %l0, %o1
}
compacted_segs += segments;
}
return 0;
2005f9c: 10 80 00 08 b 2005fbc <rtems_fdisk_compact+0x22c>
2005fa0: 90 10 20 00 clr %o0
2005fa4: d8 27 bf fc st %o4, [ %fp + -4 ]
* We need a source segment and have pages to copy and
* compacting one segment to another is silly. Compaction needs
* to free at least one more segment.
*/
if (!ssc || (pages == 0) || ((compacted_segs + segments) == 1))
2005fa8: 80 a3 20 00 cmp %o4, 0
2005fac: 32 bf ff d2 bne,a 2005ef4 <rtems_fdisk_compact+0x164>
2005fb0: b4 06 80 0d add %i2, %o5, %i2
{
#if RTEMS_FDISK_TRACE
rtems_fdisk_printf (fd, " nothing to compact");
2005fb4: 10 bf ff c1 b 2005eb8 <rtems_fdisk_compact+0x128>
2005fb8: 90 10 00 1d mov %i5, %o0
compacted_segs += segments;
}
return 0;
}
2005fbc: b0 10 00 08 mov %o0, %i0
2005fc0: 81 c7 e0 08 ret
2005fc4: 81 e8 00 00 restore
020051e0 <rtems_fdisk_erase_segment>:
/**
* Erase the segment.
*/
static int
rtems_fdisk_erase_segment (rtems_flashdisk* fd, rtems_fdisk_segment_ctl* sc)
{
20051e0: 9d e3 bf a0 save %sp, -96, %sp
int ret;
uint32_t device;
uint32_t segment;
const rtems_fdisk_segment_desc* sd;
const rtems_fdisk_driver_handlers* ops;
device = sc->device;
20051e4: d2 06 60 08 ld [ %i1 + 8 ], %o1
segment = sc->segment;
20051e8: d4 06 60 0c ld [ %i1 + 0xc ], %o2
static const rtems_fdisk_segment_desc*
rtems_fdisk_seg_descriptor (const rtems_flashdisk* fd,
uint32_t device,
uint32_t segment)
{
return fd->devices[device].segments[segment].descriptor;
20051ec: 85 2a 60 04 sll %o1, 4, %g2
20051f0: 83 2a 60 02 sll %o1, 2, %g1
20051f4: 82 20 80 01 sub %g2, %g1, %g1
20051f8: c4 06 20 2c ld [ %i0 + 0x2c ], %g2
20051fc: 89 2a a0 06 sll %o2, 6, %g4
2005200: 86 00 80 01 add %g2, %g1, %g3
const rtems_fdisk_segment_desc* sd;
const rtems_fdisk_driver_handlers* ops;
device = sc->device;
segment = sc->segment;
sd = rtems_fdisk_seg_descriptor (fd, device, segment);
ops = fd->devices[device].descriptor->flash_ops;
2005204: c6 00 e0 08 ld [ %g3 + 8 ], %g3
static const rtems_fdisk_segment_desc*
rtems_fdisk_seg_descriptor (const rtems_flashdisk* fd,
uint32_t device,
uint32_t segment)
{
return fd->devices[device].segments[segment].descriptor;
2005208: c2 00 80 01 ld [ %g2 + %g1 ], %g1
const rtems_fdisk_driver_handlers* ops;
device = sc->device;
segment = sc->segment;
sd = rtems_fdisk_seg_descriptor (fd, device, segment);
ops = fd->devices[device].descriptor->flash_ops;
ret = ops->erase (sd, device, segment);
200520c: c6 00 e0 08 ld [ %g3 + 8 ], %g3
static const rtems_fdisk_segment_desc*
rtems_fdisk_seg_descriptor (const rtems_flashdisk* fd,
uint32_t device,
uint32_t segment)
{
return fd->devices[device].segments[segment].descriptor;
2005210: 85 2a a0 04 sll %o2, 4, %g2
2005214: 84 21 00 02 sub %g4, %g2, %g2
2005218: 84 00 40 02 add %g1, %g2, %g2
const rtems_fdisk_driver_handlers* ops;
device = sc->device;
segment = sc->segment;
sd = rtems_fdisk_seg_descriptor (fd, device, segment);
ops = fd->devices[device].descriptor->flash_ops;
ret = ops->erase (sd, device, segment);
200521c: c2 00 e0 10 ld [ %g3 + 0x10 ], %g1
2005220: 9f c0 40 00 call %g1
2005224: d0 00 a0 04 ld [ %g2 + 4 ], %o0
if (ret)
2005228: ba 92 20 00 orcc %o0, 0, %i5
200522c: 22 80 00 16 be,a 2005284 <rtems_fdisk_erase_segment+0xa4><== ALWAYS TAKEN
2005230: c4 06 20 28 ld [ %i0 + 0x28 ], %g2
{
rtems_fdisk_error (" erase-segment:%02d-%03d: " \
2005234: f6 06 60 08 ld [ %i1 + 8 ], %i3 <== NOT EXECUTED
2005238: 40 00 78 1d call 20232ac <strerror> <== NOT EXECUTED
200523c: f8 06 60 0c ld [ %i1 + 0xc ], %i4 <== NOT EXECUTED
2005240: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
2005244: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
2005248: 94 10 00 1c mov %i4, %o2 <== NOT EXECUTED
200524c: 98 10 00 1d mov %i5, %o4 <== NOT EXECUTED
2005250: 11 00 80 c3 sethi %hi(0x2030c00), %o0 <== NOT EXECUTED
2005254: 7f ff ff c6 call 200516c <rtems_fdisk_error> <== NOT EXECUTED
2005258: 90 12 21 d8 or %o0, 0x1d8, %o0 ! 2030dd8 <__FUNCTION__.7063+0x5b8><== NOT EXECUTED
"segment erase failed: %s (%d)",
sc->device, sc->segment, strerror (ret), ret);
sc->failed = true;
200525c: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED
if (!rtems_fdisk_segment_queue_present (&fd->failed, sc))
2005260: b0 06 20 58 add %i0, 0x58, %i0 <== NOT EXECUTED
if (ret)
{
rtems_fdisk_error (" erase-segment:%02d-%03d: " \
"segment erase failed: %s (%d)",
sc->device, sc->segment, strerror (ret), ret);
sc->failed = true;
2005264: c2 26 60 28 st %g1, [ %i1 + 0x28 ] <== NOT EXECUTED
if (!rtems_fdisk_segment_queue_present (&fd->failed, sc))
2005268: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
200526c: 7f ff ff 09 call 2004e90 <rtems_fdisk_segment_queue_present><== NOT EXECUTED
2005270: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
2005274: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
2005278: 12 80 00 18 bne 20052d8 <rtems_fdisk_erase_segment+0xf8> <== NOT EXECUTED
200527c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
2005280: 30 80 00 14 b,a 20052d0 <rtems_fdisk_erase_segment+0xf0> <== NOT EXECUTED
rtems_fdisk_segment_queue_push_tail (&fd->failed, sc);
return ret;
}
fd->erased_blocks += sc->pages;
2005284: c2 06 60 14 ld [ %i1 + 0x14 ], %g1
sc->erased++;
memset (sc->page_descriptors, 0xff, sc->pages_desc * fd->block_size);
2005288: d2 06 60 18 ld [ %i1 + 0x18 ], %o1
if (!rtems_fdisk_segment_queue_present (&fd->failed, sc))
rtems_fdisk_segment_queue_push_tail (&fd->failed, sc);
return ret;
}
fd->erased_blocks += sc->pages;
200528c: 82 00 80 01 add %g2, %g1, %g1
2005290: c2 26 20 28 st %g1, [ %i0 + 0x28 ]
sc->erased++;
2005294: c2 06 60 2c ld [ %i1 + 0x2c ], %g1
memset (sc->page_descriptors, 0xff, sc->pages_desc * fd->block_size);
2005298: d0 06 20 14 ld [ %i0 + 0x14 ], %o0
rtems_fdisk_segment_queue_push_tail (&fd->failed, sc);
return ret;
}
fd->erased_blocks += sc->pages;
sc->erased++;
200529c: 82 00 60 01 inc %g1
memset (sc->page_descriptors, 0xff, sc->pages_desc * fd->block_size);
20052a0: f8 06 60 10 ld [ %i1 + 0x10 ], %i4
20052a4: 7f ff f4 bc call 2002594 <.umul>
20052a8: c2 26 60 2c st %g1, [ %i1 + 0x2c ]
20052ac: 92 10 20 ff mov 0xff, %o1
20052b0: 94 10 00 08 mov %o0, %o2
20052b4: 40 00 73 11 call 2021ef8 <memset>
20052b8: 90 10 00 1c mov %i4, %o0
/*
* Push to the tail of the available queue. It is a very
* simple type of wear reduction. Every other available
* segment will now get a go.
*/
rtems_fdisk_segment_queue_push_tail (&fd->available, sc);
20052bc: 90 06 20 34 add %i0, 0x34, %o0
fd->erased_blocks += sc->pages;
sc->erased++;
memset (sc->page_descriptors, 0xff, sc->pages_desc * fd->block_size);
sc->pages_active = 0;
20052c0: c0 26 60 1c clr [ %i1 + 0x1c ]
sc->pages_used = 0;
20052c4: c0 26 60 20 clr [ %i1 + 0x20 ]
sc->pages_bad = 0;
20052c8: c0 26 60 24 clr [ %i1 + 0x24 ]
sc->failed = false;
20052cc: c0 26 60 28 clr [ %i1 + 0x28 ]
/*
* Push to the tail of the available queue. It is a very
* simple type of wear reduction. Every other available
* segment will now get a go.
*/
rtems_fdisk_segment_queue_push_tail (&fd->available, sc);
20052d0: 7f ff fe a3 call 2004d5c <rtems_fdisk_segment_queue_push_tail>
20052d4: 92 10 00 19 mov %i1, %o1
return 0;
}
20052d8: 81 c7 e0 08 ret
20052dc: 91 e8 00 1d restore %g0, %i5, %o0
0200516c <rtems_fdisk_error>:
* @param ... The arguments for the format text.
* @return int The number of bytes written to the output.
*/
static int
rtems_fdisk_error (const char *format, ...)
{
200516c: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED
int ret;
va_list args;
va_start (args, format);
2005170: 82 07 a0 48 add %fp, 0x48, %g1 <== NOT EXECUTED
2005174: fa 27 a0 58 st %i5, [ %fp + 0x58 ] <== NOT EXECUTED
2005178: c2 27 bf fc st %g1, [ %fp + -4 ] <== NOT EXECUTED
fprintf (stderr, "fdisk:error:");
200517c: 3b 00 80 d8 sethi %hi(0x2036000), %i5 <== NOT EXECUTED
2005180: c2 07 61 40 ld [ %i5 + 0x140 ], %g1 ! 2036140 <_impure_ptr><== NOT EXECUTED
static int
rtems_fdisk_error (const char *format, ...)
{
int ret;
va_list args;
va_start (args, format);
2005184: f2 27 a0 48 st %i1, [ %fp + 0x48 ] <== NOT EXECUTED
2005188: f4 27 a0 4c st %i2, [ %fp + 0x4c ] <== NOT EXECUTED
200518c: f6 27 a0 50 st %i3, [ %fp + 0x50 ] <== NOT EXECUTED
2005190: f8 27 a0 54 st %i4, [ %fp + 0x54 ] <== NOT EXECUTED
fprintf (stderr, "fdisk:error:");
2005194: d2 00 60 0c ld [ %g1 + 0xc ], %o1 <== NOT EXECUTED
2005198: 11 00 80 c3 sethi %hi(0x2030c00), %o0 <== NOT EXECUTED
200519c: 40 00 70 cb call 20214c8 <fputs> <== NOT EXECUTED
20051a0: 90 12 21 98 or %o0, 0x198, %o0 ! 2030d98 <__FUNCTION__.7063+0x578><== NOT EXECUTED
ret = vfprintf (stderr, format, args);
20051a4: c2 07 61 40 ld [ %i5 + 0x140 ], %g1 <== NOT EXECUTED
20051a8: d4 07 bf fc ld [ %fp + -4 ], %o2 <== NOT EXECUTED
20051ac: d0 00 60 0c ld [ %g1 + 0xc ], %o0 <== NOT EXECUTED
20051b0: 40 00 93 02 call 2029db8 <vfprintf> <== NOT EXECUTED
20051b4: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
fprintf (stderr, "\n");
20051b8: c2 07 61 40 ld [ %i5 + 0x140 ], %g1 <== NOT EXECUTED
{
int ret;
va_list args;
va_start (args, format);
fprintf (stderr, "fdisk:error:");
ret = vfprintf (stderr, format, args);
20051bc: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED
fprintf (stderr, "\n");
20051c0: d2 00 60 0c ld [ %g1 + 0xc ], %o1 <== NOT EXECUTED
20051c4: 40 00 70 8d call 20213f8 <fputc> <== NOT EXECUTED
20051c8: 90 10 20 0a mov 0xa, %o0 <== NOT EXECUTED
fflush (stderr);
20051cc: c2 07 61 40 ld [ %i5 + 0x140 ], %g1 <== NOT EXECUTED
20051d0: 40 00 6f 7c call 2020fc0 <fflush> <== NOT EXECUTED
20051d4: d0 00 60 0c ld [ %g1 + 0xc ], %o0 <== NOT EXECUTED
va_end (args);
return ret;
}
20051d8: 81 c7 e0 08 ret <== NOT EXECUTED
20051dc: 81 e8 00 00 restore <== NOT EXECUTED
02004fec <rtems_fdisk_info>:
* @param ... The arguments for the format text.
* @return int The number of bytes written to the output.
*/
static int
rtems_fdisk_info (const rtems_flashdisk* fd, const char *format, ...)
{
2004fec: 9d e3 bf 98 save %sp, -104, %sp
int ret = 0;
if (fd->info_level >= 2)
{
va_list args;
va_start (args, format);
2004ff0: f4 27 a0 4c st %i2, [ %fp + 0x4c ]
2004ff4: f6 27 a0 50 st %i3, [ %fp + 0x50 ]
2004ff8: f8 27 a0 54 st %i4, [ %fp + 0x54 ]
2004ffc: fa 27 a0 58 st %i5, [ %fp + 0x58 ]
*/
static int
rtems_fdisk_info (const rtems_flashdisk* fd, const char *format, ...)
{
int ret = 0;
if (fd->info_level >= 2)
2005000: c2 06 20 6c ld [ %i0 + 0x6c ], %g1
2005004: 80 a0 60 01 cmp %g1, 1
2005008: 08 80 00 17 bleu 2005064 <rtems_fdisk_info+0x78> <== ALWAYS TAKEN
200500c: b0 10 20 00 clr %i0
{
va_list args;
va_start (args, format);
2005010: 82 07 a0 4c add %fp, 0x4c, %g1 <== NOT EXECUTED
fprintf (stdout, "fdisk:");
2005014: 3b 00 80 d8 sethi %hi(0x2036000), %i5 <== NOT EXECUTED
{
int ret = 0;
if (fd->info_level >= 2)
{
va_list args;
va_start (args, format);
2005018: c2 27 bf fc st %g1, [ %fp + -4 ] <== NOT EXECUTED
fprintf (stdout, "fdisk:");
200501c: c2 07 61 40 ld [ %i5 + 0x140 ], %g1 <== NOT EXECUTED
2005020: 11 00 80 c3 sethi %hi(0x2030c00), %o0 <== NOT EXECUTED
2005024: d2 00 60 08 ld [ %g1 + 8 ], %o1 <== NOT EXECUTED
2005028: 40 00 71 28 call 20214c8 <fputs> <== NOT EXECUTED
200502c: 90 12 21 80 or %o0, 0x180, %o0 <== NOT EXECUTED
ret = vfprintf (stdout, format, args);
2005030: c2 07 61 40 ld [ %i5 + 0x140 ], %g1 <== NOT EXECUTED
2005034: d4 07 bf fc ld [ %fp + -4 ], %o2 <== NOT EXECUTED
2005038: d0 00 60 08 ld [ %g1 + 8 ], %o0 <== NOT EXECUTED
200503c: 40 00 93 5f call 2029db8 <vfprintf> <== NOT EXECUTED
2005040: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
fprintf (stdout, "\n");
2005044: c2 07 61 40 ld [ %i5 + 0x140 ], %g1 <== NOT EXECUTED
if (fd->info_level >= 2)
{
va_list args;
va_start (args, format);
fprintf (stdout, "fdisk:");
ret = vfprintf (stdout, format, args);
2005048: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED
fprintf (stdout, "\n");
200504c: d2 00 60 08 ld [ %g1 + 8 ], %o1 <== NOT EXECUTED
2005050: 40 00 70 ea call 20213f8 <fputc> <== NOT EXECUTED
2005054: 90 10 20 0a mov 0xa, %o0 <== NOT EXECUTED
fflush (stdout);
2005058: c2 07 61 40 ld [ %i5 + 0x140 ], %g1 <== NOT EXECUTED
200505c: 40 00 6f d9 call 2020fc0 <fflush> <== NOT EXECUTED
2005060: d0 00 60 08 ld [ %g1 + 8 ], %o0 <== NOT EXECUTED
va_end (args);
}
return ret;
}
2005064: 81 c7 e0 08 ret
2005068: 81 e8 00 00 restore
02007160 <rtems_fdisk_initialize>:
*/
rtems_device_driver
rtems_fdisk_initialize (rtems_device_major_number major,
rtems_device_minor_number minor,
void* arg __attribute__((unused)))
{
2007160: 9d e3 bf 60 save %sp, -160, %sp
const rtems_flashdisk_config* c = rtems_flashdisk_configuration;
rtems_flashdisk* fd;
rtems_status_code sc;
sc = rtems_disk_io_initialize ();
2007164: 7f ff f6 89 call 2004b88 <rtems_disk_io_initialize>
2007168: b4 10 00 18 mov %i0, %i2
if (sc != RTEMS_SUCCESSFUL)
200716c: b0 92 20 00 orcc %o0, 0, %i0
2007170: 12 80 01 3e bne 2007668 <rtems_fdisk_initialize+0x508> <== NEVER TAKEN
2007174: 01 00 00 00 nop
static rtems_status_code
rtems_fdisk_crc16_gen_factors (uint16_t pattern)
{
uint32_t b;
rtems_fdisk_crc16_factor = malloc (sizeof (uint16_t) * 256);
2007178: 40 00 05 d2 call 20088c0 <malloc>
200717c: 90 10 22 00 mov 0x200, %o0 ! 200 <PROM_START+0x200>
2007180: 03 00 81 19 sethi %hi(0x2046400), %g1
2007184: d0 20 62 d8 st %o0, [ %g1 + 0x2d8 ] ! 20466d8 <rtems_fdisk_crc16_factor>
for (b = 0; b < 256; b++)
{
uint32_t i;
uint16_t v = b;
for (i = 8; i--;)
v = v & 1 ? (v >> 1) ^ pattern : v >> 1;
2007188: 09 3f ff e1 sethi %hi(0xffff8400), %g4
rtems_fdisk_crc16_gen_factors (uint16_t pattern)
{
uint32_t b;
rtems_fdisk_crc16_factor = malloc (sizeof (uint16_t) * 256);
if (!rtems_fdisk_crc16_factor)
200718c: 82 10 20 00 clr %g1
2007190: 80 a2 20 00 cmp %o0, 0
2007194: 12 80 00 04 bne 20071a4 <rtems_fdisk_initialize+0x44> <== ALWAYS TAKEN
2007198: 88 11 20 08 or %g4, 8, %g4
/*
* One copy buffer of a page size.
*/
fd->copy_buffer = malloc (c->block_size);
if (!fd->copy_buffer)
return RTEMS_NO_MEMORY;
200719c: 81 c7 e0 08 ret <== NOT EXECUTED
20071a0: 91 e8 20 1a restore %g0, 0x1a, %o0 <== NOT EXECUTED
return RTEMS_NO_MEMORY;
for (b = 0; b < 256; b++)
{
uint32_t i;
uint16_t v = b;
20071a4: 84 10 00 01 mov %g1, %g2
20071a8: 10 80 00 06 b 20071c0 <rtems_fdisk_initialize+0x60>
20071ac: 86 10 20 09 mov 9, %g3
20071b0: 85 28 a0 10 sll %g2, 0x10, %g2
for (i = 8; i--;)
v = v & 1 ? (v >> 1) ^ pattern : v >> 1;
20071b4: 02 80 00 03 be 20071c0 <rtems_fdisk_initialize+0x60>
20071b8: 85 30 a0 11 srl %g2, 0x11, %g2
20071bc: 84 18 80 04 xor %g2, %g4, %g2
for (b = 0; b < 256; b++)
{
uint32_t i;
uint16_t v = b;
for (i = 8; i--;)
20071c0: 86 80 ff ff addcc %g3, -1, %g3
20071c4: 12 bf ff fb bne 20071b0 <rtems_fdisk_initialize+0x50>
20071c8: 80 88 a0 01 btst 1, %g2
* @param major Flash disk major device number.
* @param minor Minor device number, not applicable.
* @param arg Initialization argument, not applicable.
*/
rtems_device_driver
rtems_fdisk_initialize (rtems_device_major_number major,
20071cc: 87 28 60 01 sll %g1, 1, %g3
rtems_fdisk_crc16_factor = malloc (sizeof (uint16_t) * 256);
if (!rtems_fdisk_crc16_factor)
return RTEMS_NO_MEMORY;
for (b = 0; b < 256; b++)
20071d0: 82 00 60 01 inc %g1
20071d4: 80 a0 61 00 cmp %g1, 0x100
20071d8: 12 bf ff f3 bne 20071a4 <rtems_fdisk_initialize+0x44>
20071dc: c4 32 00 03 sth %g2, [ %o0 + %g3 ]
sc = rtems_fdisk_crc16_gen_factors (0x8408);
if (sc != RTEMS_SUCCESSFUL)
return sc;
rtems_flashdisks = calloc (rtems_flashdisk_configuration_size,
20071e0: 10 80 01 11 b 2007624 <rtems_fdisk_initialize+0x4c4>
20071e4: 3b 00 80 d7 sethi %hi(0x2035c00), %i5
dev_t dev = rtems_filesystem_make_dev_t (major, minor);
uint32_t device;
uint32_t blocks = 0;
int ret;
fd = &rtems_flashdisks[minor];
20071e8: c2 05 a2 d0 ld [ %l6 + 0x2d0 ], %g1
name [sizeof(RTEMS_FLASHDISK_DEVICE_BASE_NAME)] += minor;
20071ec: f6 2f bf f9 stb %i3, [ %fp + -7 ]
if (!rtems_flashdisks)
return RTEMS_NO_MEMORY;
for (minor = 0; minor < rtems_flashdisk_configuration_size; minor++, c++)
{
char name[] = RTEMS_FLASHDISK_DEVICE_BASE_NAME "a";
20071f0: 05 0b d9 19 sethi %hi(0x2f646400), %g2
20071f4: 07 0b d9 99 sethi %hi(0x2f666400), %g3
20071f8: 84 10 a1 76 or %g2, 0x176, %g2
20071fc: 86 10 e0 64 or %g3, 0x64, %g3
2007200: c4 3f bf f0 std %g2, [ %fp + -16 ]
dev_t dev = rtems_filesystem_make_dev_t (major, minor);
uint32_t device;
uint32_t blocks = 0;
int ret;
fd = &rtems_flashdisks[minor];
2007204: ba 00 40 10 add %g1, %l0, %i5
name [sizeof(RTEMS_FLASHDISK_DEVICE_BASE_NAME)] += minor;
fd->major = major;
2007208: f4 20 40 10 st %i2, [ %g1 + %l0 ]
fd->minor = minor;
fd->flags = c->flags;
200720c: c2 07 20 0c ld [ %i4 + 0xc ], %g1
fd->compact_segs = c->compact_segs;
fd->avail_compact_segs = c->avail_compact_segs;
fd->block_size = c->block_size;
2007210: e2 07 00 00 ld [ %i4 ], %l1
name [sizeof(RTEMS_FLASHDISK_DEVICE_BASE_NAME)] += minor;
fd->major = major;
fd->minor = minor;
fd->flags = c->flags;
2007214: c2 27 60 08 st %g1, [ %i5 + 8 ]
fd->compact_segs = c->compact_segs;
2007218: c2 07 20 14 ld [ %i4 + 0x14 ], %g1
fd = &rtems_flashdisks[minor];
name [sizeof(RTEMS_FLASHDISK_DEVICE_BASE_NAME)] += minor;
fd->major = major;
fd->minor = minor;
200721c: f6 27 60 04 st %i3, [ %i5 + 4 ]
fd->flags = c->flags;
fd->compact_segs = c->compact_segs;
2007220: c2 27 60 0c st %g1, [ %i5 + 0xc ]
fd->avail_compact_segs = c->avail_compact_segs;
2007224: c2 07 20 18 ld [ %i4 + 0x18 ], %g1
fd->block_size = c->block_size;
fd->unavail_blocks = c->unavail_blocks;
fd->info_level = c->info_level;
for (device = 0; device < c->device_count; device++)
2007228: da 07 20 04 ld [ %i4 + 4 ], %o5
fd->major = major;
fd->minor = minor;
fd->flags = c->flags;
fd->compact_segs = c->compact_segs;
fd->avail_compact_segs = c->avail_compact_segs;
200722c: c2 27 60 10 st %g1, [ %i5 + 0x10 ]
fd->block_size = c->block_size;
fd->unavail_blocks = c->unavail_blocks;
2007230: c2 07 20 10 ld [ %i4 + 0x10 ], %g1
fd->major = major;
fd->minor = minor;
fd->flags = c->flags;
fd->compact_segs = c->compact_segs;
fd->avail_compact_segs = c->avail_compact_segs;
fd->block_size = c->block_size;
2007234: e2 27 60 14 st %l1, [ %i5 + 0x14 ]
fd->unavail_blocks = c->unavail_blocks;
2007238: c2 27 60 20 st %g1, [ %i5 + 0x20 ]
fd->info_level = c->info_level;
200723c: c2 07 20 1c ld [ %i4 + 0x1c ], %g1
for (device = 0; device < c->device_count; device++)
2007240: a4 10 20 00 clr %l2
fd->flags = c->flags;
fd->compact_segs = c->compact_segs;
fd->avail_compact_segs = c->avail_compact_segs;
fd->block_size = c->block_size;
fd->unavail_blocks = c->unavail_blocks;
fd->info_level = c->info_level;
2007244: c2 27 60 6c st %g1, [ %i5 + 0x6c ]
for (minor = 0; minor < rtems_flashdisk_configuration_size; minor++, c++)
{
char name[] = RTEMS_FLASHDISK_DEVICE_BASE_NAME "a";
dev_t dev = rtems_filesystem_make_dev_t (major, minor);
uint32_t device;
uint32_t blocks = 0;
2007248: b2 10 20 00 clr %i1
fd->avail_compact_segs = c->avail_compact_segs;
fd->block_size = c->block_size;
fd->unavail_blocks = c->unavail_blocks;
fd->info_level = c->info_level;
for (device = 0; device < c->device_count; device++)
200724c: 10 80 00 28 b 20072ec <rtems_fdisk_initialize+0x18c>
2007250: b0 10 20 00 clr %i0
rtems_fdisk_blocks_in_device (const rtems_fdisk_device_desc* dd,
uint32_t page_size)
{
uint32_t count = 0;
uint32_t s;
for (s = 0; s < dd->segment_count; s++)
2007254: a6 10 20 00 clr %l3
fd->block_size = c->block_size;
fd->unavail_blocks = c->unavail_blocks;
fd->info_level = c->info_level;
for (device = 0; device < c->device_count; device++)
blocks += rtems_fdisk_blocks_in_device (&c->devices[device],
2007258: 96 00 40 12 add %g1, %l2, %o3
rtems_fdisk_blocks_in_device (const rtems_fdisk_device_desc* dd,
uint32_t page_size)
{
uint32_t count = 0;
uint32_t s;
for (s = 0; s < dd->segment_count; s++)
200725c: d8 00 40 12 ld [ %g1 + %l2 ], %o4
2007260: 86 10 20 00 clr %g3
*/
static uint32_t
rtems_fdisk_blocks_in_device (const rtems_fdisk_device_desc* dd,
uint32_t page_size)
{
uint32_t count = 0;
2007264: 10 80 00 1c b 20072d4 <rtems_fdisk_initialize+0x174>
2007268: 84 10 20 00 clr %g2
*/
static uint32_t
rtems_fdisk_pages_in_segment (const rtems_fdisk_segment_desc* sd,
uint32_t page_size)
{
return sd->size / page_size;
200726c: 92 10 00 11 mov %l1, %o1
{
uint32_t count = 0;
uint32_t s;
for (s = 0; s < dd->segment_count; s++)
{
const rtems_fdisk_segment_desc* sd = &dd->segments[s];
2007270: 9e 01 00 13 add %g4, %l3, %o7
*/
static uint32_t
rtems_fdisk_pages_in_segment (const rtems_fdisk_segment_desc* sd,
uint32_t page_size)
{
return sd->size / page_size;
2007274: d0 03 e0 08 ld [ %o7 + 8 ], %o0
2007278: c4 3f bf e0 std %g2, [ %fp + -32 ]
200727c: d8 3f bf c8 std %o4, [ %fp + -56 ]
2007280: c8 27 bf dc st %g4, [ %fp + -36 ]
2007284: 7f ff ec fe call 200267c <.udiv>
2007288: d6 27 bf d4 st %o3, [ %fp + -44 ]
rtems_fdisk_page_desc_pages (const rtems_fdisk_segment_desc* sd,
uint32_t page_size)
{
uint32_t pages = rtems_fdisk_pages_in_segment (sd, page_size);
uint32_t bytes = pages * sizeof (rtems_fdisk_page_desc);
return ((bytes - 1) / page_size) + 1;
200728c: 94 02 3f ff add %o0, -1, %o2
2007290: 92 10 00 11 mov %l1, %o1
2007294: d4 27 bf d0 st %o2, [ %fp + -48 ]
static uint32_t
rtems_fdisk_page_desc_pages (const rtems_fdisk_segment_desc* sd,
uint32_t page_size)
{
uint32_t pages = rtems_fdisk_pages_in_segment (sd, page_size);
uint32_t bytes = pages * sizeof (rtems_fdisk_page_desc);
2007298: 91 2a 20 03 sll %o0, 3, %o0
return ((bytes - 1) / page_size) + 1;
200729c: 7f ff ec f8 call 200267c <.udiv>
20072a0: 90 02 3f ff add %o0, -1, %o0
for (s = 0; s < dd->segment_count; s++)
{
const rtems_fdisk_segment_desc* sd = &dd->segments[s];
count +=
(rtems_fdisk_pages_in_segment (sd, page_size) -
rtems_fdisk_page_desc_pages (sd, page_size)) * sd->count;
20072a4: c8 07 bf dc ld [ %fp + -36 ], %g4
20072a8: d4 1f bf d0 ldd [ %fp + -48 ], %o2
20072ac: d2 11 00 13 lduh [ %g4 + %l3 ], %o1
20072b0: 90 22 80 08 sub %o2, %o0, %o0
20072b4: 7f ff ec b8 call 2002594 <.umul>
20072b8: d6 27 bf d4 st %o3, [ %fp + -44 ]
uint32_t count = 0;
uint32_t s;
for (s = 0; s < dd->segment_count; s++)
{
const rtems_fdisk_segment_desc* sd = &dd->segments[s];
count +=
20072bc: c4 1f bf e0 ldd [ %fp + -32 ], %g2
20072c0: d8 1f bf c8 ldd [ %fp + -56 ], %o4
20072c4: d6 07 bf d4 ld [ %fp + -44 ], %o3
20072c8: 84 00 80 08 add %g2, %o0, %g2
rtems_fdisk_blocks_in_device (const rtems_fdisk_device_desc* dd,
uint32_t page_size)
{
uint32_t count = 0;
uint32_t s;
for (s = 0; s < dd->segment_count; s++)
20072cc: 86 00 e0 01 inc %g3
20072d0: a6 04 e0 0c add %l3, 0xc, %l3
20072d4: 80 a0 c0 0c cmp %g3, %o4
20072d8: 32 bf ff e5 bne,a 200726c <rtems_fdisk_initialize+0x10c>
20072dc: c8 02 e0 04 ld [ %o3 + 4 ], %g4
fd->block_size = c->block_size;
fd->unavail_blocks = c->unavail_blocks;
fd->info_level = c->info_level;
for (device = 0; device < c->device_count; device++)
blocks += rtems_fdisk_blocks_in_device (&c->devices[device],
20072e0: b2 06 40 02 add %i1, %g2, %i1
fd->avail_compact_segs = c->avail_compact_segs;
fd->block_size = c->block_size;
fd->unavail_blocks = c->unavail_blocks;
fd->info_level = c->info_level;
for (device = 0; device < c->device_count; device++)
20072e4: b0 06 20 01 inc %i0
20072e8: a4 04 a0 0c add %l2, 0xc, %l2
20072ec: 80 a6 00 0d cmp %i0, %o5
20072f0: 32 bf ff d9 bne,a 2007254 <rtems_fdisk_initialize+0xf4>
20072f4: c2 07 20 08 ld [ %i4 + 8 ], %g1
c->block_size);
/*
* One copy buffer of a page size.
*/
fd->copy_buffer = malloc (c->block_size);
20072f8: 40 00 05 72 call 20088c0 <malloc>
20072fc: 90 10 00 11 mov %l1, %o0
if (!fd->copy_buffer)
2007300: 80 a2 20 00 cmp %o0, 0
2007304: 02 80 00 bd be 20075f8 <rtems_fdisk_initialize+0x498> <== NEVER TAKEN
2007308: d0 27 60 68 st %o0, [ %i5 + 0x68 ]
return RTEMS_NO_MEMORY;
fd->blocks = calloc (blocks, sizeof (rtems_fdisk_block_ctl));
200730c: 90 10 00 19 mov %i1, %o0
2007310: 40 00 02 c5 call 2007e24 <calloc>
2007314: 92 10 20 08 mov 8, %o1
if (!fd->blocks)
2007318: 80 a2 20 00 cmp %o0, 0
200731c: 02 80 00 b7 be 20075f8 <rtems_fdisk_initialize+0x498> <== NEVER TAKEN
2007320: d0 27 60 18 st %o0, [ %i5 + 0x18 ]
return RTEMS_NO_MEMORY;
fd->block_count = blocks;
2007324: f2 27 60 1c st %i1, [ %i5 + 0x1c ]
fd->devices = calloc (c->device_count, sizeof (rtems_fdisk_device_ctl));
2007328: 90 10 00 18 mov %i0, %o0
200732c: 40 00 02 be call 2007e24 <calloc>
2007330: 92 10 20 0c mov 0xc, %o1
if (!fd->devices)
2007334: 80 a2 20 00 cmp %o0, 0
2007338: 02 80 00 b0 be 20075f8 <rtems_fdisk_initialize+0x498> <== NEVER TAKEN
200733c: d0 27 60 2c st %o0, [ %i5 + 0x2c ]
return RTEMS_NO_MEMORY;
sc = rtems_semaphore_create (rtems_build_name ('F', 'D', 'S', 'K'), 1,
2007340: 90 10 00 15 mov %l5, %o0
2007344: 92 10 20 01 mov 1, %o1
2007348: 94 10 20 54 mov 0x54, %o2
200734c: 96 10 20 00 clr %o3
2007350: 40 00 15 90 call 200c990 <rtems_semaphore_create>
2007354: 98 07 60 64 add %i5, 0x64, %o4
RTEMS_PRIORITY | RTEMS_BINARY_SEMAPHORE |
RTEMS_INHERIT_PRIORITY, 0, &fd->lock);
if (sc != RTEMS_SUCCESSFUL)
2007358: b0 92 20 00 orcc %o0, 0, %i0
200735c: 22 80 00 0d be,a 2007390 <rtems_fdisk_initialize+0x230> <== ALWAYS TAKEN
2007360: d6 07 60 20 ld [ %i5 + 0x20 ], %o3
{
rtems_fdisk_error ("disk lock create failed");
2007364: 11 00 80 c6 sethi %hi(0x2031800), %o0 <== NOT EXECUTED
2007368: 7f ff f7 81 call 200516c <rtems_fdisk_error> <== NOT EXECUTED
200736c: 90 12 20 a8 or %o0, 0xa8, %o0 ! 20318a8 <__FUNCTION__.7063+0x1088><== NOT EXECUTED
free (fd->copy_buffer);
2007370: 40 00 03 ae call 2008228 <free> <== NOT EXECUTED
2007374: d0 07 60 68 ld [ %i5 + 0x68 ], %o0 <== NOT EXECUTED
free (fd->blocks);
2007378: 40 00 03 ac call 2008228 <free> <== NOT EXECUTED
200737c: d0 07 60 18 ld [ %i5 + 0x18 ], %o0 <== NOT EXECUTED
free (fd->devices);
2007380: 40 00 03 aa call 2008228 <free> <== NOT EXECUTED
2007384: d0 07 60 2c ld [ %i5 + 0x2c ], %o0 <== NOT EXECUTED
2007388: 81 c7 e0 08 ret <== NOT EXECUTED
200738c: 81 e8 00 00 restore <== NOT EXECUTED
return sc;
}
sc = rtems_disk_create_phys(dev, c->block_size,
2007390: d4 07 00 00 ld [ %i4 ], %o2
2007394: 90 10 00 1a mov %i2, %o0
2007398: e8 23 a0 5c st %l4, [ %sp + 0x5c ]
200739c: 92 10 00 1b mov %i3, %o1
20073a0: 96 26 40 0b sub %i1, %o3, %o3
20073a4: 19 00 80 17 sethi %hi(0x2005c00), %o4
20073a8: 9a 10 20 00 clr %o5
20073ac: 7f ff f5 61 call 2004930 <rtems_disk_create_phys>
20073b0: 98 13 23 c8 or %o4, 0x3c8, %o4
blocks - fd->unavail_blocks,
rtems_fdisk_ioctl, NULL, name);
if (sc != RTEMS_SUCCESSFUL)
20073b4: b0 92 20 00 orcc %o0, 0, %i0
20073b8: 22 80 00 58 be,a 2007518 <rtems_fdisk_initialize+0x3b8> <== ALWAYS TAKEN
20073bc: b2 10 20 00 clr %i1
{
rtems_semaphore_delete (fd->lock);
20073c0: 40 00 15 e3 call 200cb4c <rtems_semaphore_delete> <== NOT EXECUTED
20073c4: d0 07 60 64 ld [ %i5 + 0x64 ], %o0 <== NOT EXECUTED
rtems_disk_delete (dev);
20073c8: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
20073cc: 7f ff f4 bf call 20046c8 <rtems_disk_delete> <== NOT EXECUTED
20073d0: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
free (fd->copy_buffer);
20073d4: 40 00 03 95 call 2008228 <free> <== NOT EXECUTED
20073d8: d0 07 60 68 ld [ %i5 + 0x68 ], %o0 <== NOT EXECUTED
free (fd->blocks);
20073dc: 40 00 03 93 call 2008228 <free> <== NOT EXECUTED
20073e0: d0 07 60 18 ld [ %i5 + 0x18 ], %o0 <== NOT EXECUTED
free (fd->devices);
20073e4: 40 00 03 91 call 2008228 <free> <== NOT EXECUTED
20073e8: d0 07 60 2c ld [ %i5 + 0x2c ], %o0 <== NOT EXECUTED
rtems_fdisk_error ("disk create phy failed");
20073ec: 11 00 80 c6 sethi %hi(0x2031800), %o0 <== NOT EXECUTED
20073f0: 7f ff f7 5f call 200516c <rtems_fdisk_error> <== NOT EXECUTED
20073f4: 90 12 20 c0 or %o0, 0xc0, %o0 ! 20318c0 <__FUNCTION__.7063+0x10a0><== NOT EXECUTED
20073f8: 81 c7 e0 08 ret <== NOT EXECUTED
20073fc: 81 e8 00 00 restore <== NOT EXECUTED
static uint32_t
rtems_fdisk_count_segments (const rtems_fdisk_device_desc* dd)
{
uint32_t count = 0;
uint32_t segment;
for (segment = 0; segment < dd->segment_count; segment++)
2007400: 84 10 20 00 clr %g2
{
rtems_fdisk_segment_ctl* sc;
uint32_t segment_count;
uint32_t segment;
segment_count = rtems_fdisk_count_segments (&c->devices[device]);
2007404: a4 00 40 19 add %g1, %i1, %l2
static uint32_t
rtems_fdisk_count_segments (const rtems_fdisk_device_desc* dd)
{
uint32_t count = 0;
uint32_t segment;
for (segment = 0; segment < dd->segment_count; segment++)
2007408: da 00 40 19 ld [ %g1 + %i1 ], %o5
* Count the segments for a device.
*/
static uint32_t
rtems_fdisk_count_segments (const rtems_fdisk_device_desc* dd)
{
uint32_t count = 0;
200740c: a2 10 20 00 clr %l1
uint32_t segment;
for (segment = 0; segment < dd->segment_count; segment++)
2007410: 10 80 00 06 b 2007428 <rtems_fdisk_initialize+0x2c8>
2007414: 82 10 20 00 clr %g1
2007418: 82 00 60 01 inc %g1
count += dd->segments[segment].count;
200741c: c6 10 c0 02 lduh [ %g3 + %g2 ], %g3
2007420: 84 00 a0 0c add %g2, 0xc, %g2
2007424: a2 04 40 03 add %l1, %g3, %l1
static uint32_t
rtems_fdisk_count_segments (const rtems_fdisk_device_desc* dd)
{
uint32_t count = 0;
uint32_t segment;
for (segment = 0; segment < dd->segment_count; segment++)
2007428: 80 a0 40 0d cmp %g1, %o5
200742c: 32 bf ff fb bne,a 2007418 <rtems_fdisk_initialize+0x2b8>
2007430: c6 04 a0 04 ld [ %l2 + 4 ], %g3
uint32_t segment_count;
uint32_t segment;
segment_count = rtems_fdisk_count_segments (&c->devices[device]);
fd->devices[device].segments = calloc (segment_count,
2007434: c2 07 60 2c ld [ %i5 + 0x2c ], %g1
2007438: 90 10 00 11 mov %l1, %o0
200743c: 88 00 40 19 add %g1, %i1, %g4
2007440: c2 27 bf ec st %g1, [ %fp + -20 ]
2007444: c8 27 bf dc st %g4, [ %fp + -36 ]
2007448: da 27 bf cc st %o5, [ %fp + -52 ]
200744c: 40 00 02 76 call 2007e24 <calloc>
2007450: 92 10 20 30 mov 0x30, %o1
2007454: c2 07 bf ec ld [ %fp + -20 ], %g1
sizeof (rtems_fdisk_segment_ctl));
if (!fd->devices[device].segments)
2007458: 80 a2 20 00 cmp %o0, 0
uint32_t segment_count;
uint32_t segment;
segment_count = rtems_fdisk_count_segments (&c->devices[device]);
fd->devices[device].segments = calloc (segment_count,
200745c: d0 20 40 19 st %o0, [ %g1 + %i1 ]
sizeof (rtems_fdisk_segment_ctl));
if (!fd->devices[device].segments)
2007460: c8 07 bf dc ld [ %fp + -36 ], %g4
2007464: 12 80 00 23 bne 20074f0 <rtems_fdisk_initialize+0x390> <== ALWAYS TAKEN
2007468: da 07 bf cc ld [ %fp + -52 ], %o5
{
rtems_disk_delete (dev);
200746c: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
2007470: 7f ff f4 96 call 20046c8 <rtems_disk_delete> <== NOT EXECUTED
2007474: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
rtems_semaphore_delete (fd->lock);
2007478: 40 00 15 b5 call 200cb4c <rtems_semaphore_delete> <== NOT EXECUTED
200747c: d0 07 60 64 ld [ %i5 + 0x64 ], %o0 <== NOT EXECUTED
free (fd->copy_buffer);
2007480: 40 00 03 6a call 2008228 <free> <== NOT EXECUTED
2007484: d0 07 60 68 ld [ %i5 + 0x68 ], %o0 <== NOT EXECUTED
free (fd->blocks);
2007488: 40 00 03 68 call 2008228 <free> <== NOT EXECUTED
200748c: d0 07 60 18 ld [ %i5 + 0x18 ], %o0 <== NOT EXECUTED
free (fd->devices);
2007490: 40 00 03 66 call 2008228 <free> <== NOT EXECUTED
2007494: d0 07 60 2c ld [ %i5 + 0x2c ], %o0 <== NOT EXECUTED
/*
* One copy buffer of a page size.
*/
fd->copy_buffer = malloc (c->block_size);
if (!fd->copy_buffer)
return RTEMS_NO_MEMORY;
2007498: 81 c7 e0 08 ret <== NOT EXECUTED
200749c: 91 e8 20 1a restore %g0, 0x1a, %o0 <== NOT EXECUTED
const rtems_fdisk_segment_desc* sd;
uint32_t seg_segment;
sd = &c->devices[device].segments[segment];
for (seg_segment = 0; seg_segment < sd->count; seg_segment++, sc++)
20074a0: 86 10 20 00 clr %g3
for (segment = 0; segment < c->devices[device].segment_count; segment++)
{
const rtems_fdisk_segment_desc* sd;
uint32_t seg_segment;
sd = &c->devices[device].segments[segment];
20074a4: 96 00 40 02 add %g1, %g2, %o3
for (seg_segment = 0; seg_segment < sd->count; seg_segment++, sc++)
20074a8: d8 10 40 02 lduh [ %g1 + %g2 ], %o4
20074ac: 10 80 00 07 b 20074c8 <rtems_fdisk_initialize+0x368>
20074b0: 82 10 00 08 mov %o0, %g1
{
sc->descriptor = sd;
20074b4: d6 20 60 04 st %o3, [ %g1 + 4 ]
sc->device = device;
20074b8: f0 20 60 08 st %i0, [ %g1 + 8 ]
sc->segment = seg_segment;
sc->erased = 0;
20074bc: c0 20 60 2c clr [ %g1 + 0x2c ]
const rtems_fdisk_segment_desc* sd;
uint32_t seg_segment;
sd = &c->devices[device].segments[segment];
for (seg_segment = 0; seg_segment < sd->count; seg_segment++, sc++)
20074c0: 86 00 e0 01 inc %g3
20074c4: 82 00 60 30 add %g1, 0x30, %g1
20074c8: 80 a0 c0 0c cmp %g3, %o4
20074cc: 2a bf ff fa bcs,a 20074b4 <rtems_fdisk_initialize+0x354>
20074d0: c6 20 60 0c st %g3, [ %g1 + 0xc ]
* @param major Flash disk major device number.
* @param minor Minor device number, not applicable.
* @param arg Initialization argument, not applicable.
*/
rtems_device_driver
rtems_fdisk_initialize (rtems_device_major_number major,
20074d4: 83 2b 20 04 sll %o4, 4, %g1
return RTEMS_NO_MEMORY;
}
sc = fd->devices[device].segments;
for (segment = 0; segment < c->devices[device].segment_count; segment++)
20074d8: 9e 03 e0 01 inc %o7
* @param major Flash disk major device number.
* @param minor Minor device number, not applicable.
* @param arg Initialization argument, not applicable.
*/
rtems_device_driver
rtems_fdisk_initialize (rtems_device_major_number major,
20074dc: 99 2b 20 06 sll %o4, 6, %o4
20074e0: 84 00 a0 0c add %g2, 0xc, %g2
20074e4: 98 23 00 01 sub %o4, %g1, %o4
20074e8: 10 80 00 04 b 20074f8 <rtems_fdisk_initialize+0x398>
20074ec: 90 02 00 0c add %o0, %o4, %o0
segment_count = rtems_fdisk_count_segments (&c->devices[device]);
fd->devices[device].segments = calloc (segment_count,
sizeof (rtems_fdisk_segment_ctl));
if (!fd->devices[device].segments)
20074f0: 84 10 20 00 clr %g2
20074f4: 9e 10 20 00 clr %o7
return RTEMS_NO_MEMORY;
}
sc = fd->devices[device].segments;
for (segment = 0; segment < c->devices[device].segment_count; segment++)
20074f8: 80 a3 c0 0d cmp %o7, %o5
20074fc: 32 bf ff e9 bne,a 20074a0 <rtems_fdisk_initialize+0x340>
2007500: c2 04 a0 04 ld [ %l2 + 4 ], %g1
sc->segment = seg_segment;
sc->erased = 0;
}
}
fd->devices[device].segment_count = segment_count;
2007504: e2 21 20 04 st %l1, [ %g4 + 4 ]
fd->devices[device].descriptor = &c->devices[device];
2007508: e4 21 20 08 st %l2, [ %g4 + 8 ]
free (fd->devices);
rtems_fdisk_error ("disk create phy failed");
return sc;
}
for (device = 0; device < c->device_count; device++)
200750c: b0 06 20 01 inc %i0
2007510: 10 80 00 03 b 200751c <rtems_fdisk_initialize+0x3bc>
2007514: b2 06 60 0c add %i1, 0xc, %i1
}
sc = rtems_disk_create_phys(dev, c->block_size,
blocks - fd->unavail_blocks,
rtems_fdisk_ioctl, NULL, name);
if (sc != RTEMS_SUCCESSFUL)
2007518: b0 10 20 00 clr %i0
free (fd->devices);
rtems_fdisk_error ("disk create phy failed");
return sc;
}
for (device = 0; device < c->device_count; device++)
200751c: c2 07 20 04 ld [ %i4 + 4 ], %g1
2007520: 80 a6 00 01 cmp %i0, %g1
2007524: 2a bf ff b7 bcs,a 2007400 <rtems_fdisk_initialize+0x2a0>
2007528: c2 07 20 08 ld [ %i4 + 8 ], %g1
fd->devices[device].segment_count = segment_count;
fd->devices[device].descriptor = &c->devices[device];
}
fd->device_count = c->device_count;
200752c: c2 27 60 30 st %g1, [ %i5 + 0x30 ]
ret = rtems_fdisk_recover_block_mappings (fd);
2007530: 7f ff f8 43 call 200563c <rtems_fdisk_recover_block_mappings>
2007534: 90 10 00 1d mov %i5, %o0
if (ret)
2007538: b0 92 20 00 orcc %o0, 0, %i0
200753c: 22 80 00 13 be,a 2007588 <rtems_fdisk_initialize+0x428> <== ALWAYS TAKEN
2007540: 90 10 00 1d mov %i5, %o0
{
rtems_disk_delete (dev);
2007544: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
2007548: 7f ff f4 60 call 20046c8 <rtems_disk_delete> <== NOT EXECUTED
200754c: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
rtems_semaphore_delete (fd->lock);
2007550: 40 00 15 7f call 200cb4c <rtems_semaphore_delete> <== NOT EXECUTED
2007554: d0 07 60 64 ld [ %i5 + 0x64 ], %o0 <== NOT EXECUTED
free (fd->copy_buffer);
2007558: 40 00 03 34 call 2008228 <free> <== NOT EXECUTED
200755c: d0 07 60 68 ld [ %i5 + 0x68 ], %o0 <== NOT EXECUTED
free (fd->blocks);
2007560: 40 00 03 32 call 2008228 <free> <== NOT EXECUTED
2007564: d0 07 60 18 ld [ %i5 + 0x18 ], %o0 <== NOT EXECUTED
free (fd->devices);
2007568: 40 00 03 30 call 2008228 <free> <== NOT EXECUTED
200756c: d0 07 60 2c ld [ %i5 + 0x2c ], %o0 <== NOT EXECUTED
rtems_fdisk_error ("recovery of disk failed: %s (%d)",
2007570: 40 00 6f 4f call 20232ac <strerror> <== NOT EXECUTED
2007574: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
2007578: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED
200757c: 11 00 80 c6 sethi %hi(0x2031800), %o0 <== NOT EXECUTED
2007580: 10 80 00 17 b 20075dc <rtems_fdisk_initialize+0x47c> <== NOT EXECUTED
2007584: 90 12 20 d8 or %o0, 0xd8, %o0 ! 20318d8 <__FUNCTION__.7063+0x10b8><== NOT EXECUTED
strerror (ret), ret);
return ret;
}
ret = rtems_fdisk_compact (fd);
2007588: 7f ff fa 02 call 2005d90 <rtems_fdisk_compact>
200758c: a0 04 20 74 add %l0, 0x74, %l0
if (ret)
2007590: 80 a2 20 00 cmp %o0, 0
2007594: 02 80 00 16 be 20075ec <rtems_fdisk_initialize+0x48c> <== ALWAYS TAKEN
2007598: b0 10 00 08 mov %o0, %i0
{
rtems_disk_delete (dev);
200759c: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
20075a0: 7f ff f4 4a call 20046c8 <rtems_disk_delete> <== NOT EXECUTED
20075a4: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
rtems_semaphore_delete (fd->lock);
20075a8: 40 00 15 69 call 200cb4c <rtems_semaphore_delete> <== NOT EXECUTED
20075ac: d0 07 60 64 ld [ %i5 + 0x64 ], %o0 <== NOT EXECUTED
free (fd->copy_buffer);
20075b0: 40 00 03 1e call 2008228 <free> <== NOT EXECUTED
20075b4: d0 07 60 68 ld [ %i5 + 0x68 ], %o0 <== NOT EXECUTED
free (fd->blocks);
20075b8: 40 00 03 1c call 2008228 <free> <== NOT EXECUTED
20075bc: d0 07 60 18 ld [ %i5 + 0x18 ], %o0 <== NOT EXECUTED
free (fd->devices);
20075c0: 40 00 03 1a call 2008228 <free> <== NOT EXECUTED
20075c4: d0 07 60 2c ld [ %i5 + 0x2c ], %o0 <== NOT EXECUTED
rtems_fdisk_error ("compacting of disk failed: %s (%d)",
20075c8: 40 00 6f 39 call 20232ac <strerror> <== NOT EXECUTED
20075cc: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
20075d0: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED
20075d4: 11 00 80 c6 sethi %hi(0x2031800), %o0 <== NOT EXECUTED
20075d8: 90 12 21 00 or %o0, 0x100, %o0 ! 2031900 <__FUNCTION__.7063+0x10e0><== NOT EXECUTED
20075dc: 7f ff f6 e4 call 200516c <rtems_fdisk_error> <== NOT EXECUTED
20075e0: 94 10 00 18 mov %i0, %o2 <== NOT EXECUTED
20075e4: 81 c7 e0 08 ret <== NOT EXECUTED
20075e8: 81 e8 00 00 restore <== NOT EXECUTED
sizeof (rtems_flashdisk));
if (!rtems_flashdisks)
return RTEMS_NO_MEMORY;
for (minor = 0; minor < rtems_flashdisk_configuration_size; minor++, c++)
20075ec: b6 06 e0 01 inc %i3
20075f0: 10 80 00 04 b 2007600 <rtems_fdisk_initialize+0x4a0>
20075f4: b8 07 20 20 add %i4, 0x20, %i4
/*
* One copy buffer of a page size.
*/
fd->copy_buffer = malloc (c->block_size);
if (!fd->copy_buffer)
return RTEMS_NO_MEMORY;
20075f8: 81 c7 e0 08 ret <== NOT EXECUTED
20075fc: 91 e8 20 1a restore %g0, 0x1a, %o0 <== NOT EXECUTED
sizeof (rtems_flashdisk));
if (!rtems_flashdisks)
return RTEMS_NO_MEMORY;
for (minor = 0; minor < rtems_flashdisk_configuration_size; minor++, c++)
2007600: 07 00 80 d7 sethi %hi(0x2035c00), %g3
2007604: c2 00 e3 08 ld [ %g3 + 0x308 ], %g1 ! 2035f08 <rtems_flashdisk_configuration_size>
2007608: 80 a6 c0 01 cmp %i3, %g1
200760c: 2a bf fe f7 bcs,a 20071e8 <rtems_fdisk_initialize+0x88>
2007610: ee 37 bf f8 sth %l7, [ %fp + -8 ]
strerror (ret), ret);
return ret;
}
}
rtems_flashdisk_count = rtems_flashdisk_configuration_size;
2007614: 05 00 81 19 sethi %hi(0x2046400), %g2
2007618: c2 20 a2 d4 st %g1, [ %g2 + 0x2d4 ] ! 20466d4 <rtems_flashdisk_count>
return RTEMS_SUCCESSFUL;
200761c: 81 c7 e0 08 ret
2007620: 91 e8 20 00 restore %g0, 0, %o0
sc = rtems_fdisk_crc16_gen_factors (0x8408);
if (sc != RTEMS_SUCCESSFUL)
return sc;
rtems_flashdisks = calloc (rtems_flashdisk_configuration_size,
2007624: d0 07 63 08 ld [ %i5 + 0x308 ], %o0
2007628: 92 10 20 74 mov 0x74, %o1
200762c: 40 00 01 fe call 2007e24 <calloc>
2007630: 2d 00 81 19 sethi %hi(0x2046400), %l6
sizeof (rtems_flashdisk));
if (!rtems_flashdisks)
2007634: 80 a2 20 00 cmp %o0, 0
2007638: 02 bf ff f0 be 20075f8 <rtems_fdisk_initialize+0x498> <== NEVER TAKEN
200763c: d0 25 a2 d0 st %o0, [ %l6 + 0x2d0 ]
2007640: 39 00 80 c0 sethi %hi(0x2030000), %i4
return RTEMS_NO_MEMORY;
for (minor = 0; minor < rtems_flashdisk_configuration_size; minor++, c++)
{
char name[] = RTEMS_FLASHDISK_DEVICE_BASE_NAME "a";
2007644: 2f 00 00 18 sethi %hi(0x6000), %l7
fd->devices = calloc (c->device_count, sizeof (rtems_fdisk_device_ctl));
if (!fd->devices)
return RTEMS_NO_MEMORY;
sc = rtems_semaphore_create (rtems_build_name ('F', 'D', 'S', 'K'), 1,
2007648: 2b 11 91 14 sethi %hi(0x46445000), %l5
return sc;
rtems_flashdisks = calloc (rtems_flashdisk_configuration_size,
sizeof (rtems_flashdisk));
if (!rtems_flashdisks)
200764c: a0 10 20 00 clr %l0
2007650: b8 17 23 f4 or %i4, 0x3f4, %i4
2007654: b6 10 20 00 clr %i3
return RTEMS_NO_MEMORY;
for (minor = 0; minor < rtems_flashdisk_configuration_size; minor++, c++)
{
char name[] = RTEMS_FLASHDISK_DEVICE_BASE_NAME "a";
2007658: ae 15 e1 00 or %l7, 0x100, %l7
fd->devices = calloc (c->device_count, sizeof (rtems_fdisk_device_ctl));
if (!fd->devices)
return RTEMS_NO_MEMORY;
sc = rtems_semaphore_create (rtems_build_name ('F', 'D', 'S', 'K'), 1,
200765c: aa 15 63 4b or %l5, 0x34b, %l5
return sc;
}
sc = rtems_disk_create_phys(dev, c->block_size,
blocks - fd->unavail_blocks,
rtems_fdisk_ioctl, NULL, name);
2007660: 10 bf ff e8 b 2007600 <rtems_fdisk_initialize+0x4a0>
2007664: a8 07 bf f0 add %fp, -16, %l4
}
rtems_flashdisk_count = rtems_flashdisk_configuration_size;
return RTEMS_SUCCESSFUL;
}
2007668: 81 c7 e0 08 ret <== NOT EXECUTED
200766c: 81 e8 00 00 restore <== NOT EXECUTED
02005fc8 <rtems_fdisk_ioctl>:
* @param argp IOCTL argument.
* @retval The IOCTL return value
*/
static int
rtems_fdisk_ioctl (rtems_disk_device *dd, uint32_t req, void* argp)
{
2005fc8: 9d e3 bf 38 save %sp, -200, %sp
dev_t dev = rtems_disk_get_device_identifier (dd);
rtems_device_minor_number minor = rtems_filesystem_dev_minor_t (dev);
rtems_blkdev_request* r = argp;
rtems_status_code sc;
errno = 0;
2005fcc: 40 00 6a fa call 2020bb4 <__errno>
2005fd0: f8 06 20 04 ld [ %i0 + 4 ], %i4
sc = rtems_semaphore_obtain (rtems_flashdisks[minor].lock, RTEMS_WAIT, 0);
2005fd4: 83 2f 20 02 sll %i4, 2, %g1
2005fd8: b7 2f 20 05 sll %i4, 5, %i3
2005fdc: 3b 00 81 19 sethi %hi(0x2046400), %i5
2005fe0: b6 26 c0 01 sub %i3, %g1, %i3
2005fe4: c2 07 62 d0 ld [ %i5 + 0x2d0 ], %g1
dev_t dev = rtems_disk_get_device_identifier (dd);
rtems_device_minor_number minor = rtems_filesystem_dev_minor_t (dev);
rtems_blkdev_request* r = argp;
rtems_status_code sc;
errno = 0;
2005fe8: c0 22 00 00 clr [ %o0 ]
sc = rtems_semaphore_obtain (rtems_flashdisks[minor].lock, RTEMS_WAIT, 0);
2005fec: b6 06 c0 1c add %i3, %i4, %i3
2005ff0: b7 2e e0 02 sll %i3, 2, %i3
2005ff4: 82 00 40 1b add %g1, %i3, %g1
2005ff8: d0 00 60 64 ld [ %g1 + 0x64 ], %o0
2005ffc: 92 10 20 00 clr %o1
2006000: 40 00 1b 02 call 200cc08 <rtems_semaphore_obtain>
2006004: 94 10 20 00 clr %o2
if (sc != RTEMS_SUCCESSFUL)
2006008: 80 a2 20 00 cmp %o0, 0
200600c: 12 80 04 44 bne 200711c <rtems_fdisk_ioctl+0x1154> <== NEVER TAKEN
2006010: 01 00 00 00 nop
errno = EIO;
else
{
errno = 0;
2006014: 40 00 6a e8 call 2020bb4 <__errno>
2006018: 01 00 00 00 nop
switch (req)
200601c: 03 08 00 10 sethi %hi(0x20004000), %g1
2006020: 84 10 62 83 or %g1, 0x283, %g2 ! 20004283 <RAM_END+0x1dc04283>
2006024: 80 a6 40 02 cmp %i1, %g2
2006028: 02 80 02 d1 be 2006b6c <rtems_fdisk_ioctl+0xba4> <== NEVER TAKEN
200602c: c0 22 00 00 clr [ %o0 ]
2006030: 80 a6 40 02 cmp %i1, %g2
2006034: 38 80 00 0c bgu,a 2006064 <rtems_fdisk_ioctl+0x9c>
2006038: 82 10 62 85 or %g1, 0x285, %g1
200603c: 84 10 62 81 or %g1, 0x281, %g2
2006040: 80 a6 40 02 cmp %i1, %g2
2006044: 02 80 02 ac be 2006af4 <rtems_fdisk_ioctl+0xb2c> <== NEVER TAKEN
2006048: 01 00 00 00 nop
200604c: 18 80 02 b2 bgu 2006b14 <rtems_fdisk_ioctl+0xb4c> <== NEVER TAKEN
2006050: 82 10 62 80 or %g1, 0x280, %g1
2006054: 80 a6 40 01 cmp %i1, %g1
2006058: 32 80 04 26 bne,a 20070f0 <rtems_fdisk_ioctl+0x1128> <== ALWAYS TAKEN
200605c: 90 10 00 18 mov %i0, %o0
2006060: 30 80 02 69 b,a 2006a04 <rtems_fdisk_ioctl+0xa3c> <== NOT EXECUTED
2006064: 80 a6 40 01 cmp %i1, %g1
2006068: 02 80 03 21 be 2006cec <rtems_fdisk_ioctl+0xd24>
200606c: 01 00 00 00 nop
2006070: 0a 80 03 1c bcs 2006ce0 <rtems_fdisk_ioctl+0xd18> <== NEVER TAKEN
2006074: c2 07 62 d0 ld [ %i5 + 0x2d0 ], %g1
2006078: 03 30 06 10 sethi %hi(0xc0184000), %g1
200607c: 82 10 62 01 or %g1, 0x201, %g1 ! c0184201 <RAM_END+0xbdd84201>
2006080: 80 a6 40 01 cmp %i1, %g1
2006084: 12 80 04 1b bne 20070f0 <rtems_fdisk_ioctl+0x1128>
2006088: 90 10 00 18 mov %i0, %o0
{
case RTEMS_BLKIO_REQUEST:
if ((minor >= rtems_flashdisk_count) ||
200608c: 03 00 81 19 sethi %hi(0x2046400), %g1
2006090: c2 00 62 d4 ld [ %g1 + 0x2d4 ], %g1 ! 20466d4 <rtems_flashdisk_count>
2006094: 80 a7 00 01 cmp %i4, %g1
2006098: 1a 80 00 08 bcc 20060b8 <rtems_fdisk_ioctl+0xf0> <== NEVER TAKEN
200609c: 01 00 00 00 nop
(rtems_flashdisks[minor].device_count == 0))
20060a0: c2 07 62 d0 ld [ %i5 + 0x2d0 ], %g1
20060a4: 82 00 40 1b add %g1, %i3, %g1
{
errno = 0;
switch (req)
{
case RTEMS_BLKIO_REQUEST:
if ((minor >= rtems_flashdisk_count) ||
20060a8: c2 00 60 30 ld [ %g1 + 0x30 ], %g1
20060ac: 80 a0 60 00 cmp %g1, 0
20060b0: 32 80 00 06 bne,a 20060c8 <rtems_fdisk_ioctl+0x100> <== ALWAYS TAKEN
20060b4: c2 06 80 00 ld [ %i2 ], %g1
(rtems_flashdisks[minor].device_count == 0))
{
errno = ENODEV;
20060b8: 40 00 6a bf call 2020bb4 <__errno> <== NOT EXECUTED
20060bc: 01 00 00 00 nop <== NOT EXECUTED
20060c0: 10 80 02 4f b 20069fc <rtems_fdisk_ioctl+0xa34> <== NOT EXECUTED
20060c4: 82 10 20 13 mov 0x13, %g1 ! 13 <PROM_START+0x13> <== NOT EXECUTED
}
else
{
switch (r->req)
20060c8: 80 a0 60 00 cmp %g1, 0
20060cc: 02 80 00 05 be 20060e0 <rtems_fdisk_ioctl+0x118>
20060d0: 80 a0 60 01 cmp %g1, 1
20060d4: 12 80 02 47 bne 20069f0 <rtems_fdisk_ioctl+0xa28> <== NEVER TAKEN
20060d8: 01 00 00 00 nop
20060dc: 30 80 00 b6 b,a 20063b4 <rtems_fdisk_ioctl+0x3ec>
{
case RTEMS_BLKDEV_REQ_READ:
errno = rtems_fdisk_read (&rtems_flashdisks[minor], r);
20060e0: 40 00 6a b5 call 2020bb4 <__errno>
20060e4: b0 06 a0 18 add %i2, 0x18, %i0
20060e8: f8 07 62 d0 ld [ %i5 + 0x2d0 ], %i4
20060ec: d0 27 bf ec st %o0, [ %fp + -20 ]
20060f0: b8 07 00 1b add %i4, %i3, %i4
{
rtems_blkdev_sg_buffer* sg = req->bufs;
uint32_t buf;
int ret = 0;
for (buf = 0; (ret == 0) && (buf < req->bufnum); buf++, sg++)
20060f4: 10 80 00 a2 b 200637c <rtems_fdisk_ioctl+0x3b4>
20060f8: a4 10 20 00 clr %l2
{
uint8_t* data;
uint32_t fb;
uint32_t b;
fb = sg->length / fd->block_size;
20060fc: d2 07 20 14 ld [ %i4 + 0x14 ], %o1
2006100: 7f ff f1 5f call 200267c <.udiv>
2006104: a2 10 20 00 clr %l1
sc = fd->blocks[block].segment;
pd = &sc->page_descriptors[bc->page];
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd,
2006108: 2d 00 80 c3 sethi %hi(0x2030c00), %l6
for (buf = 0; (ret == 0) && (buf < req->bufnum); buf++, sg++)
{
uint8_t* data;
uint32_t fb;
uint32_t b;
fb = sg->length / fd->block_size;
200610c: d0 27 bf e8 st %o0, [ %fp + -24 ]
data = sg->buffer;
2006110: e0 06 20 08 ld [ %i0 + 8 ], %l0
sc = fd->blocks[block].segment;
pd = &sc->page_descriptors[bc->page];
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd,
2006114: 10 80 00 91 b 2006358 <rtems_fdisk_ioctl+0x390>
2006118: 2f 00 80 c3 sethi %hi(0x2030c00), %l7
rtems_fdisk_block_ctl* bc;
rtems_fdisk_segment_ctl* sc;
rtems_fdisk_page_desc* pd;
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd, "read-block:%d", block);
200611c: 90 10 00 1c mov %i4, %o0
uint32_t b;
fb = sg->length / fd->block_size;
data = sg->buffer;
for (b = 0; b < fb; b++, data += fd->block_size)
{
ret = rtems_fdisk_read_block (fd, sg->block + b, data);
2006120: b2 04 40 19 add %l1, %i1, %i1
rtems_fdisk_block_ctl* bc;
rtems_fdisk_segment_ctl* sc;
rtems_fdisk_page_desc* pd;
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd, "read-block:%d", block);
2006124: 13 00 80 c4 sethi %hi(0x2031000), %o1
2006128: 94 10 00 19 mov %i1, %o2
200612c: 7f ff fb b0 call 2004fec <rtems_fdisk_info>
2006130: 92 12 62 88 or %o1, 0x288, %o1
/*
* Broken out to allow info messages when testing.
*/
if (block >= (fd->block_count - fd->unavail_blocks))
2006134: c4 07 20 1c ld [ %i4 + 0x1c ], %g2
2006138: c2 07 20 20 ld [ %i4 + 0x20 ], %g1
200613c: 82 20 80 01 sub %g2, %g1, %g1
2006140: 80 a6 40 01 cmp %i1, %g1
2006144: 2a 80 00 08 bcs,a 2006164 <rtems_fdisk_ioctl+0x19c> <== ALWAYS TAKEN
2006148: c6 07 20 18 ld [ %i4 + 0x18 ], %g3
{
rtems_fdisk_error ("read-block: block out of range: %d", block);
200614c: 11 00 80 c4 sethi %hi(0x2031000), %o0 <== NOT EXECUTED
2006150: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
2006154: 7f ff fc 06 call 200516c <rtems_fdisk_error> <== NOT EXECUTED
2006158: 90 12 22 98 or %o0, 0x298, %o0 <== NOT EXECUTED
uint8_t* data;
uint32_t fb;
uint32_t b;
fb = sg->length / fd->block_size;
data = sg->buffer;
for (b = 0; b < fb; b++, data += fd->block_size)
200615c: 10 80 00 84 b 200636c <rtems_fdisk_ioctl+0x3a4> <== NOT EXECUTED
2006160: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED
{
rtems_fdisk_error ("read-block: block out of range: %d", block);
return EIO;
}
bc = &fd->blocks[block];
2006164: 83 2e 60 03 sll %i1, 3, %g1
if (!bc->segment)
2006168: fa 00 c0 01 ld [ %g3 + %g1 ], %i5
200616c: 80 a7 60 00 cmp %i5, 0
2006170: 12 80 00 0d bne 20061a4 <rtems_fdisk_ioctl+0x1dc>
2006174: aa 00 c0 01 add %g3, %g1, %l5
{
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd, "read-block: no segment mapping: %d", block);
2006178: 94 10 00 19 mov %i1, %o2
200617c: 90 10 00 1c mov %i4, %o0
2006180: 13 00 80 c4 sethi %hi(0x2031000), %o1
2006184: 7f ff fb 9a call 2004fec <rtems_fdisk_info>
2006188: 92 12 62 c0 or %o1, 0x2c0, %o1 ! 20312c0 <__FUNCTION__.7063+0xaa0>
#endif
memset (buffer, 0xff, fd->block_size);
200618c: d4 07 20 14 ld [ %i4 + 0x14 ], %o2
2006190: 90 10 00 10 mov %l0, %o0
2006194: 40 00 6f 59 call 2021ef8 <memset>
2006198: 92 10 20 ff mov 0xff, %o1
uint8_t* data;
uint32_t fb;
uint32_t b;
fb = sg->length / fd->block_size;
data = sg->buffer;
for (b = 0; b < fb; b++, data += fd->block_size)
200619c: 10 80 03 ec b 200714c <rtems_fdisk_ioctl+0x1184>
20061a0: c2 07 20 14 ld [ %i4 + 0x14 ], %g1
memset (buffer, 0xff, fd->block_size);
return 0;
}
sc = fd->blocks[block].segment;
pd = &sc->page_descriptors[bc->page];
20061a4: da 05 60 04 ld [ %l5 + 4 ], %o5
20061a8: e8 07 60 10 ld [ %i5 + 0x10 ], %l4
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd,
20061ac: c8 07 40 00 ld [ %i5 ], %g4
memset (buffer, 0xff, fd->block_size);
return 0;
}
sc = fd->blocks[block].segment;
pd = &sc->page_descriptors[bc->page];
20061b0: a7 2b 60 03 sll %o5, 3, %l3
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd,
20061b4: d6 07 60 08 ld [ %i5 + 8 ], %o3
memset (buffer, 0xff, fd->block_size);
return 0;
}
sc = fd->blocks[block].segment;
pd = &sc->page_descriptors[bc->page];
20061b8: 86 05 00 13 add %l4, %l3, %g3
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd,
20061bc: d8 07 60 0c ld [ %i5 + 0xc ], %o4
20061c0: d0 07 60 14 ld [ %i5 + 0x14 ], %o0
20061c4: d2 07 60 1c ld [ %i5 + 0x1c ], %o1
20061c8: d4 07 60 20 ld [ %i5 + 0x20 ], %o2
20061cc: 80 a1 20 00 cmp %g4, 0
20061d0: 02 80 00 04 be 20061e0 <rtems_fdisk_ioctl+0x218>
20061d4: de 07 60 24 ld [ %i5 + 0x24 ], %o7
20061d8: 10 80 00 03 b 20061e4 <rtems_fdisk_ioctl+0x21c>
20061dc: 88 15 e2 20 or %l7, 0x220, %g4
20061e0: 88 15 a2 28 or %l6, 0x228, %g4
20061e4: d0 23 a0 5c st %o0, [ %sp + 0x5c ]
20061e8: d2 23 a0 60 st %o1, [ %sp + 0x60 ]
20061ec: d4 23 a0 64 st %o2, [ %sp + 0x64 ]
20061f0: de 23 a0 68 st %o7, [ %sp + 0x68 ]
20061f4: c8 23 a0 6c st %g4, [ %sp + 0x6c ]
20061f8: c8 10 e0 02 lduh [ %g3 + 2 ], %g4
20061fc: 90 10 00 1c mov %i4, %o0
2006200: c8 23 a0 70 st %g4, [ %sp + 0x70 ]
2006204: c8 15 00 13 lduh [ %l4 + %l3 ], %g4
2006208: 13 00 80 c4 sethi %hi(0x2031000), %o1
200620c: c8 23 a0 74 st %g4, [ %sp + 0x74 ]
2006210: c8 00 e0 04 ld [ %g3 + 4 ], %g4
2006214: 92 12 62 e8 or %o1, 0x2e8, %o1
2006218: c6 27 bf d4 st %g3, [ %fp + -44 ]
200621c: c8 23 a0 78 st %g4, [ %sp + 0x78 ]
2006220: 7f ff fb 73 call 2004fec <rtems_fdisk_info>
2006224: 94 10 00 19 mov %i1, %o2
* only set a flag by changing it from 1 to 0.
*/
static bool
rtems_fdisk_page_desc_flags_set (rtems_fdisk_page_desc* pd, uint16_t flags)
{
return (pd->flags & flags) == 0 ? true : false;
2006228: c6 07 bf d4 ld [ %fp + -44 ], %g3
200622c: c6 10 e0 02 lduh [ %g3 + 2 ], %g3
sc->pages, sc->pages_active, sc->pages_used, sc->pages_bad,
sc->next ? "set" : "null",
pd->flags, pd->crc, pd->block);
#endif
if (rtems_fdisk_page_desc_flags_set (pd, RTEMS_FDISK_PAGE_ACTIVE))
2006230: 80 88 e0 01 btst 1, %g3
2006234: 12 80 00 41 bne 2006338 <rtems_fdisk_ioctl+0x370> <== NEVER TAKEN
2006238: d8 05 60 04 ld [ %l5 + 4 ], %o4
{
if (rtems_fdisk_page_desc_flags_clear (pd, RTEMS_FDISK_PAGE_USED))
200623c: 80 88 e0 02 btst 2, %g3
2006240: 02 80 00 3c be 2006330 <rtems_fdisk_ioctl+0x368> <== NEVER TAKEN
2006244: 11 00 80 c4 sethi %hi(0x2031000), %o0
rtems_fdisk_segment_ctl* sc,
uint32_t page,
void* buffer)
{
return rtems_fdisk_seg_read (fd, sc,
page * fd->block_size, buffer, fd->block_size);
2006248: c6 07 20 14 ld [ %i4 + 0x14 ], %g3
/*
* We use the segment page offset not the page number used in the
* driver. This skips the page descriptors.
*/
int ret = rtems_fdisk_seg_read_page (fd, sc,
200624c: d0 07 60 18 ld [ %i5 + 0x18 ], %o0
rtems_fdisk_seg_read_page (const rtems_flashdisk* fd,
rtems_fdisk_segment_ctl* sc,
uint32_t page,
void* buffer)
{
return rtems_fdisk_seg_read (fd, sc,
2006250: 92 10 00 03 mov %g3, %o1
2006254: 90 02 00 0c add %o0, %o4, %o0
2006258: 7f ff f0 cf call 2002594 <.umul>
200625c: c6 27 bf d4 st %g3, [ %fp + -44 ]
2006260: c6 07 bf d4 ld [ %fp + -44 ], %g3
2006264: 94 10 00 08 mov %o0, %o2
2006268: 98 10 00 03 mov %g3, %o4
200626c: 90 10 00 1c mov %i4, %o0
2006270: 92 10 00 1d mov %i5, %o1
2006274: 7f ff fc 78 call 2005454 <rtems_fdisk_seg_read>
2006278: 96 10 00 10 mov %l0, %o3
* driver. This skips the page descriptors.
*/
int ret = rtems_fdisk_seg_read_page (fd, sc,
bc->page + sc->pages_desc, buffer);
if (ret)
200627c: 86 92 20 00 orcc %o0, 0, %g3
2006280: 22 80 00 13 be,a 20062cc <rtems_fdisk_ioctl+0x304> <== ALWAYS TAKEN
2006284: 03 00 81 19 sethi %hi(0x2046400), %g1
{
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd,
2006288: e0 07 60 08 ld [ %i5 + 8 ], %l0 <== NOT EXECUTED
200628c: f2 07 60 0c ld [ %i5 + 0xc ], %i1 <== NOT EXECUTED
2006290: fa 05 60 04 ld [ %l5 + 4 ], %i5 <== NOT EXECUTED
2006294: 40 00 74 06 call 20232ac <strerror> <== NOT EXECUTED
2006298: c6 27 bf d4 st %g3, [ %fp + -44 ] <== NOT EXECUTED
200629c: c6 07 bf d4 ld [ %fp + -44 ], %g3 <== NOT EXECUTED
20062a0: 9a 10 00 08 mov %o0, %o5 <== NOT EXECUTED
20062a4: c6 23 a0 5c st %g3, [ %sp + 0x5c ] <== NOT EXECUTED
20062a8: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
20062ac: 13 00 80 c4 sethi %hi(0x2031000), %o1 <== NOT EXECUTED
20062b0: 94 10 00 10 mov %l0, %o2 <== NOT EXECUTED
20062b4: 92 12 63 30 or %o1, 0x330, %o1 <== NOT EXECUTED
20062b8: 96 10 00 19 mov %i1, %o3 <== NOT EXECUTED
20062bc: 7f ff fb 4c call 2004fec <rtems_fdisk_info> <== NOT EXECUTED
20062c0: 98 10 00 1d mov %i5, %o4 <== NOT EXECUTED
uint8_t* data;
uint32_t fb;
uint32_t b;
fb = sg->length / fd->block_size;
data = sg->buffer;
for (b = 0; b < fb; b++, data += fd->block_size)
20062c4: 10 80 00 2a b 200636c <rtems_fdisk_ioctl+0x3a4> <== NOT EXECUTED
20062c8: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED
strerror (ret), ret);
#endif
return ret;
}
cs = rtems_fdisk_page_checksum (buffer, fd->block_size);
20062cc: c6 07 20 14 ld [ %i4 + 0x14 ], %g3
{
uint16_t cs = 0xffff;
uint32_t i;
for (i = 0; i < page_size; i++, buffer++)
cs = rtems_fdisk_calc_crc16 (cs, *buffer);
20062d0: c8 00 62 d8 ld [ %g1 + 0x2d8 ], %g4
rtems_fdisk_page_checksum (const uint8_t* buffer, uint32_t page_size)
{
uint16_t cs = 0xffff;
uint32_t i;
for (i = 0; i < page_size; i++, buffer++)
20062d4: 84 10 20 00 clr %g2
* Calculate the checksum of a page in a segment.
*/
static uint16_t
rtems_fdisk_page_checksum (const uint8_t* buffer, uint32_t page_size)
{
uint16_t cs = 0xffff;
20062d8: 10 80 00 09 b 20062fc <rtems_fdisk_ioctl+0x334>
20062dc: 94 10 3f ff mov -1, %o2
uint32_t i;
for (i = 0; i < page_size; i++, buffer++)
cs = rtems_fdisk_calc_crc16 (cs, *buffer);
20062e0: fa 0c 00 02 ldub [ %l0 + %g2 ], %i5
20062e4: 95 32 a0 10 srl %o2, 0x10, %o2
20062e8: 94 1f 40 0a xor %i5, %o2, %o2
20062ec: 94 0a a0 ff and %o2, 0xff, %o2
20062f0: 95 2a a0 01 sll %o2, 1, %o2
20062f4: d4 11 00 0a lduh [ %g4 + %o2 ], %o2
rtems_fdisk_page_checksum (const uint8_t* buffer, uint32_t page_size)
{
uint16_t cs = 0xffff;
uint32_t i;
for (i = 0; i < page_size; i++, buffer++)
20062f8: 84 00 a0 01 inc %g2
20062fc: 80 a0 80 03 cmp %g2, %g3
2006300: 12 bf ff f8 bne 20062e0 <rtems_fdisk_ioctl+0x318>
2006304: 95 2a a0 10 sll %o2, 0x10, %o2
return ret;
}
cs = rtems_fdisk_page_checksum (buffer, fd->block_size);
if (cs == pd->crc)
2006308: d6 15 00 13 lduh [ %l4 + %l3 ], %o3
200630c: 95 32 a0 10 srl %o2, 0x10, %o2
2006310: 80 a2 80 0b cmp %o2, %o3
2006314: 02 80 03 8d be 2007148 <rtems_fdisk_ioctl+0x1180> <== ALWAYS TAKEN
2006318: 11 00 80 c4 sethi %hi(0x2031000), %o0
return 0;
rtems_fdisk_error ("read-block: crc failure: %d: buffer:%04x page:%04x",
200631c: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
2006320: 7f ff fb 93 call 200516c <rtems_fdisk_error> <== NOT EXECUTED
2006324: 90 12 23 68 or %o0, 0x368, %o0 <== NOT EXECUTED
uint8_t* data;
uint32_t fb;
uint32_t b;
fb = sg->length / fd->block_size;
data = sg->buffer;
for (b = 0; b < fb; b++, data += fd->block_size)
2006328: 10 80 00 11 b 200636c <rtems_fdisk_ioctl+0x3a4> <== NOT EXECUTED
200632c: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED
rtems_fdisk_error ("read-block: crc failure: %d: buffer:%04x page:%04x",
block, cs, pd->crc);
}
else
{
rtems_fdisk_error ("read-block: block points to used page: %d: %d-%d-%d",
2006330: 10 80 00 04 b 2006340 <rtems_fdisk_ioctl+0x378> <== NOT EXECUTED
2006334: 90 12 23 a0 or %o0, 0x3a0, %o0 <== NOT EXECUTED
block, sc->device, sc->segment, bc->page);
}
}
else
{
rtems_fdisk_error ("read-block: block page not active: %d: %d-%d-%d",
2006338: 11 00 80 c4 sethi %hi(0x2031000), %o0 <== NOT EXECUTED
200633c: 90 12 23 d8 or %o0, 0x3d8, %o0 ! 20313d8 <__FUNCTION__.7063+0xbb8><== NOT EXECUTED
2006340: d4 07 60 08 ld [ %i5 + 8 ], %o2 <== NOT EXECUTED
2006344: d6 07 60 0c ld [ %i5 + 0xc ], %o3 <== NOT EXECUTED
2006348: 7f ff fb 89 call 200516c <rtems_fdisk_error> <== NOT EXECUTED
200634c: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
uint8_t* data;
uint32_t fb;
uint32_t b;
fb = sg->length / fd->block_size;
data = sg->buffer;
for (b = 0; b < fb; b++, data += fd->block_size)
2006350: 10 80 03 82 b 2007158 <rtems_fdisk_ioctl+0x1190> <== NOT EXECUTED
2006354: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED
2006358: c4 07 bf e8 ld [ %fp + -24 ], %g2
200635c: 80 a4 40 02 cmp %l1, %g2
2006360: 32 bf ff 6f bne,a 200611c <rtems_fdisk_ioctl+0x154>
2006364: f2 06 00 00 ld [ %i0 ], %i1
2006368: 82 10 20 00 clr %g1
{
rtems_blkdev_sg_buffer* sg = req->bufs;
uint32_t buf;
int ret = 0;
for (buf = 0; (ret == 0) && (buf < req->bufnum); buf++, sg++)
200636c: a4 04 a0 01 inc %l2
2006370: 80 a0 60 00 cmp %g1, 0
2006374: 12 80 00 08 bne 2006394 <rtems_fdisk_ioctl+0x3cc> <== NEVER TAKEN
2006378: b0 06 20 10 add %i0, 0x10, %i0
200637c: c2 06 a0 10 ld [ %i2 + 0x10 ], %g1
2006380: 80 a4 80 01 cmp %l2, %g1
2006384: 2a bf ff 5e bcs,a 20060fc <rtems_fdisk_ioctl+0x134>
2006388: d0 06 20 04 ld [ %i0 + 4 ], %o0
if (ret)
break;
}
}
req->status = ret ? RTEMS_IO_ERROR : RTEMS_SUCCESSFUL;
200638c: 10 80 00 03 b 2006398 <rtems_fdisk_ioctl+0x3d0>
2006390: 92 10 20 00 clr %o1
2006394: 92 10 20 1b mov 0x1b, %o1 <== NOT EXECUTED
req->req_done (req->done_arg, req->status);
2006398: c2 06 a0 04 ld [ %i2 + 4 ], %g1
200639c: d0 06 a0 08 ld [ %i2 + 8 ], %o0
20063a0: 9f c0 40 00 call %g1
20063a4: d2 26 a0 0c st %o1, [ %i2 + 0xc ]
else
{
switch (r->req)
{
case RTEMS_BLKDEV_REQ_READ:
errno = rtems_fdisk_read (&rtems_flashdisks[minor], r);
20063a8: c2 07 bf ec ld [ %fp + -20 ], %g1
break;
20063ac: 10 80 03 54 b 20070fc <rtems_fdisk_ioctl+0x1134>
20063b0: c0 20 40 00 clr [ %g1 ]
case RTEMS_BLKDEV_REQ_WRITE:
errno = rtems_fdisk_write (&rtems_flashdisks[minor], r);
20063b4: 40 00 6a 00 call 2020bb4 <__errno>
20063b8: a0 06 a0 18 add %i2, 0x18, %l0
20063bc: 03 00 81 19 sethi %hi(0x2046400), %g1
20063c0: fa 00 62 d0 ld [ %g1 + 0x2d0 ], %i5 ! 20466d0 <rtems_flashdisks>
20063c4: d0 27 bf e8 st %o0, [ %fp + -24 ]
20063c8: ba 07 40 1b add %i5, %i3, %i5
{
rtems_blkdev_sg_buffer* sg = req->bufs;
uint32_t buf;
int ret = 0;
for (buf = 0; (ret == 0) && (buf < req->bufnum); buf++, sg++)
20063cc: 10 80 01 7c b 20069bc <rtems_fdisk_ioctl+0x9f4>
20063d0: aa 10 20 00 clr %l5
{
uint8_t* data;
uint32_t fb;
uint32_t b;
fb = sg->length / fd->block_size;
20063d4: d2 07 60 14 ld [ %i5 + 0x14 ], %o1
20063d8: 7f ff f0 a9 call 200267c <.udiv>
20063dc: a4 10 20 00 clr %l2
data = sg->buffer;
20063e0: e2 04 20 08 ld [ %l0 + 8 ], %l1
for (buf = 0; (ret == 0) && (buf < req->bufnum); buf++, sg++)
{
uint8_t* data;
uint32_t fb;
uint32_t b;
fb = sg->length / fd->block_size;
20063e4: 10 80 01 6d b 2006998 <rtems_fdisk_ioctl+0x9d0>
20063e8: d0 27 bf e4 st %o0, [ %fp + -28 ]
rtems_fdisk_page_desc* pd;
uint32_t page;
int ret;
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd, "write-block:%d", block);
20063ec: 90 10 00 1d mov %i5, %o0
uint32_t b;
fb = sg->length / fd->block_size;
data = sg->buffer;
for (b = 0; b < fb; b++, data += fd->block_size)
{
ret = rtems_fdisk_write_block (fd, sg->block + b, data);
20063f0: b2 04 80 19 add %l2, %i1, %i1
rtems_fdisk_page_desc* pd;
uint32_t page;
int ret;
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd, "write-block:%d", block);
20063f4: 13 00 80 c5 sethi %hi(0x2031400), %o1
20063f8: 94 10 00 19 mov %i1, %o2
20063fc: 7f ff fa fc call 2004fec <rtems_fdisk_info>
2006400: 92 12 60 08 or %o1, 8, %o1
/*
* Broken out to allow info messages when testing.
*/
if (block >= (fd->block_count - fd->unavail_blocks))
2006404: c4 07 60 1c ld [ %i5 + 0x1c ], %g2
2006408: c2 07 60 20 ld [ %i5 + 0x20 ], %g1
200640c: 82 20 80 01 sub %g2, %g1, %g1
2006410: 80 a6 40 01 cmp %i1, %g1
2006414: 2a 80 00 08 bcs,a 2006434 <rtems_fdisk_ioctl+0x46c> <== ALWAYS TAKEN
2006418: ee 07 60 18 ld [ %i5 + 0x18 ], %l7
{
rtems_fdisk_error ("write-block: block out of range: %d", block);
200641c: 11 00 80 c5 sethi %hi(0x2031400), %o0 <== NOT EXECUTED
2006420: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
2006424: 7f ff fb 52 call 200516c <rtems_fdisk_error> <== NOT EXECUTED
2006428: 90 12 20 18 or %o0, 0x18, %o0 <== NOT EXECUTED
sc->device, sc->segment);
sc->failed = true;
rtems_fdisk_queue_segment (fd, sc);
return EIO;
200642c: 10 80 01 60 b 20069ac <rtems_fdisk_ioctl+0x9e4> <== NOT EXECUTED
2006430: b2 10 20 05 mov 5, %i1 <== NOT EXECUTED
{
rtems_fdisk_error ("write-block: block out of range: %d", block);
return EIO;
}
bc = &fd->blocks[block];
2006434: ad 2e 60 03 sll %i1, 3, %l6
/*
* Does the page exist in flash ?
*/
if (bc->segment)
2006438: f8 05 c0 16 ld [ %l7 + %l6 ], %i4
200643c: 80 a7 20 00 cmp %i4, 0
2006440: 02 80 00 97 be 200669c <rtems_fdisk_ioctl+0x6d4>
2006444: b0 05 c0 16 add %l7, %l6, %i0
{
sc = bc->segment;
pd = &sc->page_descriptors[bc->page];
2006448: c2 06 20 04 ld [ %i0 + 4 ], %g1
200644c: c4 07 20 10 ld [ %i4 + 0x10 ], %g2
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd, " write:%02d-%03d-%03d: flag used",
2006450: d4 07 20 08 ld [ %i4 + 8 ], %o2
2006454: d6 07 20 0c ld [ %i4 + 0xc ], %o3
2006458: 98 10 00 01 mov %g1, %o4
200645c: c2 27 bf dc st %g1, [ %fp + -36 ]
* Does the page exist in flash ?
*/
if (bc->segment)
{
sc = bc->segment;
pd = &sc->page_descriptors[bc->page];
2006460: c4 27 bf e0 st %g2, [ %fp + -32 ]
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd, " write:%02d-%03d-%03d: flag used",
2006464: 90 10 00 1d mov %i5, %o0
2006468: 13 00 80 c5 sethi %hi(0x2031400), %o1
200646c: 7f ff fa e0 call 2004fec <rtems_fdisk_info>
2006470: 92 12 60 40 or %o1, 0x40, %o1 ! 2031440 <__FUNCTION__.7063+0xc20>
uint32_t segment,
uint32_t page,
const void* buffer)
{
return rtems_fdisk_seg_verify (fd, device, segment,
page * fd->block_size, buffer, fd->block_size);
2006474: c4 07 60 14 ld [ %i5 + 0x14 ], %g2
#endif
/*
* The page exists in flash so see if the page has been changed.
*/
if (rtems_fdisk_seg_verify_page (fd, sc->device, sc->segment,
2006478: d0 07 20 18 ld [ %i4 + 0x18 ], %o0
uint32_t segment,
uint32_t page,
const void* buffer)
{
return rtems_fdisk_seg_verify (fd, device, segment,
page * fd->block_size, buffer, fd->block_size);
200647c: c4 27 bf ec st %g2, [ %fp + -20 ]
#endif
/*
* The page exists in flash so see if the page has been changed.
*/
if (rtems_fdisk_seg_verify_page (fd, sc->device, sc->segment,
2006480: c4 06 20 04 ld [ %i0 + 4 ], %g2
uint32_t device,
uint32_t segment,
uint32_t page,
const void* buffer)
{
return rtems_fdisk_seg_verify (fd, device, segment,
2006484: d2 07 bf ec ld [ %fp + -20 ], %o1
#endif
/*
* The page exists in flash so see if the page has been changed.
*/
if (rtems_fdisk_seg_verify_page (fd, sc->device, sc->segment,
2006488: e8 07 20 08 ld [ %i4 + 8 ], %l4
uint32_t device,
uint32_t segment,
uint32_t page,
const void* buffer)
{
return rtems_fdisk_seg_verify (fd, device, segment,
200648c: 7f ff f0 42 call 2002594 <.umul>
2006490: 90 02 00 02 add %o0, %g2, %o0
static const rtems_fdisk_segment_desc*
rtems_fdisk_seg_descriptor (const rtems_flashdisk* fd,
uint32_t device,
uint32_t segment)
{
return fd->devices[device].segments[segment].descriptor;
2006494: 89 2d 20 04 sll %l4, 4, %g4
2006498: 87 2d 20 02 sll %l4, 2, %g3
200649c: 86 21 00 03 sub %g4, %g3, %g3
20064a0: c8 07 60 2c ld [ %i5 + 0x2c ], %g4
#endif
/*
* The page exists in flash so see if the page has been changed.
*/
if (rtems_fdisk_seg_verify_page (fd, sc->device, sc->segment,
20064a4: e6 07 20 0c ld [ %i4 + 0xc ], %l3
static const rtems_fdisk_segment_desc*
rtems_fdisk_seg_descriptor (const rtems_flashdisk* fd,
uint32_t device,
uint32_t segment)
{
return fd->devices[device].segments[segment].descriptor;
20064a8: 9e 01 00 03 add %g4, %g3, %o7
20064ac: c8 01 00 03 ld [ %g4 + %g3 ], %g4
20064b0: 9b 2c e0 06 sll %l3, 6, %o5
20064b4: 87 2c e0 04 sll %l3, 4, %g3
20064b8: 86 23 40 03 sub %o5, %g3, %g3
20064bc: 86 01 00 03 add %g4, %g3, %g3
20064c0: c8 00 e0 04 ld [ %g3 + 4 ], %g4
uint32_t size)
{
const rtems_fdisk_segment_desc* sd;
const rtems_fdisk_driver_handlers* ops;
sd = rtems_fdisk_seg_descriptor (fd, device, segment);
ops = fd->devices[device].descriptor->flash_ops;
20064c4: c6 03 e0 08 ld [ %o7 + 8 ], %g3
#if RTEMS_FDISK_TRACE
rtems_fdisk_printf (fd, " seg-verify: %02d-%03d: o=%08x s=%d",
20064c8: da 07 bf ec ld [ %fp + -20 ], %o5
uint32_t size)
{
const rtems_fdisk_segment_desc* sd;
const rtems_fdisk_driver_handlers* ops;
sd = rtems_fdisk_seg_descriptor (fd, device, segment);
ops = fd->devices[device].descriptor->flash_ops;
20064cc: c6 00 e0 08 ld [ %g3 + 8 ], %g3
uint32_t device,
uint32_t segment,
uint32_t page,
const void* buffer)
{
return rtems_fdisk_seg_verify (fd, device, segment,
20064d0: 84 10 00 08 mov %o0, %g2
const rtems_fdisk_segment_desc* sd;
const rtems_fdisk_driver_handlers* ops;
sd = rtems_fdisk_seg_descriptor (fd, device, segment);
ops = fd->devices[device].descriptor->flash_ops;
#if RTEMS_FDISK_TRACE
rtems_fdisk_printf (fd, " seg-verify: %02d-%03d: o=%08x s=%d",
20064d4: 94 10 00 14 mov %l4, %o2
20064d8: 98 10 00 02 mov %g2, %o4
20064dc: c4 3f bf d0 std %g2, [ %fp + -48 ]
20064e0: 96 10 00 13 mov %l3, %o3
20064e4: c8 27 bf cc st %g4, [ %fp + -52 ]
20064e8: 90 10 00 1d mov %i5, %o0
20064ec: 13 00 80 c5 sethi %hi(0x2031400), %o1
20064f0: 7f ff fa df call 200506c <rtems_fdisk_printf>
20064f4: 92 12 60 68 or %o1, 0x68, %o1 ! 2031468 <__FUNCTION__.7063+0xc48>
device, segment, offset, size);
#endif
return ops->verify (sd, device, segment, offset, buffer, size);
20064f8: c6 07 bf d4 ld [ %fp + -44 ], %g3
20064fc: c8 07 bf cc ld [ %fp + -52 ], %g4
2006500: c4 07 bf d0 ld [ %fp + -48 ], %g2
2006504: c6 00 e0 0c ld [ %g3 + 0xc ], %g3
2006508: da 07 bf ec ld [ %fp + -20 ], %o5
200650c: 92 10 00 14 mov %l4, %o1
2006510: 90 10 00 04 mov %g4, %o0
2006514: 94 10 00 13 mov %l3, %o2
2006518: 96 10 00 02 mov %g2, %o3
200651c: 9f c0 c0 00 call %g3
2006520: 98 10 00 11 mov %l1, %o4
#endif
/*
* The page exists in flash so see if the page has been changed.
*/
if (rtems_fdisk_seg_verify_page (fd, sc->device, sc->segment,
2006524: c2 07 bf dc ld [ %fp + -36 ], %g1
2006528: 80 a2 20 00 cmp %o0, 0
200652c: 12 80 00 0c bne 200655c <rtems_fdisk_ioctl+0x594>
2006530: e8 06 20 04 ld [ %i0 + 4 ], %l4
bc->page + sc->pages_desc, buffer) == 0)
{
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd, "write-block:%d=>%02d-%03d-%03d: page verified",
2006534: d6 07 20 08 ld [ %i4 + 8 ], %o3
2006538: d8 07 20 0c ld [ %i4 + 0xc ], %o4
200653c: 90 10 00 1d mov %i5, %o0
2006540: 13 00 80 c5 sethi %hi(0x2031400), %o1
2006544: 94 10 00 19 mov %i1, %o2
2006548: 92 12 60 90 or %o1, 0x90, %o1
200654c: 7f ff fa a8 call 2004fec <rtems_fdisk_info>
2006550: 9a 10 00 14 mov %l4, %o5
uint8_t* data;
uint32_t fb;
uint32_t b;
fb = sg->length / fd->block_size;
data = sg->buffer;
for (b = 0; b < fb; b++, data += fd->block_size)
2006554: 10 80 01 0f b 2006990 <rtems_fdisk_ioctl+0x9c8>
2006558: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
* Does the page exist in flash ?
*/
if (bc->segment)
{
sc = bc->segment;
pd = &sc->page_descriptors[bc->page];
200655c: c4 07 bf e0 ld [ %fp + -32 ], %g2
2006560: 83 28 60 03 sll %g1, 3, %g1
2006564: 82 00 80 01 add %g2, %g1, %g1
* Set the flags. Setting means clear the bit to 0.
*/
static void
rtems_fdisk_page_desc_set_flags (rtems_fdisk_page_desc* pd, uint16_t flags)
{
pd->flags &= ~flags;
2006568: c4 10 60 02 lduh [ %g1 + 2 ], %g2
uint32_t page,
const rtems_fdisk_page_desc* page_desc)
{
uint32_t offset = ((page * sizeof (rtems_fdisk_page_desc)) +
((uint8_t*) &page_desc->flags) - ((uint8_t*) page_desc));
if ((fd->flags & RTEMS_FDISK_BLANK_CHECK_BEFORE_WRITE))
200656c: c6 07 60 08 ld [ %i5 + 8 ], %g3
* Set the flags. Setting means clear the bit to 0.
*/
static void
rtems_fdisk_page_desc_set_flags (rtems_fdisk_page_desc* pd, uint16_t flags)
{
pd->flags &= ~flags;
2006570: 84 08 bf fd and %g2, -3, %g2
2006574: c4 30 60 02 sth %g2, [ %g1 + 2 ]
uint32_t page,
const rtems_fdisk_page_desc* page_desc)
{
uint32_t offset = ((page * sizeof (rtems_fdisk_page_desc)) +
((uint8_t*) &page_desc->flags) - ((uint8_t*) page_desc));
if ((fd->flags & RTEMS_FDISK_BLANK_CHECK_BEFORE_WRITE))
2006578: 80 88 e0 08 btst 8, %g3
rtems_fdisk_seg_write_page_desc_flags (const rtems_flashdisk* fd,
rtems_fdisk_segment_ctl* sc,
uint32_t page,
const rtems_fdisk_page_desc* page_desc)
{
uint32_t offset = ((page * sizeof (rtems_fdisk_page_desc)) +
200657c: 85 2d 20 03 sll %l4, 3, %g2
((uint8_t*) &page_desc->flags) - ((uint8_t*) page_desc));
if ((fd->flags & RTEMS_FDISK_BLANK_CHECK_BEFORE_WRITE))
2006580: 02 80 00 20 be 2006600 <rtems_fdisk_ioctl+0x638> <== NEVER TAKEN
2006584: 84 00 a0 02 add %g2, 2, %g2
{
uint16_t flash_flags;
int ret;
ret = rtems_fdisk_seg_read (fd, sc, offset,
2006588: 94 10 00 02 mov %g2, %o2
200658c: c2 27 bf dc st %g1, [ %fp + -36 ]
2006590: c4 27 bf d0 st %g2, [ %fp + -48 ]
2006594: 90 10 00 1d mov %i5, %o0
2006598: 92 10 00 1c mov %i4, %o1
200659c: 96 07 bf f6 add %fp, -10, %o3
20065a0: 7f ff fb ad call 2005454 <rtems_fdisk_seg_read>
20065a4: 98 10 20 02 mov 2, %o4
&flash_flags, sizeof (flash_flags));
if (ret)
20065a8: c2 07 bf dc ld [ %fp + -36 ], %g1
20065ac: a6 92 20 00 orcc %o0, 0, %l3
20065b0: 12 80 00 1d bne 2006624 <rtems_fdisk_ioctl+0x65c> <== NEVER TAKEN
20065b4: c4 07 bf d0 ld [ %fp + -48 ], %g2
return ret;
if ((flash_flags & page_desc->flags) != page_desc->flags)
20065b8: c6 10 60 02 lduh [ %g1 + 2 ], %g3
20065bc: d8 17 bf f6 lduh [ %fp + -10 ], %o4
20065c0: 88 08 c0 0c and %g3, %o4, %g4
20065c4: 87 28 e0 10 sll %g3, 0x10, %g3
20065c8: 89 29 20 10 sll %g4, 0x10, %g4
20065cc: 80 a1 00 03 cmp %g4, %g3
20065d0: 02 80 00 0c be 2006600 <rtems_fdisk_ioctl+0x638> <== ALWAYS TAKEN
20065d4: 9b 30 e0 10 srl %g3, 0x10, %o5
{
rtems_fdisk_error (" seg-write-page-flags: %02d-%03d-%03d: "
20065d8: d2 07 20 08 ld [ %i4 + 8 ], %o1 <== NOT EXECUTED
20065dc: d4 07 20 0c ld [ %i4 + 0xc ], %o2 <== NOT EXECUTED
20065e0: 99 2b 20 10 sll %o4, 0x10, %o4 <== NOT EXECUTED
20065e4: 11 00 80 c5 sethi %hi(0x2031400), %o0 <== NOT EXECUTED
20065e8: 96 10 00 14 mov %l4, %o3 <== NOT EXECUTED
20065ec: 99 33 20 10 srl %o4, 0x10, %o4 <== NOT EXECUTED
20065f0: 7f ff fa df call 200516c <rtems_fdisk_error> <== NOT EXECUTED
20065f4: 90 12 20 c0 or %o0, 0xc0, %o0 <== NOT EXECUTED
strerror (ret), ret);
#endif
}
else
{
sc->pages_active--;
20065f8: 10 80 00 1b b 2006664 <rtems_fdisk_ioctl+0x69c> <== NOT EXECUTED
20065fc: c2 07 20 1c ld [ %i4 + 0x1c ], %g1 <== NOT EXECUTED
sc->device, sc->segment, page,
flash_flags, page_desc->flags);
return ret;
}
}
return rtems_fdisk_seg_write (fd, sc, offset,
2006600: 90 10 00 1d mov %i5, %o0
2006604: 92 10 00 1c mov %i4, %o1
2006608: 94 10 00 02 mov %g2, %o2
200660c: 96 00 60 02 add %g1, 2, %o3
2006610: 7f ff fb d4 call 2005560 <rtems_fdisk_seg_write>
2006614: 98 10 20 02 mov 2, %o4
rtems_fdisk_page_desc_set_flags (pd, RTEMS_FDISK_PAGE_USED);
ret = rtems_fdisk_seg_write_page_desc_flags (fd, sc, bc->page, pd);
if (ret)
2006618: a6 92 20 00 orcc %o0, 0, %l3
200661c: 22 80 00 12 be,a 2006664 <rtems_fdisk_ioctl+0x69c> <== ALWAYS TAKEN
2006620: c2 07 20 1c ld [ %i4 + 0x1c ], %g1
{
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd, " write:%02d-%03d-%03d: " \
2006624: d4 07 20 08 ld [ %i4 + 8 ], %o2 <== NOT EXECUTED
2006628: d6 07 20 0c ld [ %i4 + 0xc ], %o3 <== NOT EXECUTED
200662c: e8 06 20 04 ld [ %i0 + 4 ], %l4 <== NOT EXECUTED
2006630: 90 10 00 13 mov %l3, %o0 <== NOT EXECUTED
2006634: 40 00 73 1e call 20232ac <strerror> <== NOT EXECUTED
2006638: d4 3f bf c0 std %o2, [ %fp + -64 ] <== NOT EXECUTED
200663c: d4 1f bf c0 ldd [ %fp + -64 ], %o2 <== NOT EXECUTED
2006640: 9a 10 00 08 mov %o0, %o5 <== NOT EXECUTED
2006644: e6 23 a0 5c st %l3, [ %sp + 0x5c ] <== NOT EXECUTED
2006648: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
200664c: 13 00 80 c5 sethi %hi(0x2031400), %o1 <== NOT EXECUTED
2006650: 98 10 00 14 mov %l4, %o4 <== NOT EXECUTED
2006654: 7f ff fa 66 call 2004fec <rtems_fdisk_info> <== NOT EXECUTED
2006658: 92 12 61 10 or %o1, 0x110, %o1 <== NOT EXECUTED
/*
* If possible reuse this segment. This will mean the segment
* needs to be removed from the available list and placed
* back if space is still available.
*/
rtems_fdisk_queue_segment (fd, sc);
200665c: 10 80 00 08 b 200667c <rtems_fdisk_ioctl+0x6b4> <== NOT EXECUTED
2006660: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
strerror (ret), ret);
#endif
}
else
{
sc->pages_active--;
2006664: 82 00 7f ff add %g1, -1, %g1
2006668: c2 27 20 1c st %g1, [ %i4 + 0x1c ]
sc->pages_used++;
200666c: c2 07 20 20 ld [ %i4 + 0x20 ], %g1
2006670: 82 00 60 01 inc %g1
2006674: c2 27 20 20 st %g1, [ %i4 + 0x20 ]
/*
* If possible reuse this segment. This will mean the segment
* needs to be removed from the available list and placed
* back if space is still available.
*/
rtems_fdisk_queue_segment (fd, sc);
2006678: 90 10 00 1d mov %i5, %o0
200667c: 7f ff fb 19 call 20052e0 <rtems_fdisk_queue_segment>
2006680: 92 10 00 1c mov %i4, %o1
/*
* If no background compacting then compact in the forground.
* If we compact we ignore the error as there is little we
* can do from here. The write may will work.
*/
if ((fd->flags & RTEMS_FDISK_BACKGROUND_COMPACT) == 0)
2006684: c2 07 60 08 ld [ %i5 + 8 ], %g1
2006688: 80 88 60 02 btst 2, %g1
200668c: 12 80 00 05 bne 20066a0 <rtems_fdisk_ioctl+0x6d8> <== NEVER TAKEN
2006690: b8 07 60 34 add %i5, 0x34, %i4
rtems_fdisk_compact (fd);
2006694: 7f ff fd bf call 2005d90 <rtems_fdisk_compact>
2006698: 90 10 00 1d mov %i5, %o0
/*
* Is it time to compact the disk ?
*
* We override the background compaction configruation.
*/
if (rtems_fdisk_segment_count_queue (&fd->available) <=
200669c: b8 07 60 34 add %i5, 0x34, %i4
20066a0: 7f ff f9 f3 call 2004e6c <rtems_fdisk_segment_count_queue>
20066a4: 90 10 00 1c mov %i4, %o0
20066a8: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
20066ac: 80 a2 00 01 cmp %o0, %g1
20066b0: 18 80 00 04 bgu 20066c0 <rtems_fdisk_ioctl+0x6f8>
20066b4: 01 00 00 00 nop
fd->avail_compact_segs)
rtems_fdisk_compact (fd);
20066b8: 7f ff fd b6 call 2005d90 <rtems_fdisk_compact>
20066bc: 90 10 00 1d mov %i5, %o0
/*
* Get the next avaliable segment.
*/
sc = rtems_fdisk_segment_queue_pop_head (&fd->available);
20066c0: 7f ff f9 97 call 2004d1c <rtems_fdisk_segment_queue_pop_head>
20066c4: 90 10 00 1c mov %i4, %o0
/*
* Is the flash disk full ?
*/
if (!sc)
20066c8: a6 92 20 00 orcc %o0, 0, %l3
20066cc: 32 80 00 13 bne,a 2006718 <rtems_fdisk_ioctl+0x750> <== ALWAYS TAKEN
20066d0: c2 07 60 6c ld [ %i5 + 0x6c ], %g1
{
/*
* If compacting is configured for the background do it now
* to see if we can get some space back.
*/
if ((fd->flags & RTEMS_FDISK_BACKGROUND_COMPACT))
20066d4: c2 07 60 08 ld [ %i5 + 8 ], %g1 <== NOT EXECUTED
20066d8: 80 88 60 02 btst 2, %g1 <== NOT EXECUTED
20066dc: 02 80 00 04 be 20066ec <rtems_fdisk_ioctl+0x724> <== NOT EXECUTED
20066e0: 01 00 00 00 nop <== NOT EXECUTED
rtems_fdisk_compact (fd);
20066e4: 7f ff fd ab call 2005d90 <rtems_fdisk_compact> <== NOT EXECUTED
20066e8: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
/*
* Try again for some free space.
*/
sc = rtems_fdisk_segment_queue_pop_head (&fd->available);
20066ec: 7f ff f9 8c call 2004d1c <rtems_fdisk_segment_queue_pop_head><== NOT EXECUTED
20066f0: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
if (!sc)
20066f4: a6 92 20 00 orcc %o0, 0, %l3 <== NOT EXECUTED
20066f8: 32 80 00 08 bne,a 2006718 <rtems_fdisk_ioctl+0x750> <== NOT EXECUTED
20066fc: c2 07 60 6c ld [ %i5 + 0x6c ], %g1 <== NOT EXECUTED
{
rtems_fdisk_error ("write-block: no available pages");
2006700: 11 00 80 c5 sethi %hi(0x2031400), %o0 <== NOT EXECUTED
return ENOSPC;
2006704: b2 10 20 1c mov 0x1c, %i1 <== NOT EXECUTED
*/
sc = rtems_fdisk_segment_queue_pop_head (&fd->available);
if (!sc)
{
rtems_fdisk_error ("write-block: no available pages");
2006708: 7f ff fa 99 call 200516c <rtems_fdisk_error> <== NOT EXECUTED
200670c: 90 12 21 50 or %o0, 0x150, %o0 <== NOT EXECUTED
{
rtems_blkdev_sg_buffer* sg = req->bufs;
uint32_t buf;
int ret = 0;
for (buf = 0; (ret == 0) && (buf < req->bufnum); buf++, sg++)
2006710: 10 80 00 a8 b 20069b0 <rtems_fdisk_ioctl+0x9e8> <== NOT EXECUTED
2006714: aa 05 60 01 inc %l5 <== NOT EXECUTED
return ENOSPC;
}
}
#if RTEMS_FDISK_TRACE
if (fd->info_level >= 3)
2006718: 80 a0 60 02 cmp %g1, 2
200671c: 28 80 00 0f bleu,a 2006758 <rtems_fdisk_ioctl+0x790> <== ALWAYS TAKEN
2006720: c2 04 e0 10 ld [ %l3 + 0x10 ], %g1
{
char queues[5];
rtems_fdisk_queue_status (fd, sc, queues);
2006724: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
2006728: 92 10 00 13 mov %l3, %o1 <== NOT EXECUTED
200672c: 7f ff f9 e4 call 2004ebc <rtems_fdisk_queue_status> <== NOT EXECUTED
2006730: 94 07 bf f8 add %fp, -8, %o2 <== NOT EXECUTED
rtems_fdisk_info (fd, " write:%d=>%02d-%03d: queue check: %s",
2006734: d6 04 e0 08 ld [ %l3 + 8 ], %o3 <== NOT EXECUTED
2006738: d8 04 e0 0c ld [ %l3 + 0xc ], %o4 <== NOT EXECUTED
200673c: 13 00 80 c5 sethi %hi(0x2031400), %o1 <== NOT EXECUTED
2006740: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
2006744: 92 12 61 70 or %o1, 0x170, %o1 <== NOT EXECUTED
2006748: 94 10 00 19 mov %i1, %o2 <== NOT EXECUTED
200674c: 7f ff fa 28 call 2004fec <rtems_fdisk_info> <== NOT EXECUTED
2006750: 9a 07 bf f8 add %fp, -8, %o5 <== NOT EXECUTED
/*
* Find the next avaliable page in the segment.
*/
pd = sc->page_descriptors;
2006754: c2 04 e0 10 ld [ %l3 + 0x10 ], %g1 <== NOT EXECUTED
for (page = 0; page < sc->pages; page++, pd++)
2006758: c4 04 e0 14 ld [ %l3 + 0x14 ], %g2
200675c: 10 80 00 79 b 2006940 <rtems_fdisk_ioctl+0x978>
2006760: b8 10 20 00 clr %i4
{
if (rtems_fdisk_page_desc_erased (pd))
2006764: c2 27 bf dc st %g1, [ %fp + -36 ]
2006768: c4 27 bf d0 st %g2, [ %fp + -48 ]
200676c: 7f ff f9 fc call 2004f5c <rtems_fdisk_page_desc_erased>
2006770: 90 10 00 14 mov %l4, %o0
2006774: c2 07 bf dc ld [ %fp + -36 ], %g1
2006778: 80 8a 20 ff btst 0xff, %o0
200677c: 02 80 00 70 be 200693c <rtems_fdisk_ioctl+0x974>
2006780: c4 07 bf d0 ld [ %fp + -48 ], %g2
{
uint16_t cs = 0xffff;
uint32_t i;
for (i = 0; i < page_size; i++, buffer++)
cs = rtems_fdisk_calc_crc16 (cs, *buffer);
2006784: 03 00 81 19 sethi %hi(0x2046400), %g1
for (page = 0; page < sc->pages; page++, pd++)
{
if (rtems_fdisk_page_desc_erased (pd))
{
pd->crc = rtems_fdisk_page_checksum (buffer, fd->block_size);
2006788: c8 07 60 14 ld [ %i5 + 0x14 ], %g4
{
uint16_t cs = 0xffff;
uint32_t i;
for (i = 0; i < page_size; i++, buffer++)
cs = rtems_fdisk_calc_crc16 (cs, *buffer);
200678c: de 00 62 d8 ld [ %g1 + 0x2d8 ], %o7
rtems_fdisk_page_checksum (const uint8_t* buffer, uint32_t page_size)
{
uint16_t cs = 0xffff;
uint32_t i;
for (i = 0; i < page_size; i++, buffer++)
2006790: 86 10 20 00 clr %g3
* Calculate the checksum of a page in a segment.
*/
static uint16_t
rtems_fdisk_page_checksum (const uint8_t* buffer, uint32_t page_size)
{
uint16_t cs = 0xffff;
2006794: 10 80 00 07 b 20067b0 <rtems_fdisk_ioctl+0x7e8>
2006798: 82 10 3f ff mov -1, %g1
uint32_t i;
for (i = 0; i < page_size; i++, buffer++)
cs = rtems_fdisk_calc_crc16 (cs, *buffer);
200679c: 82 08 60 ff and %g1, 0xff, %g1
20067a0: 82 18 40 0d xor %g1, %o5, %g1
20067a4: 83 28 60 01 sll %g1, 1, %g1
20067a8: c2 13 c0 01 lduh [ %o7 + %g1 ], %g1
rtems_fdisk_page_checksum (const uint8_t* buffer, uint32_t page_size)
{
uint16_t cs = 0xffff;
uint32_t i;
for (i = 0; i < page_size; i++, buffer++)
20067ac: 86 00 e0 01 inc %g3
20067b0: 80 a0 c0 04 cmp %g3, %g4
20067b4: 32 bf ff fa bne,a 200679c <rtems_fdisk_ioctl+0x7d4>
20067b8: da 0c 40 03 ldub [ %l1 + %g3 ], %o5
for (page = 0; page < sc->pages; page++, pd++)
{
if (rtems_fdisk_page_desc_erased (pd))
{
pd->crc = rtems_fdisk_page_checksum (buffer, fd->block_size);
20067bc: c2 35 00 00 sth %g1, [ %l4 ]
pd->block = block;
20067c0: f2 25 20 04 st %i1, [ %l4 + 4 ]
* Set the flags. Setting means clear the bit to 0.
*/
static void
rtems_fdisk_page_desc_set_flags (rtems_fdisk_page_desc* pd, uint16_t flags)
{
pd->flags &= ~flags;
20067c4: c6 15 20 02 lduh [ %l4 + 2 ], %g3
if (rtems_fdisk_page_desc_erased (pd))
{
pd->crc = rtems_fdisk_page_checksum (buffer, fd->block_size);
pd->block = block;
bc->segment = sc;
20067c8: e6 25 c0 16 st %l3, [ %l7 + %l6 ]
bc->page = page;
20067cc: f8 26 20 04 st %i4, [ %i0 + 4 ]
rtems_fdisk_page_desc_set_flags (pd, RTEMS_FDISK_PAGE_ACTIVE);
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd, " write:%d=>%02d-%03d-%03d: write: " \
20067d0: c8 04 c0 00 ld [ %l3 ], %g4
* Set the flags. Setting means clear the bit to 0.
*/
static void
rtems_fdisk_page_desc_set_flags (rtems_fdisk_page_desc* pd, uint16_t flags)
{
pd->flags &= ~flags;
20067d4: 86 08 ff fe and %g3, -2, %g3
20067d8: c6 35 20 02 sth %g3, [ %l4 + 2 ]
bc->page = page;
rtems_fdisk_page_desc_set_flags (pd, RTEMS_FDISK_PAGE_ACTIVE);
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd, " write:%d=>%02d-%03d-%03d: write: " \
20067dc: d6 04 e0 08 ld [ %l3 + 8 ], %o3
20067e0: d8 04 e0 0c ld [ %l3 + 0xc ], %o4
20067e4: d4 04 e0 1c ld [ %l3 + 0x1c ], %o2
20067e8: da 04 e0 20 ld [ %l3 + 0x20 ], %o5
20067ec: 80 a1 20 00 cmp %g4, 0
20067f0: 02 80 00 05 be 2006804 <rtems_fdisk_ioctl+0x83c> <== ALWAYS TAKEN
20067f4: de 04 e0 24 ld [ %l3 + 0x24 ], %o7
20067f8: 09 00 80 c3 sethi %hi(0x2030c00), %g4 <== NOT EXECUTED
20067fc: 10 80 00 04 b 200680c <rtems_fdisk_ioctl+0x844> <== NOT EXECUTED
2006800: 88 11 22 20 or %g4, 0x220, %g4 ! 2030e20 <__FUNCTION__.7063+0x600><== NOT EXECUTED
2006804: 09 00 80 c3 sethi %hi(0x2030c00), %g4
2006808: 88 11 22 28 or %g4, 0x228, %g4 ! 2030e28 <__FUNCTION__.7063+0x608>
200680c: 87 28 e0 10 sll %g3, 0x10, %g3
2006810: 83 28 60 10 sll %g1, 0x10, %g1
2006814: 87 30 e0 10 srl %g3, 0x10, %g3
2006818: 83 30 60 10 srl %g1, 0x10, %g1
200681c: c4 23 a0 5c st %g2, [ %sp + 0x5c ]
2006820: d4 23 a0 60 st %o2, [ %sp + 0x60 ]
2006824: da 23 a0 64 st %o5, [ %sp + 0x64 ]
2006828: 94 10 00 19 mov %i1, %o2
200682c: de 23 a0 68 st %o7, [ %sp + 0x68 ]
2006830: c8 23 a0 6c st %g4, [ %sp + 0x6c ]
2006834: c6 23 a0 70 st %g3, [ %sp + 0x70 ]
2006838: c2 23 a0 74 st %g1, [ %sp + 0x74 ]
200683c: f2 23 a0 78 st %i1, [ %sp + 0x78 ]
2006840: 9a 10 00 1c mov %i4, %o5
2006844: 90 10 00 1d mov %i5, %o0
2006848: 13 00 80 c5 sethi %hi(0x2031400), %o1
200684c: 7f ff f9 e8 call 2004fec <rtems_fdisk_info>
2006850: 92 12 61 98 or %o1, 0x198, %o1 ! 2031598 <__FUNCTION__.7063+0xd78>
/*
* We use the segment page offset not the page number used in the
* driver. This skips the page descriptors.
*/
ret = rtems_fdisk_seg_write_page (fd, sc, page + sc->pages_desc, buffer);
2006854: d4 04 e0 18 ld [ %l3 + 0x18 ], %o2
2006858: 90 10 00 1d mov %i5, %o0
200685c: 92 10 00 13 mov %l3, %o1
2006860: 94 07 00 0a add %i4, %o2, %o2
2006864: 7f ff fc 4f call 20059a0 <rtems_fdisk_seg_write_page>
2006868: 96 10 00 11 mov %l1, %o3
if (ret)
200686c: b2 92 20 00 orcc %o0, 0, %i1
2006870: 22 80 00 0d be,a 20068a4 <rtems_fdisk_ioctl+0x8dc> <== ALWAYS TAKEN
2006874: 90 10 00 1d mov %i5, %o0
{
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd, "write-block:%02d-%03d-%03d: write page failed: " \
2006878: e8 04 e0 08 ld [ %l3 + 8 ], %l4 <== NOT EXECUTED
200687c: 40 00 72 8c call 20232ac <strerror> <== NOT EXECUTED
2006880: f0 04 e0 0c ld [ %l3 + 0xc ], %i0 <== NOT EXECUTED
2006884: 13 00 80 c5 sethi %hi(0x2031400), %o1 <== NOT EXECUTED
2006888: 9a 10 00 08 mov %o0, %o5 <== NOT EXECUTED
200688c: f2 23 a0 5c st %i1, [ %sp + 0x5c ] <== NOT EXECUTED
2006890: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
2006894: 92 12 61 e8 or %o1, 0x1e8, %o1 <== NOT EXECUTED
2006898: 94 10 00 14 mov %l4, %o2 <== NOT EXECUTED
200689c: 10 80 00 14 b 20068ec <rtems_fdisk_ioctl+0x924> <== NOT EXECUTED
20068a0: 96 10 00 18 mov %i0, %o3 <== NOT EXECUTED
strerror (ret), ret);
#endif
}
else
{
ret = rtems_fdisk_seg_write_page_desc (fd, sc, page, pd);
20068a4: 92 10 00 13 mov %l3, %o1
20068a8: 94 10 00 1c mov %i4, %o2
20068ac: 7f ff fb 53 call 20055f8 <rtems_fdisk_seg_write_page_desc>
20068b0: 96 10 00 14 mov %l4, %o3
if (ret)
20068b4: b2 92 20 00 orcc %o0, 0, %i1
20068b8: 22 80 00 11 be,a 20068fc <rtems_fdisk_ioctl+0x934> <== ALWAYS TAKEN
20068bc: c2 04 e0 1c ld [ %l3 + 0x1c ], %g1
{
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd, "write-block:%02d-%03d-%03d: " \
20068c0: ec 04 e0 08 ld [ %l3 + 8 ], %l6 <== NOT EXECUTED
20068c4: e8 04 e0 0c ld [ %l3 + 0xc ], %l4 <== NOT EXECUTED
20068c8: 40 00 72 79 call 20232ac <strerror> <== NOT EXECUTED
20068cc: f8 06 20 04 ld [ %i0 + 4 ], %i4 <== NOT EXECUTED
20068d0: 13 00 80 c5 sethi %hi(0x2031400), %o1 <== NOT EXECUTED
20068d4: 9a 10 00 08 mov %o0, %o5 <== NOT EXECUTED
20068d8: f2 23 a0 5c st %i1, [ %sp + 0x5c ] <== NOT EXECUTED
20068dc: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
20068e0: 92 12 62 20 or %o1, 0x220, %o1 <== NOT EXECUTED
20068e4: 94 10 00 16 mov %l6, %o2 <== NOT EXECUTED
20068e8: 96 10 00 14 mov %l4, %o3 <== NOT EXECUTED
20068ec: 7f ff f9 c0 call 2004fec <rtems_fdisk_info> <== NOT EXECUTED
20068f0: 98 10 00 1c mov %i4, %o4 <== NOT EXECUTED
{
sc->pages_active++;
}
}
rtems_fdisk_queue_segment (fd, sc);
20068f4: 10 80 00 05 b 2006908 <rtems_fdisk_ioctl+0x940> <== NOT EXECUTED
20068f8: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
strerror (ret), ret);
#endif
}
else
{
sc->pages_active++;
20068fc: 82 00 60 01 inc %g1
2006900: c2 24 e0 1c st %g1, [ %l3 + 0x1c ]
}
}
rtems_fdisk_queue_segment (fd, sc);
2006904: 90 10 00 1d mov %i5, %o0
2006908: 7f ff fa 76 call 20052e0 <rtems_fdisk_queue_segment>
200690c: 92 10 00 13 mov %l3, %o1
static bool
rtems_fdisk_is_erased_blocks_starvation (rtems_flashdisk* fd)
{
bool starvation = fd->erased_blocks < fd->starvation_threshold;
if (starvation)
2006910: c4 07 60 28 ld [ %i5 + 0x28 ], %g2
2006914: c2 07 60 24 ld [ %i5 + 0x24 ], %g1
2006918: 80 a0 80 01 cmp %g2, %g1
200691c: 1a 80 00 19 bcc 2006980 <rtems_fdisk_ioctl+0x9b8>
2006920: 90 10 00 1d mov %i5, %o0
fd->starvations++;
2006924: c2 07 60 70 ld [ %i5 + 0x70 ], %g1
2006928: 82 00 60 01 inc %g1
}
rtems_fdisk_queue_segment (fd, sc);
if (rtems_fdisk_is_erased_blocks_starvation (fd))
rtems_fdisk_compact (fd);
200692c: 7f ff fd 19 call 2005d90 <rtems_fdisk_compact>
2006930: c2 27 60 70 st %g1, [ %i5 + 0x70 ]
fb = sg->length / fd->block_size;
data = sg->buffer;
for (b = 0; b < fb; b++, data += fd->block_size)
{
ret = rtems_fdisk_write_block (fd, sg->block + b, data);
if (ret)
2006934: 10 80 00 14 b 2006984 <rtems_fdisk_ioctl+0x9bc>
2006938: 80 a6 60 00 cmp %i1, 0
* Find the next avaliable page in the segment.
*/
pd = sc->page_descriptors;
for (page = 0; page < sc->pages; page++, pd++)
200693c: b8 07 20 01 inc %i4
* @param req IOCTL request code.
* @param argp IOCTL argument.
* @retval The IOCTL return value
*/
static int
rtems_fdisk_ioctl (rtems_disk_device *dd, uint32_t req, void* argp)
2006940: a9 2f 20 03 sll %i4, 3, %l4
* Find the next avaliable page in the segment.
*/
pd = sc->page_descriptors;
for (page = 0; page < sc->pages; page++, pd++)
2006944: 80 a7 00 02 cmp %i4, %g2
2006948: 12 bf ff 87 bne 2006764 <rtems_fdisk_ioctl+0x79c> <== ALWAYS TAKEN
200694c: a8 00 40 14 add %g1, %l4, %l4
return ret;
}
}
rtems_fdisk_error ("write-block: no erased page descs in segment: %d-%d",
2006950: d2 04 e0 08 ld [ %l3 + 8 ], %o1 <== NOT EXECUTED
2006954: d4 04 e0 0c ld [ %l3 + 0xc ], %o2 <== NOT EXECUTED
2006958: 11 00 80 c5 sethi %hi(0x2031400), %o0 <== NOT EXECUTED
200695c: 7f ff fa 04 call 200516c <rtems_fdisk_error> <== NOT EXECUTED
2006960: 90 12 22 60 or %o0, 0x260, %o0 ! 2031660 <__FUNCTION__.7063+0xe40><== NOT EXECUTED
sc->device, sc->segment);
sc->failed = true;
2006964: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED
rtems_fdisk_queue_segment (fd, sc);
2006968: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
}
rtems_fdisk_error ("write-block: no erased page descs in segment: %d-%d",
sc->device, sc->segment);
sc->failed = true;
200696c: c2 24 e0 28 st %g1, [ %l3 + 0x28 ] <== NOT EXECUTED
rtems_fdisk_queue_segment (fd, sc);
2006970: 7f ff fa 5c call 20052e0 <rtems_fdisk_queue_segment> <== NOT EXECUTED
2006974: 92 10 00 13 mov %l3, %o1 <== NOT EXECUTED
return EIO;
2006978: 10 80 00 0d b 20069ac <rtems_fdisk_ioctl+0x9e4> <== NOT EXECUTED
200697c: b2 10 20 05 mov 5, %i1 <== NOT EXECUTED
fb = sg->length / fd->block_size;
data = sg->buffer;
for (b = 0; b < fb; b++, data += fd->block_size)
{
ret = rtems_fdisk_write_block (fd, sg->block + b, data);
if (ret)
2006980: 80 a6 60 00 cmp %i1, 0
2006984: 32 80 00 0b bne,a 20069b0 <rtems_fdisk_ioctl+0x9e8> <== NEVER TAKEN
2006988: aa 05 60 01 inc %l5 <== NOT EXECUTED
uint8_t* data;
uint32_t fb;
uint32_t b;
fb = sg->length / fd->block_size;
data = sg->buffer;
for (b = 0; b < fb; b++, data += fd->block_size)
200698c: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
2006990: a4 04 a0 01 inc %l2
2006994: a2 04 40 01 add %l1, %g1, %l1
2006998: c2 07 bf e4 ld [ %fp + -28 ], %g1
200699c: 80 a4 80 01 cmp %l2, %g1
20069a0: 32 bf fe 93 bne,a 20063ec <rtems_fdisk_ioctl+0x424>
20069a4: f2 04 00 00 ld [ %l0 ], %i1
20069a8: b2 10 20 00 clr %i1
{
rtems_blkdev_sg_buffer* sg = req->bufs;
uint32_t buf;
int ret = 0;
for (buf = 0; (ret == 0) && (buf < req->bufnum); buf++, sg++)
20069ac: aa 05 60 01 inc %l5
20069b0: 80 a6 60 00 cmp %i1, 0
20069b4: 12 80 00 08 bne 20069d4 <rtems_fdisk_ioctl+0xa0c> <== NEVER TAKEN
20069b8: a0 04 20 10 add %l0, 0x10, %l0
20069bc: c2 06 a0 10 ld [ %i2 + 0x10 ], %g1
20069c0: 80 a5 40 01 cmp %l5, %g1
20069c4: 2a bf fe 84 bcs,a 20063d4 <rtems_fdisk_ioctl+0x40c>
20069c8: d0 04 20 04 ld [ %l0 + 4 ], %o0
if (ret)
break;
}
}
req->status = ret ? RTEMS_IO_ERROR : RTEMS_SUCCESSFUL;
20069cc: 10 80 00 03 b 20069d8 <rtems_fdisk_ioctl+0xa10>
20069d0: 92 10 20 00 clr %o1
20069d4: 92 10 20 1b mov 0x1b, %o1 <== NOT EXECUTED
req->req_done (req->done_arg, req->status);
20069d8: c2 06 a0 04 ld [ %i2 + 4 ], %g1
20069dc: d0 06 a0 08 ld [ %i2 + 8 ], %o0
20069e0: 9f c0 40 00 call %g1
20069e4: d2 26 a0 0c st %o1, [ %i2 + 0xc ]
case RTEMS_BLKDEV_REQ_READ:
errno = rtems_fdisk_read (&rtems_flashdisks[minor], r);
break;
case RTEMS_BLKDEV_REQ_WRITE:
errno = rtems_fdisk_write (&rtems_flashdisks[minor], r);
20069e8: 10 80 01 c0 b 20070e8 <rtems_fdisk_ioctl+0x1120>
20069ec: c4 07 bf e8 ld [ %fp + -24 ], %g2
break;
default:
errno = EINVAL;
20069f0: 40 00 68 71 call 2020bb4 <__errno> <== NOT EXECUTED
20069f4: 01 00 00 00 nop <== NOT EXECUTED
20069f8: 82 10 20 16 mov 0x16, %g1 ! 16 <PROM_START+0x16> <== NOT EXECUTED
break;
20069fc: 10 80 01 c0 b 20070fc <rtems_fdisk_ioctl+0x1134> <== NOT EXECUTED
2006a00: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
}
}
break;
case RTEMS_FDISK_IOCTL_ERASE_DISK:
errno = rtems_fdisk_erase_disk (&rtems_flashdisks[minor]);
2006a04: 40 00 68 6c call 2020bb4 <__errno> <== NOT EXECUTED
2006a08: 21 00 80 c5 sethi %hi(0x2031400), %l0 <== NOT EXECUTED
2006a0c: fa 07 62 d0 ld [ %i5 + 0x2d0 ], %i5 <== NOT EXECUTED
2006a10: b2 10 00 08 mov %o0, %i1 <== NOT EXECUTED
2006a14: ba 07 40 1b add %i5, %i3, %i5 <== NOT EXECUTED
{
uint32_t device;
int ret;
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd, "erase-disk");
2006a18: 13 00 80 c5 sethi %hi(0x2031400), %o1 <== NOT EXECUTED
2006a1c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
2006a20: 92 12 62 98 or %o1, 0x298, %o1 <== NOT EXECUTED
2006a24: 7f ff f9 72 call 2004fec <rtems_fdisk_info> <== NOT EXECUTED
2006a28: 31 00 80 c5 sethi %hi(0x2031400), %i0 <== NOT EXECUTED
2006a2c: b4 10 20 00 clr %i2 <== NOT EXECUTED
*/
static int
rtems_fdisk_erase_flash (const rtems_flashdisk* fd)
{
uint32_t device;
for (device = 0; device < fd->device_count; device++)
2006a30: b8 10 20 00 clr %i4 <== NOT EXECUTED
{
int ret;
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd, " erase-flash:%02d", device);
2006a34: a0 14 22 a8 or %l0, 0x2a8, %l0 <== NOT EXECUTED
rtems_fdisk_device_erase (const rtems_flashdisk* fd, uint32_t device)
{
const rtems_fdisk_driver_handlers* ops;
ops = fd->devices[device].descriptor->flash_ops;
#if RTEMS_FDISK_TRACE
rtems_fdisk_printf (fd, " device-erase: %02d", device);
2006a38: 10 80 00 17 b 2006a94 <rtems_fdisk_ioctl+0xacc> <== NOT EXECUTED
2006a3c: b0 16 22 c0 or %i0, 0x2c0, %i0 <== NOT EXECUTED
for (device = 0; device < fd->device_count; device++)
{
int ret;
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd, " erase-flash:%02d", device);
2006a40: 94 10 00 1c mov %i4, %o2 <== NOT EXECUTED
2006a44: 7f ff f9 6a call 2004fec <rtems_fdisk_info> <== NOT EXECUTED
2006a48: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
*/
static int
rtems_fdisk_device_erase (const rtems_flashdisk* fd, uint32_t device)
{
const rtems_fdisk_driver_handlers* ops;
ops = fd->devices[device].descriptor->flash_ops;
2006a4c: c2 07 60 2c ld [ %i5 + 0x2c ], %g1 <== NOT EXECUTED
#if RTEMS_FDISK_TRACE
rtems_fdisk_printf (fd, " device-erase: %02d", device);
2006a50: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
*/
static int
rtems_fdisk_device_erase (const rtems_flashdisk* fd, uint32_t device)
{
const rtems_fdisk_driver_handlers* ops;
ops = fd->devices[device].descriptor->flash_ops;
2006a54: 82 00 40 1a add %g1, %i2, %g1 <== NOT EXECUTED
2006a58: c2 00 60 08 ld [ %g1 + 8 ], %g1 <== NOT EXECUTED
#if RTEMS_FDISK_TRACE
rtems_fdisk_printf (fd, " device-erase: %02d", device);
2006a5c: 94 10 00 1c mov %i4, %o2 <== NOT EXECUTED
*/
static int
rtems_fdisk_device_erase (const rtems_flashdisk* fd, uint32_t device)
{
const rtems_fdisk_driver_handlers* ops;
ops = fd->devices[device].descriptor->flash_ops;
2006a60: e2 00 60 08 ld [ %g1 + 8 ], %l1 <== NOT EXECUTED
#if RTEMS_FDISK_TRACE
rtems_fdisk_printf (fd, " device-erase: %02d", device);
2006a64: 7f ff f9 82 call 200506c <rtems_fdisk_printf> <== NOT EXECUTED
2006a68: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
#endif
return ops->erase_device (fd->devices[device].descriptor, device);
2006a6c: c4 07 60 2c ld [ %i5 + 0x2c ], %g2 <== NOT EXECUTED
2006a70: c2 04 60 14 ld [ %l1 + 0x14 ], %g1 <== NOT EXECUTED
2006a74: 84 00 80 1a add %g2, %i2, %g2 <== NOT EXECUTED
2006a78: d0 00 a0 08 ld [ %g2 + 8 ], %o0 <== NOT EXECUTED
2006a7c: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
2006a80: 9f c0 40 00 call %g1 <== NOT EXECUTED
2006a84: b4 06 a0 0c add %i2, 0xc, %i2 <== NOT EXECUTED
rtems_fdisk_info (fd, " erase-flash:%02d", device);
#endif
ret = rtems_fdisk_device_erase (fd, device);
if (ret != 0)
2006a88: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2006a8c: 12 80 00 18 bne 2006aec <rtems_fdisk_ioctl+0xb24> <== NOT EXECUTED
2006a90: b8 07 20 01 inc %i4 <== NOT EXECUTED
*/
static int
rtems_fdisk_erase_flash (const rtems_flashdisk* fd)
{
uint32_t device;
for (device = 0; device < fd->device_count; device++)
2006a94: c2 07 60 30 ld [ %i5 + 0x30 ], %g1 <== NOT EXECUTED
2006a98: 80 a7 00 01 cmp %i4, %g1 <== NOT EXECUTED
2006a9c: 0a bf ff e9 bcs 2006a40 <rtems_fdisk_ioctl+0xa78> <== NOT EXECUTED
2006aa0: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED
2006aa4: b4 10 20 00 clr %i2 <== NOT EXECUTED
2006aa8: 10 80 00 0d b 2006adc <rtems_fdisk_ioctl+0xb14> <== NOT EXECUTED
2006aac: b8 10 20 00 clr %i4 <== NOT EXECUTED
if (ret == 0)
{
for (device = 0; device < fd->device_count; device++)
{
if (!fd->devices[device].segments)
2006ab0: c2 00 40 1a ld [ %g1 + %i2 ], %g1 <== NOT EXECUTED
2006ab4: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
2006ab8: 02 80 00 0d be 2006aec <rtems_fdisk_ioctl+0xb24> <== NOT EXECUTED
2006abc: 90 10 20 0c mov 0xc, %o0 <== NOT EXECUTED
return ENOMEM;
ret = rtems_fdisk_recover_block_mappings (fd);
2006ac0: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
2006ac4: 7f ff fa de call 200563c <rtems_fdisk_recover_block_mappings><== NOT EXECUTED
2006ac8: b4 06 a0 0c add %i2, 0xc, %i2 <== NOT EXECUTED
if (ret)
2006acc: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2006ad0: 12 80 00 07 bne 2006aec <rtems_fdisk_ioctl+0xb24> <== NOT EXECUTED
2006ad4: b8 07 20 01 inc %i4 <== NOT EXECUTED
ret = rtems_fdisk_erase_flash (fd);
if (ret == 0)
{
for (device = 0; device < fd->device_count; device++)
2006ad8: c2 07 60 30 ld [ %i5 + 0x30 ], %g1 <== NOT EXECUTED
2006adc: 80 a7 00 01 cmp %i4, %g1 <== NOT EXECUTED
2006ae0: 2a bf ff f4 bcs,a 2006ab0 <rtems_fdisk_ioctl+0xae8> <== NOT EXECUTED
2006ae4: c2 07 60 2c ld [ %i5 + 0x2c ], %g1 <== NOT EXECUTED
2006ae8: 90 10 20 00 clr %o0 <== NOT EXECUTED
}
break;
case RTEMS_FDISK_IOCTL_ERASE_DISK:
errno = rtems_fdisk_erase_disk (&rtems_flashdisks[minor]);
break;
2006aec: 10 80 01 84 b 20070fc <rtems_fdisk_ioctl+0x1134> <== NOT EXECUTED
2006af0: d0 26 40 00 st %o0, [ %i1 ] <== NOT EXECUTED
case RTEMS_FDISK_IOCTL_COMPACT:
errno = rtems_fdisk_compact (&rtems_flashdisks[minor]);
2006af4: 40 00 68 30 call 2020bb4 <__errno> <== NOT EXECUTED
2006af8: 01 00 00 00 nop <== NOT EXECUTED
2006afc: b8 10 00 08 mov %o0, %i4 <== NOT EXECUTED
2006b00: d0 07 62 d0 ld [ %i5 + 0x2d0 ], %o0 <== NOT EXECUTED
2006b04: 7f ff fc a3 call 2005d90 <rtems_fdisk_compact> <== NOT EXECUTED
2006b08: 90 02 00 1b add %o0, %i3, %o0 <== NOT EXECUTED
break;
2006b0c: 10 80 01 7c b 20070fc <rtems_fdisk_ioctl+0x1134> <== NOT EXECUTED
2006b10: d0 27 00 00 st %o0, [ %i4 ] <== NOT EXECUTED
case RTEMS_FDISK_IOCTL_ERASE_USED:
errno = rtems_fdisk_erase_used (&rtems_flashdisks[minor]);
2006b14: 40 00 68 28 call 2020bb4 <__errno> <== NOT EXECUTED
2006b18: 01 00 00 00 nop <== NOT EXECUTED
2006b1c: f8 07 62 d0 ld [ %i5 + 0x2d0 ], %i4 <== NOT EXECUTED
2006b20: b4 10 00 08 mov %o0, %i2 <== NOT EXECUTED
2006b24: b8 07 00 1b add %i4, %i3, %i4 <== NOT EXECUTED
*/
static int
rtems_fdisk_erase_used (rtems_flashdisk* fd)
{
rtems_fdisk_segment_ctl* sc;
int latched_ret = 0;
2006b28: ba 10 20 00 clr %i5 <== NOT EXECUTED
while ((sc = rtems_fdisk_segment_queue_pop_head (&fd->erase)))
2006b2c: 10 80 00 09 b 2006b50 <rtems_fdisk_ioctl+0xb88> <== NOT EXECUTED
2006b30: b2 07 20 4c add %i4, 0x4c, %i1 <== NOT EXECUTED
{
/*
* The segment will either end up on the available queue or
* the failed queue.
*/
int ret = rtems_fdisk_erase_segment (fd, sc);
2006b34: 7f ff f9 ab call 20051e0 <rtems_fdisk_erase_segment> <== NOT EXECUTED
2006b38: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
if (ret && !latched_ret)
2006b3c: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2006b40: 02 80 00 04 be 2006b50 <rtems_fdisk_ioctl+0xb88> <== NOT EXECUTED
2006b44: 80 a7 60 00 cmp %i5, 0 <== NOT EXECUTED
2006b48: 22 80 00 02 be,a 2006b50 <rtems_fdisk_ioctl+0xb88> <== NOT EXECUTED
2006b4c: ba 10 00 08 mov %o0, %i5 <== NOT EXECUTED
rtems_fdisk_erase_used (rtems_flashdisk* fd)
{
rtems_fdisk_segment_ctl* sc;
int latched_ret = 0;
while ((sc = rtems_fdisk_segment_queue_pop_head (&fd->erase)))
2006b50: 7f ff f8 73 call 2004d1c <rtems_fdisk_segment_queue_pop_head><== NOT EXECUTED
2006b54: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
2006b58: 92 92 20 00 orcc %o0, 0, %o1 <== NOT EXECUTED
2006b5c: 12 bf ff f6 bne 2006b34 <rtems_fdisk_ioctl+0xb6c> <== NOT EXECUTED
2006b60: 01 00 00 00 nop <== NOT EXECUTED
errno = rtems_fdisk_compact (&rtems_flashdisks[minor]);
break;
case RTEMS_FDISK_IOCTL_ERASE_USED:
errno = rtems_fdisk_erase_used (&rtems_flashdisks[minor]);
break;
2006b64: 10 80 01 66 b 20070fc <rtems_fdisk_ioctl+0x1134> <== NOT EXECUTED
2006b68: fa 26 80 00 st %i5, [ %i2 ] <== NOT EXECUTED
case RTEMS_FDISK_IOCTL_MONITORING:
errno = rtems_fdisk_monitoring_data (&rtems_flashdisks[minor],
2006b6c: 40 00 68 12 call 2020bb4 <__errno> <== NOT EXECUTED
2006b70: 01 00 00 00 nop <== NOT EXECUTED
2006b74: fa 07 62 d0 ld [ %i5 + 0x2d0 ], %i5 <== NOT EXECUTED
2006b78: a0 10 00 08 mov %o0, %l0 <== NOT EXECUTED
2006b7c: ba 07 40 1b add %i5, %i3, %i5 <== NOT EXECUTED
rtems_fdisk_monitor_data* data)
{
uint32_t i;
uint32_t j;
data->block_size = fd->block_size;
2006b80: c2 07 60 14 ld [ %i5 + 0x14 ], %g1 <== NOT EXECUTED
data->block_count = fd->block_count;
2006b84: c4 07 60 1c ld [ %i5 + 0x1c ], %g2 <== NOT EXECUTED
data->unavail_blocks = fd->unavail_blocks;
data->device_count = fd->device_count;
2006b88: f2 07 60 30 ld [ %i5 + 0x30 ], %i1 <== NOT EXECUTED
rtems_fdisk_monitor_data* data)
{
uint32_t i;
uint32_t j;
data->block_size = fd->block_size;
2006b8c: c2 26 80 00 st %g1, [ %i2 ] <== NOT EXECUTED
data->block_count = fd->block_count;
data->unavail_blocks = fd->unavail_blocks;
2006b90: c2 07 60 20 ld [ %i5 + 0x20 ], %g1 <== NOT EXECUTED
{
uint32_t i;
uint32_t j;
data->block_size = fd->block_size;
data->block_count = fd->block_count;
2006b94: c4 26 a0 04 st %g2, [ %i2 + 4 ] <== NOT EXECUTED
data->unavail_blocks = fd->unavail_blocks;
2006b98: c2 26 a0 08 st %g1, [ %i2 + 8 ] <== NOT EXECUTED
data->device_count = fd->device_count;
2006b9c: f2 26 a0 0c st %i1, [ %i2 + 0xc ] <== NOT EXECUTED
data->blocks_used = 0;
2006ba0: c0 26 a0 18 clr [ %i2 + 0x18 ] <== NOT EXECUTED
for (i = 0; i < fd->block_count; i++)
2006ba4: 10 80 00 0a b 2006bcc <rtems_fdisk_ioctl+0xc04> <== NOT EXECUTED
2006ba8: 82 10 20 00 clr %g1 <== NOT EXECUTED
if (fd->blocks[i].segment)
2006bac: 87 28 60 03 sll %g1, 3, %g3 <== NOT EXECUTED
2006bb0: c6 01 00 03 ld [ %g4 + %g3 ], %g3 <== NOT EXECUTED
2006bb4: 80 a0 e0 00 cmp %g3, 0 <== NOT EXECUTED
2006bb8: 02 80 00 05 be 2006bcc <rtems_fdisk_ioctl+0xc04> <== NOT EXECUTED
2006bbc: 82 00 60 01 inc %g1 <== NOT EXECUTED
data->blocks_used++;
2006bc0: c6 06 a0 18 ld [ %i2 + 0x18 ], %g3 <== NOT EXECUTED
2006bc4: 86 00 e0 01 inc %g3 <== NOT EXECUTED
2006bc8: c6 26 a0 18 st %g3, [ %i2 + 0x18 ] <== NOT EXECUTED
data->block_count = fd->block_count;
data->unavail_blocks = fd->unavail_blocks;
data->device_count = fd->device_count;
data->blocks_used = 0;
for (i = 0; i < fd->block_count; i++)
2006bcc: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED
2006bd0: 32 bf ff f7 bne,a 2006bac <rtems_fdisk_ioctl+0xbe4> <== NOT EXECUTED
2006bd4: c8 07 60 18 ld [ %i5 + 0x18 ], %g4 <== NOT EXECUTED
if (fd->blocks[i].segment)
data->blocks_used++;
data->segs_available = rtems_fdisk_segment_count_queue (&fd->available);
2006bd8: 7f ff f8 a5 call 2004e6c <rtems_fdisk_segment_count_queue><== NOT EXECUTED
2006bdc: 90 07 60 34 add %i5, 0x34, %o0 <== NOT EXECUTED
2006be0: d0 26 a0 1c st %o0, [ %i2 + 0x1c ] <== NOT EXECUTED
data->segs_used = rtems_fdisk_segment_count_queue (&fd->used);
2006be4: 7f ff f8 a2 call 2004e6c <rtems_fdisk_segment_count_queue><== NOT EXECUTED
2006be8: 90 07 60 40 add %i5, 0x40, %o0 <== NOT EXECUTED
2006bec: d0 26 a0 20 st %o0, [ %i2 + 0x20 ] <== NOT EXECUTED
data->segs_failed = rtems_fdisk_segment_count_queue (&fd->failed);
2006bf0: 7f ff f8 9f call 2004e6c <rtems_fdisk_segment_count_queue><== NOT EXECUTED
2006bf4: 90 07 60 58 add %i5, 0x58, %o0 <== NOT EXECUTED
data->page_count = 0;
data->pages_desc = 0;
data->pages_active = 0;
data->pages_used = 0;
data->pages_bad = 0;
data->seg_erases = 0;
2006bf8: 86 10 20 00 clr %g3 <== NOT EXECUTED
if (fd->blocks[i].segment)
data->blocks_used++;
data->segs_available = rtems_fdisk_segment_count_queue (&fd->available);
data->segs_used = rtems_fdisk_segment_count_queue (&fd->used);
data->segs_failed = rtems_fdisk_segment_count_queue (&fd->failed);
2006bfc: d0 26 a0 24 st %o0, [ %i2 + 0x24 ] <== NOT EXECUTED
data->segment_count = 0;
2006c00: c0 26 a0 10 clr [ %i2 + 0x10 ] <== NOT EXECUTED
data->page_count = 0;
2006c04: c0 26 a0 14 clr [ %i2 + 0x14 ] <== NOT EXECUTED
data->pages_desc = 0;
2006c08: c0 26 a0 2c clr [ %i2 + 0x2c ] <== NOT EXECUTED
data->pages_active = 0;
2006c0c: c0 26 a0 30 clr [ %i2 + 0x30 ] <== NOT EXECUTED
data->pages_used = 0;
2006c10: c0 26 a0 34 clr [ %i2 + 0x34 ] <== NOT EXECUTED
data->pages_bad = 0;
2006c14: c0 26 a0 38 clr [ %i2 + 0x38 ] <== NOT EXECUTED
data->seg_erases = 0;
2006c18: c0 26 a0 28 clr [ %i2 + 0x28 ] <== NOT EXECUTED
for (i = 0; i < fd->device_count; i++)
2006c1c: 10 80 00 2a b 2006cc4 <rtems_fdisk_ioctl+0xcfc> <== NOT EXECUTED
2006c20: 84 10 20 00 clr %g2 <== NOT EXECUTED
{
data->segment_count += fd->devices[i].segment_count;
2006c24: c2 06 a0 10 ld [ %i2 + 0x10 ], %g1 <== NOT EXECUTED
2006c28: 9e 03 c0 03 add %o7, %g3, %o7 <== NOT EXECUTED
2006c2c: f0 03 e0 04 ld [ %o7 + 4 ], %i0 <== NOT EXECUTED
2006c30: b8 10 20 00 clr %i4 <== NOT EXECUTED
2006c34: 82 00 40 18 add %g1, %i0, %g1 <== NOT EXECUTED
for (j = 0; j < fd->devices[i].segment_count; j++)
2006c38: 88 10 20 00 clr %g4 <== NOT EXECUTED
data->pages_bad = 0;
data->seg_erases = 0;
for (i = 0; i < fd->device_count; i++)
{
data->segment_count += fd->devices[i].segment_count;
2006c3c: 10 80 00 1d b 2006cb0 <rtems_fdisk_ioctl+0xce8> <== NOT EXECUTED
2006c40: c2 26 a0 10 st %g1, [ %i2 + 0x10 ] <== NOT EXECUTED
for (j = 0; j < fd->devices[i].segment_count; j++)
{
rtems_fdisk_segment_ctl* sc = &fd->devices[i].segments[j];
data->page_count += sc->pages;
2006c44: d8 06 a0 14 ld [ %i2 + 0x14 ], %o4 <== NOT EXECUTED
{
data->segment_count += fd->devices[i].segment_count;
for (j = 0; j < fd->devices[i].segment_count; j++)
{
rtems_fdisk_segment_ctl* sc = &fd->devices[i].segments[j];
2006c48: 82 00 40 1c add %g1, %i4, %g1 <== NOT EXECUTED
data->page_count += sc->pages;
2006c4c: da 00 60 14 ld [ %g1 + 0x14 ], %o5 <== NOT EXECUTED
for (i = 0; i < fd->device_count; i++)
{
data->segment_count += fd->devices[i].segment_count;
for (j = 0; j < fd->devices[i].segment_count; j++)
2006c50: 88 01 20 01 inc %g4 <== NOT EXECUTED
{
rtems_fdisk_segment_ctl* sc = &fd->devices[i].segments[j];
data->page_count += sc->pages;
2006c54: 9a 03 00 0d add %o4, %o5, %o5 <== NOT EXECUTED
data->pages_desc += sc->pages_desc;
2006c58: d8 06 a0 2c ld [ %i2 + 0x2c ], %o4 <== NOT EXECUTED
for (j = 0; j < fd->devices[i].segment_count; j++)
{
rtems_fdisk_segment_ctl* sc = &fd->devices[i].segments[j];
data->page_count += sc->pages;
2006c5c: da 26 a0 14 st %o5, [ %i2 + 0x14 ] <== NOT EXECUTED
data->pages_desc += sc->pages_desc;
2006c60: da 00 60 18 ld [ %g1 + 0x18 ], %o5 <== NOT EXECUTED
2006c64: b8 07 20 30 add %i4, 0x30, %i4 <== NOT EXECUTED
2006c68: 9a 03 00 0d add %o4, %o5, %o5 <== NOT EXECUTED
data->pages_active += sc->pages_active;
2006c6c: d8 06 a0 30 ld [ %i2 + 0x30 ], %o4 <== NOT EXECUTED
for (j = 0; j < fd->devices[i].segment_count; j++)
{
rtems_fdisk_segment_ctl* sc = &fd->devices[i].segments[j];
data->page_count += sc->pages;
data->pages_desc += sc->pages_desc;
2006c70: da 26 a0 2c st %o5, [ %i2 + 0x2c ] <== NOT EXECUTED
data->pages_active += sc->pages_active;
2006c74: da 00 60 1c ld [ %g1 + 0x1c ], %o5 <== NOT EXECUTED
2006c78: 9a 03 00 0d add %o4, %o5, %o5 <== NOT EXECUTED
data->pages_used += sc->pages_used;
2006c7c: d8 06 a0 34 ld [ %i2 + 0x34 ], %o4 <== NOT EXECUTED
{
rtems_fdisk_segment_ctl* sc = &fd->devices[i].segments[j];
data->page_count += sc->pages;
data->pages_desc += sc->pages_desc;
data->pages_active += sc->pages_active;
2006c80: da 26 a0 30 st %o5, [ %i2 + 0x30 ] <== NOT EXECUTED
data->pages_used += sc->pages_used;
2006c84: da 00 60 20 ld [ %g1 + 0x20 ], %o5 <== NOT EXECUTED
2006c88: 9a 03 00 0d add %o4, %o5, %o5 <== NOT EXECUTED
data->pages_bad += sc->pages_bad;
2006c8c: d8 06 a0 38 ld [ %i2 + 0x38 ], %o4 <== NOT EXECUTED
rtems_fdisk_segment_ctl* sc = &fd->devices[i].segments[j];
data->page_count += sc->pages;
data->pages_desc += sc->pages_desc;
data->pages_active += sc->pages_active;
data->pages_used += sc->pages_used;
2006c90: da 26 a0 34 st %o5, [ %i2 + 0x34 ] <== NOT EXECUTED
data->pages_bad += sc->pages_bad;
2006c94: da 00 60 24 ld [ %g1 + 0x24 ], %o5 <== NOT EXECUTED
data->seg_erases += sc->erased;
2006c98: c2 00 60 2c ld [ %g1 + 0x2c ], %g1 <== NOT EXECUTED
data->page_count += sc->pages;
data->pages_desc += sc->pages_desc;
data->pages_active += sc->pages_active;
data->pages_used += sc->pages_used;
data->pages_bad += sc->pages_bad;
2006c9c: 9a 03 00 0d add %o4, %o5, %o5 <== NOT EXECUTED
2006ca0: da 26 a0 38 st %o5, [ %i2 + 0x38 ] <== NOT EXECUTED
data->seg_erases += sc->erased;
2006ca4: da 06 a0 28 ld [ %i2 + 0x28 ], %o5 <== NOT EXECUTED
2006ca8: 82 03 40 01 add %o5, %g1, %g1 <== NOT EXECUTED
2006cac: c2 26 a0 28 st %g1, [ %i2 + 0x28 ] <== NOT EXECUTED
for (i = 0; i < fd->device_count; i++)
{
data->segment_count += fd->devices[i].segment_count;
for (j = 0; j < fd->devices[i].segment_count; j++)
2006cb0: 80 a1 00 18 cmp %g4, %i0 <== NOT EXECUTED
2006cb4: 32 bf ff e4 bne,a 2006c44 <rtems_fdisk_ioctl+0xc7c> <== NOT EXECUTED
2006cb8: c2 03 c0 00 ld [ %o7 ], %g1 <== NOT EXECUTED
data->pages_active = 0;
data->pages_used = 0;
data->pages_bad = 0;
data->seg_erases = 0;
for (i = 0; i < fd->device_count; i++)
2006cbc: 84 00 a0 01 inc %g2 <== NOT EXECUTED
2006cc0: 86 00 e0 0c add %g3, 0xc, %g3 <== NOT EXECUTED
2006cc4: 80 a0 80 19 cmp %g2, %i1 <== NOT EXECUTED
2006cc8: 32 bf ff d7 bne,a 2006c24 <rtems_fdisk_ioctl+0xc5c> <== NOT EXECUTED
2006ccc: de 07 60 2c ld [ %i5 + 0x2c ], %o7 <== NOT EXECUTED
data->pages_bad += sc->pages_bad;
data->seg_erases += sc->erased;
}
}
data->info_level = fd->info_level;
2006cd0: c2 07 60 6c ld [ %i5 + 0x6c ], %g1 <== NOT EXECUTED
2006cd4: c2 26 a0 3c st %g1, [ %i2 + 0x3c ] <== NOT EXECUTED
break;
case RTEMS_FDISK_IOCTL_MONITORING:
errno = rtems_fdisk_monitoring_data (&rtems_flashdisks[minor],
(rtems_fdisk_monitor_data*) argp);
break;
2006cd8: 10 80 01 09 b 20070fc <rtems_fdisk_ioctl+0x1134> <== NOT EXECUTED
2006cdc: c0 24 00 00 clr [ %l0 ] <== NOT EXECUTED
case RTEMS_FDISK_IOCTL_INFO_LEVEL:
rtems_flashdisks[minor].info_level = (uintptr_t) argp;
2006ce0: 82 00 40 1b add %g1, %i3, %g1 <== NOT EXECUTED
break;
2006ce4: 10 80 01 06 b 20070fc <rtems_fdisk_ioctl+0x1134> <== NOT EXECUTED
2006ce8: f4 20 60 6c st %i2, [ %g1 + 0x6c ] <== NOT EXECUTED
case RTEMS_FDISK_IOCTL_PRINT_STATUS:
errno = rtems_fdisk_print_status (&rtems_flashdisks[minor]);
2006cec: 40 00 67 b2 call 2020bb4 <__errno>
2006cf0: 01 00 00 00 nop
2006cf4: c2 07 62 d0 ld [ %i5 + 0x2d0 ], %g1
2006cf8: d0 27 bf ec st %o0, [ %fp + -20 ]
2006cfc: ba 00 40 1b add %g1, %i3, %i5
*/
static int
rtems_fdisk_print_status (rtems_flashdisk* fd)
{
#if RTEMS_FDISK_TRACE
uint32_t current_info_level = fd->info_level;
2006d00: c4 07 60 6c ld [ %i5 + 0x6c ], %g2
uint32_t count;
uint32_t device;
fd->info_level = 3;
rtems_fdisk_printf (fd,
2006d04: d4 00 40 1b ld [ %g1 + %i3 ], %o2
2006d08: d6 07 60 04 ld [ %i5 + 4 ], %o3
*/
static int
rtems_fdisk_print_status (rtems_flashdisk* fd)
{
#if RTEMS_FDISK_TRACE
uint32_t current_info_level = fd->info_level;
2006d0c: c4 27 bf e8 st %g2, [ %fp + -24 ]
uint32_t total;
uint32_t count;
uint32_t device;
fd->info_level = 3;
2006d10: 84 10 20 03 mov 3, %g2
rtems_fdisk_printf (fd,
2006d14: 90 10 00 1d mov %i5, %o0
uint32_t current_info_level = fd->info_level;
uint32_t total;
uint32_t count;
uint32_t device;
fd->info_level = 3;
2006d18: c4 27 60 6c st %g2, [ %i5 + 0x6c ]
rtems_fdisk_printf (fd,
2006d1c: 13 00 80 c5 sethi %hi(0x2031400), %o1
2006d20: 7f ff f8 d3 call 200506c <rtems_fdisk_printf>
2006d24: 92 12 62 d8 or %o1, 0x2d8, %o1 ! 20316d8 <__FUNCTION__.7063+0xeb8>
"Flash Disk Driver Status : %d.%d", fd->major, fd->minor);
rtems_fdisk_printf (fd, "Block count\t%d", fd->block_count);
2006d28: d4 07 60 1c ld [ %i5 + 0x1c ], %o2
2006d2c: 90 10 00 1d mov %i5, %o0
2006d30: 13 00 80 c5 sethi %hi(0x2031400), %o1
2006d34: 7f ff f8 ce call 200506c <rtems_fdisk_printf>
2006d38: 92 12 63 00 or %o1, 0x300, %o1 ! 2031700 <__FUNCTION__.7063+0xee0>
rtems_fdisk_printf (fd, "Unavail blocks\t%d", fd->unavail_blocks);
2006d3c: d4 07 60 20 ld [ %i5 + 0x20 ], %o2
2006d40: 90 10 00 1d mov %i5, %o0
2006d44: 13 00 80 c5 sethi %hi(0x2031400), %o1
2006d48: 7f ff f8 c9 call 200506c <rtems_fdisk_printf>
2006d4c: 92 12 63 10 or %o1, 0x310, %o1 ! 2031710 <__FUNCTION__.7063+0xef0>
rtems_fdisk_printf (fd, "Starvation threshold\t%d", fd->starvation_threshold);
2006d50: d4 07 60 24 ld [ %i5 + 0x24 ], %o2
2006d54: 90 10 00 1d mov %i5, %o0
2006d58: 13 00 80 c5 sethi %hi(0x2031400), %o1
2006d5c: 7f ff f8 c4 call 200506c <rtems_fdisk_printf>
2006d60: 92 12 63 28 or %o1, 0x328, %o1 ! 2031728 <__FUNCTION__.7063+0xf08>
rtems_fdisk_printf (fd, "Starvations\t%d", fd->starvations);
2006d64: d4 07 60 70 ld [ %i5 + 0x70 ], %o2
2006d68: 90 10 00 1d mov %i5, %o0
2006d6c: 13 00 80 c5 sethi %hi(0x2031400), %o1
2006d70: 7f ff f8 bf call 200506c <rtems_fdisk_printf>
2006d74: 92 12 63 40 or %o1, 0x340, %o1 ! 2031740 <__FUNCTION__.7063+0xf20>
count = rtems_fdisk_segment_count_queue (&fd->available);
2006d78: 7f ff f8 3d call 2004e6c <rtems_fdisk_segment_count_queue>
2006d7c: 90 07 60 34 add %i5, 0x34, %o0
total = count;
rtems_fdisk_printf (fd, "Available queue\t%ld (%ld)",
2006d80: d6 07 60 3c ld [ %i5 + 0x3c ], %o3
rtems_fdisk_printf (fd, "Block count\t%d", fd->block_count);
rtems_fdisk_printf (fd, "Unavail blocks\t%d", fd->unavail_blocks);
rtems_fdisk_printf (fd, "Starvation threshold\t%d", fd->starvation_threshold);
rtems_fdisk_printf (fd, "Starvations\t%d", fd->starvations);
count = rtems_fdisk_segment_count_queue (&fd->available);
2006d84: b8 10 00 08 mov %o0, %i4
total = count;
rtems_fdisk_printf (fd, "Available queue\t%ld (%ld)",
2006d88: 13 00 80 c5 sethi %hi(0x2031400), %o1
2006d8c: 94 10 00 1c mov %i4, %o2
2006d90: 92 12 63 50 or %o1, 0x350, %o1
2006d94: 7f ff f8 b6 call 200506c <rtems_fdisk_printf>
2006d98: 90 10 00 1d mov %i5, %o0
count, rtems_fdisk_segment_queue_count (&fd->available));
count = rtems_fdisk_segment_count_queue (&fd->used);
2006d9c: 7f ff f8 34 call 2004e6c <rtems_fdisk_segment_count_queue>
2006da0: 90 07 60 40 add %i5, 0x40, %o0
total += count;
rtems_fdisk_printf (fd, "Used queue\t%ld (%ld)",
2006da4: d6 07 60 48 ld [ %i5 + 0x48 ], %o3
rtems_fdisk_printf (fd, "Starvations\t%d", fd->starvations);
count = rtems_fdisk_segment_count_queue (&fd->available);
total = count;
rtems_fdisk_printf (fd, "Available queue\t%ld (%ld)",
count, rtems_fdisk_segment_queue_count (&fd->available));
count = rtems_fdisk_segment_count_queue (&fd->used);
2006da8: 94 10 00 08 mov %o0, %o2
total += count;
2006dac: b8 02 00 1c add %o0, %i4, %i4
rtems_fdisk_printf (fd, "Used queue\t%ld (%ld)",
2006db0: 13 00 80 c5 sethi %hi(0x2031400), %o1
2006db4: 90 10 00 1d mov %i5, %o0
2006db8: 7f ff f8 ad call 200506c <rtems_fdisk_printf>
2006dbc: 92 12 63 70 or %o1, 0x370, %o1
count, rtems_fdisk_segment_queue_count (&fd->used));
count = rtems_fdisk_segment_count_queue (&fd->erase);
2006dc0: 7f ff f8 2b call 2004e6c <rtems_fdisk_segment_count_queue>
2006dc4: 90 07 60 4c add %i5, 0x4c, %o0
total += count;
rtems_fdisk_printf (fd, "Erase queue\t%ld (%ld)",
2006dc8: d6 07 60 54 ld [ %i5 + 0x54 ], %o3
count, rtems_fdisk_segment_queue_count (&fd->available));
count = rtems_fdisk_segment_count_queue (&fd->used);
total += count;
rtems_fdisk_printf (fd, "Used queue\t%ld (%ld)",
count, rtems_fdisk_segment_queue_count (&fd->used));
count = rtems_fdisk_segment_count_queue (&fd->erase);
2006dcc: 94 10 00 08 mov %o0, %o2
total += count;
2006dd0: b8 07 00 08 add %i4, %o0, %i4
rtems_fdisk_printf (fd, "Erase queue\t%ld (%ld)",
2006dd4: 13 00 80 c5 sethi %hi(0x2031400), %o1
2006dd8: 90 10 00 1d mov %i5, %o0
2006ddc: 7f ff f8 a4 call 200506c <rtems_fdisk_printf>
2006de0: 92 12 63 88 or %o1, 0x388, %o1
count, rtems_fdisk_segment_queue_count (&fd->erase));
count = rtems_fdisk_segment_count_queue (&fd->failed);
2006de4: 7f ff f8 22 call 2004e6c <rtems_fdisk_segment_count_queue>
2006de8: 90 07 60 58 add %i5, 0x58, %o0
total += count;
rtems_fdisk_printf (fd, "Failed queue\t%ld (%ld)",
2006dec: d6 07 60 60 ld [ %i5 + 0x60 ], %o3
count, rtems_fdisk_segment_queue_count (&fd->used));
count = rtems_fdisk_segment_count_queue (&fd->erase);
total += count;
rtems_fdisk_printf (fd, "Erase queue\t%ld (%ld)",
count, rtems_fdisk_segment_queue_count (&fd->erase));
count = rtems_fdisk_segment_count_queue (&fd->failed);
2006df0: 94 10 00 08 mov %o0, %o2
total += count;
2006df4: b8 07 00 08 add %i4, %o0, %i4
rtems_fdisk_printf (fd, "Failed queue\t%ld (%ld)",
2006df8: 13 00 80 c5 sethi %hi(0x2031400), %o1
2006dfc: 90 10 00 1d mov %i5, %o0
2006e00: 7f ff f8 9b call 200506c <rtems_fdisk_printf>
2006e04: 92 12 63 a0 or %o1, 0x3a0, %o1
count, rtems_fdisk_segment_queue_count (&fd->failed));
count = 0;
for (device = 0; device < fd->device_count; device++)
2006e08: c6 07 60 30 ld [ %i5 + 0x30 ], %g3
2006e0c: 84 10 20 00 clr %g2
2006e10: 82 10 20 00 clr %g1
count = rtems_fdisk_segment_count_queue (&fd->failed);
total += count;
rtems_fdisk_printf (fd, "Failed queue\t%ld (%ld)",
count, rtems_fdisk_segment_queue_count (&fd->failed));
count = 0;
2006e14: 10 80 00 07 b 2006e30 <rtems_fdisk_ioctl+0xe68>
2006e18: 96 10 20 00 clr %o3
for (device = 0; device < fd->device_count; device++)
2006e1c: 82 00 60 01 inc %g1
count += fd->devices[device].segment_count;
2006e20: 88 01 00 02 add %g4, %g2, %g4
2006e24: c8 01 20 04 ld [ %g4 + 4 ], %g4
2006e28: 84 00 a0 0c add %g2, 0xc, %g2
2006e2c: 96 02 c0 04 add %o3, %g4, %o3
total += count;
rtems_fdisk_printf (fd, "Failed queue\t%ld (%ld)",
count, rtems_fdisk_segment_queue_count (&fd->failed));
count = 0;
for (device = 0; device < fd->device_count; device++)
2006e30: 80 a0 40 03 cmp %g1, %g3
2006e34: 32 bf ff fa bne,a 2006e1c <rtems_fdisk_ioctl+0xe54>
2006e38: c8 07 60 2c ld [ %i5 + 0x2c ], %g4
count += fd->devices[device].segment_count;
rtems_fdisk_printf (fd, "Queue total\t%ld of %ld, %s", total, count,
2006e3c: 19 00 80 c4 sethi %hi(0x2031000), %o4
2006e40: 80 a7 00 0b cmp %i4, %o3
2006e44: 12 80 00 04 bne 2006e54 <rtems_fdisk_ioctl+0xe8c> <== NEVER TAKEN
2006e48: 98 13 22 80 or %o4, 0x280, %o4
2006e4c: 19 00 80 c4 sethi %hi(0x2031000), %o4
2006e50: 98 13 22 78 or %o4, 0x278, %o4 ! 2031278 <__FUNCTION__.7063+0xa58>
2006e54: 94 10 00 1c mov %i4, %o2
2006e58: 90 10 00 1d mov %i5, %o0
2006e5c: 13 00 80 c5 sethi %hi(0x2031400), %o1
2006e60: 7f ff f8 83 call 200506c <rtems_fdisk_printf>
2006e64: 92 12 63 b8 or %o1, 0x3b8, %o1 ! 20317b8 <__FUNCTION__.7063+0xf98>
total == count ? "ok" : "MISSING");
rtems_fdisk_printf (fd, "Device count\t%d", fd->device_count);
2006e68: d4 07 60 30 ld [ %i5 + 0x30 ], %o2
2006e6c: 90 10 00 1d mov %i5, %o0
2006e70: 13 00 80 c5 sethi %hi(0x2031400), %o1
for (block = 0; block < fd->block_count; block++)
{
if ((fd->blocks[block].segment == sc) &&
(fd->blocks[block].page == page) && !is_active)
rtems_fdisk_printf (fd,
2006e74: 2d 00 80 c6 sethi %hi(0x2031800), %l6
count += fd->devices[device].segment_count;
rtems_fdisk_printf (fd, "Queue total\t%ld of %ld, %s", total, count,
total == count ? "ok" : "MISSING");
rtems_fdisk_printf (fd, "Device count\t%d", fd->device_count);
2006e78: 92 12 63 d8 or %o1, 0x3d8, %o1
2006e7c: 7f ff f8 7c call 200506c <rtems_fdisk_printf>
2006e80: 2f 00 80 c6 sethi %hi(0x2031800), %l7
2006e84: b4 10 20 00 clr %i2
for (device = 0; device < fd->device_count; device++)
2006e88: b2 10 20 00 clr %i1
for (block = 0; block < fd->block_count; block++)
{
if ((fd->blocks[block].segment == sc) &&
(fd->blocks[block].page == page) && !is_active)
rtems_fdisk_printf (fd,
2006e8c: ac 15 a0 10 or %l6, 0x10, %l6
{
if (fd->blocks[block].segment == sc)
count++;
}
rtems_fdisk_printf (fd, " %3ld %s p:%3ld a:%3ld/%3ld" \
2006e90: 10 80 00 7b b 200707c <rtems_fdisk_ioctl+0x10b4>
2006e94: ae 15 e0 40 or %l7, 0x40, %l7
for (device = 0; device < fd->device_count; device++)
{
uint32_t block;
uint32_t seg;
rtems_fdisk_printf (fd, " Device\t\t%ld", device);
2006e98: 90 10 00 1d mov %i5, %o0
2006e9c: 13 00 80 c5 sethi %hi(0x2031400), %o1
2006ea0: 7f ff f8 73 call 200506c <rtems_fdisk_printf>
2006ea4: 92 12 63 e8 or %o1, 0x3e8, %o1 ! 20317e8 <__FUNCTION__.7063+0xfc8>
rtems_fdisk_printf (fd, " Segment count\t%ld",
2006ea8: c2 07 60 2c ld [ %i5 + 0x2c ], %g1
2006eac: 90 10 00 1d mov %i5, %o0
2006eb0: 82 00 40 1a add %g1, %i2, %g1
2006eb4: d4 00 60 04 ld [ %g1 + 4 ], %o2
2006eb8: 13 00 80 c5 sethi %hi(0x2031400), %o1
2006ebc: a0 10 20 00 clr %l0
2006ec0: 92 12 63 f8 or %o1, 0x3f8, %o1
2006ec4: 7f ff f8 6a call 200506c <rtems_fdisk_printf>
2006ec8: b0 10 20 00 clr %i0
fd->devices[device].segment_count);
for (seg = 0; seg < fd->devices[device].segment_count; seg++)
2006ecc: 10 80 00 65 b 2007060 <rtems_fdisk_ioctl+0x1098>
2006ed0: c2 07 60 2c ld [ %i5 + 0x2c ], %g1
uint32_t active = 0;
uint32_t used = 0;
bool is_active = false;
char queues[5];
rtems_fdisk_queue_status (fd, sc, queues);
2006ed4: 90 10 00 1d mov %i5, %o0
rtems_fdisk_printf (fd, " Segment count\t%ld",
fd->devices[device].segment_count);
for (seg = 0; seg < fd->devices[device].segment_count; seg++)
{
rtems_fdisk_segment_ctl* sc = &fd->devices[device].segments[seg];
2006ed8: b8 07 00 10 add %i4, %l0, %i4
uint32_t active = 0;
uint32_t used = 0;
bool is_active = false;
char queues[5];
rtems_fdisk_queue_status (fd, sc, queues);
2006edc: 94 07 bf f8 add %fp, -8, %o2
2006ee0: 92 10 00 1c mov %i4, %o1
2006ee4: 7f ff f7 f6 call 2004ebc <rtems_fdisk_queue_status>
2006ee8: a2 10 20 00 clr %l1
{
rtems_fdisk_segment_ctl* sc = &fd->devices[device].segments[seg];
uint32_t page;
uint32_t erased = 0;
uint32_t active = 0;
uint32_t used = 0;
2006eec: a6 10 20 00 clr %l3
for (seg = 0; seg < fd->devices[device].segment_count; seg++)
{
rtems_fdisk_segment_ctl* sc = &fd->devices[device].segments[seg];
uint32_t page;
uint32_t erased = 0;
uint32_t active = 0;
2006ef0: a8 10 20 00 clr %l4
for (seg = 0; seg < fd->devices[device].segment_count; seg++)
{
rtems_fdisk_segment_ctl* sc = &fd->devices[device].segments[seg];
uint32_t page;
uint32_t erased = 0;
2006ef4: a4 10 20 00 clr %l2
bool is_active = false;
char queues[5];
rtems_fdisk_queue_status (fd, sc, queues);
for (page = 0; page < sc->pages; page++)
2006ef8: 10 80 00 35 b 2006fcc <rtems_fdisk_ioctl+0x1004>
2006efc: aa 10 20 00 clr %l5
* @param req IOCTL request code.
* @param argp IOCTL argument.
* @retval The IOCTL return value
*/
static int
rtems_fdisk_ioctl (rtems_disk_device *dd, uint32_t req, void* argp)
2006f00: 85 2d 60 03 sll %l5, 3, %g2
rtems_fdisk_queue_status (fd, sc, queues);
for (page = 0; page < sc->pages; page++)
{
if (rtems_fdisk_page_desc_erased (&sc->page_descriptors[page]))
2006f04: 84 03 c0 02 add %o7, %g2, %g2
2006f08: 90 10 00 02 mov %g2, %o0
2006f0c: 7f ff f8 14 call 2004f5c <rtems_fdisk_page_desc_erased>
2006f10: c4 27 bf d0 st %g2, [ %fp + -48 ]
2006f14: 80 8a 20 ff btst 0xff, %o0
2006f18: 02 80 00 04 be 2006f28 <rtems_fdisk_ioctl+0xf60>
2006f1c: c4 07 bf d0 ld [ %fp + -48 ], %g2
erased++;
2006f20: 10 80 00 0c b 2006f50 <rtems_fdisk_ioctl+0xf88>
2006f24: a4 04 a0 01 inc %l2
* only set a flag by changing it from 1 to 0.
*/
static bool
rtems_fdisk_page_desc_flags_set (rtems_fdisk_page_desc* pd, uint16_t flags)
{
return (pd->flags & flags) == 0 ? true : false;
2006f28: c4 10 a0 02 lduh [ %g2 + 2 ], %g2
for (page = 0; page < sc->pages; page++)
{
if (rtems_fdisk_page_desc_erased (&sc->page_descriptors[page]))
erased++;
else if (rtems_fdisk_page_desc_flags_set (&sc->page_descriptors[page],
2006f2c: 80 88 a0 01 btst 1, %g2
2006f30: 32 80 00 09 bne,a 2006f54 <rtems_fdisk_ioctl+0xf8c> <== NEVER TAKEN
2006f34: 84 10 20 00 clr %g2 <== NOT EXECUTED
RTEMS_FDISK_PAGE_ACTIVE))
{
if (rtems_fdisk_page_desc_flags_set (&sc->page_descriptors[page],
2006f38: 80 88 a0 02 btst 2, %g2
2006f3c: 32 80 00 04 bne,a 2006f4c <rtems_fdisk_ioctl+0xf84>
2006f40: a8 05 20 01 inc %l4
RTEMS_FDISK_PAGE_USED))
used++;
2006f44: 10 80 00 03 b 2006f50 <rtems_fdisk_ioctl+0xf88>
2006f48: a6 04 e0 01 inc %l3
else
{
active++;
is_active = true;
2006f4c: a2 10 20 01 mov 1, %l1
}
}
for (block = 0; block < fd->block_count; block++)
2006f50: 84 10 20 00 clr %g2
{
if ((fd->blocks[block].segment == sc) &&
(fd->blocks[block].page == page) && !is_active)
2006f54: 10 80 00 19 b 2006fb8 <rtems_fdisk_ioctl+0xff0>
2006f58: 9a 0c 60 ff and %l1, 0xff, %o5
* @param req IOCTL request code.
* @param argp IOCTL argument.
* @retval The IOCTL return value
*/
static int
rtems_fdisk_ioctl (rtems_disk_device *dd, uint32_t req, void* argp)
2006f5c: 9f 28 a0 03 sll %g2, 3, %o7
}
}
for (block = 0; block < fd->block_count; block++)
{
if ((fd->blocks[block].segment == sc) &&
2006f60: 96 03 00 0f add %o4, %o7, %o3
2006f64: de 03 00 0f ld [ %o4 + %o7 ], %o7
2006f68: 80 a3 c0 1c cmp %o7, %i4
2006f6c: 32 80 00 13 bne,a 2006fb8 <rtems_fdisk_ioctl+0xff0>
2006f70: 84 00 a0 01 inc %g2
2006f74: de 02 e0 04 ld [ %o3 + 4 ], %o7
2006f78: 80 a3 c0 15 cmp %o7, %l5
2006f7c: 32 80 00 0f bne,a 2006fb8 <rtems_fdisk_ioctl+0xff0>
2006f80: 84 00 a0 01 inc %g2
(fd->blocks[block].page == page) && !is_active)
2006f84: 80 a3 60 00 cmp %o5, 0
2006f88: 32 80 00 0c bne,a 2006fb8 <rtems_fdisk_ioctl+0xff0> <== ALWAYS TAKEN
2006f8c: 84 00 a0 01 inc %g2
rtems_fdisk_printf (fd,
2006f90: 96 10 00 02 mov %g2, %o3 <== NOT EXECUTED
2006f94: c4 27 bf d0 st %g2, [ %fp + -48 ] <== NOT EXECUTED
2006f98: da 27 bf bc st %o5, [ %fp + -68 ] <== NOT EXECUTED
2006f9c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
2006fa0: 92 10 00 16 mov %l6, %o1 <== NOT EXECUTED
2006fa4: 7f ff f8 32 call 200506c <rtems_fdisk_printf> <== NOT EXECUTED
2006fa8: 94 10 00 15 mov %l5, %o2 <== NOT EXECUTED
2006fac: da 07 bf bc ld [ %fp + -68 ], %o5 <== NOT EXECUTED
2006fb0: c4 07 bf d0 ld [ %fp + -48 ], %g2 <== NOT EXECUTED
active++;
is_active = true;
}
}
for (block = 0; block < fd->block_count; block++)
2006fb4: 84 00 a0 01 inc %g2 <== NOT EXECUTED
2006fb8: de 07 60 1c ld [ %i5 + 0x1c ], %o7
2006fbc: 80 a0 80 0f cmp %g2, %o7
2006fc0: 2a bf ff e7 bcs,a 2006f5c <rtems_fdisk_ioctl+0xf94>
2006fc4: d8 07 60 18 ld [ %i5 + 0x18 ], %o4
bool is_active = false;
char queues[5];
rtems_fdisk_queue_status (fd, sc, queues);
for (page = 0; page < sc->pages; page++)
2006fc8: aa 05 60 01 inc %l5
2006fcc: d8 07 20 14 ld [ %i4 + 0x14 ], %o4
2006fd0: 80 a5 40 0c cmp %l5, %o4
2006fd4: 2a bf ff cb bcs,a 2006f00 <rtems_fdisk_ioctl+0xf38>
2006fd8: de 07 20 10 ld [ %i4 + 0x10 ], %o7
page, block);
}
}
count = 0;
for (block = 0; block < fd->block_count; block++)
2006fdc: de 07 60 1c ld [ %i5 + 0x1c ], %o7
2006fe0: 82 10 20 00 clr %g1
2006fe4: 10 80 00 08 b 2007004 <rtems_fdisk_ioctl+0x103c>
2006fe8: 84 10 20 00 clr %g2
{
if (fd->blocks[block].segment == sc)
2006fec: 9b 28 60 03 sll %g1, 3, %o5
2006ff0: da 02 c0 0d ld [ %o3 + %o5 ], %o5
page, block);
}
}
count = 0;
for (block = 0; block < fd->block_count; block++)
2006ff4: 82 00 60 01 inc %g1
{
if (fd->blocks[block].segment == sc)
count++;
2006ff8: 9a 1b 40 1c xor %o5, %i4, %o5
2006ffc: 80 a0 00 0d cmp %g0, %o5
2007000: 84 60 bf ff subx %g2, -1, %g2
page, block);
}
}
count = 0;
for (block = 0; block < fd->block_count; block++)
2007004: 80 a0 40 0f cmp %g1, %o7
2007008: 32 bf ff f9 bne,a 2006fec <rtems_fdisk_ioctl+0x1024>
200700c: d6 07 60 18 ld [ %i5 + 0x18 ], %o3
" u:%3ld/%3ld e:%3ld/%3ld br:%ld",
seg, queues,
sc->pages, sc->pages_active, active,
sc->pages_used, used, erased,
sc->pages - (sc->pages_active +
sc->pages_used + sc->pages_bad),
2007010: c2 07 20 20 ld [ %i4 + 0x20 ], %g1
rtems_fdisk_printf (fd, " %3ld %s p:%3ld a:%3ld/%3ld" \
" u:%3ld/%3ld e:%3ld/%3ld br:%ld",
seg, queues,
sc->pages, sc->pages_active, active,
sc->pages_used, used, erased,
sc->pages - (sc->pages_active +
2007014: da 07 20 1c ld [ %i4 + 0x1c ], %o5
{
if (fd->blocks[block].segment == sc)
count++;
}
rtems_fdisk_printf (fd, " %3ld %s p:%3ld a:%3ld/%3ld" \
2007018: c2 23 a0 60 st %g1, [ %sp + 0x60 ]
200701c: e8 23 a0 5c st %l4, [ %sp + 0x5c ]
2007020: e6 23 a0 64 st %l3, [ %sp + 0x64 ]
2007024: e4 23 a0 68 st %l2, [ %sp + 0x68 ]
* @param req IOCTL request code.
* @param argp IOCTL argument.
* @retval The IOCTL return value
*/
static int
rtems_fdisk_ioctl (rtems_disk_device *dd, uint32_t req, void* argp)
2007028: c6 07 20 24 ld [ %i4 + 0x24 ], %g3
200702c: 82 03 40 01 add %o5, %g1, %g1
2007030: 82 00 40 03 add %g1, %g3, %g1
{
if (fd->blocks[block].segment == sc)
count++;
}
rtems_fdisk_printf (fd, " %3ld %s p:%3ld a:%3ld/%3ld" \
2007034: 82 23 00 01 sub %o4, %g1, %g1
2007038: 94 10 00 18 mov %i0, %o2
200703c: c2 23 a0 6c st %g1, [ %sp + 0x6c ]
2007040: c4 23 a0 70 st %g2, [ %sp + 0x70 ]
2007044: 90 10 00 1d mov %i5, %o0
2007048: 92 10 00 17 mov %l7, %o1
200704c: 96 07 bf f8 add %fp, -8, %o3
2007050: 7f ff f8 07 call 200506c <rtems_fdisk_printf>
2007054: b0 06 20 01 inc %i0
2007058: a0 04 20 30 add %l0, 0x30, %l0
rtems_fdisk_printf (fd, " Device\t\t%ld", device);
rtems_fdisk_printf (fd, " Segment count\t%ld",
fd->devices[device].segment_count);
for (seg = 0; seg < fd->devices[device].segment_count; seg++)
200705c: c2 07 60 2c ld [ %i5 + 0x2c ], %g1
2007060: 84 00 40 1a add %g1, %i2, %g2
2007064: c4 00 a0 04 ld [ %g2 + 4 ], %g2
2007068: 80 a6 00 02 cmp %i0, %g2
200706c: 2a bf ff 9a bcs,a 2006ed4 <rtems_fdisk_ioctl+0xf0c>
2007070: f8 00 40 1a ld [ %g1 + %i2 ], %i4
rtems_fdisk_printf (fd, "Queue total\t%ld of %ld, %s", total, count,
total == count ? "ok" : "MISSING");
rtems_fdisk_printf (fd, "Device count\t%d", fd->device_count);
for (device = 0; device < fd->device_count; device++)
2007074: b2 06 60 01 inc %i1
2007078: b4 06 a0 0c add %i2, 0xc, %i2
200707c: c2 07 60 30 ld [ %i5 + 0x30 ], %g1
2007080: 80 a6 40 01 cmp %i1, %g1
2007084: 0a bf ff 85 bcs 2006e98 <rtems_fdisk_ioctl+0xed0>
2007088: 94 10 00 19 mov %i1, %o2
count);
}
}
{
rtems_fdisk_segment_ctl* sc = fd->used.head;
200708c: f8 07 60 40 ld [ %i5 + 0x40 ], %i4
int count = 0;
rtems_fdisk_printf (fd, "Used List:");
2007090: 90 10 00 1d mov %i5, %o0
2007094: 13 00 80 c6 sethi %hi(0x2031800), %o1
while (sc)
{
rtems_fdisk_printf (fd, " %3d %02d:%03d u:%3ld",
2007098: 33 00 80 c6 sethi %hi(0x2031800), %i1
}
{
rtems_fdisk_segment_ctl* sc = fd->used.head;
int count = 0;
rtems_fdisk_printf (fd, "Used List:");
200709c: 92 12 60 80 or %o1, 0x80, %o1
20070a0: 7f ff f7 f3 call 200506c <rtems_fdisk_printf>
20070a4: b4 10 20 00 clr %i2
while (sc)
{
rtems_fdisk_printf (fd, " %3d %02d:%03d u:%3ld",
20070a8: 10 80 00 0a b 20070d0 <rtems_fdisk_ioctl+0x1108>
20070ac: b2 16 60 90 or %i1, 0x90, %i1
20070b0: d8 07 20 0c ld [ %i4 + 0xc ], %o4
20070b4: da 07 20 20 ld [ %i4 + 0x20 ], %o5
20070b8: 94 10 00 1a mov %i2, %o2
20070bc: 90 10 00 1d mov %i5, %o0
20070c0: 7f ff f7 eb call 200506c <rtems_fdisk_printf>
20070c4: 92 10 00 19 mov %i1, %o1
count, sc->device, sc->segment, sc->pages_used);
sc = sc->next;
20070c8: f8 07 00 00 ld [ %i4 ], %i4
count++;
20070cc: b4 06 a0 01 inc %i2
{
rtems_fdisk_segment_ctl* sc = fd->used.head;
int count = 0;
rtems_fdisk_printf (fd, "Used List:");
while (sc)
20070d0: 80 a7 20 00 cmp %i4, 0
20070d4: 32 bf ff f7 bne,a 20070b0 <rtems_fdisk_ioctl+0x10e8>
20070d8: d6 07 20 08 ld [ %i4 + 8 ], %o3
count, sc->device, sc->segment, sc->pages_used);
sc = sc->next;
count++;
}
}
fd->info_level = current_info_level;
20070dc: c2 07 bf e8 ld [ %fp + -24 ], %g1
case RTEMS_FDISK_IOCTL_INFO_LEVEL:
rtems_flashdisks[minor].info_level = (uintptr_t) argp;
break;
case RTEMS_FDISK_IOCTL_PRINT_STATUS:
errno = rtems_fdisk_print_status (&rtems_flashdisks[minor]);
20070e0: c4 07 bf ec ld [ %fp + -20 ], %g2
count, sc->device, sc->segment, sc->pages_used);
sc = sc->next;
count++;
}
}
fd->info_level = current_info_level;
20070e4: c2 27 60 6c st %g1, [ %i5 + 0x6c ]
rtems_flashdisks[minor].info_level = (uintptr_t) argp;
break;
case RTEMS_FDISK_IOCTL_PRINT_STATUS:
errno = rtems_fdisk_print_status (&rtems_flashdisks[minor]);
break;
20070e8: 10 80 00 05 b 20070fc <rtems_fdisk_ioctl+0x1134>
20070ec: c0 20 80 00 clr [ %g2 ]
default:
rtems_blkdev_ioctl (dd, req, argp);
20070f0: 92 10 00 19 mov %i1, %o1
20070f4: 40 00 3b f3 call 20160c0 <rtems_blkdev_ioctl>
20070f8: 94 10 00 1a mov %i2, %o2
break;
}
sc = rtems_semaphore_release (rtems_flashdisks[minor].lock);
20070fc: 03 00 81 19 sethi %hi(0x2046400), %g1
2007100: c2 00 62 d0 ld [ %g1 + 0x2d0 ], %g1 ! 20466d0 <rtems_flashdisks>
2007104: b6 00 40 1b add %g1, %i3, %i3
2007108: 40 00 17 0a call 200cd30 <rtems_semaphore_release>
200710c: d0 06 e0 64 ld [ %i3 + 0x64 ], %o0
if (sc != RTEMS_SUCCESSFUL)
2007110: 80 a2 20 00 cmp %o0, 0
2007114: 02 80 00 06 be 200712c <rtems_fdisk_ioctl+0x1164> <== ALWAYS TAKEN
2007118: 01 00 00 00 nop
errno = EIO;
200711c: 40 00 66 a6 call 2020bb4 <__errno> <== NOT EXECUTED
2007120: 01 00 00 00 nop <== NOT EXECUTED
2007124: 82 10 20 05 mov 5, %g1 ! 5 <PROM_START+0x5> <== NOT EXECUTED
2007128: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
}
return errno == 0 ? 0 : -1;
200712c: 40 00 66 a2 call 2020bb4 <__errno>
2007130: 01 00 00 00 nop
2007134: c2 02 00 00 ld [ %o0 ], %g1
2007138: 80 a0 00 01 cmp %g0, %g1
200713c: b0 60 20 00 subx %g0, 0, %i0
2007140: 81 c7 e0 08 ret
2007144: 81 e8 00 00 restore
uint8_t* data;
uint32_t fb;
uint32_t b;
fb = sg->length / fd->block_size;
data = sg->buffer;
for (b = 0; b < fb; b++, data += fd->block_size)
2007148: c2 07 20 14 ld [ %i4 + 0x14 ], %g1
200714c: a2 04 60 01 inc %l1
2007150: 10 bf fc 82 b 2006358 <rtems_fdisk_ioctl+0x390>
2007154: a0 04 00 01 add %l0, %g1, %l0
{
rtems_blkdev_sg_buffer* sg = req->bufs;
uint32_t buf;
int ret = 0;
for (buf = 0; (ret == 0) && (buf < req->bufnum); buf++, sg++)
2007158: 10 bf fc 86 b 2006370 <rtems_fdisk_ioctl+0x3a8> <== NOT EXECUTED
200715c: a4 04 a0 01 inc %l2 <== NOT EXECUTED
020052e0 <rtems_fdisk_queue_segment>:
* @param fd The flash disk control table.
* @param sc The segment control table to be reallocated
*/
static void
rtems_fdisk_queue_segment (rtems_flashdisk* fd, rtems_fdisk_segment_ctl* sc)
{
20052e0: 9d e3 bf 90 save %sp, -112, %sp
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd, " queue-seg:%02d-%03d: p=%d a=%d u=%d b=%d f=%s n=%s",
20052e4: c2 06 60 28 ld [ %i1 + 0x28 ], %g1
* @param fd The flash disk control table.
* @param sc The segment control table to be reallocated
*/
static void
rtems_fdisk_queue_segment (rtems_flashdisk* fd, rtems_fdisk_segment_ctl* sc)
{
20052e8: ba 10 00 18 mov %i0, %i5
20052ec: b4 10 00 19 mov %i1, %i2
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd, " queue-seg:%02d-%03d: p=%d a=%d u=%d b=%d f=%s n=%s",
20052f0: d4 06 60 08 ld [ %i1 + 8 ], %o2
20052f4: d6 06 60 0c ld [ %i1 + 0xc ], %o3
20052f8: d8 06 60 14 ld [ %i1 + 0x14 ], %o4
20052fc: da 06 60 1c ld [ %i1 + 0x1c ], %o5
2005300: c8 06 60 20 ld [ %i1 + 0x20 ], %g4
2005304: 80 a0 60 00 cmp %g1, 0
2005308: 02 80 00 05 be 200531c <rtems_fdisk_queue_segment+0x3c> <== ALWAYS TAKEN
200530c: c6 06 60 24 ld [ %i1 + 0x24 ], %g3
2005310: 05 00 80 c3 sethi %hi(0x2030c00), %g2 <== NOT EXECUTED
2005314: 10 80 00 04 b 2005324 <rtems_fdisk_queue_segment+0x44> <== NOT EXECUTED
2005318: 84 10 a2 10 or %g2, 0x210, %g2 ! 2030e10 <__FUNCTION__.7063+0x5f0><== NOT EXECUTED
200531c: 05 00 80 c3 sethi %hi(0x2030c00), %g2
2005320: 84 10 a2 18 or %g2, 0x218, %g2 ! 2030e18 <__FUNCTION__.7063+0x5f8>
2005324: c2 06 80 00 ld [ %i2 ], %g1
2005328: 80 a0 60 00 cmp %g1, 0
200532c: 02 80 00 04 be 200533c <rtems_fdisk_queue_segment+0x5c>
2005330: 03 00 80 c3 sethi %hi(0x2030c00), %g1
2005334: 10 80 00 04 b 2005344 <rtems_fdisk_queue_segment+0x64>
2005338: 82 10 62 20 or %g1, 0x220, %g1 ! 2030e20 <__FUNCTION__.7063+0x600>
200533c: 03 00 80 c3 sethi %hi(0x2030c00), %g1
2005340: 82 10 62 28 or %g1, 0x228, %g1 ! 2030e28 <__FUNCTION__.7063+0x608>
2005344: c2 23 a0 68 st %g1, [ %sp + 0x68 ]
2005348: c8 23 a0 5c st %g4, [ %sp + 0x5c ]
200534c: c6 23 a0 60 st %g3, [ %sp + 0x60 ]
2005350: c4 23 a0 64 st %g2, [ %sp + 0x64 ]
2005354: 90 10 00 1d mov %i5, %o0
2005358: 13 00 80 c3 sethi %hi(0x2030c00), %o1
200535c: 7f ff ff 24 call 2004fec <rtems_fdisk_info>
2005360: 92 12 62 30 or %o1, 0x230, %o1 ! 2030e30 <__FUNCTION__.7063+0x610>
/*
* If the segment has failed then check the failed queue and append
* if not failed.
*/
if (sc->failed)
2005364: c2 06 a0 28 ld [ %i2 + 0x28 ], %g1
2005368: 80 a0 60 00 cmp %g1, 0
200536c: 02 80 00 09 be 2005390 <rtems_fdisk_queue_segment+0xb0> <== ALWAYS TAKEN
2005370: 92 10 00 1a mov %i2, %o1
{
if (!rtems_fdisk_segment_queue_present (&fd->failed, sc))
2005374: b0 07 60 58 add %i5, 0x58, %i0 <== NOT EXECUTED
2005378: 7f ff fe c6 call 2004e90 <rtems_fdisk_segment_queue_present><== NOT EXECUTED
200537c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
2005380: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
2005384: 12 80 00 32 bne 200544c <rtems_fdisk_queue_segment+0x16c> <== NOT EXECUTED
2005388: 01 00 00 00 nop <== NOT EXECUTED
200538c: 30 80 00 2e b,a 2005444 <rtems_fdisk_queue_segment+0x164><== NOT EXECUTED
}
/*
* Remove the queue from the available or used queue.
*/
rtems_fdisk_segment_queue_remove (&fd->available, sc);
2005390: b8 07 60 34 add %i5, 0x34, %i4
2005394: 7f ff fe 84 call 2004da4 <rtems_fdisk_segment_queue_remove>
2005398: 90 10 00 1c mov %i4, %o0
rtems_fdisk_segment_queue_remove (&fd->used, sc);
200539c: 92 10 00 1a mov %i2, %o1
20053a0: b0 07 60 40 add %i5, 0x40, %i0
20053a4: 7f ff fe 80 call 2004da4 <rtems_fdisk_segment_queue_remove>
20053a8: 90 10 00 18 mov %i0, %o0
* If they are and the driver has been configured to background
* erase place the segment on the used queue. If not configured
* to background erase perform the erase now.
*
*/
if (rtems_fdisk_seg_pages_available (sc) == 0)
20053ac: 7f ff fe f6 call 2004f84 <rtems_fdisk_seg_pages_available>
20053b0: 90 10 00 1a mov %i2, %o0
20053b4: b6 92 20 00 orcc %o0, 0, %i3
20053b8: 32 80 00 1d bne,a 200542c <rtems_fdisk_queue_segment+0x14c>
20053bc: f2 07 60 34 ld [ %i5 + 0x34 ], %i1
{
if (sc->pages_active)
20053c0: c2 06 a0 1c ld [ %i2 + 0x1c ], %g1
20053c4: 80 a0 60 00 cmp %g1, 0
20053c8: 22 80 00 0d be,a 20053fc <rtems_fdisk_queue_segment+0x11c><== NEVER TAKEN
20053cc: c2 07 60 08 ld [ %i5 + 8 ], %g1 <== NOT EXECUTED
* pages. When we compact we want to move the pages into
* a new segment and cover more than one segment.
*/
rtems_fdisk_segment_ctl* seg = fd->used.head;
while (seg)
20053d0: 10 80 00 07 b 20053ec <rtems_fdisk_queue_segment+0x10c>
20053d4: f2 07 60 40 ld [ %i5 + 0x40 ], %i1
{
if (sc->pages_used > seg->pages_used)
20053d8: c2 06 60 20 ld [ %i1 + 0x20 ], %g1
20053dc: 80 a0 80 01 cmp %g2, %g1
20053e0: 18 80 00 17 bgu 200543c <rtems_fdisk_queue_segment+0x15c>
20053e4: 01 00 00 00 nop
break;
seg = seg->next;
20053e8: f2 06 40 00 ld [ %i1 ], %i1
* pages. When we compact we want to move the pages into
* a new segment and cover more than one segment.
*/
rtems_fdisk_segment_ctl* seg = fd->used.head;
while (seg)
20053ec: 80 a6 60 00 cmp %i1, 0
20053f0: 32 bf ff fa bne,a 20053d8 <rtems_fdisk_queue_segment+0xf8>
20053f4: c4 06 a0 20 ld [ %i2 + 0x20 ], %g2
20053f8: 30 80 00 13 b,a 2005444 <rtems_fdisk_queue_segment+0x164>
else
rtems_fdisk_segment_queue_push_tail (&fd->used, sc);
}
else
{
if ((fd->flags & RTEMS_FDISK_BACKGROUND_ERASE))
20053fc: 80 88 60 01 btst 1, %g1 <== NOT EXECUTED
2005400: 12 80 00 11 bne 2005444 <rtems_fdisk_queue_segment+0x164> <== NOT EXECUTED
2005404: b0 07 60 4c add %i5, 0x4c, %i0 <== NOT EXECUTED
rtems_fdisk_segment_queue_push_tail (&fd->erase, sc);
else
rtems_fdisk_erase_segment (fd, sc);
2005408: b0 10 00 1d mov %i5, %i0 <== NOT EXECUTED
200540c: 7f ff ff 75 call 20051e0 <rtems_fdisk_erase_segment> <== NOT EXECUTED
2005410: 93 e8 00 1a restore %g0, %i2, %o1 <== NOT EXECUTED
rtems_fdisk_segment_ctl* seg = fd->available.head;
while (seg)
{
if (rtems_fdisk_seg_pages_available (sc) <
rtems_fdisk_seg_pages_available (seg))
2005414: 7f ff fe dc call 2004f84 <rtems_fdisk_seg_pages_available>
2005418: 90 10 00 19 mov %i1, %o0
*/
rtems_fdisk_segment_ctl* seg = fd->available.head;
while (seg)
{
if (rtems_fdisk_seg_pages_available (sc) <
200541c: 80 a6 c0 08 cmp %i3, %o0
2005420: 0a 80 00 07 bcs 200543c <rtems_fdisk_queue_segment+0x15c>
2005424: b0 10 00 1c mov %i4, %i0
rtems_fdisk_seg_pages_available (seg))
break;
seg = seg->next;
2005428: f2 06 40 00 ld [ %i1 ], %i1
* with all the counters updated with the number of
* bits cleared and all bits set back to 1.
*/
rtems_fdisk_segment_ctl* seg = fd->available.head;
while (seg)
200542c: 80 a6 60 00 cmp %i1, 0
2005430: 12 bf ff f9 bne 2005414 <rtems_fdisk_queue_segment+0x134>
2005434: b0 10 00 1c mov %i4, %i0
2005438: 30 80 00 03 b,a 2005444 <rtems_fdisk_queue_segment+0x164>
break;
seg = seg->next;
}
if (seg)
rtems_fdisk_segment_queue_insert_before (&fd->available, seg, sc);
200543c: 7f ff fe 77 call 2004e18 <rtems_fdisk_segment_queue_insert_before>
2005440: 81 e8 00 00 restore
else
rtems_fdisk_segment_queue_push_tail (&fd->available, sc);
2005444: 7f ff fe 46 call 2004d5c <rtems_fdisk_segment_queue_push_tail>
2005448: 93 e8 00 1a restore %g0, %i2, %o1
200544c: 81 c7 e0 08 ret <== NOT EXECUTED
2005450: 81 e8 00 00 restore <== NOT EXECUTED
0200563c <rtems_fdisk_recover_block_mappings>:
/**
* Recover the block mappings from the devices.
*/
static int
rtems_fdisk_recover_block_mappings (rtems_flashdisk* fd)
{
200563c: 9d e3 bf 98 save %sp, -104, %sp
rtems_fdisk_segment_queue_init (&fd->failed);
/*
* Clear the lock mappings.
*/
memset (fd->blocks, 0, fd->block_count * sizeof (rtems_fdisk_block_ctl));
2005640: d4 06 20 1c ld [ %i0 + 0x1c ], %o2
2005644: d0 06 20 18 ld [ %i0 + 0x18 ], %o0
* Initialise the segment control queue.
*/
static void
rtems_fdisk_segment_queue_init (rtems_fdisk_segment_ctl_queue* queue)
{
queue->head = queue->tail = 0;
2005648: c0 26 20 38 clr [ %i0 + 0x38 ]
200564c: c0 26 20 34 clr [ %i0 + 0x34 ]
queue->count = 0;
2005650: c0 26 20 3c clr [ %i0 + 0x3c ]
* Initialise the segment control queue.
*/
static void
rtems_fdisk_segment_queue_init (rtems_fdisk_segment_ctl_queue* queue)
{
queue->head = queue->tail = 0;
2005654: c0 26 20 44 clr [ %i0 + 0x44 ]
2005658: c0 26 20 40 clr [ %i0 + 0x40 ]
queue->count = 0;
200565c: c0 26 20 48 clr [ %i0 + 0x48 ]
* Initialise the segment control queue.
*/
static void
rtems_fdisk_segment_queue_init (rtems_fdisk_segment_ctl_queue* queue)
{
queue->head = queue->tail = 0;
2005660: c0 26 20 50 clr [ %i0 + 0x50 ]
2005664: c0 26 20 4c clr [ %i0 + 0x4c ]
queue->count = 0;
2005668: c0 26 20 54 clr [ %i0 + 0x54 ]
* Initialise the segment control queue.
*/
static void
rtems_fdisk_segment_queue_init (rtems_fdisk_segment_ctl_queue* queue)
{
queue->head = queue->tail = 0;
200566c: c0 26 20 5c clr [ %i0 + 0x5c ]
2005670: c0 26 20 58 clr [ %i0 + 0x58 ]
queue->count = 0;
2005674: c0 26 20 60 clr [ %i0 + 0x60 ]
rtems_fdisk_segment_queue_init (&fd->failed);
/*
* Clear the lock mappings.
*/
memset (fd->blocks, 0, fd->block_count * sizeof (rtems_fdisk_block_ctl));
2005678: 92 10 20 00 clr %o1
200567c: 95 2a a0 03 sll %o2, 3, %o2
2005680: 40 00 72 1e call 2021ef8 <memset>
2005684: 27 00 80 c3 sethi %hi(0x2030c00), %l3
* each block so we can tell which is the later block when
* duplicates appear. A power down with a failed wirte could cause
* a duplicate.
*/
const rtems_fdisk_segment_ctl* bsc = fd->blocks[pd->block].segment;
rtems_fdisk_error ("duplicate block: %d-%d-%d: " \
2005688: 29 00 80 c3 sethi %hi(0x2030c00), %l4
else if (rtems_fdisk_page_desc_flags_set (pd, RTEMS_FDISK_PAGE_ACTIVE))
{
if (pd->block >= fd->block_count)
{
#if RTEMS_FDISK_TRACE
rtems_fdisk_warning (fd,
200568c: 2b 00 80 c3 sethi %hi(0x2030c00), %l5
++fd->erased_blocks;
}
else
{
#if RTEMS_FDISK_TRACE
rtems_fdisk_warning (fd, "page not blank: %d-%d-%d",
2005690: 2d 00 80 c3 sethi %hi(0x2030c00), %l6
ret = rtems_fdisk_seg_write_page_desc (fd, sc,
page, pd);
if (ret)
{
rtems_fdisk_error ("forcing page to used failed: %d-%d-%d",
2005694: 2f 00 80 c3 sethi %hi(0x2030c00), %l7
/**
* Recover the block mappings from the devices.
*/
static int
rtems_fdisk_recover_block_mappings (rtems_flashdisk* fd)
{
2005698: ba 10 00 18 mov %i0, %i5
memset (fd->blocks, 0, fd->block_count * sizeof (rtems_fdisk_block_ctl));
/*
* Scan each segment or each device recovering the valid pages.
*/
fd->erased_blocks = 0;
200569c: c0 26 20 28 clr [ %i0 + 0x28 ]
fd->starvation_threshold = 0;
20056a0: c0 26 20 24 clr [ %i0 + 0x24 ]
for (device = 0; device < fd->device_count; device++)
20056a4: a2 10 20 00 clr %l1
20056a8: b2 10 20 00 clr %i1
rtems_fdisk_page_desc* pd;
uint32_t page;
int ret;
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd, "recover-block-mappings:%02d-%03d", device, segment);
20056ac: a6 14 e2 e0 or %l3, 0x2e0, %l3
* each block so we can tell which is the later block when
* duplicates appear. A power down with a failed wirte could cause
* a duplicate.
*/
const rtems_fdisk_segment_ctl* bsc = fd->blocks[pd->block].segment;
rtems_fdisk_error ("duplicate block: %d-%d-%d: " \
20056b0: a8 15 23 c8 or %l4, 0x3c8, %l4
else if (rtems_fdisk_page_desc_flags_set (pd, RTEMS_FDISK_PAGE_ACTIVE))
{
if (pd->block >= fd->block_count)
{
#if RTEMS_FDISK_TRACE
rtems_fdisk_warning (fd,
20056b4: aa 15 63 98 or %l5, 0x398, %l5
++fd->erased_blocks;
}
else
{
#if RTEMS_FDISK_TRACE
rtems_fdisk_warning (fd, "page not blank: %d-%d-%d",
20056b8: ac 15 a3 50 or %l6, 0x350, %l6
/*
* Scan each segment or each device recovering the valid pages.
*/
fd->erased_blocks = 0;
fd->starvation_threshold = 0;
for (device = 0; device < fd->device_count; device++)
20056bc: 10 80 00 b3 b 2005988 <rtems_fdisk_recover_block_mappings+0x34c>
20056c0: ae 15 e3 70 or %l7, 0x370, %l7
rtems_fdisk_page_desc* pd;
uint32_t page;
int ret;
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd, "recover-block-mappings:%02d-%03d", device, segment);
20056c4: 94 10 00 19 mov %i1, %o2
for (device = 0; device < fd->device_count; device++)
{
uint32_t segment;
for (segment = 0; segment < fd->devices[device].segment_count; segment++)
{
rtems_fdisk_segment_ctl* sc = &fd->devices[device].segments[segment];
20056c8: b8 07 00 12 add %i4, %l2, %i4
const rtems_fdisk_segment_desc* sd = sc->descriptor;
20056cc: f6 07 20 04 ld [ %i4 + 4 ], %i3
rtems_fdisk_page_desc* pd;
uint32_t page;
int ret;
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd, "recover-block-mappings:%02d-%03d", device, segment);
20056d0: 96 10 00 10 mov %l0, %o3
20056d4: 92 10 00 13 mov %l3, %o1
20056d8: 7f ff fe 45 call 2004fec <rtems_fdisk_info>
20056dc: 90 10 00 1d mov %i5, %o0
*/
static uint32_t
rtems_fdisk_pages_in_segment (const rtems_fdisk_segment_desc* sd,
uint32_t page_size)
{
return sd->size / page_size;
20056e0: d0 06 e0 08 ld [ %i3 + 8 ], %o0
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd, "recover-block-mappings:%02d-%03d", device, segment);
#endif
sc->pages_desc = rtems_fdisk_page_desc_pages (sd, fd->block_size);
20056e4: f4 07 60 14 ld [ %i5 + 0x14 ], %i2
*/
static uint32_t
rtems_fdisk_pages_in_segment (const rtems_fdisk_segment_desc* sd,
uint32_t page_size)
{
return sd->size / page_size;
20056e8: 7f ff f3 e5 call 200267c <.udiv>
20056ec: 92 10 00 1a mov %i2, %o1
rtems_fdisk_page_desc_pages (const rtems_fdisk_segment_desc* sd,
uint32_t page_size)
{
uint32_t pages = rtems_fdisk_pages_in_segment (sd, page_size);
uint32_t bytes = pages * sizeof (rtems_fdisk_page_desc);
return ((bytes - 1) / page_size) + 1;
20056f0: 92 10 00 1a mov %i2, %o1
*/
static uint32_t
rtems_fdisk_pages_in_segment (const rtems_fdisk_segment_desc* sd,
uint32_t page_size)
{
return sd->size / page_size;
20056f4: b6 10 00 08 mov %o0, %i3
static uint32_t
rtems_fdisk_page_desc_pages (const rtems_fdisk_segment_desc* sd,
uint32_t page_size)
{
uint32_t pages = rtems_fdisk_pages_in_segment (sd, page_size);
uint32_t bytes = pages * sizeof (rtems_fdisk_page_desc);
20056f8: 91 2a 20 03 sll %o0, 3, %o0
return ((bytes - 1) / page_size) + 1;
20056fc: 7f ff f3 e0 call 200267c <.udiv>
2005700: 90 02 3f ff add %o0, -1, %o0
#endif
sc->pages_desc = rtems_fdisk_page_desc_pages (sd, fd->block_size);
sc->pages =
rtems_fdisk_pages_in_segment (sd, fd->block_size) - sc->pages_desc;
if (sc->pages > fd->starvation_threshold)
2005704: c2 07 60 24 ld [ %i5 + 0x24 ], %g1
rtems_fdisk_page_desc_pages (const rtems_fdisk_segment_desc* sd,
uint32_t page_size)
{
uint32_t pages = rtems_fdisk_pages_in_segment (sd, page_size);
uint32_t bytes = pages * sizeof (rtems_fdisk_page_desc);
return ((bytes - 1) / page_size) + 1;
2005708: b0 02 20 01 add %o0, 1, %i0
rtems_fdisk_info (fd, "recover-block-mappings:%02d-%03d", device, segment);
#endif
sc->pages_desc = rtems_fdisk_page_desc_pages (sd, fd->block_size);
sc->pages =
rtems_fdisk_pages_in_segment (sd, fd->block_size) - sc->pages_desc;
200570c: 90 26 c0 18 sub %i3, %i0, %o0
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd, "recover-block-mappings:%02d-%03d", device, segment);
#endif
sc->pages_desc = rtems_fdisk_page_desc_pages (sd, fd->block_size);
2005710: f0 27 20 18 st %i0, [ %i4 + 0x18 ]
sc->pages =
rtems_fdisk_pages_in_segment (sd, fd->block_size) - sc->pages_desc;
if (sc->pages > fd->starvation_threshold)
2005714: 80 a2 00 01 cmp %o0, %g1
2005718: 08 80 00 03 bleu 2005724 <rtems_fdisk_recover_block_mappings+0xe8>
200571c: d0 27 20 14 st %o0, [ %i4 + 0x14 ]
fd->starvation_threshold = sc->pages;
2005720: d0 27 60 24 st %o0, [ %i5 + 0x24 ]
sc->pages_used = 0;
sc->pages_bad = 0;
sc->failed = false;
if (!sc->page_descriptors)
2005724: c2 07 20 10 ld [ %i4 + 0x10 ], %g1
sc->pages =
rtems_fdisk_pages_in_segment (sd, fd->block_size) - sc->pages_desc;
if (sc->pages > fd->starvation_threshold)
fd->starvation_threshold = sc->pages;
sc->pages_active = 0;
2005728: c0 27 20 1c clr [ %i4 + 0x1c ]
sc->pages_used = 0;
200572c: c0 27 20 20 clr [ %i4 + 0x20 ]
sc->pages_bad = 0;
2005730: c0 27 20 24 clr [ %i4 + 0x24 ]
sc->failed = false;
if (!sc->page_descriptors)
2005734: 80 a0 60 00 cmp %g1, 0
2005738: 12 80 00 08 bne 2005758 <rtems_fdisk_recover_block_mappings+0x11c><== NEVER TAKEN
200573c: c0 27 20 28 clr [ %i4 + 0x28 ]
sc->page_descriptors = malloc (sc->pages_desc * fd->block_size);
2005740: 92 10 00 1a mov %i2, %o1
2005744: 7f ff f3 94 call 2002594 <.umul>
2005748: 90 10 00 18 mov %i0, %o0
200574c: 40 00 0c 5d call 20088c0 <malloc>
2005750: 01 00 00 00 nop
2005754: d0 27 20 10 st %o0, [ %i4 + 0x10 ]
if (!sc->page_descriptors)
2005758: f6 07 20 10 ld [ %i4 + 0x10 ], %i3
200575c: 80 a6 e0 00 cmp %i3, 0
2005760: 32 80 00 05 bne,a 2005774 <rtems_fdisk_recover_block_mappings+0x138><== ALWAYS TAKEN
2005764: 90 10 00 18 mov %i0, %o0
rtems_fdisk_abort ("no memory for page descriptors");
2005768: 11 00 80 c3 sethi %hi(0x2030c00), %o0 <== NOT EXECUTED
200576c: 40 00 07 c1 call 2007670 <rtems_fdisk_abort.constprop.0> <== NOT EXECUTED
2005770: 90 12 21 b8 or %o0, 0x1b8, %o0 ! 2030db8 <__FUNCTION__.7063+0x598><== NOT EXECUTED
* descriptors.
*
* @todo It may be better to ask the driver to get these value
* so NAND flash could be better supported.
*/
ret = rtems_fdisk_seg_read (fd, sc, 0, (void*) pd,
2005774: 7f ff f3 88 call 2002594 <.umul>
2005778: 92 10 00 1a mov %i2, %o1
200577c: 92 10 00 1c mov %i4, %o1
2005780: 98 10 00 08 mov %o0, %o4
2005784: 94 10 20 00 clr %o2
2005788: 90 10 00 1d mov %i5, %o0
200578c: 7f ff ff 32 call 2005454 <rtems_fdisk_seg_read>
2005790: 96 10 00 1b mov %i3, %o3
sc->pages_desc * fd->block_size);
if (ret)
2005794: b0 92 20 00 orcc %o0, 0, %i0
2005798: 22 80 00 6a be,a 2005940 <rtems_fdisk_recover_block_mappings+0x304><== ALWAYS TAKEN
200579c: b4 10 20 00 clr %i2
{
rtems_fdisk_error ("recover-block-mappings:%02d-%03d: " \
20057a0: 40 00 76 c3 call 20232ac <strerror> <== NOT EXECUTED
20057a4: 01 00 00 00 nop <== NOT EXECUTED
20057a8: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
20057ac: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
20057b0: 94 10 00 10 mov %l0, %o2 <== NOT EXECUTED
20057b4: 11 00 80 c3 sethi %hi(0x2030c00), %o0 <== NOT EXECUTED
20057b8: 98 10 00 18 mov %i0, %o4 <== NOT EXECUTED
20057bc: 7f ff fe 6c call 200516c <rtems_fdisk_error> <== NOT EXECUTED
20057c0: 90 12 23 08 or %o0, 0x308, %o0 <== NOT EXECUTED
"read page desc failed: %s (%d)",
device, segment, strerror (ret), ret);
return ret;
20057c4: 81 c7 e0 08 ret <== NOT EXECUTED
20057c8: 81 e8 00 00 restore <== NOT EXECUTED
* If the page is active see if the block is with-in range and
* if the block is a duplicate.
*/
for (page = 0; page < sc->pages; page++, pd++)
{
if (rtems_fdisk_page_desc_erased (pd))
20057cc: 7f ff fd e4 call 2004f5c <rtems_fdisk_page_desc_erased>
20057d0: 90 10 00 1b mov %i3, %o0
20057d4: 80 8a 20 ff btst 0xff, %o0
20057d8: 22 80 00 2b be,a 2005884 <rtems_fdisk_recover_block_mappings+0x248><== NEVER TAKEN
20057dc: c2 16 e0 02 lduh [ %i3 + 2 ], %g1 <== NOT EXECUTED
rtems_fdisk_seg_blank_check_page (const rtems_flashdisk* fd,
rtems_fdisk_segment_ctl* sc,
uint32_t page)
{
return rtems_fdisk_seg_blank_check (fd, sc,
page * fd->block_size, fd->block_size);
20057e0: f0 07 60 14 ld [ %i5 + 0x14 ], %i0
if (rtems_fdisk_page_desc_erased (pd))
{
/*
* Is the page erased ?
*/
ret = rtems_fdisk_seg_blank_check_page (fd, sc,
20057e4: d0 07 20 18 ld [ %i4 + 0x18 ], %o0
static int
rtems_fdisk_seg_blank_check_page (const rtems_flashdisk* fd,
rtems_fdisk_segment_ctl* sc,
uint32_t page)
{
return rtems_fdisk_seg_blank_check (fd, sc,
20057e8: 92 10 00 18 mov %i0, %o1
20057ec: 7f ff f3 6a call 2002594 <.umul>
20057f0: 90 06 80 08 add %i2, %o0, %o0
20057f4: 92 10 00 1c mov %i4, %o1
20057f8: 94 10 00 08 mov %o0, %o2
20057fc: 96 10 00 18 mov %i0, %o3
2005800: 7f ff ff 37 call 20054dc <rtems_fdisk_seg_blank_check>
2005804: 90 10 00 1d mov %i5, %o0
* Is the page erased ?
*/
ret = rtems_fdisk_seg_blank_check_page (fd, sc,
page + sc->pages_desc);
if (ret == 0)
2005808: 80 a2 20 00 cmp %o0, 0
200580c: 32 80 00 06 bne,a 2005824 <rtems_fdisk_recover_block_mappings+0x1e8><== NEVER TAKEN
2005810: da 06 e0 04 ld [ %i3 + 4 ], %o5 <== NOT EXECUTED
{
++fd->erased_blocks;
2005814: c2 07 60 28 ld [ %i5 + 0x28 ], %g1
2005818: 82 00 60 01 inc %g1
200581c: 10 80 00 47 b 2005938 <rtems_fdisk_recover_block_mappings+0x2fc>
2005820: c2 27 60 28 st %g1, [ %i5 + 0x28 ]
}
else
{
#if RTEMS_FDISK_TRACE
rtems_fdisk_warning (fd, "page not blank: %d-%d-%d",
2005824: 92 10 00 16 mov %l6, %o1 <== NOT EXECUTED
2005828: 94 10 00 19 mov %i1, %o2 <== NOT EXECUTED
200582c: 96 10 00 10 mov %l0, %o3 <== NOT EXECUTED
2005830: 98 10 00 1a mov %i2, %o4 <== NOT EXECUTED
2005834: 7f ff fe 2e call 20050ec <rtems_fdisk_warning> <== NOT EXECUTED
2005838: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
* Set the flags. Setting means clear the bit to 0.
*/
static void
rtems_fdisk_page_desc_set_flags (rtems_fdisk_page_desc* pd, uint16_t flags)
{
pd->flags &= ~flags;
200583c: c2 16 e0 02 lduh [ %i3 + 2 ], %g1 <== NOT EXECUTED
rtems_fdisk_warning (fd, "page not blank: %d-%d-%d",
device, segment, page, pd->block);
#endif
rtems_fdisk_page_desc_set_flags (pd, RTEMS_FDISK_PAGE_USED);
ret = rtems_fdisk_seg_write_page_desc (fd, sc,
2005840: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
* Set the flags. Setting means clear the bit to 0.
*/
static void
rtems_fdisk_page_desc_set_flags (rtems_fdisk_page_desc* pd, uint16_t flags)
{
pd->flags &= ~flags;
2005844: 82 08 7f fd and %g1, -3, %g1 <== NOT EXECUTED
rtems_fdisk_warning (fd, "page not blank: %d-%d-%d",
device, segment, page, pd->block);
#endif
rtems_fdisk_page_desc_set_flags (pd, RTEMS_FDISK_PAGE_USED);
ret = rtems_fdisk_seg_write_page_desc (fd, sc,
2005848: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
* Set the flags. Setting means clear the bit to 0.
*/
static void
rtems_fdisk_page_desc_set_flags (rtems_fdisk_page_desc* pd, uint16_t flags)
{
pd->flags &= ~flags;
200584c: c2 36 e0 02 sth %g1, [ %i3 + 2 ] <== NOT EXECUTED
rtems_fdisk_warning (fd, "page not blank: %d-%d-%d",
device, segment, page, pd->block);
#endif
rtems_fdisk_page_desc_set_flags (pd, RTEMS_FDISK_PAGE_USED);
ret = rtems_fdisk_seg_write_page_desc (fd, sc,
2005850: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED
2005854: 7f ff ff 69 call 20055f8 <rtems_fdisk_seg_write_page_desc><== NOT EXECUTED
2005858: 96 10 00 1b mov %i3, %o3 <== NOT EXECUTED
page, pd);
if (ret)
200585c: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2005860: 22 80 00 0d be,a 2005894 <rtems_fdisk_recover_block_mappings+0x258><== NOT EXECUTED
2005864: c2 07 20 20 ld [ %i4 + 0x20 ], %g1 <== NOT EXECUTED
{
rtems_fdisk_error ("forcing page to used failed: %d-%d-%d",
2005868: 90 10 00 17 mov %l7, %o0 <== NOT EXECUTED
200586c: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
2005870: 94 10 00 10 mov %l0, %o2 <== NOT EXECUTED
2005874: 7f ff fe 3e call 200516c <rtems_fdisk_error> <== NOT EXECUTED
2005878: 96 10 00 1a mov %i2, %o3 <== NOT EXECUTED
}
else
{
if (rtems_fdisk_page_desc_flags_set (pd, RTEMS_FDISK_PAGE_USED))
{
sc->pages_used++;
200587c: 10 80 00 06 b 2005894 <rtems_fdisk_recover_block_mappings+0x258><== NOT EXECUTED
2005880: c2 07 20 20 ld [ %i4 + 0x20 ], %g1 <== NOT EXECUTED
sc->pages_used++;
}
}
else
{
if (rtems_fdisk_page_desc_flags_set (pd, RTEMS_FDISK_PAGE_USED))
2005884: 80 88 60 02 btst 2, %g1 <== NOT EXECUTED
2005888: 12 80 00 06 bne 20058a0 <rtems_fdisk_recover_block_mappings+0x264><== NOT EXECUTED
200588c: 80 88 60 01 btst 1, %g1 <== NOT EXECUTED
{
sc->pages_used++;
2005890: c2 07 20 20 ld [ %i4 + 0x20 ], %g1 <== NOT EXECUTED
2005894: 82 00 60 01 inc %g1 <== NOT EXECUTED
2005898: 10 80 00 28 b 2005938 <rtems_fdisk_recover_block_mappings+0x2fc><== NOT EXECUTED
200589c: c2 27 20 20 st %g1, [ %i4 + 0x20 ] <== NOT EXECUTED
}
else if (rtems_fdisk_page_desc_flags_set (pd, RTEMS_FDISK_PAGE_ACTIVE))
20058a0: 32 80 00 24 bne,a 2005930 <rtems_fdisk_recover_block_mappings+0x2f4><== NOT EXECUTED
20058a4: c2 07 20 24 ld [ %i4 + 0x24 ], %g1 <== NOT EXECUTED
{
if (pd->block >= fd->block_count)
20058a8: da 06 e0 04 ld [ %i3 + 4 ], %o5 <== NOT EXECUTED
20058ac: c2 07 60 1c ld [ %i5 + 0x1c ], %g1 <== NOT EXECUTED
20058b0: 80 a3 40 01 cmp %o5, %g1 <== NOT EXECUTED
20058b4: 2a 80 00 0a bcs,a 20058dc <rtems_fdisk_recover_block_mappings+0x2a0><== NOT EXECUTED
20058b8: c2 07 60 18 ld [ %i5 + 0x18 ], %g1 <== NOT EXECUTED
{
#if RTEMS_FDISK_TRACE
rtems_fdisk_warning (fd,
20058bc: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
20058c0: 92 10 00 15 mov %l5, %o1 <== NOT EXECUTED
20058c4: 94 10 00 19 mov %i1, %o2 <== NOT EXECUTED
20058c8: 96 10 00 10 mov %l0, %o3 <== NOT EXECUTED
20058cc: 7f ff fe 08 call 20050ec <rtems_fdisk_warning> <== NOT EXECUTED
20058d0: 98 10 00 1a mov %i2, %o4 <== NOT EXECUTED
*/
sc->pages_active++;
}
}
else
sc->pages_bad++;
20058d4: 10 80 00 17 b 2005930 <rtems_fdisk_recover_block_mappings+0x2f4><== NOT EXECUTED
20058d8: c2 07 20 24 ld [ %i4 + 0x24 ], %g1 <== NOT EXECUTED
"invalid block number: %d-%d-%d: block: %d",
device, segment, page, pd->block);
#endif
sc->pages_bad++;
}
else if (fd->blocks[pd->block].segment)
20058dc: 9b 2b 60 03 sll %o5, 3, %o5 <== NOT EXECUTED
20058e0: c4 00 40 0d ld [ %g1 + %o5 ], %g2 <== NOT EXECUTED
20058e4: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED
20058e8: 02 80 00 0c be 2005918 <rtems_fdisk_recover_block_mappings+0x2dc><== NOT EXECUTED
20058ec: 86 00 40 0d add %g1, %o5, %g3 <== NOT EXECUTED
* each block so we can tell which is the later block when
* duplicates appear. A power down with a failed wirte could cause
* a duplicate.
*/
const rtems_fdisk_segment_ctl* bsc = fd->blocks[pd->block].segment;
rtems_fdisk_error ("duplicate block: %d-%d-%d: " \
20058f0: d2 00 a0 08 ld [ %g2 + 8 ], %o1 <== NOT EXECUTED
20058f4: d4 00 a0 0c ld [ %g2 + 0xc ], %o2 <== NOT EXECUTED
20058f8: d6 00 e0 04 ld [ %g3 + 4 ], %o3 <== NOT EXECUTED
20058fc: 90 10 00 14 mov %l4, %o0 <== NOT EXECUTED
2005900: f4 23 a0 5c st %i2, [ %sp + 0x5c ] <== NOT EXECUTED
2005904: 98 10 00 19 mov %i1, %o4 <== NOT EXECUTED
2005908: 7f ff fe 19 call 200516c <rtems_fdisk_error> <== NOT EXECUTED
200590c: 9a 10 00 10 mov %l0, %o5 <== NOT EXECUTED
*/
sc->pages_active++;
}
}
else
sc->pages_bad++;
2005910: 10 80 00 08 b 2005930 <rtems_fdisk_recover_block_mappings+0x2f4><== NOT EXECUTED
2005914: c2 07 20 24 ld [ %i4 + 0x24 ], %g1 <== NOT EXECUTED
{
/**
* @todo
* Add start up crc checks here.
*/
fd->blocks[pd->block].segment = sc;
2005918: f8 20 40 0d st %i4, [ %g1 + %o5 ] <== NOT EXECUTED
fd->blocks[pd->block].page = page;
/*
* The page is active.
*/
sc->pages_active++;
200591c: c2 07 20 1c ld [ %i4 + 0x1c ], %g1 <== NOT EXECUTED
/**
* @todo
* Add start up crc checks here.
*/
fd->blocks[pd->block].segment = sc;
fd->blocks[pd->block].page = page;
2005920: f4 20 e0 04 st %i2, [ %g3 + 4 ] <== NOT EXECUTED
/*
* The page is active.
*/
sc->pages_active++;
2005924: 82 00 60 01 inc %g1 <== NOT EXECUTED
2005928: 10 80 00 04 b 2005938 <rtems_fdisk_recover_block_mappings+0x2fc><== NOT EXECUTED
200592c: c2 27 20 1c st %g1, [ %i4 + 0x1c ] <== NOT EXECUTED
}
}
else
sc->pages_bad++;
2005930: 82 00 60 01 inc %g1 <== NOT EXECUTED
2005934: c2 27 20 24 st %g1, [ %i4 + 0x24 ] <== NOT EXECUTED
* are active and how many are used.
*
* If the page is active see if the block is with-in range and
* if the block is a duplicate.
*/
for (page = 0; page < sc->pages; page++, pd++)
2005938: b4 06 a0 01 inc %i2
200593c: b6 06 e0 08 add %i3, 8, %i3
2005940: c2 07 20 14 ld [ %i4 + 0x14 ], %g1
2005944: 80 a6 80 01 cmp %i2, %g1
2005948: 0a bf ff a1 bcs 20057cc <rtems_fdisk_recover_block_mappings+0x190>
200594c: 90 10 00 1d mov %i5, %o0
}
/*
* Place the segment on to the correct queue.
*/
rtems_fdisk_queue_segment (fd, sc);
2005950: 92 10 00 1c mov %i4, %o1
2005954: 7f ff fe 63 call 20052e0 <rtems_fdisk_queue_segment>
2005958: a0 04 20 01 inc %l0
200595c: 10 80 00 03 b 2005968 <rtems_fdisk_recover_block_mappings+0x32c>
2005960: a4 04 a0 30 add %l2, 0x30, %l2
/*
* Scan each segment or each device recovering the valid pages.
*/
fd->erased_blocks = 0;
fd->starvation_threshold = 0;
for (device = 0; device < fd->device_count; device++)
2005964: a0 10 20 00 clr %l0
{
uint32_t segment;
for (segment = 0; segment < fd->devices[device].segment_count; segment++)
2005968: c2 07 60 2c ld [ %i5 + 0x2c ], %g1
200596c: 84 00 40 11 add %g1, %l1, %g2
2005970: c4 00 a0 04 ld [ %g2 + 4 ], %g2
2005974: 80 a4 00 02 cmp %l0, %g2
2005978: 2a bf ff 53 bcs,a 20056c4 <rtems_fdisk_recover_block_mappings+0x88>
200597c: f8 00 40 11 ld [ %g1 + %l1 ], %i4
/*
* Scan each segment or each device recovering the valid pages.
*/
fd->erased_blocks = 0;
fd->starvation_threshold = 0;
for (device = 0; device < fd->device_count; device++)
2005980: b2 06 60 01 inc %i1
2005984: a2 04 60 0c add %l1, 0xc, %l1
2005988: c2 07 60 30 ld [ %i5 + 0x30 ], %g1
200598c: 80 a6 40 01 cmp %i1, %g1
2005990: 0a bf ff f5 bcs 2005964 <rtems_fdisk_recover_block_mappings+0x328>
2005994: a4 10 20 00 clr %l2
rtems_fdisk_queue_segment (fd, sc);
}
}
return 0;
}
2005998: 81 c7 e0 08 ret
200599c: 91 e8 20 00 restore %g0, 0, %o0
02005a0c <rtems_fdisk_recycle_segment>:
static int
rtems_fdisk_recycle_segment (rtems_flashdisk* fd,
rtems_fdisk_segment_ctl* ssc,
rtems_fdisk_segment_ctl* dsc,
uint32_t *pages)
{
2005a0c: 9d e3 bf 80 save %sp, -128, %sp
int ret;
uint32_t spage;
uint32_t used = 0;
2005a10: a4 10 20 00 clr %l2
/*
* Get new destination segment if necessary.
*/
dst_pages = rtems_fdisk_seg_pages_available (dsc);
if (dst_pages == 0)
dsc = rtems_fdisk_seg_most_available (&fd->available);
2005a14: 82 06 20 34 add %i0, 0x34, %g1
static int
rtems_fdisk_recycle_segment (rtems_flashdisk* fd,
rtems_fdisk_segment_ctl* ssc,
rtems_fdisk_segment_ctl* dsc,
uint32_t *pages)
{
2005a18: aa 10 00 19 mov %i1, %l5
2005a1c: a2 10 00 1a mov %i2, %l1
int ret;
uint32_t spage;
uint32_t used = 0;
uint32_t active = 0;
2005a20: c0 27 bf fc clr [ %fp + -4 ]
for (spage = 0; spage < ssc->pages; spage++)
2005a24: b8 10 20 00 clr %i4
2005a28: 10 80 00 c2 b 2005d30 <rtems_fdisk_recycle_segment+0x324>
2005a2c: c2 27 bf f8 st %g1, [ %fp + -8 ]
rtems_fdisk_segment_queue_push_tail (&fd->available, sc);
}
}
static int
rtems_fdisk_recycle_segment (rtems_flashdisk* fd,
2005a30: ad 2f 20 03 sll %i4, 3, %l6
for (spage = 0; spage < ssc->pages; spage++)
{
rtems_fdisk_page_desc* spd = &ssc->page_descriptors[spage];
if (!dsc && ssc->pages_active > 0)
2005a34: 80 a4 60 00 cmp %l1, 0
2005a38: 12 80 00 0b bne 2005a64 <rtems_fdisk_recycle_segment+0x58>
2005a3c: a0 05 c0 16 add %l7, %l6, %l0
2005a40: c6 05 60 1c ld [ %l5 + 0x1c ], %g3
2005a44: 80 a0 e0 00 cmp %g3, 0
2005a48: 22 80 00 08 be,a 2005a68 <rtems_fdisk_recycle_segment+0x5c><== ALWAYS TAKEN
2005a4c: c6 14 20 02 lduh [ %l0 + 2 ], %g3
{
rtems_fdisk_error ("recycle: no available dst segment");
2005a50: 11 00 80 c3 sethi %hi(0x2030c00), %o0 <== NOT EXECUTED
2005a54: 7f ff fd c6 call 200516c <rtems_fdisk_error> <== NOT EXECUTED
2005a58: 90 12 23 f8 or %o0, 0x3f8, %o0 ! 2030ff8 <__FUNCTION__.7063+0x7d8><== NOT EXECUTED
dsc->device, dsc->segment,
rtems_fdisk_seg_pages_available (dsc));
dsc->failed = true;
rtems_fdisk_queue_segment (fd, dsc);
rtems_fdisk_segment_queue_push_head (&fd->used, ssc);
return EIO;
2005a5c: 10 80 00 ca b 2005d84 <rtems_fdisk_recycle_segment+0x378> <== NOT EXECUTED
2005a60: a8 10 20 05 mov 5, %l4 <== NOT EXECUTED
* only set a flag by changing it from 1 to 0.
*/
static bool
rtems_fdisk_page_desc_flags_set (rtems_fdisk_page_desc* pd, uint16_t flags)
{
return (pd->flags & flags) == 0 ? true : false;
2005a64: c6 14 20 02 lduh [ %l0 + 2 ], %g3
{
rtems_fdisk_error ("recycle: no available dst segment");
return EIO;
}
if (rtems_fdisk_page_desc_flags_set (spd, RTEMS_FDISK_PAGE_ACTIVE) &&
2005a68: 80 88 e0 01 btst 1, %g3
2005a6c: 12 80 00 a8 bne 2005d0c <rtems_fdisk_recycle_segment+0x300><== NEVER TAKEN
2005a70: 80 88 e0 02 btst 2, %g3
2005a74: 02 80 00 a6 be 2005d0c <rtems_fdisk_recycle_segment+0x300>
2005a78: ba 10 20 00 clr %i5
* Find the next available page in a segment.
*/
static uint32_t
rtems_fdisk_seg_next_available_page (rtems_fdisk_segment_ctl* sc)
{
rtems_fdisk_page_desc* pd = &sc->page_descriptors[0];
2005a7c: e6 04 60 10 ld [ %l1 + 0x10 ], %l3
uint32_t page;
for (page = 0; page < sc->pages; page++, pd++)
2005a80: 10 80 00 08 b 2005aa0 <rtems_fdisk_recycle_segment+0x94>
2005a84: e8 04 60 14 ld [ %l1 + 0x14 ], %l4
if (rtems_fdisk_page_desc_erased (pd))
2005a88: 7f ff fd 35 call 2004f5c <rtems_fdisk_page_desc_erased>
2005a8c: 01 00 00 00 nop
2005a90: 80 8a 20 ff btst 0xff, %o0
2005a94: 12 80 00 08 bne 2005ab4 <rtems_fdisk_recycle_segment+0xa8>
2005a98: c2 07 bf fc ld [ %fp + -4 ], %g1
rtems_fdisk_seg_next_available_page (rtems_fdisk_segment_ctl* sc)
{
rtems_fdisk_page_desc* pd = &sc->page_descriptors[0];
uint32_t page;
for (page = 0; page < sc->pages; page++, pd++)
2005a9c: ba 07 60 01 inc %i5
rtems_fdisk_segment_queue_push_tail (&fd->available, sc);
}
}
static int
rtems_fdisk_recycle_segment (rtems_flashdisk* fd,
2005aa0: 91 2f 60 03 sll %i5, 3, %o0
rtems_fdisk_seg_next_available_page (rtems_fdisk_segment_ctl* sc)
{
rtems_fdisk_page_desc* pd = &sc->page_descriptors[0];
uint32_t page;
for (page = 0; page < sc->pages; page++, pd++)
2005aa4: 80 a7 40 14 cmp %i5, %l4
2005aa8: 12 bf ff f8 bne 2005a88 <rtems_fdisk_recycle_segment+0x7c><== ALWAYS TAKEN
2005aac: 90 04 c0 08 add %l3, %o0, %o0
uint32_t dpage;
dpage = rtems_fdisk_seg_next_available_page (dsc);
dpd = &dsc->page_descriptors[dpage];
active++;
2005ab0: c2 07 bf fc ld [ %fp + -4 ], %g1 <== NOT EXECUTED
uint32_t dst_pages;
rtems_fdisk_page_desc* dpd;
uint32_t dpage;
dpage = rtems_fdisk_seg_next_available_page (dsc);
dpd = &dsc->page_descriptors[dpage];
2005ab4: b3 2f 60 03 sll %i5, 3, %i1
active++;
2005ab8: 82 00 60 01 inc %g1
2005abc: c2 27 bf fc st %g1, [ %fp + -4 ]
if (dpage >= dsc->pages)
2005ac0: 80 a7 40 14 cmp %i5, %l4
2005ac4: 0a 80 00 14 bcs 2005b14 <rtems_fdisk_recycle_segment+0x108><== ALWAYS TAKEN
2005ac8: b4 04 c0 19 add %l3, %i1, %i2
{
rtems_fdisk_error ("recycle: %02d-%03d: " \
2005acc: 7f ff fd 2e call 2004f84 <rtems_fdisk_seg_pages_available><== NOT EXECUTED
2005ad0: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED
2005ad4: d2 04 60 08 ld [ %l1 + 8 ], %o1 <== NOT EXECUTED
2005ad8: d4 04 60 0c ld [ %l1 + 0xc ], %o2 <== NOT EXECUTED
2005adc: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
2005ae0: 11 00 80 c4 sethi %hi(0x2031000), %o0 <== NOT EXECUTED
2005ae4: 7f ff fd a2 call 200516c <rtems_fdisk_error> <== NOT EXECUTED
2005ae8: 90 12 20 20 or %o0, 0x20, %o0 ! 2031020 <__FUNCTION__.7063+0x800><== NOT EXECUTED
"no page desc available: %d",
dsc->device, dsc->segment,
rtems_fdisk_seg_pages_available (dsc));
dsc->failed = true;
2005aec: 86 10 20 01 mov 1, %g3 <== NOT EXECUTED
rtems_fdisk_queue_segment (fd, dsc);
2005af0: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
2005af4: 92 10 00 11 mov %l1, %o1 <== NOT EXECUTED
2005af8: 7f ff fd fa call 20052e0 <rtems_fdisk_queue_segment> <== NOT EXECUTED
2005afc: c6 24 60 28 st %g3, [ %l1 + 0x28 ] <== NOT EXECUTED
rtems_fdisk_segment_queue_push_head (&fd->used, ssc);
2005b00: 90 06 20 40 add %i0, 0x40, %o0 <== NOT EXECUTED
2005b04: 7f ff fc 77 call 2004ce0 <rtems_fdisk_segment_queue_push_head><== NOT EXECUTED
2005b08: 92 10 00 15 mov %l5, %o1 <== NOT EXECUTED
return EIO;
2005b0c: 10 80 00 9e b 2005d84 <rtems_fdisk_recycle_segment+0x378> <== NOT EXECUTED
2005b10: a8 10 20 05 mov 5, %l4 <== NOT EXECUTED
}
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd, "recycle: %02d-%03d-%03d=>%02d-%03d-%03d",
2005b14: da 04 60 08 ld [ %l1 + 8 ], %o5
2005b18: c6 04 60 0c ld [ %l1 + 0xc ], %g3
2005b1c: d4 05 60 08 ld [ %l5 + 8 ], %o2
2005b20: d6 05 60 0c ld [ %l5 + 0xc ], %o3
2005b24: c6 23 a0 5c st %g3, [ %sp + 0x5c ]
2005b28: 98 10 00 1c mov %i4, %o4
2005b2c: fa 23 a0 60 st %i5, [ %sp + 0x60 ]
2005b30: 90 10 00 18 mov %i0, %o0
2005b34: 13 00 80 c4 sethi %hi(0x2031000), %o1
2005b38: 7f ff fd 2d call 2004fec <rtems_fdisk_info>
2005b3c: 92 12 60 50 or %o1, 0x50, %o1 ! 2031050 <__FUNCTION__.7063+0x830>
ssc->device, ssc->segment, spage,
dsc->device, dsc->segment, dpage);
#endif
ret = rtems_fdisk_seg_copy_page (fd, ssc,
2005b40: c8 04 60 18 ld [ %l1 + 0x18 ], %g4
2005b44: c6 05 60 18 ld [ %l5 + 0x18 ], %g3
rtems_fdisk_segment_ctl* dst_sc,
uint32_t dst_page)
{
int ret;
#if RTEMS_FDISK_TRACE
rtems_fdisk_printf (fd, " seg-copy-page: %02d-%03d~%03d=>%02d-%03d~%03d",
2005b48: da 04 60 08 ld [ %l1 + 8 ], %o5
2005b4c: de 04 60 0c ld [ %l1 + 0xc ], %o7
2005b50: d4 05 60 08 ld [ %l5 + 8 ], %o2
2005b54: d6 05 60 0c ld [ %l5 + 0xc ], %o3
#if RTEMS_FDISK_TRACE
rtems_fdisk_info (fd, "recycle: %02d-%03d-%03d=>%02d-%03d-%03d",
ssc->device, ssc->segment, spage,
dsc->device, dsc->segment, dpage);
#endif
ret = rtems_fdisk_seg_copy_page (fd, ssc,
2005b58: 88 07 40 04 add %i5, %g4, %g4
2005b5c: 86 07 00 03 add %i4, %g3, %g3
rtems_fdisk_segment_ctl* dst_sc,
uint32_t dst_page)
{
int ret;
#if RTEMS_FDISK_TRACE
rtems_fdisk_printf (fd, " seg-copy-page: %02d-%03d~%03d=>%02d-%03d~%03d",
2005b60: c8 23 a0 60 st %g4, [ %sp + 0x60 ]
2005b64: 98 10 00 03 mov %g3, %o4
2005b68: c8 27 bf f0 st %g4, [ %fp + -16 ]
2005b6c: de 23 a0 5c st %o7, [ %sp + 0x5c ]
2005b70: c6 27 bf f4 st %g3, [ %fp + -12 ]
2005b74: 90 10 00 18 mov %i0, %o0
2005b78: 13 00 80 c4 sethi %hi(0x2031000), %o1
2005b7c: 7f ff fd 3c call 200506c <rtems_fdisk_printf>
2005b80: 92 12 60 78 or %o1, 0x78, %o1 ! 2031078 <__FUNCTION__.7063+0x858>
rtems_fdisk_seg_read_page (const rtems_flashdisk* fd,
rtems_fdisk_segment_ctl* sc,
uint32_t page,
void* buffer)
{
return rtems_fdisk_seg_read (fd, sc,
2005b84: c6 07 bf f4 ld [ %fp + -12 ], %g3
page * fd->block_size, buffer, fd->block_size);
2005b88: e8 06 20 14 ld [ %i0 + 0x14 ], %l4
rtems_fdisk_seg_read_page (const rtems_flashdisk* fd,
rtems_fdisk_segment_ctl* sc,
uint32_t page,
void* buffer)
{
return rtems_fdisk_seg_read (fd, sc,
2005b8c: 90 10 00 03 mov %g3, %o0
2005b90: 7f ff f2 81 call 2002594 <.umul>
2005b94: 92 10 00 14 mov %l4, %o1
2005b98: d6 06 20 68 ld [ %i0 + 0x68 ], %o3
2005b9c: 94 10 00 08 mov %o0, %o2
2005ba0: 98 10 00 14 mov %l4, %o4
2005ba4: 90 10 00 18 mov %i0, %o0
2005ba8: 7f ff fe 2b call 2005454 <rtems_fdisk_seg_read>
2005bac: 92 10 00 15 mov %l5, %o1
src_sc->device, src_sc->segment, src_page,
dst_sc->device, dst_sc->segment, dst_page);
#endif
ret = rtems_fdisk_seg_read_page (fd, src_sc, src_page,
fd->copy_buffer);
if (ret)
2005bb0: a8 92 20 00 orcc %o0, 0, %l4
2005bb4: 12 80 00 0a bne 2005bdc <rtems_fdisk_recycle_segment+0x1d0><== NEVER TAKEN
2005bb8: c8 07 bf f0 ld [ %fp + -16 ], %g4
return ret;
return rtems_fdisk_seg_write_page (fd, dst_sc, dst_page,
2005bbc: d6 06 20 68 ld [ %i0 + 0x68 ], %o3
2005bc0: 90 10 00 18 mov %i0, %o0
2005bc4: 92 10 00 11 mov %l1, %o1
2005bc8: 7f ff ff 76 call 20059a0 <rtems_fdisk_seg_write_page>
2005bcc: 94 10 00 04 mov %g4, %o2
#endif
ret = rtems_fdisk_seg_copy_page (fd, ssc,
spage + ssc->pages_desc,
dsc,
dpage + dsc->pages_desc);
if (ret)
2005bd0: a8 92 20 00 orcc %o0, 0, %l4
2005bd4: 22 80 00 0e be,a 2005c0c <rtems_fdisk_recycle_segment+0x200><== ALWAYS TAKEN
2005bd8: c6 05 c0 16 ld [ %l7 + %l6 ], %g3
{
rtems_fdisk_error ("recycle: %02d-%03d-%03d=>" \
2005bdc: e0 05 60 08 ld [ %l5 + 8 ], %l0 <== NOT EXECUTED
2005be0: f2 05 60 0c ld [ %l5 + 0xc ], %i1 <== NOT EXECUTED
2005be4: f4 04 60 08 ld [ %l1 + 8 ], %i2 <== NOT EXECUTED
2005be8: f6 04 60 0c ld [ %l1 + 0xc ], %i3 <== NOT EXECUTED
2005bec: 40 00 75 b0 call 20232ac <strerror> <== NOT EXECUTED
2005bf0: 90 10 00 14 mov %l4, %o0 <== NOT EXECUTED
2005bf4: fa 23 a0 5c st %i5, [ %sp + 0x5c ] <== NOT EXECUTED
2005bf8: d0 23 a0 60 st %o0, [ %sp + 0x60 ] <== NOT EXECUTED
2005bfc: e8 23 a0 64 st %l4, [ %sp + 0x64 ] <== NOT EXECUTED
2005c00: 11 00 80 c4 sethi %hi(0x2031000), %o0 <== NOT EXECUTED
2005c04: 10 80 00 17 b 2005c60 <rtems_fdisk_recycle_segment+0x254> <== NOT EXECUTED
2005c08: 90 12 20 a8 or %o0, 0xa8, %o0 ! 20310a8 <__FUNCTION__.7063+0x888><== NOT EXECUTED
return ret;
}
*dpd = *spd;
ret = rtems_fdisk_seg_write_page_desc (fd,
2005c0c: 90 10 00 18 mov %i0, %o0
rtems_fdisk_queue_segment (fd, dsc);
rtems_fdisk_segment_queue_push_head (&fd->used, ssc);
return ret;
}
*dpd = *spd;
2005c10: c6 24 c0 19 st %g3, [ %l3 + %i1 ]
2005c14: c6 04 20 04 ld [ %l0 + 4 ], %g3
ret = rtems_fdisk_seg_write_page_desc (fd,
2005c18: 92 10 00 11 mov %l1, %o1
rtems_fdisk_queue_segment (fd, dsc);
rtems_fdisk_segment_queue_push_head (&fd->used, ssc);
return ret;
}
*dpd = *spd;
2005c1c: c6 26 a0 04 st %g3, [ %i2 + 4 ]
ret = rtems_fdisk_seg_write_page_desc (fd,
2005c20: 94 10 00 1d mov %i5, %o2
2005c24: 7f ff fe 75 call 20055f8 <rtems_fdisk_seg_write_page_desc>
2005c28: 96 10 00 1a mov %i2, %o3
dsc,
dpage, dpd);
if (ret)
2005c2c: a8 92 20 00 orcc %o0, 0, %l4
2005c30: 22 80 00 1a be,a 2005c98 <rtems_fdisk_recycle_segment+0x28c><== ALWAYS TAKEN
2005c34: c6 04 60 1c ld [ %l1 + 0x1c ], %g3
{
rtems_fdisk_error ("recycle: %02d-%03d-%03d=>" \
2005c38: e0 05 60 08 ld [ %l5 + 8 ], %l0 <== NOT EXECUTED
2005c3c: f2 05 60 0c ld [ %l5 + 0xc ], %i1 <== NOT EXECUTED
2005c40: f4 04 60 08 ld [ %l1 + 8 ], %i2 <== NOT EXECUTED
2005c44: 40 00 75 9a call 20232ac <strerror> <== NOT EXECUTED
2005c48: f6 04 60 0c ld [ %l1 + 0xc ], %i3 <== NOT EXECUTED
2005c4c: fa 23 a0 5c st %i5, [ %sp + 0x5c ] <== NOT EXECUTED
2005c50: d0 23 a0 60 st %o0, [ %sp + 0x60 ] <== NOT EXECUTED
2005c54: e8 23 a0 64 st %l4, [ %sp + 0x64 ] <== NOT EXECUTED
2005c58: 11 00 80 c4 sethi %hi(0x2031000), %o0 <== NOT EXECUTED
2005c5c: 90 12 20 f0 or %o0, 0xf0, %o0 ! 20310f0 <__FUNCTION__.7063+0x8d0><== NOT EXECUTED
2005c60: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED
2005c64: 94 10 00 19 mov %i1, %o2 <== NOT EXECUTED
2005c68: 96 10 00 1c mov %i4, %o3 <== NOT EXECUTED
2005c6c: 98 10 00 1a mov %i2, %o4 <== NOT EXECUTED
2005c70: 7f ff fd 3f call 200516c <rtems_fdisk_error> <== NOT EXECUTED
2005c74: 9a 10 00 1b mov %i3, %o5 <== NOT EXECUTED
"%02d-%03d-%03d: copy pd failed: %s (%d)",
ssc->device, ssc->segment, spage,
dsc->device, dsc->segment, dpage,
strerror (ret), ret);
rtems_fdisk_queue_segment (fd, dsc);
2005c78: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
2005c7c: 7f ff fd 99 call 20052e0 <rtems_fdisk_queue_segment> <== NOT EXECUTED
2005c80: 92 10 00 11 mov %l1, %o1 <== NOT EXECUTED
rtems_fdisk_segment_queue_push_head (&fd->used, ssc);
2005c84: 90 06 20 40 add %i0, 0x40, %o0 <== NOT EXECUTED
2005c88: 7f ff fc 16 call 2004ce0 <rtems_fdisk_segment_queue_push_head><== NOT EXECUTED
2005c8c: 92 10 00 15 mov %l5, %o1 <== NOT EXECUTED
return ret;
2005c90: 81 c7 e0 08 ret <== NOT EXECUTED
2005c94: 91 e8 00 14 restore %g0, %l4, %o0 <== NOT EXECUTED
*/
ssc->pages_active--;
ssc->pages_used++;
fd->blocks[spd->block].segment = dsc;
2005c98: c8 06 20 18 ld [ %i0 + 0x18 ], %g4
rtems_fdisk_queue_segment (fd, dsc);
rtems_fdisk_segment_queue_push_head (&fd->used, ssc);
return ret;
}
dsc->pages_active++;
2005c9c: 86 00 e0 01 inc %g3
2005ca0: c6 24 60 1c st %g3, [ %l1 + 0x1c ]
* segment will be erased. Power down could be a problem.
* We do the stats to make sure everything is as it should
* be.
*/
ssc->pages_active--;
2005ca4: c6 05 60 1c ld [ %l5 + 0x1c ], %g3
fd->blocks[spd->block].page = dpage;
/*
* Place the segment on to the correct queue.
*/
rtems_fdisk_queue_segment (fd, dsc);
2005ca8: 90 10 00 18 mov %i0, %o0
* segment will be erased. Power down could be a problem.
* We do the stats to make sure everything is as it should
* be.
*/
ssc->pages_active--;
2005cac: 86 00 ff ff add %g3, -1, %g3
2005cb0: c6 25 60 1c st %g3, [ %l5 + 0x1c ]
ssc->pages_used++;
2005cb4: c6 05 60 20 ld [ %l5 + 0x20 ], %g3
2005cb8: 86 00 e0 01 inc %g3
2005cbc: c6 25 60 20 st %g3, [ %l5 + 0x20 ]
fd->blocks[spd->block].segment = dsc;
2005cc0: c6 04 20 04 ld [ %l0 + 4 ], %g3
2005cc4: 87 28 e0 03 sll %g3, 3, %g3
2005cc8: 9e 01 00 03 add %g4, %g3, %o7
2005ccc: e2 21 00 03 st %l1, [ %g4 + %g3 ]
fd->blocks[spd->block].page = dpage;
2005cd0: fa 23 e0 04 st %i5, [ %o7 + 4 ]
/*
* Place the segment on to the correct queue.
*/
rtems_fdisk_queue_segment (fd, dsc);
2005cd4: 7f ff fd 83 call 20052e0 <rtems_fdisk_queue_segment>
2005cd8: 92 10 00 11 mov %l1, %o1
/*
* Get new destination segment if necessary.
*/
dst_pages = rtems_fdisk_seg_pages_available (dsc);
2005cdc: 7f ff fc aa call 2004f84 <rtems_fdisk_seg_pages_available>
2005ce0: 90 10 00 11 mov %l1, %o0
if (dst_pages == 0)
2005ce4: 80 a2 20 00 cmp %o0, 0
2005ce8: 32 80 00 06 bne,a 2005d00 <rtems_fdisk_recycle_segment+0x2f4>
2005cec: c6 06 c0 00 ld [ %i3 ], %g3
dsc = rtems_fdisk_seg_most_available (&fd->available);
2005cf0: 7f ff fc ad call 2004fa4 <rtems_fdisk_seg_most_available>
2005cf4: d0 07 bf f8 ld [ %fp + -8 ], %o0
2005cf8: a2 10 00 08 mov %o0, %l1
(*pages)--;
2005cfc: c6 06 c0 00 ld [ %i3 ], %g3
2005d00: 86 00 ff ff add %g3, -1, %g3
return EIO;
}
if (rtems_fdisk_page_desc_flags_set (spd, RTEMS_FDISK_PAGE_ACTIVE) &&
!rtems_fdisk_page_desc_flags_set (spd, RTEMS_FDISK_PAGE_USED))
{
2005d04: 10 80 00 0a b 2005d2c <rtems_fdisk_recycle_segment+0x320>
2005d08: c6 26 c0 00 st %g3, [ %i3 ]
if (dst_pages == 0)
dsc = rtems_fdisk_seg_most_available (&fd->available);
(*pages)--;
}
else if (rtems_fdisk_page_desc_erased (spd))
2005d0c: 7f ff fc 94 call 2004f5c <rtems_fdisk_page_desc_erased>
2005d10: 90 10 00 10 mov %l0, %o0
2005d14: 80 8a 20 ff btst 0xff, %o0
2005d18: 22 80 00 05 be,a 2005d2c <rtems_fdisk_recycle_segment+0x320><== ALWAYS TAKEN
2005d1c: a4 04 a0 01 inc %l2
{
--fd->erased_blocks;
2005d20: c6 06 20 28 ld [ %i0 + 0x28 ], %g3 <== NOT EXECUTED
2005d24: 86 00 ff ff add %g3, -1, %g3 <== NOT EXECUTED
2005d28: c6 26 20 28 st %g3, [ %i0 + 0x28 ] <== NOT EXECUTED
int ret;
uint32_t spage;
uint32_t used = 0;
uint32_t active = 0;
for (spage = 0; spage < ssc->pages; spage++)
2005d2c: b8 07 20 01 inc %i4
2005d30: c6 05 60 14 ld [ %l5 + 0x14 ], %g3
2005d34: 80 a7 00 03 cmp %i4, %g3
2005d38: 2a bf ff 3e bcs,a 2005a30 <rtems_fdisk_recycle_segment+0x24>
2005d3c: ee 05 60 10 ld [ %l5 + 0x10 ], %l7
used++;
}
}
#if RTEMS_FDISK_TRACE
rtems_fdisk_printf (fd, "ssc end: %d-%d: p=%ld, a=%ld, u=%ld",
2005d40: d4 05 60 08 ld [ %l5 + 8 ], %o2
2005d44: d6 05 60 0c ld [ %l5 + 0xc ], %o3
2005d48: da 07 bf fc ld [ %fp + -4 ], %o5
2005d4c: e4 23 a0 5c st %l2, [ %sp + 0x5c ]
2005d50: 90 10 00 18 mov %i0, %o0
2005d54: 13 00 80 c4 sethi %hi(0x2031000), %o1
2005d58: 98 10 00 1b mov %i3, %o4
2005d5c: 7f ff fc c4 call 200506c <rtems_fdisk_printf>
2005d60: 92 12 61 38 or %o1, 0x138, %o1
ssc->device, ssc->segment,
pages, active, used);
#endif
if (ssc->pages_active != 0)
2005d64: d2 05 60 1c ld [ %l5 + 0x1c ], %o1
2005d68: 80 a2 60 00 cmp %o1, 0
2005d6c: 02 80 00 04 be 2005d7c <rtems_fdisk_recycle_segment+0x370><== ALWAYS TAKEN
2005d70: 11 00 80 c4 sethi %hi(0x2031000), %o0
{
rtems_fdisk_error ("compacting: ssc pages not 0: %d",
2005d74: 7f ff fc fe call 200516c <rtems_fdisk_error> <== NOT EXECUTED
2005d78: 90 12 21 60 or %o0, 0x160, %o0 ! 2031160 <__FUNCTION__.7063+0x940><== NOT EXECUTED
ssc->pages_active);
}
ret = rtems_fdisk_erase_segment (fd, ssc);
2005d7c: 7f ff fd 19 call 20051e0 <rtems_fdisk_erase_segment>
2005d80: 93 e8 00 15 restore %g0, %l5, %o1
return ret;
}
2005d84: b0 10 00 14 mov %l4, %i0 <== NOT EXECUTED
2005d88: 81 c7 e0 08 ret <== NOT EXECUTED
2005d8c: 81 e8 00 00 restore <== NOT EXECUTED
02005560 <rtems_fdisk_seg_write>:
rtems_fdisk_seg_write (const rtems_flashdisk* fd,
rtems_fdisk_segment_ctl* sc,
uint32_t offset,
const void* buffer,
uint32_t size)
{
2005560: 9d e3 bf a0 save %sp, -96, %sp
int ret;
uint32_t device;
uint32_t segment;
const rtems_fdisk_segment_desc* sd;
const rtems_fdisk_driver_handlers* ops;
device = sc->device;
2005564: e0 06 60 08 ld [ %i1 + 8 ], %l0
segment = sc->segment;
2005568: fa 06 60 0c ld [ %i1 + 0xc ], %i5
static const rtems_fdisk_segment_desc*
rtems_fdisk_seg_descriptor (const rtems_flashdisk* fd,
uint32_t device,
uint32_t segment)
{
return fd->devices[device].segments[segment].descriptor;
200556c: 85 2c 20 04 sll %l0, 4, %g2
2005570: 83 2c 20 02 sll %l0, 2, %g1
2005574: 82 20 80 01 sub %g2, %g1, %g1
2005578: c4 06 20 2c ld [ %i0 + 0x2c ], %g2
200557c: 89 2f 60 06 sll %i5, 6, %g4
2005580: 86 00 80 01 add %g2, %g1, %g3
2005584: c4 00 80 01 ld [ %g2 + %g1 ], %g2
2005588: 83 2f 60 04 sll %i5, 4, %g1
200558c: 82 21 00 01 sub %g4, %g1, %g1
2005590: 82 00 80 01 add %g2, %g1, %g1
2005594: e2 00 60 04 ld [ %g1 + 4 ], %l1
const rtems_fdisk_segment_desc* sd;
const rtems_fdisk_driver_handlers* ops;
device = sc->device;
segment = sc->segment;
sd = rtems_fdisk_seg_descriptor (fd, device, segment);
ops = fd->devices[device].descriptor->flash_ops;
2005598: c2 00 e0 08 ld [ %g3 + 8 ], %g1
#if RTEMS_FDISK_TRACE
rtems_fdisk_printf (fd, " seg-write: %02d-%03d: o=%08x s=%d",
200559c: 90 10 00 18 mov %i0, %o0
const rtems_fdisk_segment_desc* sd;
const rtems_fdisk_driver_handlers* ops;
device = sc->device;
segment = sc->segment;
sd = rtems_fdisk_seg_descriptor (fd, device, segment);
ops = fd->devices[device].descriptor->flash_ops;
20055a0: e4 00 60 08 ld [ %g1 + 8 ], %l2
#if RTEMS_FDISK_TRACE
rtems_fdisk_printf (fd, " seg-write: %02d-%03d: o=%08x s=%d",
20055a4: 94 10 00 10 mov %l0, %o2
20055a8: 96 10 00 1d mov %i5, %o3
20055ac: 98 10 00 1a mov %i2, %o4
20055b0: 9a 10 00 1c mov %i4, %o5
20055b4: 13 00 80 c3 sethi %hi(0x2030c00), %o1
20055b8: 7f ff fe ad call 200506c <rtems_fdisk_printf>
20055bc: 92 12 62 b8 or %o1, 0x2b8, %o1 ! 2030eb8 <__FUNCTION__.7063+0x698>
device, segment, offset, size);
#endif
ret = ops->write (sd, device, segment, offset, buffer, size);
20055c0: c2 04 a0 04 ld [ %l2 + 4 ], %g1
20055c4: 90 10 00 11 mov %l1, %o0
20055c8: 92 10 00 10 mov %l0, %o1
20055cc: 94 10 00 1d mov %i5, %o2
20055d0: 96 10 00 1a mov %i2, %o3
20055d4: 98 10 00 1b mov %i3, %o4
20055d8: 9f c0 40 00 call %g1
20055dc: 9a 10 00 1c mov %i4, %o5
if (ret)
20055e0: b0 92 20 00 orcc %o0, 0, %i0
20055e4: 02 80 00 03 be 20055f0 <rtems_fdisk_seg_write+0x90> <== ALWAYS TAKEN
20055e8: 82 10 20 01 mov 1, %g1
sc->failed = true;
20055ec: c2 26 60 28 st %g1, [ %i1 + 0x28 ] <== NOT EXECUTED
return ret;
}
20055f0: 81 c7 e0 08 ret
20055f4: 81 e8 00 00 restore
020059a0 <rtems_fdisk_seg_write_page>:
static int
rtems_fdisk_seg_write_page (rtems_flashdisk* fd,
rtems_fdisk_segment_ctl* sc,
uint32_t page,
const void* buffer)
{
20059a0: 9d e3 bf a0 save %sp, -96, %sp
if ((fd->flags & RTEMS_FDISK_BLANK_CHECK_BEFORE_WRITE))
20059a4: c2 06 20 08 ld [ %i0 + 8 ], %g1
20059a8: 80 88 60 08 btst 8, %g1
20059ac: 32 80 00 0b bne,a 20059d8 <rtems_fdisk_seg_write_page+0x38><== ALWAYS TAKEN
20059b0: fa 06 20 14 ld [ %i0 + 0x14 ], %i5
{
int ret = rtems_fdisk_seg_blank_check_page (fd, sc, page);
if (ret)
return ret;
}
--fd->erased_blocks;
20059b4: c2 06 20 28 ld [ %i0 + 0x28 ], %g1 <== NOT EXECUTED
return rtems_fdisk_seg_write (fd, sc,
page * fd->block_size, buffer, fd->block_size);
20059b8: f8 06 20 14 ld [ %i0 + 0x14 ], %i4
{
int ret = rtems_fdisk_seg_blank_check_page (fd, sc, page);
if (ret)
return ret;
}
--fd->erased_blocks;
20059bc: 82 00 7f ff add %g1, -1, %g1
return rtems_fdisk_seg_write (fd, sc,
20059c0: 90 10 00 1a mov %i2, %o0
{
int ret = rtems_fdisk_seg_blank_check_page (fd, sc, page);
if (ret)
return ret;
}
--fd->erased_blocks;
20059c4: c2 26 20 28 st %g1, [ %i0 + 0x28 ]
return rtems_fdisk_seg_write (fd, sc,
20059c8: 7f ff f2 f3 call 2002594 <.umul>
20059cc: 92 10 00 1c mov %i4, %o1
20059d0: 7f ff fe e4 call 2005560 <rtems_fdisk_seg_write>
20059d4: 95 e8 00 08 restore %g0, %o0, %o2
static int
rtems_fdisk_seg_blank_check_page (const rtems_flashdisk* fd,
rtems_fdisk_segment_ctl* sc,
uint32_t page)
{
return rtems_fdisk_seg_blank_check (fd, sc,
20059d8: 90 10 00 1a mov %i2, %o0
20059dc: 7f ff f2 ee call 2002594 <.umul>
20059e0: 92 10 00 1d mov %i5, %o1
20059e4: 92 10 00 19 mov %i1, %o1
20059e8: 94 10 00 08 mov %o0, %o2
20059ec: 96 10 00 1d mov %i5, %o3
20059f0: 7f ff fe bb call 20054dc <rtems_fdisk_seg_blank_check>
20059f4: 90 10 00 18 mov %i0, %o0
const void* buffer)
{
if ((fd->flags & RTEMS_FDISK_BLANK_CHECK_BEFORE_WRITE))
{
int ret = rtems_fdisk_seg_blank_check_page (fd, sc, page);
if (ret)
20059f8: 80 a2 20 00 cmp %o0, 0
20059fc: 22 bf ff ef be,a 20059b8 <rtems_fdisk_seg_write_page+0x18><== ALWAYS TAKEN
2005a00: c2 06 20 28 ld [ %i0 + 0x28 ], %g1
return ret;
}
--fd->erased_blocks;
return rtems_fdisk_seg_write (fd, sc,
page * fd->block_size, buffer, fd->block_size);
}
2005a04: 81 c7 e0 08 ret <== NOT EXECUTED
2005a08: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED
020055f8 <rtems_fdisk_seg_write_page_desc>:
static int
rtems_fdisk_seg_write_page_desc (const rtems_flashdisk* fd,
rtems_fdisk_segment_ctl* sc,
uint32_t page,
const rtems_fdisk_page_desc* page_desc)
{
20055f8: 9d e3 bf a0 save %sp, -96, %sp
uint32_t offset = page * sizeof (rtems_fdisk_page_desc);
if ((fd->flags & RTEMS_FDISK_BLANK_CHECK_BEFORE_WRITE))
20055fc: c2 06 20 08 ld [ %i0 + 8 ], %g1
2005600: 80 88 60 08 btst 8, %g1
2005604: 12 80 00 04 bne 2005614 <rtems_fdisk_seg_write_page_desc+0x1c><== ALWAYS TAKEN
2005608: b5 2e a0 03 sll %i2, 3, %i2
offset,
sizeof (rtems_fdisk_page_desc));
if (ret)
return ret;
}
return rtems_fdisk_seg_write (fd, sc, offset,
200560c: 7f ff ff d5 call 2005560 <rtems_fdisk_seg_write>
2005610: 99 e8 20 08 restore %g0, 8, %o4
const rtems_fdisk_page_desc* page_desc)
{
uint32_t offset = page * sizeof (rtems_fdisk_page_desc);
if ((fd->flags & RTEMS_FDISK_BLANK_CHECK_BEFORE_WRITE))
{
int ret = rtems_fdisk_seg_blank_check (fd, sc,
2005614: 90 10 00 18 mov %i0, %o0
2005618: 92 10 00 19 mov %i1, %o1
200561c: 94 10 00 1a mov %i2, %o2
2005620: 7f ff ff af call 20054dc <rtems_fdisk_seg_blank_check>
2005624: 96 10 20 08 mov 8, %o3
offset,
sizeof (rtems_fdisk_page_desc));
if (ret)
2005628: 80 a2 20 00 cmp %o0, 0
200562c: 02 bf ff f8 be 200560c <rtems_fdisk_seg_write_page_desc+0x14><== ALWAYS TAKEN
2005630: 01 00 00 00 nop
return ret;
}
return rtems_fdisk_seg_write (fd, sc, offset,
page_desc, sizeof (rtems_fdisk_page_desc));
}
2005634: 81 c7 e0 08 ret <== NOT EXECUTED
2005638: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED
02004e18 <rtems_fdisk_segment_queue_insert_before>:
static void
rtems_fdisk_segment_queue_insert_before (rtems_fdisk_segment_ctl_queue* queue,
rtems_fdisk_segment_ctl* item,
rtems_fdisk_segment_ctl* sc)
{
if (item)
2004e18: 80 a2 60 00 cmp %o1, 0
2004e1c: 02 80 00 10 be 2004e5c <rtems_fdisk_segment_queue_insert_before+0x44><== NEVER TAKEN
2004e20: 84 10 00 08 mov %o0, %g2
{
rtems_fdisk_segment_ctl** prev = &queue->head;
rtems_fdisk_segment_ctl* it = queue->head;
while (it)
2004e24: 10 80 00 0b b 2004e50 <rtems_fdisk_segment_queue_insert_before+0x38>
2004e28: c2 02 00 00 ld [ %o0 ], %g1
{
if (item == it)
2004e2c: 32 80 00 08 bne,a 2004e4c <rtems_fdisk_segment_queue_insert_before+0x34>
2004e30: 84 10 00 01 mov %g1, %g2
{
sc->next = item;
2004e34: d2 22 80 00 st %o1, [ %o2 ]
*prev = sc;
queue->count++;
2004e38: c2 02 20 08 ld [ %o0 + 8 ], %g1
while (it)
{
if (item == it)
{
sc->next = item;
*prev = sc;
2004e3c: d4 20 80 00 st %o2, [ %g2 ]
queue->count++;
2004e40: 82 00 60 01 inc %g1
return;
2004e44: 81 c3 e0 08 retl
2004e48: c2 22 20 08 st %g1, [ %o0 + 8 ]
}
prev = &it->next;
it = it->next;
2004e4c: c2 00 40 00 ld [ %g1 ], %g1
if (item)
{
rtems_fdisk_segment_ctl** prev = &queue->head;
rtems_fdisk_segment_ctl* it = queue->head;
while (it)
2004e50: 80 a0 60 00 cmp %g1, 0
2004e54: 12 bf ff f6 bne 2004e2c <rtems_fdisk_segment_queue_insert_before+0x14><== ALWAYS TAKEN
2004e58: 80 a2 40 01 cmp %o1, %g1
prev = &it->next;
it = it->next;
}
}
rtems_fdisk_segment_queue_push_tail (queue, sc);
2004e5c: 92 10 00 0a mov %o2, %o1 <== NOT EXECUTED
2004e60: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED
2004e64: 7f ff ff be call 2004d5c <rtems_fdisk_segment_queue_push_tail><== NOT EXECUTED
2004e68: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED
02004d1c <rtems_fdisk_segment_queue_pop_head>:
/**
* Pop the head of the segment control queue.
*/
static rtems_fdisk_segment_ctl*
rtems_fdisk_segment_queue_pop_head (rtems_fdisk_segment_ctl_queue* queue)
{
2004d1c: 82 10 00 08 mov %o0, %g1
if (queue->head)
2004d20: d0 02 00 00 ld [ %o0 ], %o0
2004d24: 80 a2 20 00 cmp %o0, 0
2004d28: 02 80 00 0b be 2004d54 <rtems_fdisk_segment_queue_pop_head+0x38><== NEVER TAKEN
2004d2c: 01 00 00 00 nop
{
rtems_fdisk_segment_ctl* sc = queue->head;
queue->head = sc->next;
2004d30: c4 02 00 00 ld [ %o0 ], %g2
if (!queue->head)
2004d34: 80 a0 a0 00 cmp %g2, 0
2004d38: 12 80 00 03 bne 2004d44 <rtems_fdisk_segment_queue_pop_head+0x28>
2004d3c: c4 20 40 00 st %g2, [ %g1 ]
queue->tail = 0;
2004d40: c0 20 60 04 clr [ %g1 + 4 ]
queue->count--;
2004d44: c4 00 60 08 ld [ %g1 + 8 ], %g2
2004d48: 84 00 bf ff add %g2, -1, %g2
2004d4c: c4 20 60 08 st %g2, [ %g1 + 8 ]
sc->next = 0;
2004d50: c0 22 00 00 clr [ %o0 ]
return sc;
}
return 0;
}
2004d54: 81 c3 e0 08 retl
02004ce0 <rtems_fdisk_segment_queue_push_head>:
*/
static void
rtems_fdisk_segment_queue_push_head (rtems_fdisk_segment_ctl_queue* queue,
rtems_fdisk_segment_ctl* sc)
{
if (sc)
2004ce0: 80 a2 60 00 cmp %o1, 0 <== NOT EXECUTED
2004ce4: 02 80 00 0c be 2004d14 <rtems_fdisk_segment_queue_push_head+0x34><== NOT EXECUTED
2004ce8: 01 00 00 00 nop <== NOT EXECUTED
{
sc->next = queue->head;
2004cec: c2 02 00 00 ld [ %o0 ], %g1 <== NOT EXECUTED
2004cf0: c2 22 40 00 st %g1, [ %o1 ] <== NOT EXECUTED
queue->head = sc;
if (queue->tail == 0)
2004cf4: c2 02 20 04 ld [ %o0 + 4 ], %g1 <== NOT EXECUTED
2004cf8: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
2004cfc: 12 80 00 03 bne 2004d08 <rtems_fdisk_segment_queue_push_head+0x28><== NOT EXECUTED
2004d00: d2 22 00 00 st %o1, [ %o0 ] <== NOT EXECUTED
queue->tail = sc;
2004d04: d2 22 20 04 st %o1, [ %o0 + 4 ] <== NOT EXECUTED
queue->count++;
2004d08: c2 02 20 08 ld [ %o0 + 8 ], %g1 <== NOT EXECUTED
2004d0c: 82 00 60 01 inc %g1 <== NOT EXECUTED
2004d10: c2 22 20 08 st %g1, [ %o0 + 8 ] <== NOT EXECUTED
2004d14: 81 c3 e0 08 retl <== NOT EXECUTED
02004d5c <rtems_fdisk_segment_queue_push_tail>:
*/
static void
rtems_fdisk_segment_queue_push_tail (rtems_fdisk_segment_ctl_queue* queue,
rtems_fdisk_segment_ctl* sc)
{
if (sc)
2004d5c: 80 a2 60 00 cmp %o1, 0
2004d60: 02 80 00 0f be 2004d9c <rtems_fdisk_segment_queue_push_tail+0x40><== NEVER TAKEN
2004d64: 01 00 00 00 nop
{
sc->next = 0;
if (queue->head)
2004d68: c2 02 00 00 ld [ %o0 ], %g1
2004d6c: 80 a0 60 00 cmp %g1, 0
2004d70: 02 80 00 06 be 2004d88 <rtems_fdisk_segment_queue_push_tail+0x2c>
2004d74: c0 22 40 00 clr [ %o1 ]
{
queue->tail->next = sc;
2004d78: c2 02 20 04 ld [ %o0 + 4 ], %g1
2004d7c: d2 20 40 00 st %o1, [ %g1 ]
queue->tail = sc;
2004d80: 10 80 00 04 b 2004d90 <rtems_fdisk_segment_queue_push_tail+0x34>
2004d84: d2 22 20 04 st %o1, [ %o0 + 4 ]
}
else
{
queue->head = queue->tail = sc;
2004d88: d2 22 20 04 st %o1, [ %o0 + 4 ]
2004d8c: d2 22 00 00 st %o1, [ %o0 ]
}
queue->count++;
2004d90: c2 02 20 08 ld [ %o0 + 8 ], %g1
2004d94: 82 00 60 01 inc %g1
2004d98: c2 22 20 08 st %g1, [ %o0 + 8 ]
2004d9c: 81 c3 e0 08 retl
02004da4 <rtems_fdisk_segment_queue_remove>:
static void
rtems_fdisk_segment_queue_remove (rtems_fdisk_segment_ctl_queue* queue,
rtems_fdisk_segment_ctl* sc)
{
rtems_fdisk_segment_ctl* prev = 0;
rtems_fdisk_segment_ctl* it = queue->head;
2004da4: c2 02 00 00 ld [ %o0 ], %g1
/*
* Do not change sc->next as sc could be on another queue.
*/
while (it)
2004da8: 10 80 00 17 b 2004e04 <rtems_fdisk_segment_queue_remove+0x60>
2004dac: 84 10 20 00 clr %g2
{
if (sc == it)
2004db0: 32 80 00 14 bne,a 2004e00 <rtems_fdisk_segment_queue_remove+0x5c>
2004db4: 84 10 00 01 mov %g1, %g2
{
if (prev == 0)
2004db8: 80 a0 a0 00 cmp %g2, 0
2004dbc: 12 80 00 07 bne 2004dd8 <rtems_fdisk_segment_queue_remove+0x34>
2004dc0: c2 02 40 00 ld [ %o1 ], %g1
{
queue->head = sc->next;
if (queue->head == 0)
2004dc4: 80 a0 60 00 cmp %g1, 0
2004dc8: 12 80 00 09 bne 2004dec <rtems_fdisk_segment_queue_remove+0x48>
2004dcc: c2 22 00 00 st %g1, [ %o0 ]
queue->tail = 0;
2004dd0: 10 80 00 07 b 2004dec <rtems_fdisk_segment_queue_remove+0x48>
2004dd4: c0 22 20 04 clr [ %o0 + 4 ]
}
else
{
prev->next = sc->next;
2004dd8: c2 20 80 00 st %g1, [ %g2 ]
if (queue->tail == sc)
2004ddc: c2 02 20 04 ld [ %o0 + 4 ], %g1
2004de0: 80 a0 40 09 cmp %g1, %o1
2004de4: 22 80 00 02 be,a 2004dec <rtems_fdisk_segment_queue_remove+0x48><== ALWAYS TAKEN
2004de8: c4 22 20 04 st %g2, [ %o0 + 4 ]
queue->tail = prev;
}
sc->next = 0;
queue->count--;
2004dec: c2 02 20 08 ld [ %o0 + 8 ], %g1
{
prev->next = sc->next;
if (queue->tail == sc)
queue->tail = prev;
}
sc->next = 0;
2004df0: c0 22 40 00 clr [ %o1 ]
queue->count--;
2004df4: 82 00 7f ff add %g1, -1, %g1
break;
2004df8: 81 c3 e0 08 retl
2004dfc: c2 22 20 08 st %g1, [ %o0 + 8 ]
}
prev = it;
it = it->next;
2004e00: c2 00 40 00 ld [ %g1 ], %g1
/*
* Do not change sc->next as sc could be on another queue.
*/
while (it)
2004e04: 80 a0 60 00 cmp %g1, 0
2004e08: 12 bf ff ea bne 2004db0 <rtems_fdisk_segment_queue_remove+0xc>
2004e0c: 80 a2 40 01 cmp %o1, %g1
2004e10: 81 c3 e0 08 retl
020050ec <rtems_fdisk_warning>:
* @param ... The arguments for the format text.
* @return int The number of bytes written to the output.
*/
static int
rtems_fdisk_warning (const rtems_flashdisk* fd, const char *format, ...)
{
20050ec: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED
int ret = 0;
if (fd->info_level >= 1)
{
va_list args;
va_start (args, format);
20050f0: f4 27 a0 4c st %i2, [ %fp + 0x4c ] <== NOT EXECUTED
20050f4: f6 27 a0 50 st %i3, [ %fp + 0x50 ] <== NOT EXECUTED
20050f8: f8 27 a0 54 st %i4, [ %fp + 0x54 ] <== NOT EXECUTED
20050fc: fa 27 a0 58 st %i5, [ %fp + 0x58 ] <== NOT EXECUTED
*/
static int
rtems_fdisk_warning (const rtems_flashdisk* fd, const char *format, ...)
{
int ret = 0;
if (fd->info_level >= 1)
2005100: c2 06 20 6c ld [ %i0 + 0x6c ], %g1 <== NOT EXECUTED
2005104: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
2005108: 02 80 00 17 be 2005164 <rtems_fdisk_warning+0x78> <== NOT EXECUTED
200510c: b0 10 20 00 clr %i0 <== NOT EXECUTED
{
va_list args;
va_start (args, format);
2005110: 82 07 a0 4c add %fp, 0x4c, %g1 <== NOT EXECUTED
fprintf (stdout, "fdisk:warning:");
2005114: 3b 00 80 d8 sethi %hi(0x2036000), %i5 <== NOT EXECUTED
{
int ret = 0;
if (fd->info_level >= 1)
{
va_list args;
va_start (args, format);
2005118: c2 27 bf fc st %g1, [ %fp + -4 ] <== NOT EXECUTED
fprintf (stdout, "fdisk:warning:");
200511c: c2 07 61 40 ld [ %i5 + 0x140 ], %g1 <== NOT EXECUTED
2005120: 11 00 80 c3 sethi %hi(0x2030c00), %o0 <== NOT EXECUTED
2005124: d2 00 60 08 ld [ %g1 + 8 ], %o1 <== NOT EXECUTED
2005128: 40 00 70 e8 call 20214c8 <fputs> <== NOT EXECUTED
200512c: 90 12 21 88 or %o0, 0x188, %o0 <== NOT EXECUTED
ret = vfprintf (stdout, format, args);
2005130: c2 07 61 40 ld [ %i5 + 0x140 ], %g1 <== NOT EXECUTED
2005134: d4 07 bf fc ld [ %fp + -4 ], %o2 <== NOT EXECUTED
2005138: d0 00 60 08 ld [ %g1 + 8 ], %o0 <== NOT EXECUTED
200513c: 40 00 93 1f call 2029db8 <vfprintf> <== NOT EXECUTED
2005140: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
fprintf (stdout, "\n");
2005144: c2 07 61 40 ld [ %i5 + 0x140 ], %g1 <== NOT EXECUTED
if (fd->info_level >= 1)
{
va_list args;
va_start (args, format);
fprintf (stdout, "fdisk:warning:");
ret = vfprintf (stdout, format, args);
2005148: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED
fprintf (stdout, "\n");
200514c: d2 00 60 08 ld [ %g1 + 8 ], %o1 <== NOT EXECUTED
2005150: 40 00 70 aa call 20213f8 <fputc> <== NOT EXECUTED
2005154: 90 10 20 0a mov 0xa, %o0 <== NOT EXECUTED
fflush (stdout);
2005158: c2 07 61 40 ld [ %i5 + 0x140 ], %g1 <== NOT EXECUTED
200515c: 40 00 6f 99 call 2020fc0 <fflush> <== NOT EXECUTED
2005160: d0 00 60 08 ld [ %g1 + 8 ], %o0 <== NOT EXECUTED
va_end (args);
}
return ret;
}
2005164: 81 c7 e0 08 ret <== NOT EXECUTED
2005168: 81 e8 00 00 restore <== NOT EXECUTED
0200c464 <rtems_filesystem_check_access>:
int eval_flags,
mode_t node_mode,
uid_t node_uid,
gid_t node_gid
)
{
200c464: 9d e3 bf a0 save %sp, -96, %sp
mode_t perm_flags = eval_flags & RTEMS_FS_PERMS_RWX;
uid_t task_uid = geteuid();
200c468: 7f ff ff 05 call 200c07c <geteuid>
200c46c: b0 0e 20 07 and %i0, 7, %i0
if (task_uid == 0 || task_uid == node_uid) {
200c470: 91 2a 20 10 sll %o0, 0x10, %o0
200c474: 91 32 20 10 srl %o0, 0x10, %o0
200c478: 80 a2 00 1a cmp %o0, %i2
200c47c: 22 80 00 12 be,a 200c4c4 <rtems_filesystem_check_access+0x60>
200c480: b1 2e 20 06 sll %i0, 6, %i0
200c484: 80 a2 20 00 cmp %o0, 0
200c488: 12 80 00 04 bne 200c498 <rtems_filesystem_check_access+0x34>
200c48c: 01 00 00 00 nop
perm_flags <<= RTEMS_FS_USR_SHIFT;
200c490: 10 80 00 0d b 200c4c4 <rtems_filesystem_check_access+0x60>
200c494: b1 2e 20 06 sll %i0, 6, %i0
} else {
gid_t task_gid = getegid();
200c498: 7f ff fe f5 call 200c06c <getegid>
200c49c: 01 00 00 00 nop
if (task_gid == 0 || task_gid == node_gid) {
200c4a0: 91 2a 20 10 sll %o0, 0x10, %o0
200c4a4: 91 32 20 10 srl %o0, 0x10, %o0
200c4a8: 80 a2 00 1b cmp %o0, %i3
200c4ac: 22 80 00 06 be,a 200c4c4 <rtems_filesystem_check_access+0x60>
200c4b0: b1 2e 20 03 sll %i0, 3, %i0
200c4b4: 80 a2 20 00 cmp %o0, 0
200c4b8: 32 80 00 04 bne,a 200c4c8 <rtems_filesystem_check_access+0x64><== ALWAYS TAKEN
200c4bc: b0 2e 00 19 andn %i0, %i1, %i0
perm_flags <<= RTEMS_FS_GRP_SHIFT;
200c4c0: b1 2e 20 03 sll %i0, 3, %i0 <== NOT EXECUTED
} else {
perm_flags <<= RTEMS_FS_OTH_SHIFT;
}
}
return (perm_flags & node_mode) == perm_flags;
200c4c4: b0 2e 00 19 andn %i0, %i1, %i0
}
200c4c8: 80 a0 00 18 cmp %g0, %i0
200c4cc: b0 60 3f ff subx %g0, -1, %i0
200c4d0: 81 c7 e0 08 ret
200c4d4: 81 e8 00 00 restore
02004de4 <rtems_filesystem_do_unmount>:
}
void rtems_filesystem_do_unmount(
rtems_filesystem_mount_table_entry_t *mt_entry
)
{
2004de4: 9d e3 bf a0 save %sp, -96, %sp
*/
#include <rtems/userenv.h>
static inline void rtems_libio_lock( void )
{
rtems_semaphore_obtain( rtems_libio_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT );
2004de8: 3b 00 80 76 sethi %hi(0x201d800), %i5
2004dec: d0 07 61 48 ld [ %i5 + 0x148 ], %o0 ! 201d948 <rtems_libio_semaphore>
2004df0: 92 10 20 00 clr %o1
2004df4: 40 00 0a bc call 20078e4 <rtems_semaphore_obtain>
2004df8: 94 10 20 00 clr %o2
)
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
2004dfc: c4 06 00 00 ld [ %i0 ], %g2
previous = the_node->previous;
2004e00: c2 06 20 04 ld [ %i0 + 4 ], %g1
}
static inline void rtems_libio_unlock( void )
{
rtems_semaphore_release( rtems_libio_semaphore );
2004e04: d0 07 61 48 ld [ %i5 + 0x148 ], %o0
next->previous = previous;
2004e08: c2 20 a0 04 st %g1, [ %g2 + 4 ]
2004e0c: 40 00 0b 00 call 2007a0c <rtems_semaphore_release>
2004e10: c4 20 40 00 st %g2, [ %g1 ]
rtems_filesystem_mt_lock();
rtems_chain_extract_unprotected(&mt_entry->mt_node);
rtems_filesystem_mt_unlock();
rtems_filesystem_global_location_release(mt_entry->mt_point_node);
2004e14: 40 00 00 4d call 2004f48 <rtems_filesystem_global_location_release>
2004e18: d0 06 20 20 ld [ %i0 + 0x20 ], %o0
(*mt_entry->ops->fsunmount_me_h)(mt_entry);
2004e1c: c2 06 20 0c ld [ %i0 + 0xc ], %g1
2004e20: c2 00 60 3c ld [ %g1 + 0x3c ], %g1
2004e24: 9f c0 40 00 call %g1
2004e28: 90 10 00 18 mov %i0, %o0
if (mt_entry->unmount_task != 0) {
2004e2c: d0 06 20 3c ld [ %i0 + 0x3c ], %o0
2004e30: 80 a2 20 00 cmp %o0, 0
2004e34: 02 80 00 09 be 2004e58 <rtems_filesystem_do_unmount+0x74> <== NEVER TAKEN
2004e38: 01 00 00 00 nop
rtems_status_code sc =
2004e3c: 40 00 09 73 call 2007408 <rtems_event_send>
2004e40: 92 10 20 02 mov 2, %o1 ! 2 <PROM_START+0x2>
rtems_event_send(mt_entry->unmount_task, RTEMS_FILESYSTEM_UNMOUNT_EVENT);
if (sc != RTEMS_SUCCESSFUL) {
2004e44: 80 a2 20 00 cmp %o0, 0
2004e48: 02 80 00 04 be 2004e58 <rtems_filesystem_do_unmount+0x74> <== ALWAYS TAKEN
2004e4c: 11 37 ab 6f sethi %hi(0xdeadbc00), %o0
rtems_fatal_error_occurred(0xdeadbeef);
2004e50: 40 00 0c 6a call 2007ff8 <rtems_fatal_error_occurred> <== NOT EXECUTED
2004e54: 90 12 22 ef or %o0, 0x2ef, %o0 ! deadbeef <RAM_END+0xdc6dbeef><== NOT EXECUTED
}
}
free(mt_entry);
2004e58: 7f ff fa 61 call 20037dc <free>
2004e5c: 81 e8 00 00 restore
0200c510 <rtems_filesystem_eval_path_generic>:
void rtems_filesystem_eval_path_generic(
rtems_filesystem_eval_path_context_t *ctx,
void *arg,
const rtems_filesystem_eval_path_generic_config *config
)
{
200c510: 9d e3 bf a0 save %sp, -96, %sp
} else {
/* This is the root file system */
status = (*config->eval_token)(ctx, arg, ".", 1);
}
} else {
status = (*config->eval_token)(ctx, arg, "..", 2);
200c514: 23 00 80 6e sethi %hi(0x201b800), %l1
¤tloc->mt_entry->mt_point_node
);
status = RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_DONE;
} else {
/* This is the root file system */
status = (*config->eval_token)(ctx, arg, ".", 1);
200c518: 3b 00 80 6d sethi %hi(0x201b400), %i5
rtems_filesystem_eval_path_error(ctx, EINVAL);
status = RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_DONE;
}
}
} else if (rtems_filesystem_is_parent_directory(token, tokenlen)) {
rtems_filesystem_location_info_t *currentloc =
200c51c: a0 06 20 18 add %i0, 0x18, %l0
} else {
/* This is the root file system */
status = (*config->eval_token)(ctx, arg, ".", 1);
}
} else {
status = (*config->eval_token)(ctx, arg, "..", 2);
200c520: a2 14 63 f0 or %l1, 0x3f0, %l1
¤tloc->mt_entry->mt_point_node
);
status = RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_DONE;
} else {
/* This is the root file system */
status = (*config->eval_token)(ctx, arg, ".", 1);
200c524: ba 17 63 58 or %i5, 0x358, %i5
rtems_filesystem_eval_path_context_t *ctx,
const char **token,
size_t *tokenlen
)
{
rtems_filesystem_eval_path_next_token(ctx);
200c528: 40 00 00 99 call 200c78c <rtems_filesystem_eval_path_next_token>
200c52c: 90 10 00 18 mov %i0, %o0
*token = ctx->token;
*tokenlen = ctx->tokenlen;
200c530: f8 06 20 0c ld [ %i0 + 0xc ], %i4
const char *token;
size_t tokenlen;
rtems_filesystem_eval_path_get_next_token(ctx, &token, &tokenlen);
if (tokenlen > 0) {
200c534: 80 a7 20 00 cmp %i4, 0
200c538: 02 80 00 54 be 200c688 <rtems_filesystem_eval_path_generic+0x178>
200c53c: f6 06 20 08 ld [ %i0 + 8 ], %i3
if ((*config->is_directory)(ctx, arg)) {
200c540: c2 06 80 00 ld [ %i2 ], %g1
200c544: 90 10 00 18 mov %i0, %o0
200c548: 9f c0 40 00 call %g1
200c54c: 92 10 00 19 mov %i1, %o1
200c550: 80 8a 20 ff btst 0xff, %o0
200c554: 02 80 00 75 be 200c728 <rtems_filesystem_eval_path_generic+0x218>
200c558: 80 a7 20 01 cmp %i4, 1
static inline bool rtems_filesystem_is_current_directory(
const char *token,
size_t tokenlen
)
{
return tokenlen == 1 && token [0] == '.';
200c55c: 12 80 00 06 bne 200c574 <rtems_filesystem_eval_path_generic+0x64>
200c560: 82 10 20 00 clr %g1
200c564: c2 4e c0 00 ldsb [ %i3 ], %g1
200c568: 82 18 60 2e xor %g1, 0x2e, %g1
200c56c: 80 a0 00 01 cmp %g0, %g1
200c570: 82 60 3f ff subx %g0, -1, %g1
if (rtems_filesystem_is_current_directory(token, tokenlen)) {
200c574: 80 a0 60 00 cmp %g1, 0
200c578: 02 80 00 0f be 200c5b4 <rtems_filesystem_eval_path_generic+0xa4>
200c57c: 80 a7 20 02 cmp %i4, 2
if (rtems_filesystem_eval_path_has_path(ctx)) {
200c580: c2 06 20 04 ld [ %i0 + 4 ], %g1
200c584: 80 a0 60 00 cmp %g1, 0
200c588: 22 80 00 04 be,a 200c598 <rtems_filesystem_eval_path_generic+0x88>
200c58c: c2 06 20 10 ld [ %i0 + 0x10 ], %g1
¤tloc->mt_entry->mt_point_node
);
status = RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_DONE;
} else {
/* This is the root file system */
status = (*config->eval_token)(ctx, arg, ".", 1);
200c590: 10 80 00 40 b 200c690 <rtems_filesystem_eval_path_generic+0x180>
200c594: c2 06 a0 04 ld [ %i2 + 4 ], %g1
if (rtems_filesystem_eval_path_has_path(ctx)) {
status = (*config->eval_token)(ctx, arg, ".", 1);
} else {
int eval_flags = rtems_filesystem_eval_path_get_flags(ctx);
if ((eval_flags & RTEMS_FS_REJECT_TERMINAL_DOT) == 0) {
200c598: 80 88 61 00 btst 0x100, %g1
200c59c: 32 80 00 04 bne,a 200c5ac <rtems_filesystem_eval_path_generic+0x9c>
200c5a0: 90 10 00 18 mov %i0, %o0
¤tloc->mt_entry->mt_point_node
);
status = RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_DONE;
} else {
/* This is the root file system */
status = (*config->eval_token)(ctx, arg, ".", 1);
200c5a4: 10 80 00 3b b 200c690 <rtems_filesystem_eval_path_generic+0x180>
200c5a8: c2 06 a0 04 ld [ %i2 + 4 ], %g1
int eval_flags = rtems_filesystem_eval_path_get_flags(ctx);
if ((eval_flags & RTEMS_FS_REJECT_TERMINAL_DOT) == 0) {
status = (*config->eval_token)(ctx, arg, ".", 1);
} else {
rtems_filesystem_eval_path_error(ctx, EINVAL);
200c5ac: 10 80 00 5b b 200c718 <rtems_filesystem_eval_path_generic+0x208>
200c5b0: 92 10 20 16 mov 0x16, %o1
static inline bool rtems_filesystem_is_parent_directory(
const char *token,
size_t tokenlen
)
{
return tokenlen == 2 && token [0] == '.' && token [1] == '.';
200c5b4: 12 80 00 0a bne 200c5dc <rtems_filesystem_eval_path_generic+0xcc>
200c5b8: 82 10 20 00 clr %g1
200c5bc: c4 4e c0 00 ldsb [ %i3 ], %g2
200c5c0: 80 a0 a0 2e cmp %g2, 0x2e
200c5c4: 12 80 00 07 bne 200c5e0 <rtems_filesystem_eval_path_generic+0xd0>
200c5c8: 80 a0 60 00 cmp %g1, 0
200c5cc: c2 4e e0 01 ldsb [ %i3 + 1 ], %g1
200c5d0: 82 18 60 2e xor %g1, 0x2e, %g1
200c5d4: 80 a0 00 01 cmp %g0, %g1
200c5d8: 82 60 3f ff subx %g0, -1, %g1
status = RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_DONE;
}
}
} else if (rtems_filesystem_is_parent_directory(token, tokenlen)) {
200c5dc: 80 a0 60 00 cmp %g1, 0
200c5e0: 22 80 00 36 be,a 200c6b8 <rtems_filesystem_eval_path_generic+0x1a8>
200c5e4: c2 06 a0 04 ld [ %i2 + 4 ], %g1
const rtems_filesystem_eval_path_context_t *ctx,
const rtems_filesystem_location_info_t *loc
)
{
const rtems_filesystem_mount_table_entry_t *mt_entry = loc->mt_entry;
const rtems_filesystem_location_info_t *rootloc = &ctx->rootloc->location;
200c5e8: d2 06 20 30 ld [ %i0 + 0x30 ], %o1
static bool is_eval_path_root(
const rtems_filesystem_eval_path_context_t *ctx,
const rtems_filesystem_location_info_t *loc
)
{
const rtems_filesystem_mount_table_entry_t *mt_entry = loc->mt_entry;
200c5ec: c2 06 20 2c ld [ %i0 + 0x2c ], %g1
const rtems_filesystem_location_info_t *rootloc = &ctx->rootloc->location;
return mt_entry == rootloc->mt_entry
&& (*mt_entry->ops->are_nodes_equal_h)( loc, rootloc );
200c5f0: c4 02 60 14 ld [ %o1 + 0x14 ], %g2
200c5f4: 80 a0 40 02 cmp %g1, %g2
200c5f8: 12 80 00 07 bne 200c614 <rtems_filesystem_eval_path_generic+0x104>
200c5fc: 90 10 20 00 clr %o0
200c600: c2 00 60 0c ld [ %g1 + 0xc ], %g1
200c604: c2 00 60 10 ld [ %g1 + 0x10 ], %g1
200c608: 9f c0 40 00 call %g1
200c60c: 90 10 00 10 mov %l0, %o0
200c610: 90 0a 20 ff and %o0, 0xff, %o0
}
} else if (rtems_filesystem_is_parent_directory(token, tokenlen)) {
rtems_filesystem_location_info_t *currentloc =
rtems_filesystem_eval_path_get_currentloc( ctx );
if (is_eval_path_root(ctx, currentloc)) {
200c614: 80 8a 20 01 btst 1, %o0
200c618: 22 80 00 04 be,a 200c628 <rtems_filesystem_eval_path_generic+0x118>
200c61c: c2 06 20 2c ld [ %i0 + 0x2c ], %g1
¤tloc->mt_entry->mt_point_node
);
status = RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_DONE;
} else {
/* This is the root file system */
status = (*config->eval_token)(ctx, arg, ".", 1);
200c620: 10 80 00 1c b 200c690 <rtems_filesystem_eval_path_generic+0x180>
200c624: c2 06 a0 04 ld [ %i2 + 4 ], %g1
{
const rtems_filesystem_mount_table_entry_t *mt_entry = loc->mt_entry;
const rtems_filesystem_location_info_t *mt_fs_root =
&mt_entry->mt_fs_root->location;
return (*mt_entry->ops->are_nodes_equal_h)( loc, mt_fs_root );
200c628: 90 10 00 10 mov %l0, %o0
200c62c: c4 00 60 0c ld [ %g1 + 0xc ], %g2
200c630: c4 00 a0 10 ld [ %g2 + 0x10 ], %g2
200c634: 9f c0 80 00 call %g2
200c638: d2 00 60 24 ld [ %g1 + 0x24 ], %o1
rtems_filesystem_eval_path_get_currentloc( ctx );
if (is_eval_path_root(ctx, currentloc)) {
/* This prevents the escape from a chroot() environment */
status = (*config->eval_token)(ctx, arg, ".", 1);
} else if (is_fs_root(currentloc)) {
200c63c: 80 8a 20 ff btst 0xff, %o0
200c640: 22 80 00 19 be,a 200c6a4 <rtems_filesystem_eval_path_generic+0x194>
200c644: c2 06 a0 04 ld [ %i2 + 4 ], %g1
if (currentloc->mt_entry->mt_point_node != NULL) {
200c648: d2 06 20 2c ld [ %i0 + 0x2c ], %o1
200c64c: c2 02 60 20 ld [ %o1 + 0x20 ], %g1
200c650: 80 a0 60 00 cmp %g1, 0
200c654: 22 80 00 0f be,a 200c690 <rtems_filesystem_eval_path_generic+0x180><== NEVER TAKEN
200c658: c2 06 a0 04 ld [ %i2 + 4 ], %g1 <== NOT EXECUTED
static inline void rtems_filesystem_eval_path_put_back_token(
rtems_filesystem_eval_path_context_t *ctx
)
{
size_t tokenlen = ctx->tokenlen;
200c65c: c2 06 20 0c ld [ %i0 + 0xc ], %g1
ctx->path -= tokenlen;
200c660: c4 06 00 00 ld [ %i0 ], %g2
ctx->pathlen += tokenlen;
ctx->tokenlen = 0;
200c664: c0 26 20 0c clr [ %i0 + 0xc ]
rtems_filesystem_eval_path_context_t *ctx
)
{
size_t tokenlen = ctx->tokenlen;
ctx->path -= tokenlen;
200c668: 84 20 80 01 sub %g2, %g1, %g2
200c66c: c4 26 00 00 st %g2, [ %i0 ]
ctx->pathlen += tokenlen;
200c670: c4 06 20 04 ld [ %i0 + 4 ], %g2
rtems_filesystem_eval_path_put_back_token(ctx);
rtems_filesystem_eval_path_restart(
200c674: 90 10 00 18 mov %i0, %o0
200c678: 82 00 80 01 add %g2, %g1, %g1
200c67c: 92 02 60 20 add %o1, 0x20, %o1
200c680: 7f ff e1 62 call 2004c08 <rtems_filesystem_eval_path_restart>
200c684: c2 26 20 04 st %g1, [ %i0 + 4 ]
200c688: 81 c7 e0 08 ret
200c68c: 81 e8 00 00 restore
¤tloc->mt_entry->mt_point_node
);
status = RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_DONE;
} else {
/* This is the root file system */
status = (*config->eval_token)(ctx, arg, ".", 1);
200c690: 90 10 00 18 mov %i0, %o0
200c694: 92 10 00 19 mov %i1, %o1
200c698: 94 10 00 1d mov %i5, %o2
200c69c: 10 80 00 0b b 200c6c8 <rtems_filesystem_eval_path_generic+0x1b8>
200c6a0: 96 10 20 01 mov 1, %o3
}
} else {
status = (*config->eval_token)(ctx, arg, "..", 2);
200c6a4: 90 10 00 18 mov %i0, %o0
200c6a8: 92 10 00 19 mov %i1, %o1
200c6ac: 94 10 00 11 mov %l1, %o2
200c6b0: 10 80 00 06 b 200c6c8 <rtems_filesystem_eval_path_generic+0x1b8>
200c6b4: 96 10 20 02 mov 2, %o3
}
} else {
status = (*config->eval_token)(ctx, arg, token, tokenlen);
200c6b8: 90 10 00 18 mov %i0, %o0
200c6bc: 92 10 00 19 mov %i1, %o1
200c6c0: 94 10 00 1b mov %i3, %o2
200c6c4: 96 10 00 1c mov %i4, %o3
200c6c8: 9f c0 40 00 call %g1
200c6cc: 01 00 00 00 nop
}
if (status == RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_NO_ENTRY) {
200c6d0: 80 a2 20 02 cmp %o0, 2
200c6d4: 12 80 00 18 bne 200c734 <rtems_filesystem_eval_path_generic+0x224>
200c6d8: 80 a2 20 00 cmp %o0, 0
if (rtems_filesystem_eval_path_has_path(ctx)) {
200c6dc: c2 06 20 04 ld [ %i0 + 4 ], %g1
200c6e0: 80 a0 60 00 cmp %g1, 0
200c6e4: 02 80 00 16 be 200c73c <rtems_filesystem_eval_path_generic+0x22c>
200c6e8: 01 00 00 00 nop
int eval_flags;
rtems_filesystem_eval_path_eat_delimiter(ctx);
200c6ec: 40 00 00 16 call 200c744 <rtems_filesystem_eval_path_eat_delimiter>
200c6f0: 90 10 00 18 mov %i0, %o0
eval_flags = rtems_filesystem_eval_path_get_flags(ctx);
if (
(eval_flags & RTEMS_FS_ACCEPT_RESIDUAL_DELIMITERS) == 0
200c6f4: c2 06 20 10 ld [ %i0 + 0x10 ], %g1
if (rtems_filesystem_eval_path_has_path(ctx)) {
int eval_flags;
rtems_filesystem_eval_path_eat_delimiter(ctx);
eval_flags = rtems_filesystem_eval_path_get_flags(ctx);
if (
200c6f8: 80 88 60 80 btst 0x80, %g1
200c6fc: 02 80 00 06 be 200c714 <rtems_filesystem_eval_path_generic+0x204>
200c700: 90 10 00 18 mov %i0, %o0
(eval_flags & RTEMS_FS_ACCEPT_RESIDUAL_DELIMITERS) == 0
|| rtems_filesystem_eval_path_has_path(ctx)
200c704: c2 06 20 04 ld [ %i0 + 4 ], %g1
200c708: 80 a0 60 00 cmp %g1, 0
200c70c: 02 80 00 0c be 200c73c <rtems_filesystem_eval_path_generic+0x22c>
200c710: 01 00 00 00 nop
) {
rtems_filesystem_eval_path_error(ctx, ENOENT);
200c714: 92 10 20 02 mov 2, %o1 ! 2 <PROM_START+0x2>
200c718: 7f ff e0 57 call 2004874 <rtems_filesystem_eval_path_error>
200c71c: 01 00 00 00 nop
200c720: 81 c7 e0 08 ret
200c724: 81 e8 00 00 restore
}
}
}
} else {
rtems_filesystem_eval_path_error(ctx, ENOTDIR);
200c728: 90 10 00 18 mov %i0, %o0
200c72c: 10 bf ff fb b 200c718 <rtems_filesystem_eval_path_generic+0x208>
200c730: 92 10 20 14 mov 0x14, %o1
)
{
rtems_filesystem_eval_path_generic_status status =
RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_CONTINUE;
while (status == RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_CONTINUE) {
200c734: 02 bf ff 7d be 200c528 <rtems_filesystem_eval_path_generic+0x18>
200c738: 01 00 00 00 nop
200c73c: 81 c7 e0 08 ret
200c740: 81 e8 00 00 restore
02004c6c <rtems_filesystem_eval_path_recursive>:
void rtems_filesystem_eval_path_recursive(
rtems_filesystem_eval_path_context_t *ctx,
const char *path,
size_t pathlen
)
{
2004c6c: 9d e3 bf a0 save %sp, -96, %sp
if (pathlen > 0) {
2004c70: 80 a6 a0 00 cmp %i2, 0
2004c74: 02 80 00 26 be 2004d0c <rtems_filesystem_eval_path_recursive+0xa0><== NEVER TAKEN
2004c78: ba 10 00 18 mov %i0, %i5
if (ctx->recursionlevel < RTEMS_FILESYSTEM_SYMLOOP_MAX) {
2004c7c: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
2004c80: 80 a0 60 1f cmp %g1, 0x1f
2004c84: 34 80 00 23 bg,a 2004d10 <rtems_filesystem_eval_path_recursive+0xa4>
2004c88: b2 10 20 5c mov 0x5c, %i1
gid_t node_gid
);
static inline bool rtems_filesystem_is_delimiter(char c)
{
return c == '/' || c == '\\';
2004c8c: c2 4e 40 00 ldsb [ %i1 ], %g1
const char *saved_path = ctx->path;
2004c90: f6 06 00 00 ld [ %i0 ], %i3
size_t saved_pathlen = ctx->pathlen;
if (rtems_filesystem_is_delimiter(path [0])) {
2004c94: 80 a0 60 5c cmp %g1, 0x5c
2004c98: 02 80 00 05 be 2004cac <rtems_filesystem_eval_path_recursive+0x40><== NEVER TAKEN
2004c9c: f8 06 20 04 ld [ %i0 + 4 ], %i4
2004ca0: 80 a0 60 2f cmp %g1, 0x2f
2004ca4: 32 80 00 06 bne,a 2004cbc <rtems_filesystem_eval_path_recursive+0x50>
2004ca8: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
rtems_filesystem_eval_path_restart(ctx, &ctx->rootloc);
2004cac: 90 10 00 1d mov %i5, %o0
2004cb0: 7f ff ff d6 call 2004c08 <rtems_filesystem_eval_path_restart>
2004cb4: 92 07 60 30 add %i5, 0x30, %o1
}
ctx->path = path;
ctx->pathlen = pathlen;
++ctx->recursionlevel;
2004cb8: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
if (rtems_filesystem_is_delimiter(path [0])) {
rtems_filesystem_eval_path_restart(ctx, &ctx->rootloc);
}
ctx->path = path;
2004cbc: f2 27 40 00 st %i1, [ %i5 ]
ctx->pathlen = pathlen;
++ctx->recursionlevel;
2004cc0: 82 00 60 01 inc %g1
if (rtems_filesystem_is_delimiter(path [0])) {
rtems_filesystem_eval_path_restart(ctx, &ctx->rootloc);
}
ctx->path = path;
ctx->pathlen = pathlen;
2004cc4: f4 27 60 04 st %i2, [ %i5 + 4 ]
++ctx->recursionlevel;
while (ctx->pathlen > 0) {
2004cc8: 10 80 00 06 b 2004ce0 <rtems_filesystem_eval_path_recursive+0x74>
2004ccc: c2 27 60 14 st %g1, [ %i5 + 0x14 ]
(*ctx->currentloc.mt_entry->ops->eval_path_h)(ctx);
2004cd0: c2 00 60 0c ld [ %g1 + 0xc ], %g1
2004cd4: c2 00 60 08 ld [ %g1 + 8 ], %g1
2004cd8: 9f c0 40 00 call %g1
2004cdc: 90 10 00 1d mov %i5, %o0
ctx->path = path;
ctx->pathlen = pathlen;
++ctx->recursionlevel;
while (ctx->pathlen > 0) {
2004ce0: c2 07 60 04 ld [ %i5 + 4 ], %g1
2004ce4: 80 a0 60 00 cmp %g1, 0
2004ce8: 32 bf ff fa bne,a 2004cd0 <rtems_filesystem_eval_path_recursive+0x64>
2004cec: c2 07 60 2c ld [ %i5 + 0x2c ], %g1
(*ctx->currentloc.mt_entry->ops->eval_path_h)(ctx);
}
--ctx->recursionlevel;
2004cf0: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
ctx->path = saved_path;
2004cf4: f6 27 40 00 st %i3, [ %i5 ]
++ctx->recursionlevel;
while (ctx->pathlen > 0) {
(*ctx->currentloc.mt_entry->ops->eval_path_h)(ctx);
}
--ctx->recursionlevel;
2004cf8: 82 00 7f ff add %g1, -1, %g1
ctx->path = saved_path;
ctx->pathlen = saved_pathlen;
2004cfc: f8 27 60 04 st %i4, [ %i5 + 4 ]
++ctx->recursionlevel;
while (ctx->pathlen > 0) {
(*ctx->currentloc.mt_entry->ops->eval_path_h)(ctx);
}
--ctx->recursionlevel;
2004d00: c2 27 60 14 st %g1, [ %i5 + 0x14 ]
2004d04: 81 c7 e0 08 ret
2004d08: 81 e8 00 00 restore
ctx->pathlen = saved_pathlen;
} else {
rtems_filesystem_eval_path_error(ctx, ELOOP);
}
} else {
rtems_filesystem_eval_path_error(ctx, ENOENT);
2004d0c: b2 10 20 02 mov 2, %i1 <== NOT EXECUTED
2004d10: 7f ff fe d9 call 2004874 <rtems_filesystem_eval_path_error>
2004d14: 81 e8 00 00 restore
02004ae4 <rtems_filesystem_eval_path_start_with_parent>:
const char *path,
int eval_flags,
rtems_filesystem_location_info_t *parentloc,
int parent_eval_flags
)
{
2004ae4: 9d e3 bf a0 save %sp, -96, %sp
size_t pathlen = strlen(path);
2004ae8: 40 00 31 47 call 2011004 <strlen>
2004aec: 90 10 00 19 mov %i1, %o0
2004af0: 10 80 00 09 b 2004b14 <rtems_filesystem_eval_path_start_with_parent+0x30>
2004af4: 94 10 00 08 mov %o0, %o2
gid_t node_gid
);
static inline bool rtems_filesystem_is_delimiter(char c)
{
return c == '/' || c == '\\';
2004af8: c4 4e 40 01 ldsb [ %i1 + %g1 ], %g2
static size_t get_parentpathlen(const char *path, size_t pathlen)
{
while (pathlen > 0) {
size_t i = pathlen - 1;
if (rtems_filesystem_is_delimiter(path [i])) {
2004afc: 80 a0 a0 5c cmp %g2, 0x5c
2004b00: 02 80 00 28 be 2004ba0 <rtems_filesystem_eval_path_start_with_parent+0xbc><== NEVER TAKEN
2004b04: 80 a0 a0 2f cmp %g2, 0x2f
2004b08: 02 80 00 27 be 2004ba4 <rtems_filesystem_eval_path_start_with_parent+0xc0>
2004b0c: 80 a2 20 00 cmp %o0, 0
return pathlen;
}
pathlen = i;
2004b10: 94 10 00 01 mov %g1, %o2
#include <rtems/libio_.h>
static size_t get_parentpathlen(const char *path, size_t pathlen)
{
while (pathlen > 0) {
2004b14: 80 a2 a0 00 cmp %o2, 0
2004b18: 12 bf ff f8 bne 2004af8 <rtems_filesystem_eval_path_start_with_parent+0x14>
2004b1c: 82 02 bf ff add %o2, -1, %g1
size_t parentpathlen = get_parentpathlen(path, pathlen);
const char *name = NULL;
size_t namelen = 0;
const rtems_filesystem_location_info_t *currentloc = NULL;
if (pathlen > 0) {
2004b20: 80 a2 20 00 cmp %o0, 0
2004b24: 02 80 00 0a be 2004b4c <rtems_filesystem_eval_path_start_with_parent+0x68>
2004b28: ba 10 00 19 mov %i1, %i5
2004b2c: a0 10 00 08 mov %o0, %l0
if (parentpathlen == 0) {
parentpath = ".";
2004b30: 33 00 80 6d sethi %hi(0x201b400), %i1
parentpathlen = 1;
2004b34: 94 10 20 01 mov 1, %o2
size_t namelen = 0;
const rtems_filesystem_location_info_t *currentloc = NULL;
if (pathlen > 0) {
if (parentpathlen == 0) {
parentpath = ".";
2004b38: 10 80 00 09 b 2004b5c <rtems_filesystem_eval_path_start_with_parent+0x78>
2004b3c: 92 16 63 58 or %i1, 0x358, %o1
parentpathlen = 1;
name = path;
namelen = pathlen;
} else {
name = path + parentpathlen;
namelen = pathlen - parentpathlen;
2004b40: a0 22 00 0a sub %o0, %o2, %l0
rtems_filesystem_location_info_t *parentloc,
int parent_eval_flags
)
{
size_t pathlen = strlen(path);
const char *parentpath = path;
2004b44: 10 80 00 06 b 2004b5c <rtems_filesystem_eval_path_start_with_parent+0x78>
2004b48: 92 10 00 19 mov %i1, %o1
2004b4c: 92 10 00 19 mov %i1, %o1
size_t parentpathlen = get_parentpathlen(path, pathlen);
const char *name = NULL;
size_t namelen = 0;
2004b50: a0 10 20 00 clr %l0
)
{
size_t pathlen = strlen(path);
const char *parentpath = path;
size_t parentpathlen = get_parentpathlen(path, pathlen);
const char *name = NULL;
2004b54: ba 10 20 00 clr %i5
}
pathlen = i;
}
return 0;
2004b58: 94 10 20 00 clr %o2
currentloc = eval_path_start(
ctx,
parentpath,
parentpathlen,
parent_eval_flags,
&rtems_filesystem_root,
2004b5c: 03 00 80 73 sethi %hi(0x201cc00), %g1
2004b60: da 00 63 08 ld [ %g1 + 0x308 ], %o5 ! 201cf08 <rtems_current_user_env>
name = path + parentpathlen;
namelen = pathlen - parentpathlen;
}
}
currentloc = eval_path_start(
2004b64: 96 10 00 1c mov %i4, %o3
2004b68: 98 03 60 04 add %o5, 4, %o4
2004b6c: 7f ff ff 94 call 20049bc <eval_path_start>
2004b70: 90 10 00 18 mov %i0, %o0
2004b74: 92 10 00 08 mov %o0, %o1
parent_eval_flags,
&rtems_filesystem_root,
&rtems_filesystem_current
);
rtems_filesystem_location_clone(parentloc, currentloc);
2004b78: 40 00 1c f4 call 200bf48 <rtems_filesystem_location_clone>
2004b7c: 90 10 00 1b mov %i3, %o0
ctx->path = name;
ctx->pathlen = namelen;
ctx->flags = eval_flags;
rtems_filesystem_eval_path_continue(ctx);
2004b80: 90 10 00 18 mov %i0, %o0
&rtems_filesystem_current
);
rtems_filesystem_location_clone(parentloc, currentloc);
ctx->path = name;
2004b84: fa 26 00 00 st %i5, [ %i0 ]
ctx->pathlen = namelen;
2004b88: e0 26 20 04 st %l0, [ %i0 + 4 ]
ctx->flags = eval_flags;
2004b8c: f4 26 20 10 st %i2, [ %i0 + 0x10 ]
rtems_filesystem_eval_path_continue(ctx);
2004b90: 7f ff ff 71 call 2004954 <rtems_filesystem_eval_path_continue>
2004b94: b0 06 20 18 add %i0, 0x18, %i0
2004b98: 81 c7 e0 08 ret
2004b9c: 81 e8 00 00 restore
size_t parentpathlen = get_parentpathlen(path, pathlen);
const char *name = NULL;
size_t namelen = 0;
const rtems_filesystem_location_info_t *currentloc = NULL;
if (pathlen > 0) {
2004ba0: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2004ba4: 32 bf ff e7 bne,a 2004b40 <rtems_filesystem_eval_path_start_with_parent+0x5c><== ALWAYS TAKEN
2004ba8: ba 06 40 0a add %i1, %o2, %i5
rtems_filesystem_location_info_t *parentloc,
int parent_eval_flags
)
{
size_t pathlen = strlen(path);
const char *parentpath = path;
2004bac: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
size_t parentpathlen = get_parentpathlen(path, pathlen);
const char *name = NULL;
size_t namelen = 0;
2004bb0: a0 10 20 00 clr %l0 <== NOT EXECUTED
)
{
size_t pathlen = strlen(path);
const char *parentpath = path;
size_t parentpathlen = get_parentpathlen(path, pathlen);
const char *name = NULL;
2004bb4: 10 bf ff ea b 2004b5c <rtems_filesystem_eval_path_start_with_parent+0x78><== NOT EXECUTED
2004bb8: ba 10 20 00 clr %i5 <== NOT EXECUTED
0200c2cc <rtems_filesystem_get_mount_handler>:
rtems_filesystem_fsmount_me_t
rtems_filesystem_get_mount_handler(
const char *type
)
{
200c2cc: 9d e3 bf 98 save %sp, -104, %sp
find_arg fa = {
200c2d0: f0 27 bf f8 st %i0, [ %fp + -8 ]
.type = type,
.mount_h = NULL
};
if ( type != NULL ) {
200c2d4: 80 a6 20 00 cmp %i0, 0
200c2d8: 02 80 00 06 be 200c2f0 <rtems_filesystem_get_mount_handler+0x24><== NEVER TAKEN
200c2dc: c0 27 bf fc clr [ %fp + -4 ]
rtems_filesystem_iterate( find_handler, &fa );
200c2e0: 11 00 80 30 sethi %hi(0x200c000), %o0
200c2e4: 92 07 bf f8 add %fp, -8, %o1
200c2e8: 7f ff ff ce call 200c220 <rtems_filesystem_iterate>
200c2ec: 90 12 21 bc or %o0, 0x1bc, %o0
}
return fa.mount_h;
}
200c2f0: f0 07 bf fc ld [ %fp + -4 ], %i0
200c2f4: 81 c7 e0 08 ret
200c2f8: 81 e8 00 00 restore
020034a4 <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 )
{
20034a4: 9d e3 bf a0 save %sp, -96, %sp
int rv = 0;
const rtems_filesystem_mount_configuration *root_config =
&rtems_filesystem_root_configuration;
rv = mount(
20034a8: 05 00 80 6a sethi %hi(0x201a800), %g2
20034ac: 82 10 a3 08 or %g2, 0x308, %g1 ! 201ab08 <rtems_filesystem_root_configuration>
20034b0: d0 00 a3 08 ld [ %g2 + 0x308 ], %o0
20034b4: d2 00 60 04 ld [ %g1 + 4 ], %o1
20034b8: d4 00 60 08 ld [ %g1 + 8 ], %o2
20034bc: d6 00 60 0c ld [ %g1 + 0xc ], %o3
20034c0: 40 00 02 3a call 2003da8 <mount>
20034c4: d8 00 60 10 ld [ %g1 + 0x10 ], %o4
root_config->target,
root_config->filesystemtype,
root_config->options,
root_config->data
);
if ( rv != 0 )
20034c8: 80 a2 20 00 cmp %o0, 0
20034cc: 22 80 00 05 be,a 20034e0 <rtems_filesystem_initialize+0x3c><== ALWAYS TAKEN
20034d0: 11 00 80 6c sethi %hi(0x201b000), %o0
rtems_fatal_error_occurred( 0xABCD0002 );
20034d4: 11 2a f3 40 sethi %hi(0xabcd0000), %o0 <== NOT EXECUTED
20034d8: 10 80 00 09 b 20034fc <rtems_filesystem_initialize+0x58> <== NOT EXECUTED
20034dc: 90 12 20 02 or %o0, 2, %o0 ! abcd0002 <RAM_END+0xa98d0002><== NOT EXECUTED
*
* NOTE: UNIX root is 755 and owned by root/root (0/0). It is actually
* created that way by the IMFS.
*/
rv = mkdir( "/dev", 0777);
20034e0: 92 10 21 ff mov 0x1ff, %o1
20034e4: 40 00 01 e9 call 2003c88 <mkdir>
20034e8: 90 12 21 e0 or %o0, 0x1e0, %o0
if ( rv != 0 )
20034ec: 80 a2 20 00 cmp %o0, 0
20034f0: 02 80 00 05 be 2003504 <rtems_filesystem_initialize+0x60> <== ALWAYS TAKEN
20034f4: 11 2a f3 40 sethi %hi(0xabcd0000), %o0
rtems_fatal_error_occurred( 0xABCD0003 );
20034f8: 90 12 20 03 or %o0, 3, %o0 ! abcd0003 <RAM_END+0xa98d0003><== NOT EXECUTED
20034fc: 40 00 12 bf call 2007ff8 <rtems_fatal_error_occurred> <== NOT EXECUTED
2003500: 01 00 00 00 nop <== NOT EXECUTED
2003504: 81 c7 e0 08 ret
2003508: 81 e8 00 00 restore
0200c220 <rtems_filesystem_iterate>:
bool rtems_filesystem_iterate(
rtems_per_filesystem_routine routine,
void *routine_arg
)
{
200c220: 9d e3 bf a0 save %sp, -96, %sp
const rtems_filesystem_table_t *table_entry = &rtems_filesystem_table [0];
200c224: 39 00 80 6a sethi %hi(0x201a800), %i4
rtems_chain_node *node = NULL;
bool stop = false;
200c228: ba 10 20 00 clr %i5
while ( table_entry->type && !stop ) {
200c22c: 10 80 00 06 b 200c244 <rtems_filesystem_iterate+0x24>
200c230: b8 17 23 1c or %i4, 0x31c, %i4
stop = (*routine)( table_entry, routine_arg );
200c234: 92 10 00 19 mov %i1, %o1
200c238: 9f c6 00 00 call %i0
200c23c: b8 07 20 08 add %i4, 8, %i4
200c240: ba 10 00 08 mov %o0, %i5
{
const rtems_filesystem_table_t *table_entry = &rtems_filesystem_table [0];
rtems_chain_node *node = NULL;
bool stop = false;
while ( table_entry->type && !stop ) {
200c244: c2 07 00 00 ld [ %i4 ], %g1
200c248: 80 a0 60 00 cmp %g1, 0
200c24c: 02 80 00 08 be 200c26c <rtems_filesystem_iterate+0x4c>
200c250: 82 0f 60 ff and %i5, 0xff, %g1
200c254: 80 a0 60 00 cmp %g1, 0
200c258: 02 bf ff f7 be 200c234 <rtems_filesystem_iterate+0x14>
200c25c: 90 10 00 1c mov %i4, %o0
200c260: b0 0f 60 ff and %i5, 0xff, %i0
200c264: 81 c7 e0 08 ret
200c268: 81 e8 00 00 restore
stop = (*routine)( table_entry, routine_arg );
++table_entry;
}
if ( !stop ) {
200c26c: 80 a0 60 00 cmp %g1, 0
200c270: 32 80 00 15 bne,a 200c2c4 <rtems_filesystem_iterate+0xa4>
200c274: b0 0f 60 ff and %i5, 0xff, %i0
rtems_libio_lock();
200c278: 7f ff ff de call 200c1f0 <rtems_libio_lock>
200c27c: 37 00 80 73 sethi %hi(0x201cc00), %i3
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
200c280: 03 00 80 73 sethi %hi(0x201cc00), %g1
200c284: f8 00 63 a0 ld [ %g1 + 0x3a0 ], %i4 ! 201cfa0 <filesystem_chain>
for (
200c288: 10 80 00 06 b 200c2a0 <rtems_filesystem_iterate+0x80>
200c28c: b6 16 e3 a4 or %i3, 0x3a4, %i3
!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 );
200c290: 9f c6 00 00 call %i0
200c294: 92 10 00 19 mov %i1, %o1
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Next(
Chain_Node *the_node
)
{
return the_node->next;
200c298: f8 07 00 00 ld [ %i4 ], %i4
200c29c: ba 10 00 08 mov %o0, %i5
++table_entry;
}
if ( !stop ) {
rtems_libio_lock();
for (
200c2a0: 80 a7 00 1b cmp %i4, %i3
200c2a4: 12 80 00 05 bne 200c2b8 <rtems_filesystem_iterate+0x98>
200c2a8: 80 8f 60 ff btst 0xff, %i5
) {
const filesystem_node *fsn = (filesystem_node *) node;
stop = (*routine)( &fsn->entry, routine_arg );
}
rtems_libio_unlock();
200c2ac: 7f ff ff d8 call 200c20c <rtems_libio_unlock>
200c2b0: b0 0f 60 ff and %i5, 0xff, %i0
200c2b4: 30 80 00 04 b,a 200c2c4 <rtems_filesystem_iterate+0xa4>
if ( !stop ) {
rtems_libio_lock();
for (
node = rtems_chain_first( &filesystem_chain );
!rtems_chain_is_tail( &filesystem_chain, node ) && !stop;
200c2b8: 02 bf ff f6 be 200c290 <rtems_filesystem_iterate+0x70> <== ALWAYS TAKEN
200c2bc: 90 07 20 08 add %i4, 8, %o0
200c2c0: 30 bf ff fb b,a 200c2ac <rtems_filesystem_iterate+0x8c> <== NOT EXECUTED
}
rtems_libio_unlock();
}
return stop;
}
200c2c4: 81 c7 e0 08 ret
200c2c8: 81 e8 00 00 restore
02004e60 <rtems_filesystem_location_remove_from_mt_entry>:
}
void rtems_filesystem_location_remove_from_mt_entry(
rtems_filesystem_location_info_t *loc
)
{
2004e60: 9d e3 bf a0 save %sp, -96, %sp
rtems_filesystem_mt_entry_declare_lock_context(lock_context);
bool do_unmount;
rtems_filesystem_mt_entry_lock(lock_context);
2004e64: 7f ff f6 18 call 20026c4 <sparc_disable_interrupts>
2004e68: 01 00 00 00 nop
2004e6c: b8 10 00 08 mov %o0, %i4
)
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
2004e70: c4 06 00 00 ld [ %i0 ], %g2
previous = the_node->previous;
2004e74: c2 06 20 04 ld [ %i0 + 4 ], %g1
rtems_chain_extract_unprotected(&loc->mt_entry_node);
do_unmount = rtems_filesystem_is_ready_for_unmount(loc->mt_entry);
2004e78: d0 06 20 14 ld [ %i0 + 0x14 ], %o0
next->previous = previous;
2004e7c: c2 20 a0 04 st %g1, [ %g2 + 4 ]
2004e80: 7f ff ff a6 call 2004d18 <rtems_filesystem_is_ready_for_unmount>
2004e84: c4 20 40 00 st %g2, [ %g1 ]
2004e88: ba 10 00 08 mov %o0, %i5
rtems_filesystem_mt_entry_unlock(lock_context);
2004e8c: 7f ff f6 12 call 20026d4 <sparc_enable_interrupts>
2004e90: 90 10 00 1c mov %i4, %o0
if (do_unmount) {
2004e94: 80 8f 60 ff btst 0xff, %i5
2004e98: 02 80 00 05 be 2004eac <rtems_filesystem_location_remove_from_mt_entry+0x4c><== ALWAYS TAKEN
2004e9c: 01 00 00 00 nop
rtems_filesystem_do_unmount(loc->mt_entry);
2004ea0: f0 06 20 14 ld [ %i0 + 0x14 ], %i0 <== NOT EXECUTED
2004ea4: 7f ff ff d0 call 2004de4 <rtems_filesystem_do_unmount> <== NOT EXECUTED
2004ea8: 81 e8 00 00 restore <== NOT EXECUTED
2004eac: 81 c7 e0 08 ret
2004eb0: 81 e8 00 00 restore
02005098 <rtems_filesystem_location_transform_to_global>:
}
rtems_filesystem_global_location_t *rtems_filesystem_location_transform_to_global(
rtems_filesystem_location_info_t *loc
)
{
2005098: 9d e3 bf 98 save %sp, -104, %sp
rtems_filesystem_global_location_t *global_loc = malloc(sizeof(*global_loc));
200509c: 7f ff fa b9 call 2003b80 <malloc>
20050a0: 90 10 20 24 mov 0x24, %o0
if (global_loc != NULL) {
20050a4: ba 92 20 00 orcc %o0, 0, %i5
20050a8: 02 80 00 0b be 20050d4 <rtems_filesystem_location_transform_to_global+0x3c><== NEVER TAKEN
20050ac: 82 10 20 01 mov 1, %g1
global_loc->reference_count = 1;
global_loc->deferred_released_next = NULL;
20050b0: c0 27 60 1c clr [ %i5 + 0x1c ]
)
{
rtems_filesystem_global_location_t *global_loc = malloc(sizeof(*global_loc));
if (global_loc != NULL) {
global_loc->reference_count = 1;
20050b4: c2 27 60 18 st %g1, [ %i5 + 0x18 ]
global_loc->deferred_released_next = NULL;
global_loc->deferred_released_count = 0;
20050b8: c0 27 60 20 clr [ %i5 + 0x20 ]
rtems_filesystem_location_copy(&global_loc->location, loc);
20050bc: 7f ff ff 2e call 2004d74 <rtems_filesystem_location_copy>
20050c0: 92 10 00 18 mov %i0, %o1
rtems_filesystem_location_remove_from_mt_entry(loc);
20050c4: 7f ff ff 67 call 2004e60 <rtems_filesystem_location_remove_from_mt_entry>
20050c8: 90 10 00 18 mov %i0, %o0
global_loc = rtems_filesystem_global_location_obtain_null();
errno = ENOMEM;
}
return global_loc;
}
20050cc: 81 c7 e0 08 ret
20050d0: 91 e8 00 1d restore %g0, %i5, %o0
global_loc->deferred_released_next = NULL;
global_loc->deferred_released_count = 0;
rtems_filesystem_location_copy(&global_loc->location, loc);
rtems_filesystem_location_remove_from_mt_entry(loc);
} else {
rtems_filesystem_location_free(loc);
20050d4: 40 00 1b af call 200bf90 <rtems_filesystem_location_free> <== NOT EXECUTED
20050d8: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
static inline rtems_filesystem_global_location_t *
rtems_filesystem_global_location_obtain_null(void)
{
rtems_filesystem_global_location_t *global_loc = NULL;
return rtems_filesystem_global_location_obtain( &global_loc );
20050dc: 90 07 bf fc add %fp, -4, %o0 <== NOT EXECUTED
20050e0: 7f ff ff bb call 2004fcc <rtems_filesystem_global_location_obtain><== NOT EXECUTED
20050e4: c0 27 bf fc clr [ %fp + -4 ] <== NOT EXECUTED
global_loc = rtems_filesystem_global_location_obtain_null();
errno = ENOMEM;
20050e8: 40 00 2a 4a call 200fa10 <__errno> <== NOT EXECUTED
20050ec: ba 10 00 08 mov %o0, %i5 <== NOT EXECUTED
20050f0: 82 10 20 0c mov 0xc, %g1 <== NOT EXECUTED
20050f4: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
}
return global_loc;
}
20050f8: b0 10 00 1d mov %i5, %i0 <== NOT EXECUTED
20050fc: 81 c7 e0 08 ret <== NOT EXECUTED
2005100: 81 e8 00 00 restore <== NOT EXECUTED
02007fec <rtems_fsmount>:
)
/*-------------------------------------------------------------------------*\
| Return Value: |
| 0, if success, -1 and errno if failed |
\*=========================================================================*/
{
2007fec: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED
rc = tmp_rc;
}
}
else {
if (0 != (fstab_ptr->report_reasons & FSMOUNT_MNT_OK)) {
fprintf(stdout,"fsmount: mounting of \"%s\" to"
2007ff0: 23 00 81 7c sethi %hi(0x205f000), %l1 <== NOT EXECUTED
)
/*-------------------------------------------------------------------------*\
| Return Value: |
| 0, if success, -1 and errno if failed |
\*=========================================================================*/
{
2007ff4: ba 10 00 18 mov %i0, %i5 <== NOT EXECUTED
fstab_ptr->type,
fstab_ptr->options,
NULL);
if (tmp_rc != 0) {
if (0 != (fstab_ptr->report_reasons & FSMOUNT_MNT_FAILED)) {
fprintf(stdout,"fsmount: mounting of \"%s\" to"
2007ff8: 25 00 81 7c sethi %hi(0x205f000), %l2 <== NOT EXECUTED
*/
if (tmp_rc == 0) {
tmp_rc = rtems_mkdir(fstab_ptr->target, S_IRWXU | S_IRWXG | S_IRWXO);
if (tmp_rc != 0) {
if (0 != (fstab_ptr->report_reasons & FSMOUNT_MNTPNT_CRTERR)) {
fprintf(stdout,"fsmount: creation of mount point \"%s\" failed: %s\n",
2007ffc: 27 00 81 7b sethi %hi(0x205ec00), %l3 <== NOT EXECUTED
\*=========================================================================*/
{
int rc = 0;
int tmp_rc;
size_t fstab_idx = 0;
bool terminate = false;
2008000: 82 10 20 00 clr %g1 <== NOT EXECUTED
| 0, if success, -1 and errno if failed |
\*=========================================================================*/
{
int rc = 0;
int tmp_rc;
size_t fstab_idx = 0;
2008004: b8 10 20 00 clr %i4 <== NOT EXECUTED
/*-------------------------------------------------------------------------*\
| Return Value: |
| 0, if success, -1 and errno if failed |
\*=========================================================================*/
{
int rc = 0;
2008008: b0 10 20 00 clr %i0 <== NOT EXECUTED
rc = tmp_rc;
}
}
else {
if (0 != (fstab_ptr->report_reasons & FSMOUNT_MNT_OK)) {
fprintf(stdout,"fsmount: mounting of \"%s\" to"
200800c: 37 00 81 af sethi %hi(0x206bc00), %i3 <== NOT EXECUTED
2008010: a2 14 60 50 or %l1, 0x50, %l1 <== NOT EXECUTED
fstab_ptr->type,
fstab_ptr->options,
NULL);
if (tmp_rc != 0) {
if (0 != (fstab_ptr->report_reasons & FSMOUNT_MNT_FAILED)) {
fprintf(stdout,"fsmount: mounting of \"%s\" to"
2008014: a4 14 a0 20 or %l2, 0x20, %l2 <== NOT EXECUTED
bool terminate = false;
/*
* scan through all fstab entries;
*/
while (!terminate &&
2008018: 10 80 00 40 b 2008118 <rtems_fsmount+0x12c> <== NOT EXECUTED
200801c: a6 14 e3 e8 or %l3, 0x3e8, %l3 <== NOT EXECUTED
tmp_rc = 0;
/*
* create mount point
*/
if (tmp_rc == 0) {
tmp_rc = rtems_mkdir(fstab_ptr->target, S_IRWXU | S_IRWXG | S_IRWXO);
2008020: 40 00 07 fa call 200a008 <rtems_mkdir> <== NOT EXECUTED
2008024: 92 10 21 ff mov 0x1ff, %o1 <== NOT EXECUTED
if (tmp_rc != 0) {
2008028: a0 92 20 00 orcc %o0, 0, %l0 <== NOT EXECUTED
200802c: 22 80 00 47 be,a 2008148 <rtems_fsmount+0x15c> <== NOT EXECUTED
2008030: d0 07 40 00 ld [ %i5 ], %o0 <== NOT EXECUTED
if (0 != (fstab_ptr->report_reasons & FSMOUNT_MNTPNT_CRTERR)) {
2008034: c2 17 60 10 lduh [ %i5 + 0x10 ], %g1 <== NOT EXECUTED
2008038: 80 88 60 02 btst 2, %g1 <== NOT EXECUTED
200803c: 22 80 00 0e be,a 2008074 <rtems_fsmount+0x88> <== NOT EXECUTED
2008040: c2 17 60 12 lduh [ %i5 + 0x12 ], %g1 <== NOT EXECUTED
fprintf(stdout,"fsmount: creation of mount point \"%s\" failed: %s\n",
2008044: c2 06 e1 e0 ld [ %i3 + 0x1e0 ], %g1 <== NOT EXECUTED
2008048: e8 07 60 04 ld [ %i5 + 4 ], %l4 <== NOT EXECUTED
fstab_ptr->target,
strerror(errno));
200804c: 40 00 e8 68 call 20421ec <__errno> <== NOT EXECUTED
2008050: ea 00 60 08 ld [ %g1 + 8 ], %l5 <== NOT EXECUTED
*/
if (tmp_rc == 0) {
tmp_rc = rtems_mkdir(fstab_ptr->target, S_IRWXU | S_IRWXG | S_IRWXO);
if (tmp_rc != 0) {
if (0 != (fstab_ptr->report_reasons & FSMOUNT_MNTPNT_CRTERR)) {
fprintf(stdout,"fsmount: creation of mount point \"%s\" failed: %s\n",
2008054: 40 01 04 24 call 20490e4 <strerror> <== NOT EXECUTED
2008058: d0 02 00 00 ld [ %o0 ], %o0 <== NOT EXECUTED
200805c: 92 10 00 13 mov %l3, %o1 <== NOT EXECUTED
2008060: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
2008064: 94 10 00 14 mov %l4, %o2 <== NOT EXECUTED
2008068: 40 00 eb 1a call 2042cd0 <fprintf> <== NOT EXECUTED
200806c: 90 10 00 15 mov %l5, %o0 <== NOT EXECUTED
fstab_ptr->target,
strerror(errno));
}
if (0 != (fstab_ptr->abort_reasons & FSMOUNT_MNTPNT_CRTERR)) {
2008070: c2 17 60 12 lduh [ %i5 + 0x12 ], %g1 <== NOT EXECUTED
2008074: 10 80 00 14 b 20080c4 <rtems_fsmount+0xd8> <== NOT EXECUTED
2008078: 80 88 60 02 btst 2, %g1 <== NOT EXECUTED
fstab_ptr->target,
fstab_ptr->type,
fstab_ptr->options,
NULL);
if (tmp_rc != 0) {
if (0 != (fstab_ptr->report_reasons & FSMOUNT_MNT_FAILED)) {
200807c: 80 88 60 04 btst 4, %g1 <== NOT EXECUTED
2008080: 22 80 00 10 be,a 20080c0 <rtems_fsmount+0xd4> <== NOT EXECUTED
2008084: c2 17 60 12 lduh [ %i5 + 0x12 ], %g1 <== NOT EXECUTED
fprintf(stdout,"fsmount: mounting of \"%s\" to"
2008088: c2 06 e1 e0 ld [ %i3 + 0x1e0 ], %g1 <== NOT EXECUTED
200808c: ea 07 40 00 ld [ %i5 ], %l5 <== NOT EXECUTED
2008090: ec 00 60 08 ld [ %g1 + 8 ], %l6 <== NOT EXECUTED
" \"%s\" failed: %s\n",
fstab_ptr->source,
fstab_ptr->target,
strerror(errno));
2008094: 40 00 e8 56 call 20421ec <__errno> <== NOT EXECUTED
2008098: e8 07 60 04 ld [ %i5 + 4 ], %l4 <== NOT EXECUTED
fstab_ptr->type,
fstab_ptr->options,
NULL);
if (tmp_rc != 0) {
if (0 != (fstab_ptr->report_reasons & FSMOUNT_MNT_FAILED)) {
fprintf(stdout,"fsmount: mounting of \"%s\" to"
200809c: 40 01 04 12 call 20490e4 <strerror> <== NOT EXECUTED
20080a0: d0 02 00 00 ld [ %o0 ], %o0 <== NOT EXECUTED
20080a4: 92 10 00 12 mov %l2, %o1 <== NOT EXECUTED
20080a8: 98 10 00 08 mov %o0, %o4 <== NOT EXECUTED
20080ac: 94 10 00 15 mov %l5, %o2 <== NOT EXECUTED
20080b0: 90 10 00 16 mov %l6, %o0 <== NOT EXECUTED
20080b4: 40 00 eb 07 call 2042cd0 <fprintf> <== NOT EXECUTED
20080b8: 96 10 00 14 mov %l4, %o3 <== NOT EXECUTED
" \"%s\" failed: %s\n",
fstab_ptr->source,
fstab_ptr->target,
strerror(errno));
}
if (0 != (fstab_ptr->abort_reasons & FSMOUNT_MNT_FAILED)) {
20080bc: c2 17 60 12 lduh [ %i5 + 0x12 ], %g1 <== NOT EXECUTED
20080c0: 80 88 60 04 btst 4, %g1 <== NOT EXECUTED
20080c4: 32 80 00 14 bne,a 2008114 <rtems_fsmount+0x128> <== NOT EXECUTED
20080c8: b0 10 00 10 mov %l0, %i0 <== NOT EXECUTED
}
/*
* proceed to next entry
*/
if (!terminate) {
fstab_ptr++;
20080cc: 10 80 00 0f b 2008108 <rtems_fsmount+0x11c> <== NOT EXECUTED
20080d0: ba 07 60 14 add %i5, 0x14, %i5 <== NOT EXECUTED
terminate = true;
rc = tmp_rc;
}
}
else {
if (0 != (fstab_ptr->report_reasons & FSMOUNT_MNT_OK)) {
20080d4: 22 80 00 09 be,a 20080f8 <rtems_fsmount+0x10c> <== NOT EXECUTED
20080d8: c2 17 60 12 lduh [ %i5 + 0x12 ], %g1 <== NOT EXECUTED
fprintf(stdout,"fsmount: mounting of \"%s\" to"
20080dc: c2 06 e1 e0 ld [ %i3 + 0x1e0 ], %g1 <== NOT EXECUTED
20080e0: d4 07 40 00 ld [ %i5 ], %o2 <== NOT EXECUTED
20080e4: d0 00 60 08 ld [ %g1 + 8 ], %o0 <== NOT EXECUTED
20080e8: d6 07 60 04 ld [ %i5 + 4 ], %o3 <== NOT EXECUTED
20080ec: 40 00 ea f9 call 2042cd0 <fprintf> <== NOT EXECUTED
20080f0: 92 10 00 11 mov %l1, %o1 <== NOT EXECUTED
" \"%s\" succeeded\n",
fstab_ptr->source,
fstab_ptr->target);
}
if (0 != (fstab_ptr->abort_reasons & FSMOUNT_MNT_OK)) {
20080f4: c2 17 60 12 lduh [ %i5 + 0x12 ], %g1 <== NOT EXECUTED
20080f8: 80 88 60 01 btst 1, %g1 <== NOT EXECUTED
20080fc: 32 80 00 07 bne,a 2008118 <rtems_fsmount+0x12c> <== NOT EXECUTED
2008100: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED
}
/*
* proceed to next entry
*/
if (!terminate) {
fstab_ptr++;
2008104: ba 07 60 14 add %i5, 0x14, %i5 <== NOT EXECUTED
fstab_idx++;
2008108: b8 07 20 01 inc %i4 <== NOT EXECUTED
200810c: 10 80 00 03 b 2008118 <rtems_fsmount+0x12c> <== NOT EXECUTED
2008110: 82 10 20 00 clr %g1 <== NOT EXECUTED
fprintf(stdout,"fsmount: creation of mount point \"%s\" failed: %s\n",
fstab_ptr->target,
strerror(errno));
}
if (0 != (fstab_ptr->abort_reasons & FSMOUNT_MNTPNT_CRTERR)) {
terminate = true;
2008114: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED
bool terminate = false;
/*
* scan through all fstab entries;
*/
while (!terminate &&
2008118: 80 a7 00 19 cmp %i4, %i1 <== NOT EXECUTED
200811c: 1a 80 00 05 bcc 2008130 <rtems_fsmount+0x144> <== NOT EXECUTED
2008120: 82 18 60 01 xor %g1, 1, %g1 <== NOT EXECUTED
2008124: 80 88 60 ff btst 0xff, %g1 <== NOT EXECUTED
2008128: 32 bf ff be bne,a 2008020 <rtems_fsmount+0x34> <== NOT EXECUTED
200812c: d0 07 60 04 ld [ %i5 + 4 ], %o0 <== NOT EXECUTED
if (!terminate) {
fstab_ptr++;
fstab_idx++;
}
}
if (fail_idx != NULL) {
2008130: 80 a6 a0 00 cmp %i2, 0 <== NOT EXECUTED
2008134: 02 80 00 0f be 2008170 <rtems_fsmount+0x184> <== NOT EXECUTED
2008138: 01 00 00 00 nop <== NOT EXECUTED
*fail_idx = fstab_idx;
200813c: f8 26 80 00 st %i4, [ %i2 ] <== NOT EXECUTED
2008140: 81 c7 e0 08 ret <== NOT EXECUTED
2008144: 81 e8 00 00 restore <== NOT EXECUTED
}
/*
* mount device to given mount point
*/
if (tmp_rc == 0) {
tmp_rc = mount(fstab_ptr->source,
2008148: d2 07 60 04 ld [ %i5 + 4 ], %o1 <== NOT EXECUTED
200814c: d4 07 60 08 ld [ %i5 + 8 ], %o2 <== NOT EXECUTED
2008150: d6 07 60 0c ld [ %i5 + 0xc ], %o3 <== NOT EXECUTED
2008154: 40 00 04 c2 call 200945c <mount> <== NOT EXECUTED
2008158: 98 10 20 00 clr %o4 <== NOT EXECUTED
fstab_ptr->target,
fstab_ptr->type,
fstab_ptr->options,
NULL);
if (tmp_rc != 0) {
200815c: a0 92 20 00 orcc %o0, 0, %l0 <== NOT EXECUTED
2008160: 12 bf ff c7 bne 200807c <rtems_fsmount+0x90> <== NOT EXECUTED
2008164: c2 17 60 10 lduh [ %i5 + 0x10 ], %g1 <== NOT EXECUTED
terminate = true;
rc = tmp_rc;
}
}
else {
if (0 != (fstab_ptr->report_reasons & FSMOUNT_MNT_OK)) {
2008168: 10 bf ff db b 20080d4 <rtems_fsmount+0xe8> <== NOT EXECUTED
200816c: 80 88 60 01 btst 1, %g1 <== NOT EXECUTED
}
if (fail_idx != NULL) {
*fail_idx = fstab_idx;
}
return rc;
}
2008170: 81 c7 e0 08 ret <== NOT EXECUTED
2008174: 81 e8 00 00 restore <== NOT EXECUTED
02003fd0 <rtems_gxx_key_create>:
int rtems_gxx_key_create (__gthread_key_t *key, void (*dtor) (void *))
{
2003fd0: 9d e3 bf a0 save %sp, -96, %sp
* 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 ) );
2003fd4: 40 00 01 16 call 200442c <malloc>
2003fd8: 90 10 20 08 mov 8, %o0
*key = new_key;
2003fdc: d0 26 00 00 st %o0, [ %i0 ]
* 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 ) );
2003fe0: ba 10 00 08 mov %o0, %i5
*key = new_key;
new_key->val = NULL;
2003fe4: c0 22 00 00 clr [ %o0 ]
new_key->dtor = dtor;
2003fe8: f2 22 20 04 st %i1, [ %o0 + 4 ]
"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 );
2003fec: 92 10 00 1d mov %i5, %o1
2003ff0: 90 10 20 00 clr %o0
2003ff4: 94 10 00 19 mov %i1, %o2
2003ff8: 40 00 11 e4 call 2008788 <rtems_task_variable_add>
2003ffc: b0 10 20 00 clr %i0
if ( status == RTEMS_SUCCESSFUL )
2004000: 80 a2 20 00 cmp %o0, 0
2004004: 02 80 00 04 be 2004014 <rtems_gxx_key_create+0x44> <== ALWAYS TAKEN
2004008: 90 10 00 1d mov %i5, %o0
return 0;
free( new_key );
200400c: 7f ff ff 81 call 2003e10 <free> <== NOT EXECUTED
2004010: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
return -1;
}
2004014: 81 c7 e0 08 ret
2004018: 81 e8 00 00 restore
02004028 <rtems_gxx_key_delete>:
int rtems_gxx_key_delete (__gthread_key_t key)
{
2004028: 9d e3 bf a0 save %sp, -96, %sp
#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 );
200402c: 90 10 20 00 clr %o0
2004030: 40 00 12 01 call 2008834 <rtems_task_variable_delete>
2004034: 92 10 00 18 mov %i0, %o1
if ( status == RTEMS_SUCCESSFUL ) {
2004038: 80 a2 20 00 cmp %o0, 0
200403c: 12 80 00 06 bne 2004054 <rtems_gxx_key_delete+0x2c> <== NEVER TAKEN
2004040: 80 a6 20 00 cmp %i0, 0
/* Hmm - hopefully all tasks using this key have gone away... */
if ( key ) free( *(void **)key );
2004044: 02 80 00 04 be 2004054 <rtems_gxx_key_delete+0x2c> <== NEVER TAKEN
2004048: 01 00 00 00 nop
200404c: 7f ff ff 71 call 2003e10 <free>
2004050: d0 06 00 00 ld [ %i0 ], %o0
return 0;
}
key = NULL;
return 0;
}
2004054: 81 c7 e0 08 ret
2004058: 91 e8 20 00 restore %g0, 0, %o0
02003f6c <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))
{
2003f6c: 9d e3 bf 98 save %sp, -104, %sp
#ifdef DEBUG_GXX_WRAPPERS
printk( "gxx_wrappers: once=%x, func=%x\n", *once, func );
#endif
if ( *(volatile __gthread_once_t *)once == 0 ) {
2003f70: c2 06 00 00 ld [ %i0 ], %g1
2003f74: 80 a0 60 00 cmp %g1, 0
2003f78: 12 80 00 14 bne 2003fc8 <rtems_gxx_once+0x5c>
2003f7c: 90 10 21 00 mov 0x100, %o0
rtems_mode saveMode;
__gthread_once_t o;
rtems_task_mode(RTEMS_NO_PREEMPT, RTEMS_PREEMPT_MASK, &saveMode);
2003f80: 92 10 21 00 mov 0x100, %o1
2003f84: 40 00 11 87 call 20085a0 <rtems_task_mode>
2003f88: 94 07 bf fc add %fp, -4, %o2
if ( (o = *(volatile __gthread_once_t *)once) == 0 ) {
2003f8c: fa 06 00 00 ld [ %i0 ], %i5
2003f90: 80 a7 60 00 cmp %i5, 0
2003f94: 12 80 00 05 bne 2003fa8 <rtems_gxx_once+0x3c> <== NEVER TAKEN
2003f98: d0 07 bf fc ld [ %fp + -4 ], %o0
*(volatile __gthread_once_t *)once = 1;
2003f9c: 82 10 20 01 mov 1, %g1
2003fa0: c2 26 00 00 st %g1, [ %i0 ]
}
rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode);
2003fa4: d0 07 bf fc ld [ %fp + -4 ], %o0
2003fa8: 92 10 21 00 mov 0x100, %o1
2003fac: 40 00 11 7d call 20085a0 <rtems_task_mode>
2003fb0: 94 07 bf fc add %fp, -4, %o2
if ( o == 0 )
2003fb4: 80 a7 60 00 cmp %i5, 0
2003fb8: 12 80 00 04 bne 2003fc8 <rtems_gxx_once+0x5c> <== NEVER TAKEN
2003fbc: 01 00 00 00 nop
(*func)();
2003fc0: 9f c6 40 00 call %i1
2003fc4: 01 00 00 00 nop
}
return 0;
}
2003fc8: 81 c7 e0 08 ret
2003fcc: 91 e8 20 00 restore %g0, 0, %o0
020040c0 <rtems_gxx_setspecific>:
int rtems_gxx_setspecific(__gthread_key_t key, const void *ptr)
{
20040c0: 9d e3 bf a0 save %sp, -96, %sp
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 );
20040c4: d4 06 20 04 ld [ %i0 + 4 ], %o2
20040c8: 90 10 20 00 clr %o0
20040cc: 40 00 11 af call 2008788 <rtems_task_variable_add>
20040d0: 92 10 00 18 mov %i0, %o1
if ( status == RTEMS_SUCCESSFUL ) {
20040d4: 80 a2 20 00 cmp %o0, 0
20040d8: 12 80 00 05 bne 20040ec <rtems_gxx_setspecific+0x2c> <== NEVER TAKEN
20040dc: 01 00 00 00 nop
/* now let's set the proper value */
key->val = (void *)ptr;
20040e0: f2 26 00 00 st %i1, [ %i0 ]
return 0;
20040e4: 81 c7 e0 08 ret
20040e8: 91 e8 20 00 restore %g0, 0, %o0
}
return -1;
}
20040ec: 81 c7 e0 08 ret <== NOT EXECUTED
20040f0: 91 e8 3f ff restore %g0, -1, %o0 <== NOT EXECUTED
02007e48 <rtems_heap_allocate_aligned_with_boundary>:
void *rtems_heap_allocate_aligned_with_boundary(
size_t size,
uintptr_t alignment,
uintptr_t boundary
)
{
2007e48: 9d e3 bf a0 save %sp, -96, %sp
if (
2007e4c: 03 00 80 91 sethi %hi(0x2024400), %g1
2007e50: c2 00 63 80 ld [ %g1 + 0x380 ], %g1 ! 2024780 <_System_state_Current>
void *rtems_heap_allocate_aligned_with_boundary(
size_t size,
uintptr_t alignment,
uintptr_t boundary
)
{
2007e54: ba 10 00 18 mov %i0, %i5
2007e58: b8 10 00 19 mov %i1, %i4
if (
2007e5c: 80 a0 60 03 cmp %g1, 3
2007e60: 02 80 00 08 be 2007e80 <rtems_heap_allocate_aligned_with_boundary+0x38><== ALWAYS TAKEN
2007e64: b6 10 00 1a mov %i2, %i3
&& !malloc_is_system_state_OK()
) {
return NULL;
}
malloc_deferred_frees_process();
2007e68: 7f ff fb e6 call 2006e00 <malloc_deferred_frees_process>
2007e6c: b2 10 00 1d mov %i5, %i1
/* FIXME: Statistics, boundary checks */
return _Protected_heap_Allocate_aligned_with_boundary(
2007e70: 03 00 80 8c sethi %hi(0x2023000), %g1
2007e74: f0 00 60 60 ld [ %g1 + 0x60 ], %i0 ! 2023060 <RTEMS_Malloc_Heap>
2007e78: 40 00 17 45 call 200db8c <_Protected_heap_Allocate_aligned_with_boundary>
2007e7c: 95 e8 00 1c restore %g0, %i4, %o2
uintptr_t boundary
)
{
if (
_System_state_Is_up( _System_state_Get() )
&& !malloc_is_system_state_OK()
2007e80: 7f ff fb cd call 2006db4 <malloc_is_system_state_OK>
2007e84: 01 00 00 00 nop
2007e88: 80 8a 20 ff btst 0xff, %o0
2007e8c: 12 bf ff f7 bne 2007e68 <rtems_heap_allocate_aligned_with_boundary+0x20>
2007e90: b0 10 20 00 clr %i0
RTEMS_Malloc_Heap,
size,
alignment,
boundary
);
}
2007e94: 81 c7 e0 08 ret
2007e98: 81 e8 00 00 restore
02004f60 <rtems_ide_part_table_free>:
* N/A
*/
void
rtems_ide_part_table_free(rtems_disk_desc_t *disk_desc)
{
partition_table_free( disk_desc );
2004f60: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED
2004f64: 7f ff fe d1 call 2004aa8 <partition_table_free> <== NOT EXECUTED
2004f68: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED
02004f6c <rtems_ide_part_table_get>:
* RTEMS_INTERNAL_ERROR otherwise
*/
rtems_status_code
rtems_ide_part_table_get(const char *dev_name, rtems_disk_desc_t *disk_desc)
{
return partition_table_get( dev_name, disk_desc );
2004f6c: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED
2004f70: 7f ff ff 87 call 2004d8c <partition_table_get> <== NOT EXECUTED
2004f74: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED
02004f78 <rtems_ide_part_table_initialize>:
* RTEMS_NO_MEMOTY if cannot have not enough memory,
* RTEMS_INTERNAL_ERROR if other error occurs.
*/
rtems_status_code
rtems_ide_part_table_initialize(const char *dev_name)
{
2004f78: 9d e3 bf 88 save %sp, -120, %sp
rtems_part_desc_t *part_desc;
/* logical device name /dev/hdxyy */
char name[RTEMS_IDE_PARTITION_DEV_NAME_LENGTH_MAX];
disk_desc = (rtems_disk_desc_t *) calloc(1, sizeof(rtems_disk_desc_t));
2004f7c: 90 10 20 01 mov 1, %o0
2004f80: 92 10 21 28 mov 0x128, %o1
2004f84: 40 00 01 f7 call 2005760 <calloc>
2004f88: b6 10 20 1a mov 0x1a, %i3
if (disk_desc == NULL)
2004f8c: 80 a2 20 00 cmp %o0, 0
2004f90: 02 80 00 34 be 2005060 <rtems_ide_part_table_initialize+0xe8><== NEVER TAKEN
2004f94: ba 10 00 08 mov %o0, %i5
{
return RTEMS_NO_MEMORY;
}
/* get partition table */
rc = partition_table_get(dev_name, disk_desc);
2004f98: 90 10 00 18 mov %i0, %o0
2004f9c: 7f ff ff 7c call 2004d8c <partition_table_get>
2004fa0: 92 10 00 1d mov %i5, %o1
if (rc != RTEMS_SUCCESSFUL)
2004fa4: b6 92 20 00 orcc %o0, 0, %i3
2004fa8: 02 80 00 06 be 2004fc0 <rtems_ide_part_table_initialize+0x48><== ALWAYS TAKEN
2004fac: 23 00 80 91 sethi %hi(0x2024400), %l1
{
free(disk_desc);
2004fb0: 40 00 02 c1 call 2005ab4 <free> <== NOT EXECUTED
2004fb4: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
}
partition_table_free(disk_desc);
return RTEMS_SUCCESSFUL;
}
2004fb8: 81 c7 e0 08 ret <== NOT EXECUTED
2004fbc: 91 e8 00 1b restore %g0, %i3, %o0 <== NOT EXECUTED
rc = rtems_disk_create_log(dev, disk_desc->dev, part_desc->start,
part_desc->size, name);
if (rc != RTEMS_SUCCESSFUL)
{
fprintf(stdout,"Cannot create device %s, error code %d\n", name, rc);
2004fc0: 27 00 80 91 sethi %hi(0x2024400), %l3
/* To avoid device numbers conflicts we have to use for logic disk the same
* device major number as ATA device has, and minor number that equals to
* sum of logic disk partition number and the minor number of physical disk
*/
rtems_filesystem_split_dev_t (disk_desc->dev, major, minor);
2004fc4: f2 07 40 00 ld [ %i5 ], %i1
2004fc8: e0 07 60 04 ld [ %i5 + 4 ], %l0
/* create logical disks on the physical one */
for (part_num = 0; part_num < disk_desc->last_log_id; part_num++)
2004fcc: b8 10 20 00 clr %i4
{
sprintf(name, "%s%d", dev_name, part_num + 1);
2004fd0: b4 07 bf f0 add %fp, -16, %i2
2004fd4: a2 14 61 00 or %l1, 0x100, %l1
rc = rtems_disk_create_log(dev, disk_desc->dev, part_desc->start,
part_desc->size, name);
if (rc != RTEMS_SUCCESSFUL)
{
fprintf(stdout,"Cannot create device %s, error code %d\n", name, rc);
2004fd8: 25 00 80 99 sethi %hi(0x2026400), %l2
*/
rtems_filesystem_split_dev_t (disk_desc->dev, major, minor);
/* create logical disks on the physical one */
for (part_num = 0; part_num < disk_desc->last_log_id; part_num++)
2004fdc: 10 80 00 1b b 2005048 <rtems_ide_part_table_initialize+0xd0>
2004fe0: a6 14 e1 08 or %l3, 0x108, %l3
{
sprintf(name, "%s%d", dev_name, part_num + 1);
2004fe4: 92 10 00 11 mov %l1, %o1
2004fe8: 90 10 00 1a mov %i2, %o0
2004fec: 94 10 00 18 mov %i0, %o2
2004ff0: 40 00 43 cb call 2015f1c <sprintf>
2004ff4: 96 10 00 1c mov %i4, %o3
* RTEMS_SUCCESSFUL if success,
* RTEMS_NO_MEMOTY if cannot have not enough memory,
* RTEMS_INTERNAL_ERROR if other error occurs.
*/
rtems_status_code
rtems_ide_part_table_initialize(const char *dev_name)
2004ff8: 83 2f 20 02 sll %i4, 2, %g1
2004ffc: 82 07 40 01 add %i5, %g1, %g1
for (part_num = 0; part_num < disk_desc->last_log_id; part_num++)
{
sprintf(name, "%s%d", dev_name, part_num + 1);
dev = rtems_filesystem_make_dev_t(major, ++minor);
part_desc = disk_desc->partitions[part_num];
2005000: c2 00 60 24 ld [ %g1 + 0x24 ], %g1
if (part_desc == NULL)
2005004: 80 a0 60 00 cmp %g1, 0
2005008: 02 80 00 10 be 2005048 <rtems_ide_part_table_initialize+0xd0>
200500c: 92 07 00 10 add %i4, %l0, %o1
{
continue;
}
rc = rtems_disk_create_log(dev, disk_desc->dev, part_desc->start,
2005010: d4 1f 40 00 ldd [ %i5 ], %o2
2005014: d8 00 60 04 ld [ %g1 + 4 ], %o4
2005018: da 00 60 08 ld [ %g1 + 8 ], %o5
200501c: 90 10 00 19 mov %i1, %o0
2005020: 7f ff fd 63 call 20045ac <rtems_disk_create_log>
2005024: f4 23 a0 5c st %i2, [ %sp + 0x5c ]
part_desc->size, name);
if (rc != RTEMS_SUCCESSFUL)
2005028: 96 92 20 00 orcc %o0, 0, %o3
200502c: 22 80 00 08 be,a 200504c <rtems_ide_part_table_initialize+0xd4><== ALWAYS TAKEN
2005030: c2 07 60 24 ld [ %i5 + 0x24 ], %g1
{
fprintf(stdout,"Cannot create device %s, error code %d\n", name, rc);
2005034: c2 04 a1 10 ld [ %l2 + 0x110 ], %g1 <== NOT EXECUTED
2005038: 92 10 00 13 mov %l3, %o1 <== NOT EXECUTED
200503c: d0 00 60 08 ld [ %g1 + 8 ], %o0 <== NOT EXECUTED
2005040: 40 00 41 29 call 20154e4 <fprintf> <== NOT EXECUTED
2005044: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED
*/
rtems_filesystem_split_dev_t (disk_desc->dev, major, minor);
/* create logical disks on the physical one */
for (part_num = 0; part_num < disk_desc->last_log_id; part_num++)
2005048: c2 07 60 24 ld [ %i5 + 0x24 ], %g1
200504c: 80 a7 00 01 cmp %i4, %g1
2005050: 26 bf ff e5 bl,a 2004fe4 <rtems_ide_part_table_initialize+0x6c>
2005054: b8 07 20 01 inc %i4
fprintf(stdout,"Cannot create device %s, error code %d\n", name, rc);
continue;
}
}
partition_table_free(disk_desc);
2005058: 7f ff fe 94 call 2004aa8 <partition_table_free>
200505c: 90 10 00 1d mov %i5, %o0
return RTEMS_SUCCESSFUL;
}
2005060: b0 10 00 1b mov %i3, %i0
2005064: 81 c7 e0 08 ret
2005068: 81 e8 00 00 restore
0200a5b8 <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)
{
200a5b8: 9d e3 bf a0 save %sp, -96, %sp
uint32_t i;
uint32_t api_index;
Thread_Control *the_thread;
Objects_Information *information;
if ( !routine )
200a5bc: ba 10 20 01 mov 1, %i5
200a5c0: 80 a6 20 00 cmp %i0, 0
200a5c4: 02 80 00 0d be 200a5f8 <rtems_iterate_over_all_threads+0x40><== NEVER TAKEN
200a5c8: 35 00 80 81 sethi %hi(0x2020400), %i2
#endif
#include <rtems/system.h>
#include <rtems/score/thread.h>
void rtems_iterate_over_all_threads(rtems_per_thread_routine routine)
200a5cc: 83 2f 60 02 sll %i5, 2, %g1
#if !defined(RTEMS_POSIX_API) || defined(RTEMS_DEBUG)
if ( !_Objects_Information_table[ api_index ] )
continue;
#endif
information = _Objects_Information_table[ api_index ][ 1 ];
200a5d0: 84 16 a1 34 or %i2, 0x134, %g2
200a5d4: c2 00 80 01 ld [ %g2 + %g1 ], %g1
200a5d8: f6 00 60 04 ld [ %g1 + 4 ], %i3
if ( !information )
200a5dc: 80 a6 e0 00 cmp %i3, 0
200a5e0: 12 80 00 0f bne 200a61c <rtems_iterate_over_all_threads+0x64>
200a5e4: b8 10 20 01 mov 1, %i4
Objects_Information *information;
if ( !routine )
return;
for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; api_index++ ) {
200a5e8: ba 07 60 01 inc %i5
200a5ec: 80 a7 60 04 cmp %i5, 4
200a5f0: 12 bf ff f8 bne 200a5d0 <rtems_iterate_over_all_threads+0x18>
200a5f4: 83 2f 60 02 sll %i5, 2, %g1
200a5f8: 81 c7 e0 08 ret
200a5fc: 81 e8 00 00 restore
information = _Objects_Information_table[ api_index ][ 1 ];
if ( !information )
continue;
for ( i=1 ; i <= information->maximum ; i++ ) {
the_thread = (Thread_Control *)information->local_table[ i ];
200a600: 83 2f 20 02 sll %i4, 2, %g1
200a604: d0 00 80 01 ld [ %g2 + %g1 ], %o0
if ( !the_thread )
200a608: 80 a2 20 00 cmp %o0, 0
200a60c: 02 80 00 04 be 200a61c <rtems_iterate_over_all_threads+0x64>
200a610: b8 07 20 01 inc %i4
continue;
(*routine)(the_thread);
200a614: 9f c6 00 00 call %i0
200a618: 01 00 00 00 nop
information = _Objects_Information_table[ api_index ][ 1 ];
if ( !information )
continue;
for ( i=1 ; i <= information->maximum ; i++ ) {
200a61c: c2 16 e0 10 lduh [ %i3 + 0x10 ], %g1
200a620: 80 a7 00 01 cmp %i4, %g1
200a624: 28 bf ff f7 bleu,a 200a600 <rtems_iterate_over_all_threads+0x48>
200a628: c4 06 e0 1c ld [ %i3 + 0x1c ], %g2
Objects_Information *information;
if ( !routine )
return;
for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; api_index++ ) {
200a62c: 10 bf ff f0 b 200a5ec <rtems_iterate_over_all_threads+0x34>
200a630: ba 07 60 01 inc %i5
02003938 <rtems_libio_init>:
*
* Called by BSP startup code to initialize the libio subsystem.
*/
void rtems_libio_init( void )
{
2003938: 9d e3 bf a0 save %sp, -96, %sp
rtems_status_code rc;
uint32_t i;
rtems_libio_t *iop;
if (rtems_libio_number_iops > 0)
200393c: 03 00 80 73 sethi %hi(0x201cc00), %g1
2003940: fa 00 62 20 ld [ %g1 + 0x220 ], %i5 ! 201ce20 <rtems_libio_number_iops>
2003944: 80 a7 60 00 cmp %i5, 0
2003948: 02 80 00 1b be 20039b4 <rtems_libio_init+0x7c> <== NEVER TAKEN
200394c: 11 13 10 92 sethi %hi(0x4c424800), %o0
{
rtems_libio_iops = (rtems_libio_t *) calloc(rtems_libio_number_iops,
2003950: 90 10 00 1d mov %i5, %o0
2003954: 7f ff fe ee call 200350c <calloc>
2003958: 92 10 20 38 mov 0x38, %o1
200395c: 03 00 80 76 sethi %hi(0x201d800), %g1
sizeof(rtems_libio_t));
if (rtems_libio_iops == NULL)
2003960: 80 a2 20 00 cmp %o0, 0
2003964: 12 80 00 04 bne 2003974 <rtems_libio_init+0x3c>
2003968: d0 20 61 40 st %o0, [ %g1 + 0x140 ]
rtems_fatal_error_occurred(RTEMS_NO_MEMORY);
200396c: 10 80 00 1c b 20039dc <rtems_libio_init+0xa4>
2003970: 90 10 20 1a mov 0x1a, %o0
iop = rtems_libio_iop_freelist = rtems_libio_iops;
2003974: 03 00 80 76 sethi %hi(0x201d800), %g1
for (i = 0 ; (i + 1) < rtems_libio_number_iops ; i++, iop++)
2003978: 84 10 00 08 mov %o0, %g2
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;
200397c: d0 20 61 44 st %o0, [ %g1 + 0x144 ]
for (i = 0 ; (i + 1) < rtems_libio_number_iops ; i++, iop++)
2003980: 10 80 00 03 b 200398c <rtems_libio_init+0x54>
2003984: 82 10 20 00 clr %g1
iop->data1 = iop + 1;
2003988: c4 20 bf f8 st %g2, [ %g2 + -8 ]
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++)
200398c: 82 00 60 01 inc %g1
2003990: 80 a0 40 1d cmp %g1, %i5
2003994: 12 bf ff fd bne 2003988 <rtems_libio_init+0x50>
2003998: 84 00 a0 38 add %g2, 0x38, %g2
iop->data1 = iop + 1;
iop->data1 = NULL;
200399c: 85 28 60 03 sll %g1, 3, %g2
20039a0: 83 28 60 06 sll %g1, 6, %g1
20039a4: 82 20 40 02 sub %g1, %g2, %g1
20039a8: 90 02 00 01 add %o0, %g1, %o0
20039ac: c0 22 3f f8 clr [ %o0 + -8 ]
/*
* Create the binary semaphore used to provide mutual exclusion
* on the IOP Table.
*/
rc = rtems_semaphore_create(
20039b0: 11 13 10 92 sethi %hi(0x4c424800), %o0
20039b4: 92 10 20 01 mov 1, %o1
20039b8: 90 12 21 4f or %o0, 0x14f, %o0
20039bc: 94 10 20 54 mov 0x54, %o2
20039c0: 96 10 20 00 clr %o3
20039c4: 19 00 80 76 sethi %hi(0x201d800), %o4
20039c8: 40 00 0f 29 call 200766c <rtems_semaphore_create>
20039cc: 98 13 21 48 or %o4, 0x148, %o4 ! 201d948 <rtems_libio_semaphore>
1,
RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY,
RTEMS_NO_PRIORITY,
&rtems_libio_semaphore
);
if ( rc != RTEMS_SUCCESSFUL )
20039d0: 80 a2 20 00 cmp %o0, 0
20039d4: 02 80 00 04 be 20039e4 <rtems_libio_init+0xac> <== ALWAYS TAKEN
20039d8: 03 00 80 73 sethi %hi(0x201cc00), %g1
rtems_fatal_error_occurred( rc );
20039dc: 40 00 11 87 call 2007ff8 <rtems_fatal_error_occurred>
20039e0: 01 00 00 00 nop
/*
* Initialize the base file system infrastructure.
*/
if (rtems_fs_init_helper)
20039e4: c2 00 62 24 ld [ %g1 + 0x224 ], %g1
20039e8: 80 a0 60 00 cmp %g1, 0
20039ec: 02 80 00 04 be 20039fc <rtems_libio_init+0xc4>
20039f0: 01 00 00 00 nop
(* rtems_fs_init_helper)();
20039f4: 9f c0 40 00 call %g1
20039f8: 01 00 00 00 nop
20039fc: 81 c7 e0 08 ret
2003a00: 81 e8 00 00 restore
0202909c <rtems_libio_set_private_env>:
}
rtems_status_code rtems_libio_set_private_env(void)
{
202909c: 9d e3 bf a0 save %sp, -96, %sp
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_id self_task_id = rtems_task_self();
20290a0: 7f ff 92 67 call 200da3c <rtems_task_self>
20290a4: 01 00 00 00 nop
rtems_user_env_t *old_env = rtems_current_user_env;
20290a8: 03 00 81 ad sethi %hi(0x206b400), %g1
20290ac: f8 00 61 5c ld [ %g1 + 0x15c ], %i4 ! 206b55c <rtems_current_user_env>
bool uses_global_env = old_env == &rtems_global_user_env;
bool uses_shared_env = old_env->task_id != self_task_id;
20290b0: c2 07 20 24 ld [ %i4 + 0x24 ], %g1
if (uses_global_env || uses_shared_env) {
20290b4: 80 a0 40 08 cmp %g1, %o0
20290b8: 12 80 00 07 bne 20290d4 <rtems_libio_set_private_env+0x38>
20290bc: b6 10 00 08 mov %o0, %i3
20290c0: 03 00 81 ad sethi %hi(0x206b400), %g1
20290c4: 82 10 61 60 or %g1, 0x160, %g1 ! 206b560 <rtems_global_user_env>
20290c8: 80 a7 00 01 cmp %i4, %g1
20290cc: 12 80 00 2b bne 2029178 <rtems_libio_set_private_env+0xdc><== ALWAYS TAKEN
20290d0: b0 10 20 00 clr %i0
rtems_user_env_t *new_env = calloc(1, sizeof(*new_env));
20290d4: 90 10 20 01 mov 1, %o0
20290d8: 92 10 20 2c mov 0x2c, %o1
20290dc: 7f ff 7d e4 call 200886c <calloc>
20290e0: b0 10 20 1a mov 0x1a, %i0
if (new_env != NULL) {
20290e4: 80 a2 20 00 cmp %o0, 0
20290e8: 02 80 00 24 be 2029178 <rtems_libio_set_private_env+0xdc>
20290ec: ba 10 00 08 mov %o0, %i5
*new_env = *old_env;
20290f0: 92 10 00 1c mov %i4, %o1
20290f4: 40 00 71 7d call 20456e8 <memcpy>
20290f8: 94 10 20 2c mov 0x2c, %o2
new_env->reference_count = 1;
20290fc: 82 10 20 01 mov 1, %g1
new_env->task_id = self_task_id;
2029100: f6 27 60 24 st %i3, [ %i5 + 0x24 ]
if (uses_global_env || uses_shared_env) {
rtems_user_env_t *new_env = calloc(1, sizeof(*new_env));
if (new_env != NULL) {
*new_env = *old_env;
new_env->reference_count = 1;
2029104: c2 27 60 28 st %g1, [ %i5 + 0x28 ]
new_env->task_id = self_task_id;
new_env->root_directory =
rtems_filesystem_global_location_obtain(&old_env->root_directory);
2029108: 7f ff 86 3b call 200a9f4 <rtems_filesystem_global_location_obtain>
202910c: 90 07 20 04 add %i4, 4, %o0
if (new_env != NULL) {
*new_env = *old_env;
new_env->reference_count = 1;
new_env->task_id = self_task_id;
new_env->root_directory =
2029110: d0 27 60 04 st %o0, [ %i5 + 4 ]
rtems_filesystem_global_location_obtain(&old_env->root_directory);
new_env->current_directory =
rtems_filesystem_global_location_obtain(&old_env->current_directory);
2029114: 7f ff 86 38 call 200a9f4 <rtems_filesystem_global_location_obtain>
2029118: 90 10 00 1c mov %i4, %o0
static inline bool rtems_filesystem_location_is_null(
const rtems_filesystem_location_info_t *loc
)
{
return loc->handlers == &rtems_filesystem_null_handlers;
202911c: c2 07 60 04 ld [ %i5 + 4 ], %g1
*new_env = *old_env;
new_env->reference_count = 1;
new_env->task_id = self_task_id;
new_env->root_directory =
rtems_filesystem_global_location_obtain(&old_env->root_directory);
new_env->current_directory =
2029120: d0 27 40 00 st %o0, [ %i5 ]
rtems_filesystem_global_location_obtain(&old_env->current_directory);
if (
2029124: c4 00 60 10 ld [ %g1 + 0x10 ], %g2
2029128: 03 00 81 7d sethi %hi(0x205f400), %g1
202912c: 82 10 63 34 or %g1, 0x334, %g1 ! 205f734 <rtems_filesystem_null_handlers>
2029130: 80 a0 80 01 cmp %g2, %g1
2029134: 22 80 00 14 be,a 2029184 <rtems_libio_set_private_env+0xe8>
2029138: b0 10 20 0d mov 0xd, %i0
!rtems_filesystem_global_location_is_null(new_env->root_directory)
&& !rtems_filesystem_global_location_is_null(new_env->current_directory)
202913c: c4 02 20 10 ld [ %o0 + 0x10 ], %g2
2029140: 80 a0 80 01 cmp %g2, %g1
2029144: 02 80 00 0f be 2029180 <rtems_libio_set_private_env+0xe4> <== NEVER TAKEN
2029148: 90 10 20 00 clr %o0
) {
sc = rtems_task_variable_add(
202914c: 37 00 81 ad sethi %hi(0x206b400), %i3
2029150: 15 00 80 a4 sethi %hi(0x2029000), %o2
2029154: 92 16 e1 5c or %i3, 0x15c, %o1
2029158: 40 00 07 97 call 202afb4 <rtems_task_variable_add>
202915c: 94 12 a0 28 or %o2, 0x28, %o2
RTEMS_SELF,
(void **) &rtems_current_user_env,
free_user_env
);
if (sc == RTEMS_SUCCESSFUL) {
2029160: b0 92 20 00 orcc %o0, 0, %i0
2029164: 32 80 00 08 bne,a 2029184 <rtems_libio_set_private_env+0xe8>
2029168: b0 10 20 05 mov 5, %i0
free_user_env_protected(old_env);
202916c: 7f ff ff c2 call 2029074 <free_user_env_protected>
2029170: 90 10 00 1c mov %i4, %o0
rtems_current_user_env = new_env;
2029174: fa 26 e1 5c st %i5, [ %i3 + 0x15c ]
2029178: 81 c7 e0 08 ret
202917c: 81 e8 00 00 restore
2029180: b0 10 20 0d mov 0xd, %i0 <== NOT EXECUTED
} else {
sc = RTEMS_UNSATISFIED;
}
if (sc != RTEMS_SUCCESSFUL) {
free_user_env(new_env);
2029184: 7f ff ff a9 call 2029028 <free_user_env>
2029188: 90 10 00 1d mov %i5, %o0
sc = RTEMS_NO_MEMORY;
}
}
return sc;
}
202918c: 81 c7 e0 08 ret
2029190: 81 e8 00 00 restore
02029194 <rtems_libio_share_private_env>:
rtems_status_code rtems_libio_share_private_env(rtems_id task_id)
{
2029194: 9d e3 bf 98 save %sp, -104, %sp
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_id self_task_id = rtems_task_self();
2029198: 7f ff 92 29 call 200da3c <rtems_task_self>
202919c: 01 00 00 00 nop
if (task_id != RTEMS_SELF && self_task_id != task_id) {
20291a0: 80 a2 00 18 cmp %o0, %i0
20291a4: 22 80 00 27 be,a 2029240 <rtems_libio_share_private_env+0xac>
20291a8: b0 10 20 00 clr %i0
20291ac: 80 a6 20 00 cmp %i0, 0
20291b0: 22 80 00 24 be,a 2029240 <rtems_libio_share_private_env+0xac>
20291b4: b0 10 20 00 clr %i0
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
_Thread_Dispatch_disable_level++;
20291b8: 03 00 81 bd sethi %hi(0x206f400), %g1
20291bc: c4 00 63 80 ld [ %g1 + 0x380 ], %g2 ! 206f780 <_Thread_Dispatch_disable_level>
20291c0: 84 00 a0 01 inc %g2
20291c4: c4 20 63 80 st %g2, [ %g1 + 0x380 ]
return _Thread_Dispatch_disable_level;
20291c8: c2 00 63 80 ld [ %g1 + 0x380 ], %g1
/*
* We have to disable the thread dispatching to prevent deletion of the
* environment in the meantime.
*/
_Thread_Disable_dispatch();
sc = rtems_task_variable_get(
20291cc: 13 00 81 ad sethi %hi(0x206b400), %o1
20291d0: 90 10 00 18 mov %i0, %o0
20291d4: 92 12 61 5c or %o1, 0x15c, %o1
20291d8: 40 00 07 c7 call 202b0f4 <rtems_task_variable_get>
20291dc: 94 07 bf fc add %fp, -4, %o2
task_id,
(void *) &rtems_current_user_env,
(void *) &env
);
if (sc == RTEMS_SUCCESSFUL) {
20291e0: b0 92 20 00 orcc %o0, 0, %i0
20291e4: 32 80 00 06 bne,a 20291fc <rtems_libio_share_private_env+0x68>
20291e8: b0 10 20 0d mov 0xd, %i0
++env->reference_count;
20291ec: c2 07 bf fc ld [ %fp + -4 ], %g1
20291f0: c4 00 60 28 ld [ %g1 + 0x28 ], %g2
20291f4: 84 00 a0 01 inc %g2
20291f8: c4 20 60 28 st %g2, [ %g1 + 0x28 ]
} else {
sc = RTEMS_UNSATISFIED;
}
_Thread_Enable_dispatch();
20291fc: 7f ff 9b d0 call 201013c <_Thread_Enable_dispatch>
2029200: 01 00 00 00 nop
if (sc == RTEMS_SUCCESSFUL) {
2029204: 80 a6 20 00 cmp %i0, 0
2029208: 12 80 00 0e bne 2029240 <rtems_libio_share_private_env+0xac>
202920c: 90 10 20 00 clr %o0
sc = rtems_task_variable_add(
2029210: 3b 00 81 ad sethi %hi(0x206b400), %i5
2029214: 15 00 80 a4 sethi %hi(0x2029000), %o2
2029218: 92 17 61 5c or %i5, 0x15c, %o1
202921c: 40 00 07 66 call 202afb4 <rtems_task_variable_add>
2029220: 94 12 a0 28 or %o2, 0x28, %o2
RTEMS_SELF,
(void **) &rtems_current_user_env,
free_user_env
);
if (sc == RTEMS_SUCCESSFUL) {
2029224: b0 92 20 00 orcc %o0, 0, %i0
2029228: 12 80 00 08 bne 2029248 <rtems_libio_share_private_env+0xb4><== NEVER TAKEN
202922c: d0 07 bf fc ld [ %fp + -4 ], %o0
free_user_env_protected(rtems_current_user_env);
2029230: 7f ff ff 91 call 2029074 <free_user_env_protected>
2029234: d0 07 61 5c ld [ %i5 + 0x15c ], %o0
rtems_current_user_env = env;
2029238: c2 07 bf fc ld [ %fp + -4 ], %g1
202923c: c2 27 61 5c st %g1, [ %i5 + 0x15c ]
2029240: 81 c7 e0 08 ret
2029244: 81 e8 00 00 restore
} else {
free_user_env_protected(env);
2029248: 7f ff ff 8b call 2029074 <free_user_env_protected> <== NOT EXECUTED
202924c: b0 10 20 05 mov 5, %i0 <== NOT EXECUTED
2029250: 81 c7 e0 08 ret <== NOT EXECUTED
2029254: 81 e8 00 00 restore <== NOT EXECUTED
0200c0c0 <rtems_libio_to_fcntl_flags>:
int rtems_libio_to_fcntl_flags( uint32_t flags )
{
int fcntl_flags = 0;
if ( (flags & LIBIO_FLAGS_READ_WRITE) == LIBIO_FLAGS_READ_WRITE ) {
200c0c0: 84 0a 20 06 and %o0, 6, %g2
*
* Convert RTEMS internal flags to UNIX fnctl(2) flags
*/
int rtems_libio_to_fcntl_flags( uint32_t flags )
{
200c0c4: 82 10 00 08 mov %o0, %g1
int fcntl_flags = 0;
if ( (flags & LIBIO_FLAGS_READ_WRITE) == LIBIO_FLAGS_READ_WRITE ) {
200c0c8: 80 a0 a0 06 cmp %g2, 6
200c0cc: 02 80 00 07 be 200c0e8 <rtems_libio_to_fcntl_flags+0x28>
200c0d0: 90 10 20 02 mov 2, %o0
fcntl_flags |= O_RDWR;
} else if ( (flags & LIBIO_FLAGS_READ) == LIBIO_FLAGS_READ) {
200c0d4: 80 88 60 02 btst 2, %g1
200c0d8: 12 80 00 04 bne 200c0e8 <rtems_libio_to_fcntl_flags+0x28> <== ALWAYS TAKEN
200c0dc: 90 10 20 00 clr %o0
fcntl_flags |= O_RDONLY;
} else if ( (flags & LIBIO_FLAGS_WRITE) == LIBIO_FLAGS_WRITE) {
200c0e0: 91 30 60 02 srl %g1, 2, %o0 <== NOT EXECUTED
200c0e4: 90 0a 20 01 and %o0, 1, %o0 <== NOT EXECUTED
fcntl_flags |= O_WRONLY;
}
if ( (flags & LIBIO_FLAGS_NO_DELAY) == LIBIO_FLAGS_NO_DELAY ) {
200c0e8: 80 88 60 01 btst 1, %g1
200c0ec: 02 80 00 04 be 200c0fc <rtems_libio_to_fcntl_flags+0x3c>
200c0f0: 80 88 62 00 btst 0x200, %g1
fcntl_flags |= O_NONBLOCK;
200c0f4: 05 00 00 10 sethi %hi(0x4000), %g2
200c0f8: 90 12 00 02 or %o0, %g2, %o0
}
if ( (flags & LIBIO_FLAGS_APPEND) == LIBIO_FLAGS_APPEND ) {
200c0fc: 32 80 00 02 bne,a 200c104 <rtems_libio_to_fcntl_flags+0x44>
200c100: 90 12 20 08 or %o0, 8, %o0
fcntl_flags |= O_APPEND;
}
if ( (flags & LIBIO_FLAGS_CREATE) == LIBIO_FLAGS_CREATE ) {
200c104: 80 88 64 00 btst 0x400, %g1
200c108: 32 80 00 02 bne,a 200c110 <rtems_libio_to_fcntl_flags+0x50>
200c10c: 90 12 22 00 or %o0, 0x200, %o0
fcntl_flags |= O_CREAT;
}
return fcntl_flags;
}
200c110: 81 c3 e0 08 retl
02029258 <rtems_libio_use_global_env>:
return sc;
}
void rtems_libio_use_global_env(void)
{
2029258: 9d e3 bf a0 save %sp, -96, %sp
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_user_env_t *env = rtems_current_user_env;
bool uses_private_env = env != &rtems_global_user_env;
if (uses_private_env) {
202925c: 3b 00 81 ad sethi %hi(0x206b400), %i5
2029260: c2 07 61 5c ld [ %i5 + 0x15c ], %g1 ! 206b55c <rtems_current_user_env>
2029264: 39 00 81 ad sethi %hi(0x206b400), %i4
2029268: b8 17 21 60 or %i4, 0x160, %i4 ! 206b560 <rtems_global_user_env>
202926c: 80 a0 40 1c cmp %g1, %i4
2029270: 02 80 00 0a be 2029298 <rtems_libio_use_global_env+0x40>
2029274: 92 17 61 5c or %i5, 0x15c, %o1
sc = rtems_task_variable_delete(
2029278: 40 00 07 7a call 202b060 <rtems_task_variable_delete>
202927c: 90 10 20 00 clr %o0
RTEMS_SELF,
(void **) &rtems_current_user_env
);
if (sc != RTEMS_SUCCESSFUL) {
2029280: 80 a2 20 00 cmp %o0, 0
2029284: 22 80 00 05 be,a 2029298 <rtems_libio_use_global_env+0x40><== ALWAYS TAKEN
2029288: f8 27 61 5c st %i4, [ %i5 + 0x15c ]
rtems_fatal_error_occurred(0xdeadbeef);
202928c: 11 37 ab 6f sethi %hi(0xdeadbc00), %o0 <== NOT EXECUTED
2029290: 7f ff 92 98 call 200dcf0 <rtems_fatal_error_occurred> <== NOT EXECUTED
2029294: 90 12 22 ef or %o0, 0x2ef, %o0 ! deadbeef <RAM_END+0xdc6dbeef><== NOT EXECUTED
2029298: 81 c7 e0 08 ret
202929c: 81 e8 00 00 restore
0200927c <rtems_malloc_statistics_at_free>:
* size and thus we skip updating the statistics.
*/
static void rtems_malloc_statistics_at_free(
void *pointer
)
{
200927c: 9d e3 bf 98 save %sp, -104, %sp
uintptr_t size;
if (_Protected_heap_Get_block_size(RTEMS_Malloc_Heap, pointer, &size) ) {
2009280: 03 00 81 ad sethi %hi(0x206b400), %g1
2009284: d0 00 60 04 ld [ %g1 + 4 ], %o0 ! 206b404 <RTEMS_Malloc_Heap>
2009288: 92 10 00 18 mov %i0, %o1
200928c: 40 00 18 a2 call 200f514 <_Protected_heap_Get_block_size>
2009290: 94 07 bf fc add %fp, -4, %o2
2009294: 80 8a 20 ff btst 0xff, %o0
2009298: 02 80 00 08 be 20092b8 <rtems_malloc_statistics_at_free+0x3c><== NEVER TAKEN
200929c: 03 00 81 bd sethi %hi(0x206f400), %g1
MSBUMP(lifetime_freed, size);
20092a0: c8 07 bf fc ld [ %fp + -4 ], %g4
20092a4: 82 10 61 f8 or %g1, 0x1f8, %g1
20092a8: c4 18 60 28 ldd [ %g1 + 0x28 ], %g2
20092ac: 86 80 c0 04 addcc %g3, %g4, %g3
20092b0: 84 40 a0 00 addx %g2, 0, %g2
20092b4: c4 38 60 28 std %g2, [ %g1 + 0x28 ]
20092b8: 81 c7 e0 08 ret
20092bc: 81 e8 00 00 restore
020092c0 <rtems_malloc_statistics_at_malloc>:
}
static void rtems_malloc_statistics_at_malloc(
void *pointer
)
{
20092c0: 9d e3 bf 98 save %sp, -104, %sp
uintptr_t actual_size = 0;
uint32_t current_depth;
rtems_malloc_statistics_t *s = &rtems_malloc_statistics;
if ( !pointer )
20092c4: 80 a6 20 00 cmp %i0, 0
20092c8: 02 80 00 14 be 2009318 <rtems_malloc_statistics_at_malloc+0x58><== NEVER TAKEN
20092cc: c0 27 bf fc clr [ %fp + -4 ]
return;
_Protected_heap_Get_block_size(RTEMS_Malloc_Heap, pointer, &actual_size);
20092d0: 03 00 81 ad sethi %hi(0x206b400), %g1
20092d4: d0 00 60 04 ld [ %g1 + 4 ], %o0 ! 206b404 <RTEMS_Malloc_Heap>
20092d8: 92 10 00 18 mov %i0, %o1
20092dc: 40 00 18 8e call 200f514 <_Protected_heap_Get_block_size>
20092e0: 94 07 bf fc add %fp, -4, %o2
MSBUMP(lifetime_allocated, actual_size);
20092e4: 03 00 81 bd sethi %hi(0x206f400), %g1
20092e8: c8 07 bf fc ld [ %fp + -4 ], %g4
20092ec: 82 10 61 f8 or %g1, 0x1f8, %g1
20092f0: c4 18 60 20 ldd [ %g1 + 0x20 ], %g2
20092f4: 86 80 c0 04 addcc %g3, %g4, %g3
20092f8: 84 40 a0 00 addx %g2, 0, %g2
20092fc: c4 38 60 20 std %g2, [ %g1 + 0x20 ]
current_depth = (uint32_t) (s->lifetime_allocated - s->lifetime_freed);
2009300: c4 00 60 2c ld [ %g1 + 0x2c ], %g2
2009304: 84 20 c0 02 sub %g3, %g2, %g2
if (current_depth > s->max_depth)
2009308: c6 00 60 18 ld [ %g1 + 0x18 ], %g3
200930c: 80 a0 80 03 cmp %g2, %g3
2009310: 38 80 00 02 bgu,a 2009318 <rtems_malloc_statistics_at_malloc+0x58>
2009314: c4 20 60 18 st %g2, [ %g1 + 0x18 ]
2009318: 81 c7 e0 08 ret
200931c: 81 e8 00 00 restore
02010418 <rtems_memalign>:
int rtems_memalign(
void **pointer,
size_t alignment,
size_t size
)
{
2010418: 9d e3 bf a0 save %sp, -96, %sp
void *return_this;
/*
* Parameter error checks
*/
if ( !pointer )
201041c: ba 96 20 00 orcc %i0, 0, %i5
2010420: 12 80 00 04 bne 2010430 <rtems_memalign+0x18>
2010424: 03 00 80 87 sethi %hi(0x2021c00), %g1
return EINVAL;
2010428: 81 c7 e0 08 ret
201042c: 91 e8 20 16 restore %g0, 0x16, %o0
*pointer = NULL;
/*
* Do not attempt to allocate memory if not in correct system state.
*/
if ( _System_state_Is_up(_System_state_Get()) &&
2010430: c2 00 62 50 ld [ %g1 + 0x250 ], %g1
2010434: 80 a0 60 03 cmp %g1, 3
2010438: 02 80 00 0f be 2010474 <rtems_memalign+0x5c>
201043c: c0 27 40 00 clr [ %i5 ]
return EINVAL;
/*
* If some free's have been deferred, then do them now.
*/
malloc_deferred_frees_process();
2010440: 7f ff d2 8c call 2004e70 <malloc_deferred_frees_process>
2010444: b0 10 20 0c mov 0xc, %i0
Heap_Control *heap,
uintptr_t size,
uintptr_t alignment
)
{
return
2010448: 03 00 80 83 sethi %hi(0x2020c00), %g1
201044c: d0 00 63 64 ld [ %g1 + 0x364 ], %o0 ! 2020f64 <RTEMS_Malloc_Heap>
2010450: 92 10 00 1a mov %i2, %o1
2010454: 94 10 00 19 mov %i1, %o2
2010458: 7f ff e9 55 call 200a9ac <_Protected_heap_Allocate_aligned_with_boundary>
201045c: 96 10 20 00 clr %o3
return_this = _Protected_heap_Allocate_aligned(
RTEMS_Malloc_Heap,
size,
alignment
);
if ( !return_this )
2010460: 80 a2 20 00 cmp %o0, 0
2010464: 12 80 00 0a bne 201048c <rtems_memalign+0x74>
2010468: b8 10 00 08 mov %o0, %i4
201046c: 81 c7 e0 08 ret
2010470: 81 e8 00 00 restore
/*
* Do not attempt to allocate memory if not in correct system state.
*/
if ( _System_state_Is_up(_System_state_Get()) &&
!malloc_is_system_state_OK() )
2010474: 7f ff d2 6c call 2004e24 <malloc_is_system_state_OK>
2010478: 01 00 00 00 nop
*pointer = NULL;
/*
* Do not attempt to allocate memory if not in correct system state.
*/
if ( _System_state_Is_up(_System_state_Get()) &&
201047c: 80 8a 20 ff btst 0xff, %o0
2010480: 02 bf ff ea be 2010428 <rtems_memalign+0x10> <== NEVER TAKEN
2010484: 01 00 00 00 nop
2010488: 30 bf ff ee b,a 2010440 <rtems_memalign+0x28>
return ENOMEM;
/*
* If configured, update the more involved statistics
*/
if ( rtems_malloc_statistics_helpers )
201048c: 03 00 80 85 sethi %hi(0x2021400), %g1
2010490: c2 00 63 24 ld [ %g1 + 0x324 ], %g1 ! 2021724 <rtems_malloc_statistics_helpers>
2010494: 80 a0 60 00 cmp %g1, 0
2010498: 22 80 00 06 be,a 20104b0 <rtems_memalign+0x98>
201049c: f8 27 40 00 st %i4, [ %i5 ]
(*rtems_malloc_statistics_helpers->at_malloc)(pointer);
20104a0: c2 00 60 04 ld [ %g1 + 4 ], %g1
20104a4: 9f c0 40 00 call %g1
20104a8: 90 10 00 1d mov %i5, %o0
*pointer = return_this;
20104ac: f8 27 40 00 st %i4, [ %i5 ]
return 0;
}
20104b0: 81 c7 e0 08 ret
20104b4: 91 e8 20 00 restore %g0, 0, %o0
0200a008 <rtems_mkdir>:
return (retval);
}
int
rtems_mkdir(const char *path, mode_t mode)
{
200a008: 9d e3 bf 58 save %sp, -168, %sp
int success = 0;
char *dup_path = strdup(path);
200a00c: 40 00 fa 9e call 2048a84 <strdup>
200a010: 90 10 00 18 mov %i0, %o0
if (dup_path != NULL) {
200a014: b6 92 20 00 orcc %o0, 0, %i3
200a018: 32 80 00 04 bne,a 200a028 <rtems_mkdir+0x20>
200a01c: c2 4e c0 00 ldsb [ %i3 ], %g1
success = build(dup_path, mode);
free(dup_path);
}
return success != 0 ? 0 : -1;
200a020: 81 c7 e0 08 ret
200a024: 91 e8 3f ff restore %g0, -1, %o0
char *p;
p = path;
oumask = 0;
retval = 1;
if (p[0] == '/') /* Skip leading '/'. */
200a028: b8 10 20 01 mov 1, %i4
++p;
200a02c: 82 18 60 2f xor %g1, 0x2f, %g1
char *p;
p = path;
oumask = 0;
retval = 1;
if (p[0] == '/') /* Skip leading '/'. */
200a030: b0 10 20 00 clr %i0
++p;
200a034: 80 a0 00 01 cmp %g0, %g1
retval = 0;
break;
}
}
if (!last)
*p = '/';
200a038: a0 10 20 2f mov 0x2f, %l0
p = path;
oumask = 0;
retval = 1;
if (p[0] == '/') /* Skip leading '/'. */
++p;
200a03c: b4 66 ff ff subx %i3, -1, %i2
char *p;
p = path;
oumask = 0;
retval = 1;
if (p[0] == '/') /* Skip leading '/'. */
200a040: 82 10 20 01 mov 1, %g1
if (mkdir(path, last ? omode : S_IRWXU | S_IRWXG | S_IRWXO) < 0) {
if (errno == EEXIST || errno == EISDIR) {
if (stat(path, &sb) < 0) {
retval = 0;
break;
} else if (!S_ISDIR(sb.st_mode)) {
200a044: 23 00 00 3c sethi %hi(0xf000), %l1
200a048: 25 00 00 10 sethi %hi(0x4000), %l2
oumask = 0;
retval = 1;
if (p[0] == '/') /* Skip leading '/'. */
++p;
for (first = 1, last = 0; !last ; ++p) {
if (p[0] == '\0')
200a04c: c6 4e 80 00 ldsb [ %i2 ], %g3
200a050: 80 a0 e0 00 cmp %g3, 0
200a054: 22 80 00 07 be,a 200a070 <rtems_mkdir+0x68>
200a058: 84 10 20 01 mov 1, %g2
last = 1;
else if (p[0] != '/')
200a05c: 80 a0 e0 2f cmp %g3, 0x2f
200a060: 12 80 00 4f bne 200a19c <rtems_mkdir+0x194>
200a064: 84 10 20 00 clr %g2
continue;
*p = '\0';
200a068: 10 80 00 03 b 200a074 <rtems_mkdir+0x6c>
200a06c: c0 2e 80 00 clrb [ %i2 ]
200a070: c0 2e 80 00 clrb [ %i2 ]
if (!last && p[1] == '\0')
200a074: 80 a0 a0 00 cmp %g2, 0
200a078: 12 80 00 05 bne 200a08c <rtems_mkdir+0x84>
200a07c: ba 10 20 01 mov 1, %i5
200a080: c4 4e a0 01 ldsb [ %i2 + 1 ], %g2
200a084: 80 a0 00 02 cmp %g0, %g2
200a088: ba 60 3f ff subx %g0, -1, %i5
last = 1;
if (first) {
200a08c: 80 a0 60 00 cmp %g1, 0
200a090: 02 80 00 08 be 200a0b0 <rtems_mkdir+0xa8>
200a094: 80 a7 60 00 cmp %i5, 0
* mkdir [-m mode] dir
*
* We change the user's umask and then restore it,
* instead of doing chmod's.
*/
oumask = umask(0);
200a098: 40 00 09 f8 call 200c878 <umask>
200a09c: 90 10 20 00 clr %o0
200a0a0: b0 10 00 08 mov %o0, %i0
numask = oumask & ~(S_IWUSR | S_IXUSR);
(void)umask(numask);
200a0a4: 40 00 09 f5 call 200c878 <umask>
200a0a8: 90 0a 3f 3f and %o0, -193, %o0
first = 0;
}
if (last)
200a0ac: 80 a7 60 00 cmp %i5, 0
200a0b0: 02 80 00 05 be 200a0c4 <rtems_mkdir+0xbc>
200a0b4: 92 10 21 ff mov 0x1ff, %o1
(void)umask(oumask);
200a0b8: 40 00 09 f0 call 200c878 <umask>
200a0bc: 90 10 00 18 mov %i0, %o0
if (mkdir(path, last ? omode : S_IRWXU | S_IRWXG | S_IRWXO) < 0) {
200a0c0: 92 10 00 19 mov %i1, %o1
200a0c4: 7f ff fc 9e call 200933c <mkdir>
200a0c8: 90 10 00 1b mov %i3, %o0
200a0cc: 80 a2 20 00 cmp %o0, 0
200a0d0: 16 80 00 2d bge 200a184 <rtems_mkdir+0x17c>
200a0d4: 80 a7 60 00 cmp %i5, 0
if (errno == EEXIST || errno == EISDIR) {
200a0d8: 40 00 e0 45 call 20421ec <__errno>
200a0dc: 01 00 00 00 nop
200a0e0: c2 02 00 00 ld [ %o0 ], %g1
200a0e4: 80 a0 60 11 cmp %g1, 0x11
200a0e8: 12 80 00 09 bne 200a10c <rtems_mkdir+0x104>
200a0ec: 90 10 00 1b mov %i3, %o0
if (stat(path, &sb) < 0) {
200a0f0: 40 00 00 42 call 200a1f8 <stat>
200a0f4: 92 07 bf b8 add %fp, -72, %o1
200a0f8: 80 a2 20 00 cmp %o0, 0
200a0fc: 16 80 00 0c bge 200a12c <rtems_mkdir+0x124> <== ALWAYS TAKEN
200a100: c2 07 bf c4 ld [ %fp + -60 ], %g1
retval = 0;
200a104: 10 80 00 2b b 200a1b0 <rtems_mkdir+0x1a8> <== NOT EXECUTED
200a108: b8 10 20 00 clr %i4 <== NOT EXECUTED
first = 0;
}
if (last)
(void)umask(oumask);
if (mkdir(path, last ? omode : S_IRWXU | S_IRWXG | S_IRWXO) < 0) {
if (errno == EEXIST || errno == EISDIR) {
200a10c: 40 00 e0 38 call 20421ec <__errno>
200a110: 01 00 00 00 nop
200a114: c2 02 00 00 ld [ %o0 ], %g1
200a118: 80 a0 60 15 cmp %g1, 0x15
200a11c: 02 bf ff f5 be 200a0f0 <rtems_mkdir+0xe8> <== NEVER TAKEN
200a120: 90 10 00 1b mov %i3, %o0
if (stat(path, &sb) < 0) {
retval = 0;
200a124: 10 80 00 23 b 200a1b0 <rtems_mkdir+0x1a8>
200a128: b8 10 20 00 clr %i4
break;
} else if (!S_ISDIR(sb.st_mode)) {
200a12c: 82 08 40 11 and %g1, %l1, %g1
200a130: 80 a0 40 12 cmp %g1, %l2
200a134: 02 80 00 0f be 200a170 <rtems_mkdir+0x168>
200a138: 80 a7 60 00 cmp %i5, 0
if (last)
200a13c: 02 80 00 08 be 200a15c <rtems_mkdir+0x154>
200a140: 01 00 00 00 nop
errno = EEXIST;
200a144: 40 00 e0 2a call 20421ec <__errno>
200a148: b8 10 20 00 clr %i4 ! 0 <PROM_START>
200a14c: 82 10 20 11 mov 0x11, %g1
200a150: c2 22 00 00 st %g1, [ %o0 ]
200a154: 10 80 00 17 b 200a1b0 <rtems_mkdir+0x1a8>
200a158: ba 10 20 01 mov 1, %i5
else
errno = ENOTDIR;
200a15c: 40 00 e0 24 call 20421ec <__errno>
200a160: b8 10 20 00 clr %i4
200a164: 82 10 20 14 mov 0x14, %g1
200a168: 10 80 00 12 b 200a1b0 <rtems_mkdir+0x1a8>
200a16c: c2 22 00 00 st %g1, [ %o0 ]
retval = 0;
break;
}
if (last)
200a170: 32 80 00 09 bne,a 200a194 <rtems_mkdir+0x18c>
200a174: b8 10 20 02 mov 2, %i4
retval = 0;
break;
}
}
if (!last)
*p = '/';
200a178: e0 2e 80 00 stb %l0, [ %i2 ]
200a17c: 10 80 00 07 b 200a198 <rtems_mkdir+0x190>
200a180: 84 10 20 00 clr %g2
} else {
retval = 0;
break;
}
}
if (!last)
200a184: 22 bf ff fe be,a 200a17c <rtems_mkdir+0x174>
200a188: e0 2e 80 00 stb %l0, [ %i2 ]
else
errno = ENOTDIR;
retval = 0;
break;
}
if (last)
200a18c: 10 80 00 03 b 200a198 <rtems_mkdir+0x190>
200a190: 84 10 20 01 mov 1, %g2
200a194: 84 10 20 01 mov 1, %g2
200a198: 82 10 20 00 clr %g1
p = path;
oumask = 0;
retval = 1;
if (p[0] == '/') /* Skip leading '/'. */
++p;
for (first = 1, last = 0; !last ; ++p) {
200a19c: 80 a0 a0 00 cmp %g2, 0
200a1a0: 02 bf ff ab be 200a04c <rtems_mkdir+0x44>
200a1a4: b4 06 a0 01 inc %i2
200a1a8: 10 80 00 03 b 200a1b4 <rtems_mkdir+0x1ac>
200a1ac: ba 10 20 01 mov 1, %i5
}
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) {
200a1b0: 82 10 20 00 clr %g1
}
}
if (!last)
*p = '/';
}
if (!first && !last)
200a1b4: 80 97 40 01 orcc %i5, %g1, %g0
200a1b8: 12 80 00 04 bne 200a1c8 <rtems_mkdir+0x1c0>
200a1bc: 01 00 00 00 nop
(void)umask(oumask);
200a1c0: 40 00 09 ae call 200c878 <umask>
200a1c4: 90 10 00 18 mov %i0, %o0
int success = 0;
char *dup_path = strdup(path);
if (dup_path != NULL) {
success = build(dup_path, mode);
free(dup_path);
200a1c8: 7f ff fa 8d call 2008bfc <free>
200a1cc: 90 10 00 1b mov %i3, %o0
}
return success != 0 ? 0 : -1;
200a1d0: 80 a7 20 00 cmp %i4, 0
200a1d4: 02 bf ff 93 be 200a020 <rtems_mkdir+0x18>
200a1d8: 01 00 00 00 nop
}
200a1dc: 81 c7 e0 08 ret
200a1e0: 91 e8 20 00 restore %g0, 0, %o0
02020a4c <rtems_nvdisk_device_read>:
rtems_nvdisk_device_read (const rtems_nvdisk* nvd,
uint32_t device,
uint32_t offset,
void* buffer,
uint32_t size)
{
2020a4c: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED
* Get the descriptor for a device.
*/
static const rtems_nvdisk_device_desc*
rtems_nvdisk_device_descriptor (const rtems_nvdisk* nvd, uint32_t device)
{
return nvd->devices[device].descriptor;
2020a50: c4 06 20 14 ld [ %i0 + 0x14 ], %g2 <== NOT EXECUTED
2020a54: 87 2e 60 02 sll %i1, 2, %g3 <== NOT EXECUTED
2020a58: 83 2e 60 04 sll %i1, 4, %g1 <== NOT EXECUTED
2020a5c: 82 00 c0 01 add %g3, %g1, %g1 <== NOT EXECUTED
2020a60: 82 00 80 01 add %g2, %g1, %g1 <== NOT EXECUTED
2020a64: c2 00 60 10 ld [ %g1 + 0x10 ], %g1 <== NOT EXECUTED
ops = nvd->devices[device].descriptor->nv_ops;
#if RTEMS_NVDISK_TRACE
rtems_nvdisk_printf (nvd, " dev-read: %02d-%08x: s=%d",
device, offset, size);
#endif
return ops->read (device, dd->flags, dd->base, offset, buffer, size);
2020a68: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
2020a6c: c4 00 60 0c ld [ %g1 + 0xc ], %g2 <== NOT EXECUTED
2020a70: d2 00 40 00 ld [ %g1 ], %o1 <== NOT EXECUTED
2020a74: c4 00 80 00 ld [ %g2 ], %g2 <== NOT EXECUTED
2020a78: d4 00 60 04 ld [ %g1 + 4 ], %o2 <== NOT EXECUTED
2020a7c: 96 10 00 1a mov %i2, %o3 <== NOT EXECUTED
2020a80: 98 10 00 1b mov %i3, %o4 <== NOT EXECUTED
2020a84: 9f c0 80 00 call %g2 <== NOT EXECUTED
2020a88: 9a 10 00 1c mov %i4, %o5 <== NOT EXECUTED
}
2020a8c: 81 c7 e0 08 ret <== NOT EXECUTED
2020a90: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED
02020a94 <rtems_nvdisk_device_write>:
rtems_nvdisk_device_write (const rtems_nvdisk* nvd,
uint32_t device,
uint32_t offset,
const void* buffer,
uint32_t size)
{
2020a94: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED
* Get the descriptor for a device.
*/
static const rtems_nvdisk_device_desc*
rtems_nvdisk_device_descriptor (const rtems_nvdisk* nvd, uint32_t device)
{
return nvd->devices[device].descriptor;
2020a98: c4 06 20 14 ld [ %i0 + 0x14 ], %g2 <== NOT EXECUTED
2020a9c: 87 2e 60 02 sll %i1, 2, %g3 <== NOT EXECUTED
2020aa0: 83 2e 60 04 sll %i1, 4, %g1 <== NOT EXECUTED
2020aa4: 82 00 c0 01 add %g3, %g1, %g1 <== NOT EXECUTED
2020aa8: 82 00 80 01 add %g2, %g1, %g1 <== NOT EXECUTED
2020aac: c2 00 60 10 ld [ %g1 + 0x10 ], %g1 <== NOT EXECUTED
ops = nvd->devices[device].descriptor->nv_ops;
#if RTEMS_NVDISK_TRACE
rtems_nvdisk_printf (nvd, " dev-write: %02d-%08x: s=%d",
device, offset, size);
#endif
return ops->write (device, dd->flags, dd->base, offset, buffer, size);
2020ab0: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
2020ab4: c4 00 60 0c ld [ %g1 + 0xc ], %g2 <== NOT EXECUTED
2020ab8: d2 00 40 00 ld [ %g1 ], %o1 <== NOT EXECUTED
2020abc: c4 00 a0 04 ld [ %g2 + 4 ], %g2 <== NOT EXECUTED
2020ac0: d4 00 60 04 ld [ %g1 + 4 ], %o2 <== NOT EXECUTED
2020ac4: 96 10 00 1a mov %i2, %o3 <== NOT EXECUTED
2020ac8: 98 10 00 1b mov %i3, %o4 <== NOT EXECUTED
2020acc: 9f c0 80 00 call %g2 <== NOT EXECUTED
2020ad0: 9a 10 00 1c mov %i4, %o5 <== NOT EXECUTED
}
2020ad4: 81 c7 e0 08 ret <== NOT EXECUTED
2020ad8: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED
02020adc <rtems_nvdisk_error>:
* @param ... The arguments for the format text.
* @return int The number of bytes written to the output.
*/
static int
rtems_nvdisk_error (const char *format, ...)
{
2020adc: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED
int ret;
va_list args;
va_start (args, format);
2020ae0: 82 07 a0 48 add %fp, 0x48, %g1 <== NOT EXECUTED
2020ae4: fa 27 a0 58 st %i5, [ %fp + 0x58 ] <== NOT EXECUTED
2020ae8: c2 27 bf fc st %g1, [ %fp + -4 ] <== NOT EXECUTED
fprintf (stderr, "nvdisk:error:");
2020aec: 3b 00 81 af sethi %hi(0x206bc00), %i5 <== NOT EXECUTED
2020af0: c2 07 61 e0 ld [ %i5 + 0x1e0 ], %g1 ! 206bde0 <_impure_ptr><== NOT EXECUTED
static int
rtems_nvdisk_error (const char *format, ...)
{
int ret;
va_list args;
va_start (args, format);
2020af4: f2 27 a0 48 st %i1, [ %fp + 0x48 ] <== NOT EXECUTED
2020af8: f4 27 a0 4c st %i2, [ %fp + 0x4c ] <== NOT EXECUTED
2020afc: f6 27 a0 50 st %i3, [ %fp + 0x50 ] <== NOT EXECUTED
2020b00: f8 27 a0 54 st %i4, [ %fp + 0x54 ] <== NOT EXECUTED
fprintf (stderr, "nvdisk:error:");
2020b04: d2 00 60 0c ld [ %g1 + 0xc ], %o1 <== NOT EXECUTED
2020b08: 11 00 81 8a sethi %hi(0x2062800), %o0 <== NOT EXECUTED
2020b0c: 40 00 88 c1 call 2042e10 <fputs> <== NOT EXECUTED
2020b10: 90 12 21 58 or %o0, 0x158, %o0 ! 2062958 <msdos_ops+0x58> <== NOT EXECUTED
ret = vfprintf (stderr, format, args);
2020b14: c2 07 61 e0 ld [ %i5 + 0x1e0 ], %g1 <== NOT EXECUTED
2020b18: d4 07 bf fc ld [ %fp + -4 ], %o2 <== NOT EXECUTED
2020b1c: d0 00 60 0c ld [ %g1 + 0xc ], %o0 <== NOT EXECUTED
2020b20: 40 00 c9 b5 call 20531f4 <vfprintf> <== NOT EXECUTED
2020b24: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
fprintf (stderr, "\n");
2020b28: c2 07 61 e0 ld [ %i5 + 0x1e0 ], %g1 <== NOT EXECUTED
{
int ret;
va_list args;
va_start (args, format);
fprintf (stderr, "nvdisk:error:");
ret = vfprintf (stderr, format, args);
2020b2c: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED
fprintf (stderr, "\n");
2020b30: d2 00 60 0c ld [ %g1 + 0xc ], %o1 <== NOT EXECUTED
2020b34: 40 00 88 83 call 2042d40 <fputc> <== NOT EXECUTED
2020b38: 90 10 20 0a mov 0xa, %o0 <== NOT EXECUTED
fflush (stderr);
2020b3c: c2 07 61 e0 ld [ %i5 + 0x1e0 ], %g1 <== NOT EXECUTED
2020b40: 40 00 86 ae call 20425f8 <fflush> <== NOT EXECUTED
2020b44: d0 00 60 0c ld [ %g1 + 0xc ], %o0 <== NOT EXECUTED
va_end (args);
return ret;
}
2020b48: 81 c7 e0 08 ret <== NOT EXECUTED
2020b4c: 81 e8 00 00 restore <== NOT EXECUTED
02020b50 <rtems_nvdisk_get_device>:
/**
* Map a block to a device.
*/
static rtems_nvdisk_device_ctl*
rtems_nvdisk_get_device (rtems_nvdisk* nvd, uint32_t block)
{
2020b50: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED
uint32_t device;
if (block >= nvd->block_count)
2020b54: c4 06 20 10 ld [ %i0 + 0x10 ], %g2 <== NOT EXECUTED
/**
* Map a block to a device.
*/
static rtems_nvdisk_device_ctl*
rtems_nvdisk_get_device (rtems_nvdisk* nvd, uint32_t block)
{
2020b58: 82 10 00 18 mov %i0, %g1 <== NOT EXECUTED
uint32_t device;
if (block >= nvd->block_count)
2020b5c: 80 a6 40 02 cmp %i1, %g2 <== NOT EXECUTED
2020b60: 1a 80 00 06 bcc 2020b78 <rtems_nvdisk_get_device+0x28> <== NOT EXECUTED
2020b64: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
{
rtems_nvdisk_error ("read-block: bad block: %d", block);
return NULL;
}
for (device = 0; device < nvd->device_count; device++)
2020b68: fa 06 20 18 ld [ %i0 + 0x18 ], %i5 <== NOT EXECUTED
2020b6c: 86 10 20 00 clr %g3 <== NOT EXECUTED
2020b70: 10 80 00 12 b 2020bb8 <rtems_nvdisk_get_device+0x68> <== NOT EXECUTED
2020b74: 84 10 20 00 clr %g2 <== NOT EXECUTED
{
uint32_t device;
if (block >= nvd->block_count)
{
rtems_nvdisk_error ("read-block: bad block: %d", block);
2020b78: 11 00 81 8a sethi %hi(0x2062800), %o0 <== NOT EXECUTED
2020b7c: 10 80 00 14 b 2020bcc <rtems_nvdisk_get_device+0x7c> <== NOT EXECUTED
2020b80: 90 12 21 68 or %o0, 0x168, %o0 ! 2062968 <msdos_ops+0x68> <== NOT EXECUTED
return NULL;
}
for (device = 0; device < nvd->device_count; device++)
{
rtems_nvdisk_device_ctl* dc = &nvd->devices[device];
2020b84: b0 06 00 03 add %i0, %g3, %i0 <== NOT EXECUTED
if ((block >= dc->block_base) &&
2020b88: c8 06 20 0c ld [ %i0 + 0xc ], %g4 <== NOT EXECUTED
2020b8c: 80 a2 40 04 cmp %o1, %g4 <== NOT EXECUTED
2020b90: 0a 80 00 09 bcs 2020bb4 <rtems_nvdisk_get_device+0x64> <== NOT EXECUTED
2020b94: 84 00 a0 01 inc %g2 <== NOT EXECUTED
(block < (dc->block_base + dc->pages - dc->pages_desc)))
2020b98: f8 06 20 04 ld [ %i0 + 4 ], %i4 <== NOT EXECUTED
2020b9c: 88 01 00 1c add %g4, %i4, %g4 <== NOT EXECUTED
2020ba0: f8 06 20 08 ld [ %i0 + 8 ], %i4 <== NOT EXECUTED
2020ba4: 88 21 00 1c sub %g4, %i4, %g4 <== NOT EXECUTED
}
for (device = 0; device < nvd->device_count; device++)
{
rtems_nvdisk_device_ctl* dc = &nvd->devices[device];
if ((block >= dc->block_base) &&
2020ba8: 80 a2 40 04 cmp %o1, %g4 <== NOT EXECUTED
2020bac: 0a 80 00 0a bcs 2020bd4 <rtems_nvdisk_get_device+0x84> <== NOT EXECUTED
2020bb0: 01 00 00 00 nop <== NOT EXECUTED
2020bb4: 86 00 e0 14 add %g3, 0x14, %g3 <== NOT EXECUTED
{
rtems_nvdisk_error ("read-block: bad block: %d", block);
return NULL;
}
for (device = 0; device < nvd->device_count; device++)
2020bb8: 80 a0 80 1d cmp %g2, %i5 <== NOT EXECUTED
2020bbc: 32 bf ff f2 bne,a 2020b84 <rtems_nvdisk_get_device+0x34> <== NOT EXECUTED
2020bc0: f0 00 60 14 ld [ %g1 + 0x14 ], %i0 <== NOT EXECUTED
if ((block >= dc->block_base) &&
(block < (dc->block_base + dc->pages - dc->pages_desc)))
return dc;
}
rtems_nvdisk_error ("map-block:%d: no device/page map found", block);
2020bc4: 11 00 81 8a sethi %hi(0x2062800), %o0 <== NOT EXECUTED
2020bc8: 90 12 21 88 or %o0, 0x188, %o0 ! 2062988 <msdos_ops+0x88> <== NOT EXECUTED
2020bcc: 7f ff ff c4 call 2020adc <rtems_nvdisk_error> <== NOT EXECUTED
2020bd0: b0 10 20 00 clr %i0 <== NOT EXECUTED
return NULL;
}
2020bd4: 81 c7 e0 08 ret <== NOT EXECUTED
2020bd8: 81 e8 00 00 restore <== NOT EXECUTED
020210ec <rtems_nvdisk_initialize>:
*/
rtems_device_driver
rtems_nvdisk_initialize (rtems_device_major_number major,
rtems_device_minor_number minor,
void* arg __attribute__((unused)))
{
20210ec: 9d e3 bf 78 save %sp, -136, %sp <== NOT EXECUTED
const rtems_nvdisk_config* c = rtems_nvdisk_configuration;
rtems_nvdisk* nvd;
rtems_status_code sc;
sc = rtems_disk_io_initialize ();
20210f0: 7f ff 9b 69 call 2007e94 <rtems_disk_io_initialize> <== NOT EXECUTED
20210f4: a2 10 00 18 mov %i0, %l1 <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
20210f8: b0 92 20 00 orcc %o0, 0, %i0 <== NOT EXECUTED
20210fc: 12 80 00 98 bne 202135c <rtems_nvdisk_initialize+0x270> <== NOT EXECUTED
2021100: 01 00 00 00 nop <== NOT EXECUTED
static rtems_status_code
rtems_nvdisk_crc16_gen_factors (uint16_t pattern)
{
uint32_t b;
rtems_nvdisk_crc16_factor = malloc (sizeof (uint16_t) * 256);
2021104: 7f ff a0 1c call 2009174 <malloc> <== NOT EXECUTED
2021108: 90 10 22 00 mov 0x200, %o0 ! 200 <PROM_START+0x200> <== NOT EXECUTED
202110c: 03 00 81 bb sethi %hi(0x206ec00), %g1 <== NOT EXECUTED
2021110: d0 20 63 e4 st %o0, [ %g1 + 0x3e4 ] ! 206efe4 <rtems_nvdisk_crc16_factor><== NOT EXECUTED
for (b = 0; b < 256; b++)
{
uint32_t i;
uint16_t v = b;
for (i = 8; i--;)
v = v & 1 ? (v >> 1) ^ pattern : v >> 1;
2021114: 09 3f ff e1 sethi %hi(0xffff8400), %g4 <== NOT EXECUTED
rtems_nvdisk_crc16_gen_factors (uint16_t pattern)
{
uint32_t b;
rtems_nvdisk_crc16_factor = malloc (sizeof (uint16_t) * 256);
if (!rtems_nvdisk_crc16_factor)
2021118: 82 10 20 00 clr %g1 <== NOT EXECUTED
202111c: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2021120: 12 80 00 04 bne 2021130 <rtems_nvdisk_initialize+0x44> <== NOT EXECUTED
2021124: 88 11 20 08 or %g4, 8, %g4 <== NOT EXECUTED
nvd->block_size = c->block_size;
nvd->info_level = c->info_level;
nvd->devices = calloc (c->device_count, sizeof (rtems_nvdisk_device_ctl));
if (!nvd->devices)
return RTEMS_NO_MEMORY;
2021128: 81 c7 e0 08 ret <== NOT EXECUTED
202112c: 91 e8 20 1a restore %g0, 0x1a, %o0 <== NOT EXECUTED
return RTEMS_NO_MEMORY;
for (b = 0; b < 256; b++)
{
uint32_t i;
uint16_t v = b;
2021130: 84 10 00 01 mov %g1, %g2 <== NOT EXECUTED
2021134: 10 80 00 06 b 202114c <rtems_nvdisk_initialize+0x60> <== NOT EXECUTED
2021138: 86 10 20 09 mov 9, %g3 <== NOT EXECUTED
202113c: 85 28 a0 10 sll %g2, 0x10, %g2 <== NOT EXECUTED
for (i = 8; i--;)
v = v & 1 ? (v >> 1) ^ pattern : v >> 1;
2021140: 02 80 00 03 be 202114c <rtems_nvdisk_initialize+0x60> <== NOT EXECUTED
2021144: 85 30 a0 11 srl %g2, 0x11, %g2 <== NOT EXECUTED
2021148: 84 18 80 04 xor %g2, %g4, %g2 <== NOT EXECUTED
for (b = 0; b < 256; b++)
{
uint32_t i;
uint16_t v = b;
for (i = 8; i--;)
202114c: 86 80 ff ff addcc %g3, -1, %g3 <== NOT EXECUTED
2021150: 12 bf ff fb bne 202113c <rtems_nvdisk_initialize+0x50> <== NOT EXECUTED
2021154: 80 88 a0 01 btst 1, %g2 <== NOT EXECUTED
* @param major NV disk major device number.
* @param minor Minor device number, not applicable.
* @param arg Initialization argument, not applicable.
*/
rtems_device_driver
rtems_nvdisk_initialize (rtems_device_major_number major,
2021158: 87 28 60 01 sll %g1, 1, %g3 <== NOT EXECUTED
rtems_nvdisk_crc16_factor = malloc (sizeof (uint16_t) * 256);
if (!rtems_nvdisk_crc16_factor)
return RTEMS_NO_MEMORY;
for (b = 0; b < 256; b++)
202115c: 82 00 60 01 inc %g1 <== NOT EXECUTED
2021160: 80 a0 61 00 cmp %g1, 0x100 <== NOT EXECUTED
2021164: 12 bf ff f3 bne 2021130 <rtems_nvdisk_initialize+0x44> <== NOT EXECUTED
2021168: c4 32 00 03 sth %g2, [ %o0 + %g3 ] <== NOT EXECUTED
sc = rtems_nvdisk_crc16_gen_factors (0x8408);
if (sc != RTEMS_SUCCESSFUL)
return sc;
rtems_nvdisks = calloc (rtems_nvdisk_configuration_size,
202116c: 10 80 00 74 b 202133c <rtems_nvdisk_initialize+0x250> <== NOT EXECUTED
2021170: 25 00 81 ac sethi %hi(0x206b000), %l2 <== NOT EXECUTED
if (!rtems_nvdisks)
return RTEMS_NO_MEMORY;
for (minor = 0; minor < rtems_nvdisk_configuration_size; minor++, c++)
{
char name[] = RTEMS_NVDISK_DEVICE_BASE_NAME "a";
2021174: 84 10 a1 76 or %g2, 0x176, %g2 <== NOT EXECUTED
2021178: e8 37 bf f8 sth %l4, [ %fp + -8 ] <== NOT EXECUTED
202117c: 07 0b db 9d sethi %hi(0x2f6e7400), %g3 <== NOT EXECUTED
2021180: 86 10 e2 64 or %g3, 0x264, %g3 ! 2f6e7664 <RAM_END+0x2d2e7664><== NOT EXECUTED
2021184: c4 3f bf f0 std %g2, [ %fp + -16 ] <== NOT EXECUTED
dev_t dev = rtems_filesystem_make_dev_t (major, minor);
uint32_t device;
uint32_t blocks = 0;
nvd = &rtems_nvdisks[minor];
2021188: c4 05 63 dc ld [ %l5 + 0x3dc ], %g2 <== NOT EXECUTED
name [sizeof(RTEMS_NVDISK_DEVICE_BASE_NAME)] += minor;
202118c: e0 2f bf f9 stb %l0, [ %fp + -7 ] <== NOT EXECUTED
* @param major NV disk major device number.
* @param minor Minor device number, not applicable.
* @param arg Initialization argument, not applicable.
*/
rtems_device_driver
rtems_nvdisk_initialize (rtems_device_major_number major,
2021190: 82 06 c0 13 add %i3, %l3, %g1 <== NOT EXECUTED
2021194: 83 28 60 01 sll %g1, 1, %g1 <== NOT EXECUTED
char name[] = RTEMS_NVDISK_DEVICE_BASE_NAME "a";
dev_t dev = rtems_filesystem_make_dev_t (major, minor);
uint32_t device;
uint32_t blocks = 0;
nvd = &rtems_nvdisks[minor];
2021198: b4 00 80 01 add %g2, %g1, %i2 <== NOT EXECUTED
name [sizeof(RTEMS_NVDISK_DEVICE_BASE_NAME)] += minor;
nvd->major = major;
202119c: e2 20 80 01 st %l1, [ %g2 + %g1 ] <== NOT EXECUTED
nvd->minor = minor;
nvd->flags = c->flags;
20211a0: c2 06 ff f8 ld [ %i3 + -8 ], %g1 <== NOT EXECUTED
nvd->block_size = c->block_size;
20211a4: fa 06 ff ec ld [ %i3 + -20 ], %i5 <== NOT EXECUTED
name [sizeof(RTEMS_NVDISK_DEVICE_BASE_NAME)] += minor;
nvd->major = major;
nvd->minor = minor;
nvd->flags = c->flags;
20211a8: c2 26 a0 08 st %g1, [ %i2 + 8 ] <== NOT EXECUTED
nvd->block_size = c->block_size;
nvd->info_level = c->info_level;
nvd->devices = calloc (c->device_count, sizeof (rtems_nvdisk_device_ctl));
20211ac: f0 06 ff f0 ld [ %i3 + -16 ], %i0 <== NOT EXECUTED
nvd->major = major;
nvd->minor = minor;
nvd->flags = c->flags;
nvd->block_size = c->block_size;
nvd->info_level = c->info_level;
20211b0: c2 06 ff fc ld [ %i3 + -4 ], %g1 <== NOT EXECUTED
nvd = &rtems_nvdisks[minor];
name [sizeof(RTEMS_NVDISK_DEVICE_BASE_NAME)] += minor;
nvd->major = major;
nvd->minor = minor;
20211b4: e0 26 a0 04 st %l0, [ %i2 + 4 ] <== NOT EXECUTED
nvd->flags = c->flags;
nvd->block_size = c->block_size;
20211b8: fa 26 a0 0c st %i5, [ %i2 + 0xc ] <== NOT EXECUTED
nvd->info_level = c->info_level;
20211bc: c2 26 a0 24 st %g1, [ %i2 + 0x24 ] <== NOT EXECUTED
nvd->devices = calloc (c->device_count, sizeof (rtems_nvdisk_device_ctl));
20211c0: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
20211c4: 7f ff 9d aa call 200886c <calloc> <== NOT EXECUTED
20211c8: 92 10 20 14 mov 0x14, %o1 <== NOT EXECUTED
if (!nvd->devices)
20211cc: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
20211d0: 02 80 00 43 be 20212dc <rtems_nvdisk_initialize+0x1f0> <== NOT EXECUTED
20211d4: d0 26 a0 14 st %o0, [ %i2 + 0x14 ] <== NOT EXECUTED
20211d8: b2 10 00 08 mov %o0, %i1 <== NOT EXECUTED
20211dc: 96 10 20 00 clr %o3 <== NOT EXECUTED
20211e0: 10 80 00 1b b 202124c <rtems_nvdisk_initialize+0x160> <== NOT EXECUTED
20211e4: b8 10 20 00 clr %i4 <== NOT EXECUTED
* @param major NV disk major device number.
* @param minor Minor device number, not applicable.
* @param arg Initialization argument, not applicable.
*/
rtems_device_driver
rtems_nvdisk_initialize (rtems_device_major_number major,
20211e8: 85 2f 20 04 sll %i4, 4, %g2 <== NOT EXECUTED
for (device = 0; device < c->device_count; device++)
{
rtems_nvdisk_device_ctl* dc = &nvd->devices[device];
dc->device = device;
dc->pages = rtems_nvdisk_pages_in_device (nvd, &c->devices[device]);
20211ec: 86 00 c0 02 add %g3, %g2, %g3 <== NOT EXECUTED
*/
static uint32_t
rtems_nvdisk_pages_in_device (const rtems_nvdisk* nvd,
const rtems_nvdisk_device_desc* dd)
{
return dd->size / nvd->block_size;
20211f0: d0 00 e0 08 ld [ %g3 + 8 ], %o0 <== NOT EXECUTED
for (device = 0; device < c->device_count; device++)
{
rtems_nvdisk_device_ctl* dc = &nvd->devices[device];
dc->device = device;
20211f4: f8 26 40 00 st %i4, [ %i1 ] <== NOT EXECUTED
*/
static uint32_t
rtems_nvdisk_pages_in_device (const rtems_nvdisk* nvd,
const rtems_nvdisk_device_desc* dd)
{
return dd->size / nvd->block_size;
20211f8: c6 27 bf ec st %g3, [ %fp + -20 ] <== NOT EXECUTED
20211fc: d6 27 bf e4 st %o3, [ %fp + -28 ] <== NOT EXECUTED
2021200: 40 00 e8 e0 call 205b580 <.udiv> <== NOT EXECUTED
2021204: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
2021208: 84 10 00 08 mov %o0, %g2 <== NOT EXECUTED
for (device = 0; device < c->device_count; device++)
{
rtems_nvdisk_device_ctl* dc = &nvd->devices[device];
dc->device = device;
dc->pages = rtems_nvdisk_pages_in_device (nvd, &c->devices[device]);
202120c: d0 26 60 04 st %o0, [ %i1 + 4 ] <== NOT EXECUTED
rtems_nvdisk_page_desc_pages (const rtems_nvdisk* nvd,
const rtems_nvdisk_device_desc* dd)
{
uint32_t pages = rtems_nvdisk_pages_in_device (nvd, dd);
uint32_t bytes = pages * sizeof (uint16_t);
return ((bytes - 1) / nvd->block_size) + 1;
2021210: c4 27 bf e8 st %g2, [ %fp + -24 ] <== NOT EXECUTED
static uint32_t
rtems_nvdisk_page_desc_pages (const rtems_nvdisk* nvd,
const rtems_nvdisk_device_desc* dd)
{
uint32_t pages = rtems_nvdisk_pages_in_device (nvd, dd);
uint32_t bytes = pages * sizeof (uint16_t);
2021214: 91 2a 20 01 sll %o0, 1, %o0 <== NOT EXECUTED
return ((bytes - 1) / nvd->block_size) + 1;
2021218: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
202121c: 40 00 e8 d9 call 205b580 <.udiv> <== NOT EXECUTED
2021220: 90 02 3f ff add %o0, -1, %o0 <== NOT EXECUTED
rtems_nvdisk_device_ctl* dc = &nvd->devices[device];
dc->device = device;
dc->pages = rtems_nvdisk_pages_in_device (nvd, &c->devices[device]);
dc->pages_desc = rtems_nvdisk_page_desc_pages (nvd, &c->devices[device]);
dc->block_base = blocks;
2021224: d6 07 bf e4 ld [ %fp + -28 ], %o3 <== NOT EXECUTED
blocks += dc->pages - dc->pages_desc;
2021228: c4 1f bf e8 ldd [ %fp + -24 ], %g2 <== NOT EXECUTED
rtems_nvdisk_page_desc_pages (const rtems_nvdisk* nvd,
const rtems_nvdisk_device_desc* dd)
{
uint32_t pages = rtems_nvdisk_pages_in_device (nvd, dd);
uint32_t bytes = pages * sizeof (uint16_t);
return ((bytes - 1) / nvd->block_size) + 1;
202122c: 90 02 20 01 inc %o0 <== NOT EXECUTED
rtems_nvdisk_device_ctl* dc = &nvd->devices[device];
dc->device = device;
dc->pages = rtems_nvdisk_pages_in_device (nvd, &c->devices[device]);
dc->pages_desc = rtems_nvdisk_page_desc_pages (nvd, &c->devices[device]);
dc->block_base = blocks;
2021230: d6 26 60 0c st %o3, [ %i1 + 0xc ] <== NOT EXECUTED
{
rtems_nvdisk_device_ctl* dc = &nvd->devices[device];
dc->device = device;
dc->pages = rtems_nvdisk_pages_in_device (nvd, &c->devices[device]);
dc->pages_desc = rtems_nvdisk_page_desc_pages (nvd, &c->devices[device]);
2021234: d0 26 60 08 st %o0, [ %i1 + 8 ] <== NOT EXECUTED
dc->block_base = blocks;
blocks += dc->pages - dc->pages_desc;
2021238: 84 20 80 08 sub %g2, %o0, %g2 <== NOT EXECUTED
dc->descriptor = &c->devices[device];
202123c: c6 26 60 10 st %g3, [ %i1 + 0x10 ] <== NOT EXECUTED
dc->device = device;
dc->pages = rtems_nvdisk_pages_in_device (nvd, &c->devices[device]);
dc->pages_desc = rtems_nvdisk_page_desc_pages (nvd, &c->devices[device]);
dc->block_base = blocks;
blocks += dc->pages - dc->pages_desc;
2021240: 96 02 c0 02 add %o3, %g2, %o3 <== NOT EXECUTED
nvd->devices = calloc (c->device_count, sizeof (rtems_nvdisk_device_ctl));
if (!nvd->devices)
return RTEMS_NO_MEMORY;
for (device = 0; device < c->device_count; device++)
2021244: b8 07 20 01 inc %i4 <== NOT EXECUTED
2021248: b2 06 60 14 add %i1, 0x14, %i1 <== NOT EXECUTED
202124c: 80 a7 00 18 cmp %i4, %i0 <== NOT EXECUTED
2021250: 32 bf ff e6 bne,a 20211e8 <rtems_nvdisk_initialize+0xfc> <== NOT EXECUTED
2021254: c6 06 ff f4 ld [ %i3 + -12 ], %g3 <== NOT EXECUTED
blocks += dc->pages - dc->pages_desc;
dc->descriptor = &c->devices[device];
}
nvd->block_count = blocks;
2021258: d6 26 a0 10 st %o3, [ %i2 + 0x10 ] <== NOT EXECUTED
nvd->device_count = c->device_count;
202125c: f8 26 a0 18 st %i4, [ %i2 + 0x18 ] <== NOT EXECUTED
sc = rtems_disk_create_phys(dev, c->block_size, blocks,
2021260: ec 23 a0 5c st %l6, [ %sp + 0x5c ] <== NOT EXECUTED
2021264: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED
2021268: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED
202126c: 94 10 00 1d mov %i5, %o2 <== NOT EXECUTED
2021270: 98 10 00 17 mov %l7, %o4 <== NOT EXECUTED
2021274: 7f ff 9a 72 call 2007c3c <rtems_disk_create_phys> <== NOT EXECUTED
2021278: 9a 10 20 00 clr %o5 <== NOT EXECUTED
rtems_nvdisk_ioctl, NULL, name);
if (sc != RTEMS_SUCCESSFUL)
202127c: b0 92 20 00 orcc %o0, 0, %i0 <== NOT EXECUTED
2021280: 02 80 00 05 be 2021294 <rtems_nvdisk_initialize+0x1a8> <== NOT EXECUTED
2021284: 07 00 81 8a sethi %hi(0x2062800), %g3 <== NOT EXECUTED
{
rtems_nvdisk_error ("disk create phy failed");
2021288: 11 00 81 8a sethi %hi(0x2062800), %o0 <== NOT EXECUTED
202128c: 10 80 00 0e b 20212c4 <rtems_nvdisk_initialize+0x1d8> <== NOT EXECUTED
2021290: 90 12 21 e8 or %o0, 0x1e8, %o0 ! 20629e8 <msdos_ops+0xe8> <== NOT EXECUTED
return sc;
}
sc = rtems_semaphore_create (rtems_build_name ('N', 'V', 'D', 'K'), 1,
2021294: d0 00 e2 18 ld [ %g3 + 0x218 ], %o0 <== NOT EXECUTED
2021298: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
202129c: 94 10 20 54 mov 0x54, %o2 <== NOT EXECUTED
20212a0: 96 10 20 00 clr %o3 <== NOT EXECUTED
20212a4: 98 06 a0 20 add %i2, 0x20, %o4 <== NOT EXECUTED
20212a8: 7f ff af cb call 200d1d4 <rtems_semaphore_create> <== NOT EXECUTED
20212ac: b6 06 e0 14 add %i3, 0x14, %i3 <== NOT EXECUTED
RTEMS_PRIORITY | RTEMS_BINARY_SEMAPHORE |
RTEMS_INHERIT_PRIORITY, 0, &nvd->lock);
if (sc != RTEMS_SUCCESSFUL)
20212b0: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
20212b4: 02 80 00 08 be 20212d4 <rtems_nvdisk_initialize+0x1e8> <== NOT EXECUTED
20212b8: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED
{
rtems_nvdisk_error ("disk lock create failed");
20212bc: 11 00 81 8a sethi %hi(0x2062800), %o0 <== NOT EXECUTED
20212c0: 90 12 22 00 or %o0, 0x200, %o0 ! 2062a00 <msdos_ops+0x100><== NOT EXECUTED
20212c4: 7f ff fe 06 call 2020adc <rtems_nvdisk_error> <== NOT EXECUTED
20212c8: 01 00 00 00 nop <== NOT EXECUTED
20212cc: 81 c7 e0 08 ret <== NOT EXECUTED
20212d0: 81 e8 00 00 restore <== NOT EXECUTED
sizeof (rtems_nvdisk));
if (!rtems_nvdisks)
return RTEMS_NO_MEMORY;
for (minor = 0; minor < rtems_nvdisk_configuration_size; minor++, c++)
20212d4: 10 80 00 12 b 202131c <rtems_nvdisk_initialize+0x230> <== NOT EXECUTED
20212d8: a0 04 20 01 inc %l0 <== NOT EXECUTED
nvd->block_size = c->block_size;
nvd->info_level = c->info_level;
nvd->devices = calloc (c->device_count, sizeof (rtems_nvdisk_device_ctl));
if (!nvd->devices)
return RTEMS_NO_MEMORY;
20212dc: 81 c7 e0 08 ret <== NOT EXECUTED
20212e0: 91 e8 20 1a restore %g0, 0x1a, %o0 <== NOT EXECUTED
20212e4: 37 00 81 7a sethi %hi(0x205e800), %i3 <== NOT EXECUTED
20212e8: b6 16 e0 3c or %i3, 0x3c, %i3 ! 205e83c <rtems_bdbuf_configuration><== NOT EXECUTED
* @param major NV disk major device number.
* @param minor Minor device number, not applicable.
* @param arg Initialization argument, not applicable.
*/
rtems_device_driver
rtems_nvdisk_initialize (rtems_device_major_number major,
20212ec: 82 06 ff ec add %i3, -20, %g1 <== NOT EXECUTED
20212f0: a7 28 60 1f sll %g1, 0x1f, %l3 <== NOT EXECUTED
20212f4: 05 1f ff ff sethi %hi(0x7ffffc00), %g2 <== NOT EXECUTED
20212f8: 82 24 c0 01 sub %l3, %g1, %g1 <== NOT EXECUTED
20212fc: 84 10 a3 ec or %g2, 0x3ec, %g2 <== NOT EXECUTED
if (!rtems_nvdisks)
return RTEMS_NO_MEMORY;
for (minor = 0; minor < rtems_nvdisk_configuration_size; minor++, c++)
{
char name[] = RTEMS_NVDISK_DEVICE_BASE_NAME "a";
2021300: 29 00 00 18 sethi %hi(0x6000), %l4 <== NOT EXECUTED
}
nvd->block_count = blocks;
nvd->device_count = c->device_count;
sc = rtems_disk_create_phys(dev, c->block_size, blocks,
2021304: 2f 00 80 82 sethi %hi(0x2020800), %l7 <== NOT EXECUTED
* @param major NV disk major device number.
* @param minor Minor device number, not applicable.
* @param arg Initialization argument, not applicable.
*/
rtems_device_driver
rtems_nvdisk_initialize (rtems_device_major_number major,
2021308: a6 00 40 02 add %g1, %g2, %l3 <== NOT EXECUTED
202130c: a0 10 20 00 clr %l0 <== NOT EXECUTED
if (!rtems_nvdisks)
return RTEMS_NO_MEMORY;
for (minor = 0; minor < rtems_nvdisk_configuration_size; minor++, c++)
{
char name[] = RTEMS_NVDISK_DEVICE_BASE_NAME "a";
2021310: a8 15 21 00 or %l4, 0x100, %l4 <== NOT EXECUTED
nvd->block_count = blocks;
nvd->device_count = c->device_count;
sc = rtems_disk_create_phys(dev, c->block_size, blocks,
rtems_nvdisk_ioctl, NULL, name);
2021314: ac 07 bf f0 add %fp, -16, %l6 <== NOT EXECUTED
}
nvd->block_count = blocks;
nvd->device_count = c->device_count;
sc = rtems_disk_create_phys(dev, c->block_size, blocks,
2021318: ae 15 e3 dc or %l7, 0x3dc, %l7 <== NOT EXECUTED
sizeof (rtems_nvdisk));
if (!rtems_nvdisks)
return RTEMS_NO_MEMORY;
for (minor = 0; minor < rtems_nvdisk_configuration_size; minor++, c++)
202131c: c2 04 a2 b0 ld [ %l2 + 0x2b0 ], %g1 <== NOT EXECUTED
2021320: 80 a4 00 01 cmp %l0, %g1 <== NOT EXECUTED
2021324: 0a bf ff 94 bcs 2021174 <rtems_nvdisk_initialize+0x88> <== NOT EXECUTED
2021328: 05 0b d9 19 sethi %hi(0x2f646400), %g2 <== NOT EXECUTED
rtems_nvdisk_error ("disk lock create failed");
return sc;
}
}
rtems_nvdisk_count = rtems_nvdisk_configuration_size;
202132c: 05 00 81 bb sethi %hi(0x206ec00), %g2 <== NOT EXECUTED
2021330: c2 20 a3 e0 st %g1, [ %g2 + 0x3e0 ] ! 206efe0 <rtems_nvdisk_count><== NOT EXECUTED
return RTEMS_SUCCESSFUL;
2021334: 81 c7 e0 08 ret <== NOT EXECUTED
2021338: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED
sc = rtems_nvdisk_crc16_gen_factors (0x8408);
if (sc != RTEMS_SUCCESSFUL)
return sc;
rtems_nvdisks = calloc (rtems_nvdisk_configuration_size,
202133c: d0 04 a2 b0 ld [ %l2 + 0x2b0 ], %o0 <== NOT EXECUTED
2021340: 92 10 20 28 mov 0x28, %o1 <== NOT EXECUTED
2021344: 7f ff 9d 4a call 200886c <calloc> <== NOT EXECUTED
2021348: 2b 00 81 bb sethi %hi(0x206ec00), %l5 <== NOT EXECUTED
sizeof (rtems_nvdisk));
if (!rtems_nvdisks)
202134c: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2021350: 12 bf ff e5 bne 20212e4 <rtems_nvdisk_initialize+0x1f8> <== NOT EXECUTED
2021354: d0 25 63 dc st %o0, [ %l5 + 0x3dc ] <== NOT EXECUTED
2021358: 30 bf ff e1 b,a 20212dc <rtems_nvdisk_initialize+0x1f0> <== NOT EXECUTED
}
rtems_nvdisk_count = rtems_nvdisk_configuration_size;
return RTEMS_SUCCESSFUL;
}
202135c: 81 c7 e0 08 ret <== NOT EXECUTED
2021360: 81 e8 00 00 restore <== NOT EXECUTED
02020bdc <rtems_nvdisk_ioctl>:
* @param argp IOCTL argument.
* @retval The IOCTL return value
*/
static int
rtems_nvdisk_ioctl (rtems_disk_device *dd, uint32_t req, void* argp)
{
2020bdc: 9d e3 bf 88 save %sp, -120, %sp <== NOT EXECUTED
dev_t dev = rtems_disk_get_device_identifier (dd);
rtems_device_minor_number minor = rtems_filesystem_dev_minor_t (dev);
rtems_blkdev_request* r = argp;
rtems_status_code sc;
if (minor >= rtems_nvdisk_count)
2020be0: 05 00 81 bb sethi %hi(0x206ec00), %g2 <== NOT EXECUTED
dev_t device
)
{
union __rtems_dev_t temp;
temp.device = device;
2020be4: c2 06 20 04 ld [ %i0 + 4 ], %g1 <== NOT EXECUTED
2020be8: c4 00 a3 e0 ld [ %g2 + 0x3e0 ], %g2 <== NOT EXECUTED
2020bec: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED
2020bf0: 2a 80 00 03 bcs,a 2020bfc <rtems_nvdisk_ioctl+0x20> <== NOT EXECUTED
2020bf4: b7 28 60 03 sll %g1, 3, %i3 <== NOT EXECUTED
2020bf8: 30 80 00 0a b,a 2020c20 <rtems_nvdisk_ioctl+0x44> <== NOT EXECUTED
{
errno = ENODEV;
return -1;
}
if (rtems_nvdisks[minor].device_count == 0)
2020bfc: 83 28 60 05 sll %g1, 5, %g1 <== NOT EXECUTED
2020c00: 3b 00 81 bb sethi %hi(0x206ec00), %i5 <== NOT EXECUTED
2020c04: b6 06 c0 01 add %i3, %g1, %i3 <== NOT EXECUTED
2020c08: c2 07 63 dc ld [ %i5 + 0x3dc ], %g1 <== NOT EXECUTED
2020c0c: 82 00 40 1b add %g1, %i3, %g1 <== NOT EXECUTED
2020c10: c2 00 60 18 ld [ %g1 + 0x18 ], %g1 <== NOT EXECUTED
2020c14: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
2020c18: 12 80 00 08 bne 2020c38 <rtems_nvdisk_ioctl+0x5c> <== NOT EXECUTED
2020c1c: 01 00 00 00 nop <== NOT EXECUTED
{
errno = ENODEV;
2020c20: 40 00 85 73 call 20421ec <__errno> <== NOT EXECUTED
2020c24: b0 10 3f ff mov -1, %i0 ! ffffffff <RAM_END+0xfdbfffff> <== NOT EXECUTED
2020c28: 82 10 20 13 mov 0x13, %g1 <== NOT EXECUTED
2020c2c: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
return -1;
2020c30: 81 c7 e0 08 ret <== NOT EXECUTED
2020c34: 81 e8 00 00 restore <== NOT EXECUTED
}
errno = 0;
2020c38: 40 00 85 6d call 20421ec <__errno> <== NOT EXECUTED
2020c3c: 01 00 00 00 nop <== NOT EXECUTED
sc = rtems_semaphore_obtain (rtems_nvdisks[minor].lock, RTEMS_WAIT, 0);
2020c40: c2 07 63 dc ld [ %i5 + 0x3dc ], %g1 <== NOT EXECUTED
{
errno = ENODEV;
return -1;
}
errno = 0;
2020c44: c0 22 00 00 clr [ %o0 ] <== NOT EXECUTED
sc = rtems_semaphore_obtain (rtems_nvdisks[minor].lock, RTEMS_WAIT, 0);
2020c48: 82 00 40 1b add %g1, %i3, %g1 <== NOT EXECUTED
2020c4c: d0 00 60 20 ld [ %g1 + 0x20 ], %o0 <== NOT EXECUTED
2020c50: 92 10 20 00 clr %o1 <== NOT EXECUTED
2020c54: 7f ff b2 18 call 200d4b4 <rtems_semaphore_obtain> <== NOT EXECUTED
2020c58: 94 10 20 00 clr %o2 <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
2020c5c: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2020c60: 12 80 01 16 bne 20210b8 <rtems_nvdisk_ioctl+0x4dc> <== NOT EXECUTED
2020c64: 01 00 00 00 nop <== NOT EXECUTED
errno = EIO;
else
{
errno = 0;
2020c68: 40 00 85 61 call 20421ec <__errno> <== NOT EXECUTED
2020c6c: 01 00 00 00 nop <== NOT EXECUTED
switch (req)
2020c70: 03 08 00 10 sethi %hi(0x20004000), %g1 <== NOT EXECUTED
2020c74: 84 10 62 82 or %g1, 0x282, %g2 ! 20004282 <RAM_END+0x1dc04282><== NOT EXECUTED
2020c78: 80 a6 40 02 cmp %i1, %g2 <== NOT EXECUTED
2020c7c: 02 80 01 00 be 202107c <rtems_nvdisk_ioctl+0x4a0> <== NOT EXECUTED
2020c80: c0 22 00 00 clr [ %o0 ] <== NOT EXECUTED
2020c84: 05 30 06 10 sethi %hi(0xc0184000), %g2 <== NOT EXECUTED
2020c88: 84 10 a2 01 or %g2, 0x201, %g2 ! c0184201 <RAM_END+0xbdd84201><== NOT EXECUTED
2020c8c: 80 a6 40 02 cmp %i1, %g2 <== NOT EXECUTED
2020c90: 02 80 00 06 be 2020ca8 <rtems_nvdisk_ioctl+0xcc> <== NOT EXECUTED
2020c94: 82 10 62 80 or %g1, 0x280, %g1 <== NOT EXECUTED
2020c98: 80 a6 40 01 cmp %i1, %g1 <== NOT EXECUTED
2020c9c: 32 80 00 fc bne,a 202108c <rtems_nvdisk_ioctl+0x4b0> <== NOT EXECUTED
2020ca0: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
2020ca4: 30 80 00 d2 b,a 2020fec <rtems_nvdisk_ioctl+0x410> <== NOT EXECUTED
{
case RTEMS_BLKIO_REQUEST:
switch (r->req)
2020ca8: c2 06 80 00 ld [ %i2 ], %g1 <== NOT EXECUTED
2020cac: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
2020cb0: 02 80 00 05 be 2020cc4 <rtems_nvdisk_ioctl+0xe8> <== NOT EXECUTED
2020cb4: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED
2020cb8: 12 80 00 c8 bne 2020fd8 <rtems_nvdisk_ioctl+0x3fc> <== NOT EXECUTED
2020cbc: 01 00 00 00 nop <== NOT EXECUTED
2020cc0: 30 80 00 71 b,a 2020e84 <rtems_nvdisk_ioctl+0x2a8> <== NOT EXECUTED
{
case RTEMS_BLKDEV_REQ_READ:
errno = rtems_nvdisk_read (&rtems_nvdisks[minor], r);
2020cc4: 40 00 85 4a call 20421ec <__errno> <== NOT EXECUTED
2020cc8: 29 00 00 3f sethi %hi(0xfc00), %l4 <== NOT EXECUTED
2020ccc: f8 07 63 dc ld [ %i5 + 0x3dc ], %i4 <== NOT EXECUTED
cs = rtems_nvdisk_page_checksum (buffer, nvd->block_size);
if (cs != crc)
{
rtems_nvdisk_error ("read-block: crc failure: %d: buffer:%04x page:%04x",
2020cd0: 2d 00 81 8a sethi %hi(0x2062800), %l6 <== NOT EXECUTED
{
case RTEMS_BLKIO_REQUEST:
switch (r->req)
{
case RTEMS_BLKDEV_REQ_READ:
errno = rtems_nvdisk_read (&rtems_nvdisks[minor], r);
2020cd4: a6 10 00 08 mov %o0, %l3 <== NOT EXECUTED
2020cd8: b8 07 00 1b add %i4, %i3, %i4 <== NOT EXECUTED
* @retval int The ioctl return value.
*/
static int
rtems_nvdisk_read (rtems_nvdisk* nvd, rtems_blkdev_request* req)
{
rtems_blkdev_sg_buffer* sg = req->bufs;
2020cdc: b2 06 a0 18 add %i2, 0x18, %i1 <== NOT EXECUTED
#if RTEMS_NVDISK_TRACE
rtems_nvdisk_info (nvd, "read: blocks=%d", req->bufnum);
#endif
for (bufs = 0; (ret == 0) && (bufs < req->bufnum); bufs++, sg++)
2020ce0: a2 10 20 00 clr %l1 <== NOT EXECUTED
ret = rtems_nvdisk_read_checksum (nvd, dc->device, page, &crc);
if (ret)
return ret;
if (crc == 0xffff)
2020ce4: a8 15 23 ff or %l4, 0x3ff, %l4 <== NOT EXECUTED
{
uint16_t cs = 0xffff;
uint32_t i;
for (i = 0; i < page_size; i++, buffer++)
cs = rtems_nvdisk_calc_crc16 (cs, *buffer);
2020ce8: 2b 00 81 bb sethi %hi(0x206ec00), %l5 <== NOT EXECUTED
cs = rtems_nvdisk_page_checksum (buffer, nvd->block_size);
if (cs != crc)
{
rtems_nvdisk_error ("read-block: crc failure: %d: buffer:%04x page:%04x",
2020cec: 10 80 00 58 b 2020e4c <rtems_nvdisk_ioctl+0x270> <== NOT EXECUTED
2020cf0: ac 15 a1 b0 or %l6, 0x1b0, %l6 <== NOT EXECUTED
for (bufs = 0; (ret == 0) && (bufs < req->bufnum); bufs++, sg++)
{
uint8_t* data;
uint32_t nvb;
uint32_t b;
nvb = sg->length / nvd->block_size;
2020cf4: d2 07 20 0c ld [ %i4 + 0xc ], %o1 <== NOT EXECUTED
2020cf8: 40 00 ea 22 call 205b580 <.udiv> <== NOT EXECUTED
2020cfc: a0 10 20 00 clr %l0 <== NOT EXECUTED
data = sg->buffer;
2020d00: f0 06 60 08 ld [ %i1 + 8 ], %i0 <== NOT EXECUTED
for (bufs = 0; (ret == 0) && (bufs < req->bufnum); bufs++, sg++)
{
uint8_t* data;
uint32_t nvb;
uint32_t b;
nvb = sg->length / nvd->block_size;
2020d04: 10 80 00 4a b 2020e2c <rtems_nvdisk_ioctl+0x250> <== NOT EXECUTED
2020d08: ae 10 00 08 mov %o0, %l7 <== NOT EXECUTED
uint32_t page;
uint16_t crc;
uint16_t cs;
int ret;
dc = rtems_nvdisk_get_device (nvd, block);
2020d0c: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
uint32_t b;
nvb = sg->length / nvd->block_size;
data = sg->buffer;
for (b = 0; b < nvb; b++, data += nvd->block_size)
{
ret = rtems_nvdisk_read_block (nvd, sg->block + b, data);
2020d10: a4 04 00 12 add %l0, %l2, %l2 <== NOT EXECUTED
uint32_t page;
uint16_t crc;
uint16_t cs;
int ret;
dc = rtems_nvdisk_get_device (nvd, block);
2020d14: 7f ff ff 8f call 2020b50 <rtems_nvdisk_get_device> <== NOT EXECUTED
2020d18: 92 10 00 12 mov %l2, %o1 <== NOT EXECUTED
if (!dc)
2020d1c: 82 92 20 00 orcc %o0, 0, %g1 <== NOT EXECUTED
2020d20: 02 80 00 3e be 2020e18 <rtems_nvdisk_ioctl+0x23c> <== NOT EXECUTED
2020d24: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
*/
static uint32_t
rtems_nvdisk_get_page (rtems_nvdisk_device_ctl* dc,
uint32_t block)
{
return block - dc->block_base;
2020d28: c4 00 60 0c ld [ %g1 + 0xc ], %g2 <== NOT EXECUTED
rtems_nvdisk_read_checksum (const rtems_nvdisk* nvd,
uint32_t device,
uint32_t page,
uint16_t* cs)
{
return rtems_nvdisk_device_read (nvd, device,
2020d2c: d2 00 40 00 ld [ %g1 ], %o1 <== NOT EXECUTED
*/
static uint32_t
rtems_nvdisk_get_page (rtems_nvdisk_device_ctl* dc,
uint32_t block)
{
return block - dc->block_base;
2020d30: 84 24 80 02 sub %l2, %g2, %g2 <== NOT EXECUTED
rtems_nvdisk_read_checksum (const rtems_nvdisk* nvd,
uint32_t device,
uint32_t page,
uint16_t* cs)
{
return rtems_nvdisk_device_read (nvd, device,
2020d34: c2 27 bf f4 st %g1, [ %fp + -12 ] <== NOT EXECUTED
2020d38: 95 28 a0 01 sll %g2, 1, %o2 <== NOT EXECUTED
2020d3c: c4 27 bf e8 st %g2, [ %fp + -24 ] <== NOT EXECUTED
2020d40: 96 07 bf fe add %fp, -2, %o3 <== NOT EXECUTED
2020d44: 7f ff ff 42 call 2020a4c <rtems_nvdisk_device_read> <== NOT EXECUTED
2020d48: 98 10 20 02 mov 2, %o4 <== NOT EXECUTED
block, dc->device, page, crc);
#endif
ret = rtems_nvdisk_read_checksum (nvd, dc->device, page, &crc);
if (ret)
2020d4c: c2 07 bf f4 ld [ %fp + -12 ], %g1 <== NOT EXECUTED
2020d50: ba 92 20 00 orcc %o0, 0, %i5 <== NOT EXECUTED
2020d54: 12 80 00 3a bne 2020e3c <rtems_nvdisk_ioctl+0x260> <== NOT EXECUTED
2020d58: c4 07 bf e8 ld [ %fp + -24 ], %g2 <== NOT EXECUTED
return ret;
if (crc == 0xffff)
2020d5c: c6 17 bf fe lduh [ %fp + -2 ], %g3 <== NOT EXECUTED
2020d60: 80 a0 c0 14 cmp %g3, %l4 <== NOT EXECUTED
2020d64: 32 80 00 08 bne,a 2020d84 <rtems_nvdisk_ioctl+0x1a8> <== NOT EXECUTED
2020d68: fa 07 20 0c ld [ %i4 + 0xc ], %i5 <== NOT EXECUTED
{
#if RTEMS_NVDISK_TRACE
rtems_nvdisk_warning (nvd, "read-block: crc not set: %d", block);
#endif
memset (buffer, 0, nvd->block_size);
2020d6c: d4 07 20 0c ld [ %i4 + 0xc ], %o2 <== NOT EXECUTED
2020d70: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
2020d74: 40 00 92 ec call 2045924 <memset> <== NOT EXECUTED
2020d78: 92 10 20 00 clr %o1 <== NOT EXECUTED
uint8_t* data;
uint32_t nvb;
uint32_t b;
nvb = sg->length / nvd->block_size;
data = sg->buffer;
for (b = 0; b < nvb; b++, data += nvd->block_size)
2020d7c: 10 80 00 2a b 2020e24 <rtems_nvdisk_ioctl+0x248> <== NOT EXECUTED
2020d80: c2 07 20 0c ld [ %i4 + 0xc ], %g1 <== NOT EXECUTED
rtems_nvdisk_read_page (const rtems_nvdisk* nvd,
uint32_t device,
uint32_t page,
void* buffer)
{
return rtems_nvdisk_device_read (nvd, device,
2020d84: c6 00 40 00 ld [ %g1 ], %g3 <== NOT EXECUTED
#endif
memset (buffer, 0, nvd->block_size);
return 0;
}
ret = rtems_nvdisk_read_page (nvd, dc->device, page + dc->pages_desc, buffer);
2020d88: d0 00 60 08 ld [ %g1 + 8 ], %o0 <== NOT EXECUTED
rtems_nvdisk_read_page (const rtems_nvdisk* nvd,
uint32_t device,
uint32_t page,
void* buffer)
{
return rtems_nvdisk_device_read (nvd, device,
2020d8c: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
2020d90: 90 00 80 08 add %g2, %o0, %o0 <== NOT EXECUTED
2020d94: 7f ff 88 34 call 2002e64 <.umul> <== NOT EXECUTED
2020d98: c6 27 bf ec st %g3, [ %fp + -20 ] <== NOT EXECUTED
2020d9c: c6 07 bf ec ld [ %fp + -20 ], %g3 <== NOT EXECUTED
2020da0: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
2020da4: 98 10 00 1d mov %i5, %o4 <== NOT EXECUTED
2020da8: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
2020dac: 92 10 00 03 mov %g3, %o1 <== NOT EXECUTED
2020db0: 7f ff ff 27 call 2020a4c <rtems_nvdisk_device_read> <== NOT EXECUTED
2020db4: 96 10 00 18 mov %i0, %o3 <== NOT EXECUTED
return 0;
}
ret = rtems_nvdisk_read_page (nvd, dc->device, page + dc->pages_desc, buffer);
if (ret)
2020db8: ba 92 20 00 orcc %o0, 0, %i5 <== NOT EXECUTED
2020dbc: 12 80 00 20 bne 2020e3c <rtems_nvdisk_ioctl+0x260> <== NOT EXECUTED
2020dc0: c6 05 63 e4 ld [ %l5 + 0x3e4 ], %g3 <== NOT EXECUTED
return ret;
cs = rtems_nvdisk_page_checksum (buffer, nvd->block_size);
2020dc4: c4 07 20 0c ld [ %i4 + 0xc ], %g2 <== NOT EXECUTED
rtems_nvdisk_page_checksum (const uint8_t* buffer, uint32_t page_size)
{
uint16_t cs = 0xffff;
uint32_t i;
for (i = 0; i < page_size; i++, buffer++)
2020dc8: 82 10 20 00 clr %g1 <== NOT EXECUTED
* Calculate the checksum of a page.
*/
static uint16_t
rtems_nvdisk_page_checksum (const uint8_t* buffer, uint32_t page_size)
{
uint16_t cs = 0xffff;
2020dcc: 10 80 00 09 b 2020df0 <rtems_nvdisk_ioctl+0x214> <== NOT EXECUTED
2020dd0: 94 10 3f ff mov -1, %o2 <== NOT EXECUTED
uint32_t i;
for (i = 0; i < page_size; i++, buffer++)
cs = rtems_nvdisk_calc_crc16 (cs, *buffer);
2020dd4: c8 0e 00 01 ldub [ %i0 + %g1 ], %g4 <== NOT EXECUTED
2020dd8: 95 32 a0 10 srl %o2, 0x10, %o2 <== NOT EXECUTED
2020ddc: 94 19 00 0a xor %g4, %o2, %o2 <== NOT EXECUTED
2020de0: 94 0a a0 ff and %o2, 0xff, %o2 <== NOT EXECUTED
2020de4: 95 2a a0 01 sll %o2, 1, %o2 <== NOT EXECUTED
2020de8: d4 10 c0 0a lduh [ %g3 + %o2 ], %o2 <== NOT EXECUTED
rtems_nvdisk_page_checksum (const uint8_t* buffer, uint32_t page_size)
{
uint16_t cs = 0xffff;
uint32_t i;
for (i = 0; i < page_size; i++, buffer++)
2020dec: 82 00 60 01 inc %g1 <== NOT EXECUTED
2020df0: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED
2020df4: 12 bf ff f8 bne 2020dd4 <rtems_nvdisk_ioctl+0x1f8> <== NOT EXECUTED
2020df8: 95 2a a0 10 sll %o2, 0x10, %o2 <== NOT EXECUTED
if (ret)
return ret;
cs = rtems_nvdisk_page_checksum (buffer, nvd->block_size);
if (cs != crc)
2020dfc: d6 17 bf fe lduh [ %fp + -2 ], %o3 <== NOT EXECUTED
2020e00: 95 32 a0 10 srl %o2, 0x10, %o2 <== NOT EXECUTED
2020e04: 80 a2 80 0b cmp %o2, %o3 <== NOT EXECUTED
2020e08: 02 80 00 06 be 2020e20 <rtems_nvdisk_ioctl+0x244> <== NOT EXECUTED
2020e0c: 90 10 00 16 mov %l6, %o0 <== NOT EXECUTED
{
rtems_nvdisk_error ("read-block: crc failure: %d: buffer:%04x page:%04x",
2020e10: 7f ff ff 33 call 2020adc <rtems_nvdisk_error> <== NOT EXECUTED
2020e14: 92 10 00 12 mov %l2, %o1 <== NOT EXECUTED
int ret;
dc = rtems_nvdisk_get_device (nvd, block);
if (!dc)
return EIO;
2020e18: 10 80 00 09 b 2020e3c <rtems_nvdisk_ioctl+0x260> <== NOT EXECUTED
2020e1c: ba 10 20 05 mov 5, %i5 <== NOT EXECUTED
uint8_t* data;
uint32_t nvb;
uint32_t b;
nvb = sg->length / nvd->block_size;
data = sg->buffer;
for (b = 0; b < nvb; b++, data += nvd->block_size)
2020e20: c2 07 20 0c ld [ %i4 + 0xc ], %g1 <== NOT EXECUTED
2020e24: a0 04 20 01 inc %l0 <== NOT EXECUTED
2020e28: b0 06 00 01 add %i0, %g1, %i0 <== NOT EXECUTED
2020e2c: 80 a4 00 17 cmp %l0, %l7 <== NOT EXECUTED
2020e30: 32 bf ff b7 bne,a 2020d0c <rtems_nvdisk_ioctl+0x130> <== NOT EXECUTED
2020e34: e4 06 40 00 ld [ %i1 ], %l2 <== NOT EXECUTED
2020e38: ba 10 20 00 clr %i5 <== NOT EXECUTED
#if RTEMS_NVDISK_TRACE
rtems_nvdisk_info (nvd, "read: blocks=%d", req->bufnum);
#endif
for (bufs = 0; (ret == 0) && (bufs < req->bufnum); bufs++, sg++)
2020e3c: a2 04 60 01 inc %l1 <== NOT EXECUTED
2020e40: 80 a7 60 00 cmp %i5, 0 <== NOT EXECUTED
2020e44: 12 80 00 09 bne 2020e68 <rtems_nvdisk_ioctl+0x28c> <== NOT EXECUTED
2020e48: b2 06 60 10 add %i1, 0x10, %i1 <== NOT EXECUTED
2020e4c: c2 06 a0 10 ld [ %i2 + 0x10 ], %g1 <== NOT EXECUTED
2020e50: 80 a4 40 01 cmp %l1, %g1 <== NOT EXECUTED
2020e54: 2a bf ff a8 bcs,a 2020cf4 <rtems_nvdisk_ioctl+0x118> <== NOT EXECUTED
2020e58: d0 06 60 04 ld [ %i1 + 4 ], %o0 <== NOT EXECUTED
2020e5c: ba 10 20 00 clr %i5 <== NOT EXECUTED
if (ret)
break;
}
}
req->status = ret ? RTEMS_IO_ERROR : RTEMS_SUCCESSFUL;
2020e60: 10 80 00 03 b 2020e6c <rtems_nvdisk_ioctl+0x290> <== NOT EXECUTED
2020e64: 92 10 20 00 clr %o1 <== NOT EXECUTED
2020e68: 92 10 20 1b mov 0x1b, %o1 <== NOT EXECUTED
req->req_done (req->done_arg, req->status);
2020e6c: c2 06 a0 04 ld [ %i2 + 4 ], %g1 <== NOT EXECUTED
2020e70: d0 06 a0 08 ld [ %i2 + 8 ], %o0 <== NOT EXECUTED
2020e74: 9f c0 40 00 call %g1 <== NOT EXECUTED
2020e78: d2 26 a0 0c st %o1, [ %i2 + 0xc ] <== NOT EXECUTED
case RTEMS_BLKIO_REQUEST:
switch (r->req)
{
case RTEMS_BLKDEV_REQ_READ:
errno = rtems_nvdisk_read (&rtems_nvdisks[minor], r);
break;
2020e7c: 10 80 00 87 b 2021098 <rtems_nvdisk_ioctl+0x4bc> <== NOT EXECUTED
2020e80: fa 24 c0 00 st %i5, [ %l3 ] <== NOT EXECUTED
case RTEMS_BLKDEV_REQ_WRITE:
errno = rtems_nvdisk_write (&rtems_nvdisks[minor], r);
2020e84: 40 00 84 da call 20421ec <__errno> <== NOT EXECUTED
2020e88: b2 06 a0 18 add %i2, 0x18, %i1 <== NOT EXECUTED
2020e8c: fa 07 63 dc ld [ %i5 + 0x3dc ], %i5 <== NOT EXECUTED
2020e90: a8 10 00 08 mov %o0, %l4 <== NOT EXECUTED
2020e94: ba 07 40 1b add %i5, %i3, %i5 <== NOT EXECUTED
#if RTEMS_NVDISK_TRACE
rtems_nvdisk_info (nvd, "write: blocks=%d", req->bufnum);
#endif
for (bufs = 0; (ret == 0) && (bufs < req->bufnum); bufs++, sg++)
2020e98: a4 10 20 00 clr %l2 <== NOT EXECUTED
{
uint16_t cs = 0xffff;
uint32_t i;
for (i = 0; i < page_size; i++, buffer++)
cs = rtems_nvdisk_calc_crc16 (cs, *buffer);
2020e9c: 10 80 00 42 b 2020fa4 <rtems_nvdisk_ioctl+0x3c8> <== NOT EXECUTED
2020ea0: 2b 00 81 bb sethi %hi(0x206ec00), %l5 <== NOT EXECUTED
for (bufs = 0; (ret == 0) && (bufs < req->bufnum); bufs++, sg++)
{
uint8_t* data;
uint32_t nvb;
uint32_t b;
nvb = sg->length / nvd->block_size;
2020ea4: d2 07 60 0c ld [ %i5 + 0xc ], %o1 <== NOT EXECUTED
2020ea8: 40 00 e9 b6 call 205b580 <.udiv> <== NOT EXECUTED
2020eac: a0 10 20 00 clr %l0 <== NOT EXECUTED
data = sg->buffer;
2020eb0: e2 06 60 08 ld [ %i1 + 8 ], %l1 <== NOT EXECUTED
for (bufs = 0; (ret == 0) && (bufs < req->bufnum); bufs++, sg++)
{
uint8_t* data;
uint32_t nvb;
uint32_t b;
nvb = sg->length / nvd->block_size;
2020eb4: 10 80 00 34 b 2020f84 <rtems_nvdisk_ioctl+0x3a8> <== NOT EXECUTED
2020eb8: ac 10 00 08 mov %o0, %l6 <== NOT EXECUTED
rtems_nvdisk_device_ctl* dc;
uint32_t page;
uint16_t cs;
int ret;
dc = rtems_nvdisk_get_device (nvd, block);
2020ebc: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
uint32_t b;
nvb = sg->length / nvd->block_size;
data = sg->buffer;
for (b = 0; b < nvb; b++, data += nvd->block_size)
{
ret = rtems_nvdisk_write_block (nvd, sg->block + b, data);
2020ec0: ae 04 00 17 add %l0, %l7, %l7 <== NOT EXECUTED
rtems_nvdisk_device_ctl* dc;
uint32_t page;
uint16_t cs;
int ret;
dc = rtems_nvdisk_get_device (nvd, block);
2020ec4: 7f ff ff 23 call 2020b50 <rtems_nvdisk_get_device> <== NOT EXECUTED
2020ec8: 92 10 00 17 mov %l7, %o1 <== NOT EXECUTED
if (!dc)
2020ecc: b0 92 20 00 orcc %o0, 0, %i0 <== NOT EXECUTED
2020ed0: 02 80 00 85 be 20210e4 <rtems_nvdisk_ioctl+0x508> <== NOT EXECUTED
2020ed4: c4 05 63 e4 ld [ %l5 + 0x3e4 ], %g2 <== NOT EXECUTED
*/
static uint32_t
rtems_nvdisk_get_page (rtems_nvdisk_device_ctl* dc,
uint32_t block)
{
return block - dc->block_base;
2020ed8: c2 06 20 0c ld [ %i0 + 0xc ], %g1 <== NOT EXECUTED
2020edc: ae 25 c0 01 sub %l7, %g1, %l7 <== NOT EXECUTED
rtems_nvdisk_page_checksum (const uint8_t* buffer, uint32_t page_size)
{
uint16_t cs = 0xffff;
uint32_t i;
for (i = 0; i < page_size; i++, buffer++)
2020ee0: b8 10 20 00 clr %i4 <== NOT EXECUTED
if (!dc)
return EIO;
page = rtems_nvdisk_get_page (dc, block);
cs = rtems_nvdisk_page_checksum (buffer, nvd->block_size);
2020ee4: c2 07 60 0c ld [ %i5 + 0xc ], %g1 <== NOT EXECUTED
* Calculate the checksum of a page.
*/
static uint16_t
rtems_nvdisk_page_checksum (const uint8_t* buffer, uint32_t page_size)
{
uint16_t cs = 0xffff;
2020ee8: 10 80 00 07 b 2020f04 <rtems_nvdisk_ioctl+0x328> <== NOT EXECUTED
2020eec: a6 10 3f ff mov -1, %l3 <== NOT EXECUTED
uint32_t i;
for (i = 0; i < page_size; i++, buffer++)
cs = rtems_nvdisk_calc_crc16 (cs, *buffer);
2020ef0: a6 0c e0 ff and %l3, 0xff, %l3 <== NOT EXECUTED
2020ef4: a6 1c c0 03 xor %l3, %g3, %l3 <== NOT EXECUTED
2020ef8: a7 2c e0 01 sll %l3, 1, %l3 <== NOT EXECUTED
2020efc: e6 10 80 13 lduh [ %g2 + %l3 ], %l3 <== NOT EXECUTED
rtems_nvdisk_page_checksum (const uint8_t* buffer, uint32_t page_size)
{
uint16_t cs = 0xffff;
uint32_t i;
for (i = 0; i < page_size; i++, buffer++)
2020f00: b8 07 20 01 inc %i4 <== NOT EXECUTED
2020f04: 80 a7 00 01 cmp %i4, %g1 <== NOT EXECUTED
2020f08: 32 bf ff fa bne,a 2020ef0 <rtems_nvdisk_ioctl+0x314> <== NOT EXECUTED
2020f0c: c6 0c 40 1c ldub [ %l1 + %i4 ], %g3 <== NOT EXECUTED
rtems_nvdisk_write_page (const rtems_nvdisk* nvd,
uint32_t device,
uint32_t page,
const void* buffer)
{
return rtems_nvdisk_device_write (nvd, device,
2020f10: c2 06 00 00 ld [ %i0 ], %g1 <== NOT EXECUTED
#if RTEMS_NVDISK_TRACE
rtems_nvdisk_info (nvd, " write-block:%d=>%02d-%03d", block, dc->device, page);
#endif
ret = rtems_nvdisk_write_page (nvd, dc->device, page + dc->pages_desc, buffer);
2020f14: d0 06 20 08 ld [ %i0 + 8 ], %o0 <== NOT EXECUTED
rtems_nvdisk_write_page (const rtems_nvdisk* nvd,
uint32_t device,
uint32_t page,
const void* buffer)
{
return rtems_nvdisk_device_write (nvd, device,
2020f18: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
2020f1c: c2 27 bf f4 st %g1, [ %fp + -12 ] <== NOT EXECUTED
2020f20: 7f ff 87 d1 call 2002e64 <.umul> <== NOT EXECUTED
2020f24: 90 05 c0 08 add %l7, %o0, %o0 <== NOT EXECUTED
2020f28: c2 07 bf f4 ld [ %fp + -12 ], %g1 <== NOT EXECUTED
2020f2c: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
2020f30: 92 10 00 01 mov %g1, %o1 <== NOT EXECUTED
2020f34: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
2020f38: 96 10 00 11 mov %l1, %o3 <== NOT EXECUTED
2020f3c: 7f ff fe d6 call 2020a94 <rtems_nvdisk_device_write> <== NOT EXECUTED
2020f40: 98 10 00 1c mov %i4, %o4 <== NOT EXECUTED
rtems_nvdisk_info (nvd, " write-block:%d=>%02d-%03d", block, dc->device, page);
#endif
ret = rtems_nvdisk_write_page (nvd, dc->device, page + dc->pages_desc, buffer);
if (ret)
2020f44: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2020f48: 32 80 00 15 bne,a 2020f9c <rtems_nvdisk_ioctl+0x3c0> <== NOT EXECUTED
2020f4c: a4 04 a0 01 inc %l2 <== NOT EXECUTED
return ret;
return rtems_nvdisk_write_checksum (nvd, dc->device, page, cs);
2020f50: d2 06 00 00 ld [ %i0 ], %o1 <== NOT EXECUTED
rtems_nvdisk_write_checksum (const rtems_nvdisk* nvd,
uint32_t device,
uint32_t page,
const uint16_t cs)
{
return rtems_nvdisk_device_write (nvd, device,
2020f54: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
2020f58: e6 37 bf fc sth %l3, [ %fp + -4 ] <== NOT EXECUTED
2020f5c: 95 2d e0 01 sll %l7, 1, %o2 <== NOT EXECUTED
2020f60: 96 07 bf fc add %fp, -4, %o3 <== NOT EXECUTED
2020f64: 7f ff fe cc call 2020a94 <rtems_nvdisk_device_write> <== NOT EXECUTED
2020f68: 98 10 20 02 mov 2, %o4 <== NOT EXECUTED
nvb = sg->length / nvd->block_size;
data = sg->buffer;
for (b = 0; b < nvb; b++, data += nvd->block_size)
{
ret = rtems_nvdisk_write_block (nvd, sg->block + b, data);
if (ret)
2020f6c: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2020f70: 32 80 00 0b bne,a 2020f9c <rtems_nvdisk_ioctl+0x3c0> <== NOT EXECUTED
2020f74: a4 04 a0 01 inc %l2 <== NOT EXECUTED
uint8_t* data;
uint32_t nvb;
uint32_t b;
nvb = sg->length / nvd->block_size;
data = sg->buffer;
for (b = 0; b < nvb; b++, data += nvd->block_size)
2020f78: c2 07 60 0c ld [ %i5 + 0xc ], %g1 <== NOT EXECUTED
2020f7c: a0 04 20 01 inc %l0 <== NOT EXECUTED
2020f80: a2 04 40 01 add %l1, %g1, %l1 <== NOT EXECUTED
2020f84: 80 a4 00 16 cmp %l0, %l6 <== NOT EXECUTED
2020f88: 32 bf ff cd bne,a 2020ebc <rtems_nvdisk_ioctl+0x2e0> <== NOT EXECUTED
2020f8c: ee 06 40 00 ld [ %i1 ], %l7 <== NOT EXECUTED
2020f90: 90 10 20 00 clr %o0 <== NOT EXECUTED
#if RTEMS_NVDISK_TRACE
rtems_nvdisk_info (nvd, "write: blocks=%d", req->bufnum);
#endif
for (bufs = 0; (ret == 0) && (bufs < req->bufnum); bufs++, sg++)
2020f94: a4 04 a0 01 inc %l2 <== NOT EXECUTED
2020f98: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2020f9c: 12 80 00 08 bne 2020fbc <rtems_nvdisk_ioctl+0x3e0> <== NOT EXECUTED
2020fa0: b2 06 60 10 add %i1, 0x10, %i1 <== NOT EXECUTED
2020fa4: c2 06 a0 10 ld [ %i2 + 0x10 ], %g1 <== NOT EXECUTED
2020fa8: 80 a4 80 01 cmp %l2, %g1 <== NOT EXECUTED
2020fac: 2a bf ff be bcs,a 2020ea4 <rtems_nvdisk_ioctl+0x2c8> <== NOT EXECUTED
2020fb0: d0 06 60 04 ld [ %i1 + 4 ], %o0 <== NOT EXECUTED
if (ret)
break;
}
}
req->status = ret ? RTEMS_IO_ERROR : RTEMS_SUCCESSFUL;
2020fb4: 10 80 00 03 b 2020fc0 <rtems_nvdisk_ioctl+0x3e4> <== NOT EXECUTED
2020fb8: 92 10 20 00 clr %o1 <== NOT EXECUTED
2020fbc: 92 10 20 1b mov 0x1b, %o1 <== NOT EXECUTED
req->req_done (req->done_arg, req->status);
2020fc0: c2 06 a0 04 ld [ %i2 + 4 ], %g1 <== NOT EXECUTED
2020fc4: d0 06 a0 08 ld [ %i2 + 8 ], %o0 <== NOT EXECUTED
2020fc8: 9f c0 40 00 call %g1 <== NOT EXECUTED
2020fcc: d2 26 a0 0c st %o1, [ %i2 + 0xc ] <== NOT EXECUTED
errno = rtems_nvdisk_read (&rtems_nvdisks[minor], r);
break;
case RTEMS_BLKDEV_REQ_WRITE:
errno = rtems_nvdisk_write (&rtems_nvdisks[minor], r);
break;
2020fd0: 10 80 00 32 b 2021098 <rtems_nvdisk_ioctl+0x4bc> <== NOT EXECUTED
2020fd4: c0 25 00 00 clr [ %l4 ] <== NOT EXECUTED
default:
errno = EINVAL;
2020fd8: 40 00 84 85 call 20421ec <__errno> <== NOT EXECUTED
2020fdc: 01 00 00 00 nop <== NOT EXECUTED
2020fe0: 82 10 20 16 mov 0x16, %g1 ! 16 <PROM_START+0x16> <== NOT EXECUTED
break;
2020fe4: 10 80 00 2d b 2021098 <rtems_nvdisk_ioctl+0x4bc> <== NOT EXECUTED
2020fe8: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
}
break;
case RTEMS_NVDISK_IOCTL_ERASE_DISK:
errno = rtems_nvdisk_erase_disk (&rtems_nvdisks[minor]);
2020fec: 40 00 84 80 call 20421ec <__errno> <== NOT EXECUTED
2020ff0: b2 10 20 00 clr %i1 <== NOT EXECUTED
2020ff4: f4 07 63 dc ld [ %i5 + 0x3dc ], %i2 <== NOT EXECUTED
2020ff8: a0 10 00 08 mov %o0, %l0 <== NOT EXECUTED
2020ffc: b4 06 80 1b add %i2, %i3, %i2 <== NOT EXECUTED
#if RTEMS_NVDISK_TRACE
rtems_nvdisk_info (nvd, "erase-disk");
#endif
for (device = 0; device < nvd->device_count; device++)
2021000: b8 10 20 00 clr %i4 <== NOT EXECUTED
2021004: 10 80 00 17 b 2021060 <rtems_nvdisk_ioctl+0x484> <== NOT EXECUTED
2021008: a2 10 3f ff mov -1, %l1 <== NOT EXECUTED
{
rtems_nvdisk_device_ctl* dc = &nvd->devices[device];
uint32_t page;
for (page = 0; page < (dc->pages - dc->pages_desc); page++)
202100c: ba 10 20 00 clr %i5 <== NOT EXECUTED
rtems_nvdisk_info (nvd, "erase-disk");
#endif
for (device = 0; device < nvd->device_count; device++)
{
rtems_nvdisk_device_ctl* dc = &nvd->devices[device];
2021010: 10 80 00 0c b 2021040 <rtems_nvdisk_ioctl+0x464> <== NOT EXECUTED
2021014: b0 06 00 19 add %i0, %i1, %i0 <== NOT EXECUTED
rtems_nvdisk_write_checksum (const rtems_nvdisk* nvd,
uint32_t device,
uint32_t page,
const uint16_t cs)
{
return rtems_nvdisk_device_write (nvd, device,
2021018: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
202101c: e2 37 bf fe sth %l1, [ %fp + -2 ] <== NOT EXECUTED
2021020: 95 2f 60 01 sll %i5, 1, %o2 <== NOT EXECUTED
2021024: 96 07 bf fe add %fp, -2, %o3 <== NOT EXECUTED
2021028: 7f ff fe 9b call 2020a94 <rtems_nvdisk_device_write> <== NOT EXECUTED
202102c: 98 10 20 02 mov 2, %o4 <== NOT EXECUTED
rtems_nvdisk_device_ctl* dc = &nvd->devices[device];
uint32_t page;
for (page = 0; page < (dc->pages - dc->pages_desc); page++)
{
int ret = rtems_nvdisk_write_checksum (nvd, dc->device, page, 0xffff);
if (ret)
2021030: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2021034: 32 80 00 19 bne,a 2021098 <rtems_nvdisk_ioctl+0x4bc> <== NOT EXECUTED
2021038: d0 24 00 00 st %o0, [ %l0 ] <== NOT EXECUTED
for (device = 0; device < nvd->device_count; device++)
{
rtems_nvdisk_device_ctl* dc = &nvd->devices[device];
uint32_t page;
for (page = 0; page < (dc->pages - dc->pages_desc); page++)
202103c: ba 07 60 01 inc %i5 <== NOT EXECUTED
2021040: c4 06 20 04 ld [ %i0 + 4 ], %g2 <== NOT EXECUTED
2021044: c2 06 20 08 ld [ %i0 + 8 ], %g1 <== NOT EXECUTED
2021048: 82 20 80 01 sub %g2, %g1, %g1 <== NOT EXECUTED
202104c: 80 a7 40 01 cmp %i5, %g1 <== NOT EXECUTED
2021050: 2a bf ff f2 bcs,a 2021018 <rtems_nvdisk_ioctl+0x43c> <== NOT EXECUTED
2021054: d2 06 00 00 ld [ %i0 ], %o1 <== NOT EXECUTED
#if RTEMS_NVDISK_TRACE
rtems_nvdisk_info (nvd, "erase-disk");
#endif
for (device = 0; device < nvd->device_count; device++)
2021058: b8 07 20 01 inc %i4 <== NOT EXECUTED
202105c: b2 06 60 14 add %i1, 0x14, %i1 <== NOT EXECUTED
2021060: c2 06 a0 18 ld [ %i2 + 0x18 ], %g1 <== NOT EXECUTED
2021064: 80 a7 00 01 cmp %i4, %g1 <== NOT EXECUTED
2021068: 2a bf ff e9 bcs,a 202100c <rtems_nvdisk_ioctl+0x430> <== NOT EXECUTED
202106c: f0 06 a0 14 ld [ %i2 + 0x14 ], %i0 <== NOT EXECUTED
if (ret)
return ret;
}
}
return 0;
2021070: 90 10 20 00 clr %o0 <== NOT EXECUTED
}
break;
case RTEMS_NVDISK_IOCTL_ERASE_DISK:
errno = rtems_nvdisk_erase_disk (&rtems_nvdisks[minor]);
break;
2021074: 10 80 00 09 b 2021098 <rtems_nvdisk_ioctl+0x4bc> <== NOT EXECUTED
2021078: d0 24 00 00 st %o0, [ %l0 ] <== NOT EXECUTED
case RTEMS_NVDISK_IOCTL_INFO_LEVEL:
rtems_nvdisks[minor].info_level = (uintptr_t) argp;
202107c: c2 07 63 dc ld [ %i5 + 0x3dc ], %g1 <== NOT EXECUTED
2021080: 82 00 40 1b add %g1, %i3, %g1 <== NOT EXECUTED
break;
2021084: 10 80 00 05 b 2021098 <rtems_nvdisk_ioctl+0x4bc> <== NOT EXECUTED
2021088: f4 20 60 24 st %i2, [ %g1 + 0x24 ] <== NOT EXECUTED
default:
rtems_blkdev_ioctl (dd, req, argp);
202108c: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
2021090: 40 00 0f 3b call 2024d7c <rtems_blkdev_ioctl> <== NOT EXECUTED
2021094: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED
break;
}
sc = rtems_semaphore_release (rtems_nvdisks[minor].lock);
2021098: 03 00 81 bb sethi %hi(0x206ec00), %g1 <== NOT EXECUTED
202109c: c2 00 63 dc ld [ %g1 + 0x3dc ], %g1 ! 206efdc <rtems_nvdisks><== NOT EXECUTED
20210a0: b6 00 40 1b add %g1, %i3, %i3 <== NOT EXECUTED
20210a4: 7f ff b1 4e call 200d5dc <rtems_semaphore_release> <== NOT EXECUTED
20210a8: d0 06 e0 20 ld [ %i3 + 0x20 ], %o0 <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
20210ac: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
20210b0: 02 80 00 06 be 20210c8 <rtems_nvdisk_ioctl+0x4ec> <== NOT EXECUTED
20210b4: 01 00 00 00 nop <== NOT EXECUTED
errno = EIO;
20210b8: 40 00 84 4d call 20421ec <__errno> <== NOT EXECUTED
20210bc: 01 00 00 00 nop <== NOT EXECUTED
20210c0: 82 10 20 05 mov 5, %g1 ! 5 <PROM_START+0x5> <== NOT EXECUTED
20210c4: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
}
return errno == 0 ? 0 : -1;
20210c8: 40 00 84 49 call 20421ec <__errno> <== NOT EXECUTED
20210cc: 01 00 00 00 nop <== NOT EXECUTED
20210d0: c2 02 00 00 ld [ %o0 ], %g1 <== NOT EXECUTED
20210d4: 80 a0 00 01 cmp %g0, %g1 <== NOT EXECUTED
20210d8: b0 60 20 00 subx %g0, 0, %i0 <== NOT EXECUTED
20210dc: 81 c7 e0 08 ret <== NOT EXECUTED
20210e0: 81 e8 00 00 restore <== NOT EXECUTED
int ret;
dc = rtems_nvdisk_get_device (nvd, block);
if (!dc)
return EIO;
20210e4: 10 bf ff ac b 2020f94 <rtems_nvdisk_ioctl+0x3b8> <== NOT EXECUTED
20210e8: 90 10 20 05 mov 5, %o0 <== NOT EXECUTED
020213ac <rtems_nvdisk_sram_read>:
uint32_t flags __attribute__((unused)),
void* base,
uint32_t offset,
void* buffer,
size_t size)
{
20213ac: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED
memcpy (buffer, (base + offset), size);
return 0;
}
20213b0: b0 10 20 00 clr %i0 <== NOT EXECUTED
void* base,
uint32_t offset,
void* buffer,
size_t size)
{
memcpy (buffer, (base + offset), size);
20213b4: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
20213b8: 92 06 80 1b add %i2, %i3, %o1 <== NOT EXECUTED
20213bc: 40 00 90 cb call 20456e8 <memcpy> <== NOT EXECUTED
20213c0: 94 10 00 1d mov %i5, %o2 <== NOT EXECUTED
return 0;
}
20213c4: 81 c7 e0 08 ret <== NOT EXECUTED
20213c8: 81 e8 00 00 restore <== NOT EXECUTED
02021364 <rtems_nvdisk_sram_verify>:
uint32_t flags __attribute__((unused)),
void* base,
uint32_t offset,
const void* buffer,
size_t size)
{
2021364: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED
return memcmp ((base + offset), buffer, size) == 0 ? 0 : EIO;
2021368: 90 06 80 1b add %i2, %i3, %o0 <== NOT EXECUTED
202136c: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
2021370: 40 00 90 b4 call 2045640 <memcmp> <== NOT EXECUTED
2021374: 94 10 00 1d mov %i5, %o2 <== NOT EXECUTED
2021378: 80 a0 00 08 cmp %g0, %o0 <== NOT EXECUTED
202137c: b0 60 20 00 subx %g0, 0, %i0 <== NOT EXECUTED
}
2021380: b0 0e 20 05 and %i0, 5, %i0 <== NOT EXECUTED
2021384: 81 c7 e0 08 ret <== NOT EXECUTED
2021388: 81 e8 00 00 restore <== NOT EXECUTED
0202138c <rtems_nvdisk_sram_write>:
uint32_t flags __attribute__((unused)),
void* base,
uint32_t offset,
const void* buffer,
size_t size)
{
202138c: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED
memcpy ((base + offset), buffer, size);
return 0;
}
2021390: b0 10 20 00 clr %i0 <== NOT EXECUTED
void* base,
uint32_t offset,
const void* buffer,
size_t size)
{
memcpy ((base + offset), buffer, size);
2021394: 90 06 80 1b add %i2, %i3, %o0 <== NOT EXECUTED
2021398: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
202139c: 40 00 90 d3 call 20456e8 <memcpy> <== NOT EXECUTED
20213a0: 94 10 00 1d mov %i5, %o2 <== NOT EXECUTED
return 0;
}
20213a4: 81 c7 e0 08 ret <== NOT EXECUTED
20213a8: 81 e8 00 00 restore <== NOT EXECUTED
02008dc4 <rtems_partition_create>:
uint32_t length,
uint32_t buffer_size,
rtems_attribute attribute_set,
rtems_id *id
)
{
2008dc4: 9d e3 bf a0 save %sp, -96, %sp
register Partition_Control *the_partition;
if ( !rtems_is_name_valid( name ) )
2008dc8: 80 a6 20 00 cmp %i0, 0
2008dcc: 02 80 00 39 be 2008eb0 <rtems_partition_create+0xec>
2008dd0: 82 10 20 03 mov 3, %g1
return RTEMS_INVALID_NAME;
if ( !starting_address )
2008dd4: 80 a6 60 00 cmp %i1, 0
2008dd8: 02 80 00 36 be 2008eb0 <rtems_partition_create+0xec>
2008ddc: 82 10 20 09 mov 9, %g1
return RTEMS_INVALID_ADDRESS;
if ( !id )
2008de0: 80 a7 60 00 cmp %i5, 0
2008de4: 02 80 00 33 be 2008eb0 <rtems_partition_create+0xec> <== NEVER TAKEN
2008de8: 80 a6 e0 00 cmp %i3, 0
return RTEMS_INVALID_ADDRESS;
if ( length == 0 || buffer_size == 0 || length < buffer_size ||
2008dec: 02 80 00 31 be 2008eb0 <rtems_partition_create+0xec>
2008df0: 82 10 20 08 mov 8, %g1
2008df4: 80 a6 a0 00 cmp %i2, 0
2008df8: 02 80 00 2e be 2008eb0 <rtems_partition_create+0xec>
2008dfc: 80 a6 80 1b cmp %i2, %i3
2008e00: 0a 80 00 2c bcs 2008eb0 <rtems_partition_create+0xec>
2008e04: 80 8e e0 07 btst 7, %i3
2008e08: 12 80 00 2a bne 2008eb0 <rtems_partition_create+0xec>
2008e0c: 80 8e 60 07 btst 7, %i1
!_Partition_Is_buffer_size_aligned( buffer_size ) )
return RTEMS_INVALID_SIZE;
if ( !_Addresses_Is_aligned( starting_address ) )
2008e10: 12 80 00 28 bne 2008eb0 <rtems_partition_create+0xec>
2008e14: 82 10 20 09 mov 9, %g1
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
_Thread_Dispatch_disable_level++;
2008e18: 03 00 80 89 sethi %hi(0x2022400), %g1
2008e1c: c4 00 61 f0 ld [ %g1 + 0x1f0 ], %g2 ! 20225f0 <_Thread_Dispatch_disable_level>
2008e20: 84 00 a0 01 inc %g2
2008e24: c4 20 61 f0 st %g2, [ %g1 + 0x1f0 ]
return _Thread_Dispatch_disable_level;
2008e28: c2 00 61 f0 ld [ %g1 + 0x1f0 ], %g1
* 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 );
2008e2c: 23 00 80 88 sethi %hi(0x2022000), %l1
2008e30: 40 00 06 ee call 200a9e8 <_Objects_Allocate>
2008e34: 90 14 63 e4 or %l1, 0x3e4, %o0 ! 20223e4 <_Partition_Information>
_Thread_Disable_dispatch(); /* prevents deletion */
the_partition = _Partition_Allocate();
if ( !the_partition ) {
2008e38: a0 92 20 00 orcc %o0, 0, %l0
2008e3c: 32 80 00 06 bne,a 2008e54 <rtems_partition_create+0x90>
2008e40: f8 24 20 1c st %i4, [ %l0 + 0x1c ]
_Thread_Enable_dispatch();
2008e44: 40 00 0c 0c call 200be74 <_Thread_Enable_dispatch>
2008e48: 01 00 00 00 nop
return RTEMS_TOO_MANY;
2008e4c: 10 80 00 19 b 2008eb0 <rtems_partition_create+0xec>
2008e50: 82 10 20 05 mov 5, %g1 ! 5 <PROM_START+0x5>
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,
length / buffer_size, buffer_size );
2008e54: 92 10 00 1b mov %i3, %o1
_Thread_Enable_dispatch();
return RTEMS_TOO_MANY;
}
#endif
the_partition->starting_address = starting_address;
2008e58: f2 24 20 10 st %i1, [ %l0 + 0x10 ]
the_partition->length = length;
2008e5c: f4 24 20 14 st %i2, [ %l0 + 0x14 ]
the_partition->buffer_size = buffer_size;
2008e60: f6 24 20 18 st %i3, [ %l0 + 0x18 ]
the_partition->attribute_set = attribute_set;
the_partition->number_of_used_blocks = 0;
2008e64: c0 24 20 20 clr [ %l0 + 0x20 ]
_Chain_Initialize( &the_partition->Memory, starting_address,
length / buffer_size, buffer_size );
2008e68: 40 00 46 76 call 201a840 <.udiv>
2008e6c: 90 10 00 1a mov %i2, %o0
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,
2008e70: 92 10 00 19 mov %i1, %o1
length / buffer_size, buffer_size );
2008e74: 94 10 00 08 mov %o0, %o2
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,
2008e78: 96 10 00 1b mov %i3, %o3
2008e7c: b8 04 20 24 add %l0, 0x24, %i4
2008e80: 40 00 04 58 call 2009fe0 <_Chain_Initialize>
2008e84: 90 10 00 1c mov %i4, %o0
Objects_Information *information,
Objects_Control *the_object,
Objects_Name name
)
{
_Objects_Set_local_object(
2008e88: c4 14 20 0a lduh [ %l0 + 0xa ], %g2
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
2008e8c: a2 14 63 e4 or %l1, 0x3e4, %l1
2008e90: c6 04 60 1c ld [ %l1 + 0x1c ], %g3
Objects_Information *information,
Objects_Control *the_object,
Objects_Name name
)
{
_Objects_Set_local_object(
2008e94: c2 04 20 08 ld [ %l0 + 8 ], %g1
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
2008e98: 85 28 a0 02 sll %g2, 2, %g2
2008e9c: e0 20 c0 02 st %l0, [ %g3 + %g2 ]
information,
_Objects_Get_index( the_object->id ),
the_object
);
the_object->name = name;
2008ea0: f0 24 20 0c st %i0, [ %l0 + 0xc ]
name,
0 /* Not used */
);
#endif
_Thread_Enable_dispatch();
2008ea4: 40 00 0b f4 call 200be74 <_Thread_Enable_dispatch>
2008ea8: c2 27 40 00 st %g1, [ %i5 ]
return RTEMS_SUCCESSFUL;
2008eac: 82 10 20 00 clr %g1
}
2008eb0: 81 c7 e0 08 ret
2008eb4: 91 e8 00 01 restore %g0, %g1, %o0
020164d0 <rtems_partition_return_buffer>:
rtems_status_code rtems_partition_return_buffer(
rtems_id id,
void *buffer
)
{
20164d0: 9d e3 bf 98 save %sp, -104, %sp
RTEMS_INLINE_ROUTINE Partition_Control *_Partition_Get (
Objects_Id id,
Objects_Locations *location
)
{
return (Partition_Control *)
20164d4: 11 00 80 f2 sethi %hi(0x203c800), %o0
20164d8: 92 10 00 18 mov %i0, %o1
20164dc: 90 12 23 64 or %o0, 0x364, %o0
20164e0: 40 00 14 15 call 201b534 <_Objects_Get>
20164e4: 94 07 bf fc add %fp, -4, %o2
register Partition_Control *the_partition;
Objects_Locations location;
the_partition = _Partition_Get( id, &location );
switch ( location ) {
20164e8: c2 07 bf fc ld [ %fp + -4 ], %g1
20164ec: 80 a0 60 00 cmp %g1, 0
20164f0: 12 80 00 21 bne 2016574 <rtems_partition_return_buffer+0xa4>
20164f4: ba 10 00 08 mov %o0, %i5
)
{
void *starting;
void *ending;
starting = the_partition->starting_address;
20164f8: d0 02 20 10 ld [ %o0 + 0x10 ], %o0
20164fc: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
2016500: 82 02 00 01 add %o0, %g1, %g1
ending = _Addresses_Add_offset( starting, the_partition->length );
return (
_Addresses_Is_in_range( the_buffer, starting, ending ) &&
2016504: 80 a6 40 01 cmp %i1, %g1
2016508: 18 80 00 0b bgu 2016534 <rtems_partition_return_buffer+0x64><== NEVER TAKEN
201650c: 82 10 20 00 clr %g1
2016510: 80 a6 40 08 cmp %i1, %o0
2016514: 0a 80 00 09 bcs 2016538 <rtems_partition_return_buffer+0x68>
2016518: 80 a0 60 00 cmp %g1, 0
offset = (uint32_t) _Addresses_Subtract(
the_buffer,
the_partition->starting_address
);
return ((offset % the_partition->buffer_size) == 0);
201651c: d2 07 60 18 ld [ %i5 + 0x18 ], %o1
2016520: 40 00 58 5d call 202c694 <.urem>
2016524: 90 26 40 08 sub %i1, %o0, %o0
starting = the_partition->starting_address;
ending = _Addresses_Add_offset( starting, the_partition->length );
return (
_Addresses_Is_in_range( the_buffer, starting, ending ) &&
2016528: 80 a0 00 08 cmp %g0, %o0
201652c: 10 80 00 02 b 2016534 <rtems_partition_return_buffer+0x64>
2016530: 82 60 3f ff subx %g0, -1, %g1
case OBJECTS_LOCAL:
if ( _Partition_Is_buffer_valid( buffer, the_partition ) ) {
2016534: 80 a0 60 00 cmp %g1, 0
2016538: 02 80 00 0b be 2016564 <rtems_partition_return_buffer+0x94>
201653c: 90 07 60 24 add %i5, 0x24, %o0
RTEMS_INLINE_ROUTINE void _Partition_Free_buffer (
Partition_Control *the_partition,
Chain_Node *the_buffer
)
{
_Chain_Append( &the_partition->Memory, the_buffer );
2016540: 40 00 0c 7c call 2019730 <_Chain_Append>
2016544: 92 10 00 19 mov %i1, %o1
_Partition_Free_buffer( the_partition, buffer );
the_partition->number_of_used_blocks -= 1;
2016548: c2 07 60 20 ld [ %i5 + 0x20 ], %g1
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
201654c: b0 10 20 00 clr %i0
switch ( location ) {
case OBJECTS_LOCAL:
if ( _Partition_Is_buffer_valid( buffer, the_partition ) ) {
_Partition_Free_buffer( the_partition, buffer );
the_partition->number_of_used_blocks -= 1;
2016550: 82 00 7f ff add %g1, -1, %g1
_Thread_Enable_dispatch();
2016554: 40 00 17 ce call 201c48c <_Thread_Enable_dispatch>
2016558: c2 27 60 20 st %g1, [ %i5 + 0x20 ]
201655c: 81 c7 e0 08 ret
2016560: 81 e8 00 00 restore
return RTEMS_SUCCESSFUL;
}
_Thread_Enable_dispatch();
2016564: 40 00 17 ca call 201c48c <_Thread_Enable_dispatch>
2016568: b0 10 20 09 mov 9, %i0
201656c: 81 c7 e0 08 ret
2016570: 81 e8 00 00 restore
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
2016574: 81 c7 e0 08 ret
2016578: 91 e8 20 04 restore %g0, 4, %o0
0203f268 <rtems_rate_monotonic_period>:
rtems_status_code rtems_rate_monotonic_period(
rtems_id id,
rtems_interval length
)
{
203f268: 9d e3 bf 98 save %sp, -104, %sp
203f26c: 11 00 81 c0 sethi %hi(0x2070000), %o0
203f270: 92 10 00 18 mov %i0, %o1
203f274: 90 12 23 20 or %o0, 0x320, %o0
203f278: 7f ff 3f f9 call 200f25c <_Objects_Get>
203f27c: 94 07 bf fc add %fp, -4, %o2
rtems_rate_monotonic_period_states local_state;
ISR_Level level;
the_period = _Rate_monotonic_Get( id, &location );
switch ( location ) {
203f280: c2 07 bf fc ld [ %fp + -4 ], %g1
203f284: 80 a0 60 00 cmp %g1, 0
203f288: 12 80 00 6a bne 203f430 <rtems_rate_monotonic_period+0x1c8>
203f28c: ba 10 00 08 mov %o0, %i5
203f290: 37 00 81 bf sethi %hi(0x206fc00), %i3
case OBJECTS_LOCAL:
if ( !_Thread_Is_executing( the_period->owner ) ) {
203f294: c4 02 20 40 ld [ %o0 + 0x40 ], %g2
203f298: b6 16 e0 b0 or %i3, 0xb0, %i3
203f29c: c2 06 e0 0c ld [ %i3 + 0xc ], %g1
203f2a0: 80 a0 80 01 cmp %g2, %g1
203f2a4: 02 80 00 06 be 203f2bc <rtems_rate_monotonic_period+0x54>
203f2a8: 80 a6 60 00 cmp %i1, 0
_Thread_Enable_dispatch();
203f2ac: 7f ff 43 a4 call 201013c <_Thread_Enable_dispatch>
203f2b0: b0 10 20 17 mov 0x17, %i0
203f2b4: 81 c7 e0 08 ret
203f2b8: 81 e8 00 00 restore
return RTEMS_NOT_OWNER_OF_RESOURCE;
}
if ( length == RTEMS_PERIOD_STATUS ) {
203f2bc: 12 80 00 0d bne 203f2f0 <rtems_rate_monotonic_period+0x88>
203f2c0: 01 00 00 00 nop
switch ( the_period->state ) {
203f2c4: c2 02 20 38 ld [ %o0 + 0x38 ], %g1
203f2c8: 80 a0 60 04 cmp %g1, 4
203f2cc: 18 80 00 05 bgu 203f2e0 <rtems_rate_monotonic_period+0x78><== NEVER TAKEN
203f2d0: b0 10 20 00 clr %i0
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
203f2d4: 05 00 81 a5 sethi %hi(0x2069400), %g2
203f2d8: 84 10 a2 a8 or %g2, 0x2a8, %g2 ! 20696a8 <CSWTCH.23>
203f2dc: f0 08 80 01 ldub [ %g2 + %g1 ], %i0
case RATE_MONOTONIC_ACTIVE:
default: /* unreached -- only to remove warnings */
return_value = RTEMS_SUCCESSFUL;
break;
}
_Thread_Enable_dispatch();
203f2e0: 7f ff 43 97 call 201013c <_Thread_Enable_dispatch>
203f2e4: 01 00 00 00 nop
203f2e8: 81 c7 e0 08 ret
203f2ec: 81 e8 00 00 restore
return( return_value );
}
_ISR_Disable( level );
203f2f0: 7f ff 13 50 call 2004030 <sparc_disable_interrupts>
203f2f4: 01 00 00 00 nop
203f2f8: b4 10 00 08 mov %o0, %i2
if ( the_period->state == RATE_MONOTONIC_INACTIVE ) {
203f2fc: f8 07 60 38 ld [ %i5 + 0x38 ], %i4
203f300: 80 a7 20 00 cmp %i4, 0
203f304: 12 80 00 15 bne 203f358 <rtems_rate_monotonic_period+0xf0>
203f308: 80 a7 20 02 cmp %i4, 2
_ISR_Enable( level );
203f30c: 7f ff 13 4d call 2004040 <sparc_enable_interrupts>
203f310: 01 00 00 00 nop
the_period->next_length = length;
/*
* Baseline statistics information for the beginning of a period.
*/
_Rate_monotonic_Initiate_statistics( the_period );
203f314: 90 10 00 1d mov %i5, %o0
203f318: 7f ff ff ba call 203f200 <_Rate_monotonic_Initiate_statistics>
203f31c: f2 27 60 3c st %i1, [ %i5 + 0x3c ]
the_period->state = RATE_MONOTONIC_ACTIVE;
203f320: 82 10 20 02 mov 2, %g1
203f324: c2 27 60 38 st %g1, [ %i5 + 0x38 ]
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
the_watchdog->routine = routine;
203f328: 03 00 80 fd sethi %hi(0x203f400), %g1
203f32c: 82 10 60 3c or %g1, 0x3c, %g1 ! 203f43c <_Rate_monotonic_Timeout>
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
203f330: c0 27 60 18 clr [ %i5 + 0x18 ]
the_watchdog->routine = routine;
203f334: c2 27 60 2c st %g1, [ %i5 + 0x2c ]
the_watchdog->id = id;
203f338: f0 27 60 30 st %i0, [ %i5 + 0x30 ]
the_watchdog->user_data = user_data;
203f33c: c0 27 60 34 clr [ %i5 + 0x34 ]
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
203f340: f2 27 60 1c st %i1, [ %i5 + 0x1c ]
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
203f344: 11 00 81 be sethi %hi(0x206f800), %o0
203f348: 92 07 60 10 add %i5, 0x10, %o1
203f34c: 7f ff 46 c7 call 2010e68 <_Watchdog_Insert>
203f350: 90 12 20 28 or %o0, 0x28, %o0
203f354: 30 80 00 1b b,a 203f3c0 <rtems_rate_monotonic_period+0x158>
_Watchdog_Insert_ticks( &the_period->Timer, length );
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
}
if ( the_period->state == RATE_MONOTONIC_ACTIVE ) {
203f358: 12 80 00 1e bne 203f3d0 <rtems_rate_monotonic_period+0x168>
203f35c: 80 a7 20 04 cmp %i4, 4
/*
* Update statistics from the concluding period.
*/
_Rate_monotonic_Update_statistics( the_period );
203f360: 7f ff ff 5f call 203f0dc <_Rate_monotonic_Update_statistics>
203f364: 90 10 00 1d mov %i5, %o0
/*
* 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;
203f368: 82 10 20 01 mov 1, %g1
the_period->next_length = length;
203f36c: f2 27 60 3c st %i1, [ %i5 + 0x3c ]
/*
* 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;
203f370: c2 27 60 38 st %g1, [ %i5 + 0x38 ]
the_period->next_length = length;
_ISR_Enable( level );
203f374: 7f ff 13 33 call 2004040 <sparc_enable_interrupts>
203f378: 90 10 00 1a mov %i2, %o0
_Thread_Executing->Wait.id = the_period->Object.id;
203f37c: d0 06 e0 0c ld [ %i3 + 0xc ], %o0
203f380: c2 07 60 08 ld [ %i5 + 8 ], %g1
_Thread_Set_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD );
203f384: 13 00 00 10 sethi %hi(0x4000), %o1
203f388: 7f ff 45 a4 call 2010a18 <_Thread_Set_state>
203f38c: c2 22 20 20 st %g1, [ %o0 + 0x20 ]
/*
* Did the watchdog timer expire while we were actually blocking
* on it?
*/
_ISR_Disable( level );
203f390: 7f ff 13 28 call 2004030 <sparc_disable_interrupts>
203f394: 01 00 00 00 nop
local_state = the_period->state;
203f398: f4 07 60 38 ld [ %i5 + 0x38 ], %i2
the_period->state = RATE_MONOTONIC_ACTIVE;
203f39c: f8 27 60 38 st %i4, [ %i5 + 0x38 ]
_ISR_Enable( level );
203f3a0: 7f ff 13 28 call 2004040 <sparc_enable_interrupts>
203f3a4: 01 00 00 00 nop
/*
* 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 )
203f3a8: 80 a6 a0 03 cmp %i2, 3
203f3ac: 12 80 00 05 bne 203f3c0 <rtems_rate_monotonic_period+0x158>
203f3b0: 01 00 00 00 nop
_Thread_Clear_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD );
203f3b4: d0 06 e0 0c ld [ %i3 + 0xc ], %o0
203f3b8: 7f ff 42 81 call 200fdbc <_Thread_Clear_state>
203f3bc: 13 00 00 10 sethi %hi(0x4000), %o1
_Thread_Enable_dispatch();
203f3c0: 7f ff 43 5f call 201013c <_Thread_Enable_dispatch>
203f3c4: b0 10 20 00 clr %i0
203f3c8: 81 c7 e0 08 ret
203f3cc: 81 e8 00 00 restore
return RTEMS_SUCCESSFUL;
}
if ( the_period->state == RATE_MONOTONIC_EXPIRED ) {
203f3d0: 12 bf ff b9 bne 203f2b4 <rtems_rate_monotonic_period+0x4c><== NEVER TAKEN
203f3d4: b0 10 20 04 mov 4, %i0
/*
* Update statistics from the concluding period
*/
_Rate_monotonic_Update_statistics( the_period );
203f3d8: 7f ff ff 41 call 203f0dc <_Rate_monotonic_Update_statistics>
203f3dc: 90 10 00 1d mov %i5, %o0
_ISR_Enable( level );
203f3e0: 7f ff 13 18 call 2004040 <sparc_enable_interrupts>
203f3e4: 90 10 00 1a mov %i2, %o0
the_period->state = RATE_MONOTONIC_ACTIVE;
203f3e8: 82 10 20 02 mov 2, %g1
203f3ec: 92 07 60 10 add %i5, 0x10, %o1
203f3f0: c2 27 60 38 st %g1, [ %i5 + 0x38 ]
the_period->next_length = length;
203f3f4: f2 27 60 3c st %i1, [ %i5 + 0x3c ]
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
203f3f8: f2 27 60 1c st %i1, [ %i5 + 0x1c ]
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
203f3fc: 11 00 81 be sethi %hi(0x206f800), %o0
203f400: 7f ff 46 9a call 2010e68 <_Watchdog_Insert>
203f404: 90 12 20 28 or %o0, 0x28, %o0 ! 206f828 <_Watchdog_Ticks_chain>
203f408: d0 07 60 40 ld [ %i5 + 0x40 ], %o0
203f40c: d2 07 60 3c ld [ %i5 + 0x3c ], %o1
203f410: 03 00 81 ad sethi %hi(0x206b400), %g1
203f414: c2 00 60 3c ld [ %g1 + 0x3c ], %g1 ! 206b43c <_Scheduler+0x34>
203f418: 9f c0 40 00 call %g1
203f41c: b0 10 20 06 mov 6, %i0
_Watchdog_Insert_ticks( &the_period->Timer, length );
_Scheduler_Release_job(the_period->owner, the_period->next_length);
_Thread_Enable_dispatch();
203f420: 7f ff 43 47 call 201013c <_Thread_Enable_dispatch>
203f424: 01 00 00 00 nop
203f428: 81 c7 e0 08 ret
203f42c: 81 e8 00 00 restore
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
203f430: b0 10 20 04 mov 4, %i0
}
203f434: 81 c7 e0 08 ret
203f438: 81 e8 00 00 restore
0202a9c0 <rtems_rate_monotonic_report_statistics_with_plugin>:
*/
void rtems_rate_monotonic_report_statistics_with_plugin(
void *context,
rtems_printk_plugin_t print
)
{
202a9c0: 9d e3 bf 38 save %sp, -200, %sp
rtems_id id;
rtems_rate_monotonic_period_statistics the_stats;
rtems_rate_monotonic_period_status the_status;
char name[5];
if ( !print )
202a9c4: 80 a6 60 00 cmp %i1, 0
202a9c8: 02 80 00 75 be 202ab9c <rtems_rate_monotonic_report_statistics_with_plugin+0x1dc><== NEVER TAKEN
202a9cc: 90 10 00 18 mov %i0, %o0
return;
(*print)( context, "Period information by period\n" );
202a9d0: 13 00 81 91 sethi %hi(0x2064400), %o1
202a9d4: 9f c6 40 00 call %i1
202a9d8: 92 12 62 60 or %o1, 0x260, %o1 ! 2064660 <_TOD_Days_per_month+0x68>
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
(*print)( context, "--- CPU times are in seconds ---\n" );
202a9dc: 90 10 00 18 mov %i0, %o0
202a9e0: 13 00 81 91 sethi %hi(0x2064400), %o1
202a9e4: 9f c6 40 00 call %i1
202a9e8: 92 12 62 80 or %o1, 0x280, %o1 ! 2064680 <_TOD_Days_per_month+0x88>
(*print)( context, "--- Wall times are in seconds ---\n" );
202a9ec: 90 10 00 18 mov %i0, %o0
202a9f0: 13 00 81 91 sethi %hi(0x2064400), %o1
202a9f4: 9f c6 40 00 call %i1
202a9f8: 92 12 62 a8 or %o1, 0x2a8, %o1 ! 20646a8 <_TOD_Days_per_month+0xb0>
Be sure to test the various cases.
(*print)( context,"\
1234567890123456789012345678901234567890123456789012345678901234567890123456789\
\n");
*/
(*print)( context, " ID OWNER COUNT MISSED "
202a9fc: 90 10 00 18 mov %i0, %o0
202aa00: 13 00 81 91 sethi %hi(0x2064400), %o1
202aa04: 9f c6 40 00 call %i1
202aa08: 92 12 62 d0 or %o1, 0x2d0, %o1 ! 20646d0 <_TOD_Days_per_month+0xd8>
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
" "
#endif
" WALL TIME\n"
);
(*print)( context, " "
202aa0c: 90 10 00 18 mov %i0, %o0
202aa10: 13 00 81 91 sethi %hi(0x2064400), %o1
202aa14: 9f c6 40 00 call %i1
202aa18: 92 12 63 20 or %o1, 0x320, %o1 ! 2064720 <_TOD_Days_per_month+0x128>
/*
* 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 ;
202aa1c: 03 00 81 c0 sethi %hi(0x2070000), %g1
rtems_object_get_name( the_status.owner, sizeof(name), name );
/*
* Print part of report line that is not dependent on granularity
*/
(*print)( context,
202aa20: 39 00 81 91 sethi %hi(0x2064400), %i4
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,
202aa24: 37 00 81 91 sethi %hi(0x2064400), %i3
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,
202aa28: 35 00 81 91 sethi %hi(0x2064400), %i2
/*
* If the count is zero, don't print statistics
*/
if (the_stats.count == 0) {
(*print)( context, "\n" );
202aa2c: 21 00 81 97 sethi %hi(0x2065c00), %l0
/*
* 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 ;
202aa30: fa 00 63 28 ld [ %g1 + 0x328 ], %i5
rtems_object_get_name( the_status.owner, sizeof(name), name );
/*
* Print part of report line that is not dependent on granularity
*/
(*print)( context,
202aa34: b8 17 23 70 or %i4, 0x370, %i4
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,
202aa38: b6 16 e3 88 or %i3, 0x388, %i3
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,
202aa3c: b4 16 a3 a8 or %i2, 0x3a8, %i2
/*
* 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 ;
202aa40: 10 80 00 52 b 202ab88 <rtems_rate_monotonic_report_statistics_with_plugin+0x1c8>
202aa44: a0 14 20 40 or %l0, 0x40, %l0
id <= _Rate_monotonic_Information.maximum_id ;
id++ ) {
status = rtems_rate_monotonic_get_statistics( id, &the_stats );
202aa48: 40 00 50 c9 call 203ed6c <rtems_rate_monotonic_get_statistics>
202aa4c: 92 07 bf c8 add %fp, -56, %o1
if ( status != RTEMS_SUCCESSFUL )
202aa50: 80 a2 20 00 cmp %o0, 0
202aa54: 32 80 00 4d bne,a 202ab88 <rtems_rate_monotonic_report_statistics_with_plugin+0x1c8>
202aa58: ba 07 60 01 inc %i5
#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 );
202aa5c: 92 07 bf b0 add %fp, -80, %o1
202aa60: 40 00 51 34 call 203ef30 <rtems_rate_monotonic_get_status>
202aa64: 90 10 00 1d mov %i5, %o0
#endif
rtems_object_get_name( the_status.owner, sizeof(name), name );
202aa68: d0 07 bf b0 ld [ %fp + -80 ], %o0
202aa6c: 92 10 20 05 mov 5, %o1
202aa70: 7f ff 89 d6 call 200d1c8 <rtems_object_get_name>
202aa74: 94 07 bf a0 add %fp, -96, %o2
/*
* Print part of report line that is not dependent on granularity
*/
(*print)( context,
202aa78: d8 1f bf c8 ldd [ %fp + -56 ], %o4
202aa7c: 92 10 00 1c mov %i4, %o1
202aa80: 90 10 00 18 mov %i0, %o0
202aa84: 94 10 00 1d mov %i5, %o2
202aa88: 9f c6 40 00 call %i1
202aa8c: 96 07 bf a0 add %fp, -96, %o3
);
/*
* If the count is zero, don't print statistics
*/
if (the_stats.count == 0) {
202aa90: d2 07 bf c8 ld [ %fp + -56 ], %o1
202aa94: 80 a2 60 00 cmp %o1, 0
202aa98: 12 80 00 07 bne 202aab4 <rtems_rate_monotonic_report_statistics_with_plugin+0xf4>
202aa9c: 94 07 bf a8 add %fp, -88, %o2
(*print)( context, "\n" );
202aaa0: 90 10 00 18 mov %i0, %o0
202aaa4: 9f c6 40 00 call %i1
202aaa8: 92 10 00 10 mov %l0, %o1
continue;
202aaac: 10 80 00 37 b 202ab88 <rtems_rate_monotonic_report_statistics_with_plugin+0x1c8>
202aab0: ba 07 60 01 inc %i5
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 );
202aab4: 40 00 05 0c call 202bee4 <_Timespec_Divide_by_integer>
202aab8: 90 07 bf e0 add %fp, -32, %o0
(*print)( context,
202aabc: d0 07 bf d4 ld [ %fp + -44 ], %o0
202aac0: 40 00 c2 b2 call 205b588 <.div>
202aac4: 92 10 23 e8 mov 0x3e8, %o1
202aac8: a6 10 00 08 mov %o0, %l3
202aacc: d0 07 bf dc ld [ %fp + -36 ], %o0
202aad0: 40 00 c2 ae call 205b588 <.div>
202aad4: 92 10 23 e8 mov 0x3e8, %o1
202aad8: c2 07 bf a8 ld [ %fp + -88 ], %g1
202aadc: a2 10 00 08 mov %o0, %l1
202aae0: d0 07 bf ac ld [ %fp + -84 ], %o0
202aae4: e8 07 bf d0 ld [ %fp + -48 ], %l4
202aae8: e4 07 bf d8 ld [ %fp + -40 ], %l2
202aaec: c2 23 a0 5c st %g1, [ %sp + 0x5c ]
202aaf0: 40 00 c2 a6 call 205b588 <.div>
202aaf4: 92 10 23 e8 mov 0x3e8, %o1
202aaf8: 96 10 00 13 mov %l3, %o3
202aafc: 98 10 00 12 mov %l2, %o4
202ab00: 9a 10 00 11 mov %l1, %o5
202ab04: 94 10 00 14 mov %l4, %o2
202ab08: d0 23 a0 60 st %o0, [ %sp + 0x60 ]
202ab0c: 92 10 00 1b mov %i3, %o1
202ab10: 9f c6 40 00 call %i1
202ab14: 90 10 00 18 mov %i0, %o0
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);
202ab18: d2 07 bf c8 ld [ %fp + -56 ], %o1
202ab1c: 94 07 bf a8 add %fp, -88, %o2
202ab20: 40 00 04 f1 call 202bee4 <_Timespec_Divide_by_integer>
202ab24: 90 07 bf f8 add %fp, -8, %o0
(*print)( context,
202ab28: d0 07 bf ec ld [ %fp + -20 ], %o0
202ab2c: 40 00 c2 97 call 205b588 <.div>
202ab30: 92 10 23 e8 mov 0x3e8, %o1
202ab34: a6 10 00 08 mov %o0, %l3
202ab38: d0 07 bf f4 ld [ %fp + -12 ], %o0
202ab3c: 40 00 c2 93 call 205b588 <.div>
202ab40: 92 10 23 e8 mov 0x3e8, %o1
202ab44: c2 07 bf a8 ld [ %fp + -88 ], %g1
202ab48: a2 10 00 08 mov %o0, %l1
202ab4c: d0 07 bf ac ld [ %fp + -84 ], %o0
202ab50: e8 07 bf e8 ld [ %fp + -24 ], %l4
202ab54: e4 07 bf f0 ld [ %fp + -16 ], %l2
202ab58: 92 10 23 e8 mov 0x3e8, %o1
202ab5c: 40 00 c2 8b call 205b588 <.div>
202ab60: c2 23 a0 5c st %g1, [ %sp + 0x5c ]
202ab64: 92 10 00 1a mov %i2, %o1
202ab68: d0 23 a0 60 st %o0, [ %sp + 0x60 ]
202ab6c: 94 10 00 14 mov %l4, %o2
202ab70: 90 10 00 18 mov %i0, %o0
202ab74: 96 10 00 13 mov %l3, %o3
202ab78: 98 10 00 12 mov %l2, %o4
202ab7c: 9f c6 40 00 call %i1
202ab80: 9a 10 00 11 mov %l1, %o5
* 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++ ) {
202ab84: ba 07 60 01 inc %i5
/*
* 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 ;
202ab88: 03 00 81 c0 sethi %hi(0x2070000), %g1
/*
* 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 ;
202ab8c: c2 00 63 2c ld [ %g1 + 0x32c ], %g1 ! 207032c <_Rate_monotonic_Information+0xc>
202ab90: 80 a7 40 01 cmp %i5, %g1
202ab94: 08 bf ff ad bleu 202aa48 <rtems_rate_monotonic_report_statistics_with_plugin+0x88>
202ab98: 90 10 00 1d mov %i5, %o0
202ab9c: 81 c7 e0 08 ret
202aba0: 81 e8 00 00 restore
02008a64 <rtems_rbheap_allocate>:
return big_enough;
}
void *rtems_rbheap_allocate(rtems_rbheap_control *control, size_t size)
{
2008a64: 9d e3 bf a0 save %sp, -96, %sp
void *ptr = NULL;
rtems_chain_control *free_chain = &control->free_chunk_chain;
rtems_rbtree_control *chunk_tree = &control->chunk_tree;
uintptr_t alignment = control->alignment;
2008a68: fa 06 20 30 ld [ %i0 + 0x30 ], %i5
#include <stdlib.h>
static uintptr_t align_up(uintptr_t alignment, uintptr_t value)
{
uintptr_t excess = value % alignment;
2008a6c: 90 10 00 19 mov %i1, %o0
2008a70: 92 10 00 1d mov %i5, %o1
2008a74: 40 00 44 f8 call 2019e54 <.urem>
2008a78: b6 10 00 19 mov %i1, %i3
if (excess > 0) {
2008a7c: 80 a2 20 00 cmp %o0, 0
2008a80: 02 80 00 05 be 2008a94 <rtems_rbheap_allocate+0x30> <== ALWAYS TAKEN
2008a84: 80 a6 c0 19 cmp %i3, %i1
value += alignment - excess;
2008a88: b6 06 40 1d add %i1, %i5, %i3 <== NOT EXECUTED
2008a8c: b6 26 c0 08 sub %i3, %o0, %i3 <== NOT EXECUTED
rtems_chain_control *free_chain = &control->free_chunk_chain;
rtems_rbtree_control *chunk_tree = &control->chunk_tree;
uintptr_t alignment = control->alignment;
uintptr_t aligned_size = align_up(alignment, size);
if (size > 0 && size <= aligned_size) {
2008a90: 80 a6 c0 19 cmp %i3, %i1 <== NOT EXECUTED
2008a94: 0a 80 00 04 bcs 2008aa4 <rtems_rbheap_allocate+0x40> <== NEVER TAKEN
2008a98: 80 a6 60 00 cmp %i1, 0
2008a9c: 32 80 00 04 bne,a 2008aac <rtems_rbheap_allocate+0x48>
2008aa0: c2 06 00 00 ld [ %i0 ], %g1
return big_enough;
}
void *rtems_rbheap_allocate(rtems_rbheap_control *control, size_t size)
{
void *ptr = NULL;
2008aa4: 81 c7 e0 08 ret
2008aa8: 91 e8 20 00 restore %g0, 0, %o0
rtems_chain_control *free_chain,
size_t size
)
{
rtems_chain_node *current = rtems_chain_first(free_chain);
const rtems_chain_node *tail = rtems_chain_tail(free_chain);
2008aac: 84 06 20 04 add %i0, 4, %g2
rtems_rbheap_chunk *big_enough = NULL;
2008ab0: 10 80 00 06 b 2008ac8 <rtems_rbheap_allocate+0x64>
2008ab4: ba 10 20 00 clr %i5
while (current != tail && big_enough == NULL) {
rtems_rbheap_chunk *free_chunk = (rtems_rbheap_chunk *) current;
if (free_chunk->size >= size) {
2008ab8: 80 a0 c0 1b cmp %g3, %i3
2008abc: ba 40 3f ff addx %g0, -1, %i5
2008ac0: ba 08 40 1d and %g1, %i5, %i5
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Next(
Chain_Node *the_node
)
{
return the_node->next;
2008ac4: c2 00 40 00 ld [ %g1 ], %g1
{
rtems_chain_node *current = rtems_chain_first(free_chain);
const rtems_chain_node *tail = rtems_chain_tail(free_chain);
rtems_rbheap_chunk *big_enough = NULL;
while (current != tail && big_enough == NULL) {
2008ac8: 80 a7 60 00 cmp %i5, 0
2008acc: 12 80 00 04 bne 2008adc <rtems_rbheap_allocate+0x78>
2008ad0: 80 a0 40 02 cmp %g1, %g2
2008ad4: 32 bf ff f9 bne,a 2008ab8 <rtems_rbheap_allocate+0x54>
2008ad8: c6 00 60 1c ld [ %g1 + 0x1c ], %g3
uintptr_t aligned_size = align_up(alignment, size);
if (size > 0 && size <= aligned_size) {
rtems_rbheap_chunk *free_chunk = search_free_chunk(free_chain, aligned_size);
if (free_chunk != NULL) {
2008adc: 80 a7 60 00 cmp %i5, 0
2008ae0: 02 bf ff f1 be 2008aa4 <rtems_rbheap_allocate+0x40>
2008ae4: 01 00 00 00 nop
uintptr_t free_size = free_chunk->size;
2008ae8: f4 07 60 1c ld [ %i5 + 0x1c ], %i2
if (free_size > aligned_size) {
2008aec: 80 a6 80 1b cmp %i2, %i3
2008af0: 28 80 00 14 bleu,a 2008b40 <rtems_rbheap_allocate+0xdc>
2008af4: c4 07 40 00 ld [ %i5 ], %g2
rtems_rbheap_chunk *new_chunk = get_chunk(control);
2008af8: 7f ff ff 80 call 20088f8 <get_chunk>
2008afc: 90 10 00 18 mov %i0, %o0
if (new_chunk != NULL) {
2008b00: b8 92 20 00 orcc %o0, 0, %i4
2008b04: 02 bf ff e8 be 2008aa4 <rtems_rbheap_allocate+0x40> <== NEVER TAKEN
2008b08: b4 26 80 1b sub %i2, %i3, %i2
uintptr_t new_free_size = free_size - aligned_size;
free_chunk->size = new_free_size;
new_chunk->begin = free_chunk->begin + new_free_size;
2008b0c: c2 07 60 18 ld [ %i5 + 0x18 ], %g1
rtems_rbheap_chunk *new_chunk = get_chunk(control);
if (new_chunk != NULL) {
uintptr_t new_free_size = free_size - aligned_size;
free_chunk->size = new_free_size;
2008b10: f4 27 60 1c st %i2, [ %i5 + 0x1c ]
new_chunk->begin = free_chunk->begin + new_free_size;
new_chunk->size = aligned_size;
2008b14: f6 27 20 1c st %i3, [ %i4 + 0x1c ]
if (new_chunk != NULL) {
uintptr_t new_free_size = free_size - aligned_size;
free_chunk->size = new_free_size;
new_chunk->begin = free_chunk->begin + new_free_size;
2008b18: b4 06 80 01 add %i2, %g1, %i2
*/
RTEMS_INLINE_ROUTINE void _Chain_Set_off_chain(
Chain_Node *node
)
{
node->next = node->previous = NULL;
2008b1c: c0 27 20 04 clr [ %i4 + 4 ]
2008b20: f4 27 20 18 st %i2, [ %i4 + 0x18 ]
2008b24: c0 27 00 00 clr [ %i4 ]
static void insert_into_tree(
rtems_rbtree_control *tree,
rtems_rbheap_chunk *chunk
)
{
_RBTree_Insert_unprotected(tree, &chunk->tree_node);
2008b28: 90 06 20 18 add %i0, 0x18, %o0
2008b2c: 40 00 06 a9 call 200a5d0 <_RBTree_Insert_unprotected>
2008b30: 92 07 20 08 add %i4, 8, %o1
free_chunk->size = new_free_size;
new_chunk->begin = free_chunk->begin + new_free_size;
new_chunk->size = aligned_size;
rtems_chain_set_off_chain(&new_chunk->chain_node);
insert_into_tree(chunk_tree, new_chunk);
ptr = (void *) new_chunk->begin;
2008b34: f0 07 20 18 ld [ %i4 + 0x18 ], %i0
2008b38: 81 c7 e0 08 ret
2008b3c: 81 e8 00 00 restore
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
previous = the_node->previous;
2008b40: c2 07 60 04 ld [ %i5 + 4 ], %g1
}
} else {
rtems_chain_extract_unprotected(&free_chunk->chain_node);
rtems_chain_set_off_chain(&free_chunk->chain_node);
ptr = (void *) free_chunk->begin;
2008b44: f0 07 60 18 ld [ %i5 + 0x18 ], %i0
next->previous = previous;
2008b48: c2 20 a0 04 st %g1, [ %g2 + 4 ]
previous->next = next;
2008b4c: c4 20 40 00 st %g2, [ %g1 ]
*/
RTEMS_INLINE_ROUTINE void _Chain_Set_off_chain(
Chain_Node *node
)
{
node->next = node->previous = NULL;
2008b50: c0 27 60 04 clr [ %i5 + 4 ]
2008b54: c0 27 40 00 clr [ %i5 ]
}
}
}
return ptr;
}
2008b58: 81 c7 e0 08 ret
2008b5c: 81 e8 00 00 restore
02008c90 <rtems_rbheap_extend_descriptors_with_malloc>:
/* Do nothing */
}
void rtems_rbheap_extend_descriptors_with_malloc(rtems_rbheap_control *control)
{
2008c90: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED
rtems_rbheap_chunk *chunk = malloc(sizeof(*chunk));
2008c94: 7f ff ed 8d call 20042c8 <malloc> <== NOT EXECUTED
2008c98: 90 10 20 20 mov 0x20, %o0 <== NOT EXECUTED
if (chunk != NULL) {
2008c9c: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2008ca0: 02 80 00 07 be 2008cbc <rtems_rbheap_extend_descriptors_with_malloc+0x2c><== NOT EXECUTED
2008ca4: 82 06 20 0c add %i0, 0xc, %g1 <== NOT EXECUTED
Chain_Node *the_node
)
{
Chain_Node *before_node;
the_node->previous = after_node;
2008ca8: c2 22 20 04 st %g1, [ %o0 + 4 ] <== NOT EXECUTED
before_node = after_node->next;
2008cac: c2 06 20 0c ld [ %i0 + 0xc ], %g1 <== NOT EXECUTED
after_node->next = the_node;
2008cb0: d0 26 20 0c st %o0, [ %i0 + 0xc ] <== NOT EXECUTED
the_node->next = before_node;
2008cb4: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
before_node->previous = the_node;
2008cb8: d0 20 60 04 st %o0, [ %g1 + 4 ] <== NOT EXECUTED
2008cbc: 81 c7 e0 08 ret <== NOT EXECUTED
2008cc0: 81 e8 00 00 restore <== NOT EXECUTED
02008b60 <rtems_rbheap_free>:
_RBTree_Extract_unprotected(chunk_tree, &b->tree_node);
}
}
rtems_status_code rtems_rbheap_free(rtems_rbheap_control *control, void *ptr)
{
2008b60: 9d e3 bf 80 save %sp, -128, %sp
2008b64: b6 10 00 18 mov %i0, %i3
rtems_status_code sc = RTEMS_SUCCESSFUL;
if (ptr != NULL) {
2008b68: 80 a6 60 00 cmp %i1, 0
2008b6c: 02 80 00 45 be 2008c80 <rtems_rbheap_free+0x120>
2008b70: b0 10 20 00 clr %i0
#define NULL_PAGE rtems_rbheap_chunk_of_node(NULL)
static rtems_rbheap_chunk *find(rtems_rbtree_control *chunk_tree, uintptr_t key)
{
rtems_rbheap_chunk chunk = { .begin = key };
2008b74: 90 07 bf e0 add %fp, -32, %o0
2008b78: 92 10 20 00 clr %o1
2008b7c: 94 10 20 20 mov 0x20, %o2
2008b80: 40 00 22 ed call 2011734 <memset>
2008b84: b4 06 e0 18 add %i3, 0x18, %i2
RBTree_Control *the_rbtree,
RBTree_Node *the_node
)
{
RBTree_Node* iter_node = the_rbtree->root;
RBTree_Node* found = NULL;
2008b88: ba 10 20 00 clr %i5
2008b8c: f2 27 bf f8 st %i1, [ %fp + -8 ]
RTEMS_INLINE_ROUTINE RBTree_Node *_RBTree_Find_unprotected(
RBTree_Control *the_rbtree,
RBTree_Node *the_node
)
{
RBTree_Node* iter_node = the_rbtree->root;
2008b90: 10 80 00 12 b 2008bd8 <rtems_rbheap_free+0x78>
2008b94: f8 06 e0 1c ld [ %i3 + 0x1c ], %i4
RBTree_Node* found = NULL;
int compare_result;
while (iter_node) {
compare_result = the_rbtree->compare_function(the_node, iter_node);
2008b98: 90 07 bf e8 add %fp, -24, %o0
2008b9c: 9f c0 40 00 call %g1
2008ba0: 92 10 00 1c mov %i4, %o1
if ( _RBTree_Is_equal( compare_result ) ) {
2008ba4: 80 a2 20 00 cmp %o0, 0
2008ba8: 12 80 00 07 bne 2008bc4 <rtems_rbheap_free+0x64>
2008bac: 83 3a 20 1f sra %o0, 0x1f, %g1
found = iter_node;
if ( the_rbtree->is_unique )
2008bb0: c2 0e a0 14 ldub [ %i2 + 0x14 ], %g1
2008bb4: 80 a0 60 00 cmp %g1, 0
2008bb8: 12 80 00 0c bne 2008be8 <rtems_rbheap_free+0x88> <== ALWAYS TAKEN
2008bbc: ba 10 00 1c mov %i4, %i5
RTEMS_INLINE_ROUTINE bool _RBTree_Is_greater(
int compare_result
)
{
return compare_result > 0;
2008bc0: 83 3a 20 1f sra %o0, 0x1f, %g1 <== NOT EXECUTED
2008bc4: 90 20 40 08 sub %g1, %o0, %o0
2008bc8: 91 32 20 1f srl %o0, 0x1f, %o0
break;
}
RBTree_Direction dir =
(RBTree_Direction) _RBTree_Is_greater( compare_result );
iter_node = iter_node->child[dir];
2008bcc: 91 2a 20 02 sll %o0, 2, %o0
2008bd0: b8 07 00 08 add %i4, %o0, %i4
2008bd4: f8 07 20 04 ld [ %i4 + 4 ], %i4
)
{
RBTree_Node* iter_node = the_rbtree->root;
RBTree_Node* found = NULL;
int compare_result;
while (iter_node) {
2008bd8: 80 a7 20 00 cmp %i4, 0
2008bdc: 32 bf ff ef bne,a 2008b98 <rtems_rbheap_free+0x38>
2008be0: c2 06 a0 10 ld [ %i2 + 0x10 ], %g1
2008be4: b8 10 00 1d mov %i5, %i4
return rtems_rbheap_chunk_of_node(
2008be8: ba 07 3f f8 add %i4, -8, %i5
if (ptr != NULL) {
rtems_chain_control *free_chain = &control->free_chunk_chain;
rtems_rbtree_control *chunk_tree = &control->chunk_tree;
rtems_rbheap_chunk *chunk = find(chunk_tree, (uintptr_t) ptr);
if (chunk != NULL_PAGE) {
2008bec: 80 a7 7f f8 cmp %i5, -8
2008bf0: 02 80 00 24 be 2008c80 <rtems_rbheap_free+0x120>
2008bf4: b0 10 20 04 mov 4, %i0
*/
RTEMS_INLINE_ROUTINE bool _Chain_Is_node_off_chain(
const Chain_Node *node
)
{
return (node->next == NULL) && (node->previous == NULL);
2008bf8: c4 07 3f f8 ld [ %i4 + -8 ], %g2
2008bfc: 80 a0 a0 00 cmp %g2, 0
2008c00: 12 80 00 05 bne 2008c14 <rtems_rbheap_free+0xb4>
2008c04: 82 10 20 00 clr %g1
2008c08: c2 07 60 04 ld [ %i5 + 4 ], %g1
2008c0c: 80 a0 00 01 cmp %g0, %g1
2008c10: 82 60 3f ff subx %g0, -1, %g1
if (!rtems_rbheap_is_chunk_free(chunk)) {
2008c14: 80 a0 60 00 cmp %g1, 0
2008c18: 02 80 00 1a be 2008c80 <rtems_rbheap_free+0x120>
2008c1c: b0 10 20 0e mov 0xe, %i0
static rtems_rbheap_chunk *get_next(
const rtems_rbheap_chunk *chunk,
RBTree_Direction dir
)
{
return rtems_rbheap_chunk_of_node(
2008c20: b8 07 60 08 add %i5, 8, %i4
2008c24: 92 10 20 00 clr %o1
2008c28: 40 00 07 0f call 200a864 <_RBTree_Next_unprotected>
2008c2c: 90 10 00 1c mov %i4, %o0
2008c30: 92 10 20 01 mov 1, %o1
2008c34: b2 10 00 08 mov %o0, %i1
2008c38: 40 00 07 0b call 200a864 <_RBTree_Next_unprotected>
2008c3c: 90 10 00 1c mov %i4, %o0
if (chunk != NULL_PAGE) {
if (!rtems_rbheap_is_chunk_free(chunk)) {
rtems_rbheap_chunk *pred = get_next(chunk, RBT_LEFT);
rtems_rbheap_chunk *succ = get_next(chunk, RBT_RIGHT);
check_and_merge(free_chain, chunk_tree, chunk, succ);
2008c40: 92 10 00 1a mov %i2, %o1
static rtems_rbheap_chunk *get_next(
const rtems_rbheap_chunk *chunk,
RBTree_Direction dir
)
{
return rtems_rbheap_chunk_of_node(
2008c44: 96 02 3f f8 add %o0, -8, %o3
if (chunk != NULL_PAGE) {
if (!rtems_rbheap_is_chunk_free(chunk)) {
rtems_rbheap_chunk *pred = get_next(chunk, RBT_LEFT);
rtems_rbheap_chunk *succ = get_next(chunk, RBT_RIGHT);
check_and_merge(free_chain, chunk_tree, chunk, succ);
2008c48: 94 10 00 1d mov %i5, %o2
2008c4c: 7f ff ff 02 call 2008854 <check_and_merge>
2008c50: 90 10 00 1b mov %i3, %o0
)
{
Chain_Node *before_node;
the_node->previous = after_node;
before_node = after_node->next;
2008c54: c2 06 c0 00 ld [ %i3 ], %g1
Chain_Node *the_node
)
{
Chain_Node *before_node;
the_node->previous = after_node;
2008c58: f6 27 60 04 st %i3, [ %i5 + 4 ]
before_node = after_node->next;
after_node->next = the_node;
2008c5c: fa 26 c0 00 st %i5, [ %i3 ]
the_node->next = before_node;
2008c60: c2 27 40 00 st %g1, [ %i5 ]
before_node->previous = the_node;
2008c64: fa 20 60 04 st %i5, [ %g1 + 4 ]
add_to_chain(free_chain, chunk);
check_and_merge(free_chain, chunk_tree, chunk, pred);
2008c68: 90 10 00 1b mov %i3, %o0
2008c6c: 92 10 00 1a mov %i2, %o1
2008c70: 94 10 00 1d mov %i5, %o2
2008c74: 96 06 7f f8 add %i1, -8, %o3
2008c78: 7f ff fe f7 call 2008854 <check_and_merge>
2008c7c: b0 10 20 00 clr %i0
sc = RTEMS_INVALID_ID;
}
}
return sc;
}
2008c80: 81 c7 e0 08 ret
2008c84: 81 e8 00 00 restore
0204195c <rtems_rfs_bitmap_create_search>:
int
rtems_rfs_bitmap_create_search (rtems_rfs_bitmap_control* control)
{
204195c: 9d e3 bf 98 save %sp, -104, %sp
rtems_rfs_bitmap_map map;
size_t size;
rtems_rfs_bitmap_bit bit;
int rc;
rc = rtems_rfs_bitmap_load_map (control, &map);
2041960: 90 10 00 18 mov %i0, %o0
return 0;
}
int
rtems_rfs_bitmap_create_search (rtems_rfs_bitmap_control* control)
{
2041964: b8 10 00 18 mov %i0, %i4
rtems_rfs_bitmap_map map;
size_t size;
rtems_rfs_bitmap_bit bit;
int rc;
rc = rtems_rfs_bitmap_load_map (control, &map);
2041968: 7f ff fe 49 call 204128c <rtems_rfs_bitmap_load_map>
204196c: 92 07 bf fc add %fp, -4, %o1
if (rc > 0)
2041970: b0 92 20 00 orcc %o0, 0, %i0
2041974: 14 80 00 32 bg 2041a3c <rtems_rfs_bitmap_create_search+0xe0><== NEVER TAKEN
2041978: 82 10 3f ff mov -1, %g1
return rc;
control->free = 0;
search_map = control->search_bits;
204197c: f6 07 20 14 ld [ %i4 + 0x14 ], %i3
rc = rtems_rfs_bitmap_load_map (control, &map);
if (rc > 0)
return rc;
control->free = 0;
2041980: c0 27 20 10 clr [ %i4 + 0x10 ]
search_map = control->search_bits;
size = control->size;
2041984: fa 07 20 0c ld [ %i4 + 0xc ], %i5
2041988: f2 07 bf fc ld [ %fp + -4 ], %i1
bit = 0;
*search_map = RTEMS_RFS_BITMAP_ELEMENT_CLEAR;
204198c: c2 26 c0 00 st %g1, [ %i3 ]
return rc;
control->free = 0;
search_map = control->search_bits;
size = control->size;
bit = 0;
2041990: b4 10 20 00 clr %i2
*search_map = RTEMS_RFS_BITMAP_ELEMENT_CLEAR;
while (size)
2041994: 10 80 00 26 b 2041a2c <rtems_rfs_bitmap_create_search+0xd0>
2041998: b0 10 20 01 mov 1, %i0
{
rtems_rfs_bitmap_element bits;
int available;
if (size < rtems_rfs_bitmap_element_bits ())
204199c: 38 80 00 09 bgu,a 20419c0 <rtems_rfs_bitmap_create_search+0x64>
20419a0: d0 06 40 00 ld [ %i1 ], %o0
{
bits = rtems_rfs_bitmap_merge (*map,
20419a4: 90 10 20 00 clr %o0
20419a8: 7f ff fe f2 call 2041570 <rtems_rfs_bitmap_mask_section>
20419ac: 92 10 00 1d mov %i5, %o1
{
/*
* Use the normal bit operators because we do not change the bits just merge
* the 2 separate parts.
*/
bits1 &= mask;
20419b0: c2 06 40 00 ld [ %i1 ], %g1
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;
20419b4: 84 10 00 1d mov %i5, %g2
{
/*
* Use the normal bit operators because we do not change the bits just merge
* the 2 separate parts.
*/
bits1 &= mask;
20419b8: 10 80 00 03 b 20419c4 <rtems_rfs_bitmap_create_search+0x68>
20419bc: 90 0a 00 01 and %o0, %g1, %o0
available = size;
}
else
{
bits = *map;
available = rtems_rfs_bitmap_element_bits ();
20419c0: 84 10 20 20 mov 0x20, %g2
}
if (rtems_rfs_bitmap_match (bits, RTEMS_RFS_BITMAP_ELEMENT_SET))
20419c4: 80 a2 20 00 cmp %o0, 0
20419c8: 12 80 00 07 bne 20419e4 <rtems_rfs_bitmap_create_search+0x88>
20419cc: 82 10 20 00 clr %g1
control->free++;
}
size -= available;
if (bit == rtems_rfs_bitmap_element_bits ())
20419d0: 80 a6 a0 20 cmp %i2, 0x20
20419d4: 12 80 00 14 bne 2041a24 <rtems_rfs_bitmap_create_search+0xc8><== ALWAYS TAKEN
20419d8: ba 27 40 02 sub %i5, %g2, %i5
{
bit = 0;
search_map++;
*search_map = RTEMS_RFS_BITMAP_ELEMENT_CLEAR;
20419dc: 10 80 00 0e b 2041a14 <rtems_rfs_bitmap_create_search+0xb8><== NOT EXECUTED
20419e0: 82 10 3f ff mov -1, %g1 <== 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);
20419e4: 87 2e 00 01 sll %i0, %g1, %g3
rtems_rfs_bitmap_set (*search_map, bit);
else
{
int b;
for (b = 0; b < available; b++)
if (!rtems_rfs_bitmap_test (bits, b))
20419e8: 80 88 c0 08 btst %g3, %o0
20419ec: 02 80 00 05 be 2041a00 <rtems_rfs_bitmap_create_search+0xa4>
20419f0: 82 00 60 01 inc %g1
control->free++;
20419f4: c6 07 20 10 ld [ %i4 + 0x10 ], %g3
20419f8: 86 00 e0 01 inc %g3
20419fc: c6 27 20 10 st %g3, [ %i4 + 0x10 ]
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++)
2041a00: 80 a0 40 02 cmp %g1, %g2
2041a04: 06 bf ff f9 bl 20419e8 <rtems_rfs_bitmap_create_search+0x8c>
2041a08: 87 2e 00 01 sll %i0, %g1, %g3
control->free++;
}
size -= available;
if (bit == rtems_rfs_bitmap_element_bits ())
2041a0c: 10 bf ff f2 b 20419d4 <rtems_rfs_bitmap_create_search+0x78>
2041a10: 80 a6 a0 20 cmp %i2, 0x20
{
bit = 0;
2041a14: b4 10 20 00 clr %i2 <== NOT EXECUTED
search_map++;
*search_map = RTEMS_RFS_BITMAP_ELEMENT_CLEAR;
2041a18: c2 26 e0 04 st %g1, [ %i3 + 4 ] <== NOT EXECUTED
size -= available;
if (bit == rtems_rfs_bitmap_element_bits ())
{
bit = 0;
search_map++;
2041a1c: 10 80 00 03 b 2041a28 <rtems_rfs_bitmap_create_search+0xcc><== NOT EXECUTED
2041a20: b6 06 e0 04 add %i3, 4, %i3 <== NOT EXECUTED
*search_map = RTEMS_RFS_BITMAP_ELEMENT_CLEAR;
}
else
bit++;
2041a24: b4 06 a0 01 inc %i2
2041a28: b2 06 60 04 add %i1, 4, %i1
search_map = control->search_bits;
size = control->size;
bit = 0;
*search_map = RTEMS_RFS_BITMAP_ELEMENT_CLEAR;
while (size)
2041a2c: 80 a7 60 00 cmp %i5, 0
2041a30: 12 bf ff db bne 204199c <rtems_rfs_bitmap_create_search+0x40>
2041a34: 80 a7 60 1f cmp %i5, 0x1f
else
bit++;
map++;
}
return 0;
2041a38: b0 10 20 00 clr %i0
}
2041a3c: 81 c7 e0 08 ret
2041a40: 81 e8 00 00 restore
0204128c <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)
{
204128c: 9d e3 bf a0 save %sp, -96, %sp
int rc;
if (!control->buffer)
2041290: c2 06 00 00 ld [ %i0 ], %g1
* @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)
{
2041294: ba 10 00 18 mov %i0, %i5
int rc;
if (!control->buffer)
2041298: 80 a0 60 00 cmp %g1, 0
204129c: 02 80 00 0f be 20412d8 <rtems_rfs_bitmap_load_map+0x4c> <== NEVER TAKEN
20412a0: b0 10 20 06 mov 6, %i0
return ENXIO;
*map = NULL;
20412a4: c0 26 40 00 clr [ %i1 ]
rc = rtems_rfs_buffer_handle_request (control->fs,
20412a8: d4 07 60 08 ld [ %i5 + 8 ], %o2
20412ac: d0 07 60 04 ld [ %i5 + 4 ], %o0
20412b0: d2 07 40 00 ld [ %i5 ], %o1
20412b4: 7f ff d8 ae call 203756c <rtems_rfs_buffer_handle_request>
20412b8: 96 10 20 01 mov 1, %o3
control->buffer,
control->block,
true);
if (rc)
20412bc: b0 92 20 00 orcc %o0, 0, %i0
20412c0: 12 80 00 06 bne 20412d8 <rtems_rfs_bitmap_load_map+0x4c> <== NEVER TAKEN
20412c4: 01 00 00 00 nop
return rc;
*map = rtems_rfs_buffer_data (control->buffer);
20412c8: c2 07 40 00 ld [ %i5 ], %g1
20412cc: c2 00 60 08 ld [ %g1 + 8 ], %g1
20412d0: c2 00 60 1c ld [ %g1 + 0x1c ], %g1
20412d4: c2 26 40 00 st %g1, [ %i1 ]
return 0;
}
20412d8: 81 c7 e0 08 ret
20412dc: 81 e8 00 00 restore
0204185c <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)
{
204185c: 9d e3 bf a0 save %sp, -96, %sp
int rc = 0;
/*
* By default we assume the allocation failed.
*/
*allocated = false;
2041860: c0 2e 80 00 clrb [ %i2 ]
* 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))
2041864: 10 80 00 2d b 2041918 <rtems_rfs_bitmap_map_alloc+0xbc>
2041868: ba 10 00 19 mov %i1, %i5
|| ((lower_seed >= 0) && (lower_seed < control->size)))
{
/*
* Search up first so bits allocated in succession are grouped together.
*/
if (upper_seed < control->size)
204186c: 2a 80 00 07 bcs,a 2041888 <rtems_rfs_bitmap_map_alloc+0x2c><== NOT EXECUTED
2041870: fa 26 c0 00 st %i5, [ %i3 ] <== NOT EXECUTED
window, 1);
if ((rc > 0) || *allocated)
break;
}
if (lower_seed >= 0)
2041874: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED
2041878: 36 80 00 17 bge,a 20418d4 <rtems_rfs_bitmap_map_alloc+0x78><== ALWAYS TAKEN
204187c: f2 26 c0 00 st %i1, [ %i3 ]
/*
* 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)
2041880: 10 80 00 10 b 20418c0 <rtems_rfs_bitmap_map_alloc+0x64> <== NOT EXECUTED
2041884: c2 06 20 0c ld [ %i0 + 0xc ], %g1 <== NOT EXECUTED
* Search up first so bits allocated in succession are grouped together.
*/
if (upper_seed < control->size)
{
*bit = upper_seed;
rc = rtems_rfs_search_map_for_clear_bit (control, bit, allocated,
2041888: 90 10 00 18 mov %i0, %o0
204188c: 92 10 00 1b mov %i3, %o1
2041890: 94 10 00 1a mov %i2, %o2
2041894: 7f ff fe 93 call 20412e0 <rtems_rfs_search_map_for_clear_bit.constprop.1>
2041898: 96 10 20 01 mov 1, %o3
window, 1);
if ((rc > 0) || *allocated)
204189c: 80 a2 20 00 cmp %o0, 0
20418a0: 34 80 00 2d bg,a 2041954 <rtems_rfs_bitmap_map_alloc+0xf8><== NEVER TAKEN
20418a4: b0 10 20 00 clr %i0 <== NOT EXECUTED
20418a8: c2 0e 80 00 ldub [ %i2 ], %g1
20418ac: 80 a0 60 00 cmp %g1, 0
20418b0: 02 bf ff f2 be 2041878 <rtems_rfs_bitmap_map_alloc+0x1c>
20418b4: 80 a6 60 00 cmp %i1, 0
if (lower_seed >= 0)
lower_seed -= window;
}
return 0;
}
20418b8: 81 c7 e0 08 ret
20418bc: 91 e8 20 00 restore %g0, 0, %o0
/*
* 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)
20418c0: 80 a7 40 01 cmp %i5, %g1
20418c4: 2a 80 00 12 bcs,a 204190c <rtems_rfs_bitmap_map_alloc+0xb0><== ALWAYS TAKEN
20418c8: ba 07 68 00 add %i5, 0x800, %i5
upper_seed += window;
if (lower_seed >= 0)
20418cc: 10 80 00 11 b 2041910 <rtems_rfs_bitmap_map_alloc+0xb4> <== NOT EXECUTED
20418d0: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED
}
if (lower_seed >= 0)
{
*bit = lower_seed;
rc = rtems_rfs_search_map_for_clear_bit (control, bit, allocated,
20418d4: 90 10 00 18 mov %i0, %o0
20418d8: 92 10 00 1b mov %i3, %o1
20418dc: 94 10 00 1a mov %i2, %o2
20418e0: 7f ff fe 80 call 20412e0 <rtems_rfs_search_map_for_clear_bit.constprop.1>
20418e4: 96 10 3f ff mov -1, %o3
window, -1);
if ((rc > 0) || *allocated)
20418e8: 80 a2 20 00 cmp %o0, 0
20418ec: 34 80 00 1a bg,a 2041954 <rtems_rfs_bitmap_map_alloc+0xf8><== NEVER TAKEN
20418f0: b0 10 20 00 clr %i0 <== NOT EXECUTED
20418f4: c2 0e 80 00 ldub [ %i2 ], %g1
20418f8: 80 a0 60 00 cmp %g1, 0
20418fc: 22 bf ff f1 be,a 20418c0 <rtems_rfs_bitmap_map_alloc+0x64>
2041900: c2 06 20 0c ld [ %i0 + 0xc ], %g1
if (lower_seed >= 0)
lower_seed -= window;
}
return 0;
}
2041904: 81 c7 e0 08 ret
2041908: 91 e8 20 00 restore %g0, 0, %o0
* 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)
upper_seed += window;
if (lower_seed >= 0)
204190c: 80 a6 60 00 cmp %i1, 0
2041910: 36 80 00 02 bge,a 2041918 <rtems_rfs_bitmap_map_alloc+0xbc><== ALWAYS TAKEN
2041914: b2 06 78 00 add %i1, -2048, %i1
* 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))
2041918: 80 a7 60 00 cmp %i5, 0
204191c: 06 80 00 07 bl 2041938 <rtems_rfs_bitmap_map_alloc+0xdc> <== NEVER TAKEN
2041920: 80 a6 60 00 cmp %i1, 0
2041924: c2 06 20 0c ld [ %i0 + 0xc ], %g1
2041928: 80 a7 40 01 cmp %i5, %g1
204192c: 2a bf ff d7 bcs,a 2041888 <rtems_rfs_bitmap_map_alloc+0x2c>
2041930: fa 26 c0 00 st %i5, [ %i3 ]
|| ((lower_seed >= 0) && (lower_seed < control->size)))
2041934: 80 a6 60 00 cmp %i1, 0
2041938: 26 80 00 07 bl,a 2041954 <rtems_rfs_bitmap_map_alloc+0xf8>
204193c: b0 10 20 00 clr %i0
2041940: c2 06 20 0c ld [ %i0 + 0xc ], %g1
2041944: 80 a6 40 01 cmp %i1, %g1
2041948: 0a bf ff c9 bcs 204186c <rtems_rfs_bitmap_map_alloc+0x10> <== NEVER TAKEN
204194c: 80 a7 40 01 cmp %i5, %g1
if (lower_seed >= 0)
lower_seed -= window;
}
return 0;
}
2041950: b0 10 20 00 clr %i0
2041954: 81 c7 e0 08 ret
2041958: 81 e8 00 00 restore
0204162c <rtems_rfs_bitmap_map_clear>:
int
rtems_rfs_bitmap_map_clear (rtems_rfs_bitmap_control* control,
rtems_rfs_bitmap_bit bit)
{
204162c: 9d e3 bf 98 save %sp, -104, %sp
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);
2041630: 90 10 00 18 mov %i0, %o0
}
int
rtems_rfs_bitmap_map_clear (rtems_rfs_bitmap_control* control,
rtems_rfs_bitmap_bit bit)
{
2041634: ba 10 00 18 mov %i0, %i5
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);
2041638: 7f ff ff 15 call 204128c <rtems_rfs_bitmap_load_map>
204163c: 92 07 bf fc add %fp, -4, %o1
if (rc > 0)
2041640: b0 92 20 00 orcc %o0, 0, %i0
2041644: 14 80 00 1b bg 20416b0 <rtems_rfs_bitmap_map_clear+0x84> <== NEVER TAKEN
2041648: 01 00 00 00 nop
return rc;
if (bit >= control->size)
204164c: c2 07 60 0c ld [ %i5 + 0xc ], %g1
2041650: 80 a6 40 01 cmp %i1, %g1
2041654: 1a 80 00 17 bcc 20416b0 <rtems_rfs_bitmap_map_clear+0x84> <== NEVER TAKEN
2041658: b0 10 20 16 mov 0x16, %i0
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);
204165c: f8 07 bf fc ld [ %fp + -4 ], %i4
rc = rtems_rfs_bitmap_load_map (control, &map);
if (rc > 0)
return rc;
if (bit >= control->size)
return EINVAL;
search_map = control->search_bits;
2041660: c4 07 60 14 ld [ %i5 + 0x14 ], %g2
index = rtems_rfs_bitmap_map_index (bit);
2041664: 87 3e 60 05 sra %i1, 5, %g3
offset = rtems_rfs_bitmap_map_offset (bit);
map[index] = rtems_rfs_bitmap_clear (map[index], 1 << offset);
2041668: 89 28 e0 02 sll %g3, 2, %g4
*/
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);
204166c: f4 07 00 04 ld [ %i4 + %g4 ], %i2
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);
2041670: 82 10 20 01 mov 1, %g1
2041674: b7 28 40 19 sll %g1, %i1, %i3
bit = index;
index = rtems_rfs_bitmap_map_index (bit);
2041678: b3 3e 60 0a sra %i1, 0xa, %i1
*/
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);
204167c: b6 16 80 1b or %i2, %i3, %i3
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);
2041680: b3 2e 60 02 sll %i1, 2, %i1
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);
2041684: f6 27 00 04 st %i3, [ %i4 + %g4 ]
*/
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);
2041688: c8 00 80 19 ld [ %g2 + %i1 ], %g4
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);
204168c: 87 28 40 03 sll %g1, %g3, %g3
*/
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);
2041690: 86 11 00 03 or %g4, %g3, %g3
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);
2041694: c6 20 80 19 st %g3, [ %g2 + %i1 ]
rtems_rfs_buffer_mark_dirty (control->buffer);
2041698: c4 07 40 00 ld [ %i5 ], %g2
control->free++;
return 0;
204169c: b0 10 20 00 clr %i0
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);
20416a0: c2 28 80 00 stb %g1, [ %g2 ]
control->free++;
20416a4: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
20416a8: 82 00 60 01 inc %g1
20416ac: c2 27 60 10 st %g1, [ %i5 + 0x10 ]
return 0;
}
20416b0: 81 c7 e0 08 ret
20416b4: 81 e8 00 00 restore
020417a8 <rtems_rfs_bitmap_map_clear_all>:
int
rtems_rfs_bitmap_map_clear_all (rtems_rfs_bitmap_control* control)
{
20417a8: 9d e3 bf 98 save %sp, -104, %sp
rtems_rfs_bitmap_bit last_search_bit;
size_t elements;
int e;
int rc;
rc = rtems_rfs_bitmap_load_map (control, &map);
20417ac: 90 10 00 18 mov %i0, %o0
return 0;
}
int
rtems_rfs_bitmap_map_clear_all (rtems_rfs_bitmap_control* control)
{
20417b0: ba 10 00 18 mov %i0, %i5
rtems_rfs_bitmap_bit last_search_bit;
size_t elements;
int e;
int rc;
rc = rtems_rfs_bitmap_load_map (control, &map);
20417b4: 7f ff fe b6 call 204128c <rtems_rfs_bitmap_load_map>
20417b8: 92 07 bf fc add %fp, -4, %o1
if (rc > 0)
20417bc: b0 92 20 00 orcc %o0, 0, %i0
20417c0: 14 80 00 25 bg 2041854 <rtems_rfs_bitmap_map_clear_all+0xac><== NEVER TAKEN
20417c4: c6 07 bf fc ld [ %fp + -4 ], %g3
return rc;
elements = rtems_rfs_bitmap_elements (control->size);
20417c8: c8 07 60 0c ld [ %i5 + 0xc ], %g4
20417cc: 88 01 3f ff add %g4, -1, %g4
control->free = elements;
for (e = 0; e < elements; e++)
20417d0: 84 10 20 00 clr %g2
rc = rtems_rfs_bitmap_load_map (control, &map);
if (rc > 0)
return rc;
elements = rtems_rfs_bitmap_elements (control->size);
20417d4: 89 31 20 05 srl %g4, 5, %g4
20417d8: 82 01 20 01 add %g4, 1, %g1
control->free = elements;
for (e = 0; e < elements; e++)
20417dc: 10 80 00 05 b 20417f0 <rtems_rfs_bitmap_map_clear_all+0x48>
20417e0: c2 27 60 10 st %g1, [ %i5 + 0x10 ]
map[e] = RTEMS_RFS_BITMAP_ELEMENT_CLEAR;
20417e4: b6 10 3f ff mov -1, %i3
elements = rtems_rfs_bitmap_elements (control->size);
control->free = elements;
for (e = 0; e < elements; e++)
20417e8: 84 00 a0 01 inc %g2
map[e] = RTEMS_RFS_BITMAP_ELEMENT_CLEAR;
20417ec: f6 20 c0 1c st %i3, [ %g3 + %i4 ]
elements = rtems_rfs_bitmap_elements (control->size);
control->free = elements;
for (e = 0; e < elements; e++)
20417f0: 80 a0 80 01 cmp %g2, %g1
20417f4: 0a bf ff fc bcs 20417e4 <rtems_rfs_bitmap_map_clear_all+0x3c>
20417f8: b9 28 a0 02 sll %g2, 2, %i4
* 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)
20417fc: 86 88 60 1f andcc %g1, 0x1f, %g3
2041800: 22 80 00 02 be,a 2041808 <rtems_rfs_bitmap_map_clear_all+0x60>
2041804: 86 10 20 20 mov 0x20, %g3
last_search_bit = rtems_rfs_bitmap_element_bits ();
elements = rtems_rfs_bitmap_elements (elements);
2041808: 89 31 20 05 srl %g4, 5, %g4
for (e = 0; e < (elements - 1); e++)
204180c: 10 80 00 06 b 2041824 <rtems_rfs_bitmap_map_clear_all+0x7c>
2041810: 82 10 20 00 clr %g1
control->search_bits[e] = RTEMS_RFS_BITMAP_ELEMENT_CLEAR;
2041814: b9 28 60 02 sll %g1, 2, %i4 <== NOT EXECUTED
2041818: b6 10 3f ff mov -1, %i3 <== 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++)
204181c: 82 00 60 01 inc %g1 <== NOT EXECUTED
control->search_bits[e] = RTEMS_RFS_BITMAP_ELEMENT_CLEAR;
2041820: f6 20 80 1c st %i3, [ %g2 + %i4 ] <== 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++)
2041824: 80 a0 40 04 cmp %g1, %g4
2041828: 12 bf ff fb bne 2041814 <rtems_rfs_bitmap_map_clear_all+0x6c><== NEVER TAKEN
204182c: c4 07 60 14 ld [ %i5 + 0x14 ], %g2
control->search_bits[e] = RTEMS_RFS_BITMAP_ELEMENT_CLEAR;
control->search_bits[elements - 1] =
2041830: 83 28 60 02 sll %g1, 2, %g1
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);
2041834: 86 20 00 03 neg %g3
2041838: 88 10 3f ff mov -1, %g4
204183c: 87 31 00 03 srl %g4, %g3, %g3
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] =
2041840: c6 20 80 01 st %g3, [ %g2 + %g1 ]
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);
2041844: c2 07 40 00 ld [ %i5 ], %g1
2041848: 84 10 20 01 mov 1, %g2
return 0;
204184c: b0 10 20 00 clr %i0
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);
2041850: c4 28 40 00 stb %g2, [ %g1 ]
return 0;
}
2041854: 81 c7 e0 08 ret
2041858: 81 e8 00 00 restore
02041598 <rtems_rfs_bitmap_map_set>:
int
rtems_rfs_bitmap_map_set (rtems_rfs_bitmap_control* control,
rtems_rfs_bitmap_bit bit)
{
2041598: 9d e3 bf 98 save %sp, -104, %sp
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);
204159c: 90 10 00 18 mov %i0, %o0
}
int
rtems_rfs_bitmap_map_set (rtems_rfs_bitmap_control* control,
rtems_rfs_bitmap_bit bit)
{
20415a0: ba 10 00 18 mov %i0, %i5
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);
20415a4: 7f ff ff 3a call 204128c <rtems_rfs_bitmap_load_map>
20415a8: 92 07 bf fc add %fp, -4, %o1
if (rc > 0)
20415ac: b0 92 20 00 orcc %o0, 0, %i0
20415b0: 14 80 00 1d bg 2041624 <rtems_rfs_bitmap_map_set+0x8c> <== NEVER TAKEN
20415b4: 01 00 00 00 nop
return rc;
if (bit >= control->size)
20415b8: c2 07 60 0c ld [ %i5 + 0xc ], %g1
20415bc: 80 a6 40 01 cmp %i1, %g1
20415c0: 1a 80 00 19 bcc 2041624 <rtems_rfs_bitmap_map_set+0x8c> <== NEVER TAKEN
20415c4: b0 10 20 16 mov 0x16, %i0
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);
20415c8: f6 07 bf fc ld [ %fp + -4 ], %i3
if (rc > 0)
return rc;
if (bit >= control->size)
return EINVAL;
search_map = control->search_bits;
index = rtems_rfs_bitmap_map_index (bit);
20415cc: 87 3e 60 05 sra %i1, 5, %g3
offset = rtems_rfs_bitmap_map_offset (bit);
map[index] = rtems_rfs_bitmap_set (map[index], 1 << offset);
20415d0: b9 28 e0 02 sll %g3, 2, %i4
*/
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);
20415d4: c8 06 c0 1c ld [ %i3 + %i4 ], %g4
rc = rtems_rfs_bitmap_load_map (control, &map);
if (rc > 0)
return rc;
if (bit >= control->size)
return EINVAL;
search_map = control->search_bits;
20415d8: c4 07 60 14 ld [ %i5 + 0x14 ], %g2
index = rtems_rfs_bitmap_map_index (bit);
offset = rtems_rfs_bitmap_map_offset (bit);
map[index] = rtems_rfs_bitmap_set (map[index], 1 << offset);
20415dc: 82 10 20 01 mov 1, %g1
20415e0: b5 28 40 19 sll %g1, %i1, %i2
*/
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);
20415e4: 88 29 00 1a andn %g4, %i2, %g4
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);
20415e8: c8 26 c0 1c st %g4, [ %i3 + %i4 ]
if (rtems_rfs_bitmap_match(map[index], RTEMS_RFS_BITMAP_ELEMENT_SET))
20415ec: 80 a1 20 00 cmp %g4, 0
20415f0: 12 80 00 0d bne 2041624 <rtems_rfs_bitmap_map_set+0x8c> <== ALWAYS TAKEN
20415f4: b0 10 20 00 clr %i0
{
bit = index;
index = rtems_rfs_bitmap_map_index (bit);
20415f8: b3 3e 60 0a sra %i1, 0xa, %i1 <== NOT EXECUTED
offset = rtems_rfs_bitmap_map_offset (bit);
search_map[index] = rtems_rfs_bitmap_set (search_map[index], 1 << offset);
20415fc: b3 2e 60 02 sll %i1, 2, %i1 <== 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);
2041600: c8 00 80 19 ld [ %g2 + %i1 ], %g4 <== 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);
2041604: 87 28 40 03 sll %g1, %g3, %g3 <== 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);
2041608: 86 29 00 03 andn %g4, %g3, %g3 <== 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);
204160c: c6 20 80 19 st %g3, [ %g2 + %i1 ] <== NOT EXECUTED
control->free--;
2041610: c4 07 60 10 ld [ %i5 + 0x10 ], %g2 <== NOT EXECUTED
2041614: 84 00 bf ff add %g2, -1, %g2 <== NOT EXECUTED
2041618: c4 27 60 10 st %g2, [ %i5 + 0x10 ] <== NOT EXECUTED
rtems_rfs_buffer_mark_dirty (control->buffer);
204161c: c4 07 40 00 ld [ %i5 ], %g2 <== NOT EXECUTED
2041620: c2 28 80 00 stb %g1, [ %g2 ] <== NOT EXECUTED
}
return 0;
}
2041624: 81 c7 e0 08 ret
2041628: 81 e8 00 00 restore
02041718 <rtems_rfs_bitmap_map_set_all>:
int
rtems_rfs_bitmap_map_set_all (rtems_rfs_bitmap_control* control)
{
2041718: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED
rtems_rfs_bitmap_map map;
size_t elements;
int e;
int rc;
rc = rtems_rfs_bitmap_load_map (control, &map);
204171c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
return 0;
}
int
rtems_rfs_bitmap_map_set_all (rtems_rfs_bitmap_control* control)
{
2041720: ba 10 00 18 mov %i0, %i5 <== NOT EXECUTED
rtems_rfs_bitmap_map map;
size_t elements;
int e;
int rc;
rc = rtems_rfs_bitmap_load_map (control, &map);
2041724: 7f ff fe da call 204128c <rtems_rfs_bitmap_load_map> <== NOT EXECUTED
2041728: 92 07 bf fc add %fp, -4, %o1 <== NOT EXECUTED
if (rc > 0)
204172c: b0 92 20 00 orcc %o0, 0, %i0 <== NOT EXECUTED
2041730: 14 80 00 1c bg 20417a0 <rtems_rfs_bitmap_map_set_all+0x88><== NOT EXECUTED
2041734: 82 10 20 00 clr %g1 <== NOT EXECUTED
return rc;
elements = rtems_rfs_bitmap_elements (control->size);
2041738: c4 07 60 0c ld [ %i5 + 0xc ], %g2 <== NOT EXECUTED
control->free = 0;
204173c: c0 27 60 10 clr [ %i5 + 0x10 ] <== NOT EXECUTED
rc = rtems_rfs_bitmap_load_map (control, &map);
if (rc > 0)
return rc;
elements = rtems_rfs_bitmap_elements (control->size);
2041740: 84 00 bf ff add %g2, -1, %g2 <== NOT EXECUTED
control->free = 0;
for (e = 0; e < elements; e++)
map[e] = RTEMS_RFS_BITMAP_ELEMENT_SET;
2041744: c8 07 bf fc ld [ %fp + -4 ], %g4 <== NOT EXECUTED
rc = rtems_rfs_bitmap_load_map (control, &map);
if (rc > 0)
return rc;
elements = rtems_rfs_bitmap_elements (control->size);
2041748: 85 30 a0 05 srl %g2, 5, %g2 <== NOT EXECUTED
control->free = 0;
for (e = 0; e < elements; e++)
204174c: 10 80 00 04 b 204175c <rtems_rfs_bitmap_map_set_all+0x44> <== NOT EXECUTED
2041750: 86 00 a0 01 add %g2, 1, %g3 <== NOT EXECUTED
2041754: 82 00 60 01 inc %g1 <== NOT EXECUTED
map[e] = RTEMS_RFS_BITMAP_ELEMENT_SET;
2041758: c0 21 00 1c clr [ %g4 + %i4 ] <== NOT EXECUTED
elements = rtems_rfs_bitmap_elements (control->size);
control->free = 0;
for (e = 0; e < elements; e++)
204175c: 80 a0 40 03 cmp %g1, %g3 <== NOT EXECUTED
2041760: 0a bf ff fd bcs 2041754 <rtems_rfs_bitmap_map_set_all+0x3c><== NOT EXECUTED
2041764: b9 28 60 02 sll %g1, 2, %i4 <== NOT EXECUTED
map[e] = RTEMS_RFS_BITMAP_ELEMENT_SET;
elements = rtems_rfs_bitmap_elements (elements);
2041768: 85 30 a0 05 srl %g2, 5, %g2 <== NOT EXECUTED
for (e = 0; e < elements; e++)
204176c: 82 10 20 00 clr %g1 <== NOT EXECUTED
2041770: 10 80 00 05 b 2041784 <rtems_rfs_bitmap_map_set_all+0x6c> <== NOT EXECUTED
2041774: 84 00 a0 01 inc %g2 <== NOT EXECUTED
control->search_bits[e] = RTEMS_RFS_BITMAP_ELEMENT_SET;
2041778: 87 28 60 02 sll %g1, 2, %g3 <== 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++)
204177c: 82 00 60 01 inc %g1 <== NOT EXECUTED
control->search_bits[e] = RTEMS_RFS_BITMAP_ELEMENT_SET;
2041780: c0 21 00 03 clr [ %g4 + %g3 ] <== 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++)
2041784: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED
2041788: 2a bf ff fc bcs,a 2041778 <rtems_rfs_bitmap_map_set_all+0x60><== NOT EXECUTED
204178c: c8 07 60 14 ld [ %i5 + 0x14 ], %g4 <== NOT EXECUTED
control->search_bits[e] = RTEMS_RFS_BITMAP_ELEMENT_SET;
rtems_rfs_buffer_mark_dirty (control->buffer);
2041790: c2 07 40 00 ld [ %i5 ], %g1 <== NOT EXECUTED
2041794: 84 10 20 01 mov 1, %g2 <== NOT EXECUTED
return 0;
2041798: b0 10 20 00 clr %i0 <== 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);
204179c: c4 28 40 00 stb %g2, [ %g1 ] <== NOT EXECUTED
return 0;
}
20417a0: 81 c7 e0 08 ret <== NOT EXECUTED
20417a4: 81 e8 00 00 restore <== NOT EXECUTED
020416b8 <rtems_rfs_bitmap_map_test>:
int
rtems_rfs_bitmap_map_test (rtems_rfs_bitmap_control* control,
rtems_rfs_bitmap_bit bit,
bool* state)
{
20416b8: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED
rtems_rfs_bitmap_map map;
int index;
int rc;
rc = rtems_rfs_bitmap_load_map (control, &map);
20416bc: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
20416c0: 7f ff fe f3 call 204128c <rtems_rfs_bitmap_load_map> <== NOT EXECUTED
20416c4: 92 07 bf fc add %fp, -4, %o1 <== NOT EXECUTED
if (rc > 0)
20416c8: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
20416cc: 14 80 00 11 bg 2041710 <rtems_rfs_bitmap_map_test+0x58> <== NOT EXECUTED
20416d0: 01 00 00 00 nop <== NOT EXECUTED
return rc;
if (bit >= control->size)
20416d4: c2 06 20 0c ld [ %i0 + 0xc ], %g1 <== NOT EXECUTED
20416d8: 80 a6 40 01 cmp %i1, %g1 <== NOT EXECUTED
20416dc: 1a 80 00 0d bcc 2041710 <rtems_rfs_bitmap_map_test+0x58> <== NOT EXECUTED
20416e0: 90 10 20 16 mov 0x16, %o0 <== 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);
20416e4: 84 10 20 01 mov 1, %g2 <== 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);
20416e8: 83 3e 60 05 sra %i1, 5, %g1 <== 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);
20416ec: b3 28 80 19 sll %g2, %i1, %i1 <== NOT EXECUTED
20416f0: c4 07 bf fc ld [ %fp + -4 ], %g2 <== 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);
20416f4: 83 28 60 02 sll %g1, 2, %g1 <== 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);
20416f8: c2 00 80 01 ld [ %g2 + %g1 ], %g1 <== 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;
20416fc: 90 10 20 00 clr %o0 <== 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);
2041700: b2 0e 40 01 and %i1, %g1, %i1 <== NOT EXECUTED
2041704: 80 a0 00 19 cmp %g0, %i1 <== NOT EXECUTED
2041708: 82 60 3f ff subx %g0, -1, %g1 <== NOT EXECUTED
204170c: c2 2e 80 00 stb %g1, [ %i2 ] <== 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;
}
2041710: 81 c7 e0 08 ret <== NOT EXECUTED
2041714: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED
02041560 <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;
}
2041560: 82 10 3f ff mov -1, %g1 <== 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);
2041564: 90 20 00 08 neg %o0 <== NOT EXECUTED
return mask;
}
2041568: 81 c3 e0 08 retl <== NOT EXECUTED
204156c: 91 30 40 08 srl %g1, %o0, %o0 <== NOT EXECUTED
02041570 <rtems_rfs_bitmap_mask_section>:
rtems_rfs_bitmap_element
rtems_rfs_bitmap_mask_section (unsigned int start, unsigned int end)
{
2041570: 82 10 00 08 mov %o0, %g1
rtems_rfs_bitmap_element mask = 0;
if (end > start)
2041574: 80 a2 40 01 cmp %o1, %g1
2041578: 08 80 00 06 bleu 2041590 <rtems_rfs_bitmap_mask_section+0x20><== NEVER TAKEN
204157c: 90 10 20 00 clr %o0
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);
2041580: 92 20 40 09 sub %g1, %o1, %o1
2041584: 90 10 3f ff mov -1, %o0
2041588: 91 32 00 09 srl %o0, %o1, %o0
rtems_rfs_bitmap_element
rtems_rfs_bitmap_mask_section (unsigned int start, unsigned int end)
{
rtems_rfs_bitmap_element mask = 0;
if (end > start)
mask = rtems_rfs_bitmap_mask (end - start) << start;
204158c: 91 2a 00 01 sll %o0, %g1, %o0
return mask;
}
2041590: 81 c3 e0 08 retl
02041a44 <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)
{
2041a44: 9d e3 bf a0 save %sp, -96, %sp
size_t elements = rtems_rfs_bitmap_elements (size);
control->buffer = buffer;
2041a48: f4 26 00 00 st %i2, [ %i0 ]
control->fs = fs;
2041a4c: f2 26 20 04 st %i1, [ %i0 + 4 ]
control->block = block;
2041a50: f8 26 20 08 st %i4, [ %i0 + 8 ]
control->size = size;
2041a54: f6 26 20 0c st %i3, [ %i0 + 0xc ]
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);
2041a58: 90 06 ff ff add %i3, -1, %o0
control->buffer = buffer;
control->fs = fs;
control->block = block;
control->size = size;
elements = rtems_rfs_bitmap_elements (elements);
2041a5c: 91 32 20 0a srl %o0, 0xa, %o0
2041a60: 90 02 20 01 inc %o0
control->search_bits = malloc (elements * sizeof (rtems_rfs_bitmap_element));
2041a64: 7f ff 1d c4 call 2009174 <malloc>
2041a68: 91 2a 20 02 sll %o0, 2, %o0
if (!control->search_bits)
2041a6c: 80 a2 20 00 cmp %o0, 0
2041a70: 02 80 00 04 be 2041a80 <rtems_rfs_bitmap_open+0x3c> <== NEVER TAKEN
2041a74: d0 26 20 14 st %o0, [ %i0 + 0x14 ]
return ENOMEM;
return rtems_rfs_bitmap_create_search (control);
2041a78: 7f ff ff b9 call 204195c <rtems_rfs_bitmap_create_search>
2041a7c: 81 e8 00 00 restore
}
2041a80: 81 c7 e0 08 ret <== NOT EXECUTED
2041a84: 91 e8 20 0c restore %g0, 0xc, %o0 <== NOT EXECUTED
020363e4 <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)
{
20363e4: 9d e3 bf a0 save %sp, -96, %sp
/*
* 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);
20363e8: 96 10 20 01 mov 1, %o3
20363ec: 90 10 00 18 mov %i0, %o0
20363f0: 92 10 00 19 mov %i1, %o1
20363f4: 40 00 04 5e call 203756c <rtems_rfs_buffer_handle_request>
20363f8: 94 10 00 1a mov %i2, %o2
if (rc > 0)
20363fc: 80 a2 20 00 cmp %o0, 0
2036400: 14 80 00 26 bg 2036498 <rtems_rfs_block_find_indirect+0xb4><== NEVER TAKEN
2036404: 87 2e e0 02 sll %i3, 2, %g3
return rc;
*result = rtems_rfs_block_get_number (buffer, offset);
2036408: c2 06 60 08 ld [ %i1 + 8 ], %g1
203640c: c8 00 60 1c ld [ %g1 + 0x1c ], %g4
if ((*result + 1) == 0)
*result = 0;
if (*result >= rtems_rfs_fs_blocks (fs))
2036410: 90 10 20 00 clr %o0
*/
rc = rtems_rfs_buffer_handle_request (fs, buffer, block, true);
if (rc > 0)
return rc;
*result = rtems_rfs_block_get_number (buffer, offset);
2036414: 84 01 00 03 add %g4, %g3, %g2
2036418: c2 09 00 03 ldub [ %g4 + %g3 ], %g1
203641c: fa 08 a0 03 ldub [ %g2 + 3 ], %i5
2036420: c6 08 a0 01 ldub [ %g2 + 1 ], %g3
2036424: c4 08 a0 02 ldub [ %g2 + 2 ], %g2
2036428: 83 28 60 18 sll %g1, 0x18, %g1
203642c: 85 28 a0 08 sll %g2, 8, %g2
2036430: 82 17 40 01 or %i5, %g1, %g1
2036434: 87 28 e0 10 sll %g3, 0x10, %g3
2036438: 82 10 40 03 or %g1, %g3, %g1
203643c: 82 10 40 02 or %g1, %g2, %g1
if ((*result + 1) == 0)
*result = 0;
2036440: 84 38 00 01 xnor %g0, %g1, %g2
2036444: 80 a0 00 02 cmp %g0, %g2
2036448: 84 60 20 00 subx %g0, 0, %g2
203644c: 82 08 40 02 and %g1, %g2, %g1
if (*result >= rtems_rfs_fs_blocks (fs))
2036450: c4 06 20 04 ld [ %i0 + 4 ], %g2
2036454: 80 a0 40 02 cmp %g1, %g2
2036458: 0a 80 00 10 bcs 2036498 <rtems_rfs_block_find_indirect+0xb4><== ALWAYS TAKEN
203645c: c2 27 00 00 st %g1, [ %i4 ]
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BLOCK_FIND))
2036460: 90 10 20 00 clr %o0 <== NOT EXECUTED
2036464: 7f ff b5 7a call 2023a4c <rtems_rfs_trace> <== NOT EXECUTED
2036468: 13 00 00 04 sethi %hi(0x1000), %o1 <== NOT EXECUTED
203646c: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
2036470: 22 80 00 09 be,a 2036494 <rtems_rfs_block_find_indirect+0xb0><== NOT EXECUTED
2036474: c0 27 00 00 clr [ %i4 ] <== NOT EXECUTED
printf ("rtems-rfs: block-find: invalid block in table:"
2036478: d2 07 00 00 ld [ %i4 ], %o1 <== NOT EXECUTED
203647c: 11 00 81 9c sethi %hi(0x2067000), %o0 <== NOT EXECUTED
2036480: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED
2036484: 90 12 21 58 or %o0, 0x158, %o0 <== NOT EXECUTED
2036488: 40 00 41 98 call 2046ae8 <printf> <== NOT EXECUTED
203648c: 96 10 00 1b mov %i3, %o3 <== NOT EXECUTED
" block=%" PRId32 ", indirect=%" PRId32 "/%d\n", *result, block, offset);
*result = 0;
2036490: c0 27 00 00 clr [ %i4 ] <== NOT EXECUTED
2036494: 90 10 20 00 clr %o0 <== NOT EXECUTED
rc = EIO;
}
return 0;
}
2036498: 81 c7 e0 08 ret
203649c: 91 e8 00 08 restore %g0, %o0, %o0
02036504 <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)
{
2036504: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED
if (pos == 0)
2036508: 80 96 40 1a orcc %i1, %i2, %g0 <== NOT EXECUTED
203650c: 32 80 00 06 bne,a 2036524 <rtems_rfs_block_get_block_size+0x20><== NOT EXECUTED
2036510: fa 06 20 08 ld [ %i0 + 8 ], %i5 <== 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;
2036514: c0 26 c0 00 clr [ %i3 ] <== NOT EXECUTED
size->offset = 0;
2036518: c0 26 e0 04 clr [ %i3 + 4 ] <== NOT EXECUTED
203651c: 81 c7 e0 08 ret <== NOT EXECUTED
2036520: 81 e8 00 00 restore <== NOT EXECUTED
rtems_rfs_block_set_size_zero (size);
else
{
size->count = pos / rtems_rfs_fs_block_size (fs) + 1;
2036524: 94 10 20 00 clr %o2 <== NOT EXECUTED
2036528: 96 10 00 1d mov %i5, %o3 <== NOT EXECUTED
203652c: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
2036530: 40 00 97 d4 call 205c480 <__udivdi3> <== NOT EXECUTED
2036534: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED
2036538: 92 02 60 01 inc %o1 <== NOT EXECUTED
size->offset = pos % rtems_rfs_fs_block_size (fs);
203653c: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
{
if (pos == 0)
rtems_rfs_block_set_size_zero (size);
else
{
size->count = pos / rtems_rfs_fs_block_size (fs) + 1;
2036540: d2 26 c0 00 st %o1, [ %i3 ] <== NOT EXECUTED
size->offset = pos % rtems_rfs_fs_block_size (fs);
2036544: 94 10 20 00 clr %o2 <== NOT EXECUTED
2036548: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED
203654c: 40 00 98 a1 call 205c7d0 <__umoddi3> <== NOT EXECUTED
2036550: 96 10 00 1d mov %i5, %o3 <== NOT EXECUTED
2036554: d2 26 e0 04 st %o1, [ %i3 + 4 ] <== NOT EXECUTED
2036558: 81 c7 e0 08 ret <== NOT EXECUTED
203655c: 81 e8 00 00 restore <== NOT EXECUTED
0203673c <rtems_rfs_block_map_close>:
int
rtems_rfs_block_map_close (rtems_rfs_file_system* fs,
rtems_rfs_block_map* map)
{
203673c: 9d e3 bf a0 save %sp, -96, %sp
int rc = 0;
int brc;
if (map->dirty && map->inode)
2036740: c2 0e 40 00 ldub [ %i1 ], %g1
}
int
rtems_rfs_block_map_close (rtems_rfs_file_system* fs,
rtems_rfs_block_map* map)
{
2036744: ba 10 00 18 mov %i0, %i5
int rc = 0;
int brc;
if (map->dirty && map->inode)
2036748: 80 a0 60 00 cmp %g1, 0
203674c: 02 80 00 61 be 20368d0 <rtems_rfs_block_map_close+0x194>
2036750: b0 10 20 00 clr %i0
2036754: d2 06 60 04 ld [ %i1 + 4 ], %o1
2036758: 80 a2 60 00 cmp %o1, 0
203675c: 22 80 00 5e be,a 20368d4 <rtems_rfs_block_map_close+0x198><== NEVER TAKEN
2036760: 92 06 60 38 add %i1, 0x38, %o1 <== NOT EXECUTED
{
brc = rtems_rfs_inode_load (fs, map->inode);
2036764: 40 00 14 e2 call 203baec <rtems_rfs_inode_load>
2036768: 90 10 00 1d mov %i5, %o0
if (brc > 0)
203676c: b0 92 20 00 orcc %o0, 0, %i0
2036770: 14 80 00 59 bg 20368d4 <rtems_rfs_block_map_close+0x198> <== NEVER TAKEN
2036774: 92 06 60 38 add %i1, 0x38, %o1
2036778: 82 10 20 00 clr %g1
*/
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);
203677c: b8 10 20 01 mov 1, %i4
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]);
2036780: c4 06 60 04 ld [ %i1 + 4 ], %g2
return rc;
}
int
rtems_rfs_block_map_close (rtems_rfs_file_system* fs,
2036784: 87 28 60 02 sll %g1, 2, %g3
* @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);
2036788: f6 00 a0 0c ld [ %g2 + 0xc ], %i3
203678c: 86 06 40 03 add %i1, %g3, %g3
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]);
2036790: c6 00 e0 24 ld [ %g3 + 0x24 ], %g3
2036794: 88 00 60 06 add %g1, 6, %g4
2036798: 89 29 20 02 sll %g4, 2, %g4
203679c: b6 06 c0 04 add %i3, %g4, %i3
20367a0: b5 30 e0 18 srl %g3, 0x18, %i2
20367a4: f4 2e e0 04 stb %i2, [ %i3 + 4 ]
20367a8: f6 00 a0 0c ld [ %g2 + 0xc ], %i3
20367ac: b5 30 e0 10 srl %g3, 0x10, %i2
20367b0: b6 06 c0 04 add %i3, %g4, %i3
20367b4: f4 2e e0 05 stb %i2, [ %i3 + 5 ]
20367b8: f6 00 a0 0c ld [ %g2 + 0xc ], %i3
20367bc: b5 30 e0 08 srl %g3, 8, %i2
20367c0: b6 06 c0 04 add %i3, %g4, %i3
20367c4: f4 2e e0 06 stb %i2, [ %i3 + 6 ]
20367c8: f6 00 a0 0c ld [ %g2 + 0xc ], %i3
if (rc == 0)
{
int b;
for (b = 0; b < RTEMS_RFS_INODE_BLOCKS; b++)
20367cc: 82 00 60 01 inc %g1
20367d0: 88 06 c0 04 add %i3, %g4, %g4
20367d4: c6 29 20 07 stb %g3, [ %g4 + 7 ]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
20367d8: f8 28 a0 10 stb %i4, [ %g2 + 0x10 ]
20367dc: 80 a0 60 05 cmp %g1, 5
20367e0: 12 bf ff e8 bne 2036780 <rtems_rfs_block_map_close+0x44>
20367e4: 86 10 20 01 mov 1, %g3
rtems_rfs_inode_set_block (map->inode, b, map->blocks[b]);
rtems_rfs_inode_set_block_count (map->inode, map->size.count);
20367e8: c2 06 60 04 ld [ %i1 + 4 ], %g1
20367ec: c4 06 60 08 ld [ %i1 + 8 ], %g2
* @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);
20367f0: c8 00 60 0c ld [ %g1 + 0xc ], %g4
20367f4: b9 30 a0 18 srl %g2, 0x18, %i4
20367f8: f8 29 20 0c stb %i4, [ %g4 + 0xc ]
20367fc: c8 00 60 0c ld [ %g1 + 0xc ], %g4
2036800: b9 30 a0 10 srl %g2, 0x10, %i4
2036804: f8 29 20 0d stb %i4, [ %g4 + 0xd ]
2036808: c8 00 60 0c ld [ %g1 + 0xc ], %g4
203680c: b9 30 a0 08 srl %g2, 8, %i4
2036810: f8 29 20 0e stb %i4, [ %g4 + 0xe ]
2036814: c8 00 60 0c ld [ %g1 + 0xc ], %g4
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);
2036818: 90 10 00 1d mov %i5, %o0
203681c: c4 29 20 0f stb %g2, [ %g4 + 0xf ]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
2036820: c6 28 60 10 stb %g3, [ %g1 + 0x10 ]
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);
2036824: c2 06 60 04 ld [ %i1 + 4 ], %g1
*/
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);
2036828: f8 0e 60 0e ldub [ %i1 + 0xe ], %i4
203682c: c4 00 60 0c ld [ %g1 + 0xc ], %g2
2036830: c8 06 60 0c ld [ %i1 + 0xc ], %g4
2036834: f8 28 a0 0a stb %i4, [ %g2 + 0xa ]
2036838: c4 00 60 0c ld [ %g1 + 0xc ], %g2
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);
203683c: 94 10 20 01 mov 1, %o2
2036840: c8 28 a0 0b stb %g4, [ %g2 + 0xb ]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
2036844: c6 28 60 10 stb %g3, [ %g1 + 0x10 ]
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);
rtems_rfs_inode_set_last_map_block (map->inode, map->last_map_block);
2036848: c2 06 60 04 ld [ %i1 + 4 ], %g1
203684c: c4 06 60 1c ld [ %i1 + 0x1c ], %g2
* @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);
2036850: c8 00 60 0c ld [ %g1 + 0xc ], %g4
2036854: b9 30 a0 18 srl %g2, 0x18, %i4
2036858: f8 29 20 30 stb %i4, [ %g4 + 0x30 ]
203685c: c8 00 60 0c ld [ %g1 + 0xc ], %g4
2036860: b9 30 a0 10 srl %g2, 0x10, %i4
2036864: f8 29 20 31 stb %i4, [ %g4 + 0x31 ]
2036868: c8 00 60 0c ld [ %g1 + 0xc ], %g4
203686c: b9 30 a0 08 srl %g2, 8, %i4
2036870: f8 29 20 32 stb %i4, [ %g4 + 0x32 ]
2036874: c8 00 60 0c ld [ %g1 + 0xc ], %g4
2036878: c4 29 20 33 stb %g2, [ %g4 + 0x33 ]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
203687c: c6 28 60 10 stb %g3, [ %g1 + 0x10 ]
rtems_rfs_inode_set_last_data_block (map->inode, map->last_data_block);
2036880: c2 06 60 04 ld [ %i1 + 4 ], %g1
2036884: c4 06 60 20 ld [ %i1 + 0x20 ], %g2
* @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);
2036888: c8 00 60 0c ld [ %g1 + 0xc ], %g4
203688c: b9 30 a0 18 srl %g2, 0x18, %i4
2036890: f8 29 20 34 stb %i4, [ %g4 + 0x34 ]
2036894: c8 00 60 0c ld [ %g1 + 0xc ], %g4
2036898: b9 30 a0 10 srl %g2, 0x10, %i4
203689c: f8 29 20 35 stb %i4, [ %g4 + 0x35 ]
20368a0: c8 00 60 0c ld [ %g1 + 0xc ], %g4
20368a4: b9 30 a0 08 srl %g2, 8, %i4
20368a8: f8 29 20 36 stb %i4, [ %g4 + 0x36 ]
20368ac: c8 00 60 0c ld [ %g1 + 0xc ], %g4
20368b0: c4 29 20 37 stb %g2, [ %g4 + 0x37 ]
brc = rtems_rfs_inode_unload (fs, map->inode, true);
20368b4: d2 06 60 04 ld [ %i1 + 4 ], %o1
20368b8: 40 00 14 f0 call 203bc78 <rtems_rfs_inode_unload>
20368bc: c6 28 60 10 stb %g3, [ %g1 + 0x10 ]
if (brc > 0)
rc = brc;
map->dirty = false;
20368c0: c0 2e 40 00 clrb [ %i1 ]
20368c4: 82 38 00 08 xnor %g0, %o0, %g1
20368c8: 83 38 60 1f sra %g1, 0x1f, %g1
20368cc: b0 0a 00 01 and %o0, %g1, %i0
*/
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);
20368d0: 92 06 60 38 add %i1, 0x38, %o1
}
}
map->inode = NULL;
20368d4: c0 26 60 04 clr [ %i1 + 4 ]
20368d8: 40 00 02 b1 call 203739c <rtems_rfs_buffer_handle_release>
20368dc: 90 10 00 1d mov %i5, %o0
20368e0: 90 10 00 1d mov %i5, %o0
handle->dirty = false;
20368e4: c0 2e 60 38 clrb [ %i1 + 0x38 ]
handle->bnum = 0;
20368e8: c0 26 60 3c clr [ %i1 + 0x3c ]
handle->buffer = NULL;
20368ec: c0 26 60 40 clr [ %i1 + 0x40 ]
*/
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);
20368f0: 40 00 02 ab call 203739c <rtems_rfs_buffer_handle_release>
20368f4: 92 06 60 44 add %i1, 0x44, %o1
handle->dirty = false;
20368f8: c0 2e 60 44 clrb [ %i1 + 0x44 ]
handle->bnum = 0;
20368fc: c0 26 60 48 clr [ %i1 + 0x48 ]
handle->buffer = NULL;
2036900: c0 26 60 4c clr [ %i1 + 0x4c ]
rc = brc;
brc = rtems_rfs_buffer_handle_close (fs, &map->doubly_buffer);
if ((brc > 0) && (rc == 0))
rc = brc;
return rc;
}
2036904: 81 c7 e0 08 ret
2036908: 81 e8 00 00 restore
0203690c <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)
{
203690c: 9d e3 bf 98 save %sp, -104, %sp
int rc = 0;
*block = 0;
2036910: c0 26 c0 00 clr [ %i3 ]
/*
* Range checking here makes the remaining logic simpler.
*/
if (rtems_rfs_block_pos_block_past_end (bpos, &map->size))
2036914: fa 06 80 00 ld [ %i2 ], %i5
2036918: 80 a7 60 00 cmp %i5, 0
203691c: 02 80 00 05 be 2036930 <rtems_rfs_block_map_find+0x24>
2036920: f8 06 60 08 ld [ %i1 + 8 ], %i4
2036924: 80 a7 20 00 cmp %i4, 0
2036928: 02 80 00 53 be 2036a74 <rtems_rfs_block_map_find+0x168> <== NEVER TAKEN
203692c: 90 10 20 06 mov 6, %o0
2036930: 80 a7 40 1c cmp %i5, %i4
2036934: 1a 80 00 50 bcc 2036a74 <rtems_rfs_block_map_find+0x168>
2036938: 90 10 20 06 mov 6, %o0
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))
203693c: c2 06 60 10 ld [ %i1 + 0x10 ], %g1
2036940: 80 a7 40 01 cmp %i5, %g1
2036944: 12 80 00 08 bne 2036964 <rtems_rfs_block_map_find+0x58>
2036948: 80 a7 20 05 cmp %i4, 5
203694c: c2 06 60 18 ld [ %i1 + 0x18 ], %g1
2036950: 80 a0 60 00 cmp %g1, 0
2036954: 02 80 00 04 be 2036964 <rtems_rfs_block_map_find+0x58>
2036958: 80 a7 20 05 cmp %i4, 5
* 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)
{
*block = map->blocks[bpos->bno];
203695c: 10 80 00 3d b 2036a50 <rtems_rfs_block_map_find+0x144>
2036960: c2 26 c0 00 st %g1, [ %i3 ]
/*
* 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)
2036964: 38 80 00 08 bgu,a 2036984 <rtems_rfs_block_map_find+0x78>
2036968: e0 06 20 34 ld [ %i0 + 0x34 ], %l0
{
*block = map->blocks[bpos->bno];
203696c: ba 07 60 08 add %i5, 8, %i5
2036970: bb 2f 60 02 sll %i5, 2, %i5
2036974: ba 06 40 1d add %i1, %i5, %i5
2036978: c2 07 60 04 ld [ %i5 + 4 ], %g1
203697c: 10 80 00 35 b 2036a50 <rtems_rfs_block_map_find+0x144>
2036980: c2 26 c0 00 st %g1, [ %i3 ]
* 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;
2036984: 90 10 00 1d mov %i5, %o0
2036988: 40 00 93 aa call 205b830 <.urem>
203698c: 92 10 00 10 mov %l0, %o1
singly = bpos->bno / fs->blocks_per_block;
2036990: 92 10 00 10 mov %l0, %o1
* 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;
2036994: a2 10 00 08 mov %o0, %l1
singly = bpos->bno / fs->blocks_per_block;
2036998: 40 00 92 fa call 205b580 <.udiv>
203699c: 90 10 00 1d mov %i5, %o0
if (map->size.count <= fs->block_map_singly_blocks)
20369a0: c2 06 20 38 ld [ %i0 + 0x38 ], %g1
*/
rtems_rfs_block_no direct;
rtems_rfs_block_no singly;
direct = bpos->bno % fs->blocks_per_block;
singly = bpos->bno / fs->blocks_per_block;
20369a4: d0 27 bf fc st %o0, [ %fp + -4 ]
if (map->size.count <= fs->block_map_singly_blocks)
20369a8: 80 a7 00 01 cmp %i4, %g1
20369ac: 18 80 00 09 bgu 20369d0 <rtems_rfs_block_map_find+0xc4> <== NEVER TAKEN
20369b0: ba 10 00 08 mov %o0, %i5
{
/*
* This is a single indirect table of blocks anchored off a slot in the
* inode.
*/
rc = rtems_rfs_block_find_indirect (fs,
20369b4: ba 02 20 08 add %o0, 8, %i5
20369b8: 92 06 60 38 add %i1, 0x38, %o1
20369bc: bb 2f 60 02 sll %i5, 2, %i5
20369c0: 90 10 00 18 mov %i0, %o0
20369c4: ba 06 40 1d add %i1, %i5, %i5
20369c8: 10 80 00 1c b 2036a38 <rtems_rfs_block_map_find+0x12c>
20369cc: d4 07 60 04 ld [ %i5 + 4 ], %o2
* The map is doubly indirect.
*/
rtems_rfs_block_no doubly;
doubly = singly / fs->blocks_per_block;
singly %= fs->blocks_per_block;
20369d0: 40 00 93 98 call 205b830 <.urem> <== NOT EXECUTED
20369d4: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED
if (map->size.count < fs->block_map_doubly_blocks)
20369d8: c4 06 20 3c ld [ %i0 + 0x3c ], %g2 <== NOT EXECUTED
* The map is doubly indirect.
*/
rtems_rfs_block_no doubly;
doubly = singly / fs->blocks_per_block;
singly %= fs->blocks_per_block;
20369dc: d0 27 bf fc st %o0, [ %fp + -4 ] <== NOT EXECUTED
20369e0: a4 10 00 08 mov %o0, %l2 <== NOT EXECUTED
if (map->size.count < fs->block_map_doubly_blocks)
20369e4: 80 a7 00 02 cmp %i4, %g2 <== NOT EXECUTED
20369e8: 1a 80 00 23 bcc 2036a74 <rtems_rfs_block_map_find+0x168> <== NOT EXECUTED
20369ec: 90 10 20 06 mov 6, %o0 <== NOT EXECUTED
/*
* The map is doubly indirect.
*/
rtems_rfs_block_no doubly;
doubly = singly / fs->blocks_per_block;
20369f0: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED
20369f4: 40 00 92 e3 call 205b580 <.udiv> <== NOT EXECUTED
20369f8: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
singly %= fs->blocks_per_block;
if (map->size.count < fs->block_map_doubly_blocks)
{
rc = rtems_rfs_block_find_indirect (fs,
20369fc: 90 02 20 08 add %o0, 8, %o0 <== NOT EXECUTED
2036a00: 83 2a 20 02 sll %o0, 2, %g1 <== NOT EXECUTED
2036a04: 82 06 40 01 add %i1, %g1, %g1 <== NOT EXECUTED
2036a08: d4 00 60 04 ld [ %g1 + 4 ], %o2 <== NOT EXECUTED
2036a0c: b8 06 60 44 add %i1, 0x44, %i4 <== NOT EXECUTED
2036a10: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
2036a14: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
2036a18: 96 10 00 12 mov %l2, %o3 <== NOT EXECUTED
2036a1c: 7f ff fe 72 call 20363e4 <rtems_rfs_block_find_indirect> <== NOT EXECUTED
2036a20: 98 07 bf fc add %fp, -4, %o4 <== NOT EXECUTED
&map->doubly_buffer,
map->blocks[doubly],
singly, &singly);
if (rc == 0)
2036a24: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2036a28: 12 80 00 13 bne 2036a74 <rtems_rfs_block_map_find+0x168> <== NOT EXECUTED
2036a2c: d4 07 bf fc ld [ %fp + -4 ], %o2 <== NOT EXECUTED
{
rc = rtems_rfs_block_find_indirect (fs,
2036a30: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
2036a34: 92 06 60 38 add %i1, 0x38, %o1 <== NOT EXECUTED
2036a38: 96 10 00 11 mov %l1, %o3
2036a3c: 7f ff fe 6a call 20363e4 <rtems_rfs_block_find_indirect>
2036a40: 98 10 00 1b mov %i3, %o4
}
}
}
}
if (rc == 0)
2036a44: 80 a2 20 00 cmp %o0, 0
2036a48: 12 80 00 0b bne 2036a74 <rtems_rfs_block_map_find+0x168> <== NEVER TAKEN
2036a4c: 01 00 00 00 nop
{
rtems_rfs_block_copy_bpos (&map->bpos, bpos);
2036a50: c2 06 80 00 ld [ %i2 ], %g1
map->bpos.block = *block;
2036a54: 90 10 20 00 clr %o0
}
}
if (rc == 0)
{
rtems_rfs_block_copy_bpos (&map->bpos, bpos);
2036a58: c2 26 60 10 st %g1, [ %i1 + 0x10 ]
2036a5c: c2 06 a0 04 ld [ %i2 + 4 ], %g1
2036a60: c2 26 60 14 st %g1, [ %i1 + 0x14 ]
2036a64: c2 06 a0 08 ld [ %i2 + 8 ], %g1
2036a68: c2 26 60 18 st %g1, [ %i1 + 0x18 ]
map->bpos.block = *block;
2036a6c: c2 06 c0 00 ld [ %i3 ], %g1
2036a70: c2 26 60 18 st %g1, [ %i1 + 0x18 ]
}
return rc;
}
2036a74: 81 c7 e0 08 ret
2036a78: 91 e8 00 08 restore %g0, %o0, %o0
02036b24 <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)
{
2036b24: 9d e3 bf 98 save %sp, -104, %sp
int b;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BLOCK_MAP_GROW))
2036b28: 90 10 20 00 clr %o0
2036b2c: 13 00 00 08 sethi %hi(0x2000), %o1
2036b30: 7f ff b3 c7 call 2023a4c <rtems_rfs_trace>
2036b34: ba 10 00 18 mov %i0, %i5
2036b38: 80 8a 20 ff btst 0xff, %o0
2036b3c: 22 80 00 08 be,a 2036b5c <rtems_rfs_block_map_grow+0x38> <== ALWAYS TAKEN
2036b40: c4 06 60 08 ld [ %i1 + 8 ], %g2
printf ("rtems-rfs: block-map-grow: entry: blocks=%zd count=%" PRIu32 "\n",
2036b44: d4 06 60 08 ld [ %i1 + 8 ], %o2 <== NOT EXECUTED
2036b48: 11 00 81 9c sethi %hi(0x2067000), %o0 <== NOT EXECUTED
2036b4c: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED
2036b50: 40 00 3f e6 call 2046ae8 <printf> <== NOT EXECUTED
2036b54: 90 12 21 a8 or %o0, 0x1a8, %o0 <== NOT EXECUTED
blocks, map->size.count);
if ((map->size.count + blocks) >= rtems_rfs_fs_max_block_map_blocks (fs))
2036b58: c4 06 60 08 ld [ %i1 + 8 ], %g2 <== NOT EXECUTED
2036b5c: c2 07 60 3c ld [ %i5 + 0x3c ], %g1
2036b60: 84 06 80 02 add %i2, %g2, %g2
2036b64: 80 a0 80 01 cmp %g2, %g1
2036b68: 1a 80 00 b2 bcc 2036e30 <rtems_rfs_block_map_grow+0x30c> <== NEVER TAKEN
2036b6c: b0 10 20 1b mov 0x1b, %i0
map->last_map_block = new_block;
return 0;
}
int
rtems_rfs_block_map_grow (rtems_rfs_file_system* fs,
2036b70: 10 80 00 d4 b 2036ec0 <rtems_rfs_block_map_grow+0x39c>
2036b74: a0 10 20 00 clr %l0
/*
* 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,
2036b78: 90 10 00 1d mov %i5, %o0
2036b7c: 94 10 20 00 clr %o2
2036b80: 40 00 12 b3 call 203b64c <rtems_rfs_group_bitmap_alloc>
2036b84: 96 07 bf f8 add %fp, -8, %o3
false, &block);
if (rc > 0)
2036b88: b0 92 20 00 orcc %o0, 0, %i0
2036b8c: 14 80 00 d4 bg 2036edc <rtems_rfs_block_map_grow+0x3b8>
2036b90: 01 00 00 00 nop
return rc;
if (map->size.count < RTEMS_RFS_INODE_BLOCKS)
2036b94: f8 06 60 08 ld [ %i1 + 8 ], %i4
2036b98: 80 a7 20 04 cmp %i4, 4
2036b9c: 38 80 00 08 bgu,a 2036bbc <rtems_rfs_block_map_grow+0x98>
2036ba0: f0 07 60 34 ld [ %i5 + 0x34 ], %i0
map->blocks[map->size.count] = block;
2036ba4: c2 07 bf f8 ld [ %fp + -8 ], %g1
2036ba8: b8 07 20 08 add %i4, 8, %i4
2036bac: b9 2f 20 02 sll %i4, 2, %i4
2036bb0: b8 06 40 1c add %i1, %i4, %i4
2036bb4: 10 80 00 b7 b 2036e90 <rtems_rfs_block_map_grow+0x36c>
2036bb8: c2 27 20 04 st %g1, [ %i4 + 4 ]
* 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;
2036bbc: 90 10 00 1c mov %i4, %o0
2036bc0: 40 00 93 1c call 205b830 <.urem>
2036bc4: 92 10 00 18 mov %i0, %o1
singly = map->size.count / fs->blocks_per_block;
2036bc8: 92 10 00 18 mov %i0, %o1
* 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;
2036bcc: a4 10 00 08 mov %o0, %l2
singly = map->size.count / fs->blocks_per_block;
2036bd0: 40 00 92 6c call 205b580 <.udiv>
2036bd4: 90 10 00 1c mov %i4, %o0
if (map->size.count < fs->block_map_singly_blocks)
2036bd8: c2 07 60 38 ld [ %i5 + 0x38 ], %g1
2036bdc: 80 a7 00 01 cmp %i4, %g1
2036be0: 1a 80 00 1d bcc 2036c54 <rtems_rfs_block_map_grow+0x130> <== NEVER TAKEN
2036be4: ac 10 00 08 mov %o0, %l6
* 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) ||
2036be8: 80 a4 a0 00 cmp %l2, 0
2036bec: 22 80 00 07 be,a 2036c08 <rtems_rfs_block_map_grow+0xe4> <== NEVER TAKEN
2036bf0: b8 1f 20 05 xor %i4, 5, %i4 <== NOT EXECUTED
2036bf4: 80 a4 a0 05 cmp %l2, 5
2036bf8: 12 80 00 10 bne 2036c38 <rtems_rfs_block_map_grow+0x114>
2036bfc: 80 a2 20 00 cmp %o0, 0
2036c00: 12 80 00 0e bne 2036c38 <rtems_rfs_block_map_grow+0x114> <== NEVER TAKEN
2036c04: b8 1f 20 05 xor %i4, 5, %i4
/*
* 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,
2036c08: 80 a0 00 1c cmp %g0, %i4
&map->singly_buffer,
&map->blocks[singly],
2036c0c: 96 05 a0 08 add %l6, 8, %o3
/*
* 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,
2036c10: 90 10 00 1d mov %i5, %o0
&map->singly_buffer,
&map->blocks[singly],
2036c14: 97 2a e0 02 sll %o3, 2, %o3
/*
* 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,
2036c18: 92 10 00 19 mov %i1, %o1
&map->singly_buffer,
&map->blocks[singly],
2036c1c: 96 06 40 0b add %i1, %o3, %o3
/*
* 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,
2036c20: 94 10 00 11 mov %l1, %o2
2036c24: 96 02 e0 04 add %o3, 4, %o3
2036c28: 7f ff fd 9e call 20362a0 <rtems_rfs_block_map_indirect_alloc>
2036c2c: 98 60 3f ff subx %g0, -1, %o4
singly_block = rtems_rfs_block_get_number (&map->doubly_buffer,
singly);
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
singly_block, true);
if (rc > 0)
2036c30: 10 80 00 7a b 2036e18 <rtems_rfs_block_map_grow+0x2f4>
2036c34: b0 92 20 00 orcc %o0, 0, %i0
&map->blocks[singly],
upping);
}
else
{
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
2036c38: ac 05 a0 08 add %l6, 8, %l6
2036c3c: 90 10 00 1d mov %i5, %o0
2036c40: ad 2d a0 02 sll %l6, 2, %l6
2036c44: 92 10 00 11 mov %l1, %o1
2036c48: ac 06 40 16 add %i1, %l6, %l6
2036c4c: 10 80 00 70 b 2036e0c <rtems_rfs_block_map_grow+0x2e8>
2036c50: d4 05 a0 04 ld [ %l6 + 4 ], %o2
* Doubly indirect tables are being used.
*/
rtems_rfs_block_no doubly;
rtems_rfs_block_no singly_block;
doubly = singly / fs->blocks_per_block;
2036c54: 40 00 92 4b call 205b580 <.udiv> <== NOT EXECUTED
2036c58: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
singly %= fs->blocks_per_block;
2036c5c: 92 10 00 18 mov %i0, %o1 <== 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;
2036c60: a6 10 00 08 mov %o0, %l3 <== NOT EXECUTED
singly %= fs->blocks_per_block;
2036c64: 40 00 92 f3 call 205b830 <.urem> <== NOT EXECUTED
2036c68: 90 10 00 16 mov %l6, %o0 <== NOT EXECUTED
* Allocate a new block for a singly indirect table if direct is 0 as
* it is the first entry of a new block. We may also need to allocate a
* doubly indirect block as well. Both always occur when direct is 0
* and the doubly indirect block when singly is 0.
*/
if (direct == 0)
2036c6c: 80 a4 a0 00 cmp %l2, 0 <== NOT EXECUTED
2036c70: 12 80 00 4a bne 2036d98 <rtems_rfs_block_map_grow+0x274> <== NOT EXECUTED
2036c74: b8 10 00 08 mov %o0, %i4 <== NOT EXECUTED
{
rc = rtems_rfs_block_map_indirect_alloc (fs, map,
2036c78: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
2036c7c: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
2036c80: 94 10 00 11 mov %l1, %o2 <== NOT EXECUTED
2036c84: 96 07 bf fc add %fp, -4, %o3 <== NOT EXECUTED
2036c88: 7f ff fd 86 call 20362a0 <rtems_rfs_block_map_indirect_alloc><== NOT EXECUTED
2036c8c: 98 10 20 00 clr %o4 <== NOT EXECUTED
&map->singly_buffer,
&singly_block,
false);
if (rc > 0)
2036c90: b0 92 20 00 orcc %o0, 0, %i0 <== NOT EXECUTED
2036c94: 04 80 00 04 ble 2036ca4 <rtems_rfs_block_map_grow+0x180> <== NOT EXECUTED
2036c98: 80 a7 20 00 cmp %i4, 0 <== NOT EXECUTED
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
singly_block, true);
if (rc > 0)
{
rtems_rfs_group_bitmap_free (fs, false, block);
2036c9c: 10 80 00 62 b 2036e24 <rtems_rfs_block_map_grow+0x300> <== NOT EXECUTED
2036ca0: d4 07 bf f8 ld [ %fp + -8 ], %o2 <== NOT EXECUTED
/*
* Allocate a new block for a doubly indirect table if singly is 0 as
* it is the first entry of a new singly indirect block.
*/
if ((singly == 0) ||
2036ca4: 22 80 00 08 be,a 2036cc4 <rtems_rfs_block_map_grow+0x1a0><== NOT EXECUTED
2036ca8: c4 06 60 08 ld [ %i1 + 8 ], %g2 <== NOT EXECUTED
2036cac: 80 a7 20 05 cmp %i4, 5 <== NOT EXECUTED
2036cb0: 12 80 00 13 bne 2036cfc <rtems_rfs_block_map_grow+0x1d8> <== NOT EXECUTED
2036cb4: 80 a4 e0 00 cmp %l3, 0 <== NOT EXECUTED
2036cb8: 32 80 00 12 bne,a 2036d00 <rtems_rfs_block_map_grow+0x1dc><== NOT EXECUTED
2036cbc: a6 04 e0 08 add %l3, 8, %l3 <== NOT EXECUTED
((doubly == 0) && (singly == RTEMS_RFS_INODE_BLOCKS)))
{
bool upping;
upping = map->size.count == fs->block_map_singly_blocks;
2036cc0: c4 06 60 08 ld [ %i1 + 8 ], %g2 <== NOT EXECUTED
2036cc4: c2 07 60 38 ld [ %i5 + 0x38 ], %g1 <== NOT EXECUTED
rc = rtems_rfs_block_map_indirect_alloc (fs, map,
&map->doubly_buffer,
&map->blocks[doubly],
2036cc8: 96 04 e0 08 add %l3, 8, %o3 <== NOT EXECUTED
*/
if ((singly == 0) ||
((doubly == 0) && (singly == RTEMS_RFS_INODE_BLOCKS)))
{
bool upping;
upping = map->size.count == fs->block_map_singly_blocks;
2036ccc: 82 18 80 01 xor %g2, %g1, %g1 <== NOT EXECUTED
rc = rtems_rfs_block_map_indirect_alloc (fs, map,
2036cd0: 80 a0 00 01 cmp %g0, %g1 <== NOT EXECUTED
&map->doubly_buffer,
&map->blocks[doubly],
2036cd4: 97 2a e0 02 sll %o3, 2, %o3 <== NOT EXECUTED
if ((singly == 0) ||
((doubly == 0) && (singly == RTEMS_RFS_INODE_BLOCKS)))
{
bool upping;
upping = map->size.count == fs->block_map_singly_blocks;
rc = rtems_rfs_block_map_indirect_alloc (fs, map,
2036cd8: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
&map->doubly_buffer,
&map->blocks[doubly],
2036cdc: 96 06 40 0b add %i1, %o3, %o3 <== NOT EXECUTED
if ((singly == 0) ||
((doubly == 0) && (singly == RTEMS_RFS_INODE_BLOCKS)))
{
bool upping;
upping = map->size.count == fs->block_map_singly_blocks;
rc = rtems_rfs_block_map_indirect_alloc (fs, map,
2036ce0: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
2036ce4: 94 10 00 15 mov %l5, %o2 <== NOT EXECUTED
2036ce8: 96 02 e0 04 add %o3, 4, %o3 <== NOT EXECUTED
2036cec: 7f ff fd 6d call 20362a0 <rtems_rfs_block_map_indirect_alloc><== NOT EXECUTED
2036cf0: 98 60 3f ff subx %g0, -1, %o4 <== NOT EXECUTED
}
else
{
rc = rtems_rfs_buffer_handle_request (fs, &map->doubly_buffer,
map->blocks[doubly], true);
if (rc > 0)
2036cf4: 10 80 00 0b b 2036d20 <rtems_rfs_block_map_grow+0x1fc> <== NOT EXECUTED
2036cf8: b0 92 20 00 orcc %o0, 0, %i0 <== NOT EXECUTED
return rc;
}
}
else
{
rc = rtems_rfs_buffer_handle_request (fs, &map->doubly_buffer,
2036cfc: a6 04 e0 08 add %l3, 8, %l3 <== NOT EXECUTED
2036d00: a7 2c e0 02 sll %l3, 2, %l3 <== NOT EXECUTED
2036d04: a6 06 40 13 add %i1, %l3, %l3 <== NOT EXECUTED
2036d08: d4 04 e0 04 ld [ %l3 + 4 ], %o2 <== NOT EXECUTED
2036d0c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
2036d10: 92 10 00 15 mov %l5, %o1 <== NOT EXECUTED
2036d14: 40 00 02 16 call 203756c <rtems_rfs_buffer_handle_request><== NOT EXECUTED
2036d18: 96 10 20 01 mov 1, %o3 <== NOT EXECUTED
map->blocks[doubly], true);
if (rc > 0)
2036d1c: b0 92 20 00 orcc %o0, 0, %i0 <== NOT EXECUTED
2036d20: 24 80 00 08 ble,a 2036d40 <rtems_rfs_block_map_grow+0x21c><== NOT EXECUTED
2036d24: c2 06 60 4c ld [ %i1 + 0x4c ], %g1 <== NOT EXECUTED
{
rtems_rfs_group_bitmap_free (fs, false, singly_block);
2036d28: d4 07 bf fc ld [ %fp + -4 ], %o2 <== NOT EXECUTED
2036d2c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
2036d30: 40 00 12 cb call 203b85c <rtems_rfs_group_bitmap_free> <== NOT EXECUTED
2036d34: 92 10 20 00 clr %o1 <== NOT EXECUTED
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
singly_block, true);
if (rc > 0)
{
rtems_rfs_group_bitmap_free (fs, false, block);
2036d38: 10 80 00 3b b 2036e24 <rtems_rfs_block_map_grow+0x300> <== NOT EXECUTED
2036d3c: d4 07 bf f8 ld [ %fp + -8 ], %o2 <== NOT EXECUTED
rtems_rfs_group_bitmap_free (fs, false, block);
return rc;
}
}
rtems_rfs_block_set_number (&map->doubly_buffer,
2036d40: c4 0f bf fc ldub [ %fp + -4 ], %g2 <== NOT EXECUTED
2036d44: c2 00 60 1c ld [ %g1 + 0x1c ], %g1 <== NOT EXECUTED
2036d48: b9 2f 20 02 sll %i4, 2, %i4 <== NOT EXECUTED
2036d4c: c4 28 40 1c stb %g2, [ %g1 + %i4 ] <== NOT EXECUTED
2036d50: c2 06 60 4c ld [ %i1 + 0x4c ], %g1 <== NOT EXECUTED
2036d54: c4 17 bf fc lduh [ %fp + -4 ], %g2 <== NOT EXECUTED
2036d58: c2 00 60 1c ld [ %g1 + 0x1c ], %g1 <== NOT EXECUTED
2036d5c: 82 00 40 1c add %g1, %i4, %g1 <== NOT EXECUTED
2036d60: c4 28 60 01 stb %g2, [ %g1 + 1 ] <== NOT EXECUTED
2036d64: c2 06 60 4c ld [ %i1 + 0x4c ], %g1 <== NOT EXECUTED
2036d68: c4 07 bf fc ld [ %fp + -4 ], %g2 <== NOT EXECUTED
2036d6c: c2 00 60 1c ld [ %g1 + 0x1c ], %g1 <== NOT EXECUTED
2036d70: 85 30 a0 08 srl %g2, 8, %g2 <== NOT EXECUTED
2036d74: 82 00 40 1c add %g1, %i4, %g1 <== NOT EXECUTED
2036d78: c4 28 60 02 stb %g2, [ %g1 + 2 ] <== NOT EXECUTED
2036d7c: c2 06 60 4c ld [ %i1 + 0x4c ], %g1 <== NOT EXECUTED
2036d80: c2 00 60 1c ld [ %g1 + 0x1c ], %g1 <== NOT EXECUTED
2036d84: b8 00 40 1c add %g1, %i4, %i4 <== NOT EXECUTED
2036d88: c2 07 bf fc ld [ %fp + -4 ], %g1 <== NOT EXECUTED
2036d8c: c2 2f 20 03 stb %g1, [ %i4 + 3 ] <== NOT EXECUTED
2036d90: 10 80 00 2a b 2036e38 <rtems_rfs_block_map_grow+0x314> <== NOT EXECUTED
2036d94: e8 2e 60 44 stb %l4, [ %i1 + 0x44 ] <== NOT EXECUTED
singly,
singly_block);
}
else
{
rc = rtems_rfs_buffer_handle_request (fs,
2036d98: a6 04 e0 08 add %l3, 8, %l3 <== NOT EXECUTED
2036d9c: a7 2c e0 02 sll %l3, 2, %l3 <== NOT EXECUTED
2036da0: a6 06 40 13 add %i1, %l3, %l3 <== NOT EXECUTED
2036da4: d4 04 e0 04 ld [ %l3 + 4 ], %o2 <== NOT EXECUTED
2036da8: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
2036dac: 92 10 00 15 mov %l5, %o1 <== NOT EXECUTED
2036db0: 40 00 01 ef call 203756c <rtems_rfs_buffer_handle_request><== NOT EXECUTED
2036db4: 96 10 20 01 mov 1, %o3 <== NOT EXECUTED
&map->doubly_buffer,
map->blocks[doubly],
true);
if (rc > 0)
2036db8: b0 92 20 00 orcc %o0, 0, %i0 <== NOT EXECUTED
2036dbc: 24 80 00 04 ble,a 2036dcc <rtems_rfs_block_map_grow+0x2a8><== NOT EXECUTED
2036dc0: c2 06 60 4c ld [ %i1 + 0x4c ], %g1 <== NOT EXECUTED
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
singly_block, true);
if (rc > 0)
{
rtems_rfs_group_bitmap_free (fs, false, block);
2036dc4: 10 80 00 18 b 2036e24 <rtems_rfs_block_map_grow+0x300> <== NOT EXECUTED
2036dc8: d4 07 bf f8 ld [ %fp + -8 ], %o2 <== NOT EXECUTED
{
rtems_rfs_group_bitmap_free (fs, false, block);
return rc;
}
singly_block = rtems_rfs_block_get_number (&map->doubly_buffer,
2036dcc: b9 2f 20 02 sll %i4, 2, %i4 <== NOT EXECUTED
2036dd0: c4 00 60 1c ld [ %g1 + 0x1c ], %g2 <== NOT EXECUTED
singly);
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
2036dd4: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
{
rtems_rfs_group_bitmap_free (fs, false, block);
return rc;
}
singly_block = rtems_rfs_block_get_number (&map->doubly_buffer,
2036dd8: 82 00 80 1c add %g2, %i4, %g1 <== NOT EXECUTED
2036ddc: d4 08 80 1c ldub [ %g2 + %i4 ], %o2 <== NOT EXECUTED
2036de0: c6 08 60 03 ldub [ %g1 + 3 ], %g3 <== NOT EXECUTED
2036de4: c4 08 60 01 ldub [ %g1 + 1 ], %g2 <== NOT EXECUTED
2036de8: c2 08 60 02 ldub [ %g1 + 2 ], %g1 <== NOT EXECUTED
2036dec: 95 2a a0 18 sll %o2, 0x18, %o2 <== NOT EXECUTED
2036df0: 85 28 a0 10 sll %g2, 0x10, %g2 <== NOT EXECUTED
2036df4: 94 10 c0 0a or %g3, %o2, %o2 <== NOT EXECUTED
2036df8: 83 28 60 08 sll %g1, 8, %g1 <== NOT EXECUTED
2036dfc: 94 12 80 02 or %o2, %g2, %o2 <== NOT EXECUTED
singly);
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
2036e00: 92 10 00 11 mov %l1, %o1 <== NOT EXECUTED
{
rtems_rfs_group_bitmap_free (fs, false, block);
return rc;
}
singly_block = rtems_rfs_block_get_number (&map->doubly_buffer,
2036e04: 94 12 80 01 or %o2, %g1, %o2 <== NOT EXECUTED
2036e08: d4 27 bf fc st %o2, [ %fp + -4 ] <== NOT EXECUTED
singly);
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
2036e0c: 40 00 01 d8 call 203756c <rtems_rfs_buffer_handle_request>
2036e10: 96 10 20 01 mov 1, %o3
singly_block, true);
if (rc > 0)
2036e14: b0 92 20 00 orcc %o0, 0, %i0
2036e18: 24 80 00 09 ble,a 2036e3c <rtems_rfs_block_map_grow+0x318><== ALWAYS TAKEN
2036e1c: c2 06 60 40 ld [ %i1 + 0x40 ], %g1
{
rtems_rfs_group_bitmap_free (fs, false, block);
2036e20: d4 07 bf f8 ld [ %fp + -8 ], %o2 <== NOT EXECUTED
2036e24: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
2036e28: 40 00 12 8d call 203b85c <rtems_rfs_group_bitmap_free> <== NOT EXECUTED
2036e2c: 92 10 20 00 clr %o1 <== NOT EXECUTED
2036e30: 81 c7 e0 08 ret <== NOT EXECUTED
2036e34: 81 e8 00 00 restore <== NOT EXECUTED
return rc;
}
}
}
rtems_rfs_block_set_number (&map->singly_buffer, direct, block);
2036e38: c2 06 60 40 ld [ %i1 + 0x40 ], %g1 <== NOT EXECUTED
2036e3c: c4 0f bf f8 ldub [ %fp + -8 ], %g2
2036e40: c2 00 60 1c ld [ %g1 + 0x1c ], %g1
2036e44: a5 2c a0 02 sll %l2, 2, %l2
2036e48: c4 28 40 12 stb %g2, [ %g1 + %l2 ]
2036e4c: c2 06 60 40 ld [ %i1 + 0x40 ], %g1
2036e50: c4 17 bf f8 lduh [ %fp + -8 ], %g2
2036e54: c2 00 60 1c ld [ %g1 + 0x1c ], %g1
2036e58: 82 00 40 12 add %g1, %l2, %g1
2036e5c: c4 28 60 01 stb %g2, [ %g1 + 1 ]
2036e60: c2 06 60 40 ld [ %i1 + 0x40 ], %g1
2036e64: c4 07 bf f8 ld [ %fp + -8 ], %g2
2036e68: c2 00 60 1c ld [ %g1 + 0x1c ], %g1
2036e6c: 85 30 a0 08 srl %g2, 8, %g2
2036e70: 82 00 40 12 add %g1, %l2, %g1
2036e74: c4 28 60 02 stb %g2, [ %g1 + 2 ]
2036e78: c2 06 60 40 ld [ %i1 + 0x40 ], %g1
2036e7c: c2 00 60 1c ld [ %g1 + 0x1c ], %g1
2036e80: a4 00 40 12 add %g1, %l2, %l2
2036e84: c2 07 bf f8 ld [ %fp + -8 ], %g1
2036e88: c2 2c a0 03 stb %g1, [ %l2 + 3 ]
2036e8c: e8 2e 60 38 stb %l4, [ %i1 + 0x38 ]
}
map->size.count++;
2036e90: c2 06 60 08 ld [ %i1 + 8 ], %g1
map->size.offset = 0;
2036e94: c0 26 60 0c clr [ %i1 + 0xc ]
}
rtems_rfs_block_set_number (&map->singly_buffer, direct, block);
}
map->size.count++;
2036e98: 82 00 60 01 inc %g1
2036e9c: c2 26 60 08 st %g1, [ %i1 + 8 ]
map->size.offset = 0;
if (b == 0)
2036ea0: 80 a4 20 00 cmp %l0, 0
2036ea4: 12 80 00 03 bne 2036eb0 <rtems_rfs_block_map_grow+0x38c> <== NEVER TAKEN
2036ea8: c2 07 bf f8 ld [ %fp + -8 ], %g1
*new_block = block;
2036eac: c2 26 c0 00 st %g1, [ %i3 ]
map->last_data_block = block;
2036eb0: c2 26 60 20 st %g1, [ %i1 + 0x20 ]
map->dirty = true;
2036eb4: e8 2e 40 00 stb %l4, [ %i1 ]
/*
* 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++)
2036eb8: 10 80 00 05 b 2036ecc <rtems_rfs_block_map_grow+0x3a8>
2036ebc: a0 04 20 01 inc %l0
return rc;
}
}
}
rtems_rfs_block_set_number (&map->singly_buffer, direct, block);
2036ec0: a8 10 20 01 mov 1, %l4
singly,
singly_block);
}
else
{
rc = rtems_rfs_buffer_handle_request (fs,
2036ec4: aa 06 60 44 add %i1, 0x44, %l5
}
singly_block = rtems_rfs_block_get_number (&map->doubly_buffer,
singly);
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
2036ec8: a2 06 60 38 add %i1, 0x38, %l1
/*
* 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++)
2036ecc: 80 a4 00 1a cmp %l0, %i2
2036ed0: 32 bf ff 2a bne,a 2036b78 <rtems_rfs_block_map_grow+0x54>
2036ed4: d2 06 60 20 ld [ %i1 + 0x20 ], %o1
*new_block = block;
map->last_data_block = block;
map->dirty = true;
}
return 0;
2036ed8: b0 10 20 00 clr %i0
}
2036edc: 81 c7 e0 08 ret
2036ee0: 81 e8 00 00 restore
020362a0 <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)
{
20362a0: 9d e3 bf 98 save %sp, -104, %sp
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);
20362a4: d2 06 60 1c ld [ %i1 + 0x1c ], %o1
20362a8: 90 10 00 18 mov %i0, %o0
20362ac: 94 10 20 00 clr %o2
20362b0: 40 00 14 e7 call 203b64c <rtems_rfs_group_bitmap_alloc>
20362b4: 96 07 bf fc add %fp, -4, %o3
if (rc > 0)
20362b8: ba 92 20 00 orcc %o0, 0, %i5
20362bc: 34 80 00 48 bg,a 20363dc <rtems_rfs_block_map_indirect_alloc+0x13c><== NEVER TAKEN
20362c0: b0 10 00 1d mov %i5, %i0 <== NOT EXECUTED
return rc;
rc = rtems_rfs_buffer_handle_request (fs, buffer, new_block, false);
20362c4: d4 07 bf fc ld [ %fp + -4 ], %o2
20362c8: 90 10 00 18 mov %i0, %o0
20362cc: 92 10 00 1a mov %i2, %o1
20362d0: 40 00 04 a7 call 203756c <rtems_rfs_buffer_handle_request>
20362d4: 96 10 20 00 clr %o3
if (rc > 0)
20362d8: ba 92 20 00 orcc %o0, 0, %i5
20362dc: 04 80 00 07 ble 20362f8 <rtems_rfs_block_map_indirect_alloc+0x58><== ALWAYS TAKEN
20362e0: d4 07 bf fc ld [ %fp + -4 ], %o2
{
rtems_rfs_group_bitmap_free (fs, false, new_block);
20362e4: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
20362e8: 40 00 15 5d call 203b85c <rtems_rfs_group_bitmap_free> <== NOT EXECUTED
20362ec: 92 10 20 00 clr %o1 <== NOT EXECUTED
}
rtems_rfs_buffer_mark_dirty (buffer);
*block = new_block;
map->last_map_block = new_block;
return 0;
}
20362f0: 81 c7 e0 08 ret <== NOT EXECUTED
20362f4: 91 e8 00 1d restore %g0, %i5, %o0 <== NOT EXECUTED
if (rc > 0)
{
rtems_rfs_group_bitmap_free (fs, false, new_block);
return rc;
}
memset (rtems_rfs_buffer_data (buffer), 0xff, rtems_rfs_fs_block_size (fs));
20362f8: c2 06 a0 08 ld [ %i2 + 8 ], %g1
20362fc: d4 06 20 08 ld [ %i0 + 8 ], %o2
2036300: d0 00 60 1c ld [ %g1 + 0x1c ], %o0
2036304: 40 00 3d 88 call 2045924 <memset>
2036308: 92 10 20 ff mov 0xff, %o1
if (upping)
203630c: 80 a7 20 00 cmp %i4, 0
2036310: 02 80 00 2d be 20363c4 <rtems_rfs_block_map_indirect_alloc+0x124><== NEVER TAKEN
2036314: 82 10 20 01 mov 1, %g1
{
int b;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BLOCK_MAP_GROW))
2036318: 90 10 20 00 clr %o0
203631c: 7f ff b5 cc call 2023a4c <rtems_rfs_trace>
2036320: 13 00 00 08 sethi %hi(0x2000), %o1
2036324: 80 8a 20 ff btst 0xff, %o0
2036328: 02 80 00 07 be 2036344 <rtems_rfs_block_map_indirect_alloc+0xa4><== ALWAYS TAKEN
203632c: 84 10 00 19 mov %i1, %g2
printf ("rtems-rfs: block-map-grow: upping: block-count=%" PRId32 "\n",
2036330: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED
2036334: 11 00 81 9c sethi %hi(0x2067000), %o0 <== NOT EXECUTED
2036338: 40 00 41 ec call 2046ae8 <printf> <== NOT EXECUTED
203633c: 90 12 21 20 or %o0, 0x120, %o0 ! 2067120 <__FUNCTION__.7829+0x30><== NOT EXECUTED
2036340: 84 10 00 19 mov %i1, %g2 <== NOT EXECUTED
rtems_rfs_block_map_indirect_alloc (rtems_rfs_file_system* fs,
rtems_rfs_block_map* map,
rtems_rfs_buffer_handle* buffer,
rtems_rfs_block_no* block,
bool upping)
{
2036344: 82 10 20 00 clr %g1
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]);
2036348: 86 10 20 01 mov 1, %g3
203634c: c8 06 a0 08 ld [ %i2 + 8 ], %g4
2036350: fa 08 a0 24 ldub [ %g2 + 0x24 ], %i5
2036354: c8 01 20 1c ld [ %g4 + 0x1c ], %g4
2036358: fa 29 00 01 stb %i5, [ %g4 + %g1 ]
203635c: c8 06 a0 08 ld [ %i2 + 8 ], %g4
2036360: fa 10 a0 24 lduh [ %g2 + 0x24 ], %i5
2036364: c8 01 20 1c ld [ %g4 + 0x1c ], %g4
2036368: 88 01 00 01 add %g4, %g1, %g4
203636c: fa 29 20 01 stb %i5, [ %g4 + 1 ]
2036370: c8 06 a0 08 ld [ %i2 + 8 ], %g4
2036374: fa 00 a0 24 ld [ %g2 + 0x24 ], %i5
2036378: c8 01 20 1c ld [ %g4 + 0x1c ], %g4
203637c: bb 37 60 08 srl %i5, 8, %i5
2036380: 88 01 00 01 add %g4, %g1, %g4
2036384: fa 29 20 02 stb %i5, [ %g4 + 2 ]
2036388: c8 06 a0 08 ld [ %i2 + 8 ], %g4
203638c: fa 00 a0 24 ld [ %g2 + 0x24 ], %i5
2036390: c8 01 20 1c ld [ %g4 + 0x1c ], %g4
2036394: 84 00 a0 04 add %g2, 4, %g2
2036398: 88 01 00 01 add %g4, %g1, %g4
203639c: fa 29 20 03 stb %i5, [ %g4 + 3 ]
20363a0: 82 00 60 04 add %g1, 4, %g1
{
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++)
20363a4: 80 a0 60 14 cmp %g1, 0x14
20363a8: 12 bf ff e9 bne 203634c <rtems_rfs_block_map_indirect_alloc+0xac>
20363ac: c6 2e 80 00 stb %g3, [ %i2 ]
rtems_rfs_block_set_number (buffer, b, map->blocks[b]);
memset (map->blocks, 0, sizeof (map->blocks));
20363b0: 90 06 60 24 add %i1, 0x24, %o0
20363b4: 92 10 20 00 clr %o1
20363b8: 40 00 3d 5b call 2045924 <memset>
20363bc: 94 10 20 14 mov 0x14, %o2
}
rtems_rfs_buffer_mark_dirty (buffer);
20363c0: 82 10 20 01 mov 1, %g1
20363c4: c2 2e 80 00 stb %g1, [ %i2 ]
*block = new_block;
20363c8: c2 07 bf fc ld [ %fp + -4 ], %g1
map->last_map_block = new_block;
return 0;
20363cc: ba 10 20 00 clr %i5
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;
20363d0: c2 26 c0 00 st %g1, [ %i3 ]
map->last_map_block = new_block;
20363d4: c2 26 60 1c st %g1, [ %i1 + 0x1c ]
return 0;
}
20363d8: b0 10 00 1d mov %i5, %i0
20363dc: 81 c7 e0 08 ret
20363e0: 81 e8 00 00 restore
020361c0 <rtems_rfs_block_map_indirect_shrink>:
rtems_rfs_block_map_indirect_shrink (rtems_rfs_file_system* fs,
rtems_rfs_block_map* map,
rtems_rfs_buffer_handle* buffer,
rtems_rfs_block_no indirect,
rtems_rfs_block_no index)
{
20361c0: 9d e3 bf a0 save %sp, -96, %sp
* 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) ||
20361c4: 80 a7 20 00 cmp %i4, 0
20361c8: 02 80 00 09 be 20361ec <rtems_rfs_block_map_indirect_shrink+0x2c><== NEVER TAKEN
20361cc: 82 06 e0 08 add %i3, 8, %g1
20361d0: 80 a7 20 05 cmp %i4, 5
20361d4: 32 80 00 2f bne,a 2036290 <rtems_rfs_block_map_indirect_shrink+0xd0>
20361d8: b0 10 20 00 clr %i0
20361dc: 80 a6 e0 00 cmp %i3, 0
20361e0: 32 80 00 2c bne,a 2036290 <rtems_rfs_block_map_indirect_shrink+0xd0><== NEVER TAKEN
20361e4: b0 10 20 00 clr %i0 <== NOT EXECUTED
((indirect == 0) && (index == RTEMS_RFS_INODE_BLOCKS)))
{
rtems_rfs_block_no block_to_free = map->blocks[indirect];
20361e8: 82 06 e0 08 add %i3, 8, %g1
if ((indirect == 0) && (index == RTEMS_RFS_INODE_BLOCKS))
20361ec: 80 a7 20 05 cmp %i4, 5
* 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];
20361f0: 83 28 60 02 sll %g1, 2, %g1
20361f4: 82 06 40 01 add %i1, %g1, %g1
if ((indirect == 0) && (index == RTEMS_RFS_INODE_BLOCKS))
20361f8: 12 80 00 1a bne 2036260 <rtems_rfs_block_map_indirect_shrink+0xa0><== NEVER TAKEN
20361fc: fa 00 60 04 ld [ %g1 + 4 ], %i5
2036200: 80 a6 e0 00 cmp %i3, 0
2036204: 32 80 00 18 bne,a 2036264 <rtems_rfs_block_map_indirect_shrink+0xa4><== NEVER TAKEN
2036208: b6 06 e0 08 add %i3, 8, %i3 <== 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);
203620c: c2 06 a0 08 ld [ %i2 + 8 ], %g1
2036210: 84 10 20 00 clr %g2
2036214: c2 00 60 1c ld [ %g1 + 0x1c ], %g1
2036218: f8 08 40 00 ldub [ %g1 ], %i4
203621c: c8 08 60 01 ldub [ %g1 + 1 ], %g4
2036220: b9 2f 20 18 sll %i4, 0x18, %i4
2036224: 89 29 20 10 sll %g4, 0x10, %g4
2036228: 88 17 00 04 or %i4, %g4, %g4
203622c: f8 08 60 03 ldub [ %g1 + 3 ], %i4
* @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,
2036230: 86 06 40 02 add %i1, %g2, %g3
/*
* 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);
2036234: 88 11 00 1c or %g4, %i4, %g4
2036238: f8 08 60 02 ldub [ %g1 + 2 ], %i4
203623c: 84 00 a0 04 add %g2, 4, %g2
2036240: b9 2f 20 08 sll %i4, 8, %i4
2036244: 88 11 00 1c or %g4, %i4, %g4
2036248: c8 20 e0 24 st %g4, [ %g3 + 0x24 ]
{
/*
* Move to direct inode access.
*/
int b;
for (b = 0; b < RTEMS_RFS_INODE_BLOCKS; b++)
203624c: 80 a0 a0 14 cmp %g2, 0x14
2036250: 12 bf ff f2 bne 2036218 <rtems_rfs_block_map_indirect_shrink+0x58>
2036254: 82 00 60 04 add %g1, 4, %g1
* One less singly indirect block in the inode.
*/
map->blocks[indirect] = 0;
}
rc = rtems_rfs_group_bitmap_free (fs, false, block_to_free);
2036258: 10 80 00 07 b 2036274 <rtems_rfs_block_map_indirect_shrink+0xb4>
203625c: 90 10 00 18 mov %i0, %o0
else
{
/*
* One less singly indirect block in the inode.
*/
map->blocks[indirect] = 0;
2036260: b6 06 e0 08 add %i3, 8, %i3 <== NOT EXECUTED
2036264: b7 2e e0 02 sll %i3, 2, %i3 <== NOT EXECUTED
2036268: b6 06 40 1b add %i1, %i3, %i3 <== NOT EXECUTED
203626c: c0 26 e0 04 clr [ %i3 + 4 ] <== NOT EXECUTED
}
rc = rtems_rfs_group_bitmap_free (fs, false, block_to_free);
2036270: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
2036274: 92 10 20 00 clr %o1
2036278: 40 00 15 79 call 203b85c <rtems_rfs_group_bitmap_free>
203627c: 94 10 00 1d mov %i5, %o2
if (rc > 0)
2036280: b0 92 20 00 orcc %o0, 0, %i0
2036284: 14 80 00 05 bg 2036298 <rtems_rfs_block_map_indirect_shrink+0xd8><== NEVER TAKEN
2036288: 01 00 00 00 nop
return rc;
map->last_map_block = block_to_free;
203628c: fa 26 60 1c st %i5, [ %i1 + 0x1c ]
2036290: 81 c7 e0 08 ret
2036294: 81 e8 00 00 restore
}
return rc;
}
2036298: 81 c7 e0 08 ret <== NOT EXECUTED
203629c: 81 e8 00 00 restore <== NOT EXECUTED
020365b8 <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)
{
20365b8: 9d e3 bf a0 save %sp, -96, %sp
* 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;
20365bc: c0 2e 80 00 clrb [ %i2 ]
map->inode = NULL;
20365c0: c0 26 a0 04 clr [ %i2 + 4 ]
* @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;
20365c4: c0 26 a0 08 clr [ %i2 + 8 ]
size->offset = 0;
20365c8: c0 26 a0 0c clr [ %i2 + 0xc ]
* @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;
20365cc: c0 26 a0 10 clr [ %i2 + 0x10 ]
bpos->boff = 0;
20365d0: c0 26 a0 14 clr [ %i2 + 0x14 ]
bpos->block = 0;
20365d4: c0 26 a0 18 clr [ %i2 + 0x18 ]
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
20365d8: c0 2e a0 38 clrb [ %i2 + 0x38 ]
handle->bnum = 0;
20365dc: c0 26 a0 3c clr [ %i2 + 0x3c ]
handle->buffer = NULL;
20365e0: c0 26 a0 40 clr [ %i2 + 0x40 ]
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
20365e4: c0 2e a0 44 clrb [ %i2 + 0x44 ]
handle->bnum = 0;
20365e8: c0 26 a0 48 clr [ %i2 + 0x48 ]
handle->buffer = NULL;
20365ec: c0 26 a0 4c clr [ %i2 + 0x4c ]
return rc;
rc = rtems_rfs_buffer_handle_open (fs, &map->doubly_buffer);
if (rc > 0)
return rc;
rc = rtems_rfs_inode_load (fs, inode);
20365f0: 90 10 00 18 mov %i0, %o0
20365f4: 40 00 15 3e call 203baec <rtems_rfs_inode_load>
20365f8: 92 10 00 19 mov %i1, %o1
if (rc > 0)
20365fc: ba 92 20 00 orcc %o0, 0, %i5
2036600: 14 80 00 40 bg 2036700 <rtems_rfs_block_map_open+0x148> <== NEVER TAKEN
2036604: 84 10 20 00 clr %g2
* @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]);
2036608: c2 06 60 0c ld [ %i1 + 0xc ], %g1
/*
* Extract the block and block count data from the inode into the targets
* byte order.
*/
map->inode = inode;
203660c: f2 26 a0 04 st %i1, [ %i2 + 4 ]
2036610: 88 00 a0 06 add %g2, 6, %g4
2036614: 89 29 20 02 sll %g4, 2, %g4
2036618: 88 00 40 04 add %g1, %g4, %g4
203661c: 86 01 20 04 add %g4, 4, %g3
2036620: f8 09 20 04 ldub [ %g4 + 4 ], %i4
2036624: c8 09 20 05 ldub [ %g4 + 5 ], %g4
2036628: b9 2f 20 18 sll %i4, 0x18, %i4
203662c: 89 29 20 10 sll %g4, 0x10, %g4
2036630: b8 17 00 04 or %i4, %g4, %i4
2036634: c8 08 e0 03 ldub [ %g3 + 3 ], %g4
block_size = rtems_rfs_fs_block_size (fs);
return (((uint64_t) (size->count - 1)) * block_size) + offset;
}
int
rtems_rfs_block_map_open (rtems_rfs_file_system* fs,
2036638: bb 28 a0 02 sll %g2, 2, %i5
203663c: b8 17 00 04 or %i4, %g4, %i4
2036640: c8 08 e0 02 ldub [ %g3 + 2 ], %g4
2036644: ba 06 80 1d add %i2, %i5, %i5
2036648: 89 29 20 08 sll %g4, 8, %g4
203664c: 86 17 00 04 or %i4, %g4, %g3
/*
* 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++)
2036650: 84 00 a0 01 inc %g2
2036654: 80 a0 a0 05 cmp %g2, 5
2036658: 12 bf ff ee bne 2036610 <rtems_rfs_block_map_open+0x58>
203665c: c6 27 60 24 st %g3, [ %i5 + 0x24 ]
* @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);
2036660: c6 08 60 0c ldub [ %g1 + 0xc ], %g3
2036664: c4 08 60 0d ldub [ %g1 + 0xd ], %g2
2036668: 87 28 e0 18 sll %g3, 0x18, %g3
203666c: 85 28 a0 10 sll %g2, 0x10, %g2
2036670: 84 10 c0 02 or %g3, %g2, %g2
2036674: c6 08 60 0f ldub [ %g1 + 0xf ], %g3
2036678: 84 10 80 03 or %g2, %g3, %g2
203667c: c6 08 60 0e ldub [ %g1 + 0xe ], %g3
2036680: 87 28 e0 08 sll %g3, 8, %g3
2036684: 84 10 80 03 or %g2, %g3, %g2
map->blocks[b] = rtems_rfs_inode_get_block (inode, b);
map->size.count = rtems_rfs_inode_get_block_count (inode);
2036688: c4 26 a0 08 st %g2, [ %i2 + 8 ]
map->size.offset = rtems_rfs_inode_get_block_offset (inode);
203668c: c6 08 60 0b ldub [ %g1 + 0xb ], %g3
* @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);
2036690: c4 08 60 0a ldub [ %g1 + 0xa ], %g2
2036694: 85 28 a0 08 sll %g2, 8, %g2
2036698: 84 10 c0 02 or %g3, %g2, %g2
203669c: c4 26 a0 0c st %g2, [ %i2 + 0xc ]
* @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);
20366a0: c6 08 60 30 ldub [ %g1 + 0x30 ], %g3
20366a4: c4 08 60 31 ldub [ %g1 + 0x31 ], %g2
20366a8: 87 28 e0 18 sll %g3, 0x18, %g3
20366ac: 85 28 a0 10 sll %g2, 0x10, %g2
20366b0: 84 10 c0 02 or %g3, %g2, %g2
20366b4: c6 08 60 33 ldub [ %g1 + 0x33 ], %g3
20366b8: 84 10 80 03 or %g2, %g3, %g2
20366bc: c6 08 60 32 ldub [ %g1 + 0x32 ], %g3
20366c0: 87 28 e0 08 sll %g3, 8, %g3
20366c4: 84 10 80 03 or %g2, %g3, %g2
map->last_map_block = rtems_rfs_inode_get_last_map_block (inode);
20366c8: c4 26 a0 1c st %g2, [ %i2 + 0x1c ]
* @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);
20366cc: c4 08 60 35 ldub [ %g1 + 0x35 ], %g2
20366d0: c6 08 60 34 ldub [ %g1 + 0x34 ], %g3
20366d4: 85 28 a0 10 sll %g2, 0x10, %g2
20366d8: 87 28 e0 18 sll %g3, 0x18, %g3
20366dc: 86 10 c0 02 or %g3, %g2, %g3
20366e0: c4 08 60 37 ldub [ %g1 + 0x37 ], %g2
20366e4: 86 10 c0 02 or %g3, %g2, %g3
20366e8: c4 08 60 36 ldub [ %g1 + 0x36 ], %g2
20366ec: 85 28 a0 08 sll %g2, 8, %g2
20366f0: 82 10 c0 02 or %g3, %g2, %g1
map->last_data_block = rtems_rfs_inode_get_last_data_block (inode);
20366f4: c2 26 a0 20 st %g1, [ %i2 + 0x20 ]
rc = rtems_rfs_inode_unload (fs, inode, false);
20366f8: 40 00 15 60 call 203bc78 <rtems_rfs_inode_unload>
20366fc: 95 e8 20 00 restore %g0, 0, %o2
*/
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);
2036700: 92 06 a0 38 add %i2, 0x38, %o1 <== NOT EXECUTED
2036704: 40 00 03 26 call 203739c <rtems_rfs_buffer_handle_release><== NOT EXECUTED
2036708: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
203670c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
handle->dirty = false;
2036710: c0 2e a0 38 clrb [ %i2 + 0x38 ] <== NOT EXECUTED
handle->bnum = 0;
2036714: c0 26 a0 3c clr [ %i2 + 0x3c ] <== NOT EXECUTED
handle->buffer = NULL;
2036718: c0 26 a0 40 clr [ %i2 + 0x40 ] <== 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);
203671c: 92 06 a0 44 add %i2, 0x44, %o1 <== NOT EXECUTED
2036720: 40 00 03 1f call 203739c <rtems_rfs_buffer_handle_release><== NOT EXECUTED
2036724: b0 10 00 1d mov %i5, %i0 <== NOT EXECUTED
handle->dirty = false;
2036728: c0 2e a0 44 clrb [ %i2 + 0x44 ] <== NOT EXECUTED
handle->bnum = 0;
203672c: c0 26 a0 48 clr [ %i2 + 0x48 ] <== NOT EXECUTED
handle->buffer = NULL;
2036730: c0 26 a0 4c clr [ %i2 + 0x4c ] <== NOT EXECUTED
return rc;
}
2036734: 81 c7 e0 08 ret <== NOT EXECUTED
2036738: 81 e8 00 00 restore <== NOT EXECUTED
02036ee4 <rtems_rfs_block_map_shrink>:
int
rtems_rfs_block_map_shrink (rtems_rfs_file_system* fs,
rtems_rfs_block_map* map,
size_t blocks)
{
2036ee4: 9d e3 bf a0 save %sp, -96, %sp
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BLOCK_MAP_SHRINK))
2036ee8: 90 10 20 00 clr %o0
2036eec: 7f ff b2 d8 call 2023a4c <rtems_rfs_trace>
2036ef0: 13 00 00 10 sethi %hi(0x4000), %o1
2036ef4: 80 8a 20 ff btst 0xff, %o0
2036ef8: 22 80 00 08 be,a 2036f18 <rtems_rfs_block_map_shrink+0x34><== ALWAYS TAKEN
2036efc: c2 06 60 08 ld [ %i1 + 8 ], %g1
printf ("rtems-rfs: block-map-shrink: entry: blocks=%zd count=%" PRIu32 "\n",
2036f00: d4 06 60 08 ld [ %i1 + 8 ], %o2 <== NOT EXECUTED
2036f04: 11 00 81 9c sethi %hi(0x2067000), %o0 <== NOT EXECUTED
2036f08: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED
2036f0c: 40 00 3e f7 call 2046ae8 <printf> <== NOT EXECUTED
2036f10: 90 12 21 e0 or %o0, 0x1e0, %o0 <== NOT EXECUTED
blocks, map->size.count);
if (map->size.count == 0)
2036f14: c2 06 60 08 ld [ %i1 + 8 ], %g1 <== NOT EXECUTED
2036f18: 80 a0 60 00 cmp %g1, 0
2036f1c: 12 80 00 04 bne 2036f2c <rtems_rfs_block_map_shrink+0x48>
2036f20: 80 a6 80 01 cmp %i2, %g1
* 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);
return 0;
2036f24: 10 80 00 b8 b 2037204 <rtems_rfs_block_map_shrink+0x320>
2036f28: 90 10 20 00 clr %o0
2036f2c: 38 80 00 90 bgu,a 203716c <rtems_rfs_block_map_shrink+0x288><== NEVER TAKEN
2036f30: b4 10 00 01 mov %g1, %i2 <== 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,
2036f34: 10 80 00 8f b 2037170 <rtems_rfs_block_map_shrink+0x28c>
2036f38: a4 06 60 44 add %i1, 0x44, %l2
{
rtems_rfs_block_no block;
rtems_rfs_block_no block_to_free;
int rc;
block = map->size.count - 1;
2036f3c: ba 00 7f ff add %g1, -1, %i5
if (block < RTEMS_RFS_INODE_BLOCKS)
2036f40: 80 a7 60 04 cmp %i5, 4
2036f44: 38 80 00 08 bgu,a 2036f64 <rtems_rfs_block_map_shrink+0x80>
2036f48: f6 06 20 34 ld [ %i0 + 0x34 ], %i3
{
/*
* We have less than RTEMS_RFS_INODE_BLOCKS so they are held in the
* inode.
*/
block_to_free = map->blocks[block];
2036f4c: 82 00 60 07 add %g1, 7, %g1
2036f50: 83 28 60 02 sll %g1, 2, %g1
2036f54: 82 06 40 01 add %i1, %g1, %g1
2036f58: fa 00 60 04 ld [ %g1 + 4 ], %i5
map->blocks[block] = 0;
2036f5c: 10 80 00 76 b 2037134 <rtems_rfs_block_map_shrink+0x250>
2036f60: c0 20 60 04 clr [ %g1 + 4 ]
* table of block numbers.
*/
rtems_rfs_block_no direct;
rtems_rfs_block_no singly;
direct = block % fs->blocks_per_block;
2036f64: 90 10 00 1d mov %i5, %o0
2036f68: 40 00 92 32 call 205b830 <.urem>
2036f6c: 92 10 00 1b mov %i3, %o1
singly = block / fs->blocks_per_block;
2036f70: 92 10 00 1b mov %i3, %o1
* table of block numbers.
*/
rtems_rfs_block_no direct;
rtems_rfs_block_no singly;
direct = block % fs->blocks_per_block;
2036f74: b8 10 00 08 mov %o0, %i4
singly = block / fs->blocks_per_block;
2036f78: 40 00 91 82 call 205b580 <.udiv>
2036f7c: 90 10 00 1d mov %i5, %o0
if (block < fs->block_map_singly_blocks)
2036f80: c2 06 20 38 ld [ %i0 + 0x38 ], %g1
2036f84: 80 a7 40 01 cmp %i5, %g1
2036f88: 1a 80 00 20 bcc 2037008 <rtems_rfs_block_map_shrink+0x124><== NEVER TAKEN
2036f8c: a2 10 00 08 mov %o0, %l1
{
/*
* Request the indirect block and then obtain the block number from the
* indirect block.
*/
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
2036f90: 82 02 20 08 add %o0, 8, %g1
2036f94: 83 28 60 02 sll %g1, 2, %g1
2036f98: 82 06 40 01 add %i1, %g1, %g1
2036f9c: d4 00 60 04 ld [ %g1 + 4 ], %o2
2036fa0: 90 10 00 18 mov %i0, %o0
2036fa4: 92 10 00 10 mov %l0, %o1
2036fa8: 40 00 01 71 call 203756c <rtems_rfs_buffer_handle_request>
2036fac: 96 10 20 01 mov 1, %o3
map->blocks[singly], true);
if (rc > 0)
2036fb0: 80 a2 20 00 cmp %o0, 0
2036fb4: 14 80 00 94 bg 2037204 <rtems_rfs_block_map_shrink+0x320> <== NEVER TAKEN
2036fb8: 85 2f 20 02 sll %i4, 2, %g2
return rc;
block_to_free = rtems_rfs_block_get_number (&map->singly_buffer,
2036fbc: c2 06 60 40 ld [ %i1 + 0x40 ], %g1
2036fc0: c6 00 60 1c ld [ %g1 + 0x1c ], %g3
direct);
rc = rtems_rfs_block_map_indirect_shrink (fs, map, &map->singly_buffer,
2036fc4: 90 10 00 18 mov %i0, %o0
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,
2036fc8: 82 00 c0 02 add %g3, %g2, %g1
2036fcc: fa 08 c0 02 ldub [ %g3 + %g2 ], %i5
2036fd0: c8 08 60 03 ldub [ %g1 + 3 ], %g4
2036fd4: c4 08 60 01 ldub [ %g1 + 1 ], %g2
2036fd8: c2 08 60 02 ldub [ %g1 + 2 ], %g1
2036fdc: bb 2f 60 18 sll %i5, 0x18, %i5
2036fe0: 85 28 a0 10 sll %g2, 0x10, %g2
2036fe4: ba 11 00 1d or %g4, %i5, %i5
2036fe8: 83 28 60 08 sll %g1, 8, %g1
2036fec: ba 17 40 02 or %i5, %g2, %i5
direct);
rc = rtems_rfs_block_map_indirect_shrink (fs, map, &map->singly_buffer,
2036ff0: 92 10 00 19 mov %i1, %o1
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,
2036ff4: ba 17 40 01 or %i5, %g1, %i5
direct);
rc = rtems_rfs_block_map_indirect_shrink (fs, map, &map->singly_buffer,
2036ff8: 94 10 00 10 mov %l0, %o2
2036ffc: 96 10 00 11 mov %l1, %o3
2037000: 10 80 00 48 b 2037120 <rtems_rfs_block_map_shrink+0x23c>
2037004: 98 10 00 1c mov %i4, %o4
singly, direct);
if (rc)
return rc;
}
else if (block < fs->block_map_doubly_blocks)
2037008: c2 06 20 3c ld [ %i0 + 0x3c ], %g1 <== NOT EXECUTED
203700c: 80 a7 40 01 cmp %i5, %g1 <== NOT EXECUTED
2037010: 3a 80 00 5d bcc,a 2037184 <rtems_rfs_block_map_shrink+0x2a0><== NOT EXECUTED
2037014: c2 06 60 08 ld [ %i1 + 8 ], %g1 <== 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;
2037018: 40 00 91 5a call 205b580 <.udiv> <== NOT EXECUTED
203701c: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
doubly_singly = singly % fs->blocks_per_block;
2037020: 92 10 00 1b mov %i3, %o1 <== 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;
2037024: a8 10 00 08 mov %o0, %l4 <== NOT EXECUTED
doubly_singly = singly % fs->blocks_per_block;
2037028: 40 00 92 02 call 205b830 <.urem> <== NOT EXECUTED
203702c: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED
rc = rtems_rfs_buffer_handle_request (fs, &map->doubly_buffer,
2037030: 82 05 20 08 add %l4, 8, %g1 <== NOT EXECUTED
2037034: 83 28 60 02 sll %g1, 2, %g1 <== NOT EXECUTED
2037038: 82 06 40 01 add %i1, %g1, %g1 <== NOT EXECUTED
203703c: d4 00 60 04 ld [ %g1 + 4 ], %o2 <== 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;
2037040: a2 10 00 08 mov %o0, %l1 <== NOT EXECUTED
rc = rtems_rfs_buffer_handle_request (fs, &map->doubly_buffer,
2037044: 92 10 00 12 mov %l2, %o1 <== NOT EXECUTED
2037048: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
203704c: 40 00 01 48 call 203756c <rtems_rfs_buffer_handle_request><== NOT EXECUTED
2037050: 96 10 20 01 mov 1, %o3 <== NOT EXECUTED
map->blocks[doubly], true);
if (rc > 0)
2037054: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2037058: 14 80 00 6b bg 2037204 <rtems_rfs_block_map_shrink+0x320> <== NOT EXECUTED
203705c: 85 2c 60 02 sll %l1, 2, %g2 <== NOT EXECUTED
return rc;
singly = rtems_rfs_block_get_number (&map->doubly_buffer,
2037060: c2 06 60 4c ld [ %i1 + 0x4c ], %g1 <== NOT EXECUTED
2037064: c6 00 60 1c ld [ %g1 + 0x1c ], %g3 <== NOT EXECUTED
doubly_singly);
/*
* Read the singly indirect table and get the block number.
*/
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
2037068: 90 10 00 18 mov %i0, %o0 <== 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,
203706c: 82 00 c0 02 add %g3, %g2, %g1 <== NOT EXECUTED
2037070: f6 08 c0 02 ldub [ %g3 + %g2 ], %i3 <== NOT EXECUTED
2037074: c8 08 60 03 ldub [ %g1 + 3 ], %g4 <== NOT EXECUTED
2037078: c4 08 60 01 ldub [ %g1 + 1 ], %g2 <== NOT EXECUTED
203707c: c2 08 60 02 ldub [ %g1 + 2 ], %g1 <== NOT EXECUTED
2037080: 85 28 a0 10 sll %g2, 0x10, %g2 <== NOT EXECUTED
2037084: 83 28 60 08 sll %g1, 8, %g1 <== NOT EXECUTED
2037088: b7 2e e0 18 sll %i3, 0x18, %i3 <== NOT EXECUTED
doubly_singly);
/*
* Read the singly indirect table and get the block number.
*/
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
203708c: 92 10 00 10 mov %l0, %o1 <== 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,
2037090: b6 11 00 1b or %g4, %i3, %i3 <== NOT EXECUTED
doubly_singly);
/*
* Read the singly indirect table and get the block number.
*/
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
2037094: 96 10 20 01 mov 1, %o3 <== 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,
2037098: b6 16 c0 02 or %i3, %g2, %i3 <== NOT EXECUTED
203709c: b6 16 c0 01 or %i3, %g1, %i3 <== NOT EXECUTED
doubly_singly);
/*
* Read the singly indirect table and get the block number.
*/
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
20370a0: 40 00 01 33 call 203756c <rtems_rfs_buffer_handle_request><== NOT EXECUTED
20370a4: 94 10 00 1b mov %i3, %o2 <== NOT EXECUTED
singly, true);
if (rc > 0)
20370a8: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
20370ac: 14 80 00 56 bg 2037204 <rtems_rfs_block_map_shrink+0x320> <== NOT EXECUTED
20370b0: 85 2f 20 02 sll %i4, 2, %g2 <== NOT EXECUTED
return rc;
block_to_free = rtems_rfs_block_get_number (&map->singly_buffer,
20370b4: c2 06 60 40 ld [ %i1 + 0x40 ], %g1 <== NOT EXECUTED
20370b8: c6 00 60 1c ld [ %g1 + 0x1c ], %g3 <== NOT EXECUTED
direct);
if (direct == 0)
20370bc: 80 a7 20 00 cmp %i4, 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,
20370c0: 82 00 c0 02 add %g3, %g2, %g1 <== NOT EXECUTED
20370c4: fa 08 c0 02 ldub [ %g3 + %g2 ], %i5 <== NOT EXECUTED
20370c8: c8 08 60 03 ldub [ %g1 + 3 ], %g4 <== NOT EXECUTED
20370cc: c4 08 60 01 ldub [ %g1 + 1 ], %g2 <== NOT EXECUTED
20370d0: c2 08 60 02 ldub [ %g1 + 2 ], %g1 <== NOT EXECUTED
20370d4: bb 2f 60 18 sll %i5, 0x18, %i5 <== NOT EXECUTED
20370d8: 85 28 a0 10 sll %g2, 0x10, %g2 <== NOT EXECUTED
20370dc: ba 11 00 1d or %g4, %i5, %i5 <== NOT EXECUTED
20370e0: 83 28 60 08 sll %g1, 8, %g1 <== NOT EXECUTED
20370e4: ba 17 40 02 or %i5, %g2, %i5 <== NOT EXECUTED
direct);
if (direct == 0)
20370e8: 12 80 00 13 bne 2037134 <rtems_rfs_block_map_shrink+0x250><== NOT EXECUTED
20370ec: ba 17 40 01 or %i5, %g1, %i5 <== NOT EXECUTED
{
rc = rtems_rfs_group_bitmap_free (fs, false, singly);
20370f0: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
20370f4: 92 10 20 00 clr %o1 <== NOT EXECUTED
20370f8: 40 00 11 d9 call 203b85c <rtems_rfs_group_bitmap_free> <== NOT EXECUTED
20370fc: 94 10 00 1b mov %i3, %o2 <== NOT EXECUTED
if (rc > 0)
2037100: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2037104: 14 80 00 40 bg 2037204 <rtems_rfs_block_map_shrink+0x320> <== NOT EXECUTED
2037108: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
return rc;
map->last_map_block = singly;
203710c: f6 26 60 1c st %i3, [ %i1 + 0x1c ] <== NOT EXECUTED
rc = rtems_rfs_block_map_indirect_shrink (fs, map, &map->doubly_buffer,
2037110: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
2037114: 94 10 00 12 mov %l2, %o2 <== NOT EXECUTED
2037118: 96 10 00 14 mov %l4, %o3 <== NOT EXECUTED
203711c: 98 10 00 11 mov %l1, %o4 <== NOT EXECUTED
2037120: 7f ff fc 28 call 20361c0 <rtems_rfs_block_map_indirect_shrink>
2037124: 01 00 00 00 nop
doubly, doubly_singly);
if (rc)
2037128: 80 a2 20 00 cmp %o0, 0
203712c: 12 80 00 36 bne 2037204 <rtems_rfs_block_map_shrink+0x320><== NEVER TAKEN
2037130: 01 00 00 00 nop
{
rc = EIO;
break;
}
}
rc = rtems_rfs_group_bitmap_free (fs, false, block_to_free);
2037134: 90 10 00 18 mov %i0, %o0
2037138: 92 10 20 00 clr %o1
203713c: 40 00 11 c8 call 203b85c <rtems_rfs_group_bitmap_free>
2037140: 94 10 00 1d mov %i5, %o2
if (rc > 0)
2037144: 80 a2 20 00 cmp %o0, 0
2037148: 14 80 00 2f bg 2037204 <rtems_rfs_block_map_shrink+0x320> <== NEVER TAKEN
203714c: b4 06 bf ff add %i2, -1, %i2
return rc;
map->size.count--;
2037150: c2 06 60 08 ld [ %i1 + 8 ], %g1
map->size.offset = 0;
2037154: c0 26 60 0c clr [ %i1 + 0xc ]
}
}
rc = rtems_rfs_group_bitmap_free (fs, false, block_to_free);
if (rc > 0)
return rc;
map->size.count--;
2037158: 82 00 7f ff add %g1, -1, %g1
map->size.offset = 0;
map->last_data_block = block_to_free;
203715c: fa 26 60 20 st %i5, [ %i1 + 0x20 ]
}
}
rc = rtems_rfs_group_bitmap_free (fs, false, block_to_free);
if (rc > 0)
return rc;
map->size.count--;
2037160: c2 26 60 08 st %g1, [ %i1 + 8 ]
map->size.offset = 0;
map->last_data_block = block_to_free;
map->dirty = true;
2037164: 10 80 00 05 b 2037178 <rtems_rfs_block_map_shrink+0x294>
2037168: e6 2e 40 00 stb %l3, [ %i1 ]
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,
203716c: a4 06 60 44 add %i1, 0x44, %l2 <== NOT EXECUTED
doubly_singly);
/*
* Read the singly indirect table and get the block number.
*/
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
2037170: a0 06 60 38 add %i1, 0x38, %l0
if (rc > 0)
return rc;
map->size.count--;
map->size.offset = 0;
map->last_data_block = block_to_free;
map->dirty = true;
2037174: a6 10 20 01 mov 1, %l3
return 0;
if (blocks > map->size.count)
blocks = map->size.count;
while (blocks)
2037178: 80 a6 a0 00 cmp %i2, 0
203717c: 12 bf ff 70 bne 2036f3c <rtems_rfs_block_map_shrink+0x58>
2037180: c2 06 60 08 ld [ %i1 + 8 ], %g1
map->last_data_block = block_to_free;
map->dirty = true;
blocks--;
}
if (map->size.count == 0)
2037184: 80 a0 60 00 cmp %g1, 0
2037188: 32 80 00 05 bne,a 203719c <rtems_rfs_block_map_shrink+0x2b8>
203718c: c4 06 60 10 ld [ %i1 + 0x10 ], %g2
{
map->last_map_block = 0;
2037190: c0 26 60 1c clr [ %i1 + 0x1c ]
map->last_data_block = 0;
2037194: c0 26 60 20 clr [ %i1 + 0x20 ]
}
/*
* Keep the position inside the map.
*/
if (rtems_rfs_block_pos_past_end (&map->bpos, &map->size))
2037198: c4 06 60 10 ld [ %i1 + 0x10 ], %g2
203719c: 80 a0 a0 00 cmp %g2, 0
20371a0: 02 80 00 06 be 20371b8 <rtems_rfs_block_map_shrink+0x2d4>
20371a4: 80 a0 80 01 cmp %g2, %g1
20371a8: 80 a0 60 00 cmp %g1, 0
20371ac: 22 80 00 0e be,a 20371e4 <rtems_rfs_block_map_shrink+0x300><== ALWAYS TAKEN
20371b0: c4 06 60 0c ld [ %i1 + 0xc ], %g2
20371b4: 80 a0 80 01 cmp %g2, %g1 <== NOT EXECUTED
20371b8: 3a 80 00 0b bcc,a 20371e4 <rtems_rfs_block_map_shrink+0x300>
20371bc: c4 06 60 0c ld [ %i1 + 0xc ], %g2
20371c0: 86 00 7f ff add %g1, -1, %g3
20371c4: 80 a0 80 03 cmp %g2, %g3
20371c8: 12 80 00 0f bne 2037204 <rtems_rfs_block_map_shrink+0x320><== NEVER TAKEN
20371cc: 90 10 20 00 clr %o0
20371d0: c6 06 60 14 ld [ %i1 + 0x14 ], %g3
20371d4: c4 06 60 0c ld [ %i1 + 0xc ], %g2
20371d8: 80 a0 c0 02 cmp %g3, %g2
20371dc: 08 80 00 0a bleu 2037204 <rtems_rfs_block_map_shrink+0x320><== NEVER TAKEN
20371e0: 01 00 00 00 nop
rtems_rfs_block_size_get_bpos (&map->size, &map->bpos);
20371e4: c2 26 60 10 st %g1, [ %i1 + 0x10 ]
20371e8: c4 26 60 14 st %g2, [ %i1 + 0x14 ]
20371ec: 80 a0 a0 00 cmp %g2, 0
20371f0: 02 80 00 04 be 2037200 <rtems_rfs_block_map_shrink+0x31c> <== ALWAYS TAKEN
20371f4: c0 26 60 18 clr [ %i1 + 0x18 ]
20371f8: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED
20371fc: c2 26 60 10 st %g1, [ %i1 + 0x10 ] <== NOT EXECUTED
return 0;
2037200: 90 10 20 00 clr %o0
}
2037204: 81 c7 e0 08 ret
2037208: 91 e8 00 08 restore %g0, %o0, %o0
02041ae4 <rtems_rfs_buffer_bdbuf_release>:
int
rtems_rfs_buffer_bdbuf_release (rtems_rfs_buffer* buffer,
bool modified)
{
2041ae4: 9d e3 bf a0 save %sp, -96, %sp
rtems_status_code sc;
int rc = 0;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_RELEASE))
2041ae8: 90 10 20 00 clr %o0
2041aec: 7f ff 87 d8 call 2023a4c <rtems_rfs_trace>
2041af0: 92 10 20 40 mov 0x40, %o1
2041af4: 80 8a 20 ff btst 0xff, %o0
2041af8: 02 80 00 0e be 2041b30 <rtems_rfs_buffer_bdbuf_release+0x4c><== ALWAYS TAKEN
2041afc: 80 a6 60 00 cmp %i1, 0
printf ("rtems-rfs: bdbuf-release: block=%" PRIuPTR " bdbuf=%" PRIu32 " %s\n",
2041b00: d2 06 20 34 ld [ %i0 + 0x34 ], %o1 <== NOT EXECUTED
2041b04: 02 80 00 05 be 2041b18 <rtems_rfs_buffer_bdbuf_release+0x34><== NOT EXECUTED
2041b08: d4 06 20 18 ld [ %i0 + 0x18 ], %o2 <== NOT EXECUTED
2041b0c: 17 00 81 a7 sethi %hi(0x2069c00), %o3 <== NOT EXECUTED
2041b10: 10 80 00 04 b 2041b20 <rtems_rfs_buffer_bdbuf_release+0x3c><== NOT EXECUTED
2041b14: 96 12 e0 e8 or %o3, 0xe8, %o3 ! 2069ce8 <msdos_map+0x100> <== NOT EXECUTED
2041b18: 17 00 81 82 sethi %hi(0x2060800), %o3 <== NOT EXECUTED
2041b1c: 96 12 e0 10 or %o3, 0x10, %o3 ! 2060810 <rtems_bdpart_shell_usage+0xc40><== NOT EXECUTED
2041b20: 11 00 81 a7 sethi %hi(0x2069c00), %o0 <== NOT EXECUTED
2041b24: 40 00 13 f1 call 2046ae8 <printf> <== NOT EXECUTED
2041b28: 90 12 20 f8 or %o0, 0xf8, %o0 ! 2069cf8 <msdos_map+0x110> <== NOT EXECUTED
((intptr_t) buffer->user),
buffer->block, modified ? "(modified)" : "");
if (modified)
2041b2c: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED
2041b30: 02 80 00 06 be 2041b48 <rtems_rfs_buffer_bdbuf_release+0x64>
2041b34: 90 10 00 18 mov %i0, %o0
sc = rtems_bdbuf_release_modified (buffer);
2041b38: 7f ff 13 82 call 2006940 <rtems_bdbuf_release_modified>
2041b3c: 01 00 00 00 nop
int
rtems_rfs_buffer_bdbuf_release (rtems_rfs_buffer* buffer,
bool modified)
{
rtems_status_code sc;
int rc = 0;
2041b40: 10 80 00 05 b 2041b54 <rtems_rfs_buffer_bdbuf_release+0x70>
2041b44: 80 a0 00 08 cmp %g0, %o0
buffer->block, modified ? "(modified)" : "");
if (modified)
sc = rtems_bdbuf_release_modified (buffer);
else
sc = rtems_bdbuf_release (buffer);
2041b48: 7f ff 13 49 call 200686c <rtems_bdbuf_release>
2041b4c: 01 00 00 00 nop
int
rtems_rfs_buffer_bdbuf_release (rtems_rfs_buffer* buffer,
bool modified)
{
rtems_status_code sc;
int rc = 0;
2041b50: 80 a0 00 08 cmp %g0, %o0
2041b54: b0 60 20 00 subx %g0, 0, %i0
#endif
rc = EIO;
}
return rc;
}
2041b58: b0 0e 20 05 and %i0, 5, %i0
2041b5c: 81 c7 e0 08 ret
2041b60: 81 e8 00 00 restore
02037b70 <rtems_rfs_buffer_close>:
return 0;
}
int
rtems_rfs_buffer_close (rtems_rfs_file_system* fs)
{
2037b70: 9d e3 bf a0 save %sp, -96, %sp
int rc = 0;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CLOSE))
2037b74: 90 10 20 00 clr %o0
2037b78: 7f ff af b5 call 2023a4c <rtems_rfs_trace>
2037b7c: 92 10 20 10 mov 0x10, %o1
2037b80: 80 8a 20 ff btst 0xff, %o0
2037b84: 22 80 00 06 be,a 2037b9c <rtems_rfs_buffer_close+0x2c> <== ALWAYS TAKEN
2037b88: c2 06 20 10 ld [ %i0 + 0x10 ], %g1
printf ("rtems-rfs: buffer-close: closing\n");
2037b8c: 11 00 81 9d sethi %hi(0x2067400), %o0 <== NOT EXECUTED
2037b90: 40 00 3c 6e call 2046d48 <puts> <== NOT EXECUTED
2037b94: 90 12 22 b8 or %o0, 0x2b8, %o0 ! 20676b8 <__FUNCTION__.7829+0x5c8><== 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));
2037b98: c2 06 20 10 ld [ %i0 + 0x10 ], %g1 <== NOT EXECUTED
2037b9c: 90 10 00 18 mov %i0, %o0
2037ba0: 7f ff ff b9 call 2037a84 <rtems_rfs_buffer_setblksize>
2037ba4: d2 00 60 20 ld [ %g1 + 0x20 ], %o1
if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CLOSE))
2037ba8: ba 92 20 00 orcc %o0, 0, %i5
2037bac: 04 80 00 0e ble 2037be4 <rtems_rfs_buffer_close+0x74> <== ALWAYS TAKEN
2037bb0: 90 10 20 00 clr %o0
2037bb4: 7f ff af a6 call 2023a4c <rtems_rfs_trace> <== NOT EXECUTED
2037bb8: 92 10 20 10 mov 0x10, %o1 <== NOT EXECUTED
2037bbc: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
2037bc0: 02 80 00 09 be 2037be4 <rtems_rfs_buffer_close+0x74> <== NOT EXECUTED
2037bc4: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: buffer-close: set media block size failed: %d: %s\n",
2037bc8: 40 00 45 47 call 20490e4 <strerror> <== NOT EXECUTED
2037bcc: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
2037bd0: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
2037bd4: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
2037bd8: 11 00 81 9d sethi %hi(0x2067400), %o0 <== NOT EXECUTED
2037bdc: 40 00 3b c3 call 2046ae8 <printf> <== NOT EXECUTED
2037be0: 90 12 22 e0 or %o0, 0x2e0, %o0 ! 20676e0 <__FUNCTION__.7829+0x5f0><== NOT EXECUTED
rc, strerror (rc));
if (close (fs->device) < 0)
2037be4: 7f ff 43 48 call 2008904 <close>
2037be8: d0 06 20 0c ld [ %i0 + 0xc ], %o0
2037bec: 80 a2 20 00 cmp %o0, 0
2037bf0: 16 80 00 12 bge 2037c38 <rtems_rfs_buffer_close+0xc8> <== ALWAYS TAKEN
2037bf4: 01 00 00 00 nop
{
rc = errno;
2037bf8: 40 00 29 7d call 20421ec <__errno> <== NOT EXECUTED
2037bfc: 01 00 00 00 nop <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CLOSE))
2037c00: 92 10 20 10 mov 0x10, %o1 ! 10 <PROM_START+0x10> <== NOT EXECUTED
printf ("rtems-rfs: buffer-close: set media block size failed: %d: %s\n",
rc, strerror (rc));
if (close (fs->device) < 0)
{
rc = errno;
2037c04: fa 02 00 00 ld [ %o0 ], %i5 <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CLOSE))
2037c08: 7f ff af 91 call 2023a4c <rtems_rfs_trace> <== NOT EXECUTED
2037c0c: 90 10 20 00 clr %o0 <== NOT EXECUTED
2037c10: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
2037c14: 02 80 00 09 be 2037c38 <rtems_rfs_buffer_close+0xc8> <== NOT EXECUTED
2037c18: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: buffer-close: file close failed: %d: %s\n",
2037c1c: 40 00 45 32 call 20490e4 <strerror> <== NOT EXECUTED
2037c20: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
2037c24: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
2037c28: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
2037c2c: 11 00 81 9d sethi %hi(0x2067400), %o0 <== NOT EXECUTED
2037c30: 40 00 3b ae call 2046ae8 <printf> <== NOT EXECUTED
2037c34: 90 12 23 20 or %o0, 0x320, %o0 ! 2067720 <__FUNCTION__.7829+0x630><== NOT EXECUTED
rc, strerror (rc));
}
return rc;
}
2037c38: 81 c7 e0 08 ret
2037c3c: 91 e8 00 1d restore %g0, %i5, %o0
0203739c <rtems_rfs_buffer_handle_release>:
}
int
rtems_rfs_buffer_handle_release (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
203739c: 9d e3 bf a0 save %sp, -96, %sp
int rc = 0;
if (rtems_rfs_buffer_handle_has_block (handle))
20373a0: c2 06 60 08 ld [ %i1 + 8 ], %g1
}
int
rtems_rfs_buffer_handle_release (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
20373a4: ba 10 00 18 mov %i0, %i5
int rc = 0;
if (rtems_rfs_buffer_handle_has_block (handle))
20373a8: 80 a0 60 00 cmp %g1, 0
20373ac: 02 80 00 6e be 2037564 <rtems_rfs_buffer_handle_release+0x1c8>
20373b0: b0 10 20 00 clr %i0
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_RELEASE))
20373b4: 90 10 20 00 clr %o0
20373b8: 7f ff b1 a5 call 2023a4c <rtems_rfs_trace>
20373bc: 92 10 22 00 mov 0x200, %o1
20373c0: 80 8a 20 ff btst 0xff, %o0
20373c4: 22 80 00 18 be,a 2037424 <rtems_rfs_buffer_handle_release+0x88><== ALWAYS TAKEN
20373c8: d0 06 60 08 ld [ %i1 + 8 ], %o0
printf ("rtems-rfs: buffer-release: block=%" PRIu32 " %s refs=%d %s\n",
20373cc: c2 0e 40 00 ldub [ %i1 ], %g1 <== NOT EXECUTED
20373d0: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
20373d4: 02 80 00 05 be 20373e8 <rtems_rfs_buffer_handle_release+0x4c><== NOT EXECUTED
20373d8: d2 06 60 04 ld [ %i1 + 4 ], %o1 <== NOT EXECUTED
20373dc: 15 00 81 9c sethi %hi(0x2067000), %o2 <== NOT EXECUTED
20373e0: 10 80 00 04 b 20373f0 <rtems_rfs_buffer_handle_release+0x54><== NOT EXECUTED
20373e4: 94 12 a2 a8 or %o2, 0x2a8, %o2 ! 20672a8 <__FUNCTION__.7829+0x1b8><== NOT EXECUTED
20373e8: 15 00 81 82 sethi %hi(0x2060800), %o2 <== NOT EXECUTED
20373ec: 94 12 a0 10 or %o2, 0x10, %o2 ! 2060810 <rtems_bdpart_shell_usage+0xc40><== 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" : "");
20373f0: c2 06 60 08 ld [ %i1 + 8 ], %g1 <== NOT EXECUTED
20373f4: d6 00 60 30 ld [ %g1 + 0x30 ], %o3 <== 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",
20373f8: 80 a2 e0 00 cmp %o3, 0 <== NOT EXECUTED
20373fc: 32 80 00 05 bne,a 2037410 <rtems_rfs_buffer_handle_release+0x74><== NOT EXECUTED
2037400: 19 00 81 82 sethi %hi(0x2060800), %o4 <== NOT EXECUTED
2037404: 19 00 81 9c sethi %hi(0x2067000), %o4 <== NOT EXECUTED
2037408: 10 80 00 03 b 2037414 <rtems_rfs_buffer_handle_release+0x78><== NOT EXECUTED
203740c: 98 13 22 b0 or %o4, 0x2b0, %o4 ! 20672b0 <__FUNCTION__.7829+0x1c0><== NOT EXECUTED
2037410: 98 13 20 10 or %o4, 0x10, %o4 <== NOT EXECUTED
2037414: 11 00 81 9c sethi %hi(0x2067000), %o0 <== NOT EXECUTED
2037418: 40 00 3d b4 call 2046ae8 <printf> <== NOT EXECUTED
203741c: 90 12 22 c0 or %o0, 0x2c0, %o0 ! 20672c0 <__FUNCTION__.7829+0x1d0><== 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)
2037420: d0 06 60 08 ld [ %i1 + 8 ], %o0 <== NOT EXECUTED
2037424: c2 02 20 30 ld [ %o0 + 0x30 ], %g1
2037428: 80 a0 60 00 cmp %g1, 0
203742c: 04 80 00 03 ble 2037438 <rtems_rfs_buffer_handle_release+0x9c><== NEVER TAKEN
2037430: 82 00 7f ff add %g1, -1, %g1
rtems_rfs_buffer_refs_down (handle);
2037434: c2 22 20 30 st %g1, [ %o0 + 0x30 ]
if (rtems_rfs_buffer_refs (handle) == 0)
2037438: c2 02 20 30 ld [ %o0 + 0x30 ], %g1
203743c: 80 a0 60 00 cmp %g1, 0
2037440: 12 80 00 48 bne 2037560 <rtems_rfs_buffer_handle_release+0x1c4>
2037444: b0 10 20 00 clr %i0
2037448: 7f ff cf 87 call 202b264 <_Chain_Extract>
203744c: 01 00 00 00 nop
{
rtems_chain_extract (rtems_rfs_buffer_link (handle));
fs->buffers_count--;
2037450: c2 07 60 50 ld [ %i5 + 0x50 ], %g1
if (rtems_rfs_fs_no_local_cache (fs))
2037454: f0 07 40 00 ld [ %i5 ], %i0
rtems_rfs_buffer_refs_down (handle);
if (rtems_rfs_buffer_refs (handle) == 0)
{
rtems_chain_extract (rtems_rfs_buffer_link (handle));
fs->buffers_count--;
2037458: 82 00 7f ff add %g1, -1, %g1
if (rtems_rfs_fs_no_local_cache (fs))
203745c: b0 8e 20 02 andcc %i0, 2, %i0
2037460: 02 80 00 08 be 2037480 <rtems_rfs_buffer_handle_release+0xe4>
2037464: c2 27 60 50 st %g1, [ %i5 + 0x50 ]
{
handle->buffer->user = (void*) 0;
2037468: d0 06 60 08 ld [ %i1 + 8 ], %o0
rc = rtems_rfs_buffer_io_release (handle->buffer,
203746c: d2 0e 40 00 ldub [ %i1 ], %o1
2037470: 40 00 29 9d call 2041ae4 <rtems_rfs_buffer_bdbuf_release>
2037474: c0 22 20 34 clr [ %o0 + 0x34 ]
2037478: 10 80 00 3a b 2037560 <rtems_rfs_buffer_handle_release+0x1c4>
203747c: b0 10 00 08 mov %o0, %i0
* 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 +
2037480: c2 07 60 60 ld [ %i5 + 0x60 ], %g1
2037484: c4 07 60 70 ld [ %i5 + 0x70 ], %g2
2037488: 84 00 80 01 add %g2, %g1, %g2
203748c: c2 07 60 40 ld [ %i5 + 0x40 ], %g1
2037490: 80 a0 80 01 cmp %g2, %g1
2037494: 2a 80 00 25 bcs,a 2037528 <rtems_rfs_buffer_handle_release+0x18c>
2037498: c2 0e 40 00 ldub [ %i1 ], %g1
fs->release_modified_count) >= fs->max_held_buffers)
{
rtems_rfs_buffer* buffer;
bool modified;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_RELEASE))
203749c: 90 10 20 00 clr %o0
20374a0: 7f ff b1 6b call 2023a4c <rtems_rfs_trace>
20374a4: 92 10 22 00 mov 0x200, %o1
20374a8: 80 8a 20 ff btst 0xff, %o0
20374ac: 22 80 00 09 be,a 20374d0 <rtems_rfs_buffer_handle_release+0x134><== ALWAYS TAKEN
20374b0: c4 07 60 60 ld [ %i5 + 0x60 ], %g2
printf ("rtems-rfs: buffer-release: local cache overflow:"
20374b4: d2 07 60 70 ld [ %i5 + 0x70 ], %o1 <== NOT EXECUTED
20374b8: c2 07 60 60 ld [ %i5 + 0x60 ], %g1 <== NOT EXECUTED
20374bc: 11 00 81 9c sethi %hi(0x2067000), %o0 <== NOT EXECUTED
20374c0: 92 02 40 01 add %o1, %g1, %o1 <== NOT EXECUTED
20374c4: 40 00 3d 89 call 2046ae8 <printf> <== NOT EXECUTED
20374c8: 90 12 22 f8 or %o0, 0x2f8, %o0 <== NOT EXECUTED
" %" PRIu32 "\n", fs->release_count + fs->release_modified_count);
if (fs->release_count > fs->release_modified_count)
20374cc: c4 07 60 60 ld [ %i5 + 0x60 ], %g2 <== NOT EXECUTED
20374d0: c2 07 60 70 ld [ %i5 + 0x70 ], %g1
20374d4: 80 a0 80 01 cmp %g2, %g1
20374d8: 08 80 00 09 bleu 20374fc <rtems_rfs_buffer_handle_release+0x160>
20374dc: 01 00 00 00 nop
*/
RTEMS_INLINE_ROUTINE rtems_chain_node *rtems_chain_get(
rtems_chain_control *the_chain
)
{
return _Chain_Get( the_chain );
20374e0: 7f ff 5b 47 call 200e1fc <_Chain_Get>
20374e4: 90 07 60 54 add %i5, 0x54, %o0
{
buffer = (rtems_rfs_buffer*) rtems_chain_get (&fs->release);
fs->release_count--;
20374e8: c2 07 60 60 ld [ %i5 + 0x60 ], %g1
modified = false;
20374ec: 92 10 20 00 clr %o1
" %" 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--;
20374f0: 82 00 7f ff add %g1, -1, %g1
20374f4: 10 80 00 08 b 2037514 <rtems_rfs_buffer_handle_release+0x178>
20374f8: c2 27 60 60 st %g1, [ %i5 + 0x60 ]
20374fc: 7f ff 5b 40 call 200e1fc <_Chain_Get>
2037500: 90 07 60 64 add %i5, 0x64, %o0
}
else
{
buffer =
(rtems_rfs_buffer*) rtems_chain_get (&fs->release_modified);
fs->release_modified_count--;
2037504: c2 07 60 70 ld [ %i5 + 0x70 ], %g1
modified = true;
2037508: 92 10 20 01 mov 1, %o1
}
else
{
buffer =
(rtems_rfs_buffer*) rtems_chain_get (&fs->release_modified);
fs->release_modified_count--;
203750c: 82 00 7f ff add %g1, -1, %g1
2037510: c2 27 60 70 st %g1, [ %i5 + 0x70 ]
modified = true;
}
buffer->user = (void*) 0;
2037514: c0 22 20 34 clr [ %o0 + 0x34 ]
rc = rtems_rfs_buffer_io_release (buffer, modified);
2037518: 40 00 29 73 call 2041ae4 <rtems_rfs_buffer_bdbuf_release>
203751c: 92 0a 60 01 and %o1, 1, %o1
2037520: b0 10 00 08 mov %o0, %i0
}
if (rtems_rfs_buffer_dirty (handle))
2037524: c2 0e 40 00 ldub [ %i1 ], %g1
2037528: 80 a0 60 00 cmp %g1, 0
203752c: 02 80 00 08 be 203754c <rtems_rfs_buffer_handle_release+0x1b0>
2037530: d2 06 60 08 ld [ %i1 + 8 ], %o1
RTEMS_INLINE_ROUTINE void rtems_chain_append(
rtems_chain_control *the_chain,
rtems_chain_node *the_node
)
{
_Chain_Append( the_chain, the_node );
2037534: 7f ff 5b 26 call 200e1cc <_Chain_Append>
2037538: 90 07 60 64 add %i5, 0x64, %o0
{
rtems_chain_append (&fs->release_modified,
rtems_rfs_buffer_link (handle));
fs->release_modified_count++;
203753c: c2 07 60 70 ld [ %i5 + 0x70 ], %g1
2037540: 82 00 60 01 inc %g1
2037544: 10 80 00 07 b 2037560 <rtems_rfs_buffer_handle_release+0x1c4>
2037548: c2 27 60 70 st %g1, [ %i5 + 0x70 ]
203754c: 7f ff 5b 20 call 200e1cc <_Chain_Append>
2037550: 90 07 60 54 add %i5, 0x54, %o0
}
else
{
rtems_chain_append (&fs->release, rtems_rfs_buffer_link (handle));
fs->release_count++;
2037554: c2 07 60 60 ld [ %i5 + 0x60 ], %g1
2037558: 82 00 60 01 inc %g1
203755c: c2 27 60 60 st %g1, [ %i5 + 0x60 ]
}
}
}
handle->buffer = NULL;
2037560: c0 26 60 08 clr [ %i1 + 8 ]
}
return rc;
}
2037564: 81 c7 e0 08 ret
2037568: 81 e8 00 00 restore
0203756c <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)
{
203756c: 9d e3 bf a0 save %sp, -96, %sp
/*
* 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))
2037570: c2 06 60 08 ld [ %i1 + 8 ], %g1
2037574: 80 a0 60 00 cmp %g1, 0
2037578: 02 80 00 1a be 20375e0 <rtems_rfs_buffer_handle_request+0x74>
203757c: ba 10 00 18 mov %i0, %i5
{
/*
* Treat block 0 as special to handle the loading of the super block.
*/
if (block && (rtems_rfs_buffer_bnum (handle) == block))
2037580: 80 a6 a0 00 cmp %i2, 0
2037584: 02 80 00 06 be 203759c <rtems_rfs_buffer_handle_request+0x30><== NEVER TAKEN
2037588: 90 10 20 00 clr %o0
203758c: c2 06 60 04 ld [ %i1 + 4 ], %g1
2037590: 80 a0 40 1a cmp %g1, %i2
2037594: 02 80 00 75 be 2037768 <rtems_rfs_buffer_handle_request+0x1fc>
2037598: b0 10 20 00 clr %i0
return 0;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))
203759c: 7f ff b1 2c call 2023a4c <rtems_rfs_trace>
20375a0: 92 10 21 00 mov 0x100, %o1
20375a4: 80 8a 20 ff btst 0xff, %o0
20375a8: 22 80 00 07 be,a 20375c4 <rtems_rfs_buffer_handle_request+0x58><== ALWAYS TAKEN
20375ac: 90 10 00 1d mov %i5, %o0
printf ("rtems-rfs: buffer-request: handle has buffer: %" PRIu32 "\n",
20375b0: d2 06 60 04 ld [ %i1 + 4 ], %o1 <== NOT EXECUTED
20375b4: 11 00 81 9c sethi %hi(0x2067000), %o0 <== NOT EXECUTED
20375b8: 40 00 3d 4c call 2046ae8 <printf> <== NOT EXECUTED
20375bc: 90 12 23 38 or %o0, 0x338, %o0 ! 2067338 <__FUNCTION__.7829+0x248><== NOT EXECUTED
rtems_rfs_buffer_bnum (handle));
rc = rtems_rfs_buffer_handle_release (fs, handle);
20375c0: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
20375c4: 7f ff ff 76 call 203739c <rtems_rfs_buffer_handle_release>
20375c8: 92 10 00 19 mov %i1, %o1
if (rc > 0)
20375cc: b0 92 20 00 orcc %o0, 0, %i0
20375d0: 14 80 00 8b bg 20377fc <rtems_rfs_buffer_handle_request+0x290><== NEVER TAKEN
20375d4: 01 00 00 00 nop
return rc;
handle->dirty = false;
20375d8: c0 2e 40 00 clrb [ %i1 ]
handle->bnum = 0;
20375dc: c0 26 60 04 clr [ %i1 + 4 ]
}
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))
20375e0: 90 10 20 00 clr %o0
20375e4: 7f ff b1 1a call 2023a4c <rtems_rfs_trace>
20375e8: 92 10 21 00 mov 0x100, %o1
20375ec: 80 8a 20 ff btst 0xff, %o0
20375f0: 22 80 00 07 be,a 203760c <rtems_rfs_buffer_handle_request+0xa0><== ALWAYS TAKEN
20375f4: c2 07 60 50 ld [ %i5 + 0x50 ], %g1
printf ("rtems-rfs: buffer-request: block=%" PRIu32 "\n", block);
20375f8: 11 00 81 9c sethi %hi(0x2067000), %o0 <== NOT EXECUTED
20375fc: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED
2037600: 40 00 3d 3a call 2046ae8 <printf> <== NOT EXECUTED
2037604: 90 12 23 70 or %o0, 0x370, %o0 <== 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)
2037608: c2 07 60 50 ld [ %i5 + 0x50 ], %g1 <== NOT EXECUTED
203760c: 80 a0 60 00 cmp %g1, 0
2037610: 22 80 00 16 be,a 2037668 <rtems_rfs_buffer_handle_request+0xfc>
2037614: c2 07 40 00 ld [ %i5 ], %g1
{
/*
* Check the active buffer list for shared buffers.
*/
handle->buffer = rtems_rfs_scan_chain (&fs->buffers,
2037618: 90 07 60 44 add %i5, 0x44, %o0
203761c: 92 07 60 50 add %i5, 0x50, %o1
2037620: 7f ff ff 22 call 20372a8 <rtems_rfs_scan_chain>
2037624: 94 10 00 1a mov %i2, %o2
&fs->buffers_count,
block);
if (rtems_rfs_buffer_handle_has_block (handle) &&
2037628: 80 a2 20 00 cmp %o0, 0
203762c: 02 80 00 0e be 2037664 <rtems_rfs_buffer_handle_request+0xf8>
2037630: d0 26 60 08 st %o0, [ %i1 + 8 ]
rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))
2037634: 90 10 20 00 clr %o0
2037638: 7f ff b1 05 call 2023a4c <rtems_rfs_trace>
203763c: 92 10 21 00 mov 0x100, %o1
* 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) &&
2037640: 80 8a 20 ff btst 0xff, %o0
2037644: 22 80 00 09 be,a 2037668 <rtems_rfs_buffer_handle_request+0xfc><== ALWAYS TAKEN
2037648: c2 07 40 00 ld [ %i5 ], %g1
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);
203764c: c2 06 60 08 ld [ %i1 + 8 ], %g1 <== 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",
2037650: 11 00 81 9c sethi %hi(0x2067000), %o0 <== NOT EXECUTED
2037654: d2 00 60 30 ld [ %g1 + 0x30 ], %o1 <== NOT EXECUTED
2037658: 90 12 23 98 or %o0, 0x398, %o0 <== NOT EXECUTED
203765c: 40 00 3d 23 call 2046ae8 <printf> <== NOT EXECUTED
2037660: 92 02 60 01 inc %o1 <== 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) &&
2037664: c2 07 40 00 ld [ %i5 ], %g1
2037668: 80 88 60 02 btst 2, %g1
203766c: 12 80 00 20 bne 20376ec <rtems_rfs_buffer_handle_request+0x180>
2037670: c2 06 60 08 ld [ %i1 + 8 ], %g1
2037674: 80 a0 60 00 cmp %g1, 0
2037678: 32 80 00 42 bne,a 2037780 <rtems_rfs_buffer_handle_request+0x214>
203767c: d2 06 60 08 ld [ %i1 + 8 ], %o1
!rtems_rfs_buffer_handle_has_block (handle))
{
/*
* Check the local cache of released buffers.
*/
if (fs->release_count)
2037680: c2 07 60 60 ld [ %i5 + 0x60 ], %g1
2037684: 80 a0 60 00 cmp %g1, 0
2037688: 22 80 00 08 be,a 20376a8 <rtems_rfs_buffer_handle_request+0x13c>
203768c: c2 06 60 08 ld [ %i1 + 8 ], %g1
handle->buffer = rtems_rfs_scan_chain (&fs->release,
2037690: 90 07 60 54 add %i5, 0x54, %o0
2037694: 92 07 60 60 add %i5, 0x60, %o1
2037698: 7f ff ff 04 call 20372a8 <rtems_rfs_scan_chain>
203769c: 94 10 00 1a mov %i2, %o2
20376a0: d0 26 60 08 st %o0, [ %i1 + 8 ]
&fs->release_count,
block);
if (!rtems_rfs_buffer_handle_has_block (handle) &&
20376a4: c2 06 60 08 ld [ %i1 + 8 ], %g1
20376a8: 80 a0 60 00 cmp %g1, 0
20376ac: 32 80 00 10 bne,a 20376ec <rtems_rfs_buffer_handle_request+0x180>
20376b0: c2 06 60 08 ld [ %i1 + 8 ], %g1
20376b4: c2 07 60 70 ld [ %i5 + 0x70 ], %g1
20376b8: 80 a0 60 00 cmp %g1, 0
20376bc: 22 80 00 0c be,a 20376ec <rtems_rfs_buffer_handle_request+0x180>
20376c0: c2 06 60 08 ld [ %i1 + 8 ], %g1
fs->release_modified_count)
{
handle->buffer = rtems_rfs_scan_chain (&fs->release_modified,
20376c4: 90 07 60 64 add %i5, 0x64, %o0
20376c8: 92 07 60 70 add %i5, 0x70, %o1
20376cc: 7f ff fe f7 call 20372a8 <rtems_rfs_scan_chain>
20376d0: 94 10 00 1a mov %i2, %o2
&fs->release_modified_count,
block);
/*
* If we found a buffer retain the dirty buffer state.
*/
if (rtems_rfs_buffer_handle_has_block (handle))
20376d4: 80 a2 20 00 cmp %o0, 0
20376d8: 02 80 00 04 be 20376e8 <rtems_rfs_buffer_handle_request+0x17c>
20376dc: d0 26 60 08 st %o0, [ %i1 + 8 ]
rtems_rfs_buffer_mark_dirty (handle);
20376e0: 82 10 20 01 mov 1, %g1
20376e4: c2 2e 40 00 stb %g1, [ %i1 ]
}
/*
* If not located we request the buffer from the I/O layer.
*/
if (!rtems_rfs_buffer_handle_has_block (handle))
20376e8: c2 06 60 08 ld [ %i1 + 8 ], %g1
20376ec: 80 a0 60 00 cmp %g1, 0
20376f0: 32 80 00 24 bne,a 2037780 <rtems_rfs_buffer_handle_request+0x214>
20376f4: d2 06 60 08 ld [ %i1 + 8 ], %o1
{
rc = rtems_rfs_buffer_io_request (fs, block, read, &handle->buffer);
20376f8: 90 10 00 1d mov %i5, %o0
20376fc: 92 10 00 1a mov %i2, %o1
2037700: 94 10 00 1b mov %i3, %o2
2037704: 40 00 28 e7 call 2041aa0 <rtems_rfs_buffer_bdbuf_request>
2037708: 96 06 60 08 add %i1, 8, %o3
if (rc > 0)
203770c: b0 92 20 00 orcc %o0, 0, %i0
2037710: 04 80 00 18 ble 2037770 <rtems_rfs_buffer_handle_request+0x204><== ALWAYS TAKEN
2037714: 90 10 20 00 clr %o0
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))
2037718: 7f ff b0 cd call 2023a4c <rtems_rfs_trace> <== NOT EXECUTED
203771c: 92 10 21 00 mov 0x100, %o1 <== NOT EXECUTED
2037720: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
2037724: 02 80 00 11 be 2037768 <rtems_rfs_buffer_handle_request+0x1fc><== NOT EXECUTED
2037728: 80 a6 e0 00 cmp %i3, 0 <== NOT EXECUTED
printf ("rtems-rfs: buffer-request: block=%" PRIu32 ": bdbuf-%s: %d: %s\n",
203772c: 22 80 00 05 be,a 2037740 <rtems_rfs_buffer_handle_request+0x1d4><== NOT EXECUTED
2037730: 3b 00 81 9c sethi %hi(0x2067000), %i5 <== NOT EXECUTED
2037734: 3b 00 81 8e sethi %hi(0x2063800), %i5 <== NOT EXECUTED
2037738: 10 80 00 03 b 2037744 <rtems_rfs_buffer_handle_request+0x1d8><== NOT EXECUTED
203773c: ba 17 60 80 or %i5, 0x80, %i5 ! 2063880 <rtems_rfs_rtems_eval_config+0xd48><== NOT EXECUTED
2037740: ba 17 63 30 or %i5, 0x330, %i5 <== NOT EXECUTED
2037744: 40 00 46 68 call 20490e4 <strerror> <== NOT EXECUTED
2037748: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
203774c: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED
2037750: 98 10 00 08 mov %o0, %o4 <== NOT EXECUTED
2037754: 94 10 00 1d mov %i5, %o2 <== NOT EXECUTED
2037758: 11 00 81 9c sethi %hi(0x2067000), %o0 <== NOT EXECUTED
203775c: 96 10 00 18 mov %i0, %o3 <== NOT EXECUTED
2037760: 40 00 3c e2 call 2046ae8 <printf> <== NOT EXECUTED
2037764: 90 12 23 d0 or %o0, 0x3d0, %o0 <== NOT EXECUTED
2037768: 81 c7 e0 08 ret
203776c: 81 e8 00 00 restore
block, read ? "read" : "get", rc, strerror (rc));
return rc;
}
rtems_chain_set_off_chain (rtems_rfs_buffer_link(handle));
2037770: c2 06 60 08 ld [ %i1 + 8 ], %g1
2037774: c0 20 60 04 clr [ %g1 + 4 ]
2037778: c0 20 40 00 clr [ %g1 ]
}
/*
* Increase the reference count of the buffer.
*/
rtems_rfs_buffer_refs_up (handle);
203777c: d2 06 60 08 ld [ %i1 + 8 ], %o1
2037780: 90 07 60 44 add %i5, 0x44, %o0
2037784: c2 02 60 30 ld [ %o1 + 0x30 ], %g1
2037788: 82 00 60 01 inc %g1
203778c: 7f ff 5a 90 call 200e1cc <_Chain_Append>
2037790: c2 22 60 30 st %g1, [ %o1 + 0x30 ]
rtems_chain_append (&fs->buffers, rtems_rfs_buffer_link (handle));
fs->buffers_count++;
2037794: c2 07 60 50 ld [ %i5 + 0x50 ], %g1
handle->buffer->user = (void*) ((intptr_t) block);
handle->bnum = block;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))
2037798: 90 10 20 00 clr %o0
/*
* 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++;
203779c: 82 00 60 01 inc %g1
20377a0: c2 27 60 50 st %g1, [ %i5 + 0x50 ]
handle->buffer->user = (void*) ((intptr_t) block);
20377a4: c2 06 60 08 ld [ %i1 + 8 ], %g1
handle->bnum = block;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))
20377a8: 92 10 21 00 mov 0x100, %o1
*/
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);
20377ac: f4 20 60 34 st %i2, [ %g1 + 0x34 ]
handle->bnum = block;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))
20377b0: 7f ff b0 a7 call 2023a4c <rtems_rfs_trace>
20377b4: f4 26 60 04 st %i2, [ %i1 + 4 ]
20377b8: 80 8a 20 ff btst 0xff, %o0
20377bc: 02 80 00 0f be 20377f8 <rtems_rfs_buffer_handle_request+0x28c><== ALWAYS TAKEN
20377c0: 80 a6 e0 00 cmp %i3, 0
printf ("rtems-rfs: buffer-request: block=%" PRIu32 " bdbuf-%s=%" PRIu32 " refs=%d\n",
20377c4: 22 80 00 05 be,a 20377d8 <rtems_rfs_buffer_handle_request+0x26c><== NOT EXECUTED
20377c8: 15 00 81 9c sethi %hi(0x2067000), %o2 <== NOT EXECUTED
20377cc: 15 00 81 8e sethi %hi(0x2063800), %o2 <== NOT EXECUTED
20377d0: 10 80 00 03 b 20377dc <rtems_rfs_buffer_handle_request+0x270><== NOT EXECUTED
20377d4: 94 12 a0 80 or %o2, 0x80, %o2 ! 2063880 <rtems_rfs_rtems_eval_config+0xd48><== NOT EXECUTED
20377d8: 94 12 a3 30 or %o2, 0x330, %o2 <== NOT EXECUTED
block, read ? "read" : "get", handle->buffer->block,
20377dc: c2 06 60 08 ld [ %i1 + 8 ], %g1 <== 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",
20377e0: 11 00 81 9d sethi %hi(0x2067400), %o0 <== NOT EXECUTED
20377e4: d6 00 60 18 ld [ %g1 + 0x18 ], %o3 <== NOT EXECUTED
20377e8: d8 00 60 30 ld [ %g1 + 0x30 ], %o4 <== NOT EXECUTED
20377ec: 90 12 20 08 or %o0, 8, %o0 <== NOT EXECUTED
20377f0: 40 00 3c be call 2046ae8 <printf> <== NOT EXECUTED
20377f4: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED
block, read ? "read" : "get", handle->buffer->block,
handle->buffer->references);
return 0;
20377f8: b0 10 20 00 clr %i0
}
20377fc: 81 c7 e0 08 ret
2037800: 81 e8 00 00 restore
02037804 <rtems_rfs_buffer_open>:
return rc;
}
int
rtems_rfs_buffer_open (const char* name, rtems_rfs_file_system* fs)
{
2037804: 9d e3 bf 58 save %sp, -168, %sp
struct stat st;
#if RTEMS_RFS_USE_LIBBLOCK
int rv;
#endif
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SYNC))
2037808: 90 10 20 00 clr %o0
203780c: 7f ff b0 90 call 2023a4c <rtems_rfs_trace>
2037810: 92 10 20 20 mov 0x20, %o1
2037814: 80 8a 20 ff btst 0xff, %o0
2037818: 22 80 00 07 be,a 2037834 <rtems_rfs_buffer_open+0x30> <== ALWAYS TAKEN
203781c: 90 10 00 18 mov %i0, %o0
printf ("rtems-rfs: buffer-open: opening: %s\n", name);
2037820: 11 00 81 9d sethi %hi(0x2067400), %o0 <== NOT EXECUTED
2037824: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
2037828: 40 00 3c b0 call 2046ae8 <printf> <== NOT EXECUTED
203782c: 90 12 20 48 or %o0, 0x48, %o0 <== NOT EXECUTED
fs->device = open (name, O_RDWR);
2037830: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
2037834: 7f ff 48 ac call 2009ae4 <open>
2037838: 92 10 20 02 mov 2, %o1
if (fs->device < 0)
203783c: 80 a2 20 00 cmp %o0, 0
2037840: 16 80 00 0f bge 203787c <rtems_rfs_buffer_open+0x78> <== ALWAYS TAKEN
2037844: d0 26 60 0c st %o0, [ %i1 + 0xc ]
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_OPEN))
2037848: 90 10 20 00 clr %o0 <== NOT EXECUTED
203784c: 7f ff b0 80 call 2023a4c <rtems_rfs_trace> <== NOT EXECUTED
2037850: 92 10 20 08 mov 8, %o1 <== NOT EXECUTED
2037854: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
2037858: 12 80 00 04 bne 2037868 <rtems_rfs_buffer_open+0x64> <== NOT EXECUTED
203785c: 11 00 81 9d sethi %hi(0x2067400), %o0 <== NOT EXECUTED
printf ("rtems-rfs: buffer-open: cannot open file\n");
return ENXIO;
2037860: 81 c7 e0 08 ret <== NOT EXECUTED
2037864: 91 e8 20 06 restore %g0, 6, %o0 <== NOT EXECUTED
fs->device = open (name, O_RDWR);
if (fs->device < 0)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_OPEN))
printf ("rtems-rfs: buffer-open: cannot open file\n");
2037868: 90 12 20 70 or %o0, 0x70, %o0 <== NOT EXECUTED
203786c: 40 00 3d 37 call 2046d48 <puts> <== NOT EXECUTED
2037870: 01 00 00 00 nop <== NOT EXECUTED
return ENXIO;
2037874: 81 c7 e0 08 ret <== NOT EXECUTED
2037878: 91 e8 20 06 restore %g0, 6, %o0 <== NOT EXECUTED
}
if (fstat (fs->device, &st) < 0)
203787c: 7f ff c1 aa call 2027f24 <fstat>
2037880: 92 07 bf b8 add %fp, -72, %o1
2037884: 80 a2 20 00 cmp %o0, 0
2037888: 16 80 00 12 bge 20378d0 <rtems_rfs_buffer_open+0xcc> <== ALWAYS TAKEN
203788c: c4 07 bf c4 ld [ %fp + -60 ], %g2
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_OPEN))
2037890: 90 10 20 00 clr %o0 <== NOT EXECUTED
2037894: 7f ff b0 6e call 2023a4c <rtems_rfs_trace> <== NOT EXECUTED
2037898: 92 10 20 08 mov 8, %o1 <== NOT EXECUTED
203789c: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
20378a0: 02 bf ff f5 be 2037874 <rtems_rfs_buffer_open+0x70> <== NOT EXECUTED
20378a4: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: buffer-open: stat '%s' failed: %s\n",
name, strerror (errno));
20378a8: 40 00 2a 51 call 20421ec <__errno> <== NOT EXECUTED
20378ac: 01 00 00 00 nop <== NOT EXECUTED
}
if (fstat (fs->device, &st) < 0)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_OPEN))
printf ("rtems-rfs: buffer-open: stat '%s' failed: %s\n",
20378b0: 40 00 46 0d call 20490e4 <strerror> <== NOT EXECUTED
20378b4: d0 02 00 00 ld [ %o0 ], %o0 <== NOT EXECUTED
20378b8: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
20378bc: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
20378c0: 11 00 81 9d sethi %hi(0x2067400), %o0 <== NOT EXECUTED
20378c4: 40 00 3c 89 call 2046ae8 <printf> <== NOT EXECUTED
20378c8: 90 12 20 a0 or %o0, 0xa0, %o0 ! 20674a0 <__FUNCTION__.7829+0x3b0><== NOT EXECUTED
20378cc: 30 bf ff ea b,a 2037874 <rtems_rfs_buffer_open+0x70> <== NOT EXECUTED
#if RTEMS_RFS_USE_LIBBLOCK
/*
* Is the device a block device ?
*/
if (!S_ISBLK (st.st_mode))
20378d0: 03 00 00 3c sethi %hi(0xf000), %g1
20378d4: 84 08 80 01 and %g2, %g1, %g2
20378d8: 03 00 00 18 sethi %hi(0x6000), %g1
20378dc: 80 a0 80 01 cmp %g2, %g1
20378e0: 22 80 00 0c be,a 2037910 <rtems_rfs_buffer_open+0x10c> <== ALWAYS TAKEN
20378e4: d0 06 60 0c ld [ %i1 + 0xc ], %o0
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_OPEN))
20378e8: 90 10 20 00 clr %o0 <== NOT EXECUTED
20378ec: 7f ff b0 58 call 2023a4c <rtems_rfs_trace> <== NOT EXECUTED
20378f0: 92 10 20 08 mov 8, %o1 <== NOT EXECUTED
20378f4: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
20378f8: 02 bf ff df be 2037874 <rtems_rfs_buffer_open+0x70> <== NOT EXECUTED
20378fc: 11 00 81 9d sethi %hi(0x2067400), %o0 <== NOT EXECUTED
printf ("rtems-rfs: buffer-open: '%s' is not a block device\n", name);
2037900: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
2037904: 40 00 3c 79 call 2046ae8 <printf> <== NOT EXECUTED
2037908: 90 12 20 d0 or %o0, 0xd0, %o0 <== NOT EXECUTED
203790c: 30 bf ff da b,a 2037874 <rtems_rfs_buffer_open+0x70> <== NOT EXECUTED
2037910: 13 10 01 10 sethi %hi(0x40044000), %o1
2037914: 94 06 60 10 add %i1, 0x10, %o2
2037918: 7f ff 45 10 call 2008d58 <ioctl>
203791c: 92 12 62 09 or %o1, 0x209, %o1
/*
* Check that device is registred as a block device and lock it.
*/
rv = rtems_disk_fd_get_disk_device (fs->device, &fs->disk);
if (rv != 0)
2037920: 80 a2 20 00 cmp %o0, 0
2037924: 02 80 00 09 be 2037948 <rtems_rfs_buffer_open+0x144> <== ALWAYS TAKEN
2037928: 90 10 20 00 clr %o0
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_OPEN))
203792c: 7f ff b0 48 call 2023a4c <rtems_rfs_trace> <== NOT EXECUTED
2037930: 92 10 20 08 mov 8, %o1 <== NOT EXECUTED
2037934: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
2037938: 02 bf ff cf be 2037874 <rtems_rfs_buffer_open+0x70> <== NOT EXECUTED
203793c: 11 00 81 9d sethi %hi(0x2067400), %o0 <== NOT EXECUTED
printf ("rtems-rfs: buffer-open: cannot obtain the disk\n");
2037940: 10 bf ff cb b 203786c <rtems_rfs_buffer_open+0x68> <== NOT EXECUTED
2037944: 90 12 21 08 or %o0, 0x108, %o0 ! 2067508 <__FUNCTION__.7829+0x418><== NOT EXECUTED
#else
fs->media_size = st.st_size;
strcat (fs->name, name);
#endif
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SYNC))
2037948: 92 10 20 20 mov 0x20, %o1
203794c: 7f ff b0 40 call 2023a4c <rtems_rfs_trace>
2037950: b0 10 20 00 clr %i0
2037954: 80 8a 20 ff btst 0xff, %o0
2037958: 02 80 00 07 be 2037974 <rtems_rfs_buffer_open+0x170> <== ALWAYS TAKEN
203795c: 11 00 81 9d sethi %hi(0x2067400), %o0
printf ("rtems-rfs: buffer-open: blks=%" PRId32 ", blk-size=%" PRId32 "\n",
rtems_rfs_fs_media_blocks (fs),
2037960: c2 06 60 10 ld [ %i1 + 0x10 ], %g1 <== 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",
2037964: d2 00 60 1c ld [ %g1 + 0x1c ], %o1 <== NOT EXECUTED
2037968: d4 00 60 20 ld [ %g1 + 0x20 ], %o2 <== NOT EXECUTED
203796c: 40 00 3c 5f call 2046ae8 <printf> <== NOT EXECUTED
2037970: 90 12 21 38 or %o0, 0x138, %o0 <== NOT EXECUTED
rtems_rfs_fs_media_blocks (fs),
rtems_rfs_fs_media_block_size (fs));
return 0;
}
2037974: 81 c7 e0 08 ret
2037978: 81 e8 00 00 restore
02037a84 <rtems_rfs_buffer_setblksize>:
return result;
}
int
rtems_rfs_buffer_setblksize (rtems_rfs_file_system* fs, size_t size)
{
2037a84: 9d e3 bf a0 save %sp, -96, %sp
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SETBLKSIZE))
2037a88: 90 10 20 00 clr %o0
return result;
}
int
rtems_rfs_buffer_setblksize (rtems_rfs_file_system* fs, size_t size)
{
2037a8c: f2 27 a0 48 st %i1, [ %fp + 0x48 ]
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SETBLKSIZE))
2037a90: 7f ff af ef call 2023a4c <rtems_rfs_trace>
2037a94: 92 10 24 00 mov 0x400, %o1
2037a98: 80 8a 20 ff btst 0xff, %o0
2037a9c: 02 80 00 05 be 2037ab0 <rtems_rfs_buffer_setblksize+0x2c> <== ALWAYS TAKEN
2037aa0: d2 07 a0 48 ld [ %fp + 0x48 ], %o1
printf ("rtems-rfs: buffer-setblksize: block size: %zu\n", size);
2037aa4: 11 00 81 9d sethi %hi(0x2067400), %o0 <== NOT EXECUTED
2037aa8: 40 00 3c 10 call 2046ae8 <printf> <== NOT EXECUTED
2037aac: 90 12 22 08 or %o0, 0x208, %o0 ! 2067608 <__FUNCTION__.7829+0x518><== NOT EXECUTED
rc = rtems_rfs_buffers_release (fs);
2037ab0: 7f ff ff d5 call 2037a04 <rtems_rfs_buffers_release>
2037ab4: 90 10 00 18 mov %i0, %o0
if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SETBLKSIZE))
2037ab8: ba 92 20 00 orcc %o0, 0, %i5
2037abc: 04 80 00 0e ble 2037af4 <rtems_rfs_buffer_setblksize+0x70><== ALWAYS TAKEN
2037ac0: 90 10 20 00 clr %o0
2037ac4: 7f ff af e2 call 2023a4c <rtems_rfs_trace> <== NOT EXECUTED
2037ac8: 92 10 24 00 mov 0x400, %o1 <== NOT EXECUTED
2037acc: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
2037ad0: 02 80 00 09 be 2037af4 <rtems_rfs_buffer_setblksize+0x70> <== NOT EXECUTED
2037ad4: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: buffer-setblksize: buffer release failed: %d: %s\n",
2037ad8: 40 00 45 83 call 20490e4 <strerror> <== NOT EXECUTED
2037adc: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
2037ae0: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
2037ae4: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
2037ae8: 11 00 81 9d sethi %hi(0x2067400), %o0 <== NOT EXECUTED
2037aec: 40 00 3b ff call 2046ae8 <printf> <== NOT EXECUTED
2037af0: 90 12 22 38 or %o0, 0x238, %o0 ! 2067638 <__FUNCTION__.7829+0x548><== NOT EXECUTED
rc, strerror (rc));
rc = rtems_rfs_buffer_sync (fs);
2037af4: 7f ff ff a2 call 203797c <rtems_rfs_buffer_sync>
2037af8: 90 10 00 18 mov %i0, %o0
if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SETBLKSIZE))
2037afc: ba 92 20 00 orcc %o0, 0, %i5
2037b00: 04 80 00 0e ble 2037b38 <rtems_rfs_buffer_setblksize+0xb4><== ALWAYS TAKEN
2037b04: 90 10 20 00 clr %o0
2037b08: 7f ff af d1 call 2023a4c <rtems_rfs_trace> <== NOT EXECUTED
2037b0c: 92 10 24 00 mov 0x400, %o1 <== NOT EXECUTED
2037b10: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
2037b14: 22 80 00 0a be,a 2037b3c <rtems_rfs_buffer_setblksize+0xb8><== NOT EXECUTED
2037b18: d0 06 20 10 ld [ %i0 + 0x10 ], %o0 <== NOT EXECUTED
printf ("rtems-rfs: buffer-setblksize: device sync failed: %d: %s\n",
2037b1c: 40 00 45 72 call 20490e4 <strerror> <== NOT EXECUTED
2037b20: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
2037b24: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
2037b28: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
2037b2c: 11 00 81 9d sethi %hi(0x2067400), %o0 <== NOT EXECUTED
2037b30: 40 00 3b ee call 2046ae8 <printf> <== NOT EXECUTED
2037b34: 90 12 22 78 or %o0, 0x278, %o0 ! 2067678 <__FUNCTION__.7829+0x588><== NOT EXECUTED
rc, strerror (rc));
#if RTEMS_RFS_USE_LIBBLOCK
rc = fs->disk->ioctl (fs->disk, RTEMS_BLKIO_SETBLKSIZE, &size);
2037b38: d0 06 20 10 ld [ %i0 + 0x10 ], %o0
2037b3c: 13 20 01 10 sethi %hi(0x80044000), %o1
2037b40: c2 02 20 38 ld [ %o0 + 0x38 ], %g1
2037b44: 92 12 62 04 or %o1, 0x204, %o1
2037b48: 9f c0 40 00 call %g1
2037b4c: 94 07 a0 48 add %fp, 0x48, %o2
if (rc < 0)
2037b50: b0 92 20 00 orcc %o0, 0, %i0
2037b54: 16 80 00 05 bge 2037b68 <rtems_rfs_buffer_setblksize+0xe4><== ALWAYS TAKEN
2037b58: 01 00 00 00 nop
rc = errno;
2037b5c: 40 00 29 a4 call 20421ec <__errno> <== NOT EXECUTED
2037b60: 01 00 00 00 nop <== NOT EXECUTED
2037b64: f0 02 00 00 ld [ %o0 ], %i0 <== NOT EXECUTED
#endif
return rc;
}
2037b68: 81 c7 e0 08 ret
2037b6c: 81 e8 00 00 restore
0203797c <rtems_rfs_buffer_sync>:
return rc;
}
int
rtems_rfs_buffer_sync (rtems_rfs_file_system* fs)
{
203797c: 9d e3 bf a0 save %sp, -96, %sp
int result = 0;
#if RTEMS_RFS_USE_LIBBLOCK
rtems_status_code sc;
#endif
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SYNC))
2037980: 90 10 20 00 clr %o0
2037984: 7f ff b0 32 call 2023a4c <rtems_rfs_trace>
2037988: 92 10 20 20 mov 0x20, %o1
203798c: 80 8a 20 ff btst 0xff, %o0
2037990: 22 80 00 06 be,a 20379a8 <rtems_rfs_buffer_sync+0x2c> <== ALWAYS TAKEN
2037994: d0 06 20 10 ld [ %i0 + 0x10 ], %o0
printf ("rtems-rfs: buffer-sync: syncing\n");
2037998: 11 00 81 9d sethi %hi(0x2067400), %o0 <== NOT EXECUTED
203799c: 40 00 3c eb call 2046d48 <puts> <== NOT EXECUTED
20379a0: 90 12 21 68 or %o0, 0x168, %o0 ! 2067568 <__FUNCTION__.7829+0x478><== 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));
20379a4: d0 06 20 10 ld [ %i0 + 0x10 ], %o0 <== NOT EXECUTED
20379a8: 7f ff 3c 54 call 2006af8 <rtems_bdbuf_syncdev>
20379ac: ba 10 20 00 clr %i5
if (sc != RTEMS_SUCCESSFUL)
20379b0: 80 a2 20 00 cmp %o0, 0
20379b4: 02 80 00 0f be 20379f0 <rtems_rfs_buffer_sync+0x74> <== ALWAYS TAKEN
20379b8: b8 10 00 08 mov %o0, %i4
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SYNC))
20379bc: 90 10 20 00 clr %o0 <== NOT EXECUTED
20379c0: 92 10 20 20 mov 0x20, %o1 <== NOT EXECUTED
20379c4: 7f ff b0 22 call 2023a4c <rtems_rfs_trace> <== NOT EXECUTED
20379c8: ba 10 20 05 mov 5, %i5 <== NOT EXECUTED
20379cc: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
20379d0: 22 80 00 09 be,a 20379f4 <rtems_rfs_buffer_sync+0x78> <== NOT EXECUTED
20379d4: d0 06 20 10 ld [ %i0 + 0x10 ], %o0 <== NOT EXECUTED
printf ("rtems-rfs: buffer-sync: device sync failed: %s\n",
20379d8: 7f ff 43 ec call 2008988 <rtems_status_text> <== NOT EXECUTED
20379dc: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
20379e0: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED
20379e4: 11 00 81 9d sethi %hi(0x2067400), %o0 <== NOT EXECUTED
20379e8: 40 00 3c 40 call 2046ae8 <printf> <== NOT EXECUTED
20379ec: 90 12 21 88 or %o0, 0x188, %o0 ! 2067588 <__FUNCTION__.7829+0x498><== NOT EXECUTED
rtems_status_text (sc));
result = EIO;
}
rtems_disk_release (fs->disk);
20379f0: d0 06 20 10 ld [ %i0 + 0x10 ], %o0
20379f4: 7f ff 40 da call 2007d5c <rtems_disk_release>
20379f8: b0 10 00 1d mov %i5, %i0
printf ("rtems-rfs: buffer-sync: file sync failed: %d: %s\n",
result, strerror (result));
}
#endif
return result;
}
20379fc: 81 c7 e0 08 ret
2037a00: 81 e8 00 00 restore
02037a04 <rtems_rfs_buffers_release>:
return rrc;
}
int
rtems_rfs_buffers_release (rtems_rfs_file_system* fs)
{
2037a04: 9d e3 bf a0 save %sp, -96, %sp
int rrc = 0;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_RELEASE))
2037a08: 90 10 20 00 clr %o0
2037a0c: 92 10 20 40 mov 0x40, %o1
2037a10: 7f ff b0 0f call 2023a4c <rtems_rfs_trace>
2037a14: ba 10 00 18 mov %i0, %i5
2037a18: 80 8a 20 ff btst 0xff, %o0
2037a1c: 02 80 00 09 be 2037a40 <rtems_rfs_buffers_release+0x3c> <== ALWAYS TAKEN
2037a20: 92 07 60 60 add %i5, 0x60, %o1
printf ("rtems-rfs: buffers-release: active:%" PRIu32 " "
2037a24: d2 06 20 50 ld [ %i0 + 0x50 ], %o1 <== NOT EXECUTED
2037a28: d4 06 20 60 ld [ %i0 + 0x60 ], %o2 <== NOT EXECUTED
2037a2c: d6 06 20 70 ld [ %i0 + 0x70 ], %o3 <== NOT EXECUTED
2037a30: 11 00 81 9d sethi %hi(0x2067400), %o0 <== NOT EXECUTED
2037a34: 40 00 3c 2d call 2046ae8 <printf> <== NOT EXECUTED
2037a38: 90 12 21 b8 or %o0, 0x1b8, %o0 ! 20675b8 <__FUNCTION__.7829+0x4c8><== 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,
2037a3c: 92 07 60 60 add %i5, 0x60, %o1 <== NOT EXECUTED
2037a40: 94 10 20 00 clr %o2
2037a44: 7f ff fd f6 call 203721c <rtems_rfs_release_chain>
2037a48: 90 07 60 54 add %i5, 0x54, %o0
2037a4c: 82 38 00 08 xnor %g0, %o0, %g1
2037a50: 83 38 60 1f sra %g1, 0x1f, %g1
&fs->release_count,
false);
if ((rc > 0) && (rrc == 0))
rrc = rc;
rc = rtems_rfs_release_chain (&fs->release_modified,
2037a54: 92 07 60 70 add %i5, 0x70, %o1
2037a58: b0 0a 00 01 and %o0, %g1, %i0
2037a5c: 94 10 20 01 mov 1, %o2
2037a60: 7f ff fd ef call 203721c <rtems_rfs_release_chain>
2037a64: 90 07 60 64 add %i5, 0x64, %o0
&fs->release_modified_count,
true);
if ((rc > 0) && (rrc == 0))
2037a68: 80 a6 20 00 cmp %i0, 0
2037a6c: 12 80 00 04 bne 2037a7c <rtems_rfs_buffers_release+0x78> <== NEVER TAKEN
2037a70: 80 a2 20 00 cmp %o0, 0
2037a74: 34 80 00 02 bg,a 2037a7c <rtems_rfs_buffers_release+0x78><== NEVER TAKEN
2037a78: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED
rrc = rc;
return rrc;
}
2037a7c: 81 c7 e0 08 ret
2037a80: 81 e8 00 00 restore
02038160 <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)
{
2038160: 9d e3 bf 30 save %sp, -208, %sp
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))
2038164: 90 10 20 00 clr %o0
2038168: 7f ff ae 39 call 2023a4c <rtems_rfs_trace>
203816c: 13 08 00 00 sethi %hi(0x20000000), %o1
2038170: 80 8a 20 ff btst 0xff, %o0
2038174: 02 80 00 14 be 20381c4 <rtems_rfs_dir_add_entry+0x64> <== ALWAYS TAKEN
2038178: a6 07 bf b0 add %fp, -80, %l3
{
int c;
printf ("rtems-rfs: dir-add-entry: dir=%" PRId32 ", name=",
203817c: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED
2038180: 11 00 81 9e sethi %hi(0x2067800), %o0 <== NOT EXECUTED
2038184: ba 10 00 1a mov %i2, %i5 <== NOT EXECUTED
2038188: 90 12 22 28 or %o0, 0x228, %o0 <== NOT EXECUTED
203818c: 40 00 3a 57 call 2046ae8 <printf> <== NOT EXECUTED
2038190: a0 06 80 1b add %i2, %i3, %l0 <== NOT EXECUTED
rtems_rfs_inode_ino (dir));
for (c = 0; c < length; c++)
2038194: 10 80 00 05 b 20381a8 <rtems_rfs_dir_add_entry+0x48> <== NOT EXECUTED
2038198: 80 a7 40 10 cmp %i5, %l0 <== NOT EXECUTED
printf ("%c", name[c]);
203819c: 40 00 3a bd call 2046c90 <putchar> <== NOT EXECUTED
20381a0: ba 07 60 01 inc %i5 <== 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++)
20381a4: 80 a7 40 10 cmp %i5, %l0 <== NOT EXECUTED
20381a8: 32 bf ff fd bne,a 203819c <rtems_rfs_dir_add_entry+0x3c> <== NOT EXECUTED
20381ac: d0 4f 40 00 ldsb [ %i5 ], %o0 <== NOT EXECUTED
printf ("%c", name[c]);
printf (", len=%zd\n", length);
20381b0: 11 00 81 9e sethi %hi(0x2067800), %o0 <== NOT EXECUTED
20381b4: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
20381b8: 40 00 3a 4c call 2046ae8 <printf> <== NOT EXECUTED
20381bc: 90 12 22 58 or %o0, 0x258, %o0 <== NOT EXECUTED
}
rc = rtems_rfs_block_map_open (fs, dir, &map);
20381c0: a6 07 bf b0 add %fp, -80, %l3 <== NOT EXECUTED
20381c4: 90 10 00 18 mov %i0, %o0
20381c8: 92 10 00 19 mov %i1, %o1
20381cc: 7f ff f8 fb call 20365b8 <rtems_rfs_block_map_open>
20381d0: 94 10 00 13 mov %l3, %o2
if (rc > 0)
20381d4: ba 92 20 00 orcc %o0, 0, %i5
20381d8: 34 80 00 c5 bg,a 20384ec <rtems_rfs_dir_add_entry+0x38c> <== NEVER TAKEN
20381dc: b0 10 00 1d mov %i5, %i0 <== 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)
20381e0: 29 00 00 3f sethi %hi(0xfc00), %l4
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
20381e4: c0 2f bf a4 clrb [ %fp + -92 ]
handle->bnum = 0;
20381e8: c0 27 bf a8 clr [ %fp + -88 ]
handle->buffer = NULL;
20381ec: c0 27 bf ac clr [ %fp + -84 ]
* @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;
20381f0: c0 27 bf 98 clr [ %fp + -104 ]
bpos->boff = 0;
20381f4: c0 27 bf 9c clr [ %fp + -100 ]
bpos->block = 0;
20381f8: c0 27 bf a0 clr [ %fp + -96 ]
20381fc: a8 15 23 ff or %l4, 0x3ff, %l4
{
if ((length + RTEMS_RFS_DIR_ENTRY_SIZE) <
2038200: aa 06 e0 0a add %i3, 0xa, %l5
/*
* 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);
2038204: 90 10 00 18 mov %i0, %o0
2038208: 92 10 00 13 mov %l3, %o1
203820c: 94 07 bf 98 add %fp, -104, %o2
2038210: 7f ff f9 bf call 203690c <rtems_rfs_block_map_find>
2038214: 96 07 bf 94 add %fp, -108, %o3
if (rc > 0)
2038218: ba 92 20 00 orcc %o0, 0, %i5
203821c: 04 80 00 29 ble 20382c0 <rtems_rfs_dir_add_entry+0x160>
2038220: 80 a7 60 06 cmp %i5, 6
{
if (rc != ENXIO)
2038224: 02 80 00 0f be 2038260 <rtems_rfs_dir_add_entry+0x100> <== ALWAYS TAKEN
2038228: 90 10 00 18 mov %i0, %o0
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_ADD_ENTRY))
203822c: 90 10 20 00 clr %o0 <== NOT EXECUTED
2038230: 7f ff ae 07 call 2023a4c <rtems_rfs_trace> <== NOT EXECUTED
2038234: 13 08 00 00 sethi %hi(0x20000000), %o1 <== NOT EXECUTED
2038238: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
203823c: 22 80 00 a6 be,a 20384d4 <rtems_rfs_dir_add_entry+0x374> <== NOT EXECUTED
2038240: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED
printf ("rtems-rfs: dir-add-entry: "
2038244: f8 06 60 08 ld [ %i1 + 8 ], %i4 <== NOT EXECUTED
2038248: 40 00 43 a7 call 20490e4 <strerror> <== NOT EXECUTED
203824c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
2038250: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
2038254: 11 00 81 9e sethi %hi(0x2067800), %o0 <== NOT EXECUTED
2038258: 10 80 00 15 b 20382ac <rtems_rfs_dir_add_entry+0x14c> <== NOT EXECUTED
203825c: 90 12 22 68 or %o0, 0x268, %o0 ! 2067a68 <__FUNCTION__.7829+0x978><== NOT EXECUTED
}
/*
* We have reached the end of the directory so add a block.
*/
rc = rtems_rfs_block_map_grow (fs, &map, 1, &block);
2038260: 92 10 00 13 mov %l3, %o1
2038264: 94 10 20 01 mov 1, %o2
2038268: 7f ff fa 2f call 2036b24 <rtems_rfs_block_map_grow>
203826c: 96 07 bf 94 add %fp, -108, %o3
if (rc > 0)
2038270: ba 92 20 00 orcc %o0, 0, %i5
2038274: 04 80 00 14 ble 20382c4 <rtems_rfs_dir_add_entry+0x164> <== ALWAYS TAKEN
2038278: a0 10 20 00 clr %l0
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_ADD_ENTRY))
203827c: 90 10 20 00 clr %o0 <== NOT EXECUTED
2038280: 7f ff ad f3 call 2023a4c <rtems_rfs_trace> <== NOT EXECUTED
2038284: 13 08 00 00 sethi %hi(0x20000000), %o1 <== NOT EXECUTED
2038288: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
203828c: 22 80 00 92 be,a 20384d4 <rtems_rfs_dir_add_entry+0x374> <== NOT EXECUTED
2038290: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED
printf ("rtems-rfs: dir-add-entry: "
2038294: f8 06 60 08 ld [ %i1 + 8 ], %i4 <== NOT EXECUTED
2038298: 40 00 43 93 call 20490e4 <strerror> <== NOT EXECUTED
203829c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
20382a0: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
20382a4: 11 00 81 9e sethi %hi(0x2067800), %o0 <== NOT EXECUTED
20382a8: 90 12 22 b0 or %o0, 0x2b0, %o0 ! 2067ab0 <__FUNCTION__.7829+0x9c0><== NOT EXECUTED
20382ac: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
20382b0: 40 00 3a 0e call 2046ae8 <printf> <== NOT EXECUTED
20382b4: 94 10 00 1d mov %i5, %o2 <== NOT EXECUTED
entry += elength;
offset += elength;
}
}
rtems_rfs_buffer_handle_close (fs, &buffer);
20382b8: 10 80 00 87 b 20384d4 <rtems_rfs_dir_add_entry+0x374> <== NOT EXECUTED
20382bc: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED
20382c0: a0 10 20 01 mov 1, %l0
}
read = false;
}
bpos.bno++;
20382c4: c2 07 bf 98 ld [ %fp + -104 ], %g1
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, read);
20382c8: d4 07 bf 94 ld [ %fp + -108 ], %o2
}
read = false;
}
bpos.bno++;
20382cc: 82 00 60 01 inc %g1
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, read);
20382d0: a0 0c 20 ff and %l0, 0xff, %l0
}
read = false;
}
bpos.bno++;
20382d4: c2 27 bf 98 st %g1, [ %fp + -104 ]
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, read);
20382d8: 90 10 00 18 mov %i0, %o0
20382dc: 92 07 bf a4 add %fp, -92, %o1
20382e0: 7f ff fc a3 call 203756c <rtems_rfs_buffer_handle_request>
20382e4: 96 10 00 10 mov %l0, %o3
if (rc > 0)
20382e8: ba 92 20 00 orcc %o0, 0, %i5
20382ec: 04 80 00 0f ble 2038328 <rtems_rfs_dir_add_entry+0x1c8> <== ALWAYS TAKEN
20382f0: c2 07 bf ac ld [ %fp + -84 ], %g1
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_ADD_ENTRY))
20382f4: 90 10 20 00 clr %o0 <== NOT EXECUTED
20382f8: 7f ff ad d5 call 2023a4c <rtems_rfs_trace> <== NOT EXECUTED
20382fc: 13 08 00 00 sethi %hi(0x20000000), %o1 <== NOT EXECUTED
2038300: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
2038304: 22 80 00 74 be,a 20384d4 <rtems_rfs_dir_add_entry+0x374> <== NOT EXECUTED
2038308: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED
printf ("rtems-rfs: dir-add-entry: "
203830c: f8 06 60 08 ld [ %i1 + 8 ], %i4 <== NOT EXECUTED
2038310: 40 00 43 75 call 20490e4 <strerror> <== NOT EXECUTED
2038314: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
2038318: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
203831c: 11 00 81 9e sethi %hi(0x2067800), %o0 <== NOT EXECUTED
2038320: 10 bf ff e3 b 20382ac <rtems_rfs_dir_add_entry+0x14c> <== NOT EXECUTED
2038324: 90 12 22 f8 or %o0, 0x2f8, %o0 ! 2067af8 <__FUNCTION__.7829+0xa08><== NOT EXECUTED
break;
}
entry = rtems_rfs_buffer_data (&buffer);
if (!read)
2038328: 80 a4 20 00 cmp %l0, 0
203832c: 12 80 00 06 bne 2038344 <rtems_rfs_dir_add_entry+0x1e4>
2038330: fa 00 60 1c ld [ %g1 + 0x1c ], %i5
memset (entry, 0xff, rtems_rfs_fs_block_size (fs));
2038334: d4 06 20 08 ld [ %i0 + 8 ], %o2
2038338: 90 10 00 1d mov %i5, %o0
203833c: 40 00 35 7a call 2045924 <memset>
2038340: 92 10 20 ff mov 0xff, %o1
offset = 0;
while (offset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
2038344: c2 06 20 08 ld [ %i0 + 8 ], %g1
entry = rtems_rfs_buffer_data (&buffer);
if (!read)
memset (entry, 0xff, rtems_rfs_fs_block_size (fs));
offset = 0;
2038348: a2 10 20 00 clr %l1
while (offset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
203834c: 10 80 00 5d b 20384c0 <rtems_rfs_dir_add_entry+0x360>
2038350: 84 00 7f f6 add %g1, -10, %g2
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
2038354: e0 0f 60 08 ldub [ %i5 + 8 ], %l0
eino = rtems_rfs_dir_entry_ino (entry);
2038358: e4 0f 40 00 ldub [ %i5 ], %l2
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);
203835c: a1 2c 20 08 sll %l0, 8, %l0
2038360: a0 14 00 03 or %l0, %g3, %l0
eino = rtems_rfs_dir_entry_ino (entry);
2038364: c6 0f 60 01 ldub [ %i5 + 1 ], %g3
2038368: a5 2c a0 18 sll %l2, 0x18, %l2
203836c: 87 28 e0 10 sll %g3, 0x10, %g3
2038370: a4 14 80 03 or %l2, %g3, %l2
2038374: c6 0f 60 03 ldub [ %i5 + 3 ], %g3
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
2038378: 80 a4 00 14 cmp %l0, %l4
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
eino = rtems_rfs_dir_entry_ino (entry);
203837c: a4 14 80 03 or %l2, %g3, %l2
2038380: c6 0f 60 02 ldub [ %i5 + 2 ], %g3
2038384: 87 28 e0 08 sll %g3, 8, %g3
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
2038388: 12 80 00 2a bne 2038430 <rtems_rfs_dir_add_entry+0x2d0>
203838c: a4 14 80 03 or %l2, %g3, %l2
{
if ((length + RTEMS_RFS_DIR_ENTRY_SIZE) <
(rtems_rfs_fs_block_size (fs) - offset))
2038390: a2 20 40 11 sub %g1, %l1, %l1
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) <
2038394: 80 a5 40 11 cmp %l5, %l1
2038398: 3a bf ff 9c bcc,a 2038208 <rtems_rfs_dir_add_entry+0xa8> <== NEVER TAKEN
203839c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
(rtems_rfs_fs_block_size (fs) - offset))
{
uint32_t hash;
hash = rtems_rfs_dir_hash (name, length);
20383a0: 92 10 00 1b mov %i3, %o1
20383a4: 40 00 25 fc call 2041b94 <rtems_rfs_dir_hash>
20383a8: 90 10 00 1a mov %i2, %o0
rtems_rfs_dir_set_entry_hash (entry, hash);
20383ac: 83 32 20 18 srl %o0, 0x18, %g1
20383b0: c2 2f 60 04 stb %g1, [ %i5 + 4 ]
20383b4: 83 32 20 10 srl %o0, 0x10, %g1
20383b8: c2 2f 60 05 stb %g1, [ %i5 + 5 ]
20383bc: 83 32 20 08 srl %o0, 8, %g1
20383c0: c2 2f 60 06 stb %g1, [ %i5 + 6 ]
rtems_rfs_dir_set_entry_ino (entry, ino);
20383c4: 83 37 20 18 srl %i4, 0x18, %g1
20383c8: c2 2f 40 00 stb %g1, [ %i5 ]
20383cc: 83 37 20 10 srl %i4, 0x10, %g1
20383d0: c2 2f 60 01 stb %g1, [ %i5 + 1 ]
20383d4: 83 37 20 08 srl %i4, 8, %g1
20383d8: c2 2f 60 02 stb %g1, [ %i5 + 2 ]
rtems_rfs_dir_set_entry_length (entry,
20383dc: 82 06 e0 0a add %i3, 0xa, %g1
20383e0: 85 30 60 08 srl %g1, 8, %g2
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);
20383e4: d0 2f 60 07 stb %o0, [ %i5 + 7 ]
rtems_rfs_dir_set_entry_ino (entry, ino);
rtems_rfs_dir_set_entry_length (entry,
20383e8: c4 2f 60 08 stb %g2, [ %i5 + 8 ]
20383ec: c2 2f 60 09 stb %g1, [ %i5 + 9 ]
RTEMS_RFS_DIR_ENTRY_SIZE + length);
memcpy (entry + RTEMS_RFS_DIR_ENTRY_SIZE, name, length);
20383f0: 94 10 00 1b mov %i3, %o2
(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);
20383f4: f8 2f 60 03 stb %i4, [ %i5 + 3 ]
rtems_rfs_dir_set_entry_length (entry,
RTEMS_RFS_DIR_ENTRY_SIZE + length);
memcpy (entry + RTEMS_RFS_DIR_ENTRY_SIZE, name, length);
20383f8: 90 07 60 0a add %i5, 0xa, %o0
20383fc: 40 00 34 bb call 20456e8 <memcpy>
2038400: 92 10 00 1a mov %i2, %o1
rtems_rfs_buffer_mark_dirty (&buffer);
2038404: 82 10 20 01 mov 1, %g1
rtems_rfs_buffer_handle_close (fs, &buffer);
2038408: 92 07 bf a4 add %fp, -92, %o1
rtems_rfs_dir_set_entry_hash (entry, hash);
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);
rtems_rfs_buffer_mark_dirty (&buffer);
203840c: c2 2f bf a4 stb %g1, [ %fp + -92 ]
rtems_rfs_buffer_handle_close (fs, &buffer);
2038410: 7f ff fe 0c call 2037c40 <rtems_rfs_buffer_handle_close>
2038414: 90 10 00 18 mov %i0, %o0
rtems_rfs_block_map_close (fs, &map);
2038418: 90 10 00 18 mov %i0, %o0
203841c: 92 07 bf b0 add %fp, -80, %o1
2038420: 7f ff f8 c7 call 203673c <rtems_rfs_block_map_close>
2038424: ba 10 20 00 clr %i5
}
rtems_rfs_buffer_handle_close (fs, &buffer);
rtems_rfs_block_map_close (fs, &map);
return rc;
}
2038428: 81 c7 e0 08 ret
203842c: 91 e8 00 1d restore %g0, %i5, %o0
}
break;
}
if (rtems_rfs_dir_entry_valid (fs, elength, eino))
2038430: 80 a4 20 0a cmp %l0, 0xa
2038434: 04 80 00 0d ble 2038468 <rtems_rfs_dir_add_entry+0x308> <== NEVER TAKEN
2038438: 90 10 20 00 clr %o0
203843c: c6 06 20 1c ld [ %i0 + 0x1c ], %g3
2038440: 80 a4 00 03 cmp %l0, %g3
2038444: 1a 80 00 09 bcc 2038468 <rtems_rfs_dir_add_entry+0x308> <== NEVER TAKEN
2038448: 80 a4 a0 00 cmp %l2, 0
203844c: 02 80 00 07 be 2038468 <rtems_rfs_dir_add_entry+0x308> <== NEVER TAKEN
2038450: 01 00 00 00 nop
2038454: c6 06 20 14 ld [ %i0 + 0x14 ], %g3
2038458: 80 a4 80 03 cmp %l2, %g3
203845c: 28 80 00 18 bleu,a 20384bc <rtems_rfs_dir_add_entry+0x35c><== ALWAYS TAKEN
2038460: ba 07 40 10 add %i5, %l0, %i5
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_ADD_ENTRY))
2038464: 90 10 20 00 clr %o0 <== NOT EXECUTED
2038468: 7f ff ad 79 call 2023a4c <rtems_rfs_trace> <== NOT EXECUTED
203846c: 13 08 00 00 sethi %hi(0x20000000), %o1 <== NOT EXECUTED
2038470: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
2038474: 02 80 00 0a be 203849c <rtems_rfs_dir_add_entry+0x33c> <== NOT EXECUTED
2038478: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED
printf ("rtems-rfs: dir-add-entry: "
203847c: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED
2038480: 11 00 81 9e sethi %hi(0x2067800), %o0 <== NOT EXECUTED
2038484: 94 10 00 10 mov %l0, %o2 <== NOT EXECUTED
2038488: 90 12 23 40 or %o0, 0x340, %o0 <== NOT EXECUTED
203848c: 96 10 00 12 mov %l2, %o3 <== NOT EXECUTED
2038490: 40 00 39 96 call 2046ae8 <printf> <== NOT EXECUTED
2038494: 98 10 00 11 mov %l1, %o4 <== 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);
2038498: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED
203849c: 7f ff fd e9 call 2037c40 <rtems_rfs_buffer_handle_close> <== NOT EXECUTED
20384a0: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
rtems_rfs_block_map_close (fs, &map);
20384a4: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
20384a8: 92 07 bf b0 add %fp, -80, %o1 <== NOT EXECUTED
20384ac: 7f ff f8 a4 call 203673c <rtems_rfs_block_map_close> <== NOT EXECUTED
20384b0: ba 10 20 05 mov 5, %i5 <== NOT EXECUTED
}
rtems_rfs_buffer_handle_close (fs, &buffer);
rtems_rfs_block_map_close (fs, &map);
return rc;
}
20384b4: 81 c7 e0 08 ret <== NOT EXECUTED
20384b8: 91 e8 00 1d restore %g0, %i5, %o0 <== NOT EXECUTED
rtems_rfs_block_map_close (fs, &map);
return EIO;
}
entry += elength;
offset += elength;
20384bc: a2 04 40 10 add %l1, %l0, %l1
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))
20384c0: 80 a4 40 02 cmp %l1, %g2
20384c4: 2a bf ff a4 bcs,a 2038354 <rtems_rfs_dir_add_entry+0x1f4><== ALWAYS TAKEN
20384c8: c6 0f 60 09 ldub [ %i5 + 9 ], %g3
/*
* 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);
20384cc: 10 bf ff 4f b 2038208 <rtems_rfs_dir_add_entry+0xa8> <== NOT EXECUTED
20384d0: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
entry += elength;
offset += elength;
}
}
rtems_rfs_buffer_handle_close (fs, &buffer);
20384d4: 7f ff fd db call 2037c40 <rtems_rfs_buffer_handle_close> <== NOT EXECUTED
20384d8: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
rtems_rfs_block_map_close (fs, &map);
20384dc: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
20384e0: 7f ff f8 97 call 203673c <rtems_rfs_block_map_close> <== NOT EXECUTED
20384e4: 92 07 bf b0 add %fp, -80, %o1 <== NOT EXECUTED
return rc;
}
20384e8: b0 10 00 1d mov %i5, %i0 <== NOT EXECUTED
20384ec: 81 c7 e0 08 ret <== NOT EXECUTED
20384f0: 81 e8 00 00 restore <== NOT EXECUTED
020384f4 <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)
{
20384f4: 9d e3 bf 38 save %sp, -200, %sp
rtems_rfs_block_no block;
rtems_rfs_buffer_handle buffer;
bool search;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY))
20384f8: 90 10 20 00 clr %o0
20384fc: 13 10 00 00 sethi %hi(0x40000000), %o1
2038500: 7f ff ad 53 call 2023a4c <rtems_rfs_trace>
2038504: ba 10 00 18 mov %i0, %i5
2038508: 80 8a 20 ff btst 0xff, %o0
203850c: 02 80 00 09 be 2038530 <rtems_rfs_dir_del_entry+0x3c> <== ALWAYS TAKEN
2038510: aa 07 bf b0 add %fp, -80, %l5
printf ("rtems-rfs: dir-del-entry: dir=%" PRId32 ", entry=%" PRId32 " offset=%" PRIu32 "\n",
2038514: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED
2038518: 11 00 81 9e sethi %hi(0x2067800), %o0 <== NOT EXECUTED
203851c: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED
2038520: 90 12 23 98 or %o0, 0x398, %o0 <== NOT EXECUTED
2038524: 40 00 39 71 call 2046ae8 <printf> <== NOT EXECUTED
2038528: 96 10 00 1b mov %i3, %o3 <== NOT EXECUTED
rtems_rfs_inode_ino (dir), ino, offset);
rc = rtems_rfs_block_map_open (fs, dir, &map);
203852c: aa 07 bf b0 add %fp, -80, %l5 <== NOT EXECUTED
2038530: 90 10 00 1d mov %i5, %o0
2038534: 92 10 00 19 mov %i1, %o1
2038538: 7f ff f8 20 call 20365b8 <rtems_rfs_block_map_open>
203853c: 94 10 00 15 mov %l5, %o2
if (rc > 0)
2038540: b0 92 20 00 orcc %o0, 0, %i0
2038544: 14 80 00 c4 bg 2038854 <rtems_rfs_dir_del_entry+0x360> <== NEVER TAKEN
2038548: ac 07 bf a0 add %fp, -96, %l6
return rc;
rc = rtems_rfs_block_map_seek (fs, &map, offset, &block);
203854c: 90 10 00 1d mov %i5, %o0
2038550: 92 10 00 15 mov %l5, %o1
2038554: 94 10 20 00 clr %o2
2038558: 96 10 00 1b mov %i3, %o3
203855c: 7f ff f9 48 call 2036a7c <rtems_rfs_block_map_seek>
2038560: 98 10 00 16 mov %l6, %o4
if (rc > 0)
2038564: b0 92 20 00 orcc %o0, 0, %i0
2038568: 04 80 00 06 ble 2038580 <rtems_rfs_dir_del_entry+0x8c> <== ALWAYS TAKEN
203856c: 80 a6 20 06 cmp %i0, 6
{
if (rc == ENXIO)
2038570: 22 80 00 b6 be,a 2038848 <rtems_rfs_dir_del_entry+0x354> <== NOT EXECUTED
2038574: b0 10 20 02 mov 2, %i0 <== NOT EXECUTED
}
}
rtems_rfs_buffer_mark_dirty (&buffer);
rtems_rfs_buffer_handle_close (fs, &buffer);
rtems_rfs_block_map_close (fs, &map);
2038578: 10 80 00 b5 b 203884c <rtems_rfs_dir_del_entry+0x358> <== NOT EXECUTED
203857c: 90 10 00 1d mov %i5, %o0 <== 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)
2038580: 80 a0 00 1b cmp %g0, %i3
int elength;
elength = rtems_rfs_dir_entry_length (entry);
eino = rtems_rfs_dir_entry_ino (entry);
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
2038584: 29 00 00 3f sethi %hi(0xfc00), %l4
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: "
2038588: 2f 00 81 9f sethi %hi(0x2067c00), %l7
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
203858c: c0 2f bf a4 clrb [ %fp + -92 ]
handle->bnum = 0;
2038590: c0 27 bf a8 clr [ %fp + -88 ]
handle->buffer = NULL;
2038594: c0 27 bf ac clr [ %fp + -84 ]
rc = ENOENT;
rtems_rfs_block_map_close (fs, &map);
return rc;
}
rc = rtems_rfs_buffer_handle_open (fs, &buffer);
2038598: b0 10 20 00 clr %i0
/*
* If we are searching start at the beginning of the block. If not searching
* skip to the offset in the block.
*/
if (search)
203859c: a6 60 3f ff subx %g0, -1, %l3
int elength;
elength = rtems_rfs_dir_entry_length (entry);
eino = rtems_rfs_dir_entry_ino (entry);
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
20385a0: a8 15 23 ff or %l4, 0x3ff, %l4
/*
* Only search if the offset is 0 else we are at that position.
*/
search = offset ? false : true;
while (rc == 0)
20385a4: 10 80 00 c1 b 20388a8 <rtems_rfs_dir_del_entry+0x3b4>
20385a8: ae 15 e0 20 or %l7, 0x20, %l7
{
uint8_t* entry;
int eoffset;
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, true);
20385ac: 90 10 00 1d mov %i5, %o0
20385b0: 92 07 bf a4 add %fp, -92, %o1
20385b4: 7f ff fb ee call 203756c <rtems_rfs_buffer_handle_request>
20385b8: 96 10 20 01 mov 1, %o3
if (rc > 0)
20385bc: a4 92 20 00 orcc %o0, 0, %l2
20385c0: 04 80 00 13 ble 203860c <rtems_rfs_dir_del_entry+0x118> <== ALWAYS TAKEN
20385c4: 80 a4 e0 00 cmp %l3, 0
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY))
20385c8: 90 10 20 00 clr %o0 <== NOT EXECUTED
20385cc: 7f ff ad 20 call 2023a4c <rtems_rfs_trace> <== NOT EXECUTED
20385d0: 13 10 00 00 sethi %hi(0x40000000), %o1 <== NOT EXECUTED
20385d4: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
20385d8: 22 80 00 b9 be,a 20388bc <rtems_rfs_dir_del_entry+0x3c8> <== NOT EXECUTED
20385dc: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED
printf ("rtems-rfs: dir-del-entry: "
20385e0: f8 06 60 08 ld [ %i1 + 8 ], %i4 <== NOT EXECUTED
20385e4: 40 00 42 c0 call 20490e4 <strerror> <== NOT EXECUTED
20385e8: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED
20385ec: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
20385f0: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
20385f4: 94 10 00 12 mov %l2, %o2 <== NOT EXECUTED
20385f8: 11 00 81 9e sethi %hi(0x2067800), %o0 <== NOT EXECUTED
20385fc: 40 00 39 3b call 2046ae8 <printf> <== NOT EXECUTED
2038600: 90 12 23 d8 or %o0, 0x3d8, %o0 ! 2067bd8 <__FUNCTION__.7829+0xae8><== NOT EXECUTED
if (rc == ENXIO)
rc = ENOENT;
}
}
rtems_rfs_buffer_handle_close (fs, &buffer);
2038604: 10 80 00 ae b 20388bc <rtems_rfs_dir_del_entry+0x3c8> <== NOT EXECUTED
2038608: 92 07 bf a4 add %fp, -92, %o1 <== 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)
203860c: 12 80 00 06 bne 2038624 <rtems_rfs_dir_del_entry+0x130> <== NEVER TAKEN
2038610: a0 10 20 00 clr %l0
eoffset = 0;
else
eoffset = offset % rtems_rfs_fs_block_size (fs);
2038614: d2 07 60 08 ld [ %i5 + 8 ], %o1
2038618: 40 00 8c 86 call 205b830 <.urem>
203861c: 90 10 00 1b mov %i3, %o0
2038620: a0 10 00 08 mov %o0, %l0
entry = rtems_rfs_buffer_data (&buffer) + eoffset;
2038624: c2 07 bf ac ld [ %fp + -84 ], %g1
2038628: f8 00 60 1c ld [ %g1 + 0x1c ], %i4
while (eoffset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
203862c: c2 07 60 08 ld [ %i5 + 8 ], %g1
if (search)
eoffset = 0;
else
eoffset = offset % rtems_rfs_fs_block_size (fs);
entry = rtems_rfs_buffer_data (&buffer) + eoffset;
2038630: b8 07 00 10 add %i4, %l0, %i4
while (eoffset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
2038634: 10 80 00 8d b 2038868 <rtems_rfs_dir_del_entry+0x374>
2038638: 84 00 7f f6 add %g1, -10, %g2
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
203863c: e2 0f 20 08 ldub [ %i4 + 8 ], %l1
eino = rtems_rfs_dir_entry_ino (entry);
2038640: d6 0f 00 00 ldub [ %i4 ], %o3
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);
2038644: a3 2c 60 08 sll %l1, 8, %l1
2038648: a2 14 40 03 or %l1, %g3, %l1
eino = rtems_rfs_dir_entry_ino (entry);
203864c: c6 0f 20 01 ldub [ %i4 + 1 ], %g3
2038650: 97 2a e0 18 sll %o3, 0x18, %o3
2038654: 87 28 e0 10 sll %g3, 0x10, %g3
2038658: 96 12 c0 03 or %o3, %g3, %o3
203865c: c6 0f 20 03 ldub [ %i4 + 3 ], %g3
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
2038660: 80 a4 40 14 cmp %l1, %l4
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
eino = rtems_rfs_dir_entry_ino (entry);
2038664: 96 12 c0 03 or %o3, %g3, %o3
2038668: c6 0f 20 02 ldub [ %i4 + 2 ], %g3
203866c: 87 28 e0 08 sll %g3, 8, %g3
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
2038670: 02 80 00 81 be 2038874 <rtems_rfs_dir_del_entry+0x380> <== NEVER TAKEN
2038674: 96 12 c0 03 or %o3, %g3, %o3
break;
if (rtems_rfs_dir_entry_valid (fs, elength, eino))
2038678: 80 a4 60 0a cmp %l1, 0xa
203867c: 24 80 00 0d ble,a 20386b0 <rtems_rfs_dir_del_entry+0x1bc><== NEVER TAKEN
2038680: d6 27 bf 9c st %o3, [ %fp + -100 ] <== NOT EXECUTED
2038684: c6 07 60 1c ld [ %i5 + 0x1c ], %g3
2038688: 80 a4 40 03 cmp %l1, %g3
203868c: 1a 80 00 08 bcc 20386ac <rtems_rfs_dir_del_entry+0x1b8> <== NEVER TAKEN
2038690: 80 a2 e0 00 cmp %o3, 0
2038694: 22 80 00 07 be,a 20386b0 <rtems_rfs_dir_del_entry+0x1bc> <== NEVER TAKEN
2038698: d6 27 bf 9c st %o3, [ %fp + -100 ] <== NOT EXECUTED
203869c: c6 07 60 14 ld [ %i5 + 0x14 ], %g3
20386a0: 80 a2 c0 03 cmp %o3, %g3
20386a4: 08 80 00 11 bleu 20386e8 <rtems_rfs_dir_del_entry+0x1f4> <== ALWAYS TAKEN
20386a8: 80 a6 80 0b cmp %i2, %o3
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY))
20386ac: d6 27 bf 9c st %o3, [ %fp + -100 ] <== NOT EXECUTED
20386b0: 90 10 20 00 clr %o0 <== NOT EXECUTED
20386b4: 7f ff ac e6 call 2023a4c <rtems_rfs_trace> <== NOT EXECUTED
20386b8: 13 10 00 00 sethi %hi(0x40000000), %o1 <== NOT EXECUTED
20386bc: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
20386c0: 02 80 00 87 be 20388dc <rtems_rfs_dir_del_entry+0x3e8> <== NOT EXECUTED
20386c4: d6 07 bf 9c ld [ %fp + -100 ], %o3 <== NOT EXECUTED
printf ("rtems-rfs: dir-del-entry: "
20386c8: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED
20386cc: d8 07 bf a0 ld [ %fp + -96 ], %o4 <== NOT EXECUTED
20386d0: 90 10 00 17 mov %l7, %o0 <== NOT EXECUTED
20386d4: 94 10 00 11 mov %l1, %o2 <== NOT EXECUTED
20386d8: 40 00 39 04 call 2046ae8 <printf> <== NOT EXECUTED
20386dc: 9a 10 00 10 mov %l0, %o5 <== NOT EXECUTED
rc = ENOENT;
rtems_rfs_block_map_close (fs, &map);
return rc;
}
rc = rtems_rfs_buffer_handle_open (fs, &buffer);
20386e0: 10 80 00 71 b 20388a4 <rtems_rfs_dir_del_entry+0x3b0> <== NOT EXECUTED
20386e4: a4 10 20 05 mov 5, %l2 <== NOT EXECUTED
rtems_rfs_inode_ino (dir), elength, eino, block, eoffset);
rc = EIO;
break;
}
if (ino == rtems_rfs_dir_entry_ino (entry))
20386e8: 12 80 00 5d bne 203885c <rtems_rfs_dir_del_entry+0x368> <== NEVER TAKEN
20386ec: 80 a4 e0 00 cmp %l3, 0
{
uint32_t remaining;
remaining = rtems_rfs_fs_block_size (fs) - (eoffset + elength);
memmove (entry, entry + elength, remaining);
20386f0: 92 07 00 11 add %i4, %l1, %o1
20386f4: 90 10 00 1c mov %i4, %o0
}
if (ino == rtems_rfs_dir_entry_ino (entry))
{
uint32_t remaining;
remaining = rtems_rfs_fs_block_size (fs) - (eoffset + elength);
20386f8: b6 04 00 11 add %l0, %l1, %i3
20386fc: b6 20 40 1b sub %g1, %i3, %i3
memmove (entry, entry + elength, remaining);
2038700: 40 00 34 37 call 20457dc <memmove>
2038704: 94 10 00 1b mov %i3, %o2
memset (entry + remaining, 0xff, elength);
2038708: 90 07 00 1b add %i4, %i3, %o0
203870c: 92 10 20 ff mov 0xff, %o1
2038710: 40 00 34 85 call 2045924 <memset>
2038714: 94 10 00 11 mov %l1, %o2
* 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);
2038718: c4 0f 20 08 ldub [ %i4 + 8 ], %g2
203871c: c2 0f 20 09 ldub [ %i4 + 9 ], %g1
2038720: 85 28 a0 08 sll %g2, 8, %g2
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY))
2038724: 90 10 20 00 clr %o0
* 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);
2038728: b8 10 80 01 or %g2, %g1, %i4
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY))
203872c: 7f ff ac c8 call 2023a4c <rtems_rfs_trace>
2038730: 13 10 00 00 sethi %hi(0x40000000), %o1
2038734: 80 8a 20 ff btst 0xff, %o0
2038738: 02 80 00 1a be 20387a0 <rtems_rfs_dir_del_entry+0x2ac> <== ALWAYS TAKEN
203873c: 03 3f ff c0 sethi %hi(0xffff0000), %g1
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");
2038740: c2 07 bf c0 ld [ %fp + -64 ], %g1 <== 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: "
2038744: d6 07 bf a0 ld [ %fp + -96 ], %o3 <== NOT EXECUTED
2038748: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
203874c: 12 80 00 08 bne 203876c <rtems_rfs_dir_del_entry+0x278> <== NOT EXECUTED
2038750: c4 07 bf b8 ld [ %fp + -72 ], %g2 <== 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");
2038754: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED
2038758: 12 80 00 06 bne 2038770 <rtems_rfs_dir_del_entry+0x27c> <== NOT EXECUTED
203875c: 84 00 bf ff add %g2, -1, %g2 <== 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: "
2038760: 1b 00 81 9e sethi %hi(0x2067800), %o5 <== NOT EXECUTED
2038764: 10 80 00 08 b 2038784 <rtems_rfs_dir_del_entry+0x290> <== NOT EXECUTED
2038768: 9a 13 63 88 or %o5, 0x388, %o5 ! 2067b88 <__FUNCTION__.7829+0xa98><== 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");
203876c: 84 00 bf ff add %g2, -1, %g2 <== NOT EXECUTED
2038770: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED
2038774: 02 bf ff fc be 2038764 <rtems_rfs_dir_del_entry+0x270> <== NOT EXECUTED
2038778: 1b 00 81 9e sethi %hi(0x2067800), %o5 <== 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: "
203877c: 1b 00 81 9e sethi %hi(0x2067800), %o5 <== NOT EXECUTED
2038780: 9a 13 63 90 or %o5, 0x390, %o5 ! 2067b90 <__FUNCTION__.7829+0xaa0><== NOT EXECUTED
2038784: 11 00 81 9f sethi %hi(0x2067c00), %o0 <== NOT EXECUTED
2038788: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED
203878c: 90 12 20 70 or %o0, 0x70, %o0 <== NOT EXECUTED
2038790: 94 10 00 1c mov %i4, %o2 <== NOT EXECUTED
2038794: 40 00 38 d5 call 2046ae8 <printf> <== NOT EXECUTED
2038798: 98 10 00 10 mov %l0, %o4 <== 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) &&
203879c: 03 3f ff c0 sethi %hi(0xffff0000), %g1 <== NOT EXECUTED
20387a0: b8 38 40 1c xnor %g1, %i4, %i4
20387a4: 80 a7 20 00 cmp %i4, 0
20387a8: 12 80 00 23 bne 2038834 <rtems_rfs_dir_del_entry+0x340>
20387ac: 80 a4 20 00 cmp %l0, 0
20387b0: 12 80 00 21 bne 2038834 <rtems_rfs_dir_del_entry+0x340> <== ALWAYS TAKEN
20387b4: c2 07 bf c0 ld [ %fp + -64 ], %g1
(eoffset == 0) && rtems_rfs_block_map_last (&map))
20387b8: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
20387bc: 12 80 00 05 bne 20387d0 <rtems_rfs_dir_del_entry+0x2dc> <== NOT EXECUTED
20387c0: c4 07 bf b8 ld [ %fp + -72 ], %g2 <== NOT EXECUTED
20387c4: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED
20387c8: 02 80 00 07 be 20387e4 <rtems_rfs_dir_del_entry+0x2f0> <== NOT EXECUTED
20387cc: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
20387d0: 84 00 bf ff add %g2, -1, %g2 <== NOT EXECUTED
20387d4: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED
20387d8: 12 80 00 18 bne 2038838 <rtems_rfs_dir_del_entry+0x344> <== NOT EXECUTED
20387dc: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED
{
rc = rtems_rfs_block_map_shrink (fs, &map, 1);
20387e0: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
20387e4: 92 07 bf b0 add %fp, -80, %o1 <== NOT EXECUTED
20387e8: 7f ff f9 bf call 2036ee4 <rtems_rfs_block_map_shrink> <== NOT EXECUTED
20387ec: 94 10 20 01 mov 1, %o2 <== NOT EXECUTED
if (rc > 0)
20387f0: b8 92 20 00 orcc %o0, 0, %i4 <== NOT EXECUTED
20387f4: 04 80 00 10 ble 2038834 <rtems_rfs_dir_del_entry+0x340> <== NOT EXECUTED
20387f8: 90 10 20 00 clr %o0 <== NOT EXECUTED
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY))
20387fc: 7f ff ac 94 call 2023a4c <rtems_rfs_trace> <== NOT EXECUTED
2038800: 13 10 00 00 sethi %hi(0x40000000), %o1 <== NOT EXECUTED
2038804: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
2038808: 02 80 00 0c be 2038838 <rtems_rfs_dir_del_entry+0x344> <== NOT EXECUTED
203880c: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED
printf ("rtems-rfs: dir-del-entry: "
2038810: f6 06 60 08 ld [ %i1 + 8 ], %i3 <== NOT EXECUTED
2038814: 40 00 42 34 call 20490e4 <strerror> <== NOT EXECUTED
2038818: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
203881c: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
2038820: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
2038824: 94 10 00 1c mov %i4, %o2 <== NOT EXECUTED
2038828: 11 00 81 9f sethi %hi(0x2067c00), %o0 <== NOT EXECUTED
203882c: 40 00 38 af call 2046ae8 <printf> <== NOT EXECUTED
2038830: 90 12 20 d0 or %o0, 0xd0, %o0 ! 2067cd0 <__FUNCTION__.7829+0xbe0><== 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);
2038834: 82 10 20 01 mov 1, %g1
rtems_rfs_buffer_handle_close (fs, &buffer);
2038838: 90 10 00 1d mov %i5, %o0
"block map shrink failed for ino %" PRIu32 ": %d: %s\n",
rtems_rfs_inode_ino (dir), rc, strerror (rc));
}
}
rtems_rfs_buffer_mark_dirty (&buffer);
203883c: c2 2f bf a4 stb %g1, [ %fp + -92 ]
rtems_rfs_buffer_handle_close (fs, &buffer);
2038840: 7f ff fd 00 call 2037c40 <rtems_rfs_buffer_handle_close>
2038844: 92 07 bf a4 add %fp, -92, %o1
rtems_rfs_block_map_close (fs, &map);
2038848: 90 10 00 1d mov %i5, %o0
203884c: 7f ff f7 bc call 203673c <rtems_rfs_block_map_close>
2038850: 92 07 bf b0 add %fp, -80, %o1
2038854: 81 c7 e0 08 ret
2038858: 81 e8 00 00 restore
return 0;
}
if (!search)
203885c: 02 80 00 20 be 20388dc <rtems_rfs_dir_del_entry+0x3e8> <== NOT EXECUTED
2038860: b8 07 00 11 add %i4, %l1, %i4 <== NOT EXECUTED
rc = EIO;
break;
}
entry += elength;
eoffset += elength;
2038864: a0 04 00 11 add %l0, %l1, %l0 <== 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))
2038868: 80 a4 00 02 cmp %l0, %g2
203886c: 2a bf ff 74 bcs,a 203863c <rtems_rfs_dir_del_entry+0x148><== ALWAYS TAKEN
2038870: c6 0f 20 09 ldub [ %i4 + 9 ], %g3
entry += elength;
eoffset += elength;
}
if (rc == 0)
2038874: 80 a4 a0 00 cmp %l2, 0 <== NOT EXECUTED
2038878: 32 80 00 0c bne,a 20388a8 <rtems_rfs_dir_del_entry+0x3b4><== NOT EXECUTED
203887c: b0 10 00 12 mov %l2, %i0 <== NOT EXECUTED
{
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
2038880: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
2038884: 92 10 00 15 mov %l5, %o1 <== NOT EXECUTED
2038888: 7f ff f8 9a call 2036af0 <rtems_rfs_block_map_next_block> <== NOT EXECUTED
203888c: 94 10 00 16 mov %l6, %o2 <== NOT EXECUTED
if (rc == ENXIO)
2038890: 80 a2 20 06 cmp %o0, 6 <== NOT EXECUTED
2038894: 12 80 00 05 bne 20388a8 <rtems_rfs_dir_del_entry+0x3b4> <== NOT EXECUTED
2038898: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED
rc = ENOENT;
203889c: 10 80 00 06 b 20388b4 <rtems_rfs_dir_del_entry+0x3c0> <== NOT EXECUTED
20388a0: b0 10 20 02 mov 2, %i0 <== NOT EXECUTED
rc = ENOENT;
rtems_rfs_block_map_close (fs, &map);
return rc;
}
rc = rtems_rfs_buffer_handle_open (fs, &buffer);
20388a4: b0 10 00 12 mov %l2, %i0 <== NOT EXECUTED
/*
* Only search if the offset is 0 else we are at that position.
*/
search = offset ? false : true;
while (rc == 0)
20388a8: 80 a6 20 00 cmp %i0, 0
20388ac: 02 bf ff 40 be 20385ac <rtems_rfs_dir_del_entry+0xb8> <== ALWAYS TAKEN
20388b0: d4 07 bf a0 ld [ %fp + -96 ], %o2
20388b4: a4 10 00 18 mov %i0, %l2 <== NOT EXECUTED
if (rc == ENXIO)
rc = ENOENT;
}
}
rtems_rfs_buffer_handle_close (fs, &buffer);
20388b8: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED
20388bc: 7f ff fc e1 call 2037c40 <rtems_rfs_buffer_handle_close> <== NOT EXECUTED
20388c0: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
rtems_rfs_block_map_close (fs, &map);
20388c4: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
20388c8: 92 07 bf b0 add %fp, -80, %o1 <== NOT EXECUTED
20388cc: 7f ff f7 9c call 203673c <rtems_rfs_block_map_close> <== NOT EXECUTED
20388d0: b0 10 00 12 mov %l2, %i0 <== NOT EXECUTED
20388d4: 81 c7 e0 08 ret <== NOT EXECUTED
20388d8: 81 e8 00 00 restore <== NOT EXECUTED
rc = ENOENT;
rtems_rfs_block_map_close (fs, &map);
return rc;
}
rc = rtems_rfs_buffer_handle_open (fs, &buffer);
20388dc: 10 bf ff f2 b 20388a4 <rtems_rfs_dir_del_entry+0x3b0> <== NOT EXECUTED
20388e0: a4 10 20 05 mov 5, %l2 <== NOT EXECUTED
02038c74 <rtems_rfs_dir_empty>:
int
rtems_rfs_dir_empty (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* dir)
{
2038c74: 9d e3 bf 40 save %sp, -192, %sp
rtems_rfs_buffer_handle buffer;
rtems_rfs_block_no block;
bool empty;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
2038c78: 90 10 20 00 clr %o0
2038c7c: 7f ff ab 74 call 2023a4c <rtems_rfs_trace>
2038c80: 13 20 00 00 sethi %hi(0x80000000), %o1
2038c84: 80 8a 20 ff btst 0xff, %o0
2038c88: 02 80 00 07 be 2038ca4 <rtems_rfs_dir_empty+0x30> <== ALWAYS TAKEN
2038c8c: b8 07 bf b0 add %fp, -80, %i4
printf ("rtems-rfs: dir-empty: dir=%" PRId32 "\n", rtems_rfs_inode_ino (dir));
2038c90: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED
2038c94: 11 00 81 9f sethi %hi(0x2067c00), %o0 <== NOT EXECUTED
2038c98: 40 00 37 94 call 2046ae8 <printf> <== NOT EXECUTED
2038c9c: 90 12 22 00 or %o0, 0x200, %o0 ! 2067e00 <__FUNCTION__.7829+0xd10><== NOT EXECUTED
empty = true;
rc = rtems_rfs_block_map_open (fs, dir, &map);
2038ca0: b8 07 bf b0 add %fp, -80, %i4 <== NOT EXECUTED
2038ca4: 90 10 00 18 mov %i0, %o0
2038ca8: 92 10 00 19 mov %i1, %o1
2038cac: 7f ff f6 43 call 20365b8 <rtems_rfs_block_map_open>
2038cb0: 94 10 00 1c mov %i4, %o2
if (rc > 0)
2038cb4: ba 92 20 00 orcc %o0, 0, %i5
2038cb8: 34 80 00 82 bg,a 2038ec0 <rtems_rfs_dir_empty+0x24c> <== NEVER TAKEN
2038cbc: b0 10 00 1d mov %i5, %i0 <== NOT EXECUTED
return rc;
rc = rtems_rfs_block_map_seek (fs, &map, 0, &block);
2038cc0: b6 07 bf a0 add %fp, -96, %i3
2038cc4: 90 10 00 18 mov %i0, %o0
2038cc8: 92 10 00 1c mov %i4, %o1
2038ccc: 94 10 20 00 clr %o2
2038cd0: 96 10 20 00 clr %o3
2038cd4: 7f ff f7 6a call 2036a7c <rtems_rfs_block_map_seek>
2038cd8: 98 10 00 1b mov %i3, %o4
if (rc > 0)
2038cdc: ba 92 20 00 orcc %o0, 0, %i5
2038ce0: 04 80 00 05 ble 2038cf4 <rtems_rfs_dir_empty+0x80> <== ALWAYS TAKEN
2038ce4: 25 00 00 3f sethi %hi(0xfc00), %l2
{
rtems_rfs_block_map_close (fs, &map);
2038ce8: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
2038cec: 10 80 00 69 b 2038e90 <rtems_rfs_dir_empty+0x21c> <== NOT EXECUTED
2038cf0: 92 10 00 1c mov %i4, %o1 <== 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: "
2038cf4: 27 00 81 9f sethi %hi(0x2067c00), %l3
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
2038cf8: c0 2f bf a4 clrb [ %fp + -92 ]
handle->bnum = 0;
2038cfc: c0 27 bf a8 clr [ %fp + -88 ]
handle->buffer = NULL;
2038d00: c0 27 bf ac clr [ %fp + -84 ]
int elength;
elength = rtems_rfs_dir_entry_length (entry);
eino = rtems_rfs_dir_entry_ino (entry);
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
2038d04: a4 14 a3 ff or %l2, 0x3ff, %l2
break;
if (rtems_rfs_dir_entry_valid (fs, elength, eino))
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_EMPTY))
printf ("rtems-rfs: dir-empty: "
2038d08: a6 14 e2 20 or %l3, 0x220, %l3
offset += elength;
}
if (empty)
{
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
2038d0c: a2 10 00 1c mov %i4, %l1
2038d10: a0 10 00 1b mov %i3, %l0
while (empty)
{
uint8_t* entry;
int offset;
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, true);
2038d14: d4 07 bf a0 ld [ %fp + -96 ], %o2
2038d18: 90 10 00 18 mov %i0, %o0
2038d1c: 92 07 bf a4 add %fp, -92, %o1
2038d20: 7f ff fa 13 call 203756c <rtems_rfs_buffer_handle_request>
2038d24: 96 10 20 01 mov 1, %o3
if (rc > 0)
2038d28: ba 92 20 00 orcc %o0, 0, %i5
2038d2c: 14 80 00 4c bg 2038e5c <rtems_rfs_dir_empty+0x1e8> <== NEVER TAKEN
2038d30: c2 07 bf ac ld [ %fp + -84 ], %g1
break;
entry = rtems_rfs_buffer_data (&buffer);
offset = 0;
while (offset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
2038d34: c4 06 20 08 ld [ %i0 + 8 ], %g2
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, true);
if (rc > 0)
break;
entry = rtems_rfs_buffer_data (&buffer);
2038d38: c2 00 60 1c ld [ %g1 + 0x1c ], %g1
offset = 0;
while (offset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
2038d3c: 84 00 bf f6 add %g2, -10, %g2
2038d40: 10 80 00 3b b 2038e2c <rtems_rfs_dir_empty+0x1b8>
2038d44: b6 10 20 00 clr %i3
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
2038d48: f8 08 60 08 ldub [ %g1 + 8 ], %i4
eino = rtems_rfs_dir_entry_ino (entry);
2038d4c: f4 08 40 00 ldub [ %g1 ], %i2
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);
2038d50: b9 2f 20 08 sll %i4, 8, %i4
2038d54: b8 17 00 03 or %i4, %g3, %i4
eino = rtems_rfs_dir_entry_ino (entry);
2038d58: c6 08 60 01 ldub [ %g1 + 1 ], %g3
2038d5c: b5 2e a0 18 sll %i2, 0x18, %i2
2038d60: 87 28 e0 10 sll %g3, 0x10, %g3
2038d64: b4 16 80 03 or %i2, %g3, %i2
2038d68: c6 08 60 03 ldub [ %g1 + 3 ], %g3
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
2038d6c: 80 a7 00 12 cmp %i4, %l2
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
eino = rtems_rfs_dir_entry_ino (entry);
2038d70: b4 16 80 03 or %i2, %g3, %i2
2038d74: c6 08 60 02 ldub [ %g1 + 2 ], %g3
2038d78: 87 28 e0 08 sll %g3, 8, %g3
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
2038d7c: 02 80 00 48 be 2038e9c <rtems_rfs_dir_empty+0x228>
2038d80: b4 16 80 03 or %i2, %g3, %i2
break;
if (rtems_rfs_dir_entry_valid (fs, elength, eino))
2038d84: 80 a7 20 0a cmp %i4, 0xa
2038d88: 04 80 00 0d ble 2038dbc <rtems_rfs_dir_empty+0x148> <== NEVER TAKEN
2038d8c: 90 10 20 01 mov 1, %o0
2038d90: c6 06 20 1c ld [ %i0 + 0x1c ], %g3
2038d94: 80 a7 00 03 cmp %i4, %g3
2038d98: 1a 80 00 09 bcc 2038dbc <rtems_rfs_dir_empty+0x148> <== NEVER TAKEN
2038d9c: 80 a6 a0 00 cmp %i2, 0
2038da0: 02 80 00 07 be 2038dbc <rtems_rfs_dir_empty+0x148> <== NEVER TAKEN
2038da4: 01 00 00 00 nop
2038da8: c6 06 20 14 ld [ %i0 + 0x14 ], %g3
2038dac: 80 a6 80 03 cmp %i2, %g3
2038db0: 08 80 00 10 bleu 2038df0 <rtems_rfs_dir_empty+0x17c> <== ALWAYS TAKEN
2038db4: 80 a7 20 0b cmp %i4, 0xb
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_EMPTY))
2038db8: 90 10 20 01 mov 1, %o0 <== NOT EXECUTED
2038dbc: 7f ff ab 24 call 2023a4c <rtems_rfs_trace> <== NOT EXECUTED
2038dc0: 92 10 20 00 clr %o1 <== NOT EXECUTED
2038dc4: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
2038dc8: 22 80 00 36 be,a 2038ea0 <rtems_rfs_dir_empty+0x22c> <== NOT EXECUTED
2038dcc: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
printf ("rtems-rfs: dir-empty: "
2038dd0: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED
2038dd4: 90 10 00 13 mov %l3, %o0 <== NOT EXECUTED
2038dd8: 94 10 00 1c mov %i4, %o2 <== NOT EXECUTED
2038ddc: 96 10 00 1a mov %i2, %o3 <== NOT EXECUTED
2038de0: 40 00 37 42 call 2046ae8 <printf> <== NOT EXECUTED
2038de4: 98 10 00 1b mov %i3, %o4 <== NOT EXECUTED
offset += elength;
}
if (empty)
{
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
2038de8: 10 80 00 2e b 2038ea0 <rtems_rfs_dir_empty+0x22c> <== NOT EXECUTED
2038dec: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
/*
* Ignore the current (.) and parent (..) entries. Anything else means
* the directory is not empty.
*/
if (((elength != (RTEMS_RFS_DIR_ENTRY_SIZE + 1)) ||
2038df0: 12 80 00 04 bne 2038e00 <rtems_rfs_dir_empty+0x18c>
2038df4: 80 a7 20 0c cmp %i4, 0xc
2038df8: 10 80 00 09 b 2038e1c <rtems_rfs_dir_empty+0x1a8>
2038dfc: c6 08 60 0a ldub [ %g1 + 0xa ], %g3
(entry[RTEMS_RFS_DIR_ENTRY_SIZE] != '.')) &&
2038e00: 32 80 00 18 bne,a 2038e60 <rtems_rfs_dir_empty+0x1ec>
2038e04: 82 10 20 00 clr %g1
((elength != (RTEMS_RFS_DIR_ENTRY_SIZE + 2)) ||
2038e08: c6 08 60 0a ldub [ %g1 + 0xa ], %g3
2038e0c: 80 a0 e0 2e cmp %g3, 0x2e
2038e10: 32 80 00 14 bne,a 2038e60 <rtems_rfs_dir_empty+0x1ec> <== NEVER TAKEN
2038e14: 82 10 20 00 clr %g1 <== NOT EXECUTED
(entry[RTEMS_RFS_DIR_ENTRY_SIZE] != '.') ||
2038e18: c6 08 60 0b ldub [ %g1 + 0xb ], %g3
2038e1c: 80 a0 e0 2e cmp %g3, 0x2e
2038e20: 12 80 00 0c bne 2038e50 <rtems_rfs_dir_empty+0x1dc> <== NEVER TAKEN
2038e24: b6 06 c0 1c add %i3, %i4, %i3
{
empty = false;
break;
}
entry += elength;
2038e28: 82 00 40 1c add %g1, %i4, %g1
break;
entry = rtems_rfs_buffer_data (&buffer);
offset = 0;
while (offset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
2038e2c: 80 a6 c0 02 cmp %i3, %g2
2038e30: 2a bf ff c6 bcs,a 2038d48 <rtems_rfs_dir_empty+0xd4> <== ALWAYS TAKEN
2038e34: c6 08 60 09 ldub [ %g1 + 9 ], %g3
offset += elength;
}
if (empty)
{
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
2038e38: 10 80 00 1a b 2038ea0 <rtems_rfs_dir_empty+0x22c> <== NOT EXECUTED
2038e3c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
if (rc > 0)
{
if (rc == ENXIO)
2038e40: 02 80 00 06 be 2038e58 <rtems_rfs_dir_empty+0x1e4> <== ALWAYS TAKEN
2038e44: 82 10 20 01 mov 1, %g1
break;
}
}
}
if ((rc == 0) && !empty)
2038e48: 10 80 00 07 b 2038e64 <rtems_rfs_dir_empty+0x1f0> <== NOT EXECUTED
2038e4c: 82 18 60 01 xor %g1, 1, %g1 <== NOT EXECUTED
* the directory is not empty.
*/
if (((elength != (RTEMS_RFS_DIR_ENTRY_SIZE + 1)) ||
(entry[RTEMS_RFS_DIR_ENTRY_SIZE] != '.')) &&
((elength != (RTEMS_RFS_DIR_ENTRY_SIZE + 2)) ||
(entry[RTEMS_RFS_DIR_ENTRY_SIZE] != '.') ||
2038e50: 10 80 00 04 b 2038e60 <rtems_rfs_dir_empty+0x1ec> <== NOT EXECUTED
2038e54: 82 10 20 00 clr %g1 <== NOT EXECUTED
{
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
if (rc > 0)
{
if (rc == ENXIO)
rc = 0;
2038e58: ba 10 20 00 clr %i5
if (empty)
{
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
if (rc > 0)
{
if (rc == ENXIO)
2038e5c: 82 10 20 01 mov 1, %g1
break;
}
}
}
if ((rc == 0) && !empty)
2038e60: 82 18 60 01 xor %g1, 1, %g1
2038e64: 80 88 60 ff btst 0xff, %g1
2038e68: 02 80 00 06 be 2038e80 <rtems_rfs_dir_empty+0x20c>
2038e6c: 92 07 bf a4 add %fp, -92, %o1
2038e70: 80 a7 60 00 cmp %i5, 0
2038e74: 22 80 00 03 be,a 2038e80 <rtems_rfs_dir_empty+0x20c> <== ALWAYS TAKEN
2038e78: ba 10 20 5a mov 0x5a, %i5
rc = ENOTEMPTY;
rtems_rfs_buffer_handle_close (fs, &buffer);
2038e7c: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED
2038e80: 7f ff fb 70 call 2037c40 <rtems_rfs_buffer_handle_close>
2038e84: 90 10 00 18 mov %i0, %o0
rtems_rfs_block_map_close (fs, &map);
2038e88: 90 10 00 18 mov %i0, %o0
2038e8c: 92 07 bf b0 add %fp, -80, %o1
2038e90: 7f ff f6 2b call 203673c <rtems_rfs_block_map_close>
2038e94: b0 10 00 1d mov %i5, %i0
2038e98: 30 80 00 0a b,a 2038ec0 <rtems_rfs_dir_empty+0x24c>
offset += elength;
}
if (empty)
{
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
2038e9c: 90 10 00 18 mov %i0, %o0
2038ea0: 92 10 00 11 mov %l1, %o1
2038ea4: 7f ff f7 13 call 2036af0 <rtems_rfs_block_map_next_block>
2038ea8: 94 10 00 10 mov %l0, %o2
if (rc > 0)
2038eac: ba 92 20 00 orcc %o0, 0, %i5
2038eb0: 24 bf ff 9a ble,a 2038d18 <rtems_rfs_dir_empty+0xa4> <== NEVER TAKEN
2038eb4: d4 07 bf a0 ld [ %fp + -96 ], %o2 <== NOT EXECUTED
{
if (rc == ENXIO)
2038eb8: 10 bf ff e2 b 2038e40 <rtems_rfs_dir_empty+0x1cc>
2038ebc: 80 a7 60 06 cmp %i5, 6
rc = ENOTEMPTY;
rtems_rfs_buffer_handle_close (fs, &buffer);
rtems_rfs_block_map_close (fs, &map);
return rc;
}
2038ec0: 81 c7 e0 08 ret
2038ec4: 81 e8 00 00 restore
02041b94 <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;
2041b94: 05 37 f7 c5 sethi %hi(0xdfdf1400), %g2
2041b98: 84 10 a2 9f or %g2, 0x29f, %g2 ! dfdf169f <RAM_END+0xdd9f169f>
2041b9c: 84 02 40 02 add %o1, %g2, %g2
2041ba0: 86 10 00 02 mov %g2, %g3
} 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)
2041ba4: 10 80 00 48 b 2041cc4 <rtems_rfs_dir_hash+0x130>
2041ba8: 88 10 00 02 mov %g2, %g4
{
a += k[0];
a += ((uint32_t)k[1])<<8;
a += ((uint32_t)k[2])<<16;
2041bac: d8 0a 20 02 ldub [ %o0 + 2 ], %o4
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];
2041bb0: 88 03 40 04 add %o5, %g4, %g4
a += ((uint32_t)k[1])<<8;
2041bb4: da 0a 20 01 ldub [ %o0 + 1 ], %o5
a += ((uint32_t)k[2])<<16;
2041bb8: 99 2b 20 10 sll %o4, 0x10, %o4
/*--------------- all but the last block: affect some 32 bits of (a,b,c) */
while (length > 12)
{
a += k[0];
a += ((uint32_t)k[1])<<8;
2041bbc: 9b 2b 60 08 sll %o5, 8, %o5
2041bc0: 9a 01 00 0d add %g4, %o5, %o5
a += ((uint32_t)k[2])<<16;
a += ((uint32_t)k[3])<<24;
b += k[4];
2041bc4: c8 0a 20 04 ldub [ %o0 + 4 ], %g4
/*--------------- all but the last block: affect some 32 bits of (a,b,c) */
while (length > 12)
{
a += k[0];
a += ((uint32_t)k[1])<<8;
a += ((uint32_t)k[2])<<16;
2041bc8: 9a 03 40 0c add %o5, %o4, %o5
a += ((uint32_t)k[3])<<24;
b += k[4];
2041bcc: 86 01 00 03 add %g4, %g3, %g3
b += ((uint32_t)k[5])<<8;
2041bd0: c8 0a 20 05 ldub [ %o0 + 5 ], %g4
while (length > 12)
{
a += k[0];
a += ((uint32_t)k[1])<<8;
a += ((uint32_t)k[2])<<16;
a += ((uint32_t)k[3])<<24;
2041bd4: d8 0a 20 03 ldub [ %o0 + 3 ], %o4
b += k[4];
b += ((uint32_t)k[5])<<8;
2041bd8: 89 29 20 08 sll %g4, 8, %g4
2041bdc: 86 00 c0 04 add %g3, %g4, %g3
b += ((uint32_t)k[6])<<16;
2041be0: c8 0a 20 06 ldub [ %o0 + 6 ], %g4
while (length > 12)
{
a += k[0];
a += ((uint32_t)k[1])<<8;
a += ((uint32_t)k[2])<<16;
a += ((uint32_t)k[3])<<24;
2041be4: 99 2b 20 18 sll %o4, 0x18, %o4
b += k[4];
b += ((uint32_t)k[5])<<8;
b += ((uint32_t)k[6])<<16;
2041be8: 89 29 20 10 sll %g4, 0x10, %g4
2041bec: 86 00 c0 04 add %g3, %g4, %g3
b += ((uint32_t)k[7])<<24;
2041bf0: c8 0a 20 07 ldub [ %o0 + 7 ], %g4
while (length > 12)
{
a += k[0];
a += ((uint32_t)k[1])<<8;
a += ((uint32_t)k[2])<<16;
a += ((uint32_t)k[3])<<24;
2041bf4: 9a 03 40 0c add %o5, %o4, %o5
b += k[4];
b += ((uint32_t)k[5])<<8;
b += ((uint32_t)k[6])<<16;
b += ((uint32_t)k[7])<<24;
2041bf8: 89 29 20 18 sll %g4, 0x18, %g4
2041bfc: 86 00 c0 04 add %g3, %g4, %g3
c += k[8];
2041c00: c8 0a 20 08 ldub [ %o0 + 8 ], %g4
c += ((uint32_t)k[9])<<8;
c += ((uint32_t)k[10])<<16;
c += ((uint32_t)k[11])<<24;
mix(a,b,c);
length -= 12;
2041c04: 92 02 7f f4 add %o1, -12, %o1
a += ((uint32_t)k[3])<<24;
b += k[4];
b += ((uint32_t)k[5])<<8;
b += ((uint32_t)k[6])<<16;
b += ((uint32_t)k[7])<<24;
c += k[8];
2041c08: 84 01 00 02 add %g4, %g2, %g2
c += ((uint32_t)k[9])<<8;
2041c0c: c8 0a 20 09 ldub [ %o0 + 9 ], %g4
2041c10: 89 29 20 08 sll %g4, 8, %g4
2041c14: 84 00 80 04 add %g2, %g4, %g2
c += ((uint32_t)k[10])<<16;
2041c18: c8 0a 20 0a ldub [ %o0 + 0xa ], %g4
2041c1c: 89 29 20 10 sll %g4, 0x10, %g4
2041c20: 84 00 80 04 add %g2, %g4, %g2
c += ((uint32_t)k[11])<<24;
2041c24: c8 0a 20 0b ldub [ %o0 + 0xb ], %g4
mix(a,b,c);
length -= 12;
k += 12;
2041c28: 90 02 20 0c add %o0, 0xc, %o0
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;
2041c2c: 89 29 20 18 sll %g4, 0x18, %g4
2041c30: 84 00 80 04 add %g2, %g4, %g2
mix(a,b,c);
2041c34: 9a 23 40 02 sub %o5, %g2, %o5
2041c38: 99 28 a0 04 sll %g2, 4, %o4
2041c3c: 89 30 a0 1c srl %g2, 0x1c, %g4
2041c40: 88 13 00 04 or %o4, %g4, %g4
2041c44: 88 1b 40 04 xor %o5, %g4, %g4
2041c48: 99 29 20 06 sll %g4, 6, %o4
2041c4c: 9b 31 20 1a srl %g4, 0x1a, %o5
2041c50: 9a 13 00 0d or %o4, %o5, %o5
2041c54: 84 00 80 03 add %g2, %g3, %g2
2041c58: 86 20 c0 04 sub %g3, %g4, %g3
2041c5c: 86 1b 40 03 xor %o5, %g3, %g3
2041c60: 99 28 e0 08 sll %g3, 8, %o4
2041c64: 9b 30 e0 18 srl %g3, 0x18, %o5
2041c68: 9a 13 00 0d or %o4, %o5, %o5
2041c6c: 88 01 00 02 add %g4, %g2, %g4
2041c70: 84 20 80 03 sub %g2, %g3, %g2
2041c74: 84 1b 40 02 xor %o5, %g2, %g2
2041c78: 99 28 a0 10 sll %g2, 0x10, %o4
2041c7c: 9b 30 a0 10 srl %g2, 0x10, %o5
2041c80: 9a 13 00 0d or %o4, %o5, %o5
2041c84: 86 00 c0 04 add %g3, %g4, %g3
2041c88: 88 21 00 02 sub %g4, %g2, %g4
2041c8c: 88 1b 40 04 xor %o5, %g4, %g4
2041c90: 99 29 20 13 sll %g4, 0x13, %o4
2041c94: 9b 31 20 0d srl %g4, 0xd, %o5
2041c98: 9a 13 00 0d or %o4, %o5, %o5
2041c9c: 84 00 80 03 add %g2, %g3, %g2
2041ca0: 86 20 c0 04 sub %g3, %g4, %g3
2041ca4: 88 01 00 02 add %g4, %g2, %g4
2041ca8: 86 1b 40 03 xor %o5, %g3, %g3
2041cac: 84 20 80 03 sub %g2, %g3, %g2
2041cb0: 99 28 e0 04 sll %g3, 4, %o4
2041cb4: 9b 30 e0 1c srl %g3, 0x1c, %o5
2041cb8: 86 00 c0 04 add %g3, %g4, %g3
2041cbc: 9a 13 00 0d or %o4, %o5, %o5
2041cc0: 84 1b 40 02 xor %o5, %g2, %g2
} 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)
2041cc4: 80 a2 60 0c cmp %o1, 0xc
2041cc8: 38 bf ff b9 bgu,a 2041bac <rtems_rfs_dir_hash+0x18>
2041ccc: da 0a 00 00 ldub [ %o0 ], %o5
length -= 12;
k += 12;
}
/*-------------------------------- last block: affect all 32 bits of (c) */
switch(length) /* all the case statements fall through */
2041cd0: 92 02 7f ff add %o1, -1, %o1
2041cd4: 80 a2 60 0b cmp %o1, 0xb
2041cd8: 18 80 00 4b bgu 2041e04 <rtems_rfs_dir_hash+0x270> <== NEVER TAKEN
2041cdc: 93 2a 60 02 sll %o1, 2, %o1
2041ce0: 1b 00 81 06 sethi %hi(0x2041800), %o5
2041ce4: 9a 13 63 64 or %o5, 0x364, %o5 ! 2041b64 <rtems_rfs_buffer_bdbuf_release+0x80>
2041ce8: da 03 40 09 ld [ %o5 + %o1 ], %o5
2041cec: 81 c3 40 00 jmp %o5
2041cf0: 01 00 00 00 nop
{
case 12: c+=((uint32_t)k[11])<<24;
2041cf4: da 0a 20 0b ldub [ %o0 + 0xb ], %o5
2041cf8: 9b 2b 60 18 sll %o5, 0x18, %o5
2041cfc: 84 03 40 02 add %o5, %g2, %g2
case 11: c+=((uint32_t)k[10])<<16;
2041d00: da 0a 20 0a ldub [ %o0 + 0xa ], %o5
2041d04: 9b 2b 60 10 sll %o5, 0x10, %o5
2041d08: 84 00 80 0d add %g2, %o5, %g2
case 10: c+=((uint32_t)k[9])<<8;
2041d0c: da 0a 20 09 ldub [ %o0 + 9 ], %o5
2041d10: 9b 2b 60 08 sll %o5, 8, %o5
2041d14: 84 00 80 0d add %g2, %o5, %g2
case 9 : c+=k[8];
2041d18: da 0a 20 08 ldub [ %o0 + 8 ], %o5
2041d1c: 84 00 80 0d add %g2, %o5, %g2
case 8 : b+=((uint32_t)k[7])<<24;
2041d20: da 0a 20 07 ldub [ %o0 + 7 ], %o5
2041d24: 9b 2b 60 18 sll %o5, 0x18, %o5
2041d28: 86 03 40 03 add %o5, %g3, %g3
case 7 : b+=((uint32_t)k[6])<<16;
2041d2c: da 0a 20 06 ldub [ %o0 + 6 ], %o5
2041d30: 9b 2b 60 10 sll %o5, 0x10, %o5
2041d34: 86 00 c0 0d add %g3, %o5, %g3
case 6 : b+=((uint32_t)k[5])<<8;
2041d38: da 0a 20 05 ldub [ %o0 + 5 ], %o5
2041d3c: 9b 2b 60 08 sll %o5, 8, %o5
2041d40: 86 00 c0 0d add %g3, %o5, %g3
case 5 : b+=k[4];
2041d44: da 0a 20 04 ldub [ %o0 + 4 ], %o5
2041d48: 86 00 c0 0d add %g3, %o5, %g3
case 4 : a+=((uint32_t)k[3])<<24;
2041d4c: da 0a 20 03 ldub [ %o0 + 3 ], %o5
2041d50: 9b 2b 60 18 sll %o5, 0x18, %o5
2041d54: 88 03 40 04 add %o5, %g4, %g4
case 3 : a+=((uint32_t)k[2])<<16;
2041d58: da 0a 20 02 ldub [ %o0 + 2 ], %o5
2041d5c: 9b 2b 60 10 sll %o5, 0x10, %o5
2041d60: 88 01 00 0d add %g4, %o5, %g4
case 2 : a+=((uint32_t)k[1])<<8;
2041d64: da 0a 20 01 ldub [ %o0 + 1 ], %o5
2041d68: 9b 2b 60 08 sll %o5, 8, %o5
2041d6c: 88 01 00 0d add %g4, %o5, %g4
case 1 : a+=k[0];
2041d70: c2 0a 00 00 ldub [ %o0 ], %g1
break;
case 0 : return c;
}
}
final(a,b,c);
2041d74: 9b 30 e0 12 srl %g3, 0x12, %o5
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];
2041d78: 88 01 00 01 add %g4, %g1, %g4
break;
case 0 : return c;
}
}
final(a,b,c);
2041d7c: 83 28 e0 0e sll %g3, 0xe, %g1
2041d80: 82 13 40 01 or %o5, %g1, %g1
2041d84: 84 18 80 03 xor %g2, %g3, %g2
2041d88: 84 20 80 01 sub %g2, %g1, %g2
2041d8c: 9b 28 a0 0b sll %g2, 0xb, %o5
2041d90: 83 30 a0 15 srl %g2, 0x15, %g1
2041d94: 82 13 40 01 or %o5, %g1, %g1
2041d98: 88 18 80 04 xor %g2, %g4, %g4
2041d9c: 88 21 00 01 sub %g4, %g1, %g4
2041da0: 9b 29 20 19 sll %g4, 0x19, %o5
2041da4: 83 31 20 07 srl %g4, 7, %g1
2041da8: 82 13 40 01 or %o5, %g1, %g1
2041dac: 86 19 00 03 xor %g4, %g3, %g3
2041db0: 86 20 c0 01 sub %g3, %g1, %g3
2041db4: 9b 28 e0 10 sll %g3, 0x10, %o5
2041db8: 83 30 e0 10 srl %g3, 0x10, %g1
2041dbc: 82 13 40 01 or %o5, %g1, %g1
2041dc0: 84 18 c0 02 xor %g3, %g2, %g2
2041dc4: 84 20 80 01 sub %g2, %g1, %g2
2041dc8: 9b 28 a0 04 sll %g2, 4, %o5
2041dcc: 83 30 a0 1c srl %g2, 0x1c, %g1
2041dd0: 82 13 40 01 or %o5, %g1, %g1
2041dd4: 88 18 80 04 xor %g2, %g4, %g4
2041dd8: 88 21 00 01 sub %g4, %g1, %g4
2041ddc: 83 29 20 0e sll %g4, 0xe, %g1
2041de0: 86 19 00 03 xor %g4, %g3, %g3
2041de4: 89 31 20 12 srl %g4, 0x12, %g4
2041de8: 88 10 40 04 or %g1, %g4, %g4
2041dec: 86 20 c0 04 sub %g3, %g4, %g3
2041df0: 84 18 c0 02 xor %g3, %g2, %g2
2041df4: 83 28 e0 18 sll %g3, 0x18, %g1
2041df8: 87 30 e0 08 srl %g3, 8, %g3
2041dfc: 86 10 40 03 or %g1, %g3, %g3
2041e00: 84 20 80 03 sub %g2, %g3, %g2
return c;
}
2041e04: 81 c3 e0 08 retl
2041e08: 90 10 00 02 mov %g2, %o0
02037c68 <rtems_rfs_dir_lookup_ino>:
rtems_rfs_inode_handle* inode,
const char* name,
int length,
rtems_rfs_ino* ino,
uint32_t* offset)
{
2037c68: 9d e3 bf 38 save %sp, -200, %sp
rtems_rfs_block_map map;
rtems_rfs_buffer_handle entries;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
2037c6c: 90 10 20 00 clr %o0
2037c70: 13 01 00 00 sethi %hi(0x4000000), %o1
2037c74: 7f ff af 76 call 2023a4c <rtems_rfs_trace>
2037c78: a0 10 00 18 mov %i0, %l0
2037c7c: 80 8a 20 ff btst 0xff, %o0
2037c80: 22 80 00 13 be,a 2037ccc <rtems_rfs_dir_lookup_ino+0x64> <== ALWAYS TAKEN
2037c84: c0 27 00 00 clr [ %i4 ]
{
int c;
printf ("rtems-rfs: dir-lookup-ino: lookup ino: root=%" PRId32 ", path=",
2037c88: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED
2037c8c: 11 00 81 9d sethi %hi(0x2067400), %o0 <== NOT EXECUTED
inode->ino);
for (c = 0; c < length; c++)
2037c90: b0 10 20 00 clr %i0 <== NOT EXECUTED
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
{
int c;
printf ("rtems-rfs: dir-lookup-ino: lookup ino: root=%" PRId32 ", path=",
2037c94: 40 00 3b 95 call 2046ae8 <printf> <== NOT EXECUTED
2037c98: 90 12 23 58 or %o0, 0x358, %o0 <== NOT EXECUTED
inode->ino);
for (c = 0; c < length; c++)
2037c9c: 10 80 00 05 b 2037cb0 <rtems_rfs_dir_lookup_ino+0x48> <== NOT EXECUTED
2037ca0: 80 a6 00 1b cmp %i0, %i3 <== NOT EXECUTED
printf ("%c", name[c]);
2037ca4: 40 00 3b fb call 2046c90 <putchar> <== NOT EXECUTED
2037ca8: b0 06 20 01 inc %i0 <== 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++)
2037cac: 80 a6 00 1b cmp %i0, %i3 <== NOT EXECUTED
2037cb0: 26 bf ff fd bl,a 2037ca4 <rtems_rfs_dir_lookup_ino+0x3c> <== NOT EXECUTED
2037cb4: d0 4e 80 18 ldsb [ %i2 + %i0 ], %o0 <== NOT EXECUTED
printf ("%c", name[c]);
printf (", len=%d\n", length);
2037cb8: 11 00 81 9d sethi %hi(0x2067400), %o0 <== NOT EXECUTED
2037cbc: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
2037cc0: 40 00 3b 8a call 2046ae8 <printf> <== NOT EXECUTED
2037cc4: 90 12 23 90 or %o0, 0x390, %o0 <== NOT EXECUTED
}
*ino = RTEMS_RFS_EMPTY_INO;
2037cc8: c0 27 00 00 clr [ %i4 ] <== NOT EXECUTED
*offset = 0;
2037ccc: c0 27 40 00 clr [ %i5 ]
rc = rtems_rfs_block_map_open (fs, inode, &map);
2037cd0: 90 10 00 10 mov %l0, %o0
2037cd4: 92 10 00 19 mov %i1, %o1
2037cd8: 7f ff fa 38 call 20365b8 <rtems_rfs_block_map_open>
2037cdc: 94 07 bf b0 add %fp, -80, %o2
if (rc > 0)
2037ce0: b0 92 20 00 orcc %o0, 0, %i0
2037ce4: 04 80 00 12 ble 2037d2c <rtems_rfs_dir_lookup_ino+0xc4> <== ALWAYS TAKEN
2037ce8: 90 10 20 00 clr %o0
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
2037cec: 7f ff af 58 call 2023a4c <rtems_rfs_trace> <== NOT EXECUTED
2037cf0: 13 01 00 00 sethi %hi(0x4000000), %o1 <== NOT EXECUTED
2037cf4: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
2037cf8: 02 80 01 18 be 2038158 <rtems_rfs_dir_lookup_ino+0x4f0> <== NOT EXECUTED
2037cfc: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: dir-lookup-ino: map open failed for ino %" PRIu32 ": %d: %s",
2037d00: fa 06 60 08 ld [ %i1 + 8 ], %i5 <== NOT EXECUTED
2037d04: 40 00 44 f8 call 20490e4 <strerror> <== NOT EXECUTED
2037d08: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
2037d0c: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
2037d10: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
2037d14: 94 10 00 18 mov %i0, %o2 <== NOT EXECUTED
2037d18: 11 00 81 9d sethi %hi(0x2067400), %o0 <== NOT EXECUTED
2037d1c: 40 00 3b 73 call 2046ae8 <printf> <== NOT EXECUTED
2037d20: 90 12 23 a0 or %o0, 0x3a0, %o0 ! 20677a0 <__FUNCTION__.7829+0x6b0><== NOT EXECUTED
2037d24: 81 c7 e0 08 ret <== NOT EXECUTED
2037d28: 81 e8 00 00 restore <== NOT EXECUTED
uint32_t hash;
/*
* Calculate the hash of the look up string.
*/
hash = rtems_rfs_dir_hash (name, length);
2037d2c: 92 10 00 1b mov %i3, %o1
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
2037d30: c0 2f bf a4 clrb [ %fp + -92 ]
handle->bnum = 0;
2037d34: c0 27 bf a8 clr [ %fp + -88 ]
handle->buffer = NULL;
2037d38: c0 27 bf ac clr [ %fp + -84 ]
2037d3c: 40 00 27 96 call 2041b94 <rtems_rfs_dir_hash>
2037d40: 90 10 00 1a mov %i2, %o0
/*
* 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);
2037d44: 92 07 bf b0 add %fp, -80, %o1
uint32_t hash;
/*
* Calculate the hash of the look up string.
*/
hash = rtems_rfs_dir_hash (name, length);
2037d48: d0 27 bf 9c st %o0, [ %fp + -100 ]
/*
* 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);
2037d4c: 94 10 20 00 clr %o2
2037d50: 90 10 00 10 mov %l0, %o0
2037d54: 96 10 20 00 clr %o3
2037d58: 7f ff fb 49 call 2036a7c <rtems_rfs_block_map_seek>
2037d5c: 98 07 bf a0 add %fp, -96, %o4
if (rc > 0)
2037d60: b0 92 20 00 orcc %o0, 0, %i0
2037d64: 04 80 00 d3 ble 20380b0 <rtems_rfs_dir_lookup_ino+0x448> <== ALWAYS TAKEN
2037d68: 90 10 20 00 clr %o0
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
2037d6c: 7f ff af 38 call 2023a4c <rtems_rfs_trace> <== NOT EXECUTED
2037d70: 13 01 00 00 sethi %hi(0x4000000), %o1 <== NOT EXECUTED
2037d74: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
2037d78: 02 80 00 0a be 2037da0 <rtems_rfs_dir_lookup_ino+0x138> <== NOT EXECUTED
2037d7c: 80 a6 20 06 cmp %i0, 6 <== NOT EXECUTED
printf ("rtems-rfs: dir-lookup-ino: block map find failed: %d: %s\n",
2037d80: 40 00 44 d9 call 20490e4 <strerror> <== NOT EXECUTED
2037d84: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
2037d88: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
2037d8c: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
2037d90: 11 00 81 9d sethi %hi(0x2067400), %o0 <== NOT EXECUTED
2037d94: 40 00 3b 55 call 2046ae8 <printf> <== NOT EXECUTED
2037d98: 90 12 23 e0 or %o0, 0x3e0, %o0 ! 20677e0 <__FUNCTION__.7829+0x6f0><== NOT EXECUTED
rc, strerror (rc));
if (rc == ENXIO)
2037d9c: 80 a6 20 06 cmp %i0, 6 <== NOT EXECUTED
2037da0: 22 80 00 dc be,a 2038110 <rtems_rfs_dir_lookup_ino+0x4a8><== NOT EXECUTED
2037da4: b0 10 20 02 mov 2, %i0 <== 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);
2037da8: 10 80 00 db b 2038114 <rtems_rfs_dir_lookup_ino+0x4ac> <== NOT EXECUTED
2037dac: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED
while ((rc == 0) && block)
{
uint8_t* entry;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
2037db0: 7f ff af 27 call 2023a4c <rtems_rfs_trace>
2037db4: 13 01 00 00 sethi %hi(0x4000000), %o1
2037db8: 80 8a 20 ff btst 0xff, %o0
2037dbc: 02 80 00 08 be 2037ddc <rtems_rfs_dir_lookup_ino+0x174> <== ALWAYS TAKEN
2037dc0: d4 07 bf a0 ld [ %fp + -96 ], %o2
printf ("rtems-rfs: dir-lookup-ino: block read, ino=%" PRIu32 " bno=%" PRId32 "\n",
2037dc4: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED
2037dc8: d4 07 bf c0 ld [ %fp + -64 ], %o2 <== NOT EXECUTED
2037dcc: 11 00 81 9e sethi %hi(0x2067800), %o0 <== NOT EXECUTED
2037dd0: 40 00 3b 46 call 2046ae8 <printf> <== NOT EXECUTED
2037dd4: 90 12 20 20 or %o0, 0x20, %o0 ! 2067820 <__FUNCTION__.7829+0x730><== NOT EXECUTED
rtems_rfs_inode_ino (inode), map.bpos.bno);
rc = rtems_rfs_buffer_handle_request (fs, &entries, block, true);
2037dd8: d4 07 bf a0 ld [ %fp + -96 ], %o2 <== NOT EXECUTED
2037ddc: 90 10 00 10 mov %l0, %o0
2037de0: 92 07 bf a4 add %fp, -92, %o1
2037de4: 7f ff fd e2 call 203756c <rtems_rfs_buffer_handle_request>
2037de8: 96 10 20 01 mov 1, %o3
if (rc > 0)
2037dec: a2 92 20 00 orcc %o0, 0, %l1
2037df0: 04 80 00 15 ble 2037e44 <rtems_rfs_dir_lookup_ino+0x1dc> <== ALWAYS TAKEN
2037df4: c2 07 bf ac ld [ %fp + -84 ], %g1
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
2037df8: 90 10 20 00 clr %o0 <== NOT EXECUTED
2037dfc: 7f ff af 14 call 2023a4c <rtems_rfs_trace> <== NOT EXECUTED
2037e00: 13 01 00 00 sethi %hi(0x4000000), %o1 <== NOT EXECUTED
2037e04: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
2037e08: 22 80 00 c2 be,a 2038110 <rtems_rfs_dir_lookup_ino+0x4a8><== NOT EXECUTED
2037e0c: b0 10 00 11 mov %l1, %i0 <== NOT EXECUTED
printf ("rtems-rfs: dir-lookup-ino: block read, ino=%" PRIu32 " block=%" PRId32 ": %d: %s\n",
2037e10: f8 06 60 08 ld [ %i1 + 8 ], %i4 <== NOT EXECUTED
2037e14: fa 07 bf a0 ld [ %fp + -96 ], %i5 <== NOT EXECUTED
2037e18: 40 00 44 b3 call 20490e4 <strerror> <== NOT EXECUTED
2037e1c: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED
2037e20: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
2037e24: 98 10 00 08 mov %o0, %o4 <== NOT EXECUTED
2037e28: 94 10 00 1d mov %i5, %o2 <== NOT EXECUTED
2037e2c: 11 00 81 9e sethi %hi(0x2067800), %o0 <== NOT EXECUTED
2037e30: 96 10 00 11 mov %l1, %o3 <== NOT EXECUTED
2037e34: 40 00 3b 2d call 2046ae8 <printf> <== NOT EXECUTED
2037e38: 90 12 20 58 or %o0, 0x58, %o0 <== NOT EXECUTED
printf ("rtems-rfs: dir-lookup-ino: "
"block map next block failed in ino %" PRIu32 ": %d: %s\n",
rtems_rfs_inode_ino (inode), rc, strerror (rc));
}
if (rc == ENXIO)
rc = ENOENT;
2037e3c: 10 80 00 b5 b 2038110 <rtems_rfs_dir_lookup_ino+0x4a8> <== NOT EXECUTED
2037e40: b0 10 00 11 mov %l1, %i0 <== NOT EXECUTED
* means the entry is empty.
*/
entry = rtems_rfs_buffer_data (&entries);
map.bpos.boff = 0;
2037e44: c0 27 bf c4 clr [ %fp + -60 ]
while (map.bpos.boff < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
2037e48: 10 80 00 71 b 203800c <rtems_rfs_dir_lookup_ino+0x3a4>
2037e4c: e4 00 60 1c ld [ %g1 + 0x1c ], %l2
{
uint32_t ehash;
int elength;
ehash = rtems_rfs_dir_entry_hash (entry);
2037e50: c8 0c a0 04 ldub [ %l2 + 4 ], %g4
2037e54: 85 28 a0 10 sll %g2, 0x10, %g2
2037e58: 89 29 20 18 sll %g4, 0x18, %g4
2037e5c: 88 11 00 02 or %g4, %g2, %g4
2037e60: c4 0c a0 07 ldub [ %l2 + 7 ], %g2
elength = rtems_rfs_dir_entry_length (entry);
2037e64: c6 0c a0 09 ldub [ %l2 + 9 ], %g3
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);
2037e68: 88 11 00 02 or %g4, %g2, %g4
2037e6c: c4 0c a0 06 ldub [ %l2 + 6 ], %g2
elength = rtems_rfs_dir_entry_length (entry);
*ino = rtems_rfs_dir_entry_ino (entry);
2037e70: de 0c 80 00 ldub [ %l2 ], %o7
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);
2037e74: 85 28 a0 08 sll %g2, 8, %g2
2037e78: 88 11 00 02 or %g4, %g2, %g4
elength = rtems_rfs_dir_entry_length (entry);
2037e7c: c4 0c a0 08 ldub [ %l2 + 8 ], %g2
*ino = rtems_rfs_dir_entry_ino (entry);
2037e80: 9f 2b e0 18 sll %o7, 0x18, %o7
{
uint32_t ehash;
int elength;
ehash = rtems_rfs_dir_entry_hash (entry);
elength = rtems_rfs_dir_entry_length (entry);
2037e84: 85 28 a0 08 sll %g2, 8, %g2
2037e88: a6 10 80 03 or %g2, %g3, %l3
*ino = rtems_rfs_dir_entry_ino (entry);
2037e8c: c6 0c a0 01 ldub [ %l2 + 1 ], %g3
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
2037e90: 80 a4 c0 14 cmp %l3, %l4
uint32_t ehash;
int elength;
ehash = rtems_rfs_dir_entry_hash (entry);
elength = rtems_rfs_dir_entry_length (entry);
*ino = rtems_rfs_dir_entry_ino (entry);
2037e94: 87 28 e0 10 sll %g3, 0x10, %g3
2037e98: 86 13 c0 03 or %o7, %g3, %g3
2037e9c: de 0c a0 03 ldub [ %l2 + 3 ], %o7
2037ea0: 86 10 c0 0f or %g3, %o7, %g3
2037ea4: de 0c a0 02 ldub [ %l2 + 2 ], %o7
2037ea8: 9f 2b e0 08 sll %o7, 8, %o7
2037eac: 86 10 c0 0f or %g3, %o7, %g3
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
2037eb0: 12 80 00 07 bne 2037ecc <rtems_rfs_dir_lookup_ino+0x264>
2037eb4: c6 27 00 00 st %g3, [ %i4 ]
map.bpos.boff += elength;
entry += elength;
}
if (rc == 0)
2037eb8: 80 a4 60 00 cmp %l1, 0
2037ebc: 32 80 00 85 bne,a 20380d0 <rtems_rfs_dir_lookup_ino+0x468><== NEVER TAKEN
2037ec0: b0 10 00 11 mov %l1, %i0 <== NOT EXECUTED
{
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
2037ec4: 10 80 00 5a b 203802c <rtems_rfs_dir_lookup_ino+0x3c4>
2037ec8: 90 10 00 10 mov %l0, %o0
*ino = rtems_rfs_dir_entry_ino (entry);
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
break;
if (rtems_rfs_dir_entry_valid (fs, elength, *ino))
2037ecc: 80 a4 e0 0a cmp %l3, 0xa
2037ed0: 34 80 00 0a bg,a 2037ef8 <rtems_rfs_dir_lookup_ino+0x290><== ALWAYS TAKEN
2037ed4: de 04 20 1c ld [ %l0 + 0x1c ], %o7
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
2037ed8: 90 10 20 00 clr %o0 <== NOT EXECUTED
2037edc: 7f ff ae dc call 2023a4c <rtems_rfs_trace> <== NOT EXECUTED
2037ee0: 13 01 00 00 sethi %hi(0x4000000), %o1 <== NOT EXECUTED
2037ee4: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
2037ee8: 22 80 00 70 be,a 20380a8 <rtems_rfs_dir_lookup_ino+0x440><== NOT EXECUTED
2037eec: a2 10 20 05 mov 5, %l1 <== NOT EXECUTED
printf ("rtems-rfs: dir-lookup-ino: "
2037ef0: 10 80 00 0c b 2037f20 <rtems_rfs_dir_lookup_ino+0x2b8> <== NOT EXECUTED
2037ef4: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED
*ino = rtems_rfs_dir_entry_ino (entry);
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
break;
if (rtems_rfs_dir_entry_valid (fs, elength, *ino))
2037ef8: 80 a4 c0 0f cmp %l3, %o7
2037efc: 1a bf ff f7 bcc 2037ed8 <rtems_rfs_dir_lookup_ino+0x270> <== NEVER TAKEN
2037f00: 80 a0 e0 00 cmp %g3, 0
2037f04: 02 bf ff f6 be 2037edc <rtems_rfs_dir_lookup_ino+0x274> <== NEVER TAKEN
2037f08: 90 10 20 00 clr %o0
2037f0c: de 04 20 14 ld [ %l0 + 0x14 ], %o7
2037f10: 80 a0 c0 0f cmp %g3, %o7
2037f14: 08 80 00 0a bleu 2037f3c <rtems_rfs_dir_lookup_ino+0x2d4> <== ALWAYS TAKEN
2037f18: c2 07 bf 9c ld [ %fp + -100 ], %g1
2037f1c: 30 bf ff f0 b,a 2037edc <rtems_rfs_dir_lookup_ino+0x274> <== NOT EXECUTED
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
printf ("rtems-rfs: dir-lookup-ino: "
2037f20: d6 07 00 00 ld [ %i4 ], %o3 <== NOT EXECUTED
2037f24: d8 07 bf c4 ld [ %fp + -60 ], %o4 <== NOT EXECUTED
2037f28: 90 10 00 17 mov %l7, %o0 <== NOT EXECUTED
2037f2c: 40 00 3a ef call 2046ae8 <printf> <== NOT EXECUTED
2037f30: 94 10 00 13 mov %l3, %o2 <== NOT EXECUTED
printf ("rtems-rfs: dir-lookup-ino: "
"block map next block failed in ino %" PRIu32 ": %d: %s\n",
rtems_rfs_inode_ino (inode), rc, strerror (rc));
}
if (rc == ENXIO)
rc = ENOENT;
2037f34: 10 80 00 5d b 20380a8 <rtems_rfs_dir_lookup_ino+0x440> <== NOT EXECUTED
2037f38: a2 10 20 05 mov 5, %l1 <== NOT EXECUTED
rtems_rfs_inode_ino (inode), elength, *ino, map.bpos.boff);
rc = EIO;
break;
}
if (ehash == hash)
2037f3c: 80 a1 00 01 cmp %g4, %g1
2037f40: 12 80 00 30 bne 2038000 <rtems_rfs_dir_lookup_ino+0x398>
2037f44: c6 07 bf c4 ld [ %fp + -60 ], %g3
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO_CHECK))
2037f48: 90 10 20 00 clr %o0
2037f4c: 7f ff ae c0 call 2023a4c <rtems_rfs_trace>
2037f50: 13 02 00 00 sethi %hi(0x8000000), %o1
2037f54: 80 8a 20 ff btst 0xff, %o0
2037f58: 02 80 00 12 be 2037fa0 <rtems_rfs_dir_lookup_ino+0x338> <== ALWAYS TAKEN
2037f5c: 90 04 a0 0a add %l2, 0xa, %o0
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));
2037f60: c6 0c a0 01 ldub [ %l2 + 1 ], %g3 <== NOT EXECUTED
2037f64: da 0c 80 00 ldub [ %l2 ], %o5 <== NOT EXECUTED
2037f68: 87 28 e0 10 sll %g3, 0x10, %g3 <== NOT EXECUTED
2037f6c: 9b 2b 60 18 sll %o5, 0x18, %o5 <== NOT EXECUTED
2037f70: 9a 13 40 03 or %o5, %g3, %o5 <== NOT EXECUTED
2037f74: c6 0c a0 03 ldub [ %l2 + 3 ], %g3 <== NOT EXECUTED
}
if (ehash == hash)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO_CHECK))
printf ("rtems-rfs: dir-lookup-ino: "
2037f78: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== 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));
2037f7c: 9a 13 40 03 or %o5, %g3, %o5 <== NOT EXECUTED
2037f80: c6 0c a0 02 ldub [ %l2 + 2 ], %g3 <== NOT EXECUTED
}
if (ehash == hash)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO_CHECK))
printf ("rtems-rfs: dir-lookup-ino: "
2037f84: d4 1f bf c0 ldd [ %fp + -64 ], %o2 <== 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));
2037f88: 87 28 e0 08 sll %g3, 8, %g3 <== NOT EXECUTED
}
if (ehash == hash)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO_CHECK))
printf ("rtems-rfs: dir-lookup-ino: "
2037f8c: 90 10 00 15 mov %l5, %o0 <== NOT EXECUTED
2037f90: 98 10 00 13 mov %l3, %o4 <== NOT EXECUTED
2037f94: 40 00 3a d5 call 2046ae8 <printf> <== NOT EXECUTED
2037f98: 9a 13 40 03 or %o5, %g3, %o5 <== 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)
2037f9c: 90 04 a0 0a add %l2, 0xa, %o0 <== NOT EXECUTED
2037fa0: 92 10 00 1a mov %i2, %o1
2037fa4: 40 00 35 a7 call 2045640 <memcmp>
2037fa8: 94 10 00 1b mov %i3, %o2
2037fac: 80 a2 20 00 cmp %o0, 0
2037fb0: 12 80 00 14 bne 2038000 <rtems_rfs_dir_lookup_ino+0x398> <== NEVER TAKEN
2037fb4: c6 07 bf c4 ld [ %fp + -60 ], %g3
{
*offset = rtems_rfs_block_map_pos (fs, &map);
2037fb8: 90 10 00 10 mov %l0, %o0
2037fbc: 7f ff f9 4a call 20364e4 <rtems_rfs_block_get_pos>
2037fc0: 92 07 bf c0 add %fp, -64, %o1
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO_FOUND))
2037fc4: 90 10 20 00 clr %o0
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);
2037fc8: d2 27 40 00 st %o1, [ %i5 ]
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO_FOUND))
2037fcc: 7f ff ae a0 call 2023a4c <rtems_rfs_trace>
2037fd0: 13 04 00 00 sethi %hi(0x10000000), %o1
2037fd4: 80 8a 20 ff btst 0xff, %o0
2037fd8: 22 80 00 4f be,a 2038114 <rtems_rfs_dir_lookup_ino+0x4ac><== ALWAYS TAKEN
2037fdc: 92 07 bf a4 add %fp, -92, %o1
printf ("rtems-rfs: dir-lookup-ino: "
2037fe0: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED
2037fe4: d4 07 00 00 ld [ %i4 ], %o2 <== NOT EXECUTED
2037fe8: d6 07 40 00 ld [ %i5 ], %o3 <== NOT EXECUTED
2037fec: 11 00 81 9e sethi %hi(0x2067800), %o0 <== NOT EXECUTED
2037ff0: 40 00 3a be call 2046ae8 <printf> <== NOT EXECUTED
2037ff4: 90 12 21 50 or %o0, 0x150, %o0 ! 2067950 <__FUNCTION__.7829+0x860><== 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);
2037ff8: 10 80 00 47 b 2038114 <rtems_rfs_dir_lookup_ino+0x4ac> <== NOT EXECUTED
2037ffc: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED
return 0;
}
}
map.bpos.boff += elength;
entry += elength;
2038000: a4 04 80 13 add %l2, %l3, %l2
rtems_rfs_block_map_close (fs, &map);
return 0;
}
}
map.bpos.boff += elength;
2038004: 86 00 c0 13 add %g3, %l3, %g3
2038008: c6 27 bf c4 st %g3, [ %fp + -60 ]
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))
203800c: c4 04 20 08 ld [ %l0 + 8 ], %g2
2038010: c6 07 bf c4 ld [ %fp + -60 ], %g3
2038014: 84 00 bf f6 add %g2, -10, %g2
2038018: 80 a0 c0 02 cmp %g3, %g2
203801c: 2a bf ff 8d bcs,a 2037e50 <rtems_rfs_dir_lookup_ino+0x1e8><== ALWAYS TAKEN
2038020: c4 0c a0 05 ldub [ %l2 + 5 ], %g2
map.bpos.boff += elength;
entry += elength;
}
if (rc == 0)
2038024: 10 bf ff a6 b 2037ebc <rtems_rfs_dir_lookup_ino+0x254> <== NOT EXECUTED
2038028: 80 a4 60 00 cmp %l1, 0 <== NOT EXECUTED
{
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
203802c: 92 07 bf b0 add %fp, -80, %o1
2038030: 7f ff fa b0 call 2036af0 <rtems_rfs_block_map_next_block>
2038034: 94 07 bf a0 add %fp, -96, %o2
if ((rc > 0) && (rc != ENXIO))
2038038: 80 a2 20 06 cmp %o0, 6
203803c: 02 80 00 05 be 2038050 <rtems_rfs_dir_lookup_ino+0x3e8> <== ALWAYS TAKEN
2038040: b0 10 00 08 mov %o0, %i0
2038044: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2038048: 14 80 00 07 bg 2038064 <rtems_rfs_dir_lookup_ino+0x3fc> <== NOT EXECUTED
203804c: 90 10 20 00 clr %o0 <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
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)
2038050: 80 a6 20 06 cmp %i0, 6
2038054: 12 80 00 20 bne 20380d4 <rtems_rfs_dir_lookup_ino+0x46c> <== NEVER TAKEN
2038058: 80 a6 20 00 cmp %i0, 0
rc = ENOENT;
203805c: 10 80 00 11 b 20380a0 <rtems_rfs_dir_lookup_ino+0x438>
2038060: b0 10 20 02 mov 2, %i0
if (rc == 0)
{
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))
2038064: 7f ff ae 7a call 2023a4c <rtems_rfs_trace> <== NOT EXECUTED
2038068: 13 01 00 00 sethi %hi(0x4000000), %o1 <== NOT EXECUTED
203806c: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
2038070: 22 bf ff f9 be,a 2038054 <rtems_rfs_dir_lookup_ino+0x3ec><== NOT EXECUTED
2038074: 80 a6 20 06 cmp %i0, 6 <== NOT EXECUTED
printf ("rtems-rfs: dir-lookup-ino: "
2038078: e2 06 60 08 ld [ %i1 + 8 ], %l1 <== NOT EXECUTED
203807c: 40 00 44 1a call 20490e4 <strerror> <== NOT EXECUTED
2038080: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
2038084: 92 10 00 11 mov %l1, %o1 <== NOT EXECUTED
2038088: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
203808c: 94 10 00 18 mov %i0, %o2 <== NOT EXECUTED
2038090: 40 00 3a 96 call 2046ae8 <printf> <== NOT EXECUTED
2038094: 90 10 00 16 mov %l6, %o0 <== NOT EXECUTED
rtems_rfs_buffer_handle_close (fs, &entries);
rtems_rfs_block_map_close (fs, &map);
return rc;
}
while ((rc == 0) && block)
2038098: 10 80 00 0f b 20380d4 <rtems_rfs_dir_lookup_ino+0x46c> <== NOT EXECUTED
203809c: 80 a6 20 00 cmp %i0, 0 <== NOT EXECUTED
20380a0: 10 80 00 25 b 2038134 <rtems_rfs_dir_lookup_ino+0x4cc>
20380a4: a2 10 00 18 mov %i0, %l1
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;
20380a8: 10 80 00 0a b 20380d0 <rtems_rfs_dir_lookup_ino+0x468> <== NOT EXECUTED
20380ac: b0 10 00 11 mov %l1, %i0 <== NOT EXECUTED
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)
20380b0: 29 00 00 3f sethi %hi(0xfc00), %l4
}
if (ehash == hash)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO_CHECK))
printf ("rtems-rfs: dir-lookup-ino: "
20380b4: 2b 00 81 9e sethi %hi(0x2067800), %l5
{
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: "
20380b8: 2d 00 81 9e sethi %hi(0x2067800), %l6
break;
if (rtems_rfs_dir_entry_valid (fs, elength, *ino))
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
printf ("rtems-rfs: dir-lookup-ino: "
20380bc: 2f 00 81 9e sethi %hi(0x2067800), %l7
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)
20380c0: a8 15 23 ff or %l4, 0x3ff, %l4
}
if (ehash == hash)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO_CHECK))
printf ("rtems-rfs: dir-lookup-ino: "
20380c4: aa 15 60 f0 or %l5, 0xf0, %l5
{
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: "
20380c8: ac 15 a1 98 or %l6, 0x198, %l6
break;
if (rtems_rfs_dir_entry_valid (fs, elength, *ino))
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
printf ("rtems-rfs: dir-lookup-ino: "
20380cc: ae 15 e0 a0 or %l7, 0xa0, %l7
rtems_rfs_buffer_handle_close (fs, &entries);
rtems_rfs_block_map_close (fs, &map);
return rc;
}
while ((rc == 0) && block)
20380d0: 80 a6 20 00 cmp %i0, 0
20380d4: 12 80 00 17 bne 2038130 <rtems_rfs_dir_lookup_ino+0x4c8> <== NEVER TAKEN
20380d8: c2 07 bf a0 ld [ %fp + -96 ], %g1
20380dc: 80 a0 60 00 cmp %g1, 0
20380e0: 12 bf ff 34 bne 2037db0 <rtems_rfs_dir_lookup_ino+0x148> <== ALWAYS TAKEN
20380e4: 90 10 20 00 clr %o0
20380e8: 30 80 00 15 b,a 203813c <rtems_rfs_dir_lookup_ino+0x4d4> <== NOT EXECUTED
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",
20380ec: 40 00 43 fe call 20490e4 <strerror> <== NOT EXECUTED
20380f0: 90 10 20 05 mov 5, %o0 <== NOT EXECUTED
20380f4: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
20380f8: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
20380fc: 94 10 20 05 mov 5, %o2 <== NOT EXECUTED
2038100: 11 00 81 9e sethi %hi(0x2067800), %o0 <== NOT EXECUTED
2038104: 40 00 3a 79 call 2046ae8 <printf> <== NOT EXECUTED
2038108: 90 12 21 e8 or %o0, 0x1e8, %o0 ! 20679e8 <__FUNCTION__.7829+0x8f8><== NOT EXECUTED
}
}
if ((rc == 0) && (block == 0))
{
rc = EIO;
203810c: b0 10 20 05 mov 5, %i0 <== 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);
2038110: 92 07 bf a4 add %fp, -92, %o1
2038114: 7f ff fe cb call 2037c40 <rtems_rfs_buffer_handle_close>
2038118: 90 10 00 10 mov %l0, %o0
rtems_rfs_block_map_close (fs, &map);
203811c: 90 10 00 10 mov %l0, %o0
2038120: 7f ff f9 87 call 203673c <rtems_rfs_block_map_close>
2038124: 92 07 bf b0 add %fp, -80, %o1
2038128: 81 c7 e0 08 ret
203812c: 81 e8 00 00 restore
rtems_rfs_buffer_handle_close (fs, &entries);
rtems_rfs_block_map_close (fs, &map);
return rc;
}
while ((rc == 0) && block)
2038130: a2 10 00 18 mov %i0, %l1 <== NOT EXECUTED
printf ("rtems-rfs: dir-lookup-ino: "
"block map next block failed in ino %" PRIu32 ": %d: %s\n",
rtems_rfs_inode_ino (inode), rc, strerror (rc));
}
if (rc == ENXIO)
rc = ENOENT;
2038134: 10 bf ff f7 b 2038110 <rtems_rfs_dir_lookup_ino+0x4a8>
2038138: b0 10 00 11 mov %l1, %i0
}
if ((rc == 0) && (block == 0))
{
rc = EIO;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
203813c: 7f ff ae 44 call 2023a4c <rtems_rfs_trace> <== NOT EXECUTED
2038140: 13 01 00 00 sethi %hi(0x4000000), %o1 <== NOT EXECUTED
2038144: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
2038148: 32 bf ff e9 bne,a 20380ec <rtems_rfs_dir_lookup_ino+0x484><== NOT EXECUTED
203814c: fa 06 60 08 ld [ %i1 + 8 ], %i5 <== NOT EXECUTED
}
}
if ((rc == 0) && (block == 0))
{
rc = EIO;
2038150: 10 bf ff f0 b 2038110 <rtems_rfs_dir_lookup_ino+0x4a8> <== NOT EXECUTED
2038154: b0 10 20 05 mov 5, %i0 <== NOT EXECUTED
}
rtems_rfs_buffer_handle_close (fs, &entries);
rtems_rfs_block_map_close (fs, &map);
return rc;
}
2038158: 81 c7 e0 08 ret <== NOT EXECUTED
203815c: 81 e8 00 00 restore <== NOT EXECUTED
020388e4 <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)
{
20388e4: 9d e3 bf 40 save %sp, -192, %sp
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))
20388e8: 90 10 20 00 clr %o0
20388ec: 7f ff ac 58 call 2023a4c <rtems_rfs_trace>
20388f0: 13 20 00 00 sethi %hi(0x80000000), %o1
20388f4: 80 8a 20 ff btst 0xff, %o0
20388f8: 22 80 00 09 be,a 203891c <rtems_rfs_dir_read+0x38> <== ALWAYS TAKEN
20388fc: c0 27 40 00 clr [ %i5 ]
printf ("rtems-rfs: dir-read: dir=%" PRId32 " offset=%" PRId64 "\n",
2038900: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED
2038904: 11 00 81 9f sethi %hi(0x2067c00), %o0 <== NOT EXECUTED
2038908: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED
203890c: 90 12 21 18 or %o0, 0x118, %o0 <== NOT EXECUTED
2038910: 40 00 38 76 call 2046ae8 <printf> <== NOT EXECUTED
2038914: 96 10 00 1b mov %i3, %o3 <== NOT EXECUTED
rtems_rfs_inode_ino (dir), offset);
*length = 0;
2038918: c0 27 40 00 clr [ %i5 ] <== NOT EXECUTED
rc = rtems_rfs_block_map_open (fs, dir, &map);
203891c: 90 10 00 18 mov %i0, %o0
2038920: 92 10 00 19 mov %i1, %o1
2038924: 7f ff f7 25 call 20365b8 <rtems_rfs_block_map_open>
2038928: 94 07 bf b0 add %fp, -80, %o2
if (rc > 0)
203892c: a0 92 20 00 orcc %o0, 0, %l0
2038930: 14 80 00 cf bg 2038c6c <rtems_rfs_dir_read+0x388> <== NEVER TAKEN
2038934: 90 10 00 1a mov %i2, %o0
return rc;
if (((rtems_rfs_fs_block_size (fs) -
(offset % rtems_rfs_fs_block_size (fs))) <= RTEMS_RFS_DIR_ENTRY_SIZE))
2038938: e0 06 20 08 ld [ %i0 + 8 ], %l0
203893c: a2 10 00 10 mov %l0, %l1
2038940: 92 10 00 1b mov %i3, %o1
2038944: a0 10 20 00 clr %l0
2038948: 96 10 00 11 mov %l1, %o3
203894c: 40 00 8d d9 call 205c0b0 <__moddi3>
2038950: 94 10 00 10 mov %l0, %o2
rc = rtems_rfs_block_map_open (fs, dir, &map);
if (rc > 0)
return rc;
if (((rtems_rfs_fs_block_size (fs) -
2038954: 92 a4 40 09 subcc %l1, %o1, %o1
2038958: 90 64 00 08 subx %l0, %o0, %o0
203895c: 80 a2 20 00 cmp %o0, 0
2038960: 34 80 00 15 bg,a 20389b4 <rtems_rfs_dir_read+0xd0> <== NEVER TAKEN
2038964: a2 07 bf b0 add %fp, -80, %l1 <== NOT EXECUTED
2038968: 80 a2 20 00 cmp %o0, 0
203896c: 32 80 00 06 bne,a 2038984 <rtems_rfs_dir_read+0xa0> <== NEVER TAKEN
2038970: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
2038974: 80 a2 60 0a cmp %o1, 0xa
2038978: 38 80 00 0f bgu,a 20389b4 <rtems_rfs_dir_read+0xd0> <== ALWAYS TAKEN
203897c: a2 07 bf b0 add %fp, -80, %l1
(offset % rtems_rfs_fs_block_size (fs))) <= RTEMS_RFS_DIR_ENTRY_SIZE))
offset = (((offset / rtems_rfs_fs_block_size (fs)) + 1) *
2038980: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
2038984: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
2038988: 94 10 00 10 mov %l0, %o2 <== NOT EXECUTED
203898c: 40 00 8c de call 205bd04 <__divdi3> <== NOT EXECUTED
2038990: 96 10 00 11 mov %l1, %o3 <== NOT EXECUTED
2038994: 94 10 00 10 mov %l0, %o2 <== NOT EXECUTED
2038998: 92 82 60 01 inccc %o1 <== NOT EXECUTED
203899c: 96 10 00 11 mov %l1, %o3 <== NOT EXECUTED
20389a0: 40 00 8c 50 call 205bae0 <__muldi3> <== NOT EXECUTED
20389a4: 90 42 20 00 addx %o0, 0, %o0 <== NOT EXECUTED
20389a8: b4 10 00 08 mov %o0, %i2 <== NOT EXECUTED
20389ac: b6 10 00 09 mov %o1, %i3 <== NOT EXECUTED
rtems_rfs_fs_block_size (fs));
rc = rtems_rfs_block_map_seek (fs, &map, offset, &block);
20389b0: a2 07 bf b0 add %fp, -80, %l1 <== NOT EXECUTED
20389b4: a4 07 bf a0 add %fp, -96, %l2
20389b8: 90 10 00 18 mov %i0, %o0
20389bc: 92 10 00 11 mov %l1, %o1
20389c0: 94 10 00 1a mov %i2, %o2
20389c4: 96 10 00 1b mov %i3, %o3
20389c8: 7f ff f8 2d call 2036a7c <rtems_rfs_block_map_seek>
20389cc: 98 10 00 12 mov %l2, %o4
if (rc > 0)
20389d0: a0 92 20 00 orcc %o0, 0, %l0
20389d4: 04 80 00 07 ble 20389f0 <rtems_rfs_dir_read+0x10c> <== ALWAYS TAKEN
20389d8: 80 a4 20 06 cmp %l0, 6
{
if (rc == ENXIO)
20389dc: 22 80 00 02 be,a 20389e4 <rtems_rfs_dir_read+0x100> <== NOT EXECUTED
20389e0: a0 10 20 02 mov 2, %l0 <== NOT EXECUTED
rc = ENOENT;
rtems_rfs_block_map_close (fs, &map);
20389e4: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
20389e8: 10 80 00 9f b 2038c64 <rtems_rfs_dir_read+0x380> <== NOT EXECUTED
20389ec: 92 10 00 11 mov %l1, %o1 <== 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)
20389f0: 2b 00 00 3f sethi %hi(0xfc00), %l5
}
*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",
20389f4: 2d 00 81 9f sethi %hi(0x2067c00), %l6
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
20389f8: c0 2f bf a4 clrb [ %fp + -92 ]
handle->bnum = 0;
20389fc: c0 27 bf a8 clr [ %fp + -88 ]
handle->buffer = NULL;
2038a00: c0 27 bf ac clr [ %fp + -84 ]
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)
2038a04: aa 15 63 ff or %l5, 0x3ff, %l5
}
*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",
2038a08: ac 15 a1 c8 or %l6, 0x1c8, %l6
offset, *length);
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
2038a0c: ae 10 00 11 mov %l1, %l7
2038a10: a8 10 00 12 mov %l2, %l4
uint8_t* entry;
rtems_rfs_ino eino;
int elength;
int remaining;
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, true);
2038a14: d4 07 bf a0 ld [ %fp + -96 ], %o2
2038a18: 90 10 00 18 mov %i0, %o0
2038a1c: 92 07 bf a4 add %fp, -92, %o1
2038a20: 7f ff fa d3 call 203756c <rtems_rfs_buffer_handle_request>
2038a24: 96 10 20 01 mov 1, %o3
if (rc > 0)
2038a28: a0 92 20 00 orcc %o0, 0, %l0
2038a2c: 04 80 00 04 ble 2038a3c <rtems_rfs_dir_read+0x158> <== ALWAYS TAKEN
2038a30: c2 07 bf ac ld [ %fp + -84 ], %g1
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
if (rc == ENXIO)
rc = ENOENT;
}
rtems_rfs_buffer_handle_close (fs, &buffer);
2038a34: 10 80 00 88 b 2038c54 <rtems_rfs_dir_read+0x370> <== NOT EXECUTED
2038a38: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED
rtems_rfs_block_map_close (fs, &map);
return rc;
}
entry = rtems_rfs_buffer_data (&buffer);
entry += map.bpos.boff;
2038a3c: e6 07 bf c4 ld [ %fp + -60 ], %l3
rtems_rfs_buffer_handle_close (fs, &buffer);
rtems_rfs_block_map_close (fs, &map);
return rc;
}
entry = rtems_rfs_buffer_data (&buffer);
2038a40: c2 00 60 1c ld [ %g1 + 0x1c ], %g1
entry += map.bpos.boff;
2038a44: a2 00 40 13 add %g1, %l3, %l1
elength = rtems_rfs_dir_entry_length (entry);
2038a48: c4 0c 60 09 ldub [ %l1 + 9 ], %g2
2038a4c: e4 0c 60 08 ldub [ %l1 + 8 ], %l2
eino = rtems_rfs_dir_entry_ino (entry);
2038a50: c8 08 40 13 ldub [ %g1 + %l3 ], %g4
}
entry = rtems_rfs_buffer_data (&buffer);
entry += map.bpos.boff;
elength = rtems_rfs_dir_entry_length (entry);
2038a54: a5 2c a0 08 sll %l2, 8, %l2
eino = rtems_rfs_dir_entry_ino (entry);
2038a58: c6 0c 60 01 ldub [ %l1 + 1 ], %g3
}
entry = rtems_rfs_buffer_data (&buffer);
entry += map.bpos.boff;
elength = rtems_rfs_dir_entry_length (entry);
2038a5c: a4 14 80 02 or %l2, %g2, %l2
eino = rtems_rfs_dir_entry_ino (entry);
2038a60: c2 0c 60 02 ldub [ %l1 + 2 ], %g1
if (elength != RTEMS_RFS_DIR_ENTRY_EMPTY)
2038a64: 80 a4 80 15 cmp %l2, %l5
2038a68: 02 80 00 5d be 2038bdc <rtems_rfs_dir_read+0x2f8>
2038a6c: c4 0c 60 03 ldub [ %l1 + 3 ], %g2
entry = rtems_rfs_buffer_data (&buffer);
entry += map.bpos.boff;
elength = rtems_rfs_dir_entry_length (entry);
eino = rtems_rfs_dir_entry_ino (entry);
2038a70: a9 29 20 18 sll %g4, 0x18, %l4
2038a74: 86 08 e0 ff and %g3, 0xff, %g3
2038a78: 84 08 a0 ff and %g2, 0xff, %g2
2038a7c: 87 28 e0 10 sll %g3, 0x10, %g3
2038a80: 82 08 60 ff and %g1, 0xff, %g1
2038a84: a8 15 00 03 or %l4, %g3, %l4
2038a88: 83 28 60 08 sll %g1, 8, %g1
2038a8c: a8 15 00 02 or %l4, %g2, %l4
if (elength != RTEMS_RFS_DIR_ENTRY_EMPTY)
{
if (rtems_rfs_dir_entry_valid (fs, elength, eino))
2038a90: 80 a4 a0 0a cmp %l2, 0xa
2038a94: 04 80 00 0d ble 2038ac8 <rtems_rfs_dir_read+0x1e4> <== NEVER TAKEN
2038a98: a8 15 00 01 or %l4, %g1, %l4
2038a9c: c2 06 20 1c ld [ %i0 + 0x1c ], %g1
2038aa0: 80 a4 80 01 cmp %l2, %g1
2038aa4: 1a 80 00 0a bcc 2038acc <rtems_rfs_dir_read+0x1e8> <== NEVER TAKEN
2038aa8: 90 10 20 00 clr %o0
2038aac: 80 a5 20 00 cmp %l4, 0
2038ab0: 02 80 00 08 be 2038ad0 <rtems_rfs_dir_read+0x1ec> <== NEVER TAKEN
2038ab4: 13 20 00 00 sethi %hi(0x80000000), %o1
2038ab8: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
2038abc: 80 a5 00 01 cmp %l4, %g1
2038ac0: 08 80 00 12 bleu 2038b08 <rtems_rfs_dir_read+0x224> <== ALWAYS TAKEN
2038ac4: 90 10 00 1c mov %i4, %o0
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
2038ac8: 90 10 20 00 clr %o0 <== NOT EXECUTED
2038acc: 13 20 00 00 sethi %hi(0x80000000), %o1 <== NOT EXECUTED
2038ad0: 7f ff ab df call 2023a4c <rtems_rfs_trace> <== NOT EXECUTED
2038ad4: a0 10 20 05 mov 5, %l0 <== NOT EXECUTED
2038ad8: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
2038adc: 22 80 00 5e be,a 2038c54 <rtems_rfs_dir_read+0x370> <== NOT EXECUTED
2038ae0: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED
printf ("rtems-rfs: dir-read: "
2038ae4: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED
2038ae8: d8 07 bf c4 ld [ %fp + -60 ], %o4 <== NOT EXECUTED
2038aec: 11 00 81 9f sethi %hi(0x2067c00), %o0 <== NOT EXECUTED
2038af0: 94 10 00 12 mov %l2, %o2 <== NOT EXECUTED
2038af4: 96 10 00 14 mov %l4, %o3 <== NOT EXECUTED
2038af8: 40 00 37 fc call 2046ae8 <printf> <== NOT EXECUTED
2038afc: 90 12 21 48 or %o0, 0x148, %o0 <== NOT EXECUTED
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
if (rc == ENXIO)
rc = ENOENT;
}
rtems_rfs_buffer_handle_close (fs, &buffer);
2038b00: 10 80 00 55 b 2038c54 <rtems_rfs_dir_read+0x370> <== NOT EXECUTED
2038b04: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED
rtems_rfs_inode_ino (dir), elength, eino, map.bpos.boff);
rc = EIO;
break;
}
memset (dirent, 0, sizeof (struct dirent));
2038b08: 92 10 20 00 clr %o1
2038b0c: 40 00 33 86 call 2045924 <memset>
2038b10: 94 10 21 18 mov 0x118, %o2
dirent->d_off = offset;
dirent->d_reclen = sizeof (struct dirent);
2038b14: 82 10 21 18 mov 0x118, %g1
rc = EIO;
break;
}
memset (dirent, 0, sizeof (struct dirent));
dirent->d_off = offset;
2038b18: f4 3f 20 08 std %i2, [ %i4 + 8 ]
dirent->d_reclen = sizeof (struct dirent);
2038b1c: c2 37 20 10 sth %g1, [ %i4 + 0x10 ]
*length += elength;
2038b20: c2 07 40 00 ld [ %i5 ], %g1
2038b24: 82 04 80 01 add %l2, %g1, %g1
2038b28: c2 27 40 00 st %g1, [ %i5 ]
remaining = rtems_rfs_fs_block_size (fs) - (map.bpos.boff + elength);
2038b2c: c4 06 20 08 ld [ %i0 + 8 ], %g2
2038b30: a6 20 80 13 sub %g2, %l3, %l3
2038b34: a6 24 c0 12 sub %l3, %l2, %l3
if (remaining <= RTEMS_RFS_DIR_ENTRY_SIZE)
2038b38: 80 a4 e0 0a cmp %l3, 0xa
2038b3c: 14 80 00 04 bg 2038b4c <rtems_rfs_dir_read+0x268> <== ALWAYS TAKEN
2038b40: a4 04 bf f6 add %l2, -10, %l2
*length += remaining;
2038b44: 82 04 c0 01 add %l3, %g1, %g1 <== NOT EXECUTED
2038b48: c2 27 40 00 st %g1, [ %i5 ] <== NOT EXECUTED
2038b4c: 80 a4 a0 ff cmp %l2, 0xff
2038b50: 34 80 00 02 bg,a 2038b58 <rtems_rfs_dir_read+0x274> <== NEVER TAKEN
2038b54: a4 10 20 ff mov 0xff, %l2 <== NOT EXECUTED
elength -= RTEMS_RFS_DIR_ENTRY_SIZE;
if (elength > NAME_MAX)
elength = NAME_MAX;
memcpy (dirent->d_name, entry + RTEMS_RFS_DIR_ENTRY_SIZE, elength);
2038b58: 92 04 60 0a add %l1, 0xa, %o1
2038b5c: 94 10 00 12 mov %l2, %o2
2038b60: ba 07 20 14 add %i4, 0x14, %i5
2038b64: 40 00 32 e1 call 20456e8 <memcpy>
2038b68: 90 10 00 1d mov %i5, %o0
dirent->d_ino = rtems_rfs_dir_entry_ino (entry);
2038b6c: c4 0c 40 00 ldub [ %l1 ], %g2
2038b70: c2 0c 60 01 ldub [ %l1 + 1 ], %g1
2038b74: 85 28 a0 18 sll %g2, 0x18, %g2
2038b78: 83 28 60 10 sll %g1, 0x10, %g1
2038b7c: 82 10 80 01 or %g2, %g1, %g1
2038b80: c4 0c 60 03 ldub [ %l1 + 3 ], %g2
dirent->d_namlen = elength;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
2038b84: 90 10 20 00 clr %o0
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);
2038b88: 82 10 40 02 or %g1, %g2, %g1
2038b8c: c4 0c 60 02 ldub [ %l1 + 2 ], %g2
dirent->d_namlen = elength;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
2038b90: 13 20 00 00 sethi %hi(0x80000000), %o1
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);
2038b94: 85 28 a0 08 sll %g2, 8, %g2
2038b98: 82 10 40 02 or %g1, %g2, %g1
dirent->d_namlen = elength;
2038b9c: e4 37 20 12 sth %l2, [ %i4 + 0x12 ]
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
2038ba0: 7f ff ab ab call 2023a4c <rtems_rfs_trace>
2038ba4: c2 27 00 00 st %g1, [ %i4 ]
2038ba8: 80 8a 20 ff btst 0xff, %o0
2038bac: 22 80 00 2a be,a 2038c54 <rtems_rfs_dir_read+0x370> <== ALWAYS TAKEN
2038bb0: 92 07 bf a4 add %fp, -92, %o1
printf ("rtems-rfs: dir-read: found off:%" PRIooff_t " ino:%ld name=%s\n",
2038bb4: c4 1f 20 08 ldd [ %i4 + 8 ], %g2 <== NOT EXECUTED
2038bb8: d6 07 00 00 ld [ %i4 ], %o3 <== NOT EXECUTED
2038bbc: 11 00 81 9f sethi %hi(0x2067c00), %o0 <== NOT EXECUTED
2038bc0: 92 10 00 02 mov %g2, %o1 <== NOT EXECUTED
2038bc4: 94 10 00 03 mov %g3, %o2 <== NOT EXECUTED
2038bc8: 98 10 00 1d mov %i5, %o4 <== NOT EXECUTED
2038bcc: 40 00 37 c7 call 2046ae8 <printf> <== NOT EXECUTED
2038bd0: 90 12 21 90 or %o0, 0x190, %o0 <== NOT EXECUTED
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
if (rc == ENXIO)
rc = ENOENT;
}
rtems_rfs_buffer_handle_close (fs, &buffer);
2038bd4: 10 80 00 20 b 2038c54 <rtems_rfs_dir_read+0x370> <== NOT EXECUTED
2038bd8: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED
printf ("rtems-rfs: dir-read: found off:%" PRIooff_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;
2038bdc: c2 06 20 08 ld [ %i0 + 8 ], %g1
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
2038be0: 90 10 20 00 clr %o0
printf ("rtems-rfs: dir-read: found off:%" PRIooff_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;
2038be4: a6 20 40 13 sub %g1, %l3, %l3
2038be8: c2 07 40 00 ld [ %i5 ], %g1
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
2038bec: 13 20 00 00 sethi %hi(0x80000000), %o1
printf ("rtems-rfs: dir-read: found off:%" PRIooff_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;
2038bf0: a6 00 40 13 add %g1, %l3, %l3
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
2038bf4: 7f ff ab 96 call 2023a4c <rtems_rfs_trace>
2038bf8: e6 27 40 00 st %l3, [ %i5 ]
2038bfc: 80 8a 20 ff btst 0xff, %o0
2038c00: 02 80 00 08 be 2038c20 <rtems_rfs_dir_read+0x33c> <== ALWAYS TAKEN
2038c04: 90 10 00 18 mov %i0, %o0
printf ("rtems-rfs: dir-read: next block: off:%" PRId64 " length:%zd\n",
2038c08: d6 07 40 00 ld [ %i5 ], %o3 <== NOT EXECUTED
2038c0c: 90 10 00 16 mov %l6, %o0 <== NOT EXECUTED
2038c10: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED
2038c14: 40 00 37 b5 call 2046ae8 <printf> <== NOT EXECUTED
2038c18: 94 10 00 1b mov %i3, %o2 <== NOT EXECUTED
offset, *length);
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
2038c1c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
2038c20: 92 10 00 17 mov %l7, %o1
2038c24: 7f ff f7 b3 call 2036af0 <rtems_rfs_block_map_next_block>
2038c28: 94 10 00 14 mov %l4, %o2
if (rc == ENXIO)
2038c2c: 80 a2 20 06 cmp %o0, 6
2038c30: 02 80 00 07 be 2038c4c <rtems_rfs_dir_read+0x368> <== ALWAYS TAKEN
2038c34: a0 10 00 08 mov %o0, %l0
/*
* Look for an empty entry and if this is the last block that is the end of
* the directory.
*/
while (rc == 0)
2038c38: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2038c3c: 02 bf ff 77 be 2038a18 <rtems_rfs_dir_read+0x134> <== NOT EXECUTED
2038c40: d4 07 bf a0 ld [ %fp + -96 ], %o2 <== NOT EXECUTED
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
if (rc == ENXIO)
rc = ENOENT;
}
rtems_rfs_buffer_handle_close (fs, &buffer);
2038c44: 10 80 00 04 b 2038c54 <rtems_rfs_dir_read+0x370> <== NOT EXECUTED
2038c48: 92 07 bf a4 add %fp, -92, %o1 <== 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;
2038c4c: a0 10 20 02 mov 2, %l0
}
rtems_rfs_buffer_handle_close (fs, &buffer);
2038c50: 92 07 bf a4 add %fp, -92, %o1
2038c54: 7f ff fb fb call 2037c40 <rtems_rfs_buffer_handle_close>
2038c58: 90 10 00 18 mov %i0, %o0
rtems_rfs_block_map_close (fs, &map);
2038c5c: 90 10 00 18 mov %i0, %o0
2038c60: 92 07 bf b0 add %fp, -80, %o1
2038c64: 7f ff f6 b6 call 203673c <rtems_rfs_block_map_close>
2038c68: 01 00 00 00 nop
return rc;
}
2038c6c: 81 c7 e0 08 ret
2038c70: 91 e8 00 10 restore %g0, %l0, %o0
02038ec8 <rtems_rfs_file_close>:
}
int
rtems_rfs_file_close (rtems_rfs_file_system* fs,
rtems_rfs_file_handle* handle)
{
2038ec8: 9d e3 bf a0 save %sp, -96, %sp
int rrc;
int rc;
rrc = 0;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_CLOSE))
2038ecc: 90 10 20 10 mov 0x10, %o0
2038ed0: 7f ff aa df call 2023a4c <rtems_rfs_trace>
2038ed4: 92 10 20 00 clr %o1
2038ed8: 80 8a 20 ff btst 0xff, %o0
2038edc: 22 80 00 08 be,a 2038efc <rtems_rfs_file_close+0x34> <== ALWAYS TAKEN
2038ee0: d2 06 60 1c ld [ %i1 + 0x1c ], %o1
printf ("rtems-rfs: file-close: entry: ino=%" PRId32 "\n",
handle->shared->inode.ino);
2038ee4: c2 06 60 1c ld [ %i1 + 0x1c ], %g1 <== NOT EXECUTED
int rc;
rrc = 0;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_CLOSE))
printf ("rtems-rfs: file-close: entry: ino=%" PRId32 "\n",
2038ee8: 11 00 81 9f sethi %hi(0x2067c00), %o0 <== NOT EXECUTED
2038eec: d2 00 60 14 ld [ %g1 + 0x14 ], %o1 <== NOT EXECUTED
2038ef0: 40 00 36 fe call 2046ae8 <printf> <== NOT EXECUTED
2038ef4: 90 12 22 68 or %o0, 0x268, %o0 <== NOT EXECUTED
handle->shared->inode.ino);
if (handle->shared->references > 0)
2038ef8: d2 06 60 1c ld [ %i1 + 0x1c ], %o1 <== NOT EXECUTED
2038efc: c2 02 60 08 ld [ %o1 + 8 ], %g1
2038f00: 80 a0 60 00 cmp %g1, 0
2038f04: 04 80 00 03 ble 2038f10 <rtems_rfs_file_close+0x48> <== NEVER TAKEN
2038f08: 82 00 7f ff add %g1, -1, %g1
handle->shared->references--;
2038f0c: c2 22 60 08 st %g1, [ %o1 + 8 ]
if (handle->shared->references == 0)
2038f10: c2 02 60 08 ld [ %o1 + 8 ], %g1
2038f14: 80 a0 60 00 cmp %g1, 0
2038f18: 12 80 00 7e bne 2039110 <rtems_rfs_file_close+0x248> <== NEVER TAKEN
2038f1c: ba 10 20 00 clr %i5
{
if (!rtems_rfs_inode_is_loaded (&handle->shared->inode))
2038f20: c2 02 60 18 ld [ %o1 + 0x18 ], %g1
2038f24: 80 a0 60 00 cmp %g1, 0
2038f28: 32 80 00 09 bne,a 2038f4c <rtems_rfs_file_close+0x84> <== NEVER TAKEN
2038f2c: c2 06 60 1c ld [ %i1 + 0x1c ], %g1 <== NOT EXECUTED
rrc = rtems_rfs_inode_load (fs, &handle->shared->inode);
2038f30: 90 10 00 18 mov %i0, %o0
2038f34: 40 00 0a ee call 203baec <rtems_rfs_inode_load>
2038f38: 92 02 60 0c add %o1, 0xc, %o1
if (rrc == 0)
2038f3c: ba 92 20 00 orcc %o0, 0, %i5
2038f40: 32 80 00 3f bne,a 203903c <rtems_rfs_file_close+0x174> <== NEVER TAKEN
2038f44: d2 06 60 1c ld [ %i1 + 0x1c ], %o1 <== NOT EXECUTED
{
/*
* @todo This could be clever and only update if different.
*/
rtems_rfs_inode_set_atime (&handle->shared->inode,
2038f48: c2 06 60 1c ld [ %i1 + 0x1c ], %g1
2038f4c: c4 00 60 8c ld [ %g1 + 0x8c ], %g2
*/
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);
2038f50: c6 00 60 18 ld [ %g1 + 0x18 ], %g3
2038f54: 89 30 a0 18 srl %g2, 0x18, %g4
2038f58: c8 28 e0 10 stb %g4, [ %g3 + 0x10 ]
2038f5c: c6 00 60 18 ld [ %g1 + 0x18 ], %g3
2038f60: 89 30 a0 10 srl %g2, 0x10, %g4
2038f64: c8 28 e0 11 stb %g4, [ %g3 + 0x11 ]
2038f68: c6 00 60 18 ld [ %g1 + 0x18 ], %g3
2038f6c: 89 30 a0 08 srl %g2, 8, %g4
2038f70: c8 28 e0 12 stb %g4, [ %g3 + 0x12 ]
2038f74: c6 00 60 18 ld [ %g1 + 0x18 ], %g3
2038f78: c4 28 e0 13 stb %g2, [ %g3 + 0x13 ]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
2038f7c: 86 10 20 01 mov 1, %g3
2038f80: c6 28 60 1c stb %g3, [ %g1 + 0x1c ]
handle->shared->atime);
rtems_rfs_inode_set_mtime (&handle->shared->inode,
2038f84: c2 06 60 1c ld [ %i1 + 0x1c ], %g1
2038f88: c4 00 60 90 ld [ %g1 + 0x90 ], %g2
*/
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);
2038f8c: c8 00 60 18 ld [ %g1 + 0x18 ], %g4
2038f90: bb 30 a0 18 srl %g2, 0x18, %i5
2038f94: fa 29 20 14 stb %i5, [ %g4 + 0x14 ]
2038f98: c8 00 60 18 ld [ %g1 + 0x18 ], %g4
2038f9c: bb 30 a0 10 srl %g2, 0x10, %i5
2038fa0: fa 29 20 15 stb %i5, [ %g4 + 0x15 ]
2038fa4: c8 00 60 18 ld [ %g1 + 0x18 ], %g4
2038fa8: bb 30 a0 08 srl %g2, 8, %i5
2038fac: fa 29 20 16 stb %i5, [ %g4 + 0x16 ]
2038fb0: c8 00 60 18 ld [ %g1 + 0x18 ], %g4
2038fb4: c4 29 20 17 stb %g2, [ %g4 + 0x17 ]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
2038fb8: c6 28 60 1c stb %g3, [ %g1 + 0x1c ]
handle->shared->mtime);
rtems_rfs_inode_set_ctime (&handle->shared->inode,
2038fbc: c2 06 60 1c ld [ %i1 + 0x1c ], %g1
2038fc0: c4 00 60 94 ld [ %g1 + 0x94 ], %g2
*/
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);
2038fc4: c8 00 60 18 ld [ %g1 + 0x18 ], %g4
2038fc8: bb 30 a0 18 srl %g2, 0x18, %i5
2038fcc: fa 29 20 18 stb %i5, [ %g4 + 0x18 ]
2038fd0: c8 00 60 18 ld [ %g1 + 0x18 ], %g4
2038fd4: bb 30 a0 10 srl %g2, 0x10, %i5
2038fd8: fa 29 20 19 stb %i5, [ %g4 + 0x19 ]
2038fdc: c8 00 60 18 ld [ %g1 + 0x18 ], %g4
2038fe0: bb 30 a0 08 srl %g2, 8, %i5
2038fe4: fa 29 20 1a stb %i5, [ %g4 + 0x1a ]
2038fe8: c8 00 60 18 ld [ %g1 + 0x18 ], %g4
2038fec: c4 29 20 1b stb %g2, [ %g4 + 0x1b ]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
2038ff0: c6 28 60 1c stb %g3, [ %g1 + 0x1c ]
handle->shared->ctime);
if (!rtems_rfs_block_size_equal (&handle->shared->size,
2038ff4: c2 06 60 1c ld [ %i1 + 0x1c ], %g1
2038ff8: c4 00 60 84 ld [ %g1 + 0x84 ], %g2
2038ffc: c6 00 60 3c ld [ %g1 + 0x3c ], %g3
2039000: 80 a0 80 03 cmp %g2, %g3
2039004: 32 80 00 08 bne,a 2039024 <rtems_rfs_file_close+0x15c> <== NEVER TAKEN
2039008: c4 20 60 3c st %g2, [ %g1 + 0x3c ] <== NOT EXECUTED
203900c: c8 00 60 88 ld [ %g1 + 0x88 ], %g4
2039010: c6 00 60 40 ld [ %g1 + 0x40 ], %g3
2039014: 80 a1 00 03 cmp %g4, %g3
2039018: 02 80 00 08 be 2039038 <rtems_rfs_file_close+0x170> <== ALWAYS TAKEN
203901c: ba 10 20 00 clr %i5
*/
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);
2039020: c4 20 60 3c st %g2, [ %g1 + 0x3c ] <== NOT EXECUTED
2039024: c4 00 60 88 ld [ %g1 + 0x88 ], %g2 <== NOT EXECUTED
map->dirty = true;
2039028: ba 10 20 00 clr %i5 <== NOT EXECUTED
*/
static inline void
rtems_rfs_block_map_set_size (rtems_rfs_block_map* map,
rtems_rfs_block_size* size)
{
rtems_rfs_block_copy_size (&map->size, size);
203902c: c4 20 60 40 st %g2, [ %g1 + 0x40 ] <== NOT EXECUTED
map->dirty = true;
2039030: 84 10 20 01 mov 1, %g2 <== NOT EXECUTED
2039034: c4 28 60 34 stb %g2, [ %g1 + 0x34 ] <== NOT EXECUTED
&handle->shared->map.size))
rtems_rfs_block_map_set_size (&handle->shared->map,
&handle->shared->size);
}
rc = rtems_rfs_block_map_close (fs, &handle->shared->map);
2039038: d2 06 60 1c ld [ %i1 + 0x1c ], %o1
203903c: 90 10 00 18 mov %i0, %o0
2039040: 7f ff f5 bf call 203673c <rtems_rfs_block_map_close>
2039044: 92 02 60 34 add %o1, 0x34, %o1
if (rc > 0)
2039048: b8 92 20 00 orcc %o0, 0, %i4
203904c: 04 80 00 14 ble 203909c <rtems_rfs_file_close+0x1d4> <== ALWAYS TAKEN
2039050: 90 10 20 10 mov 0x10, %o0
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_CLOSE))
2039054: 7f ff aa 7e call 2023a4c <rtems_rfs_trace> <== NOT EXECUTED
2039058: 92 10 20 00 clr %o1 <== NOT EXECUTED
203905c: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
2039060: 02 80 00 0d be 2039094 <rtems_rfs_file_close+0x1cc> <== NOT EXECUTED
2039064: 80 a7 60 00 cmp %i5, 0 <== NOT EXECUTED
printf ("rtems-rfs: file-close: map close error: ino=%" PRId32 ": %d: %s\n",
handle->shared->inode.ino, rc, strerror (rc));
2039068: c2 06 60 1c ld [ %i1 + 0x1c ], %g1 <== 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",
203906c: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
2039070: 40 00 40 1d call 20490e4 <strerror> <== NOT EXECUTED
2039074: f6 00 60 14 ld [ %g1 + 0x14 ], %i3 <== NOT EXECUTED
2039078: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
203907c: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
2039080: 94 10 00 1c mov %i4, %o2 <== NOT EXECUTED
2039084: 11 00 81 9f sethi %hi(0x2067c00), %o0 <== NOT EXECUTED
2039088: 40 00 36 98 call 2046ae8 <printf> <== NOT EXECUTED
203908c: 90 12 22 90 or %o0, 0x290, %o0 ! 2067e90 <__FUNCTION__.7829+0xda0><== NOT EXECUTED
handle->shared->inode.ino, rc, strerror (rc));
if (rrc == 0)
2039090: 80 a7 60 00 cmp %i5, 0 <== NOT EXECUTED
2039094: 22 80 00 02 be,a 203909c <rtems_rfs_file_close+0x1d4> <== NOT EXECUTED
2039098: ba 10 00 1c mov %i4, %i5 <== NOT EXECUTED
rrc = rc;
}
rc = rtems_rfs_inode_close (fs, &handle->shared->inode);
203909c: d2 06 60 1c ld [ %i1 + 0x1c ], %o1
20390a0: 90 10 00 18 mov %i0, %o0
20390a4: 40 00 0b 31 call 203bd68 <rtems_rfs_inode_close>
20390a8: 92 02 60 0c add %o1, 0xc, %o1
if (rc > 0)
20390ac: b8 92 20 00 orcc %o0, 0, %i4
20390b0: 04 80 00 14 ble 2039100 <rtems_rfs_file_close+0x238> <== ALWAYS TAKEN
20390b4: 90 10 20 10 mov 0x10, %o0
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_CLOSE))
20390b8: 7f ff aa 65 call 2023a4c <rtems_rfs_trace> <== NOT EXECUTED
20390bc: 92 10 20 00 clr %o1 <== NOT EXECUTED
20390c0: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
20390c4: 02 80 00 0d be 20390f8 <rtems_rfs_file_close+0x230> <== NOT EXECUTED
20390c8: 80 a7 60 00 cmp %i5, 0 <== NOT EXECUTED
printf ("rtems-rfs: file-close: inode close error: ino=%" PRId32 ": %d: %s\n",
handle->shared->inode.ino, rc, strerror (rc));
20390cc: c2 06 60 1c ld [ %i1 + 0x1c ], %g1 <== 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",
20390d0: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
20390d4: 40 00 40 04 call 20490e4 <strerror> <== NOT EXECUTED
20390d8: f6 00 60 14 ld [ %g1 + 0x14 ], %i3 <== NOT EXECUTED
20390dc: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
20390e0: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
20390e4: 94 10 00 1c mov %i4, %o2 <== NOT EXECUTED
20390e8: 11 00 81 9f sethi %hi(0x2067c00), %o0 <== NOT EXECUTED
20390ec: 40 00 36 7f call 2046ae8 <printf> <== NOT EXECUTED
20390f0: 90 12 22 d0 or %o0, 0x2d0, %o0 ! 2067ed0 <__FUNCTION__.7829+0xde0><== NOT EXECUTED
handle->shared->inode.ino, rc, strerror (rc));
if (rrc == 0)
20390f4: 80 a7 60 00 cmp %i5, 0 <== NOT EXECUTED
20390f8: 22 80 00 02 be,a 2039100 <rtems_rfs_file_close+0x238> <== NOT EXECUTED
20390fc: ba 10 00 1c mov %i4, %i5 <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
2039100: 7f ff c8 59 call 202b264 <_Chain_Extract>
2039104: d0 06 60 1c ld [ %i1 + 0x1c ], %o0
rrc = rc;
}
rtems_chain_extract (&handle->shared->link);
free (handle->shared);
2039108: 7f ff 3e bd call 2008bfc <free>
203910c: d0 06 60 1c ld [ %i1 + 0x1c ], %o0
*/
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);
2039110: 90 10 00 18 mov %i0, %o0
2039114: 7f ff f8 a2 call 203739c <rtems_rfs_buffer_handle_release>
2039118: 92 06 60 04 add %i1, 4, %o1
handle->dirty = false;
203911c: c0 2e 60 04 clrb [ %i1 + 4 ]
handle->bnum = 0;
2039120: c0 26 60 08 clr [ %i1 + 8 ]
rc = rtems_rfs_buffer_handle_close (fs, &handle->buffer);
if ((rrc == 0) && (rc > 0))
rrc = rc;
if (rrc > 0)
2039124: 80 a7 60 00 cmp %i5, 0
2039128: 04 80 00 0f ble 2039164 <rtems_rfs_file_close+0x29c> <== ALWAYS TAKEN
203912c: c0 26 60 0c clr [ %i1 + 0xc ]
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_CLOSE))
2039130: 90 10 20 10 mov 0x10, %o0 <== NOT EXECUTED
2039134: 7f ff aa 46 call 2023a4c <rtems_rfs_trace> <== NOT EXECUTED
2039138: 92 10 20 00 clr %o1 <== NOT EXECUTED
203913c: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
2039140: 22 80 00 0a be,a 2039168 <rtems_rfs_file_close+0x2a0> <== NOT EXECUTED
2039144: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
printf ("rtems-rfs: file-close: result: %d: %s\n", rrc, strerror (rrc));
2039148: 40 00 3f e7 call 20490e4 <strerror> <== NOT EXECUTED
203914c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
2039150: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
2039154: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
2039158: 11 00 81 9f sethi %hi(0x2067c00), %o0 <== NOT EXECUTED
203915c: 40 00 36 63 call 2046ae8 <printf> <== NOT EXECUTED
2039160: 90 12 23 10 or %o0, 0x310, %o0 ! 2067f10 <__FUNCTION__.7829+0xe20><== NOT EXECUTED
}
free (handle);
2039164: 90 10 00 19 mov %i1, %o0
2039168: 7f ff 3e a5 call 2008bfc <free>
203916c: b0 10 00 1d mov %i5, %i0
return rrc;
}
2039170: 81 c7 e0 08 ret
2039174: 81 e8 00 00 restore
0203939c <rtems_rfs_file_io_end>:
int
rtems_rfs_file_io_end (rtems_rfs_file_handle* handle,
size_t size,
bool read)
{
203939c: 9d e3 bf a0 save %sp, -96, %sp
bool atime;
bool mtime;
bool length;
int rc = 0;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
20393a0: 90 10 20 20 mov 0x20, %o0
20393a4: 92 10 20 00 clr %o1
20393a8: 7f ff a9 a9 call 2023a4c <rtems_rfs_trace>
20393ac: ba 10 00 18 mov %i0, %i5
20393b0: 80 8a 20 ff btst 0xff, %o0
20393b4: 22 80 00 0e be,a 20393ec <rtems_rfs_file_io_end+0x50> <== ALWAYS TAKEN
20393b8: c2 07 60 0c ld [ %i5 + 0xc ], %g1
printf ("rtems-rfs: file-io: end: %s size=%zu\n",
20393bc: 80 a6 a0 00 cmp %i2, 0 <== NOT EXECUTED
20393c0: 22 80 00 05 be,a 20393d4 <rtems_rfs_file_io_end+0x38> <== NOT EXECUTED
20393c4: 13 00 81 7e sethi %hi(0x205f800), %o1 <== NOT EXECUTED
20393c8: 13 00 81 8e sethi %hi(0x2063800), %o1 <== NOT EXECUTED
20393cc: 10 80 00 03 b 20393d8 <rtems_rfs_file_io_end+0x3c> <== NOT EXECUTED
20393d0: 92 12 60 80 or %o1, 0x80, %o1 ! 2063880 <rtems_rfs_rtems_eval_config+0xd48><== NOT EXECUTED
20393d4: 92 12 61 b0 or %o1, 0x1b0, %o1 <== NOT EXECUTED
20393d8: 11 00 81 9f sethi %hi(0x2067c00), %o0 <== NOT EXECUTED
20393dc: 94 10 00 19 mov %i1, %o2 <== NOT EXECUTED
20393e0: 40 00 35 c2 call 2046ae8 <printf> <== NOT EXECUTED
20393e4: 90 12 23 f0 or %o0, 0x3f0, %o0 <== NOT EXECUTED
read ? "read" : "write", size);
if (rtems_rfs_buffer_handle_has_block (&handle->buffer))
20393e8: c2 07 60 0c ld [ %i5 + 0xc ], %g1 <== NOT EXECUTED
20393ec: 80 a0 60 00 cmp %g1, 0
20393f0: 02 80 00 1e be 2039468 <rtems_rfs_file_io_end+0xcc> <== NEVER TAKEN
20393f4: 80 a6 a0 00 cmp %i2, 0
{
if (!read)
20393f8: 32 80 00 05 bne,a 203940c <rtems_rfs_file_io_end+0x70>
20393fc: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
rtems_rfs_buffer_mark_dirty (rtems_rfs_file_buffer (handle));
2039400: 82 10 20 01 mov 1, %g1
2039404: c2 2f 60 04 stb %g1, [ %i5 + 4 ]
rc = rtems_rfs_buffer_handle_release (rtems_rfs_file_fs (handle),
2039408: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
203940c: 92 07 60 04 add %i5, 4, %o1
2039410: 7f ff f7 e3 call 203739c <rtems_rfs_buffer_handle_release>
2039414: d0 00 60 98 ld [ %g1 + 0x98 ], %o0
rtems_rfs_file_buffer (handle));
if (rc > 0)
2039418: b0 92 20 00 orcc %o0, 0, %i0
203941c: 04 80 00 14 ble 203946c <rtems_rfs_file_io_end+0xd0> <== ALWAYS TAKEN
2039420: 80 a6 a0 00 cmp %i2, 0
{
printf (
2039424: 22 80 00 05 be,a 2039438 <rtems_rfs_file_io_end+0x9c> <== NOT EXECUTED
2039428: 3b 00 81 7e sethi %hi(0x205f800), %i5 <== NOT EXECUTED
203942c: 3b 00 81 8e sethi %hi(0x2063800), %i5 <== NOT EXECUTED
2039430: 10 80 00 03 b 203943c <rtems_rfs_file_io_end+0xa0> <== NOT EXECUTED
2039434: ba 17 60 80 or %i5, 0x80, %i5 ! 2063880 <rtems_rfs_rtems_eval_config+0xd48><== NOT EXECUTED
2039438: ba 17 61 b0 or %i5, 0x1b0, %i5 <== NOT EXECUTED
203943c: 40 00 3f 2a call 20490e4 <strerror> <== NOT EXECUTED
2039440: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
2039444: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
2039448: 98 10 00 08 mov %o0, %o4 <== NOT EXECUTED
203944c: 94 10 00 19 mov %i1, %o2 <== NOT EXECUTED
2039450: 11 00 81 a0 sethi %hi(0x2068000), %o0 <== NOT EXECUTED
2039454: 96 10 00 18 mov %i0, %o3 <== NOT EXECUTED
2039458: 40 00 35 a4 call 2046ae8 <printf> <== NOT EXECUTED
203945c: 90 12 20 18 or %o0, 0x18, %o0 <== 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;
2039460: 81 c7 e0 08 ret <== NOT EXECUTED
2039464: 81 e8 00 00 restore <== NOT EXECUTED
bool read)
{
bool atime;
bool mtime;
bool length;
int rc = 0;
2039468: b0 10 20 00 clr %i0 <== NOT EXECUTED
* increase the block number and adjust the offset.
*
* If we are the last block and the position is past the current size update
* the size with the new length. The map holds the block count.
*/
handle->bpos.boff += size;
203946c: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
2039470: b2 06 40 01 add %i1, %g1, %i1
if (handle->bpos.boff >=
rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle)))
2039474: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
* 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;
2039478: f2 27 60 14 st %i1, [ %i5 + 0x14 ]
if (handle->bpos.boff >=
rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle)))
203947c: c4 00 60 98 ld [ %g1 + 0x98 ], %g2
2039480: c4 00 a0 08 ld [ %g2 + 8 ], %g2
* 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;
if (handle->bpos.boff >=
2039484: 80 a6 40 02 cmp %i1, %g2
2039488: 0a 80 00 07 bcs 20394a4 <rtems_rfs_file_io_end+0x108>
203948c: 80 a6 a0 00 cmp %i2, 0
rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle)))
{
handle->bpos.bno++;
2039490: c6 07 60 10 ld [ %i5 + 0x10 ], %g3
handle->bpos.boff -= rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
2039494: b2 26 40 02 sub %i1, %g2, %i1
handle->bpos.boff += size;
if (handle->bpos.boff >=
rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle)))
{
handle->bpos.bno++;
2039498: 86 00 e0 01 inc %g3
handle->bpos.boff -= rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
203949c: f2 27 60 14 st %i1, [ %i5 + 0x14 ]
handle->bpos.boff += size;
if (handle->bpos.boff >=
rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle)))
{
handle->bpos.bno++;
20394a0: c6 27 60 10 st %g3, [ %i5 + 0x10 ]
}
length = false;
mtime = false;
if (!read &&
20394a4: 12 80 00 19 bne 2039508 <rtems_rfs_file_io_end+0x16c>
20394a8: 84 10 20 00 clr %g2
rtems_rfs_block_map_past_end (rtems_rfs_file_map (handle),
20394ac: c6 07 60 10 ld [ %i5 + 0x10 ], %g3
}
length = false;
mtime = false;
if (!read &&
20394b0: 80 a0 e0 00 cmp %g3, 0
20394b4: 02 80 00 05 be 20394c8 <rtems_rfs_file_io_end+0x12c>
20394b8: c4 00 60 3c ld [ %g1 + 0x3c ], %g2
rtems_rfs_block_map_past_end (rtems_rfs_file_map (handle),
20394bc: 80 a0 a0 00 cmp %g2, 0
20394c0: 22 80 00 0f be,a 20394fc <rtems_rfs_file_io_end+0x160> <== NEVER TAKEN
20394c4: c4 07 60 14 ld [ %i5 + 0x14 ], %g2 <== NOT EXECUTED
20394c8: 80 a0 c0 02 cmp %g3, %g2
20394cc: 3a 80 00 0c bcc,a 20394fc <rtems_rfs_file_io_end+0x160>
20394d0: c4 07 60 14 ld [ %i5 + 0x14 ], %g2
20394d4: 88 00 bf ff add %g2, -1, %g4
20394d8: 80 a0 c0 04 cmp %g3, %g4
20394dc: 12 80 00 0b bne 2039508 <rtems_rfs_file_io_end+0x16c>
20394e0: 84 10 20 00 clr %g2
20394e4: c8 07 60 14 ld [ %i5 + 0x14 ], %g4
20394e8: c6 00 60 40 ld [ %g1 + 0x40 ], %g3
20394ec: 80 a1 00 03 cmp %g4, %g3
20394f0: 28 80 00 07 bleu,a 203950c <rtems_rfs_file_io_end+0x170>
20394f4: c2 07 40 00 ld [ %i5 ], %g1
*/
static inline void
rtems_rfs_block_map_set_size_offset (rtems_rfs_block_map* map,
rtems_rfs_block_off offset)
{
map->size.offset = offset;
20394f8: c4 07 60 14 ld [ %i5 + 0x14 ], %g2
20394fc: c4 20 60 40 st %g2, [ %g1 + 0x40 ]
map->dirty = true;
2039500: 84 10 20 01 mov 1, %g2
2039504: c4 28 60 34 stb %g2, [ %g1 + 0x34 ]
handle->bpos.boff);
length = true;
mtime = true;
}
atime = rtems_rfs_file_update_atime (handle);
2039508: c2 07 40 00 ld [ %i5 ], %g1
mtime = rtems_rfs_file_update_mtime (handle) && mtime;
203950c: b8 10 20 00 clr %i4
handle->bpos.boff);
length = true;
mtime = true;
}
atime = rtems_rfs_file_update_atime (handle);
2039510: a2 08 60 01 and %g1, 1, %l1
mtime = rtems_rfs_file_update_mtime (handle) && mtime;
2039514: 80 88 60 02 btst 2, %g1
2039518: a2 1c 60 01 xor %l1, 1, %l1
203951c: 12 80 00 03 bne 2039528 <rtems_rfs_file_io_end+0x18c> <== NEVER TAKEN
2039520: a0 10 00 11 mov %l1, %l0
2039524: b8 08 a0 ff and %g2, 0xff, %i4
2039528: b2 0f 20 01 and %i4, 1, %i1
length = rtems_rfs_file_update_length (handle) && length;
203952c: 80 88 60 04 btst 4, %g1
2039530: 12 80 00 03 bne 203953c <rtems_rfs_file_io_end+0x1a0> <== NEVER TAKEN
2039534: b6 10 20 00 clr %i3
2039538: b6 08 a0 ff and %g2, 0xff, %i3
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
203953c: 90 10 20 20 mov 0x20, %o0
2039540: 92 10 20 00 clr %o1
2039544: 7f ff a9 42 call 2023a4c <rtems_rfs_trace>
2039548: b6 0e e0 01 and %i3, 1, %i3
203954c: 80 8a 20 ff btst 0xff, %o0
2039550: 22 80 00 17 be,a 20395ac <rtems_rfs_file_io_end+0x210> <== ALWAYS TAKEN
2039554: b8 17 00 11 or %i4, %l1, %i4
printf ("rtems-rfs: file-io: end: pos=%" PRIu32 ":%" PRIu32 " %c %c %c\n",
2039558: 82 0c 20 ff and %l0, 0xff, %g1 <== NOT EXECUTED
203955c: 80 a0 00 01 cmp %g0, %g1 <== NOT EXECUTED
2039560: d2 07 60 10 ld [ %i5 + 0x10 ], %o1 <== NOT EXECUTED
2039564: 96 40 3f ff addx %g0, -1, %o3 <== NOT EXECUTED
2039568: 82 0e 60 ff and %i1, 0xff, %g1 <== NOT EXECUTED
203956c: d4 07 60 14 ld [ %i5 + 0x14 ], %o2 <== NOT EXECUTED
2039570: 80 a0 00 01 cmp %g0, %g1 <== NOT EXECUTED
2039574: 82 0e e0 ff and %i3, 0xff, %g1 <== NOT EXECUTED
2039578: 98 40 3f ff addx %g0, -1, %o4 <== NOT EXECUTED
203957c: 80 a0 00 01 cmp %g0, %g1 <== NOT EXECUTED
2039580: 96 0a ff ec and %o3, -20, %o3 <== NOT EXECUTED
2039584: 98 0b 3f e0 and %o4, -32, %o4 <== NOT EXECUTED
2039588: 9a 40 3f ff addx %g0, -1, %o5 <== NOT EXECUTED
203958c: 11 00 81 a0 sethi %hi(0x2068000), %o0 <== NOT EXECUTED
2039590: 9a 0b 7f e1 and %o5, -31, %o5 <== NOT EXECUTED
2039594: 90 12 20 60 or %o0, 0x60, %o0 <== NOT EXECUTED
2039598: 96 02 e0 41 add %o3, 0x41, %o3 <== NOT EXECUTED
203959c: 98 03 20 4d add %o4, 0x4d, %o4 <== NOT EXECUTED
20395a0: 40 00 35 52 call 2046ae8 <printf> <== NOT EXECUTED
20395a4: 9a 03 60 4c add %o5, 0x4c, %o5 <== NOT EXECUTED
handle->bpos.bno, handle->bpos.boff,
atime ? 'A' : '-', mtime ? 'M' : '-', length ? 'L' : '-');
if (atime || mtime)
20395a8: b8 17 00 11 or %i4, %l1, %i4 <== NOT EXECUTED
20395ac: 80 8f 20 01 btst 1, %i4
20395b0: 02 80 00 13 be 20395fc <rtems_rfs_file_io_end+0x260> <== NEVER TAKEN
20395b4: 80 8e e0 ff btst 0xff, %i3
{
time_t now = time (NULL);
20395b8: 40 00 55 7b call 204eba4 <time>
20395bc: 90 10 20 00 clr %o0
if (read && atime)
20395c0: 80 a6 a0 00 cmp %i2, 0
20395c4: 02 80 00 07 be 20395e0 <rtems_rfs_file_io_end+0x244>
20395c8: 80 8e 60 ff btst 0xff, %i1
20395cc: 80 8c 20 ff btst 0xff, %l0
20395d0: 02 80 00 04 be 20395e0 <rtems_rfs_file_io_end+0x244> <== NEVER TAKEN
20395d4: 80 8e 60 ff btst 0xff, %i1
handle->shared->atime = now;
20395d8: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
20395dc: d0 20 60 8c st %o0, [ %g1 + 0x8c ]
if (!read && mtime)
20395e0: 02 80 00 07 be 20395fc <rtems_rfs_file_io_end+0x260>
20395e4: 80 8e e0 ff btst 0xff, %i3
20395e8: 80 a6 a0 01 cmp %i2, 1
20395ec: 02 80 00 04 be 20395fc <rtems_rfs_file_io_end+0x260> <== NEVER TAKEN
20395f0: 80 8e e0 ff btst 0xff, %i3
handle->shared->mtime = now;
20395f4: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
20395f8: d0 20 60 90 st %o0, [ %g1 + 0x90 ]
}
if (length)
20395fc: 02 80 00 07 be 2039618 <rtems_rfs_file_io_end+0x27c>
2039600: 01 00 00 00 nop
{
handle->shared->size.count =
rtems_rfs_block_map_count (rtems_rfs_file_map (handle));
2039604: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
if (!read && mtime)
handle->shared->mtime = now;
}
if (length)
{
handle->shared->size.count =
2039608: c4 00 60 3c ld [ %g1 + 0x3c ], %g2
203960c: c4 20 60 84 st %g2, [ %g1 + 0x84 ]
rtems_rfs_block_map_count (rtems_rfs_file_map (handle));
handle->shared->size.offset =
2039610: c4 00 60 40 ld [ %g1 + 0x40 ], %g2
2039614: c4 20 60 88 st %g2, [ %g1 + 0x88 ]
rtems_rfs_block_map_size_offset (rtems_rfs_file_map (handle));
}
return rc;
}
2039618: 81 c7 e0 08 ret
203961c: 81 e8 00 00 restore
02039620 <rtems_rfs_file_io_release>:
int
rtems_rfs_file_io_release (rtems_rfs_file_handle* handle)
{
int rc = 0;
if (rtems_rfs_buffer_handle_has_block (&handle->buffer))
2039620: c2 02 20 0c ld [ %o0 + 0xc ], %g1
2039624: 80 a0 60 00 cmp %g1, 0
2039628: 02 80 00 08 be 2039648 <rtems_rfs_file_io_release+0x28> <== ALWAYS TAKEN
203962c: 92 10 00 08 mov %o0, %o1
rc = rtems_rfs_buffer_handle_release (rtems_rfs_file_fs (handle),
2039630: c2 02 20 1c ld [ %o0 + 0x1c ], %g1 <== NOT EXECUTED
2039634: 92 02 60 04 add %o1, 4, %o1 <== NOT EXECUTED
2039638: d0 00 60 98 ld [ %g1 + 0x98 ], %o0 <== NOT EXECUTED
203963c: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED
2039640: 7f ff f7 57 call 203739c <rtems_rfs_buffer_handle_release><== NOT EXECUTED
2039644: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED
rtems_rfs_file_buffer (handle));
return rc;
}
2039648: 81 c3 e0 08 retl
203964c: 90 10 20 00 clr %o0
02039178 <rtems_rfs_file_io_start>:
int
rtems_rfs_file_io_start (rtems_rfs_file_handle* handle,
size_t* available,
bool read)
{
2039178: 9d e3 bf 98 save %sp, -104, %sp
size_t size;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
203917c: 90 10 20 20 mov 0x20, %o0
2039180: 92 10 20 00 clr %o1
2039184: 7f ff aa 32 call 2023a4c <rtems_rfs_trace>
2039188: ba 10 00 18 mov %i0, %i5
203918c: 80 8a 20 ff btst 0xff, %o0
2039190: 22 80 00 0f be,a 20391cc <rtems_rfs_file_io_start+0x54> <== ALWAYS TAKEN
2039194: c2 07 60 0c ld [ %i5 + 0xc ], %g1
printf ("rtems-rfs: file-io: start: %s pos=%" PRIu32 ":%" PRIu32 "\n",
2039198: 80 a6 a0 00 cmp %i2, 0 <== NOT EXECUTED
203919c: 22 80 00 05 be,a 20391b0 <rtems_rfs_file_io_start+0x38> <== NOT EXECUTED
20391a0: 13 00 81 7e sethi %hi(0x205f800), %o1 <== NOT EXECUTED
20391a4: 13 00 81 8e sethi %hi(0x2063800), %o1 <== NOT EXECUTED
20391a8: 10 80 00 03 b 20391b4 <rtems_rfs_file_io_start+0x3c> <== NOT EXECUTED
20391ac: 92 12 60 80 or %o1, 0x80, %o1 ! 2063880 <rtems_rfs_rtems_eval_config+0xd48><== NOT EXECUTED
20391b0: 92 12 61 b0 or %o1, 0x1b0, %o1 <== NOT EXECUTED
20391b4: d4 07 60 10 ld [ %i5 + 0x10 ], %o2 <== NOT EXECUTED
20391b8: d6 07 60 14 ld [ %i5 + 0x14 ], %o3 <== NOT EXECUTED
20391bc: 11 00 81 9f sethi %hi(0x2067c00), %o0 <== NOT EXECUTED
20391c0: 40 00 36 4a call 2046ae8 <printf> <== NOT EXECUTED
20391c4: 90 12 23 38 or %o0, 0x338, %o0 ! 2067f38 <__FUNCTION__.7829+0xe48><== NOT EXECUTED
read ? "read" : "write", handle->bpos.bno, handle->bpos.boff);
if (!rtems_rfs_buffer_handle_has_block (&handle->buffer))
20391c8: c2 07 60 0c ld [ %i5 + 0xc ], %g1 <== NOT EXECUTED
20391cc: 80 a0 60 00 cmp %g1, 0
20391d0: 12 80 00 4f bne 203930c <rtems_rfs_file_io_start+0x194>
20391d4: 80 a6 a0 00 cmp %i2, 0
bool request_read;
int rc;
request_read = read;
rc = rtems_rfs_block_map_find (rtems_rfs_file_fs (handle),
20391d8: d2 07 60 1c ld [ %i5 + 0x1c ], %o1
20391dc: 94 07 60 10 add %i5, 0x10, %o2
20391e0: d0 02 60 98 ld [ %o1 + 0x98 ], %o0
20391e4: 96 07 bf fc add %fp, -4, %o3
20391e8: 7f ff f5 c9 call 203690c <rtems_rfs_block_map_find>
20391ec: 92 02 60 34 add %o1, 0x34, %o1
rtems_rfs_file_map (handle),
rtems_rfs_file_bpos (handle),
&block);
if (rc > 0)
20391f0: b0 92 20 00 orcc %o0, 0, %i0
20391f4: 04 80 00 1e ble 203926c <rtems_rfs_file_io_start+0xf4>
20391f8: 80 a6 20 06 cmp %i0, 6
{
/*
* Has the read reached the EOF ?
*/
if (read && (rc == ENXIO))
20391fc: 32 80 00 66 bne,a 2039394 <rtems_rfs_file_io_start+0x21c><== NEVER TAKEN
2039200: 90 10 20 20 mov 0x20, %o0 <== NOT EXECUTED
2039204: 80 a6 a0 00 cmp %i2, 0
2039208: 22 80 00 05 be,a 203921c <rtems_rfs_file_io_start+0xa4> <== ALWAYS TAKEN
203920c: 80 a6 20 06 cmp %i0, 6
{
*available = 0;
2039210: c0 26 40 00 clr [ %i1 ] <== NOT EXECUTED
return 0;
2039214: 81 c7 e0 08 ret <== NOT EXECUTED
2039218: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED
}
if (rc != ENXIO)
203921c: 12 80 00 5e bne 2039394 <rtems_rfs_file_io_start+0x21c> <== NEVER TAKEN
2039220: 90 10 20 20 mov 0x20, %o0
return rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
2039224: 7f ff aa 0a call 2023a4c <rtems_rfs_trace>
2039228: 92 10 20 00 clr %o1
203922c: 80 8a 20 ff btst 0xff, %o0
2039230: 22 80 00 06 be,a 2039248 <rtems_rfs_file_io_start+0xd0> <== ALWAYS TAKEN
2039234: d2 07 60 1c ld [ %i5 + 0x1c ], %o1
printf ("rtems-rfs: file-io: start: grow\n");
2039238: 11 00 81 9f sethi %hi(0x2067c00), %o0 <== NOT EXECUTED
203923c: 40 00 36 c3 call 2046d48 <puts> <== NOT EXECUTED
2039240: 90 12 23 68 or %o0, 0x368, %o0 ! 2067f68 <__FUNCTION__.7829+0xe78><== NOT EXECUTED
rc = rtems_rfs_block_map_grow (rtems_rfs_file_fs (handle),
2039244: d2 07 60 1c ld [ %i5 + 0x1c ], %o1 <== NOT EXECUTED
2039248: 94 10 20 01 mov 1, %o2
203924c: d0 02 60 98 ld [ %o1 + 0x98 ], %o0
2039250: 96 07 bf fc add %fp, -4, %o3
2039254: 7f ff f6 34 call 2036b24 <rtems_rfs_block_map_grow>
2039258: 92 02 60 34 add %o1, 0x34, %o1
rtems_rfs_file_map (handle),
1, &block);
if (rc > 0)
203925c: b0 92 20 00 orcc %o0, 0, %i0
2039260: 14 80 00 4d bg 2039394 <rtems_rfs_file_io_start+0x21c>
2039264: b8 10 20 00 clr %i4
2039268: 30 80 00 0f b,a 20392a4 <rtems_rfs_file_io_start+0x12c>
/*
* 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 &&
203926c: 80 a6 a0 00 cmp %i2, 0
2039270: 12 80 00 0d bne 20392a4 <rtems_rfs_file_io_start+0x12c>
2039274: b8 10 00 1a mov %i2, %i4
2039278: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
203927c: 80 a0 60 00 cmp %g1, 0
2039280: 12 80 00 09 bne 20392a4 <rtems_rfs_file_io_start+0x12c>
2039284: b8 10 20 01 mov 1, %i4
(rtems_rfs_file_block_offset (handle) ||
(*available < rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle)))))
2039288: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
* 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) ||
203928c: c4 06 40 00 ld [ %i1 ], %g2
(*available < rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle)))))
2039290: c2 00 60 98 ld [ %g1 + 0x98 ], %g1
* 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) ||
2039294: c2 00 60 08 ld [ %g1 + 8 ], %g1
2039298: 80 a0 80 01 cmp %g2, %g1
203929c: 3a 80 00 02 bcc,a 20392a4 <rtems_rfs_file_io_start+0x12c><== NEVER TAKEN
20392a0: b8 10 20 00 clr %i4 <== NOT EXECUTED
(*available < rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle)))))
request_read = true;
}
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
20392a4: 90 10 20 20 mov 0x20, %o0
20392a8: 7f ff a9 e9 call 2023a4c <rtems_rfs_trace>
20392ac: 92 10 20 00 clr %o1
20392b0: 80 8a 20 ff btst 0xff, %o0
20392b4: 22 80 00 0e be,a 20392ec <rtems_rfs_file_io_start+0x174> <== ALWAYS TAKEN
20392b8: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
printf ("rtems-rfs: file-io: start: block=%" PRIu32 " request-read=%s\n",
20392bc: 80 8f 20 ff btst 0xff, %i4 <== NOT EXECUTED
20392c0: 02 80 00 05 be 20392d4 <rtems_rfs_file_io_start+0x15c> <== NOT EXECUTED
20392c4: d2 07 bf fc ld [ %fp + -4 ], %o1 <== NOT EXECUTED
20392c8: 15 00 81 9e sethi %hi(0x2067800), %o2 <== NOT EXECUTED
20392cc: 10 80 00 04 b 20392dc <rtems_rfs_file_io_start+0x164> <== NOT EXECUTED
20392d0: 94 12 a3 88 or %o2, 0x388, %o2 ! 2067b88 <__FUNCTION__.7829+0xa98><== NOT EXECUTED
20392d4: 15 00 81 9e sethi %hi(0x2067800), %o2 <== NOT EXECUTED
20392d8: 94 12 a3 90 or %o2, 0x390, %o2 ! 2067b90 <__FUNCTION__.7829+0xaa0><== NOT EXECUTED
20392dc: 11 00 81 9f sethi %hi(0x2067c00), %o0 <== NOT EXECUTED
20392e0: 40 00 36 02 call 2046ae8 <printf> <== NOT EXECUTED
20392e4: 90 12 23 88 or %o0, 0x388, %o0 ! 2067f88 <__FUNCTION__.7829+0xe98><== NOT EXECUTED
block, request_read ? "yes" : "no");
rc = rtems_rfs_buffer_handle_request (rtems_rfs_file_fs (handle),
20392e8: c2 07 60 1c ld [ %i5 + 0x1c ], %g1 <== NOT EXECUTED
20392ec: d4 07 bf fc ld [ %fp + -4 ], %o2
20392f0: d0 00 60 98 ld [ %g1 + 0x98 ], %o0
20392f4: 92 07 60 04 add %i5, 4, %o1
20392f8: 7f ff f8 9d call 203756c <rtems_rfs_buffer_handle_request>
20392fc: 96 0f 20 ff and %i4, 0xff, %o3
rtems_rfs_file_buffer (handle),
block, request_read);
if (rc > 0)
2039300: b0 92 20 00 orcc %o0, 0, %i0
2039304: 14 80 00 24 bg 2039394 <rtems_rfs_file_io_start+0x21c> <== NEVER TAKEN
2039308: 80 a6 a0 00 cmp %i2, 0
return rc;
}
if (read
203930c: 02 80 00 12 be 2039354 <rtems_rfs_file_io_start+0x1dc>
2039310: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
&& rtems_rfs_block_map_last (rtems_rfs_file_map (handle))
2039314: c4 00 60 44 ld [ %g1 + 0x44 ], %g2
2039318: 80 a0 a0 00 cmp %g2, 0
203931c: 12 80 00 05 bne 2039330 <rtems_rfs_file_io_start+0x1b8>
2039320: c6 00 60 3c ld [ %g1 + 0x3c ], %g3
2039324: 80 a0 e0 00 cmp %g3, 0
2039328: 22 80 00 07 be,a 2039344 <rtems_rfs_file_io_start+0x1cc> <== NEVER TAKEN
203932c: f8 00 60 40 ld [ %g1 + 0x40 ], %i4 <== NOT EXECUTED
2039330: 86 00 ff ff add %g3, -1, %g3
2039334: 80 a0 80 03 cmp %g2, %g3
2039338: 32 80 00 07 bne,a 2039354 <rtems_rfs_file_io_start+0x1dc>
203933c: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
&& rtems_rfs_block_map_size_offset (rtems_rfs_file_map (handle)))
2039340: f8 00 60 40 ld [ %g1 + 0x40 ], %i4
2039344: 80 a7 20 00 cmp %i4, 0
2039348: 32 80 00 06 bne,a 2039360 <rtems_rfs_file_io_start+0x1e8>
203934c: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
size = rtems_rfs_block_map_size_offset (rtems_rfs_file_map (handle));
else
size = rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
2039350: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
2039354: c2 00 60 98 ld [ %g1 + 0x98 ], %g1
2039358: f8 00 60 08 ld [ %g1 + 8 ], %i4
*available = size - rtems_rfs_file_block_offset (handle);
203935c: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
2039360: 90 10 20 20 mov 0x20, %o0
&& 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);
2039364: 82 27 00 01 sub %i4, %g1, %g1
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
2039368: 92 10 20 00 clr %o1
&& 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);
203936c: c2 26 40 00 st %g1, [ %i1 ]
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
2039370: 7f ff a9 b7 call 2023a4c <rtems_rfs_trace>
2039374: b0 10 20 00 clr %i0
2039378: 80 8a 20 ff btst 0xff, %o0
203937c: 02 80 00 06 be 2039394 <rtems_rfs_file_io_start+0x21c> <== ALWAYS TAKEN
2039380: 11 00 81 9f sethi %hi(0x2067c00), %o0
printf ("rtems-rfs: file-io: start: available=%zu (%zu)\n",
2039384: d2 06 40 00 ld [ %i1 ], %o1 <== NOT EXECUTED
2039388: 94 10 00 1c mov %i4, %o2 <== NOT EXECUTED
203938c: 40 00 35 d7 call 2046ae8 <printf> <== NOT EXECUTED
2039390: 90 12 23 c0 or %o0, 0x3c0, %o0 <== NOT EXECUTED
*available, size);
return 0;
}
2039394: 81 c7 e0 08 ret
2039398: 81 e8 00 00 restore
02039aa8 <rtems_rfs_file_open>:
int
rtems_rfs_file_open (rtems_rfs_file_system* fs,
rtems_rfs_ino ino,
int oflag,
rtems_rfs_file_handle** file)
{
2039aa8: 9d e3 bf a0 save %sp, -96, %sp
rtems_rfs_file_handle* handle;
rtems_rfs_file_shared* shared;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_OPEN))
2039aac: 90 10 20 08 mov 8, %o0
2039ab0: 7f ff a7 e7 call 2023a4c <rtems_rfs_trace>
2039ab4: 92 10 20 00 clr %o1
2039ab8: 80 8a 20 ff btst 0xff, %o0
2039abc: 22 80 00 07 be,a 2039ad8 <rtems_rfs_file_open+0x30> <== ALWAYS TAKEN
2039ac0: c0 26 c0 00 clr [ %i3 ]
printf ("rtems-rfs: file-open: ino=%" PRId32 "\n", ino);
2039ac4: 11 00 81 a0 sethi %hi(0x2068000), %o0 <== NOT EXECUTED
2039ac8: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
2039acc: 40 00 34 07 call 2046ae8 <printf> <== NOT EXECUTED
2039ad0: 90 12 20 e0 or %o0, 0xe0, %o0 <== NOT EXECUTED
*file = NULL;
2039ad4: c0 26 c0 00 clr [ %i3 ] <== NOT EXECUTED
/*
* 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));
2039ad8: 90 10 20 20 mov 0x20, %o0
2039adc: 7f ff 3d a6 call 2009174 <malloc>
2039ae0: a0 10 20 0c mov 0xc, %l0
if (!handle)
2039ae4: 80 a2 20 00 cmp %o0, 0
2039ae8: 02 80 00 a4 be 2039d78 <rtems_rfs_file_open+0x2d0> <== NEVER TAKEN
2039aec: ba 10 00 08 mov %o0, %i5
return ENOMEM;
memset (handle, 0, sizeof (rtems_rfs_file_handle));
2039af0: 92 10 20 00 clr %o1
2039af4: 40 00 2f 8c call 2045924 <memset>
2039af8: 94 10 20 20 mov 0x20, %o2
/*
* 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);
2039afc: 90 10 00 18 mov %i0, %o0
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
2039b00: c0 2f 60 04 clrb [ %i5 + 4 ]
handle->bnum = 0;
2039b04: c0 27 60 08 clr [ %i5 + 8 ]
handle->buffer = NULL;
2039b08: c0 27 60 0c clr [ %i5 + 0xc ]
2039b0c: 7f ff ff d9 call 2039a70 <rtems_rfs_file_get_shared>
2039b10: 92 10 00 19 mov %i1, %o1
if (shared)
2039b14: b8 92 20 00 orcc %o0, 0, %i4
2039b18: 02 80 00 0d be 2039b4c <rtems_rfs_file_open+0xa4> <== ALWAYS TAKEN
2039b1c: 90 10 20 08 mov 8, %o0
{
shared->references++;
2039b20: c2 07 20 08 ld [ %i4 + 8 ], %g1 <== NOT EXECUTED
2039b24: 82 00 60 01 inc %g1 <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_OPEN))
2039b28: 92 10 20 00 clr %o1 <== NOT EXECUTED
2039b2c: 7f ff a7 c8 call 2023a4c <rtems_rfs_trace> <== NOT EXECUTED
2039b30: c2 27 20 08 st %g1, [ %i4 + 8 ] <== NOT EXECUTED
2039b34: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
2039b38: 22 80 00 8d be,a 2039d6c <rtems_rfs_file_open+0x2c4> <== NOT EXECUTED
2039b3c: f4 27 40 00 st %i2, [ %i5 ] <== NOT EXECUTED
printf ("rtems-rfs: file-open: ino=%" PRId32 " shared\n", ino);
2039b40: 11 00 81 a0 sethi %hi(0x2068000), %o0 <== NOT EXECUTED
2039b44: 10 80 00 87 b 2039d60 <rtems_rfs_file_open+0x2b8> <== NOT EXECUTED
2039b48: 90 12 21 00 or %o0, 0x100, %o0 ! 2068100 <__FUNCTION__.7829+0x1010><== 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));
2039b4c: 7f ff 3d 8a call 2009174 <malloc>
2039b50: 90 10 20 9c mov 0x9c, %o0
if (!shared)
2039b54: b8 92 20 00 orcc %o0, 0, %i4
2039b58: 12 80 00 04 bne 2039b68 <rtems_rfs_file_open+0xc0> <== ALWAYS TAKEN
2039b5c: 92 10 20 00 clr %o1
*/
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);
2039b60: 10 80 00 34 b 2039c30 <rtems_rfs_file_open+0x188> <== NOT EXECUTED
2039b64: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
rtems_rfs_buffer_handle_close (fs, &handle->buffer);
free (handle);
return ENOMEM;
}
memset (shared, 0, sizeof (rtems_rfs_file_shared));
2039b68: 40 00 2f 6f call 2045924 <memset>
2039b6c: 94 10 20 9c mov 0x9c, %o2
rc = rtems_rfs_inode_open (fs, ino, &shared->inode, true);
2039b70: a2 07 20 0c add %i4, 0xc, %l1
2039b74: 90 10 00 18 mov %i0, %o0
2039b78: 92 10 00 19 mov %i1, %o1
2039b7c: 94 10 00 11 mov %l1, %o2
2039b80: 40 00 08 08 call 203bba0 <rtems_rfs_inode_open>
2039b84: 96 10 20 01 mov 1, %o3
if (rc > 0)
2039b88: a0 92 20 00 orcc %o0, 0, %l0
2039b8c: 04 80 00 0f ble 2039bc8 <rtems_rfs_file_open+0x120> <== ALWAYS TAKEN
2039b90: 90 10 20 08 mov 8, %o0
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_OPEN))
2039b94: 7f ff a7 ae call 2023a4c <rtems_rfs_trace> <== NOT EXECUTED
2039b98: 92 10 20 00 clr %o1 <== NOT EXECUTED
2039b9c: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
2039ba0: 02 80 00 21 be 2039c24 <rtems_rfs_file_open+0x17c> <== NOT EXECUTED
2039ba4: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: file-open: inode open failed: %d: %s\n",
2039ba8: 40 00 3d 4f call 20490e4 <strerror> <== NOT EXECUTED
2039bac: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
2039bb0: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED
2039bb4: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
2039bb8: 11 00 81 a0 sethi %hi(0x2068000), %o0 <== NOT EXECUTED
2039bbc: 40 00 33 cb call 2046ae8 <printf> <== NOT EXECUTED
2039bc0: 90 12 21 28 or %o0, 0x128, %o0 ! 2068128 <__FUNCTION__.7829+0x1038><== NOT EXECUTED
2039bc4: 30 80 00 18 b,a 2039c24 <rtems_rfs_file_open+0x17c> <== 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);
2039bc8: 90 10 00 18 mov %i0, %o0
2039bcc: 92 10 00 11 mov %l1, %o1
2039bd0: 7f ff f2 7a call 20365b8 <rtems_rfs_block_map_open>
2039bd4: 94 07 20 34 add %i4, 0x34, %o2
if (rc > 0)
2039bd8: a0 92 20 00 orcc %o0, 0, %l0
2039bdc: 04 80 00 1e ble 2039c54 <rtems_rfs_file_open+0x1ac> <== ALWAYS TAKEN
2039be0: 82 10 20 01 mov 1, %g1
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_OPEN))
2039be4: 90 10 20 08 mov 8, %o0 <== NOT EXECUTED
2039be8: 7f ff a7 99 call 2023a4c <rtems_rfs_trace> <== NOT EXECUTED
2039bec: 92 10 20 00 clr %o1 <== NOT EXECUTED
2039bf0: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
2039bf4: 22 80 00 0a be,a 2039c1c <rtems_rfs_file_open+0x174> <== NOT EXECUTED
2039bf8: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
printf ("rtems-rfs: file-open: block map open failed: %d: %s\n",
2039bfc: 40 00 3d 3a call 20490e4 <strerror> <== NOT EXECUTED
2039c00: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
2039c04: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED
2039c08: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
2039c0c: 11 00 81 a0 sethi %hi(0x2068000), %o0 <== NOT EXECUTED
2039c10: 40 00 33 b6 call 2046ae8 <printf> <== NOT EXECUTED
2039c14: 90 12 21 60 or %o0, 0x160, %o0 ! 2068160 <__FUNCTION__.7829+0x1070><== NOT EXECUTED
rc, strerror (rc));
rtems_rfs_inode_close (fs, &shared->inode);
2039c18: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
2039c1c: 40 00 08 53 call 203bd68 <rtems_rfs_inode_close> <== NOT EXECUTED
2039c20: 92 10 00 11 mov %l1, %o1 <== NOT EXECUTED
free (shared);
2039c24: 7f ff 3b f6 call 2008bfc <free> <== NOT EXECUTED
2039c28: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
2039c2c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
2039c30: 7f ff f5 db call 203739c <rtems_rfs_buffer_handle_release><== NOT EXECUTED
2039c34: 92 07 60 04 add %i5, 4, %o1 <== NOT EXECUTED
rtems_rfs_buffer_handle_close (fs, &handle->buffer);
free (handle);
2039c38: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
handle->dirty = false;
2039c3c: c0 2f 60 04 clrb [ %i5 + 4 ] <== NOT EXECUTED
handle->bnum = 0;
2039c40: c0 27 60 08 clr [ %i5 + 8 ] <== NOT EXECUTED
2039c44: 7f ff 3b ee call 2008bfc <free> <== NOT EXECUTED
2039c48: c0 27 60 0c clr [ %i5 + 0xc ] <== NOT EXECUTED
return rc;
2039c4c: 81 c7 e0 08 ret <== NOT EXECUTED
2039c50: 91 e8 00 10 restore %g0, %l0, %o0 <== NOT EXECUTED
}
shared->references = 1;
2039c54: c2 27 20 08 st %g1, [ %i4 + 8 ]
* @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);
2039c58: c2 07 20 18 ld [ %i4 + 0x18 ], %g1
RTEMS_INLINE_ROUTINE void rtems_chain_append(
rtems_chain_control *the_chain,
rtems_chain_node *the_node
)
{
_Chain_Append( the_chain, the_node );
2039c5c: 90 06 20 74 add %i0, 0x74, %o0
2039c60: c6 08 60 0c ldub [ %g1 + 0xc ], %g3
2039c64: c4 08 60 0d ldub [ %g1 + 0xd ], %g2
2039c68: 87 28 e0 18 sll %g3, 0x18, %g3
2039c6c: 85 28 a0 10 sll %g2, 0x10, %g2
2039c70: 84 10 c0 02 or %g3, %g2, %g2
2039c74: c6 08 60 0f ldub [ %g1 + 0xf ], %g3
2039c78: 92 10 00 1c mov %i4, %o1
2039c7c: 84 10 80 03 or %g2, %g3, %g2
2039c80: c6 08 60 0e ldub [ %g1 + 0xe ], %g3
2039c84: 87 28 e0 08 sll %g3, 8, %g3
2039c88: 84 10 80 03 or %g2, %g3, %g2
shared->size.count = rtems_rfs_inode_get_block_count (&shared->inode);
2039c8c: c4 27 20 84 st %g2, [ %i4 + 0x84 ]
shared->size.offset = rtems_rfs_inode_get_block_offset (&shared->inode);
2039c90: c6 08 60 0b ldub [ %g1 + 0xb ], %g3
* @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);
2039c94: c4 08 60 0a ldub [ %g1 + 0xa ], %g2
2039c98: 85 28 a0 08 sll %g2, 8, %g2
2039c9c: 84 10 c0 02 or %g3, %g2, %g2
2039ca0: c4 27 20 88 st %g2, [ %i4 + 0x88 ]
* @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);
2039ca4: c6 08 60 10 ldub [ %g1 + 0x10 ], %g3
2039ca8: c4 08 60 11 ldub [ %g1 + 0x11 ], %g2
2039cac: 87 28 e0 18 sll %g3, 0x18, %g3
2039cb0: 85 28 a0 10 sll %g2, 0x10, %g2
2039cb4: 84 10 c0 02 or %g3, %g2, %g2
2039cb8: c6 08 60 13 ldub [ %g1 + 0x13 ], %g3
2039cbc: 84 10 80 03 or %g2, %g3, %g2
2039cc0: c6 08 60 12 ldub [ %g1 + 0x12 ], %g3
2039cc4: 87 28 e0 08 sll %g3, 8, %g3
2039cc8: 84 10 80 03 or %g2, %g3, %g2
shared->atime = rtems_rfs_inode_get_atime (&shared->inode);
2039ccc: c4 27 20 8c st %g2, [ %i4 + 0x8c ]
* @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);
2039cd0: c6 08 60 14 ldub [ %g1 + 0x14 ], %g3
2039cd4: c4 08 60 15 ldub [ %g1 + 0x15 ], %g2
2039cd8: 87 28 e0 18 sll %g3, 0x18, %g3
2039cdc: 85 28 a0 10 sll %g2, 0x10, %g2
2039ce0: 84 10 c0 02 or %g3, %g2, %g2
2039ce4: c6 08 60 17 ldub [ %g1 + 0x17 ], %g3
2039ce8: 84 10 80 03 or %g2, %g3, %g2
2039cec: c6 08 60 16 ldub [ %g1 + 0x16 ], %g3
2039cf0: 87 28 e0 08 sll %g3, 8, %g3
2039cf4: 84 10 80 03 or %g2, %g3, %g2
shared->mtime = rtems_rfs_inode_get_mtime (&shared->inode);
2039cf8: c4 27 20 90 st %g2, [ %i4 + 0x90 ]
* @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);
2039cfc: c4 08 60 19 ldub [ %g1 + 0x19 ], %g2
2039d00: c6 08 60 18 ldub [ %g1 + 0x18 ], %g3
2039d04: 85 28 a0 10 sll %g2, 0x10, %g2
2039d08: 87 28 e0 18 sll %g3, 0x18, %g3
2039d0c: 86 10 c0 02 or %g3, %g2, %g3
2039d10: c4 08 60 1b ldub [ %g1 + 0x1b ], %g2
2039d14: 86 10 c0 02 or %g3, %g2, %g3
2039d18: c4 08 60 1a ldub [ %g1 + 0x1a ], %g2
shared->ctime = rtems_rfs_inode_get_ctime (&shared->inode);
shared->fs = fs;
2039d1c: f0 27 20 98 st %i0, [ %i4 + 0x98 ]
2039d20: 85 28 a0 08 sll %g2, 8, %g2
2039d24: 82 10 c0 02 or %g3, %g2, %g1
2039d28: 7f ff 51 29 call 200e1cc <_Chain_Append>
2039d2c: c2 27 20 94 st %g1, [ %i4 + 0x94 ]
rtems_chain_append (&fs->file_shares, &shared->link);
rtems_rfs_inode_unload (fs, &shared->inode, false);
2039d30: 92 10 00 11 mov %l1, %o1
2039d34: 94 10 20 00 clr %o2
2039d38: 40 00 07 d0 call 203bc78 <rtems_rfs_inode_unload>
2039d3c: 90 10 00 18 mov %i0, %o0
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_OPEN))
2039d40: 90 10 20 08 mov 8, %o0
2039d44: 7f ff a7 42 call 2023a4c <rtems_rfs_trace>
2039d48: 92 10 20 00 clr %o1
2039d4c: 80 8a 20 ff btst 0xff, %o0
2039d50: 22 80 00 07 be,a 2039d6c <rtems_rfs_file_open+0x2c4> <== ALWAYS TAKEN
2039d54: f4 27 40 00 st %i2, [ %i5 ]
printf ("rtems-rfs: file-open: ino=%" PRId32 " share created\n", ino);
2039d58: 11 00 81 a0 sethi %hi(0x2068000), %o0 <== NOT EXECUTED
2039d5c: 90 12 21 98 or %o0, 0x198, %o0 ! 2068198 <__FUNCTION__.7829+0x10a8><== NOT EXECUTED
2039d60: 40 00 33 62 call 2046ae8 <printf> <== NOT EXECUTED
2039d64: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
}
handle->flags = oflag;
2039d68: f4 27 40 00 st %i2, [ %i5 ] <== NOT EXECUTED
handle->shared = shared;
2039d6c: f8 27 60 1c st %i4, [ %i5 + 0x1c ]
*file = handle;
2039d70: fa 26 c0 00 st %i5, [ %i3 ]
return 0;
2039d74: a0 10 20 00 clr %l0
}
2039d78: b0 10 00 10 mov %l0, %i0
2039d7c: 81 c7 e0 08 ret
2039d80: 81 e8 00 00 restore
02039650 <rtems_rfs_file_seek>:
int
rtems_rfs_file_seek (rtems_rfs_file_handle* handle,
rtems_rfs_pos pos,
rtems_rfs_pos* new_pos)
{
2039650: 9d e3 bf 98 save %sp, -104, %sp
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
2039654: 90 10 20 20 mov 0x20, %o0
2039658: 7f ff a8 fd call 2023a4c <rtems_rfs_trace>
203965c: 92 10 20 00 clr %o1
2039660: 80 8a 20 ff btst 0xff, %o0
2039664: 22 80 00 08 be,a 2039684 <rtems_rfs_file_seek+0x34> <== ALWAYS TAKEN
2039668: d2 06 20 1c ld [ %i0 + 0x1c ], %o1
printf ("rtems-rfs: file-seek: new=%" PRIu64 "\n", pos);
203966c: 11 00 81 a0 sethi %hi(0x2068000), %o0 <== NOT EXECUTED
2039670: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
2039674: 90 12 20 98 or %o0, 0x98, %o0 <== NOT EXECUTED
2039678: 40 00 35 1c call 2046ae8 <printf> <== NOT EXECUTED
203967c: 94 10 00 1a mov %i2, %o2 <== 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),
2039680: d2 06 20 1c ld [ %i0 + 0x1c ], %o1 <== NOT EXECUTED
2039684: d0 02 60 98 ld [ %o1 + 0x98 ], %o0
2039688: 7f ff f3 b6 call 2036560 <rtems_rfs_block_get_size>
203968c: 92 02 60 84 add %o1, 0x84, %o1
2039690: 80 a6 40 08 cmp %i1, %o0
2039694: 18 80 00 23 bgu 2039720 <rtems_rfs_file_seek+0xd0> <== NEVER TAKEN
2039698: 01 00 00 00 nop
203969c: 32 80 00 06 bne,a 20396b4 <rtems_rfs_file_seek+0x64> <== NEVER TAKEN
20396a0: c2 06 20 1c ld [ %i0 + 0x1c ], %g1 <== NOT EXECUTED
20396a4: 80 a6 80 09 cmp %i2, %o1
20396a8: 18 80 00 1e bgu 2039720 <rtems_rfs_file_seek+0xd0>
20396ac: 01 00 00 00 nop
handle->shared))
{
rtems_rfs_file_set_bpos (handle, pos);
20396b0: c2 06 20 1c ld [ %i0 + 0x1c ], %g1
20396b4: b8 06 20 10 add %i0, 0x10, %i4
20396b8: d0 00 60 98 ld [ %g1 + 0x98 ], %o0
20396bc: 92 10 00 19 mov %i1, %o1
20396c0: 94 10 00 1a mov %i2, %o2
20396c4: 7f ff f3 77 call 20364a0 <rtems_rfs_block_get_bpos>
20396c8: 96 10 00 1c mov %i4, %o3
/*
* If the file has a block check if it maps to the current position and it
* does not release it. That will force us to get the block at the new
* position when the I/O starts.
*/
if (rtems_rfs_buffer_handle_has_block (&handle->buffer))
20396cc: c2 06 20 0c ld [ %i0 + 0xc ], %g1
20396d0: 80 a0 60 00 cmp %g1, 0
20396d4: 02 80 00 18 be 2039734 <rtems_rfs_file_seek+0xe4>
20396d8: 94 10 00 1c mov %i4, %o2
{
rtems_rfs_buffer_block block;
int rc;
rc = rtems_rfs_block_map_find (rtems_rfs_file_fs (handle),
20396dc: d2 06 20 1c ld [ %i0 + 0x1c ], %o1
20396e0: d0 02 60 98 ld [ %o1 + 0x98 ], %o0
20396e4: 96 07 bf fc add %fp, -4, %o3
20396e8: 7f ff f4 89 call 203690c <rtems_rfs_block_map_find>
20396ec: 92 02 60 34 add %o1, 0x34, %o1
rtems_rfs_file_map (handle),
rtems_rfs_file_bpos (handle),
&block);
if (rc > 0)
20396f0: 80 a2 20 00 cmp %o0, 0
20396f4: 14 80 00 13 bg 2039740 <rtems_rfs_file_seek+0xf0> <== NEVER TAKEN
20396f8: c2 07 bf fc ld [ %fp + -4 ], %g1
return rc;
if (rtems_rfs_buffer_bnum (&handle->buffer) != block)
20396fc: c4 06 20 08 ld [ %i0 + 8 ], %g2
2039700: 80 a0 80 01 cmp %g2, %g1
2039704: 02 80 00 0c be 2039734 <rtems_rfs_file_seek+0xe4> <== ALWAYS TAKEN
2039708: 92 06 20 04 add %i0, 4, %o1
{
rc = rtems_rfs_buffer_handle_release (rtems_rfs_file_fs (handle),
203970c: c2 06 20 1c ld [ %i0 + 0x1c ], %g1 <== NOT EXECUTED
2039710: 7f ff f7 23 call 203739c <rtems_rfs_buffer_handle_release><== NOT EXECUTED
2039714: d0 00 60 98 ld [ %g1 + 0x98 ], %o0 <== NOT EXECUTED
/*
* The seek is outside the current file so release any buffer. A write will
* extend the file.
*/
int rc = rtems_rfs_file_io_release (handle);
if (rc > 0)
2039718: 10 80 00 05 b 203972c <rtems_rfs_file_seek+0xdc> <== NOT EXECUTED
203971c: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
{
/*
* The seek is outside the current file so release any buffer. A write will
* extend the file.
*/
int rc = rtems_rfs_file_io_release (handle);
2039720: 7f ff ff c0 call 2039620 <rtems_rfs_file_io_release>
2039724: 90 10 00 18 mov %i0, %o0
if (rc > 0)
2039728: 80 a2 20 00 cmp %o0, 0
203972c: 14 80 00 05 bg 2039740 <rtems_rfs_file_seek+0xf0> <== NEVER TAKEN
2039730: 01 00 00 00 nop
return rc;
}
*new_pos = pos;
2039734: f2 26 c0 00 st %i1, [ %i3 ]
2039738: f4 26 e0 04 st %i2, [ %i3 + 4 ]
return 0;
203973c: 90 10 20 00 clr %o0
}
2039740: 81 c7 e0 08 ret
2039744: 91 e8 00 08 restore %g0, %o0, %o0
02039748 <rtems_rfs_file_set_size>:
int
rtems_rfs_file_set_size (rtems_rfs_file_handle* handle,
rtems_rfs_pos new_size)
{
2039748: 9d e3 bf 90 save %sp, -112, %sp
203974c: ba 10 00 1a mov %i2, %i5
rtems_rfs_block_map* map = rtems_rfs_file_map (handle);
2039750: f4 06 20 1c ld [ %i0 + 0x1c ], %i2
}
int
rtems_rfs_file_set_size (rtems_rfs_file_handle* handle,
rtems_rfs_pos new_size)
{
2039754: b6 10 00 18 mov %i0, %i3
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))
2039758: 90 10 20 20 mov 0x20, %o0
203975c: 92 10 20 00 clr %o1
2039760: 7f ff a8 bb call 2023a4c <rtems_rfs_trace>
2039764: b8 10 00 19 mov %i1, %i4
2039768: 80 8a 20 ff btst 0xff, %o0
203976c: 02 80 00 07 be 2039788 <rtems_rfs_file_set_size+0x40> <== ALWAYS TAKEN
2039770: b0 06 a0 34 add %i2, 0x34, %i0
printf ("rtems-rfs: file-set-size: size=%" PRIu64 "\n", new_size);
2039774: 11 00 81 a0 sethi %hi(0x2068000), %o0 <== NOT EXECUTED
2039778: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
203977c: 90 12 20 b8 or %o0, 0xb8, %o0 <== NOT EXECUTED
2039780: 40 00 34 da call 2046ae8 <printf> <== NOT EXECUTED
2039784: 94 10 00 1d mov %i5, %o2 <== NOT EXECUTED
size = rtems_rfs_file_size (handle);
2039788: d2 06 e0 1c ld [ %i3 + 0x1c ], %o1
203978c: d0 02 60 98 ld [ %o1 + 0x98 ], %o0
2039790: 7f ff f3 74 call 2036560 <rtems_rfs_block_get_size>
2039794: 92 02 60 84 add %o1, 0x84, %o1
/*
* If the file is same size do nothing else grow or shrink it ?
*
* If the file does not change size do not update the times.
*/
if (size != new_size)
2039798: 80 a2 00 1c cmp %o0, %i4
203979c: 12 80 00 07 bne 20397b8 <rtems_rfs_file_set_size+0x70> <== NEVER TAKEN
20397a0: 80 97 00 1d orcc %i4, %i5, %g0
20397a4: 80 a2 40 1d cmp %o1, %i5
20397a8: 12 80 00 04 bne 20397b8 <rtems_rfs_file_set_size+0x70>
20397ac: 80 97 00 1d orcc %i4, %i5, %g0
if (rtems_rfs_file_update_mtime (handle))
handle->shared->mtime = time (NULL);
}
return 0;
20397b0: 10 80 00 ad b 2039a64 <rtems_rfs_file_set_size+0x31c>
20397b4: 90 10 20 00 clr %o0
if (size != new_size)
{
/*
* Short cut for the common truncate on open call.
*/
if (new_size == 0)
20397b8: 12 80 00 0a bne 20397e0 <rtems_rfs_file_set_size+0x98>
20397bc: f2 06 e0 1c ld [ %i3 + 0x1c ], %i1
{
rc = rtems_rfs_block_map_free_all (rtems_rfs_file_fs (handle), map);
20397c0: d0 06 60 98 ld [ %i1 + 0x98 ], %o0
20397c4: 7f ff f6 92 call 203720c <rtems_rfs_block_map_free_all>
20397c8: 92 10 00 18 mov %i0, %o1
if (rc > 0)
20397cc: 80 a2 20 00 cmp %o0, 0
20397d0: 14 80 00 a6 bg 2039a68 <rtems_rfs_file_set_size+0x320> <== NEVER TAKEN
20397d4: b0 10 00 08 mov %o0, %i0
rtems_rfs_block_size_get_bpos (rtems_rfs_block_map_size (map),
rtems_rfs_file_bpos (handle));
}
}
handle->shared->size.count = rtems_rfs_block_map_count (map);
20397d8: 10 80 00 97 b 2039a34 <rtems_rfs_file_set_size+0x2ec>
20397dc: fa 06 e0 1c ld [ %i3 + 0x1c ], %i5
if (rc > 0)
return rc;
}
else
{
if (size < new_size)
20397e0: 80 a7 00 08 cmp %i4, %o0
20397e4: 38 80 00 09 bgu,a 2039808 <rtems_rfs_file_set_size+0xc0> <== NEVER TAKEN
20397e8: c2 06 60 98 ld [ %i1 + 0x98 ], %g1 <== NOT EXECUTED
20397ec: 80 a7 00 08 cmp %i4, %o0
20397f0: 32 80 00 58 bne,a 2039950 <rtems_rfs_file_set_size+0x208><== NEVER TAKEN
20397f4: e0 06 60 98 ld [ %i1 + 0x98 ], %l0 <== NOT EXECUTED
20397f8: 80 a7 40 09 cmp %i5, %o1
20397fc: 28 80 00 55 bleu,a 2039950 <rtems_rfs_file_set_size+0x208>
2039800: e0 06 60 98 ld [ %i1 + 0x98 ], %l0
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));
2039804: c2 06 60 98 ld [ %i1 + 0x98 ], %g1
*/
rtems_rfs_pos count;
uint32_t length;
bool read_block;
count = new_size - size;
2039808: ba a7 40 09 subcc %i5, %o1, %i5
length = rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
203980c: f2 00 60 08 ld [ %g1 + 8 ], %i1
*/
rtems_rfs_pos count;
uint32_t length;
bool read_block;
count = new_size - size;
2039810: b8 67 00 08 subx %i4, %o0, %i4
length = rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
read_block = false;
2039814: a2 10 20 00 clr %l1
2039818: a0 10 20 01 mov 1, %l0
while (count)
203981c: 10 80 00 48 b 203993c <rtems_rfs_file_set_size+0x1f4>
2039820: a4 06 e0 04 add %i3, 4, %l2
/*
* 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);
2039824: c2 06 a0 3c ld [ %i2 + 0x3c ], %g1
2039828: c4 27 bf f8 st %g2, [ %fp + -8 ]
203982c: c2 27 bf f4 st %g1, [ %fp + -12 ]
2039830: 80 a0 a0 00 cmp %g2, 0
2039834: 02 80 00 04 be 2039844 <rtems_rfs_file_set_size+0xfc>
2039838: c0 27 bf fc clr [ %fp + -4 ]
203983c: 82 00 7f ff add %g1, -1, %g1
2039840: c2 27 bf f4 st %g1, [ %fp + -12 ]
rc = rtems_rfs_block_map_find (rtems_rfs_file_fs (handle),
2039844: c2 06 e0 1c ld [ %i3 + 0x1c ], %g1
2039848: 92 10 00 18 mov %i0, %o1
203984c: d0 00 60 98 ld [ %g1 + 0x98 ], %o0
2039850: 94 07 bf f4 add %fp, -12, %o2
2039854: 7f ff f4 2e call 203690c <rtems_rfs_block_map_find>
2039858: 96 07 bf f0 add %fp, -16, %o3
map, &bpos, &block);
if (rc > 0)
203985c: 80 a2 20 00 cmp %o0, 0
2039860: 14 80 00 0b bg 203988c <rtems_rfs_file_set_size+0x144>
2039864: 80 a2 20 06 cmp %o0, 6
map, 1, &block);
if (rc > 0)
return rc;
}
if (count < (length - bpos.boff))
2039868: c2 07 bf f8 ld [ %fp + -8 ], %g1
203986c: 80 a7 20 00 cmp %i4, 0
2039870: 12 80 00 17 bne 20398cc <rtems_rfs_file_set_size+0x184> <== NEVER TAKEN
2039874: 84 26 40 01 sub %i1, %g1, %g2
2039878: 80 a0 80 1d cmp %g2, %i5
203987c: 38 80 00 10 bgu,a 20398bc <rtems_rfs_file_set_size+0x174>
2039880: b2 00 40 1d add %g1, %i5, %i1
*/
static inline void
rtems_rfs_block_map_set_size_offset (rtems_rfs_block_map* map,
rtems_rfs_block_off offset)
{
map->size.offset = offset;
2039884: 10 80 00 13 b 20398d0 <rtems_rfs_file_set_size+0x188>
2039888: c0 26 a0 40 clr [ %i2 + 0x40 ]
if (rc > 0)
{
/*
* Have we reached the EOF ?
*/
if (rc != ENXIO)
203988c: 12 80 00 76 bne 2039a64 <rtems_rfs_file_set_size+0x31c> <== NEVER TAKEN
2039890: 92 10 00 18 mov %i0, %o1
return rc;
rc = rtems_rfs_block_map_grow (rtems_rfs_file_fs (handle),
2039894: c2 06 e0 1c ld [ %i3 + 0x1c ], %g1
2039898: d0 00 60 98 ld [ %g1 + 0x98 ], %o0
203989c: 94 10 20 01 mov 1, %o2
20398a0: 7f ff f4 a1 call 2036b24 <rtems_rfs_block_map_grow>
20398a4: 96 07 bf f0 add %fp, -16, %o3
map, 1, &block);
if (rc > 0)
20398a8: 80 a2 20 00 cmp %o0, 0
20398ac: 04 bf ff f0 ble 203986c <rtems_rfs_file_set_size+0x124> <== ALWAYS TAKEN
20398b0: c2 07 bf f8 ld [ %fp + -8 ], %g1
if (rtems_rfs_file_update_mtime (handle))
handle->shared->mtime = time (NULL);
}
return 0;
}
20398b4: 81 c7 e0 08 ret <== NOT EXECUTED
20398b8: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED
map->dirty = true;
20398bc: e0 2e a0 34 stb %l0, [ %i2 + 0x34 ]
*/
static inline void
rtems_rfs_block_map_set_size_offset (rtems_rfs_block_map* map,
rtems_rfs_block_off offset)
{
map->size.offset = offset;
20398c0: f2 26 a0 40 st %i1, [ %i2 + 0x40 ]
}
if (count < (length - bpos.boff))
{
length = count + bpos.boff;
read_block = true;
20398c4: 10 80 00 04 b 20398d4 <rtems_rfs_file_set_size+0x18c>
20398c8: a2 10 20 01 mov 1, %l1
20398cc: c0 26 a0 40 clr [ %i2 + 0x40 ] <== NOT EXECUTED
map->dirty = true;
20398d0: e0 2e a0 34 stb %l0, [ %i2 + 0x34 ]
}
/*
* Only read the block if the length is not the block size.
*/
rc = rtems_rfs_buffer_handle_request (rtems_rfs_file_fs (handle),
20398d4: c2 06 e0 1c ld [ %i3 + 0x1c ], %g1
20398d8: d4 07 bf f0 ld [ %fp + -16 ], %o2
20398dc: d0 00 60 98 ld [ %g1 + 0x98 ], %o0
20398e0: 92 10 00 12 mov %l2, %o1
20398e4: 7f ff f7 22 call 203756c <rtems_rfs_buffer_handle_request>
20398e8: 96 0c 60 01 and %l1, 1, %o3
rtems_rfs_file_buffer (handle),
block, read_block);
if (rc > 0)
20398ec: 80 a2 20 00 cmp %o0, 0
20398f0: 14 80 00 5d bg 2039a64 <rtems_rfs_file_set_size+0x31c> <== NEVER TAKEN
20398f4: d4 07 bf f8 ld [ %fp + -8 ], %o2
return rc;
dst = rtems_rfs_buffer_data (&handle->buffer);
20398f8: c2 06 e0 0c ld [ %i3 + 0xc ], %g1
memset (dst + bpos.boff, 0, length - bpos.boff);
20398fc: d0 00 60 1c ld [ %g1 + 0x1c ], %o0
2039900: 92 10 20 00 clr %o1
2039904: 90 02 00 0a add %o0, %o2, %o0
2039908: 40 00 30 07 call 2045924 <memset>
203990c: 94 26 40 0a sub %i1, %o2, %o2
rtems_rfs_buffer_mark_dirty (rtems_rfs_file_buffer (handle));
rc = rtems_rfs_buffer_handle_release (rtems_rfs_file_fs (handle),
2039910: c2 06 e0 1c ld [ %i3 + 0x1c ], %g1
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));
2039914: e0 2e e0 04 stb %l0, [ %i3 + 4 ]
rc = rtems_rfs_buffer_handle_release (rtems_rfs_file_fs (handle),
2039918: d0 00 60 98 ld [ %g1 + 0x98 ], %o0
203991c: 7f ff f6 a0 call 203739c <rtems_rfs_buffer_handle_release>
2039920: 92 10 00 12 mov %l2, %o1
rtems_rfs_file_buffer (handle));
if (rc > 0)
2039924: 80 a2 20 00 cmp %o0, 0
2039928: 14 80 00 4f bg 2039a64 <rtems_rfs_file_set_size+0x31c> <== NEVER TAKEN
203992c: c2 07 bf f8 ld [ %fp + -8 ], %g1
return rc;
count -= length - bpos.boff;
2039930: 82 26 40 01 sub %i1, %g1, %g1
2039934: ba a7 40 01 subcc %i5, %g1, %i5
2039938: b8 67 20 00 subx %i4, 0, %i4
count = new_size - size;
length = rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
read_block = false;
while (count)
203993c: 80 97 00 1d orcc %i4, %i5, %g0
2039940: 32 bf ff b9 bne,a 2039824 <rtems_rfs_file_set_size+0xdc>
2039944: c4 06 a0 40 ld [ %i2 + 0x40 ], %g2
rtems_rfs_block_size_get_bpos (rtems_rfs_block_map_size (map),
rtems_rfs_file_bpos (handle));
}
}
handle->shared->size.count = rtems_rfs_block_map_count (map);
2039948: 10 80 00 3b b 2039a34 <rtems_rfs_file_set_size+0x2ec>
203994c: fa 06 e0 1c ld [ %i3 + 0x1c ], %i5
rtems_rfs_block_no blocks;
uint32_t offset;
blocks =
rtems_rfs_block_map_count (map) -
(((new_size - 1) /
2039950: 92 87 7f ff addcc %i5, -1, %o1
2039954: e2 04 20 08 ld [ %l0 + 8 ], %l1
2039958: 90 47 3f ff addx %i4, -1, %o0
203995c: 94 10 20 00 clr %o2
2039960: 40 00 8a c8 call 205c480 <__udivdi3>
2039964: 96 10 00 11 mov %l1, %o3
* Shrink
*/
rtems_rfs_block_no blocks;
uint32_t offset;
blocks =
2039968: c2 06 a0 3c ld [ %i2 + 0x3c ], %g1
203996c: 92 38 00 09 xnor %g0, %o1, %o1
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));
2039970: 90 10 00 1c mov %i4, %o0
* Shrink
*/
rtems_rfs_block_no blocks;
uint32_t offset;
blocks =
2039974: b0 02 40 01 add %o1, %g1, %i0
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));
2039978: 94 10 20 00 clr %o2
203997c: 92 10 00 1d mov %i5, %o1
2039980: 40 00 8b 94 call 205c7d0 <__umoddi3>
2039984: 96 10 00 11 mov %l1, %o3
if (blocks)
2039988: 80 a6 20 00 cmp %i0, 0
203998c: 12 80 00 0b bne 20399b8 <rtems_rfs_file_set_size+0x270>
2039990: ba 10 00 09 mov %o1, %i5
return rc;
}
rtems_rfs_block_map_set_size_offset (map, offset);
if (rtems_rfs_block_pos_past_end (rtems_rfs_file_bpos (handle),
2039994: c4 06 e0 10 ld [ %i3 + 0x10 ], %g2
2039998: 82 10 20 01 mov 1, %g1
*/
static inline void
rtems_rfs_block_map_set_size_offset (rtems_rfs_block_map* map,
rtems_rfs_block_off offset)
{
map->size.offset = offset;
203999c: fa 26 a0 40 st %i5, [ %i2 + 0x40 ]
map->dirty = true;
20399a0: c2 2e a0 34 stb %g1, [ %i2 + 0x34 ]
20399a4: 80 a0 a0 00 cmp %g2, 0
20399a8: 12 80 00 0d bne 20399dc <rtems_rfs_file_set_size+0x294>
20399ac: c2 06 a0 3c ld [ %i2 + 0x3c ], %g1
20399b0: 10 80 00 0f b 20399ec <rtems_rfs_file_set_size+0x2a4>
20399b4: 80 a0 80 01 cmp %g2, %g1
new_size % rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
if (blocks)
{
int rc;
rc = rtems_rfs_block_map_shrink (rtems_rfs_file_fs (handle),
20399b8: 90 10 00 10 mov %l0, %o0
20399bc: 92 06 60 34 add %i1, 0x34, %o1
20399c0: 7f ff f5 49 call 2036ee4 <rtems_rfs_block_map_shrink>
20399c4: 94 10 00 18 mov %i0, %o2
rtems_rfs_file_map (handle),
blocks);
if (rc > 0)
20399c8: 80 a2 20 00 cmp %o0, 0
20399cc: 34 80 00 27 bg,a 2039a68 <rtems_rfs_file_set_size+0x320> <== NEVER TAKEN
20399d0: b0 10 00 08 mov %o0, %i0 <== 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),
20399d4: 10 bf ff f1 b 2039998 <rtems_rfs_file_set_size+0x250>
20399d8: c4 06 e0 10 ld [ %i3 + 0x10 ], %g2
20399dc: 80 a0 60 00 cmp %g1, 0
20399e0: 22 80 00 0e be,a 2039a18 <rtems_rfs_file_set_size+0x2d0> <== NEVER TAKEN
20399e4: c2 26 e0 10 st %g1, [ %i3 + 0x10 ] <== NOT EXECUTED
20399e8: 80 a0 80 01 cmp %g2, %g1
20399ec: 3a 80 00 0b bcc,a 2039a18 <rtems_rfs_file_set_size+0x2d0><== NEVER TAKEN
20399f0: c2 26 e0 10 st %g1, [ %i3 + 0x10 ] <== NOT EXECUTED
20399f4: 86 00 7f ff add %g1, -1, %g3
20399f8: 80 a0 80 03 cmp %g2, %g3
20399fc: 32 80 00 0e bne,a 2039a34 <rtems_rfs_file_set_size+0x2ec><== NEVER TAKEN
2039a00: fa 06 e0 1c ld [ %i3 + 0x1c ], %i5 <== NOT EXECUTED
2039a04: c4 06 e0 14 ld [ %i3 + 0x14 ], %g2
2039a08: 80 a0 80 1d cmp %g2, %i5
2039a0c: 28 80 00 0a bleu,a 2039a34 <rtems_rfs_file_set_size+0x2ec>
2039a10: fa 06 e0 1c ld [ %i3 + 0x1c ], %i5
rtems_rfs_block_map_size (map)))
rtems_rfs_block_size_get_bpos (rtems_rfs_block_map_size (map),
2039a14: c2 26 e0 10 st %g1, [ %i3 + 0x10 ]
2039a18: fa 26 e0 14 st %i5, [ %i3 + 0x14 ]
2039a1c: 80 a7 60 00 cmp %i5, 0
2039a20: 02 80 00 04 be 2039a30 <rtems_rfs_file_set_size+0x2e8> <== NEVER TAKEN
2039a24: c0 26 e0 18 clr [ %i3 + 0x18 ]
2039a28: 82 00 7f ff add %g1, -1, %g1
2039a2c: c2 26 e0 10 st %g1, [ %i3 + 0x10 ]
rtems_rfs_file_bpos (handle));
}
}
handle->shared->size.count = rtems_rfs_block_map_count (map);
2039a30: fa 06 e0 1c ld [ %i3 + 0x1c ], %i5
2039a34: c2 06 a0 3c ld [ %i2 + 0x3c ], %g1
2039a38: c2 27 60 84 st %g1, [ %i5 + 0x84 ]
handle->shared->size.offset = rtems_rfs_block_map_size_offset (map);
2039a3c: c2 06 a0 40 ld [ %i2 + 0x40 ], %g1
2039a40: c2 27 60 88 st %g1, [ %i5 + 0x88 ]
if (rtems_rfs_file_update_mtime (handle))
2039a44: c2 06 c0 00 ld [ %i3 ], %g1
2039a48: 80 88 60 02 btst 2, %g1
2039a4c: 12 80 00 06 bne 2039a64 <rtems_rfs_file_set_size+0x31c> <== NEVER TAKEN
2039a50: 90 10 20 00 clr %o0
handle->shared->mtime = time (NULL);
2039a54: 40 00 54 54 call 204eba4 <time>
2039a58: 90 10 20 00 clr %o0
2039a5c: d0 27 60 90 st %o0, [ %i5 + 0x90 ]
}
return 0;
2039a60: 90 10 20 00 clr %o0
}
2039a64: b0 10 00 08 mov %o0, %i0
2039a68: 81 c7 e0 08 ret
2039a6c: 81 e8 00 00 restore
0203a6ac <rtems_rfs_format>:
return rc;
}
int
rtems_rfs_format (const char* name, const rtems_rfs_format_config* config)
{
203a6ac: 9d e3 be c0 save %sp, -320, %sp
rtems_rfs_file_system fs;
int group;
int rc;
if (config->verbose)
203a6b0: c2 0e 60 15 ldub [ %i1 + 0x15 ], %g1
203a6b4: 80 a0 60 00 cmp %g1, 0
203a6b8: 22 80 00 07 be,a 203a6d4 <rtems_rfs_format+0x28> <== ALWAYS TAKEN
203a6bc: 92 10 20 00 clr %o1
printf ("rtems-rfs: format: %s\n", name);
203a6c0: 11 00 81 a1 sethi %hi(0x2068400), %o0 <== NOT EXECUTED
203a6c4: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
203a6c8: 40 00 31 08 call 2046ae8 <printf> <== NOT EXECUTED
203a6cc: 90 12 21 20 or %o0, 0x120, %o0 <== NOT EXECUTED
memset (&fs, 0, sizeof (rtems_rfs_file_system));
203a6d0: 92 10 20 00 clr %o1 <== NOT EXECUTED
203a6d4: 94 10 20 84 mov 0x84, %o2
203a6d8: 40 00 2c 93 call 2045924 <memset>
203a6dc: 90 07 bf 7c add %fp, -132, %o0
203a6e0: 82 07 bf c4 add %fp, -60, %g1
203a6e4: c2 27 bf c0 st %g1, [ %fp + -64 ]
head->previous = NULL;
tail->previous = head;
203a6e8: 82 07 bf c0 add %fp, -64, %g1
203a6ec: c2 27 bf c8 st %g1, [ %fp + -56 ]
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
203a6f0: 82 07 bf d4 add %fp, -44, %g1
203a6f4: c2 27 bf d0 st %g1, [ %fp + -48 ]
head->previous = NULL;
tail->previous = head;
203a6f8: 82 07 bf d0 add %fp, -48, %g1
203a6fc: c2 27 bf d8 st %g1, [ %fp + -40 ]
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
203a700: 82 07 bf e4 add %fp, -28, %g1
203a704: c2 27 bf e0 st %g1, [ %fp + -32 ]
head->previous = NULL;
tail->previous = head;
203a708: 82 07 bf e0 add %fp, -32, %g1
203a70c: c2 27 bf e8 st %g1, [ %fp + -24 ]
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
203a710: 82 07 bf f4 add %fp, -12, %g1
203a714: c2 27 bf f0 st %g1, [ %fp + -16 ]
head->previous = NULL;
tail->previous = head;
203a718: 82 07 bf f0 add %fp, -16, %g1
203a71c: c2 27 bf f8 st %g1, [ %fp + -8 ]
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;
203a720: 82 10 20 05 mov 5, %g1
203a724: c2 27 bf bc st %g1, [ %fp + -68 ]
fs.release_count = 0;
fs.release_modified_count = 0;
fs.flags = RTEMS_RFS_FS_NO_LOCAL_CACHE;
203a728: 82 10 20 02 mov 2, %g1
/*
* Open the buffer interface.
*/
rc = rtems_rfs_buffer_open (name, &fs);
203a72c: 90 10 00 18 mov %i0, %o0
fs.max_held_buffers = RTEMS_RFS_FS_MAX_HELD_BUFFERS;
fs.release_count = 0;
fs.release_modified_count = 0;
fs.flags = RTEMS_RFS_FS_NO_LOCAL_CACHE;
203a730: c2 27 bf 7c st %g1, [ %fp + -132 ]
/*
* Open the buffer interface.
*/
rc = rtems_rfs_buffer_open (name, &fs);
203a734: 7f ff f4 34 call 2037804 <rtems_rfs_buffer_open>
203a738: 92 07 bf 7c add %fp, -132, %o1
if (rc > 0)
203a73c: ba 92 20 00 orcc %o0, 0, %i5
203a740: 04 80 00 08 ble 203a760 <rtems_rfs_format+0xb4> <== ALWAYS TAKEN
203a744: c2 07 bf 8c ld [ %fp + -116 ], %g1
{
printf ("rtems-rfs: format: buffer open failed: %d: %s\n",
203a748: 40 00 3a 67 call 20490e4 <strerror> <== NOT EXECUTED
203a74c: 01 00 00 00 nop <== NOT EXECUTED
203a750: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
203a754: 11 00 81 a1 sethi %hi(0x2068400), %o0 <== NOT EXECUTED
203a758: 10 80 03 0e b 203b390 <rtems_rfs_format+0xce4> <== NOT EXECUTED
203a75c: 90 12 21 38 or %o0, 0x138, %o0 ! 2068538 <__FUNCTION__.7829+0x1448><== NOT EXECUTED
}
/*
* Check the media.
*/
if (rtems_rfs_fs_media_block_size (&fs) == 0)
203a760: c2 00 60 20 ld [ %g1 + 0x20 ], %g1
203a764: 80 a0 60 00 cmp %g1, 0
203a768: 32 80 00 08 bne,a 203a788 <rtems_rfs_format+0xdc> <== ALWAYS TAKEN
203a76c: c2 06 40 00 ld [ %i1 ], %g1
{
printf ("rtems-rfs: media block is invalid: %" PRIu32 "\n",
203a770: 11 00 81 a1 sethi %hi(0x2068400), %o0 <== NOT EXECUTED
203a774: 92 10 20 00 clr %o1 <== NOT EXECUTED
203a778: 40 00 30 dc call 2046ae8 <printf> <== NOT EXECUTED
203a77c: 90 12 21 68 or %o0, 0x168, %o0 <== NOT EXECUTED
/*
* Check the configuration data.
*/
if (!rtems_rfs_check_config (&fs, config))
return -1;
203a780: 81 c7 e0 08 ret <== NOT EXECUTED
203a784: 91 e8 3f ff restore %g0, -1, %o0 <== 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;
if (!fs->block_size)
203a788: 80 a0 60 00 cmp %g1, 0
203a78c: 12 80 00 2a bne 203a834 <rtems_rfs_format+0x188>
203a790: c2 27 bf 84 st %g1, [ %fp + -124 ]
{
uint64_t total_size = rtems_rfs_fs_media_size (fs);
203a794: 7f ff fd 8f call 2039dd0 <rtems_rfs_fs_media_size>
203a798: 90 07 bf 7c add %fp, -132, %o0
if (total_size >= GIGS (1))
203a79c: 80 a2 20 00 cmp %o0, 0
203a7a0: 12 80 00 08 bne 203a7c0 <rtems_rfs_format+0x114> <== NEVER TAKEN
203a7a4: 3b 00 04 00 sethi %hi(0x100000), %i5
203a7a8: 03 00 03 ff sethi %hi(0xffc00), %g1
203a7ac: 82 10 63 ff or %g1, 0x3ff, %g1 ! fffff <PROM_START+0xfffff>
203a7b0: 80 a2 40 01 cmp %o1, %g1
203a7b4: 08 80 00 16 bleu 203a80c <rtems_rfs_format+0x160> <== ALWAYS TAKEN
203a7b8: c2 07 bf 84 ld [ %fp + -124 ], %g1
{
uint32_t gigs = (total_size + GIGS (1)) / GIGS (1);
203a7bc: 3b 00 04 00 sethi %hi(0x100000), %i5 <== NOT EXECUTED
203a7c0: 86 82 40 1d addcc %o1, %i5, %g3 <== NOT EXECUTED
203a7c4: 83 30 e0 14 srl %g3, 0x14, %g1 <== NOT EXECUTED
203a7c8: b8 10 20 00 clr %i4 <== NOT EXECUTED
int b;
for (b = 31; b > 0; b--)
if ((gigs & (1 << b)) != 0)
203a7cc: 86 10 20 01 mov 1, %g3 <== 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);
203a7d0: 84 42 00 1c addx %o0, %i4, %g2 <== NOT EXECUTED
203a7d4: 85 28 a0 0c sll %g2, 0xc, %g2 <== NOT EXECUTED
203a7d8: 84 10 80 01 or %g2, %g1, %g2 <== NOT EXECUTED
int b;
for (b = 31; b > 0; b--)
203a7dc: 82 10 20 1f mov 0x1f, %g1 <== NOT EXECUTED
if ((gigs & (1 << b)) != 0)
203a7e0: 89 28 c0 01 sll %g3, %g1, %g4 <== NOT EXECUTED
203a7e4: 80 89 00 02 btst %g4, %g2 <== NOT EXECUTED
203a7e8: 32 80 00 06 bne,a 203a800 <rtems_rfs_format+0x154> <== NOT EXECUTED
203a7ec: 84 10 20 01 mov 1, %g2 <== NOT EXECUTED
if (total_size >= GIGS (1))
{
uint32_t gigs = (total_size + GIGS (1)) / GIGS (1);
int b;
for (b = 31; b > 0; b--)
203a7f0: 82 80 7f ff addcc %g1, -1, %g1 <== NOT EXECUTED
203a7f4: 12 bf ff fc bne 203a7e4 <rtems_rfs_format+0x138> <== NOT EXECUTED
203a7f8: 89 28 c0 01 sll %g3, %g1, %g4 <== NOT EXECUTED
if ((gigs & (1 << b)) != 0)
break;
fs->block_size = 1 << b;
203a7fc: 84 10 20 01 mov 1, %g2 <== NOT EXECUTED
203a800: 83 28 80 01 sll %g2, %g1, %g1 <== NOT EXECUTED
203a804: c2 27 bf 84 st %g1, [ %fp + -124 ] <== NOT EXECUTED
}
if (fs->block_size < 512)
203a808: c2 07 bf 84 ld [ %fp + -124 ], %g1 <== NOT EXECUTED
203a80c: 80 a0 61 ff cmp %g1, 0x1ff
203a810: 18 80 00 05 bgu 203a824 <rtems_rfs_format+0x178> <== NEVER TAKEN
203a814: c4 07 bf 84 ld [ %fp + -124 ], %g2
fs->block_size = 512;
203a818: 82 10 22 00 mov 0x200, %g1
203a81c: c2 27 bf 84 st %g1, [ %fp + -124 ]
if (fs->block_size > (4 * 1024))
203a820: c4 07 bf 84 ld [ %fp + -124 ], %g2
203a824: 03 00 00 04 sethi %hi(0x1000), %g1
203a828: 80 a0 80 01 cmp %g2, %g1
203a82c: 38 80 00 02 bgu,a 203a834 <rtems_rfs_format+0x188> <== NEVER TAKEN
203a830: c2 27 bf 84 st %g1, [ %fp + -124 ] <== NOT EXECUTED
fs->block_size = (4 * 1024);
}
if ((fs->block_size % rtems_rfs_fs_media_block_size (fs)) != 0)
203a834: c2 07 bf 8c ld [ %fp + -116 ], %g1
203a838: fa 07 bf 84 ld [ %fp + -124 ], %i5
203a83c: f8 00 60 20 ld [ %g1 + 0x20 ], %i4
203a840: 90 10 00 1d mov %i5, %o0
203a844: 40 00 83 fb call 205b830 <.urem>
203a848: 92 10 00 1c mov %i4, %o1
203a84c: 80 a2 20 00 cmp %o0, 0
203a850: 22 80 00 07 be,a 203a86c <rtems_rfs_format+0x1c0> <== ALWAYS TAKEN
203a854: c2 06 60 04 ld [ %i1 + 4 ], %g1
{
printf ("block size (%zd) is not a multiple of media block size (%" PRId32 ")\n",
203a858: 11 00 81 a1 sethi %hi(0x2068400), %o0 <== NOT EXECUTED
203a85c: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
203a860: 90 12 21 90 or %o0, 0x190, %o0 <== NOT EXECUTED
203a864: 10 80 02 cc b 203b394 <rtems_rfs_format+0xce8> <== NOT EXECUTED
203a868: 94 10 00 1c mov %i4, %o2 <== NOT EXECUTED
fs->block_size, rtems_rfs_fs_media_block_size (fs));
return false;
}
fs->group_blocks = config->group_blocks;
if (!fs->group_blocks)
203a86c: 80 a0 60 00 cmp %g1, 0
203a870: 02 80 00 04 be 203a880 <rtems_rfs_format+0x1d4> <== ALWAYS TAKEN
203a874: bb 2f 60 03 sll %i5, 3, %i5
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;
203a878: 10 80 00 03 b 203a884 <rtems_rfs_format+0x1d8> <== NOT EXECUTED
203a87c: c2 27 bf a4 st %g1, [ %fp + -92 ] <== NOT EXECUTED
{
/*
* 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);
203a880: fa 27 bf a4 st %i5, [ %fp + -92 ]
}
if (fs->group_blocks > rtems_rfs_bitmap_numof_bits (fs->block_size))
203a884: c2 07 bf a4 ld [ %fp + -92 ], %g1
203a888: 80 a0 40 1d cmp %g1, %i5
203a88c: 08 80 00 04 bleu 203a89c <rtems_rfs_format+0x1f0> <== ALWAYS TAKEN
203a890: 11 00 81 a1 sethi %hi(0x2068400), %o0
{
printf ("group block count is higher than bits in block\n");
203a894: 10 80 01 2f b 203ad50 <rtems_rfs_format+0x6a4> <== NOT EXECUTED
203a898: 90 12 21 d0 or %o0, 0x1d0, %o0 ! 20685d0 <__FUNCTION__.7829+0x14e0><== NOT EXECUTED
return false;
}
fs->blocks = rtems_rfs_fs_media_size (fs) / fs->block_size;
203a89c: 7f ff fd 4d call 2039dd0 <rtems_rfs_fs_media_size>
203a8a0: 90 07 bf 7c add %fp, -132, %o0
203a8a4: fa 07 bf 84 ld [ %fp + -124 ], %i5
203a8a8: 94 10 20 00 clr %o2
203a8ac: 40 00 86 f5 call 205c480 <__udivdi3>
203a8b0: 96 10 00 1d mov %i5, %o3
* 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));
203a8b4: b9 2f 60 03 sll %i5, 3, %i4
{
printf ("group block count is higher than bits in block\n");
return false;
}
fs->blocks = rtems_rfs_fs_media_size (fs) / fs->block_size;
203a8b8: d2 27 bf 80 st %o1, [ %fp + -128 ]
/*
* 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),
203a8bc: 90 10 00 09 mov %o1, %o0
{
printf ("group block count is higher than bits in block\n");
return false;
}
fs->blocks = rtems_rfs_fs_media_size (fs) / fs->block_size;
203a8c0: b6 10 00 09 mov %o1, %i3
/*
* 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),
203a8c4: 7f ff ff 6f call 203a680 <rtems_rfs_rup_quotient>
203a8c8: 92 10 00 1c mov %i4, %o1
rtems_rfs_bits_per_block (fs));
fs->group_inodes = config->group_inodes;
203a8cc: c2 06 60 08 ld [ %i1 + 8 ], %g1
/*
* 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),
203a8d0: d0 27 bf a0 st %o0, [ %fp + -96 ]
rtems_rfs_bits_per_block (fs));
fs->group_inodes = config->group_inodes;
203a8d4: c2 27 bf a8 st %g1, [ %fp + -88 ]
if (!fs->group_inodes)
203a8d8: 80 a0 60 00 cmp %g1, 0
203a8dc: 12 80 00 14 bne 203a92c <rtems_rfs_format+0x280> <== NEVER TAKEN
203a8e0: b4 10 00 08 mov %o0, %i2
int inode_overhead = RTEMS_RFS_INODE_OVERHEAD_PERCENTAGE;
/*
* The number of inodes per group is set as a percentage.
*/
if (config->inode_overhead)
203a8e4: d0 06 60 0c ld [ %i1 + 0xc ], %o0
203a8e8: 80 a2 20 00 cmp %o0, 0
203a8ec: 22 80 00 02 be,a 203a8f4 <rtems_rfs_format+0x248> <== ALWAYS TAKEN
203a8f0: 90 10 20 01 mov 1, %o0
rtems_rfs_inodes_from_percent (rtems_rfs_file_system* fs,
int percentage)
{
int blocks;
blocks = ((rtems_rfs_fs_blocks (fs) -
RTEMS_RFS_SUPERBLOCK_SIZE) * percentage) / 100;
203a8f4: 7f ff 21 5c call 2002e64 <.umul>
203a8f8: 92 06 ff ff add %i3, -1, %o1
203a8fc: 40 00 83 21 call 205b580 <.udiv>
203a900: 92 10 20 64 mov 0x64, %o1
blocks = rtems_rfs_rup_quotient (blocks, fs->group_count);
203a904: 7f ff ff 5f call 203a680 <rtems_rfs_rup_quotient>
203a908: 92 10 00 1a mov %i2, %o1
return blocks * (rtems_rfs_fs_block_size (fs) / RTEMS_RFS_INODE_SIZE);
203a90c: 92 10 20 38 mov 0x38, %o1
int percentage)
{
int blocks;
blocks = ((rtems_rfs_fs_blocks (fs) -
RTEMS_RFS_SUPERBLOCK_SIZE) * percentage) / 100;
blocks = rtems_rfs_rup_quotient (blocks, fs->group_count);
203a910: b6 10 00 08 mov %o0, %i3
return blocks * (rtems_rfs_fs_block_size (fs) / RTEMS_RFS_INODE_SIZE);
203a914: 40 00 83 1b call 205b580 <.udiv>
203a918: 90 10 00 1d mov %i5, %o0
203a91c: 92 10 00 08 mov %o0, %o1
203a920: 7f ff 21 51 call 2002e64 <.umul>
203a924: 90 10 00 1b mov %i3, %o0
* 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);
203a928: d0 27 bf a8 st %o0, [ %fp + -88 ]
}
/*
* 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;
203a92c: 90 10 00 1d mov %i5, %o0
203a930: 40 00 83 14 call 205b580 <.udiv>
203a934: 92 10 20 38 mov 0x38, %o1
203a938: ba 10 00 08 mov %o0, %i5
203a93c: d0 27 bf ac st %o0, [ %fp + -84 ]
fs->group_inodes =
rtems_rfs_rup_quotient (fs->group_inodes,
203a940: d0 07 bf a8 ld [ %fp + -88 ], %o0
203a944: 7f ff ff 4f call 203a680 <rtems_rfs_rup_quotient>
203a948: 92 10 00 1d mov %i5, %o1
fs->inodes_per_block) * fs->inodes_per_block;
203a94c: 7f ff 21 46 call 2002e64 <.umul>
203a950: 92 10 00 1d mov %i5, %o1
if (fs->group_inodes > rtems_rfs_bitmap_numof_bits (fs->block_size))
203a954: 80 a2 00 1c cmp %o0, %i4
203a958: 38 80 00 03 bgu,a 203a964 <rtems_rfs_format+0x2b8> <== NEVER TAKEN
203a95c: f8 27 bf a8 st %i4, [ %fp + -88 ] <== NOT EXECUTED
203a960: d0 27 bf a8 st %o0, [ %fp + -88 ]
fs->group_inodes = rtems_rfs_bitmap_numof_bits (fs->block_size);
fs->max_name_length = config->max_name_length;
203a964: c2 06 60 10 ld [ %i1 + 0x10 ], %g1
if (!fs->max_name_length)
203a968: 80 a0 60 00 cmp %g1, 0
203a96c: 22 80 02 90 be,a 203b3ac <rtems_rfs_format+0xd00> <== ALWAYS TAKEN
203a970: 82 10 22 00 mov 0x200, %g1
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;
203a974: 10 80 02 8f b 203b3b0 <rtems_rfs_format+0xd04> <== NOT EXECUTED
203a978: c2 27 bf 98 st %g1, [ %fp + -104 ] <== NOT EXECUTED
if (!rtems_rfs_check_config (&fs, config))
return -1;
if (config->verbose)
{
printf ("rtems-rfs: format: media size = %" PRIu64 "\n",
203a97c: 7f ff fd 15 call 2039dd0 <rtems_rfs_fs_media_size> <== NOT EXECUTED
203a980: 90 07 bf 7c add %fp, -132, %o0 <== NOT EXECUTED
203a984: 84 10 00 08 mov %o0, %g2 <== NOT EXECUTED
203a988: 86 10 00 09 mov %o1, %g3 <== NOT EXECUTED
203a98c: 11 00 81 a1 sethi %hi(0x2068400), %o0 <== NOT EXECUTED
203a990: 92 10 00 02 mov %g2, %o1 <== NOT EXECUTED
203a994: 94 10 00 03 mov %g3, %o2 <== NOT EXECUTED
203a998: 40 00 30 54 call 2046ae8 <printf> <== NOT EXECUTED
203a99c: 90 12 22 00 or %o0, 0x200, %o0 <== NOT EXECUTED
rtems_rfs_fs_media_size (&fs));
printf ("rtems-rfs: format: media blocks = %" PRIu32 "\n",
203a9a0: c2 07 bf 8c ld [ %fp + -116 ], %g1 <== NOT EXECUTED
203a9a4: 11 00 81 a1 sethi %hi(0x2068400), %o0 <== NOT EXECUTED
203a9a8: d2 00 60 1c ld [ %g1 + 0x1c ], %o1 <== NOT EXECUTED
203a9ac: 40 00 30 4f call 2046ae8 <printf> <== NOT EXECUTED
203a9b0: 90 12 22 28 or %o0, 0x228, %o0 <== NOT EXECUTED
rtems_rfs_fs_media_blocks (&fs));
printf ("rtems-rfs: format: media block size = %" PRIu32 "\n",
203a9b4: c2 07 bf 8c ld [ %fp + -116 ], %g1 <== NOT EXECUTED
203a9b8: 11 00 81 a1 sethi %hi(0x2068400), %o0 <== NOT EXECUTED
203a9bc: d2 00 60 20 ld [ %g1 + 0x20 ], %o1 <== NOT EXECUTED
203a9c0: 40 00 30 4a call 2046ae8 <printf> <== NOT EXECUTED
203a9c4: 90 12 22 50 or %o0, 0x250, %o0 <== NOT EXECUTED
rtems_rfs_fs_media_block_size (&fs));
printf ("rtems-rfs: format: size = %" PRIu64 "\n",
203a9c8: 7f ff fc f9 call 2039dac <rtems_rfs_fs_size> <== NOT EXECUTED
203a9cc: 90 07 bf 7c add %fp, -132, %o0 <== NOT EXECUTED
203a9d0: 84 10 00 08 mov %o0, %g2 <== NOT EXECUTED
203a9d4: 86 10 00 09 mov %o1, %g3 <== NOT EXECUTED
203a9d8: 11 00 81 a1 sethi %hi(0x2068400), %o0 <== NOT EXECUTED
203a9dc: 92 10 00 02 mov %g2, %o1 <== NOT EXECUTED
203a9e0: 94 10 00 03 mov %g3, %o2 <== NOT EXECUTED
203a9e4: 40 00 30 41 call 2046ae8 <printf> <== NOT EXECUTED
203a9e8: 90 12 22 80 or %o0, 0x280, %o0 <== NOT EXECUTED
rtems_rfs_fs_size (&fs));
printf ("rtems-rfs: format: blocks = %zu\n",
203a9ec: d2 07 bf 80 ld [ %fp + -128 ], %o1 <== NOT EXECUTED
203a9f0: 11 00 81 a1 sethi %hi(0x2068400), %o0 <== NOT EXECUTED
203a9f4: 40 00 30 3d call 2046ae8 <printf> <== NOT EXECUTED
203a9f8: 90 12 22 a0 or %o0, 0x2a0, %o0 ! 20686a0 <__FUNCTION__.7829+0x15b0><== NOT EXECUTED
rtems_rfs_fs_blocks (&fs));
printf ("rtems-rfs: format: block size = %zu\n",
203a9fc: d2 07 bf 84 ld [ %fp + -124 ], %o1 <== NOT EXECUTED
203aa00: 11 00 81 a1 sethi %hi(0x2068400), %o0 <== NOT EXECUTED
203aa04: 40 00 30 39 call 2046ae8 <printf> <== NOT EXECUTED
203aa08: 90 12 22 c8 or %o0, 0x2c8, %o0 ! 20686c8 <__FUNCTION__.7829+0x15d8><== NOT EXECUTED
rtems_rfs_fs_block_size (&fs));
printf ("rtems-rfs: format: bits per block = %u\n",
203aa0c: d2 07 bf 84 ld [ %fp + -124 ], %o1 <== NOT EXECUTED
203aa10: 11 00 81 a1 sethi %hi(0x2068400), %o0 <== NOT EXECUTED
203aa14: 93 2a 60 03 sll %o1, 3, %o1 <== NOT EXECUTED
203aa18: 40 00 30 34 call 2046ae8 <printf> <== NOT EXECUTED
203aa1c: 90 12 22 f0 or %o0, 0x2f0, %o0 <== NOT EXECUTED
rtems_rfs_bits_per_block (&fs));
printf ("rtems-rfs: format: inode size = %zu\n", RTEMS_RFS_INODE_SIZE);
203aa20: 92 10 20 38 mov 0x38, %o1 <== NOT EXECUTED
203aa24: 11 00 81 a1 sethi %hi(0x2068400), %o0 <== NOT EXECUTED
203aa28: 40 00 30 30 call 2046ae8 <printf> <== NOT EXECUTED
203aa2c: 90 12 23 18 or %o0, 0x318, %o0 ! 2068718 <__FUNCTION__.7829+0x1628><== NOT EXECUTED
printf ("rtems-rfs: format: inodes = %zu (%d.%d%%)\n",
203aa30: d2 07 bf a0 ld [ %fp + -96 ], %o1 <== NOT EXECUTED
fs.group_inodes * fs.group_count,
203aa34: fa 07 bf a8 ld [ %fp + -88 ], %i5 <== 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",
203aa38: 7f ff 21 0b call 2002e64 <.umul> <== NOT EXECUTED
203aa3c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
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,
rtems_rfs_fs_block_size (fs));
203aa40: f8 07 bf 84 ld [ %fp + -124 ], %i4 <== 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",
203aa44: b6 10 00 08 mov %o0, %i3 <== 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,
203aa48: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
203aa4c: 91 2f 60 03 sll %i5, 3, %o0 <== NOT EXECUTED
203aa50: bb 2f 60 06 sll %i5, 6, %i5 <== NOT EXECUTED
203aa54: 7f ff ff 0b call 203a680 <rtems_rfs_rup_quotient> <== NOT EXECUTED
203aa58: 90 27 40 08 sub %i5, %o0, %o0 <== 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))
203aa5c: c2 07 bf 80 ld [ %fp + -128 ], %g1 <== 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));
203aa60: b9 2f 20 03 sll %i4, 3, %i4 <== 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))
203aa64: 92 00 7f ff add %g1, -1, %o1 <== NOT EXECUTED
203aa68: 80 a7 00 09 cmp %i4, %o1 <== NOT EXECUTED
203aa6c: 28 80 00 02 bleu,a 203aa74 <rtems_rfs_format+0x3c8> <== NOT EXECUTED
203aa70: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
bits_per_block = rtems_rfs_fs_blocks (fs) - RTEMS_RFS_SUPERBLOCK_SIZE;
return ((blocks + 1) * 100 * 10) / bits_per_block;
203aa74: 84 02 20 01 add %o0, 1, %g2 <== NOT EXECUTED
203aa78: 87 28 a0 02 sll %g2, 2, %g3 <== NOT EXECUTED
203aa7c: 89 28 a0 07 sll %g2, 7, %g4 <== NOT EXECUTED
203aa80: 86 21 00 03 sub %g4, %g3, %g3 <== NOT EXECUTED
203aa84: 90 00 c0 02 add %g3, %g2, %o0 <== NOT EXECUTED
203aa88: 40 00 82 c0 call 205b588 <.div> <== NOT EXECUTED
203aa8c: 91 2a 20 03 sll %o0, 3, %o0 <== 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",
203aa90: 92 10 20 0a mov 0xa, %o1 <== NOT EXECUTED
203aa94: 40 00 82 bd call 205b588 <.div> <== NOT EXECUTED
203aa98: b8 10 00 08 mov %o0, %i4 <== NOT EXECUTED
203aa9c: 92 10 20 0a mov 0xa, %o1 <== NOT EXECUTED
203aaa0: ba 10 00 08 mov %o0, %i5 <== NOT EXECUTED
203aaa4: 40 00 83 65 call 205b838 <.rem> <== NOT EXECUTED
203aaa8: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
203aaac: 94 10 00 1d mov %i5, %o2 <== NOT EXECUTED
203aab0: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
203aab4: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
203aab8: 11 00 81 a1 sethi %hi(0x2068400), %o0 <== NOT EXECUTED
203aabc: 40 00 30 0b call 2046ae8 <printf> <== NOT EXECUTED
203aac0: 90 12 23 40 or %o0, 0x340, %o0 ! 2068740 <__FUNCTION__.7829+0x1650><== 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);
203aac4: d2 07 bf a0 ld [ %fp + -96 ], %o1 <== NOT EXECUTED
203aac8: 11 00 81 a1 sethi %hi(0x2068400), %o0 <== NOT EXECUTED
203aacc: 40 00 30 07 call 2046ae8 <printf> <== NOT EXECUTED
203aad0: 90 12 23 70 or %o0, 0x370, %o0 ! 2068770 <__FUNCTION__.7829+0x1680><== NOT EXECUTED
printf ("rtems-rfs: format: group blocks = %zu\n", fs.group_blocks);
203aad4: d2 07 bf a4 ld [ %fp + -92 ], %o1 <== NOT EXECUTED
203aad8: 11 00 81 a1 sethi %hi(0x2068400), %o0 <== NOT EXECUTED
203aadc: 40 00 30 03 call 2046ae8 <printf> <== NOT EXECUTED
203aae0: 90 12 23 90 or %o0, 0x390, %o0 ! 2068790 <__FUNCTION__.7829+0x16a0><== NOT EXECUTED
printf ("rtems-rfs: format: group inodes = %zu\n", fs.group_inodes);
203aae4: d2 07 bf a8 ld [ %fp + -88 ], %o1 <== NOT EXECUTED
203aae8: 11 00 81 a1 sethi %hi(0x2068400), %o0 <== NOT EXECUTED
203aaec: 40 00 2f ff call 2046ae8 <printf> <== NOT EXECUTED
203aaf0: 90 12 23 b8 or %o0, 0x3b8, %o0 ! 20687b8 <__FUNCTION__.7829+0x16c8><== NOT EXECUTED
}
rc = rtems_rfs_buffer_setblksize (&fs, rtems_rfs_fs_block_size (&fs));
203aaf4: d2 07 bf 84 ld [ %fp + -124 ], %o1 <== NOT EXECUTED
203aaf8: 7f ff f3 e3 call 2037a84 <rtems_rfs_buffer_setblksize>
203aafc: 90 07 bf 7c add %fp, -132, %o0
if (rc > 0)
203ab00: ba 92 20 00 orcc %o0, 0, %i5
203ab04: 24 80 00 08 ble,a 203ab24 <rtems_rfs_format+0x478> <== ALWAYS TAKEN
203ab08: c0 2f bf 30 clrb [ %fp + -208 ]
{
printf ("rtems-rfs: format: setting block size failed: %d: %s\n",
203ab0c: 40 00 39 76 call 20490e4 <strerror> <== NOT EXECUTED
203ab10: 01 00 00 00 nop <== NOT EXECUTED
203ab14: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
203ab18: 11 00 81 a1 sethi %hi(0x2068400), %o0 <== NOT EXECUTED
203ab1c: 10 80 02 1d b 203b390 <rtems_rfs_format+0xce4> <== NOT EXECUTED
203ab20: 90 12 23 e0 or %o0, 0x3e0, %o0 ! 20687e0 <__FUNCTION__.7829+0x16f0><== NOT EXECUTED
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
handle->bnum = 0;
203ab24: c0 27 bf 34 clr [ %fp + -204 ]
handle->buffer = NULL;
203ab28: c0 27 bf 38 clr [ %fp + -200 ]
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);
203ab2c: 90 07 bf 7c add %fp, -132, %o0
203ab30: 92 07 bf 30 add %fp, -208, %o1
203ab34: 94 10 20 00 clr %o2
203ab38: 7f ff f2 8d call 203756c <rtems_rfs_buffer_handle_request>
203ab3c: 96 10 20 00 clr %o3
if (rc > 0)
203ab40: ba 92 20 00 orcc %o0, 0, %i5
203ab44: 04 80 00 0a ble 203ab6c <rtems_rfs_format+0x4c0> <== ALWAYS TAKEN
203ab48: 92 07 bf 30 add %fp, -208, %o1
{
rtems_rfs_buffer_handle_close (fs, &handle);
203ab4c: 7f ff fe c3 call 203a658 <rtems_rfs_buffer_handle_close> <== NOT EXECUTED
203ab50: 90 07 bf 7c add %fp, -132, %o0 <== NOT EXECUTED
printf ("rtems-rfs: write-superblock: request failed: %d: %s\n",
203ab54: 40 00 39 64 call 20490e4 <strerror> <== NOT EXECUTED
203ab58: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
203ab5c: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
203ab60: 11 00 81 a2 sethi %hi(0x2068800), %o0 <== NOT EXECUTED
203ab64: 10 80 00 73 b 203ad30 <rtems_rfs_format+0x684> <== NOT EXECUTED
203ab68: 90 12 20 18 or %o0, 0x18, %o0 ! 2068818 <__FUNCTION__.7829+0x1728><== NOT EXECUTED
rc, strerror (rc));
return false;
}
sb = rtems_rfs_buffer_data (&handle);
203ab6c: c2 07 bf 38 ld [ %fp + -200 ], %g1
#define write_sb(_o, _d) rtems_rfs_write_u32(sb + (_o), _d)
memset (sb, 0xff, rtems_rfs_fs_block_size (fs));
203ab70: d4 07 bf 84 ld [ %fp + -124 ], %o2
printf ("rtems-rfs: write-superblock: request failed: %d: %s\n",
rc, strerror (rc));
return false;
}
sb = rtems_rfs_buffer_data (&handle);
203ab74: fa 00 60 1c ld [ %g1 + 0x1c ], %i5
#define write_sb(_o, _d) rtems_rfs_write_u32(sb + (_o), _d)
memset (sb, 0xff, rtems_rfs_fs_block_size (fs));
203ab78: 92 10 20 ff mov 0xff, %o1
203ab7c: 40 00 2b 6a call 2045924 <memset>
203ab80: 90 10 00 1d mov %i5, %o0
write_sb (RTEMS_RFS_SB_OFFSET_MAGIC, RTEMS_RFS_SB_MAGIC);
203ab84: 82 10 20 28 mov 0x28, %g1
203ab88: c2 2f 40 00 stb %g1, [ %i5 ]
203ab8c: 82 10 20 09 mov 9, %g1
203ab90: c2 2f 60 01 stb %g1, [ %i5 + 1 ]
203ab94: 82 10 20 20 mov 0x20, %g1
write_sb (RTEMS_RFS_SB_OFFSET_VERSION, RTEMS_RFS_VERSION);
203ab98: c0 2f 60 04 clrb [ %i5 + 4 ]
#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);
203ab9c: c2 2f 60 02 stb %g1, [ %i5 + 2 ]
write_sb (RTEMS_RFS_SB_OFFSET_VERSION, RTEMS_RFS_VERSION);
203aba0: c0 2f 60 05 clrb [ %i5 + 5 ]
203aba4: c0 2f 60 06 clrb [ %i5 + 6 ]
203aba8: c0 2f 60 07 clrb [ %i5 + 7 ]
#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);
203abac: 84 10 20 01 mov 1, %g2
203abb0: c4 2f 60 03 stb %g2, [ %i5 + 3 ]
write_sb (RTEMS_RFS_SB_OFFSET_VERSION, RTEMS_RFS_VERSION);
write_sb (RTEMS_RFS_SB_OFFSET_BLOCKS, rtems_rfs_fs_blocks (fs));
203abb4: c2 07 bf 80 ld [ %fp + -128 ], %g1
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);
203abb8: 92 07 bf 30 add %fp, -208, %o1
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));
203abbc: 87 30 60 18 srl %g1, 0x18, %g3
203abc0: c6 2f 60 0c stb %g3, [ %i5 + 0xc ]
203abc4: 87 30 60 10 srl %g1, 0x10, %g3
203abc8: c2 2f 60 0f stb %g1, [ %i5 + 0xf ]
203abcc: c6 2f 60 0d stb %g3, [ %i5 + 0xd ]
203abd0: 87 30 60 08 srl %g1, 8, %g3
write_sb (RTEMS_RFS_SB_OFFSET_BLOCK_SIZE, rtems_rfs_fs_block_size (fs));
203abd4: c2 0f bf 84 ldub [ %fp + -124 ], %g1
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));
203abd8: c6 2f 60 0e stb %g3, [ %i5 + 0xe ]
write_sb (RTEMS_RFS_SB_OFFSET_BLOCK_SIZE, rtems_rfs_fs_block_size (fs));
203abdc: c2 2f 60 08 stb %g1, [ %i5 + 8 ]
203abe0: c2 17 bf 84 lduh [ %fp + -124 ], %g1
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);
203abe4: 90 07 bf 7c add %fp, -132, %o0
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));
write_sb (RTEMS_RFS_SB_OFFSET_BLOCK_SIZE, rtems_rfs_fs_block_size (fs));
203abe8: c2 2f 60 09 stb %g1, [ %i5 + 9 ]
203abec: c2 07 bf 84 ld [ %fp + -124 ], %g1
203abf0: 83 30 60 08 srl %g1, 8, %g1
203abf4: c2 2f 60 0a stb %g1, [ %i5 + 0xa ]
203abf8: c2 07 bf 84 ld [ %fp + -124 ], %g1
203abfc: c2 2f 60 0b stb %g1, [ %i5 + 0xb ]
write_sb (RTEMS_RFS_SB_OFFSET_BAD_BLOCKS, fs->bad_blocks);
203ac00: c2 0f bf 94 ldub [ %fp + -108 ], %g1
203ac04: c2 2f 60 10 stb %g1, [ %i5 + 0x10 ]
203ac08: c2 17 bf 94 lduh [ %fp + -108 ], %g1
203ac0c: c2 2f 60 11 stb %g1, [ %i5 + 0x11 ]
203ac10: c2 07 bf 94 ld [ %fp + -108 ], %g1
203ac14: 83 30 60 08 srl %g1, 8, %g1
203ac18: c2 2f 60 12 stb %g1, [ %i5 + 0x12 ]
203ac1c: c2 07 bf 94 ld [ %fp + -108 ], %g1
203ac20: c2 2f 60 13 stb %g1, [ %i5 + 0x13 ]
write_sb (RTEMS_RFS_SB_OFFSET_MAX_NAME_LENGTH, fs->max_name_length);
203ac24: c2 0f bf 98 ldub [ %fp + -104 ], %g1
203ac28: c2 2f 60 14 stb %g1, [ %i5 + 0x14 ]
203ac2c: c2 17 bf 98 lduh [ %fp + -104 ], %g1
203ac30: c2 2f 60 15 stb %g1, [ %i5 + 0x15 ]
203ac34: c2 07 bf 98 ld [ %fp + -104 ], %g1
203ac38: 83 30 60 08 srl %g1, 8, %g1
203ac3c: c2 2f 60 16 stb %g1, [ %i5 + 0x16 ]
203ac40: c2 07 bf 98 ld [ %fp + -104 ], %g1
203ac44: c2 2f 60 17 stb %g1, [ %i5 + 0x17 ]
write_sb (RTEMS_RFS_SB_OFFSET_GROUPS, fs->group_count);
203ac48: c2 0f bf a0 ldub [ %fp + -96 ], %g1
203ac4c: c2 2f 60 18 stb %g1, [ %i5 + 0x18 ]
203ac50: c2 17 bf a0 lduh [ %fp + -96 ], %g1
203ac54: c2 2f 60 19 stb %g1, [ %i5 + 0x19 ]
203ac58: c2 07 bf a0 ld [ %fp + -96 ], %g1
203ac5c: 83 30 60 08 srl %g1, 8, %g1
203ac60: c2 2f 60 1a stb %g1, [ %i5 + 0x1a ]
203ac64: c2 07 bf a0 ld [ %fp + -96 ], %g1
203ac68: c2 2f 60 1b stb %g1, [ %i5 + 0x1b ]
write_sb (RTEMS_RFS_SB_OFFSET_GROUP_BLOCKS, fs->group_blocks);
203ac6c: c2 0f bf a4 ldub [ %fp + -92 ], %g1
203ac70: c2 2f 60 1c stb %g1, [ %i5 + 0x1c ]
203ac74: c2 17 bf a4 lduh [ %fp + -92 ], %g1
203ac78: c2 2f 60 1d stb %g1, [ %i5 + 0x1d ]
203ac7c: c2 07 bf a4 ld [ %fp + -92 ], %g1
203ac80: 83 30 60 08 srl %g1, 8, %g1
203ac84: c2 2f 60 1e stb %g1, [ %i5 + 0x1e ]
203ac88: c2 07 bf a4 ld [ %fp + -92 ], %g1
203ac8c: c2 2f 60 1f stb %g1, [ %i5 + 0x1f ]
write_sb (RTEMS_RFS_SB_OFFSET_GROUP_INODES, fs->group_inodes);
203ac90: c2 0f bf a8 ldub [ %fp + -88 ], %g1
203ac94: c2 2f 60 20 stb %g1, [ %i5 + 0x20 ]
203ac98: c2 17 bf a8 lduh [ %fp + -88 ], %g1
203ac9c: c2 2f 60 21 stb %g1, [ %i5 + 0x21 ]
203aca0: c2 07 bf a8 ld [ %fp + -88 ], %g1
203aca4: 83 30 60 08 srl %g1, 8, %g1
203aca8: c2 2f 60 22 stb %g1, [ %i5 + 0x22 ]
203acac: c2 07 bf a8 ld [ %fp + -88 ], %g1
write_sb (RTEMS_RFS_SB_OFFSET_INODE_SIZE, RTEMS_RFS_INODE_SIZE);
203acb0: c0 2f 60 24 clrb [ %i5 + 0x24 ]
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);
203acb4: c2 2f 60 23 stb %g1, [ %i5 + 0x23 ]
write_sb (RTEMS_RFS_SB_OFFSET_INODE_SIZE, RTEMS_RFS_INODE_SIZE);
203acb8: c0 2f 60 25 clrb [ %i5 + 0x25 ]
203acbc: c0 2f 60 26 clrb [ %i5 + 0x26 ]
203acc0: 82 10 20 38 mov 0x38, %g1
203acc4: c2 2f 60 27 stb %g1, [ %i5 + 0x27 ]
rtems_rfs_buffer_mark_dirty (&handle);
rc = rtems_rfs_buffer_handle_release (fs, &handle);
203acc8: 7f ff f1 b5 call 203739c <rtems_rfs_buffer_handle_release>
203accc: c4 2f bf 30 stb %g2, [ %fp + -208 ]
if (rc > 0)
{
rtems_rfs_buffer_handle_close (fs, &handle);
203acd0: 92 07 bf 30 add %fp, -208, %o1
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);
203acd4: ba 10 00 08 mov %o0, %i5
if (rc > 0)
203acd8: 80 a7 60 00 cmp %i5, 0
203acdc: 04 80 00 0a ble 203ad04 <rtems_rfs_format+0x658> <== ALWAYS TAKEN
203ace0: 90 07 bf 7c add %fp, -132, %o0
{
rtems_rfs_buffer_handle_close (fs, &handle);
203ace4: 7f ff fe 5d call 203a658 <rtems_rfs_buffer_handle_close> <== NOT EXECUTED
203ace8: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: write-superblock: buffer release failed: %d: %s\n",
203acec: 40 00 38 fe call 20490e4 <strerror> <== NOT EXECUTED
203acf0: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
203acf4: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
203acf8: 11 00 81 a2 sethi %hi(0x2068800), %o0 <== NOT EXECUTED
203acfc: 10 80 00 0d b 203ad30 <rtems_rfs_format+0x684> <== NOT EXECUTED
203ad00: 90 12 20 50 or %o0, 0x50, %o0 ! 2068850 <__FUNCTION__.7829+0x1760><== NOT EXECUTED
rc, strerror (rc));
return false;
}
rc = rtems_rfs_buffer_handle_close (fs, &handle);
203ad04: 7f ff fe 55 call 203a658 <rtems_rfs_buffer_handle_close>
203ad08: 01 00 00 00 nop
printf ("rtems-rfs: write-superblock: buffer handle close failed: %d: %s\n",
rc, strerror (rc));
return false;
}
return true;
203ad0c: 82 10 20 01 mov 1, %g1 ! 1 <PROM_START+0x1>
rc, strerror (rc));
return false;
}
rc = rtems_rfs_buffer_handle_close (fs, &handle);
if (rc > 0)
203ad10: 80 a2 20 00 cmp %o0, 0
203ad14: 04 80 00 0a ble 203ad3c <rtems_rfs_format+0x690> <== ALWAYS TAKEN
203ad18: ba 10 00 08 mov %o0, %i5
{
printf ("rtems-rfs: write-superblock: buffer handle close failed: %d: %s\n",
203ad1c: 40 00 38 f2 call 20490e4 <strerror> <== NOT EXECUTED
203ad20: 01 00 00 00 nop <== NOT EXECUTED
203ad24: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
203ad28: 11 00 81 a2 sethi %hi(0x2068800), %o0 <== NOT EXECUTED
203ad2c: 90 12 20 90 or %o0, 0x90, %o0 ! 2068890 <__FUNCTION__.7829+0x17a0><== NOT EXECUTED
203ad30: 40 00 2f 6e call 2046ae8 <printf> <== NOT EXECUTED
203ad34: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
rc, strerror (rc));
return false;
203ad38: 82 10 20 00 clr %g1 <== NOT EXECUTED
printf ("rtems-rfs: format: setting block size failed: %d: %s\n",
rc, strerror (rc));
return -1;
}
if (!rtems_rfs_write_superblock (&fs))
203ad3c: 80 88 60 ff btst 0xff, %g1
203ad40: 12 80 00 f3 bne 203b10c <rtems_rfs_format+0xa60> <== ALWAYS TAKEN
203ad44: ba 10 20 00 clr %i5
{
printf ("rtems-rfs: format: superblock write failed\n");
203ad48: 11 00 81 a2 sethi %hi(0x2068800), %o0 <== NOT EXECUTED
203ad4c: 90 12 20 d8 or %o0, 0xd8, %o0 ! 20688d8 <__FUNCTION__.7829+0x17e8><== NOT EXECUTED
203ad50: 40 00 2f fe call 2046d48 <puts> <== NOT EXECUTED
203ad54: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
203ad58: 30 80 01 93 b,a 203b3a4 <rtems_rfs_format+0xcf8> <== NOT EXECUTED
size_t group_size;
int blocks;
int b;
int rc;
group_base = rtems_rfs_fs_block (fs, group, 0);
203ad5c: f8 07 bf a4 ld [ %fp + -92 ], %i4
203ad60: 90 10 00 1d mov %i5, %o0
203ad64: 7f ff 20 40 call 2002e64 <.umul>
203ad68: 92 10 00 1c mov %i4, %o1
if (group_base > rtems_rfs_fs_blocks (fs))
203ad6c: c2 07 bf 80 ld [ %fp + -128 ], %g1
size_t group_size;
int blocks;
int b;
int rc;
group_base = rtems_rfs_fs_block (fs, group, 0);
203ad70: a0 02 20 01 add %o0, 1, %l0
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,
203ad74: ec 0e 60 14 ldub [ %i1 + 0x14 ], %l6
int b;
int rc;
group_base = rtems_rfs_fs_block (fs, group, 0);
if (group_base > rtems_rfs_fs_blocks (fs))
203ad78: 80 a4 00 01 cmp %l0, %g1
203ad7c: 08 80 00 08 bleu 203ad9c <rtems_rfs_format+0x6f0> <== ALWAYS TAKEN
203ad80: b4 10 00 08 mov %o0, %i2
{
printf ("rtems-rfs: write-group: group %d base beyond disk limit\n",
203ad84: 11 00 81 a2 sethi %hi(0x2068800), %o0 <== NOT EXECUTED
203ad88: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
203ad8c: 40 00 2f 57 call 2046ae8 <printf> <== NOT EXECUTED
203ad90: 90 12 21 08 or %o0, 0x108, %o0 <== NOT EXECUTED
rc = rtems_rfs_buffer_handle_close (fs, &handle);
if (rc > 0)
{
printf ("\nrtems-rfs: write-group: buffer handle close failed: %d: %s\n",
rc, strerror (rc));
return false;
203ad94: 10 80 00 d9 b 203b0f8 <rtems_rfs_format+0xa4c> <== NOT EXECUTED
203ad98: 82 10 20 00 clr %g1 <== 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))
203ad9c: 84 04 00 1c add %l0, %i4, %g2
203ada0: 80 a0 80 01 cmp %g2, %g1
203ada4: 38 80 00 02 bgu,a 203adac <rtems_rfs_format+0x700> <== ALWAYS TAKEN
203ada8: b8 20 40 10 sub %g1, %l0, %i4
group_size = rtems_rfs_fs_blocks (fs) - group_base;
if (verbose)
203adac: 80 8d e0 ff btst 0xff, %l7
203adb0: 22 80 00 09 be,a 203add4 <rtems_rfs_format+0x728> <== ALWAYS TAKEN
203adb4: c0 2f bf 30 clrb [ %fp + -208 ]
printf ("\rrtems-rfs: format: group %3d: base = %" PRId32 ", size = %zd",
203adb8: 11 00 81 a2 sethi %hi(0x2068800), %o0 <== NOT EXECUTED
203adbc: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
203adc0: 90 12 21 48 or %o0, 0x148, %o0 <== NOT EXECUTED
203adc4: 94 10 00 10 mov %l0, %o2 <== NOT EXECUTED
203adc8: 40 00 2f 48 call 2046ae8 <printf> <== NOT EXECUTED
203adcc: 96 10 00 1c mov %i4, %o3 <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
203add0: c0 2f bf 30 clrb [ %fp + -208 ] <== NOT EXECUTED
handle->bnum = 0;
203add4: c0 27 bf 34 clr [ %fp + -204 ]
printf ("\nrtems-rfs: write-group: handle open failed: %d: %s\n",
rc, strerror (rc));
return false;
}
if (verbose)
203add8: 80 8d e0 ff btst 0xff, %l7
203addc: 02 80 00 05 be 203adf0 <rtems_rfs_format+0x744> <== ALWAYS TAKEN
203ade0: c0 27 bf 38 clr [ %fp + -200 ]
printf (", blocks");
203ade4: 11 00 81 a2 sethi %hi(0x2068800), %o0 <== NOT EXECUTED
203ade8: 40 00 2f 40 call 2046ae8 <printf> <== NOT EXECUTED
203adec: 90 12 21 80 or %o0, 0x180, %o0 ! 2068980 <__FUNCTION__.7829+0x1890><== NOT EXECUTED
/*
* Open the block bitmap using the new buffer.
*/
rc = rtems_rfs_bitmap_open (&bitmap, fs, &handle, group_size,
203adf0: 98 10 00 10 mov %l0, %o4
203adf4: b6 07 bf 3c add %fp, -196, %i3
203adf8: 92 07 bf 7c add %fp, -132, %o1
203adfc: 90 10 00 1b mov %i3, %o0
203ae00: 94 07 bf 30 add %fp, -208, %o2
203ae04: 40 00 1b 10 call 2041a44 <rtems_rfs_bitmap_open>
203ae08: 96 10 00 1c mov %i4, %o3
group_base + RTEMS_RFS_GROUP_BLOCK_BITMAP_BLOCK);
if (rc > 0)
203ae0c: a0 92 20 00 orcc %o0, 0, %l0
203ae10: 04 80 00 0a ble 203ae38 <rtems_rfs_format+0x78c> <== ALWAYS TAKEN
203ae14: 92 07 bf 30 add %fp, -208, %o1
{
rtems_rfs_buffer_handle_close (fs, &handle);
203ae18: 7f ff fe 10 call 203a658 <rtems_rfs_buffer_handle_close> <== NOT EXECUTED
203ae1c: 90 07 bf 7c add %fp, -132, %o0 <== NOT EXECUTED
printf ("\nrtems-rfs: write-group: group %3d: open block bitmap failed: %d: %s\n",
203ae20: 40 00 38 b1 call 20490e4 <strerror> <== NOT EXECUTED
203ae24: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
203ae28: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
203ae2c: 11 00 81 a2 sethi %hi(0x2068800), %o0 <== NOT EXECUTED
203ae30: 10 80 00 17 b 203ae8c <rtems_rfs_format+0x7e0> <== NOT EXECUTED
203ae34: 90 12 21 90 or %o0, 0x190, %o0 ! 2068990 <__FUNCTION__.7829+0x18a0><== 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));
203ae38: c2 07 bf 38 ld [ %fp + -200 ], %g1
203ae3c: d4 07 bf 84 ld [ %fp + -124 ], %o2
203ae40: d0 00 60 1c ld [ %g1 + 0x1c ], %o0
203ae44: 40 00 2a b8 call 2045924 <memset>
203ae48: 92 10 20 ff mov 0xff, %o1
/*
* Clear the bitmap.
*/
rc = rtems_rfs_bitmap_map_clear_all (&bitmap);
203ae4c: 40 00 1a 57 call 20417a8 <rtems_rfs_bitmap_map_clear_all>
203ae50: 90 10 00 1b mov %i3, %o0
203ae54: a0 10 00 08 mov %o0, %l0
if (rc > 0)
203ae58: 80 a4 20 00 cmp %l0, 0
203ae5c: 04 80 00 0f ble 203ae98 <rtems_rfs_format+0x7ec> <== ALWAYS TAKEN
203ae60: 90 10 00 1b mov %i3, %o0
{
rtems_rfs_bitmap_close (&bitmap);
203ae64: 40 00 1b 09 call 2041a88 <rtems_rfs_bitmap_close> <== NOT EXECUTED
203ae68: 01 00 00 00 nop <== NOT EXECUTED
rtems_rfs_buffer_handle_close (fs, &handle);
203ae6c: 92 07 bf 30 add %fp, -208, %o1 <== NOT EXECUTED
203ae70: 7f ff fd fa call 203a658 <rtems_rfs_buffer_handle_close> <== NOT EXECUTED
203ae74: 90 07 bf 7c add %fp, -132, %o0 <== NOT EXECUTED
printf ("\nrtems-rfs: write-group: group %3d: block bitmap clear all failed: %d: %s\n",
203ae78: 40 00 38 9b call 20490e4 <strerror> <== NOT EXECUTED
203ae7c: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
203ae80: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
203ae84: 11 00 81 a2 sethi %hi(0x2068800), %o0 <== NOT EXECUTED
203ae88: 90 12 21 d8 or %o0, 0x1d8, %o0 ! 20689d8 <__FUNCTION__.7829+0x18e8><== NOT EXECUTED
203ae8c: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
203ae90: 10 80 00 5e b 203b008 <rtems_rfs_format+0x95c> <== NOT EXECUTED
203ae94: 94 10 00 10 mov %l0, %o2 <== NOT EXECUTED
}
/*
* Forced allocation of the block bitmap.
*/
rtems_rfs_bitmap_map_set (&bitmap, RTEMS_RFS_GROUP_BLOCK_BITMAP_BLOCK);
203ae98: 40 00 19 c0 call 2041598 <rtems_rfs_bitmap_map_set>
203ae9c: 92 10 20 00 clr %o1
/*
* Forced allocation of the inode bitmap.
*/
rtems_rfs_bitmap_map_set (&bitmap, RTEMS_RFS_GROUP_INODE_BITMAP_BLOCK);
203aea0: 92 10 20 01 mov 1, %o1
203aea4: 40 00 19 bd call 2041598 <rtems_rfs_bitmap_map_set>
203aea8: 90 10 00 1b mov %i3, %o0
/*
* Determine the number of inodes blocks in the group.
*/
blocks = rtems_rfs_rup_quotient (fs->group_inodes, fs->inodes_per_block);
203aeac: d0 07 bf a8 ld [ %fp + -88 ], %o0
203aeb0: d2 07 bf ac ld [ %fp + -84 ], %o1
203aeb4: 7f ff fd f3 call 203a680 <rtems_rfs_rup_quotient>
203aeb8: a2 10 20 00 clr %l1
203aebc: 10 80 00 05 b 203aed0 <rtems_rfs_format+0x824>
203aec0: a0 10 00 08 mov %o0, %l0
/*
* 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);
203aec4: 92 04 60 02 add %l1, 2, %o1
203aec8: 40 00 19 b4 call 2041598 <rtems_rfs_bitmap_map_set>
203aecc: a2 04 60 01 inc %l1
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++)
203aed0: 80 a4 40 10 cmp %l1, %l0
203aed4: 06 bf ff fc bl 203aec4 <rtems_rfs_format+0x818>
203aed8: 90 10 00 1b mov %i3, %o0
rtems_rfs_bitmap_map_set (&bitmap, b + RTEMS_RFS_GROUP_INODE_BLOCK);
/*
* Close the block bitmap.
*/
rc = rtems_rfs_bitmap_close (&bitmap);
203aedc: 40 00 1a eb call 2041a88 <rtems_rfs_bitmap_close>
203aee0: 01 00 00 00 nop
if (rc > 0)
203aee4: b6 92 20 00 orcc %o0, 0, %i3
203aee8: 24 80 00 0d ble,a 203af1c <rtems_rfs_format+0x870> <== ALWAYS TAKEN
203aeec: 82 10 20 01 mov 1, %g1
{
rtems_rfs_buffer_handle_close (fs, &handle);
203aef0: 92 07 bf 30 add %fp, -208, %o1 <== NOT EXECUTED
203aef4: 7f ff fd d9 call 203a658 <rtems_rfs_buffer_handle_close> <== NOT EXECUTED
203aef8: 90 07 bf 7c add %fp, -132, %o0 <== NOT EXECUTED
printf ("\nrtems-rfs: write-group: group %3d: close block bitmap failed: %d: %s\n",
203aefc: 40 00 38 7a call 20490e4 <strerror> <== NOT EXECUTED
203af00: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
203af04: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
203af08: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
203af0c: 94 10 00 1b mov %i3, %o2 <== NOT EXECUTED
203af10: 11 00 81 a2 sethi %hi(0x2068800), %o0 <== NOT EXECUTED
203af14: 10 80 00 3d b 203b008 <rtems_rfs_format+0x95c> <== NOT EXECUTED
203af18: 90 12 22 28 or %o0, 0x228, %o0 ! 2068a28 <__FUNCTION__.7829+0x1938><== NOT EXECUTED
return false;
}
rtems_rfs_buffer_mark_dirty (&handle);
if (verbose)
203af1c: 80 8d e0 ff btst 0xff, %l7
203af20: 02 80 00 05 be 203af34 <rtems_rfs_format+0x888> <== ALWAYS TAKEN
203af24: c2 2f bf 30 stb %g1, [ %fp + -208 ]
printf (", inodes");
203af28: 11 00 81 a2 sethi %hi(0x2068800), %o0 <== NOT EXECUTED
203af2c: 40 00 2e ef call 2046ae8 <printf> <== NOT EXECUTED
203af30: 90 12 22 70 or %o0, 0x270, %o0 ! 2068a70 <__FUNCTION__.7829+0x1980><== NOT EXECUTED
/*
* Open the inode bitmap using the old buffer. Should release any changes.
*/
rc = rtems_rfs_bitmap_open (&bitmap, fs, &handle, group_size,
203af34: 96 10 00 1c mov %i4, %o3
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,
203af38: ae 07 bf 7c add %fp, -132, %l7
printf (", inodes");
/*
* Open the inode bitmap using the old buffer. Should release any changes.
*/
rc = rtems_rfs_bitmap_open (&bitmap, fs, &handle, group_size,
203af3c: b6 07 bf 30 add %fp, -208, %i3
203af40: 90 07 bf 3c add %fp, -196, %o0
203af44: 92 10 00 17 mov %l7, %o1
203af48: 94 10 00 1b mov %i3, %o2
203af4c: 40 00 1a be call 2041a44 <rtems_rfs_bitmap_open>
203af50: 98 06 a0 02 add %i2, 2, %o4
group_base + RTEMS_RFS_GROUP_INODE_BITMAP_BLOCK);
if (rc > 0)
203af54: b8 92 20 00 orcc %o0, 0, %i4
203af58: 04 80 00 09 ble 203af7c <rtems_rfs_format+0x8d0> <== ALWAYS TAKEN
203af5c: 92 10 00 1b mov %i3, %o1
{
rtems_rfs_buffer_handle_close (fs, &handle);
203af60: 7f ff fd be call 203a658 <rtems_rfs_buffer_handle_close> <== NOT EXECUTED
203af64: 90 10 00 17 mov %l7, %o0 <== NOT EXECUTED
printf ("\nrtems-rfs: write-group: group %3d: open inode bitmap failed: %d: %s\n",
203af68: 40 00 38 5f call 20490e4 <strerror> <== NOT EXECUTED
203af6c: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
203af70: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
203af74: 10 80 00 23 b 203b000 <rtems_rfs_format+0x954> <== NOT EXECUTED
203af78: 90 10 00 15 mov %l5, %o0 <== 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));
203af7c: c2 07 bf 38 ld [ %fp + -200 ], %g1
203af80: d4 07 bf 84 ld [ %fp + -124 ], %o2
203af84: d0 00 60 1c ld [ %g1 + 0x1c ], %o0
203af88: 40 00 2a 67 call 2045924 <memset>
203af8c: 92 10 20 00 clr %o1
/*
* Clear the inode bitmap.
*/
rc = rtems_rfs_bitmap_map_clear_all (&bitmap);
203af90: 40 00 1a 06 call 20417a8 <rtems_rfs_bitmap_map_clear_all>
203af94: 90 07 bf 3c add %fp, -196, %o0
203af98: b8 10 00 08 mov %o0, %i4
if (rc > 0)
203af9c: 80 a7 20 00 cmp %i4, 0
203afa0: 04 80 00 0c ble 203afd0 <rtems_rfs_format+0x924> <== ALWAYS TAKEN
203afa4: 90 07 bf 3c add %fp, -196, %o0
{
rtems_rfs_bitmap_close (&bitmap);
203afa8: 40 00 1a b8 call 2041a88 <rtems_rfs_bitmap_close> <== NOT EXECUTED
203afac: 01 00 00 00 nop <== NOT EXECUTED
rtems_rfs_buffer_handle_close (fs, &handle);
203afb0: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
203afb4: 7f ff fd a9 call 203a658 <rtems_rfs_buffer_handle_close> <== NOT EXECUTED
203afb8: 90 10 00 17 mov %l7, %o0 <== NOT EXECUTED
printf ("\nrtems-rfs: write-group: group %3d: inode bitmap" \
203afbc: 40 00 38 4a call 20490e4 <strerror> <== NOT EXECUTED
203afc0: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
203afc4: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
203afc8: 10 80 00 0e b 203b000 <rtems_rfs_format+0x954> <== NOT EXECUTED
203afcc: 90 10 00 14 mov %l4, %o0 <== NOT EXECUTED
}
/*
* Close the inode bitmap.
*/
rc = rtems_rfs_bitmap_close (&bitmap);
203afd0: 40 00 1a ae call 2041a88 <rtems_rfs_bitmap_close>
203afd4: 01 00 00 00 nop
if (rc > 0)
203afd8: b8 92 20 00 orcc %o0, 0, %i4
203afdc: 24 80 00 0f ble,a 203b018 <rtems_rfs_format+0x96c> <== ALWAYS TAKEN
203afe0: 82 10 20 01 mov 1, %g1
{
rtems_rfs_buffer_handle_close (fs, &handle);
203afe4: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
203afe8: 7f ff fd 9c call 203a658 <rtems_rfs_buffer_handle_close> <== NOT EXECUTED
203afec: 90 10 00 17 mov %l7, %o0 <== NOT EXECUTED
printf ("\nrtems-rfs: write-group: group %3d: close inode" \
203aff0: 40 00 38 3d call 20490e4 <strerror> <== NOT EXECUTED
203aff4: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
203aff8: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
203affc: 90 10 00 13 mov %l3, %o0 <== NOT EXECUTED
203b000: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
203b004: 94 10 00 1c mov %i4, %o2 <== NOT EXECUTED
203b008: 40 00 2e b8 call 2046ae8 <printf> <== NOT EXECUTED
203b00c: 01 00 00 00 nop <== NOT EXECUTED
rc = rtems_rfs_buffer_handle_close (fs, &handle);
if (rc > 0)
{
printf ("\nrtems-rfs: write-group: buffer handle close failed: %d: %s\n",
rc, strerror (rc));
return false;
203b010: 10 80 00 3a b 203b0f8 <rtems_rfs_format+0xa4c> <== NOT EXECUTED
203b014: 82 10 20 00 clr %g1 ! 0 <PROM_START> <== NOT EXECUTED
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);
203b018: c2 2f bf 30 stb %g1, [ %fp + -208 ]
/*
* Initialise the inode tables if required to do so.
*/
if (initialise_inodes)
203b01c: 80 8d a0 ff btst 0xff, %l6
203b020: 12 80 00 27 bne 203b0bc <rtems_rfs_format+0xa10> <== NEVER TAKEN
203b024: a2 10 20 00 clr %l1
rtems_rfs_buffer_mark_dirty (&handle);
}
}
rc = rtems_rfs_buffer_handle_close (fs, &handle);
203b028: 90 07 bf 7c add %fp, -132, %o0
203b02c: 7f ff fd 8b call 203a658 <rtems_rfs_buffer_handle_close>
203b030: 92 07 bf 30 add %fp, -208, %o1
if (rc > 0)
203b034: b8 92 20 00 orcc %o0, 0, %i4
203b038: 04 80 00 30 ble 203b0f8 <rtems_rfs_format+0xa4c> <== ALWAYS TAKEN
203b03c: 82 10 20 01 mov 1, %g1
203b040: 30 80 00 27 b,a 203b0dc <rtems_rfs_format+0xa30> <== NOT EXECUTED
*/
if (initialise_inodes)
{
for (b = 0; b < blocks; b++)
{
rc = rtems_rfs_buffer_handle_request (fs, &handle,
203b044: 90 10 00 17 mov %l7, %o0 <== NOT EXECUTED
return rc;
}
int
rtems_rfs_format (const char* name, const rtems_rfs_format_config* config)
203b048: b8 00 40 11 add %g1, %l1, %i4 <== NOT EXECUTED
*/
if (initialise_inodes)
{
for (b = 0; b < blocks; b++)
{
rc = rtems_rfs_buffer_handle_request (fs, &handle,
203b04c: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
203b050: 94 10 00 1c mov %i4, %o2 <== NOT EXECUTED
203b054: 7f ff f1 46 call 203756c <rtems_rfs_buffer_handle_request><== NOT EXECUTED
203b058: 96 10 20 00 clr %o3 <== NOT EXECUTED
group_base + b + RTEMS_RFS_GROUP_INODE_BLOCK,
false);
if (rc > 0)
203b05c: b4 92 20 00 orcc %o0, 0, %i2 <== NOT EXECUTED
203b060: 04 80 00 10 ble 203b0a0 <rtems_rfs_format+0x9f4> <== NOT EXECUTED
203b064: c4 07 bf 38 ld [ %fp + -200 ], %g2 <== NOT EXECUTED
{
rtems_rfs_buffer_handle_close (fs, &handle);
203b068: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
203b06c: 7f ff fd 7b call 203a658 <rtems_rfs_buffer_handle_close> <== NOT EXECUTED
203b070: 90 10 00 17 mov %l7, %o0 <== NOT EXECUTED
printf ("\nrtems-rfs: write-group: group %3d: block %" PRId32 " request failed: %d: %s\n",
203b074: 40 00 38 1c call 20490e4 <strerror> <== NOT EXECUTED
203b078: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
203b07c: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
203b080: 98 10 00 08 mov %o0, %o4 <== NOT EXECUTED
203b084: 94 10 00 1c mov %i4, %o2 <== NOT EXECUTED
203b088: 11 00 81 a2 sethi %hi(0x2068800), %o0 <== NOT EXECUTED
203b08c: 96 10 00 1a mov %i2, %o3 <== NOT EXECUTED
203b090: 40 00 2e 96 call 2046ae8 <printf> <== NOT EXECUTED
203b094: 90 12 23 60 or %o0, 0x360, %o0 <== NOT EXECUTED
rc = rtems_rfs_buffer_handle_close (fs, &handle);
if (rc > 0)
{
printf ("\nrtems-rfs: write-group: buffer handle close failed: %d: %s\n",
rc, strerror (rc));
return false;
203b098: 10 80 00 18 b 203b0f8 <rtems_rfs_format+0xa4c> <== NOT EXECUTED
203b09c: 82 10 20 00 clr %g1 <== 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));
203b0a0: d4 07 bf 84 ld [ %fp + -124 ], %o2 <== NOT EXECUTED
203b0a4: d0 00 a0 1c ld [ %g2 + 0x1c ], %o0 <== NOT EXECUTED
203b0a8: 92 10 20 ff mov 0xff, %o1 <== NOT EXECUTED
203b0ac: 40 00 2a 1e call 2045924 <memset> <== NOT EXECUTED
203b0b0: a2 04 60 01 inc %l1 <== NOT EXECUTED
rtems_rfs_buffer_mark_dirty (&handle);
203b0b4: 10 80 00 05 b 203b0c8 <rtems_rfs_format+0xa1c> <== NOT EXECUTED
203b0b8: ec 2f bf 30 stb %l6, [ %fp + -208 ] <== NOT EXECUTED
if (initialise_inodes)
{
for (b = 0; b < blocks; b++)
{
rc = rtems_rfs_buffer_handle_request (fs, &handle,
group_base + b + RTEMS_RFS_GROUP_INODE_BLOCK,
203b0bc: b4 06 a0 03 add %i2, 3, %i2 <== NOT EXECUTED
* Force the whole buffer to a known state. The bit map may not occupy the
* whole block.
*/
memset (rtems_rfs_buffer_data (&handle), 0xff, rtems_rfs_fs_block_size (fs));
rtems_rfs_buffer_mark_dirty (&handle);
203b0c0: ac 10 20 01 mov 1, %l6 <== NOT EXECUTED
if (initialise_inodes)
{
for (b = 0; b < blocks; b++)
{
rc = rtems_rfs_buffer_handle_request (fs, &handle,
group_base + b + RTEMS_RFS_GROUP_INODE_BLOCK,
203b0c4: f4 27 bf 24 st %i2, [ %fp + -220 ] <== NOT EXECUTED
/*
* Initialise the inode tables if required to do so.
*/
if (initialise_inodes)
{
for (b = 0; b < blocks; b++)
203b0c8: 80 a4 40 10 cmp %l1, %l0 <== NOT EXECUTED
203b0cc: 06 bf ff de bl 203b044 <rtems_rfs_format+0x998> <== NOT EXECUTED
203b0d0: c2 07 bf 24 ld [ %fp + -220 ], %g1 <== NOT EXECUTED
rtems_rfs_buffer_mark_dirty (&handle);
}
}
rc = rtems_rfs_buffer_handle_close (fs, &handle);
203b0d4: 10 bf ff d6 b 203b02c <rtems_rfs_format+0x980> <== NOT EXECUTED
203b0d8: 90 07 bf 7c add %fp, -132, %o0 <== NOT EXECUTED
if (rc > 0)
{
printf ("\nrtems-rfs: write-group: buffer handle close failed: %d: %s\n",
203b0dc: 40 00 38 02 call 20490e4 <strerror> <== NOT EXECUTED
203b0e0: 01 00 00 00 nop <== NOT EXECUTED
203b0e4: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
203b0e8: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
203b0ec: 40 00 2e 7f call 2046ae8 <printf> <== NOT EXECUTED
203b0f0: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED
rc, strerror (rc));
return false;
203b0f4: 82 10 20 00 clr %g1 <== NOT EXECUTED
printf ("rtems-rfs: format: superblock write failed\n");
return -1;
}
for (group = 0; group < fs.group_count; group++)
if (!rtems_rfs_write_group (&fs, group,
203b0f8: 80 88 60 ff btst 0xff, %g1
203b0fc: 02 80 00 a9 be 203b3a0 <rtems_rfs_format+0xcf4> <== NEVER TAKEN
203b100: ba 07 60 01 inc %i5
{
printf ("rtems-rfs: format: superblock write failed\n");
return -1;
}
for (group = 0; group < fs.group_count; group++)
203b104: 10 80 00 0b b 203b130 <rtems_rfs_format+0xa84>
203b108: c2 07 bf a0 ld [ %fp + -96 ], %g1
}
rc = rtems_rfs_buffer_handle_close (fs, &handle);
if (rc > 0)
{
printf ("\nrtems-rfs: write-group: buffer handle close failed: %d: %s\n",
203b10c: 25 00 81 a2 sethi %hi(0x2068800), %l2
*/
rc = rtems_rfs_bitmap_close (&bitmap);
if (rc > 0)
{
rtems_rfs_buffer_handle_close (fs, &handle);
printf ("\nrtems-rfs: write-group: group %3d: close inode" \
203b110: 27 00 81 a2 sethi %hi(0x2068800), %l3
rc = rtems_rfs_bitmap_map_clear_all (&bitmap);
if (rc > 0)
{
rtems_rfs_bitmap_close (&bitmap);
rtems_rfs_buffer_handle_close (fs, &handle);
printf ("\nrtems-rfs: write-group: group %3d: inode bitmap" \
203b114: 29 00 81 a2 sethi %hi(0x2068800), %l4
rc = rtems_rfs_bitmap_open (&bitmap, fs, &handle, group_size,
group_base + RTEMS_RFS_GROUP_INODE_BITMAP_BLOCK);
if (rc > 0)
{
rtems_rfs_buffer_handle_close (fs, &handle);
printf ("\nrtems-rfs: write-group: group %3d: open inode bitmap failed: %d: %s\n",
203b118: 2b 00 81 a2 sethi %hi(0x2068800), %l5
}
rc = rtems_rfs_buffer_handle_close (fs, &handle);
if (rc > 0)
{
printf ("\nrtems-rfs: write-group: buffer handle close failed: %d: %s\n",
203b11c: a4 14 a3 a8 or %l2, 0x3a8, %l2
*/
rc = rtems_rfs_bitmap_close (&bitmap);
if (rc > 0)
{
rtems_rfs_buffer_handle_close (fs, &handle);
printf ("\nrtems-rfs: write-group: group %3d: close inode" \
203b120: a6 14 e3 18 or %l3, 0x318, %l3
rc = rtems_rfs_bitmap_map_clear_all (&bitmap);
if (rc > 0)
{
rtems_rfs_bitmap_close (&bitmap);
rtems_rfs_buffer_handle_close (fs, &handle);
printf ("\nrtems-rfs: write-group: group %3d: inode bitmap" \
203b124: a8 15 22 c8 or %l4, 0x2c8, %l4
rc = rtems_rfs_bitmap_open (&bitmap, fs, &handle, group_size,
group_base + RTEMS_RFS_GROUP_INODE_BITMAP_BLOCK);
if (rc > 0)
{
rtems_rfs_buffer_handle_close (fs, &handle);
printf ("\nrtems-rfs: write-group: group %3d: open inode bitmap failed: %d: %s\n",
203b128: aa 15 62 80 or %l5, 0x280, %l5
{
printf ("rtems-rfs: format: superblock write failed\n");
return -1;
}
for (group = 0; group < fs.group_count; group++)
203b12c: c2 07 bf a0 ld [ %fp + -96 ], %g1
203b130: 80 a7 40 01 cmp %i5, %g1
203b134: 06 bf ff 0a bl 203ad5c <rtems_rfs_format+0x6b0>
203b138: ee 0e 60 15 ldub [ %i1 + 0x15 ], %l7
if (!rtems_rfs_write_group (&fs, group,
config->initialise_inodes, config->verbose))
return -1;
if (config->verbose)
203b13c: 80 8d e0 ff btst 0xff, %l7
203b140: 02 80 00 04 be 203b150 <rtems_rfs_format+0xaa4> <== ALWAYS TAKEN
203b144: 01 00 00 00 nop
printf ("\n");
203b148: 40 00 2e d2 call 2046c90 <putchar> <== NOT EXECUTED
203b14c: 90 10 20 0a mov 0xa, %o0 ! a <PROM_START+0xa> <== NOT EXECUTED
rc = rtems_rfs_buffer_close (&fs);
203b150: 7f ff f2 88 call 2037b70 <rtems_rfs_buffer_close>
203b154: 90 07 bf 7c add %fp, -132, %o0
if (rc > 0)
203b158: ba 92 20 00 orcc %o0, 0, %i5
203b15c: 24 80 00 08 ble,a 203b17c <rtems_rfs_format+0xad0> <== ALWAYS TAKEN
203b160: 90 10 00 18 mov %i0, %o0
{
printf ("rtems-rfs: format: buffer close failed: %d: %s\n",
203b164: 40 00 37 e0 call 20490e4 <strerror> <== NOT EXECUTED
203b168: 01 00 00 00 nop <== NOT EXECUTED
203b16c: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
203b170: 11 00 81 a2 sethi %hi(0x2068800), %o0 <== NOT EXECUTED
203b174: 10 80 00 87 b 203b390 <rtems_rfs_format+0xce4> <== NOT EXECUTED
203b178: 90 12 23 e8 or %o0, 0x3e8, %o0 ! 2068be8 <__FUNCTION__.7829+0x1af8><== NOT EXECUTED
int rc;
/*
* External API so returns -1.
*/
rc = rtems_rfs_fs_open (name, NULL,
203b17c: 92 10 20 00 clr %o1
203b180: 94 10 20 06 mov 6, %o2
203b184: 96 10 20 00 clr %o3
203b188: 7f ff fb 1c call 2039df8 <rtems_rfs_fs_open>
203b18c: 98 07 bf 28 add %fp, -216, %o4
RTEMS_RFS_FS_FORCE_OPEN | RTEMS_RFS_FS_NO_LOCAL_CACHE,
0, &fs);
if (rc < 0)
203b190: 80 a2 20 00 cmp %o0, 0
203b194: 36 80 00 0e bge,a 203b1cc <rtems_rfs_format+0xb20> <== ALWAYS TAKEN
203b198: d0 07 bf 28 ld [ %fp + -216 ], %o0
{
printf ("rtems-rfs: format: file system open failed: %d: %s\n",
errno, strerror (errno));
203b19c: 40 00 1c 14 call 20421ec <__errno> <== NOT EXECUTED
203b1a0: b0 10 20 00 clr %i0 <== NOT EXECUTED
203b1a4: 40 00 1c 12 call 20421ec <__errno> <== NOT EXECUTED
203b1a8: fa 02 00 00 ld [ %o0 ], %i5 <== NOT EXECUTED
rc = rtems_rfs_fs_open (name, NULL,
RTEMS_RFS_FS_FORCE_OPEN | RTEMS_RFS_FS_NO_LOCAL_CACHE,
0, &fs);
if (rc < 0)
{
printf ("rtems-rfs: format: file system open failed: %d: %s\n",
203b1ac: 40 00 37 ce call 20490e4 <strerror> <== NOT EXECUTED
203b1b0: d0 02 00 00 ld [ %o0 ], %o0 <== NOT EXECUTED
203b1b4: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
203b1b8: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
203b1bc: 11 00 81 a3 sethi %hi(0x2068c00), %o0 <== NOT EXECUTED
203b1c0: 40 00 2e 4a call 2046ae8 <printf> <== NOT EXECUTED
203b1c4: 90 12 20 18 or %o0, 0x18, %o0 ! 2068c18 <__FUNCTION__.7829+0x1b28><== NOT EXECUTED
203b1c8: 30 80 00 77 b,a 203b3a4 <rtems_rfs_format+0xcf8> <== NOT EXECUTED
errno, strerror (errno));
return -1;
}
rc = rtems_rfs_inode_alloc (fs, RTEMS_RFS_ROOT_INO, &ino);
203b1cc: 92 10 20 01 mov 1, %o1
203b1d0: 40 00 02 38 call 203bab0 <rtems_rfs_inode_alloc>
203b1d4: 94 07 bf 2c add %fp, -212, %o2
if (rc > 0)
203b1d8: ba 92 20 00 orcc %o0, 0, %i5
203b1dc: 04 80 00 0a ble 203b204 <rtems_rfs_format+0xb58> <== ALWAYS TAKEN
203b1e0: d2 07 bf 2c ld [ %fp + -212 ], %o1
{
printf ("rtems-rfs: format: inode allocation failed: %d: %s\n",
203b1e4: 40 00 37 c0 call 20490e4 <strerror> <== NOT EXECUTED
203b1e8: 01 00 00 00 nop <== NOT EXECUTED
203b1ec: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
203b1f0: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
203b1f4: 11 00 81 a3 sethi %hi(0x2068c00), %o0 <== NOT EXECUTED
203b1f8: 40 00 2e 3c call 2046ae8 <printf> <== NOT EXECUTED
203b1fc: 90 12 20 50 or %o0, 0x50, %o0 ! 2068c50 <__FUNCTION__.7829+0x1b60><== NOT EXECUTED
203b200: 30 80 00 06 b,a 203b218 <rtems_rfs_format+0xb6c> <== NOT EXECUTED
rc, strerror (rc));
rtems_rfs_fs_close (fs);
return rc;
}
if (ino != RTEMS_RFS_ROOT_INO)
203b204: 80 a2 60 01 cmp %o1, 1
203b208: 02 80 00 08 be 203b228 <rtems_rfs_format+0xb7c> <== ALWAYS TAKEN
203b20c: 11 00 81 a3 sethi %hi(0x2068c00), %o0
{
printf ("rtems-rfs: format: allocated inode not root ino: %" PRId32 "\n", ino);
203b210: 40 00 2e 36 call 2046ae8 <printf> <== NOT EXECUTED
203b214: 90 12 20 88 or %o0, 0x88, %o0 ! 2068c88 <__FUNCTION__.7829+0x1b98><== NOT EXECUTED
rtems_rfs_fs_close (fs);
203b218: 7f ff fc f3 call 203a5e4 <rtems_rfs_fs_close> <== NOT EXECUTED
203b21c: d0 07 bf 28 ld [ %fp + -216 ], %o0 <== NOT EXECUTED
rc, strerror (rc));
return -1;
}
rc = rtems_rfs_write_root_dir (name);
if (rc > 0)
203b220: 10 80 00 55 b 203b374 <rtems_rfs_format+0xcc8> <== NOT EXECUTED
203b224: 80 a7 60 00 cmp %i5, 0 <== NOT EXECUTED
printf ("rtems-rfs: format: allocated inode not root ino: %" PRId32 "\n", ino);
rtems_rfs_fs_close (fs);
return rc;
}
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
203b228: d0 07 bf 28 ld [ %fp + -216 ], %o0
203b22c: 92 10 20 01 mov 1, %o1
203b230: 94 07 bf 54 add %fp, -172, %o2
203b234: 40 00 02 5b call 203bba0 <rtems_rfs_inode_open>
203b238: 96 10 20 01 mov 1, %o3
if (rc > 0)
203b23c: ba 92 20 00 orcc %o0, 0, %i5
203b240: 24 80 00 0e ble,a 203b278 <rtems_rfs_format+0xbcc> <== ALWAYS TAKEN
203b244: 90 07 bf 54 add %fp, -172, %o0
{
printf ("rtems-rfs: format: inode open failed: %d: %s\n",
203b248: 40 00 37 a7 call 20490e4 <strerror> <== NOT EXECUTED
203b24c: 01 00 00 00 nop <== NOT EXECUTED
203b250: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
203b254: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
203b258: 11 00 81 a3 sethi %hi(0x2068c00), %o0 <== NOT EXECUTED
203b25c: 40 00 2e 23 call 2046ae8 <printf> <== NOT EXECUTED
203b260: 90 12 20 c0 or %o0, 0xc0, %o0 ! 2068cc0 <__FUNCTION__.7829+0x1bd0><== NOT EXECUTED
rc, strerror (rc));
rtems_rfs_group_bitmap_free (fs, true, ino);
203b264: d0 07 bf 28 ld [ %fp + -216 ], %o0 <== NOT EXECUTED
203b268: d4 07 bf 2c ld [ %fp + -212 ], %o2 <== NOT EXECUTED
203b26c: 40 00 01 7c call 203b85c <rtems_rfs_group_bitmap_free> <== NOT EXECUTED
203b270: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
203b274: 30 bf ff e9 b,a 203b218 <rtems_rfs_format+0xb6c> <== NOT EXECUTED
rtems_rfs_fs_close (fs);
return rc;
}
rc = rtems_rfs_inode_initialise (&inode, 0,
203b278: 92 10 20 00 clr %o1
203b27c: 15 00 00 10 sethi %hi(0x4000), %o2
203b280: 96 10 20 00 clr %o3
203b284: 94 12 a1 c9 or %o2, 0x1c9, %o2
203b288: 40 00 03 39 call 203bf6c <rtems_rfs_inode_initialise>
203b28c: 98 10 20 00 clr %o4
(RTEMS_RFS_S_IFDIR | RTEMS_RFS_S_IRWXU |
RTEMS_RFS_S_IXGRP | RTEMS_RFS_S_IXOTH),
0, 0);
if (rc > 0)
203b290: ba 92 20 00 orcc %o0, 0, %i5
203b294: 24 80 00 0a ble,a 203b2bc <rtems_rfs_format+0xc10> <== ALWAYS TAKEN
203b298: d0 07 bf 28 ld [ %fp + -216 ], %o0
printf ("rtems-rfs: format: inode initialise failed: %d: %s\n",
203b29c: 40 00 37 92 call 20490e4 <strerror> <== NOT EXECUTED
203b2a0: 01 00 00 00 nop <== NOT EXECUTED
203b2a4: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
203b2a8: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
203b2ac: 11 00 81 a3 sethi %hi(0x2068c00), %o0 <== NOT EXECUTED
203b2b0: 40 00 2e 0e call 2046ae8 <printf> <== NOT EXECUTED
203b2b4: 90 12 20 f0 or %o0, 0xf0, %o0 ! 2068cf0 <__FUNCTION__.7829+0x1c00><== NOT EXECUTED
rc, strerror (rc));
rc = rtems_rfs_dir_add_entry (fs, &inode, ".", 1, ino);
203b2b8: d0 07 bf 28 ld [ %fp + -216 ], %o0 <== NOT EXECUTED
203b2bc: d8 07 bf 2c ld [ %fp + -212 ], %o4
203b2c0: 92 07 bf 54 add %fp, -172, %o1
203b2c4: 15 00 81 82 sethi %hi(0x2060800), %o2
203b2c8: 96 10 20 01 mov 1, %o3
203b2cc: 7f ff f3 a5 call 2038160 <rtems_rfs_dir_add_entry>
203b2d0: 94 12 a1 10 or %o2, 0x110, %o2
if (rc > 0)
203b2d4: ba 92 20 00 orcc %o0, 0, %i5
203b2d8: 24 80 00 0a ble,a 203b300 <rtems_rfs_format+0xc54> <== ALWAYS TAKEN
203b2dc: d0 07 bf 28 ld [ %fp + -216 ], %o0
printf ("rtems-rfs: format: directory add failed: %d: %s\n",
203b2e0: 40 00 37 81 call 20490e4 <strerror> <== NOT EXECUTED
203b2e4: 01 00 00 00 nop <== NOT EXECUTED
203b2e8: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
203b2ec: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
203b2f0: 11 00 81 a3 sethi %hi(0x2068c00), %o0 <== NOT EXECUTED
203b2f4: 40 00 2d fd call 2046ae8 <printf> <== NOT EXECUTED
203b2f8: 90 12 21 28 or %o0, 0x128, %o0 ! 2068d28 <__FUNCTION__.7829+0x1c38><== NOT EXECUTED
rc, strerror (rc));
rc = rtems_rfs_inode_close (fs, &inode);
203b2fc: d0 07 bf 28 ld [ %fp + -216 ], %o0 <== NOT EXECUTED
203b300: 40 00 02 9a call 203bd68 <rtems_rfs_inode_close>
203b304: 92 07 bf 54 add %fp, -172, %o1
if (rc > 0)
203b308: ba 92 20 00 orcc %o0, 0, %i5
203b30c: 04 80 00 09 ble 203b330 <rtems_rfs_format+0xc84> <== ALWAYS TAKEN
203b310: 01 00 00 00 nop
printf ("rtems-rfs: format: inode close failed: %d: %s\n",
203b314: 40 00 37 74 call 20490e4 <strerror> <== NOT EXECUTED
203b318: 01 00 00 00 nop <== NOT EXECUTED
203b31c: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
203b320: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
203b324: 11 00 81 a3 sethi %hi(0x2068c00), %o0 <== NOT EXECUTED
203b328: 40 00 2d f0 call 2046ae8 <printf> <== NOT EXECUTED
203b32c: 90 12 21 60 or %o0, 0x160, %o0 ! 2068d60 <__FUNCTION__.7829+0x1c70><== NOT EXECUTED
rc, strerror (rc));
rc = rtems_rfs_fs_close (fs);
203b330: 7f ff fc ad call 203a5e4 <rtems_rfs_fs_close>
203b334: d0 07 bf 28 ld [ %fp + -216 ], %o0
if (rc < 0)
203b338: ba 92 20 00 orcc %o0, 0, %i5
203b33c: 16 80 00 0e bge 203b374 <rtems_rfs_format+0xcc8> <== ALWAYS TAKEN
203b340: 80 a7 60 00 cmp %i5, 0
printf ("rtems-rfs: format: file system close failed: %d: %s\n",
errno, strerror (errno));
203b344: 40 00 1b aa call 20421ec <__errno> <== NOT EXECUTED
203b348: 01 00 00 00 nop <== NOT EXECUTED
203b34c: 40 00 1b a8 call 20421ec <__errno> <== NOT EXECUTED
203b350: f8 02 00 00 ld [ %o0 ], %i4 <== 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",
203b354: 40 00 37 64 call 20490e4 <strerror> <== NOT EXECUTED
203b358: d0 02 00 00 ld [ %o0 ], %o0 <== NOT EXECUTED
203b35c: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
203b360: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
203b364: 11 00 81 a3 sethi %hi(0x2068c00), %o0 <== NOT EXECUTED
203b368: 40 00 2d e0 call 2046ae8 <printf> <== NOT EXECUTED
203b36c: 90 12 21 90 or %o0, 0x190, %o0 ! 2068d90 <__FUNCTION__.7829+0x1ca0><== NOT EXECUTED
rc, strerror (rc));
return -1;
}
rc = rtems_rfs_write_root_dir (name);
if (rc > 0)
203b370: 80 a7 60 00 cmp %i5, 0 <== NOT EXECUTED
203b374: 24 80 00 0c ble,a 203b3a4 <rtems_rfs_format+0xcf8> <== ALWAYS TAKEN
203b378: b0 10 20 00 clr %i0
{
printf ("rtems-rfs: format: writing root dir failed: %d: %s\n",
203b37c: 40 00 37 5a call 20490e4 <strerror> <== NOT EXECUTED
203b380: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
203b384: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
203b388: 11 00 81 a3 sethi %hi(0x2068c00), %o0 <== NOT EXECUTED
203b38c: 90 12 21 c8 or %o0, 0x1c8, %o0 ! 2068dc8 <__FUNCTION__.7829+0x1cd8><== NOT EXECUTED
203b390: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
203b394: 40 00 2d d5 call 2046ae8 <printf> <== NOT EXECUTED
203b398: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
203b39c: 30 80 00 02 b,a 203b3a4 <rtems_rfs_format+0xcf8> <== NOT EXECUTED
/*
* Check the configuration data.
*/
if (!rtems_rfs_check_config (&fs, config))
return -1;
203b3a0: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
203b3a4: 81 c7 e0 08 ret
203b3a8: 81 e8 00 00 restore
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;
203b3ac: c2 27 bf 98 st %g1, [ %fp + -104 ]
* Check the configuration data.
*/
if (!rtems_rfs_check_config (&fs, config))
return -1;
if (config->verbose)
203b3b0: c2 0e 60 15 ldub [ %i1 + 0x15 ], %g1
203b3b4: 80 a0 60 00 cmp %g1, 0
203b3b8: 02 bf fd d0 be 203aaf8 <rtems_rfs_format+0x44c> <== ALWAYS TAKEN
203b3bc: d2 07 bf 84 ld [ %fp + -124 ], %o1
203b3c0: 30 bf fd 6f b,a 203a97c <rtems_rfs_format+0x2d0> <== NOT EXECUTED
0203a5e4 <rtems_rfs_fs_close>:
int
rtems_rfs_fs_close (rtems_rfs_file_system* fs)
{
203a5e4: 9d e3 bf a0 save %sp, -96, %sp
int group;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_CLOSE))
203a5e8: 90 10 20 00 clr %o0
203a5ec: 7f ff a5 18 call 2023a4c <rtems_rfs_trace>
203a5f0: 92 10 20 02 mov 2, %o1
203a5f4: 80 8a 20 ff btst 0xff, %o0
203a5f8: 22 80 00 06 be,a 203a610 <rtems_rfs_fs_close+0x2c> <== ALWAYS TAKEN
203a5fc: b8 10 20 00 clr %i4
printf ("rtems-rfs: close\n");
203a600: 11 00 81 a1 sethi %hi(0x2068400), %o0 <== NOT EXECUTED
203a604: 40 00 31 d1 call 2046d48 <puts> <== NOT EXECUTED
203a608: 90 12 21 08 or %o0, 0x108, %o0 ! 2068508 <__FUNCTION__.7829+0x1418><== NOT EXECUTED
return 0;
}
int
rtems_rfs_fs_close (rtems_rfs_file_system* fs)
{
203a60c: b8 10 20 00 clr %i4 <== NOT EXECUTED
203a610: 10 80 00 07 b 203a62c <rtems_rfs_fs_close+0x48>
203a614: ba 10 20 00 clr %i5
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]);
203a618: 90 10 00 18 mov %i0, %o0
203a61c: 92 02 40 1c add %o1, %i4, %o1
203a620: 40 00 03 e7 call 203b5bc <rtems_rfs_group_close>
203a624: ba 07 60 01 inc %i5
203a628: b8 07 20 50 add %i4, 0x50, %i4
int group;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_CLOSE))
printf ("rtems-rfs: close\n");
for (group = 0; group < fs->group_count; group++)
203a62c: c2 06 20 24 ld [ %i0 + 0x24 ], %g1
203a630: 80 a7 40 01 cmp %i5, %g1
203a634: 26 bf ff f9 bl,a 203a618 <rtems_rfs_fs_close+0x34>
203a638: d2 06 20 20 ld [ %i0 + 0x20 ], %o1
rtems_rfs_group_close (fs, &fs->groups[group]);
rtems_rfs_buffer_close (fs);
203a63c: 7f ff f5 4d call 2037b70 <rtems_rfs_buffer_close>
203a640: 90 10 00 18 mov %i0, %o0
free (fs);
203a644: 90 10 00 18 mov %i0, %o0
203a648: 7f ff 39 6d call 2008bfc <free>
203a64c: b0 10 20 00 clr %i0
return 0;
}
203a650: 81 c7 e0 08 ret
203a654: 81 e8 00 00 restore
02039df8 <rtems_rfs_fs_open>:
rtems_rfs_fs_open (const char* name,
void* user,
uint32_t flags,
uint32_t max_held_buffers,
rtems_rfs_file_system** fs)
{
2039df8: 9d e3 bf 68 save %sp, -152, %sp
#endif
rtems_rfs_inode_handle inode;
uint16_t mode;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
2039dfc: 90 10 20 00 clr %o0
2039e00: 7f ff a7 13 call 2023a4c <rtems_rfs_trace>
2039e04: 92 10 20 01 mov 1, %o1
2039e08: 80 8a 20 ff btst 0xff, %o0
2039e0c: 02 80 00 05 be 2039e20 <rtems_rfs_fs_open+0x28> <== ALWAYS TAKEN
2039e10: 11 00 81 a0 sethi %hi(0x2068000), %o0
printf ("rtems-rfs: open: %s\n", name);
2039e14: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
2039e18: 40 00 33 34 call 2046ae8 <printf> <== NOT EXECUTED
2039e1c: 90 12 21 c8 or %o0, 0x1c8, %o0 <== NOT EXECUTED
*fs = malloc (sizeof (rtems_rfs_file_system));
2039e20: 7f ff 3c d5 call 2009174 <malloc>
2039e24: 90 10 20 84 mov 0x84, %o0
if (!*fs)
2039e28: 80 a2 20 00 cmp %o0, 0
2039e2c: 12 80 00 0f bne 2039e68 <rtems_rfs_fs_open+0x70> <== ALWAYS TAKEN
2039e30: d0 27 00 00 st %o0, [ %i4 ]
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
2039e34: 90 10 20 00 clr %o0 <== NOT EXECUTED
2039e38: 7f ff a7 05 call 2023a4c <rtems_rfs_trace> <== NOT EXECUTED
2039e3c: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
2039e40: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
2039e44: 02 80 00 05 be 2039e58 <rtems_rfs_fs_open+0x60> <== NOT EXECUTED
2039e48: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: open: no memory for file system data\n");
2039e4c: 11 00 81 a0 sethi %hi(0x2068000), %o0 <== NOT EXECUTED
2039e50: 40 00 33 be call 2046d48 <puts> <== NOT EXECUTED
2039e54: 90 12 21 e0 or %o0, 0x1e0, %o0 ! 20681e0 <__FUNCTION__.7829+0x10f0><== NOT EXECUTED
errno = ENOMEM;
2039e58: 40 00 20 e5 call 20421ec <__errno> <== NOT EXECUTED
2039e5c: 01 00 00 00 nop <== NOT EXECUTED
2039e60: 10 80 01 c5 b 203a574 <rtems_rfs_fs_open+0x77c> <== NOT EXECUTED
2039e64: 82 10 20 0c mov 0xc, %g1 ! c <PROM_START+0xc> <== NOT EXECUTED
return -1;
}
memset (*fs, 0, sizeof (rtems_rfs_file_system));
2039e68: 92 10 20 00 clr %o1
2039e6c: 40 00 2e ae call 2045924 <memset>
2039e70: 94 10 20 84 mov 0x84, %o2
(*fs)->user = user;
2039e74: c2 07 00 00 ld [ %i4 ], %g1
#endif
/*
* Open the buffer interface.
*/
rc = rtems_rfs_buffer_open (name, *fs);
2039e78: 90 10 00 18 mov %i0, %o0
return -1;
}
memset (*fs, 0, sizeof (rtems_rfs_file_system));
(*fs)->user = user;
2039e7c: f2 20 60 80 st %i1, [ %g1 + 0x80 ]
rtems_chain_initialize_empty (&(*fs)->buffers);
2039e80: c2 07 00 00 ld [ %i4 ], %g1
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
head->previous = NULL;
2039e84: c0 20 60 48 clr [ %g1 + 0x48 ]
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 );
2039e88: 84 00 60 44 add %g1, 0x44, %g2
2039e8c: 86 00 60 48 add %g1, 0x48, %g3
head->next = tail;
head->previous = NULL;
tail->previous = head;
2039e90: c4 20 60 4c st %g2, [ %g1 + 0x4c ]
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
2039e94: c6 20 60 44 st %g3, [ %g1 + 0x44 ]
rtems_chain_initialize_empty (&(*fs)->release);
2039e98: c2 07 00 00 ld [ %i4 ], %g1
head->previous = NULL;
2039e9c: c0 20 60 58 clr [ %g1 + 0x58 ]
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 );
2039ea0: 84 00 60 54 add %g1, 0x54, %g2
2039ea4: 86 00 60 58 add %g1, 0x58, %g3
head->next = tail;
head->previous = NULL;
tail->previous = head;
2039ea8: c4 20 60 5c st %g2, [ %g1 + 0x5c ]
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
2039eac: c6 20 60 54 st %g3, [ %g1 + 0x54 ]
rtems_chain_initialize_empty (&(*fs)->release_modified);
2039eb0: c2 07 00 00 ld [ %i4 ], %g1
head->previous = NULL;
2039eb4: c0 20 60 68 clr [ %g1 + 0x68 ]
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 );
2039eb8: 84 00 60 64 add %g1, 0x64, %g2
2039ebc: 86 00 60 68 add %g1, 0x68, %g3
head->next = tail;
head->previous = NULL;
tail->previous = head;
2039ec0: c4 20 60 6c st %g2, [ %g1 + 0x6c ]
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
2039ec4: c6 20 60 64 st %g3, [ %g1 + 0x64 ]
rtems_chain_initialize_empty (&(*fs)->file_shares);
2039ec8: c2 07 00 00 ld [ %i4 ], %g1
head->previous = NULL;
2039ecc: c0 20 60 78 clr [ %g1 + 0x78 ]
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 );
2039ed0: 84 00 60 74 add %g1, 0x74, %g2
2039ed4: 86 00 60 78 add %g1, 0x78, %g3
head->next = tail;
head->previous = NULL;
tail->previous = head;
2039ed8: c4 20 60 7c st %g2, [ %g1 + 0x7c ]
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
2039edc: c6 20 60 74 st %g3, [ %g1 + 0x74 ]
(*fs)->max_held_buffers = max_held_buffers;
2039ee0: d2 07 00 00 ld [ %i4 ], %o1
2039ee4: f6 22 60 40 st %i3, [ %o1 + 0x40 ]
(*fs)->buffers_count = 0;
2039ee8: c0 22 60 50 clr [ %o1 + 0x50 ]
(*fs)->release_count = 0;
2039eec: c0 22 60 60 clr [ %o1 + 0x60 ]
(*fs)->release_modified_count = 0;
2039ef0: c0 22 60 70 clr [ %o1 + 0x70 ]
#endif
/*
* Open the buffer interface.
*/
rc = rtems_rfs_buffer_open (name, *fs);
2039ef4: 7f ff f6 44 call 2037804 <rtems_rfs_buffer_open>
2039ef8: f4 22 40 00 st %i2, [ %o1 ]
if (rc > 0)
2039efc: ba 92 20 00 orcc %o0, 0, %i5
2039f00: 04 80 00 16 ble 2039f58 <rtems_rfs_fs_open+0x160> <== ALWAYS TAKEN
2039f04: f6 07 00 00 ld [ %i4 ], %i3
{
free (*fs);
2039f08: 7f ff 3b 3d call 2008bfc <free> <== NOT EXECUTED
2039f0c: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
2039f10: 90 10 20 00 clr %o0 <== NOT EXECUTED
2039f14: 7f ff a6 ce call 2023a4c <rtems_rfs_trace> <== NOT EXECUTED
2039f18: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
2039f1c: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
2039f20: 02 80 00 09 be 2039f44 <rtems_rfs_fs_open+0x14c> <== NOT EXECUTED
2039f24: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: open: buffer open failed: %d: %s\n",
2039f28: 40 00 3c 6f call 20490e4 <strerror> <== NOT EXECUTED
2039f2c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
2039f30: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
2039f34: 11 00 81 a0 sethi %hi(0x2068000), %o0 <== NOT EXECUTED
2039f38: 90 12 22 10 or %o0, 0x210, %o0 ! 2068210 <__FUNCTION__.7829+0x1120><== NOT EXECUTED
2039f3c: 40 00 32 eb call 2046ae8 <printf> <== NOT EXECUTED
2039f40: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
rc, strerror (rc));
errno = rc;
2039f44: 40 00 20 aa call 20421ec <__errno> <== NOT EXECUTED
2039f48: 01 00 00 00 nop <== NOT EXECUTED
2039f4c: fa 22 00 00 st %i5, [ %o0 ] <== NOT EXECUTED
return -1;
2039f50: 81 c7 e0 08 ret <== NOT EXECUTED
2039f54: 91 e8 3f ff restore %g0, -1, %o0 <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
2039f58: c0 2f bf cc clrb [ %fp + -52 ]
handle->bnum = 0;
2039f5c: c0 27 bf d0 clr [ %fp + -48 ]
handle->buffer = NULL;
2039f60: c0 27 bf d4 clr [ %fp + -44 ]
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);
2039f64: 90 10 00 1b mov %i3, %o0
2039f68: 92 07 bf cc add %fp, -52, %o1
2039f6c: 94 10 20 00 clr %o2
2039f70: 7f ff f5 7f call 203756c <rtems_rfs_buffer_handle_request>
2039f74: 96 10 20 01 mov 1, %o3
if (rc > 0)
2039f78: ba 92 20 00 orcc %o0, 0, %i5
2039f7c: 04 80 00 0d ble 2039fb0 <rtems_rfs_fs_open+0x1b8> <== ALWAYS TAKEN
2039f80: 90 10 20 00 clr %o0
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
2039f84: 7f ff a6 b2 call 2023a4c <rtems_rfs_trace> <== NOT EXECUTED
2039f88: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
2039f8c: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
2039f90: 22 80 01 2d be,a 203a444 <rtems_rfs_fs_open+0x64c> <== NOT EXECUTED
2039f94: 80 a7 60 00 cmp %i5, 0 <== NOT EXECUTED
printf ("rtems-rfs: read-superblock: request failed%d: %s\n",
2039f98: 40 00 3c 53 call 20490e4 <strerror> <== NOT EXECUTED
2039f9c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
2039fa0: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
2039fa4: 11 00 81 a0 sethi %hi(0x2068000), %o0 <== NOT EXECUTED
2039fa8: 10 80 00 de b 203a320 <rtems_rfs_fs_open+0x528> <== NOT EXECUTED
2039fac: 90 12 22 40 or %o0, 0x240, %o0 ! 2068240 <__FUNCTION__.7829+0x1150><== NOT EXECUTED
rc, strerror (rc));
return rc;
}
sb = rtems_rfs_buffer_data (&handle);
2039fb0: c2 07 bf d4 ld [ %fp + -44 ], %g1
2039fb4: fa 00 60 1c ld [ %g1 + 0x1c ], %i5
#define read_sb(_o) rtems_rfs_read_u32 (sb + (_o))
if (read_sb (RTEMS_RFS_SB_OFFSET_MAGIC) != RTEMS_RFS_SB_MAGIC)
2039fb8: c2 0f 60 01 ldub [ %i5 + 1 ], %g1
2039fbc: c4 0f 40 00 ldub [ %i5 ], %g2
2039fc0: 83 28 60 10 sll %g1, 0x10, %g1
2039fc4: 85 28 a0 18 sll %g2, 0x18, %g2
2039fc8: 84 10 80 01 or %g2, %g1, %g2
2039fcc: c2 0f 60 03 ldub [ %i5 + 3 ], %g1
2039fd0: 84 10 80 01 or %g2, %g1, %g2
2039fd4: c2 0f 60 02 ldub [ %i5 + 2 ], %g1
2039fd8: 83 28 60 08 sll %g1, 8, %g1
2039fdc: 84 10 80 01 or %g2, %g1, %g2
2039fe0: 03 0a 02 48 sethi %hi(0x28092000), %g1
2039fe4: 82 10 60 01 or %g1, 1, %g1 ! 28092001 <RAM_END+0x25c92001>
2039fe8: 80 a0 80 01 cmp %g2, %g1
2039fec: 22 80 00 0b be,a 203a018 <rtems_rfs_fs_open+0x220> <== ALWAYS TAKEN
2039ff0: c2 0f 60 0d ldub [ %i5 + 0xd ], %g1
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
2039ff4: 90 10 20 00 clr %o0 <== NOT EXECUTED
2039ff8: 7f ff a6 95 call 2023a4c <rtems_rfs_trace> <== NOT EXECUTED
2039ffc: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
203a000: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
203a004: 22 80 00 57 be,a 203a160 <rtems_rfs_fs_open+0x368> <== NOT EXECUTED
203a008: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
printf ("rtems-rfs: read-superblock: invalid superblock, bad magic\n");
203a00c: 11 00 81 a0 sethi %hi(0x2068000), %o0 <== NOT EXECUTED
203a010: 10 80 00 2f b 203a0cc <rtems_rfs_fs_open+0x2d4> <== NOT EXECUTED
203a014: 90 12 22 78 or %o0, 0x278, %o0 ! 2068278 <__FUNCTION__.7829+0x1188><== NOT EXECUTED
rtems_rfs_buffer_handle_close (fs, &handle);
return EIO;
}
fs->blocks = read_sb (RTEMS_RFS_SB_OFFSET_BLOCKS);
203a018: d6 0f 60 0c ldub [ %i5 + 0xc ], %o3
203a01c: 83 28 60 10 sll %g1, 0x10, %g1
203a020: 97 2a e0 18 sll %o3, 0x18, %o3
203a024: 96 12 c0 01 or %o3, %g1, %o3
203a028: c2 0f 60 0f ldub [ %i5 + 0xf ], %g1
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;
203a02c: 94 10 20 00 clr %o2
printf ("rtems-rfs: read-superblock: invalid superblock, bad magic\n");
rtems_rfs_buffer_handle_close (fs, &handle);
return EIO;
}
fs->blocks = read_sb (RTEMS_RFS_SB_OFFSET_BLOCKS);
203a030: 96 12 c0 01 or %o3, %g1, %o3
203a034: c2 0f 60 0e ldub [ %i5 + 0xe ], %g1
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;
203a038: 90 10 20 00 clr %o0
printf ("rtems-rfs: read-superblock: invalid superblock, bad magic\n");
rtems_rfs_buffer_handle_close (fs, &handle);
return EIO;
}
fs->blocks = read_sb (RTEMS_RFS_SB_OFFSET_BLOCKS);
203a03c: 83 28 60 08 sll %g1, 8, %g1
203a040: 96 12 c0 01 or %o3, %g1, %o3
203a044: d6 26 e0 04 st %o3, [ %i3 + 4 ]
fs->block_size = read_sb (RTEMS_RFS_SB_OFFSET_BLOCK_SIZE);
203a048: c2 0f 60 09 ldub [ %i5 + 9 ], %g1
203a04c: f4 0f 60 08 ldub [ %i5 + 8 ], %i2
203a050: 83 28 60 10 sll %g1, 0x10, %g1
203a054: b5 2e a0 18 sll %i2, 0x18, %i2
203a058: b4 16 80 01 or %i2, %g1, %i2
203a05c: c2 0f 60 0b ldub [ %i5 + 0xb ], %g1
203a060: b4 16 80 01 or %i2, %g1, %i2
203a064: c2 0f 60 0a ldub [ %i5 + 0xa ], %g1
203a068: 83 28 60 08 sll %g1, 8, %g1
203a06c: b4 16 80 01 or %i2, %g1, %i2
203a070: f4 26 e0 08 st %i2, [ %i3 + 8 ]
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;
203a074: 40 00 86 9b call 205bae0 <__muldi3>
203a078: 92 10 00 1a mov %i2, %o1
203a07c: b2 10 00 08 mov %o0, %i1
203a080: b0 10 00 09 mov %o1, %i0
}
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))
203a084: 7f ff ff 53 call 2039dd0 <rtems_rfs_fs_media_size>
203a088: 90 10 00 1b mov %i3, %o0
203a08c: 80 a6 40 08 cmp %i1, %o0
203a090: 38 80 00 08 bgu,a 203a0b0 <rtems_rfs_fs_open+0x2b8> <== NEVER TAKEN
203a094: 90 10 20 00 clr %o0 <== NOT EXECUTED
203a098: 32 80 00 11 bne,a 203a0dc <rtems_rfs_fs_open+0x2e4> <== NEVER TAKEN
203a09c: c4 0f 60 24 ldub [ %i5 + 0x24 ], %g2 <== NOT EXECUTED
203a0a0: 80 a6 00 09 cmp %i0, %o1
203a0a4: 28 80 00 0e bleu,a 203a0dc <rtems_rfs_fs_open+0x2e4> <== ALWAYS TAKEN
203a0a8: c4 0f 60 24 ldub [ %i5 + 0x24 ], %g2
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
203a0ac: 90 10 20 00 clr %o0 <== NOT EXECUTED
203a0b0: 7f ff a6 67 call 2023a4c <rtems_rfs_trace> <== NOT EXECUTED
203a0b4: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
203a0b8: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
203a0bc: 22 80 00 29 be,a 203a160 <rtems_rfs_fs_open+0x368> <== NOT EXECUTED
203a0c0: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
printf ("rtems-rfs: read-superblock: invalid superblock block/size count\n");
203a0c4: 11 00 81 a0 sethi %hi(0x2068000), %o0 <== NOT EXECUTED
203a0c8: 90 12 22 b8 or %o0, 0x2b8, %o0 ! 20682b8 <__FUNCTION__.7829+0x11c8><== NOT EXECUTED
203a0cc: 40 00 33 1f call 2046d48 <puts> <== NOT EXECUTED
203a0d0: 01 00 00 00 nop <== 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",
read_sb (RTEMS_RFS_SB_OFFSET_VERSION), RTEMS_RFS_VERSION_MASK);
rtems_rfs_buffer_handle_close (fs, &handle);
203a0d4: 10 80 00 23 b 203a160 <rtems_rfs_fs_open+0x368> <== NOT EXECUTED
203a0d8: 90 10 00 1b mov %i3, %o0 <== 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)
203a0dc: c2 0f 60 25 ldub [ %i5 + 0x25 ], %g1
203a0e0: 85 28 a0 18 sll %g2, 0x18, %g2
203a0e4: 83 28 60 10 sll %g1, 0x10, %g1
203a0e8: 82 10 80 01 or %g2, %g1, %g1
203a0ec: c4 0f 60 27 ldub [ %i5 + 0x27 ], %g2
203a0f0: 82 10 40 02 or %g1, %g2, %g1
203a0f4: c4 0f 60 26 ldub [ %i5 + 0x26 ], %g2
203a0f8: 85 28 a0 08 sll %g2, 8, %g2
203a0fc: 82 10 40 02 or %g1, %g2, %g1
203a100: 80 a0 60 38 cmp %g1, 0x38
203a104: 22 80 00 1b be,a 203a170 <rtems_rfs_fs_open+0x378> <== ALWAYS TAKEN
203a108: c4 0f 60 10 ldub [ %i5 + 0x10 ], %g2
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
203a10c: 90 10 20 00 clr %o0 <== NOT EXECUTED
203a110: 7f ff a6 4f call 2023a4c <rtems_rfs_trace> <== NOT EXECUTED
203a114: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
203a118: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
203a11c: 22 80 00 11 be,a 203a160 <rtems_rfs_fs_open+0x368> <== NOT EXECUTED
203a120: 90 10 00 1b mov %i3, %o0 <== 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);
203a124: c2 0f 60 05 ldub [ %i5 + 5 ], %g1 <== NOT EXECUTED
203a128: d2 0f 60 04 ldub [ %i5 + 4 ], %o1 <== NOT EXECUTED
203a12c: 83 28 60 10 sll %g1, 0x10, %g1 <== NOT EXECUTED
203a130: 93 2a 60 18 sll %o1, 0x18, %o1 <== NOT EXECUTED
203a134: 92 12 40 01 or %o1, %g1, %o1 <== NOT EXECUTED
203a138: c2 0f 60 07 ldub [ %i5 + 7 ], %g1 <== 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",
203a13c: 11 00 81 a0 sethi %hi(0x2068000), %o0 <== NOT EXECUTED
read_sb (RTEMS_RFS_SB_OFFSET_VERSION), RTEMS_RFS_VERSION_MASK);
203a140: 92 12 40 01 or %o1, %g1, %o1 <== NOT EXECUTED
203a144: c2 0f 60 06 ldub [ %i5 + 6 ], %g1 <== 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",
203a148: 90 12 22 f8 or %o0, 0x2f8, %o0 <== NOT EXECUTED
read_sb (RTEMS_RFS_SB_OFFSET_VERSION), RTEMS_RFS_VERSION_MASK);
203a14c: 83 28 60 08 sll %g1, 8, %g1 <== 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",
203a150: 94 10 20 00 clr %o2 <== NOT EXECUTED
203a154: 40 00 32 65 call 2046ae8 <printf> <== NOT EXECUTED
203a158: 92 12 40 01 or %o1, %g1, %o1 <== NOT EXECUTED
read_sb (RTEMS_RFS_SB_OFFSET_VERSION), RTEMS_RFS_VERSION_MASK);
rtems_rfs_buffer_handle_close (fs, &handle);
203a15c: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
203a160: 92 07 bf cc add %fp, -52, %o1 <== NOT EXECUTED
203a164: 7f ff ff 08 call 2039d84 <rtems_rfs_buffer_handle_close> <== NOT EXECUTED
203a168: ba 10 20 05 mov 5, %i5 <== NOT EXECUTED
203a16c: 30 80 00 b8 b,a 203a44c <rtems_rfs_fs_open+0x654> <== NOT EXECUTED
return EIO;
}
fs->bad_blocks = read_sb (RTEMS_RFS_SB_OFFSET_BAD_BLOCKS);
203a170: c2 0f 60 11 ldub [ %i5 + 0x11 ], %g1
203a174: 85 28 a0 18 sll %g2, 0x18, %g2
203a178: 83 28 60 10 sll %g1, 0x10, %g1
203a17c: 82 10 80 01 or %g2, %g1, %g1
203a180: c4 0f 60 13 ldub [ %i5 + 0x13 ], %g2
fs->group_count = read_sb (RTEMS_RFS_SB_OFFSET_GROUPS);
fs->group_blocks = read_sb (RTEMS_RFS_SB_OFFSET_GROUP_BLOCKS);
fs->group_inodes = read_sb (RTEMS_RFS_SB_OFFSET_GROUP_INODES);
fs->blocks_per_block =
rtems_rfs_fs_block_size (fs) / sizeof (rtems_rfs_inode_block);
203a184: 91 36 a0 02 srl %i2, 2, %o0
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);
203a188: 82 10 40 02 or %g1, %g2, %g1
203a18c: c4 0f 60 12 ldub [ %i5 + 0x12 ], %g2
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;
203a190: 92 10 00 08 mov %o0, %o1
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);
203a194: 85 28 a0 08 sll %g2, 8, %g2
203a198: 82 10 40 02 or %g1, %g2, %g1
203a19c: c2 26 e0 18 st %g1, [ %i3 + 0x18 ]
fs->max_name_length = read_sb (RTEMS_RFS_SB_OFFSET_MAX_NAME_LENGTH);
203a1a0: c4 0f 60 14 ldub [ %i5 + 0x14 ], %g2
203a1a4: c2 0f 60 15 ldub [ %i5 + 0x15 ], %g1
203a1a8: 85 28 a0 18 sll %g2, 0x18, %g2
203a1ac: 83 28 60 10 sll %g1, 0x10, %g1
203a1b0: 82 10 80 01 or %g2, %g1, %g1
203a1b4: c4 0f 60 17 ldub [ %i5 + 0x17 ], %g2
203a1b8: 82 10 40 02 or %g1, %g2, %g1
203a1bc: c4 0f 60 16 ldub [ %i5 + 0x16 ], %g2
203a1c0: 85 28 a0 08 sll %g2, 8, %g2
203a1c4: 82 10 40 02 or %g1, %g2, %g1
203a1c8: c2 26 e0 1c st %g1, [ %i3 + 0x1c ]
fs->group_count = read_sb (RTEMS_RFS_SB_OFFSET_GROUPS);
203a1cc: c2 0f 60 19 ldub [ %i5 + 0x19 ], %g1
203a1d0: f0 0f 60 18 ldub [ %i5 + 0x18 ], %i0
203a1d4: 83 28 60 10 sll %g1, 0x10, %g1
203a1d8: b1 2e 20 18 sll %i0, 0x18, %i0
203a1dc: b0 16 00 01 or %i0, %g1, %i0
203a1e0: c2 0f 60 1b ldub [ %i5 + 0x1b ], %g1
203a1e4: b0 16 00 01 or %i0, %g1, %i0
203a1e8: c2 0f 60 1a ldub [ %i5 + 0x1a ], %g1
203a1ec: 83 28 60 08 sll %g1, 8, %g1
203a1f0: b0 16 00 01 or %i0, %g1, %i0
203a1f4: f0 26 e0 24 st %i0, [ %i3 + 0x24 ]
fs->group_blocks = read_sb (RTEMS_RFS_SB_OFFSET_GROUP_BLOCKS);
203a1f8: c2 0f 60 1d ldub [ %i5 + 0x1d ], %g1
203a1fc: f2 0f 60 1c ldub [ %i5 + 0x1c ], %i1
203a200: 83 28 60 10 sll %g1, 0x10, %g1
203a204: b3 2e 60 18 sll %i1, 0x18, %i1
203a208: b2 16 40 01 or %i1, %g1, %i1
203a20c: c2 0f 60 1f ldub [ %i5 + 0x1f ], %g1
203a210: b2 16 40 01 or %i1, %g1, %i1
203a214: c2 0f 60 1e ldub [ %i5 + 0x1e ], %g1
203a218: 83 28 60 08 sll %g1, 8, %g1
203a21c: b2 16 40 01 or %i1, %g1, %i1
203a220: f2 26 e0 28 st %i1, [ %i3 + 0x28 ]
fs->group_inodes = read_sb (RTEMS_RFS_SB_OFFSET_GROUP_INODES);
203a224: c2 0f 60 21 ldub [ %i5 + 0x21 ], %g1
203a228: c4 0f 60 20 ldub [ %i5 + 0x20 ], %g2
203a22c: 83 28 60 10 sll %g1, 0x10, %g1
203a230: 85 28 a0 18 sll %g2, 0x18, %g2
203a234: 84 10 80 01 or %g2, %g1, %g2
203a238: c2 0f 60 23 ldub [ %i5 + 0x23 ], %g1
203a23c: 84 10 80 01 or %g2, %g1, %g2
203a240: c2 0f 60 22 ldub [ %i5 + 0x22 ], %g1
fs->blocks_per_block =
203a244: d0 26 e0 34 st %o0, [ %i3 + 0x34 ]
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);
203a248: 83 28 60 08 sll %g1, 8, %g1
203a24c: ba 10 80 01 or %g2, %g1, %i5
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;
203a250: 85 2a 20 02 sll %o0, 2, %g2
203a254: 84 00 80 08 add %g2, %o0, %g2
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);
203a258: fa 26 e0 2c st %i5, [ %i3 + 0x2c ]
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;
203a25c: 7f ff 23 02 call 2002e64 <.umul>
203a260: c4 26 e0 38 st %g2, [ %i3 + 0x38 ]
203a264: 83 2a 20 02 sll %o0, 2, %g1
203a268: 90 00 40 08 add %g1, %o0, %o0
fs->inodes = fs->group_count * fs->group_inodes;
203a26c: 92 10 00 18 mov %i0, %o1
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 =
203a270: d0 26 e0 3c st %o0, [ %i3 + 0x3c ]
fs->blocks_per_block * fs->blocks_per_block * RTEMS_RFS_INODE_BLOCKS;
fs->inodes = fs->group_count * fs->group_inodes;
203a274: 7f ff 22 fc call 2002e64 <.umul>
203a278: 90 10 00 1d mov %i5, %o0
fs->inodes_per_block = fs->block_size / RTEMS_RFS_INODE_SIZE;
203a27c: 92 10 20 38 mov 0x38, %o1
fs->block_map_singly_blocks =
fs->blocks_per_block * RTEMS_RFS_INODE_BLOCKS;
fs->block_map_doubly_blocks =
fs->blocks_per_block * fs->blocks_per_block * RTEMS_RFS_INODE_BLOCKS;
fs->inodes = fs->group_count * fs->group_inodes;
203a280: d0 26 e0 14 st %o0, [ %i3 + 0x14 ]
fs->inodes_per_block = fs->block_size / RTEMS_RFS_INODE_SIZE;
203a284: 40 00 84 bf call 205b580 <.udiv>
203a288: 90 10 00 1a mov %i2, %o0
203a28c: d0 26 e0 30 st %o0, [ %i3 + 0x30 ]
if (fs->group_blocks >
rtems_rfs_bitmap_numof_bits (rtems_rfs_fs_block_size (fs)))
203a290: b5 2e a0 03 sll %i2, 3, %i2
{
rtems_rfs_buffer_handle_close (fs, &handle);
203a294: 90 10 00 1b mov %i3, %o0
fs->inodes = fs->group_count * fs->group_inodes;
fs->inodes_per_block = fs->block_size / RTEMS_RFS_INODE_SIZE;
if (fs->group_blocks >
203a298: 80 a6 40 1a cmp %i1, %i2
203a29c: 08 80 00 0c bleu 203a2cc <rtems_rfs_fs_open+0x4d4> <== ALWAYS TAKEN
203a2a0: 92 07 bf cc add %fp, -52, %o1
rtems_rfs_bitmap_numof_bits (rtems_rfs_fs_block_size (fs)))
{
rtems_rfs_buffer_handle_close (fs, &handle);
203a2a4: 7f ff fe b8 call 2039d84 <rtems_rfs_buffer_handle_close> <== NOT EXECUTED
203a2a8: ba 10 20 05 mov 5, %i5 <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
203a2ac: 90 10 20 00 clr %o0 <== NOT EXECUTED
203a2b0: 7f ff a5 e7 call 2023a4c <rtems_rfs_trace> <== NOT EXECUTED
203a2b4: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
203a2b8: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
203a2bc: 02 80 00 64 be 203a44c <rtems_rfs_fs_open+0x654> <== NOT EXECUTED
203a2c0: 11 00 81 a0 sethi %hi(0x2068000), %o0 <== NOT EXECUTED
printf ("rtems-rfs: read-superblock: groups blocks larger than block bits\n");
203a2c4: 10 80 00 2e b 203a37c <rtems_rfs_fs_open+0x584> <== NOT EXECUTED
203a2c8: 90 12 23 40 or %o0, 0x340, %o0 ! 2068340 <__FUNCTION__.7829+0x1250><== NOT EXECUTED
return EIO;
}
rtems_rfs_buffer_handle_close (fs, &handle);
203a2cc: 7f ff fe ae call 2039d84 <rtems_rfs_buffer_handle_close>
203a2d0: 01 00 00 00 nop
/*
* Change the block size to the value in the superblock.
*/
rc = rtems_rfs_buffer_setblksize (fs, rtems_rfs_fs_block_size (fs));
203a2d4: d2 06 e0 08 ld [ %i3 + 8 ], %o1
203a2d8: 7f ff f5 eb call 2037a84 <rtems_rfs_buffer_setblksize>
203a2dc: 90 10 00 1b mov %i3, %o0
if (rc > 0)
203a2e0: ba 92 20 00 orcc %o0, 0, %i5
203a2e4: 04 80 00 13 ble 203a330 <rtems_rfs_fs_open+0x538> <== ALWAYS TAKEN
203a2e8: 92 07 bf cc add %fp, -52, %o1
{
rtems_rfs_buffer_handle_close (fs, &handle);
203a2ec: 7f ff fe a6 call 2039d84 <rtems_rfs_buffer_handle_close> <== NOT EXECUTED
203a2f0: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
203a2f4: 90 10 20 00 clr %o0 <== NOT EXECUTED
203a2f8: 7f ff a5 d5 call 2023a4c <rtems_rfs_trace> <== NOT EXECUTED
203a2fc: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
203a300: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
203a304: 22 80 00 50 be,a 203a444 <rtems_rfs_fs_open+0x64c> <== NOT EXECUTED
203a308: 80 a7 60 00 cmp %i5, 0 <== NOT EXECUTED
printf ("rtems-rfs: read-superblock: invalid superblock block size%d: %s\n",
203a30c: 40 00 3b 76 call 20490e4 <strerror> <== NOT EXECUTED
203a310: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
203a314: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
203a318: 11 00 81 a0 sethi %hi(0x2068000), %o0 <== NOT EXECUTED
203a31c: 90 12 23 88 or %o0, 0x388, %o0 ! 2068388 <__FUNCTION__.7829+0x1298><== NOT EXECUTED
203a320: 40 00 31 f2 call 2046ae8 <printf> <== NOT EXECUTED
203a324: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
errno = rc;
return -1;
}
rc = rtems_rfs_fs_read_superblock (*fs);
if (rc > 0)
203a328: 10 80 00 47 b 203a444 <rtems_rfs_fs_open+0x64c> <== NOT EXECUTED
203a32c: 80 a7 60 00 cmp %i5, 0 <== NOT EXECUTED
printf ("rtems-rfs: read-superblock: invalid superblock block size%d: %s\n",
rc, strerror (rc));
return rc;
}
fs->groups = calloc (fs->group_count, sizeof (rtems_rfs_group));
203a330: d0 06 e0 24 ld [ %i3 + 0x24 ], %o0
203a334: 7f ff 39 4e call 200886c <calloc>
203a338: 92 10 20 50 mov 0x50, %o1
203a33c: d0 26 e0 20 st %o0, [ %i3 + 0x20 ]
if (!fs->groups)
203a340: b2 10 20 00 clr %i1
203a344: 80 a2 20 00 cmp %o0, 0
203a348: 12 80 00 39 bne 203a42c <rtems_rfs_fs_open+0x634> <== ALWAYS TAKEN
203a34c: b4 10 20 00 clr %i2
{
rtems_rfs_buffer_handle_close (fs, &handle);
203a350: 92 07 bf cc add %fp, -52, %o1 <== NOT EXECUTED
203a354: 7f ff fe 8c call 2039d84 <rtems_rfs_buffer_handle_close> <== NOT EXECUTED
203a358: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
203a35c: 90 10 20 00 clr %o0 <== NOT EXECUTED
203a360: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
203a364: 7f ff a5 ba call 2023a4c <rtems_rfs_trace> <== NOT EXECUTED
203a368: ba 10 20 0c mov 0xc, %i5 <== NOT EXECUTED
203a36c: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
203a370: 02 80 00 37 be 203a44c <rtems_rfs_fs_open+0x654> <== NOT EXECUTED
203a374: 11 00 81 a0 sethi %hi(0x2068000), %o0 <== NOT EXECUTED
printf ("rtems-rfs: read-superblock: no memory for group table\n");
203a378: 90 12 23 d0 or %o0, 0x3d0, %o0 ! 20683d0 <__FUNCTION__.7829+0x12e0><== NOT EXECUTED
203a37c: 40 00 32 73 call 2046d48 <puts> <== NOT EXECUTED
203a380: 01 00 00 00 nop <== NOT EXECUTED
203a384: 30 80 00 32 b,a 203a44c <rtems_rfs_fs_open+0x654> <== 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),
203a388: 90 10 00 1a mov %i2, %o0
203a38c: 7f ff 22 b6 call 2002e64 <.umul>
203a390: 92 10 00 1d mov %i5, %o1
* 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,
203a394: d8 06 e0 20 ld [ %i3 + 0x20 ], %o4
203a398: d6 06 e0 2c ld [ %i3 + 0x2c ], %o3
rtems_rfs_fs_block (fs, group, 0),
203a39c: 92 02 20 01 add %o0, 1, %o1
* 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,
203a3a0: 94 10 00 1d mov %i5, %o2
203a3a4: 98 03 00 19 add %o4, %i1, %o4
203a3a8: 90 10 00 1b mov %i3, %o0
203a3ac: 40 00 04 06 call 203b3c4 <rtems_rfs_group_open>
203a3b0: b2 06 60 50 add %i1, 0x50, %i1
rtems_rfs_fs_block (fs, group, 0),
fs->group_blocks,
fs->group_inodes,
&fs->groups[group]);
if (rc > 0)
203a3b4: 80 a2 20 00 cmp %o0, 0
203a3b8: 04 80 00 1c ble 203a428 <rtems_rfs_fs_open+0x630> <== ALWAYS TAKEN
203a3bc: ba 10 00 08 mov %o0, %i5
203a3c0: b0 10 20 00 clr %i0 <== NOT EXECUTED
203a3c4: 10 80 00 07 b 203a3e0 <rtems_rfs_fs_open+0x5e8> <== NOT EXECUTED
203a3c8: b2 10 20 00 clr %i1 <== NOT EXECUTED
{
int g;
for (g = 0; g < group; g++)
rtems_rfs_group_close (fs, &fs->groups[g]);
203a3cc: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
203a3d0: 92 02 40 18 add %o1, %i0, %o1 <== NOT EXECUTED
203a3d4: 40 00 04 7a call 203b5bc <rtems_rfs_group_close> <== NOT EXECUTED
203a3d8: b2 06 60 01 inc %i1 <== NOT EXECUTED
203a3dc: b0 06 20 50 add %i0, 0x50, %i0 <== NOT EXECUTED
fs->group_inodes,
&fs->groups[group]);
if (rc > 0)
{
int g;
for (g = 0; g < group; g++)
203a3e0: 80 a6 40 1a cmp %i1, %i2 <== NOT EXECUTED
203a3e4: 26 bf ff fa bl,a 203a3cc <rtems_rfs_fs_open+0x5d4> <== NOT EXECUTED
203a3e8: d2 06 e0 20 ld [ %i3 + 0x20 ], %o1 <== NOT EXECUTED
rtems_rfs_group_close (fs, &fs->groups[g]);
rtems_rfs_buffer_handle_close (fs, &handle);
203a3ec: 92 07 bf cc add %fp, -52, %o1 <== NOT EXECUTED
203a3f0: 7f ff fe 65 call 2039d84 <rtems_rfs_buffer_handle_close> <== NOT EXECUTED
203a3f4: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
203a3f8: 90 10 20 00 clr %o0 <== NOT EXECUTED
203a3fc: 7f ff a5 94 call 2023a4c <rtems_rfs_trace> <== NOT EXECUTED
203a400: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
203a404: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
203a408: 22 80 00 0f be,a 203a444 <rtems_rfs_fs_open+0x64c> <== NOT EXECUTED
203a40c: 80 a7 60 00 cmp %i5, 0 <== NOT EXECUTED
printf ("rtems-rfs: read-superblock: no memory for group table%d: %s\n",
203a410: 40 00 3b 35 call 20490e4 <strerror> <== NOT EXECUTED
203a414: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
203a418: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
203a41c: 11 00 81 a1 sethi %hi(0x2068400), %o0 <== NOT EXECUTED
203a420: 10 bf ff c0 b 203a320 <rtems_rfs_fs_open+0x528> <== NOT EXECUTED
203a424: 90 12 20 08 or %o0, 8, %o0 ! 2068408 <__FUNCTION__.7829+0x1318><== 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++)
203a428: b4 06 a0 01 inc %i2
203a42c: c2 06 e0 24 ld [ %i3 + 0x24 ], %g1
203a430: 80 a6 80 01 cmp %i2, %g1
203a434: 26 bf ff d5 bl,a 203a388 <rtems_rfs_fs_open+0x590>
203a438: fa 06 e0 28 ld [ %i3 + 0x28 ], %i5
rc, strerror (rc));
errno = rc;
return -1;
}
rc = rtems_rfs_inode_open (*fs, RTEMS_RFS_ROOT_INO, &inode, true);
203a43c: 10 80 00 14 b 203a48c <rtems_rfs_fs_open+0x694>
203a440: d0 07 00 00 ld [ %i4 ], %o0
errno = rc;
return -1;
}
rc = rtems_rfs_fs_read_superblock (*fs);
if (rc > 0)
203a444: 22 80 00 12 be,a 203a48c <rtems_rfs_fs_open+0x694> <== NOT EXECUTED
203a448: d0 07 00 00 ld [ %i4 ], %o0 <== NOT EXECUTED
{
rtems_rfs_buffer_close (*fs);
203a44c: 7f ff f5 c9 call 2037b70 <rtems_rfs_buffer_close> <== NOT EXECUTED
203a450: d0 07 00 00 ld [ %i4 ], %o0 <== NOT EXECUTED
free (*fs);
203a454: 7f ff 39 ea call 2008bfc <free> <== NOT EXECUTED
203a458: d0 07 00 00 ld [ %i4 ], %o0 <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
203a45c: 90 10 20 00 clr %o0 <== NOT EXECUTED
203a460: 7f ff a5 7b call 2023a4c <rtems_rfs_trace> <== NOT EXECUTED
203a464: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
203a468: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
203a46c: 02 bf fe b6 be 2039f44 <rtems_rfs_fs_open+0x14c> <== NOT EXECUTED
203a470: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: open: reading superblock: %d: %s\n",
203a474: 40 00 3b 1c call 20490e4 <strerror> <== NOT EXECUTED
203a478: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
203a47c: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
203a480: 11 00 81 a1 sethi %hi(0x2068400), %o0 <== NOT EXECUTED
203a484: 10 bf fe ae b 2039f3c <rtems_rfs_fs_open+0x144> <== NOT EXECUTED
203a488: 90 12 20 48 or %o0, 0x48, %o0 ! 2068448 <__FUNCTION__.7829+0x1358><== NOT EXECUTED
rc, strerror (rc));
errno = rc;
return -1;
}
rc = rtems_rfs_inode_open (*fs, RTEMS_RFS_ROOT_INO, &inode, true);
203a48c: 92 10 20 01 mov 1, %o1
203a490: 94 07 bf d8 add %fp, -40, %o2
203a494: 40 00 05 c3 call 203bba0 <rtems_rfs_inode_open>
203a498: 96 10 20 01 mov 1, %o3
if (rc > 0)
203a49c: ba 92 20 00 orcc %o0, 0, %i5
203a4a0: 04 80 00 12 ble 203a4e8 <rtems_rfs_fs_open+0x6f0> <== ALWAYS TAKEN
203a4a4: d0 07 00 00 ld [ %i4 ], %o0
{
rtems_rfs_buffer_close (*fs);
203a4a8: 7f ff f5 b2 call 2037b70 <rtems_rfs_buffer_close> <== NOT EXECUTED
203a4ac: 01 00 00 00 nop <== NOT EXECUTED
free (*fs);
203a4b0: 7f ff 39 d3 call 2008bfc <free> <== NOT EXECUTED
203a4b4: d0 07 00 00 ld [ %i4 ], %o0 <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
203a4b8: 90 10 20 00 clr %o0 <== NOT EXECUTED
203a4bc: 7f ff a5 64 call 2023a4c <rtems_rfs_trace> <== NOT EXECUTED
203a4c0: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
203a4c4: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
203a4c8: 02 bf fe 9f be 2039f44 <rtems_rfs_fs_open+0x14c> <== NOT EXECUTED
203a4cc: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: open: reading root inode: %d: %s\n",
203a4d0: 40 00 3b 05 call 20490e4 <strerror> <== NOT EXECUTED
203a4d4: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
203a4d8: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
203a4dc: 11 00 81 a1 sethi %hi(0x2068400), %o0 <== NOT EXECUTED
203a4e0: 10 bf fe 97 b 2039f3c <rtems_rfs_fs_open+0x144> <== NOT EXECUTED
203a4e4: 90 12 20 78 or %o0, 0x78, %o0 ! 2068478 <__FUNCTION__.7829+0x1388><== NOT EXECUTED
rc, strerror (rc));
errno = rc;
return -1;
}
if (((*fs)->flags & RTEMS_RFS_FS_FORCE_OPEN) == 0)
203a4e8: c2 02 00 00 ld [ %o0 ], %g1
203a4ec: 80 88 60 04 btst 4, %g1
203a4f0: 12 80 00 23 bne 203a57c <rtems_rfs_fs_open+0x784>
203a4f4: c4 07 bf e4 ld [ %fp + -28 ], %g2
* @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);
203a4f8: c2 08 a0 02 ldub [ %g2 + 2 ], %g1
203a4fc: c4 08 a0 03 ldub [ %g2 + 3 ], %g2
203a500: 83 28 60 08 sll %g1, 8, %g1
203a504: 82 10 40 02 or %g1, %g2, %g1
{
mode = rtems_rfs_inode_get_mode (&inode);
if ((mode == 0xffff) || !RTEMS_RFS_S_ISDIR (mode))
203a508: 05 3f ff c0 sethi %hi(0xffff0000), %g2
203a50c: 87 28 60 10 sll %g1, 0x10, %g3
203a510: 80 a0 c0 02 cmp %g3, %g2
203a514: 02 80 00 07 be 203a530 <rtems_rfs_fs_open+0x738> <== NEVER TAKEN
203a518: 05 00 00 3c sethi %hi(0xf000), %g2
203a51c: 82 08 40 02 and %g1, %g2, %g1
203a520: 05 00 00 10 sethi %hi(0x4000), %g2
203a524: 80 a0 40 02 cmp %g1, %g2
203a528: 02 80 00 15 be 203a57c <rtems_rfs_fs_open+0x784> <== ALWAYS TAKEN
203a52c: 01 00 00 00 nop
{
rtems_rfs_inode_close (*fs, &inode);
203a530: 40 00 06 0e call 203bd68 <rtems_rfs_inode_close> <== NOT EXECUTED
203a534: 92 07 bf d8 add %fp, -40, %o1 <== NOT EXECUTED
rtems_rfs_buffer_close (*fs);
203a538: 7f ff f5 8e call 2037b70 <rtems_rfs_buffer_close> <== NOT EXECUTED
203a53c: d0 07 00 00 ld [ %i4 ], %o0 <== NOT EXECUTED
free (*fs);
203a540: 7f ff 39 af call 2008bfc <free> <== NOT EXECUTED
203a544: d0 07 00 00 ld [ %i4 ], %o0 <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
203a548: 90 10 20 00 clr %o0 <== NOT EXECUTED
203a54c: 7f ff a5 40 call 2023a4c <rtems_rfs_trace> <== NOT EXECUTED
203a550: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
203a554: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
203a558: 02 80 00 04 be 203a568 <rtems_rfs_fs_open+0x770> <== NOT EXECUTED
203a55c: 11 00 81 a1 sethi %hi(0x2068400), %o0 <== NOT EXECUTED
printf ("rtems-rfs: open: invalid root inode mode\n");
203a560: 40 00 31 fa call 2046d48 <puts> <== NOT EXECUTED
203a564: 90 12 20 a8 or %o0, 0xa8, %o0 ! 20684a8 <__FUNCTION__.7829+0x13b8><== NOT EXECUTED
errno = EIO;
203a568: 40 00 1f 21 call 20421ec <__errno> <== NOT EXECUTED
203a56c: 01 00 00 00 nop <== NOT EXECUTED
203a570: 82 10 20 05 mov 5, %g1 ! 5 <PROM_START+0x5> <== NOT EXECUTED
203a574: 10 bf fe 77 b 2039f50 <rtems_rfs_fs_open+0x158> <== NOT EXECUTED
203a578: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
return -1;
}
}
rc = rtems_rfs_inode_close (*fs, &inode);
203a57c: 40 00 05 fb call 203bd68 <rtems_rfs_inode_close>
203a580: 92 07 bf d8 add %fp, -40, %o1
if (rc > 0)
203a584: ba 92 20 00 orcc %o0, 0, %i5
203a588: 04 80 00 12 ble 203a5d0 <rtems_rfs_fs_open+0x7d8> <== ALWAYS TAKEN
203a58c: 01 00 00 00 nop
{
rtems_rfs_buffer_close (*fs);
203a590: 7f ff f5 78 call 2037b70 <rtems_rfs_buffer_close> <== NOT EXECUTED
203a594: d0 07 00 00 ld [ %i4 ], %o0 <== NOT EXECUTED
free (*fs);
203a598: 7f ff 39 99 call 2008bfc <free> <== NOT EXECUTED
203a59c: d0 07 00 00 ld [ %i4 ], %o0 <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
203a5a0: 90 10 20 00 clr %o0 <== NOT EXECUTED
203a5a4: 7f ff a5 2a call 2023a4c <rtems_rfs_trace> <== NOT EXECUTED
203a5a8: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
203a5ac: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
203a5b0: 02 bf fe 65 be 2039f44 <rtems_rfs_fs_open+0x14c> <== NOT EXECUTED
203a5b4: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: open: closing root inode: %d: %s\n", rc, strerror (rc));
203a5b8: 40 00 3a cb call 20490e4 <strerror> <== NOT EXECUTED
203a5bc: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
203a5c0: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
203a5c4: 11 00 81 a1 sethi %hi(0x2068400), %o0 <== NOT EXECUTED
203a5c8: 10 bf fe 5d b 2039f3c <rtems_rfs_fs_open+0x144> <== NOT EXECUTED
203a5cc: 90 12 20 d8 or %o0, 0xd8, %o0 ! 20684d8 <__FUNCTION__.7829+0x13e8><== NOT EXECUTED
errno = rc;
return -1;
}
errno = 0;
203a5d0: 40 00 1f 07 call 20421ec <__errno>
203a5d4: b0 10 20 00 clr %i0
203a5d8: c0 22 00 00 clr [ %o0 ]
return 0;
}
203a5dc: 81 c7 e0 08 ret
203a5e0: 81 e8 00 00 restore
02039dac <rtems_rfs_fs_size>:
#include <rtems/rfs/rtems-rfs-inode.h>
#include <rtems/rfs/rtems-rfs-trace.h>
uint64_t
rtems_rfs_fs_size (rtems_rfs_file_system* fs)
{
2039dac: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED
uint64_t blocks = rtems_rfs_fs_blocks (fs);
uint64_t block_size = rtems_rfs_fs_block_size (fs);
return blocks * block_size;
2039db0: d2 06 20 08 ld [ %i0 + 8 ], %o1 <== NOT EXECUTED
2039db4: d6 06 20 04 ld [ %i0 + 4 ], %o3 <== NOT EXECUTED
2039db8: 94 10 20 00 clr %o2 <== NOT EXECUTED
2039dbc: 40 00 87 49 call 205bae0 <__muldi3> <== NOT EXECUTED
2039dc0: 90 10 20 00 clr %o0 <== NOT EXECUTED
}
2039dc4: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED
2039dc8: 81 c7 e0 08 ret <== NOT EXECUTED
2039dcc: 93 e8 00 09 restore %g0, %o1, %o1 <== NOT EXECUTED
0203b64c <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)
{
203b64c: 9d e3 bf 98 save %sp, -104, %sp
rtems_rfs_bitmap_bit bit;
int offset;
bool updown;
int direction;
if (inode)
203b650: 80 a6 a0 00 cmp %i2, 0
203b654: 02 80 00 05 be 203b668 <rtems_rfs_group_bitmap_alloc+0x1c>
203b658: ba 10 00 18 mov %i0, %i5
{
size = fs->group_inodes;
203b65c: e2 06 20 2c ld [ %i0 + 0x2c ], %l1
goal -= RTEMS_RFS_ROOT_INO;
203b660: 10 80 00 03 b 203b66c <rtems_rfs_group_bitmap_alloc+0x20>
203b664: b2 06 7f ff add %i1, -1, %i1
}
else
size = fs->group_blocks;
203b668: e2 06 20 28 ld [ %i0 + 0x28 ], %l1
group_start = goal / size;
203b66c: 92 10 00 11 mov %l1, %o1
203b670: 40 00 7f c4 call 205b580 <.udiv>
203b674: 90 10 00 19 mov %i1, %o0
bit = (rtems_rfs_bitmap_bit) (goal % size);
203b678: 92 10 00 11 mov %l1, %o1
goal -= RTEMS_RFS_ROOT_INO;
}
else
size = fs->group_blocks;
group_start = goal / size;
203b67c: a8 10 00 08 mov %o0, %l4
bit = (rtems_rfs_bitmap_bit) (goal % size);
offset = 0;
updown = true;
direction = 1;
203b680: b8 10 20 01 mov 1, %i4
}
else
size = fs->group_blocks;
group_start = goal / size;
bit = (rtems_rfs_bitmap_bit) (goal % size);
203b684: 90 10 00 19 mov %i1, %o0
203b688: 40 00 80 6a call 205b830 <.urem>
203b68c: a4 10 20 01 mov 1, %l2
offset = 0;
203b690: a0 10 20 00 clr %l0
}
else
size = fs->group_blocks;
group_start = goal / size;
bit = (rtems_rfs_bitmap_bit) (goal % size);
203b694: d0 27 bf fc st %o0, [ %fp + -4 ]
*/
while (true)
{
rtems_rfs_bitmap_control* bitmap;
int group;
bool allocated = false;
203b698: c0 2f bf fb clrb [ %fp + -5 ]
/*
* 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);
203b69c: 90 10 00 1c mov %i4, %o0
203b6a0: 7f ff 1d f1 call 2002e64 <.umul>
203b6a4: 92 10 00 10 mov %l0, %o1
if (offset)
203b6a8: 80 a4 20 00 cmp %l0, 0
203b6ac: 02 80 00 07 be 203b6c8 <rtems_rfs_group_bitmap_alloc+0x7c>
203b6b0: b2 05 00 08 add %l4, %o0, %i1
bit = direction > 0 ? 0 : size - 1;
203b6b4: 80 a7 20 00 cmp %i4, 0
203b6b8: 14 80 00 03 bg 203b6c4 <rtems_rfs_group_bitmap_alloc+0x78>
203b6bc: 82 10 20 00 clr %g1
203b6c0: 82 04 7f ff add %l1, -1, %g1
203b6c4: c2 27 bf fc st %g1, [ %fp + -4 ]
/*
* 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))
203b6c8: 80 a6 60 00 cmp %i1, 0
203b6cc: 06 80 00 07 bl 203b6e8 <rtems_rfs_group_bitmap_alloc+0x9c>
203b6d0: 80 8c a0 ff btst 0xff, %l2
203b6d4: c2 07 60 24 ld [ %i5 + 0x24 ], %g1
203b6d8: 80 a6 40 01 cmp %i1, %g1
203b6dc: 26 80 00 0a bl,a 203b704 <rtems_rfs_group_bitmap_alloc+0xb8>
203b6e0: c2 07 60 20 ld [ %i5 + 0x20 ], %g1
{
if (!updown)
203b6e4: 80 8c a0 ff btst 0xff, %l2
203b6e8: 02 80 00 50 be 203b828 <rtems_rfs_group_bitmap_alloc+0x1dc>
203b6ec: 80 a7 20 00 cmp %i4, 0
break;
direction = direction > 0 ? -1 : 1;
203b6f0: 24 80 00 03 ble,a 203b6fc <rtems_rfs_group_bitmap_alloc+0xb0><== ALWAYS TAKEN
203b6f4: b8 10 20 01 mov 1, %i4
203b6f8: b8 10 3f ff mov -1, %i4 <== NOT EXECUTED
updown = false;
203b6fc: 10 bf ff e7 b 203b698 <rtems_rfs_group_bitmap_alloc+0x4c>
203b700: a4 10 20 00 clr %l2
203b704: a7 2e 60 04 sll %i1, 4, %l3
203b708: 85 2e 60 06 sll %i1, 6, %g2
continue;
}
if (inode)
203b70c: 80 a6 a0 00 cmp %i2, 0
bitmap = &fs->groups[group].inode_bitmap;
203b710: a6 04 c0 02 add %l3, %g2, %l3
direction = direction > 0 ? -1 : 1;
updown = false;
continue;
}
if (inode)
203b714: 02 80 00 04 be 203b724 <rtems_rfs_group_bitmap_alloc+0xd8>
203b718: a6 00 40 13 add %g1, %l3, %l3
bitmap = &fs->groups[group].inode_bitmap;
203b71c: 10 80 00 03 b 203b728 <rtems_rfs_group_bitmap_alloc+0xdc>
203b720: a6 04 e0 2c add %l3, 0x2c, %l3
else
bitmap = &fs->groups[group].block_bitmap;
203b724: a6 04 e0 08 add %l3, 8, %l3
rc = rtems_rfs_bitmap_map_alloc (bitmap, bit, &allocated, &bit);
203b728: d2 07 bf fc ld [ %fp + -4 ], %o1
203b72c: 90 10 00 13 mov %l3, %o0
203b730: 94 07 bf fb add %fp, -5, %o2
203b734: 40 00 18 4a call 204185c <rtems_rfs_bitmap_map_alloc>
203b738: 96 07 bf fc add %fp, -4, %o3
if (rc > 0)
203b73c: b0 92 20 00 orcc %o0, 0, %i0
203b740: 14 80 00 45 bg 203b854 <rtems_rfs_group_bitmap_alloc+0x208><== NEVER TAKEN
203b744: 01 00 00 00 nop
return rc;
if (rtems_rfs_fs_release_bitmaps (fs))
203b748: c2 07 40 00 ld [ %i5 ], %g1
203b74c: 80 88 60 01 btst 1, %g1
203b750: 12 80 00 06 bne 203b768 <rtems_rfs_group_bitmap_alloc+0x11c><== NEVER TAKEN
203b754: c2 0f bf fb ldub [ %fp + -5 ], %g1
rtems_rfs_bitmap_release_buffer (fs, bitmap);
203b758: d2 04 c0 00 ld [ %l3 ], %o1
203b75c: 7f ff ef 10 call 203739c <rtems_rfs_buffer_handle_release>
203b760: 90 10 00 1d mov %i5, %o0
if (allocated)
203b764: c2 0f bf fb ldub [ %fp + -5 ], %g1
203b768: 80 a0 60 00 cmp %g1, 0
203b76c: 02 80 00 27 be 203b808 <rtems_rfs_group_bitmap_alloc+0x1bc>
203b770: 80 8c a0 ff btst 0xff, %l2
{
if (inode)
203b774: 80 a6 a0 00 cmp %i2, 0
203b778: 02 80 00 09 be 203b79c <rtems_rfs_group_bitmap_alloc+0x150>
203b77c: c2 07 bf fc ld [ %fp + -4 ], %g1
*result = rtems_rfs_group_inode (fs, group, bit);
203b780: d2 07 60 2c ld [ %i5 + 0x2c ], %o1
203b784: b8 00 60 01 add %g1, 1, %i4
203b788: 7f ff 1d b7 call 2002e64 <.umul>
203b78c: 90 10 00 19 mov %i1, %o0
203b790: 90 07 00 08 add %i4, %o0, %o0
203b794: 10 80 00 09 b 203b7b8 <rtems_rfs_group_bitmap_alloc+0x16c>
203b798: d0 26 c0 00 st %o0, [ %i3 ]
else
*result = rtems_rfs_group_block (&fs->groups[group], bit);
203b79c: c4 07 60 20 ld [ %i5 + 0x20 ], %g2
203b7a0: 87 2e 60 04 sll %i1, 4, %g3
203b7a4: b3 2e 60 06 sll %i1, 6, %i1
203b7a8: b2 00 c0 19 add %g3, %i1, %i1
203b7ac: c4 00 80 19 ld [ %g2 + %i1 ], %g2
203b7b0: 82 00 40 02 add %g1, %g2, %g1
203b7b4: c2 26 c0 00 st %g1, [ %i3 ]
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_BITMAPS))
203b7b8: 90 10 20 00 clr %o0
203b7bc: 13 00 00 80 sethi %hi(0x20000), %o1
203b7c0: 7f ff a0 a3 call 2023a4c <rtems_rfs_trace>
203b7c4: b0 10 20 00 clr %i0
203b7c8: 80 8a 20 ff btst 0xff, %o0
203b7cc: 02 80 00 0d be 203b800 <rtems_rfs_group_bitmap_alloc+0x1b4><== ALWAYS TAKEN
203b7d0: 80 a6 a0 00 cmp %i2, 0
printf ("rtems-rfs: group-bitmap-alloc: %s allocated: %" PRId32 "\n",
203b7d4: 22 80 00 05 be,a 203b7e8 <rtems_rfs_group_bitmap_alloc+0x19c><== NOT EXECUTED
203b7d8: 13 00 81 8c sethi %hi(0x2063000), %o1 <== NOT EXECUTED
203b7dc: 13 00 81 8d sethi %hi(0x2063400), %o1 <== NOT EXECUTED
203b7e0: 10 80 00 03 b 203b7ec <rtems_rfs_group_bitmap_alloc+0x1a0><== NOT EXECUTED
203b7e4: 92 12 60 58 or %o1, 0x58, %o1 ! 2063458 <rtems_rfs_rtems_eval_config+0x920><== NOT EXECUTED
203b7e8: 92 12 63 48 or %o1, 0x348, %o1 <== NOT EXECUTED
203b7ec: d4 06 c0 00 ld [ %i3 ], %o2 <== NOT EXECUTED
203b7f0: 11 00 81 a3 sethi %hi(0x2068c00), %o0 <== NOT EXECUTED
inode ? "inode" : "block", *result);
return 0;
203b7f4: b0 10 20 00 clr %i0 <== NOT EXECUTED
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))
printf ("rtems-rfs: group-bitmap-alloc: %s allocated: %" PRId32 "\n",
203b7f8: 40 00 2c bc call 2046ae8 <printf> <== NOT EXECUTED
203b7fc: 90 12 23 20 or %o0, 0x320, %o0 <== NOT EXECUTED
203b800: 81 c7 e0 08 ret
203b804: 81 e8 00 00 restore
inode ? "inode" : "block", *result);
return 0;
}
if (updown)
203b808: 22 bf ff a4 be,a 203b698 <rtems_rfs_group_bitmap_alloc+0x4c><== NEVER TAKEN
203b80c: a0 04 20 01 inc %l0 <== NOT EXECUTED
direction = direction > 0 ? -1 : 1;
203b810: 80 a7 20 00 cmp %i4, 0
203b814: 24 80 00 03 ble,a 203b820 <rtems_rfs_group_bitmap_alloc+0x1d4><== NEVER TAKEN
203b818: b8 10 20 01 mov 1, %i4 <== NOT EXECUTED
203b81c: b8 10 3f ff mov -1, %i4
offset++;
203b820: 10 bf ff 9e b 203b698 <rtems_rfs_group_bitmap_alloc+0x4c>
203b824: a0 04 20 01 inc %l0
}
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_BITMAPS))
203b828: 90 10 20 00 clr %o0
203b82c: 7f ff a0 88 call 2023a4c <rtems_rfs_trace>
203b830: 13 00 00 80 sethi %hi(0x20000), %o1
203b834: 80 8a 20 ff btst 0xff, %o0
203b838: 12 80 00 04 bne 203b848 <rtems_rfs_group_bitmap_alloc+0x1fc><== NEVER TAKEN
203b83c: 11 00 81 a3 sethi %hi(0x2068c00), %o0
printf ("rtems-rfs: group-bitmap-alloc: no blocks available\n");
return ENOSPC;
203b840: 81 c7 e0 08 ret
203b844: 91 e8 20 1c restore %g0, 0x1c, %o0
offset++;
}
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_BITMAPS))
printf ("rtems-rfs: group-bitmap-alloc: no blocks available\n");
203b848: 40 00 2d 40 call 2046d48 <puts> <== NOT EXECUTED
203b84c: 90 12 23 58 or %o0, 0x358, %o0 <== NOT EXECUTED
return ENOSPC;
203b850: b0 10 20 1c mov 0x1c, %i0 <== NOT EXECUTED
}
203b854: 81 c7 e0 08 ret <== NOT EXECUTED
203b858: 81 e8 00 00 restore <== NOT EXECUTED
0203b85c <rtems_rfs_group_bitmap_free>:
int
rtems_rfs_group_bitmap_free (rtems_rfs_file_system* fs,
bool inode,
rtems_rfs_bitmap_bit no)
{
203b85c: 9d e3 bf a0 save %sp, -96, %sp
unsigned int group;
rtems_rfs_bitmap_bit bit;
size_t size;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_BITMAPS))
203b860: 90 10 20 00 clr %o0
203b864: 13 00 00 80 sethi %hi(0x20000), %o1
203b868: 7f ff a0 79 call 2023a4c <rtems_rfs_trace>
203b86c: ba 10 00 18 mov %i0, %i5
203b870: 80 8a 20 ff btst 0xff, %o0
203b874: 02 80 00 0d be 203b8a8 <rtems_rfs_group_bitmap_free+0x4c> <== ALWAYS TAKEN
203b878: 80 a6 60 00 cmp %i1, 0
printf ("rtems-rfs: group-bitmap-free: %s free: %" PRId32 "\n",
203b87c: 22 80 00 05 be,a 203b890 <rtems_rfs_group_bitmap_free+0x34><== NOT EXECUTED
203b880: 13 00 81 8c sethi %hi(0x2063000), %o1 <== NOT EXECUTED
203b884: 13 00 81 8d sethi %hi(0x2063400), %o1 <== NOT EXECUTED
203b888: 10 80 00 03 b 203b894 <rtems_rfs_group_bitmap_free+0x38> <== NOT EXECUTED
203b88c: 92 12 60 58 or %o1, 0x58, %o1 ! 2063458 <rtems_rfs_rtems_eval_config+0x920><== NOT EXECUTED
203b890: 92 12 63 48 or %o1, 0x348, %o1 <== NOT EXECUTED
203b894: 11 00 81 a3 sethi %hi(0x2068c00), %o0 <== NOT EXECUTED
203b898: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED
203b89c: 40 00 2c 93 call 2046ae8 <printf> <== NOT EXECUTED
203b8a0: 90 12 23 90 or %o0, 0x390, %o0 <== NOT EXECUTED
inode ? "inode" : "block", no);
if (inode)
203b8a4: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED
203b8a8: 02 80 00 04 be 203b8b8 <rtems_rfs_group_bitmap_free+0x5c>
203b8ac: b4 06 bf ff add %i2, -1, %i2
{
no -= RTEMS_RFS_ROOT_INO;
size = fs->group_inodes;
203b8b0: 10 80 00 03 b 203b8bc <rtems_rfs_group_bitmap_free+0x60>
203b8b4: f6 07 60 2c ld [ %i5 + 0x2c ], %i3
}
else
{
no -= RTEMS_RFS_SUPERBLOCK_SIZE;
size = fs->group_blocks;
203b8b8: f6 07 60 28 ld [ %i5 + 0x28 ], %i3
}
group = no / size;
203b8bc: 92 10 00 1b mov %i3, %o1
203b8c0: 40 00 7f 30 call 205b580 <.udiv>
203b8c4: 90 10 00 1a mov %i2, %o0
bit = (rtems_rfs_bitmap_bit) (no % size);
203b8c8: 92 10 00 1b mov %i3, %o1
{
no -= RTEMS_RFS_SUPERBLOCK_SIZE;
size = fs->group_blocks;
}
group = no / size;
203b8cc: b0 10 00 08 mov %o0, %i0
bit = (rtems_rfs_bitmap_bit) (no % size);
203b8d0: 40 00 7f d8 call 205b830 <.urem>
203b8d4: 90 10 00 1a mov %i2, %o0
203b8d8: c2 07 60 20 ld [ %i5 + 0x20 ], %g1
203b8dc: b9 2e 20 04 sll %i0, 4, %i4
203b8e0: 92 10 00 08 mov %o0, %o1
203b8e4: b1 2e 20 06 sll %i0, 6, %i0
if (inode)
203b8e8: 80 a6 60 00 cmp %i1, 0
bitmap = &fs->groups[group].inode_bitmap;
203b8ec: b8 07 00 18 add %i4, %i0, %i4
}
group = no / size;
bit = (rtems_rfs_bitmap_bit) (no % size);
if (inode)
203b8f0: 02 80 00 04 be 203b900 <rtems_rfs_group_bitmap_free+0xa4>
203b8f4: b8 00 40 1c add %g1, %i4, %i4
bitmap = &fs->groups[group].inode_bitmap;
203b8f8: 10 80 00 03 b 203b904 <rtems_rfs_group_bitmap_free+0xa8>
203b8fc: b8 07 20 2c add %i4, 0x2c, %i4
else
bitmap = &fs->groups[group].block_bitmap;
203b900: b8 07 20 08 add %i4, 8, %i4
rc = rtems_rfs_bitmap_map_clear (bitmap, bit);
203b904: 40 00 17 4a call 204162c <rtems_rfs_bitmap_map_clear>
203b908: 90 10 00 1c mov %i4, %o0
rtems_rfs_bitmap_release_buffer (fs, bitmap);
203b90c: d2 07 00 00 ld [ %i4 ], %o1
if (inode)
bitmap = &fs->groups[group].inode_bitmap;
else
bitmap = &fs->groups[group].block_bitmap;
rc = rtems_rfs_bitmap_map_clear (bitmap, bit);
203b910: b0 10 00 08 mov %o0, %i0
rtems_rfs_bitmap_release_buffer (fs, bitmap);
203b914: 7f ff ee a2 call 203739c <rtems_rfs_buffer_handle_release>
203b918: 90 10 00 1d mov %i5, %o0
return rc;
}
203b91c: 81 c7 e0 08 ret
203b920: 81 e8 00 00 restore
0203b924 <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)
{
203b924: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED
unsigned int group;
rtems_rfs_bitmap_bit bit;
size_t size;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_BITMAPS))
203b928: 90 10 20 00 clr %o0 <== NOT EXECUTED
203b92c: 13 00 00 80 sethi %hi(0x20000), %o1 <== NOT EXECUTED
203b930: 7f ff a0 47 call 2023a4c <rtems_rfs_trace> <== NOT EXECUTED
203b934: ba 10 00 18 mov %i0, %i5 <== NOT EXECUTED
203b938: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
203b93c: 02 80 00 0d be 203b970 <rtems_rfs_group_bitmap_test+0x4c> <== NOT EXECUTED
203b940: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED
printf ("rtems-rfs: group-bitmap-test: %s test: %" PRId32 "\n",
203b944: 22 80 00 05 be,a 203b958 <rtems_rfs_group_bitmap_test+0x34><== NOT EXECUTED
203b948: 13 00 81 8c sethi %hi(0x2063000), %o1 <== NOT EXECUTED
203b94c: 13 00 81 8d sethi %hi(0x2063400), %o1 <== NOT EXECUTED
203b950: 10 80 00 03 b 203b95c <rtems_rfs_group_bitmap_test+0x38> <== NOT EXECUTED
203b954: 92 12 60 58 or %o1, 0x58, %o1 ! 2063458 <rtems_rfs_rtems_eval_config+0x920><== NOT EXECUTED
203b958: 92 12 63 48 or %o1, 0x348, %o1 <== NOT EXECUTED
203b95c: 11 00 81 a3 sethi %hi(0x2068c00), %o0 <== NOT EXECUTED
203b960: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED
203b964: 40 00 2c 61 call 2046ae8 <printf> <== NOT EXECUTED
203b968: 90 12 23 c0 or %o0, 0x3c0, %o0 <== NOT EXECUTED
inode ? "inode" : "block", no);
if (inode)
203b96c: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED
203b970: 22 80 00 0b be,a 203b99c <rtems_rfs_group_bitmap_test+0x78><== NOT EXECUTED
203b974: c2 07 60 04 ld [ %i5 + 4 ], %g1 <== NOT EXECUTED
{
if ((no < RTEMS_RFS_ROOT_INO) || (no > rtems_rfs_fs_inodes (fs)))
203b978: 80 a6 a0 00 cmp %i2, 0 <== NOT EXECUTED
203b97c: 04 80 00 25 ble 203ba10 <rtems_rfs_group_bitmap_test+0xec><== NOT EXECUTED
203b980: b0 10 20 16 mov 0x16, %i0 <== NOT EXECUTED
203b984: c2 07 60 14 ld [ %i5 + 0x14 ], %g1 <== NOT EXECUTED
203b988: 80 a6 80 01 cmp %i2, %g1 <== NOT EXECUTED
203b98c: 18 80 00 21 bgu 203ba10 <rtems_rfs_group_bitmap_test+0xec><== NOT EXECUTED
203b990: b4 06 bf ff add %i2, -1, %i2 <== NOT EXECUTED
return EINVAL;
no -= RTEMS_RFS_ROOT_INO;
size = fs->group_inodes;
203b994: 10 80 00 06 b 203b9ac <rtems_rfs_group_bitmap_test+0x88> <== NOT EXECUTED
203b998: f0 07 60 2c ld [ %i5 + 0x2c ], %i0 <== NOT EXECUTED
}
else
{
if (no >= rtems_rfs_fs_blocks (fs))
203b99c: 80 a6 80 01 cmp %i2, %g1 <== NOT EXECUTED
203b9a0: 1a 80 00 1c bcc 203ba10 <rtems_rfs_group_bitmap_test+0xec><== NOT EXECUTED
203b9a4: b0 10 20 16 mov 0x16, %i0 <== NOT EXECUTED
return EINVAL;
size = fs->group_blocks;
203b9a8: f0 07 60 28 ld [ %i5 + 0x28 ], %i0 <== NOT EXECUTED
}
group = no / size;
203b9ac: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
203b9b0: 40 00 7e f4 call 205b580 <.udiv> <== NOT EXECUTED
203b9b4: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
bit = (rtems_rfs_bitmap_bit) (no % size);
203b9b8: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
if (no >= rtems_rfs_fs_blocks (fs))
return EINVAL;
size = fs->group_blocks;
}
group = no / size;
203b9bc: a0 10 00 08 mov %o0, %l0 <== NOT EXECUTED
bit = (rtems_rfs_bitmap_bit) (no % size);
203b9c0: 40 00 7f 9c call 205b830 <.urem> <== NOT EXECUTED
203b9c4: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
203b9c8: c2 07 60 20 ld [ %i5 + 0x20 ], %g1 <== NOT EXECUTED
203b9cc: b9 2c 20 04 sll %l0, 4, %i4 <== NOT EXECUTED
203b9d0: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED
203b9d4: a1 2c 20 06 sll %l0, 6, %l0 <== NOT EXECUTED
if (inode)
203b9d8: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED
bitmap = &fs->groups[group].inode_bitmap;
203b9dc: b8 07 00 10 add %i4, %l0, %i4 <== NOT EXECUTED
}
group = no / size;
bit = (rtems_rfs_bitmap_bit) (no % size);
if (inode)
203b9e0: 02 80 00 04 be 203b9f0 <rtems_rfs_group_bitmap_test+0xcc> <== NOT EXECUTED
203b9e4: b8 00 40 1c add %g1, %i4, %i4 <== NOT EXECUTED
bitmap = &fs->groups[group].inode_bitmap;
203b9e8: 10 80 00 03 b 203b9f4 <rtems_rfs_group_bitmap_test+0xd0> <== NOT EXECUTED
203b9ec: b8 07 20 2c add %i4, 0x2c, %i4 <== NOT EXECUTED
else
bitmap = &fs->groups[group].block_bitmap;
203b9f0: b8 07 20 08 add %i4, 8, %i4 <== NOT EXECUTED
rc = rtems_rfs_bitmap_map_test (bitmap, bit, state);
203b9f4: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
203b9f8: 40 00 17 30 call 20416b8 <rtems_rfs_bitmap_map_test> <== NOT EXECUTED
203b9fc: 94 10 00 1b mov %i3, %o2 <== NOT EXECUTED
rtems_rfs_bitmap_release_buffer (fs, bitmap);
203ba00: d2 07 00 00 ld [ %i4 ], %o1 <== 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);
203ba04: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED
rtems_rfs_bitmap_release_buffer (fs, bitmap);
203ba08: 7f ff ee 65 call 203739c <rtems_rfs_buffer_handle_release><== NOT EXECUTED
203ba0c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
return rc;
}
203ba10: 81 c7 e0 08 ret <== NOT EXECUTED
203ba14: 81 e8 00 00 restore <== NOT EXECUTED
0203b5bc <rtems_rfs_group_close>:
int
rtems_rfs_group_close (rtems_rfs_file_system* fs, rtems_rfs_group* group)
{
203b5bc: 9d e3 bf a0 save %sp, -96, %sp
int result = 0;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_CLOSE))
203b5c0: 90 10 20 00 clr %o0
203b5c4: 13 00 00 40 sethi %hi(0x10000), %o1
203b5c8: 7f ff a1 21 call 2023a4c <rtems_rfs_trace>
203b5cc: ba 10 00 18 mov %i0, %i5
203b5d0: 80 8a 20 ff btst 0xff, %o0
203b5d4: 02 80 00 06 be 203b5ec <rtems_rfs_group_close+0x30> <== ALWAYS TAKEN
203b5d8: 01 00 00 00 nop
printf ("rtems-rfs: group-close: base=%" PRId32 "\n", group->base);
203b5dc: d2 06 40 00 ld [ %i1 ], %o1 <== NOT EXECUTED
203b5e0: 11 00 81 a3 sethi %hi(0x2068c00), %o0 <== NOT EXECUTED
203b5e4: 40 00 2d 41 call 2046ae8 <printf> <== NOT EXECUTED
203b5e8: 90 12 22 f8 or %o0, 0x2f8, %o0 ! 2068ef8 <__FUNCTION__.7829+0x1e08><== 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);
203b5ec: 40 00 19 27 call 2041a88 <rtems_rfs_bitmap_close>
203b5f0: 90 06 60 2c add %i1, 0x2c, %o0
*/
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);
203b5f4: 92 06 60 44 add %i1, 0x44, %o1
203b5f8: b8 10 00 08 mov %o0, %i4
203b5fc: 7f ff ef 68 call 203739c <rtems_rfs_buffer_handle_release>
203b600: 90 10 00 1d mov %i5, %o0
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);
203b604: 90 06 60 08 add %i1, 8, %o0
handle->dirty = false;
203b608: c0 2e 60 44 clrb [ %i1 + 0x44 ]
handle->bnum = 0;
203b60c: c0 26 60 48 clr [ %i1 + 0x48 ]
203b610: 40 00 19 1e call 2041a88 <rtems_rfs_bitmap_close>
203b614: c0 26 60 4c clr [ %i1 + 0x4c ]
if (rc > 0)
203b618: b0 92 20 00 orcc %o0, 0, %i0
203b61c: 14 80 00 05 bg 203b630 <rtems_rfs_group_close+0x74> <== NEVER TAKEN
203b620: 90 10 00 1d mov %i5, %o0
203b624: b0 38 00 1c xnor %g0, %i4, %i0
203b628: b1 3e 20 1f sra %i0, 0x1f, %i0
203b62c: b0 0f 00 18 and %i4, %i0, %i0
*/
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);
203b630: 7f ff ef 5b call 203739c <rtems_rfs_buffer_handle_release>
203b634: 92 06 60 20 add %i1, 0x20, %o1
handle->dirty = false;
203b638: c0 2e 60 20 clrb [ %i1 + 0x20 ]
handle->bnum = 0;
203b63c: c0 26 60 24 clr [ %i1 + 0x24 ]
handle->buffer = NULL;
203b640: c0 26 60 28 clr [ %i1 + 0x28 ]
rc = rtems_rfs_buffer_handle_close (fs, &group->block_bitmap_buffer);
if (rc > 0)
result = rc;
return result;
}
203b644: 81 c7 e0 08 ret
203b648: 81 e8 00 00 restore
0203b3c4 <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)
{
203b3c4: 9d e3 bf a0 save %sp, -96, %sp
int rc;
if (base >= rtems_rfs_fs_blocks (fs))
203b3c8: c2 06 20 04 ld [ %i0 + 4 ], %g1
203b3cc: 80 a6 40 01 cmp %i1, %g1
203b3d0: 0a 80 00 10 bcs 203b410 <rtems_rfs_group_open+0x4c> <== ALWAYS TAKEN
203b3d4: 84 06 80 19 add %i2, %i1, %g2
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_OPEN))
203b3d8: 90 10 20 00 clr %o0 <== NOT EXECUTED
203b3dc: 13 00 00 20 sethi %hi(0x8000), %o1 <== NOT EXECUTED
203b3e0: 7f ff a1 9b call 2023a4c <rtems_rfs_trace> <== NOT EXECUTED
203b3e4: ba 10 20 05 mov 5, %i5 <== NOT EXECUTED
203b3e8: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
203b3ec: 22 80 00 72 be,a 203b5b4 <rtems_rfs_group_open+0x1f0> <== NOT EXECUTED
203b3f0: b0 10 00 1d mov %i5, %i0 <== NOT EXECUTED
printf ("rtems-rfs: group-open: base outside file system range: %d: %s\n",
203b3f4: 40 00 37 3c call 20490e4 <strerror> <== NOT EXECUTED
203b3f8: 90 10 20 05 mov 5, %o0 <== NOT EXECUTED
203b3fc: 92 10 20 05 mov 5, %o1 <== NOT EXECUTED
203b400: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
203b404: 11 00 81 a3 sethi %hi(0x2068c00), %o0 <== NOT EXECUTED
203b408: 10 80 00 36 b 203b4e0 <rtems_rfs_group_open+0x11c> <== NOT EXECUTED
203b40c: 90 12 22 00 or %o0, 0x200, %o0 ! 2068e00 <__FUNCTION__.7829+0x1d10><== NOT EXECUTED
EIO, strerror (EIO));
return EIO;
}
if ((base + size) >= rtems_rfs_fs_blocks (fs))
203b410: 80 a0 80 01 cmp %g2, %g1
203b414: 3a 80 00 02 bcc,a 203b41c <rtems_rfs_group_open+0x58> <== ALWAYS TAKEN
203b418: b4 20 40 19 sub %g1, %i1, %i2
203b41c: 80 a6 80 1b cmp %i2, %i3
203b420: 08 80 00 03 bleu 203b42c <rtems_rfs_group_open+0x68> <== NEVER TAKEN
203b424: a0 10 00 1a mov %i2, %l0
203b428: a0 10 00 1b mov %i3, %l0
* the format configuration needs reviewing.
*/
if (inodes > size)
inodes = size;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_OPEN))
203b42c: 90 10 20 00 clr %o0
203b430: 7f ff a1 87 call 2023a4c <rtems_rfs_trace>
203b434: 13 00 00 20 sethi %hi(0x8000), %o1
203b438: 80 8a 20 ff btst 0xff, %o0
203b43c: 22 80 00 09 be,a 203b460 <rtems_rfs_group_open+0x9c> <== ALWAYS TAKEN
203b440: f2 27 00 00 st %i1, [ %i4 ]
printf ("rtems-rfs: group-open: base=%" PRId32 ", blocks=%zd inodes=%zd\n",
203b444: 11 00 81 a3 sethi %hi(0x2068c00), %o0 <== NOT EXECUTED
203b448: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
203b44c: 90 12 22 40 or %o0, 0x240, %o0 <== NOT EXECUTED
203b450: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED
203b454: 40 00 2d a5 call 2046ae8 <printf> <== NOT EXECUTED
203b458: 96 10 00 10 mov %l0, %o3 <== NOT EXECUTED
base, size, inodes);
group->base = base;
203b45c: f2 27 00 00 st %i1, [ %i4 ] <== NOT EXECUTED
group->size = size;
203b460: f4 27 20 04 st %i2, [ %i4 + 4 ]
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
203b464: c0 2f 20 20 clrb [ %i4 + 0x20 ]
handle->bnum = 0;
203b468: c0 27 20 24 clr [ %i4 + 0x24 ]
handle->buffer = NULL;
203b46c: c0 27 20 28 clr [ %i4 + 0x28 ]
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,
203b470: a2 07 20 08 add %i4, 8, %l1
203b474: b6 07 20 20 add %i4, 0x20, %i3
203b478: 90 10 00 11 mov %l1, %o0
203b47c: 92 10 00 18 mov %i0, %o1
203b480: 94 10 00 1b mov %i3, %o2
203b484: 96 10 00 1a mov %i2, %o3
203b488: 40 00 19 6f call 2041a44 <rtems_rfs_bitmap_open>
203b48c: 98 10 00 19 mov %i1, %o4
&group->block_bitmap_buffer, size,
group->base + RTEMS_RFS_GROUP_BLOCK_BITMAP_BLOCK);
if (rc > 0)
203b490: ba 92 20 00 orcc %o0, 0, %i5
203b494: 04 80 00 16 ble 203b4ec <rtems_rfs_group_open+0x128> <== ALWAYS TAKEN
203b498: 92 10 00 1b mov %i3, %o1
*/
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);
203b49c: 7f ff ef c0 call 203739c <rtems_rfs_buffer_handle_release><== NOT EXECUTED
203b4a0: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
{
rtems_rfs_buffer_handle_close (fs, &group->block_bitmap_buffer);
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_OPEN))
203b4a4: 90 10 20 00 clr %o0 <== NOT EXECUTED
handle->dirty = false;
203b4a8: c0 2f 20 20 clrb [ %i4 + 0x20 ] <== NOT EXECUTED
handle->bnum = 0;
203b4ac: c0 27 20 24 clr [ %i4 + 0x24 ] <== NOT EXECUTED
handle->buffer = NULL;
203b4b0: c0 27 20 28 clr [ %i4 + 0x28 ] <== NOT EXECUTED
203b4b4: 7f ff a1 66 call 2023a4c <rtems_rfs_trace> <== NOT EXECUTED
203b4b8: 13 00 00 20 sethi %hi(0x8000), %o1 <== NOT EXECUTED
203b4bc: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
203b4c0: 22 80 00 3d be,a 203b5b4 <rtems_rfs_group_open+0x1f0> <== NOT EXECUTED
203b4c4: b0 10 00 1d mov %i5, %i0 <== NOT EXECUTED
printf ("rtems-rfs: group-open: could not open block bitmap: %d: %s\n",
203b4c8: 40 00 37 07 call 20490e4 <strerror> <== NOT EXECUTED
203b4cc: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
203b4d0: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
203b4d4: 11 00 81 a3 sethi %hi(0x2068c00), %o0 <== NOT EXECUTED
203b4d8: 90 12 22 78 or %o0, 0x278, %o0 ! 2068e78 <__FUNCTION__.7829+0x1d88><== NOT EXECUTED
203b4dc: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
203b4e0: 40 00 2d 82 call 2046ae8 <printf> <== NOT EXECUTED
203b4e4: b0 10 00 1d mov %i5, %i0 <== NOT EXECUTED
203b4e8: 30 80 00 33 b,a 203b5b4 <rtems_rfs_group_open+0x1f0> <== 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,
203b4ec: d8 07 00 00 ld [ %i4 ], %o4
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
203b4f0: c0 2f 20 44 clrb [ %i4 + 0x44 ]
handle->bnum = 0;
203b4f4: c0 27 20 48 clr [ %i4 + 0x48 ]
handle->buffer = NULL;
203b4f8: c0 27 20 4c clr [ %i4 + 0x4c ]
203b4fc: b4 07 20 44 add %i4, 0x44, %i2
203b500: 90 07 20 2c add %i4, 0x2c, %o0
203b504: 92 10 00 18 mov %i0, %o1
203b508: 94 10 00 1a mov %i2, %o2
203b50c: 96 10 00 10 mov %l0, %o3
203b510: 40 00 19 4d call 2041a44 <rtems_rfs_bitmap_open>
203b514: 98 03 20 01 inc %o4
&group->inode_bitmap_buffer, inodes,
group->base + RTEMS_RFS_GROUP_INODE_BITMAP_BLOCK);
if (rc > 0)
203b518: ba 92 20 00 orcc %o0, 0, %i5
203b51c: 04 80 00 1b ble 203b588 <rtems_rfs_group_open+0x1c4> <== ALWAYS TAKEN
203b520: 92 10 00 1a mov %i2, %o1
*/
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);
203b524: 7f ff ef 9e call 203739c <rtems_rfs_buffer_handle_release><== NOT EXECUTED
203b528: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
{
rtems_rfs_buffer_handle_close (fs, &group->inode_bitmap_buffer);
rtems_rfs_bitmap_close (&group->block_bitmap);
203b52c: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED
handle->dirty = false;
203b530: c0 2f 20 44 clrb [ %i4 + 0x44 ] <== NOT EXECUTED
handle->bnum = 0;
203b534: c0 27 20 48 clr [ %i4 + 0x48 ] <== NOT EXECUTED
203b538: 40 00 19 54 call 2041a88 <rtems_rfs_bitmap_close> <== NOT EXECUTED
203b53c: c0 27 20 4c clr [ %i4 + 0x4c ] <== 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);
203b540: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
203b544: 7f ff ef 96 call 203739c <rtems_rfs_buffer_handle_release><== NOT EXECUTED
203b548: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
rtems_rfs_buffer_handle_close (fs, &group->block_bitmap_buffer);
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_OPEN))
203b54c: 90 10 20 00 clr %o0 <== NOT EXECUTED
handle->dirty = false;
203b550: c0 2f 20 20 clrb [ %i4 + 0x20 ] <== NOT EXECUTED
handle->bnum = 0;
203b554: c0 27 20 24 clr [ %i4 + 0x24 ] <== NOT EXECUTED
handle->buffer = NULL;
203b558: c0 27 20 28 clr [ %i4 + 0x28 ] <== NOT EXECUTED
203b55c: 7f ff a1 3c call 2023a4c <rtems_rfs_trace> <== NOT EXECUTED
203b560: 13 00 00 20 sethi %hi(0x8000), %o1 <== NOT EXECUTED
203b564: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
203b568: 22 80 00 13 be,a 203b5b4 <rtems_rfs_group_open+0x1f0> <== NOT EXECUTED
203b56c: b0 10 00 1d mov %i5, %i0 <== NOT EXECUTED
printf ("rtems-rfs: group-open: could not open inode bitmap: %d: %s\n",
203b570: 40 00 36 dd call 20490e4 <strerror> <== NOT EXECUTED
203b574: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
203b578: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
203b57c: 11 00 81 a3 sethi %hi(0x2068c00), %o0 <== NOT EXECUTED
203b580: 10 bf ff d7 b 203b4dc <rtems_rfs_group_open+0x118> <== NOT EXECUTED
203b584: 90 12 22 b8 or %o0, 0x2b8, %o0 ! 2068eb8 <__FUNCTION__.7829+0x1dc8><== NOT EXECUTED
rc, strerror (rc));
return rc;
}
if (rtems_rfs_fs_release_bitmaps (fs))
203b588: c2 06 00 00 ld [ %i0 ], %g1
203b58c: 80 88 60 01 btst 1, %g1
203b590: 12 80 00 08 bne 203b5b0 <rtems_rfs_group_open+0x1ec> <== NEVER TAKEN
203b594: ba 10 20 00 clr %i5
{
rtems_rfs_bitmap_release_buffer (fs, &group->block_bitmap);
203b598: d2 07 20 08 ld [ %i4 + 8 ], %o1
203b59c: 7f ff ef 80 call 203739c <rtems_rfs_buffer_handle_release>
203b5a0: 90 10 00 18 mov %i0, %o0
rtems_rfs_bitmap_release_buffer (fs, &group->inode_bitmap);
203b5a4: d2 07 20 2c ld [ %i4 + 0x2c ], %o1
203b5a8: 7f ff ef 7d call 203739c <rtems_rfs_buffer_handle_release>
203b5ac: 90 10 00 18 mov %i0, %o0
}
return 0;
}
203b5b0: b0 10 00 1d mov %i5, %i0
203b5b4: 81 c7 e0 08 ret
203b5b8: 81 e8 00 00 restore
0203ba18 <rtems_rfs_group_usage>:
size_t* blocks,
size_t* inodes)
{
int g;
*blocks = 0;
203ba18: c0 22 40 00 clr [ %o1 ] <== NOT EXECUTED
*inodes = 0;
203ba1c: c0 22 80 00 clr [ %o2 ] <== NOT EXECUTED
for (g = 0; g < fs->group_count; g++)
203ba20: 86 10 20 00 clr %g3 <== NOT EXECUTED
203ba24: 10 80 00 11 b 203ba68 <rtems_rfs_group_usage+0x50> <== NOT EXECUTED
203ba28: 84 10 20 00 clr %g2 <== NOT EXECUTED
{
rtems_rfs_group* group = &fs->groups[g];
203ba2c: c2 02 20 20 ld [ %o0 + 0x20 ], %g1 <== NOT EXECUTED
int g;
*blocks = 0;
*inodes = 0;
for (g = 0; g < fs->group_count; g++)
203ba30: 84 00 a0 01 inc %g2 <== NOT EXECUTED
{
rtems_rfs_group* group = &fs->groups[g];
203ba34: 82 00 40 03 add %g1, %g3, %g1 <== NOT EXECUTED
*blocks +=
rtems_rfs_bitmap_map_size(&group->block_bitmap) -
203ba38: d8 00 60 14 ld [ %g1 + 0x14 ], %o4 <== NOT EXECUTED
203ba3c: da 00 60 18 ld [ %g1 + 0x18 ], %o5 <== NOT EXECUTED
203ba40: 86 00 e0 50 add %g3, 0x50, %g3 <== NOT EXECUTED
203ba44: 9a 23 00 0d sub %o4, %o5, %o5 <== NOT EXECUTED
*inodes = 0;
for (g = 0; g < fs->group_count; g++)
{
rtems_rfs_group* group = &fs->groups[g];
*blocks +=
203ba48: 88 01 00 0d add %g4, %o5, %g4 <== NOT EXECUTED
203ba4c: c8 22 40 00 st %g4, [ %o1 ] <== 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) -
203ba50: c8 00 60 38 ld [ %g1 + 0x38 ], %g4 <== NOT EXECUTED
203ba54: c2 00 60 3c ld [ %g1 + 0x3c ], %g1 <== NOT EXECUTED
203ba58: 82 21 00 01 sub %g4, %g1, %g1 <== 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 +=
203ba5c: c8 02 80 00 ld [ %o2 ], %g4 <== NOT EXECUTED
203ba60: 82 01 00 01 add %g4, %g1, %g1 <== NOT EXECUTED
203ba64: c2 22 80 00 st %g1, [ %o2 ] <== NOT EXECUTED
int g;
*blocks = 0;
*inodes = 0;
for (g = 0; g < fs->group_count; g++)
203ba68: c2 02 20 24 ld [ %o0 + 0x24 ], %g1 <== NOT EXECUTED
203ba6c: 80 a0 80 01 cmp %g2, %g1 <== NOT EXECUTED
203ba70: 06 bf ff ef bl 203ba2c <rtems_rfs_group_usage+0x14> <== NOT EXECUTED
203ba74: c8 02 40 00 ld [ %o1 ], %g4 <== 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))
203ba78: c4 02 20 04 ld [ %o0 + 4 ], %g2 <== NOT EXECUTED
203ba7c: 80 a1 00 02 cmp %g4, %g2 <== NOT EXECUTED
203ba80: 08 80 00 03 bleu 203ba8c <rtems_rfs_group_usage+0x74> <== NOT EXECUTED
203ba84: 82 10 00 04 mov %g4, %g1 <== NOT EXECUTED
203ba88: 82 10 00 02 mov %g2, %g1 <== NOT EXECUTED
203ba8c: c2 22 40 00 st %g1, [ %o1 ] <== NOT EXECUTED
*blocks = rtems_rfs_fs_blocks (fs);
if (*inodes > rtems_rfs_fs_inodes (fs))
203ba90: c4 02 20 14 ld [ %o0 + 0x14 ], %g2 <== NOT EXECUTED
203ba94: c2 02 80 00 ld [ %o2 ], %g1 <== NOT EXECUTED
203ba98: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED
203ba9c: 38 80 00 02 bgu,a 203baa4 <rtems_rfs_group_usage+0x8c> <== NOT EXECUTED
203baa0: 82 10 00 02 mov %g2, %g1 <== NOT EXECUTED
203baa4: c2 22 80 00 st %g1, [ %o2 ] <== NOT EXECUTED
*inodes = rtems_rfs_fs_inodes (fs);
return 0;
}
203baa8: 81 c3 e0 08 retl <== NOT EXECUTED
203baac: 90 10 20 00 clr %o0 <== NOT EXECUTED
0203bd68 <rtems_rfs_inode_close>:
}
int
rtems_rfs_inode_close (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* handle)
{
203bd68: 9d e3 bf a0 save %sp, -96, %sp
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_CLOSE))
203bd6c: 90 10 20 00 clr %o0
203bd70: 7f ff 9f 37 call 2023a4c <rtems_rfs_trace>
203bd74: 13 00 02 00 sethi %hi(0x80000), %o1
203bd78: 80 8a 20 ff btst 0xff, %o0
203bd7c: 22 80 00 07 be,a 203bd98 <rtems_rfs_inode_close+0x30> <== ALWAYS TAKEN
203bd80: 90 10 00 18 mov %i0, %o0
printf ("rtems-rfs: inode-close: ino: %" PRIu32 "\n", handle->ino);
203bd84: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED
203bd88: 11 00 81 a4 sethi %hi(0x2069000), %o0 <== NOT EXECUTED
203bd8c: 40 00 2b 57 call 2046ae8 <printf> <== NOT EXECUTED
203bd90: 90 12 20 88 or %o0, 0x88, %o0 ! 2069088 <__FUNCTION__.7829+0x1f98><== NOT EXECUTED
rc = rtems_rfs_inode_unload (fs, handle, true);
203bd94: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
203bd98: 92 10 00 19 mov %i1, %o1
203bd9c: 7f ff ff b7 call 203bc78 <rtems_rfs_inode_unload>
203bda0: 94 10 20 01 mov 1, %o2
if ((rc == 0) && (handle->loads > 0))
203bda4: b0 92 20 00 orcc %o0, 0, %i0
203bda8: 32 80 00 11 bne,a 203bdec <rtems_rfs_inode_close+0x84> <== NEVER TAKEN
203bdac: c0 26 60 08 clr [ %i1 + 8 ] <== NOT EXECUTED
203bdb0: c2 06 60 24 ld [ %i1 + 0x24 ], %g1
203bdb4: 80 a0 60 00 cmp %g1, 0
203bdb8: 04 80 00 0c ble 203bde8 <rtems_rfs_inode_close+0x80> <== ALWAYS TAKEN
203bdbc: 13 00 02 00 sethi %hi(0x80000), %o1
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_CLOSE))
203bdc0: 90 10 20 00 clr %o0 <== NOT EXECUTED
203bdc4: 7f ff 9f 22 call 2023a4c <rtems_rfs_trace> <== NOT EXECUTED
203bdc8: b0 10 20 05 mov 5, %i0 <== NOT EXECUTED
203bdcc: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
203bdd0: 22 80 00 07 be,a 203bdec <rtems_rfs_inode_close+0x84> <== NOT EXECUTED
203bdd4: c0 26 60 08 clr [ %i1 + 8 ] <== NOT EXECUTED
printf ("rtems-rfs: inode-close: bad loads number: %d\n",
203bdd8: d2 06 60 24 ld [ %i1 + 0x24 ], %o1 <== NOT EXECUTED
203bddc: 11 00 81 a4 sethi %hi(0x2069000), %o0 <== NOT EXECUTED
203bde0: 40 00 2b 42 call 2046ae8 <printf> <== NOT EXECUTED
203bde4: 90 12 20 b0 or %o0, 0xb0, %o0 ! 20690b0 <__FUNCTION__.7829+0x1fc0><== NOT EXECUTED
handle->loads);
rc = EIO;
}
handle->ino = 0;
203bde8: c0 26 60 08 clr [ %i1 + 8 ]
return rc;
}
203bdec: 81 c7 e0 08 ret
203bdf0: 81 e8 00 00 restore
0203c0bc <rtems_rfs_inode_create>:
uint16_t mode,
uint16_t links,
uid_t uid,
gid_t gid,
rtems_rfs_ino* ino)
{
203c0bc: 9d e3 bf 50 save %sp, -176, %sp
rtems_rfs_inode_handle parent_inode;
rtems_rfs_inode_handle inode;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_CREATE))
203c0c0: 90 10 20 00 clr %o0
uint16_t mode,
uint16_t links,
uid_t uid,
gid_t gid,
rtems_rfs_ino* ino)
{
203c0c4: e2 07 a0 64 ld [ %fp + 0x64 ], %l1
203c0c8: e8 17 a0 5e lduh [ %fp + 0x5e ], %l4
203c0cc: e6 17 a0 62 lduh [ %fp + 0x62 ], %l3
rtems_rfs_inode_handle parent_inode;
rtems_rfs_inode_handle inode;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_CREATE))
203c0d0: 7f ff 9e 5f call 2023a4c <rtems_rfs_trace>
203c0d4: 13 00 10 00 sethi %hi(0x400000), %o1
203c0d8: 80 8a 20 ff btst 0xff, %o0
203c0dc: 02 80 00 36 be 203c1b4 <rtems_rfs_inode_create+0xf8> <== ALWAYS TAKEN
203c0e0: a4 0f 30 00 and %i4, -4096, %l2
{
const char* type = "unknown";
int c;
if (RTEMS_RFS_S_ISDIR (mode))
203c0e4: 82 0f 30 00 and %i4, -4096, %g1 <== NOT EXECUTED
203c0e8: 05 00 00 10 sethi %hi(0x4000), %g2 <== NOT EXECUTED
203c0ec: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED
203c0f0: 02 80 00 11 be 203c134 <rtems_rfs_inode_create+0x78> <== NOT EXECUTED
203c0f4: 05 00 00 08 sethi %hi(0x2000), %g2 <== NOT EXECUTED
type = "dir";
else if (RTEMS_RFS_S_ISCHR (mode))
203c0f8: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED
203c0fc: 02 80 00 11 be 203c140 <rtems_rfs_inode_create+0x84> <== NOT EXECUTED
203c100: 05 00 00 18 sethi %hi(0x6000), %g2 <== NOT EXECUTED
type = "char";
else if (RTEMS_RFS_S_ISBLK (mode))
203c104: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED
203c108: 02 80 00 11 be 203c14c <rtems_rfs_inode_create+0x90> <== NOT EXECUTED
203c10c: 05 00 00 20 sethi %hi(0x8000), %g2 <== NOT EXECUTED
type = "block";
else if (RTEMS_RFS_S_ISREG (mode))
203c110: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED
203c114: 02 80 00 11 be 203c158 <rtems_rfs_inode_create+0x9c> <== NOT EXECUTED
203c118: 05 00 00 28 sethi %hi(0xa000), %g2 <== NOT EXECUTED
type = "file";
else if (RTEMS_RFS_S_ISLNK (mode))
203c11c: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED
203c120: 22 80 00 11 be,a 203c164 <rtems_rfs_inode_create+0xa8> <== NOT EXECUTED
203c124: 21 00 81 8d sethi %hi(0x2063400), %l0 <== NOT EXECUTED
rtems_rfs_inode_handle inode;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_CREATE))
{
const char* type = "unknown";
203c128: 21 00 81 a4 sethi %hi(0x2069000), %l0 <== NOT EXECUTED
203c12c: 10 80 00 0f b 203c168 <rtems_rfs_inode_create+0xac> <== NOT EXECUTED
203c130: a0 14 21 18 or %l0, 0x118, %l0 ! 2069118 <__FUNCTION__.7829+0x2028><== NOT EXECUTED
int c;
if (RTEMS_RFS_S_ISDIR (mode))
type = "dir";
203c134: 21 00 81 81 sethi %hi(0x2060400), %l0 <== NOT EXECUTED
203c138: 10 80 00 0c b 203c168 <rtems_rfs_inode_create+0xac> <== NOT EXECUTED
203c13c: a0 14 21 80 or %l0, 0x180, %l0 ! 2060580 <rtems_bdpart_shell_usage+0x9b0><== NOT EXECUTED
else if (RTEMS_RFS_S_ISCHR (mode))
type = "char";
203c140: 21 00 81 a4 sethi %hi(0x2069000), %l0 <== NOT EXECUTED
203c144: 10 80 00 09 b 203c168 <rtems_rfs_inode_create+0xac> <== NOT EXECUTED
203c148: a0 14 21 10 or %l0, 0x110, %l0 ! 2069110 <__FUNCTION__.7829+0x2020><== NOT EXECUTED
else if (RTEMS_RFS_S_ISBLK (mode))
type = "block";
203c14c: 21 00 81 8c sethi %hi(0x2063000), %l0 <== NOT EXECUTED
203c150: 10 80 00 06 b 203c168 <rtems_rfs_inode_create+0xac> <== NOT EXECUTED
203c154: a0 14 23 48 or %l0, 0x348, %l0 ! 2063348 <rtems_rfs_rtems_eval_config+0x810><== NOT EXECUTED
else if (RTEMS_RFS_S_ISREG (mode))
type = "file";
203c158: 21 00 81 89 sethi %hi(0x2062400), %l0 <== NOT EXECUTED
203c15c: 10 80 00 03 b 203c168 <rtems_rfs_inode_create+0xac> <== NOT EXECUTED
203c160: a0 14 22 88 or %l0, 0x288, %l0 ! 2062688 <rtems_rtc_shell_usage+0xb58><== NOT EXECUTED
else if (RTEMS_RFS_S_ISLNK (mode))
type = "link";
203c164: a0 14 23 e8 or %l0, 0x3e8, %l0 <== NOT EXECUTED
printf("rtems-rfs: inode-create: parent:%" PRIu32 " name:", parent);
203c168: 11 00 81 a4 sethi %hi(0x2069000), %o0 <== NOT EXECUTED
203c16c: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
203c170: 90 12 21 20 or %o0, 0x120, %o0 <== NOT EXECUTED
203c174: 40 00 2a 5d call 2046ae8 <printf> <== NOT EXECUTED
203c178: a4 10 00 1a mov %i2, %l2 <== NOT EXECUTED
for (c = 0; c < length; c++)
203c17c: 10 80 00 04 b 203c18c <rtems_rfs_inode_create+0xd0> <== NOT EXECUTED
203c180: aa 06 80 1b add %i2, %i3, %l5 <== NOT EXECUTED
printf ("%c", name[c]);
203c184: 40 00 2a c3 call 2046c90 <putchar> <== NOT EXECUTED
203c188: a4 04 a0 01 inc %l2 <== 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++)
203c18c: 80 a4 80 15 cmp %l2, %l5 <== NOT EXECUTED
203c190: 32 bf ff fd bne,a 203c184 <rtems_rfs_inode_create+0xc8> <== NOT EXECUTED
203c194: d0 4c 80 00 ldsb [ %l2 ], %o0 <== NOT EXECUTED
printf ("%c", name[c]);
printf (" type:%s mode:%04x (%03o)\n", type, mode, mode & ((1 << 10) - 1));
203c198: 11 00 81 a4 sethi %hi(0x2069000), %o0 <== NOT EXECUTED
203c19c: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED
203c1a0: 90 12 21 50 or %o0, 0x150, %o0 <== NOT EXECUTED
203c1a4: 94 10 00 1c mov %i4, %o2 <== NOT EXECUTED
203c1a8: 40 00 2a 50 call 2046ae8 <printf> <== NOT EXECUTED
203c1ac: 96 0f 23 ff and %i4, 0x3ff, %o3 <== NOT EXECUTED
}
/*
* The file type is field within the mode. Check we have a sane mode set.
*/
switch (mode & RTEMS_RFS_S_IFMT)
203c1b0: a4 0f 30 00 and %i4, -4096, %l2 <== NOT EXECUTED
203c1b4: 05 00 00 18 sethi %hi(0x6000), %g2
203c1b8: 80 a4 80 02 cmp %l2, %g2
203c1bc: 02 80 00 11 be 203c200 <rtems_rfs_inode_create+0x144> <== NEVER TAKEN
203c1c0: 82 10 00 12 mov %l2, %g1
203c1c4: 80 a4 80 02 cmp %l2, %g2
203c1c8: 18 80 00 08 bgu 203c1e8 <rtems_rfs_inode_create+0x12c>
203c1cc: 05 00 00 20 sethi %hi(0x8000), %g2
203c1d0: 05 00 00 08 sethi %hi(0x2000), %g2
203c1d4: 80 a4 80 02 cmp %l2, %g2
203c1d8: 02 80 00 0a be 203c200 <rtems_rfs_inode_create+0x144> <== NEVER TAKEN
203c1dc: 05 00 00 10 sethi %hi(0x4000), %g2
203c1e0: 10 80 00 06 b 203c1f8 <rtems_rfs_inode_create+0x13c>
203c1e4: 80 a0 40 02 cmp %g1, %g2
203c1e8: 80 a4 80 02 cmp %l2, %g2
203c1ec: 02 80 00 05 be 203c200 <rtems_rfs_inode_create+0x144>
203c1f0: 05 00 00 28 sethi %hi(0xa000), %g2
203c1f4: 80 a0 40 02 cmp %g1, %g2
203c1f8: 12 80 00 81 bne 203c3fc <rtems_rfs_inode_create+0x340> <== NEVER TAKEN
203c1fc: a0 10 20 16 mov 0x16, %l0
break;
default:
return EINVAL;
}
rc = rtems_rfs_inode_alloc (fs, parent, ino);
203c200: 90 10 00 18 mov %i0, %o0
203c204: 92 10 00 19 mov %i1, %o1
203c208: 7f ff fe 2a call 203bab0 <rtems_rfs_inode_alloc>
203c20c: 94 10 00 11 mov %l1, %o2
if (rc > 0)
203c210: a0 92 20 00 orcc %o0, 0, %l0
203c214: 34 80 00 7b bg,a 203c400 <rtems_rfs_inode_create+0x344>
203c218: b0 10 00 10 mov %l0, %i0
return rc;
rc = rtems_rfs_inode_open (fs, *ino, &inode, true);
203c21c: d2 04 40 00 ld [ %l1 ], %o1
203c220: 90 10 00 18 mov %i0, %o0
203c224: 94 07 bf d8 add %fp, -40, %o2
203c228: 7f ff fe 5e call 203bba0 <rtems_rfs_inode_open>
203c22c: 96 10 20 01 mov 1, %o3
if (rc > 0)
203c230: a0 92 20 00 orcc %o0, 0, %l0
203c234: 04 80 00 04 ble 203c244 <rtems_rfs_inode_create+0x188> <== ALWAYS TAKEN
203c238: 90 07 bf d8 add %fp, -40, %o0
}
rc = rtems_rfs_inode_close (fs, &inode);
if (rc > 0)
{
rtems_rfs_inode_free (fs, *ino);
203c23c: 10 80 00 6c b 203c3ec <rtems_rfs_inode_create+0x330> <== NOT EXECUTED
203c240: d2 04 40 00 ld [ %l1 ], %o1 <== NOT EXECUTED
{
rtems_rfs_inode_free (fs, *ino);
return rc;
}
rc = rtems_rfs_inode_initialise (&inode, links, mode, uid, gid);
203c244: 92 10 00 1d mov %i5, %o1
203c248: 94 10 00 1c mov %i4, %o2
203c24c: 96 10 00 14 mov %l4, %o3
203c250: 7f ff ff 47 call 203bf6c <rtems_rfs_inode_initialise>
203c254: 98 10 00 13 mov %l3, %o4
if (rc > 0)
203c258: a0 92 20 00 orcc %o0, 0, %l0
203c25c: 04 80 00 07 ble 203c278 <rtems_rfs_inode_create+0x1bc> <== ALWAYS TAKEN
203c260: 03 00 00 10 sethi %hi(0x4000), %g1
{
rtems_rfs_inode_close (fs, &inode);
203c264: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
203c268: 7f ff fe c0 call 203bd68 <rtems_rfs_inode_close> <== NOT EXECUTED
203c26c: 92 07 bf d8 add %fp, -40, %o1 <== NOT EXECUTED
}
rc = rtems_rfs_inode_close (fs, &inode);
if (rc > 0)
{
rtems_rfs_inode_free (fs, *ino);
203c270: 10 80 00 5f b 203c3ec <rtems_rfs_inode_create+0x330> <== NOT EXECUTED
203c274: d2 04 40 00 ld [ %l1 ], %o1 <== 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))
203c278: 80 a4 80 01 cmp %l2, %g1
203c27c: 12 80 00 17 bne 203c2d8 <rtems_rfs_inode_create+0x21c>
203c280: 90 10 00 18 mov %i0, %o0
{
rc = rtems_rfs_dir_add_entry (fs, &inode, ".", 1, *ino);
203c284: d8 04 40 00 ld [ %l1 ], %o4
203c288: 92 07 bf d8 add %fp, -40, %o1
203c28c: 15 00 81 82 sethi %hi(0x2060800), %o2
203c290: 96 10 20 01 mov 1, %o3
203c294: 7f ff ef b3 call 2038160 <rtems_rfs_dir_add_entry>
203c298: 94 12 a1 10 or %o2, 0x110, %o2
if (rc == 0)
203c29c: a0 92 20 00 orcc %o0, 0, %l0
203c2a0: 12 80 00 0b bne 203c2cc <rtems_rfs_inode_create+0x210> <== NEVER TAKEN
203c2a4: 80 a4 20 00 cmp %l0, 0
rc = rtems_rfs_dir_add_entry (fs, &inode, "..", 2, parent);
203c2a8: 90 10 00 18 mov %i0, %o0
203c2ac: 92 07 bf d8 add %fp, -40, %o1
203c2b0: 15 00 81 80 sethi %hi(0x2060000), %o2
203c2b4: 96 10 20 02 mov 2, %o3
203c2b8: 94 12 a2 38 or %o2, 0x238, %o2
203c2bc: 7f ff ef a9 call 2038160 <rtems_rfs_dir_add_entry>
203c2c0: 98 10 00 19 mov %i1, %o4
203c2c4: a0 10 00 08 mov %o0, %l0
if (rc > 0)
203c2c8: 80 a4 20 00 cmp %l0, 0
203c2cc: 14 80 00 0b bg 203c2f8 <rtems_rfs_inode_create+0x23c> <== NEVER TAKEN
203c2d0: 90 10 00 18 mov %i0, %o0
rtems_rfs_inode_close (fs, &inode);
return rc;
}
}
rc = rtems_rfs_inode_open (fs, parent, &parent_inode, true);
203c2d4: 90 10 00 18 mov %i0, %o0
203c2d8: 92 10 00 19 mov %i1, %o1
203c2dc: 94 07 bf b0 add %fp, -80, %o2
203c2e0: 7f ff fe 30 call 203bba0 <rtems_rfs_inode_open>
203c2e4: 96 10 20 01 mov 1, %o3
203c2e8: a0 10 00 08 mov %o0, %l0
if (rc > 0)
203c2ec: 80 a4 20 00 cmp %l0, 0
203c2f0: 04 80 00 04 ble 203c300 <rtems_rfs_inode_create+0x244> <== ALWAYS TAKEN
203c2f4: 90 10 00 18 mov %i0, %o0
{
rtems_rfs_inode_delete (fs, &inode);
203c2f8: 10 80 00 30 b 203c3b8 <rtems_rfs_inode_create+0x2fc> <== NOT EXECUTED
203c2fc: 92 07 bf d8 add %fp, -40, %o1 <== NOT EXECUTED
rtems_rfs_inode_close (fs, &inode);
return rc;
}
rc = rtems_rfs_dir_add_entry (fs, &parent_inode, name, length, *ino);
203c300: d8 04 40 00 ld [ %l1 ], %o4
203c304: 92 07 bf b0 add %fp, -80, %o1
203c308: 94 10 00 1a mov %i2, %o2
203c30c: 7f ff ef 95 call 2038160 <rtems_rfs_dir_add_entry>
203c310: 96 10 00 1b mov %i3, %o3
if (rc > 0)
203c314: a0 92 20 00 orcc %o0, 0, %l0
203c318: 04 80 00 0b ble 203c344 <rtems_rfs_inode_create+0x288> <== ALWAYS TAKEN
203c31c: 03 00 00 10 sethi %hi(0x4000), %g1
{
rtems_rfs_inode_delete (fs, &inode);
203c320: 92 07 bf d8 add %fp, -40, %o1 <== NOT EXECUTED
203c324: 7f ff fe b4 call 203bdf4 <rtems_rfs_inode_delete> <== NOT EXECUTED
203c328: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
rtems_rfs_inode_close (fs, &inode);
203c32c: 92 07 bf d8 add %fp, -40, %o1 <== NOT EXECUTED
203c330: 7f ff fe 8e call 203bd68 <rtems_rfs_inode_close> <== NOT EXECUTED
203c334: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
rtems_rfs_inode_close (fs, &parent_inode);
203c338: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
203c33c: 10 80 00 23 b 203c3c8 <rtems_rfs_inode_create+0x30c> <== NOT EXECUTED
203c340: 92 07 bf b0 add %fp, -80, %o1 <== 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))
203c344: 80 a4 80 01 cmp %l2, %g1
203c348: 12 80 00 15 bne 203c39c <rtems_rfs_inode_create+0x2e0>
203c34c: 92 07 bf b0 add %fp, -80, %o1
*/
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);
203c350: c2 07 bf bc ld [ %fp + -68 ], %g1
if (links == 0xffff)
203c354: 09 3f ff c0 sethi %hi(0xffff0000), %g4
*/
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);
203c358: c6 08 60 01 ldub [ %g1 + 1 ], %g3
203c35c: c4 08 40 00 ldub [ %g1 ], %g2
203c360: 85 28 a0 08 sll %g2, 8, %g2
203c364: 84 10 80 03 or %g2, %g3, %g2
if (links == 0xffff)
203c368: 87 28 a0 10 sll %g2, 0x10, %g3
203c36c: 87 30 e0 10 srl %g3, 0x10, %g3
links = 0;
203c370: 86 39 00 03 xnor %g4, %g3, %g3
203c374: 80 a0 00 03 cmp %g0, %g3
203c378: 86 60 20 00 subx %g0, 0, %g3
203c37c: 84 08 80 03 and %g2, %g3, %g2
rtems_rfs_inode_set_links (&parent_inode,
203c380: 84 00 a0 01 inc %g2
* @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);
203c384: 87 30 a0 08 srl %g2, 8, %g3
203c388: c6 28 40 00 stb %g3, [ %g1 ]
203c38c: c2 07 bf bc ld [ %fp + -68 ], %g1
203c390: c4 28 60 01 stb %g2, [ %g1 + 1 ]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
203c394: 82 10 20 01 mov 1, %g1
203c398: c2 2f bf c0 stb %g1, [ %fp + -64 ]
rtems_rfs_inode_get_links (&parent_inode) + 1);
rc = rtems_rfs_inode_close (fs, &parent_inode);
203c39c: 7f ff fe 73 call 203bd68 <rtems_rfs_inode_close>
203c3a0: 90 10 00 18 mov %i0, %o0
if (rc > 0)
{
rtems_rfs_inode_delete (fs, &inode);
203c3a4: 92 07 bf d8 add %fp, -40, %o1
*/
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);
203c3a8: a0 10 00 08 mov %o0, %l0
if (rc > 0)
203c3ac: 80 a4 20 00 cmp %l0, 0
203c3b0: 04 80 00 09 ble 203c3d4 <rtems_rfs_inode_create+0x318> <== ALWAYS TAKEN
203c3b4: 90 10 00 18 mov %i0, %o0
{
rtems_rfs_inode_delete (fs, &inode);
203c3b8: 7f ff fe 8f call 203bdf4 <rtems_rfs_inode_delete> <== NOT EXECUTED
203c3bc: 01 00 00 00 nop <== NOT EXECUTED
rtems_rfs_inode_close (fs, &inode);
203c3c0: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
203c3c4: 92 07 bf d8 add %fp, -40, %o1 <== NOT EXECUTED
203c3c8: 7f ff fe 68 call 203bd68 <rtems_rfs_inode_close> <== NOT EXECUTED
203c3cc: b0 10 00 10 mov %l0, %i0 <== NOT EXECUTED
203c3d0: 30 80 00 0c b,a 203c400 <rtems_rfs_inode_create+0x344> <== NOT EXECUTED
return rc;
}
rc = rtems_rfs_inode_close (fs, &inode);
203c3d4: 7f ff fe 65 call 203bd68 <rtems_rfs_inode_close>
203c3d8: 01 00 00 00 nop
if (rc > 0)
203c3dc: a0 92 20 00 orcc %o0, 0, %l0
203c3e0: 24 80 00 07 ble,a 203c3fc <rtems_rfs_inode_create+0x340> <== ALWAYS TAKEN
203c3e4: a0 10 20 00 clr %l0
{
rtems_rfs_inode_free (fs, *ino);
203c3e8: d2 04 40 00 ld [ %l1 ], %o1 <== NOT EXECUTED
203c3ec: 7f ff fd bb call 203bad8 <rtems_rfs_inode_free> <== NOT EXECUTED
203c3f0: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
return rc;
}
return 0;
}
203c3f4: 81 c7 e0 08 ret <== NOT EXECUTED
203c3f8: 91 e8 00 10 restore %g0, %l0, %o0 <== NOT EXECUTED
203c3fc: b0 10 00 10 mov %l0, %i0
203c400: 81 c7 e0 08 ret
203c404: 81 e8 00 00 restore
0203bdf4 <rtems_rfs_inode_delete>:
}
int
rtems_rfs_inode_delete (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* handle)
{
203bdf4: 9d e3 bf 50 save %sp, -176, %sp
int rc = 0;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_DELETE))
203bdf8: 90 10 20 00 clr %o0
203bdfc: 7f ff 9f 14 call 2023a4c <rtems_rfs_trace>
203be00: 13 00 20 00 sethi %hi(0x800000), %o1
203be04: 80 8a 20 ff btst 0xff, %o0
203be08: 22 80 00 0f be,a 203be44 <rtems_rfs_inode_delete+0x50> <== ALWAYS TAKEN
203be0c: c4 06 60 0c ld [ %i1 + 0xc ], %g2
printf("rtems-rfs: inode-delete: ino:%" PRIu32 " loaded:%s\n",
203be10: c2 06 60 0c ld [ %i1 + 0xc ], %g1 <== NOT EXECUTED
203be14: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
203be18: 02 80 00 05 be 203be2c <rtems_rfs_inode_delete+0x38> <== NOT EXECUTED
203be1c: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED
203be20: 15 00 81 9e sethi %hi(0x2067800), %o2 <== NOT EXECUTED
203be24: 10 80 00 04 b 203be34 <rtems_rfs_inode_delete+0x40> <== NOT EXECUTED
203be28: 94 12 a3 88 or %o2, 0x388, %o2 ! 2067b88 <__FUNCTION__.7829+0xa98><== NOT EXECUTED
203be2c: 15 00 81 9e sethi %hi(0x2067800), %o2 <== NOT EXECUTED
203be30: 94 12 a3 90 or %o2, 0x390, %o2 ! 2067b90 <__FUNCTION__.7829+0xaa0><== NOT EXECUTED
203be34: 11 00 81 a4 sethi %hi(0x2069000), %o0 <== NOT EXECUTED
203be38: 40 00 2b 2c call 2046ae8 <printf> <== NOT EXECUTED
203be3c: 90 12 20 e0 or %o0, 0xe0, %o0 ! 20690e0 <__FUNCTION__.7829+0x1ff0><== NOT EXECUTED
rtems_rfs_inode_ino (handle),
rtems_rfs_inode_is_loaded (handle) ? "yes" : "no");
if (rtems_rfs_inode_is_loaded (handle))
203be40: c4 06 60 0c ld [ %i1 + 0xc ], %g2 <== NOT EXECUTED
203be44: 80 a0 a0 00 cmp %g2, 0
203be48: 02 80 00 1e be 203bec0 <rtems_rfs_inode_delete+0xcc> <== NEVER TAKEN
203be4c: 90 10 20 00 clr %o0
rtems_rfs_block_map map;
/*
* Free the ino number.
*/
rc = rtems_rfs_inode_free (fs, handle->ino);
203be50: d2 06 60 08 ld [ %i1 + 8 ], %o1
203be54: 7f ff ff 21 call 203bad8 <rtems_rfs_inode_free>
203be58: 90 10 00 18 mov %i0, %o0
if (rc > 0)
203be5c: 80 a2 20 00 cmp %o0, 0
203be60: 14 80 00 18 bg 203bec0 <rtems_rfs_inode_delete+0xcc> <== NEVER TAKEN
203be64: 92 10 00 19 mov %i1, %o1
return rc;
/*
* Free the blocks the inode may have attached.
*/
rc = rtems_rfs_block_map_open (fs, handle, &map);
203be68: 90 10 00 18 mov %i0, %o0
203be6c: 7f ff e9 d3 call 20365b8 <rtems_rfs_block_map_open>
203be70: 94 07 bf b0 add %fp, -80, %o2
if (rc == 0)
203be74: 80 a2 20 00 cmp %o0, 0
203be78: 12 80 00 12 bne 203bec0 <rtems_rfs_inode_delete+0xcc> <== NEVER TAKEN
203be7c: 92 07 bf b0 add %fp, -80, %o1
{
int rrc;
rrc = rtems_rfs_block_map_free_all (fs, &map);
203be80: 7f ff ec e3 call 203720c <rtems_rfs_block_map_free_all>
203be84: 90 10 00 18 mov %i0, %o0
rc = rtems_rfs_block_map_close (fs, &map);
203be88: 92 07 bf b0 add %fp, -80, %o1
203be8c: 7f ff ea 2c call 203673c <rtems_rfs_block_map_close>
203be90: 90 10 00 18 mov %i0, %o0
if (rc > 0)
rrc = rc;
memset (handle->node, 0xff, RTEMS_RFS_INODE_SIZE);
203be94: d0 06 60 0c ld [ %i1 + 0xc ], %o0
203be98: 92 10 20 ff mov 0xff, %o1
203be9c: 40 00 26 a2 call 2045924 <memset>
203bea0: 94 10 20 38 mov 0x38, %o2
rtems_rfs_buffer_mark_dirty (&handle->buffer);
203bea4: 82 10 20 01 mov 1, %g1
/*
* 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);
203bea8: 90 10 00 18 mov %i0, %o0
rrc = rtems_rfs_block_map_free_all (fs, &map);
rc = rtems_rfs_block_map_close (fs, &map);
if (rc > 0)
rrc = rc;
memset (handle->node, 0xff, RTEMS_RFS_INODE_SIZE);
rtems_rfs_buffer_mark_dirty (&handle->buffer);
203beac: c2 2e 60 10 stb %g1, [ %i1 + 0x10 ]
/*
* 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);
203beb0: 7f ff ed 3b call 203739c <rtems_rfs_buffer_handle_release>
203beb4: 92 06 60 10 add %i1, 0x10, %o1
handle->loads = 0;
203beb8: c0 26 60 24 clr [ %i1 + 0x24 ]
handle->node = NULL;
203bebc: c0 26 60 0c clr [ %i1 + 0xc ]
}
}
return rc;
}
203bec0: 81 c7 e0 08 ret
203bec4: 91 e8 00 08 restore %g0, %o0, %o0
020216f8 <rtems_rfs_inode_get_block>:
* @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]);
20216f8: c2 02 20 0c ld [ %o0 + 0xc ], %g1 <== NOT EXECUTED
20216fc: 92 02 60 06 add %o1, 6, %o1 <== NOT EXECUTED
2021700: 85 2a 60 02 sll %o1, 2, %g2 <== NOT EXECUTED
2021704: 84 00 40 02 add %g1, %g2, %g2 <== NOT EXECUTED
2021708: 82 00 a0 04 add %g2, 4, %g1 <== NOT EXECUTED
202170c: d0 08 a0 04 ldub [ %g2 + 4 ], %o0 <== NOT EXECUTED
2021710: c4 08 a0 05 ldub [ %g2 + 5 ], %g2 <== NOT EXECUTED
2021714: 91 2a 20 18 sll %o0, 0x18, %o0 <== NOT EXECUTED
2021718: 85 28 a0 10 sll %g2, 0x10, %g2 <== NOT EXECUTED
202171c: 90 12 00 02 or %o0, %g2, %o0 <== NOT EXECUTED
2021720: c4 08 60 03 ldub [ %g1 + 3 ], %g2 <== NOT EXECUTED
2021724: c2 08 60 02 ldub [ %g1 + 2 ], %g1 <== NOT EXECUTED
2021728: 90 12 00 02 or %o0, %g2, %o0 <== NOT EXECUTED
202172c: 83 28 60 08 sll %g1, 8, %g1 <== NOT EXECUTED
}
2021730: 81 c3 e0 08 retl <== NOT EXECUTED
2021734: 90 12 00 01 or %o0, %g1, %o0 <== NOT EXECUTED
0203baec <rtems_rfs_inode_load>:
}
int
rtems_rfs_inode_load (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* handle)
{
203baec: 9d e3 bf a0 save %sp, -96, %sp
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_LOAD))
203baf0: 90 10 20 00 clr %o0
203baf4: 7f ff 9f d6 call 2023a4c <rtems_rfs_trace>
203baf8: 13 00 04 00 sethi %hi(0x100000), %o1
203bafc: 80 8a 20 ff btst 0xff, %o0
203bb00: 02 80 00 0f be 203bb3c <rtems_rfs_inode_load+0x50> <== ALWAYS TAKEN
203bb04: c2 06 60 0c ld [ %i1 + 0xc ], %g1
printf ("rtems-rfs: inode-load: ino=%" PRIu32 " loads=%i loaded=%s\n",
203bb08: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED
203bb0c: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
203bb10: 02 80 00 05 be 203bb24 <rtems_rfs_inode_load+0x38> <== NOT EXECUTED
203bb14: d4 06 60 24 ld [ %i1 + 0x24 ], %o2 <== NOT EXECUTED
203bb18: 17 00 81 9e sethi %hi(0x2067800), %o3 <== NOT EXECUTED
203bb1c: 10 80 00 04 b 203bb2c <rtems_rfs_inode_load+0x40> <== NOT EXECUTED
203bb20: 96 12 e3 88 or %o3, 0x388, %o3 ! 2067b88 <__FUNCTION__.7829+0xa98><== NOT EXECUTED
203bb24: 17 00 81 9e sethi %hi(0x2067800), %o3 <== NOT EXECUTED
203bb28: 96 12 e3 90 or %o3, 0x390, %o3 ! 2067b90 <__FUNCTION__.7829+0xaa0><== NOT EXECUTED
203bb2c: 11 00 81 a3 sethi %hi(0x2068c00), %o0 <== NOT EXECUTED
203bb30: 40 00 2b ee call 2046ae8 <printf> <== NOT EXECUTED
203bb34: 90 12 23 f0 or %o0, 0x3f0, %o0 ! 2068ff0 <__FUNCTION__.7829+0x1f00><== NOT EXECUTED
/*
* An inode does not move so once loaded no need to do again.
*/
if (!rtems_rfs_inode_is_loaded (handle))
203bb38: c2 06 60 0c ld [ %i1 + 0xc ], %g1 <== NOT EXECUTED
203bb3c: 80 a0 60 00 cmp %g1, 0
203bb40: 32 80 00 13 bne,a 203bb8c <rtems_rfs_inode_load+0xa0>
203bb44: c2 06 60 24 ld [ %i1 + 0x24 ], %g1
{
int rc;
rc = rtems_rfs_buffer_handle_request (fs,&handle->buffer,
203bb48: d4 06 60 1c ld [ %i1 + 0x1c ], %o2
203bb4c: 90 10 00 18 mov %i0, %o0
203bb50: 92 06 60 10 add %i1, 0x10, %o1
203bb54: 7f ff ee 86 call 203756c <rtems_rfs_buffer_handle_request>
203bb58: 96 10 20 01 mov 1, %o3
handle->block, true);
if (rc > 0)
203bb5c: b0 92 20 00 orcc %o0, 0, %i0
203bb60: 14 80 00 0e bg 203bb98 <rtems_rfs_inode_load+0xac> <== NEVER TAKEN
203bb64: 01 00 00 00 nop
return rc;
handle->node = rtems_rfs_buffer_data (&handle->buffer);
203bb68: c4 06 60 18 ld [ %i1 + 0x18 ], %g2
handle->node += handle->offset;
203bb6c: c2 06 60 20 ld [ %i1 + 0x20 ], %g1
203bb70: c4 00 a0 1c ld [ %g2 + 0x1c ], %g2
203bb74: 87 28 60 03 sll %g1, 3, %g3
203bb78: 83 28 60 06 sll %g1, 6, %g1
203bb7c: 82 20 40 03 sub %g1, %g3, %g1
203bb80: 82 00 80 01 add %g2, %g1, %g1
203bb84: c2 26 60 0c st %g1, [ %i1 + 0xc ]
}
handle->loads++;
203bb88: c2 06 60 24 ld [ %i1 + 0x24 ], %g1
return 0;
203bb8c: b0 10 20 00 clr %i0
handle->node = rtems_rfs_buffer_data (&handle->buffer);
handle->node += handle->offset;
}
handle->loads++;
203bb90: 82 00 60 01 inc %g1
203bb94: c2 26 60 24 st %g1, [ %i1 + 0x24 ]
return 0;
}
203bb98: 81 c7 e0 08 ret
203bb9c: 81 e8 00 00 restore
0203bba0 <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)
{
203bba0: 9d e3 bf a0 save %sp, -96, %sp
int group;
int gino;
int index;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_OPEN))
203bba4: 90 10 20 00 clr %o0
203bba8: 7f ff 9f a9 call 2023a4c <rtems_rfs_trace>
203bbac: 13 00 01 00 sethi %hi(0x40000), %o1
203bbb0: 80 8a 20 ff btst 0xff, %o0
203bbb4: 02 80 00 07 be 203bbd0 <rtems_rfs_inode_open+0x30> <== ALWAYS TAKEN
203bbb8: 80 a6 60 00 cmp %i1, 0
printf ("rtems-rfs: inode-open: ino: %" PRIu32 "\n", ino);
203bbbc: 11 00 81 a4 sethi %hi(0x2069000), %o0 <== NOT EXECUTED
203bbc0: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
203bbc4: 40 00 2b c9 call 2046ae8 <printf> <== NOT EXECUTED
203bbc8: 90 12 20 28 or %o0, 0x28, %o0 <== NOT EXECUTED
if (ino == RTEMS_RFS_EMPTY_INO)
203bbcc: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED
203bbd0: 02 80 00 28 be 203bc70 <rtems_rfs_inode_open+0xd0> <== NEVER TAKEN
203bbd4: 82 10 20 16 mov 0x16, %g1
return EINVAL;
if ((ino - RTEMS_RFS_ROOT_INO) > rtems_rfs_fs_inodes (fs))
203bbd8: c4 06 20 14 ld [ %i0 + 0x14 ], %g2
203bbdc: ba 06 7f ff add %i1, -1, %i5
203bbe0: 80 a7 40 02 cmp %i5, %g2
203bbe4: 18 80 00 23 bgu 203bc70 <rtems_rfs_inode_open+0xd0> <== NEVER TAKEN
203bbe8: 90 10 00 1d mov %i5, %o0
return EINVAL;
handle->ino = ino;
203bbec: f2 26 a0 08 st %i1, [ %i2 + 8 ]
handle->node = NULL;
handle->loads = 0;
gino = ino - RTEMS_RFS_ROOT_INO;
group = gino / fs->group_inodes;
203bbf0: f2 06 20 2c ld [ %i0 + 0x2c ], %i1
gino = gino % fs->group_inodes;
203bbf4: 92 10 00 19 mov %i1, %o1
if ((ino - RTEMS_RFS_ROOT_INO) > rtems_rfs_fs_inodes (fs))
return EINVAL;
handle->ino = ino;
handle->node = NULL;
203bbf8: c0 26 a0 0c clr [ %i2 + 0xc ]
handle->loads = 0;
gino = ino - RTEMS_RFS_ROOT_INO;
group = gino / fs->group_inodes;
gino = gino % fs->group_inodes;
203bbfc: 40 00 7f 0d call 205b830 <.urem>
203bc00: c0 26 a0 24 clr [ %i2 + 0x24 ]
index = (gino / fs->inodes_per_block) + RTEMS_RFS_GROUP_INODE_BLOCK;
203bc04: f8 06 20 30 ld [ %i0 + 0x30 ], %i4
handle->node = NULL;
handle->loads = 0;
gino = ino - RTEMS_RFS_ROOT_INO;
group = gino / fs->group_inodes;
gino = gino % fs->group_inodes;
203bc08: a0 10 00 08 mov %o0, %l0
index = (gino / fs->inodes_per_block) + RTEMS_RFS_GROUP_INODE_BLOCK;
handle->offset = gino % fs->inodes_per_block;
203bc0c: 40 00 7f 09 call 205b830 <.urem>
203bc10: 92 10 00 1c mov %i4, %o1
handle->ino = ino;
handle->node = NULL;
handle->loads = 0;
gino = ino - RTEMS_RFS_ROOT_INO;
group = gino / fs->group_inodes;
203bc14: 92 10 00 19 mov %i1, %o1
gino = gino % fs->group_inodes;
index = (gino / fs->inodes_per_block) + RTEMS_RFS_GROUP_INODE_BLOCK;
handle->offset = gino % fs->inodes_per_block;
203bc18: d0 26 a0 20 st %o0, [ %i2 + 0x20 ]
handle->ino = ino;
handle->node = NULL;
handle->loads = 0;
gino = ino - RTEMS_RFS_ROOT_INO;
group = gino / fs->group_inodes;
203bc1c: 40 00 7e 59 call 205b580 <.udiv>
203bc20: 90 10 00 1d mov %i5, %o0
gino = gino % fs->group_inodes;
index = (gino / fs->inodes_per_block) + RTEMS_RFS_GROUP_INODE_BLOCK;
handle->offset = gino % fs->inodes_per_block;
handle->block = rtems_rfs_group_block (&fs->groups[group], index);
203bc24: c4 06 20 20 ld [ %i0 + 0x20 ], %g2
203bc28: 87 2a 20 04 sll %o0, 4, %g3
203bc2c: 83 2a 20 06 sll %o0, 6, %g1
203bc30: 82 00 c0 01 add %g3, %g1, %g1
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;
203bc34: fa 00 80 01 ld [ %g2 + %g1 ], %i5
203bc38: 90 10 00 10 mov %l0, %o0
203bc3c: ba 07 60 02 add %i5, 2, %i5
203bc40: 40 00 7e 50 call 205b580 <.udiv>
203bc44: 92 10 00 1c mov %i4, %o1
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
203bc48: c0 2e a0 10 clrb [ %i2 + 0x10 ]
handle->offset = gino % fs->inodes_per_block;
handle->block = rtems_rfs_group_block (&fs->groups[group], index);
203bc4c: 90 07 40 08 add %i5, %o0, %o0
handle->bnum = 0;
203bc50: c0 26 a0 14 clr [ %i2 + 0x14 ]
203bc54: d0 26 a0 1c st %o0, [ %i2 + 0x1c ]
handle->buffer = NULL;
203bc58: c0 26 a0 18 clr [ %i2 + 0x18 ]
rc = rtems_rfs_buffer_handle_open (fs, &handle->buffer);
if ((rc == 0) && load)
203bc5c: 80 a6 e0 00 cmp %i3, 0
203bc60: 02 80 00 04 be 203bc70 <rtems_rfs_inode_open+0xd0> <== NEVER TAKEN
203bc64: 82 10 20 00 clr %g1
rc = rtems_rfs_inode_load (fs, handle);
203bc68: 7f ff ff a1 call 203baec <rtems_rfs_inode_load>
203bc6c: 93 e8 00 1a restore %g0, %i2, %o1
return rc;
}
203bc70: 81 c7 e0 08 ret <== NOT EXECUTED
203bc74: 91 e8 00 01 restore %g0, %g1, %o0 <== NOT EXECUTED
02021738 <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);
2021738: c2 02 20 0c ld [ %o0 + 0xc ], %g1 <== NOT EXECUTED
202173c: 92 02 60 06 add %o1, 6, %o1 <== NOT EXECUTED
2021740: 93 2a 60 02 sll %o1, 2, %o1 <== NOT EXECUTED
2021744: 82 00 40 09 add %g1, %o1, %g1 <== NOT EXECUTED
2021748: 85 32 a0 18 srl %o2, 0x18, %g2 <== NOT EXECUTED
202174c: c4 28 60 04 stb %g2, [ %g1 + 4 ] <== NOT EXECUTED
2021750: c2 02 20 0c ld [ %o0 + 0xc ], %g1 <== NOT EXECUTED
2021754: 85 32 a0 10 srl %o2, 0x10, %g2 <== NOT EXECUTED
2021758: 82 00 40 09 add %g1, %o1, %g1 <== NOT EXECUTED
202175c: c4 28 60 05 stb %g2, [ %g1 + 5 ] <== NOT EXECUTED
2021760: c2 02 20 0c ld [ %o0 + 0xc ], %g1 <== NOT EXECUTED
2021764: 85 32 a0 08 srl %o2, 8, %g2 <== NOT EXECUTED
2021768: 82 00 40 09 add %g1, %o1, %g1 <== NOT EXECUTED
202176c: c4 28 60 06 stb %g2, [ %g1 + 6 ] <== NOT EXECUTED
2021770: c2 02 20 0c ld [ %o0 + 0xc ], %g1 <== NOT EXECUTED
2021774: 92 00 40 09 add %g1, %o1, %o1 <== NOT EXECUTED
2021778: d4 2a 60 07 stb %o2, [ %o1 + 7 ] <== NOT EXECUTED
rtems_rfs_buffer_mark_dirty (&handle->buffer);
202177c: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED
2021780: 81 c3 e0 08 retl <== NOT EXECUTED
2021784: c2 2a 20 10 stb %g1, [ %o0 + 0x10 ] <== NOT EXECUTED
0203bec8 <rtems_rfs_inode_time_stamp_now>:
int
rtems_rfs_inode_time_stamp_now (rtems_rfs_inode_handle* handle,
bool atime,
bool mtime)
{
203bec8: 9d e3 bf a0 save %sp, -96, %sp
time_t now;
if (!rtems_rfs_inode_is_loaded (handle))
203becc: c2 06 20 0c ld [ %i0 + 0xc ], %g1
int
rtems_rfs_inode_time_stamp_now (rtems_rfs_inode_handle* handle,
bool atime,
bool mtime)
{
203bed0: ba 10 00 18 mov %i0, %i5
time_t now;
if (!rtems_rfs_inode_is_loaded (handle))
203bed4: 80 a0 60 00 cmp %g1, 0
203bed8: 02 80 00 23 be 203bf64 <rtems_rfs_inode_time_stamp_now+0x9c><== NEVER TAKEN
203bedc: b0 10 20 06 mov 6, %i0
return ENXIO;
now = time (NULL);
203bee0: 40 00 4b 31 call 204eba4 <time>
203bee4: 90 10 20 00 clr %o0
if (atime)
203bee8: 80 a6 60 00 cmp %i1, 0
203beec: 02 80 00 0f be 203bf28 <rtems_rfs_inode_time_stamp_now+0x60><== NEVER TAKEN
203bef0: 80 a6 a0 00 cmp %i2, 0
*/
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);
203bef4: c2 07 60 0c ld [ %i5 + 0xc ], %g1
203bef8: 85 32 20 18 srl %o0, 0x18, %g2
203befc: c4 28 60 10 stb %g2, [ %g1 + 0x10 ]
203bf00: c2 07 60 0c ld [ %i5 + 0xc ], %g1
203bf04: 85 32 20 10 srl %o0, 0x10, %g2
203bf08: c4 28 60 11 stb %g2, [ %g1 + 0x11 ]
203bf0c: c2 07 60 0c ld [ %i5 + 0xc ], %g1
203bf10: 85 32 20 08 srl %o0, 8, %g2
203bf14: c4 28 60 12 stb %g2, [ %g1 + 0x12 ]
203bf18: c2 07 60 0c ld [ %i5 + 0xc ], %g1
203bf1c: d0 28 60 13 stb %o0, [ %g1 + 0x13 ]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
203bf20: 82 10 20 01 mov 1, %g1
203bf24: c2 2f 60 10 stb %g1, [ %i5 + 0x10 ]
rtems_rfs_inode_set_atime (handle, now);
if (mtime)
203bf28: 02 80 00 0f be 203bf64 <rtems_rfs_inode_time_stamp_now+0x9c><== NEVER TAKEN
203bf2c: b0 10 20 00 clr %i0
*/
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);
203bf30: c2 07 60 0c ld [ %i5 + 0xc ], %g1
203bf34: 85 32 20 18 srl %o0, 0x18, %g2
203bf38: c4 28 60 14 stb %g2, [ %g1 + 0x14 ]
203bf3c: c2 07 60 0c ld [ %i5 + 0xc ], %g1
203bf40: 85 32 20 10 srl %o0, 0x10, %g2
203bf44: c4 28 60 15 stb %g2, [ %g1 + 0x15 ]
203bf48: c2 07 60 0c ld [ %i5 + 0xc ], %g1
203bf4c: 85 32 20 08 srl %o0, 8, %g2
203bf50: c4 28 60 16 stb %g2, [ %g1 + 0x16 ]
203bf54: c2 07 60 0c ld [ %i5 + 0xc ], %g1
203bf58: d0 28 60 17 stb %o0, [ %g1 + 0x17 ]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
203bf5c: 82 10 20 01 mov 1, %g1
203bf60: c2 2f 60 10 stb %g1, [ %i5 + 0x10 ]
rtems_rfs_inode_set_mtime (handle, now);
return 0;
}
203bf64: 81 c7 e0 08 ret
203bf68: 81 e8 00 00 restore
0203bc78 <rtems_rfs_inode_unload>:
int
rtems_rfs_inode_unload (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* handle,
bool update_ctime)
{
203bc78: 9d e3 bf a0 save %sp, -96, %sp
int rc = 0;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_UNLOAD))
203bc7c: 90 10 20 00 clr %o0
203bc80: 7f ff 9f 73 call 2023a4c <rtems_rfs_trace>
203bc84: 13 00 08 00 sethi %hi(0x200000), %o1
203bc88: 80 8a 20 ff btst 0xff, %o0
203bc8c: 02 80 00 0f be 203bcc8 <rtems_rfs_inode_unload+0x50> <== ALWAYS TAKEN
203bc90: c2 06 60 0c ld [ %i1 + 0xc ], %g1
printf ("rtems-rfs: inode-unload: ino=%" PRIu32 " loads=%i loaded=%s\n",
203bc94: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED
203bc98: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
203bc9c: 02 80 00 05 be 203bcb0 <rtems_rfs_inode_unload+0x38> <== NOT EXECUTED
203bca0: d4 06 60 24 ld [ %i1 + 0x24 ], %o2 <== NOT EXECUTED
203bca4: 17 00 81 9e sethi %hi(0x2067800), %o3 <== NOT EXECUTED
203bca8: 10 80 00 04 b 203bcb8 <rtems_rfs_inode_unload+0x40> <== NOT EXECUTED
203bcac: 96 12 e3 88 or %o3, 0x388, %o3 ! 2067b88 <__FUNCTION__.7829+0xa98><== NOT EXECUTED
203bcb0: 17 00 81 9e sethi %hi(0x2067800), %o3 <== NOT EXECUTED
203bcb4: 96 12 e3 90 or %o3, 0x390, %o3 ! 2067b90 <__FUNCTION__.7829+0xaa0><== NOT EXECUTED
203bcb8: 11 00 81 a4 sethi %hi(0x2069000), %o0 <== NOT EXECUTED
203bcbc: 40 00 2b 8b call 2046ae8 <printf> <== NOT EXECUTED
203bcc0: 90 12 20 50 or %o0, 0x50, %o0 ! 2069050 <__FUNCTION__.7829+0x1f60><== NOT EXECUTED
handle->ino, handle->loads,
rtems_rfs_inode_is_loaded (handle) ? "yes" : "no");
if (rtems_rfs_inode_is_loaded (handle))
203bcc4: c2 06 60 0c ld [ %i1 + 0xc ], %g1 <== NOT EXECUTED
203bcc8: 80 a0 60 00 cmp %g1, 0
203bccc: 32 80 00 04 bne,a 203bcdc <rtems_rfs_inode_unload+0x64>
203bcd0: c4 06 60 24 ld [ %i1 + 0x24 ], %g2
int
rtems_rfs_inode_unload (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* handle,
bool update_ctime)
{
int rc = 0;
203bcd4: 10 80 00 23 b 203bd60 <rtems_rfs_inode_unload+0xe8>
203bcd8: 90 10 20 00 clr %o0
handle->ino, handle->loads,
rtems_rfs_inode_is_loaded (handle) ? "yes" : "no");
if (rtems_rfs_inode_is_loaded (handle))
{
if (handle->loads == 0)
203bcdc: 80 a0 a0 00 cmp %g2, 0
203bce0: 02 80 00 20 be 203bd60 <rtems_rfs_inode_unload+0xe8> <== NEVER TAKEN
203bce4: 90 10 20 05 mov 5, %o0
return EIO;
handle->loads--;
203bce8: 82 00 bf ff add %g2, -1, %g1
if (handle->loads == 0)
203bcec: 80 a0 60 00 cmp %g1, 0
203bcf0: 12 bf ff f9 bne 203bcd4 <rtems_rfs_inode_unload+0x5c>
203bcf4: c2 26 60 24 st %g1, [ %i1 + 0x24 ]
{
/*
* If the buffer is dirty it will be release. Also set the ctime.
*/
if (rtems_rfs_buffer_dirty (&handle->buffer) && update_ctime)
203bcf8: c2 0e 60 10 ldub [ %i1 + 0x10 ], %g1
203bcfc: 80 a0 60 00 cmp %g1, 0
203bd00: 02 80 00 15 be 203bd54 <rtems_rfs_inode_unload+0xdc>
203bd04: 90 10 00 18 mov %i0, %o0
203bd08: 80 a6 a0 00 cmp %i2, 0
203bd0c: 02 80 00 12 be 203bd54 <rtems_rfs_inode_unload+0xdc> <== NEVER TAKEN
203bd10: 01 00 00 00 nop
rtems_rfs_inode_set_ctime (handle, time (NULL));
203bd14: 40 00 4b a4 call 204eba4 <time>
203bd18: 90 10 20 00 clr %o0 ! 0 <PROM_START>
*/
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);
203bd1c: c4 06 60 0c ld [ %i1 + 0xc ], %g2
203bd20: 87 32 20 18 srl %o0, 0x18, %g3
203bd24: c6 28 a0 18 stb %g3, [ %g2 + 0x18 ]
203bd28: c4 06 60 0c ld [ %i1 + 0xc ], %g2
203bd2c: 87 32 20 10 srl %o0, 0x10, %g3
203bd30: c6 28 a0 19 stb %g3, [ %g2 + 0x19 ]
203bd34: c4 06 60 0c ld [ %i1 + 0xc ], %g2
203bd38: 87 32 20 08 srl %o0, 8, %g3
203bd3c: c6 28 a0 1a stb %g3, [ %g2 + 0x1a ]
203bd40: c4 06 60 0c ld [ %i1 + 0xc ], %g2
rtems_rfs_buffer_mark_dirty (&handle->buffer);
203bd44: 82 10 20 01 mov 1, %g1
*/
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);
203bd48: d0 28 a0 1b stb %o0, [ %g2 + 0x1b ]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
203bd4c: c2 2e 60 10 stb %g1, [ %i1 + 0x10 ]
rc = rtems_rfs_buffer_handle_release (fs, &handle->buffer);
203bd50: 90 10 00 18 mov %i0, %o0
203bd54: 7f ff ed 92 call 203739c <rtems_rfs_buffer_handle_release>
203bd58: 92 06 60 10 add %i1, 0x10, %o1
handle->node = NULL;
203bd5c: c0 26 60 0c clr [ %i1 + 0xc ]
}
}
return rc;
}
203bd60: 81 c7 e0 08 ret
203bd64: 91 e8 00 08 restore %g0, %o0, %o0
0203c4a4 <rtems_rfs_link>:
const char* name,
int length,
rtems_rfs_ino parent,
rtems_rfs_ino target,
bool link_dir)
{
203c4a4: 9d e3 bf 50 save %sp, -176, %sp
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))
203c4a8: 90 10 20 00 clr %o0
203c4ac: 7f ff 9d 68 call 2023a4c <rtems_rfs_trace>
203c4b0: 13 00 40 00 sethi %hi(0x1000000), %o1
203c4b4: 80 8a 20 ff btst 0xff, %o0
203c4b8: 02 80 00 13 be 203c504 <rtems_rfs_link+0x60> <== ALWAYS TAKEN
203c4bc: 90 10 00 18 mov %i0, %o0
{
int c;
printf ("rtems-rfs: link: parent(%" PRIu32 ") -> ", parent);
203c4c0: 11 00 81 a4 sethi %hi(0x2069000), %o0 <== NOT EXECUTED
203c4c4: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
203c4c8: 90 12 21 70 or %o0, 0x170, %o0 <== NOT EXECUTED
203c4cc: 40 00 29 87 call 2046ae8 <printf> <== NOT EXECUTED
203c4d0: a0 10 20 00 clr %l0 <== NOT EXECUTED
for (c = 0; c < length; c++)
203c4d4: 10 80 00 05 b 203c4e8 <rtems_rfs_link+0x44> <== NOT EXECUTED
203c4d8: 80 a4 00 1a cmp %l0, %i2 <== NOT EXECUTED
printf ("%c", name[c]);
203c4dc: 40 00 29 ed call 2046c90 <putchar> <== NOT EXECUTED
203c4e0: a0 04 20 01 inc %l0 <== 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++)
203c4e4: 80 a4 00 1a cmp %l0, %i2 <== NOT EXECUTED
203c4e8: 26 bf ff fd bl,a 203c4dc <rtems_rfs_link+0x38> <== NOT EXECUTED
203c4ec: d0 4e 40 10 ldsb [ %i1 + %l0 ], %o0 <== NOT EXECUTED
printf ("%c", name[c]);
printf ("(%" PRIu32 ")\n", target);
203c4f0: 11 00 81 a4 sethi %hi(0x2069000), %o0 <== NOT EXECUTED
203c4f4: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
203c4f8: 40 00 29 7c call 2046ae8 <printf> <== NOT EXECUTED
203c4fc: 90 12 21 98 or %o0, 0x198, %o0 <== NOT EXECUTED
}
rc = rtems_rfs_inode_open (fs, target, &target_inode, true);
203c500: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
203c504: 92 10 00 1c mov %i4, %o1
203c508: 94 07 bf d8 add %fp, -40, %o2
203c50c: 7f ff fd a5 call 203bba0 <rtems_rfs_inode_open>
203c510: 96 10 20 01 mov 1, %o3
if (rc)
203c514: a0 92 20 00 orcc %o0, 0, %l0
203c518: 12 80 00 49 bne 203c63c <rtems_rfs_link+0x198> <== NEVER TAKEN
203c51c: 80 a7 60 00 cmp %i5, 0
/*
* 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)))
203c520: 12 80 00 10 bne 203c560 <rtems_rfs_link+0xbc> <== NEVER TAKEN
203c524: 90 10 00 18 mov %i0, %o0
* @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);
203c528: c2 07 bf e4 ld [ %fp + -28 ], %g1
203c52c: c4 08 60 02 ldub [ %g1 + 2 ], %g2
203c530: 03 00 00 3c sethi %hi(0xf000), %g1
203c534: 85 28 a0 08 sll %g2, 8, %g2
203c538: 84 08 80 01 and %g2, %g1, %g2
203c53c: 03 00 00 10 sethi %hi(0x4000), %g1
203c540: 80 a0 80 01 cmp %g2, %g1
203c544: 12 80 00 08 bne 203c564 <rtems_rfs_link+0xc0> <== ALWAYS TAKEN
203c548: 92 10 00 1b mov %i3, %o1
{
rtems_rfs_inode_close (fs, &target_inode);
203c54c: 92 07 bf d8 add %fp, -40, %o1 <== NOT EXECUTED
203c550: 7f ff fe 06 call 203bd68 <rtems_rfs_inode_close> <== NOT EXECUTED
203c554: a0 10 20 86 mov 0x86, %l0 <== NOT EXECUTED
}
rc = rtems_rfs_inode_close (fs, &target_inode);
return rc;
}
203c558: 81 c7 e0 08 ret <== NOT EXECUTED
203c55c: 91 e8 00 10 restore %g0, %l0, %o0 <== NOT EXECUTED
{
rtems_rfs_inode_close (fs, &target_inode);
return ENOTSUP;
}
rc = rtems_rfs_inode_open (fs, parent, &parent_inode, true);
203c560: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
203c564: 94 07 bf b0 add %fp, -80, %o2
203c568: 7f ff fd 8e call 203bba0 <rtems_rfs_inode_open>
203c56c: 96 10 20 01 mov 1, %o3
203c570: a0 10 00 08 mov %o0, %l0
if (rc)
203c574: 80 a4 20 00 cmp %l0, 0
203c578: 02 80 00 04 be 203c588 <rtems_rfs_link+0xe4> <== ALWAYS TAKEN
203c57c: 90 10 00 18 mov %i0, %o0
rc = rtems_rfs_dir_add_entry (fs, &parent_inode, name, length, target);
if (rc > 0)
{
rtems_rfs_inode_close (fs, &parent_inode);
rtems_rfs_inode_close (fs, &target_inode);
203c580: 10 80 00 0f b 203c5bc <rtems_rfs_link+0x118> <== NOT EXECUTED
203c584: 92 07 bf d8 add %fp, -40, %o1 <== NOT EXECUTED
{
rtems_rfs_inode_close (fs, &target_inode);
return rc;
}
rc = rtems_rfs_dir_add_entry (fs, &parent_inode, name, length, target);
203c588: 92 07 bf b0 add %fp, -80, %o1
203c58c: 94 10 00 19 mov %i1, %o2
203c590: 96 10 00 1a mov %i2, %o3
203c594: 7f ff ee f3 call 2038160 <rtems_rfs_dir_add_entry>
203c598: 98 10 00 1c mov %i4, %o4
if (rc > 0)
203c59c: a0 92 20 00 orcc %o0, 0, %l0
203c5a0: 04 80 00 0a ble 203c5c8 <rtems_rfs_link+0x124> <== ALWAYS TAKEN
203c5a4: 92 07 bf b0 add %fp, -80, %o1
{
rtems_rfs_inode_close (fs, &parent_inode);
203c5a8: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
203c5ac: 7f ff fd ef call 203bd68 <rtems_rfs_inode_close> <== NOT EXECUTED
203c5b0: 01 00 00 00 nop <== NOT EXECUTED
rtems_rfs_inode_close (fs, &target_inode);
203c5b4: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
203c5b8: 92 07 bf d8 add %fp, -40, %o1 <== NOT EXECUTED
203c5bc: 7f ff fd eb call 203bd68 <rtems_rfs_inode_close> <== NOT EXECUTED
203c5c0: b0 10 00 10 mov %l0, %i0 <== NOT EXECUTED
203c5c4: 30 80 00 1f b,a 203c640 <rtems_rfs_link+0x19c> <== NOT EXECUTED
return rc;
}
links = rtems_rfs_inode_get_links (&target_inode) + 1;
203c5c8: 7f ff ff a8 call 203c468 <rtems_rfs_inode_get_links>
203c5cc: 90 07 bf d8 add %fp, -40, %o0
* @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);
203c5d0: c2 07 bf e4 ld [ %fp + -28 ], %g1
203c5d4: 90 02 20 01 inc %o0
203c5d8: 85 32 20 08 srl %o0, 8, %g2
203c5dc: c4 28 40 00 stb %g2, [ %g1 ]
203c5e0: c2 07 bf e4 ld [ %fp + -28 ], %g1
rtems_rfs_inode_set_links (&target_inode, links);
rc = rtems_rfs_inode_time_stamp_now (&parent_inode, true, true);
203c5e4: 92 10 20 01 mov 1, %o1
203c5e8: d0 28 60 01 stb %o0, [ %g1 + 1 ]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
203c5ec: 82 10 20 01 mov 1, %g1
203c5f0: 90 07 bf b0 add %fp, -80, %o0
203c5f4: c2 2f bf e8 stb %g1, [ %fp + -24 ]
203c5f8: 7f ff fe 34 call 203bec8 <rtems_rfs_inode_time_stamp_now>
203c5fc: 94 10 20 01 mov 1, %o2
if (rc > 0)
{
rtems_rfs_inode_close (fs, &parent_inode);
203c600: 92 07 bf b0 add %fp, -80, %o1
}
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);
203c604: a0 10 00 08 mov %o0, %l0
if (rc > 0)
203c608: 80 a4 20 00 cmp %l0, 0
203c60c: 14 bf ff e8 bg 203c5ac <rtems_rfs_link+0x108> <== NEVER TAKEN
203c610: 90 10 00 18 mov %i0, %o0
rtems_rfs_inode_close (fs, &parent_inode);
rtems_rfs_inode_close (fs, &target_inode);
return rc;
}
rc = rtems_rfs_inode_close (fs, &parent_inode);
203c614: 7f ff fd d5 call 203bd68 <rtems_rfs_inode_close>
203c618: 01 00 00 00 nop
if (rc > 0)
{
rtems_rfs_inode_close (fs, &target_inode);
203c61c: 92 07 bf d8 add %fp, -40, %o1
rtems_rfs_inode_close (fs, &parent_inode);
rtems_rfs_inode_close (fs, &target_inode);
return rc;
}
rc = rtems_rfs_inode_close (fs, &parent_inode);
203c620: a0 10 00 08 mov %o0, %l0
if (rc > 0)
203c624: 80 a4 20 00 cmp %l0, 0
203c628: 14 bf ff e5 bg 203c5bc <rtems_rfs_link+0x118> <== NEVER TAKEN
203c62c: 90 10 00 18 mov %i0, %o0
{
rtems_rfs_inode_close (fs, &target_inode);
return rc;
}
rc = rtems_rfs_inode_close (fs, &target_inode);
203c630: 7f ff fd ce call 203bd68 <rtems_rfs_inode_close>
203c634: 01 00 00 00 nop
203c638: a0 10 00 08 mov %o0, %l0
return rc;
}
203c63c: b0 10 00 10 mov %l0, %i0
203c640: 81 c7 e0 08 ret
203c644: 81 e8 00 00 restore
0203ce20 <rtems_rfs_mutex_create>:
RTEMS_INHERIT_PRIORITY | RTEMS_NO_PRIORITY_CEILING | RTEMS_LOCAL)
#endif
int
rtems_rfs_mutex_create (rtems_rfs_mutex* mutex)
{
203ce20: 9d e3 bf a0 save %sp, -96, %sp
#if __rtems__
rtems_status_code sc;
sc = rtems_semaphore_create (rtems_build_name ('R', 'F', 'S', 'm'),
203ce24: 11 14 91 94 sethi %hi(0x52465000), %o0
203ce28: 98 10 00 18 mov %i0, %o4
203ce2c: 90 12 23 6d or %o0, 0x36d, %o0
203ce30: 92 10 20 01 mov 1, %o1
203ce34: 94 10 20 54 mov 0x54, %o2
203ce38: 96 10 20 00 clr %o3
203ce3c: 7f ff 40 e6 call 200d1d4 <rtems_semaphore_create>
203ce40: b0 10 20 00 clr %i0
1, RTEMS_RFS_MUTEX_ATTRIBS, 0,
mutex);
if (sc != RTEMS_SUCCESSFUL)
203ce44: 80 a2 20 00 cmp %o0, 0
203ce48: 02 80 00 0f be 203ce84 <rtems_rfs_mutex_create+0x64> <== ALWAYS TAKEN
203ce4c: ba 10 00 08 mov %o0, %i5
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
203ce50: 90 10 20 00 clr %o0 <== NOT EXECUTED
203ce54: 92 10 20 04 mov 4, %o1 <== NOT EXECUTED
203ce58: 7f ff 9a fd call 2023a4c <rtems_rfs_trace> <== NOT EXECUTED
203ce5c: b0 10 20 05 mov 5, %i0 <== NOT EXECUTED
203ce60: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
203ce64: 02 80 00 08 be 203ce84 <rtems_rfs_mutex_create+0x64> <== NOT EXECUTED
203ce68: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: mutex: open failed: %s\n",
203ce6c: 7f ff 2e c7 call 2008988 <rtems_status_text> <== NOT EXECUTED
203ce70: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
203ce74: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED
203ce78: 11 00 81 a4 sethi %hi(0x2069000), %o0 <== NOT EXECUTED
203ce7c: 40 00 27 1b call 2046ae8 <printf> <== NOT EXECUTED
203ce80: 90 12 23 c8 or %o0, 0x3c8, %o0 ! 20693c8 <__FUNCTION__.7829+0x22d8><== NOT EXECUTED
rtems_status_text (sc));
return EIO;
}
#endif
return 0;
}
203ce84: 81 c7 e0 08 ret
203ce88: 81 e8 00 00 restore
0203ce8c <rtems_rfs_mutex_destroy>:
int
rtems_rfs_mutex_destroy (rtems_rfs_mutex* mutex)
{
203ce8c: 9d e3 bf a0 save %sp, -96, %sp
#if __rtems__
rtems_status_code sc;
sc = rtems_semaphore_delete (*mutex);
203ce90: d0 06 00 00 ld [ %i0 ], %o0
203ce94: 7f ff 41 3f call 200d390 <rtems_semaphore_delete>
203ce98: b0 10 20 00 clr %i0
if (sc != RTEMS_SUCCESSFUL)
203ce9c: 80 a2 20 00 cmp %o0, 0
203cea0: 02 80 00 0f be 203cedc <rtems_rfs_mutex_destroy+0x50> <== ALWAYS TAKEN
203cea4: ba 10 00 08 mov %o0, %i5
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
203cea8: 90 10 20 00 clr %o0 <== NOT EXECUTED
203ceac: 92 10 20 04 mov 4, %o1 <== NOT EXECUTED
203ceb0: 7f ff 9a e7 call 2023a4c <rtems_rfs_trace> <== NOT EXECUTED
203ceb4: b0 10 20 05 mov 5, %i0 <== NOT EXECUTED
203ceb8: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
203cebc: 02 80 00 08 be 203cedc <rtems_rfs_mutex_destroy+0x50> <== NOT EXECUTED
203cec0: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: mutex: close failed: %s\n",
203cec4: 7f ff 2e b1 call 2008988 <rtems_status_text> <== NOT EXECUTED
203cec8: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
203cecc: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED
203ced0: 11 00 81 a4 sethi %hi(0x2069000), %o0 <== NOT EXECUTED
203ced4: 40 00 27 05 call 2046ae8 <printf> <== NOT EXECUTED
203ced8: 90 12 23 f0 or %o0, 0x3f0, %o0 ! 20693f0 <__FUNCTION__.7829+0x2300><== NOT EXECUTED
rtems_status_text (sc));
return EIO;
}
#endif
return 0;
}
203cedc: 81 c7 e0 08 ret
203cee0: 81 e8 00 00 restore
0203d0fc <rtems_rfs_mutex_lock.isra.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)
203d0fc: 9d e3 bf a0 save %sp, -96, %sp
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
203d100: 92 10 20 00 clr %o1
203d104: 90 10 00 18 mov %i0, %o0
203d108: 94 10 20 00 clr %o2
203d10c: 7f ff 40 ea call 200d4b4 <rtems_semaphore_obtain>
203d110: b0 10 20 00 clr %i0
if (sc != RTEMS_SUCCESSFUL)
203d114: 80 a2 20 00 cmp %o0, 0
203d118: 02 80 00 0f be 203d154 <rtems_rfs_mutex_lock.isra.0+0x58> <== ALWAYS TAKEN
203d11c: ba 10 00 08 mov %o0, %i5
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
203d120: 90 10 20 00 clr %o0 <== NOT EXECUTED
203d124: 92 10 20 04 mov 4, %o1 <== NOT EXECUTED
203d128: 7f ff 9a 49 call 2023a4c <rtems_rfs_trace> <== NOT EXECUTED
203d12c: b0 10 20 05 mov 5, %i0 <== NOT EXECUTED
203d130: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
203d134: 02 80 00 08 be 203d154 <rtems_rfs_mutex_lock.isra.0+0x58> <== NOT EXECUTED
203d138: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: mutex: obtain failed: %s\n",
203d13c: 7f ff 2e 13 call 2008988 <rtems_status_text> <== NOT EXECUTED
203d140: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
203d144: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED
203d148: 11 00 81 8a sethi %hi(0x2062800), %o0 <== NOT EXECUTED
203d14c: 40 00 26 67 call 2046ae8 <printf> <== NOT EXECUTED
203d150: 90 12 22 50 or %o0, 0x250, %o0 ! 2062a50 <rtems_nvdisk_sram_handlers+0x34><== NOT EXECUTED
#endif
return EIO;
}
#endif
return 0;
}
203d154: 81 c7 e0 08 ret
203d158: 81 e8 00 00 restore
02021e18 <rtems_rfs_mutex_lock.isra.3>:
* @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)
2021e18: 9d e3 bf a0 save %sp, -96, %sp
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
2021e1c: 92 10 20 00 clr %o1
2021e20: 90 10 00 18 mov %i0, %o0
2021e24: 94 10 20 00 clr %o2
2021e28: 7f ff ad a3 call 200d4b4 <rtems_semaphore_obtain>
2021e2c: b0 10 20 00 clr %i0
if (sc != RTEMS_SUCCESSFUL)
2021e30: 80 a2 20 00 cmp %o0, 0
2021e34: 02 80 00 0f be 2021e70 <rtems_rfs_mutex_lock.isra.3+0x58> <== ALWAYS TAKEN
2021e38: ba 10 00 08 mov %o0, %i5
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
2021e3c: 90 10 20 00 clr %o0 <== NOT EXECUTED
2021e40: 92 10 20 04 mov 4, %o1 <== NOT EXECUTED
2021e44: 40 00 07 02 call 2023a4c <rtems_rfs_trace> <== NOT EXECUTED
2021e48: b0 10 20 05 mov 5, %i0 <== NOT EXECUTED
2021e4c: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
2021e50: 02 80 00 08 be 2021e70 <rtems_rfs_mutex_lock.isra.3+0x58> <== NOT EXECUTED
2021e54: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: mutex: obtain failed: %s\n",
2021e58: 7f ff 9a cc call 2008988 <rtems_status_text> <== NOT EXECUTED
2021e5c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
2021e60: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED
2021e64: 11 00 81 8a sethi %hi(0x2062800), %o0 <== NOT EXECUTED
2021e68: 40 00 93 20 call 2046ae8 <printf> <== NOT EXECUTED
2021e6c: 90 12 22 50 or %o0, 0x250, %o0 ! 2062a50 <rtems_nvdisk_sram_handlers+0x34><== NOT EXECUTED
#endif
return EIO;
}
#endif
return 0;
}
2021e70: 81 c7 e0 08 ret
2021e74: 81 e8 00 00 restore
02021dc0 <rtems_rfs_mutex_unlock.isra.2>:
* @param mutex The mutex to unlock.
* @retval true The mutex is unlocked.
* @retval false The mutex could not be unlocked.
*/
static inline int
rtems_rfs_mutex_unlock (rtems_rfs_mutex* mutex)
2021dc0: 9d e3 bf a0 save %sp, -96, %sp
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
2021dc4: 90 10 00 18 mov %i0, %o0
2021dc8: 7f ff ae 05 call 200d5dc <rtems_semaphore_release>
2021dcc: b0 10 20 00 clr %i0
if (sc != RTEMS_SUCCESSFUL)
2021dd0: 80 a2 20 00 cmp %o0, 0
2021dd4: 02 80 00 0f be 2021e10 <rtems_rfs_mutex_unlock.isra.2+0x50><== ALWAYS TAKEN
2021dd8: ba 10 00 08 mov %o0, %i5
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
2021ddc: 90 10 20 00 clr %o0 <== NOT EXECUTED
2021de0: 92 10 20 04 mov 4, %o1 <== NOT EXECUTED
2021de4: 40 00 07 1a call 2023a4c <rtems_rfs_trace> <== NOT EXECUTED
2021de8: b0 10 20 05 mov 5, %i0 <== NOT EXECUTED
2021dec: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
2021df0: 02 80 00 08 be 2021e10 <rtems_rfs_mutex_unlock.isra.2+0x50><== NOT EXECUTED
2021df4: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: mutex: release failed: %s\n",
2021df8: 7f ff 9a e4 call 2008988 <rtems_status_text> <== NOT EXECUTED
2021dfc: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
2021e00: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED
2021e04: 11 00 81 8a sethi %hi(0x2062800), %o0 <== NOT EXECUTED
2021e08: 40 00 93 38 call 2046ae8 <printf> <== NOT EXECUTED
2021e0c: 90 12 22 28 or %o0, 0x228, %o0 ! 2062a28 <rtems_nvdisk_sram_handlers+0xc><== NOT EXECUTED
#endif
return EIO;
}
#endif
return 0;
}
2021e10: 81 c7 e0 08 ret
2021e14: 81 e8 00 00 restore
0203721c <rtems_rfs_release_chain>:
static int
rtems_rfs_release_chain (rtems_chain_control* chain,
uint32_t* count,
bool modified)
{
203721c: 9d e3 bf a0 save %sp, -96, %sp
rtems_rfs_buffer* buffer;
int rrc = 0;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))
2037220: 90 10 20 00 clr %o0
2037224: 92 10 20 80 mov 0x80, %o1
2037228: 7f ff b2 09 call 2023a4c <rtems_rfs_trace>
203722c: ba 10 00 18 mov %i0, %i5
2037230: 80 8a 20 ff btst 0xff, %o0
2037234: 22 80 00 07 be,a 2037250 <rtems_rfs_release_chain+0x34> <== ALWAYS TAKEN
2037238: b0 10 20 00 clr %i0
printf ("rtems-rfs: release-chain: count=%" PRIu32 "\n", *count);
203723c: d2 06 40 00 ld [ %i1 ], %o1 <== NOT EXECUTED
2037240: 11 00 81 9c sethi %hi(0x2067000), %o0 <== NOT EXECUTED
2037244: 40 00 3e 29 call 2046ae8 <printf> <== NOT EXECUTED
2037248: 90 12 22 20 or %o0, 0x220, %o0 ! 2067220 <__FUNCTION__.7829+0x130><== NOT EXECUTED
(*count)--;
buffer->user = (void*) 0;
rc = rtems_rfs_buffer_io_release (buffer, modified);
if ((rc > 0) && (rrc == 0))
203724c: b0 10 20 00 clr %i0 <== NOT EXECUTED
2037250: 10 80 00 10 b 2037290 <rtems_rfs_release_chain+0x74>
2037254: b8 07 60 04 add %i5, 4, %i4
2037258: 7f ff 5b e9 call 200e1fc <_Chain_Get>
203725c: 90 10 00 1d mov %i5, %o0
printf ("rtems-rfs: release-chain: count=%" PRIu32 "\n", *count);
while (!rtems_chain_is_empty (chain))
{
buffer = (rtems_rfs_buffer*) rtems_chain_get (chain);
(*count)--;
2037260: c2 06 40 00 ld [ %i1 ], %g1
buffer->user = (void*) 0;
rc = rtems_rfs_buffer_io_release (buffer, modified);
2037264: 92 10 00 1a mov %i2, %o1
printf ("rtems-rfs: release-chain: count=%" PRIu32 "\n", *count);
while (!rtems_chain_is_empty (chain))
{
buffer = (rtems_rfs_buffer*) rtems_chain_get (chain);
(*count)--;
2037268: 82 00 7f ff add %g1, -1, %g1
203726c: c2 26 40 00 st %g1, [ %i1 ]
buffer->user = (void*) 0;
rc = rtems_rfs_buffer_io_release (buffer, modified);
2037270: 40 00 2a 1d call 2041ae4 <rtems_rfs_buffer_bdbuf_release>
2037274: c0 22 20 34 clr [ %o0 + 0x34 ]
if ((rc > 0) && (rrc == 0))
2037278: 80 a2 20 00 cmp %o0, 0
203727c: 24 80 00 06 ble,a 2037294 <rtems_rfs_release_chain+0x78> <== ALWAYS TAKEN
2037280: c2 07 40 00 ld [ %i5 ], %g1
2037284: 80 a6 20 00 cmp %i0, 0 <== NOT EXECUTED
2037288: 22 80 00 02 be,a 2037290 <rtems_rfs_release_chain+0x74> <== NOT EXECUTED
203728c: b0 10 00 08 mov %o0, %i0 <== 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))
2037290: c2 07 40 00 ld [ %i5 ], %g1
2037294: 80 a0 40 1c cmp %g1, %i4
2037298: 12 bf ff f0 bne 2037258 <rtems_rfs_release_chain+0x3c>
203729c: 01 00 00 00 nop
rc = rtems_rfs_buffer_io_release (buffer, modified);
if ((rc > 0) && (rrc == 0))
rrc = rc;
}
return rrc;
}
20372a0: 81 c7 e0 08 ret
20372a4: 81 e8 00 00 restore
02021a60 <rtems_rfs_rtems_chown>:
static int
rtems_rfs_rtems_chown (const rtems_filesystem_location_info_t *pathloc,
uid_t owner,
gid_t group)
{
2021a60: 9d e3 bf 78 save %sp, -136, %sp
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
2021a64: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
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);
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
2021a68: d2 06 20 08 ld [ %i0 + 8 ], %o1
static int
rtems_rfs_rtems_chown (const rtems_filesystem_location_info_t *pathloc,
uid_t owner,
gid_t group)
{
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
2021a6c: fa 00 60 08 ld [ %g1 + 8 ], %i5
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);
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
2021a70: 94 07 bf d8 add %fp, -40, %o2
2021a74: 90 10 00 1d mov %i5, %o0
2021a78: 40 00 68 4a call 203bba0 <rtems_rfs_inode_open>
2021a7c: 96 10 20 01 mov 1, %o3
if (rc > 0)
2021a80: b8 92 20 00 orcc %o0, 0, %i4
2021a84: 04 80 00 07 ble 2021aa0 <rtems_rfs_rtems_chown+0x40> <== ALWAYS TAKEN
2021a88: 01 00 00 00 nop
{
return rtems_rfs_rtems_error ("chown: opening inode", rc);
2021a8c: 40 00 81 d8 call 20421ec <__errno> <== NOT EXECUTED
2021a90: b0 10 3f ff mov -1, %i0 ! ffffffff <RAM_END+0xfdbfffff> <== NOT EXECUTED
2021a94: f8 22 00 00 st %i4, [ %o0 ] <== NOT EXECUTED
2021a98: 81 c7 e0 08 ret <== NOT EXECUTED
2021a9c: 81 e8 00 00 restore <== NOT EXECUTED
/*
* Verify I am the owner of the node or the super user.
*/
#if defined (RTEMS_POSIX_API)
uid = geteuid();
2021aa0: 40 00 19 8e call 20280d8 <geteuid>
2021aa4: 01 00 00 00 nop
* @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;
2021aa8: c2 07 bf e4 ld [ %fp + -28 ], %g1
if ((uid != rtems_rfs_inode_get_uid (&inode)) && (uid != 0))
2021aac: 91 2a 20 10 sll %o0, 0x10, %o0
2021ab0: c6 08 60 07 ldub [ %g1 + 7 ], %g3
2021ab4: c4 08 60 06 ldub [ %g1 + 6 ], %g2
2021ab8: 85 28 a0 08 sll %g2, 8, %g2
2021abc: 84 10 80 03 or %g2, %g3, %g2
2021ac0: 85 28 a0 10 sll %g2, 0x10, %g2
2021ac4: 80 a0 80 08 cmp %g2, %o0
2021ac8: 02 80 00 0e be 2021b00 <rtems_rfs_rtems_chown+0xa0> <== ALWAYS TAKEN
2021acc: 87 32 20 10 srl %o0, 0x10, %g3
2021ad0: 80 a0 e0 00 cmp %g3, 0 <== NOT EXECUTED
2021ad4: 22 80 00 0c be,a 2021b04 <rtems_rfs_rtems_chown+0xa4> <== NOT EXECUTED
2021ad8: b5 2e a0 10 sll %i2, 0x10, %i2 <== NOT EXECUTED
{
rtems_rfs_inode_close (fs, &inode);
2021adc: 92 07 bf d8 add %fp, -40, %o1 <== NOT EXECUTED
2021ae0: 40 00 68 a2 call 203bd68 <rtems_rfs_inode_close> <== NOT EXECUTED
2021ae4: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
return rtems_rfs_rtems_error ("chown: not able", EPERM);
2021ae8: 40 00 81 c1 call 20421ec <__errno> <== NOT EXECUTED
2021aec: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
2021af0: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED
2021af4: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
2021af8: 81 c7 e0 08 ret <== NOT EXECUTED
2021afc: 81 e8 00 00 restore <== 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);
2021b00: b5 2e a0 10 sll %i2, 0x10, %i2
2021b04: b4 16 80 19 or %i2, %i1, %i2
2021b08: 85 36 a0 18 srl %i2, 0x18, %g2
2021b0c: c4 28 60 04 stb %g2, [ %g1 + 4 ]
2021b10: c2 07 bf e4 ld [ %fp + -28 ], %g1
2021b14: 85 36 a0 10 srl %i2, 0x10, %g2
2021b18: c4 28 60 05 stb %g2, [ %g1 + 5 ]
2021b1c: c2 07 bf e4 ld [ %fp + -28 ], %g1
2021b20: b5 36 a0 08 srl %i2, 8, %i2
2021b24: f4 28 60 06 stb %i2, [ %g1 + 6 ]
2021b28: c2 07 bf e4 ld [ %fp + -28 ], %g1
}
#endif
rtems_rfs_inode_set_uid_gid (&inode, owner, group);
rc = rtems_rfs_inode_close (fs, &inode);
2021b2c: 90 10 00 1d mov %i5, %o0
2021b30: f2 28 60 07 stb %i1, [ %g1 + 7 ]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
2021b34: 82 10 20 01 mov 1, %g1
2021b38: 92 07 bf d8 add %fp, -40, %o1
2021b3c: c2 2f bf e8 stb %g1, [ %fp + -24 ]
2021b40: 40 00 68 8a call 203bd68 <rtems_rfs_inode_close>
2021b44: b0 10 20 00 clr %i0
if (rc)
2021b48: 80 a2 20 00 cmp %o0, 0
2021b4c: 02 80 00 05 be 2021b60 <rtems_rfs_rtems_chown+0x100> <== ALWAYS TAKEN
2021b50: ba 10 00 08 mov %o0, %i5
{
return rtems_rfs_rtems_error ("chown: closing inode", rc);
2021b54: 40 00 81 a6 call 20421ec <__errno> <== NOT EXECUTED
2021b58: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
2021b5c: fa 22 00 00 st %i5, [ %o0 ] <== NOT EXECUTED
}
return 0;
}
2021b60: 81 c7 e0 08 ret
2021b64: 81 e8 00 00 restore
0203cf68 <rtems_rfs_rtems_device_close>:
rtems_device_major_number major;
rtems_device_minor_number minor;
rtems_rfs_rtems_device_get_major_and_minor (iop, &major, &minor);
return rtems_deviceio_close (iop, major, minor);
203cf68: d2 02 20 2c ld [ %o0 + 0x2c ], %o1 <== NOT EXECUTED
203cf6c: d4 02 20 30 ld [ %o0 + 0x30 ], %o2 <== NOT EXECUTED
203cf70: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED
203cf74: 40 00 06 2a call 203e81c <rtems_deviceio_close> <== NOT EXECUTED
203cf78: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED
0203cf24 <rtems_rfs_rtems_device_ftruncate>:
static int
rtems_rfs_rtems_device_ftruncate (rtems_libio_t* iop, off_t length)
{
return 0;
}
203cf24: 81 c3 e0 08 retl <== NOT EXECUTED
203cf28: 90 10 20 00 clr %o0 <== NOT EXECUTED
0203cf2c <rtems_rfs_rtems_device_ioctl>:
rtems_device_major_number major;
rtems_device_minor_number minor;
rtems_rfs_rtems_device_get_major_and_minor (iop, &major, &minor);
return rtems_deviceio_control (iop, command, buffer, major, minor);
203cf2c: d6 02 20 2c ld [ %o0 + 0x2c ], %o3 <== NOT EXECUTED
203cf30: d8 02 20 30 ld [ %o0 + 0x30 ], %o4 <== NOT EXECUTED
203cf34: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED
203cf38: 40 00 06 79 call 203e91c <rtems_deviceio_control> <== NOT EXECUTED
203cf3c: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED
0203cfd0 <rtems_rfs_rtems_device_open>:
static int
rtems_rfs_rtems_device_open ( rtems_libio_t *iop,
const char *pathname,
int oflag,
mode_t mode)
{
203cfd0: 9d e3 bf 78 save %sp, -136, %sp <== NOT EXECUTED
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (&iop->pathinfo);
203cfd4: c2 06 20 28 ld [ %i0 + 0x28 ], %g1 <== NOT EXECUTED
rtems_rfs_ino ino = rtems_rfs_rtems_get_iop_ino (iop);
203cfd8: e0 06 20 1c ld [ %i0 + 0x1c ], %l0 <== NOT EXECUTED
rtems_rfs_rtems_device_open ( rtems_libio_t *iop,
const char *pathname,
int oflag,
mode_t mode)
{
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (&iop->pathinfo);
203cfdc: fa 00 60 08 ld [ %g1 + 8 ], %i5 <== 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);
203cfe0: 92 10 20 00 clr %o1 <== NOT EXECUTED
.fstat_h = rtems_rfs_rtems_fstat,
.ftruncate_h = rtems_rfs_rtems_device_ftruncate,
.fsync_h = rtems_filesystem_default_fsync_or_fdatasync,
.fdatasync_h = rtems_filesystem_default_fsync_or_fdatasync,
.fcntl_h = rtems_filesystem_default_fcntl
};
203cfe4: c2 07 60 80 ld [ %i5 + 0x80 ], %g1 <== NOT EXECUTED
203cfe8: 94 10 20 00 clr %o2 <== NOT EXECUTED
203cfec: 7f ff 41 32 call 200d4b4 <rtems_semaphore_obtain> <== NOT EXECUTED
203cff0: d0 00 40 00 ld [ %g1 ], %o0 <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
203cff4: b8 92 20 00 orcc %o0, 0, %i4 <== NOT EXECUTED
203cff8: 02 80 00 0f be 203d034 <rtems_rfs_rtems_device_open+0x64> <== NOT EXECUTED
203cffc: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
203d000: 90 10 20 00 clr %o0 <== NOT EXECUTED
203d004: 7f ff 9a 92 call 2023a4c <rtems_rfs_trace> <== NOT EXECUTED
203d008: 92 10 20 04 mov 4, %o1 <== NOT EXECUTED
203d00c: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
203d010: 22 80 00 09 be,a 203d034 <rtems_rfs_rtems_device_open+0x64><== NOT EXECUTED
203d014: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
printf ("rtems-rfs: mutex: obtain failed: %s\n",
203d018: 7f ff 2e 5c call 2008988 <rtems_status_text> <== NOT EXECUTED
203d01c: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
203d020: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED
203d024: 11 00 81 8a sethi %hi(0x2062800), %o0 <== NOT EXECUTED
203d028: 40 00 26 b0 call 2046ae8 <printf> <== NOT EXECUTED
203d02c: 90 12 22 50 or %o0, 0x250, %o0 ! 2062a50 <rtems_nvdisk_sram_handlers+0x34><== NOT EXECUTED
rtems_device_minor_number minor;
int rc;
rtems_rfs_rtems_lock (fs);
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
203d030: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
203d034: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED
203d038: 94 07 bf d8 add %fp, -40, %o2 <== NOT EXECUTED
203d03c: 7f ff fa d9 call 203bba0 <rtems_rfs_inode_open> <== NOT EXECUTED
203d040: 96 10 20 01 mov 1, %o3 <== NOT EXECUTED
if (rc > 0)
203d044: b8 92 20 00 orcc %o0, 0, %i4 <== NOT EXECUTED
203d048: 04 80 00 09 ble 203d06c <rtems_rfs_rtems_device_open+0x9c><== NOT EXECUTED
203d04c: 92 10 20 00 clr %o1 <== NOT EXECUTED
{
rtems_rfs_rtems_unlock (fs);
203d050: 7f ff ff cb call 203cf7c <rtems_rfs_rtems_unlock> <== NOT EXECUTED
203d054: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
return rtems_rfs_rtems_error ("device_open: opening inode", rc);
203d058: 40 00 14 65 call 20421ec <__errno> <== NOT EXECUTED
203d05c: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
203d060: f8 22 00 00 st %i4, [ %o0 ] <== NOT EXECUTED
203d064: 81 c7 e0 08 ret <== NOT EXECUTED
203d068: 81 e8 00 00 restore <== NOT EXECUTED
}
major = rtems_rfs_inode_get_block (&inode, 0);
203d06c: 7f ff ff 9e call 203cee4 <rtems_rfs_inode_get_block> <== NOT EXECUTED
203d070: 90 07 bf d8 add %fp, -40, %o0 <== NOT EXECUTED
minor = rtems_rfs_inode_get_block (&inode, 1);
203d074: 92 10 20 01 mov 1, %o1 <== 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);
203d078: b8 10 00 08 mov %o0, %i4 <== NOT EXECUTED
minor = rtems_rfs_inode_get_block (&inode, 1);
203d07c: 7f ff ff 9a call 203cee4 <rtems_rfs_inode_get_block> <== NOT EXECUTED
203d080: 90 07 bf d8 add %fp, -40, %o0 <== NOT EXECUTED
rc = rtems_rfs_inode_close (fs, &inode);
203d084: 92 07 bf d8 add %fp, -40, %o1 <== 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);
203d088: a0 10 00 08 mov %o0, %l0 <== NOT EXECUTED
rc = rtems_rfs_inode_close (fs, &inode);
203d08c: 7f ff fb 37 call 203bd68 <rtems_rfs_inode_close> <== NOT EXECUTED
203d090: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
203d094: a2 10 00 08 mov %o0, %l1 <== NOT EXECUTED
if (rc > 0)
203d098: 80 a4 60 00 cmp %l1, 0 <== NOT EXECUTED
203d09c: 04 80 00 09 ble 203d0c0 <rtems_rfs_rtems_device_open+0xf0><== NOT EXECUTED
203d0a0: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
{
rtems_rfs_rtems_unlock (fs);
203d0a4: 7f ff ff b6 call 203cf7c <rtems_rfs_rtems_unlock> <== NOT EXECUTED
203d0a8: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
return rtems_rfs_rtems_error ("device_open: closing inode", rc);
203d0ac: 40 00 14 50 call 20421ec <__errno> <== NOT EXECUTED
203d0b0: 01 00 00 00 nop <== NOT EXECUTED
203d0b4: e2 22 00 00 st %l1, [ %o0 ] <== NOT EXECUTED
203d0b8: 81 c7 e0 08 ret <== NOT EXECUTED
203d0bc: 81 e8 00 00 restore <== NOT EXECUTED
}
rtems_rfs_rtems_unlock (fs);
203d0c0: 7f ff ff af call 203cf7c <rtems_rfs_rtems_unlock> <== NOT EXECUTED
203d0c4: 01 00 00 00 nop <== NOT EXECUTED
iop->data0 = major;
iop->data1 = (void *) minor;
return rtems_deviceio_open (iop, pathname, oflag, mode, minor, major);
203d0c8: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
return rtems_rfs_rtems_error ("device_open: closing inode", rc);
}
rtems_rfs_rtems_unlock (fs);
iop->data0 = major;
203d0cc: f8 26 20 2c st %i4, [ %i0 + 0x2c ] <== NOT EXECUTED
iop->data1 = (void *) minor;
203d0d0: e0 26 20 30 st %l0, [ %i0 + 0x30 ] <== NOT EXECUTED
return rtems_deviceio_open (iop, pathname, oflag, mode, minor, major);
203d0d4: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
203d0d8: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED
203d0dc: 96 10 00 1b mov %i3, %o3 <== NOT EXECUTED
203d0e0: 98 10 00 10 mov %l0, %o4 <== NOT EXECUTED
203d0e4: 40 00 05 c1 call 203e7e8 <rtems_deviceio_open> <== NOT EXECUTED
203d0e8: 9a 10 00 1c mov %i4, %o5 <== NOT EXECUTED
}
203d0ec: 81 c7 e0 08 ret <== NOT EXECUTED
203d0f0: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED
0203cf54 <rtems_rfs_rtems_device_read>:
rtems_device_major_number major;
rtems_device_minor_number minor;
rtems_rfs_rtems_device_get_major_and_minor (iop, &major, &minor);
return rtems_deviceio_read (iop, buffer, count, major, minor);
203cf54: d6 02 20 2c ld [ %o0 + 0x2c ], %o3 <== NOT EXECUTED
203cf58: d8 02 20 30 ld [ %o0 + 0x30 ], %o4 <== NOT EXECUTED
203cf5c: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED
203cf60: 40 00 06 3b call 203e84c <rtems_deviceio_read> <== NOT EXECUTED
203cf64: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED
0203cf40 <rtems_rfs_rtems_device_write>:
rtems_device_major_number major;
rtems_device_minor_number minor;
rtems_rfs_rtems_device_get_major_and_minor (iop, &major, &minor);
return rtems_deviceio_write (iop, buffer, count, major, minor);
203cf40: d6 02 20 2c ld [ %o0 + 0x2c ], %o3 <== NOT EXECUTED
203cf44: d8 02 20 30 ld [ %o0 + 0x30 ], %o4 <== NOT EXECUTED
203cf48: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED
203cf4c: 40 00 06 5a call 203e8b4 <rtems_deviceio_write> <== NOT EXECUTED
203cf50: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED
0203d2a0 <rtems_rfs_rtems_dir_open>:
static int
rtems_rfs_rtems_dir_open (rtems_libio_t* iop,
const char* pathname,
int oflag,
mode_t mode)
{
203d2a0: 9d e3 bf 78 save %sp, -136, %sp
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (&iop->pathinfo);
203d2a4: c2 06 20 28 ld [ %i0 + 0x28 ], %g1
rtems_rfs_ino ino = rtems_rfs_rtems_get_iop_ino (iop);
203d2a8: f8 06 20 1c ld [ %i0 + 0x1c ], %i4
rtems_rfs_rtems_dir_open (rtems_libio_t* iop,
const char* pathname,
int oflag,
mode_t mode)
{
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (&iop->pathinfo);
203d2ac: fa 00 60 08 ld [ %g1 + 8 ], %i5
.fstat_h = rtems_rfs_rtems_fstat,
.ftruncate_h = rtems_filesystem_default_ftruncate_directory,
.fsync_h = rtems_filesystem_default_fsync_or_fdatasync,
.fdatasync_h = rtems_rfs_rtems_fdatasync,
.fcntl_h = rtems_filesystem_default_fcntl
};
203d2b0: c2 07 60 80 ld [ %i5 + 0x80 ], %g1
203d2b4: 7f ff ff 92 call 203d0fc <rtems_rfs_mutex_lock.isra.0>
203d2b8: d0 00 40 00 ld [ %g1 ], %o0
rtems_rfs_inode_handle inode;
int rc;
rtems_rfs_rtems_lock (fs);
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
203d2bc: 92 10 00 1c mov %i4, %o1
203d2c0: 90 10 00 1d mov %i5, %o0
203d2c4: 94 07 bf d8 add %fp, -40, %o2
203d2c8: 7f ff fa 36 call 203bba0 <rtems_rfs_inode_open>
203d2cc: 96 10 20 01 mov 1, %o3
if (rc)
203d2d0: b8 92 20 00 orcc %o0, 0, %i4
203d2d4: 02 80 00 09 be 203d2f8 <rtems_rfs_rtems_dir_open+0x58> <== ALWAYS TAKEN
203d2d8: c2 07 bf e4 ld [ %fp + -28 ], %g1
{
rtems_rfs_rtems_unlock (fs);
203d2dc: 7f ff ff a0 call 203d15c <rtems_rfs_rtems_unlock> <== NOT EXECUTED
203d2e0: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
return rtems_rfs_rtems_error ("dir_open: opening inode", rc);
203d2e4: 40 00 13 c2 call 20421ec <__errno> <== NOT EXECUTED
203d2e8: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
203d2ec: f8 22 00 00 st %i4, [ %o0 ] <== NOT EXECUTED
203d2f0: 81 c7 e0 08 ret <== NOT EXECUTED
203d2f4: 81 e8 00 00 restore <== 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);
203d2f8: c4 08 60 02 ldub [ %g1 + 2 ], %g2
}
if (!RTEMS_RFS_S_ISDIR (rtems_rfs_inode_get_mode (&inode)))
203d2fc: 03 00 00 3c sethi %hi(0xf000), %g1
203d300: 85 28 a0 08 sll %g2, 8, %g2
203d304: 84 08 80 01 and %g2, %g1, %g2
203d308: 03 00 00 10 sethi %hi(0x4000), %g1
203d30c: 80 a0 80 01 cmp %g2, %g1
203d310: 02 80 00 0c be 203d340 <rtems_rfs_rtems_dir_open+0xa0> <== ALWAYS TAKEN
203d314: 92 07 bf d8 add %fp, -40, %o1
{
rtems_rfs_inode_close (fs, &inode);
203d318: 7f ff fa 94 call 203bd68 <rtems_rfs_inode_close> <== NOT EXECUTED
203d31c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
rtems_rfs_rtems_unlock (fs);
203d320: 7f ff ff 8f call 203d15c <rtems_rfs_rtems_unlock> <== NOT EXECUTED
203d324: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
return rtems_rfs_rtems_error ("dir_open: not dir", ENOTDIR);
203d328: 40 00 13 b1 call 20421ec <__errno> <== NOT EXECUTED
203d32c: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
203d330: 82 10 20 14 mov 0x14, %g1 <== NOT EXECUTED
203d334: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
203d338: 81 c7 e0 08 ret <== NOT EXECUTED
203d33c: 81 e8 00 00 restore <== NOT EXECUTED
}
iop->offset = 0;
203d340: c0 26 20 08 clr [ %i0 + 8 ]
203d344: c0 26 20 0c clr [ %i0 + 0xc ]
rtems_rfs_inode_close (fs, &inode);
203d348: 7f ff fa 88 call 203bd68 <rtems_rfs_inode_close>
203d34c: 90 10 00 1d mov %i5, %o0
rtems_rfs_rtems_unlock (fs);
203d350: 90 10 00 1d mov %i5, %o0
203d354: 7f ff ff 82 call 203d15c <rtems_rfs_rtems_unlock>
203d358: b0 10 20 00 clr %i0
return 0;
}
203d35c: 81 c7 e0 08 ret
203d360: 81 e8 00 00 restore
0203d1b0 <rtems_rfs_rtems_dir_read>:
*/
static ssize_t
rtems_rfs_rtems_dir_read (rtems_libio_t* iop,
void* buffer,
size_t count)
{
203d1b0: 9d e3 bf 70 save %sp, -144, %sp
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (&iop->pathinfo);
203d1b4: c2 06 20 28 ld [ %i0 + 0x28 ], %g1
rtems_rfs_ino ino = rtems_rfs_rtems_get_iop_ino (iop);
203d1b8: f8 06 20 1c ld [ %i0 + 0x1c ], %i4
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);
203d1bc: fa 00 60 08 ld [ %g1 + 8 ], %i5
count = count / sizeof (struct dirent);
dirent = buffer;
rtems_rfs_rtems_lock (fs);
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
203d1c0: a0 07 bf d8 add %fp, -40, %l0
.fstat_h = rtems_rfs_rtems_fstat,
.ftruncate_h = rtems_filesystem_default_ftruncate_directory,
.fsync_h = rtems_filesystem_default_fsync_or_fdatasync,
.fdatasync_h = rtems_rfs_rtems_fdatasync,
.fcntl_h = rtems_filesystem_default_fcntl
};
203d1c4: c2 07 60 80 ld [ %i5 + 0x80 ], %g1
*/
static inline void
rtems_rfs_rtems_lock (rtems_rfs_file_system* fs)
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
rtems_rfs_mutex_lock (&rtems->access);
203d1c8: 7f ff ff cd call 203d0fc <rtems_rfs_mutex_lock.isra.0>
203d1cc: d0 00 40 00 ld [ %g1 ], %o0
count = count / sizeof (struct dirent);
dirent = buffer;
rtems_rfs_rtems_lock (fs);
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
203d1d0: 92 10 00 1c mov %i4, %o1
203d1d4: 90 10 00 1d mov %i5, %o0
203d1d8: 94 10 00 10 mov %l0, %o2
203d1dc: 7f ff fa 71 call 203bba0 <rtems_rfs_inode_open>
203d1e0: 96 10 20 01 mov 1, %o3
if (rc)
203d1e4: b8 92 20 00 orcc %o0, 0, %i4
203d1e8: 02 80 00 1f be 203d264 <rtems_rfs_rtems_dir_read+0xb4> <== ALWAYS TAKEN
203d1ec: 90 10 00 1a mov %i2, %o0
{
rtems_rfs_rtems_unlock (fs);
203d1f0: 7f ff ff db call 203d15c <rtems_rfs_rtems_unlock> <== NOT EXECUTED
203d1f4: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
return rtems_rfs_rtems_error ("dir_read: read inode", rc);
203d1f8: 40 00 13 fd call 20421ec <__errno> <== NOT EXECUTED
203d1fc: 01 00 00 00 nop <== NOT EXECUTED
203d200: f8 22 00 00 st %i4, [ %o0 ] <== NOT EXECUTED
203d204: 10 80 00 25 b 203d298 <rtems_rfs_rtems_dir_read+0xe8> <== NOT EXECUTED
203d208: b8 10 3f ff mov -1, %i4 <== 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);
203d20c: d4 1e 20 08 ldd [ %i0 + 8 ], %o2
203d210: 90 10 00 1d mov %i5, %o0
203d214: 92 10 00 10 mov %l0, %o1
203d218: 7f ff ed b3 call 20388e4 <rtems_rfs_dir_read>
203d21c: 9a 07 bf d4 add %fp, -44, %o5
if (rc == ENOENT)
203d220: 80 a2 20 02 cmp %o0, 2
203d224: 02 80 00 18 be 203d284 <rtems_rfs_rtems_dir_read+0xd4>
203d228: b4 10 00 08 mov %o0, %i2
{
rc = 0;
break;
}
if (rc > 0)
203d22c: 80 a2 20 00 cmp %o0, 0
203d230: 24 80 00 06 ble,a 203d248 <rtems_rfs_rtems_dir_read+0x98><== ALWAYS TAKEN
203d234: c4 1e 20 08 ldd [ %i0 + 8 ], %g2
{
bytes_transferred = rtems_rfs_rtems_error ("dir_read: dir read", rc);
203d238: 40 00 13 ed call 20421ec <__errno> <== NOT EXECUTED
203d23c: b8 10 3f ff mov -1, %i4 <== NOT EXECUTED
203d240: 10 80 00 11 b 203d284 <rtems_rfs_rtems_dir_read+0xd4> <== NOT EXECUTED
203d244: f4 22 00 00 st %i2, [ %o0 ] <== NOT EXECUTED
break;
}
iop->offset += size;
203d248: c2 07 bf d4 ld [ %fp + -44 ], %g1
* 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,
203d24c: b8 07 21 18 add %i4, 0x118, %i4
if (rc > 0)
{
bytes_transferred = rtems_rfs_rtems_error ("dir_read: dir read", rc);
break;
}
iop->offset += size;
203d250: 86 80 c0 01 addcc %g3, %g1, %g3
return rtems_rfs_rtems_error ("dir_read: read inode", rc);
}
bytes_transferred = 0;
for (d = 0; d < count; d++, dirent++)
203d254: b6 06 e0 01 inc %i3
if (rc > 0)
{
bytes_transferred = rtems_rfs_rtems_error ("dir_read: dir read", rc);
break;
}
iop->offset += size;
203d258: 84 40 a0 00 addx %g2, 0, %g2
203d25c: 10 80 00 07 b 203d278 <rtems_rfs_rtems_dir_read+0xc8>
203d260: c4 3e 20 08 std %g2, [ %i0 + 8 ]
struct dirent* dirent;
ssize_t bytes_transferred;
int d;
int rc;
count = count / sizeof (struct dirent);
203d264: 92 10 21 18 mov 0x118, %o1
203d268: 40 00 78 c6 call 205b580 <.udiv>
203d26c: b6 10 20 00 clr %i3
* 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,
203d270: b8 10 20 00 clr %i4
struct dirent* dirent;
ssize_t bytes_transferred;
int d;
int rc;
count = count / sizeof (struct dirent);
203d274: a2 10 00 08 mov %o0, %l1
return rtems_rfs_rtems_error ("dir_read: read inode", rc);
}
bytes_transferred = 0;
for (d = 0; d < count; d++, dirent++)
203d278: 80 a6 c0 11 cmp %i3, %l1
203d27c: 12 bf ff e4 bne 203d20c <rtems_rfs_rtems_dir_read+0x5c>
203d280: 98 06 40 1c add %i1, %i4, %o4
}
iop->offset += size;
bytes_transferred += sizeof (struct dirent);
}
rtems_rfs_inode_close (fs, &inode);
203d284: 90 10 00 1d mov %i5, %o0
203d288: 7f ff fa b8 call 203bd68 <rtems_rfs_inode_close>
203d28c: 92 07 bf d8 add %fp, -40, %o1
rtems_rfs_rtems_unlock (fs);
203d290: 7f ff ff b3 call 203d15c <rtems_rfs_rtems_unlock>
203d294: 90 10 00 1d mov %i5, %o0
return bytes_transferred;
}
203d298: 81 c7 e0 08 ret
203d29c: 91 e8 00 1c restore %g0, %i4, %o0
02021cb8 <rtems_rfs_rtems_eval_path>:
.eval_token = rtems_rfs_rtems_eval_token
};
static void
rtems_rfs_rtems_eval_path (rtems_filesystem_eval_path_context_t *ctx)
{
2021cb8: 9d e3 bf 78 save %sp, -136, %sp
rtems_filesystem_location_info_t *currentloc =
rtems_filesystem_eval_path_get_currentloc (ctx);
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (currentloc);
2021cbc: c2 06 20 2c ld [ %i0 + 0x2c ], %g1
rtems_rfs_ino ino = rtems_rfs_rtems_get_pathloc_ino (currentloc);
rtems_rfs_inode_handle inode;
int rc;
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
2021cc0: d2 06 20 20 ld [ %i0 + 0x20 ], %o1
static void
rtems_rfs_rtems_eval_path (rtems_filesystem_eval_path_context_t *ctx)
{
rtems_filesystem_location_info_t *currentloc =
rtems_filesystem_eval_path_get_currentloc (ctx);
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (currentloc);
2021cc4: fa 00 60 08 ld [ %g1 + 8 ], %i5
rtems_rfs_ino ino = rtems_rfs_rtems_get_pathloc_ino (currentloc);
rtems_rfs_inode_handle inode;
int rc;
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
2021cc8: 94 07 bf d8 add %fp, -40, %o2
2021ccc: 90 10 00 1d mov %i5, %o0
2021cd0: 40 00 67 b4 call 203bba0 <rtems_rfs_inode_open>
2021cd4: 96 10 20 01 mov 1, %o3
if (rc == 0) {
2021cd8: b8 92 20 00 orcc %o0, 0, %i4
2021cdc: 12 80 00 10 bne 2021d1c <rtems_rfs_rtems_eval_path+0x64> <== NEVER TAKEN
2021ce0: 90 10 00 18 mov %i0, %o0
rtems_filesystem_eval_path_generic (
2021ce4: 92 07 bf d8 add %fp, -40, %o1
2021ce8: 15 00 81 8a sethi %hi(0x2062800), %o2
2021cec: 40 00 1d f1 call 20294b0 <rtems_filesystem_eval_path_generic>
2021cf0: 94 12 a3 38 or %o2, 0x338, %o2 ! 2062b38 <rtems_rfs_rtems_eval_config>
ctx,
&inode,
&rtems_rfs_rtems_eval_config
);
rc = rtems_rfs_inode_close (fs, &inode);
2021cf4: 90 10 00 1d mov %i5, %o0
2021cf8: 40 00 68 1c call 203bd68 <rtems_rfs_inode_close>
2021cfc: 92 07 bf d8 add %fp, -40, %o1
if (rc != 0) {
2021d00: ba 92 20 00 orcc %o0, 0, %i5
2021d04: 02 80 00 0c be 2021d34 <rtems_rfs_rtems_eval_path+0x7c> <== ALWAYS TAKEN
2021d08: 01 00 00 00 nop
rtems_filesystem_eval_path_error (
ctx,
rtems_rfs_rtems_error ("eval_path: closing inode", rc)
2021d0c: 40 00 81 38 call 20421ec <__errno> <== NOT EXECUTED
2021d10: 01 00 00 00 nop <== NOT EXECUTED
2021d14: 10 80 00 05 b 2021d28 <rtems_rfs_rtems_eval_path+0x70> <== NOT EXECUTED
2021d18: fa 22 00 00 st %i5, [ %o0 ] <== NOT EXECUTED
);
}
} else {
rtems_filesystem_eval_path_error (
ctx,
rtems_rfs_rtems_error ("eval_path: opening inode", rc)
2021d1c: 40 00 81 34 call 20421ec <__errno> <== NOT EXECUTED
2021d20: 01 00 00 00 nop <== NOT EXECUTED
2021d24: f8 22 00 00 st %i4, [ %o0 ] <== NOT EXECUTED
ctx,
rtems_rfs_rtems_error ("eval_path: closing inode", rc)
);
}
} else {
rtems_filesystem_eval_path_error (
2021d28: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
2021d2c: 7f ff a1 5c call 200a29c <rtems_filesystem_eval_path_error><== NOT EXECUTED
2021d30: 92 10 3f ff mov -1, %o1 <== NOT EXECUTED
2021d34: 81 c7 e0 08 ret
2021d38: 81 e8 00 00 restore
02022174 <rtems_rfs_rtems_eval_token>:
rtems_filesystem_eval_path_context_t *ctx,
void *arg,
const char *token,
size_t tokenlen
)
{
2022174: 9d e3 bf 90 save %sp, -112, %sp
2022178: f8 06 60 0c ld [ %i1 + 0xc ], %i4
202217c: ba 10 00 18 mov %i0, %i5
* @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;
2022180: c2 0f 20 07 ldub [ %i4 + 7 ], %g1
2022184: f0 0f 20 06 ldub [ %i4 + 6 ], %i0
static bool
rtems_rfs_rtems_eval_perms (rtems_filesystem_eval_path_context_t *ctx,
int eval_flags,
rtems_rfs_inode_handle* inode)
{
return rtems_filesystem_eval_path_check_access(
2022188: 90 10 00 19 mov %i1, %o0
202218c: b1 2e 20 08 sll %i0, 8, %i0
2022190: 7f ff fd 52 call 20216d8 <rtems_rfs_inode_get_gid>
2022194: b0 16 00 01 or %i0, %g1, %i0
* @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);
2022198: c2 0f 20 02 ldub [ %i4 + 2 ], %g1
202219c: d4 0f 20 03 ldub [ %i4 + 3 ], %o2
20221a0: 83 28 60 08 sll %g1, 8, %g1
20221a4: 97 2e 20 10 sll %i0, 0x10, %o3
20221a8: 99 2a 20 10 sll %o0, 0x10, %o4
20221ac: 92 10 20 01 mov 1, %o1
20221b0: 90 10 00 1d mov %i5, %o0
20221b4: 94 12 80 01 or %o2, %g1, %o2
20221b8: 97 32 e0 10 srl %o3, 0x10, %o3
20221bc: 99 33 20 10 srl %o4, 0x10, %o4
20221c0: 40 00 1c ae call 2029478 <rtems_filesystem_eval_path_check_access>
20221c4: b0 10 20 01 mov 1, %i0
rtems_filesystem_eval_path_generic_status status =
RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_DONE;
rtems_rfs_inode_handle* inode = arg;
bool access_ok = rtems_rfs_rtems_eval_perms (ctx, RTEMS_FS_PERMS_EXEC, inode);
if (access_ok) {
20221c8: 80 8a 20 ff btst 0xff, %o0
20221cc: 02 80 00 71 be 2022390 <rtems_rfs_rtems_eval_token+0x21c>
20221d0: 80 a6 e0 01 cmp %i3, 1
static inline bool rtems_filesystem_is_current_directory(
const char *token,
size_t tokenlen
)
{
return tokenlen == 1 && token [0] == '.';
20221d4: 12 80 00 06 bne 20221ec <rtems_rfs_rtems_eval_token+0x78>
20221d8: 82 10 20 00 clr %g1
20221dc: c2 4e 80 00 ldsb [ %i2 ], %g1
20221e0: 82 18 60 2e xor %g1, 0x2e, %g1
20221e4: 80 a0 00 01 cmp %g0, %g1
20221e8: 82 60 3f ff subx %g0, -1, %g1
if (rtems_filesystem_is_current_directory (token, tokenlen)) {
20221ec: 80 a0 60 00 cmp %g1, 0
20221f0: 22 80 00 04 be,a 2022200 <rtems_rfs_rtems_eval_token+0x8c>
20221f4: c2 07 60 2c ld [ %i5 + 0x2c ], %g1
static inline void rtems_filesystem_eval_path_clear_token(
rtems_filesystem_eval_path_context_t *ctx
)
{
ctx->tokenlen = 0;
20221f8: 10 80 00 44 b 2022308 <rtems_rfs_rtems_eval_token+0x194>
20221fc: c0 27 60 0c clr [ %i5 + 0xc ]
rtems_filesystem_location_info_t *currentloc =
rtems_filesystem_eval_path_get_currentloc( ctx );
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (currentloc);
rtems_rfs_ino entry_ino;
uint32_t entry_doff;
int rc = rtems_rfs_dir_lookup_ino (
2022200: 92 10 00 19 mov %i1, %o1
if (rtems_filesystem_is_current_directory (token, tokenlen)) {
rtems_filesystem_eval_path_clear_token (ctx);
} else {
rtems_filesystem_location_info_t *currentloc =
rtems_filesystem_eval_path_get_currentloc( ctx );
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (currentloc);
2022204: f8 00 60 08 ld [ %g1 + 8 ], %i4
rtems_rfs_ino entry_ino;
uint32_t entry_doff;
int rc = rtems_rfs_dir_lookup_ino (
2022208: 94 10 00 1a mov %i2, %o2
202220c: 90 10 00 1c mov %i4, %o0
2022210: 96 10 00 1b mov %i3, %o3
2022214: 98 07 bf f4 add %fp, -12, %o4
2022218: 9a 07 bf f8 add %fp, -8, %o5
202221c: 40 00 56 93 call 2037c68 <rtems_rfs_dir_lookup_ino>
2022220: b0 10 20 02 mov 2, %i0
tokenlen,
&entry_ino,
&entry_doff
);
if (rc == 0) {
2022224: 80 a2 20 00 cmp %o0, 0
2022228: 12 80 00 5a bne 2022390 <rtems_rfs_rtems_eval_token+0x21c>
202222c: 90 10 00 1c mov %i4, %o0
rc = rtems_rfs_inode_close (fs, inode);
2022230: 40 00 66 ce call 203bd68 <rtems_rfs_inode_close>
2022234: 92 10 00 19 mov %i1, %o1
if (rc == 0) {
2022238: 80 a2 20 00 cmp %o0, 0
202223c: 02 80 00 07 be 2022258 <rtems_rfs_rtems_eval_token+0xe4> <== ALWAYS TAKEN
2022240: 90 10 00 19 mov %i1, %o0
if (rc != 0) {
/*
* This prevents the rtems_rfs_inode_close() from doing something in
* rtems_rfs_rtems_eval_path().
*/
memset (inode, 0, sizeof(*inode));
2022244: 92 10 20 00 clr %o1 <== NOT EXECUTED
2022248: 40 00 8d b7 call 2045924 <memset> <== NOT EXECUTED
202224c: 94 10 20 28 mov 0x28, %o2 <== NOT EXECUTED
void *arg,
const char *token,
size_t tokenlen
)
{
rtems_filesystem_eval_path_generic_status status =
2022250: 81 c7 e0 08 ret <== NOT EXECUTED
2022254: 91 e8 20 01 restore %g0, 1, %o0 <== NOT EXECUTED
);
if (rc == 0) {
rc = rtems_rfs_inode_close (fs, inode);
if (rc == 0) {
rc = rtems_rfs_inode_open (fs, entry_ino, inode, true);
2022258: d2 07 bf f4 ld [ %fp + -12 ], %o1
202225c: 90 10 00 1c mov %i4, %o0
2022260: 94 10 00 19 mov %i1, %o2
2022264: 40 00 66 4f call 203bba0 <rtems_rfs_inode_open>
2022268: 96 10 20 01 mov 1, %o3
}
if (rc != 0) {
202226c: 80 a2 20 00 cmp %o0, 0
2022270: 02 80 00 2f be 202232c <rtems_rfs_rtems_eval_token+0x1b8> <== ALWAYS TAKEN
2022274: 90 10 00 19 mov %i1, %o0
/*
* This prevents the rtems_rfs_inode_close() from doing something in
* rtems_rfs_rtems_eval_path().
*/
memset (inode, 0, sizeof(*inode));
2022278: 10 bf ff f4 b 2022248 <rtems_rfs_rtems_eval_token+0xd4> <== NOT EXECUTED
202227c: 92 10 20 00 clr %o1 <== NOT EXECUTED
bool follow_sym_link = (eval_flags & RTEMS_FS_FOLLOW_SYM_LINK) != 0;
bool terminal = !rtems_filesystem_eval_path_has_path (ctx);
rtems_filesystem_eval_path_clear_token (ctx);
if (is_sym_link && (follow_sym_link || !terminal)) {
2022280: 02 80 00 04 be 2022290 <rtems_rfs_rtems_eval_token+0x11c>
2022284: 80 88 a0 ff btst 0xff, %g2
2022288: 02 80 00 23 be 2022314 <rtems_rfs_rtems_eval_token+0x1a0>
202228c: 90 07 60 18 add %i5, 0x18, %o0
rtems_filesystem_eval_path_context_t* ctx,
rtems_rfs_file_system* fs,
rtems_rfs_ino ino
)
{
size_t len = MAXPATHLEN;
2022290: 82 10 24 00 mov 0x400, %g1
bool terminal = !rtems_filesystem_eval_path_has_path (ctx);
rtems_filesystem_eval_path_clear_token (ctx);
if (is_sym_link && (follow_sym_link || !terminal)) {
rtems_rfs_rtems_follow_link (ctx, fs, entry_ino);
2022294: f4 07 bf f4 ld [ %fp + -12 ], %i2
rtems_filesystem_eval_path_context_t* ctx,
rtems_rfs_file_system* fs,
rtems_rfs_ino ino
)
{
size_t len = MAXPATHLEN;
2022298: c2 27 bf fc st %g1, [ %fp + -4 ]
char *link = malloc(len + 1);
202229c: 7f ff 9b b6 call 2009174 <malloc>
20222a0: 90 10 24 01 mov 0x401, %o0
if (link != NULL) {
20222a4: b6 92 20 00 orcc %o0, 0, %i3
20222a8: 02 80 00 14 be 20222f8 <rtems_rfs_rtems_eval_token+0x184> <== NEVER TAKEN
20222ac: 90 10 00 1c mov %i4, %o0
int rc = rtems_rfs_symlink_read (fs, ino, link, len, &len);
20222b0: 92 10 00 1a mov %i2, %o1
20222b4: 94 10 00 1b mov %i3, %o2
20222b8: 96 10 24 00 mov 0x400, %o3
20222bc: 40 00 6a 68 call 203cc5c <rtems_rfs_symlink_read>
20222c0: 98 07 bf fc add %fp, -4, %o4
if (rc == 0) {
20222c4: 80 a2 20 00 cmp %o0, 0
20222c8: 12 80 00 06 bne 20222e0 <rtems_rfs_rtems_eval_token+0x16c><== NEVER TAKEN
20222cc: 90 10 00 1d mov %i5, %o0
rtems_filesystem_eval_path_recursive (ctx, link, len);
20222d0: d4 07 bf fc ld [ %fp + -4 ], %o2
20222d4: 7f ff a0 f0 call 200a694 <rtems_filesystem_eval_path_recursive>
20222d8: 92 10 00 1b mov %i3, %o1
20222dc: 30 80 00 03 b,a 20222e8 <rtems_rfs_rtems_eval_token+0x174>
} else {
rtems_filesystem_eval_path_error (ctx, 0);
20222e0: 7f ff 9f ef call 200a29c <rtems_filesystem_eval_path_error><== NOT EXECUTED
20222e4: 92 10 20 00 clr %o1 <== NOT EXECUTED
}
free(link);
20222e8: 7f ff 9a 45 call 2008bfc <free>
20222ec: 90 10 00 1b mov %i3, %o0
void *arg,
const char *token,
size_t tokenlen
)
{
rtems_filesystem_eval_path_generic_status status =
20222f0: 81 c7 e0 08 ret
20222f4: 91 e8 20 01 restore %g0, 1, %o0
rtems_filesystem_eval_path_error (ctx, 0);
}
free(link);
} else {
rtems_filesystem_eval_path_error (ctx, ENOMEM);
20222f8: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
20222fc: 92 10 20 0c mov 0xc, %o1 <== NOT EXECUTED
2022300: 7f ff 9f e7 call 200a29c <rtems_filesystem_eval_path_error><== NOT EXECUTED
2022304: 01 00 00 00 nop <== NOT EXECUTED
void *arg,
const char *token,
size_t tokenlen
)
{
rtems_filesystem_eval_path_generic_status status =
2022308: 81 c7 e0 08 ret
202230c: 91 e8 20 01 restore %g0, 1, %o0
rtems_filesystem_eval_path_clear_token (ctx);
if (is_sym_link && (follow_sym_link || !terminal)) {
rtems_rfs_rtems_follow_link (ctx, fs, entry_ino);
} else {
rc = rtems_rfs_rtems_set_handlers (currentloc, inode) ? 0 : EIO;
2022310: 90 07 60 18 add %i5, 0x18, %o0
2022314: 40 00 01 1d call 2022788 <rtems_rfs_rtems_set_handlers>
2022318: 92 10 00 19 mov %i1, %o1
202231c: 80 8a 20 ff btst 0xff, %o0
2022320: 12 80 00 18 bne 2022380 <rtems_rfs_rtems_eval_token+0x20c><== ALWAYS TAKEN
2022324: c2 07 bf f4 ld [ %fp + -12 ], %g1
2022328: 30 80 00 0f b,a 2022364 <rtems_rfs_rtems_eval_token+0x1f0><== NOT EXECUTED
status = RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_NO_ENTRY;
rc = -1;
}
if (rc == 0) {
bool is_sym_link = rtems_rfs_rtems_node_type_by_inode (inode)
202232c: 7f ff ff 53 call 2022078 <rtems_rfs_rtems_node_type_by_inode>
2022330: 90 10 00 19 mov %i1, %o0
== RTEMS_FILESYSTEM_SYM_LINK;
int eval_flags = rtems_filesystem_eval_path_get_flags (ctx);
bool follow_sym_link = (eval_flags & RTEMS_FS_FOLLOW_SYM_LINK) != 0;
bool terminal = !rtems_filesystem_eval_path_has_path (ctx);
2022334: c2 07 60 04 ld [ %i5 + 4 ], %g1
if (rc == 0) {
bool is_sym_link = rtems_rfs_rtems_node_type_by_inode (inode)
== RTEMS_FILESYSTEM_SYM_LINK;
int eval_flags = rtems_filesystem_eval_path_get_flags (ctx);
bool follow_sym_link = (eval_flags & RTEMS_FS_FOLLOW_SYM_LINK) != 0;
2022338: c4 07 60 10 ld [ %i5 + 0x10 ], %g2
bool terminal = !rtems_filesystem_eval_path_has_path (ctx);
202233c: 80 a0 00 01 cmp %g0, %g1
2022340: c0 27 60 0c clr [ %i5 + 0xc ]
2022344: 82 60 3f ff subx %g0, -1, %g1
if (rc == 0) {
bool is_sym_link = rtems_rfs_rtems_node_type_by_inode (inode)
== RTEMS_FILESYSTEM_SYM_LINK;
int eval_flags = rtems_filesystem_eval_path_get_flags (ctx);
bool follow_sym_link = (eval_flags & RTEMS_FS_FOLLOW_SYM_LINK) != 0;
2022348: 85 30 a0 04 srl %g2, 4, %g2
bool terminal = !rtems_filesystem_eval_path_has_path (ctx);
202234c: b0 10 00 01 mov %g1, %i0
rtems_filesystem_eval_path_clear_token (ctx);
if (is_sym_link && (follow_sym_link || !terminal)) {
2022350: 80 a2 20 03 cmp %o0, 3
2022354: 12 bf ff ef bne 2022310 <rtems_rfs_rtems_eval_token+0x19c>
2022358: 84 08 a0 01 and %g2, 1, %g2
202235c: 10 bf ff c9 b 2022280 <rtems_rfs_rtems_eval_token+0x10c>
2022360: 80 a0 60 00 cmp %g1, 0
status = RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_CONTINUE;
}
} else {
rtems_filesystem_eval_path_error (
ctx,
rtems_rfs_rtems_error ("eval_path: set handlers", rc)
2022364: 40 00 7f a2 call 20421ec <__errno> <== NOT EXECUTED
2022368: 01 00 00 00 nop <== NOT EXECUTED
202236c: 82 10 20 05 mov 5, %g1 ! 5 <PROM_START+0x5> <== NOT EXECUTED
if (!terminal) {
status = RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_CONTINUE;
}
} else {
rtems_filesystem_eval_path_error (
2022370: 92 10 3f ff mov -1, %o1 <== NOT EXECUTED
ctx,
rtems_rfs_rtems_error ("eval_path: set handlers", rc)
2022374: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
if (!terminal) {
status = RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_CONTINUE;
}
} else {
rtems_filesystem_eval_path_error (
2022378: 10 bf ff e2 b 2022300 <rtems_rfs_rtems_eval_token+0x18c> <== NOT EXECUTED
202237c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
void *arg,
const char *token,
size_t tokenlen
)
{
rtems_filesystem_eval_path_generic_status status =
2022380: b0 0e 20 ff and %i0, 0xff, %i0
if (is_sym_link && (follow_sym_link || !terminal)) {
rtems_rfs_rtems_follow_link (ctx, fs, entry_ino);
} else {
rc = rtems_rfs_rtems_set_handlers (currentloc, inode) ? 0 : EIO;
if (rc == 0) {
rtems_rfs_rtems_set_pathloc_ino (currentloc, entry_ino);
2022384: c2 27 60 20 st %g1, [ %i5 + 0x20 ]
rtems_rfs_rtems_set_pathloc_doff (currentloc, entry_doff);
2022388: c2 07 bf f8 ld [ %fp + -8 ], %g1
202238c: c2 27 60 24 st %g1, [ %i5 + 0x24 ]
}
}
}
return status;
}
2022390: 81 c7 e0 08 ret
2022394: 81 e8 00 00 restore
02022638 <rtems_rfs_rtems_fchmod>:
}
static int
rtems_rfs_rtems_fchmod (const rtems_filesystem_location_info_t* pathloc,
mode_t mode)
{
2022638: 9d e3 bf 78 save %sp, -136, %sp
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
202263c: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
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);
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
2022640: d2 06 20 08 ld [ %i0 + 8 ], %o1
static int
rtems_rfs_rtems_fchmod (const rtems_filesystem_location_info_t* pathloc,
mode_t mode)
{
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
2022644: fa 00 60 08 ld [ %g1 + 8 ], %i5
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);
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
2022648: 94 07 bf d8 add %fp, -40, %o2
202264c: 90 10 00 1d mov %i5, %o0
2022650: 40 00 65 54 call 203bba0 <rtems_rfs_inode_open>
2022654: 96 10 20 01 mov 1, %o3
if (rc)
2022658: b8 92 20 00 orcc %o0, 0, %i4
202265c: 02 80 00 07 be 2022678 <rtems_rfs_rtems_fchmod+0x40> <== ALWAYS TAKEN
2022660: c2 07 bf e4 ld [ %fp + -28 ], %g1
{
return rtems_rfs_rtems_error ("fchmod: opening inode", rc);
2022664: 40 00 7e e2 call 20421ec <__errno> <== NOT EXECUTED
2022668: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
202266c: f8 22 00 00 st %i4, [ %o0 ] <== NOT EXECUTED
2022670: 81 c7 e0 08 ret <== NOT EXECUTED
2022674: 81 e8 00 00 restore <== 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);
2022678: f8 08 60 02 ldub [ %g1 + 2 ], %i4
202267c: c2 08 60 03 ldub [ %g1 + 3 ], %g1
2022680: b9 2f 20 08 sll %i4, 8, %i4
/*
* Verify I am the owner of the node or the super user.
*/
#if defined (RTEMS_POSIX_API)
uid = geteuid();
2022684: 40 00 16 95 call 20280d8 <geteuid>
2022688: b8 17 00 01 or %i4, %g1, %i4
* @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;
202268c: c2 07 bf e4 ld [ %fp + -28 ], %g1
if ((uid != rtems_rfs_inode_get_uid (&inode)) && (uid != 0))
2022690: 91 2a 20 10 sll %o0, 0x10, %o0
2022694: c6 08 60 07 ldub [ %g1 + 7 ], %g3
2022698: c4 08 60 06 ldub [ %g1 + 6 ], %g2
202269c: 85 28 a0 08 sll %g2, 8, %g2
20226a0: 84 10 80 03 or %g2, %g3, %g2
20226a4: 85 28 a0 10 sll %g2, 0x10, %g2
20226a8: 80 a0 80 08 cmp %g2, %o0
20226ac: 02 80 00 0e be 20226e4 <rtems_rfs_rtems_fchmod+0xac> <== ALWAYS TAKEN
20226b0: 87 32 20 10 srl %o0, 0x10, %g3
20226b4: 80 a0 e0 00 cmp %g3, 0 <== NOT EXECUTED
20226b8: 22 80 00 0c be,a 20226e8 <rtems_rfs_rtems_fchmod+0xb0> <== NOT EXECUTED
20226bc: b8 0f 30 00 and %i4, -4096, %i4 <== NOT EXECUTED
{
rtems_rfs_inode_close (fs, &inode);
20226c0: 92 07 bf d8 add %fp, -40, %o1 <== NOT EXECUTED
20226c4: 40 00 65 a9 call 203bd68 <rtems_rfs_inode_close> <== NOT EXECUTED
20226c8: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
return rtems_rfs_rtems_error ("fchmod: checking uid", EPERM);
20226cc: 40 00 7e c8 call 20421ec <__errno> <== NOT EXECUTED
20226d0: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
20226d4: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED
20226d8: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
20226dc: 81 c7 e0 08 ret <== NOT EXECUTED
20226e0: 81 e8 00 00 restore <== NOT EXECUTED
}
#endif
imode &= ~(S_IRWXU | S_IRWXG | S_IRWXO | S_ISUID | S_ISGID | S_ISVTX);
20226e4: b8 0f 30 00 and %i4, -4096, %i4
imode |= mode & (S_IRWXU | S_IRWXG | S_IRWXO | S_ISUID | S_ISGID | S_ISVTX);
20226e8: b2 0e 6f ff and %i1, 0xfff, %i1
20226ec: b2 17 00 19 or %i4, %i1, %i1
* @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);
20226f0: 85 36 60 08 srl %i1, 8, %g2
20226f4: c4 28 60 02 stb %g2, [ %g1 + 2 ]
20226f8: c2 07 bf e4 ld [ %fp + -28 ], %g1
rtems_rfs_inode_set_mode (&inode, imode);
rc = rtems_rfs_inode_close (fs, &inode);
20226fc: 90 10 00 1d mov %i5, %o0
2022700: f2 28 60 03 stb %i1, [ %g1 + 3 ]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
2022704: 82 10 20 01 mov 1, %g1
2022708: 92 07 bf d8 add %fp, -40, %o1
202270c: c2 2f bf e8 stb %g1, [ %fp + -24 ]
2022710: 40 00 65 96 call 203bd68 <rtems_rfs_inode_close>
2022714: b0 10 20 00 clr %i0
if (rc > 0)
2022718: 80 a2 20 00 cmp %o0, 0
202271c: 04 80 00 05 ble 2022730 <rtems_rfs_rtems_fchmod+0xf8> <== ALWAYS TAKEN
2022720: ba 10 00 08 mov %o0, %i5
{
return rtems_rfs_rtems_error ("fchmod: closing inode", rc);
2022724: 40 00 7e b2 call 20421ec <__errno> <== NOT EXECUTED
2022728: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
202272c: fa 22 00 00 st %i5, [ %o0 ] <== NOT EXECUTED
}
return 0;
}
2022730: 81 c7 e0 08 ret
2022734: 81 e8 00 00 restore
02022754 <rtems_rfs_rtems_fdatasync>:
* @param iop
* @return int
*/
int
rtems_rfs_rtems_fdatasync (rtems_libio_t* iop)
{
2022754: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED
int rc;
rc = rtems_rfs_buffer_sync (rtems_rfs_rtems_pathloc_dev (&iop->pathinfo));
2022758: c2 06 20 28 ld [ %i0 + 0x28 ], %g1 <== NOT EXECUTED
if (rc)
return rtems_rfs_rtems_error ("fdatasync: sync", rc);
return 0;
202275c: b0 10 20 00 clr %i0 <== NOT EXECUTED
int
rtems_rfs_rtems_fdatasync (rtems_libio_t* iop)
{
int rc;
rc = rtems_rfs_buffer_sync (rtems_rfs_rtems_pathloc_dev (&iop->pathinfo));
2022760: 40 00 54 87 call 203797c <rtems_rfs_buffer_sync> <== NOT EXECUTED
2022764: d0 00 60 08 ld [ %g1 + 8 ], %o0 <== NOT EXECUTED
if (rc)
2022768: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
202276c: 02 80 00 05 be 2022780 <rtems_rfs_rtems_fdatasync+0x2c> <== NOT EXECUTED
2022770: ba 10 00 08 mov %o0, %i5 <== NOT EXECUTED
return rtems_rfs_rtems_error ("fdatasync: sync", rc);
2022774: 40 00 7e 9e call 20421ec <__errno> <== NOT EXECUTED
2022778: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
202277c: fa 22 00 00 st %i5, [ %o0 ] <== NOT EXECUTED
return 0;
}
2022780: 81 c7 e0 08 ret <== NOT EXECUTED
2022784: 81 e8 00 00 restore <== NOT EXECUTED
0203d6d4 <rtems_rfs_rtems_file_close>:
* @param iop
* @return int
*/
static int
rtems_rfs_rtems_file_close (rtems_libio_t* iop)
{
203d6d4: 9d e3 bf a0 save %sp, -96, %sp
rtems_rfs_file_handle* file = rtems_rfs_rtems_get_iop_file_handle (iop);
203d6d8: f8 06 20 20 ld [ %i0 + 0x20 ], %i4
rtems_rfs_file_system* fs = rtems_rfs_file_fs (file);
203d6dc: c2 07 20 1c ld [ %i4 + 0x1c ], %g1
203d6e0: fa 00 60 98 ld [ %g1 + 0x98 ], %i5
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);
203d6e4: 7f ff ff 20 call 203d364 <rtems_rfs_rtems_lock>
203d6e8: 90 10 00 1d mov %i5, %o0
rc = rtems_rfs_file_close (fs, file);
203d6ec: 90 10 00 1d mov %i5, %o0
203d6f0: 7f ff ed f6 call 2038ec8 <rtems_rfs_file_close>
203d6f4: 92 10 00 1c mov %i4, %o1
if (rc > 0)
203d6f8: b0 92 20 00 orcc %o0, 0, %i0
203d6fc: 04 80 00 06 ble 203d714 <rtems_rfs_rtems_file_close+0x40> <== ALWAYS TAKEN
203d700: 01 00 00 00 nop
rc = rtems_rfs_rtems_error ("file-close: file close", rc);
203d704: 40 00 12 ba call 20421ec <__errno> <== NOT EXECUTED
203d708: 01 00 00 00 nop <== NOT EXECUTED
203d70c: f0 22 00 00 st %i0, [ %o0 ] <== NOT EXECUTED
203d710: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
rtems_rfs_rtems_unlock (fs);
203d714: 7f ff ff 29 call 203d3b8 <rtems_rfs_rtems_unlock>
203d718: 90 10 00 1d mov %i5, %o0
return rc;
}
203d71c: 81 c7 e0 08 ret
203d720: 81 e8 00 00 restore
0203d40c <rtems_rfs_rtems_file_ftruncate>:
* @return int
*/
static int
rtems_rfs_rtems_file_ftruncate (rtems_libio_t* iop,
off_t length)
{
203d40c: 9d e3 bf a0 save %sp, -96, %sp
rtems_rfs_file_handle* file = rtems_rfs_rtems_get_iop_file_handle (iop);
203d410: f6 06 20 20 ld [ %i0 + 0x20 ], %i3
int rc;
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_FILE_FTRUNC))
printf("rtems-rfs: file-ftrunc: handle:%p length:%" PRIdoff_t "\n", file, length);
rtems_rfs_rtems_lock (rtems_rfs_file_fs (file));
203d414: c2 06 e0 1c ld [ %i3 + 0x1c ], %g1
203d418: 7f ff ff d3 call 203d364 <rtems_rfs_rtems_lock>
203d41c: d0 00 60 98 ld [ %g1 + 0x98 ], %o0
rc = rtems_rfs_file_set_size (file, length);
203d420: 90 10 00 1b mov %i3, %o0
203d424: 92 10 00 19 mov %i1, %o1
203d428: 7f ff f0 c8 call 2039748 <rtems_rfs_file_set_size>
203d42c: 94 10 00 1a mov %i2, %o2
if (rc)
203d430: b0 92 20 00 orcc %o0, 0, %i0
203d434: 22 80 00 07 be,a 203d450 <rtems_rfs_rtems_file_ftruncate+0x44><== ALWAYS TAKEN
203d438: c2 06 e0 1c ld [ %i3 + 0x1c ], %g1
rc = rtems_rfs_rtems_error ("file_ftruncate: set size", rc);
203d43c: 40 00 13 6c call 20421ec <__errno> <== NOT EXECUTED
203d440: 01 00 00 00 nop <== NOT EXECUTED
203d444: f0 22 00 00 st %i0, [ %o0 ] <== NOT EXECUTED
203d448: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
203d44c: c2 06 e0 1c ld [ %i3 + 0x1c ], %g1 <== NOT EXECUTED
203d450: 7f ff ff da call 203d3b8 <rtems_rfs_rtems_unlock>
203d454: d0 00 60 98 ld [ %g1 + 0x98 ], %o0
return rc;
}
203d458: 81 c7 e0 08 ret
203d45c: 81 e8 00 00 restore
0203d460 <rtems_rfs_rtems_file_lseek>:
*/
static off_t
rtems_rfs_rtems_file_lseek (rtems_libio_t* iop,
off_t offset,
int whence)
{
203d460: 9d e3 bf 98 save %sp, -104, %sp
203d464: b8 10 00 19 mov %i1, %i4
rtems_rfs_file_handle* file = rtems_rfs_rtems_get_iop_file_handle (iop);
203d468: f2 06 20 20 ld [ %i0 + 0x20 ], %i1
*/
static off_t
rtems_rfs_rtems_file_lseek (rtems_libio_t* iop,
off_t offset,
int whence)
{
203d46c: ba 10 00 1a mov %i2, %i5
off_t new_offset;
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_FILE_LSEEK))
printf("rtems-rfs: file-lseek: handle:%p offset:%" PRIdoff_t "\n", file, offset);
rtems_rfs_rtems_lock (rtems_rfs_file_fs (file));
203d470: c2 06 60 1c ld [ %i1 + 0x1c ], %g1
*/
static off_t
rtems_rfs_rtems_file_lseek (rtems_libio_t* iop,
off_t offset,
int whence)
{
203d474: a0 10 00 1b mov %i3, %l0
off_t new_offset;
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_FILE_LSEEK))
printf("rtems-rfs: file-lseek: handle:%p offset:%" PRIdoff_t "\n", file, offset);
rtems_rfs_rtems_lock (rtems_rfs_file_fs (file));
203d478: 7f ff ff bb call 203d364 <rtems_rfs_rtems_lock>
203d47c: d0 00 60 98 ld [ %g1 + 0x98 ], %o0
old_offset = iop->offset;
new_offset = rtems_filesystem_default_lseek_file (iop, offset, whence);
203d480: 92 10 00 1c mov %i4, %o1
203d484: 94 10 00 1d mov %i5, %o2
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_FILE_LSEEK))
printf("rtems-rfs: file-lseek: handle:%p offset:%" PRIdoff_t "\n", file, offset);
rtems_rfs_rtems_lock (rtems_rfs_file_fs (file));
old_offset = iop->offset;
203d488: f4 1e 20 08 ldd [ %i0 + 8 ], %i2
new_offset = rtems_filesystem_default_lseek_file (iop, offset, whence);
203d48c: 90 10 00 18 mov %i0, %o0
203d490: 40 00 01 51 call 203d9d4 <rtems_filesystem_default_lseek_file>
203d494: 96 10 00 10 mov %l0, %o3
203d498: b8 10 00 08 mov %o0, %i4
if (new_offset != -1)
203d49c: 80 a7 3f ff cmp %i4, -1
203d4a0: 12 80 00 05 bne 203d4b4 <rtems_rfs_rtems_file_lseek+0x54>
203d4a4: ba 10 00 09 mov %o1, %i5
203d4a8: 80 a2 7f ff cmp %o1, -1
203d4ac: 22 80 00 13 be,a 203d4f8 <rtems_rfs_rtems_file_lseek+0x98><== ALWAYS TAKEN
203d4b0: c2 06 60 1c ld [ %i1 + 0x1c ], %g1
{
rtems_rfs_pos pos = iop->offset;
203d4b4: c4 1e 20 08 ldd [ %i0 + 8 ], %g2
int rc = rtems_rfs_file_seek (file, pos, &pos);
203d4b8: 90 10 00 19 mov %i1, %o0
old_offset = iop->offset;
new_offset = rtems_filesystem_default_lseek_file (iop, offset, whence);
if (new_offset != -1)
{
rtems_rfs_pos pos = iop->offset;
203d4bc: c4 3f bf f8 std %g2, [ %fp + -8 ]
int rc = rtems_rfs_file_seek (file, pos, &pos);
203d4c0: 92 10 00 02 mov %g2, %o1
203d4c4: 94 10 00 03 mov %g3, %o2
203d4c8: 7f ff f0 62 call 2039650 <rtems_rfs_file_seek>
203d4cc: 96 07 bf f8 add %fp, -8, %o3
if (rc)
203d4d0: a0 92 20 00 orcc %o0, 0, %l0
203d4d4: 22 80 00 09 be,a 203d4f8 <rtems_rfs_rtems_file_lseek+0x98><== ALWAYS TAKEN
203d4d8: c2 06 60 1c ld [ %i1 + 0x1c ], %g1
{
rtems_rfs_rtems_error ("file_lseek: lseek", rc);
203d4dc: 40 00 13 44 call 20421ec <__errno> <== NOT EXECUTED
203d4e0: 39 3f ff ff sethi %hi(0xfffffc00), %i4 <== NOT EXECUTED
203d4e4: e0 22 00 00 st %l0, [ %o0 ] <== NOT EXECUTED
iop->offset = old_offset;
203d4e8: f4 3e 20 08 std %i2, [ %i0 + 8 ] <== NOT EXECUTED
new_offset = -1;
203d4ec: b8 17 23 ff or %i4, 0x3ff, %i4 <== NOT EXECUTED
203d4f0: ba 10 00 1c mov %i4, %i5 <== NOT EXECUTED
}
}
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
203d4f4: c2 06 60 1c ld [ %i1 + 0x1c ], %g1 <== NOT EXECUTED
return new_offset;
}
203d4f8: b0 10 00 1c mov %i4, %i0
iop->offset = old_offset;
new_offset = -1;
}
}
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
203d4fc: d0 00 60 98 ld [ %g1 + 0x98 ], %o0
203d500: 7f ff ff ae call 203d3b8 <rtems_rfs_rtems_unlock>
203d504: b2 10 00 1d mov %i5, %i1
return new_offset;
}
203d508: 81 c7 e0 08 ret
203d50c: 81 e8 00 00 restore
0203d724 <rtems_rfs_rtems_file_open>:
static int
rtems_rfs_rtems_file_open (rtems_libio_t* iop,
const char* pathname,
int oflag,
mode_t mode)
{
203d724: 9d e3 bf 98 save %sp, -104, %sp
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (&iop->pathinfo);
203d728: c2 06 20 28 ld [ %i0 + 0x28 ], %g1
203d72c: fa 00 60 08 ld [ %g1 + 8 ], %i5
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_FILE_OPEN))
printf("rtems-rfs: file-open: path:%s ino:%" PRId32 " flags:%04i mode:%04" PRIu32 "\n",
pathname, ino, flags, mode);
rtems_rfs_rtems_lock (fs);
203d730: 7f ff ff 0d call 203d364 <rtems_rfs_rtems_lock>
203d734: 90 10 00 1d mov %i5, %o0
ino = rtems_rfs_rtems_get_iop_ino (iop);
rc = rtems_rfs_file_open (fs, ino, flags, &file);
203d738: d2 06 20 1c ld [ %i0 + 0x1c ], %o1
203d73c: 90 10 00 1d mov %i5, %o0
203d740: 94 10 20 00 clr %o2
203d744: 7f ff f0 d9 call 2039aa8 <rtems_rfs_file_open>
203d748: 96 07 bf fc add %fp, -4, %o3
if (rc > 0)
203d74c: b8 92 20 00 orcc %o0, 0, %i4
203d750: 04 80 00 09 ble 203d774 <rtems_rfs_rtems_file_open+0x50> <== ALWAYS TAKEN
203d754: c2 07 bf fc ld [ %fp + -4 ], %g1
{
rtems_rfs_rtems_unlock (fs);
203d758: 7f ff ff 18 call 203d3b8 <rtems_rfs_rtems_unlock> <== NOT EXECUTED
203d75c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
return rtems_rfs_rtems_error ("file-open: open", rc);
203d760: 40 00 12 a3 call 20421ec <__errno> <== NOT EXECUTED
203d764: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
203d768: f8 22 00 00 st %i4, [ %o0 ] <== NOT EXECUTED
203d76c: 81 c7 e0 08 ret <== NOT EXECUTED
203d770: 81 e8 00 00 restore <== NOT EXECUTED
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_FILE_OPEN))
printf("rtems-rfs: file-open: handle:%p\n", file);
rtems_rfs_rtems_set_iop_file_handle (iop, file);
rtems_rfs_rtems_unlock (fs);
203d774: 90 10 00 1d mov %i5, %o0
}
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_FILE_OPEN))
printf("rtems-rfs: file-open: handle:%p\n", file);
rtems_rfs_rtems_set_iop_file_handle (iop, file);
203d778: c2 26 20 20 st %g1, [ %i0 + 0x20 ]
rtems_rfs_rtems_unlock (fs);
203d77c: 7f ff ff 0f call 203d3b8 <rtems_rfs_rtems_unlock>
203d780: b0 10 20 00 clr %i0
return 0;
}
203d784: 81 c7 e0 08 ret
203d788: 81 e8 00 00 restore
0203d78c <rtems_rfs_rtems_file_read>:
*/
static ssize_t
rtems_rfs_rtems_file_read (rtems_libio_t* iop,
void* buffer,
size_t count)
{
203d78c: 9d e3 bf 98 save %sp, -104, %sp
rtems_rfs_file_handle* file = rtems_rfs_rtems_get_iop_file_handle (iop);
203d790: e0 06 20 20 ld [ %i0 + 0x20 ], %l0
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));
203d794: c2 04 20 1c ld [ %l0 + 0x1c ], %g1
203d798: 7f ff fe f3 call 203d364 <rtems_rfs_rtems_lock>
203d79c: d0 00 60 98 ld [ %g1 + 0x98 ], %o0
pos = iop->offset;
if (pos < rtems_rfs_file_size (file))
203d7a0: d2 04 20 1c ld [ %l0 + 0x1c ], %o1
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;
203d7a4: f8 1e 20 08 ldd [ %i0 + 8 ], %i4
203d7a8: d0 02 60 98 ld [ %o1 + 0x98 ], %o0
203d7ac: 7f ff e3 6d call 2036560 <rtems_rfs_block_get_size>
203d7b0: 92 02 60 84 add %o1, 0x84, %o1
if (pos < rtems_rfs_file_size (file))
203d7b4: 80 a2 00 1c cmp %o0, %i4
203d7b8: 18 80 00 2a bgu 203d860 <rtems_rfs_rtems_file_read+0xd4> <== NEVER TAKEN
203d7bc: b6 10 20 00 clr %i3
203d7c0: 80 a2 00 1c cmp %o0, %i4
203d7c4: 12 80 00 2d bne 203d878 <rtems_rfs_rtems_file_read+0xec> <== NEVER TAKEN
203d7c8: 80 a2 40 1d cmp %o1, %i5
203d7cc: 18 80 00 26 bgu 203d864 <rtems_rfs_rtems_file_read+0xd8>
203d7d0: 80 a6 a0 00 cmp %i2, 0
}
}
}
if (read >= 0)
iop->offset = pos + read;
203d7d4: 10 80 00 2a b 203d87c <rtems_rfs_rtems_file_read+0xf0>
203d7d8: ba 86 c0 1d addcc %i3, %i5, %i5
{
while (count)
{
size_t size;
rc = rtems_rfs_file_io_start (file, &size, true);
203d7dc: 92 07 bf fc add %fp, -4, %o1
203d7e0: 7f ff ee 66 call 2039178 <rtems_rfs_file_io_start>
203d7e4: 94 10 20 01 mov 1, %o2
if (rc > 0)
203d7e8: a2 92 20 00 orcc %o0, 0, %l1
203d7ec: 14 80 00 19 bg 203d850 <rtems_rfs_rtems_file_read+0xc4> <== NEVER TAKEN
203d7f0: c2 07 bf fc ld [ %fp + -4 ], %g1
{
read = rtems_rfs_rtems_error ("file-read: read: io-start", rc);
break;
}
if (size == 0)
203d7f4: 80 a0 60 00 cmp %g1, 0
203d7f8: 02 80 00 1d be 203d86c <rtems_rfs_rtems_file_read+0xe0>
203d7fc: 80 a0 40 1a cmp %g1, %i2
break;
if (size > count)
203d800: 38 80 00 02 bgu,a 203d808 <rtems_rfs_rtems_file_read+0x7c>
203d804: f4 27 bf fc st %i2, [ %fp + -4 ]
size = count;
memcpy (data, rtems_rfs_file_data (file), size);
203d808: c2 04 20 0c ld [ %l0 + 0xc ], %g1
203d80c: e2 07 bf fc ld [ %fp + -4 ], %l1
203d810: d2 00 60 1c ld [ %g1 + 0x1c ], %o1
203d814: c2 04 20 14 ld [ %l0 + 0x14 ], %g1
203d818: 94 10 00 11 mov %l1, %o2
203d81c: 92 02 40 01 add %o1, %g1, %o1
203d820: 40 00 1f b2 call 20456e8 <memcpy>
203d824: 90 10 00 19 mov %i1, %o0
data += size;
count -= size;
read += size;
rc = rtems_rfs_file_io_end (file, size, true);
203d828: 92 10 00 11 mov %l1, %o1
if (size > count)
size = count;
memcpy (data, rtems_rfs_file_data (file), size);
data += size;
203d82c: b2 06 40 11 add %i1, %l1, %i1
count -= size;
203d830: b4 26 80 11 sub %i2, %l1, %i2
read += size;
203d834: b6 06 c0 11 add %i3, %l1, %i3
rc = rtems_rfs_file_io_end (file, size, true);
203d838: 90 10 00 10 mov %l0, %o0
203d83c: 7f ff ee d8 call 203939c <rtems_rfs_file_io_end>
203d840: 94 10 20 01 mov 1, %o2
if (rc > 0)
203d844: a2 92 20 00 orcc %o0, 0, %l1
203d848: 04 80 00 07 ble 203d864 <rtems_rfs_rtems_file_read+0xd8> <== ALWAYS TAKEN
203d84c: 80 a6 a0 00 cmp %i2, 0
{
read = rtems_rfs_rtems_error ("file-read: read: io-end", rc);
203d850: 40 00 12 67 call 20421ec <__errno> <== NOT EXECUTED
203d854: b6 10 3f ff mov -1, %i3 <== NOT EXECUTED
203d858: 10 80 00 0c b 203d888 <rtems_rfs_rtems_file_read+0xfc> <== NOT EXECUTED
203d85c: e2 22 00 00 st %l1, [ %o0 ] <== NOT EXECUTED
pos = iop->offset;
if (pos < rtems_rfs_file_size (file))
{
while (count)
203d860: 80 a6 a0 00 cmp %i2, 0 <== NOT EXECUTED
203d864: 12 bf ff de bne 203d7dc <rtems_rfs_rtems_file_read+0x50>
203d868: 90 10 00 10 mov %l0, %o0
break;
}
}
}
if (read >= 0)
203d86c: 80 a6 e0 00 cmp %i3, 0
203d870: 26 80 00 07 bl,a 203d88c <rtems_rfs_rtems_file_read+0x100><== NEVER TAKEN
203d874: c2 04 20 1c ld [ %l0 + 0x1c ], %g1 <== NOT EXECUTED
iop->offset = pos + read;
203d878: ba 86 c0 1d addcc %i3, %i5, %i5
203d87c: 85 3e e0 1f sra %i3, 0x1f, %g2
203d880: b8 40 80 1c addx %g2, %i4, %i4
203d884: f8 3e 20 08 std %i4, [ %i0 + 8 ]
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
203d888: c2 04 20 1c ld [ %l0 + 0x1c ], %g1
return read;
}
203d88c: b0 10 00 1b mov %i3, %i0
}
if (read >= 0)
iop->offset = pos + read;
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
203d890: 7f ff fe ca call 203d3b8 <rtems_rfs_rtems_unlock>
203d894: d0 00 60 98 ld [ %g1 + 0x98 ], %o0
return read;
}
203d898: 81 c7 e0 08 ret
203d89c: 81 e8 00 00 restore
0203d510 <rtems_rfs_rtems_file_write>:
*/
static ssize_t
rtems_rfs_rtems_file_write (rtems_libio_t* iop,
const void* buffer,
size_t count)
{
203d510: 9d e3 bf 90 save %sp, -112, %sp
rtems_rfs_file_handle* file = rtems_rfs_rtems_get_iop_file_handle (iop);
203d514: f6 06 20 20 ld [ %i0 + 0x20 ], %i3
*/
static ssize_t
rtems_rfs_rtems_file_write (rtems_libio_t* iop,
const void* buffer,
size_t count)
{
203d518: a0 10 00 18 mov %i0, %l0
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));
203d51c: c2 06 e0 1c ld [ %i3 + 0x1c ], %g1
203d520: 7f ff ff 91 call 203d364 <rtems_rfs_rtems_lock>
203d524: d0 00 60 98 ld [ %g1 + 0x98 ], %o0
pos = iop->offset;
file_size = rtems_rfs_file_size (file);
203d528: d2 06 e0 1c ld [ %i3 + 0x1c ], %o1
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;
203d52c: c4 1e 20 08 ldd [ %i0 + 8 ], %g2
203d530: d0 02 60 98 ld [ %o1 + 0x98 ], %o0
203d534: c4 3f bf f8 std %g2, [ %fp + -8 ]
203d538: 7f ff e4 0a call 2036560 <rtems_rfs_block_get_size>
203d53c: 92 02 60 84 add %o1, 0x84, %o1
203d540: 86 10 00 09 mov %o1, %g3
file_size = rtems_rfs_file_size (file);
if (pos > file_size)
203d544: d2 07 bf f8 ld [ %fp + -8 ], %o1
203d548: 82 10 00 08 mov %o0, %g1
203d54c: 80 a2 40 01 cmp %o1, %g1
203d550: 18 80 00 08 bgu 203d570 <rtems_rfs_rtems_file_write+0x60> <== NEVER TAKEN
203d554: d4 07 bf fc ld [ %fp + -4 ], %o2
203d558: 80 a2 40 01 cmp %o1, %g1
203d55c: 12 80 00 11 bne 203d5a0 <rtems_rfs_rtems_file_write+0x90> <== NEVER TAKEN
203d560: 80 a0 40 09 cmp %g1, %o1
203d564: 80 a2 80 03 cmp %o2, %g3
203d568: 08 80 00 0e bleu 203d5a0 <rtems_rfs_rtems_file_write+0x90>
203d56c: 80 a0 40 09 cmp %g1, %o1
/*
* If the iop position is past the physical end of the file we need to set
* the file size to the new length before writing. The
* rtems_rfs_file_io_end() will grow the file subsequently.
*/
rc = rtems_rfs_file_set_size (file, pos);
203d570: 7f ff f0 76 call 2039748 <rtems_rfs_file_set_size>
203d574: 90 10 00 1b mov %i3, %o0
203d578: c2 06 e0 1c ld [ %i3 + 0x1c ], %g1
if (rc)
203d57c: ba 92 20 00 orcc %o0, 0, %i5
203d580: 12 80 00 20 bne 203d600 <rtems_rfs_rtems_file_write+0xf0> <== NEVER TAKEN
203d584: d0 00 60 98 ld [ %g1 + 0x98 ], %o0
{
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);
203d588: d2 07 bf f8 ld [ %fp + -8 ], %o1
203d58c: d4 07 bf fc ld [ %fp + -4 ], %o2
203d590: 7f ff e3 c4 call 20364a0 <rtems_rfs_block_get_bpos>
203d594: 96 06 e0 10 add %i3, 0x10, %o3
*/
static ssize_t
rtems_rfs_rtems_file_write (rtems_libio_t* iop,
const void* buffer,
size_t count)
{
203d598: 10 80 00 40 b 203d698 <rtems_rfs_rtems_file_write+0x188>
203d59c: b0 10 20 00 clr %i0
return rtems_rfs_rtems_error ("file-write: write extend", rc);
}
rtems_rfs_file_set_bpos (file, pos);
}
else if (pos < file_size && (iop->flags & LIBIO_FLAGS_APPEND) != 0)
203d5a0: 38 80 00 09 bgu,a 203d5c4 <rtems_rfs_rtems_file_write+0xb4><== NEVER TAKEN
203d5a4: c4 04 20 10 ld [ %l0 + 0x10 ], %g2 <== NOT EXECUTED
203d5a8: 80 a0 40 09 cmp %g1, %o1
203d5ac: 12 80 00 3b bne 203d698 <rtems_rfs_rtems_file_write+0x188><== NEVER TAKEN
203d5b0: b0 10 20 00 clr %i0
203d5b4: 80 a0 c0 0a cmp %g3, %o2
203d5b8: 08 80 00 39 bleu 203d69c <rtems_rfs_rtems_file_write+0x18c>
203d5bc: 80 a6 a0 00 cmp %i2, 0
203d5c0: c4 04 20 10 ld [ %l0 + 0x10 ], %g2
203d5c4: 80 88 a2 00 btst 0x200, %g2
203d5c8: 22 80 00 34 be,a 203d698 <rtems_rfs_rtems_file_write+0x188>
203d5cc: b0 10 20 00 clr %i0
{
pos = file_size;
203d5d0: c2 27 bf f8 st %g1, [ %fp + -8 ]
203d5d4: c6 27 bf fc st %g3, [ %fp + -4 ]
rc = rtems_rfs_file_seek (file, pos, &pos);
203d5d8: 90 10 00 1b mov %i3, %o0
203d5dc: 92 10 00 01 mov %g1, %o1
203d5e0: 94 10 00 03 mov %g3, %o2
203d5e4: 7f ff f0 1b call 2039650 <rtems_rfs_file_seek>
203d5e8: 96 07 bf f8 add %fp, -8, %o3
if (rc)
203d5ec: ba 92 20 00 orcc %o0, 0, %i5
203d5f0: 22 80 00 2a be,a 203d698 <rtems_rfs_rtems_file_write+0x188><== ALWAYS TAKEN
203d5f4: b0 10 20 00 clr %i0
{
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
203d5f8: c2 06 e0 1c ld [ %i3 + 0x1c ], %g1 <== NOT EXECUTED
203d5fc: d0 00 60 98 ld [ %g1 + 0x98 ], %o0 <== NOT EXECUTED
203d600: 7f ff ff 6e call 203d3b8 <rtems_rfs_rtems_unlock> <== NOT EXECUTED
203d604: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
return rtems_rfs_rtems_error ("file-write: write append seek", rc);
203d608: 40 00 12 f9 call 20421ec <__errno> <== NOT EXECUTED
203d60c: 01 00 00 00 nop <== NOT EXECUTED
203d610: fa 22 00 00 st %i5, [ %o0 ] <== NOT EXECUTED
203d614: 81 c7 e0 08 ret <== NOT EXECUTED
203d618: 81 e8 00 00 restore <== NOT EXECUTED
while (count)
{
size_t size = count;
rc = rtems_rfs_file_io_start (file, &size, false);
203d61c: 90 10 00 1b mov %i3, %o0
203d620: 92 07 bf f4 add %fp, -12, %o1
203d624: 7f ff ee d5 call 2039178 <rtems_rfs_file_io_start>
203d628: 94 10 20 00 clr %o2
if (rc)
203d62c: ba 92 20 00 orcc %o0, 0, %i5
203d630: 12 80 00 16 bne 203d688 <rtems_rfs_rtems_file_write+0x178>
203d634: c2 07 bf f4 ld [ %fp + -12 ], %g1
{
write = rtems_rfs_rtems_error ("file-write: write open", rc);
break;
}
if (size > count)
203d638: 80 a0 40 1a cmp %g1, %i2
203d63c: 38 80 00 02 bgu,a 203d644 <rtems_rfs_rtems_file_write+0x134>
203d640: f4 27 bf f4 st %i2, [ %fp + -12 ]
size = count;
memcpy (rtems_rfs_file_data (file), data, size);
203d644: c2 06 e0 0c ld [ %i3 + 0xc ], %g1
203d648: d4 07 bf f4 ld [ %fp + -12 ], %o2
203d64c: d0 00 60 1c ld [ %g1 + 0x1c ], %o0
203d650: c2 06 e0 14 ld [ %i3 + 0x14 ], %g1
203d654: 92 10 00 19 mov %i1, %o1
203d658: 40 00 20 24 call 20456e8 <memcpy>
203d65c: 90 02 00 01 add %o0, %g1, %o0
data += size;
203d660: d2 07 bf f4 ld [ %fp + -12 ], %o1
count -= size;
write += size;
rc = rtems_rfs_file_io_end (file, size, false);
203d664: 90 10 00 1b mov %i3, %o0
if (size > count)
size = count;
memcpy (rtems_rfs_file_data (file), data, size);
data += size;
203d668: b2 06 40 09 add %i1, %o1, %i1
count -= size;
203d66c: b4 26 80 09 sub %i2, %o1, %i2
write += size;
203d670: b0 06 00 09 add %i0, %o1, %i0
rc = rtems_rfs_file_io_end (file, size, false);
203d674: 7f ff ef 4a call 203939c <rtems_rfs_file_io_end>
203d678: 94 10 20 00 clr %o2
if (rc)
203d67c: ba 92 20 00 orcc %o0, 0, %i5
203d680: 02 80 00 07 be 203d69c <rtems_rfs_rtems_file_write+0x18c> <== ALWAYS TAKEN
203d684: 80 a6 a0 00 cmp %i2, 0
{
write = rtems_rfs_rtems_error ("file-write: write close", rc);
203d688: 40 00 12 d9 call 20421ec <__errno>
203d68c: b0 10 3f ff mov -1, %i0
203d690: 10 80 00 0c b 203d6c0 <rtems_rfs_rtems_file_write+0x1b0>
203d694: fa 22 00 00 st %i5, [ %o0 ]
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
return rtems_rfs_rtems_error ("file-write: write append seek", rc);
}
}
while (count)
203d698: 80 a6 a0 00 cmp %i2, 0
203d69c: 32 bf ff e0 bne,a 203d61c <rtems_rfs_rtems_file_write+0x10c>
203d6a0: f4 27 bf f4 st %i2, [ %fp + -12 ]
write = rtems_rfs_rtems_error ("file-write: write close", rc);
break;
}
}
if (write >= 0)
203d6a4: 80 a6 20 00 cmp %i0, 0
203d6a8: 06 80 00 06 bl 203d6c0 <rtems_rfs_rtems_file_write+0x1b0> <== NEVER TAKEN
203d6ac: f8 1f bf f8 ldd [ %fp + -8 ], %i4
iop->offset = pos + write;
203d6b0: 85 3e 20 1f sra %i0, 0x1f, %g2
203d6b4: 86 86 00 1d addcc %i0, %i5, %g3
203d6b8: 84 40 80 1c addx %g2, %i4, %g2
203d6bc: c4 3c 20 08 std %g2, [ %l0 + 8 ]
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
203d6c0: c2 06 e0 1c ld [ %i3 + 0x1c ], %g1
203d6c4: 7f ff ff 3d call 203d3b8 <rtems_rfs_rtems_unlock>
203d6c8: d0 00 60 98 ld [ %g1 + 0x98 ], %o0
return write;
}
203d6cc: 81 c7 e0 08 ret
203d6d0: 81 e8 00 00 restore
02022398 <rtems_rfs_rtems_fstat>:
}
int
rtems_rfs_rtems_fstat (const rtems_filesystem_location_info_t* pathloc,
struct stat* buf)
{
2022398: 9d e3 bf 78 save %sp, -136, %sp
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
202239c: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
int rc;
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_STAT))
printf ("rtems-rfs-rtems: stat: in: ino:%" PRId32 "\n", ino);
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
20223a0: d2 06 20 08 ld [ %i0 + 8 ], %o1
int
rtems_rfs_rtems_fstat (const rtems_filesystem_location_info_t* pathloc,
struct stat* buf)
{
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
20223a4: fa 00 60 08 ld [ %g1 + 8 ], %i5
int rc;
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_STAT))
printf ("rtems-rfs-rtems: stat: in: ino:%" PRId32 "\n", ino);
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
20223a8: 94 07 bf d8 add %fp, -40, %o2
20223ac: 90 10 00 1d mov %i5, %o0
20223b0: 40 00 65 fc call 203bba0 <rtems_rfs_inode_open>
20223b4: 96 10 20 01 mov 1, %o3
if (rc)
20223b8: b8 92 20 00 orcc %o0, 0, %i4
20223bc: 02 80 00 07 be 20223d8 <rtems_rfs_rtems_fstat+0x40> <== ALWAYS TAKEN
20223c0: c4 07 bf e4 ld [ %fp + -28 ], %g2
{
return rtems_rfs_rtems_error ("stat: opening inode", rc);
20223c4: 40 00 7f 8a call 20421ec <__errno> <== NOT EXECUTED
20223c8: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
20223cc: f8 22 00 00 st %i4, [ %o0 ] <== NOT EXECUTED
20223d0: 81 c7 e0 08 ret <== NOT EXECUTED
20223d4: 81 e8 00 00 restore <== NOT EXECUTED
20223d8: c2 08 a0 02 ldub [ %g2 + 2 ], %g1
20223dc: f8 08 a0 03 ldub [ %g2 + 3 ], %i4
}
mode = rtems_rfs_inode_get_mode (&inode);
if (RTEMS_RFS_S_ISCHR (mode) || RTEMS_RFS_S_ISBLK (mode))
20223e0: 05 3f ff ec sethi %hi(0xffffb000), %g2
20223e4: 83 28 60 08 sll %g1, 8, %g1
20223e8: b8 10 40 1c or %g1, %i4, %i4
20223ec: 82 08 40 02 and %g1, %g2, %g1
20223f0: 05 00 00 08 sethi %hi(0x2000), %g2
20223f4: 80 a0 40 02 cmp %g1, %g2
20223f8: 32 80 00 0c bne,a 2022428 <rtems_rfs_rtems_fstat+0x90> <== ALWAYS TAKEN
20223fc: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
{
buf->st_rdev =
rtems_filesystem_make_dev_t (rtems_rfs_inode_get_block (&inode, 0),
2022400: 92 10 20 00 clr %o1 <== NOT EXECUTED
2022404: 7f ff fc bd call 20216f8 <rtems_rfs_inode_get_block> <== NOT EXECUTED
2022408: 90 07 bf d8 add %fp, -40, %o0 <== NOT EXECUTED
202240c: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
2022410: b6 10 00 08 mov %o0, %i3 <== NOT EXECUTED
2022414: 7f ff fc b9 call 20216f8 <rtems_rfs_inode_get_block> <== NOT EXECUTED
2022418: 90 07 bf d8 add %fp, -40, %o0 <== NOT EXECUTED
mode = rtems_rfs_inode_get_mode (&inode);
if (RTEMS_RFS_S_ISCHR (mode) || RTEMS_RFS_S_ISBLK (mode))
{
buf->st_rdev =
202241c: f6 26 60 18 st %i3, [ %i1 + 0x18 ] <== NOT EXECUTED
2022420: d0 26 60 1c st %o0, [ %i1 + 0x1c ] <== 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);
2022424: c2 07 60 10 ld [ %i5 + 0x10 ], %g1 <== NOT EXECUTED
buf->st_ino = rtems_rfs_inode_ino (&inode);
buf->st_mode = rtems_rfs_rtems_mode (mode);
2022428: 91 2f 20 10 sll %i4, 0x10, %o0
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);
202242c: c2 26 60 04 st %g1, [ %i1 + 4 ]
2022430: 83 38 60 1f sra %g1, 0x1f, %g1
2022434: c2 26 40 00 st %g1, [ %i1 ]
buf->st_ino = rtems_rfs_inode_ino (&inode);
2022438: c2 07 bf e0 ld [ %fp + -32 ], %g1
buf->st_mode = rtems_rfs_rtems_mode (mode);
202243c: 91 32 20 10 srl %o0, 0x10, %o0
2022440: 40 00 01 03 call 202284c <rtems_rfs_rtems_mode>
2022444: c2 26 60 08 st %g1, [ %i1 + 8 ]
*/
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);
2022448: c2 07 bf e4 ld [ %fp + -28 ], %g1
202244c: d0 26 60 0c st %o0, [ %i1 + 0xc ]
2022450: c6 08 60 01 ldub [ %g1 + 1 ], %g3
2022454: c4 08 40 00 ldub [ %g1 ], %g2
if (links == 0xffff)
2022458: 09 3f ff c0 sethi %hi(0xffff0000), %g4
*/
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);
202245c: 85 28 a0 08 sll %g2, 8, %g2
2022460: 84 10 80 03 or %g2, %g3, %g2
if (links == 0xffff)
2022464: 87 28 a0 10 sll %g2, 0x10, %g3
2022468: 87 30 e0 10 srl %g3, 0x10, %g3
links = 0;
202246c: 86 39 00 03 xnor %g4, %g3, %g3
2022470: 80 a0 00 03 cmp %g0, %g3
2022474: 86 60 20 00 subx %g0, 0, %g3
2022478: 84 08 80 03 and %g2, %g3, %g2
buf->st_nlink = rtems_rfs_inode_get_links (&inode);
202247c: c4 36 60 10 sth %g2, [ %i1 + 0x10 ]
* @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;
2022480: c6 08 60 06 ldub [ %g1 + 6 ], %g3
2022484: c4 08 60 07 ldub [ %g1 + 7 ], %g2
2022488: 87 28 e0 08 sll %g3, 8, %g3
202248c: 82 10 c0 02 or %g3, %g2, %g1
buf->st_uid = rtems_rfs_inode_get_uid (&inode);
buf->st_gid = rtems_rfs_inode_get_gid (&inode);
2022490: 90 07 bf d8 add %fp, -40, %o0
2022494: 7f ff fc 91 call 20216d8 <rtems_rfs_inode_get_gid>
2022498: c2 36 60 12 sth %g1, [ %i1 + 0x12 ]
/*
* 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));
202249c: d2 07 bf e0 ld [ %fp + -32 ], %o1
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);
buf->st_gid = rtems_rfs_inode_get_gid (&inode);
20224a0: d0 36 60 14 sth %o0, [ %i1 + 0x14 ]
/*
* 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));
20224a4: 40 00 5d 73 call 2039a70 <rtems_rfs_file_get_shared>
20224a8: 90 10 00 1d mov %i5, %o0
if (shared)
20224ac: 92 92 20 00 orcc %o0, 0, %o1
20224b0: 02 80 00 17 be 202250c <rtems_rfs_rtems_fstat+0x174>
20224b4: c2 07 bf e4 ld [ %fp + -28 ], %g1
{
buf->st_atime = rtems_rfs_file_shared_get_atime (shared);
20224b8: c2 02 60 8c ld [ %o1 + 0x8c ], %g1
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))
20224bc: c4 06 60 0c ld [ %i1 + 0xc ], %g2
*/
shared = rtems_rfs_file_get_shared (fs, rtems_rfs_inode_ino (&inode));
if (shared)
{
buf->st_atime = rtems_rfs_file_shared_get_atime (shared);
20224c0: c2 26 60 28 st %g1, [ %i1 + 0x28 ]
buf->st_mtime = rtems_rfs_file_shared_get_mtime (shared);
20224c4: c2 02 60 90 ld [ %o1 + 0x90 ], %g1
20224c8: c2 26 60 30 st %g1, [ %i1 + 0x30 ]
buf->st_ctime = rtems_rfs_file_shared_get_ctime (shared);
20224cc: c2 02 60 94 ld [ %o1 + 0x94 ], %g1
20224d0: c2 26 60 38 st %g1, [ %i1 + 0x38 ]
buf->st_blocks = rtems_rfs_file_shared_get_block_count (shared);
20224d4: c2 02 60 84 ld [ %o1 + 0x84 ], %g1
20224d8: c2 26 60 44 st %g1, [ %i1 + 0x44 ]
if (S_ISLNK (buf->st_mode))
20224dc: 03 00 00 3c sethi %hi(0xf000), %g1
20224e0: 84 08 80 01 and %g2, %g1, %g2
20224e4: 03 00 00 28 sethi %hi(0xa000), %g1
20224e8: 80 a0 80 01 cmp %g2, %g1
20224ec: 12 80 00 04 bne 20224fc <rtems_rfs_rtems_fstat+0x164> <== ALWAYS TAKEN
20224f0: 90 10 00 1d mov %i5, %o0
buf->st_size = rtems_rfs_file_shared_get_block_offset (shared);
20224f4: 10 80 00 3d b 20225e8 <rtems_rfs_rtems_fstat+0x250> <== NOT EXECUTED
20224f8: c2 12 60 8a lduh [ %o1 + 0x8a ], %g1 <== 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);
20224fc: 40 00 50 19 call 2036560 <rtems_rfs_block_get_size>
2022500: 92 02 60 84 add %o1, 0x84, %o1
buf->st_blocks = rtems_rfs_inode_get_block_count (&inode);
if (S_ISLNK (buf->st_mode))
buf->st_size = rtems_rfs_inode_get_block_offset (&inode);
else
buf->st_size = rtems_rfs_inode_get_size (fs, &inode);
2022504: 10 80 00 3f b 2022600 <rtems_rfs_rtems_fstat+0x268>
2022508: d0 3e 60 20 std %o0, [ %i1 + 0x20 ]
* @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);
202250c: c6 08 60 10 ldub [ %g1 + 0x10 ], %g3
2022510: c4 08 60 11 ldub [ %g1 + 0x11 ], %g2
2022514: 87 28 e0 18 sll %g3, 0x18, %g3
2022518: 85 28 a0 10 sll %g2, 0x10, %g2
202251c: 84 10 c0 02 or %g3, %g2, %g2
2022520: c6 08 60 13 ldub [ %g1 + 0x13 ], %g3
2022524: 84 10 80 03 or %g2, %g3, %g2
2022528: c6 08 60 12 ldub [ %g1 + 0x12 ], %g3
202252c: 87 28 e0 08 sll %g3, 8, %g3
2022530: 84 10 80 03 or %g2, %g3, %g2
else
buf->st_size = rtems_rfs_file_shared_get_size (fs, shared);
}
else
{
buf->st_atime = rtems_rfs_inode_get_atime (&inode);
2022534: c4 26 60 28 st %g2, [ %i1 + 0x28 ]
* @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);
2022538: c6 08 60 14 ldub [ %g1 + 0x14 ], %g3
202253c: c4 08 60 15 ldub [ %g1 + 0x15 ], %g2
2022540: 87 28 e0 18 sll %g3, 0x18, %g3
2022544: 85 28 a0 10 sll %g2, 0x10, %g2
2022548: 84 10 c0 02 or %g3, %g2, %g2
202254c: c6 08 60 17 ldub [ %g1 + 0x17 ], %g3
2022550: 84 10 80 03 or %g2, %g3, %g2
2022554: c6 08 60 16 ldub [ %g1 + 0x16 ], %g3
2022558: 87 28 e0 08 sll %g3, 8, %g3
202255c: 84 10 80 03 or %g2, %g3, %g2
buf->st_mtime = rtems_rfs_inode_get_mtime (&inode);
2022560: c4 26 60 30 st %g2, [ %i1 + 0x30 ]
* @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);
2022564: c6 08 60 18 ldub [ %g1 + 0x18 ], %g3
2022568: c4 08 60 19 ldub [ %g1 + 0x19 ], %g2
202256c: 87 28 e0 18 sll %g3, 0x18, %g3
2022570: 85 28 a0 10 sll %g2, 0x10, %g2
2022574: 84 10 c0 02 or %g3, %g2, %g2
2022578: c6 08 60 1b ldub [ %g1 + 0x1b ], %g3
202257c: 84 10 80 03 or %g2, %g3, %g2
2022580: c6 08 60 1a ldub [ %g1 + 0x1a ], %g3
2022584: 87 28 e0 08 sll %g3, 8, %g3
2022588: 84 10 80 03 or %g2, %g3, %g2
buf->st_ctime = rtems_rfs_inode_get_ctime (&inode);
202258c: c4 26 60 38 st %g2, [ %i1 + 0x38 ]
* @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);
2022590: c6 08 60 0c ldub [ %g1 + 0xc ], %g3
2022594: c4 08 60 0d ldub [ %g1 + 0xd ], %g2
2022598: 87 28 e0 18 sll %g3, 0x18, %g3
202259c: 85 28 a0 10 sll %g2, 0x10, %g2
20225a0: 84 10 c0 02 or %g3, %g2, %g2
20225a4: c6 08 60 0f ldub [ %g1 + 0xf ], %g3
20225a8: 84 10 80 03 or %g2, %g3, %g2
20225ac: c6 08 60 0e ldub [ %g1 + 0xe ], %g3
20225b0: 87 28 e0 08 sll %g3, 8, %g3
20225b4: 84 10 80 03 or %g2, %g3, %g2
buf->st_blocks = rtems_rfs_inode_get_block_count (&inode);
if (S_ISLNK (buf->st_mode))
20225b8: c6 06 60 0c ld [ %i1 + 0xc ], %g3
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);
20225bc: c4 26 60 44 st %g2, [ %i1 + 0x44 ]
if (S_ISLNK (buf->st_mode))
20225c0: 05 00 00 3c sethi %hi(0xf000), %g2
20225c4: 86 08 c0 02 and %g3, %g2, %g3
20225c8: 05 00 00 28 sethi %hi(0xa000), %g2
20225cc: 80 a0 c0 02 cmp %g3, %g2
20225d0: 12 80 00 09 bne 20225f4 <rtems_rfs_rtems_fstat+0x25c>
20225d4: 90 10 00 1d mov %i5, %o0
* @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);
20225d8: c4 08 60 0a ldub [ %g1 + 0xa ], %g2
buf->st_size = rtems_rfs_inode_get_block_offset (&inode);
20225dc: c2 08 60 0b ldub [ %g1 + 0xb ], %g1
20225e0: 85 28 a0 08 sll %g2, 8, %g2
20225e4: 82 10 40 02 or %g1, %g2, %g1
20225e8: c0 26 60 20 clr [ %i1 + 0x20 ]
20225ec: 10 80 00 05 b 2022600 <rtems_rfs_rtems_fstat+0x268>
20225f0: c2 26 60 24 st %g1, [ %i1 + 0x24 ]
else
buf->st_size = rtems_rfs_inode_get_size (fs, &inode);
20225f4: 40 00 67 85 call 203c408 <rtems_rfs_inode_get_size>
20225f8: 92 07 bf d8 add %fp, -40, %o1
20225fc: d0 3e 60 20 std %o0, [ %i1 + 0x20 ]
}
buf->st_blksize = rtems_rfs_fs_block_size (fs);
2022600: c2 07 60 08 ld [ %i5 + 8 ], %g1
rc = rtems_rfs_inode_close (fs, &inode);
2022604: 90 10 00 1d mov %i5, %o0
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);
2022608: c2 26 60 40 st %g1, [ %i1 + 0x40 ]
rc = rtems_rfs_inode_close (fs, &inode);
202260c: 92 07 bf d8 add %fp, -40, %o1
2022610: 40 00 65 d6 call 203bd68 <rtems_rfs_inode_close>
2022614: b0 10 20 00 clr %i0
if (rc > 0)
2022618: 80 a2 20 00 cmp %o0, 0
202261c: 04 80 00 05 ble 2022630 <rtems_rfs_rtems_fstat+0x298> <== ALWAYS TAKEN
2022620: ba 10 00 08 mov %o0, %i5
{
return rtems_rfs_rtems_error ("stat: closing inode", rc);
2022624: 40 00 7e f2 call 20421ec <__errno> <== NOT EXECUTED
2022628: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
202262c: fa 22 00 00 st %i5, [ %o0 ] <== NOT EXECUTED
}
return 0;
}
2022630: 81 c7 e0 08 ret
2022634: 81 e8 00 00 restore
02021e90 <rtems_rfs_rtems_initialise>:
*/
int
rtems_rfs_rtems_initialise (rtems_filesystem_mount_table_entry_t* mt_entry,
const void* data)
{
2021e90: 9d e3 bf 98 save %sp, -104, %sp
/*
* Parse the options the user specifiies.
*/
while (options)
{
printf ("options=%s\n", options);
2021e94: 3b 00 81 8a sethi %hi(0x2062800), %i5
if (strncmp (options, "hold-bitmaps",
2021e98: 35 00 81 8a sethi %hi(0x2062800), %i2
sizeof ("hold-bitmaps") - 1) == 0)
flags |= RTEMS_RFS_FS_BITMAPS_HOLD;
else if (strncmp (options, "no-local-cache",
2021e9c: 21 00 81 8a sethi %hi(0x2062800), %l0
sizeof ("no-local-cache") - 1) == 0)
flags |= RTEMS_RFS_FS_NO_LOCAL_CACHE;
else if (strncmp (options, "max-held-bufs",
2021ea0: 23 00 81 8a sethi %hi(0x2062800), %l1
const void* data)
{
rtems_rfs_rtems_private* rtems;
rtems_rfs_file_system* fs;
uint32_t flags = 0;
uint32_t max_held_buffers = RTEMS_RFS_FS_MAX_HELD_BUFFERS;
2021ea4: b6 10 20 05 mov 5, %i3
rtems_rfs_rtems_initialise (rtems_filesystem_mount_table_entry_t* mt_entry,
const void* data)
{
rtems_rfs_rtems_private* rtems;
rtems_rfs_file_system* fs;
uint32_t flags = 0;
2021ea8: b8 10 20 00 clr %i4
/*
* Parse the options the user specifiies.
*/
while (options)
{
printf ("options=%s\n", options);
2021eac: ba 17 62 78 or %i5, 0x278, %i5
if (strncmp (options, "hold-bitmaps",
2021eb0: b4 16 a2 88 or %i2, 0x288, %i2
sizeof ("hold-bitmaps") - 1) == 0)
flags |= RTEMS_RFS_FS_BITMAPS_HOLD;
else if (strncmp (options, "no-local-cache",
2021eb4: a0 14 22 98 or %l0, 0x298, %l0
int rc;
/*
* Parse the options the user specifiies.
*/
while (options)
2021eb8: 10 80 00 2f b 2021f74 <rtems_rfs_rtems_initialise+0xe4>
2021ebc: a2 14 62 a8 or %l1, 0x2a8, %l1
{
printf ("options=%s\n", options);
2021ec0: 40 00 93 0a call 2046ae8 <printf> <== NOT EXECUTED
2021ec4: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
if (strncmp (options, "hold-bitmaps",
2021ec8: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
2021ecc: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED
2021ed0: 40 00 9d 12 call 2049318 <strncmp> <== NOT EXECUTED
2021ed4: 94 10 20 0c mov 0xc, %o2 <== NOT EXECUTED
2021ed8: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2021edc: 12 80 00 04 bne 2021eec <rtems_rfs_rtems_initialise+0x5c> <== NOT EXECUTED
2021ee0: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
sizeof ("hold-bitmaps") - 1) == 0)
flags |= RTEMS_RFS_FS_BITMAPS_HOLD;
2021ee4: 10 80 00 1a b 2021f4c <rtems_rfs_rtems_initialise+0xbc> <== NOT EXECUTED
2021ee8: b8 17 20 01 or %i4, 1, %i4 <== NOT EXECUTED
else if (strncmp (options, "no-local-cache",
2021eec: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED
2021ef0: 40 00 9d 0a call 2049318 <strncmp> <== NOT EXECUTED
2021ef4: 94 10 20 0e mov 0xe, %o2 <== NOT EXECUTED
2021ef8: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2021efc: 12 80 00 04 bne 2021f0c <rtems_rfs_rtems_initialise+0x7c> <== NOT EXECUTED
2021f00: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
sizeof ("no-local-cache") - 1) == 0)
flags |= RTEMS_RFS_FS_NO_LOCAL_CACHE;
2021f04: 10 80 00 12 b 2021f4c <rtems_rfs_rtems_initialise+0xbc> <== NOT EXECUTED
2021f08: b8 17 20 02 or %i4, 2, %i4 <== NOT EXECUTED
else if (strncmp (options, "max-held-bufs",
2021f0c: 92 10 00 11 mov %l1, %o1 <== NOT EXECUTED
2021f10: 40 00 9d 02 call 2049318 <strncmp> <== NOT EXECUTED
2021f14: 94 10 20 0d mov 0xd, %o2 <== NOT EXECUTED
2021f18: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2021f1c: 12 80 00 07 bne 2021f38 <rtems_rfs_rtems_initialise+0xa8> <== NOT EXECUTED
2021f20: 92 10 20 00 clr %o1 <== NOT EXECUTED
sizeof ("max-held-bufs") - 1) == 0)
{
max_held_buffers = strtoul (options + sizeof ("max-held-bufs"), 0, 0);
2021f24: 90 06 60 0e add %i1, 0xe, %o0 <== NOT EXECUTED
2021f28: 40 00 a2 eb call 204aad4 <strtoul> <== NOT EXECUTED
2021f2c: 94 10 20 00 clr %o2 <== NOT EXECUTED
2021f30: 10 80 00 06 b 2021f48 <rtems_rfs_rtems_initialise+0xb8> <== NOT EXECUTED
2021f34: b6 10 00 08 mov %o0, %i3 <== NOT EXECUTED
}
else
return rtems_rfs_rtems_error ("initialise: invalid option", EINVAL);
2021f38: 40 00 80 ad call 20421ec <__errno> <== NOT EXECUTED
2021f3c: 01 00 00 00 nop <== NOT EXECUTED
2021f40: 10 80 00 18 b 2021fa0 <rtems_rfs_rtems_initialise+0x110> <== NOT EXECUTED
2021f44: 82 10 20 16 mov 0x16, %g1 ! 16 <PROM_START+0x16> <== NOT EXECUTED
options = strchr (options, ',');
2021f48: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
2021f4c: 40 00 9a 23 call 20487d8 <strchr> <== NOT EXECUTED
2021f50: 92 10 20 2c mov 0x2c, %o1 <== NOT EXECUTED
if (options)
2021f54: b2 92 20 00 orcc %o0, 0, %i1 <== NOT EXECUTED
2021f58: 02 80 00 0a be 2021f80 <rtems_rfs_rtems_initialise+0xf0> <== NOT EXECUTED
2021f5c: 01 00 00 00 nop <== NOT EXECUTED
{
++options;
if (*options == '\0')
2021f60: c2 4e 60 01 ldsb [ %i1 + 1 ], %g1 <== NOT EXECUTED
2021f64: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
2021f68: 02 80 00 06 be 2021f80 <rtems_rfs_rtems_initialise+0xf0> <== NOT EXECUTED
2021f6c: 01 00 00 00 nop <== NOT EXECUTED
return rtems_rfs_rtems_error ("initialise: invalid option", EINVAL);
options = strchr (options, ',');
if (options)
{
++options;
2021f70: b2 06 60 01 inc %i1 <== NOT EXECUTED
int rc;
/*
* Parse the options the user specifiies.
*/
while (options)
2021f74: 80 a6 60 00 cmp %i1, 0
2021f78: 12 bf ff d2 bne 2021ec0 <rtems_rfs_rtems_initialise+0x30> <== NEVER TAKEN
2021f7c: 92 10 00 19 mov %i1, %o1
if (*options == '\0')
options = NULL;
}
}
rtems = malloc (sizeof (rtems_rfs_rtems_private));
2021f80: 7f ff 9c 7d call 2009174 <malloc>
2021f84: 90 10 20 04 mov 4, %o0
if (!rtems)
2021f88: ba 92 20 00 orcc %o0, 0, %i5
2021f8c: 12 80 00 08 bne 2021fac <rtems_rfs_rtems_initialise+0x11c><== ALWAYS TAKEN
2021f90: 01 00 00 00 nop
return rtems_rfs_rtems_error ("initialise: local data", ENOMEM);
2021f94: 40 00 80 96 call 20421ec <__errno> <== NOT EXECUTED
2021f98: 01 00 00 00 nop <== NOT EXECUTED
2021f9c: 82 10 20 0c mov 0xc, %g1 ! c <PROM_START+0xc> <== NOT EXECUTED
2021fa0: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
2021fa4: 81 c7 e0 08 ret <== NOT EXECUTED
2021fa8: 91 e8 3f ff restore %g0, -1, %o0 <== NOT EXECUTED
memset (rtems, 0, sizeof (rtems_rfs_rtems_private));
rc = rtems_rfs_mutex_create (&rtems->access);
2021fac: 40 00 6b 9d call 203ce20 <rtems_rfs_mutex_create>
2021fb0: c0 27 40 00 clr [ %i5 ]
if (rc > 0)
2021fb4: b4 92 20 00 orcc %o0, 0, %i2
2021fb8: 14 80 00 09 bg 2021fdc <rtems_rfs_rtems_initialise+0x14c> <== NEVER TAKEN
2021fbc: 01 00 00 00 nop
{
free (rtems);
return rtems_rfs_rtems_error ("initialise: cannot create mutex", rc);
}
rc = rtems_rfs_mutex_lock (&rtems->access);
2021fc0: 7f ff ff 96 call 2021e18 <rtems_rfs_mutex_lock.isra.3>
2021fc4: d0 07 40 00 ld [ %i5 ], %o0
if (rc > 0)
2021fc8: b4 92 20 00 orcc %o0, 0, %i2
2021fcc: 24 80 00 0b ble,a 2021ff8 <rtems_rfs_rtems_initialise+0x168><== ALWAYS TAKEN
2021fd0: d0 06 20 38 ld [ %i0 + 0x38 ], %o0
{
rtems_rfs_mutex_destroy (&rtems->access);
2021fd4: 40 00 6b ae call 203ce8c <rtems_rfs_mutex_destroy> <== NOT EXECUTED
2021fd8: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
free (rtems);
2021fdc: 7f ff 9b 08 call 2008bfc <free> <== NOT EXECUTED
2021fe0: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
return rtems_rfs_rtems_error ("initialise: cannot lock access mutex", rc);
2021fe4: 40 00 80 82 call 20421ec <__errno> <== NOT EXECUTED
2021fe8: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
2021fec: f4 22 00 00 st %i2, [ %o0 ] <== NOT EXECUTED
2021ff0: 81 c7 e0 08 ret <== NOT EXECUTED
2021ff4: 81 e8 00 00 restore <== NOT EXECUTED
}
rc = rtems_rfs_fs_open (mt_entry->dev, rtems, flags, max_held_buffers, &fs);
2021ff8: 94 10 00 1c mov %i4, %o2
2021ffc: 92 10 00 1d mov %i5, %o1
2022000: 96 10 00 1b mov %i3, %o3
2022004: 40 00 5f 7d call 2039df8 <rtems_rfs_fs_open>
2022008: 98 07 bf fc add %fp, -4, %o4
if (rc)
202200c: b8 92 20 00 orcc %o0, 0, %i4
2022010: 02 80 00 09 be 2022034 <rtems_rfs_rtems_initialise+0x1a4> <== ALWAYS TAKEN
2022014: d0 07 bf fc ld [ %fp + -4 ], %o0
{
free (rtems);
2022018: 7f ff 9a f9 call 2008bfc <free> <== NOT EXECUTED
202201c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
return rtems_rfs_rtems_error ("initialise: open", rc);
2022020: 40 00 80 73 call 20421ec <__errno> <== NOT EXECUTED
2022024: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
2022028: f8 22 00 00 st %i4, [ %o0 ] <== NOT EXECUTED
202202c: 81 c7 e0 08 ret <== NOT EXECUTED
2022030: 81 e8 00 00 restore <== NOT EXECUTED
}
mt_entry->fs_info = fs;
mt_entry->ops = &rtems_rfs_ops;
2022034: 03 00 81 8a sethi %hi(0x2062800), %g1
2022038: 82 10 62 b8 or %g1, 0x2b8, %g1 ! 2062ab8 <rtems_rfs_ops>
202203c: c2 26 20 0c st %g1, [ %i0 + 0xc ]
mt_entry->mt_fs_root->location.node_access = (void*) RTEMS_RFS_ROOT_INO;
2022040: c2 06 20 24 ld [ %i0 + 0x24 ], %g1
{
free (rtems);
return rtems_rfs_rtems_error ("initialise: open", rc);
}
mt_entry->fs_info = fs;
2022044: d0 26 20 08 st %o0, [ %i0 + 8 ]
mt_entry->ops = &rtems_rfs_ops;
mt_entry->mt_fs_root->location.node_access = (void*) RTEMS_RFS_ROOT_INO;
2022048: 84 10 20 01 mov 1, %g2
* Unlock the RFS file system.
*/
static inline void
rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
202204c: fa 02 20 80 ld [ %o0 + 0x80 ], %i5
2022050: c4 20 60 08 st %g2, [ %g1 + 8 ]
mt_entry->mt_fs_root->location.handlers = &rtems_rfs_rtems_dir_handlers;
2022054: 05 00 81 a5 sethi %hi(0x2069400), %g2
2022058: 84 10 a0 40 or %g2, 0x40, %g2 ! 2069440 <rtems_rfs_rtems_dir_handlers>
rtems_rfs_buffers_release (fs);
202205c: 40 00 56 6a call 2037a04 <rtems_rfs_buffers_release>
2022060: c4 20 60 10 st %g2, [ %g1 + 0x10 ]
rtems_rfs_mutex_unlock (&rtems->access);
2022064: d0 07 40 00 ld [ %i5 ], %o0
2022068: 7f ff ff 56 call 2021dc0 <rtems_rfs_mutex_unlock.isra.2>
202206c: b0 10 20 00 clr %i0
rtems_rfs_rtems_unlock (fs);
return 0;
}
2022070: 81 c7 e0 08 ret
2022074: 81 e8 00 00 restore
0202181c <rtems_rfs_rtems_link>:
static int
rtems_rfs_rtems_link (const rtems_filesystem_location_info_t *parentloc,
const rtems_filesystem_location_info_t *targetloc,
const char *name,
size_t namelen)
{
202181c: 9d e3 bf a0 save %sp, -96, %sp
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (targetloc);
2021820: c2 06 60 14 ld [ %i1 + 0x14 ], %g1
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_LINK))
printf ("rtems-rfs-rtems: link: in: parent:%" PRId32 " target:%" PRId32 "\n",
parent, target);
rc = rtems_rfs_link (fs, name, namelen, parent, target, false);
2021824: d6 06 20 08 ld [ %i0 + 8 ], %o3
2021828: d0 00 60 08 ld [ %g1 + 8 ], %o0
202182c: d8 06 60 08 ld [ %i1 + 8 ], %o4
2021830: 92 10 00 1a mov %i2, %o1
2021834: 94 10 00 1b mov %i3, %o2
2021838: 9a 10 20 00 clr %o5
202183c: 40 00 6b 1a call 203c4a4 <rtems_rfs_link>
2021840: b0 10 20 00 clr %i0
if (rc)
2021844: 80 a2 20 00 cmp %o0, 0
2021848: 02 80 00 05 be 202185c <rtems_rfs_rtems_link+0x40> <== ALWAYS TAKEN
202184c: ba 10 00 08 mov %o0, %i5
{
return rtems_rfs_rtems_error ("link: linking", rc);
2021850: 40 00 82 67 call 20421ec <__errno> <== NOT EXECUTED
2021854: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
2021858: fa 22 00 00 st %i5, [ %o0 ] <== NOT EXECUTED
}
return 0;
}
202185c: 81 c7 e0 08 ret
2021860: 81 e8 00 00 restore
02022894 <rtems_rfs_rtems_lock>:
/**
* Lock the RFS file system.
*/
static inline void
rtems_rfs_rtems_lock (rtems_rfs_file_system* fs)
{
2022894: 9d e3 bf a0 save %sp, -96, %sp
driver, strerror (errno));
return 1;
}
return 0;
}
2022898: c2 06 20 80 ld [ %i0 + 0x80 ], %g1
*/
static inline int
rtems_rfs_mutex_lock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
202289c: 92 10 20 00 clr %o1
20228a0: d0 00 40 00 ld [ %g1 ], %o0
20228a4: 7f ff ab 04 call 200d4b4 <rtems_semaphore_obtain>
20228a8: 94 10 20 00 clr %o2
if (sc != RTEMS_SUCCESSFUL)
20228ac: ba 92 20 00 orcc %o0, 0, %i5
20228b0: 02 80 00 0c be 20228e0 <rtems_rfs_rtems_lock+0x4c> <== ALWAYS TAKEN
20228b4: 90 10 20 00 clr %o0
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
20228b8: 40 00 04 65 call 2023a4c <rtems_rfs_trace> <== NOT EXECUTED
20228bc: 92 10 20 04 mov 4, %o1 <== NOT EXECUTED
20228c0: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
20228c4: 02 80 00 07 be 20228e0 <rtems_rfs_rtems_lock+0x4c> <== NOT EXECUTED
20228c8: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
printf ("rtems-rfs: mutex: obtain failed: %s\n",
20228cc: 7f ff 98 2f call 2008988 <rtems_status_text> <== NOT EXECUTED
20228d0: 31 00 81 8a sethi %hi(0x2062800), %i0 <== NOT EXECUTED
20228d4: b0 16 22 50 or %i0, 0x250, %i0 ! 2062a50 <rtems_nvdisk_sram_handlers+0x34><== NOT EXECUTED
20228d8: 40 00 90 84 call 2046ae8 <printf> <== NOT EXECUTED
20228dc: 93 e8 00 08 restore %g0, %o0, %o1 <== NOT EXECUTED
20228e0: 81 c7 e0 08 ret
20228e4: 81 e8 00 00 restore
02021b68 <rtems_rfs_rtems_mknod>:
rtems_rfs_rtems_mknod (const rtems_filesystem_location_info_t *parentloc,
const char *name,
size_t namelen,
mode_t mode,
dev_t dev)
{
2021b68: 9d e3 bf 60 save %sp, -160, %sp
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (parentloc);
2021b6c: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
rtems_rfs_ino parent = rtems_rfs_rtems_get_pathloc_ino (parentloc);
2021b70: f0 06 20 08 ld [ %i0 + 8 ], %i0
uid_t uid;
gid_t gid;
int rc;
#if defined(RTEMS_POSIX_API)
uid = geteuid ();
2021b74: 40 00 19 59 call 20280d8 <geteuid>
2021b78: e0 00 60 08 ld [ %g1 + 8 ], %l0
gid = getegid ();
2021b7c: 40 00 19 53 call 20280c8 <getegid>
2021b80: a4 10 00 08 mov %o0, %l2
2021b84: a2 10 00 08 mov %o0, %l1
#else
uid = 0;
gid = 0;
#endif
rc = rtems_rfs_inode_create (fs, parent, name, namelen,
2021b88: 40 00 03 2e call 2022840 <rtems_rfs_rtems_imode>
2021b8c: 90 10 00 1b mov %i3, %o0
2021b90: 82 07 bf d4 add %fp, -44, %g1
2021b94: 99 2a 20 10 sll %o0, 0x10, %o4
2021b98: 96 10 00 1a mov %i2, %o3
2021b9c: a5 2c a0 10 sll %l2, 0x10, %l2
2021ba0: a3 2c 60 10 sll %l1, 0x10, %l1
2021ba4: a5 34 a0 10 srl %l2, 0x10, %l2
2021ba8: a3 34 60 10 srl %l1, 0x10, %l1
2021bac: e4 23 a0 5c st %l2, [ %sp + 0x5c ]
2021bb0: e2 23 a0 60 st %l1, [ %sp + 0x60 ]
2021bb4: c2 23 a0 64 st %g1, [ %sp + 0x64 ]
2021bb8: 90 10 00 10 mov %l0, %o0
2021bbc: 92 10 00 18 mov %i0, %o1
2021bc0: 94 10 00 19 mov %i1, %o2
2021bc4: 99 33 20 10 srl %o4, 0x10, %o4
2021bc8: 40 00 69 3d call 203c0bc <rtems_rfs_inode_create>
2021bcc: 9a 10 20 01 mov 1, %o5
rtems_rfs_rtems_imode (mode),
1, uid, gid, &ino);
if (rc > 0)
2021bd0: b4 92 20 00 orcc %o0, 0, %i2
2021bd4: 14 80 00 09 bg 2021bf8 <rtems_rfs_rtems_mknod+0x90>
2021bd8: d2 07 bf d4 ld [ %fp + -44 ], %o1
{
return rtems_rfs_rtems_error ("mknod: inode create", rc);
}
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
2021bdc: 90 10 00 10 mov %l0, %o0
2021be0: 94 07 bf d8 add %fp, -40, %o2
2021be4: 40 00 67 ef call 203bba0 <rtems_rfs_inode_open>
2021be8: 96 10 20 01 mov 1, %o3
if (rc > 0)
2021bec: b4 92 20 00 orcc %o0, 0, %i2
2021bf0: 04 80 00 07 ble 2021c0c <rtems_rfs_rtems_mknod+0xa4> <== ALWAYS TAKEN
2021bf4: 03 00 00 3c sethi %hi(0xf000), %g1
{
return rtems_rfs_rtems_error ("mknod: inode open", rc);
2021bf8: 40 00 81 7d call 20421ec <__errno>
2021bfc: b0 10 3f ff mov -1, %i0
2021c00: f4 22 00 00 st %i2, [ %o0 ]
2021c04: 81 c7 e0 08 ret
2021c08: 81 e8 00 00 restore
}
if (S_ISDIR(mode) || S_ISREG(mode))
2021c0c: 05 00 00 20 sethi %hi(0x8000), %g2
2021c10: 82 0e c0 01 and %i3, %g1, %g1
2021c14: 80 a0 40 02 cmp %g1, %g2
2021c18: 02 80 00 1c be 2021c88 <rtems_rfs_rtems_mknod+0x120>
2021c1c: 05 00 00 10 sethi %hi(0x4000), %g2
2021c20: 80 a0 40 02 cmp %g1, %g2
2021c24: 02 80 00 19 be 2021c88 <rtems_rfs_rtems_mknod+0x120> <== ALWAYS TAKEN
2021c28: 03 00 00 2c sethi %hi(0xb000), %g1
{
}
else if (S_ISCHR (mode) || S_ISBLK (mode))
2021c2c: b6 0e c0 01 and %i3, %g1, %i3 <== NOT EXECUTED
2021c30: 03 00 00 08 sethi %hi(0x2000), %g1 <== NOT EXECUTED
2021c34: 80 a6 c0 01 cmp %i3, %g1 <== NOT EXECUTED
2021c38: 12 80 00 0b bne 2021c64 <rtems_rfs_rtems_mknod+0xfc> <== NOT EXECUTED
2021c3c: 90 07 bf d8 add %fp, -40, %o0 <== NOT EXECUTED
{
int major;
int minor;
rtems_filesystem_split_dev_t (dev, major, minor);
rtems_rfs_inode_set_block (&inode, 0, major);
2021c40: 94 10 00 1c mov %i4, %o2 <== NOT EXECUTED
2021c44: 7f ff fe bd call 2021738 <rtems_rfs_inode_set_block> <== NOT EXECUTED
2021c48: 92 10 20 00 clr %o1 <== NOT EXECUTED
rtems_rfs_inode_set_block (&inode, 1, minor);
2021c4c: 90 07 bf d8 add %fp, -40, %o0 <== NOT EXECUTED
2021c50: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
2021c54: 7f ff fe b9 call 2021738 <rtems_rfs_inode_set_block> <== NOT EXECUTED
2021c58: 94 10 00 1d mov %i5, %o2 <== NOT EXECUTED
{
rtems_rfs_inode_close (fs, &inode);
return rtems_rfs_rtems_error ("mknod: bad mode", EINVAL);
}
rc = rtems_rfs_inode_close (fs, &inode);
2021c5c: 10 80 00 0c b 2021c8c <rtems_rfs_rtems_mknod+0x124> <== NOT EXECUTED
2021c60: 90 10 00 10 mov %l0, %o0 <== 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);
2021c64: 92 07 bf d8 add %fp, -40, %o1 <== NOT EXECUTED
2021c68: 40 00 68 40 call 203bd68 <rtems_rfs_inode_close> <== NOT EXECUTED
2021c6c: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
return rtems_rfs_rtems_error ("mknod: bad mode", EINVAL);
2021c70: 40 00 81 5f call 20421ec <__errno> <== NOT EXECUTED
2021c74: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
2021c78: 82 10 20 16 mov 0x16, %g1 <== NOT EXECUTED
2021c7c: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
2021c80: 81 c7 e0 08 ret <== NOT EXECUTED
2021c84: 81 e8 00 00 restore <== NOT EXECUTED
}
rc = rtems_rfs_inode_close (fs, &inode);
2021c88: 90 10 00 10 mov %l0, %o0
2021c8c: 92 07 bf d8 add %fp, -40, %o1
2021c90: 40 00 68 36 call 203bd68 <rtems_rfs_inode_close>
2021c94: b0 10 20 00 clr %i0
if (rc > 0)
2021c98: 80 a2 20 00 cmp %o0, 0
2021c9c: 04 80 00 05 ble 2021cb0 <rtems_rfs_rtems_mknod+0x148> <== ALWAYS TAKEN
2021ca0: ba 10 00 08 mov %o0, %i5
{
return rtems_rfs_rtems_error ("mknod: closing inode", rc);
2021ca4: 40 00 81 52 call 20421ec <__errno> <== NOT EXECUTED
2021ca8: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
2021cac: fa 22 00 00 st %i5, [ %o0 ] <== NOT EXECUTED
}
return 0;
}
2021cb0: 81 c7 e0 08 ret
2021cb4: 81 e8 00 00 restore
020220fc <rtems_rfs_rtems_node_type>:
* @return rtems_filesystem_node_types_t
*/
static rtems_filesystem_node_types_t
rtems_rfs_rtems_node_type (const rtems_filesystem_location_info_t* pathloc)
{
20220fc: 9d e3 bf 78 save %sp, -136, %sp
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
2022100: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
rtems_rfs_ino ino = rtems_rfs_rtems_get_pathloc_ino (pathloc);
rtems_filesystem_node_types_t type;
rtems_rfs_inode_handle inode;
int rc;
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
2022104: d2 06 20 08 ld [ %i0 + 8 ], %o1
*/
static rtems_filesystem_node_types_t
rtems_rfs_rtems_node_type (const rtems_filesystem_location_info_t* pathloc)
{
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
2022108: fa 00 60 08 ld [ %g1 + 8 ], %i5
rtems_rfs_ino ino = rtems_rfs_rtems_get_pathloc_ino (pathloc);
rtems_filesystem_node_types_t type;
rtems_rfs_inode_handle inode;
int rc;
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
202210c: 94 07 bf d8 add %fp, -40, %o2
2022110: 90 10 00 1d mov %i5, %o0
2022114: 40 00 66 a3 call 203bba0 <rtems_rfs_inode_open>
2022118: 96 10 20 01 mov 1, %o3
if (rc > 0)
202211c: b8 92 20 00 orcc %o0, 0, %i4
2022120: 04 80 00 07 ble 202213c <rtems_rfs_rtems_node_type+0x40> <== ALWAYS TAKEN
2022124: 01 00 00 00 nop
{
return rtems_rfs_rtems_error ("node_type: opening inode", rc);
2022128: 40 00 80 31 call 20421ec <__errno> <== NOT EXECUTED
202212c: b0 10 3f ff mov -1, %i0 ! ffffffff <RAM_END+0xfdbfffff> <== NOT EXECUTED
2022130: f8 22 00 00 st %i4, [ %o0 ] <== NOT EXECUTED
2022134: 81 c7 e0 08 ret <== NOT EXECUTED
2022138: 81 e8 00 00 restore <== NOT EXECUTED
}
type = rtems_rfs_rtems_node_type_by_inode (&inode);
202213c: 7f ff ff cf call 2022078 <rtems_rfs_rtems_node_type_by_inode>
2022140: 90 07 bf d8 add %fp, -40, %o0
rc = rtems_rfs_inode_close (fs, &inode);
2022144: 92 07 bf d8 add %fp, -40, %o1
if (rc > 0)
{
return rtems_rfs_rtems_error ("node_type: opening inode", rc);
}
type = rtems_rfs_rtems_node_type_by_inode (&inode);
2022148: b0 10 00 08 mov %o0, %i0
rc = rtems_rfs_inode_close (fs, &inode);
202214c: 40 00 67 07 call 203bd68 <rtems_rfs_inode_close>
2022150: 90 10 00 1d mov %i5, %o0
if (rc > 0)
2022154: ba 92 20 00 orcc %o0, 0, %i5
2022158: 04 80 00 05 ble 202216c <rtems_rfs_rtems_node_type+0x70> <== ALWAYS TAKEN
202215c: 01 00 00 00 nop
{
return rtems_rfs_rtems_error ("node_type: closing inode", rc);
2022160: 40 00 80 23 call 20421ec <__errno> <== NOT EXECUTED
2022164: b0 10 3f ff mov -1, %i0 ! ffffffff <RAM_END+0xfdbfffff> <== NOT EXECUTED
2022168: fa 22 00 00 st %i5, [ %o0 ] <== NOT EXECUTED
}
return type;
}
202216c: 81 c7 e0 08 ret
2022170: 81 e8 00 00 restore
020218f0 <rtems_rfs_rtems_readlink>:
static ssize_t
rtems_rfs_rtems_readlink (const rtems_filesystem_location_info_t* pathloc,
char* buf,
size_t bufsize)
{
20218f0: 9d e3 bf 98 save %sp, -104, %sp
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
20218f4: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
int rc;
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_READLINK))
printf ("rtems-rfs-rtems: readlink: in: ino:%" PRId32 "\n", ino);
rc = rtems_rfs_symlink_read (fs, ino, buf, bufsize, &length);
20218f8: d2 06 20 08 ld [ %i0 + 8 ], %o1
20218fc: d0 00 60 08 ld [ %g1 + 8 ], %o0
2021900: 94 10 00 19 mov %i1, %o2
2021904: 96 10 00 1a mov %i2, %o3
2021908: 40 00 6c d5 call 203cc5c <rtems_rfs_symlink_read>
202190c: 98 07 bf fc add %fp, -4, %o4
if (rc)
{
return rtems_rfs_rtems_error ("readlink: reading link", rc);
}
return (ssize_t) length;
2021910: f0 07 bf fc ld [ %fp + -4 ], %i0
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_READLINK))
printf ("rtems-rfs-rtems: readlink: in: ino:%" PRId32 "\n", ino);
rc = rtems_rfs_symlink_read (fs, ino, buf, bufsize, &length);
if (rc)
2021914: 80 a2 20 00 cmp %o0, 0
2021918: 02 80 00 05 be 202192c <rtems_rfs_rtems_readlink+0x3c> <== ALWAYS TAKEN
202191c: ba 10 00 08 mov %o0, %i5
{
return rtems_rfs_rtems_error ("readlink: reading link", rc);
2021920: 40 00 82 33 call 20421ec <__errno> <== NOT EXECUTED
2021924: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
2021928: fa 22 00 00 st %i5, [ %o0 ] <== NOT EXECUTED
}
return (ssize_t) length;
}
202192c: 81 c7 e0 08 ret
2021930: 81 e8 00 00 restore
02021864 <rtems_rfs_rtems_rename>:
rtems_rfs_rtems_rename(const rtems_filesystem_location_info_t* old_parent_loc,
const rtems_filesystem_location_info_t* old_loc,
const rtems_filesystem_location_info_t* new_parent_loc,
const char* new_name,
size_t new_name_len)
{
2021864: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (old_loc);
2021868: c2 06 60 14 ld [ %i1 + 0x14 ], %g1 <== 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);
202186c: e0 06 20 08 ld [ %i0 + 8 ], %l0 <== NOT EXECUTED
const rtems_filesystem_location_info_t* old_loc,
const rtems_filesystem_location_info_t* new_parent_loc,
const char* new_name,
size_t new_name_len)
{
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (old_loc);
2021870: fa 00 60 08 ld [ %g1 + 8 ], %i5 <== NOT EXECUTED
int rc;
old_parent = rtems_rfs_rtems_get_pathloc_ino (old_parent_loc);
new_parent = rtems_rfs_rtems_get_pathloc_ino (new_parent_loc);
ino = rtems_rfs_rtems_get_pathloc_ino (old_loc);
2021874: f0 06 60 08 ld [ %i1 + 8 ], %i0 <== NOT EXECUTED
/*
* Link to the inode before unlinking so the inode is not erased when
* unlinked.
*/
rc = rtems_rfs_link (fs, new_name, new_name_len, new_parent, ino, true);
2021878: d6 06 a0 08 ld [ %i2 + 8 ], %o3 <== NOT EXECUTED
202187c: 94 10 00 1c mov %i4, %o2 <== NOT EXECUTED
old_parent = rtems_rfs_rtems_get_pathloc_ino (old_parent_loc);
new_parent = rtems_rfs_rtems_get_pathloc_ino (new_parent_loc);
ino = rtems_rfs_rtems_get_pathloc_ino (old_loc);
doff = rtems_rfs_rtems_get_pathloc_doff (old_loc);
2021880: f2 06 60 0c ld [ %i1 + 0xc ], %i1 <== NOT EXECUTED
/*
* Link to the inode before unlinking so the inode is not erased when
* unlinked.
*/
rc = rtems_rfs_link (fs, new_name, new_name_len, new_parent, ino, true);
2021884: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
2021888: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
202188c: 98 10 00 18 mov %i0, %o4 <== NOT EXECUTED
2021890: 40 00 6b 05 call 203c4a4 <rtems_rfs_link> <== NOT EXECUTED
2021894: 9a 10 20 01 mov 1, %o5 <== NOT EXECUTED
if (rc)
2021898: b8 92 20 00 orcc %o0, 0, %i4 <== NOT EXECUTED
202189c: 02 80 00 07 be 20218b8 <rtems_rfs_rtems_rename+0x54> <== NOT EXECUTED
20218a0: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
{
return rtems_rfs_rtems_error ("rename: linking", rc);
20218a4: 40 00 82 52 call 20421ec <__errno> <== NOT EXECUTED
20218a8: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
20218ac: f8 22 00 00 st %i4, [ %o0 ] <== NOT EXECUTED
20218b0: 81 c7 e0 08 ret <== NOT EXECUTED
20218b4: 81 e8 00 00 restore <== 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,
20218b8: 94 10 00 18 mov %i0, %o2 <== NOT EXECUTED
20218bc: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED
20218c0: 96 10 00 19 mov %i1, %o3 <== NOT EXECUTED
20218c4: 98 10 20 02 mov 2, %o4 <== NOT EXECUTED
20218c8: 40 00 6b 60 call 203c648 <rtems_rfs_unlink> <== NOT EXECUTED
20218cc: b0 10 20 00 clr %i0 <== NOT EXECUTED
rtems_rfs_unlink_dir_allowed);
if (rc)
20218d0: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
20218d4: 02 80 00 05 be 20218e8 <rtems_rfs_rtems_rename+0x84> <== NOT EXECUTED
20218d8: ba 10 00 08 mov %o0, %i5 <== NOT EXECUTED
{
return rtems_rfs_rtems_error ("rename: unlinking", rc);
20218dc: 40 00 82 44 call 20421ec <__errno> <== NOT EXECUTED
20218e0: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
20218e4: fa 22 00 00 st %i5, [ %o0 ] <== NOT EXECUTED
}
return 0;
}
20218e8: 81 c7 e0 08 ret <== NOT EXECUTED
20218ec: 81 e8 00 00 restore <== NOT EXECUTED
02022788 <rtems_rfs_rtems_set_handlers>:
*/
bool
rtems_rfs_rtems_set_handlers (rtems_filesystem_location_info_t* loc,
rtems_rfs_inode_handle* inode)
{
2022788: 9d e3 bf a0 save %sp, -96, %sp
* @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);
202278c: c2 06 60 0c ld [ %i1 + 0xc ], %g1
uint16_t mode = rtems_rfs_inode_get_mode (inode);
loc->handlers = NULL;
if (RTEMS_RFS_S_ISDIR (mode))
2022790: 05 00 00 10 sethi %hi(0x4000), %g2
2022794: d2 08 60 02 ldub [ %g1 + 2 ], %o1
2022798: c2 08 60 03 ldub [ %g1 + 3 ], %g1
202279c: 93 2a 60 08 sll %o1, 8, %o1
20227a0: 92 12 40 01 or %o1, %g1, %o1
20227a4: 03 00 00 3c sethi %hi(0xf000), %g1
20227a8: 82 0a 40 01 and %o1, %g1, %g1
20227ac: 80 a0 40 02 cmp %g1, %g2
20227b0: 12 80 00 05 bne 20227c4 <rtems_rfs_rtems_set_handlers+0x3c>
20227b4: c0 26 20 10 clr [ %i0 + 0x10 ]
loc->handlers = rtems_rfs_rtems_handlers (dir);
20227b8: 03 00 81 a5 sethi %hi(0x2069400), %g1
20227bc: 10 80 00 0a b 20227e4 <rtems_rfs_rtems_set_handlers+0x5c>
20227c0: 82 10 60 40 or %g1, 0x40, %g1 ! 2069440 <rtems_rfs_rtems_dir_handlers>
else if (RTEMS_RFS_S_ISCHR (mode) || RTEMS_RFS_S_ISBLK(mode))
20227c4: 07 00 00 2c sethi %hi(0xb000), %g3
20227c8: 05 00 00 08 sethi %hi(0x2000), %g2
20227cc: 86 0a 40 03 and %o1, %g3, %g3
20227d0: 80 a0 c0 02 cmp %g3, %g2
20227d4: 12 80 00 07 bne 20227f0 <rtems_rfs_rtems_set_handlers+0x68><== ALWAYS TAKEN
20227d8: 05 00 00 28 sethi %hi(0xa000), %g2
loc->handlers = rtems_rfs_rtems_handlers (device);
20227dc: 03 00 81 a5 sethi %hi(0x2069400), %g1 <== NOT EXECUTED
20227e0: 82 10 60 14 or %g1, 0x14, %g1 ! 2069414 <rtems_rfs_rtems_device_handlers><== NOT EXECUTED
20227e4: c2 26 20 10 st %g1, [ %i0 + 0x10 ]
else
{
printf ("rtems-rfs: mode type unknown: %04x\n", mode);
return false;
}
return true;
20227e8: 10 80 00 13 b 2022834 <rtems_rfs_rtems_set_handlers+0xac>
20227ec: b0 10 20 01 mov 1, %i0
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);
else if (RTEMS_RFS_S_ISLNK (mode))
20227f0: 80 a0 40 02 cmp %g1, %g2
20227f4: 12 80 00 05 bne 2022808 <rtems_rfs_rtems_set_handlers+0x80>
20227f8: 05 00 00 20 sethi %hi(0x8000), %g2
loc->handlers = rtems_rfs_rtems_handlers (link);
20227fc: 03 00 81 8a sethi %hi(0x2062800), %g1
2022800: 10 bf ff f9 b 20227e4 <rtems_rfs_rtems_set_handlers+0x5c>
2022804: 82 10 63 0c or %g1, 0x30c, %g1 ! 2062b0c <rtems_rfs_rtems_link_handlers>
else if (RTEMS_RFS_S_ISREG (mode))
2022808: 80 a0 40 02 cmp %g1, %g2
202280c: 32 80 00 05 bne,a 2022820 <rtems_rfs_rtems_set_handlers+0x98><== NEVER TAKEN
2022810: 93 2a 60 10 sll %o1, 0x10, %o1 <== NOT EXECUTED
loc->handlers = rtems_rfs_rtems_handlers (file);
2022814: 03 00 81 a5 sethi %hi(0x2069400), %g1
2022818: 10 bf ff f3 b 20227e4 <rtems_rfs_rtems_set_handlers+0x5c>
202281c: 82 10 60 6c or %g1, 0x6c, %g1 ! 206946c <rtems_rfs_rtems_file_handlers>
else
{
printf ("rtems-rfs: mode type unknown: %04x\n", mode);
2022820: 11 00 81 8a sethi %hi(0x2062800), %o0 <== NOT EXECUTED
2022824: 93 32 60 10 srl %o1, 0x10, %o1 <== NOT EXECUTED
2022828: 90 12 23 40 or %o0, 0x340, %o0 <== NOT EXECUTED
202282c: 40 00 90 af call 2046ae8 <printf> <== NOT EXECUTED
2022830: b0 10 20 00 clr %i0 <== NOT EXECUTED
return false;
}
return true;
}
2022834: b0 0e 20 01 and %i0, 1, %i0
2022838: 81 c7 e0 08 ret
202283c: 81 e8 00 00 restore
02021788 <rtems_rfs_rtems_statvfs>:
* @return int
*/
static int
rtems_rfs_rtems_statvfs (const rtems_filesystem_location_info_t* pathloc,
struct statvfs* sb)
{
2021788: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
202178c: c2 06 20 14 ld [ %i0 + 0x14 ], %g1 <== NOT EXECUTED
size_t blocks;
size_t inodes;
rtems_rfs_group_usage (fs, &blocks, &inodes);
2021790: 92 07 bf f8 add %fp, -8, %o1 <== NOT EXECUTED
*/
static int
rtems_rfs_rtems_statvfs (const rtems_filesystem_location_info_t* pathloc,
struct statvfs* sb)
{
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
2021794: fa 00 60 08 ld [ %g1 + 8 ], %i5 <== NOT EXECUTED
size_t blocks;
size_t inodes;
rtems_rfs_group_usage (fs, &blocks, &inodes);
2021798: 94 07 bf fc add %fp, -4, %o2 <== NOT EXECUTED
202179c: 40 00 68 9f call 203ba18 <rtems_rfs_group_usage> <== NOT EXECUTED
20217a0: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
sb->f_bsize = rtems_rfs_fs_block_size (fs);
20217a4: c2 07 60 08 ld [ %i5 + 8 ], %g1 <== NOT EXECUTED
20217a8: c2 26 40 00 st %g1, [ %i1 ] <== NOT EXECUTED
sb->f_frsize = rtems_rfs_fs_media_block_size (fs);
20217ac: c2 07 60 10 ld [ %i5 + 0x10 ], %g1 <== NOT EXECUTED
20217b0: c4 00 60 20 ld [ %g1 + 0x20 ], %g2 <== NOT EXECUTED
sb->f_blocks = rtems_rfs_fs_media_blocks (fs);
20217b4: c2 00 60 1c ld [ %g1 + 0x1c ], %g1 <== NOT EXECUTED
size_t inodes;
rtems_rfs_group_usage (fs, &blocks, &inodes);
sb->f_bsize = rtems_rfs_fs_block_size (fs);
sb->f_frsize = rtems_rfs_fs_media_block_size (fs);
20217b8: c4 26 60 04 st %g2, [ %i1 + 4 ] <== NOT EXECUTED
sb->f_blocks = rtems_rfs_fs_media_blocks (fs);
20217bc: c2 26 60 0c st %g1, [ %i1 + 0xc ] <== NOT EXECUTED
sb->f_bfree = rtems_rfs_fs_blocks (fs) - blocks;
20217c0: c4 07 60 04 ld [ %i5 + 4 ], %g2 <== NOT EXECUTED
20217c4: c2 07 bf f8 ld [ %fp + -8 ], %g1 <== 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);
20217c8: c0 26 60 08 clr [ %i1 + 8 ] <== NOT EXECUTED
sb->f_bfree = rtems_rfs_fs_blocks (fs) - blocks;
20217cc: 82 20 80 01 sub %g2, %g1, %g1 <== NOT EXECUTED
sb->f_bavail = sb->f_bfree;
sb->f_files = rtems_rfs_fs_inodes (fs);
sb->f_ffree = rtems_rfs_fs_inodes (fs) - inodes;
20217d0: c4 07 bf fc ld [ %fp + -4 ], %g2 <== 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;
20217d4: c2 26 60 14 st %g1, [ %i1 + 0x14 ] <== NOT EXECUTED
sb->f_bavail = sb->f_bfree;
20217d8: c2 26 60 1c st %g1, [ %i1 + 0x1c ] <== NOT EXECUTED
sb->f_files = rtems_rfs_fs_inodes (fs);
20217dc: c2 07 60 14 ld [ %i5 + 0x14 ], %g1 <== 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;
20217e0: c0 26 60 10 clr [ %i1 + 0x10 ] <== NOT EXECUTED
sb->f_bavail = sb->f_bfree;
sb->f_files = rtems_rfs_fs_inodes (fs);
20217e4: c2 26 60 20 st %g1, [ %i1 + 0x20 ] <== NOT EXECUTED
sb->f_ffree = rtems_rfs_fs_inodes (fs) - inodes;
20217e8: 82 20 40 02 sub %g1, %g2, %g1 <== NOT EXECUTED
20217ec: c2 26 60 24 st %g1, [ %i1 + 0x24 ] <== NOT EXECUTED
sb->f_favail = sb->f_ffree;
20217f0: c2 26 60 28 st %g1, [ %i1 + 0x28 ] <== NOT EXECUTED
sb->f_fsid = RTEMS_RFS_SB_MAGIC;
20217f4: 03 0a 02 48 sethi %hi(0x28092000), %g1 <== NOT EXECUTED
20217f8: 82 10 60 01 or %g1, 1, %g1 ! 28092001 <RAM_END+0x25c92001><== NOT EXECUTED
20217fc: c2 26 60 2c st %g1, [ %i1 + 0x2c ] <== NOT EXECUTED
sb->f_flag = rtems_rfs_fs_flags (fs);
2021800: c2 07 40 00 ld [ %i5 ], %g1 <== 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;
2021804: c0 26 60 18 clr [ %i1 + 0x18 ] <== NOT EXECUTED
sb->f_files = rtems_rfs_fs_inodes (fs);
sb->f_ffree = rtems_rfs_fs_inodes (fs) - inodes;
sb->f_favail = sb->f_ffree;
sb->f_fsid = RTEMS_RFS_SB_MAGIC;
sb->f_flag = rtems_rfs_fs_flags (fs);
2021808: c2 26 60 30 st %g1, [ %i1 + 0x30 ] <== NOT EXECUTED
sb->f_namemax = rtems_rfs_fs_max_name (fs);
202180c: c2 07 60 1c ld [ %i5 + 0x1c ], %g1 <== NOT EXECUTED
2021810: c2 26 60 34 st %g1, [ %i1 + 0x34 ] <== NOT EXECUTED
return 0;
}
2021814: 81 c7 e0 08 ret <== NOT EXECUTED
2021818: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED
02021934 <rtems_rfs_rtems_symlink>:
static int
rtems_rfs_rtems_symlink (const rtems_filesystem_location_info_t* parent_loc,
const char* node_name,
size_t node_name_len,
const char* target)
{
2021934: 9d e3 bf 98 save %sp, -104, %sp
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (parent_loc);
2021938: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
rtems_rfs_ino parent = rtems_rfs_rtems_get_pathloc_ino (parent_loc);
int rc;
rc = rtems_rfs_symlink (fs, node_name, node_name_len,
target, strlen (target),
202193c: 90 10 00 1b mov %i3, %o0
2021940: 40 00 9e 10 call 2049180 <strlen>
2021944: f8 00 60 08 ld [ %g1 + 8 ], %i4
const char* node_name,
size_t node_name_len,
const char* target)
{
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (parent_loc);
rtems_rfs_ino parent = rtems_rfs_rtems_get_pathloc_ino (parent_loc);
2021948: f0 06 20 08 ld [ %i0 + 8 ], %i0
int rc;
rc = rtems_rfs_symlink (fs, node_name, node_name_len,
202194c: 40 00 19 e3 call 20280d8 <geteuid>
2021950: ba 10 00 08 mov %o0, %i5
2021954: 40 00 19 dd call 20280c8 <getegid>
2021958: a0 10 00 08 mov %o0, %l0
202195c: 91 2a 20 10 sll %o0, 0x10, %o0
2021960: 91 32 20 10 srl %o0, 0x10, %o0
2021964: f0 23 a0 60 st %i0, [ %sp + 0x60 ]
2021968: d0 23 a0 5c st %o0, [ %sp + 0x5c ]
202196c: 98 10 00 1d mov %i5, %o4
2021970: 9b 2c 20 10 sll %l0, 0x10, %o5
2021974: 90 10 00 1c mov %i4, %o0
2021978: 92 10 00 19 mov %i1, %o1
202197c: 94 10 00 1a mov %i2, %o2
2021980: 96 10 00 1b mov %i3, %o3
2021984: 9b 33 60 10 srl %o5, 0x10, %o5
2021988: 40 00 6c 1c call 203c9f8 <rtems_rfs_symlink>
202198c: b0 10 20 00 clr %i0
target, strlen (target),
geteuid(), getegid(), parent);
if (rc)
2021990: 80 a2 20 00 cmp %o0, 0
2021994: 02 80 00 05 be 20219a8 <rtems_rfs_rtems_symlink+0x74> <== ALWAYS TAKEN
2021998: ba 10 00 08 mov %o0, %i5
{
return rtems_rfs_rtems_error ("symlink: linking", rc);
202199c: 40 00 82 14 call 20421ec <__errno> <== NOT EXECUTED
20219a0: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
20219a4: fa 22 00 00 st %i5, [ %o0 ] <== NOT EXECUTED
}
return 0;
}
20219a8: 81 c7 e0 08 ret
20219ac: 81 e8 00 00 restore
020228e8 <rtems_rfs_rtems_unlock>:
/**
* Unlock the RFS file system.
*/
static inline void
rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)
{
20228e8: 9d e3 bf a0 save %sp, -96, %sp
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
20228ec: fa 06 20 80 ld [ %i0 + 0x80 ], %i5
rtems_rfs_buffers_release (fs);
20228f0: 40 00 54 45 call 2037a04 <rtems_rfs_buffers_release>
20228f4: 90 10 00 18 mov %i0, %o0
*/
static inline int
rtems_rfs_mutex_unlock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
20228f8: 7f ff ab 39 call 200d5dc <rtems_semaphore_release>
20228fc: d0 07 40 00 ld [ %i5 ], %o0
if (sc != RTEMS_SUCCESSFUL)
2022900: ba 92 20 00 orcc %o0, 0, %i5
2022904: 02 80 00 0c be 2022934 <rtems_rfs_rtems_unlock+0x4c> <== ALWAYS TAKEN
2022908: 90 10 20 00 clr %o0
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
202290c: 40 00 04 50 call 2023a4c <rtems_rfs_trace> <== NOT EXECUTED
2022910: 92 10 20 04 mov 4, %o1 <== NOT EXECUTED
2022914: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
2022918: 02 80 00 07 be 2022934 <rtems_rfs_rtems_unlock+0x4c> <== NOT EXECUTED
202291c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
printf ("rtems-rfs: mutex: release failed: %s\n",
2022920: 7f ff 98 1a call 2008988 <rtems_status_text> <== NOT EXECUTED
2022924: 31 00 81 8a sethi %hi(0x2062800), %i0 <== NOT EXECUTED
2022928: b0 16 22 28 or %i0, 0x228, %i0 ! 2062a28 <rtems_nvdisk_sram_handlers+0xc><== NOT EXECUTED
202292c: 40 00 90 6f call 2046ae8 <printf> <== NOT EXECUTED
2022930: 93 e8 00 08 restore %g0, %o0, %o1 <== NOT EXECUTED
2022934: 81 c7 e0 08 ret
2022938: 81 e8 00 00 restore
020219b0 <rtems_rfs_rtems_utime>:
static int
rtems_rfs_rtems_utime(const rtems_filesystem_location_info_t* pathloc,
time_t atime,
time_t mtime)
{
20219b0: 9d e3 bf 78 save %sp, -136, %sp <== NOT EXECUTED
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
20219b4: c2 06 20 14 ld [ %i0 + 0x14 ], %g1 <== NOT EXECUTED
rtems_rfs_ino ino = rtems_rfs_rtems_get_pathloc_ino (pathloc);
rtems_rfs_inode_handle inode;
int rc;
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
20219b8: d2 06 20 08 ld [ %i0 + 8 ], %o1 <== NOT EXECUTED
static int
rtems_rfs_rtems_utime(const rtems_filesystem_location_info_t* pathloc,
time_t atime,
time_t mtime)
{
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
20219bc: fa 00 60 08 ld [ %g1 + 8 ], %i5 <== NOT EXECUTED
rtems_rfs_ino ino = rtems_rfs_rtems_get_pathloc_ino (pathloc);
rtems_rfs_inode_handle inode;
int rc;
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
20219c0: 94 07 bf d8 add %fp, -40, %o2 <== NOT EXECUTED
20219c4: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
20219c8: 40 00 68 76 call 203bba0 <rtems_rfs_inode_open> <== NOT EXECUTED
20219cc: 96 10 20 01 mov 1, %o3 <== NOT EXECUTED
if (rc)
20219d0: b8 92 20 00 orcc %o0, 0, %i4 <== NOT EXECUTED
20219d4: 02 80 00 07 be 20219f0 <rtems_rfs_rtems_utime+0x40> <== NOT EXECUTED
20219d8: c2 07 bf e4 ld [ %fp + -28 ], %g1 <== NOT EXECUTED
{
return rtems_rfs_rtems_error ("utime: read inode", rc);
20219dc: 40 00 82 04 call 20421ec <__errno> <== NOT EXECUTED
20219e0: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
20219e4: f8 22 00 00 st %i4, [ %o0 ] <== NOT EXECUTED
20219e8: 81 c7 e0 08 ret <== NOT EXECUTED
20219ec: 81 e8 00 00 restore <== 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);
20219f0: 85 36 60 18 srl %i1, 0x18, %g2 <== NOT EXECUTED
20219f4: c4 28 60 10 stb %g2, [ %g1 + 0x10 ] <== NOT EXECUTED
20219f8: 85 36 60 10 srl %i1, 0x10, %g2 <== NOT EXECUTED
20219fc: c4 28 60 11 stb %g2, [ %g1 + 0x11 ] <== NOT EXECUTED
2021a00: 85 36 60 08 srl %i1, 8, %g2 <== NOT EXECUTED
2021a04: c4 28 60 12 stb %g2, [ %g1 + 0x12 ] <== NOT EXECUTED
rtems_rfs_buffer_mark_dirty (&handle->buffer);
2021a08: 84 10 20 01 mov 1, %g2 <== NOT EXECUTED
2021a0c: c4 2f bf e8 stb %g2, [ %fp + -24 ] <== 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);
2021a10: 85 36 a0 18 srl %i2, 0x18, %g2 <== NOT EXECUTED
2021a14: c4 28 60 14 stb %g2, [ %g1 + 0x14 ] <== NOT EXECUTED
2021a18: 85 36 a0 10 srl %i2, 0x10, %g2 <== NOT EXECUTED
2021a1c: c4 28 60 15 stb %g2, [ %g1 + 0x15 ] <== NOT EXECUTED
2021a20: 85 36 a0 08 srl %i2, 8, %g2 <== NOT EXECUTED
}
rtems_rfs_inode_set_atime (&inode, atime);
rtems_rfs_inode_set_mtime (&inode, mtime);
rc = rtems_rfs_inode_close (fs, &inode);
2021a24: 90 10 00 1d mov %i5, %o0 <== 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);
2021a28: f2 28 60 13 stb %i1, [ %g1 + 0x13 ] <== 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);
2021a2c: c4 28 60 16 stb %g2, [ %g1 + 0x16 ] <== NOT EXECUTED
2021a30: f4 28 60 17 stb %i2, [ %g1 + 0x17 ] <== NOT EXECUTED
2021a34: 92 07 bf d8 add %fp, -40, %o1 <== NOT EXECUTED
2021a38: 40 00 68 cc call 203bd68 <rtems_rfs_inode_close> <== NOT EXECUTED
2021a3c: b0 10 20 00 clr %i0 <== NOT EXECUTED
if (rc)
2021a40: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2021a44: 02 80 00 05 be 2021a58 <rtems_rfs_rtems_utime+0xa8> <== NOT EXECUTED
2021a48: ba 10 00 08 mov %o0, %i5 <== NOT EXECUTED
{
return rtems_rfs_rtems_error ("utime: closing inode", rc);
2021a4c: 40 00 81 e8 call 20421ec <__errno> <== NOT EXECUTED
2021a50: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
2021a54: fa 22 00 00 st %i5, [ %o0 ] <== NOT EXECUTED
}
return 0;
}
2021a58: 81 c7 e0 08 ret <== NOT EXECUTED
2021a5c: 81 e8 00 00 restore <== NOT EXECUTED
020372a8 <rtems_rfs_scan_chain>:
*/
static rtems_rfs_buffer*
rtems_rfs_scan_chain (rtems_chain_control* chain,
uint32_t* count,
rtems_rfs_buffer_block block)
{
20372a8: 9d e3 bf a0 save %sp, -96, %sp
rtems_rfs_buffer* buffer;
rtems_chain_node* node;
node = rtems_chain_last (chain);
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))
20372ac: 90 10 20 00 clr %o0
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Last(
Chain_Control *the_chain
)
{
return _Chain_Tail( the_chain )->previous;
20372b0: fa 06 20 08 ld [ %i0 + 8 ], %i5
20372b4: 7f ff b1 e6 call 2023a4c <rtems_rfs_trace>
20372b8: 92 10 20 80 mov 0x80, %o1
20372bc: 80 8a 20 ff btst 0xff, %o0
20372c0: 22 80 00 29 be,a 2037364 <rtems_rfs_scan_chain+0xbc> <== ALWAYS TAKEN
20372c4: 39 00 81 9c sethi %hi(0x2067000), %i4
printf ("rtems-rfs: buffer-scan: count=%" PRIu32 ", block=%" PRIu32 ": ", *count, block);
20372c8: d2 06 40 00 ld [ %i1 ], %o1 <== NOT EXECUTED
20372cc: 11 00 81 9c sethi %hi(0x2067000), %o0 <== NOT EXECUTED
20372d0: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED
20372d4: 40 00 3e 05 call 2046ae8 <printf> <== NOT EXECUTED
20372d8: 90 12 22 48 or %o0, 0x248, %o0 <== NOT EXECUTED
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));
20372dc: 10 80 00 22 b 2037364 <rtems_rfs_scan_chain+0xbc> <== NOT EXECUTED
20372e0: 39 00 81 9c sethi %hi(0x2067000), %i4 <== NOT EXECUTED
while (!rtems_chain_is_head (chain, node))
{
buffer = (rtems_rfs_buffer*) node;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))
20372e4: 7f ff b1 da call 2023a4c <rtems_rfs_trace>
20372e8: 01 00 00 00 nop
20372ec: 80 8a 20 ff btst 0xff, %o0
20372f0: 22 80 00 06 be,a 2037308 <rtems_rfs_scan_chain+0x60> <== ALWAYS TAKEN
20372f4: c2 07 60 34 ld [ %i5 + 0x34 ], %g1
printf ("%" PRIuPTR " ", ((intptr_t) buffer->user));
20372f8: d2 07 60 34 ld [ %i5 + 0x34 ], %o1 <== NOT EXECUTED
20372fc: 40 00 3d fb call 2046ae8 <printf> <== NOT EXECUTED
2037300: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
if (((rtems_rfs_buffer_block) ((intptr_t)(buffer->user))) == block)
2037304: c2 07 60 34 ld [ %i5 + 0x34 ], %g1 <== NOT EXECUTED
2037308: 80 a0 40 1a cmp %g1, %i2
203730c: 32 80 00 17 bne,a 2037368 <rtems_rfs_scan_chain+0xc0>
2037310: fa 07 60 04 ld [ %i5 + 4 ], %i5
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))
2037314: 90 10 20 00 clr %o0
2037318: 7f ff b1 cd call 2023a4c <rtems_rfs_trace>
203731c: 92 10 20 80 mov 0x80, %o1
2037320: 80 8a 20 ff btst 0xff, %o0
2037324: 22 80 00 07 be,a 2037340 <rtems_rfs_scan_chain+0x98> <== ALWAYS TAKEN
2037328: c2 06 40 00 ld [ %i1 ], %g1
printf (": found block=%" PRIuPTR "\n",
203732c: d2 07 60 34 ld [ %i5 + 0x34 ], %o1 <== NOT EXECUTED
2037330: 11 00 81 9c sethi %hi(0x2067000), %o0 <== NOT EXECUTED
2037334: 40 00 3d ed call 2046ae8 <printf> <== NOT EXECUTED
2037338: 90 12 22 80 or %o0, 0x280, %o0 ! 2067280 <__FUNCTION__.7829+0x190><== NOT EXECUTED
((intptr_t)(buffer->user)));
(*count)--;
203733c: c2 06 40 00 ld [ %i1 ], %g1 <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
2037340: 90 10 00 1d mov %i5, %o0
2037344: 82 00 7f ff add %g1, -1, %g1
rtems_chain_extract (node);
rtems_chain_set_off_chain (node);
return buffer;
2037348: b0 10 00 1d mov %i5, %i0
203734c: 7f ff cf c6 call 202b264 <_Chain_Extract>
2037350: c2 26 40 00 st %g1, [ %i1 ]
*/
RTEMS_INLINE_ROUTINE void _Chain_Set_off_chain(
Chain_Node *node
)
{
node->next = node->previous = NULL;
2037354: c0 27 60 04 clr [ %i5 + 4 ]
2037358: c0 27 40 00 clr [ %i5 ]
203735c: 81 c7 e0 08 ret
2037360: 81 e8 00 00 restore
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));
2037364: b8 17 22 78 or %i4, 0x278, %i4
while (!rtems_chain_is_head (chain, node))
{
buffer = (rtems_rfs_buffer*) node;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))
2037368: 90 10 20 00 clr %o0
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))
203736c: 80 a7 40 18 cmp %i5, %i0
2037370: 12 bf ff dd bne 20372e4 <rtems_rfs_scan_chain+0x3c>
2037374: 92 10 20 80 mov 0x80, %o1
return buffer;
}
node = rtems_chain_previous (node);
}
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))
2037378: 7f ff b1 b5 call 2023a4c <rtems_rfs_trace>
203737c: b0 10 20 00 clr %i0
2037380: 80 8a 20 ff btst 0xff, %o0
2037384: 02 bf ff f6 be 203735c <rtems_rfs_scan_chain+0xb4> <== ALWAYS TAKEN
2037388: 11 00 81 9c sethi %hi(0x2067000), %o0
printf (": not found\n");
203738c: 40 00 3e 6f call 2046d48 <puts> <== NOT EXECUTED
2037390: 90 12 22 98 or %o0, 0x298, %o0 ! 2067298 <__FUNCTION__.7829+0x1a8><== NOT EXECUTED
return NULL;
}
2037394: 81 c7 e0 08 ret <== NOT EXECUTED
2037398: 81 e8 00 00 restore <== NOT EXECUTED
020412e0 <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,
20412e0: 9d e3 bf 88 save %sp, -120, %sp
rtems_rfs_bitmap_element* map_bits;
int map_index;
int map_offset;
int rc;
*found = false;
20412e4: c0 2e 80 00 clrb [ %i2 ]
/*
* Load the bitmap.
*/
rc = rtems_rfs_bitmap_load_map (control, &map);
20412e8: 90 10 00 18 mov %i0, %o0
20412ec: 7f ff ff e8 call 204128c <rtems_rfs_bitmap_load_map>
20412f0: 92 07 bf fc add %fp, -4, %o1
if (rc > 0)
20412f4: 80 a2 20 00 cmp %o0, 0
20412f8: 14 80 00 98 bg 2041558 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x278><== NEVER TAKEN
20412fc: a1 2e e0 0b sll %i3, 0xb, %l0
return rc;
/*
* Calculate the bit we are testing plus the end point we search over.
*/
test_bit = *bit;
2041300: fa 06 40 00 ld [ %i1 ], %i5
end_bit = test_bit + (window * direction);
if (end_bit < 0)
2041304: a0 84 00 1d addcc %l0, %i5, %l0
2041308: 2c 80 00 08 bneg,a 2041328 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x48>
204130c: a0 10 20 00 clr %l0
end_bit = 0;
else if (end_bit >= control->size)
2041310: c2 06 20 0c ld [ %i0 + 0xc ], %g1
2041314: 80 a4 00 01 cmp %l0, %g1
2041318: 3a 80 00 04 bcc,a 2041328 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x48><== ALWAYS TAKEN
204131c: a0 00 7f ff add %g1, -1, %l0
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];
2041320: 10 80 00 03 b 204132c <rtems_rfs_search_map_for_clear_bit.constprop.1+0x4c><== NOT EXECUTED
2041324: c4 06 20 14 ld [ %i0 + 0x14 ], %g2 <== NOT EXECUTED
2041328: c4 06 20 14 ld [ %i0 + 0x14 ], %g2
map_bits = &map[map_index];
204132c: e2 07 bf fc ld [ %fp + -4 ], %l1
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);
2041330: b9 3f 60 05 sra %i5, 5, %i4
map_offset = rtems_rfs_bitmap_map_offset (test_bit);
search_index = rtems_rfs_bitmap_map_index (map_index);
2041334: a7 3f 60 0a sra %i5, 0xa, %l3
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);
2041338: a4 0f 60 1f and %i5, 0x1f, %l2
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];
204133c: a7 2c e0 02 sll %l3, 2, %l3
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);
search_offset = rtems_rfs_bitmap_map_offset (map_index);
2041340: 82 0f 20 1f and %i4, 0x1f, %g1
search_bits = &control->search_bits[search_index];
2041344: a6 00 80 13 add %g2, %l3, %l3
map_offset += direction;
test_bit += direction;
}
}
map_bits += direction;
2041348: ad 2e e0 02 sll %i3, 2, %l6
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];
map_bits = &map[map_index];
204134c: 85 2f 20 02 sll %i4, 2, %g2
2041350: a8 10 20 1f mov 0x1f, %l4
2041354: 80 a6 e0 00 cmp %i3, 0
2041358: 04 80 00 03 ble 2041364 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x84>
204135c: a2 04 40 02 add %l1, %g2, %l1
2041360: a8 10 20 00 clr %l4
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)))
2041364: ab 3e e0 1f sra %i3, 0x1f, %l5
return 0;
}
static int
rtems_rfs_search_map_for_clear_bit (rtems_rfs_bitmap_control* control,
2041368: 89 2e e0 05 sll %i3, 5, %g4
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)))
204136c: aa 25 40 1b sub %l5, %i3, %l5
*/
static bool
rtems_rfs_bitmap_test (rtems_rfs_bitmap_element target,
rtems_rfs_bitmap_bit bit)
{
return RTEMS_RFS_BITMAP_TEST_BIT (target, bit);
2041370: ae 10 20 01 mov 1, %l7
test_bit = (map_index * rtems_rfs_bitmap_element_bits ()) + map_offset;
search_offset += direction;
if (((direction < 0) && (test_bit <= end_bit))
2041374: 87 36 e0 1f srl %i3, 0x1f, %g3
|| ((direction > 0) && (test_bit >= end_bit)))
2041378: ab 35 60 1f srl %l5, 0x1f, %l5
*/
rtems_rfs_bitmap_bit bits_skipped;
test_bit &= ~((1 << RTEMS_RFS_ELEMENT_BITS_POWER_2) - 1);
if (direction > 0)
{
bits_skipped = rtems_rfs_bitmap_element_bits () - search_offset;
204137c: 9a 10 20 20 mov 0x20, %o5
/*
* 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))
2041380: d8 04 c0 00 ld [ %l3 ], %o4
2041384: 80 a3 20 00 cmp %o4, 0
2041388: 02 80 00 44 be 2041498 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x1b8><== NEVER TAKEN
204138c: 80 a6 e0 00 cmp %i3, 0
return 0;
}
static int
rtems_rfs_search_map_for_clear_bit (rtems_rfs_bitmap_control* control,
2041390: 96 07 00 1b add %i4, %i3, %o3
2041394: 84 10 20 00 clr %g2
2041398: 97 2a e0 05 sll %o3, 5, %o3
204139c: 82 20 40 1c sub %g1, %i4, %g1
20413a0: 10 80 00 38 b 2041480 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x1a0>
20413a4: 96 02 c0 14 add %o3, %l4, %o3
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))
20413a8: 80 8b c0 0c btst %o7, %o4
20413ac: 12 80 00 1a bne 2041414 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x134>
20413b0: a4 24 80 1d sub %l2, %i5, %l2
return 0;
}
static int
rtems_rfs_search_map_for_clear_bit (rtems_rfs_bitmap_control* control,
20413b4: 10 80 00 1d b 2041428 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x148>
20413b8: ba 00 80 0b add %g2, %o3, %i5
*/
static bool
rtems_rfs_bitmap_test (rtems_rfs_bitmap_element target,
rtems_rfs_bitmap_bit bit)
{
return RTEMS_RFS_BITMAP_TEST_BIT (target, bit);
20413bc: 95 2d c0 0a sll %l7, %o2, %o2
* 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))
20413c0: 80 8a 80 09 btst %o2, %o1
20413c4: 02 80 00 12 be 204140c <rtems_rfs_search_map_for_clear_bit.constprop.1+0x12c>
20413c8: 80 a7 40 10 cmp %i5, %l0
*/
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);
20413cc: 94 2a 40 0a andn %o1, %o2, %o2
&& (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,
20413d0: 80 a2 a0 00 cmp %o2, 0
20413d4: 12 80 00 05 bne 20413e8 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x108>
20413d8: d4 24 40 00 st %o2, [ %l1 ]
*/
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);
20413dc: c2 04 c0 00 ld [ %l3 ], %g1
20413e0: 9e 28 40 0f andn %g1, %o7, %o7
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,
20413e4: de 24 c0 00 st %o7, [ %l3 ]
1 << search_offset);
control->free--;
20413e8: c2 06 20 10 ld [ %i0 + 0x10 ], %g1
*bit = test_bit;
*found = true;
rtems_rfs_buffer_mark_dirty (control->buffer);
20413ec: c4 06 00 00 ld [ %i0 ], %g2
*map_bits = rtems_rfs_bitmap_set (*map_bits, 1 << map_offset);
if (rtems_rfs_bitmap_match(*map_bits,
RTEMS_RFS_BITMAP_ELEMENT_SET))
*search_bits = rtems_rfs_bitmap_set (*search_bits,
1 << search_offset);
control->free--;
20413f0: 82 00 7f ff add %g1, -1, %g1
20413f4: c2 26 20 10 st %g1, [ %i0 + 0x10 ]
*bit = test_bit;
20413f8: fa 26 40 00 st %i5, [ %i1 ]
*found = true;
20413fc: 82 10 20 01 mov 1, %g1
2041400: c2 2e 80 00 stb %g1, [ %i2 ]
rtems_rfs_buffer_mark_dirty (control->buffer);
2041404: 10 80 00 54 b 2041554 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x274>
2041408: c2 28 80 00 stb %g1, [ %g2 ]
return 0;
}
if (test_bit == end_bit)
204140c: 02 80 00 06 be 2041424 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x144>
2041410: ba 07 40 1b add %i5, %i3, %i5
return 0;
}
static int
rtems_rfs_search_map_for_clear_bit (rtems_rfs_bitmap_control* control,
2041414: 94 04 80 1d add %l2, %i5, %o2
{
/*
* 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)
2041418: 80 a2 a0 1f cmp %o2, 0x1f
204141c: 28 bf ff e8 bleu,a 20413bc <rtems_rfs_search_map_for_clear_bit.constprop.1+0xdc><== ALWAYS TAKEN
2041420: d2 04 40 00 ld [ %l1 ], %o1
return 0;
}
static int
rtems_rfs_search_map_for_clear_bit (rtems_rfs_bitmap_control* control,
2041424: ba 00 80 0b add %g2, %o3, %i5
map_offset += direction;
test_bit += direction;
}
}
map_bits += direction;
2041428: a2 04 40 16 add %l1, %l6, %l1
map_index += direction;
204142c: b8 07 00 1b add %i4, %i3, %i4
test_bit = (map_index * rtems_rfs_bitmap_element_bits ()) + map_offset;
search_offset += direction;
if (((direction < 0) && (test_bit <= end_bit))
2041430: 80 a7 40 10 cmp %i5, %l0
2041434: 04 80 00 03 ble 2041440 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x160>
2041438: 9e 10 20 01 mov 1, %o7
204143c: 9e 10 20 00 clr %o7
2041440: 80 8b e0 ff btst 0xff, %o7
2041444: 02 80 00 05 be 2041458 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x178>
2041448: 84 00 80 04 add %g2, %g4, %g2
204144c: 80 a0 e0 00 cmp %g3, 0
2041450: 32 80 00 29 bne,a 20414f4 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x214>
2041454: a4 10 00 14 mov %l4, %l2
|| ((direction > 0) && (test_bit >= end_bit)))
2041458: 80 a7 40 10 cmp %i5, %l0
204145c: 16 80 00 03 bge 2041468 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x188>
2041460: 9e 10 20 01 mov 1, %o7
2041464: 9e 10 20 00 clr %o7
2041468: 80 8b e0 ff btst 0xff, %o7
204146c: 02 80 00 05 be 2041480 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x1a0>
2041470: a4 10 00 14 mov %l4, %l2
2041474: 80 a5 60 00 cmp %l5, 0
2041478: 32 80 00 20 bne,a 20414f8 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x218><== ALWAYS TAKEN
204147c: a6 04 c0 16 add %l3, %l6, %l3
return 0;
}
static int
rtems_rfs_search_map_for_clear_bit (rtems_rfs_bitmap_control* control,
2041480: 9e 00 40 1c add %g1, %i4, %o7
* 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)
2041484: 80 a3 e0 1f cmp %o7, 0x1f
2041488: 28 bf ff c8 bleu,a 20413a8 <rtems_rfs_search_map_for_clear_bit.constprop.1+0xc8><== ALWAYS TAKEN
204148c: 9f 2d c0 0f sll %l7, %o7, %o7
}
map_bits += direction * bits_skipped;
map_index += direction * bits_skipped;
}
search_bits += direction;
2041490: 10 80 00 1a b 20414f8 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x218><== NOT EXECUTED
2041494: a6 04 c0 16 add %l3, %l6, %l3 <== 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)
2041498: 04 80 00 07 ble 20414b4 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x1d4><== NOT EXECUTED
204149c: ba 0f 7f e0 and %i5, -32, %i5 <== NOT EXECUTED
{
bits_skipped = rtems_rfs_bitmap_element_bits () - search_offset;
20414a0: 92 23 40 01 sub %o5, %g1, %o1 <== NOT EXECUTED
test_bit += bits_skipped * rtems_rfs_bitmap_element_bits ();
map_offset = 0;
20414a4: a4 10 20 00 clr %l2 <== NOT EXECUTED
rtems_rfs_bitmap_bit bits_skipped;
test_bit &= ~((1 << RTEMS_RFS_ELEMENT_BITS_POWER_2) - 1);
if (direction > 0)
{
bits_skipped = rtems_rfs_bitmap_element_bits () - search_offset;
test_bit += bits_skipped * rtems_rfs_bitmap_element_bits ();
20414a8: 83 2a 60 05 sll %o1, 5, %g1 <== NOT EXECUTED
20414ac: 10 80 00 07 b 20414c8 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x1e8><== NOT EXECUTED
20414b0: ba 00 40 1d add %g1, %i5, %i5 <== NOT EXECUTED
map_offset = 0;
}
else
{
bits_skipped = search_offset + 1;
20414b4: 92 00 60 01 add %g1, 1, %o1 <== NOT EXECUTED
/*
* Need to remove 1 for the rounding up. The above rounds down and
* adds 1. Remember the logic is for subtraction.
*/
test_bit -= ((bits_skipped - 1) * rtems_rfs_bitmap_element_bits ()) + 1;
map_offset = rtems_rfs_bitmap_element_bits () - 1;
20414b8: a4 10 20 1f mov 0x1f, %l2 <== NOT EXECUTED
bits_skipped = search_offset + 1;
/*
* Need to remove 1 for the rounding up. The above rounds down and
* adds 1. Remember the logic is for subtraction.
*/
test_bit -= ((bits_skipped - 1) * rtems_rfs_bitmap_element_bits ()) + 1;
20414bc: 83 28 60 05 sll %g1, 5, %g1 <== NOT EXECUTED
20414c0: 82 38 00 01 xnor %g0, %g1, %g1 <== NOT EXECUTED
20414c4: ba 00 40 1d add %g1, %i5, %i5 <== NOT EXECUTED
map_offset = rtems_rfs_bitmap_element_bits () - 1;
}
map_bits += direction * bits_skipped;
20414c8: c6 27 bf f4 st %g3, [ %fp + -12 ] <== NOT EXECUTED
20414cc: c8 27 bf f0 st %g4, [ %fp + -16 ] <== NOT EXECUTED
20414d0: da 27 bf ec st %o5, [ %fp + -20 ] <== NOT EXECUTED
20414d4: 7f ff 06 64 call 2002e64 <.umul> <== NOT EXECUTED
20414d8: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
20414dc: c6 07 bf f4 ld [ %fp + -12 ], %g3 <== NOT EXECUTED
20414e0: 83 2a 20 02 sll %o0, 2, %g1 <== NOT EXECUTED
map_index += direction * bits_skipped;
20414e4: b8 07 00 08 add %i4, %o0, %i4 <== NOT EXECUTED
* adds 1. Remember the logic is for subtraction.
*/
test_bit -= ((bits_skipped - 1) * rtems_rfs_bitmap_element_bits ()) + 1;
map_offset = rtems_rfs_bitmap_element_bits () - 1;
}
map_bits += direction * bits_skipped;
20414e8: a2 04 40 01 add %l1, %g1, %l1 <== NOT EXECUTED
20414ec: c8 07 bf f0 ld [ %fp + -16 ], %g4 <== NOT EXECUTED
20414f0: da 07 bf ec ld [ %fp + -20 ], %o5 <== NOT EXECUTED
map_index += direction * bits_skipped;
}
search_bits += direction;
20414f4: a6 04 c0 16 add %l3, %l6, %l3
search_offset = direction > 0 ? 0 : rtems_rfs_bitmap_element_bits () - 1;
20414f8: 80 a6 e0 00 cmp %i3, 0
20414fc: 04 80 00 03 ble 2041508 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x228>
2041500: 82 10 20 1f mov 0x1f, %g1
2041504: 82 10 20 00 clr %g1
}
while (((direction < 0) && (test_bit >= end_bit))
2041508: 80 a7 40 10 cmp %i5, %l0
204150c: 16 80 00 03 bge 2041518 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x238>
2041510: 84 10 20 01 mov 1, %g2
2041514: 84 10 20 00 clr %g2
|| ((direction > 0) && (test_bit <= end_bit)));
2041518: 80 88 a0 ff btst 0xff, %g2
204151c: 02 80 00 06 be 2041534 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x254>
2041520: 80 a7 40 10 cmp %i5, %l0
2041524: 80 a0 e0 00 cmp %g3, 0
2041528: 32 bf ff 97 bne,a 2041384 <rtems_rfs_search_map_for_clear_bit.constprop.1+0xa4><== NEVER TAKEN
204152c: d8 04 c0 00 ld [ %l3 ], %o4 <== NOT EXECUTED
2041530: 80 a7 40 10 cmp %i5, %l0
2041534: 04 80 00 03 ble 2041540 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x260>
2041538: 84 10 20 01 mov 1, %g2
204153c: 84 10 20 00 clr %g2
2041540: 80 88 a0 ff btst 0xff, %g2
2041544: 02 80 00 04 be 2041554 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x274>
2041548: 80 a5 60 00 cmp %l5, 0
204154c: 32 bf ff 8e bne,a 2041384 <rtems_rfs_search_map_for_clear_bit.constprop.1+0xa4><== NEVER TAKEN
2041550: d8 04 c0 00 ld [ %l3 ], %o4 <== NOT EXECUTED
return 0;
2041554: 90 10 20 00 clr %o0
}
2041558: 81 c7 e0 08 ret
204155c: 91 e8 00 08 restore %g0, %o0, %o0
02023448 <rtems_rfs_shell_block>:
return 0;
}
static int
rtems_rfs_shell_block (rtems_rfs_file_system* fs, int argc, char *argv[])
{
2023448: 9d e3 bf 90 save %sp, -112, %sp <== NOT EXECUTED
uint8_t* data;
bool state;
int b;
int rc;
if (argc <= 1)
202344c: 80 a6 60 01 cmp %i1, 1 <== NOT EXECUTED
2023450: 34 80 00 07 bg,a 202346c <rtems_rfs_shell_block+0x24> <== NOT EXECUTED
2023454: d0 06 a0 04 ld [ %i2 + 4 ], %o0 <== NOT EXECUTED
{
printf ("error: no block number provided\n");
2023458: 11 00 81 8c sethi %hi(0x2063000), %o0 <== NOT EXECUTED
202345c: 40 00 8e 3b call 2046d48 <puts> <== NOT EXECUTED
2023460: 90 12 20 00 mov %o0, %o0 ! 2063000 <rtems_rfs_rtems_eval_config+0x4c8><== NOT EXECUTED
{
rtems_rfs_buffer_handle_close (fs, &buffer);
rtems_rfs_shell_unlock_rfs (fs);
printf ("error: requesting buffer handle: block=%" PRIu32 ": (%d) %s\n",
block, rc, strerror (rc));
return 1;
2023464: 81 c7 e0 08 ret <== NOT EXECUTED
2023468: 91 e8 20 01 restore %g0, 1, %o0 <== NOT EXECUTED
{
printf ("error: no block number provided\n");
return 1;
}
block = strtoul (argv[1], 0, 0);
202346c: 92 10 20 00 clr %o1 <== NOT EXECUTED
2023470: 40 00 9d 99 call 204aad4 <strtoul> <== NOT EXECUTED
2023474: 94 10 20 00 clr %o2 <== NOT EXECUTED
2023478: ba 10 00 08 mov %o0, %i5 <== NOT EXECUTED
*/
static void
rtems_rfs_shell_lock_rfs (rtems_rfs_file_system* fs)
{
#if __rtems__
rtems_rfs_rtems_lock (fs);
202347c: 7f ff fd 06 call 2022894 <rtems_rfs_rtems_lock> <== NOT EXECUTED
2023480: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
block = strtoul (argv[1], 0, 0);
rtems_rfs_shell_lock_rfs (fs);
rc = rtems_rfs_group_bitmap_test (fs, false, block, &state);
2023484: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
2023488: 92 10 20 00 clr %o1 <== NOT EXECUTED
202348c: 94 10 00 1d mov %i5, %o2 <== NOT EXECUTED
2023490: 40 00 61 25 call 203b924 <rtems_rfs_group_bitmap_test> <== NOT EXECUTED
2023494: 96 07 bf f3 add %fp, -13, %o3 <== NOT EXECUTED
if (rc > 0)
2023498: b8 92 20 00 orcc %o0, 0, %i4 <== NOT EXECUTED
202349c: 04 80 00 0a ble 20234c4 <rtems_rfs_shell_block+0x7c> <== NOT EXECUTED
20234a0: c2 0f bf f3 ldub [ %fp + -13 ], %g1 <== NOT EXECUTED
*/
static void
rtems_rfs_shell_unlock_rfs (rtems_rfs_file_system* fs)
{
#if __rtems__
rtems_rfs_rtems_unlock (fs);
20234a4: 7f ff fd 11 call 20228e8 <rtems_rfs_rtems_unlock> <== NOT EXECUTED
20234a8: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
rc = rtems_rfs_group_bitmap_test (fs, false, block, &state);
if (rc > 0)
{
rtems_rfs_shell_unlock_rfs (fs);
printf ("error: testing block state: block=%" PRIu32 ": (%d) %s\n",
20234ac: 40 00 97 0e call 20490e4 <strerror> <== NOT EXECUTED
20234b0: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
20234b4: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
20234b8: 11 00 81 8c sethi %hi(0x2063000), %o0 <== NOT EXECUTED
20234bc: 10 80 00 25 b 2023550 <rtems_rfs_shell_block+0x108> <== NOT EXECUTED
20234c0: 90 12 20 20 or %o0, 0x20, %o0 ! 2063020 <rtems_rfs_rtems_eval_config+0x4e8><== NOT EXECUTED
block, rc, strerror (rc));
return 1;
}
printf (" %5" PRIu32 ": block %s\n", block, state ? "allocated" : "free");
20234c4: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
20234c8: 22 80 00 05 be,a 20234dc <rtems_rfs_shell_block+0x94> <== NOT EXECUTED
20234cc: 15 00 81 82 sethi %hi(0x2060800), %o2 <== NOT EXECUTED
20234d0: 15 00 81 8b sethi %hi(0x2062c00), %o2 <== NOT EXECUTED
20234d4: 10 80 00 03 b 20234e0 <rtems_rfs_shell_block+0x98> <== NOT EXECUTED
20234d8: 94 12 a3 f0 or %o2, 0x3f0, %o2 ! 2062ff0 <rtems_rfs_rtems_eval_config+0x4b8><== NOT EXECUTED
20234dc: 94 12 a1 f8 or %o2, 0x1f8, %o2 <== NOT EXECUTED
20234e0: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
20234e4: 11 00 81 8c sethi %hi(0x2063000), %o0 <== NOT EXECUTED
20234e8: 40 00 8d 80 call 2046ae8 <printf> <== NOT EXECUTED
20234ec: 90 12 20 50 or %o0, 0x50, %o0 ! 2063050 <rtems_rfs_rtems_eval_config+0x518><== NOT EXECUTED
printf ("error: opening buffer handle: block=%" PRIu32 ": (%d) %s\n",
block, rc, strerror (rc));
return 1;
}
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, true);
20234f0: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
20234f4: c0 2f bf f4 clrb [ %fp + -12 ] <== NOT EXECUTED
handle->bnum = 0;
20234f8: c0 27 bf f8 clr [ %fp + -8 ] <== NOT EXECUTED
handle->buffer = NULL;
20234fc: c0 27 bf fc clr [ %fp + -4 ] <== NOT EXECUTED
2023500: 92 07 bf f4 add %fp, -12, %o1 <== NOT EXECUTED
2023504: 94 10 00 1d mov %i5, %o2 <== NOT EXECUTED
2023508: 40 00 50 19 call 203756c <rtems_rfs_buffer_handle_request><== NOT EXECUTED
202350c: 96 10 20 01 mov 1, %o3 <== NOT EXECUTED
if (rc > 0)
2023510: b8 92 20 00 orcc %o0, 0, %i4 <== NOT EXECUTED
2023514: 04 80 00 14 ble 2023564 <rtems_rfs_shell_block+0x11c> <== NOT EXECUTED
2023518: c2 07 bf fc ld [ %fp + -4 ], %g1 <== 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);
202351c: 92 07 bf f4 add %fp, -12, %o1 <== NOT EXECUTED
2023520: 40 00 4f 9f call 203739c <rtems_rfs_buffer_handle_release><== NOT EXECUTED
2023524: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
*/
static void
rtems_rfs_shell_unlock_rfs (rtems_rfs_file_system* fs)
{
#if __rtems__
rtems_rfs_rtems_unlock (fs);
2023528: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
handle->dirty = false;
202352c: c0 2f bf f4 clrb [ %fp + -12 ] <== NOT EXECUTED
handle->bnum = 0;
2023530: c0 27 bf f8 clr [ %fp + -8 ] <== NOT EXECUTED
2023534: 7f ff fc ed call 20228e8 <rtems_rfs_rtems_unlock> <== NOT EXECUTED
2023538: c0 27 bf fc clr [ %fp + -4 ] <== NOT EXECUTED
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, true);
if (rc > 0)
{
rtems_rfs_buffer_handle_close (fs, &buffer);
rtems_rfs_shell_unlock_rfs (fs);
printf ("error: requesting buffer handle: block=%" PRIu32 ": (%d) %s\n",
202353c: 40 00 96 ea call 20490e4 <strerror> <== NOT EXECUTED
2023540: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
2023544: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
2023548: 11 00 81 8c sethi %hi(0x2063000), %o0 <== NOT EXECUTED
202354c: 90 12 20 68 or %o0, 0x68, %o0 ! 2063068 <rtems_rfs_rtems_eval_config+0x530><== NOT EXECUTED
2023550: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
2023554: 40 00 8d 65 call 2046ae8 <printf> <== NOT EXECUTED
2023558: 94 10 00 1c mov %i4, %o2 <== NOT EXECUTED
block, rc, strerror (rc));
return 1;
202355c: 81 c7 e0 08 ret <== NOT EXECUTED
2023560: 91 e8 20 01 restore %g0, 1, %o0 <== NOT EXECUTED
int mod = b % 16;
if (mod == 0)
{
if (b)
printf ("\n");
printf ("%04x ", b);
2023564: 37 00 81 8c sethi %hi(0x2063000), %i3 <== NOT EXECUTED
}
if (mod == 8)
printf (" ");
printf ("%02x ", *data);
2023568: 35 00 81 8c sethi %hi(0x2063000), %i2 <== NOT EXECUTED
printf ("error: requesting buffer handle: block=%" PRIu32 ": (%d) %s\n",
block, rc, strerror (rc));
return 1;
}
for (b = 0, data = rtems_rfs_buffer_data (&buffer);
202356c: f8 00 60 1c ld [ %g1 + 0x1c ], %i4 <== NOT EXECUTED
2023570: ba 10 20 00 clr %i5 <== NOT EXECUTED
int mod = b % 16;
if (mod == 0)
{
if (b)
printf ("\n");
printf ("%04x ", b);
2023574: b6 16 e1 30 or %i3, 0x130, %i3 <== NOT EXECUTED
printf ("error: requesting buffer handle: block=%" PRIu32 ": (%d) %s\n",
block, rc, strerror (rc));
return 1;
}
for (b = 0, data = rtems_rfs_buffer_data (&buffer);
2023578: 10 80 00 16 b 20235d0 <rtems_rfs_shell_block+0x188> <== NOT EXECUTED
202357c: b4 16 a1 38 or %i2, 0x138, %i2 <== NOT EXECUTED
b < rtems_rfs_fs_block_size (fs);
b++, data++)
{
int mod = b % 16;
if (mod == 0)
2023580: 12 80 00 0c bne 20235b0 <rtems_rfs_shell_block+0x168> <== NOT EXECUTED
2023584: 80 a0 60 08 cmp %g1, 8 <== NOT EXECUTED
{
if (b)
2023588: 80 a7 60 00 cmp %i5, 0 <== NOT EXECUTED
202358c: 02 80 00 05 be 20235a0 <rtems_rfs_shell_block+0x158> <== NOT EXECUTED
2023590: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
printf ("\n");
2023594: 40 00 8d bf call 2046c90 <putchar> <== NOT EXECUTED
2023598: 90 10 20 0a mov 0xa, %o0 <== NOT EXECUTED
printf ("%04x ", b);
202359c: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
20235a0: 40 00 8d 52 call 2046ae8 <printf> <== NOT EXECUTED
20235a4: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
}
if (mod == 8)
printf (" ");
printf ("%02x ", *data);
20235a8: 10 80 00 07 b 20235c4 <rtems_rfs_shell_block+0x17c> <== NOT EXECUTED
20235ac: d2 0f 00 1d ldub [ %i4 + %i5 ], %o1 <== NOT EXECUTED
{
if (b)
printf ("\n");
printf ("%04x ", b);
}
if (mod == 8)
20235b0: 32 80 00 05 bne,a 20235c4 <rtems_rfs_shell_block+0x17c> <== NOT EXECUTED
20235b4: d2 0f 00 1d ldub [ %i4 + %i5 ], %o1 <== NOT EXECUTED
printf (" ");
20235b8: 40 00 8d b6 call 2046c90 <putchar> <== NOT EXECUTED
20235bc: 90 10 20 20 mov 0x20, %o0 <== NOT EXECUTED
printf ("%02x ", *data);
20235c0: d2 0f 00 1d ldub [ %i4 + %i5 ], %o1 <== NOT EXECUTED
20235c4: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
20235c8: 40 00 8d 48 call 2046ae8 <printf> <== NOT EXECUTED
20235cc: ba 07 60 01 inc %i5 <== NOT EXECUTED
printf ("error: requesting buffer handle: block=%" PRIu32 ": (%d) %s\n",
block, rc, strerror (rc));
return 1;
}
for (b = 0, data = rtems_rfs_buffer_data (&buffer);
20235d0: c2 06 20 08 ld [ %i0 + 8 ], %g1 <== NOT EXECUTED
20235d4: 80 a7 40 01 cmp %i5, %g1 <== NOT EXECUTED
20235d8: 0a bf ff ea bcs 2023580 <rtems_rfs_shell_block+0x138> <== NOT EXECUTED
20235dc: 82 8f 60 0f andcc %i5, 0xf, %g1 <== NOT EXECUTED
if (mod == 8)
printf (" ");
printf ("%02x ", *data);
}
printf ("\n");
20235e0: 40 00 8d ac call 2046c90 <putchar> <== NOT EXECUTED
20235e4: 90 10 20 0a mov 0xa, %o0 <== 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);
20235e8: 92 07 bf f4 add %fp, -12, %o1 <== NOT EXECUTED
20235ec: 40 00 4f 6c call 203739c <rtems_rfs_buffer_handle_release><== NOT EXECUTED
20235f0: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
*/
static void
rtems_rfs_shell_unlock_rfs (rtems_rfs_file_system* fs)
{
#if __rtems__
rtems_rfs_rtems_unlock (fs);
20235f4: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
handle->dirty = false;
20235f8: c0 2f bf f4 clrb [ %fp + -12 ] <== NOT EXECUTED
handle->bnum = 0;
20235fc: c0 27 bf f8 clr [ %fp + -8 ] <== NOT EXECUTED
handle->buffer = NULL;
2023600: c0 27 bf fc clr [ %fp + -4 ] <== NOT EXECUTED
2023604: 7f ff fc b9 call 20228e8 <rtems_rfs_rtems_unlock> <== NOT EXECUTED
2023608: b0 10 20 00 clr %i0 <== NOT EXECUTED
}
rtems_rfs_shell_unlock_rfs (fs);
return 0;
}
202360c: 81 c7 e0 08 ret <== NOT EXECUTED
2023610: 81 e8 00 00 restore <== NOT EXECUTED
02022f64 <rtems_rfs_shell_data>:
return rc;
}
static int
rtems_rfs_shell_data (rtems_rfs_file_system* fs, int argc, char *argv[])
{
2022f64: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED
size_t blocks;
size_t inodes;
int bpcent;
int ipcent;
printf ("RFS Filesystem Data\n");
2022f68: 11 00 81 8b sethi %hi(0x2062c00), %o0 <== NOT EXECUTED
2022f6c: 40 00 8f 77 call 2046d48 <puts> <== NOT EXECUTED
2022f70: 90 12 21 70 or %o0, 0x170, %o0 ! 2062d70 <rtems_rfs_rtems_eval_config+0x238><== NOT EXECUTED
printf (" flags: %08" PRIx32 "\n", fs->flags);
2022f74: d2 06 00 00 ld [ %i0 ], %o1 <== NOT EXECUTED
2022f78: 11 00 81 8b sethi %hi(0x2062c00), %o0 <== NOT EXECUTED
2022f7c: 40 00 8e db call 2046ae8 <printf> <== NOT EXECUTED
2022f80: 90 12 21 88 or %o0, 0x188, %o0 ! 2062d88 <rtems_rfs_rtems_eval_config+0x250><== NOT EXECUTED
#if 0
printf (" device: %08lx\n", rtems_rfs_fs_device (fs));
#endif
printf (" blocks: %zu\n", rtems_rfs_fs_blocks (fs));
2022f84: d2 06 20 04 ld [ %i0 + 4 ], %o1 <== NOT EXECUTED
2022f88: 11 00 81 8b sethi %hi(0x2062c00), %o0 <== NOT EXECUTED
2022f8c: 40 00 8e d7 call 2046ae8 <printf> <== NOT EXECUTED
2022f90: 90 12 21 a8 or %o0, 0x1a8, %o0 ! 2062da8 <rtems_rfs_rtems_eval_config+0x270><== NOT EXECUTED
printf (" block size: %zu\n", rtems_rfs_fs_block_size (fs));
2022f94: d2 06 20 08 ld [ %i0 + 8 ], %o1 <== NOT EXECUTED
2022f98: 11 00 81 8b sethi %hi(0x2062c00), %o0 <== NOT EXECUTED
2022f9c: 40 00 8e d3 call 2046ae8 <printf> <== NOT EXECUTED
2022fa0: 90 12 21 c8 or %o0, 0x1c8, %o0 ! 2062dc8 <rtems_rfs_rtems_eval_config+0x290><== NOT EXECUTED
printf (" size: %" PRIu64 "\n", rtems_rfs_fs_size (fs));
2022fa4: 40 00 5b 82 call 2039dac <rtems_rfs_fs_size> <== NOT EXECUTED
2022fa8: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
2022fac: 84 10 00 08 mov %o0, %g2 <== NOT EXECUTED
2022fb0: 86 10 00 09 mov %o1, %g3 <== NOT EXECUTED
2022fb4: 11 00 81 8b sethi %hi(0x2062c00), %o0 <== NOT EXECUTED
2022fb8: 92 10 00 02 mov %g2, %o1 <== NOT EXECUTED
2022fbc: 94 10 00 03 mov %g3, %o2 <== NOT EXECUTED
2022fc0: 40 00 8e ca call 2046ae8 <printf> <== NOT EXECUTED
2022fc4: 90 12 21 e8 or %o0, 0x1e8, %o0 <== NOT EXECUTED
printf (" media block size: %" PRIu32 "\n", rtems_rfs_fs_media_block_size (fs));
2022fc8: c2 06 20 10 ld [ %i0 + 0x10 ], %g1 <== NOT EXECUTED
2022fcc: 11 00 81 8b sethi %hi(0x2062c00), %o0 <== NOT EXECUTED
2022fd0: d2 00 60 20 ld [ %g1 + 0x20 ], %o1 <== NOT EXECUTED
2022fd4: 40 00 8e c5 call 2046ae8 <printf> <== NOT EXECUTED
2022fd8: 90 12 22 08 or %o0, 0x208, %o0 <== NOT EXECUTED
printf (" media size: %" PRIu64 "\n", rtems_rfs_fs_media_size (fs));
2022fdc: 40 00 5b 7d call 2039dd0 <rtems_rfs_fs_media_size> <== NOT EXECUTED
2022fe0: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
2022fe4: 84 10 00 08 mov %o0, %g2 <== NOT EXECUTED
2022fe8: 86 10 00 09 mov %o1, %g3 <== NOT EXECUTED
2022fec: 11 00 81 8b sethi %hi(0x2062c00), %o0 <== NOT EXECUTED
2022ff0: 92 10 00 02 mov %g2, %o1 <== NOT EXECUTED
2022ff4: 94 10 00 03 mov %g3, %o2 <== NOT EXECUTED
2022ff8: 40 00 8e bc call 2046ae8 <printf> <== NOT EXECUTED
2022ffc: 90 12 22 28 or %o0, 0x228, %o0 <== NOT EXECUTED
printf (" inodes: %" PRIu32 "\n", rtems_rfs_fs_inodes (fs));
2023000: d2 06 20 14 ld [ %i0 + 0x14 ], %o1 <== NOT EXECUTED
2023004: 11 00 81 8b sethi %hi(0x2062c00), %o0 <== NOT EXECUTED
2023008: 40 00 8e b8 call 2046ae8 <printf> <== NOT EXECUTED
202300c: 90 12 22 48 or %o0, 0x248, %o0 ! 2062e48 <rtems_rfs_rtems_eval_config+0x310><== NOT EXECUTED
printf (" bad blocks: %" PRIu32 "\n", fs->bad_blocks);
2023010: d2 06 20 18 ld [ %i0 + 0x18 ], %o1 <== NOT EXECUTED
2023014: 11 00 81 8b sethi %hi(0x2062c00), %o0 <== NOT EXECUTED
2023018: 40 00 8e b4 call 2046ae8 <printf> <== NOT EXECUTED
202301c: 90 12 22 68 or %o0, 0x268, %o0 ! 2062e68 <rtems_rfs_rtems_eval_config+0x330><== NOT EXECUTED
printf (" max. name length: %" PRIu32 "\n", rtems_rfs_fs_max_name (fs));
2023020: d2 06 20 1c ld [ %i0 + 0x1c ], %o1 <== NOT EXECUTED
2023024: 11 00 81 8b sethi %hi(0x2062c00), %o0 <== NOT EXECUTED
2023028: 40 00 8e b0 call 2046ae8 <printf> <== NOT EXECUTED
202302c: 90 12 22 88 or %o0, 0x288, %o0 ! 2062e88 <rtems_rfs_rtems_eval_config+0x350><== NOT EXECUTED
printf (" groups: %d\n", fs->group_count);
2023030: d2 06 20 24 ld [ %i0 + 0x24 ], %o1 <== NOT EXECUTED
2023034: 11 00 81 8b sethi %hi(0x2062c00), %o0 <== NOT EXECUTED
2023038: 40 00 8e ac call 2046ae8 <printf> <== NOT EXECUTED
202303c: 90 12 22 a8 or %o0, 0x2a8, %o0 ! 2062ea8 <rtems_rfs_rtems_eval_config+0x370><== NOT EXECUTED
printf (" group blocks: %zd\n", fs->group_blocks);
2023040: d2 06 20 28 ld [ %i0 + 0x28 ], %o1 <== NOT EXECUTED
2023044: 11 00 81 8b sethi %hi(0x2062c00), %o0 <== NOT EXECUTED
2023048: 40 00 8e a8 call 2046ae8 <printf> <== NOT EXECUTED
202304c: 90 12 22 c0 or %o0, 0x2c0, %o0 ! 2062ec0 <rtems_rfs_rtems_eval_config+0x388><== NOT EXECUTED
printf (" group inodes: %zd\n", fs->group_inodes);
2023050: d2 06 20 2c ld [ %i0 + 0x2c ], %o1 <== NOT EXECUTED
2023054: 11 00 81 8b sethi %hi(0x2062c00), %o0 <== NOT EXECUTED
2023058: 40 00 8e a4 call 2046ae8 <printf> <== NOT EXECUTED
202305c: 90 12 22 e0 or %o0, 0x2e0, %o0 ! 2062ee0 <rtems_rfs_rtems_eval_config+0x3a8><== NOT EXECUTED
printf (" inodes per block: %zd\n", fs->inodes_per_block);
2023060: d2 06 20 30 ld [ %i0 + 0x30 ], %o1 <== NOT EXECUTED
2023064: 11 00 81 8b sethi %hi(0x2062c00), %o0 <== NOT EXECUTED
2023068: 40 00 8e a0 call 2046ae8 <printf> <== NOT EXECUTED
202306c: 90 12 23 00 or %o0, 0x300, %o0 ! 2062f00 <rtems_rfs_rtems_eval_config+0x3c8><== NOT EXECUTED
printf (" blocks per block: %zd\n", fs->blocks_per_block);
2023070: d2 06 20 34 ld [ %i0 + 0x34 ], %o1 <== NOT EXECUTED
2023074: 11 00 81 8b sethi %hi(0x2062c00), %o0 <== NOT EXECUTED
2023078: 40 00 8e 9c call 2046ae8 <printf> <== NOT EXECUTED
202307c: 90 12 23 20 or %o0, 0x320, %o0 ! 2062f20 <rtems_rfs_rtems_eval_config+0x3e8><== NOT EXECUTED
printf (" singly blocks: %zd\n", fs->block_map_singly_blocks);
2023080: d2 06 20 38 ld [ %i0 + 0x38 ], %o1 <== NOT EXECUTED
2023084: 11 00 81 8b sethi %hi(0x2062c00), %o0 <== NOT EXECUTED
2023088: 40 00 8e 98 call 2046ae8 <printf> <== NOT EXECUTED
202308c: 90 12 23 40 or %o0, 0x340, %o0 ! 2062f40 <rtems_rfs_rtems_eval_config+0x408><== NOT EXECUTED
printf (" doublly blocks: %zd\n", fs->block_map_doubly_blocks);
2023090: d2 06 20 3c ld [ %i0 + 0x3c ], %o1 <== NOT EXECUTED
2023094: 11 00 81 8b sethi %hi(0x2062c00), %o0 <== NOT EXECUTED
2023098: 40 00 8e 94 call 2046ae8 <printf> <== NOT EXECUTED
202309c: 90 12 23 60 or %o0, 0x360, %o0 ! 2062f60 <rtems_rfs_rtems_eval_config+0x428><== NOT EXECUTED
printf (" max. held buffers: %" PRId32 "\n", fs->max_held_buffers);
20230a0: d2 06 20 40 ld [ %i0 + 0x40 ], %o1 <== NOT EXECUTED
20230a4: 11 00 81 8b sethi %hi(0x2062c00), %o0 <== NOT EXECUTED
20230a8: 40 00 8e 90 call 2046ae8 <printf> <== NOT EXECUTED
20230ac: 90 12 23 80 or %o0, 0x380, %o0 ! 2062f80 <rtems_rfs_rtems_eval_config+0x448><== NOT EXECUTED
*/
static void
rtems_rfs_shell_lock_rfs (rtems_rfs_file_system* fs)
{
#if __rtems__
rtems_rfs_rtems_lock (fs);
20230b0: 7f ff fd f9 call 2022894 <rtems_rfs_rtems_lock> <== NOT EXECUTED
20230b4: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
printf (" doublly blocks: %zd\n", fs->block_map_doubly_blocks);
printf (" max. held buffers: %" PRId32 "\n", fs->max_held_buffers);
rtems_rfs_shell_lock_rfs (fs);
rtems_rfs_group_usage (fs, &blocks, &inodes);
20230b8: 94 07 bf fc add %fp, -4, %o2 <== NOT EXECUTED
20230bc: 92 07 bf f8 add %fp, -8, %o1 <== NOT EXECUTED
20230c0: 40 00 62 56 call 203ba18 <rtems_rfs_group_usage> <== NOT EXECUTED
20230c4: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
*/
static void
rtems_rfs_shell_unlock_rfs (rtems_rfs_file_system* fs)
{
#if __rtems__
rtems_rfs_rtems_unlock (fs);
20230c8: 7f ff fe 08 call 20228e8 <rtems_rfs_rtems_unlock> <== NOT EXECUTED
20230cc: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
rtems_rfs_group_usage (fs, &blocks, &inodes);
rtems_rfs_shell_unlock_rfs (fs);
bpcent = (blocks * 1000) / rtems_rfs_fs_blocks (fs);
20230d0: fa 07 bf f8 ld [ %fp + -8 ], %i5 <== NOT EXECUTED
20230d4: d2 06 20 04 ld [ %i0 + 4 ], %o1 <== NOT EXECUTED
20230d8: 83 2f 60 02 sll %i5, 2, %g1 <== NOT EXECUTED
20230dc: 91 2f 60 07 sll %i5, 7, %o0 <== NOT EXECUTED
20230e0: 90 22 00 01 sub %o0, %g1, %o0 <== NOT EXECUTED
20230e4: 90 02 00 1d add %o0, %i5, %o0 <== NOT EXECUTED
20230e8: 40 00 e1 26 call 205b580 <.udiv> <== NOT EXECUTED
20230ec: 91 2a 20 03 sll %o0, 3, %o0 <== NOT EXECUTED
ipcent = (inodes * 1000) / rtems_rfs_fs_inodes (fs);
20230f0: c2 07 bf fc ld [ %fp + -4 ], %g1 <== NOT EXECUTED
20230f4: d2 06 20 14 ld [ %i0 + 0x14 ], %o1 <== NOT EXECUTED
20230f8: 85 28 60 02 sll %g1, 2, %g2 <== NOT EXECUTED
20230fc: 87 28 60 07 sll %g1, 7, %g3 <== NOT EXECUTED
2023100: 84 20 c0 02 sub %g3, %g2, %g2 <== NOT EXECUTED
rtems_rfs_group_usage (fs, &blocks, &inodes);
rtems_rfs_shell_unlock_rfs (fs);
bpcent = (blocks * 1000) / rtems_rfs_fs_blocks (fs);
2023104: b6 10 00 08 mov %o0, %i3 <== NOT EXECUTED
ipcent = (inodes * 1000) / rtems_rfs_fs_inodes (fs);
2023108: 90 00 80 01 add %g2, %g1, %o0 <== NOT EXECUTED
202310c: 40 00 e1 1d call 205b580 <.udiv> <== NOT EXECUTED
2023110: 91 2a 20 03 sll %o0, 3, %o0 <== NOT EXECUTED
printf (" blocks used: %zd (%d.%d%%)\n",
2023114: 92 10 20 0a mov 0xa, %o1 <== NOT EXECUTED
rtems_rfs_group_usage (fs, &blocks, &inodes);
rtems_rfs_shell_unlock_rfs (fs);
bpcent = (blocks * 1000) / rtems_rfs_fs_blocks (fs);
ipcent = (inodes * 1000) / rtems_rfs_fs_inodes (fs);
2023118: b8 10 00 08 mov %o0, %i4 <== NOT EXECUTED
printf (" blocks used: %zd (%d.%d%%)\n",
202311c: 40 00 e1 1b call 205b588 <.div> <== NOT EXECUTED
2023120: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
2023124: 92 10 20 0a mov 0xa, %o1 <== NOT EXECUTED
2023128: b4 10 00 08 mov %o0, %i2 <== NOT EXECUTED
202312c: 40 00 e1 c3 call 205b838 <.rem> <== NOT EXECUTED
2023130: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
2023134: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED
2023138: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
202313c: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
2023140: 11 00 81 8b sethi %hi(0x2062c00), %o0 <== NOT EXECUTED
2023144: 40 00 8e 69 call 2046ae8 <printf> <== NOT EXECUTED
2023148: 90 12 23 a0 or %o0, 0x3a0, %o0 ! 2062fa0 <rtems_rfs_rtems_eval_config+0x468><== NOT EXECUTED
blocks, bpcent / 10, bpcent % 10);
printf (" inodes used: %zd (%d.%d%%)\n",
202314c: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
2023150: f6 07 bf fc ld [ %fp + -4 ], %i3 <== NOT EXECUTED
2023154: 40 00 e1 0d call 205b588 <.div> <== NOT EXECUTED
2023158: 92 10 20 0a mov 0xa, %o1 <== NOT EXECUTED
202315c: 92 10 20 0a mov 0xa, %o1 <== NOT EXECUTED
2023160: ba 10 00 08 mov %o0, %i5 <== NOT EXECUTED
2023164: 40 00 e1 b5 call 205b838 <.rem> <== NOT EXECUTED
2023168: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
202316c: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
2023170: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
2023174: 94 10 00 1d mov %i5, %o2 <== NOT EXECUTED
2023178: 11 00 81 8b sethi %hi(0x2062c00), %o0 <== NOT EXECUTED
inodes, ipcent / 10, ipcent % 10);
return 0;
}
202317c: b0 10 20 00 clr %i0 <== NOT EXECUTED
bpcent = (blocks * 1000) / rtems_rfs_fs_blocks (fs);
ipcent = (inodes * 1000) / rtems_rfs_fs_inodes (fs);
printf (" blocks used: %zd (%d.%d%%)\n",
blocks, bpcent / 10, bpcent % 10);
printf (" inodes used: %zd (%d.%d%%)\n",
2023180: 40 00 8e 5a call 2046ae8 <printf> <== NOT EXECUTED
2023184: 90 12 23 c8 or %o0, 0x3c8, %o0 <== NOT EXECUTED
inodes, ipcent / 10, ipcent % 10);
return 0;
}
2023188: 81 c7 e0 08 ret <== NOT EXECUTED
202318c: 81 e8 00 00 restore <== NOT EXECUTED
02023190 <rtems_rfs_shell_dir>:
return 0;
}
static int
rtems_rfs_shell_dir (rtems_rfs_file_system* fs, int argc, char *argv[])
{
2023190: 9d e3 bf 90 save %sp, -112, %sp <== NOT EXECUTED
bool state;
int entry;
int b;
int rc;
if (argc <= 1)
2023194: 80 a6 60 01 cmp %i1, 1 <== NOT EXECUTED
2023198: 34 80 00 07 bg,a 20231b4 <rtems_rfs_shell_dir+0x24> <== NOT EXECUTED
202319c: d0 06 a0 04 ld [ %i2 + 4 ], %o0 <== NOT EXECUTED
{
printf ("error: no block number provided\n");
20231a0: 11 00 81 8c sethi %hi(0x2063000), %o0 <== NOT EXECUTED
20231a4: 40 00 8e e9 call 2046d48 <puts> <== NOT EXECUTED
20231a8: 90 12 20 00 mov %o0, %o0 ! 2063000 <rtems_rfs_rtems_eval_config+0x4c8><== NOT EXECUTED
{
rtems_rfs_buffer_handle_close (fs, &buffer);
rtems_rfs_shell_unlock_rfs (fs);
printf ("error: requesting buffer handle: block=%" PRIu32 ": (%d) %s\n",
block, rc, strerror (rc));
return 1;
20231ac: 81 c7 e0 08 ret <== NOT EXECUTED
20231b0: 91 e8 20 01 restore %g0, 1, %o0 <== NOT EXECUTED
{
printf ("error: no block number provided\n");
return 1;
}
block = strtoul (argv[1], 0, 0);
20231b4: 92 10 20 00 clr %o1 <== NOT EXECUTED
20231b8: 40 00 9e 47 call 204aad4 <strtoul> <== NOT EXECUTED
20231bc: 94 10 20 00 clr %o2 <== NOT EXECUTED
20231c0: ba 10 00 08 mov %o0, %i5 <== NOT EXECUTED
*/
static void
rtems_rfs_shell_lock_rfs (rtems_rfs_file_system* fs)
{
#if __rtems__
rtems_rfs_rtems_lock (fs);
20231c4: 7f ff fd b4 call 2022894 <rtems_rfs_rtems_lock> <== NOT EXECUTED
20231c8: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
block = strtoul (argv[1], 0, 0);
rtems_rfs_shell_lock_rfs (fs);
rc = rtems_rfs_group_bitmap_test (fs, false, block, &state);
20231cc: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
20231d0: 92 10 20 00 clr %o1 <== NOT EXECUTED
20231d4: 94 10 00 1d mov %i5, %o2 <== NOT EXECUTED
20231d8: 40 00 61 d3 call 203b924 <rtems_rfs_group_bitmap_test> <== NOT EXECUTED
20231dc: 96 07 bf f3 add %fp, -13, %o3 <== NOT EXECUTED
if (rc > 0)
20231e0: b8 92 20 00 orcc %o0, 0, %i4 <== NOT EXECUTED
20231e4: 04 80 00 0a ble 202320c <rtems_rfs_shell_dir+0x7c> <== NOT EXECUTED
20231e8: c2 0f bf f3 ldub [ %fp + -13 ], %g1 <== NOT EXECUTED
*/
static void
rtems_rfs_shell_unlock_rfs (rtems_rfs_file_system* fs)
{
#if __rtems__
rtems_rfs_rtems_unlock (fs);
20231ec: 7f ff fd bf call 20228e8 <rtems_rfs_rtems_unlock> <== NOT EXECUTED
20231f0: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
rc = rtems_rfs_group_bitmap_test (fs, false, block, &state);
if (rc > 0)
{
rtems_rfs_shell_unlock_rfs (fs);
printf ("error: testing block state: block=%" PRIu32 ": (%d) %s\n",
20231f4: 40 00 97 bc call 20490e4 <strerror> <== NOT EXECUTED
20231f8: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
20231fc: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
2023200: 11 00 81 8c sethi %hi(0x2063000), %o0 <== NOT EXECUTED
2023204: 10 80 00 25 b 2023298 <rtems_rfs_shell_dir+0x108> <== NOT EXECUTED
2023208: 90 12 20 20 or %o0, 0x20, %o0 ! 2063020 <rtems_rfs_rtems_eval_config+0x4e8><== NOT EXECUTED
block, rc, strerror (rc));
return 1;
}
printf (" %5" PRIu32 ": block %s\n", block, state ? "allocated" : "free");
202320c: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
2023210: 22 80 00 05 be,a 2023224 <rtems_rfs_shell_dir+0x94> <== NOT EXECUTED
2023214: 15 00 81 82 sethi %hi(0x2060800), %o2 <== NOT EXECUTED
2023218: 15 00 81 8b sethi %hi(0x2062c00), %o2 <== NOT EXECUTED
202321c: 10 80 00 03 b 2023228 <rtems_rfs_shell_dir+0x98> <== NOT EXECUTED
2023220: 94 12 a3 f0 or %o2, 0x3f0, %o2 ! 2062ff0 <rtems_rfs_rtems_eval_config+0x4b8><== NOT EXECUTED
2023224: 94 12 a1 f8 or %o2, 0x1f8, %o2 <== NOT EXECUTED
2023228: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
202322c: 11 00 81 8c sethi %hi(0x2063000), %o0 <== NOT EXECUTED
2023230: 40 00 8e 2e call 2046ae8 <printf> <== NOT EXECUTED
2023234: 90 12 20 50 or %o0, 0x50, %o0 ! 2063050 <rtems_rfs_rtems_eval_config+0x518><== NOT EXECUTED
printf ("error: opening buffer handle: block=%" PRIu32 ": (%d) %s\n",
block, rc, strerror (rc));
return 1;
}
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, true);
2023238: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
202323c: c0 2f bf f4 clrb [ %fp + -12 ] <== NOT EXECUTED
handle->bnum = 0;
2023240: c0 27 bf f8 clr [ %fp + -8 ] <== NOT EXECUTED
handle->buffer = NULL;
2023244: c0 27 bf fc clr [ %fp + -4 ] <== NOT EXECUTED
2023248: 92 07 bf f4 add %fp, -12, %o1 <== NOT EXECUTED
202324c: 94 10 00 1d mov %i5, %o2 <== NOT EXECUTED
2023250: 40 00 50 c7 call 203756c <rtems_rfs_buffer_handle_request><== NOT EXECUTED
2023254: 96 10 20 01 mov 1, %o3 <== NOT EXECUTED
if (rc > 0)
2023258: b8 92 20 00 orcc %o0, 0, %i4 <== NOT EXECUTED
202325c: 04 80 00 14 ble 20232ac <rtems_rfs_shell_dir+0x11c> <== NOT EXECUTED
2023260: c2 07 bf fc ld [ %fp + -4 ], %g1 <== 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);
2023264: 92 07 bf f4 add %fp, -12, %o1 <== NOT EXECUTED
2023268: 40 00 50 4d call 203739c <rtems_rfs_buffer_handle_release><== NOT EXECUTED
202326c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
*/
static void
rtems_rfs_shell_unlock_rfs (rtems_rfs_file_system* fs)
{
#if __rtems__
rtems_rfs_rtems_unlock (fs);
2023270: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
handle->dirty = false;
2023274: c0 2f bf f4 clrb [ %fp + -12 ] <== NOT EXECUTED
handle->bnum = 0;
2023278: c0 27 bf f8 clr [ %fp + -8 ] <== NOT EXECUTED
202327c: 7f ff fd 9b call 20228e8 <rtems_rfs_rtems_unlock> <== NOT EXECUTED
2023280: c0 27 bf fc clr [ %fp + -4 ] <== NOT EXECUTED
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, true);
if (rc > 0)
{
rtems_rfs_buffer_handle_close (fs, &buffer);
rtems_rfs_shell_unlock_rfs (fs);
printf ("error: requesting buffer handle: block=%" PRIu32 ": (%d) %s\n",
2023284: 40 00 97 98 call 20490e4 <strerror> <== NOT EXECUTED
2023288: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
202328c: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
2023290: 11 00 81 8c sethi %hi(0x2063000), %o0 <== NOT EXECUTED
2023294: 90 12 20 68 or %o0, 0x68, %o0 ! 2063068 <rtems_rfs_rtems_eval_config+0x530><== NOT EXECUTED
2023298: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
202329c: 40 00 8e 13 call 2046ae8 <printf> <== NOT EXECUTED
20232a0: 94 10 00 1c mov %i4, %o2 <== NOT EXECUTED
block, rc, strerror (rc));
return 1;
20232a4: 81 c7 e0 08 ret <== NOT EXECUTED
20232a8: 91 e8 20 01 restore %g0, 1, %o0 <== NOT EXECUTED
int c;
eino = rtems_rfs_dir_entry_ino (data);
elength = rtems_rfs_dir_entry_length (data);
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
20232ac: 25 00 00 3f sethi %hi(0xfc00), %l2 <== NOT EXECUTED
break;
}
length = elength - RTEMS_RFS_DIR_ENTRY_SIZE;
printf (" %5d: %04x inode=%-6" PRIu32 " hash=%08" PRIx32 " name[%03u]=",
20232b0: 27 00 81 8c sethi %hi(0x2063000), %l3 <== NOT EXECUTED
length = 50;
for (c = 0; c < length; c++)
printf ("%c", data[RTEMS_RFS_DIR_ENTRY_SIZE + c]);
if (length < elength - RTEMS_RFS_DIR_ENTRY_SIZE)
printf ("...");
20232b4: 29 00 81 8c sethi %hi(0x2063000), %l4 <== NOT EXECUTED
return 1;
}
b = 0;
entry = 1;
data = rtems_rfs_buffer_data (&buffer);
20232b8: fa 00 60 1c ld [ %g1 + 0x1c ], %i5 <== NOT EXECUTED
printf ("error: requesting buffer handle: block=%" PRIu32 ": (%d) %s\n",
block, rc, strerror (rc));
return 1;
}
b = 0;
20232bc: b4 10 20 00 clr %i2 <== NOT EXECUTED
entry = 1;
20232c0: b6 10 20 01 mov 1, %i3 <== NOT EXECUTED
int c;
eino = rtems_rfs_dir_entry_ino (data);
elength = rtems_rfs_dir_entry_length (data);
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
20232c4: a4 14 a3 ff or %l2, 0x3ff, %l2 <== NOT EXECUTED
break;
}
length = elength - RTEMS_RFS_DIR_ENTRY_SIZE;
printf (" %5d: %04x inode=%-6" PRIu32 " hash=%08" PRIx32 " name[%03u]=",
20232c8: a6 14 e0 f8 or %l3, 0xf8, %l3 <== NOT EXECUTED
b = 0;
entry = 1;
data = rtems_rfs_buffer_data (&buffer);
while (b < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE - 1))
20232cc: 10 80 00 4f b 2023408 <rtems_rfs_shell_dir+0x278> <== NOT EXECUTED
20232d0: a8 15 21 28 or %l4, 0x128, %l4 <== NOT EXECUTED
rtems_rfs_ino eino;
int elength;
int length;
int c;
eino = rtems_rfs_dir_entry_ino (data);
20232d4: d6 0f 40 00 ldub [ %i5 ], %o3 <== NOT EXECUTED
20232d8: 83 28 60 10 sll %g1, 0x10, %g1 <== NOT EXECUTED
20232dc: 97 2a e0 18 sll %o3, 0x18, %o3 <== NOT EXECUTED
20232e0: 96 12 c0 01 or %o3, %g1, %o3 <== NOT EXECUTED
20232e4: c2 0f 60 03 ldub [ %i5 + 3 ], %g1 <== NOT EXECUTED
elength = rtems_rfs_dir_entry_length (data);
20232e8: f8 0f 60 08 ldub [ %i5 + 8 ], %i4 <== NOT EXECUTED
rtems_rfs_ino eino;
int elength;
int length;
int c;
eino = rtems_rfs_dir_entry_ino (data);
20232ec: 96 12 c0 01 or %o3, %g1, %o3 <== NOT EXECUTED
20232f0: c2 0f 60 02 ldub [ %i5 + 2 ], %g1 <== NOT EXECUTED
elength = rtems_rfs_dir_entry_length (data);
20232f4: b9 2f 20 08 sll %i4, 8, %i4 <== NOT EXECUTED
rtems_rfs_ino eino;
int elength;
int length;
int c;
eino = rtems_rfs_dir_entry_ino (data);
20232f8: 83 28 60 08 sll %g1, 8, %g1 <== NOT EXECUTED
20232fc: 96 12 c0 01 or %o3, %g1, %o3 <== NOT EXECUTED
elength = rtems_rfs_dir_entry_length (data);
2023300: c2 0f 60 09 ldub [ %i5 + 9 ], %g1 <== NOT EXECUTED
2023304: b8 17 00 01 or %i4, %g1, %i4 <== NOT EXECUTED
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
2023308: 80 a7 00 12 cmp %i4, %l2 <== NOT EXECUTED
202330c: 02 80 00 44 be 202341c <rtems_rfs_shell_dir+0x28c> <== NOT EXECUTED
2023310: 80 a7 20 09 cmp %i4, 9 <== NOT EXECUTED
break;
if ((elength < RTEMS_RFS_DIR_ENTRY_SIZE) ||
2023314: 34 80 00 07 bg,a 2023330 <rtems_rfs_shell_dir+0x1a0> <== NOT EXECUTED
2023318: c2 06 20 1c ld [ %i0 + 0x1c ], %g1 <== NOT EXECUTED
(elength >= rtems_rfs_fs_max_name (fs)))
{
printf (" %5d: entry length appears corrupt: %d\n", entry, elength);
202331c: 11 00 81 8c sethi %hi(0x2063000), %o0 <== NOT EXECUTED
2023320: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
2023324: 90 12 20 a0 or %o0, 0xa0, %o0 <== NOT EXECUTED
2023328: 10 80 00 0f b 2023364 <rtems_rfs_shell_dir+0x1d4> <== NOT EXECUTED
202332c: 94 10 00 1c mov %i4, %o2 <== NOT EXECUTED
elength = rtems_rfs_dir_entry_length (data);
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
break;
if ((elength < RTEMS_RFS_DIR_ENTRY_SIZE) ||
2023330: 80 a7 00 01 cmp %i4, %g1 <== NOT EXECUTED
2023334: 1a bf ff fa bcc 202331c <rtems_rfs_shell_dir+0x18c> <== NOT EXECUTED
2023338: 80 a2 e0 00 cmp %o3, 0 <== NOT EXECUTED
{
printf (" %5d: entry length appears corrupt: %d\n", entry, elength);
break;
}
if ((eino < RTEMS_RFS_ROOT_INO) || (eino >= rtems_rfs_fs_inodes (fs)))
202333c: 02 80 00 07 be 2023358 <rtems_rfs_shell_dir+0x1c8> <== NOT EXECUTED
2023340: 11 00 81 8c sethi %hi(0x2063000), %o0 <== NOT EXECUTED
2023344: c2 06 20 14 ld [ %i0 + 0x14 ], %g1 <== NOT EXECUTED
2023348: 80 a2 c0 01 cmp %o3, %g1 <== NOT EXECUTED
202334c: 2a 80 00 0a bcs,a 2023374 <rtems_rfs_shell_dir+0x1e4> <== NOT EXECUTED
2023350: c2 0f 60 05 ldub [ %i5 + 5 ], %g1 <== NOT EXECUTED
{
printf (" %5d: entry ino appears corrupt: ino=%" PRId32 "\n", entry, eino);
2023354: 11 00 81 8c sethi %hi(0x2063000), %o0 <== NOT EXECUTED
2023358: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
202335c: 90 12 20 c8 or %o0, 0xc8, %o0 <== NOT EXECUTED
2023360: 94 10 00 0b mov %o3, %o2 <== NOT EXECUTED
2023364: 40 00 8d e1 call 2046ae8 <printf> <== NOT EXECUTED
2023368: 01 00 00 00 nop <== NOT EXECUTED
break;
202336c: 10 80 00 2d b 2023420 <rtems_rfs_shell_dir+0x290> <== NOT EXECUTED
2023370: 92 07 bf f4 add %fp, -12, %o1 <== NOT EXECUTED
length = elength - RTEMS_RFS_DIR_ENTRY_SIZE;
printf (" %5d: %04x inode=%-6" PRIu32 " hash=%08" PRIx32 " name[%03u]=",
entry, b,
rtems_rfs_dir_entry_ino (data),
rtems_rfs_dir_entry_hash (data),
2023374: d8 0f 60 04 ldub [ %i5 + 4 ], %o4 <== NOT EXECUTED
2023378: 83 28 60 10 sll %g1, 0x10, %g1 <== NOT EXECUTED
202337c: 99 2b 20 18 sll %o4, 0x18, %o4 <== NOT EXECUTED
2023380: 98 13 00 01 or %o4, %g1, %o4 <== NOT EXECUTED
2023384: c2 0f 60 07 ldub [ %i5 + 7 ], %g1 <== NOT EXECUTED
{
printf (" %5d: entry ino appears corrupt: ino=%" PRId32 "\n", entry, eino);
break;
}
length = elength - RTEMS_RFS_DIR_ENTRY_SIZE;
2023388: b2 07 3f f6 add %i4, -10, %i1 <== NOT EXECUTED
printf (" %5d: %04x inode=%-6" PRIu32 " hash=%08" PRIx32 " name[%03u]=",
entry, b,
rtems_rfs_dir_entry_ino (data),
rtems_rfs_dir_entry_hash (data),
202338c: 98 13 00 01 or %o4, %g1, %o4 <== NOT EXECUTED
2023390: c2 0f 60 06 ldub [ %i5 + 6 ], %g1 <== NOT EXECUTED
break;
}
length = elength - RTEMS_RFS_DIR_ENTRY_SIZE;
printf (" %5d: %04x inode=%-6" PRIu32 " hash=%08" PRIx32 " name[%03u]=",
2023394: 90 10 00 13 mov %l3, %o0 <== NOT EXECUTED
entry, b,
rtems_rfs_dir_entry_ino (data),
rtems_rfs_dir_entry_hash (data),
2023398: 83 28 60 08 sll %g1, 8, %g1 <== NOT EXECUTED
break;
}
length = elength - RTEMS_RFS_DIR_ENTRY_SIZE;
printf (" %5d: %04x inode=%-6" PRIu32 " hash=%08" PRIx32 " name[%03u]=",
202339c: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
20233a0: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED
20233a4: 98 13 00 01 or %o4, %g1, %o4 <== NOT EXECUTED
20233a8: 40 00 8d d0 call 2046ae8 <printf> <== NOT EXECUTED
20233ac: 9a 10 00 19 mov %i1, %o5 <== NOT EXECUTED
20233b0: 80 a6 60 32 cmp %i1, 0x32 <== NOT EXECUTED
20233b4: 04 80 00 03 ble 20233c0 <rtems_rfs_shell_dir+0x230> <== NOT EXECUTED
20233b8: a2 10 00 19 mov %i1, %l1 <== NOT EXECUTED
20233bc: a2 10 20 32 mov 0x32, %l1 <== NOT EXECUTED
length);
if (length > 50)
length = 50;
for (c = 0; c < length; c++)
20233c0: 10 80 00 05 b 20233d4 <rtems_rfs_shell_dir+0x244> <== NOT EXECUTED
20233c4: a0 10 20 00 clr %l0 <== NOT EXECUTED
printf ("%c", data[RTEMS_RFS_DIR_ENTRY_SIZE + c]);
20233c8: d0 08 60 0a ldub [ %g1 + 0xa ], %o0 <== NOT EXECUTED
20233cc: 40 00 8e 31 call 2046c90 <putchar> <== NOT EXECUTED
20233d0: a0 04 20 01 inc %l0 <== NOT EXECUTED
length);
if (length > 50)
length = 50;
for (c = 0; c < length; c++)
20233d4: 80 a4 00 11 cmp %l0, %l1 <== NOT EXECUTED
20233d8: 06 bf ff fc bl 20233c8 <rtems_rfs_shell_dir+0x238> <== NOT EXECUTED
20233dc: 82 07 40 10 add %i5, %l0, %g1 <== NOT EXECUTED
printf ("%c", data[RTEMS_RFS_DIR_ENTRY_SIZE + c]);
if (length < elength - RTEMS_RFS_DIR_ENTRY_SIZE)
20233e0: 80 a4 40 19 cmp %l1, %i1 <== NOT EXECUTED
20233e4: 16 80 00 05 bge 20233f8 <rtems_rfs_shell_dir+0x268> <== NOT EXECUTED
20233e8: 90 10 20 0a mov 0xa, %o0 <== NOT EXECUTED
printf ("...");
20233ec: 40 00 8d bf call 2046ae8 <printf> <== NOT EXECUTED
20233f0: 90 10 00 14 mov %l4, %o0 <== NOT EXECUTED
printf ("\n");
20233f4: 90 10 20 0a mov 0xa, %o0 <== NOT EXECUTED
20233f8: 40 00 8e 26 call 2046c90 <putchar> <== NOT EXECUTED
20233fc: b4 06 80 1c add %i2, %i4, %i2 <== NOT EXECUTED
b += elength;
data += elength;
2023400: ba 07 40 1c add %i5, %i4, %i5 <== NOT EXECUTED
entry++;
2023404: b6 06 e0 01 inc %i3 <== NOT EXECUTED
b = 0;
entry = 1;
data = rtems_rfs_buffer_data (&buffer);
while (b < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE - 1))
2023408: c2 06 20 08 ld [ %i0 + 8 ], %g1 <== NOT EXECUTED
202340c: 82 00 7f f5 add %g1, -11, %g1 <== NOT EXECUTED
2023410: 80 a6 80 01 cmp %i2, %g1 <== NOT EXECUTED
2023414: 2a bf ff b0 bcs,a 20232d4 <rtems_rfs_shell_dir+0x144> <== NOT EXECUTED
2023418: c2 0f 60 01 ldub [ %i5 + 1 ], %g1 <== 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);
202341c: 92 07 bf f4 add %fp, -12, %o1 <== NOT EXECUTED
2023420: 40 00 4f df call 203739c <rtems_rfs_buffer_handle_release><== NOT EXECUTED
2023424: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
*/
static void
rtems_rfs_shell_unlock_rfs (rtems_rfs_file_system* fs)
{
#if __rtems__
rtems_rfs_rtems_unlock (fs);
2023428: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
handle->dirty = false;
202342c: c0 2f bf f4 clrb [ %fp + -12 ] <== NOT EXECUTED
handle->bnum = 0;
2023430: c0 27 bf f8 clr [ %fp + -8 ] <== NOT EXECUTED
handle->buffer = NULL;
2023434: c0 27 bf fc clr [ %fp + -4 ] <== NOT EXECUTED
2023438: 7f ff fd 2c call 20228e8 <rtems_rfs_rtems_unlock> <== NOT EXECUTED
202343c: b0 10 20 00 clr %i0 <== NOT EXECUTED
}
rtems_rfs_shell_unlock_rfs (fs);
return 0;
}
2023440: 81 c7 e0 08 ret <== NOT EXECUTED
2023444: 81 e8 00 00 restore <== NOT EXECUTED
02022dc8 <rtems_rfs_shell_group>:
return 0;
}
static int
rtems_rfs_shell_group (rtems_rfs_file_system* fs, int argc, char *argv[])
{
2022dc8: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED
int g;
start = 0;
end = fs->group_count - 1;
switch (argc)
2022dcc: 80 a6 60 02 cmp %i1, 2 <== NOT EXECUTED
2022dd0: 02 80 00 09 be 2022df4 <rtems_rfs_shell_group+0x2c> <== NOT EXECUTED
2022dd4: f8 06 20 24 ld [ %i0 + 0x24 ], %i4 <== NOT EXECUTED
2022dd8: 80 a6 60 03 cmp %i1, 3 <== NOT EXECUTED
2022ddc: 02 80 00 0d be 2022e10 <rtems_rfs_shell_group+0x48> <== NOT EXECUTED
2022de0: 80 a6 60 01 cmp %i1, 1 <== NOT EXECUTED
2022de4: 12 80 00 16 bne 2022e3c <rtems_rfs_shell_group+0x74> <== NOT EXECUTED
2022de8: 11 00 81 8b sethi %hi(0x2062c00), %o0 <== NOT EXECUTED
int start;
int end;
int g;
start = 0;
end = fs->group_count - 1;
2022dec: 10 80 00 18 b 2022e4c <rtems_rfs_shell_group+0x84> <== NOT EXECUTED
2022df0: b8 07 3f ff add %i4, -1, %i4 <== NOT EXECUTED
switch (argc)
{
case 1:
break;
case 2:
start = end = strtoul (argv[1], 0, 0);
2022df4: d0 06 a0 04 ld [ %i2 + 4 ], %o0 <== NOT EXECUTED
2022df8: 92 10 20 00 clr %o1 <== NOT EXECUTED
2022dfc: 40 00 9f 36 call 204aad4 <strtoul> <== NOT EXECUTED
2022e00: 94 10 20 00 clr %o2 <== NOT EXECUTED
2022e04: b8 10 00 08 mov %o0, %i4 <== NOT EXECUTED
break;
2022e08: 10 80 00 12 b 2022e50 <rtems_rfs_shell_group+0x88> <== NOT EXECUTED
2022e0c: ba 10 00 08 mov %o0, %i5 <== NOT EXECUTED
case 3:
start = strtoul (argv[1], 0, 0);
2022e10: d0 06 a0 04 ld [ %i2 + 4 ], %o0 <== NOT EXECUTED
2022e14: 92 10 20 00 clr %o1 <== NOT EXECUTED
2022e18: 40 00 9f 2f call 204aad4 <strtoul> <== NOT EXECUTED
2022e1c: 94 10 20 00 clr %o2 <== NOT EXECUTED
2022e20: ba 10 00 08 mov %o0, %i5 <== NOT EXECUTED
end = strtoul (argv[2], 0, 0);
2022e24: d0 06 a0 08 ld [ %i2 + 8 ], %o0 <== NOT EXECUTED
2022e28: 92 10 20 00 clr %o1 <== NOT EXECUTED
2022e2c: 40 00 9f 2a call 204aad4 <strtoul> <== NOT EXECUTED
2022e30: 94 10 20 00 clr %o2 <== NOT EXECUTED
break;
2022e34: 10 80 00 07 b 2022e50 <rtems_rfs_shell_group+0x88> <== NOT EXECUTED
2022e38: b8 10 00 08 mov %o0, %i4 <== NOT EXECUTED
default:
printf ("error: too many arguments.\n");
2022e3c: 40 00 8f c3 call 2046d48 <puts> <== NOT EXECUTED
2022e40: 90 12 20 e0 or %o0, 0xe0, %o0 <== NOT EXECUTED
if ((start < 0) || (end < 0) ||
(start >= fs->group_count) || (end >= fs->group_count))
{
printf ("error: group out of range (0->%d).\n", fs->group_count);
return 1;
2022e44: 81 c7 e0 08 ret <== NOT EXECUTED
2022e48: 91 e8 20 01 restore %g0, 1, %o0 <== NOT EXECUTED
{
int start;
int end;
int g;
start = 0;
2022e4c: ba 10 20 00 clr %i5 <== NOT EXECUTED
default:
printf ("error: too many arguments.\n");
return 1;
}
if ((start < 0) || (end < 0) ||
2022e50: 80 a7 20 00 cmp %i4, 0 <== NOT EXECUTED
2022e54: 06 80 00 0a bl 2022e7c <rtems_rfs_shell_group+0xb4> <== NOT EXECUTED
2022e58: 80 a7 60 00 cmp %i5, 0 <== NOT EXECUTED
2022e5c: 26 80 00 09 bl,a 2022e80 <rtems_rfs_shell_group+0xb8> <== NOT EXECUTED
2022e60: d2 06 20 24 ld [ %i0 + 0x24 ], %o1 <== NOT EXECUTED
(start >= fs->group_count) || (end >= fs->group_count))
2022e64: c2 06 20 24 ld [ %i0 + 0x24 ], %g1 <== NOT EXECUTED
default:
printf ("error: too many arguments.\n");
return 1;
}
if ((start < 0) || (end < 0) ||
2022e68: 80 a7 40 01 cmp %i5, %g1 <== NOT EXECUTED
2022e6c: 16 80 00 04 bge 2022e7c <rtems_rfs_shell_group+0xb4> <== NOT EXECUTED
2022e70: 80 a7 00 01 cmp %i4, %g1 <== NOT EXECUTED
(start >= fs->group_count) || (end >= fs->group_count))
2022e74: 06 80 00 08 bl 2022e94 <rtems_rfs_shell_group+0xcc> <== NOT EXECUTED
2022e78: 01 00 00 00 nop <== NOT EXECUTED
{
printf ("error: group out of range (0->%d).\n", fs->group_count);
2022e7c: d2 06 20 24 ld [ %i0 + 0x24 ], %o1 <== NOT EXECUTED
2022e80: 11 00 81 8b sethi %hi(0x2062c00), %o0 <== NOT EXECUTED
2022e84: 40 00 8f 19 call 2046ae8 <printf> <== NOT EXECUTED
2022e88: 90 12 21 00 or %o0, 0x100, %o0 ! 2062d00 <rtems_rfs_rtems_eval_config+0x1c8><== NOT EXECUTED
return 1;
2022e8c: 81 c7 e0 08 ret <== NOT EXECUTED
2022e90: 91 e8 20 01 restore %g0, 1, %o0 <== NOT EXECUTED
*/
static void
rtems_rfs_shell_lock_rfs (rtems_rfs_file_system* fs)
{
#if __rtems__
rtems_rfs_rtems_lock (fs);
2022e94: 7f ff fe 80 call 2022894 <rtems_rfs_rtems_lock> <== NOT EXECUTED
2022e98: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
return 0;
}
static int
rtems_rfs_shell_group (rtems_rfs_file_system* fs, int argc, char *argv[])
2022e9c: a7 2f 60 04 sll %i5, 4, %l3 <== NOT EXECUTED
2022ea0: 83 2f 60 06 sll %i5, 6, %g1 <== NOT EXECUTED
rtems_rfs_group* group = &fs->groups[g];
size_t blocks;
size_t inodes;
blocks = group->size - rtems_rfs_bitmap_map_free (&group->block_bitmap);
inodes = fs->group_inodes - rtems_rfs_bitmap_map_free (&group->inode_bitmap);
printf (" %4d: base=%-7" PRIu32 " size=%-6zu blocks=%-5zu (%3zu%%) inode=%-5zu (%3zu%%)\n",
2022ea4: 25 00 81 8b sethi %hi(0x2062c00), %l2 <== NOT EXECUTED
return 0;
}
static int
rtems_rfs_shell_group (rtems_rfs_file_system* fs, int argc, char *argv[])
2022ea8: a6 04 c0 01 add %l3, %g1, %l3 <== NOT EXECUTED
return 1;
}
rtems_rfs_shell_lock_rfs (fs);
for (g = start; g <= end; g++)
2022eac: b6 10 20 00 clr %i3 <== NOT EXECUTED
2022eb0: 10 80 00 25 b 2022f44 <rtems_rfs_shell_group+0x17c> <== NOT EXECUTED
2022eb4: a4 14 a1 28 or %l2, 0x128, %l2 <== NOT EXECUTED
return 0;
}
static int
rtems_rfs_shell_group (rtems_rfs_file_system* fs, int argc, char *argv[])
2022eb8: 84 06 c0 13 add %i3, %l3, %g2 <== NOT EXECUTED
rtems_rfs_shell_lock_rfs (fs);
for (g = start; g <= end; g++)
{
rtems_rfs_group* group = &fs->groups[g];
2022ebc: 82 00 c0 02 add %g3, %g2, %g1 <== NOT EXECUTED
size_t blocks;
size_t inodes;
blocks = group->size - rtems_rfs_bitmap_map_free (&group->block_bitmap);
2022ec0: f2 00 60 04 ld [ %g1 + 4 ], %i1 <== NOT EXECUTED
2022ec4: f4 00 60 18 ld [ %g1 + 0x18 ], %i2 <== NOT EXECUTED
inodes = fs->group_inodes - rtems_rfs_bitmap_map_free (&group->inode_bitmap);
printf (" %4d: base=%-7" PRIu32 " size=%-6zu blocks=%-5zu (%3zu%%) inode=%-5zu (%3zu%%)\n",
2022ec8: ea 00 c0 02 ld [ %g3 + %g2 ], %l5 <== NOT EXECUTED
{
rtems_rfs_group* group = &fs->groups[g];
size_t blocks;
size_t inodes;
blocks = group->size - rtems_rfs_bitmap_map_free (&group->block_bitmap);
inodes = fs->group_inodes - rtems_rfs_bitmap_map_free (&group->inode_bitmap);
2022ecc: e2 06 20 2c ld [ %i0 + 0x2c ], %l1 <== NOT EXECUTED
2022ed0: e0 00 60 3c ld [ %g1 + 0x3c ], %l0 <== NOT EXECUTED
for (g = start; g <= end; g++)
{
rtems_rfs_group* group = &fs->groups[g];
size_t blocks;
size_t inodes;
blocks = group->size - rtems_rfs_bitmap_map_free (&group->block_bitmap);
2022ed4: b4 26 40 1a sub %i1, %i2, %i2 <== NOT EXECUTED
inodes = fs->group_inodes - rtems_rfs_bitmap_map_free (&group->inode_bitmap);
printf (" %4d: base=%-7" PRIu32 " size=%-6zu blocks=%-5zu (%3zu%%) inode=%-5zu (%3zu%%)\n",
g, group->base, group->size,
blocks, (blocks * 100) / group->size,
2022ed8: 85 2e a0 02 sll %i2, 2, %g2 <== NOT EXECUTED
2022edc: 83 2e a0 04 sll %i2, 4, %g1 <== NOT EXECUTED
2022ee0: 82 00 80 01 add %g2, %g1, %g1 <== NOT EXECUTED
rtems_rfs_group* group = &fs->groups[g];
size_t blocks;
size_t inodes;
blocks = group->size - rtems_rfs_bitmap_map_free (&group->block_bitmap);
inodes = fs->group_inodes - rtems_rfs_bitmap_map_free (&group->inode_bitmap);
printf (" %4d: base=%-7" PRIu32 " size=%-6zu blocks=%-5zu (%3zu%%) inode=%-5zu (%3zu%%)\n",
2022ee4: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
g, group->base, group->size,
blocks, (blocks * 100) / group->size,
2022ee8: 91 28 60 02 sll %g1, 2, %o0 <== NOT EXECUTED
rtems_rfs_group* group = &fs->groups[g];
size_t blocks;
size_t inodes;
blocks = group->size - rtems_rfs_bitmap_map_free (&group->block_bitmap);
inodes = fs->group_inodes - rtems_rfs_bitmap_map_free (&group->inode_bitmap);
printf (" %4d: base=%-7" PRIu32 " size=%-6zu blocks=%-5zu (%3zu%%) inode=%-5zu (%3zu%%)\n",
2022eec: 40 00 e1 a5 call 205b580 <.udiv> <== NOT EXECUTED
2022ef0: 90 00 40 08 add %g1, %o0, %o0 <== NOT EXECUTED
{
rtems_rfs_group* group = &fs->groups[g];
size_t blocks;
size_t inodes;
blocks = group->size - rtems_rfs_bitmap_map_free (&group->block_bitmap);
inodes = fs->group_inodes - rtems_rfs_bitmap_map_free (&group->inode_bitmap);
2022ef4: a0 24 40 10 sub %l1, %l0, %l0 <== NOT EXECUTED
printf (" %4d: base=%-7" PRIu32 " size=%-6zu blocks=%-5zu (%3zu%%) inode=%-5zu (%3zu%%)\n",
g, group->base, group->size,
blocks, (blocks * 100) / group->size,
inodes, (inodes * 100) / fs->group_inodes);
2022ef8: 83 2c 20 02 sll %l0, 2, %g1 <== NOT EXECUTED
rtems_rfs_group* group = &fs->groups[g];
size_t blocks;
size_t inodes;
blocks = group->size - rtems_rfs_bitmap_map_free (&group->block_bitmap);
inodes = fs->group_inodes - rtems_rfs_bitmap_map_free (&group->inode_bitmap);
printf (" %4d: base=%-7" PRIu32 " size=%-6zu blocks=%-5zu (%3zu%%) inode=%-5zu (%3zu%%)\n",
2022efc: a8 10 00 08 mov %o0, %l4 <== NOT EXECUTED
2022f00: e0 23 a0 5c st %l0, [ %sp + 0x5c ] <== NOT EXECUTED
2022f04: 92 10 00 11 mov %l1, %o1 <== NOT EXECUTED
g, group->base, group->size,
blocks, (blocks * 100) / group->size,
inodes, (inodes * 100) / fs->group_inodes);
2022f08: a1 2c 20 04 sll %l0, 4, %l0 <== NOT EXECUTED
2022f0c: a0 00 40 10 add %g1, %l0, %l0 <== NOT EXECUTED
2022f10: 91 2c 20 02 sll %l0, 2, %o0 <== NOT EXECUTED
rtems_rfs_group* group = &fs->groups[g];
size_t blocks;
size_t inodes;
blocks = group->size - rtems_rfs_bitmap_map_free (&group->block_bitmap);
inodes = fs->group_inodes - rtems_rfs_bitmap_map_free (&group->inode_bitmap);
printf (" %4d: base=%-7" PRIu32 " size=%-6zu blocks=%-5zu (%3zu%%) inode=%-5zu (%3zu%%)\n",
2022f14: 40 00 e1 9b call 205b580 <.udiv> <== NOT EXECUTED
2022f18: 90 04 00 08 add %l0, %o0, %o0 <== NOT EXECUTED
2022f1c: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
2022f20: d0 23 a0 60 st %o0, [ %sp + 0x60 ] <== NOT EXECUTED
2022f24: 94 10 00 15 mov %l5, %o2 <== NOT EXECUTED
2022f28: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED
2022f2c: 96 10 00 19 mov %i1, %o3 <== NOT EXECUTED
2022f30: 98 10 00 1a mov %i2, %o4 <== NOT EXECUTED
2022f34: 9a 10 00 14 mov %l4, %o5 <== NOT EXECUTED
2022f38: 40 00 8e ec call 2046ae8 <printf> <== NOT EXECUTED
2022f3c: ba 07 60 01 inc %i5 <== NOT EXECUTED
2022f40: b6 06 e0 50 add %i3, 0x50, %i3 <== NOT EXECUTED
return 1;
}
rtems_rfs_shell_lock_rfs (fs);
for (g = start; g <= end; g++)
2022f44: 80 a7 40 1c cmp %i5, %i4 <== NOT EXECUTED
2022f48: 24 bf ff dc ble,a 2022eb8 <rtems_rfs_shell_group+0xf0> <== NOT EXECUTED
2022f4c: c6 06 20 20 ld [ %i0 + 0x20 ], %g3 <== NOT EXECUTED
*/
static void
rtems_rfs_shell_unlock_rfs (rtems_rfs_file_system* fs)
{
#if __rtems__
rtems_rfs_rtems_unlock (fs);
2022f50: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
2022f54: 7f ff fe 65 call 20228e8 <rtems_rfs_rtems_unlock> <== NOT EXECUTED
2022f58: b0 10 20 00 clr %i0 <== NOT EXECUTED
}
rtems_rfs_shell_unlock_rfs (fs);
return 0;
}
2022f5c: 81 c7 e0 08 ret <== NOT EXECUTED
2022f60: 81 e8 00 00 restore <== NOT EXECUTED
0202293c <rtems_rfs_shell_inode>:
return 0;
}
static int
rtems_rfs_shell_inode (rtems_rfs_file_system* fs, int argc, char *argv[])
{
202293c: 9d e3 bf 68 save %sp, -152, %sp <== NOT EXECUTED
bool have_end;
int arg;
int b;
int rc;
total = fs->group_inodes * fs->group_count;
2022940: d0 06 20 24 ld [ %i0 + 0x24 ], %o0 <== NOT EXECUTED
2022944: d2 06 20 2c ld [ %i0 + 0x2c ], %o1 <== NOT EXECUTED
2022948: 7f ff 81 47 call 2002e64 <.umul> <== NOT EXECUTED
202294c: 2f 00 81 8a sethi %hi(0x2062800), %l7 <== NOT EXECUTED
show_all = false;
error_check_only = false;
forced = false;
have_start = have_end = false;
for (arg = 1; arg < argc; arg++)
2022950: b6 10 20 01 mov 1, %i3 <== NOT EXECUTED
int b;
int rc;
total = fs->group_inodes * fs->group_count;
start = RTEMS_RFS_ROOT_INO;
end = total - 1;
2022954: a8 02 3f ff add %o0, -1, %l4 <== NOT EXECUTED
bool have_end;
int arg;
int b;
int rc;
total = fs->group_inodes * fs->group_count;
2022958: a2 10 00 08 mov %o0, %l1 <== NOT EXECUTED
start = RTEMS_RFS_ROOT_INO;
end = total - 1;
202295c: b8 10 00 14 mov %l4, %i4 <== NOT EXECUTED
show_all = false;
error_check_only = false;
forced = false;
have_start = have_end = false;
2022960: ac 10 20 00 clr %l6 <== NOT EXECUTED
2022964: aa 10 20 00 clr %l5 <== NOT EXECUTED
total = fs->group_inodes * fs->group_count;
start = RTEMS_RFS_ROOT_INO;
end = total - 1;
show_all = false;
error_check_only = false;
forced = false;
2022968: a6 10 20 00 clr %l3 <== NOT EXECUTED
total = fs->group_inodes * fs->group_count;
start = RTEMS_RFS_ROOT_INO;
end = total - 1;
show_all = false;
error_check_only = false;
202296c: a0 10 20 00 clr %l0 <== NOT EXECUTED
int rc;
total = fs->group_inodes * fs->group_count;
start = RTEMS_RFS_ROOT_INO;
end = total - 1;
show_all = false;
2022970: a4 10 20 00 clr %l2 <== NOT EXECUTED
int arg;
int b;
int rc;
total = fs->group_inodes * fs->group_count;
start = RTEMS_RFS_ROOT_INO;
2022974: ba 10 20 01 mov 1, %i5 <== NOT EXECUTED
show_all = false;
error_check_only = false;
forced = false;
have_start = have_end = false;
for (arg = 1; arg < argc; arg++)
2022978: 10 80 00 2e b 2022a30 <rtems_rfs_shell_inode+0xf4> <== NOT EXECUTED
202297c: ae 15 e3 98 or %l7, 0x398, %l7 <== NOT EXECUTED
{
if (argv[arg][0] == '-')
2022980: d2 06 80 01 ld [ %i2 + %g1 ], %o1 <== NOT EXECUTED
2022984: c2 4a 40 00 ldsb [ %o1 ], %g1 <== NOT EXECUTED
2022988: 80 a0 60 2d cmp %g1, 0x2d <== NOT EXECUTED
202298c: 12 80 00 0e bne 20229c4 <rtems_rfs_shell_inode+0x88> <== NOT EXECUTED
2022990: 80 8d a0 ff btst 0xff, %l6 <== NOT EXECUTED
{
switch (argv[arg][1])
2022994: c2 4a 60 01 ldsb [ %o1 + 1 ], %g1 <== NOT EXECUTED
2022998: 80 a0 60 65 cmp %g1, 0x65 <== NOT EXECUTED
202299c: 02 80 00 23 be 2022a28 <rtems_rfs_shell_inode+0xec> <== NOT EXECUTED
20229a0: 80 a0 60 66 cmp %g1, 0x66 <== NOT EXECUTED
20229a4: 02 80 00 06 be 20229bc <rtems_rfs_shell_inode+0x80> <== NOT EXECUTED
20229a8: 80 a0 60 61 cmp %g1, 0x61 <== NOT EXECUTED
20229ac: 12 80 00 0b bne 20229d8 <rtems_rfs_shell_inode+0x9c> <== NOT EXECUTED
20229b0: 01 00 00 00 nop <== NOT EXECUTED
{
case 'a':
show_all = true;
20229b4: 10 80 00 1e b 2022a2c <rtems_rfs_shell_inode+0xf0> <== NOT EXECUTED
20229b8: a4 10 20 01 mov 1, %l2 ! 1 <PROM_START+0x1> <== NOT EXECUTED
case 'e':
error_check_only = true;
break;
case 'f':
forced = true;
break;
20229bc: 10 80 00 1c b 2022a2c <rtems_rfs_shell_inode+0xf0> <== NOT EXECUTED
20229c0: a6 10 20 01 mov 1, %l3 <== NOT EXECUTED
break;
}
}
else
{
if (have_end && have_start)
20229c4: 02 80 00 09 be 20229e8 <rtems_rfs_shell_inode+0xac> <== NOT EXECUTED
20229c8: 82 0d 60 ff and %l5, 0xff, %g1 <== NOT EXECUTED
20229cc: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
20229d0: 02 80 00 09 be 20229f4 <rtems_rfs_shell_inode+0xb8> <== NOT EXECUTED
20229d4: 90 10 00 09 mov %o1, %o0 <== NOT EXECUTED
printf ("warning: option ignored: %s\n", argv[arg]);
20229d8: 40 00 90 44 call 2046ae8 <printf> <== NOT EXECUTED
20229dc: 90 10 00 17 mov %l7, %o0 <== NOT EXECUTED
show_all = false;
error_check_only = false;
forced = false;
have_start = have_end = false;
for (arg = 1; arg < argc; arg++)
20229e0: 10 80 00 14 b 2022a30 <rtems_rfs_shell_inode+0xf4> <== NOT EXECUTED
20229e4: b6 06 e0 01 inc %i3 <== NOT EXECUTED
}
else
{
if (have_end && have_start)
printf ("warning: option ignored: %s\n", argv[arg]);
else if (!have_start)
20229e8: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
20229ec: 12 80 00 09 bne 2022a10 <rtems_rfs_shell_inode+0xd4> <== NOT EXECUTED
20229f0: 90 10 00 09 mov %o1, %o0 <== NOT EXECUTED
{
start = end = strtoul (argv[arg], 0, 0);
20229f4: 94 10 20 00 clr %o2 <== NOT EXECUTED
20229f8: 92 10 20 00 clr %o1 <== NOT EXECUTED
20229fc: 40 00 a0 36 call 204aad4 <strtoul> <== NOT EXECUTED
2022a00: aa 10 20 01 mov 1, %l5 <== NOT EXECUTED
2022a04: ba 10 00 08 mov %o0, %i5 <== NOT EXECUTED
2022a08: 10 80 00 09 b 2022a2c <rtems_rfs_shell_inode+0xf0> <== NOT EXECUTED
2022a0c: b8 10 00 08 mov %o0, %i4 <== NOT EXECUTED
have_start = true;
}
else
{
end = strtoul (argv[arg], 0, 0);
2022a10: 94 10 20 00 clr %o2 <== NOT EXECUTED
2022a14: 92 10 20 00 clr %o1 <== NOT EXECUTED
2022a18: 40 00 a0 2f call 204aad4 <strtoul> <== NOT EXECUTED
2022a1c: ac 10 20 01 mov 1, %l6 <== NOT EXECUTED
2022a20: 10 80 00 03 b 2022a2c <rtems_rfs_shell_inode+0xf0> <== NOT EXECUTED
2022a24: b8 10 00 08 mov %o0, %i4 <== NOT EXECUTED
{
case 'a':
show_all = true;
break;
case 'e':
error_check_only = true;
2022a28: a0 10 20 01 mov 1, %l0 <== NOT EXECUTED
show_all = false;
error_check_only = false;
forced = false;
have_start = have_end = false;
for (arg = 1; arg < argc; arg++)
2022a2c: b6 06 e0 01 inc %i3 <== NOT EXECUTED
2022a30: 80 a6 c0 19 cmp %i3, %i1 <== NOT EXECUTED
2022a34: 06 bf ff d3 bl 2022980 <rtems_rfs_shell_inode+0x44> <== NOT EXECUTED
2022a38: 83 2e e0 02 sll %i3, 2, %g1 <== NOT EXECUTED
have_end = true;
}
}
}
if ((start >= total) || (end >= total))
2022a3c: 80 a7 00 11 cmp %i4, %l1 <== NOT EXECUTED
2022a40: 1a 80 00 04 bcc 2022a50 <rtems_rfs_shell_inode+0x114> <== NOT EXECUTED
2022a44: 80 a7 40 11 cmp %i5, %l1 <== NOT EXECUTED
2022a48: 2a 80 00 08 bcs,a 2022a68 <rtems_rfs_shell_inode+0x12c> <== NOT EXECUTED
2022a4c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
{
printf ("error: inode out of range (0->%" PRId32 ").\n", total - 1);
2022a50: 11 00 81 8a sethi %hi(0x2062800), %o0 <== NOT EXECUTED
2022a54: 92 10 00 14 mov %l4, %o1 <== NOT EXECUTED
2022a58: 40 00 90 24 call 2046ae8 <printf> <== NOT EXECUTED
2022a5c: 90 12 23 b8 or %o0, 0x3b8, %o0 <== NOT EXECUTED
2022a60: 81 c7 e0 08 ret <== NOT EXECUTED
2022a64: 91 e8 20 01 restore %g0, 1, %o0 <== NOT EXECUTED
}
}
if (!error_check_only || error)
{
printf (" %5" PRIu32 ": pos=%06" PRIu32 ":%04zx %c ",
2022a68: 37 00 81 8b sethi %hi(0x2062c00), %i3 <== 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);
if (links == 0xffff)
2022a6c: 35 00 00 3f sethi %hi(0xfc00), %i2 <== NOT EXECUTED
rtems_rfs_inode_get_links (&inode),
mode, type, mode & ((1 << 10) - 1),
rtems_rfs_inode_get_block_offset (&inode),
rtems_rfs_inode_get_block_count (&inode));
for (b = 0; b < (RTEMS_RFS_INODE_BLOCKS - 1); b++)
printf ("%" PRIu32 " ", rtems_rfs_inode_get_block (&inode, b));
2022a70: 33 00 81 8b sethi %hi(0x2062c00), %i1 <== NOT EXECUTED
*/
static void
rtems_rfs_shell_lock_rfs (rtems_rfs_file_system* fs)
{
#if __rtems__
rtems_rfs_rtems_lock (fs);
2022a74: 7f ff ff 88 call 2022894 <rtems_rfs_rtems_lock> <== NOT EXECUTED
2022a78: a2 1c 20 01 xor %l0, 1, %l1 <== NOT EXECUTED
}
}
if (!error_check_only || error)
{
printf (" %5" PRIu32 ": pos=%06" PRIu32 ":%04zx %c ",
2022a7c: b6 16 e0 40 or %i3, 0x40, %i3 <== NOT EXECUTED
2022a80: b4 16 a3 ff or %i2, 0x3ff, %i2 <== NOT EXECUTED
rtems_rfs_inode_get_links (&inode),
mode, type, mode & ((1 << 10) - 1),
rtems_rfs_inode_get_block_offset (&inode),
rtems_rfs_inode_get_block_count (&inode));
for (b = 0; b < (RTEMS_RFS_INODE_BLOCKS - 1); b++)
printf ("%" PRIu32 " ", rtems_rfs_inode_get_block (&inode, b));
2022a84: b2 16 60 a0 or %i1, 0xa0, %i1 <== NOT EXECUTED
return 1;
}
rtems_rfs_shell_lock_rfs (fs);
for (ino = start; ino <= end; ino++)
2022a88: 10 80 00 c9 b 2022dac <rtems_rfs_shell_inode+0x470> <== NOT EXECUTED
2022a8c: a2 0c 60 ff and %l1, 0xff, %l1 <== NOT EXECUTED
{
rtems_rfs_inode_handle inode;
bool allocated;
rc = rtems_rfs_group_bitmap_test (fs, true, ino, &allocated);
2022a90: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
2022a94: 94 10 00 1d mov %i5, %o2 <== NOT EXECUTED
2022a98: 40 00 63 a3 call 203b924 <rtems_rfs_group_bitmap_test> <== NOT EXECUTED
2022a9c: 96 07 bf d7 add %fp, -41, %o3 <== NOT EXECUTED
if (rc > 0)
2022aa0: a8 92 20 00 orcc %o0, 0, %l4 <== NOT EXECUTED
2022aa4: 04 80 00 0a ble 2022acc <rtems_rfs_shell_inode+0x190> <== NOT EXECUTED
2022aa8: 80 8c a0 ff btst 0xff, %l2 <== NOT EXECUTED
*/
static void
rtems_rfs_shell_unlock_rfs (rtems_rfs_file_system* fs)
{
#if __rtems__
rtems_rfs_rtems_unlock (fs);
2022aac: 7f ff ff 8f call 20228e8 <rtems_rfs_rtems_unlock> <== NOT EXECUTED
2022ab0: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
rc = rtems_rfs_group_bitmap_test (fs, true, ino, &allocated);
if (rc > 0)
{
rtems_rfs_shell_unlock_rfs (fs);
printf ("error: testing inode state: ino=%" PRIu32 ": (%d) %s\n",
2022ab4: 40 00 99 8c call 20490e4 <strerror> <== NOT EXECUTED
2022ab8: 90 10 00 14 mov %l4, %o0 <== NOT EXECUTED
2022abc: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
2022ac0: 11 00 81 8a sethi %hi(0x2062800), %o0 <== NOT EXECUTED
2022ac4: 10 80 00 b5 b 2022d98 <rtems_rfs_shell_inode+0x45c> <== NOT EXECUTED
2022ac8: 90 12 23 e0 or %o0, 0x3e0, %o0 ! 2062be0 <rtems_rfs_rtems_eval_config+0xa8><== NOT EXECUTED
ino, rc, strerror (rc));
return 1;
}
if (show_all || allocated)
2022acc: 12 80 00 05 bne 2022ae0 <rtems_rfs_shell_inode+0x1a4> <== NOT EXECUTED
2022ad0: c2 0f bf d7 ldub [ %fp + -41 ], %g1 <== NOT EXECUTED
2022ad4: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
2022ad8: 22 80 00 b5 be,a 2022dac <rtems_rfs_shell_inode+0x470> <== NOT EXECUTED
2022adc: ba 07 60 01 inc %i5 <== NOT EXECUTED
{
uint16_t mode;
bool error;
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
2022ae0: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
2022ae4: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
2022ae8: 94 07 bf d8 add %fp, -40, %o2 <== NOT EXECUTED
2022aec: 40 00 64 2d call 203bba0 <rtems_rfs_inode_open> <== NOT EXECUTED
2022af0: 96 10 20 01 mov 1, %o3 <== NOT EXECUTED
if (rc > 0)
2022af4: a8 92 20 00 orcc %o0, 0, %l4 <== NOT EXECUTED
2022af8: 04 80 00 0a ble 2022b20 <rtems_rfs_shell_inode+0x1e4> <== NOT EXECUTED
2022afc: c2 07 bf e4 ld [ %fp + -28 ], %g1 <== NOT EXECUTED
*/
static void
rtems_rfs_shell_unlock_rfs (rtems_rfs_file_system* fs)
{
#if __rtems__
rtems_rfs_rtems_unlock (fs);
2022b00: 7f ff ff 7a call 20228e8 <rtems_rfs_rtems_unlock> <== NOT EXECUTED
2022b04: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
if (rc > 0)
{
rtems_rfs_shell_unlock_rfs (fs);
printf ("error: opening inode handle: ino=%" PRIu32 ": (%d) %s\n",
2022b08: 40 00 99 77 call 20490e4 <strerror> <== NOT EXECUTED
2022b0c: 90 10 00 14 mov %l4, %o0 <== NOT EXECUTED
2022b10: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
2022b14: 11 00 81 8b sethi %hi(0x2062c00), %o0 <== NOT EXECUTED
2022b18: 10 80 00 a0 b 2022d98 <rtems_rfs_shell_inode+0x45c> <== NOT EXECUTED
2022b1c: 90 12 20 10 or %o0, 0x10, %o0 ! 2062c10 <rtems_rfs_rtems_eval_config+0xd8><== NOT EXECUTED
ino, rc, strerror (rc));
return 1;
}
error = false;
2022b20: 84 10 20 00 clr %g2 <== 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);
2022b24: e8 08 60 02 ldub [ %g1 + 2 ], %l4 <== NOT EXECUTED
2022b28: c2 08 60 03 ldub [ %g1 + 3 ], %g1 <== NOT EXECUTED
2022b2c: a9 2d 20 08 sll %l4, 8, %l4 <== NOT EXECUTED
mode = rtems_rfs_inode_get_mode (&inode);
if (error_check_only)
2022b30: 80 8c 20 ff btst 0xff, %l0 <== NOT EXECUTED
2022b34: 02 80 00 18 be 2022b94 <rtems_rfs_shell_inode+0x258> <== NOT EXECUTED
2022b38: a8 15 00 01 or %l4, %g1, %l4 <== NOT EXECUTED
{
if (!RTEMS_RFS_S_ISDIR (mode) &&
2022b3c: 03 00 00 3c sethi %hi(0xf000), %g1 <== NOT EXECUTED
2022b40: 07 00 00 08 sethi %hi(0x2000), %g3 <== NOT EXECUTED
2022b44: 82 0d 00 01 and %l4, %g1, %g1 <== NOT EXECUTED
2022b48: 80 a0 40 03 cmp %g1, %g3 <== NOT EXECUTED
2022b4c: 02 80 00 13 be 2022b98 <rtems_rfs_shell_inode+0x25c> <== NOT EXECUTED
2022b50: 80 88 a0 ff btst 0xff, %g2 <== NOT EXECUTED
2022b54: 07 00 00 10 sethi %hi(0x4000), %g3 <== NOT EXECUTED
2022b58: 80 a0 40 03 cmp %g1, %g3 <== NOT EXECUTED
2022b5c: 02 80 00 0f be 2022b98 <rtems_rfs_shell_inode+0x25c> <== NOT EXECUTED
2022b60: 80 88 a0 ff btst 0xff, %g2 <== NOT EXECUTED
!RTEMS_RFS_S_ISCHR (mode) &&
2022b64: 07 00 00 18 sethi %hi(0x6000), %g3 <== NOT EXECUTED
2022b68: 80 a0 40 03 cmp %g1, %g3 <== NOT EXECUTED
2022b6c: 02 80 00 0a be 2022b94 <rtems_rfs_shell_inode+0x258> <== NOT EXECUTED
2022b70: 07 00 00 20 sethi %hi(0x8000), %g3 <== NOT EXECUTED
!RTEMS_RFS_S_ISBLK (mode) &&
2022b74: 80 a0 40 03 cmp %g1, %g3 <== NOT EXECUTED
2022b78: 02 80 00 08 be 2022b98 <rtems_rfs_shell_inode+0x25c> <== NOT EXECUTED
2022b7c: 80 88 a0 ff btst 0xff, %g2 <== NOT EXECUTED
!RTEMS_RFS_S_ISREG (mode) &&
2022b80: 05 00 00 28 sethi %hi(0xa000), %g2 <== NOT EXECUTED
2022b84: 82 18 40 02 xor %g1, %g2, %g1 <== NOT EXECUTED
2022b88: 80 a0 00 01 cmp %g0, %g1 <== NOT EXECUTED
2022b8c: 10 80 00 02 b 2022b94 <rtems_rfs_shell_inode+0x258> <== NOT EXECUTED
2022b90: 84 40 20 00 addx %g0, 0, %g2 <== NOT EXECUTED
}
#endif
}
}
if (!error_check_only || error)
2022b94: 80 88 a0 ff btst 0xff, %g2 <== NOT EXECUTED
2022b98: 12 80 00 06 bne 2022bb0 <rtems_rfs_shell_inode+0x274> <== NOT EXECUTED
2022b9c: c2 07 bf f8 ld [ %fp + -8 ], %g1 <== NOT EXECUTED
2022ba0: 80 a4 60 00 cmp %l1, 0 <== NOT EXECUTED
2022ba4: 02 80 00 71 be 2022d68 <rtems_rfs_shell_inode+0x42c> <== NOT EXECUTED
2022ba8: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
{
printf (" %5" PRIu32 ": pos=%06" PRIu32 ":%04zx %c ",
2022bac: c2 07 bf f8 ld [ %fp + -8 ], %g1 <== NOT EXECUTED
2022bb0: c6 0f bf d7 ldub [ %fp + -41 ], %g3 <== NOT EXECUTED
2022bb4: d4 07 bf ec ld [ %fp + -20 ], %o2 <== NOT EXECUTED
2022bb8: 80 a0 00 03 cmp %g0, %g3 <== NOT EXECUTED
2022bbc: 97 28 60 03 sll %g1, 3, %o3 <== NOT EXECUTED
2022bc0: 83 28 60 06 sll %g1, 6, %g1 <== NOT EXECUTED
2022bc4: 98 40 3f ff addx %g0, -1, %o4 <== NOT EXECUTED
2022bc8: 96 20 40 0b sub %g1, %o3, %o3 <== NOT EXECUTED
2022bcc: 98 0b 20 05 and %o4, 5, %o4 <== NOT EXECUTED
2022bd0: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
2022bd4: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
2022bd8: 40 00 8f c4 call 2046ae8 <printf> <== NOT EXECUTED
2022bdc: 98 03 20 41 add %o4, 0x41, %o4 <== NOT EXECUTED
ino, rtems_rfs_buffer_bnum (&inode.buffer),
inode.offset * RTEMS_RFS_INODE_SIZE,
allocated ? 'A' : 'F');
if (!allocated && !forced)
2022be0: c2 0f bf d7 ldub [ %fp + -41 ], %g1 <== NOT EXECUTED
2022be4: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
2022be8: 12 80 00 0a bne 2022c10 <rtems_rfs_shell_inode+0x2d4> <== NOT EXECUTED
2022bec: 03 00 00 3c sethi %hi(0xf000), %g1 <== NOT EXECUTED
2022bf0: 80 8c e0 ff btst 0xff, %l3 <== NOT EXECUTED
2022bf4: 12 80 00 08 bne 2022c14 <rtems_rfs_shell_inode+0x2d8> <== NOT EXECUTED
2022bf8: 05 00 00 10 sethi %hi(0x4000), %g2 <== NOT EXECUTED
printf (" --\n");
2022bfc: 11 00 81 8b sethi %hi(0x2062c00), %o0 <== NOT EXECUTED
2022c00: 40 00 90 52 call 2046d48 <puts> <== NOT EXECUTED
2022c04: 90 12 20 60 or %o0, 0x60, %o0 ! 2062c60 <rtems_rfs_rtems_eval_config+0x128><== NOT EXECUTED
2022c08: 10 80 00 58 b 2022d68 <rtems_rfs_shell_inode+0x42c> <== NOT EXECUTED
2022c0c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
else
{
const char* type;
type = "UKN";
if (RTEMS_RFS_S_ISDIR (mode))
2022c10: 05 00 00 10 sethi %hi(0x4000), %g2 <== NOT EXECUTED
2022c14: 82 0d 00 01 and %l4, %g1, %g1 <== NOT EXECUTED
2022c18: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED
2022c1c: 02 80 00 10 be 2022c5c <rtems_rfs_shell_inode+0x320> <== NOT EXECUTED
2022c20: 05 00 00 08 sethi %hi(0x2000), %g2 <== NOT EXECUTED
type = "DIR";
else if (RTEMS_RFS_S_ISCHR (mode))
2022c24: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED
2022c28: 02 80 00 10 be 2022c68 <rtems_rfs_shell_inode+0x32c> <== NOT EXECUTED
2022c2c: 05 00 00 18 sethi %hi(0x6000), %g2 <== NOT EXECUTED
type = "CHR";
else if (RTEMS_RFS_S_ISBLK (mode))
2022c30: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED
2022c34: 02 80 00 10 be 2022c74 <rtems_rfs_shell_inode+0x338> <== NOT EXECUTED
2022c38: 05 00 00 20 sethi %hi(0x8000), %g2 <== NOT EXECUTED
type = "BLK";
else if (RTEMS_RFS_S_ISREG (mode))
2022c3c: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED
2022c40: 02 80 00 10 be 2022c80 <rtems_rfs_shell_inode+0x344> <== NOT EXECUTED
2022c44: 05 00 00 28 sethi %hi(0xa000), %g2 <== NOT EXECUTED
type = "REG";
else if (RTEMS_RFS_S_ISLNK (mode))
2022c48: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED
2022c4c: 02 80 00 10 be 2022c8c <rtems_rfs_shell_inode+0x350> <== NOT EXECUTED
2022c50: 17 00 81 8a sethi %hi(0x2062800), %o3 <== NOT EXECUTED
if (!allocated && !forced)
printf (" --\n");
else
{
const char* type;
type = "UKN";
2022c54: 10 80 00 10 b 2022c94 <rtems_rfs_shell_inode+0x358> <== NOT EXECUTED
2022c58: 96 12 e3 88 or %o3, 0x388, %o3 ! 2062b88 <rtems_rfs_rtems_eval_config+0x50><== NOT EXECUTED
if (RTEMS_RFS_S_ISDIR (mode))
type = "DIR";
2022c5c: 17 00 81 8a sethi %hi(0x2062800), %o3 <== NOT EXECUTED
2022c60: 10 80 00 0d b 2022c94 <rtems_rfs_shell_inode+0x358> <== NOT EXECUTED
2022c64: 96 12 e3 68 or %o3, 0x368, %o3 ! 2062b68 <rtems_rfs_rtems_eval_config+0x30><== NOT EXECUTED
else if (RTEMS_RFS_S_ISCHR (mode))
type = "CHR";
2022c68: 17 00 81 8a sethi %hi(0x2062800), %o3 <== NOT EXECUTED
2022c6c: 10 80 00 0a b 2022c94 <rtems_rfs_shell_inode+0x358> <== NOT EXECUTED
2022c70: 96 12 e3 70 or %o3, 0x370, %o3 ! 2062b70 <rtems_rfs_rtems_eval_config+0x38><== NOT EXECUTED
else if (RTEMS_RFS_S_ISBLK (mode))
type = "BLK";
2022c74: 17 00 81 8a sethi %hi(0x2062800), %o3 <== NOT EXECUTED
2022c78: 10 80 00 07 b 2022c94 <rtems_rfs_shell_inode+0x358> <== NOT EXECUTED
2022c7c: 96 12 e3 78 or %o3, 0x378, %o3 ! 2062b78 <rtems_rfs_rtems_eval_config+0x40><== NOT EXECUTED
else if (RTEMS_RFS_S_ISREG (mode))
type = "REG";
2022c80: 17 00 81 8a sethi %hi(0x2062800), %o3 <== NOT EXECUTED
2022c84: 10 80 00 04 b 2022c94 <rtems_rfs_shell_inode+0x358> <== NOT EXECUTED
2022c88: 96 12 e3 80 or %o3, 0x380, %o3 ! 2062b80 <rtems_rfs_rtems_eval_config+0x48><== NOT EXECUTED
else if (RTEMS_RFS_S_ISLNK (mode))
type = "LNK";
2022c8c: 17 00 81 8a sethi %hi(0x2062800), %o3 <== NOT EXECUTED
2022c90: 96 12 e3 90 or %o3, 0x390, %o3 ! 2062b90 <rtems_rfs_rtems_eval_config+0x58><== 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);
2022c94: c2 07 bf e4 ld [ %fp + -28 ], %g1 <== NOT EXECUTED
printf ("links=%03i mode=%04x (%s/%03o) bo=%04u bc=%04" PRIu32 " b=[",
2022c98: 95 2d 20 10 sll %l4, 0x10, %o2 <== NOT EXECUTED
2022c9c: c6 08 60 01 ldub [ %g1 + 1 ], %g3 <== NOT EXECUTED
2022ca0: c4 08 40 00 ldub [ %g1 ], %g2 <== NOT EXECUTED
* @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);
2022ca4: c8 08 60 0c ldub [ %g1 + 0xc ], %g4 <== 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);
2022ca8: 85 28 a0 08 sll %g2, 8, %g2 <== NOT EXECUTED
2022cac: 84 10 80 03 or %g2, %g3, %g2 <== NOT EXECUTED
if (links == 0xffff)
2022cb0: 87 28 a0 10 sll %g2, 0x10, %g3 <== NOT EXECUTED
2022cb4: 87 30 e0 10 srl %g3, 0x10, %g3 <== NOT EXECUTED
links = 0;
2022cb8: 86 18 c0 1a xor %g3, %i2, %g3 <== NOT EXECUTED
2022cbc: 80 a0 00 03 cmp %g0, %g3 <== NOT EXECUTED
2022cc0: 92 60 20 00 subx %g0, 0, %o1 <== NOT EXECUTED
2022cc4: 84 08 80 09 and %g2, %o1, %g2 <== NOT EXECUTED
2022cc8: 93 28 a0 10 sll %g2, 0x10, %o1 <== NOT EXECUTED
* @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);
2022ccc: c4 08 60 0d ldub [ %g1 + 0xd ], %g2 <== NOT EXECUTED
2022cd0: 89 29 20 18 sll %g4, 0x18, %g4 <== NOT EXECUTED
2022cd4: 85 28 a0 10 sll %g2, 0x10, %g2 <== NOT EXECUTED
2022cd8: 88 11 00 02 or %g4, %g2, %g4 <== NOT EXECUTED
2022cdc: c4 08 60 0f ldub [ %g1 + 0xf ], %g2 <== NOT EXECUTED
* @return uint32_t The block offset.
*/
static inline uint16_t
rtems_rfs_inode_get_block_offset (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u16 (&handle->node->block_offset);
2022ce0: c6 08 60 0a ldub [ %g1 + 0xa ], %g3 <== NOT EXECUTED
* @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);
2022ce4: 88 11 00 02 or %g4, %g2, %g4 <== NOT EXECUTED
2022ce8: c4 08 60 0e ldub [ %g1 + 0xe ], %g2 <== NOT EXECUTED
2022cec: da 08 60 0b ldub [ %g1 + 0xb ], %o5 <== NOT EXECUTED
* @return uint32_t The block offset.
*/
static inline uint16_t
rtems_rfs_inode_get_block_offset (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u16 (&handle->node->block_offset);
2022cf0: 87 28 e0 08 sll %g3, 8, %g3 <== NOT EXECUTED
* @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);
2022cf4: 85 28 a0 08 sll %g2, 8, %g2 <== NOT EXECUTED
2022cf8: 82 11 00 02 or %g4, %g2, %g1 <== NOT EXECUTED
2022cfc: 98 0d 23 ff and %l4, 0x3ff, %o4 <== NOT EXECUTED
2022d00: c2 23 a0 5c st %g1, [ %sp + 0x5c ] <== NOT EXECUTED
2022d04: 11 00 81 8b sethi %hi(0x2062c00), %o0 <== NOT EXECUTED
2022d08: 93 32 60 10 srl %o1, 0x10, %o1 <== NOT EXECUTED
2022d0c: 90 12 20 68 or %o0, 0x68, %o0 <== NOT EXECUTED
2022d10: 95 32 a0 10 srl %o2, 0x10, %o2 <== NOT EXECUTED
2022d14: 9a 13 40 03 or %o5, %g3, %o5 <== NOT EXECUTED
2022d18: 40 00 8f 74 call 2046ae8 <printf> <== NOT EXECUTED
2022d1c: a8 10 20 00 clr %l4 <== NOT EXECUTED
rtems_rfs_inode_get_links (&inode),
mode, type, mode & ((1 << 10) - 1),
rtems_rfs_inode_get_block_offset (&inode),
rtems_rfs_inode_get_block_count (&inode));
for (b = 0; b < (RTEMS_RFS_INODE_BLOCKS - 1); b++)
printf ("%" PRIu32 " ", rtems_rfs_inode_get_block (&inode, b));
2022d20: 92 10 00 14 mov %l4, %o1 <== NOT EXECUTED
2022d24: 7f ff fe cc call 2022854 <rtems_rfs_inode_get_block> <== NOT EXECUTED
2022d28: 90 07 bf d8 add %fp, -40, %o0 <== NOT EXECUTED
2022d2c: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED
2022d30: 40 00 8f 6e call 2046ae8 <printf> <== NOT EXECUTED
2022d34: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
printf ("links=%03i mode=%04x (%s/%03o) bo=%04u bc=%04" PRIu32 " b=[",
rtems_rfs_inode_get_links (&inode),
mode, type, mode & ((1 << 10) - 1),
rtems_rfs_inode_get_block_offset (&inode),
rtems_rfs_inode_get_block_count (&inode));
for (b = 0; b < (RTEMS_RFS_INODE_BLOCKS - 1); b++)
2022d38: a8 05 20 01 inc %l4 <== NOT EXECUTED
2022d3c: 80 a5 20 04 cmp %l4, 4 <== NOT EXECUTED
2022d40: 32 bf ff f9 bne,a 2022d24 <rtems_rfs_shell_inode+0x3e8> <== NOT EXECUTED
2022d44: 92 10 00 14 mov %l4, %o1 <== NOT EXECUTED
printf ("%" PRIu32 " ", rtems_rfs_inode_get_block (&inode, b));
printf ("%" PRIu32 "]\n", rtems_rfs_inode_get_block (&inode, b));
2022d48: 92 10 20 04 mov 4, %o1 <== NOT EXECUTED
2022d4c: 7f ff fe c2 call 2022854 <rtems_rfs_inode_get_block> <== NOT EXECUTED
2022d50: 90 07 bf d8 add %fp, -40, %o0 <== NOT EXECUTED
2022d54: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED
2022d58: 11 00 81 8b sethi %hi(0x2062c00), %o0 <== NOT EXECUTED
2022d5c: 40 00 8f 63 call 2046ae8 <printf> <== NOT EXECUTED
2022d60: 90 12 20 a8 or %o0, 0xa8, %o0 ! 2062ca8 <rtems_rfs_rtems_eval_config+0x170><== NOT EXECUTED
}
}
rc = rtems_rfs_inode_close (fs, &inode);
2022d64: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
2022d68: 40 00 64 00 call 203bd68 <rtems_rfs_inode_close> <== NOT EXECUTED
2022d6c: 92 07 bf d8 add %fp, -40, %o1 <== NOT EXECUTED
if (rc > 0)
2022d70: a8 92 20 00 orcc %o0, 0, %l4 <== NOT EXECUTED
2022d74: 24 80 00 0e ble,a 2022dac <rtems_rfs_shell_inode+0x470> <== NOT EXECUTED
2022d78: ba 07 60 01 inc %i5 <== NOT EXECUTED
*/
static void
rtems_rfs_shell_unlock_rfs (rtems_rfs_file_system* fs)
{
#if __rtems__
rtems_rfs_rtems_unlock (fs);
2022d7c: 7f ff fe db call 20228e8 <rtems_rfs_rtems_unlock> <== NOT EXECUTED
2022d80: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
rc = rtems_rfs_inode_close (fs, &inode);
if (rc > 0)
{
rtems_rfs_shell_unlock_rfs (fs);
printf ("error: closing inode handle: ino=%" PRIu32 ": (%d) %s\n",
2022d84: 40 00 98 d8 call 20490e4 <strerror> <== NOT EXECUTED
2022d88: 90 10 00 14 mov %l4, %o0 <== NOT EXECUTED
2022d8c: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
2022d90: 11 00 81 8b sethi %hi(0x2062c00), %o0 <== NOT EXECUTED
2022d94: 90 12 20 b0 or %o0, 0xb0, %o0 ! 2062cb0 <rtems_rfs_rtems_eval_config+0x178><== NOT EXECUTED
2022d98: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
2022d9c: 40 00 8f 53 call 2046ae8 <printf> <== NOT EXECUTED
2022da0: 94 10 00 14 mov %l4, %o2 <== NOT EXECUTED
2022da4: 81 c7 e0 08 ret <== NOT EXECUTED
2022da8: 91 e8 20 01 restore %g0, 1, %o0 <== NOT EXECUTED
return 1;
}
rtems_rfs_shell_lock_rfs (fs);
for (ino = start; ino <= end; ino++)
2022dac: 80 a7 40 1c cmp %i5, %i4 <== NOT EXECUTED
2022db0: 08 bf ff 38 bleu 2022a90 <rtems_rfs_shell_inode+0x154> <== NOT EXECUTED
2022db4: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
*/
static void
rtems_rfs_shell_unlock_rfs (rtems_rfs_file_system* fs)
{
#if __rtems__
rtems_rfs_rtems_unlock (fs);
2022db8: 7f ff fe cc call 20228e8 <rtems_rfs_rtems_unlock> <== NOT EXECUTED
2022dbc: b0 10 20 00 clr %i0 <== NOT EXECUTED
}
rtems_rfs_shell_unlock_rfs (fs);
return 0;
}
2022dc0: 81 c7 e0 08 ret <== NOT EXECUTED
2022dc4: 81 e8 00 00 restore <== NOT EXECUTED
02023614 <rtems_rfs_shell_usage>:
}
void
rtems_rfs_shell_usage (const char* arg)
{
2023614: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED
printf ("%s: RFS debugger\n", arg);
2023618: 11 00 81 8c sethi %hi(0x2063000), %o0 <== NOT EXECUTED
202361c: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
2023620: 40 00 8d 32 call 2046ae8 <printf> <== NOT EXECUTED
2023624: 90 12 21 40 or %o0, 0x140, %o0 <== NOT EXECUTED
printf (" %s [-hl] <path> <command>\n", arg);
2023628: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
202362c: 11 00 81 8c sethi %hi(0x2063000), %o0 <== NOT EXECUTED
2023630: 40 00 8d 2e call 2046ae8 <printf> <== NOT EXECUTED
2023634: 90 12 21 58 or %o0, 0x158, %o0 ! 2063158 <rtems_rfs_rtems_eval_config+0x620><== NOT EXECUTED
printf (" where:\n");
2023638: 11 00 81 8c sethi %hi(0x2063000), %o0 <== NOT EXECUTED
202363c: 40 00 8d c3 call 2046d48 <puts> <== NOT EXECUTED
2023640: 90 12 21 78 or %o0, 0x178, %o0 ! 2063178 <rtems_rfs_rtems_eval_config+0x640><== NOT EXECUTED
printf (" path: Path to the mounted RFS file system\n");
2023644: 11 00 81 8c sethi %hi(0x2063000), %o0 <== NOT EXECUTED
2023648: 40 00 8d c0 call 2046d48 <puts> <== NOT EXECUTED
202364c: 90 12 21 88 or %o0, 0x188, %o0 ! 2063188 <rtems_rfs_rtems_eval_config+0x650><== NOT EXECUTED
printf (" command: A debugger command. See -l for a list plus help.\n");
2023650: 11 00 81 8c sethi %hi(0x2063000), %o0 <== NOT EXECUTED
2023654: 40 00 8d bd call 2046d48 <puts> <== NOT EXECUTED
2023658: 90 12 21 c0 or %o0, 0x1c0, %o0 ! 20631c0 <rtems_rfs_rtems_eval_config+0x688><== NOT EXECUTED
printf (" -h: This help\n");
202365c: 11 00 81 8c sethi %hi(0x2063000), %o0 <== NOT EXECUTED
printf (" -l: The debugger command list.\n");
2023660: 31 00 81 8c sethi %hi(0x2063000), %i0 <== NOT EXECUTED
printf ("%s: RFS debugger\n", arg);
printf (" %s [-hl] <path> <command>\n", arg);
printf (" where:\n");
printf (" path: Path to the mounted RFS file system\n");
printf (" command: A debugger command. See -l for a list plus help.\n");
printf (" -h: This help\n");
2023664: 90 12 22 00 or %o0, 0x200, %o0 <== NOT EXECUTED
2023668: 40 00 8d b8 call 2046d48 <puts> <== NOT EXECUTED
202366c: b0 16 22 18 or %i0, 0x218, %i0 <== NOT EXECUTED
printf (" -l: The debugger command list.\n");
2023670: 40 00 8d b6 call 2046d48 <puts> <== NOT EXECUTED
2023674: 81 e8 00 00 restore <== NOT EXECUTED
0203c9f8 <rtems_rfs_symlink>:
const char* link,
int link_length,
uid_t uid,
gid_t gid,
rtems_rfs_ino parent)
{
203c9f8: 9d e3 bf 00 save %sp, -256, %sp
rtems_rfs_inode_handle inode;
rtems_rfs_ino ino;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_SYMLINK))
203c9fc: 90 10 20 02 mov 2, %o0
const char* link,
int link_length,
uid_t uid,
gid_t gid,
rtems_rfs_ino parent)
{
203ca00: e2 07 a0 60 ld [ %fp + 0x60 ], %l1
203ca04: e4 17 a0 5e lduh [ %fp + 0x5e ], %l2
rtems_rfs_inode_handle inode;
rtems_rfs_ino ino;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_SYMLINK))
203ca08: 7f ff 9c 11 call 2023a4c <rtems_rfs_trace>
203ca0c: 92 10 20 00 clr %o1
203ca10: 80 8a 20 ff btst 0xff, %o0
203ca14: 12 80 00 07 bne 203ca30 <rtems_rfs_symlink+0x38> <== NEVER TAKEN
203ca18: 11 00 81 a4 sethi %hi(0x2069000), %o0
printf (" link:");
for (c = 0; c < link_length; c++)
printf ("%c", link[c]);
}
if (link_length >= rtems_rfs_fs_block_size (fs))
203ca1c: c2 06 20 08 ld [ %i0 + 8 ], %g1
203ca20: 80 a7 00 01 cmp %i4, %g1
203ca24: 1a 80 00 8b bcc 203cc50 <rtems_rfs_symlink+0x258> <== NEVER TAKEN
203ca28: b4 10 20 5b mov 0x5b, %i2
203ca2c: 30 80 00 19 b,a 203ca90 <rtems_rfs_symlink+0x98>
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_SYMLINK))
{
int c;
printf ("rtems-rfs: symlink: parent:%" PRIu32 " name:", parent);
203ca30: 92 10 00 11 mov %l1, %o1 <== NOT EXECUTED
203ca34: 90 12 23 70 or %o0, 0x370, %o0 <== NOT EXECUTED
203ca38: 40 00 28 2c call 2046ae8 <printf> <== NOT EXECUTED
203ca3c: a0 10 20 00 clr %l0 <== NOT EXECUTED
for (c = 0; c < length; c++)
203ca40: 10 80 00 05 b 203ca54 <rtems_rfs_symlink+0x5c> <== NOT EXECUTED
203ca44: 80 a4 00 1a cmp %l0, %i2 <== NOT EXECUTED
printf ("%c", name[c]);
203ca48: 40 00 28 92 call 2046c90 <putchar> <== NOT EXECUTED
203ca4c: a0 04 20 01 inc %l0 <== 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++)
203ca50: 80 a4 00 1a cmp %l0, %i2 <== NOT EXECUTED
203ca54: 26 bf ff fd bl,a 203ca48 <rtems_rfs_symlink+0x50> <== NOT EXECUTED
203ca58: d0 4e 40 10 ldsb [ %i1 + %l0 ], %o0 <== NOT EXECUTED
printf ("%c", name[c]);
printf (" link:");
203ca5c: 11 00 81 a4 sethi %hi(0x2069000), %o0 <== NOT EXECUTED
for (c = 0; c < link_length; c++)
203ca60: b4 10 20 00 clr %i2 <== NOT EXECUTED
{
int c;
printf ("rtems-rfs: symlink: parent:%" PRIu32 " name:", parent);
for (c = 0; c < length; c++)
printf ("%c", name[c]);
printf (" link:");
203ca64: 40 00 28 21 call 2046ae8 <printf> <== NOT EXECUTED
203ca68: 90 12 23 98 or %o0, 0x398, %o0 <== NOT EXECUTED
for (c = 0; c < link_length; c++)
203ca6c: 10 80 00 05 b 203ca80 <rtems_rfs_symlink+0x88> <== NOT EXECUTED
203ca70: 80 a6 80 1c cmp %i2, %i4 <== NOT EXECUTED
printf ("%c", link[c]);
203ca74: 40 00 28 87 call 2046c90 <putchar> <== NOT EXECUTED
203ca78: b4 06 a0 01 inc %i2 <== 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++)
203ca7c: 80 a6 80 1c cmp %i2, %i4 <== NOT EXECUTED
203ca80: 26 bf ff fd bl,a 203ca74 <rtems_rfs_symlink+0x7c> <== NOT EXECUTED
203ca84: d0 4e c0 1a ldsb [ %i3 + %i2 ], %o0 <== NOT EXECUTED
printf ("%c", link[c]);
}
if (link_length >= rtems_rfs_fs_block_size (fs))
203ca88: 10 bf ff e6 b 203ca20 <rtems_rfs_symlink+0x28> <== NOT EXECUTED
203ca8c: c2 06 20 08 ld [ %i0 + 8 ], %g1 <== NOT EXECUTED
return ENAMETOOLONG;
rc = rtems_rfs_inode_create (fs, parent, name, strlen (name),
203ca90: 40 00 31 bc call 2049180 <strlen>
203ca94: 90 10 00 19 mov %i1, %o0
203ca98: 82 07 bf 74 add %fp, -140, %g1
203ca9c: 96 10 00 08 mov %o0, %o3
203caa0: fa 23 a0 5c st %i5, [ %sp + 0x5c ]
203caa4: e4 23 a0 60 st %l2, [ %sp + 0x60 ]
203caa8: c2 23 a0 64 st %g1, [ %sp + 0x64 ]
203caac: 90 10 00 18 mov %i0, %o0
203cab0: 92 10 00 11 mov %l1, %o1
203cab4: 94 10 00 19 mov %i1, %o2
203cab8: 19 00 00 28 sethi %hi(0xa000), %o4
203cabc: 9a 10 20 01 mov 1, %o5
203cac0: 7f ff fd 7f call 203c0bc <rtems_rfs_inode_create>
203cac4: 98 13 21 ff or %o4, 0x1ff, %o4
RTEMS_RFS_S_SYMLINK,
1, uid, gid, &ino);
if (rc > 0)
203cac8: b4 92 20 00 orcc %o0, 0, %i2
203cacc: 34 80 00 62 bg,a 203cc54 <rtems_rfs_symlink+0x25c> <== NEVER TAKEN
203cad0: b0 10 00 1a mov %i2, %i0 <== NOT EXECUTED
return rc;
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
203cad4: d2 07 bf 74 ld [ %fp + -140 ], %o1
203cad8: 90 10 00 18 mov %i0, %o0
203cadc: 94 07 bf 88 add %fp, -120, %o2
203cae0: 7f ff fc 30 call 203bba0 <rtems_rfs_inode_open>
203cae4: 96 10 20 01 mov 1, %o3
if (rc > 0)
203cae8: b4 92 20 00 orcc %o0, 0, %i2
203caec: 34 80 00 5a bg,a 203cc54 <rtems_rfs_symlink+0x25c> <== NEVER TAKEN
203caf0: b0 10 00 1a mov %i2, %i0 <== NOT EXECUTED
/*
* 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)
203caf4: 80 a7 20 13 cmp %i4, 0x13
203caf8: 38 80 00 15 bgu,a 203cb4c <rtems_rfs_symlink+0x154> <== NEVER TAKEN
203cafc: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
{
memset (inode.node->data.name, 0, RTEMS_RFS_INODE_DATA_NAME_SIZE);
203cb00: d0 07 bf 94 ld [ %fp + -108 ], %o0
203cb04: 92 10 20 00 clr %o1
203cb08: 94 10 20 14 mov 0x14, %o2
203cb0c: 40 00 23 86 call 2045924 <memset>
203cb10: 90 02 20 1c add %o0, 0x1c, %o0
memcpy (inode.node->data.name, link, link_length);
203cb14: d0 07 bf 94 ld [ %fp + -108 ], %o0
203cb18: 92 10 00 1b mov %i3, %o1
203cb1c: 90 02 20 1c add %o0, 0x1c, %o0
203cb20: 40 00 22 f2 call 20456e8 <memcpy>
203cb24: 94 10 00 1c mov %i4, %o2
* @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);
203cb28: c2 07 bf 94 ld [ %fp + -108 ], %g1
203cb2c: c0 28 60 0c clrb [ %g1 + 0xc ]
203cb30: c2 07 bf 94 ld [ %fp + -108 ], %g1
203cb34: c0 28 60 0d clrb [ %g1 + 0xd ]
203cb38: c2 07 bf 94 ld [ %fp + -108 ], %g1
203cb3c: c0 28 60 0e clrb [ %g1 + 0xe ]
203cb40: c2 07 bf 94 ld [ %fp + -108 ], %g1
203cb44: 10 80 00 38 b 203cc24 <rtems_rfs_symlink+0x22c>
203cb48: c0 28 60 0f clrb [ %g1 + 0xf ]
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);
203cb4c: 92 07 bf 88 add %fp, -120, %o1 <== NOT EXECUTED
203cb50: 7f ff e6 9a call 20365b8 <rtems_rfs_block_map_open> <== NOT EXECUTED
203cb54: 94 07 bf b0 add %fp, -80, %o2 <== NOT EXECUTED
203cb58: b4 10 00 08 mov %o0, %i2 <== NOT EXECUTED
if (rc > 0)
203cb5c: 80 a6 a0 00 cmp %i2, 0 <== NOT EXECUTED
203cb60: 14 80 00 2d bg 203cc14 <rtems_rfs_symlink+0x21c> <== NOT EXECUTED
203cb64: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
{
rtems_rfs_inode_close (fs, &inode);
return rc;
}
rc = rtems_rfs_block_map_grow (fs, &map, 1, &block);
203cb68: 92 07 bf b0 add %fp, -80, %o1 <== NOT EXECUTED
203cb6c: 94 10 20 01 mov 1, %o2 <== NOT EXECUTED
203cb70: 7f ff e7 ed call 2036b24 <rtems_rfs_block_map_grow> <== NOT EXECUTED
203cb74: 96 07 bf 78 add %fp, -136, %o3 <== NOT EXECUTED
if (rc > 0)
203cb78: b4 92 20 00 orcc %o0, 0, %i2 <== NOT EXECUTED
203cb7c: 14 80 00 0c bg 203cbac <rtems_rfs_symlink+0x1b4> <== NOT EXECUTED
203cb80: 90 10 00 18 mov %i0, %o0 <== 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);
203cb84: d4 07 bf 78 ld [ %fp + -136 ], %o2 <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
203cb88: c0 2f bf 7c clrb [ %fp + -132 ] <== NOT EXECUTED
handle->bnum = 0;
203cb8c: c0 27 bf 80 clr [ %fp + -128 ] <== NOT EXECUTED
handle->buffer = NULL;
203cb90: c0 27 bf 84 clr [ %fp + -124 ] <== NOT EXECUTED
203cb94: 92 07 bf 7c add %fp, -132, %o1 <== NOT EXECUTED
203cb98: 7f ff ea 75 call 203756c <rtems_rfs_buffer_handle_request><== NOT EXECUTED
203cb9c: 96 10 20 00 clr %o3 <== NOT EXECUTED
if (rc > 0)
203cba0: b4 92 20 00 orcc %o0, 0, %i2 <== NOT EXECUTED
203cba4: 04 80 00 06 ble 203cbbc <rtems_rfs_symlink+0x1c4> <== NOT EXECUTED
203cba8: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
{
rtems_rfs_block_map_close (fs, &map);
203cbac: 7f ff e6 e4 call 203673c <rtems_rfs_block_map_close> <== NOT EXECUTED
203cbb0: 92 07 bf b0 add %fp, -80, %o1 <== NOT EXECUTED
}
rc = rtems_rfs_block_map_close (fs, &map);
if (rc > 0)
{
rtems_rfs_inode_close (fs, &inode);
203cbb4: 10 80 00 18 b 203cc14 <rtems_rfs_symlink+0x21c> <== NOT EXECUTED
203cbb8: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
rtems_rfs_block_map_close (fs, &map);
rtems_rfs_inode_close (fs, &inode);
return rc;
}
data = rtems_rfs_buffer_data (&buffer);
203cbbc: c2 07 bf 84 ld [ %fp + -124 ], %g1 <== NOT EXECUTED
memset (data, 0xff, rtems_rfs_fs_block_size (fs));
203cbc0: d4 06 20 08 ld [ %i0 + 8 ], %o2 <== NOT EXECUTED
rtems_rfs_block_map_close (fs, &map);
rtems_rfs_inode_close (fs, &inode);
return rc;
}
data = rtems_rfs_buffer_data (&buffer);
203cbc4: fa 00 60 1c ld [ %g1 + 0x1c ], %i5 <== NOT EXECUTED
memset (data, 0xff, rtems_rfs_fs_block_size (fs));
203cbc8: 92 10 20 ff mov 0xff, %o1 <== NOT EXECUTED
203cbcc: 40 00 23 56 call 2045924 <memset> <== NOT EXECUTED
203cbd0: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
memcpy (data, link, link_length);
203cbd4: 94 10 00 1c mov %i4, %o2 <== NOT EXECUTED
203cbd8: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
203cbdc: 40 00 22 c3 call 20456e8 <memcpy> <== NOT EXECUTED
203cbe0: 90 10 00 1d mov %i5, %o0 <== 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);
203cbe4: 92 07 bf 7c add %fp, -132, %o1 <== NOT EXECUTED
203cbe8: 7f ff e9 ed call 203739c <rtems_rfs_buffer_handle_release><== NOT EXECUTED
203cbec: 90 10 00 18 mov %i0, %o0 <== 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);
203cbf0: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
handle->dirty = false;
203cbf4: c0 2f bf 7c clrb [ %fp + -132 ] <== NOT EXECUTED
handle->bnum = 0;
203cbf8: c0 27 bf 80 clr [ %fp + -128 ] <== NOT EXECUTED
handle->buffer = NULL;
203cbfc: c0 27 bf 84 clr [ %fp + -124 ] <== NOT EXECUTED
203cc00: 7f ff e6 cf call 203673c <rtems_rfs_block_map_close> <== NOT EXECUTED
203cc04: 92 07 bf b0 add %fp, -80, %o1 <== NOT EXECUTED
if (rc > 0)
203cc08: b4 92 20 00 orcc %o0, 0, %i2 <== NOT EXECUTED
203cc0c: 04 80 00 06 ble 203cc24 <rtems_rfs_symlink+0x22c> <== NOT EXECUTED
203cc10: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
{
rtems_rfs_inode_close (fs, &inode);
203cc14: 7f ff fc 55 call 203bd68 <rtems_rfs_inode_close> <== NOT EXECUTED
203cc18: 92 07 bf 88 add %fp, -120, %o1 <== NOT EXECUTED
rtems_rfs_inode_set_block_offset (&inode, link_length);
rc = rtems_rfs_inode_close (fs, &inode);
return rc;
}
203cc1c: 81 c7 e0 08 ret <== NOT EXECUTED
203cc20: 91 e8 00 1a restore %g0, %i2, %o0 <== 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);
203cc24: c2 07 bf 94 ld [ %fp + -108 ], %g1
203cc28: 85 37 20 08 srl %i4, 8, %g2
203cc2c: c4 28 60 0a stb %g2, [ %g1 + 0xa ]
203cc30: c2 07 bf 94 ld [ %fp + -108 ], %g1
}
}
rtems_rfs_inode_set_block_offset (&inode, link_length);
rc = rtems_rfs_inode_close (fs, &inode);
203cc34: 90 10 00 18 mov %i0, %o0
203cc38: f8 28 60 0b stb %i4, [ %g1 + 0xb ]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
203cc3c: 82 10 20 01 mov 1, %g1
203cc40: 92 07 bf 88 add %fp, -120, %o1
203cc44: 7f ff fc 49 call 203bd68 <rtems_rfs_inode_close>
203cc48: c2 2f bf 98 stb %g1, [ %fp + -104 ]
203cc4c: b4 10 00 08 mov %o0, %i2
return rc;
}
203cc50: b0 10 00 1a mov %i2, %i0
203cc54: 81 c7 e0 08 ret
203cc58: 81 e8 00 00 restore
0203cc5c <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)
{
203cc5c: 9d e3 bf 18 save %sp, -232, %sp
rtems_rfs_inode_handle inode;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_SYMLINK_READ))
203cc60: 90 10 20 04 mov 4, %o0
203cc64: 92 10 20 00 clr %o1
203cc68: 7f ff 9b 79 call 2023a4c <rtems_rfs_trace>
203cc6c: ba 10 00 18 mov %i0, %i5
203cc70: 80 8a 20 ff btst 0xff, %o0
203cc74: 22 80 00 07 be,a 203cc90 <rtems_rfs_symlink_read+0x34> <== ALWAYS TAKEN
203cc78: 90 10 00 1d mov %i5, %o0
printf ("rtems-rfs: symlink-read: link:%" PRIu32 "\n", link);
203cc7c: 11 00 81 a4 sethi %hi(0x2069000), %o0 <== NOT EXECUTED
203cc80: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
203cc84: 40 00 27 99 call 2046ae8 <printf> <== NOT EXECUTED
203cc88: 90 12 23 a0 or %o0, 0x3a0, %o0 <== NOT EXECUTED
rc = rtems_rfs_inode_open (fs, link, &inode, true);
203cc8c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
203cc90: 92 10 00 19 mov %i1, %o1
203cc94: 94 07 bf 88 add %fp, -120, %o2
203cc98: 7f ff fb c2 call 203bba0 <rtems_rfs_inode_open>
203cc9c: 96 10 20 01 mov 1, %o3
if (rc)
203cca0: b0 92 20 00 orcc %o0, 0, %i0
203cca4: 12 80 00 0d bne 203ccd8 <rtems_rfs_symlink_read+0x7c> <== NEVER TAKEN
203cca8: d2 07 bf 94 ld [ %fp + -108 ], %o1
return rc;
if (!RTEMS_RFS_S_ISLNK (rtems_rfs_inode_get_mode (&inode)))
203ccac: 03 00 00 3c sethi %hi(0xf000), %g1
* @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);
203ccb0: c4 0a 60 02 ldub [ %o1 + 2 ], %g2
203ccb4: 85 28 a0 08 sll %g2, 8, %g2
203ccb8: 84 08 80 01 and %g2, %g1, %g2
203ccbc: 03 00 00 28 sethi %hi(0xa000), %g1
203ccc0: 80 a0 80 01 cmp %g2, %g1
203ccc4: 02 80 00 07 be 203cce0 <rtems_rfs_symlink_read+0x84> <== ALWAYS TAKEN
203ccc8: 90 10 00 1d mov %i5, %o0
{
rtems_rfs_inode_close (fs, &inode);
203cccc: 92 07 bf 88 add %fp, -120, %o1 <== NOT EXECUTED
203ccd0: 7f ff fc 26 call 203bd68 <rtems_rfs_inode_close> <== NOT EXECUTED
203ccd4: b0 10 20 16 mov 0x16, %i0 <== NOT EXECUTED
203ccd8: 81 c7 e0 08 ret <== NOT EXECUTED
203ccdc: 81 e8 00 00 restore <== NOT EXECUTED
* @return uint32_t The block offset.
*/
static inline uint16_t
rtems_rfs_inode_get_block_offset (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u16 (&handle->node->block_offset);
203cce0: d4 0a 60 0a ldub [ %o1 + 0xa ], %o2
return EINVAL;
}
*length = rtems_rfs_inode_get_block_offset (&inode);
203cce4: c2 0a 60 0b ldub [ %o1 + 0xb ], %g1
203cce8: 95 2a a0 08 sll %o2, 8, %o2
203ccec: 94 10 40 0a or %g1, %o2, %o2
203ccf0: 80 a2 80 1b cmp %o2, %i3
203ccf4: 38 80 00 02 bgu,a 203ccfc <rtems_rfs_symlink_read+0xa0>
203ccf8: 94 10 00 1b mov %i3, %o2
203ccfc: d4 27 00 00 st %o2, [ %i4 ]
* @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);
203cd00: c2 0a 60 0d ldub [ %o1 + 0xd ], %g1
203cd04: c4 0a 60 0c ldub [ %o1 + 0xc ], %g2
203cd08: 83 28 60 10 sll %g1, 0x10, %g1
203cd0c: 85 28 a0 18 sll %g2, 0x18, %g2
203cd10: 84 10 80 01 or %g2, %g1, %g2
203cd14: c2 0a 60 0f ldub [ %o1 + 0xf ], %g1
203cd18: 84 10 80 01 or %g2, %g1, %g2
203cd1c: c2 0a 60 0e ldub [ %o1 + 0xe ], %g1
203cd20: 83 28 60 08 sll %g1, 8, %g1
if (size < *length)
{
*length = size;
}
if (rtems_rfs_inode_get_block_count (&inode) == 0)
203cd24: 80 90 80 01 orcc %g2, %g1, %g0
203cd28: 32 80 00 07 bne,a 203cd44 <rtems_rfs_symlink_read+0xe8> <== NEVER TAKEN
203cd2c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
{
memcpy (path, inode.node->data.name, *length);
203cd30: 90 10 00 1a mov %i2, %o0
203cd34: 40 00 22 6d call 20456e8 <memcpy>
203cd38: 92 02 60 1c add %o1, 0x1c, %o1
rtems_rfs_inode_close (fs, &inode);
return rc;
}
}
rc = rtems_rfs_inode_close (fs, &inode);
203cd3c: 10 80 00 34 b 203ce0c <rtems_rfs_symlink_read+0x1b0>
203cd40: 90 10 00 1d mov %i5, %o0
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);
203cd44: 92 07 bf 88 add %fp, -120, %o1 <== NOT EXECUTED
203cd48: 7f ff e6 1c call 20365b8 <rtems_rfs_block_map_open> <== NOT EXECUTED
203cd4c: 94 07 bf b0 add %fp, -80, %o2 <== NOT EXECUTED
203cd50: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED
if (rc > 0)
203cd54: 80 a6 20 00 cmp %i0, 0 <== NOT EXECUTED
203cd58: 14 80 00 29 bg 203cdfc <rtems_rfs_symlink_read+0x1a0> <== NOT EXECUTED
203cd5c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
{
rtems_rfs_inode_close (fs, &inode);
return rc;
}
rc = rtems_rfs_block_map_seek (fs, &map, 0, &block);
203cd60: 92 07 bf b0 add %fp, -80, %o1 <== NOT EXECUTED
203cd64: 94 10 20 00 clr %o2 <== NOT EXECUTED
203cd68: 96 10 20 00 clr %o3 <== NOT EXECUTED
203cd6c: 7f ff e7 44 call 2036a7c <rtems_rfs_block_map_seek> <== NOT EXECUTED
203cd70: 98 07 bf 78 add %fp, -136, %o4 <== NOT EXECUTED
if (rc > 0)
203cd74: b0 92 20 00 orcc %o0, 0, %i0 <== NOT EXECUTED
203cd78: 14 80 00 0c bg 203cda8 <rtems_rfs_symlink_read+0x14c> <== NOT EXECUTED
203cd7c: 90 10 00 1d mov %i5, %o0 <== 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);
203cd80: d4 07 bf 78 ld [ %fp + -136 ], %o2 <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
203cd84: c0 2f bf 7c clrb [ %fp + -132 ] <== NOT EXECUTED
handle->bnum = 0;
203cd88: c0 27 bf 80 clr [ %fp + -128 ] <== NOT EXECUTED
handle->buffer = NULL;
203cd8c: c0 27 bf 84 clr [ %fp + -124 ] <== NOT EXECUTED
203cd90: 92 07 bf 7c add %fp, -132, %o1 <== NOT EXECUTED
203cd94: 7f ff e9 f6 call 203756c <rtems_rfs_buffer_handle_request><== NOT EXECUTED
203cd98: 96 10 20 00 clr %o3 <== NOT EXECUTED
if (rc > 0)
203cd9c: b0 92 20 00 orcc %o0, 0, %i0 <== NOT EXECUTED
203cda0: 04 80 00 06 ble 203cdb8 <rtems_rfs_symlink_read+0x15c> <== NOT EXECUTED
203cda4: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
{
rtems_rfs_block_map_close (fs, &map);
203cda8: 7f ff e6 65 call 203673c <rtems_rfs_block_map_close> <== NOT EXECUTED
203cdac: 92 07 bf b0 add %fp, -80, %o1 <== NOT EXECUTED
}
rc = rtems_rfs_block_map_close (fs, &map);
if (rc > 0)
{
rtems_rfs_inode_close (fs, &inode);
203cdb0: 10 80 00 13 b 203cdfc <rtems_rfs_symlink_read+0x1a0> <== NOT EXECUTED
203cdb4: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
rtems_rfs_inode_close (fs, &inode);
return rc;
}
data = rtems_rfs_buffer_data (&buffer);
memcpy (path, data, *length);
203cdb8: c2 07 bf 84 ld [ %fp + -124 ], %g1 <== NOT EXECUTED
203cdbc: d4 07 00 00 ld [ %i4 ], %o2 <== NOT EXECUTED
203cdc0: d2 00 60 1c ld [ %g1 + 0x1c ], %o1 <== NOT EXECUTED
203cdc4: 40 00 22 49 call 20456e8 <memcpy> <== NOT EXECUTED
203cdc8: 90 10 00 1a mov %i2, %o0 <== 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);
203cdcc: 92 07 bf 7c add %fp, -132, %o1 <== NOT EXECUTED
203cdd0: 7f ff e9 73 call 203739c <rtems_rfs_buffer_handle_release><== NOT EXECUTED
203cdd4: 90 10 00 1d mov %i5, %o0 <== 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);
203cdd8: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
handle->dirty = false;
203cddc: c0 2f bf 7c clrb [ %fp + -132 ] <== NOT EXECUTED
handle->bnum = 0;
203cde0: c0 27 bf 80 clr [ %fp + -128 ] <== NOT EXECUTED
handle->buffer = NULL;
203cde4: c0 27 bf 84 clr [ %fp + -124 ] <== NOT EXECUTED
203cde8: 7f ff e6 55 call 203673c <rtems_rfs_block_map_close> <== NOT EXECUTED
203cdec: 92 07 bf b0 add %fp, -80, %o1 <== NOT EXECUTED
if (rc > 0)
203cdf0: b0 92 20 00 orcc %o0, 0, %i0 <== NOT EXECUTED
203cdf4: 04 80 00 06 ble 203ce0c <rtems_rfs_symlink_read+0x1b0> <== NOT EXECUTED
203cdf8: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
{
rtems_rfs_inode_close (fs, &inode);
203cdfc: 7f ff fb db call 203bd68 <rtems_rfs_inode_close> <== NOT EXECUTED
203ce00: 92 07 bf 88 add %fp, -120, %o1 <== NOT EXECUTED
203ce04: 81 c7 e0 08 ret <== NOT EXECUTED
203ce08: 81 e8 00 00 restore <== NOT EXECUTED
return rc;
}
}
rc = rtems_rfs_inode_close (fs, &inode);
203ce0c: 7f ff fb d7 call 203bd68 <rtems_rfs_inode_close>
203ce10: 92 07 bf 88 add %fp, -120, %o1
203ce14: b0 10 00 08 mov %o0, %i0
return rc;
}
203ce18: 81 c7 e0 08 ret
203ce1c: 81 e8 00 00 restore
02023a8c <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;
2023a8c: 03 00 81 bb sethi %hi(0x206ec00), %g1 <== NOT EXECUTED
2023a90: c4 18 63 e8 ldd [ %g1 + 0x3e8 ], %g2 ! 206efe8 <rtems_rfs_trace_flags><== NOT EXECUTED
rtems_rfs_trace_flags &= ~mask;
2023a94: 90 28 80 08 andn %g2, %o0, %o0 <== NOT EXECUTED
2023a98: 92 28 c0 09 andn %g3, %o1, %o1 <== NOT EXECUTED
2023a9c: d0 38 63 e8 std %o0, [ %g1 + 0x3e8 ] <== NOT EXECUTED
return state;
}
2023aa0: 90 10 00 02 mov %g2, %o0 <== NOT EXECUTED
2023aa4: 81 c3 e0 08 retl <== NOT EXECUTED
2023aa8: 92 10 00 03 mov %g3, %o1 <== NOT EXECUTED
02023a6c <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;
2023a6c: 03 00 81 bb sethi %hi(0x206ec00), %g1 <== NOT EXECUTED
2023a70: c4 18 63 e8 ldd [ %g1 + 0x3e8 ], %g2 ! 206efe8 <rtems_rfs_trace_flags><== NOT EXECUTED
rtems_rfs_trace_flags |= mask;
2023a74: 90 12 00 02 or %o0, %g2, %o0 <== NOT EXECUTED
2023a78: 92 12 40 03 or %o1, %g3, %o1 <== NOT EXECUTED
2023a7c: d0 38 63 e8 std %o0, [ %g1 + 0x3e8 ] <== NOT EXECUTED
return state;
}
2023a80: 90 10 00 02 mov %g2, %o0 <== NOT EXECUTED
2023a84: 81 c3 e0 08 retl <== NOT EXECUTED
2023a88: 92 10 00 03 mov %g3, %o1 <== NOT EXECUTED
02023aac <rtems_rfs_trace_shell_command>:
int
rtems_rfs_trace_shell_command (int argc, char *argv[])
{
2023aac: 9d e3 be f8 save %sp, -264, %sp <== NOT EXECUTED
const char* table[] =
2023ab0: 13 00 81 8e sethi %hi(0x2063800), %o1 <== NOT EXECUTED
2023ab4: 90 07 bf 64 add %fp, -156, %o0 <== NOT EXECUTED
2023ab8: 92 12 60 bc or %o1, 0xbc, %o1 <== NOT EXECUTED
2023abc: 94 10 20 9c mov 0x9c, %o2 <== NOT EXECUTED
return 1;
}
}
else
{
if (strcmp (argv[arg], "set") == 0)
2023ac0: 29 00 81 8d sethi %hi(0x2063400), %l4 <== NOT EXECUTED
set = true;
if (strcmp (argv[arg], "clear") == 0)
2023ac4: 2b 00 81 8d sethi %hi(0x2063400), %l5 <== NOT EXECUTED
}
int
rtems_rfs_trace_shell_command (int argc, char *argv[])
{
const char* table[] =
2023ac8: 40 00 87 08 call 20456e8 <memcpy> <== NOT EXECUTED
2023acc: 2d 00 81 8d sethi %hi(0x2063400), %l6 <== NOT EXECUTED
rtems_rfs_trace_mask clear_value = 0;
bool set = true;
int arg;
int t;
for (arg = 1; arg < argc; arg++)
2023ad0: a2 10 20 01 mov 1, %l1 <== NOT EXECUTED
"file-set"
};
rtems_rfs_trace_mask set_value = 0;
rtems_rfs_trace_mask clear_value = 0;
bool set = true;
2023ad4: a4 10 20 01 mov 1, %l2 <== NOT EXECUTED
"file-io",
"file-set"
};
rtems_rfs_trace_mask set_value = 0;
rtems_rfs_trace_mask clear_value = 0;
2023ad8: b4 10 20 00 clr %i2 <== NOT EXECUTED
2023adc: b6 10 20 00 clr %i3 <== NOT EXECUTED
"file-close",
"file-io",
"file-set"
};
rtems_rfs_trace_mask set_value = 0;
2023ae0: b8 10 20 00 clr %i4 <== NOT EXECUTED
2023ae4: ba 10 20 00 clr %i5 <== NOT EXECUTED
return 1;
}
}
else
{
if (strcmp (argv[arg], "set") == 0)
2023ae8: a8 15 22 48 or %l4, 0x248, %l4 <== NOT EXECUTED
set = true;
if (strcmp (argv[arg], "clear") == 0)
2023aec: aa 15 62 50 or %l5, 0x250, %l5 <== NOT EXECUTED
set = false;
else if (strcmp (argv[arg], "all") == 0)
2023af0: ac 15 a2 58 or %l6, 0x258, %l6 <== NOT EXECUTED
rtems_rfs_trace_mask clear_value = 0;
bool set = true;
int arg;
int t;
for (arg = 1; arg < argc; arg++)
2023af4: 10 80 00 68 b 2023c94 <rtems_rfs_trace_shell_command+0x1e8><== NOT EXECUTED
2023af8: 27 00 81 bb sethi %hi(0x206ec00), %l3 <== NOT EXECUTED
{
if (argv[arg][0] == '-')
2023afc: e0 06 40 01 ld [ %i1 + %g1 ], %l0 <== NOT EXECUTED
2023b00: c2 4c 00 00 ldsb [ %l0 ], %g1 <== NOT EXECUTED
2023b04: 80 a0 60 2d cmp %g1, 0x2d <== NOT EXECUTED
2023b08: 12 80 00 25 bne 2023b9c <rtems_rfs_trace_shell_command+0xf0><== NOT EXECUTED
2023b0c: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
{
switch (argv[arg][1])
2023b10: c2 4c 20 01 ldsb [ %l0 + 1 ], %g1 <== NOT EXECUTED
2023b14: 80 a0 60 68 cmp %g1, 0x68 <== NOT EXECUTED
2023b18: 02 80 00 06 be 2023b30 <rtems_rfs_trace_shell_command+0x84><== NOT EXECUTED
2023b1c: 80 a0 60 6c cmp %g1, 0x6c <== NOT EXECUTED
2023b20: 32 80 00 1a bne,a 2023b88 <rtems_rfs_trace_shell_command+0xdc><== NOT EXECUTED
2023b24: 11 00 81 8d sethi %hi(0x2063400), %o0 <== 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]);
2023b28: 10 80 00 08 b 2023b48 <rtems_rfs_trace_shell_command+0x9c><== NOT EXECUTED
2023b2c: d2 06 40 00 ld [ %i1 ], %o1 <== NOT EXECUTED
if (argv[arg][0] == '-')
{
switch (argv[arg][1])
{
case 'h':
printf ("usage: %s [-hl] [set/clear] [flags]\n", argv[0]);
2023b30: d2 06 40 00 ld [ %i1 ], %o1 <== NOT EXECUTED
2023b34: 11 00 81 8d sethi %hi(0x2063400), %o0 <== NOT EXECUTED
2023b38: 40 00 8b ec call 2046ae8 <printf> <== NOT EXECUTED
2023b3c: 90 12 21 d8 or %o0, 0x1d8, %o0 ! 20635d8 <rtems_rfs_rtems_eval_config+0xaa0><== NOT EXECUTED
return 0;
case 'l':
printf ("%s: valid flags to set or clear are:\n", argv[0]);
for (t = 0; t < (sizeof (table) / sizeof (const char*)); t++)
printf (" %s\n", table[t]);
return 0;
2023b40: 81 c7 e0 08 ret <== NOT EXECUTED
2023b44: 91 e8 20 00 restore %g0, 0, %o0 <== 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]);
2023b48: 11 00 81 8d sethi %hi(0x2063400), %o0 <== NOT EXECUTED
for (t = 0; t < (sizeof (table) / sizeof (const char*)); t++)
printf (" %s\n", table[t]);
2023b4c: 39 00 81 8d sethi %hi(0x2063400), %i4 <== 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]);
2023b50: 90 12 22 00 or %o0, 0x200, %o0 <== NOT EXECUTED
2023b54: 40 00 8b e5 call 2046ae8 <printf> <== NOT EXECUTED
2023b58: ba 10 20 00 clr %i5 <== NOT EXECUTED
for (t = 0; t < (sizeof (table) / sizeof (const char*)); t++)
printf (" %s\n", table[t]);
2023b5c: b8 17 22 28 or %i4, 0x228, %i4 <== NOT EXECUTED
2023b60: 82 07 bf 64 add %fp, -156, %g1 <== NOT EXECUTED
2023b64: d2 00 40 1d ld [ %g1 + %i5 ], %o1 <== NOT EXECUTED
2023b68: 40 00 8b e0 call 2046ae8 <printf> <== NOT EXECUTED
2023b6c: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
2023b70: ba 07 60 04 add %i5, 4, %i5 <== 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++)
2023b74: 80 a7 60 9c cmp %i5, 0x9c <== NOT EXECUTED
2023b78: 12 bf ff fb bne 2023b64 <rtems_rfs_trace_shell_command+0xb8><== NOT EXECUTED
2023b7c: 82 07 bf 64 add %fp, -156, %g1 <== NOT EXECUTED
printf (" %s\n", table[t]);
return 0;
2023b80: 81 c7 e0 08 ret <== NOT EXECUTED
2023b84: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED
default:
printf ("error: unknown option\n");
return 1;
2023b88: b0 10 20 01 mov 1, %i0 <== NOT EXECUTED
printf ("%s: valid flags to set or clear are:\n", argv[0]);
for (t = 0; t < (sizeof (table) / sizeof (const char*)); t++)
printf (" %s\n", table[t]);
return 0;
default:
printf ("error: unknown option\n");
2023b8c: 40 00 8c 6f call 2046d48 <puts> <== NOT EXECUTED
2023b90: 90 12 22 30 or %o0, 0x230, %o0 <== NOT EXECUTED
2023b94: 81 c7 e0 08 ret <== NOT EXECUTED
2023b98: 81 e8 00 00 restore <== NOT EXECUTED
return 1;
}
}
else
{
if (strcmp (argv[arg], "set") == 0)
2023b9c: 40 00 93 6d call 2048950 <strcmp> <== NOT EXECUTED
2023ba0: 92 10 00 14 mov %l4, %o1 <== NOT EXECUTED
2023ba4: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2023ba8: 22 80 00 02 be,a 2023bb0 <rtems_rfs_trace_shell_command+0x104><== NOT EXECUTED
2023bac: a4 10 20 01 mov 1, %l2 <== NOT EXECUTED
set = true;
if (strcmp (argv[arg], "clear") == 0)
2023bb0: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
2023bb4: 40 00 93 67 call 2048950 <strcmp> <== NOT EXECUTED
2023bb8: 92 10 00 15 mov %l5, %o1 <== NOT EXECUTED
2023bbc: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2023bc0: 22 80 00 2e be,a 2023c78 <rtems_rfs_trace_shell_command+0x1cc><== NOT EXECUTED
2023bc4: a4 10 20 00 clr %l2 <== NOT EXECUTED
set = false;
else if (strcmp (argv[arg], "all") == 0)
2023bc8: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
2023bcc: 40 00 93 61 call 2048950 <strcmp> <== NOT EXECUTED
2023bd0: 92 10 00 16 mov %l6, %o1 <== NOT EXECUTED
2023bd4: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2023bd8: 12 80 00 09 bne 2023bfc <rtems_rfs_trace_shell_command+0x150><== NOT EXECUTED
2023bdc: 94 10 20 00 clr %o2 <== NOT EXECUTED
{
if (set)
2023be0: 80 8c a0 ff btst 0xff, %l2 <== NOT EXECUTED
2023be4: 22 80 00 23 be,a 2023c70 <rtems_rfs_trace_shell_command+0x1c4><== NOT EXECUTED
2023be8: 35 3f ff ff sethi %hi(0xfffffc00), %i2 <== NOT EXECUTED
set_value = RTEMS_RFS_TRACE_ALL;
2023bec: 39 3f ff ff sethi %hi(0xfffffc00), %i4 <== NOT EXECUTED
2023bf0: b8 17 23 ff or %i4, 0x3ff, %i4 ! ffffffff <RAM_END+0xfdbfffff><== NOT EXECUTED
2023bf4: 10 80 00 21 b 2023c78 <rtems_rfs_trace_shell_command+0x1cc><== NOT EXECUTED
2023bf8: ba 10 00 1c mov %i4, %i5 <== NOT EXECUTED
rtems_rfs_trace_flags &= ~mask;
return state;
}
int
rtems_rfs_trace_shell_command (int argc, char *argv[])
2023bfc: 83 2a a0 02 sll %o2, 2, %g1 <== NOT EXECUTED
}
else
{
for (t = 0; t < (sizeof (table) / sizeof (const char*)); t++)
{
if (strcmp (argv[arg], table[t]) == 0)
2023c00: 84 07 bf 64 add %fp, -156, %g2 <== NOT EXECUTED
2023c04: d2 00 80 01 ld [ %g2 + %g1 ], %o1 <== NOT EXECUTED
2023c08: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
2023c0c: 40 00 93 51 call 2048950 <strcmp> <== NOT EXECUTED
2023c10: d4 27 bf 5c st %o2, [ %fp + -164 ] <== NOT EXECUTED
2023c14: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2023c18: 12 80 00 10 bne 2023c58 <rtems_rfs_trace_shell_command+0x1ac><== NOT EXECUTED
2023c1c: d4 07 bf 5c ld [ %fp + -164 ], %o2 <== NOT EXECUTED
{
if (set)
set_value = 1ULL << t;
2023c20: 90 10 20 00 clr %o0 <== NOT EXECUTED
{
for (t = 0; t < (sizeof (table) / sizeof (const char*)); t++)
{
if (strcmp (argv[arg], table[t]) == 0)
{
if (set)
2023c24: 80 8c a0 ff btst 0xff, %l2 <== NOT EXECUTED
2023c28: 02 80 00 07 be 2023c44 <rtems_rfs_trace_shell_command+0x198><== NOT EXECUTED
2023c2c: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
set_value = 1ULL << t;
2023c30: 40 00 df f0 call 205bbf0 <__ashldi3> <== NOT EXECUTED
2023c34: 01 00 00 00 nop <== NOT EXECUTED
2023c38: b8 10 00 08 mov %o0, %i4 <== NOT EXECUTED
2023c3c: 10 80 00 0f b 2023c78 <rtems_rfs_trace_shell_command+0x1cc><== NOT EXECUTED
2023c40: ba 10 00 09 mov %o1, %i5 <== NOT EXECUTED
else
clear_value = 1ULL << t;
2023c44: 40 00 df eb call 205bbf0 <__ashldi3> <== NOT EXECUTED
2023c48: 01 00 00 00 nop <== NOT EXECUTED
2023c4c: b4 10 00 08 mov %o0, %i2 <== NOT EXECUTED
2023c50: 10 80 00 0a b 2023c78 <rtems_rfs_trace_shell_command+0x1cc><== NOT EXECUTED
2023c54: b6 10 00 09 mov %o1, %i3 <== NOT EXECUTED
else
clear_value = RTEMS_RFS_TRACE_ALL;
}
else
{
for (t = 0; t < (sizeof (table) / sizeof (const char*)); t++)
2023c58: 94 02 a0 01 inc %o2 <== NOT EXECUTED
2023c5c: 80 a2 a0 27 cmp %o2, 0x27 <== NOT EXECUTED
2023c60: 12 bf ff e8 bne 2023c00 <rtems_rfs_trace_shell_command+0x154><== NOT EXECUTED
2023c64: 83 2a a0 02 sll %o2, 2, %g1 <== NOT EXECUTED
break;
}
}
}
rtems_rfs_trace_flags |= set_value;
2023c68: 10 80 00 05 b 2023c7c <rtems_rfs_trace_shell_command+0x1d0><== NOT EXECUTED
2023c6c: c4 1c e3 e8 ldd [ %l3 + 0x3e8 ], %g2 <== NOT EXECUTED
else if (strcmp (argv[arg], "all") == 0)
{
if (set)
set_value = RTEMS_RFS_TRACE_ALL;
else
clear_value = RTEMS_RFS_TRACE_ALL;
2023c70: b4 16 a3 ff or %i2, 0x3ff, %i2 <== NOT EXECUTED
2023c74: b6 10 00 1a mov %i2, %i3 <== NOT EXECUTED
break;
}
}
}
rtems_rfs_trace_flags |= set_value;
2023c78: c4 1c e3 e8 ldd [ %l3 + 0x3e8 ], %g2 <== NOT EXECUTED
rtems_rfs_trace_mask clear_value = 0;
bool set = true;
int arg;
int t;
for (arg = 1; arg < argc; arg++)
2023c7c: a2 04 60 01 inc %l1 <== NOT EXECUTED
break;
}
}
}
rtems_rfs_trace_flags |= set_value;
2023c80: 84 17 00 02 or %i4, %g2, %g2 <== NOT EXECUTED
2023c84: 86 17 40 03 or %i5, %g3, %g3 <== NOT EXECUTED
rtems_rfs_trace_flags &= ~clear_value;
2023c88: 84 28 80 1a andn %g2, %i2, %g2 <== NOT EXECUTED
2023c8c: 86 28 c0 1b andn %g3, %i3, %g3 <== NOT EXECUTED
2023c90: c4 3c e3 e8 std %g2, [ %l3 + 0x3e8 ] <== NOT EXECUTED
rtems_rfs_trace_mask clear_value = 0;
bool set = true;
int arg;
int t;
for (arg = 1; arg < argc; arg++)
2023c94: 80 a4 40 18 cmp %l1, %i0 <== NOT EXECUTED
2023c98: 06 bf ff 99 bl 2023afc <rtems_rfs_trace_shell_command+0x50><== NOT EXECUTED
2023c9c: 83 2c 60 02 sll %l1, 2, %g1 <== NOT EXECUTED
2023ca0: 30 bf ff b8 b,a 2023b80 <rtems_rfs_trace_shell_command+0xd4><== NOT EXECUTED
0203c648 <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)
{
203c648: 9d e3 bf 50 save %sp, -176, %sp
rtems_rfs_inode_handle target_inode;
uint16_t links;
bool dir;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
203c64c: 90 10 20 00 clr %o0
203c650: 7f ff 9c ff call 2023a4c <rtems_rfs_trace>
203c654: 13 00 80 00 sethi %hi(0x2000000), %o1
203c658: 80 8a 20 ff btst 0xff, %o0
203c65c: 02 80 00 08 be 203c67c <rtems_rfs_unlink+0x34> <== ALWAYS TAKEN
203c660: 90 10 00 18 mov %i0, %o0
printf ("rtems-rfs: unlink: parent(%" PRIu32 ") -X-> (%" PRIu32 ")\n", parent, target);
203c664: 11 00 81 a4 sethi %hi(0x2069000), %o0 <== NOT EXECUTED
203c668: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
203c66c: 90 12 21 a0 or %o0, 0x1a0, %o0 <== NOT EXECUTED
203c670: 40 00 29 1e call 2046ae8 <printf> <== NOT EXECUTED
203c674: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED
rc = rtems_rfs_inode_open (fs, target, &target_inode, true);
203c678: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
203c67c: 92 10 00 1a mov %i2, %o1
203c680: 94 07 bf d8 add %fp, -40, %o2
203c684: 7f ff fd 47 call 203bba0 <rtems_rfs_inode_open>
203c688: 96 10 20 01 mov 1, %o3
if (rc)
203c68c: ba 92 20 00 orcc %o0, 0, %i5
203c690: 12 80 00 d7 bne 203c9ec <rtems_rfs_unlink+0x3a4> <== NEVER TAKEN
203c694: c2 07 bf e4 ld [ %fp + -28 ], %g1
/*
* If a directory process the unlink mode.
*/
dir = RTEMS_RFS_S_ISDIR (rtems_rfs_inode_get_mode (&target_inode));
203c698: 05 00 00 3c sethi %hi(0xf000), %g2
* @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);
203c69c: c2 08 60 02 ldub [ %g1 + 2 ], %g1
203c6a0: 83 28 60 08 sll %g1, 8, %g1
203c6a4: 82 08 40 02 and %g1, %g2, %g1
203c6a8: 05 00 00 10 sethi %hi(0x4000), %g2
203c6ac: 82 18 40 02 xor %g1, %g2, %g1
203c6b0: 80 a0 00 01 cmp %g0, %g1
203c6b4: a0 60 3f ff subx %g0, -1, %l0
if (dir)
203c6b8: 80 8c 20 ff btst 0xff, %l0
203c6bc: 02 80 00 26 be 203c754 <rtems_rfs_unlink+0x10c>
203c6c0: 80 a7 20 00 cmp %i4, 0
{
switch (dir_mode)
203c6c4: 22 80 00 06 be,a 203c6dc <rtems_rfs_unlink+0x94> <== NEVER TAKEN
203c6c8: 90 10 20 00 clr %o0 <== NOT EXECUTED
203c6cc: 80 a7 20 01 cmp %i4, 1
203c6d0: 12 80 00 22 bne 203c758 <rtems_rfs_unlink+0x110> <== NEVER TAKEN
203c6d4: 90 10 00 18 mov %i0, %o0
203c6d8: 30 80 00 0f b,a 203c714 <rtems_rfs_unlink+0xcc>
{
case rtems_rfs_unlink_dir_denied:
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
203c6dc: 7f ff 9c dc call 2023a4c <rtems_rfs_trace> <== NOT EXECUTED
203c6e0: 13 00 80 00 sethi %hi(0x2000000), %o1 <== NOT EXECUTED
203c6e4: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
203c6e8: 22 80 00 06 be,a 203c700 <rtems_rfs_unlink+0xb8> <== NOT EXECUTED
203c6ec: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
printf ("rtems-rfs: link is a directory\n");
203c6f0: 11 00 81 a4 sethi %hi(0x2069000), %o0 <== NOT EXECUTED
203c6f4: 40 00 29 95 call 2046d48 <puts> <== NOT EXECUTED
203c6f8: 90 12 21 d0 or %o0, 0x1d0, %o0 ! 20691d0 <__FUNCTION__.7829+0x20e0><== NOT EXECUTED
rtems_rfs_inode_close (fs, &target_inode);
203c6fc: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
203c700: 92 07 bf d8 add %fp, -40, %o1 <== NOT EXECUTED
203c704: 7f ff fd 99 call 203bd68 <rtems_rfs_inode_close> <== NOT EXECUTED
203c708: ba 10 20 15 mov 0x15, %i5 <== NOT EXECUTED
if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
printf ("rtems-rfs: link: target inode-close failed: %d: %s\n",
rc, strerror (rc));
return rc;
}
203c70c: 81 c7 e0 08 ret <== NOT EXECUTED
203c710: 91 e8 00 1d restore %g0, %i5, %o0 <== NOT EXECUTED
printf ("rtems-rfs: link is a directory\n");
rtems_rfs_inode_close (fs, &target_inode);
return EISDIR;
case rtems_rfs_unlink_dir_if_empty:
rc = rtems_rfs_dir_empty (fs, &target_inode);
203c714: 7f ff f1 58 call 2038c74 <rtems_rfs_dir_empty>
203c718: 92 07 bf d8 add %fp, -40, %o1
if (rc > 0)
203c71c: ba 92 20 00 orcc %o0, 0, %i5
203c720: 04 80 00 0d ble 203c754 <rtems_rfs_unlink+0x10c>
203c724: 90 10 20 00 clr %o0
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
203c728: 7f ff 9c c9 call 2023a4c <rtems_rfs_trace>
203c72c: 13 00 80 00 sethi %hi(0x2000000), %o1
203c730: 80 8a 20 ff btst 0xff, %o0
203c734: 22 80 00 97 be,a 203c990 <rtems_rfs_unlink+0x348> <== ALWAYS TAKEN
203c738: 90 10 00 18 mov %i0, %o0
printf ("rtems-rfs: dir-empty: %d: %s\n", rc, strerror (rc));
203c73c: 40 00 32 6a call 20490e4 <strerror> <== NOT EXECUTED
203c740: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
203c744: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
203c748: 11 00 81 a4 sethi %hi(0x2069000), %o0 <== NOT EXECUTED
203c74c: 10 80 00 8e b 203c984 <rtems_rfs_unlink+0x33c> <== NOT EXECUTED
203c750: 90 12 21 f0 or %o0, 0x1f0, %o0 ! 20691f0 <__FUNCTION__.7829+0x2100><== NOT EXECUTED
default:
break;
}
}
rc = rtems_rfs_inode_open (fs, parent, &parent_inode, true);
203c754: 90 10 00 18 mov %i0, %o0
203c758: 92 10 00 19 mov %i1, %o1
203c75c: 94 07 bf b0 add %fp, -80, %o2
203c760: 7f ff fd 10 call 203bba0 <rtems_rfs_inode_open>
203c764: 96 10 20 01 mov 1, %o3
if (rc)
203c768: ba 92 20 00 orcc %o0, 0, %i5
203c76c: 02 80 00 0e be 203c7a4 <rtems_rfs_unlink+0x15c> <== ALWAYS TAKEN
203c770: 90 10 00 18 mov %i0, %o0
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
203c774: 90 10 20 00 clr %o0 <== NOT EXECUTED
203c778: 7f ff 9c b5 call 2023a4c <rtems_rfs_trace> <== NOT EXECUTED
203c77c: 13 00 80 00 sethi %hi(0x2000000), %o1 <== NOT EXECUTED
203c780: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
203c784: 22 80 00 83 be,a 203c990 <rtems_rfs_unlink+0x348> <== NOT EXECUTED
203c788: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
printf ("rtems-rfs: link: inode-open failed: %d: %s\n",
203c78c: 40 00 32 56 call 20490e4 <strerror> <== NOT EXECUTED
203c790: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
203c794: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
203c798: 11 00 81 a4 sethi %hi(0x2069000), %o0 <== NOT EXECUTED
203c79c: 10 80 00 7a b 203c984 <rtems_rfs_unlink+0x33c> <== NOT EXECUTED
203c7a0: 90 12 22 10 or %o0, 0x210, %o0 ! 2069210 <__FUNCTION__.7829+0x2120><== 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);
203c7a4: 92 07 bf b0 add %fp, -80, %o1
203c7a8: 94 10 00 1a mov %i2, %o2
203c7ac: 7f ff ef 52 call 20384f4 <rtems_rfs_dir_del_entry>
203c7b0: 96 10 00 1b mov %i3, %o3
if (rc > 0)
203c7b4: ba 92 20 00 orcc %o0, 0, %i5
203c7b8: 04 80 00 0e ble 203c7f0 <rtems_rfs_unlink+0x1a8> <== ALWAYS TAKEN
203c7bc: 01 00 00 00 nop
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
203c7c0: 90 10 20 00 clr %o0 ! 0 <PROM_START> <== NOT EXECUTED
203c7c4: 7f ff 9c a2 call 2023a4c <rtems_rfs_trace> <== NOT EXECUTED
203c7c8: 13 00 80 00 sethi %hi(0x2000000), %o1 <== NOT EXECUTED
203c7cc: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
203c7d0: 22 80 00 59 be,a 203c934 <rtems_rfs_unlink+0x2ec> <== NOT EXECUTED
203c7d4: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
printf ("rtems-rfs: unlink: dir-del failed: %d: %s\n",
203c7d8: 40 00 32 43 call 20490e4 <strerror> <== NOT EXECUTED
203c7dc: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
203c7e0: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
203c7e4: 11 00 81 a4 sethi %hi(0x2069000), %o0 <== NOT EXECUTED
203c7e8: 10 80 00 50 b 203c928 <rtems_rfs_unlink+0x2e0> <== NOT EXECUTED
203c7ec: 90 12 22 40 or %o0, 0x240, %o0 ! 2069240 <__FUNCTION__.7829+0x2150><== 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);
203c7f0: 7f ff ff 1e call 203c468 <rtems_rfs_inode_get_links>
203c7f4: 90 07 bf d8 add %fp, -40, %o0
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
203c7f8: 13 00 80 00 sethi %hi(0x2000000), %o1
rtems_rfs_inode_close (fs, &parent_inode);
rtems_rfs_inode_close (fs, &target_inode);
return rc;
}
links = rtems_rfs_inode_get_links (&target_inode);
203c7fc: ba 10 00 08 mov %o0, %i5
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
203c800: 7f ff 9c 93 call 2023a4c <rtems_rfs_trace>
203c804: 90 10 20 00 clr %o0
203c808: 80 8a 20 ff btst 0xff, %o0
203c80c: 02 80 00 09 be 203c830 <rtems_rfs_unlink+0x1e8> <== ALWAYS TAKEN
203c810: 83 2f 60 10 sll %i5, 0x10, %g1
printf ("rtems-rfs: unlink: target:%" PRIu32 " links:%u\n", target, links);
203c814: 95 2f 60 10 sll %i5, 0x10, %o2 <== NOT EXECUTED
203c818: 11 00 81 a4 sethi %hi(0x2069000), %o0 <== NOT EXECUTED
203c81c: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED
203c820: 90 12 22 70 or %o0, 0x270, %o0 <== NOT EXECUTED
203c824: 40 00 28 b1 call 2046ae8 <printf> <== NOT EXECUTED
203c828: 95 32 a0 10 srl %o2, 0x10, %o2 <== NOT EXECUTED
if (links > 1)
203c82c: 83 2f 60 10 sll %i5, 0x10, %g1 <== NOT EXECUTED
203c830: 83 30 60 10 srl %g1, 0x10, %g1
203c834: 80 a0 60 01 cmp %g1, 1
203c838: 08 80 00 0a bleu 203c860 <rtems_rfs_unlink+0x218>
203c83c: c2 07 bf e4 ld [ %fp + -28 ], %g1
{
links--;
203c840: ba 07 7f ff add %i5, -1, %i5
* @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);
203c844: 85 37 60 08 srl %i5, 8, %g2
203c848: c4 28 40 00 stb %g2, [ %g1 ]
203c84c: c2 07 bf e4 ld [ %fp + -28 ], %g1
203c850: fa 28 60 01 stb %i5, [ %g1 + 1 ]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
203c854: 82 10 20 01 mov 1, %g1
203c858: 10 80 00 23 b 203c8e4 <rtems_rfs_unlink+0x29c>
203c85c: c2 2f bf e8 stb %g1, [ %fp + -24 ]
else
{
/*
* Erasing the inode releases all blocks attached to it.
*/
rc = rtems_rfs_inode_delete (fs, &target_inode);
203c860: 90 10 00 18 mov %i0, %o0
203c864: 7f ff fd 64 call 203bdf4 <rtems_rfs_inode_delete>
203c868: 92 07 bf d8 add %fp, -40, %o1
if (rc > 0)
203c86c: ba 92 20 00 orcc %o0, 0, %i5
203c870: 04 80 00 0d ble 203c8a4 <rtems_rfs_unlink+0x25c> <== ALWAYS TAKEN
203c874: 90 10 20 00 clr %o0
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
203c878: 7f ff 9c 75 call 2023a4c <rtems_rfs_trace> <== NOT EXECUTED
203c87c: 13 00 80 00 sethi %hi(0x2000000), %o1 <== NOT EXECUTED
203c880: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
203c884: 22 80 00 2c be,a 203c934 <rtems_rfs_unlink+0x2ec> <== NOT EXECUTED
203c888: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
printf ("rtems-rfs: unlink: inode-del failed: %d: %s\n",
203c88c: 40 00 32 16 call 20490e4 <strerror> <== NOT EXECUTED
203c890: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
203c894: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
203c898: 11 00 81 a4 sethi %hi(0x2069000), %o0 <== NOT EXECUTED
203c89c: 10 80 00 23 b 203c928 <rtems_rfs_unlink+0x2e0> <== NOT EXECUTED
203c8a0: 90 12 22 98 or %o0, 0x298, %o0 ! 2069298 <__FUNCTION__.7829+0x21a8><== NOT EXECUTED
rtems_rfs_inode_close (fs, &parent_inode);
rtems_rfs_inode_close (fs, &target_inode);
return rc;
}
if (dir)
203c8a4: 80 8c 20 ff btst 0xff, %l0
203c8a8: 02 80 00 10 be 203c8e8 <rtems_rfs_unlink+0x2a0>
203c8ac: 90 07 bf b0 add %fp, -80, %o0
{
links = rtems_rfs_inode_get_links (&parent_inode);
203c8b0: 7f ff fe ee call 203c468 <rtems_rfs_inode_get_links>
203c8b4: 90 07 bf b0 add %fp, -80, %o0
if (links > 1)
203c8b8: 80 a2 20 01 cmp %o0, 1
203c8bc: 08 80 00 03 bleu 203c8c8 <rtems_rfs_unlink+0x280>
203c8c0: 82 10 00 08 mov %o0, %g1
links--;
203c8c4: 82 02 3f ff add %o0, -1, %g1
* @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);
203c8c8: c4 07 bf bc ld [ %fp + -68 ], %g2
203c8cc: 87 30 60 08 srl %g1, 8, %g3
203c8d0: c6 28 80 00 stb %g3, [ %g2 ]
203c8d4: c4 07 bf bc ld [ %fp + -68 ], %g2
203c8d8: c2 28 a0 01 stb %g1, [ %g2 + 1 ]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
203c8dc: 82 10 20 01 mov 1, %g1
203c8e0: c2 2f bf c0 stb %g1, [ %fp + -64 ]
rtems_rfs_inode_set_links (&parent_inode, links);
}
}
rc = rtems_rfs_inode_time_stamp_now (&parent_inode, true, true);
203c8e4: 90 07 bf b0 add %fp, -80, %o0
203c8e8: 92 10 20 01 mov 1, %o1
203c8ec: 7f ff fd 77 call 203bec8 <rtems_rfs_inode_time_stamp_now>
203c8f0: 94 10 20 01 mov 1, %o2
if (rc > 0)
203c8f4: ba 92 20 00 orcc %o0, 0, %i5
203c8f8: 04 80 00 13 ble 203c944 <rtems_rfs_unlink+0x2fc> <== ALWAYS TAKEN
203c8fc: 90 10 20 00 clr %o0
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
203c900: 7f ff 9c 53 call 2023a4c <rtems_rfs_trace> <== NOT EXECUTED
203c904: 13 00 80 00 sethi %hi(0x2000000), %o1 <== NOT EXECUTED
203c908: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
203c90c: 22 80 00 0a be,a 203c934 <rtems_rfs_unlink+0x2ec> <== NOT EXECUTED
203c910: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
printf ("rtems-rfs: link: inode-time-stamp failed: %d: %s\n",
203c914: 40 00 31 f4 call 20490e4 <strerror> <== NOT EXECUTED
203c918: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
203c91c: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
203c920: 11 00 81 a4 sethi %hi(0x2069000), %o0 <== NOT EXECUTED
203c924: 90 12 22 c8 or %o0, 0x2c8, %o0 ! 20692c8 <__FUNCTION__.7829+0x21d8><== NOT EXECUTED
203c928: 40 00 28 70 call 2046ae8 <printf> <== NOT EXECUTED
203c92c: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
rc, strerror (rc));
rtems_rfs_inode_close (fs, &parent_inode);
203c930: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
203c934: 7f ff fd 0d call 203bd68 <rtems_rfs_inode_close> <== NOT EXECUTED
203c938: 92 07 bf b0 add %fp, -80, %o1 <== NOT EXECUTED
if (rc > 0)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
printf ("rtems-rfs: link: parent inode-close failed: %d: %s\n",
rc, strerror (rc));
rtems_rfs_inode_close (fs, &target_inode);
203c93c: 10 80 00 15 b 203c990 <rtems_rfs_unlink+0x348> <== NOT EXECUTED
203c940: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
rtems_rfs_inode_close (fs, &parent_inode);
rtems_rfs_inode_close (fs, &target_inode);
return rc;
}
rc = rtems_rfs_inode_close (fs, &parent_inode);
203c944: 90 10 00 18 mov %i0, %o0
203c948: 7f ff fd 08 call 203bd68 <rtems_rfs_inode_close>
203c94c: 92 07 bf b0 add %fp, -80, %o1
if (rc > 0)
203c950: ba 92 20 00 orcc %o0, 0, %i5
203c954: 04 80 00 13 ble 203c9a0 <rtems_rfs_unlink+0x358> <== ALWAYS TAKEN
203c958: 90 10 20 00 clr %o0
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
203c95c: 7f ff 9c 3c call 2023a4c <rtems_rfs_trace> <== NOT EXECUTED
203c960: 13 00 80 00 sethi %hi(0x2000000), %o1 <== NOT EXECUTED
203c964: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
203c968: 02 80 00 0a be 203c990 <rtems_rfs_unlink+0x348> <== NOT EXECUTED
203c96c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
printf ("rtems-rfs: link: parent inode-close failed: %d: %s\n",
203c970: 40 00 31 dd call 20490e4 <strerror> <== NOT EXECUTED
203c974: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
203c978: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
203c97c: 11 00 81 a4 sethi %hi(0x2069000), %o0 <== NOT EXECUTED
203c980: 90 12 23 00 or %o0, 0x300, %o0 ! 2069300 <__FUNCTION__.7829+0x2210><== NOT EXECUTED
203c984: 40 00 28 59 call 2046ae8 <printf> <== NOT EXECUTED
203c988: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
rc, strerror (rc));
rtems_rfs_inode_close (fs, &target_inode);
203c98c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
203c990: 7f ff fc f6 call 203bd68 <rtems_rfs_inode_close>
203c994: 92 07 bf d8 add %fp, -40, %o1
if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
printf ("rtems-rfs: link: target inode-close failed: %d: %s\n",
rc, strerror (rc));
return rc;
}
203c998: 81 c7 e0 08 ret
203c99c: 91 e8 00 1d restore %g0, %i5, %o0
rc, strerror (rc));
rtems_rfs_inode_close (fs, &target_inode);
return rc;
}
rc = rtems_rfs_inode_close (fs, &target_inode);
203c9a0: 90 10 00 18 mov %i0, %o0
203c9a4: 7f ff fc f1 call 203bd68 <rtems_rfs_inode_close>
203c9a8: 92 07 bf d8 add %fp, -40, %o1
if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
203c9ac: ba 92 20 00 orcc %o0, 0, %i5
203c9b0: 04 80 00 10 ble 203c9f0 <rtems_rfs_unlink+0x3a8> <== ALWAYS TAKEN
203c9b4: b0 10 00 1d mov %i5, %i0
203c9b8: 90 10 20 00 clr %o0 <== NOT EXECUTED
203c9bc: 7f ff 9c 24 call 2023a4c <rtems_rfs_trace> <== NOT EXECUTED
203c9c0: 13 00 80 00 sethi %hi(0x2000000), %o1 <== NOT EXECUTED
203c9c4: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
203c9c8: 22 80 00 0a be,a 203c9f0 <rtems_rfs_unlink+0x3a8> <== NOT EXECUTED
203c9cc: b0 10 00 1d mov %i5, %i0 <== NOT EXECUTED
printf ("rtems-rfs: link: target inode-close failed: %d: %s\n",
203c9d0: 40 00 31 c5 call 20490e4 <strerror> <== NOT EXECUTED
203c9d4: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
203c9d8: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
203c9dc: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
203c9e0: 11 00 81 a4 sethi %hi(0x2069000), %o0 <== NOT EXECUTED
203c9e4: 40 00 28 41 call 2046ae8 <printf> <== NOT EXECUTED
203c9e8: 90 12 23 38 or %o0, 0x338, %o0 ! 2069338 <__FUNCTION__.7829+0x2248><== NOT EXECUTED
rc, strerror (rc));
return rc;
}
203c9ec: b0 10 00 1d mov %i5, %i0 <== NOT EXECUTED
203c9f0: 81 c7 e0 08 ret
203c9f4: 81 e8 00 00 restore
02023678 <rtems_shell_debugrfs>:
}
int
rtems_shell_debugrfs (int argc, char *argv[])
{
2023678: 9d e3 be f0 save %sp, -272, %sp <== NOT EXECUTED
const rtems_rfs_shell_cmd table[] =
202367c: 13 00 81 8d sethi %hi(0x2063400), %o1 <== NOT EXECUTED
2023680: b8 07 bf c4 add %fp, -60, %i4 <== NOT EXECUTED
2023684: 92 12 61 98 or %o1, 0x198, %o1 <== NOT EXECUTED
2023688: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
202368c: 40 00 88 17 call 20456e8 <memcpy> <== NOT EXECUTED
2023690: 94 10 20 3c mov 0x3c, %o2 <== NOT EXECUTED
};
int arg;
int t;
for (arg = 1; arg < argc; arg++)
2023694: 80 a6 20 01 cmp %i0, 1 <== NOT EXECUTED
2023698: 04 80 00 28 ble 2023738 <rtems_shell_debugrfs+0xc0> <== NOT EXECUTED
202369c: 11 00 81 8c sethi %hi(0x2063000), %o0 <== NOT EXECUTED
{
if (argv[arg][0] != '-')
20236a0: fa 06 60 04 ld [ %i1 + 4 ], %i5 <== NOT EXECUTED
20236a4: c2 4f 40 00 ldsb [ %i5 ], %g1 <== NOT EXECUTED
20236a8: 80 a0 60 2d cmp %g1, 0x2d <== NOT EXECUTED
20236ac: 12 80 00 20 bne 202372c <rtems_shell_debugrfs+0xb4> <== NOT EXECUTED
20236b0: 80 a6 20 02 cmp %i0, 2 <== NOT EXECUTED
break;
switch (argv[arg][1])
20236b4: c2 4f 60 01 ldsb [ %i5 + 1 ], %g1 <== NOT EXECUTED
20236b8: 80 a0 60 68 cmp %g1, 0x68 <== NOT EXECUTED
20236bc: 02 80 00 07 be 20236d8 <rtems_shell_debugrfs+0x60> <== NOT EXECUTED
20236c0: 11 00 81 8c sethi %hi(0x2063000), %o0 <== NOT EXECUTED
20236c4: 80 a0 60 6c cmp %g1, 0x6c <== NOT EXECUTED
20236c8: 12 80 00 38 bne 20237a8 <rtems_shell_debugrfs+0x130> <== NOT EXECUTED
20236cc: 90 12 22 70 or %o0, 0x270, %o0 <== NOT EXECUTED
{
case 'h':
rtems_rfs_shell_usage (argv[0]);
return 0;
case 'l':
printf ("%s: commands are:\n", argv[0]);
20236d0: 10 80 00 06 b 20236e8 <rtems_shell_debugrfs+0x70> <== NOT EXECUTED
20236d4: d2 06 40 00 ld [ %i1 ], %o1 <== NOT EXECUTED
break;
switch (argv[arg][1])
{
case 'h':
rtems_rfs_shell_usage (argv[0]);
20236d8: 7f ff ff cf call 2023614 <rtems_rfs_shell_usage> <== NOT EXECUTED
20236dc: d0 06 40 00 ld [ %i1 ], %o0 <== NOT EXECUTED
return 0;
case 'l':
printf ("%s: commands are:\n", argv[0]);
for (t = 0; t < (sizeof (table) / sizeof (const rtems_rfs_shell_cmd)); t++)
printf (" %s\t\t%s\n", table[t].name, table[t].help);
return 0;
20236e0: 81 c7 e0 08 ret <== NOT EXECUTED
20236e4: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED
{
case 'h':
rtems_rfs_shell_usage (argv[0]);
return 0;
case 'l':
printf ("%s: commands are:\n", argv[0]);
20236e8: 11 00 81 8c sethi %hi(0x2063000), %o0 <== NOT EXECUTED
for (t = 0; t < (sizeof (table) / sizeof (const rtems_rfs_shell_cmd)); t++)
printf (" %s\t\t%s\n", table[t].name, table[t].help);
20236ec: 37 00 81 8c sethi %hi(0x2063000), %i3 <== NOT EXECUTED
{
case 'h':
rtems_rfs_shell_usage (argv[0]);
return 0;
case 'l':
printf ("%s: commands are:\n", argv[0]);
20236f0: 90 12 22 48 or %o0, 0x248, %o0 <== NOT EXECUTED
20236f4: 40 00 8c fd call 2046ae8 <printf> <== NOT EXECUTED
20236f8: ba 10 20 00 clr %i5 <== NOT EXECUTED
for (t = 0; t < (sizeof (table) / sizeof (const rtems_rfs_shell_cmd)); t++)
printf (" %s\t\t%s\n", table[t].name, table[t].help);
20236fc: b6 16 e2 60 or %i3, 0x260, %i3 <== NOT EXECUTED
printf (" -h: This help\n");
printf (" -l: The debugger command list.\n");
}
int
rtems_shell_debugrfs (int argc, char *argv[])
2023700: 82 07 00 1d add %i4, %i5, %g1 <== NOT EXECUTED
rtems_rfs_shell_usage (argv[0]);
return 0;
case 'l':
printf ("%s: commands are:\n", argv[0]);
for (t = 0; t < (sizeof (table) / sizeof (const rtems_rfs_shell_cmd)); t++)
printf (" %s\t\t%s\n", table[t].name, table[t].help);
2023704: d2 07 00 1d ld [ %i4 + %i5 ], %o1 <== NOT EXECUTED
2023708: d4 00 60 08 ld [ %g1 + 8 ], %o2 <== NOT EXECUTED
202370c: 40 00 8c f7 call 2046ae8 <printf> <== NOT EXECUTED
2023710: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
2023714: ba 07 60 0c add %i5, 0xc, %i5 <== NOT EXECUTED
case 'h':
rtems_rfs_shell_usage (argv[0]);
return 0;
case 'l':
printf ("%s: commands are:\n", argv[0]);
for (t = 0; t < (sizeof (table) / sizeof (const rtems_rfs_shell_cmd)); t++)
2023718: 80 a7 60 3c cmp %i5, 0x3c <== NOT EXECUTED
202371c: 12 bf ff fa bne 2023704 <rtems_shell_debugrfs+0x8c> <== NOT EXECUTED
2023720: 82 07 00 1d add %i4, %i5, %g1 <== NOT EXECUTED
printf (" %s\t\t%s\n", table[t].name, table[t].help);
return 0;
2023724: 81 c7 e0 08 ret <== NOT EXECUTED
2023728: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED
printf ("error: unknown option: %s\n", argv[arg]);
return 1;
}
}
if ((argc - arg) < 2)
202372c: 32 80 00 06 bne,a 2023744 <rtems_shell_debugrfs+0xcc> <== NOT EXECUTED
2023730: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
printf ("error: you need at least a path and command, try %s -h\n", argv[0]);
2023734: 11 00 81 8c sethi %hi(0x2063000), %o0 <== NOT EXECUTED
2023738: d2 06 40 00 ld [ %i1 ], %o1 <== NOT EXECUTED
202373c: 10 80 00 42 b 2023844 <rtems_shell_debugrfs+0x1cc> <== NOT EXECUTED
2023740: 90 12 22 90 or %o0, 0x290, %o0 <== NOT EXECUTED
rtems_rfs_get_fs (const char* path, rtems_rfs_file_system** fs)
{
struct statvfs sb;
int rc;
rc = statvfs (path, &sb);
2023744: 40 00 17 1b call 20293b0 <statvfs> <== NOT EXECUTED
2023748: 92 07 bf 50 add %fp, -176, %o1 <== NOT EXECUTED
if (rc < 0)
202374c: b8 92 20 00 orcc %o0, 0, %i4 <== NOT EXECUTED
2023750: 16 80 00 0f bge 202378c <rtems_shell_debugrfs+0x114> <== NOT EXECUTED
2023754: c4 07 bf 7c ld [ %fp + -132 ], %g2 <== NOT EXECUTED
{
printf ("error: cannot statvfs path: %s: (%d) %s\n",
path, errno, strerror (errno));
2023758: 40 00 7a a5 call 20421ec <__errno> <== NOT EXECUTED
202375c: b0 10 20 01 mov 1, %i0 <== NOT EXECUTED
2023760: 40 00 7a a3 call 20421ec <__errno> <== NOT EXECUTED
2023764: f8 02 00 00 ld [ %o0 ], %i4 <== NOT EXECUTED
int rc;
rc = statvfs (path, &sb);
if (rc < 0)
{
printf ("error: cannot statvfs path: %s: (%d) %s\n",
2023768: 40 00 96 5f call 20490e4 <strerror> <== NOT EXECUTED
202376c: d0 02 00 00 ld [ %o0 ], %o0 <== NOT EXECUTED
2023770: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
2023774: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
2023778: 94 10 00 1c mov %i4, %o2 <== NOT EXECUTED
202377c: 11 00 81 8c sethi %hi(0x2063000), %o0 <== NOT EXECUTED
2023780: 40 00 8c da call 2046ae8 <printf> <== NOT EXECUTED
2023784: 90 12 22 c8 or %o0, 0x2c8, %o0 ! 20632c8 <rtems_rfs_rtems_eval_config+0x790><== NOT EXECUTED
2023788: 30 80 00 31 b,a 202384c <rtems_shell_debugrfs+0x1d4> <== NOT EXECUTED
path, errno, strerror (errno));
return -1;
}
if (sb.f_fsid != RTEMS_RFS_SB_MAGIC)
202378c: 03 0a 02 48 sethi %hi(0x28092000), %g1 <== NOT EXECUTED
2023790: 82 10 60 01 or %g1, 1, %g1 ! 28092001 <RAM_END+0x25c92001><== NOT EXECUTED
2023794: 80 a0 80 01 cmp %g2, %g1 <== NOT EXECUTED
2023798: 22 80 00 06 be,a 20237b0 <rtems_shell_debugrfs+0x138> <== NOT EXECUTED
202379c: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
{
printf ("error: path '%s' is not on an RFS file system\n", path);
20237a0: 11 00 81 8c sethi %hi(0x2063000), %o0 <== NOT EXECUTED
20237a4: 90 12 22 f8 or %o0, 0x2f8, %o0 ! 20632f8 <rtems_rfs_rtems_eval_config+0x7c0><== NOT EXECUTED
20237a8: 10 80 00 27 b 2023844 <rtems_shell_debugrfs+0x1cc> <== NOT EXECUTED
20237ac: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
* system data.
*/
{
rtems_filesystem_eval_path_context_t ctx;
int eval_flags = RTEMS_FS_FOLLOW_LINK;
const rtems_filesystem_location_info_t *currentloc =
20237b0: 94 10 20 18 mov 0x18, %o2 <== NOT EXECUTED
20237b4: 7f ff 9b 50 call 200a4f4 <rtems_filesystem_eval_path_start><== NOT EXECUTED
20237b8: 90 07 bf 8c add %fp, -116, %o0 <== NOT EXECUTED
rtems_filesystem_eval_path_start (&ctx, path, eval_flags);
*fs = rtems_rfs_rtems_pathloc_dev (currentloc);
20237bc: c2 02 20 14 ld [ %o0 + 0x14 ], %g1 <== NOT EXECUTED
rtems_filesystem_eval_path_cleanup (&ctx);
20237c0: 90 07 bf 8c add %fp, -116, %o0 <== NOT EXECUTED
20237c4: 7f ff 9b 88 call 200a5e4 <rtems_filesystem_eval_path_cleanup><== NOT EXECUTED
20237c8: f4 00 60 08 ld [ %g1 + 8 ], %i2 <== NOT EXECUTED
if ((argc - arg) < 2)
printf ("error: you need at least a path and command, try %s -h\n", argv[0]);
else
{
rtems_rfs_file_system* fs;
if (rtems_rfs_get_fs (argv[arg], &fs) == 0)
20237cc: 80 a7 20 00 cmp %i4, 0 <== NOT EXECUTED
20237d0: 32 80 00 1f bne,a 202384c <rtems_shell_debugrfs+0x1d4> <== NOT EXECUTED
20237d4: b0 10 20 01 mov 1, %i0 <== NOT EXECUTED
20237d8: ba 10 20 00 clr %i5 <== NOT EXECUTED
{
for (t = 0; t < (sizeof (table) / sizeof (const rtems_rfs_shell_cmd)); t++)
if (strcmp (argv[arg + 1], table[t].name) == 0)
20237dc: 82 07 bf c4 add %fp, -60, %g1 <== NOT EXECUTED
20237e0: f6 06 60 08 ld [ %i1 + 8 ], %i3 <== NOT EXECUTED
20237e4: d2 00 40 1c ld [ %g1 + %i4 ], %o1 <== NOT EXECUTED
20237e8: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
20237ec: 40 00 94 59 call 2048950 <strcmp> <== NOT EXECUTED
20237f0: b8 07 20 0c add %i4, 0xc, %i4 <== NOT EXECUTED
20237f4: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
20237f8: 32 80 00 0d bne,a 202382c <rtems_shell_debugrfs+0x1b4> <== NOT EXECUTED
20237fc: ba 07 60 01 inc %i5 <== NOT EXECUTED
return table[t].handler (fs, argc - 2, argv + 2);
2023800: 83 2f 60 02 sll %i5, 2, %g1 <== NOT EXECUTED
2023804: bb 2f 60 04 sll %i5, 4, %i5 <== NOT EXECUTED
2023808: ba 27 40 01 sub %i5, %g1, %i5 <== NOT EXECUTED
202380c: ba 07 80 1d add %fp, %i5, %i5 <== NOT EXECUTED
2023810: c2 07 7f c8 ld [ %i5 + -56 ], %g1 <== NOT EXECUTED
2023814: 92 06 3f fe add %i0, -2, %o1 <== NOT EXECUTED
2023818: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
202381c: 9f c0 40 00 call %g1 <== NOT EXECUTED
2023820: 94 06 60 08 add %i1, 8, %o2 <== NOT EXECUTED
2023824: 81 c7 e0 08 ret <== NOT EXECUTED
2023828: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED
else
{
rtems_rfs_file_system* fs;
if (rtems_rfs_get_fs (argv[arg], &fs) == 0)
{
for (t = 0; t < (sizeof (table) / sizeof (const rtems_rfs_shell_cmd)); t++)
202382c: 80 a7 60 05 cmp %i5, 5 <== NOT EXECUTED
2023830: 12 bf ff ec bne 20237e0 <rtems_shell_debugrfs+0x168> <== NOT EXECUTED
2023834: 82 07 bf c4 add %fp, -60, %g1 <== NOT EXECUTED
if (strcmp (argv[arg + 1], table[t].name) == 0)
return table[t].handler (fs, argc - 2, argv + 2);
printf ("error: command not found: %s\n", argv[arg + 1]);
2023838: 11 00 81 8c sethi %hi(0x2063000), %o0 <== NOT EXECUTED
202383c: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
2023840: 90 12 23 28 or %o0, 0x328, %o0 <== NOT EXECUTED
2023844: 40 00 8c a9 call 2046ae8 <printf> <== NOT EXECUTED
2023848: b0 10 20 01 mov 1, %i0 <== NOT EXECUTED
}
}
return 1;
}
202384c: 81 c7 e0 08 ret <== NOT EXECUTED
2023850: 81 e8 00 00 restore <== NOT EXECUTED
02023854 <rtems_shell_rfs_format>:
int
rtems_shell_rfs_format (int argc, char* argv[])
{
2023854: 9d e3 bf 88 save %sp, -120, %sp <== NOT EXECUTED
rtems_rfs_format_config config;
const char* driver = NULL;
int arg;
memset (&config, 0, sizeof (rtems_rfs_format_config));
2023858: 92 10 20 00 clr %o1 <== NOT EXECUTED
202385c: 90 07 bf e8 add %fp, -24, %o0 <== NOT EXECUTED
2023860: 94 10 20 18 mov 0x18, %o2 <== NOT EXECUTED
2023864: 40 00 88 30 call 2045924 <memset> <== NOT EXECUTED
2023868: ba 10 20 01 mov 1, %i5 <== NOT EXECUTED
int
rtems_shell_rfs_format (int argc, char* argv[])
{
rtems_rfs_format_config config;
const char* driver = NULL;
202386c: b8 10 20 00 clr %i4 <== NOT EXECUTED
int arg;
memset (&config, 0, sizeof (rtems_rfs_format_config));
for (arg = 1; arg < argc; arg++)
2023870: 10 80 00 5b b 20239dc <rtems_shell_rfs_format+0x188> <== NOT EXECUTED
2023874: b6 10 20 01 mov 1, %i3 <== NOT EXECUTED
{
if (argv[arg][0] == '-')
2023878: d2 06 40 01 ld [ %i1 + %g1 ], %o1 <== NOT EXECUTED
202387c: c2 4a 40 00 ldsb [ %o1 ], %g1 <== NOT EXECUTED
2023880: 80 a0 60 2d cmp %g1, 0x2d <== NOT EXECUTED
2023884: 12 80 00 4e bne 20239bc <rtems_shell_rfs_format+0x168> <== NOT EXECUTED
2023888: 80 a7 20 00 cmp %i4, 0 <== NOT EXECUTED
{
switch (argv[arg][1])
202388c: c2 4a 60 01 ldsb [ %o1 + 1 ], %g1 <== NOT EXECUTED
2023890: 80 a0 60 69 cmp %g1, 0x69 <== NOT EXECUTED
2023894: 22 80 00 2e be,a 202394c <rtems_shell_rfs_format+0xf8> <== NOT EXECUTED
2023898: ba 07 60 01 inc %i5 <== NOT EXECUTED
202389c: 14 80 00 09 bg 20238c0 <rtems_shell_rfs_format+0x6c> <== NOT EXECUTED
20238a0: 80 a0 60 73 cmp %g1, 0x73 <== NOT EXECUTED
20238a4: 80 a0 60 49 cmp %g1, 0x49 <== NOT EXECUTED
20238a8: 02 80 00 35 be 202397c <rtems_shell_rfs_format+0x128> <== NOT EXECUTED
20238ac: 80 a0 60 62 cmp %g1, 0x62 <== NOT EXECUTED
20238b0: 12 80 00 41 bne 20239b4 <rtems_shell_rfs_format+0x160> <== NOT EXECUTED
20238b4: 11 00 81 77 sethi %hi(0x205dc00), %o0 <== NOT EXECUTED
}
config.block_size = strtoul (argv[arg], 0, 0);
break;
case 'b':
arg++;
20238b8: 10 80 00 19 b 202391c <rtems_shell_rfs_format+0xc8> <== NOT EXECUTED
20238bc: ba 07 60 01 inc %i5 <== NOT EXECUTED
for (arg = 1; arg < argc; arg++)
{
if (argv[arg][0] == '-')
{
switch (argv[arg][1])
20238c0: 02 80 00 0a be 20238e8 <rtems_shell_rfs_format+0x94> <== NOT EXECUTED
20238c4: 80 a0 60 76 cmp %g1, 0x76 <== NOT EXECUTED
20238c8: 02 80 00 06 be 20238e0 <rtems_shell_rfs_format+0x8c> <== NOT EXECUTED
20238cc: 80 a0 60 6f cmp %g1, 0x6f <== NOT EXECUTED
20238d0: 12 80 00 39 bne 20239b4 <rtems_shell_rfs_format+0x160> <== NOT EXECUTED
20238d4: 11 00 81 77 sethi %hi(0x205dc00), %o0 <== NOT EXECUTED
case 'I':
config.initialise_inodes = true;
break;
case 'o':
arg++;
20238d8: 10 80 00 2b b 2023984 <rtems_shell_rfs_format+0x130> <== NOT EXECUTED
20238dc: ba 07 60 01 inc %i5 <== NOT EXECUTED
{
switch (argv[arg][1])
{
case 'v':
config.verbose = true;
break;
20238e0: 10 80 00 3e b 20239d8 <rtems_shell_rfs_format+0x184> <== NOT EXECUTED
20238e4: f6 2f bf fd stb %i3, [ %fp + -3 ] <== NOT EXECUTED
case 's':
arg++;
20238e8: ba 07 60 01 inc %i5 <== NOT EXECUTED
if (arg >= argc)
20238ec: 80 a7 40 18 cmp %i5, %i0 <== NOT EXECUTED
20238f0: 06 80 00 05 bl 2023904 <rtems_shell_rfs_format+0xb0> <== NOT EXECUTED
20238f4: 83 2f 60 02 sll %i5, 2, %g1 <== NOT EXECUTED
{
printf ("error: block size needs an argument\n");
20238f8: 11 00 81 8d sethi %hi(0x2063400), %o0 <== NOT EXECUTED
20238fc: 10 80 00 40 b 20239fc <rtems_shell_rfs_format+0x1a8> <== NOT EXECUTED
2023900: 90 12 20 98 or %o0, 0x98, %o0 ! 2063498 <rtems_rfs_rtems_eval_config+0x960><== NOT EXECUTED
return 1;
}
config.block_size = strtoul (argv[arg], 0, 0);
2023904: d0 06 40 01 ld [ %i1 + %g1 ], %o0 <== NOT EXECUTED
2023908: 92 10 20 00 clr %o1 <== NOT EXECUTED
202390c: 40 00 9c 72 call 204aad4 <strtoul> <== NOT EXECUTED
2023910: 94 10 20 00 clr %o2 <== NOT EXECUTED
break;
2023914: 10 80 00 31 b 20239d8 <rtems_shell_rfs_format+0x184> <== NOT EXECUTED
2023918: d0 27 bf e8 st %o0, [ %fp + -24 ] <== NOT EXECUTED
case 'b':
arg++;
if (arg >= argc)
202391c: 80 a7 40 18 cmp %i5, %i0 <== NOT EXECUTED
2023920: 06 80 00 05 bl 2023934 <rtems_shell_rfs_format+0xe0> <== NOT EXECUTED
2023924: 83 2f 60 02 sll %i5, 2, %g1 <== NOT EXECUTED
{
printf ("error: group block count needs an argument\n");
2023928: 11 00 81 8d sethi %hi(0x2063400), %o0 <== NOT EXECUTED
202392c: 10 80 00 34 b 20239fc <rtems_shell_rfs_format+0x1a8> <== NOT EXECUTED
2023930: 90 12 20 c0 or %o0, 0xc0, %o0 ! 20634c0 <rtems_rfs_rtems_eval_config+0x988><== NOT EXECUTED
return 1;
}
config.group_blocks = strtoul (argv[arg], 0, 0);
2023934: d0 06 40 01 ld [ %i1 + %g1 ], %o0 <== NOT EXECUTED
2023938: 92 10 20 00 clr %o1 <== NOT EXECUTED
202393c: 40 00 9c 66 call 204aad4 <strtoul> <== NOT EXECUTED
2023940: 94 10 20 00 clr %o2 <== NOT EXECUTED
break;
2023944: 10 80 00 25 b 20239d8 <rtems_shell_rfs_format+0x184> <== NOT EXECUTED
2023948: d0 27 bf ec st %o0, [ %fp + -20 ] <== NOT EXECUTED
case 'i':
arg++;
if (arg >= argc)
202394c: 80 a7 40 18 cmp %i5, %i0 <== NOT EXECUTED
2023950: 06 80 00 05 bl 2023964 <rtems_shell_rfs_format+0x110> <== NOT EXECUTED
2023954: 83 2f 60 02 sll %i5, 2, %g1 <== NOT EXECUTED
{
printf ("error: group inode count needs an argument\n");
2023958: 11 00 81 8d sethi %hi(0x2063400), %o0 <== NOT EXECUTED
202395c: 10 80 00 28 b 20239fc <rtems_shell_rfs_format+0x1a8> <== NOT EXECUTED
2023960: 90 12 20 f0 or %o0, 0xf0, %o0 ! 20634f0 <rtems_rfs_rtems_eval_config+0x9b8><== NOT EXECUTED
return 1;
}
config.group_inodes = strtoul (argv[arg], 0, 0);
2023964: d0 06 40 01 ld [ %i1 + %g1 ], %o0 <== NOT EXECUTED
2023968: 92 10 20 00 clr %o1 <== NOT EXECUTED
202396c: 40 00 9c 5a call 204aad4 <strtoul> <== NOT EXECUTED
2023970: 94 10 20 00 clr %o2 <== NOT EXECUTED
break;
2023974: 10 80 00 19 b 20239d8 <rtems_shell_rfs_format+0x184> <== NOT EXECUTED
2023978: d0 27 bf f0 st %o0, [ %fp + -16 ] <== NOT EXECUTED
case 'I':
config.initialise_inodes = true;
break;
202397c: 10 80 00 17 b 20239d8 <rtems_shell_rfs_format+0x184> <== NOT EXECUTED
2023980: f6 2f bf fc stb %i3, [ %fp + -4 ] <== NOT EXECUTED
case 'o':
arg++;
if (arg >= argc)
2023984: 80 a7 40 18 cmp %i5, %i0 <== NOT EXECUTED
2023988: 06 80 00 05 bl 202399c <rtems_shell_rfs_format+0x148> <== NOT EXECUTED
202398c: 83 2f 60 02 sll %i5, 2, %g1 <== NOT EXECUTED
{
printf ("error: inode percentage overhead needs an argument\n");
2023990: 11 00 81 8d sethi %hi(0x2063400), %o0 <== NOT EXECUTED
2023994: 10 80 00 1a b 20239fc <rtems_shell_rfs_format+0x1a8> <== NOT EXECUTED
2023998: 90 12 21 20 or %o0, 0x120, %o0 ! 2063520 <rtems_rfs_rtems_eval_config+0x9e8><== NOT EXECUTED
return 1;
}
config.inode_overhead = strtoul (argv[arg], 0, 0);
202399c: d0 06 40 01 ld [ %i1 + %g1 ], %o0 <== NOT EXECUTED
20239a0: 92 10 20 00 clr %o1 <== NOT EXECUTED
20239a4: 40 00 9c 4c call 204aad4 <strtoul> <== NOT EXECUTED
20239a8: 94 10 20 00 clr %o2 <== NOT EXECUTED
break;
20239ac: 10 80 00 0b b 20239d8 <rtems_shell_rfs_format+0x184> <== NOT EXECUTED
20239b0: d0 27 bf f4 st %o0, [ %fp + -12 ] <== NOT EXECUTED
default:
printf ("error: invalid option: %s\n", argv[arg]);
20239b4: 10 80 00 06 b 20239cc <rtems_shell_rfs_format+0x178> <== NOT EXECUTED
20239b8: 90 12 22 08 or %o0, 0x208, %o0 <== NOT EXECUTED
return 1;
}
}
else
{
if (!driver)
20239bc: 22 80 00 07 be,a 20239d8 <rtems_shell_rfs_format+0x184> <== NOT EXECUTED
20239c0: b8 10 00 09 mov %o1, %i4 <== NOT EXECUTED
driver = argv[arg];
else
{
printf ("error: only one driver name allowed: %s\n", argv[arg]);
20239c4: 11 00 81 77 sethi %hi(0x205dc00), %o0 <== NOT EXECUTED
20239c8: 90 12 22 28 or %o0, 0x228, %o0 ! 205de28 <_rodata_start+0x7b8><== NOT EXECUTED
20239cc: 40 00 8c 47 call 2046ae8 <printf> <== NOT EXECUTED
20239d0: b0 10 20 01 mov 1, %i0 <== NOT EXECUTED
20239d4: 30 80 00 1c b,a 2023a44 <rtems_shell_rfs_format+0x1f0> <== NOT EXECUTED
const char* driver = NULL;
int arg;
memset (&config, 0, sizeof (rtems_rfs_format_config));
for (arg = 1; arg < argc; arg++)
20239d8: ba 07 60 01 inc %i5 <== NOT EXECUTED
20239dc: 80 a7 40 18 cmp %i5, %i0 <== NOT EXECUTED
20239e0: 06 bf ff a6 bl 2023878 <rtems_shell_rfs_format+0x24> <== NOT EXECUTED
20239e4: 83 2f 60 02 sll %i5, 2, %g1 <== NOT EXECUTED
return 1;
}
}
}
if (!driver) {
20239e8: 80 a7 20 00 cmp %i4, 0 <== NOT EXECUTED
20239ec: 12 80 00 07 bne 2023a08 <rtems_shell_rfs_format+0x1b4> <== NOT EXECUTED
20239f0: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
printf ("error: no driver name provided\n");
20239f4: 11 00 81 8d sethi %hi(0x2063400), %o0 <== NOT EXECUTED
20239f8: 90 12 21 58 or %o0, 0x158, %o0 ! 2063558 <rtems_rfs_rtems_eval_config+0xa20><== NOT EXECUTED
20239fc: 40 00 8c d3 call 2046d48 <puts> <== NOT EXECUTED
2023a00: b0 10 20 01 mov 1, %i0 <== NOT EXECUTED
2023a04: 30 80 00 10 b,a 2023a44 <rtems_shell_rfs_format+0x1f0> <== NOT EXECUTED
return 1;
}
if (rtems_rfs_format (driver, &config) < 0)
2023a08: 92 07 bf e8 add %fp, -24, %o1 <== NOT EXECUTED
2023a0c: 40 00 5b 28 call 203a6ac <rtems_rfs_format> <== NOT EXECUTED
2023a10: b0 10 20 00 clr %i0 <== NOT EXECUTED
2023a14: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2023a18: 16 80 00 0b bge 2023a44 <rtems_shell_rfs_format+0x1f0> <== NOT EXECUTED
2023a1c: 01 00 00 00 nop <== NOT EXECUTED
{
printf ("error: format of %s failed: %s\n",
driver, strerror (errno));
2023a20: 40 00 79 f3 call 20421ec <__errno> <== NOT EXECUTED
2023a24: b0 10 20 01 mov 1, %i0 ! 1 <PROM_START+0x1> <== NOT EXECUTED
return 1;
}
if (rtems_rfs_format (driver, &config) < 0)
{
printf ("error: format of %s failed: %s\n",
2023a28: 40 00 95 af call 20490e4 <strerror> <== NOT EXECUTED
2023a2c: d0 02 00 00 ld [ %o0 ], %o0 <== NOT EXECUTED
2023a30: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
2023a34: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
2023a38: 11 00 81 8d sethi %hi(0x2063400), %o0 <== NOT EXECUTED
2023a3c: 40 00 8c 2b call 2046ae8 <printf> <== NOT EXECUTED
2023a40: 90 12 21 78 or %o0, 0x178, %o0 ! 2063578 <rtems_rfs_rtems_eval_config+0xa40><== NOT EXECUTED
driver, strerror (errno));
return 1;
}
return 0;
}
2023a44: 81 c7 e0 08 ret <== NOT EXECUTED
2023a48: 81 e8 00 00 restore <== NOT EXECUTED
02017a10 <rtems_signal_send>:
rtems_status_code rtems_signal_send(
rtems_id id,
rtems_signal_set signal_set
)
{
2017a10: 9d e3 bf 98 save %sp, -104, %sp
register Thread_Control *the_thread;
Objects_Locations location;
RTEMS_API_Control *api;
ASR_Information *asr;
if ( !signal_set )
2017a14: 80 a6 60 00 cmp %i1, 0
2017a18: 02 80 00 35 be 2017aec <rtems_signal_send+0xdc>
2017a1c: 82 10 20 0a mov 0xa, %g1
return RTEMS_INVALID_NUMBER;
the_thread = _Thread_Get( id, &location );
2017a20: 90 10 00 18 mov %i0, %o0
2017a24: 40 00 12 a7 call 201c4c0 <_Thread_Get>
2017a28: 92 07 bf fc add %fp, -4, %o1
switch ( location ) {
2017a2c: c2 07 bf fc ld [ %fp + -4 ], %g1
2017a30: 80 a0 60 00 cmp %g1, 0
2017a34: 12 80 00 2d bne 2017ae8 <rtems_signal_send+0xd8>
2017a38: b8 10 00 08 mov %o0, %i4
case OBJECTS_LOCAL:
api = the_thread->API_Extensions[ THREAD_API_RTEMS ];
2017a3c: fa 02 21 58 ld [ %o0 + 0x158 ], %i5
asr = &api->Signal;
if ( ! _ASR_Is_null_handler( asr->handler ) ) {
2017a40: c2 07 60 0c ld [ %i5 + 0xc ], %g1
2017a44: 80 a0 60 00 cmp %g1, 0
2017a48: 02 80 00 24 be 2017ad8 <rtems_signal_send+0xc8>
2017a4c: 01 00 00 00 nop
if ( asr->is_enabled ) {
2017a50: c2 0f 60 08 ldub [ %i5 + 8 ], %g1
2017a54: 80 a0 60 00 cmp %g1, 0
2017a58: 02 80 00 15 be 2017aac <rtems_signal_send+0x9c>
2017a5c: 01 00 00 00 nop
rtems_signal_set *signal_set
)
{
ISR_Level _level;
_ISR_Disable( _level );
2017a60: 7f ff e3 64 call 20107f0 <sparc_disable_interrupts>
2017a64: 01 00 00 00 nop
*signal_set |= signals;
2017a68: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
2017a6c: b2 10 40 19 or %g1, %i1, %i1
2017a70: f2 27 60 14 st %i1, [ %i5 + 0x14 ]
_ISR_Enable( _level );
2017a74: 7f ff e3 63 call 2010800 <sparc_enable_interrupts>
2017a78: 01 00 00 00 nop
_ASR_Post_signals( signal_set, &asr->signals_posted );
if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
2017a7c: 03 00 80 f4 sethi %hi(0x203d000), %g1
2017a80: 82 10 62 a0 or %g1, 0x2a0, %g1 ! 203d2a0 <_Per_CPU_Information>
2017a84: c4 00 60 08 ld [ %g1 + 8 ], %g2
2017a88: 80 a0 a0 00 cmp %g2, 0
2017a8c: 02 80 00 0f be 2017ac8 <rtems_signal_send+0xb8>
2017a90: 01 00 00 00 nop
2017a94: c4 00 60 0c ld [ %g1 + 0xc ], %g2
2017a98: 80 a7 00 02 cmp %i4, %g2
2017a9c: 12 80 00 0b bne 2017ac8 <rtems_signal_send+0xb8> <== NEVER TAKEN
2017aa0: 84 10 20 01 mov 1, %g2
_Thread_Dispatch_necessary = true;
2017aa4: c4 28 60 18 stb %g2, [ %g1 + 0x18 ]
2017aa8: 30 80 00 08 b,a 2017ac8 <rtems_signal_send+0xb8>
rtems_signal_set *signal_set
)
{
ISR_Level _level;
_ISR_Disable( _level );
2017aac: 7f ff e3 51 call 20107f0 <sparc_disable_interrupts>
2017ab0: 01 00 00 00 nop
*signal_set |= signals;
2017ab4: c2 07 60 18 ld [ %i5 + 0x18 ], %g1
2017ab8: b2 10 40 19 or %g1, %i1, %i1
2017abc: f2 27 60 18 st %i1, [ %i5 + 0x18 ]
_ISR_Enable( _level );
2017ac0: 7f ff e3 50 call 2010800 <sparc_enable_interrupts>
2017ac4: 01 00 00 00 nop
} else {
_ASR_Post_signals( signal_set, &asr->signals_pending );
}
_Thread_Enable_dispatch();
2017ac8: 40 00 12 71 call 201c48c <_Thread_Enable_dispatch>
2017acc: 01 00 00 00 nop
return RTEMS_SUCCESSFUL;
2017ad0: 10 80 00 07 b 2017aec <rtems_signal_send+0xdc>
2017ad4: 82 10 20 00 clr %g1 ! 0 <PROM_START>
}
_Thread_Enable_dispatch();
2017ad8: 40 00 12 6d call 201c48c <_Thread_Enable_dispatch>
2017adc: 01 00 00 00 nop
return RTEMS_NOT_DEFINED;
2017ae0: 10 80 00 03 b 2017aec <rtems_signal_send+0xdc>
2017ae4: 82 10 20 0b mov 0xb, %g1 ! b <PROM_START+0xb>
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
2017ae8: 82 10 20 04 mov 4, %g1
}
2017aec: 81 c7 e0 08 ret
2017af0: 91 e8 00 01 restore %g0, %g1, %o0
02007488 <rtems_stack_checker_begin_extension>:
* rtems_stack_checker_Begin_extension
*/
void rtems_stack_checker_begin_extension(
Thread_Control *the_thread
)
{
2007488: 9d e3 bf a0 save %sp, -96, %sp
Stack_check_Control *the_pattern;
if ( the_thread->Object.id == 0 ) /* skip system tasks */
200748c: c2 06 20 08 ld [ %i0 + 8 ], %g1
2007490: 80 a0 60 00 cmp %g1, 0
2007494: 02 80 00 07 be 20074b0 <rtems_stack_checker_begin_extension+0x28><== NEVER TAKEN
2007498: 13 00 81 bd sethi %hi(0x206f400), %o1
return;
the_pattern = Stack_check_Get_pattern_area(&the_thread->Start.Initial_stack);
*the_pattern = Stack_check_Pattern;
200749c: d0 06 20 b8 ld [ %i0 + 0xb8 ], %o0
20074a0: 90 02 20 08 add %o0, 8, %o0
20074a4: 92 12 61 c4 or %o1, 0x1c4, %o1
20074a8: 40 00 f8 90 call 20456e8 <memcpy>
20074ac: 94 10 20 10 mov 0x10, %o2
20074b0: 81 c7 e0 08 ret
20074b4: 81 e8 00 00 restore
020073d0 <rtems_stack_checker_create_extension>:
*/
bool rtems_stack_checker_create_extension(
Thread_Control *running __attribute__((unused)),
Thread_Control *the_thread
)
{
20073d0: 9d e3 bf a0 save %sp, -96, %sp
static uint32_t pattern[ 4 ] = {
0xFEEDF00D, 0x0BAD0D06, /* FEED FOOD to BAD DOG */
0xDEADF00D, 0x600D0D06 /* DEAD FOOD but GOOD DOG */
};
if ( Stack_check_Initialized )
20073d4: 03 00 81 b2 sethi %hi(0x206c800), %g1
20073d8: c2 00 60 68 ld [ %g1 + 0x68 ], %g1 ! 206c868 <Stack_check_Initialized>
20073dc: 80 a0 60 00 cmp %g1, 0
20073e0: 12 80 00 21 bne 2007464 <rtems_stack_checker_create_extension+0x94>
20073e4: 05 00 81 bd sethi %hi(0x206f400), %g2
/*
* Dope the pattern and fill areas
*/
p = Stack_check_Pattern.pattern;
for ( i = 0; i < PATTERN_SIZE_WORDS; i++ ) {
p[i] = pattern[ i%4 ];
20073e8: 07 3f bb 7c sethi %hi(0xfeedf000), %g3
20073ec: 82 10 a1 c4 or %g2, 0x1c4, %g1
20073f0: 86 10 e0 0d or %g3, 0xd, %g3
20073f4: c6 20 a1 c4 st %g3, [ %g2 + 0x1c4 ]
20073f8: 05 02 eb 43 sethi %hi(0xbad0c00), %g2
20073fc: 84 10 a1 06 or %g2, 0x106, %g2 ! bad0d06 <RAM_END+0x96d0d06>
2007400: c4 20 60 04 st %g2, [ %g1 + 4 ]
2007404: 05 37 ab 7c sethi %hi(0xdeadf000), %g2
2007408: 84 10 a0 0d or %g2, 0xd, %g2 ! deadf00d <RAM_END+0xdc6df00d>
200740c: c4 20 60 08 st %g2, [ %g1 + 8 ]
2007410: 05 18 03 43 sethi %hi(0x600d0c00), %g2
2007414: 84 10 a1 06 or %g2, 0x106, %g2 ! 600d0d06 <RAM_END+0x5dcd0d06>
2007418: c4 20 60 0c st %g2, [ %g1 + 0xc ]
/*
* If appropriate, setup the interrupt stack for high water testing
* also.
*/
#if (CPU_ALLOCATE_INTERRUPT_STACK == TRUE)
if (_CPU_Interrupt_stack_low && _CPU_Interrupt_stack_high) {
200741c: 03 00 81 bf sethi %hi(0x206fc00), %g1
2007420: d0 00 60 b0 ld [ %g1 + 0xb0 ], %o0 ! 206fcb0 <_Per_CPU_Information>
2007424: 80 a2 20 00 cmp %o0, 0
2007428: 02 80 00 0c be 2007458 <rtems_stack_checker_create_extension+0x88><== NEVER TAKEN
200742c: 84 10 60 b0 or %g1, 0xb0, %g2
2007430: d4 00 a0 04 ld [ %g2 + 4 ], %o2
2007434: 80 a2 a0 00 cmp %o2, 0
2007438: 02 80 00 08 be 2007458 <rtems_stack_checker_create_extension+0x88><== NEVER TAKEN
200743c: 03 00 81 bd sethi %hi(0x206f400), %g1
Stack_check_Interrupt_stack.area = _CPU_Interrupt_stack_low;
2007440: 84 10 61 d4 or %g1, 0x1d4, %g2 ! 206f5d4 <Stack_check_Interrupt_stack>
Stack_check_Interrupt_stack.size = (char *) _CPU_Interrupt_stack_high -
2007444: 94 22 80 08 sub %o2, %o0, %o2
* If appropriate, setup the interrupt stack for high water testing
* also.
*/
#if (CPU_ALLOCATE_INTERRUPT_STACK == TRUE)
if (_CPU_Interrupt_stack_low && _CPU_Interrupt_stack_high) {
Stack_check_Interrupt_stack.area = _CPU_Interrupt_stack_low;
2007448: d0 20 a0 04 st %o0, [ %g2 + 4 ]
Stack_check_Interrupt_stack.size = (char *) _CPU_Interrupt_stack_high -
200744c: d4 20 61 d4 st %o2, [ %g1 + 0x1d4 ]
(char *) _CPU_Interrupt_stack_low;
Stack_check_Dope_stack(&Stack_check_Interrupt_stack);
2007450: 40 00 f9 35 call 2045924 <memset>
2007454: 92 10 20 a5 mov 0xa5, %o1
}
#endif
Stack_check_Initialized = 1;
2007458: 84 10 20 01 mov 1, %g2
200745c: 03 00 81 b2 sethi %hi(0x206c800), %g1
2007460: c4 20 60 68 st %g2, [ %g1 + 0x68 ] ! 206c868 <Stack_check_Initialized>
Thread_Control *the_thread
)
{
Stack_check_Initialize();
if (the_thread)
2007464: 80 a6 60 00 cmp %i1, 0
2007468: 02 80 00 06 be 2007480 <rtems_stack_checker_create_extension+0xb0><== NEVER TAKEN
200746c: 01 00 00 00 nop
Stack_check_Dope_stack(&the_thread->Start.Initial_stack);
2007470: d0 06 60 b8 ld [ %i1 + 0xb8 ], %o0
2007474: d4 06 60 b4 ld [ %i1 + 0xb4 ], %o2
2007478: 40 00 f9 2b call 2045924 <memset>
200747c: 92 10 20 a5 mov 0xa5, %o1
return true;
}
2007480: 81 c7 e0 08 ret
2007484: 91 e8 20 01 restore %g0, 1, %o0
020075d0 <rtems_stack_checker_is_blown>:
/*
* Check if blown
*/
bool rtems_stack_checker_is_blown( void )
{
20075d0: 9d e3 bf a0 save %sp, -96, %sp
Stack_Control *the_stack = &_Thread_Executing->Start.Initial_stack;
20075d4: 03 00 81 bf sethi %hi(0x206fc00), %g1
20075d8: fa 00 60 bc ld [ %g1 + 0xbc ], %i5 ! 206fcbc <_Per_CPU_Information+0xc>
)
{
#if defined(__GNUC__)
void *sp = __builtin_frame_address(0);
if ( sp < the_stack->area ) {
20075dc: d0 07 60 b8 ld [ %i5 + 0xb8 ], %o0
20075e0: 80 a7 80 08 cmp %fp, %o0
20075e4: 0a 80 00 06 bcs 20075fc <rtems_stack_checker_is_blown+0x2c><== NEVER TAKEN
20075e8: b8 10 20 00 clr %i4
return false;
}
if ( sp > (the_stack->area + the_stack->size) ) {
20075ec: c2 07 60 b4 ld [ %i5 + 0xb4 ], %g1
20075f0: 82 02 00 01 add %o0, %g1, %g1
20075f4: 80 a0 40 1e cmp %g1, %fp
20075f8: b8 60 3f ff subx %g0, -1, %i4
/*
* The stack checker must be initialized before the pattern is there
* to check.
*/
if ( Stack_check_Initialized ) {
20075fc: 03 00 81 b2 sethi %hi(0x206c800), %g1
2007600: c2 00 60 68 ld [ %g1 + 0x68 ], %g1 ! 206c868 <Stack_check_Initialized>
2007604: 80 a0 60 00 cmp %g1, 0
2007608: 02 80 00 09 be 200762c <rtems_stack_checker_is_blown+0x5c><== NEVER TAKEN
200760c: 92 10 20 01 mov 1, %o1
pattern_ok = (!memcmp(
2007610: 90 02 20 08 add %o0, 8, %o0
2007614: 13 00 81 bd sethi %hi(0x206f400), %o1
2007618: 94 10 20 10 mov 0x10, %o2
200761c: 40 00 f8 09 call 2045640 <memcmp>
2007620: 92 12 61 c4 or %o1, 0x1c4, %o1
2007624: 80 a0 00 08 cmp %g0, %o0
2007628: 92 60 3f ff subx %g0, -1, %o1
/*
* Let's report as much as we can.
*/
if ( !sp_ok || !pattern_ok ) {
200762c: 82 1a 60 01 xor %o1, 1, %g1
2007630: 80 88 60 ff btst 0xff, %g1
2007634: 12 80 00 05 bne 2007648 <rtems_stack_checker_is_blown+0x78><== NEVER TAKEN
2007638: b8 1f 20 01 xor %i4, 1, %i4
200763c: 80 8f 20 ff btst 0xff, %i4
2007640: 02 80 00 05 be 2007654 <rtems_stack_checker_is_blown+0x84><== ALWAYS TAKEN
2007644: 01 00 00 00 nop
Stack_check_report_blown_task( _Thread_Executing, pattern_ok );
2007648: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
200764c: 7f ff ff 9b call 20074b8 <Stack_check_report_blown_task> <== NOT EXECUTED
2007650: 92 0a 60 01 and %o1, 1, %o1 <== NOT EXECUTED
/*
* The Stack Pointer and the Pattern Area are OK so return false.
*/
return false;
}
2007654: 81 c7 e0 08 ret
2007658: 91 e8 20 00 restore %g0, 0, %o0
0200765c <rtems_stack_checker_report_usage_with_plugin>:
void rtems_stack_checker_report_usage_with_plugin(
void *context,
rtems_printk_plugin_t print
)
{
200765c: 9d e3 bf a0 save %sp, -96, %sp
if ( !print )
2007660: 80 a6 60 00 cmp %i1, 0
2007664: 02 80 00 14 be 20076b4 <rtems_stack_checker_report_usage_with_plugin+0x58><== NEVER TAKEN
2007668: 39 00 81 b2 sethi %hi(0x206c800), %i4
return;
print_context = context;
print_handler = print;
200766c: 3b 00 81 b2 sethi %hi(0x206c800), %i5
)
{
if ( !print )
return;
print_context = context;
2007670: f0 27 20 6c st %i0, [ %i4 + 0x6c ]
print_handler = print;
2007674: f2 27 60 70 st %i1, [ %i5 + 0x70 ]
(*print)( context, "Stack usage by thread\n");
2007678: 90 10 00 18 mov %i0, %o0
200767c: 13 00 81 7b sethi %hi(0x205ec00), %o1
2007680: 9f c6 40 00 call %i1
2007684: 92 12 63 80 or %o1, 0x380, %o1 ! 205ef80 <write_block_string.9494+0x6b0>
(*print)( context,
2007688: 90 10 00 18 mov %i0, %o0
200768c: 13 00 81 7b sethi %hi(0x205ec00), %o1
2007690: 9f c6 40 00 call %i1
2007694: 92 12 63 98 or %o1, 0x398, %o1 ! 205ef98 <write_block_string.9494+0x6c8>
" 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 );
2007698: 11 00 80 1c sethi %hi(0x2007000), %o0
200769c: 40 00 1d 4d call 200ebd0 <rtems_iterate_over_all_threads>
20076a0: 90 12 22 60 or %o0, 0x260, %o0 ! 2007260 <Stack_check_Dump_threads_usage>
#if (CPU_ALLOCATE_INTERRUPT_STACK == TRUE)
/* dump interrupt stack info if any */
Stack_check_Dump_threads_usage((Thread_Control *) -1);
20076a4: 7f ff fe ef call 2007260 <Stack_check_Dump_threads_usage>
20076a8: 90 10 3f ff mov -1, %o0
#endif
print_context = NULL;
20076ac: c0 27 20 6c clr [ %i4 + 0x6c ]
print_handler = NULL;
20076b0: c0 27 60 70 clr [ %i5 + 0x70 ]
20076b4: 81 c7 e0 08 ret
20076b8: 81 e8 00 00 restore
02007560 <rtems_stack_checker_switch_extension>:
*/
void rtems_stack_checker_switch_extension(
Thread_Control *running __attribute__((unused)),
Thread_Control *heir __attribute__((unused))
)
{
2007560: 9d e3 bf a0 save %sp, -96, %sp
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);
2007564: c2 06 20 b8 ld [ %i0 + 0xb8 ], %g1
{
#if defined(__GNUC__)
void *sp = __builtin_frame_address(0);
if ( sp < the_stack->area ) {
return false;
2007568: ba 10 20 00 clr %i5
)
{
#if defined(__GNUC__)
void *sp = __builtin_frame_address(0);
if ( sp < the_stack->area ) {
200756c: 80 a7 80 01 cmp %fp, %g1
2007570: 0a 80 00 06 bcs 2007588 <rtems_stack_checker_switch_extension+0x28><== NEVER TAKEN
2007574: 90 00 60 08 add %g1, 8, %o0
return false;
}
if ( sp > (the_stack->area + the_stack->size) ) {
2007578: c4 06 20 b4 ld [ %i0 + 0xb4 ], %g2
200757c: 82 00 40 02 add %g1, %g2, %g1
2007580: 80 a0 40 1e cmp %g1, %fp
2007584: ba 60 3f ff subx %g0, -1, %i5
/*
* 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,
2007588: 13 00 81 bd sethi %hi(0x206f400), %o1
200758c: 94 10 20 10 mov 0x10, %o2
2007590: 40 00 f8 2c call 2045640 <memcmp>
2007594: 92 12 61 c4 or %o1, 0x1c4, %o1
2007598: 80 a0 00 08 cmp %g0, %o0
200759c: 82 60 3f ff subx %g0, -1, %g1
(void *) Stack_check_Pattern.pattern, PATTERN_SIZE_BYTES));
if ( !sp_ok || !pattern_ok ) {
20075a0: 80 a0 60 00 cmp %g1, 0
20075a4: 02 80 00 06 be 20075bc <rtems_stack_checker_switch_extension+0x5c>
20075a8: 92 10 00 01 mov %g1, %o1
20075ac: ba 1f 60 01 xor %i5, 1, %i5
20075b0: 80 8f 60 ff btst 0xff, %i5
20075b4: 02 80 00 05 be 20075c8 <rtems_stack_checker_switch_extension+0x68><== ALWAYS TAKEN
20075b8: 01 00 00 00 nop
Stack_check_report_blown_task( running, pattern_ok );
20075bc: 90 10 00 18 mov %i0, %o0
20075c0: 7f ff ff be call 20074b8 <Stack_check_report_blown_task>
20075c4: 92 0a 60 01 and %o1, 1, %o1
20075c8: 81 c7 e0 08 ret
20075cc: 81 e8 00 00 restore
0201f55c <rtems_string_to_int>:
const char *s,
int *n,
char **endptr,
int base
)
{
201f55c: 9d e3 bf 98 save %sp, -104, %sp
long result;
char *end;
if ( !n )
201f560: 80 a6 60 00 cmp %i1, 0
201f564: 02 80 00 25 be 201f5f8 <rtems_string_to_int+0x9c>
201f568: 82 10 20 09 mov 9, %g1
return RTEMS_INVALID_ADDRESS;
errno = 0;
201f56c: 40 00 8b 20 call 20421ec <__errno>
201f570: 01 00 00 00 nop
201f574: c0 22 00 00 clr [ %o0 ]
*n = 0;
201f578: c0 26 40 00 clr [ %i1 ]
result = strtol( s, &end, base );
201f57c: 90 10 00 18 mov %i0, %o0
201f580: 92 07 bf fc add %fp, -4, %o1
201f584: 40 00 ac 06 call 204a59c <strtol>
201f588: 94 10 00 1b mov %i3, %o2
if ( endptr )
201f58c: 80 a6 a0 00 cmp %i2, 0
return RTEMS_INVALID_ADDRESS;
errno = 0;
*n = 0;
result = strtol( s, &end, base );
201f590: ba 10 00 08 mov %o0, %i5
if ( endptr )
201f594: 02 80 00 03 be 201f5a0 <rtems_string_to_int+0x44>
201f598: c4 07 bf fc ld [ %fp + -4 ], %g2
*endptr = end;
201f59c: c4 26 80 00 st %g2, [ %i2 ]
if ( end == s )
201f5a0: 80 a0 80 18 cmp %g2, %i0
201f5a4: 02 80 00 15 be 201f5f8 <rtems_string_to_int+0x9c>
201f5a8: 82 10 20 0b mov 0xb, %g1
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
201f5ac: 40 00 8b 10 call 20421ec <__errno>
201f5b0: 01 00 00 00 nop
201f5b4: c2 02 00 00 ld [ %o0 ], %g1
201f5b8: 80 a0 60 22 cmp %g1, 0x22
201f5bc: 32 80 00 0e bne,a 201f5f4 <rtems_string_to_int+0x98>
201f5c0: fa 26 40 00 st %i5, [ %i1 ]
(( result == 0 ) || ( result == LONG_MAX ) || ( result == LONG_MIN )))
201f5c4: 03 20 00 00 sethi %hi(0x80000000), %g1
201f5c8: 82 38 40 1d xnor %g1, %i5, %g1
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
201f5cc: 80 a0 60 00 cmp %g1, 0
201f5d0: 02 80 00 0a be 201f5f8 <rtems_string_to_int+0x9c>
201f5d4: 82 10 20 0a mov 0xa, %g1
201f5d8: 80 a7 60 00 cmp %i5, 0
201f5dc: 02 80 00 07 be 201f5f8 <rtems_string_to_int+0x9c> <== NEVER TAKEN
201f5e0: 05 20 00 00 sethi %hi(0x80000000), %g2
(( result == 0 ) || ( result == LONG_MAX ) || ( result == LONG_MIN )))
201f5e4: 80 a7 40 02 cmp %i5, %g2
201f5e8: 02 80 00 04 be 201f5f8 <rtems_string_to_int+0x9c> <== ALWAYS TAKEN
201f5ec: 01 00 00 00 nop
errno = ERANGE;
return RTEMS_INVALID_NUMBER;
}
#endif
*n = result;
201f5f0: fa 26 40 00 st %i5, [ %i1 ] <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
201f5f4: 82 10 20 00 clr %g1
}
201f5f8: 81 c7 e0 08 ret
201f5fc: 91 e8 00 01 restore %g0, %g1, %o0
0200daac <rtems_string_to_long>:
const char *s,
long *n,
char **endptr,
int base
)
{
200daac: 9d e3 bf 98 save %sp, -104, %sp
long result;
char *end;
if ( !n )
200dab0: 80 a6 60 00 cmp %i1, 0
200dab4: 02 80 00 25 be 200db48 <rtems_string_to_long+0x9c>
200dab8: 82 10 20 09 mov 9, %g1
return RTEMS_INVALID_ADDRESS;
errno = 0;
200dabc: 40 00 0b de call 2010a34 <__errno>
200dac0: 01 00 00 00 nop
200dac4: c0 22 00 00 clr [ %o0 ]
*n = 0;
200dac8: c0 26 40 00 clr [ %i1 ]
result = strtol( s, &end, base );
200dacc: 90 10 00 18 mov %i0, %o0
200dad0: 92 07 bf fc add %fp, -4, %o1
200dad4: 40 00 17 8d call 2013908 <strtol>
200dad8: 94 10 00 1b mov %i3, %o2
if ( endptr )
200dadc: 80 a6 a0 00 cmp %i2, 0
return RTEMS_INVALID_ADDRESS;
errno = 0;
*n = 0;
result = strtol( s, &end, base );
200dae0: ba 10 00 08 mov %o0, %i5
if ( endptr )
200dae4: 02 80 00 03 be 200daf0 <rtems_string_to_long+0x44>
200dae8: c4 07 bf fc ld [ %fp + -4 ], %g2
*endptr = end;
200daec: c4 26 80 00 st %g2, [ %i2 ]
if ( end == s )
200daf0: 80 a0 80 18 cmp %g2, %i0
200daf4: 02 80 00 15 be 200db48 <rtems_string_to_long+0x9c>
200daf8: 82 10 20 0b mov 0xb, %g1
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
200dafc: 40 00 0b ce call 2010a34 <__errno>
200db00: 01 00 00 00 nop
200db04: c2 02 00 00 ld [ %o0 ], %g1
200db08: 80 a0 60 22 cmp %g1, 0x22
200db0c: 32 80 00 0e bne,a 200db44 <rtems_string_to_long+0x98>
200db10: fa 26 40 00 st %i5, [ %i1 ]
(( result == 0 ) || ( result == LONG_MAX ) || ( result == LONG_MIN )))
200db14: 03 20 00 00 sethi %hi(0x80000000), %g1
200db18: 82 38 40 1d xnor %g1, %i5, %g1
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
200db1c: 80 a0 60 00 cmp %g1, 0
200db20: 02 80 00 0a be 200db48 <rtems_string_to_long+0x9c>
200db24: 82 10 20 0a mov 0xa, %g1
200db28: 80 a7 60 00 cmp %i5, 0
200db2c: 02 80 00 07 be 200db48 <rtems_string_to_long+0x9c> <== NEVER TAKEN
200db30: 05 20 00 00 sethi %hi(0x80000000), %g2
(( result == 0 ) || ( result == LONG_MAX ) || ( result == LONG_MIN )))
200db34: 80 a7 40 02 cmp %i5, %g2
200db38: 02 80 00 04 be 200db48 <rtems_string_to_long+0x9c> <== ALWAYS TAKEN
200db3c: 01 00 00 00 nop
return RTEMS_INVALID_NUMBER;
*n = result;
200db40: fa 26 40 00 st %i5, [ %i1 ] <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
200db44: 82 10 20 00 clr %g1
}
200db48: 81 c7 e0 08 ret
200db4c: 91 e8 00 01 restore %g0, %g1, %o0
0200d9e0 <rtems_string_to_long_long>:
const char *s,
long long *n,
char **endptr,
int base
)
{
200d9e0: 9d e3 bf 98 save %sp, -104, %sp
long long result;
char *end;
if ( !n )
200d9e4: 80 a6 60 00 cmp %i1, 0
200d9e8: 02 80 00 2f be 200daa4 <rtems_string_to_long_long+0xc4>
200d9ec: 82 10 20 09 mov 9, %g1
return RTEMS_INVALID_ADDRESS;
errno = 0;
200d9f0: 40 00 0c 11 call 2010a34 <__errno>
200d9f4: 01 00 00 00 nop
200d9f8: c0 22 00 00 clr [ %o0 ]
*n = 0;
200d9fc: c0 26 40 00 clr [ %i1 ]
200da00: c0 26 60 04 clr [ %i1 + 4 ]
result = strtoll( s, &end, base );
200da04: 90 10 00 18 mov %i0, %o0
200da08: 92 07 bf fc add %fp, -4, %o1
200da0c: 40 00 17 c8 call 201392c <strtoll>
200da10: 94 10 00 1b mov %i3, %o2
if ( endptr )
200da14: 80 a6 a0 00 cmp %i2, 0
return RTEMS_INVALID_ADDRESS;
errno = 0;
*n = 0;
result = strtoll( s, &end, base );
200da18: b8 10 00 08 mov %o0, %i4
200da1c: ba 10 00 09 mov %o1, %i5
if ( endptr )
200da20: 02 80 00 03 be 200da2c <rtems_string_to_long_long+0x4c>
200da24: c4 07 bf fc ld [ %fp + -4 ], %g2
*endptr = end;
200da28: c4 26 80 00 st %g2, [ %i2 ]
if ( end == s )
200da2c: 80 a0 80 18 cmp %g2, %i0
200da30: 02 80 00 1d be 200daa4 <rtems_string_to_long_long+0xc4>
200da34: 82 10 20 0b mov 0xb, %g1
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
200da38: 40 00 0b ff call 2010a34 <__errno>
200da3c: 01 00 00 00 nop
200da40: c2 02 00 00 ld [ %o0 ], %g1
200da44: 80 a0 60 22 cmp %g1, 0x22
200da48: 32 80 00 16 bne,a 200daa0 <rtems_string_to_long_long+0xc0>
200da4c: f8 3e 40 00 std %i4, [ %i1 ]
(( result == 0 ) || ( result == LONG_LONG_MAX ) || ( result == LONG_LONG_MIN )))
200da50: 05 1f ff ff sethi %hi(0x7ffffc00), %g2
200da54: 07 3f ff ff sethi %hi(0xfffffc00), %g3
200da58: 84 10 a3 ff or %g2, 0x3ff, %g2
200da5c: 86 10 e3 ff or %g3, 0x3ff, %g3
200da60: 84 1f 00 02 xor %i4, %g2, %g2
200da64: 86 1f 40 03 xor %i5, %g3, %g3
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
200da68: 80 90 80 03 orcc %g2, %g3, %g0
200da6c: 02 80 00 0e be 200daa4 <rtems_string_to_long_long+0xc4>
200da70: 82 10 20 0a mov 0xa, %g1
200da74: 80 97 00 1d orcc %i4, %i5, %g0
200da78: 02 80 00 0b be 200daa4 <rtems_string_to_long_long+0xc4> <== NEVER TAKEN
200da7c: 01 00 00 00 nop
(( result == 0 ) || ( result == LONG_LONG_MAX ) || ( result == LONG_LONG_MIN )))
200da80: 03 20 00 00 sethi %hi(0x80000000), %g1
200da84: 80 a7 00 01 cmp %i4, %g1
200da88: 32 80 00 06 bne,a 200daa0 <rtems_string_to_long_long+0xc0><== NEVER TAKEN
200da8c: f8 3e 40 00 std %i4, [ %i1 ] <== NOT EXECUTED
200da90: 80 a7 60 00 cmp %i5, 0
200da94: 22 80 00 04 be,a 200daa4 <rtems_string_to_long_long+0xc4><== ALWAYS TAKEN
200da98: 82 10 20 0a mov 0xa, %g1
return RTEMS_INVALID_NUMBER;
*n = result;
200da9c: f8 3e 40 00 std %i4, [ %i1 ] <== NOT EXECUTED
200daa0: 82 10 20 00 clr %g1
return RTEMS_SUCCESSFUL;
}
200daa4: 81 c7 e0 08 ret
200daa8: 91 e8 00 01 restore %g0, %g1, %o0
0201f610 <rtems_string_to_unsigned_char>:
const char *s,
unsigned char *n,
char **endptr,
int base
)
{
201f610: 9d e3 bf 98 save %sp, -104, %sp
unsigned long result;
char *end;
if ( !n )
201f614: 80 a6 60 00 cmp %i1, 0
201f618: 02 80 00 26 be 201f6b0 <rtems_string_to_unsigned_char+0xa0>
201f61c: 82 10 20 09 mov 9, %g1
return RTEMS_INVALID_ADDRESS;
errno = 0;
201f620: 40 00 8a f3 call 20421ec <__errno>
201f624: 01 00 00 00 nop
201f628: c0 22 00 00 clr [ %o0 ]
*n = 0;
201f62c: c0 2e 40 00 clrb [ %i1 ]
result = strtoul( s, &end, base );
201f630: 90 10 00 18 mov %i0, %o0
201f634: 92 07 bf fc add %fp, -4, %o1
201f638: 40 00 ad 27 call 204aad4 <strtoul>
201f63c: 94 10 00 1b mov %i3, %o2
if ( endptr )
201f640: 80 a6 a0 00 cmp %i2, 0
return RTEMS_INVALID_ADDRESS;
errno = 0;
*n = 0;
result = strtoul( s, &end, base );
201f644: ba 10 00 08 mov %o0, %i5
if ( endptr )
201f648: 02 80 00 03 be 201f654 <rtems_string_to_unsigned_char+0x44>
201f64c: c4 07 bf fc ld [ %fp + -4 ], %g2
*endptr = end;
201f650: c4 26 80 00 st %g2, [ %i2 ]
if ( end == s )
201f654: 80 a0 80 18 cmp %g2, %i0
201f658: 02 80 00 16 be 201f6b0 <rtems_string_to_unsigned_char+0xa0>
201f65c: 82 10 20 0b mov 0xb, %g1
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
201f660: 40 00 8a e3 call 20421ec <__errno>
201f664: 01 00 00 00 nop
201f668: c2 02 00 00 ld [ %o0 ], %g1
201f66c: 80 a0 60 22 cmp %g1, 0x22
201f670: 12 80 00 07 bne 201f68c <rtems_string_to_unsigned_char+0x7c>
201f674: 80 a7 60 ff cmp %i5, 0xff
(( result == 0 ) || ( result == ULONG_MAX )))
201f678: 84 07 7f ff add %i5, -1, %g2
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
201f67c: 80 a0 bf fd cmp %g2, -3
201f680: 18 80 00 0c bgu 201f6b0 <rtems_string_to_unsigned_char+0xa0><== ALWAYS TAKEN
201f684: 82 10 20 0a mov 0xa, %g1
(( result == 0 ) || ( result == ULONG_MAX )))
return RTEMS_INVALID_NUMBER;
#if (UCHAR_MAX < ULONG_MAX)
if ( result > UCHAR_MAX ) {
201f688: 80 a7 60 ff cmp %i5, 0xff <== NOT EXECUTED
201f68c: 28 80 00 08 bleu,a 201f6ac <rtems_string_to_unsigned_char+0x9c>
201f690: fa 2e 40 00 stb %i5, [ %i1 ]
errno = ERANGE;
201f694: 40 00 8a d6 call 20421ec <__errno>
201f698: 01 00 00 00 nop
201f69c: 82 10 20 22 mov 0x22, %g1 ! 22 <PROM_START+0x22>
201f6a0: c2 22 00 00 st %g1, [ %o0 ]
return RTEMS_INVALID_NUMBER;
201f6a4: 10 80 00 03 b 201f6b0 <rtems_string_to_unsigned_char+0xa0>
201f6a8: 82 10 20 0a mov 0xa, %g1
}
#endif
*n = result;
return RTEMS_SUCCESSFUL;
201f6ac: 82 10 20 00 clr %g1
}
201f6b0: 81 c7 e0 08 ret
201f6b4: 91 e8 00 01 restore %g0, %g1, %o0
0200dc08 <rtems_string_to_unsigned_int>:
const char *s,
unsigned int *n,
char **endptr,
int base
)
{
200dc08: 9d e3 bf 98 save %sp, -104, %sp
unsigned long result;
char *end;
if ( !n )
200dc0c: 80 a6 60 00 cmp %i1, 0
200dc10: 02 80 00 1e be 200dc88 <rtems_string_to_unsigned_int+0x80>
200dc14: 82 10 20 09 mov 9, %g1
return RTEMS_INVALID_ADDRESS;
errno = 0;
200dc18: 40 00 0b 87 call 2010a34 <__errno>
200dc1c: 01 00 00 00 nop
200dc20: c0 22 00 00 clr [ %o0 ]
*n = 0;
200dc24: c0 26 40 00 clr [ %i1 ]
result = strtoul( s, &end, base );
200dc28: 90 10 00 18 mov %i0, %o0
200dc2c: 92 07 bf fc add %fp, -4, %o1
200dc30: 40 00 18 84 call 2013e40 <strtoul>
200dc34: 94 10 00 1b mov %i3, %o2
if ( endptr )
200dc38: 80 a6 a0 00 cmp %i2, 0
return RTEMS_INVALID_ADDRESS;
errno = 0;
*n = 0;
result = strtoul( s, &end, base );
200dc3c: ba 10 00 08 mov %o0, %i5
if ( endptr )
200dc40: 02 80 00 03 be 200dc4c <rtems_string_to_unsigned_int+0x44>
200dc44: c4 07 bf fc ld [ %fp + -4 ], %g2
*endptr = end;
200dc48: c4 26 80 00 st %g2, [ %i2 ]
if ( end == s )
200dc4c: 80 a0 80 18 cmp %g2, %i0
200dc50: 02 80 00 0e be 200dc88 <rtems_string_to_unsigned_int+0x80>
200dc54: 82 10 20 0b mov 0xb, %g1
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
200dc58: 40 00 0b 77 call 2010a34 <__errno>
200dc5c: 01 00 00 00 nop
200dc60: c2 02 00 00 ld [ %o0 ], %g1
200dc64: 80 a0 60 22 cmp %g1, 0x22
200dc68: 32 80 00 07 bne,a 200dc84 <rtems_string_to_unsigned_int+0x7c>
200dc6c: fa 26 40 00 st %i5, [ %i1 ]
(( result == 0 ) || ( result == ULONG_MAX )))
200dc70: 84 07 7f ff add %i5, -1, %g2
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
200dc74: 80 a0 bf fd cmp %g2, -3
200dc78: 18 80 00 04 bgu 200dc88 <rtems_string_to_unsigned_int+0x80><== ALWAYS TAKEN
200dc7c: 82 10 20 0a mov 0xa, %g1
errno = ERANGE;
return RTEMS_INVALID_NUMBER;
}
#endif
*n = result;
200dc80: fa 26 40 00 st %i5, [ %i1 ] <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
200dc84: 82 10 20 00 clr %g1
}
200dc88: 81 c7 e0 08 ret
200dc8c: 91 e8 00 01 restore %g0, %g1, %o0
0201f6b8 <rtems_string_to_unsigned_long>:
const char *s,
unsigned long *n,
char **endptr,
int base
)
{
201f6b8: 9d e3 bf 98 save %sp, -104, %sp
unsigned long result;
char *end;
if ( !n )
201f6bc: 80 a6 60 00 cmp %i1, 0
201f6c0: 02 80 00 1e be 201f738 <rtems_string_to_unsigned_long+0x80>
201f6c4: 82 10 20 09 mov 9, %g1
return RTEMS_INVALID_ADDRESS;
errno = 0;
201f6c8: 40 00 8a c9 call 20421ec <__errno>
201f6cc: 01 00 00 00 nop
201f6d0: c0 22 00 00 clr [ %o0 ]
*n = 0;
201f6d4: c0 26 40 00 clr [ %i1 ]
result = strtoul( s, &end, base );
201f6d8: 90 10 00 18 mov %i0, %o0
201f6dc: 92 07 bf fc add %fp, -4, %o1
201f6e0: 40 00 ac fd call 204aad4 <strtoul>
201f6e4: 94 10 00 1b mov %i3, %o2
if ( endptr )
201f6e8: 80 a6 a0 00 cmp %i2, 0
return RTEMS_INVALID_ADDRESS;
errno = 0;
*n = 0;
result = strtoul( s, &end, base );
201f6ec: ba 10 00 08 mov %o0, %i5
if ( endptr )
201f6f0: 02 80 00 03 be 201f6fc <rtems_string_to_unsigned_long+0x44>
201f6f4: c4 07 bf fc ld [ %fp + -4 ], %g2
*endptr = end;
201f6f8: c4 26 80 00 st %g2, [ %i2 ]
if ( end == s )
201f6fc: 80 a0 80 18 cmp %g2, %i0
201f700: 02 80 00 0e be 201f738 <rtems_string_to_unsigned_long+0x80>
201f704: 82 10 20 0b mov 0xb, %g1
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
201f708: 40 00 8a b9 call 20421ec <__errno>
201f70c: 01 00 00 00 nop
201f710: c2 02 00 00 ld [ %o0 ], %g1
201f714: 80 a0 60 22 cmp %g1, 0x22
201f718: 32 80 00 07 bne,a 201f734 <rtems_string_to_unsigned_long+0x7c>
201f71c: fa 26 40 00 st %i5, [ %i1 ]
(( result == 0 ) || ( result == ULONG_MAX )))
201f720: 84 07 7f ff add %i5, -1, %g2
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
201f724: 80 a0 bf fd cmp %g2, -3
201f728: 18 80 00 04 bgu 201f738 <rtems_string_to_unsigned_long+0x80><== ALWAYS TAKEN
201f72c: 82 10 20 0a mov 0xa, %g1
(( result == 0 ) || ( result == ULONG_MAX )))
return RTEMS_INVALID_NUMBER;
*n = result;
201f730: fa 26 40 00 st %i5, [ %i1 ] <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
201f734: 82 10 20 00 clr %g1
}
201f738: 81 c7 e0 08 ret
201f73c: 91 e8 00 01 restore %g0, %g1, %o0
0200dc90 <rtems_string_to_unsigned_long_long>:
const char *s,
unsigned long long *n,
char **endptr,
int base
)
{
200dc90: 9d e3 bf 98 save %sp, -104, %sp
unsigned long long result;
char *end;
if ( !n )
200dc94: 80 a6 60 00 cmp %i1, 0
200dc98: 02 80 00 23 be 200dd24 <rtems_string_to_unsigned_long_long+0x94>
200dc9c: 82 10 20 09 mov 9, %g1
return RTEMS_INVALID_ADDRESS;
errno = 0;
200dca0: 40 00 0b 65 call 2010a34 <__errno>
200dca4: 01 00 00 00 nop
200dca8: c0 22 00 00 clr [ %o0 ]
*n = 0;
200dcac: c0 26 40 00 clr [ %i1 ]
200dcb0: c0 26 60 04 clr [ %i1 + 4 ]
result = strtoull( s, &end, base );
200dcb4: 90 10 00 18 mov %i0, %o0
200dcb8: 92 07 bf fc add %fp, -4, %o1
200dcbc: 40 00 18 6a call 2013e64 <strtoull>
200dcc0: 94 10 00 1b mov %i3, %o2
if ( endptr )
200dcc4: 80 a6 a0 00 cmp %i2, 0
return RTEMS_INVALID_ADDRESS;
errno = 0;
*n = 0;
result = strtoull( s, &end, base );
200dcc8: b8 10 00 08 mov %o0, %i4
200dccc: ba 10 00 09 mov %o1, %i5
if ( endptr )
200dcd0: 02 80 00 03 be 200dcdc <rtems_string_to_unsigned_long_long+0x4c>
200dcd4: c4 07 bf fc ld [ %fp + -4 ], %g2
*endptr = end;
200dcd8: c4 26 80 00 st %g2, [ %i2 ]
if ( end == s )
200dcdc: 80 a0 80 18 cmp %g2, %i0
200dce0: 02 80 00 11 be 200dd24 <rtems_string_to_unsigned_long_long+0x94>
200dce4: 82 10 20 0b mov 0xb, %g1
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
200dce8: 40 00 0b 53 call 2010a34 <__errno>
200dcec: 01 00 00 00 nop
200dcf0: c2 02 00 00 ld [ %o0 ], %g1
200dcf4: 80 a0 60 22 cmp %g1, 0x22
200dcf8: 32 80 00 0a bne,a 200dd20 <rtems_string_to_unsigned_long_long+0x90>
200dcfc: f8 3e 40 00 std %i4, [ %i1 ]
(( result == 0 ) || ( result == ULONG_LONG_MAX )))
200dd00: 86 87 7f ff addcc %i5, -1, %g3
200dd04: 84 47 3f ff addx %i4, -1, %g2
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
200dd08: 80 a0 bf ff cmp %g2, -1
200dd0c: 12 80 00 04 bne 200dd1c <rtems_string_to_unsigned_long_long+0x8c><== NEVER TAKEN
200dd10: 80 a0 ff fd cmp %g3, -3
200dd14: 18 80 00 04 bgu 200dd24 <rtems_string_to_unsigned_long_long+0x94><== ALWAYS TAKEN
200dd18: 82 10 20 0a mov 0xa, %g1
(( result == 0 ) || ( result == ULONG_LONG_MAX )))
return RTEMS_INVALID_NUMBER;
*n = result;
200dd1c: f8 3e 40 00 std %i4, [ %i1 ] <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
200dd20: 82 10 20 00 clr %g1
}
200dd24: 81 c7 e0 08 ret
200dd28: 91 e8 00 01 restore %g0, %g1, %o0
020030f0 <rtems_tarfs_load>:
int rtems_tarfs_load(
const char *mountpoint,
uint8_t *tar_image,
size_t tar_size
)
{
20030f0: 9d e3 bd e8 save %sp, -536, %sp
IMFS_jnode_t *node;
int rv = 0;
int eval_flags = RTEMS_FS_FOLLOW_LINK;
rtems_filesystem_eval_path_context_t ctx;
rtems_filesystem_location_info_t rootloc;
rtems_filesystem_location_info_t *currentloc =
20030f4: 94 10 20 18 mov 0x18, %o2
20030f8: 92 10 00 18 mov %i0, %o1
20030fc: 40 00 08 04 call 200510c <rtems_filesystem_eval_path_start>
2003100: 90 07 be 60 add %fp, -416, %o0
static inline void rtems_filesystem_eval_path_extract_currentloc(
rtems_filesystem_eval_path_context_t *ctx,
rtems_filesystem_location_info_t *get
)
{
rtems_filesystem_location_copy_and_detach(
2003104: 92 07 be 78 add %fp, -392, %o1
2003108: b6 10 00 08 mov %o0, %i3
200310c: 40 00 08 fa call 20054f4 <rtems_filesystem_location_copy_and_detach>
2003110: 90 07 be 48 add %fp, -440, %o0
static inline void rtems_filesystem_eval_path_set_flags(
rtems_filesystem_eval_path_context_t *ctx,
int flags
)
{
ctx->flags = flags;
2003114: 82 10 20 60 mov 0x60, %g1
2003118: c2 27 be 70 st %g1, [ %fp + -400 ]
&ctx,
RTEMS_FS_MAKE | RTEMS_FS_EXCLUSIVE
);
if (
rootloc.mt_entry->ops != &IMFS_ops
200311c: c2 07 be 5c ld [ %fp + -420 ], %g1
rtems_filesystem_eval_path_set_flags(
&ctx,
RTEMS_FS_MAKE | RTEMS_FS_EXCLUSIVE
);
if (
2003120: 05 00 80 7e sethi %hi(0x201f800), %g2
rootloc.mt_entry->ops != &IMFS_ops
2003124: c2 00 60 0c ld [ %g1 + 0xc ], %g1
rtems_filesystem_eval_path_set_flags(
&ctx,
RTEMS_FS_MAKE | RTEMS_FS_EXCLUSIVE
);
if (
2003128: 84 10 a1 a8 or %g2, 0x1a8, %g2
200312c: 80 a0 40 02 cmp %g1, %g2
2003130: 02 80 00 06 be 2003148 <rtems_tarfs_load+0x58>
2003134: 05 00 80 80 sethi %hi(0x2020000), %g2
rootloc.mt_entry->ops != &IMFS_ops
&& rootloc.mt_entry->ops != &fifoIMFS_ops
2003138: 84 10 a3 18 or %g2, 0x318, %g2 ! 2020318 <fifoIMFS_ops>
200313c: 80 a0 40 02 cmp %g1, %g2
2003140: 32 80 00 66 bne,a 20032d8 <rtems_tarfs_load+0x1e8> <== ALWAYS TAKEN
2003144: b0 10 3f ff mov -1, %i0
/*
* Read a header.
*/
hdr_ptr = (char *) &tar_image[offset];
offset += 512;
if (strncmp(&hdr_ptr[257], "ustar", 5))
2003148: 25 00 80 7e sethi %hi(0x201f800), %l2
filename,
strlen( filename )
);
rtems_filesystem_eval_path_continue( &ctx );
if ( !rtems_filesystem_location_is_null( currentloc ) ) {
200314c: 27 00 80 80 sethi %hi(0x2020000), %l3
* - 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, "/");
2003150: 29 00 80 72 sethi %hi(0x201c800), %l4
rtems_filesystem_eval_path_set_flags(
&ctx,
RTEMS_FS_MAKE | RTEMS_FS_EXCLUSIVE
);
if (
2003154: ba 10 20 00 clr %i5
/*
* Read a header.
*/
hdr_ptr = (char *) &tar_image[offset];
offset += 512;
if (strncmp(&hdr_ptr[257], "ustar", 5))
2003158: a4 14 a2 30 or %l2, 0x230, %l2
break;
strncpy(filename, hdr_ptr, MAX_NAME_FIELD_SIZE);
200315c: a0 07 be 98 add %fp, -360, %l0
filename,
strlen( filename )
);
rtems_filesystem_eval_path_continue( &ctx );
if ( !rtems_filesystem_location_is_null( currentloc ) ) {
2003160: a6 14 e0 74 or %l3, 0x74, %l3
* - 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, "/");
2003164: a8 15 21 50 or %l4, 0x150, %l4
/*
* Create an IMFS node structure pointing to tar image memory.
*/
offset = 0;
while ( rv == 0 ) {
if (offset + 512 > tar_size)
2003168: b8 07 62 00 add %i5, 0x200, %i4
200316c: 80 a7 00 1a cmp %i4, %i2
2003170: 18 80 00 59 bgu 20032d4 <rtems_tarfs_load+0x1e4> <== NEVER TAKEN
2003174: ba 06 40 1d add %i1, %i5, %i5
/*
* Read a header.
*/
hdr_ptr = (char *) &tar_image[offset];
offset += 512;
if (strncmp(&hdr_ptr[257], "ustar", 5))
2003178: 92 10 00 12 mov %l2, %o1
200317c: 90 07 61 01 add %i5, 0x101, %o0
2003180: 40 00 43 da call 20140e8 <strncmp>
2003184: 94 10 20 05 mov 5, %o2
2003188: 80 a2 20 00 cmp %o0, 0
200318c: 12 80 00 52 bne 20032d4 <rtems_tarfs_load+0x1e4>
2003190: 94 10 20 63 mov 0x63, %o2
break;
strncpy(filename, hdr_ptr, MAX_NAME_FIELD_SIZE);
2003194: 92 10 00 1d mov %i5, %o1
2003198: 40 00 44 2a call 2014240 <strncpy>
200319c: 90 10 00 10 mov %l0, %o0
filename[MAX_NAME_FIELD_SIZE] = '\0';
linkflag = hdr_ptr[156];
file_mode = _rtems_octal2ulong(&hdr_ptr[100], 8);
20031a0: 92 10 20 08 mov 8, %o1
offset += 512;
if (strncmp(&hdr_ptr[257], "ustar", 5))
break;
strncpy(filename, hdr_ptr, MAX_NAME_FIELD_SIZE);
filename[MAX_NAME_FIELD_SIZE] = '\0';
20031a4: c0 2f be fb clrb [ %fp + -261 ]
linkflag = hdr_ptr[156];
20031a8: ec 0f 60 9c ldub [ %i5 + 0x9c ], %l6
file_mode = _rtems_octal2ulong(&hdr_ptr[100], 8);
20031ac: 40 00 21 94 call 200b7fc <_rtems_octal2ulong>
20031b0: 90 07 60 64 add %i5, 0x64, %o0
file_size = _rtems_octal2ulong(&hdr_ptr[124], 12);
20031b4: 92 10 20 0c mov 0xc, %o1
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);
20031b8: aa 10 00 08 mov %o0, %l5
file_size = _rtems_octal2ulong(&hdr_ptr[124], 12);
20031bc: 40 00 21 90 call 200b7fc <_rtems_octal2ulong>
20031c0: 90 07 60 7c add %i5, 0x7c, %o0
hdr_chksum = _rtems_octal2ulong(&hdr_ptr[148], 8);
20031c4: 92 10 20 08 mov 8, %o1
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);
20031c8: a2 10 00 08 mov %o0, %l1
hdr_chksum = _rtems_octal2ulong(&hdr_ptr[148], 8);
20031cc: 40 00 21 8c call 200b7fc <_rtems_octal2ulong>
20031d0: 90 07 60 94 add %i5, 0x94, %o0
20031d4: ae 10 00 08 mov %o0, %l7
if (_rtems_tar_header_checksum(hdr_ptr) != hdr_chksum)
20031d8: 40 00 21 9c call 200b848 <_rtems_tar_header_checksum>
20031dc: 90 10 00 1d mov %i5, %o0
20031e0: 80 a2 00 17 cmp %o0, %l7
20031e4: 12 80 00 3c bne 20032d4 <rtems_tarfs_load+0x1e4> <== NEVER TAKEN
20031e8: 82 0d a0 ff and %l6, 0xff, %g1
* 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) {
20031ec: 80 a0 60 35 cmp %g1, 0x35
20031f0: 12 80 00 16 bne 2003248 <rtems_tarfs_load+0x158>
20031f4: 80 a0 60 30 cmp %g1, 0x30
strcpy(full_filename, mountpoint);
20031f8: 92 10 00 18 mov %i0, %o1
20031fc: 40 00 41 c7 call 2013918 <strcpy>
2003200: 90 07 bf 00 add %fp, -256, %o0
if (full_filename[strlen(full_filename)-1] != '/')
2003204: 40 00 43 87 call 2014020 <strlen>
2003208: 90 07 bf 00 add %fp, -256, %o0
200320c: 90 07 80 08 add %fp, %o0, %o0
2003210: c2 4a 3e ff ldsb [ %o0 + -257 ], %g1
2003214: 80 a0 60 2f cmp %g1, 0x2f
2003218: 02 80 00 04 be 2003228 <rtems_tarfs_load+0x138> <== ALWAYS TAKEN
200321c: 90 07 bf 00 add %fp, -256, %o0
strcat(full_filename, "/");
2003220: 40 00 41 6d call 20137d4 <strcat> <== NOT EXECUTED
2003224: 92 10 00 14 mov %l4, %o1 <== NOT EXECUTED
strcat(full_filename, filename);
2003228: 92 10 00 10 mov %l0, %o1
200322c: 40 00 41 6a call 20137d4 <strcat>
2003230: 90 07 bf 00 add %fp, -256, %o0
mkdir(full_filename, S_IRWXU | S_IRWXG | S_IRWXO);
2003234: 90 07 bf 00 add %fp, -256, %o0
2003238: 40 00 03 f7 call 2004214 <mkdir>
200323c: 92 10 21 ff mov 0x1ff, %o1
rtems_filesystem_eval_path_set_flags(
&ctx,
RTEMS_FS_MAKE | RTEMS_FS_EXCLUSIVE
);
if (
2003240: 10 bf ff ca b 2003168 <rtems_tarfs_load+0x78>
2003244: ba 10 00 1c mov %i4, %i5
mkdir(full_filename, S_IRWXU | S_IRWXG | S_IRWXO);
}
/*
* Create a LINEAR_FILE node
*/
else if (linkflag == REGTYPE) {
2003248: 12 bf ff c8 bne 2003168 <rtems_tarfs_load+0x78>
200324c: ba 10 00 1c mov %i4, %i5
rtems_filesystem_location_free( currentloc );
2003250: 40 00 02 42 call 2003b58 <rtems_filesystem_location_free>
2003254: 90 10 00 1b mov %i3, %o0
rtems_filesystem_location_clone( currentloc, &rootloc );
2003258: 92 07 be 48 add %fp, -440, %o1
200325c: 40 00 01 6f call 2003818 <rtems_filesystem_location_clone>
2003260: 90 10 00 1b mov %i3, %o0
rtems_filesystem_eval_path_set_path(
2003264: 40 00 43 6f call 2014020 <strlen>
2003268: 90 10 00 10 mov %l0, %o0
rtems_filesystem_eval_path_context_t *ctx,
const char *path,
size_t pathlen
)
{
ctx->path = path;
200326c: e0 27 be 60 st %l0, [ %fp + -416 ]
ctx->pathlen = pathlen;
2003270: d0 27 be 64 st %o0, [ %fp + -412 ]
&ctx,
filename,
strlen( filename )
);
rtems_filesystem_eval_path_continue( &ctx );
2003274: 40 00 07 48 call 2004f94 <rtems_filesystem_eval_path_continue>
2003278: 90 07 be 60 add %fp, -416, %o0
if ( !rtems_filesystem_location_is_null( currentloc ) ) {
200327c: c2 06 e0 10 ld [ %i3 + 0x10 ], %g1
2003280: 80 a0 40 13 cmp %g1, %l3
2003284: 02 80 00 0f be 20032c0 <rtems_tarfs_load+0x1d0> <== NEVER TAKEN
2003288: d4 1f be 68 ldd [ %fp + -408 ], %o2
size_t namelen,
mode_t mode,
const IMFS_types_union *info
)
{
const IMFS_fs_info_t *fs_info =
200328c: c2 06 e0 14 ld [ %i3 + 0x14 ], %g1
(const IMFS_fs_info_t *) parentloc->mt_entry->fs_info;
return IMFS_create_node_with_control(
2003290: c2 00 60 08 ld [ %g1 + 8 ], %g1
node = IMFS_create_node(
currentloc,
IMFS_LINEAR_FILE,
rtems_filesystem_eval_path_get_token( &ctx ),
rtems_filesystem_eval_path_get_tokenlen( &ctx ),
(file_mode & (S_IRWXU | S_IRWXG | S_IRWXO)) | S_IFREG,
2003294: 98 0d 61 ff and %l5, 0x1ff, %o4
2003298: d2 00 60 1c ld [ %g1 + 0x1c ], %o1
200329c: 03 00 00 20 sethi %hi(0x8000), %g1
20032a0: 90 10 00 1b mov %i3, %o0
20032a4: 98 13 00 01 or %o4, %g1, %o4
20032a8: 40 00 23 01 call 200beac <IMFS_create_node_with_control>
20032ac: 9a 10 20 00 clr %o5
NULL
);
node->info.linearfile.size = file_size;
node->info.linearfile.direct = &tar_image[offset];
20032b0: 84 06 40 1c add %i1, %i4, %g2
rtems_filesystem_eval_path_get_token( &ctx ),
rtems_filesystem_eval_path_get_tokenlen( &ctx ),
(file_mode & (S_IRWXU | S_IRWXG | S_IRWXO)) | S_IFREG,
NULL
);
node->info.linearfile.size = file_size;
20032b4: c0 22 20 50 clr [ %o0 + 0x50 ]
20032b8: e2 22 20 54 st %l1, [ %o0 + 0x54 ]
node->info.linearfile.direct = &tar_image[offset];
20032bc: c4 22 20 58 st %g2, [ %o0 + 0x58 ]
}
nblocks = (((file_size) + 511) & ~511) / 512;
20032c0: a2 04 61 ff add %l1, 0x1ff, %l1
offset += 512 * nblocks;
20032c4: a2 0c 7e 00 and %l1, -512, %l1
20032c8: b8 04 40 1c add %l1, %i4, %i4
rtems_filesystem_eval_path_set_flags(
&ctx,
RTEMS_FS_MAKE | RTEMS_FS_EXCLUSIVE
);
if (
20032cc: 10 bf ff a7 b 2003168 <rtems_tarfs_load+0x78>
20032d0: ba 10 00 1c mov %i4, %i5
linkflag = hdr_ptr[156];
file_mode = _rtems_octal2ulong(&hdr_ptr[100], 8);
file_size = _rtems_octal2ulong(&hdr_ptr[124], 12);
hdr_chksum = _rtems_octal2ulong(&hdr_ptr[148], 8);
if (_rtems_tar_header_checksum(hdr_ptr) != hdr_chksum)
20032d4: b0 10 20 00 clr %i0
nblocks = (((file_size) + 511) & ~511) / 512;
offset += 512 * nblocks;
}
}
rtems_filesystem_location_free( &rootloc );
20032d8: 40 00 02 20 call 2003b58 <rtems_filesystem_location_free>
20032dc: 90 07 be 48 add %fp, -440, %o0
rtems_filesystem_eval_path_cleanup( &ctx );
20032e0: 40 00 07 c7 call 20051fc <rtems_filesystem_eval_path_cleanup>
20032e4: 90 07 be 60 add %fp, -416, %o0
return rv;
}
20032e8: 81 c7 e0 08 ret
20032ec: 81 e8 00 00 restore
0200f460 <rtems_task_mode>:
rtems_status_code rtems_task_mode(
rtems_mode mode_set,
rtems_mode mask,
rtems_mode *previous_mode_set
)
{
200f460: 9d e3 bf a0 save %sp, -96, %sp
ASR_Information *asr;
bool is_asr_enabled = false;
bool needs_asr_dispatching = false;
rtems_mode old_mode;
if ( !previous_mode_set )
200f464: 80 a6 a0 00 cmp %i2, 0
200f468: 02 80 00 5a be 200f5d0 <rtems_task_mode+0x170>
200f46c: 82 10 20 09 mov 9, %g1
return RTEMS_INVALID_ADDRESS;
executing = _Thread_Executing;
200f470: 03 00 80 78 sethi %hi(0x201e000), %g1
200f474: f8 00 60 1c ld [ %g1 + 0x1c ], %i4 ! 201e01c <_Per_CPU_Information+0xc>
api = executing->API_Extensions[ THREAD_API_RTEMS ];
asr = &api->Signal;
old_mode = (executing->is_preemptible) ? RTEMS_PREEMPT : RTEMS_NO_PREEMPT;
200f478: c2 0f 20 70 ldub [ %i4 + 0x70 ], %g1
if ( !previous_mode_set )
return RTEMS_INVALID_ADDRESS;
executing = _Thread_Executing;
api = executing->API_Extensions[ THREAD_API_RTEMS ];
200f47c: fa 07 21 58 ld [ %i4 + 0x158 ], %i5
asr = &api->Signal;
old_mode = (executing->is_preemptible) ? RTEMS_PREEMPT : RTEMS_NO_PREEMPT;
200f480: 80 a0 00 01 cmp %g0, %g1
if ( executing->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_NONE )
200f484: c2 07 20 78 ld [ %i4 + 0x78 ], %g1
executing = _Thread_Executing;
api = executing->API_Extensions[ THREAD_API_RTEMS ];
asr = &api->Signal;
old_mode = (executing->is_preemptible) ? RTEMS_PREEMPT : RTEMS_NO_PREEMPT;
200f488: b6 60 3f ff subx %g0, -1, %i3
if ( executing->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_NONE )
200f48c: 80 a0 60 00 cmp %g1, 0
200f490: 02 80 00 03 be 200f49c <rtems_task_mode+0x3c>
200f494: b7 2e e0 08 sll %i3, 8, %i3
old_mode |= RTEMS_NO_TIMESLICE;
else
old_mode |= RTEMS_TIMESLICE;
200f498: b6 16 e2 00 or %i3, 0x200, %i3
old_mode |= (asr->is_enabled) ? RTEMS_ASR : RTEMS_NO_ASR;
200f49c: c2 0f 60 08 ldub [ %i5 + 8 ], %g1
200f4a0: 80 a0 00 01 cmp %g0, %g1
old_mode |= _ISR_Get_level();
200f4a4: 7f ff f0 06 call 200b4bc <_CPU_ISR_Get_level>
200f4a8: a0 60 3f ff subx %g0, -1, %l0
if ( executing->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_NONE )
old_mode |= RTEMS_NO_TIMESLICE;
else
old_mode |= RTEMS_TIMESLICE;
old_mode |= (asr->is_enabled) ? RTEMS_ASR : RTEMS_NO_ASR;
200f4ac: a1 2c 20 0a sll %l0, 0xa, %l0
200f4b0: 90 14 00 08 or %l0, %o0, %o0
old_mode |= _ISR_Get_level();
200f4b4: b6 12 00 1b or %o0, %i3, %i3
*previous_mode_set = old_mode;
/*
* These are generic thread scheduling characteristics.
*/
if ( mask & RTEMS_PREEMPT_MASK )
200f4b8: 80 8e 61 00 btst 0x100, %i1
200f4bc: 02 80 00 06 be 200f4d4 <rtems_task_mode+0x74>
200f4c0: f6 26 80 00 st %i3, [ %i2 ]
*/
RTEMS_INLINE_ROUTINE bool _Modes_Is_preempt (
Modes_Control mode_set
)
{
return (mode_set & RTEMS_PREEMPT_MASK) == RTEMS_PREEMPT;
200f4c4: 83 36 20 08 srl %i0, 8, %g1
200f4c8: 82 18 60 01 xor %g1, 1, %g1
200f4cc: 82 08 60 01 and %g1, 1, %g1
executing->is_preemptible = _Modes_Is_preempt(mode_set) ? true : false;
200f4d0: c2 2f 20 70 stb %g1, [ %i4 + 0x70 ]
if ( mask & RTEMS_TIMESLICE_MASK ) {
200f4d4: 80 8e 62 00 btst 0x200, %i1
200f4d8: 02 80 00 0b be 200f504 <rtems_task_mode+0xa4>
200f4dc: 80 8e 60 0f btst 0xf, %i1
if ( _Modes_Is_timeslice(mode_set) ) {
200f4e0: 80 8e 22 00 btst 0x200, %i0
200f4e4: 22 80 00 07 be,a 200f500 <rtems_task_mode+0xa0>
200f4e8: c0 27 20 78 clr [ %i4 + 0x78 ]
executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE;
200f4ec: 82 10 20 01 mov 1, %g1
200f4f0: c2 27 20 78 st %g1, [ %i4 + 0x78 ]
executing->cpu_time_budget = _Thread_Ticks_per_timeslice;
200f4f4: 03 00 80 76 sethi %hi(0x201d800), %g1
200f4f8: c2 00 62 40 ld [ %g1 + 0x240 ], %g1 ! 201da40 <_Thread_Ticks_per_timeslice>
200f4fc: c2 27 20 74 st %g1, [ %i4 + 0x74 ]
}
/*
* Set the new interrupt level
*/
if ( mask & RTEMS_INTERRUPT_MASK )
200f500: 80 8e 60 0f btst 0xf, %i1
200f504: 02 80 00 06 be 200f51c <rtems_task_mode+0xbc>
200f508: 80 8e 64 00 btst 0x400, %i1
*/
RTEMS_INLINE_ROUTINE ISR_Level _Modes_Get_interrupt_level (
Modes_Control mode_set
)
{
return ( mode_set & RTEMS_INTERRUPT_MASK );
200f50c: 90 0e 20 0f and %i0, 0xf, %o0
*/
RTEMS_INLINE_ROUTINE void _Modes_Set_interrupt_level (
Modes_Control mode_set
)
{
_ISR_Set_level( _Modes_Get_interrupt_level( mode_set ) );
200f510: 7f ff cc 71 call 20026d4 <sparc_enable_interrupts>
200f514: 91 2a 20 08 sll %o0, 8, %o0
* This is specific to the RTEMS API
*/
is_asr_enabled = false;
needs_asr_dispatching = false;
if ( mask & RTEMS_ASR_MASK ) {
200f518: 80 8e 64 00 btst 0x400, %i1
200f51c: 02 80 00 14 be 200f56c <rtems_task_mode+0x10c>
200f520: 88 10 20 00 clr %g4
is_asr_enabled = _Modes_Is_asr_disabled( mode_set ) ? false : true;
if ( is_asr_enabled != asr->is_enabled ) {
200f524: c2 0f 60 08 ldub [ %i5 + 8 ], %g1
*/
is_asr_enabled = false;
needs_asr_dispatching = false;
if ( mask & RTEMS_ASR_MASK ) {
is_asr_enabled = _Modes_Is_asr_disabled( mode_set ) ? false : true;
200f528: b1 36 20 0a srl %i0, 0xa, %i0
200f52c: b0 1e 20 01 xor %i0, 1, %i0
200f530: b0 0e 20 01 and %i0, 1, %i0
if ( is_asr_enabled != asr->is_enabled ) {
200f534: 80 a6 00 01 cmp %i0, %g1
200f538: 22 80 00 0e be,a 200f570 <rtems_task_mode+0x110>
200f53c: 03 00 80 77 sethi %hi(0x201dc00), %g1
)
{
rtems_signal_set _signals;
ISR_Level _level;
_ISR_Disable( _level );
200f540: 7f ff cc 61 call 20026c4 <sparc_disable_interrupts>
200f544: f0 2f 60 08 stb %i0, [ %i5 + 8 ]
_signals = information->signals_pending;
200f548: c2 07 60 18 ld [ %i5 + 0x18 ], %g1
information->signals_pending = information->signals_posted;
200f54c: c4 07 60 14 ld [ %i5 + 0x14 ], %g2
information->signals_posted = _signals;
200f550: c2 27 60 14 st %g1, [ %i5 + 0x14 ]
rtems_signal_set _signals;
ISR_Level _level;
_ISR_Disable( _level );
_signals = information->signals_pending;
information->signals_pending = information->signals_posted;
200f554: c4 27 60 18 st %g2, [ %i5 + 0x18 ]
information->signals_posted = _signals;
_ISR_Enable( _level );
200f558: 7f ff cc 5f call 20026d4 <sparc_enable_interrupts>
200f55c: 01 00 00 00 nop
asr->is_enabled = is_asr_enabled;
_ASR_Swap_signals( asr );
if ( _ASR_Are_signals_pending( asr ) ) {
200f560: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
200f564: 80 a0 00 01 cmp %g0, %g1
200f568: 88 40 20 00 addx %g0, 0, %g4
needs_asr_dispatching = true;
}
}
}
if ( _System_state_Is_up( _System_state_Get() ) ) {
200f56c: 03 00 80 77 sethi %hi(0x201dc00), %g1
200f570: c4 00 60 20 ld [ %g1 + 0x20 ], %g2 ! 201dc20 <_System_state_Current>
200f574: 80 a0 a0 03 cmp %g2, 3
200f578: 12 80 00 16 bne 200f5d0 <rtems_task_mode+0x170>
200f57c: 82 10 20 00 clr %g1
bool are_signals_pending
)
{
Thread_Control *executing;
executing = _Thread_Executing;
200f580: 07 00 80 78 sethi %hi(0x201e000), %g3
if ( are_signals_pending ||
200f584: 80 89 20 ff btst 0xff, %g4
bool are_signals_pending
)
{
Thread_Control *executing;
executing = _Thread_Executing;
200f588: 86 10 e0 10 or %g3, 0x10, %g3
if ( are_signals_pending ||
200f58c: 12 80 00 0a bne 200f5b4 <rtems_task_mode+0x154>
200f590: c4 00 e0 0c ld [ %g3 + 0xc ], %g2
200f594: c6 00 e0 10 ld [ %g3 + 0x10 ], %g3
200f598: 80 a0 80 03 cmp %g2, %g3
200f59c: 02 80 00 0d be 200f5d0 <rtems_task_mode+0x170>
200f5a0: 01 00 00 00 nop
(!_Thread_Is_heir( executing ) && executing->is_preemptible) ) {
200f5a4: c4 08 a0 70 ldub [ %g2 + 0x70 ], %g2
200f5a8: 80 a0 a0 00 cmp %g2, 0
200f5ac: 02 80 00 09 be 200f5d0 <rtems_task_mode+0x170> <== NEVER TAKEN
200f5b0: 01 00 00 00 nop
_Thread_Dispatch_necessary = true;
200f5b4: 84 10 20 01 mov 1, %g2 ! 1 <PROM_START+0x1>
200f5b8: 03 00 80 78 sethi %hi(0x201e000), %g1
200f5bc: 82 10 60 10 or %g1, 0x10, %g1 ! 201e010 <_Per_CPU_Information>
200f5c0: c4 28 60 18 stb %g2, [ %g1 + 0x18 ]
if (_Thread_Evaluate_is_dispatch_needed( needs_asr_dispatching ) )
_Thread_Dispatch();
200f5c4: 7f ff ea a5 call 200a058 <_Thread_Dispatch>
200f5c8: 01 00 00 00 nop
}
return RTEMS_SUCCESSFUL;
200f5cc: 82 10 20 00 clr %g1 ! 0 <PROM_START>
}
200f5d0: 81 c7 e0 08 ret
200f5d4: 91 e8 00 01 restore %g0, %g1, %o0
0200bf30 <rtems_task_set_priority>:
rtems_status_code rtems_task_set_priority(
rtems_id id,
rtems_task_priority new_priority,
rtems_task_priority *old_priority
)
{
200bf30: 9d e3 bf 98 save %sp, -104, %sp
register Thread_Control *the_thread;
Objects_Locations location;
if ( new_priority != RTEMS_CURRENT_PRIORITY &&
200bf34: 80 a6 60 00 cmp %i1, 0
200bf38: 02 80 00 08 be 200bf58 <rtems_task_set_priority+0x28>
200bf3c: 80 a6 a0 00 cmp %i2, 0
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 ) );
200bf40: 03 00 80 84 sethi %hi(0x2021000), %g1
200bf44: c4 08 61 98 ldub [ %g1 + 0x198 ], %g2 ! 2021198 <rtems_maximum_priority>
200bf48: 80 a6 40 02 cmp %i1, %g2
200bf4c: 18 80 00 1e bgu 200bfc4 <rtems_task_set_priority+0x94>
200bf50: 82 10 20 13 mov 0x13, %g1
!_RTEMS_tasks_Priority_is_valid( new_priority ) )
return RTEMS_INVALID_PRIORITY;
if ( !old_priority )
200bf54: 80 a6 a0 00 cmp %i2, 0
200bf58: 02 80 00 1b be 200bfc4 <rtems_task_set_priority+0x94>
200bf5c: 82 10 20 09 mov 9, %g1
return RTEMS_INVALID_ADDRESS;
the_thread = _Thread_Get( id, &location );
200bf60: 90 10 00 18 mov %i0, %o0
200bf64: 40 00 09 8a call 200e58c <_Thread_Get>
200bf68: 92 07 bf fc add %fp, -4, %o1
switch ( location ) {
200bf6c: c2 07 bf fc ld [ %fp + -4 ], %g1
200bf70: 80 a0 60 00 cmp %g1, 0
200bf74: 12 80 00 14 bne 200bfc4 <rtems_task_set_priority+0x94>
200bf78: 82 10 20 04 mov 4, %g1
case OBJECTS_LOCAL:
/* XXX need helper to "convert" from core priority */
*old_priority = the_thread->current_priority;
200bf7c: c2 02 20 14 ld [ %o0 + 0x14 ], %g1
if ( new_priority != RTEMS_CURRENT_PRIORITY ) {
200bf80: 80 a6 60 00 cmp %i1, 0
200bf84: 02 80 00 0d be 200bfb8 <rtems_task_set_priority+0x88>
200bf88: c2 26 80 00 st %g1, [ %i2 ]
the_thread->real_priority = new_priority;
if ( the_thread->resource_count == 0 ||
200bf8c: c2 02 20 1c ld [ %o0 + 0x1c ], %g1
200bf90: 80 a0 60 00 cmp %g1, 0
200bf94: 02 80 00 06 be 200bfac <rtems_task_set_priority+0x7c>
200bf98: f2 22 20 18 st %i1, [ %o0 + 0x18 ]
200bf9c: c2 02 20 14 ld [ %o0 + 0x14 ], %g1
200bfa0: 80 a0 40 19 cmp %g1, %i1
200bfa4: 08 80 00 05 bleu 200bfb8 <rtems_task_set_priority+0x88> <== ALWAYS TAKEN
200bfa8: 01 00 00 00 nop
the_thread->current_priority > new_priority )
_Thread_Change_priority( the_thread, new_priority, false );
200bfac: 92 10 00 19 mov %i1, %o1
200bfb0: 40 00 08 45 call 200e0c4 <_Thread_Change_priority>
200bfb4: 94 10 20 00 clr %o2
}
_Thread_Enable_dispatch();
200bfb8: 40 00 09 68 call 200e558 <_Thread_Enable_dispatch>
200bfbc: 01 00 00 00 nop
200bfc0: 82 10 20 00 clr %g1 ! 0 <PROM_START>
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
200bfc4: 81 c7 e0 08 ret
200bfc8: 91 e8 00 01 restore %g0, %g1, %o0
020064d8 <rtems_termios_baud_to_index>:
#include <rtems/termiostypes.h>
int rtems_termios_baud_to_index(
rtems_termios_baud_t termios_baud
)
{
20064d8: 82 10 00 08 mov %o0, %g1
int baud_index;
switch (termios_baud) {
20064dc: 80 a0 60 09 cmp %g1, 9
20064e0: 02 80 00 17 be 200653c <rtems_termios_baud_to_index+0x64>
20064e4: 90 10 20 09 mov 9, %o0
20064e8: 80 a0 60 09 cmp %g1, 9
20064ec: 18 80 00 23 bgu 2006578 <rtems_termios_baud_to_index+0xa0>
20064f0: 80 a0 60 0e cmp %g1, 0xe
20064f4: 80 a0 60 04 cmp %g1, 4
20064f8: 02 80 00 11 be 200653c <rtems_termios_baud_to_index+0x64>
20064fc: 90 10 20 04 mov 4, %o0
2006500: 80 a0 60 04 cmp %g1, 4
2006504: 18 80 00 10 bgu 2006544 <rtems_termios_baud_to_index+0x6c>
2006508: 80 a0 60 06 cmp %g1, 6
200650c: 80 a0 60 01 cmp %g1, 1
2006510: 02 80 00 0b be 200653c <rtems_termios_baud_to_index+0x64>
2006514: 90 10 20 01 mov 1, %o0
2006518: 80 a0 60 01 cmp %g1, 1
200651c: 0a 80 00 08 bcs 200653c <rtems_termios_baud_to_index+0x64>
2006520: 90 10 20 00 clr %o0
2006524: 80 a0 60 02 cmp %g1, 2
2006528: 02 80 00 05 be 200653c <rtems_termios_baud_to_index+0x64>
200652c: 90 10 20 02 mov 2, %o0
2006530: 80 a0 60 03 cmp %g1, 3
2006534: 12 80 00 3b bne 2006620 <rtems_termios_baud_to_index+0x148><== NEVER TAKEN
2006538: 90 10 20 03 mov 3, %o0
200653c: 81 c3 e0 08 retl
2006540: 01 00 00 00 nop
2006544: 02 bf ff fe be 200653c <rtems_termios_baud_to_index+0x64>
2006548: 90 10 20 06 mov 6, %o0 ! 6 <PROM_START+0x6>
200654c: 80 a0 60 06 cmp %g1, 6
2006550: 0a bf ff fb bcs 200653c <rtems_termios_baud_to_index+0x64>
2006554: 90 10 20 05 mov 5, %o0
2006558: 80 a0 60 07 cmp %g1, 7
200655c: 02 bf ff f8 be 200653c <rtems_termios_baud_to_index+0x64>
2006560: 90 10 20 07 mov 7, %o0
2006564: 80 a0 60 08 cmp %g1, 8
2006568: 12 80 00 2e bne 2006620 <rtems_termios_baud_to_index+0x148><== NEVER TAKEN
200656c: 90 10 20 08 mov 8, %o0
2006570: 81 c3 e0 08 retl
2006574: 01 00 00 00 nop
2006578: 02 bf ff f1 be 200653c <rtems_termios_baud_to_index+0x64>
200657c: 90 10 20 0e mov 0xe, %o0 ! e <PROM_START+0xe>
2006580: 80 a0 60 0e cmp %g1, 0xe
2006584: 18 80 00 10 bgu 20065c4 <rtems_termios_baud_to_index+0xec>
2006588: 05 00 00 04 sethi %hi(0x1000), %g2
200658c: 80 a0 60 0b cmp %g1, 0xb
2006590: 02 bf ff eb be 200653c <rtems_termios_baud_to_index+0x64>
2006594: 90 10 20 0b mov 0xb, %o0
2006598: 80 a0 60 0b cmp %g1, 0xb
200659c: 0a bf ff e8 bcs 200653c <rtems_termios_baud_to_index+0x64>
20065a0: 90 10 20 0a mov 0xa, %o0
20065a4: 80 a0 60 0c cmp %g1, 0xc
20065a8: 02 bf ff e5 be 200653c <rtems_termios_baud_to_index+0x64>
20065ac: 90 10 20 0c mov 0xc, %o0
20065b0: 80 a0 60 0d cmp %g1, 0xd
20065b4: 12 80 00 1b bne 2006620 <rtems_termios_baud_to_index+0x148><== NEVER TAKEN
20065b8: 90 10 20 0d mov 0xd, %o0
20065bc: 81 c3 e0 08 retl
20065c0: 01 00 00 00 nop
20065c4: 86 10 a0 02 or %g2, 2, %g3
20065c8: 80 a0 40 03 cmp %g1, %g3
20065cc: 02 bf ff dc be 200653c <rtems_termios_baud_to_index+0x64>
20065d0: 90 10 20 11 mov 0x11, %o0
20065d4: 80 a0 40 03 cmp %g1, %g3
20065d8: 38 80 00 0b bgu,a 2006604 <rtems_termios_baud_to_index+0x12c>
20065dc: 86 10 a0 03 or %g2, 3, %g3
20065e0: 80 a0 60 0f cmp %g1, 0xf
20065e4: 02 bf ff d6 be 200653c <rtems_termios_baud_to_index+0x64>
20065e8: 90 10 20 0f mov 0xf, %o0
20065ec: 84 10 a0 01 or %g2, 1, %g2
20065f0: 80 a0 40 02 cmp %g1, %g2
20065f4: 12 80 00 0b bne 2006620 <rtems_termios_baud_to_index+0x148><== NEVER TAKEN
20065f8: 90 10 20 10 mov 0x10, %o0
20065fc: 81 c3 e0 08 retl
2006600: 01 00 00 00 nop
2006604: 80 a0 40 03 cmp %g1, %g3
2006608: 02 bf ff cd be 200653c <rtems_termios_baud_to_index+0x64>
200660c: 90 10 20 12 mov 0x12, %o0
2006610: 84 10 a0 04 or %g2, 4, %g2
2006614: 80 a0 40 02 cmp %g1, %g2
2006618: 02 bf ff c9 be 200653c <rtems_termios_baud_to_index+0x64>
200661c: 90 10 20 13 mov 0x13, %o0
case B38400: baud_index = 15; break;
case B57600: baud_index = 16; break;
case B115200: baud_index = 17; break;
case B230400: baud_index = 18; break;
case B460800: baud_index = 19; break;
default: baud_index = -1; break;
2006620: 90 10 3f ff mov -1, %o0
}
return baud_index;
}
2006624: 81 c3 e0 08 retl
02005854 <rtems_termios_close>:
}
}
rtems_status_code
rtems_termios_close (void *arg)
{
2005854: 9d e3 bf a0 save %sp, -96, %sp
rtems_libio_open_close_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
2005858: c2 06 00 00 ld [ %i0 ], %g1
rtems_status_code sc;
sc = rtems_semaphore_obtain(
200585c: 92 10 20 00 clr %o1
rtems_status_code
rtems_termios_close (void *arg)
{
rtems_libio_open_close_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
2005860: fa 00 60 30 ld [ %g1 + 0x30 ], %i5
rtems_status_code sc;
sc = rtems_semaphore_obtain(
2005864: 03 00 80 76 sethi %hi(0x201d800), %g1
2005868: d0 00 61 88 ld [ %g1 + 0x188 ], %o0 ! 201d988 <rtems_termios_ttyMutex>
200586c: 40 00 08 1e call 20078e4 <rtems_semaphore_obtain>
2005870: 94 10 20 00 clr %o2
rtems_termios_ttyMutex, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
2005874: 80 a2 20 00 cmp %o0, 0
2005878: 22 80 00 03 be,a 2005884 <rtems_termios_close+0x30> <== ALWAYS TAKEN
200587c: c2 07 60 08 ld [ %i5 + 8 ], %g1
2005880: 30 80 00 30 b,a 2005940 <rtems_termios_close+0xec> <== NOT EXECUTED
rtems_fatal_error_occurred (sc);
if (--tty->refcount == 0) {
2005884: 82 00 7f ff add %g1, -1, %g1
2005888: 80 a0 60 00 cmp %g1, 0
200588c: 12 80 00 64 bne 2005a1c <rtems_termios_close+0x1c8>
2005890: c2 27 60 08 st %g1, [ %i5 + 8 ]
if (rtems_termios_linesw[tty->t_line].l_close != NULL) {
2005894: c4 07 60 cc ld [ %i5 + 0xcc ], %g2
2005898: 03 00 80 75 sethi %hi(0x201d400), %g1
200589c: 85 28 a0 05 sll %g2, 5, %g2
20058a0: 82 10 61 d4 or %g1, 0x1d4, %g1
20058a4: 82 00 40 02 add %g1, %g2, %g1
20058a8: c2 00 60 04 ld [ %g1 + 4 ], %g1
20058ac: 80 a0 60 00 cmp %g1, 0
20058b0: 22 80 00 06 be,a 20058c8 <rtems_termios_close+0x74>
20058b4: d0 07 60 18 ld [ %i5 + 0x18 ], %o0
/*
* call discipline-specific close
*/
sc = rtems_termios_linesw[tty->t_line].l_close(tty);
20058b8: 9f c0 40 00 call %g1
20058bc: 90 10 00 1d mov %i5, %o0
}
drainOutput (tty);
rtems_semaphore_release (tty->osem);
}
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
20058c0: 10 80 00 11 b 2005904 <rtems_termios_close+0xb0>
20058c4: c2 07 60 b4 ld [ %i5 + 0xb4 ], %g1
sc = rtems_termios_linesw[tty->t_line].l_close(tty);
} else {
/*
* default: just flush output buffer
*/
sc = rtems_semaphore_obtain(tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
20058c8: 92 10 20 00 clr %o1
20058cc: 40 00 08 06 call 20078e4 <rtems_semaphore_obtain>
20058d0: 94 10 20 00 clr %o2
if (sc != RTEMS_SUCCESSFUL) {
20058d4: 80 a2 20 00 cmp %o0, 0
20058d8: 22 80 00 03 be,a 20058e4 <rtems_termios_close+0x90> <== ALWAYS TAKEN
20058dc: c2 07 60 b4 ld [ %i5 + 0xb4 ], %g1
20058e0: 30 80 00 18 b,a 2005940 <rtems_termios_close+0xec> <== NOT EXECUTED
drainOutput (struct rtems_termios_tty *tty)
{
rtems_interrupt_level level;
rtems_status_code sc;
if (tty->device.outputUsesInterrupts != TERMIOS_POLLED) {
20058e4: 80 a0 60 00 cmp %g1, 0
20058e8: 02 80 00 04 be 20058f8 <rtems_termios_close+0xa4>
20058ec: 01 00 00 00 nop
20058f0: 7f ff fe ad call 20053a4 <drainOutput.part.0>
20058f4: 90 10 00 1d mov %i5, %o0
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);
20058f8: 40 00 08 45 call 2007a0c <rtems_semaphore_release>
20058fc: d0 07 60 18 ld [ %i5 + 0x18 ], %o0
}
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
2005900: c2 07 60 b4 ld [ %i5 + 0xb4 ], %g1
2005904: 80 a0 60 02 cmp %g1, 2
2005908: 32 80 00 10 bne,a 2005948 <rtems_termios_close+0xf4>
200590c: c2 07 60 9c ld [ %i5 + 0x9c ], %g1
/*
* send "terminate" to I/O tasks
*/
sc = rtems_event_send( tty->rxTaskId, TERMIOS_RX_TERMINATE_EVENT );
2005910: d0 07 60 c4 ld [ %i5 + 0xc4 ], %o0
2005914: 40 00 06 bd call 2007408 <rtems_event_send>
2005918: 92 10 20 01 mov 1, %o1
if (sc != RTEMS_SUCCESSFUL)
200591c: 80 a2 20 00 cmp %o0, 0
2005920: 22 80 00 03 be,a 200592c <rtems_termios_close+0xd8> <== ALWAYS TAKEN
2005924: d0 07 60 c8 ld [ %i5 + 0xc8 ], %o0
2005928: 30 80 00 06 b,a 2005940 <rtems_termios_close+0xec> <== NOT EXECUTED
rtems_fatal_error_occurred (sc);
sc = rtems_event_send( tty->txTaskId, TERMIOS_TX_TERMINATE_EVENT );
200592c: 40 00 06 b7 call 2007408 <rtems_event_send>
2005930: 92 10 20 01 mov 1, %o1
if (sc != RTEMS_SUCCESSFUL)
2005934: 80 a2 20 00 cmp %o0, 0
2005938: 22 80 00 04 be,a 2005948 <rtems_termios_close+0xf4> <== ALWAYS TAKEN
200593c: c2 07 60 9c ld [ %i5 + 0x9c ], %g1
rtems_fatal_error_occurred (sc);
2005940: 40 00 09 ae call 2007ff8 <rtems_fatal_error_occurred> <== NOT EXECUTED
2005944: 01 00 00 00 nop <== NOT EXECUTED
}
if (tty->device.lastClose)
2005948: 80 a0 60 00 cmp %g1, 0
200594c: 22 80 00 07 be,a 2005968 <rtems_termios_close+0x114> <== ALWAYS TAKEN
2005950: c4 07 40 00 ld [ %i5 ], %g2
(*tty->device.lastClose)(tty->major, tty->minor, arg);
2005954: d0 07 60 0c ld [ %i5 + 0xc ], %o0 <== NOT EXECUTED
2005958: d2 07 60 10 ld [ %i5 + 0x10 ], %o1 <== NOT EXECUTED
200595c: 9f c0 40 00 call %g1 <== NOT EXECUTED
2005960: 94 10 00 18 mov %i0, %o2 <== NOT EXECUTED
if (tty->forw == NULL) {
2005964: c4 07 40 00 ld [ %i5 ], %g2 <== NOT EXECUTED
2005968: 80 a0 a0 00 cmp %g2, 0
200596c: 12 80 00 08 bne 200598c <rtems_termios_close+0x138>
2005970: c2 07 60 04 ld [ %i5 + 4 ], %g1
rtems_termios_ttyTail = tty->back;
2005974: 05 00 80 76 sethi %hi(0x201d800), %g2
if ( rtems_termios_ttyTail != NULL ) {
2005978: 80 a0 60 00 cmp %g1, 0
200597c: 02 80 00 05 be 2005990 <rtems_termios_close+0x13c> <== ALWAYS TAKEN
2005980: c2 20 a1 8c st %g1, [ %g2 + 0x18c ]
rtems_termios_ttyTail->forw = NULL;
2005984: 10 80 00 03 b 2005990 <rtems_termios_close+0x13c> <== NOT EXECUTED
2005988: c0 20 40 00 clr [ %g1 ] <== NOT EXECUTED
}
} else {
tty->forw->back = tty->back;
200598c: c2 20 a0 04 st %g1, [ %g2 + 4 ]
}
if (tty->back == NULL) {
2005990: c4 07 60 04 ld [ %i5 + 4 ], %g2
2005994: 80 a0 a0 00 cmp %g2, 0
2005998: 12 80 00 08 bne 20059b8 <rtems_termios_close+0x164> <== NEVER TAKEN
200599c: c2 07 40 00 ld [ %i5 ], %g1
rtems_termios_ttyHead = tty->forw;
20059a0: 05 00 80 76 sethi %hi(0x201d800), %g2
if ( rtems_termios_ttyHead != NULL ) {
20059a4: 80 a0 60 00 cmp %g1, 0
20059a8: 02 80 00 05 be 20059bc <rtems_termios_close+0x168>
20059ac: c2 20 a1 90 st %g1, [ %g2 + 0x190 ]
rtems_termios_ttyHead->back = NULL;
20059b0: 10 80 00 03 b 20059bc <rtems_termios_close+0x168>
20059b4: c0 20 60 04 clr [ %g1 + 4 ]
}
} else {
tty->back->forw = tty->forw;
20059b8: c2 20 80 00 st %g1, [ %g2 ] <== NOT EXECUTED
}
rtems_semaphore_delete (tty->isem);
20059bc: 40 00 07 9b call 2007828 <rtems_semaphore_delete>
20059c0: d0 07 60 14 ld [ %i5 + 0x14 ], %o0
rtems_semaphore_delete (tty->osem);
20059c4: 40 00 07 99 call 2007828 <rtems_semaphore_delete>
20059c8: d0 07 60 18 ld [ %i5 + 0x18 ], %o0
rtems_semaphore_delete (tty->rawOutBuf.Semaphore);
20059cc: 40 00 07 97 call 2007828 <rtems_semaphore_delete>
20059d0: d0 07 60 8c ld [ %i5 + 0x8c ], %o0
if ((tty->device.pollRead == NULL) ||
20059d4: c2 07 60 a0 ld [ %i5 + 0xa0 ], %g1
20059d8: 80 a0 60 00 cmp %g1, 0
20059dc: 02 80 00 06 be 20059f4 <rtems_termios_close+0x1a0>
20059e0: 01 00 00 00 nop
20059e4: c2 07 60 b4 ld [ %i5 + 0xb4 ], %g1
20059e8: 80 a0 60 02 cmp %g1, 2
20059ec: 12 80 00 04 bne 20059fc <rtems_termios_close+0x1a8>
20059f0: 01 00 00 00 nop
(tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN))
rtems_semaphore_delete (tty->rawInBuf.Semaphore);
20059f4: 40 00 07 8d call 2007828 <rtems_semaphore_delete>
20059f8: d0 07 60 68 ld [ %i5 + 0x68 ], %o0
free (tty->rawInBuf.theBuf);
20059fc: 7f ff f7 78 call 20037dc <free>
2005a00: d0 07 60 58 ld [ %i5 + 0x58 ], %o0
free (tty->rawOutBuf.theBuf);
2005a04: 7f ff f7 76 call 20037dc <free>
2005a08: d0 07 60 7c ld [ %i5 + 0x7c ], %o0
free (tty->cbuf);
2005a0c: 7f ff f7 74 call 20037dc <free>
2005a10: d0 07 60 1c ld [ %i5 + 0x1c ], %o0
free (tty);
2005a14: 7f ff f7 72 call 20037dc <free>
2005a18: 90 10 00 1d mov %i5, %o0
}
rtems_semaphore_release (rtems_termios_ttyMutex);
2005a1c: 03 00 80 76 sethi %hi(0x201d800), %g1
2005a20: d0 00 61 88 ld [ %g1 + 0x188 ], %o0 ! 201d988 <rtems_termios_ttyMutex>
2005a24: 40 00 07 fa call 2007a0c <rtems_semaphore_release>
2005a28: b0 10 20 00 clr %i0
return RTEMS_SUCCESSFUL;
}
2005a2c: 81 c7 e0 08 ret
2005a30: 81 e8 00 00 restore
02006d98 <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)
{
2006d98: 9d e3 bf a0 save %sp, -96, %sp
rtems_status_code sc;
/*
* sum up character count already sent
*/
tty->t_dqlen += len;
2006d9c: c2 06 20 90 ld [ %i0 + 0x90 ], %g1
* for each transmitted character.
* It returns number of characters left to transmit
*/
int
rtems_termios_dequeue_characters (void *ttyp, int len)
{
2006da0: 90 10 00 18 mov %i0, %o0
rtems_status_code sc;
/*
* sum up character count already sent
*/
tty->t_dqlen += len;
2006da4: b2 00 40 19 add %g1, %i1, %i1
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
2006da8: c2 06 20 b4 ld [ %i0 + 0xb4 ], %g1
2006dac: 80 a0 60 02 cmp %g1, 2
2006db0: 12 80 00 0a bne 2006dd8 <rtems_termios_dequeue_characters+0x40>
2006db4: f2 26 20 90 st %i1, [ %i0 + 0x90 ]
/*
* send wake up to transmitter task
*/
sc = rtems_event_send(tty->txTaskId, TERMIOS_TX_START_EVENT);
2006db8: d0 06 20 c8 ld [ %i0 + 0xc8 ], %o0
2006dbc: 40 00 01 93 call 2007408 <rtems_event_send>
2006dc0: 92 10 20 02 mov 2, %o1
if (sc != RTEMS_SUCCESSFUL)
2006dc4: 80 a2 20 00 cmp %o0, 0
2006dc8: 02 80 00 11 be 2006e0c <rtems_termios_dequeue_characters+0x74><== ALWAYS TAKEN
2006dcc: b0 10 20 00 clr %i0
rtems_fatal_error_occurred (sc);
2006dd0: 40 00 04 8a call 2007ff8 <rtems_fatal_error_occurred> <== NOT EXECUTED
2006dd4: 01 00 00 00 nop <== NOT EXECUTED
return 0; /* nothing to output in IRQ... */
}
if (tty->t_line == PPPDISC ) {
2006dd8: c2 06 20 cc ld [ %i0 + 0xcc ], %g1
2006ddc: 80 a0 60 05 cmp %g1, 5
2006de0: 12 80 00 09 bne 2006e04 <rtems_termios_dequeue_characters+0x6c>
2006de4: 03 00 80 75 sethi %hi(0x201d400), %g1
/*
* call any line discipline start function
*/
if (rtems_termios_linesw[tty->t_line].l_start != NULL) {
2006de8: c2 00 62 88 ld [ %g1 + 0x288 ], %g1 ! 201d688 <rtems_termios_linesw+0xb4>
2006dec: 80 a0 60 00 cmp %g1, 0
2006df0: 02 80 00 07 be 2006e0c <rtems_termios_dequeue_characters+0x74><== NEVER TAKEN
2006df4: b0 10 20 00 clr %i0
rtems_termios_linesw[tty->t_line].l_start(tty);
2006df8: 9f c0 40 00 call %g1
2006dfc: 01 00 00 00 nop
2006e00: 30 80 00 03 b,a 2006e0c <rtems_termios_dequeue_characters+0x74>
}
return 0; /* nothing to output in IRQ... */
}
return rtems_termios_refill_transmitter(tty);
2006e04: 7f ff f8 d3 call 2005150 <rtems_termios_refill_transmitter>
2006e08: 81 e8 00 00 restore
}
2006e0c: 81 c7 e0 08 ret
2006e10: 81 e8 00 00 restore
02006a30 <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)
{
2006a30: 9d e3 bf a0 save %sp, -96, %sp
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) {
2006a34: c4 06 20 cc ld [ %i0 + 0xcc ], %g2
2006a38: 03 00 80 75 sethi %hi(0x201d400), %g1
2006a3c: 85 28 a0 05 sll %g2, 5, %g2
2006a40: 82 10 61 d4 or %g1, 0x1d4, %g1
2006a44: 84 00 40 02 add %g1, %g2, %g2
2006a48: c4 00 a0 10 ld [ %g2 + 0x10 ], %g2
* 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)
{
2006a4c: ba 10 00 18 mov %i0, %i5
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);
2006a50: b8 10 00 01 mov %g1, %i4
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) {
2006a54: 80 a0 a0 00 cmp %g2, 0
2006a58: 12 80 00 10 bne 2006a98 <rtems_termios_enqueue_raw_characters+0x68>
2006a5c: b4 06 40 1a add %i1, %i2, %i2
* 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)
2006a60: b6 10 20 00 clr %i3
2006a64: b0 10 20 00 clr %i0
/*
* 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);
2006a68: a2 07 60 30 add %i5, 0x30, %l1
(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,
(void *)&(tty->termios.c_cc[VSTOP]), 1);
2006a6c: 10 80 00 a5 b 2006d00 <rtems_termios_enqueue_raw_characters+0x2d0>
2006a70: a4 07 60 4a add %i5, 0x4a, %l2
bool flow_rcv = false; /* true, if flow control char received */
rtems_interrupt_level level;
if (rtems_termios_linesw[tty->t_line].l_rint != NULL) {
while (len--) {
c = *buf++;
2006a74: d0 0e 40 00 ldub [ %i1 ], %o0
rtems_termios_linesw[tty->t_line].l_rint(c,tty);
2006a78: 83 28 60 05 sll %g1, 5, %g1
2006a7c: 82 07 00 01 add %i4, %g1, %g1
2006a80: c2 00 60 10 ld [ %g1 + 0x10 ], %g1
2006a84: 91 2a 20 18 sll %o0, 0x18, %o0
bool flow_rcv = false; /* true, if flow control char received */
rtems_interrupt_level level;
if (rtems_termios_linesw[tty->t_line].l_rint != NULL) {
while (len--) {
c = *buf++;
2006a88: b2 06 60 01 inc %i1
rtems_termios_linesw[tty->t_line].l_rint(c,tty);
2006a8c: 91 3a 20 18 sra %o0, 0x18, %o0
2006a90: 9f c0 40 00 call %g1
2006a94: 92 10 00 1d mov %i5, %o1
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--) {
2006a98: 80 a6 40 1a cmp %i1, %i2
2006a9c: 32 bf ff f6 bne,a 2006a74 <rtems_termios_enqueue_raw_characters+0x44>
2006aa0: c2 07 60 cc ld [ %i5 + 0xcc ], %g1
}
/*
* check to see if rcv wakeup callback was set
*/
if (( !tty->tty_rcvwakeup ) && ( tty->tty_rcv.sw_pfn != NULL )) {
2006aa4: c2 07 60 e4 ld [ %i5 + 0xe4 ], %g1
2006aa8: 80 a0 60 00 cmp %g1, 0
2006aac: 12 80 00 0b bne 2006ad8 <rtems_termios_enqueue_raw_characters+0xa8><== NEVER TAKEN
2006ab0: b0 10 20 00 clr %i0
2006ab4: c2 07 60 dc ld [ %i5 + 0xdc ], %g1
2006ab8: 80 a0 60 00 cmp %g1, 0
2006abc: 02 80 00 9b be 2006d28 <rtems_termios_enqueue_raw_characters+0x2f8>
2006ac0: 01 00 00 00 nop
(*tty->tty_rcv.sw_pfn)(&tty->termios, tty->tty_rcv.sw_arg);
2006ac4: d2 07 60 e0 ld [ %i5 + 0xe0 ], %o1
2006ac8: 9f c0 40 00 call %g1
2006acc: 90 07 60 30 add %i5, 0x30, %o0
tty->tty_rcvwakeup = 1;
2006ad0: 82 10 20 01 mov 1, %g1
2006ad4: c2 27 60 e4 st %g1, [ %i5 + 0xe4 ]
2006ad8: 81 c7 e0 08 ret
2006adc: 81 e8 00 00 restore
while (len--) {
c = *buf++;
/* FIXME: implement IXANY: any character restarts output */
/* if incoming XON/XOFF controls outgoing stream: */
if (tty->flow_ctrl & FL_MDXON) {
2006ae0: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1
}
return 0;
}
while (len--) {
c = *buf++;
2006ae4: e0 0e 40 00 ldub [ %i1 ], %l0
/* FIXME: implement IXANY: any character restarts output */
/* if incoming XON/XOFF controls outgoing stream: */
if (tty->flow_ctrl & FL_MDXON) {
2006ae8: 80 88 62 00 btst 0x200, %g1
2006aec: 02 80 00 17 be 2006b48 <rtems_termios_enqueue_raw_characters+0x118>
2006af0: b2 06 60 01 inc %i1
/* if received char is V_STOP and V_START (both are equal value) */
if (c == tty->termios.c_cc[VSTOP]) {
2006af4: c4 0f 60 4a ldub [ %i5 + 0x4a ], %g2
2006af8: 83 2c 20 18 sll %l0, 0x18, %g1
2006afc: 83 38 60 18 sra %g1, 0x18, %g1
2006b00: 80 a0 40 02 cmp %g1, %g2
2006b04: c4 0f 60 49 ldub [ %i5 + 0x49 ], %g2
2006b08: 12 80 00 0a bne 2006b30 <rtems_termios_enqueue_raw_characters+0x100>
2006b0c: 84 08 a0 ff and %g2, 0xff, %g2
if (c == tty->termios.c_cc[VSTART]) {
2006b10: 80 a0 40 02 cmp %g1, %g2
/* received VSTOP and VSTART==VSTOP? */
/* then toggle "stop output" status */
tty->flow_ctrl = tty->flow_ctrl ^ FL_ORCVXOF;
2006b14: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1
/* 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]) {
2006b18: 32 80 00 03 bne,a 2006b24 <rtems_termios_enqueue_raw_characters+0xf4><== ALWAYS TAKEN
2006b1c: 82 10 60 10 or %g1, 0x10, %g1
2006b20: 82 18 60 10 xor %g1, 0x10, %g1 <== NOT EXECUTED
tty->flow_ctrl = tty->flow_ctrl ^ FL_ORCVXOF;
}
else {
/* VSTOP received (other code than VSTART) */
/* stop output */
tty->flow_ctrl |= FL_ORCVXOF;
2006b24: c2 27 60 b8 st %g1, [ %i5 + 0xb8 ]
* 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)
{
2006b28: 10 80 00 0b b 2006b54 <rtems_termios_enqueue_raw_characters+0x124>
2006b2c: b6 10 20 01 mov 1, %i3
/* stop output */
tty->flow_ctrl |= FL_ORCVXOF;
}
flow_rcv = true;
}
else if (c == tty->termios.c_cc[VSTART]) {
2006b30: 80 a0 40 02 cmp %g1, %g2
2006b34: 12 80 00 06 bne 2006b4c <rtems_termios_enqueue_raw_characters+0x11c><== ALWAYS TAKEN
2006b38: 80 8e e0 ff btst 0xff, %i3
/* VSTART received */
/* restart output */
tty->flow_ctrl &= ~FL_ORCVXOF;
2006b3c: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1 <== NOT EXECUTED
2006b40: 10 bf ff f9 b 2006b24 <rtems_termios_enqueue_raw_characters+0xf4><== NOT EXECUTED
2006b44: 82 08 7f ef and %g1, -17, %g1 <== NOT EXECUTED
flow_rcv = true;
}
}
if (flow_rcv) {
2006b48: 80 8e e0 ff btst 0xff, %i3
2006b4c: 02 80 00 1c be 2006bbc <rtems_termios_enqueue_raw_characters+0x18c><== ALWAYS TAKEN
2006b50: 01 00 00 00 nop
/* restart output according to FL_ORCVXOF flag */
if ((tty->flow_ctrl & (FL_ORCVXOF | FL_OSTOP)) == FL_OSTOP) {
2006b54: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1
2006b58: 82 08 60 30 and %g1, 0x30, %g1
2006b5c: 80 a0 60 20 cmp %g1, 0x20
2006b60: 12 80 00 69 bne 2006d04 <rtems_termios_enqueue_raw_characters+0x2d4><== ALWAYS TAKEN
2006b64: 80 a6 40 1a cmp %i1, %i2
/* disable interrupts */
rtems_interrupt_disable(level);
2006b68: 7f ff ee d7 call 20026c4 <sparc_disable_interrupts> <== NOT EXECUTED
2006b6c: 01 00 00 00 nop <== NOT EXECUTED
2006b70: b8 10 00 08 mov %o0, %i4 <== NOT EXECUTED
tty->flow_ctrl &= ~FL_OSTOP;
2006b74: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1 <== NOT EXECUTED
2006b78: 82 08 7f df and %g1, -33, %g1 <== NOT EXECUTED
2006b7c: c2 27 60 b8 st %g1, [ %i5 + 0xb8 ] <== NOT EXECUTED
/* check for chars in output buffer (or rob_state?) */
if (tty->rawOutBufState != rob_idle) {
2006b80: c2 07 60 94 ld [ %i5 + 0x94 ], %g1 <== NOT EXECUTED
2006b84: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
2006b88: 02 80 00 09 be 2006bac <rtems_termios_enqueue_raw_characters+0x17c><== NOT EXECUTED
2006b8c: 01 00 00 00 nop <== NOT EXECUTED
/* if chars available, call write function... */
(*tty->device.write)(
tty->minor, &tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail], 1);
2006b90: c4 07 60 84 ld [ %i5 + 0x84 ], %g2 <== 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)(
2006b94: d2 07 60 7c ld [ %i5 + 0x7c ], %o1 <== NOT EXECUTED
2006b98: c2 07 60 a4 ld [ %i5 + 0xa4 ], %g1 <== NOT EXECUTED
2006b9c: d0 07 60 10 ld [ %i5 + 0x10 ], %o0 <== NOT EXECUTED
2006ba0: 92 02 40 02 add %o1, %g2, %o1 <== NOT EXECUTED
2006ba4: 9f c0 40 00 call %g1 <== NOT EXECUTED
2006ba8: 94 10 20 01 mov 1, %o2 <== NOT EXECUTED
tty->minor, &tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail], 1);
}
/* reenable interrupts */
rtems_interrupt_enable(level);
2006bac: 7f ff ee ca call 20026d4 <sparc_enable_interrupts> <== NOT EXECUTED
2006bb0: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
tty->tty_rcvwakeup = 1;
}
return 0;
}
while (len--) {
2006bb4: 10 80 00 54 b 2006d04 <rtems_termios_enqueue_raw_characters+0x2d4><== NOT EXECUTED
2006bb8: 80 a6 40 1a cmp %i1, %i2 <== NOT EXECUTED
}
/* reenable interrupts */
rtems_interrupt_enable(level);
}
} else {
newTail = (tty->rawInBuf.Tail + 1) % tty->rawInBuf.Size;
2006bbc: d0 07 60 60 ld [ %i5 + 0x60 ], %o0
2006bc0: d2 07 60 64 ld [ %i5 + 0x64 ], %o1
2006bc4: 40 00 47 df call 2018b40 <.urem>
2006bc8: 90 02 20 01 inc %o0
/* if chars_in_buffer > highwater */
rtems_interrupt_disable(level);
2006bcc: 7f ff ee be call 20026c4 <sparc_disable_interrupts>
2006bd0: b8 10 00 08 mov %o0, %i4
2006bd4: a6 10 00 08 mov %o0, %l3
if ((((newTail - tty->rawInBuf.Head + tty->rawInBuf.Size)
2006bd8: c2 07 60 5c ld [ %i5 + 0x5c ], %g1
2006bdc: d0 07 60 64 ld [ %i5 + 0x64 ], %o0
% tty->rawInBuf.Size) > tty->highwater) &&
2006be0: d2 07 60 64 ld [ %i5 + 0x64 ], %o1
}
} 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)
2006be4: 90 22 00 01 sub %o0, %g1, %o0
% tty->rawInBuf.Size) > tty->highwater) &&
2006be8: 40 00 47 d6 call 2018b40 <.urem>
2006bec: 90 02 00 1c add %o0, %i4, %o0
}
} 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)
2006bf0: c2 07 60 c0 ld [ %i5 + 0xc0 ], %g1
2006bf4: 80 a2 00 01 cmp %o0, %g1
2006bf8: 08 80 00 2b bleu 2006ca4 <rtems_termios_enqueue_raw_characters+0x274><== ALWAYS TAKEN
2006bfc: 01 00 00 00 nop
% tty->rawInBuf.Size) > tty->highwater) &&
!(tty->flow_ctrl & FL_IREQXOF)) {
2006c00: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1 <== 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) &&
2006c04: 80 88 60 01 btst 1, %g1 <== NOT EXECUTED
2006c08: 12 80 00 27 bne 2006ca4 <rtems_termios_enqueue_raw_characters+0x274><== NOT EXECUTED
2006c0c: 01 00 00 00 nop <== NOT EXECUTED
!(tty->flow_ctrl & FL_IREQXOF)) {
/* incoming data stream should be stopped */
tty->flow_ctrl |= FL_IREQXOF;
2006c10: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1 <== NOT EXECUTED
2006c14: 82 10 60 01 or %g1, 1, %g1 <== NOT EXECUTED
2006c18: c2 27 60 b8 st %g1, [ %i5 + 0xb8 ] <== NOT EXECUTED
if ((tty->flow_ctrl & (FL_MDXOF | FL_ISNTXOF))
2006c1c: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1 <== NOT EXECUTED
2006c20: 82 08 64 02 and %g1, 0x402, %g1 <== NOT EXECUTED
2006c24: 80 a0 64 00 cmp %g1, 0x400 <== NOT EXECUTED
== (FL_MDXOF ) ) {
if ((tty->flow_ctrl & FL_OSTOP) ||
2006c28: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1 <== 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))
2006c2c: 32 80 00 12 bne,a 2006c74 <rtems_termios_enqueue_raw_characters+0x244><== NOT EXECUTED
2006c30: 82 08 61 04 and %g1, 0x104, %g1 <== NOT EXECUTED
== (FL_MDXOF ) ) {
if ((tty->flow_ctrl & FL_OSTOP) ||
2006c34: 80 88 60 20 btst 0x20, %g1 <== NOT EXECUTED
2006c38: 12 80 00 06 bne 2006c50 <rtems_termios_enqueue_raw_characters+0x220><== NOT EXECUTED
2006c3c: 01 00 00 00 nop <== NOT EXECUTED
2006c40: c2 07 60 94 ld [ %i5 + 0x94 ], %g1 <== NOT EXECUTED
2006c44: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
2006c48: 12 80 00 17 bne 2006ca4 <rtems_termios_enqueue_raw_characters+0x274><== NOT EXECUTED
2006c4c: 01 00 00 00 nop <== 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;
2006c50: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1 <== NOT EXECUTED
(*tty->device.write)(tty->minor,
2006c54: d0 07 60 10 ld [ %i5 + 0x10 ], %o0 <== 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;
2006c58: 82 10 60 02 or %g1, 2, %g1 <== NOT EXECUTED
2006c5c: c2 27 60 b8 st %g1, [ %i5 + 0xb8 ] <== NOT EXECUTED
(*tty->device.write)(tty->minor,
2006c60: c2 07 60 a4 ld [ %i5 + 0xa4 ], %g1 <== NOT EXECUTED
2006c64: 92 10 00 12 mov %l2, %o1 <== NOT EXECUTED
2006c68: 9f c0 40 00 call %g1 <== NOT EXECUTED
2006c6c: 94 10 20 01 mov 1, %o2 <== NOT EXECUTED
2006c70: 30 80 00 0d b,a 2006ca4 <rtems_termios_enqueue_raw_characters+0x274><== NOT EXECUTED
(void *)&(tty->termios.c_cc[VSTOP]), 1);
}
} else if ((tty->flow_ctrl & (FL_MDRTS | FL_IRTSOFF)) == (FL_MDRTS) ) {
2006c74: 80 a0 61 00 cmp %g1, 0x100 <== NOT EXECUTED
2006c78: 12 80 00 0b bne 2006ca4 <rtems_termios_enqueue_raw_characters+0x274><== NOT EXECUTED
2006c7c: 01 00 00 00 nop <== NOT EXECUTED
tty->flow_ctrl |= FL_IRTSOFF;
2006c80: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1 <== NOT EXECUTED
2006c84: 82 10 60 04 or %g1, 4, %g1 <== NOT EXECUTED
2006c88: c2 27 60 b8 st %g1, [ %i5 + 0xb8 ] <== NOT EXECUTED
/* deactivate RTS line */
if (tty->device.stopRemoteTx != NULL) {
2006c8c: c2 07 60 ac ld [ %i5 + 0xac ], %g1 <== NOT EXECUTED
2006c90: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
2006c94: 02 80 00 04 be 2006ca4 <rtems_termios_enqueue_raw_characters+0x274><== NOT EXECUTED
2006c98: 01 00 00 00 nop <== NOT EXECUTED
tty->device.stopRemoteTx(tty->minor);
2006c9c: 9f c0 40 00 call %g1 <== NOT EXECUTED
2006ca0: d0 07 60 10 ld [ %i5 + 0x10 ], %o0 <== NOT EXECUTED
}
}
}
/* reenable interrupts */
rtems_interrupt_enable(level);
2006ca4: 7f ff ee 8c call 20026d4 <sparc_enable_interrupts>
2006ca8: 90 10 00 13 mov %l3, %o0
if (newTail == tty->rawInBuf.Head) {
2006cac: c2 07 60 5c ld [ %i5 + 0x5c ], %g1
2006cb0: 80 a7 00 01 cmp %i4, %g1
2006cb4: 32 80 00 04 bne,a 2006cc4 <rtems_termios_enqueue_raw_characters+0x294><== ALWAYS TAKEN
2006cb8: c2 07 60 58 ld [ %i5 + 0x58 ], %g1
dropped++;
2006cbc: 10 80 00 11 b 2006d00 <rtems_termios_enqueue_raw_characters+0x2d0><== NOT EXECUTED
2006cc0: b0 06 20 01 inc %i0 <== NOT EXECUTED
} else {
tty->rawInBuf.theBuf[newTail] = c;
2006cc4: e0 28 40 1c stb %l0, [ %g1 + %i4 ]
tty->rawInBuf.Tail = newTail;
/*
* check to see if rcv wakeup callback was set
*/
if (( !tty->tty_rcvwakeup ) && ( tty->tty_rcv.sw_pfn != NULL )) {
2006cc8: c2 07 60 e4 ld [ %i5 + 0xe4 ], %g1
if (newTail == tty->rawInBuf.Head) {
dropped++;
} else {
tty->rawInBuf.theBuf[newTail] = c;
tty->rawInBuf.Tail = newTail;
2006ccc: f8 27 60 60 st %i4, [ %i5 + 0x60 ]
/*
* check to see if rcv wakeup callback was set
*/
if (( !tty->tty_rcvwakeup ) && ( tty->tty_rcv.sw_pfn != NULL )) {
2006cd0: 80 a0 60 00 cmp %g1, 0
2006cd4: 12 80 00 0c bne 2006d04 <rtems_termios_enqueue_raw_characters+0x2d4><== NEVER TAKEN
2006cd8: 80 a6 40 1a cmp %i1, %i2
2006cdc: c2 07 60 dc ld [ %i5 + 0xdc ], %g1
2006ce0: 80 a0 60 00 cmp %g1, 0
2006ce4: 02 80 00 08 be 2006d04 <rtems_termios_enqueue_raw_characters+0x2d4><== ALWAYS TAKEN
2006ce8: 80 a6 40 1a cmp %i1, %i2
(*tty->tty_rcv.sw_pfn)(&tty->termios, tty->tty_rcv.sw_arg);
2006cec: d2 07 60 e0 ld [ %i5 + 0xe0 ], %o1 <== NOT EXECUTED
2006cf0: 9f c0 40 00 call %g1 <== NOT EXECUTED
2006cf4: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED
tty->tty_rcvwakeup = 1;
2006cf8: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED
2006cfc: c2 27 60 e4 st %g1, [ %i5 + 0xe4 ] <== NOT EXECUTED
tty->tty_rcvwakeup = 1;
}
return 0;
}
while (len--) {
2006d00: 80 a6 40 1a cmp %i1, %i2
2006d04: 12 bf ff 77 bne 2006ae0 <rtems_termios_enqueue_raw_characters+0xb0>
2006d08: 01 00 00 00 nop
}
}
}
}
tty->rawInBufDropped += dropped;
2006d0c: c2 07 60 78 ld [ %i5 + 0x78 ], %g1
rtems_semaphore_release (tty->rawInBuf.Semaphore);
2006d10: d0 07 60 68 ld [ %i5 + 0x68 ], %o0
}
}
}
}
tty->rawInBufDropped += dropped;
2006d14: 82 00 40 18 add %g1, %i0, %g1
rtems_semaphore_release (tty->rawInBuf.Semaphore);
2006d18: 40 00 03 3d call 2007a0c <rtems_semaphore_release>
2006d1c: c2 27 60 78 st %g1, [ %i5 + 0x78 ]
return dropped;
2006d20: 81 c7 e0 08 ret
2006d24: 81 e8 00 00 restore
}
2006d28: 81 c7 e0 08 ret
2006d2c: 81 e8 00 00 restore
02005a54 <rtems_termios_ioctl>:
}
}
rtems_status_code
rtems_termios_ioctl (void *arg)
{
2005a54: 9d e3 bf a0 save %sp, -96, %sp
rtems_libio_ioctl_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
2005a58: c2 06 00 00 ld [ %i0 ], %g1
struct ttywakeup *wakeup = (struct ttywakeup *)args->buffer;
2005a5c: f6 06 20 08 ld [ %i0 + 8 ], %i3
rtems_status_code
rtems_termios_ioctl (void *arg)
{
rtems_libio_ioctl_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
2005a60: fa 00 60 30 ld [ %g1 + 0x30 ], %i5
}
}
rtems_status_code
rtems_termios_ioctl (void *arg)
{
2005a64: b8 10 00 18 mov %i0, %i4
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);
2005a68: d0 07 60 18 ld [ %i5 + 0x18 ], %o0
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;
2005a6c: c0 26 20 0c clr [ %i0 + 0xc ]
sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
2005a70: 92 10 20 00 clr %o1
2005a74: 40 00 07 9c call 20078e4 <rtems_semaphore_obtain>
2005a78: 94 10 20 00 clr %o2
if (sc != RTEMS_SUCCESSFUL) {
2005a7c: b0 92 20 00 orcc %o0, 0, %i0
2005a80: 12 80 00 f7 bne 2005e5c <rtems_termios_ioctl+0x408> <== NEVER TAKEN
2005a84: 01 00 00 00 nop
return sc;
}
switch (args->command) {
2005a88: c2 07 20 04 ld [ %i4 + 4 ], %g1
2005a8c: 80 a0 60 04 cmp %g1, 4
2005a90: 22 80 00 c5 be,a 2005da4 <rtems_termios_ioctl+0x350>
2005a94: c2 06 c0 00 ld [ %i3 ], %g1
2005a98: 18 80 00 0c bgu 2005ac8 <rtems_termios_ioctl+0x74>
2005a9c: 05 10 01 19 sethi %hi(0x40046400), %g2
2005aa0: 80 a0 60 02 cmp %g1, 2
2005aa4: 22 80 00 2e be,a 2005b5c <rtems_termios_ioctl+0x108>
2005aa8: d2 07 20 08 ld [ %i4 + 8 ], %o1
2005aac: 38 80 00 b4 bgu,a 2005d7c <rtems_termios_ioctl+0x328>
2005ab0: c2 07 60 b4 ld [ %i5 + 0xb4 ], %g1
2005ab4: 80 a0 60 01 cmp %g1, 1
2005ab8: 32 80 00 18 bne,a 2005b18 <rtems_termios_ioctl+0xc4> <== NEVER TAKEN
2005abc: c4 07 60 cc ld [ %i5 + 0xcc ], %g2 <== NOT EXECUTED
sc = RTEMS_INVALID_NUMBER;
}
break;
case RTEMS_IO_GET_ATTRIBUTES:
*(struct termios *)args->buffer = tty->termios;
2005ac0: 10 80 00 23 b 2005b4c <rtems_termios_ioctl+0xf8>
2005ac4: d0 07 20 08 ld [ %i4 + 8 ], %o0
args->ioctl_return = 0;
sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL) {
return sc;
}
switch (args->command) {
2005ac8: 84 10 a2 7f or %g2, 0x27f, %g2
2005acc: 80 a0 40 02 cmp %g1, %g2
2005ad0: 02 80 00 d4 be 2005e20 <rtems_termios_ioctl+0x3cc> <== NEVER TAKEN
2005ad4: 01 00 00 00 nop
2005ad8: 18 80 00 07 bgu 2005af4 <rtems_termios_ioctl+0xa0>
2005adc: 05 10 01 1d sethi %hi(0x40047400), %g2
2005ae0: 80 a0 60 05 cmp %g1, 5
2005ae4: 32 80 00 0d bne,a 2005b18 <rtems_termios_ioctl+0xc4>
2005ae8: c4 07 60 cc ld [ %i5 + 0xcc ], %g2
case RTEMS_IO_TCDRAIN:
drainOutput (tty);
break;
case RTEMS_IO_SNDWAKEUP:
tty->tty_snd = *wakeup;
2005aec: 10 80 00 aa b 2005d94 <rtems_termios_ioctl+0x340>
2005af0: c2 06 c0 00 ld [ %i3 ], %g1
args->ioctl_return = 0;
sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL) {
return sc;
}
switch (args->command) {
2005af4: 84 10 a0 1a or %g2, 0x1a, %g2
2005af8: 80 a0 40 02 cmp %g1, %g2
2005afc: 02 80 00 c6 be 2005e14 <rtems_termios_ioctl+0x3c0>
2005b00: c4 07 60 cc ld [ %i5 + 0xcc ], %g2
2005b04: 07 20 01 1d sethi %hi(0x80047400), %g3
2005b08: 86 10 e0 1b or %g3, 0x1b, %g3 ! 8004741b <RAM_END+0x7dc4741b>
2005b0c: 80 a0 40 03 cmp %g1, %g3
2005b10: 02 80 00 a9 be 2005db4 <rtems_termios_ioctl+0x360> <== ALWAYS TAKEN
2005b14: 03 00 80 75 sethi %hi(0x201d400), %g1
default:
if (rtems_termios_linesw[tty->t_line].l_ioctl != NULL) {
2005b18: 03 00 80 75 sethi %hi(0x201d400), %g1
2005b1c: 85 28 a0 05 sll %g2, 5, %g2
2005b20: 82 10 61 d4 or %g1, 0x1d4, %g1
2005b24: 82 00 40 02 add %g1, %g2, %g1
2005b28: c2 00 60 18 ld [ %g1 + 0x18 ], %g1
2005b2c: 80 a0 60 00 cmp %g1, 0
2005b30: 02 80 00 c9 be 2005e54 <rtems_termios_ioctl+0x400>
2005b34: b0 10 20 0a mov 0xa, %i0
sc = rtems_termios_linesw[tty->t_line].l_ioctl(tty,args);
2005b38: 90 10 00 1d mov %i5, %o0
2005b3c: 9f c0 40 00 call %g1
2005b40: 92 10 00 1c mov %i4, %o1
tty->t_sc = NULL; /* ensure that no more valid data */
/*
* open new line discipline
*/
if (rtems_termios_linesw[tty->t_line].l_open != NULL) {
sc = rtems_termios_linesw[tty->t_line].l_open(tty);
2005b44: 10 80 00 c4 b 2005e54 <rtems_termios_ioctl+0x400>
2005b48: b0 10 00 08 mov %o0, %i0
sc = RTEMS_INVALID_NUMBER;
}
break;
case RTEMS_IO_GET_ATTRIBUTES:
*(struct termios *)args->buffer = tty->termios;
2005b4c: 92 07 60 30 add %i5, 0x30, %o1
2005b50: 40 00 29 f7 call 201032c <memcpy>
2005b54: 94 10 20 24 mov 0x24, %o2
break;
2005b58: 30 80 00 bf b,a 2005e54 <rtems_termios_ioctl+0x400>
case RTEMS_IO_SET_ATTRIBUTES:
tty->termios = *(struct termios *)args->buffer;
2005b5c: 90 07 60 30 add %i5, 0x30, %o0
2005b60: 40 00 29 f3 call 201032c <memcpy>
2005b64: 94 10 20 24 mov 0x24, %o2
/*
* check for flow control options to be switched off
*/
/* check for outgoing XON/XOFF flow control switched off */
if (( tty->flow_ctrl & FL_MDXON) &&
2005b68: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1
2005b6c: 80 88 62 00 btst 0x200, %g1
2005b70: 02 80 00 20 be 2005bf0 <rtems_termios_ioctl+0x19c>
2005b74: 01 00 00 00 nop
!(tty->termios.c_iflag & IXON)) {
2005b78: c2 07 60 30 ld [ %i5 + 0x30 ], %g1
/*
* check for flow control options to be switched off
*/
/* check for outgoing XON/XOFF flow control switched off */
if (( tty->flow_ctrl & FL_MDXON) &&
2005b7c: 80 88 64 00 btst 0x400, %g1
2005b80: 12 80 00 1c bne 2005bf0 <rtems_termios_ioctl+0x19c>
2005b84: 01 00 00 00 nop
!(tty->termios.c_iflag & IXON)) {
/* clear related flags in flow_ctrl */
tty->flow_ctrl &= ~(FL_MDXON | FL_ORCVXOF);
2005b88: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1
2005b8c: 82 08 7d ef and %g1, -529, %g1
2005b90: c2 27 60 b8 st %g1, [ %i5 + 0xb8 ]
/* has output been stopped due to received XOFF? */
if (tty->flow_ctrl & FL_OSTOP) {
2005b94: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1
2005b98: 80 88 60 20 btst 0x20, %g1
2005b9c: 02 80 00 15 be 2005bf0 <rtems_termios_ioctl+0x19c> <== ALWAYS TAKEN
2005ba0: 01 00 00 00 nop
/* disable interrupts */
rtems_interrupt_disable(level);
2005ba4: 7f ff f2 c8 call 20026c4 <sparc_disable_interrupts> <== NOT EXECUTED
2005ba8: 01 00 00 00 nop <== NOT EXECUTED
2005bac: b8 10 00 08 mov %o0, %i4 <== NOT EXECUTED
tty->flow_ctrl &= ~FL_OSTOP;
2005bb0: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1 <== NOT EXECUTED
2005bb4: 82 08 7f df and %g1, -33, %g1 <== NOT EXECUTED
2005bb8: c2 27 60 b8 st %g1, [ %i5 + 0xb8 ] <== NOT EXECUTED
/* check for chars in output buffer (or rob_state?) */
if (tty->rawOutBufState != rob_idle) {
2005bbc: c2 07 60 94 ld [ %i5 + 0x94 ], %g1 <== NOT EXECUTED
2005bc0: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
2005bc4: 02 80 00 09 be 2005be8 <rtems_termios_ioctl+0x194> <== NOT EXECUTED
2005bc8: 01 00 00 00 nop <== NOT EXECUTED
/* if chars available, call write function... */
(*tty->device.write)(
tty->minor, &tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail],1);
2005bcc: c4 07 60 84 ld [ %i5 + 0x84 ], %g2 <== 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)(
2005bd0: d2 07 60 7c ld [ %i5 + 0x7c ], %o1 <== NOT EXECUTED
2005bd4: c2 07 60 a4 ld [ %i5 + 0xa4 ], %g1 <== NOT EXECUTED
2005bd8: d0 07 60 10 ld [ %i5 + 0x10 ], %o0 <== NOT EXECUTED
2005bdc: 92 02 40 02 add %o1, %g2, %o1 <== NOT EXECUTED
2005be0: 9f c0 40 00 call %g1 <== NOT EXECUTED
2005be4: 94 10 20 01 mov 1, %o2 <== NOT EXECUTED
tty->minor, &tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail],1);
}
/* reenable interrupts */
rtems_interrupt_enable(level);
2005be8: 7f ff f2 bb call 20026d4 <sparc_enable_interrupts> <== NOT EXECUTED
2005bec: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
}
}
/* check for incoming XON/XOFF flow control switched off */
if (( tty->flow_ctrl & FL_MDXOF) && !(tty->termios.c_iflag & IXOFF)) {
2005bf0: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1
2005bf4: 80 88 64 00 btst 0x400, %g1
2005bf8: 02 80 00 0c be 2005c28 <rtems_termios_ioctl+0x1d4>
2005bfc: 03 00 00 04 sethi %hi(0x1000), %g1
2005c00: c4 07 60 30 ld [ %i5 + 0x30 ], %g2
2005c04: 80 88 80 01 btst %g2, %g1
2005c08: 12 80 00 08 bne 2005c28 <rtems_termios_ioctl+0x1d4> <== NEVER TAKEN
2005c0c: 01 00 00 00 nop
/* clear related flags in flow_ctrl */
tty->flow_ctrl &= ~(FL_MDXOF);
2005c10: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1
2005c14: 82 08 7b ff and %g1, -1025, %g1
2005c18: c2 27 60 b8 st %g1, [ %i5 + 0xb8 ]
/* FIXME: what happens, if we had sent XOFF but not yet XON? */
tty->flow_ctrl &= ~(FL_ISNTXOF);
2005c1c: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1
2005c20: 82 08 7f fd and %g1, -3, %g1
2005c24: c2 27 60 b8 st %g1, [ %i5 + 0xb8 ]
}
/* check for incoming RTS/CTS flow control switched off */
if (( tty->flow_ctrl & FL_MDRTS) && !(tty->termios.c_cflag & CRTSCTS)) {
2005c28: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1
2005c2c: 80 88 61 00 btst 0x100, %g1
2005c30: 02 80 00 16 be 2005c88 <rtems_termios_ioctl+0x234> <== ALWAYS TAKEN
2005c34: c2 07 60 38 ld [ %i5 + 0x38 ], %g1
2005c38: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
2005c3c: 06 80 00 14 bl 2005c8c <rtems_termios_ioctl+0x238> <== NOT EXECUTED
2005c40: 01 00 00 00 nop <== NOT EXECUTED
/* clear related flags in flow_ctrl */
tty->flow_ctrl &= ~(FL_MDRTS);
2005c44: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1 <== NOT EXECUTED
2005c48: 82 08 7e ff and %g1, -257, %g1 <== NOT EXECUTED
2005c4c: c2 27 60 b8 st %g1, [ %i5 + 0xb8 ] <== NOT EXECUTED
/* restart remote Tx, if it was stopped */
if ((tty->flow_ctrl & FL_IRTSOFF) && (tty->device.startRemoteTx != NULL)) {
2005c50: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1 <== NOT EXECUTED
2005c54: 80 88 60 04 btst 4, %g1 <== NOT EXECUTED
2005c58: 02 80 00 08 be 2005c78 <rtems_termios_ioctl+0x224> <== NOT EXECUTED
2005c5c: 01 00 00 00 nop <== NOT EXECUTED
2005c60: c2 07 60 b0 ld [ %i5 + 0xb0 ], %g1 <== NOT EXECUTED
2005c64: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
2005c68: 02 80 00 04 be 2005c78 <rtems_termios_ioctl+0x224> <== NOT EXECUTED
2005c6c: 01 00 00 00 nop <== NOT EXECUTED
tty->device.startRemoteTx(tty->minor);
2005c70: 9f c0 40 00 call %g1 <== NOT EXECUTED
2005c74: d0 07 60 10 ld [ %i5 + 0x10 ], %o0 <== NOT EXECUTED
}
tty->flow_ctrl &= ~(FL_IRTSOFF);
2005c78: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1 <== NOT EXECUTED
2005c7c: 82 08 7f fb and %g1, -5, %g1 <== NOT EXECUTED
2005c80: c2 27 60 b8 st %g1, [ %i5 + 0xb8 ] <== NOT EXECUTED
/*
* check for flow control options to be switched on
*/
/* check for incoming RTS/CTS flow control switched on */
if (tty->termios.c_cflag & CRTSCTS) {
2005c84: c2 07 60 38 ld [ %i5 + 0x38 ], %g1 <== NOT EXECUTED
2005c88: 80 a0 60 00 cmp %g1, 0
2005c8c: 36 80 00 06 bge,a 2005ca4 <rtems_termios_ioctl+0x250> <== ALWAYS TAKEN
2005c90: c2 07 60 30 ld [ %i5 + 0x30 ], %g1
tty->flow_ctrl |= FL_MDRTS;
2005c94: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1 <== NOT EXECUTED
2005c98: 82 10 61 00 or %g1, 0x100, %g1 <== NOT EXECUTED
2005c9c: c2 27 60 b8 st %g1, [ %i5 + 0xb8 ] <== NOT EXECUTED
}
/* check for incoming XON/XOF flow control switched on */
if (tty->termios.c_iflag & IXOFF) {
2005ca0: c2 07 60 30 ld [ %i5 + 0x30 ], %g1 <== NOT EXECUTED
2005ca4: 05 00 00 04 sethi %hi(0x1000), %g2
2005ca8: 80 88 40 02 btst %g1, %g2
2005cac: 02 80 00 06 be 2005cc4 <rtems_termios_ioctl+0x270>
2005cb0: 80 88 64 00 btst 0x400, %g1
tty->flow_ctrl |= FL_MDXOF;
2005cb4: c4 07 60 b8 ld [ %i5 + 0xb8 ], %g2
2005cb8: 84 10 a4 00 or %g2, 0x400, %g2
2005cbc: c4 27 60 b8 st %g2, [ %i5 + 0xb8 ]
}
/* check for outgoing XON/XOF flow control switched on */
if (tty->termios.c_iflag & IXON) {
2005cc0: 80 88 64 00 btst 0x400, %g1
2005cc4: 22 80 00 06 be,a 2005cdc <rtems_termios_ioctl+0x288>
2005cc8: c2 07 60 3c ld [ %i5 + 0x3c ], %g1
tty->flow_ctrl |= FL_MDXON;
2005ccc: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1
2005cd0: 82 10 62 00 or %g1, 0x200, %g1
2005cd4: c2 27 60 b8 st %g1, [ %i5 + 0xb8 ]
tty->termios = *(struct termios *)args->buffer;
/* check for and process change in flow control options */
termios_set_flowctrl(tty);
if (tty->termios.c_lflag & ICANON) {
2005cd8: c2 07 60 3c ld [ %i5 + 0x3c ], %g1
2005cdc: 80 88 60 02 btst 2, %g1
2005ce0: 02 80 00 04 be 2005cf0 <rtems_termios_ioctl+0x29c>
2005ce4: 01 00 00 00 nop
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
else
tty->rawInBufSemaphoreFirstTimeout = tty->vtimeTicks;
} else {
if (tty->termios.c_cc[VMIN]) {
tty->rawInBufSemaphoreOptions = RTEMS_WAIT;
2005ce8: 10 80 00 19 b 2005d4c <rtems_termios_ioctl+0x2f8>
2005cec: c0 27 60 6c clr [ %i5 + 0x6c ]
tty->rawInBufSemaphoreOptions = RTEMS_WAIT;
tty->rawInBufSemaphoreTimeout = RTEMS_NO_TIMEOUT;
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
} else {
tty->vtimeTicks = tty->termios.c_cc[VTIME] *
rtems_clock_get_ticks_per_second() / 10;
2005cf0: 40 00 05 38 call 20071d0 <rtems_clock_get_ticks_per_second>
2005cf4: f8 0f 60 46 ldub [ %i5 + 0x46 ], %i4
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] *
2005cf8: 40 00 4a ac call 20187a8 <.umul>
2005cfc: 92 10 00 1c mov %i4, %o1
rtems_clock_get_ticks_per_second() / 10;
2005d00: 40 00 4a e4 call 2018890 <.udiv>
2005d04: 92 10 20 0a mov 0xa, %o1
if (tty->termios.c_cc[VTIME]) {
2005d08: c2 0f 60 46 ldub [ %i5 + 0x46 ], %g1
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] *
2005d0c: d0 27 60 54 st %o0, [ %i5 + 0x54 ]
rtems_clock_get_ticks_per_second() / 10;
if (tty->termios.c_cc[VTIME]) {
2005d10: 80 a0 60 00 cmp %g1, 0
2005d14: 02 80 00 0a be 2005d3c <rtems_termios_ioctl+0x2e8>
2005d18: c2 0f 60 47 ldub [ %i5 + 0x47 ], %g1
tty->rawInBufSemaphoreOptions = RTEMS_WAIT;
2005d1c: c0 27 60 6c clr [ %i5 + 0x6c ]
tty->rawInBufSemaphoreTimeout = tty->vtimeTicks;
if (tty->termios.c_cc[VMIN])
2005d20: 80 88 60 ff btst 0xff, %g1
2005d24: 02 80 00 04 be 2005d34 <rtems_termios_ioctl+0x2e0>
2005d28: d0 27 60 70 st %o0, [ %i5 + 0x70 ]
tty->rawInBufSemaphoreFirstTimeout = tty->vtimeTicks;
} else {
if (tty->termios.c_cc[VMIN]) {
tty->rawInBufSemaphoreOptions = RTEMS_WAIT;
tty->rawInBufSemaphoreTimeout = RTEMS_NO_TIMEOUT;
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
2005d2c: 10 80 00 0c b 2005d5c <rtems_termios_ioctl+0x308>
2005d30: c0 27 60 74 clr [ %i5 + 0x74 ]
tty->rawInBufSemaphoreOptions = RTEMS_WAIT;
tty->rawInBufSemaphoreTimeout = tty->vtimeTicks;
if (tty->termios.c_cc[VMIN])
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
else
tty->rawInBufSemaphoreFirstTimeout = tty->vtimeTicks;
2005d34: 10 80 00 0a b 2005d5c <rtems_termios_ioctl+0x308>
2005d38: d0 27 60 74 st %o0, [ %i5 + 0x74 ]
} else {
if (tty->termios.c_cc[VMIN]) {
2005d3c: 80 88 60 ff btst 0xff, %g1
2005d40: 02 80 00 06 be 2005d58 <rtems_termios_ioctl+0x304> <== ALWAYS TAKEN
2005d44: 82 10 20 01 mov 1, %g1
tty->rawInBufSemaphoreOptions = RTEMS_WAIT;
2005d48: c0 27 60 6c clr [ %i5 + 0x6c ] <== NOT EXECUTED
tty->rawInBufSemaphoreTimeout = RTEMS_NO_TIMEOUT;
2005d4c: c0 27 60 70 clr [ %i5 + 0x70 ]
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
2005d50: 10 80 00 03 b 2005d5c <rtems_termios_ioctl+0x308>
2005d54: c0 27 60 74 clr [ %i5 + 0x74 ]
} else {
tty->rawInBufSemaphoreOptions = RTEMS_NO_WAIT;
2005d58: c2 27 60 6c st %g1, [ %i5 + 0x6c ]
}
}
}
if (tty->device.setAttributes)
2005d5c: c2 07 60 a8 ld [ %i5 + 0xa8 ], %g1
2005d60: 80 a0 60 00 cmp %g1, 0
2005d64: 02 80 00 3c be 2005e54 <rtems_termios_ioctl+0x400>
2005d68: 01 00 00 00 nop
(*tty->device.setAttributes)(tty->minor, &tty->termios);
2005d6c: d0 07 60 10 ld [ %i5 + 0x10 ], %o0
2005d70: 9f c0 40 00 call %g1
2005d74: 92 07 60 30 add %i5, 0x30, %o1
2005d78: 30 80 00 37 b,a 2005e54 <rtems_termios_ioctl+0x400>
drainOutput (struct rtems_termios_tty *tty)
{
rtems_interrupt_level level;
rtems_status_code sc;
if (tty->device.outputUsesInterrupts != TERMIOS_POLLED) {
2005d7c: 80 a0 60 00 cmp %g1, 0
2005d80: 02 80 00 35 be 2005e54 <rtems_termios_ioctl+0x400> <== ALWAYS TAKEN
2005d84: 01 00 00 00 nop
2005d88: 7f ff fd 87 call 20053a4 <drainOutput.part.0> <== NOT EXECUTED
2005d8c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
2005d90: 30 80 00 31 b,a 2005e54 <rtems_termios_ioctl+0x400> <== NOT EXECUTED
case RTEMS_IO_TCDRAIN:
drainOutput (tty);
break;
case RTEMS_IO_SNDWAKEUP:
tty->tty_snd = *wakeup;
2005d94: c2 27 60 d4 st %g1, [ %i5 + 0xd4 ]
2005d98: c2 06 e0 04 ld [ %i3 + 4 ], %g1
break;
2005d9c: 10 80 00 2e b 2005e54 <rtems_termios_ioctl+0x400>
2005da0: c2 27 60 d8 st %g1, [ %i5 + 0xd8 ]
case RTEMS_IO_RCVWAKEUP:
tty->tty_rcv = *wakeup;
2005da4: c2 27 60 dc st %g1, [ %i5 + 0xdc ]
2005da8: c2 06 e0 04 ld [ %i3 + 4 ], %g1
break;
2005dac: 10 80 00 2a b 2005e54 <rtems_termios_ioctl+0x400>
2005db0: c2 27 60 e0 st %g1, [ %i5 + 0xe0 ]
#if 1 /* FIXME */
case TIOCSETD:
/*
* close old line discipline
*/
if (rtems_termios_linesw[tty->t_line].l_close != NULL) {
2005db4: 82 10 61 d4 or %g1, 0x1d4, %g1
2005db8: 85 28 a0 05 sll %g2, 5, %g2
2005dbc: 84 00 40 02 add %g1, %g2, %g2
2005dc0: c2 00 a0 04 ld [ %g2 + 4 ], %g1
2005dc4: 80 a0 60 00 cmp %g1, 0
2005dc8: 22 80 00 06 be,a 2005de0 <rtems_termios_ioctl+0x38c>
2005dcc: c2 07 20 08 ld [ %i4 + 8 ], %g1
sc = rtems_termios_linesw[tty->t_line].l_close(tty);
2005dd0: 9f c0 40 00 call %g1
2005dd4: 90 10 00 1d mov %i5, %o0
2005dd8: b0 10 00 08 mov %o0, %i0
}
tty->t_line=*(int*)(args->buffer);
2005ddc: c2 07 20 08 ld [ %i4 + 8 ], %g1
tty->t_sc = NULL; /* ensure that no more valid data */
/*
* open new line discipline
*/
if (rtems_termios_linesw[tty->t_line].l_open != NULL) {
2005de0: 05 00 80 75 sethi %hi(0x201d400), %g2
* 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);
2005de4: c2 00 40 00 ld [ %g1 ], %g1
tty->t_sc = NULL; /* ensure that no more valid data */
/*
* open new line discipline
*/
if (rtems_termios_linesw[tty->t_line].l_open != NULL) {
2005de8: 84 10 a1 d4 or %g2, 0x1d4, %g2
* 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);
2005dec: c2 27 60 cc st %g1, [ %i5 + 0xcc ]
tty->t_sc = NULL; /* ensure that no more valid data */
/*
* open new line discipline
*/
if (rtems_termios_linesw[tty->t_line].l_open != NULL) {
2005df0: 83 28 60 05 sll %g1, 5, %g1
2005df4: c2 00 80 01 ld [ %g2 + %g1 ], %g1
2005df8: 80 a0 60 00 cmp %g1, 0
2005dfc: 02 80 00 16 be 2005e54 <rtems_termios_ioctl+0x400>
2005e00: c0 27 60 d0 clr [ %i5 + 0xd0 ]
sc = rtems_termios_linesw[tty->t_line].l_open(tty);
2005e04: 9f c0 40 00 call %g1
2005e08: 90 10 00 1d mov %i5, %o0
2005e0c: 10 80 00 12 b 2005e54 <rtems_termios_ioctl+0x400>
2005e10: b0 10 00 08 mov %o0, %i0
}
break;
case TIOCGETD:
*(int*)(args->buffer)=tty->t_line;
2005e14: c2 07 20 08 ld [ %i4 + 8 ], %g1
break;
2005e18: 10 80 00 0f b 2005e54 <rtems_termios_ioctl+0x400>
2005e1c: c4 20 40 00 st %g2, [ %g1 ]
#endif
case FIONREAD: {
int rawnc = tty->rawInBuf.Tail - tty->rawInBuf.Head;
2005e20: c4 07 60 60 ld [ %i5 + 0x60 ], %g2 <== NOT EXECUTED
2005e24: c2 07 60 5c ld [ %i5 + 0x5c ], %g1 <== NOT EXECUTED
if ( rawnc < 0 )
2005e28: 82 a0 80 01 subcc %g2, %g1, %g1 <== NOT EXECUTED
2005e2c: 3c 80 00 05 bpos,a 2005e40 <rtems_termios_ioctl+0x3ec> <== NOT EXECUTED
2005e30: c8 07 60 20 ld [ %i5 + 0x20 ], %g4 <== NOT EXECUTED
rawnc += tty->rawInBuf.Size;
2005e34: c4 07 60 64 ld [ %i5 + 0x64 ], %g2 <== NOT EXECUTED
2005e38: 82 00 40 02 add %g1, %g2, %g1 <== NOT EXECUTED
/* Half guess that this is the right operation */
*(int *)args->buffer = tty->ccount - tty->cindex + rawnc;
2005e3c: c8 07 60 20 ld [ %i5 + 0x20 ], %g4 <== NOT EXECUTED
2005e40: c6 07 60 24 ld [ %i5 + 0x24 ], %g3 <== NOT EXECUTED
2005e44: c4 07 20 08 ld [ %i4 + 8 ], %g2 <== NOT EXECUTED
2005e48: 86 21 00 03 sub %g4, %g3, %g3 <== NOT EXECUTED
2005e4c: 82 00 c0 01 add %g3, %g1, %g1 <== NOT EXECUTED
2005e50: c2 20 80 00 st %g1, [ %g2 ] <== NOT EXECUTED
}
break;
}
rtems_semaphore_release (tty->osem);
2005e54: 40 00 06 ee call 2007a0c <rtems_semaphore_release>
2005e58: d0 07 60 18 ld [ %i5 + 0x18 ], %o0
return sc;
}
2005e5c: 81 c7 e0 08 ret
2005e60: 81 e8 00 00 restore
02005408 <rtems_termios_open>:
rtems_device_major_number major,
rtems_device_minor_number minor,
void *arg,
const rtems_termios_callbacks *callbacks
)
{
2005408: 9d e3 bf a0 save %sp, -96, %sp
struct rtems_termios_tty *tty;
/*
* See if the device has already been opened
*/
sc = rtems_semaphore_obtain(
200540c: 03 00 80 76 sethi %hi(0x201d800), %g1
2005410: d0 00 61 88 ld [ %g1 + 0x188 ], %o0 ! 201d988 <rtems_termios_ttyMutex>
2005414: 92 10 20 00 clr %o1
2005418: 40 00 09 33 call 20078e4 <rtems_semaphore_obtain>
200541c: 94 10 20 00 clr %o2
rtems_termios_ttyMutex, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
2005420: b8 92 20 00 orcc %o0, 0, %i4
2005424: 12 80 01 09 bne 2005848 <rtems_termios_open+0x440> <== NEVER TAKEN
2005428: 03 00 80 76 sethi %hi(0x201d800), %g1
return sc;
for (tty = rtems_termios_ttyHead ; tty != NULL ; tty = tty->forw) {
200542c: e0 00 61 90 ld [ %g1 + 0x190 ], %l0 ! 201d990 <rtems_termios_ttyHead>
2005430: 10 80 00 0a b 2005458 <rtems_termios_open+0x50>
2005434: ba 10 00 10 mov %l0, %i5
if ((tty->major == major) && (tty->minor == minor))
2005438: 80 a0 40 18 cmp %g1, %i0
200543c: 32 80 00 07 bne,a 2005458 <rtems_termios_open+0x50>
2005440: fa 07 40 00 ld [ %i5 ], %i5
2005444: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
2005448: 80 a0 40 19 cmp %g1, %i1
200544c: 22 80 00 d0 be,a 200578c <rtems_termios_open+0x384> <== ALWAYS TAKEN
2005450: c2 06 80 00 ld [ %i2 ], %g1
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) {
2005454: fa 07 40 00 ld [ %i5 ], %i5 <== NOT EXECUTED
2005458: 80 a7 60 00 cmp %i5, 0
200545c: 32 bf ff f7 bne,a 2005438 <rtems_termios_open+0x30>
2005460: c2 07 60 0c ld [ %i5 + 0xc ], %g1
static char c = 'a';
/*
* Create a new device
*/
tty = calloc (1, sizeof (struct rtems_termios_tty));
2005464: 10 80 00 f2 b 200582c <rtems_termios_open+0x424>
2005468: 90 10 20 01 mov 1, %o0
return RTEMS_NO_MEMORY;
}
/*
* allocate raw input buffer
*/
tty->rawInBuf.Size = RAW_INPUT_BUFFER_SIZE;
200546c: c2 00 62 f8 ld [ %g1 + 0x2f8 ], %g1
2005470: c2 27 60 64 st %g1, [ %i5 + 0x64 ]
tty->rawInBuf.theBuf = malloc (tty->rawInBuf.Size);
2005474: d0 07 60 64 ld [ %i5 + 0x64 ], %o0
2005478: 7f ff f9 c2 call 2003b80 <malloc>
200547c: 01 00 00 00 nop
2005480: d0 27 60 58 st %o0, [ %i5 + 0x58 ]
if (tty->rawInBuf.theBuf == NULL) {
2005484: 80 a2 20 00 cmp %o0, 0
2005488: 02 80 00 16 be 20054e0 <rtems_termios_open+0xd8>
200548c: a2 10 00 08 mov %o0, %l1
return RTEMS_NO_MEMORY;
}
/*
* allocate raw output buffer
*/
tty->rawOutBuf.Size = RAW_OUTPUT_BUFFER_SIZE;
2005490: 03 00 80 73 sethi %hi(0x201cc00), %g1
2005494: c2 00 62 fc ld [ %g1 + 0x2fc ], %g1 ! 201cefc <rtems_termios_raw_output_size>
2005498: c2 27 60 88 st %g1, [ %i5 + 0x88 ]
tty->rawOutBuf.theBuf = malloc (tty->rawOutBuf.Size);
200549c: d0 07 60 88 ld [ %i5 + 0x88 ], %o0
20054a0: 7f ff f9 b8 call 2003b80 <malloc>
20054a4: 01 00 00 00 nop
20054a8: d0 27 60 7c st %o0, [ %i5 + 0x7c ]
if (tty->rawOutBuf.theBuf == NULL) {
20054ac: 80 a2 20 00 cmp %o0, 0
20054b0: 02 80 00 0a be 20054d8 <rtems_termios_open+0xd0>
20054b4: a4 10 00 08 mov %o0, %l2
return RTEMS_NO_MEMORY;
}
/*
* allocate cooked buffer
*/
tty->cbuf = malloc (CBUFSIZE);
20054b8: 03 00 80 73 sethi %hi(0x201cc00), %g1
20054bc: 7f ff f9 b1 call 2003b80 <malloc>
20054c0: d0 00 63 00 ld [ %g1 + 0x300 ], %o0 ! 201cf00 <rtems_termios_cbufsize>
if (tty->cbuf == NULL) {
20054c4: 80 a2 20 00 cmp %o0, 0
20054c8: 12 80 00 0e bne 2005500 <rtems_termios_open+0xf8>
20054cc: d0 27 60 1c st %o0, [ %i5 + 0x1c ]
free((void *)(tty->rawOutBuf.theBuf));
20054d0: 7f ff f8 c3 call 20037dc <free>
20054d4: 90 10 00 12 mov %l2, %o0
free((void *)(tty->rawInBuf.theBuf));
20054d8: 7f ff f8 c1 call 20037dc <free>
20054dc: 90 10 00 11 mov %l1, %o0
free(tty);
20054e0: 7f ff f8 bf call 20037dc <free>
20054e4: 90 10 00 1d mov %i5, %o0
rtems_semaphore_release (rtems_termios_ttyMutex);
20054e8: 03 00 80 76 sethi %hi(0x201d800), %g1
20054ec: d0 00 61 88 ld [ %g1 + 0x188 ], %o0 ! 201d988 <rtems_termios_ttyMutex>
20054f0: 40 00 09 47 call 2007a0c <rtems_semaphore_release>
20054f4: b8 10 20 1a mov 0x1a, %i4
return RTEMS_NO_MEMORY;
20054f8: 81 c7 e0 08 ret
20054fc: 91 e8 00 1c restore %g0, %i4, %o0
}
/*
* Initialize wakeup callbacks
*/
tty->tty_snd.sw_pfn = NULL;
2005500: c0 27 60 d4 clr [ %i5 + 0xd4 ]
tty->tty_snd.sw_arg = NULL;
2005504: c0 27 60 d8 clr [ %i5 + 0xd8 ]
tty->tty_rcv.sw_pfn = NULL;
2005508: c0 27 60 dc clr [ %i5 + 0xdc ]
tty->tty_rcv.sw_arg = NULL;
200550c: c0 27 60 e0 clr [ %i5 + 0xe0 ]
tty->tty_rcvwakeup = 0;
2005510: c0 27 60 e4 clr [ %i5 + 0xe4 ]
/*
* link tty
*/
tty->forw = rtems_termios_ttyHead;
2005514: e0 27 40 00 st %l0, [ %i5 ]
tty->back = NULL;
if (rtems_termios_ttyHead != NULL)
2005518: 80 a4 20 00 cmp %l0, 0
200551c: 02 80 00 03 be 2005528 <rtems_termios_open+0x120>
2005520: c0 27 60 04 clr [ %i5 + 4 ]
rtems_termios_ttyHead->back = tty;
2005524: fa 24 20 04 st %i5, [ %l0 + 4 ]
rtems_termios_ttyHead = tty;
2005528: 03 00 80 76 sethi %hi(0x201d800), %g1
200552c: fa 20 61 90 st %i5, [ %g1 + 0x190 ] ! 201d990 <rtems_termios_ttyHead>
if (rtems_termios_ttyTail == NULL)
2005530: 03 00 80 76 sethi %hi(0x201d800), %g1
2005534: c4 00 61 8c ld [ %g1 + 0x18c ], %g2 ! 201d98c <rtems_termios_ttyTail>
2005538: 80 a0 a0 00 cmp %g2, 0
200553c: 22 80 00 02 be,a 2005544 <rtems_termios_open+0x13c>
2005540: fa 20 61 8c st %i5, [ %g1 + 0x18c ]
/*
* Set up mutex semaphores
*/
sc = rtems_semaphore_create (
rtems_build_name ('T', 'R', 'i', c),
2005544: 21 00 80 73 sethi %hi(0x201cc00), %l0
2005548: d0 4c 23 04 ldsb [ %l0 + 0x304 ], %o0 ! 201cf04 <c.6816>
tty->major = major;
/*
* Set up mutex semaphores
*/
sc = rtems_semaphore_create (
200554c: 03 15 14 9a sethi %hi(0x54526800), %g1
2005550: 82 10 61 00 or %g1, 0x100, %g1 ! 54526900 <RAM_END+0x52126900>
rtems_termios_ttyHead->back = tty;
rtems_termios_ttyHead = tty;
if (rtems_termios_ttyTail == NULL)
rtems_termios_ttyTail = tty;
tty->minor = minor;
2005554: f2 27 60 10 st %i1, [ %i5 + 0x10 ]
tty->major = major;
2005558: f0 27 60 0c st %i0, [ %i5 + 0xc ]
/*
* Set up mutex semaphores
*/
sc = rtems_semaphore_create (
200555c: 90 12 00 01 or %o0, %g1, %o0
2005560: 92 10 20 01 mov 1, %o1
2005564: 94 10 20 54 mov 0x54, %o2
2005568: 96 10 20 00 clr %o3
200556c: 40 00 08 40 call 200766c <rtems_semaphore_create>
2005570: 98 07 60 14 add %i5, 0x14, %o4
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)
2005574: 80 a2 20 00 cmp %o0, 0
2005578: 22 80 00 03 be,a 2005584 <rtems_termios_open+0x17c>
200557c: d0 4c 23 04 ldsb [ %l0 + 0x304 ], %o0
2005580: 30 80 00 a4 b,a 2005810 <rtems_termios_open+0x408>
rtems_fatal_error_occurred (sc);
sc = rtems_semaphore_create (
2005584: 03 15 14 9b sethi %hi(0x54526c00), %g1
2005588: 82 10 63 00 or %g1, 0x300, %g1 ! 54526f00 <RAM_END+0x52126f00>
200558c: 92 10 20 01 mov 1, %o1
2005590: 90 12 00 01 or %o0, %g1, %o0
2005594: 94 10 20 54 mov 0x54, %o2
2005598: 96 10 20 00 clr %o3
200559c: 40 00 08 34 call 200766c <rtems_semaphore_create>
20055a0: 98 07 60 18 add %i5, 0x18, %o4
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)
20055a4: 80 a2 20 00 cmp %o0, 0
20055a8: 22 80 00 03 be,a 20055b4 <rtems_termios_open+0x1ac>
20055ac: d0 4c 23 04 ldsb [ %l0 + 0x304 ], %o0
20055b0: 30 80 00 98 b,a 2005810 <rtems_termios_open+0x408>
rtems_fatal_error_occurred (sc);
sc = rtems_semaphore_create (
20055b4: 03 15 14 9e sethi %hi(0x54527800), %g1
20055b8: 92 10 20 00 clr %o1
20055bc: 90 12 00 01 or %o0, %g1, %o0
20055c0: 94 10 20 20 mov 0x20, %o2
20055c4: 96 10 20 00 clr %o3
20055c8: 40 00 08 29 call 200766c <rtems_semaphore_create>
20055cc: 98 07 60 8c add %i5, 0x8c, %o4
rtems_build_name ('T', 'R', 'x', c),
0,
RTEMS_SIMPLE_BINARY_SEMAPHORE | RTEMS_FIFO,
RTEMS_NO_PRIORITY,
&tty->rawOutBuf.Semaphore);
if (sc != RTEMS_SUCCESSFUL)
20055d0: 80 a2 20 00 cmp %o0, 0
20055d4: 22 80 00 03 be,a 20055e0 <rtems_termios_open+0x1d8>
20055d8: c0 27 60 94 clr [ %i5 + 0x94 ]
20055dc: 30 80 00 8d b,a 2005810 <rtems_termios_open+0x408>
tty->rawOutBufState = rob_idle;
/*
* Set callbacks
*/
tty->device = *callbacks;
20055e0: 90 07 60 98 add %i5, 0x98, %o0
20055e4: 92 10 00 1b mov %i3, %o1
20055e8: 40 00 2b 51 call 201032c <memcpy>
20055ec: 94 10 20 20 mov 0x20, %o2
/*
* Create I/O tasks
*/
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
20055f0: c2 07 60 b4 ld [ %i5 + 0xb4 ], %g1
20055f4: 80 a0 60 02 cmp %g1, 2
20055f8: 32 80 00 1b bne,a 2005664 <rtems_termios_open+0x25c>
20055fc: c2 07 60 a0 ld [ %i5 + 0xa0 ], %g1
sc = rtems_task_create (
rtems_build_name ('T', 'x', 'T', c),
2005600: d0 4c 23 04 ldsb [ %l0 + 0x304 ], %o0
/*
* Create I/O tasks
*/
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
sc = rtems_task_create (
2005604: 03 15 1e 15 sethi %hi(0x54785400), %g1
2005608: 92 10 20 0a mov 0xa, %o1
200560c: 90 12 00 01 or %o0, %g1, %o0
2005610: 94 10 24 00 mov 0x400, %o2
2005614: 96 10 25 00 mov 0x500, %o3
2005618: 98 10 20 00 clr %o4
200561c: 40 00 09 29 call 2007ac0 <rtems_task_create>
2005620: 9a 07 60 c8 add %i5, 0xc8, %o5
TERMIOS_TXTASK_STACKSIZE,
RTEMS_NO_PREEMPT | RTEMS_NO_TIMESLICE |
RTEMS_NO_ASR,
RTEMS_NO_FLOATING_POINT | RTEMS_LOCAL,
&tty->txTaskId);
if (sc != RTEMS_SUCCESSFUL)
2005624: 80 a2 20 00 cmp %o0, 0
2005628: 22 80 00 03 be,a 2005634 <rtems_termios_open+0x22c> <== ALWAYS TAKEN
200562c: d0 4c 23 04 ldsb [ %l0 + 0x304 ], %o0
2005630: 30 80 00 78 b,a 2005810 <rtems_termios_open+0x408> <== NOT EXECUTED
rtems_fatal_error_occurred (sc);
sc = rtems_task_create (
2005634: 03 14 9e 15 sethi %hi(0x52785400), %g1
2005638: 92 10 20 09 mov 9, %o1
200563c: 90 12 00 01 or %o0, %g1, %o0
2005640: 94 10 24 00 mov 0x400, %o2
2005644: 96 10 25 00 mov 0x500, %o3
2005648: 98 10 20 00 clr %o4
200564c: 40 00 09 1d call 2007ac0 <rtems_task_create>
2005650: 9a 07 60 c4 add %i5, 0xc4, %o5
TERMIOS_RXTASK_STACKSIZE,
RTEMS_NO_PREEMPT | RTEMS_NO_TIMESLICE |
RTEMS_NO_ASR,
RTEMS_NO_FLOATING_POINT | RTEMS_LOCAL,
&tty->rxTaskId);
if (sc != RTEMS_SUCCESSFUL)
2005654: 80 a2 20 00 cmp %o0, 0
2005658: 22 80 00 03 be,a 2005664 <rtems_termios_open+0x25c> <== ALWAYS TAKEN
200565c: c2 07 60 a0 ld [ %i5 + 0xa0 ], %g1
2005660: 30 80 00 6c b,a 2005810 <rtems_termios_open+0x408> <== NOT EXECUTED
rtems_fatal_error_occurred (sc);
}
if ((tty->device.pollRead == NULL) ||
2005664: 80 a0 60 00 cmp %g1, 0
2005668: 02 80 00 07 be 2005684 <rtems_termios_open+0x27c>
200566c: 03 00 80 73 sethi %hi(0x201cc00), %g1
2005670: c2 07 60 b4 ld [ %i5 + 0xb4 ], %g1
2005674: 80 a0 60 02 cmp %g1, 2
2005678: 12 80 00 0f bne 20056b4 <rtems_termios_open+0x2ac>
200567c: 03 00 00 09 sethi %hi(0x2400), %g1
(tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN)){
sc = rtems_semaphore_create (
rtems_build_name ('T', 'R', 'r', c),
2005680: 03 00 80 73 sethi %hi(0x201cc00), %g1
2005684: d0 48 63 04 ldsb [ %g1 + 0x304 ], %o0 ! 201cf04 <c.6816>
rtems_fatal_error_occurred (sc);
}
if ((tty->device.pollRead == NULL) ||
(tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN)){
sc = rtems_semaphore_create (
2005688: 03 15 14 9c sethi %hi(0x54527000), %g1
200568c: 82 10 62 00 or %g1, 0x200, %g1 ! 54527200 <RAM_END+0x52127200>
2005690: 92 10 20 00 clr %o1
2005694: 90 12 00 01 or %o0, %g1, %o0
2005698: 94 10 20 24 mov 0x24, %o2
200569c: 96 10 20 00 clr %o3
20056a0: 40 00 07 f3 call 200766c <rtems_semaphore_create>
20056a4: 98 07 60 68 add %i5, 0x68, %o4
rtems_build_name ('T', 'R', 'r', c),
0,
RTEMS_SIMPLE_BINARY_SEMAPHORE | RTEMS_PRIORITY,
RTEMS_NO_PRIORITY,
&tty->rawInBuf.Semaphore);
if (sc != RTEMS_SUCCESSFUL)
20056a8: 80 a2 20 00 cmp %o0, 0
20056ac: 12 80 00 59 bne 2005810 <rtems_termios_open+0x408> <== NEVER TAKEN
20056b0: 03 00 00 09 sethi %hi(0x2400), %g1
}
/*
* Set default parameters
*/
tty->termios.c_iflag = BRKINT | ICRNL | IXON | IMAXBEL;
20056b4: 82 10 61 02 or %g1, 0x102, %g1 ! 2502 <PROM_START+0x2502>
20056b8: c2 27 60 30 st %g1, [ %i5 + 0x30 ]
tty->termios.c_oflag = OPOST | ONLCR | XTABS;
20056bc: 03 00 00 06 sethi %hi(0x1800), %g1
20056c0: 82 10 60 05 or %g1, 5, %g1 ! 1805 <PROM_START+0x1805>
20056c4: c2 27 60 34 st %g1, [ %i5 + 0x34 ]
tty->termios.c_cflag = B9600 | CS8 | CREAD | CLOCAL;
20056c8: 82 10 28 bd mov 0x8bd, %g1
20056cc: c2 27 60 38 st %g1, [ %i5 + 0x38 ]
tty->termios.c_lflag =
20056d0: 03 00 00 20 sethi %hi(0x8000), %g1
20056d4: 82 10 62 3b or %g1, 0x23b, %g1 ! 823b <PROM_START+0x823b>
20056d8: c2 27 60 3c st %g1, [ %i5 + 0x3c ]
ISIG | ICANON | IEXTEN | ECHO | ECHOK | ECHOE | ECHOCTL;
tty->termios.c_cc[VINTR] = '\003';
20056dc: 82 10 20 03 mov 3, %g1
20056e0: c2 2f 60 41 stb %g1, [ %i5 + 0x41 ]
tty->termios.c_cc[VQUIT] = '\034';
20056e4: 82 10 20 1c mov 0x1c, %g1
20056e8: c2 2f 60 42 stb %g1, [ %i5 + 0x42 ]
tty->termios.c_cc[VERASE] = '\177';
20056ec: 82 10 20 7f mov 0x7f, %g1
20056f0: c2 2f 60 43 stb %g1, [ %i5 + 0x43 ]
tty->termios.c_cc[VKILL] = '\025';
20056f4: 82 10 20 15 mov 0x15, %g1
20056f8: c2 2f 60 44 stb %g1, [ %i5 + 0x44 ]
tty->termios.c_cc[VEOF] = '\004';
20056fc: 82 10 20 04 mov 4, %g1
2005700: c2 2f 60 45 stb %g1, [ %i5 + 0x45 ]
tty->termios.c_cc[VEOL] = '\000';
tty->termios.c_cc[VEOL2] = '\000';
tty->termios.c_cc[VSTART] = '\021';
2005704: 82 10 20 11 mov 0x11, %g1
2005708: c2 2f 60 49 stb %g1, [ %i5 + 0x49 ]
tty->termios.c_cc[VSTOP] = '\023';
200570c: 82 10 20 13 mov 0x13, %g1
2005710: c2 2f 60 4a stb %g1, [ %i5 + 0x4a ]
tty->termios.c_cc[VSUSP] = '\032';
2005714: 82 10 20 1a mov 0x1a, %g1
2005718: c2 2f 60 4b stb %g1, [ %i5 + 0x4b ]
tty->termios.c_cc[VREPRINT] = '\022';
200571c: 82 10 20 12 mov 0x12, %g1
2005720: c2 2f 60 4d stb %g1, [ %i5 + 0x4d ]
tty->termios.c_cc[VDISCARD] = '\017';
2005724: 82 10 20 0f mov 0xf, %g1
2005728: c2 2f 60 4e stb %g1, [ %i5 + 0x4e ]
tty->termios.c_cc[VWERASE] = '\027';
200572c: 82 10 20 17 mov 0x17, %g1
2005730: c2 2f 60 4f stb %g1, [ %i5 + 0x4f ]
tty->termios.c_cc[VLNEXT] = '\026';
2005734: 82 10 20 16 mov 0x16, %g1
/* start with no flow control, clear flow control flags */
tty->flow_ctrl = 0;
2005738: c0 27 60 b8 clr [ %i5 + 0xb8 ]
tty->termios.c_cc[VSTOP] = '\023';
tty->termios.c_cc[VSUSP] = '\032';
tty->termios.c_cc[VREPRINT] = '\022';
tty->termios.c_cc[VDISCARD] = '\017';
tty->termios.c_cc[VWERASE] = '\027';
tty->termios.c_cc[VLNEXT] = '\026';
200573c: c2 2f 60 50 stb %g1, [ %i5 + 0x50 ]
/* 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;
2005740: c2 07 60 64 ld [ %i5 + 0x64 ], %g1
tty->termios.c_cc[VINTR] = '\003';
tty->termios.c_cc[VQUIT] = '\034';
tty->termios.c_cc[VERASE] = '\177';
tty->termios.c_cc[VKILL] = '\025';
tty->termios.c_cc[VEOF] = '\004';
tty->termios.c_cc[VEOL] = '\000';
2005744: c0 2f 60 4c clrb [ %i5 + 0x4c ]
/* 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;
2005748: 83 30 60 01 srl %g1, 1, %g1
200574c: c2 27 60 bc st %g1, [ %i5 + 0xbc ]
tty->highwater = tty->rawInBuf.Size * 3/4;
2005750: c2 07 60 64 ld [ %i5 + 0x64 ], %g1
tty->termios.c_cc[VQUIT] = '\034';
tty->termios.c_cc[VERASE] = '\177';
tty->termios.c_cc[VKILL] = '\025';
tty->termios.c_cc[VEOF] = '\004';
tty->termios.c_cc[VEOL] = '\000';
tty->termios.c_cc[VEOL2] = '\000';
2005754: c0 2f 60 51 clrb [ %i5 + 0x51 ]
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;
2005758: 85 28 60 01 sll %g1, 1, %g2
200575c: 82 00 80 01 add %g2, %g1, %g1
2005760: 83 30 60 02 srl %g1, 2, %g1
2005764: c2 27 60 c0 st %g1, [ %i5 + 0xc0 ]
/*
* Bump name characer
*/
if (c++ == 'z')
2005768: 03 00 80 73 sethi %hi(0x201cc00), %g1
200576c: c4 08 63 04 ldub [ %g1 + 0x304 ], %g2 ! 201cf04 <c.6816>
2005770: c6 48 63 04 ldsb [ %g1 + 0x304 ], %g3
2005774: 80 a0 e0 7a cmp %g3, 0x7a
2005778: 12 80 00 03 bne 2005784 <rtems_termios_open+0x37c>
200577c: 84 00 a0 01 inc %g2
c = 'a';
2005780: 84 10 20 61 mov 0x61, %g2
2005784: c4 28 63 04 stb %g2, [ %g1 + 0x304 ]
}
args->iop->data1 = tty;
2005788: c2 06 80 00 ld [ %i2 ], %g1
200578c: fa 20 60 30 st %i5, [ %g1 + 0x30 ]
if (!tty->refcount++) {
2005790: c2 07 60 08 ld [ %i5 + 8 ], %g1
2005794: 84 00 60 01 add %g1, 1, %g2
2005798: 80 a0 60 00 cmp %g1, 0
200579c: 12 80 00 1f bne 2005818 <rtems_termios_open+0x410>
20057a0: c4 27 60 08 st %g2, [ %i5 + 8 ]
if (tty->device.firstOpen)
20057a4: c2 07 60 98 ld [ %i5 + 0x98 ], %g1
20057a8: 80 a0 60 00 cmp %g1, 0
20057ac: 02 80 00 05 be 20057c0 <rtems_termios_open+0x3b8>
20057b0: 90 10 00 18 mov %i0, %o0
(*tty->device.firstOpen)(major, minor, arg);
20057b4: 92 10 00 19 mov %i1, %o1
20057b8: 9f c0 40 00 call %g1
20057bc: 94 10 00 1a mov %i2, %o2
/*
* start I/O tasks, if needed
*/
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
20057c0: c2 07 60 b4 ld [ %i5 + 0xb4 ], %g1
20057c4: 80 a0 60 02 cmp %g1, 2
20057c8: 12 80 00 15 bne 200581c <rtems_termios_open+0x414>
20057cc: 03 00 80 76 sethi %hi(0x201d800), %g1
sc = rtems_task_start(
20057d0: d0 07 60 c4 ld [ %i5 + 0xc4 ], %o0
20057d4: 13 00 80 1b sethi %hi(0x2006c00), %o1
20057d8: 94 10 00 1d mov %i5, %o2
20057dc: 40 00 09 5e call 2007d54 <rtems_task_start>
20057e0: 92 12 61 30 or %o1, 0x130, %o1
tty->rxTaskId, rtems_termios_rxdaemon, (rtems_task_argument)tty);
if (sc != RTEMS_SUCCESSFUL)
20057e4: 80 a2 20 00 cmp %o0, 0
20057e8: 22 80 00 03 be,a 20057f4 <rtems_termios_open+0x3ec> <== ALWAYS TAKEN
20057ec: d0 07 60 c8 ld [ %i5 + 0xc8 ], %o0
20057f0: 30 80 00 08 b,a 2005810 <rtems_termios_open+0x408> <== NOT EXECUTED
rtems_fatal_error_occurred (sc);
sc = rtems_task_start(
20057f4: 13 00 80 14 sethi %hi(0x2005000), %o1
20057f8: 94 10 00 1d mov %i5, %o2
20057fc: 40 00 09 56 call 2007d54 <rtems_task_start>
2005800: 92 12 63 34 or %o1, 0x334, %o1
tty->txTaskId, rtems_termios_txdaemon, (rtems_task_argument)tty);
if (sc != RTEMS_SUCCESSFUL)
2005804: 80 a2 20 00 cmp %o0, 0
2005808: 02 80 00 05 be 200581c <rtems_termios_open+0x414> <== ALWAYS TAKEN
200580c: 03 00 80 76 sethi %hi(0x201d800), %g1
rtems_fatal_error_occurred (sc);
2005810: 40 00 09 fa call 2007ff8 <rtems_fatal_error_occurred>
2005814: 01 00 00 00 nop
}
}
rtems_semaphore_release (rtems_termios_ttyMutex);
2005818: 03 00 80 76 sethi %hi(0x201d800), %g1
200581c: 40 00 08 7c call 2007a0c <rtems_semaphore_release>
2005820: d0 00 61 88 ld [ %g1 + 0x188 ], %o0 ! 201d988 <rtems_termios_ttyMutex>
return RTEMS_SUCCESSFUL;
2005824: 81 c7 e0 08 ret
2005828: 91 e8 00 1c restore %g0, %i4, %o0
static char c = 'a';
/*
* Create a new device
*/
tty = calloc (1, sizeof (struct rtems_termios_tty));
200582c: 7f ff f7 38 call 200350c <calloc>
2005830: 92 10 20 e8 mov 0xe8, %o1
if (tty == NULL) {
2005834: ba 92 20 00 orcc %o0, 0, %i5
2005838: 32 bf ff 0d bne,a 200546c <rtems_termios_open+0x64>
200583c: 03 00 80 73 sethi %hi(0x201cc00), %g1
tty->cbuf = malloc (CBUFSIZE);
if (tty->cbuf == NULL) {
free((void *)(tty->rawOutBuf.theBuf));
free((void *)(tty->rawInBuf.theBuf));
free(tty);
rtems_semaphore_release (rtems_termios_ttyMutex);
2005840: 10 bf ff 2b b 20054ec <rtems_termios_open+0xe4>
2005844: 03 00 80 76 sethi %hi(0x201d800), %g1
rtems_fatal_error_occurred (sc);
}
}
rtems_semaphore_release (rtems_termios_ttyMutex);
return RTEMS_SUCCESSFUL;
}
2005848: b0 10 00 1c mov %i4, %i0 <== NOT EXECUTED
200584c: 81 c7 e0 08 ret <== NOT EXECUTED
2005850: 81 e8 00 00 restore <== NOT EXECUTED
02005e64 <rtems_termios_puts>:
* Send characters to device-specific code
*/
void
rtems_termios_puts (
const void *_buf, size_t len, struct rtems_termios_tty *tty)
{
2005e64: 9d e3 bf a0 save %sp, -96, %sp
const unsigned char *buf = _buf;
unsigned int newHead;
rtems_interrupt_level level;
rtems_status_code sc;
if (tty->device.outputUsesInterrupts == TERMIOS_POLLED) {
2005e68: c2 06 a0 b4 ld [ %i2 + 0xb4 ], %g1
2005e6c: 80 a0 60 00 cmp %g1, 0
2005e70: 12 80 00 08 bne 2005e90 <rtems_termios_puts+0x2c>
2005e74: 92 10 00 18 mov %i0, %o1
(*tty->device.write)(tty->minor, buf, len);
2005e78: c2 06 a0 a4 ld [ %i2 + 0xa4 ], %g1
2005e7c: d0 06 a0 10 ld [ %i2 + 0x10 ], %o0
2005e80: 9f c0 40 00 call %g1
2005e84: 94 10 00 19 mov %i1, %o2
return;
2005e88: 81 c7 e0 08 ret
2005e8c: 81 e8 00 00 restore
}
newHead = tty->rawOutBuf.Head;
2005e90: fa 06 a0 80 ld [ %i2 + 0x80 ], %i5
/*
* Send characters to device-specific code
*/
void
rtems_termios_puts (
2005e94: b2 06 00 19 add %i0, %i1, %i1
* with interrupts enabled.
*/
newHead = (newHead + 1) % tty->rawOutBuf.Size;
rtems_interrupt_disable (level);
while (newHead == tty->rawOutBuf.Tail) {
tty->rawOutBufState = rob_wait;
2005e98: b6 10 20 02 mov 2, %i3
if (tty->device.outputUsesInterrupts == TERMIOS_POLLED) {
(*tty->device.write)(tty->minor, buf, len);
return;
}
newHead = tty->rawOutBuf.Head;
while (len) {
2005e9c: 10 80 00 36 b 2005f74 <rtems_termios_puts+0x110>
2005ea0: a0 10 20 01 mov 1, %l0
* len -= ncopy
*
* To minimize latency, the memcpy should be done
* with interrupts enabled.
*/
newHead = (newHead + 1) % tty->rawOutBuf.Size;
2005ea4: d2 06 a0 88 ld [ %i2 + 0x88 ], %o1
2005ea8: 40 00 4b 26 call 2018b40 <.urem>
2005eac: 90 07 60 01 add %i5, 1, %o0
2005eb0: 10 80 00 0d b 2005ee4 <rtems_termios_puts+0x80>
2005eb4: ba 10 00 08 mov %o0, %i5
rtems_interrupt_disable (level);
while (newHead == tty->rawOutBuf.Tail) {
tty->rawOutBufState = rob_wait;
rtems_interrupt_enable (level);
2005eb8: 7f ff f2 07 call 20026d4 <sparc_enable_interrupts>
2005ebc: 90 10 00 1c mov %i4, %o0
sc = rtems_semaphore_obtain(
2005ec0: d0 06 a0 8c ld [ %i2 + 0x8c ], %o0
2005ec4: 92 10 20 00 clr %o1
2005ec8: 40 00 06 87 call 20078e4 <rtems_semaphore_obtain>
2005ecc: 94 10 20 00 clr %o2
tty->rawOutBuf.Semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
2005ed0: 80 a2 20 00 cmp %o0, 0
2005ed4: 02 80 00 04 be 2005ee4 <rtems_termios_puts+0x80> <== ALWAYS TAKEN
2005ed8: 01 00 00 00 nop
rtems_fatal_error_occurred (sc);
2005edc: 40 00 08 47 call 2007ff8 <rtems_fatal_error_occurred> <== NOT EXECUTED
2005ee0: 01 00 00 00 nop <== NOT EXECUTED
rtems_interrupt_disable (level);
2005ee4: 7f ff f1 f8 call 20026c4 <sparc_disable_interrupts>
2005ee8: 01 00 00 00 nop
2005eec: b8 10 00 08 mov %o0, %i4
* 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) {
2005ef0: c2 06 a0 84 ld [ %i2 + 0x84 ], %g1
2005ef4: 80 a7 40 01 cmp %i5, %g1
2005ef8: 22 bf ff f0 be,a 2005eb8 <rtems_termios_puts+0x54>
2005efc: f6 26 a0 94 st %i3, [ %i2 + 0x94 ]
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++;
2005f00: c2 06 a0 80 ld [ %i2 + 0x80 ], %g1
2005f04: c6 0e 00 00 ldub [ %i0 ], %g3
2005f08: c4 06 a0 7c ld [ %i2 + 0x7c ], %g2
2005f0c: b0 06 20 01 inc %i0
2005f10: c6 28 80 01 stb %g3, [ %g2 + %g1 ]
tty->rawOutBuf.Head = newHead;
if (tty->rawOutBufState == rob_idle) {
2005f14: c2 06 a0 94 ld [ %i2 + 0x94 ], %g1
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
rtems_interrupt_disable (level);
}
tty->rawOutBuf.theBuf[tty->rawOutBuf.Head] = *buf++;
tty->rawOutBuf.Head = newHead;
2005f18: fa 26 a0 80 st %i5, [ %i2 + 0x80 ]
if (tty->rawOutBufState == rob_idle) {
2005f1c: 80 a0 60 00 cmp %g1, 0
2005f20: 12 80 00 13 bne 2005f6c <rtems_termios_puts+0x108>
2005f24: 01 00 00 00 nop
/* check, whether XOFF has been received */
if (!(tty->flow_ctrl & FL_ORCVXOF)) {
2005f28: c2 06 a0 b8 ld [ %i2 + 0xb8 ], %g1
2005f2c: 80 88 60 10 btst 0x10, %g1
2005f30: 12 80 00 0b bne 2005f5c <rtems_termios_puts+0xf8> <== NEVER TAKEN
2005f34: 01 00 00 00 nop
(*tty->device.write)(
tty->minor, &tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail],1);
2005f38: c4 06 a0 84 ld [ %i2 + 0x84 ], %g2
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)(
2005f3c: d2 06 a0 7c ld [ %i2 + 0x7c ], %o1
2005f40: c2 06 a0 a4 ld [ %i2 + 0xa4 ], %g1
2005f44: d0 06 a0 10 ld [ %i2 + 0x10 ], %o0
2005f48: 92 02 40 02 add %o1, %g2, %o1
2005f4c: 9f c0 40 00 call %g1
2005f50: 94 10 20 01 mov 1, %o2
tty->minor, &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;
2005f54: 10 80 00 06 b 2005f6c <rtems_termios_puts+0x108>
2005f58: e0 26 a0 94 st %l0, [ %i2 + 0x94 ]
if (!(tty->flow_ctrl & FL_ORCVXOF)) {
(*tty->device.write)(
tty->minor, &tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail],1);
} else {
/* remember that output has been stopped due to flow ctrl*/
tty->flow_ctrl |= FL_OSTOP;
2005f5c: c2 06 a0 b8 ld [ %i2 + 0xb8 ], %g1 <== NOT EXECUTED
2005f60: 82 10 60 20 or %g1, 0x20, %g1 <== NOT EXECUTED
2005f64: c2 26 a0 b8 st %g1, [ %i2 + 0xb8 ] <== NOT EXECUTED
}
tty->rawOutBufState = rob_busy;
2005f68: e0 26 a0 94 st %l0, [ %i2 + 0x94 ] <== NOT EXECUTED
}
rtems_interrupt_enable (level);
2005f6c: 7f ff f1 da call 20026d4 <sparc_enable_interrupts>
2005f70: 90 10 00 1c mov %i4, %o0
if (tty->device.outputUsesInterrupts == TERMIOS_POLLED) {
(*tty->device.write)(tty->minor, buf, len);
return;
}
newHead = tty->rawOutBuf.Head;
while (len) {
2005f74: 80 a6 00 19 cmp %i0, %i1
2005f78: 12 bf ff cb bne 2005ea4 <rtems_termios_puts+0x40>
2005f7c: 01 00 00 00 nop
2005f80: 81 c7 e0 08 ret
2005f84: 81 e8 00 00 restore
02006678 <rtems_termios_read>:
return RTEMS_SUCCESSFUL;
}
rtems_status_code
rtems_termios_read (void *arg)
{
2006678: 9d e3 bf a0 save %sp, -96, %sp
rtems_libio_rw_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
200667c: c2 06 00 00 ld [ %i0 ], %g1
uint32_t count = args->count;
char *buffer = args->buffer;
2006680: f4 1e 20 10 ldd [ %i0 + 0x10 ], %i2
rtems_status_code
rtems_termios_read (void *arg)
{
rtems_libio_rw_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
2006684: fa 00 60 30 ld [ %g1 + 0x30 ], %i5
return RTEMS_SUCCESSFUL;
}
rtems_status_code
rtems_termios_read (void *arg)
{
2006688: b8 10 00 18 mov %i0, %i4
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);
200668c: d0 07 60 14 ld [ %i5 + 0x14 ], %o0
2006690: 92 10 20 00 clr %o1
2006694: 40 00 04 94 call 20078e4 <rtems_semaphore_obtain>
2006698: 94 10 20 00 clr %o2
if (sc != RTEMS_SUCCESSFUL)
200669c: b0 92 20 00 orcc %o0, 0, %i0
20066a0: 12 80 00 dd bne 2006a14 <rtems_termios_read+0x39c> <== NEVER TAKEN
20066a4: 03 00 80 75 sethi %hi(0x201d400), %g1
return sc;
if (rtems_termios_linesw[tty->t_line].l_read != NULL) {
20066a8: c4 07 60 cc ld [ %i5 + 0xcc ], %g2
20066ac: 85 28 a0 05 sll %g2, 5, %g2
20066b0: 82 10 61 d4 or %g1, 0x1d4, %g1
20066b4: 82 00 40 02 add %g1, %g2, %g1
20066b8: c2 00 60 08 ld [ %g1 + 8 ], %g1
20066bc: 80 a0 60 00 cmp %g1, 0
20066c0: 02 80 00 06 be 20066d8 <rtems_termios_read+0x60>
20066c4: 90 10 00 1d mov %i5, %o0
sc = rtems_termios_linesw[tty->t_line].l_read(tty,args);
20066c8: 9f c0 40 00 call %g1
20066cc: 92 10 00 1c mov %i4, %o1
20066d0: 10 80 00 ce b 2006a08 <rtems_termios_read+0x390>
20066d4: b0 10 00 08 mov %o0, %i0
tty->tty_rcvwakeup = 0;
rtems_semaphore_release (tty->isem);
return sc;
}
if (tty->cindex == tty->ccount) {
20066d8: c4 07 60 24 ld [ %i5 + 0x24 ], %g2
20066dc: c2 07 60 20 ld [ %i5 + 0x20 ], %g1
20066e0: 80 a0 80 01 cmp %g2, %g1
20066e4: 12 80 00 bf bne 20069e0 <rtems_termios_read+0x368> <== NEVER TAKEN
20066e8: 80 a6 e0 00 cmp %i3, 0
tty->cindex = tty->ccount = 0;
tty->read_start_column = tty->column;
20066ec: c2 07 60 28 ld [ %i5 + 0x28 ], %g1
rtems_semaphore_release (tty->isem);
return sc;
}
if (tty->cindex == tty->ccount) {
tty->cindex = tty->ccount = 0;
20066f0: c0 27 60 20 clr [ %i5 + 0x20 ]
tty->read_start_column = tty->column;
20066f4: c2 27 60 2c st %g1, [ %i5 + 0x2c ]
if (tty->device.pollRead != NULL &&
20066f8: c2 07 60 a0 ld [ %i5 + 0xa0 ], %g1
20066fc: 80 a0 60 00 cmp %g1, 0
2006700: 02 80 00 4c be 2006830 <rtems_termios_read+0x1b8>
2006704: c0 27 60 24 clr [ %i5 + 0x24 ]
2006708: c2 07 60 b4 ld [ %i5 + 0xb4 ], %g1
200670c: 80 a0 60 00 cmp %g1, 0
2006710: 32 80 00 49 bne,a 2006834 <rtems_termios_read+0x1bc>
2006714: e0 07 60 74 ld [ %i5 + 0x74 ], %l0
static rtems_status_code
fillBufferPoll (struct rtems_termios_tty *tty)
{
int n;
if (tty->termios.c_lflag & ICANON) {
2006718: c2 07 60 3c ld [ %i5 + 0x3c ], %g1
200671c: 80 88 60 02 btst 2, %g1
2006720: 02 80 00 13 be 200676c <rtems_termios_read+0xf4>
2006724: 01 00 00 00 nop
for (;;) {
n = (*tty->device.pollRead)(tty->minor);
2006728: c2 07 60 a0 ld [ %i5 + 0xa0 ], %g1
200672c: 9f c0 40 00 call %g1
2006730: d0 07 60 10 ld [ %i5 + 0x10 ], %o0
if (n < 0) {
2006734: 80 a2 20 00 cmp %o0, 0
2006738: 16 80 00 06 bge 2006750 <rtems_termios_read+0xd8>
200673c: 90 0a 20 ff and %o0, 0xff, %o0
rtems_task_wake_after (1);
2006740: 40 00 05 a1 call 2007dc4 <rtems_task_wake_after>
2006744: 90 10 20 01 mov 1, %o0
{
int n;
if (tty->termios.c_lflag & ICANON) {
for (;;) {
n = (*tty->device.pollRead)(tty->minor);
2006748: 10 bf ff f9 b 200672c <rtems_termios_read+0xb4>
200674c: c2 07 60 a0 ld [ %i5 + 0xa0 ], %g1
if (n < 0) {
rtems_task_wake_after (1);
} else {
if (siproc (n, tty))
2006750: 7f ff ff 88 call 2006570 <siproc>
2006754: 92 10 00 1d mov %i5, %o1
2006758: 80 a2 20 00 cmp %o0, 0
200675c: 22 bf ff f4 be,a 200672c <rtems_termios_read+0xb4>
2006760: c2 07 60 a0 ld [ %i5 + 0xa0 ], %g1
sc = fillBufferQueue (tty);
if (sc != RTEMS_SUCCESSFUL)
tty->cindex = tty->ccount = 0;
}
while (count && (tty->cindex < tty->ccount)) {
2006764: 10 80 00 9f b 20069e0 <rtems_termios_read+0x368>
2006768: 80 a6 e0 00 cmp %i3, 0
}
}
} else {
rtems_interval then, now;
then = rtems_clock_get_ticks_since_boot();
200676c: 40 00 02 a1 call 20071f0 <rtems_clock_get_ticks_since_boot>
2006770: 01 00 00 00 nop
2006774: b2 10 00 08 mov %o0, %i1
for (;;) {
n = (*tty->device.pollRead)(tty->minor);
2006778: c2 07 60 a0 ld [ %i5 + 0xa0 ], %g1
200677c: 9f c0 40 00 call %g1
2006780: d0 07 60 10 ld [ %i5 + 0x10 ], %o0
if (n < 0) {
2006784: 80 a2 20 00 cmp %o0, 0
2006788: 36 80 00 1c bge,a 20067f8 <rtems_termios_read+0x180>
200678c: 90 0a 20 ff and %o0, 0xff, %o0
if (tty->termios.c_cc[VMIN]) {
2006790: c2 0f 60 47 ldub [ %i5 + 0x47 ], %g1
2006794: 80 a0 60 00 cmp %g1, 0
2006798: 02 80 00 0d be 20067cc <rtems_termios_read+0x154>
200679c: c2 0f 60 46 ldub [ %i5 + 0x46 ], %g1
if (tty->termios.c_cc[VTIME] && tty->ccount) {
20067a0: 80 88 60 ff btst 0xff, %g1
20067a4: 32 80 00 06 bne,a 20067bc <rtems_termios_read+0x144> <== ALWAYS TAKEN
20067a8: c2 07 60 20 ld [ %i5 + 0x20 ], %g1
now = rtems_clock_get_ticks_since_boot();
if ((now - then) > tty->vtimeTicks) {
break;
}
}
rtems_task_wake_after (1);
20067ac: 40 00 05 86 call 2007dc4 <rtems_task_wake_after>
20067b0: 90 10 20 01 mov 1, %o0
} else {
rtems_interval then, now;
then = rtems_clock_get_ticks_since_boot();
for (;;) {
n = (*tty->device.pollRead)(tty->minor);
20067b4: 10 bf ff f2 b 200677c <rtems_termios_read+0x104>
20067b8: c2 07 60 a0 ld [ %i5 + 0xa0 ], %g1
if (n < 0) {
if (tty->termios.c_cc[VMIN]) {
if (tty->termios.c_cc[VTIME] && tty->ccount) {
20067bc: 80 a0 60 00 cmp %g1, 0
20067c0: 02 bf ff fb be 20067ac <rtems_termios_read+0x134>
20067c4: 01 00 00 00 nop
20067c8: 30 80 00 04 b,a 20067d8 <rtems_termios_read+0x160>
if ((now - then) > tty->vtimeTicks) {
break;
}
}
} else {
if (!tty->termios.c_cc[VTIME])
20067cc: 80 88 60 ff btst 0xff, %g1
20067d0: 02 80 00 84 be 20069e0 <rtems_termios_read+0x368> <== NEVER TAKEN
20067d4: 80 a6 e0 00 cmp %i3, 0
break;
now = rtems_clock_get_ticks_since_boot();
20067d8: 40 00 02 86 call 20071f0 <rtems_clock_get_ticks_since_boot>
20067dc: 01 00 00 00 nop
if ((now - then) > tty->vtimeTicks) {
20067e0: c2 07 60 54 ld [ %i5 + 0x54 ], %g1
20067e4: 90 22 00 19 sub %o0, %i1, %o0
20067e8: 80 a2 00 01 cmp %o0, %g1
20067ec: 08 bf ff f0 bleu 20067ac <rtems_termios_read+0x134>
20067f0: 80 a6 e0 00 cmp %i3, 0
20067f4: 30 80 00 7b b,a 20069e0 <rtems_termios_read+0x368>
break;
}
}
rtems_task_wake_after (1);
} else {
siproc (n, tty);
20067f8: 7f ff ff 5e call 2006570 <siproc>
20067fc: 92 10 00 1d mov %i5, %o1
if (tty->ccount >= tty->termios.c_cc[VMIN])
2006800: c2 0f 60 47 ldub [ %i5 + 0x47 ], %g1
2006804: c4 07 60 20 ld [ %i5 + 0x20 ], %g2
2006808: 80 a0 80 01 cmp %g2, %g1
200680c: 16 80 00 74 bge 20069dc <rtems_termios_read+0x364>
2006810: 80 a0 60 00 cmp %g1, 0
break;
if (tty->termios.c_cc[VMIN] && tty->termios.c_cc[VTIME])
2006814: 22 bf ff da be,a 200677c <rtems_termios_read+0x104> <== NEVER TAKEN
2006818: c2 07 60 a0 ld [ %i5 + 0xa0 ], %g1 <== NOT EXECUTED
200681c: c2 0f 60 46 ldub [ %i5 + 0x46 ], %g1
2006820: 80 a0 60 00 cmp %g1, 0
2006824: 22 bf ff d6 be,a 200677c <rtems_termios_read+0x104> <== NEVER TAKEN
2006828: c2 07 60 a0 ld [ %i5 + 0xa0 ], %g1 <== NOT EXECUTED
200682c: 30 bf ff d0 b,a 200676c <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;
2006830: e0 07 60 74 ld [ %i5 + 0x74 ], %l0
rtems_status_code sc;
int wait = 1;
2006834: b2 10 20 01 mov 1, %i1
while ( wait ) {
/*
* Process characters read from raw queue
*/
while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&
(tty->ccount < (CBUFSIZE-1))) {
2006838: 23 00 80 73 sethi %hi(0x201cc00), %l1
== (FL_MDXON | FL_ISNTXOF))
&& ((tty->rawOutBufState == rob_idle)
|| (tty->flow_ctrl & FL_OSTOP))) {
/* XON should be sent now... */
(*tty->device.write)(
tty->minor, (void *)&(tty->termios.c_cc[VSTART]), 1);
200683c: 10 80 00 4b b 2006968 <rtems_termios_read+0x2f0>
2006840: a4 07 60 49 add %i5, 0x49, %l2
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;
2006844: d0 07 60 5c ld [ %i5 + 0x5c ], %o0
2006848: d2 07 60 64 ld [ %i5 + 0x64 ], %o1
200684c: 40 00 48 bd call 2018b40 <.urem>
2006850: 90 02 20 01 inc %o0
c = tty->rawInBuf.theBuf[newHead];
2006854: c2 07 60 58 ld [ %i5 + 0x58 ], %g1
2006858: e0 08 40 08 ldub [ %g1 + %o0 ], %l0
tty->rawInBuf.Head = newHead;
200685c: d0 27 60 5c st %o0, [ %i5 + 0x5c ]
if(((tty->rawInBuf.Tail-newHead+tty->rawInBuf.Size)
2006860: c2 07 60 60 ld [ %i5 + 0x60 ], %g1
2006864: c4 07 60 64 ld [ %i5 + 0x64 ], %g2
% tty->rawInBuf.Size)
2006868: d2 07 60 64 ld [ %i5 + 0x64 ], %o1
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)
200686c: 82 00 80 01 add %g2, %g1, %g1
% tty->rawInBuf.Size)
2006870: 40 00 48 b4 call 2018b40 <.urem>
2006874: 90 20 40 08 sub %g1, %o0, %o0
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)
2006878: c2 07 60 bc ld [ %i5 + 0xbc ], %g1
200687c: 80 a2 00 01 cmp %o0, %g1
2006880: 3a 80 00 27 bcc,a 200691c <rtems_termios_read+0x2a4> <== NEVER TAKEN
2006884: c2 07 60 3c ld [ %i5 + 0x3c ], %g1 <== NOT EXECUTED
% tty->rawInBuf.Size)
< tty->lowwater) {
tty->flow_ctrl &= ~FL_IREQXOF;
2006888: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1
200688c: 82 08 7f fe and %g1, -2, %g1
2006890: c2 27 60 b8 st %g1, [ %i5 + 0xb8 ]
/* if tx stopped and XON should be sent... */
if (((tty->flow_ctrl & (FL_MDXON | FL_ISNTXOF))
2006894: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1
2006898: 82 08 62 02 and %g1, 0x202, %g1
200689c: 80 a0 62 02 cmp %g1, 0x202
20068a0: 12 80 00 11 bne 20068e4 <rtems_termios_read+0x26c> <== ALWAYS TAKEN
20068a4: 01 00 00 00 nop
== (FL_MDXON | FL_ISNTXOF))
&& ((tty->rawOutBufState == rob_idle)
20068a8: c2 07 60 94 ld [ %i5 + 0x94 ], %g1 <== NOT EXECUTED
20068ac: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
20068b0: 22 80 00 07 be,a 20068cc <rtems_termios_read+0x254> <== NOT EXECUTED
20068b4: c2 07 60 a4 ld [ %i5 + 0xa4 ], %g1 <== NOT EXECUTED
|| (tty->flow_ctrl & FL_OSTOP))) {
20068b8: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1 <== NOT EXECUTED
20068bc: 80 88 60 20 btst 0x20, %g1 <== NOT EXECUTED
20068c0: 02 80 00 09 be 20068e4 <rtems_termios_read+0x26c> <== NOT EXECUTED
20068c4: 01 00 00 00 nop <== NOT EXECUTED
/* XON should be sent now... */
(*tty->device.write)(
20068c8: c2 07 60 a4 ld [ %i5 + 0xa4 ], %g1 <== NOT EXECUTED
20068cc: d0 07 60 10 ld [ %i5 + 0x10 ], %o0 <== NOT EXECUTED
20068d0: 92 10 00 12 mov %l2, %o1 <== NOT EXECUTED
20068d4: 9f c0 40 00 call %g1 <== NOT EXECUTED
20068d8: 94 10 20 01 mov 1, %o2 <== NOT EXECUTED
}
}
}
/* continue processing new character */
if (tty->termios.c_lflag & ICANON) {
20068dc: 10 80 00 10 b 200691c <rtems_termios_read+0x2a4> <== NOT EXECUTED
20068e0: c2 07 60 3c ld [ %i5 + 0x3c ], %g1 <== NOT EXECUTED
&& ((tty->rawOutBufState == rob_idle)
|| (tty->flow_ctrl & FL_OSTOP))) {
/* XON should be sent now... */
(*tty->device.write)(
tty->minor, (void *)&(tty->termios.c_cc[VSTART]), 1);
} else if (tty->flow_ctrl & FL_MDRTS) {
20068e4: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1
20068e8: 80 88 61 00 btst 0x100, %g1
20068ec: 22 80 00 0c be,a 200691c <rtems_termios_read+0x2a4> <== ALWAYS TAKEN
20068f0: c2 07 60 3c ld [ %i5 + 0x3c ], %g1
tty->flow_ctrl &= ~FL_IRTSOFF;
20068f4: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1 <== NOT EXECUTED
20068f8: 82 08 7f fb and %g1, -5, %g1 <== NOT EXECUTED
20068fc: c2 27 60 b8 st %g1, [ %i5 + 0xb8 ] <== NOT EXECUTED
/* activate RTS line */
if (tty->device.startRemoteTx != NULL) {
2006900: c2 07 60 b0 ld [ %i5 + 0xb0 ], %g1 <== NOT EXECUTED
2006904: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
2006908: 22 80 00 05 be,a 200691c <rtems_termios_read+0x2a4> <== NOT EXECUTED
200690c: c2 07 60 3c ld [ %i5 + 0x3c ], %g1 <== NOT EXECUTED
tty->device.startRemoteTx(tty->minor);
2006910: 9f c0 40 00 call %g1 <== NOT EXECUTED
2006914: d0 07 60 10 ld [ %i5 + 0x10 ], %o0 <== NOT EXECUTED
}
}
}
/* continue processing new character */
if (tty->termios.c_lflag & ICANON) {
2006918: c2 07 60 3c ld [ %i5 + 0x3c ], %g1 <== NOT EXECUTED
if (siproc (c, tty))
200691c: 92 10 00 1d mov %i5, %o1
}
}
}
/* continue processing new character */
if (tty->termios.c_lflag & ICANON) {
2006920: 80 88 60 02 btst 2, %g1
2006924: 02 80 00 09 be 2006948 <rtems_termios_read+0x2d0> <== NEVER TAKEN
2006928: 90 0c 20 ff and %l0, 0xff, %o0
if (siproc (c, tty))
200692c: 7f ff ff 11 call 2006570 <siproc>
2006930: 01 00 00 00 nop
2006934: 80 a2 20 00 cmp %o0, 0
2006938: 22 80 00 0c be,a 2006968 <rtems_termios_read+0x2f0>
200693c: e0 07 60 70 ld [ %i5 + 0x70 ], %l0
wait = 0;
2006940: 10 80 00 09 b 2006964 <rtems_termios_read+0x2ec>
2006944: b2 10 20 00 clr %i1
} else {
siproc (c, tty);
2006948: 7f ff ff 0a call 2006570 <siproc> <== NOT EXECUTED
200694c: 01 00 00 00 nop <== NOT EXECUTED
if (tty->ccount >= tty->termios.c_cc[VMIN])
2006950: c2 0f 60 47 ldub [ %i5 + 0x47 ], %g1 <== NOT EXECUTED
2006954: c4 07 60 20 ld [ %i5 + 0x20 ], %g2 <== NOT EXECUTED
2006958: 80 a0 80 01 cmp %g2, %g1 <== NOT EXECUTED
200695c: 36 80 00 02 bge,a 2006964 <rtems_termios_read+0x2ec> <== NOT EXECUTED
2006960: b2 10 20 00 clr %i1 <== NOT EXECUTED
wait = 0;
}
timeout = tty->rawInBufSemaphoreTimeout;
2006964: e0 07 60 70 ld [ %i5 + 0x70 ], %l0
while ( wait ) {
/*
* Process characters read from raw queue
*/
while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&
2006968: c4 07 60 5c ld [ %i5 + 0x5c ], %g2
200696c: c2 07 60 60 ld [ %i5 + 0x60 ], %g1
2006970: 80 a0 80 01 cmp %g2, %g1
2006974: 12 80 00 07 bne 2006990 <rtems_termios_read+0x318>
2006978: c2 04 63 00 ld [ %l1 + 0x300 ], %g1
}
/*
* Wait for characters
*/
if ( wait ) {
200697c: 80 a6 60 00 cmp %i1, 0
2006980: 02 80 00 18 be 20069e0 <rtems_termios_read+0x368>
2006984: 80 a6 e0 00 cmp %i3, 0
sc = rtems_semaphore_obtain(
2006988: 10 80 00 08 b 20069a8 <rtems_termios_read+0x330>
200698c: d0 07 60 68 ld [ %i5 + 0x68 ], %o0
while ( wait ) {
/*
* Process characters read from raw queue
*/
while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&
2006990: c4 07 60 20 ld [ %i5 + 0x20 ], %g2
(tty->ccount < (CBUFSIZE-1))) {
2006994: 82 00 7f ff add %g1, -1, %g1
while ( wait ) {
/*
* Process characters read from raw queue
*/
while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&
2006998: 80 a0 80 01 cmp %g2, %g1
200699c: 0a bf ff aa bcs 2006844 <rtems_termios_read+0x1cc> <== ALWAYS TAKEN
20069a0: 80 a6 60 00 cmp %i1, 0
20069a4: 30 bf ff f7 b,a 2006980 <rtems_termios_read+0x308> <== NOT EXECUTED
/*
* Wait for characters
*/
if ( wait ) {
sc = rtems_semaphore_obtain(
20069a8: d2 07 60 6c ld [ %i5 + 0x6c ], %o1
20069ac: 40 00 03 ce call 20078e4 <rtems_semaphore_obtain>
20069b0: 94 10 00 10 mov %l0, %o2
tty->rawInBuf.Semaphore, tty->rawInBufSemaphoreOptions, timeout);
if (sc != RTEMS_SUCCESSFUL)
20069b4: 80 a2 20 00 cmp %o0, 0
20069b8: 02 bf ff ec be 2006968 <rtems_termios_read+0x2f0> <== ALWAYS TAKEN
20069bc: 80 a6 e0 00 cmp %i3, 0
20069c0: 30 80 00 08 b,a 20069e0 <rtems_termios_read+0x368> <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
tty->cindex = tty->ccount = 0;
}
while (count && (tty->cindex < tty->ccount)) {
*buffer++ = tty->cbuf[tty->cindex++];
count--;
20069c4: b6 06 ff ff add %i3, -1, %i3
if (sc != RTEMS_SUCCESSFUL)
tty->cindex = tty->ccount = 0;
}
while (count && (tty->cindex < tty->ccount)) {
*buffer++ = tty->cbuf[tty->cindex++];
20069c8: c4 08 80 01 ldub [ %g2 + %g1 ], %g2
20069cc: 82 00 60 01 inc %g1
20069d0: c4 2e 80 00 stb %g2, [ %i2 ]
20069d4: c2 27 60 24 st %g1, [ %i5 + 0x24 ]
20069d8: b4 06 a0 01 inc %i2
sc = fillBufferQueue (tty);
if (sc != RTEMS_SUCCESSFUL)
tty->cindex = tty->ccount = 0;
}
while (count && (tty->cindex < tty->ccount)) {
20069dc: 80 a6 e0 00 cmp %i3, 0
20069e0: 22 80 00 08 be,a 2006a00 <rtems_termios_read+0x388>
20069e4: c2 07 20 14 ld [ %i4 + 0x14 ], %g1
20069e8: c2 07 60 24 ld [ %i5 + 0x24 ], %g1
20069ec: c4 07 60 20 ld [ %i5 + 0x20 ], %g2
20069f0: 80 a0 40 02 cmp %g1, %g2
20069f4: 26 bf ff f4 bl,a 20069c4 <rtems_termios_read+0x34c>
20069f8: c4 07 60 1c ld [ %i5 + 0x1c ], %g2
*buffer++ = tty->cbuf[tty->cindex++];
count--;
}
args->bytes_moved = args->count - count;
20069fc: c2 07 20 14 ld [ %i4 + 0x14 ], %g1
2006a00: b6 20 40 1b sub %g1, %i3, %i3
2006a04: f6 27 20 1c st %i3, [ %i4 + 0x1c ]
tty->tty_rcvwakeup = 0;
rtems_semaphore_release (tty->isem);
2006a08: d0 07 60 14 ld [ %i5 + 0x14 ], %o0
2006a0c: 40 00 04 00 call 2007a0c <rtems_semaphore_release>
2006a10: c0 27 60 e4 clr [ %i5 + 0xe4 ]
return sc;
}
2006a14: 81 c7 e0 08 ret
2006a18: 81 e8 00 00 restore
02005150 <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
*/
static int
rtems_termios_refill_transmitter (struct rtems_termios_tty *tty)
{
2005150: 9d e3 bf a0 save %sp, -96, %sp
int nToSend;
rtems_interrupt_level level;
int len;
/* check for XOF/XON to send */
if ((tty->flow_ctrl & (FL_MDXOF | FL_IREQXOF | FL_ISNTXOF))
2005154: c2 06 20 b8 ld [ %i0 + 0xb8 ], %g1
2005158: 82 08 64 03 and %g1, 0x403, %g1
200515c: 80 a0 64 01 cmp %g1, 0x401
2005160: 12 80 00 0f bne 200519c <rtems_termios_refill_transmitter+0x4c><== ALWAYS TAKEN
2005164: ba 10 00 18 mov %i0, %i5
== (FL_MDXOF | FL_IREQXOF)) {
/* XOFF should be sent now... */
(*tty->device.write)(tty->minor, (void *)&(tty->termios.c_cc[VSTOP]), 1);
2005168: c2 06 20 a4 ld [ %i0 + 0xa4 ], %g1 <== NOT EXECUTED
200516c: d0 06 20 10 ld [ %i0 + 0x10 ], %o0 <== NOT EXECUTED
2005170: 92 06 20 4a add %i0, 0x4a, %o1 <== NOT EXECUTED
2005174: 9f c0 40 00 call %g1 <== NOT EXECUTED
2005178: 94 10 20 01 mov 1, %o2 <== NOT EXECUTED
rtems_interrupt_disable(level);
200517c: 7f ff f5 52 call 20026c4 <sparc_disable_interrupts> <== NOT EXECUTED
2005180: 01 00 00 00 nop <== NOT EXECUTED
tty->t_dqlen--;
2005184: c2 06 20 90 ld [ %i0 + 0x90 ], %g1 <== NOT EXECUTED
2005188: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED
200518c: c2 26 20 90 st %g1, [ %i0 + 0x90 ] <== NOT EXECUTED
tty->flow_ctrl |= FL_ISNTXOF;
2005190: c2 06 20 b8 ld [ %i0 + 0xb8 ], %g1 <== NOT EXECUTED
2005194: 10 80 00 12 b 20051dc <rtems_termios_refill_transmitter+0x8c><== NOT EXECUTED
2005198: 82 10 60 02 or %g1, 2, %g1 <== NOT EXECUTED
rtems_interrupt_enable(level);
nToSend = 1;
} else if ((tty->flow_ctrl & (FL_IREQXOF | FL_ISNTXOF)) == FL_ISNTXOF) {
200519c: c2 06 20 b8 ld [ %i0 + 0xb8 ], %g1
20051a0: 82 08 60 03 and %g1, 3, %g1
20051a4: 80 a0 60 02 cmp %g1, 2
20051a8: 12 80 00 12 bne 20051f0 <rtems_termios_refill_transmitter+0xa0><== ALWAYS TAKEN
20051ac: 92 06 20 49 add %i0, 0x49, %o1
* 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);
20051b0: c2 06 20 a4 ld [ %i0 + 0xa4 ], %g1 <== NOT EXECUTED
20051b4: d0 06 20 10 ld [ %i0 + 0x10 ], %o0 <== NOT EXECUTED
20051b8: 9f c0 40 00 call %g1 <== NOT EXECUTED
20051bc: 94 10 20 01 mov 1, %o2 <== NOT EXECUTED
rtems_interrupt_disable(level);
20051c0: 7f ff f5 41 call 20026c4 <sparc_disable_interrupts> <== NOT EXECUTED
20051c4: 01 00 00 00 nop <== NOT EXECUTED
tty->t_dqlen--;
20051c8: c2 06 20 90 ld [ %i0 + 0x90 ], %g1 <== NOT EXECUTED
20051cc: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED
20051d0: c2 26 20 90 st %g1, [ %i0 + 0x90 ] <== NOT EXECUTED
tty->flow_ctrl &= ~FL_ISNTXOF;
20051d4: c2 06 20 b8 ld [ %i0 + 0xb8 ], %g1 <== NOT EXECUTED
20051d8: 82 08 7f fd and %g1, -3, %g1 <== NOT EXECUTED
20051dc: c2 27 60 b8 st %g1, [ %i5 + 0xb8 ] <== NOT EXECUTED
rtems_interrupt_enable(level);
20051e0: 7f ff f5 3d call 20026d4 <sparc_enable_interrupts> <== NOT EXECUTED
20051e4: b0 10 20 01 mov 1, %i0 <== NOT EXECUTED
20051e8: 81 c7 e0 08 ret
20051ec: 81 e8 00 00 restore
nToSend = 1;
} else {
if ( tty->rawOutBuf.Head == tty->rawOutBuf.Tail ) {
20051f0: c4 06 20 80 ld [ %i0 + 0x80 ], %g2
20051f4: c2 06 20 84 ld [ %i0 + 0x84 ], %g1
20051f8: 80 a0 80 01 cmp %g2, %g1
20051fc: 12 80 00 0a bne 2005224 <rtems_termios_refill_transmitter+0xd4>
2005200: 01 00 00 00 nop
/*
* buffer was empty
*/
if (tty->rawOutBufState == rob_wait) {
2005204: c2 06 20 94 ld [ %i0 + 0x94 ], %g1
2005208: 80 a0 60 02 cmp %g1, 2
200520c: 12 bf ff f7 bne 20051e8 <rtems_termios_refill_transmitter+0x98><== ALWAYS TAKEN
2005210: b0 10 20 00 clr %i0
/*
* this should never happen...
*/
rtems_semaphore_release (tty->rawOutBuf.Semaphore);
2005214: 40 00 09 fe call 2007a0c <rtems_semaphore_release> <== NOT EXECUTED
2005218: d0 07 60 8c ld [ %i5 + 0x8c ], %o0 <== NOT EXECUTED
200521c: 81 c7 e0 08 ret <== NOT EXECUTED
2005220: 81 e8 00 00 restore <== NOT EXECUTED
}
return 0;
}
rtems_interrupt_disable(level);
2005224: 7f ff f5 28 call 20026c4 <sparc_disable_interrupts>
2005228: 01 00 00 00 nop
len = tty->t_dqlen;
200522c: f8 06 20 90 ld [ %i0 + 0x90 ], %i4
tty->t_dqlen = 0;
2005230: c0 26 20 90 clr [ %i0 + 0x90 ]
rtems_interrupt_enable(level);
2005234: 7f ff f5 28 call 20026d4 <sparc_enable_interrupts>
2005238: 01 00 00 00 nop
newTail = (tty->rawOutBuf.Tail + len) % tty->rawOutBuf.Size;
200523c: d0 06 20 84 ld [ %i0 + 0x84 ], %o0
2005240: d2 06 20 88 ld [ %i0 + 0x88 ], %o1
2005244: 40 00 4e 3f call 2018b40 <.urem>
2005248: 90 07 00 08 add %i4, %o0, %o0
tty->rawOutBuf.Tail = newTail;
if (tty->rawOutBufState == rob_wait) {
200524c: c2 06 20 94 ld [ %i0 + 0x94 ], %g1
len = tty->t_dqlen;
tty->t_dqlen = 0;
rtems_interrupt_enable(level);
newTail = (tty->rawOutBuf.Tail + len) % tty->rawOutBuf.Size;
tty->rawOutBuf.Tail = newTail;
2005250: d0 27 60 84 st %o0, [ %i5 + 0x84 ]
if (tty->rawOutBufState == rob_wait) {
2005254: 80 a0 60 02 cmp %g1, 2
2005258: 12 80 00 04 bne 2005268 <rtems_termios_refill_transmitter+0x118>
200525c: b8 10 00 08 mov %o0, %i4
/*
* wake up any pending writer task
*/
rtems_semaphore_release (tty->rawOutBuf.Semaphore);
2005260: 40 00 09 eb call 2007a0c <rtems_semaphore_release>
2005264: d0 06 20 8c ld [ %i0 + 0x8c ], %o0
}
if (newTail == tty->rawOutBuf.Head) {
2005268: c2 07 60 80 ld [ %i5 + 0x80 ], %g1
200526c: 80 a7 00 01 cmp %i4, %g1
2005270: 12 80 00 0b bne 200529c <rtems_termios_refill_transmitter+0x14c>
2005274: 01 00 00 00 nop
nToSend = 0;
/*
* check to see if snd wakeup callback was set
*/
if ( tty->tty_snd.sw_pfn != NULL) {
2005278: c2 07 60 d4 ld [ %i5 + 0xd4 ], %g1
if (newTail == tty->rawOutBuf.Head) {
/*
* Buffer has become empty
*/
tty->rawOutBufState = rob_idle;
200527c: c0 27 60 94 clr [ %i5 + 0x94 ]
nToSend = 0;
/*
* check to see if snd wakeup callback was set
*/
if ( tty->tty_snd.sw_pfn != NULL) {
2005280: 80 a0 60 00 cmp %g1, 0
2005284: 02 80 00 29 be 2005328 <rtems_termios_refill_transmitter+0x1d8><== ALWAYS TAKEN
2005288: b0 10 20 00 clr %i0
(*tty->tty_snd.sw_pfn)(&tty->termios, tty->tty_snd.sw_arg);
200528c: d2 07 60 d8 ld [ %i5 + 0xd8 ], %o1 <== NOT EXECUTED
2005290: 9f c0 40 00 call %g1 <== NOT EXECUTED
2005294: 90 07 60 30 add %i5, 0x30, %o0 <== NOT EXECUTED
2005298: 30 80 00 24 b,a 2005328 <rtems_termios_refill_transmitter+0x1d8><== NOT EXECUTED
}
}
/* check, whether output should stop due to received XOFF */
else if ((tty->flow_ctrl & (FL_MDXON | FL_ORCVXOF))
200529c: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1
20052a0: 82 08 62 10 and %g1, 0x210, %g1
20052a4: 80 a0 62 10 cmp %g1, 0x210
20052a8: 12 80 00 0c bne 20052d8 <rtems_termios_refill_transmitter+0x188><== ALWAYS TAKEN
20052ac: 01 00 00 00 nop
== (FL_MDXON | FL_ORCVXOF)) {
/* Buffer not empty, but output stops due to XOFF */
/* set flag, that output has been stopped */
rtems_interrupt_disable(level);
20052b0: 7f ff f5 05 call 20026c4 <sparc_disable_interrupts> <== NOT EXECUTED
20052b4: 01 00 00 00 nop <== NOT EXECUTED
tty->flow_ctrl |= FL_OSTOP;
20052b8: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1 <== NOT EXECUTED
20052bc: 82 10 60 20 or %g1, 0x20, %g1 <== NOT EXECUTED
20052c0: c2 27 60 b8 st %g1, [ %i5 + 0xb8 ] <== NOT EXECUTED
tty->rawOutBufState = rob_busy; /*apm*/
20052c4: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED
20052c8: c2 27 60 94 st %g1, [ %i5 + 0x94 ] <== NOT EXECUTED
rtems_interrupt_enable(level);
20052cc: 7f ff f5 02 call 20026d4 <sparc_enable_interrupts> <== NOT EXECUTED
20052d0: b0 10 20 00 clr %i0 <== NOT EXECUTED
20052d4: 30 80 00 15 b,a 2005328 <rtems_termios_refill_transmitter+0x1d8><== NOT EXECUTED
nToSend = 0;
} else {
/*
* Buffer not empty, start tranmitter
*/
if (newTail > tty->rawOutBuf.Head)
20052d8: c2 07 60 80 ld [ %i5 + 0x80 ], %g1
20052dc: 80 a7 00 01 cmp %i4, %g1
20052e0: 08 80 00 04 bleu 20052f0 <rtems_termios_refill_transmitter+0x1a0>
20052e4: 01 00 00 00 nop
nToSend = tty->rawOutBuf.Size - newTail;
20052e8: f0 07 60 88 ld [ %i5 + 0x88 ], %i0
20052ec: 30 80 00 02 b,a 20052f4 <rtems_termios_refill_transmitter+0x1a4>
else
nToSend = tty->rawOutBuf.Head - newTail;
20052f0: f0 07 60 80 ld [ %i5 + 0x80 ], %i0
/* 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)) {
20052f4: c2 07 60 b8 ld [ %i5 + 0xb8 ], %g1
20052f8: 80 88 66 00 btst 0x600, %g1
20052fc: 02 80 00 03 be 2005308 <rtems_termios_refill_transmitter+0x1b8>
2005300: b0 26 00 1c sub %i0, %i4, %i0
nToSend = 1;
2005304: b0 10 20 01 mov 1, %i0
}
tty->rawOutBufState = rob_busy; /*apm*/
2005308: 82 10 20 01 mov 1, %g1
(*tty->device.write)(
200530c: d2 07 60 7c ld [ %i5 + 0x7c ], %o1
/* 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*/
2005310: c2 27 60 94 st %g1, [ %i5 + 0x94 ]
(*tty->device.write)(
2005314: d0 07 60 10 ld [ %i5 + 0x10 ], %o0
2005318: c2 07 60 a4 ld [ %i5 + 0xa4 ], %g1
200531c: 92 02 40 1c add %o1, %i4, %o1
2005320: 9f c0 40 00 call %g1
2005324: 94 10 00 18 mov %i0, %o2
tty->minor, &tty->rawOutBuf.theBuf[newTail], nToSend);
}
tty->rawOutBuf.Tail = newTail; /*apm*/
2005328: f8 27 60 84 st %i4, [ %i5 + 0x84 ]
}
return nToSend;
}
200532c: 81 c7 e0 08 ret
2005330: 81 e8 00 00 restore
02006d30 <rtems_termios_rxdaemon>:
/*
* this task actually processes any receive events
*/
static rtems_task rtems_termios_rxdaemon(rtems_task_argument argument)
{
2006d30: 9d e3 bf 98 save %sp, -104, %sp
while (1) {
/*
* wait for rtems event
*/
rtems_event_receive(
2006d34: 90 10 20 03 mov 3, %o0
2006d38: 92 10 20 02 mov 2, %o1
2006d3c: 94 10 20 00 clr %o2
2006d40: 40 00 01 4f call 200727c <rtems_event_receive>
2006d44: 96 07 bf fc add %fp, -4, %o3
(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) {
2006d48: c2 07 bf fc ld [ %fp + -4 ], %g1
2006d4c: 80 88 60 01 btst 1, %g1
2006d50: 22 80 00 06 be,a 2006d68 <rtems_termios_rxdaemon+0x38> <== ALWAYS TAKEN
2006d54: c2 06 20 a0 ld [ %i0 + 0xa0 ], %g1
tty->rxTaskId = 0;
2006d58: c0 26 20 c4 clr [ %i0 + 0xc4 ] <== NOT EXECUTED
rtems_task_delete(RTEMS_SELF);
2006d5c: 40 00 03 a3 call 2007be8 <rtems_task_delete> <== NOT EXECUTED
2006d60: 90 10 20 00 clr %o0 <== NOT EXECUTED
}
/*
* do something
*/
c = tty->device.pollRead(tty->minor);
2006d64: c2 06 20 a0 ld [ %i0 + 0xa0 ], %g1 <== NOT EXECUTED
2006d68: 9f c0 40 00 call %g1
2006d6c: d0 06 20 10 ld [ %i0 + 0x10 ], %o0
if (c != EOF) {
2006d70: 80 a2 3f ff cmp %o0, -1
2006d74: 22 bf ff f1 be,a 2006d38 <rtems_termios_rxdaemon+0x8>
2006d78: 90 10 20 03 mov 3, %o0
/*
* pollRead did call enqueue on its own
*/
c_buf = c;
2006d7c: d0 2f bf fb stb %o0, [ %fp + -5 ]
rtems_termios_enqueue_raw_characters ( tty,&c_buf,1);
2006d80: 92 07 bf fb add %fp, -5, %o1
2006d84: 90 10 00 18 mov %i0, %o0
2006d88: 7f ff ff 2a call 2006a30 <rtems_termios_enqueue_raw_characters>
2006d8c: 94 10 20 01 mov 1, %o2
while (1) {
/*
* wait for rtems event
*/
rtems_event_receive(
2006d90: 10 bf ff ea b 2006d38 <rtems_termios_rxdaemon+0x8>
2006d94: 90 10 20 03 mov 3, %o0
02005334 <rtems_termios_txdaemon>:
/*
* this task actually processes any transmit events
*/
static rtems_task rtems_termios_txdaemon(rtems_task_argument argument)
{
2005334: 9d e3 bf 98 save %sp, -104, %sp
}
/*
* call any line discipline start function
*/
if (rtems_termios_linesw[tty->t_line].l_start != NULL) {
2005338: 3b 00 80 75 sethi %hi(0x201d400), %i5
200533c: ba 17 61 d4 or %i5, 0x1d4, %i5 ! 201d5d4 <rtems_termios_linesw>
while (1) {
/*
* wait for rtems event
*/
rtems_event_receive(
2005340: 90 10 20 03 mov 3, %o0
2005344: 92 10 20 02 mov 2, %o1
2005348: 94 10 20 00 clr %o2
200534c: 40 00 07 cc call 200727c <rtems_event_receive>
2005350: 96 07 bf fc add %fp, -4, %o3
(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) {
2005354: c2 07 bf fc ld [ %fp + -4 ], %g1
2005358: 80 88 60 01 btst 1, %g1
200535c: 22 80 00 06 be,a 2005374 <rtems_termios_txdaemon+0x40> <== ALWAYS TAKEN
2005360: c2 06 20 cc ld [ %i0 + 0xcc ], %g1
tty->txTaskId = 0;
2005364: c0 26 20 c8 clr [ %i0 + 0xc8 ] <== NOT EXECUTED
rtems_task_delete(RTEMS_SELF);
2005368: 40 00 0a 20 call 2007be8 <rtems_task_delete> <== NOT EXECUTED
200536c: 90 10 20 00 clr %o0 <== NOT EXECUTED
}
/*
* call any line discipline start function
*/
if (rtems_termios_linesw[tty->t_line].l_start != NULL) {
2005370: c2 06 20 cc ld [ %i0 + 0xcc ], %g1 <== NOT EXECUTED
2005374: 83 28 60 05 sll %g1, 5, %g1
2005378: 82 07 40 01 add %i5, %g1, %g1
200537c: c2 00 60 14 ld [ %g1 + 0x14 ], %g1
2005380: 80 a0 60 00 cmp %g1, 0
2005384: 02 80 00 04 be 2005394 <rtems_termios_txdaemon+0x60> <== ALWAYS TAKEN
2005388: 01 00 00 00 nop
rtems_termios_linesw[tty->t_line].l_start(tty);
200538c: 9f c0 40 00 call %g1 <== NOT EXECUTED
2005390: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
}
/*
* try to push further characters to device
*/
rtems_termios_refill_transmitter(tty);
2005394: 7f ff ff 6f call 2005150 <rtems_termios_refill_transmitter>
2005398: 90 10 00 18 mov %i0, %o0
}
200539c: 10 bf ff ea b 2005344 <rtems_termios_txdaemon+0x10>
20053a0: 90 10 20 03 mov 3, %o0
020065b8 <rtems_termios_write>:
rtems_termios_puts (&c, 1, tty);
}
rtems_status_code
rtems_termios_write (void *arg)
{
20065b8: 9d e3 bf a0 save %sp, -96, %sp
rtems_libio_rw_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
20065bc: c2 06 00 00 ld [ %i0 ], %g1
rtems_termios_puts (&c, 1, tty);
}
rtems_status_code
rtems_termios_write (void *arg)
{
20065c0: b8 10 00 18 mov %i0, %i4
rtems_libio_rw_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
20065c4: fa 00 60 30 ld [ %g1 + 0x30 ], %i5
rtems_status_code sc;
sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
20065c8: 92 10 20 00 clr %o1
20065cc: d0 07 60 18 ld [ %i5 + 0x18 ], %o0
20065d0: 40 00 04 c5 call 20078e4 <rtems_semaphore_obtain>
20065d4: 94 10 20 00 clr %o2
if (sc != RTEMS_SUCCESSFUL)
20065d8: b0 92 20 00 orcc %o0, 0, %i0
20065dc: 12 80 00 25 bne 2006670 <rtems_termios_write+0xb8> <== NEVER TAKEN
20065e0: 03 00 80 75 sethi %hi(0x201d400), %g1
return sc;
if (rtems_termios_linesw[tty->t_line].l_write != NULL) {
20065e4: c4 07 60 cc ld [ %i5 + 0xcc ], %g2
20065e8: 85 28 a0 05 sll %g2, 5, %g2
20065ec: 82 10 61 d4 or %g1, 0x1d4, %g1
20065f0: 82 00 40 02 add %g1, %g2, %g1
20065f4: c2 00 60 0c ld [ %g1 + 0xc ], %g1
20065f8: 80 a0 60 00 cmp %g1, 0
20065fc: 02 80 00 06 be 2006614 <rtems_termios_write+0x5c>
2006600: 90 10 00 1d mov %i5, %o0
sc = rtems_termios_linesw[tty->t_line].l_write(tty,args);
2006604: 9f c0 40 00 call %g1
2006608: 92 10 00 1c mov %i4, %o1
200660c: 10 80 00 17 b 2006668 <rtems_termios_write+0xb0>
2006610: b0 10 00 08 mov %o0, %i0
rtems_semaphore_release (tty->osem);
return sc;
}
if (tty->termios.c_oflag & OPOST) {
2006614: c2 07 60 34 ld [ %i5 + 0x34 ], %g1
uint32_t count = args->count;
char *buffer = args->buffer;
while (count--)
2006618: b6 10 20 00 clr %i3
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) {
200661c: 80 88 60 01 btst 1, %g1
2006620: f4 07 20 14 ld [ %i4 + 0x14 ], %i2
2006624: 12 80 00 07 bne 2006640 <rtems_termios_write+0x88> <== ALWAYS TAKEN
2006628: f2 07 20 10 ld [ %i4 + 0x10 ], %i1
char *buffer = args->buffer;
while (count--)
oproc (*buffer++, tty);
args->bytes_moved = args->count;
} else {
rtems_termios_puts (args->buffer, args->count, tty);
200662c: 10 80 00 0a b 2006654 <rtems_termios_write+0x9c> <== NOT EXECUTED
2006630: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
}
if (tty->termios.c_oflag & OPOST) {
uint32_t count = args->count;
char *buffer = args->buffer;
while (count--)
oproc (*buffer++, tty);
2006634: 92 10 00 1d mov %i5, %o1
2006638: 7f ff fe 54 call 2005f88 <oproc>
200663c: b6 06 e0 01 inc %i3
return sc;
}
if (tty->termios.c_oflag & OPOST) {
uint32_t count = args->count;
char *buffer = args->buffer;
while (count--)
2006640: 80 a6 c0 1a cmp %i3, %i2
2006644: 32 bf ff fc bne,a 2006634 <rtems_termios_write+0x7c>
2006648: d0 0e 40 1b ldub [ %i1 + %i3 ], %o0
oproc (*buffer++, tty);
args->bytes_moved = args->count;
} else {
rtems_termios_puts (args->buffer, args->count, tty);
args->bytes_moved = args->count;
200664c: 10 80 00 06 b 2006664 <rtems_termios_write+0xac>
2006650: c2 07 20 14 ld [ %i4 + 0x14 ], %g1
char *buffer = args->buffer;
while (count--)
oproc (*buffer++, tty);
args->bytes_moved = args->count;
} else {
rtems_termios_puts (args->buffer, args->count, tty);
2006654: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED
2006658: 7f ff fe 03 call 2005e64 <rtems_termios_puts> <== NOT EXECUTED
200665c: 94 10 00 1d mov %i5, %o2 <== NOT EXECUTED
args->bytes_moved = args->count;
2006660: c2 07 20 14 ld [ %i4 + 0x14 ], %g1 <== NOT EXECUTED
2006664: c2 27 20 1c st %g1, [ %i4 + 0x1c ]
}
rtems_semaphore_release (tty->osem);
2006668: 40 00 04 e9 call 2007a0c <rtems_semaphore_release>
200666c: d0 07 60 18 ld [ %i5 + 0x18 ], %o0
return sc;
}
2006670: 81 c7 e0 08 ret
2006674: 81 e8 00 00 restore
0201844c <rtems_timer_cancel>:
*/
rtems_status_code rtems_timer_cancel(
rtems_id id
)
{
201844c: 9d e3 bf 98 save %sp, -104, %sp
RTEMS_INLINE_ROUTINE Timer_Control *_Timer_Get (
Objects_Id id,
Objects_Locations *location
)
{
return (Timer_Control *)
2018450: 11 00 80 f5 sethi %hi(0x203d400), %o0
2018454: 92 10 00 18 mov %i0, %o1
2018458: 90 12 22 e4 or %o0, 0x2e4, %o0
201845c: 40 00 0c 36 call 201b534 <_Objects_Get>
2018460: 94 07 bf fc add %fp, -4, %o2
Timer_Control *the_timer;
Objects_Locations location;
the_timer = _Timer_Get( id, &location );
switch ( location ) {
2018464: c2 07 bf fc ld [ %fp + -4 ], %g1
2018468: 80 a0 60 00 cmp %g1, 0
201846c: 12 80 00 0c bne 201849c <rtems_timer_cancel+0x50>
2018470: 01 00 00 00 nop
case OBJECTS_LOCAL:
if ( !_Timer_Is_dormant_class( the_timer->the_class ) )
2018474: c2 02 20 38 ld [ %o0 + 0x38 ], %g1
2018478: 80 a0 60 04 cmp %g1, 4
201847c: 02 80 00 04 be 201848c <rtems_timer_cancel+0x40> <== NEVER TAKEN
2018480: 01 00 00 00 nop
(void) _Watchdog_Remove( &the_timer->Ticker );
2018484: 40 00 14 35 call 201d558 <_Watchdog_Remove>
2018488: 90 02 20 10 add %o0, 0x10, %o0
_Thread_Enable_dispatch();
201848c: 40 00 10 00 call 201c48c <_Thread_Enable_dispatch>
2018490: b0 10 20 00 clr %i0
2018494: 81 c7 e0 08 ret
2018498: 81 e8 00 00 restore
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
201849c: 81 c7 e0 08 ret
20184a0: 91 e8 20 04 restore %g0, 4, %o0
02018960 <rtems_timer_server_fire_when>:
rtems_id id,
rtems_time_of_day *wall_time,
rtems_timer_service_routine_entry routine,
void *user_data
)
{
2018960: 9d e3 bf 98 save %sp, -104, %sp
Timer_Control *the_timer;
Objects_Locations location;
rtems_interval seconds;
Timer_server_Control *timer_server = _Timer_server;
2018964: 03 00 80 f5 sethi %hi(0x203d400), %g1
2018968: f8 00 63 24 ld [ %g1 + 0x324 ], %i4 ! 203d724 <_Timer_server>
if ( !timer_server )
201896c: 80 a7 20 00 cmp %i4, 0
2018970: 02 80 00 3c be 2018a60 <rtems_timer_server_fire_when+0x100>
2018974: 82 10 20 0e mov 0xe, %g1
return RTEMS_INCORRECT_STATE;
if ( !_TOD.is_set )
2018978: 21 00 80 f3 sethi %hi(0x203cc00), %l0
201897c: 82 14 20 b8 or %l0, 0xb8, %g1 ! 203ccb8 <_TOD>
2018980: c4 08 60 14 ldub [ %g1 + 0x14 ], %g2
2018984: 80 a0 a0 00 cmp %g2, 0
2018988: 02 80 00 36 be 2018a60 <rtems_timer_server_fire_when+0x100><== NEVER TAKEN
201898c: 82 10 20 0b mov 0xb, %g1
return RTEMS_NOT_DEFINED;
if ( !routine )
2018990: 80 a6 a0 00 cmp %i2, 0
2018994: 02 80 00 33 be 2018a60 <rtems_timer_server_fire_when+0x100>
2018998: 82 10 20 09 mov 9, %g1
return RTEMS_INVALID_ADDRESS;
if ( !_TOD_Validate( wall_time ) )
201899c: 7f ff f3 82 call 20157a4 <_TOD_Validate>
20189a0: 90 10 00 19 mov %i1, %o0
20189a4: 80 8a 20 ff btst 0xff, %o0
20189a8: 02 80 00 2e be 2018a60 <rtems_timer_server_fire_when+0x100>
20189ac: 82 10 20 14 mov 0x14, %g1
return RTEMS_INVALID_CLOCK;
seconds = _TOD_To_seconds( wall_time );
20189b0: 7f ff f3 43 call 20156bc <_TOD_To_seconds>
20189b4: 90 10 00 19 mov %i1, %o0
20189b8: b2 10 00 08 mov %o0, %i1
20189bc: d0 1c 20 b8 ldd [ %l0 + 0xb8 ], %o0
20189c0: 94 10 20 00 clr %o2
20189c4: 17 0e e6 b2 sethi %hi(0x3b9ac800), %o3
20189c8: 40 00 50 11 call 202ca0c <__divdi3>
20189cc: 96 12 e2 00 or %o3, 0x200, %o3 ! 3b9aca00 <RAM_END+0x395aca00>
if ( seconds <= _TOD_Seconds_since_epoch() )
20189d0: 80 a6 40 09 cmp %i1, %o1
20189d4: 08 80 00 23 bleu 2018a60 <rtems_timer_server_fire_when+0x100>
20189d8: 82 10 20 14 mov 0x14, %g1
20189dc: 11 00 80 f5 sethi %hi(0x203d400), %o0
20189e0: 92 10 00 18 mov %i0, %o1
20189e4: 90 12 22 e4 or %o0, 0x2e4, %o0
20189e8: 40 00 0a d3 call 201b534 <_Objects_Get>
20189ec: 94 07 bf fc add %fp, -4, %o2
return RTEMS_INVALID_CLOCK;
the_timer = _Timer_Get( id, &location );
switch ( location ) {
20189f0: c2 07 bf fc ld [ %fp + -4 ], %g1
20189f4: 80 a0 60 00 cmp %g1, 0
20189f8: 12 80 00 19 bne 2018a5c <rtems_timer_server_fire_when+0xfc>
20189fc: ba 10 00 08 mov %o0, %i5
case OBJECTS_LOCAL:
(void) _Watchdog_Remove( &the_timer->Ticker );
2018a00: 40 00 12 d6 call 201d558 <_Watchdog_Remove>
2018a04: 90 02 20 10 add %o0, 0x10, %o0
2018a08: d0 1c 20 b8 ldd [ %l0 + 0xb8 ], %o0
the_timer->the_class = TIMER_TIME_OF_DAY_ON_TASK;
2018a0c: 82 10 20 03 mov 3, %g1
2018a10: 94 10 20 00 clr %o2
2018a14: c2 27 60 38 st %g1, [ %i5 + 0x38 ]
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
2018a18: c0 27 60 18 clr [ %i5 + 0x18 ]
the_watchdog->routine = routine;
2018a1c: f4 27 60 2c st %i2, [ %i5 + 0x2c ]
the_watchdog->id = id;
2018a20: f0 27 60 30 st %i0, [ %i5 + 0x30 ]
the_watchdog->user_data = user_data;
2018a24: f6 27 60 34 st %i3, [ %i5 + 0x34 ]
2018a28: 17 0e e6 b2 sethi %hi(0x3b9ac800), %o3
2018a2c: 40 00 4f f8 call 202ca0c <__divdi3>
2018a30: 96 12 e2 00 or %o3, 0x200, %o3 ! 3b9aca00 <RAM_END+0x395aca00>
_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 );
2018a34: c2 07 20 04 ld [ %i4 + 4 ], %g1
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();
2018a38: 92 26 40 09 sub %i1, %o1, %o1
(*timer_server->schedule_operation)( timer_server, the_timer );
2018a3c: 90 10 00 1c mov %i4, %o0
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();
2018a40: d2 27 60 1c st %o1, [ %i5 + 0x1c ]
(*timer_server->schedule_operation)( timer_server, the_timer );
2018a44: 9f c0 40 00 call %g1
2018a48: 92 10 00 1d mov %i5, %o1
_Thread_Enable_dispatch();
2018a4c: 40 00 0e 90 call 201c48c <_Thread_Enable_dispatch>
2018a50: 01 00 00 00 nop
return RTEMS_SUCCESSFUL;
2018a54: 10 80 00 03 b 2018a60 <rtems_timer_server_fire_when+0x100>
2018a58: 82 10 20 00 clr %g1 ! 0 <PROM_START>
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
2018a5c: 82 10 20 04 mov 4, %g1
}
2018a60: 81 c7 e0 08 ret
2018a64: 91 e8 00 01 restore %g0, %g1, %o0
02003580 <rtems_verror>:
static int rtems_verror(
rtems_error_code_t error_flag,
const char *printf_format,
va_list arglist
)
{
2003580: 9d e3 bf a0 save %sp, -96, %sp
int local_errno = 0;
int chars_written = 0;
rtems_status_code status;
if (error_flag & RTEMS_ERROR_PANIC) {
2003584: 03 08 00 00 sethi %hi(0x20000000), %g1
2003588: 80 8e 00 01 btst %i0, %g1
200358c: 12 80 00 0e bne 20035c4 <rtems_verror+0x44>
2003590: ba 10 00 18 mov %i0, %i5
/* don't aggravate things */
if (rtems_panic_in_progress > 2)
return 0;
}
(void) fflush(stdout); /* in case stdout/stderr same */
2003594: 03 00 80 74 sethi %hi(0x201d000), %g1
2003598: c2 00 60 68 ld [ %g1 + 0x68 ], %g1 ! 201d068 <_impure_ptr>
status = error_flag & ~RTEMS_ERROR_MASK;
200359c: 39 1c 00 00 sethi %hi(0x70000000), %i4
/* don't aggravate things */
if (rtems_panic_in_progress > 2)
return 0;
}
(void) fflush(stdout); /* in case stdout/stderr same */
20035a0: d0 00 60 08 ld [ %g1 + 8 ], %o0
20035a4: 40 00 32 1e call 200fe1c <fflush>
20035a8: b8 2f 40 1c andn %i5, %i4, %i4
status = error_flag & ~RTEMS_ERROR_MASK;
if (error_flag & RTEMS_ERROR_ERRNO) /* include errno? */
20035ac: 03 10 00 00 sethi %hi(0x40000000), %g1
20035b0: 80 8f 40 01 btst %i5, %g1
20035b4: 12 80 00 16 bne 200360c <rtems_verror+0x8c>
20035b8: ba 10 20 00 clr %i5
#if defined(RTEMS_MULTIPROCESSING)
if (_System_state_Is_multiprocessing)
fprintf(stderr, "[%" PRIu32 "] ", _Configuration_MP_table->node);
#endif
chars_written += vfprintf(stderr, printf_format, arglist);
20035bc: 10 80 00 18 b 200361c <rtems_verror+0x9c>
20035c0: 37 00 80 74 sethi %hi(0x201d000), %i3
int local_errno = 0;
int chars_written = 0;
rtems_status_code status;
if (error_flag & RTEMS_ERROR_PANIC) {
if (rtems_panic_in_progress++)
20035c4: 05 00 80 76 sethi %hi(0x201d800), %g2
20035c8: c2 00 a1 3c ld [ %g2 + 0x13c ], %g1 ! 201d93c <rtems_panic_in_progress>
20035cc: 86 00 60 01 add %g1, 1, %g3
20035d0: 80 a0 60 00 cmp %g1, 0
20035d4: 02 80 00 07 be 20035f0 <rtems_verror+0x70> <== ALWAYS TAKEN
20035d8: c6 20 a1 3c st %g3, [ %g2 + 0x13c ]
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
_Thread_Dispatch_disable_level++;
20035dc: 03 00 80 76 sethi %hi(0x201d800), %g1 <== NOT EXECUTED
20035e0: c4 00 62 e0 ld [ %g1 + 0x2e0 ], %g2 ! 201dae0 <_Thread_Dispatch_disable_level><== NOT EXECUTED
20035e4: 84 00 a0 01 inc %g2 <== NOT EXECUTED
20035e8: c4 20 62 e0 st %g2, [ %g1 + 0x2e0 ] <== NOT EXECUTED
return _Thread_Dispatch_disable_level;
20035ec: c2 00 62 e0 ld [ %g1 + 0x2e0 ], %g1 <== NOT EXECUTED
_Thread_Disable_dispatch(); /* disable task switches */
/* don't aggravate things */
if (rtems_panic_in_progress > 2)
20035f0: 03 00 80 76 sethi %hi(0x201d800), %g1
20035f4: c2 00 61 3c ld [ %g1 + 0x13c ], %g1 ! 201d93c <rtems_panic_in_progress>
20035f8: 80 a0 60 02 cmp %g1, 2
20035fc: 04 bf ff e6 ble 2003594 <rtems_verror+0x14> <== ALWAYS TAKEN
2003600: b0 10 20 00 clr %i0
2003604: 81 c7 e0 08 ret <== NOT EXECUTED
2003608: 81 e8 00 00 restore <== NOT EXECUTED
(void) fflush(stdout); /* in case stdout/stderr same */
status = error_flag & ~RTEMS_ERROR_MASK;
if (error_flag & RTEMS_ERROR_ERRNO) /* include errno? */
local_errno = errno;
200360c: 40 00 31 01 call 200fa10 <__errno>
2003610: 01 00 00 00 nop
2003614: fa 02 00 00 ld [ %o0 ], %i5
#if defined(RTEMS_MULTIPROCESSING)
if (_System_state_Is_multiprocessing)
fprintf(stderr, "[%" PRIu32 "] ", _Configuration_MP_table->node);
#endif
chars_written += vfprintf(stderr, printf_format, arglist);
2003618: 37 00 80 74 sethi %hi(0x201d000), %i3
200361c: c2 06 e0 68 ld [ %i3 + 0x68 ], %g1 ! 201d068 <_impure_ptr>
2003620: 92 10 00 19 mov %i1, %o1
2003624: d0 00 60 0c ld [ %g1 + 0xc ], %o0
2003628: 40 00 46 32 call 2014ef0 <vfprintf>
200362c: 94 10 00 1a mov %i2, %o2
if (status)
2003630: 80 a7 20 00 cmp %i4, 0
2003634: 02 80 00 0c be 2003664 <rtems_verror+0xe4>
2003638: b0 10 00 08 mov %o0, %i0
chars_written +=
fprintf(stderr, " (status: %s)", rtems_status_text(status));
200363c: c2 06 e0 68 ld [ %i3 + 0x68 ], %g1
2003640: 90 10 00 1c mov %i4, %o0
2003644: 7f ff ff c9 call 2003568 <rtems_status_text>
2003648: f6 00 60 0c ld [ %g1 + 0xc ], %i3
200364c: 13 00 80 6c sethi %hi(0x201b000), %o1
2003650: 94 10 00 08 mov %o0, %o2
2003654: 92 12 61 e8 or %o1, 0x1e8, %o1
2003658: 40 00 32 e3 call 20101e4 <fprintf>
200365c: 90 10 00 1b mov %i3, %o0
#endif
chars_written += vfprintf(stderr, printf_format, arglist);
if (status)
chars_written +=
2003660: b0 06 00 08 add %i0, %o0, %i0
fprintf(stderr, " (status: %s)", rtems_status_text(status));
if (local_errno) {
2003664: 80 a7 60 00 cmp %i5, 0
2003668: 22 80 00 1c be,a 20036d8 <rtems_verror+0x158>
200366c: 3b 00 80 74 sethi %hi(0x201d000), %i5
if ((local_errno > 0) && *strerror(local_errno))
2003670: 80 a7 60 00 cmp %i5, 0
2003674: 04 80 00 11 ble 20036b8 <rtems_verror+0x138>
2003678: 03 00 80 74 sethi %hi(0x201d000), %g1
200367c: 40 00 36 5a call 2010fe4 <strerror>
2003680: 90 10 00 1d mov %i5, %o0
2003684: c2 4a 00 00 ldsb [ %o0 ], %g1
2003688: 80 a0 60 00 cmp %g1, 0
200368c: 02 80 00 0b be 20036b8 <rtems_verror+0x138> <== NEVER TAKEN
2003690: 03 00 80 74 sethi %hi(0x201d000), %g1
chars_written += fprintf(stderr, " (errno: %s)", strerror(local_errno));
2003694: c2 00 60 68 ld [ %g1 + 0x68 ], %g1 ! 201d068 <_impure_ptr>
2003698: 90 10 00 1d mov %i5, %o0
200369c: 40 00 36 52 call 2010fe4 <strerror>
20036a0: f8 00 60 0c ld [ %g1 + 0xc ], %i4
20036a4: 13 00 80 6c sethi %hi(0x201b000), %o1
20036a8: 94 10 00 08 mov %o0, %o2
20036ac: 92 12 61 f8 or %o1, 0x1f8, %o1
20036b0: 10 80 00 07 b 20036cc <rtems_verror+0x14c>
20036b4: 90 10 00 1c mov %i4, %o0
else
chars_written += fprintf(stderr, " (unknown errno=%d)", local_errno);
20036b8: c2 00 60 68 ld [ %g1 + 0x68 ], %g1
20036bc: 13 00 80 6c sethi %hi(0x201b000), %o1
20036c0: d0 00 60 0c ld [ %g1 + 0xc ], %o0
20036c4: 92 12 62 08 or %o1, 0x208, %o1
20036c8: 94 10 00 1d mov %i5, %o2
20036cc: 40 00 32 c6 call 20101e4 <fprintf>
20036d0: 3b 00 80 74 sethi %hi(0x201d000), %i5
20036d4: b0 06 00 08 add %i0, %o0, %i0
}
chars_written += fprintf(stderr, "\n");
20036d8: c2 07 60 68 ld [ %i5 + 0x68 ], %g1
20036dc: 13 00 80 6c sethi %hi(0x201b000), %o1
20036e0: d0 00 60 0c ld [ %g1 + 0xc ], %o0
20036e4: 40 00 32 c0 call 20101e4 <fprintf>
20036e8: 92 12 60 40 or %o1, 0x40, %o1
(void) fflush(stderr);
20036ec: c2 07 60 68 ld [ %i5 + 0x68 ], %g1
chars_written += fprintf(stderr, " (errno: %s)", strerror(local_errno));
else
chars_written += fprintf(stderr, " (unknown errno=%d)", local_errno);
}
chars_written += fprintf(stderr, "\n");
20036f0: b0 06 00 08 add %i0, %o0, %i0
(void) fflush(stderr);
20036f4: 40 00 31 ca call 200fe1c <fflush>
20036f8: d0 00 60 0c ld [ %g1 + 0xc ], %o0
return chars_written;
}
20036fc: 81 c7 e0 08 ret
2003700: 81 e8 00 00 restore
020280f8 <scanInt>:
/*
* Extract an integer value from the database
*/
static int
scanInt(FILE *fp, int *val)
{
20280f8: 9d e3 bf a0 save %sp, -96, %sp
int c;
unsigned int i = 0;
unsigned int limit = INT_MAX;
20280fc: 37 1f ff ff sethi %hi(0x7ffffc00), %i3
int sign = 0;
2028100: b8 10 20 00 clr %i4
static int
scanInt(FILE *fp, int *val)
{
int c;
unsigned int i = 0;
unsigned int limit = INT_MAX;
2028104: b6 16 e3 ff or %i3, 0x3ff, %i3
*/
static int
scanInt(FILE *fp, int *val)
{
int c;
unsigned int i = 0;
2028108: ba 10 20 00 clr %i5
unsigned int limit = INT_MAX;
int sign = 0;
int d;
for (;;) {
c = getc(fp);
202810c: 21 00 81 af sethi %hi(0x206bc00), %l0
limit++;
continue;
}
sign = 1;
}
if (!isdigit(c))
2028110: 23 00 81 af sethi %hi(0x206bc00), %l1
unsigned int limit = INT_MAX;
int sign = 0;
int d;
for (;;) {
c = getc(fp);
2028114: c2 06 20 04 ld [ %i0 + 4 ], %g1
2028118: 82 00 7f ff add %g1, -1, %g1
202811c: 80 a0 60 00 cmp %g1, 0
2028120: 16 80 00 07 bge 202813c <scanInt+0x44> <== ALWAYS TAKEN
2028124: c2 26 20 04 st %g1, [ %i0 + 4 ]
2028128: d0 04 21 e0 ld [ %l0 + 0x1e0 ], %o0 <== NOT EXECUTED
202812c: 40 00 7e 97 call 2047b88 <__srget_r> <== NOT EXECUTED
2028130: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
if (c == ':')
2028134: 10 80 00 07 b 2028150 <scanInt+0x58> <== NOT EXECUTED
2028138: 80 a2 20 3a cmp %o0, 0x3a <== NOT EXECUTED
unsigned int limit = INT_MAX;
int sign = 0;
int d;
for (;;) {
c = getc(fp);
202813c: c4 06 00 00 ld [ %i0 ], %g2
2028140: d0 08 80 00 ldub [ %g2 ], %o0
2028144: 84 00 a0 01 inc %g2
2028148: c4 26 00 00 st %g2, [ %i0 ]
if (c == ':')
202814c: 80 a2 20 3a cmp %o0, 0x3a
2028150: 02 80 00 21 be 20281d4 <scanInt+0xdc>
2028154: 80 a7 20 00 cmp %i4, 0
break;
if (sign == 0) {
2028158: 12 80 00 08 bne 2028178 <scanInt+0x80>
202815c: c4 04 61 d0 ld [ %l1 + 0x1d0 ], %g2
if (c == '-') {
2028160: 80 a2 20 2d cmp %o0, 0x2d
2028164: 12 80 00 05 bne 2028178 <scanInt+0x80>
2028168: b8 10 20 01 mov 1, %i4
sign = -1;
limit++;
202816c: b6 06 e0 01 inc %i3
continue;
2028170: 10 bf ff e9 b 2028114 <scanInt+0x1c>
2028174: b8 10 3f ff mov -1, %i4
}
sign = 1;
}
if (!isdigit(c))
2028178: 84 00 80 08 add %g2, %o0, %g2
202817c: c4 08 a0 01 ldub [ %g2 + 1 ], %g2
2028180: 80 88 a0 04 btst 4, %g2
2028184: 02 80 00 1d be 20281f8 <scanInt+0x100>
2028188: b4 02 3f d0 add %o0, -48, %i2
return 0;
d = c - '0';
if ((i > (limit / 10))
202818c: 92 10 20 0a mov 0xa, %o1
2028190: 40 00 cc fc call 205b580 <.udiv>
2028194: 90 10 00 1b mov %i3, %o0
2028198: 80 a7 40 08 cmp %i5, %o0
202819c: 38 80 00 15 bgu,a 20281f0 <scanInt+0xf8>
20281a0: b0 10 20 00 clr %i0
|| ((i == (limit / 10)) && (d > (limit % 10))))
20281a4: 12 80 00 08 bne 20281c4 <scanInt+0xcc>
20281a8: 83 2f 60 01 sll %i5, 1, %g1
20281ac: 90 10 00 1b mov %i3, %o0
20281b0: 40 00 cd a0 call 205b830 <.urem>
20281b4: 92 10 20 0a mov 0xa, %o1
20281b8: 80 a6 80 08 cmp %i2, %o0
20281bc: 18 80 00 0f bgu 20281f8 <scanInt+0x100> <== ALWAYS TAKEN
20281c0: 83 2f 60 01 sll %i5, 1, %g1
return 0;
i = i * 10 + d;
20281c4: bb 2f 60 03 sll %i5, 3, %i5
20281c8: ba 00 40 1d add %g1, %i5, %i5
20281cc: 10 bf ff d2 b 2028114 <scanInt+0x1c>
20281d0: ba 06 80 1d add %i2, %i5, %i5
}
if (sign == 0)
20281d4: 02 80 00 07 be 20281f0 <scanInt+0xf8> <== NEVER TAKEN
20281d8: b0 10 20 00 clr %i0
return 0;
*val = i * sign;
20281dc: 90 10 00 1c mov %i4, %o0
20281e0: 92 10 00 1d mov %i5, %o1
20281e4: 7f ff 6b 20 call 2002e64 <.umul>
20281e8: b0 10 20 01 mov 1, %i0
20281ec: d0 26 40 00 st %o0, [ %i1 ]
return 1;
20281f0: 81 c7 e0 08 ret
20281f4: 81 e8 00 00 restore
continue;
}
sign = 1;
}
if (!isdigit(c))
return 0;
20281f8: b0 10 20 00 clr %i0
}
if (sign == 0)
return 0;
*val = i * sign;
return 1;
}
20281fc: 81 c7 e0 08 ret
2028200: 81 e8 00 00 restore
020282f4 <scangr>:
FILE *fp,
struct group *grp,
char *buffer,
size_t bufsize
)
{
20282f4: 9d e3 bf 98 save %sp, -104, %sp
int grgid;
char *grmem, *cp;
int memcount;
if (!scanString(fp, &grp->gr_name, &buffer, &bufsize, 0)
20282f8: 98 10 20 00 clr %o4
FILE *fp,
struct group *grp,
char *buffer,
size_t bufsize
)
{
20282fc: f4 27 a0 4c st %i2, [ %fp + 0x4c ]
2028300: f6 27 a0 50 st %i3, [ %fp + 0x50 ]
int grgid;
char *grmem, *cp;
int memcount;
if (!scanString(fp, &grp->gr_name, &buffer, &bufsize, 0)
2028304: 90 10 00 18 mov %i0, %o0
2028308: 92 10 00 19 mov %i1, %o1
202830c: 94 07 a0 4c add %fp, 0x4c, %o2
2028310: 7f ff ff bd call 2028204 <scanString>
2028314: 96 07 a0 50 add %fp, 0x50, %o3
2028318: 80 a2 20 00 cmp %o0, 0
202831c: 12 80 00 04 bne 202832c <scangr+0x38>
2028320: 90 10 00 18 mov %i0, %o0
|| !scanString(fp, &grp->gr_passwd, &buffer, &bufsize, 0)
|| !scanInt(fp, &grgid)
|| !scanString(fp, &grmem, &buffer, &bufsize, 1))
return 0;
2028324: 81 c7 e0 08 ret
2028328: 91 e8 20 00 restore %g0, 0, %o0
int grgid;
char *grmem, *cp;
int memcount;
if (!scanString(fp, &grp->gr_name, &buffer, &bufsize, 0)
|| !scanString(fp, &grp->gr_passwd, &buffer, &bufsize, 0)
202832c: 92 06 60 04 add %i1, 4, %o1
2028330: 94 07 a0 4c add %fp, 0x4c, %o2
2028334: 96 07 a0 50 add %fp, 0x50, %o3
2028338: 7f ff ff b3 call 2028204 <scanString>
202833c: 98 10 20 00 clr %o4
2028340: 80 a2 20 00 cmp %o0, 0
2028344: 02 bf ff f8 be 2028324 <scangr+0x30> <== NEVER TAKEN
2028348: 90 10 00 18 mov %i0, %o0
|| !scanInt(fp, &grgid)
202834c: 7f ff ff 6b call 20280f8 <scanInt>
2028350: 92 07 bf f8 add %fp, -8, %o1
2028354: 80 a2 20 00 cmp %o0, 0
2028358: 02 bf ff f3 be 2028324 <scangr+0x30> <== NEVER TAKEN
202835c: 90 10 00 18 mov %i0, %o0
|| !scanString(fp, &grmem, &buffer, &bufsize, 1))
2028360: 92 07 bf fc add %fp, -4, %o1
2028364: 94 07 a0 4c add %fp, 0x4c, %o2
2028368: 96 07 a0 50 add %fp, 0x50, %o3
202836c: 7f ff ff a6 call 2028204 <scanString>
2028370: 98 10 20 01 mov 1, %o4
2028374: 80 a2 20 00 cmp %o0, 0
2028378: 02 bf ff eb be 2028324 <scangr+0x30> <== NEVER TAKEN
202837c: c2 07 bf f8 ld [ %fp + -8 ], %g1
grp->gr_gid = grgid;
/*
* Determine number of members
*/
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
2028380: c6 07 bf fc ld [ %fp + -4 ], %g3
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;
2028384: c2 36 60 08 sth %g1, [ %i1 + 8 ]
/*
* Determine number of members
*/
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
2028388: 84 10 00 03 mov %g3, %g2
202838c: 10 80 00 05 b 20283a0 <scangr+0xac>
2028390: 82 10 20 01 mov 1, %g1
2028394: 84 00 a0 01 inc %g2
if(*cp == ',')
memcount++;
2028398: 80 a0 00 04 cmp %g0, %g4
202839c: 82 60 7f ff subx %g1, -1, %g1
grp->gr_gid = grgid;
/*
* Determine number of members
*/
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
20283a0: c8 48 80 00 ldsb [ %g2 ], %g4
20283a4: 80 a1 20 00 cmp %g4, 0
20283a8: 32 bf ff fb bne,a 2028394 <scangr+0xa0>
20283ac: 88 19 20 2c xor %g4, 0x2c, %g4
}
/*
* Hack to produce (hopefully) a suitably-aligned array of pointers
*/
if (bufsize < (((memcount+1)*sizeof(char *)) + 15))
20283b0: c4 07 a0 50 ld [ %fp + 0x50 ], %g2
20283b4: 83 28 60 02 sll %g1, 2, %g1
20283b8: 82 00 60 13 add %g1, 0x13, %g1
20283bc: 80 a0 80 01 cmp %g2, %g1
20283c0: 0a bf ff d9 bcs 2028324 <scangr+0x30> <== NEVER TAKEN
20283c4: c2 07 a0 4c ld [ %fp + 0x4c ], %g1
/*
* Fill in pointer array
*/
grp->gr_mem[0] = grmem;
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
20283c8: 84 10 20 01 mov 1, %g2
/*
* Hack to produce (hopefully) a suitably-aligned array of pointers
*/
if (bufsize < (((memcount+1)*sizeof(char *)) + 15))
return 0;
grp->gr_mem = (char **)(((uintptr_t)buffer + 15) & ~15);
20283cc: 82 00 60 0f add %g1, 0xf, %g1
20283d0: 82 08 7f f0 and %g1, -16, %g1
20283d4: c2 26 60 0c st %g1, [ %i1 + 0xc ]
/*
* Fill in pointer array
*/
grp->gr_mem[0] = grmem;
20283d8: c6 20 40 00 st %g3, [ %g1 ]
}
/*
* Extract a single group record from the database
*/
static int scangr(
20283dc: c2 07 bf fc ld [ %fp + -4 ], %g1
/*
* Fill in pointer array
*/
grp->gr_mem[0] = grmem;
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
20283e0: 10 80 00 0a b 2028408 <scangr+0x114>
20283e4: 82 00 60 01 inc %g1
if(*cp == ',') {
20283e8: 32 80 00 08 bne,a 2028408 <scangr+0x114>
20283ec: 82 00 60 01 inc %g1
*cp = '\0';
20283f0: c0 28 7f ff clrb [ %g1 + -1 ]
grp->gr_mem[memcount++] = cp + 1;
20283f4: c8 06 60 0c ld [ %i1 + 0xc ], %g4
20283f8: 87 28 a0 02 sll %g2, 2, %g3
20283fc: 84 00 a0 01 inc %g2
2028400: c2 21 00 03 st %g1, [ %g4 + %g3 ]
2028404: 82 00 60 01 inc %g1
/*
* Fill in pointer array
*/
grp->gr_mem[0] = grmem;
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
2028408: c6 48 7f ff ldsb [ %g1 + -1 ], %g3
202840c: 80 a0 e0 00 cmp %g3, 0
2028410: 32 bf ff f6 bne,a 20283e8 <scangr+0xf4>
2028414: 80 a0 e0 2c cmp %g3, 0x2c
if(*cp == ',') {
*cp = '\0';
grp->gr_mem[memcount++] = cp + 1;
}
}
grp->gr_mem[memcount] = NULL;
2028418: c2 06 60 0c ld [ %i1 + 0xc ], %g1
202841c: 85 28 a0 02 sll %g2, 2, %g2
2028420: c0 20 40 02 clr [ %g1 + %g2 ]
return 1;
}
2028424: 81 c7 e0 08 ret
2028428: 91 e8 20 01 restore %g0, 1, %o0
0202842c <scanpw>:
FILE *fp,
struct passwd *pwd,
char *buffer,
size_t bufsize
)
{
202842c: 9d e3 bf 98 save %sp, -104, %sp
int pwuid, pwgid;
if (!scanString(fp, &pwd->pw_name, &buffer, &bufsize, 0)
2028430: 98 10 20 00 clr %o4
FILE *fp,
struct passwd *pwd,
char *buffer,
size_t bufsize
)
{
2028434: f4 27 a0 4c st %i2, [ %fp + 0x4c ]
2028438: f6 27 a0 50 st %i3, [ %fp + 0x50 ]
int pwuid, pwgid;
if (!scanString(fp, &pwd->pw_name, &buffer, &bufsize, 0)
202843c: 90 10 00 18 mov %i0, %o0
2028440: 92 10 00 19 mov %i1, %o1
2028444: 94 07 a0 4c add %fp, 0x4c, %o2
2028448: 7f ff ff 6f call 2028204 <scanString>
202844c: 96 07 a0 50 add %fp, 0x50, %o3
2028450: 80 a2 20 00 cmp %o0, 0
2028454: 12 80 00 04 bne 2028464 <scanpw+0x38>
2028458: 90 10 00 18 mov %i0, %o0
|| !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;
202845c: 81 c7 e0 08 ret
2028460: 91 e8 20 00 restore %g0, 0, %o0
)
{
int pwuid, pwgid;
if (!scanString(fp, &pwd->pw_name, &buffer, &bufsize, 0)
|| !scanString(fp, &pwd->pw_passwd, &buffer, &bufsize, 0)
2028464: 92 06 60 04 add %i1, 4, %o1
2028468: 94 07 a0 4c add %fp, 0x4c, %o2
202846c: 96 07 a0 50 add %fp, 0x50, %o3
2028470: 7f ff ff 65 call 2028204 <scanString>
2028474: 98 10 20 00 clr %o4
2028478: 80 a2 20 00 cmp %o0, 0
202847c: 02 bf ff f8 be 202845c <scanpw+0x30> <== NEVER TAKEN
2028480: 90 10 00 18 mov %i0, %o0
|| !scanInt(fp, &pwuid)
2028484: 7f ff ff 1d call 20280f8 <scanInt>
2028488: 92 07 bf f8 add %fp, -8, %o1
202848c: 80 a2 20 00 cmp %o0, 0
2028490: 02 bf ff f3 be 202845c <scanpw+0x30>
2028494: 90 10 00 18 mov %i0, %o0
|| !scanInt(fp, &pwgid)
2028498: 7f ff ff 18 call 20280f8 <scanInt>
202849c: 92 07 bf fc add %fp, -4, %o1
20284a0: 80 a2 20 00 cmp %o0, 0
20284a4: 02 bf ff ee be 202845c <scanpw+0x30>
20284a8: 90 10 00 18 mov %i0, %o0
|| !scanString(fp, &pwd->pw_comment, &buffer, &bufsize, 0)
20284ac: 92 06 60 0c add %i1, 0xc, %o1
20284b0: 94 07 a0 4c add %fp, 0x4c, %o2
20284b4: 96 07 a0 50 add %fp, 0x50, %o3
20284b8: 7f ff ff 53 call 2028204 <scanString>
20284bc: 98 10 20 00 clr %o4
20284c0: 80 a2 20 00 cmp %o0, 0
20284c4: 02 bf ff e6 be 202845c <scanpw+0x30> <== NEVER TAKEN
20284c8: 90 10 00 18 mov %i0, %o0
|| !scanString(fp, &pwd->pw_gecos, &buffer, &bufsize, 0)
20284cc: 92 06 60 10 add %i1, 0x10, %o1
20284d0: 94 07 a0 4c add %fp, 0x4c, %o2
20284d4: 96 07 a0 50 add %fp, 0x50, %o3
20284d8: 7f ff ff 4b call 2028204 <scanString>
20284dc: 98 10 20 00 clr %o4
20284e0: 80 a2 20 00 cmp %o0, 0
20284e4: 02 bf ff de be 202845c <scanpw+0x30> <== NEVER TAKEN
20284e8: 90 10 00 18 mov %i0, %o0
|| !scanString(fp, &pwd->pw_dir, &buffer, &bufsize, 0)
20284ec: 92 06 60 14 add %i1, 0x14, %o1
20284f0: 94 07 a0 4c add %fp, 0x4c, %o2
20284f4: 96 07 a0 50 add %fp, 0x50, %o3
20284f8: 7f ff ff 43 call 2028204 <scanString>
20284fc: 98 10 20 00 clr %o4
2028500: 80 a2 20 00 cmp %o0, 0
2028504: 02 bf ff d6 be 202845c <scanpw+0x30> <== NEVER TAKEN
2028508: 90 10 00 18 mov %i0, %o0
|| !scanString(fp, &pwd->pw_shell, &buffer, &bufsize, 1))
202850c: 92 06 60 18 add %i1, 0x18, %o1
2028510: 94 07 a0 4c add %fp, 0x4c, %o2
2028514: 96 07 a0 50 add %fp, 0x50, %o3
2028518: 7f ff ff 3b call 2028204 <scanString>
202851c: 98 10 20 01 mov 1, %o4
2028520: 80 a2 20 00 cmp %o0, 0
2028524: 02 bf ff ce be 202845c <scanpw+0x30>
2028528: c2 07 bf f8 ld [ %fp + -8 ], %g1
return 0;
pwd->pw_uid = pwuid;
202852c: c2 36 60 08 sth %g1, [ %i1 + 8 ]
pwd->pw_gid = pwgid;
2028530: c2 07 bf fc ld [ %fp + -4 ], %g1
2028534: c2 36 60 0a sth %g1, [ %i1 + 0xa ]
return 1;
}
2028538: 81 c7 e0 08 ret
202853c: 91 e8 20 01 restore %g0, 1, %o0
02007f20 <sched_get_priority_max>:
#include <rtems/posix/priority.h>
int sched_get_priority_max(
int policy
)
{
2007f20: 9d e3 bf a0 save %sp, -96, %sp
switch ( policy ) {
2007f24: 80 a6 20 04 cmp %i0, 4
2007f28: 18 80 00 06 bgu 2007f40 <sched_get_priority_max+0x20>
2007f2c: 82 10 20 01 mov 1, %g1
2007f30: b1 28 40 18 sll %g1, %i0, %i0
2007f34: 80 8e 20 17 btst 0x17, %i0
2007f38: 12 80 00 08 bne 2007f58 <sched_get_priority_max+0x38> <== ALWAYS TAKEN
2007f3c: 03 00 80 86 sethi %hi(0x2021800), %g1
case SCHED_RR:
case SCHED_SPORADIC:
break;
default:
rtems_set_errno_and_return_minus_one( EINVAL );
2007f40: 40 00 21 86 call 2010558 <__errno>
2007f44: b0 10 3f ff mov -1, %i0
2007f48: 82 10 20 16 mov 0x16, %g1
2007f4c: c2 22 00 00 st %g1, [ %o0 ]
2007f50: 81 c7 e0 08 ret
2007f54: 81 e8 00 00 restore
}
return POSIX_SCHEDULER_MAXIMUM_PRIORITY;
2007f58: f0 08 62 48 ldub [ %g1 + 0x248 ], %i0
}
2007f5c: 81 c7 e0 08 ret
2007f60: 91 ee 3f ff restore %i0, -1, %o0
02007f64 <sched_get_priority_min>:
#include <rtems/posix/priority.h>
int sched_get_priority_min(
int policy
)
{
2007f64: 9d e3 bf a0 save %sp, -96, %sp
switch ( policy ) {
2007f68: 80 a6 20 04 cmp %i0, 4
2007f6c: 18 80 00 06 bgu 2007f84 <sched_get_priority_min+0x20>
2007f70: 82 10 20 01 mov 1, %g1
2007f74: 83 28 40 18 sll %g1, %i0, %g1
2007f78: 80 88 60 17 btst 0x17, %g1
2007f7c: 12 80 00 06 bne 2007f94 <sched_get_priority_min+0x30> <== ALWAYS TAKEN
2007f80: b0 10 20 01 mov 1, %i0
case SCHED_RR:
case SCHED_SPORADIC:
break;
default:
rtems_set_errno_and_return_minus_one( EINVAL );
2007f84: 40 00 21 75 call 2010558 <__errno>
2007f88: b0 10 3f ff mov -1, %i0
2007f8c: 82 10 20 16 mov 0x16, %g1
2007f90: c2 22 00 00 st %g1, [ %o0 ]
}
return POSIX_SCHEDULER_MINIMUM_PRIORITY;
}
2007f94: 81 c7 e0 08 ret
2007f98: 81 e8 00 00 restore
02007f9c <sched_rr_get_interval>:
int sched_rr_get_interval(
pid_t pid,
struct timespec *interval
)
{
2007f9c: 9d e3 bf a0 save %sp, -96, %sp
/*
* Only supported for the "calling process" (i.e. this node).
*/
if ( pid && pid != getpid() )
2007fa0: 80 a6 20 00 cmp %i0, 0
2007fa4: 02 80 00 0b be 2007fd0 <sched_rr_get_interval+0x34> <== NEVER TAKEN
2007fa8: 80 a6 60 00 cmp %i1, 0
2007fac: 7f ff ef 93 call 2003df8 <getpid>
2007fb0: 01 00 00 00 nop
2007fb4: 80 a6 00 08 cmp %i0, %o0
2007fb8: 02 80 00 06 be 2007fd0 <sched_rr_get_interval+0x34>
2007fbc: 80 a6 60 00 cmp %i1, 0
rtems_set_errno_and_return_minus_one( ESRCH );
2007fc0: 40 00 21 66 call 2010558 <__errno>
2007fc4: 01 00 00 00 nop
2007fc8: 10 80 00 07 b 2007fe4 <sched_rr_get_interval+0x48>
2007fcc: 82 10 20 03 mov 3, %g1 ! 3 <PROM_START+0x3>
if ( !interval )
2007fd0: 12 80 00 08 bne 2007ff0 <sched_rr_get_interval+0x54>
2007fd4: 03 00 80 89 sethi %hi(0x2022400), %g1
rtems_set_errno_and_return_minus_one( EINVAL );
2007fd8: 40 00 21 60 call 2010558 <__errno>
2007fdc: 01 00 00 00 nop
2007fe0: 82 10 20 16 mov 0x16, %g1 ! 16 <PROM_START+0x16>
2007fe4: c2 22 00 00 st %g1, [ %o0 ]
2007fe8: 81 c7 e0 08 ret
2007fec: 91 e8 3f ff restore %g0, -1, %o0
_Timespec_From_ticks( _Thread_Ticks_per_timeslice, interval );
2007ff0: d0 00 63 40 ld [ %g1 + 0x340 ], %o0
2007ff4: 92 10 00 19 mov %i1, %o1
2007ff8: 40 00 0e 99 call 200ba5c <_Timespec_From_ticks>
2007ffc: b0 10 20 00 clr %i0
return 0;
}
2008000: 81 c7 e0 08 ret
2008004: 81 e8 00 00 restore
020086cc <sem_open>:
int oflag,
...
/* mode_t mode, */
/* unsigned int value */
)
{
20086cc: 9d e3 bf 88 save %sp, -120, %sp
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
_Thread_Dispatch_disable_level++;
20086d0: 03 00 80 89 sethi %hi(0x2022400), %g1
20086d4: c4 00 61 f0 ld [ %g1 + 0x1f0 ], %g2 ! 20225f0 <_Thread_Dispatch_disable_level>
size_t name_len;
_Thread_Disable_dispatch();
if ( oflag & O_CREAT ) {
va_start(arg, oflag);
20086d8: f4 27 a0 4c st %i2, [ %fp + 0x4c ]
20086dc: 84 00 a0 01 inc %g2
20086e0: c4 20 61 f0 st %g2, [ %g1 + 0x1f0 ]
return _Thread_Dispatch_disable_level;
20086e4: c2 00 61 f0 ld [ %g1 + 0x1f0 ], %g1
20086e8: f6 27 a0 50 st %i3, [ %fp + 0x50 ]
20086ec: f8 27 a0 54 st %i4, [ %fp + 0x54 ]
20086f0: fa 27 a0 58 st %i5, [ %fp + 0x58 ]
Objects_Locations location;
size_t name_len;
_Thread_Disable_dispatch();
if ( oflag & O_CREAT ) {
20086f4: b4 8e 62 00 andcc %i1, 0x200, %i2
20086f8: 02 80 00 05 be 200870c <sem_open+0x40>
20086fc: b8 10 20 00 clr %i4
va_start(arg, oflag);
mode = va_arg( arg, mode_t );
value = va_arg( arg, unsigned int );
2008700: f8 07 a0 50 ld [ %fp + 0x50 ], %i4
size_t name_len;
_Thread_Disable_dispatch();
if ( oflag & O_CREAT ) {
va_start(arg, oflag);
2008704: 82 07 a0 4c add %fp, 0x4c, %g1
2008708: c2 27 bf ec st %g1, [ %fp + -20 ]
const char *name,
Objects_Id *id,
size_t *len
)
{
return _POSIX_Name_to_id( &_POSIX_Semaphore_Information, name, id, len );
200870c: 37 00 80 8a sethi %hi(0x2022800), %i3
2008710: 92 10 00 18 mov %i0, %o1
2008714: 90 16 e0 e0 or %i3, 0xe0, %o0
2008718: 94 07 bf f0 add %fp, -16, %o2
200871c: 7f ff fe 7d call 2008110 <_POSIX_Name_to_id>
2008720: 96 07 bf fc add %fp, -4, %o3
* 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 ) {
2008724: ba 92 20 00 orcc %o0, 0, %i5
2008728: 22 80 00 0e be,a 2008760 <sem_open+0x94>
200872c: b2 0e 6a 00 and %i1, 0xa00, %i1
/*
* 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) ) ) {
2008730: 80 a7 60 02 cmp %i5, 2
2008734: 12 80 00 04 bne 2008744 <sem_open+0x78>
2008738: 80 a6 a0 00 cmp %i2, 0
200873c: 12 80 00 20 bne 20087bc <sem_open+0xf0>
2008740: d2 07 bf fc ld [ %fp + -4 ], %o1
_Thread_Enable_dispatch();
2008744: 40 00 0d cc call 200be74 <_Thread_Enable_dispatch>
2008748: b0 10 3f ff mov -1, %i0
rtems_set_errno_and_return_minus_one_cast( status, sem_t * );
200874c: 40 00 24 89 call 2011970 <__errno>
2008750: 01 00 00 00 nop
2008754: fa 22 00 00 st %i5, [ %o0 ]
2008758: 81 c7 e0 08 ret
200875c: 81 e8 00 00 restore
/*
* Check for existence with creation.
*/
if ( (oflag & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL) ) {
2008760: 80 a6 6a 00 cmp %i1, 0xa00
2008764: 12 80 00 0a bne 200878c <sem_open+0xc0>
2008768: d2 07 bf f0 ld [ %fp + -16 ], %o1
_Thread_Enable_dispatch();
200876c: 40 00 0d c2 call 200be74 <_Thread_Enable_dispatch>
2008770: b0 10 3f ff mov -1, %i0
rtems_set_errno_and_return_minus_one_cast( EEXIST, sem_t * );
2008774: 40 00 24 7f call 2011970 <__errno>
2008778: 01 00 00 00 nop
200877c: 82 10 20 11 mov 0x11, %g1 ! 11 <PROM_START+0x11>
2008780: c2 22 00 00 st %g1, [ %o0 ]
2008784: 81 c7 e0 08 ret
2008788: 81 e8 00 00 restore
RTEMS_INLINE_ROUTINE POSIX_Semaphore_Control *_POSIX_Semaphore_Get (
sem_t *id,
Objects_Locations *location
)
{
return (POSIX_Semaphore_Control *)
200878c: 94 07 bf f8 add %fp, -8, %o2
2008790: 40 00 09 d4 call 200aee0 <_Objects_Get>
2008794: 90 16 e0 e0 or %i3, 0xe0, %o0
}
the_semaphore = _POSIX_Semaphore_Get( (sem_t *) &the_semaphore_id, &location );
the_semaphore->open_count += 1;
2008798: c2 02 20 18 ld [ %o0 + 0x18 ], %g1
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( (sem_t *) &the_semaphore_id, &location );
200879c: d0 27 bf f4 st %o0, [ %fp + -12 ]
the_semaphore->open_count += 1;
20087a0: 82 00 60 01 inc %g1
_Thread_Enable_dispatch();
20087a4: 40 00 0d b4 call 200be74 <_Thread_Enable_dispatch>
20087a8: c2 22 20 18 st %g1, [ %o0 + 0x18 ]
_Thread_Enable_dispatch();
20087ac: 40 00 0d b2 call 200be74 <_Thread_Enable_dispatch>
20087b0: 01 00 00 00 nop
goto return_id;
20087b4: 10 80 00 0d b 20087e8 <sem_open+0x11c>
20087b8: f0 07 bf f4 ld [ %fp + -12 ], %i0
/*
* 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(
20087bc: 94 10 20 00 clr %o2
20087c0: 96 10 00 1c mov %i4, %o3
20087c4: 98 07 bf f4 add %fp, -12, %o4
20087c8: 40 00 19 94 call 200ee18 <_POSIX_Semaphore_Create_support>
20087cc: 90 10 00 18 mov %i0, %o0
/*
* errno was set by Create_support, so don't set it again.
*/
_Thread_Enable_dispatch();
20087d0: 40 00 0d a9 call 200be74 <_Thread_Enable_dispatch>
20087d4: ba 10 00 08 mov %o0, %i5
if ( status == -1 )
20087d8: 80 a7 7f ff cmp %i5, -1
20087dc: 22 80 00 04 be,a 20087ec <sem_open+0x120> <== NEVER TAKEN
20087e0: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
return_id:
#if defined(RTEMS_USE_16_BIT_OBJECT)
the_semaphore->Semaphore_id = the_semaphore->Object.id;
return &the_semaphore->Semaphore_id;
#else
return (sem_t *)&the_semaphore->Object.id;
20087e4: f0 07 bf f4 ld [ %fp + -12 ], %i0
20087e8: b0 06 20 08 add %i0, 8, %i0
#endif
}
20087ec: 81 c7 e0 08 ret
20087f0: 81 e8 00 00 restore
02007f00 <sigaction>:
int sigaction(
int sig,
const struct sigaction *act,
struct sigaction *oact
)
{
2007f00: 9d e3 bf a0 save %sp, -96, %sp
ISR_Level level;
if ( oact )
2007f04: 80 a6 a0 00 cmp %i2, 0
2007f08: 02 80 00 0a be 2007f30 <sigaction+0x30>
2007f0c: 83 2e 20 02 sll %i0, 2, %g1
*oact = _POSIX_signals_Vectors[ sig ];
2007f10: 85 2e 20 04 sll %i0, 4, %g2
2007f14: 82 20 80 01 sub %g2, %g1, %g1
2007f18: 13 00 80 85 sethi %hi(0x2021400), %o1
2007f1c: 90 10 00 1a mov %i2, %o0
2007f20: 92 12 62 90 or %o1, 0x290, %o1
2007f24: 94 10 20 0c mov 0xc, %o2
2007f28: 40 00 25 3c call 2011418 <memcpy>
2007f2c: 92 02 40 01 add %o1, %g1, %o1
if ( !sig )
2007f30: 80 a6 20 00 cmp %i0, 0
2007f34: 32 80 00 03 bne,a 2007f40 <sigaction+0x40>
2007f38: 82 06 3f ff add %i0, -1, %g1
2007f3c: 30 80 00 06 b,a 2007f54 <sigaction+0x54>
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !is_valid_signo(sig) )
2007f40: 80 a0 60 1f cmp %g1, 0x1f
2007f44: 18 80 00 04 bgu 2007f54 <sigaction+0x54>
2007f48: 80 a6 20 09 cmp %i0, 9
*
* NOTE: Solaris documentation claims to "silently enforce" this which
* contradicts the POSIX specification.
*/
if ( sig == SIGKILL )
2007f4c: 12 80 00 08 bne 2007f6c <sigaction+0x6c>
2007f50: 80 a6 60 00 cmp %i1, 0
rtems_set_errno_and_return_minus_one( EINVAL );
2007f54: 40 00 22 e6 call 2010aec <__errno>
2007f58: 01 00 00 00 nop
2007f5c: 82 10 20 16 mov 0x16, %g1 ! 16 <PROM_START+0x16>
2007f60: c2 22 00 00 st %g1, [ %o0 ]
2007f64: 10 80 00 20 b 2007fe4 <sigaction+0xe4>
2007f68: 82 10 3f ff mov -1, %g1
/*
* Evaluate the new action structure and set the global signal vector
* appropriately.
*/
if ( act ) {
2007f6c: 02 80 00 1e be 2007fe4 <sigaction+0xe4> <== NEVER TAKEN
2007f70: 82 10 20 00 clr %g1
/*
* Unless the user is installing the default signal actions, then
* we can just copy the provided sigaction structure into the vectors.
*/
_ISR_Disable( level );
2007f74: 7f ff ea b8 call 2002a54 <sparc_disable_interrupts>
2007f78: 01 00 00 00 nop
2007f7c: b8 10 00 08 mov %o0, %i4
if ( act->sa_handler == SIG_DFL ) {
2007f80: c2 06 60 08 ld [ %i1 + 8 ], %g1
2007f84: 3b 00 80 85 sethi %hi(0x2021400), %i5
2007f88: 80 a0 60 00 cmp %g1, 0
2007f8c: 12 80 00 0a bne 2007fb4 <sigaction+0xb4>
2007f90: ba 17 62 90 or %i5, 0x290, %i5
_POSIX_signals_Vectors[ sig ] = _POSIX_signals_Default_vectors[ sig ];
2007f94: 83 2e 20 02 sll %i0, 2, %g1
2007f98: 13 00 80 7c sethi %hi(0x201f000), %o1
2007f9c: b1 2e 20 04 sll %i0, 4, %i0
2007fa0: 92 12 60 c4 or %o1, 0xc4, %o1
2007fa4: b0 26 00 01 sub %i0, %g1, %i0
2007fa8: 90 07 40 18 add %i5, %i0, %o0
2007fac: 10 80 00 09 b 2007fd0 <sigaction+0xd0>
2007fb0: 92 02 40 18 add %o1, %i0, %o1
} else {
_POSIX_signals_Clear_process_signals( sig );
2007fb4: 40 00 16 e1 call 200db38 <_POSIX_signals_Clear_process_signals>
2007fb8: 90 10 00 18 mov %i0, %o0
_POSIX_signals_Vectors[ sig ] = *act;
2007fbc: 83 2e 20 02 sll %i0, 2, %g1
2007fc0: 92 10 00 19 mov %i1, %o1
2007fc4: b1 2e 20 04 sll %i0, 4, %i0
2007fc8: 90 26 00 01 sub %i0, %g1, %o0
2007fcc: 90 07 40 08 add %i5, %o0, %o0
2007fd0: 40 00 25 12 call 2011418 <memcpy>
2007fd4: 94 10 20 0c mov 0xc, %o2
}
_ISR_Enable( level );
2007fd8: 7f ff ea a3 call 2002a64 <sparc_enable_interrupts>
2007fdc: 90 10 00 1c mov %i4, %o0
* 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;
2007fe0: 82 10 20 00 clr %g1
}
2007fe4: 81 c7 e0 08 ret
2007fe8: 91 e8 00 01 restore %g0, %g1, %o0
02008448 <sigtimedwait>:
int sigtimedwait(
const sigset_t *set,
siginfo_t *info,
const struct timespec *timeout
)
{
2008448: 9d e3 bf 90 save %sp, -112, %sp
ISR_Level level;
/*
* Error check parameters before disabling interrupts.
*/
if ( !set )
200844c: 80 a6 20 00 cmp %i0, 0
2008450: 02 80 00 0e be 2008488 <sigtimedwait+0x40>
2008454: 80 a6 a0 00 cmp %i2, 0
/* NOTE: This is very specifically a RELATIVE not ABSOLUTE time
* in the Open Group specification.
*/
interval = 0;
if ( timeout ) {
2008458: 02 80 00 10 be 2008498 <sigtimedwait+0x50>
200845c: b6 10 20 00 clr %i3
if ( !_Timespec_Is_valid( timeout ) )
2008460: 40 00 0e e1 call 200bfe4 <_Timespec_Is_valid>
2008464: 90 10 00 1a mov %i2, %o0
2008468: 80 8a 20 ff btst 0xff, %o0
200846c: 02 80 00 07 be 2008488 <sigtimedwait+0x40>
2008470: 01 00 00 00 nop
rtems_set_errno_and_return_minus_one( EINVAL );
interval = _Timespec_To_ticks( timeout );
2008474: 40 00 0e ee call 200c02c <_Timespec_To_ticks>
2008478: 90 10 00 1a mov %i2, %o0
if ( !interval )
200847c: b6 92 20 00 orcc %o0, 0, %i3
2008480: 12 80 00 07 bne 200849c <sigtimedwait+0x54> <== ALWAYS TAKEN
2008484: 80 a6 60 00 cmp %i1, 0
rtems_set_errno_and_return_minus_one( EINVAL );
2008488: 40 00 23 63 call 2011214 <__errno>
200848c: 01 00 00 00 nop
2008490: 10 80 00 64 b 2008620 <sigtimedwait+0x1d8>
2008494: 82 10 20 16 mov 0x16, %g1 ! 16 <PROM_START+0x16>
/*
* Initialize local variables.
*/
the_info = ( info ) ? info : &signal_information;
2008498: 80 a6 60 00 cmp %i1, 0
200849c: 22 80 00 02 be,a 20084a4 <sigtimedwait+0x5c>
20084a0: b2 07 bf f4 add %fp, -12, %i1
the_thread = _Thread_Executing;
20084a4: 21 00 80 86 sethi %hi(0x2021800), %l0
20084a8: a0 14 23 10 or %l0, 0x310, %l0 ! 2021b10 <_Per_CPU_Information>
20084ac: fa 04 20 0c ld [ %l0 + 0xc ], %i5
* What if they are already pending?
*/
/* API signals pending? */
_ISR_Disable( level );
20084b0: 7f ff ea 46 call 2002dc8 <sparc_disable_interrupts>
20084b4: f8 07 61 5c ld [ %i5 + 0x15c ], %i4
20084b8: b4 10 00 08 mov %o0, %i2
if ( *set & api->signals_pending ) {
20084bc: c4 06 00 00 ld [ %i0 ], %g2
20084c0: c2 07 20 d4 ld [ %i4 + 0xd4 ], %g1
20084c4: 80 88 80 01 btst %g2, %g1
20084c8: 22 80 00 12 be,a 2008510 <sigtimedwait+0xc8>
20084cc: 03 00 80 87 sethi %hi(0x2021c00), %g1
/* XXX real info later */
the_info->si_signo = _POSIX_signals_Get_lowest( api->signals_pending );
20084d0: 7f ff ff c6 call 20083e8 <_POSIX_signals_Get_lowest>
20084d4: 90 10 00 01 mov %g1, %o0
_POSIX_signals_Clear_signals(
20084d8: 94 10 00 19 mov %i1, %o2
/* 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 );
20084dc: 92 10 00 08 mov %o0, %o1
20084e0: d0 26 40 00 st %o0, [ %i1 ]
_POSIX_signals_Clear_signals(
20084e4: 96 10 20 00 clr %o3
20084e8: 90 10 00 1c mov %i4, %o0
20084ec: 40 00 17 ae call 200e3a4 <_POSIX_signals_Clear_signals>
20084f0: 98 10 20 00 clr %o4
the_info->si_signo,
the_info,
false,
false
);
_ISR_Enable( level );
20084f4: 7f ff ea 39 call 2002dd8 <sparc_enable_interrupts>
20084f8: 90 10 00 1a mov %i2, %o0
the_info->si_code = SI_USER;
20084fc: 82 10 20 01 mov 1, %g1
the_info->si_value.sival_int = 0;
2008500: c0 26 60 08 clr [ %i1 + 8 ]
false,
false
);
_ISR_Enable( level );
the_info->si_code = SI_USER;
2008504: c2 26 60 04 st %g1, [ %i1 + 4 ]
the_info->si_value.sival_int = 0;
return the_info->si_signo;
2008508: 10 80 00 48 b 2008628 <sigtimedwait+0x1e0>
200850c: fa 06 40 00 ld [ %i1 ], %i5
}
/* Process pending signals? */
if ( *set & _POSIX_signals_Pending ) {
2008510: c2 00 61 64 ld [ %g1 + 0x164 ], %g1
2008514: 80 88 80 01 btst %g2, %g1
2008518: 22 80 00 12 be,a 2008560 <sigtimedwait+0x118>
200851c: 82 10 3f ff mov -1, %g1
signo = _POSIX_signals_Get_lowest( _POSIX_signals_Pending );
2008520: 7f ff ff b2 call 20083e8 <_POSIX_signals_Get_lowest>
2008524: 90 10 00 01 mov %g1, %o0
_POSIX_signals_Clear_signals( api, signo, the_info, true, false );
2008528: 94 10 00 19 mov %i1, %o2
}
/* Process pending signals? */
if ( *set & _POSIX_signals_Pending ) {
signo = _POSIX_signals_Get_lowest( _POSIX_signals_Pending );
200852c: ba 10 00 08 mov %o0, %i5
_POSIX_signals_Clear_signals( api, signo, the_info, true, false );
2008530: 96 10 20 01 mov 1, %o3
2008534: 90 10 00 1c mov %i4, %o0
2008538: 92 10 00 1d mov %i5, %o1
200853c: 40 00 17 9a call 200e3a4 <_POSIX_signals_Clear_signals>
2008540: 98 10 20 00 clr %o4
_ISR_Enable( level );
2008544: 7f ff ea 25 call 2002dd8 <sparc_enable_interrupts>
2008548: 90 10 00 1a mov %i2, %o0
the_info->si_signo = signo;
the_info->si_code = SI_USER;
200854c: 82 10 20 01 mov 1, %g1
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;
2008550: fa 26 40 00 st %i5, [ %i1 ]
the_info->si_code = SI_USER;
2008554: c2 26 60 04 st %g1, [ %i1 + 4 ]
the_info->si_value.sival_int = 0;
2008558: 10 80 00 34 b 2008628 <sigtimedwait+0x1e0>
200855c: c0 26 60 08 clr [ %i1 + 8 ]
return signo;
}
the_info->si_signo = -1;
2008560: c2 26 40 00 st %g1, [ %i1 ]
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
_Thread_Dispatch_disable_level++;
2008564: 03 00 80 85 sethi %hi(0x2021400), %g1
2008568: c4 00 61 e0 ld [ %g1 + 0x1e0 ], %g2 ! 20215e0 <_Thread_Dispatch_disable_level>
200856c: 84 00 a0 01 inc %g2
2008570: c4 20 61 e0 st %g2, [ %g1 + 0x1e0 ]
return _Thread_Dispatch_disable_level;
2008574: c2 00 61 e0 ld [ %g1 + 0x1e0 ], %g1
_Thread_Disable_dispatch();
the_thread->Wait.queue = &_POSIX_signals_Wait_queue;
the_thread->Wait.return_code = EINTR;
2008578: 82 10 20 04 mov 4, %g1
200857c: c2 27 60 34 st %g1, [ %i5 + 0x34 ]
the_thread->Wait.option = *set;
2008580: c2 06 00 00 ld [ %i0 ], %g1
the_thread->Wait.return_argument = the_info;
2008584: f2 27 60 28 st %i1, [ %i5 + 0x28 ]
the_info->si_signo = -1;
_Thread_Disable_dispatch();
the_thread->Wait.queue = &_POSIX_signals_Wait_queue;
the_thread->Wait.return_code = EINTR;
the_thread->Wait.option = *set;
2008588: c2 27 60 30 st %g1, [ %i5 + 0x30 ]
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;
200858c: a2 10 20 01 mov 1, %l1
}
the_info->si_signo = -1;
_Thread_Disable_dispatch();
the_thread->Wait.queue = &_POSIX_signals_Wait_queue;
2008590: 35 00 80 87 sethi %hi(0x2021c00), %i2
2008594: b4 16 a0 fc or %i2, 0xfc, %i2 ! 2021cfc <_POSIX_signals_Wait_queue>
2008598: f4 27 60 44 st %i2, [ %i5 + 0x44 ]
200859c: e2 26 a0 30 st %l1, [ %i2 + 0x30 ]
the_thread->Wait.return_code = EINTR;
the_thread->Wait.option = *set;
the_thread->Wait.return_argument = the_info;
_Thread_queue_Enter_critical_section( &_POSIX_signals_Wait_queue );
_ISR_Enable( level );
20085a0: 7f ff ea 0e call 2002dd8 <sparc_enable_interrupts>
20085a4: 01 00 00 00 nop
_Thread_queue_Enqueue( &_POSIX_signals_Wait_queue, interval );
20085a8: 90 10 00 1a mov %i2, %o0
20085ac: 92 10 00 1b mov %i3, %o1
20085b0: 15 00 80 2f sethi %hi(0x200bc00), %o2
20085b4: 40 00 0d 36 call 200ba8c <_Thread_queue_Enqueue_with_handler>
20085b8: 94 12 a1 f8 or %o2, 0x1f8, %o2 ! 200bdf8 <_Thread_queue_Timeout>
_Thread_Enable_dispatch();
20085bc: 40 00 0b f1 call 200b580 <_Thread_Enable_dispatch>
20085c0: 01 00 00 00 nop
/*
* 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 );
20085c4: d2 06 40 00 ld [ %i1 ], %o1
20085c8: 90 10 00 1c mov %i4, %o0
20085cc: 94 10 00 19 mov %i1, %o2
20085d0: 96 10 20 00 clr %o3
20085d4: 40 00 17 74 call 200e3a4 <_POSIX_signals_Clear_signals>
20085d8: 98 10 20 00 clr %o4
/* 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)
20085dc: c2 04 20 0c ld [ %l0 + 0xc ], %g1
20085e0: c2 00 60 34 ld [ %g1 + 0x34 ], %g1
20085e4: 80 a0 60 04 cmp %g1, 4
20085e8: 12 80 00 09 bne 200860c <sigtimedwait+0x1c4>
20085ec: 01 00 00 00 nop
|| !(*set & signo_to_mask( the_info->si_signo )) ) {
20085f0: fa 06 40 00 ld [ %i1 ], %i5
20085f4: 82 07 7f ff add %i5, -1, %g1
20085f8: a3 2c 40 01 sll %l1, %g1, %l1
20085fc: c2 06 00 00 ld [ %i0 ], %g1
2008600: 80 8c 40 01 btst %l1, %g1
2008604: 12 80 00 09 bne 2008628 <sigtimedwait+0x1e0>
2008608: 01 00 00 00 nop
errno = _Thread_Executing->Wait.return_code;
200860c: 40 00 23 02 call 2011214 <__errno>
2008610: 01 00 00 00 nop
2008614: 03 00 80 86 sethi %hi(0x2021800), %g1
2008618: c2 00 63 1c ld [ %g1 + 0x31c ], %g1 ! 2021b1c <_Per_CPU_Information+0xc>
200861c: c2 00 60 34 ld [ %g1 + 0x34 ], %g1
2008620: c2 22 00 00 st %g1, [ %o0 ]
return -1;
2008624: ba 10 3f ff mov -1, %i5
}
return the_info->si_signo;
}
2008628: 81 c7 e0 08 ret
200862c: 91 e8 00 1d restore %g0, %i5, %o0
0200a36c <sigwait>:
int sigwait(
const sigset_t *set,
int *sig
)
{
200a36c: 9d e3 bf a0 save %sp, -96, %sp
int status;
status = sigtimedwait( set, NULL, NULL );
200a370: 92 10 20 00 clr %o1
200a374: 90 10 00 18 mov %i0, %o0
200a378: 7f ff ff 7f call 200a174 <sigtimedwait>
200a37c: 94 10 20 00 clr %o2
if ( status != -1 ) {
200a380: 80 a2 3f ff cmp %o0, -1
200a384: 02 80 00 06 be 200a39c <sigwait+0x30>
200a388: 80 a6 60 00 cmp %i1, 0
if ( sig )
200a38c: 32 80 00 09 bne,a 200a3b0 <sigwait+0x44> <== ALWAYS TAKEN
200a390: d0 26 40 00 st %o0, [ %i1 ]
*sig = status;
return 0;
200a394: 81 c7 e0 08 ret <== NOT EXECUTED
200a398: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED
}
return errno;
200a39c: 40 00 22 34 call 2012c6c <__errno>
200a3a0: 01 00 00 00 nop
200a3a4: f0 02 00 00 ld [ %o0 ], %i0
200a3a8: 81 c7 e0 08 ret
200a3ac: 81 e8 00 00 restore
status = sigtimedwait( set, NULL, NULL );
if ( status != -1 ) {
if ( sig )
*sig = status;
return 0;
200a3b0: b0 10 20 00 clr %i0
}
return errno;
}
200a3b4: 81 c7 e0 08 ret
200a3b8: 81 e8 00 00 restore
02006570 <siproc>:
/*
* Process input character, with semaphore.
*/
static int
siproc (unsigned char c, struct rtems_termios_tty *tty)
{
2006570: 9d e3 bf a0 save %sp, -96, %sp
int i;
/*
* Obtain output semaphore if character will be echoed
*/
if (tty->termios.c_lflag & (ECHO|ECHOE|ECHOK|ECHONL|ECHOPRT|ECHOCTL|ECHOKE)) {
2006574: c2 06 60 3c ld [ %i1 + 0x3c ], %g1
2006578: 80 88 6e 78 btst 0xe78, %g1
200657c: 02 80 00 0d be 20065b0 <siproc+0x40> <== NEVER TAKEN
2006580: 94 10 20 00 clr %o2
rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
2006584: d0 06 60 18 ld [ %i1 + 0x18 ], %o0
2006588: 40 00 04 d7 call 20078e4 <rtems_semaphore_obtain>
200658c: 92 10 20 00 clr %o1
i = iproc (c, tty);
2006590: 90 10 00 18 mov %i0, %o0
2006594: 7f ff ff 6b call 2006340 <iproc>
2006598: 92 10 00 19 mov %i1, %o1
200659c: b0 10 00 08 mov %o0, %i0
rtems_semaphore_release (tty->osem);
20065a0: 40 00 05 1b call 2007a0c <rtems_semaphore_release>
20065a4: d0 06 60 18 ld [ %i1 + 0x18 ], %o0
20065a8: 81 c7 e0 08 ret
20065ac: 81 e8 00 00 restore
}
else {
i = iproc (c, tty);
20065b0: 7f ff ff 64 call 2006340 <iproc> <== NOT EXECUTED
20065b4: 81 e8 00 00 restore <== NOT EXECUTED
02005f94 <sync_per_thread>:
fdatasync(fn);
}
/* iterate over all FILE *'s for this thread */
static void sync_per_thread(Thread_Control *t)
{
2005f94: 9d e3 bf a0 save %sp, -96, %sp
/*
* The sync_wrapper() function will operate on the current thread's
* reent structure so we will temporarily use that.
*/
this_reent = t->libc_reent;
2005f98: c4 06 21 54 ld [ %i0 + 0x154 ], %g2
if ( this_reent ) {
2005f9c: 80 a0 a0 00 cmp %g2, 0
2005fa0: 02 80 00 0c be 2005fd0 <sync_per_thread+0x3c> <== NEVER TAKEN
2005fa4: 3b 00 80 7e sethi %hi(0x201f800), %i5
current_reent = _Thread_Executing->libc_reent;
2005fa8: ba 17 61 30 or %i5, 0x130, %i5 ! 201f930 <_Per_CPU_Information>
2005fac: c2 07 60 0c ld [ %i5 + 0xc ], %g1
_Thread_Executing->libc_reent = this_reent;
_fwalk (t->libc_reent, sync_wrapper);
2005fb0: 13 00 80 17 sethi %hi(0x2005c00), %o1
* 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;
2005fb4: f8 00 61 54 ld [ %g1 + 0x154 ], %i4
_Thread_Executing->libc_reent = this_reent;
2005fb8: c4 20 61 54 st %g2, [ %g1 + 0x154 ]
_fwalk (t->libc_reent, sync_wrapper);
2005fbc: d0 06 21 54 ld [ %i0 + 0x154 ], %o0
2005fc0: 40 00 2d ef call 201177c <_fwalk>
2005fc4: 92 12 63 d8 or %o1, 0x3d8, %o1
_Thread_Executing->libc_reent = current_reent;
2005fc8: c2 07 60 0c ld [ %i5 + 0xc ], %g1
2005fcc: f8 20 61 54 st %i4, [ %g1 + 0x154 ]
2005fd0: 81 c7 e0 08 ret
2005fd4: 81 e8 00 00 restore
020071e8 <sysconf>:
*/
long sysconf(
int name
)
{
20071e8: 9d e3 bf a0 save %sp, -96, %sp
if ( name == _SC_CLK_TCK )
20071ec: 80 a6 20 02 cmp %i0, 2
20071f0: 12 80 00 09 bne 2007214 <sysconf+0x2c>
20071f4: 03 00 80 74 sethi %hi(0x201d000), %g1
return (TOD_MICROSECONDS_PER_SECOND /
20071f8: 03 00 80 74 sethi %hi(0x201d000), %g1
20071fc: d2 00 60 6c ld [ %g1 + 0x6c ], %o1 ! 201d06c <Configuration+0x10>
2007200: 11 00 03 d0 sethi %hi(0xf4000), %o0
2007204: 40 00 46 68 call 2018ba4 <.udiv>
2007208: 90 12 22 40 or %o0, 0x240, %o0 ! f4240 <PROM_START+0xf4240>
200720c: 81 c7 e0 08 ret
2007210: 91 e8 00 08 restore %g0, %o0, %o0
rtems_configuration_get_microseconds_per_tick());
if ( name == _SC_OPEN_MAX )
2007214: 80 a6 20 04 cmp %i0, 4
2007218: 02 80 00 13 be 2007264 <sysconf+0x7c>
200721c: d0 00 61 b4 ld [ %g1 + 0x1b4 ], %o0
return rtems_libio_number_iops;
if ( name == _SC_GETPW_R_SIZE_MAX )
2007220: 80 a6 20 33 cmp %i0, 0x33
2007224: 02 80 00 10 be 2007264 <sysconf+0x7c>
2007228: 90 10 24 00 mov 0x400, %o0
return 1024;
if ( name == _SC_PAGESIZE )
200722c: 80 a6 20 08 cmp %i0, 8
2007230: 02 80 00 0d be 2007264 <sysconf+0x7c>
2007234: 11 00 00 04 sethi %hi(0x1000), %o0
return PAGE_SIZE;
if ( name == _SC_SYMLOOP_MAX )
2007238: 80 a6 20 4f cmp %i0, 0x4f
200723c: 02 80 00 0a be 2007264 <sysconf+0x7c> <== NEVER TAKEN
2007240: 90 10 20 20 mov 0x20, %o0
return RTEMS_FILESYSTEM_SYMLOOP_MAX;
#if defined(__sparc__)
if ( name == 515 ) /* Solaris _SC_STACK_PROT */
2007244: 80 a6 22 03 cmp %i0, 0x203
2007248: 02 80 00 07 be 2007264 <sysconf+0x7c> <== NEVER TAKEN
200724c: 90 10 20 00 clr %o0
return 0;
#endif
rtems_set_errno_and_return_minus_one( EINVAL );
2007250: 40 00 22 b5 call 200fd24 <__errno>
2007254: 01 00 00 00 nop
2007258: 82 10 20 16 mov 0x16, %g1 ! 16 <PROM_START+0x16>
200725c: c2 22 00 00 st %g1, [ %o0 ]
2007260: 90 10 3f ff mov -1, %o0
}
2007264: b0 10 00 08 mov %o0, %i0
2007268: 81 c7 e0 08 ret
200726c: 81 e8 00 00 restore
02013084 <tcsetattr>:
int tcsetattr(
int fd,
int opt,
struct termios *tp
)
{
2013084: 9d e3 bf a0 save %sp, -96, %sp
switch (opt) {
2013088: 80 a6 60 00 cmp %i1, 0
201308c: 02 80 00 10 be 20130cc <tcsetattr+0x48>
2013090: 80 a6 60 01 cmp %i1, 1
2013094: 02 80 00 08 be 20130b4 <tcsetattr+0x30>
2013098: 90 10 00 18 mov %i0, %o0
default:
rtems_set_errno_and_return_minus_one( ENOTSUP );
201309c: 40 00 11 1b call 2017508 <__errno>
20130a0: b0 10 3f ff mov -1, %i0
20130a4: 82 10 20 86 mov 0x86, %g1
20130a8: c2 22 00 00 st %g1, [ %o0 ]
20130ac: 81 c7 e0 08 ret
20130b0: 81 e8 00 00 restore
case TCSADRAIN:
if (ioctl( fd, RTEMS_IO_TCDRAIN, NULL ) < 0)
20130b4: 92 10 20 03 mov 3, %o1
20130b8: 40 00 0e 18 call 2016918 <ioctl>
20130bc: 94 10 20 00 clr %o2
20130c0: 80 a2 20 00 cmp %o0, 0
20130c4: 26 80 00 04 bl,a 20130d4 <tcsetattr+0x50> <== NEVER TAKEN
20130c8: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
return -1;
/*
* Fall through to....
*/
case TCSANOW:
return ioctl( fd, RTEMS_IO_SET_ATTRIBUTES, tp );
20130cc: 40 00 0e 13 call 2016918 <ioctl>
20130d0: 93 e8 20 02 restore %g0, 2, %o1
}
}
20130d4: 81 c7 e0 08 ret <== NOT EXECUTED
20130d8: 81 e8 00 00 restore <== NOT EXECUTED
020087f4 <timer_create>:
int timer_create(
clockid_t clock_id,
struct sigevent *evp,
timer_t *timerid
)
{
20087f4: 9d e3 bf a0 save %sp, -96, %sp
POSIX_Timer_Control *ptimer;
if ( clock_id != CLOCK_REALTIME )
20087f8: 80 a6 20 01 cmp %i0, 1
20087fc: 12 80 00 13 bne 2008848 <timer_create+0x54>
2008800: 80 a6 a0 00 cmp %i2, 0
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !timerid )
2008804: 02 80 00 11 be 2008848 <timer_create+0x54>
2008808: 80 a6 60 00 cmp %i1, 0
/*
* The data of the structure evp are checked in order to verify if they
* are coherent.
*/
if (evp != NULL) {
200880c: 02 80 00 13 be 2008858 <timer_create+0x64>
2008810: 03 00 80 89 sethi %hi(0x2022400), %g1
/* The structure has data */
if ( ( evp->sigev_notify != SIGEV_NONE ) &&
2008814: c2 06 40 00 ld [ %i1 ], %g1
2008818: 82 00 7f ff add %g1, -1, %g1
200881c: 80 a0 60 01 cmp %g1, 1
2008820: 28 80 00 03 bleu,a 200882c <timer_create+0x38> <== ALWAYS TAKEN
2008824: c2 06 60 04 ld [ %i1 + 4 ], %g1
2008828: 30 80 00 08 b,a 2008848 <timer_create+0x54> <== NOT EXECUTED
( evp->sigev_notify != SIGEV_SIGNAL ) ) {
/* The value of the field sigev_notify is not valid */
rtems_set_errno_and_return_minus_one( EINVAL );
}
if ( !evp->sigev_signo )
200882c: 80 a0 60 00 cmp %g1, 0
2008830: 32 80 00 03 bne,a 200883c <timer_create+0x48> <== ALWAYS TAKEN
2008834: 82 00 7f ff add %g1, -1, %g1
2008838: 30 80 00 04 b,a 2008848 <timer_create+0x54> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !is_valid_signo(evp->sigev_signo) )
200883c: 80 a0 60 1f cmp %g1, 0x1f
2008840: 28 80 00 06 bleu,a 2008858 <timer_create+0x64> <== ALWAYS TAKEN
2008844: 03 00 80 89 sethi %hi(0x2022400), %g1
rtems_set_errno_and_return_minus_one( EINVAL );
2008848: 40 00 24 4a call 2011970 <__errno>
200884c: 01 00 00 00 nop
2008850: 10 80 00 11 b 2008894 <timer_create+0xa0>
2008854: 82 10 20 16 mov 0x16, %g1 ! 16 <PROM_START+0x16>
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
_Thread_Dispatch_disable_level++;
2008858: c4 00 61 f0 ld [ %g1 + 0x1f0 ], %g2
200885c: 84 00 a0 01 inc %g2
2008860: c4 20 61 f0 st %g2, [ %g1 + 0x1f0 ]
return _Thread_Dispatch_disable_level;
2008864: c2 00 61 f0 ld [ %g1 + 0x1f0 ], %g1
* 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 );
2008868: 11 00 80 8a sethi %hi(0x2022800), %o0
200886c: 40 00 08 5f call 200a9e8 <_Objects_Allocate>
2008870: 90 12 21 20 or %o0, 0x120, %o0 ! 2022920 <_POSIX_Timer_Information>
/*
* Allocate a timer
*/
ptimer = _POSIX_Timer_Allocate();
if ( !ptimer ) {
2008874: 80 a2 20 00 cmp %o0, 0
2008878: 12 80 00 0a bne 20088a0 <timer_create+0xac>
200887c: 82 10 20 02 mov 2, %g1
_Thread_Enable_dispatch();
2008880: 40 00 0d 7d call 200be74 <_Thread_Enable_dispatch>
2008884: 01 00 00 00 nop
rtems_set_errno_and_return_minus_one( EAGAIN );
2008888: 40 00 24 3a call 2011970 <__errno>
200888c: 01 00 00 00 nop
2008890: 82 10 20 0b mov 0xb, %g1 ! b <PROM_START+0xb>
2008894: c2 22 00 00 st %g1, [ %o0 ]
2008898: 81 c7 e0 08 ret
200889c: 91 e8 3f ff restore %g0, -1, %o0
}
/* The data of the created timer are stored to use them later */
ptimer->state = POSIX_TIMER_STATE_CREATE_NEW;
20088a0: c2 2a 20 3c stb %g1, [ %o0 + 0x3c ]
ptimer->thread_id = _Thread_Executing->Object.id;
20088a4: 03 00 80 8a sethi %hi(0x2022800), %g1
20088a8: c2 00 63 6c ld [ %g1 + 0x36c ], %g1 ! 2022b6c <_Per_CPU_Information+0xc>
if ( evp != NULL ) {
20088ac: 80 a6 60 00 cmp %i1, 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;
20088b0: c2 00 60 08 ld [ %g1 + 8 ], %g1
if ( evp != NULL ) {
20088b4: 02 80 00 08 be 20088d4 <timer_create+0xe0>
20088b8: c2 22 20 38 st %g1, [ %o0 + 0x38 ]
ptimer->inf.sigev_notify = evp->sigev_notify;
20088bc: c2 06 40 00 ld [ %i1 ], %g1
20088c0: c2 22 20 40 st %g1, [ %o0 + 0x40 ]
ptimer->inf.sigev_signo = evp->sigev_signo;
20088c4: c2 06 60 04 ld [ %i1 + 4 ], %g1
20088c8: c2 22 20 44 st %g1, [ %o0 + 0x44 ]
ptimer->inf.sigev_value = evp->sigev_value;
20088cc: c2 06 60 08 ld [ %i1 + 8 ], %g1
20088d0: c2 22 20 48 st %g1, [ %o0 + 0x48 ]
Objects_Information *information,
Objects_Control *the_object,
uint32_t name
)
{
_Objects_Set_local_object(
20088d4: c4 12 20 0a lduh [ %o0 + 0xa ], %g2
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
20088d8: 07 00 80 8a sethi %hi(0x2022800), %g3
20088dc: c6 00 e1 3c ld [ %g3 + 0x13c ], %g3 ! 202293c <_POSIX_Timer_Information+0x1c>
}
ptimer->overrun = 0;
20088e0: c0 22 20 68 clr [ %o0 + 0x68 ]
ptimer->timer_data.it_value.tv_sec = 0;
20088e4: c0 22 20 5c clr [ %o0 + 0x5c ]
ptimer->timer_data.it_value.tv_nsec = 0;
20088e8: c0 22 20 60 clr [ %o0 + 0x60 ]
ptimer->timer_data.it_interval.tv_sec = 0;
20088ec: c0 22 20 54 clr [ %o0 + 0x54 ]
ptimer->timer_data.it_interval.tv_nsec = 0;
20088f0: c0 22 20 58 clr [ %o0 + 0x58 ]
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
20088f4: c0 22 20 18 clr [ %o0 + 0x18 ]
the_watchdog->routine = routine;
20088f8: c0 22 20 2c clr [ %o0 + 0x2c ]
the_watchdog->id = id;
20088fc: c0 22 20 30 clr [ %o0 + 0x30 ]
the_watchdog->user_data = user_data;
2008900: c0 22 20 34 clr [ %o0 + 0x34 ]
Objects_Information *information,
Objects_Control *the_object,
uint32_t name
)
{
_Objects_Set_local_object(
2008904: c2 02 20 08 ld [ %o0 + 8 ], %g1
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
2008908: 85 28 a0 02 sll %g2, 2, %g2
200890c: d0 20 c0 02 st %o0, [ %g3 + %g2 ]
_Objects_Get_index( the_object->id ),
the_object
);
/* ASSERT: information->is_string == false */
the_object->name.name_u32 = name;
2008910: c0 22 20 0c clr [ %o0 + 0xc ]
_Watchdog_Initialize( &ptimer->Timer, NULL, 0, NULL );
_Objects_Open_u32(&_POSIX_Timer_Information, &ptimer->Object, 0);
*timerid = ptimer->Object.id;
2008914: c2 26 80 00 st %g1, [ %i2 ]
_Thread_Enable_dispatch();
2008918: 40 00 0d 57 call 200be74 <_Thread_Enable_dispatch>
200891c: b0 10 20 00 clr %i0
return 0;
}
2008920: 81 c7 e0 08 ret
2008924: 81 e8 00 00 restore
020073e0 <timer_settime>:
timer_t timerid,
int flags,
const struct itimerspec *value,
struct itimerspec *ovalue
)
{
20073e0: 9d e3 bf 78 save %sp, -136, %sp
Objects_Locations location;
bool activated;
uint32_t initial_period;
struct itimerspec normalize;
if ( !value )
20073e4: 80 a6 a0 00 cmp %i2, 0
20073e8: 02 80 00 7c be 20075d8 <timer_settime+0x1f8> <== NEVER TAKEN
20073ec: 01 00 00 00 nop
/*
* 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) ) ) {
20073f0: 40 00 0f 55 call 200b144 <_Timespec_Is_valid>
20073f4: 90 06 a0 08 add %i2, 8, %o0
20073f8: 80 8a 20 ff btst 0xff, %o0
20073fc: 02 80 00 77 be 20075d8 <timer_settime+0x1f8>
2007400: 01 00 00 00 nop
rtems_set_errno_and_return_minus_one( EINVAL );
}
if ( !_Timespec_Is_valid( &(value->it_interval) ) ) {
2007404: 40 00 0f 50 call 200b144 <_Timespec_Is_valid>
2007408: 90 10 00 1a mov %i2, %o0
200740c: 80 8a 20 ff btst 0xff, %o0
2007410: 02 80 00 72 be 20075d8 <timer_settime+0x1f8> <== NEVER TAKEN
2007414: 80 8e 7f fb btst -5, %i1
rtems_set_errno_and_return_minus_one( EINVAL );
}
if ( flags != TIMER_ABSTIME && flags != POSIX_TIMER_RELATIVE ) {
2007418: 12 80 00 70 bne 20075d8 <timer_settime+0x1f8>
200741c: 90 07 bf f0 add %fp, -16, %o0
rtems_set_errno_and_return_minus_one( EINVAL );
}
normalize = *value;
2007420: 92 10 00 1a mov %i2, %o1
2007424: 40 00 25 eb call 2010bd0 <memcpy>
2007428: 94 10 20 10 mov 0x10, %o2
/* Convert absolute to relative time */
if (flags == TIMER_ABSTIME) {
200742c: 80 a6 60 04 cmp %i1, 4
2007430: 12 80 00 1d bne 20074a4 <timer_settime+0xc4>
2007434: 11 00 80 7a sethi %hi(0x201e800), %o0
struct timespec *tod_as_timespec
)
{
Timestamp_Control tod_as_timestamp;
_TOD_Get_as_timestamp( &tod_as_timestamp );
2007438: 40 00 06 5e call 2008db0 <_TOD_Get_as_timestamp>
200743c: 90 07 bf e0 add %fp, -32, %o0
_Timestamp_To_timespec( &tod_as_timestamp, tod_as_timespec );
2007440: f8 1f bf e0 ldd [ %fp + -32 ], %i4
static inline void _Timestamp64_implementation_To_timespec(
const Timestamp64_Control *_timestamp,
struct timespec *_timespec
)
{
_timespec->tv_sec = (time_t) (*_timestamp / 1000000000L);
2007444: 94 10 20 00 clr %o2
2007448: 90 10 00 1c mov %i4, %o0
200744c: 92 10 00 1d mov %i5, %o1
2007450: 17 0e e6 b2 sethi %hi(0x3b9ac800), %o3
2007454: 40 00 49 54 call 20199a4 <__divdi3>
2007458: 96 12 e2 00 or %o3, 0x200, %o3 ! 3b9aca00 <RAM_END+0x395aca00>
_timespec->tv_nsec = (long) (*_timestamp % 1000000000L);
200745c: 94 10 20 00 clr %o2
static inline void _Timestamp64_implementation_To_timespec(
const Timestamp64_Control *_timestamp,
struct timespec *_timespec
)
{
_timespec->tv_sec = (time_t) (*_timestamp / 1000000000L);
2007460: d2 27 bf e8 st %o1, [ %fp + -24 ]
_timespec->tv_nsec = (long) (*_timestamp % 1000000000L);
2007464: 90 10 00 1c mov %i4, %o0
2007468: 92 10 00 1d mov %i5, %o1
200746c: 17 0e e6 b2 sethi %hi(0x3b9ac800), %o3
2007470: 40 00 4a 38 call 2019d50 <__moddi3>
2007474: 96 12 e2 00 or %o3, 0x200, %o3 ! 3b9aca00 <RAM_END+0x395aca00>
struct timespec now;
_TOD_Get( &now );
/* Check for seconds in the past */
if ( _Timespec_Greater_than( &now, &normalize.it_value ) )
2007478: 90 07 bf f8 add %fp, -8, %o0
200747c: d2 27 bf ec st %o1, [ %fp + -20 ]
2007480: 40 00 0f 43 call 200b18c <_Timespec_Less_than>
2007484: 92 07 bf e8 add %fp, -24, %o1
2007488: 80 8a 20 ff btst 0xff, %o0
200748c: 12 80 00 53 bne 20075d8 <timer_settime+0x1f8>
2007490: 92 07 bf f8 add %fp, -8, %o1
rtems_set_errno_and_return_minus_one( EINVAL );
_Timespec_Subtract( &now, &normalize.it_value, &normalize.it_value );
2007494: 90 07 bf e8 add %fp, -24, %o0
2007498: 40 00 0f 4d call 200b1cc <_Timespec_Subtract>
200749c: 94 10 00 09 mov %o1, %o2
RTEMS_INLINE_ROUTINE POSIX_Timer_Control *_POSIX_Timer_Get (
timer_t id,
Objects_Locations *location
)
{
return (POSIX_Timer_Control *)
20074a0: 11 00 80 7a sethi %hi(0x201e800), %o0
20074a4: 92 10 00 18 mov %i0, %o1
20074a8: 90 12 20 30 or %o0, 0x30, %o0
20074ac: 40 00 08 e1 call 2009830 <_Objects_Get>
20074b0: 94 07 bf dc add %fp, -36, %o2
* something with the structure of times of the timer: to stop, start
* or start it again
*/
ptimer = _POSIX_Timer_Get( timerid, &location );
switch ( location ) {
20074b4: c2 07 bf dc ld [ %fp + -36 ], %g1
20074b8: 80 a0 60 00 cmp %g1, 0
20074bc: 12 80 00 47 bne 20075d8 <timer_settime+0x1f8>
20074c0: b2 10 00 08 mov %o0, %i1
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 ) {
20074c4: c2 07 bf f8 ld [ %fp + -8 ], %g1
20074c8: 80 a0 60 00 cmp %g1, 0
20074cc: 12 80 00 14 bne 200751c <timer_settime+0x13c>
20074d0: c2 07 bf fc ld [ %fp + -4 ], %g1
20074d4: 80 a0 60 00 cmp %g1, 0
20074d8: 12 80 00 11 bne 200751c <timer_settime+0x13c>
20074dc: 01 00 00 00 nop
/* Stop the timer */
(void) _Watchdog_Remove( &ptimer->Timer );
20074e0: 40 00 10 72 call 200b6a8 <_Watchdog_Remove>
20074e4: 90 02 20 10 add %o0, 0x10, %o0
/* The old data of the timer are returned */
if ( ovalue )
20074e8: 80 a6 e0 00 cmp %i3, 0
20074ec: 02 80 00 05 be 2007500 <timer_settime+0x120>
20074f0: 90 10 00 1b mov %i3, %o0
*ovalue = ptimer->timer_data;
20074f4: 92 06 60 54 add %i1, 0x54, %o1
20074f8: 40 00 25 b6 call 2010bd0 <memcpy>
20074fc: 94 10 20 10 mov 0x10, %o2
/* The new data are set */
ptimer->timer_data = normalize;
2007500: 90 06 60 54 add %i1, 0x54, %o0
2007504: 92 07 bf f0 add %fp, -16, %o1
2007508: 40 00 25 b2 call 2010bd0 <memcpy>
200750c: 94 10 20 10 mov 0x10, %o2
/* Indicates that the timer is created and stopped */
ptimer->state = POSIX_TIMER_STATE_CREATE_STOP;
2007510: 82 10 20 04 mov 4, %g1
2007514: 10 80 00 2d b 20075c8 <timer_settime+0x1e8>
2007518: c2 2e 60 3c stb %g1, [ %i1 + 0x3c ]
_Thread_Enable_dispatch();
return 0;
}
/* Convert from seconds and nanoseconds to ticks */
ptimer->ticks = _Timespec_To_ticks( &value->it_interval );
200751c: 40 00 0f 3d call 200b210 <_Timespec_To_ticks>
2007520: 90 10 00 1a mov %i2, %o0
2007524: d0 26 60 64 st %o0, [ %i1 + 0x64 ]
initial_period = _Timespec_To_ticks( &normalize.it_value );
2007528: 40 00 0f 3a call 200b210 <_Timespec_To_ticks>
200752c: 90 07 bf f8 add %fp, -8, %o0
activated = _POSIX_Timer_Insert_helper(
2007530: d4 06 60 08 ld [ %i1 + 8 ], %o2
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 );
2007534: 92 10 00 08 mov %o0, %o1
activated = _POSIX_Timer_Insert_helper(
2007538: 17 00 80 1d sethi %hi(0x2007400), %o3
200753c: 90 06 60 10 add %i1, 0x10, %o0
2007540: 96 12 e1 f0 or %o3, 0x1f0, %o3
2007544: 40 00 18 4e call 200d67c <_POSIX_Timer_Insert_helper>
2007548: 98 10 00 19 mov %i1, %o4
initial_period,
ptimer->Object.id,
_POSIX_Timer_TSR,
ptimer
);
if ( !activated ) {
200754c: 80 8a 20 ff btst 0xff, %o0
2007550: 02 80 00 1e be 20075c8 <timer_settime+0x1e8>
2007554: 80 a6 e0 00 cmp %i3, 0
/*
* The timer has been started and is running. So we return the
* old ones in "ovalue"
*/
if ( ovalue )
2007558: 02 80 00 05 be 200756c <timer_settime+0x18c>
200755c: 90 10 00 1b mov %i3, %o0
*ovalue = ptimer->timer_data;
2007560: 92 06 60 54 add %i1, 0x54, %o1
2007564: 40 00 25 9b call 2010bd0 <memcpy>
2007568: 94 10 20 10 mov 0x10, %o2
ptimer->timer_data = normalize;
200756c: 92 07 bf f0 add %fp, -16, %o1
2007570: 94 10 20 10 mov 0x10, %o2
2007574: 40 00 25 97 call 2010bd0 <memcpy>
2007578: 90 06 60 54 add %i1, 0x54, %o0
/* Indicate that the time is running */
ptimer->state = POSIX_TIMER_STATE_CREATE_RUN;
200757c: 82 10 20 03 mov 3, %g1
struct timespec *tod_as_timespec
)
{
Timestamp_Control tod_as_timestamp;
_TOD_Get_as_timestamp( &tod_as_timestamp );
2007580: 90 07 bf e0 add %fp, -32, %o0
2007584: 40 00 06 0b call 2008db0 <_TOD_Get_as_timestamp>
2007588: c2 2e 60 3c stb %g1, [ %i1 + 0x3c ]
_Timestamp_To_timespec( &tod_as_timestamp, tod_as_timespec );
200758c: f8 1f bf e0 ldd [ %fp + -32 ], %i4
static inline void _Timestamp64_implementation_To_timespec(
const Timestamp64_Control *_timestamp,
struct timespec *_timespec
)
{
_timespec->tv_sec = (time_t) (*_timestamp / 1000000000L);
2007590: 94 10 20 00 clr %o2
2007594: 90 10 00 1c mov %i4, %o0
2007598: 92 10 00 1d mov %i5, %o1
200759c: 17 0e e6 b2 sethi %hi(0x3b9ac800), %o3
20075a0: 40 00 49 01 call 20199a4 <__divdi3>
20075a4: 96 12 e2 00 or %o3, 0x200, %o3 ! 3b9aca00 <RAM_END+0x395aca00>
_timespec->tv_nsec = (long) (*_timestamp % 1000000000L);
20075a8: 90 10 00 1c mov %i4, %o0
static inline void _Timestamp64_implementation_To_timespec(
const Timestamp64_Control *_timestamp,
struct timespec *_timespec
)
{
_timespec->tv_sec = (time_t) (*_timestamp / 1000000000L);
20075ac: d2 26 60 6c st %o1, [ %i1 + 0x6c ]
_timespec->tv_nsec = (long) (*_timestamp % 1000000000L);
20075b0: 94 10 20 00 clr %o2
20075b4: 92 10 00 1d mov %i5, %o1
20075b8: 17 0e e6 b2 sethi %hi(0x3b9ac800), %o3
20075bc: 40 00 49 e5 call 2019d50 <__moddi3>
20075c0: 96 12 e2 00 or %o3, 0x200, %o3 ! 3b9aca00 <RAM_END+0x395aca00>
20075c4: d2 26 60 70 st %o1, [ %i1 + 0x70 ]
_TOD_Get( &ptimer->time );
_Thread_Enable_dispatch();
20075c8: 40 00 0c 46 call 200a6e0 <_Thread_Enable_dispatch>
20075cc: b0 10 20 00 clr %i0
20075d0: 81 c7 e0 08 ret
20075d4: 81 e8 00 00 restore
#endif
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EINVAL );
20075d8: 40 00 23 37 call 20102b4 <__errno>
20075dc: b0 10 3f ff mov -1, %i0
20075e0: 82 10 20 16 mov 0x16, %g1
20075e4: c2 22 00 00 st %g1, [ %o0 ]
}
20075e8: 81 c7 e0 08 ret
20075ec: 81 e8 00 00 restore
020075b0 <ualarm>:
useconds_t ualarm(
useconds_t useconds,
useconds_t interval
)
{
20075b0: 9d e3 bf 98 save %sp, -104, %sp
/*
* Initialize the timer used to implement alarm().
*/
if ( !the_timer->routine ) {
20075b4: 3b 00 80 7f sethi %hi(0x201fc00), %i5
20075b8: ba 17 63 b8 or %i5, 0x3b8, %i5 ! 201ffb8 <_POSIX_signals_Ualarm_timer>
20075bc: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
20075c0: 80 a0 60 00 cmp %g1, 0
20075c4: 12 80 00 0a bne 20075ec <ualarm+0x3c>
20075c8: b8 10 00 18 mov %i0, %i4
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
the_watchdog->routine = routine;
20075cc: 03 00 80 1d sethi %hi(0x2007400), %g1
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
20075d0: c0 27 60 08 clr [ %i5 + 8 ]
the_watchdog->routine = routine;
20075d4: 82 10 61 84 or %g1, 0x184, %g1
the_watchdog->id = id;
20075d8: c0 27 60 20 clr [ %i5 + 0x20 ]
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
the_watchdog->routine = routine;
20075dc: c2 27 60 1c st %g1, [ %i5 + 0x1c ]
the_watchdog->id = id;
the_watchdog->user_data = user_data;
20075e0: c0 27 60 24 clr [ %i5 + 0x24 ]
useconds_t ualarm(
useconds_t useconds,
useconds_t interval
)
{
useconds_t remaining = 0;
20075e4: 10 80 00 1b b 2007650 <ualarm+0xa0>
20075e8: b0 10 20 00 clr %i0
if ( !the_timer->routine ) {
_Watchdog_Initialize( the_timer, _POSIX_signals_Ualarm_TSR, 0, NULL );
} else {
Watchdog_States state;
state = _Watchdog_Remove( the_timer );
20075ec: 40 00 0f f1 call 200b5b0 <_Watchdog_Remove>
20075f0: 90 10 00 1d mov %i5, %o0
if ( (state == WATCHDOG_ACTIVE) || (state == WATCHDOG_REMOVE_IT) ) {
20075f4: 90 02 3f fe add %o0, -2, %o0
20075f8: 80 a2 20 01 cmp %o0, 1
20075fc: 18 80 00 15 bgu 2007650 <ualarm+0xa0> <== NEVER TAKEN
2007600: b0 10 20 00 clr %i0
* 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);
2007604: c2 07 60 0c ld [ %i5 + 0xc ], %g1
2007608: d0 07 60 14 ld [ %i5 + 0x14 ], %o0
/* remaining is now in ticks */
_Timespec_From_ticks( ticks, &tp );
200760c: 92 07 bf f8 add %fp, -8, %o1
* 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);
2007610: 90 02 00 01 add %o0, %g1, %o0
2007614: c2 07 60 18 ld [ %i5 + 0x18 ], %g1
/* remaining is now in ticks */
_Timespec_From_ticks( ticks, &tp );
2007618: 40 00 0e 83 call 200b024 <_Timespec_From_ticks>
200761c: 90 22 00 01 sub %o0, %g1, %o0
remaining = tp.tv_sec * TOD_MICROSECONDS_PER_SECOND;
2007620: c2 07 bf f8 ld [ %fp + -8 ], %g1
remaining += tp.tv_nsec / 1000;
2007624: d0 07 bf fc ld [ %fp + -4 ], %o0
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;
2007628: 85 28 60 03 sll %g1, 3, %g2
200762c: 87 28 60 08 sll %g1, 8, %g3
2007630: 84 20 c0 02 sub %g3, %g2, %g2
remaining += tp.tv_nsec / 1000;
2007634: 92 10 23 e8 mov 0x3e8, %o1
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;
2007638: b1 28 a0 06 sll %g2, 6, %i0
200763c: b0 26 00 02 sub %i0, %g2, %i0
remaining += tp.tv_nsec / 1000;
2007640: 40 00 4c 62 call 201a7c8 <.div>
2007644: b0 06 00 01 add %i0, %g1, %i0
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;
2007648: b1 2e 20 06 sll %i0, 6, %i0
remaining += tp.tv_nsec / 1000;
200764c: b0 02 00 18 add %o0, %i0, %i0
/*
* 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 ) {
2007650: 80 a7 20 00 cmp %i4, 0
2007654: 02 80 00 19 be 20076b8 <ualarm+0x108>
2007658: 3b 00 03 d0 sethi %hi(0xf4000), %i5
Watchdog_Interval ticks;
tp.tv_sec = useconds / TOD_MICROSECONDS_PER_SECOND;
200765c: 90 10 00 1c mov %i4, %o0
2007660: 40 00 4c 58 call 201a7c0 <.udiv>
2007664: 92 17 62 40 or %i5, 0x240, %o1
tp.tv_nsec = (useconds % TOD_MICROSECONDS_PER_SECOND) * 1000;
2007668: 92 17 62 40 or %i5, 0x240, %o1
* 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;
200766c: d0 27 bf f8 st %o0, [ %fp + -8 ]
tp.tv_nsec = (useconds % TOD_MICROSECONDS_PER_SECOND) * 1000;
2007670: 40 00 4d 00 call 201aa70 <.urem>
2007674: 90 10 00 1c mov %i4, %o0
2007678: 85 2a 20 07 sll %o0, 7, %g2
200767c: 83 2a 20 02 sll %o0, 2, %g1
2007680: 82 20 80 01 sub %g2, %g1, %g1
2007684: 90 00 40 08 add %g1, %o0, %o0
2007688: 91 2a 20 03 sll %o0, 3, %o0
200768c: d0 27 bf fc st %o0, [ %fp + -4 ]
ticks = _Timespec_To_ticks( &tp );
2007690: 40 00 0e 7a call 200b078 <_Timespec_To_ticks>
2007694: 90 07 bf f8 add %fp, -8, %o0
if ( ticks == 0 )
ticks = 1;
_Watchdog_Insert_ticks( the_timer, _Timespec_To_ticks( &tp ) );
2007698: 40 00 0e 78 call 200b078 <_Timespec_To_ticks>
200769c: 90 07 bf f8 add %fp, -8, %o0
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
20076a0: 13 00 80 7f sethi %hi(0x201fc00), %o1
20076a4: 92 12 63 b8 or %o1, 0x3b8, %o1 ! 201ffb8 <_POSIX_signals_Ualarm_timer>
20076a8: d0 22 60 0c st %o0, [ %o1 + 0xc ]
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
20076ac: 11 00 80 7d sethi %hi(0x201f400), %o0
20076b0: 40 00 0f 68 call 200b450 <_Watchdog_Insert>
20076b4: 90 12 23 58 or %o0, 0x358, %o0 ! 201f758 <_Watchdog_Ticks_chain>
}
return remaining;
}
20076b8: 81 c7 e0 08 ret
20076bc: 81 e8 00 00 restore
02007138 <unmount>:
return mt_entry == root->mt_entry || mt_entry == current->mt_entry;
}
int unmount( const char *path )
{
2007138: 9d e3 bf 60 save %sp, -160, %sp
int rv = 0;
rtems_filesystem_eval_path_context_t ctx;
int eval_flags = RTEMS_FS_FOLLOW_LINK;
const rtems_filesystem_location_info_t *currentloc =
200713c: 94 10 20 18 mov 0x18, %o2
2007140: 92 10 00 18 mov %i0, %o1
2007144: 7f ff f7 1c call 2004db4 <rtems_filesystem_eval_path_start>
2007148: 90 07 bf c8 add %fp, -56, %o0
rtems_filesystem_eval_path_start( &ctx, path, eval_flags );
rtems_filesystem_mount_table_entry_t *mt_entry = currentloc->mt_entry;
200714c: fa 02 20 14 ld [ %o0 + 0x14 ], %i5
const rtems_filesystem_location_info_t *loc
)
{
const rtems_filesystem_mount_table_entry_t *mt_entry = loc->mt_entry;
return (*mt_entry->ops->are_nodes_equal_h)(
2007150: c2 07 60 0c ld [ %i5 + 0xc ], %g1
2007154: c2 00 60 10 ld [ %g1 + 0x10 ], %g1
2007158: 9f c0 40 00 call %g1
200715c: d2 07 60 24 ld [ %i5 + 0x24 ], %o1
if ( rtems_filesystem_location_is_root( currentloc ) ) {
2007160: 80 8a 20 ff btst 0xff, %o0
2007164: 02 80 00 26 be 20071fc <unmount+0xc4>
2007168: 03 00 80 74 sethi %hi(0x201d000), %g1
static bool contains_root_or_current_directory(
const rtems_filesystem_mount_table_entry_t *mt_entry
)
{
const rtems_filesystem_location_info_t *root =
&rtems_filesystem_root->location;
200716c: c2 00 63 c8 ld [ %g1 + 0x3c8 ], %g1 ! 201d3c8 <rtems_current_user_env>
const rtems_filesystem_location_info_t *current =
&rtems_filesystem_current->location;
2007170: c4 00 40 00 ld [ %g1 ], %g2
return mt_entry == root->mt_entry || mt_entry == current->mt_entry;
2007174: c2 00 60 04 ld [ %g1 + 4 ], %g1
2007178: c2 00 60 14 ld [ %g1 + 0x14 ], %g1
200717c: 80 a7 40 01 cmp %i5, %g1
2007180: 22 80 00 06 be,a 2007198 <unmount+0x60>
2007184: 82 10 20 01 mov 1, %g1
2007188: c2 00 a0 14 ld [ %g2 + 0x14 ], %g1
200718c: 82 1f 40 01 xor %i5, %g1, %g1
2007190: 80 a0 00 01 cmp %g0, %g1
2007194: 82 60 3f ff subx %g0, -1, %g1
const rtems_filesystem_location_info_t *currentloc =
rtems_filesystem_eval_path_start( &ctx, path, eval_flags );
rtems_filesystem_mount_table_entry_t *mt_entry = currentloc->mt_entry;
if ( rtems_filesystem_location_is_root( currentloc ) ) {
if ( !contains_root_or_current_directory( mt_entry ) ) {
2007198: 80 a0 60 00 cmp %g1, 0
200719c: 12 80 00 14 bne 20071ec <unmount+0xb4>
20071a0: 01 00 00 00 nop
const rtems_filesystem_operations_table *mt_point_ops =
mt_entry->mt_point_node->location.mt_entry->ops;
20071a4: c2 07 60 20 ld [ %i5 + 0x20 ], %g1
20071a8: c2 00 60 14 ld [ %g1 + 0x14 ], %g1
rv = (*mt_point_ops->unmount_h)( mt_entry );
20071ac: c2 00 60 0c ld [ %g1 + 0xc ], %g1
20071b0: c2 00 60 38 ld [ %g1 + 0x38 ], %g1
20071b4: 9f c0 40 00 call %g1
20071b8: 90 10 00 1d mov %i5, %o0
if ( rv == 0 ) {
20071bc: b0 92 20 00 orcc %o0, 0, %i0
20071c0: 12 80 00 14 bne 2007210 <unmount+0xd8>
20071c4: 01 00 00 00 nop
rtems_id self_task_id = rtems_task_self();
20071c8: 40 00 03 cb call 20080f4 <rtems_task_self>
20071cc: 01 00 00 00 nop
rtems_filesystem_mt_entry_declare_lock_context( lock_context );
rtems_filesystem_mt_entry_lock( lock_context );
20071d0: 7f ff ed 0c call 2002600 <sparc_disable_interrupts>
20071d4: b8 10 00 08 mov %o0, %i4
mt_entry->unmount_task = self_task_id;
20071d8: f8 27 60 3c st %i4, [ %i5 + 0x3c ]
mt_entry->mounted = false;
20071dc: c0 2f 60 28 clrb [ %i5 + 0x28 ]
rtems_filesystem_mt_entry_unlock( lock_context );
20071e0: 7f ff ed 0c call 2002610 <sparc_enable_interrupts>
20071e4: 01 00 00 00 nop
20071e8: 30 80 00 0a b,a 2007210 <unmount+0xd8>
}
} else {
errno = EBUSY;
20071ec: 40 00 22 f7 call 200fdc8 <__errno>
20071f0: 01 00 00 00 nop
20071f4: 10 80 00 05 b 2007208 <unmount+0xd0>
20071f8: 82 10 20 10 mov 0x10, %g1 ! 10 <PROM_START+0x10>
rv = -1;
}
} else {
errno = EACCES;
20071fc: 40 00 22 f3 call 200fdc8 <__errno>
2007200: 01 00 00 00 nop
2007204: 82 10 20 0d mov 0xd, %g1 ! d <PROM_START+0xd>
2007208: c2 22 00 00 st %g1, [ %o0 ]
rv = -1;
200720c: b0 10 3f ff mov -1, %i0
}
rtems_filesystem_eval_path_cleanup( &ctx );
2007210: 7f ff f7 25 call 2004ea4 <rtems_filesystem_eval_path_cleanup>
2007214: 90 07 bf c8 add %fp, -56, %o0
if ( rv == 0 ) {
2007218: 80 a6 20 00 cmp %i0, 0
200721c: 12 80 00 0b bne 2007248 <unmount+0x110>
2007220: 90 10 20 02 mov 2, %o0
rtems_event_set out;
rtems_status_code sc = rtems_event_receive(
2007224: 92 10 20 00 clr %o1
2007228: 94 10 20 00 clr %o2
200722c: 40 00 01 14 call 200767c <rtems_event_receive>
2007230: 96 07 bf c4 add %fp, -60, %o3
RTEMS_EVENT_ALL | RTEMS_WAIT,
RTEMS_NO_TIMEOUT,
&out
);
if ( sc != RTEMS_SUCCESSFUL ) {
2007234: 80 a2 20 00 cmp %o0, 0
2007238: 02 80 00 04 be 2007248 <unmount+0x110> <== ALWAYS TAKEN
200723c: 11 37 ab 6f sethi %hi(0xdeadbc00), %o0
rtems_fatal_error_occurred( 0xdeadbeef );
2007240: 40 00 04 5a call 20083a8 <rtems_fatal_error_occurred> <== NOT EXECUTED
2007244: 90 12 22 ef or %o0, 0x2ef, %o0 ! deadbeef <RAM_END+0xdc6dbeef><== NOT EXECUTED
}
}
return rv;
}
2007248: 81 c7 e0 08 ret
200724c: 81 e8 00 00 restore
0201a29c <write>:
ssize_t write(
int fd,
const void *buffer,
size_t count
)
{
201a29c: 9d e3 bf a0 save %sp, -96, %sp
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
201a2a0: 03 00 80 73 sethi %hi(0x201cc00), %g1
201a2a4: c2 00 62 20 ld [ %g1 + 0x220 ], %g1 ! 201ce20 <rtems_libio_number_iops>
201a2a8: 80 a6 00 01 cmp %i0, %g1
201a2ac: 1a 80 00 16 bcc 201a304 <write+0x68>
201a2b0: 83 2e 20 03 sll %i0, 3, %g1
iop = rtems_libio_iop( fd );
201a2b4: b1 2e 20 06 sll %i0, 6, %i0
201a2b8: b0 26 00 01 sub %i0, %g1, %i0
201a2bc: 03 00 80 76 sethi %hi(0x201d800), %g1
201a2c0: d0 00 61 40 ld [ %g1 + 0x140 ], %o0 ! 201d940 <rtems_libio_iops>
201a2c4: 90 02 00 18 add %o0, %i0, %o0
rtems_libio_check_is_open( iop );
201a2c8: c2 02 20 10 ld [ %o0 + 0x10 ], %g1
201a2cc: 80 88 61 00 btst 0x100, %g1
201a2d0: 02 80 00 0d be 201a304 <write+0x68>
201a2d4: 80 a6 60 00 cmp %i1, 0
rtems_libio_check_buffer( buffer );
201a2d8: 12 80 00 06 bne 201a2f0 <write+0x54> <== ALWAYS TAKEN
201a2dc: 80 a6 a0 00 cmp %i2, 0
201a2e0: 7f ff d5 cc call 200fa10 <__errno> <== NOT EXECUTED
201a2e4: 01 00 00 00 nop <== NOT EXECUTED
201a2e8: 10 80 00 0a b 201a310 <write+0x74> <== NOT EXECUTED
201a2ec: 82 10 20 16 mov 0x16, %g1 ! 16 <PROM_START+0x16> <== NOT EXECUTED
rtems_libio_check_count( count );
201a2f0: 02 80 00 10 be 201a330 <write+0x94>
201a2f4: b0 10 20 00 clr %i0
rtems_libio_check_permissions_with_error( iop, LIBIO_FLAGS_WRITE, EBADF );
201a2f8: 80 88 60 04 btst 4, %g1
201a2fc: 32 80 00 08 bne,a 201a31c <write+0x80>
201a300: c2 02 20 24 ld [ %o0 + 0x24 ], %g1
201a304: 7f ff d5 c3 call 200fa10 <__errno>
201a308: 01 00 00 00 nop
201a30c: 82 10 20 09 mov 9, %g1 ! 9 <PROM_START+0x9>
201a310: c2 22 00 00 st %g1, [ %o0 ]
201a314: 81 c7 e0 08 ret
201a318: 91 e8 3f ff restore %g0, -1, %o0
/*
* Now process the write() request.
*/
return (*iop->pathinfo.handlers->write_h)( iop, buffer, count );
201a31c: 92 10 00 19 mov %i1, %o1
201a320: c2 00 60 0c ld [ %g1 + 0xc ], %g1
201a324: 9f c0 40 00 call %g1
201a328: 94 10 00 1a mov %i2, %o2
201a32c: b0 10 00 08 mov %o0, %i0
}
201a330: 81 c7 e0 08 ret
201a334: 81 e8 00 00 restore
02008078 <writev>:
ssize_t writev(
int fd,
const struct iovec *iov,
int iovcnt
)
{
2008078: 9d e3 bf a0 save %sp, -96, %sp
int bytes;
rtems_libio_t *iop;
ssize_t old;
bool all_zeros;
rtems_libio_check_fd( fd );
200807c: 03 00 80 76 sethi %hi(0x201d800), %g1
2008080: c2 00 61 30 ld [ %g1 + 0x130 ], %g1 ! 201d930 <rtems_libio_number_iops>
2008084: 80 a6 00 01 cmp %i0, %g1
2008088: 2a 80 00 03 bcs,a 2008094 <writev+0x1c>
200808c: 83 2e 20 03 sll %i0, 3, %g1
2008090: 30 80 00 0c b,a 20080c0 <writev+0x48>
iop = rtems_libio_iop( fd );
2008094: b1 2e 20 06 sll %i0, 6, %i0
2008098: b0 26 00 01 sub %i0, %g1, %i0
200809c: 03 00 80 79 sethi %hi(0x201e400), %g1
20080a0: f8 00 60 50 ld [ %g1 + 0x50 ], %i4 ! 201e450 <rtems_libio_iops>
20080a4: b8 07 00 18 add %i4, %i0, %i4
rtems_libio_check_is_open( iop );
20080a8: c2 07 20 10 ld [ %i4 + 0x10 ], %g1
20080ac: 80 88 61 00 btst 0x100, %g1
20080b0: 02 80 00 04 be 20080c0 <writev+0x48>
20080b4: 80 88 60 04 btst 4, %g1
rtems_libio_check_permissions_with_error( iop, LIBIO_FLAGS_WRITE, EBADF );
20080b8: 12 80 00 06 bne 20080d0 <writev+0x58> <== ALWAYS TAKEN
20080bc: 80 a6 60 00 cmp %i1, 0
20080c0: 40 00 21 a3 call 201074c <__errno>
20080c4: 01 00 00 00 nop
20080c8: 10 80 00 20 b 2008148 <writev+0xd0>
20080cc: 82 10 20 09 mov 9, %g1 ! 9 <PROM_START+0x9>
/*
* Argument validation on IO vector
*/
if ( !iov )
20080d0: 02 80 00 1b be 200813c <writev+0xc4>
20080d4: 80 a6 a0 00 cmp %i2, 0
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iovcnt <= 0 )
20080d8: 04 80 00 19 ble 200813c <writev+0xc4>
20080dc: 80 a6 a4 00 cmp %i2, 0x400
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iovcnt > IOV_MAX )
20080e0: 24 80 00 03 ble,a 20080ec <writev+0x74> <== ALWAYS TAKEN
20080e4: b5 2e a0 03 sll %i2, 3, %i2
20080e8: 30 80 00 15 b,a 200813c <writev+0xc4> <== NOT EXECUTED
#include <sys/uio.h>
#include <rtems/libio_.h>
#include <rtems/seterr.h>
ssize_t writev(
20080ec: 82 10 20 00 clr %g1
20080f0: 86 10 20 01 mov 1, %g3
20080f4: 84 10 20 00 clr %g2
/*
* 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 )
20080f8: c8 06 40 01 ld [ %i1 + %g1 ], %g4
20080fc: 80 a1 20 00 cmp %g4, 0
2008100: 02 80 00 0f be 200813c <writev+0xc4>
2008104: 88 06 40 01 add %i1, %g1, %g4
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iov[v].iov_len )
2008108: c8 01 20 04 ld [ %g4 + 4 ], %g4
all_zeros = false;
200810c: 80 a0 00 04 cmp %g0, %g4
2008110: ba 40 3f ff addx %g0, -1, %i5
/* check for wrap */
old = total;
total += iov[v].iov_len;
if ( total < old || total > SSIZE_MAX )
2008114: 88 81 00 02 addcc %g4, %g2, %g4
2008118: 0c 80 00 09 bneg 200813c <writev+0xc4>
200811c: 86 08 c0 1d and %g3, %i5, %g3
2008120: 80 a1 00 02 cmp %g4, %g2
2008124: 06 80 00 03 bl 2008130 <writev+0xb8>
2008128: ba 10 20 01 mov 1, %i5
200812c: ba 10 20 00 clr %i5
2008130: 80 8f 60 ff btst 0xff, %i5
2008134: 02 80 00 07 be 2008150 <writev+0xd8>
2008138: 82 00 60 08 add %g1, 8, %g1
rtems_set_errno_and_return_minus_one( EINVAL );
200813c: 40 00 21 84 call 201074c <__errno>
2008140: 01 00 00 00 nop
2008144: 82 10 20 16 mov 0x16, %g1 ! 16 <PROM_START+0x16>
2008148: 10 80 00 21 b 20081cc <writev+0x154>
200814c: c2 22 00 00 st %g1, [ %o0 ]
* 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++ ) {
2008150: 80 a0 40 1a cmp %g1, %i2
2008154: 12 bf ff e9 bne 20080f8 <writev+0x80>
2008158: 84 10 00 04 mov %g4, %g2
}
/*
* A writev with all zeros is supposed to have no effect per OpenGroup.
*/
if ( all_zeros == true ) {
200815c: 80 88 e0 ff btst 0xff, %g3
2008160: 12 80 00 19 bne 20081c4 <writev+0x14c>
2008164: b0 10 20 00 clr %i0
2008168: ba 10 20 00 clr %i5
#include <sys/uio.h>
#include <rtems/libio_.h>
#include <rtems/seterr.h>
ssize_t writev(
200816c: b6 06 40 1d add %i1, %i5, %i3
/*
* Now process the writev().
*/
for ( total=0, v=0 ; v < iovcnt ; v++ ) {
/* all zero lengths has no effect */
if ( iov[v].iov_len == 0 )
2008170: d4 06 e0 04 ld [ %i3 + 4 ], %o2
2008174: 80 a2 a0 00 cmp %o2, 0
2008178: 22 80 00 10 be,a 20081b8 <writev+0x140> <== NEVER TAKEN
200817c: ba 07 60 08 add %i5, 8, %i5 <== NOT EXECUTED
continue;
bytes = (*iop->pathinfo.handlers->write_h)(
2008180: c2 07 20 24 ld [ %i4 + 0x24 ], %g1
2008184: d2 06 40 1d ld [ %i1 + %i5 ], %o1
2008188: c2 00 60 0c ld [ %g1 + 0xc ], %g1
200818c: 9f c0 40 00 call %g1
2008190: 90 10 00 1c mov %i4, %o0
iop,
iov[v].iov_base,
iov[v].iov_len
);
if ( bytes < 0 )
2008194: 80 a2 20 00 cmp %o0, 0
2008198: 26 80 00 0b bl,a 20081c4 <writev+0x14c> <== NEVER TAKEN
200819c: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
return -1;
if ( bytes > 0 ) {
20081a0: 32 80 00 02 bne,a 20081a8 <writev+0x130> <== ALWAYS TAKEN
20081a4: b0 06 00 08 add %i0, %o0, %i0
total += bytes;
}
if (bytes != iov[ v ].iov_len)
20081a8: c2 06 e0 04 ld [ %i3 + 4 ], %g1
20081ac: 80 a2 00 01 cmp %o0, %g1
20081b0: 12 80 00 05 bne 20081c4 <writev+0x14c> <== NEVER TAKEN
20081b4: ba 07 60 08 add %i5, 8, %i5
}
/*
* Now process the writev().
*/
for ( total=0, v=0 ; v < iovcnt ; v++ ) {
20081b8: 80 a7 40 1a cmp %i5, %i2
20081bc: 12 bf ff ed bne 2008170 <writev+0xf8>
20081c0: b6 06 40 1d add %i1, %i5, %i3
20081c4: 81 c7 e0 08 ret
20081c8: 81 e8 00 00 restore
iov[v].iov_base,
iov[v].iov_len
);
if ( bytes < 0 )
return -1;
20081cc: b0 10 3f ff mov -1, %i0
if (bytes != iov[ v ].iov_len)
break;
}
return total;
}
20081d0: 81 c7 e0 08 ret
20081d4: 81 e8 00 00 restore