RTEMS 4.11Annotated Report
Sat Jul 14 16:19:04 2012
0200b764 <IMFS_chown>:
int IMFS_chown(
const rtems_filesystem_location_info_t *loc,
uid_t owner,
gid_t group
)
{
200b764: 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();
200b768: 40 00 02 4e call 200c0a0 <geteuid>
200b76c: fa 06 20 08 ld [ %i0 + 8 ], %i5
if ( ( st_uid != jnode->st_uid ) && ( st_uid != 0 ) )
200b770: c2 17 60 3c lduh [ %i5 + 0x3c ], %g1
200b774: 91 2a 20 10 sll %o0, 0x10, %o0
200b778: 91 32 20 10 srl %o0, 0x10, %o0
200b77c: 80 a2 00 01 cmp %o0, %g1
200b780: 02 80 00 0a be 200b7a8 <IMFS_chown+0x44>
200b784: 80 a2 20 00 cmp %o0, 0
200b788: 22 80 00 09 be,a 200b7ac <IMFS_chown+0x48> <== NEVER TAKEN
200b78c: f2 37 60 3c sth %i1, [ %i5 + 0x3c ] <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EPERM );
200b790: 40 00 10 a2 call 200fa18 <__errno>
200b794: b0 10 3f ff mov -1, %i0
200b798: 82 10 20 01 mov 1, %g1
200b79c: c2 22 00 00 st %g1, [ %o0 ]
200b7a0: 81 c7 e0 08 ret
200b7a4: 81 e8 00 00 restore
#endif
jnode->st_uid = owner;
200b7a8: f2 37 60 3c sth %i1, [ %i5 + 0x3c ]
jnode->st_gid = group;
200b7ac: f4 37 60 3e sth %i2, [ %i5 + 0x3e ]
IMFS_update_ctime( jnode );
200b7b0: 90 07 bf f8 add %fp, -8, %o0
200b7b4: 7f ff e0 34 call 2003884 <gettimeofday>
200b7b8: 92 10 20 00 clr %o1
200b7bc: c2 07 bf f8 ld [ %fp + -8 ], %g1
200b7c0: c2 27 60 48 st %g1, [ %i5 + 0x48 ]
return 0;
}
200b7c4: 81 c7 e0 08 ret
200b7c8: 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 33 call 2013da0 <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 2b call 2013da0 <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 e8 call 2013cd0 <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 bd call 2013c60 <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 b6 call 2013c60 <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 fd call 2013da0 <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 a8 call 2013c60 <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 d9 call 2015934 <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
0200b908 <IMFS_eval_token>:
rtems_filesystem_eval_path_context_t *ctx,
void *arg,
const char *token,
size_t tokenlen
)
{
200b908: 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;
200b90c: f8 06 20 20 ld [ %i0 + 0x20 ], %i4
bool access_ok = rtems_filesystem_eval_path_check_access(
200b910: 90 10 00 18 mov %i0, %o0
200b914: d4 07 20 30 ld [ %i4 + 0x30 ], %o2
200b918: d6 17 20 3c lduh [ %i4 + 0x3c ], %o3
200b91c: d8 17 20 3e lduh [ %i4 + 0x3e ], %o4
200b920: 40 00 02 f0 call 200c4e0 <rtems_filesystem_eval_path_check_access>
200b924: 92 10 20 01 mov 1, %o1
dir->st_mode,
dir->st_uid,
dir->st_gid
);
if ( access_ok ) {
200b928: 80 8a 20 ff btst 0xff, %o0
200b92c: 12 80 00 04 bne 200b93c <IMFS_eval_token+0x34>
200b930: 80 a6 e0 01 cmp %i3, 1
void *arg,
const char *token,
size_t tokenlen
)
{
rtems_filesystem_eval_path_generic_status status =
200b934: 81 c7 e0 08 ret
200b938: 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] == '.';
200b93c: 12 80 00 06 bne 200b954 <IMFS_eval_token+0x4c>
200b940: 82 10 20 00 clr %g1
200b944: c2 4e 80 00 ldsb [ %i2 ], %g1
200b948: 82 18 60 2e xor %g1, 0x2e, %g1
200b94c: 80 a0 00 01 cmp %g0, %g1
200b950: 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 ) ) {
200b954: 80 a0 60 00 cmp %g1, 0
200b958: 12 80 00 2b bne 200ba04 <IMFS_eval_token+0xfc>
200b95c: 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] == '.';
200b960: 12 80 00 0b bne 200b98c <IMFS_eval_token+0x84>
200b964: 80 a0 60 00 cmp %g1, 0
200b968: c4 4e 80 00 ldsb [ %i2 ], %g2
200b96c: 80 a0 a0 2e cmp %g2, 0x2e
200b970: 12 80 00 07 bne 200b98c <IMFS_eval_token+0x84>
200b974: 80 a0 60 00 cmp %g1, 0
200b978: c2 4e a0 01 ldsb [ %i2 + 1 ], %g1
200b97c: 82 18 60 2e xor %g1, 0x2e, %g1
200b980: 80 a0 00 01 cmp %g0, %g1
200b984: 82 60 3f ff subx %g0, -1, %g1
return dir;
} else {
if ( rtems_filesystem_is_parent_directory( token, tokenlen ) ) {
200b988: 80 a0 60 00 cmp %g1, 0
200b98c: 22 80 00 04 be,a 200b99c <IMFS_eval_token+0x94>
200b990: fa 07 20 50 ld [ %i4 + 0x50 ], %i5
return dir->Parent;
200b994: 10 80 00 17 b 200b9f0 <IMFS_eval_token+0xe8>
200b998: 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 );
200b99c: 10 80 00 10 b 200b9dc <IMFS_eval_token+0xd4>
200b9a0: 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
200b9a4: 92 10 00 1a mov %i2, %o1
200b9a8: 40 00 15 cb call 20110d4 <strncmp>
200b9ac: 94 10 00 1b mov %i3, %o2
&& entry->name [tokenlen] == '\0';
200b9b0: 80 a2 20 00 cmp %o0, 0
200b9b4: 12 80 00 06 bne 200b9cc <IMFS_eval_token+0xc4>
200b9b8: 82 10 20 00 clr %g1
200b9bc: 82 07 40 1b add %i5, %i3, %g1
200b9c0: c2 48 60 0c ldsb [ %g1 + 0xc ], %g1
200b9c4: 80 a0 00 01 cmp %g0, %g1
200b9c8: 82 60 3f ff subx %g0, -1, %g1
if ( match ) {
200b9cc: 80 a0 60 00 cmp %g1, 0
200b9d0: 12 80 00 09 bne 200b9f4 <IMFS_eval_token+0xec>
200b9d4: 80 a7 60 00 cmp %i5, 0
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Next(
Chain_Node *the_node
)
{
return the_node->next;
200b9d8: 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 ) {
200b9dc: 80 a7 40 19 cmp %i5, %i1
200b9e0: 12 bf ff f1 bne 200b9a4 <IMFS_eval_token+0x9c>
200b9e4: 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;
200b9e8: 81 c7 e0 08 ret
200b9ec: 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 ) {
200b9f0: 80 a7 60 00 cmp %i5, 0
200b9f4: 32 80 00 06 bne,a 200ba0c <IMFS_eval_token+0x104>
200b9f8: 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;
200b9fc: 81 c7 e0 08 ret
200ba00: 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 ) ) {
200ba04: 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 );
200ba08: 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;
200ba0c: c6 06 20 10 ld [ %i0 + 0x10 ], %g3
200ba10: 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;
200ba14: c2 07 60 4c ld [ %i5 + 0x4c ], %g1
200ba18: 84 60 3f ff subx %g0, -1, %g2
200ba1c: 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;
200ba20: 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)) {
200ba24: 80 a0 60 02 cmp %g1, 2
200ba28: 12 80 00 0a bne 200ba50 <IMFS_eval_token+0x148>
200ba2c: 88 10 00 02 mov %g2, %g4
200ba30: 80 a0 a0 00 cmp %g2, 0
200ba34: 22 80 00 2b be,a 200bae0 <IMFS_eval_token+0x1d8>
200ba38: fa 07 60 50 ld [ %i5 + 0x50 ], %i5
200ba3c: 80 88 e0 08 btst 8, %g3
200ba40: 22 80 00 29 be,a 200bae4 <IMFS_eval_token+0x1dc>
200ba44: c2 17 20 34 lduh [ %i4 + 0x34 ], %g1
entry = entry->info.hard_link.link_node;
200ba48: 10 80 00 26 b 200bae0 <IMFS_eval_token+0x1d8>
200ba4c: fa 07 60 50 ld [ %i5 + 0x50 ], %i5
}
if ( type == IMFS_SYM_LINK && (follow_sym_link || !terminal)) {
200ba50: 80 a0 60 03 cmp %g1, 3
200ba54: 12 80 00 10 bne 200ba94 <IMFS_eval_token+0x18c>
200ba58: 80 a0 60 00 cmp %g1, 0
200ba5c: 80 a0 a0 00 cmp %g2, 0
200ba60: 02 80 00 04 be 200ba70 <IMFS_eval_token+0x168>
200ba64: 80 88 e0 10 btst 0x10, %g3
200ba68: 22 80 00 1f be,a 200bae4 <IMFS_eval_token+0x1dc>
200ba6c: c2 17 20 34 lduh [ %i4 + 0x34 ], %g1
const char *target = entry->info.sym_link.name;
200ba70: fa 07 60 50 ld [ %i5 + 0x50 ], %i5
rtems_filesystem_eval_path_recursive( ctx, target, strlen( target ) );
200ba74: 40 00 15 66 call 201100c <strlen>
200ba78: 90 10 00 1d mov %i5, %o0
200ba7c: 92 10 00 1d mov %i5, %o1
200ba80: 94 10 00 08 mov %o0, %o2
200ba84: 7f ff e4 7a call 2004c6c <rtems_filesystem_eval_path_recursive>
200ba88: 90 10 00 18 mov %i0, %o0
void *arg,
const char *token,
size_t tokenlen
)
{
rtems_filesystem_eval_path_generic_status status =
200ba8c: 81 c7 e0 08 ret
200ba90: 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 ) {
200ba94: 32 80 00 14 bne,a 200bae4 <IMFS_eval_token+0x1dc>
200ba98: c2 17 20 34 lduh [ %i4 + 0x34 ], %g1
if ( node->info.directory.mt_fs != NULL ) {
200ba9c: d2 07 60 5c ld [ %i5 + 0x5c ], %o1
200baa0: 80 a2 60 00 cmp %o1, 0
200baa4: 02 80 00 0f be 200bae0 <IMFS_eval_token+0x1d8>
200baa8: 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(
200baac: d4 07 60 30 ld [ %i5 + 0x30 ], %o2
200bab0: d6 17 60 3c lduh [ %i5 + 0x3c ], %o3
200bab4: 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;
200bab8: 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(
200babc: 40 00 02 89 call 200c4e0 <rtems_filesystem_eval_path_check_access>
200bac0: 92 10 20 01 mov 1, %o1
RTEMS_FS_PERMS_EXEC,
entry->st_mode,
entry->st_uid,
entry->st_gid
);
if ( access_ok ) {
200bac4: 80 8a 20 ff btst 0xff, %o0
200bac8: 02 80 00 04 be 200bad8 <IMFS_eval_token+0x1d0> <== NEVER TAKEN
200bacc: 90 10 00 18 mov %i0, %o0
rtems_filesystem_eval_path_restart( ctx, fs_root_ptr );
200bad0: 7f ff e4 4e call 2004c08 <rtems_filesystem_eval_path_restart>
200bad4: 92 10 00 1c mov %i4, %o1
void *arg,
const char *token,
size_t tokenlen
)
{
rtems_filesystem_eval_path_generic_status status =
200bad8: 81 c7 e0 08 ret
200badc: 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;
200bae0: c2 17 20 34 lduh [ %i4 + 0x34 ], %g1
200bae4: 82 00 7f ff add %g1, -1, %g1
200bae8: c2 37 20 34 sth %g1, [ %i4 + 0x34 ]
++entry->reference_count;
200baec: c2 17 60 34 lduh [ %i5 + 0x34 ], %g1
200baf0: 82 00 60 01 inc %g1
200baf4: 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;
200baf8: c2 07 60 4c ld [ %i5 + 0x4c ], %g1
currentloc->node_access = entry;
200bafc: fa 26 20 20 st %i5, [ %i0 + 0x20 ]
200bb00: c2 00 60 04 ld [ %g1 + 4 ], %g1
200bb04: c2 26 20 28 st %g1, [ %i0 + 0x28 ]
void *arg,
const char *token,
size_t tokenlen
)
{
rtems_filesystem_eval_path_generic_status status =
200bb08: b0 09 20 ff and %g4, 0xff, %i0
status = RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_NO_ENTRY;
}
}
return status;
}
200bb0c: 81 c7 e0 08 ret
200bb10: 81 e8 00 00 restore
0200bb2c <IMFS_fchmod>:
int IMFS_fchmod(
const rtems_filesystem_location_info_t *loc,
mode_t mode
)
{
200bb2c: 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();
200bb30: 40 00 01 5c call 200c0a0 <geteuid>
200bb34: fa 06 20 08 ld [ %i0 + 8 ], %i5
if ( ( st_uid != jnode->st_uid ) && ( st_uid != 0 ) )
200bb38: c2 17 60 3c lduh [ %i5 + 0x3c ], %g1
200bb3c: 91 2a 20 10 sll %o0, 0x10, %o0
200bb40: 91 32 20 10 srl %o0, 0x10, %o0
200bb44: 80 a2 00 01 cmp %o0, %g1
200bb48: 02 80 00 0a be 200bb70 <IMFS_fchmod+0x44>
200bb4c: 80 a2 20 00 cmp %o0, 0
200bb50: 22 80 00 09 be,a 200bb74 <IMFS_fchmod+0x48> <== NEVER TAKEN
200bb54: c2 07 60 30 ld [ %i5 + 0x30 ], %g1 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EPERM );
200bb58: 40 00 0f b0 call 200fa18 <__errno>
200bb5c: b0 10 3f ff mov -1, %i0
200bb60: 82 10 20 01 mov 1, %g1
200bb64: c2 22 00 00 st %g1, [ %o0 ]
200bb68: 81 c7 e0 08 ret
200bb6c: 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);
200bb70: 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 );
200bb74: 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);
200bb78: 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 );
200bb7c: 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);
200bb80: b2 0e 6f ff and %i1, 0xfff, %i1
200bb84: b2 16 40 01 or %i1, %g1, %i1
IMFS_update_ctime( jnode );
200bb88: 7f ff df 3f call 2003884 <gettimeofday>
200bb8c: f2 27 60 30 st %i1, [ %i5 + 0x30 ]
200bb90: c2 07 bf f8 ld [ %fp + -8 ], %g1
200bb94: c2 27 60 48 st %g1, [ %i5 + 0x48 ]
return 0;
}
200bb98: 81 c7 e0 08 ret
200bb9c: 91 e8 20 00 restore %g0, 0, %o0
02003a9c <IMFS_fifo_write>:
static ssize_t IMFS_fifo_write(
rtems_libio_t *iop,
const void *buffer,
size_t count
)
{
2003a9c: 9d e3 bf 98 save %sp, -104, %sp
IMFS_jnode_t *jnode = iop->pathinfo.node_access;
2003aa0: fa 06 20 1c ld [ %i0 + 0x1c ], %i5
int err = pipe_write(JNODE2PIPE(jnode), buffer, count, iop);
2003aa4: 96 10 00 18 mov %i0, %o3
2003aa8: d0 07 60 50 ld [ %i5 + 0x50 ], %o0
2003aac: 92 10 00 19 mov %i1, %o1
2003ab0: 40 00 2a 60 call 200e430 <pipe_write>
2003ab4: 94 10 00 1a mov %i2, %o2
if (err > 0) {
2003ab8: b0 92 20 00 orcc %o0, 0, %i0
2003abc: 04 80 00 09 ble 2003ae0 <IMFS_fifo_write+0x44>
2003ac0: 90 07 bf f8 add %fp, -8, %o0
IMFS_mtime_ctime_update(jnode);
2003ac4: 40 00 04 15 call 2004b18 <gettimeofday>
2003ac8: 92 10 20 00 clr %o1
2003acc: c2 07 bf f8 ld [ %fp + -8 ], %g1
2003ad0: c2 27 60 44 st %g1, [ %i5 + 0x44 ]
2003ad4: c2 27 60 48 st %g1, [ %i5 + 0x48 ]
2003ad8: 81 c7 e0 08 ret
2003adc: 81 e8 00 00 restore
}
IMFS_FIFO_RETURN(err);
2003ae0: 80 a6 20 00 cmp %i0, 0
2003ae4: 02 80 00 06 be 2003afc <IMFS_fifo_write+0x60> <== NEVER TAKEN
2003ae8: 01 00 00 00 nop
2003aec: 40 00 37 b2 call 20119b4 <__errno>
2003af0: b0 20 00 18 neg %i0
2003af4: f0 22 00 00 st %i0, [ %o0 ]
2003af8: b0 10 3f ff mov -1, %i0
}
2003afc: 81 c7 e0 08 ret
2003b00: 81 e8 00 00 restore
0200bba0 <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
)
{
200bba0: 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;
200bba4: f6 06 20 24 ld [ %i0 + 0x24 ], %i3
200bba8: b8 07 bf e8 add %fp, -24, %i4
200bbac: 92 10 00 1b mov %i3, %o1
200bbb0: 90 10 00 1c mov %i4, %o0
200bbb4: 40 00 11 e0 call 2010334 <memcpy>
200bbb8: 94 10 20 18 mov 0x18, %o2
jnode = (IMFS_jnode_t *)loc.node_access;
200bbbc: 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;
200bbc0: c0 26 e0 08 clr [ %i3 + 8 ]
200bbc4: b6 10 00 1c mov %i4, %i3
200bbc8: c2 07 60 4c ld [ %i5 + 0x4c ], %g1
do {
next = jnode->Parent;
200bbcc: f8 07 60 08 ld [ %i5 + 8 ], %i4
200bbd0: 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 ) ) {
200bbd4: 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;
200bbd8: fa 27 bf f0 st %i5, [ %fp + -16 ]
IMFS_Set_handlers( &loc );
if ( !IMFS_is_directory( jnode ) || jnode_has_no_children( jnode ) ) {
200bbdc: 80 a0 60 00 cmp %g1, 0
200bbe0: 12 80 00 07 bne 200bbfc <IMFS_fsunmount+0x5c>
200bbe4: c4 27 bf f8 st %g2, [ %fp + -8 ]
200bbe8: 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 );
200bbec: 82 07 60 54 add %i5, 0x54, %g1
200bbf0: 80 a0 80 01 cmp %g2, %g1
200bbf4: 32 80 00 10 bne,a 200bc34 <IMFS_fsunmount+0x94>
200bbf8: c2 07 60 4c ld [ %i5 + 0x4c ], %g1
result = IMFS_rmnod( NULL, &loc );
200bbfc: 90 10 20 00 clr %o0
200bc00: 7f ff dd a8 call 20032a0 <IMFS_rmnod>
200bc04: 92 10 00 1b mov %i3, %o1
if ( result != 0 )
200bc08: 80 a2 20 00 cmp %o0, 0
200bc0c: 02 80 00 04 be 200bc1c <IMFS_fsunmount+0x7c> <== ALWAYS TAKEN
200bc10: 11 37 ab 6f sethi %hi(0xdeadbc00), %o0
rtems_fatal_error_occurred( 0xdeadbeef );
200bc14: 7f ff f1 02 call 200801c <rtems_fatal_error_occurred> <== NOT EXECUTED
200bc18: 90 12 22 ef or %o0, 0x2ef, %o0 ! deadbeef <RAM_END+0xdc6dbeef><== NOT EXECUTED
IMFS_node_destroy( jnode );
200bc1c: 7f ff dc cf call 2002f58 <IMFS_node_destroy>
200bc20: 90 10 00 1d mov %i5, %o0
jnode = next;
}
if ( jnode != NULL ) {
200bc24: 80 a7 20 00 cmp %i4, 0
200bc28: 02 80 00 0e be 200bc60 <IMFS_fsunmount+0xc0>
200bc2c: 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;
200bc30: c2 07 60 4c ld [ %i5 + 0x4c ], %g1
if ( IMFS_is_directory( jnode ) ) {
200bc34: c2 00 40 00 ld [ %g1 ], %g1
200bc38: 80 a0 60 00 cmp %g1, 0
200bc3c: 32 bf ff e4 bne,a 200bbcc <IMFS_fsunmount+0x2c> <== NEVER TAKEN
200bc40: 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;
200bc44: 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 );
200bc48: 84 07 60 54 add %i5, 0x54, %g2
if ( jnode_has_children( jnode ) )
200bc4c: 80 a0 40 02 cmp %g1, %g2
200bc50: 02 bf ff de be 200bbc8 <IMFS_fsunmount+0x28>
200bc54: 80 a0 60 00 cmp %g1, 0
jnode = jnode_get_first_child( jnode );
}
}
} while (jnode != NULL);
200bc58: 12 bf ff dc bne 200bbc8 <IMFS_fsunmount+0x28> <== ALWAYS TAKEN
200bc5c: ba 10 00 01 mov %g1, %i5
200bc60: 81 c7 e0 08 ret
200bc64: 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 dc ld [ %g1 + 0x1dc ], %g2 ! 201d5dc <imfs_instance.6560>
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 dc st %g2, [ %g1 + 0x1dc ]
memcpy(
2002e80: 40 00 35 2d call 2010334 <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 a1 00 or %o2, 0x100, %o2
2002e9c: 19 00 00 10 sethi %hi(0x4000), %o4
2002ea0: 9a 10 20 00 clr %o5
2002ea4: 40 00 22 4a call 200b7cc <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 ec or %g1, 0x1ec, %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 2c ld [ %g1 + 0x22c ], %g1
} else {
errno = ENOMEM;
rv = -1;
}
} else {
errno = ENOMEM;
2002ef0: 40 00 32 ca call 200fa18 <__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 d8 st %g1, [ %g2 + 0x1d8 ] ! 201d5d8 <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
02004a78 <IMFS_make_generic_node>:
const char *path,
mode_t mode,
const IMFS_node_control *node_control,
void *context
)
{
2004a78: 9d e3 bf 48 save %sp, -184, %sp
int rv = 0;
mode &= ~rtems_filesystem_umask;
2004a7c: 03 00 80 85 sethi %hi(0x2021400), %g1
2004a80: c2 00 62 70 ld [ %g1 + 0x270 ], %g1 ! 2021670 <rtems_current_user_env>
switch (mode & S_IFMT) {
2004a84: 05 00 00 08 sethi %hi(0x2000), %g2
void *context
)
{
int rv = 0;
mode &= ~rtems_filesystem_umask;
2004a88: c2 00 60 08 ld [ %g1 + 8 ], %g1
2004a8c: b2 2e 40 01 andn %i1, %g1, %i1
switch (mode & S_IFMT) {
2004a90: 03 00 00 3c sethi %hi(0xf000), %g1
2004a94: 82 0e 40 01 and %i1, %g1, %g1
2004a98: 80 a0 40 02 cmp %g1, %g2
2004a9c: 22 80 00 3a be,a 2004b84 <IMFS_make_generic_node+0x10c>
2004aa0: c2 06 80 00 ld [ %i2 ], %g1
2004aa4: 38 80 00 04 bgu,a 2004ab4 <IMFS_make_generic_node+0x3c> <== ALWAYS TAKEN
2004aa8: 05 00 00 18 sethi %hi(0x6000), %g2
2004aac: 10 80 00 05 b 2004ac0 <IMFS_make_generic_node+0x48> <== NOT EXECUTED
2004ab0: 05 00 00 04 sethi %hi(0x1000), %g2 <== NOT EXECUTED
2004ab4: 80 a0 40 02 cmp %g1, %g2
2004ab8: 02 80 00 32 be 2004b80 <IMFS_make_generic_node+0x108>
2004abc: 05 00 00 20 sethi %hi(0x8000), %g2
2004ac0: 80 a0 40 02 cmp %g1, %g2
2004ac4: 22 80 00 30 be,a 2004b84 <IMFS_make_generic_node+0x10c> <== NEVER TAKEN
2004ac8: c2 06 80 00 ld [ %i2 ], %g1 <== NOT EXECUTED
2004acc: 30 80 00 27 b,a 2004b68 <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 =
2004ad0: 94 10 20 78 mov 0x78, %o2
2004ad4: 40 00 08 10 call 2006b14 <rtems_filesystem_eval_path_start>
2004ad8: 90 07 bf c8 add %fp, -56, %o0
rtems_filesystem_eval_path_start( &ctx, path, eval_flags );
if ( IMFS_is_imfs_instance( currentloc ) ) {
2004adc: 7f ff ff d5 call 2004a30 <IMFS_is_imfs_instance>
2004ae0: ba 10 00 08 mov %o0, %i5
2004ae4: 80 8a 20 ff btst 0xff, %o0
2004ae8: 02 80 00 19 be 2004b4c <IMFS_make_generic_node+0xd4>
2004aec: 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(
2004af0: 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;
2004af4: f6 27 bf b0 st %i3, [ %fp + -80 ]
new_node = IMFS_create_node_with_control(
2004af8: 90 10 00 1d mov %i5, %o0
2004afc: 92 10 00 1a mov %i2, %o1
2004b00: 98 10 00 19 mov %i1, %o4
2004b04: 9a 07 bf b0 add %fp, -80, %o5
2004b08: 40 00 2d 3f call 2010004 <IMFS_create_node_with_control>
2004b0c: b0 10 3f ff mov -1, %i0
rtems_filesystem_eval_path_get_tokenlen( &ctx ),
mode,
&info
);
if ( new_node != NULL ) {
2004b10: 80 a2 20 00 cmp %o0, 0
2004b14: 02 80 00 11 be 2004b58 <IMFS_make_generic_node+0xe0>
2004b18: 92 10 20 00 clr %o1
IMFS_jnode_t *parent = currentloc->node_access;
2004b1c: fa 07 60 08 ld [ %i5 + 8 ], %i5
IMFS_update_ctime( parent );
2004b20: 40 00 02 93 call 200556c <gettimeofday>
2004b24: 90 07 bf a8 add %fp, -88, %o0
2004b28: c2 07 bf a8 ld [ %fp + -88 ], %g1
IMFS_update_mtime( parent );
2004b2c: 90 07 bf a8 add %fp, -88, %o0
);
if ( new_node != NULL ) {
IMFS_jnode_t *parent = currentloc->node_access;
IMFS_update_ctime( parent );
2004b30: c2 27 60 48 st %g1, [ %i5 + 0x48 ]
IMFS_update_mtime( parent );
2004b34: 40 00 02 8e call 200556c <gettimeofday>
2004b38: 92 10 20 00 clr %o1
2004b3c: c2 07 bf a8 ld [ %fp + -88 ], %g1
2004b40: b0 10 20 00 clr %i0
2004b44: 10 80 00 05 b 2004b58 <IMFS_make_generic_node+0xe0>
2004b48: c2 27 60 44 st %g1, [ %i5 + 0x44 ]
} else {
rv = -1;
}
} else {
rtems_filesystem_eval_path_error( &ctx, ENOTSUP );
2004b4c: 92 10 20 86 mov 0x86, %o1
2004b50: 40 00 07 5b call 20068bc <rtems_filesystem_eval_path_error>
2004b54: b0 10 3f ff mov -1, %i0
rv = -1;
}
rtems_filesystem_eval_path_cleanup( &ctx );
2004b58: 40 00 08 2b call 2006c04 <rtems_filesystem_eval_path_cleanup>
2004b5c: 90 07 bf c8 add %fp, -56, %o0
2004b60: 81 c7 e0 08 ret
2004b64: 81 e8 00 00 restore
} else {
errno = EINVAL;
2004b68: 40 00 3d 73 call 2014134 <__errno>
2004b6c: b0 10 3f ff mov -1, %i0
2004b70: 82 10 20 16 mov 0x16, %g1
2004b74: c2 22 00 00 st %g1, [ %o0 ]
2004b78: 81 c7 e0 08 ret
2004b7c: 81 e8 00 00 restore
rv = -1;
break;
}
if ( rv == 0 ) {
if ( node_control->imfs_type == IMFS_GENERIC ) {
2004b80: c2 06 80 00 ld [ %i2 ], %g1
2004b84: 80 a0 60 07 cmp %g1, 7
2004b88: 02 bf ff d2 be 2004ad0 <IMFS_make_generic_node+0x58>
2004b8c: 92 10 00 18 mov %i0, %o1
2004b90: 30 bf ff f6 b,a 2004b68 <IMFS_make_generic_node+0xf0>
0200e3cc <IMFS_memfile_addblock>:
*/
MEMFILE_STATIC int IMFS_memfile_addblock(
IMFS_jnode_t *the_jnode,
unsigned int block
)
{
200e3cc: 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 );
200e3d0: 94 10 20 01 mov 1, %o2
200e3d4: 90 10 00 18 mov %i0, %o0
200e3d8: 7f ff fe d6 call 200df30 <IMFS_memfile_get_block_pointer>
200e3dc: 92 10 00 19 mov %i1, %o1
if ( *block_entry_ptr )
200e3e0: 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 );
200e3e4: ba 10 00 08 mov %o0, %i5
if ( *block_entry_ptr )
200e3e8: 80 a0 60 00 cmp %g1, 0
200e3ec: 12 80 00 08 bne 200e40c <IMFS_memfile_addblock+0x40>
200e3f0: b0 10 20 00 clr %i0
return 0;
/*
* There is no memory for this block number so allocate it.
*/
memory = memfile_alloc_block();
200e3f4: 7f ff fe c2 call 200defc <memfile_alloc_block>
200e3f8: 01 00 00 00 nop
if ( !memory )
200e3fc: 80 a2 20 00 cmp %o0, 0
200e400: 22 80 00 03 be,a 200e40c <IMFS_memfile_addblock+0x40> <== NEVER TAKEN
200e404: b0 10 20 01 mov 1, %i0 <== NOT EXECUTED
return 1;
*block_entry_ptr = memory;
200e408: d0 27 40 00 st %o0, [ %i5 ]
return 0;
200e40c: 81 c7 e0 08 ret
200e410: 81 e8 00 00 restore
0200e5e0 <IMFS_memfile_extend>:
MEMFILE_STATIC int IMFS_memfile_extend(
IMFS_jnode_t *the_jnode,
bool zero_fill,
off_t new_length
)
{
200e5e0: 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 )
200e5e4: 03 00 80 75 sethi %hi(0x201d400), %g1
200e5e8: fa 00 61 d8 ld [ %g1 + 0x1d8 ], %i5 ! 201d5d8 <imfs_memfile_bytes_per_block>
200e5ec: b9 37 60 02 srl %i5, 2, %i4
200e5f0: 92 10 00 1c mov %i4, %o1
200e5f4: 40 00 28 6f call 20187b0 <.umul>
200e5f8: 90 07 20 01 add %i4, 1, %o0
200e5fc: 92 10 00 1c mov %i4, %o1
200e600: 40 00 28 6c call 20187b0 <.umul>
200e604: 90 02 20 01 inc %o0
200e608: 92 10 00 1d mov %i5, %o1
200e60c: 40 00 28 69 call 20187b0 <.umul>
200e610: 90 02 3f ff add %o0, -1, %o0
200e614: 82 10 20 00 clr %g1
200e618: 80 a0 40 1a cmp %g1, %i2
200e61c: 34 80 00 0b bg,a 200e648 <IMFS_memfile_extend+0x68> <== NEVER TAKEN
200e620: f8 06 20 50 ld [ %i0 + 0x50 ], %i4 <== NOT EXECUTED
200e624: 80 a0 40 1a cmp %g1, %i2
200e628: 12 80 00 04 bne 200e638 <IMFS_memfile_extend+0x58> <== NEVER TAKEN
200e62c: 80 a2 00 1b cmp %o0, %i3
200e630: 38 80 00 06 bgu,a 200e648 <IMFS_memfile_extend+0x68>
200e634: f8 06 20 50 ld [ %i0 + 0x50 ], %i4
rtems_set_errno_and_return_minus_one( EFBIG );
200e638: 40 00 04 f8 call 200fa18 <__errno>
200e63c: 01 00 00 00 nop
200e640: 10 80 00 3c b 200e730 <IMFS_memfile_extend+0x150>
200e644: 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 )
200e648: 80 a6 80 1c cmp %i2, %i4
200e64c: 14 80 00 07 bg 200e668 <IMFS_memfile_extend+0x88> <== NEVER TAKEN
200e650: e0 06 20 54 ld [ %i0 + 0x54 ], %l0
200e654: 80 a6 80 1c cmp %i2, %i4
200e658: 12 80 00 48 bne 200e778 <IMFS_memfile_extend+0x198> <== NEVER TAKEN
200e65c: 80 a6 c0 10 cmp %i3, %l0
200e660: 08 80 00 46 bleu 200e778 <IMFS_memfile_extend+0x198> <== NEVER TAKEN
200e664: 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;
200e668: a3 3f 60 1f sra %i5, 0x1f, %l1
200e66c: 96 10 00 1d mov %i5, %o3
200e670: 94 10 00 11 mov %l1, %o2
200e674: 90 10 00 1a mov %i2, %o0
200e678: 40 00 29 e0 call 2018df8 <__divdi3>
200e67c: 92 10 00 1b mov %i3, %o1
old_blocks = the_jnode->info.file.size / IMFS_MEMFILE_BYTES_PER_BLOCK;
200e680: 94 10 00 11 mov %l1, %o2
200e684: 90 10 00 1c mov %i4, %o0
200e688: 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;
200e68c: a4 10 00 09 mov %o1, %l2
old_blocks = the_jnode->info.file.size / IMFS_MEMFILE_BYTES_PER_BLOCK;
200e690: 40 00 29 da call 2018df8 <__divdi3>
200e694: 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++ ) {
200e698: 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;
200e69c: 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;
200e6a0: 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;
200e6a4: 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;
200e6a8: 40 00 28 42 call 20187b0 <.umul>
200e6ac: 92 10 00 1d mov %i5, %o1
/*
* Now allocate each of those blocks.
*/
for ( block=old_blocks ; block<=new_blocks ; block++ ) {
200e6b0: 10 80 00 23 b 200e73c <IMFS_memfile_extend+0x15c>
200e6b4: a0 24 00 08 sub %l0, %o0, %l0
if ( !IMFS_memfile_addblock( the_jnode, block ) ) {
200e6b8: 7f ff ff 45 call 200e3cc <IMFS_memfile_addblock>
200e6bc: 92 10 00 1d mov %i5, %o1
200e6c0: 80 a2 20 00 cmp %o0, 0
200e6c4: 12 80 00 15 bne 200e718 <IMFS_memfile_extend+0x138> <== NEVER TAKEN
200e6c8: 80 a6 60 00 cmp %i1, 0
if ( zero_fill ) {
200e6cc: 22 80 00 1c be,a 200e73c <IMFS_memfile_extend+0x15c>
200e6d0: a2 04 60 01 inc %l1
size_t count = IMFS_MEMFILE_BYTES_PER_BLOCK - offset;
200e6d4: e8 04 e1 d8 ld [ %l3 + 0x1d8 ], %l4
block_p *block_ptr =
200e6d8: 92 10 00 1d mov %i5, %o1
200e6dc: 94 10 20 00 clr %o2
200e6e0: 7f ff fe 14 call 200df30 <IMFS_memfile_get_block_pointer>
200e6e4: 90 10 00 18 mov %i0, %o0
IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
memset( &(*block_ptr) [offset], 0, count);
200e6e8: 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;
200e6ec: 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);
200e6f0: 90 02 00 10 add %o0, %l0, %o0
200e6f4: 92 10 20 00 clr %o1
200e6f8: 94 10 00 14 mov %l4, %o2
200e6fc: 40 00 07 4b call 2010428 <memset>
200e700: a0 10 20 00 clr %l0
200e704: 10 80 00 0e b 200e73c <IMFS_memfile_extend+0x15c>
200e708: a2 04 60 01 inc %l1
offset = 0;
}
} else {
for ( ; block>=old_blocks ; block-- ) {
IMFS_memfile_remove_block( the_jnode, block );
200e70c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
200e710: 7f ff ff a8 call 200e5b0 <IMFS_memfile_remove_block> <== NOT EXECUTED
200e714: ba 07 7f ff add %i5, -1, %i5 <== NOT EXECUTED
memset( &(*block_ptr) [offset], 0, count);
offset = 0;
}
} else {
for ( ; block>=old_blocks ; block-- ) {
200e718: 80 a7 40 1c cmp %i5, %i4 <== NOT EXECUTED
200e71c: 1a bf ff fc bcc 200e70c <IMFS_memfile_extend+0x12c> <== NOT EXECUTED
200e720: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
IMFS_memfile_remove_block( the_jnode, block );
}
rtems_set_errno_and_return_minus_one( ENOSPC );
200e724: 40 00 04 bd call 200fa18 <__errno> <== NOT EXECUTED
200e728: 01 00 00 00 nop <== NOT EXECUTED
200e72c: 82 10 20 1c mov 0x1c, %g1 ! 1c <PROM_START+0x1c> <== NOT EXECUTED
200e730: c2 22 00 00 st %g1, [ %o0 ]
200e734: 81 c7 e0 08 ret
200e738: 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(
200e73c: 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++ ) {
200e740: 80 a7 40 12 cmp %i5, %l2
200e744: 08 bf ff dd bleu 200e6b8 <IMFS_memfile_extend+0xd8>
200e748: 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);
200e74c: 92 10 20 00 clr %o1
}
/*
* Set the new length of the file.
*/
the_jnode->info.file.size = new_length;
200e750: f4 3e 20 50 std %i2, [ %i0 + 0x50 ]
IMFS_update_ctime(the_jnode);
200e754: 7f ff d4 4c call 2003884 <gettimeofday>
200e758: 90 07 bf f8 add %fp, -8, %o0
200e75c: c2 07 bf f8 ld [ %fp + -8 ], %g1
IMFS_update_mtime(the_jnode);
200e760: 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);
200e764: c2 26 20 48 st %g1, [ %i0 + 0x48 ]
IMFS_update_mtime(the_jnode);
200e768: 7f ff d4 47 call 2003884 <gettimeofday>
200e76c: 92 10 20 00 clr %o1
200e770: c2 07 bf f8 ld [ %fp + -8 ], %g1
200e774: c2 26 20 44 st %g1, [ %i0 + 0x44 ]
return 0;
}
200e778: 81 c7 e0 08 ret
200e77c: 91 e8 20 00 restore %g0, 0, %o0
0200df30 <IMFS_memfile_get_block_pointer>:
#endif
IMFS_jnode_t *the_jnode,
unsigned int block,
int malloc_it
)
{
200df30: 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 ) {
200df34: 03 00 80 75 sethi %hi(0x201d400), %g1
200df38: fa 00 61 d8 ld [ %g1 + 0x1d8 ], %i5 ! 201d5d8 <imfs_memfile_bytes_per_block>
200df3c: bb 37 60 02 srl %i5, 2, %i5
200df40: 82 07 7f ff add %i5, -1, %g1
200df44: 80 a6 40 01 cmp %i1, %g1
200df48: 18 80 00 18 bgu 200dfa8 <IMFS_memfile_get_block_pointer+0x78>
200df4c: 90 07 60 01 add %i5, 1, %o0
p = info->indirect;
if ( malloc_it ) {
200df50: 80 a6 a0 00 cmp %i2, 0
200df54: 02 80 00 10 be 200df94 <IMFS_memfile_get_block_pointer+0x64>
200df58: c2 06 20 58 ld [ %i0 + 0x58 ], %g1
if ( !p ) {
200df5c: 80 a0 60 00 cmp %g1, 0
200df60: 32 80 00 0a bne,a 200df88 <IMFS_memfile_get_block_pointer+0x58>
200df64: f0 06 20 58 ld [ %i0 + 0x58 ], %i0
p = memfile_alloc_block();
200df68: 7f ff ff e5 call 200defc <memfile_alloc_block>
200df6c: 01 00 00 00 nop
if ( !p )
200df70: 80 a2 20 00 cmp %o0, 0
200df74: 32 80 00 04 bne,a 200df84 <IMFS_memfile_get_block_pointer+0x54><== ALWAYS TAKEN
200df78: d0 26 20 58 st %o0, [ %i0 + 0x58 ]
return 0;
200df7c: 81 c7 e0 08 ret <== NOT EXECUTED
200df80: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED
info->indirect = p;
}
return &info->indirect[ my_block ];
200df84: f0 06 20 58 ld [ %i0 + 0x58 ], %i0
200df88: b3 2e 60 02 sll %i1, 2, %i1
200df8c: 81 c7 e0 08 ret
200df90: 91 ee 00 19 restore %i0, %i1, %o0
}
if ( !p )
200df94: 80 a0 60 00 cmp %g1, 0
200df98: 02 bf ff f9 be 200df7c <IMFS_memfile_get_block_pointer+0x4c><== NEVER TAKEN
200df9c: b3 2e 60 02 sll %i1, 2, %i1
return 0;
return &info->indirect[ my_block ];
200dfa0: 81 c7 e0 08 ret
200dfa4: 91 e8 40 19 restore %g1, %i1, %o0
/*
* Is the block number in the doubly indirect portion?
*/
if ( my_block <= LAST_DOUBLY_INDIRECT ) {
200dfa8: 40 00 2a 02 call 20187b0 <.umul>
200dfac: 92 10 00 1d mov %i5, %o1
200dfb0: 82 02 3f ff add %o0, -1, %g1
200dfb4: 80 a6 40 01 cmp %i1, %g1
200dfb8: 18 80 00 2c bgu 200e068 <IMFS_memfile_get_block_pointer+0x138>
200dfbc: b8 10 00 08 mov %o0, %i4
my_block -= FIRST_DOUBLY_INDIRECT;
200dfc0: b2 26 40 1d sub %i1, %i5, %i1
singly = my_block % IMFS_MEMFILE_BLOCK_SLOTS;
200dfc4: 92 10 00 1d mov %i5, %o1
200dfc8: 40 00 2a e0 call 2018b48 <.urem>
200dfcc: 90 10 00 19 mov %i1, %o0
doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS;
200dfd0: 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;
200dfd4: b8 10 00 08 mov %o0, %i4
doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS;
200dfd8: 40 00 2a 30 call 2018898 <.udiv>
200dfdc: 90 10 00 19 mov %i1, %o0
p = info->doubly_indirect;
if ( malloc_it ) {
200dfe0: 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;
200dfe4: ba 10 00 08 mov %o0, %i5
p = info->doubly_indirect;
if ( malloc_it ) {
200dfe8: 02 80 00 17 be 200e044 <IMFS_memfile_get_block_pointer+0x114>
200dfec: d0 06 20 5c ld [ %i0 + 0x5c ], %o0
if ( !p ) {
200dff0: 80 a2 20 00 cmp %o0, 0
200dff4: 12 80 00 08 bne 200e014 <IMFS_memfile_get_block_pointer+0xe4>
200dff8: bb 2f 60 02 sll %i5, 2, %i5
p = memfile_alloc_block();
200dffc: 7f ff ff c0 call 200defc <memfile_alloc_block>
200e000: 01 00 00 00 nop
if ( !p )
200e004: 80 a2 20 00 cmp %o0, 0
200e008: 02 bf ff dd be 200df7c <IMFS_memfile_get_block_pointer+0x4c><== NEVER TAKEN
200e00c: 01 00 00 00 nop
return 0;
info->doubly_indirect = p;
200e010: d0 26 20 5c st %o0, [ %i0 + 0x5c ]
}
p1 = (block_p *)p[ doubly ];
200e014: b6 02 00 1d add %o0, %i5, %i3
200e018: d0 02 00 1d ld [ %o0 + %i5 ], %o0
if ( !p1 ) {
200e01c: 80 a2 20 00 cmp %o0, 0
200e020: 12 80 00 4a bne 200e148 <IMFS_memfile_get_block_pointer+0x218>
200e024: b1 2f 20 02 sll %i4, 2, %i0
p1 = memfile_alloc_block();
200e028: 7f ff ff b5 call 200defc <memfile_alloc_block>
200e02c: 01 00 00 00 nop
if ( !p1 )
200e030: 80 a2 20 00 cmp %o0, 0
200e034: 02 bf ff d2 be 200df7c <IMFS_memfile_get_block_pointer+0x4c><== NEVER TAKEN
200e038: 01 00 00 00 nop
return 0;
p[ doubly ] = (block_p) p1;
200e03c: 10 80 00 43 b 200e148 <IMFS_memfile_get_block_pointer+0x218>
200e040: d0 26 c0 00 st %o0, [ %i3 ]
}
return (block_p *)&p1[ singly ];
}
if ( !p )
200e044: 80 a2 20 00 cmp %o0, 0
200e048: 02 bf ff cd be 200df7c <IMFS_memfile_get_block_pointer+0x4c><== NEVER TAKEN
200e04c: bb 2f 60 02 sll %i5, 2, %i5
return 0;
p = (block_p *)p[ doubly ];
200e050: c2 02 00 1d ld [ %o0 + %i5 ], %g1
if ( !p )
200e054: 80 a0 60 00 cmp %g1, 0
200e058: 02 bf ff c9 be 200df7c <IMFS_memfile_get_block_pointer+0x4c><== NEVER TAKEN
200e05c: 01 00 00 00 nop
return 0;
return (block_p *)&p[ singly ];
200e060: 10 80 00 48 b 200e180 <IMFS_memfile_get_block_pointer+0x250>
200e064: b1 2f 20 02 sll %i4, 2, %i0
}
/*
* Is the block number in the triply indirect portion?
*/
if ( my_block <= LAST_TRIPLY_INDIRECT ) {
200e068: 90 02 20 01 inc %o0
200e06c: 40 00 29 d1 call 20187b0 <.umul>
200e070: 92 10 00 1d mov %i5, %o1
200e074: 90 02 3f ff add %o0, -1, %o0
200e078: 80 a6 40 08 cmp %i1, %o0
200e07c: 18 bf ff c0 bgu 200df7c <IMFS_memfile_get_block_pointer+0x4c><== NEVER TAKEN
200e080: b2 26 40 1c sub %i1, %i4, %i1
my_block -= FIRST_TRIPLY_INDIRECT;
singly = my_block % IMFS_MEMFILE_BLOCK_SLOTS;
200e084: 92 10 00 1d mov %i5, %o1
200e088: 40 00 2a b0 call 2018b48 <.urem>
200e08c: 90 10 00 19 mov %i1, %o0
doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS;
200e090: 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;
200e094: b6 10 00 08 mov %o0, %i3
doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS;
200e098: 40 00 2a 00 call 2018898 <.udiv>
200e09c: 90 10 00 19 mov %i1, %o0
triply = doubly / IMFS_MEMFILE_BLOCK_SLOTS;
200e0a0: 92 10 00 1d mov %i5, %o1
200e0a4: 40 00 29 fd call 2018898 <.udiv>
200e0a8: b2 10 00 08 mov %o0, %i1
doubly %= IMFS_MEMFILE_BLOCK_SLOTS;
200e0ac: 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;
200e0b0: b8 10 00 08 mov %o0, %i4
doubly %= IMFS_MEMFILE_BLOCK_SLOTS;
200e0b4: 40 00 2a a5 call 2018b48 <.urem>
200e0b8: 90 10 00 19 mov %i1, %o0
p = info->triply_indirect;
if ( malloc_it ) {
200e0bc: 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;
200e0c0: ba 10 00 08 mov %o0, %i5
p = info->triply_indirect;
if ( malloc_it ) {
200e0c4: 02 80 00 23 be 200e150 <IMFS_memfile_get_block_pointer+0x220>
200e0c8: d0 06 20 60 ld [ %i0 + 0x60 ], %o0
if ( !p ) {
200e0cc: 80 a2 20 00 cmp %o0, 0
200e0d0: 12 80 00 08 bne 200e0f0 <IMFS_memfile_get_block_pointer+0x1c0>
200e0d4: b9 2f 20 02 sll %i4, 2, %i4
p = memfile_alloc_block();
200e0d8: 7f ff ff 89 call 200defc <memfile_alloc_block>
200e0dc: 01 00 00 00 nop
if ( !p )
200e0e0: 80 a2 20 00 cmp %o0, 0
200e0e4: 02 bf ff a6 be 200df7c <IMFS_memfile_get_block_pointer+0x4c><== NEVER TAKEN
200e0e8: 01 00 00 00 nop
return 0;
info->triply_indirect = p;
200e0ec: d0 26 20 60 st %o0, [ %i0 + 0x60 ]
}
p1 = (block_p *) p[ triply ];
200e0f0: b4 02 00 1c add %o0, %i4, %i2
200e0f4: d0 02 00 1c ld [ %o0 + %i4 ], %o0
if ( !p1 ) {
200e0f8: 80 a2 20 00 cmp %o0, 0
200e0fc: 12 80 00 08 bne 200e11c <IMFS_memfile_get_block_pointer+0x1ec>
200e100: bb 2f 60 02 sll %i5, 2, %i5
p1 = memfile_alloc_block();
200e104: 7f ff ff 7e call 200defc <memfile_alloc_block>
200e108: 01 00 00 00 nop
if ( !p1 )
200e10c: 80 a2 20 00 cmp %o0, 0
200e110: 02 bf ff 9b be 200df7c <IMFS_memfile_get_block_pointer+0x4c><== NEVER TAKEN
200e114: 01 00 00 00 nop
return 0;
p[ triply ] = (block_p) p1;
200e118: d0 26 80 00 st %o0, [ %i2 ]
}
p2 = (block_p *)p1[ doubly ];
200e11c: b8 02 00 1d add %o0, %i5, %i4
200e120: d0 02 00 1d ld [ %o0 + %i5 ], %o0
if ( !p2 ) {
200e124: 80 a2 20 00 cmp %o0, 0
200e128: 12 80 00 08 bne 200e148 <IMFS_memfile_get_block_pointer+0x218>
200e12c: b1 2e e0 02 sll %i3, 2, %i0
p2 = memfile_alloc_block();
200e130: 7f ff ff 73 call 200defc <memfile_alloc_block>
200e134: 01 00 00 00 nop
if ( !p2 )
200e138: 80 a2 20 00 cmp %o0, 0
200e13c: 02 bf ff 90 be 200df7c <IMFS_memfile_get_block_pointer+0x4c><== NEVER TAKEN
200e140: 01 00 00 00 nop
return 0;
p1[ doubly ] = (block_p) p2;
200e144: d0 27 00 00 st %o0, [ %i4 ]
}
return (block_p *)&p2[ singly ];
200e148: 81 c7 e0 08 ret
200e14c: 91 ea 00 18 restore %o0, %i0, %o0
}
if ( !p )
200e150: 80 a2 20 00 cmp %o0, 0
200e154: 02 bf ff 8a be 200df7c <IMFS_memfile_get_block_pointer+0x4c><== NEVER TAKEN
200e158: b9 2f 20 02 sll %i4, 2, %i4
return 0;
p1 = (block_p *) p[ triply ];
200e15c: c2 02 00 1c ld [ %o0 + %i4 ], %g1
if ( !p1 )
200e160: 80 a0 60 00 cmp %g1, 0
200e164: 02 bf ff 86 be 200df7c <IMFS_memfile_get_block_pointer+0x4c><== NEVER TAKEN
200e168: bb 2f 60 02 sll %i5, 2, %i5
return 0;
p2 = (block_p *)p1[ doubly ];
200e16c: c2 00 40 1d ld [ %g1 + %i5 ], %g1
if ( !p2 )
200e170: 80 a0 60 00 cmp %g1, 0
200e174: 02 bf ff 82 be 200df7c <IMFS_memfile_get_block_pointer+0x4c><== NEVER TAKEN
200e178: 01 00 00 00 nop
return 0;
return (block_p *)&p2[ singly ];
200e17c: b1 2e e0 02 sll %i3, 2, %i0
/*
* This means the requested block number is out of range.
*/
return 0;
}
200e180: 81 c7 e0 08 ret
200e184: 91 e8 40 18 restore %g1, %i0, %o0
0200e188 <IMFS_memfile_read>:
IMFS_jnode_t *the_jnode,
off_t start,
unsigned char *destination,
unsigned int length
)
{
200e188: 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;
200e18c: c2 06 20 4c ld [ %i0 + 0x4c ], %g1
200e190: 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 ) {
200e194: c2 00 40 00 ld [ %g1 ], %g1
IMFS_jnode_t *the_jnode,
off_t start,
unsigned char *destination,
unsigned int length
)
{
200e198: a0 10 00 19 mov %i1, %l0
200e19c: 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 ) {
200e1a0: 80 a0 60 05 cmp %g1, 5
200e1a4: 12 80 00 17 bne 200e200 <IMFS_memfile_read+0x78>
200e1a8: 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))
200e1ac: f4 1e 20 50 ldd [ %i0 + 0x50 ], %i2
200e1b0: 82 10 20 00 clr %g1
200e1b4: 86 a6 c0 11 subcc %i3, %l1, %g3
200e1b8: 84 66 80 19 subx %i2, %i1, %g2
200e1bc: 80 a0 40 02 cmp %g1, %g2
200e1c0: 14 80 00 07 bg 200e1dc <IMFS_memfile_read+0x54> <== NEVER TAKEN
200e1c4: d2 06 20 58 ld [ %i0 + 0x58 ], %o1
200e1c8: 80 a0 40 02 cmp %g1, %g2
200e1cc: 12 80 00 06 bne 200e1e4 <IMFS_memfile_read+0x5c> <== NEVER TAKEN
200e1d0: 80 a7 00 03 cmp %i4, %g3
200e1d4: 28 80 00 05 bleu,a 200e1e8 <IMFS_memfile_read+0x60> <== NEVER TAKEN
200e1d8: b0 10 00 1c mov %i4, %i0 <== NOT EXECUTED
my_length = the_jnode->info.linearfile.size - start;
200e1dc: 10 80 00 03 b 200e1e8 <IMFS_memfile_read+0x60>
200e1e0: 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;
200e1e4: 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);
200e1e8: 90 10 00 12 mov %l2, %o0
200e1ec: 92 02 40 11 add %o1, %l1, %o1
200e1f0: 40 00 08 51 call 2010334 <memcpy>
200e1f4: 94 10 00 18 mov %i0, %o2
return copied;
memcpy( dest, &(*block_ptr)[ 0 ], my_length );
copied += my_length;
}
IMFS_update_atime( the_jnode );
200e1f8: 10 80 00 5d b 200e36c <IMFS_memfile_read+0x1e4>
200e1fc: 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 )
200e200: c6 06 20 50 ld [ %i0 + 0x50 ], %g3
200e204: 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;
200e208: 82 10 00 1a mov %i2, %g1
if ( last_byte > the_jnode->info.file.size )
200e20c: c4 06 20 54 ld [ %i0 + 0x54 ], %g2
200e210: 80 a1 00 03 cmp %g4, %g3
200e214: 14 80 00 08 bg 200e234 <IMFS_memfile_read+0xac> <== NEVER TAKEN
200e218: b6 07 00 1a add %i4, %i2, %i3
200e21c: 80 a1 00 03 cmp %g4, %g3
200e220: 32 80 00 07 bne,a 200e23c <IMFS_memfile_read+0xb4> <== NEVER TAKEN
200e224: 03 00 80 75 sethi %hi(0x201d400), %g1 <== NOT EXECUTED
200e228: 80 a6 c0 02 cmp %i3, %g2
200e22c: 28 80 00 04 bleu,a 200e23c <IMFS_memfile_read+0xb4>
200e230: 03 00 80 75 sethi %hi(0x201d400), %g1
my_length = the_jnode->info.file.size - start;
200e234: 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;
200e238: 03 00 80 75 sethi %hi(0x201d400), %g1
200e23c: f6 00 61 d8 ld [ %g1 + 0x1d8 ], %i3 ! 201d5d8 <imfs_memfile_bytes_per_block>
200e240: 90 10 00 10 mov %l0, %o0
200e244: b5 3e e0 1f sra %i3, 0x1f, %i2
200e248: 96 10 00 1b mov %i3, %o3
200e24c: 94 10 00 1a mov %i2, %o2
200e250: 40 00 2b d5 call 20191a4 <__moddi3>
200e254: 92 10 00 11 mov %l1, %o1
block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;
200e258: 94 10 00 1a mov %i2, %o2
*/
/*
* Phase 1: possibly the last part of one block
*/
start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;
200e25c: a6 10 00 09 mov %o1, %l3
block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;
200e260: 90 10 00 10 mov %l0, %o0
200e264: 92 10 00 11 mov %l1, %o1
200e268: 40 00 2a e4 call 2018df8 <__divdi3>
200e26c: 96 10 00 1b mov %i3, %o3
if ( start_offset ) {
200e270: 80 a4 e0 00 cmp %l3, 0
200e274: 02 80 00 18 be 200e2d4 <IMFS_memfile_read+0x14c>
200e278: b4 10 00 09 mov %o1, %i2
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK - start_offset;
200e27c: b6 26 c0 13 sub %i3, %l3, %i3
200e280: 80 a7 00 1b cmp %i4, %i3
200e284: 08 80 00 03 bleu 200e290 <IMFS_memfile_read+0x108>
200e288: b2 10 00 1c mov %i4, %i1
200e28c: 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 );
200e290: 90 10 00 1d mov %i5, %o0
200e294: 92 10 00 1a mov %i2, %o1
200e298: 94 10 20 00 clr %o2
200e29c: 7f ff ff 25 call 200df30 <IMFS_memfile_get_block_pointer>
200e2a0: b0 10 20 00 clr %i0
if ( !block_ptr )
200e2a4: 80 a2 20 00 cmp %o0, 0
200e2a8: 02 80 00 35 be 200e37c <IMFS_memfile_read+0x1f4> <== NEVER TAKEN
200e2ac: 94 10 00 19 mov %i1, %o2
return copied;
memcpy( dest, &(*block_ptr)[ start_offset ], to_copy );
200e2b0: d2 02 00 00 ld [ %o0 ], %o1
200e2b4: 90 10 00 12 mov %l2, %o0
200e2b8: 92 02 40 13 add %o1, %l3, %o1
200e2bc: 40 00 08 1e call 2010334 <memcpy>
200e2c0: a4 04 80 19 add %l2, %i1, %l2
dest += to_copy;
block++;
200e2c4: b4 06 a0 01 inc %i2
my_length -= to_copy;
200e2c8: b8 27 00 19 sub %i4, %i1, %i4
copied += to_copy;
200e2cc: 10 80 00 03 b 200e2d8 <IMFS_memfile_read+0x150>
200e2d0: 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;
200e2d4: b0 10 20 00 clr %i0
}
/*
* Phase 2: all of zero of more blocks
*/
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;
200e2d8: 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(
200e2dc: a4 24 80 18 sub %l2, %i0, %l2
}
/*
* Phase 2: all of zero of more blocks
*/
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;
200e2e0: f6 00 61 d8 ld [ %g1 + 0x1d8 ], %i3
while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {
200e2e4: 10 80 00 0f b 200e320 <IMFS_memfile_read+0x198>
200e2e8: a0 10 00 01 mov %g1, %l0
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
200e2ec: 90 10 00 1d mov %i5, %o0
200e2f0: 92 10 00 1a mov %i2, %o1
200e2f4: 7f ff ff 0f call 200df30 <IMFS_memfile_get_block_pointer>
200e2f8: 94 10 20 00 clr %o2
if ( !block_ptr )
200e2fc: 82 92 20 00 orcc %o0, 0, %g1
200e300: 02 80 00 1f be 200e37c <IMFS_memfile_read+0x1f4> <== NEVER TAKEN
200e304: 90 10 00 19 mov %i1, %o0
return copied;
memcpy( dest, &(*block_ptr)[ 0 ], to_copy );
200e308: d2 00 40 00 ld [ %g1 ], %o1
200e30c: 94 10 00 1b mov %i3, %o2
200e310: 40 00 08 09 call 2010334 <memcpy>
200e314: b4 06 a0 01 inc %i2
dest += to_copy;
block++;
my_length -= to_copy;
200e318: b8 27 00 1b sub %i4, %i3, %i4
copied += to_copy;
200e31c: 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 ) {
200e320: c2 04 21 d8 ld [ %l0 + 0x1d8 ], %g1
200e324: 80 a7 00 01 cmp %i4, %g1
200e328: 1a bf ff f1 bcc 200e2ec <IMFS_memfile_read+0x164>
200e32c: 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 ) {
200e330: 80 a7 20 00 cmp %i4, 0
200e334: 02 80 00 0e be 200e36c <IMFS_memfile_read+0x1e4>
200e338: 90 07 bf f8 add %fp, -8, %o0
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
200e33c: 90 10 00 1d mov %i5, %o0
200e340: 92 10 00 1a mov %i2, %o1
200e344: 7f ff fe fb call 200df30 <IMFS_memfile_get_block_pointer>
200e348: 94 10 20 00 clr %o2
if ( !block_ptr )
200e34c: 82 92 20 00 orcc %o0, 0, %g1
200e350: 02 80 00 0b be 200e37c <IMFS_memfile_read+0x1f4> <== NEVER TAKEN
200e354: 90 10 00 19 mov %i1, %o0
return copied;
memcpy( dest, &(*block_ptr)[ 0 ], my_length );
200e358: d2 00 40 00 ld [ %g1 ], %o1
200e35c: 94 10 00 1c mov %i4, %o2
200e360: 40 00 07 f5 call 2010334 <memcpy>
200e364: b0 07 00 18 add %i4, %i0, %i0
copied += my_length;
}
IMFS_update_atime( the_jnode );
200e368: 90 07 bf f8 add %fp, -8, %o0
200e36c: 7f ff d5 46 call 2003884 <gettimeofday>
200e370: 92 10 20 00 clr %o1
200e374: c2 07 bf f8 ld [ %fp + -8 ], %g1
200e378: c2 27 60 40 st %g1, [ %i5 + 0x40 ]
return copied;
}
200e37c: 81 c7 e0 08 ret
200e380: 81 e8 00 00 restore
0200e484 <IMFS_memfile_remove>:
* is better to stick to simple, easy to understand algorithms.
*/
IMFS_jnode_t *IMFS_memfile_remove(
IMFS_jnode_t *the_jnode
)
{
200e484: 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;
200e488: 03 00 80 75 sethi %hi(0x201d400), %g1
200e48c: fa 00 61 d8 ld [ %g1 + 0x1d8 ], %i5 ! 201d5d8 <imfs_memfile_bytes_per_block>
* + doubly indirect
* + triply indirect
*/
info = &the_jnode->info.file;
if ( info->indirect ) {
200e490: c2 06 20 58 ld [ %i0 + 0x58 ], %g1
200e494: 80 a0 60 00 cmp %g1, 0
200e498: 02 80 00 05 be 200e4ac <IMFS_memfile_remove+0x28>
200e49c: bb 37 60 02 srl %i5, 2, %i5
memfile_free_blocks_in_table( &info->indirect, to_free );
200e4a0: 90 06 20 58 add %i0, 0x58, %o0
200e4a4: 7f ff ff e5 call 200e438 <memfile_free_blocks_in_table>
200e4a8: 92 10 00 1d mov %i5, %o1
}
if ( info->doubly_indirect ) {
200e4ac: c2 06 20 5c ld [ %i0 + 0x5c ], %g1
200e4b0: b8 10 20 00 clr %i4
200e4b4: 80 a0 60 00 cmp %g1, 0
200e4b8: 12 80 00 0d bne 200e4ec <IMFS_memfile_remove+0x68>
200e4bc: 37 00 80 75 sethi %hi(0x201d400), %i3
}
memfile_free_blocks_in_table( &info->doubly_indirect, to_free );
}
if ( info->triply_indirect ) {
200e4c0: 10 80 00 15 b 200e514 <IMFS_memfile_remove+0x90>
200e4c4: 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(
200e4c8: 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] ) {
200e4cc: 90 00 80 01 add %g2, %g1, %o0
200e4d0: c2 00 80 01 ld [ %g2 + %g1 ], %g1
200e4d4: 80 a0 60 00 cmp %g1, 0
200e4d8: 22 80 00 05 be,a 200e4ec <IMFS_memfile_remove+0x68> <== NEVER TAKEN
200e4dc: b8 07 20 01 inc %i4 <== NOT EXECUTED
memfile_free_blocks_in_table(
200e4e0: 7f ff ff d6 call 200e438 <memfile_free_blocks_in_table>
200e4e4: 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++ ) {
200e4e8: b8 07 20 01 inc %i4
200e4ec: c2 06 e1 d8 ld [ %i3 + 0x1d8 ], %g1
200e4f0: 83 30 60 02 srl %g1, 2, %g1
200e4f4: 80 a7 00 01 cmp %i4, %g1
200e4f8: 2a bf ff f4 bcs,a 200e4c8 <IMFS_memfile_remove+0x44>
200e4fc: 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 );
200e500: 90 06 20 5c add %i0, 0x5c, %o0
200e504: 7f ff ff cd call 200e438 <memfile_free_blocks_in_table>
200e508: 92 10 00 1d mov %i5, %o1
}
if ( info->triply_indirect ) {
200e50c: c2 06 20 60 ld [ %i0 + 0x60 ], %g1
200e510: b8 10 20 00 clr %i4
200e514: 80 a0 60 00 cmp %g1, 0
200e518: 12 80 00 1c bne 200e588 <IMFS_memfile_remove+0x104>
200e51c: 33 00 80 75 sethi %hi(0x201d400), %i1
200e520: 81 c7 e0 08 ret
200e524: 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(
200e528: 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];
200e52c: f6 00 40 10 ld [ %g1 + %l0 ], %i3
if ( !p ) /* ensure we have a valid pointer */
200e530: 80 a6 e0 00 cmp %i3, 0
200e534: 02 80 00 1b be 200e5a0 <IMFS_memfile_remove+0x11c> <== NEVER TAKEN
200e538: 90 06 20 60 add %i0, 0x60, %o0
200e53c: 10 80 00 09 b 200e560 <IMFS_memfile_remove+0xdc>
200e540: b4 10 20 00 clr %i2
break;
for ( j=0 ; j<IMFS_MEMFILE_BLOCK_SLOTS ; j++ ) {
if ( p[j] ) {
200e544: 80 a0 60 00 cmp %g1, 0
200e548: 02 80 00 04 be 200e558 <IMFS_memfile_remove+0xd4> <== NEVER TAKEN
200e54c: 90 10 00 1b mov %i3, %o0
memfile_free_blocks_in_table( (block_p **)&p[j], to_free);
200e550: 7f ff ff ba call 200e438 <memfile_free_blocks_in_table>
200e554: 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++ ) {
200e558: b4 06 a0 01 inc %i2
200e55c: b6 06 e0 04 add %i3, 4, %i3
200e560: c2 06 61 d8 ld [ %i1 + 0x1d8 ], %g1
200e564: 83 30 60 02 srl %g1, 2, %g1
200e568: 80 a6 80 01 cmp %i2, %g1
200e56c: 2a bf ff f6 bcs,a 200e544 <IMFS_memfile_remove+0xc0>
200e570: 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(
200e574: d0 06 20 60 ld [ %i0 + 0x60 ], %o0
200e578: 92 10 00 1d mov %i5, %o1
200e57c: 90 02 00 10 add %o0, %l0, %o0
200e580: 7f ff ff ae call 200e438 <memfile_free_blocks_in_table>
200e584: 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++ ) {
200e588: c2 06 61 d8 ld [ %i1 + 0x1d8 ], %g1
200e58c: 83 30 60 02 srl %g1, 2, %g1
200e590: 80 a7 00 01 cmp %i4, %g1
200e594: 2a bf ff e5 bcs,a 200e528 <IMFS_memfile_remove+0xa4>
200e598: 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(
200e59c: 90 06 20 60 add %i0, 0x60, %o0
200e5a0: 7f ff ff a6 call 200e438 <memfile_free_blocks_in_table>
200e5a4: 92 10 00 1d mov %i5, %o1
(block_p **)&info->triply_indirect, to_free );
}
return the_jnode;
}
200e5a8: 81 c7 e0 08 ret
200e5ac: 81 e8 00 00 restore
0200e5b0 <IMFS_memfile_remove_block>:
*/
MEMFILE_STATIC int IMFS_memfile_remove_block(
IMFS_jnode_t *the_jnode,
unsigned int block
)
{
200e5b0: 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 );
200e5b4: 94 10 20 00 clr %o2 <== NOT EXECUTED
200e5b8: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
200e5bc: 7f ff fe 5d call 200df30 <IMFS_memfile_get_block_pointer> <== NOT EXECUTED
200e5c0: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
200e5c4: 82 10 00 08 mov %o0, %g1 <== NOT EXECUTED
IMFS_assert( block_ptr );
ptr = *block_ptr;
200e5c8: d0 02 00 00 ld [ %o0 ], %o0 <== NOT EXECUTED
*block_ptr = 0;
memfile_free_block( ptr );
return 1;
}
200e5cc: 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 );
200e5d0: 7f ff ff 91 call 200e414 <memfile_free_block> <== NOT EXECUTED
200e5d4: c0 20 40 00 clr [ %g1 ] <== NOT EXECUTED
return 1;
}
200e5d8: 81 c7 e0 08 ret <== NOT EXECUTED
200e5dc: 81 e8 00 00 restore <== NOT EXECUTED
0200e780 <IMFS_memfile_write>:
IMFS_jnode_t *the_jnode,
off_t start,
const unsigned char *source,
unsigned int length
)
{
200e780: 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 ) {
200e784: c2 06 20 50 ld [ %i0 + 0x50 ], %g1
200e788: 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;
200e78c: 96 07 00 1a add %i4, %i2, %o3
if ( last_byte > the_jnode->info.file.size ) {
200e790: 80 a0 c0 01 cmp %g3, %g1
200e794: 14 80 00 1b bg 200e800 <IMFS_memfile_write+0x80> <== NEVER TAKEN
200e798: c4 06 20 54 ld [ %i0 + 0x54 ], %g2
200e79c: 80 a0 c0 01 cmp %g3, %g1
200e7a0: 32 80 00 06 bne,a 200e7b8 <IMFS_memfile_write+0x38> <== NEVER TAKEN
200e7a4: 03 00 80 75 sethi %hi(0x201d400), %g1 <== NOT EXECUTED
200e7a8: 80 a2 c0 02 cmp %o3, %g2
200e7ac: 18 80 00 16 bgu 200e804 <IMFS_memfile_write+0x84>
200e7b0: 80 a6 40 01 cmp %i1, %g1
*/
/*
* Phase 1: possibly the last part of one block
*/
start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;
200e7b4: 03 00 80 75 sethi %hi(0x201d400), %g1
200e7b8: fa 00 61 d8 ld [ %g1 + 0x1d8 ], %i5 ! 201d5d8 <imfs_memfile_bytes_per_block>
200e7bc: 92 10 00 1a mov %i2, %o1
200e7c0: a3 3f 60 1f sra %i5, 0x1f, %l1
200e7c4: 96 10 00 1d mov %i5, %o3
200e7c8: 94 10 00 11 mov %l1, %o2
200e7cc: 40 00 2a 76 call 20191a4 <__moddi3>
200e7d0: 90 10 00 19 mov %i1, %o0
block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;
200e7d4: 90 10 00 19 mov %i1, %o0
*/
/*
* Phase 1: possibly the last part of one block
*/
start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;
200e7d8: a0 10 00 09 mov %o1, %l0
block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;
200e7dc: 94 10 00 11 mov %l1, %o2
200e7e0: 92 10 00 1a mov %i2, %o1
200e7e4: 40 00 29 85 call 2018df8 <__divdi3>
200e7e8: 96 10 00 1d mov %i5, %o3
if ( start_offset ) {
200e7ec: 80 a4 20 00 cmp %l0, 0
200e7f0: 12 80 00 17 bne 200e84c <IMFS_memfile_write+0xcc>
200e7f4: b4 10 00 09 mov %o1, %i2
status = IMFS_memfile_extend( the_jnode, zero_fill, last_byte );
if ( status )
return status;
}
copied = 0;
200e7f8: 10 80 00 28 b 200e898 <IMFS_memfile_write+0x118>
200e7fc: 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;
200e800: 80 a6 40 01 cmp %i1, %g1 <== NOT EXECUTED
200e804: 14 80 00 09 bg 200e828 <IMFS_memfile_write+0xa8> <== NEVER TAKEN
200e808: 92 10 20 01 mov 1, %o1
200e80c: 80 a6 40 01 cmp %i1, %g1
200e810: 32 80 00 06 bne,a 200e828 <IMFS_memfile_write+0xa8> <== NEVER TAKEN
200e814: 92 10 20 00 clr %o1 <== NOT EXECUTED
200e818: 80 a6 80 02 cmp %i2, %g2
200e81c: 18 80 00 04 bgu 200e82c <IMFS_memfile_write+0xac>
200e820: 90 10 00 18 mov %i0, %o0
200e824: 92 10 20 00 clr %o1
status = IMFS_memfile_extend( the_jnode, zero_fill, last_byte );
200e828: 90 10 00 18 mov %i0, %o0
200e82c: 92 0a 60 01 and %o1, 1, %o1
200e830: 7f ff ff 6c call 200e5e0 <IMFS_memfile_extend>
200e834: 94 10 20 00 clr %o2
if ( status )
200e838: 82 92 20 00 orcc %o0, 0, %g1
200e83c: 22 bf ff df be,a 200e7b8 <IMFS_memfile_write+0x38>
200e840: 03 00 80 75 sethi %hi(0x201d400), %g1
}
IMFS_mtime_ctime_update( the_jnode );
return copied;
}
200e844: 81 c7 e0 08 ret
200e848: 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;
200e84c: ba 27 40 10 sub %i5, %l0, %i5
200e850: 80 a7 40 1c cmp %i5, %i4
200e854: 38 80 00 02 bgu,a 200e85c <IMFS_memfile_write+0xdc>
200e858: 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 );
200e85c: 90 10 00 18 mov %i0, %o0
200e860: 92 10 00 1a mov %i2, %o1
200e864: 7f ff fd b3 call 200df30 <IMFS_memfile_get_block_pointer>
200e868: 94 10 20 00 clr %o2
if ( !block_ptr )
200e86c: 80 a2 20 00 cmp %o0, 0
200e870: 02 80 00 36 be 200e948 <IMFS_memfile_write+0x1c8> <== NEVER TAKEN
200e874: 82 10 20 00 clr %g1
block,
to_copy,
src
);
#endif
memcpy( &(*block_ptr)[ start_offset ], src, to_copy );
200e878: d0 02 00 00 ld [ %o0 ], %o0
200e87c: 92 10 00 1b mov %i3, %o1
200e880: 90 02 00 10 add %o0, %l0, %o0
200e884: 94 10 00 1d mov %i5, %o2
200e888: 40 00 06 ab call 2010334 <memcpy>
200e88c: b6 06 c0 1d add %i3, %i5, %i3
src += to_copy;
block++;
200e890: b4 06 a0 01 inc %i2
my_length -= to_copy;
200e894: b8 27 00 1d sub %i4, %i5, %i4
/*
* Phase 2: all of zero of more blocks
*/
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;
200e898: 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(
200e89c: b6 26 c0 1d sub %i3, %i5, %i3
/*
* Phase 2: all of zero of more blocks
*/
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;
200e8a0: f2 00 61 d8 ld [ %g1 + 0x1d8 ], %i1
while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {
200e8a4: 10 80 00 0f b 200e8e0 <IMFS_memfile_write+0x160>
200e8a8: a2 10 00 01 mov %g1, %l1
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
200e8ac: 90 10 00 18 mov %i0, %o0
200e8b0: 92 10 00 1a mov %i2, %o1
200e8b4: 7f ff fd 9f call 200df30 <IMFS_memfile_get_block_pointer>
200e8b8: 94 10 20 00 clr %o2
if ( !block_ptr )
200e8bc: 80 a2 20 00 cmp %o0, 0
200e8c0: 02 80 00 21 be 200e944 <IMFS_memfile_write+0x1c4> <== NEVER TAKEN
200e8c4: 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 );
200e8c8: d0 02 00 00 ld [ %o0 ], %o0
200e8cc: 92 10 00 10 mov %l0, %o1
200e8d0: 40 00 06 99 call 2010334 <memcpy>
200e8d4: b4 06 a0 01 inc %i2
src += to_copy;
block++;
my_length -= to_copy;
200e8d8: 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(
200e8dc: 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 ) {
200e8e0: c2 04 61 d8 ld [ %l1 + 0x1d8 ], %g1
200e8e4: 80 a7 00 01 cmp %i4, %g1
200e8e8: 1a bf ff f1 bcc 200e8ac <IMFS_memfile_write+0x12c>
200e8ec: 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 ) {
200e8f0: 80 a7 20 00 cmp %i4, 0
200e8f4: 02 80 00 0f be 200e930 <IMFS_memfile_write+0x1b0>
200e8f8: 90 07 bf f8 add %fp, -8, %o0
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
200e8fc: 90 10 00 18 mov %i0, %o0
200e900: 92 10 00 1a mov %i2, %o1
200e904: 7f ff fd 8b call 200df30 <IMFS_memfile_get_block_pointer>
200e908: 94 10 20 00 clr %o2
if ( !block_ptr )
200e90c: 80 a2 20 00 cmp %o0, 0
200e910: 02 80 00 0e be 200e948 <IMFS_memfile_write+0x1c8> <== NEVER TAKEN
200e914: 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 );
200e918: d0 02 00 00 ld [ %o0 ], %o0
200e91c: 92 10 00 10 mov %l0, %o1
200e920: 94 10 00 1c mov %i4, %o2
200e924: 40 00 06 84 call 2010334 <memcpy>
200e928: ba 07 40 1c add %i5, %i4, %i5
my_length = 0;
copied += to_copy;
}
IMFS_mtime_ctime_update( the_jnode );
200e92c: 90 07 bf f8 add %fp, -8, %o0
200e930: 7f ff d3 d5 call 2003884 <gettimeofday>
200e934: 92 10 20 00 clr %o1
200e938: c2 07 bf f8 ld [ %fp + -8 ], %g1
200e93c: c2 26 20 44 st %g1, [ %i0 + 0x44 ]
200e940: 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 )
200e944: 82 10 00 1d mov %i5, %g1
}
IMFS_mtime_ctime_update( the_jnode );
return copied;
}
200e948: b0 10 00 01 mov %g1, %i0
200e94c: 81 c7 e0 08 ret
200e950: 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 f3 call 200b898 <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 31 call 200fa18 <__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 2d call 200fa18 <__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
0200bce8 <IMFS_node_remove_directory>:
static IMFS_jnode_t *IMFS_node_remove_directory(
IMFS_jnode_t *node,
const IMFS_jnode_t *root_node
)
{
200bce8: 9d e3 bf a0 save %sp, -96, %sp
if ( !rtems_chain_is_empty( &node->info.directory.Entries ) ) {
200bcec: 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 );
200bcf0: 82 06 20 54 add %i0, 0x54, %g1
200bcf4: 80 a0 80 01 cmp %g2, %g1
200bcf8: 02 80 00 06 be 200bd10 <IMFS_node_remove_directory+0x28>
200bcfc: 80 a6 00 19 cmp %i0, %i1
errno = ENOTEMPTY;
200bd00: 40 00 0f 46 call 200fa18 <__errno>
200bd04: 01 00 00 00 nop
200bd08: 10 80 00 0b b 200bd34 <IMFS_node_remove_directory+0x4c>
200bd0c: 82 10 20 5a mov 0x5a, %g1 ! 5a <PROM_START+0x5a>
node = NULL;
} else if ( node == root_node || IMFS_is_mount_point( node ) ) {
200bd10: 02 80 00 06 be 200bd28 <IMFS_node_remove_directory+0x40>
200bd14: 01 00 00 00 nop
200bd18: c2 06 20 5c ld [ %i0 + 0x5c ], %g1
200bd1c: 80 a0 60 00 cmp %g1, 0
200bd20: 02 80 00 07 be 200bd3c <IMFS_node_remove_directory+0x54> <== ALWAYS TAKEN
200bd24: 01 00 00 00 nop
errno = EBUSY;
200bd28: 40 00 0f 3c call 200fa18 <__errno>
200bd2c: 01 00 00 00 nop
200bd30: 82 10 20 10 mov 0x10, %g1 ! 10 <PROM_START+0x10>
200bd34: c2 22 00 00 st %g1, [ %o0 ]
node = NULL;
200bd38: b0 10 20 00 clr %i0
}
return node;
}
200bd3c: 81 c7 e0 08 ret
200bd40: 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 45 call 2010334 <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 e8 call 200fa18 <__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 e4 call 200fa18 <__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 97 call 200fa18 <__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 93 call 200fa18 <__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
020222b4 <Stack_check_Dump_threads_usage>:
static rtems_printk_plugin_t print_handler;
static void Stack_check_Dump_threads_usage(
Thread_Control *the_thread
)
{
20222b4: 9d e3 bf 98 save %sp, -104, %sp
/*
* Obtain interrupt stack information
*/
#if (CPU_ALLOCATE_INTERRUPT_STACK == TRUE)
if (the_thread == (Thread_Control *) -1) {
20222b8: 80 a6 3f ff cmp %i0, -1
20222bc: 32 80 00 0a bne,a 20222e4 <Stack_check_Dump_threads_usage+0x30>
20222c0: e0 06 21 40 ld [ %i0 + 0x140 ], %l0
if (!Stack_check_Interrupt_stack.area)
20222c4: 3b 00 81 8a sethi %hi(0x2062800), %i5
20222c8: ba 17 61 c8 or %i5, 0x1c8, %i5 ! 20629c8 <Stack_check_Interrupt_stack>
20222cc: c2 07 60 04 ld [ %i5 + 4 ], %g1
20222d0: 80 a0 60 00 cmp %g1, 0
20222d4: 02 80 00 4c be 2022404 <Stack_check_Dump_threads_usage+0x150><== NEVER TAKEN
20222d8: a0 10 20 00 clr %l0
return;
stack = &Stack_check_Interrupt_stack;
the_thread = 0;
20222dc: 10 80 00 04 b 20222ec <Stack_check_Dump_threads_usage+0x38>
20222e0: b0 10 20 00 clr %i0
current = 0;
} else
#endif
{
stack = &the_thread->Start.Initial_stack;
20222e4: ba 06 20 b4 add %i0, 0xb4, %i5
current = (void *)_CPU_Context_Get_SP( &the_thread->Registers );
}
low = Stack_check_usable_stack_start(stack);
20222e8: c2 07 60 04 ld [ %i5 + 4 ], %g1
size = Stack_check_usable_stack_size(stack);
20222ec: 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);
20222f0: 84 00 60 10 add %g1, 0x10, %g2
size = Stack_check_usable_stack_size(stack);
20222f4: 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;
20222f8: 82 00 60 20 add %g1, 0x20, %g1
for (ebase = base + length; base < ebase; base++)
20222fc: 86 0e 7f fc and %i1, -4, %g3
if (*base != U32_PATTERN)
2022300: 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++)
2022304: 86 00 40 03 add %g1, %g3, %g3
if (*base != U32_PATTERN)
2022308: 10 80 00 06 b 2022320 <Stack_check_Dump_threads_usage+0x6c>
202230c: 88 11 21 a5 or %g4, 0x1a5, %g4
2022310: 80 a7 00 04 cmp %i4, %g4
2022314: 12 80 00 08 bne 2022334 <Stack_check_Dump_threads_usage+0x80>
2022318: 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++)
202231c: 82 00 60 04 add %g1, 4, %g1
2022320: 80 a0 40 03 cmp %g1, %g3
2022324: 2a bf ff fb bcs,a 2022310 <Stack_check_Dump_threads_usage+0x5c><== ALWAYS TAKEN
2022328: 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;
202232c: 10 80 00 06 b 2022344 <Stack_check_Dump_threads_usage+0x90><== NOT EXECUTED
2022330: 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 )
2022334: 02 80 00 04 be 2022344 <Stack_check_Dump_threads_usage+0x90><== NEVER TAKEN
2022338: b8 10 20 00 clr %i4
used = Stack_check_Calculate_used( low, size, high_water_mark );
202233c: b8 00 80 19 add %g2, %i1, %i4
2022340: b8 27 00 01 sub %i4, %g1, %i4
else
used = 0;
#if (CPU_ALLOCATE_INTERRUPT_STACK == TRUE)
if ( the_thread )
2022344: 80 a6 20 00 cmp %i0, 0
2022348: 02 80 00 12 be 2022390 <Stack_check_Dump_threads_usage+0xdc>
202234c: 03 00 81 85 sethi %hi(0x2061400), %g1
#endif
{
(*print_handler)(
2022350: f6 06 20 08 ld [ %i0 + 8 ], %i3
2022354: f4 00 62 c8 ld [ %g1 + 0x2c8 ], %i2
2022358: 03 00 81 85 sethi %hi(0x2061400), %g1
202235c: e2 00 62 c4 ld [ %g1 + 0x2c4 ], %l1 ! 20616c4 <print_context>
2022360: 94 07 bf f8 add %fp, -8, %o2
2022364: 90 10 00 1b mov %i3, %o0
2022368: 7f ff b3 24 call 200eff8 <rtems_object_get_name>
202236c: 92 10 20 05 mov 5, %o1
2022370: 13 00 81 61 sethi %hi(0x2058400), %o1
2022374: 96 10 00 08 mov %o0, %o3
2022378: 92 12 61 b8 or %o1, 0x1b8, %o1
202237c: 90 10 00 11 mov %l1, %o0
2022380: 9f c6 80 00 call %i2
2022384: 94 10 00 1b mov %i3, %o2
(*print_handler)(
print_context,
" %010p - %010p %010p %8" PRId32 " ",
stack->area,
stack->area + stack->size - 1,
2022388: 10 80 00 0a b 20223b0 <Stack_check_Dump_threads_usage+0xfc>
202238c: 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 );
2022390: 05 00 81 85 sethi %hi(0x2061400), %g2
2022394: c2 00 62 c8 ld [ %g1 + 0x2c8 ], %g1
2022398: d0 00 a2 c4 ld [ %g2 + 0x2c4 ], %o0
202239c: 13 00 81 61 sethi %hi(0x2058400), %o1
20223a0: 94 10 3f ff mov -1, %o2
20223a4: 9f c0 40 00 call %g1
20223a8: 92 12 61 c8 or %o1, 0x1c8, %o1
(*print_handler)(
print_context,
" %010p - %010p %010p %8" PRId32 " ",
stack->area,
stack->area + stack->size - 1,
20223ac: d4 07 60 04 ld [ %i5 + 4 ], %o2
else {
(*print_handler)( print_context, "0x%08" PRIx32 " INTR", ~0 );
}
#endif
(*print_handler)(
20223b0: 35 00 81 85 sethi %hi(0x2061400), %i2
20223b4: 37 00 81 85 sethi %hi(0x2061400), %i3
print_context,
" %010p - %010p %010p %8" PRId32 " ",
stack->area,
stack->area + stack->size - 1,
20223b8: d6 07 40 00 ld [ %i5 ], %o3
else {
(*print_handler)( print_context, "0x%08" PRIx32 " INTR", ~0 );
}
#endif
(*print_handler)(
20223bc: c2 06 a2 c8 ld [ %i2 + 0x2c8 ], %g1
20223c0: d0 06 e2 c4 ld [ %i3 + 0x2c4 ], %o0
print_context,
" %010p - %010p %010p %8" PRId32 " ",
stack->area,
stack->area + stack->size - 1,
20223c4: 96 02 ff ff add %o3, -1, %o3
else {
(*print_handler)( print_context, "0x%08" PRIx32 " INTR", ~0 );
}
#endif
(*print_handler)(
20223c8: 13 00 81 61 sethi %hi(0x2058400), %o1
20223cc: 96 02 80 0b add %o2, %o3, %o3
20223d0: 92 12 61 d8 or %o1, 0x1d8, %o1
20223d4: 98 10 00 10 mov %l0, %o4
20223d8: 9f c0 40 00 call %g1
20223dc: 9a 10 00 19 mov %i1, %o5
stack->area + stack->size - 1,
current,
size
);
if (Stack_check_Initialized == 0) {
20223e0: 03 00 81 85 sethi %hi(0x2061400), %g1
20223e4: c2 00 62 c0 ld [ %g1 + 0x2c0 ], %g1 ! 20616c0 <Stack_check_Initialized>
(*print_handler)( print_context, "Unavailable\n" );
20223e8: d0 06 e2 c4 ld [ %i3 + 0x2c4 ], %o0
stack->area + stack->size - 1,
current,
size
);
if (Stack_check_Initialized == 0) {
20223ec: 80 a0 60 00 cmp %g1, 0
20223f0: 12 80 00 07 bne 202240c <Stack_check_Dump_threads_usage+0x158><== ALWAYS TAKEN
20223f4: c2 06 a2 c8 ld [ %i2 + 0x2c8 ], %g1
(*print_handler)( print_context, "Unavailable\n" );
20223f8: 13 00 81 61 sethi %hi(0x2058400), %o1 <== NOT EXECUTED
20223fc: 9f c0 40 00 call %g1 <== NOT EXECUTED
2022400: 92 12 61 f8 or %o1, 0x1f8, %o1 ! 20585f8 <RTEMS_BDPART_MBR_MASTER_TYPE+0x300><== NOT EXECUTED
2022404: 81 c7 e0 08 ret <== NOT EXECUTED
2022408: 81 e8 00 00 restore <== NOT EXECUTED
} else {
(*print_handler)( print_context, "%8" PRId32 "\n", used );
202240c: 13 00 81 61 sethi %hi(0x2058400), %o1
2022410: 94 10 00 1c mov %i4, %o2
2022414: 9f c0 40 00 call %g1
2022418: 92 12 62 08 or %o1, 0x208, %o1
202241c: 81 c7 e0 08 ret
2022420: 81 e8 00 00 restore
0202250c <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)
{
202250c: 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");
2022510: 11 00 81 61 sethi %hi(0x2058400), %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);
2022514: fa 06 20 b8 ld [ %i0 + 0xb8 ], %i5
char name[32];
printk("BLOWN STACK!!!\n");
2022518: 7f ff 87 b8 call 20043f8 <printk>
202251c: 90 12 22 10 or %o0, 0x210, %o0
printk("task control block: 0x%08" PRIxPTR "\n", running);
2022520: 92 10 00 18 mov %i0, %o1
2022524: 11 00 81 61 sethi %hi(0x2058400), %o0
2022528: 7f ff 87 b4 call 20043f8 <printk>
202252c: 90 12 22 20 or %o0, 0x220, %o0 ! 2058620 <RTEMS_BDPART_MBR_MASTER_TYPE+0x328>
printk("task ID: 0x%08lx\n", (unsigned long) running->Object.id);
2022530: d2 06 20 08 ld [ %i0 + 8 ], %o1
2022534: 11 00 81 61 sethi %hi(0x2058400), %o0
2022538: 7f ff 87 b0 call 20043f8 <printk>
202253c: 90 12 22 40 or %o0, 0x240, %o0 ! 2058640 <RTEMS_BDPART_MBR_MASTER_TYPE+0x348>
printk(
2022540: d2 06 20 0c ld [ %i0 + 0xc ], %o1
2022544: 11 00 81 61 sethi %hi(0x2058400), %o0
2022548: 7f ff 87 ac call 20043f8 <printk>
202254c: 90 12 22 58 or %o0, 0x258, %o0 ! 2058658 <RTEMS_BDPART_MBR_MASTER_TYPE+0x360>
"task name: 0x%08" PRIx32 "\n",
running->Object.name.name_u32
);
printk(
2022550: d0 06 20 08 ld [ %i0 + 8 ], %o0
2022554: 94 07 bf e0 add %fp, -32, %o2
2022558: 7f ff b2 a8 call 200eff8 <rtems_object_get_name>
202255c: 92 10 20 20 mov 0x20, %o1
2022560: 92 10 00 08 mov %o0, %o1
2022564: 11 00 81 61 sethi %hi(0x2058400), %o0
2022568: 7f ff 87 a4 call 20043f8 <printk>
202256c: 90 12 22 70 or %o0, 0x270, %o0 ! 2058670 <RTEMS_BDPART_MBR_MASTER_TYPE+0x378>
);
printk(
"task stack area (%lu Bytes): 0x%08" PRIxPTR " .. 0x%08" PRIxPTR "\n",
(unsigned long) stack->size,
stack->area,
((char *) stack->area + stack->size)
2022570: d4 06 20 b8 ld [ %i0 + 0xb8 ], %o2
2022574: 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(
2022578: 11 00 81 61 sethi %hi(0x2058400), %o0
202257c: 96 02 80 09 add %o2, %o1, %o3
2022580: 7f ff 87 9e call 20043f8 <printk>
2022584: 90 12 22 88 or %o0, 0x288, %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) {
2022588: 80 a6 60 00 cmp %i1, 0
202258c: 12 80 00 07 bne 20225a8 <Stack_check_report_blown_task+0x9c><== NEVER TAKEN
2022590: 11 00 81 61 sethi %hi(0x2058400), %o0
printk(
2022594: 92 10 20 10 mov 0x10, %o1
2022598: 90 12 22 b8 or %o0, 0x2b8, %o0
202259c: 94 07 60 08 add %i5, 8, %o2
20225a0: 7f ff 87 96 call 20043f8 <printk>
20225a4: 96 07 60 18 add %i5, 0x18, %o3
rtems_configuration_get_user_multiprocessing_table()->node
);
}
#endif
rtems_fatal_error_occurred(0x81);
20225a8: 7f ff 95 e8 call 2007d48 <rtems_fatal_error_occurred>
20225ac: 90 10 20 81 mov 0x81, %o0
0200a954 <_CORE_RWLock_Release>:
*/
CORE_RWLock_Status _CORE_RWLock_Release(
CORE_RWLock_Control *the_rwlock
)
{
200a954: 9d e3 bf a0 save %sp, -96, %sp
ISR_Level level;
Thread_Control *executing = _Thread_Executing;
200a958: 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 );
200a95c: 7f ff e4 a1 call 2003be0 <sparc_disable_interrupts>
200a960: fa 00 61 2c ld [ %g1 + 0x12c ], %i5 ! 202112c <_Per_CPU_Information+0xc>
200a964: 84 10 00 08 mov %o0, %g2
if ( the_rwlock->current_state == CORE_RWLOCK_UNLOCKED){
200a968: c2 06 20 44 ld [ %i0 + 0x44 ], %g1
200a96c: 80 a0 60 00 cmp %g1, 0
200a970: 12 80 00 08 bne 200a990 <_CORE_RWLock_Release+0x3c>
200a974: 80 a0 60 01 cmp %g1, 1
_ISR_Enable( level );
200a978: 7f ff e4 9e call 2003bf0 <sparc_enable_interrupts>
200a97c: b0 10 20 00 clr %i0
executing->Wait.return_code = CORE_RWLOCK_UNAVAILABLE;
200a980: 82 10 20 02 mov 2, %g1
200a984: c2 27 60 34 st %g1, [ %i5 + 0x34 ]
200a988: 81 c7 e0 08 ret
200a98c: 81 e8 00 00 restore
return CORE_RWLOCK_SUCCESSFUL;
}
if ( the_rwlock->current_state == CORE_RWLOCK_LOCKED_FOR_READING ) {
200a990: 32 80 00 0b bne,a 200a9bc <_CORE_RWLock_Release+0x68>
200a994: c0 27 60 34 clr [ %i5 + 0x34 ]
the_rwlock->number_of_readers -= 1;
200a998: c2 06 20 48 ld [ %i0 + 0x48 ], %g1
200a99c: 82 00 7f ff add %g1, -1, %g1
if ( the_rwlock->number_of_readers != 0 ) {
200a9a0: 80 a0 60 00 cmp %g1, 0
200a9a4: 02 80 00 05 be 200a9b8 <_CORE_RWLock_Release+0x64>
200a9a8: c2 26 20 48 st %g1, [ %i0 + 0x48 ]
/* must be unlocked again */
_ISR_Enable( level );
200a9ac: 7f ff e4 91 call 2003bf0 <sparc_enable_interrupts>
200a9b0: b0 10 20 00 clr %i0
return CORE_RWLOCK_SUCCESSFUL;
200a9b4: 30 80 00 24 b,a 200aa44 <_CORE_RWLock_Release+0xf0>
}
}
/* CORE_RWLOCK_LOCKED_FOR_WRITING or READING with readers */
executing->Wait.return_code = CORE_RWLOCK_SUCCESSFUL;
200a9b8: 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;
200a9bc: c0 26 20 44 clr [ %i0 + 0x44 ]
_ISR_Enable( level );
200a9c0: 7f ff e4 8c call 2003bf0 <sparc_enable_interrupts>
200a9c4: 90 10 00 02 mov %g2, %o0
next = _Thread_queue_Dequeue( &the_rwlock->Wait_queue );
200a9c8: 40 00 07 9d call 200c83c <_Thread_queue_Dequeue>
200a9cc: 90 10 00 18 mov %i0, %o0
if ( next ) {
200a9d0: 80 a2 20 00 cmp %o0, 0
200a9d4: 22 80 00 1c be,a 200aa44 <_CORE_RWLock_Release+0xf0>
200a9d8: b0 10 20 00 clr %i0
if ( next->Wait.option == CORE_RWLOCK_THREAD_WAITING_FOR_WRITE ) {
200a9dc: c2 02 20 30 ld [ %o0 + 0x30 ], %g1
200a9e0: 80 a0 60 01 cmp %g1, 1
200a9e4: 32 80 00 05 bne,a 200a9f8 <_CORE_RWLock_Release+0xa4>
200a9e8: c2 06 20 48 ld [ %i0 + 0x48 ], %g1
the_rwlock->current_state = CORE_RWLOCK_LOCKED_FOR_WRITING;
200a9ec: 82 10 20 02 mov 2, %g1
return CORE_RWLOCK_SUCCESSFUL;
200a9f0: 10 80 00 14 b 200aa40 <_CORE_RWLock_Release+0xec>
200a9f4: c2 26 20 44 st %g1, [ %i0 + 0x44 ]
}
/*
* Must be CORE_RWLOCK_THREAD_WAITING_FOR_READING
*/
the_rwlock->number_of_readers += 1;
200a9f8: 82 00 60 01 inc %g1
200a9fc: c2 26 20 48 st %g1, [ %i0 + 0x48 ]
the_rwlock->current_state = CORE_RWLOCK_LOCKED_FOR_READING;
200aa00: 82 10 20 01 mov 1, %g1
200aa04: 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 );
200aa08: 40 00 08 c9 call 200cd2c <_Thread_queue_First>
200aa0c: 90 10 00 18 mov %i0, %o0
if ( !next ||
200aa10: 92 92 20 00 orcc %o0, 0, %o1
200aa14: 22 80 00 0c be,a 200aa44 <_CORE_RWLock_Release+0xf0>
200aa18: b0 10 20 00 clr %i0
200aa1c: c2 02 60 30 ld [ %o1 + 0x30 ], %g1
200aa20: 80 a0 60 01 cmp %g1, 1
200aa24: 02 80 00 07 be 200aa40 <_CORE_RWLock_Release+0xec> <== NEVER TAKEN
200aa28: 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;
200aa2c: c2 06 20 48 ld [ %i0 + 0x48 ], %g1
200aa30: 82 00 60 01 inc %g1
_Thread_queue_Extract( &the_rwlock->Wait_queue, next );
200aa34: 40 00 08 6f call 200cbf0 <_Thread_queue_Extract>
200aa38: c2 26 20 48 st %g1, [ %i0 + 0x48 ]
}
200aa3c: 30 bf ff f3 b,a 200aa08 <_CORE_RWLock_Release+0xb4>
}
/* indentation is to match _ISR_Disable at top */
return CORE_RWLOCK_SUCCESSFUL;
}
200aa40: b0 10 20 00 clr %i0
200aa44: 81 c7 e0 08 ret
200aa48: 81 e8 00 00 restore
0200aa4c <_CORE_RWLock_Timeout>:
void _CORE_RWLock_Timeout(
Objects_Id id,
void *ignored
)
{
200aa4c: 9d e3 bf 98 save %sp, -104, %sp
Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
200aa50: 90 10 00 18 mov %i0, %o0
200aa54: 40 00 06 a2 call 200c4dc <_Thread_Get>
200aa58: 92 07 bf fc add %fp, -4, %o1
switch ( location ) {
200aa5c: c2 07 bf fc ld [ %fp + -4 ], %g1
200aa60: 80 a0 60 00 cmp %g1, 0
200aa64: 12 80 00 09 bne 200aa88 <_CORE_RWLock_Timeout+0x3c> <== NEVER TAKEN
200aa68: 01 00 00 00 nop
#if defined(RTEMS_MULTIPROCESSING)
case OBJECTS_REMOTE: /* impossible */
#endif
break;
case OBJECTS_LOCAL:
_Thread_queue_Process_timeout( the_thread );
200aa6c: 40 00 08 ed call 200ce20 <_Thread_queue_Process_timeout>
200aa70: 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--;
200aa74: 03 00 80 82 sethi %hi(0x2020800), %g1
200aa78: c4 00 63 f0 ld [ %g1 + 0x3f0 ], %g2 ! 2020bf0 <_Thread_Dispatch_disable_level>
200aa7c: 84 00 bf ff add %g2, -1, %g2
200aa80: c4 20 63 f0 st %g2, [ %g1 + 0x3f0 ]
return _Thread_Dispatch_disable_level;
200aa84: c2 00 63 f0 ld [ %g1 + 0x3f0 ], %g1
200aa88: 81 c7 e0 08 ret
200aa8c: 81 e8 00 00 restore
020110e4 <_CORE_message_queue_Initialize>:
CORE_message_queue_Control *the_message_queue,
CORE_message_queue_Attributes *the_message_queue_attributes,
uint32_t maximum_pending_messages,
size_t maximum_message_size
)
{
20110e4: 9d e3 bf a0 save %sp, -96, %sp
size_t message_buffering_required = 0;
size_t allocated_message_size;
the_message_queue->maximum_pending_messages = maximum_pending_messages;
20110e8: f4 26 20 44 st %i2, [ %i0 + 0x44 ]
the_message_queue->number_of_pending_messages = 0;
20110ec: c0 26 20 48 clr [ %i0 + 0x48 ]
the_message_queue->maximum_message_size = maximum_message_size;
20110f0: f6 26 20 4c st %i3, [ %i0 + 0x4c ]
CORE_message_queue_Control *the_message_queue,
CORE_message_queue_Notify_Handler the_handler,
void *the_argument
)
{
the_message_queue->notify_handler = the_handler;
20110f4: c0 26 20 60 clr [ %i0 + 0x60 ]
/*
* Round size up to multiple of a pointer for chain init and
* check for overflow on adding overhead to each message.
*/
allocated_message_size = maximum_message_size;
if (allocated_message_size & (sizeof(uint32_t) - 1)) {
20110f8: 80 8e e0 03 btst 3, %i3
20110fc: 02 80 00 09 be 2011120 <_CORE_message_queue_Initialize+0x3c>
2011100: c0 26 20 64 clr [ %i0 + 0x64 ]
allocated_message_size += sizeof(uint32_t);
2011104: 96 06 e0 04 add %i3, 4, %o3
allocated_message_size &= ~(sizeof(uint32_t) - 1);
2011108: 96 0a ff fc and %o3, -4, %o3
}
if (allocated_message_size < maximum_message_size)
201110c: 80 a2 c0 1b cmp %o3, %i3
2011110: 3a 80 00 06 bcc,a 2011128 <_CORE_message_queue_Initialize+0x44><== ALWAYS TAKEN
2011114: ba 02 e0 14 add %o3, 0x14, %i5
return false;
2011118: 10 80 00 24 b 20111a8 <_CORE_message_queue_Initialize+0xc4>
201111c: b0 10 20 00 clr %i0
/*
* Round size up to multiple of a pointer for chain init and
* check for overflow on adding overhead to each message.
*/
allocated_message_size = maximum_message_size;
if (allocated_message_size & (sizeof(uint32_t) - 1)) {
2011120: 96 10 00 1b mov %i3, %o3
/*
* Calculate how much total memory is required for message buffering and
* check for overflow on the multiplication.
*/
if ( !size_t_mult32_with_overflow(
2011124: ba 02 e0 14 add %o3, 0x14, %i5
size_t a,
size_t b,
size_t *c
)
{
long long x = (long long)a*b;
2011128: 90 10 20 00 clr %o0
201112c: 92 10 00 1a mov %i2, %o1
2011130: 94 10 20 00 clr %o2
2011134: 40 00 43 75 call 2021f08 <__muldi3>
2011138: 96 10 00 1d mov %i5, %o3
if ( x > SIZE_MAX )
201113c: 80 a2 20 00 cmp %o0, 0
2011140: 34 80 00 1a bg,a 20111a8 <_CORE_message_queue_Initialize+0xc4>
2011144: b0 10 20 00 clr %i0
/*
* Attempt to allocate the message memory
*/
the_message_queue->message_buffers = (CORE_message_queue_Buffer *)
_Workspace_Allocate( message_buffering_required );
2011148: 40 00 0c 1c call 20141b8 <_Workspace_Allocate>
201114c: 90 10 00 09 mov %o1, %o0
return false;
/*
* Attempt to allocate the message memory
*/
the_message_queue->message_buffers = (CORE_message_queue_Buffer *)
2011150: d0 26 20 5c st %o0, [ %i0 + 0x5c ]
_Workspace_Allocate( message_buffering_required );
if (the_message_queue->message_buffers == 0)
2011154: 80 a2 20 00 cmp %o0, 0
2011158: 02 bf ff f0 be 2011118 <_CORE_message_queue_Initialize+0x34>
201115c: 92 10 00 08 mov %o0, %o1
/*
* Initialize the pool of inactive messages, pending messages,
* and set of waiting threads.
*/
_Chain_Initialize (
2011160: 90 06 20 68 add %i0, 0x68, %o0
2011164: 94 10 00 1a mov %i2, %o2
2011168: 7f ff ff d1 call 20110ac <_Chain_Initialize>
201116c: 96 10 00 1d mov %i5, %o3
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 );
2011170: 82 06 20 50 add %i0, 0x50, %g1
head->next = tail;
head->previous = NULL;
tail->previous = head;
2011174: c2 26 20 58 st %g1, [ %i0 + 0x58 ]
*/
RTEMS_INLINE_ROUTINE bool _CORE_message_queue_Is_priority(
CORE_message_queue_Attributes *the_attribute
)
{
return
2011178: c2 06 40 00 ld [ %i1 ], %g1
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 );
201117c: 84 06 20 54 add %i0, 0x54, %g2
2011180: 82 18 60 01 xor %g1, 1, %g1
allocated_message_size + sizeof( CORE_message_queue_Buffer_control )
);
_Chain_Initialize_empty( &the_message_queue->Pending_messages );
_Thread_queue_Initialize(
2011184: 80 a0 00 01 cmp %g0, %g1
head->next = tail;
2011188: c4 26 20 50 st %g2, [ %i0 + 0x50 ]
head->previous = NULL;
201118c: c0 26 20 54 clr [ %i0 + 0x54 ]
2011190: 90 10 00 18 mov %i0, %o0
2011194: 92 60 3f ff subx %g0, -1, %o1
2011198: 94 10 20 80 mov 0x80, %o2
201119c: 96 10 20 06 mov 6, %o3
20111a0: 40 00 09 da call 2013908 <_Thread_queue_Initialize>
20111a4: b0 10 20 01 mov 1, %i0
STATES_WAITING_FOR_MESSAGE,
CORE_MESSAGE_QUEUE_STATUS_TIMEOUT
);
return true;
}
20111a8: b0 0e 20 01 and %i0, 1, %i0
20111ac: 81 c7 e0 08 ret
20111b0: 81 e8 00 00 restore
020087a0 <_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
)
{
20087a0: 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)) ) {
20087a4: 90 10 00 18 mov %i0, %o0
20087a8: 40 00 07 6e call 200a560 <_Thread_queue_Dequeue>
20087ac: ba 10 00 18 mov %i0, %i5
20087b0: 80 a2 20 00 cmp %o0, 0
20087b4: 12 80 00 0e bne 20087ec <_CORE_semaphore_Surrender+0x4c>
20087b8: 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 );
20087bc: 7f ff e7 c2 call 20026c4 <sparc_disable_interrupts>
20087c0: 01 00 00 00 nop
if ( the_semaphore->count < the_semaphore->Attributes.maximum_count )
20087c4: c2 07 60 48 ld [ %i5 + 0x48 ], %g1
20087c8: c4 07 60 40 ld [ %i5 + 0x40 ], %g2
20087cc: 80 a0 40 02 cmp %g1, %g2
20087d0: 1a 80 00 05 bcc 20087e4 <_CORE_semaphore_Surrender+0x44> <== NEVER TAKEN
20087d4: b0 10 20 04 mov 4, %i0
the_semaphore->count += 1;
20087d8: 82 00 60 01 inc %g1
{
Thread_Control *the_thread;
ISR_Level level;
CORE_semaphore_Status status;
status = CORE_SEMAPHORE_STATUS_SUCCESSFUL;
20087dc: b0 10 20 00 clr %i0
#endif
} else {
_ISR_Disable( level );
if ( the_semaphore->count < the_semaphore->Attributes.maximum_count )
the_semaphore->count += 1;
20087e0: c2 27 60 48 st %g1, [ %i5 + 0x48 ]
else
status = CORE_SEMAPHORE_MAXIMUM_COUNT_EXCEEDED;
_ISR_Enable( level );
20087e4: 7f ff e7 bc call 20026d4 <sparc_enable_interrupts>
20087e8: 01 00 00 00 nop
}
return status;
}
20087ec: 81 c7 e0 08 ret
20087f0: 81 e8 00 00 restore
02007488 <_Event_Surrender>:
*/
void _Event_Surrender(
Thread_Control *the_thread
)
{
2007488: 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 ];
200748c: f8 06 21 58 ld [ %i0 + 0x158 ], %i4
option_set = (rtems_option) the_thread->Wait.option;
2007490: f6 06 20 30 ld [ %i0 + 0x30 ], %i3
_ISR_Disable( level );
2007494: 7f ff ec 8c call 20026c4 <sparc_disable_interrupts>
2007498: ba 10 00 18 mov %i0, %i5
200749c: b0 10 00 08 mov %o0, %i0
pending_events = api->pending_events;
20074a0: c4 07 00 00 ld [ %i4 ], %g2
event_condition = (rtems_event_set) the_thread->Wait.count;
20074a4: 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 ) ) {
20074a8: 82 88 c0 02 andcc %g3, %g2, %g1
20074ac: 02 80 00 42 be 20075b4 <_Event_Surrender+0x12c>
20074b0: 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() &&
20074b4: 88 11 20 20 or %g4, 0x20, %g4 ! 201e020 <_Per_CPU_Information>
20074b8: f4 01 20 08 ld [ %g4 + 8 ], %i2
20074bc: 80 a6 a0 00 cmp %i2, 0
20074c0: 22 80 00 1d be,a 2007534 <_Event_Surrender+0xac>
20074c4: c8 07 60 10 ld [ %i5 + 0x10 ], %g4
20074c8: c8 01 20 0c ld [ %g4 + 0xc ], %g4
20074cc: 80 a7 40 04 cmp %i5, %g4
20074d0: 32 80 00 19 bne,a 2007534 <_Event_Surrender+0xac>
20074d4: c8 07 60 10 ld [ %i5 + 0x10 ], %g4
_Thread_Is_executing( the_thread ) &&
((_Event_Sync_state == THREAD_BLOCKING_OPERATION_TIMEOUT) ||
20074d8: 09 00 80 79 sethi %hi(0x201e400), %g4
20074dc: f4 01 20 20 ld [ %g4 + 0x20 ], %i2 ! 201e420 <_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 ) &&
20074e0: 80 a6 a0 02 cmp %i2, 2
20074e4: 02 80 00 07 be 2007500 <_Event_Surrender+0x78> <== NEVER TAKEN
20074e8: 80 a0 40 03 cmp %g1, %g3
((_Event_Sync_state == THREAD_BLOCKING_OPERATION_TIMEOUT) ||
(_Event_Sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED)) ) {
20074ec: c8 01 20 20 ld [ %g4 + 0x20 ], %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) ||
20074f0: 80 a1 20 01 cmp %g4, 1
20074f4: 32 80 00 10 bne,a 2007534 <_Event_Surrender+0xac>
20074f8: 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) ) {
20074fc: 80 a0 40 03 cmp %g1, %g3
2007500: 02 80 00 04 be 2007510 <_Event_Surrender+0x88>
2007504: 80 8e e0 02 btst 2, %i3
2007508: 02 80 00 2b be 20075b4 <_Event_Surrender+0x12c> <== NEVER TAKEN
200750c: 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) );
2007510: 84 28 80 01 andn %g2, %g1, %g2
api->pending_events = _Event_sets_Clear( pending_events,seized_events );
2007514: c4 27 00 00 st %g2, [ %i4 ]
the_thread->Wait.count = 0;
*(rtems_event_set *)the_thread->Wait.return_argument = seized_events;
2007518: 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;
200751c: c0 27 60 24 clr [ %i5 + 0x24 ]
*(rtems_event_set *)the_thread->Wait.return_argument = seized_events;
2007520: c2 20 80 00 st %g1, [ %g2 ]
_Event_Sync_state = THREAD_BLOCKING_OPERATION_SATISFIED;
2007524: 84 10 20 03 mov 3, %g2
2007528: 03 00 80 79 sethi %hi(0x201e400), %g1
200752c: c4 20 60 20 st %g2, [ %g1 + 0x20 ] ! 201e420 <_Event_Sync_state>
2007530: 30 80 00 21 b,a 20075b4 <_Event_Surrender+0x12c>
}
/*
* Otherwise, this is a normal send to another thread
*/
if ( _States_Is_waiting_for_event( the_thread->current_state ) ) {
2007534: 80 89 21 00 btst 0x100, %g4
2007538: 02 80 00 1f be 20075b4 <_Event_Surrender+0x12c>
200753c: 80 a0 40 03 cmp %g1, %g3
if ( seized_events == event_condition || _Options_Is_any( option_set ) ) {
2007540: 02 80 00 04 be 2007550 <_Event_Surrender+0xc8>
2007544: 80 8e e0 02 btst 2, %i3
2007548: 02 80 00 1b be 20075b4 <_Event_Surrender+0x12c> <== NEVER TAKEN
200754c: 01 00 00 00 nop
2007550: 84 28 80 01 andn %g2, %g1, %g2
api->pending_events = _Event_sets_Clear( pending_events, seized_events );
2007554: c4 27 00 00 st %g2, [ %i4 ]
the_thread->Wait.count = 0;
*(rtems_event_set *)the_thread->Wait.return_argument = seized_events;
2007558: 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;
200755c: c0 27 60 24 clr [ %i5 + 0x24 ]
*(rtems_event_set *)the_thread->Wait.return_argument = seized_events;
2007560: c2 20 80 00 st %g1, [ %g2 ]
_ISR_Flash( level );
2007564: 7f ff ec 5c call 20026d4 <sparc_enable_interrupts>
2007568: 90 10 00 18 mov %i0, %o0
200756c: 7f ff ec 56 call 20026c4 <sparc_disable_interrupts>
2007570: 01 00 00 00 nop
if ( !_Watchdog_Is_active( &the_thread->Timer ) ) {
2007574: c2 07 60 50 ld [ %i5 + 0x50 ], %g1
2007578: 80 a0 60 02 cmp %g1, 2
200757c: 02 80 00 06 be 2007594 <_Event_Surrender+0x10c>
2007580: 82 10 20 03 mov 3, %g1
_ISR_Enable( level );
2007584: 7f ff ec 54 call 20026d4 <sparc_enable_interrupts>
2007588: 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 );
200758c: 10 80 00 08 b 20075ac <_Event_Surrender+0x124>
2007590: 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;
2007594: c2 27 60 50 st %g1, [ %i5 + 0x50 ]
_Thread_Unblock( the_thread );
} else {
_Watchdog_Deactivate( &the_thread->Timer );
_ISR_Enable( level );
2007598: 7f ff ec 4f call 20026d4 <sparc_enable_interrupts>
200759c: 33 04 00 ff sethi %hi(0x1003fc00), %i1
(void) _Watchdog_Remove( &the_thread->Timer );
20075a0: 40 00 0e ae call 200b058 <_Watchdog_Remove>
20075a4: 90 07 60 48 add %i5, 0x48, %o0
20075a8: b2 16 63 f8 or %i1, 0x3f8, %i1
20075ac: 40 00 0a 28 call 2009e4c <_Thread_Clear_state>
20075b0: 91 e8 00 1d restore %g0, %i5, %o0
_Thread_Unblock( the_thread );
}
return;
}
}
_ISR_Enable( level );
20075b4: 7f ff ec 48 call 20026d4 <sparc_enable_interrupts>
20075b8: 81 e8 00 00 restore
020075bc <_Event_Timeout>:
void _Event_Timeout(
Objects_Id id,
void *ignored
)
{
20075bc: 9d e3 bf 98 save %sp, -104, %sp
Thread_Control *the_thread;
Objects_Locations location;
ISR_Level level;
the_thread = _Thread_Get( id, &location );
20075c0: 90 10 00 18 mov %i0, %o0
20075c4: 40 00 0b 0f call 200a200 <_Thread_Get>
20075c8: 92 07 bf fc add %fp, -4, %o1
switch ( location ) {
20075cc: c2 07 bf fc ld [ %fp + -4 ], %g1
20075d0: 80 a0 60 00 cmp %g1, 0
20075d4: 12 80 00 1d bne 2007648 <_Event_Timeout+0x8c> <== NEVER TAKEN
20075d8: 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 );
20075dc: 7f ff ec 3a call 20026c4 <sparc_disable_interrupts>
20075e0: 01 00 00 00 nop
RTEMS_INLINE_ROUTINE bool _Thread_Is_executing (
const Thread_Control *the_thread
)
{
return ( the_thread == _Thread_Executing );
20075e4: 03 00 80 78 sethi %hi(0x201e000), %g1
return;
}
#endif
the_thread->Wait.count = 0;
if ( _Thread_Is_executing( the_thread ) ) {
20075e8: c2 00 60 2c ld [ %g1 + 0x2c ], %g1 ! 201e02c <_Per_CPU_Information+0xc>
20075ec: 80 a7 40 01 cmp %i5, %g1
20075f0: 12 80 00 09 bne 2007614 <_Event_Timeout+0x58>
20075f4: c0 27 60 24 clr [ %i5 + 0x24 ]
if ( _Event_Sync_state == THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED )
20075f8: 03 00 80 79 sethi %hi(0x201e400), %g1
20075fc: c4 00 60 20 ld [ %g1 + 0x20 ], %g2 ! 201e420 <_Event_Sync_state>
2007600: 80 a0 a0 01 cmp %g2, 1
2007604: 32 80 00 05 bne,a 2007618 <_Event_Timeout+0x5c>
2007608: 82 10 20 06 mov 6, %g1
_Event_Sync_state = THREAD_BLOCKING_OPERATION_TIMEOUT;
200760c: 84 10 20 02 mov 2, %g2
2007610: c4 20 60 20 st %g2, [ %g1 + 0x20 ]
}
the_thread->Wait.return_code = RTEMS_TIMEOUT;
2007614: 82 10 20 06 mov 6, %g1
2007618: c2 27 60 34 st %g1, [ %i5 + 0x34 ]
_ISR_Enable( level );
200761c: 7f ff ec 2e call 20026d4 <sparc_enable_interrupts>
2007620: 01 00 00 00 nop
RTEMS_INLINE_ROUTINE void _Thread_Unblock (
Thread_Control *the_thread
)
{
_Thread_Clear_state( the_thread, STATES_BLOCKED );
2007624: 90 10 00 1d mov %i5, %o0
2007628: 13 04 00 ff sethi %hi(0x1003fc00), %o1
200762c: 40 00 0a 08 call 2009e4c <_Thread_Clear_state>
2007630: 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--;
2007634: 03 00 80 76 sethi %hi(0x201d800), %g1
2007638: c4 00 62 f0 ld [ %g1 + 0x2f0 ], %g2 ! 201daf0 <_Thread_Dispatch_disable_level>
200763c: 84 00 bf ff add %g2, -1, %g2
2007640: c4 20 62 f0 st %g2, [ %g1 + 0x2f0 ]
return _Thread_Dispatch_disable_level;
2007644: c2 00 62 f0 ld [ %g1 + 0x2f0 ], %g1
2007648: 81 c7 e0 08 ret
200764c: 81 e8 00 00 restore
0200d758 <_Heap_Extend>:
Heap_Control *heap,
void *extend_area_begin_ptr,
uintptr_t extend_area_size,
uintptr_t *extended_size_ptr
)
{
200d758: 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;
200d75c: c0 27 bf f8 clr [ %fp + -8 ]
Heap_Block *extend_last_block = NULL;
200d760: 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;
200d764: 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;
200d768: 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;
200d76c: ec 06 20 10 ld [ %i0 + 0x10 ], %l6
uintptr_t const min_block_size = heap->min_block_size;
200d770: 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 ) {
200d774: 80 a7 40 19 cmp %i5, %i1
200d778: 1a 80 00 04 bcc 200d788 <_Heap_Extend+0x30>
200d77c: e6 06 20 30 ld [ %i0 + 0x30 ], %l3
return false;
200d780: 10 80 00 a2 b 200da08 <_Heap_Extend+0x2b0>
200d784: b0 10 20 00 clr %i0
}
extend_area_ok = _Heap_Get_first_and_last_block(
200d788: 90 10 00 19 mov %i1, %o0
200d78c: 92 10 00 1a mov %i2, %o1
200d790: 94 10 00 16 mov %l6, %o2
200d794: 98 07 bf f8 add %fp, -8, %o4
200d798: 7f ff ec 9e call 2008a10 <_Heap_Get_first_and_last_block>
200d79c: 9a 07 bf fc add %fp, -4, %o5
page_size,
min_block_size,
&extend_first_block,
&extend_last_block
);
if (!extend_area_ok ) {
200d7a0: 80 8a 20 ff btst 0xff, %o0
200d7a4: 02 bf ff f7 be 200d780 <_Heap_Extend+0x28>
200d7a8: a4 10 20 00 clr %l2
200d7ac: b4 10 00 15 mov %l5, %i2
200d7b0: a8 10 20 00 clr %l4
200d7b4: b8 10 20 00 clr %i4
200d7b8: a2 10 20 00 clr %l1
200d7bc: 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;
200d7c0: e0 06 80 00 ld [ %i2 ], %l0
200d7c4: 92 10 00 16 mov %l6, %o1
200d7c8: 82 04 3f f8 add %l0, -8, %g1
200d7cc: 90 10 00 10 mov %l0, %o0
200d7d0: 40 00 2d 82 call 2018dd8 <.urem>
200d7d4: 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);
200d7d8: c2 07 bf f4 ld [ %fp + -12 ], %g1
Heap_Block *const end_block =
_Heap_Block_of_alloc_area( sub_area_end, page_size );
if (
200d7dc: 80 a5 c0 1d cmp %l7, %i5
200d7e0: 1a 80 00 05 bcc 200d7f4 <_Heap_Extend+0x9c>
200d7e4: 90 20 40 08 sub %g1, %o0, %o0
200d7e8: 80 a6 40 10 cmp %i1, %l0
200d7ec: 2a 80 00 87 bcs,a 200da08 <_Heap_Extend+0x2b0>
200d7f0: 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 ) {
200d7f4: 80 a7 40 17 cmp %i5, %l7
200d7f8: 02 80 00 06 be 200d810 <_Heap_Extend+0xb8>
200d7fc: 80 a7 40 10 cmp %i5, %l0
merge_below_block = start_block;
} else if ( extend_area_end < sub_area_end ) {
200d800: 2a 80 00 05 bcs,a 200d814 <_Heap_Extend+0xbc>
200d804: a8 10 00 1a mov %i2, %l4
link_below_block = start_block;
}
if ( sub_area_end == extend_area_begin ) {
200d808: 10 80 00 04 b 200d818 <_Heap_Extend+0xc0>
200d80c: 80 a4 00 19 cmp %l0, %i1
200d810: a2 10 00 1a mov %i2, %l1
200d814: 80 a4 00 19 cmp %l0, %i1
200d818: 12 80 00 05 bne 200d82c <_Heap_Extend+0xd4>
200d81c: 80 a4 00 19 cmp %l0, %i1
start_block->prev_size = extend_area_end;
200d820: 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 )
200d824: 10 80 00 04 b 200d834 <_Heap_Extend+0xdc>
200d828: b8 10 00 08 mov %o0, %i4
merge_above_block = end_block;
} else if ( sub_area_end < extend_area_begin ) {
200d82c: 2a 80 00 02 bcs,a 200d834 <_Heap_Extend+0xdc>
200d830: 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;
200d834: f4 02 20 04 ld [ %o0 + 4 ], %i2
200d838: 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);
200d83c: 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 );
200d840: 80 a6 80 15 cmp %i2, %l5
200d844: 12 bf ff df bne 200d7c0 <_Heap_Extend+0x68>
200d848: ae 10 00 1a mov %i2, %l7
if ( extend_area_begin < heap->area_begin ) {
200d84c: c2 06 20 18 ld [ %i0 + 0x18 ], %g1
200d850: 80 a6 40 01 cmp %i1, %g1
200d854: 3a 80 00 04 bcc,a 200d864 <_Heap_Extend+0x10c>
200d858: c2 06 20 1c ld [ %i0 + 0x1c ], %g1
heap->area_begin = extend_area_begin;
200d85c: 10 80 00 05 b 200d870 <_Heap_Extend+0x118>
200d860: f2 26 20 18 st %i1, [ %i0 + 0x18 ]
} else if ( heap->area_end < extend_area_end ) {
200d864: 80 a0 40 1d cmp %g1, %i5
200d868: 2a 80 00 02 bcs,a 200d870 <_Heap_Extend+0x118>
200d86c: 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;
200d870: c4 07 bf f8 ld [ %fp + -8 ], %g2
200d874: c2 07 bf fc ld [ %fp + -4 ], %g1
extend_first_block->prev_size = extend_area_end;
200d878: 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 =
200d87c: 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;
200d880: 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;
200d884: 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 =
200d888: 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 ) {
200d88c: c6 06 20 20 ld [ %i0 + 0x20 ], %g3
200d890: 80 a0 c0 02 cmp %g3, %g2
200d894: 08 80 00 04 bleu 200d8a4 <_Heap_Extend+0x14c>
200d898: c0 20 60 04 clr [ %g1 + 4 ]
heap->first_block = extend_first_block;
200d89c: 10 80 00 06 b 200d8b4 <_Heap_Extend+0x15c>
200d8a0: c4 26 20 20 st %g2, [ %i0 + 0x20 ]
} else if ( (uintptr_t) extend_last_block > (uintptr_t) heap->last_block ) {
200d8a4: c4 06 20 24 ld [ %i0 + 0x24 ], %g2
200d8a8: 80 a0 80 01 cmp %g2, %g1
200d8ac: 2a 80 00 02 bcs,a 200d8b4 <_Heap_Extend+0x15c>
200d8b0: c2 26 20 24 st %g1, [ %i0 + 0x24 ]
heap->last_block = extend_last_block;
}
if ( merge_below_block != NULL ) {
200d8b4: 80 a4 60 00 cmp %l1, 0
200d8b8: 02 80 00 14 be 200d908 <_Heap_Extend+0x1b0>
200d8bc: 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;
200d8c0: 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;
200d8c4: 92 10 00 1a mov %i2, %o1
200d8c8: 40 00 2d 44 call 2018dd8 <.urem>
200d8cc: 90 10 00 19 mov %i1, %o0
if ( remainder != 0 ) {
200d8d0: 80 a2 20 00 cmp %o0, 0
200d8d4: 02 80 00 04 be 200d8e4 <_Heap_Extend+0x18c>
200d8d8: c2 04 40 00 ld [ %l1 ], %g1
return value - remainder + alignment;
200d8dc: b2 06 40 1a add %i1, %i2, %i1
200d8e0: 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 =
200d8e4: 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;
200d8e8: 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 =
200d8ec: 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;
200d8f0: 82 10 60 01 or %g1, 1, %g1
_Heap_Free_block( heap, new_first_block );
200d8f4: 90 10 00 18 mov %i0, %o0
200d8f8: 7f ff ff 8e call 200d730 <_Heap_Free_block>
200d8fc: c2 22 60 04 st %g1, [ %o1 + 4 ]
link_below_block,
extend_last_block
);
}
if ( merge_above_block != NULL ) {
200d900: 10 80 00 08 b 200d920 <_Heap_Extend+0x1c8>
200d904: 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 ) {
200d908: 80 a5 20 00 cmp %l4, 0
200d90c: 02 80 00 04 be 200d91c <_Heap_Extend+0x1c4>
200d910: 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;
200d914: 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 =
200d918: e8 20 60 04 st %l4, [ %g1 + 4 ]
link_below_block,
extend_last_block
);
}
if ( merge_above_block != NULL ) {
200d91c: 80 a7 20 00 cmp %i4, 0
200d920: 02 80 00 15 be 200d974 <_Heap_Extend+0x21c>
200d924: 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);
200d928: 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(
200d92c: ba 27 40 1c sub %i5, %i4, %i5
200d930: 40 00 2d 2a call 2018dd8 <.urem>
200d934: 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)
200d938: c4 07 20 04 ld [ %i4 + 4 ], %g2
200d93c: 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 =
200d940: 82 02 00 1c add %o0, %i4, %g1
(last_block->size_and_flag - last_block_new_size)
200d944: 84 20 80 08 sub %g2, %o0, %g2
| HEAP_PREV_BLOCK_USED;
200d948: 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 =
200d94c: 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;
200d950: 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 );
200d954: 92 10 00 1c mov %i4, %o1
200d958: 82 08 60 01 and %g1, 1, %g1
block->size_and_flag = size | flag;
200d95c: 90 12 00 01 or %o0, %g1, %o0
200d960: d0 27 20 04 st %o0, [ %i4 + 4 ]
200d964: 7f ff ff 73 call 200d730 <_Heap_Free_block>
200d968: 90 10 00 18 mov %i0, %o0
extend_first_block,
extend_last_block
);
}
if ( merge_below_block == NULL && merge_above_block == NULL ) {
200d96c: 10 80 00 0f b 200d9a8 <_Heap_Extend+0x250>
200d970: 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 ) {
200d974: 80 a4 a0 00 cmp %l2, 0
200d978: 02 80 00 0b be 200d9a4 <_Heap_Extend+0x24c>
200d97c: 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;
200d980: c4 04 a0 04 ld [ %l2 + 4 ], %g2
_Heap_Link_above(
200d984: 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 );
200d988: 86 20 c0 12 sub %g3, %l2, %g3
200d98c: 84 08 a0 01 and %g2, 1, %g2
block->size_and_flag = size | flag;
200d990: 84 10 c0 02 or %g3, %g2, %g2
200d994: c4 24 a0 04 st %g2, [ %l2 + 4 ]
last_block->size_and_flag |= HEAP_PREV_BLOCK_USED;
200d998: c4 00 60 04 ld [ %g1 + 4 ], %g2
200d99c: 84 10 a0 01 or %g2, 1, %g2
200d9a0: c4 20 60 04 st %g2, [ %g1 + 4 ]
extend_first_block,
extend_last_block
);
}
if ( merge_below_block == NULL && merge_above_block == NULL ) {
200d9a4: 80 a7 20 00 cmp %i4, 0
200d9a8: 32 80 00 09 bne,a 200d9cc <_Heap_Extend+0x274>
200d9ac: c2 06 20 24 ld [ %i0 + 0x24 ], %g1
200d9b0: 80 a4 60 00 cmp %l1, 0
200d9b4: 32 80 00 06 bne,a 200d9cc <_Heap_Extend+0x274>
200d9b8: c2 06 20 24 ld [ %i0 + 0x24 ], %g1
_Heap_Free_block( heap, extend_first_block );
200d9bc: d2 07 bf f8 ld [ %fp + -8 ], %o1
200d9c0: 7f ff ff 5c call 200d730 <_Heap_Free_block>
200d9c4: 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
200d9c8: 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(
200d9cc: 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;
200d9d0: 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(
200d9d4: 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;
200d9d8: 84 08 a0 01 and %g2, 1, %g2
block->size_and_flag = size | flag;
200d9dc: 84 10 c0 02 or %g3, %g2, %g2
200d9e0: c4 20 60 04 st %g2, [ %g1 + 4 ]
}
_Heap_Set_last_block_size( heap );
extended_size = stats->free_size - free_size;
200d9e4: c2 06 20 30 ld [ %i0 + 0x30 ], %g1
/* Statistics */
stats->size += extended_size;
if ( extended_size_ptr != NULL )
200d9e8: 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;
200d9ec: a6 20 40 13 sub %g1, %l3, %l3
/* Statistics */
stats->size += extended_size;
200d9f0: c2 06 20 2c ld [ %i0 + 0x2c ], %g1
200d9f4: 82 00 40 13 add %g1, %l3, %g1
if ( extended_size_ptr != NULL )
200d9f8: 02 80 00 03 be 200da04 <_Heap_Extend+0x2ac> <== NEVER TAKEN
200d9fc: c2 26 20 2c st %g1, [ %i0 + 0x2c ]
*extended_size_ptr = extended_size;
200da00: e6 26 c0 00 st %l3, [ %i3 ]
return true;
200da04: b0 10 20 01 mov 1, %i0
}
200da08: b0 0e 20 01 and %i0, 1, %i0
200da0c: 81 c7 e0 08 ret
200da10: 81 e8 00 00 restore
0200d784 <_Heap_Free>:
return do_free;
}
#endif
bool _Heap_Free( Heap_Control *heap, void *alloc_begin_ptr )
{
200d784: 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 ) {
200d788: 80 a6 60 00 cmp %i1, 0
200d78c: 02 80 00 7a be 200d974 <_Heap_Free+0x1f0>
200d790: 88 10 20 01 mov 1, %g4
200d794: d2 06 20 10 ld [ %i0 + 0x10 ], %o1
200d798: 40 00 2c ec call 2018b48 <.urem>
200d79c: 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
200d7a0: 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);
200d7a4: 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);
200d7a8: 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;
200d7ac: 80 a2 00 1b cmp %o0, %i3
200d7b0: 0a 80 00 05 bcs 200d7c4 <_Heap_Free+0x40>
200d7b4: 82 10 20 00 clr %g1
200d7b8: c2 06 20 24 ld [ %i0 + 0x24 ], %g1
200d7bc: 80 a0 40 08 cmp %g1, %o0
200d7c0: 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 ) ) {
200d7c4: 80 a0 60 00 cmp %g1, 0
200d7c8: 02 80 00 6b be 200d974 <_Heap_Free+0x1f0>
200d7cc: 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;
200d7d0: f8 02 20 04 ld [ %o0 + 4 ], %i4
200d7d4: 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);
200d7d8: 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;
200d7dc: 80 a0 40 1b cmp %g1, %i3
200d7e0: 0a 80 00 05 bcs 200d7f4 <_Heap_Free+0x70> <== NEVER TAKEN
200d7e4: 86 10 20 00 clr %g3
200d7e8: c6 06 20 24 ld [ %i0 + 0x24 ], %g3
200d7ec: 80 a0 c0 01 cmp %g3, %g1
200d7f0: 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 ) ) {
200d7f4: 80 a0 e0 00 cmp %g3, 0
200d7f8: 02 80 00 5f be 200d974 <_Heap_Free+0x1f0> <== NEVER TAKEN
200d7fc: 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;
200d800: fa 00 60 04 ld [ %g1 + 4 ], %i5
return false;
}
_Heap_Protection_block_check( heap, next_block );
if ( !_Heap_Is_prev_used( next_block ) ) {
200d804: 80 8f 60 01 btst 1, %i5
200d808: 22 80 00 5c be,a 200d978 <_Heap_Free+0x1f4> <== NEVER TAKEN
200d80c: 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
200d810: c8 06 20 24 ld [ %i0 + 0x24 ], %g4
&& !_Heap_Is_prev_used( _Heap_Block_at( next_block, next_block_size ));
200d814: 80 a0 40 04 cmp %g1, %g4
200d818: 02 80 00 07 be 200d834 <_Heap_Free+0xb0>
200d81c: ba 0f 7f fe and %i5, -2, %i5
200d820: 86 00 40 1d add %g1, %i5, %g3
200d824: f4 00 e0 04 ld [ %g3 + 4 ], %i2
200d828: b4 1e a0 01 xor %i2, 1, %i2
200d82c: 10 80 00 03 b 200d838 <_Heap_Free+0xb4>
200d830: b4 0e a0 01 and %i2, 1, %i2
200d834: b4 10 20 00 clr %i2
if ( !_Heap_Is_prev_used( block ) ) {
200d838: 80 8f 20 01 btst 1, %i4
200d83c: 12 80 00 26 bne 200d8d4 <_Heap_Free+0x150>
200d840: 80 8e a0 ff btst 0xff, %i2
uintptr_t const prev_size = block->prev_size;
200d844: 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);
200d848: 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;
200d84c: 80 a0 c0 1b cmp %g3, %i3
200d850: 0a 80 00 04 bcs 200d860 <_Heap_Free+0xdc> <== NEVER TAKEN
200d854: b2 10 20 00 clr %i1
200d858: 80 a1 00 03 cmp %g4, %g3
200d85c: 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 ) ) {
200d860: 80 a6 60 00 cmp %i1, 0
200d864: 02 80 00 44 be 200d974 <_Heap_Free+0x1f0> <== NEVER TAKEN
200d868: 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;
200d86c: 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) ) {
200d870: 80 8e e0 01 btst 1, %i3
200d874: 02 80 00 40 be 200d974 <_Heap_Free+0x1f0> <== NEVER TAKEN
200d878: 80 8e a0 ff btst 0xff, %i2
_HAssert( false );
return( false );
}
if ( next_is_free ) { /* coalesce both */
200d87c: 22 80 00 0f be,a 200d8b8 <_Heap_Free+0x134>
200d880: 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;
200d884: c8 00 60 08 ld [ %g1 + 8 ], %g4
Heap_Block *prev = block->prev;
200d888: c2 00 60 0c ld [ %g1 + 0xc ], %g1
uintptr_t const size = block_size + prev_size + next_block_size;
200d88c: ba 00 80 1d add %g2, %i5, %i5
prev->next = next;
200d890: c8 20 60 08 st %g4, [ %g1 + 8 ]
next->prev = prev;
200d894: c2 21 20 0c st %g1, [ %g4 + 0xc ]
_Heap_Free_list_remove( next_block );
stats->free_blocks -= 1;
200d898: 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;
200d89c: b8 07 40 1c add %i5, %i4, %i4
_Heap_Free_list_remove( next_block );
stats->free_blocks -= 1;
200d8a0: 82 00 7f ff add %g1, -1, %g1
200d8a4: 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;
200d8a8: 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;
200d8ac: 82 17 20 01 or %i4, 1, %g1
200d8b0: 10 80 00 27 b 200d94c <_Heap_Free+0x1c8>
200d8b4: 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;
200d8b8: 88 17 20 01 or %i4, 1, %g4
200d8bc: c8 20 e0 04 st %g4, [ %g3 + 4 ]
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
200d8c0: c6 00 60 04 ld [ %g1 + 4 ], %g3
next_block->prev_size = size;
200d8c4: 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;
200d8c8: 86 08 ff fe and %g3, -2, %g3
200d8cc: 10 80 00 20 b 200d94c <_Heap_Free+0x1c8>
200d8d0: c6 20 60 04 st %g3, [ %g1 + 4 ]
next_block->prev_size = size;
}
} else if ( next_is_free ) { /* coalesce next */
200d8d4: 22 80 00 0d be,a 200d908 <_Heap_Free+0x184>
200d8d8: 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;
200d8dc: c8 00 60 08 ld [ %g1 + 8 ], %g4
Heap_Block *prev = old_block->prev;
200d8e0: c2 00 60 0c ld [ %g1 + 0xc ], %g1
new_block->next = next;
200d8e4: c8 22 20 08 st %g4, [ %o0 + 8 ]
new_block->prev = prev;
200d8e8: c2 22 20 0c st %g1, [ %o0 + 0xc ]
uintptr_t const size = block_size + next_block_size;
200d8ec: 86 07 40 02 add %i5, %g2, %g3
next->prev = new_block;
prev->next = new_block;
200d8f0: 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;
200d8f4: d0 21 20 0c st %o0, [ %g4 + 0xc ]
_Heap_Free_list_replace( next_block, block );
block->size_and_flag = size | HEAP_PREV_BLOCK_USED;
200d8f8: 82 10 e0 01 or %g3, 1, %g1
next_block = _Heap_Block_at( block, size );
next_block->prev_size = size;
200d8fc: 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;
200d900: 10 80 00 13 b 200d94c <_Heap_Free+0x1c8>
200d904: c2 22 20 04 st %g1, [ %o0 + 4 ]
)
{
Heap_Block *next = block_before->next;
new_block->next = next;
new_block->prev = block_before;
200d908: f0 22 20 0c st %i0, [ %o0 + 0xc ]
Heap_Block *new_block
)
{
Heap_Block *next = block_before->next;
new_block->next = next;
200d90c: c6 22 20 08 st %g3, [ %o0 + 8 ]
new_block->prev = block_before;
block_before->next = new_block;
next->prev = new_block;
200d910: 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;
200d914: 86 10 a0 01 or %g2, 1, %g3
200d918: c6 22 20 04 st %g3, [ %o0 + 4 ]
next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED;
200d91c: c6 00 60 04 ld [ %g1 + 4 ], %g3
next_block->prev_size = block_size;
200d920: 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;
200d924: 86 08 ff fe and %g3, -2, %g3
200d928: c6 20 60 04 st %g3, [ %g1 + 4 ]
next_block->prev_size = block_size;
/* Statistics */
++stats->free_blocks;
200d92c: c2 06 20 38 ld [ %i0 + 0x38 ], %g1
if ( stats->max_free_blocks < stats->free_blocks ) {
200d930: 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;
200d934: 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;
200d938: d0 26 20 08 st %o0, [ %i0 + 8 ]
if ( stats->max_free_blocks < stats->free_blocks ) {
200d93c: 80 a0 c0 01 cmp %g3, %g1
200d940: 1a 80 00 03 bcc 200d94c <_Heap_Free+0x1c8>
200d944: c2 26 20 38 st %g1, [ %i0 + 0x38 ]
stats->max_free_blocks = stats->free_blocks;
200d948: c2 26 20 3c st %g1, [ %i0 + 0x3c ]
}
}
/* Statistics */
--stats->used_blocks;
200d94c: c2 06 20 40 ld [ %i0 + 0x40 ], %g1
200d950: 82 00 7f ff add %g1, -1, %g1
200d954: c2 26 20 40 st %g1, [ %i0 + 0x40 ]
++stats->frees;
200d958: c2 06 20 50 ld [ %i0 + 0x50 ], %g1
200d95c: 82 00 60 01 inc %g1
200d960: c2 26 20 50 st %g1, [ %i0 + 0x50 ]
stats->free_size += block_size;
200d964: c2 06 20 30 ld [ %i0 + 0x30 ], %g1
200d968: 84 00 40 02 add %g1, %g2, %g2
200d96c: 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;
200d970: 88 10 20 01 mov 1, %g4
--stats->used_blocks;
++stats->frees;
stats->free_size += block_size;
return( true );
}
200d974: b0 09 20 01 and %g4, 1, %i0
200d978: 81 c7 e0 08 ret
200d97c: 81 e8 00 00 restore
0201214c <_Heap_Iterate>:
void _Heap_Iterate(
Heap_Control *heap,
Heap_Block_visitor visitor,
void *visitor_arg
)
{
201214c: 9d e3 bf a0 save %sp, -96, %sp
Heap_Block *current = heap->first_block;
Heap_Block *end = heap->last_block;
bool stop = false;
2012150: 90 10 20 00 clr %o0
Heap_Control *heap,
Heap_Block_visitor visitor,
void *visitor_arg
)
{
Heap_Block *current = heap->first_block;
2012154: c2 06 20 20 ld [ %i0 + 0x20 ], %g1
Heap_Block *end = heap->last_block;
bool stop = false;
while ( !stop && current != end ) {
2012158: 10 80 00 0a b 2012180 <_Heap_Iterate+0x34>
201215c: 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 );
2012160: 90 10 00 01 mov %g1, %o0
2012164: 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);
2012168: 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;
201216c: d4 07 60 04 ld [ %i5 + 4 ], %o2
2012170: 96 10 00 1a mov %i2, %o3
2012174: 9f c6 40 00 call %i1
2012178: 94 0a a0 01 and %o2, 1, %o2
201217c: 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 ) {
2012180: 80 a0 40 1c cmp %g1, %i4
2012184: 02 80 00 05 be 2012198 <_Heap_Iterate+0x4c>
2012188: 90 1a 20 01 xor %o0, 1, %o0
201218c: 80 8a 20 ff btst 0xff, %o0
2012190: 32 bf ff f4 bne,a 2012160 <_Heap_Iterate+0x14> <== ALWAYS TAKEN
2012194: d2 00 60 04 ld [ %g1 + 4 ], %o1
2012198: 81 c7 e0 08 ret
201219c: 81 e8 00 00 restore
0200daa8 <_Heap_Size_of_alloc_area>:
bool _Heap_Size_of_alloc_area(
Heap_Control *heap,
void *alloc_begin_ptr,
uintptr_t *alloc_size
)
{
200daa8: 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);
200daac: d2 06 20 10 ld [ %i0 + 0x10 ], %o1
200dab0: 40 00 2c 26 call 2018b48 <.urem>
200dab4: 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
200dab8: 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);
200dabc: 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);
200dac0: 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;
200dac4: 80 a2 00 04 cmp %o0, %g4
200dac8: 0a 80 00 05 bcs 200dadc <_Heap_Size_of_alloc_area+0x34>
200dacc: 82 10 20 00 clr %g1
200dad0: c2 06 20 24 ld [ %i0 + 0x24 ], %g1
200dad4: 80 a0 40 08 cmp %g1, %o0
200dad8: 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 ) ) {
200dadc: 80 a0 60 00 cmp %g1, 0
200dae0: 02 80 00 15 be 200db34 <_Heap_Size_of_alloc_area+0x8c>
200dae4: 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;
200dae8: c2 02 20 04 ld [ %o0 + 4 ], %g1
200daec: 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);
200daf0: 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;
200daf4: 80 a0 40 04 cmp %g1, %g4
200daf8: 0a 80 00 05 bcs 200db0c <_Heap_Size_of_alloc_area+0x64> <== NEVER TAKEN
200dafc: 84 10 20 00 clr %g2
200db00: c4 06 20 24 ld [ %i0 + 0x24 ], %g2
200db04: 80 a0 80 01 cmp %g2, %g1
200db08: 84 60 3f ff subx %g0, -1, %g2
}
block_size = _Heap_Block_size( block );
next_block = _Heap_Block_at( block, block_size );
if (
200db0c: 80 a0 a0 00 cmp %g2, 0
200db10: 02 80 00 09 be 200db34 <_Heap_Size_of_alloc_area+0x8c> <== NEVER TAKEN
200db14: 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;
200db18: c4 00 60 04 ld [ %g1 + 4 ], %g2
!_Heap_Is_block_in_heap( heap, next_block )
|| !_Heap_Is_prev_used( next_block )
200db1c: 80 88 a0 01 btst 1, %g2
200db20: 02 80 00 05 be 200db34 <_Heap_Size_of_alloc_area+0x8c> <== NEVER TAKEN
200db24: 82 20 40 19 sub %g1, %i1, %g1
return false;
}
*alloc_size = (uintptr_t) next_block + HEAP_ALLOC_BONUS - alloc_begin;
return true;
200db28: 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;
200db2c: 82 00 60 04 add %g1, 4, %g1
200db30: c2 26 80 00 st %g1, [ %i2 ]
return true;
}
200db34: b0 08 e0 01 and %g3, 1, %i0
200db38: 81 c7 e0 08 ret
200db3c: 81 e8 00 00 restore
020098d8 <_Heap_Walk>:
bool _Heap_Walk(
Heap_Control *heap,
int source,
bool dump
)
{
20098d8: 9d e3 bf 80 save %sp, -128, %sp
20098dc: ac 10 00 19 mov %i1, %l6
uintptr_t const page_size = heap->page_size;
20098e0: f8 06 20 10 ld [ %i0 + 0x10 ], %i4
uintptr_t const min_block_size = heap->min_block_size;
20098e4: f6 06 20 14 ld [ %i0 + 0x14 ], %i3
Heap_Block *const first_block = heap->first_block;
20098e8: 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;
20098ec: 80 a6 a0 00 cmp %i2, 0
20098f0: 02 80 00 05 be 2009904 <_Heap_Walk+0x2c>
20098f4: e0 06 20 24 ld [ %i0 + 0x24 ], %l0
20098f8: 3b 00 80 26 sethi %hi(0x2009800), %i5
20098fc: 10 80 00 04 b 200990c <_Heap_Walk+0x34>
2009900: ba 17 60 88 or %i5, 0x88, %i5 ! 2009888 <_Heap_Walk_print>
2009904: 3b 00 80 26 sethi %hi(0x2009800), %i5
2009908: ba 17 60 80 or %i5, 0x80, %i5 ! 2009880 <_Heap_Walk_print_nothing>
if ( !_System_state_Is_up( _System_state_Get() ) ) {
200990c: 05 00 80 80 sethi %hi(0x2020000), %g2
2009910: c4 00 a0 10 ld [ %g2 + 0x10 ], %g2 ! 2020010 <_System_state_Current>
2009914: 80 a0 a0 03 cmp %g2, 3
2009918: 22 80 00 04 be,a 2009928 <_Heap_Walk+0x50>
200991c: c4 06 20 1c ld [ %i0 + 0x1c ], %g2
return true;
2009920: 10 80 01 2a b 2009dc8 <_Heap_Walk+0x4f0>
2009924: 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)(
2009928: da 06 20 18 ld [ %i0 + 0x18 ], %o5
200992c: c4 23 a0 5c st %g2, [ %sp + 0x5c ]
2009930: f2 23 a0 60 st %i1, [ %sp + 0x60 ]
2009934: e0 23 a0 64 st %l0, [ %sp + 0x64 ]
2009938: c4 06 20 08 ld [ %i0 + 8 ], %g2
200993c: 90 10 00 16 mov %l6, %o0
2009940: c4 23 a0 68 st %g2, [ %sp + 0x68 ]
2009944: c4 06 20 0c ld [ %i0 + 0xc ], %g2
2009948: 92 10 20 00 clr %o1
200994c: c4 23 a0 6c st %g2, [ %sp + 0x6c ]
2009950: 15 00 80 72 sethi %hi(0x201c800), %o2
2009954: 96 10 00 1c mov %i4, %o3
2009958: 94 12 a0 f8 or %o2, 0xf8, %o2
200995c: 9f c7 40 00 call %i5
2009960: 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 ) {
2009964: 80 a7 20 00 cmp %i4, 0
2009968: 12 80 00 07 bne 2009984 <_Heap_Walk+0xac>
200996c: 80 8f 20 07 btst 7, %i4
(*printer)( source, true, "page size is zero\n" );
2009970: 15 00 80 72 sethi %hi(0x201c800), %o2
2009974: 90 10 00 16 mov %l6, %o0
2009978: 92 10 20 01 mov 1, %o1
200997c: 10 80 00 37 b 2009a58 <_Heap_Walk+0x180>
2009980: 94 12 a1 90 or %o2, 0x190, %o2
return false;
}
if ( !_Addresses_Is_aligned( (void *) page_size ) ) {
2009984: 22 80 00 08 be,a 20099a4 <_Heap_Walk+0xcc>
2009988: 90 10 00 1b mov %i3, %o0
(*printer)(
200998c: 15 00 80 72 sethi %hi(0x201c800), %o2
2009990: 90 10 00 16 mov %l6, %o0
2009994: 92 10 20 01 mov 1, %o1
2009998: 94 12 a1 a8 or %o2, 0x1a8, %o2
200999c: 10 80 01 12 b 2009de4 <_Heap_Walk+0x50c>
20099a0: 96 10 00 1c mov %i4, %o3
RTEMS_INLINE_ROUTINE bool _Heap_Is_aligned(
uintptr_t value,
uintptr_t alignment
)
{
return (value % alignment) == 0;
20099a4: 7f ff e0 78 call 2001b84 <.urem>
20099a8: 92 10 00 1c mov %i4, %o1
);
return false;
}
if ( !_Heap_Is_aligned( min_block_size, page_size ) ) {
20099ac: 80 a2 20 00 cmp %o0, 0
20099b0: 22 80 00 08 be,a 20099d0 <_Heap_Walk+0xf8>
20099b4: 90 06 60 08 add %i1, 8, %o0
(*printer)(
20099b8: 15 00 80 72 sethi %hi(0x201c800), %o2
20099bc: 90 10 00 16 mov %l6, %o0
20099c0: 92 10 20 01 mov 1, %o1
20099c4: 94 12 a1 c8 or %o2, 0x1c8, %o2
20099c8: 10 80 01 07 b 2009de4 <_Heap_Walk+0x50c>
20099cc: 96 10 00 1b mov %i3, %o3
20099d0: 7f ff e0 6d call 2001b84 <.urem>
20099d4: 92 10 00 1c mov %i4, %o1
);
return false;
}
if (
20099d8: 80 a2 20 00 cmp %o0, 0
20099dc: 22 80 00 07 be,a 20099f8 <_Heap_Walk+0x120>
20099e0: c4 06 60 04 ld [ %i1 + 4 ], %g2
!_Heap_Is_aligned( _Heap_Alloc_area_of_block( first_block ), page_size )
) {
(*printer)(
20099e4: 15 00 80 72 sethi %hi(0x201c800), %o2
20099e8: 90 10 00 16 mov %l6, %o0
20099ec: 92 10 20 01 mov 1, %o1
20099f0: 10 80 00 fc b 2009de0 <_Heap_Walk+0x508>
20099f4: 94 12 a1 f0 or %o2, 0x1f0, %o2
);
return false;
}
if ( !_Heap_Is_prev_used( first_block ) ) {
20099f8: 80 88 a0 01 btst 1, %g2
20099fc: 32 80 00 07 bne,a 2009a18 <_Heap_Walk+0x140>
2009a00: f4 04 20 04 ld [ %l0 + 4 ], %i2
(*printer)(
2009a04: 15 00 80 72 sethi %hi(0x201c800), %o2
2009a08: 90 10 00 16 mov %l6, %o0
2009a0c: 92 10 20 01 mov 1, %o1
2009a10: 10 80 00 12 b 2009a58 <_Heap_Walk+0x180>
2009a14: 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;
2009a18: 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);
2009a1c: 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;
2009a20: c4 06 a0 04 ld [ %i2 + 4 ], %g2
);
return false;
}
if ( _Heap_Is_free( last_block ) ) {
2009a24: 80 88 a0 01 btst 1, %g2
2009a28: 12 80 00 07 bne 2009a44 <_Heap_Walk+0x16c>
2009a2c: 80 a6 80 19 cmp %i2, %i1
(*printer)(
2009a30: 15 00 80 72 sethi %hi(0x201c800), %o2
2009a34: 90 10 00 16 mov %l6, %o0
2009a38: 92 10 20 01 mov 1, %o1
2009a3c: 10 80 00 07 b 2009a58 <_Heap_Walk+0x180>
2009a40: 94 12 a2 58 or %o2, 0x258, %o2
);
return false;
}
if (
2009a44: 02 80 00 0a be 2009a6c <_Heap_Walk+0x194>
2009a48: 15 00 80 72 sethi %hi(0x201c800), %o2
_Heap_Block_at( last_block, _Heap_Block_size( last_block ) ) != first_block
) {
(*printer)(
2009a4c: 90 10 00 16 mov %l6, %o0
2009a50: 92 10 20 01 mov 1, %o1
2009a54: 94 12 a2 70 or %o2, 0x270, %o2
2009a58: 9f c7 40 00 call %i5
2009a5c: b0 10 20 00 clr %i0
2009a60: b0 0e 20 ff and %i0, 0xff, %i0
2009a64: 81 c7 e0 08 ret
2009a68: 81 e8 00 00 restore
int source,
Heap_Walk_printer printer,
Heap_Control *heap
)
{
uintptr_t const page_size = heap->page_size;
2009a6c: 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;
2009a70: d6 06 20 08 ld [ %i0 + 8 ], %o3
const Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap );
2009a74: 10 80 00 30 b 2009b34 <_Heap_Walk+0x25c>
2009a78: 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;
2009a7c: 80 a0 c0 0b cmp %g3, %o3
2009a80: 18 80 00 05 bgu 2009a94 <_Heap_Walk+0x1bc>
2009a84: 84 10 20 00 clr %g2
2009a88: c4 06 20 24 ld [ %i0 + 0x24 ], %g2
2009a8c: 80 a0 80 0b cmp %g2, %o3
2009a90: 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 ) ) {
2009a94: 80 a0 a0 00 cmp %g2, 0
2009a98: 32 80 00 07 bne,a 2009ab4 <_Heap_Walk+0x1dc>
2009a9c: 90 02 e0 08 add %o3, 8, %o0
(*printer)(
2009aa0: 15 00 80 72 sethi %hi(0x201c800), %o2
2009aa4: 90 10 00 16 mov %l6, %o0
2009aa8: 92 10 20 01 mov 1, %o1
2009aac: 10 80 00 ce b 2009de4 <_Heap_Walk+0x50c>
2009ab0: 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;
2009ab4: d6 27 bf fc st %o3, [ %fp + -4 ]
2009ab8: 7f ff e0 33 call 2001b84 <.urem>
2009abc: 92 10 00 11 mov %l1, %o1
);
return false;
}
if (
2009ac0: 80 a2 20 00 cmp %o0, 0
2009ac4: 02 80 00 07 be 2009ae0 <_Heap_Walk+0x208>
2009ac8: d6 07 bf fc ld [ %fp + -4 ], %o3
!_Heap_Is_aligned( _Heap_Alloc_area_of_block( free_block ), page_size )
) {
(*printer)(
2009acc: 15 00 80 72 sethi %hi(0x201c800), %o2
2009ad0: 90 10 00 16 mov %l6, %o0
2009ad4: 92 10 20 01 mov 1, %o1
2009ad8: 10 80 00 c3 b 2009de4 <_Heap_Walk+0x50c>
2009adc: 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;
2009ae0: c4 02 e0 04 ld [ %o3 + 4 ], %g2
2009ae4: 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;
2009ae8: 84 02 c0 02 add %o3, %g2, %g2
2009aec: c4 00 a0 04 ld [ %g2 + 4 ], %g2
);
return false;
}
if ( _Heap_Is_used( free_block ) ) {
2009af0: 80 88 a0 01 btst 1, %g2
2009af4: 22 80 00 07 be,a 2009b10 <_Heap_Walk+0x238>
2009af8: d8 02 e0 0c ld [ %o3 + 0xc ], %o4
(*printer)(
2009afc: 15 00 80 72 sethi %hi(0x201c800), %o2
2009b00: 90 10 00 16 mov %l6, %o0
2009b04: 92 10 20 01 mov 1, %o1
2009b08: 10 80 00 b7 b 2009de4 <_Heap_Walk+0x50c>
2009b0c: 94 12 a2 f0 or %o2, 0x2f0, %o2
);
return false;
}
if ( free_block->prev != prev_block ) {
2009b10: 80 a3 00 19 cmp %o4, %i1
2009b14: 02 80 00 07 be 2009b30 <_Heap_Walk+0x258>
2009b18: b2 10 00 0b mov %o3, %i1
(*printer)(
2009b1c: 15 00 80 72 sethi %hi(0x201c800), %o2
2009b20: 90 10 00 16 mov %l6, %o0
2009b24: 92 10 20 01 mov 1, %o1
2009b28: 10 80 00 4d b 2009c5c <_Heap_Walk+0x384>
2009b2c: 94 12 a3 10 or %o2, 0x310, %o2
return false;
}
prev_block = free_block;
free_block = free_block->next;
2009b30: 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 ) {
2009b34: 80 a2 c0 18 cmp %o3, %i0
2009b38: 32 bf ff d1 bne,a 2009a7c <_Heap_Walk+0x1a4>
2009b3c: 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)(
2009b40: 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 ) {
2009b44: 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)(
2009b48: 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)" : "")
2009b4c: 23 00 80 73 sethi %hi(0x201cc00), %l1
2009b50: 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;
2009b54: 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;
2009b58: 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;
2009b5c: 9e 1e 40 10 xor %i1, %l0, %o7
2009b60: 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;
2009b64: a8 0c bf fe and %l2, -2, %l4
2009b68: 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);
2009b6c: 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;
2009b70: 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;
2009b74: 80 a3 00 13 cmp %o4, %l3
2009b78: 18 80 00 05 bgu 2009b8c <_Heap_Walk+0x2b4> <== NEVER TAKEN
2009b7c: 9e 10 20 00 clr %o7
2009b80: de 06 20 24 ld [ %i0 + 0x24 ], %o7
2009b84: 80 a3 c0 13 cmp %o7, %l3
2009b88: 9e 60 3f ff subx %g0, -1, %o7
if ( !_Heap_Is_block_in_heap( heap, next_block ) ) {
2009b8c: 80 a3 e0 00 cmp %o7, 0
2009b90: 32 80 00 07 bne,a 2009bac <_Heap_Walk+0x2d4>
2009b94: da 27 bf f8 st %o5, [ %fp + -8 ]
(*printer)(
2009b98: 15 00 80 72 sethi %hi(0x201c800), %o2
2009b9c: 90 10 00 16 mov %l6, %o0
2009ba0: 92 10 20 01 mov 1, %o1
2009ba4: 10 80 00 2c b 2009c54 <_Heap_Walk+0x37c>
2009ba8: 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;
2009bac: 90 10 00 14 mov %l4, %o0
2009bb0: 7f ff df f5 call 2001b84 <.urem>
2009bb4: 92 10 00 1c mov %i4, %o1
2009bb8: da 07 bf f8 ld [ %fp + -8 ], %o5
);
return false;
}
if ( !_Heap_Is_aligned( block_size, page_size ) && is_not_last_block ) {
2009bbc: 80 a2 20 00 cmp %o0, 0
2009bc0: 02 80 00 0c be 2009bf0 <_Heap_Walk+0x318>
2009bc4: 9e 0b 60 ff and %o5, 0xff, %o7
2009bc8: 80 a3 e0 00 cmp %o7, 0
2009bcc: 02 80 00 19 be 2009c30 <_Heap_Walk+0x358>
2009bd0: 80 a6 40 13 cmp %i1, %l3
(*printer)(
2009bd4: 15 00 80 72 sethi %hi(0x201c800), %o2
2009bd8: 90 10 00 16 mov %l6, %o0
2009bdc: 92 10 20 01 mov 1, %o1
2009be0: 94 12 a3 78 or %o2, 0x378, %o2
2009be4: 96 10 00 19 mov %i1, %o3
2009be8: 10 80 00 1d b 2009c5c <_Heap_Walk+0x384>
2009bec: 98 10 00 14 mov %l4, %o4
);
return false;
}
if ( block_size < min_block_size && is_not_last_block ) {
2009bf0: 80 a3 e0 00 cmp %o7, 0
2009bf4: 02 80 00 0f be 2009c30 <_Heap_Walk+0x358>
2009bf8: 80 a6 40 13 cmp %i1, %l3
2009bfc: 80 a5 00 1b cmp %l4, %i3
2009c00: 1a 80 00 0c bcc 2009c30 <_Heap_Walk+0x358>
2009c04: 80 a6 40 13 cmp %i1, %l3
(*printer)(
2009c08: 90 10 00 16 mov %l6, %o0
2009c0c: 92 10 20 01 mov 1, %o1
2009c10: 15 00 80 72 sethi %hi(0x201c800), %o2
2009c14: 96 10 00 19 mov %i1, %o3
2009c18: 94 12 a3 a8 or %o2, 0x3a8, %o2
2009c1c: 98 10 00 14 mov %l4, %o4
2009c20: 9f c7 40 00 call %i5
2009c24: 9a 10 00 1b mov %i3, %o5
"block 0x%08x: next block 0x%08x is not a successor\n",
block,
next_block
);
return false;
2009c28: 10 80 00 68 b 2009dc8 <_Heap_Walk+0x4f0>
2009c2c: b0 10 20 00 clr %i0
);
return false;
}
if ( next_block_begin <= block_begin && is_not_last_block ) {
2009c30: 2a 80 00 10 bcs,a 2009c70 <_Heap_Walk+0x398>
2009c34: de 04 e0 04 ld [ %l3 + 4 ], %o7
2009c38: 80 8b 60 ff btst 0xff, %o5
2009c3c: 22 80 00 0d be,a 2009c70 <_Heap_Walk+0x398>
2009c40: de 04 e0 04 ld [ %l3 + 4 ], %o7
(*printer)(
2009c44: 15 00 80 72 sethi %hi(0x201c800), %o2
2009c48: 90 10 00 16 mov %l6, %o0
2009c4c: 92 10 20 01 mov 1, %o1
2009c50: 94 12 a3 d8 or %o2, 0x3d8, %o2
2009c54: 96 10 00 19 mov %i1, %o3
2009c58: 98 10 00 13 mov %l3, %o4
2009c5c: 9f c7 40 00 call %i5
2009c60: b0 10 20 00 clr %i0
2009c64: b0 0e 20 ff and %i0, 0xff, %i0
2009c68: 81 c7 e0 08 ret
2009c6c: 81 e8 00 00 restore
);
return false;
}
if ( !_Heap_Is_prev_used( next_block ) ) {
2009c70: 80 8b e0 01 btst 1, %o7
2009c74: 12 80 00 3f bne 2009d70 <_Heap_Walk+0x498>
2009c78: 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 ?
2009c7c: 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)(
2009c80: d8 06 20 08 ld [ %i0 + 8 ], %o4
2009c84: 80 a3 40 0c cmp %o5, %o4
2009c88: 02 80 00 08 be 2009ca8 <_Heap_Walk+0x3d0>
2009c8c: 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)" : ""),
2009c90: 80 a3 40 18 cmp %o5, %i0
2009c94: 12 80 00 07 bne 2009cb0 <_Heap_Walk+0x3d8>
2009c98: 96 14 60 80 or %l1, 0x80, %o3
2009c9c: 17 00 80 72 sethi %hi(0x201c800), %o3
2009ca0: 10 80 00 04 b 2009cb0 <_Heap_Walk+0x3d8>
2009ca4: 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)(
2009ca8: 03 00 80 72 sethi %hi(0x201c800), %g1
2009cac: 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 ?
2009cb0: 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)(
2009cb4: 80 a3 00 0f cmp %o4, %o7
2009cb8: 02 80 00 06 be 2009cd0 <_Heap_Walk+0x3f8>
2009cbc: 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)" : "")
2009cc0: 12 80 00 06 bne 2009cd8 <_Heap_Walk+0x400>
2009cc4: 9e 14 60 80 or %l1, 0x80, %o7
2009cc8: 10 80 00 04 b 2009cd8 <_Heap_Walk+0x400>
2009ccc: 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)(
2009cd0: 03 00 80 72 sethi %hi(0x201c800), %g1
2009cd4: 9e 10 60 d8 or %g1, 0xd8, %o7 ! 201c8d8 <__log2table+0x140>
2009cd8: d6 23 a0 5c st %o3, [ %sp + 0x5c ]
2009cdc: d8 23 a0 60 st %o4, [ %sp + 0x60 ]
2009ce0: de 23 a0 64 st %o7, [ %sp + 0x64 ]
2009ce4: 90 10 00 16 mov %l6, %o0
2009ce8: 92 10 20 00 clr %o1
2009cec: 94 10 00 15 mov %l5, %o2
2009cf0: 96 10 00 19 mov %i1, %o3
2009cf4: 9f c7 40 00 call %i5
2009cf8: 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 ) {
2009cfc: da 04 c0 00 ld [ %l3 ], %o5
2009d00: 80 a5 00 0d cmp %l4, %o5
2009d04: 02 80 00 0c be 2009d34 <_Heap_Walk+0x45c>
2009d08: 80 a4 a0 00 cmp %l2, 0
(*printer)(
2009d0c: e6 23 a0 5c st %l3, [ %sp + 0x5c ]
2009d10: 90 10 00 16 mov %l6, %o0
2009d14: 92 10 20 01 mov 1, %o1
2009d18: 15 00 80 73 sethi %hi(0x201cc00), %o2
2009d1c: 96 10 00 19 mov %i1, %o3
2009d20: 94 12 a0 48 or %o2, 0x48, %o2
2009d24: 9f c7 40 00 call %i5
2009d28: 98 10 00 14 mov %l4, %o4
"block 0x%08x: next block 0x%08x is not a successor\n",
block,
next_block
);
return false;
2009d2c: 10 bf ff ce b 2009c64 <_Heap_Walk+0x38c>
2009d30: b0 10 20 00 clr %i0
);
return false;
}
if ( !prev_used ) {
2009d34: 32 80 00 0a bne,a 2009d5c <_Heap_Walk+0x484>
2009d38: c6 06 20 08 ld [ %i0 + 8 ], %g3
(*printer)(
2009d3c: 15 00 80 73 sethi %hi(0x201cc00), %o2
2009d40: 90 10 00 16 mov %l6, %o0
2009d44: 92 10 20 01 mov 1, %o1
2009d48: 10 80 00 26 b 2009de0 <_Heap_Walk+0x508>
2009d4c: 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 ) {
2009d50: 22 80 00 19 be,a 2009db4 <_Heap_Walk+0x4dc>
2009d54: b2 10 00 13 mov %l3, %i1
return true;
}
free_block = free_block->next;
2009d58: 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 ) {
2009d5c: 80 a0 c0 18 cmp %g3, %i0
2009d60: 12 bf ff fc bne 2009d50 <_Heap_Walk+0x478>
2009d64: 80 a0 c0 19 cmp %g3, %i1
return false;
}
if ( !_Heap_Walk_is_in_free_list( heap, block ) ) {
(*printer)(
2009d68: 10 80 00 1b b 2009dd4 <_Heap_Walk+0x4fc>
2009d6c: 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) {
2009d70: 80 a4 a0 00 cmp %l2, 0
2009d74: 02 80 00 09 be 2009d98 <_Heap_Walk+0x4c0>
2009d78: 92 10 20 00 clr %o1
(*printer)(
2009d7c: 15 00 80 73 sethi %hi(0x201cc00), %o2
2009d80: 96 10 00 19 mov %i1, %o3
2009d84: 94 12 a0 b8 or %o2, 0xb8, %o2
2009d88: 9f c7 40 00 call %i5
2009d8c: 98 10 00 14 mov %l4, %o4
2009d90: 10 80 00 09 b 2009db4 <_Heap_Walk+0x4dc>
2009d94: b2 10 00 13 mov %l3, %i1
"block 0x%08x: size %u\n",
block,
block_size
);
} else {
(*printer)(
2009d98: da 06 40 00 ld [ %i1 ], %o5
2009d9c: 15 00 80 73 sethi %hi(0x201cc00), %o2
2009da0: 96 10 00 19 mov %i1, %o3
2009da4: 94 12 a0 d0 or %o2, 0xd0, %o2
2009da8: 9f c7 40 00 call %i5
2009dac: 98 10 00 14 mov %l4, %o4
2009db0: b2 10 00 13 mov %l3, %i1
block->prev_size
);
}
block = next_block;
} while ( block != first_block );
2009db4: 80 a4 c0 1a cmp %l3, %i2
2009db8: 32 bf ff 68 bne,a 2009b58 <_Heap_Walk+0x280>
2009dbc: e4 06 60 04 ld [ %i1 + 4 ], %l2
2009dc0: 10 80 00 02 b 2009dc8 <_Heap_Walk+0x4f0>
2009dc4: b0 10 20 01 mov 1, %i0
2009dc8: b0 0e 20 ff and %i0, 0xff, %i0
2009dcc: 81 c7 e0 08 ret
2009dd0: 81 e8 00 00 restore
return false;
}
if ( !_Heap_Walk_is_in_free_list( heap, block ) ) {
(*printer)(
2009dd4: 90 10 00 16 mov %l6, %o0
2009dd8: 92 10 20 01 mov 1, %o1
2009ddc: 94 12 a0 f8 or %o2, 0xf8, %o2
2009de0: 96 10 00 19 mov %i1, %o3
2009de4: 9f c7 40 00 call %i5
2009de8: b0 10 20 00 clr %i0
2009dec: b0 0e 20 ff and %i0, 0xff, %i0
2009df0: 81 c7 e0 08 ret
2009df4: 81 e8 00 00 restore
02008d7c <_Objects_Allocate>:
*/
Objects_Control *_Objects_Allocate(
Objects_Information *information
)
{
2008d7c: 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 )
2008d80: c2 06 20 18 ld [ %i0 + 0x18 ], %g1
2008d84: 80 a0 60 00 cmp %g1, 0
2008d88: 12 80 00 04 bne 2008d98 <_Objects_Allocate+0x1c> <== ALWAYS TAKEN
2008d8c: ba 10 00 18 mov %i0, %i5
return NULL;
2008d90: 81 c7 e0 08 ret
2008d94: 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 );
2008d98: b8 06 20 20 add %i0, 0x20, %i4
2008d9c: 7f ff fd 83 call 20083a8 <_Chain_Get>
2008da0: 90 10 00 1c mov %i4, %o0
if ( information->auto_extend ) {
2008da4: c2 0f 60 12 ldub [ %i5 + 0x12 ], %g1
2008da8: 80 a0 60 00 cmp %g1, 0
2008dac: 02 80 00 1d be 2008e20 <_Objects_Allocate+0xa4>
2008db0: 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 ) {
2008db4: 80 a2 20 00 cmp %o0, 0
2008db8: 32 80 00 0a bne,a 2008de0 <_Objects_Allocate+0x64>
2008dbc: c4 07 60 08 ld [ %i5 + 8 ], %g2
_Objects_Extend_information( information );
2008dc0: 40 00 00 21 call 2008e44 <_Objects_Extend_information>
2008dc4: 90 10 00 1d mov %i5, %o0
the_object = (Objects_Control *) _Chain_Get( &information->Inactive );
2008dc8: 7f ff fd 78 call 20083a8 <_Chain_Get>
2008dcc: 90 10 00 1c mov %i4, %o0
}
if ( the_object ) {
2008dd0: b0 92 20 00 orcc %o0, 0, %i0
2008dd4: 02 bf ff ef be 2008d90 <_Objects_Allocate+0x14>
2008dd8: 01 00 00 00 nop
uint32_t block;
block = (uint32_t) _Objects_Get_index( the_object->id ) -
2008ddc: c4 07 60 08 ld [ %i5 + 8 ], %g2
2008de0: d0 06 20 08 ld [ %i0 + 8 ], %o0
_Objects_Get_index( information->minimum_id );
block /= information->allocation_size;
2008de4: d2 17 60 14 lduh [ %i5 + 0x14 ], %o1
}
if ( the_object ) {
uint32_t block;
block = (uint32_t) _Objects_Get_index( the_object->id ) -
2008de8: 03 00 00 3f sethi %hi(0xfc00), %g1
2008dec: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff <PROM_START+0xffff>
2008df0: 90 0a 00 01 and %o0, %g1, %o0
2008df4: 82 08 80 01 and %g2, %g1, %g1
_Objects_Get_index( information->minimum_id );
block /= information->allocation_size;
2008df8: 40 00 3e a8 call 2018898 <.udiv>
2008dfc: 90 22 00 01 sub %o0, %g1, %o0
information->inactive_per_block[ block ]--;
2008e00: c2 07 60 30 ld [ %i5 + 0x30 ], %g1
2008e04: 91 2a 20 02 sll %o0, 2, %o0
2008e08: c4 00 40 08 ld [ %g1 + %o0 ], %g2
2008e0c: 84 00 bf ff add %g2, -1, %g2
2008e10: c4 20 40 08 st %g2, [ %g1 + %o0 ]
information->inactive--;
2008e14: c2 17 60 2c lduh [ %i5 + 0x2c ], %g1
2008e18: 82 00 7f ff add %g1, -1, %g1
2008e1c: c2 37 60 2c sth %g1, [ %i5 + 0x2c ]
);
}
#endif
return the_object;
}
2008e20: 81 c7 e0 08 ret
2008e24: 81 e8 00 00 restore
0200918c <_Objects_Get_information>:
Objects_Information *_Objects_Get_information(
Objects_APIs the_api,
uint16_t the_class
)
{
200918c: 9d e3 bf a0 save %sp, -96, %sp
Objects_Information *info;
int the_class_api_maximum;
if ( !the_class )
2009190: 80 a6 60 00 cmp %i1, 0
2009194: 12 80 00 04 bne 20091a4 <_Objects_Get_information+0x18>
2009198: 01 00 00 00 nop
return NULL;
200919c: 81 c7 e0 08 ret
20091a0: 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 );
20091a4: 40 00 12 67 call 200db40 <_Objects_API_maximum_class>
20091a8: 90 10 00 18 mov %i0, %o0
if ( the_class_api_maximum == 0 )
20091ac: 80 a2 20 00 cmp %o0, 0
20091b0: 02 bf ff fb be 200919c <_Objects_Get_information+0x10>
20091b4: 80 a6 40 08 cmp %i1, %o0
return NULL;
if ( the_class > (uint32_t) the_class_api_maximum )
20091b8: 18 bf ff f9 bgu 200919c <_Objects_Get_information+0x10>
20091bc: 03 00 80 76 sethi %hi(0x201d800), %g1
return NULL;
if ( !_Objects_Information_table[ the_api ] )
20091c0: b1 2e 20 02 sll %i0, 2, %i0
20091c4: 82 10 62 54 or %g1, 0x254, %g1
20091c8: c2 00 40 18 ld [ %g1 + %i0 ], %g1
20091cc: 80 a0 60 00 cmp %g1, 0
20091d0: 02 bf ff f3 be 200919c <_Objects_Get_information+0x10> <== NEVER TAKEN
20091d4: b3 2e 60 02 sll %i1, 2, %i1
return NULL;
info = _Objects_Information_table[ the_api ][ the_class ];
20091d8: f0 00 40 19 ld [ %g1 + %i1 ], %i0
if ( !info )
20091dc: 80 a6 20 00 cmp %i0, 0
20091e0: 02 bf ff ef be 200919c <_Objects_Get_information+0x10> <== NEVER TAKEN
20091e4: 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 )
20091e8: c2 16 20 10 lduh [ %i0 + 0x10 ], %g1
20091ec: 80 a0 60 00 cmp %g1, 0
20091f0: 02 bf ff eb be 200919c <_Objects_Get_information+0x10>
20091f4: 01 00 00 00 nop
return NULL;
#endif
return info;
}
20091f8: 81 c7 e0 08 ret
20091fc: 81 e8 00 00 restore
0201b510 <_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;
201b510: c2 02 20 08 ld [ %o0 + 8 ], %g1
201b514: 92 22 40 01 sub %o1, %g1, %o1
if ( information->maximum >= index ) {
201b518: 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;
201b51c: 92 02 60 01 inc %o1
if ( information->maximum >= index ) {
201b520: 80 a0 40 09 cmp %g1, %o1
201b524: 0a 80 00 09 bcs 201b548 <_Objects_Get_no_protection+0x38>
201b528: 93 2a 60 02 sll %o1, 2, %o1
if ( (the_object = information->local_table[ index ]) != NULL ) {
201b52c: c2 02 20 1c ld [ %o0 + 0x1c ], %g1
201b530: d0 00 40 09 ld [ %g1 + %o1 ], %o0
201b534: 80 a2 20 00 cmp %o0, 0
201b538: 02 80 00 05 be 201b54c <_Objects_Get_no_protection+0x3c> <== NEVER TAKEN
201b53c: 82 10 20 01 mov 1, %g1
*location = OBJECTS_LOCAL;
return the_object;
201b540: 81 c3 e0 08 retl
201b544: 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;
201b548: 82 10 20 01 mov 1, %g1
return NULL;
201b54c: 90 10 20 00 clr %o0
}
201b550: 81 c3 e0 08 retl
201b554: c2 22 80 00 st %g1, [ %o2 ]
0200d290 <_Objects_Id_to_name>:
*/
Objects_Name_or_id_lookup_errors _Objects_Id_to_name (
Objects_Id id,
Objects_Name *name
)
{
200d290: 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;
200d294: 80 a6 20 00 cmp %i0, 0
200d298: 12 80 00 06 bne 200d2b0 <_Objects_Id_to_name+0x20>
200d29c: 83 36 20 18 srl %i0, 0x18, %g1
200d2a0: 03 00 80 b8 sethi %hi(0x202e000), %g1
200d2a4: c2 00 62 fc ld [ %g1 + 0x2fc ], %g1 ! 202e2fc <_Per_CPU_Information+0xc>
200d2a8: f0 00 60 08 ld [ %g1 + 8 ], %i0
200d2ac: 83 36 20 18 srl %i0, 0x18, %g1
200d2b0: 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 )
200d2b4: 84 00 7f ff add %g1, -1, %g2
200d2b8: 80 a0 a0 02 cmp %g2, 2
200d2bc: 08 80 00 18 bleu 200d31c <_Objects_Id_to_name+0x8c>
200d2c0: 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;
200d2c4: 81 c7 e0 08 ret
200d2c8: 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 ];
200d2cc: 85 28 a0 02 sll %g2, 2, %g2
200d2d0: d0 00 40 02 ld [ %g1 + %g2 ], %o0
if ( !information )
200d2d4: 80 a2 20 00 cmp %o0, 0
200d2d8: 02 bf ff fb be 200d2c4 <_Objects_Id_to_name+0x34> <== NEVER TAKEN
200d2dc: 01 00 00 00 nop
return OBJECTS_INVALID_ID;
#if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES)
if ( information->is_string )
200d2e0: c2 0a 20 38 ldub [ %o0 + 0x38 ], %g1
200d2e4: 80 a0 60 00 cmp %g1, 0
200d2e8: 12 bf ff f7 bne 200d2c4 <_Objects_Id_to_name+0x34> <== NEVER TAKEN
200d2ec: 92 10 00 18 mov %i0, %o1
return OBJECTS_INVALID_ID;
#endif
the_object = _Objects_Get( information, tmpId, &ignored_location );
200d2f0: 7f ff ff ca call 200d218 <_Objects_Get>
200d2f4: 94 07 bf fc add %fp, -4, %o2
if ( !the_object )
200d2f8: 80 a2 20 00 cmp %o0, 0
200d2fc: 02 bf ff f2 be 200d2c4 <_Objects_Id_to_name+0x34>
200d300: 01 00 00 00 nop
return OBJECTS_INVALID_ID;
*name = the_object->name;
200d304: c2 02 20 0c ld [ %o0 + 0xc ], %g1
_Thread_Enable_dispatch();
return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL;
200d308: 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();
200d30c: 40 00 03 c3 call 200e218 <_Thread_Enable_dispatch>
200d310: c2 26 40 00 st %g1, [ %i1 ]
200d314: 81 c7 e0 08 ret
200d318: 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 ] )
200d31c: 05 00 80 b7 sethi %hi(0x202dc00), %g2
200d320: 84 10 a0 e4 or %g2, 0xe4, %g2 ! 202dce4 <_Objects_Information_table>
200d324: c2 00 80 01 ld [ %g2 + %g1 ], %g1
200d328: 80 a0 60 00 cmp %g1, 0
200d32c: 12 bf ff e8 bne 200d2cc <_Objects_Id_to_name+0x3c>
200d330: 85 36 20 1b srl %i0, 0x1b, %g2
200d334: 30 bf ff e4 b,a 200d2c4 <_Objects_Id_to_name+0x34>
0200f0c4 <_POSIX_Keys_Run_destructors>:
*/
void _POSIX_Keys_Run_destructors(
Thread_Control *thread
)
{
200f0c4: 9d e3 bf a0 save %sp, -96, %sp
Objects_Maximum thread_index = _Objects_Get_index( thread->Object.id );
200f0c8: 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 ];
200f0cc: 39 00 00 3f sethi %hi(0xfc00), %i4
200f0d0: b5 30 60 18 srl %g1, 0x18, %i2
200f0d4: b8 17 23 ff or %i4, 0x3ff, %i4
200f0d8: b4 0e a0 07 and %i2, 7, %i2
200f0dc: b8 08 40 1c and %g1, %i4, %i4
200f0e0: b4 06 a0 04 add %i2, 4, %i2
200f0e4: 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;
200f0e8: 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 ];
200f0ec: 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;
200f0f0: 82 16 e2 f8 or %i3, 0x2f8, %g1
done = true;
for ( index = 1 ; index <= max ; ++index ) {
200f0f4: ba 10 20 01 mov 1, %i5
*/
while ( !done ) {
Objects_Maximum index = 0;
Objects_Maximum max = _POSIX_Keys_Information.maximum;
done = true;
200f0f8: 84 10 20 01 mov 1, %g2
for ( index = 1 ; index <= max ; ++index ) {
200f0fc: 10 80 00 18 b 200f15c <_POSIX_Keys_Run_destructors+0x98>
200f100: f2 10 60 10 lduh [ %g1 + 0x10 ], %i1
POSIX_Keys_Control *key = (POSIX_Keys_Control *)
_POSIX_Keys_Information.local_table [ index ];
200f104: 86 16 e2 f8 or %i3, 0x2f8, %g3
Objects_Maximum max = _POSIX_Keys_Information.maximum;
done = true;
for ( index = 1 ; index <= max ; ++index ) {
POSIX_Keys_Control *key = (POSIX_Keys_Control *)
200f108: c6 00 e0 1c ld [ %g3 + 0x1c ], %g3
200f10c: 83 28 60 02 sll %g1, 2, %g1
200f110: c2 00 c0 01 ld [ %g3 + %g1 ], %g1
_POSIX_Keys_Information.local_table [ index ];
if ( key != NULL && key->destructor != NULL ) {
200f114: 80 a0 60 00 cmp %g1, 0
200f118: 22 80 00 11 be,a 200f15c <_POSIX_Keys_Run_destructors+0x98>
200f11c: ba 07 60 01 inc %i5
200f120: c6 00 60 10 ld [ %g1 + 0x10 ], %g3
200f124: 80 a0 e0 00 cmp %g3, 0
200f128: 02 80 00 0c be 200f158 <_POSIX_Keys_Run_destructors+0x94>
200f12c: 86 00 40 1a add %g1, %i2, %g3
void *value = key->Values [ thread_api ][ thread_index ];
200f130: c6 00 e0 04 ld [ %g3 + 4 ], %g3
200f134: d0 00 c0 1c ld [ %g3 + %i4 ], %o0
if ( value != NULL ) {
200f138: 80 a2 20 00 cmp %o0, 0
200f13c: 22 80 00 08 be,a 200f15c <_POSIX_Keys_Run_destructors+0x98><== ALWAYS TAKEN
200f140: ba 07 60 01 inc %i5
key->Values [ thread_api ][ thread_index ] = NULL;
200f144: c0 20 c0 1c clr [ %g3 + %i4 ] <== NOT EXECUTED
(*key->destructor)( value );
200f148: c2 00 60 10 ld [ %g1 + 0x10 ], %g1 <== NOT EXECUTED
200f14c: 9f c0 40 00 call %g1 <== NOT EXECUTED
200f150: 01 00 00 00 nop <== NOT EXECUTED
done = false;
200f154: 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 ) {
200f158: ba 07 60 01 inc %i5
200f15c: 83 2f 60 10 sll %i5, 0x10, %g1
200f160: 83 30 60 10 srl %g1, 0x10, %g1
200f164: 80 a0 40 19 cmp %g1, %i1
200f168: 08 bf ff e7 bleu 200f104 <_POSIX_Keys_Run_destructors+0x40>
200f16c: 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 ) {
200f170: 02 bf ff e1 be 200f0f4 <_POSIX_Keys_Run_destructors+0x30> <== NEVER TAKEN
200f174: 82 16 e2 f8 or %i3, 0x2f8, %g1
done = false;
}
}
}
}
}
200f178: 81 c7 e0 08 ret
200f17c: 81 e8 00 00 restore
0200ca64 <_POSIX_Message_queue_Receive_support>:
size_t msg_len,
unsigned int *msg_prio,
bool wait,
Watchdog_Interval timeout
)
{
200ca64: 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(
200ca68: 11 00 80 ab sethi %hi(0x202ac00), %o0
200ca6c: 92 10 00 18 mov %i0, %o1
200ca70: 90 12 21 3c or %o0, 0x13c, %o0
200ca74: 40 00 0c bc call 200fd64 <_Objects_Get>
200ca78: 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 ) {
200ca7c: c2 07 bf f8 ld [ %fp + -8 ], %g1
200ca80: 80 a0 60 00 cmp %g1, 0
200ca84: 12 80 00 40 bne 200cb84 <_POSIX_Message_queue_Receive_support+0x120>
200ca88: 01 00 00 00 nop
case OBJECTS_LOCAL:
if ( (the_mq_fd->oflag & O_ACCMODE) == O_WRONLY ) {
200ca8c: c2 02 20 14 ld [ %o0 + 0x14 ], %g1
200ca90: 84 08 60 03 and %g1, 3, %g2
200ca94: 80 a0 a0 01 cmp %g2, 1
200ca98: 32 80 00 05 bne,a 200caac <_POSIX_Message_queue_Receive_support+0x48>
200ca9c: d0 02 20 10 ld [ %o0 + 0x10 ], %o0
_Thread_Enable_dispatch();
200caa0: 40 00 10 83 call 2010cac <_Thread_Enable_dispatch>
200caa4: 01 00 00 00 nop
200caa8: 30 80 00 37 b,a 200cb84 <_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 ) {
200caac: c4 02 20 68 ld [ %o0 + 0x68 ], %g2
200cab0: 80 a6 80 02 cmp %i2, %g2
200cab4: 1a 80 00 08 bcc 200cad4 <_POSIX_Message_queue_Receive_support+0x70>
200cab8: 84 10 3f ff mov -1, %g2
_Thread_Enable_dispatch();
200cabc: 40 00 10 7c call 2010cac <_Thread_Enable_dispatch>
200cac0: 01 00 00 00 nop
rtems_set_errno_and_return_minus_one( EMSGSIZE );
200cac4: 40 00 28 7f call 2016cc0 <__errno>
200cac8: 01 00 00 00 nop
200cacc: 10 80 00 31 b 200cb90 <_POSIX_Message_queue_Receive_support+0x12c>
200cad0: 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;
200cad4: c4 27 bf fc st %g2, [ %fp + -4 ]
/*
* A timed receive with a bad time will do a poll regardless.
*/
if ( wait )
200cad8: 80 a7 20 00 cmp %i4, 0
200cadc: 02 80 00 05 be 200caf0 <_POSIX_Message_queue_Receive_support+0x8c>
200cae0: 98 10 20 00 clr %o4
do_wait = (the_mq_fd->oflag & O_NONBLOCK) ? false : true;
200cae4: 99 30 60 0e srl %g1, 0xe, %o4
200cae8: 98 1b 20 01 xor %o4, 1, %o4
200caec: 98 0b 20 01 and %o4, 1, %o4
do_wait = wait;
/*
* Now perform the actual message receive
*/
_CORE_message_queue_Seize(
200caf0: 90 02 20 1c add %o0, 0x1c, %o0
200caf4: 92 10 00 18 mov %i0, %o1
200caf8: 94 10 00 19 mov %i1, %o2
200cafc: 96 07 bf fc add %fp, -4, %o3
200cb00: 98 0b 20 01 and %o4, 1, %o4
200cb04: 40 00 08 6d call 200ecb8 <_CORE_message_queue_Seize>
200cb08: 9a 10 00 1d mov %i5, %o5
&length_out,
do_wait,
timeout
);
_Thread_Enable_dispatch();
200cb0c: 40 00 10 68 call 2010cac <_Thread_Enable_dispatch>
200cb10: 01 00 00 00 nop
if (msg_prio) {
200cb14: 80 a6 e0 00 cmp %i3, 0
200cb18: 02 80 00 08 be 200cb38 <_POSIX_Message_queue_Receive_support+0xd4><== NEVER TAKEN
200cb1c: 03 00 80 ab sethi %hi(0x202ac00), %g1
*msg_prio = _POSIX_Message_queue_Priority_from_core(
_Thread_Executing->Wait.count
200cb20: 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);
200cb24: c4 00 60 24 ld [ %g1 + 0x24 ], %g2
200cb28: 83 38 a0 1f sra %g2, 0x1f, %g1
200cb2c: 84 18 40 02 xor %g1, %g2, %g2
200cb30: 82 20 80 01 sub %g2, %g1, %g1
timeout
);
_Thread_Enable_dispatch();
if (msg_prio) {
*msg_prio = _POSIX_Message_queue_Priority_from_core(
200cb34: c2 26 c0 00 st %g1, [ %i3 ]
_Thread_Executing->Wait.count
);
}
if ( !_Thread_Executing->Wait.return_code )
200cb38: 3b 00 80 ab sethi %hi(0x202ac00), %i5
200cb3c: ba 17 61 b0 or %i5, 0x1b0, %i5 ! 202adb0 <_Per_CPU_Information>
200cb40: c2 07 60 0c ld [ %i5 + 0xc ], %g1
200cb44: c2 00 60 34 ld [ %g1 + 0x34 ], %g1
200cb48: 80 a0 60 00 cmp %g1, 0
200cb4c: 12 80 00 05 bne 200cb60 <_POSIX_Message_queue_Receive_support+0xfc>
200cb50: 01 00 00 00 nop
return length_out;
200cb54: f0 07 bf fc ld [ %fp + -4 ], %i0
200cb58: 81 c7 e0 08 ret
200cb5c: 81 e8 00 00 restore
rtems_set_errno_and_return_minus_one(
200cb60: 40 00 28 58 call 2016cc0 <__errno>
200cb64: b0 10 3f ff mov -1, %i0
200cb68: c2 07 60 0c ld [ %i5 + 0xc ], %g1
200cb6c: b8 10 00 08 mov %o0, %i4
200cb70: 40 00 00 96 call 200cdc8 <_POSIX_Message_queue_Translate_core_message_queue_return_code>
200cb74: d0 00 60 34 ld [ %g1 + 0x34 ], %o0
200cb78: d0 27 00 00 st %o0, [ %i4 ]
200cb7c: 81 c7 e0 08 ret
200cb80: 81 e8 00 00 restore
#endif
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EBADF );
200cb84: 40 00 28 4f call 2016cc0 <__errno>
200cb88: 01 00 00 00 nop
200cb8c: 82 10 20 09 mov 9, %g1 ! 9 <PROM_START+0x9>
200cb90: c2 22 00 00 st %g1, [ %o0 ]
200cb94: b0 10 3f ff mov -1, %i0
}
200cb98: 81 c7 e0 08 ret
200cb9c: 81 e8 00 00 restore
0200ee20 <_POSIX_Semaphore_Create_support>:
size_t name_len,
int pshared,
unsigned int value,
POSIX_Semaphore_Control **the_sem
)
{
200ee20: 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)
200ee24: 80 a6 a0 00 cmp %i2, 0
200ee28: 22 80 00 06 be,a 200ee40 <_POSIX_Semaphore_Create_support+0x20>
200ee2c: 03 00 80 89 sethi %hi(0x2022400), %g1
rtems_set_errno_and_return_minus_one( ENOSYS );
200ee30: 40 00 0a d2 call 2011978 <__errno>
200ee34: 01 00 00 00 nop
200ee38: 10 80 00 11 b 200ee7c <_POSIX_Semaphore_Create_support+0x5c>
200ee3c: 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++;
200ee40: c4 00 61 f0 ld [ %g1 + 0x1f0 ], %g2
200ee44: 84 00 a0 01 inc %g2
200ee48: c4 20 61 f0 st %g2, [ %g1 + 0x1f0 ]
return _Thread_Dispatch_disable_level;
200ee4c: 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 *)
200ee50: 21 00 80 8a sethi %hi(0x2022800), %l0
200ee54: 7f ff ee ee call 200aa0c <_Objects_Allocate>
200ee58: 90 14 20 e0 or %l0, 0xe0, %o0 ! 20228e0 <_POSIX_Semaphore_Information>
_Thread_Disable_dispatch();
the_semaphore = _POSIX_Semaphore_Allocate();
if ( !the_semaphore ) {
200ee5c: ba 92 20 00 orcc %o0, 0, %i5
200ee60: 12 80 00 0a bne 200ee88 <_POSIX_Semaphore_Create_support+0x68>
200ee64: 80 a6 20 00 cmp %i0, 0
_Thread_Enable_dispatch();
200ee68: 7f ff f4 0c call 200be98 <_Thread_Enable_dispatch>
200ee6c: 01 00 00 00 nop
rtems_set_errno_and_return_minus_one( ENOSPC );
200ee70: 40 00 0a c2 call 2011978 <__errno>
200ee74: 01 00 00 00 nop
200ee78: 82 10 20 1c mov 0x1c, %g1 ! 1c <PROM_START+0x1c>
200ee7c: c2 22 00 00 st %g1, [ %o0 ]
200ee80: 81 c7 e0 08 ret
200ee84: 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 ) {
200ee88: 02 80 00 10 be 200eec8 <_POSIX_Semaphore_Create_support+0xa8>
200ee8c: 90 10 00 18 mov %i0, %o0
name = _Workspace_String_duplicate( name_arg, name_len );
200ee90: 40 00 04 78 call 2010070 <_Workspace_String_duplicate>
200ee94: 92 10 00 19 mov %i1, %o1
if ( !name ) {
200ee98: b4 92 20 00 orcc %o0, 0, %i2
200ee9c: 12 80 00 0d bne 200eed0 <_POSIX_Semaphore_Create_support+0xb0><== ALWAYS TAKEN
200eea0: 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 );
200eea4: 90 14 20 e0 or %l0, 0xe0, %o0 <== NOT EXECUTED
200eea8: 7f ff ef b0 call 200ad68 <_Objects_Free> <== NOT EXECUTED
200eeac: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
_POSIX_Semaphore_Free( the_semaphore );
_Thread_Enable_dispatch();
200eeb0: 7f ff f3 fa call 200be98 <_Thread_Enable_dispatch> <== NOT EXECUTED
200eeb4: 01 00 00 00 nop <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOMEM );
200eeb8: 40 00 0a b0 call 2011978 <__errno> <== NOT EXECUTED
200eebc: 01 00 00 00 nop <== NOT EXECUTED
200eec0: 10 bf ff ef b 200ee7c <_POSIX_Semaphore_Create_support+0x5c><== NOT EXECUTED
200eec4: 82 10 20 0c mov 0xc, %g1 ! c <PROM_START+0xc> <== NOT EXECUTED
}
} else {
name = NULL;
200eec8: b4 10 20 00 clr %i2
}
the_semaphore->process_shared = pshared;
if ( name ) {
200eecc: 80 a6 a0 00 cmp %i2, 0
200eed0: 02 80 00 08 be 200eef0 <_POSIX_Semaphore_Create_support+0xd0>
200eed4: c0 27 60 10 clr [ %i5 + 0x10 ]
the_semaphore->named = true;
200eed8: 82 10 20 01 mov 1, %g1
200eedc: c2 2f 60 14 stb %g1, [ %i5 + 0x14 ]
the_semaphore->open_count = 1;
200eee0: 82 10 20 01 mov 1, %g1
200eee4: c2 27 60 18 st %g1, [ %i5 + 0x18 ]
the_semaphore->linked = true;
200eee8: 10 80 00 05 b 200eefc <_POSIX_Semaphore_Create_support+0xdc>
200eeec: c2 2f 60 15 stb %g1, [ %i5 + 0x15 ]
} else {
the_semaphore->named = false;
200eef0: c0 2f 60 14 clrb [ %i5 + 0x14 ]
the_semaphore->open_count = 0;
200eef4: c0 27 60 18 clr [ %i5 + 0x18 ]
the_semaphore->linked = false;
200eef8: 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;
200eefc: 82 10 3f ff mov -1, %g1
_CORE_semaphore_Initialize( &the_semaphore->Semaphore, the_sem_attr, value );
200ef00: 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;
200ef04: c2 27 60 5c st %g1, [ %i5 + 0x5c ]
_CORE_semaphore_Initialize( &the_semaphore->Semaphore, the_sem_attr, value );
200ef08: 92 07 60 5c add %i5, 0x5c, %o1
200ef0c: 94 10 00 1b mov %i3, %o2
200ef10: 7f ff ed 33 call 200a3dc <_CORE_semaphore_Initialize>
200ef14: c0 27 60 60 clr [ %i5 + 0x60 ]
Objects_Information *information,
Objects_Control *the_object,
const char *name
)
{
_Objects_Set_local_object(
200ef18: c2 17 60 0a lduh [ %i5 + 0xa ], %g1
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
200ef1c: 05 00 80 8a sethi %hi(0x2022800), %g2
200ef20: c4 00 a0 fc ld [ %g2 + 0xfc ], %g2 ! 20228fc <_POSIX_Semaphore_Information+0x1c>
200ef24: 83 28 60 02 sll %g1, 2, %g1
200ef28: 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;
200ef2c: f4 27 60 0c st %i2, [ %i5 + 0xc ]
&_POSIX_Semaphore_Information,
&the_semaphore->Object,
name
);
*the_sem = the_semaphore;
200ef30: fa 27 00 00 st %i5, [ %i4 ]
_Thread_Enable_dispatch();
200ef34: 7f ff f3 d9 call 200be98 <_Thread_Enable_dispatch>
200ef38: b0 10 20 00 clr %i0
return 0;
}
200ef3c: 81 c7 e0 08 ret
200ef40: 81 e8 00 00 restore
0200c8d8 <_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 ];
200c8d8: c2 02 21 5c ld [ %o0 + 0x15c ], %g1
if ( thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE &&
200c8dc: c4 00 60 d8 ld [ %g1 + 0xd8 ], %g2
200c8e0: 80 a0 a0 00 cmp %g2, 0
200c8e4: 12 80 00 13 bne 200c930 <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch+0x58><== NEVER TAKEN
200c8e8: 01 00 00 00 nop
200c8ec: c4 00 60 dc ld [ %g1 + 0xdc ], %g2
200c8f0: 80 a0 a0 01 cmp %g2, 1
200c8f4: 12 80 00 0f bne 200c930 <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch+0x58>
200c8f8: 01 00 00 00 nop
thread_support->cancelability_type == PTHREAD_CANCEL_ASYNCHRONOUS &&
200c8fc: c2 00 60 e0 ld [ %g1 + 0xe0 ], %g1
200c900: 80 a0 60 00 cmp %g1, 0
200c904: 02 80 00 0b be 200c930 <_POSIX_Thread_Evaluate_cancellation_and_enable_dispatch+0x58>
200c908: 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--;
200c90c: 03 00 80 77 sethi %hi(0x201dc00), %g1
200c910: 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 );
200c914: 92 10 3f ff mov -1, %o1
200c918: 84 00 bf ff add %g2, -1, %g2
200c91c: c4 20 63 50 st %g2, [ %g1 + 0x350 ]
return _Thread_Dispatch_disable_level;
200c920: c2 00 63 50 ld [ %g1 + 0x350 ], %g1
200c924: 82 13 c0 00 mov %o7, %g1
200c928: 40 00 01 b5 call 200cffc <_POSIX_Thread_Exit>
200c92c: 9e 10 40 00 mov %g1, %o7
} else
_Thread_Enable_dispatch();
200c930: 82 13 c0 00 mov %o7, %g1
200c934: 7f ff f6 58 call 200a294 <_Thread_Enable_dispatch>
200c938: 9e 10 40 00 mov %g1, %o7
0200dc80 <_POSIX_Thread_Translate_sched_param>:
int policy,
struct sched_param *param,
Thread_CPU_budget_algorithms *budget_algorithm,
Thread_CPU_budget_algorithm_callout *budget_callout
)
{
200dc80: 9d e3 bf a0 save %sp, -96, %sp
if ( !_POSIX_Priority_Is_valid( param->sched_priority ) )
200dc84: 7f ff ff f4 call 200dc54 <_POSIX_Priority_Is_valid>
200dc88: d0 06 40 00 ld [ %i1 ], %o0
200dc8c: 80 8a 20 ff btst 0xff, %o0
200dc90: 32 80 00 04 bne,a 200dca0 <_POSIX_Thread_Translate_sched_param+0x20><== ALWAYS TAKEN
200dc94: c0 26 80 00 clr [ %i2 ]
return EINVAL;
200dc98: 81 c7 e0 08 ret
200dc9c: 91 e8 20 16 restore %g0, 0x16, %o0
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE;
*budget_callout = NULL;
if ( policy == SCHED_OTHER ) {
200dca0: 80 a6 20 00 cmp %i0, 0
200dca4: 12 80 00 06 bne 200dcbc <_POSIX_Thread_Translate_sched_param+0x3c>
200dca8: c0 26 c0 00 clr [ %i3 ]
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE;
200dcac: 82 10 20 01 mov 1, %g1
200dcb0: c2 26 80 00 st %g1, [ %i2 ]
return 0;
200dcb4: 81 c7 e0 08 ret
200dcb8: 81 e8 00 00 restore
}
if ( policy == SCHED_FIFO ) {
200dcbc: 80 a6 20 01 cmp %i0, 1
200dcc0: 02 80 00 29 be 200dd64 <_POSIX_Thread_Translate_sched_param+0xe4>
200dcc4: 80 a6 20 02 cmp %i0, 2
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE;
return 0;
}
if ( policy == SCHED_RR ) {
200dcc8: 12 80 00 04 bne 200dcd8 <_POSIX_Thread_Translate_sched_param+0x58>
200dccc: 80 a6 20 04 cmp %i0, 4
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_EXHAUST_TIMESLICE;
200dcd0: 10 80 00 25 b 200dd64 <_POSIX_Thread_Translate_sched_param+0xe4>
200dcd4: f0 26 80 00 st %i0, [ %i2 ]
return 0;
}
if ( policy == SCHED_SPORADIC ) {
200dcd8: 12 bf ff f0 bne 200dc98 <_POSIX_Thread_Translate_sched_param+0x18>
200dcdc: 01 00 00 00 nop
if ( (param->sched_ss_repl_period.tv_sec == 0) &&
200dce0: c2 06 60 08 ld [ %i1 + 8 ], %g1
200dce4: 80 a0 60 00 cmp %g1, 0
200dce8: 32 80 00 07 bne,a 200dd04 <_POSIX_Thread_Translate_sched_param+0x84>
200dcec: c2 06 60 10 ld [ %i1 + 0x10 ], %g1
200dcf0: c2 06 60 0c ld [ %i1 + 0xc ], %g1
200dcf4: 80 a0 60 00 cmp %g1, 0
200dcf8: 02 bf ff e8 be 200dc98 <_POSIX_Thread_Translate_sched_param+0x18>
200dcfc: 01 00 00 00 nop
(param->sched_ss_repl_period.tv_nsec == 0) )
return EINVAL;
if ( (param->sched_ss_init_budget.tv_sec == 0) &&
200dd00: c2 06 60 10 ld [ %i1 + 0x10 ], %g1
200dd04: 80 a0 60 00 cmp %g1, 0
200dd08: 12 80 00 06 bne 200dd20 <_POSIX_Thread_Translate_sched_param+0xa0>
200dd0c: 01 00 00 00 nop
200dd10: c2 06 60 14 ld [ %i1 + 0x14 ], %g1
200dd14: 80 a0 60 00 cmp %g1, 0
200dd18: 02 bf ff e0 be 200dc98 <_POSIX_Thread_Translate_sched_param+0x18>
200dd1c: 01 00 00 00 nop
(param->sched_ss_init_budget.tv_nsec == 0) )
return EINVAL;
if ( _Timespec_To_ticks( ¶m->sched_ss_repl_period ) <
200dd20: 7f ff f7 6d call 200bad4 <_Timespec_To_ticks>
200dd24: 90 06 60 08 add %i1, 8, %o0
200dd28: ba 10 00 08 mov %o0, %i5
_Timespec_To_ticks( ¶m->sched_ss_init_budget ) )
200dd2c: 7f ff f7 6a call 200bad4 <_Timespec_To_ticks>
200dd30: 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 ) <
200dd34: 80 a7 40 08 cmp %i5, %o0
200dd38: 0a bf ff d8 bcs 200dc98 <_POSIX_Thread_Translate_sched_param+0x18>
200dd3c: 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 ) )
200dd40: 7f ff ff c5 call 200dc54 <_POSIX_Priority_Is_valid>
200dd44: d0 06 60 04 ld [ %i1 + 4 ], %o0
200dd48: 80 8a 20 ff btst 0xff, %o0
200dd4c: 02 bf ff d3 be 200dc98 <_POSIX_Thread_Translate_sched_param+0x18>
200dd50: 82 10 20 03 mov 3, %g1
return EINVAL;
*budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_CALLOUT;
200dd54: c2 26 80 00 st %g1, [ %i2 ]
*budget_callout = _POSIX_Threads_Sporadic_budget_callout;
200dd58: 03 00 80 1f sethi %hi(0x2007c00), %g1
200dd5c: 82 10 62 14 or %g1, 0x214, %g1 ! 2007e14 <_POSIX_Threads_Sporadic_budget_callout>
200dd60: c2 26 c0 00 st %g1, [ %i3 ]
return 0;
}
return EINVAL;
}
200dd64: 81 c7 e0 08 ret
200dd68: 91 e8 20 00 restore %g0, 0, %o0
0200cc30 <_POSIX_Threads_Delete_extension>:
*/
static void _POSIX_Threads_Delete_extension(
Thread_Control *executing __attribute__((unused)),
Thread_Control *deleted
)
{
200cc30: 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 ];
200cc34: f0 06 61 5c ld [ %i1 + 0x15c ], %i0
/*
* Run the POSIX cancellation handlers
*/
_POSIX_Threads_cancel_run( deleted );
200cc38: 40 00 09 09 call 200f05c <_POSIX_Threads_cancel_run>
200cc3c: 90 10 00 19 mov %i1, %o0
/*
* Run all the key destructors
*/
_POSIX_Keys_Run_destructors( deleted );
200cc40: 90 10 00 19 mov %i1, %o0
200cc44: 40 00 09 20 call 200f0c4 <_POSIX_Keys_Run_destructors>
200cc48: 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 )) )
200cc4c: 10 80 00 03 b 200cc58 <_POSIX_Threads_Delete_extension+0x28>
200cc50: f8 06 60 28 ld [ %i1 + 0x28 ], %i4
*(void **)the_thread->Wait.return_argument = value_ptr;
200cc54: 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 )) )
200cc58: 7f ff f6 42 call 200a560 <_Thread_queue_Dequeue>
200cc5c: 90 10 00 1d mov %i5, %o0
200cc60: 80 a2 20 00 cmp %o0, 0
200cc64: 32 bf ff fc bne,a 200cc54 <_POSIX_Threads_Delete_extension+0x24><== NEVER TAKEN
200cc68: c2 02 20 28 ld [ %o0 + 0x28 ], %g1 <== NOT EXECUTED
*(void **)the_thread->Wait.return_argument = value_ptr;
if ( api->schedpolicy == SCHED_SPORADIC )
200cc6c: c2 06 20 84 ld [ %i0 + 0x84 ], %g1
200cc70: 80 a0 60 04 cmp %g1, 4
200cc74: 32 80 00 05 bne,a 200cc88 <_POSIX_Threads_Delete_extension+0x58>
200cc78: c0 26 61 5c clr [ %i1 + 0x15c ]
(void) _Watchdog_Remove( &api->Sporadic_timer );
200cc7c: 7f ff f8 f7 call 200b058 <_Watchdog_Remove>
200cc80: 90 06 20 a8 add %i0, 0xa8, %o0
deleted->API_Extensions[ THREAD_API_POSIX ] = NULL;
200cc84: c0 26 61 5c clr [ %i1 + 0x15c ]
_Workspace_Free( api );
200cc88: 7f ff f9 6d call 200b23c <_Workspace_Free>
200cc8c: 81 e8 00 00 restore
02007b70 <_POSIX_Threads_Initialize_user_threads_body>:
*
* Output parameters: NONE
*/
void _POSIX_Threads_Initialize_user_threads_body(void)
{
2007b70: 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;
2007b74: 03 00 80 86 sethi %hi(0x2021800), %g1
2007b78: 82 10 62 60 or %g1, 0x260, %g1 ! 2021a60 <Configuration_POSIX_API>
maximum = Configuration_POSIX_API.number_of_initialization_threads;
2007b7c: f6 00 60 30 ld [ %g1 + 0x30 ], %i3
if ( !user_threads || maximum == 0 )
2007b80: 80 a6 e0 00 cmp %i3, 0
2007b84: 02 80 00 1d be 2007bf8 <_POSIX_Threads_Initialize_user_threads_body+0x88><== NEVER TAKEN
2007b88: fa 00 60 34 ld [ %g1 + 0x34 ], %i5
2007b8c: 80 a7 60 00 cmp %i5, 0
2007b90: 02 80 00 1a be 2007bf8 <_POSIX_Threads_Initialize_user_threads_body+0x88><== NEVER TAKEN
2007b94: 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 );
2007b98: 40 00 18 75 call 200dd6c <pthread_attr_init>
2007b9c: 90 07 bf c0 add %fp, -64, %o0
(void) pthread_attr_setinheritsched( &attr, PTHREAD_EXPLICIT_SCHED );
2007ba0: 92 10 20 02 mov 2, %o1
2007ba4: 40 00 18 7e call 200dd9c <pthread_attr_setinheritsched>
2007ba8: 90 07 bf c0 add %fp, -64, %o0
(void) pthread_attr_setstacksize(&attr, user_threads[ index ].stack_size);
2007bac: d2 07 60 04 ld [ %i5 + 4 ], %o1
2007bb0: 40 00 18 8a call 200ddd8 <pthread_attr_setstacksize>
2007bb4: 90 07 bf c0 add %fp, -64, %o0
status = pthread_create(
2007bb8: d4 07 40 00 ld [ %i5 ], %o2
2007bbc: 90 07 bf bc add %fp, -68, %o0
2007bc0: 92 07 bf c0 add %fp, -64, %o1
2007bc4: 96 10 20 00 clr %o3
2007bc8: 7f ff ff 16 call 2007820 <pthread_create>
2007bcc: ba 07 60 08 add %i5, 8, %i5
&thread_id,
&attr,
user_threads[ index ].thread_entry,
NULL
);
if ( status )
2007bd0: 80 a2 20 00 cmp %o0, 0
2007bd4: 02 80 00 05 be 2007be8 <_POSIX_Threads_Initialize_user_threads_body+0x78>
2007bd8: 94 10 00 08 mov %o0, %o2
_Internal_error_Occurred( INTERNAL_ERROR_POSIX_API, true, status );
2007bdc: 90 10 20 02 mov 2, %o0
2007be0: 40 00 07 f9 call 2009bc4 <_Internal_error_Occurred>
2007be4: 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++ ) {
2007be8: b8 07 20 01 inc %i4
2007bec: 80 a7 00 1b cmp %i4, %i3
2007bf0: 12 bf ff ea bne 2007b98 <_POSIX_Threads_Initialize_user_threads_body+0x28><== NEVER TAKEN
2007bf4: 01 00 00 00 nop
2007bf8: 81 c7 e0 08 ret
2007bfc: 81 e8 00 00 restore
0200cd84 <_POSIX_Threads_Sporadic_budget_TSR>:
*/
void _POSIX_Threads_Sporadic_budget_TSR(
Objects_Id id __attribute__((unused)),
void *argument
)
{
200cd84: 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 ];
200cd88: 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 );
200cd8c: 40 00 04 30 call 200de4c <_Timespec_To_ticks>
200cd90: 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);
200cd94: 03 00 80 73 sethi %hi(0x201cc00), %g1
200cd98: d2 08 61 48 ldub [ %g1 + 0x148 ], %o1 ! 201cd48 <rtems_maximum_priority>
200cd9c: c2 07 60 88 ld [ %i5 + 0x88 ], %g1
the_thread->cpu_time_budget = ticks;
200cda0: d0 26 60 74 st %o0, [ %i1 + 0x74 ]
200cda4: 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 ) {
200cda8: c2 06 60 1c ld [ %i1 + 0x1c ], %g1
200cdac: 80 a0 60 00 cmp %g1, 0
200cdb0: 12 80 00 09 bne 200cdd4 <_POSIX_Threads_Sporadic_budget_TSR+0x50><== NEVER TAKEN
200cdb4: 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 ) {
200cdb8: c2 06 60 14 ld [ %i1 + 0x14 ], %g1
200cdbc: 80 a0 40 09 cmp %g1, %o1
200cdc0: 08 80 00 06 bleu 200cdd8 <_POSIX_Threads_Sporadic_budget_TSR+0x54>
200cdc4: 90 07 60 90 add %i5, 0x90, %o0
_Thread_Change_priority( the_thread, new_priority, true );
200cdc8: 90 10 00 19 mov %i1, %o0
200cdcc: 7f ff f3 db call 2009d38 <_Thread_Change_priority>
200cdd0: 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 );
200cdd4: 90 07 60 90 add %i5, 0x90, %o0
200cdd8: 40 00 04 1d call 200de4c <_Timespec_To_ticks>
200cddc: 31 00 80 76 sethi %hi(0x201d800), %i0
)
{
the_watchdog->initial = units;
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
200cde0: b0 16 23 98 or %i0, 0x398, %i0 ! 201db98 <_Watchdog_Ticks_chain>
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
200cde4: d0 27 60 b4 st %o0, [ %i5 + 0xb4 ]
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
200cde8: 7f ff f8 44 call 200aef8 <_Watchdog_Insert>
200cdec: 93 ef 60 a8 restore %i5, 0xa8, %o1
0200cdf0 <_POSIX_Threads_Sporadic_budget_callout>:
)
{
POSIX_API_Control *api;
uint32_t new_priority;
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
200cdf0: 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 */
200cdf4: 86 10 3f ff mov -1, %g3
200cdf8: c4 00 a0 8c ld [ %g2 + 0x8c ], %g2
200cdfc: c6 22 20 74 st %g3, [ %o0 + 0x74 ]
200ce00: 07 00 80 73 sethi %hi(0x201cc00), %g3
200ce04: d2 08 e1 48 ldub [ %g3 + 0x148 ], %o1 ! 201cd48 <rtems_maximum_priority>
200ce08: 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 ) {
200ce0c: c4 02 20 1c ld [ %o0 + 0x1c ], %g2
200ce10: 80 a0 a0 00 cmp %g2, 0
200ce14: 12 80 00 09 bne 200ce38 <_POSIX_Threads_Sporadic_budget_callout+0x48><== NEVER TAKEN
200ce18: 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 ) {
200ce1c: c2 02 20 14 ld [ %o0 + 0x14 ], %g1
200ce20: 80 a0 40 09 cmp %g1, %o1
200ce24: 1a 80 00 05 bcc 200ce38 <_POSIX_Threads_Sporadic_budget_callout+0x48><== NEVER TAKEN
200ce28: 94 10 20 01 mov 1, %o2
_Thread_Change_priority( the_thread, new_priority, true );
200ce2c: 82 13 c0 00 mov %o7, %g1
200ce30: 7f ff f3 c2 call 2009d38 <_Thread_Change_priority>
200ce34: 9e 10 40 00 mov %g1, %o7
200ce38: 81 c3 e0 08 retl <== NOT EXECUTED
02007614 <_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)
{
2007614: 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;
2007618: c2 06 60 68 ld [ %i1 + 0x68 ], %g1
200761c: 82 00 60 01 inc %g1
2007620: c2 26 60 68 st %g1, [ %i1 + 0x68 ]
/* The timer must be reprogrammed */
if ( ( ptimer->timer_data.it_interval.tv_sec != 0 ) ||
2007624: c2 06 60 54 ld [ %i1 + 0x54 ], %g1
2007628: 80 a0 60 00 cmp %g1, 0
200762c: 32 80 00 07 bne,a 2007648 <_POSIX_Timer_TSR+0x34>
2007630: d2 06 60 64 ld [ %i1 + 0x64 ], %o1
2007634: c2 06 60 58 ld [ %i1 + 0x58 ], %g1
2007638: 80 a0 60 00 cmp %g1, 0
200763c: 02 80 00 1e be 20076b4 <_POSIX_Timer_TSR+0xa0> <== NEVER TAKEN
2007640: 82 10 20 04 mov 4, %g1
( ptimer->timer_data.it_interval.tv_nsec != 0 ) ) {
activated = _POSIX_Timer_Insert_helper(
2007644: d2 06 60 64 ld [ %i1 + 0x64 ], %o1
2007648: d4 06 60 08 ld [ %i1 + 8 ], %o2
200764c: 90 06 60 10 add %i1, 0x10, %o0
2007650: 17 00 80 1d sethi %hi(0x2007400), %o3
2007654: 98 10 00 19 mov %i1, %o4
2007658: 40 00 18 0b call 200d684 <_POSIX_Timer_Insert_helper>
200765c: 96 12 e2 14 or %o3, 0x214, %o3
ptimer->ticks,
ptimer->Object.id,
_POSIX_Timer_TSR,
ptimer
);
if ( !activated )
2007660: 80 8a 20 ff btst 0xff, %o0
2007664: 02 80 00 19 be 20076c8 <_POSIX_Timer_TSR+0xb4> <== NEVER TAKEN
2007668: 01 00 00 00 nop
struct timespec *tod_as_timespec
)
{
Timestamp_Control tod_as_timestamp;
_TOD_Get_as_timestamp( &tod_as_timestamp );
200766c: 40 00 05 da call 2008dd4 <_TOD_Get_as_timestamp>
2007670: 90 07 bf f8 add %fp, -8, %o0
_Timestamp_To_timespec( &tod_as_timestamp, tod_as_timespec );
2007674: 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);
2007678: 94 10 20 00 clr %o2
200767c: 90 10 00 1c mov %i4, %o0
2007680: 92 10 00 1d mov %i5, %o1
2007684: 17 0e e6 b2 sethi %hi(0x3b9ac800), %o3
2007688: 40 00 48 c9 call 20199ac <__divdi3>
200768c: 96 12 e2 00 or %o3, 0x200, %o3 ! 3b9aca00 <RAM_END+0x395aca00>
_timespec->tv_nsec = (long) (*_timestamp % 1000000000L);
2007690: 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);
2007694: d2 26 60 6c st %o1, [ %i1 + 0x6c ]
_timespec->tv_nsec = (long) (*_timestamp % 1000000000L);
2007698: 94 10 20 00 clr %o2
200769c: 92 10 00 1d mov %i5, %o1
20076a0: 17 0e e6 b2 sethi %hi(0x3b9ac800), %o3
20076a4: 40 00 49 ad call 2019d58 <__moddi3>
20076a8: 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;
20076ac: 82 10 20 03 mov 3, %g1
20076b0: 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 ) ) {
20076b4: d0 06 60 38 ld [ %i1 + 0x38 ], %o0
20076b8: d2 06 60 44 ld [ %i1 + 0x44 ], %o1
20076bc: 40 00 16 e5 call 200d250 <pthread_kill>
20076c0: 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;
20076c4: c0 26 60 68 clr [ %i1 + 0x68 ]
20076c8: 81 c7 e0 08 ret
20076cc: 81 e8 00 00 restore
0200f180 <_POSIX_signals_Check_signal>:
bool _POSIX_signals_Check_signal(
POSIX_API_Control *api,
int signo,
bool is_global
)
{
200f180: 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,
200f184: 98 10 20 01 mov 1, %o4
200f188: 90 10 00 18 mov %i0, %o0
200f18c: 92 10 00 19 mov %i1, %o1
200f190: 94 07 bf cc add %fp, -52, %o2
200f194: 40 00 00 2e call 200f24c <_POSIX_signals_Clear_signals>
200f198: 96 10 00 1a mov %i2, %o3
200f19c: 80 8a 20 ff btst 0xff, %o0
200f1a0: 02 80 00 28 be 200f240 <_POSIX_signals_Check_signal+0xc0>
200f1a4: 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 )
200f1a8: 85 2e 60 02 sll %i1, 2, %g2
200f1ac: 35 00 80 78 sethi %hi(0x201e000), %i2
200f1b0: b7 2e 60 04 sll %i1, 4, %i3
200f1b4: b4 16 a0 80 or %i2, 0x80, %i2
200f1b8: b6 26 c0 02 sub %i3, %g2, %i3
200f1bc: 84 06 80 1b add %i2, %i3, %g2
200f1c0: fa 00 a0 08 ld [ %g2 + 8 ], %i5
200f1c4: 80 a7 60 01 cmp %i5, 1
200f1c8: 02 80 00 1e be 200f240 <_POSIX_signals_Check_signal+0xc0> <== NEVER TAKEN
200f1cc: 90 07 bf d8 add %fp, -40, %o0
return false;
/*
* Block the signals requested in sa_mask
*/
saved_signals_blocked = api->signals_blocked;
200f1d0: f8 06 20 d0 ld [ %i0 + 0xd0 ], %i4
api->signals_blocked |= _POSIX_signals_Vectors[ signo ].sa_mask;
200f1d4: c2 00 a0 04 ld [ %g2 + 4 ], %g1
200f1d8: 82 10 40 1c or %g1, %i4, %g1
200f1dc: 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,
200f1e0: 03 00 80 78 sethi %hi(0x201e000), %g1
200f1e4: d2 00 60 2c ld [ %g1 + 0x2c ], %o1 ! 201e02c <_Per_CPU_Information+0xc>
200f1e8: 94 10 20 28 mov 0x28, %o2
200f1ec: 40 00 04 52 call 2010334 <memcpy>
200f1f0: 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 ) {
200f1f4: c2 06 80 1b ld [ %i2 + %i3 ], %g1
200f1f8: 80 a0 60 02 cmp %g1, 2
200f1fc: 12 80 00 07 bne 200f218 <_POSIX_signals_Check_signal+0x98>
200f200: 90 10 00 19 mov %i1, %o0
case SA_SIGINFO:
(*_POSIX_signals_Vectors[ signo ].sa_sigaction)(
200f204: 92 07 bf cc add %fp, -52, %o1
200f208: 9f c7 40 00 call %i5
200f20c: 94 10 20 00 clr %o2
signo,
&siginfo_struct,
NULL /* context is undefined per 1003.1b-1993, p. 66 */
);
break;
200f210: 10 80 00 05 b 200f224 <_POSIX_signals_Check_signal+0xa4>
200f214: 03 00 80 78 sethi %hi(0x201e000), %g1
default:
(*_POSIX_signals_Vectors[ signo ].sa_handler)( signo );
200f218: 9f c7 40 00 call %i5
200f21c: 01 00 00 00 nop
}
/*
* Restore the blocking information
*/
memcpy( &_Thread_Executing->Wait, &stored_thread_wait_information,
200f220: 03 00 80 78 sethi %hi(0x201e000), %g1
200f224: d0 00 60 2c ld [ %g1 + 0x2c ], %o0 ! 201e02c <_Per_CPU_Information+0xc>
200f228: 92 07 bf d8 add %fp, -40, %o1
200f22c: 90 02 20 20 add %o0, 0x20, %o0
200f230: 40 00 04 41 call 2010334 <memcpy>
200f234: 94 10 20 28 mov 0x28, %o2
/*
* Restore the previous set of blocked signals
*/
api->signals_blocked = saved_signals_blocked;
return true;
200f238: 82 10 20 01 mov 1, %g1
sizeof( Thread_Wait_information ));
/*
* Restore the previous set of blocked signals
*/
api->signals_blocked = saved_signals_blocked;
200f23c: f8 26 20 d0 st %i4, [ %i0 + 0xd0 ]
return true;
}
200f240: b0 08 60 01 and %g1, 1, %i0
200f244: 81 c7 e0 08 ret
200f248: 81 e8 00 00 restore
0200f974 <_POSIX_signals_Clear_process_signals>:
*/
void _POSIX_signals_Clear_process_signals(
int signo
)
{
200f974: 9d e3 bf a0 save %sp, -96, %sp
200f978: 82 06 3f ff add %i0, -1, %g1
200f97c: ba 10 20 01 mov 1, %i5
clear_signal = true;
mask = signo_to_mask( signo );
ISR_Level level;
_ISR_Disable( level );
200f980: 7f ff cb 51 call 20026c4 <sparc_disable_interrupts>
200f984: bb 2f 40 01 sll %i5, %g1, %i5
if ( _POSIX_signals_Vectors[ signo ].sa_flags == SA_SIGINFO ) {
200f988: 05 00 80 78 sethi %hi(0x201e000), %g2
200f98c: 83 2e 20 02 sll %i0, 2, %g1
200f990: 84 10 a0 80 or %g2, 0x80, %g2
200f994: b1 2e 20 04 sll %i0, 4, %i0
200f998: 82 26 00 01 sub %i0, %g1, %g1
200f99c: c4 00 80 01 ld [ %g2 + %g1 ], %g2
200f9a0: 80 a0 a0 02 cmp %g2, 2
200f9a4: 32 80 00 0c bne,a 200f9d4 <_POSIX_signals_Clear_process_signals+0x60>
200f9a8: 03 00 80 78 sethi %hi(0x201e000), %g1
if ( !_Chain_Is_empty( &_POSIX_signals_Siginfo[ signo ] ) )
200f9ac: 05 00 80 78 sethi %hi(0x201e000), %g2
200f9b0: 84 10 a2 78 or %g2, 0x278, %g2 ! 201e278 <_POSIX_signals_Siginfo>
200f9b4: 86 00 40 02 add %g1, %g2, %g3
200f9b8: 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 );
200f9bc: 86 00 e0 04 add %g3, 4, %g3
200f9c0: 80 a0 40 03 cmp %g1, %g3
200f9c4: 02 80 00 04 be 200f9d4 <_POSIX_signals_Clear_process_signals+0x60><== ALWAYS TAKEN
200f9c8: 03 00 80 78 sethi %hi(0x201e000), %g1
clear_signal = false;
}
if ( clear_signal ) {
_POSIX_signals_Pending &= ~mask;
}
_ISR_Enable( level );
200f9cc: 7f ff cb 42 call 20026d4 <sparc_enable_interrupts>
200f9d0: 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;
200f9d4: c4 00 62 74 ld [ %g1 + 0x274 ], %g2
200f9d8: ba 28 80 1d andn %g2, %i5, %i5
200f9dc: 10 bf ff fc b 200f9cc <_POSIX_signals_Clear_process_signals+0x58>
200f9e0: fa 20 62 74 st %i5, [ %g1 + 0x274 ]
0200840c <_POSIX_signals_Get_lowest>:
sigset_t set
)
{
int signo;
for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) {
200840c: 82 10 20 1b mov 0x1b, %g1
2008410: 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(
2008414: 86 00 7f ff add %g1, -1, %g3
2008418: 87 28 80 03 sll %g2, %g3, %g3
)
{
int signo;
for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) {
if ( set & signo_to_mask( signo ) ) {
200841c: 80 88 c0 08 btst %g3, %o0
2008420: 12 80 00 11 bne 2008464 <_POSIX_signals_Get_lowest+0x58> <== NEVER TAKEN
2008424: 01 00 00 00 nop
sigset_t set
)
{
int signo;
for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) {
2008428: 82 00 60 01 inc %g1
200842c: 80 a0 60 20 cmp %g1, 0x20
2008430: 12 bf ff fa bne 2008418 <_POSIX_signals_Get_lowest+0xc>
2008434: 86 00 7f ff add %g1, -1, %g3
2008438: 82 10 20 01 mov 1, %g1
200843c: 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(
2008440: 86 00 7f ff add %g1, -1, %g3
2008444: 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 ) ) {
2008448: 80 88 c0 08 btst %g3, %o0
200844c: 12 80 00 06 bne 2008464 <_POSIX_signals_Get_lowest+0x58>
2008450: 01 00 00 00 nop
*/
#if (SIGHUP != 1)
#error "Assumption that SIGHUP==1 violated!!"
#endif
for ( signo = SIGHUP ; signo <= __SIGLASTNOTRT ; signo++ ) {
2008454: 82 00 60 01 inc %g1
2008458: 80 a0 60 1b cmp %g1, 0x1b
200845c: 12 bf ff fa bne 2008444 <_POSIX_signals_Get_lowest+0x38> <== ALWAYS TAKEN
2008460: 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;
}
2008464: 81 c3 e0 08 retl
2008468: 90 10 00 01 mov %g1, %o0
0201a654 <_POSIX_signals_Unblock_thread>:
bool _POSIX_signals_Unblock_thread(
Thread_Control *the_thread,
int signo,
siginfo_t *info
)
{
201a654: 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 ) ) {
201a658: c2 06 20 10 ld [ %i0 + 0x10 ], %g1
201a65c: 3b 04 00 20 sethi %hi(0x10008000), %i5
201a660: 84 06 7f ff add %i1, -1, %g2
201a664: 86 10 20 01 mov 1, %g3
201a668: 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 ];
201a66c: 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 ) ) {
201a670: 80 a7 00 1d cmp %i4, %i5
201a674: 12 80 00 1e bne 201a6ec <_POSIX_signals_Unblock_thread+0x98>
201a678: 85 28 c0 02 sll %g3, %g2, %g2
if ( (the_thread->Wait.option & mask) || (~api->signals_blocked & mask) ) {
201a67c: c2 06 20 30 ld [ %i0 + 0x30 ], %g1
201a680: 80 88 80 01 btst %g2, %g1
201a684: 12 80 00 08 bne 201a6a4 <_POSIX_signals_Unblock_thread+0x50>
201a688: 82 10 20 04 mov 4, %g1
201a68c: c2 01 20 d0 ld [ %g4 + 0xd0 ], %g1
201a690: 80 a8 80 01 andncc %g2, %g1, %g0
201a694: 32 80 00 04 bne,a 201a6a4 <_POSIX_signals_Unblock_thread+0x50>
201a698: 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;
201a69c: 10 80 00 3d b 201a790 <_POSIX_signals_Unblock_thread+0x13c>
201a6a0: 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;
201a6a4: c2 26 20 34 st %g1, [ %i0 + 0x34 ]
the_info = (siginfo_t *) the_thread->Wait.return_argument;
if ( !info ) {
201a6a8: 80 a6 a0 00 cmp %i2, 0
201a6ac: 12 80 00 07 bne 201a6c8 <_POSIX_signals_Unblock_thread+0x74>
201a6b0: d0 06 20 28 ld [ %i0 + 0x28 ], %o0
the_info->si_signo = signo;
the_info->si_code = SI_USER;
201a6b4: 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;
201a6b8: f2 22 00 00 st %i1, [ %o0 ]
the_info->si_code = SI_USER;
201a6bc: c2 22 20 04 st %g1, [ %o0 + 4 ]
the_info->si_value.sival_int = 0;
201a6c0: 10 80 00 05 b 201a6d4 <_POSIX_signals_Unblock_thread+0x80>
201a6c4: c0 22 20 08 clr [ %o0 + 8 ]
} else {
*the_info = *info;
201a6c8: 92 10 00 1a mov %i2, %o1
201a6cc: 7f ff d7 1a call 2010334 <memcpy>
201a6d0: 94 10 20 0c mov 0xc, %o2
}
_Thread_queue_Extract_with_proxy( the_thread );
201a6d4: 90 10 00 18 mov %i0, %o0
201a6d8: 7f ff c0 8f call 200a914 <_Thread_queue_Extract_with_proxy>
201a6dc: b0 10 20 01 mov 1, %i0
201a6e0: b0 0e 20 01 and %i0, 1, %i0
201a6e4: 81 c7 e0 08 ret
201a6e8: 81 e8 00 00 restore
}
/*
* Thread is not waiting due to a sigwait.
*/
if ( ~api->signals_blocked & mask ) {
201a6ec: c8 01 20 d0 ld [ %g4 + 0xd0 ], %g4
201a6f0: 80 a8 80 04 andncc %g2, %g4, %g0
201a6f4: 02 80 00 26 be 201a78c <_POSIX_signals_Unblock_thread+0x138>
201a6f8: 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 ) ) {
201a6fc: 80 88 40 02 btst %g1, %g2
201a700: 02 80 00 17 be 201a75c <_POSIX_signals_Unblock_thread+0x108>
201a704: 80 a0 60 00 cmp %g1, 0
the_thread->Wait.return_code = EINTR;
201a708: 84 10 20 04 mov 4, %g2
201a70c: 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) )
201a710: 05 00 00 ef sethi %hi(0x3bc00), %g2
201a714: 84 10 a2 e0 or %g2, 0x2e0, %g2 ! 3bee0 <PROM_START+0x3bee0>
201a718: 80 88 40 02 btst %g1, %g2
201a71c: 02 80 00 06 be 201a734 <_POSIX_signals_Unblock_thread+0xe0>
201a720: 80 88 60 08 btst 8, %g1
_Thread_queue_Extract_with_proxy( the_thread );
201a724: 7f ff c0 7c call 200a914 <_Thread_queue_Extract_with_proxy>
201a728: 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;
201a72c: 10 80 00 19 b 201a790 <_POSIX_signals_Unblock_thread+0x13c>
201a730: 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) ) {
201a734: 22 80 00 17 be,a 201a790 <_POSIX_signals_Unblock_thread+0x13c><== NEVER TAKEN
201a738: b0 10 20 00 clr %i0 <== NOT EXECUTED
(void) _Watchdog_Remove( &the_thread->Timer );
201a73c: 7f ff c2 47 call 200b058 <_Watchdog_Remove>
201a740: 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 );
201a744: 90 10 00 18 mov %i0, %o0
201a748: 13 04 00 ff sethi %hi(0x1003fc00), %o1
201a74c: 7f ff bd c0 call 2009e4c <_Thread_Clear_state>
201a750: 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;
201a754: 10 80 00 0f b 201a790 <_POSIX_signals_Unblock_thread+0x13c>
201a758: 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 ) {
201a75c: 32 80 00 0d bne,a 201a790 <_POSIX_signals_Unblock_thread+0x13c><== NEVER TAKEN
201a760: b0 10 20 00 clr %i0 <== NOT EXECUTED
if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
201a764: 03 00 80 78 sethi %hi(0x201e000), %g1
201a768: 82 10 60 20 or %g1, 0x20, %g1 ! 201e020 <_Per_CPU_Information>
201a76c: c4 00 60 08 ld [ %g1 + 8 ], %g2
201a770: 80 a0 a0 00 cmp %g2, 0
201a774: 22 80 00 07 be,a 201a790 <_POSIX_signals_Unblock_thread+0x13c>
201a778: b0 10 20 00 clr %i0
201a77c: c4 00 60 0c ld [ %g1 + 0xc ], %g2
201a780: 80 a6 00 02 cmp %i0, %g2
201a784: 22 80 00 02 be,a 201a78c <_POSIX_signals_Unblock_thread+0x138><== ALWAYS TAKEN
201a788: c6 28 60 18 stb %g3, [ %g1 + 0x18 ]
_Thread_Dispatch_necessary = true;
}
}
return false;
201a78c: b0 10 20 00 clr %i0
}
201a790: b0 0e 20 01 and %i0, 1, %i0
201a794: 81 c7 e0 08 ret
201a798: 81 e8 00 00 restore
0200a3a0 <_RBTree_Extract_unprotected>:
*/
void _RBTree_Extract_unprotected(
RBTree_Control *the_rbtree,
RBTree_Node *the_node
)
{
200a3a0: 9d e3 bf a0 save %sp, -96, %sp
RBTree_Node *leaf, *target;
RBTree_Color victim_color;
RBTree_Direction dir;
if (!the_node) return;
200a3a4: 80 a6 60 00 cmp %i1, 0
200a3a8: 02 80 00 69 be 200a54c <_RBTree_Extract_unprotected+0x1ac>
200a3ac: 01 00 00 00 nop
/* check if min needs to be updated */
if (the_node == the_rbtree->first[RBT_LEFT]) {
200a3b0: c2 06 20 08 ld [ %i0 + 8 ], %g1
200a3b4: 80 a6 40 01 cmp %i1, %g1
200a3b8: 32 80 00 07 bne,a 200a3d4 <_RBTree_Extract_unprotected+0x34>
200a3bc: 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 );
200a3c0: 90 10 00 19 mov %i1, %o0
200a3c4: 40 00 01 31 call 200a888 <_RBTree_Next_unprotected>
200a3c8: 92 10 20 01 mov 1, %o1
RBTree_Node *next;
next = _RBTree_Successor_unprotected(the_node);
the_rbtree->first[RBT_LEFT] = next;
200a3cc: 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]) {
200a3d0: c2 06 20 0c ld [ %i0 + 0xc ], %g1
200a3d4: 80 a6 40 01 cmp %i1, %g1
200a3d8: 32 80 00 07 bne,a 200a3f4 <_RBTree_Extract_unprotected+0x54>
200a3dc: 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 );
200a3e0: 90 10 00 19 mov %i1, %o0
200a3e4: 40 00 01 29 call 200a888 <_RBTree_Next_unprotected>
200a3e8: 92 10 20 00 clr %o1
RBTree_Node *previous;
previous = _RBTree_Predecessor_unprotected(the_node);
the_rbtree->first[RBT_RIGHT] = previous;
200a3ec: 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]) {
200a3f0: fa 06 60 04 ld [ %i1 + 4 ], %i5
200a3f4: 80 a7 60 00 cmp %i5, 0
200a3f8: 02 80 00 36 be 200a4d0 <_RBTree_Extract_unprotected+0x130>
200a3fc: f8 06 60 08 ld [ %i1 + 8 ], %i4
200a400: 80 a7 20 00 cmp %i4, 0
200a404: 32 80 00 05 bne,a 200a418 <_RBTree_Extract_unprotected+0x78>
200a408: c2 07 60 08 ld [ %i5 + 8 ], %g1
200a40c: 10 80 00 35 b 200a4e0 <_RBTree_Extract_unprotected+0x140>
200a410: 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];
200a414: c2 07 60 08 ld [ %i5 + 8 ], %g1
200a418: 80 a0 60 00 cmp %g1, 0
200a41c: 32 bf ff fe bne,a 200a414 <_RBTree_Extract_unprotected+0x74>
200a420: 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];
200a424: f8 07 60 04 ld [ %i5 + 4 ], %i4
if(leaf) {
200a428: 80 a7 20 00 cmp %i4, 0
200a42c: 02 80 00 05 be 200a440 <_RBTree_Extract_unprotected+0xa0>
200a430: 01 00 00 00 nop
leaf->parent = target->parent;
200a434: c2 07 40 00 ld [ %i5 ], %g1
200a438: 10 80 00 04 b 200a448 <_RBTree_Extract_unprotected+0xa8>
200a43c: c2 27 00 00 st %g1, [ %i4 ]
} else {
/* fix the tree here if the child is a null leaf. */
_RBTree_Extract_validate_unprotected(target);
200a440: 7f ff ff 73 call 200a20c <_RBTree_Extract_validate_unprotected>
200a444: 90 10 00 1d mov %i5, %o0
}
victim_color = target->color;
dir = target != target->parent->child[0];
200a448: 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;
200a44c: c2 07 60 0c ld [ %i5 + 0xc ], %g1
dir = target != target->parent->child[0];
200a450: c6 00 a0 04 ld [ %g2 + 4 ], %g3
200a454: 86 1f 40 03 xor %i5, %g3, %g3
200a458: 80 a0 00 03 cmp %g0, %g3
200a45c: 86 40 20 00 addx %g0, 0, %g3
target->parent->child[dir] = leaf;
200a460: 87 28 e0 02 sll %g3, 2, %g3
200a464: 84 00 80 03 add %g2, %g3, %g2
200a468: f8 20 a0 04 st %i4, [ %g2 + 4 ]
/* now replace the_node with target */
dir = the_node != the_node->parent->child[0];
200a46c: c4 06 40 00 ld [ %i1 ], %g2
200a470: c6 00 a0 04 ld [ %g2 + 4 ], %g3
200a474: 86 1e 40 03 xor %i1, %g3, %g3
200a478: 80 a0 00 03 cmp %g0, %g3
200a47c: 86 40 20 00 addx %g0, 0, %g3
the_node->parent->child[dir] = target;
200a480: 87 28 e0 02 sll %g3, 2, %g3
200a484: 84 00 80 03 add %g2, %g3, %g2
200a488: 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];
200a48c: c4 06 60 08 ld [ %i1 + 8 ], %g2
200a490: c4 27 60 08 st %g2, [ %i5 + 8 ]
if (the_node->child[RBT_RIGHT])
200a494: c4 06 60 08 ld [ %i1 + 8 ], %g2
200a498: 80 a0 a0 00 cmp %g2, 0
200a49c: 32 80 00 02 bne,a 200a4a4 <_RBTree_Extract_unprotected+0x104><== ALWAYS TAKEN
200a4a0: fa 20 80 00 st %i5, [ %g2 ]
the_node->child[RBT_RIGHT]->parent = target;
target->child[RBT_LEFT] = the_node->child[RBT_LEFT];
200a4a4: c4 06 60 04 ld [ %i1 + 4 ], %g2
200a4a8: c4 27 60 04 st %g2, [ %i5 + 4 ]
if (the_node->child[RBT_LEFT])
200a4ac: c4 06 60 04 ld [ %i1 + 4 ], %g2
200a4b0: 80 a0 a0 00 cmp %g2, 0
200a4b4: 32 80 00 02 bne,a 200a4bc <_RBTree_Extract_unprotected+0x11c>
200a4b8: 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;
200a4bc: c4 06 40 00 ld [ %i1 ], %g2
200a4c0: c4 27 40 00 st %g2, [ %i5 ]
target->color = the_node->color;
200a4c4: c4 06 60 0c ld [ %i1 + 0xc ], %g2
200a4c8: 10 80 00 14 b 200a518 <_RBTree_Extract_unprotected+0x178>
200a4cc: 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 ) {
200a4d0: 80 a7 20 00 cmp %i4, 0
200a4d4: 32 80 00 04 bne,a 200a4e4 <_RBTree_Extract_unprotected+0x144>
200a4d8: c2 06 40 00 ld [ %i1 ], %g1
200a4dc: 30 80 00 04 b,a 200a4ec <_RBTree_Extract_unprotected+0x14c>
leaf->parent = the_node->parent;
200a4e0: c2 06 40 00 ld [ %i1 ], %g1
200a4e4: 10 80 00 04 b 200a4f4 <_RBTree_Extract_unprotected+0x154>
200a4e8: 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);
200a4ec: 7f ff ff 48 call 200a20c <_RBTree_Extract_validate_unprotected>
200a4f0: 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];
200a4f4: 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;
200a4f8: c2 06 60 0c ld [ %i1 + 0xc ], %g1
/* remove the_node from the tree */
dir = the_node != the_node->parent->child[0];
200a4fc: c6 00 a0 04 ld [ %g2 + 4 ], %g3
200a500: 86 1e 40 03 xor %i1, %g3, %g3
200a504: 80 a0 00 03 cmp %g0, %g3
200a508: 86 40 20 00 addx %g0, 0, %g3
the_node->parent->child[dir] = leaf;
200a50c: 87 28 e0 02 sll %g3, 2, %g3
200a510: 84 00 80 03 add %g2, %g3, %g2
200a514: 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 */
200a518: 80 a0 60 00 cmp %g1, 0
200a51c: 32 80 00 06 bne,a 200a534 <_RBTree_Extract_unprotected+0x194>
200a520: c2 06 20 04 ld [ %i0 + 4 ], %g1
if (leaf) {
200a524: 80 a7 20 00 cmp %i4, 0
200a528: 32 80 00 02 bne,a 200a530 <_RBTree_Extract_unprotected+0x190>
200a52c: 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;
200a530: 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;
200a534: c0 26 60 08 clr [ %i1 + 8 ]
200a538: c0 26 60 04 clr [ %i1 + 4 ]
200a53c: 80 a0 60 00 cmp %g1, 0
200a540: 02 80 00 03 be 200a54c <_RBTree_Extract_unprotected+0x1ac>
200a544: c0 26 40 00 clr [ %i1 ]
200a548: c0 20 60 0c clr [ %g1 + 0xc ]
200a54c: 81 c7 e0 08 ret
200a550: 81 e8 00 00 restore
0200b594 <_RBTree_Initialize>:
void *starting_address,
size_t number_nodes,
size_t node_size,
bool is_unique
)
{
200b594: 9d e3 bf a0 save %sp, -96, %sp
size_t count;
RBTree_Node *next;
/* TODO: Error message? */
if (!the_rbtree) return;
200b598: 80 a6 20 00 cmp %i0, 0
200b59c: 02 80 00 10 be 200b5dc <_RBTree_Initialize+0x48> <== NEVER TAKEN
200b5a0: 01 00 00 00 nop
RBTree_Control *the_rbtree,
RBTree_Compare_function compare_function,
bool is_unique
)
{
the_rbtree->permanent_null = NULL;
200b5a4: c0 26 00 00 clr [ %i0 ]
the_rbtree->root = NULL;
200b5a8: c0 26 20 04 clr [ %i0 + 4 ]
the_rbtree->first[0] = NULL;
200b5ac: c0 26 20 08 clr [ %i0 + 8 ]
the_rbtree->first[1] = NULL;
200b5b0: c0 26 20 0c clr [ %i0 + 0xc ]
the_rbtree->compare_function = compare_function;
200b5b4: 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-- ) {
200b5b8: 10 80 00 06 b 200b5d0 <_RBTree_Initialize+0x3c>
200b5bc: fa 2e 20 14 stb %i5, [ %i0 + 0x14 ]
_RBTree_Insert_unprotected(the_rbtree, next);
200b5c0: 90 10 00 18 mov %i0, %o0
200b5c4: 7f ff ff 2e call 200b27c <_RBTree_Insert_unprotected>
200b5c8: b4 06 80 1c add %i2, %i4, %i2
200b5cc: 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-- ) {
200b5d0: 80 a6 e0 00 cmp %i3, 0
200b5d4: 12 bf ff fb bne 200b5c0 <_RBTree_Initialize+0x2c>
200b5d8: 92 10 00 1a mov %i2, %o1
200b5dc: 81 c7 e0 08 ret
200b5e0: 81 e8 00 00 restore
0200a5f4 <_RBTree_Insert_unprotected>:
*/
RBTree_Node *_RBTree_Insert_unprotected(
RBTree_Control *the_rbtree,
RBTree_Node *the_node
)
{
200a5f4: 9d e3 bf a0 save %sp, -96, %sp
if(!the_node) return (RBTree_Node*)-1;
200a5f8: 80 a6 60 00 cmp %i1, 0
200a5fc: 02 80 00 7c be 200a7ec <_RBTree_Insert_unprotected+0x1f8>
200a600: ba 10 00 18 mov %i0, %i5
RBTree_Node *iter_node = the_rbtree->root;
200a604: f0 06 20 04 ld [ %i0 + 4 ], %i0
int compare_result;
if (!iter_node) { /* special case: first node inserted */
200a608: b6 96 20 00 orcc %i0, 0, %i3
200a60c: 32 80 00 0c bne,a 200a63c <_RBTree_Insert_unprotected+0x48>
200a610: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
the_node->color = RBT_BLACK;
200a614: c0 26 60 0c clr [ %i1 + 0xc ]
the_rbtree->root = the_node;
200a618: f2 27 60 04 st %i1, [ %i5 + 4 ]
the_rbtree->first[0] = the_rbtree->first[1] = the_node;
200a61c: f2 27 60 0c st %i1, [ %i5 + 0xc ]
200a620: f2 27 60 08 st %i1, [ %i5 + 8 ]
the_node->parent = (RBTree_Node *) the_rbtree;
200a624: fa 26 40 00 st %i5, [ %i1 ]
the_node->child[RBT_LEFT] = the_node->child[RBT_RIGHT] = NULL;
200a628: c0 26 60 08 clr [ %i1 + 8 ]
200a62c: c0 26 60 04 clr [ %i1 + 4 ]
200a630: 81 c7 e0 08 ret
200a634: 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);
200a638: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
200a63c: 90 10 00 19 mov %i1, %o0
200a640: 9f c0 40 00 call %g1
200a644: 92 10 00 18 mov %i0, %o1
if ( the_rbtree->is_unique && _RBTree_Is_equal( compare_result ) )
200a648: c2 0f 60 14 ldub [ %i5 + 0x14 ], %g1
200a64c: 80 a0 60 00 cmp %g1, 0
200a650: 02 80 00 05 be 200a664 <_RBTree_Insert_unprotected+0x70>
200a654: b8 38 00 08 xnor %g0, %o0, %i4
200a658: 80 a2 20 00 cmp %o0, 0
200a65c: 02 80 00 65 be 200a7f0 <_RBTree_Insert_unprotected+0x1fc>
200a660: 01 00 00 00 nop
return iter_node;
RBTree_Direction dir = !_RBTree_Is_lesser( compare_result );
200a664: b9 37 20 1f srl %i4, 0x1f, %i4
if (!iter_node->child[dir]) {
200a668: 83 2f 20 02 sll %i4, 2, %g1
200a66c: 82 06 00 01 add %i0, %g1, %g1
200a670: f0 00 60 04 ld [ %g1 + 4 ], %i0
200a674: 80 a6 20 00 cmp %i0, 0
200a678: 32 bf ff f0 bne,a 200a638 <_RBTree_Insert_unprotected+0x44>
200a67c: b6 10 00 18 mov %i0, %i3
the_node->child[RBT_LEFT] = the_node->child[RBT_RIGHT] = NULL;
200a680: c0 26 60 08 clr [ %i1 + 8 ]
200a684: c0 26 60 04 clr [ %i1 + 4 ]
the_node->color = RBT_RED;
200a688: 84 10 20 01 mov 1, %g2
iter_node->child[dir] = the_node;
200a68c: 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;
200a690: c4 26 60 0c st %g2, [ %i1 + 0xc ]
iter_node->child[dir] = the_node;
the_node->parent = iter_node;
200a694: f6 26 40 00 st %i3, [ %i1 ]
/* update min/max */
compare_result = the_rbtree->compare_function(
200a698: 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];
200a69c: b6 07 20 02 add %i4, 2, %i3
200a6a0: 85 2e e0 02 sll %i3, 2, %g2
200a6a4: d2 07 40 02 ld [ %i5 + %g2 ], %o1
200a6a8: 9f c0 40 00 call %g1
200a6ac: 90 10 00 19 mov %i1, %o0
the_node,
_RBTree_First(the_rbtree, dir)
);
if ( (!dir && _RBTree_Is_lesser(compare_result)) ||
200a6b0: 80 a7 20 00 cmp %i4, 0
200a6b4: 12 80 00 06 bne 200a6cc <_RBTree_Insert_unprotected+0xd8>
200a6b8: 80 a2 20 00 cmp %o0, 0
200a6bc: 36 80 00 3c bge,a 200a7ac <_RBTree_Insert_unprotected+0x1b8>
200a6c0: d0 06 40 00 ld [ %i1 ], %o0
(dir && _RBTree_Is_greater(compare_result)) ) {
the_rbtree->first[dir] = the_node;
200a6c4: 10 80 00 04 b 200a6d4 <_RBTree_Insert_unprotected+0xe0>
200a6c8: 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)) ) {
200a6cc: 04 80 00 37 ble 200a7a8 <_RBTree_Insert_unprotected+0x1b4>
200a6d0: b7 2e e0 02 sll %i3, 2, %i3
the_rbtree->first[dir] = the_node;
200a6d4: 10 80 00 35 b 200a7a8 <_RBTree_Insert_unprotected+0x1b4>
200a6d8: 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;
200a6dc: 02 80 00 13 be 200a728 <_RBTree_Insert_unprotected+0x134> <== NEVER TAKEN
200a6e0: 82 10 20 00 clr %g1
if(!(the_node->parent->parent->parent)) return NULL;
200a6e4: c2 07 40 00 ld [ %i5 ], %g1
200a6e8: 80 a0 60 00 cmp %g1, 0
200a6ec: 02 80 00 0f be 200a728 <_RBTree_Insert_unprotected+0x134> <== NEVER TAKEN
200a6f0: 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])
200a6f4: c2 07 60 04 ld [ %i5 + 4 ], %g1
200a6f8: 80 a2 00 01 cmp %o0, %g1
200a6fc: 22 80 00 02 be,a 200a704 <_RBTree_Insert_unprotected+0x110>
200a700: 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);
200a704: 80 a0 60 00 cmp %g1, 0
200a708: 02 80 00 09 be 200a72c <_RBTree_Insert_unprotected+0x138>
200a70c: 84 10 20 00 clr %g2
200a710: c4 00 60 0c ld [ %g1 + 0xc ], %g2
200a714: 80 a0 a0 01 cmp %g2, 1
200a718: 32 80 00 05 bne,a 200a72c <_RBTree_Insert_unprotected+0x138>
200a71c: 84 10 20 00 clr %g2
200a720: 10 80 00 03 b 200a72c <_RBTree_Insert_unprotected+0x138>
200a724: 84 10 20 01 mov 1, %g2
200a728: 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)) {
200a72c: 80 a0 a0 00 cmp %g2, 0
200a730: 22 80 00 08 be,a 200a750 <_RBTree_Insert_unprotected+0x15c>
200a734: c2 07 60 04 ld [ %i5 + 4 ], %g1
the_node->parent->color = RBT_BLACK;
200a738: c0 22 20 0c clr [ %o0 + 0xc ]
u->color = RBT_BLACK;
200a73c: c0 20 60 0c clr [ %g1 + 0xc ]
g->color = RBT_RED;
200a740: b2 10 00 1d mov %i5, %i1
200a744: 82 10 20 01 mov 1, %g1
200a748: 10 80 00 18 b 200a7a8 <_RBTree_Insert_unprotected+0x1b4>
200a74c: 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];
200a750: 82 1a 00 01 xor %o0, %g1, %g1
200a754: 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];
200a758: c2 02 20 04 ld [ %o0 + 4 ], %g1
RBTree_Direction pdir = the_node->parent != g->child[0];
200a75c: 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];
200a760: 82 1e 40 01 xor %i1, %g1, %g1
200a764: 80 a0 00 01 cmp %g0, %g1
200a768: 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) {
200a76c: 80 a0 40 1c cmp %g1, %i4
200a770: 22 80 00 08 be,a 200a790 <_RBTree_Insert_unprotected+0x19c>
200a774: c2 06 40 00 ld [ %i1 ], %g1
_RBTree_Rotate(the_node->parent, pdir);
200a778: 7f ff ff 80 call 200a578 <_RBTree_Rotate>
200a77c: 92 10 00 1c mov %i4, %o1
the_node = the_node->child[pdir];
200a780: 83 2f 20 02 sll %i4, 2, %g1
200a784: b2 06 40 01 add %i1, %g1, %i1
200a788: f2 06 60 04 ld [ %i1 + 4 ], %i1
}
the_node->parent->color = RBT_BLACK;
200a78c: c2 06 40 00 ld [ %i1 ], %g1
g->color = RBT_RED;
200a790: 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;
200a794: c0 20 60 0c clr [ %g1 + 0xc ]
g->color = RBT_RED;
200a798: d2 27 60 0c st %o1, [ %i5 + 0xc ]
/* now rotate grandparent in the other branch direction (toward uncle) */
_RBTree_Rotate(g, (1-pdir));
200a79c: 90 10 00 1d mov %i5, %o0
200a7a0: 7f ff ff 76 call 200a578 <_RBTree_Rotate>
200a7a4: 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;
200a7a8: d0 06 40 00 ld [ %i1 ], %o0
200a7ac: fa 02 00 00 ld [ %o0 ], %i5
200a7b0: 80 a7 60 00 cmp %i5, 0
200a7b4: 22 80 00 06 be,a 200a7cc <_RBTree_Insert_unprotected+0x1d8>
200a7b8: 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);
200a7bc: c2 02 20 0c ld [ %o0 + 0xc ], %g1
200a7c0: 82 18 60 01 xor %g1, 1, %g1
200a7c4: 80 a0 00 01 cmp %g0, %g1
200a7c8: 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))) {
200a7cc: 80 a0 60 00 cmp %g1, 0
200a7d0: 12 bf ff c3 bne 200a6dc <_RBTree_Insert_unprotected+0xe8>
200a7d4: 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;
200a7d8: 12 80 00 06 bne 200a7f0 <_RBTree_Insert_unprotected+0x1fc>
200a7dc: 01 00 00 00 nop
200a7e0: c0 26 60 0c clr [ %i1 + 0xc ]
200a7e4: 81 c7 e0 08 ret
200a7e8: 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;
200a7ec: b0 10 3f ff mov -1, %i0
/* verify red-black properties */
_RBTree_Validate_insert_unprotected(the_node);
}
return (RBTree_Node*)0;
}
200a7f0: 81 c7 e0 08 ret
200a7f4: 81 e8 00 00 restore
0200a828 <_RBTree_Iterate_unprotected>:
const RBTree_Control *rbtree,
RBTree_Direction dir,
RBTree_Visitor visitor,
void *visitor_arg
)
{
200a828: 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;
200a82c: b8 10 20 00 clr %i4
*/
RTEMS_INLINE_ROUTINE RBTree_Direction _RBTree_Opposite_direction(
RBTree_Direction the_dir
)
{
return (RBTree_Direction) !((int) the_dir);
200a830: 80 a0 00 19 cmp %g0, %i1
200a834: 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];
200a838: 82 00 60 02 add %g1, 2, %g1
200a83c: 83 28 60 02 sll %g1, 2, %g1
while ( !stop && current != NULL ) {
200a840: 10 80 00 0a b 200a868 <_RBTree_Iterate_unprotected+0x40>
200a844: fa 06 00 01 ld [ %i0 + %g1 ], %i5
stop = (*visitor)( current, dir, visitor_arg );
200a848: 92 10 00 19 mov %i1, %o1
200a84c: 9f c6 80 00 call %i2
200a850: 94 10 00 1b mov %i3, %o2
current = _RBTree_Next_unprotected( current, dir );
200a854: 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 );
200a858: b8 10 00 08 mov %o0, %i4
current = _RBTree_Next_unprotected( current, dir );
200a85c: 40 00 00 0b call 200a888 <_RBTree_Next_unprotected>
200a860: 90 10 00 1d mov %i5, %o0
200a864: 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 ) {
200a868: 80 a7 60 00 cmp %i5, 0
200a86c: 02 80 00 05 be 200a880 <_RBTree_Iterate_unprotected+0x58>
200a870: b8 1f 20 01 xor %i4, 1, %i4
200a874: 80 8f 20 ff btst 0xff, %i4
200a878: 12 bf ff f4 bne 200a848 <_RBTree_Iterate_unprotected+0x20><== ALWAYS TAKEN
200a87c: 90 10 00 1d mov %i5, %o0
200a880: 81 c7 e0 08 ret
200a884: 81 e8 00 00 restore
0200a190 <_RBTree_Rotate>:
RBTree_Node *the_node,
RBTree_Direction dir
)
{
RBTree_Node *c;
if (the_node == NULL) return;
200a190: 80 a2 20 00 cmp %o0, 0
200a194: 02 80 00 1c be 200a204 <_RBTree_Rotate+0x74> <== NEVER TAKEN
200a198: 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);
200a19c: 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;
200a1a0: 87 28 e0 02 sll %g3, 2, %g3
200a1a4: 86 02 00 03 add %o0, %g3, %g3
200a1a8: c2 00 e0 04 ld [ %g3 + 4 ], %g1
200a1ac: 80 a0 60 00 cmp %g1, 0
200a1b0: 02 80 00 15 be 200a204 <_RBTree_Rotate+0x74> <== NEVER TAKEN
200a1b4: 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];
200a1b8: 84 00 40 09 add %g1, %o1, %g2
200a1bc: c8 00 a0 04 ld [ %g2 + 4 ], %g4
200a1c0: c8 20 e0 04 st %g4, [ %g3 + 4 ]
if (c->child[dir])
200a1c4: c4 00 a0 04 ld [ %g2 + 4 ], %g2
200a1c8: 80 a0 a0 00 cmp %g2, 0
200a1cc: 32 80 00 02 bne,a 200a1d4 <_RBTree_Rotate+0x44>
200a1d0: 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;
200a1d4: 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;
200a1d8: 92 00 40 09 add %g1, %o1, %o1
200a1dc: d0 22 60 04 st %o0, [ %o1 + 4 ]
the_node->parent->child[the_node != the_node->parent->child[0]] = c;
200a1e0: c6 00 a0 04 ld [ %g2 + 4 ], %g3
c->parent = the_node->parent;
200a1e4: 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;
200a1e8: 86 1a 00 03 xor %o0, %g3, %g3
c->parent = the_node->parent;
the_node->parent = c;
200a1ec: 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;
200a1f0: 80 a0 00 03 cmp %g0, %g3
200a1f4: 86 40 20 00 addx %g0, 0, %g3
200a1f8: 87 28 e0 02 sll %g3, 2, %g3
200a1fc: 86 00 80 03 add %g2, %g3, %g3
200a200: c2 20 e0 04 st %g1, [ %g3 + 4 ]
200a204: 81 c3 e0 08 retl
0200a140 <_RBTree_Sibling>:
*/
RTEMS_INLINE_ROUTINE RBTree_Node *_RBTree_Sibling(
const RBTree_Node *the_node
)
{
if(!the_node) return NULL;
200a140: 80 a2 20 00 cmp %o0, 0
200a144: 02 80 00 10 be 200a184 <_RBTree_Sibling+0x44> <== NEVER TAKEN
200a148: 82 10 20 00 clr %g1
if(!(the_node->parent)) return NULL;
200a14c: c4 02 00 00 ld [ %o0 ], %g2
200a150: 80 a0 a0 00 cmp %g2, 0
200a154: 22 80 00 0d be,a 200a188 <_RBTree_Sibling+0x48> <== NEVER TAKEN
200a158: 90 10 00 01 mov %g1, %o0 <== NOT EXECUTED
if(!(the_node->parent->parent)) return NULL;
200a15c: c2 00 80 00 ld [ %g2 ], %g1
200a160: 80 a0 60 00 cmp %g1, 0
200a164: 02 80 00 08 be 200a184 <_RBTree_Sibling+0x44>
200a168: 82 10 20 00 clr %g1
if(the_node == the_node->parent->child[RBT_LEFT])
200a16c: c2 00 a0 04 ld [ %g2 + 4 ], %g1
200a170: 80 a2 00 01 cmp %o0, %g1
200a174: 22 80 00 04 be,a 200a184 <_RBTree_Sibling+0x44>
200a178: c2 00 a0 08 ld [ %g2 + 8 ], %g1
return the_node->parent->child[RBT_RIGHT];
200a17c: 81 c3 e0 08 retl
200a180: 90 10 00 01 mov %g1, %o0
else
return the_node->parent->child[RBT_LEFT];
}
200a184: 90 10 00 01 mov %g1, %o0
200a188: 81 c3 e0 08 retl
02032cb4 <_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
)
{
2032cb4: 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;
2032cb8: 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 );
2032cbc: 7f ff 72 0c call 200f4ec <_TOD_Get_uptime>
2032cc0: 90 07 bf f8 add %fp, -8, %o0
const Timestamp64_Control *_start,
const Timestamp64_Control *_end,
Timestamp64_Control *_result
)
{
*_result = *_end - *_start;
2032cc4: c4 1e 20 50 ldd [ %i0 + 0x50 ], %g2
_Timestamp_Subtract(
2032cc8: 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;
2032ccc: 82 10 20 01 mov 1, %g1
2032cd0: 86 a3 40 03 subcc %o5, %g3, %g3
2032cd4: 84 63 00 02 subx %o4, %g2, %g2
2032cd8: 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) {
2032cdc: 05 00 81 89 sethi %hi(0x2062400), %g2
2032ce0: 84 10 a0 90 or %g2, 0x90, %g2 ! 2062490 <_Per_CPU_Information>
2032ce4: c6 00 a0 0c ld [ %g2 + 0xc ], %g3
2032ce8: 80 a6 c0 03 cmp %i3, %g3
2032cec: 12 80 00 15 bne 2032d40 <_Rate_monotonic_Get_status+0x8c>
2032cf0: f8 1e e0 80 ldd [ %i3 + 0x80 ], %i4
2032cf4: c4 18 a0 20 ldd [ %g2 + 0x20 ], %g2
2032cf8: 9a a3 40 03 subcc %o5, %g3, %o5
2032cfc: 98 63 00 02 subx %o4, %g2, %o4
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
2032d00: c4 1e 20 48 ldd [ %i0 + 0x48 ], %g2
static inline void _Timestamp64_implementation_Add_to(
Timestamp64_Control *_time,
const Timestamp64_Control *_add
)
{
*_time += *_add;
2032d04: ba 87 40 0d addcc %i5, %o5, %i5
2032d08: 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))
2032d0c: 80 a0 80 1c cmp %g2, %i4
2032d10: 34 80 00 0c bg,a 2032d40 <_Rate_monotonic_Get_status+0x8c><== NEVER TAKEN
2032d14: 82 10 20 00 clr %g1 <== NOT EXECUTED
2032d18: 32 80 00 06 bne,a 2032d30 <_Rate_monotonic_Get_status+0x7c>
2032d1c: 86 a7 40 03 subcc %i5, %g3, %g3
2032d20: 80 a0 c0 1d cmp %g3, %i5
2032d24: 18 80 00 06 bgu 2032d3c <_Rate_monotonic_Get_status+0x88>
2032d28: 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;
2032d2c: 82 10 20 01 mov 1, %g1
const Timestamp64_Control *_start,
const Timestamp64_Control *_end,
Timestamp64_Control *_result
)
{
*_result = *_end - *_start;
2032d30: 84 67 00 02 subx %i4, %g2, %g2
2032d34: 10 80 00 03 b 2032d40 <_Rate_monotonic_Get_status+0x8c>
2032d38: 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;
2032d3c: 82 10 20 00 clr %g1
return false;
*cpu_since_last_period = used - the_period->cpu_usage_period_initiated;
#endif
return true;
}
2032d40: b0 08 60 01 and %g1, 1, %i0
2032d44: 81 c7 e0 08 ret
2032d48: 81 e8 00 00 restore
020330ac <_Rate_monotonic_Timeout>:
void _Rate_monotonic_Timeout(
Objects_Id id,
void *ignored
)
{
20330ac: 9d e3 bf 98 save %sp, -104, %sp
20330b0: 11 00 81 8a sethi %hi(0x2062800), %o0
20330b4: 92 10 00 18 mov %i0, %o1
20330b8: 90 12 22 50 or %o0, 0x250, %o0
20330bc: 7f ff 57 b9 call 2008fa0 <_Objects_Get>
20330c0: 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 ) {
20330c4: c2 07 bf fc ld [ %fp + -4 ], %g1
20330c8: 80 a0 60 00 cmp %g1, 0
20330cc: 12 80 00 25 bne 2033160 <_Rate_monotonic_Timeout+0xb4> <== NEVER TAKEN
20330d0: ba 10 00 08 mov %o0, %i5
case OBJECTS_LOCAL:
the_thread = the_period->owner;
20330d4: d0 02 20 40 ld [ %o0 + 0x40 ], %o0
if ( _States_Is_waiting_for_period( the_thread->current_state ) &&
20330d8: 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);
20330dc: c4 02 20 10 ld [ %o0 + 0x10 ], %g2
20330e0: 80 88 80 01 btst %g2, %g1
20330e4: 22 80 00 0b be,a 2033110 <_Rate_monotonic_Timeout+0x64>
20330e8: c2 07 60 38 ld [ %i5 + 0x38 ], %g1
20330ec: c4 02 20 20 ld [ %o0 + 0x20 ], %g2
20330f0: c2 07 60 08 ld [ %i5 + 8 ], %g1
20330f4: 80 a0 80 01 cmp %g2, %g1
20330f8: 32 80 00 06 bne,a 2033110 <_Rate_monotonic_Timeout+0x64>
20330fc: 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 );
2033100: 13 04 00 ff sethi %hi(0x1003fc00), %o1
2033104: 7f ff 5a 73 call 2009ad0 <_Thread_Clear_state>
2033108: 92 12 63 f8 or %o1, 0x3f8, %o1 ! 1003fff8 <RAM_END+0xdc3fff8>
203310c: 30 80 00 06 b,a 2033124 <_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 ) {
2033110: 80 a0 60 01 cmp %g1, 1
2033114: 12 80 00 0d bne 2033148 <_Rate_monotonic_Timeout+0x9c>
2033118: 82 10 20 04 mov 4, %g1
the_period->state = RATE_MONOTONIC_EXPIRED_WHILE_BLOCKING;
203311c: 82 10 20 03 mov 3, %g1
2033120: c2 27 60 38 st %g1, [ %i5 + 0x38 ]
_Rate_monotonic_Initiate_statistics( the_period );
2033124: 7f ff ff 53 call 2032e70 <_Rate_monotonic_Initiate_statistics>
2033128: 90 10 00 1d mov %i5, %o0
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
203312c: c2 07 60 3c ld [ %i5 + 0x3c ], %g1
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
2033130: 11 00 81 88 sethi %hi(0x2062000), %o0
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
2033134: c2 27 60 1c st %g1, [ %i5 + 0x1c ]
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
2033138: 90 12 20 08 or %o0, 8, %o0
203313c: 7f ff 5e 90 call 200ab7c <_Watchdog_Insert>
2033140: 92 07 60 10 add %i5, 0x10, %o1
2033144: 30 80 00 02 b,a 203314c <_Rate_monotonic_Timeout+0xa0>
_Watchdog_Insert_ticks( &the_period->Timer, the_period->next_length );
} else
the_period->state = RATE_MONOTONIC_EXPIRED;
2033148: 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--;
203314c: 03 00 81 87 sethi %hi(0x2061c00), %g1
2033150: c4 00 63 60 ld [ %g1 + 0x360 ], %g2 ! 2061f60 <_Thread_Dispatch_disable_level>
2033154: 84 00 bf ff add %g2, -1, %g2
2033158: c4 20 63 60 st %g2, [ %g1 + 0x360 ]
return _Thread_Dispatch_disable_level;
203315c: c2 00 63 60 ld [ %g1 + 0x360 ], %g1
2033160: 81 c7 e0 08 ret
2033164: 81 e8 00 00 restore
02032d4c <_Rate_monotonic_Update_statistics>:
}
static void _Rate_monotonic_Update_statistics(
Rate_monotonic_Control *the_period
)
{
2032d4c: 9d e3 bf 90 save %sp, -112, %sp
/*
* Update the counts.
*/
stats = &the_period->Statistics;
stats->count++;
2032d50: c2 06 20 58 ld [ %i0 + 0x58 ], %g1
2032d54: 82 00 60 01 inc %g1
2032d58: c2 26 20 58 st %g1, [ %i0 + 0x58 ]
if ( the_period->state == RATE_MONOTONIC_EXPIRED )
2032d5c: c2 06 20 38 ld [ %i0 + 0x38 ], %g1
2032d60: 80 a0 60 04 cmp %g1, 4
2032d64: 12 80 00 05 bne 2032d78 <_Rate_monotonic_Update_statistics+0x2c>
2032d68: 90 10 00 18 mov %i0, %o0
stats->missed_count++;
2032d6c: c2 06 20 5c ld [ %i0 + 0x5c ], %g1
2032d70: 82 00 60 01 inc %g1
2032d74: c2 26 20 5c st %g1, [ %i0 + 0x5c ]
/*
* Grab status for time statistics.
*/
valid_status =
2032d78: 92 07 bf f8 add %fp, -8, %o1
2032d7c: 7f ff ff ce call 2032cb4 <_Rate_monotonic_Get_status>
2032d80: 94 07 bf f0 add %fp, -16, %o2
_Rate_monotonic_Get_status( the_period, &since_last_period, &executed );
if (!valid_status)
2032d84: 80 8a 20 ff btst 0xff, %o0
2032d88: 02 80 00 38 be 2032e68 <_Rate_monotonic_Update_statistics+0x11c>
2032d8c: c4 1f bf f0 ldd [ %fp + -16 ], %g2
static inline void _Timestamp64_implementation_Add_to(
Timestamp64_Control *_time,
const Timestamp64_Control *_add
)
{
*_time += *_add;
2032d90: 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 ) )
2032d94: c2 06 20 60 ld [ %i0 + 0x60 ], %g1
2032d98: ba 87 40 03 addcc %i5, %g3, %i5
2032d9c: b8 47 00 02 addx %i4, %g2, %i4
2032da0: 80 a0 40 02 cmp %g1, %g2
2032da4: 14 80 00 09 bg 2032dc8 <_Rate_monotonic_Update_statistics+0x7c>
2032da8: f8 3e 20 70 std %i4, [ %i0 + 0x70 ]
2032dac: 80 a0 40 02 cmp %g1, %g2
2032db0: 32 80 00 08 bne,a 2032dd0 <_Rate_monotonic_Update_statistics+0x84><== NEVER TAKEN
2032db4: c2 06 20 68 ld [ %i0 + 0x68 ], %g1 <== NOT EXECUTED
2032db8: c2 06 20 64 ld [ %i0 + 0x64 ], %g1
2032dbc: 80 a0 40 03 cmp %g1, %g3
2032dc0: 28 80 00 04 bleu,a 2032dd0 <_Rate_monotonic_Update_statistics+0x84>
2032dc4: c2 06 20 68 ld [ %i0 + 0x68 ], %g1
stats->min_cpu_time = executed;
2032dc8: c4 3e 20 60 std %g2, [ %i0 + 0x60 ]
if ( _Timestamp_Greater_than( &executed, &stats->max_cpu_time ) )
2032dcc: c2 06 20 68 ld [ %i0 + 0x68 ], %g1
2032dd0: 80 a0 40 02 cmp %g1, %g2
2032dd4: 26 80 00 0a bl,a 2032dfc <_Rate_monotonic_Update_statistics+0xb0><== NEVER TAKEN
2032dd8: c4 3e 20 68 std %g2, [ %i0 + 0x68 ] <== NOT EXECUTED
2032ddc: 80 a0 40 02 cmp %g1, %g2
2032de0: 32 80 00 08 bne,a 2032e00 <_Rate_monotonic_Update_statistics+0xb4><== NEVER TAKEN
2032de4: c4 1f bf f8 ldd [ %fp + -8 ], %g2 <== NOT EXECUTED
2032de8: c2 06 20 6c ld [ %i0 + 0x6c ], %g1
2032dec: 80 a0 40 03 cmp %g1, %g3
2032df0: 3a 80 00 04 bcc,a 2032e00 <_Rate_monotonic_Update_statistics+0xb4>
2032df4: c4 1f bf f8 ldd [ %fp + -8 ], %g2
stats->max_cpu_time = executed;
2032df8: 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 );
2032dfc: c4 1f bf f8 ldd [ %fp + -8 ], %g2
2032e00: f8 1e 20 88 ldd [ %i0 + 0x88 ], %i4
if ( _Timestamp_Less_than( &since_last_period, &stats->min_wall_time ) )
2032e04: c2 06 20 78 ld [ %i0 + 0x78 ], %g1
2032e08: ba 87 40 03 addcc %i5, %g3, %i5
2032e0c: b8 47 00 02 addx %i4, %g2, %i4
2032e10: 80 a0 40 02 cmp %g1, %g2
2032e14: 14 80 00 09 bg 2032e38 <_Rate_monotonic_Update_statistics+0xec>
2032e18: f8 3e 20 88 std %i4, [ %i0 + 0x88 ]
2032e1c: 80 a0 40 02 cmp %g1, %g2
2032e20: 32 80 00 08 bne,a 2032e40 <_Rate_monotonic_Update_statistics+0xf4><== NEVER TAKEN
2032e24: c2 06 20 80 ld [ %i0 + 0x80 ], %g1 <== NOT EXECUTED
2032e28: c2 06 20 7c ld [ %i0 + 0x7c ], %g1
2032e2c: 80 a0 40 03 cmp %g1, %g3
2032e30: 28 80 00 04 bleu,a 2032e40 <_Rate_monotonic_Update_statistics+0xf4>
2032e34: c2 06 20 80 ld [ %i0 + 0x80 ], %g1
stats->min_wall_time = since_last_period;
2032e38: c4 3e 20 78 std %g2, [ %i0 + 0x78 ]
if ( _Timestamp_Greater_than( &since_last_period, &stats->max_wall_time ) )
2032e3c: c2 06 20 80 ld [ %i0 + 0x80 ], %g1
2032e40: 80 a0 40 02 cmp %g1, %g2
2032e44: 26 80 00 09 bl,a 2032e68 <_Rate_monotonic_Update_statistics+0x11c><== NEVER TAKEN
2032e48: c4 3e 20 80 std %g2, [ %i0 + 0x80 ] <== NOT EXECUTED
2032e4c: 80 a0 40 02 cmp %g1, %g2
2032e50: 12 80 00 06 bne 2032e68 <_Rate_monotonic_Update_statistics+0x11c><== NEVER TAKEN
2032e54: 01 00 00 00 nop
2032e58: c2 06 20 84 ld [ %i0 + 0x84 ], %g1
2032e5c: 80 a0 40 03 cmp %g1, %g3
2032e60: 2a 80 00 02 bcs,a 2032e68 <_Rate_monotonic_Update_statistics+0x11c>
2032e64: c4 3e 20 80 std %g2, [ %i0 + 0x80 ]
2032e68: 81 c7 e0 08 ret
2032e6c: 81 e8 00 00 restore
0200b50c <_Scheduler_CBS_Budget_callout>:
Scheduler_CBS_Server **_Scheduler_CBS_Server_list;
void _Scheduler_CBS_Budget_callout(
Thread_Control *the_thread
)
{
200b50c: 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;
200b510: d2 06 20 ac ld [ %i0 + 0xac ], %o1
if ( the_thread->real_priority != new_priority )
200b514: c2 06 20 18 ld [ %i0 + 0x18 ], %g1
200b518: 80 a0 40 09 cmp %g1, %o1
200b51c: 32 80 00 02 bne,a 200b524 <_Scheduler_CBS_Budget_callout+0x18><== ALWAYS TAKEN
200b520: d2 26 20 18 st %o1, [ %i0 + 0x18 ]
the_thread->real_priority = new_priority;
if ( the_thread->current_priority != new_priority )
200b524: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
200b528: 80 a0 40 09 cmp %g1, %o1
200b52c: 02 80 00 04 be 200b53c <_Scheduler_CBS_Budget_callout+0x30><== NEVER TAKEN
200b530: 90 10 00 18 mov %i0, %o0
_Thread_Change_priority(the_thread, new_priority, true);
200b534: 40 00 01 8e call 200bb6c <_Thread_Change_priority>
200b538: 94 10 20 01 mov 1, %o2
/* Invoke callback function if any. */
sched_info = (Scheduler_CBS_Per_thread *) the_thread->scheduler_info;
200b53c: fa 06 20 88 ld [ %i0 + 0x88 ], %i5
if ( sched_info->cbs_server->cbs_budget_overrun ) {
200b540: c2 07 60 18 ld [ %i5 + 0x18 ], %g1
200b544: c4 00 60 0c ld [ %g1 + 0xc ], %g2
200b548: 80 a0 a0 00 cmp %g2, 0
200b54c: 02 80 00 09 be 200b570 <_Scheduler_CBS_Budget_callout+0x64><== NEVER TAKEN
200b550: 01 00 00 00 nop
_Scheduler_CBS_Get_server_id(
200b554: d0 00 40 00 ld [ %g1 ], %o0
200b558: 7f ff ff d7 call 200b4b4 <_Scheduler_CBS_Get_server_id>
200b55c: 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 );
200b560: c2 07 60 18 ld [ %i5 + 0x18 ], %g1
200b564: c2 00 60 0c ld [ %g1 + 0xc ], %g1
200b568: 9f c0 40 00 call %g1
200b56c: d0 07 bf fc ld [ %fp + -4 ], %o0
200b570: 81 c7 e0 08 ret
200b574: 81 e8 00 00 restore
0200b114 <_Scheduler_CBS_Create_server>:
int _Scheduler_CBS_Create_server (
Scheduler_CBS_Parameters *params,
Scheduler_CBS_Budget_overrun budget_overrun_callback,
rtems_id *server_id
)
{
200b114: 9d e3 bf a0 save %sp, -96, %sp
unsigned int i;
Scheduler_CBS_Server *the_server;
if ( params->budget <= 0 ||
200b118: c2 06 20 04 ld [ %i0 + 4 ], %g1
200b11c: 80 a0 60 00 cmp %g1, 0
200b120: 04 80 00 1d ble 200b194 <_Scheduler_CBS_Create_server+0x80>
200b124: 01 00 00 00 nop
200b128: c2 06 00 00 ld [ %i0 ], %g1
200b12c: 80 a0 60 00 cmp %g1, 0
200b130: 04 80 00 19 ble 200b194 <_Scheduler_CBS_Create_server+0x80>
200b134: 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++ ) {
200b138: c4 00 60 bc ld [ %g1 + 0xbc ], %g2 ! 20204bc <_Scheduler_CBS_Maximum_servers>
if ( !_Scheduler_CBS_Server_list[i] )
200b13c: 03 00 80 85 sethi %hi(0x2021400), %g1
200b140: c6 00 63 88 ld [ %g1 + 0x388 ], %g3 ! 2021788 <_Scheduler_CBS_Server_list>
200b144: 10 80 00 07 b 200b160 <_Scheduler_CBS_Create_server+0x4c>
200b148: 82 10 20 00 clr %g1
200b14c: c8 00 c0 1c ld [ %g3 + %i4 ], %g4
200b150: 80 a1 20 00 cmp %g4, 0
200b154: 02 80 00 14 be 200b1a4 <_Scheduler_CBS_Create_server+0x90>
200b158: 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++ ) {
200b15c: 82 00 60 01 inc %g1
200b160: 80 a0 40 02 cmp %g1, %g2
200b164: 12 bf ff fa bne 200b14c <_Scheduler_CBS_Create_server+0x38>
200b168: 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;
200b16c: 81 c7 e0 08 ret
200b170: 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;
200b174: c4 20 60 04 st %g2, [ %g1 + 4 ]
200b178: c4 06 20 04 ld [ %i0 + 4 ], %g2
the_server->task_id = -1;
the_server->cbs_budget_overrun = budget_overrun_callback;
200b17c: 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;
200b180: c4 20 60 08 st %g2, [ %g1 + 8 ]
the_server->task_id = -1;
200b184: 84 10 3f ff mov -1, %g2
200b188: c4 20 40 00 st %g2, [ %g1 ]
the_server->cbs_budget_overrun = budget_overrun_callback;
return SCHEDULER_CBS_OK;
200b18c: 81 c7 e0 08 ret
200b190: 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;
200b194: 81 c7 e0 08 ret
200b198: 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;
200b19c: 81 c7 e0 08 ret <== NOT EXECUTED
200b1a0: 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 *)
200b1a4: f6 07 63 88 ld [ %i5 + 0x388 ], %i3
}
if ( i == _Scheduler_CBS_Maximum_servers )
return SCHEDULER_CBS_ERROR_FULL;
*server_id = i;
200b1a8: c2 26 80 00 st %g1, [ %i2 ]
_Scheduler_CBS_Server_list[*server_id] = (Scheduler_CBS_Server *)
_Workspace_Allocate( sizeof(Scheduler_CBS_Server) );
200b1ac: 40 00 07 a9 call 200d050 <_Workspace_Allocate>
200b1b0: 90 10 20 10 mov 0x10, %o0
the_server = _Scheduler_CBS_Server_list[*server_id];
200b1b4: 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 *)
200b1b8: d0 26 c0 1c st %o0, [ %i3 + %i4 ]
_Workspace_Allocate( sizeof(Scheduler_CBS_Server) );
the_server = _Scheduler_CBS_Server_list[*server_id];
200b1bc: c4 07 63 88 ld [ %i5 + 0x388 ], %g2
200b1c0: 83 28 60 02 sll %g1, 2, %g1
200b1c4: c2 00 80 01 ld [ %g2 + %g1 ], %g1
if ( !the_server )
200b1c8: 80 a0 60 00 cmp %g1, 0
200b1cc: 32 bf ff ea bne,a 200b174 <_Scheduler_CBS_Create_server+0x60><== ALWAYS TAKEN
200b1d0: c4 06 00 00 ld [ %i0 ], %g2
200b1d4: 30 bf ff f2 b,a 200b19c <_Scheduler_CBS_Create_server+0x88><== NOT EXECUTED
0200b24c <_Scheduler_CBS_Detach_thread>:
int _Scheduler_CBS_Detach_thread (
Scheduler_CBS_Server_id server_id,
rtems_id task_id
)
{
200b24c: 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);
200b250: 90 10 00 19 mov %i1, %o0
200b254: 40 00 03 78 call 200c034 <_Thread_Get>
200b258: 92 07 bf fc add %fp, -4, %o1
/* The routine _Thread_Get may disable dispatch and not enable again. */
if ( the_thread ) {
200b25c: ba 92 20 00 orcc %o0, 0, %i5
200b260: 02 80 00 05 be 200b274 <_Scheduler_CBS_Detach_thread+0x28>
200b264: 03 00 80 81 sethi %hi(0x2020400), %g1
_Thread_Enable_dispatch();
200b268: 40 00 03 66 call 200c000 <_Thread_Enable_dispatch>
200b26c: 01 00 00 00 nop
}
if ( server_id >= _Scheduler_CBS_Maximum_servers )
200b270: 03 00 80 81 sethi %hi(0x2020400), %g1
200b274: c2 00 60 bc ld [ %g1 + 0xbc ], %g1 ! 20204bc <_Scheduler_CBS_Maximum_servers>
200b278: 80 a6 00 01 cmp %i0, %g1
200b27c: 1a 80 00 1b bcc 200b2e8 <_Scheduler_CBS_Detach_thread+0x9c>
200b280: 80 a7 60 00 cmp %i5, 0
return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;
if ( !the_thread )
200b284: 02 80 00 19 be 200b2e8 <_Scheduler_CBS_Detach_thread+0x9c>
200b288: 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] )
200b28c: c2 00 63 88 ld [ %g1 + 0x388 ], %g1 ! 2021788 <_Scheduler_CBS_Server_list>
200b290: b1 2e 20 02 sll %i0, 2, %i0
200b294: c2 00 40 18 ld [ %g1 + %i0 ], %g1
200b298: 80 a0 60 00 cmp %g1, 0
200b29c: 02 80 00 11 be 200b2e0 <_Scheduler_CBS_Detach_thread+0x94>
200b2a0: 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 )
200b2a4: c4 00 40 00 ld [ %g1 ], %g2
200b2a8: 80 a0 80 19 cmp %g2, %i1
200b2ac: 12 80 00 0f bne 200b2e8 <_Scheduler_CBS_Detach_thread+0x9c><== NEVER TAKEN
200b2b0: 84 10 3f ff mov -1, %g2
return SCHEDULER_CBS_ERROR_INVALID_PARAMETER;
_Scheduler_CBS_Server_list[server_id]->task_id = -1;
200b2b4: c4 20 40 00 st %g2, [ %g1 ]
sched_info = (Scheduler_CBS_Per_thread *) the_thread->scheduler_info;
sched_info->cbs_server = NULL;
200b2b8: c2 07 60 88 ld [ %i5 + 0x88 ], %g1
200b2bc: c0 20 60 18 clr [ %g1 + 0x18 ]
the_thread->budget_algorithm = the_thread->Start.budget_algorithm;
200b2c0: c2 07 60 a0 ld [ %i5 + 0xa0 ], %g1
200b2c4: c2 27 60 78 st %g1, [ %i5 + 0x78 ]
the_thread->budget_callout = the_thread->Start.budget_callout;
200b2c8: c2 07 60 a4 ld [ %i5 + 0xa4 ], %g1
200b2cc: c2 27 60 7c st %g1, [ %i5 + 0x7c ]
the_thread->is_preemptible = the_thread->Start.is_preemptible;
200b2d0: c2 0f 60 9c ldub [ %i5 + 0x9c ], %g1
200b2d4: c2 2f 60 70 stb %g1, [ %i5 + 0x70 ]
return SCHEDULER_CBS_OK;
200b2d8: 81 c7 e0 08 ret
200b2dc: 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;
200b2e0: 81 c7 e0 08 ret
200b2e4: 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;
}
200b2e8: 81 c7 e0 08 ret
200b2ec: 91 e8 3f ee restore %g0, -18, %o0
0200b578 <_Scheduler_CBS_Initialize>:
}
}
int _Scheduler_CBS_Initialize(void)
{
200b578: 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*) );
200b57c: 3b 00 80 81 sethi %hi(0x2020400), %i5
200b580: 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(
200b584: 40 00 06 b3 call 200d050 <_Workspace_Allocate>
200b588: 91 2a 20 02 sll %o0, 2, %o0
200b58c: 05 00 80 85 sethi %hi(0x2021400), %g2
_Scheduler_CBS_Maximum_servers * sizeof(Scheduler_CBS_Server*) );
if ( !_Scheduler_CBS_Server_list )
200b590: 80 a2 20 00 cmp %o0, 0
200b594: 02 80 00 0d be 200b5c8 <_Scheduler_CBS_Initialize+0x50> <== NEVER TAKEN
200b598: d0 20 a3 88 st %o0, [ %g2 + 0x388 ]
return SCHEDULER_CBS_ERROR_NO_MEMORY;
for (i = 0; i<_Scheduler_CBS_Maximum_servers; i++) {
200b59c: c6 07 60 bc ld [ %i5 + 0xbc ], %g3
200b5a0: 10 80 00 05 b 200b5b4 <_Scheduler_CBS_Initialize+0x3c>
200b5a4: 82 10 20 00 clr %g1
_Scheduler_CBS_Server_list[i] = NULL;
200b5a8: 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++) {
200b5ac: 82 00 60 01 inc %g1
_Scheduler_CBS_Server_list[i] = NULL;
200b5b0: 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++) {
200b5b4: 80 a0 40 03 cmp %g1, %g3
200b5b8: 12 bf ff fc bne 200b5a8 <_Scheduler_CBS_Initialize+0x30>
200b5bc: fa 00 a3 88 ld [ %g2 + 0x388 ], %i5
_Scheduler_CBS_Server_list[i] = NULL;
}
return SCHEDULER_CBS_OK;
200b5c0: 81 c7 e0 08 ret
200b5c4: 91 e8 20 00 restore %g0, 0, %o0
}
200b5c8: 81 c7 e0 08 ret <== NOT EXECUTED
200b5cc: 91 e8 3f ef restore %g0, -17, %o0 <== NOT EXECUTED
0200a1c0 <_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;
200a1c0: c2 02 20 88 ld [ %o0 + 0x88 ], %g1
if (deadline) {
200a1c4: 80 a2 60 00 cmp %o1, 0
200a1c8: 02 80 00 10 be 200a208 <_Scheduler_CBS_Release_job+0x48>
200a1cc: c2 00 60 18 ld [ %g1 + 0x18 ], %g1
/* Initializing or shifting deadline. */
if (serv_info)
200a1d0: 80 a0 60 00 cmp %g1, 0
200a1d4: 02 80 00 08 be 200a1f4 <_Scheduler_CBS_Release_job+0x34>
200a1d8: 05 00 80 7d sethi %hi(0x201f400), %g2
new_priority = (_Watchdog_Ticks_since_boot + serv_info->parameters.deadline)
200a1dc: d2 00 a3 e8 ld [ %g2 + 0x3e8 ], %o1 ! 201f7e8 <_Watchdog_Ticks_since_boot>
200a1e0: c4 00 60 04 ld [ %g1 + 4 ], %g2
200a1e4: 92 02 40 02 add %o1, %g2, %o1
200a1e8: 05 20 00 00 sethi %hi(0x80000000), %g2
200a1ec: 10 80 00 0a b 200a214 <_Scheduler_CBS_Release_job+0x54>
200a1f0: 92 2a 40 02 andn %o1, %g2, %o1
& ~SCHEDULER_EDF_PRIO_MSB;
else
new_priority = (_Watchdog_Ticks_since_boot + deadline)
200a1f4: c2 00 a3 e8 ld [ %g2 + 0x3e8 ], %g1
200a1f8: 92 02 40 01 add %o1, %g1, %o1
200a1fc: 03 20 00 00 sethi %hi(0x80000000), %g1
200a200: 10 80 00 07 b 200a21c <_Scheduler_CBS_Release_job+0x5c>
200a204: 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)
200a208: 80 a0 60 00 cmp %g1, 0
200a20c: 02 80 00 04 be 200a21c <_Scheduler_CBS_Release_job+0x5c> <== NEVER TAKEN
200a210: d2 02 20 ac ld [ %o0 + 0xac ], %o1
the_thread->cpu_time_budget = serv_info->parameters.budget;
200a214: c2 00 60 08 ld [ %g1 + 8 ], %g1
200a218: c2 22 20 74 st %g1, [ %o0 + 0x74 ]
the_thread->real_priority = new_priority;
200a21c: d2 22 20 18 st %o1, [ %o0 + 0x18 ]
_Thread_Change_priority(the_thread, new_priority, true);
200a220: 94 10 20 01 mov 1, %o2
200a224: 82 13 c0 00 mov %o7, %g1
200a228: 40 00 01 31 call 200a6ec <_Thread_Change_priority>
200a22c: 9e 10 40 00 mov %g1, %o7
0200a230 <_Scheduler_CBS_Unblock>:
#include <rtems/score/schedulercbs.h>
void _Scheduler_CBS_Unblock(
Thread_Control *the_thread
)
{
200a230: 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);
200a234: 40 00 00 57 call 200a390 <_Scheduler_EDF_Enqueue>
200a238: 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;
200a23c: c2 06 20 88 ld [ %i0 + 0x88 ], %g1
200a240: 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) {
200a244: 80 a7 60 00 cmp %i5, 0
200a248: 02 80 00 18 be 200a2a8 <_Scheduler_CBS_Unblock+0x78>
200a24c: 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 ) {
200a250: 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 -
200a254: d0 00 63 e8 ld [ %g1 + 0x3e8 ], %o0
200a258: f8 06 20 18 ld [ %i0 + 0x18 ], %i4
_Watchdog_Ticks_since_boot;
if ( deadline*budget_left > budget*deadline_left ) {
200a25c: 40 00 3f c1 call 201a160 <.umul>
200a260: 90 27 00 08 sub %i4, %o0, %o0
200a264: d2 06 20 74 ld [ %i0 + 0x74 ], %o1
200a268: b6 10 00 08 mov %o0, %i3
200a26c: 40 00 3f bd call 201a160 <.umul>
200a270: d0 07 60 08 ld [ %i5 + 8 ], %o0
200a274: 80 a6 c0 08 cmp %i3, %o0
200a278: 24 80 00 0d ble,a 200a2ac <_Scheduler_CBS_Unblock+0x7c>
200a27c: 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;
200a280: d2 06 20 ac ld [ %i0 + 0xac ], %o1
if ( the_thread->real_priority != new_priority )
200a284: 80 a7 00 09 cmp %i4, %o1
200a288: 32 80 00 02 bne,a 200a290 <_Scheduler_CBS_Unblock+0x60>
200a28c: d2 26 20 18 st %o1, [ %i0 + 0x18 ]
the_thread->real_priority = new_priority;
if ( the_thread->current_priority != new_priority )
200a290: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
200a294: 80 a0 40 09 cmp %g1, %o1
200a298: 02 80 00 04 be 200a2a8 <_Scheduler_CBS_Unblock+0x78>
200a29c: 90 10 00 18 mov %i0, %o0
_Thread_Change_priority(the_thread, new_priority, true);
200a2a0: 40 00 01 13 call 200a6ec <_Thread_Change_priority>
200a2a4: 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,
200a2a8: 3b 00 80 7f sethi %hi(0x201fc00), %i5
200a2ac: ba 17 60 20 or %i5, 0x20, %i5 ! 201fc20 <_Per_CPU_Information>
200a2b0: c4 07 60 10 ld [ %i5 + 0x10 ], %g2
200a2b4: 03 00 80 7a sethi %hi(0x201e800), %g1
200a2b8: d0 06 20 14 ld [ %i0 + 0x14 ], %o0
200a2bc: c2 00 61 b0 ld [ %g1 + 0x1b0 ], %g1
200a2c0: 9f c0 40 00 call %g1
200a2c4: d2 00 a0 14 ld [ %g2 + 0x14 ], %o1
200a2c8: 80 a2 20 00 cmp %o0, 0
200a2cc: 04 80 00 0f ble 200a308 <_Scheduler_CBS_Unblock+0xd8>
200a2d0: 01 00 00 00 nop
_Thread_Heir->current_priority)) {
_Thread_Heir = the_thread;
if ( _Thread_Executing->is_preemptible ||
200a2d4: 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;
200a2d8: f0 27 60 10 st %i0, [ %i5 + 0x10 ]
if ( _Thread_Executing->is_preemptible ||
200a2dc: c2 08 60 70 ldub [ %g1 + 0x70 ], %g1
200a2e0: 80 a0 60 00 cmp %g1, 0
200a2e4: 12 80 00 06 bne 200a2fc <_Scheduler_CBS_Unblock+0xcc>
200a2e8: 84 10 20 01 mov 1, %g2
200a2ec: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
200a2f0: 80 a0 60 00 cmp %g1, 0
200a2f4: 12 80 00 05 bne 200a308 <_Scheduler_CBS_Unblock+0xd8> <== ALWAYS TAKEN
200a2f8: 01 00 00 00 nop
the_thread->current_priority == 0 )
_Thread_Dispatch_necessary = true;
200a2fc: 03 00 80 7f sethi %hi(0x201fc00), %g1
200a300: 82 10 60 20 or %g1, 0x20, %g1 ! 201fc20 <_Per_CPU_Information>
200a304: c4 28 60 18 stb %g2, [ %g1 + 0x18 ]
200a308: 81 c7 e0 08 ret
200a30c: 81 e8 00 00 restore
0200a310 <_Scheduler_EDF_Allocate>:
#include <rtems/score/wkspace.h>
void *_Scheduler_EDF_Allocate(
Thread_Control *the_thread
)
{
200a310: 9d e3 bf a0 save %sp, -96, %sp
void *sched;
Scheduler_EDF_Per_thread *schinfo;
sched = _Workspace_Allocate( sizeof(Scheduler_EDF_Per_thread) );
200a314: 40 00 06 57 call 200bc70 <_Workspace_Allocate>
200a318: 90 10 20 18 mov 0x18, %o0
if ( sched ) {
200a31c: 80 a2 20 00 cmp %o0, 0
200a320: 02 80 00 05 be 200a334 <_Scheduler_EDF_Allocate+0x24> <== NEVER TAKEN
200a324: 82 10 20 02 mov 2, %g1
the_thread->scheduler_info = sched;
200a328: d0 26 20 88 st %o0, [ %i0 + 0x88 ]
schinfo = (Scheduler_EDF_Per_thread *)(the_thread->scheduler_info);
schinfo->thread = the_thread;
200a32c: f0 22 00 00 st %i0, [ %o0 ]
schinfo->queue_state = SCHEDULER_EDF_QUEUE_STATE_NEVER_HAS_BEEN;
200a330: c2 22 20 14 st %g1, [ %o0 + 0x14 ]
}
return sched;
}
200a334: 81 c7 e0 08 ret
200a338: 91 e8 00 08 restore %g0, %o0, %o0
0200a388 <_Scheduler_EDF_Unblock>:
#include <rtems/score/scheduleredf.h>
void _Scheduler_EDF_Unblock(
Thread_Control *the_thread
)
{
200a388: 9d e3 bf a0 save %sp, -96, %sp
_Scheduler_EDF_Enqueue(the_thread);
200a38c: 7f ff ff ad call 200a240 <_Scheduler_EDF_Enqueue>
200a390: 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(
200a394: 3b 00 80 7e sethi %hi(0x201f800), %i5
200a398: ba 17 63 70 or %i5, 0x370, %i5 ! 201fb70 <_Per_CPU_Information>
200a39c: c4 07 60 10 ld [ %i5 + 0x10 ], %g2
200a3a0: 03 00 80 7a sethi %hi(0x201e800), %g1
200a3a4: d0 00 a0 14 ld [ %g2 + 0x14 ], %o0
200a3a8: c2 00 61 00 ld [ %g1 + 0x100 ], %g1
200a3ac: 9f c0 40 00 call %g1
200a3b0: d2 06 20 14 ld [ %i0 + 0x14 ], %o1
200a3b4: 80 a2 20 00 cmp %o0, 0
200a3b8: 16 80 00 0f bge 200a3f4 <_Scheduler_EDF_Unblock+0x6c>
200a3bc: 01 00 00 00 nop
_Thread_Heir->current_priority,
the_thread->current_priority )) {
_Thread_Heir = the_thread;
if ( _Thread_Executing->is_preemptible ||
200a3c0: 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;
200a3c4: f0 27 60 10 st %i0, [ %i5 + 0x10 ]
if ( _Thread_Executing->is_preemptible ||
200a3c8: c2 08 60 70 ldub [ %g1 + 0x70 ], %g1
200a3cc: 80 a0 60 00 cmp %g1, 0
200a3d0: 12 80 00 06 bne 200a3e8 <_Scheduler_EDF_Unblock+0x60>
200a3d4: 84 10 20 01 mov 1, %g2
200a3d8: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
200a3dc: 80 a0 60 00 cmp %g1, 0
200a3e0: 12 80 00 05 bne 200a3f4 <_Scheduler_EDF_Unblock+0x6c> <== ALWAYS TAKEN
200a3e4: 01 00 00 00 nop
the_thread->current_priority == 0 )
_Thread_Dispatch_necessary = true;
200a3e8: 03 00 80 7e sethi %hi(0x201f800), %g1
200a3ec: 82 10 63 70 or %g1, 0x370, %g1 ! 201fb70 <_Per_CPU_Information>
200a3f0: c4 28 60 18 stb %g2, [ %g1 + 0x18 ]
200a3f4: 81 c7 e0 08 ret
200a3f8: 81 e8 00 00 restore
02009a7c <_Scheduler_priority_Tick>:
#include <rtems/system.h>
#include <rtems/score/schedulerpriority.h>
void _Scheduler_priority_Tick( void )
{
2009a7c: 9d e3 bf a0 save %sp, -96, %sp
Thread_Control *executing;
executing = _Thread_Executing;
2009a80: 03 00 80 78 sethi %hi(0x201e000), %g1
2009a84: fa 00 60 2c ld [ %g1 + 0x2c ], %i5 ! 201e02c <_Per_CPU_Information+0xc>
/*
* If the thread is not preemptible or is not ready, then
* just return.
*/
if ( !executing->is_preemptible )
2009a88: c2 0f 60 70 ldub [ %i5 + 0x70 ], %g1
2009a8c: 80 a0 60 00 cmp %g1, 0
2009a90: 02 80 00 25 be 2009b24 <_Scheduler_priority_Tick+0xa8>
2009a94: 01 00 00 00 nop
return;
if ( !_States_Is_ready( executing->current_state ) )
2009a98: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
2009a9c: 80 a0 60 00 cmp %g1, 0
2009aa0: 12 80 00 21 bne 2009b24 <_Scheduler_priority_Tick+0xa8>
2009aa4: 01 00 00 00 nop
/*
* The cpu budget algorithm determines what happens next.
*/
switch ( executing->budget_algorithm ) {
2009aa8: c2 07 60 78 ld [ %i5 + 0x78 ], %g1
2009aac: 80 a0 60 01 cmp %g1, 1
2009ab0: 0a 80 00 14 bcs 2009b00 <_Scheduler_priority_Tick+0x84>
2009ab4: 80 a0 60 02 cmp %g1, 2
2009ab8: 28 80 00 07 bleu,a 2009ad4 <_Scheduler_priority_Tick+0x58>
2009abc: c2 07 60 74 ld [ %i5 + 0x74 ], %g1
2009ac0: 80 a0 60 03 cmp %g1, 3
2009ac4: 12 80 00 18 bne 2009b24 <_Scheduler_priority_Tick+0xa8> <== NEVER TAKEN
2009ac8: 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 )
2009acc: 10 80 00 0f b 2009b08 <_Scheduler_priority_Tick+0x8c>
2009ad0: 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 ) {
2009ad4: 82 00 7f ff add %g1, -1, %g1
2009ad8: 80 a0 60 00 cmp %g1, 0
2009adc: 14 80 00 09 bg 2009b00 <_Scheduler_priority_Tick+0x84>
2009ae0: 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();
2009ae4: 03 00 80 73 sethi %hi(0x201cc00), %g1
2009ae8: c2 00 61 fc ld [ %g1 + 0x1fc ], %g1 ! 201cdfc <_Scheduler+0xc>
2009aec: 9f c0 40 00 call %g1
2009af0: 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;
2009af4: 03 00 80 76 sethi %hi(0x201d800), %g1
2009af8: c2 00 62 50 ld [ %g1 + 0x250 ], %g1 ! 201da50 <_Thread_Ticks_per_timeslice>
2009afc: c2 27 60 74 st %g1, [ %i5 + 0x74 ]
2009b00: 81 c7 e0 08 ret
2009b04: 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 )
2009b08: 82 00 7f ff add %g1, -1, %g1
2009b0c: 80 a0 60 00 cmp %g1, 0
2009b10: 12 bf ff fc bne 2009b00 <_Scheduler_priority_Tick+0x84>
2009b14: c2 27 60 74 st %g1, [ %i5 + 0x74 ]
(*executing->budget_callout)( executing );
2009b18: c2 07 60 7c ld [ %i5 + 0x7c ], %g1
2009b1c: 9f c0 40 00 call %g1
2009b20: 90 10 00 1d mov %i5, %o0
2009b24: 81 c7 e0 08 ret
2009b28: 81 e8 00 00 restore
020086ac <_TOD_Validate>:
*/
bool _TOD_Validate(
const rtems_time_of_day *the_tod
)
{
20086ac: 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 /
20086b0: 03 00 80 7d sethi %hi(0x201f400), %g1
20086b4: d2 00 60 1c ld [ %g1 + 0x1c ], %o1 ! 201f41c <Configuration+0x10>
20086b8: 11 00 03 d0 sethi %hi(0xf4000), %o0
20086bc: 40 00 48 90 call 201a8fc <.udiv>
20086c0: 90 12 22 40 or %o0, 0x240, %o0 ! f4240 <PROM_START+0xf4240>
rtems_configuration_get_microseconds_per_tick();
if ((!the_tod) ||
20086c4: 80 a6 20 00 cmp %i0, 0
20086c8: 02 80 00 28 be 2008768 <_TOD_Validate+0xbc> <== NEVER TAKEN
20086cc: 84 10 20 00 clr %g2
20086d0: c2 06 20 18 ld [ %i0 + 0x18 ], %g1
20086d4: 80 a0 40 08 cmp %g1, %o0
20086d8: 3a 80 00 25 bcc,a 200876c <_TOD_Validate+0xc0>
20086dc: b0 08 a0 01 and %g2, 1, %i0
(the_tod->ticks >= ticks_per_second) ||
20086e0: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
20086e4: 80 a0 60 3b cmp %g1, 0x3b
20086e8: 38 80 00 21 bgu,a 200876c <_TOD_Validate+0xc0>
20086ec: b0 08 a0 01 and %g2, 1, %i0
(the_tod->second >= TOD_SECONDS_PER_MINUTE) ||
20086f0: c2 06 20 10 ld [ %i0 + 0x10 ], %g1
20086f4: 80 a0 60 3b cmp %g1, 0x3b
20086f8: 38 80 00 1d bgu,a 200876c <_TOD_Validate+0xc0>
20086fc: b0 08 a0 01 and %g2, 1, %i0
(the_tod->minute >= TOD_MINUTES_PER_HOUR) ||
2008700: c2 06 20 0c ld [ %i0 + 0xc ], %g1
2008704: 80 a0 60 17 cmp %g1, 0x17
2008708: 38 80 00 19 bgu,a 200876c <_TOD_Validate+0xc0>
200870c: b0 08 a0 01 and %g2, 1, %i0
(the_tod->hour >= TOD_HOURS_PER_DAY) ||
(the_tod->month == 0) ||
2008710: 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) ||
2008714: 80 a0 60 00 cmp %g1, 0
2008718: 02 80 00 14 be 2008768 <_TOD_Validate+0xbc> <== NEVER TAKEN
200871c: 80 a0 60 0c cmp %g1, 0xc
(the_tod->month == 0) ||
2008720: 38 80 00 13 bgu,a 200876c <_TOD_Validate+0xc0>
2008724: b0 08 a0 01 and %g2, 1, %i0
(the_tod->month > TOD_MONTHS_PER_YEAR) ||
(the_tod->year < TOD_BASE_YEAR) ||
2008728: 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) ||
200872c: 80 a1 27 c3 cmp %g4, 0x7c3
2008730: 28 80 00 0f bleu,a 200876c <_TOD_Validate+0xc0>
2008734: b0 08 a0 01 and %g2, 1, %i0
(the_tod->year < TOD_BASE_YEAR) ||
(the_tod->day == 0) )
2008738: 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) ||
200873c: 80 a0 e0 00 cmp %g3, 0
2008740: 02 80 00 0a be 2008768 <_TOD_Validate+0xbc> <== NEVER TAKEN
2008744: 80 89 20 03 btst 3, %g4
2008748: 05 00 80 77 sethi %hi(0x201dc00), %g2
(the_tod->day == 0) )
return false;
if ( (the_tod->year % 4) == 0 )
200874c: 12 80 00 03 bne 2008758 <_TOD_Validate+0xac>
2008750: 84 10 a2 58 or %g2, 0x258, %g2 ! 201de58 <_TOD_Days_per_month>
days_in_month = _TOD_Days_per_month[ 1 ][ the_tod->month ];
2008754: 82 00 60 0d add %g1, 0xd, %g1
else
days_in_month = _TOD_Days_per_month[ 0 ][ the_tod->month ];
2008758: 83 28 60 02 sll %g1, 2, %g1
200875c: c2 00 80 01 ld [ %g2 + %g1 ], %g1
if ( the_tod->day > days_in_month )
2008760: 80 a0 40 03 cmp %g1, %g3
2008764: 84 60 3f ff subx %g0, -1, %g2
return false;
return true;
}
2008768: b0 08 a0 01 and %g2, 1, %i0
200876c: 81 c7 e0 08 ret
2008770: 81 e8 00 00 restore
02009d38 <_Thread_Change_priority>:
void _Thread_Change_priority(
Thread_Control *the_thread,
Priority_Control new_priority,
bool prepend_it
)
{
2009d38: 9d e3 bf a0 save %sp, -96, %sp
2009d3c: ba 10 00 18 mov %i0, %i5
States_Control state, original_state;
/*
* Save original state
*/
original_state = the_thread->current_state;
2009d40: 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 );
2009d44: 40 00 03 6a call 200aaec <_Thread_Set_transient>
2009d48: 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 )
2009d4c: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
2009d50: 80 a0 40 19 cmp %g1, %i1
2009d54: 02 80 00 04 be 2009d64 <_Thread_Change_priority+0x2c>
2009d58: 90 10 00 1d mov %i5, %o0
_Thread_Set_priority( the_thread, new_priority );
2009d5c: 40 00 03 4b call 200aa88 <_Thread_Set_priority>
2009d60: 92 10 00 19 mov %i1, %o1
_ISR_Disable( level );
2009d64: 7f ff e2 58 call 20026c4 <sparc_disable_interrupts>
2009d68: 01 00 00 00 nop
2009d6c: 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;
2009d70: f8 07 60 10 ld [ %i5 + 0x10 ], %i4
if ( state != STATES_TRANSIENT ) {
2009d74: 80 a7 20 04 cmp %i4, 4
2009d78: 02 80 00 10 be 2009db8 <_Thread_Change_priority+0x80>
2009d7c: 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 ) )
2009d80: 80 a0 60 00 cmp %g1, 0
2009d84: 12 80 00 03 bne 2009d90 <_Thread_Change_priority+0x58> <== NEVER TAKEN
2009d88: 82 0f 3f fb and %i4, -5, %g1
the_thread->current_state = _States_Clear( STATES_TRANSIENT, state );
2009d8c: c2 27 60 10 st %g1, [ %i5 + 0x10 ]
_ISR_Enable( level );
2009d90: 7f ff e2 51 call 20026d4 <sparc_enable_interrupts>
2009d94: 90 10 00 1b mov %i3, %o0
if ( _States_Is_waiting_on_thread_queue( state ) ) {
2009d98: 03 00 00 ef sethi %hi(0x3bc00), %g1
2009d9c: 82 10 62 e0 or %g1, 0x2e0, %g1 ! 3bee0 <PROM_START+0x3bee0>
2009da0: 80 8f 00 01 btst %i4, %g1
2009da4: 02 80 00 28 be 2009e44 <_Thread_Change_priority+0x10c>
2009da8: 01 00 00 00 nop
_Thread_queue_Requeue( the_thread->Wait.queue, the_thread );
2009dac: f0 07 60 44 ld [ %i5 + 0x44 ], %i0
2009db0: 40 00 03 08 call 200a9d0 <_Thread_queue_Requeue>
2009db4: 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 ) ) {
2009db8: 80 a0 60 00 cmp %g1, 0
2009dbc: 12 80 00 0b bne 2009de8 <_Thread_Change_priority+0xb0> <== NEVER TAKEN
2009dc0: 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 );
2009dc4: c0 27 60 10 clr [ %i5 + 0x10 ]
if ( prepend_it )
2009dc8: 80 a6 a0 00 cmp %i2, 0
2009dcc: 02 80 00 04 be 2009ddc <_Thread_Change_priority+0xa4>
2009dd0: 82 10 61 f0 or %g1, 0x1f0, %g1
*/
RTEMS_INLINE_ROUTINE void _Scheduler_Enqueue_first(
Thread_Control *the_thread
)
{
_Scheduler.Operations.enqueue_first( the_thread );
2009dd4: 10 80 00 03 b 2009de0 <_Thread_Change_priority+0xa8>
2009dd8: c2 00 60 28 ld [ %g1 + 0x28 ], %g1
*/
RTEMS_INLINE_ROUTINE void _Scheduler_Enqueue(
Thread_Control *the_thread
)
{
_Scheduler.Operations.enqueue( the_thread );
2009ddc: c2 00 60 24 ld [ %g1 + 0x24 ], %g1
2009de0: 9f c0 40 00 call %g1
2009de4: 90 10 00 1d mov %i5, %o0
_Scheduler_Enqueue_first( the_thread );
else
_Scheduler_Enqueue( the_thread );
}
_ISR_Flash( level );
2009de8: 7f ff e2 3b call 20026d4 <sparc_enable_interrupts>
2009dec: 90 10 00 1b mov %i3, %o0
2009df0: 7f ff e2 35 call 20026c4 <sparc_disable_interrupts>
2009df4: 01 00 00 00 nop
2009df8: 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();
2009dfc: 03 00 80 73 sethi %hi(0x201cc00), %g1
2009e00: c2 00 61 f8 ld [ %g1 + 0x1f8 ], %g1 ! 201cdf8 <_Scheduler+0x8>
2009e04: 9f c0 40 00 call %g1
2009e08: 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 );
2009e0c: 03 00 80 78 sethi %hi(0x201e000), %g1
2009e10: 82 10 60 20 or %g1, 0x20, %g1 ! 201e020 <_Per_CPU_Information>
2009e14: 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() &&
2009e18: c6 00 60 10 ld [ %g1 + 0x10 ], %g3
2009e1c: 80 a0 80 03 cmp %g2, %g3
2009e20: 02 80 00 07 be 2009e3c <_Thread_Change_priority+0x104>
2009e24: 01 00 00 00 nop
2009e28: c4 08 a0 70 ldub [ %g2 + 0x70 ], %g2
2009e2c: 80 a0 a0 00 cmp %g2, 0
2009e30: 02 80 00 03 be 2009e3c <_Thread_Change_priority+0x104>
2009e34: 84 10 20 01 mov 1, %g2
_Thread_Executing->is_preemptible )
_Thread_Dispatch_necessary = true;
2009e38: c4 28 60 18 stb %g2, [ %g1 + 0x18 ]
_ISR_Enable( level );
2009e3c: 7f ff e2 26 call 20026d4 <sparc_enable_interrupts>
2009e40: 81 e8 00 00 restore
2009e44: 81 c7 e0 08 ret
2009e48: 81 e8 00 00 restore
0200a038 <_Thread_Delay_ended>:
void _Thread_Delay_ended(
Objects_Id id,
void *ignored __attribute__((unused))
)
{
200a038: 9d e3 bf 98 save %sp, -104, %sp
Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
200a03c: 90 10 00 18 mov %i0, %o0
200a040: 40 00 00 70 call 200a200 <_Thread_Get>
200a044: 92 07 bf fc add %fp, -4, %o1
switch ( location ) {
200a048: c2 07 bf fc ld [ %fp + -4 ], %g1
200a04c: 80 a0 60 00 cmp %g1, 0
200a050: 12 80 00 09 bne 200a074 <_Thread_Delay_ended+0x3c> <== NEVER TAKEN
200a054: 13 04 00 00 sethi %hi(0x10000000), %o1
#if defined(RTEMS_MULTIPROCESSING)
case OBJECTS_REMOTE: /* impossible */
#endif
break;
case OBJECTS_LOCAL:
_Thread_Clear_state(
200a058: 7f ff ff 7d call 2009e4c <_Thread_Clear_state>
200a05c: 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--;
200a060: 03 00 80 76 sethi %hi(0x201d800), %g1
200a064: c4 00 62 f0 ld [ %g1 + 0x2f0 ], %g2 ! 201daf0 <_Thread_Dispatch_disable_level>
200a068: 84 00 bf ff add %g2, -1, %g2
200a06c: c4 20 62 f0 st %g2, [ %g1 + 0x2f0 ]
return _Thread_Dispatch_disable_level;
200a070: c2 00 62 f0 ld [ %g1 + 0x2f0 ], %g1
200a074: 81 c7 e0 08 ret
200a078: 81 e8 00 00 restore
0200a07c <_Thread_Dispatch>:
* INTERRUPT LATENCY:
* dispatch thread
* no dispatch thread
*/
void _Thread_Dispatch( void )
{
200a07c: 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++;
200a080: 03 00 80 76 sethi %hi(0x201d800), %g1
200a084: c4 00 62 f0 ld [ %g1 + 0x2f0 ], %g2 ! 201daf0 <_Thread_Dispatch_disable_level>
200a088: 84 00 a0 01 inc %g2
200a08c: c4 20 62 f0 st %g2, [ %g1 + 0x2f0 ]
return _Thread_Dispatch_disable_level;
200a090: c2 00 62 f0 ld [ %g1 + 0x2f0 ], %g1
#endif
/*
* Now determine if we need to perform a dispatch on the current CPU.
*/
executing = _Thread_Executing;
200a094: 21 00 80 78 sethi %hi(0x201e000), %l0
200a098: 82 14 20 20 or %l0, 0x20, %g1 ! 201e020 <_Per_CPU_Information>
_ISR_Disable( level );
200a09c: 7f ff e1 8a call 20026c4 <sparc_disable_interrupts>
200a0a0: 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;
200a0a4: 25 00 80 76 sethi %hi(0x201d800), %l2
#endif
/*
* Switch libc's task specific data.
*/
if ( _Thread_libc_reent ) {
200a0a8: 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 ) {
200a0ac: 10 80 00 42 b 200a1b4 <_Thread_Dispatch+0x138>
200a0b0: 23 00 80 76 sethi %hi(0x201d800), %l1
heir = _Thread_Heir;
_Thread_Dispatch_necessary = false;
200a0b4: 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 )
200a0b8: 80 a6 00 19 cmp %i0, %i1
200a0bc: 12 80 00 0d bne 200a0f0 <_Thread_Dispatch+0x74>
200a0c0: f0 20 60 0c st %i0, [ %g1 + 0xc ]
_ISR_Disable( level );
}
post_switch:
_ISR_Enable( level );
200a0c4: 7f ff e1 84 call 20026d4 <sparc_enable_interrupts>
200a0c8: 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--;
200a0cc: 03 00 80 76 sethi %hi(0x201d800), %g1
200a0d0: c4 00 62 f0 ld [ %g1 + 0x2f0 ], %g2 ! 201daf0 <_Thread_Dispatch_disable_level>
200a0d4: 84 00 bf ff add %g2, -1, %g2
200a0d8: c4 20 62 f0 st %g2, [ %g1 + 0x2f0 ]
return _Thread_Dispatch_disable_level;
200a0dc: c2 00 62 f0 ld [ %g1 + 0x2f0 ], %g1
_Thread_Unnest_dispatch();
_API_extensions_Run_postswitch();
200a0e0: 7f ff f8 5d call 2008254 <_API_extensions_Run_postswitch>
200a0e4: 01 00 00 00 nop
200a0e8: 81 c7 e0 08 ret
200a0ec: 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 )
200a0f0: c2 06 20 78 ld [ %i0 + 0x78 ], %g1
200a0f4: 80 a0 60 01 cmp %g1, 1
200a0f8: 12 80 00 03 bne 200a104 <_Thread_Dispatch+0x88>
200a0fc: c2 04 a2 50 ld [ %l2 + 0x250 ], %g1
heir->cpu_time_budget = _Thread_Ticks_per_timeslice;
200a100: c2 26 20 74 st %g1, [ %i0 + 0x74 ]
_ISR_Enable( level );
200a104: 7f ff e1 74 call 20026d4 <sparc_enable_interrupts>
200a108: 01 00 00 00 nop
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
{
Timestamp_Control uptime, ran;
_TOD_Get_uptime( &uptime );
200a10c: 40 00 0d 1a call 200d574 <_TOD_Get_uptime>
200a110: 90 07 bf f8 add %fp, -8, %o0
_Timestamp_Subtract(
200a114: c4 1f bf f8 ldd [ %fp + -8 ], %g2
200a118: 82 14 20 20 or %l0, 0x20, %g1
const Timestamp64_Control *_start,
const Timestamp64_Control *_end,
Timestamp64_Control *_result
)
{
*_result = *_end - *_start;
200a11c: f8 18 60 20 ldd [ %g1 + 0x20 ], %i4
200a120: b6 a0 c0 1d subcc %g3, %i5, %i3
200a124: b4 60 80 1c subx %g2, %i4, %i2
static inline void _Timestamp64_implementation_Add_to(
Timestamp64_Control *_time,
const Timestamp64_Control *_add
)
{
*_time += *_add;
200a128: f8 1e 60 80 ldd [ %i1 + 0x80 ], %i4
200a12c: ba 87 40 1b addcc %i5, %i3, %i5
200a130: b8 47 00 1a addx %i4, %i2, %i4
200a134: 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;
200a138: c4 38 60 20 std %g2, [ %g1 + 0x20 ]
#endif
/*
* Switch libc's task specific data.
*/
if ( _Thread_libc_reent ) {
200a13c: c2 04 e3 6c ld [ %l3 + 0x36c ], %g1
200a140: 80 a0 60 00 cmp %g1, 0
200a144: 02 80 00 06 be 200a15c <_Thread_Dispatch+0xe0> <== NEVER TAKEN
200a148: 90 10 00 19 mov %i1, %o0
executing->libc_reent = *_Thread_libc_reent;
200a14c: c4 00 40 00 ld [ %g1 ], %g2
200a150: c4 26 61 54 st %g2, [ %i1 + 0x154 ]
*_Thread_libc_reent = heir->libc_reent;
200a154: c4 06 21 54 ld [ %i0 + 0x154 ], %g2
200a158: c4 20 40 00 st %g2, [ %g1 ]
}
_User_extensions_Thread_switch( executing, heir );
200a15c: 40 00 03 58 call 200aebc <_User_extensions_Thread_switch>
200a160: 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 );
200a164: 90 06 60 c8 add %i1, 0xc8, %o0
200a168: 40 00 04 83 call 200b374 <_CPU_Context_switch>
200a16c: 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) &&
200a170: c2 06 61 50 ld [ %i1 + 0x150 ], %g1
200a174: 80 a0 60 00 cmp %g1, 0
200a178: 02 80 00 0c be 200a1a8 <_Thread_Dispatch+0x12c>
200a17c: d0 04 63 68 ld [ %l1 + 0x368 ], %o0
200a180: 80 a6 40 08 cmp %i1, %o0
200a184: 02 80 00 09 be 200a1a8 <_Thread_Dispatch+0x12c>
200a188: 80 a2 20 00 cmp %o0, 0
!_Thread_Is_allocated_fp( executing ) ) {
if ( _Thread_Allocated_fp != NULL )
200a18c: 02 80 00 04 be 200a19c <_Thread_Dispatch+0x120>
200a190: 01 00 00 00 nop
_Context_Save_fp( &_Thread_Allocated_fp->fp_context );
200a194: 40 00 04 3e call 200b28c <_CPU_Context_save_fp>
200a198: 90 02 21 50 add %o0, 0x150, %o0
_Context_Restore_fp( &executing->fp_context );
200a19c: 40 00 04 59 call 200b300 <_CPU_Context_restore_fp>
200a1a0: 90 06 61 50 add %i1, 0x150, %o0
_Thread_Allocated_fp = executing;
200a1a4: f2 24 63 68 st %i1, [ %l1 + 0x368 ]
if ( executing->fp_context != NULL )
_Context_Restore_fp( &executing->fp_context );
#endif
#endif
executing = _Thread_Executing;
200a1a8: 82 14 20 20 or %l0, 0x20, %g1
_ISR_Disable( level );
200a1ac: 7f ff e1 46 call 20026c4 <sparc_disable_interrupts>
200a1b0: 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 ) {
200a1b4: 82 14 20 20 or %l0, 0x20, %g1
200a1b8: c4 08 60 18 ldub [ %g1 + 0x18 ], %g2
200a1bc: 80 a0 a0 00 cmp %g2, 0
200a1c0: 32 bf ff bd bne,a 200a0b4 <_Thread_Dispatch+0x38>
200a1c4: f0 00 60 10 ld [ %g1 + 0x10 ], %i0
200a1c8: 30 bf ff bf b,a 200a0c4 <_Thread_Dispatch+0x48>
0200f7cc <_Thread_Handler>:
* Input parameters: NONE
*
* Output parameters: NONE
*/
void _Thread_Handler( void )
{
200f7cc: 9d e3 bf a0 save %sp, -96, %sp
#if defined(EXECUTE_GLOBAL_CONSTRUCTORS)
static bool doneConstructors;
bool doCons;
#endif
executing = _Thread_Executing;
200f7d0: 03 00 80 78 sethi %hi(0x201e000), %g1
200f7d4: fa 00 60 2c ld [ %g1 + 0x2c ], %i5 ! 201e02c <_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();
200f7d8: 3f 00 80 3d sethi %hi(0x200f400), %i7
200f7dc: be 17 e3 cc or %i7, 0x3cc, %i7 ! 200f7cc <_Thread_Handler>
/*
* have to put level into a register for those cpu's that use
* inline asm here
*/
level = executing->Start.isr_level;
200f7e0: d0 07 60 a8 ld [ %i5 + 0xa8 ], %o0
_ISR_Set_level(level);
200f7e4: 7f ff cb bc call 20026d4 <sparc_enable_interrupts>
200f7e8: 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;
200f7ec: 03 00 80 75 sethi %hi(0x201d400), %g1
doneConstructors = true;
200f7f0: 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;
200f7f4: f8 08 62 f0 ldub [ %g1 + 0x2f0 ], %i4
doneConstructors = true;
200f7f8: c4 28 62 f0 stb %g2, [ %g1 + 0x2f0 ]
#endif
#endif
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
#if ( CPU_USE_DEFERRED_FP_SWITCH == TRUE )
if ( (executing->fp_context != NULL) &&
200f7fc: c2 07 61 50 ld [ %i5 + 0x150 ], %g1
200f800: 80 a0 60 00 cmp %g1, 0
200f804: 02 80 00 0c be 200f834 <_Thread_Handler+0x68>
200f808: 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 );
200f80c: d0 00 63 68 ld [ %g1 + 0x368 ], %o0 ! 201db68 <_Thread_Allocated_fp>
200f810: 80 a7 40 08 cmp %i5, %o0
200f814: 02 80 00 08 be 200f834 <_Thread_Handler+0x68>
200f818: 80 a2 20 00 cmp %o0, 0
!_Thread_Is_allocated_fp( executing ) ) {
if ( _Thread_Allocated_fp != NULL )
200f81c: 22 80 00 06 be,a 200f834 <_Thread_Handler+0x68>
200f820: fa 20 63 68 st %i5, [ %g1 + 0x368 ]
_Context_Save_fp( &_Thread_Allocated_fp->fp_context );
200f824: 7f ff ee 9a call 200b28c <_CPU_Context_save_fp>
200f828: 90 02 21 50 add %o0, 0x150, %o0
_Thread_Allocated_fp = executing;
200f82c: 03 00 80 76 sethi %hi(0x201d800), %g1
200f830: fa 20 63 68 st %i5, [ %g1 + 0x368 ] ! 201db68 <_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 );
200f834: 7f ff ed 2d call 200ace8 <_User_extensions_Thread_begin>
200f838: 90 10 00 1d mov %i5, %o0
/*
* At this point, the dispatch disable level BETTER be 1.
*/
_Thread_Enable_dispatch();
200f83c: 7f ff ea 64 call 200a1cc <_Thread_Enable_dispatch>
200f840: 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) */ {
200f844: 80 8f 20 ff btst 0xff, %i4
200f848: 32 80 00 05 bne,a 200f85c <_Thread_Handler+0x90>
200f84c: c2 07 60 90 ld [ %i5 + 0x90 ], %g1
INIT_NAME ();
200f850: 40 00 35 1a call 201ccb8 <_init>
200f854: 01 00 00 00 nop
_Thread_Enable_dispatch();
#endif
}
#endif
if ( executing->Start.prototype == THREAD_START_NUMERIC ) {
200f858: c2 07 60 90 ld [ %i5 + 0x90 ], %g1
200f85c: 80 a0 60 00 cmp %g1, 0
200f860: 12 80 00 05 bne 200f874 <_Thread_Handler+0xa8>
200f864: 80 a0 60 01 cmp %g1, 1
executing->Wait.return_argument =
(*(Thread_Entry_numeric) executing->Start.entry_point)(
200f868: c2 07 60 8c ld [ %i5 + 0x8c ], %g1
200f86c: 10 80 00 06 b 200f884 <_Thread_Handler+0xb8>
200f870: 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 ) {
200f874: 12 80 00 07 bne 200f890 <_Thread_Handler+0xc4> <== NEVER TAKEN
200f878: 01 00 00 00 nop
executing->Wait.return_argument =
(*(Thread_Entry_pointer) executing->Start.entry_point)(
200f87c: c2 07 60 8c ld [ %i5 + 0x8c ], %g1
200f880: d0 07 60 94 ld [ %i5 + 0x94 ], %o0
200f884: 9f c0 40 00 call %g1
200f888: 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 =
200f88c: 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 );
200f890: 7f ff ed 27 call 200ad2c <_User_extensions_Thread_exitted>
200f894: 90 10 00 1d mov %i5, %o0
_Internal_error_Occurred(
200f898: 90 10 20 00 clr %o0
200f89c: 92 10 20 01 mov 1, %o1
200f8a0: 7f ff e5 0b call 2008ccc <_Internal_error_Occurred>
200f8a4: 94 10 20 05 mov 5, %o2
0200a4b0 <_Thread_Handler_initialization>:
*
* Output parameters: NONE
*/
void _Thread_Handler_initialization(void)
{
200a4b0: 9d e3 bf 98 save %sp, -104, %sp
uint32_t ticks_per_timeslice =
200a4b4: 03 00 80 73 sethi %hi(0x201cc00), %g1
200a4b8: 82 10 60 fc or %g1, 0xfc, %g1 ! 201ccfc <Configuration>
#if defined(RTEMS_MULTIPROCESSING)
uint32_t maximum_proxies =
_Configuration_MP_table->maximum_proxies;
#endif
if ( rtems_configuration_get_stack_allocate_hook() == NULL ||
200a4bc: c6 00 60 2c ld [ %g1 + 0x2c ], %g3
* Output parameters: NONE
*/
void _Thread_Handler_initialization(void)
{
uint32_t ticks_per_timeslice =
200a4c0: fa 00 60 18 ld [ %g1 + 0x18 ], %i5
rtems_configuration_get_ticks_per_timeslice();
uint32_t maximum_extensions =
200a4c4: 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 ||
200a4c8: 80 a0 e0 00 cmp %g3, 0
200a4cc: 02 80 00 06 be 200a4e4 <_Thread_Handler_initialization+0x34>
200a4d0: c4 00 60 28 ld [ %g1 + 0x28 ], %g2
200a4d4: c6 00 60 30 ld [ %g1 + 0x30 ], %g3
200a4d8: 80 a0 e0 00 cmp %g3, 0
200a4dc: 12 80 00 06 bne 200a4f4 <_Thread_Handler_initialization+0x44><== ALWAYS TAKEN
200a4e0: 80 a0 a0 00 cmp %g2, 0
rtems_configuration_get_stack_free_hook() == NULL)
_Internal_error_Occurred(
200a4e4: 90 10 20 00 clr %o0
200a4e8: 92 10 20 01 mov 1, %o1
200a4ec: 7f ff f9 f8 call 2008ccc <_Internal_error_Occurred>
200a4f0: 94 10 20 0e mov 0xe, %o2
INTERNAL_ERROR_CORE,
true,
INTERNAL_ERROR_BAD_STACK_HOOK
);
if ( stack_allocate_init_hook != NULL )
200a4f4: 22 80 00 05 be,a 200a508 <_Thread_Handler_initialization+0x58>
200a4f8: 03 00 80 78 sethi %hi(0x201e000), %g1
(*stack_allocate_init_hook)( rtems_configuration_get_stack_space_size() );
200a4fc: 9f c0 80 00 call %g2
200a500: d0 00 60 08 ld [ %g1 + 8 ], %o0 ! 201e008 <_RTEMS_Objects+0x1c>
_Thread_Dispatch_necessary = false;
200a504: 03 00 80 78 sethi %hi(0x201e000), %g1
200a508: 82 10 60 20 or %g1, 0x20, %g1 ! 201e020 <_Per_CPU_Information>
200a50c: c0 28 60 18 clrb [ %g1 + 0x18 ]
_Thread_Executing = NULL;
200a510: c0 20 60 0c clr [ %g1 + 0xc ]
_Thread_Heir = NULL;
200a514: c0 20 60 10 clr [ %g1 + 0x10 ]
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
_Thread_Allocated_fp = NULL;
200a518: 03 00 80 76 sethi %hi(0x201d800), %g1
200a51c: c0 20 63 68 clr [ %g1 + 0x368 ] ! 201db68 <_Thread_Allocated_fp>
#endif
_Thread_Maximum_extensions = maximum_extensions;
200a520: 03 00 80 76 sethi %hi(0x201d800), %g1
200a524: f8 20 63 70 st %i4, [ %g1 + 0x370 ] ! 201db70 <_Thread_Maximum_extensions>
_Thread_Ticks_per_timeslice = ticks_per_timeslice;
200a528: 03 00 80 76 sethi %hi(0x201d800), %g1
200a52c: fa 20 62 50 st %i5, [ %g1 + 0x250 ] ! 201da50 <_Thread_Ticks_per_timeslice>
#if defined(RTEMS_MULTIPROCESSING)
if ( _System_state_Is_multiprocessing )
maximum_internal_threads += 1;
#endif
_Objects_Initialize_information(
200a530: 82 10 20 08 mov 8, %g1
200a534: 11 00 80 76 sethi %hi(0x201d800), %o0
200a538: c2 23 a0 5c st %g1, [ %sp + 0x5c ]
200a53c: 90 12 23 f0 or %o0, 0x3f0, %o0
200a540: 92 10 20 01 mov 1, %o1
200a544: 94 10 20 01 mov 1, %o2
200a548: 96 10 20 01 mov 1, %o3
200a54c: 98 10 21 68 mov 0x168, %o4
200a550: 7f ff fb 67 call 20092ec <_Objects_Initialize_information>
200a554: 9a 10 20 00 clr %o5
200a558: 81 c7 e0 08 ret
200a55c: 81 e8 00 00 restore
0200a2b4 <_Thread_Initialize>:
Thread_CPU_budget_algorithms budget_algorithm,
Thread_CPU_budget_algorithm_callout budget_callout,
uint32_t isr_level,
Objects_Name name
)
{
200a2b4: 9d e3 bf a0 save %sp, -96, %sp
200a2b8: 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;
200a2bc: c0 26 61 58 clr [ %i1 + 0x158 ]
200a2c0: c0 26 61 5c clr [ %i1 + 0x15c ]
extensions_area = NULL;
the_thread->libc_reent = NULL;
200a2c4: 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
)
{
200a2c8: e0 07 a0 60 ld [ %fp + 0x60 ], %l0
200a2cc: 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 ) {
200a2d0: 80 a6 a0 00 cmp %i2, 0
200a2d4: 12 80 00 0d bne 200a308 <_Thread_Initialize+0x54>
200a2d8: e4 0f a0 5f ldub [ %fp + 0x5f ], %l2
actual_stack_size = _Thread_Stack_Allocate( the_thread, stack_size );
200a2dc: 90 10 00 19 mov %i1, %o0
200a2e0: 40 00 02 12 call 200ab28 <_Thread_Stack_Allocate>
200a2e4: 92 10 00 1b mov %i3, %o1
if ( !actual_stack_size || actual_stack_size < stack_size )
200a2e8: 80 a2 00 1b cmp %o0, %i3
200a2ec: 0a 80 00 6d bcs 200a4a0 <_Thread_Initialize+0x1ec>
200a2f0: 80 a2 20 00 cmp %o0, 0
200a2f4: 02 80 00 6b be 200a4a0 <_Thread_Initialize+0x1ec> <== NEVER TAKEN
200a2f8: 82 10 20 01 mov 1, %g1
return false; /* stack allocation failed */
stack = the_thread->Start.stack;
200a2fc: f4 06 60 c0 ld [ %i1 + 0xc0 ], %i2
the_thread->Start.core_allocated_stack = true;
200a300: 10 80 00 04 b 200a310 <_Thread_Initialize+0x5c>
200a304: c2 2e 60 b0 stb %g1, [ %i1 + 0xb0 ]
} else {
stack = stack_area;
actual_stack_size = stack_size;
the_thread->Start.core_allocated_stack = false;
200a308: c0 2e 60 b0 clrb [ %i1 + 0xb0 ]
200a30c: 90 10 00 1b mov %i3, %o0
Stack_Control *the_stack,
void *starting_address,
size_t size
)
{
the_stack->area = starting_address;
200a310: f4 26 60 b8 st %i2, [ %i1 + 0xb8 ]
the_stack->size = size;
200a314: 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 ) {
200a318: 80 a7 20 00 cmp %i4, 0
200a31c: 02 80 00 07 be 200a338 <_Thread_Initialize+0x84>
200a320: b6 10 20 00 clr %i3
fp_area = _Workspace_Allocate( CONTEXT_FP_SIZE );
200a324: 40 00 03 be call 200b21c <_Workspace_Allocate>
200a328: 90 10 20 88 mov 0x88, %o0
if ( !fp_area )
200a32c: b6 92 20 00 orcc %o0, 0, %i3
200a330: 22 80 00 4d be,a 200a464 <_Thread_Initialize+0x1b0>
200a334: b8 10 20 00 clr %i4
#endif
/*
* Allocate the extensions area for this thread
*/
if ( _Thread_Maximum_extensions ) {
200a338: 03 00 80 76 sethi %hi(0x201d800), %g1
200a33c: d0 00 63 70 ld [ %g1 + 0x370 ], %o0 ! 201db70 <_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;
200a340: f6 26 61 50 st %i3, [ %i1 + 0x150 ]
the_thread->Start.fp_context = fp_area;
200a344: f6 26 60 bc st %i3, [ %i1 + 0xbc ]
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
200a348: c0 26 60 50 clr [ %i1 + 0x50 ]
the_watchdog->routine = routine;
200a34c: c0 26 60 64 clr [ %i1 + 0x64 ]
the_watchdog->id = id;
200a350: c0 26 60 68 clr [ %i1 + 0x68 ]
the_watchdog->user_data = user_data;
200a354: c0 26 60 6c clr [ %i1 + 0x6c ]
#endif
/*
* Allocate the extensions area for this thread
*/
if ( _Thread_Maximum_extensions ) {
200a358: 80 a2 20 00 cmp %o0, 0
200a35c: 02 80 00 08 be 200a37c <_Thread_Initialize+0xc8>
200a360: b8 10 20 00 clr %i4
extensions_area = _Workspace_Allocate(
200a364: 90 02 20 01 inc %o0
200a368: 40 00 03 ad call 200b21c <_Workspace_Allocate>
200a36c: 91 2a 20 02 sll %o0, 2, %o0
(_Thread_Maximum_extensions + 1) * sizeof( void * )
);
if ( !extensions_area )
200a370: b8 92 20 00 orcc %o0, 0, %i4
200a374: 02 80 00 3d be 200a468 <_Thread_Initialize+0x1b4>
200a378: 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 ) {
200a37c: 80 a7 20 00 cmp %i4, 0
200a380: 12 80 00 0a bne 200a3a8 <_Thread_Initialize+0xf4>
200a384: 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;
200a388: c2 07 a0 64 ld [ %fp + 0x64 ], %g1
/*
* General initialization
*/
the_thread->Start.is_preemptible = is_preemptible;
200a38c: e4 2e 60 9c stb %l2, [ %i1 + 0x9c ]
the_thread->Start.budget_algorithm = budget_algorithm;
200a390: e0 26 60 a0 st %l0, [ %i1 + 0xa0 ]
the_thread->Start.budget_callout = budget_callout;
switch ( budget_algorithm ) {
200a394: 80 a4 20 02 cmp %l0, 2
200a398: 12 80 00 12 bne 200a3e0 <_Thread_Initialize+0x12c>
200a39c: 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;
200a3a0: 10 80 00 0e b 200a3d8 <_Thread_Initialize+0x124>
200a3a4: 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++ )
200a3a8: 03 00 80 76 sethi %hi(0x201d800), %g1
200a3ac: c4 00 63 70 ld [ %g1 + 0x370 ], %g2 ! 201db70 <_Thread_Maximum_extensions>
200a3b0: 10 80 00 05 b 200a3c4 <_Thread_Initialize+0x110>
200a3b4: 82 10 20 00 clr %g1
the_thread->extensions[i] = NULL;
200a3b8: 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++ )
200a3bc: 82 00 60 01 inc %g1
the_thread->extensions[i] = NULL;
200a3c0: 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++ )
200a3c4: 80 a0 40 02 cmp %g1, %g2
200a3c8: 28 bf ff fc bleu,a 200a3b8 <_Thread_Initialize+0x104>
200a3cc: 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;
200a3d0: 10 bf ff ef b 200a38c <_Thread_Initialize+0xd8>
200a3d4: 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;
200a3d8: c2 00 62 50 ld [ %g1 + 0x250 ], %g1
200a3dc: c2 26 60 74 st %g1, [ %i1 + 0x74 ]
case THREAD_CPU_BUDGET_ALGORITHM_CALLOUT:
break;
#endif
}
the_thread->Start.isr_level = isr_level;
200a3e0: c2 07 a0 68 ld [ %fp + 0x68 ], %g1
the_thread->current_state = STATES_DORMANT;
the_thread->Wait.queue = NULL;
200a3e4: c0 26 60 44 clr [ %i1 + 0x44 ]
case THREAD_CPU_BUDGET_ALGORITHM_CALLOUT:
break;
#endif
}
the_thread->Start.isr_level = isr_level;
200a3e8: c2 26 60 a8 st %g1, [ %i1 + 0xa8 ]
the_thread->current_state = STATES_DORMANT;
200a3ec: 82 10 20 01 mov 1, %g1
200a3f0: c2 26 60 10 st %g1, [ %i1 + 0x10 ]
*/
RTEMS_INLINE_ROUTINE void* _Scheduler_Allocate(
Thread_Control *the_thread
)
{
return _Scheduler.Operations.allocate( the_thread );
200a3f4: 03 00 80 73 sethi %hi(0x201cc00), %g1
200a3f8: c2 00 62 08 ld [ %g1 + 0x208 ], %g1 ! 201ce08 <_Scheduler+0x18>
the_thread->Wait.queue = NULL;
the_thread->resource_count = 0;
200a3fc: c0 26 60 1c clr [ %i1 + 0x1c ]
the_thread->real_priority = priority;
200a400: fa 26 60 18 st %i5, [ %i1 + 0x18 ]
the_thread->Start.initial_priority = priority;
200a404: fa 26 60 ac st %i5, [ %i1 + 0xac ]
200a408: 9f c0 40 00 call %g1
200a40c: 90 10 00 19 mov %i1, %o0
sched =_Scheduler_Allocate( the_thread );
if ( !sched )
200a410: b4 92 20 00 orcc %o0, 0, %i2
200a414: 02 80 00 15 be 200a468 <_Thread_Initialize+0x1b4>
200a418: 90 10 00 19 mov %i1, %o0
goto failed;
_Thread_Set_priority( the_thread, priority );
200a41c: 40 00 01 9b call 200aa88 <_Thread_Set_priority>
200a420: 92 10 00 1d mov %i5, %o1
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
200a424: c4 06 20 1c ld [ %i0 + 0x1c ], %g2
Objects_Information *information,
Objects_Control *the_object,
Objects_Name name
)
{
_Objects_Set_local_object(
200a428: c2 16 60 0a lduh [ %i1 + 0xa ], %g1
static inline void _Timestamp64_implementation_Set_to_zero(
Timestamp64_Control *_time
)
{
*_time = 0;
200a42c: c0 26 60 80 clr [ %i1 + 0x80 ]
200a430: c0 26 60 84 clr [ %i1 + 0x84 ]
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
200a434: 83 28 60 02 sll %g1, 2, %g1
200a438: f2 20 80 01 st %i1, [ %g2 + %g1 ]
information,
_Objects_Get_index( the_object->id ),
the_object
);
the_object->name = name;
200a43c: 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 );
200a440: 90 10 00 19 mov %i1, %o0
200a444: 40 00 02 5d call 200adb8 <_User_extensions_Thread_create>
200a448: b0 10 20 01 mov 1, %i0
if ( extension_status )
200a44c: 80 8a 20 ff btst 0xff, %o0
200a450: 02 80 00 06 be 200a468 <_Thread_Initialize+0x1b4>
200a454: 01 00 00 00 nop
200a458: b0 0e 20 01 and %i0, 1, %i0
200a45c: 81 c7 e0 08 ret
200a460: 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;
200a464: 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 );
200a468: 40 00 03 75 call 200b23c <_Workspace_Free>
200a46c: d0 06 61 54 ld [ %i1 + 0x154 ], %o0
for ( i=0 ; i <= THREAD_API_LAST ; i++ )
_Workspace_Free( the_thread->API_Extensions[i] );
200a470: 40 00 03 73 call 200b23c <_Workspace_Free>
200a474: d0 06 61 58 ld [ %i1 + 0x158 ], %o0
200a478: 40 00 03 71 call 200b23c <_Workspace_Free>
200a47c: d0 06 61 5c ld [ %i1 + 0x15c ], %o0
_Workspace_Free( extensions_area );
200a480: 40 00 03 6f call 200b23c <_Workspace_Free>
200a484: 90 10 00 1c mov %i4, %o0
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
_Workspace_Free( fp_area );
200a488: 40 00 03 6d call 200b23c <_Workspace_Free>
200a48c: 90 10 00 1b mov %i3, %o0
#endif
_Workspace_Free( sched );
200a490: 40 00 03 6b call 200b23c <_Workspace_Free>
200a494: 90 10 00 1a mov %i2, %o0
_Thread_Stack_Free( the_thread );
200a498: 40 00 01 b4 call 200ab68 <_Thread_Stack_Free>
200a49c: 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 */
200a4a0: b0 10 20 00 clr %i0
_Workspace_Free( sched );
_Thread_Stack_Free( the_thread );
return false;
}
200a4a4: b0 0e 20 01 and %i0, 1, %i0
200a4a8: 81 c7 e0 08 ret
200a4ac: 81 e8 00 00 restore
0200ab68 <_Thread_Stack_Free>:
*/
void _Thread_Stack_Free(
Thread_Control *the_thread
)
{
200ab68: 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 )
200ab6c: c4 0e 20 b0 ldub [ %i0 + 0xb0 ], %g2
void _Thread_Stack_Free(
Thread_Control *the_thread
)
{
rtems_stack_free_hook stack_free_hook =
200ab70: 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 )
200ab74: 80 a0 a0 00 cmp %g2, 0
200ab78: 02 80 00 04 be 200ab88 <_Thread_Stack_Free+0x20> <== NEVER TAKEN
200ab7c: c2 00 61 2c ld [ %g1 + 0x12c ], %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 );
200ab80: 9f c0 40 00 call %g1
200ab84: d0 06 20 b8 ld [ %i0 + 0xb8 ], %o0
200ab88: 81 c7 e0 08 ret
200ab8c: 81 e8 00 00 restore
0200a9d0 <_Thread_queue_Requeue>:
void _Thread_queue_Requeue(
Thread_queue_Control *the_thread_queue,
Thread_Control *the_thread
)
{
200a9d0: 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 )
200a9d4: 80 a6 20 00 cmp %i0, 0
200a9d8: 02 80 00 19 be 200aa3c <_Thread_queue_Requeue+0x6c> <== NEVER TAKEN
200a9dc: 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 ) {
200a9e0: fa 06 20 34 ld [ %i0 + 0x34 ], %i5
200a9e4: 80 a7 60 01 cmp %i5, 1
200a9e8: 12 80 00 15 bne 200aa3c <_Thread_queue_Requeue+0x6c> <== NEVER TAKEN
200a9ec: 01 00 00 00 nop
Thread_queue_Control *tq = the_thread_queue;
ISR_Level level;
ISR_Level level_ignored;
_ISR_Disable( level );
200a9f0: 7f ff df 35 call 20026c4 <sparc_disable_interrupts>
200a9f4: 01 00 00 00 nop
200a9f8: b8 10 00 08 mov %o0, %i4
200a9fc: c4 06 60 10 ld [ %i1 + 0x10 ], %g2
if ( _States_Is_waiting_on_thread_queue( the_thread->current_state ) ) {
200aa00: 03 00 00 ef sethi %hi(0x3bc00), %g1
200aa04: 82 10 62 e0 or %g1, 0x2e0, %g1 ! 3bee0 <PROM_START+0x3bee0>
200aa08: 80 88 80 01 btst %g2, %g1
200aa0c: 02 80 00 0a be 200aa34 <_Thread_queue_Requeue+0x64> <== NEVER TAKEN
200aa10: 90 10 00 18 mov %i0, %o0
_Thread_queue_Enter_critical_section( tq );
_Thread_queue_Extract_priority_helper( tq, the_thread, true );
200aa14: 92 10 00 19 mov %i1, %o1
200aa18: 94 10 20 01 mov 1, %o2
200aa1c: 40 00 0c b1 call 200dce0 <_Thread_queue_Extract_priority_helper>
200aa20: fa 26 20 30 st %i5, [ %i0 + 0x30 ]
(void) _Thread_queue_Enqueue_priority( tq, the_thread, &level_ignored );
200aa24: 90 10 00 18 mov %i0, %o0
200aa28: 92 10 00 19 mov %i1, %o1
200aa2c: 7f ff ff 50 call 200a76c <_Thread_queue_Enqueue_priority>
200aa30: 94 07 bf fc add %fp, -4, %o2
}
_ISR_Enable( level );
200aa34: 7f ff df 28 call 20026d4 <sparc_enable_interrupts>
200aa38: 90 10 00 1c mov %i4, %o0
200aa3c: 81 c7 e0 08 ret
200aa40: 81 e8 00 00 restore
0200aa44 <_Thread_queue_Timeout>:
void _Thread_queue_Timeout(
Objects_Id id,
void *ignored __attribute__((unused))
)
{
200aa44: 9d e3 bf 98 save %sp, -104, %sp
Thread_Control *the_thread;
Objects_Locations location;
the_thread = _Thread_Get( id, &location );
200aa48: 90 10 00 18 mov %i0, %o0
200aa4c: 7f ff fd ed call 200a200 <_Thread_Get>
200aa50: 92 07 bf fc add %fp, -4, %o1
switch ( location ) {
200aa54: c2 07 bf fc ld [ %fp + -4 ], %g1
200aa58: 80 a0 60 00 cmp %g1, 0
200aa5c: 12 80 00 09 bne 200aa80 <_Thread_queue_Timeout+0x3c> <== NEVER TAKEN
200aa60: 01 00 00 00 nop
#if defined(RTEMS_MULTIPROCESSING)
case OBJECTS_REMOTE: /* impossible */
#endif
break;
case OBJECTS_LOCAL:
_Thread_queue_Process_timeout( the_thread );
200aa64: 40 00 0c d6 call 200ddbc <_Thread_queue_Process_timeout>
200aa68: 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--;
200aa6c: 03 00 80 76 sethi %hi(0x201d800), %g1
200aa70: c4 00 62 f0 ld [ %g1 + 0x2f0 ], %g2 ! 201daf0 <_Thread_Dispatch_disable_level>
200aa74: 84 00 bf ff add %g2, -1, %g2
200aa78: c4 20 62 f0 st %g2, [ %g1 + 0x2f0 ]
return _Thread_Dispatch_disable_level;
200aa7c: c2 00 62 f0 ld [ %g1 + 0x2f0 ], %g1
200aa80: 81 c7 e0 08 ret
200aa84: 81 e8 00 00 restore
02018c9c <_Timer_server_Body>:
* @a arg points to the corresponding timer server control block.
*/
static rtems_task _Timer_server_Body(
rtems_task_argument arg
)
{
2018c9c: 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;
2018ca0: 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;
2018ca4: a4 07 bf e8 add %fp, -24, %l2
2018ca8: aa 07 bf ec add %fp, -20, %l5
2018cac: b8 07 bf f4 add %fp, -12, %i4
2018cb0: b2 07 bf f8 add %fp, -8, %i1
2018cb4: ea 27 bf e8 st %l5, [ %fp + -24 ]
head->previous = NULL;
2018cb8: c0 27 bf ec clr [ %fp + -20 ]
tail->previous = head;
2018cbc: 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;
2018cc0: f2 27 bf f4 st %i1, [ %fp + -12 ]
head->previous = NULL;
2018cc4: c0 27 bf f8 clr [ %fp + -8 ]
tail->previous = head;
2018cc8: 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 );
2018ccc: 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();
2018cd0: 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 );
2018cd4: 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 );
2018cd8: 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 );
2018cdc: 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;
2018ce0: 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;
2018ce4: c2 04 e2 78 ld [ %l3 + 0x278 ], %g1
/*
* We assume adequate unsigned arithmetic here.
*/
Watchdog_Interval delta = snapshot - watchdogs->last_snapshot;
2018ce8: d2 06 20 3c ld [ %i0 + 0x3c ], %o1
watchdogs->last_snapshot = snapshot;
_Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
2018cec: 90 10 00 1a mov %i2, %o0
2018cf0: 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;
2018cf4: c2 26 20 3c st %g1, [ %i0 + 0x3c ]
_Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
2018cf8: 40 00 11 97 call 201d354 <_Watchdog_Adjust_to_chain>
2018cfc: 94 10 00 1c mov %i4, %o2
2018d00: d0 1d 20 c8 ldd [ %l4 + 0xc8 ], %o0
2018d04: 94 10 20 00 clr %o2
2018d08: 17 0e e6 b2 sethi %hi(0x3b9ac800), %o3
2018d0c: 40 00 4f 42 call 202ca14 <__divdi3>
2018d10: 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;
2018d14: 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 ) {
2018d18: 80 a2 40 0a cmp %o1, %o2
2018d1c: 08 80 00 07 bleu 2018d38 <_Timer_server_Body+0x9c>
2018d20: 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 );
2018d24: 92 22 40 0a sub %o1, %o2, %o1
2018d28: 90 10 00 1b mov %i3, %o0
2018d2c: 40 00 11 8a call 201d354 <_Watchdog_Adjust_to_chain>
2018d30: 94 10 00 1c mov %i4, %o2
2018d34: 30 80 00 06 b,a 2018d4c <_Timer_server_Body+0xb0>
} else if ( snapshot < last_snapshot ) {
2018d38: 1a 80 00 05 bcc 2018d4c <_Timer_server_Body+0xb0>
2018d3c: 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 );
2018d40: 92 10 20 01 mov 1, %o1
2018d44: 40 00 11 5c call 201d2b4 <_Watchdog_Adjust>
2018d48: 94 22 80 1d sub %o2, %i5, %o2
}
watchdogs->last_snapshot = snapshot;
2018d4c: 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 );
2018d50: d0 06 20 78 ld [ %i0 + 0x78 ], %o0
2018d54: 40 00 02 8c call 2019784 <_Chain_Get>
2018d58: 01 00 00 00 nop
if ( timer == NULL ) {
2018d5c: 92 92 20 00 orcc %o0, 0, %o1
2018d60: 02 80 00 0c be 2018d90 <_Timer_server_Body+0xf4>
2018d64: 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 ) {
2018d68: c2 02 60 38 ld [ %o1 + 0x38 ], %g1
2018d6c: 80 a0 60 01 cmp %g1, 1
2018d70: 02 80 00 05 be 2018d84 <_Timer_server_Body+0xe8>
2018d74: 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 ) {
2018d78: 80 a0 60 03 cmp %g1, 3
2018d7c: 12 bf ff f5 bne 2018d50 <_Timer_server_Body+0xb4> <== NEVER TAKEN
2018d80: 90 10 00 1b mov %i3, %o0
_Watchdog_Insert( &ts->TOD_watchdogs.Chain, &timer->Ticker );
2018d84: 40 00 11 a6 call 201d41c <_Watchdog_Insert>
2018d88: 92 02 60 10 add %o1, 0x10, %o1
2018d8c: 30 bf ff f1 b,a 2018d50 <_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 );
2018d90: 7f ff de 98 call 20107f0 <sparc_disable_interrupts>
2018d94: 01 00 00 00 nop
if ( _Chain_Is_empty( insert_chain ) ) {
2018d98: c2 07 bf e8 ld [ %fp + -24 ], %g1
2018d9c: 80 a0 40 15 cmp %g1, %l5
2018da0: 12 80 00 0a bne 2018dc8 <_Timer_server_Body+0x12c> <== NEVER TAKEN
2018da4: 01 00 00 00 nop
ts->insert_chain = NULL;
2018da8: c0 26 20 78 clr [ %i0 + 0x78 ]
_ISR_Enable( level );
2018dac: 7f ff de 95 call 2010800 <sparc_enable_interrupts>
2018db0: 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 ) ) {
2018db4: c2 07 bf f4 ld [ %fp + -12 ], %g1
2018db8: 80 a0 40 19 cmp %g1, %i1
2018dbc: 12 80 00 06 bne 2018dd4 <_Timer_server_Body+0x138>
2018dc0: 01 00 00 00 nop
2018dc4: 30 80 00 18 b,a 2018e24 <_Timer_server_Body+0x188>
ts->insert_chain = NULL;
_ISR_Enable( level );
break;
} else {
_ISR_Enable( level );
2018dc8: 7f ff de 8e call 2010800 <sparc_enable_interrupts> <== NOT EXECUTED
2018dcc: 01 00 00 00 nop <== NOT EXECUTED
2018dd0: 30 bf ff c5 b,a 2018ce4 <_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 );
2018dd4: 7f ff de 87 call 20107f0 <sparc_disable_interrupts>
2018dd8: 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;
2018ddc: 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))
2018de0: 80 a7 40 19 cmp %i5, %i1
2018de4: 02 80 00 0d be 2018e18 <_Timer_server_Body+0x17c>
2018de8: 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;
2018dec: c2 07 40 00 ld [ %i5 ], %g1
head->next = new_first;
new_first->previous = head;
2018df0: 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;
2018df4: c2 27 bf f4 st %g1, [ %fp + -12 ]
watchdog = (Watchdog_Control *) _Chain_Get_unprotected( &fire_chain );
if ( watchdog != NULL ) {
watchdog->state = WATCHDOG_INACTIVE;
2018df8: c0 27 60 08 clr [ %i5 + 8 ]
_ISR_Enable( level );
2018dfc: 7f ff de 81 call 2010800 <sparc_enable_interrupts>
2018e00: 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 );
2018e04: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
2018e08: d0 07 60 20 ld [ %i5 + 0x20 ], %o0
2018e0c: 9f c0 40 00 call %g1
2018e10: d2 07 60 24 ld [ %i5 + 0x24 ], %o1
}
2018e14: 30 bf ff f0 b,a 2018dd4 <_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 );
2018e18: 7f ff de 7a call 2010800 <sparc_enable_interrupts>
2018e1c: 01 00 00 00 nop
2018e20: 30 bf ff b0 b,a 2018ce0 <_Timer_server_Body+0x44>
* the active flag of the timer server is true.
*/
(*watchdog->routine)( watchdog->id, watchdog->user_data );
}
} else {
ts->active = false;
2018e24: c0 2e 20 7c clrb [ %i0 + 0x7c ]
2018e28: 7f ff ff 19 call 2018a8c <_Thread_Dispatch_increment_disable_level>
2018e2c: 01 00 00 00 nop
/*
* Block until there is something to do.
*/
_Thread_Disable_dispatch();
_Thread_Set_state( ts->thread, STATES_DELAYING );
2018e30: d0 06 00 00 ld [ %i0 ], %o0
2018e34: 40 00 0f f9 call 201ce18 <_Thread_Set_state>
2018e38: 92 10 20 08 mov 8, %o1
_Timer_server_Reset_interval_system_watchdog( ts );
2018e3c: 7f ff ff 1b call 2018aa8 <_Timer_server_Reset_interval_system_watchdog>
2018e40: 90 10 00 18 mov %i0, %o0
_Timer_server_Reset_tod_system_watchdog( ts );
2018e44: 7f ff ff 2d call 2018af8 <_Timer_server_Reset_tod_system_watchdog>
2018e48: 90 10 00 18 mov %i0, %o0
_Thread_Enable_dispatch();
2018e4c: 40 00 0d 99 call 201c4b0 <_Thread_Enable_dispatch>
2018e50: 01 00 00 00 nop
ts->active = true;
2018e54: 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 );
2018e58: 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;
2018e5c: 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 );
2018e60: 40 00 11 c7 call 201d57c <_Watchdog_Remove>
2018e64: 01 00 00 00 nop
static void _Timer_server_Stop_tod_system_watchdog(
Timer_server_Control *ts
)
{
_Watchdog_Remove( &ts->TOD_watchdogs.System_watchdog );
2018e68: 40 00 11 c5 call 201d57c <_Watchdog_Remove>
2018e6c: 90 10 00 10 mov %l0, %o0
2018e70: 30 bf ff 9c b,a 2018ce0 <_Timer_server_Body+0x44>
02018b48 <_Timer_server_Schedule_operation_method>:
static void _Timer_server_Schedule_operation_method(
Timer_server_Control *ts,
Timer_Control *timer
)
{
2018b48: 9d e3 bf a0 save %sp, -96, %sp
if ( ts->insert_chain == NULL ) {
2018b4c: c2 06 20 78 ld [ %i0 + 0x78 ], %g1
2018b50: 80 a0 60 00 cmp %g1, 0
2018b54: 12 80 00 4f bne 2018c90 <_Timer_server_Schedule_operation_method+0x148>
2018b58: 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();
2018b5c: 7f ff ff cc call 2018a8c <_Thread_Dispatch_increment_disable_level>
2018b60: 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 ) {
2018b64: c2 06 60 38 ld [ %i1 + 0x38 ], %g1
2018b68: 80 a0 60 01 cmp %g1, 1
2018b6c: 12 80 00 1f bne 2018be8 <_Timer_server_Schedule_operation_method+0xa0>
2018b70: 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 );
2018b74: 7f ff df 1f call 20107f0 <sparc_disable_interrupts>
2018b78: 01 00 00 00 nop
snapshot = _Watchdog_Ticks_since_boot;
2018b7c: 03 00 80 f3 sethi %hi(0x203cc00), %g1
2018b80: c4 00 62 78 ld [ %g1 + 0x278 ], %g2 ! 203ce78 <_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;
2018b84: c2 06 20 30 ld [ %i0 + 0x30 ], %g1
last_snapshot = ts->Interval_watchdogs.last_snapshot;
2018b88: 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 );
2018b8c: 86 06 20 34 add %i0, 0x34, %g3
if ( !_Chain_Is_empty( &ts->Interval_watchdogs.Chain ) ) {
2018b90: 80 a0 40 03 cmp %g1, %g3
2018b94: 02 80 00 08 be 2018bb4 <_Timer_server_Schedule_operation_method+0x6c>
2018b98: 88 20 80 04 sub %g2, %g4, %g4
/*
* We assume adequate unsigned arithmetic here.
*/
delta = snapshot - last_snapshot;
delta_interval = first_watchdog->delta_interval;
2018b9c: f8 00 60 10 ld [ %g1 + 0x10 ], %i4
if (delta_interval > delta) {
2018ba0: 80 a7 00 04 cmp %i4, %g4
2018ba4: 08 80 00 03 bleu 2018bb0 <_Timer_server_Schedule_operation_method+0x68>
2018ba8: 86 10 20 00 clr %g3
delta_interval -= delta;
2018bac: 86 27 00 04 sub %i4, %g4, %g3
} else {
delta_interval = 0;
}
first_watchdog->delta_interval = delta_interval;
2018bb0: c6 20 60 10 st %g3, [ %g1 + 0x10 ]
}
ts->Interval_watchdogs.last_snapshot = snapshot;
2018bb4: c4 26 20 3c st %g2, [ %i0 + 0x3c ]
_ISR_Enable( level );
2018bb8: 7f ff df 12 call 2010800 <sparc_enable_interrupts>
2018bbc: 01 00 00 00 nop
_Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker );
2018bc0: 90 06 20 30 add %i0, 0x30, %o0
2018bc4: 40 00 12 16 call 201d41c <_Watchdog_Insert>
2018bc8: 92 07 60 10 add %i5, 0x10, %o1
if ( !ts->active ) {
2018bcc: c2 0e 20 7c ldub [ %i0 + 0x7c ], %g1
2018bd0: 80 a0 60 00 cmp %g1, 0
2018bd4: 12 80 00 2d bne 2018c88 <_Timer_server_Schedule_operation_method+0x140>
2018bd8: 01 00 00 00 nop
_Timer_server_Reset_interval_system_watchdog( ts );
2018bdc: 7f ff ff b3 call 2018aa8 <_Timer_server_Reset_interval_system_watchdog>
2018be0: 90 10 00 18 mov %i0, %o0
2018be4: 30 80 00 29 b,a 2018c88 <_Timer_server_Schedule_operation_method+0x140>
}
} else if ( timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) {
2018be8: 12 80 00 28 bne 2018c88 <_Timer_server_Schedule_operation_method+0x140>
2018bec: 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 );
2018bf0: 7f ff df 00 call 20107f0 <sparc_disable_interrupts>
2018bf4: 01 00 00 00 nop
2018bf8: b8 10 00 08 mov %o0, %i4
2018bfc: 03 00 80 f3 sethi %hi(0x203cc00), %g1
2018c00: d0 18 60 c8 ldd [ %g1 + 0xc8 ], %o0 ! 203ccc8 <_TOD>
2018c04: 94 10 20 00 clr %o2
2018c08: 17 0e e6 b2 sethi %hi(0x3b9ac800), %o3
2018c0c: 40 00 4f 82 call 202ca14 <__divdi3>
2018c10: 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;
2018c14: c2 06 20 68 ld [ %i0 + 0x68 ], %g1
snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch();
last_snapshot = ts->TOD_watchdogs.last_snapshot;
2018c18: 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 );
2018c1c: 86 06 20 6c add %i0, 0x6c, %g3
if ( !_Chain_Is_empty( &ts->TOD_watchdogs.Chain ) ) {
2018c20: 80 a0 40 03 cmp %g1, %g3
2018c24: 02 80 00 0d be 2018c58 <_Timer_server_Schedule_operation_method+0x110>
2018c28: 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 ) {
2018c2c: 08 80 00 08 bleu 2018c4c <_Timer_server_Schedule_operation_method+0x104>
2018c30: c6 00 60 10 ld [ %g1 + 0x10 ], %g3
/*
* We advanced in time.
*/
delta = snapshot - last_snapshot;
2018c34: 88 22 40 02 sub %o1, %g2, %g4
if (delta_interval > delta) {
2018c38: 80 a0 c0 04 cmp %g3, %g4
2018c3c: 08 80 00 06 bleu 2018c54 <_Timer_server_Schedule_operation_method+0x10c><== NEVER TAKEN
2018c40: 84 10 20 00 clr %g2
delta_interval -= delta;
2018c44: 10 80 00 04 b 2018c54 <_Timer_server_Schedule_operation_method+0x10c>
2018c48: 84 20 c0 04 sub %g3, %g4, %g2
}
} else {
/*
* Someone put us in the past.
*/
delta = last_snapshot - snapshot;
2018c4c: 84 00 c0 02 add %g3, %g2, %g2
delta_interval += delta;
2018c50: 84 20 80 09 sub %g2, %o1, %g2
}
first_watchdog->delta_interval = delta_interval;
2018c54: c4 20 60 10 st %g2, [ %g1 + 0x10 ]
}
ts->TOD_watchdogs.last_snapshot = snapshot;
2018c58: d2 26 20 74 st %o1, [ %i0 + 0x74 ]
_ISR_Enable( level );
2018c5c: 7f ff de e9 call 2010800 <sparc_enable_interrupts>
2018c60: 90 10 00 1c mov %i4, %o0
_Watchdog_Insert( &ts->TOD_watchdogs.Chain, &timer->Ticker );
2018c64: 90 06 20 68 add %i0, 0x68, %o0
2018c68: 40 00 11 ed call 201d41c <_Watchdog_Insert>
2018c6c: 92 07 60 10 add %i5, 0x10, %o1
if ( !ts->active ) {
2018c70: c2 0e 20 7c ldub [ %i0 + 0x7c ], %g1
2018c74: 80 a0 60 00 cmp %g1, 0
2018c78: 12 80 00 04 bne 2018c88 <_Timer_server_Schedule_operation_method+0x140>
2018c7c: 01 00 00 00 nop
_Timer_server_Reset_tod_system_watchdog( ts );
2018c80: 7f ff ff 9e call 2018af8 <_Timer_server_Reset_tod_system_watchdog>
2018c84: 90 10 00 18 mov %i0, %o0
}
}
_Thread_Enable_dispatch();
2018c88: 40 00 0e 0a call 201c4b0 <_Thread_Enable_dispatch>
2018c8c: 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 );
2018c90: f0 06 20 78 ld [ %i0 + 0x78 ], %i0
2018c94: 40 00 02 b0 call 2019754 <_Chain_Append>
2018c98: 81 e8 00 00 restore
0200c814 <_Timespec_Add_to>:
uint32_t _Timespec_Add_to(
struct timespec *time,
const struct timespec *add
)
{
200c814: 82 10 00 08 mov %o0, %g1
uint32_t seconds = add->tv_sec;
200c818: d0 02 40 00 ld [ %o1 ], %o0
/* Add the basics */
time->tv_sec += add->tv_sec;
200c81c: c4 00 40 00 ld [ %g1 ], %g2
time->tv_nsec += add->tv_nsec;
200c820: c6 00 60 04 ld [ %g1 + 4 ], %g3
)
{
uint32_t seconds = add->tv_sec;
/* Add the basics */
time->tv_sec += add->tv_sec;
200c824: 84 00 80 08 add %g2, %o0, %g2
200c828: c4 20 40 00 st %g2, [ %g1 ]
time->tv_nsec += add->tv_nsec;
200c82c: c4 02 60 04 ld [ %o1 + 4 ], %g2
/* Now adjust it so nanoseconds is in range */
while ( time->tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) {
time->tv_nsec -= TOD_NANOSECONDS_PER_SECOND;
200c830: 09 31 19 4d sethi %hi(0xc4653400), %g4
{
uint32_t seconds = add->tv_sec;
/* Add the basics */
time->tv_sec += add->tv_sec;
time->tv_nsec += add->tv_nsec;
200c834: 84 00 c0 02 add %g3, %g2, %g2
/* Now adjust it so nanoseconds is in range */
while ( time->tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) {
time->tv_nsec -= TOD_NANOSECONDS_PER_SECOND;
200c838: 88 11 22 00 or %g4, 0x200, %g4
/* Add the basics */
time->tv_sec += add->tv_sec;
time->tv_nsec += add->tv_nsec;
/* Now adjust it so nanoseconds is in range */
while ( time->tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) {
200c83c: 07 0e e6 b2 sethi %hi(0x3b9ac800), %g3
{
uint32_t seconds = add->tv_sec;
/* Add the basics */
time->tv_sec += add->tv_sec;
time->tv_nsec += add->tv_nsec;
200c840: c4 20 60 04 st %g2, [ %g1 + 4 ]
/* Now adjust it so nanoseconds is in range */
while ( time->tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) {
200c844: 10 80 00 07 b 200c860 <_Timespec_Add_to+0x4c>
200c848: 86 10 e1 ff or %g3, 0x1ff, %g3
time->tv_nsec -= TOD_NANOSECONDS_PER_SECOND;
200c84c: c4 20 60 04 st %g2, [ %g1 + 4 ] <== NOT EXECUTED
time->tv_sec++;
200c850: c4 00 40 00 ld [ %g1 ], %g2 <== NOT EXECUTED
seconds++;
200c854: 90 02 20 01 inc %o0 <== NOT EXECUTED
time->tv_nsec += add->tv_nsec;
/* Now adjust it so nanoseconds is in range */
while ( time->tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) {
time->tv_nsec -= TOD_NANOSECONDS_PER_SECOND;
time->tv_sec++;
200c858: 84 00 a0 01 inc %g2 <== NOT EXECUTED
200c85c: c4 20 40 00 st %g2, [ %g1 ] <== NOT EXECUTED
/* Add the basics */
time->tv_sec += add->tv_sec;
time->tv_nsec += add->tv_nsec;
/* Now adjust it so nanoseconds is in range */
while ( time->tv_nsec >= TOD_NANOSECONDS_PER_SECOND ) {
200c860: c4 00 60 04 ld [ %g1 + 4 ], %g2
200c864: 80 a0 80 03 cmp %g2, %g3
200c868: 18 bf ff f9 bgu 200c84c <_Timespec_Add_to+0x38> <== NEVER TAKEN
200c86c: 84 00 80 04 add %g2, %g4, %g2
time->tv_sec++;
seconds++;
}
return seconds;
}
200c870: 81 c3 e0 08 retl
0200a5bc <_Timespec_Divide>:
const struct timespec *lhs,
const struct timespec *rhs,
uint32_t *ival_percentage,
uint32_t *fval_percentage
)
{
200a5bc: 9d e3 bf a0 save %sp, -96, %sp
* For math simplicity just convert the timespec to nanoseconds
* in a 64-bit integer.
*/
left = lhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND;
left += lhs->tv_nsec;
right = rhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND;
200a5c0: c6 06 40 00 ld [ %i1 ], %g3
const struct timespec *lhs,
const struct timespec *rhs,
uint32_t *ival_percentage,
uint32_t *fval_percentage
)
{
200a5c4: 88 10 00 19 mov %i1, %g4
* For math simplicity just convert the timespec to nanoseconds
* in a 64-bit integer.
*/
left = lhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND;
left += lhs->tv_nsec;
right = rhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND;
200a5c8: 85 38 e0 1f sra %g3, 0x1f, %g2
/*
* For math simplicity just convert the timespec to nanoseconds
* in a 64-bit integer.
*/
left = lhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND;
200a5cc: de 06 00 00 ld [ %i0 ], %o7
left += lhs->tv_nsec;
right = rhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND;
200a5d0: b3 28 a0 03 sll %g2, 3, %i1
/*
* For math simplicity just convert the timespec to nanoseconds
* in a 64-bit integer.
*/
left = lhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND;
left += lhs->tv_nsec;
200a5d4: c2 06 20 04 ld [ %i0 + 4 ], %g1
right = rhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND;
200a5d8: b1 30 e0 1d srl %g3, 0x1d, %i0
200a5dc: bb 28 e0 03 sll %g3, 3, %i5
200a5e0: b8 16 00 19 or %i0, %i1, %i4
200a5e4: 9b 37 60 1b srl %i5, 0x1b, %o5
200a5e8: b1 2f 20 05 sll %i4, 5, %i0
200a5ec: b3 2f 60 05 sll %i5, 5, %i1
200a5f0: b0 13 40 18 or %o5, %i0, %i0
200a5f4: ba a6 40 1d subcc %i1, %i5, %i5
200a5f8: b8 66 00 1c subx %i0, %i4, %i4
200a5fc: 9b 37 60 1a srl %i5, 0x1a, %o5
200a600: b1 2f 20 06 sll %i4, 6, %i0
200a604: b3 2f 60 06 sll %i5, 6, %i1
200a608: b0 13 40 18 or %o5, %i0, %i0
200a60c: b2 a6 40 1d subcc %i1, %i5, %i1
200a610: b0 66 00 1c subx %i0, %i4, %i0
200a614: 86 86 40 03 addcc %i1, %g3, %g3
200a618: 84 46 00 02 addx %i0, %g2, %g2
200a61c: bb 30 e0 1e srl %g3, 0x1e, %i5
200a620: b1 28 a0 02 sll %g2, 2, %i0
200a624: b3 28 e0 02 sll %g3, 2, %i1
200a628: b0 17 40 18 or %i5, %i0, %i0
200a62c: 86 80 c0 19 addcc %g3, %i1, %g3
200a630: 84 40 80 18 addx %g2, %i0, %g2
200a634: bb 30 e0 1e srl %g3, 0x1e, %i5
200a638: b1 28 a0 02 sll %g2, 2, %i0
200a63c: b3 28 e0 02 sll %g3, 2, %i1
200a640: b0 17 40 18 or %i5, %i0, %i0
200a644: b2 80 c0 19 addcc %g3, %i1, %i1
right += rhs->tv_nsec;
200a648: d6 01 20 04 ld [ %g4 + 4 ], %o3
* For math simplicity just convert the timespec to nanoseconds
* in a 64-bit integer.
*/
left = lhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND;
left += lhs->tv_nsec;
right = rhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND;
200a64c: b0 40 80 18 addx %g2, %i0, %i0
200a650: 85 36 60 1e srl %i1, 0x1e, %g2
200a654: bb 2e 60 02 sll %i1, 2, %i5
200a658: b9 2e 20 02 sll %i0, 2, %i4
200a65c: 86 86 40 1d addcc %i1, %i5, %g3
200a660: b8 10 80 1c or %g2, %i4, %i4
200a664: 84 46 00 1c addx %i0, %i4, %g2
right += rhs->tv_nsec;
200a668: 95 3a e0 1f sra %o3, 0x1f, %o2
* For math simplicity just convert the timespec to nanoseconds
* in a 64-bit integer.
*/
left = lhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND;
left += lhs->tv_nsec;
right = rhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND;
200a66c: b3 30 e0 17 srl %g3, 0x17, %i1
200a670: b9 28 a0 09 sll %g2, 9, %i4
200a674: bb 28 e0 09 sll %g3, 9, %i5
200a678: 84 16 40 1c or %i1, %i4, %g2
right += rhs->tv_nsec;
200a67c: 96 87 40 0b addcc %i5, %o3, %o3
200a680: 94 40 80 0a addx %g2, %o2, %o2
if ( right == 0 ) {
200a684: 80 92 80 0b orcc %o2, %o3, %g0
200a688: 32 80 00 06 bne,a 200a6a0 <_Timespec_Divide+0xe4> <== NEVER TAKEN
200a68c: b9 3b e0 1f sra %o7, 0x1f, %i4 <== NOT EXECUTED
*ival_percentage = 0;
200a690: c0 26 80 00 clr [ %i2 ]
*fval_percentage = 0;
200a694: c0 26 c0 00 clr [ %i3 ]
return;
200a698: 81 c7 e0 08 ret
200a69c: 81 e8 00 00 restore
/*
* For math simplicity just convert the timespec to nanoseconds
* in a 64-bit integer.
*/
left = lhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND;
200a6a0: 85 2f 20 03 sll %i4, 3, %g2 <== NOT EXECUTED
200a6a4: b3 2b e0 03 sll %o7, 3, %i1 <== NOT EXECUTED
200a6a8: 87 33 e0 1d srl %o7, 0x1d, %g3 <== NOT EXECUTED
200a6ac: b0 10 c0 02 or %g3, %g2, %i0 <== NOT EXECUTED
200a6b0: 85 36 60 1b srl %i1, 0x1b, %g2 <== NOT EXECUTED
200a6b4: 99 2e 20 05 sll %i0, 5, %o4 <== NOT EXECUTED
200a6b8: 9b 2e 60 05 sll %i1, 5, %o5 <== NOT EXECUTED
200a6bc: 98 10 80 0c or %g2, %o4, %o4 <== NOT EXECUTED
200a6c0: b2 a3 40 19 subcc %o5, %i1, %i1 <== NOT EXECUTED
200a6c4: 85 36 60 1a srl %i1, 0x1a, %g2 <== NOT EXECUTED
200a6c8: b0 63 00 18 subx %o4, %i0, %i0 <== NOT EXECUTED
200a6cc: 9b 2e 60 06 sll %i1, 6, %o5 <== NOT EXECUTED
200a6d0: 99 2e 20 06 sll %i0, 6, %o4 <== NOT EXECUTED
200a6d4: 9a a3 40 19 subcc %o5, %i1, %o5 <== NOT EXECUTED
200a6d8: 98 10 80 0c or %g2, %o4, %o4 <== NOT EXECUTED
200a6dc: 98 63 00 18 subx %o4, %i0, %o4 <== NOT EXECUTED
200a6e0: ba 83 40 0f addcc %o5, %o7, %i5 <== NOT EXECUTED
200a6e4: 85 37 60 1e srl %i5, 0x1e, %g2 <== NOT EXECUTED
200a6e8: b8 43 00 1c addx %o4, %i4, %i4 <== NOT EXECUTED
200a6ec: 9b 2f 60 02 sll %i5, 2, %o5 <== NOT EXECUTED
200a6f0: 99 2f 20 02 sll %i4, 2, %o4 <== NOT EXECUTED
200a6f4: ba 87 40 0d addcc %i5, %o5, %i5 <== NOT EXECUTED
200a6f8: 98 10 80 0c or %g2, %o4, %o4 <== NOT EXECUTED
200a6fc: 85 37 60 1e srl %i5, 0x1e, %g2 <== NOT EXECUTED
200a700: b8 47 00 0c addx %i4, %o4, %i4 <== NOT EXECUTED
200a704: 9b 2f 60 02 sll %i5, 2, %o5 <== NOT EXECUTED
200a708: 99 2f 20 02 sll %i4, 2, %o4 <== NOT EXECUTED
200a70c: 9a 87 40 0d addcc %i5, %o5, %o5 <== NOT EXECUTED
200a710: 98 10 80 0c or %g2, %o4, %o4 <== NOT EXECUTED
200a714: 85 33 60 1e srl %o5, 0x1e, %g2 <== NOT EXECUTED
200a718: 98 47 00 0c addx %i4, %o4, %o4 <== NOT EXECUTED
200a71c: b3 2b 60 02 sll %o5, 2, %i1 <== NOT EXECUTED
200a720: b1 2b 20 02 sll %o4, 2, %i0 <== NOT EXECUTED
200a724: 86 83 40 19 addcc %o5, %i1, %g3 <== NOT EXECUTED
200a728: b0 10 80 18 or %g2, %i0, %i0 <== NOT EXECUTED
200a72c: 84 43 00 18 addx %o4, %i0, %g2 <== NOT EXECUTED
200a730: 89 28 e0 09 sll %g3, 9, %g4 <== NOT EXECUTED
200a734: b9 30 e0 17 srl %g3, 0x17, %i4 <== NOT EXECUTED
left += lhs->tv_nsec;
200a738: 92 81 00 01 addcc %g4, %g1, %o1 <== NOT EXECUTED
/*
* For math simplicity just convert the timespec to nanoseconds
* in a 64-bit integer.
*/
left = lhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND;
200a73c: bb 28 a0 09 sll %g2, 9, %i5 <== NOT EXECUTED
left += lhs->tv_nsec;
200a740: 91 38 60 1f sra %g1, 0x1f, %o0 <== NOT EXECUTED
/*
* For math simplicity just convert the timespec to nanoseconds
* in a 64-bit integer.
*/
left = lhs->tv_sec * (uint64_t)TOD_NANOSECONDS_PER_SECOND;
200a744: 84 17 00 1d or %i4, %i5, %g2 <== NOT EXECUTED
left += lhs->tv_nsec;
200a748: 90 40 80 08 addx %g2, %o0, %o0 <== NOT EXECUTED
* Put it back in the timespec result.
*
* TODO: Rounding on the last digit of the fval.
*/
answer = (left * 100000) / right;
200a74c: 83 2a 20 02 sll %o0, 2, %g1 <== NOT EXECUTED
200a750: bb 2a 60 02 sll %o1, 2, %i5 <== NOT EXECUTED
200a754: 85 32 60 1e srl %o1, 0x1e, %g2 <== NOT EXECUTED
200a758: b8 10 80 01 or %g2, %g1, %i4 <== NOT EXECUTED
200a75c: 83 37 60 1b srl %i5, 0x1b, %g1 <== NOT EXECUTED
200a760: 9b 2f 60 05 sll %i5, 5, %o5 <== NOT EXECUTED
200a764: 99 2f 20 05 sll %i4, 5, %o4 <== NOT EXECUTED
200a768: ba a3 40 1d subcc %o5, %i5, %i5 <== NOT EXECUTED
200a76c: 98 10 40 0c or %g1, %o4, %o4 <== NOT EXECUTED
200a770: b8 63 00 1c subx %o4, %i4, %i4 <== NOT EXECUTED
200a774: 92 87 40 09 addcc %i5, %o1, %o1 <== NOT EXECUTED
200a778: 83 32 60 1e srl %o1, 0x1e, %g1 <== NOT EXECUTED
200a77c: 90 47 00 08 addx %i4, %o0, %o0 <== NOT EXECUTED
200a780: b3 2a 60 02 sll %o1, 2, %i1 <== NOT EXECUTED
200a784: b1 2a 20 02 sll %o0, 2, %i0 <== NOT EXECUTED
200a788: 92 82 40 19 addcc %o1, %i1, %o1 <== NOT EXECUTED
200a78c: b0 10 40 18 or %g1, %i0, %i0 <== NOT EXECUTED
200a790: 83 32 60 1e srl %o1, 0x1e, %g1 <== NOT EXECUTED
200a794: 90 42 00 18 addx %o0, %i0, %o0 <== NOT EXECUTED
200a798: b3 2a 60 02 sll %o1, 2, %i1 <== NOT EXECUTED
200a79c: b1 2a 20 02 sll %o0, 2, %i0 <== NOT EXECUTED
200a7a0: 92 82 40 19 addcc %o1, %i1, %o1 <== NOT EXECUTED
200a7a4: b0 10 40 18 or %g1, %i0, %i0 <== NOT EXECUTED
200a7a8: 87 32 60 1b srl %o1, 0x1b, %g3 <== NOT EXECUTED
200a7ac: 90 42 00 18 addx %o0, %i0, %o0 <== NOT EXECUTED
200a7b0: 83 2a 60 05 sll %o1, 5, %g1 <== NOT EXECUTED
200a7b4: 85 2a 20 05 sll %o0, 5, %g2 <== NOT EXECUTED
200a7b8: 92 10 00 01 mov %g1, %o1 <== NOT EXECUTED
200a7bc: 40 00 3a 5c call 201912c <__udivdi3> <== NOT EXECUTED
200a7c0: 90 10 c0 02 or %g3, %g2, %o0 <== NOT EXECUTED
*ival_percentage = answer / 1000;
200a7c4: 94 10 20 00 clr %o2 <== NOT EXECUTED
* Put it back in the timespec result.
*
* TODO: Rounding on the last digit of the fval.
*/
answer = (left * 100000) / right;
200a7c8: b8 10 00 08 mov %o0, %i4 <== NOT EXECUTED
200a7cc: ba 10 00 09 mov %o1, %i5 <== NOT EXECUTED
*ival_percentage = answer / 1000;
200a7d0: 40 00 3a 57 call 201912c <__udivdi3> <== NOT EXECUTED
200a7d4: 96 10 23 e8 mov 0x3e8, %o3 <== NOT EXECUTED
*fval_percentage = answer % 1000;
200a7d8: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
* TODO: Rounding on the last digit of the fval.
*/
answer = (left * 100000) / right;
*ival_percentage = answer / 1000;
200a7dc: d2 26 80 00 st %o1, [ %i2 ] <== NOT EXECUTED
*fval_percentage = answer % 1000;
200a7e0: 94 10 20 00 clr %o2 <== NOT EXECUTED
200a7e4: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
200a7e8: 40 00 3b 25 call 201947c <__umoddi3> <== NOT EXECUTED
200a7ec: 96 10 23 e8 mov 0x3e8, %o3 <== NOT EXECUTED
200a7f0: d2 26 c0 00 st %o1, [ %i3 ] <== NOT EXECUTED
200a7f4: 81 c7 e0 08 ret <== NOT EXECUTED
200a7f8: 81 e8 00 00 restore <== NOT EXECUTED
0200c57c <_Timestamp64_Divide>:
const Timestamp64_Control *_lhs,
const Timestamp64_Control *_rhs,
uint32_t *_ival_percentage,
uint32_t *_fval_percentage
)
{
200c57c: 9d e3 bf a0 save %sp, -96, %sp
Timestamp64_Control answer;
if ( *_rhs == 0 ) {
200c580: d4 1e 40 00 ldd [ %i1 ], %o2
200c584: 80 92 80 0b orcc %o2, %o3, %g0
200c588: 32 80 00 06 bne,a 200c5a0 <_Timestamp64_Divide+0x24> <== ALWAYS TAKEN
200c58c: f8 1e 00 00 ldd [ %i0 ], %i4
*_ival_percentage = 0;
200c590: c0 26 80 00 clr [ %i2 ] <== NOT EXECUTED
*_fval_percentage = 0;
200c594: c0 26 c0 00 clr [ %i3 ] <== NOT EXECUTED
return;
200c598: 81 c7 e0 08 ret <== NOT EXECUTED
200c59c: 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;
200c5a0: 83 2f 20 02 sll %i4, 2, %g1
200c5a4: 89 37 60 1e srl %i5, 0x1e, %g4
200c5a8: 87 2f 60 02 sll %i5, 2, %g3
200c5ac: 84 11 00 01 or %g4, %g1, %g2
200c5b0: 83 30 e0 1b srl %g3, 0x1b, %g1
200c5b4: b1 28 a0 05 sll %g2, 5, %i0
200c5b8: b3 28 e0 05 sll %g3, 5, %i1
200c5bc: b0 10 40 18 or %g1, %i0, %i0
200c5c0: 92 a6 40 03 subcc %i1, %g3, %o1
200c5c4: 90 66 00 02 subx %i0, %g2, %o0
200c5c8: 92 82 40 1d addcc %o1, %i5, %o1
200c5cc: 83 32 60 1e srl %o1, 0x1e, %g1
200c5d0: 90 42 00 1c addx %o0, %i4, %o0
200c5d4: bb 2a 60 02 sll %o1, 2, %i5
200c5d8: b9 2a 20 02 sll %o0, 2, %i4
200c5dc: 92 82 40 1d addcc %o1, %i5, %o1
200c5e0: b8 10 40 1c or %g1, %i4, %i4
200c5e4: 83 32 60 1e srl %o1, 0x1e, %g1
200c5e8: 90 42 00 1c addx %o0, %i4, %o0
200c5ec: bb 2a 60 02 sll %o1, 2, %i5
200c5f0: b9 2a 20 02 sll %o0, 2, %i4
200c5f4: 92 82 40 1d addcc %o1, %i5, %o1
200c5f8: b8 10 40 1c or %g1, %i4, %i4
200c5fc: 87 32 60 1b srl %o1, 0x1b, %g3
200c600: 90 42 00 1c addx %o0, %i4, %o0
200c604: 83 2a 60 05 sll %o1, 5, %g1
200c608: 85 2a 20 05 sll %o0, 5, %g2
200c60c: 92 10 00 01 mov %g1, %o1
200c610: 40 00 3a 13 call 201ae5c <__divdi3>
200c614: 90 10 c0 02 or %g3, %g2, %o0
*_ival_percentage = answer / 1000;
200c618: 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;
200c61c: b8 10 00 08 mov %o0, %i4
200c620: ba 10 00 09 mov %o1, %i5
*_ival_percentage = answer / 1000;
200c624: 40 00 3a 0e call 201ae5c <__divdi3>
200c628: 96 10 23 e8 mov 0x3e8, %o3
*_fval_percentage = answer % 1000;
200c62c: 90 10 00 1c mov %i4, %o0
* TODO: Rounding on the last digit of the fval.
*/
answer = (*_lhs * 100000) / *_rhs;
*_ival_percentage = answer / 1000;
200c630: d2 26 80 00 st %o1, [ %i2 ]
*_fval_percentage = answer % 1000;
200c634: 94 10 20 00 clr %o2
200c638: 92 10 00 1d mov %i5, %o1
200c63c: 40 00 3a f3 call 201b208 <__moddi3>
200c640: 96 10 23 e8 mov 0x3e8, %o3
200c644: d2 26 c0 00 st %o1, [ %i3 ]
200c648: 81 c7 e0 08 ret
200c64c: 81 e8 00 00 restore
0200ac30 <_User_extensions_Handler_initialization>:
#include <rtems/score/userext.h>
#include <rtems/score/wkspace.h>
#include <string.h>
void _User_extensions_Handler_initialization(void)
{
200ac30: 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;
200ac34: 03 00 80 73 sethi %hi(0x201cc00), %g1
200ac38: 82 10 60 fc or %g1, 0xfc, %g1 ! 201ccfc <Configuration>
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
200ac3c: 05 00 80 77 sethi %hi(0x201dc00), %g2
initial_extensions = Configuration.User_extension_table;
200ac40: 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;
200ac44: f8 00 60 44 ld [ %g1 + 0x44 ], %i4
200ac48: 82 10 a0 c8 or %g2, 0xc8, %g1
200ac4c: 86 00 60 04 add %g1, 4, %g3
head->previous = NULL;
200ac50: c0 20 60 04 clr [ %g1 + 4 ]
tail->previous = head;
200ac54: 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;
200ac58: c6 20 a0 c8 st %g3, [ %g2 + 0xc8 ]
200ac5c: 05 00 80 76 sethi %hi(0x201d800), %g2
200ac60: 82 10 a2 f4 or %g2, 0x2f4, %g1 ! 201daf4 <_User_extensions_Switches_list>
200ac64: 86 00 60 04 add %g1, 4, %g3
head->previous = NULL;
200ac68: c0 20 60 04 clr [ %g1 + 4 ]
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
200ac6c: c6 20 a2 f4 st %g3, [ %g2 + 0x2f4 ]
initial_extensions = Configuration.User_extension_table;
_Chain_Initialize_empty( &_User_extensions_List );
_Chain_Initialize_empty( &_User_extensions_Switches_list );
if ( initial_extensions ) {
200ac70: 80 a6 a0 00 cmp %i2, 0
200ac74: 02 80 00 1b be 200ace0 <_User_extensions_Handler_initialization+0xb0><== NEVER TAKEN
200ac78: c2 20 60 08 st %g1, [ %g1 + 8 ]
extension = (User_extensions_Control *)
_Workspace_Allocate_or_fatal_error(
number_of_extensions * sizeof( User_extensions_Control )
200ac7c: 83 2f 20 02 sll %i4, 2, %g1
200ac80: b7 2f 20 04 sll %i4, 4, %i3
200ac84: b6 26 c0 01 sub %i3, %g1, %i3
200ac88: b6 06 c0 1c add %i3, %i4, %i3
200ac8c: 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 *)
200ac90: 40 00 01 71 call 200b254 <_Workspace_Allocate_or_fatal_error>
200ac94: 90 10 00 1b mov %i3, %o0
_Workspace_Allocate_or_fatal_error(
number_of_extensions * sizeof( User_extensions_Control )
);
memset (
200ac98: 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 *)
200ac9c: ba 10 00 08 mov %o0, %i5
_Workspace_Allocate_or_fatal_error(
number_of_extensions * sizeof( User_extensions_Control )
);
memset (
200aca0: 92 10 20 00 clr %o1
200aca4: 40 00 15 e1 call 2010428 <memset>
200aca8: b6 10 20 00 clr %i3
extension,
0,
number_of_extensions * sizeof( User_extensions_Control )
);
for ( i = 0 ; i < number_of_extensions ; i++ ) {
200acac: 10 80 00 0b b 200acd8 <_User_extensions_Handler_initialization+0xa8>
200acb0: 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;
200acb4: 90 07 60 14 add %i5, 0x14, %o0
200acb8: 92 06 80 09 add %i2, %o1, %o1
200acbc: 40 00 15 9e call 2010334 <memcpy>
200acc0: 94 10 20 20 mov 0x20, %o2
_User_extensions_Add_set( extension );
200acc4: 90 10 00 1d mov %i5, %o0
200acc8: 40 00 0c 7d call 200debc <_User_extensions_Add_set>
200accc: b6 06 e0 01 inc %i3
_User_extensions_Add_set_with_table (extension, &initial_extensions[i]);
extension++;
200acd0: 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++ ) {
200acd4: 80 a6 c0 1c cmp %i3, %i4
200acd8: 12 bf ff f7 bne 200acb4 <_User_extensions_Handler_initialization+0x84>
200acdc: 93 2e e0 05 sll %i3, 5, %o1
200ace0: 81 c7 e0 08 ret
200ace4: 81 e8 00 00 restore
0200c958 <_Watchdog_Adjust>:
void _Watchdog_Adjust(
Chain_Control *header,
Watchdog_Adjust_directions direction,
Watchdog_Interval units
)
{
200c958: 9d e3 bf a0 save %sp, -96, %sp
ISR_Level level;
_ISR_Disable( level );
200c95c: 7f ff da ec call 200350c <sparc_disable_interrupts>
200c960: 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;
200c964: 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 );
200c968: 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 ) ) {
200c96c: 80 a0 40 1c cmp %g1, %i4
200c970: 02 80 00 20 be 200c9f0 <_Watchdog_Adjust+0x98>
200c974: 80 a6 60 00 cmp %i1, 0
switch ( direction ) {
200c978: 02 80 00 1b be 200c9e4 <_Watchdog_Adjust+0x8c>
200c97c: b6 10 20 01 mov 1, %i3
200c980: 80 a6 60 01 cmp %i1, 1
200c984: 12 80 00 1b bne 200c9f0 <_Watchdog_Adjust+0x98> <== NEVER TAKEN
200c988: 01 00 00 00 nop
case WATCHDOG_BACKWARD:
_Watchdog_First( header )->delta_interval += units;
200c98c: c4 00 60 10 ld [ %g1 + 0x10 ], %g2
200c990: 10 80 00 07 b 200c9ac <_Watchdog_Adjust+0x54>
200c994: b4 00 80 1a add %g2, %i2, %i2
break;
case WATCHDOG_FORWARD:
while ( units ) {
if ( units < _Watchdog_First( header )->delta_interval ) {
200c998: c4 00 60 10 ld [ %g1 + 0x10 ], %g2
200c99c: 80 a6 80 02 cmp %i2, %g2
200c9a0: 3a 80 00 05 bcc,a 200c9b4 <_Watchdog_Adjust+0x5c>
200c9a4: f6 20 60 10 st %i3, [ %g1 + 0x10 ]
_Watchdog_First( header )->delta_interval -= units;
200c9a8: b4 20 80 1a sub %g2, %i2, %i2
break;
200c9ac: 10 80 00 11 b 200c9f0 <_Watchdog_Adjust+0x98>
200c9b0: f4 20 60 10 st %i2, [ %g1 + 0x10 ]
} else {
units -= _Watchdog_First( header )->delta_interval;
200c9b4: b4 26 80 02 sub %i2, %g2, %i2
_Watchdog_First( header )->delta_interval = 1;
_ISR_Enable( level );
200c9b8: 7f ff da d9 call 200351c <sparc_enable_interrupts>
200c9bc: 01 00 00 00 nop
_Watchdog_Tickle( header );
200c9c0: 40 00 00 90 call 200cc00 <_Watchdog_Tickle>
200c9c4: 90 10 00 18 mov %i0, %o0
_ISR_Disable( level );
200c9c8: 7f ff da d1 call 200350c <sparc_disable_interrupts>
200c9cc: 01 00 00 00 nop
if ( _Chain_Is_empty( header ) )
200c9d0: c2 06 00 00 ld [ %i0 ], %g1
200c9d4: 80 a0 40 1c cmp %g1, %i4
200c9d8: 12 80 00 04 bne 200c9e8 <_Watchdog_Adjust+0x90>
200c9dc: 80 a6 a0 00 cmp %i2, 0
200c9e0: 30 80 00 04 b,a 200c9f0 <_Watchdog_Adjust+0x98>
switch ( direction ) {
case WATCHDOG_BACKWARD:
_Watchdog_First( header )->delta_interval += units;
break;
case WATCHDOG_FORWARD:
while ( units ) {
200c9e4: 80 a6 a0 00 cmp %i2, 0
200c9e8: 32 bf ff ec bne,a 200c998 <_Watchdog_Adjust+0x40> <== ALWAYS TAKEN
200c9ec: c2 06 00 00 ld [ %i0 ], %g1
}
break;
}
}
_ISR_Enable( level );
200c9f0: 7f ff da cb call 200351c <sparc_enable_interrupts>
200c9f4: 91 e8 00 08 restore %g0, %o0, %o0
0200b058 <_Watchdog_Remove>:
*/
Watchdog_States _Watchdog_Remove(
Watchdog_Control *the_watchdog
)
{
200b058: 9d e3 bf a0 save %sp, -96, %sp
ISR_Level level;
Watchdog_States previous_state;
Watchdog_Control *next_watchdog;
_ISR_Disable( level );
200b05c: 7f ff dd 9a call 20026c4 <sparc_disable_interrupts>
200b060: ba 10 00 18 mov %i0, %i5
previous_state = the_watchdog->state;
200b064: f0 06 20 08 ld [ %i0 + 8 ], %i0
switch ( previous_state ) {
200b068: 80 a6 20 01 cmp %i0, 1
200b06c: 22 80 00 1e be,a 200b0e4 <_Watchdog_Remove+0x8c>
200b070: c0 27 60 08 clr [ %i5 + 8 ]
200b074: 0a 80 00 1d bcs 200b0e8 <_Watchdog_Remove+0x90>
200b078: 03 00 80 76 sethi %hi(0x201d800), %g1
200b07c: 80 a6 20 03 cmp %i0, 3
200b080: 18 80 00 1a bgu 200b0e8 <_Watchdog_Remove+0x90> <== NEVER TAKEN
200b084: 01 00 00 00 nop
RTEMS_INLINE_ROUTINE Watchdog_Control *_Watchdog_Next(
Watchdog_Control *the_watchdog
)
{
return ( (Watchdog_Control *) the_watchdog->Node.next );
200b088: 10 80 00 02 b 200b090 <_Watchdog_Remove+0x38>
200b08c: c2 07 40 00 ld [ %i5 ], %g1
break;
case WATCHDOG_ACTIVE:
case WATCHDOG_REMOVE_IT:
the_watchdog->state = WATCHDOG_INACTIVE;
200b090: c0 27 60 08 clr [ %i5 + 8 ]
next_watchdog = _Watchdog_Next( the_watchdog );
if ( _Watchdog_Next(next_watchdog) )
200b094: c4 00 40 00 ld [ %g1 ], %g2
200b098: 80 a0 a0 00 cmp %g2, 0
200b09c: 02 80 00 07 be 200b0b8 <_Watchdog_Remove+0x60>
200b0a0: 05 00 80 76 sethi %hi(0x201d800), %g2
next_watchdog->delta_interval += the_watchdog->delta_interval;
200b0a4: c6 00 60 10 ld [ %g1 + 0x10 ], %g3
200b0a8: c4 07 60 10 ld [ %i5 + 0x10 ], %g2
200b0ac: 84 00 c0 02 add %g3, %g2, %g2
200b0b0: c4 20 60 10 st %g2, [ %g1 + 0x10 ]
if ( _Watchdog_Sync_count )
200b0b4: 05 00 80 76 sethi %hi(0x201d800), %g2
200b0b8: c4 00 a3 e4 ld [ %g2 + 0x3e4 ], %g2 ! 201dbe4 <_Watchdog_Sync_count>
200b0bc: 80 a0 a0 00 cmp %g2, 0
200b0c0: 22 80 00 07 be,a 200b0dc <_Watchdog_Remove+0x84>
200b0c4: c4 07 60 04 ld [ %i5 + 4 ], %g2
_Watchdog_Sync_level = _ISR_Nest_level;
200b0c8: 05 00 80 78 sethi %hi(0x201e000), %g2
200b0cc: c6 00 a0 28 ld [ %g2 + 0x28 ], %g3 ! 201e028 <_Per_CPU_Information+0x8>
200b0d0: 05 00 80 76 sethi %hi(0x201d800), %g2
200b0d4: c6 20 a3 84 st %g3, [ %g2 + 0x384 ] ! 201db84 <_Watchdog_Sync_level>
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
previous = the_node->previous;
200b0d8: c4 07 60 04 ld [ %i5 + 4 ], %g2
next->previous = previous;
200b0dc: c4 20 60 04 st %g2, [ %g1 + 4 ]
previous->next = next;
200b0e0: c2 20 80 00 st %g1, [ %g2 ]
_Chain_Extract_unprotected( &the_watchdog->Node );
break;
}
the_watchdog->stop_time = _Watchdog_Ticks_since_boot;
200b0e4: 03 00 80 76 sethi %hi(0x201d800), %g1
200b0e8: c2 00 63 e8 ld [ %g1 + 0x3e8 ], %g1 ! 201dbe8 <_Watchdog_Ticks_since_boot>
200b0ec: c2 27 60 18 st %g1, [ %i5 + 0x18 ]
_ISR_Enable( level );
200b0f0: 7f ff dd 79 call 20026d4 <sparc_enable_interrupts>
200b0f4: 01 00 00 00 nop
return( previous_state );
}
200b0f8: 81 c7 e0 08 ret
200b0fc: 81 e8 00 00 restore
0200c2c8 <_Watchdog_Report_chain>:
void _Watchdog_Report_chain(
const char *name,
Chain_Control *header
)
{
200c2c8: 9d e3 bf a0 save %sp, -96, %sp
ISR_Level level;
Chain_Node *node;
_ISR_Disable( level );
200c2cc: 7f ff db 6d call 2003080 <sparc_disable_interrupts>
200c2d0: b8 10 00 18 mov %i0, %i4
200c2d4: b0 10 00 08 mov %o0, %i0
printk( "Watchdog Chain: %s %p\n", name, header );
200c2d8: 11 00 80 76 sethi %hi(0x201d800), %o0
200c2dc: 94 10 00 19 mov %i1, %o2
200c2e0: 90 12 20 60 or %o0, 0x60, %o0
200c2e4: 7f ff e3 51 call 2005028 <printk>
200c2e8: 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;
200c2ec: 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 );
200c2f0: b2 06 60 04 add %i1, 4, %i1
if ( !_Chain_Is_empty( header ) ) {
200c2f4: 80 a7 40 19 cmp %i5, %i1
200c2f8: 12 80 00 04 bne 200c308 <_Watchdog_Report_chain+0x40>
200c2fc: 92 10 00 1d mov %i5, %o1
_Watchdog_Report( NULL, watch );
}
printk( "== end of %s \n", name );
} else {
printk( "Chain is empty\n" );
200c300: 10 80 00 0d b 200c334 <_Watchdog_Report_chain+0x6c>
200c304: 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 );
200c308: 40 00 00 0f call 200c344 <_Watchdog_Report>
200c30c: 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 )
200c310: 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 ) ;
200c314: 80 a7 40 19 cmp %i5, %i1
200c318: 12 bf ff fc bne 200c308 <_Watchdog_Report_chain+0x40> <== NEVER TAKEN
200c31c: 92 10 00 1d mov %i5, %o1
{
Watchdog_Control *watch = (Watchdog_Control *) node;
_Watchdog_Report( NULL, watch );
}
printk( "== end of %s \n", name );
200c320: 11 00 80 76 sethi %hi(0x201d800), %o0
200c324: 92 10 00 1c mov %i4, %o1
200c328: 7f ff e3 40 call 2005028 <printk>
200c32c: 90 12 20 78 or %o0, 0x78, %o0
200c330: 30 80 00 03 b,a 200c33c <_Watchdog_Report_chain+0x74>
} else {
printk( "Chain is empty\n" );
200c334: 7f ff e3 3d call 2005028 <printk>
200c338: 90 12 20 88 or %o0, 0x88, %o0
}
_ISR_Enable( level );
200c33c: 7f ff db 55 call 2003090 <sparc_enable_interrupts>
200c340: 81 e8 00 00 restore
02011b64 <_fat_block_read>:
uint32_t start,
uint32_t offset,
uint32_t count,
void *buff
)
{
2011b64: 9d e3 bf 98 save %sp, -104, %sp
int rc = RC_OK;
ssize_t cmpltd = 0;
2011b68: 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)
2011b6c: 10 80 00 18 b 2011bcc <_fat_block_read+0x68>
2011b70: c0 27 bf fc clr [ %fp + -4 ]
{
rc = fat_buf_access(fs_info, blk, FAT_OP_TYPE_READ, &block);
2011b74: 92 10 00 19 mov %i1, %o1
2011b78: 94 10 20 01 mov 1, %o2
2011b7c: 7f ff ff 25 call 2011810 <fat_buf_access>
2011b80: 96 07 bf fc add %fp, -4, %o3
if (rc != RC_OK)
2011b84: 80 a2 20 00 cmp %o0, 0
2011b88: 32 80 00 16 bne,a 2011be0 <_fat_block_read+0x7c> <== NEVER TAKEN
2011b8c: ba 10 3f ff mov -1, %i5 <== NOT EXECUTED
return -1;
c = MIN(count, (fs_info->vol.bps - ofs));
2011b90: e0 16 00 00 lduh [ %i0 ], %l0
2011b94: a0 24 00 1a sub %l0, %i2, %l0
2011b98: 80 a4 00 1b cmp %l0, %i3
2011b9c: 38 80 00 02 bgu,a 2011ba4 <_fat_block_read+0x40>
2011ba0: a0 10 00 1b mov %i3, %l0
memcpy((buff + cmpltd), (block->buffer + ofs), c);
2011ba4: c2 07 bf fc ld [ %fp + -4 ], %g1
2011ba8: 90 07 00 1d add %i4, %i5, %o0
2011bac: d2 00 60 1c ld [ %g1 + 0x1c ], %o1
2011bb0: 94 10 00 10 mov %l0, %o2
2011bb4: 92 02 40 1a add %o1, %i2, %o1
2011bb8: 40 00 23 cf call 201aaf4 <memcpy>
2011bbc: b6 26 c0 10 sub %i3, %l0, %i3
count -= c;
cmpltd += c;
2011bc0: ba 04 00 1d add %l0, %i5, %i5
blk++;
2011bc4: b2 06 60 01 inc %i1
ofs = 0;
2011bc8: 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)
2011bcc: 80 a6 e0 00 cmp %i3, 0
2011bd0: 12 bf ff e9 bne 2011b74 <_fat_block_read+0x10>
2011bd4: 90 10 00 18 mov %i0, %o0
cmpltd += c;
blk++;
ofs = 0;
}
return cmpltd;
}
2011bd8: 81 c7 e0 08 ret
2011bdc: 91 e8 00 1d restore %g0, %i5, %o0
2011be0: b0 10 00 1d mov %i5, %i0 <== NOT EXECUTED
2011be4: 81 c7 e0 08 ret <== NOT EXECUTED
2011be8: 81 e8 00 00 restore <== NOT EXECUTED
02011bec <_fat_block_write>:
fat_fs_info_t *fs_info,
uint32_t start,
uint32_t offset,
uint32_t count,
const void *buff)
{
2011bec: 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;
2011bf0: a2 10 20 01 mov 1, %l1
2011bf4: 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;
2011bf8: c0 27 bf fc clr [ %fp + -4 ]
uint32_t c = 0;
while(count > 0)
2011bfc: 10 80 00 1b b 2011c68 <_fat_block_write+0x7c>
2011c00: b0 10 20 00 clr %i0
{
c = MIN(count, (fs_info->vol.bps - ofs));
2011c04: ba 20 40 1a sub %g1, %i2, %i5
2011c08: 80 a7 40 1b cmp %i5, %i3
2011c0c: 38 80 00 02 bgu,a 2011c14 <_fat_block_write+0x28>
2011c10: 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);
2011c14: 90 10 00 10 mov %l0, %o0
2011c18: 92 10 00 19 mov %i1, %o1
while(count > 0)
{
c = MIN(count, (fs_info->vol.bps - ofs));
if (c == fs_info->vol.bps)
2011c1c: 80 a7 40 01 cmp %i5, %g1
2011c20: 02 80 00 03 be 2011c2c <_fat_block_write+0x40>
2011c24: 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);
2011c28: 94 10 20 01 mov 1, %o2
2011c2c: 7f ff fe f9 call 2011810 <fat_buf_access>
2011c30: 96 07 bf fc add %fp, -4, %o3
if (rc != RC_OK)
2011c34: 80 a2 20 00 cmp %o0, 0
2011c38: 12 80 00 11 bne 2011c7c <_fat_block_write+0x90> <== NEVER TAKEN
2011c3c: c2 07 bf fc ld [ %fp + -4 ], %g1
return -1;
memcpy((block->buffer + ofs), (buff + cmpltd), c);
2011c40: 92 07 00 18 add %i4, %i0, %o1
2011c44: d0 00 60 1c ld [ %g1 + 0x1c ], %o0
2011c48: 94 10 00 1d mov %i5, %o2
2011c4c: 90 02 00 1a add %o0, %i2, %o0
2011c50: 40 00 23 a9 call 201aaf4 <memcpy>
2011c54: b6 26 c0 1d sub %i3, %i5, %i3
fat_buf_mark_modified(fs_info);
count -= c;
cmpltd +=c;
2011c58: b0 07 40 18 add %i5, %i0, %i0
2011c5c: e2 2c 20 7c stb %l1, [ %l0 + 0x7c ]
blk++;
2011c60: b2 06 60 01 inc %i1
ofs = 0;
2011c64: 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)
2011c68: 80 a6 e0 00 cmp %i3, 0
2011c6c: 32 bf ff e6 bne,a 2011c04 <_fat_block_write+0x18>
2011c70: c2 14 00 00 lduh [ %l0 ], %g1
2011c74: 81 c7 e0 08 ret
2011c78: 81 e8 00 00 restore
cmpltd +=c;
blk++;
ofs = 0;
}
return cmpltd;
}
2011c7c: 81 c7 e0 08 ret <== NOT EXECUTED
2011c80: 91 e8 3f ff restore %g0, -1, %o0 <== NOT EXECUTED
02011c84 <_fat_block_zero>:
_fat_block_zero(
fat_fs_info_t *fs_info,
uint32_t start,
uint32_t offset,
uint32_t count)
{
2011c84: 9d e3 bf 98 save %sp, -104, %sp
2011c88: 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)
2011c8c: 10 80 00 1a b 2011cf4 <_fat_block_zero+0x70>
2011c90: c0 27 bf fc clr [ %fp + -4 ]
{
c = MIN(count, (fs_info->vol.bps - ofs));
2011c94: ba 20 40 1a sub %g1, %i2, %i5
2011c98: 80 a7 40 1b cmp %i5, %i3
2011c9c: 38 80 00 02 bgu,a 2011ca4 <_fat_block_zero+0x20> <== NEVER TAKEN
2011ca0: 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);
2011ca4: 90 10 00 18 mov %i0, %o0
2011ca8: 92 10 00 19 mov %i1, %o1
while(count > 0)
{
c = MIN(count, (fs_info->vol.bps - ofs));
if (c == fs_info->vol.bps)
2011cac: 80 a7 40 01 cmp %i5, %g1
2011cb0: 02 80 00 03 be 2011cbc <_fat_block_zero+0x38>
2011cb4: 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);
2011cb8: 94 10 20 01 mov 1, %o2
2011cbc: 7f ff fe d5 call 2011810 <fat_buf_access>
2011cc0: 96 07 bf fc add %fp, -4, %o3
if (rc != RC_OK)
2011cc4: 80 a2 20 00 cmp %o0, 0
2011cc8: 12 80 00 10 bne 2011d08 <_fat_block_zero+0x84> <== NEVER TAKEN
2011ccc: c2 07 bf fc ld [ %fp + -4 ], %g1
return -1;
memset((block->buffer + ofs), 0, c);
2011cd0: 92 10 20 00 clr %o1
2011cd4: d0 00 60 1c ld [ %g1 + 0x1c ], %o0
2011cd8: 94 10 00 1d mov %i5, %o2
2011cdc: 90 02 00 1a add %o0, %i2, %o0
2011ce0: 40 00 23 c2 call 201abe8 <memset>
2011ce4: b6 26 c0 1d sub %i3, %i5, %i3
fat_buf_mark_modified(fs_info);
count -= c;
blk++;
2011ce8: b2 06 60 01 inc %i1
2011cec: f8 2e 20 7c stb %i4, [ %i0 + 0x7c ]
ofs = 0;
2011cf0: 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)
2011cf4: 80 a6 e0 00 cmp %i3, 0
2011cf8: 32 bf ff e7 bne,a 2011c94 <_fat_block_zero+0x10>
2011cfc: c2 16 00 00 lduh [ %i0 ], %g1
count -= c;
blk++;
ofs = 0;
}
return 0;
2011d00: 81 c7 e0 08 ret
2011d04: 91 e8 20 00 restore %g0, 0, %o0
}
2011d08: 81 c7 e0 08 ret <== NOT EXECUTED
2011d0c: 91 e8 3f ff restore %g0, -1, %o0 <== NOT EXECUTED
02003f80 <_lstat_r>:
struct _reent *ptr __attribute__((unused)),
const char *path,
struct stat *buf
)
{
return _STAT_NAME( path, buf );
2003f80: 90 10 00 09 mov %o1, %o0 <== NOT EXECUTED
2003f84: 92 10 00 0a mov %o2, %o1 <== NOT EXECUTED
2003f88: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED
2003f8c: 7f ff ff e9 call 2003f30 <lstat> <== NOT EXECUTED
2003f90: 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
02007968 <aio_cancel>:
* operation(s) cannot be canceled
*/
int aio_cancel(int fildes, struct aiocb *aiocbp)
{
2007968: 9d e3 bf a0 save %sp, -96, %sp
rtems_aio_request_chain *r_chain;
int result;
pthread_mutex_lock (&aio_request_queue.mutex);
200796c: 3b 00 80 7f sethi %hi(0x201fc00), %i5
2007970: 40 00 04 68 call 2008b10 <pthread_mutex_lock>
2007974: 90 17 62 bc or %i5, 0x2bc, %o0 ! 201febc <aio_request_queue>
if (fcntl (fildes, F_GETFD) < 0) {
2007978: 90 10 00 18 mov %i0, %o0
200797c: 40 00 1a ae call 200e434 <fcntl>
2007980: 92 10 20 01 mov 1, %o1
2007984: 80 a2 20 00 cmp %o0, 0
2007988: 16 80 00 08 bge 20079a8 <aio_cancel+0x40>
200798c: 80 a6 60 00 cmp %i1, 0
pthread_mutex_unlock(&aio_request_queue.mutex);
2007990: 40 00 04 81 call 2008b94 <pthread_mutex_unlock>
2007994: 90 17 62 bc or %i5, 0x2bc, %o0
rtems_set_errno_and_return_minus_one (EBADF);
2007998: 40 00 28 e6 call 2011d30 <__errno>
200799c: 01 00 00 00 nop
20079a0: 10 80 00 54 b 2007af0 <aio_cancel+0x188>
20079a4: 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) {
20079a8: 32 80 00 35 bne,a 2007a7c <aio_cancel+0x114>
20079ac: 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);
20079b0: 11 00 80 7f sethi %hi(0x201fc00), %o0
20079b4: 92 10 00 18 mov %i0, %o1
20079b8: 90 12 23 04 or %o0, 0x304, %o0
20079bc: 40 00 01 71 call 2007f80 <rtems_aio_search_fd>
20079c0: 94 10 20 00 clr %o2
if (r_chain == NULL) {
20079c4: b8 92 20 00 orcc %o0, 0, %i4
20079c8: 12 80 00 20 bne 2007a48 <aio_cancel+0xe0>
20079cc: 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;
20079d0: 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)) {
20079d4: c4 07 60 54 ld [ %i5 + 0x54 ], %g2
20079d8: 82 07 60 58 add %i5, 0x58, %g1
20079dc: 80 a0 80 01 cmp %g2, %g1
20079e0: 02 80 00 08 be 2007a00 <aio_cancel+0x98> <== NEVER TAKEN
20079e4: 92 10 00 18 mov %i0, %o1
r_chain = rtems_aio_search_fd (&aio_request_queue.idle_req, fildes, 0);
20079e8: 90 07 60 54 add %i5, 0x54, %o0
20079ec: 40 00 01 65 call 2007f80 <rtems_aio_search_fd>
20079f0: 94 10 20 00 clr %o2
if (r_chain == NULL) {
20079f4: b8 92 20 00 orcc %o0, 0, %i4
20079f8: 12 80 00 08 bne 2007a18 <aio_cancel+0xb0>
20079fc: 01 00 00 00 nop
pthread_mutex_unlock(&aio_request_queue.mutex);
2007a00: 11 00 80 7f sethi %hi(0x201fc00), %o0
return AIO_ALLDONE;
2007a04: 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);
2007a08: 40 00 04 63 call 2008b94 <pthread_mutex_unlock>
2007a0c: 90 12 22 bc or %o0, 0x2bc, %o0
return AIO_ALLDONE;
2007a10: 81 c7 e0 08 ret
2007a14: 81 e8 00 00 restore
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
2007a18: 40 00 0a cb call 200a544 <_Chain_Extract>
2007a1c: 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);
2007a20: 40 00 01 80 call 2008020 <rtems_aio_remove_fd>
2007a24: 90 10 00 1c mov %i4, %o0
pthread_mutex_destroy (&r_chain->mutex);
2007a28: 40 00 03 8c call 2008858 <pthread_mutex_destroy>
2007a2c: 90 10 00 1b mov %i3, %o0
pthread_cond_destroy (&r_chain->mutex);
2007a30: 40 00 02 ac call 20084e0 <pthread_cond_destroy>
2007a34: 90 10 00 1b mov %i3, %o0
free (r_chain);
2007a38: 7f ff f0 ca call 2003d60 <free>
2007a3c: 90 10 00 1c mov %i4, %o0
pthread_mutex_unlock (&aio_request_queue.mutex);
2007a40: 10 80 00 0b b 2007a6c <aio_cancel+0x104>
2007a44: 90 10 00 1d mov %i5, %o0
return AIO_ALLDONE;
}
AIO_printf ("Request chain on [WQ]\n");
pthread_mutex_lock (&r_chain->mutex);
2007a48: 40 00 04 32 call 2008b10 <pthread_mutex_lock>
2007a4c: 90 10 00 1b mov %i3, %o0
2007a50: 40 00 0a bd call 200a544 <_Chain_Extract>
2007a54: 90 10 00 1c mov %i4, %o0
rtems_chain_extract (&r_chain->next_fd);
rtems_aio_remove_fd (r_chain);
2007a58: 40 00 01 72 call 2008020 <rtems_aio_remove_fd>
2007a5c: 90 10 00 1c mov %i4, %o0
pthread_mutex_unlock (&r_chain->mutex);
2007a60: 40 00 04 4d call 2008b94 <pthread_mutex_unlock>
2007a64: 90 10 00 1b mov %i3, %o0
pthread_mutex_unlock (&aio_request_queue.mutex);
2007a68: 90 17 62 bc or %i5, 0x2bc, %o0
2007a6c: 40 00 04 4a call 2008b94 <pthread_mutex_unlock>
2007a70: b0 10 20 00 clr %i0
return AIO_CANCELED;
2007a74: 81 c7 e0 08 ret
2007a78: 81 e8 00 00 restore
} else {
AIO_printf ("Cancel request\n");
if (aiocbp->aio_fildes != fildes) {
2007a7c: 80 a7 00 18 cmp %i4, %i0
2007a80: 12 80 00 17 bne 2007adc <aio_cancel+0x174>
2007a84: 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);
2007a88: 11 00 80 7f sethi %hi(0x201fc00), %o0
2007a8c: 92 10 00 1c mov %i4, %o1
2007a90: 90 12 23 04 or %o0, 0x304, %o0
2007a94: 40 00 01 3b call 2007f80 <rtems_aio_search_fd>
2007a98: 94 10 20 00 clr %o2
if (r_chain == NULL) {
2007a9c: b6 92 20 00 orcc %o0, 0, %i3
2007aa0: 32 80 00 1c bne,a 2007b10 <aio_cancel+0x1a8>
2007aa4: b8 06 e0 1c add %i3, 0x1c, %i4
2007aa8: ba 17 62 bc or %i5, 0x2bc, %i5
if (!rtems_chain_is_empty (&aio_request_queue.idle_req)) {
2007aac: c4 07 60 54 ld [ %i5 + 0x54 ], %g2
2007ab0: 82 07 60 58 add %i5, 0x58, %g1
2007ab4: 80 a0 80 01 cmp %g2, %g1
2007ab8: 02 bf ff d2 be 2007a00 <aio_cancel+0x98> <== NEVER TAKEN
2007abc: 92 10 00 1c mov %i4, %o1
r_chain = rtems_aio_search_fd (&aio_request_queue.idle_req, fildes, 0);
2007ac0: 90 07 60 54 add %i5, 0x54, %o0
2007ac4: 40 00 01 2f call 2007f80 <rtems_aio_search_fd>
2007ac8: 94 10 20 00 clr %o2
if (r_chain == NULL) {
2007acc: 80 a2 20 00 cmp %o0, 0
2007ad0: 12 80 00 0b bne 2007afc <aio_cancel+0x194>
2007ad4: 90 02 20 08 add %o0, 8, %o0
pthread_mutex_unlock (&aio_request_queue.mutex);
2007ad8: 90 10 00 1d mov %i5, %o0
2007adc: 40 00 04 2e call 2008b94 <pthread_mutex_unlock>
2007ae0: 01 00 00 00 nop
rtems_set_errno_and_return_minus_one (EINVAL);
2007ae4: 40 00 28 93 call 2011d30 <__errno>
2007ae8: 01 00 00 00 nop
2007aec: 82 10 20 16 mov 0x16, %g1 ! 16 <PROM_START+0x16>
2007af0: c2 22 00 00 st %g1, [ %o0 ]
2007af4: 81 c7 e0 08 ret
2007af8: 91 e8 3f ff restore %g0, -1, %o0
}
AIO_printf ("Request on [IQ]\n");
result = rtems_aio_remove_req (&r_chain->perfd, aiocbp);
2007afc: 40 00 01 5d call 2008070 <rtems_aio_remove_req>
2007b00: 92 10 00 19 mov %i1, %o1
2007b04: b0 10 00 08 mov %o0, %i0
pthread_mutex_unlock (&aio_request_queue.mutex);
2007b08: 10 80 00 0b b 2007b34 <aio_cancel+0x1cc>
2007b0c: 90 10 00 1d mov %i5, %o0
return AIO_ALLDONE;
}
}
AIO_printf ("Request on [WQ]\n");
pthread_mutex_lock (&r_chain->mutex);
2007b10: 40 00 04 00 call 2008b10 <pthread_mutex_lock>
2007b14: 90 10 00 1c mov %i4, %o0
result = rtems_aio_remove_req (&r_chain->perfd, aiocbp);
2007b18: 92 10 00 19 mov %i1, %o1
2007b1c: 40 00 01 55 call 2008070 <rtems_aio_remove_req>
2007b20: 90 06 e0 08 add %i3, 8, %o0
2007b24: b0 10 00 08 mov %o0, %i0
pthread_mutex_unlock (&r_chain->mutex);
2007b28: 40 00 04 1b call 2008b94 <pthread_mutex_unlock>
2007b2c: 90 10 00 1c mov %i4, %o0
pthread_mutex_unlock (&aio_request_queue.mutex);
2007b30: 90 17 62 bc or %i5, 0x2bc, %o0
2007b34: 40 00 04 18 call 2008b94 <pthread_mutex_unlock>
2007b38: 01 00 00 00 nop
return result;
}
return AIO_ALLDONE;
}
2007b3c: 81 c7 e0 08 ret
2007b40: 81 e8 00 00 restore
02007b4c <aio_fsync>:
int aio_fsync(
int op,
struct aiocb *aiocbp
)
{
2007b4c: 9d e3 bf a0 save %sp, -96, %sp
rtems_aio_request *req;
int mode;
if (op != O_SYNC)
2007b50: 03 00 00 08 sethi %hi(0x2000), %g1
2007b54: 80 a6 00 01 cmp %i0, %g1
2007b58: 12 80 00 10 bne 2007b98 <aio_fsync+0x4c>
2007b5c: ba 10 20 16 mov 0x16, %i5
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
2007b60: d0 06 40 00 ld [ %i1 ], %o0
2007b64: 40 00 1a 34 call 200e434 <fcntl>
2007b68: 92 10 20 03 mov 3, %o1
if (!(((mode & O_ACCMODE) == O_WRONLY) || ((mode & O_ACCMODE) == O_RDWR)))
2007b6c: 90 0a 20 03 and %o0, 3, %o0
2007b70: 90 02 3f ff add %o0, -1, %o0
2007b74: 80 a2 20 01 cmp %o0, 1
2007b78: 18 80 00 08 bgu 2007b98 <aio_fsync+0x4c>
2007b7c: ba 10 20 09 mov 9, %i5
rtems_aio_set_errno_return_minus_one (EBADF, aiocbp);
req = malloc (sizeof (rtems_aio_request));
2007b80: 7f ff f1 ad call 2004234 <malloc>
2007b84: 90 10 20 18 mov 0x18, %o0
if (req == NULL)
2007b88: b0 92 20 00 orcc %o0, 0, %i0
2007b8c: 32 80 00 09 bne,a 2007bb0 <aio_fsync+0x64> <== ALWAYS TAKEN
2007b90: f2 26 20 14 st %i1, [ %i0 + 0x14 ]
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
2007b94: ba 10 20 0b mov 0xb, %i5 <== NOT EXECUTED
2007b98: 82 10 3f ff mov -1, %g1
2007b9c: fa 26 60 34 st %i5, [ %i1 + 0x34 ]
2007ba0: 40 00 28 64 call 2011d30 <__errno>
2007ba4: c2 26 60 38 st %g1, [ %i1 + 0x38 ]
2007ba8: 10 80 00 06 b 2007bc0 <aio_fsync+0x74>
2007bac: fa 22 00 00 st %i5, [ %o0 ]
req->aiocbp = aiocbp;
req->aiocbp->aio_lio_opcode = LIO_SYNC;
2007bb0: 82 10 20 03 mov 3, %g1
2007bb4: c2 26 60 30 st %g1, [ %i1 + 0x30 ]
return rtems_aio_enqueue (req);
2007bb8: 40 00 01 4e call 20080f0 <rtems_aio_enqueue>
2007bbc: 81 e8 00 00 restore
}
2007bc0: 81 c7 e0 08 ret
2007bc4: 91 e8 3f ff restore %g0, -1, %o0
02008308 <aio_read>:
* 0 - otherwise
*/
int
aio_read (struct aiocb *aiocbp)
{
2008308: 9d e3 bf a0 save %sp, -96, %sp
rtems_aio_request *req;
int mode;
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
200830c: d0 06 00 00 ld [ %i0 ], %o0
2008310: 92 10 20 03 mov 3, %o1
2008314: 40 00 18 48 call 200e434 <fcntl>
2008318: ba 10 00 18 mov %i0, %i5
if (!(((mode & O_ACCMODE) == O_RDONLY) || ((mode & O_ACCMODE) == O_RDWR)))
200831c: 80 8a 20 01 btst 1, %o0
2008320: 12 80 00 11 bne 2008364 <aio_read+0x5c>
2008324: 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)
2008328: c2 06 20 18 ld [ %i0 + 0x18 ], %g1
200832c: 80 a0 60 00 cmp %g1, 0
2008330: 22 80 00 04 be,a 2008340 <aio_read+0x38>
2008334: 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);
2008338: 10 80 00 0b b 2008364 <aio_read+0x5c>
200833c: 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)
2008340: 80 a0 60 00 cmp %g1, 0
2008344: 06 80 00 08 bl 2008364 <aio_read+0x5c>
2008348: b8 10 20 16 mov 0x16, %i4
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
req = malloc (sizeof (rtems_aio_request));
200834c: 7f ff ef ba call 2004234 <malloc>
2008350: 90 10 20 18 mov 0x18, %o0
if (req == NULL)
2008354: b0 92 20 00 orcc %o0, 0, %i0
2008358: 32 80 00 09 bne,a 200837c <aio_read+0x74> <== ALWAYS TAKEN
200835c: fa 26 20 14 st %i5, [ %i0 + 0x14 ]
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
2008360: b8 10 20 0b mov 0xb, %i4 <== NOT EXECUTED
2008364: 82 10 3f ff mov -1, %g1
2008368: f8 27 60 34 st %i4, [ %i5 + 0x34 ]
200836c: 40 00 26 71 call 2011d30 <__errno>
2008370: c2 27 60 38 st %g1, [ %i5 + 0x38 ]
2008374: 10 80 00 06 b 200838c <aio_read+0x84>
2008378: f8 22 00 00 st %i4, [ %o0 ]
req->aiocbp = aiocbp;
req->aiocbp->aio_lio_opcode = LIO_READ;
200837c: 82 10 20 01 mov 1, %g1
2008380: c2 27 60 30 st %g1, [ %i5 + 0x30 ]
return rtems_aio_enqueue (req);
2008384: 7f ff ff 5b call 20080f0 <rtems_aio_enqueue>
2008388: 81 e8 00 00 restore
}
200838c: 81 c7 e0 08 ret
2008390: 91 e8 3f ff restore %g0, -1, %o0
0200839c <aio_write>:
* 0 - otherwise
*/
int
aio_write (struct aiocb *aiocbp)
{
200839c: 9d e3 bf a0 save %sp, -96, %sp
rtems_aio_request *req;
int mode;
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
20083a0: d0 06 00 00 ld [ %i0 ], %o0
20083a4: 40 00 18 24 call 200e434 <fcntl>
20083a8: 92 10 20 03 mov 3, %o1
* 0 - otherwise
*/
int
aio_write (struct aiocb *aiocbp)
{
20083ac: 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)))
20083b0: 90 0a 20 03 and %o0, 3, %o0
20083b4: 90 02 3f ff add %o0, -1, %o0
20083b8: 80 a2 20 01 cmp %o0, 1
20083bc: 18 80 00 11 bgu 2008400 <aio_write+0x64>
20083c0: 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)
20083c4: c2 06 20 18 ld [ %i0 + 0x18 ], %g1
20083c8: 80 a0 60 00 cmp %g1, 0
20083cc: 22 80 00 04 be,a 20083dc <aio_write+0x40>
20083d0: 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);
20083d4: 10 80 00 0b b 2008400 <aio_write+0x64>
20083d8: 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)
20083dc: 80 a0 60 00 cmp %g1, 0
20083e0: 06 80 00 08 bl 2008400 <aio_write+0x64>
20083e4: b8 10 20 16 mov 0x16, %i4
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
req = malloc (sizeof (rtems_aio_request));
20083e8: 7f ff ef 93 call 2004234 <malloc>
20083ec: 90 10 20 18 mov 0x18, %o0
if (req == NULL)
20083f0: b0 92 20 00 orcc %o0, 0, %i0
20083f4: 32 80 00 09 bne,a 2008418 <aio_write+0x7c> <== ALWAYS TAKEN
20083f8: fa 26 20 14 st %i5, [ %i0 + 0x14 ]
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
20083fc: b8 10 20 0b mov 0xb, %i4 <== NOT EXECUTED
2008400: 82 10 3f ff mov -1, %g1
2008404: f8 27 60 34 st %i4, [ %i5 + 0x34 ]
2008408: 40 00 26 4a call 2011d30 <__errno>
200840c: c2 27 60 38 st %g1, [ %i5 + 0x38 ]
2008410: 10 80 00 06 b 2008428 <aio_write+0x8c>
2008414: f8 22 00 00 st %i4, [ %o0 ]
req->aiocbp = aiocbp;
req->aiocbp->aio_lio_opcode = LIO_WRITE;
2008418: 82 10 20 02 mov 2, %g1
200841c: c2 27 60 30 st %g1, [ %i5 + 0x30 ]
return rtems_aio_enqueue (req);
2008420: 7f ff ff 34 call 20080f0 <rtems_aio_enqueue>
2008424: 81 e8 00 00 restore
}
2008428: 81 c7 e0 08 ret
200842c: 91 e8 3f ff restore %g0, -1, %o0
02004684 <cfgetispeed>:
speed_t cfgetispeed(
const struct termios *tp
)
{
return (tp->c_cflag / (CIBAUD / CBAUD)) & CBAUD;
2004684: d0 12 20 08 lduh [ %o0 + 8 ], %o0 <== NOT EXECUTED
}
2004688: 03 00 00 04 sethi %hi(0x1000), %g1 <== NOT EXECUTED
200468c: 82 10 60 0f or %g1, 0xf, %g1 ! 100f <PROM_START+0x100f> <== NOT EXECUTED
2004690: 81 c3 e0 08 retl <== NOT EXECUTED
2004694: 90 0a 00 01 and %o0, %g1, %o0 <== NOT EXECUTED
02004698 <cfgetospeed>:
speed_t cfgetospeed(
const struct termios *tp
)
{
return tp->c_cflag & CBAUD;
2004698: d0 02 20 08 ld [ %o0 + 8 ], %o0 <== NOT EXECUTED
}
200469c: 03 00 00 04 sethi %hi(0x1000), %g1 <== NOT EXECUTED
20046a0: 82 10 60 0f or %g1, 0xf, %g1 ! 100f <PROM_START+0x100f> <== NOT EXECUTED
20046a4: 81 c3 e0 08 retl <== NOT EXECUTED
20046a8: 90 0a 00 01 and %o0, %g1, %o0 <== NOT EXECUTED
020046ac <cfsetispeed>:
int cfsetispeed(
struct termios *tp,
speed_t speed
)
{
20046ac: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED
if ( speed & ~CBAUD )
20046b0: 03 3f ff fb sethi %hi(0xffffec00), %g1 <== NOT EXECUTED
20046b4: 82 10 63 f0 or %g1, 0x3f0, %g1 ! ffffeff0 <RAM_END+0xfdbfeff0><== NOT EXECUTED
20046b8: 80 8e 40 01 btst %i1, %g1 <== NOT EXECUTED
20046bc: 22 80 00 08 be,a 20046dc <cfsetispeed+0x30> <== NOT EXECUTED
20046c0: c2 06 20 08 ld [ %i0 + 8 ], %g1 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
20046c4: 40 00 32 4c call 2010ff4 <__errno> <== NOT EXECUTED
20046c8: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
20046cc: 82 10 20 16 mov 0x16, %g1 <== NOT EXECUTED
20046d0: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
20046d4: 81 c7 e0 08 ret <== NOT EXECUTED
20046d8: 81 e8 00 00 restore <== NOT EXECUTED
tp->c_cflag = (tp->c_cflag & ~CIBAUD) | (speed * (CIBAUD / CBAUD));
20046dc: 05 04 03 c0 sethi %hi(0x100f0000), %g2 <== NOT EXECUTED
20046e0: b3 2e 60 10 sll %i1, 0x10, %i1 <== NOT EXECUTED
20046e4: 82 28 40 02 andn %g1, %g2, %g1 <== NOT EXECUTED
20046e8: b2 16 40 01 or %i1, %g1, %i1 <== NOT EXECUTED
20046ec: f2 26 20 08 st %i1, [ %i0 + 8 ] <== NOT EXECUTED
return 0;
}
20046f0: 81 c7 e0 08 ret <== NOT EXECUTED
20046f4: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED
020046f8 <cfsetospeed>:
int cfsetospeed(
struct termios *tp,
speed_t speed
)
{
20046f8: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED
if ( speed & ~CBAUD )
20046fc: 03 3f ff fb sethi %hi(0xffffec00), %g1 <== NOT EXECUTED
2004700: 82 10 63 f0 or %g1, 0x3f0, %g1 ! ffffeff0 <RAM_END+0xfdbfeff0><== NOT EXECUTED
2004704: 80 8e 40 01 btst %i1, %g1 <== NOT EXECUTED
2004708: 22 80 00 08 be,a 2004728 <cfsetospeed+0x30> <== NOT EXECUTED
200470c: c4 06 20 08 ld [ %i0 + 8 ], %g2 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
2004710: 40 00 32 39 call 2010ff4 <__errno> <== NOT EXECUTED
2004714: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
2004718: 82 10 20 16 mov 0x16, %g1 <== NOT EXECUTED
200471c: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
2004720: 81 c7 e0 08 ret <== NOT EXECUTED
2004724: 81 e8 00 00 restore <== NOT EXECUTED
tp->c_cflag = (tp->c_cflag & ~CBAUD) | speed;
2004728: 82 08 80 01 and %g2, %g1, %g1 <== NOT EXECUTED
200472c: b2 16 40 01 or %i1, %g1, %i1 <== NOT EXECUTED
2004730: f2 26 20 08 st %i1, [ %i0 + 8 ] <== NOT EXECUTED
return 0;
}
2004734: 81 c7 e0 08 ret <== NOT EXECUTED
2004738: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED
02003bb0 <chroot>:
#include <unistd.h>
#include <rtems/libio_.h>
int chroot( const char *path )
{
2003bb0: 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(
2003bb4: 94 10 20 19 mov 0x19, %o2
2003bb8: 92 10 00 18 mov %i0, %o1
2003bbc: 90 07 bf c8 add %fp, -56, %o0
2003bc0: 17 00 80 4a sethi %hi(0x2012800), %o3
2003bc4: 96 12 e0 04 or %o3, 4, %o3 ! 2012804 <rtems_global_user_env+0x4>
2003bc8: 40 00 04 cc call 2004ef8 <rtems_filesystem_eval_path_start_with_root_and_current>
2003bcc: 98 02 ff fc add %o3, -4, %o4
2003bd0: 90 07 bf b0 add %fp, -80, %o0
2003bd4: 40 00 05 e3 call 2005360 <rtems_filesystem_location_copy_and_detach>
2003bd8: 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 );
2003bdc: 40 00 06 5a call 2005544 <rtems_filesystem_location_transform_to_global>
2003be0: 90 07 bf b0 add %fp, -80, %o0
if ( !rtems_filesystem_global_location_is_null( new_current_loc ) ) {
2003be4: c2 02 20 10 ld [ %o0 + 0x10 ], %g1
2003be8: 39 00 80 48 sethi %hi(0x2012000), %i4
2003bec: b8 17 20 74 or %i4, 0x74, %i4 ! 2012074 <rtems_filesystem_null_handlers>
2003bf0: 80 a0 40 1c cmp %g1, %i4
2003bf4: 02 80 00 29 be 2003c98 <chroot+0xe8>
2003bf8: d0 27 bf ac st %o0, [ %fp + -84 ]
rtems_filesystem_global_location_t *new_root_loc =
2003bfc: 40 00 06 1f call 2005478 <rtems_filesystem_global_location_obtain>
2003c00: 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)(
2003c04: c2 02 20 14 ld [ %o0 + 0x14 ], %g1
2003c08: 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 =
2003c0c: c2 00 60 14 ld [ %g1 + 0x14 ], %g1
2003c10: 9f c0 40 00 call %g1
2003c14: 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 ) {
2003c18: 80 a2 20 00 cmp %o0, 0
2003c1c: 32 80 00 17 bne,a 2003c78 <chroot+0xc8>
2003c20: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
sc = rtems_libio_set_private_env();
2003c24: 40 00 03 32 call 20048ec <rtems_libio_set_private_env>
2003c28: 01 00 00 00 nop
if (sc == RTEMS_SUCCESSFUL) {
2003c2c: 80 a2 20 00 cmp %o0, 0
2003c30: 12 80 00 0c bne 2003c60 <chroot+0xb0>
2003c34: 80 a2 20 0d cmp %o0, 0xd
rtems_filesystem_global_location_assign(
2003c38: 39 00 80 49 sethi %hi(0x2012400), %i4
2003c3c: d0 07 23 fc ld [ %i4 + 0x3fc ], %o0 ! 20127fc <rtems_current_user_env>
2003c40: 92 10 00 1d mov %i5, %o1
2003c44: 40 00 06 04 call 2005454 <rtems_filesystem_global_location_assign>
2003c48: 90 02 20 04 add %o0, 4, %o0
&rtems_filesystem_root,
new_root_loc
);
rtems_filesystem_global_location_assign(
2003c4c: d0 07 23 fc ld [ %i4 + 0x3fc ], %o0
2003c50: d2 07 bf ac ld [ %fp + -84 ], %o1
2003c54: 40 00 06 00 call 2005454 <rtems_filesystem_global_location_assign>
2003c58: b0 10 20 00 clr %i0
2003c5c: 30 80 00 10 b,a 2003c9c <chroot+0xec>
&rtems_filesystem_current,
new_current_loc
);
} else {
if (sc != RTEMS_UNSATISFIED) {
2003c60: 02 80 00 18 be 2003cc0 <chroot+0x110> <== NEVER TAKEN
2003c64: 01 00 00 00 nop
errno = ENOMEM;
2003c68: 40 00 20 93 call 200beb4 <__errno>
2003c6c: 01 00 00 00 nop
2003c70: 10 80 00 08 b 2003c90 <chroot+0xe0>
2003c74: 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 ) ) {
2003c78: 80 a0 40 1c cmp %g1, %i4
2003c7c: 02 80 00 11 be 2003cc0 <chroot+0x110> <== NEVER TAKEN
2003c80: 01 00 00 00 nop
errno = eno;
2003c84: 40 00 20 8c call 200beb4 <__errno>
2003c88: 01 00 00 00 nop
2003c8c: 82 10 20 14 mov 0x14, %g1 ! 14 <PROM_START+0x14>
2003c90: 10 80 00 0c b 2003cc0 <chroot+0x110>
2003c94: c2 22 00 00 st %g1, [ %o0 ]
if ( rv != 0 ) {
rtems_filesystem_global_location_release( new_root_loc );
}
} else {
rv = -1;
2003c98: b0 10 3f ff mov -1, %i0
}
rtems_filesystem_eval_path_cleanup( &ctx );
2003c9c: 40 00 04 dd call 2005010 <rtems_filesystem_eval_path_cleanup>
2003ca0: 90 07 bf c8 add %fp, -56, %o0
if ( rv != 0 ) {
2003ca4: 80 a6 20 00 cmp %i0, 0
2003ca8: 02 80 00 0a be 2003cd0 <chroot+0x120>
2003cac: 01 00 00 00 nop
rtems_filesystem_global_location_release( new_current_loc );
2003cb0: 40 00 05 d1 call 20053f4 <rtems_filesystem_global_location_release>
2003cb4: d0 07 bf ac ld [ %fp + -84 ], %o0
2003cb8: 81 c7 e0 08 ret
2003cbc: 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 );
2003cc0: 40 00 05 cd call 20053f4 <rtems_filesystem_global_location_release>
2003cc4: 90 10 00 1d mov %i5, %o0
}
} else {
rv = -1;
2003cc8: 10 bf ff f5 b 2003c9c <chroot+0xec>
2003ccc: b0 10 3f ff mov -1, %i0
if ( rv != 0 ) {
rtems_filesystem_global_location_release( new_current_loc );
}
return rv;
}
2003cd0: 81 c7 e0 08 ret
2003cd4: 81 e8 00 00 restore
02007584 <clock_gettime>:
int clock_gettime(
clockid_t clock_id,
struct timespec *tp
)
{
2007584: 9d e3 bf 98 save %sp, -104, %sp
if ( !tp )
2007588: 80 a6 60 00 cmp %i1, 0
200758c: 02 80 00 24 be 200761c <clock_gettime+0x98>
2007590: 80 a6 20 01 cmp %i0, 1
rtems_set_errno_and_return_minus_one( EINVAL );
if ( clock_id == CLOCK_REALTIME ) {
2007594: 12 80 00 14 bne 20075e4 <clock_gettime+0x60>
2007598: 80 a6 20 04 cmp %i0, 4
struct timespec *tod_as_timespec
)
{
Timestamp_Control tod_as_timestamp;
_TOD_Get_as_timestamp( &tod_as_timestamp );
200759c: 40 00 08 19 call 2009600 <_TOD_Get_as_timestamp>
20075a0: 90 07 bf f8 add %fp, -8, %o0
_Timestamp_To_timespec( &tod_as_timestamp, tod_as_timespec );
20075a4: 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);
20075a8: 94 10 20 00 clr %o2
20075ac: 90 10 00 1c mov %i4, %o0
20075b0: 92 10 00 1d mov %i5, %o1
20075b4: 17 0e e6 b2 sethi %hi(0x3b9ac800), %o3
20075b8: 40 00 53 ae call 201c470 <__divdi3>
20075bc: 96 12 e2 00 or %o3, 0x200, %o3 ! 3b9aca00 <RAM_END+0x395aca00>
_timespec->tv_nsec = (long) (*_timestamp % 1000000000L);
20075c0: 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);
20075c4: d2 26 40 00 st %o1, [ %i1 ]
_timespec->tv_nsec = (long) (*_timestamp % 1000000000L);
20075c8: 94 10 20 00 clr %o2
20075cc: 92 10 00 1d mov %i5, %o1
20075d0: 17 0e e6 b2 sethi %hi(0x3b9ac800), %o3
20075d4: 40 00 54 92 call 201c81c <__moddi3>
20075d8: 96 12 e2 00 or %o3, 0x200, %o3 ! 3b9aca00 <RAM_END+0x395aca00>
20075dc: 10 80 00 06 b 20075f4 <clock_gettime+0x70>
20075e0: d2 26 60 04 st %o1, [ %i1 + 4 ]
_TOD_Get(tp);
return 0;
}
#ifdef CLOCK_MONOTONIC
if ( clock_id == CLOCK_MONOTONIC ) {
20075e4: 12 80 00 06 bne 20075fc <clock_gettime+0x78> <== ALWAYS TAKEN
20075e8: 80 a6 20 02 cmp %i0, 2
_TOD_Get_uptime_as_timespec( tp );
20075ec: 40 00 08 18 call 200964c <_TOD_Get_uptime_as_timespec>
20075f0: 90 10 00 19 mov %i1, %o0
return 0;
20075f4: 81 c7 e0 08 ret
20075f8: 91 e8 20 00 restore %g0, 0, %o0
}
#endif
#ifdef _POSIX_CPUTIME
if ( clock_id == CLOCK_PROCESS_CPUTIME_ID ) {
20075fc: 02 bf ff fc be 20075ec <clock_gettime+0x68>
2007600: 80 a6 20 03 cmp %i0, 3
return 0;
}
#endif
#ifdef _POSIX_THREAD_CPUTIME
if ( clock_id == CLOCK_THREAD_CPUTIME_ID )
2007604: 12 80 00 06 bne 200761c <clock_gettime+0x98>
2007608: 01 00 00 00 nop
rtems_set_errno_and_return_minus_one( ENOSYS );
200760c: 40 00 25 3a call 2010af4 <__errno>
2007610: 01 00 00 00 nop
2007614: 10 80 00 05 b 2007628 <clock_gettime+0xa4>
2007618: 82 10 20 58 mov 0x58, %g1 ! 58 <PROM_START+0x58>
#endif
rtems_set_errno_and_return_minus_one( EINVAL );
200761c: 40 00 25 36 call 2010af4 <__errno>
2007620: 01 00 00 00 nop
2007624: 82 10 20 16 mov 0x16, %g1 ! 16 <PROM_START+0x16>
2007628: c2 22 00 00 st %g1, [ %o0 ]
return 0;
}
200762c: 81 c7 e0 08 ret
2007630: 91 e8 3f ff restore %g0, -1, %o0
02025620 <clock_settime>:
int clock_settime(
clockid_t clock_id,
const struct timespec *tp
)
{
2025620: 9d e3 bf 98 save %sp, -104, %sp
if ( !tp )
2025624: 80 a6 60 00 cmp %i1, 0
2025628: 02 80 00 4c be 2025758 <clock_settime+0x138> <== NEVER TAKEN
202562c: 80 a6 20 01 cmp %i0, 1
rtems_set_errno_and_return_minus_one( EINVAL );
if ( clock_id == CLOCK_REALTIME ) {
2025630: 12 80 00 42 bne 2025738 <clock_settime+0x118>
2025634: 80 a6 20 02 cmp %i0, 2
if ( tp->tv_sec < TOD_SECONDS_1970_THROUGH_1988 )
2025638: c4 06 40 00 ld [ %i1 ], %g2
202563c: 03 08 76 b9 sethi %hi(0x21dae400), %g1
2025640: 82 10 60 ff or %g1, 0xff, %g1 ! 21dae4ff <RAM_END+0x1f9ae4ff>
2025644: 80 a0 80 01 cmp %g2, %g1
2025648: 08 80 00 44 bleu 2025758 <clock_settime+0x138>
202564c: 03 00 81 87 sethi %hi(0x2061c00), %g1
*
* This rountine increments the thread dispatch level
*/
RTEMS_INLINE_ROUTINE uint32_t _Thread_Dispatch_increment_disable_level(void)
{
_Thread_Dispatch_disable_level++;
2025650: c4 00 63 60 ld [ %g1 + 0x360 ], %g2 ! 2061f60 <_Thread_Dispatch_disable_level>
2025654: 84 00 a0 01 inc %g2
2025658: c4 20 63 60 st %g2, [ %g1 + 0x360 ]
return _Thread_Dispatch_disable_level;
202565c: c2 00 63 60 ld [ %g1 + 0x360 ], %g1
const struct timespec *tod_as_timespec
)
{
Timestamp_Control tod_as_timestamp;
_Timestamp_Set(
2025660: 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 );
2025664: 90 07 bf f8 add %fp, -8, %o0
const struct timespec *tod_as_timespec
)
{
Timestamp_Control tod_as_timestamp;
_Timestamp_Set(
2025668: 85 38 e0 1f sra %g3, 0x1f, %g2
Timestamp64_Control *_time,
Timestamp64_Control _seconds,
Timestamp64_Control _nanoseconds
)
{
*_time = _seconds * 1000000000L + _nanoseconds;
202566c: 83 28 a0 03 sll %g2, 3, %g1
2025670: bb 28 e0 03 sll %g3, 3, %i5
2025674: 89 30 e0 1d srl %g3, 0x1d, %g4
2025678: b7 2f 60 05 sll %i5, 5, %i3
202567c: b8 11 00 01 or %g4, %g1, %i4
2025680: 83 37 60 1b srl %i5, 0x1b, %g1
2025684: b5 2f 20 05 sll %i4, 5, %i2
2025688: ba a6 c0 1d subcc %i3, %i5, %i5
202568c: b4 10 40 1a or %g1, %i2, %i2
2025690: b7 2f 60 06 sll %i5, 6, %i3
2025694: b8 66 80 1c subx %i2, %i4, %i4
2025698: 83 37 60 1a srl %i5, 0x1a, %g1
202569c: b6 a6 c0 1d subcc %i3, %i5, %i3
20256a0: b5 2f 20 06 sll %i4, 6, %i2
20256a4: b4 10 40 1a or %g1, %i2, %i2
20256a8: b4 66 80 1c subx %i2, %i4, %i2
20256ac: 86 86 c0 03 addcc %i3, %g3, %g3
20256b0: 83 30 e0 1e srl %g3, 0x1e, %g1
20256b4: b7 28 e0 02 sll %g3, 2, %i3
20256b8: 84 46 80 02 addx %i2, %g2, %g2
20256bc: 86 80 c0 1b addcc %g3, %i3, %g3
20256c0: b5 28 a0 02 sll %g2, 2, %i2
20256c4: b7 28 e0 02 sll %g3, 2, %i3
20256c8: b4 10 40 1a or %g1, %i2, %i2
20256cc: 83 30 e0 1e srl %g3, 0x1e, %g1
20256d0: 84 40 80 1a addx %g2, %i2, %g2
20256d4: b6 80 c0 1b addcc %g3, %i3, %i3
20256d8: bb 2e e0 02 sll %i3, 2, %i5
20256dc: b5 28 a0 02 sll %g2, 2, %i2
20256e0: b4 10 40 1a or %g1, %i2, %i2
20256e4: 83 36 e0 1e srl %i3, 0x1e, %g1
20256e8: b4 40 80 1a addx %g2, %i2, %i2
20256ec: 86 86 c0 1d addcc %i3, %i5, %g3
20256f0: b9 2e a0 02 sll %i2, 2, %i4
20256f4: bb 30 e0 17 srl %g3, 0x17, %i5
20256f8: b8 10 40 1c or %g1, %i4, %i4
20256fc: 84 46 80 1c addx %i2, %i4, %g2
2025700: 89 28 a0 09 sll %g2, 9, %g4
2025704: 84 17 40 04 or %i5, %g4, %g2
2025708: fa 06 60 04 ld [ %i1 + 4 ], %i5
202570c: 83 28 e0 09 sll %g3, 9, %g1
2025710: b9 3f 60 1f sra %i5, 0x1f, %i4
2025714: 86 80 40 1d addcc %g1, %i5, %g3
2025718: 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;
202571c: 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 );
2025720: 40 00 04 82 call 2026928 <_TOD_Set_with_timestamp>
2025724: 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();
2025728: 7f ff 91 ca call 2009e50 <_Thread_Enable_dispatch>
202572c: 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;
2025730: 81 c7 e0 08 ret
2025734: 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 )
2025738: 02 80 00 04 be 2025748 <clock_settime+0x128>
202573c: 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 )
2025740: 12 80 00 06 bne 2025758 <clock_settime+0x138>
2025744: 01 00 00 00 nop
rtems_set_errno_and_return_minus_one( ENOSYS );
2025748: 40 00 44 0d call 203677c <__errno>
202574c: 01 00 00 00 nop
2025750: 10 80 00 05 b 2025764 <clock_settime+0x144>
2025754: 82 10 20 58 mov 0x58, %g1 ! 58 <PROM_START+0x58>
#endif
else
rtems_set_errno_and_return_minus_one( EINVAL );
2025758: 40 00 44 09 call 203677c <__errno>
202575c: 01 00 00 00 nop
2025760: 82 10 20 16 mov 0x16, %g1 ! 16 <PROM_START+0x16>
2025764: c2 22 00 00 st %g1, [ %o0 ]
return 0;
}
2025768: 81 c7 e0 08 ret
202576c: 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 70 ld [ %g1 + 0x370 ], %l0 ! 2021770 <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 74 ld [ %g1 + 0x374 ], %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 47 call 20145ac <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 74 st %l1, [ %g1 + 0x374 ] ! 2021774 <disktab> <== NOT EXECUTED
disktab_size = new_size;
20038a0: 03 00 80 85 sethi %hi(0x2021400), %g1 <== NOT EXECUTED
20038a4: fa 20 63 70 st %i5, [ %g1 + 0x370 ] ! 2021770 <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 74 ld [ %g1 + 0x374 ], %l2 ! 2021774 <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 27 call 20145ac <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 6a call 2014b10 <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 20 call 20157ec <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 19 call 20157ec <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 40 or %o0, 0x140, %o0
2004bb8: 40 00 42 9f call 2015634 <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 34 ld [ %g1 + 0x34 ], %g1 ! 201a434 <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 44 or %g2, 0x44, %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 98 or %i1, 0x98, %i1
for (j = 0; j < m; ++j) {
printk("%c", current->name [j]);
2002ca4: b0 16 20 a0 or %i0, 0xa0, %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 a8 or %l0, 0xa8, %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
0200bd4c <devFS_eval_path>:
}
void devFS_eval_path(
rtems_filesystem_eval_path_context_t *ctx
)
{
200bd4c: 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;
200bd50: 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;
200bd54: f2 06 00 00 ld [ %i0 ], %i1
200bd58: 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;
200bd5c: 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;
200bd60: e2 00 60 04 ld [ %g1 + 4 ], %l1
200bd64: fa 00 40 00 ld [ %g1 ], %i5
devFS_node *nodes = data->nodes;
devFS_node *node = NULL;
200bd68: b8 10 20 00 clr %i4
devFS_node *free_node = NULL;
200bd6c: 82 10 20 00 clr %g1
for (i = 0; (free_node == NULL || node == NULL) && i < n; ++i) {
200bd70: 10 80 00 12 b 200bdb8 <devFS_eval_path+0x6c>
200bd74: b4 10 20 00 clr %i2
devFS_node *current = nodes + i;
if (current->name != NULL) {
200bd78: 80 a2 20 00 cmp %o0, 0
200bd7c: 02 80 00 0c be 200bdac <devFS_eval_path+0x60>
200bd80: a0 10 00 1d mov %i5, %l0
if (
200bd84: c4 07 60 04 ld [ %i5 + 4 ], %g2
200bd88: 80 a0 80 1b cmp %g2, %i3
200bd8c: 12 80 00 08 bne 200bdac <devFS_eval_path+0x60>
200bd90: a0 10 00 01 mov %g1, %l0
current->namelen == pathlen
&& memcmp(current->name, path, pathlen) == 0
200bd94: 92 10 00 19 mov %i1, %o1
200bd98: 40 00 0d ec call 200f548 <memcmp>
200bd9c: 94 10 00 1b mov %i3, %o2
200bda0: 80 a2 20 00 cmp %o0, 0
200bda4: 22 80 00 02 be,a 200bdac <devFS_eval_path+0x60>
200bda8: 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) {
200bdac: b4 06 a0 01 inc %i2
200bdb0: ba 07 60 14 add %i5, 0x14, %i5
200bdb4: 82 10 00 10 mov %l0, %g1
200bdb8: 80 a7 20 00 cmp %i4, 0
200bdbc: 02 80 00 0a be 200bde4 <devFS_eval_path+0x98>
200bdc0: 80 a6 80 11 cmp %i2, %l1
200bdc4: 80 a0 60 00 cmp %g1, 0
200bdc8: 02 80 00 07 be 200bde4 <devFS_eval_path+0x98>
200bdcc: 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) {
200bdd0: 80 a7 20 00 cmp %i4, 0
200bdd4: 12 80 00 08 bne 200bdf4 <devFS_eval_path+0xa8>
200bdd8: 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) {
200bddc: 10 80 00 0b b 200be08 <devFS_eval_path+0xbc>
200bde0: 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) {
200bde4: 32 bf ff e5 bne,a 200bd78 <devFS_eval_path+0x2c>
200bde8: 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) {
200bdec: 10 bf ff fa b 200bdd4 <devFS_eval_path+0x88>
200bdf0: 80 a7 20 00 cmp %i4, 0
if ((eval_flags & RTEMS_FS_EXCLUSIVE) == 0) {
200bdf4: 80 88 a0 40 btst 0x40, %g2
200bdf8: 12 80 00 12 bne 200be40 <devFS_eval_path+0xf4>
200bdfc: b2 10 20 11 mov 0x11, %i1
currentloc->node_access = node;
200be00: 10 80 00 0a b 200be28 <devFS_eval_path+0xdc>
200be04: 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) {
200be08: 02 80 00 0d be 200be3c <devFS_eval_path+0xf0> <== NEVER TAKEN
200be0c: 80 a0 60 00 cmp %g1, 0
if (free_node != NULL) {
200be10: 02 80 00 09 be 200be34 <devFS_eval_path+0xe8>
200be14: 84 10 21 ff mov 0x1ff, %g2
free_node->mode = S_IRWXU | S_IRWXG | S_IRWXO;
200be18: c4 20 60 10 st %g2, [ %g1 + 0x10 ]
currentloc->node_access = free_node;
200be1c: c2 26 20 20 st %g1, [ %i0 + 0x20 ]
rtems_filesystem_eval_path_context_t *ctx,
const char *token,
size_t tokenlen
)
{
ctx->token = token;
200be20: f2 26 20 08 st %i1, [ %i0 + 8 ]
ctx->tokenlen = tokenlen;
200be24: 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;
200be28: c0 26 20 04 clr [ %i0 + 4 ]
200be2c: 81 c7 e0 08 ret
200be30: 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);
200be34: 10 80 00 03 b 200be40 <devFS_eval_path+0xf4>
200be38: b2 10 20 1c mov 0x1c, %i1
}
} else {
rtems_filesystem_eval_path_error(ctx, ENOENT);
200be3c: b2 10 20 02 mov 2, %i1 <== NOT EXECUTED
200be40: 7f ff e4 1f call 2004ebc <rtems_filesystem_eval_path_error>
200be44: 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 54 call 200f5f0 <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 55 call 200e604 <__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 4c call 200e604 <__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 6c ld [ %g1 + 0x36c ], %o0 ! 202176c <diskdevs_mutex>
20037e0: 92 10 20 00 clr %o1
20037e4: 94 10 20 00 clr %o2
20037e8: 40 00 15 48 call 2008d08 <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 68 stb %g2, [ %g1 + 0x368 ]
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 68 clrb [ %g1 + 0x368 ] ! 2021768 <diskdevs_protected>
sc = rtems_semaphore_release(diskdevs_mutex);
200381c: 03 00 80 85 sethi %hi(0x2021400), %g1
2003820: 40 00 15 84 call 2008e30 <rtems_semaphore_release>
2003824: d0 00 63 6c ld [ %g1 + 0x36c ], %o0 ! 202176c <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 e2 call 20093bc <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 50 call 2007908 <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 10 call 200801c <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 70 ld [ %g1 + 0x70 ], %g1 ! 201d070 <__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
02024608 <endgrent>:
}
void endgrent(void)
{
if (group_fp != NULL)
2024608: 03 00 81 86 sethi %hi(0x2061800), %g1
202460c: d0 00 60 a8 ld [ %g1 + 0xa8 ], %o0 ! 20618a8 <group_fp>
2024610: 80 a2 20 00 cmp %o0, 0
2024614: 02 80 00 05 be 2024628 <endgrent+0x20> <== NEVER TAKEN
2024618: 01 00 00 00 nop
fclose(group_fp);
202461c: 82 13 c0 00 mov %o7, %g1
2024620: 40 00 48 a9 call 20368c4 <fclose>
2024624: 9e 10 40 00 mov %g1, %o7
2024628: 81 c3 e0 08 retl <== NOT EXECUTED
02024464 <endpwent>:
}
void endpwent(void)
{
if (passwd_fp != NULL)
2024464: 03 00 81 85 sethi %hi(0x2061400), %g1
2024468: d0 00 63 c8 ld [ %g1 + 0x3c8 ], %o0 ! 20617c8 <passwd_fp>
202446c: 80 a2 20 00 cmp %o0, 0
2024470: 02 80 00 05 be 2024484 <endpwent+0x20> <== NEVER TAKEN
2024474: 01 00 00 00 nop
fclose(passwd_fp);
2024478: 82 13 c0 00 mov %o7, %g1
202447c: 40 00 49 12 call 20368c4 <fclose>
2024480: 9e 10 40 00 mov %g1, %o7
2024484: 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 90 or %i2, 0x390, %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 88 or %i0, 0x388, %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 70 ld [ %i3 + 0x70 ], %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 70 ld [ %i3 + 0x70 ], %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 70 ld [ %i3 + 0x70 ], %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 70 ld [ %i3 + 0x70 ], %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 70 ld [ %i3 + 0x70 ], %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 70 ld [ %i3 + 0x70 ], %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 98 call 2010428 <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 ef call 200fa18 <__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 39 call 200bf6c <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
02011810 <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)
{
2011810: 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)
2011814: c2 0e 20 7d ldub [ %i0 + 0x7d ], %g1
2011818: 80 a0 60 00 cmp %g1, 0
201181c: 32 80 00 14 bne,a 201186c <fat_buf_access+0x5c>
2011820: 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);
2011824: 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)
2011828: 80 a6 a0 01 cmp %i2, 1
201182c: d0 06 20 58 ld [ %i0 + 0x58 ], %o0
2011830: 12 80 00 06 bne 2011848 <fat_buf_access+0x38>
2011834: 94 06 20 80 add %i0, 0x80, %o2
sc = rtems_bdbuf_read(fs_info->vol.dd, blk, &fs_info->c.buf);
2011838: 7f ff f9 ce call 200ff70 <rtems_bdbuf_read>
201183c: 01 00 00 00 nop
else
sc = rtems_bdbuf_get(fs_info->vol.dd, blk, &fs_info->c.buf);
if (sc != RTEMS_SUCCESSFUL)
2011840: 10 80 00 05 b 2011854 <fat_buf_access+0x44>
2011844: 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);
2011848: 7f ff f9 99 call 200feac <rtems_bdbuf_get>
201184c: 01 00 00 00 nop
if (sc != RTEMS_SUCCESSFUL)
2011850: 80 a2 20 00 cmp %o0, 0
2011854: 12 80 00 60 bne 20119d4 <fat_buf_access+0x1c4> <== NEVER TAKEN
2011858: 82 10 20 01 mov 1, %g1
rtems_set_errno_and_return_minus_one(EIO);
fs_info->c.blk_num = blk;
201185c: f2 26 20 78 st %i1, [ %i0 + 0x78 ]
fs_info->c.modified = 0;
2011860: c0 2e 20 7c clrb [ %i0 + 0x7c ]
fs_info->c.state = FAT_CACHE_ACTUAL;
2011864: c2 2e 20 7d stb %g1, [ %i0 + 0x7d ]
}
sec_of_fat = ((fs_info->c.blk_num >= fs_info->vol.fat_loc) &&
2011868: c2 06 20 78 ld [ %i0 + 0x78 ], %g1
201186c: c4 16 20 14 lduh [ %i0 + 0x14 ], %g2
2011870: 80 a0 40 02 cmp %g1, %g2
2011874: 0a 80 00 05 bcs 2011888 <fat_buf_access+0x78> <== NEVER TAKEN
2011878: ba 10 20 00 clr %i5
201187c: c4 06 20 1c ld [ %i0 + 0x1c ], %g2
2011880: 80 a0 40 02 cmp %g1, %g2
2011884: 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)
2011888: 80 a0 40 19 cmp %g1, %i1
201188c: 22 80 00 5b be,a 20119f8 <fat_buf_access+0x1e8>
2011890: c2 06 20 80 ld [ %i0 + 0x80 ], %g1
{
if (fs_info->c.modified)
2011894: c2 0e 20 7c ldub [ %i0 + 0x7c ], %g1
2011898: 80 a0 60 00 cmp %g1, 0
201189c: 02 80 00 3b be 2011988 <fat_buf_access+0x178>
20118a0: 80 8f 60 ff btst 0xff, %i5
{
if (sec_of_fat && !fs_info->vol.mirror)
20118a4: 02 80 00 0b be 20118d0 <fat_buf_access+0xc0>
20118a8: 01 00 00 00 nop
20118ac: c2 0e 20 48 ldub [ %i0 + 0x48 ], %g1
20118b0: 80 a0 60 00 cmp %g1, 0
20118b4: 12 80 00 07 bne 20118d0 <fat_buf_access+0xc0> <== NEVER TAKEN
20118b8: 01 00 00 00 nop
memcpy(fs_info->sec_buf, fs_info->c.buf->buffer,
20118bc: c2 06 20 80 ld [ %i0 + 0x80 ], %g1
20118c0: d0 06 20 84 ld [ %i0 + 0x84 ], %o0
20118c4: d2 00 60 1c ld [ %g1 + 0x1c ], %o1
20118c8: 40 00 24 8b call 201aaf4 <memcpy>
20118cc: d4 16 00 00 lduh [ %i0 ], %o2
fs_info->vol.bps);
sc = rtems_bdbuf_release_modified(fs_info->c.buf);
20118d0: 7f ff fa 5a call 2010238 <rtems_bdbuf_release_modified>
20118d4: d0 06 20 80 ld [ %i0 + 0x80 ], %o0
fs_info->c.state = FAT_CACHE_EMPTY;
20118d8: c0 2e 20 7d clrb [ %i0 + 0x7d ]
fs_info->c.modified = 0;
if (sc != RTEMS_SUCCESSFUL)
20118dc: 80 a2 20 00 cmp %o0, 0
20118e0: 12 80 00 3d bne 20119d4 <fat_buf_access+0x1c4> <== NEVER TAKEN
20118e4: c0 2e 20 7c clrb [ %i0 + 0x7c ]
rtems_set_errno_and_return_minus_one(EIO);
if (sec_of_fat && !fs_info->vol.mirror)
20118e8: 80 8f 60 ff btst 0xff, %i5
20118ec: 02 80 00 2d be 20119a0 <fat_buf_access+0x190>
20118f0: 92 10 00 19 mov %i1, %o1
20118f4: c2 0e 20 48 ldub [ %i0 + 0x48 ], %g1
20118f8: 80 a0 60 00 cmp %g1, 0
20118fc: 02 80 00 1c be 201196c <fat_buf_access+0x15c> <== ALWAYS TAKEN
2011900: 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)
2011904: 10 80 00 28 b 20119a4 <fat_buf_access+0x194> <== NOT EXECUTED
2011908: 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,
201190c: 40 00 45 c9 call 2023030 <.umul>
2011910: 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,
2011914: d2 06 20 78 ld [ %i0 + 0x78 ], %o1
2011918: 94 07 bf fc add %fp, -4, %o2
201191c: 92 02 00 09 add %o0, %o1, %o1
2011920: 7f ff f9 63 call 200feac <rtems_bdbuf_get>
2011924: 90 10 00 1c mov %i4, %o0
fs_info->c.blk_num +
fs_info->vol.fat_length * i,
&b);
if ( sc != RTEMS_SUCCESSFUL)
2011928: 80 a2 20 00 cmp %o0, 0
201192c: 22 80 00 03 be,a 2011938 <fat_buf_access+0x128> <== ALWAYS TAKEN
2011930: c2 07 bf fc ld [ %fp + -4 ], %g1
2011934: 30 80 00 0a b,a 201195c <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);
2011938: d2 06 20 84 ld [ %i0 + 0x84 ], %o1
201193c: d0 00 60 1c ld [ %g1 + 0x1c ], %o0
2011940: 40 00 24 6d call 201aaf4 <memcpy>
2011944: d4 16 00 00 lduh [ %i0 ], %o2
sc = rtems_bdbuf_release_modified(b);
2011948: 7f ff fa 3c call 2010238 <rtems_bdbuf_release_modified>
201194c: d0 07 bf fc ld [ %fp + -4 ], %o0
if ( sc != RTEMS_SUCCESSFUL)
2011950: 80 a2 20 00 cmp %o0, 0
2011954: 22 80 00 06 be,a 201196c <fat_buf_access+0x15c> <== ALWAYS TAKEN
2011958: ba 07 60 01 inc %i5
rtems_set_errno_and_return_minus_one(ENOMEM);
201195c: 40 00 21 b1 call 201a020 <__errno> <== NOT EXECUTED
2011960: 01 00 00 00 nop <== NOT EXECUTED
2011964: 10 80 00 1f b 20119e0 <fat_buf_access+0x1d0> <== NOT EXECUTED
2011968: 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++)
201196c: c4 0e 20 09 ldub [ %i0 + 9 ], %g2
2011970: 90 0f 60 ff and %i5, 0xff, %o0
2011974: 80 a2 00 02 cmp %o0, %g2
2011978: 2a bf ff e5 bcs,a 201190c <fat_buf_access+0xfc>
201197c: 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);
2011980: 10 80 00 08 b 20119a0 <fat_buf_access+0x190>
2011984: 92 10 00 19 mov %i1, %o1
}
}
}
else
{
sc = rtems_bdbuf_release(fs_info->c.buf);
2011988: 7f ff f9 f7 call 2010164 <rtems_bdbuf_release>
201198c: d0 06 20 80 ld [ %i0 + 0x80 ], %o0
fs_info->c.state = FAT_CACHE_EMPTY;
if (sc != RTEMS_SUCCESSFUL)
2011990: 80 a2 20 00 cmp %o0, 0
2011994: 12 80 00 10 bne 20119d4 <fat_buf_access+0x1c4> <== NEVER TAKEN
2011998: 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);
201199c: 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)
20119a0: 80 a6 a0 01 cmp %i2, 1
20119a4: d0 06 20 58 ld [ %i0 + 0x58 ], %o0
20119a8: 12 80 00 06 bne 20119c0 <fat_buf_access+0x1b0>
20119ac: 94 06 20 80 add %i0, 0x80, %o2
sc = rtems_bdbuf_read(fs_info->vol.dd, blk, &fs_info->c.buf);
20119b0: 7f ff f9 70 call 200ff70 <rtems_bdbuf_read>
20119b4: 01 00 00 00 nop
else
sc = rtems_bdbuf_get(fs_info->vol.dd, blk, &fs_info->c.buf);
if (sc != RTEMS_SUCCESSFUL)
20119b8: 10 80 00 05 b 20119cc <fat_buf_access+0x1bc>
20119bc: 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);
20119c0: 7f ff f9 3b call 200feac <rtems_bdbuf_get>
20119c4: 01 00 00 00 nop
if (sc != RTEMS_SUCCESSFUL)
20119c8: 80 a2 20 00 cmp %o0, 0
20119cc: 02 80 00 08 be 20119ec <fat_buf_access+0x1dc> <== ALWAYS TAKEN
20119d0: 82 10 20 01 mov 1, %g1
rtems_set_errno_and_return_minus_one(EIO);
20119d4: 40 00 21 93 call 201a020 <__errno> <== NOT EXECUTED
20119d8: 01 00 00 00 nop <== NOT EXECUTED
20119dc: 82 10 20 05 mov 5, %g1 ! 5 <PROM_START+0x5> <== NOT EXECUTED
20119e0: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
20119e4: 81 c7 e0 08 ret <== NOT EXECUTED
20119e8: 91 e8 3f ff restore %g0, -1, %o0 <== NOT EXECUTED
fs_info->c.blk_num = blk;
20119ec: f2 26 20 78 st %i1, [ %i0 + 0x78 ]
fs_info->c.state = FAT_CACHE_ACTUAL;
20119f0: c2 2e 20 7d stb %g1, [ %i0 + 0x7d ]
}
*buf = fs_info->c.buf;
20119f4: c2 06 20 80 ld [ %i0 + 0x80 ], %g1
20119f8: c2 26 c0 00 st %g1, [ %i3 ]
return RC_OK;
}
20119fc: 81 c7 e0 08 ret
2011a00: 91 e8 20 00 restore %g0, 0, %o0
02011a04 <fat_buf_release>:
int
fat_buf_release(fat_fs_info_t *fs_info)
{
2011a04: 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)
2011a08: c2 0e 20 7d ldub [ %i0 + 0x7d ], %g1
return RC_OK;
}
int
fat_buf_release(fat_fs_info_t *fs_info)
{
2011a0c: 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)
2011a10: 80 a0 60 00 cmp %g1, 0
2011a14: 02 80 00 52 be 2011b5c <fat_buf_release+0x158>
2011a18: b0 10 20 00 clr %i0
return RC_OK;
sec_of_fat = ((fs_info->c.blk_num >= fs_info->vol.fat_loc) &&
2011a1c: c2 07 60 78 ld [ %i5 + 0x78 ], %g1
2011a20: c4 17 60 14 lduh [ %i5 + 0x14 ], %g2
2011a24: 80 a0 40 02 cmp %g1, %g2
2011a28: 0a 80 00 05 bcs 2011a3c <fat_buf_release+0x38> <== NEVER TAKEN
2011a2c: b8 10 20 00 clr %i4
2011a30: c4 07 60 1c ld [ %i5 + 0x1c ], %g2
2011a34: 80 a0 40 02 cmp %g1, %g2
2011a38: b8 40 20 00 addx %g0, 0, %i4
(fs_info->c.blk_num < fs_info->vol.rdir_loc));
if (fs_info->c.modified)
2011a3c: c2 0f 60 7c ldub [ %i5 + 0x7c ], %g1
2011a40: 80 a0 60 00 cmp %g1, 0
2011a44: 02 80 00 39 be 2011b28 <fat_buf_release+0x124>
2011a48: 80 8f 20 ff btst 0xff, %i4
{
if (sec_of_fat && !fs_info->vol.mirror)
2011a4c: 02 80 00 0b be 2011a78 <fat_buf_release+0x74>
2011a50: 01 00 00 00 nop
2011a54: c2 0f 60 48 ldub [ %i5 + 0x48 ], %g1
2011a58: 80 a0 60 00 cmp %g1, 0
2011a5c: 12 80 00 07 bne 2011a78 <fat_buf_release+0x74> <== NEVER TAKEN
2011a60: 01 00 00 00 nop
memcpy(fs_info->sec_buf, fs_info->c.buf->buffer, fs_info->vol.bps);
2011a64: c2 07 60 80 ld [ %i5 + 0x80 ], %g1
2011a68: d0 07 60 84 ld [ %i5 + 0x84 ], %o0
2011a6c: d2 00 60 1c ld [ %g1 + 0x1c ], %o1
2011a70: 40 00 24 21 call 201aaf4 <memcpy>
2011a74: d4 17 40 00 lduh [ %i5 ], %o2
sc = rtems_bdbuf_release_modified(fs_info->c.buf);
2011a78: 7f ff f9 f0 call 2010238 <rtems_bdbuf_release_modified>
2011a7c: d0 07 60 80 ld [ %i5 + 0x80 ], %o0
if (sc != RTEMS_SUCCESSFUL)
2011a80: 80 a2 20 00 cmp %o0, 0
2011a84: 12 80 00 2e bne 2011b3c <fat_buf_release+0x138> <== NEVER TAKEN
2011a88: 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)
2011a8c: 02 80 00 32 be 2011b54 <fat_buf_release+0x150>
2011a90: c0 2f 60 7c clrb [ %i5 + 0x7c ]
2011a94: c2 0f 60 48 ldub [ %i5 + 0x48 ], %g1
2011a98: 80 a0 60 00 cmp %g1, 0
2011a9c: 22 80 00 1c be,a 2011b0c <fat_buf_release+0x108> <== ALWAYS TAKEN
2011aa0: 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;
2011aa4: 10 80 00 2d b 2011b58 <fat_buf_release+0x154> <== NOT EXECUTED
2011aa8: 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,
2011aac: 40 00 45 61 call 2023030 <.umul>
2011ab0: 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,
2011ab4: d2 07 60 78 ld [ %i5 + 0x78 ], %o1
2011ab8: 94 07 bf fc add %fp, -4, %o2
2011abc: 92 02 00 09 add %o0, %o1, %o1
2011ac0: 7f ff f8 fb call 200feac <rtems_bdbuf_get>
2011ac4: 90 10 00 1b mov %i3, %o0
fs_info->c.blk_num +
fs_info->vol.fat_length * i,
&b);
if ( sc != RTEMS_SUCCESSFUL)
2011ac8: 80 a2 20 00 cmp %o0, 0
2011acc: 22 80 00 03 be,a 2011ad8 <fat_buf_release+0xd4> <== ALWAYS TAKEN
2011ad0: c2 07 bf fc ld [ %fp + -4 ], %g1
2011ad4: 30 80 00 0a b,a 2011afc <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);
2011ad8: d2 07 60 84 ld [ %i5 + 0x84 ], %o1
2011adc: d0 00 60 1c ld [ %g1 + 0x1c ], %o0
2011ae0: 40 00 24 05 call 201aaf4 <memcpy>
2011ae4: d4 17 40 00 lduh [ %i5 ], %o2
sc = rtems_bdbuf_release_modified(b);
2011ae8: 7f ff f9 d4 call 2010238 <rtems_bdbuf_release_modified>
2011aec: d0 07 bf fc ld [ %fp + -4 ], %o0
if ( sc != RTEMS_SUCCESSFUL)
2011af0: 80 a2 20 00 cmp %o0, 0
2011af4: 22 80 00 06 be,a 2011b0c <fat_buf_release+0x108> <== ALWAYS TAKEN
2011af8: b8 07 20 01 inc %i4
rtems_set_errno_and_return_minus_one(ENOMEM);
2011afc: 40 00 21 49 call 201a020 <__errno> <== NOT EXECUTED
2011b00: 01 00 00 00 nop <== NOT EXECUTED
2011b04: 10 80 00 11 b 2011b48 <fat_buf_release+0x144> <== NOT EXECUTED
2011b08: 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++)
2011b0c: c4 0f 60 09 ldub [ %i5 + 9 ], %g2
2011b10: 90 0f 20 ff and %i4, 0xff, %o0
2011b14: 80 a2 00 02 cmp %o0, %g2
2011b18: 2a bf ff e5 bcs,a 2011aac <fat_buf_release+0xa8>
2011b1c: 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;
2011b20: 10 80 00 0e b 2011b58 <fat_buf_release+0x154>
2011b24: c0 2f 60 7d clrb [ %i5 + 0x7d ]
}
}
}
else
{
sc = rtems_bdbuf_release(fs_info->c.buf);
2011b28: 7f ff f9 8f call 2010164 <rtems_bdbuf_release>
2011b2c: d0 07 60 80 ld [ %i5 + 0x80 ], %o0
if (sc != RTEMS_SUCCESSFUL)
2011b30: 80 a2 20 00 cmp %o0, 0
2011b34: 22 80 00 09 be,a 2011b58 <fat_buf_release+0x154> <== ALWAYS TAKEN
2011b38: c0 2f 60 7d clrb [ %i5 + 0x7d ]
rtems_set_errno_and_return_minus_one(EIO);
2011b3c: 40 00 21 39 call 201a020 <__errno> <== NOT EXECUTED
2011b40: 01 00 00 00 nop <== NOT EXECUTED
2011b44: 82 10 20 05 mov 5, %g1 ! 5 <PROM_START+0x5> <== NOT EXECUTED
2011b48: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
2011b4c: 81 c7 e0 08 ret <== NOT EXECUTED
2011b50: 91 e8 3f ff restore %g0, -1, %o0 <== NOT EXECUTED
}
fs_info->c.state = FAT_CACHE_EMPTY;
2011b54: c0 2f 60 7d clrb [ %i5 + 0x7d ]
return RC_OK;
2011b58: b0 10 20 00 clr %i0
}
2011b5c: 81 c7 e0 08 ret
2011b60: 81 e8 00 00 restore
02010b84 <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)) )
2010b84: 80 a2 60 00 cmp %o1, 0
2010b88: 32 80 00 08 bne,a 2010ba8 <fat_cluster_num_to_sector_num+0x24>
2010b8c: c2 0a 20 05 ldub [ %o0 + 5 ], %g1
2010b90: c2 0a 20 0a ldub [ %o0 + 0xa ], %g1
2010b94: 80 88 60 03 btst 3, %g1
2010b98: 22 80 00 04 be,a 2010ba8 <fat_cluster_num_to_sector_num+0x24><== NEVER TAKEN
2010b9c: c2 0a 20 05 ldub [ %o0 + 5 ], %g1 <== NOT EXECUTED
return fs_info->vol.rdir_loc;
2010ba0: 81 c3 e0 08 retl
2010ba4: d0 02 20 1c ld [ %o0 + 0x1c ], %o0
return (((cln - FAT_RSRVD_CLN) << fs_info->vol.spc_log2) +
2010ba8: 92 02 7f fe add %o1, -2, %o1
2010bac: 93 2a 40 01 sll %o1, %g1, %o1
2010bb0: c2 02 20 30 ld [ %o0 + 0x30 ], %g1
fs_info->vol.data_fsec);
}
2010bb4: 81 c3 e0 08 retl
2010bb8: 90 02 40 01 add %o1, %g1, %o0
02011d1c <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)) )
2011d1c: 80 a2 60 00 cmp %o1, 0 <== NOT EXECUTED
2011d20: 12 80 00 08 bne 2011d40 <fat_cluster_read+0x24> <== NOT EXECUTED
2011d24: 98 10 00 0a mov %o2, %o4 <== NOT EXECUTED
2011d28: c2 0a 20 0a ldub [ %o0 + 0xa ], %g1 <== NOT EXECUTED
2011d2c: 80 88 60 03 btst 3, %g1 <== NOT EXECUTED
2011d30: 22 80 00 05 be,a 2011d44 <fat_cluster_read+0x28> <== NOT EXECUTED
2011d34: c2 0a 20 05 ldub [ %o0 + 5 ], %g1 <== NOT EXECUTED
return fs_info->vol.rdir_loc;
2011d38: 10 80 00 07 b 2011d54 <fat_cluster_read+0x38> <== NOT EXECUTED
2011d3c: d2 02 20 1c ld [ %o0 + 0x1c ], %o1 <== NOT EXECUTED
return (((cln - FAT_RSRVD_CLN) << fs_info->vol.spc_log2) +
2011d40: c2 0a 20 05 ldub [ %o0 + 5 ], %g1 <== NOT EXECUTED
2011d44: 92 02 7f fe add %o1, -2, %o1 <== NOT EXECUTED
2011d48: 93 2a 40 01 sll %o1, %g1, %o1 <== NOT EXECUTED
2011d4c: c2 02 20 30 ld [ %o0 + 0x30 ], %g1 <== NOT EXECUTED
2011d50: 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);
2011d54: d6 0a 20 04 ldub [ %o0 + 4 ], %o3 <== NOT EXECUTED
2011d58: 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,
2011d5c: 94 10 20 00 clr %o2 <== NOT EXECUTED
2011d60: 97 2a c0 01 sll %o3, %g1, %o3 <== NOT EXECUTED
2011d64: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED
2011d68: 7f ff ff 7f call 2011b64 <_fat_block_read> <== NOT EXECUTED
2011d6c: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED
02011d70 <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)) )
2011d70: 80 a2 60 00 cmp %o1, 0
2011d74: 12 80 00 08 bne 2011d94 <fat_cluster_write+0x24> <== ALWAYS TAKEN
2011d78: 98 10 00 0a mov %o2, %o4
2011d7c: c2 0a 20 0a ldub [ %o0 + 0xa ], %g1 <== NOT EXECUTED
2011d80: 80 88 60 03 btst 3, %g1 <== NOT EXECUTED
2011d84: 22 80 00 05 be,a 2011d98 <fat_cluster_write+0x28> <== NOT EXECUTED
2011d88: c2 0a 20 05 ldub [ %o0 + 5 ], %g1 <== NOT EXECUTED
return fs_info->vol.rdir_loc;
2011d8c: 10 80 00 07 b 2011da8 <fat_cluster_write+0x38> <== NOT EXECUTED
2011d90: d2 02 20 1c ld [ %o0 + 0x1c ], %o1 <== NOT EXECUTED
return (((cln - FAT_RSRVD_CLN) << fs_info->vol.spc_log2) +
2011d94: c2 0a 20 05 ldub [ %o0 + 5 ], %g1
2011d98: 92 02 7f fe add %o1, -2, %o1
2011d9c: 93 2a 40 01 sll %o1, %g1, %o1
2011da0: c2 02 20 30 ld [ %o0 + 0x30 ], %g1
2011da4: 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);
2011da8: d6 0a 20 04 ldub [ %o0 + 4 ], %o3
2011dac: 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,
2011db0: 94 10 20 00 clr %o2
2011db4: 97 2a c0 01 sll %o3, %g1, %o3
2011db8: 82 13 c0 00 mov %o7, %g1
2011dbc: 7f ff ff 8c call 2011bec <_fat_block_write>
2011dc0: 9e 10 40 00 mov %g1, %o7
02011f74 <fat_fat32_update_fsinfo_sector>:
fat_fat32_update_fsinfo_sector(
fat_fs_info_t *fs_info,
uint32_t free_count,
uint32_t next_free
)
{
2011f74: 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);
2011f78: 7f ff fe 1a call 20117e0 <CPU_swap_u32> <== NOT EXECUTED
2011f7c: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
2011f80: d0 27 bf f8 st %o0, [ %fp + -8 ] <== NOT EXECUTED
le_next_free = CT_LE_L(next_free);
2011f84: 7f ff fe 17 call 20117e0 <CPU_swap_u32> <== NOT EXECUTED
2011f88: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
ret1 = _fat_block_write(fs_info,
2011f8c: 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);
2011f90: d0 27 bf fc st %o0, [ %fp + -4 ] <== NOT EXECUTED
ret1 = _fat_block_write(fs_info,
2011f94: 94 10 21 e8 mov 0x1e8, %o2 <== NOT EXECUTED
2011f98: 96 10 20 04 mov 4, %o3 <== NOT EXECUTED
2011f9c: 98 07 bf f8 add %fp, -8, %o4 <== NOT EXECUTED
2011fa0: 7f ff ff 13 call 2011bec <_fat_block_write> <== NOT EXECUTED
2011fa4: 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,
2011fa8: 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,
2011fac: 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,
2011fb0: 94 10 21 ec mov 0x1ec, %o2 <== NOT EXECUTED
2011fb4: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
2011fb8: 96 10 20 04 mov 4, %o3 <== NOT EXECUTED
2011fbc: 7f ff ff 0c call 2011bec <_fat_block_write> <== NOT EXECUTED
2011fc0: 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) )
2011fc4: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2011fc8: 06 80 00 04 bl 2011fd8 <fat_fat32_update_fsinfo_sector+0x64><== NOT EXECUTED
2011fcc: 80 a7 60 00 cmp %i5, 0 <== NOT EXECUTED
2011fd0: 16 80 00 03 bge 2011fdc <fat_fat32_update_fsinfo_sector+0x68><== NOT EXECUTED
2011fd4: b0 10 20 00 clr %i0 <== NOT EXECUTED
return -1;
2011fd8: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
return RC_OK;
}
2011fdc: 81 c7 e0 08 ret <== NOT EXECUTED
2011fe0: 81 e8 00 00 restore <== NOT EXECUTED
020110f0 <fat_file_close>:
int
fat_file_close(
fat_fs_info_t *fs_info,
fat_file_fd_t *fat_fd
)
{
20110f0: 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)
20110f4: c2 06 60 08 ld [ %i1 + 8 ], %g1
20110f8: 80 a0 60 01 cmp %g1, 1
20110fc: 08 80 00 05 bleu 2011110 <fat_file_close+0x20>
2011100: 82 00 7f ff add %g1, -1, %g1
{
fat_fd->links_num--;
return rc;
2011104: 90 10 20 00 clr %o0
2011108: 10 80 00 25 b 201119c <fat_file_close+0xac>
201110c: 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)
2011110: c2 0e 60 30 ldub [ %i1 + 0x30 ], %g1
2011114: 80 88 60 01 btst 1, %g1
2011118: 02 80 00 14 be 2011168 <fat_file_close+0x78>
201111c: 90 10 00 18 mov %i0, %o0
{
rc = fat_file_truncate(fs_info, fat_fd, 0);
2011120: 92 10 00 19 mov %i1, %o1
2011124: 7f ff ff ae call 2010fdc <fat_file_truncate>
2011128: 94 10 20 00 clr %o2
if ( rc != RC_OK )
201112c: 80 a2 20 00 cmp %o0, 0
2011130: 12 80 00 1b bne 201119c <fat_file_close+0xac> <== NEVER TAKEN
2011134: 01 00 00 00 nop
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
2011138: 40 00 0e 15 call 201498c <_Chain_Extract>
201113c: 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) )
2011140: d2 06 60 0c ld [ %i1 + 0xc ], %o1
2011144: 40 00 03 88 call 2011f64 <fat_ino_is_unique>
2011148: 90 10 00 18 mov %i0, %o0
201114c: 80 8a 20 ff btst 0xff, %o0
2011150: 02 80 00 0f be 201118c <fat_file_close+0x9c> <== ALWAYS TAKEN
2011154: 01 00 00 00 nop
fat_free_unique_ino(fs_info, fat_fd->ino);
2011158: d2 06 60 0c ld [ %i1 + 0xc ], %o1 <== NOT EXECUTED
201115c: 40 00 03 77 call 2011f38 <fat_free_unique_ino> <== NOT EXECUTED
2011160: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
2011164: 30 80 00 0a b,a 201118c <fat_file_close+0x9c> <== NOT EXECUTED
free(fat_fd);
}
else
{
if (fat_ino_is_unique(fs_info, fat_fd->ino))
2011168: 40 00 03 7f call 2011f64 <fat_ino_is_unique>
201116c: d2 06 60 0c ld [ %i1 + 0xc ], %o1
2011170: 80 8a 20 ff btst 0xff, %o0
2011174: 02 80 00 04 be 2011184 <fat_file_close+0x94> <== ALWAYS TAKEN
2011178: 01 00 00 00 nop
{
fat_fd->links_num = 0;
201117c: 10 80 00 06 b 2011194 <fat_file_close+0xa4> <== NOT EXECUTED
2011180: c0 26 60 08 clr [ %i1 + 8 ] <== NOT EXECUTED
2011184: 40 00 0e 02 call 201498c <_Chain_Extract>
2011188: 90 10 00 19 mov %i1, %o0
}
else
{
_hash_delete(fs_info->vhash, key, fat_fd->ino, fat_fd);
free(fat_fd);
201118c: 7f ff cd 1c call 20045fc <free>
2011190: 90 10 00 19 mov %i1, %o0
}
}
/*
* flush any modified "cached" buffer back to disk
*/
rc = fat_buf_release(fs_info);
2011194: 40 00 02 1c call 2011a04 <fat_buf_release>
2011198: 81 e8 00 00 restore
return rc;
}
201119c: 81 c7 e0 08 ret
20111a0: 91 e8 00 08 restore %g0, %o0, %o0
02011274 <fat_file_extend>:
fat_file_fd_t *fat_fd,
bool zero_fill,
uint32_t new_length,
uint32_t *a_length
)
{
2011274: 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;
2011278: f6 27 00 00 st %i3, [ %i4 ]
if (new_length <= fat_fd->fat_file_size)
201127c: c2 06 60 18 ld [ %i1 + 0x18 ], %g1
uint32_t new_length,
uint32_t *a_length
)
{
int rc = RC_OK;
uint32_t chain = 0;
2011280: 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;
2011284: 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)
2011288: 80 a6 c0 01 cmp %i3, %g1
201128c: 18 80 00 04 bgu 201129c <fat_file_extend+0x28>
2011290: ba 10 00 18 mov %i0, %i5
return RC_OK;
2011294: 81 c7 e0 08 ret
2011298: 91 e8 20 00 restore %g0, 0, %o0
if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&
201129c: c4 06 60 20 ld [ %i1 + 0x20 ], %g2
20112a0: 80 a0 a0 01 cmp %g2, 1
20112a4: 32 80 00 0b bne,a 20112d0 <fat_file_extend+0x5c> <== ALWAYS TAKEN
20112a8: e0 17 60 06 lduh [ %i5 + 6 ], %l0
20112ac: c4 06 60 24 ld [ %i1 + 0x24 ], %g2 <== NOT EXECUTED
20112b0: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED
20112b4: 32 80 00 07 bne,a 20112d0 <fat_file_extend+0x5c> <== NOT EXECUTED
20112b8: e0 17 60 06 lduh [ %i5 + 6 ], %l0 <== NOT EXECUTED
(fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))
20112bc: 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)) &&
20112c0: 80 88 a0 03 btst 3, %g2 <== NOT EXECUTED
20112c4: 22 80 00 03 be,a 20112d0 <fat_file_extend+0x5c> <== NOT EXECUTED
20112c8: e0 17 60 06 lduh [ %i5 + 6 ], %l0 <== NOT EXECUTED
20112cc: 30 80 00 39 b,a 20113b0 <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))) &
20112d0: 84 04 3f ff add %l0, -1, %g2
20112d4: 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 -
20112d8: a0 24 00 12 sub %l0, %l2, %l0
20112dc: 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;
20112e0: 84 26 c0 01 sub %i3, %g1, %g2
if (bytes2add > bytes_remain)
20112e4: 80 a0 80 10 cmp %g2, %l0
20112e8: 08 80 00 03 bleu 20112f4 <fat_file_extend+0x80>
20112ec: a2 10 20 00 clr %l1
bytes2add -= bytes_remain;
20112f0: a2 20 80 10 sub %g2, %l0, %l1
else
bytes2add = 0;
if (zero_fill && bytes_remain > 0) {
20112f4: 80 a4 20 00 cmp %l0, 0
20112f8: 02 80 00 1c be 2011368 <fat_file_extend+0xf4>
20112fc: 80 a4 60 00 cmp %l1, 0
2011300: 80 a6 a0 00 cmp %i2, 0
2011304: 02 80 00 19 be 2011368 <fat_file_extend+0xf4>
2011308: 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;
201130c: 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);
2011310: 90 10 00 1d mov %i5, %o0
2011314: 92 10 00 19 mov %i1, %o1
2011318: 95 30 40 0a srl %g1, %o2, %o2
201131c: 7f ff fe 39 call 2010c00 <fat_file_lseek>
2011320: 96 07 bf fc add %fp, -4, %o3
if (rc != RC_OK)
2011324: b0 92 60 00 orcc %o1, 0, %i0
2011328: 12 80 00 26 bne 20113c0 <fat_file_extend+0x14c> <== NEVER TAKEN
201132c: d2 07 bf fc ld [ %fp + -4 ], %o1
return rc;
sec = fat_cluster_num_to_sector_num(fs_info, cur_cln);
2011330: 7f ff fe 15 call 2010b84 <fat_cluster_num_to_sector_num>
2011334: 90 10 00 1d mov %i5, %o0
sec += ofs >> fs_info->vol.sec_log2;
2011338: d2 0f 60 02 ldub [ %i5 + 2 ], %o1
byte = ofs & (fs_info->vol.bps - 1);
201133c: 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;
2011340: 93 34 80 09 srl %l2, %o1, %o1
byte = ofs & (fs_info->vol.bps - 1);
2011344: 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;
2011348: 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);
201134c: 94 0c 80 0a and %l2, %o2, %o2
2011350: 90 10 00 1d mov %i5, %o0
2011354: 40 00 02 4c call 2011c84 <_fat_block_zero>
2011358: 96 10 00 10 mov %l0, %o3
if (rc != RC_OK)
201135c: b0 92 20 00 orcc %o0, 0, %i0
2011360: 12 80 00 18 bne 20113c0 <fat_file_extend+0x14c> <== NEVER TAKEN
2011364: 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)
2011368: 02 bf ff cb be 2011294 <fat_file_extend+0x20>
201136c: a4 04 7f ff add %l1, -1, %l2
return RC_OK;
cls2add = ((bytes2add - 1) >> fs_info->vol.bpc_log2) + 1;
2011370: c2 0f 60 08 ldub [ %i5 + 8 ], %g1
rc = fat_scan_fat_for_free_clusters(fs_info, &chain, cls2add,
2011374: 90 10 00 1d mov %i5, %o0
* file ) - return
*/
if (bytes2add == 0)
return RC_OK;
cls2add = ((bytes2add - 1) >> fs_info->vol.bpc_log2) + 1;
2011378: a5 34 80 01 srl %l2, %g1, %l2
rc = fat_scan_fat_for_free_clusters(fs_info, &chain, cls2add,
201137c: 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;
2011380: a4 04 a0 01 inc %l2
rc = fat_scan_fat_for_free_clusters(fs_info, &chain, cls2add,
2011384: 96 07 bf fc add %fp, -4, %o3
2011388: 94 10 00 12 mov %l2, %o2
201138c: 98 07 bf f8 add %fp, -8, %o4
2011390: 40 00 1c 6e call 2018548 <fat_scan_fat_for_free_clusters>
2011394: 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)
2011398: b0 92 20 00 orcc %o0, 0, %i0
201139c: 12 80 00 09 bne 20113c0 <fat_file_extend+0x14c> <== NEVER TAKEN
20113a0: 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))
20113a4: 80 94 00 01 orcc %l0, %g1, %g0
20113a8: 12 80 00 08 bne 20113c8 <fat_file_extend+0x154> <== ALWAYS TAKEN
20113ac: 80 a4 80 01 cmp %l2, %g1
rtems_set_errno_and_return_minus_one(ENOSPC);
20113b0: 40 00 23 1c call 201a020 <__errno> <== NOT EXECUTED
20113b4: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
20113b8: 82 10 20 1c mov 0x1c, %g1 <== NOT EXECUTED
20113bc: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
20113c0: 81 c7 e0 08 ret <== NOT EXECUTED
20113c4: 81 e8 00 00 restore <== NOT EXECUTED
/* check wether we satisfied request for 'cls2add' clusters */
if (cls2add != cls_added)
20113c8: 02 80 00 09 be 20113ec <fat_file_extend+0x178> <== ALWAYS TAKEN
20113cc: 82 24 80 01 sub %l2, %g1, %g1
{
new_length -= bytes2add & (fs_info->vol.bpc - 1);
20113d0: c4 17 60 06 lduh [ %i5 + 6 ], %g2 <== NOT EXECUTED
20113d4: 84 00 bf ff add %g2, -1, %g2 <== NOT EXECUTED
20113d8: a2 0c 40 02 and %l1, %g2, %l1 <== NOT EXECUTED
new_length -= (cls2add - cls_added) << fs_info->vol.bpc_log2;
20113dc: 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);
20113e0: b6 26 c0 11 sub %i3, %l1, %i3 <== NOT EXECUTED
new_length -= (cls2add - cls_added) << fs_info->vol.bpc_log2;
20113e4: 83 28 40 02 sll %g1, %g2, %g1 <== NOT EXECUTED
20113e8: 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 )
20113ec: d6 06 60 18 ld [ %i1 + 0x18 ], %o3
20113f0: 80 a2 e0 00 cmp %o3, 0
20113f4: 32 80 00 07 bne,a 2011410 <fat_file_extend+0x19c>
20113f8: c2 06 60 3c ld [ %i1 + 0x3c ], %g1
{
fat_fd->map.disk_cln = fat_fd->cln = chain;
20113fc: c2 07 bf f0 ld [ %fp + -16 ], %g1
fat_fd->map.file_cln = 0;
2011400: 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;
2011404: c2 26 60 1c st %g1, [ %i1 + 0x1c ]
2011408: 10 80 00 1d b 201147c <fat_file_extend+0x208>
201140c: c2 26 60 38 st %g1, [ %i1 + 0x38 ]
fat_fd->map.file_cln = 0;
}
else
{
if (fat_fd->map.last_cln != FAT_UNDEFINED_VALUE)
2011410: 80 a0 7f ff cmp %g1, -1
2011414: 22 80 00 04 be,a 2011424 <fat_file_extend+0x1b0> <== NEVER TAKEN
2011418: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
{
old_last_cl = fat_fd->map.last_cln;
201141c: 10 80 00 0c b 201144c <fat_file_extend+0x1d8>
2011420: c2 27 bf f4 st %g1, [ %fp + -12 ]
}
else
{
rc = fat_file_ioctl(fs_info, fat_fd, F_CLU_NUM,
2011424: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
2011428: 94 10 20 01 mov 1, %o2 <== NOT EXECUTED
201142c: 96 02 ff ff add %o3, -1, %o3 <== NOT EXECUTED
2011430: 7f ff ff 5d call 20111a4 <fat_file_ioctl> <== NOT EXECUTED
2011434: 98 07 bf f4 add %fp, -12, %o4 <== NOT EXECUTED
(fat_fd->fat_file_size - 1), &old_last_cl);
if ( rc != RC_OK )
2011438: b4 92 20 00 orcc %o0, 0, %i2 <== NOT EXECUTED
201143c: 02 80 00 05 be 2011450 <fat_file_extend+0x1dc> <== NOT EXECUTED
2011440: 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);
2011444: 10 80 00 1f b 20114c0 <fat_file_extend+0x24c> <== NOT EXECUTED
2011448: 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);
201144c: d2 07 bf f4 ld [ %fp + -12 ], %o1
2011450: d4 07 bf f0 ld [ %fp + -16 ], %o2
2011454: 40 00 1b 5f call 20181d0 <fat_set_fat_cluster>
2011458: 90 10 00 1d mov %i5, %o0
201145c: b4 10 00 08 mov %o0, %i2
if ( rc != RC_OK )
2011460: 80 a6 a0 00 cmp %i2, 0
2011464: 02 80 00 04 be 2011474 <fat_file_extend+0x200> <== ALWAYS TAKEN
2011468: 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);
201146c: 10 80 00 16 b 20114c4 <fat_file_extend+0x250> <== NOT EXECUTED
2011470: 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);
2011474: 40 00 01 64 call 2011a04 <fat_buf_release>
2011478: 01 00 00 00 nop
}
/* update number of the last cluster of the file if it changed */
if (cls_added != 0)
201147c: c2 07 bf fc ld [ %fp + -4 ], %g1
2011480: 80 a0 60 00 cmp %g1, 0
2011484: 22 80 00 14 be,a 20114d4 <fat_file_extend+0x260> <== NEVER TAKEN
2011488: f6 27 00 00 st %i3, [ %i4 ] <== NOT EXECUTED
{
fat_fd->map.last_cln = last_cl;
201148c: c2 07 bf f8 ld [ %fp + -8 ], %g1
2011490: c2 26 60 3c st %g1, [ %i1 + 0x3c ]
if (fat_fd->fat_file_type == FAT_DIRECTORY)
2011494: c2 06 60 10 ld [ %i1 + 0x10 ], %g1
2011498: 80 a0 60 00 cmp %g1, 0
201149c: 32 80 00 0e bne,a 20114d4 <fat_file_extend+0x260>
20114a0: f6 27 00 00 st %i3, [ %i4 ]
{
rc = fat_init_clusters_chain(fs_info, chain);
20114a4: d2 07 bf f0 ld [ %fp + -16 ], %o1
20114a8: 40 00 02 47 call 2011dc4 <fat_init_clusters_chain>
20114ac: 90 10 00 1d mov %i5, %o0
if ( rc != RC_OK )
20114b0: b4 92 20 00 orcc %o0, 0, %i2
20114b4: 22 80 00 08 be,a 20114d4 <fat_file_extend+0x260> <== ALWAYS TAKEN
20114b8: f6 27 00 00 st %i3, [ %i4 ]
{
fat_free_fat_clusters_chain(fs_info, chain);
20114bc: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
20114c0: d2 07 bf f0 ld [ %fp + -16 ], %o1 <== NOT EXECUTED
20114c4: 40 00 1b f2 call 201848c <fat_free_fat_clusters_chain> <== NOT EXECUTED
20114c8: b0 10 00 1a mov %i2, %i0 <== NOT EXECUTED
20114cc: 81 c7 e0 08 ret <== NOT EXECUTED
20114d0: 81 e8 00 00 restore <== NOT EXECUTED
}
}
}
*a_length = new_length;
fat_fd->fat_file_size = new_length;
20114d4: f6 26 60 18 st %i3, [ %i1 + 0x18 ]
return RC_OK;
}
20114d8: 81 c7 e0 08 ret
20114dc: 81 e8 00 00 restore
020111a4 <fat_file_ioctl>:
fat_file_ioctl(
fat_fs_info_t *fs_info,
fat_file_fd_t *fat_fd,
int cmd,
...)
{
20111a4: 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);
20111a8: 82 07 a0 50 add %fp, 0x50, %g1
20111ac: f6 27 a0 50 st %i3, [ %fp + 0x50 ]
20111b0: f8 27 a0 54 st %i4, [ %fp + 0x54 ]
20111b4: 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;
20111b8: c0 27 bf f8 clr [ %fp + -8 ]
uint32_t *ret;
va_list ap;
va_start(ap, cmd);
switch (cmd)
20111bc: 80 a6 a0 01 cmp %i2, 1
20111c0: 12 80 00 26 bne 2011258 <fat_file_ioctl+0xb4> <== NEVER TAKEN
20111c4: c2 27 bf fc st %g1, [ %fp + -4 ]
{
case F_CLU_NUM:
pos = va_arg(ap, uint32_t);
ret = va_arg(ap, uint32_t *);
20111c8: 82 07 a0 58 add %fp, 0x58, %g1
20111cc: c2 27 bf fc st %g1, [ %fp + -4 ]
/* sanity check */
if ( pos >= fat_fd->fat_file_size ) {
20111d0: c2 06 60 18 ld [ %i1 + 0x18 ], %g1
20111d4: 80 a6 c0 01 cmp %i3, %g1
20111d8: 0a 80 00 06 bcs 20111f0 <fat_file_ioctl+0x4c> <== ALWAYS TAKEN
20111dc: ba 10 00 1c mov %i4, %i5
va_end(ap);
rtems_set_errno_and_return_minus_one( EIO );
20111e0: 40 00 23 90 call 201a020 <__errno> <== NOT EXECUTED
20111e4: 01 00 00 00 nop <== NOT EXECUTED
20111e8: 10 80 00 1f b 2011264 <fat_file_ioctl+0xc0> <== NOT EXECUTED
20111ec: 82 10 20 05 mov 5, %g1 ! 5 <PROM_START+0x5> <== NOT EXECUTED
}
if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&
20111f0: c2 06 60 20 ld [ %i1 + 0x20 ], %g1
20111f4: 80 a0 60 01 cmp %g1, 1
20111f8: 32 80 00 0d bne,a 201122c <fat_file_ioctl+0x88>
20111fc: d4 0e 20 08 ldub [ %i0 + 8 ], %o2
2011200: c2 06 60 24 ld [ %i1 + 0x24 ], %g1
2011204: 80 a0 60 00 cmp %g1, 0
2011208: 32 80 00 09 bne,a 201122c <fat_file_ioctl+0x88> <== NEVER TAKEN
201120c: d4 0e 20 08 ldub [ %i0 + 8 ], %o2 <== NOT EXECUTED
(fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))
2011210: 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)) &&
2011214: 80 88 60 03 btst 3, %g1
2011218: 22 80 00 05 be,a 201122c <fat_file_ioctl+0x88> <== NEVER TAKEN
201121c: 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;
2011220: c0 27 00 00 clr [ %i4 ]
rc = RC_OK;
break;
2011224: 81 c7 e0 08 ret
2011228: 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);
201122c: 90 10 00 18 mov %i0, %o0
2011230: 92 10 00 19 mov %i1, %o1
2011234: 95 36 c0 0a srl %i3, %o2, %o2
2011238: 7f ff fe 72 call 2010c00 <fat_file_lseek>
201123c: 96 07 bf f8 add %fp, -8, %o3
if ( rc != RC_OK )
2011240: b0 92 60 00 orcc %o1, 0, %i0
2011244: 12 80 00 03 bne 2011250 <fat_file_ioctl+0xac> <== NEVER TAKEN
2011248: c2 07 bf f8 ld [ %fp + -8 ], %g1
break;
*ret = cur_cln;
201124c: c2 27 40 00 st %g1, [ %i5 ]
break;
2011250: 81 c7 e0 08 ret
2011254: 81 e8 00 00 restore
default:
errno = EINVAL;
2011258: 40 00 23 72 call 201a020 <__errno> <== NOT EXECUTED
201125c: 01 00 00 00 nop <== NOT EXECUTED
2011260: 82 10 20 16 mov 0x16, %g1 ! 16 <PROM_START+0x16> <== NOT EXECUTED
2011264: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
rc = -1;
2011268: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
break;
}
va_end(ap);
return rc;
}
201126c: 81 c7 e0 08 ret <== NOT EXECUTED
2011270: 81 e8 00 00 restore <== NOT EXECUTED
02010c00 <fat_file_lseek>:
fat_fs_info_t *fs_info,
fat_file_fd_t *fat_fd,
uint32_t file_cln,
uint32_t *disk_cln
)
{
2010c00: 9d e3 bf 98 save %sp, -104, %sp
int rc = RC_OK;
if (file_cln == fat_fd->map.file_cln)
2010c04: c2 06 60 34 ld [ %i1 + 0x34 ], %g1
2010c08: 80 a6 80 01 cmp %i2, %g1
2010c0c: 12 80 00 05 bne 2010c20 <fat_file_lseek+0x20>
2010c10: 01 00 00 00 nop
*disk_cln = fat_fd->map.disk_cln;
2010c14: c2 06 60 38 ld [ %i1 + 0x38 ], %g1
2010c18: 10 80 00 1b b 2010c84 <fat_file_lseek+0x84>
2010c1c: 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)
2010c20: 28 80 00 06 bleu,a 2010c38 <fat_file_lseek+0x38>
2010c24: c2 06 60 1c ld [ %i1 + 0x1c ], %g1
{
cur_cln = fat_fd->map.disk_cln;
2010c28: c4 06 60 38 ld [ %i1 + 0x38 ], %g2
count = file_cln - fat_fd->map.file_cln;
2010c2c: 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;
2010c30: 10 80 00 04 b 2010c40 <fat_file_lseek+0x40>
2010c34: c4 27 bf fc st %g2, [ %fp + -4 ]
count = file_cln - fat_fd->map.file_cln;
}
else
{
cur_cln = fat_fd->cln;
2010c38: b8 10 00 1a mov %i2, %i4
2010c3c: c2 27 bf fc st %g1, [ %fp + -4 ]
count = file_cln;
}
/* skip over the clusters */
for (i = 0; i < count; i++)
2010c40: 10 80 00 0b b 2010c6c <fat_file_lseek+0x6c>
2010c44: ba 10 20 00 clr %i5
{
rc = fat_get_fat_cluster(fs_info, cur_cln, &cur_cln);
2010c48: 90 10 00 18 mov %i0, %o0
2010c4c: 40 00 1c ea call 2017ff4 <fat_get_fat_cluster>
2010c50: 94 07 bf fc add %fp, -4, %o2
if ( rc != RC_OK )
2010c54: 80 a2 20 00 cmp %o0, 0
2010c58: 22 80 00 05 be,a 2010c6c <fat_file_lseek+0x6c> <== ALWAYS TAKEN
2010c5c: ba 07 60 01 inc %i5
return rc;
2010c60: 86 10 00 08 mov %o0, %g3 <== NOT EXECUTED
2010c64: 10 80 00 0a b 2010c8c <fat_file_lseek+0x8c> <== NOT EXECUTED
2010c68: 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++)
2010c6c: 80 a7 40 1c cmp %i5, %i4
2010c70: 12 bf ff f6 bne 2010c48 <fat_file_lseek+0x48>
2010c74: d2 07 bf fc ld [ %fp + -4 ], %o1
if ( rc != RC_OK )
return rc;
}
/* update cache */
fat_fd->map.file_cln = file_cln;
2010c78: f4 26 60 34 st %i2, [ %i1 + 0x34 ]
fat_fd->map.disk_cln = cur_cln;
2010c7c: d2 26 60 38 st %o1, [ %i1 + 0x38 ]
*disk_cln = cur_cln;
2010c80: d2 26 c0 00 st %o1, [ %i3 ]
}
return RC_OK;
2010c84: 84 10 20 00 clr %g2
2010c88: 86 10 20 00 clr %g3
}
2010c8c: b0 10 00 02 mov %g2, %i0
2010c90: 81 c7 e0 08 ret
2010c94: 93 e8 00 03 restore %g0, %g3, %o1
02010c98 <fat_file_open>:
fat_file_open(
fat_fs_info_t *fs_info,
fat_dir_pos_t *dir_pos,
fat_file_fd_t **fat_fd
)
{
2010c98: 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);
2010c9c: 90 10 00 18 mov %i0, %o0
2010ca0: 7f ff ff c7 call 2010bbc <fat_construct_key>
2010ca4: 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;
2010ca8: 82 0a 20 01 and %o0, 1, %g1
rtems_chain_node *the_node = rtems_chain_first(hash + mod);
2010cac: 85 28 60 02 sll %g1, 2, %g2
2010cb0: b7 28 60 04 sll %g1, 4, %i3
2010cb4: c2 06 20 60 ld [ %i0 + 0x60 ], %g1
2010cb8: 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);
2010cbc: 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);
2010cc0: 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;
2010cc4: 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 ));
2010cc8: 10 80 00 0c b 2010cf8 <fat_file_open+0x60>
2010ccc: 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);
2010cd0: 7f ff ff bb call 2010bbc <fat_construct_key>
2010cd4: 92 07 60 20 add %i5, 0x20, %o1
if ( (key1) == ck)
2010cd8: 80 a7 00 08 cmp %i4, %o0
2010cdc: 32 80 00 07 bne,a 2010cf8 <fat_file_open+0x60>
2010ce0: 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++;
2010ce4: 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;
2010ce8: fa 26 80 00 st %i5, [ %i2 ]
lfat_fd->links_num++;
2010cec: 82 00 60 01 inc %g1
2010cf0: 10 80 00 42 b 2010df8 <fat_file_open+0x160>
2010cf4: 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) ; )
2010cf8: 80 a7 40 10 cmp %i5, %l0
2010cfc: 12 bf ff f5 bne 2010cd0 <fat_file_open+0x38>
2010d00: 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);
2010d04: 10 80 00 3f b 2010e00 <fat_file_open+0x168>
2010d08: 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);
2010d0c: 7f ff ff ac call 2010bbc <fat_construct_key> <== NOT EXECUTED
2010d10: 92 07 60 20 add %i5, 0x20, %o1 <== NOT EXECUTED
if ( (key1) == ck)
2010d14: 80 a7 00 08 cmp %i4, %o0 <== NOT EXECUTED
2010d18: 32 80 00 0a bne,a 2010d40 <fat_file_open+0xa8> <== NOT EXECUTED
2010d1c: fa 07 40 00 ld [ %i5 ], %i5 <== NOT EXECUTED
{
if ( ((key2) == 0) || ((key2) == ffd->ino) )
2010d20: 80 a7 20 00 cmp %i4, 0 <== NOT EXECUTED
2010d24: 22 80 00 0b be,a 2010d50 <fat_file_open+0xb8> <== NOT EXECUTED
2010d28: a0 10 20 00 clr %l0 <== NOT EXECUTED
2010d2c: c2 07 60 0c ld [ %i5 + 0xc ], %g1 <== NOT EXECUTED
2010d30: 80 a7 00 01 cmp %i4, %g1 <== NOT EXECUTED
2010d34: 22 80 00 07 be,a 2010d50 <fat_file_open+0xb8> <== NOT EXECUTED
2010d38: a0 10 20 00 clr %l0 <== NOT EXECUTED
{
*ret = (void *)the_node;
return 0;
}
}
the_node = the_node->next;
2010d3c: 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) ; )
2010d40: 80 a7 40 10 cmp %i5, %l0
2010d44: 12 bf ff f2 bne 2010d0c <fat_file_open+0x74> <== NEVER TAKEN
2010d48: 90 10 00 18 mov %i0, %o0
2010d4c: 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));
2010d50: 7f ff cf c1 call 2004c54 <malloc>
2010d54: 90 10 20 44 mov 0x44, %o0
2010d58: d0 26 80 00 st %o0, [ %i2 ]
if ( lfat_fd == NULL )
2010d5c: 80 a2 20 00 cmp %o0, 0
2010d60: 02 80 00 1c be 2010dd0 <fat_file_open+0x138> <== NEVER TAKEN
2010d64: ba 10 00 08 mov %o0, %i5
rtems_set_errno_and_return_minus_one( ENOMEM );
memset(lfat_fd, 0, sizeof(fat_file_fd_t));
2010d68: 92 10 20 00 clr %o1
2010d6c: 40 00 27 9f call 201abe8 <memset>
2010d70: 94 10 20 44 mov 0x44, %o2
lfat_fd->links_num = 1;
2010d74: 82 10 20 01 mov 1, %g1
2010d78: c2 27 60 08 st %g1, [ %i5 + 8 ]
lfat_fd->flags &= ~FAT_FILE_REMOVED;
2010d7c: c2 0f 60 30 ldub [ %i5 + 0x30 ], %g1
lfat_fd->map.last_cln = FAT_UNDEFINED_VALUE;
lfat_fd->dir_pos = *dir_pos;
2010d80: 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;
2010d84: 82 08 7f fe and %g1, -2, %g1
2010d88: c2 2f 60 30 stb %g1, [ %i5 + 0x30 ]
lfat_fd->map.last_cln = FAT_UNDEFINED_VALUE;
2010d8c: 82 10 3f ff mov -1, %g1
lfat_fd->dir_pos = *dir_pos;
2010d90: 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;
2010d94: c2 27 60 3c st %g1, [ %i5 + 0x3c ]
lfat_fd->dir_pos = *dir_pos;
2010d98: 40 00 27 57 call 201aaf4 <memcpy>
2010d9c: 94 10 20 10 mov 0x10, %o2
if ( rc != RC_OK )
2010da0: 80 a4 20 00 cmp %l0, 0
2010da4: 02 80 00 04 be 2010db4 <fat_file_open+0x11c> <== NEVER TAKEN
2010da8: 01 00 00 00 nop
lfat_fd->ino = key;
2010dac: 10 80 00 0f b 2010de8 <fat_file_open+0x150>
2010db0: f8 27 60 0c st %i4, [ %i5 + 0xc ]
else
{
lfat_fd->ino = fat_get_unique_ino(fs_info);
2010db4: 40 00 04 31 call 2011e78 <fat_get_unique_ino> <== NOT EXECUTED
2010db8: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
if ( lfat_fd->ino == 0 )
2010dbc: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2010dc0: 12 80 00 0a bne 2010de8 <fat_file_open+0x150> <== NOT EXECUTED
2010dc4: d0 27 60 0c st %o0, [ %i5 + 0xc ] <== NOT EXECUTED
{
free((*fat_fd));
2010dc8: 7f ff ce 0d call 20045fc <free> <== NOT EXECUTED
2010dcc: 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 );
2010dd0: 40 00 24 94 call 201a020 <__errno> <== NOT EXECUTED
2010dd4: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
2010dd8: 82 10 20 0c mov 0xc, %g1 <== NOT EXECUTED
2010ddc: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
2010de0: 81 c7 e0 08 ret <== NOT EXECUTED
2010de4: 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);
2010de8: 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 );
2010dec: 92 10 00 1d mov %i5, %o1
2010df0: 7f ff e2 9f call 200986c <_Chain_Append>
2010df4: 90 02 00 1b add %o0, %i3, %o0
/*
* other fields of fat-file descriptor will be initialized on upper
* level
*/
return RC_OK;
2010df8: 81 c7 e0 08 ret
2010dfc: 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);
2010e00: 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;
2010e04: 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 ));
2010e08: 10 bf ff ce b 2010d40 <fat_file_open+0xa8>
2010e0c: a0 04 20 04 add %l0, 4, %l0
02010e24 <fat_file_read>:
fat_file_fd_t *fat_fd,
uint32_t start,
uint32_t count,
uint8_t *buf
)
{
2010e24: 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;
2010e28: c0 27 bf fc clr [ %fp + -4 ]
fat_file_fd_t *fat_fd,
uint32_t start,
uint32_t count,
uint8_t *buf
)
{
2010e2c: 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)
2010e30: 80 a6 e0 00 cmp %i3, 0
2010e34: 02 80 00 68 be 2010fd4 <fat_file_read+0x1b0> <== NEVER TAKEN
2010e38: 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 )
2010e3c: c2 06 60 18 ld [ %i1 + 0x18 ], %g1
2010e40: 80 a6 80 01 cmp %i2, %g1
2010e44: 1a 80 00 64 bcc 2010fd4 <fat_file_read+0x1b0>
2010e48: 80 a6 c0 01 cmp %i3, %g1
return FAT_EOF;
if ((count > fat_fd->fat_file_size) ||
2010e4c: 38 80 00 07 bgu,a 2010e68 <fat_file_read+0x44> <== NEVER TAKEN
2010e50: b6 20 40 1a sub %g1, %i2, %i3 <== NOT EXECUTED
(start > fat_fd->fat_file_size - count))
2010e54: 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) ||
2010e58: 80 a6 80 02 cmp %i2, %g2
2010e5c: 28 80 00 04 bleu,a 2010e6c <fat_file_read+0x48>
2010e60: c2 06 60 20 ld [ %i1 + 0x20 ], %g1
(start > fat_fd->fat_file_size - count))
count = fat_fd->fat_file_size - start;
2010e64: b6 20 40 1a sub %g1, %i2, %i3
if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&
2010e68: c2 06 60 20 ld [ %i1 + 0x20 ], %g1
2010e6c: 80 a0 60 01 cmp %g1, 1
2010e70: 32 80 00 1c bne,a 2010ee0 <fat_file_read+0xbc>
2010e74: e4 0f 60 08 ldub [ %i5 + 8 ], %l2
2010e78: c2 06 60 24 ld [ %i1 + 0x24 ], %g1
2010e7c: 80 a0 60 00 cmp %g1, 0
2010e80: 32 80 00 18 bne,a 2010ee0 <fat_file_read+0xbc> <== NEVER TAKEN
2010e84: e4 0f 60 08 ldub [ %i5 + 8 ], %l2 <== NOT EXECUTED
(fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))
2010e88: 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)) &&
2010e8c: 80 88 60 03 btst 3, %g1
2010e90: 22 80 00 14 be,a 2010ee0 <fat_file_read+0xbc> <== NEVER TAKEN
2010e94: 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);
2010e98: d2 06 60 1c ld [ %i1 + 0x1c ], %o1
2010e9c: 7f ff ff 3a call 2010b84 <fat_cluster_num_to_sector_num>
2010ea0: 90 10 00 1d mov %i5, %o0
sec += (start >> fs_info->vol.sec_log2);
2010ea4: d2 0f 60 02 ldub [ %i5 + 2 ], %o1
byte = start & (fs_info->vol.bps - 1);
2010ea8: 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);
2010eac: 93 36 80 09 srl %i2, %o1, %o1
byte = start & (fs_info->vol.bps - 1);
2010eb0: 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);
2010eb4: 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);
2010eb8: 94 0e 80 0a and %i2, %o2, %o2
2010ebc: 90 10 00 1d mov %i5, %o0
2010ec0: 96 10 00 1b mov %i3, %o3
2010ec4: 40 00 03 28 call 2011b64 <_fat_block_read>
2010ec8: 98 10 00 1c mov %i4, %o4
if ( ret < 0 )
2010ecc: 80 a2 20 00 cmp %o0, 0
2010ed0: 16 80 00 41 bge 2010fd4 <fat_file_read+0x1b0> <== ALWAYS TAKEN
2010ed4: 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;
2010ed8: 10 80 00 3f b 2010fd4 <fat_file_read+0x1b0> <== NOT EXECUTED
2010edc: 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);
2010ee0: f0 17 60 06 lduh [ %i5 + 6 ], %i0
return -1;
return ret;
}
cl_start = start >> fs_info->vol.bpc_log2;
2010ee4: 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);
2010ee8: a6 07 bf fc add %fp, -4, %l3
2010eec: 90 10 00 1d mov %i5, %o0
2010ef0: 92 10 00 19 mov %i1, %o1
2010ef4: 94 10 00 12 mov %l2, %o2
2010ef8: 7f ff ff 42 call 2010c00 <fat_file_lseek>
2010efc: 96 10 00 13 mov %l3, %o3
if (rc != RC_OK)
2010f00: 90 92 60 00 orcc %o1, 0, %o0
2010f04: 12 80 00 34 bne 2010fd4 <fat_file_read+0x1b0> <== NEVER TAKEN
2010f08: 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);
2010f0c: b1 2e 20 10 sll %i0, 0x10, %i0
2010f10: b1 36 20 10 srl %i0, 0x10, %i0
2010f14: b0 06 3f ff add %i0, -1, %i0
2010f18: b4 0e 80 18 and %i2, %i0, %i2
2010f1c: b0 10 20 00 clr %i0
2010f20: 10 80 00 20 b 2010fa0 <fat_file_read+0x17c>
2010f24: a2 10 00 1a mov %i2, %l1
if (rc != RC_OK)
return rc;
while (count > 0)
{
c = MIN(count, (fs_info->vol.bpc - ofs));
2010f28: a0 24 00 11 sub %l0, %l1, %l0
2010f2c: 80 a4 00 1b cmp %l0, %i3
2010f30: 38 80 00 02 bgu,a 2010f38 <fat_file_read+0x114>
2010f34: a0 10 00 1b mov %i3, %l0
sec = fat_cluster_num_to_sector_num(fs_info, cur_cln);
2010f38: d2 07 bf fc ld [ %fp + -4 ], %o1
2010f3c: 7f ff ff 12 call 2010b84 <fat_cluster_num_to_sector_num>
2010f40: 90 10 00 1d mov %i5, %o0
sec += (ofs >> fs_info->vol.sec_log2);
2010f44: d2 0f 60 02 ldub [ %i5 + 2 ], %o1
byte = ofs & (fs_info->vol.bps - 1);
2010f48: 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);
2010f4c: 93 34 40 09 srl %l1, %o1, %o1
byte = ofs & (fs_info->vol.bps - 1);
2010f50: 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);
2010f54: 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);
2010f58: 94 0c 40 0a and %l1, %o2, %o2
2010f5c: 90 10 00 1d mov %i5, %o0
2010f60: 96 10 00 10 mov %l0, %o3
2010f64: 40 00 03 00 call 2011b64 <_fat_block_read>
2010f68: 98 07 00 18 add %i4, %i0, %o4
if ( ret < 0 )
2010f6c: 80 a2 20 00 cmp %o0, 0
2010f70: 06 80 00 18 bl 2010fd0 <fat_file_read+0x1ac> <== NEVER TAKEN
2010f74: b6 26 c0 10 sub %i3, %l0, %i3
return -1;
count -= c;
cmpltd += c;
2010f78: b0 06 00 10 add %i0, %l0, %i0
save_cln = cur_cln;
2010f7c: e0 07 bf fc ld [ %fp + -4 ], %l0
rc = fat_get_fat_cluster(fs_info, cur_cln, &cur_cln);
2010f80: 90 10 00 1d mov %i5, %o0
2010f84: 92 10 00 10 mov %l0, %o1
2010f88: 94 10 00 13 mov %l3, %o2
2010f8c: 40 00 1c 1a call 2017ff4 <fat_get_fat_cluster>
2010f90: a2 10 20 00 clr %l1
if ( rc != RC_OK )
2010f94: 80 a2 20 00 cmp %o0, 0
2010f98: 12 80 00 0f bne 2010fd4 <fat_file_read+0x1b0> <== NEVER TAKEN
2010f9c: 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)
2010fa0: 80 a6 e0 00 cmp %i3, 0
2010fa4: 32 bf ff e1 bne,a 2010f28 <fat_file_read+0x104>
2010fa8: 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);
2010fac: c2 0f 60 08 ldub [ %i5 + 8 ], %g1
2010fb0: b4 06 bf ff add %i2, -1, %i2
fat_fd->map.disk_cln = save_cln;
2010fb4: 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);
2010fb8: b4 06 80 18 add %i2, %i0, %i2
fat_fd->map.disk_cln = save_cln;
return cmpltd;
2010fbc: 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);
2010fc0: 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 +
2010fc4: a4 06 80 12 add %i2, %l2, %l2
2010fc8: 10 80 00 03 b 2010fd4 <fat_file_read+0x1b0>
2010fcc: 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;
2010fd0: 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;
}
2010fd4: 81 c7 e0 08 ret
2010fd8: 91 e8 00 08 restore %g0, %o0, %o0
02011734 <fat_file_size>:
int
fat_file_size(
fat_fs_info_t *fs_info,
fat_file_fd_t *fat_fd
)
{
2011734: 9d e3 bf 98 save %sp, -104, %sp
int rc = RC_OK;
uint32_t cur_cln = fat_fd->cln;
2011738: c2 06 60 1c ld [ %i1 + 0x1c ], %g1
201173c: 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)) &&
2011740: c2 06 60 20 ld [ %i1 + 0x20 ], %g1
2011744: 80 a0 60 01 cmp %g1, 1
2011748: 12 80 00 0d bne 201177c <fat_file_size+0x48> <== ALWAYS TAKEN
201174c: ba 10 00 18 mov %i0, %i5
2011750: c2 06 60 24 ld [ %i1 + 0x24 ], %g1 <== NOT EXECUTED
2011754: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
2011758: 32 80 00 0a bne,a 2011780 <fat_file_size+0x4c> <== NOT EXECUTED
201175c: c0 26 60 18 clr [ %i1 + 0x18 ] <== NOT EXECUTED
(fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))
2011760: 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)) &&
2011764: 80 88 60 03 btst 3, %g1 <== NOT EXECUTED
2011768: 22 80 00 06 be,a 2011780 <fat_file_size+0x4c> <== NOT EXECUTED
201176c: 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;
2011770: c2 06 20 28 ld [ %i0 + 0x28 ], %g1 <== NOT EXECUTED
2011774: 10 80 00 18 b 20117d4 <fat_file_size+0xa0> <== NOT EXECUTED
2011778: c2 26 60 18 st %g1, [ %i1 + 0x18 ] <== NOT EXECUTED
return rc;
}
fat_fd->fat_file_size = 0;
201177c: c0 26 60 18 clr [ %i1 + 0x18 ]
while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)
2011780: 10 80 00 0d b 20117b4 <fat_file_size+0x80>
2011784: 82 10 20 00 clr %g1
{
save_cln = cur_cln;
rc = fat_get_fat_cluster(fs_info, cur_cln, &cur_cln);
2011788: 92 10 00 1c mov %i4, %o1
201178c: 40 00 1a 1a call 2017ff4 <fat_get_fat_cluster>
2011790: 94 07 bf fc add %fp, -4, %o2
if ( rc != RC_OK )
2011794: b0 92 20 00 orcc %o0, 0, %i0
2011798: 12 80 00 10 bne 20117d8 <fat_file_size+0xa4> <== NEVER TAKEN
201179c: 01 00 00 00 nop
return rc;
fat_fd->fat_file_size += fs_info->vol.bpc;
20117a0: c2 17 60 06 lduh [ %i5 + 6 ], %g1
20117a4: c4 06 60 18 ld [ %i1 + 0x18 ], %g2
20117a8: 82 00 80 01 add %g2, %g1, %g1
20117ac: 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;
20117b0: 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)
20117b4: f8 07 bf fc ld [ %fp + -4 ], %i4
20117b8: c6 07 60 0c ld [ %i5 + 0xc ], %g3
20117bc: c4 07 60 10 ld [ %i5 + 0x10 ], %g2
20117c0: 86 0f 00 03 and %i4, %g3, %g3
20117c4: 80 a0 c0 02 cmp %g3, %g2
20117c8: 0a bf ff f0 bcs 2011788 <fat_file_size+0x54>
20117cc: 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;
20117d0: c2 26 60 3c st %g1, [ %i1 + 0x3c ]
20117d4: b0 10 20 00 clr %i0
return rc;
}
20117d8: 81 c7 e0 08 ret
20117dc: 81 e8 00 00 restore
02010fdc <fat_file_truncate>:
fat_file_truncate(
fat_fs_info_t *fs_info,
fat_file_fd_t *fat_fd,
uint32_t new_length
)
{
2010fdc: 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;
2010fe0: 82 10 3f ff mov -1, %g1
2010fe4: c2 27 bf fc st %g1, [ %fp + -4 ]
if ( new_length >= fat_fd->fat_file_size )
2010fe8: c2 06 60 18 ld [ %i1 + 0x18 ], %g1
2010fec: 80 a6 80 01 cmp %i2, %g1
2010ff0: 0a 80 00 04 bcs 2011000 <fat_file_truncate+0x24>
2010ff4: c0 27 bf f8 clr [ %fp + -8 ]
return rc;
2010ff8: 10 80 00 3b b 20110e4 <fat_file_truncate+0x108>
2010ffc: 92 10 20 00 clr %o1
assert(fat_fd->fat_file_size);
2011000: 80 a0 60 00 cmp %g1, 0
2011004: 32 80 00 0a bne,a 201102c <fat_file_truncate+0x50> <== ALWAYS TAKEN
2011008: c4 0e 20 08 ldub [ %i0 + 8 ], %g2
201100c: 11 00 80 98 sethi %hi(0x2026000), %o0 <== NOT EXECUTED
2011010: 15 00 80 98 sethi %hi(0x2026000), %o2 <== NOT EXECUTED
2011014: 17 00 80 98 sethi %hi(0x2026000), %o3 <== NOT EXECUTED
2011018: 90 12 22 28 or %o0, 0x228, %o0 <== NOT EXECUTED
201101c: 92 10 22 7d mov 0x27d, %o1 <== NOT EXECUTED
2011020: 94 12 a2 88 or %o2, 0x288, %o2 <== NOT EXECUTED
2011024: 40 00 07 ed call 2012fd8 <__assert_func> <== NOT EXECUTED
2011028: 96 12 e2 70 or %o3, 0x270, %o3 <== NOT EXECUTED
cl_start = (new_length + fs_info->vol.bpc - 1) >> fs_info->vol.bpc_log2;
201102c: c6 16 20 06 lduh [ %i0 + 6 ], %g3
2011030: 86 00 ff ff add %g3, -1, %g3
2011034: b4 00 c0 1a add %g3, %i2, %i2
2011038: b5 36 80 02 srl %i2, %g2, %i2
if ((cl_start << fs_info->vol.bpc_log2) >= fat_fd->fat_file_size)
201103c: 85 2e 80 02 sll %i2, %g2, %g2
2011040: 80 a0 80 01 cmp %g2, %g1
2011044: 1a bf ff ed bcc 2010ff8 <fat_file_truncate+0x1c>
2011048: 80 a6 a0 00 cmp %i2, 0
return RC_OK;
if (cl_start != 0)
201104c: 12 80 00 0b bne 2011078 <fat_file_truncate+0x9c>
2011050: 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);
2011054: 92 10 00 19 mov %i1, %o1
2011058: 94 10 00 1a mov %i2, %o2
201105c: 7f ff fe e9 call 2010c00 <fat_file_lseek>
2011060: 96 07 bf f8 add %fp, -8, %o3
if (rc != RC_OK)
2011064: 80 a2 60 00 cmp %o1, 0
2011068: 32 80 00 20 bne,a 20110e8 <fat_file_truncate+0x10c> <== NEVER TAKEN
201106c: b0 10 00 09 mov %o1, %i0 <== NOT EXECUTED
return rc;
rc = fat_free_fat_clusters_chain(fs_info, cur_cln);
2011070: 10 80 00 0b b 201109c <fat_file_truncate+0xc0>
2011074: 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);
2011078: 92 10 00 19 mov %i1, %o1
201107c: 94 06 bf ff add %i2, -1, %o2
2011080: 7f ff fe e0 call 2010c00 <fat_file_lseek>
2011084: 96 07 bf fc add %fp, -4, %o3
if (rc != RC_OK)
2011088: 80 a2 60 00 cmp %o1, 0
201108c: 02 bf ff f2 be 2011054 <fat_file_truncate+0x78> <== ALWAYS TAKEN
2011090: 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;
}
2011094: 81 c7 e0 08 ret <== NOT EXECUTED
2011098: 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);
201109c: 40 00 1c fc call 201848c <fat_free_fat_clusters_chain>
20110a0: 90 10 00 18 mov %i0, %o0
if (rc != RC_OK)
20110a4: 92 92 20 00 orcc %o0, 0, %o1
20110a8: 12 80 00 0f bne 20110e4 <fat_file_truncate+0x108> <== NEVER TAKEN
20110ac: 80 a6 a0 00 cmp %i2, 0
return rc;
if (cl_start != 0)
20110b0: 02 80 00 0d be 20110e4 <fat_file_truncate+0x108>
20110b4: 92 10 20 00 clr %o1
{
rc = fat_set_fat_cluster(fs_info, new_last_cln, FAT_GENFAT_EOC);
20110b8: d2 07 bf fc ld [ %fp + -4 ], %o1
20110bc: 90 10 00 18 mov %i0, %o0
20110c0: 40 00 1c 44 call 20181d0 <fat_set_fat_cluster>
20110c4: 94 10 3f ff mov -1, %o2
if ( rc != RC_OK )
20110c8: 92 92 20 00 orcc %o0, 0, %o1
20110cc: 12 80 00 06 bne 20110e4 <fat_file_truncate+0x108> <== NEVER TAKEN
20110d0: c2 07 bf fc ld [ %fp + -4 ], %g1
return rc;
fat_fd->map.file_cln = cl_start - 1;
20110d4: b4 06 bf ff add %i2, -1, %i2
fat_fd->map.disk_cln = new_last_cln;
20110d8: 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;
20110dc: f4 26 60 34 st %i2, [ %i1 + 0x34 ]
fat_fd->map.disk_cln = new_last_cln;
fat_fd->map.last_cln = new_last_cln;
20110e0: c2 26 60 3c st %g1, [ %i1 + 0x3c ]
}
return RC_OK;
}
20110e4: b0 10 00 09 mov %o1, %i0
20110e8: 81 c7 e0 08 ret
20110ec: 81 e8 00 00 restore
020114e0 <fat_file_write>:
fat_file_fd_t *fat_fd,
uint32_t start,
uint32_t count,
const uint8_t *buf
)
{
20114e0: 9d e3 bf 98 save %sp, -104, %sp
int rc = 0;
ssize_t ret = 0;
uint32_t cmpltd = 0;
uint32_t cur_cln = 0;
20114e4: 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;
20114e8: c0 27 bf fc clr [ %fp + -4 ]
fat_file_fd_t *fat_fd,
uint32_t start,
uint32_t count,
const uint8_t *buf
)
{
20114ec: 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;
20114f0: c2 06 60 18 ld [ %i1 + 0x18 ], %g1
if ( count == 0 )
20114f4: 80 a6 e0 00 cmp %i3, 0
20114f8: 02 80 00 79 be 20116dc <fat_file_write+0x1fc> <== NEVER TAKEN
20114fc: 90 10 20 00 clr %o0
return cmpltd;
if (start >= fat_fd->size_limit)
2011500: f0 06 60 14 ld [ %i1 + 0x14 ], %i0
2011504: 80 a6 80 18 cmp %i2, %i0
2011508: 2a 80 00 07 bcs,a 2011524 <fat_file_write+0x44> <== ALWAYS TAKEN
201150c: b0 26 00 1a sub %i0, %i2, %i0
rtems_set_errno_and_return_minus_one(EFBIG);
2011510: 40 00 22 c4 call 201a020 <__errno> <== NOT EXECUTED
2011514: 01 00 00 00 nop <== NOT EXECUTED
2011518: 82 10 20 1b mov 0x1b, %g1 ! 1b <PROM_START+0x1b> <== NOT EXECUTED
201151c: 10 80 00 6f b 20116d8 <fat_file_write+0x1f8> <== NOT EXECUTED
2011520: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
2011524: 80 a6 00 1b cmp %i0, %i3
2011528: 38 80 00 02 bgu,a 2011530 <fat_file_write+0x50> <== ALWAYS TAKEN
201152c: 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;
2011530: 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);
2011534: b6 06 00 1a add %i0, %i2, %i3
2011538: 94 40 20 00 addx %g0, 0, %o2
201153c: 90 10 00 1d mov %i5, %o0
2011540: 92 10 00 19 mov %i1, %o1
2011544: 96 10 00 1b mov %i3, %o3
2011548: 7f ff ff 4b call 2011274 <fat_file_extend>
201154c: 98 07 bf fc add %fp, -4, %o4
if (rc != RC_OK)
2011550: 80 a2 20 00 cmp %o0, 0
2011554: 12 80 00 62 bne 20116dc <fat_file_write+0x1fc> <== NEVER TAKEN
2011558: 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))
201155c: 80 a0 40 1b cmp %g1, %i3
2011560: 32 80 00 02 bne,a 2011568 <fat_file_write+0x88> <== NEVER TAKEN
2011564: b0 20 40 1a sub %g1, %i2, %i0 <== NOT EXECUTED
count = c - start;
if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&
2011568: c2 06 60 20 ld [ %i1 + 0x20 ], %g1
201156c: 80 a0 60 01 cmp %g1, 1
2011570: 32 80 00 1c bne,a 20115e0 <fat_file_write+0x100>
2011574: e4 0f 60 08 ldub [ %i5 + 8 ], %l2
2011578: c2 06 60 24 ld [ %i1 + 0x24 ], %g1
201157c: 80 a0 60 00 cmp %g1, 0
2011580: 32 80 00 18 bne,a 20115e0 <fat_file_write+0x100> <== NEVER TAKEN
2011584: e4 0f 60 08 ldub [ %i5 + 8 ], %l2 <== NOT EXECUTED
(fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))
2011588: 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)) &&
201158c: 80 88 60 03 btst 3, %g1
2011590: 22 80 00 14 be,a 20115e0 <fat_file_write+0x100> <== NEVER TAKEN
2011594: 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);
2011598: d2 06 60 1c ld [ %i1 + 0x1c ], %o1
201159c: 7f ff fd 7a call 2010b84 <fat_cluster_num_to_sector_num>
20115a0: 90 10 00 1d mov %i5, %o0
sec += (start >> fs_info->vol.sec_log2);
20115a4: d2 0f 60 02 ldub [ %i5 + 2 ], %o1
byte = start & (fs_info->vol.bps - 1);
20115a8: 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);
20115ac: 93 36 80 09 srl %i2, %o1, %o1
byte = start & (fs_info->vol.bps - 1);
20115b0: 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);
20115b4: 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);
20115b8: 94 0e 80 0a and %i2, %o2, %o2
20115bc: 90 10 00 1d mov %i5, %o0
20115c0: 96 10 00 18 mov %i0, %o3
20115c4: 40 00 01 8a call 2011bec <_fat_block_write>
20115c8: 98 10 00 1c mov %i4, %o4
if ( ret < 0 )
20115cc: 80 a2 20 00 cmp %o0, 0
20115d0: 16 80 00 43 bge 20116dc <fat_file_write+0x1fc> <== ALWAYS TAKEN
20115d4: 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;
20115d8: 10 80 00 41 b 20116dc <fat_file_write+0x1fc> <== NOT EXECUTED
20115dc: 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);
20115e0: f6 17 60 06 lduh [ %i5 + 6 ], %i3
return -1;
return ret;
}
cl_start = start >> fs_info->vol.bpc_log2;
20115e4: 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);
20115e8: a6 07 bf f8 add %fp, -8, %l3
20115ec: 90 10 00 1d mov %i5, %o0
20115f0: 92 10 00 19 mov %i1, %o1
20115f4: 94 10 00 12 mov %l2, %o2
20115f8: 7f ff fd 82 call 2010c00 <fat_file_lseek>
20115fc: 96 10 00 13 mov %l3, %o3
if (rc != RC_OK)
2011600: 90 92 60 00 orcc %o1, 0, %o0
2011604: 12 80 00 36 bne 20116dc <fat_file_write+0x1fc> <== NEVER TAKEN
2011608: 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);
201160c: b7 36 e0 10 srl %i3, 0x10, %i3
2011610: b6 06 ff ff add %i3, -1, %i3
2011614: a0 10 20 00 clr %l0
2011618: b4 0e 80 1b and %i2, %i3, %i2
201161c: b6 10 20 00 clr %i3
2011620: 10 80 00 22 b 20116a8 <fat_file_write+0x1c8>
2011624: a2 10 00 1a mov %i2, %l1
if (rc != RC_OK)
return rc;
while (count > 0)
{
c = MIN(count, (fs_info->vol.bpc - ofs));
2011628: a0 24 00 11 sub %l0, %l1, %l0
201162c: 80 a4 00 18 cmp %l0, %i0
2011630: 38 80 00 02 bgu,a 2011638 <fat_file_write+0x158>
2011634: a0 10 00 18 mov %i0, %l0
sec = fat_cluster_num_to_sector_num(fs_info, cur_cln);
2011638: 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));
201163c: e0 27 bf fc st %l0, [ %fp + -4 ]
sec = fat_cluster_num_to_sector_num(fs_info, cur_cln);
2011640: 7f ff fd 51 call 2010b84 <fat_cluster_num_to_sector_num>
2011644: 90 10 00 1d mov %i5, %o0
sec += (ofs >> fs_info->vol.sec_log2);
2011648: d2 0f 60 02 ldub [ %i5 + 2 ], %o1
byte = ofs & (fs_info->vol.bps - 1);
201164c: 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);
2011650: 93 34 40 09 srl %l1, %o1, %o1
byte = ofs & (fs_info->vol.bps - 1);
2011654: 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);
2011658: 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);
201165c: 94 0c 40 0a and %l1, %o2, %o2
2011660: 90 10 00 1d mov %i5, %o0
2011664: 96 10 00 10 mov %l0, %o3
2011668: 40 00 01 61 call 2011bec <_fat_block_write>
201166c: 98 07 00 1b add %i4, %i3, %o4
if ( ret < 0 )
2011670: 80 a2 20 00 cmp %o0, 0
2011674: 06 80 00 19 bl 20116d8 <fat_file_write+0x1f8> <== NEVER TAKEN
2011678: c2 07 bf fc ld [ %fp + -4 ], %g1
return -1;
count -= c;
cmpltd += c;
save_cln = cur_cln;
201167c: 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;
2011680: b0 26 00 01 sub %i0, %g1, %i0
cmpltd += c;
2011684: b6 06 c0 01 add %i3, %g1, %i3
save_cln = cur_cln;
rc = fat_get_fat_cluster(fs_info, cur_cln, &cur_cln);
2011688: 90 10 00 1d mov %i5, %o0
201168c: 92 10 00 10 mov %l0, %o1
2011690: 94 10 00 13 mov %l3, %o2
2011694: 40 00 1a 58 call 2017ff4 <fat_get_fat_cluster>
2011698: a2 10 20 00 clr %l1
if ( rc != RC_OK )
201169c: 80 a2 20 00 cmp %o0, 0
20116a0: 12 80 00 0f bne 20116dc <fat_file_write+0x1fc> <== NEVER TAKEN
20116a4: 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)
20116a8: 80 a6 20 00 cmp %i0, 0
20116ac: 32 bf ff df bne,a 2011628 <fat_file_write+0x148>
20116b0: 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);
20116b4: c2 0f 60 08 ldub [ %i5 + 8 ], %g1
20116b8: b4 06 bf ff add %i2, -1, %i2
fat_fd->map.disk_cln = save_cln;
20116bc: 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);
20116c0: b4 06 80 1b add %i2, %i3, %i2
fat_fd->map.disk_cln = save_cln;
return cmpltd;
20116c4: 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);
20116c8: 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 +
20116cc: a4 06 80 12 add %i2, %l2, %l2
20116d0: 10 80 00 03 b 20116dc <fat_file_write+0x1fc>
20116d4: 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;
20116d8: 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;
}
20116dc: 81 c7 e0 08 ret
20116e0: 91 e8 00 08 restore %g0, %o0, %o0
0201848c <fat_free_fat_clusters_chain>:
int
fat_free_fat_clusters_chain(
fat_fs_info_t *fs_info,
uint32_t chain
)
{
201848c: 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;
2018490: b8 10 20 00 clr %i4
int
fat_free_fat_clusters_chain(
fat_fs_info_t *fs_info,
uint32_t chain
)
{
2018494: ba 10 00 18 mov %i0, %i5
int rc = RC_OK, rc1 = RC_OK;
uint32_t cur_cln = chain;
uint32_t next_cln = 0;
2018498: 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;
201849c: 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)
20184a0: 10 80 00 19 b 2018504 <fat_free_fat_clusters_chain+0x78>
20184a4: b4 10 20 00 clr %i2
{
rc = fat_get_fat_cluster(fs_info, cur_cln, &next_cln);
20184a8: 92 10 00 1b mov %i3, %o1
20184ac: 7f ff fe d2 call 2017ff4 <fat_get_fat_cluster>
20184b0: 94 07 bf fc add %fp, -4, %o2
if ( rc != RC_OK )
20184b4: b0 92 20 00 orcc %o0, 0, %i0
20184b8: 02 80 00 0b be 20184e4 <fat_free_fat_clusters_chain+0x58> <== ALWAYS TAKEN
20184bc: 90 10 00 1d mov %i5, %o0
{
if(fs_info->vol.free_cls != FAT_UNDEFINED_VALUE)
20184c0: c2 07 60 40 ld [ %i5 + 0x40 ], %g1 <== NOT EXECUTED
20184c4: 80 a0 7f ff cmp %g1, -1 <== NOT EXECUTED
20184c8: 02 80 00 03 be 20184d4 <fat_free_fat_clusters_chain+0x48> <== NOT EXECUTED
20184cc: b8 07 00 01 add %i4, %g1, %i4 <== NOT EXECUTED
fs_info->vol.free_cls += freed_cls_cnt;
20184d0: f8 27 60 40 st %i4, [ %i5 + 0x40 ] <== NOT EXECUTED
fat_buf_release(fs_info);
20184d4: 7f ff e5 4c call 2011a04 <fat_buf_release> <== NOT EXECUTED
20184d8: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
20184dc: 81 c7 e0 08 ret <== NOT EXECUTED
20184e0: 81 e8 00 00 restore <== NOT EXECUTED
return rc;
}
rc = fat_set_fat_cluster(fs_info, cur_cln, FAT_GENFAT_FREE);
20184e4: 92 10 00 1b mov %i3, %o1
20184e8: 7f ff ff 3a call 20181d0 <fat_set_fat_cluster>
20184ec: 94 10 20 00 clr %o2
if ( rc != RC_OK )
20184f0: 80 a2 20 00 cmp %o0, 0
20184f4: 32 80 00 02 bne,a 20184fc <fat_free_fat_clusters_chain+0x70><== NEVER TAKEN
20184f8: b4 10 00 08 mov %o0, %i2 <== NOT EXECUTED
rc1 = rc;
freed_cls_cnt++;
cur_cln = next_cln;
20184fc: 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++;
2018500: 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)
2018504: c4 07 60 0c ld [ %i5 + 0xc ], %g2
2018508: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
201850c: 84 0e c0 02 and %i3, %g2, %g2
2018510: 80 a0 80 01 cmp %g2, %g1
2018514: 0a bf ff e5 bcs 20184a8 <fat_free_fat_clusters_chain+0x1c>
2018518: 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)
201851c: c2 07 60 40 ld [ %i5 + 0x40 ], %g1
2018520: 80 a0 7f ff cmp %g1, -1
2018524: 02 80 00 05 be 2018538 <fat_free_fat_clusters_chain+0xac> <== ALWAYS TAKEN
2018528: f2 27 60 44 st %i1, [ %i5 + 0x44 ]
fs_info->vol.free_cls += freed_cls_cnt;
201852c: b8 07 00 01 add %i4, %g1, %i4 <== NOT EXECUTED
2018530: f8 27 60 40 st %i4, [ %i5 + 0x40 ] <== NOT EXECUTED
fat_buf_release(fs_info);
2018534: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
2018538: 7f ff e5 33 call 2011a04 <fat_buf_release>
201853c: b0 10 00 1a mov %i2, %i0
if (rc1 != RC_OK)
return rc1;
return RC_OK;
}
2018540: 81 c7 e0 08 ret
2018544: 81 e8 00 00 restore
02011f38 <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);
2011f38: c2 02 20 74 ld [ %o0 + 0x74 ], %g1 <== NOT EXECUTED
2011f3c: c4 02 20 68 ld [ %o0 + 0x68 ], %g2 <== NOT EXECUTED
2011f40: 86 10 20 01 mov 1, %g3 <== NOT EXECUTED
2011f44: 92 22 40 01 sub %o1, %g1, %o1 <== NOT EXECUTED
2011f48: 83 32 60 03 srl %o1, 3, %g1 <== NOT EXECUTED
2011f4c: 92 0a 60 07 and %o1, 7, %o1 <== NOT EXECUTED
2011f50: 93 28 c0 09 sll %g3, %o1, %o1 <== NOT EXECUTED
2011f54: c6 08 80 01 ldub [ %g2 + %g1 ], %g3 <== NOT EXECUTED
2011f58: 92 28 c0 09 andn %g3, %o1, %o1 <== NOT EXECUTED
2011f5c: 81 c3 e0 08 retl <== NOT EXECUTED
2011f60: d2 28 80 01 stb %o1, [ %g2 + %g1 ] <== NOT EXECUTED
02017ff4 <fat_get_fat_cluster>:
fat_get_fat_cluster(
fat_fs_info_t *fs_info,
uint32_t cln,
uint32_t *ret_val
)
{
2017ff4: 9d e3 bf 98 save %sp, -104, %sp
int rc = RC_OK;
rtems_bdbuf_buffer *block0 = NULL;
2017ff8: 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)) )
2017ffc: 80 a6 60 01 cmp %i1, 1
2018000: 08 80 00 6b bleu 20181ac <fat_get_fat_cluster+0x1b8> <== NEVER TAKEN
2018004: ba 10 00 18 mov %i0, %i5
2018008: c2 06 20 34 ld [ %i0 + 0x34 ], %g1
201800c: 82 00 60 01 inc %g1
2018010: 80 a6 40 01 cmp %i1, %g1
2018014: 28 80 00 03 bleu,a 2018020 <fat_get_fat_cluster+0x2c> <== ALWAYS TAKEN
2018018: c2 0e 20 0a ldub [ %i0 + 0xa ], %g1
201801c: 30 80 00 64 b,a 20181ac <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) +
2018020: 86 08 60 01 and %g1, 1, %g3
2018024: 80 88 e0 ff btst 0xff, %g3
2018028: 02 80 00 05 be 201803c <fat_get_fat_cluster+0x48> <== NEVER TAKEN
201802c: 88 08 60 02 and %g1, 2, %g4
2018030: 85 36 60 01 srl %i1, 1, %g2
2018034: 10 80 00 06 b 201804c <fat_get_fat_cluster+0x58>
2018038: 84 00 80 19 add %g2, %i1, %g2
201803c: 80 89 20 ff btst 0xff, %g4 <== NOT EXECUTED
2018040: 02 80 00 03 be 201804c <fat_get_fat_cluster+0x58> <== NOT EXECUTED
2018044: 85 2e 60 02 sll %i1, 2, %g2 <== NOT EXECUTED
2018048: 85 2e 60 01 sll %i1, 1, %g2 <== NOT EXECUTED
201804c: f6 0f 60 02 ldub [ %i5 + 2 ], %i3
2018050: c8 07 60 4c ld [ %i5 + 0x4c ], %g4
2018054: 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);
2018058: 80 88 e0 ff btst 0xff, %g3
201805c: 02 80 00 05 be 2018070 <fat_get_fat_cluster+0x7c> <== NEVER TAKEN
2018060: b6 00 80 04 add %g2, %g4, %i3
2018064: b9 36 60 01 srl %i1, 1, %i4
2018068: 10 80 00 07 b 2018084 <fat_get_fat_cluster+0x90>
201806c: b8 07 00 19 add %i4, %i1, %i4
2018070: 82 08 60 02 and %g1, 2, %g1 <== NOT EXECUTED
2018074: 80 88 60 ff btst 0xff, %g1 <== NOT EXECUTED
2018078: 02 80 00 03 be 2018084 <fat_get_fat_cluster+0x90> <== NOT EXECUTED
201807c: b9 2e 60 02 sll %i1, 2, %i4 <== NOT EXECUTED
2018080: b9 2e 60 01 sll %i1, 1, %i4 <== NOT EXECUTED
2018084: e0 17 40 00 lduh [ %i5 ], %l0
rc = fat_buf_access(fs_info, sec, FAT_OP_TYPE_READ, &block0);
2018088: 90 10 00 1d mov %i5, %o0
201808c: 92 10 00 1b mov %i3, %o1
2018090: 94 10 20 01 mov 1, %o2
2018094: 7f ff e5 df call 2011810 <fat_buf_access>
2018098: 96 07 bf fc add %fp, -4, %o3
if (rc != RC_OK)
201809c: b0 92 20 00 orcc %o0, 0, %i0
20180a0: 12 80 00 3a bne 2018188 <fat_get_fat_cluster+0x194> <== NEVER TAKEN
20180a4: 83 2c 20 10 sll %l0, 0x10, %g1
return rc;
switch ( fs_info->vol.type )
20180a8: c4 0f 60 0a ldub [ %i5 + 0xa ], %g2
20180ac: 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);
20180b0: 83 30 60 10 srl %g1, 0x10, %g1
20180b4: 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 )
20180b8: 02 80 00 29 be 201815c <fat_get_fat_cluster+0x168> <== NEVER TAKEN
20180bc: 82 0f 00 01 and %i4, %g1, %g1
20180c0: 80 a0 a0 04 cmp %g2, 4
20180c4: 02 80 00 33 be 2018190 <fat_get_fat_cluster+0x19c> <== NEVER TAKEN
20180c8: 80 a0 a0 01 cmp %g2, 1
20180cc: 12 80 00 38 bne 20181ac <fat_get_fat_cluster+0x1b8> <== NEVER TAKEN
20180d0: 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) )
20180d4: 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)));
20180d8: c6 00 a0 1c ld [ %g2 + 0x1c ], %g3
if ( ofs == (fs_info->vol.bps - 1) )
20180dc: 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)));
20180e0: c4 08 c0 01 ldub [ %g3 + %g1 ], %g2
if ( ofs == (fs_info->vol.bps - 1) )
20180e4: 80 a0 40 04 cmp %g1, %g4
20180e8: 12 80 00 11 bne 201812c <fat_get_fat_cluster+0x138> <== ALWAYS TAKEN
20180ec: c4 26 80 00 st %g2, [ %i2 ]
{
rc = fat_buf_access(fs_info, sec + 1, FAT_OP_TYPE_READ,
20180f0: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
20180f4: 92 06 e0 01 add %i3, 1, %o1 <== NOT EXECUTED
20180f8: 94 10 20 01 mov 1, %o2 <== NOT EXECUTED
20180fc: 7f ff e5 c5 call 2011810 <fat_buf_access> <== NOT EXECUTED
2018100: 96 07 bf fc add %fp, -4, %o3 <== NOT EXECUTED
&block0);
if (rc != RC_OK)
2018104: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2018108: 12 80 00 2f bne 20181c4 <fat_get_fat_cluster+0x1d0> <== NOT EXECUTED
201810c: c2 07 bf fc ld [ %fp + -4 ], %g1 <== NOT EXECUTED
return rc;
*ret_val |= (*((uint8_t *)(block0->buffer)))<<8;
2018110: c4 06 80 00 ld [ %i2 ], %g2 <== NOT EXECUTED
2018114: c2 00 60 1c ld [ %g1 + 0x1c ], %g1 <== NOT EXECUTED
2018118: c2 08 40 00 ldub [ %g1 ], %g1 <== NOT EXECUTED
201811c: 83 28 60 08 sll %g1, 8, %g1 <== NOT EXECUTED
2018120: 82 10 80 01 or %g2, %g1, %g1 <== NOT EXECUTED
2018124: 10 80 00 07 b 2018140 <fat_get_fat_cluster+0x14c> <== NOT EXECUTED
2018128: c2 26 80 00 st %g1, [ %i2 ] <== NOT EXECUTED
}
else
{
*ret_val |= (*((uint8_t *)(block0->buffer + ofs + 1)))<<8;
201812c: 82 00 c0 01 add %g3, %g1, %g1
2018130: c2 08 60 01 ldub [ %g1 + 1 ], %g1
2018134: 83 28 60 08 sll %g1, 8, %g1
2018138: 84 10 40 02 or %g1, %g2, %g2
201813c: c4 26 80 00 st %g2, [ %i2 ]
}
if ( FAT_CLUSTER_IS_ODD(cln) )
2018140: 80 8e 60 01 btst 1, %i1
2018144: 02 80 00 04 be 2018154 <fat_get_fat_cluster+0x160>
2018148: c2 06 80 00 ld [ %i2 ], %g1
*ret_val = (*ret_val) >> FAT12_SHIFT;
201814c: 10 80 00 0e b 2018184 <fat_get_fat_cluster+0x190>
2018150: 83 30 60 04 srl %g1, 4, %g1
else
*ret_val = (*ret_val) & FAT_FAT12_MASK;
2018154: 10 80 00 0c b 2018184 <fat_get_fat_cluster+0x190>
2018158: 82 08 6f ff and %g1, 0xfff, %g1
break;
case FAT_FAT16:
*ret_val = *((uint16_t *)(block0->buffer + ofs));
201815c: c4 07 bf fc ld [ %fp + -4 ], %g2 <== NOT EXECUTED
*ret_val = CF_LE_W(*ret_val);
2018160: 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));
2018164: c4 00 a0 1c ld [ %g2 + 0x1c ], %g2 <== NOT EXECUTED
*ret_val = CF_LE_W(*ret_val);
2018168: 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));
201816c: c2 10 80 01 lduh [ %g2 + %g1 ], %g1 <== NOT EXECUTED
*ret_val = CF_LE_W(*ret_val);
2018170: 83 28 60 10 sll %g1, 0x10, %g1 <== NOT EXECUTED
2018174: 85 30 60 18 srl %g1, 0x18, %g2 <== NOT EXECUTED
2018178: 83 30 60 08 srl %g1, 8, %g1 <== NOT EXECUTED
201817c: 82 08 40 03 and %g1, %g3, %g1 <== NOT EXECUTED
2018180: 82 10 80 01 or %g2, %g1, %g1 <== NOT EXECUTED
2018184: c2 26 80 00 st %g1, [ %i2 ]
break;
2018188: 81 c7 e0 08 ret
201818c: 81 e8 00 00 restore
case FAT_FAT32:
*ret_val = *((uint32_t *)(block0->buffer + ofs));
2018190: c4 07 bf fc ld [ %fp + -4 ], %g2 <== NOT EXECUTED
2018194: c4 00 a0 1c ld [ %g2 + 0x1c ], %g2 <== NOT EXECUTED
*ret_val = CF_LE_L(*ret_val);
2018198: 7f ff ff 8b call 2017fc4 <CPU_swap_u32> <== NOT EXECUTED
201819c: d0 00 80 01 ld [ %g2 + %g1 ], %o0 <== NOT EXECUTED
20181a0: d0 26 80 00 st %o0, [ %i2 ] <== NOT EXECUTED
break;
20181a4: 81 c7 e0 08 ret <== NOT EXECUTED
20181a8: 81 e8 00 00 restore <== NOT EXECUTED
default:
rtems_set_errno_and_return_minus_one(EIO);
20181ac: 40 00 07 9d call 201a020 <__errno> <== NOT EXECUTED
20181b0: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
20181b4: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
20181b8: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
20181bc: 81 c7 e0 08 ret <== NOT EXECUTED
20181c0: 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)
20181c4: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
break;
}
return RC_OK;
}
20181c8: 81 c7 e0 08 ret <== NOT EXECUTED
20181cc: 81 e8 00 00 restore <== NOT EXECUTED
02011e78 <fat_get_unique_ino>:
* 0 means FAILED !!!
*
*/
uint32_t
fat_get_unique_ino(fat_fs_info_t *fs_info)
{
2011e78: 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))
2011e7c: 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)
2011e80: 10 80 00 2b b 2011f2c <fat_get_unique_ino+0xb4> <== NOT EXECUTED
2011e84: 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))
2011e88: c2 06 20 6c ld [ %i0 + 0x6c ], %g1 <== NOT EXECUTED
2011e8c: 85 30 60 03 srl %g1, 3, %g2 <== NOT EXECUTED
2011e90: b6 00 c0 02 add %g3, %g2, %i3 <== NOT EXECUTED
2011e94: f4 08 c0 02 ldub [ %g3 + %g2 ], %i2 <== NOT EXECUTED
2011e98: c4 48 c0 02 ldsb [ %g3 + %g2 ], %g2 <== NOT EXECUTED
2011e9c: ba 08 60 07 and %g1, 7, %i5 <== NOT EXECUTED
2011ea0: 85 38 80 1d sra %g2, %i5, %g2 <== NOT EXECUTED
2011ea4: 80 88 a0 01 btst 1, %g2 <== NOT EXECUTED
2011ea8: 12 80 00 0a bne 2011ed0 <fat_get_unique_ino+0x58> <== NOT EXECUTED
2011eac: 82 00 60 01 inc %g1 <== NOT EXECUTED
{
FAT_SET_UNIQ_INO_BUSY(fs_info->index, fs_info->uino);
2011eb0: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED
2011eb4: bb 28 40 1d sll %g1, %i5, %i5 <== NOT EXECUTED
2011eb8: ba 17 40 1a or %i5, %i2, %i5 <== NOT EXECUTED
2011ebc: fa 2e c0 00 stb %i5, [ %i3 ] <== NOT EXECUTED
return (fs_info->uino_base + fs_info->index);
2011ec0: c4 06 20 6c ld [ %i0 + 0x6c ], %g2 <== NOT EXECUTED
2011ec4: c2 06 20 74 ld [ %i0 + 0x74 ], %g1 <== NOT EXECUTED
2011ec8: 81 c7 e0 08 ret <== NOT EXECUTED
2011ecc: 91 e8 80 01 restore %g2, %g1, %o0 <== NOT EXECUTED
}
fs_info->index++;
if (fs_info->index >= fs_info->uino_pool_size)
2011ed0: 80 a0 40 04 cmp %g1, %g4 <== NOT EXECUTED
2011ed4: 3a 80 00 03 bcc,a 2011ee0 <fat_get_unique_ino+0x68> <== NOT EXECUTED
2011ed8: c0 26 20 6c clr [ %i0 + 0x6c ] <== NOT EXECUTED
2011edc: 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++)
2011ee0: 92 02 60 01 inc %o1 <== NOT EXECUTED
2011ee4: 80 a2 40 04 cmp %o1, %g4 <== NOT EXECUTED
2011ee8: 32 bf ff e8 bne,a 2011e88 <fat_get_unique_ino+0x10> <== NOT EXECUTED
2011eec: 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))
2011ef0: c2 06 20 74 ld [ %i0 + 0x74 ], %g1 <== NOT EXECUTED
2011ef4: 93 2a 60 01 sll %o1, 1, %o1 <== NOT EXECUTED
2011ef8: 82 27 00 01 sub %i4, %g1, %g1 <== NOT EXECUTED
2011efc: 80 a2 40 01 cmp %o1, %g1 <== NOT EXECUTED
2011f00: 2a 80 00 04 bcs,a 2011f10 <fat_get_unique_ino+0x98> <== NOT EXECUTED
2011f04: d0 06 20 68 ld [ %i0 + 0x68 ], %o0 <== NOT EXECUTED
resrc_unsuff = true;
}
else
resrc_unsuff = true;
}
return 0;
2011f08: 81 c7 e0 08 ret <== NOT EXECUTED
2011f0c: 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);
2011f10: 7f ff ce 2a call 20057b8 <realloc> <== NOT EXECUTED
2011f14: d2 26 20 70 st %o1, [ %i0 + 0x70 ] <== NOT EXECUTED
if (fs_info->uino != NULL)
2011f18: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2011f1c: 02 bf ff fb be 2011f08 <fat_get_unique_ino+0x90> <== NOT EXECUTED
2011f20: d0 26 20 68 st %o0, [ %i0 + 0x68 ] <== NOT EXECUTED
fs_info->index = fs_info->uino_pool_size;
2011f24: c2 06 20 70 ld [ %i0 + 0x70 ], %g1 <== NOT EXECUTED
2011f28: 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++)
2011f2c: c8 06 20 70 ld [ %i0 + 0x70 ], %g4 <== NOT EXECUTED
2011f30: 10 bf ff ed b 2011ee4 <fat_get_unique_ino+0x6c> <== NOT EXECUTED
2011f34: 92 10 20 00 clr %o1 <== NOT EXECUTED
02011dc4 <fat_init_clusters_chain>:
int
fat_init_clusters_chain(
fat_fs_info_t *fs_info,
uint32_t start_cln
)
{
2011dc4: 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));
2011dc8: 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;
2011dcc: f2 27 bf fc st %i1, [ %fp + -4 ]
char *buf;
buf = calloc(fs_info->vol.bpc, sizeof(char));
2011dd0: 92 10 20 01 mov 1, %o1
2011dd4: 7f ff c9 35 call 20042a8 <calloc>
2011dd8: ba 10 00 18 mov %i0, %i5
if ( buf == NULL )
2011ddc: b8 92 20 00 orcc %o0, 0, %i4
2011de0: 12 80 00 1b bne 2011e4c <fat_init_clusters_chain+0x88> <== ALWAYS TAKEN
2011de4: d2 07 bf fc ld [ %fp + -4 ], %o1
rtems_set_errno_and_return_minus_one( EIO );
2011de8: 40 00 20 8e call 201a020 <__errno> <== NOT EXECUTED
2011dec: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
2011df0: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
2011df4: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
2011df8: 81 c7 e0 08 ret <== NOT EXECUTED
2011dfc: 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);
2011e00: 7f ff ff dc call 2011d70 <fat_cluster_write>
2011e04: 94 10 00 1c mov %i4, %o2
if ( ret == -1 )
2011e08: 80 a2 3f ff cmp %o0, -1
2011e0c: 12 80 00 06 bne 2011e24 <fat_init_clusters_chain+0x60> <== ALWAYS TAKEN
2011e10: d2 07 bf fc ld [ %fp + -4 ], %o1
{
free(buf);
2011e14: 7f ff c9 fa call 20045fc <free> <== NOT EXECUTED
2011e18: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
return -1;
2011e1c: 81 c7 e0 08 ret <== NOT EXECUTED
2011e20: 91 e8 3f ff restore %g0, -1, %o0 <== NOT EXECUTED
}
rc = fat_get_fat_cluster(fs_info, cur_cln, &cur_cln);
2011e24: 90 10 00 1d mov %i5, %o0
2011e28: 40 00 18 73 call 2017ff4 <fat_get_fat_cluster>
2011e2c: 94 07 bf fc add %fp, -4, %o2
if ( rc != RC_OK )
2011e30: b0 92 20 00 orcc %o0, 0, %i0
2011e34: 02 80 00 06 be 2011e4c <fat_init_clusters_chain+0x88> <== ALWAYS TAKEN
2011e38: d2 07 bf fc ld [ %fp + -4 ], %o1
{
free(buf);
2011e3c: 7f ff c9 f0 call 20045fc <free> <== NOT EXECUTED
2011e40: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
2011e44: 81 c7 e0 08 ret <== NOT EXECUTED
2011e48: 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)
2011e4c: c4 07 60 0c ld [ %i5 + 0xc ], %g2
2011e50: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
2011e54: 84 0a 40 02 and %o1, %g2, %g2
2011e58: 80 a0 80 01 cmp %g2, %g1
2011e5c: 0a bf ff e9 bcs 2011e00 <fat_init_clusters_chain+0x3c>
2011e60: 90 10 00 1d mov %i5, %o0
free(buf);
return rc;
}
}
free(buf);
2011e64: 90 10 00 1c mov %i4, %o0
2011e68: 7f ff c9 e5 call 20045fc <free>
2011e6c: b0 10 20 00 clr %i0
return rc;
}
2011e70: 81 c7 e0 08 ret
2011e74: 81 e8 00 00 restore
020120fc <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)
{
20120fc: 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);
2012100: 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)
{
2012104: 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;
2012108: c0 27 bf a4 clr [ %fp + -92 ]
vol->fd = open(device, O_RDWR);
201210c: 7f ff cd 10 call 200554c <open>
2012110: 90 10 00 19 mov %i1, %o0
if (vol->fd < 0)
2012114: 80 a2 20 00 cmp %o0, 0
2012118: 06 80 00 09 bl 201213c <fat_init_volume_info+0x40> <== NEVER TAKEN
201211c: d0 24 20 54 st %o0, [ %l0 + 0x54 ]
{
rtems_set_errno_and_return_minus_one(ENXIO);
}
rc = fstat(vol->fd, &stat_buf);
2012120: 40 00 04 3f call 201321c <fstat>
2012124: 92 07 bf b8 add %fp, -72, %o1
if (rc != 0)
2012128: 80 a2 20 00 cmp %o0, 0
201212c: 02 80 00 08 be 201214c <fat_init_volume_info+0x50> <== ALWAYS TAKEN
2012130: d0 06 20 54 ld [ %i0 + 0x54 ], %o0
{
close(vol->fd);
2012134: 7f ff c8 74 call 2004304 <close> <== NOT EXECUTED
2012138: 01 00 00 00 nop <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(ENXIO);
201213c: 40 00 1f b9 call 201a020 <__errno> <== NOT EXECUTED
2012140: 01 00 00 00 nop <== NOT EXECUTED
2012144: 10 80 01 c3 b 2012850 <fat_init_volume_info+0x754> <== NOT EXECUTED
2012148: 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))
201214c: c6 07 bf c4 ld [ %fp + -60 ], %g3
2012150: 05 00 00 3c sethi %hi(0xf000), %g2
2012154: 86 08 c0 02 and %g3, %g2, %g3
2012158: 05 00 00 18 sethi %hi(0x6000), %g2
201215c: 80 a0 c0 02 cmp %g3, %g2
2012160: 12 bf ff f5 bne 2012134 <fat_init_volume_info+0x38> <== NEVER TAKEN
2012164: 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);
2012168: 94 06 20 58 add %i0, 0x58, %o2
201216c: 7f ff c9 95 call 20047c0 <ioctl>
2012170: 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) {
2012174: ba 92 20 00 orcc %o0, 0, %i5
2012178: 22 80 00 04 be,a 2012188 <fat_init_volume_info+0x8c> <== ALWAYS TAKEN
201217c: d0 06 20 58 ld [ %i0 + 0x58 ], %o0
close(vol->fd);
2012180: 10 bf ff ed b 2012134 <fat_init_volume_info+0x38> <== NOT EXECUTED
2012184: 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);
2012188: 92 10 20 00 clr %o1
201218c: 7f ff f7 79 call 200ff70 <rtems_bdbuf_read>
2012190: 94 07 bf a4 add %fp, -92, %o2
if (sc != RTEMS_SUCCESSFUL)
2012194: 80 a2 20 00 cmp %o0, 0
2012198: 22 80 00 03 be,a 20121a4 <fat_init_volume_info+0xa8> <== ALWAYS TAKEN
201219c: d0 07 bf a4 ld [ %fp + -92 ], %o0
20121a0: 30 80 00 32 b,a 2012268 <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);
20121a4: de 02 20 1c ld [ %o0 + 0x1c ], %o7
20121a8: c2 0b e0 20 ldub [ %o7 + 0x20 ], %g1
20121ac: c4 0b e0 0b ldub [ %o7 + 0xb ], %g2
20121b0: c2 2f bf 99 stb %g1, [ %fp + -103 ]
20121b4: c2 0b e0 21 ldub [ %o7 + 0x21 ], %g1
20121b8: d6 0b e0 0c ldub [ %o7 + 0xc ], %o3
20121bc: c2 2f bf 9a stb %g1, [ %fp + -102 ]
20121c0: c2 0b e0 23 ldub [ %o7 + 0x23 ], %g1
20121c4: da 0b e0 0e ldub [ %o7 + 0xe ], %o5
20121c8: c2 2f bf 8f stb %g1, [ %fp + -113 ]
20121cc: c2 0b e0 2c ldub [ %o7 + 0x2c ], %g1
20121d0: d8 0b e0 0f ldub [ %o7 + 0xf ], %o4
20121d4: c2 2f bf 9f stb %g1, [ %fp + -97 ]
20121d8: c2 0b e0 2d ldub [ %o7 + 0x2d ], %g1
20121dc: c6 0b e0 11 ldub [ %o7 + 0x11 ], %g3
20121e0: c2 2f bf 9e stb %g1, [ %fp + -98 ]
20121e4: c2 0b e0 2e ldub [ %o7 + 0x2e ], %g1
20121e8: c8 0b e0 12 ldub [ %o7 + 0x12 ], %g4
20121ec: c2 2f bf 9d stb %g1, [ %fp + -99 ]
20121f0: c2 0b e0 2f ldub [ %o7 + 0x2f ], %g1
20121f4: f8 0b e0 0d ldub [ %o7 + 0xd ], %i4
20121f8: f4 0b e0 10 ldub [ %o7 + 0x10 ], %i2
20121fc: e2 0b e0 13 ldub [ %o7 + 0x13 ], %l1
2012200: e4 0b e0 14 ldub [ %o7 + 0x14 ], %l2
2012204: ee 0b e0 16 ldub [ %o7 + 0x16 ], %l7
2012208: f0 0b e0 17 ldub [ %o7 + 0x17 ], %i0
201220c: f2 0b e0 22 ldub [ %o7 + 0x22 ], %i1
2012210: e8 0b e0 24 ldub [ %o7 + 0x24 ], %l4
2012214: ec 0b e0 25 ldub [ %o7 + 0x25 ], %l6
2012218: ea 0b e0 26 ldub [ %o7 + 0x26 ], %l5
201221c: e6 0b e0 27 ldub [ %o7 + 0x27 ], %l3
2012220: f6 0b e0 28 ldub [ %o7 + 0x28 ], %i3
2012224: c2 2f bf 97 stb %g1, [ %fp + -105 ]
2012228: c2 0b e0 30 ldub [ %o7 + 0x30 ], %g1
201222c: de 0b e0 31 ldub [ %o7 + 0x31 ], %o7
2012230: c2 2f bf 9c stb %g1, [ %fp + -100 ]
sc = rtems_bdbuf_release( block);
2012234: c4 3f bf 80 std %g2, [ %fp + -128 ]
2012238: c8 27 bf 7c st %g4, [ %fp + -132 ]
201223c: d6 27 bf 78 st %o3, [ %fp + -136 ]
2012240: 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);
2012244: de 2f bf 9b stb %o7, [ %fp + -101 ]
sc = rtems_bdbuf_release( block);
2012248: 7f ff f7 c7 call 2010164 <rtems_bdbuf_release>
201224c: 01 00 00 00 nop
if (sc != RTEMS_SUCCESSFUL)
2012250: c4 1f bf 80 ldd [ %fp + -128 ], %g2
2012254: 80 a2 20 00 cmp %o0, 0
2012258: c8 07 bf 7c ld [ %fp + -132 ], %g4
201225c: d6 07 bf 78 ld [ %fp + -136 ], %o3
2012260: 02 80 00 08 be 2012280 <fat_init_volume_info+0x184> <== ALWAYS TAKEN
2012264: d8 1f bf 70 ldd [ %fp + -144 ], %o4
{
close(vol->fd);
2012268: 7f ff c8 27 call 2004304 <close> <== NOT EXECUTED
201226c: d0 04 20 54 ld [ %l0 + 0x54 ], %o0 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EIO );
2012270: 40 00 1f 6c call 201a020 <__errno> <== NOT EXECUTED
2012274: 01 00 00 00 nop <== NOT EXECUTED
2012278: 10 80 01 76 b 2012850 <fat_init_volume_info+0x754> <== NOT EXECUTED
201227c: 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);
2012280: 96 0a e0 ff and %o3, 0xff, %o3
2012284: 84 08 a0 ff and %g2, 0xff, %g2
2012288: 97 2a e0 08 sll %o3, 8, %o3
201228c: 84 12 c0 02 or %o3, %g2, %g2
if ( (vol->bps != 512) &&
2012290: 9f 28 a0 10 sll %g2, 0x10, %o7
2012294: 9f 33 e0 10 srl %o7, 0x10, %o7
2012298: 80 a3 e4 00 cmp %o7, 0x400
201229c: 02 80 00 0c be 20122cc <fat_init_volume_info+0x1d0> <== NEVER TAKEN
20122a0: c4 34 00 00 sth %g2, [ %l0 ]
20122a4: 80 a3 e2 00 cmp %o7, 0x200
20122a8: 22 80 00 0a be,a 20122d0 <fat_init_volume_info+0x1d4> <== ALWAYS TAKEN
20122ac: 9f 28 a0 10 sll %g2, 0x10, %o7
(vol->bps != 1024) &&
20122b0: 80 a3 e8 00 cmp %o7, 0x800 <== NOT EXECUTED
20122b4: 02 80 00 06 be 20122cc <fat_init_volume_info+0x1d0> <== NOT EXECUTED
20122b8: 17 00 00 04 sethi %hi(0x1000), %o3 <== NOT EXECUTED
(vol->bps != 2048) &&
20122bc: 80 a3 c0 0b cmp %o7, %o3 <== NOT EXECUTED
20122c0: 02 80 00 04 be 20122d0 <fat_init_volume_info+0x1d4> <== NOT EXECUTED
20122c4: 9f 28 a0 10 sll %g2, 0x10, %o7 <== NOT EXECUTED
20122c8: 30 80 00 d1 b,a 201260c <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;
20122cc: 9f 28 a0 10 sll %g2, 0x10, %o7 <== NOT EXECUTED
20122d0: c0 2c 20 03 clrb [ %l0 + 3 ]
20122d4: 10 80 00 05 b 20122e8 <fat_init_volume_info+0x1ec>
20122d8: 9f 33 e0 19 srl %o7, 0x19, %o7
i >>= 1, vol->sec_mul++);
20122dc: 9f 3b e0 01 sra %o7, 1, %o7 <== NOT EXECUTED
20122e0: 96 02 e0 01 inc %o3 <== NOT EXECUTED
20122e4: 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;
20122e8: 80 8b e0 01 btst 1, %o7
20122ec: 22 bf ff fc be,a 20122dc <fat_init_volume_info+0x1e0> <== NEVER TAKEN
20122f0: 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;
20122f4: 85 28 a0 10 sll %g2, 0x10, %g2
20122f8: c0 2c 20 02 clrb [ %l0 + 2 ]
20122fc: 93 30 a0 10 srl %g2, 0x10, %o1
2012300: 10 80 00 05 b 2012314 <fat_init_volume_info+0x218>
2012304: 84 10 00 09 mov %o1, %g2
i >>= 1, vol->sec_log2++);
2012308: 85 38 a0 01 sra %g2, 1, %g2
201230c: 9e 03 e0 01 inc %o7
2012310: 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;
2012314: 80 88 a0 01 btst 1, %g2
2012318: 22 bf ff fc be,a 2012308 <fat_init_volume_info+0x20c>
201231c: 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)
2012320: 9e 8f 20 ff andcc %i4, 0xff, %o7
2012324: 02 80 00 ba be 201260c <fat_init_volume_info+0x510> <== NEVER TAKEN
2012328: 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;
201232c: 10 80 00 05 b 2012340 <fat_init_volume_info+0x244>
2012330: c0 2c 20 05 clrb [ %l0 + 5 ]
i >>= 1, vol->spc_log2++);
2012334: 84 00 a0 01 inc %g2
2012338: 9f 3b e0 01 sra %o7, 1, %o7
201233c: 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;
2012340: 80 8b e0 01 btst 1, %o7
2012344: 02 bf ff fc be 2012334 <fat_init_volume_info+0x238>
2012348: 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)
201234c: 85 2a 40 02 sll %o1, %g2, %g2
2012350: 97 28 a0 10 sll %g2, 0x10, %o3
2012354: 1f 20 00 00 sethi %hi(0x80000000), %o7
2012358: 80 a2 c0 0f cmp %o3, %o7
201235c: 18 80 00 ac bgu 201260c <fat_init_volume_info+0x510> <== NEVER TAKEN
2012360: 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;
2012364: 1f 00 00 3f sethi %hi(0xfc00), %o7
2012368: c0 2c 20 08 clrb [ %l0 + 8 ]
201236c: 9e 13 e3 ff or %o7, 0x3ff, %o7
2012370: 10 80 00 05 b 2012384 <fat_init_volume_info+0x288>
2012374: 84 08 80 0f and %g2, %o7, %g2
i >>= 1, vol->bpc_log2++);
2012378: 85 38 a0 01 sra %g2, 1, %g2
201237c: 9e 03 e0 01 inc %o7
2012380: 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;
2012384: 80 88 a0 01 btst 1, %g2
2012388: 22 bf ff fc be,a 2012378 <fat_init_volume_info+0x27c>
201238c: 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)) /
2012390: 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);
2012394: 98 0b 20 ff and %o4, 0xff, %o4
2012398: 9a 0b 60 ff and %o5, 0xff, %o5
201239c: 99 2b 20 08 sll %o4, 8, %o4
vol->rdir_entrs = FAT_GET_BR_FILES_PER_ROOT_DIR(boot_rec);
20123a0: 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);
20123a4: 9a 13 00 0d or %o4, %o5, %o5
vol->rdir_entrs = FAT_GET_BR_FILES_PER_ROOT_DIR(boot_rec);
20123a8: 89 29 20 08 sll %g4, 8, %g4
20123ac: 86 08 e0 ff and %g3, 0xff, %g3
20123b0: 86 11 00 03 or %g4, %g3, %g3
20123b4: 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)) /
20123b8: 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);
20123bc: 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)) /
20123c0: 91 30 e0 0b srl %g3, 0xb, %o0
20123c4: da 27 bf 74 st %o5, [ %fp + -140 ]
20123c8: 90 02 00 02 add %o0, %g2, %o0
20123cc: 40 00 43 55 call 2023120 <.div>
20123d0: f4 2c 20 09 stb %i2, [ %l0 + 9 ]
vol->bps;
vol->rdir_size = vol->rdir_secs << vol->sec_log2;
20123d4: 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)) /
20123d8: d0 24 20 24 st %o0, [ %l0 + 0x24 ]
vol->bps;
vol->rdir_size = vol->rdir_secs << vol->sec_log2;
20123dc: 87 2a 00 03 sll %o0, %g3, %g3
20123e0: c6 24 20 28 st %g3, [ %l0 + 0x28 ]
if ( (FAT_GET_BR_SECTORS_PER_FAT(boot_rec)) != 0)
20123e4: b0 0e 20 ff and %i0, 0xff, %i0
20123e8: ae 0d e0 ff and %l7, 0xff, %l7
20123ec: 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)) /
20123f0: 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)
20123f4: ae 16 00 17 or %i0, %l7, %l7
20123f8: af 2d e0 10 sll %l7, 0x10, %l7
20123fc: 80 a5 e0 00 cmp %l7, 0
2012400: 02 80 00 05 be 2012414 <fat_init_volume_info+0x318> <== NEVER TAKEN
2012404: da 07 bf 74 ld [ %fp + -140 ], %o5
vol->fat_length = FAT_GET_BR_SECTORS_PER_FAT(boot_rec);
2012408: af 35 e0 10 srl %l7, 0x10, %l7
201240c: 10 80 00 0c b 201243c <fat_init_volume_info+0x340>
2012410: ee 24 20 18 st %l7, [ %l0 + 0x18 ]
else
vol->fat_length = FAT_GET_BR_SECTORS_PER_FAT32(boot_rec);
2012414: ac 0d a0 ff and %l6, 0xff, %l6 <== NOT EXECUTED
2012418: aa 0d 60 ff and %l5, 0xff, %l5 <== NOT EXECUTED
201241c: ad 2d a0 08 sll %l6, 8, %l6 <== NOT EXECUTED
2012420: ab 2d 60 10 sll %l5, 0x10, %l5 <== NOT EXECUTED
2012424: a8 0d 20 ff and %l4, 0xff, %l4 <== NOT EXECUTED
2012428: aa 15 80 15 or %l6, %l5, %l5 <== NOT EXECUTED
201242c: a7 2c e0 18 sll %l3, 0x18, %l3 <== NOT EXECUTED
2012430: a8 15 40 14 or %l5, %l4, %l4 <== NOT EXECUTED
2012434: a6 15 00 13 or %l4, %l3, %l3 <== NOT EXECUTED
2012438: e6 24 20 18 st %l3, [ %l0 + 0x18 ] <== NOT EXECUTED
vol->data_fsec = vol->fat_loc + vol->fats * vol->fat_length +
201243c: d2 04 20 18 ld [ %l0 + 0x18 ], %o1
2012440: 9b 2b 60 10 sll %o5, 0x10, %o5
2012444: c4 27 bf 80 st %g2, [ %fp + -128 ]
2012448: b1 33 60 10 srl %o5, 0x10, %i0
201244c: 40 00 42 f9 call 2023030 <.umul>
2012450: 90 0e a0 ff and %i2, 0xff, %o0
2012454: c4 07 bf 80 ld [ %fp + -128 ], %g2
2012458: 90 06 00 08 add %i0, %o0, %o0
201245c: 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;
2012460: d0 24 20 1c st %o0, [ %l0 + 0x1c ]
if ( (FAT_GET_BR_TOTAL_SECTORS_NUM16(boot_rec)) != 0)
2012464: a4 0c a0 ff and %l2, 0xff, %l2
2012468: a2 0c 60 ff and %l1, 0xff, %l1
201246c: a5 2c a0 08 sll %l2, 8, %l2
2012470: a2 14 80 11 or %l2, %l1, %l1
2012474: a3 2c 60 10 sll %l1, 0x10, %l1
2012478: 80 a4 60 00 cmp %l1, 0
201247c: 02 80 00 05 be 2012490 <fat_init_volume_info+0x394> <== NEVER TAKEN
2012480: c4 24 20 30 st %g2, [ %l0 + 0x30 ]
vol->tot_secs = FAT_GET_BR_TOTAL_SECTORS_NUM16(boot_rec);
2012484: a3 34 60 10 srl %l1, 0x10, %l1
2012488: 10 80 00 0d b 20124bc <fat_init_volume_info+0x3c0>
201248c: e2 24 20 2c st %l1, [ %l0 + 0x2c ]
else
vol->tot_secs = FAT_GET_BR_TOTAL_SECTORS_NUM32(boot_rec);
2012490: c8 0f bf 99 ldub [ %fp + -103 ], %g4 <== NOT EXECUTED
2012494: c6 0f bf 9a ldub [ %fp + -102 ], %g3 <== NOT EXECUTED
2012498: c2 0f bf 8f ldub [ %fp + -113 ], %g1 <== NOT EXECUTED
201249c: 87 28 e0 08 sll %g3, 8, %g3 <== NOT EXECUTED
20124a0: b2 0e 60 ff and %i1, 0xff, %i1 <== NOT EXECUTED
20124a4: b3 2e 60 10 sll %i1, 0x10, %i1 <== NOT EXECUTED
20124a8: 86 10 c0 19 or %g3, %i1, %g3 <== NOT EXECUTED
20124ac: 86 10 c0 04 or %g3, %g4, %g3 <== NOT EXECUTED
20124b0: 89 28 60 18 sll %g1, 0x18, %g4 <== NOT EXECUTED
20124b4: 86 10 c0 04 or %g3, %g4, %g3 <== NOT EXECUTED
20124b8: c6 24 20 2c st %g3, [ %l0 + 0x2c ] <== NOT EXECUTED
data_secs = vol->tot_secs - vol->data_fsec;
20124bc: d0 04 20 2c ld [ %l0 + 0x2c ], %o0
vol->data_cls = data_secs / vol->spc;
20124c0: 92 0f 20 ff and %i4, 0xff, %o1
20124c4: 40 00 43 15 call 2023118 <.udiv>
20124c8: 90 22 00 02 sub %o0, %g2, %o0
/* determine FAT type at least */
if ( vol->data_cls < FAT_FAT12_MAX_CLN)
20124cc: 80 a2 2f f4 cmp %o0, 0xff4
20124d0: 18 80 00 08 bgu 20124f0 <fat_init_volume_info+0x3f4> <== NEVER TAKEN
20124d4: d0 24 20 34 st %o0, [ %l0 + 0x34 ]
{
vol->type = FAT_FAT12;
20124d8: 84 10 20 01 mov 1, %g2
20124dc: c4 2c 20 0a stb %g2, [ %l0 + 0xa ]
vol->mask = FAT_FAT12_MASK;
20124e0: 84 10 2f ff mov 0xfff, %g2
20124e4: c4 24 20 0c st %g2, [ %l0 + 0xc ]
vol->eoc_val = FAT_FAT12_EOC;
20124e8: 10 80 00 0f b 2012524 <fat_init_volume_info+0x428>
20124ec: 84 10 2f f8 mov 0xff8, %g2
}
else
{
if ( vol->data_cls < FAT_FAT16_MAX_CLN)
20124f0: 05 00 00 3f sethi %hi(0xfc00), %g2 <== NOT EXECUTED
20124f4: 86 10 a3 f4 or %g2, 0x3f4, %g3 ! fff4 <PROM_START+0xfff4> <== NOT EXECUTED
20124f8: 80 a2 00 03 cmp %o0, %g3 <== NOT EXECUTED
20124fc: 38 80 00 05 bgu,a 2012510 <fat_init_volume_info+0x414> <== NOT EXECUTED
2012500: 84 10 20 04 mov 4, %g2 <== NOT EXECUTED
{
vol->type = FAT_FAT16;
2012504: 86 10 20 02 mov 2, %g3 <== NOT EXECUTED
2012508: 10 80 00 04 b 2012518 <fat_init_volume_info+0x41c> <== NOT EXECUTED
201250c: 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;
2012510: c4 2c 20 0a stb %g2, [ %l0 + 0xa ] <== NOT EXECUTED
vol->mask = FAT_FAT32_MASK;
2012514: 05 03 ff ff sethi %hi(0xffffc00), %g2 <== NOT EXECUTED
2012518: 86 10 a3 ff or %g2, 0x3ff, %g3 ! fffffff <RAM_END+0xdbfffff><== NOT EXECUTED
vol->eoc_val = FAT_FAT32_EOC;
201251c: 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;
2012520: c6 24 20 0c st %g3, [ %l0 + 0xc ] <== NOT EXECUTED
vol->eoc_val = FAT_FAT32_EOC;
2012524: c4 24 20 10 st %g2, [ %l0 + 0x10 ]
}
}
if (vol->type == FAT_FAT32)
2012528: c4 0c 20 0a ldub [ %l0 + 0xa ], %g2
201252c: 80 a0 a0 04 cmp %g2, 4
2012530: 12 80 00 6e bne 20126e8 <fat_init_volume_info+0x5ec> <== ALWAYS TAKEN
2012534: 82 10 3f ff mov -1, %g1
{
vol->rdir_cl = FAT_GET_BR_FAT32_ROOT_CLUSTER(boot_rec);
2012538: c6 0f bf 9e ldub [ %fp + -98 ], %g3 <== NOT EXECUTED
201253c: c4 0f bf 9d ldub [ %fp + -99 ], %g2 <== NOT EXECUTED
2012540: 87 28 e0 08 sll %g3, 8, %g3 <== NOT EXECUTED
2012544: 85 28 a0 10 sll %g2, 0x10, %g2 <== NOT EXECUTED
2012548: c2 0f bf 97 ldub [ %fp + -105 ], %g1 <== NOT EXECUTED
201254c: 84 10 c0 02 or %g3, %g2, %g2 <== NOT EXECUTED
2012550: c6 0f bf 9f ldub [ %fp + -97 ], %g3 <== NOT EXECUTED
2012554: 84 10 80 03 or %g2, %g3, %g2 <== NOT EXECUTED
2012558: 87 28 60 18 sll %g1, 0x18, %g3 <== NOT EXECUTED
201255c: 84 10 80 03 or %g2, %g3, %g2 <== NOT EXECUTED
2012560: c4 24 20 38 st %g2, [ %l0 + 0x38 ] <== NOT EXECUTED
vol->mirror = FAT_GET_BR_EXT_FLAGS(boot_rec) & FAT_BR_EXT_FLAGS_MIRROR;
2012564: 84 0e ff 80 and %i3, -128, %g2 <== NOT EXECUTED
if (vol->mirror)
2012568: 80 88 a0 80 btst 0x80, %g2 <== NOT EXECUTED
201256c: 02 80 00 05 be 2012580 <fat_init_volume_info+0x484> <== NOT EXECUTED
2012570: 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;
2012574: b6 0e e0 0f and %i3, 0xf, %i3 <== NOT EXECUTED
2012578: 10 80 00 03 b 2012584 <fat_init_volume_info+0x488> <== NOT EXECUTED
201257c: f6 2c 20 50 stb %i3, [ %l0 + 0x50 ] <== NOT EXECUTED
else
vol->afat = 0;
2012580: c0 2c 20 50 clrb [ %l0 + 0x50 ] <== NOT EXECUTED
vol->info_sec = FAT_GET_BR_FAT32_FS_INFO_SECTOR(boot_rec);
2012584: d2 0f bf 9b ldub [ %fp + -101 ], %o1 <== NOT EXECUTED
2012588: c4 0f bf 9c ldub [ %fp + -100 ], %g2 <== NOT EXECUTED
201258c: 93 2a 60 08 sll %o1, 8, %o1 <== NOT EXECUTED
2012590: 92 12 40 02 or %o1, %g2, %o1 <== NOT EXECUTED
2012594: d2 34 20 3c sth %o1, [ %l0 + 0x3c ] <== NOT EXECUTED
if( vol->info_sec == 0 )
2012598: 93 2a 60 10 sll %o1, 0x10, %o1 <== NOT EXECUTED
201259c: 93 32 60 10 srl %o1, 0x10, %o1 <== NOT EXECUTED
20125a0: 80 a2 60 00 cmp %o1, 0 <== NOT EXECUTED
20125a4: 32 80 00 03 bne,a 20125b0 <fat_init_volume_info+0x4b4> <== NOT EXECUTED
20125a8: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
20125ac: 30 80 00 18 b,a 201260c <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,
20125b0: 94 10 20 00 clr %o2 <== NOT EXECUTED
20125b4: 96 10 20 04 mov 4, %o3 <== NOT EXECUTED
20125b8: 7f ff fd 6b call 2011b64 <_fat_block_read> <== NOT EXECUTED
20125bc: 98 07 bf a8 add %fp, -88, %o4 <== NOT EXECUTED
FAT_FSI_LEADSIG_SIZE, fs_info_sector);
if ( ret < 0 )
20125c0: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
20125c4: 06 80 00 22 bl 201264c <fat_init_volume_info+0x550> <== NOT EXECUTED
20125c8: c4 0f bf aa ldub [ %fp + -86 ], %g2 <== NOT EXECUTED
{
close(vol->fd);
return -1;
}
if (FAT_GET_FSINFO_LEAD_SIGNATURE(fs_info_sector) !=
20125cc: c6 0f bf a9 ldub [ %fp + -87 ], %g3 <== NOT EXECUTED
20125d0: 85 28 a0 10 sll %g2, 0x10, %g2 <== NOT EXECUTED
20125d4: 87 28 e0 08 sll %g3, 8, %g3 <== NOT EXECUTED
20125d8: 86 10 c0 02 or %g3, %g2, %g3 <== NOT EXECUTED
20125dc: c4 0f bf a8 ldub [ %fp + -88 ], %g2 <== NOT EXECUTED
20125e0: 86 10 c0 02 or %g3, %g2, %g3 <== NOT EXECUTED
20125e4: c4 0f bf ab ldub [ %fp + -85 ], %g2 <== NOT EXECUTED
20125e8: 85 28 a0 18 sll %g2, 0x18, %g2 <== NOT EXECUTED
20125ec: 86 10 c0 02 or %g3, %g2, %g3 <== NOT EXECUTED
20125f0: 05 10 58 54 sethi %hi(0x41615000), %g2 <== NOT EXECUTED
20125f4: 84 10 a2 52 or %g2, 0x252, %g2 ! 41615252 <RAM_END+0x3f215252><== NOT EXECUTED
20125f8: 80 a0 c0 02 cmp %g3, %g2 <== NOT EXECUTED
20125fc: 02 80 00 0a be 2012624 <fat_init_volume_info+0x528> <== NOT EXECUTED
2012600: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
FAT_FSINFO_LEAD_SIGNATURE_VALUE)
{
_fat_block_release(fs_info);
2012604: 7f ff fd c3 call 2011d10 <_fat_block_release> <== NOT EXECUTED
2012608: 01 00 00 00 nop <== NOT EXECUTED
close(vol->fd);
201260c: 7f ff c7 3e call 2004304 <close> <== NOT EXECUTED
2012610: d0 04 20 54 ld [ %l0 + 0x54 ], %o0 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
2012614: 40 00 1e 83 call 201a020 <__errno> <== NOT EXECUTED
2012618: 01 00 00 00 nop <== NOT EXECUTED
201261c: 10 80 00 8d b 2012850 <fat_init_volume_info+0x754> <== NOT EXECUTED
2012620: 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,
2012624: d2 14 20 3c lduh [ %l0 + 0x3c ], %o1 <== NOT EXECUTED
2012628: 94 10 21 e4 mov 0x1e4, %o2 <== NOT EXECUTED
201262c: 96 10 20 0c mov 0xc, %o3 <== NOT EXECUTED
2012630: 7f ff fd 4d call 2011b64 <_fat_block_read> <== NOT EXECUTED
2012634: 98 07 bf a8 add %fp, -88, %o4 <== NOT EXECUTED
FAT_USEFUL_INFO_SIZE, fs_info_sector);
if ( ret < 0 )
2012638: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
201263c: 16 80 00 08 bge 201265c <fat_init_volume_info+0x560> <== NOT EXECUTED
2012640: c6 0f bf ad ldub [ %fp + -83 ], %g3 <== NOT EXECUTED
{
_fat_block_release(fs_info);
2012644: 7f ff fd b3 call 2011d10 <_fat_block_release> <== NOT EXECUTED
2012648: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
close(vol->fd);
201264c: 7f ff c7 2e call 2004304 <close> <== NOT EXECUTED
2012650: 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 );
2012654: 10 80 00 81 b 2012858 <fat_init_volume_info+0x75c> <== NOT EXECUTED
2012658: 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);
201265c: c4 0f bf ae ldub [ %fp + -82 ], %g2 <== NOT EXECUTED
2012660: 87 28 e0 08 sll %g3, 8, %g3 <== NOT EXECUTED
2012664: 85 28 a0 10 sll %g2, 0x10, %g2 <== NOT EXECUTED
2012668: 84 10 c0 02 or %g3, %g2, %g2 <== NOT EXECUTED
201266c: 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,
2012670: 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);
2012674: 84 10 80 03 or %g2, %g3, %g2 <== NOT EXECUTED
2012678: 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,
201267c: 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);
2012680: 87 28 e0 18 sll %g3, 0x18, %g3 <== NOT EXECUTED
2012684: 84 10 80 03 or %g2, %g3, %g2 <== NOT EXECUTED
vol->next_cl = FAT_GET_FSINFO_NEXT_FREE_CLUSTER(fs_info_sector);
2012688: 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);
201268c: c4 24 20 40 st %g2, [ %l0 + 0x40 ] <== NOT EXECUTED
vol->next_cl = FAT_GET_FSINFO_NEXT_FREE_CLUSTER(fs_info_sector);
2012690: c4 0f bf b2 ldub [ %fp + -78 ], %g2 <== NOT EXECUTED
2012694: 87 28 e0 08 sll %g3, 8, %g3 <== NOT EXECUTED
2012698: 85 28 a0 10 sll %g2, 0x10, %g2 <== NOT EXECUTED
201269c: 84 10 c0 02 or %g3, %g2, %g2 <== NOT EXECUTED
20126a0: c6 0f bf b0 ldub [ %fp + -80 ], %g3 <== NOT EXECUTED
rc = fat_fat32_update_fsinfo_sector(fs_info, 0xFFFFFFFF,
20126a4: 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);
20126a8: 84 10 80 03 or %g2, %g3, %g2 <== NOT EXECUTED
20126ac: c6 0f bf b3 ldub [ %fp + -77 ], %g3 <== NOT EXECUTED
20126b0: 87 28 e0 18 sll %g3, 0x18, %g3 <== NOT EXECUTED
20126b4: 84 10 80 03 or %g2, %g3, %g2 <== NOT EXECUTED
rc = fat_fat32_update_fsinfo_sector(fs_info, 0xFFFFFFFF,
20126b8: 7f ff fe 2f call 2011f74 <fat_fat32_update_fsinfo_sector> <== NOT EXECUTED
20126bc: c4 24 20 44 st %g2, [ %l0 + 0x44 ] <== NOT EXECUTED
0xFFFFFFFF);
if ( rc != RC_OK )
20126c0: b8 92 20 00 orcc %o0, 0, %i4 <== NOT EXECUTED
20126c4: 02 80 00 0e be 20126fc <fat_init_volume_info+0x600> <== NOT EXECUTED
20126c8: 01 00 00 00 nop <== NOT EXECUTED
{
_fat_block_release(fs_info);
20126cc: 7f ff fd 91 call 2011d10 <_fat_block_release> <== NOT EXECUTED
20126d0: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
close(vol->fd);
20126d4: d0 04 20 54 ld [ %l0 + 0x54 ], %o0 <== NOT EXECUTED
20126d8: 7f ff c7 0b call 2004304 <close> <== NOT EXECUTED
20126dc: ba 10 00 1c mov %i4, %i5 <== NOT EXECUTED
free(fs_info->uino);
rtems_set_errno_and_return_minus_one( ENOMEM );
}
return RC_OK;
}
20126e0: 81 c7 e0 08 ret <== NOT EXECUTED
20126e4: 91 e8 00 1d restore %g0, %i5, %o0 <== NOT EXECUTED
}
}
}
else
{
vol->rdir_cl = 0;
20126e8: c0 24 20 38 clr [ %l0 + 0x38 ]
vol->mirror = 0;
20126ec: c0 2c 20 48 clrb [ %l0 + 0x48 ]
vol->afat = 0;
20126f0: c0 2c 20 50 clrb [ %l0 + 0x50 ]
vol->free_cls = 0xFFFFFFFF;
20126f4: c2 24 20 40 st %g1, [ %l0 + 0x40 ]
vol->next_cl = 0xFFFFFFFF;
20126f8: c2 24 20 44 st %g1, [ %l0 + 0x44 ]
}
_fat_block_release(fs_info);
20126fc: 7f ff fd 85 call 2011d10 <_fat_block_release>
2012700: 90 10 00 10 mov %l0, %o0
vol->afat_loc = vol->fat_loc + vol->fat_length * vol->afat;
2012704: d2 04 20 18 ld [ %l0 + 0x18 ], %o1
2012708: 40 00 42 4a call 2023030 <.umul>
201270c: d0 0c 20 50 ldub [ %l0 + 0x50 ], %o0
2012710: 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));
2012714: 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;
2012718: 90 02 00 02 add %o0, %g2, %o0
201271c: 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));
2012720: 7f ff c6 e2 call 20042a8 <calloc>
2012724: 90 10 20 02 mov 2, %o0
if ( fs_info->vhash == NULL )
2012728: 80 a2 20 00 cmp %o0, 0
201272c: 02 80 00 12 be 2012774 <fat_init_volume_info+0x678> <== NEVER TAKEN
2012730: 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 );
2012734: 84 02 20 04 add %o0, 4, %g2
2012738: 86 02 20 10 add %o0, 0x10, %g3
head->next = tail;
201273c: 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 );
2012740: 84 02 20 0c add %o0, 0xc, %g2
head->next = tail;
head->previous = NULL;
2012744: c0 22 20 04 clr [ %o0 + 4 ]
tail->previous = head;
2012748: 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;
201274c: c6 22 20 0c st %g3, [ %o0 + 0xc ]
head->previous = NULL;
2012750: c0 22 20 10 clr [ %o0 + 0x10 ]
tail->previous = head;
2012754: 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));
2012758: 92 10 20 0c mov 0xc, %o1
201275c: 7f ff c6 d3 call 20042a8 <calloc>
2012760: 90 10 20 02 mov 2, %o0
if ( fs_info->rhash == NULL )
2012764: 80 a2 20 00 cmp %o0, 0
2012768: 12 80 00 06 bne 2012780 <fat_init_volume_info+0x684> <== ALWAYS TAKEN
201276c: d0 24 20 64 st %o0, [ %l0 + 0x64 ]
2012770: 30 80 00 1c b,a 20127e0 <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);
2012774: 7f ff c6 e4 call 2004304 <close> <== NOT EXECUTED
2012778: d0 04 20 54 ld [ %l0 + 0x54 ], %o0 <== NOT EXECUTED
201277c: 30 80 00 32 b,a 2012844 <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 );
2012780: 84 02 20 04 add %o0, 4, %g2
head->next = tail;
2012784: 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 );
2012788: 84 02 20 0c add %o0, 0xc, %g2
head->next = tail;
head->previous = NULL;
201278c: c0 22 20 04 clr [ %o0 + 4 ]
tail->previous = head;
2012790: c4 22 20 14 st %g2, [ %o0 + 0x14 ]
2012794: 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;
2012798: 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 );
201279c: 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;
20127a0: 84 10 21 00 mov 0x100, %g2
head->next = tail;
20127a4: c6 22 20 0c st %g3, [ %o0 + 0xc ]
20127a8: c4 24 20 70 st %g2, [ %l0 + 0x70 ]
fs_info->uino_base = (vol->tot_secs << vol->sec_mul) << 4;
20127ac: c6 04 20 2c ld [ %l0 + 0x2c ], %g3
20127b0: c4 0c 20 03 ldub [ %l0 + 3 ], %g2
fs_info->index = 0;
20127b4: 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;
20127b8: 85 28 c0 02 sll %g3, %g2, %g2
20127bc: 85 28 a0 04 sll %g2, 4, %g2
fs_info->index = 0;
fs_info->uino = (char *)calloc(fs_info->uino_pool_size, sizeof(char));
20127c0: 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;
20127c4: c4 24 20 74 st %g2, [ %l0 + 0x74 ]
fs_info->index = 0;
fs_info->uino = (char *)calloc(fs_info->uino_pool_size, sizeof(char));
20127c8: 7f ff c6 b8 call 20042a8 <calloc>
20127cc: 92 10 20 01 mov 1, %o1
if ( fs_info->uino == NULL )
20127d0: 80 a2 20 00 cmp %o0, 0
20127d4: 12 80 00 0d bne 2012808 <fat_init_volume_info+0x70c> <== ALWAYS TAKEN
20127d8: d0 24 20 68 st %o0, [ %l0 + 0x68 ]
20127dc: 30 80 00 05 b,a 20127f0 <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);
20127e0: 7f ff c6 c9 call 2004304 <close> <== NOT EXECUTED
20127e4: d0 04 20 54 ld [ %l0 + 0x54 ], %o0 <== NOT EXECUTED
free(fs_info->vhash);
20127e8: 10 80 00 15 b 201283c <fat_init_volume_info+0x740> <== NOT EXECUTED
20127ec: 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);
20127f0: 7f ff c6 c5 call 2004304 <close> <== NOT EXECUTED
20127f4: d0 04 20 54 ld [ %l0 + 0x54 ], %o0 <== NOT EXECUTED
free(fs_info->vhash);
20127f8: 7f ff c7 81 call 20045fc <free> <== NOT EXECUTED
20127fc: d0 04 20 60 ld [ %l0 + 0x60 ], %o0 <== NOT EXECUTED
free(fs_info->rhash);
2012800: 10 80 00 0f b 201283c <fat_init_volume_info+0x740> <== NOT EXECUTED
2012804: 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));
2012808: d0 14 00 00 lduh [ %l0 ], %o0
201280c: 7f ff c6 a7 call 20042a8 <calloc>
2012810: 92 10 20 01 mov 1, %o1
if (fs_info->sec_buf == NULL)
2012814: 80 a2 20 00 cmp %o0, 0
2012818: 12 80 00 10 bne 2012858 <fat_init_volume_info+0x75c> <== ALWAYS TAKEN
201281c: d0 24 20 84 st %o0, [ %l0 + 0x84 ]
{
close(vol->fd);
2012820: 7f ff c6 b9 call 2004304 <close> <== NOT EXECUTED
2012824: d0 04 20 54 ld [ %l0 + 0x54 ], %o0 <== NOT EXECUTED
free(fs_info->vhash);
2012828: 7f ff c7 75 call 20045fc <free> <== NOT EXECUTED
201282c: d0 04 20 60 ld [ %l0 + 0x60 ], %o0 <== NOT EXECUTED
free(fs_info->rhash);
2012830: 7f ff c7 73 call 20045fc <free> <== NOT EXECUTED
2012834: d0 04 20 64 ld [ %l0 + 0x64 ], %o0 <== NOT EXECUTED
free(fs_info->uino);
2012838: d0 04 20 68 ld [ %l0 + 0x68 ], %o0 <== NOT EXECUTED
201283c: 7f ff c7 70 call 20045fc <free> <== NOT EXECUTED
2012840: 01 00 00 00 nop <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOMEM );
2012844: 40 00 1d f7 call 201a020 <__errno> <== NOT EXECUTED
2012848: 01 00 00 00 nop <== NOT EXECUTED
201284c: 82 10 20 0c mov 0xc, %g1 ! c <PROM_START+0xc> <== NOT EXECUTED
2012850: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
2012854: ba 10 3f ff mov -1, %i5 <== NOT EXECUTED
}
return RC_OK;
}
2012858: b0 10 00 1d mov %i5, %i0
201285c: 81 c7 e0 08 ret
2012860: 81 e8 00 00 restore
02018548 <fat_scan_fat_for_free_clusters>:
uint32_t count,
uint32_t *cls_added,
uint32_t *last_cl,
bool zero_fill
)
{
2018548: 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;
201854c: e8 06 20 34 ld [ %i0 + 0x34 ], %l4
bool zero_fill
)
{
int rc = RC_OK;
uint32_t cl4find = 2;
uint32_t next_cln = 0;
2018550: 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;
2018554: c0 26 c0 00 clr [ %i3 ]
if (count == 0)
2018558: 80 a6 a0 00 cmp %i2, 0
201855c: 02 80 00 87 be 2018778 <fat_scan_fat_for_free_clusters+0x230><== NEVER TAKEN
2018560: a2 10 20 00 clr %l1
return rc;
if (fs_info->vol.next_cl != FAT_UNDEFINED_VALUE)
2018564: e0 06 20 44 ld [ %i0 + 0x44 ], %l0
2018568: 80 a4 3f ff cmp %l0, -1
201856c: 22 80 00 02 be,a 2018574 <fat_scan_fat_for_free_clusters+0x2c>
2018570: 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;
2018574: a8 05 20 02 add %l4, 2, %l4
2018578: a6 10 20 02 mov 2, %l3
201857c: 10 80 00 64 b 201870c <fat_scan_fat_for_free_clusters+0x1c4>
2018580: 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);
2018584: 92 10 00 10 mov %l0, %o1
2018588: 7f ff fe 9b call 2017ff4 <fat_get_fat_cluster>
201858c: 94 07 bf fc add %fp, -4, %o2
if ( rc != RC_OK )
2018590: a2 92 20 00 orcc %o0, 0, %l1
2018594: 02 80 00 0b be 20185c0 <fat_scan_fat_for_free_clusters+0x78><== ALWAYS TAKEN
2018598: c2 07 bf fc ld [ %fp + -4 ], %g1
{
if (*cls_added != 0)
201859c: c2 06 c0 00 ld [ %i3 ], %g1 <== NOT EXECUTED
20185a0: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
20185a4: 22 80 00 76 be,a 201877c <fat_scan_fat_for_free_clusters+0x234><== NOT EXECUTED
20185a8: b0 10 00 11 mov %l1, %i0 <== NOT EXECUTED
fat_free_fat_clusters_chain(fs_info, (*chain));
20185ac: d2 06 40 00 ld [ %i1 ], %o1 <== NOT EXECUTED
20185b0: 7f ff ff b7 call 201848c <fat_free_fat_clusters_chain> <== NOT EXECUTED
20185b4: 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;
}
20185b8: 81 c7 e0 08 ret <== NOT EXECUTED
20185bc: 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)
20185c0: 80 a0 60 00 cmp %g1, 0
20185c4: 32 80 00 4e bne,a 20186fc <fat_scan_fat_for_free_clusters+0x1b4>
20185c8: 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)
20185cc: c2 06 c0 00 ld [ %i3 ], %g1
20185d0: 80 a0 60 00 cmp %g1, 0
20185d4: 12 80 00 0e bne 201860c <fat_scan_fat_for_free_clusters+0xc4>
20185d8: 90 10 00 18 mov %i0, %o0
{
*chain = cl4find;
20185dc: e0 26 40 00 st %l0, [ %i1 ]
rc = fat_set_fat_cluster(fs_info, cl4find, FAT_GENFAT_EOC);
20185e0: 92 10 00 10 mov %l0, %o1
20185e4: 7f ff fe fb call 20181d0 <fat_set_fat_cluster>
20185e8: 94 10 3f ff mov -1, %o2
if ( rc != RC_OK )
20185ec: 80 a2 20 00 cmp %o0, 0
20185f0: 32 80 00 62 bne,a 2018778 <fat_scan_fat_for_free_clusters+0x230><== NEVER TAKEN
20185f4: 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) {
20185f8: 80 a7 60 00 cmp %i5, 0
20185fc: 22 80 00 18 be,a 201865c <fat_scan_fat_for_free_clusters+0x114>
2018600: 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)) )
2018604: 10 80 00 1c b 2018674 <fat_scan_fat_for_free_clusters+0x12c>
2018608: 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);
201860c: 92 10 00 10 mov %l0, %o1
2018610: 7f ff fe f0 call 20181d0 <fat_set_fat_cluster>
2018614: 94 10 3f ff mov -1, %o2
2018618: aa 10 00 08 mov %o0, %l5
if ( rc != RC_OK )
201861c: 80 a5 60 00 cmp %l5, 0
2018620: 02 80 00 07 be 201863c <fat_scan_fat_for_free_clusters+0xf4><== ALWAYS TAKEN
2018624: 90 10 00 18 mov %i0, %o0
{
/* cleanup activity */
fat_free_fat_clusters_chain(fs_info, (*chain));
2018628: d2 06 40 00 ld [ %i1 ], %o1 <== NOT EXECUTED
201862c: 7f ff ff 98 call 201848c <fat_free_fat_clusters_chain> <== NOT EXECUTED
2018630: 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;
}
2018634: 81 c7 e0 08 ret <== NOT EXECUTED
2018638: 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);
201863c: 92 10 00 12 mov %l2, %o1
2018640: 7f ff fe e4 call 20181d0 <fat_set_fat_cluster>
2018644: 94 10 00 10 mov %l0, %o2
if ( rc != RC_OK )
2018648: a4 92 20 00 orcc %o0, 0, %l2
201864c: 02 bf ff ec be 20185fc <fat_scan_fat_for_free_clusters+0xb4><== ALWAYS TAKEN
2018650: 80 a7 60 00 cmp %i5, 0
return RC_OK;
cleanup:
/* cleanup activity */
fat_free_fat_clusters_chain(fs_info, (*chain));
2018654: 10 80 00 3e b 201874c <fat_scan_fat_for_free_clusters+0x204><== NOT EXECUTED
2018658: d2 06 40 00 ld [ %i1 ], %o1 <== NOT EXECUTED
if ( rc != RC_OK )
goto cleanup;
}
save_cln = cl4find;
(*cls_added)++;
201865c: 82 00 60 01 inc %g1
/* have we satisfied request ? */
if (*cls_added == count)
2018660: 80 a0 40 1a cmp %g1, %i2
2018664: 02 80 00 19 be 20186c8 <fat_scan_fat_for_free_clusters+0x180>
2018668: c2 26 c0 00 st %g1, [ %i3 ]
201866c: 10 80 00 23 b 20186f8 <fat_scan_fat_for_free_clusters+0x1b0>
2018670: a4 10 00 10 mov %l0, %l2
2018674: 32 80 00 08 bne,a 2018694 <fat_scan_fat_for_free_clusters+0x14c><== ALWAYS TAKEN
2018678: c2 0e 20 05 ldub [ %i0 + 5 ], %g1
201867c: c2 0e 20 0a ldub [ %i0 + 0xa ], %g1 <== NOT EXECUTED
2018680: 80 88 60 03 btst 3, %g1 <== NOT EXECUTED
2018684: 22 80 00 04 be,a 2018694 <fat_scan_fat_for_free_clusters+0x14c><== NOT EXECUTED
2018688: c2 0e 20 05 ldub [ %i0 + 5 ], %g1 <== NOT EXECUTED
return fs_info->vol.rdir_loc;
201868c: 10 80 00 06 b 20186a4 <fat_scan_fat_for_free_clusters+0x15c><== NOT EXECUTED
2018690: d2 06 20 1c ld [ %i0 + 0x1c ], %o1 <== NOT EXECUTED
return (((cln - FAT_RSRVD_CLN) << fs_info->vol.spc_log2) +
2018694: 92 04 3f fe add %l0, -2, %o1
2018698: 93 2a 40 01 sll %o1, %g1, %o1
201869c: c2 06 20 30 ld [ %i0 + 0x30 ], %g1
20186a0: 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);
20186a4: d6 16 20 06 lduh [ %i0 + 6 ], %o3
20186a8: 90 10 00 18 mov %i0, %o0
20186ac: 7f ff e5 76 call 2011c84 <_fat_block_zero>
20186b0: 94 10 20 00 clr %o2
if ( rc != RC_OK )
20186b4: a4 92 20 00 orcc %o0, 0, %l2
20186b8: 22 bf ff e9 be,a 201865c <fat_scan_fat_for_free_clusters+0x114><== ALWAYS TAKEN
20186bc: c2 06 c0 00 ld [ %i3 ], %g1
return RC_OK;
cleanup:
/* cleanup activity */
fat_free_fat_clusters_chain(fs_info, (*chain));
20186c0: 10 80 00 23 b 201874c <fat_scan_fat_for_free_clusters+0x204><== NOT EXECUTED
20186c4: 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)
20186c8: c2 06 20 40 ld [ %i0 + 0x40 ], %g1
20186cc: 80 a0 7f ff cmp %g1, -1
20186d0: 02 80 00 05 be 20186e4 <fat_scan_fat_for_free_clusters+0x19c><== ALWAYS TAKEN
20186d4: e0 26 20 44 st %l0, [ %i0 + 0x44 ]
fs_info->vol.free_cls -= (*cls_added);
20186d8: c4 06 c0 00 ld [ %i3 ], %g2 <== NOT EXECUTED
20186dc: 82 20 40 02 sub %g1, %g2, %g1 <== NOT EXECUTED
20186e0: c2 26 20 40 st %g1, [ %i0 + 0x40 ] <== NOT EXECUTED
*last_cl = save_cln;
20186e4: e0 27 00 00 st %l0, [ %i4 ]
fat_buf_release(fs_info);
20186e8: 7f ff e4 c7 call 2011a04 <fat_buf_release>
20186ec: 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;
}
20186f0: 81 c7 e0 08 ret
20186f4: 91 e8 00 11 restore %g0, %l1, %o0
fat_buf_release(fs_info);
return rc;
}
}
i++;
cl4find++;
20186f8: a0 04 20 01 inc %l0
if (cl4find >= data_cls_val)
20186fc: 80 a4 00 14 cmp %l0, %l4
2018700: 0a 80 00 03 bcs 201870c <fat_scan_fat_for_free_clusters+0x1c4><== ALWAYS TAKEN
2018704: a6 04 e0 01 inc %l3
cl4find = 2;
2018708: 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)
201870c: 80 a4 c0 14 cmp %l3, %l4
2018710: 0a bf ff 9d bcs 2018584 <fat_scan_fat_for_free_clusters+0x3c><== ALWAYS TAKEN
2018714: 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)
2018718: c2 06 20 40 ld [ %i0 + 0x40 ], %g1 <== NOT EXECUTED
201871c: 80 a0 7f ff cmp %g1, -1 <== NOT EXECUTED
2018720: 02 80 00 05 be 2018734 <fat_scan_fat_for_free_clusters+0x1ec><== NOT EXECUTED
2018724: e4 26 20 44 st %l2, [ %i0 + 0x44 ] <== NOT EXECUTED
fs_info->vol.free_cls -= (*cls_added);
2018728: c4 06 c0 00 ld [ %i3 ], %g2 <== NOT EXECUTED
201872c: 82 20 40 02 sub %g1, %g2, %g1 <== NOT EXECUTED
2018730: c2 26 20 40 st %g1, [ %i0 + 0x40 ] <== NOT EXECUTED
*last_cl = save_cln;
2018734: e4 27 00 00 st %l2, [ %i4 ] <== NOT EXECUTED
fat_buf_release(fs_info);
2018738: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
201873c: 7f ff e4 b2 call 2011a04 <fat_buf_release> <== NOT EXECUTED
2018740: 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;
}
2018744: 81 c7 e0 08 ret <== NOT EXECUTED
2018748: 91 e8 00 11 restore %g0, %l1, %o0 <== NOT EXECUTED
return RC_OK;
cleanup:
/* cleanup activity */
fat_free_fat_clusters_chain(fs_info, (*chain));
201874c: 7f ff ff 50 call 201848c <fat_free_fat_clusters_chain> <== NOT EXECUTED
2018750: 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);
2018754: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED
2018758: 94 10 20 00 clr %o2 <== NOT EXECUTED
201875c: 7f ff fe 9d call 20181d0 <fat_set_fat_cluster> <== NOT EXECUTED
2018760: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
fat_buf_release(fs_info);
2018764: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
2018768: 7f ff e4 a7 call 2011a04 <fat_buf_release> <== NOT EXECUTED
201876c: a2 10 00 12 mov %l2, %l1 <== NOT EXECUTED
return rc;
}
2018770: 81 c7 e0 08 ret <== NOT EXECUTED
2018774: 91 e8 00 11 restore %g0, %l1, %o0 <== NOT EXECUTED
2018778: b0 10 00 11 mov %l1, %i0 <== NOT EXECUTED
201877c: 81 c7 e0 08 ret <== NOT EXECUTED
2018780: 81 e8 00 00 restore <== NOT EXECUTED
020181d0 <fat_set_fat_cluster>:
fat_set_fat_cluster(
fat_fs_info_t *fs_info,
uint32_t cln,
uint32_t in_val
)
{
20181d0: 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;
20181d4: c0 27 bf fc clr [ %fp + -4 ]
/* sanity check */
if ( (cln < 2) || (cln > (fs_info->vol.data_cls + 1)) )
20181d8: 80 a6 60 01 cmp %i1, 1
20181dc: 08 80 00 a6 bleu 2018474 <fat_set_fat_cluster+0x2a4> <== NEVER TAKEN
20181e0: ba 10 00 18 mov %i0, %i5
20181e4: c2 06 20 34 ld [ %i0 + 0x34 ], %g1
20181e8: 82 00 60 01 inc %g1
20181ec: 80 a6 40 01 cmp %i1, %g1
20181f0: 28 80 00 03 bleu,a 20181fc <fat_set_fat_cluster+0x2c> <== ALWAYS TAKEN
20181f4: c2 0e 20 0a ldub [ %i0 + 0xa ], %g1
20181f8: 30 80 00 9f b,a 2018474 <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) +
20181fc: 84 08 60 01 and %g1, 1, %g2
2018200: 80 88 a0 ff btst 0xff, %g2
2018204: 02 80 00 05 be 2018218 <fat_set_fat_cluster+0x48> <== NEVER TAKEN
2018208: 86 08 60 02 and %g1, 2, %g3
201820c: a1 36 60 01 srl %i1, 1, %l0
2018210: 10 80 00 06 b 2018228 <fat_set_fat_cluster+0x58>
2018214: a0 04 00 19 add %l0, %i1, %l0
2018218: 80 88 e0 ff btst 0xff, %g3 <== NOT EXECUTED
201821c: 02 80 00 03 be 2018228 <fat_set_fat_cluster+0x58> <== NOT EXECUTED
2018220: a1 2e 60 02 sll %i1, 2, %l0 <== NOT EXECUTED
2018224: a1 2e 60 01 sll %i1, 1, %l0 <== NOT EXECUTED
2018228: 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);
201822c: 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) +
2018230: a1 34 00 03 srl %l0, %g3, %l0
2018234: 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);
2018238: 02 80 00 05 be 201824c <fat_set_fat_cluster+0x7c> <== NEVER TAKEN
201823c: a0 04 00 03 add %l0, %g3, %l0
2018240: b7 36 60 01 srl %i1, 1, %i3
2018244: 10 80 00 07 b 2018260 <fat_set_fat_cluster+0x90>
2018248: b6 06 c0 19 add %i3, %i1, %i3
201824c: 82 08 60 02 and %g1, 2, %g1 <== NOT EXECUTED
2018250: 80 88 60 ff btst 0xff, %g1 <== NOT EXECUTED
2018254: 02 80 00 03 be 2018260 <fat_set_fat_cluster+0x90> <== NOT EXECUTED
2018258: b7 2e 60 02 sll %i1, 2, %i3 <== NOT EXECUTED
201825c: b7 2e 60 01 sll %i1, 1, %i3 <== NOT EXECUTED
2018260: f8 17 40 00 lduh [ %i5 ], %i4
rc = fat_buf_access(fs_info, sec, FAT_OP_TYPE_READ, &block0);
2018264: 90 10 00 1d mov %i5, %o0
2018268: 92 10 00 10 mov %l0, %o1
201826c: 94 10 20 01 mov 1, %o2
2018270: 7f ff e5 68 call 2011810 <fat_buf_access>
2018274: 96 07 bf fc add %fp, -4, %o3
if (rc != RC_OK)
2018278: b0 92 20 00 orcc %o0, 0, %i0
201827c: 12 80 00 56 bne 20183d4 <fat_set_fat_cluster+0x204> <== NEVER TAKEN
2018280: 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);
2018284: b9 37 20 10 srl %i4, 0x10, %i4
2018288: b8 07 3f ff add %i4, -1, %i4
201828c: 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 )
2018290: f6 0f 60 0a ldub [ %i5 + 0xa ], %i3
2018294: 80 a6 e0 02 cmp %i3, 2
2018298: 02 80 00 5f be 2018414 <fat_set_fat_cluster+0x244> <== NEVER TAKEN
201829c: 80 a6 e0 04 cmp %i3, 4
20182a0: 02 80 00 68 be 2018440 <fat_set_fat_cluster+0x270> <== NEVER TAKEN
20182a4: 80 a6 e0 01 cmp %i3, 1
20182a8: 12 80 00 73 bne 2018474 <fat_set_fat_cluster+0x2a4> <== NEVER TAKEN
20182ac: 80 8e 60 01 btst 1, %i1
{
case FAT_FAT12:
if ( FAT_CLUSTER_IS_ODD(cln) )
20182b0: 02 80 00 29 be 2018354 <fat_set_fat_cluster+0x184>
20182b4: 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;
20182b8: 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)) =
20182bc: c4 08 40 1c ldub [ %g1 + %i4 ], %g2
20182c0: 84 08 a0 0f and %g2, 0xf, %g2
20182c4: c4 28 40 1c stb %g2, [ %g1 + %i4 ]
(*((uint8_t *)(block0->buffer + ofs))) & 0x0F;
*((uint8_t *)(block0->buffer + ofs)) =
(*((uint8_t *)(block0->buffer + ofs))) |
20182c8: 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)) =
20182cc: 85 2e a0 04 sll %i2, 4, %g2
(*((uint8_t *)(block0->buffer + ofs))) |
20182d0: 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)) =
20182d4: c6 08 40 1c ldub [ %g1 + %i4 ], %g3
20182d8: 84 10 c0 02 or %g3, %g2, %g2
20182dc: 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) )
20182e0: c2 17 40 00 lduh [ %i5 ], %g1
20182e4: 82 00 7f ff add %g1, -1, %g1
20182e8: 80 a7 00 01 cmp %i4, %g1
20182ec: 12 80 00 11 bne 2018330 <fat_set_fat_cluster+0x160> <== ALWAYS TAKEN
20182f0: f6 2f 60 7c stb %i3, [ %i5 + 0x7c ]
{
rc = fat_buf_access(fs_info, sec + 1, FAT_OP_TYPE_READ,
20182f4: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
20182f8: 92 04 20 01 add %l0, 1, %o1 <== NOT EXECUTED
20182fc: 94 10 20 01 mov 1, %o2 <== NOT EXECUTED
2018300: 7f ff e5 44 call 2011810 <fat_buf_access> <== NOT EXECUTED
2018304: 96 07 bf fc add %fp, -4, %o3 <== NOT EXECUTED
&block0);
if (rc != RC_OK)
2018308: b0 92 20 00 orcc %o0, 0, %i0 <== NOT EXECUTED
201830c: 12 80 00 32 bne 20183d4 <fat_set_fat_cluster+0x204> <== NOT EXECUTED
2018310: 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);
2018314: 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;
2018318: c2 00 60 1c ld [ %g1 + 0x1c ], %g1 <== NOT EXECUTED
*((uint8_t *)(block0->buffer)) =
(*((uint8_t *)(block0->buffer))) |
(uint8_t )((fat16_clv & 0xFF00)>>8);
201831c: 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;
2018320: c0 28 40 00 clrb [ %g1 ] <== NOT EXECUTED
*((uint8_t *)(block0->buffer)) =
(*((uint8_t *)(block0->buffer))) |
2018324: c2 07 bf fc ld [ %fp + -4 ], %g1 <== NOT EXECUTED
2018328: 10 80 00 27 b 20183c4 <fat_set_fat_cluster+0x1f4> <== NOT EXECUTED
201832c: c2 00 60 1c ld [ %g1 + 0x1c ], %g1 <== NOT EXECUTED
fat_buf_mark_modified(fs_info);
}
else
{
*((uint8_t *)(block0->buffer + ofs + 1)) &= 0x00;
2018330: c2 07 bf fc ld [ %fp + -4 ], %g1
2018334: b8 07 20 01 inc %i4
2018338: 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);
201833c: b5 2e a0 14 sll %i2, 0x14, %i2
fat_buf_mark_modified(fs_info);
}
else
{
*((uint8_t *)(block0->buffer + ofs + 1)) &= 0x00;
2018340: c0 28 40 1c clrb [ %g1 + %i4 ]
*((uint8_t *)(block0->buffer + ofs + 1)) =
(*((uint8_t *)(block0->buffer + ofs + 1))) |
2018344: c2 07 bf fc ld [ %fp + -4 ], %g1
(uint8_t )((fat16_clv & 0xFF00)>>8);
2018348: 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))) |
201834c: 10 80 00 2d b 2018400 <fat_set_fat_cluster+0x230>
2018350: c2 00 60 1c ld [ %g1 + 0x1c ], %g1
}
}
else
{
fat16_clv = ((uint16_t )in_val) & FAT_FAT12_MASK;
*((uint8_t *)(block0->buffer + ofs)) &= 0x00;
2018354: c2 00 60 1c ld [ %g1 + 0x1c ], %g1
(uint8_t )((fat16_clv & 0xFF00)>>8);
}
}
else
{
fat16_clv = ((uint16_t )in_val) & FAT_FAT12_MASK;
2018358: b4 0e af ff and %i2, 0xfff, %i2
*((uint8_t *)(block0->buffer + ofs)) &= 0x00;
201835c: c0 28 40 1c clrb [ %g1 + %i4 ]
*((uint8_t *)(block0->buffer + ofs)) =
(*((uint8_t *)(block0->buffer + ofs))) |
2018360: c2 07 bf fc ld [ %fp + -4 ], %g1
2018364: 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)) =
2018368: c4 08 40 1c ldub [ %g1 + %i4 ], %g2
201836c: 84 10 80 1a or %g2, %i2, %g2
2018370: 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) )
2018374: c2 17 40 00 lduh [ %i5 ], %g1
2018378: 82 00 7f ff add %g1, -1, %g1
201837c: 80 a7 00 01 cmp %i4, %g1
2018380: 12 80 00 17 bne 20183dc <fat_set_fat_cluster+0x20c> <== ALWAYS TAKEN
2018384: f6 2f 60 7c stb %i3, [ %i5 + 0x7c ]
{
rc = fat_buf_access(fs_info, sec + 1, FAT_OP_TYPE_READ,
2018388: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
201838c: 92 04 20 01 add %l0, 1, %o1 <== NOT EXECUTED
2018390: 94 10 20 01 mov 1, %o2 <== NOT EXECUTED
2018394: 7f ff e5 1f call 2011810 <fat_buf_access> <== NOT EXECUTED
2018398: 96 07 bf fc add %fp, -4, %o3 <== NOT EXECUTED
&block0);
if (rc != RC_OK)
201839c: b0 92 20 00 orcc %o0, 0, %i0 <== NOT EXECUTED
20183a0: 12 80 00 0d bne 20183d4 <fat_set_fat_cluster+0x204> <== NOT EXECUTED
20183a4: 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);
20183a8: 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;
20183ac: 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)) =
20183b0: c4 08 40 00 ldub [ %g1 ], %g2 <== NOT EXECUTED
20183b4: 84 08 bf f0 and %g2, -16, %g2 <== NOT EXECUTED
20183b8: c4 28 40 00 stb %g2, [ %g1 ] <== NOT EXECUTED
(*((uint8_t *)(block0->buffer))) & 0xF0;
*((uint8_t *)(block0->buffer)) =
(*((uint8_t *)(block0->buffer))) |
20183bc: c2 07 bf fc ld [ %fp + -4 ], %g1 <== NOT EXECUTED
20183c0: 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)) =
20183c4: c4 08 40 00 ldub [ %g1 ], %g2 <== NOT EXECUTED
20183c8: b4 16 80 02 or %i2, %g2, %i2 <== NOT EXECUTED
20183cc: 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;
20183d0: f6 2f 60 7c stb %i3, [ %i5 + 0x7c ] <== NOT EXECUTED
20183d4: 81 c7 e0 08 ret <== NOT EXECUTED
20183d8: 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;
20183dc: c2 07 bf fc ld [ %fp + -4 ], %g1
20183e0: b8 07 20 01 inc %i4
20183e4: 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);
20183e8: b5 36 a0 08 srl %i2, 8, %i2
fat_buf_mark_modified(fs_info);
}
else
{
*((uint8_t *)(block0->buffer + ofs + 1)) =
20183ec: c4 08 40 1c ldub [ %g1 + %i4 ], %g2
20183f0: 84 08 bf f0 and %g2, -16, %g2
20183f4: 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))) |
20183f8: c2 07 bf fc ld [ %fp + -4 ], %g1
20183fc: 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)) =
2018400: c4 08 40 1c ldub [ %g1 + %i4 ], %g2
2018404: b4 10 80 1a or %g2, %i2, %i2
2018408: f4 28 40 1c stb %i2, [ %g1 + %i4 ]
201840c: 81 c7 e0 08 ret
2018410: 81 e8 00 00 restore
}
}
break;
case FAT_FAT16:
*((uint16_t *)(block0->buffer + ofs)) =
2018414: c2 07 bf fc ld [ %fp + -4 ], %g1 <== NOT EXECUTED
break;
}
return RC_OK;
}
2018418: 05 00 00 3f sethi %hi(0xfc00), %g2 <== NOT EXECUTED
}
}
break;
case FAT_FAT16:
*((uint16_t *)(block0->buffer + ofs)) =
201841c: c2 00 60 1c ld [ %g1 + 0x1c ], %g1 <== NOT EXECUTED
break;
}
return RC_OK;
}
2018420: 84 10 a3 ff or %g2, 0x3ff, %g2 <== NOT EXECUTED
2018424: 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));
2018428: b5 2e a0 10 sll %i2, 0x10, %i2 <== NOT EXECUTED
201842c: 85 28 a0 08 sll %g2, 8, %g2 <== NOT EXECUTED
2018430: b5 36 a0 18 srl %i2, 0x18, %i2 <== NOT EXECUTED
2018434: b4 10 80 1a or %g2, %i2, %i2 <== NOT EXECUTED
}
}
break;
case FAT_FAT16:
*((uint16_t *)(block0->buffer + ofs)) =
2018438: 10 80 00 0b b 2018464 <fat_set_fat_cluster+0x294> <== NOT EXECUTED
201843c: 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));
2018440: 11 3c 00 00 sethi %hi(0xf0000000), %o0 <== NOT EXECUTED
2018444: 7f ff fe e0 call 2017fc4 <CPU_swap_u32> <== NOT EXECUTED
2018448: 90 2e 80 08 andn %i2, %o0, %o0 <== NOT EXECUTED
*((uint32_t *)(block0->buffer + ofs)) =
(*((uint32_t *)(block0->buffer + ofs))) & (CT_LE_L(0xF0000000));
201844c: c2 07 bf fc ld [ %fp + -4 ], %g1 <== NOT EXECUTED
2018450: c2 00 60 1c ld [ %g1 + 0x1c ], %g1 <== NOT EXECUTED
2018454: c4 00 40 1c ld [ %g1 + %i4 ], %g2 <== NOT EXECUTED
2018458: 84 08 a0 f0 and %g2, 0xf0, %g2 <== NOT EXECUTED
*((uint32_t *)(block0->buffer + ofs)) =
fat32_clv | (*((uint32_t *)(block0->buffer + ofs)));
201845c: 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)) =
2018460: d0 20 40 1c st %o0, [ %g1 + %i4 ] <== NOT EXECUTED
2018464: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED
2018468: c2 2f 60 7c stb %g1, [ %i5 + 0x7c ] <== NOT EXECUTED
201846c: 81 c7 e0 08 ret <== NOT EXECUTED
2018470: 81 e8 00 00 restore <== NOT EXECUTED
fat_buf_mark_modified(fs_info);
break;
default:
rtems_set_errno_and_return_minus_one(EIO);
2018474: 40 00 06 eb call 201a020 <__errno> <== NOT EXECUTED
2018478: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
201847c: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
2018480: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
break;
}
return RC_OK;
}
2018484: 81 c7 e0 08 ret <== NOT EXECUTED
2018488: 81 e8 00 00 restore <== NOT EXECUTED
02011fe4 <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)
{
2011fe4: 9d e3 bf a0 save %sp, -96, %sp
int rc = RC_OK;
int i = 0;
if (fs_info->vol.type & FAT_FAT32)
2011fe8: 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)
{
2011fec: ba 10 00 18 mov %i0, %i5
int rc = RC_OK;
int i = 0;
if (fs_info->vol.type & FAT_FAT32)
2011ff0: 82 08 60 04 and %g1, 4, %g1
2011ff4: 80 88 60 ff btst 0xff, %g1
2011ff8: 02 80 00 09 be 201201c <fat_shutdown_drive+0x38> <== ALWAYS TAKEN
2011ffc: b0 10 20 00 clr %i0
{
rc = fat_fat32_update_fsinfo_sector(fs_info, fs_info->vol.free_cls,
2012000: d2 07 60 40 ld [ %i5 + 0x40 ], %o1 <== NOT EXECUTED
2012004: d4 07 60 44 ld [ %i5 + 0x44 ], %o2 <== NOT EXECUTED
2012008: 7f ff ff db call 2011f74 <fat_fat32_update_fsinfo_sector> <== NOT EXECUTED
201200c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
fs_info->vol.next_cl);
if ( rc != RC_OK )
2012010: b0 92 20 00 orcc %o0, 0, %i0 <== NOT EXECUTED
2012014: 32 80 00 02 bne,a 201201c <fat_shutdown_drive+0x38> <== NOT EXECUTED
2012018: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
rc = -1;
}
fat_buf_release(fs_info);
201201c: 7f ff fe 7a call 2011a04 <fat_buf_release>
2012020: 90 10 00 1d mov %i5, %o0
if (rtems_bdbuf_syncdev(fs_info->vol.dd) != RTEMS_SUCCESSFUL)
2012024: 7f ff f8 f3 call 20103f0 <rtems_bdbuf_syncdev>
2012028: d0 07 60 58 ld [ %i5 + 0x58 ], %o0
201202c: 80 a2 20 00 cmp %o0, 0
2012030: 32 80 00 02 bne,a 2012038 <fat_shutdown_drive+0x54> <== NEVER TAKEN
2012034: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
rc = -1;
2012038: 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;
201203c: f6 07 60 60 ld [ %i5 + 0x60 ], %i3
while ( (node = rtems_chain_get(the_chain)) != NULL )
2012040: 10 80 00 04 b 2012050 <fat_shutdown_drive+0x6c>
2012044: b6 06 c0 1c add %i3, %i4, %i3
free(node);
2012048: 7f ff c9 6d call 20045fc <free> <== NOT EXECUTED
201204c: 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 );
2012050: 7f ff de 13 call 200989c <_Chain_Get>
2012054: 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 )
2012058: 80 a2 20 00 cmp %o0, 0
201205c: 12 bf ff fb bne 2012048 <fat_shutdown_drive+0x64> <== NEVER TAKEN
2012060: 01 00 00 00 nop
2012064: 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++)
2012068: 80 a7 20 18 cmp %i4, 0x18
201206c: 32 bf ff f5 bne,a 2012040 <fat_shutdown_drive+0x5c>
2012070: f6 07 60 60 ld [ %i5 + 0x60 ], %i3
2012074: 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;
2012078: f6 07 60 64 ld [ %i5 + 0x64 ], %i3
while ( (node = rtems_chain_get(the_chain)) != NULL )
201207c: 10 80 00 04 b 201208c <fat_shutdown_drive+0xa8>
2012080: b6 06 c0 1c add %i3, %i4, %i3
free(node);
2012084: 7f ff c9 5e call 20045fc <free> <== NOT EXECUTED
2012088: 01 00 00 00 nop <== NOT EXECUTED
201208c: 7f ff de 04 call 200989c <_Chain_Get>
2012090: 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 )
2012094: 80 a2 20 00 cmp %o0, 0
2012098: 12 bf ff fb bne 2012084 <fat_shutdown_drive+0xa0> <== NEVER TAKEN
201209c: 01 00 00 00 nop
20120a0: 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++)
20120a4: 80 a7 20 18 cmp %i4, 0x18
20120a8: 32 bf ff f5 bne,a 201207c <fat_shutdown_drive+0x98>
20120ac: f6 07 60 64 ld [ %i5 + 0x64 ], %i3
while ( (node = rtems_chain_get(the_chain)) != NULL )
free(node);
}
free(fs_info->vhash);
20120b0: 7f ff c9 53 call 20045fc <free>
20120b4: d0 07 60 60 ld [ %i5 + 0x60 ], %o0
free(fs_info->rhash);
20120b8: 7f ff c9 51 call 20045fc <free>
20120bc: d0 07 60 64 ld [ %i5 + 0x64 ], %o0
free(fs_info->uino);
20120c0: 7f ff c9 4f call 20045fc <free>
20120c4: d0 07 60 68 ld [ %i5 + 0x68 ], %o0
free(fs_info->sec_buf);
20120c8: 7f ff c9 4d call 20045fc <free>
20120cc: d0 07 60 84 ld [ %i5 + 0x84 ], %o0
close(fs_info->vol.fd);
20120d0: 7f ff c8 8d call 2004304 <close>
20120d4: d0 07 60 54 ld [ %i5 + 0x54 ], %o0
if (rc)
20120d8: 80 a6 20 00 cmp %i0, 0
20120dc: 02 80 00 06 be 20120f4 <fat_shutdown_drive+0x110> <== ALWAYS TAKEN
20120e0: 01 00 00 00 nop
errno = EIO;
20120e4: 40 00 1f cf call 201a020 <__errno> <== NOT EXECUTED
20120e8: 01 00 00 00 nop <== NOT EXECUTED
20120ec: 82 10 20 05 mov 5, %g1 ! 5 <PROM_START+0x5> <== NOT EXECUTED
20120f0: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
return rc;
}
20120f4: 81 c7 e0 08 ret
20120f8: 81 e8 00 00 restore
02032528 <fchdir>:
#include <unistd.h>
#include <rtems/libio_.h>
int fchdir( int fd )
{
2032528: 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 );
203252c: 03 00 81 76 sethi %hi(0x205d800), %g1
2032530: c2 00 63 3c ld [ %g1 + 0x33c ], %g1 ! 205db3c <rtems_libio_number_iops>
int rv = 0;
rtems_libio_t *iop;
struct stat st;
rtems_filesystem_location_info_t loc;
st.st_mode = 0;
2032534: c0 27 bf c4 clr [ %fp + -60 ]
st.st_uid = 0;
2032538: c0 37 bf ca clrh [ %fp + -54 ]
st.st_gid = 0;
rtems_libio_check_fd( fd );
203253c: 80 a6 00 01 cmp %i0, %g1
2032540: 1a 80 00 0c bcc 2032570 <fchdir+0x48>
2032544: c0 37 bf cc clrh [ %fp + -52 ]
iop = rtems_libio_iop( fd );
2032548: 83 2e 20 03 sll %i0, 3, %g1
203254c: b1 2e 20 06 sll %i0, 6, %i0
2032550: b0 26 00 01 sub %i0, %g1, %i0
2032554: 03 00 81 87 sethi %hi(0x2061c00), %g1
2032558: fa 00 61 c0 ld [ %g1 + 0x1c0 ], %i5 ! 2061dc0 <rtems_libio_iops>
203255c: ba 07 40 18 add %i5, %i0, %i5
rtems_libio_check_is_open( iop );
2032560: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
2032564: 80 88 61 00 btst 0x100, %g1
2032568: 32 80 00 08 bne,a 2032588 <fchdir+0x60>
203256c: d0 07 60 28 ld [ %i5 + 0x28 ], %o0
2032570: 40 00 10 83 call 203677c <__errno>
2032574: b0 10 3f ff mov -1, %i0
2032578: 82 10 20 09 mov 9, %g1
203257c: c2 22 00 00 st %g1, [ %o0 ]
2032580: 81 c7 e0 08 ret
2032584: 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 );
2032588: c2 02 20 0c ld [ %o0 + 0xc ], %g1
203258c: c2 00 40 00 ld [ %g1 ], %g1
2032590: 9f c0 40 00 call %g1
2032594: b8 07 60 14 add %i5, 0x14, %i4
rtems_filesystem_instance_lock( &iop->pathinfo );
rv = (*iop->pathinfo.handlers->fstat_h)( &iop->pathinfo, &st );
2032598: c2 07 60 24 ld [ %i5 + 0x24 ], %g1
203259c: 90 10 00 1c mov %i4, %o0
20325a0: c2 00 60 18 ld [ %g1 + 0x18 ], %g1
20325a4: 9f c0 40 00 call %g1
20325a8: 92 07 bf b8 add %fp, -72, %o1
if ( rv == 0 ) {
20325ac: b0 92 20 00 orcc %o0, 0, %i0
20325b0: 32 80 00 13 bne,a 20325fc <fchdir+0xd4> <== NEVER TAKEN
20325b4: d0 07 60 28 ld [ %i5 + 0x28 ], %o0 <== NOT EXECUTED
bool access_ok = rtems_filesystem_check_access(
20325b8: d2 07 bf c4 ld [ %fp + -60 ], %o1
20325bc: d4 17 bf ca lduh [ %fp + -54 ], %o2
20325c0: d6 17 bf cc lduh [ %fp + -52 ], %o3
20325c4: 7f ff 6f 85 call 200e3d8 <rtems_filesystem_check_access>
20325c8: 90 10 20 01 mov 1, %o0
st.st_mode,
st.st_uid,
st.st_gid
);
if ( access_ok ) {
20325cc: 80 8a 20 ff btst 0xff, %o0
20325d0: 02 80 00 06 be 20325e8 <fchdir+0xc0>
20325d4: 90 07 bf a0 add %fp, -96, %o0
rtems_filesystem_location_clone( &loc, &iop->pathinfo );
20325d8: 7f ff 6e 40 call 200ded8 <rtems_filesystem_location_clone>
20325dc: 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;
20325e0: 10 80 00 07 b 20325fc <fchdir+0xd4>
20325e4: d0 07 60 28 ld [ %i5 + 0x28 ], %o0
} else {
errno = EACCES;
20325e8: 40 00 10 65 call 203677c <__errno>
20325ec: b0 10 3f ff mov -1, %i0
20325f0: 82 10 20 0d mov 0xd, %g1
20325f4: c2 22 00 00 st %g1, [ %o0 ]
20325f8: d0 07 60 28 ld [ %i5 + 0x28 ], %o0
(*mt_entry->ops->unlock_h)( mt_entry );
20325fc: c2 02 20 0c ld [ %o0 + 0xc ], %g1
2032600: c2 00 60 04 ld [ %g1 + 4 ], %g1
2032604: 9f c0 40 00 call %g1
2032608: 01 00 00 00 nop
rv = -1;
}
}
rtems_filesystem_instance_unlock( &iop->pathinfo );
if ( rv == 0 ) {
203260c: 80 a6 20 00 cmp %i0, 0
2032610: 12 80 00 05 bne 2032624 <fchdir+0xfc>
2032614: 01 00 00 00 nop
rv = rtems_filesystem_chdir( &loc );
2032618: 7f ff c4 32 call 20236e0 <rtems_filesystem_chdir>
203261c: 90 07 bf a0 add %fp, -96, %o0
2032620: b0 10 00 08 mov %o0, %i0
}
return rv;
}
2032624: 81 c7 e0 08 ret
2032628: 81 e8 00 00 restore
020239c8 <fchmod>:
#include <sys/stat.h>
#include <rtems/libio_.h>
int fchmod( int fd, mode_t mode )
{
20239c8: 9d e3 bf a0 save %sp, -96, %sp
int rv;
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
20239cc: 03 00 81 76 sethi %hi(0x205d800), %g1
20239d0: c2 00 63 3c ld [ %g1 + 0x33c ], %g1 ! 205db3c <rtems_libio_number_iops>
20239d4: 80 a6 00 01 cmp %i0, %g1
20239d8: 2a 80 00 03 bcs,a 20239e4 <fchmod+0x1c>
20239dc: 83 2e 20 03 sll %i0, 3, %g1
20239e0: 30 80 00 0a b,a 2023a08 <fchmod+0x40>
iop = rtems_libio_iop( fd );
20239e4: b1 2e 20 06 sll %i0, 6, %i0
20239e8: b0 26 00 01 sub %i0, %g1, %i0
20239ec: 03 00 81 87 sethi %hi(0x2061c00), %g1
20239f0: fa 00 61 c0 ld [ %g1 + 0x1c0 ], %i5 ! 2061dc0 <rtems_libio_iops>
20239f4: ba 07 40 18 add %i5, %i0, %i5
rtems_libio_check_is_open(iop);
20239f8: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
20239fc: 80 88 61 00 btst 0x100, %g1
2023a00: 32 80 00 06 bne,a 2023a18 <fchmod+0x50>
2023a04: d0 07 60 28 ld [ %i5 + 0x28 ], %o0
2023a08: 40 00 4b 5d call 203677c <__errno>
2023a0c: 01 00 00 00 nop
2023a10: 10 80 00 1b b 2023a7c <fchmod+0xb4>
2023a14: 82 10 20 09 mov 9, %g1 ! 9 <PROM_START+0x9>
if (iop->pathinfo.mt_entry->writeable) {
2023a18: c2 0a 20 29 ldub [ %o0 + 0x29 ], %g1
2023a1c: 80 a0 60 00 cmp %g1, 0
2023a20: 02 80 00 14 be 2023a70 <fchmod+0xa8> <== NEVER TAKEN
2023a24: 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 );
2023a28: c2 02 20 0c ld [ %o0 + 0xc ], %g1
2023a2c: c2 00 40 00 ld [ %g1 ], %g1
2023a30: 9f c0 40 00 call %g1
2023a34: 01 00 00 00 nop
rtems_filesystem_instance_lock( &iop->pathinfo );
rv = (*iop->pathinfo.mt_entry->ops->fchmod_h)( &iop->pathinfo, mode );
2023a38: c2 07 60 28 ld [ %i5 + 0x28 ], %g1
2023a3c: 90 07 60 14 add %i5, 0x14, %o0
2023a40: c2 00 60 0c ld [ %g1 + 0xc ], %g1
2023a44: c2 00 60 20 ld [ %g1 + 0x20 ], %g1
2023a48: 9f c0 40 00 call %g1
2023a4c: 92 10 00 19 mov %i1, %o1
2023a50: 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;
2023a54: d0 07 60 28 ld [ %i5 + 0x28 ], %o0
(*mt_entry->ops->unlock_h)( mt_entry );
2023a58: c2 02 20 0c ld [ %o0 + 0xc ], %g1
2023a5c: c2 00 60 04 ld [ %g1 + 4 ], %g1
2023a60: 9f c0 40 00 call %g1
2023a64: 01 00 00 00 nop
2023a68: 81 c7 e0 08 ret
2023a6c: 81 e8 00 00 restore
rtems_filesystem_instance_unlock( &iop->pathinfo );
} else {
errno = EROFS;
2023a70: 40 00 4b 43 call 203677c <__errno> <== NOT EXECUTED
2023a74: 01 00 00 00 nop <== NOT EXECUTED
2023a78: 82 10 20 1e mov 0x1e, %g1 ! 1e <PROM_START+0x1e> <== NOT EXECUTED
2023a7c: c2 22 00 00 st %g1, [ %o0 ]
rv = -1;
}
return rv;
}
2023a80: 81 c7 e0 08 ret
2023a84: 91 e8 3f ff restore %g0, -1, %o0
02023a88 <fchown>:
#include <unistd.h>
#include <rtems/libio_.h>
int fchown( int fd, uid_t owner, gid_t group )
{
2023a88: 9d e3 bf a0 save %sp, -96, %sp
int rv = 0;
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
2023a8c: 03 00 81 76 sethi %hi(0x205d800), %g1
2023a90: c2 00 63 3c ld [ %g1 + 0x33c ], %g1 ! 205db3c <rtems_libio_number_iops>
2023a94: 80 a6 00 01 cmp %i0, %g1
2023a98: 2a 80 00 03 bcs,a 2023aa4 <fchown+0x1c>
2023a9c: 83 2e 20 03 sll %i0, 3, %g1
2023aa0: 30 80 00 0a b,a 2023ac8 <fchown+0x40>
iop = rtems_libio_iop( fd );
2023aa4: b1 2e 20 06 sll %i0, 6, %i0
2023aa8: b0 26 00 01 sub %i0, %g1, %i0
2023aac: 03 00 81 87 sethi %hi(0x2061c00), %g1
2023ab0: fa 00 61 c0 ld [ %g1 + 0x1c0 ], %i5 ! 2061dc0 <rtems_libio_iops>
2023ab4: ba 07 40 18 add %i5, %i0, %i5
rtems_libio_check_is_open(iop);
2023ab8: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
2023abc: 80 88 61 00 btst 0x100, %g1
2023ac0: 32 80 00 06 bne,a 2023ad8 <fchown+0x50>
2023ac4: d0 07 60 28 ld [ %i5 + 0x28 ], %o0
2023ac8: 40 00 4b 2d call 203677c <__errno>
2023acc: 01 00 00 00 nop
2023ad0: 10 80 00 1c b 2023b40 <fchown+0xb8>
2023ad4: 82 10 20 09 mov 9, %g1 ! 9 <PROM_START+0x9>
if (iop->pathinfo.mt_entry->writeable) {
2023ad8: c2 0a 20 29 ldub [ %o0 + 0x29 ], %g1
2023adc: 80 a0 60 00 cmp %g1, 0
2023ae0: 02 80 00 15 be 2023b34 <fchown+0xac> <== NEVER TAKEN
2023ae4: 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 );
2023ae8: c2 02 20 0c ld [ %o0 + 0xc ], %g1
2023aec: c2 00 40 00 ld [ %g1 ], %g1
2023af0: 9f c0 40 00 call %g1
2023af4: 01 00 00 00 nop
rtems_filesystem_instance_lock( &iop->pathinfo );
rv = (*iop->pathinfo.mt_entry->ops->chown_h)(
2023af8: c2 07 60 28 ld [ %i5 + 0x28 ], %g1
2023afc: 90 07 60 14 add %i5, 0x14, %o0
2023b00: c2 00 60 0c ld [ %g1 + 0xc ], %g1
2023b04: 92 10 00 19 mov %i1, %o1
2023b08: c2 00 60 24 ld [ %g1 + 0x24 ], %g1
2023b0c: 9f c0 40 00 call %g1
2023b10: 94 10 00 1a mov %i2, %o2
2023b14: 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;
2023b18: d0 07 60 28 ld [ %i5 + 0x28 ], %o0
(*mt_entry->ops->unlock_h)( mt_entry );
2023b1c: c2 02 20 0c ld [ %o0 + 0xc ], %g1
2023b20: c2 00 60 04 ld [ %g1 + 4 ], %g1
2023b24: 9f c0 40 00 call %g1
2023b28: 01 00 00 00 nop
2023b2c: 81 c7 e0 08 ret
2023b30: 81 e8 00 00 restore
owner,
group
);
rtems_filesystem_instance_unlock( &iop->pathinfo );
} else {
errno = EROFS;
2023b34: 40 00 4b 12 call 203677c <__errno> <== NOT EXECUTED
2023b38: 01 00 00 00 nop <== NOT EXECUTED
2023b3c: 82 10 20 1e mov 0x1e, %g1 ! 1e <PROM_START+0x1e> <== NOT EXECUTED
2023b40: c2 22 00 00 st %g1, [ %o0 ]
rv = -1;
}
return rv;
}
2023b44: 81 c7 e0 08 ret
2023b48: 91 e8 3f ff restore %g0, -1, %o0
0202f908 <fcntl>:
int fcntl(
int fd,
int cmd,
...
)
{
202f908: 9d e3 bf 98 save %sp, -104, %sp
int fd2;
int flags;
int mask;
int ret = 0;
rtems_libio_check_fd( fd );
202f90c: 05 00 80 d7 sethi %hi(0x2035c00), %g2
202f910: c4 00 a2 f8 ld [ %g2 + 0x2f8 ], %g2 ! 2035ef8 <rtems_libio_number_iops>
...
)
{
int ret;
va_list ap;
va_start( ap, cmd );
202f914: 82 07 a0 4c add %fp, 0x4c, %g1
202f918: f4 27 a0 4c st %i2, [ %fp + 0x4c ]
202f91c: f6 27 a0 50 st %i3, [ %fp + 0x50 ]
202f920: f8 27 a0 54 st %i4, [ %fp + 0x54 ]
202f924: fa 27 a0 58 st %i5, [ %fp + 0x58 ]
int fd2;
int flags;
int mask;
int ret = 0;
rtems_libio_check_fd( fd );
202f928: 80 a6 00 02 cmp %i0, %g2
202f92c: 1a 80 00 0c bcc 202f95c <fcntl+0x54>
202f930: c2 27 bf fc st %g1, [ %fp + -4 ]
iop = rtems_libio_iop( fd );
202f934: 85 2e 20 03 sll %i0, 3, %g2
202f938: b1 2e 20 06 sll %i0, 6, %i0
202f93c: b0 26 00 02 sub %i0, %g2, %i0
202f940: 05 00 81 1a sethi %hi(0x2046800), %g2
202f944: fa 00 a3 74 ld [ %g2 + 0x374 ], %i5 ! 2046b74 <rtems_libio_iops>
202f948: ba 07 40 18 add %i5, %i0, %i5
rtems_libio_check_is_open(iop);
202f94c: d0 07 60 10 ld [ %i5 + 0x10 ], %o0
202f950: 80 8a 21 00 btst 0x100, %o0
202f954: 12 80 00 06 bne 202f96c <fcntl+0x64>
202f958: 80 a6 60 09 cmp %i1, 9
202f95c: 7f ff c4 98 call 2020bbc <__errno>
202f960: 01 00 00 00 nop
202f964: 10 80 00 5d b 202fad8 <fcntl+0x1d0>
202f968: 82 10 20 09 mov 9, %g1 ! 9 <PROM_START+0x9>
/*
* This switch should contain all the cases from POSIX.
*/
switch ( cmd ) {
202f96c: 18 80 00 58 bgu 202facc <fcntl+0x1c4>
202f970: 85 2e 60 02 sll %i1, 2, %g2
202f974: 07 00 80 be sethi %hi(0x202f800), %g3
202f978: 86 10 e0 e0 or %g3, 0xe0, %g3 ! 202f8e0 <_calloc_r+0x14>
202f97c: c4 00 c0 02 ld [ %g3 + %g2 ], %g2
202f980: 81 c0 80 00 jmp %g2
202f984: 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();
202f988: 7f ff 63 20 call 2008608 <rtems_libio_allocate>
202f98c: 01 00 00 00 nop
if (diop != NULL) {
202f990: b8 92 20 00 orcc %o0, 0, %i4
202f994: 02 80 00 62 be 202fb1c <fcntl+0x214>
202f998: b0 10 3f ff mov -1, %i0
int oflag = rtems_libio_to_fcntl_flags( iop->flags );
202f99c: 7f ff 63 05 call 20085b0 <rtems_libio_to_fcntl_flags>
202f9a0: d0 07 60 10 ld [ %i5 + 0x10 ], %o0
oflag &= ~O_CREAT;
diop->flags |= rtems_libio_fcntl_flags( oflag );
202f9a4: 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;
202f9a8: b6 0a 3d ff and %o0, -513, %i3
diop->flags |= rtems_libio_fcntl_flags( oflag );
202f9ac: 7f ff 62 f4 call 200857c <rtems_libio_fcntl_flags>
202f9b0: 90 10 00 1b mov %i3, %o0
202f9b4: 90 12 00 1a or %o0, %i2, %o0
202f9b8: 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;
202f9bc: d0 07 60 28 ld [ %i5 + 0x28 ], %o0
(*mt_entry->ops->lock_h)( mt_entry );
202f9c0: c2 02 20 0c ld [ %o0 + 0xc ], %g1
202f9c4: c2 00 40 00 ld [ %g1 ], %g1
202f9c8: 9f c0 40 00 call %g1
202f9cc: 01 00 00 00 nop
rtems_filesystem_instance_lock( &iop->pathinfo );
rtems_filesystem_location_clone( &diop->pathinfo, &iop->pathinfo );
202f9d0: 92 07 60 14 add %i5, 0x14, %o1
202f9d4: 7f ff 9c e6 call 2016d6c <rtems_filesystem_location_clone>
202f9d8: 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;
202f9dc: d0 07 60 28 ld [ %i5 + 0x28 ], %o0
(*mt_entry->ops->unlock_h)( mt_entry );
202f9e0: c2 02 20 0c ld [ %o0 + 0xc ], %g1
202f9e4: c2 00 60 04 ld [ %g1 + 4 ], %g1
202f9e8: 9f c0 40 00 call %g1
202f9ec: 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 );
202f9f0: c2 07 20 24 ld [ %i4 + 0x24 ], %g1
202f9f4: 90 10 00 1c mov %i4, %o0
202f9f8: c2 00 40 00 ld [ %g1 ], %g1
202f9fc: 92 10 20 00 clr %o1
202fa00: 94 10 00 1b mov %i3, %o2
202fa04: 9f c0 40 00 call %g1
202fa08: 96 10 20 00 clr %o3
if ( rv == 0 ) {
202fa0c: b0 92 20 00 orcc %o0, 0, %i0
202fa10: 12 80 00 11 bne 202fa54 <fcntl+0x14c> <== NEVER TAKEN
202fa14: 03 00 81 1a sethi %hi(0x2046800), %g1
rv = diop - rtems_libio_iops;
202fa18: f0 00 63 74 ld [ %g1 + 0x374 ], %i0 ! 2046b74 <rtems_libio_iops>
202fa1c: b8 27 00 18 sub %i4, %i0, %i4
202fa20: b9 3f 20 03 sra %i4, 3, %i4
202fa24: 85 2f 20 03 sll %i4, 3, %g2
202fa28: 83 2f 20 06 sll %i4, 6, %g1
202fa2c: 82 00 80 01 add %g2, %g1, %g1
202fa30: 85 28 60 06 sll %g1, 6, %g2
202fa34: 82 00 40 02 add %g1, %g2, %g1
202fa38: 82 00 40 1c add %g1, %i4, %g1
202fa3c: b1 28 60 0f sll %g1, 0xf, %i0
202fa40: 82 00 40 18 add %g1, %i0, %g1
202fa44: 83 28 60 03 sll %g1, 3, %g1
202fa48: b8 00 40 1c add %g1, %i4, %i4
202fa4c: 10 80 00 25 b 202fae0 <fcntl+0x1d8>
202fa50: b0 20 00 1c neg %i4, %i0
} else {
rtems_libio_free( diop );
202fa54: 7f ff 63 04 call 2008664 <rtems_libio_free> <== NOT EXECUTED
202fa58: 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) {
202fa5c: 10 80 00 22 b 202fae4 <fcntl+0x1dc> <== NOT EXECUTED
202fa60: 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);
202fa64: b1 32 20 0b srl %o0, 0xb, %i0
202fa68: 10 80 00 21 b 202faec <fcntl+0x1e4>
202fa6c: 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 ) )
202fa70: c2 00 40 00 ld [ %g1 ], %g1
202fa74: 80 a0 60 00 cmp %g1, 0
202fa78: 22 80 00 0e be,a 202fab0 <fcntl+0x1a8>
202fa7c: 90 0a 37 ff and %o0, -2049, %o0
iop->flags |= LIBIO_FLAGS_CLOSE_ON_EXEC;
202fa80: 10 80 00 0c b 202fab0 <fcntl+0x1a8>
202fa84: 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 );
202fa88: 7f ff 62 ca call 20085b0 <rtems_libio_to_fcntl_flags>
202fa8c: 01 00 00 00 nop
202fa90: 10 80 00 14 b 202fae0 <fcntl+0x1d8>
202fa94: b0 10 00 08 mov %o0, %i0
break;
case F_SETFL:
flags = rtems_libio_fcntl_flags( va_arg( ap, int ) );
202fa98: 7f ff 62 b9 call 200857c <rtems_libio_fcntl_flags>
202fa9c: 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);
202faa0: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
202faa4: 90 0a 22 01 and %o0, 0x201, %o0
202faa8: 82 08 7d fe and %g1, -514, %g1
202faac: 90 12 00 01 or %o0, %g1, %o0
202fab0: d0 27 60 10 st %o0, [ %i5 + 0x10 ]
{
rtems_libio_t *iop;
int fd2;
int flags;
int mask;
int ret = 0;
202fab4: 10 80 00 0e b 202faec <fcntl+0x1e4>
202fab8: b0 10 20 00 clr %i0
errno = ENOTSUP;
ret = -1;
break;
case F_GETOWN: /* for sockets. */
errno = ENOTSUP;
202fabc: 7f ff c4 40 call 2020bbc <__errno>
202fac0: 01 00 00 00 nop
202fac4: 10 80 00 05 b 202fad8 <fcntl+0x1d0>
202fac8: 82 10 20 86 mov 0x86, %g1 ! 86 <PROM_START+0x86>
ret = -1;
break;
default:
errno = EINVAL;
202facc: 7f ff c4 3c call 2020bbc <__errno>
202fad0: 01 00 00 00 nop
202fad4: 82 10 20 16 mov 0x16, %g1 ! 16 <PROM_START+0x16>
202fad8: 10 80 00 10 b 202fb18 <fcntl+0x210>
202fadc: 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) {
202fae0: 80 a6 20 00 cmp %i0, 0
202fae4: 06 80 00 0e bl 202fb1c <fcntl+0x214> <== NEVER TAKEN
202fae8: 01 00 00 00 nop
int err = (*iop->pathinfo.handlers->fcntl_h)( iop, cmd );
202faec: c2 07 60 24 ld [ %i5 + 0x24 ], %g1
202faf0: 90 10 00 1d mov %i5, %o0
202faf4: c2 00 60 28 ld [ %g1 + 0x28 ], %g1
202faf8: 9f c0 40 00 call %g1
202fafc: 92 10 00 19 mov %i1, %o1
if (err) {
202fb00: ba 92 20 00 orcc %o0, 0, %i5
202fb04: 02 80 00 06 be 202fb1c <fcntl+0x214> <== ALWAYS TAKEN
202fb08: 01 00 00 00 nop
errno = err;
202fb0c: 7f ff c4 2c call 2020bbc <__errno> <== NOT EXECUTED
202fb10: 01 00 00 00 nop <== NOT EXECUTED
202fb14: 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);
202fb18: b0 10 3f ff mov -1, %i0
va_list ap;
va_start( ap, cmd );
ret = vfcntl(fd,cmd,ap);
va_end(ap);
return ret;
}
202fb1c: 81 c7 e0 08 ret
202fb20: 81 e8 00 00 restore
0200de3c <fifo_open>:
*/
int fifo_open(
pipe_control_t **pipep,
rtems_libio_t *iop
)
{
200de3c: 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) {
200de40: 3b 00 80 8d sethi %hi(0x2023400), %i5
200de44: c2 07 61 80 ld [ %i5 + 0x180 ], %g1 ! 2023580 <pipe_semaphore>
*/
int fifo_open(
pipe_control_t **pipep,
rtems_libio_t *iop
)
{
200de48: b6 10 00 18 mov %i0, %i3
static int pipe_lock(void)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
if (pipe_semaphore == RTEMS_ID_NONE) {
200de4c: 80 a0 60 00 cmp %g1, 0
200de50: 02 80 00 0c be 200de80 <fifo_open+0x44>
200de54: b8 17 61 80 or %i5, 0x180, %i4
rtems_libio_unlock();
}
if (sc == RTEMS_SUCCESSFUL) {
sc = rtems_semaphore_obtain(pipe_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
200de58: 03 00 80 8d sethi %hi(0x2023400), %g1
200de5c: d0 00 61 80 ld [ %g1 + 0x180 ], %o0 ! 2023580 <pipe_semaphore>
200de60: 92 10 20 00 clr %o1
200de64: 7f ff ec cb call 2009190 <rtems_semaphore_obtain>
200de68: 94 10 20 00 clr %o2
}
if (sc == RTEMS_SUCCESSFUL) {
200de6c: 80 a2 20 00 cmp %o0, 0
200de70: 22 80 01 00 be,a 200e270 <fifo_open+0x434> <== ALWAYS TAKEN
200de74: fa 06 c0 00 ld [ %i3 ], %i5
return 0;
} else {
return -ENOMEM;
200de78: 81 c7 e0 08 ret <== NOT EXECUTED
200de7c: 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 );
200de80: 03 00 80 8d sethi %hi(0x2023400), %g1
200de84: d0 00 63 ec ld [ %g1 + 0x3ec ], %o0 ! 20237ec <rtems_libio_semaphore>
200de88: 92 10 20 00 clr %o1
200de8c: 7f ff ec c1 call 2009190 <rtems_semaphore_obtain>
200de90: 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) {
200de94: c2 07 61 80 ld [ %i5 + 0x180 ], %g1
200de98: 80 a0 60 00 cmp %g1, 0
200de9c: 12 80 00 0a bne 200dec4 <fifo_open+0x88> <== NEVER TAKEN
200dea0: ba 10 20 00 clr %i5
sc = rtems_semaphore_create(
200dea4: 11 14 12 54 sethi %hi(0x50495000), %o0
200dea8: 92 10 20 01 mov 1, %o1
200deac: 90 12 20 45 or %o0, 0x45, %o0
200deb0: 94 10 20 54 mov 0x54, %o2
200deb4: 96 10 20 00 clr %o3
200deb8: 7f ff ec 18 call 2008f18 <rtems_semaphore_create>
200debc: 98 10 00 1c mov %i4, %o4
200dec0: ba 10 00 08 mov %o0, %i5
}
static inline void rtems_libio_unlock( void )
{
rtems_semaphore_release( rtems_libio_semaphore );
200dec4: 03 00 80 8d sethi %hi(0x2023400), %g1
200dec8: 7f ff ec fc call 20092b8 <rtems_semaphore_release>
200decc: d0 00 63 ec ld [ %g1 + 0x3ec ], %o0 ! 20237ec <rtems_libio_semaphore>
}
rtems_libio_unlock();
}
if (sc == RTEMS_SUCCESSFUL) {
200ded0: 80 a7 60 00 cmp %i5, 0
200ded4: 02 bf ff e1 be 200de58 <fifo_open+0x1c>
200ded8: b0 10 3f f4 mov -12, %i0
200dedc: 81 c7 e0 08 ret
200dee0: 81 e8 00 00 restore
{
static char c = 'a';
pipe_control_t *pipe;
int err = -ENOMEM;
pipe = malloc(sizeof(pipe_control_t));
200dee4: 7f ff dc 08 call 2004f04 <malloc>
200dee8: 90 10 20 34 mov 0x34, %o0
if (pipe == NULL)
200deec: ba 92 20 00 orcc %o0, 0, %i5
200def0: 02 80 00 e4 be 200e280 <fifo_open+0x444> <== NEVER TAKEN
200def4: 92 10 20 00 clr %o1
return err;
memset(pipe, 0, sizeof(pipe_control_t));
200def8: 40 00 13 47 call 2012c14 <memset>
200defc: 94 10 20 34 mov 0x34, %o2
pipe->Size = PIPE_BUF;
200df00: 82 10 22 00 mov 0x200, %g1
pipe->Buffer = malloc(pipe->Size);
200df04: 90 10 22 00 mov 0x200, %o0
200df08: 7f ff db ff call 2004f04 <malloc>
200df0c: c2 27 60 04 st %g1, [ %i5 + 4 ]
if (! pipe->Buffer)
200df10: 80 a2 20 00 cmp %o0, 0
200df14: 02 80 00 40 be 200e014 <fifo_open+0x1d8> <== NEVER TAKEN
200df18: d0 27 40 00 st %o0, [ %i5 ]
goto err_buf;
err = -ENOMEM;
if (rtems_barrier_create(
rtems_build_name ('P', 'I', 'r', c),
200df1c: 39 00 80 8b sethi %hi(0x2022c00), %i4
200df20: d0 4f 22 30 ldsb [ %i4 + 0x230 ], %o0 ! 2022e30 <c.7109>
if (! pipe->Buffer)
goto err_buf;
err = -ENOMEM;
if (rtems_barrier_create(
200df24: 35 14 12 5c sethi %hi(0x50497000), %i2
200df28: 82 16 a2 00 or %i2, 0x200, %g1 ! 50497200 <RAM_END+0x4e097200>
200df2c: 92 10 20 00 clr %o1
200df30: 90 12 00 01 or %o0, %g1, %o0
200df34: 94 10 20 00 clr %o2
200df38: 40 00 05 ea call 200f6e0 <rtems_barrier_create>
200df3c: 96 07 60 2c add %i5, 0x2c, %o3
200df40: 80 a2 20 00 cmp %o0, 0
200df44: 12 80 00 32 bne 200e00c <fifo_open+0x1d0>
200df48: d0 4f 22 30 ldsb [ %i4 + 0x230 ], %o0
rtems_build_name ('P', 'I', 'r', c),
RTEMS_BARRIER_MANUAL_RELEASE, 0,
&pipe->readBarrier) != RTEMS_SUCCESSFUL)
goto err_rbar;
if (rtems_barrier_create(
200df4c: 03 14 12 5d sethi %hi(0x50497400), %g1
200df50: 82 10 63 00 or %g1, 0x300, %g1 ! 50497700 <RAM_END+0x4e097700>
200df54: 92 10 20 00 clr %o1
200df58: 90 12 00 01 or %o0, %g1, %o0
200df5c: 94 10 20 00 clr %o2
200df60: 40 00 05 e0 call 200f6e0 <rtems_barrier_create>
200df64: 96 07 60 30 add %i5, 0x30, %o3
200df68: 80 a2 20 00 cmp %o0, 0
200df6c: 12 80 00 26 bne 200e004 <fifo_open+0x1c8>
200df70: d0 4f 22 30 ldsb [ %i4 + 0x230 ], %o0
rtems_build_name ('P', 'I', 'w', c),
RTEMS_BARRIER_MANUAL_RELEASE, 0,
&pipe->writeBarrier) != RTEMS_SUCCESSFUL)
goto err_wbar;
if (rtems_semaphore_create(
200df74: b4 16 a3 00 or %i2, 0x300, %i2
200df78: 92 10 20 01 mov 1, %o1
200df7c: 90 12 00 1a or %o0, %i2, %o0
200df80: 94 10 20 10 mov 0x10, %o2
200df84: 96 10 20 00 clr %o3
200df88: 7f ff eb e4 call 2008f18 <rtems_semaphore_create>
200df8c: 98 07 60 28 add %i5, 0x28, %o4
200df90: 80 a2 20 00 cmp %o0, 0
200df94: 12 80 00 1a bne 200dffc <fifo_open+0x1c0>
200df98: 94 07 bf fc add %fp, -4, %o2
RTEMS_INLINE_ROUTINE Barrier_Control *_Barrier_Get (
Objects_Id id,
Objects_Locations *location
)
{
return (Barrier_Control *)
200df9c: d2 07 60 2c ld [ %i5 + 0x2c ], %o1
200dfa0: 31 00 80 90 sethi %hi(0x2024000), %i0
200dfa4: 7f ff f2 e9 call 200ab48 <_Objects_Get>
200dfa8: 90 16 22 b0 or %i0, 0x2b0, %o0 ! 20242b0 <_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;
200dfac: c2 02 20 4c ld [ %o0 + 0x4c ], %g1
200dfb0: 35 04 00 00 sethi %hi(0x10000000), %i2
200dfb4: 82 10 40 1a or %g1, %i2, %g1
_Thread_Enable_dispatch();
200dfb8: 7f ff f6 90 call 200b9f8 <_Thread_Enable_dispatch>
200dfbc: c2 22 20 4c st %g1, [ %o0 + 0x4c ]
200dfc0: d2 07 60 30 ld [ %i5 + 0x30 ], %o1
200dfc4: 94 07 bf fc add %fp, -4, %o2
200dfc8: 7f ff f2 e0 call 200ab48 <_Objects_Get>
200dfcc: 90 16 22 b0 or %i0, 0x2b0, %o0
_Barrier_Get(pipe->writeBarrier, &location)->Barrier.Wait_queue.state
|= STATES_INTERRUPTIBLE_BY_SIGNAL;
200dfd0: c2 02 20 4c ld [ %o0 + 0x4c ], %g1
200dfd4: b4 10 40 1a or %g1, %i2, %i2
_Thread_Enable_dispatch();
200dfd8: 7f ff f6 88 call 200b9f8 <_Thread_Enable_dispatch>
200dfdc: f4 22 20 4c st %i2, [ %o0 + 0x4c ]
#ifdef RTEMS_POSIX_API
pipe_interruptible(pipe);
#endif
*pipep = pipe;
if (c ++ == 'z')
200dfe0: c2 0f 22 30 ldub [ %i4 + 0x230 ], %g1
200dfe4: c4 4f 22 30 ldsb [ %i4 + 0x230 ], %g2
200dfe8: 80 a0 a0 7a cmp %g2, 0x7a
200dfec: 12 80 00 a7 bne 200e288 <fifo_open+0x44c>
200dff0: 82 00 60 01 inc %g1
c = 'a';
200dff4: 10 80 00 a5 b 200e288 <fifo_open+0x44c>
200dff8: 82 10 20 61 mov 0x61, %g1
return 0;
err_sem:
rtems_barrier_delete(pipe->writeBarrier);
200dffc: 40 00 05 e9 call 200f7a0 <rtems_barrier_delete>
200e000: d0 07 60 30 ld [ %i5 + 0x30 ], %o0
err_wbar:
rtems_barrier_delete(pipe->readBarrier);
200e004: 40 00 05 e7 call 200f7a0 <rtems_barrier_delete>
200e008: d0 07 60 2c ld [ %i5 + 0x2c ], %o0
err_rbar:
free(pipe->Buffer);
200e00c: 7f ff da 95 call 2004a60 <free>
200e010: d0 07 40 00 ld [ %i5 ], %o0
err_buf:
free(pipe);
200e014: 7f ff da 93 call 2004a60 <free>
200e018: 90 10 00 1d mov %i5, %o0
if (err)
goto out;
}
if (! PIPE_LOCK(pipe))
err = -EINTR;
200e01c: 10 80 00 13 b 200e068 <fifo_open+0x22c>
200e020: b0 10 3f f4 mov -12, %i0
err = pipe_alloc(&pipe);
if (err)
goto out;
}
if (! PIPE_LOCK(pipe))
200e024: d0 07 60 28 ld [ %i5 + 0x28 ], %o0
200e028: 92 10 20 00 clr %o1
200e02c: 7f ff ec 59 call 2009190 <rtems_semaphore_obtain>
200e030: 94 10 20 00 clr %o2
err = -EINTR;
if (*pipep == NULL) {
200e034: c2 06 c0 00 ld [ %i3 ], %g1
err = pipe_alloc(&pipe);
if (err)
goto out;
}
if (! PIPE_LOCK(pipe))
200e038: 80 a0 00 08 cmp %g0, %o0
200e03c: b0 60 20 00 subx %g0, 0, %i0
err = -EINTR;
if (*pipep == NULL) {
200e040: 80 a0 60 00 cmp %g1, 0
200e044: 12 80 00 09 bne 200e068 <fifo_open+0x22c>
200e048: b0 0e 3f fc and %i0, -4, %i0
if (err)
200e04c: 80 a6 20 00 cmp %i0, 0
200e050: 22 80 00 06 be,a 200e068 <fifo_open+0x22c> <== ALWAYS TAKEN
200e054: fa 26 c0 00 st %i5, [ %i3 ]
pipe_free(pipe);
200e058: 7f ff ff 41 call 200dd5c <pipe_free> <== NOT EXECUTED
200e05c: 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);
200e060: 10 80 00 03 b 200e06c <fifo_open+0x230> <== NOT EXECUTED
200e064: 03 00 80 8d sethi %hi(0x2023400), %g1 <== NOT EXECUTED
200e068: 03 00 80 8d sethi %hi(0x2023400), %g1
200e06c: 7f ff ec 93 call 20092b8 <rtems_semaphore_release>
200e070: d0 00 61 80 ld [ %g1 + 0x180 ], %o0 ! 2023580 <pipe_semaphore>
pipe_control_t *pipe;
unsigned int prevCounter;
int err;
err = pipe_new(pipep);
if (err)
200e074: 80 a6 20 00 cmp %i0, 0
200e078: 12 80 00 86 bne 200e290 <fifo_open+0x454>
200e07c: 01 00 00 00 nop
return err;
pipe = *pipep;
switch (LIBIO_ACCMODE(iop)) {
200e080: c2 06 60 10 ld [ %i1 + 0x10 ], %g1
200e084: 82 08 60 06 and %g1, 6, %g1
200e088: 80 a0 60 04 cmp %g1, 4
200e08c: 02 80 00 2e be 200e144 <fifo_open+0x308>
200e090: fa 06 c0 00 ld [ %i3 ], %i5
200e094: 80 a0 60 06 cmp %g1, 6
200e098: 02 80 00 56 be 200e1f0 <fifo_open+0x3b4>
200e09c: 80 a0 60 02 cmp %g1, 2
200e0a0: 12 80 00 6a bne 200e248 <fifo_open+0x40c> <== NEVER TAKEN
200e0a4: 01 00 00 00 nop
case LIBIO_FLAGS_READ:
pipe->readerCounter ++;
200e0a8: c2 07 60 20 ld [ %i5 + 0x20 ], %g1
200e0ac: 82 00 60 01 inc %g1
200e0b0: c2 27 60 20 st %g1, [ %i5 + 0x20 ]
if (pipe->Readers ++ == 0)
200e0b4: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
200e0b8: 84 00 60 01 add %g1, 1, %g2
200e0bc: 80 a0 60 00 cmp %g1, 0
200e0c0: 12 80 00 05 bne 200e0d4 <fifo_open+0x298> <== NEVER TAKEN
200e0c4: c4 27 60 10 st %g2, [ %i5 + 0x10 ]
PIPE_WAKEUPWRITERS(pipe);
200e0c8: d0 07 60 30 ld [ %i5 + 0x30 ], %o0
200e0cc: 40 00 05 de call 200f844 <rtems_barrier_release>
200e0d0: 92 07 bf f8 add %fp, -8, %o1
if (pipe->Writers == 0) {
200e0d4: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
200e0d8: 80 a0 60 00 cmp %g1, 0
200e0dc: 12 80 00 5b bne 200e248 <fifo_open+0x40c>
200e0e0: 01 00 00 00 nop
/* Not an error */
if (LIBIO_NODELAY(iop))
200e0e4: c2 06 60 10 ld [ %i1 + 0x10 ], %g1
200e0e8: 80 88 60 01 btst 1, %g1
200e0ec: 12 80 00 57 bne 200e248 <fifo_open+0x40c>
200e0f0: 01 00 00 00 nop
break;
prevCounter = pipe->writerCounter;
200e0f4: f8 07 60 24 ld [ %i5 + 0x24 ], %i4
err = -EINTR;
/* Wait until a writer opens the pipe */
do {
PIPE_UNLOCK(pipe);
200e0f8: 7f ff ec 70 call 20092b8 <rtems_semaphore_release>
200e0fc: d0 07 60 28 ld [ %i5 + 0x28 ], %o0
if (! PIPE_READWAIT(pipe))
200e100: d0 07 60 2c ld [ %i5 + 0x2c ], %o0
200e104: 40 00 05 e6 call 200f89c <rtems_barrier_wait>
200e108: 92 10 20 00 clr %o1
200e10c: 80 a2 20 00 cmp %o0, 0
200e110: 12 80 00 52 bne 200e258 <fifo_open+0x41c> <== NEVER TAKEN
200e114: 92 10 20 00 clr %o1
goto out_error;
if (! PIPE_LOCK(pipe))
200e118: d0 07 60 28 ld [ %i5 + 0x28 ], %o0
200e11c: 7f ff ec 1d call 2009190 <rtems_semaphore_obtain>
200e120: 94 10 20 00 clr %o2
200e124: 80 a2 20 00 cmp %o0, 0
200e128: 32 80 00 4d bne,a 200e25c <fifo_open+0x420> <== NEVER TAKEN
200e12c: b0 10 3f fc mov -4, %i0 <== NOT EXECUTED
goto out_error;
} while (prevCounter == pipe->writerCounter);
200e130: c2 07 60 24 ld [ %i5 + 0x24 ], %g1
200e134: 80 a7 00 01 cmp %i4, %g1
200e138: 02 bf ff f0 be 200e0f8 <fifo_open+0x2bc> <== NEVER TAKEN
200e13c: 01 00 00 00 nop
200e140: 30 80 00 42 b,a 200e248 <fifo_open+0x40c>
}
break;
case LIBIO_FLAGS_WRITE:
pipe->writerCounter ++;
200e144: c2 07 60 24 ld [ %i5 + 0x24 ], %g1
200e148: 82 00 60 01 inc %g1
200e14c: c2 27 60 24 st %g1, [ %i5 + 0x24 ]
if (pipe->Writers ++ == 0)
200e150: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
200e154: 84 00 60 01 add %g1, 1, %g2
200e158: 80 a0 60 00 cmp %g1, 0
200e15c: 12 80 00 05 bne 200e170 <fifo_open+0x334> <== NEVER TAKEN
200e160: c4 27 60 14 st %g2, [ %i5 + 0x14 ]
PIPE_WAKEUPREADERS(pipe);
200e164: d0 07 60 2c ld [ %i5 + 0x2c ], %o0
200e168: 40 00 05 b7 call 200f844 <rtems_barrier_release>
200e16c: 92 07 bf f8 add %fp, -8, %o1
if (pipe->Readers == 0 && LIBIO_NODELAY(iop)) {
200e170: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
200e174: 80 a0 60 00 cmp %g1, 0
200e178: 12 80 00 34 bne 200e248 <fifo_open+0x40c>
200e17c: 01 00 00 00 nop
200e180: c2 06 60 10 ld [ %i1 + 0x10 ], %g1
200e184: 80 88 60 01 btst 1, %g1
200e188: 22 80 00 07 be,a 200e1a4 <fifo_open+0x368>
200e18c: f8 07 60 20 ld [ %i5 + 0x20 ], %i4
PIPE_UNLOCK(pipe);
200e190: d0 07 60 28 ld [ %i5 + 0x28 ], %o0
200e194: 7f ff ec 49 call 20092b8 <rtems_semaphore_release>
200e198: b0 10 3f fa mov -6, %i0
err = -ENXIO;
goto out_error;
200e19c: 10 80 00 31 b 200e260 <fifo_open+0x424>
200e1a0: 90 10 00 1b mov %i3, %o0
if (pipe->Readers == 0) {
prevCounter = pipe->readerCounter;
err = -EINTR;
do {
PIPE_UNLOCK(pipe);
200e1a4: 7f ff ec 45 call 20092b8 <rtems_semaphore_release>
200e1a8: d0 07 60 28 ld [ %i5 + 0x28 ], %o0
if (! PIPE_WRITEWAIT(pipe))
200e1ac: d0 07 60 30 ld [ %i5 + 0x30 ], %o0
200e1b0: 40 00 05 bb call 200f89c <rtems_barrier_wait>
200e1b4: 92 10 20 00 clr %o1
200e1b8: 80 a2 20 00 cmp %o0, 0
200e1bc: 12 80 00 27 bne 200e258 <fifo_open+0x41c> <== NEVER TAKEN
200e1c0: 92 10 20 00 clr %o1
goto out_error;
if (! PIPE_LOCK(pipe))
200e1c4: d0 07 60 28 ld [ %i5 + 0x28 ], %o0
200e1c8: 7f ff eb f2 call 2009190 <rtems_semaphore_obtain>
200e1cc: 94 10 20 00 clr %o2
200e1d0: 80 a2 20 00 cmp %o0, 0
200e1d4: 32 80 00 22 bne,a 200e25c <fifo_open+0x420> <== NEVER TAKEN
200e1d8: b0 10 3f fc mov -4, %i0 <== NOT EXECUTED
goto out_error;
} while (prevCounter == pipe->readerCounter);
200e1dc: c2 07 60 20 ld [ %i5 + 0x20 ], %g1
200e1e0: 80 a7 00 01 cmp %i4, %g1
200e1e4: 02 bf ff f0 be 200e1a4 <fifo_open+0x368> <== NEVER TAKEN
200e1e8: 01 00 00 00 nop
200e1ec: 30 80 00 17 b,a 200e248 <fifo_open+0x40c>
}
break;
case LIBIO_FLAGS_READ_WRITE:
pipe->readerCounter ++;
200e1f0: c2 07 60 20 ld [ %i5 + 0x20 ], %g1
200e1f4: 82 00 60 01 inc %g1
200e1f8: c2 27 60 20 st %g1, [ %i5 + 0x20 ]
if (pipe->Readers ++ == 0)
200e1fc: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
200e200: 84 00 60 01 add %g1, 1, %g2
200e204: 80 a0 60 00 cmp %g1, 0
200e208: 12 80 00 05 bne 200e21c <fifo_open+0x3e0> <== NEVER TAKEN
200e20c: c4 27 60 10 st %g2, [ %i5 + 0x10 ]
PIPE_WAKEUPWRITERS(pipe);
200e210: d0 07 60 30 ld [ %i5 + 0x30 ], %o0
200e214: 40 00 05 8c call 200f844 <rtems_barrier_release>
200e218: 92 07 bf f8 add %fp, -8, %o1
pipe->writerCounter ++;
200e21c: c2 07 60 24 ld [ %i5 + 0x24 ], %g1
200e220: 82 00 60 01 inc %g1
200e224: c2 27 60 24 st %g1, [ %i5 + 0x24 ]
if (pipe->Writers ++ == 0)
200e228: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
200e22c: 84 00 60 01 add %g1, 1, %g2
200e230: 80 a0 60 00 cmp %g1, 0
200e234: 12 80 00 05 bne 200e248 <fifo_open+0x40c> <== NEVER TAKEN
200e238: c4 27 60 14 st %g2, [ %i5 + 0x14 ]
PIPE_WAKEUPREADERS(pipe);
200e23c: d0 07 60 2c ld [ %i5 + 0x2c ], %o0
200e240: 40 00 05 81 call 200f844 <rtems_barrier_release>
200e244: 92 07 bf f8 add %fp, -8, %o1
break;
}
PIPE_UNLOCK(pipe);
200e248: 7f ff ec 1c call 20092b8 <rtems_semaphore_release>
200e24c: d0 07 60 28 ld [ %i5 + 0x28 ], %o0
return 0;
200e250: 81 c7 e0 08 ret
200e254: 81 e8 00 00 restore
/* Not an error */
if (LIBIO_NODELAY(iop))
break;
prevCounter = pipe->writerCounter;
err = -EINTR;
200e258: b0 10 3f fc mov -4, %i0 <== NOT EXECUTED
PIPE_UNLOCK(pipe);
return 0;
out_error:
pipe_release(pipep, iop);
200e25c: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
200e260: 7f ff fe ca call 200dd88 <pipe_release>
200e264: 92 10 00 19 mov %i1, %o1
return err;
200e268: 81 c7 e0 08 ret
200e26c: 81 e8 00 00 restore
err = pipe_lock();
if (err)
return err;
pipe = *pipep;
if (pipe == NULL) {
200e270: 80 a7 60 00 cmp %i5, 0
200e274: 32 bf ff 6d bne,a 200e028 <fifo_open+0x1ec>
200e278: d0 07 60 28 ld [ %i5 + 0x28 ], %o0
200e27c: 30 bf ff 1a b,a 200dee4 <fifo_open+0xa8>
if (err)
goto out;
}
if (! PIPE_LOCK(pipe))
err = -EINTR;
200e280: 10 bf ff 7a b 200e068 <fifo_open+0x22c> <== NOT EXECUTED
200e284: b0 10 3f f4 mov -12, %i0 <== NOT EXECUTED
#ifdef RTEMS_POSIX_API
pipe_interruptible(pipe);
#endif
*pipep = pipe;
if (c ++ == 'z')
200e288: 10 bf ff 67 b 200e024 <fifo_open+0x1e8>
200e28c: c2 2f 22 30 stb %g1, [ %i4 + 0x230 ]
return 0;
out_error:
pipe_release(pipep, iop);
return err;
}
200e290: 81 c7 e0 08 ret
200e294: 81 e8 00 00 restore
020099d0 <fpathconf>:
long fpathconf(
int fd,
int name
)
{
20099d0: 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);
20099d4: 03 00 80 49 sethi %hi(0x2012400), %g1
20099d8: c2 00 63 f4 ld [ %g1 + 0x3f4 ], %g1 ! 20127f4 <rtems_libio_number_iops>
20099dc: 80 a6 00 01 cmp %i0, %g1
20099e0: 2a 80 00 03 bcs,a 20099ec <fpathconf+0x1c> <== NEVER TAKEN
20099e4: 83 2e 20 03 sll %i0, 3, %g1 <== NOT EXECUTED
20099e8: 30 80 00 0a b,a 2009a10 <fpathconf+0x40>
iop = rtems_libio_iop(fd);
20099ec: b1 2e 20 06 sll %i0, 6, %i0 <== NOT EXECUTED
20099f0: b0 26 00 01 sub %i0, %g1, %i0 <== NOT EXECUTED
20099f4: 03 00 80 4c sethi %hi(0x2013000), %g1 <== NOT EXECUTED
20099f8: c2 00 60 e4 ld [ %g1 + 0xe4 ], %g1 ! 20130e4 <rtems_libio_iops><== NOT EXECUTED
20099fc: b0 00 40 18 add %g1, %i0, %i0 <== NOT EXECUTED
rtems_libio_check_is_open(iop);
2009a00: c2 06 20 10 ld [ %i0 + 0x10 ], %g1 <== NOT EXECUTED
2009a04: 80 88 61 00 btst 0x100, %g1 <== NOT EXECUTED
2009a08: 32 80 00 06 bne,a 2009a20 <fpathconf+0x50> <== NOT EXECUTED
2009a0c: c2 06 20 28 ld [ %i0 + 0x28 ], %g1 <== NOT EXECUTED
2009a10: 40 00 09 29 call 200beb4 <__errno>
2009a14: 01 00 00 00 nop
2009a18: 10 80 00 32 b 2009ae0 <fpathconf+0x110>
2009a1c: 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 ) {
2009a20: 80 a6 60 0b cmp %i1, 0xb <== NOT EXECUTED
2009a24: 18 80 00 2c bgu 2009ad4 <fpathconf+0x104> <== NOT EXECUTED
2009a28: c2 00 60 2c ld [ %g1 + 0x2c ], %g1 <== NOT EXECUTED
2009a2c: b3 2e 60 02 sll %i1, 2, %i1 <== NOT EXECUTED
2009a30: 05 00 80 26 sethi %hi(0x2009800), %g2 <== NOT EXECUTED
2009a34: 84 10 a1 a0 or %g2, 0x1a0, %g2 ! 20099a0 <_close_r+0x10> <== NOT EXECUTED
2009a38: c4 00 80 19 ld [ %g2 + %i1 ], %g2 <== NOT EXECUTED
2009a3c: 81 c0 80 00 jmp %g2 <== NOT EXECUTED
2009a40: 01 00 00 00 nop <== NOT EXECUTED
case _PC_LINK_MAX:
return_value = the_limits->link_max;
2009a44: f0 00 40 00 ld [ %g1 ], %i0 <== NOT EXECUTED
break;
2009a48: 81 c7 e0 08 ret <== NOT EXECUTED
2009a4c: 81 e8 00 00 restore <== NOT EXECUTED
case _PC_MAX_CANON:
return_value = the_limits->max_canon;
2009a50: f0 00 60 04 ld [ %g1 + 4 ], %i0 <== NOT EXECUTED
break;
2009a54: 81 c7 e0 08 ret <== NOT EXECUTED
2009a58: 81 e8 00 00 restore <== NOT EXECUTED
case _PC_MAX_INPUT:
return_value = the_limits->max_input;
2009a5c: f0 00 60 08 ld [ %g1 + 8 ], %i0 <== NOT EXECUTED
break;
2009a60: 81 c7 e0 08 ret <== NOT EXECUTED
2009a64: 81 e8 00 00 restore <== NOT EXECUTED
case _PC_NAME_MAX:
return_value = the_limits->name_max;
2009a68: f0 00 60 0c ld [ %g1 + 0xc ], %i0 <== NOT EXECUTED
break;
2009a6c: 81 c7 e0 08 ret <== NOT EXECUTED
2009a70: 81 e8 00 00 restore <== NOT EXECUTED
case _PC_PATH_MAX:
return_value = the_limits->path_max;
2009a74: f0 00 60 10 ld [ %g1 + 0x10 ], %i0 <== NOT EXECUTED
break;
2009a78: 81 c7 e0 08 ret <== NOT EXECUTED
2009a7c: 81 e8 00 00 restore <== NOT EXECUTED
case _PC_PIPE_BUF:
return_value = the_limits->pipe_buf;
2009a80: f0 00 60 14 ld [ %g1 + 0x14 ], %i0 <== NOT EXECUTED
break;
2009a84: 81 c7 e0 08 ret <== NOT EXECUTED
2009a88: 81 e8 00 00 restore <== NOT EXECUTED
case _PC_CHOWN_RESTRICTED:
return_value = the_limits->posix_chown_restrictions;
2009a8c: f0 00 60 1c ld [ %g1 + 0x1c ], %i0 <== NOT EXECUTED
break;
2009a90: 81 c7 e0 08 ret <== NOT EXECUTED
2009a94: 81 e8 00 00 restore <== NOT EXECUTED
case _PC_NO_TRUNC:
return_value = the_limits->posix_no_trunc;
2009a98: f0 00 60 20 ld [ %g1 + 0x20 ], %i0 <== NOT EXECUTED
break;
2009a9c: 81 c7 e0 08 ret <== NOT EXECUTED
2009aa0: 81 e8 00 00 restore <== NOT EXECUTED
case _PC_VDISABLE:
return_value = the_limits->posix_vdisable;
2009aa4: f0 00 60 2c ld [ %g1 + 0x2c ], %i0 <== NOT EXECUTED
break;
2009aa8: 81 c7 e0 08 ret <== NOT EXECUTED
2009aac: 81 e8 00 00 restore <== NOT EXECUTED
case _PC_ASYNC_IO:
return_value = the_limits->posix_async_io;
2009ab0: f0 00 60 18 ld [ %g1 + 0x18 ], %i0 <== NOT EXECUTED
break;
2009ab4: 81 c7 e0 08 ret <== NOT EXECUTED
2009ab8: 81 e8 00 00 restore <== NOT EXECUTED
case _PC_PRIO_IO:
return_value = the_limits->posix_prio_io;
2009abc: f0 00 60 24 ld [ %g1 + 0x24 ], %i0 <== NOT EXECUTED
break;
2009ac0: 81 c7 e0 08 ret <== NOT EXECUTED
2009ac4: 81 e8 00 00 restore <== NOT EXECUTED
case _PC_SYNC_IO:
return_value = the_limits->posix_sync_io;
2009ac8: f0 00 60 28 ld [ %g1 + 0x28 ], %i0 <== NOT EXECUTED
break;
2009acc: 81 c7 e0 08 ret <== NOT EXECUTED
2009ad0: 81 e8 00 00 restore <== NOT EXECUTED
default:
rtems_set_errno_and_return_minus_one( EINVAL );
2009ad4: 40 00 08 f8 call 200beb4 <__errno> <== NOT EXECUTED
2009ad8: 01 00 00 00 nop <== NOT EXECUTED
2009adc: 82 10 20 16 mov 0x16, %g1 ! 16 <PROM_START+0x16> <== NOT EXECUTED
2009ae0: c2 22 00 00 st %g1, [ %o0 ]
break;
}
return return_value;
}
2009ae4: 81 c7 e0 08 ret
2009ae8: 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 68 or %g1, 0x168, %g1 ! 201d968 <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 30 ld [ %g1 + 0x30 ], %g1 ! 201dc30 <_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 a4 ld [ %g1 + 0x1a4 ], %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 ec ld [ %i5 + 0x1ec ], %o0 ! 201cdec <RTEMS_Malloc_Heap>
2003854: 40 00 17 53 call 20095a0 <_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 ec ld [ %i5 + 0x1ec ], %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 e0 restore %i0, 0x2e0, %o0
200387c: 81 c7 e0 08 ret
2003880: 81 e8 00 00 restore
0201a03c <fstat>:
int fstat(
int fd,
struct stat *sbuf
)
{
201a03c: 9d e3 bf a0 save %sp, -96, %sp
rtems_libio_t *iop;
/*
* Check to see if we were passed a valid pointer.
*/
if ( !sbuf )
201a040: 80 a6 60 00 cmp %i1, 0
201a044: 32 80 00 06 bne,a 201a05c <fstat+0x20> <== ALWAYS TAKEN
201a048: 03 00 80 73 sethi %hi(0x201cc00), %g1
rtems_set_errno_and_return_minus_one( EFAULT );
201a04c: 7f ff d6 73 call 200fa18 <__errno> <== NOT EXECUTED
201a050: 01 00 00 00 nop <== NOT EXECUTED
201a054: 10 80 00 12 b 201a09c <fstat+0x60> <== NOT EXECUTED
201a058: 82 10 20 0e mov 0xe, %g1 ! e <PROM_START+0xe> <== NOT EXECUTED
/*
* Now process the stat() request.
*/
iop = rtems_libio_iop( fd );
201a05c: c2 00 62 30 ld [ %g1 + 0x230 ], %g1
201a060: 80 a6 00 01 cmp %i0, %g1
201a064: 1a 80 00 0b bcc 201a090 <fstat+0x54>
201a068: 83 2e 20 03 sll %i0, 3, %g1
201a06c: b1 2e 20 06 sll %i0, 6, %i0
201a070: b0 26 00 01 sub %i0, %g1, %i0
201a074: 03 00 80 76 sethi %hi(0x201d800), %g1
201a078: c2 00 61 50 ld [ %g1 + 0x150 ], %g1 ! 201d950 <rtems_libio_iops>
201a07c: b0 00 40 18 add %g1, %i0, %i0
rtems_libio_check_fd( fd );
rtems_libio_check_is_open(iop);
201a080: c2 06 20 10 ld [ %i0 + 0x10 ], %g1
201a084: 80 88 61 00 btst 0x100, %g1
201a088: 12 80 00 08 bne 201a0a8 <fstat+0x6c>
201a08c: 94 10 20 48 mov 0x48, %o2
/*
* Now process the stat() request.
*/
iop = rtems_libio_iop( fd );
rtems_libio_check_fd( fd );
201a090: 7f ff d6 62 call 200fa18 <__errno>
201a094: 01 00 00 00 nop
201a098: 82 10 20 09 mov 9, %g1 ! 9 <PROM_START+0x9>
201a09c: c2 22 00 00 st %g1, [ %o0 ]
201a0a0: 81 c7 e0 08 ret
201a0a4: 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) );
201a0a8: 90 10 00 19 mov %i1, %o0
201a0ac: 7f ff d8 df call 2010428 <memset>
201a0b0: 92 10 20 00 clr %o1
return (*iop->pathinfo.handlers->fstat_h)( &iop->pathinfo, sbuf );
201a0b4: c2 06 20 24 ld [ %i0 + 0x24 ], %g1
201a0b8: 90 06 20 14 add %i0, 0x14, %o0
201a0bc: c2 00 60 18 ld [ %g1 + 0x18 ], %g1
201a0c0: 9f c0 40 00 call %g1
201a0c4: 92 10 00 19 mov %i1, %o1
}
201a0c8: 81 c7 e0 08 ret
201a0cc: 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 70 ld [ %g1 + 0x370 ], %g1 ! 2021770 <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 74 ld [ %g1 + 0x374 ], %g1 ! 2021774 <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
0202fb4c <getdents>:
int getdents(
int dd_fd,
char *dd_buf,
int dd_len
)
{
202fb4c: 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 );
202fb50: 03 00 80 d7 sethi %hi(0x2035c00), %g1
202fb54: c2 00 62 f8 ld [ %g1 + 0x2f8 ], %g1 ! 2035ef8 <rtems_libio_number_iops>
202fb58: 80 a6 00 01 cmp %i0, %g1
202fb5c: 1a 80 00 08 bcc 202fb7c <getdents+0x30> <== NEVER TAKEN
202fb60: ba 10 20 00 clr %i5
202fb64: 83 2e 20 03 sll %i0, 3, %g1
202fb68: b1 2e 20 06 sll %i0, 6, %i0
202fb6c: b0 26 00 01 sub %i0, %g1, %i0
202fb70: 03 00 81 1a sethi %hi(0x2046800), %g1
202fb74: fa 00 63 74 ld [ %g1 + 0x374 ], %i5 ! 2046b74 <rtems_libio_iops>
202fb78: ba 07 40 18 add %i5, %i0, %i5
/*
* Make sure we are working on a directory
*/
type = rtems_filesystem_node_type( &iop->pathinfo );
202fb7c: 7f ff 69 85 call 200a190 <rtems_filesystem_node_type>
202fb80: 90 07 60 14 add %i5, 0x14, %o0
if ( type != RTEMS_FILESYSTEM_DIRECTORY )
202fb84: 80 a2 20 00 cmp %o0, 0
202fb88: 22 80 00 08 be,a 202fba8 <getdents+0x5c>
202fb8c: c2 07 60 24 ld [ %i5 + 0x24 ], %g1
rtems_set_errno_and_return_minus_one( ENOTDIR );
202fb90: 7f ff c4 0b call 2020bbc <__errno>
202fb94: b0 10 3f ff mov -1, %i0
202fb98: 82 10 20 14 mov 0x14, %g1
202fb9c: c2 22 00 00 st %g1, [ %o0 ]
202fba0: 81 c7 e0 08 ret
202fba4: 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 );
202fba8: 90 10 00 1d mov %i5, %o0
202fbac: c2 00 60 08 ld [ %g1 + 8 ], %g1
202fbb0: 92 10 00 19 mov %i1, %o1
202fbb4: 9f c0 40 00 call %g1
202fbb8: 94 10 00 1a mov %i2, %o2
}
202fbbc: 81 c7 e0 08 ret
202fbc0: 91 e8 00 08 restore %g0, %o0, %o0
020240b4 <init_etc_passwd_group>:
/*
* Initialize useable but dummy databases
*/
void init_etc_passwd_group(void)
{
20240b4: 9d e3 bf a0 save %sp, -96, %sp
FILE *fp;
static char etc_passwd_initted = 0;
if (etc_passwd_initted)
20240b8: 03 00 81 85 sethi %hi(0x2061400), %g1
20240bc: c4 48 62 e0 ldsb [ %g1 + 0x2e0 ], %g2 ! 20616e0 <etc_passwd_initted.7005>
20240c0: 80 a0 a0 00 cmp %g2, 0
20240c4: 12 80 00 2f bne 2024180 <init_etc_passwd_group+0xcc>
20240c8: 84 10 20 01 mov 1, %g2
return;
etc_passwd_initted = 1;
mkdir("/etc", 0777);
20240cc: 92 10 21 ff mov 0x1ff, %o1
FILE *fp;
static char etc_passwd_initted = 0;
if (etc_passwd_initted)
return;
etc_passwd_initted = 1;
20240d0: c4 28 62 e0 stb %g2, [ %g1 + 0x2e0 ]
mkdir("/etc", 0777);
20240d4: 11 00 81 62 sethi %hi(0x2058800), %o0
20240d8: 7f ff 7e 4f call 2003a14 <mkdir>
20240dc: 90 12 21 f0 or %o0, 0x1f0, %o0 ! 20589f0 <RTEMS_BDPART_MBR_MASTER_TYPE+0x6f8>
/*
* Initialize /etc/passwd
*/
if ((fp = fopen("/etc/passwd", "r")) != NULL) {
20240e0: 3b 00 81 62 sethi %hi(0x2058800), %i5
20240e4: 13 00 81 74 sethi %hi(0x205d000), %o1
20240e8: 90 17 61 f8 or %i5, 0x1f8, %o0
20240ec: 40 00 4c 4a call 2037214 <fopen>
20240f0: 92 12 63 00 or %o1, 0x300, %o1
20240f4: 80 a2 20 00 cmp %o0, 0
20240f8: 22 80 00 03 be,a 2024104 <init_etc_passwd_group+0x50>
20240fc: 90 17 61 f8 or %i5, 0x1f8, %o0
2024100: 30 80 00 0b b,a 202412c <init_etc_passwd_group+0x78>
fclose(fp);
}
else if ((fp = fopen("/etc/passwd", "w")) != NULL) {
2024104: 13 00 81 5a sethi %hi(0x2056800), %o1
2024108: 40 00 4c 43 call 2037214 <fopen>
202410c: 92 12 61 c8 or %o1, 0x1c8, %o1 ! 20569c8 <rtems_rtc_shell_usage+0x4e8>
2024110: ba 92 20 00 orcc %o0, 0, %i5
2024114: 02 80 00 08 be 2024134 <init_etc_passwd_group+0x80> <== NEVER TAKEN
2024118: 11 00 81 62 sethi %hi(0x2058800), %o0
fprintf(fp, "root:*:0:0:root::/:/bin/sh\n"
202411c: 92 10 00 1d mov %i5, %o1
2024120: 40 00 4c a0 call 20373a0 <fputs>
2024124: 90 12 22 08 or %o0, 0x208, %o0
"rtems:*:1:1:RTEMS Application::/:/bin/sh\n"
"tty:!:2:2:tty owner::/:/bin/false\n" );
fclose(fp);
2024128: 90 10 00 1d mov %i5, %o0
202412c: 40 00 49 e6 call 20368c4 <fclose>
2024130: 01 00 00 00 nop
}
/*
* Initialize /etc/group
*/
if ((fp = fopen("/etc/group", "r")) != NULL) {
2024134: 3b 00 81 62 sethi %hi(0x2058800), %i5
2024138: 13 00 81 74 sethi %hi(0x205d000), %o1
202413c: 90 17 62 70 or %i5, 0x270, %o0
2024140: 40 00 4c 35 call 2037214 <fopen>
2024144: 92 12 63 00 or %o1, 0x300, %o1
2024148: b0 92 20 00 orcc %o0, 0, %i0
202414c: 12 80 00 0b bne 2024178 <init_etc_passwd_group+0xc4>
2024150: 90 17 62 70 or %i5, 0x270, %o0
fclose(fp);
}
else if ((fp = fopen("/etc/group", "w")) != NULL) {
2024154: 13 00 81 5a sethi %hi(0x2056800), %o1
2024158: 40 00 4c 2f call 2037214 <fopen>
202415c: 92 12 61 c8 or %o1, 0x1c8, %o1 ! 20569c8 <rtems_rtc_shell_usage+0x4e8>
2024160: b0 92 20 00 orcc %o0, 0, %i0
2024164: 02 80 00 07 be 2024180 <init_etc_passwd_group+0xcc> <== NEVER TAKEN
2024168: 11 00 81 62 sethi %hi(0x2058800), %o0
fprintf( fp, "root:x:0:root\n"
202416c: 92 10 00 18 mov %i0, %o1
2024170: 40 00 4c 8c call 20373a0 <fputs>
2024174: 90 12 22 80 or %o0, 0x280, %o0
"rtems:x:1:rtems\n"
"tty:x:2:tty\n" );
fclose(fp);
2024178: 40 00 49 d3 call 20368c4 <fclose>
202417c: 81 e8 00 00 restore
2024180: 81 c7 e0 08 ret
2024184: 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 70 ld [ %g2 + 0x70 ], %g2 ! 201d070 <__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 10 ld [ %g1 + 0x310 ], %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
0201a340 <killinfo>:
int killinfo(
pid_t pid,
int sig,
const union sigval *value
)
{
201a340: 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() )
201a344: 7f ff ff 68 call 201a0e4 <getpid>
201a348: 01 00 00 00 nop
201a34c: 80 a6 00 08 cmp %i0, %o0
201a350: 02 80 00 06 be 201a368 <killinfo+0x28>
201a354: 80 a6 60 00 cmp %i1, 0
rtems_set_errno_and_return_minus_one( ESRCH );
201a358: 7f ff d5 b0 call 200fa18 <__errno>
201a35c: 01 00 00 00 nop
201a360: 10 80 00 a4 b 201a5f0 <killinfo+0x2b0>
201a364: 82 10 20 03 mov 3, %g1 ! 3 <PROM_START+0x3>
/*
* Validate the signal passed.
*/
if ( !sig )
201a368: 32 80 00 03 bne,a 201a374 <killinfo+0x34>
201a36c: ba 06 7f ff add %i1, -1, %i5
201a370: 30 80 00 04 b,a 201a380 <killinfo+0x40>
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !is_valid_signo(sig) )
201a374: 80 a7 60 1f cmp %i5, 0x1f
201a378: 28 80 00 06 bleu,a 201a390 <killinfo+0x50>
201a37c: 83 2e 60 02 sll %i1, 2, %g1
rtems_set_errno_and_return_minus_one( EINVAL );
201a380: 7f ff d5 a6 call 200fa18 <__errno>
201a384: 01 00 00 00 nop
201a388: 10 80 00 9a b 201a5f0 <killinfo+0x2b0>
201a38c: 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 )
201a390: 85 2e 60 04 sll %i1, 4, %g2
201a394: 84 20 80 01 sub %g2, %g1, %g2
201a398: 03 00 80 78 sethi %hi(0x201e000), %g1
201a39c: 82 10 60 80 or %g1, 0x80, %g1 ! 201e080 <_POSIX_signals_Vectors>
201a3a0: 82 00 40 02 add %g1, %g2, %g1
201a3a4: c2 00 60 08 ld [ %g1 + 8 ], %g1
201a3a8: 80 a0 60 01 cmp %g1, 1
201a3ac: 02 80 00 9d be 201a620 <killinfo+0x2e0>
201a3b0: 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 ) )
201a3b4: 02 80 00 06 be 201a3cc <killinfo+0x8c>
201a3b8: 80 a6 60 08 cmp %i1, 8
201a3bc: 02 80 00 04 be 201a3cc <killinfo+0x8c>
201a3c0: 80 a6 60 0b cmp %i1, 0xb
201a3c4: 12 80 00 08 bne 201a3e4 <killinfo+0xa4>
201a3c8: 82 10 20 01 mov 1, %g1
return pthread_kill( pthread_self(), sig );
201a3cc: 40 00 01 2d call 201a880 <pthread_self>
201a3d0: 01 00 00 00 nop
201a3d4: 40 00 00 f2 call 201a79c <pthread_kill>
201a3d8: 92 10 00 19 mov %i1, %o1
201a3dc: 81 c7 e0 08 ret
201a3e0: 91 e8 00 08 restore %g0, %o0, %o0
/*
* Build up a siginfo structure
*/
siginfo = &siginfo_struct;
siginfo->si_signo = sig;
201a3e4: f2 27 bf f4 st %i1, [ %fp + -12 ]
siginfo->si_code = SI_USER;
201a3e8: c2 27 bf f8 st %g1, [ %fp + -8 ]
if ( !value ) {
201a3ec: 80 a6 a0 00 cmp %i2, 0
201a3f0: 12 80 00 04 bne 201a400 <killinfo+0xc0>
201a3f4: bb 28 40 1d sll %g1, %i5, %i5
siginfo->si_value.sival_int = 0;
201a3f8: 10 80 00 04 b 201a408 <killinfo+0xc8>
201a3fc: c0 27 bf fc clr [ %fp + -4 ]
} else {
siginfo->si_value = *value;
201a400: c2 06 80 00 ld [ %i2 ], %g1
201a404: 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++;
201a408: 03 00 80 76 sethi %hi(0x201d800), %g1
201a40c: c4 00 62 f0 ld [ %g1 + 0x2f0 ], %g2 ! 201daf0 <_Thread_Dispatch_disable_level>
201a410: 84 00 a0 01 inc %g2
201a414: c4 20 62 f0 st %g2, [ %g1 + 0x2f0 ]
return _Thread_Dispatch_disable_level;
201a418: c2 00 62 f0 ld [ %g1 + 0x2f0 ], %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;
201a41c: 03 00 80 78 sethi %hi(0x201e000), %g1
201a420: d0 00 60 2c ld [ %g1 + 0x2c ], %o0 ! 201e02c <_Per_CPU_Information+0xc>
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
if ( _POSIX_signals_Is_interested( api, mask ) ) {
201a424: c4 02 21 5c ld [ %o0 + 0x15c ], %g2
201a428: c4 00 a0 d0 ld [ %g2 + 0xd0 ], %g2
201a42c: 80 af 40 02 andncc %i5, %g2, %g0
201a430: 12 80 00 52 bne 201a578 <killinfo+0x238>
201a434: 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 );
201a438: 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;
201a43c: c2 00 62 0c ld [ %g1 + 0x20c ], %g1
201a440: 10 80 00 0a b 201a468 <killinfo+0x128>
201a444: 84 10 a2 10 or %g2, 0x210, %g2
#endif
/*
* Is this thread is actually blocked waiting for the signal?
*/
if (the_thread->Wait.option & mask)
201a448: 80 8f 40 04 btst %i5, %g4
201a44c: 12 80 00 4a bne 201a574 <killinfo+0x234>
201a450: 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)
201a454: c6 00 e0 d0 ld [ %g3 + 0xd0 ], %g3
201a458: 80 af 40 03 andncc %i5, %g3, %g0
201a45c: 12 80 00 47 bne 201a578 <killinfo+0x238>
201a460: 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 ) {
201a464: 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 );
201a468: 80 a0 40 02 cmp %g1, %g2
201a46c: 32 bf ff f7 bne,a 201a448 <killinfo+0x108>
201a470: c8 00 60 30 ld [ %g1 + 0x30 ], %g4
* NOTES:
*
* + rtems internal threads do not receive signals.
*/
interested = NULL;
interested_priority = PRIORITY_MAXIMUM + 1;
201a474: 03 00 80 73 sethi %hi(0x201cc00), %g1
201a478: c6 08 61 48 ldub [ %g1 + 0x148 ], %g3 ! 201cd48 <rtems_maximum_priority>
for (the_api = OBJECTS_CLASSIC_API; the_api <= OBJECTS_APIS_LAST; the_api++) {
201a47c: b8 10 20 02 mov 2, %i4
* NOTES:
*
* + rtems internal threads do not receive signals.
*/
interested = NULL;
interested_priority = PRIORITY_MAXIMUM + 1;
201a480: 86 00 e0 01 inc %g3
*
* NOTES:
*
* + rtems internal threads do not receive signals.
*/
interested = NULL;
201a484: 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 ] )
201a488: 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);
201a48c: 35 04 00 00 sethi %hi(0x10000000), %i2
*/
#define _POSIX_signals_Is_interested( _api, _mask ) \
( ~(_api)->signals_blocked & (_mask) )
int killinfo(
201a490: 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 ] )
201a494: 88 13 62 54 or %o5, 0x254, %g4
201a498: c4 01 00 02 ld [ %g4 + %g2 ], %g2
201a49c: 80 a0 a0 00 cmp %g2, 0
201a4a0: 22 80 00 2f be,a 201a55c <killinfo+0x21c> <== NEVER TAKEN
201a4a4: b8 07 20 01 inc %i4 <== NOT EXECUTED
continue;
the_info = _Objects_Information_table[ the_api ][ 1 ];
201a4a8: 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++ ) {
201a4ac: b6 10 20 01 mov 1, %i3
*/
if ( !the_info )
continue;
#endif
maximum = the_info->maximum;
201a4b0: d8 10 a0 10 lduh [ %g2 + 0x10 ], %o4
object_table = the_info->local_table;
for ( index = 1 ; index <= maximum ; index++ ) {
201a4b4: 10 80 00 26 b 201a54c <killinfo+0x20c>
201a4b8: d6 00 a0 1c ld [ %g2 + 0x1c ], %o3
the_thread = (Thread_Control *) object_table[ index ];
201a4bc: c4 02 c0 02 ld [ %o3 + %g2 ], %g2
if ( !the_thread )
201a4c0: 80 a0 a0 00 cmp %g2, 0
201a4c4: 22 80 00 22 be,a 201a54c <killinfo+0x20c>
201a4c8: 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 )
201a4cc: c8 00 a0 14 ld [ %g2 + 0x14 ], %g4
201a4d0: 80 a1 00 03 cmp %g4, %g3
201a4d4: 38 80 00 1e bgu,a 201a54c <killinfo+0x20c>
201a4d8: b6 06 e0 01 inc %i3
#if defined(RTEMS_DEBUG)
if ( !api )
continue;
#endif
if ( !_POSIX_signals_Is_interested( api, mask ) )
201a4dc: f0 00 a1 5c ld [ %g2 + 0x15c ], %i0
201a4e0: f0 06 20 d0 ld [ %i0 + 0xd0 ], %i0
201a4e4: 80 af 40 18 andncc %i5, %i0, %g0
201a4e8: 22 80 00 19 be,a 201a54c <killinfo+0x20c>
201a4ec: 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 ) {
201a4f0: 80 a1 00 03 cmp %g4, %g3
201a4f4: 2a 80 00 14 bcs,a 201a544 <killinfo+0x204>
201a4f8: 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 ) ) {
201a4fc: 80 a0 60 00 cmp %g1, 0
201a500: 22 80 00 13 be,a 201a54c <killinfo+0x20c> <== NEVER TAKEN
201a504: b6 06 e0 01 inc %i3 <== NOT EXECUTED
201a508: de 00 60 10 ld [ %g1 + 0x10 ], %o7
201a50c: 80 a3 e0 00 cmp %o7, 0
201a510: 22 80 00 0f be,a 201a54c <killinfo+0x20c> <== NEVER TAKEN
201a514: b6 06 e0 01 inc %i3 <== NOT EXECUTED
/* preferred ready over blocked */
DEBUG_STEP("5");
if ( _States_Is_ready( the_thread->current_state ) ) {
201a518: f0 00 a0 10 ld [ %g2 + 0x10 ], %i0
201a51c: 80 a6 20 00 cmp %i0, 0
201a520: 22 80 00 09 be,a 201a544 <killinfo+0x204>
201a524: 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) ) {
201a528: 80 8b c0 1a btst %o7, %i2
201a52c: 32 80 00 08 bne,a 201a54c <killinfo+0x20c>
201a530: b6 06 e0 01 inc %i3
DEBUG_STEP("7");
if ( _States_Is_interruptible_by_signal(the_thread->current_state) ) {
201a534: 80 8e 00 1a btst %i0, %i2
201a538: 22 80 00 05 be,a 201a54c <killinfo+0x20c>
201a53c: 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 ) ) {
201a540: 86 10 00 04 mov %g4, %g3
201a544: 82 10 00 02 mov %g2, %g1
#endif
maximum = the_info->maximum;
object_table = the_info->local_table;
for ( index = 1 ; index <= maximum ; index++ ) {
201a548: b6 06 e0 01 inc %i3
201a54c: 80 a6 c0 0c cmp %i3, %o4
201a550: 08 bf ff db bleu 201a4bc <killinfo+0x17c>
201a554: 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++) {
201a558: b8 07 20 01 inc %i4
201a55c: 80 a7 20 04 cmp %i4, 4
201a560: 12 bf ff cd bne 201a494 <killinfo+0x154>
201a564: 85 2f 20 02 sll %i4, 2, %g2
}
}
}
}
if ( interested ) {
201a568: 80 a0 60 00 cmp %g1, 0
201a56c: 02 80 00 0c be 201a59c <killinfo+0x25c>
201a570: 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)
201a574: 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 ) ) {
201a578: 92 10 00 19 mov %i1, %o1
201a57c: 40 00 00 36 call 201a654 <_POSIX_signals_Unblock_thread>
201a580: 94 07 bf f4 add %fp, -12, %o2
201a584: 80 8a 20 ff btst 0xff, %o0
201a588: 02 80 00 05 be 201a59c <killinfo+0x25c>
201a58c: 01 00 00 00 nop
_Thread_Enable_dispatch();
201a590: 7f ff bf 0f call 200a1cc <_Thread_Enable_dispatch>
201a594: b0 10 20 00 clr %i0 ! 0 <PROM_START>
201a598: 30 80 00 23 b,a 201a624 <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 );
201a59c: 40 00 00 24 call 201a62c <_POSIX_signals_Set_process_signals>
201a5a0: 90 10 00 1d mov %i5, %o0
if ( _POSIX_signals_Vectors[ sig ].sa_flags == SA_SIGINFO ) {
201a5a4: 83 2e 60 02 sll %i1, 2, %g1
201a5a8: b3 2e 60 04 sll %i1, 4, %i1
201a5ac: b2 26 40 01 sub %i1, %g1, %i1
201a5b0: 03 00 80 78 sethi %hi(0x201e000), %g1
201a5b4: 82 10 60 80 or %g1, 0x80, %g1 ! 201e080 <_POSIX_signals_Vectors>
201a5b8: c2 00 40 19 ld [ %g1 + %i1 ], %g1
201a5bc: 80 a0 60 02 cmp %g1, 2
201a5c0: 12 bf ff f4 bne 201a590 <killinfo+0x250>
201a5c4: 11 00 80 78 sethi %hi(0x201e000), %o0
psiginfo = (POSIX_signals_Siginfo_node *)
201a5c8: 7f ff b7 78 call 20083a8 <_Chain_Get>
201a5cc: 90 12 22 00 or %o0, 0x200, %o0 ! 201e200 <_POSIX_signals_Inactive_siginfo>
_Chain_Get( &_POSIX_signals_Inactive_siginfo );
if ( !psiginfo ) {
201a5d0: ba 92 20 00 orcc %o0, 0, %i5
201a5d4: 12 80 00 0a bne 201a5fc <killinfo+0x2bc>
201a5d8: 92 07 bf f4 add %fp, -12, %o1
_Thread_Enable_dispatch();
201a5dc: 7f ff be fc call 200a1cc <_Thread_Enable_dispatch>
201a5e0: 01 00 00 00 nop
rtems_set_errno_and_return_minus_one( EAGAIN );
201a5e4: 7f ff d5 0d call 200fa18 <__errno>
201a5e8: 01 00 00 00 nop
201a5ec: 82 10 20 0b mov 0xb, %g1 ! b <PROM_START+0xb>
201a5f0: c2 22 00 00 st %g1, [ %o0 ]
201a5f4: 81 c7 e0 08 ret
201a5f8: 91 e8 3f ff restore %g0, -1, %o0
}
psiginfo->Info = *siginfo;
201a5fc: 90 07 60 08 add %i5, 8, %o0
201a600: 7f ff d7 4d call 2010334 <memcpy>
201a604: 94 10 20 0c mov 0xc, %o2
_Chain_Append( &_POSIX_signals_Siginfo[ sig ], &psiginfo->Node );
201a608: 11 00 80 78 sethi %hi(0x201e000), %o0
201a60c: 92 10 00 1d mov %i5, %o1
201a610: 90 12 22 78 or %o0, 0x278, %o0
201a614: 7f ff b7 59 call 2008378 <_Chain_Append>
201a618: 90 02 00 19 add %o0, %i1, %o0
201a61c: 30 bf ff dd b,a 201a590 <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;
201a620: b0 10 20 00 clr %i0
}
DEBUG_STEP("\n");
_Thread_Enable_dispatch();
return 0;
}
201a624: 81 c7 e0 08 ret
201a628: 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 30 ld [ %g1 + 0x30 ], %g1 ! 201dc30 <_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 78 ld [ %g1 + 0x278 ], %i5
20040d4: c2 07 20 78 ld [ %i4 + 0x78 ], %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 72 call 20106ac <_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 78 st %i5, [ %i4 + 0x78 ]
*
* 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 78 ld [ %i5 + 0x78 ], %g1 ! 201d078 <_impure_ptr>
20040f8: 40 00 2e 9a call 200fb60 <fclose>
20040fc: d0 00 60 04 ld [ %g1 + 4 ], %o0
fclose (stdout);
2004100: c2 07 60 78 ld [ %i5 + 0x78 ], %g1
2004104: 40 00 2e 97 call 200fb60 <fclose>
2004108: d0 00 60 08 ld [ %g1 + 8 ], %o0
fclose (stderr);
200410c: c2 07 60 78 ld [ %i5 + 0x78 ], %g1
2004110: f0 00 60 0c ld [ %g1 + 0xc ], %i0
2004114: 40 00 2e 93 call 200fb60 <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 68 or %g1, 0x168, %g1 ! 201d968 <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 30 ld [ %g1 + 0x30 ], %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 ec ld [ %g1 + 0x1ec ], %o0 ! 201cdec <RTEMS_Malloc_Heap>
2003bc8: 92 10 00 1d mov %i5, %o1
2003bcc: 94 10 20 00 clr %o2
2003bd0: 40 00 16 66 call 2009568 <_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 a0 ld [ %g1 + 0x1a0 ], %g1 ! 201d5a0 <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 7f call 200fa18 <__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 9c ld [ %g1 + 0x19c ], %g1 ! 201d59c <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 a4 ld [ %g1 + 0x1a4 ], %g1 ! 201d5a4 <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 e8 ld [ %g1 + 0xe8 ], %i5 ! 201dce8 <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 c2 call 2018b28 <.udiv>
2003c24: 90 06 00 1d add %i0, %i5, %o0
2003c28: 40 00 53 86 call 2018a40 <.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 dc ld [ %i4 + 0x3dc ], %o0 ! 201cfdc <RTEMS_Malloc_Heap>
2003c4c: 40 00 16 31 call 2009510 <_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 10 call 200fca8 <__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 dc ld [ %i4 + 0x3dc ], %i0
return (void *) 0;
}
MSBUMP(space_available, the_size);
2003c84: c4 00 60 b8 ld [ %g1 + 0xb8 ], %g2
2003c88: b4 10 20 00 clr %i2
2003c8c: ba 07 40 02 add %i5, %g2, %i5
2003c90: fa 20 60 b8 st %i5, [ %g1 + 0xb8 ]
2003c94: 40 00 16 11 call 20094d8 <_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 e8 st %i1, [ %g1 + 0xe8 ]
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 d9 call 2008034 <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
0200defc <memfile_alloc_block>:
* Allocate a block for an in-memory file.
*/
int memfile_blocks_allocated = 0;
void *memfile_alloc_block(void)
{
200defc: 9d e3 bf a0 save %sp, -96, %sp
void *memory;
memory = (void *)calloc(1, IMFS_MEMFILE_BYTES_PER_BLOCK);
200df00: 03 00 80 75 sethi %hi(0x201d400), %g1
200df04: d2 00 61 d8 ld [ %g1 + 0x1d8 ], %o1 ! 201d5d8 <imfs_memfile_bytes_per_block>
200df08: 7f ff d5 81 call 200350c <calloc>
200df0c: 90 10 20 01 mov 1, %o0
if ( memory )
200df10: b0 92 20 00 orcc %o0, 0, %i0
200df14: 02 80 00 05 be 200df28 <memfile_alloc_block+0x2c> <== NEVER TAKEN
200df18: 03 00 80 75 sethi %hi(0x201d400), %g1
memfile_blocks_allocated++;
200df1c: c4 00 62 ec ld [ %g1 + 0x2ec ], %g2 ! 201d6ec <memfile_blocks_allocated>
200df20: 84 00 a0 01 inc %g2
200df24: c4 20 62 ec st %g2, [ %g1 + 0x2ec ]
return memory;
}
200df28: 81 c7 e0 08 ret
200df2c: 81 e8 00 00 restore
0200ea2c <memfile_ftruncate>:
*/
int memfile_ftruncate(
rtems_libio_t *iop,
off_t length
)
{
200ea2c: 9d e3 bf 98 save %sp, -104, %sp
IMFS_jnode_t *the_jnode;
the_jnode = iop->pathinfo.node_access;
200ea30: 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 )
200ea34: c2 07 60 50 ld [ %i5 + 0x50 ], %g1
200ea38: 80 a0 40 19 cmp %g1, %i1
200ea3c: 06 80 00 09 bl 200ea60 <memfile_ftruncate+0x34> <== NEVER TAKEN
200ea40: 90 10 00 1d mov %i5, %o0
200ea44: 32 80 00 0d bne,a 200ea78 <memfile_ftruncate+0x4c> <== NEVER TAKEN
200ea48: f2 27 60 50 st %i1, [ %i5 + 0x50 ] <== NOT EXECUTED
200ea4c: c2 07 60 54 ld [ %i5 + 0x54 ], %g1
200ea50: 80 a0 40 1a cmp %g1, %i2
200ea54: 3a 80 00 09 bcc,a 200ea78 <memfile_ftruncate+0x4c>
200ea58: f2 27 60 50 st %i1, [ %i5 + 0x50 ]
return IMFS_memfile_extend( the_jnode, true, length );
200ea5c: 90 10 00 1d mov %i5, %o0
200ea60: 92 10 20 01 mov 1, %o1
200ea64: 94 10 00 19 mov %i1, %o2
200ea68: 7f ff fe de call 200e5e0 <IMFS_memfile_extend>
200ea6c: 96 10 00 1a mov %i2, %o3
200ea70: 81 c7 e0 08 ret
200ea74: 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;
200ea78: f4 27 60 54 st %i2, [ %i5 + 0x54 ]
IMFS_update_atime( the_jnode );
200ea7c: 90 07 bf f8 add %fp, -8, %o0
200ea80: 7f ff d3 81 call 2003884 <gettimeofday>
200ea84: 92 10 20 00 clr %o1
200ea88: c2 07 bf f8 ld [ %fp + -8 ], %g1
200ea8c: c2 27 60 40 st %g1, [ %i5 + 0x40 ]
return 0;
}
200ea90: 81 c7 e0 08 ret
200ea94: 91 e8 20 00 restore %g0, 0, %o0
0200e9b0 <memfile_open>:
rtems_libio_t *iop,
const char *pathname,
int oflag,
mode_t mode
)
{
200e9b0: 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)
200e9b4: c2 06 20 10 ld [ %i0 + 0x10 ], %g1
200e9b8: 80 88 60 04 btst 4, %g1
200e9bc: 12 80 00 04 bne 200e9cc <memfile_open+0x1c>
200e9c0: d0 06 20 1c ld [ %i0 + 0x1c ], %o0
if ((count != 0)
&& (IMFS_memfile_write(the_jnode, 0, buffer, count) == -1))
return -1;
}
return 0;
200e9c4: 81 c7 e0 08 ret
200e9c8: 91 e8 20 00 restore %g0, 0, %o0
200e9cc: 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)) {
200e9d0: c2 00 40 00 ld [ %g1 ], %g1
200e9d4: 80 a0 60 05 cmp %g1, 5
200e9d8: 12 bf ff fb bne 200e9c4 <memfile_open+0x14> <== ALWAYS TAKEN
200e9dc: 03 00 80 6e sethi %hi(0x201b800), %g1
uint32_t count = the_jnode->info.linearfile.size;
200e9e0: d8 02 20 54 ld [ %o0 + 0x54 ], %o4 <== NOT EXECUTED
const unsigned char *buffer = the_jnode->info.linearfile.direct;
200e9e4: d6 02 20 58 ld [ %o0 + 0x58 ], %o3 <== NOT EXECUTED
the_jnode->control = &IMFS_node_control_memfile;
the_jnode->info.file.size = 0;
200e9e8: 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;
200e9ec: 82 10 63 0c or %g1, 0x30c, %g1 <== NOT EXECUTED
the_jnode->info.file.size = 0;
200e9f0: 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;
200e9f4: c2 22 20 4c st %g1, [ %o0 + 0x4c ] <== NOT EXECUTED
the_jnode->info.file.size = 0;
the_jnode->info.file.indirect = 0;
200e9f8: c0 22 20 58 clr [ %o0 + 0x58 ] <== NOT EXECUTED
the_jnode->info.file.doubly_indirect = 0;
200e9fc: c0 22 20 5c clr [ %o0 + 0x5c ] <== NOT EXECUTED
the_jnode->info.file.triply_indirect = 0;
if ((count != 0)
200ea00: 80 a3 20 00 cmp %o4, 0 <== NOT EXECUTED
200ea04: 02 bf ff f0 be 200e9c4 <memfile_open+0x14> <== NOT EXECUTED
200ea08: c0 22 20 60 clr [ %o0 + 0x60 ] <== NOT EXECUTED
&& (IMFS_memfile_write(the_jnode, 0, buffer, count) == -1))
200ea0c: 92 10 20 00 clr %o1 <== NOT EXECUTED
200ea10: 7f ff ff 5c call 200e780 <IMFS_memfile_write> <== NOT EXECUTED
200ea14: 94 10 20 00 clr %o2 <== NOT EXECUTED
return -1;
200ea18: 90 38 00 08 xnor %g0, %o0, %o0 <== NOT EXECUTED
200ea1c: 80 a0 00 08 cmp %g0, %o0 <== NOT EXECUTED
200ea20: b0 40 3f ff addx %g0, -1, %i0 <== NOT EXECUTED
}
return 0;
}
200ea24: 81 c7 e0 08 ret <== NOT EXECUTED
200ea28: 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 4e call 200c2f0 <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 18 or %l1, 0x318, %l1 ! 201b718 <rtems_status_assoc+0x1a0>
size_t filesystemtype_size = strlen( filesystemtype ) + 1;
2003ddc: 40 00 34 8c call 201100c <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 86 call 201100c <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 80 call 201100c <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 3e call 2010334 <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 38 call 2010334 <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 32 call 2010334 <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 1c or %g1, 0x31c, %g1 ! 201b71c <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 4e call 20083e4 <_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 58 ld [ %i4 + 0x158 ], %o0 ! 201d958 <rtems_libio_semaphore>
2003f48: 40 00 0e 70 call 2007908 <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 58 ld [ %i4 + 0x158 ], %o0
2003f58: 82 10 62 f8 or %g1, 0x2f8, %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 b0 call 2007a30 <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 58 ld [ %g1 + 0x158 ], %o0 ! 201d958 <rtems_libio_semaphore>
2003fbc: 92 10 20 00 clr %o1
2003fc0: 40 00 0e 52 call 2007908 <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 f8 ld [ %g2 + 0x2f8 ], %g3 ! 201cef8 <rtems_filesystem_mount_table>
2003fd0: 82 10 a2 f8 or %g2, 0x2f8, %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 87 call 200fa18 <__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 88 call 2007a30 <rtems_semaphore_release>
2004014: d0 00 61 58 ld [ %g1 + 0x158 ], %o0 ! 201d958 <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 18 ld [ %i5 + 0x318 ], %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 18 ld [ %i5 + 0x318 ], %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 68 call 200fa18 <__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 60 call 200fa18 <__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 2a call 2020bbc <__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
02015ffc <msdos_creat_node>:
msdos_node_type_t type,
const char *name,
int name_len,
mode_t mode,
const fat_file_fd_t *link_fd)
{
2015ffc: 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;
2016000: 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);
2016004: 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;
2016008: 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;
201600c: 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);
2016010: 94 10 20 20 mov 0x20, %o2
2016014: c2 27 bf 78 st %g1, [ %fp + -136 ]
dir_pos->lname.ofs = FAT_FILE_SHORT_NAME;
2016018: 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;
201601c: e0 06 20 08 ld [ %i0 + 8 ], %l0
fat_file_fd_t *fat_fd = NULL;
2016020: c0 27 bf 6c clr [ %fp + -148 ]
time_t time_ret = 0;
uint16_t time_val = 0;
2016024: c0 37 bf 68 clrh [ %fp + -152 ]
uint16_t date = 0;
2016028: 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;
201602c: c0 27 bf 70 clr [ %fp + -144 ]
dir_pos->sname.ofs = 0;
2016030: 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);
2016034: 40 00 12 ed call 201abe8 <memset>
2016038: 90 07 bf 80 add %fp, -128, %o0
memset(dot_dotdot, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE * 2);
201603c: 90 07 bf c0 add %fp, -64, %o0
2016040: 92 10 20 00 clr %o1
2016044: 40 00 12 e9 call 201abe8 <memset>
2016048: 94 10 20 40 mov 0x40, %o2
if (name_len > MSDOS_NAME_MAX_LFN_WITH_DOT) {
201604c: 80 a6 e1 04 cmp %i3, 0x104
2016050: 24 80 00 06 ble,a 2016068 <msdos_creat_node+0x6c> <== ALWAYS TAKEN
2016054: 90 10 00 1a mov %i2, %o0
rtems_set_errno_and_return_minus_one(ENAMETOOLONG);
2016058: 40 00 0f f2 call 201a020 <__errno> <== NOT EXECUTED
201605c: 01 00 00 00 nop <== NOT EXECUTED
2016060: 10 80 00 0c b 2016090 <msdos_creat_node+0x94> <== NOT EXECUTED
2016064: 82 10 20 5b mov 0x5b, %g1 ! 5b <PROM_START+0x5b> <== NOT EXECUTED
}
name_type = msdos_long_to_short (name, name_len,
2016068: 92 10 00 1b mov %i3, %o1
201606c: 94 07 bf 80 add %fp, -128, %o2
2016070: 40 00 01 45 call 2016584 <msdos_long_to_short>
2016074: 96 10 20 0b mov 0xb, %o3
MSDOS_DIR_NAME(short_node),
MSDOS_NAME_MAX);
if (name_type == MSDOS_NAME_INVALID) {
2016078: a4 92 20 00 orcc %o0, 0, %l2
201607c: 32 80 00 08 bne,a 201609c <msdos_creat_node+0xa0> <== ALWAYS TAKEN
2016080: c0 2f bf 8c clrb [ %fp + -116 ]
rtems_set_errno_and_return_minus_one(EINVAL);
2016084: 40 00 0f e7 call 201a020 <__errno> <== NOT EXECUTED
2016088: 01 00 00 00 nop <== NOT EXECUTED
201608c: 82 10 20 16 mov 0x16, %g1 ! 16 <PROM_START+0x16> <== NOT EXECUTED
2016090: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
2016094: 10 80 00 ce b 20163cc <msdos_creat_node+0x3d0> <== NOT EXECUTED
2016098: 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);
201609c: 40 00 16 c8 call 201bbbc <time>
20160a0: 90 10 20 00 clr %o0
if ( time_ret == -1 )
20160a4: 80 a2 3f ff cmp %o0, -1
20160a8: 12 80 00 04 bne 20160b8 <msdos_creat_node+0xbc> <== ALWAYS TAKEN
20160ac: 92 07 bf 6a add %fp, -150, %o1
20160b0: 10 80 00 c7 b 20163cc <msdos_creat_node+0x3d0> <== NOT EXECUTED
20160b4: ba 10 3f ff mov -1, %i5 <== NOT EXECUTED
return -1;
msdos_date_unix2dos(time_ret, &date, &time_val);
20160b8: 40 00 0c 36 call 2019190 <msdos_date_unix2dos>
20160bc: 94 07 bf 68 add %fp, -152, %o2
*MSDOS_DIR_CRT_TIME(short_node) = CT_LE_W(time_val);
20160c0: c2 17 bf 68 lduh [ %fp + -152 ], %g1
*MSDOS_DIR_CRT_DATE(short_node) = CT_LE_W(date);
20160c4: 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);
20160c8: 83 28 60 10 sll %g1, 0x10, %g1
20160cc: 85 30 60 08 srl %g1, 8, %g2
20160d0: 83 30 60 18 srl %g1, 0x18, %g1
*MSDOS_DIR_CRT_DATE(short_node) = CT_LE_W(date);
20160d4: 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);
20160d8: 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;
20160dc: 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);
20160e0: 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);
20160e4: c4 37 bf 8e sth %g2, [ %fp + -114 ]
*MSDOS_DIR_CRT_DATE(short_node) = CT_LE_W(date);
20160e8: 87 30 e0 18 srl %g3, 0x18, %g3
*MSDOS_DIR_WRITE_TIME(short_node) = CT_LE_W(time_val);
20160ec: 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);
20160f0: 82 10 40 03 or %g1, %g3, %g1
20160f4: 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);
20160f8: 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) {
20160fc: 80 a6 60 00 cmp %i1, 0
2016100: 12 80 00 05 bne 2016114 <msdos_creat_node+0x118>
2016104: c2 37 bf 92 sth %g1, [ %fp + -110 ]
*MSDOS_DIR_ATTR(short_node) |= MSDOS_ATTR_DIRECTORY;
2016108: c2 0f bf 8b ldub [ %fp + -117 ], %g1
201610c: 10 80 00 2f b 20161c8 <msdos_creat_node+0x1cc>
2016110: 82 10 60 10 or %g1, 0x10, %g1
}
else if (type == MSDOS_HARD_LINK) {
2016114: 80 a6 60 02 cmp %i1, 2
2016118: 12 80 00 2b bne 20161c4 <msdos_creat_node+0x1c8> <== ALWAYS TAKEN
201611c: 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,
2016120: 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)) )
2016124: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED
2016128: 32 80 00 08 bne,a 2016148 <msdos_creat_node+0x14c> <== NOT EXECUTED
201612c: c2 0f 20 05 ldub [ %i4 + 5 ], %g1 <== NOT EXECUTED
2016130: c2 0f 20 0a ldub [ %i4 + 0xa ], %g1 <== NOT EXECUTED
2016134: 80 88 60 03 btst 3, %g1 <== NOT EXECUTED
2016138: 22 80 00 04 be,a 2016148 <msdos_creat_node+0x14c> <== NOT EXECUTED
201613c: c2 0f 20 05 ldub [ %i4 + 5 ], %g1 <== NOT EXECUTED
return fs_info->vol.rdir_loc;
2016140: 10 80 00 06 b 2016158 <msdos_creat_node+0x15c> <== NOT EXECUTED
2016144: c4 07 20 1c ld [ %i4 + 0x1c ], %g2 <== NOT EXECUTED
return (((cln - FAT_RSRVD_CLN) << fs_info->vol.spc_log2) +
2016148: 84 00 bf fe add %g2, -2, %g2 <== NOT EXECUTED
201614c: 85 28 80 01 sll %g2, %g1, %g2 <== NOT EXECUTED
2016150: c2 07 20 30 ld [ %i4 + 0x30 ], %g1 <== NOT EXECUTED
2016154: 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);
2016158: c2 07 60 24 ld [ %i5 + 0x24 ], %g1 <== NOT EXECUTED
201615c: d2 0f 20 02 ldub [ %i4 + 2 ], %o1 <== NOT EXECUTED
byte = (link_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1));
2016160: 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);
2016164: 93 30 40 09 srl %g1, %o1, %o1 <== NOT EXECUTED
byte = (link_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1));
2016168: 94 02 bf ff add %o2, -1, %o2 <== NOT EXECUTED
ret = _fat_block_read(&fs_info->fat,
201616c: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
2016170: 92 00 80 09 add %g2, %o1, %o1 <== NOT EXECUTED
2016174: 94 0a 80 01 and %o2, %g1, %o2 <== NOT EXECUTED
2016178: 96 10 20 20 mov 0x20, %o3 <== NOT EXECUTED
201617c: 7f ff ee 7a call 2011b64 <_fat_block_read> <== NOT EXECUTED
2016180: 98 07 bf a0 add %fp, -96, %o4 <== NOT EXECUTED
sec, byte, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE,
link_node);
if (ret < 0) {
2016184: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2016188: 06 bf ff c3 bl 2016094 <msdos_creat_node+0x98> <== NOT EXECUTED
201618c: 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);
2016190: c2 2f bf 8d stb %g1, [ %fp + -115 ] <== NOT EXECUTED
*MSDOS_DIR_CRT_TIME(short_node) =*MSDOS_DIR_CRT_TIME(link_node);
2016194: c2 17 bf ae lduh [ %fp + -82 ], %g1 <== NOT EXECUTED
2016198: c2 37 bf 8e sth %g1, [ %fp + -114 ] <== NOT EXECUTED
*MSDOS_DIR_CRT_DATE(short_node) =*MSDOS_DIR_CRT_DATE(link_node);
201619c: c2 17 bf b0 lduh [ %fp + -80 ], %g1 <== NOT EXECUTED
20161a0: 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);
20161a4: c2 07 bf bc ld [ %fp + -68 ], %g1 <== NOT EXECUTED
20161a8: c2 27 bf 9c st %g1, [ %fp + -100 ] <== NOT EXECUTED
*MSDOS_DIR_FIRST_CLUSTER_LOW(short_node) =
20161ac: c2 17 bf ba lduh [ %fp + -70 ], %g1 <== NOT EXECUTED
20161b0: c2 37 bf 9a sth %g1, [ %fp + -102 ] <== NOT EXECUTED
*MSDOS_DIR_FIRST_CLUSTER_LOW(link_node);
*MSDOS_DIR_FIRST_CLUSTER_HI(short_node) =
20161b4: c2 17 bf b4 lduh [ %fp + -76 ], %g1 <== NOT EXECUTED
20161b8: 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;
20161bc: 10 80 00 02 b 20161c4 <msdos_creat_node+0x1c8> <== NOT EXECUTED
20161c0: c2 0f bf ab ldub [ %fp + -85 ], %g1 <== NOT EXECUTED
}
else { /* regular file... */
*MSDOS_DIR_ATTR(short_node) |= MSDOS_ATTR_ARCHIVE;
20161c4: 82 10 60 20 or %g1, 0x20, %g1
20161c8: 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);
20161cc: 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,
20161d0: 90 10 00 18 mov %i0, %o0
20161d4: e2 23 a0 5c st %l1, [ %sp + 0x5c ]
20161d8: 92 10 20 01 mov 1, %o1
20161dc: 94 10 00 1a mov %i2, %o2
20161e0: 96 10 00 1b mov %i3, %o3
20161e4: 98 10 00 12 mov %l2, %o4
20161e8: 40 00 05 fc call 20179d8 <msdos_get_name_node>
20161ec: 9a 07 bf 70 add %fp, -144, %o5
name_type, &dir_pos, short_node);
if ( rc != RC_OK )
20161f0: ba 92 20 00 orcc %o0, 0, %i5
20161f4: 12 80 00 76 bne 20163cc <msdos_creat_node+0x3d0> <== NEVER TAKEN
20161f8: 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)
20161fc: 32 80 00 75 bne,a 20163d0 <msdos_creat_node+0x3d4>
2016200: b0 10 00 1d mov %i5, %i0
{
/* open new directory as fat-file */
rc = fat_file_open(&fs_info->fat, &dir_pos, &fat_fd);
2016204: 90 10 00 1c mov %i4, %o0
2016208: 92 07 bf 70 add %fp, -144, %o1
201620c: 7f ff ea a3 call 2010c98 <fat_file_open>
2016210: 94 07 bf 6c add %fp, -148, %o2
if (rc != RC_OK)
2016214: ba 92 20 00 orcc %o0, 0, %i5
2016218: 32 80 00 6a bne,a 20163c0 <msdos_creat_node+0x3c4> <== NEVER TAKEN
201621c: 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;
2016220: fa 07 bf 6c ld [ %fp + -148 ], %i5
fat_fd->fat_file_type = FAT_DIRECTORY;
fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
2016224: 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,
2016228: 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;
201622c: 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,
2016230: 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;
2016234: c0 27 60 18 clr [ %i5 + 0x18 ]
fat_fd->fat_file_type = FAT_DIRECTORY;
2016238: 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,
201623c: 40 00 12 2e call 201aaf4 <memcpy>
2016240: 90 07 bf c0 add %fp, -64, %o0
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
memcpy(DOTDOT_NODE_P(dot_dotdot), short_node,
2016244: 92 10 00 11 mov %l1, %o1
2016248: 94 10 20 20 mov 0x20, %o2
201624c: 40 00 12 2a call 201aaf4 <memcpy>
2016250: 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,
2016254: 03 00 80 99 sethi %hi(0x2026400), %g1
2016258: d2 00 63 54 ld [ %g1 + 0x354 ], %o1 ! 2026754 <MSDOS_DOT_NAME>
201625c: 94 10 20 0b mov 0xb, %o2
2016260: 40 00 12 25 call 201aaf4 <memcpy>
2016264: 90 07 bf c0 add %fp, -64, %o0
MSDOS_NAME_MAX);
memcpy(MSDOS_DIR_NAME(DOTDOT_NODE_P(dot_dotdot)), MSDOS_DOTDOT_NAME,
2016268: 03 00 80 99 sethi %hi(0x2026400), %g1
201626c: d2 00 63 50 ld [ %g1 + 0x350 ], %o1 ! 2026750 <MSDOS_DOTDOT_NAME>
2016270: 90 07 bf e0 add %fp, -32, %o0
2016274: 40 00 12 20 call 201aaf4 <memcpy>
2016278: 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)) &&
201627c: c2 04 20 20 ld [ %l0 + 0x20 ], %g1
2016280: 80 a0 60 01 cmp %g1, 1
2016284: 32 80 00 0e bne,a 20162bc <msdos_creat_node+0x2c0>
2016288: c2 04 20 1c ld [ %l0 + 0x1c ], %g1
201628c: c2 04 20 24 ld [ %l0 + 0x24 ], %g1
2016290: 80 a0 60 00 cmp %g1, 0
2016294: 32 80 00 0a bne,a 20162bc <msdos_creat_node+0x2c0> <== NEVER TAKEN
2016298: c2 04 20 1c ld [ %l0 + 0x1c ], %g1 <== NOT EXECUTED
(fs_info->fat.vol.type & FAT_FAT32))
201629c: 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)) &&
20162a0: 82 08 60 04 and %g1, 4, %g1
20162a4: 80 88 60 ff btst 0xff, %g1
20162a8: 22 80 00 05 be,a 20162bc <msdos_creat_node+0x2c0> <== ALWAYS TAKEN
20162ac: 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;
20162b0: c0 37 bf fa clrh [ %fp + -6 ] <== NOT EXECUTED
*MSDOS_DIR_FIRST_CLUSTER_HI(DOTDOT_NODE_P(dot_dotdot)) = 0x0000;
20162b4: 10 80 00 10 b 20162f4 <msdos_creat_node+0x2f8> <== NOT EXECUTED
20162b8: 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;
}
20162bc: 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)) =
20162c0: 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;
}
20162c4: 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)) =
20162c8: 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;
}
20162cc: 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));
20162d0: 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));
20162d4: 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;
}
20162d8: 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)) =
20162dc: 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));
20162e0: 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)) =
20162e4: 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)) =
20162e8: 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)) =
20162ec: 82 10 80 01 or %g2, %g1, %g1
20162f0: 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,
20162f4: 90 10 00 1c mov %i4, %o0
20162f8: 92 10 00 1d mov %i5, %o1
20162fc: 94 10 20 00 clr %o2
2016300: 96 10 20 40 mov 0x40, %o3
2016304: 7f ff ec 77 call 20114e0 <fat_file_write>
2016308: 98 07 bf c0 add %fp, -64, %o4
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE * 2,
(uint8_t *)dot_dotdot);
if (ret < 0)
201630c: 80 a2 20 00 cmp %o0, 0
2016310: 06 80 00 27 bl 20163ac <msdos_creat_node+0x3b0> <== NEVER TAKEN
2016314: 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;
2016318: c2 17 20 06 lduh [ %i4 + 6 ], %g1
201631c: 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,
2016320: 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;
2016324: 82 00 80 01 add %g2, %g1, %g1
2016328: 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));
201632c: 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;
}
2016330: 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)) =
2016334: 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;
}
2016338: 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)) =
201633c: 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;
}
2016340: 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));
2016344: 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));
2016348: 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;
}
201634c: 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)) =
2016350: 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));
2016354: 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)) =
2016358: 83 30 60 08 srl %g1, 8, %g1
201635c: 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)) =
2016360: 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)) =
2016364: 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,
2016368: 94 10 20 00 clr %o2
201636c: 96 10 20 20 mov 0x20, %o3
2016370: 7f ff ec 5c call 20114e0 <fat_file_write>
2016374: 98 07 bf c0 add %fp, -64, %o4
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE,
(uint8_t *)DOT_NODE_P(dot_dotdot));
if (ret < 0)
2016378: 80 a2 20 00 cmp %o0, 0
201637c: 06 80 00 0d bl 20163b0 <msdos_creat_node+0x3b4> <== NEVER TAKEN
2016380: 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);
2016384: d0 06 20 14 ld [ %i0 + 0x14 ], %o0
2016388: 40 00 01 45 call 201689c <msdos_set_first_cluster_num>
201638c: d2 07 bf 6c ld [ %fp + -148 ], %o1
if (rc != RC_OK)
2016390: ba 92 20 00 orcc %o0, 0, %i5
2016394: 12 80 00 08 bne 20163b4 <msdos_creat_node+0x3b8> <== NEVER TAKEN
2016398: d2 07 bf 6c ld [ %fp + -148 ], %o1
goto error;
fat_file_close(&fs_info->fat, fat_fd);
201639c: 7f ff eb 55 call 20110f0 <fat_file_close>
20163a0: 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;
}
20163a4: 81 c7 e0 08 ret
20163a8: 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;
20163ac: 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);
20163b0: d2 07 bf 6c ld [ %fp + -148 ], %o1 <== NOT EXECUTED
20163b4: 7f ff eb 4f call 20110f0 <fat_file_close> <== NOT EXECUTED
20163b8: 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);
20163bc: d0 06 20 14 ld [ %i0 + 0x14 ], %o0 <== NOT EXECUTED
20163c0: 92 07 bf 70 add %fp, -144, %o1 <== NOT EXECUTED
20163c4: 40 00 01 81 call 20169c8 <msdos_set_first_char4file_name> <== NOT EXECUTED
20163c8: 94 10 20 e5 mov 0xe5, %o2 <== NOT EXECUTED
return rc;
}
20163cc: b0 10 00 1d mov %i5, %i0 <== NOT EXECUTED
20163d0: 81 c7 e0 08 ret
20163d4: 81 e8 00 00 restore
020192dc <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;
20192dc: 85 32 60 0b srl %o1, 0xb, %g2
20192e0: 84 08 a0 1f and %g2, 0x1f, %g2
20192e4: 87 28 a0 03 sll %g2, 3, %g3
20192e8: 83 28 a0 07 sll %g2, 7, %g1
20192ec: 82 20 40 03 sub %g1, %g3, %g1
20192f0: 85 28 60 04 sll %g1, 4, %g2
20192f4: 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
20192f8: 82 0a 67 e0 and %o1, 0x7e0, %g1
20192fc: 87 30 60 04 srl %g1, 4, %g3
2019300: 82 20 40 03 sub %g1, %g3, %g1
+ ((dt & MSDOS_DT_HOURS_MASK) >> MSDOS_DT_HOURS_SHIFT) * 3600;
2019304: 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)
2019308: 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;
201930c: 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) {
2019310: 03 00 80 a0 sethi %hi(0x2028000), %g1
2019314: c4 10 62 fa lduh [ %g1 + 0x2fa ], %g2 ! 20282fa <lastdosdate>
2019318: 80 a0 80 08 cmp %g2, %o0
201931c: 02 80 00 34 be 20193ec <msdos_date_dos2unix+0x110>
2019320: 93 2a 60 01 sll %o1, 1, %o1
lastdosdate = dd;
2019324: d0 30 62 fa sth %o0, [ %g1 + 0x2fa ]
days = 0;
year = (dd & MSDOS_DD_YEAR_MASK) >> MSDOS_DD_YEAR_SHIFT;
2019328: 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;
201932c: 82 10 20 00 clr %g1
year = (dd & MSDOS_DD_YEAR_MASK) >> MSDOS_DD_YEAR_SHIFT;
2019330: 88 09 20 7f and %g4, 0x7f, %g4
for (y = 0; y < year; y++)
2019334: 10 80 00 07 b 2019350 <msdos_date_dos2unix+0x74>
2019338: 84 10 20 00 clr %g2
days += y & 0x03 ? 365 : 366;
201933c: 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++)
2019340: 84 00 a0 01 inc %g2
days += y & 0x03 ? 365 : 366;
2019344: 86 60 3f ff subx %g0, -1, %g3
2019348: 86 00 e1 6d add %g3, 0x16d, %g3
201934c: 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++)
2019350: 80 a0 80 04 cmp %g2, %g4
2019354: 12 bf ff fa bne 201933c <msdos_date_dos2unix+0x60>
2019358: 86 08 a0 03 and %g2, 3, %g3
days += y & 0x03 ? 365 : 366;
months = year & 0x03 ? regyear : leapyear;
201935c: 80 a0 e0 00 cmp %g3, 0
2019360: 22 80 00 05 be,a 2019374 <msdos_date_dos2unix+0x98> <== ALWAYS TAKEN
2019364: 09 00 80 9e sethi %hi(0x2027800), %g4
2019368: 09 00 80 9e sethi %hi(0x2027800), %g4 <== NOT EXECUTED
201936c: 10 80 00 03 b 2019378 <msdos_date_dos2unix+0x9c> <== NOT EXECUTED
2019370: 88 11 23 88 or %g4, 0x388, %g4 ! 2027b88 <regyear> <== NOT EXECUTED
2019374: 88 11 23 a0 or %g4, 0x3a0, %g4
/*
* Prevent going from 0 to 0xffffffff in the following
* loop.
*/
month = (dd & MSDOS_DD_MONTH_MASK) >> MSDOS_DD_MONTH_SHIFT;
2019378: 86 0a 21 e0 and %o0, 0x1e0, %g3
201937c: 87 30 e0 05 srl %g3, 5, %g3
if (month == 0) {
2019380: 80 a0 e0 00 cmp %g3, 0
2019384: 22 80 00 02 be,a 201938c <msdos_date_dos2unix+0xb0> <== NEVER TAKEN
2019388: 86 10 20 01 mov 1, %g3 <== NOT EXECUTED
month = 1;
}
for (m = 0; m < month - 1; m++)
201938c: 84 10 20 00 clr %g2
2019390: 10 80 00 05 b 20193a4 <msdos_date_dos2unix+0xc8>
2019394: 86 00 ff ff add %g3, -1, %g3
days += months[m];
2019398: 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++)
201939c: 84 00 a0 01 inc %g2 <== NOT EXECUTED
days += months[m];
20193a0: 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++)
20193a4: 80 a0 80 03 cmp %g2, %g3
20193a8: 0a bf ff fc bcs 2019398 <msdos_date_dos2unix+0xbc> <== NEVER TAKEN
20193ac: 9b 28 a0 01 sll %g2, 1, %o5
days += months[m];
days += ((dd & MSDOS_DD_DAY_MASK) >> MSDOS_DD_DAY_SHIFT) - 1;
20193b0: 90 0a 20 1f and %o0, 0x1f, %o0
20193b4: 90 02 3f ff add %o0, -1, %o0
20193b8: 82 02 00 01 add %o0, %g1, %g1
lastseconds = (days + DAYSTO1980) * SECONDSPERDAY;
20193bc: 85 28 60 07 sll %g1, 7, %g2
20193c0: 83 28 60 09 sll %g1, 9, %g1
20193c4: 82 20 40 02 sub %g1, %g2, %g1
20193c8: 85 28 60 04 sll %g1, 4, %g2
20193cc: 82 20 80 01 sub %g2, %g1, %g1
20193d0: 85 28 60 04 sll %g1, 4, %g2
20193d4: 82 20 80 01 sub %g2, %g1, %g1
20193d8: 05 04 b3 a9 sethi %hi(0x12cea400), %g2
20193dc: 84 10 a2 00 or %g2, 0x200, %g2 ! 12cea600 <RAM_END+0x108ea600>
20193e0: 82 00 40 02 add %g1, %g2, %g1
20193e4: 05 00 80 a0 sethi %hi(0x2028000), %g2
20193e8: c2 20 a2 fc st %g1, [ %g2 + 0x2fc ] ! 20282fc <lastseconds>
}
return seconds + lastseconds;
20193ec: 03 00 80 a0 sethi %hi(0x2028000), %g1
20193f0: d0 00 62 fc ld [ %g1 + 0x2fc ], %o0 ! 20282fc <lastseconds>
}
20193f4: 81 c3 e0 08 retl
20193f8: 90 02 40 08 add %o1, %o0, %o0
02019190 <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)
{
2019190: 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) {
2019194: 03 00 80 a0 sethi %hi(0x2028000), %g1
2019198: c4 00 62 ec ld [ %g1 + 0x2ec ], %g2 ! 20282ec <lasttime>
201919c: 80 a0 80 18 cmp %g2, %i0
20191a0: 02 80 00 47 be 20192bc <msdos_date_unix2dos+0x12c>
20191a4: 92 10 20 3c mov 0x3c, %o1
lasttime = t;
20191a8: f0 20 62 ec st %i0, [ %g1 + 0x2ec ]
lastdtime = (((t % 60) >> 1) << MSDOS_DT_2SECONDS_SHIFT)
+ (((t / 60) % 60) << MSDOS_DT_MINUTES_SHIFT)
20191ac: 40 00 27 db call 2023118 <.udiv>
20191b0: 90 10 00 18 mov %i0, %o0
20191b4: 40 00 28 85 call 20233c8 <.urem>
20191b8: 92 10 20 3c mov 0x3c, %o1
+ (((t / 3600) % 24) << MSDOS_DT_HOURS_SHIFT);
20191bc: 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)
20191c0: bb 2a 20 05 sll %o0, 5, %i5
+ (((t / 60) % 60) << MSDOS_DT_MINUTES_SHIFT)
+ (((t / 3600) % 24) << MSDOS_DT_HOURS_SHIFT);
20191c4: 40 00 27 d5 call 2023118 <.udiv>
20191c8: 90 10 00 18 mov %i0, %o0
20191cc: 40 00 28 7f call 20233c8 <.urem>
20191d0: 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)
20191d4: 91 2a 20 0b sll %o0, 0xb, %o0
20191d8: 92 10 20 3c mov 0x3c, %o1
20191dc: ba 07 40 08 add %i5, %o0, %i5
20191e0: 40 00 28 7a call 20233c8 <.urem>
20191e4: 90 10 00 18 mov %i0, %o0
20191e8: 03 00 80 a0 sethi %hi(0x2028000), %g1
20191ec: 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);
20191f0: 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)
20191f4: 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);
20191f8: 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)
20191fc: fa 30 62 f0 sth %i5, [ %g1 + 0x2f0 ]
/*
* 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);
2019200: 40 00 27 c6 call 2023118 <.udiv>
2019204: 90 10 00 18 mov %i0, %o0
if (days != lastday) {
2019208: 03 00 80 a0 sethi %hi(0x2028000), %g1
201920c: c4 00 62 f4 ld [ %g1 + 0x2f4 ], %g2 ! 20282f4 <lastday>
2019210: 80 a2 00 02 cmp %o0, %g2
2019214: 22 80 00 2b be,a 20192c0 <msdos_date_unix2dos+0x130>
2019218: 03 00 80 a0 sethi %hi(0x2028000), %g1
lastday = days;
201921c: d0 20 62 f4 st %o0, [ %g1 + 0x2f4 ] ! 20282f4 <lastday>
for (year = 1970;; year++) {
2019220: 82 10 27 b2 mov 0x7b2, %g1
inc = year & 0x03 ? 365 : 366;
2019224: 84 08 60 03 and %g1, 3, %g2
2019228: 80 a0 00 02 cmp %g0, %g2
201922c: 86 60 3f ff subx %g0, -1, %g3
2019230: 86 00 e1 6d add %g3, 0x16d, %g3
if (days < inc)
2019234: 80 a2 00 03 cmp %o0, %g3
2019238: 0a 80 00 05 bcs 201924c <msdos_date_unix2dos+0xbc>
201923c: 80 a0 a0 00 cmp %g2, 0
break;
days -= inc;
2019240: 90 22 00 03 sub %o0, %g3, %o0
}
2019244: 10 bf ff f8 b 2019224 <msdos_date_unix2dos+0x94>
2019248: 82 00 60 01 inc %g1
months = year & 0x03 ? regyear : leapyear;
201924c: 22 80 00 05 be,a 2019260 <msdos_date_unix2dos+0xd0> <== ALWAYS TAKEN
2019250: 09 00 80 9e sethi %hi(0x2027800), %g4
2019254: 09 00 80 9e sethi %hi(0x2027800), %g4 <== NOT EXECUTED
2019258: 10 80 00 03 b 2019264 <msdos_date_unix2dos+0xd4> <== NOT EXECUTED
201925c: 88 11 23 88 or %g4, 0x388, %g4 ! 2027b88 <regyear> <== NOT EXECUTED
2019260: 88 11 23 a0 or %g4, 0x3a0, %g4
for (month = 0; month < 12; month++) {
2019264: 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,
2019268: 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])
201926c: c6 11 00 03 lduh [ %g4 + %g3 ], %g3
2019270: 80 a2 00 03 cmp %o0, %g3
2019274: 2a 80 00 07 bcs,a 2019290 <msdos_date_unix2dos+0x100> <== ALWAYS TAKEN
2019278: 90 02 20 01 inc %o0
if (days < inc)
break;
days -= inc;
}
months = year & 0x03 ? regyear : leapyear;
for (month = 0; month < 12; month++) {
201927c: 84 00 a0 01 inc %g2 <== NOT EXECUTED
2019280: 80 a0 a0 0c cmp %g2, 0xc <== NOT EXECUTED
2019284: 12 bf ff f9 bne 2019268 <msdos_date_unix2dos+0xd8> <== NOT EXECUTED
2019288: 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)
201928c: 90 02 20 01 inc %o0 <== NOT EXECUTED
2019290: 84 00 a0 01 inc %g2
2019294: 07 00 80 a0 sethi %hi(0x2028000), %g3
2019298: 85 28 a0 05 sll %g2, 5, %g2
201929c: 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)
20192a0: 80 a0 67 bc cmp %g1, 0x7bc
20192a4: 08 80 00 06 bleu 20192bc <msdos_date_unix2dos+0x12c> <== NEVER TAKEN
20192a8: d0 30 e2 f8 sth %o0, [ %g3 + 0x2f8 ]
lastddate += (year - 1980) <<
20192ac: 82 00 78 44 add %g1, -1980, %g1
20192b0: 83 28 60 09 sll %g1, 9, %g1
20192b4: 90 02 00 01 add %o0, %g1, %o0
20192b8: d0 30 e2 f8 sth %o0, [ %g3 + 0x2f8 ]
MSDOS_DD_YEAR_SHIFT;
}
}
*dtp = lastdtime;
20192bc: 03 00 80 a0 sethi %hi(0x2028000), %g1
20192c0: c2 10 62 f0 lduh [ %g1 + 0x2f0 ], %g1 ! 20282f0 <lastdtime>
20192c4: c2 36 80 00 sth %g1, [ %i2 ]
*ddp = lastddate;
20192c8: 03 00 80 a0 sethi %hi(0x2028000), %g1
20192cc: c2 10 62 f8 lduh [ %g1 + 0x2f8 ], %g1 ! 20282f8 <lastddate>
20192d0: c2 36 40 00 sth %g1, [ %i1 ]
20192d4: 81 c7 e0 08 ret
20192d8: 81 e8 00 00 restore
02016afc <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
)
{
2016afc: 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,
2016b00: 23 00 80 99 sethi %hi(0x2026400), %l1
fat_file_fd_t *fat_fd,
bool *ret_val
)
{
ssize_t ret = 0;
msdos_fs_info_t *fs_info = mt_entry->fs_info;
2016b04: 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)),
2016b08: 25 00 80 99 sethi %hi(0x2026400), %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;
2016b0c: 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;
2016b10: 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,
2016b14: a2 14 63 10 or %l1, 0x310, %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,
2016b18: 10 80 00 33 b 2016be4 <msdos_dir_is_empty+0xe8>
2016b1c: a4 14 a3 20 or %l2, 0x320, %l2
fs_info->fat.vol.bps,
fs_info->cl_buf)) != FAT_EOF)
{
if (ret < MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
2016b20: 04 80 00 2a ble 2016bc8 <msdos_dir_is_empty+0xcc> <== NEVER TAKEN
2016b24: b0 10 3f ff mov -1, %i0
return -1;
assert(ret == fs_info->fat.vol.bps);
2016b28: c2 17 40 00 lduh [ %i5 ], %g1
2016b2c: 80 a2 00 01 cmp %o0, %g1
2016b30: 02 80 00 28 be 2016bd0 <msdos_dir_is_empty+0xd4> <== ALWAYS TAKEN
2016b34: b8 10 20 00 clr %i4
2016b38: 11 00 80 99 sethi %hi(0x2026400), %o0 <== NOT EXECUTED
2016b3c: 15 00 80 99 sethi %hi(0x2026400), %o2 <== NOT EXECUTED
2016b40: 17 00 80 99 sethi %hi(0x2026400), %o3 <== NOT EXECUTED
2016b44: 90 12 22 a0 or %o0, 0x2a0, %o0 <== NOT EXECUTED
2016b48: 92 10 23 60 mov 0x360, %o1 <== NOT EXECUTED
2016b4c: 94 12 a3 58 or %o2, 0x358, %o2 <== NOT EXECUTED
2016b50: 7f ff f1 22 call 2012fd8 <__assert_func> <== NOT EXECUTED
2016b54: 96 12 e2 f0 or %o3, 0x2f0, %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)) ==
2016b58: e0 08 40 1c ldub [ %g1 + %i4 ], %l0
2016b5c: 80 a4 20 e5 cmp %l0, 0xe5
2016b60: 02 80 00 14 be 2016bb0 <msdos_dir_is_empty+0xb4> <== NEVER TAKEN
2016b64: b0 00 40 1c add %g1, %i4, %i0
MSDOS_THIS_DIR_ENTRY_EMPTY) ||
((*MSDOS_DIR_ATTR(entry) & MSDOS_ATTR_LFN_MASK) ==
2016b68: 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) ||
2016b6c: 82 08 60 3f and %g1, 0x3f, %g1
2016b70: 80 a0 60 0f cmp %g1, 0xf
2016b74: 02 80 00 0f be 2016bb0 <msdos_dir_is_empty+0xb4> <== NEVER TAKEN
2016b78: 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,
2016b7c: 92 10 00 11 mov %l1, %o1
2016b80: 40 00 13 b9 call 201ba64 <strncmp>
2016b84: 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) ||
2016b88: 80 a2 20 00 cmp %o0, 0
2016b8c: 22 80 00 12 be,a 2016bd4 <msdos_dir_is_empty+0xd8>
2016b90: 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)),
2016b94: 90 10 00 18 mov %i0, %o0
2016b98: 92 10 00 12 mov %l2, %o1
2016b9c: 40 00 13 b2 call 201ba64 <strncmp>
2016ba0: 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) ||
2016ba4: 80 a2 20 00 cmp %o0, 0
2016ba8: 12 80 00 04 bne 2016bb8 <msdos_dir_is_empty+0xbc>
2016bac: 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)
2016bb0: 10 80 00 09 b 2016bd4 <msdos_dir_is_empty+0xd8>
2016bb4: b8 07 20 20 add %i4, 0x20, %i4
continue;
/*
* Nothing more to look at.
*/
if ((*MSDOS_DIR_NAME(entry)) ==
2016bb8: 12 80 00 04 bne 2016bc8 <msdos_dir_is_empty+0xcc>
2016bbc: b0 10 20 00 clr %i0
MSDOS_THIS_DIR_ENTRY_AND_REST_EMPTY)
{
*ret_val = true;
2016bc0: 82 10 20 01 mov 1, %g1
2016bc4: c2 2e 80 00 stb %g1, [ %i2 ]
return RC_OK;
2016bc8: 81 c7 e0 08 ret
2016bcc: 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;
2016bd0: 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;
2016bd4: 80 a7 00 13 cmp %i4, %l3
2016bd8: 2a bf ff e0 bcs,a 2016b58 <msdos_dir_is_empty+0x5c> <== ALWAYS TAKEN
2016bdc: c2 07 60 94 ld [ %i5 + 0x94 ], %g1
/*
* Short file name entries mean not empty.
*/
return RC_OK;
}
j++;
2016be0: 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,
2016be4: f8 17 40 00 lduh [ %i5 ], %i4
2016be8: 90 10 00 1b mov %i3, %o0
2016bec: 40 00 31 11 call 2023030 <.umul>
2016bf0: 92 10 00 1c mov %i4, %o1
2016bf4: d8 07 60 94 ld [ %i5 + 0x94 ], %o4
2016bf8: 94 10 00 08 mov %o0, %o2
2016bfc: 92 10 00 19 mov %i1, %o1
2016c00: 90 10 00 1d mov %i5, %o0
2016c04: 7f ff e8 88 call 2010e24 <fat_file_read>
2016c08: 96 10 00 1c mov %i4, %o3
2016c0c: 80 a2 20 00 cmp %o0, 0
2016c10: 32 bf ff c4 bne,a 2016b20 <msdos_dir_is_empty+0x24> <== ALWAYS TAKEN
2016c14: 80 a2 20 1f cmp %o0, 0x1f
*/
return RC_OK;
}
j++;
}
*ret_val = true;
2016c18: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED
2016c1c: c2 2e 80 00 stb %g1, [ %i2 ] <== NOT EXECUTED
2016c20: b0 10 20 00 clr %i0 <== NOT EXECUTED
return RC_OK;
}
2016c24: 81 c7 e0 08 ret <== NOT EXECUTED
2016c28: 81 e8 00 00 restore <== NOT EXECUTED
02019578 <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)
{
2019578: 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;
201957c: 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);
2019580: 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;
2019584: 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);
2019588: 94 10 20 00 clr %o2 <== NOT EXECUTED
201958c: 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)
{
2019590: 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;
2019594: 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);
2019598: 40 00 28 6a call 2023740 <__divdi3> <== NOT EXECUTED
201959c: 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;
20195a0: 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);
20195a4: a6 10 00 09 mov %o1, %l3 <== NOT EXECUTED
count = (count / sizeof(struct dirent)) * sizeof(struct dirent);
20195a8: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
20195ac: 40 00 26 db call 2023118 <.udiv> <== NOT EXECUTED
20195b0: 92 10 21 18 mov 0x118, %o1 <== NOT EXECUTED
20195b4: a5 2a 20 03 sll %o0, 3, %l2 <== NOT EXECUTED
20195b8: 91 2a 20 05 sll %o0, 5, %o0 <== NOT EXECUTED
20195bc: a4 04 80 08 add %l2, %o0, %l2 <== NOT EXECUTED
20195c0: 85 2c a0 03 sll %l2, 3, %g2 <== NOT EXECUTED
20195c4: 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 :
20195c8: c4 04 20 20 ld [ %l0 + 0x20 ], %g2 <== NOT EXECUTED
20195cc: 80 a0 a0 01 cmp %g2, 1 <== NOT EXECUTED
20195d0: 32 80 00 0b bne,a 20195fc <msdos_dir_read+0x84> <== NOT EXECUTED
20195d4: 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) &&
20195d8: c4 04 20 24 ld [ %l0 + 0x24 ], %g2 <== NOT EXECUTED
20195dc: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED
20195e0: 32 80 00 07 bne,a 20195fc <msdos_dir_read+0x84> <== NOT EXECUTED
20195e4: ea 15 a0 06 lduh [ %l6 + 6 ], %l5 <== NOT EXECUTED
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16))) ?
20195e8: 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) &&
20195ec: 80 88 a0 03 btst 3, %g2 <== NOT EXECUTED
20195f0: 22 80 00 03 be,a 20195fc <msdos_dir_read+0x84> <== NOT EXECUTED
20195f4: ea 15 a0 06 lduh [ %l6 + 6 ], %l5 <== NOT EXECUTED
20195f8: 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,
20195fc: d0 05 a0 90 ld [ %l6 + 0x90 ], %o0 <== NOT EXECUTED
2019600: 92 10 20 00 clr %o1 <== NOT EXECUTED
2019604: 7f ff be 12 call 2008e4c <rtems_semaphore_obtain> <== NOT EXECUTED
2019608: 94 10 20 00 clr %o2 <== NOT EXECUTED
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
201960c: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2019610: 22 80 00 fe be,a 2019a08 <msdos_dir_read+0x490> <== NOT EXECUTED
2019614: a2 10 20 00 clr %l1 <== NOT EXECUTED
2019618: 30 80 00 0b b,a 2019644 <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),
201961c: 90 10 00 16 mov %l6, %o0 <== NOT EXECUTED
2019620: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED
2019624: 94 10 00 11 mov %l1, %o2 <== NOT EXECUTED
2019628: 7f ff dd ff call 2010e24 <fat_file_read> <== NOT EXECUTED
201962c: 96 10 00 15 mov %l5, %o3 <== NOT EXECUTED
bts2rd, fs_info->cl_buf);
if (ret < MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
2019630: 80 a2 20 1f cmp %o0, 0x1f <== NOT EXECUTED
2019634: 14 80 00 ee bg 20199ec <msdos_dir_read+0x474> <== NOT EXECUTED
2019638: d0 27 be cc st %o0, [ %fp + -308 ] <== NOT EXECUTED
{
rtems_semaphore_release(fs_info->vol_sema);
201963c: 7f ff be 4e call 2008f74 <rtems_semaphore_release> <== NOT EXECUTED
2019640: d0 05 a0 90 ld [ %l6 + 0x90 ], %o0 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
2019644: 40 00 02 77 call 201a020 <__errno> <== NOT EXECUTED
2019648: b2 10 3f ff mov -1, %i1 <== NOT EXECUTED
201964c: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
2019650: 10 80 01 07 b 2019a6c <msdos_dir_read+0x4f4> <== NOT EXECUTED
2019654: 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;
2019658: ae 00 c0 1c add %g3, %i4, %l7 <== NOT EXECUTED
/*
* Is this directory from here on empty ?
*/
if ((*MSDOS_DIR_ENTRY_TYPE(entry)) ==
201965c: c6 08 c0 1c ldub [ %g3 + %i4 ], %g3 <== NOT EXECUTED
2019660: 88 88 e0 ff andcc %g3, 0xff, %g4 <== NOT EXECUTED
2019664: 12 80 00 04 bne 2019674 <msdos_dir_read+0xfc> <== NOT EXECUTED
2019668: 80 a1 20 e5 cmp %g4, 0xe5 <== NOT EXECUTED
break;
}
j++;
}
rtems_semaphore_release(fs_info->vol_sema);
201966c: 10 80 00 ef b 2019a28 <msdos_dir_read+0x4b0> <== NOT EXECUTED
2019670: 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)
2019674: 22 80 00 df be,a 20199f0 <msdos_dir_read+0x478> <== NOT EXECUTED
2019678: 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) &&
201967c: c8 0d e0 0b ldub [ %l7 + 0xb ], %g4 <== NOT EXECUTED
2019680: 9e 09 20 08 and %g4, 8, %o7 <== NOT EXECUTED
2019684: 80 8b e0 ff btst 0xff, %o7 <== NOT EXECUTED
2019688: 22 80 00 07 be,a 20196a4 <msdos_dir_read+0x12c> <== NOT EXECUTED
201968c: 88 09 20 3f and %g4, 0x3f, %g4 <== NOT EXECUTED
2019690: 9e 09 20 3f and %g4, 0x3f, %o7 <== NOT EXECUTED
2019694: 80 a3 e0 0f cmp %o7, 0xf <== NOT EXECUTED
2019698: 32 80 00 d6 bne,a 20199f0 <msdos_dir_read+0x478> <== NOT EXECUTED
201969c: 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) ==
20196a0: 88 09 20 3f and %g4, 0x3f, %g4 <== NOT EXECUTED
20196a4: 80 a1 20 0f cmp %g4, 0xf <== NOT EXECUTED
20196a8: 12 80 00 3e bne 20197a0 <msdos_dir_read+0x228> <== NOT EXECUTED
20196ac: 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)
20196b0: 80 a6 ff ff cmp %i3, -1 <== NOT EXECUTED
20196b4: 32 80 00 0f bne,a 20196f0 <msdos_dir_read+0x178> <== NOT EXECUTED
20196b8: 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) &
20196bc: 88 08 e0 40 and %g3, 0x40, %g4 <== NOT EXECUTED
20196c0: 80 89 20 ff btst 0xff, %g4 <== NOT EXECUTED
20196c4: 22 80 00 cb be,a 20199f0 <msdos_dir_read+0x478> <== NOT EXECUTED
20196c8: 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)
20196cc: 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) &
20196d0: ba 08 e0 3f and %g3, 0x3f, %i5 <== NOT EXECUTED
continue;
/*
* Remember the start location of the long file name.
*/
lfn_start =
20196d4: 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);
20196d8: e8 0d e0 0d ldub [ %l7 + 0xd ], %l4 <== NOT EXECUTED
memset (tmp_dirent.d_name, 0, sizeof(tmp_dirent.d_name));
20196dc: 90 07 be fc add %fp, -260, %o0 <== NOT EXECUTED
20196e0: 92 10 20 00 clr %o1 <== NOT EXECUTED
20196e4: 40 00 05 41 call 201abe8 <memset> <== NOT EXECUTED
20196e8: 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) &
20196ec: c6 0d c0 00 ldub [ %l7 ], %g3 <== NOT EXECUTED
20196f0: 86 08 e0 3f and %g3, 0x3f, %g3 <== NOT EXECUTED
20196f4: 80 a7 40 03 cmp %i5, %g3 <== NOT EXECUTED
20196f8: 32 80 00 bb bne,a 20199e4 <msdos_dir_read+0x46c> <== NOT EXECUTED
20196fc: b6 10 3f ff mov -1, %i3 <== NOT EXECUTED
MSDOS_LAST_LONG_ENTRY_MASK)) ||
2019700: c6 0d e0 0d ldub [ %l7 + 0xd ], %g3 <== NOT EXECUTED
2019704: 88 0d 20 ff and %l4, 0xff, %g4 <== NOT EXECUTED
2019708: 80 a1 00 03 cmp %g4, %g3 <== NOT EXECUTED
201970c: 32 80 00 b6 bne,a 20199e4 <msdos_dir_read+0x46c> <== NOT EXECUTED
2019710: 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--;
2019714: ba 07 7f ff add %i5, -1, %i5 <== NOT EXECUTED
p = entry + 1;
o = lfn_entries * MSDOS_LFN_LEN_PER_ENTRY;
2019718: 87 2f 60 02 sll %i5, 2, %g3 <== NOT EXECUTED
201971c: 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)
2019720: 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;
2019724: 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;
2019728: 84 05 e0 01 add %l7, 1, %g2 <== NOT EXECUTED
o = lfn_entries * MSDOS_LFN_LEN_PER_ENTRY;
201972c: 88 01 00 1d add %g4, %i5, %g4 <== NOT EXECUTED
for (q = 0; q < MSDOS_LFN_LEN_PER_ENTRY; q++)
2019730: 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)
2019734: 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))
2019738: 9a 00 c0 04 add %g3, %g4, %o5 <== NOT EXECUTED
201973c: 80 a3 60 fe cmp %o5, 0xfe <== NOT EXECUTED
2019740: 18 80 00 a3 bgu 20199cc <msdos_dir_read+0x454> <== NOT EXECUTED
2019744: 9a 03 c0 03 add %o7, %g3, %o5 <== NOT EXECUTED
break;
tmp_dirent.d_name[o++] = *p;
2019748: d8 08 80 00 ldub [ %g2 ], %o4 <== NOT EXECUTED
201974c: d8 2b 60 14 stb %o4, [ %o5 + 0x14 ] <== NOT EXECUTED
if (*p == '\0')
2019750: da 48 80 00 ldsb [ %g2 ], %o5 <== NOT EXECUTED
2019754: 80 a3 60 00 cmp %o5, 0 <== NOT EXECUTED
2019758: 02 80 00 9d be 20199cc <msdos_dir_read+0x454> <== NOT EXECUTED
201975c: 80 a0 e0 04 cmp %g3, 4 <== NOT EXECUTED
break;
switch (q)
2019760: 02 80 00 06 be 2019778 <msdos_dir_read+0x200> <== NOT EXECUTED
2019764: 80 a0 e0 0a cmp %g3, 0xa <== NOT EXECUTED
2019768: 32 80 00 08 bne,a 2019788 <msdos_dir_read+0x210> <== NOT EXECUTED
201976c: 84 00 a0 02 add %g2, 2, %g2 <== NOT EXECUTED
{
case 4:
p += 5;
break;
case 10:
p += 4;
2019770: 10 80 00 04 b 2019780 <msdos_dir_read+0x208> <== NOT EXECUTED
2019774: 84 00 a0 04 add %g2, 4, %g2 <== NOT EXECUTED
switch (q)
{
case 4:
p += 5;
break;
2019778: 10 80 00 04 b 2019788 <msdos_dir_read+0x210> <== NOT EXECUTED
201977c: 84 00 a0 05 add %g2, 5, %g2 <== NOT EXECUTED
case 10:
p += 4;
break;
2019780: 10 80 00 03 b 201978c <msdos_dir_read+0x214> <== NOT EXECUTED
2019784: 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++)
2019788: 86 00 e0 01 inc %g3 <== NOT EXECUTED
201978c: 80 a0 e0 0d cmp %g3, 0xd <== NOT EXECUTED
2019790: 12 bf ff eb bne 201973c <msdos_dir_read+0x1c4> <== NOT EXECUTED
2019794: 9a 00 c0 04 add %g3, %g4, %o5 <== NOT EXECUTED
rtems_semaphore_release(fs_info->vol_sema);
return rc;
}
}
if (count <= 0)
2019798: 10 80 00 8e b 20199d0 <msdos_dir_read+0x458> <== NOT EXECUTED
201979c: 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)
20197a0: 02 80 00 04 be 20197b0 <msdos_dir_read+0x238> <== NOT EXECUTED
20197a4: 90 10 00 16 mov %l6, %o0 <== NOT EXECUTED
{
lfn_start = FAT_FILE_SHORT_NAME;
start--;
20197a8: 10 80 00 8e b 20199e0 <msdos_dir_read+0x468> <== NOT EXECUTED
20197ac: 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,
20197b0: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED
20197b4: 94 10 20 01 mov 1, %o2 <== NOT EXECUTED
20197b8: 96 10 00 11 mov %l1, %o3 <== NOT EXECUTED
20197bc: 7f ff de 7a call 20111a4 <fat_file_ioctl> <== NOT EXECUTED
20197c0: 98 07 be d4 add %fp, -300, %o4 <== NOT EXECUTED
j * bts2rd, &cur_cln);
if (rc != RC_OK)
20197c4: b2 92 20 00 orcc %o0, 0, %i1 <== NOT EXECUTED
20197c8: 12 80 00 7d bne 20199bc <msdos_dir_read+0x444> <== NOT EXECUTED
20197cc: 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;
20197d0: 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;
20197d4: c6 27 be d8 st %g3, [ %fp + -296 ] <== NOT EXECUTED
20197d8: c2 27 be e0 st %g1, [ %fp + -288 ] <== NOT EXECUTED
dir_pos->lname.ofs = FAT_FILE_SHORT_NAME;
20197dc: c2 27 be e4 st %g1, [ %fp + -284 ] <== NOT EXECUTED
dir_pos.sname.ofs = i;
20197e0: f8 27 be dc st %i4, [ %fp + -292 ] <== NOT EXECUTED
rc = fat_file_open(&fs_info->fat, &dir_pos, &tmp_fat_fd);
20197e4: 90 10 00 16 mov %l6, %o0 <== NOT EXECUTED
20197e8: 92 07 be d8 add %fp, -296, %o1 <== NOT EXECUTED
20197ec: 7f ff dd 2b call 2010c98 <fat_file_open> <== NOT EXECUTED
20197f0: 94 07 be d0 add %fp, -304, %o2 <== NOT EXECUTED
if (rc != RC_OK)
20197f4: b2 92 20 00 orcc %o0, 0, %i1 <== NOT EXECUTED
20197f8: 12 80 00 71 bne 20199bc <msdos_dir_read+0x444> <== NOT EXECUTED
20197fc: 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);
2019800: 82 10 21 18 mov 0x118, %g1 <== NOT EXECUTED
tmp_dirent.d_ino = tmp_fat_fd->ino;
2019804: 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;
2019808: c0 27 be f0 clr [ %fp + -272 ] <== NOT EXECUTED
201980c: f4 27 be f4 st %i2, [ %fp + -268 ] <== NOT EXECUTED
tmp_dirent.d_reclen = sizeof(struct dirent);
2019810: 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)
2019814: 80 a6 ff ff cmp %i3, -1 <== NOT EXECUTED
2019818: 02 80 00 1d be 201988c <msdos_dir_read+0x314> <== NOT EXECUTED
201981c: c6 27 be e8 st %g3, [ %fp + -280 ] <== NOT EXECUTED
2019820: 88 10 20 00 clr %g4 <== NOT EXECUTED
2019824: 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;
2019828: da 0d c0 04 ldub [ %l7 + %g4 ], %o5 <== NOT EXECUTED
201982c: 9e 08 e0 01 and %g3, 1, %o7 <== NOT EXECUTED
2019830: 80 a0 00 0f cmp %g0, %o7 <== NOT EXECUTED
2019834: 86 08 e0 ff and %g3, 0xff, %g3 <== NOT EXECUTED
2019838: 9e 40 3f ff addx %g0, -1, %o7 <== NOT EXECUTED
201983c: 87 30 e0 01 srl %g3, 1, %g3 <== NOT EXECUTED
2019840: 9e 0b e0 80 and %o7, 0x80, %o7 <== NOT EXECUTED
2019844: 86 03 40 03 add %o5, %g3, %g3 <== NOT EXECUTED
2019848: 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++)
201984c: 88 01 20 01 inc %g4 <== NOT EXECUTED
2019850: 80 a1 20 0b cmp %g4, 0xb <== NOT EXECUTED
2019854: 12 bf ff f5 bne 2019828 <msdos_dir_read+0x2b0> <== NOT EXECUTED
2019858: 86 00 c0 0f add %g3, %o7, %g3 <== NOT EXECUTED
cs = ((cs & 1) ? 0x80 : 0) + (cs >> 1) + *p;
if (lfn_entries || (lfn_checksum != cs))
201985c: 86 18 c0 14 xor %g3, %l4, %g3 <== NOT EXECUTED
2019860: 80 88 e0 ff btst 0xff, %g3 <== NOT EXECUTED
2019864: 12 80 00 0b bne 2019890 <msdos_dir_read+0x318> <== NOT EXECUTED
2019868: 86 10 20 08 mov 8, %g3 <== NOT EXECUTED
201986c: 80 a7 60 00 cmp %i5, 0 <== NOT EXECUTED
2019870: 12 80 00 09 bne 2019894 <msdos_dir_read+0x31c> <== NOT EXECUTED
2019874: 88 05 c0 03 add %l7, %g3, %g4 <== NOT EXECUTED
2019878: 30 80 00 70 b,a 2019a38 <msdos_dir_read+0x4c0> <== NOT EXECUTED
const char *src_tmp;
/*
* find last non-blank character of base name
*/
for ((i = MSDOS_SHORT_BASE_LEN ,
201987c: 32 80 00 06 bne,a 2019894 <msdos_dir_read+0x31c> <== NOT EXECUTED
2019880: 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++));
2019884: 10 80 00 09 b 20198a8 <msdos_dir_read+0x330> <== NOT EXECUTED
2019888: 03 00 80 9e sethi %hi(0x2027800), %g1 <== NOT EXECUTED
const char *src_tmp;
/*
* find last non-blank character of base name
*/
for ((i = MSDOS_SHORT_BASE_LEN ,
201988c: 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)
2019890: 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) &&
2019894: c8 49 3f ff ldsb [ %g4 + -1 ], %g4 <== NOT EXECUTED
2019898: 80 a1 20 20 cmp %g4, 0x20 <== NOT EXECUTED
201989c: 22 bf ff f8 be,a 201987c <msdos_dir_read+0x304> <== NOT EXECUTED
20198a0: 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++));
20198a4: 03 00 80 9e sethi %hi(0x2027800), %g1 <== NOT EXECUTED
20198a8: b6 10 20 00 clr %i3 <== NOT EXECUTED
20198ac: da 00 63 b8 ld [ %g1 + 0x3b8 ], %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(
20198b0: 10 80 00 0b b 20198dc <msdos_dir_read+0x364> <== NOT EXECUTED
20198b4: 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++));
20198b8: 98 03 40 0f add %o5, %o7, %o4 <== NOT EXECUTED
20198bc: d8 0b 20 01 ldub [ %o4 + 1 ], %o4 <== NOT EXECUTED
20198c0: 98 0b 20 03 and %o4, 3, %o4 <== NOT EXECUTED
20198c4: 80 a3 20 01 cmp %o4, 1 <== NOT EXECUTED
20198c8: 22 80 00 02 be,a 20198d0 <msdos_dir_read+0x358> <== NOT EXECUTED
20198cc: 9e 03 e0 20 add %o7, 0x20, %o7 <== NOT EXECUTED
20198d0: de 29 00 00 stb %o7, [ %g4 ] <== NOT EXECUTED
20198d4: b6 06 e0 01 inc %i3 <== NOT EXECUTED
20198d8: 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)
20198dc: 9e 20 c0 1b sub %g3, %i3, %o7 <== NOT EXECUTED
/*
* copy base name to destination
*/
src_tmp = src;
len = i;
while (i-- > 0) {
20198e0: 80 a3 e0 00 cmp %o7, 0 <== NOT EXECUTED
20198e4: 34 bf ff f5 bg,a 20198b8 <msdos_dir_read+0x340> <== NOT EXECUTED
20198e8: 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) &&
20198ec: f6 4d e0 0a ldsb [ %l7 + 0xa ], %i3 <== NOT EXECUTED
20198f0: 80 a6 e0 20 cmp %i3, 0x20 <== NOT EXECUTED
20198f4: 12 80 00 55 bne 2019a48 <msdos_dir_read+0x4d0> <== NOT EXECUTED
20198f8: b6 10 20 03 mov 3, %i3 <== NOT EXECUTED
20198fc: f6 4d e0 09 ldsb [ %l7 + 9 ], %i3 <== NOT EXECUTED
2019900: 80 a6 e0 20 cmp %i3, 0x20 <== NOT EXECUTED
2019904: 12 80 00 51 bne 2019a48 <msdos_dir_read+0x4d0> <== NOT EXECUTED
2019908: b6 10 20 02 mov 2, %i3 <== NOT EXECUTED
201990c: f6 4d e0 08 ldsb [ %l7 + 8 ], %i3 <== NOT EXECUTED
2019910: 80 a6 e0 20 cmp %i3, 0x20 <== NOT EXECUTED
2019914: 22 80 00 18 be,a 2019974 <msdos_dir_read+0x3fc> <== NOT EXECUTED
2019918: c0 29 00 00 clrb [ %g4 ] <== NOT EXECUTED
201991c: 10 80 00 4b b 2019a48 <msdos_dir_read+0x4d0> <== NOT EXECUTED
2019920: 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++));
2019924: da 0b 60 08 ldub [ %o5 + 8 ], %o5 <== NOT EXECUTED
2019928: 94 03 00 0d add %o4, %o5, %o2 <== NOT EXECUTED
201992c: d4 0a a0 01 ldub [ %o2 + 1 ], %o2 <== NOT EXECUTED
2019930: 94 0a a0 03 and %o2, 3, %o2 <== NOT EXECUTED
2019934: 80 a2 a0 01 cmp %o2, 1 <== NOT EXECUTED
2019938: 22 80 00 02 be,a 2019940 <msdos_dir_read+0x3c8> <== NOT EXECUTED
201993c: 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)
2019940: 94 01 00 0f add %g4, %o7, %o2 <== NOT EXECUTED
2019944: 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++));
2019948: 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)
201994c: 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) {
2019950: 80 a3 60 00 cmp %o5, 0 <== NOT EXECUTED
2019954: 14 bf ff f4 bg 2019924 <msdos_dir_read+0x3ac> <== NOT EXECUTED
2019958: 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)
201995c: 84 38 00 1b xnor %g0, %i3, %g2 <== NOT EXECUTED
2019960: 85 38 a0 1f sra %g2, 0x1f, %g2 <== NOT EXECUTED
2019964: b6 0e c0 02 and %i3, %g2, %i3 <== NOT EXECUTED
2019968: 88 02 c0 1b add %o3, %i3, %g4 <== NOT EXECUTED
201996c: 86 00 c0 1b add %g3, %i3, %g3 <== NOT EXECUTED
while (i-- > 0) {
*dst++ = tolower((unsigned char)(*src_tmp++));
len++;
}
}
*dst = '\0'; /* terminate string */
2019970: 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(
2019974: c6 37 be fa sth %g3, [ %fp + -262 ] <== NOT EXECUTED
2019978: 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));
201997c: c2 07 a0 48 ld [ %fp + 0x48 ], %g1 <== NOT EXECUTED
2019980: 92 07 be e8 add %fp, -280, %o1 <== NOT EXECUTED
2019984: 90 00 40 1a add %g1, %i2, %o0 <== NOT EXECUTED
2019988: 40 00 04 5b call 201aaf4 <memcpy> <== NOT EXECUTED
201998c: 94 10 21 18 mov 0x118, %o2 <== NOT EXECUTED
iop->offset = iop->offset + sizeof(struct dirent);
2019990: 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);
2019994: 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);
2019998: 86 80 e1 18 addcc %g3, 0x118, %g3 <== NOT EXECUTED
201999c: 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);
20199a0: 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);
20199a4: 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);
20199a8: 7f ff dd d2 call 20110f0 <fat_file_close> <== NOT EXECUTED
20199ac: b4 06 a1 18 add %i2, 0x118, %i2 <== NOT EXECUTED
if (rc != RC_OK)
20199b0: b2 92 20 00 orcc %o0, 0, %i1 <== NOT EXECUTED
20199b4: 02 80 00 06 be 20199cc <msdos_dir_read+0x454> <== NOT EXECUTED
20199b8: a4 04 be e8 add %l2, -280, %l2 <== NOT EXECUTED
{
rtems_semaphore_release(fs_info->vol_sema);
20199bc: 7f ff bd 6e call 2008f74 <rtems_semaphore_release> <== NOT EXECUTED
20199c0: d0 05 a0 90 ld [ %l6 + 0x90 ], %o0 <== NOT EXECUTED
j++;
}
rtems_semaphore_release(fs_info->vol_sema);
return cmpltd;
}
20199c4: 81 c7 e0 08 ret <== NOT EXECUTED
20199c8: 91 e8 00 19 restore %g0, %i1, %o0 <== NOT EXECUTED
rtems_semaphore_release(fs_info->vol_sema);
return rc;
}
}
if (count <= 0)
20199cc: 80 a4 a0 00 cmp %l2, 0 <== NOT EXECUTED
20199d0: 32 80 00 08 bne,a 20199f0 <msdos_dir_read+0x478> <== NOT EXECUTED
20199d4: b8 07 20 20 add %i4, 0x20, %i4 <== NOT EXECUTED
20199d8: 10 80 00 10 b 2019a18 <msdos_dir_read+0x4a0> <== NOT EXECUTED
20199dc: 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;
20199e0: 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)
20199e4: 10 80 00 03 b 20199f0 <msdos_dir_read+0x478> <== NOT EXECUTED
20199e8: 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)
20199ec: 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)
20199f0: c2 07 be cc ld [ %fp + -308 ], %g1 <== NOT EXECUTED
20199f4: 80 a7 00 01 cmp %i4, %g1 <== NOT EXECUTED
20199f8: 2a bf ff 18 bcs,a 2019658 <msdos_dir_read+0xe0> <== NOT EXECUTED
20199fc: c6 05 a0 94 ld [ %l6 + 0x94 ], %g3 <== NOT EXECUTED
2019a00: 10 80 00 06 b 2019a18 <msdos_dir_read+0x4a0> <== NOT EXECUTED
2019a04: 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)
2019a08: ba 10 20 00 clr %i5 <== NOT EXECUTED
2019a0c: a8 10 20 00 clr %l4 <== NOT EXECUTED
2019a10: b6 10 3f ff mov -1, %i3 <== NOT EXECUTED
2019a14: b4 10 20 00 clr %i2 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
while (count > 0)
2019a18: 80 a4 a0 00 cmp %l2, 0 <== NOT EXECUTED
2019a1c: 32 bf ff 00 bne,a 201961c <msdos_dir_read+0xa4> <== NOT EXECUTED
2019a20: d8 05 a0 94 ld [ %l6 + 0x94 ], %o4 <== NOT EXECUTED
break;
}
j++;
}
rtems_semaphore_release(fs_info->vol_sema);
2019a24: d0 05 a0 90 ld [ %l6 + 0x90 ], %o0 <== NOT EXECUTED
2019a28: 7f ff bd 53 call 2008f74 <rtems_semaphore_release> <== NOT EXECUTED
2019a2c: b2 10 00 1a mov %i2, %i1 <== NOT EXECUTED
return cmpltd;
}
2019a30: 81 c7 e0 08 ret <== NOT EXECUTED
2019a34: 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);
2019a38: 40 00 07 d9 call 201b99c <strlen> <== NOT EXECUTED
2019a3c: 90 07 be fc add %fp, -260, %o0 <== NOT EXECUTED
2019a40: 10 bf ff cf b 201997c <msdos_dir_read+0x404> <== NOT EXECUTED
2019a44: d0 37 be fa sth %o0, [ %fp + -262 ] <== NOT EXECUTED
{};
/*
* extension is not empty
*/
if (i > 0) {
*dst++ = '.'; /* append dot */
2019a48: 82 10 20 2e mov 0x2e, %g1 <== NOT EXECUTED
len += i + 1; /* extension + dot */
2019a4c: 9e 06 e0 01 add %i3, 1, %o7 <== NOT EXECUTED
{};
/*
* extension is not empty
*/
if (i > 0) {
*dst++ = '.'; /* append dot */
2019a50: c2 29 00 00 stb %g1, [ %g4 ] <== NOT EXECUTED
len += i + 1; /* extension + dot */
2019a54: 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++));
2019a58: 03 00 80 9e sethi %hi(0x2027800), %g1 <== NOT EXECUTED
{};
/*
* extension is not empty
*/
if (i > 0) {
*dst++ = '.'; /* append dot */
2019a5c: 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++));
2019a60: d8 00 63 b8 ld [ %g1 + 0x3b8 ], %o4 <== NOT EXECUTED
2019a64: 10 bf ff ba b 201994c <msdos_dir_read+0x3d4> <== NOT EXECUTED
2019a68: 9e 10 20 00 clr %o7 <== NOT EXECUTED
j++;
}
rtems_semaphore_release(fs_info->vol_sema);
return cmpltd;
}
2019a6c: b0 10 00 19 mov %i1, %i0 <== NOT EXECUTED
2019a70: 81 c7 e0 08 ret <== NOT EXECUTED
2019a74: 81 e8 00 00 restore <== NOT EXECUTED
02019a78 <msdos_dir_stat>:
int
msdos_dir_stat(
const rtems_filesystem_location_info_t *loc,
struct stat *buf
)
{
2019a78: 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;
2019a7c: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
fat_file_fd_t *fat_fd = loc->node_access;
2019a80: 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;
2019a84: 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,
2019a88: 92 10 20 00 clr %o1
2019a8c: d0 07 60 90 ld [ %i5 + 0x90 ], %o0
2019a90: 7f ff bc ef call 2008e4c <rtems_semaphore_obtain>
2019a94: 94 10 20 00 clr %o2
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
2019a98: 80 a2 20 00 cmp %o0, 0
2019a9c: 22 80 00 08 be,a 2019abc <msdos_dir_stat+0x44> <== ALWAYS TAKEN
2019aa0: c2 07 60 58 ld [ %i5 + 0x58 ], %g1
rtems_set_errno_and_return_minus_one(EIO);
2019aa4: 40 00 01 5f call 201a020 <__errno> <== NOT EXECUTED
2019aa8: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
2019aac: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
2019ab0: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
2019ab4: 81 c7 e0 08 ret <== NOT EXECUTED
2019ab8: 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);
2019abc: 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);
2019ac0: c4 18 40 00 ldd [ %g1 ], %g2
buf->st_ino = fat_fd->ino;
2019ac4: 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);
2019ac8: c4 3e 40 00 std %g2, [ %i1 ]
buf->st_ino = fat_fd->ino;
2019acc: c2 26 60 08 st %g1, [ %i1 + 8 ]
buf->st_mode = S_IFDIR | S_IRWXU | S_IRWXG | S_IRWXO;
2019ad0: 03 00 00 10 sethi %hi(0x4000), %g1
2019ad4: 82 10 61 ff or %g1, 0x1ff, %g1 ! 41ff <PROM_START+0x41ff>
2019ad8: c2 26 60 0c st %g1, [ %i1 + 0xc ]
buf->st_rdev = 0ll;
buf->st_size = fat_fd->fat_file_size;
2019adc: 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;
2019ae0: c0 26 60 18 clr [ %i1 + 0x18 ]
buf->st_size = fat_fd->fat_file_size;
2019ae4: c2 26 60 24 st %g1, [ %i1 + 0x24 ]
buf->st_blocks = fat_fd->fat_file_size >> FAT_SECTOR512_BITS;
2019ae8: 83 30 60 09 srl %g1, 9, %g1
2019aec: c2 26 60 44 st %g1, [ %i1 + 0x44 ]
buf->st_blksize = fs_info->fat.vol.bps;
2019af0: 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;
2019af4: 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;
2019af8: c2 26 60 40 st %g1, [ %i1 + 0x40 ]
buf->st_mtime = fat_fd->mtime;
2019afc: 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;
2019b00: 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;
2019b04: c2 26 60 30 st %g1, [ %i1 + 0x30 ]
rtems_semaphore_release(fs_info->vol_sema);
2019b08: 7f ff bd 1b call 2008f74 <rtems_semaphore_release>
2019b0c: b0 10 20 00 clr %i0
return RC_OK;
}
2019b10: 81 c7 e0 08 ret
2019b14: 81 e8 00 00 restore
020163ec <msdos_eval_token>:
rtems_filesystem_eval_path_context_t *ctx,
void *arg,
const char *token,
size_t tokenlen
)
{
20163ec: 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] == '.';
20163f0: 82 10 20 00 clr %g1
20163f4: 80 a6 e0 01 cmp %i3, 1
20163f8: 12 80 00 06 bne 2016410 <msdos_eval_token+0x24>
20163fc: ba 10 00 18 mov %i0, %i5
2016400: c2 4e 80 00 ldsb [ %i2 ], %g1
2016404: 82 18 60 2e xor %g1, 0x2e, %g1
2016408: 80 a0 00 01 cmp %g0, %g1
201640c: 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)) {
2016410: 80 a0 60 00 cmp %g1, 0
2016414: 02 80 00 05 be 2016428 <msdos_eval_token+0x3c>
2016418: 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;
201641c: c0 27 60 0c clr [ %i5 + 0xc ]
2016420: 81 c7 e0 08 ret
2016424: 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);
2016428: 90 07 60 18 add %i5, 0x18, %o0
201642c: 92 10 00 1a mov %i2, %o1
2016430: 40 00 05 aa call 2017ad8 <msdos_find_name>
2016434: 94 10 00 1b mov %i3, %o2
if (rc == RC_OK) {
2016438: 80 a2 20 00 cmp %o0, 0
201643c: 12 80 00 12 bne 2016484 <msdos_eval_token+0x98>
2016440: 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)
2016444: 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;
2016448: 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)
201644c: c4 00 a0 10 ld [ %g2 + 0x10 ], %g2
2016450: c0 27 60 0c clr [ %i5 + 0xc ]
2016454: 80 a0 a0 00 cmp %g2, 0
2016458: 12 80 00 04 bne 2016468 <msdos_eval_token+0x7c>
201645c: c2 00 60 08 ld [ %g1 + 8 ], %g1
loc->handlers = fs_info->directory_handlers;
2016460: 10 80 00 03 b 201646c <msdos_eval_token+0x80>
2016464: c2 00 60 88 ld [ %g1 + 0x88 ], %g1
else
loc->handlers = fs_info->file_handlers;
2016468: c2 00 60 8c ld [ %g1 + 0x8c ], %g1
201646c: 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)) {
2016470: c2 07 60 04 ld [ %i5 + 4 ], %g1
void *arg,
const char *token,
size_t tokenlen
)
{
rtems_filesystem_eval_path_generic_status status =
2016474: 80 a0 00 01 cmp %g0, %g1
2016478: b0 60 3f ff subx %g0, -1, %i0
201647c: 81 c7 e0 08 ret
2016480: 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) {
2016484: 82 10 61 01 or %g1, 0x101, %g1
2016488: 80 a2 00 01 cmp %o0, %g1
201648c: 02 bf ff e5 be 2016420 <msdos_eval_token+0x34> <== ALWAYS TAKEN
2016490: b0 10 20 02 mov 2, %i0
status = RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_NO_ENTRY;
} else {
rtems_filesystem_eval_path_error(ctx, 0);
2016494: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
2016498: 92 10 20 00 clr %o1 <== NOT EXECUTED
201649c: 7f ff bd b4 call 2005b6c <rtems_filesystem_eval_path_error><== NOT EXECUTED
20164a0: b0 10 20 01 mov 1, %i0 <== NOT EXECUTED
}
}
return status;
}
20164a4: 81 c7 e0 08 ret <== NOT EXECUTED
20164a8: 81 e8 00 00 restore <== NOT EXECUTED
02019b74 <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)
{
2019b74: 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;
2019b78: c2 06 20 28 ld [ %i0 + 0x28 ], %g1
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
2019b7c: 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;
2019b80: fa 00 60 08 ld [ %g1 + 8 ], %i5
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
2019b84: 94 10 20 00 clr %o2
2019b88: 7f ff bc b1 call 2008e4c <rtems_semaphore_obtain>
2019b8c: d0 07 60 90 ld [ %i5 + 0x90 ], %o0
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
2019b90: 80 a2 20 00 cmp %o0, 0
2019b94: 02 80 00 08 be 2019bb4 <msdos_file_close+0x40> <== ALWAYS TAKEN
2019b98: 01 00 00 00 nop
rtems_set_errno_and_return_minus_one(EIO);
2019b9c: 40 00 01 21 call 201a020 <__errno> <== NOT EXECUTED
2019ba0: b0 10 3f ff mov -1, %i0 ! ffffffff <RAM_END+0xfdbfffff> <== NOT EXECUTED
2019ba4: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
2019ba8: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
2019bac: 81 c7 e0 08 ret <== NOT EXECUTED
2019bb0: 81 e8 00 00 restore <== NOT EXECUTED
rc = msdos_file_update(iop);
2019bb4: 7f ff ff d9 call 2019b18 <msdos_file_update>
2019bb8: 90 10 00 18 mov %i0, %o0
2019bbc: b0 10 00 08 mov %o0, %i0
rtems_semaphore_release(fs_info->vol_sema);
2019bc0: 7f ff bc ed call 2008f74 <rtems_semaphore_release>
2019bc4: d0 07 60 90 ld [ %i5 + 0x90 ], %o0
return rc;
}
2019bc8: 81 c7 e0 08 ret
2019bcc: 81 e8 00 00 restore
02019dd0 <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)
{
2019dd0: 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;
2019dd4: c2 06 20 28 ld [ %i0 + 0x28 ], %g1
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
2019dd8: 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;
2019ddc: 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,
2019de0: 92 10 20 00 clr %o1
2019de4: d0 07 60 90 ld [ %i5 + 0x90 ], %o0
2019de8: 7f ff bc 19 call 2008e4c <rtems_semaphore_obtain>
2019dec: 94 10 20 00 clr %o2
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
2019df0: 80 a2 20 00 cmp %o0, 0
2019df4: 02 80 00 08 be 2019e14 <msdos_file_ftruncate+0x44> <== ALWAYS TAKEN
2019df8: 80 a2 00 19 cmp %o0, %i1
rtems_set_errno_and_return_minus_one(EIO);
2019dfc: 40 00 00 89 call 201a020 <__errno> <== NOT EXECUTED
2019e00: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
2019e04: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
2019e08: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
2019e0c: 81 c7 e0 08 ret <== NOT EXECUTED
2019e10: 81 e8 00 00 restore <== NOT EXECUTED
old_length = fat_fd->fat_file_size;
if (length < old_length) {
2019e14: 14 80 00 08 bg 2019e34 <msdos_file_ftruncate+0x64> <== NEVER TAKEN
2019e18: f6 07 20 18 ld [ %i4 + 0x18 ], %i3
2019e1c: 80 a2 00 19 cmp %o0, %i1
2019e20: 12 80 00 0d bne 2019e54 <msdos_file_ftruncate+0x84> <== NEVER TAKEN
2019e24: 90 10 00 1d mov %i5, %o0
2019e28: 80 a6 c0 1a cmp %i3, %i2
2019e2c: 08 80 00 0b bleu 2019e58 <msdos_file_ftruncate+0x88>
2019e30: 92 10 00 1c mov %i4, %o1
rc = fat_file_truncate(&fs_info->fat, fat_fd, length);
2019e34: 90 10 00 1d mov %i5, %o0
2019e38: 92 10 00 1c mov %i4, %o1
2019e3c: 7f ff dc 68 call 2010fdc <fat_file_truncate>
2019e40: 94 10 00 1a mov %i2, %o2
errno = ENOSPC;
rc = -1;
}
}
if (rc == RC_OK) {
2019e44: b0 92 20 00 orcc %o0, 0, %i0
2019e48: 22 80 00 18 be,a 2019ea8 <msdos_file_ftruncate+0xd8> <== ALWAYS TAKEN
2019e4c: f4 27 20 18 st %i2, [ %i4 + 0x18 ]
2019e50: 30 80 00 16 b,a 2019ea8 <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,
2019e54: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
2019e58: 94 10 20 01 mov 1, %o2
2019e5c: 96 10 00 1a mov %i2, %o3
2019e60: 7f ff dd 05 call 2011274 <fat_file_extend>
2019e64: 98 07 bf fc add %fp, -4, %o4
fat_fd,
true,
length,
&new_length);
if (rc == RC_OK && length != new_length) {
2019e68: b0 92 20 00 orcc %o0, 0, %i0
2019e6c: 12 80 00 0f bne 2019ea8 <msdos_file_ftruncate+0xd8> <== NEVER TAKEN
2019e70: 80 a6 60 00 cmp %i1, 0
2019e74: 12 80 00 05 bne 2019e88 <msdos_file_ftruncate+0xb8> <== NEVER TAKEN
2019e78: c2 07 bf fc ld [ %fp + -4 ], %g1
2019e7c: 80 a6 80 01 cmp %i2, %g1
2019e80: 22 80 00 0a be,a 2019ea8 <msdos_file_ftruncate+0xd8> <== ALWAYS TAKEN
2019e84: f4 27 20 18 st %i2, [ %i4 + 0x18 ]
fat_file_truncate(&fs_info->fat, fat_fd, old_length);
2019e88: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
2019e8c: 94 10 00 1b mov %i3, %o2 <== NOT EXECUTED
2019e90: 7f ff dc 53 call 2010fdc <fat_file_truncate> <== NOT EXECUTED
2019e94: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
errno = ENOSPC;
2019e98: 40 00 00 62 call 201a020 <__errno> <== NOT EXECUTED
2019e9c: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
2019ea0: 82 10 20 1c mov 0x1c, %g1 <== NOT EXECUTED
2019ea4: 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);
2019ea8: 7f ff bc 33 call 2008f74 <rtems_semaphore_release>
2019eac: d0 07 60 90 ld [ %i5 + 0x90 ], %o0
return rc;
}
2019eb0: 81 c7 e0 08 ret
2019eb4: 81 e8 00 00 restore
02019bd0 <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)
{
2019bd0: 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;
2019bd4: c2 06 20 28 ld [ %i0 + 0x28 ], %g1
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
2019bd8: 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;
2019bdc: 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,
2019be0: 92 10 20 00 clr %o1
2019be4: d0 04 20 90 ld [ %l0 + 0x90 ], %o0
2019be8: 94 10 20 00 clr %o2
2019bec: 7f ff bc 98 call 2008e4c <rtems_semaphore_obtain>
2019bf0: b6 10 00 18 mov %i0, %i3
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
2019bf4: 80 a2 20 00 cmp %o0, 0
2019bf8: 22 80 00 08 be,a 2019c18 <msdos_file_read+0x48> <== ALWAYS TAKEN
2019bfc: d4 06 20 0c ld [ %i0 + 0xc ], %o2
rtems_set_errno_and_return_minus_one(EIO);
2019c00: 40 00 01 08 call 201a020 <__errno> <== NOT EXECUTED
2019c04: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
2019c08: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
2019c0c: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
2019c10: 81 c7 e0 08 ret <== NOT EXECUTED
2019c14: 81 e8 00 00 restore <== NOT EXECUTED
ret = fat_file_read(&fs_info->fat, fat_fd, iop->offset, count,
2019c18: 90 10 00 10 mov %l0, %o0
2019c1c: 92 10 00 1d mov %i5, %o1
2019c20: 96 10 00 1a mov %i2, %o3
2019c24: 7f ff dc 80 call 2010e24 <fat_file_read>
2019c28: 98 10 00 19 mov %i1, %o4
buffer);
if (ret > 0)
2019c2c: b0 92 20 00 orcc %o0, 0, %i0
2019c30: 04 80 00 06 ble 2019c48 <msdos_file_read+0x78>
2019c34: 85 3e 20 1f sra %i0, 0x1f, %g2
iop->offset += ret;
2019c38: f8 1e e0 08 ldd [ %i3 + 8 ], %i4
2019c3c: 86 87 40 18 addcc %i5, %i0, %g3
2019c40: 84 47 00 02 addx %i4, %g2, %g2
2019c44: c4 3e e0 08 std %g2, [ %i3 + 8 ]
rtems_semaphore_release(fs_info->vol_sema);
2019c48: 7f ff bc cb call 2008f74 <rtems_semaphore_release>
2019c4c: d0 04 20 90 ld [ %l0 + 0x90 ], %o0
return ret;
}
2019c50: 81 c7 e0 08 ret
2019c54: 81 e8 00 00 restore
02019d30 <msdos_file_stat>:
int
msdos_file_stat(
const rtems_filesystem_location_info_t *loc,
struct stat *buf
)
{
2019d30: 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;
2019d34: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
fat_file_fd_t *fat_fd = loc->node_access;
2019d38: 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;
2019d3c: 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,
2019d40: 92 10 20 00 clr %o1
2019d44: d0 07 60 90 ld [ %i5 + 0x90 ], %o0
2019d48: 7f ff bc 41 call 2008e4c <rtems_semaphore_obtain>
2019d4c: 94 10 20 00 clr %o2
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
2019d50: 80 a2 20 00 cmp %o0, 0
2019d54: 22 80 00 08 be,a 2019d74 <msdos_file_stat+0x44> <== ALWAYS TAKEN
2019d58: c2 07 60 58 ld [ %i5 + 0x58 ], %g1
rtems_set_errno_and_return_minus_one(EIO);
2019d5c: 40 00 00 b1 call 201a020 <__errno> <== NOT EXECUTED
2019d60: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
2019d64: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
2019d68: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
2019d6c: 81 c7 e0 08 ret <== NOT EXECUTED
2019d70: 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);
2019d74: 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);
2019d78: c4 18 40 00 ldd [ %g1 ], %g2
buf->st_ino = fat_fd->ino;
2019d7c: 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);
2019d80: c4 3e 40 00 std %g2, [ %i1 ]
buf->st_ino = fat_fd->ino;
2019d84: c2 26 60 08 st %g1, [ %i1 + 8 ]
buf->st_mode = S_IFREG | S_IRWXU | S_IRWXG | S_IRWXO;
2019d88: 03 00 00 20 sethi %hi(0x8000), %g1
2019d8c: 82 10 61 ff or %g1, 0x1ff, %g1 ! 81ff <PROM_START+0x81ff>
2019d90: c2 26 60 0c st %g1, [ %i1 + 0xc ]
buf->st_rdev = 0ll;
buf->st_size = fat_fd->fat_file_size;
2019d94: 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;
2019d98: c0 26 60 18 clr [ %i1 + 0x18 ]
buf->st_size = fat_fd->fat_file_size;
2019d9c: c2 26 60 24 st %g1, [ %i1 + 0x24 ]
buf->st_blocks = fat_fd->fat_file_size >> FAT_SECTOR512_BITS;
2019da0: 83 30 60 09 srl %g1, 9, %g1
2019da4: c2 26 60 44 st %g1, [ %i1 + 0x44 ]
buf->st_blksize = fs_info->fat.vol.bps;
2019da8: 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;
2019dac: 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;
2019db0: c2 26 60 40 st %g1, [ %i1 + 0x40 ]
buf->st_mtime = fat_fd->mtime;
2019db4: 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;
2019db8: 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;
2019dbc: c2 26 60 30 st %g1, [ %i1 + 0x30 ]
rtems_semaphore_release(fs_info->vol_sema);
2019dc0: 7f ff bc 6d call 2008f74 <rtems_semaphore_release>
2019dc4: b0 10 20 00 clr %i0
return RC_OK;
}
2019dc8: 81 c7 e0 08 ret
2019dcc: 81 e8 00 00 restore
02019eb8 <msdos_file_sync>:
* RETURNS:
* RC_OK on success, or -1 if error occured (errno set appropriately)
*/
int
msdos_file_sync(rtems_libio_t *iop)
{
2019eb8: 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;
2019ebc: c2 06 20 28 ld [ %i0 + 0x28 ], %g1
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
2019ec0: 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;
2019ec4: fa 00 60 08 ld [ %g1 + 8 ], %i5
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
2019ec8: 94 10 20 00 clr %o2
2019ecc: 7f ff bb e0 call 2008e4c <rtems_semaphore_obtain>
2019ed0: d0 07 60 90 ld [ %i5 + 0x90 ], %o0
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
2019ed4: 80 a2 20 00 cmp %o0, 0
2019ed8: 02 80 00 08 be 2019ef8 <msdos_file_sync+0x40> <== ALWAYS TAKEN
2019edc: 01 00 00 00 nop
rtems_set_errno_and_return_minus_one(EIO);
2019ee0: 40 00 00 50 call 201a020 <__errno> <== NOT EXECUTED
2019ee4: b0 10 3f ff mov -1, %i0 ! ffffffff <RAM_END+0xfdbfffff> <== NOT EXECUTED
2019ee8: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
2019eec: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
2019ef0: 81 c7 e0 08 ret <== NOT EXECUTED
2019ef4: 81 e8 00 00 restore <== NOT EXECUTED
rc = msdos_file_update(iop);
2019ef8: 7f ff ff 08 call 2019b18 <msdos_file_update>
2019efc: 90 10 00 18 mov %i0, %o0
if (rc != RC_OK)
2019f00: b0 92 20 00 orcc %o0, 0, %i0
2019f04: 12 80 00 04 bne 2019f14 <msdos_file_sync+0x5c> <== NEVER TAKEN
2019f08: 01 00 00 00 nop
{
rtems_semaphore_release(fs_info->vol_sema);
return rc;
}
rc = msdos_sync_unprotected(fs_info);
2019f0c: 7f ff f7 78 call 2017cec <msdos_sync_unprotected>
2019f10: 90 10 00 1d mov %i5, %o0
rtems_semaphore_release(fs_info->vol_sema);
2019f14: 7f ff bc 18 call 2008f74 <rtems_semaphore_release>
2019f18: d0 07 60 90 ld [ %i5 + 0x90 ], %o0
return RC_OK;
}
2019f1c: 81 c7 e0 08 ret
2019f20: 81 e8 00 00 restore
02019b18 <msdos_file_update>:
#include "msdos.h"
static int
msdos_file_update(rtems_libio_t *iop)
{
2019b18: 9d e3 bf a0 save %sp, -96, %sp
int rc = RC_OK;
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
2019b1c: 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))
2019b20: c2 0e 60 30 ldub [ %i1 + 0x30 ], %g1
2019b24: 80 88 60 01 btst 1, %g1
2019b28: 12 80 00 11 bne 2019b6c <msdos_file_update+0x54> <== NEVER TAKEN
2019b2c: 90 10 20 00 clr %o0
{
rc = msdos_set_first_cluster_num(iop->pathinfo.mt_entry, fat_fd);
2019b30: d0 06 20 28 ld [ %i0 + 0x28 ], %o0
2019b34: 7f ff f3 5a call 201689c <msdos_set_first_cluster_num>
2019b38: 92 10 00 19 mov %i1, %o1
if (rc != RC_OK)
2019b3c: 80 a2 20 00 cmp %o0, 0
2019b40: 12 80 00 0b bne 2019b6c <msdos_file_update+0x54> <== NEVER TAKEN
2019b44: 01 00 00 00 nop
{
return rc;
}
rc = msdos_set_file_size(iop->pathinfo.mt_entry, fat_fd);
2019b48: d0 06 20 28 ld [ %i0 + 0x28 ], %o0
2019b4c: 7f ff f3 86 call 2016964 <msdos_set_file_size>
2019b50: 92 10 00 19 mov %i1, %o1
if (rc != RC_OK)
2019b54: 80 a2 20 00 cmp %o0, 0
2019b58: 12 80 00 05 bne 2019b6c <msdos_file_update+0x54> <== NEVER TAKEN
2019b5c: 01 00 00 00 nop
{
return rc;
}
rc = msdos_set_dir_wrt_time_and_date(iop->pathinfo.mt_entry, fat_fd);
2019b60: f0 06 20 28 ld [ %i0 + 0x28 ], %i0
2019b64: 7f ff f3 13 call 20167b0 <msdos_set_dir_wrt_time_and_date>
2019b68: 81 e8 00 00 restore
return rc;
}
}
return rc;
}
2019b6c: 81 c7 e0 08 ret <== NOT EXECUTED
2019b70: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED
02019c58 <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)
{
2019c58: 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;
2019c5c: c2 06 20 28 ld [ %i0 + 0x28 ], %g1
fat_file_fd_t *fat_fd = iop->pathinfo.node_access;
2019c60: 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;
2019c64: 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,
2019c68: 92 10 20 00 clr %o1
2019c6c: d0 04 20 90 ld [ %l0 + 0x90 ], %o0
2019c70: 94 10 20 00 clr %o2
2019c74: 7f ff bc 76 call 2008e4c <rtems_semaphore_obtain>
2019c78: b6 10 00 18 mov %i0, %i3
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
2019c7c: 80 a2 20 00 cmp %o0, 0
2019c80: 22 80 00 08 be,a 2019ca0 <msdos_file_write+0x48> <== ALWAYS TAKEN
2019c84: c2 06 20 10 ld [ %i0 + 0x10 ], %g1
rtems_set_errno_and_return_minus_one(EIO);
2019c88: 40 00 00 e6 call 201a020 <__errno> <== NOT EXECUTED
2019c8c: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
2019c90: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
2019c94: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
2019c98: 81 c7 e0 08 ret <== NOT EXECUTED
2019c9c: 81 e8 00 00 restore <== NOT EXECUTED
if ((iop->flags & LIBIO_FLAGS_APPEND) != 0)
2019ca0: 80 88 62 00 btst 0x200, %g1
2019ca4: 22 80 00 06 be,a 2019cbc <msdos_file_write+0x64>
2019ca8: d4 06 e0 0c ld [ %i3 + 0xc ], %o2
iop->offset = fat_fd->fat_file_size;
2019cac: c2 04 60 18 ld [ %l1 + 0x18 ], %g1
2019cb0: c0 26 20 08 clr [ %i0 + 8 ]
2019cb4: c2 26 20 0c st %g1, [ %i0 + 0xc ]
ret = fat_file_write(&fs_info->fat, fat_fd, iop->offset, count,
2019cb8: d4 06 e0 0c ld [ %i3 + 0xc ], %o2
2019cbc: 90 10 00 10 mov %l0, %o0
2019cc0: 92 10 00 11 mov %l1, %o1
2019cc4: 96 10 00 1a mov %i2, %o3
2019cc8: 7f ff de 06 call 20114e0 <fat_file_write>
2019ccc: 98 10 00 19 mov %i1, %o4
buffer);
if (ret < 0)
2019cd0: b0 92 20 00 orcc %o0, 0, %i0
2019cd4: 36 80 00 06 bge,a 2019cec <msdos_file_write+0x94> <== ALWAYS TAKEN
2019cd8: f8 1e e0 08 ldd [ %i3 + 8 ], %i4
{
rtems_semaphore_release(fs_info->vol_sema);
2019cdc: 7f ff bc a6 call 2008f74 <rtems_semaphore_release> <== NOT EXECUTED
2019ce0: d0 04 20 90 ld [ %l0 + 0x90 ], %o0 <== NOT EXECUTED
return -1;
2019ce4: 81 c7 e0 08 ret <== NOT EXECUTED
2019ce8: 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;
2019cec: 85 3e 20 1f sra %i0, 0x1f, %g2
2019cf0: 86 86 00 1d addcc %i0, %i5, %g3
2019cf4: 84 40 80 1c addx %g2, %i4, %g2
2019cf8: c4 3e e0 08 std %g2, [ %i3 + 8 ]
if (iop->offset > fat_fd->fat_file_size)
2019cfc: 80 a0 a0 00 cmp %g2, 0
2019d00: 14 80 00 07 bg 2019d1c <msdos_file_write+0xc4> <== NEVER TAKEN
2019d04: c2 04 60 18 ld [ %l1 + 0x18 ], %g1
2019d08: 80 a0 a0 00 cmp %g2, 0
2019d0c: 12 80 00 05 bne 2019d20 <msdos_file_write+0xc8> <== NEVER TAKEN
2019d10: 80 a0 c0 01 cmp %g3, %g1
2019d14: 08 80 00 03 bleu 2019d20 <msdos_file_write+0xc8>
2019d18: 01 00 00 00 nop
fat_fd->fat_file_size = iop->offset;
2019d1c: c6 24 60 18 st %g3, [ %l1 + 0x18 ]
rtems_semaphore_release(fs_info->vol_sema);
2019d20: 7f ff bc 95 call 2008f74 <rtems_semaphore_release>
2019d24: d0 04 20 90 ld [ %l0 + 0x90 ], %o0
return ret;
}
2019d28: 81 c7 e0 08 ret
2019d2c: 81 e8 00 00 restore
020193fc <msdos_filename_unix2dos>:
/*
* Fill the dos filename string with blanks. These are DOS's pad
* characters.
*/
for (i = 0; i <= 10; i++)
20193fc: 82 10 20 00 clr %g1
dn[i] = ' ';
2019400: 84 10 20 20 mov 0x20, %g2
2019404: 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++)
2019408: 82 00 60 01 inc %g1
201940c: 80 a0 60 0b cmp %g1, 0xb
2019410: 32 bf ff fe bne,a 2019408 <msdos_filename_unix2dos+0xc>
2019414: 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) {
2019418: c2 4a 00 00 ldsb [ %o0 ], %g1
201941c: 80 a0 60 2e cmp %g1, 0x2e
2019420: 12 80 00 12 bne 2019468 <msdos_filename_unix2dos+0x6c> <== ALWAYS TAKEN
2019424: 80 a2 60 00 cmp %o1, 0
2019428: 80 a2 60 01 cmp %o1, 1 <== NOT EXECUTED
201942c: 32 80 00 04 bne,a 201943c <msdos_filename_unix2dos+0x40> <== NOT EXECUTED
2019430: c2 4a 20 01 ldsb [ %o0 + 1 ], %g1 <== NOT EXECUTED
dn[0] = '.';
return 0;
2019434: 10 80 00 4f b 2019570 <msdos_filename_unix2dos+0x174> <== NOT EXECUTED
2019438: c2 2a 80 00 stb %g1, [ %o2 ] <== NOT EXECUTED
}
if (un[0] == '.' && un[1] == '.' && unlen == 2) {
201943c: 80 a0 60 2e cmp %g1, 0x2e <== NOT EXECUTED
2019440: 12 80 00 0a bne 2019468 <msdos_filename_unix2dos+0x6c> <== NOT EXECUTED
2019444: 80 a2 60 00 cmp %o1, 0 <== NOT EXECUTED
2019448: 80 a2 60 02 cmp %o1, 2 <== NOT EXECUTED
201944c: 12 80 00 07 bne 2019468 <msdos_filename_unix2dos+0x6c> <== NOT EXECUTED
2019450: 80 a2 60 00 cmp %o1, 0 <== NOT EXECUTED
dn[0] = '.';
2019454: c2 2a 80 00 stb %g1, [ %o2 ] <== NOT EXECUTED
dn[1] = '.';
return 0;
2019458: 10 80 00 46 b 2019570 <msdos_filename_unix2dos+0x174> <== NOT EXECUTED
201945c: 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--;
2019460: 92 02 7f ff add %o1, -1, %o1 <== NOT EXECUTED
}
/*
* Remove any dots from the start of a file name.
*/
while (unlen && (*un == '.')) {
2019464: 80 a2 60 00 cmp %o1, 0 <== NOT EXECUTED
2019468: 32 80 00 05 bne,a 201947c <msdos_filename_unix2dos+0x80> <== ALWAYS TAKEN
201946c: 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++)
2019470: 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)
2019474: 10 80 00 0d b 20194a8 <msdos_filename_unix2dos+0xac>
2019478: 1b 00 80 9a sethi %hi(0x2026800), %o5
}
/*
* Remove any dots from the start of a file name.
*/
while (unlen && (*un == '.')) {
201947c: 80 a0 60 2e cmp %g1, 0x2e
2019480: 22 bf ff f8 be,a 2019460 <msdos_filename_unix2dos+0x64> <== NEVER TAKEN
2019484: 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++)
2019488: 10 bf ff fb b 2019474 <msdos_filename_unix2dos+0x78>
201948c: 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)
2019490: c8 0b 00 04 ldub [ %o4 + %g4 ], %g4
2019494: 80 89 20 ff btst 0xff, %g4
2019498: 02 80 00 1a be 2019500 <msdos_filename_unix2dos+0x104>
201949c: 80 a0 a0 00 cmp %g2, 0
break;
dn[i] = msdos_map[c];
20194a0: 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++) {
20194a4: 82 00 60 01 inc %g1
20194a8: 84 a2 40 01 subcc %o1, %g1, %g2
20194ac: 02 80 00 14 be 20194fc <msdos_filename_unix2dos+0x100>
20194b0: 86 02 00 01 add %o0, %g1, %g3
20194b4: 80 a0 60 07 cmp %g1, 7
20194b8: 04 80 00 03 ble 20194c4 <msdos_filename_unix2dos+0xc8>
20194bc: 88 10 20 01 mov 1, %g4
20194c0: 88 10 20 00 clr %g4
20194c4: 80 89 20 ff btst 0xff, %g4
20194c8: 02 80 00 0e be 2019500 <msdos_filename_unix2dos+0x104>
20194cc: 80 a0 a0 00 cmp %g2, 0
20194d0: c8 0a 00 01 ldub [ %o0 + %g1 ], %g4
20194d4: 80 a1 20 00 cmp %g4, 0
20194d8: 02 80 00 09 be 20194fc <msdos_filename_unix2dos+0x100> <== NEVER TAKEN
20194dc: 80 a1 20 2e cmp %g4, 0x2e
20194e0: 12 bf ff ec bne 2019490 <msdos_filename_unix2dos+0x94>
20194e4: 98 13 61 60 or %o5, 0x160, %o4
/*
* Strip any further characters up to a '.' or the end of the
* string.
*/
while (unlen && (c = *un)) {
20194e8: 10 80 00 06 b 2019500 <msdos_filename_unix2dos+0x104>
20194ec: 80 a0 a0 00 cmp %g2, 0
un++;
unlen--;
/* Make sure we've skipped over the dot before stopping. */
if (c == '.')
20194f0: 80 a0 60 2e cmp %g1, 0x2e
20194f4: 02 80 00 09 be 2019518 <msdos_filename_unix2dos+0x11c>
20194f8: 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)) {
20194fc: 80 a0 a0 00 cmp %g2, 0
2019500: 02 80 00 07 be 201951c <msdos_filename_unix2dos+0x120>
2019504: 82 10 20 08 mov 8, %g1
2019508: c2 08 c0 00 ldub [ %g3 ], %g1
201950c: 80 a0 60 00 cmp %g1, 0
2019510: 32 bf ff f8 bne,a 20194f0 <msdos_filename_unix2dos+0xf4> <== ALWAYS TAKEN
2019514: 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++)
2019518: 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)
201951c: 10 80 00 08 b 201953c <msdos_filename_unix2dos+0x140>
2019520: 1b 00 80 9a sethi %hi(0x2026800), %o5
2019524: c8 0b 00 04 ldub [ %o4 + %g4 ], %g4
2019528: 80 89 20 ff btst 0xff, %g4
201952c: 02 80 00 11 be 2019570 <msdos_filename_unix2dos+0x174> <== ALWAYS TAKEN
2019530: 84 00 bf ff add %g2, -1, %g2
break;
dn[i] = msdos_map[c];
2019534: 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++) {
2019538: 82 00 60 01 inc %g1 <== NOT EXECUTED
201953c: 80 a0 a0 00 cmp %g2, 0
2019540: 02 80 00 0c be 2019570 <msdos_filename_unix2dos+0x174>
2019544: 80 a0 60 0a cmp %g1, 0xa
2019548: 04 80 00 03 ble 2019554 <msdos_filename_unix2dos+0x158> <== ALWAYS TAKEN
201954c: 88 10 20 01 mov 1, %g4
2019550: 88 10 20 00 clr %g4 <== NOT EXECUTED
2019554: 80 89 20 ff btst 0xff, %g4
2019558: 02 80 00 06 be 2019570 <msdos_filename_unix2dos+0x174> <== NEVER TAKEN
201955c: 88 00 c0 01 add %g3, %g1, %g4
2019560: c8 09 3f f8 ldub [ %g4 + -8 ], %g4
2019564: 80 a1 20 00 cmp %g4, 0
2019568: 12 bf ff ef bne 2019524 <msdos_filename_unix2dos+0x128> <== ALWAYS TAKEN
201956c: 98 13 61 60 or %o5, 0x160, %o4
dn[i] = msdos_map[c];
un++;
unlen--;
}
return 0;
}
2019570: 81 c3 e0 08 retl
2019574: 90 10 20 00 clr %o0
02017ad8 <msdos_find_name>:
msdos_find_name(
rtems_filesystem_location_info_t *parent_loc,
const char *name,
int name_len
)
{
2017ad8: 9d e3 bf 60 save %sp, -160, %sp
int rc = RC_OK;
msdos_fs_info_t *fs_info = parent_loc->mt_entry->fs_info;
2017adc: 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);
2017ae0: 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;
2017ae4: 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);
2017ae8: 92 10 20 00 clr %o1
2017aec: 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;
2017af0: 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);
2017af4: 40 00 0c 3d call 201abe8 <memset>
2017af8: 90 10 00 1c mov %i4, %o0
name_type = msdos_long_to_short (name,
2017afc: 92 10 00 1a mov %i2, %o1
2017b00: 94 10 00 1c mov %i4, %o2
2017b04: 96 10 20 0b mov 0xb, %o3
2017b08: 7f ff fa 9f call 2016584 <msdos_long_to_short>
2017b0c: 90 10 00 19 mov %i1, %o0
msdos_find_name(
rtems_filesystem_location_info_t *parent_loc,
const char *name,
int name_len
)
{
2017b10: 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,
2017b14: 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,
2017b18: f8 23 a0 5c st %i4, [ %sp + 0x5c ]
2017b1c: 90 10 00 18 mov %i0, %o0
2017b20: 92 10 20 00 clr %o1
2017b24: 94 10 00 19 mov %i1, %o2
2017b28: 96 10 00 1a mov %i2, %o3
2017b2c: 7f ff ff ab call 20179d8 <msdos_get_name_node>
2017b30: 9a 07 bf d0 add %fp, -48, %o5
&dir_pos, node_entry);
if (rc != RC_OK)
2017b34: b0 92 20 00 orcc %o0, 0, %i0
2017b38: 12 80 00 68 bne 2017cd8 <msdos_find_name+0x200>
2017b3c: 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;
2017b40: 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) ||
2017b44: 84 08 60 08 and %g1, 8, %g2
2017b48: 80 88 a0 ff btst 0xff, %g2
2017b4c: 12 80 00 63 bne 2017cd8 <msdos_find_name+0x200> <== NEVER TAKEN
2017b50: b0 16 21 01 or %i0, 0x101, %i0
2017b54: 82 08 60 3f and %g1, 0x3f, %g1
2017b58: 80 a0 60 0f cmp %g1, 0xf
2017b5c: 02 80 00 5f be 2017cd8 <msdos_find_name+0x200> <== NEVER TAKEN
2017b60: 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);
2017b64: 92 07 bf d0 add %fp, -48, %o1
2017b68: 7f ff e4 4c call 2010c98 <fat_file_open>
2017b6c: 94 07 bf cc add %fp, -52, %o2
if (rc != RC_OK)
2017b70: b0 92 20 00 orcc %o0, 0, %i0
2017b74: 12 80 00 59 bne 2017cd8 <msdos_find_name+0x200> <== NEVER TAKEN
2017b78: f8 07 bf cc ld [ %fp + -52 ], %i4
return rc;
fat_fd->dir_pos = dir_pos;
2017b7c: 92 07 bf d0 add %fp, -48, %o1
2017b80: 90 07 20 20 add %i4, 0x20, %o0
2017b84: 40 00 0b dc call 201aaf4 <memcpy>
2017b88: 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)
2017b8c: c2 07 20 08 ld [ %i4 + 8 ], %g1
2017b90: 80 a0 60 01 cmp %g1, 1
2017b94: 32 80 00 49 bne,a 2017cb8 <msdos_find_name+0x1e0>
2017b98: d2 06 e0 08 ld [ %i3 + 8 ], %o1
{
fat_fd->cln = MSDOS_EXTRACT_CLUSTER_NUM(node_entry);
2017b9c: c2 17 bf f4 lduh [ %fp + -12 ], %g1
2017ba0: 83 28 60 10 sll %g1, 0x10, %g1
2017ba4: 85 30 60 18 srl %g1, 0x18, %g2
2017ba8: 87 30 60 08 srl %g1, 8, %g3
2017bac: 03 00 00 3f sethi %hi(0xfc00), %g1
2017bb0: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff <PROM_START+0xffff>
2017bb4: 86 08 c0 01 and %g3, %g1, %g3
2017bb8: 86 10 80 03 or %g2, %g3, %g3
2017bbc: c4 17 bf fa lduh [ %fp + -6 ], %g2
2017bc0: 87 28 e0 10 sll %g3, 0x10, %g3
2017bc4: 85 28 a0 10 sll %g2, 0x10, %g2
2017bc8: 89 30 a0 18 srl %g2, 0x18, %g4
2017bcc: 85 30 a0 08 srl %g2, 8, %g2
2017bd0: 84 08 80 01 and %g2, %g1, %g2
2017bd4: 84 11 00 02 or %g4, %g2, %g2
2017bd8: 84 10 c0 02 or %g3, %g2, %g2
2017bdc: c4 27 20 1c st %g2, [ %i4 + 0x1c ]
time_val = *MSDOS_DIR_WRITE_TIME(node_entry);
date = *MSDOS_DIR_WRITE_DATE(node_entry);
2017be0: c4 17 bf f8 lduh [ %fp + -8 ], %g2
fat_fd->mtime = msdos_date_dos2unix(CF_LE_W(date), CF_LE_W(time_val));
2017be4: 85 28 a0 10 sll %g2, 0x10, %g2
2017be8: 91 30 a0 18 srl %g2, 0x18, %o0
2017bec: 85 30 a0 08 srl %g2, 8, %g2
2017bf0: 86 08 80 01 and %g2, %g1, %g3
2017bf4: c4 17 bf f6 lduh [ %fp + -10 ], %g2
2017bf8: 90 12 00 03 or %o0, %g3, %o0
2017bfc: 85 28 a0 10 sll %g2, 0x10, %g2
2017c00: 93 30 a0 18 srl %g2, 0x18, %o1
2017c04: 85 30 a0 08 srl %g2, 8, %g2
2017c08: 82 08 80 01 and %g2, %g1, %g1
2017c0c: 40 00 05 b4 call 20192dc <msdos_date_dos2unix>
2017c10: 92 12 40 01 or %o1, %g1, %o1
if ((*MSDOS_DIR_ATTR(node_entry)) & MSDOS_ATTR_DIRECTORY)
2017c14: 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));
2017c18: d0 27 20 40 st %o0, [ %i4 + 0x40 ]
if ((*MSDOS_DIR_ATTR(node_entry)) & MSDOS_ATTR_DIRECTORY)
2017c1c: 82 08 60 10 and %g1, 0x10, %g1
2017c20: 80 88 60 ff btst 0xff, %g1
2017c24: 02 80 00 0e be 2017c5c <msdos_find_name+0x184>
2017c28: f8 07 bf cc ld [ %fp + -52 ], %i4
{
fat_fd->fat_file_type = FAT_DIRECTORY;
fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
2017c2c: 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;
2017c30: c0 27 20 10 clr [ %i4 + 0x10 ]
fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
2017c34: c2 27 20 14 st %g1, [ %i4 + 0x14 ]
rc = fat_file_size(&fs_info->fat, fat_fd);
2017c38: 90 10 00 1d mov %i5, %o0
2017c3c: 7f ff e6 be call 2011734 <fat_file_size>
2017c40: 92 10 00 1c mov %i4, %o1
if (rc != RC_OK)
2017c44: b0 92 20 00 orcc %o0, 0, %i0
2017c48: 02 80 00 0d be 2017c7c <msdos_find_name+0x1a4> <== ALWAYS TAKEN
2017c4c: c2 07 bf cc ld [ %fp + -52 ], %g1
{
fat_file_close(&fs_info->fat, fat_fd);
2017c50: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
2017c54: 10 80 00 1f b 2017cd0 <msdos_find_name+0x1f8> <== NOT EXECUTED
2017c58: 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));
2017c5c: 7f ff fa 30 call 201651c <CPU_swap_u32>
2017c60: d0 07 bf fc ld [ %fp + -4 ], %o0
fat_fd->fat_file_type = FAT_FILE;
2017c64: 82 10 20 04 mov 4, %g1
return rc;
}
}
else
{
fat_fd->fat_file_size = CF_LE_L(*MSDOS_DIR_FILE_SIZE(node_entry));
2017c68: d0 27 20 18 st %o0, [ %i4 + 0x18 ]
fat_fd->fat_file_type = FAT_FILE;
2017c6c: c2 27 20 10 st %g1, [ %i4 + 0x10 ]
fat_fd->size_limit = MSDOS_MAX_FILE_SIZE;
2017c70: 82 10 3f ff mov -1, %g1
2017c74: c2 27 20 14 st %g1, [ %i4 + 0x14 ]
}
/* these data is not actual for zero-length fat-file */
fat_fd->map.file_cln = 0;
2017c78: c2 07 bf cc ld [ %fp + -52 ], %g1
fat_fd->map.disk_cln = fat_fd->cln;
2017c7c: c4 00 60 1c ld [ %g1 + 0x1c ], %g2
if ((fat_fd->fat_file_size != 0) &&
2017c80: 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;
2017c84: c0 20 60 34 clr [ %g1 + 0x34 ]
fat_fd->map.disk_cln = fat_fd->cln;
if ((fat_fd->fat_file_size != 0) &&
2017c88: 80 a0 e0 00 cmp %g3, 0
2017c8c: 02 80 00 08 be 2017cac <msdos_find_name+0x1d4>
2017c90: c4 20 60 38 st %g2, [ %g1 + 0x38 ]
(fat_fd->fat_file_size <= fs_info->fat.vol.bpc))
2017c94: 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) &&
2017c98: 80 a0 c0 04 cmp %g3, %g4
2017c9c: 38 80 00 05 bgu,a 2017cb0 <msdos_find_name+0x1d8>
2017ca0: 84 10 3f ff mov -1, %g2
{
fat_fd->map.last_cln = fat_fd->cln;
}
else
{
fat_fd->map.last_cln = FAT_UNDEFINED_VALUE;
2017ca4: 10 80 00 04 b 2017cb4 <msdos_find_name+0x1dc>
2017ca8: c4 20 60 3c st %g2, [ %g1 + 0x3c ]
2017cac: 84 10 3f ff mov -1, %g2
2017cb0: 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);
2017cb4: d2 06 e0 08 ld [ %i3 + 8 ], %o1
2017cb8: 7f ff e5 0e call 20110f0 <fat_file_close>
2017cbc: 90 10 00 1d mov %i5, %o0
if (rc != RC_OK)
2017cc0: b0 92 20 00 orcc %o0, 0, %i0
2017cc4: 02 80 00 07 be 2017ce0 <msdos_find_name+0x208> <== ALWAYS TAKEN
2017cc8: d2 07 bf cc ld [ %fp + -52 ], %o1
{
fat_file_close(&fs_info->fat, fat_fd);
2017ccc: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
2017cd0: 7f ff e5 08 call 20110f0 <fat_file_close> <== NOT EXECUTED
2017cd4: 01 00 00 00 nop <== NOT EXECUTED
2017cd8: 81 c7 e0 08 ret
2017cdc: 81 e8 00 00 restore
return rc;
}
/* update node_info_ptr field */
parent_loc->node_access = fat_fd;
2017ce0: d2 26 e0 08 st %o1, [ %i3 + 8 ]
return rc;
}
2017ce4: 81 c7 e0 08 ret
2017ce8: 81 e8 00 00 restore
02016c2c <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
)
{
2016c2c: 9d e3 bf 60 save %sp, -160, %sp
2016c30: f6 27 a0 50 st %i3, [ %fp + 0x50 ]
2016c34: 84 10 00 1a mov %i2, %g2
2016c38: e4 07 a0 5c ld [ %fp + 0x5c ], %l2
2016c3c: 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);
2016c40: 80 a7 20 00 cmp %i4, 0
2016c44: 14 80 00 0a bg 2016c6c <msdos_find_name_in_fat_file+0x40> <== ALWAYS TAKEN
2016c48: e0 06 20 08 ld [ %i0 + 8 ], %l0
2016c4c: 11 00 80 99 sethi %hi(0x2026400), %o0 <== NOT EXECUTED
2016c50: 15 00 80 99 sethi %hi(0x2026400), %o2 <== NOT EXECUTED
2016c54: 17 00 80 99 sethi %hi(0x2026400), %o3 <== NOT EXECUTED
2016c58: 90 12 22 a0 or %o0, 0x2a0, %o0 <== NOT EXECUTED
2016c5c: 92 10 23 c4 mov 0x3c4, %o1 <== NOT EXECUTED
2016c60: 94 12 a3 70 or %o2, 0x370, %o2 <== NOT EXECUTED
2016c64: 10 80 00 3e b 2016d5c <msdos_find_name_in_fat_file+0x130> <== NOT EXECUTED
2016c68: 96 12 e3 30 or %o3, 0x330, %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;
2016c6c: 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;
2016c70: c0 24 80 00 clr [ %l2 ]
dir_pos->sname.ofs = 0;
dir_pos->lname.cln = FAT_FILE_SHORT_NAME;
2016c74: c2 24 a0 08 st %g1, [ %l2 + 8 ]
dir_pos->lname.ofs = FAT_FILE_SHORT_NAME;
2016c78: c2 24 a0 0c st %g1, [ %l2 + 0xc ]
fat_dir_pos_init(dir_pos);
lfn_start.cln = lfn_start.ofs = FAT_FILE_SHORT_NAME;
2016c7c: c2 27 bf fc st %g1, [ %fp + -4 ]
2016c80: 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))
2016c84: 82 1f 60 01 xor %i5, 1, %g1
2016c88: 80 a0 00 01 cmp %g0, %g1
2016c8c: b4 60 3f ff subx %g0, -1, %i2
2016c90: 80 8e a0 ff btst 0xff, %i2
2016c94: 02 80 00 05 be 2016ca8 <msdos_find_name_in_fat_file+0x7c>
2016c98: c0 24 a0 04 clr [ %l2 + 4 ]
2016c9c: 80 a0 a0 00 cmp %g2, 0
2016ca0: 12 80 00 08 bne 2016cc0 <msdos_find_name_in_fat_file+0x94>
2016ca4: a6 10 20 00 clr %l3
lfn_entries = 0;
else
lfn_entries =
2016ca8: c4 27 bf d0 st %g2, [ %fp + -48 ]
2016cac: 90 07 20 0c add %i4, 0xc, %o0
2016cb0: 40 00 31 1c call 2023120 <.div>
2016cb4: 92 10 20 0d mov 0xd, %o1
2016cb8: c4 07 bf d0 ld [ %fp + -48 ], %g2
2016cbc: 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) &&
2016cc0: c2 06 60 20 ld [ %i1 + 0x20 ], %g1
2016cc4: 80 a0 60 01 cmp %g1, 1
2016cc8: 32 80 00 0b bne,a 2016cf4 <msdos_find_name_in_fat_file+0xc8>
2016ccc: e2 14 20 06 lduh [ %l0 + 6 ], %l1
2016cd0: c2 06 60 24 ld [ %i1 + 0x24 ], %g1
2016cd4: 80 a0 60 00 cmp %g1, 0
2016cd8: 32 80 00 07 bne,a 2016cf4 <msdos_find_name_in_fat_file+0xc8><== NEVER TAKEN
2016cdc: e2 14 20 06 lduh [ %l0 + 6 ], %l1 <== NOT EXECUTED
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))
2016ce0: 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) &&
2016ce4: 80 88 60 03 btst 3, %g1
2016ce8: 22 80 00 03 be,a 2016cf4 <msdos_find_name_in_fat_file+0xc8><== NEVER TAKEN
2016cec: e2 14 20 06 lduh [ %l0 + 6 ], %l1 <== NOT EXECUTED
2016cf0: 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 ||
2016cf4: 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))
2016cf8: 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),
2016cfc: 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;
2016d00: 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;
2016d04: 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;
2016d08: 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;
2016d0c: 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;
2016d10: 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;
2016d14: 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;
2016d18: 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;
2016d1c: 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 ||
2016d20: 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),
2016d24: 10 80 00 eb b 20170d0 <msdos_find_name_in_fat_file+0x4a4>
2016d28: 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)
2016d2c: 80 a2 20 1f cmp %o0, 0x1f
2016d30: 04 80 02 02 ble 2017538 <msdos_find_name_in_fat_file+0x90c><== NEVER TAKEN
2016d34: 80 a2 00 11 cmp %o0, %l1
rtems_set_errno_and_return_minus_one(EIO);
assert(ret == bts2rd);
2016d38: 22 80 00 0b be,a 2016d64 <msdos_find_name_in_fat_file+0x138><== ALWAYS TAKEN
2016d3c: ea 04 20 94 ld [ %l0 + 0x94 ], %l5
2016d40: 11 00 80 99 sethi %hi(0x2026400), %o0 <== NOT EXECUTED
2016d44: 15 00 80 99 sethi %hi(0x2026400), %o2 <== NOT EXECUTED
2016d48: 17 00 80 99 sethi %hi(0x2026400), %o3 <== NOT EXECUTED
2016d4c: 90 12 22 a0 or %o0, 0x2a0, %o0 <== NOT EXECUTED
2016d50: 92 10 23 f4 mov 0x3f4, %o1 <== NOT EXECUTED
2016d54: 94 12 a3 70 or %o2, 0x370, %o2 <== NOT EXECUTED
2016d58: 96 12 e3 40 or %o3, 0x340, %o3 <== NOT EXECUTED
2016d5c: 7f ff f0 9f call 2012fd8 <__assert_func> <== NOT EXECUTED
2016d60: 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;
2016d64: 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)
2016d68: 80 a6 20 00 cmp %i0, 0
2016d6c: 12 80 00 04 bne 2016d7c <msdos_find_name_in_fat_file+0x150>
2016d70: de 0d 40 00 ldub [ %l5 ], %o7
2016d74: ae 10 00 1a mov %i2, %l7
2016d78: ac 10 00 1b mov %i3, %l6
{
empty_space_entry = dir_entry;
empty_space_offset = dir_offset;
}
if (remainder_empty)
2016d7c: 98 8b e0 ff andcc %o7, 0xff, %o4
2016d80: 12 80 00 11 bne 2016dc4 <msdos_find_name_in_fat_file+0x198>
2016d84: 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)
2016d88: 80 a0 a0 00 cmp %g2, 0
2016d8c: 12 80 00 06 bne 2016da4 <msdos_find_name_in_fat_file+0x178>
2016d90: c4 0f bf e7 ldub [ %fp + -25 ], %g2
return MSDOS_NAME_NOT_FOUND_ERR;
2016d94: 31 00 00 1f sethi %hi(0x7c00), %i0
2016d98: b0 16 21 01 or %i0, 0x101, %i0 ! 7d01 <PROM_START+0x7d01>
2016d9c: 81 c7 e0 08 ret
2016da0: 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)
2016da4: 80 88 a0 ff btst 0xff, %g2
2016da8: 12 80 00 dc bne 2017118 <msdos_find_name_in_fat_file+0x4ec>
2016dac: 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;
2016db0: 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);
2016db4: b5 36 a0 05 srl %i2, 5, %i2
2016db8: 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 +=
2016dbc: 10 80 00 d7 b 2017118 <msdos_find_name_in_fat_file+0x4ec>
2016dc0: 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)
2016dc4: 12 80 00 0c bne 2016df4 <msdos_find_name_in_fat_file+0x1c8>
2016dc8: c2 0f bf e7 ldub [ %fp + -25 ], %g1
{
if (create_node)
2016dcc: 80 a0 a0 00 cmp %g2, 0
2016dd0: 22 80 00 bb be,a 20170bc <msdos_find_name_in_fat_file+0x490>
2016dd4: 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))
2016dd8: c2 07 bf d8 ld [ %fp + -40 ], %g1
if (create_node)
{
/*
* Remainder is not empty so is this entry empty ?
*/
empty_space_count++;
2016ddc: b0 06 20 01 inc %i0
if (empty_space_count == (lfn_entries + 1))
2016de0: 80 a6 00 01 cmp %i0, %g1
2016de4: 32 80 00 b6 bne,a 20170bc <msdos_find_name_in_fat_file+0x490>
2016de8: b4 06 a0 20 add %i2, 0x20, %i2
empty_space_found = true;
2016dec: 10 80 00 b2 b 20170b4 <msdos_find_name_in_fat_file+0x488>
2016df0: 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)
2016df4: 98 18 60 01 xor %g1, 1, %o4
2016df8: 80 8b 20 ff btst 0xff, %o4
2016dfc: 02 80 00 07 be 2016e18 <msdos_find_name_in_fat_file+0x1ec><== NEVER TAKEN
2016e00: d8 0d 60 0b ldub [ %l5 + 0xb ], %o4
2016e04: 80 a0 a0 00 cmp %g2, 0
2016e08: 02 80 00 04 be 2016e18 <msdos_find_name_in_fat_file+0x1ec>
2016e0c: 01 00 00 00 nop
{
empty_space_entry = 0;
empty_space_count = 0;
2016e10: 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;
2016e14: 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) ==
2016e18: 98 0b 20 3f and %o4, 0x3f, %o4
2016e1c: 80 a3 20 0f cmp %o4, 0xf
2016e20: 12 80 00 54 bne 2016f70 <msdos_find_name_in_fat_file+0x344>
2016e24: 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)
2016e28: d8 07 bf f8 ld [ %fp + -8 ], %o4
2016e2c: 80 a3 3f ff cmp %o4, -1
2016e30: 32 80 00 10 bne,a 2016e70 <msdos_find_name_in_fat_file+0x244>
2016e34: de 0d 40 00 ldub [ %l5 ], %o7
/*
* The first entry must have the last long entry
* flag set.
*/
if ((*MSDOS_DIR_ENTRY_TYPE(entry) &
2016e38: 98 0b e0 40 and %o7, 0x40, %o4
2016e3c: 80 8b 20 ff btst 0xff, %o4
2016e40: 02 80 00 9e be 20170b8 <msdos_find_name_in_fat_file+0x48c>
2016e44: 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) &
2016e48: 9e 0b e0 3f and %o7, 0x3f, %o7
2016e4c: 80 a4 c0 0f cmp %l3, %o7
2016e50: 32 80 00 9b bne,a 20170bc <msdos_find_name_in_fat_file+0x490>
2016e54: b4 06 a0 20 add %i2, 0x20, %i2
continue;
/*
* Get the checksum of the short entry.
*/
lfn_start.cln = dir_offset;
2016e58: f6 27 bf f8 st %i3, [ %fp + -8 ]
lfn_start.ofs = dir_entry;
2016e5c: f4 27 bf fc st %i2, [ %fp + -4 ]
lfn_entry = lfn_entries;
lfn_checksum = *MSDOS_DIR_LFN_CHECKSUM(entry);
2016e60: c6 0d 60 0d ldub [ %l5 + 0xd ], %g3
2016e64: c6 2f bf ef stb %g3, [ %fp + -17 ]
2016e68: 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) &
2016e6c: de 0d 40 00 ldub [ %l5 ], %o7
2016e70: 9e 0b e0 3f and %o7, 0x3f, %o7
2016e74: 80 a0 c0 0f cmp %g3, %o7
2016e78: 12 80 00 07 bne 2016e94 <msdos_find_name_in_fat_file+0x268><== NEVER TAKEN
2016e7c: 82 10 3f ff mov -1, %g1
MSDOS_LAST_LONG_ENTRY_MASK)) ||
2016e80: d8 0f bf ef ldub [ %fp + -17 ], %o4
2016e84: de 0d 60 0d ldub [ %l5 + 0xd ], %o7
2016e88: 80 a3 00 0f cmp %o4, %o7
2016e8c: 02 80 00 04 be 2016e9c <msdos_find_name_in_fat_file+0x270><== ALWAYS TAKEN
2016e90: 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;
2016e94: 10 80 00 89 b 20170b8 <msdos_find_name_in_fat_file+0x48c> <== NOT EXECUTED
2016e98: c2 27 bf f8 st %g1, [ %fp + -8 ] <== NOT EXECUTED
}
lfn_entry--;
o = lfn_entry * MSDOS_LFN_LEN_PER_ENTRY;
2016e9c: 9f 2b 20 02 sll %o4, 2, %o7
2016ea0: 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(
2016ea4: 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;
2016ea8: 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++)
2016eac: 9e 10 20 00 clr %o7
lfn_start.cln = FAT_FILE_SHORT_NAME;
continue;
}
lfn_entry--;
o = lfn_entry * MSDOS_LFN_LEN_PER_ENTRY;
2016eb0: 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')
2016eb4: d4 4b 40 00 ldsb [ %o5 ], %o2
2016eb8: 80 a2 a0 00 cmp %o2, 0
2016ebc: 12 80 00 0b bne 2016ee8 <msdos_find_name_in_fat_file+0x2bc>
2016ec0: 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) &&
2016ec4: 80 a0 c0 13 cmp %g3, %l3
2016ec8: 12 80 00 22 bne 2016f50 <msdos_find_name_in_fat_file+0x324><== NEVER TAKEN
2016ecc: 80 a3 20 00 cmp %o4, 0
((o + i) != name_len))
2016ed0: 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) &&
2016ed4: 80 a3 c0 1c cmp %o7, %i4
2016ed8: 02 80 00 1e be 2016f50 <msdos_find_name_in_fat_file+0x324><== ALWAYS TAKEN
2016edc: 80 a3 20 00 cmp %o4, 0
break;
}
if (((o + i) >= name_len) || (*p != name[o + i]))
{
lfn_start.cln = FAT_FILE_SHORT_NAME;
2016ee0: 10 80 00 0b b 2016f0c <msdos_find_name_in_fat_file+0x2e0> <== NOT EXECUTED
2016ee4: 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]))
2016ee8: 80 a2 40 1c cmp %o1, %i4
2016eec: 16 80 00 07 bge 2016f08 <msdos_find_name_in_fat_file+0x2dc>
2016ef0: 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(
2016ef4: 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]))
2016ef8: d2 4a 40 0f ldsb [ %o1 + %o7 ], %o1
2016efc: 80 a2 80 09 cmp %o2, %o1
2016f00: 02 80 00 05 be 2016f14 <msdos_find_name_in_fat_file+0x2e8>
2016f04: 80 a3 e0 04 cmp %o7, 4
{
lfn_start.cln = FAT_FILE_SHORT_NAME;
2016f08: 86 10 3f ff mov -1, %g3
break;
2016f0c: 10 80 00 10 b 2016f4c <msdos_find_name_in_fat_file+0x320>
2016f10: c6 27 bf f8 st %g3, [ %fp + -8 ]
}
switch (i)
2016f14: 02 80 00 06 be 2016f2c <msdos_find_name_in_fat_file+0x300>
2016f18: 80 a3 e0 0a cmp %o7, 0xa
2016f1c: 32 80 00 08 bne,a 2016f3c <msdos_find_name_in_fat_file+0x310>
2016f20: 9a 03 60 02 add %o5, 2, %o5
{
case 4:
p += 5;
break;
case 10:
p += 4;
2016f24: 10 80 00 04 b 2016f34 <msdos_find_name_in_fat_file+0x308>
2016f28: 9a 03 60 04 add %o5, 4, %o5
switch (i)
{
case 4:
p += 5;
break;
2016f2c: 10 80 00 04 b 2016f3c <msdos_find_name_in_fat_file+0x310>
2016f30: 9a 03 60 05 add %o5, 5, %o5
case 10:
p += 4;
break;
2016f34: 10 80 00 03 b 2016f40 <msdos_find_name_in_fat_file+0x314>
2016f38: 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++)
2016f3c: 9e 03 e0 01 inc %o7
2016f40: 80 a3 e0 0d cmp %o7, 0xd
2016f44: 32 bf ff dd bne,a 2016eb8 <msdos_find_name_in_fat_file+0x28c>
2016f48: d4 4b 40 00 ldsb [ %o5 ], %o2
p += 2;
break;
}
}
lfn_matched = ((lfn_entry == 0) &&
2016f4c: 80 a3 20 00 cmp %o4, 0
2016f50: 12 80 00 06 bne 2016f68 <msdos_find_name_in_fat_file+0x33c>
2016f54: 9a 10 20 00 clr %o5
2016f58: c6 07 bf f8 ld [ %fp + -8 ], %g3
2016f5c: 86 38 00 03 xnor %g0, %g3, %g3
2016f60: 80 a0 00 03 cmp %g0, %g3
2016f64: 9a 40 20 00 addx %g0, 0, %o5
#endif
lfn_start.cln = FAT_FILE_SHORT_NAME;
continue;
}
lfn_entry--;
2016f68: 10 80 00 54 b 20170b8 <msdos_find_name_in_fat_file+0x48c>
2016f6c: 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)
2016f70: 02 80 01 85 be 2017584 <msdos_find_name_in_fat_file+0x958>
2016f74: c2 07 bf dc ld [ %fp + -36 ], %g1
2016f78: 9a 10 20 00 clr %o5
2016f7c: 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;
2016f80: d6 0d 40 0d ldub [ %l5 + %o5 ], %o3
2016f84: 98 0b e0 01 and %o7, 1, %o4
2016f88: 80 a0 00 0c cmp %g0, %o4
2016f8c: 9e 0b e0 ff and %o7, 0xff, %o7
2016f90: 98 40 3f ff addx %g0, -1, %o4
2016f94: 9f 33 e0 01 srl %o7, 1, %o7
2016f98: 98 0b 20 80 and %o4, 0x80, %o4
2016f9c: 9e 02 c0 0f add %o3, %o7, %o7
2016fa0: 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++)
2016fa4: 9a 03 60 01 inc %o5
2016fa8: 80 a3 60 0b cmp %o5, 0xb
2016fac: 12 bf ff f5 bne 2016f80 <msdos_find_name_in_fat_file+0x354>
2016fb0: 9e 03 c0 0c add %o7, %o4, %o7
cs = ((cs & 1) ? 0x80 : 0) + (cs >> 1) + *p;
if (lfn_entry || (lfn_checksum != cs))
2016fb4: c2 0f bf ef ldub [ %fp + -17 ], %g1
2016fb8: 9e 1b c0 01 xor %o7, %g1, %o7
2016fbc: 80 8b e0 ff btst 0xff, %o7
2016fc0: 12 80 01 71 bne 2017584 <msdos_find_name_in_fat_file+0x958><== NEVER TAKEN
2016fc4: c2 07 bf dc ld [ %fp + -36 ], %g1
2016fc8: 80 a0 e0 00 cmp %g3, 0
2016fcc: 12 80 01 6f bne 2017588 <msdos_find_name_in_fat_file+0x95c><== NEVER TAKEN
2016fd0: 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,
2016fd4: 90 10 00 10 mov %l0, %o0
2016fd8: 92 10 00 19 mov %i1, %o1
2016fdc: 94 10 20 01 mov 1, %o2
2016fe0: 96 10 00 04 mov %g4, %o3
2016fe4: 7f ff e8 70 call 20111a4 <fat_file_ioctl>
2016fe8: 98 10 00 12 mov %l2, %o4
dir_offset * bts2rd,
&dir_pos->sname.cln);
if (rc != RC_OK)
2016fec: b0 92 20 00 orcc %o0, 0, %i0
2016ff0: 02 80 00 13 be 201703c <msdos_find_name_in_fat_file+0x410><== ALWAYS TAKEN
2016ff4: d2 07 bf f8 ld [ %fp + -8 ], %o1
2016ff8: 81 c7 e0 08 ret <== NOT EXECUTED
2016ffc: 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) &&
2017000: 80 a3 ff ff cmp %o7, -1
2017004: 12 80 00 29 bne 20170a8 <msdos_find_name_in_fat_file+0x47c><== NEVER TAKEN
2017008: 82 10 3f ff mov -1, %g1
(lfn_start.cln == FAT_FILE_SHORT_NAME) &&
(memcmp(MSDOS_DIR_NAME(entry),
201700c: c4 3f bf d0 std %g2, [ %fp + -48 ]
2017010: c8 27 bf cc st %g4, [ %fp + -52 ]
2017014: 90 10 00 15 mov %l5, %o0
2017018: 92 10 00 14 mov %l4, %o1
201701c: 40 00 0e 8c call 201aa4c <memcmp>
2017020: 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) &&
2017024: c4 1f bf d0 ldd [ %fp + -48 ], %g2
2017028: 80 a2 20 00 cmp %o0, 0
201702c: 12 80 00 1e bne 20170a4 <msdos_find_name_in_fat_file+0x478>
2017030: 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,
2017034: 10 bf ff e9 b 2016fd8 <msdos_find_name_in_fat_file+0x3ac>
2017038: 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)
201703c: 80 a2 7f ff cmp %o1, -1
2017040: 12 80 00 0c bne 2017070 <msdos_find_name_in_fat_file+0x444>
2017044: f4 24 a0 04 st %i2, [ %l2 + 4 ]
&lfn_start.cln);
if (rc != RC_OK)
return rc;
}
dir_pos->lname.cln = lfn_start.cln;
2017048: c2 07 bf f8 ld [ %fp + -8 ], %g1
dir_pos->lname.ofs = lfn_start.ofs;
memcpy(name_dir_entry, entry,
201704c: 90 10 00 14 mov %l4, %o0
&lfn_start.cln);
if (rc != RC_OK)
return rc;
}
dir_pos->lname.cln = lfn_start.cln;
2017050: c2 24 a0 08 st %g1, [ %l2 + 8 ]
dir_pos->lname.ofs = lfn_start.ofs;
2017054: c2 07 bf fc ld [ %fp + -4 ], %g1
memcpy(name_dir_entry, entry,
2017058: 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;
201705c: c2 24 a0 0c st %g1, [ %l2 + 0xc ]
memcpy(name_dir_entry, entry,
2017060: 40 00 0e a5 call 201aaf4 <memcpy>
2017064: 94 10 20 20 mov 0x20, %o2
2017068: 81 c7 e0 08 ret
201706c: 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,
2017070: 40 00 2f f0 call 2023030 <.umul>
2017074: 90 10 00 11 mov %l1, %o0
2017078: 92 10 00 19 mov %i1, %o1
201707c: 96 10 00 08 mov %o0, %o3
2017080: 94 10 20 01 mov 1, %o2
2017084: 90 10 00 10 mov %l0, %o0
2017088: 7f ff e8 47 call 20111a4 <fat_file_ioctl>
201708c: 98 07 bf f8 add %fp, -8, %o4
lfn_start.cln * bts2rd,
&lfn_start.cln);
if (rc != RC_OK)
2017090: 80 a2 20 00 cmp %o0, 0
2017094: 12 80 01 37 bne 2017570 <msdos_find_name_in_fat_file+0x944><== NEVER TAKEN
2017098: 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,
201709c: 10 bf ff ed b 2017050 <msdos_find_name_in_fat_file+0x424>
20170a0: 90 10 00 14 mov %l4, %o0
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
return RC_OK;
}
lfn_start.cln = FAT_FILE_SHORT_NAME;
20170a4: 82 10 3f ff mov -1, %g1
lfn_matched = false;
20170a8: 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;
20170ac: 10 80 00 03 b 20170b8 <msdos_find_name_in_fat_file+0x48c>
20170b0: 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;
20170b4: 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)
20170b8: 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;
20170bc: 80 a6 80 11 cmp %i2, %l1
20170c0: 0a bf ff 2a bcs 2016d68 <msdos_find_name_in_fat_file+0x13c><== ALWAYS TAKEN
20170c4: aa 05 60 20 add %l5, 0x20, %l5
}
if (remainder_empty)
break;
dir_offset++;
20170c8: b6 06 e0 01 inc %i3 <== NOT EXECUTED
20170cc: 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),
20170d0: d8 04 20 94 ld [ %l0 + 0x94 ], %o4
20170d4: 94 10 00 04 mov %g4, %o2
20170d8: c4 3f bf d0 std %g2, [ %fp + -48 ]
20170dc: c8 27 bf cc st %g4, [ %fp + -52 ]
20170e0: da 27 bf c4 st %o5, [ %fp + -60 ]
20170e4: 90 10 00 10 mov %l0, %o0
20170e8: 92 10 00 19 mov %i1, %o1
20170ec: 7f ff e7 4e call 2010e24 <fat_file_read>
20170f0: 96 10 00 11 mov %l1, %o3
20170f4: c4 1f bf d0 ldd [ %fp + -48 ], %g2
20170f8: 80 a2 20 00 cmp %o0, 0
20170fc: c8 07 bf cc ld [ %fp + -52 ], %g4
2017100: 12 bf ff 0b bne 2016d2c <msdos_find_name_in_fat_file+0x100><== ALWAYS TAKEN
2017104: da 07 bf c4 ld [ %fp + -60 ], %o5
}
/*
* If we are not to create the entry return a not found error.
*/
if (!create_node)
2017108: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED
201710c: 22 bf ff 23 be,a 2016d98 <msdos_find_name_in_fat_file+0x16c><== NOT EXECUTED
2017110: 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)
2017114: 80 a7 60 02 cmp %i5, 2 <== NOT EXECUTED
2017118: 12 80 00 2e bne 20171d0 <msdos_find_name_in_fat_file+0x5a4>
201711c: 80 a4 e0 00 cmp %l3, 0
{
int slot = (((empty_space_offset * bts2rd) + empty_space_entry) /
2017120: 90 10 00 16 mov %l6, %o0
2017124: 40 00 2f c3 call 2023030 <.umul>
2017128: 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 == '.'))
201712c: 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;
2017130: 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) /
2017134: 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 == '.'))
2017138: 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) /
201713c: 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 == '.'))
2017140: 02 80 00 05 be 2017154 <msdos_find_name_in_fat_file+0x528><== NEVER TAKEN
2017144: ba 07 40 08 add %i5, %o0, %i5
2017148: 80 a0 a0 20 cmp %g2, 0x20
201714c: 32 80 00 05 bne,a 2017160 <msdos_find_name_in_fat_file+0x534>
2017150: c4 4d 20 01 ldsb [ %l4 + 1 ], %g2
*c = '_';
2017154: 84 10 20 5f mov 0x5f, %g2
2017158: 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 == '.'))
201715c: c4 4d 20 01 ldsb [ %l4 + 1 ], %g2
2017160: 80 a0 a0 2e cmp %g2, 0x2e
2017164: 22 80 00 06 be,a 201717c <msdos_find_name_in_fat_file+0x550><== NEVER TAKEN
2017168: 84 10 20 5f mov 0x5f, %g2 <== NOT EXECUTED
201716c: 80 a0 a0 20 cmp %g2, 0x20
2017170: 12 80 00 05 bne 2017184 <msdos_find_name_in_fat_file+0x558>
2017174: 86 05 20 02 add %l4, 2, %g3
*c = '_';
2017178: 84 10 20 5f mov 0x5f, %g2
201717c: 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++)
2017180: 86 05 20 02 add %l4, 2, %g3
2017184: 84 10 20 00 clr %g2
if ((*c == ' ') || (*c == '.'))
*c = '_';
for (i = 0; i < 4; i++, c++)
*c = hex[(num >> ((3 - i) * 4)) & 0xf];
2017188: 35 00 80 97 sethi %hi(0x2025c00), %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(
201718c: 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];
2017190: b8 16 a2 78 or %i2, 0x278, %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(
2017194: 89 29 20 02 sll %g4, 2, %g4
2017198: 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];
201719c: 89 3f 40 04 sra %i5, %g4, %g4
20171a0: 88 09 20 0f and %g4, 0xf, %g4
20171a4: c8 0f 00 04 ldub [ %i4 + %g4 ], %g4
20171a8: 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++)
20171ac: 84 00 a0 01 inc %g2
20171b0: 80 a0 a0 04 cmp %g2, 4
20171b4: 12 bf ff f8 bne 2017194 <msdos_find_name_in_fat_file+0x568>
20171b8: 88 20 00 02 neg %g2, %g4
*c = hex[(num >> ((3 - i) * 4)) & 0xf];
*c++ = '~';
20171bc: 84 10 20 7e mov 0x7e, %g2
20171c0: c4 2d 20 06 stb %g2, [ %l4 + 6 ]
*c++ = '1';
20171c4: 84 10 20 31 mov 0x31, %g2
20171c8: 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)
20171cc: 80 a4 e0 00 cmp %l3, 0
20171d0: 02 80 00 10 be 2017210 <msdos_find_name_in_fat_file+0x5e4>
20171d4: b8 10 20 00 clr %i4
20171d8: 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 =
20171dc: c8 0d 00 02 ldub [ %l4 + %g2 ], %g4
20171e0: 86 0f 20 01 and %i4, 1, %g3
20171e4: 80 a0 00 03 cmp %g0, %g3
20171e8: b8 0f 20 ff and %i4, 0xff, %i4
20171ec: 86 40 3f ff addx %g0, -1, %g3
20171f0: b9 37 20 01 srl %i4, 1, %i4
20171f4: 86 08 e0 80 and %g3, 0x80, %g3
20171f8: b8 01 00 1c add %g4, %i4, %i4
20171fc: 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++)
2017200: 84 00 a0 01 inc %g2
2017204: 80 a0 a0 0b cmp %g2, 0xb
2017208: 12 bf ff f5 bne 20171dc <msdos_find_name_in_fat_file+0x5b0>
201720c: 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)
2017210: 80 a6 20 00 cmp %i0, 0
2017214: 22 80 00 06 be,a 201722c <msdos_find_name_in_fat_file+0x600><== NEVER TAKEN
2017218: 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;
201721c: 82 1e c0 16 xor %i3, %l6, %g1
2017220: 80 a0 00 01 cmp %g0, %g1
2017224: 10 80 00 04 b 2017234 <msdos_find_name_in_fat_file+0x608>
2017228: 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;
201722c: b4 10 20 01 mov 1, %i2 <== NOT EXECUTED
empty_space_offset = dir_offset;
empty_space_entry = 0;
2017230: 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;
2017234: 84 10 3f ff mov -1, %g2
2017238: 90 10 00 16 mov %l6, %o0
201723c: c4 27 bf fc st %g2, [ %fp + -4 ]
2017240: c4 27 bf f8 st %g2, [ %fp + -8 ]
2017244: 40 00 2f 7b call 2023030 <.umul>
2017248: 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(
201724c: c6 07 a0 50 ld [ %fp + 0x50 ], %g3
2017250: 83 2c e0 02 sll %l3, 2, %g1
2017254: 85 2c e0 04 sll %l3, 4, %g2
2017258: 82 20 80 01 sub %g2, %g1, %g1
201725c: 82 00 40 13 add %g1, %l3, %g1
2017260: 82 00 c0 01 add %g3, %g1, %g1
2017264: ba 10 00 08 mov %o0, %i5
2017268: 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;
201726c: b0 10 20 00 clr %i0
length, lfn_entry);
#endif
/*
* Time to write the short file name entry.
*/
if (lfn_entry == (lfn_entries + 1))
2017270: 82 04 e0 01 add %l3, 1, %g1
#endif
/*
* The one more is the short entry.
*/
while (lfn_entry < (lfn_entries + 1))
2017274: 10 80 00 ba b 201755c <msdos_find_name_in_fat_file+0x930>
2017278: c2 27 bf ec st %g1, [ %fp + -20 ]
{
int length = 0;
if (read_cluster)
201727c: 02 80 00 2f be 2017338 <msdos_find_name_in_fat_file+0x70c><== ALWAYS TAKEN
2017280: 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,
2017284: d8 04 20 94 ld [ %l0 + 0x94 ], %o4 <== NOT EXECUTED
2017288: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
201728c: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
2017290: 94 10 00 1d mov %i5, %o2 <== NOT EXECUTED
2017294: 7f ff e6 e4 call 2010e24 <fat_file_read> <== NOT EXECUTED
2017298: 96 10 00 11 mov %l1, %o3 <== NOT EXECUTED
(empty_space_offset * bts2rd), bts2rd,
fs_info->cl_buf);
if (ret != bts2rd)
201729c: 80 a2 00 11 cmp %o0, %l1 <== NOT EXECUTED
20172a0: 02 80 00 25 be 2017334 <msdos_find_name_in_fat_file+0x708><== NOT EXECUTED
20172a4: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
{
if (ret != FAT_EOF)
20172a8: 22 80 00 03 be,a 20172b4 <msdos_find_name_in_fat_file+0x688><== NOT EXECUTED
20172ac: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
20172b0: 30 80 00 1b b,a 201731c <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,
20172b4: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
20172b8: 94 10 20 00 clr %o2 <== NOT EXECUTED
20172bc: 96 10 00 1d mov %i5, %o3 <== NOT EXECUTED
20172c0: 7f ff e7 ed call 2011274 <fat_file_extend> <== NOT EXECUTED
20172c4: 98 07 bf f4 add %fp, -12, %o4 <== NOT EXECUTED
empty_space_offset * bts2rd, &new_length);
if (ret != RC_OK)
20172c8: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
20172cc: 12 80 00 a9 bne 2017570 <msdos_find_name_in_fat_file+0x944><== NOT EXECUTED
20172d0: 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))
20172d4: 80 a0 40 1d cmp %g1, %i5 <== NOT EXECUTED
20172d8: 22 80 00 03 be,a 20172e4 <msdos_find_name_in_fat_file+0x6b8><== NOT EXECUTED
20172dc: d0 04 20 94 ld [ %l0 + 0x94 ], %o0 <== NOT EXECUTED
20172e0: 30 80 00 0f b,a 201731c <msdos_find_name_in_fat_file+0x6f0><== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
memset(fs_info->cl_buf, 0, bts2rd);
20172e4: 92 10 20 00 clr %o1 <== NOT EXECUTED
20172e8: 40 00 0e 40 call 201abe8 <memset> <== NOT EXECUTED
20172ec: 94 10 00 11 mov %l1, %o2 <== NOT EXECUTED
ret = fat_file_write(&fs_info->fat, fat_fd,
20172f0: d8 04 20 94 ld [ %l0 + 0x94 ], %o4 <== NOT EXECUTED
20172f4: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
20172f8: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
20172fc: 94 10 00 1d mov %i5, %o2 <== NOT EXECUTED
2017300: 7f ff e8 78 call 20114e0 <fat_file_write> <== NOT EXECUTED
2017304: 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)
2017308: 80 a2 3f ff cmp %o0, -1 <== NOT EXECUTED
201730c: 02 80 00 99 be 2017570 <msdos_find_name_in_fat_file+0x944><== NOT EXECUTED
2017310: 80 a2 00 11 cmp %o0, %l1 <== NOT EXECUTED
return ret;
else if (ret != bts2rd)
2017314: 02 80 00 09 be 2017338 <msdos_find_name_in_fat_file+0x70c><== NOT EXECUTED
2017318: c6 07 bf e4 ld [ %fp + -28 ], %g3 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
201731c: 40 00 0b 41 call 201a020 <__errno> <== NOT EXECUTED
2017320: 01 00 00 00 nop <== NOT EXECUTED
2017324: 82 10 20 05 mov 5, %g1 ! 5 <PROM_START+0x5> <== NOT EXECUTED
2017328: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
201732c: 10 80 00 91 b 2017570 <msdos_find_name_in_fat_file+0x944> <== NOT EXECUTED
2017330: 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(
2017334: c6 07 bf e4 ld [ %fp + -28 ], %g3 <== NOT EXECUTED
2017338: 83 2e 20 02 sll %i0, 2, %g1
201733c: 97 2e 20 04 sll %i0, 4, %o3
2017340: 84 06 20 01 add %i0, 1, %g2
2017344: 96 22 c0 01 sub %o3, %g1, %o3
2017348: 9a 10 20 00 clr %o5
201734c: 96 02 c0 18 add %o3, %i0, %o3
2017350: b4 10 20 00 clr %i2
2017354: 96 20 c0 0b sub %g3, %o3, %o3
2017358: 10 80 00 68 b 20174f8 <msdos_find_name_in_fat_file+0x8cc>
201735c: 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;
2017360: 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))
2017364: 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;
2017368: aa 03 00 1b add %o4, %i3, %l5
char* p;
const char* n;
int i;
char fill = 0;
length += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE;
201736c: 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))
2017370: 80 a0 80 01 cmp %g2, %g1
2017374: 12 80 00 25 bne 2017408 <msdos_find_name_in_fat_file+0x7dc>
2017378: b0 10 00 02 mov %g2, %i0
{
/* get current cluster number */
int rc = fat_file_ioctl(&fs_info->fat, fat_fd, F_CLU_NUM,
201737c: 90 10 00 10 mov %l0, %o0
2017380: 92 10 00 19 mov %i1, %o1
2017384: 94 10 20 01 mov 1, %o2
2017388: 96 10 00 1d mov %i5, %o3
201738c: 7f ff e7 86 call 20111a4 <fat_file_ioctl>
2017390: 98 10 00 12 mov %l2, %o4
empty_space_offset * bts2rd,
&dir_pos->sname.cln);
if (rc != RC_OK)
2017394: 80 a2 20 00 cmp %o0, 0
2017398: 12 80 00 76 bne 2017570 <msdos_find_name_in_fat_file+0x944><== NEVER TAKEN
201739c: d2 07 bf f8 ld [ %fp + -8 ], %o1
return rc;
dir_pos->sname.ofs = dir_entry;
if (lfn_start.cln != FAT_FILE_SHORT_NAME)
20173a0: 80 a2 7f ff cmp %o1, -1
20173a4: 12 80 00 0c bne 20173d4 <msdos_find_name_in_fat_file+0x7a8>
20173a8: f6 24 a0 04 st %i3, [ %l2 + 4 ]
&lfn_start.cln);
if (rc != RC_OK)
return rc;
}
dir_pos->lname.cln = lfn_start.cln;
20173ac: 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,
20173b0: 90 10 00 15 mov %l5, %o0
&lfn_start.cln);
if (rc != RC_OK)
return rc;
}
dir_pos->lname.cln = lfn_start.cln;
20173b4: c2 24 a0 08 st %g1, [ %l2 + 8 ]
dir_pos->lname.ofs = lfn_start.ofs;
20173b8: c2 07 bf fc ld [ %fp + -4 ], %g1
/* write new node entry */
memcpy (entry, (uint8_t *) name_dir_entry,
20173bc: 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;
20173c0: c2 24 a0 0c st %g1, [ %l2 + 0xc ]
/* write new node entry */
memcpy (entry, (uint8_t *) name_dir_entry,
20173c4: 40 00 0d cc call 201aaf4 <memcpy>
20173c8: 94 10 20 20 mov 0x20, %o2
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
break;
20173cc: 10 80 00 50 b 201750c <msdos_find_name_in_fat_file+0x8e0>
20173d0: 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,
20173d4: 40 00 2f 17 call 2023030 <.umul>
20173d8: 90 10 00 11 mov %l1, %o0
20173dc: 92 10 00 19 mov %i1, %o1
20173e0: 96 10 00 08 mov %o0, %o3
20173e4: 94 10 20 01 mov 1, %o2
20173e8: 90 10 00 10 mov %l0, %o0
20173ec: 7f ff e7 6e call 20111a4 <fat_file_ioctl>
20173f0: 98 07 bf f8 add %fp, -8, %o4
lfn_start.cln * bts2rd,
&lfn_start.cln);
if (rc != RC_OK)
20173f4: 80 a2 20 00 cmp %o0, 0
20173f8: 02 bf ff ee be 20173b0 <msdos_find_name_in_fat_file+0x784><== ALWAYS TAKEN
20173fc: 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,
2017400: 81 c7 e0 08 ret <== NOT EXECUTED
2017404: 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)
2017408: c2 07 bf f8 ld [ %fp + -8 ], %g1
201740c: 80 a0 7f ff cmp %g1, -1
2017410: 32 80 00 05 bne,a 2017424 <msdos_find_name_in_fat_file+0x7f8>
2017414: d8 3f bf c0 std %o4, [ %fp + -64 ]
{
lfn_start.cln = empty_space_offset;
2017418: ec 27 bf f8 st %l6, [ %fp + -8 ]
lfn_start.ofs = dir_entry;
201741c: f6 27 bf fc st %i3, [ %fp + -4 ]
}
/*
* Clear the entry before loading the data.
*/
memset (entry, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
2017420: d8 3f bf c0 std %o4, [ %fp + -64 ]
2017424: 94 10 20 20 mov 0x20, %o2
2017428: c4 27 bf d0 st %g2, [ %fp + -48 ]
201742c: d6 27 bf c8 st %o3, [ %fp + -56 ]
2017430: 90 10 00 15 mov %l5, %o0
2017434: 40 00 0d ed call 201abe8 <memset>
2017438: 92 10 20 00 clr %o1
*MSDOS_DIR_LFN_CHECKSUM(entry) = lfn_checksum;
201743c: 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(
2017440: d6 07 bf c8 ld [ %fp + -56 ], %o3
2017444: 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++)
2017448: d8 07 bf c0 ld [ %fp + -64 ], %o4
201744c: 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;
2017450: 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(
2017454: 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;
2017458: 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++)
201745c: b0 10 20 00 clr %i0
{
if (*n != 0)
2017460: d0 4b c0 00 ldsb [ %o7 ], %o0
2017464: 80 a2 20 00 cmp %o0, 0
2017468: 02 80 00 05 be 201747c <msdos_find_name_in_fat_file+0x850>
201746c: d2 0b c0 00 ldub [ %o7 ], %o1
{
*p = *n;
2017470: d2 28 40 00 stb %o1, [ %g1 ]
n++;
2017474: 10 80 00 05 b 2017488 <msdos_find_name_in_fat_file+0x85c>
2017478: 9e 03 e0 01 inc %o7
}
else
{
p [0] = fill;
201747c: d4 28 40 00 stb %o2, [ %g1 ]
p [1] = fill;
2017480: d4 28 60 01 stb %o2, [ %g1 + 1 ]
fill = 0xff;
2017484: 94 10 3f ff mov -1, %o2
}
switch (i)
2017488: 80 a6 20 04 cmp %i0, 4
201748c: 02 80 00 06 be 20174a4 <msdos_find_name_in_fat_file+0x878>
2017490: 80 a6 20 0a cmp %i0, 0xa
2017494: 32 80 00 08 bne,a 20174b4 <msdos_find_name_in_fat_file+0x888>
2017498: 82 00 60 02 add %g1, 2, %g1
{
case 4:
p += 5;
break;
case 10:
p += 4;
201749c: 10 80 00 04 b 20174ac <msdos_find_name_in_fat_file+0x880>
20174a0: 82 00 60 04 add %g1, 4, %g1
switch (i)
{
case 4:
p += 5;
break;
20174a4: 10 80 00 04 b 20174b4 <msdos_find_name_in_fat_file+0x888>
20174a8: 82 00 60 05 add %g1, 5, %g1
case 10:
p += 4;
break;
20174ac: 10 80 00 03 b 20174b8 <msdos_find_name_in_fat_file+0x88c>
20174b0: 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++)
20174b4: b0 06 20 01 inc %i0
20174b8: 80 a6 20 0d cmp %i0, 0xd
20174bc: 32 bf ff ea bne,a 2017464 <msdos_find_name_in_fat_file+0x838>
20174c0: 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(
20174c4: c6 07 bf ec ld [ %fp + -20 ], %g3
break;
}
}
*MSDOS_DIR_ENTRY_TYPE(entry) = (lfn_entries - lfn_entry) + 1;
if (lfn_entry == 1)
20174c8: 80 a0 a0 01 cmp %g2, 1
20174cc: 02 80 00 04 be 20174dc <msdos_find_name_in_fat_file+0x8b0>
20174d0: 82 20 c0 02 sub %g3, %g2, %g1
*MSDOS_DIR_ENTRY_TYPE(entry) |= MSDOS_LAST_LONG_ENTRY;
20174d4: 10 80 00 04 b 20174e4 <msdos_find_name_in_fat_file+0x8b8>
20174d8: c2 2b 00 1b stb %g1, [ %o4 + %i3 ]
20174dc: 82 10 60 40 or %g1, 0x40, %g1
20174e0: c2 2b 00 1b stb %g1, [ %o4 + %i3 ]
*MSDOS_DIR_ATTR(entry) |= MSDOS_ATTR_LFN;
20174e4: c2 0d 60 0b ldub [ %l5 + 0xb ], %g1
20174e8: 84 00 a0 01 inc %g2
20174ec: 82 10 60 0f or %g1, 0xf, %g1
20174f0: 9a 03 7f f3 add %o5, -13, %o5
20174f4: 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(
20174f8: 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;
20174fc: 80 a6 c0 11 cmp %i3, %l1
2017500: 0a bf ff 98 bcs 2017360 <msdos_find_name_in_fat_file+0x734><== ALWAYS TAKEN
2017504: 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,
2017508: d8 04 20 94 ld [ %l0 + 0x94 ], %o4 <== NOT EXECUTED
201750c: 90 10 00 10 mov %l0, %o0
2017510: 92 10 00 19 mov %i1, %o1
2017514: 94 07 40 17 add %i5, %l7, %o2
2017518: 96 10 00 1a mov %i2, %o3
201751c: 7f ff e7 f1 call 20114e0 <fat_file_write>
2017520: 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)
2017524: 80 a2 3f ff cmp %o0, -1
2017528: 02 80 00 14 be 2017578 <msdos_find_name_in_fat_file+0x94c><== NEVER TAKEN
201752c: 80 a2 00 1a cmp %o0, %i2
return ret;
else if (ret != length)
2017530: 02 80 00 08 be 2017550 <msdos_find_name_in_fat_file+0x924><== ALWAYS TAKEN
2017534: ba 07 40 11 add %i5, %l1, %i5
rtems_set_errno_and_return_minus_one(EIO);
2017538: 40 00 0a ba call 201a020 <__errno> <== NOT EXECUTED
201753c: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
2017540: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
2017544: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
2017548: 81 c7 e0 08 ret <== NOT EXECUTED
201754c: 81 e8 00 00 restore <== NOT EXECUTED
empty_space_offset++;
2017550: ac 05 a0 01 inc %l6
empty_space_entry = 0;
2017554: ae 10 20 00 clr %l7
read_cluster = true;
2017558: b4 10 20 01 mov 1, %i2
#endif
/*
* The one more is the short entry.
*/
while (lfn_entry < (lfn_entries + 1))
201755c: 80 a4 c0 18 cmp %l3, %i0
2017560: 16 bf ff 47 bge 201727c <msdos_find_name_in_fat_file+0x650>
2017564: 80 8e a0 ff btst 0xff, %i2
empty_space_offset++;
empty_space_entry = 0;
read_cluster = true;
}
return 0;
2017568: 81 c7 e0 08 ret
201756c: 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,
2017570: 81 c7 e0 08 ret <== NOT EXECUTED
2017574: 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)
2017578: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
201757c: 81 c7 e0 08 ret <== NOT EXECUTED
2017580: 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 ||
2017584: 80 a0 60 00 cmp %g1, 0
2017588: 02 bf fe c8 be 20170a8 <msdos_find_name_in_fat_file+0x47c>
201758c: 82 10 3f ff mov -1, %g1
((name_type == MSDOS_NAME_SHORT) &&
2017590: 10 bf fe 9c b 2017000 <msdos_find_name_in_fat_file+0x3d4>
2017594: de 07 bf f8 ld [ %fp + -8 ], %o7
02017598 <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
)
{
2017598: 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) &&
201759c: c2 06 60 20 ld [ %i1 + 0x20 ], %g1
20175a0: 80 a0 60 01 cmp %g1, 1
20175a4: 12 80 00 0f bne 20175e0 <msdos_find_node_by_cluster_num_in_fat_file+0x48><== ALWAYS TAKEN
20175a8: fa 06 20 08 ld [ %i0 + 8 ], %i5
20175ac: c2 06 60 24 ld [ %i1 + 0x24 ], %g1 <== NOT EXECUTED
20175b0: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
20175b4: 32 80 00 07 bne,a 20175d0 <msdos_find_node_by_cluster_num_in_fat_file+0x38><== NOT EXECUTED
20175b8: f0 17 60 06 lduh [ %i5 + 6 ], %i0 <== NOT EXECUTED
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))
20175bc: 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) &&
20175c0: 80 88 60 03 btst 3, %g1 <== NOT EXECUTED
20175c4: 22 80 00 03 be,a 20175d0 <msdos_find_node_by_cluster_num_in_fat_file+0x38><== NOT EXECUTED
20175c8: 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;
20175cc: 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)
20175d0: 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;
20175d4: 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)
20175d8: 10 80 00 44 b 20176e8 <msdos_find_node_by_cluster_num_in_fat_file+0x150>
20175dc: 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;
20175e0: 10 bf ff fc b 20175d0 <msdos_find_node_by_cluster_num_in_fat_file+0x38>
20175e4: 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 )
20175e8: 14 80 00 08 bg 2017608 <msdos_find_node_by_cluster_num_in_fat_file+0x70><== ALWAYS TAKEN
20175ec: 80 a2 00 18 cmp %o0, %i0
rtems_set_errno_and_return_minus_one( EIO );
20175f0: 40 00 0a 8c call 201a020 <__errno> <== NOT EXECUTED
20175f4: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
20175f8: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
20175fc: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
2017600: 81 c7 e0 08 ret <== NOT EXECUTED
2017604: 81 e8 00 00 restore <== NOT EXECUTED
assert(ret == bts2rd);
2017608: 22 80 00 0a be,a 2017630 <msdos_find_node_by_cluster_num_in_fat_file+0x98><== ALWAYS TAKEN
201760c: e0 07 60 94 ld [ %i5 + 0x94 ], %l0
2017610: 11 00 80 99 sethi %hi(0x2026400), %o0 <== NOT EXECUTED
2017614: 15 00 80 99 sethi %hi(0x2026400), %o2 <== NOT EXECUTED
2017618: 17 00 80 99 sethi %hi(0x2026400), %o3 <== NOT EXECUTED
201761c: 90 12 22 a0 or %o0, 0x2a0, %o0 <== NOT EXECUTED
2017620: 92 10 26 49 mov 0x649, %o1 <== NOT EXECUTED
2017624: 94 12 a3 90 or %o2, 0x390, %o2 <== NOT EXECUTED
2017628: 7f ff ee 6c call 2012fd8 <__assert_func> <== NOT EXECUTED
201762c: 96 12 e3 40 or %o3, 0x340, %o3 <== NOT EXECUTED
for (i = 0; i < bts2rd; i += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
{
char* entry = (char*) fs_info->cl_buf + i;
2017630: a4 10 20 00 clr %l2
/* if this and all rest entries are empty - return not-found */
if ((*MSDOS_DIR_ENTRY_TYPE(entry)) ==
2017634: c2 0c 00 00 ldub [ %l0 ], %g1
2017638: 80 a0 60 00 cmp %g1, 0
201763c: 02 80 00 34 be 201770c <msdos_find_node_by_cluster_num_in_fat_file+0x174><== NEVER TAKEN
2017640: 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)) ==
2017644: 22 80 00 25 be,a 20176d8 <msdos_find_node_by_cluster_num_in_fat_file+0x140><== NEVER TAKEN
2017648: 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)
201764c: c4 14 20 14 lduh [ %l0 + 0x14 ], %g2
2017650: c2 14 20 1a lduh [ %l0 + 0x1a ], %g1
2017654: 85 28 a0 10 sll %g2, 0x10, %g2
2017658: 87 30 a0 18 srl %g2, 0x18, %g3
201765c: 83 28 60 10 sll %g1, 0x10, %g1
2017660: 85 30 a0 08 srl %g2, 8, %g2
2017664: 84 08 80 13 and %g2, %l3, %g2
2017668: 84 10 c0 02 or %g3, %g2, %g2
201766c: 87 30 60 18 srl %g1, 0x18, %g3
2017670: 85 28 a0 10 sll %g2, 0x10, %g2
2017674: 83 30 60 08 srl %g1, 8, %g1
2017678: 82 08 40 13 and %g1, %l3, %g1
201767c: 82 10 c0 01 or %g3, %g1, %g1
2017680: 82 10 80 01 or %g2, %g1, %g1
2017684: 80 a0 40 1a cmp %g1, %i2
2017688: 32 80 00 14 bne,a 20176d8 <msdos_find_node_by_cluster_num_in_fat_file+0x140>
201768c: 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,
2017690: 90 10 00 1d mov %i5, %o0
2017694: 92 10 00 19 mov %i1, %o1
2017698: 94 10 20 01 mov 1, %o2
201769c: 96 10 00 11 mov %l1, %o3
20176a0: 7f ff e6 c1 call 20111a4 <fat_file_ioctl>
20176a4: 98 10 00 1b mov %i3, %o4
&dir_pos->sname.cln);
if (rc != RC_OK)
20176a8: b0 92 20 00 orcc %o0, 0, %i0
20176ac: 12 bf ff d5 bne 2017600 <msdos_find_node_by_cluster_num_in_fat_file+0x68><== NEVER TAKEN
20176b0: 82 10 3f ff mov -1, %g1
return rc;
dir_pos->sname.ofs = i;
20176b4: e4 26 e0 04 st %l2, [ %i3 + 4 ]
dir_pos->lname.cln = FAT_FILE_SHORT_NAME;
20176b8: c2 26 e0 08 st %g1, [ %i3 + 8 ]
dir_pos->lname.ofs = FAT_FILE_SHORT_NAME;
20176bc: c2 26 e0 0c st %g1, [ %i3 + 0xc ]
memcpy(dir_entry, entry,
20176c0: 90 10 00 1c mov %i4, %o0
20176c4: 92 10 00 10 mov %l0, %o1
20176c8: 40 00 0d 0b call 201aaf4 <memcpy>
20176cc: 94 10 20 20 mov 0x20, %o2
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
return RC_OK;
20176d0: 81 c7 e0 08 ret
20176d4: 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)
20176d8: 80 a4 80 18 cmp %l2, %i0
20176dc: 0a bf ff d6 bcs 2017634 <msdos_find_node_by_cluster_num_in_fat_file+0x9c><== ALWAYS TAKEN
20176e0: a0 04 20 20 add %l0, 0x20, %l0
20176e4: 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,
20176e8: d8 07 60 94 ld [ %i5 + 0x94 ], %o4
20176ec: 90 10 00 1d mov %i5, %o0
20176f0: 92 10 00 19 mov %i1, %o1
20176f4: 94 10 00 11 mov %l1, %o2
20176f8: 7f ff e5 cb call 2010e24 <fat_file_read>
20176fc: 96 10 00 18 mov %i0, %o3
2017700: 80 a2 20 00 cmp %o0, 0
2017704: 12 bf ff b9 bne 20175e8 <msdos_find_node_by_cluster_num_in_fat_file+0x50><== ALWAYS TAKEN
2017708: 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;
201770c: 31 00 00 1f sethi %hi(0x7c00), %i0 <== NOT EXECUTED
2017710: b0 16 21 01 or %i0, 0x101, %i0 ! 7d01 <PROM_START+0x7d01> <== NOT EXECUTED
}
}
j++;
}
return MSDOS_NAME_NOT_FOUND_ERR;
}
2017714: 81 c7 e0 08 ret <== NOT EXECUTED
2017718: 81 e8 00 00 restore <== NOT EXECUTED
0200cc44 <msdos_format>:
)
/*-------------------------------------------------------------------------*\
| Return Value: |
| 0, if success, -1 and errno if failed |
\*=========================================================================*/
{
200cc44: 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");
200cc48: 92 10 20 02 mov 2, %o1
200cc4c: 90 10 00 19 mov %i1, %o0
200cc50: 15 00 80 98 sethi %hi(0x2026000), %o2
200cc54: 7f ff ff 84 call 200ca64 <msdos_format_printf>
200cc58: 94 12 a0 78 or %o2, 0x78, %o2 ! 2026078 <_CPU_Trap_slot_template+0x68>
fd = open(devname, O_RDWR);
200cc5c: 92 10 20 02 mov 2, %o1
200cc60: 7f ff e2 3b call 200554c <open>
200cc64: 90 10 00 18 mov %i0, %o0
\*=========================================================================*/
{
char tmp_sec[FAT_TOTAL_MBR_SIZE];
int rc;
struct stat stat_buf;
int ret_val = 0;
200cc68: 82 38 00 08 xnor %g0, %o0, %g1
200cc6c: 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);
200cc70: b4 10 00 08 mov %o0, %i2
\*=========================================================================*/
{
char tmp_sec[FAT_TOTAL_MBR_SIZE];
int rc;
struct stat stat_buf;
int ret_val = 0;
200cc74: ba 40 3f ff addx %g0, -1, %i5
}
/*
* sanity check on device
*/
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
200cc78: 90 10 00 19 mov %i1, %o0
200cc7c: 92 10 20 02 mov 2, %o1
200cc80: 15 00 80 98 sethi %hi(0x2026000), %o2
200cc84: 96 10 00 18 mov %i0, %o3
200cc88: 7f ff ff 77 call 200ca64 <msdos_format_printf>
200cc8c: 94 12 a0 88 or %o2, 0x88, %o2
"stat check: %s\n", devname);
if (ret_val == 0) {
200cc90: 80 a7 60 00 cmp %i5, 0
200cc94: 12 80 00 06 bne 200ccac <msdos_format+0x68> <== NEVER TAKEN
200cc98: b6 10 3f ff mov -1, %i3
rc = fstat(fd, &stat_buf);
200cc9c: 90 10 00 1a mov %i2, %o0
200cca0: 40 00 19 5f call 201321c <fstat>
200cca4: 92 07 bd 68 add %fp, -664, %o1
200cca8: b6 10 00 08 mov %o0, %i3
ret_val = rc;
}
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_INFO,
200ccac: 90 10 00 19 mov %i1, %o0
200ccb0: 92 10 20 01 mov 1, %o1
200ccb4: 15 00 80 98 sethi %hi(0x2026000), %o2
200ccb8: 96 10 00 18 mov %i0, %o3
200ccbc: 7f ff ff 6a call 200ca64 <msdos_format_printf>
200ccc0: 94 12 a0 98 or %o2, 0x98, %o2
"formating: %s\n", devname);
/* rtems feature: no block devices, all are character devices */
if ((ret_val == 0) && (!S_ISBLK(stat_buf.st_mode))) {
200ccc4: 80 a6 e0 00 cmp %i3, 0
200ccc8: 12 80 01 9b bne 200d334 <msdos_format+0x6f0> <== NEVER TAKEN
200cccc: c4 07 bd 74 ld [ %fp + -652 ], %g2
200ccd0: 03 00 00 3c sethi %hi(0xf000), %g1
200ccd4: 84 08 80 01 and %g2, %g1, %g2
200ccd8: 03 00 00 18 sethi %hi(0x6000), %g1
200ccdc: 80 a0 80 01 cmp %g2, %g1
200cce0: 02 80 02 f4 be 200d8b0 <msdos_format+0xc6c> <== ALWAYS TAKEN
200cce4: 92 10 20 00 clr %o1
errno = ENOTTY;
200cce8: 40 00 34 ce call 201a020 <__errno> <== NOT EXECUTED
200ccec: b6 10 3f ff mov -1, %i3 <== NOT EXECUTED
200ccf0: 82 10 20 19 mov 0x19, %g1 <== NOT EXECUTED
200ccf4: 10 80 03 15 b 200d948 <msdos_format+0xd04> <== NOT EXECUTED
200ccf8: 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);
200ccfc: 92 17 62 05 or %i5, 0x205, %o1
200cd00: 7f ff de b0 call 20047c0 <ioctl>
200cd04: 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) {
200cd08: b0 92 20 00 orcc %o0, 0, %i0
200cd0c: 12 80 01 2e bne 200d1c4 <msdos_format+0x580> <== NEVER TAKEN
200cd10: e2 07 bd b0 ld [ %fp + -592 ], %l1
total_size = fmt_params->bytes_per_sector * fmt_params->totl_sector_cnt;
200cd14: e0 07 bd b4 ld [ %fp + -588 ], %l0
200cd18: 92 10 00 11 mov %l1, %o1
200cd1c: 40 00 58 c5 call 2023030 <.umul>
200cd20: 90 10 00 10 mov %l0, %o0
200cd24: b8 10 20 00 clr %i4
200cd28: ba 10 00 08 mov %o0, %i5
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
200cd2c: d0 23 a0 5c st %o0, [ %sp + 0x5c ]
200cd30: f8 3f bd 60 std %i4, [ %fp + -672 ]
200cd34: 9a 10 20 00 clr %o5
200cd38: 90 10 00 19 mov %i1, %o0
200cd3c: 92 10 20 02 mov 2, %o1
200cd40: 15 00 80 98 sethi %hi(0x2026000), %o2
200cd44: 96 10 00 11 mov %l1, %o3
200cd48: 94 12 a0 a8 or %o2, 0xa8, %o2
200cd4c: 7f ff ff 46 call 200ca64 <msdos_format_printf>
200cd50: 98 10 00 10 mov %l0, %o4
/*
* determine number of FATs
*/
if (ret_val == 0) {
if ((rqdata == NULL) ||
200cd54: 80 a6 60 00 cmp %i1, 0
200cd58: 02 80 00 0a be 200cd80 <msdos_format+0x13c>
200cd5c: 82 10 20 02 mov 2, %g1
(rqdata->fat_num == 0)) {
200cd60: c2 06 60 0c ld [ %i1 + 0xc ], %g1
/*
* determine number of FATs
*/
if (ret_val == 0) {
if ((rqdata == NULL) ||
200cd64: 80 a0 60 00 cmp %g1, 0
200cd68: 12 80 00 04 bne 200cd78 <msdos_format+0x134> <== NEVER TAKEN
200cd6c: 80 a0 60 06 cmp %g1, 6
(rqdata->fat_num == 0)) {
fmt_params->fat_num = 2;
200cd70: 10 80 00 04 b 200cd80 <msdos_format+0x13c>
200cd74: 82 10 20 02 mov 2, %g1
}
else if (rqdata->fat_num <= 6) {
200cd78: 38 80 01 13 bgu,a 200d1c4 <msdos_format+0x580> <== NOT EXECUTED
200cd7c: b0 10 20 16 mov 0x16, %i0 <== NOT EXECUTED
fmt_params->fat_num = rqdata->fat_num;
200cd80: 10 80 02 d9 b 200d8e4 <msdos_format+0xca0>
200cd84: 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) &&
200cd88: c2 0e 60 14 ldub [ %i1 + 0x14 ], %g1
200cd8c: 80 a0 60 01 cmp %g1, 1
200cd90: 12 80 00 04 bne 200cda0 <msdos_format+0x15c> <== ALWAYS TAKEN
200cd94: 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;
200cd98: 10 80 00 45 b 200ceac <msdos_format+0x268> <== NOT EXECUTED
200cd9c: 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) &&
200cda0: 12 80 00 04 bne 200cdb0 <msdos_format+0x16c> <== ALWAYS TAKEN
200cda4: 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;
200cda8: 10 80 00 41 b 200ceac <msdos_format+0x268> <== NOT EXECUTED
200cdac: 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) &&
200cdb0: 12 80 00 05 bne 200cdc4 <msdos_format+0x180> <== ALWAYS TAKEN
200cdb4: 80 a0 60 00 cmp %g1, 0
(rqdata->fattype == MSDOS_FMT_FAT32)) {
fmt_params->fattype = FAT_FAT32;
200cdb8: 82 10 20 04 mov 4, %g1 <== NOT EXECUTED
200cdbc: 10 80 00 3c b 200ceac <msdos_format+0x268> <== NOT EXECUTED
200cdc0: c2 2f bd e2 stb %g1, [ %fp + -542 ] <== NOT EXECUTED
}
else if ((rqdata != NULL) &&
200cdc4: 22 80 00 07 be,a 200cde0 <msdos_format+0x19c> <== ALWAYS TAKEN
200cdc8: c2 06 60 08 ld [ %i1 + 8 ], %g1
(rqdata->fattype != MSDOS_FMT_FATANY)) {
ret_val = -1;
errno = EINVAL;
200cdcc: 40 00 34 95 call 201a020 <__errno> <== NOT EXECUTED
200cdd0: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
200cdd4: 82 10 20 16 mov 0x16, %g1 <== NOT EXECUTED
200cdd8: 10 80 00 35 b 200ceac <msdos_format+0x268> <== NOT EXECUTED
200cddc: 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) {
200cde0: 84 90 60 00 orcc %g1, 0, %g2
200cde4: 12 80 00 05 bne 200cdf8 <msdos_format+0x1b4> <== NEVER TAKEN
200cde8: 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;
200cdec: 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;
200cdf0: 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
200cdf4: c6 07 bd b4 ld [ %fp + -588 ], %g3
< FAT_FAT12_MAX_CLN * fat12_sect_per_clust) {
200cdf8: 89 28 60 02 sll %g1, 2, %g4
200cdfc: 9f 28 60 0a sll %g1, 0xa, %o7
200ce00: 88 23 c0 04 sub %o7, %g4, %g4
200ce04: 88 01 00 01 add %g4, %g1, %g4
200ce08: 89 29 20 02 sll %g4, 2, %g4
200ce0c: 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
200ce10: 80 a0 c0 01 cmp %g3, %g1
200ce14: 3a 80 00 04 bcc,a 200ce24 <msdos_format+0x1e0> <== NEVER TAKEN
200ce18: 83 28 a0 02 sll %g2, 2, %g1 <== NOT EXECUTED
< FAT_FAT12_MAX_CLN * fat12_sect_per_clust) {
fmt_params->fattype = FAT_FAT12;
200ce1c: 10 80 00 0b b 200ce48 <msdos_format+0x204>
200ce20: 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) {
200ce24: 89 28 a0 0e sll %g2, 0xe, %g4 <== NOT EXECUTED
200ce28: 82 21 00 01 sub %g4, %g1, %g1 <== NOT EXECUTED
200ce2c: 82 00 40 02 add %g1, %g2, %g1 <== NOT EXECUTED
200ce30: 83 28 60 02 sll %g1, 2, %g1 <== NOT EXECUTED
200ce34: 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
200ce38: 80 a0 c0 02 cmp %g3, %g2 <== NOT EXECUTED
200ce3c: 1a 80 00 06 bcc 200ce54 <msdos_format+0x210> <== NOT EXECUTED
200ce40: 84 10 20 00 clr %g2 <== NOT EXECUTED
< FAT_FAT16_MAX_CLN * fat16_sect_per_clust) {
fmt_params->fattype = FAT_FAT16;
200ce44: 82 10 20 02 mov 2, %g1 <== NOT EXECUTED
200ce48: c2 2f bd e2 stb %g1, [ %fp + -542 ]
/* start trying with small clusters */
fmt_params->sectors_per_cluster = 2;
200ce4c: 10 80 00 15 b 200cea0 <msdos_format+0x25c>
200ce50: 82 10 20 02 mov 2, %g1
}
else {
#define ONE_GB (1024L * 1024L * 1024L)
uint32_t gigs = (total_size + ONE_GB) / ONE_GB;
200ce54: 07 10 00 00 sethi %hi(0x40000000), %g3 <== NOT EXECUTED
200ce58: ba 87 40 03 addcc %i5, %g3, %i5 <== NOT EXECUTED
200ce5c: 83 37 60 1e srl %i5, 0x1e, %g1 <== NOT EXECUTED
200ce60: b8 47 00 02 addx %i4, %g2, %i4 <== NOT EXECUTED
200ce64: 85 2f 20 02 sll %i4, 2, %g2 <== NOT EXECUTED
200ce68: 84 10 80 01 or %g2, %g1, %g2 <== NOT EXECUTED
int b;
fmt_params->fattype = FAT_FAT32;
200ce6c: 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)
200ce70: 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;
200ce74: c2 2f bd e2 stb %g1, [ %fp + -542 ] <== NOT EXECUTED
/* scale with the size of disk... */
for (b = 31; b > 0; b--)
200ce78: 82 10 20 1f mov 0x1f, %g1 <== NOT EXECUTED
if ((gigs & (1 << b)) != 0)
200ce7c: 89 28 c0 01 sll %g3, %g1, %g4 <== NOT EXECUTED
200ce80: 80 89 00 02 btst %g4, %g2 <== NOT EXECUTED
200ce84: 32 80 00 06 bne,a 200ce9c <msdos_format+0x258> <== NOT EXECUTED
200ce88: 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--)
200ce8c: 82 80 7f ff addcc %g1, -1, %g1 <== NOT EXECUTED
200ce90: 12 bf ff fc bne 200ce80 <msdos_format+0x23c> <== NOT EXECUTED
200ce94: 89 28 c0 01 sll %g3, %g1, %g4 <== NOT EXECUTED
if ((gigs & (1 << b)) != 0)
break;
fmt_params->sectors_per_cluster = 1 << b;
200ce98: 84 10 20 01 mov 1, %g2 <== NOT EXECUTED
200ce9c: 83 28 80 01 sll %g2, %g1, %g1 <== NOT EXECUTED
}
}
/*
* try to use user requested cluster size
*/
if ((rqdata != NULL) &&
200cea0: 80 a6 60 00 cmp %i1, 0
200cea4: 02 80 00 06 be 200cebc <msdos_format+0x278>
200cea8: c2 27 bd bc st %g1, [ %fp + -580 ]
(rqdata->sectors_per_cluster > 0)) {
200ceac: c2 06 60 08 ld [ %i1 + 8 ], %g1
}
}
/*
* try to use user requested cluster size
*/
if ((rqdata != NULL) &&
200ceb0: 80 a0 60 00 cmp %g1, 0
200ceb4: 32 80 00 02 bne,a 200cebc <msdos_format+0x278> <== NEVER TAKEN
200ceb8: 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) {
200cebc: f8 07 bd b0 ld [ %fp + -592 ], %i4
200cec0: d6 07 bd bc ld [ %fp + -580 ], %o3
200cec4: 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) {
200cec8: 80 a2 c0 1d cmp %o3, %i5
200cecc: 2a 80 00 0c bcs,a 200cefc <msdos_format+0x2b8>
200ced0: 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) {
200ced4: 11 00 00 20 sethi %hi(0x8000), %o0
200ced8: 40 00 58 90 call 2023118 <.udiv>
200cedc: 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
200cee0: 80 a7 40 08 cmp %i5, %o0
200cee4: 08 80 00 04 bleu 200cef4 <msdos_format+0x2b0> <== ALWAYS TAKEN
200cee8: 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) {
200ceec: 10 80 00 04 b 200cefc <msdos_format+0x2b8> <== NOT EXECUTED
200cef0: 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;
200cef4: 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) {
200cef8: bb 37 60 01 srl %i5, 1, %i5
200cefc: 80 a7 60 00 cmp %i5, 0
200cf00: 12 bf ff f3 bne 200cecc <msdos_format+0x288>
200cf04: 80 a2 c0 1d cmp %o3, %i5
}
}
}
}
if (ret_val == 0) {
200cf08: 80 a6 20 00 cmp %i0, 0
200cf0c: 12 80 00 ad bne 200d1c0 <msdos_format+0x57c> <== NEVER TAKEN
200cf10: d6 27 bd bc st %o3, [ %fp + -580 ]
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
200cf14: 90 10 00 19 mov %i1, %o0
200cf18: 92 10 20 02 mov 2, %o1
200cf1c: 15 00 80 98 sethi %hi(0x2026000), %o2
200cf20: 7f ff fe d1 call 200ca64 <msdos_format_printf>
200cf24: 94 12 a0 e8 or %o2, 0xe8, %o2 ! 20260e8 <_CPU_Trap_slot_template+0xd8>
"sectors per cluster: %d\n", fmt_params->sectors_per_cluster);
if (fmt_params->fattype == FAT_FAT32) {
200cf28: f8 0f bd e2 ldub [ %fp + -542 ], %i4
200cf2c: 82 0f 20 ff and %i4, 0xff, %g1
200cf30: 80 a0 60 04 cmp %g1, 4
200cf34: 12 80 00 0a bne 200cf5c <msdos_format+0x318> <== ALWAYS TAKEN
200cf38: 82 10 20 01 mov 1, %g1
/* recommended: for FAT32, always set reserved sector count to 32 */
fmt_params->rsvd_sector_cnt = 32;
200cf3c: 82 10 20 20 mov 0x20, %g1 <== NOT EXECUTED
200cf40: 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;
200cf44: 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;
200cf48: c0 27 bd c8 clr [ %fp + -568 ] <== NOT EXECUTED
/* location of copy of MBR */
fmt_params->mbr_copy_sec = 6;
200cf4c: c2 27 bd d8 st %g1, [ %fp + -552 ] <== NOT EXECUTED
/* location of fsinfo sector */
fmt_params->fsinfo_sec = 1;
200cf50: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED
200cf54: 10 80 00 1b b 200cfc0 <msdos_format+0x37c> <== NOT EXECUTED
200cf58: 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) &&
200cf5c: 80 a6 60 00 cmp %i1, 0
200cf60: 02 80 00 08 be 200cf80 <msdos_format+0x33c>
200cf64: c2 27 bd b8 st %g1, [ %fp + -584 ]
(rqdata->files_per_root_dir > 0)) {
200cf68: 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) &&
200cf6c: 80 a0 60 00 cmp %g1, 0
200cf70: 22 80 00 05 be,a 200cf84 <msdos_format+0x340> <== ALWAYS TAKEN
200cf74: 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;
200cf78: 10 80 00 08 b 200cf98 <msdos_format+0x354> <== NOT EXECUTED
200cf7c: 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) {
200cf80: 82 0f 20 ff and %i4, 0xff, %g1
200cf84: 80 a0 60 02 cmp %g1, 2
200cf88: 32 80 00 03 bne,a 200cf94 <msdos_format+0x350> <== ALWAYS TAKEN
200cf8c: 82 10 20 40 mov 0x40, %g1
200cf90: 82 10 22 00 mov 0x200, %g1 <== NOT EXECUTED
fmt_params->files_per_root_dir = 512;
}
else {
fmt_params->files_per_root_dir = 64;
200cf94: 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/
200cf98: 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 +
200cf9c: fa 07 bd c8 ld [ %fp + -568 ], %i5
(2*fmt_params->bytes_per_sector/
200cfa0: 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 +
200cfa4: ba 07 7f ff add %i5, -1, %i5
(2*fmt_params->bytes_per_sector/
200cfa8: 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 +
200cfac: 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 %
200cfb0: 40 00 59 06 call 20233c8 <.urem>
200cfb4: 90 10 00 1d mov %i5, %o0
200cfb8: 90 27 40 08 sub %i5, %o0, %o0
200cfbc: 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)
200cfc0: 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)
200cfc4: d0 07 bd c8 ld [ %fp + -568 ], %o0
+ fmt_params->bytes_per_sector - 1)
/ fmt_params->bytes_per_sector);
200cfc8: 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)
200cfcc: 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)
200cfd0: 91 2a 20 05 sll %o0, 5, %o0
+ fmt_params->bytes_per_sector - 1)
/ fmt_params->bytes_per_sector);
200cfd4: 40 00 58 51 call 2023118 <.udiv>
200cfd8: 90 04 00 08 add %l0, %o0, %o0
}
if (ret_val == 0) {
fatdata_sect_cnt = (fmt_params->totl_sector_cnt -
200cfdc: c2 07 bd b8 ld [ %fp + -584 ], %g1
200cfe0: 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 =
200cfe4: 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 -
200cfe8: 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,
200cfec: 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 -
200cff0: 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,
200cff4: e6 0f bd e0 ldub [ %fp + -544 ], %l3
200cff8: 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) {
200cffc: 92 10 00 1d mov %i5, %o1
200d000: 40 00 58 46 call 2023118 <.udiv>
200d004: 11 00 00 20 sethi %hi(0x8000), %o0
200d008: 10 80 00 03 b 200d014 <msdos_format+0x3d0>
200d00c: 80 a2 00 11 cmp %o0, %l1
200d010: 80 a2 00 11 cmp %o0, %l1 <== NOT EXECUTED
200d014: 2a bf ff ff bcs,a 200d010 <msdos_format+0x3cc> <== NEVER TAKEN
200d018: 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))) {
200d01c: 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)) ||
200d020: 80 a0 00 02 cmp %g0, %g2
((fattype == FAT_FAT16) && (data_cluster_cnt > FAT_FAT16_MAX_CLN))) {
200d024: 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)) ||
200d028: aa 60 3f ff subx %g0, -1, %l5
200d02c: 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)
200d030: 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)) ||
200d034: 80 a0 00 02 cmp %g0, %g2
((fattype == FAT_FAT16) && (data_cluster_cnt > FAT_FAT16_MAX_CLN))) {
200d038: 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)) ||
200d03c: 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)
200d040: 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;
200d044: 90 10 00 12 mov %l2, %o0
200d048: 40 00 58 34 call 2023118 <.udiv>
200d04c: 92 10 00 11 mov %l1, %o1
if (fattype == FAT_FAT12) {
200d050: 80 a7 20 01 cmp %i4, 1
200d054: 12 80 00 06 bne 200d06c <msdos_format+0x428> <== NEVER TAKEN
200d058: 84 10 00 08 mov %o0, %g2
fat_capacity = fatdata_cluster_cnt * 3 / 2;
200d05c: 91 2a 20 01 sll %o0, 1, %o0
200d060: 90 02 00 02 add %o0, %g2, %o0
200d064: 10 80 00 06 b 200d07c <msdos_format+0x438>
200d068: 91 32 20 01 srl %o0, 1, %o0
}
else if (fattype == FAT_FAT16) {
200d06c: 80 a7 20 02 cmp %i4, 2 <== NOT EXECUTED
200d070: 12 80 00 03 bne 200d07c <msdos_format+0x438> <== NOT EXECUTED
200d074: 91 2a 20 02 sll %o0, 2, %o0 <== NOT EXECUTED
fat_capacity = fatdata_cluster_cnt * 2;
200d078: 91 28 a0 01 sll %g2, 1, %o0 <== NOT EXECUTED
}
else { /* FAT32 */
fat_capacity = fatdata_cluster_cnt * 4;
}
sectors_per_fat = ((fat_capacity
200d07c: c4 27 bd 50 st %g2, [ %fp + -688 ]
200d080: 92 10 00 1d mov %i5, %o1
200d084: 40 00 58 25 call 2023118 <.udiv>
200d088: 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))
200d08c: 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)
200d090: 92 10 00 13 mov %l3, %o1
200d094: c6 27 bd 54 st %g3, [ %fp + -684 ]
200d098: 40 00 57 e6 call 2023030 <.umul>
200d09c: d0 27 bd 5c st %o0, [ %fp + -676 ]
+ (sectors_per_cluster - 1))
/ sectors_per_cluster));
200d0a0: c6 07 bd 54 ld [ %fp + -684 ], %g3
200d0a4: 92 10 00 11 mov %l1, %o1
200d0a8: 40 00 58 1c call 2023118 <.udiv>
200d0ac: 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 -
200d0b0: c4 07 bd 50 ld [ %fp + -688 ], %g2
200d0b4: 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)) ||
200d0b8: 80 a2 2f f5 cmp %o0, 0xff5
200d0bc: 18 80 00 03 bgu 200d0c8 <msdos_format+0x484> <== NEVER TAKEN
200d0c0: 86 10 20 01 mov 1, %g3
200d0c4: 86 10 20 00 clr %g3
200d0c8: 80 88 e0 ff btst 0xff, %g3
200d0cc: 02 80 00 06 be 200d0e4 <msdos_format+0x4a0> <== ALWAYS TAKEN
200d0d0: 80 a5 00 08 cmp %l4, %o0
200d0d4: 80 a5 a0 00 cmp %l6, 0 <== NOT EXECUTED
200d0d8: 32 80 00 09 bne,a 200d0fc <msdos_format+0x4b8> <== NOT EXECUTED
200d0dc: a3 2c 60 01 sll %l1, 1, %l1 <== NOT EXECUTED
200d0e0: 80 a5 00 08 cmp %l4, %o0 <== NOT EXECUTED
200d0e4: 1a 80 00 08 bcc 200d104 <msdos_format+0x4c0> <== ALWAYS TAKEN
200d0e8: 84 10 20 01 mov 1, %g2
200d0ec: 80 a5 60 00 cmp %l5, 0 <== NOT EXECUTED
200d0f0: 22 80 00 06 be,a 200d108 <msdos_format+0x4c4> <== NOT EXECUTED
200d0f4: c4 27 bd 50 st %g2, [ %fp + -688 ] <== NOT EXECUTED
((fattype == FAT_FAT16) && (data_cluster_cnt > FAT_FAT16_MAX_CLN))) {
sectors_per_cluster *= 2;
200d0f8: a3 2c 60 01 sll %l1, 1, %l1 <== NOT EXECUTED
200d0fc: 10 80 00 02 b 200d104 <msdos_format+0x4c0> <== NOT EXECUTED
200d100: 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)
200d104: c4 27 bd 50 st %g2, [ %fp + -688 ]
200d108: 90 10 00 11 mov %l1, %o0
200d10c: 40 00 57 c9 call 2023030 <.umul>
200d110: 92 10 00 1d mov %i5, %o1
200d114: 80 a2 00 17 cmp %o0, %l7
200d118: 18 80 00 08 bgu 200d138 <msdos_format+0x4f4> <== NEVER TAKEN
200d11c: c4 07 bd 50 ld [ %fp + -688 ], %g2
> MS_BYTES_PER_CLUSTER_LIMIT) {
ret_val = EINVAL;
finished = true;
}
} while (!finished);
200d120: 80 88 a0 ff btst 0xff, %g2
200d124: 02 bf ff c9 be 200d048 <msdos_format+0x404> <== NEVER TAKEN
200d128: 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;
200d12c: c2 07 bd 5c ld [ %fp + -676 ], %g1
200d130: 10 80 00 07 b 200d14c <msdos_format+0x508>
200d134: 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);
200d138: 40 00 33 ba call 201a020 <__errno> <== NOT EXECUTED
200d13c: a2 10 20 00 clr %l1 <== NOT EXECUTED
200d140: 82 10 20 16 mov 0x16, %g1 <== NOT EXECUTED
200d144: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
200d148: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
}
/*
* determine media code
*/
if (ret_val == 0) {
200d14c: 80 a6 20 00 cmp %i0, 0
200d150: 12 80 00 1c bne 200d1c0 <msdos_format+0x57c> <== NEVER TAKEN
200d154: e2 27 bd bc st %l1, [ %fp + -580 ]
if ((rqdata != NULL) &&
200d158: 80 a6 60 00 cmp %i1, 0
200d15c: 02 80 00 17 be 200d1b8 <msdos_format+0x574>
200d160: 82 10 3f f8 mov -8, %g1
(rqdata->media != 0)) {
200d164: fa 0e 60 15 ldub [ %i1 + 0x15 ], %i5
/*
* determine media code
*/
if (ret_val == 0) {
if ((rqdata != NULL) &&
200d168: b8 8f 60 ff andcc %i5, 0xff, %i4
200d16c: 22 80 00 16 be,a 200d1c4 <msdos_format+0x580> <== ALWAYS TAKEN
200d170: c2 2f bd e1 stb %g1, [ %fp + -543 ]
(rqdata->media != 0)) {
const char valid_media_codes[] =
200d174: 94 10 20 09 mov 9, %o2 <== NOT EXECUTED
200d178: 90 07 be 00 add %fp, -512, %o0 <== NOT EXECUTED
200d17c: 13 00 80 98 sethi %hi(0x2026000), %o1 <== NOT EXECUTED
200d180: 40 00 36 5d call 201aaf4 <memcpy> <== NOT EXECUTED
200d184: 92 12 61 98 or %o1, 0x198, %o1 ! 2026198 <_CPU_Trap_slot_template+0x188><== NOT EXECUTED
{0xF0,0xF8,0xF9,0xFA,0xFB,0xFC,0xFD,0xFE,0xFF};
if (NULL==memchr(valid_media_codes,
200d188: 90 07 be 00 add %fp, -512, %o0 <== NOT EXECUTED
200d18c: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
200d190: 40 00 35 eb call 201a93c <memchr> <== NOT EXECUTED
200d194: 94 10 20 09 mov 9, %o2 <== NOT EXECUTED
200d198: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
200d19c: 32 80 00 0a bne,a 200d1c4 <msdos_format+0x580> <== NOT EXECUTED
200d1a0: fa 2f bd e1 stb %i5, [ %fp + -543 ] <== NOT EXECUTED
rqdata->media,
sizeof(valid_media_codes))) {
ret_val = -1;
errno = EINVAL;
200d1a4: 40 00 33 9f call 201a020 <__errno> <== NOT EXECUTED
200d1a8: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
200d1ac: 82 10 20 16 mov 0x16, %g1 <== NOT EXECUTED
200d1b0: 10 80 00 05 b 200d1c4 <msdos_format+0x580> <== NOT EXECUTED
200d1b4: 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;
200d1b8: 10 80 00 03 b 200d1c4 <msdos_format+0x580>
200d1bc: c2 2f bd e1 stb %g1, [ %fp + -543 ]
}
/*
* determine media code
*/
if (ret_val == 0) {
200d1c0: 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) {
200d1c4: f8 07 bd cc ld [ %fp + -564 ], %i4
200d1c8: d0 0f bd e0 ldub [ %fp + -544 ], %o0
200d1cc: 80 a7 20 00 cmp %i4, 0
200d1d0: 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);
200d1d4: 90 0a 20 ff and %o0, 0xff, %o0
}
/*
* determine location and size of root directory
* for formatting
*/
if (fmt_params->root_dir_sectors > 0) {
200d1d8: 02 80 00 08 be 200d1f8 <msdos_format+0x5b4> <== NEVER TAKEN
200d1dc: 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);
200d1e0: 40 00 57 94 call 2023030 <.umul>
200d1e4: 01 00 00 00 nop
fmt_params->root_dir_fmt_sec_cnt = fmt_params->root_dir_sectors;
200d1e8: 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);
200d1ec: 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 =
200d1f0: 10 80 00 08 b 200d210 <msdos_format+0x5cc>
200d1f4: 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);
200d1f8: 40 00 57 8e call 2023030 <.umul> <== NOT EXECUTED
200d1fc: 01 00 00 00 nop <== NOT EXECUTED
fmt_params->root_dir_fmt_sec_cnt = fmt_params->sectors_per_cluster;
200d200: 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);
200d204: 90 02 00 1d add %o0, %i5, %o0 <== NOT EXECUTED
fmt_params->root_dir_fmt_sec_cnt = fmt_params->sectors_per_cluster;
200d208: 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 =
200d20c: 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) {
200d210: 80 a6 20 00 cmp %i0, 0
200d214: 12 80 01 ca bne 200d93c <msdos_format+0xcf8> <== NEVER TAKEN
200d218: 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) &&
200d21c: 80 a6 60 00 cmp %i1, 0
200d220: 02 80 00 07 be 200d23c <msdos_format+0x5f8>
200d224: 03 00 80 98 sethi %hi(0x2026000), %g1
(rqdata->OEMName != NULL)) {
200d228: 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) &&
200d22c: 80 a0 60 00 cmp %g1, 0
200d230: 32 80 00 05 bne,a 200d244 <msdos_format+0x600> <== ALWAYS TAKEN
200d234: 05 00 80 9e sethi %hi(0x2027800), %g2
*/
if (ret_val == 0) {
const char *from;
char *to = fmt_params->OEMName;
int cnt;
from = "RTEMS"; /* default: make "from" point to OS Name */
200d238: 03 00 80 98 sethi %hi(0x2026000), %g1 <== NOT EXECUTED
200d23c: 82 10 60 50 or %g1, 0x50, %g1 ! 2026050 <_CPU_Trap_slot_template+0x40>
from = rqdata->OEMName;
}
for (cnt = 0;
cnt < (sizeof(fmt_params->OEMName)-1);
cnt++) {
if (isprint((unsigned char)*from)) {
200d240: 05 00 80 9e sethi %hi(0x2027800), %g2
200d244: 86 10 20 09 mov 9, %g3
200d248: f8 00 a3 b8 ld [ %g2 + 0x3b8 ], %i4
/*
* non-printable character in given name, so keep stuck
* at that character and replace all following characters
* with a ' '
*/
*to++=' ';
200d24c: b0 10 20 20 mov 0x20, %i0
/*
* determine usable OEMName
*/
if (ret_val == 0) {
const char *from;
char *to = fmt_params->OEMName;
200d250: 10 80 00 0f b 200d28c <msdos_format+0x648>
200d254: 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)) {
200d258: 88 0f 60 ff and %i5, 0xff, %g4
200d25c: 88 07 00 04 add %i4, %g4, %g4
200d260: c8 49 20 01 ldsb [ %g4 + 1 ], %g4
200d264: 80 89 20 97 btst 0x97, %g4
200d268: 02 80 00 06 be 200d280 <msdos_format+0x63c>
200d26c: 88 00 a0 01 add %g2, 1, %g4
*to++ = *from++;
200d270: fa 28 80 00 stb %i5, [ %g2 ]
200d274: 82 00 60 01 inc %g1
200d278: 10 80 00 04 b 200d288 <msdos_format+0x644>
200d27c: 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++=' ';
200d280: f0 28 80 00 stb %i0, [ %g2 ]
200d284: 84 10 00 04 mov %g4, %g2
}
*to = '\0';
200d288: 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;
200d28c: 86 80 ff ff addcc %g3, -1, %g3
200d290: 32 bf ff f2 bne,a 200d258 <msdos_format+0x614>
200d294: 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) &&
200d298: 10 80 01 9f b 200d914 <msdos_format+0xcd0>
200d29c: 80 a6 60 00 cmp %i1, 0
200d2a0: 80 a0 60 00 cmp %g1, 0
200d2a4: 22 80 00 05 be,a 200d2b8 <msdos_format+0x674> <== NEVER TAKEN
200d2a8: 03 00 80 95 sethi %hi(0x2025400), %g1 <== NOT EXECUTED
(rqdata->VolLabel != NULL)) {
from = rqdata->VolLabel;
fmt_params->VolLabel_present = true;
200d2ac: 84 10 20 01 mov 1, %g2
200d2b0: 10 80 00 03 b 200d2bc <msdos_format+0x678>
200d2b4: 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 */
200d2b8: 82 10 62 c0 or %g1, 0x2c0, %g1
fmt_params->VolLabel_present = true;
}
for (cnt = 0;
cnt < (sizeof(fmt_params->VolLabel)-1);
cnt++) {
if (isprint((unsigned char)*from)) {
200d2bc: 05 00 80 9e sethi %hi(0x2027800), %g2
200d2c0: 86 10 20 0c mov 0xc, %g3
200d2c4: f8 00 a3 b8 ld [ %g2 + 0x3b8 ], %i4
/*
* non-printable character in given name, so keep stuck
* at that character and replace all following characters
* with a ' '
*/
*to++=' ';
200d2c8: b0 10 20 20 mov 0x20, %i0
/*
* determine usable Volume Label
*/
if (ret_val == 0) {
const char *from;
char *to = fmt_params->VolLabel;
200d2cc: 10 80 00 0f b 200d308 <msdos_format+0x6c4>
200d2d0: 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)) {
200d2d4: 88 0f 60 ff and %i5, 0xff, %g4
200d2d8: 88 07 00 04 add %i4, %g4, %g4
200d2dc: c8 49 20 01 ldsb [ %g4 + 1 ], %g4
200d2e0: 80 89 20 97 btst 0x97, %g4
200d2e4: 02 80 00 06 be 200d2fc <msdos_format+0x6b8>
200d2e8: 88 00 a0 01 add %g2, 1, %g4
*to++ = *from++;
200d2ec: fa 28 80 00 stb %i5, [ %g2 ]
200d2f0: 82 00 60 01 inc %g1
200d2f4: 10 80 00 04 b 200d304 <msdos_format+0x6c0>
200d2f8: 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++=' ';
200d2fc: f0 28 80 00 stb %i0, [ %g2 ]
200d300: 84 10 00 04 mov %g4, %g2
}
*to = '\0';
200d304: c0 29 00 00 clrb [ %g4 ]
if ((rqdata != NULL) &&
(rqdata->VolLabel != NULL)) {
from = rqdata->VolLabel;
fmt_params->VolLabel_present = true;
}
for (cnt = 0;
200d308: 86 80 ff ff addcc %g3, -1, %g3
200d30c: 32 bf ff f2 bne,a 200d2d4 <msdos_format+0x690>
200d310: fa 08 40 00 ldub [ %g1 ], %i5
200d314: 30 80 01 84 b,a 200d924 <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;
200d318: 83 28 60 01 sll %g1, 1, %g1 <== NOT EXECUTED
200d31c: 10 80 00 05 b 200d330 <msdos_format+0x6ec> <== NOT EXECUTED
200d320: c2 27 bd fc st %g1, [ %fp + -516 ] <== NOT EXECUTED
}
else {
*volid_ptr = rand();
200d324: 40 00 36 88 call 201ad44 <rand>
200d328: 01 00 00 00 nop
200d32c: 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) &&
200d330: 80 a6 e0 00 cmp %i3, 0
200d334: 12 80 00 20 bne 200d3b4 <msdos_format+0x770> <== NEVER TAKEN
200d338: 80 a6 e0 00 cmp %i3, 0
200d33c: 80 a6 60 00 cmp %i1, 0
200d340: 02 80 00 1d be 200d3b4 <msdos_format+0x770>
200d344: 80 a6 e0 00 cmp %i3, 0
(rqdata != NULL) &&
200d348: c2 0e 60 16 ldub [ %i1 + 0x16 ], %g1
200d34c: 80 a0 60 00 cmp %g1, 0
200d350: 02 80 00 11 be 200d394 <msdos_format+0x750> <== ALWAYS TAKEN
200d354: 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,
200d358: 92 10 20 02 mov 2, %o1
200d35c: 15 00 80 98 sethi %hi(0x2026000), %o2
200d360: 7f ff fd c1 call 200ca64 <msdos_format_printf>
200d364: 94 12 a1 08 or %o2, 0x108, %o2 ! 2026108 <_CPU_Trap_slot_template+0xf8>
| 0, if success, -1 and errno if failed |
\*=========================================================================*/
{
int ret_val = 0;
if (0 > lseek(fd,((off_t)start_sector)*sector_size,SEEK_SET)) {
200d368: 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,
200d36c: 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)) {
200d370: 92 10 20 00 clr %o1
200d374: 94 10 20 00 clr %o2
200d378: 7f ff dd b2 call 2004a40 <lseek>
200d37c: 96 10 20 00 clr %o3
200d380: 80 a2 20 00 cmp %o0, 0
200d384: 16 80 01 73 bge 200d950 <msdos_format+0xd0c> <== ALWAYS TAKEN
200d388: 90 10 00 1a mov %i2, %o0
}
}
}
}
if (ret_val == 0) {
200d38c: 10 80 01 42 b 200d894 <msdos_format+0xc50> <== NOT EXECUTED
200d390: 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
200d394: d6 07 bd b4 ld [ %fp + -588 ], %o3
200d398: d8 07 bd b0 ld [ %fp + -592 ], %o4
200d39c: 92 10 00 1a mov %i2, %o1
200d3a0: 94 10 20 00 clr %o2
200d3a4: 7f ff fd dd call 200cb18 <msdos_format_fill_sectors>
200d3a8: 9a 10 3f e5 mov -27, %o5
200d3ac: b6 10 00 08 mov %o0, %i3
}
/*
* create master boot record
*/
if (ret_val == 0) {
200d3b0: 80 a6 e0 00 cmp %i3, 0
200d3b4: 12 80 01 39 bne 200d898 <msdos_format+0xc54> <== NEVER TAKEN
200d3b8: 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,
200d3bc: 10 bf ff e7 b 200d358 <msdos_format+0x714>
200d3c0: 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;
200d3c4: 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);
200d3c8: 92 10 20 00 clr %o1
200d3cc: 94 10 21 be mov 0x1be, %o2
200d3d0: 40 00 36 06 call 201abe8 <memset>
200d3d4: 90 07 be 00 add %fp, -512, %o0
* with 0xEB,....
*/
/*
* fill OEMName
*/
memcpy(FAT_GET_ADDR_BR_OEMNAME(mbr),
200d3d8: 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,
200d3dc: c0 37 bf fe clrh [ %fp + -2 ]
* with 0xEB,....
*/
/*
* fill OEMName
*/
memcpy(FAT_GET_ADDR_BR_OEMNAME(mbr),
200d3e0: 92 07 bd e3 add %fp, -541, %o1
200d3e4: 40 00 35 c4 call 201aaf4 <memcpy>
200d3e8: 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);
200d3ec: 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);
200d3f0: 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);
200d3f4: c2 2f be 0b stb %g1, [ %fp + -501 ]
200d3f8: 83 30 60 08 srl %g1, 8, %g1
200d3fc: c2 2f be 0c stb %g1, [ %fp + -500 ]
FAT_SET_BR_SECTORS_PER_CLUSTER(mbr , fmt_params->sectors_per_cluster);
200d400: 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);
200d404: 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);
200d408: c2 2f be 0d stb %g1, [ %fp + -499 ]
FAT_SET_BR_RESERVED_SECTORS_NUM(mbr, fmt_params->rsvd_sector_cnt);
200d40c: 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);
200d410: 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);
200d414: c2 2f be 0e stb %g1, [ %fp + -498 ]
200d418: 83 30 60 08 srl %g1, 8, %g1
200d41c: 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);
200d420: 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 */
200d424: 88 10 20 02 mov 2, %g4
FAT_SET_BR_FILES_PER_ROOT_DIR(mbr , fmt_params->files_per_root_dir);
200d428: c2 2f be 11 stb %g1, [ %fp + -495 ]
200d42c: 83 30 60 08 srl %g1, 8, %g1
200d430: 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);
200d434: 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);
200d438: f8 2f be 13 stb %i4, [ %fp + -493 ]
FAT_SET_BR_MEDIA(mbr , fmt_params->media_code);
200d43c: c2 2f be 15 stb %g1, [ %fp + -491 ]
FAT_SET_BR_SECTORS_PER_TRACK(mbr , 255); /* only needed for INT13... */
200d440: 82 10 3f ff mov -1, %g1
200d444: c2 2f be 18 stb %g1, [ %fp + -488 ]
FAT_SET_BR_NUMBER_OF_HEADS(mbr , 6); /* only needed for INT13... */
200d448: 82 10 20 06 mov 6, %g1
200d44c: 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);
200d450: 82 0f 40 02 and %i5, %g2, %g1
200d454: 83 30 60 08 srl %g1, 8, %g1
200d458: c2 2f be 21 stb %g1, [ %fp + -479 ]
200d45c: 83 37 60 10 srl %i5, 0x10, %g1
200d460: bb 37 60 18 srl %i5, 0x18, %i5
200d464: fa 2f be 23 stb %i5, [ %fp + -477 ]
if (fmt_params->fattype != FAT_FAT32) {
200d468: 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);
200d46c: 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... */
200d470: 86 10 20 01 mov 1, %g3
FAT_SET_BR_TOTAL_SECTORS_NUM32(mbr , total_sectors_num32);
200d474: 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 */
200d478: 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);
200d47c: 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... */
200d480: c6 2f be 1c stb %g3, [ %fp + -484 ]
FAT_SET_BR_TOTAL_SECTORS_NUM32(mbr , total_sectors_num32);
if (fmt_params->fattype != FAT_FAT32) {
200d484: 80 a7 60 04 cmp %i5, 4
200d488: 02 80 00 1c be 200d4f8 <msdos_format+0x8b4> <== NEVER TAKEN
200d48c: c2 07 bd c0 ld [ %fp + -576 ], %g1
FAT_SET_BR_SECTORS_PER_FAT(mbr ,fmt_params->sectors_per_fat);
200d490: c2 2f be 16 stb %g1, [ %fp + -490 ]
200d494: 83 30 60 08 srl %g1, 8, %g1
200d498: 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);
200d49c: 82 10 20 29 mov 0x29, %g1
200d4a0: c2 2f be 26 stb %g1, [ %fp + -474 ]
FAT_SET_BR_VOLID(mbr , fmt_params->vol_id); /* volume id */
200d4a4: c2 07 bd fc ld [ %fp + -516 ], %g1
memcpy(FAT_GET_ADDR_BR_VOLLAB(mbr),
200d4a8: 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 */
200d4ac: 84 08 40 02 and %g1, %g2, %g2
200d4b0: 85 30 a0 08 srl %g2, 8, %g2
200d4b4: c2 2f be 27 stb %g1, [ %fp + -473 ]
200d4b8: c4 2f be 28 stb %g2, [ %fp + -472 ]
200d4bc: 85 30 60 10 srl %g1, 0x10, %g2
200d4c0: 83 30 60 18 srl %g1, 0x18, %g1
200d4c4: c4 2f be 29 stb %g2, [ %fp + -471 ]
200d4c8: c2 2f be 2a stb %g1, [ %fp + -470 ]
memcpy(FAT_GET_ADDR_BR_VOLLAB(mbr),
200d4cc: 90 07 be 2b add %fp, -469, %o0
200d4d0: 40 00 35 89 call 201aaf4 <memcpy>
200d4d4: 94 10 20 0b mov 0xb, %o2
fmt_params->VolLabel,
FAT_BR_VOLLAB_SIZE);
memcpy(FAT_GET_ADDR_BR_FILSYSTYPE(mbr),
200d4d8: 13 00 80 98 sethi %hi(0x2026000), %o1
200d4dc: 80 a7 60 01 cmp %i5, 1
200d4e0: 12 80 00 04 bne 200d4f0 <msdos_format+0x8ac> <== NEVER TAKEN
200d4e4: 92 12 60 68 or %o1, 0x68, %o1
200d4e8: 13 00 80 98 sethi %hi(0x2026000), %o1
200d4ec: 92 12 60 58 or %o1, 0x58, %o1 ! 2026058 <_CPU_Trap_slot_template+0x48>
200d4f0: 10 80 00 1d b 200d564 <msdos_format+0x920>
200d4f4: 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);
200d4f8: 84 08 40 02 and %g1, %g2, %g2 <== NOT EXECUTED
200d4fc: 85 30 a0 08 srl %g2, 8, %g2 <== NOT EXECUTED
200d500: c2 2f be 24 stb %g1, [ %fp + -476 ] <== NOT EXECUTED
200d504: c4 2f be 25 stb %g2, [ %fp + -475 ] <== NOT EXECUTED
200d508: 85 30 60 10 srl %g1, 0x10, %g2 <== NOT EXECUTED
200d50c: 83 30 60 18 srl %g1, 0x18, %g1 <== NOT EXECUTED
200d510: 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 */
200d514: 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);
200d518: 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 */
200d51c: c2 2f be 32 stb %g1, [ %fp + -462 ] <== NOT EXECUTED
200d520: 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 */
200d524: 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*/
200d528: 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 */
200d52c: c2 2f be 33 stb %g1, [ %fp + -461 ] <== NOT EXECUTED
memset(FAT_GET_ADDR_BR_FAT32_RESERVED(mbr),0,FAT_BR_FAT32_RESERVED_SIZE);
200d530: 92 10 20 00 clr %o1 <== NOT EXECUTED
200d534: 94 10 20 0c mov 0xc, %o2 <== NOT EXECUTED
200d538: 40 00 35 ac call 201abe8 <memset> <== NOT EXECUTED
200d53c: 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);
200d540: 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);
200d544: 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);
200d548: 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);
200d54c: 90 07 be 47 add %fp, -441, %o0 <== NOT EXECUTED
200d550: 40 00 35 a6 call 201abe8 <memset> <== NOT EXECUTED
200d554: 94 10 20 0b mov 0xb, %o2 <== NOT EXECUTED
memcpy(FAT_GET_ADDR_BR_FAT32_FILSYSTYPE(mbr),
200d558: 13 00 80 98 sethi %hi(0x2026000), %o1 <== NOT EXECUTED
200d55c: 90 07 be 52 add %fp, -430, %o0 <== NOT EXECUTED
200d560: 92 12 61 20 or %o1, 0x120, %o1 <== NOT EXECUTED
200d564: 40 00 35 64 call 201aaf4 <memcpy>
200d568: 94 10 20 08 mov 8, %o2
FAT_BR_FILSYSTYPE_SIZE);
}
/*
* add boot record signature
*/
FAT_SET_BR_SIGNATURE(mbr, FAT_BR_SIGNATURE_VAL);
200d56c: 82 10 20 55 mov 0x55, %g1
200d570: c2 2f bf fe stb %g1, [ %fp + -2 ]
200d574: 82 10 3f aa mov -86, %g1
200d578: c2 2f bf ff stb %g1, [ %fp + -1 ]
/*
* add jump to boot loader at start of sector
*/
FAT_SET_VAL8(mbr,0,0xeb);
200d57c: 82 10 3f eb mov -21, %g1
200d580: c2 2f be 00 stb %g1, [ %fp + -512 ]
FAT_SET_VAL8(mbr,1,0x3c);
200d584: 82 10 20 3c mov 0x3c, %g1
200d588: c2 2f be 01 stb %g1, [ %fp + -511 ]
FAT_SET_VAL8(mbr,2,0x90);
200d58c: 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,
200d590: 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);
200d594: 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,
200d598: 92 10 20 02 mov 2, %o1
200d59c: 15 00 80 98 sethi %hi(0x2026000), %o2
200d5a0: 7f ff fd 31 call 200ca64 <msdos_format_printf>
200d5a4: 94 12 a1 30 or %o2, 0x130, %o2 ! 2026130 <_CPU_Trap_slot_template+0x120>
"write MRB sector\n");
ret_val = msdos_format_write_sec(fd,
200d5a8: d4 07 bd b0 ld [ %fp + -592 ], %o2
200d5ac: 90 10 00 1a mov %i2, %o0
200d5b0: 92 10 20 00 clr %o1
200d5b4: 7f ff fd 41 call 200cab8 <msdos_format_write_sec>
200d5b8: 96 07 be 00 add %fp, -512, %o3
0,
fmt_params.bytes_per_sector,
tmp_sec);
}
if ((ret_val == 0) &&
200d5bc: b6 92 20 00 orcc %o0, 0, %i3
200d5c0: 12 80 00 b5 bne 200d894 <msdos_format+0xc50> <== NEVER TAKEN
200d5c4: c2 07 bd d8 ld [ %fp + -552 ], %g1
200d5c8: 80 a0 60 00 cmp %g1, 0
200d5cc: 12 80 00 08 bne 200d5ec <msdos_format+0x9a8> <== NEVER TAKEN
200d5d0: 90 10 00 19 mov %i1, %o0
}
/*
* for FAT32: initialize info sector on disk
*/
if ((ret_val == 0) &&
(fmt_params.fsinfo_sec != 0)) {
200d5d4: fa 07 bd dc ld [ %fp + -548 ], %i5
}
}
/*
* for FAT32: initialize info sector on disk
*/
if ((ret_val == 0) &&
200d5d8: 80 a7 60 00 cmp %i5, 0
200d5dc: 22 80 00 37 be,a 200d6b8 <msdos_format+0xa74> <== ALWAYS TAKEN
200d5e0: d2 07 bd c0 ld [ %fp + -576 ], %o1
\*=========================================================================*/
{
/*
* clear fsinfo sector data
*/
memset(fsinfo,0,FAT_TOTAL_FSINFO_SIZE);
200d5e4: 10 80 00 10 b 200d624 <msdos_format+0x9e0> <== NOT EXECUTED
200d5e8: 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,
200d5ec: 92 10 20 02 mov 2, %o1 <== NOT EXECUTED
200d5f0: 15 00 80 98 sethi %hi(0x2026000), %o2 <== NOT EXECUTED
200d5f4: 7f ff fd 1c call 200ca64 <msdos_format_printf> <== NOT EXECUTED
200d5f8: 94 12 a1 48 or %o2, 0x148, %o2 ! 2026148 <_CPU_Trap_slot_template+0x138><== NOT EXECUTED
"write back up MRB sector\n");
ret_val = msdos_format_write_sec(fd,
200d5fc: d2 07 bd d8 ld [ %fp + -552 ], %o1 <== NOT EXECUTED
200d600: d4 07 bd b0 ld [ %fp + -592 ], %o2 <== NOT EXECUTED
200d604: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
200d608: 7f ff fd 2c call 200cab8 <msdos_format_write_sec> <== NOT EXECUTED
200d60c: 96 07 be 00 add %fp, -512, %o3 <== NOT EXECUTED
}
}
/*
* for FAT32: initialize info sector on disk
*/
if ((ret_val == 0) &&
200d610: b6 92 20 00 orcc %o0, 0, %i3 <== NOT EXECUTED
200d614: 22 bf ff f1 be,a 200d5d8 <msdos_format+0x994> <== NOT EXECUTED
200d618: 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) {
200d61c: 10 80 00 9f b 200d898 <msdos_format+0xc54> <== NOT EXECUTED
200d620: 80 a6 bf ff cmp %i2, -1 <== NOT EXECUTED
\*=========================================================================*/
{
/*
* clear fsinfo sector data
*/
memset(fsinfo,0,FAT_TOTAL_FSINFO_SIZE);
200d624: 94 10 22 00 mov 0x200, %o2 <== NOT EXECUTED
200d628: 40 00 35 70 call 201abe8 <memset> <== NOT EXECUTED
200d62c: 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 );
200d630: 82 10 20 52 mov 0x52, %g1 <== NOT EXECUTED
200d634: c2 2f be 00 stb %g1, [ %fp + -512 ] <== NOT EXECUTED
200d638: c2 2f be 01 stb %g1, [ %fp + -511 ] <== NOT EXECUTED
200d63c: 82 10 20 61 mov 0x61, %g1 <== NOT EXECUTED
200d640: c2 2f be 02 stb %g1, [ %fp + -510 ] <== NOT EXECUTED
FAT_SET_FSINFO_STRUC_SIGNATURE(fsinfo,FAT_FSINFO_STRUC_SIGNATURE_VALUE);
200d644: c2 2f bf e7 stb %g1, [ %fp + -25 ] <== NOT EXECUTED
FAT_SET_FSINFO_TRAIL_SIGNATURE(fsinfo,FAT_FSINFO_TRAIL_SIGNATURE_VALUE);
200d648: 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,
200d64c: 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);
200d650: c2 2f bf fe stb %g1, [ %fp + -2 ] <== NOT EXECUTED
200d654: 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 );
200d658: 84 10 20 41 mov 0x41, %g2 <== NOT EXECUTED
FAT_SET_FSINFO_STRUC_SIGNATURE(fsinfo,FAT_FSINFO_STRUC_SIGNATURE_VALUE);
200d65c: 86 10 20 72 mov 0x72, %g3 <== NOT EXECUTED
FAT_SET_FSINFO_TRAIL_SIGNATURE(fsinfo,FAT_FSINFO_TRAIL_SIGNATURE_VALUE);
200d660: 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,
200d664: 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 );
200d668: c4 2f be 03 stb %g2, [ %fp + -509 ] <== NOT EXECUTED
FAT_SET_FSINFO_STRUC_SIGNATURE(fsinfo,FAT_FSINFO_STRUC_SIGNATURE_VALUE);
200d66c: c6 2f bf e4 stb %g3, [ %fp + -28 ] <== NOT EXECUTED
200d670: c6 2f bf e5 stb %g3, [ %fp + -27 ] <== NOT EXECUTED
200d674: 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,
200d678: c2 2f bf e8 stb %g1, [ %fp + -24 ] <== NOT EXECUTED
200d67c: c2 2f bf e9 stb %g1, [ %fp + -23 ] <== NOT EXECUTED
200d680: c2 2f bf ea stb %g1, [ %fp + -22 ] <== NOT EXECUTED
200d684: c2 2f bf eb stb %g1, [ %fp + -21 ] <== NOT EXECUTED
0xffffffff);
FAT_SET_FSINFO_NEXT_FREE_CLUSTER (fsinfo+FAT_FSI_INFO,
200d688: c2 2f bf ec stb %g1, [ %fp + -20 ] <== NOT EXECUTED
200d68c: c2 2f bf ed stb %g1, [ %fp + -19 ] <== NOT EXECUTED
200d690: c2 2f bf ee stb %g1, [ %fp + -18 ] <== NOT EXECUTED
200d694: 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,
200d698: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
200d69c: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
200d6a0: 7f ff fd 06 call 200cab8 <msdos_format_write_sec> <== NOT EXECUTED
200d6a4: 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) {
200d6a8: b6 92 20 00 orcc %o0, 0, %i3 <== NOT EXECUTED
200d6ac: 12 80 00 7b bne 200d898 <msdos_format+0xc54> <== NOT EXECUTED
200d6b0: 80 a6 bf ff cmp %i2, -1 <== NOT EXECUTED
ret_val = msdos_format_fill_sectors
(rqdata,
200d6b4: d2 07 bd c0 ld [ %fp + -576 ], %o1 <== NOT EXECUTED
200d6b8: d0 0f bd e0 ldub [ %fp + -544 ], %o0
200d6bc: 40 00 56 5d call 2023030 <.umul>
200d6c0: 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
200d6c4: d8 07 bd b0 ld [ %fp + -592 ], %o4
(rqdata,
200d6c8: 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
200d6cc: 92 10 00 1a mov %i2, %o1
200d6d0: 90 10 00 19 mov %i1, %o0
200d6d4: 94 10 00 1d mov %i5, %o2
200d6d8: 7f ff fd 10 call 200cb18 <msdos_format_fill_sectors>
200d6dc: 9a 10 20 00 clr %o5
}
/*
* clear/init root directory
* -> write all directory sectors as 0x00
*/
if (ret_val == 0) {
200d6e0: b6 92 20 00 orcc %o0, 0, %i3
200d6e4: 12 80 00 6c bne 200d894 <msdos_format+0xc50> <== NEVER TAKEN
200d6e8: d4 1f bd d0 ldd [ %fp + -560 ], %o2
ret_val = msdos_format_fill_sectors
200d6ec: d8 07 bd b0 ld [ %fp + -592 ], %o4
200d6f0: 90 10 00 19 mov %i1, %o0
200d6f4: 92 10 00 1a mov %i2, %o1
200d6f8: 7f ff fd 08 call 200cb18 <msdos_format_fill_sectors>
200d6fc: 9a 10 20 00 clr %o5
0x00);
}
/*
* write volume label to first entry of directory
*/
if ((ret_val == 0) && fmt_params.VolLabel_present) {
200d700: b6 92 20 00 orcc %o0, 0, %i3
200d704: 12 80 00 64 bne 200d894 <msdos_format+0xc50> <== NEVER TAKEN
200d708: c2 0f bd f8 ldub [ %fp + -520 ], %g1
200d70c: 80 a0 60 00 cmp %g1, 0
200d710: 12 80 00 08 bne 200d730 <msdos_format+0xaec>
200d714: 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){
200d718: c2 0f bd f8 ldub [ %fp + -520 ], %g1
200d71c: 80 a0 60 00 cmp %g1, 0
200d720: 02 80 00 5e be 200d898 <msdos_format+0xc54>
200d724: 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));
200d728: 10 80 00 15 b 200d77c <msdos_format+0xb38>
200d72c: 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));
200d730: 94 10 22 00 mov 0x200, %o2
200d734: 40 00 35 2d call 201abe8 <memset>
200d738: 90 07 be 00 add %fp, -512, %o0
memcpy(MSDOS_DIR_NAME(tmp_sec),fmt_params.VolLabel,MSDOS_SHORT_NAME_LEN);
200d73c: 92 07 bd ec add %fp, -532, %o1
200d740: 94 10 20 0b mov 0xb, %o2
200d744: 40 00 34 ec call 201aaf4 <memcpy>
200d748: 90 07 be 00 add %fp, -512, %o0
*MSDOS_DIR_ATTR(tmp_sec) = MSDOS_ATTR_VOLUME_ID;
ret_val = msdos_format_write_sec
200d74c: d2 07 bd d0 ld [ %fp + -560 ], %o1
200d750: 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;
200d754: 82 10 20 08 mov 8, %g1
ret_val = msdos_format_write_sec
200d758: 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;
200d75c: c2 2f be 0b stb %g1, [ %fp + -501 ]
ret_val = msdos_format_write_sec
200d760: 7f ff fc d6 call 200cab8 <msdos_format_write_sec>
200d764: 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){
200d768: 80 a2 20 00 cmp %o0, 0
200d76c: 02 bf ff ec be 200d71c <msdos_format+0xad8> <== ALWAYS TAKEN
200d770: c2 0f bd f8 ldub [ %fp + -520 ], %g1
200d774: 10 80 00 48 b 200d894 <msdos_format+0xc50> <== NOT EXECUTED
200d778: 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));
200d77c: 92 10 20 00 clr %o1
200d780: 40 00 35 1a call 201abe8 <memset>
200d784: 94 10 22 00 mov 0x200, %o2
switch(fmt_params.fattype) {
200d788: c2 0f bd e2 ldub [ %fp + -542 ], %g1
200d78c: 80 a0 60 02 cmp %g1, 2
200d790: 02 80 00 0c be 200d7c0 <msdos_format+0xb7c> <== NEVER TAKEN
200d794: 80 a0 60 04 cmp %g1, 4
200d798: 02 80 00 12 be 200d7e0 <msdos_format+0xb9c> <== NEVER TAKEN
200d79c: 80 a0 60 01 cmp %g1, 1
200d7a0: 12 80 00 1d bne 200d814 <msdos_format+0xbd0> <== NEVER TAKEN
200d7a4: 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));
200d7a8: 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)));
200d7ac: 82 10 3f 8f mov -113, %g1
200d7b0: 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));
200d7b4: 82 10 3f ff mov -1, %g1
break;
200d7b8: 10 80 00 1b b 200d824 <msdos_format+0xbe0>
200d7bc: 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);
200d7c0: 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);
200d7c4: 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);
200d7c8: 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);
200d7cc: 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);
200d7d0: 82 10 3f ff mov -1, %g1 <== NOT EXECUTED
200d7d4: c2 2f be 01 stb %g1, [ %fp + -511 ] <== NOT EXECUTED
/* FAT entry 1: EOC */
FAT_SET_VAL16(tmp_sec,2,FAT_FAT16_EOC);
break;
200d7d8: 10 80 00 13 b 200d824 <msdos_format+0xbe0> <== NOT EXECUTED
200d7dc: 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);
200d7e0: c2 0f bd e1 ldub [ %fp + -543 ], %g1 <== NOT EXECUTED
/* FAT entry 1: EOC */
FAT_SET_VAL32(tmp_sec,4,FAT_FAT32_EOC);
200d7e4: 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);
200d7e8: c2 2f be 00 stb %g1, [ %fp + -512 ] <== NOT EXECUTED
200d7ec: 82 10 3f ff mov -1, %g1 <== NOT EXECUTED
/* FAT entry 1: EOC */
FAT_SET_VAL32(tmp_sec,4,FAT_FAT32_EOC);
200d7f0: 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);
200d7f4: c2 2f be 01 stb %g1, [ %fp + -511 ] <== NOT EXECUTED
200d7f8: c2 2f be 02 stb %g1, [ %fp + -510 ] <== NOT EXECUTED
200d7fc: c2 2f be 03 stb %g1, [ %fp + -509 ] <== NOT EXECUTED
/* FAT entry 1: EOC */
FAT_SET_VAL32(tmp_sec,4,FAT_FAT32_EOC);
200d800: c2 2f be 05 stb %g1, [ %fp + -507 ] <== NOT EXECUTED
200d804: c2 2f be 06 stb %g1, [ %fp + -506 ] <== NOT EXECUTED
200d808: 82 10 20 0f mov 0xf, %g1 <== NOT EXECUTED
break;
200d80c: 10 80 00 06 b 200d824 <msdos_format+0xbe0> <== NOT EXECUTED
200d810: c2 2f be 07 stb %g1, [ %fp + -505 ] <== NOT EXECUTED
default:
ret_val = -1;
errno = EINVAL;
200d814: 40 00 32 03 call 201a020 <__errno> <== NOT EXECUTED
200d818: b6 10 3f ff mov -1, %i3 <== NOT EXECUTED
200d81c: 82 10 20 16 mov 0x16, %g1 <== NOT EXECUTED
200d820: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
}
if (fmt_params.fattype == FAT_FAT32) {
200d824: c2 0f bd e2 ldub [ %fp + -542 ], %g1
200d828: 80 a0 60 04 cmp %g1, 4
200d82c: 12 80 00 14 bne 200d87c <msdos_format+0xc38> <== ALWAYS TAKEN
200d830: 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);
200d834: 82 10 3f f8 mov -8, %g1 <== NOT EXECUTED
200d838: c2 2f be 08 stb %g1, [ %fp + -504 ] <== NOT EXECUTED
200d83c: 82 10 3f ff mov -1, %g1 <== NOT EXECUTED
200d840: c2 2f be 09 stb %g1, [ %fp + -503 ] <== NOT EXECUTED
200d844: c2 2f be 0a stb %g1, [ %fp + -502 ] <== NOT EXECUTED
200d848: 82 10 20 0f mov 0xf, %g1 <== NOT EXECUTED
200d84c: 10 80 00 0c b 200d87c <msdos_format+0xc38> <== NOT EXECUTED
200d850: 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),
200d854: 40 00 55 f7 call 2023030 <.umul>
200d858: 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,
200d85c: 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
200d860: d4 07 bd b0 ld [ %fp + -592 ], %o2
(fd,
200d864: 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
200d868: 96 07 be 00 add %fp, -512, %o3
200d86c: 90 10 00 1a mov %i2, %o0
200d870: 7f ff fc 92 call 200cab8 <msdos_format_write_sec>
200d874: ba 07 60 01 inc %i5
200d878: 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);
200d87c: 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;
200d880: 80 a7 40 01 cmp %i5, %g1
200d884: 16 80 00 04 bge 200d894 <msdos_format+0xc50>
200d888: 80 a6 e0 00 cmp %i3, 0
(i < fmt_params.fat_num) && (ret_val == 0);
200d88c: 02 bf ff f2 be 200d854 <msdos_format+0xc10> <== ALWAYS TAKEN
200d890: d2 07 bd c0 ld [ %fp + -576 ], %o1
/*
* cleanup:
* sync and unlock disk
* free any data structures (not needed now)
*/
if (fd != -1) {
200d894: 80 a6 bf ff cmp %i2, -1
200d898: 22 80 00 42 be,a 200d9a0 <msdos_format+0xd5c> <== NEVER TAKEN
200d89c: b0 10 00 1b mov %i3, %i0 <== NOT EXECUTED
close(fd);
200d8a0: 7f ff da 99 call 2004304 <close>
200d8a4: 90 10 00 1a mov %i2, %o0
}
return ret_val;
}
200d8a8: 81 c7 e0 08 ret
200d8ac: 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));
200d8b0: 94 10 20 50 mov 0x50, %o2
200d8b4: 40 00 34 cd call 201abe8 <memset>
200d8b8: 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);
200d8bc: 90 10 00 1a mov %i2, %o0
200d8c0: 3b 10 01 10 sethi %hi(0x40044000), %i5
200d8c4: 94 07 bd b0 add %fp, -592, %o2
200d8c8: 7f ff db be call 20047c0 <ioctl>
200d8cc: 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) {
200d8d0: b0 92 20 00 orcc %o0, 0, %i0
200d8d4: 12 bf fe 3d bne 200d1c8 <msdos_format+0x584> <== NEVER TAKEN
200d8d8: 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);
200d8dc: 10 bf fd 08 b 200ccfc <msdos_format+0xb8>
200d8e0: 90 10 00 1a mov %i2, %o0
ret_val = EINVAL;
}
}
if (ret_val == 0)
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
200d8e4: d6 0f bd e0 ldub [ %fp + -544 ], %o3
200d8e8: 90 10 00 19 mov %i1, %o0
200d8ec: 92 10 20 02 mov 2, %o1
200d8f0: 15 00 80 98 sethi %hi(0x2026000), %o2
200d8f4: 7f ff fc 5c call 200ca64 <msdos_format_printf>
200d8f8: 94 12 a1 68 or %o2, 0x168, %o2 ! 2026168 <_CPU_Trap_slot_template+0x158>
/*
* determine FAT type and sectors per cluster
* depends on
*/
if (ret_val == 0) {
fmt_params->sectors_per_cluster = 1;
200d8fc: 82 10 20 01 mov 1, %g1
if ((rqdata != NULL) &&
200d900: 80 a6 60 00 cmp %i1, 0
200d904: 12 bf fd 21 bne 200cd88 <msdos_format+0x144>
200d908: 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;
200d90c: 10 bf fd 39 b 200cdf0 <msdos_format+0x1ac>
200d910: 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) &&
200d914: 32 bf fe 63 bne,a 200d2a0 <msdos_format+0x65c>
200d918: 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 */
200d91c: 10 bf fe 67 b 200d2b8 <msdos_format+0x674>
200d920: 03 00 80 95 sethi %hi(0x2025400), %g1
{
int ret_val = 0;
int rc;
struct timeval time_value;
rc = rtems_clock_get_tod_timeval(&time_value);
200d924: 40 00 1a 4b call 2014250 <rtems_clock_get_tod_timeval>
200d928: 90 07 be 00 add %fp, -512, %o0
if (rc == RTEMS_SUCCESSFUL) {
200d92c: 80 a2 20 00 cmp %o0, 0
200d930: 02 bf fe 7a be 200d318 <msdos_format+0x6d4> <== NEVER TAKEN
200d934: c2 07 be 00 ld [ %fp + -512 ], %g1
200d938: 30 bf fe 7b b,a 200d324 <msdos_format+0x6e0>
}
/*
* Phuuu.... That's it.
*/
if (ret_val != 0) {
rtems_set_errno_and_return_minus_one(ret_val);
200d93c: 40 00 31 b9 call 201a020 <__errno> <== NOT EXECUTED
200d940: b6 10 3f ff mov -1, %i3 <== NOT EXECUTED
200d944: 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) &&
200d948: 10 bf fe 7b b 200d334 <msdos_format+0x6f0> <== NOT EXECUTED
200d94c: 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)) {
200d950: 92 07 be 00 add %fp, -512, %o1
200d954: 40 00 17 2c call 2013604 <read>
200d958: 94 10 00 1d mov %i5, %o2
200d95c: 80 a2 20 00 cmp %o0, 0
200d960: 06 80 00 0e bl 200d998 <msdos_format+0xd54> <== NEVER TAKEN
200d964: 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,
200d968: 92 10 20 02 mov 2, %o1
200d96c: 15 00 80 98 sethi %hi(0x2026000), %o2
200d970: 7f ff fc 3d call 200ca64 <msdos_format_printf>
200d974: 94 12 a1 80 or %o2, 0x180, %o2 ! 2026180 <_CPU_Trap_slot_template+0x170>
{
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) {
200d978: fa 07 bd b4 ld [ %fp + -588 ], %i5
200d97c: 03 00 00 3f sethi %hi(0xfc00), %g1
200d980: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff <PROM_START+0xffff>
200d984: 80 a7 40 01 cmp %i5, %g1
200d988: 18 bf fe 90 bgu 200d3c8 <msdos_format+0x784> <== NEVER TAKEN
200d98c: b8 10 20 00 clr %i4
200d990: 10 bf fe 8d b 200d3c4 <msdos_format+0x780>
200d994: b8 10 00 1d mov %i5, %i4
}
}
}
}
if (ret_val == 0) {
200d998: 10 bf ff bf b 200d894 <msdos_format+0xc50> <== NOT EXECUTED
200d99c: b6 10 3f ff mov -1, %i3 <== NOT EXECUTED
if (fd != -1) {
close(fd);
}
return ret_val;
}
200d9a0: 81 c7 e0 08 ret <== NOT EXECUTED
200d9a4: 81 e8 00 00 restore <== NOT EXECUTED
0200cb18 <msdos_format_fill_sectors>:
)
/*-------------------------------------------------------------------------*\
| Return Value: |
| 0, if success, -1 and errno if failed |
\*=========================================================================*/
{
200cb18: 9d e3 bf a0 save %sp, -96, %sp
/*
* allocate and fill buffer
*/
if (ret_val == 0) {
fill_buffer = malloc(sector_size);
200cb1c: 7f ff e0 4e call 2004c54 <malloc>
200cb20: 90 10 00 1c mov %i4, %o0
if (fill_buffer == NULL) {
200cb24: a0 92 20 00 orcc %o0, 0, %l0
200cb28: 12 80 00 07 bne 200cb44 <msdos_format_fill_sectors+0x2c> <== ALWAYS TAKEN
200cb2c: 92 10 00 1d mov %i5, %o1
errno = ENOMEM;
200cb30: 40 00 35 3c call 201a020 <__errno> <== NOT EXECUTED
200cb34: ba 10 3f ff mov -1, %i5 <== NOT EXECUTED
200cb38: 82 10 20 0c mov 0xc, %g1 <== NOT EXECUTED
200cb3c: 10 80 00 05 b 200cb50 <msdos_format_fill_sectors+0x38> <== NOT EXECUTED
200cb40: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
ret_val = -1;
}
else {
memset(fill_buffer,fill_byte,sector_size);
200cb44: 94 10 00 1c mov %i4, %o2
200cb48: 40 00 38 28 call 201abe8 <memset>
200cb4c: ba 10 20 00 clr %i5
}
}
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
200cb50: 90 10 00 18 mov %i0, %o0
200cb54: 92 10 20 02 mov 2, %o1
200cb58: 15 00 80 98 sethi %hi(0x2026000), %o2
200cb5c: 7f ff ff c2 call 200ca64 <msdos_format_printf>
200cb60: 94 12 a0 20 or %o2, 0x20, %o2 ! 2026020 <_CPU_Trap_slot_template+0x10>
}
/*=========================================================================* \
| Function: |
\*-------------------------------------------------------------------------*/
static int msdos_format_fill_sectors
200cb64: 85 2e e0 02 sll %i3, 2, %g2
200cb68: 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, ".");
200cb6c: 2b 00 80 97 sethi %hi(0x2025c00), %l5
}
/*=========================================================================* \
| Function: |
\*-------------------------------------------------------------------------*/
static int msdos_format_fill_sectors
200cb70: 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) &&
200cb74: a4 10 20 00 clr %l2
}
/*=========================================================================* \
| Function: |
\*-------------------------------------------------------------------------*/
static int msdos_format_fill_sectors
200cb78: 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;
200cb7c: a2 10 3f ff mov -1, %l1
}
/*=========================================================================* \
| Function: |
\*-------------------------------------------------------------------------*/
static int msdos_format_fill_sectors
200cb80: a6 00 40 13 add %g1, %l3, %l3
200cb84: 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) &&
200cb88: 10 80 00 15 b 200cbdc <msdos_format_fill_sectors+0xc4>
200cb8c: aa 15 61 c8 or %l5, 0x1c8, %l5
(sector_cnt > 0)) {
int percent = (sector_cnt * 100) / total_sectors;
200cb90: 40 00 59 62 call 2023118 <.udiv>
200cb94: 92 10 00 1b mov %i3, %o1
if (percent != last_percent) {
200cb98: 80 a2 00 11 cmp %o0, %l1
200cb9c: 02 80 00 08 be 200cbbc <msdos_format_fill_sectors+0xa4>
200cba0: 80 8a 20 01 btst 1, %o0
if ((percent & 1) == 0)
200cba4: 12 80 00 06 bne 200cbbc <msdos_format_fill_sectors+0xa4>
200cba8: a2 10 00 08 mov %o0, %l1
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL, ".");
200cbac: 90 10 00 18 mov %i0, %o0
200cbb0: 92 10 20 02 mov 2, %o1
200cbb4: 7f ff ff ac call 200ca64 <msdos_format_printf>
200cbb8: 94 10 00 15 mov %l5, %o2
last_percent = percent;
}
ret_val = msdos_format_write_sec(fd,start_sector,sector_size,fill_buffer);
200cbbc: 92 10 00 1a mov %i2, %o1
200cbc0: 90 10 00 19 mov %i1, %o0
200cbc4: 94 10 00 1c mov %i4, %o2
200cbc8: 96 10 00 10 mov %l0, %o3
200cbcc: 7f ff ff bb call 200cab8 <msdos_format_write_sec>
200cbd0: b4 06 a0 01 inc %i2
200cbd4: a4 04 bf 9c add %l2, -100, %l2
200cbd8: 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) &&
200cbdc: 80 a5 00 1a cmp %l4, %i2
200cbe0: 02 80 00 04 be 200cbf0 <msdos_format_fill_sectors+0xd8>
200cbe4: 80 a7 60 00 cmp %i5, 0
200cbe8: 02 bf ff ea be 200cb90 <msdos_format_fill_sectors+0x78> <== ALWAYS TAKEN
200cbec: 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");
200cbf0: 90 10 00 18 mov %i0, %o0
200cbf4: 92 10 20 02 mov 2, %o1
200cbf8: 15 00 80 95 sethi %hi(0x2025400), %o2
200cbfc: 7f ff ff 9a call 200ca64 <msdos_format_printf>
200cc00: 94 12 a2 10 or %o2, 0x210, %o2 ! 2025610 <rtems_filesystem_table+0x454>
if (ret_val)
200cc04: 80 a7 60 00 cmp %i5, 0
200cc08: 02 80 00 09 be 200cc2c <msdos_format_fill_sectors+0x114> <== ALWAYS TAKEN
200cc0c: 80 a4 20 00 cmp %l0, 0
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_INFO,
200cc10: 15 00 80 98 sethi %hi(0x2026000), %o2 <== NOT EXECUTED
200cc14: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
200cc18: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
200cc1c: 94 12 a0 30 or %o2, 0x30, %o2 <== NOT EXECUTED
200cc20: 7f ff ff 91 call 200ca64 <msdos_format_printf> <== NOT EXECUTED
200cc24: 96 10 00 1a mov %i2, %o3 <== NOT EXECUTED
"filling error on sector: %d\n", start_sector);
/*
* cleanup
*/
if (fill_buffer != NULL) {
200cc28: 80 a4 20 00 cmp %l0, 0 <== NOT EXECUTED
200cc2c: 02 80 00 04 be 200cc3c <msdos_format_fill_sectors+0x124> <== NEVER TAKEN
200cc30: 01 00 00 00 nop
free(fill_buffer);
200cc34: 7f ff de 72 call 20045fc <free>
200cc38: 90 10 00 10 mov %l0, %o0
fill_buffer = NULL;
}
return ret_val;
}
200cc3c: 81 c7 e0 08 ret
200cc40: 91 e8 00 1d restore %g0, %i5, %o0
0200ca64 <msdos_format_printf>:
*/
static void
msdos_format_printf (const msdos_format_request_param_t *rqdata,
int info_level,
const char *format, ...)
{
200ca64: 9d e3 bf 98 save %sp, -104, %sp
va_list args;
va_start (args, format);
200ca68: 94 07 a0 50 add %fp, 0x50, %o2
200ca6c: f6 27 a0 50 st %i3, [ %fp + 0x50 ]
200ca70: f8 27 a0 54 st %i4, [ %fp + 0x54 ]
200ca74: fa 27 a0 58 st %i5, [ %fp + 0x58 ]
if (rqdata != NULL && rqdata->info_level >= info_level)
200ca78: 80 a6 20 00 cmp %i0, 0
200ca7c: 02 80 00 0d be 200cab0 <msdos_format_printf+0x4c>
200ca80: d4 27 bf fc st %o2, [ %fp + -4 ]
200ca84: c2 06 20 1c ld [ %i0 + 0x1c ], %g1
200ca88: 80 a0 40 19 cmp %g1, %i1
200ca8c: 06 80 00 09 bl 200cab0 <msdos_format_printf+0x4c> <== ALWAYS TAKEN
200ca90: 3b 00 80 9e sethi %hi(0x2027800), %i5
{
vfprintf (stdout, format, args);
200ca94: c2 07 63 c0 ld [ %i5 + 0x3c0 ], %g1 ! 2027bc0 <_impure_ptr><== NOT EXECUTED
200ca98: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED
200ca9c: 40 00 4b 7b call 201f888 <vfprintf> <== NOT EXECUTED
200caa0: d0 00 60 08 ld [ %g1 + 8 ], %o0 <== NOT EXECUTED
fflush (stdout);
200caa4: c2 07 63 c0 ld [ %i5 + 0x3c0 ], %g1 <== NOT EXECUTED
200caa8: 40 00 36 61 call 201a42c <fflush> <== NOT EXECUTED
200caac: d0 00 60 08 ld [ %g1 + 8 ], %o0 <== NOT EXECUTED
200cab0: 81 c7 e0 08 ret
200cab4: 81 e8 00 00 restore
0200cab8 <msdos_format_write_sec>:
)
/*-------------------------------------------------------------------------*\
| Return Value: |
| 0, if success, -1 and errno if failed |
\*=========================================================================*/
{
200cab8: 9d e3 bf a0 save %sp, -96, %sp
int ret_val = 0;
if (0 > lseek(fd,((off_t)start_sector)*sector_size,SEEK_SET)) {
200cabc: 94 10 20 00 clr %o2
200cac0: 96 10 00 1a mov %i2, %o3
200cac4: 90 10 20 00 clr %o0
200cac8: 40 00 5a ec call 2023678 <__muldi3>
200cacc: 92 10 00 19 mov %i1, %o1
200cad0: 84 10 00 08 mov %o0, %g2
200cad4: 86 10 00 09 mov %o1, %g3
200cad8: 90 10 00 18 mov %i0, %o0
200cadc: 92 10 00 02 mov %g2, %o1
200cae0: 94 10 00 03 mov %g3, %o2
200cae4: 7f ff df d7 call 2004a40 <lseek>
200cae8: 96 10 20 00 clr %o3
200caec: 80 a2 20 00 cmp %o0, 0
200caf0: 16 80 00 04 bge 200cb00 <msdos_format_write_sec+0x48> <== ALWAYS TAKEN
200caf4: 90 10 00 18 mov %i0, %o0
200caf8: 81 c7 e0 08 ret <== NOT EXECUTED
200cafc: 91 e8 3f ff restore %g0, -1, %o0 <== NOT EXECUTED
ret_val = -1;
}
if (ret_val == 0) {
if (0 > write(fd,buffer,sector_size)) {
200cb00: 92 10 00 1b mov %i3, %o1
200cb04: 7f ff ee e6 call 200869c <write>
200cb08: 94 10 00 1a mov %i2, %o2
200cb0c: b1 3a 20 1f sra %o0, 0x1f, %i0
ret_val = -1;
}
}
return ret_val;
}
200cb10: 81 c7 e0 08 ret
200cb14: 81 e8 00 00 restore
0201771c <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
)
{
201771c: 9d e3 bf 50 save %sp, -176, %sp
int rc = RC_OK;
msdos_fs_info_t *fs_info = mt_entry->fs_info;
2017720: f8 06 20 08 ld [ %i0 + 8 ], %i4
fat_file_fd_t *fat_fd = NULL;
2017724: 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);
2017728: 90 10 00 1c mov %i4, %o0
201772c: 92 10 00 1a mov %i2, %o1
2017730: 7f ff e5 5a call 2010c98 <fat_file_open>
2017734: 94 07 bf bc add %fp, -68, %o2
if (rc != RC_OK)
2017738: ba 92 20 00 orcc %o0, 0, %i5
201773c: 32 80 00 a5 bne,a 20179d0 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x2b4><== NEVER TAKEN
2017740: b0 10 00 1d mov %i5, %i0 <== NOT EXECUTED
return rc;
fat_fd->cln = cln;
2017744: d2 07 bf bc ld [ %fp + -68 ], %o1
fat_fd->fat_file_type = FAT_DIRECTORY;
fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
2017748: 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;
201774c: f2 22 60 1c st %i1, [ %o1 + 0x1c ]
fat_fd->fat_file_type = FAT_DIRECTORY;
2017750: c0 22 60 10 clr [ %o1 + 0x10 ]
fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
2017754: c2 22 60 14 st %g1, [ %o1 + 0x14 ]
fat_fd->map.file_cln = 0;
2017758: c0 22 60 34 clr [ %o1 + 0x34 ]
fat_fd->map.disk_cln = fat_fd->cln;
201775c: f2 22 60 38 st %i1, [ %o1 + 0x38 ]
rc = fat_file_size(&fs_info->fat, fat_fd);
2017760: 7f ff e7 f5 call 2011734 <fat_file_size>
2017764: 90 10 00 1c mov %i4, %o0
if (rc != RC_OK)
2017768: ba 92 20 00 orcc %o0, 0, %i5
201776c: 22 80 00 04 be,a 201777c <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x60><== ALWAYS TAKEN
2017770: 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);
2017774: 10 80 00 19 b 20177d8 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0xbc><== NOT EXECUTED
2017778: 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);
201777c: 92 10 20 00 clr %o1
2017780: 90 10 00 1d mov %i5, %o0
2017784: 40 00 0d 19 call 201abe8 <memset>
2017788: 94 10 20 20 mov 0x20, %o2
msdos_long_to_short(".", 1, dot_node, MSDOS_SHORT_NAME_LEN);
201778c: 94 10 00 1d mov %i5, %o2
2017790: 33 00 80 97 sethi %hi(0x2025c00), %i1
2017794: 92 10 20 01 mov 1, %o1
2017798: 96 10 20 0b mov 0xb, %o3
201779c: 7f ff fb 7a call 2016584 <msdos_long_to_short>
20177a0: 90 16 61 c8 or %i1, 0x1c8, %o0
rc = msdos_find_name_in_fat_file(mt_entry, fat_fd, false, ".", 1,
20177a4: d2 07 bf bc ld [ %fp + -68 ], %o1
20177a8: fa 23 a0 60 st %i5, [ %sp + 0x60 ]
20177ac: f4 23 a0 5c st %i2, [ %sp + 0x5c ]
20177b0: 90 10 00 18 mov %i0, %o0
20177b4: 94 10 20 00 clr %o2
20177b8: 96 16 61 c8 or %i1, 0x1c8, %o3
20177bc: 98 10 20 01 mov 1, %o4
20177c0: 7f ff fd 1b call 2016c2c <msdos_find_name_in_fat_file>
20177c4: 9a 10 20 01 mov 1, %o5
MSDOS_NAME_SHORT, dir_pos, dot_node);
if (rc != RC_OK)
20177c8: ba 92 20 00 orcc %o0, 0, %i5
20177cc: 22 80 00 05 be,a 20177e0 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0xc4><== ALWAYS TAKEN
20177d0: ba 07 bf e0 add %fp, -32, %i5
{
fat_file_close(&fs_info->fat, fat_fd);
20177d4: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
20177d8: 10 80 00 77 b 20179b4 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x298><== NOT EXECUTED
20177dc: 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);
20177e0: 92 10 20 00 clr %o1
20177e4: 90 10 00 1d mov %i5, %o0
20177e8: 40 00 0d 00 call 201abe8 <memset>
20177ec: 94 10 20 20 mov 0x20, %o2
msdos_long_to_short("..", 2, dotdot_node, MSDOS_SHORT_NAME_LEN);
20177f0: 94 10 00 1d mov %i5, %o2
20177f4: 33 00 80 99 sethi %hi(0x2026400), %i1
20177f8: 92 10 20 02 mov 2, %o1
20177fc: 96 10 20 0b mov 0xb, %o3
2017800: 7f ff fb 61 call 2016584 <msdos_long_to_short>
2017804: 90 16 60 50 or %i1, 0x50, %o0
rc = msdos_find_name_in_fat_file(mt_entry, fat_fd, false, "..", 2,
2017808: d2 07 bf bc ld [ %fp + -68 ], %o1
201780c: fa 23 a0 60 st %i5, [ %sp + 0x60 ]
2017810: f4 23 a0 5c st %i2, [ %sp + 0x5c ]
2017814: 90 10 00 18 mov %i0, %o0
2017818: 94 10 20 00 clr %o2
201781c: 96 16 60 50 or %i1, 0x50, %o3
2017820: 98 10 20 02 mov 2, %o4
2017824: 7f ff fd 02 call 2016c2c <msdos_find_name_in_fat_file>
2017828: 9a 10 20 01 mov 1, %o5
MSDOS_NAME_SHORT, dir_pos,
dotdot_node);
if (rc != RC_OK)
201782c: ba 92 20 00 orcc %o0, 0, %i5
2017830: 02 80 00 04 be 2017840 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x124><== ALWAYS TAKEN
2017834: 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);
2017838: 10 80 00 5f b 20179b4 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x298><== NOT EXECUTED
201783c: 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);
2017840: e0 17 bf da lduh [ %fp + -38 ], %l0
2017844: e2 17 bf d4 lduh [ %fp + -44 ], %l1
/* close fat-file corresponded to ".." directory */
rc = fat_file_close(&fs_info->fat, fat_fd);
2017848: 7f ff e6 2a call 20110f0 <fat_file_close>
201784c: 90 10 00 1c mov %i4, %o0
if ( rc != RC_OK )
2017850: ba 92 20 00 orcc %o0, 0, %i5
2017854: 12 80 00 5e bne 20179cc <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x2b0><== NEVER TAKEN
2017858: c2 17 bf f4 lduh [ %fp + -12 ], %g1
return rc;
if ( (MSDOS_EXTRACT_CLUSTER_NUM(dotdot_node)) == 0)
201785c: 83 28 60 10 sll %g1, 0x10, %g1
2017860: 85 30 60 18 srl %g1, 0x18, %g2
2017864: 87 30 60 08 srl %g1, 8, %g3
2017868: 03 00 00 3f sethi %hi(0xfc00), %g1
201786c: 82 10 63 ff or %g1, 0x3ff, %g1 ! ffff <PROM_START+0xffff>
2017870: 86 08 c0 01 and %g3, %g1, %g3
2017874: 86 10 80 03 or %g2, %g3, %g3
2017878: c4 17 bf fa lduh [ %fp + -6 ], %g2
201787c: 87 28 e0 10 sll %g3, 0x10, %g3
2017880: 85 28 a0 10 sll %g2, 0x10, %g2
2017884: 89 30 a0 18 srl %g2, 0x18, %g4
2017888: 85 30 a0 08 srl %g2, 8, %g2
201788c: 82 08 80 01 and %g2, %g1, %g1
2017890: 82 11 00 01 or %g4, %g1, %g1
2017894: 80 90 c0 01 orcc %g3, %g1, %g0
2017898: 12 80 00 08 bne 20178b8 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x19c><== ALWAYS TAKEN
201789c: 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;
20178a0: 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;
20178a4: c0 26 a0 04 clr [ %i2 + 4 ] <== NOT EXECUTED
dir_pos->lname.cln = FAT_FILE_SHORT_NAME;
20178a8: c2 26 a0 08 st %g1, [ %i2 + 8 ] <== NOT EXECUTED
dir_pos->lname.ofs = FAT_FILE_SHORT_NAME;
20178ac: 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;
20178b0: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED
20178b4: 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);
20178b8: 92 10 00 1a mov %i2, %o1
20178bc: 7f ff e4 f7 call 2010c98 <fat_file_open>
20178c0: 94 07 bf bc add %fp, -68, %o2
if (rc != RC_OK)
20178c4: ba 92 20 00 orcc %o0, 0, %i5
20178c8: 12 80 00 41 bne 20179cc <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x2b0><== NEVER TAKEN
20178cc: c2 17 bf f4 lduh [ %fp + -12 ], %g1
return rc;
if ((MSDOS_EXTRACT_CLUSTER_NUM(dotdot_node)) == 0)
20178d0: 33 00 00 3f sethi %hi(0xfc00), %i1
20178d4: 83 28 60 10 sll %g1, 0x10, %g1
20178d8: b2 16 63 ff or %i1, 0x3ff, %i1
20178dc: bb 30 60 18 srl %g1, 0x18, %i5
20178e0: 83 30 60 08 srl %g1, 8, %g1
20178e4: 82 08 40 19 and %g1, %i1, %g1
20178e8: ba 17 40 01 or %i5, %g1, %i5
20178ec: c2 17 bf fa lduh [ %fp + -6 ], %g1
20178f0: bb 2f 60 10 sll %i5, 0x10, %i5
20178f4: 83 28 60 10 sll %g1, 0x10, %g1
20178f8: 89 30 60 18 srl %g1, 0x18, %g4
20178fc: 83 30 60 08 srl %g1, 8, %g1
2017900: b2 08 40 19 and %g1, %i1, %i1
2017904: 88 11 00 19 or %g4, %i1, %g4
2017908: 88 97 40 04 orcc %i5, %g4, %g4
201790c: 12 80 00 05 bne 2017920 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x204><== ALWAYS TAKEN
2017910: d2 07 bf bc ld [ %fp + -68 ], %o1
fat_fd->cln = fs_info->fat.vol.rdir_cl;
2017914: c2 07 20 38 ld [ %i4 + 0x38 ], %g1 <== NOT EXECUTED
2017918: 10 80 00 03 b 2017924 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x208><== NOT EXECUTED
201791c: c2 22 60 1c st %g1, [ %o1 + 0x1c ] <== NOT EXECUTED
else
fat_fd->cln = MSDOS_EXTRACT_CLUSTER_NUM(dotdot_node);
2017920: c8 22 60 1c st %g4, [ %o1 + 0x1c ]
fat_fd->fat_file_type = FAT_DIRECTORY;
fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
2017924: 03 00 08 00 sethi %hi(0x200000), %g1
2017928: c2 22 60 14 st %g1, [ %o1 + 0x14 ]
fat_fd->map.file_cln = 0;
fat_fd->map.disk_cln = fat_fd->cln;
201792c: 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;
2017930: c0 22 60 10 clr [ %o1 + 0x10 ]
fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
fat_fd->map.file_cln = 0;
2017934: c0 22 60 34 clr [ %o1 + 0x34 ]
fat_fd->map.disk_cln = fat_fd->cln;
2017938: c2 22 60 38 st %g1, [ %o1 + 0x38 ]
rc = fat_file_size(&fs_info->fat, fat_fd);
201793c: 7f ff e7 7e call 2011734 <fat_file_size>
2017940: 90 10 00 1c mov %i4, %o0
if (rc != RC_OK)
2017944: ba 92 20 00 orcc %o0, 0, %i5
2017948: 02 80 00 04 be 2017958 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x23c><== ALWAYS TAKEN
201794c: d2 07 bf bc ld [ %fp + -68 ], %o1
{
fat_file_close(&fs_info->fat, fat_fd);
2017950: 10 80 00 19 b 20179b4 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x298><== NOT EXECUTED
2017954: 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);
2017958: 87 2c 60 10 sll %l1, 0x10, %g3
201795c: 03 00 00 3f sethi %hi(0xfc00), %g1
2017960: 95 30 e0 18 srl %g3, 0x18, %o2
2017964: 82 10 63 ff or %g1, 0x3ff, %g1
2017968: 87 30 e0 08 srl %g3, 8, %g3
201796c: 86 08 c0 01 and %g3, %g1, %g3
2017970: 85 2c 20 10 sll %l0, 0x10, %g2
2017974: 94 12 80 03 or %o2, %g3, %o2
2017978: 87 30 a0 18 srl %g2, 0x18, %g3
201797c: 85 30 a0 08 srl %g2, 8, %g2
2017980: 82 08 80 01 and %g2, %g1, %g1
2017984: 82 10 c0 01 or %g3, %g1, %g1
2017988: 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,
201798c: 90 10 00 18 mov %i0, %o0
2017990: 94 12 80 01 or %o2, %g1, %o2
2017994: 96 10 00 1a mov %i2, %o3
2017998: 7f ff ff 00 call 2017598 <msdos_find_node_by_cluster_num_in_fat_file>
201799c: 98 10 00 1b mov %i3, %o4
20179a0: d2 07 bf bc ld [ %fp + -68 ], %o1
20179a4: ba 10 00 08 mov %o0, %i5
dir_pos, dir_entry);
if (rc != RC_OK)
20179a8: 80 a7 60 00 cmp %i5, 0
20179ac: 02 80 00 05 be 20179c0 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x2a4><== ALWAYS TAKEN
20179b0: 90 10 00 1c mov %i4, %o0
{
fat_file_close(&fs_info->fat, fat_fd);
20179b4: 7f ff e5 cf call 20110f0 <fat_file_close> <== NOT EXECUTED
20179b8: b0 10 00 1d mov %i5, %i0 <== NOT EXECUTED
20179bc: 30 80 00 05 b,a 20179d0 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x2b4><== NOT EXECUTED
return rc;
}
rc = fat_file_close(&fs_info->fat, fat_fd);
20179c0: 7f ff e5 cc call 20110f0 <fat_file_close>
20179c4: 01 00 00 00 nop
20179c8: ba 10 00 08 mov %o0, %i5
return rc;
}
20179cc: b0 10 00 1d mov %i5, %i0
20179d0: 81 c7 e0 08 ret
20179d4: 81 e8 00 00 restore
020179d8 <msdos_get_name_node>:
int name_len,
msdos_name_type_t name_type,
fat_dir_pos_t *dir_pos,
char *name_dir_entry
)
{
20179d8: 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,
20179dc: d0 06 20 14 ld [ %i0 + 0x14 ], %o0
20179e0: 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
)
{
20179e4: 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,
20179e8: 9a 10 00 1c mov %i4, %o5
20179ec: fa 23 a0 5c st %i5, [ %sp + 0x5c ]
20179f0: e0 23 a0 60 st %l0, [ %sp + 0x60 ]
20179f4: 94 10 00 19 mov %i1, %o2
20179f8: 96 10 00 1a mov %i2, %o3
20179fc: 7f ff fc 8c call 2016c2c <msdos_find_name_in_fat_file>
2017a00: 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))
2017a04: 03 00 00 1f sethi %hi(0x7c00), %g1
2017a08: 82 10 61 01 or %g1, 0x101, %g1 ! 7d01 <PROM_START+0x7d01>
2017a0c: 80 a2 00 01 cmp %o0, %g1
2017a10: 02 80 00 05 be 2017a24 <msdos_get_name_node+0x4c>
2017a14: b8 10 00 08 mov %o0, %i4
2017a18: 80 a2 20 00 cmp %o0, 0
2017a1c: 12 80 00 2d bne 2017ad0 <msdos_get_name_node+0xf8> <== NEVER TAKEN
2017a20: 01 00 00 00 nop
return rc;
if (!create_node)
2017a24: 80 a6 60 00 cmp %i1, 0
2017a28: 12 80 00 2a bne 2017ad0 <msdos_get_name_node+0xf8>
2017a2c: 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)
2017a30: 82 10 61 01 or %g1, 0x101, %g1 ! 7d01 <PROM_START+0x7d01>
2017a34: 80 a7 00 01 cmp %i4, %g1
2017a38: 02 80 00 26 be 2017ad0 <msdos_get_name_node+0xf8>
2017a3c: 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)
2017a40: 12 80 00 24 bne 2017ad0 <msdos_get_name_node+0xf8> <== NEVER TAKEN
2017a44: 90 10 00 1a mov %i2, %o0
{
if (strncmp(name, "..", 2) == 0)
2017a48: 13 00 80 99 sethi %hi(0x2026400), %o1
2017a4c: 94 10 20 02 mov 2, %o2
2017a50: 40 00 10 05 call 201ba64 <strncmp>
2017a54: 92 12 60 50 or %o1, 0x50, %o1
2017a58: 80 a2 20 00 cmp %o0, 0
2017a5c: 12 80 00 1d bne 2017ad0 <msdos_get_name_node+0xf8>
2017a60: 05 00 00 3f sethi %hi(0xfc00), %g2
{
dotdot_cln = MSDOS_EXTRACT_CLUSTER_NUM((name_dir_entry));
2017a64: c6 14 20 1a lduh [ %l0 + 0x1a ], %g3
2017a68: c8 14 20 14 lduh [ %l0 + 0x14 ], %g4
2017a6c: 87 28 e0 10 sll %g3, 0x10, %g3
2017a70: 89 29 20 10 sll %g4, 0x10, %g4
2017a74: 83 30 e0 18 srl %g3, 0x18, %g1
2017a78: b3 31 20 18 srl %g4, 0x18, %i1
2017a7c: 89 31 20 08 srl %g4, 8, %g4
2017a80: 84 10 a3 ff or %g2, 0x3ff, %g2
2017a84: 87 30 e0 08 srl %g3, 8, %g3
2017a88: 88 09 00 02 and %g4, %g2, %g4
2017a8c: 84 08 c0 02 and %g3, %g2, %g2
2017a90: b2 16 40 04 or %i1, %g4, %i1
2017a94: 82 10 40 02 or %g1, %g2, %g1
2017a98: b3 2e 60 10 sll %i1, 0x10, %i1
/* are we right under root dir ? */
if (dotdot_cln == 0)
2017a9c: b2 96 40 01 orcc %i1, %g1, %i1
2017aa0: 12 80 00 08 bne 2017ac0 <msdos_get_name_node+0xe8>
2017aa4: 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;
2017aa8: c0 27 60 04 clr [ %i5 + 4 ]
dir_pos->lname.cln = FAT_FILE_SHORT_NAME;
2017aac: c2 27 60 08 st %g1, [ %i5 + 8 ]
dir_pos->lname.ofs = FAT_FILE_SHORT_NAME;
2017ab0: 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;
2017ab4: 82 10 20 01 mov 1, %g1
2017ab8: 10 80 00 06 b 2017ad0 <msdos_get_name_node+0xf8>
2017abc: c2 27 40 00 st %g1, [ %i5 ]
}
else
{
rc =
2017ac0: f0 06 20 14 ld [ %i0 + 0x14 ], %i0
2017ac4: b4 10 00 1d mov %i5, %i2
2017ac8: 7f ff ff 15 call 201771c <msdos_get_dotdot_dir_info_cluster_num_and_offset>
2017acc: 97 e8 00 10 restore %g0, %l0, %o3
}
}
}
}
return rc;
}
2017ad0: 81 c7 e0 08 ret
2017ad4: 91 e8 00 1c restore %g0, %i4, %o0
0200da3c <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
)
{
200da3c: 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));
200da40: 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;
200da44: 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));
200da48: 7f ff da 18 call 20042a8 <calloc>
200da4c: 92 10 20 98 mov 0x98, %o1
if (!fs_info)
200da50: ba 92 20 00 orcc %o0, 0, %i5
200da54: 32 80 00 03 bne,a 200da60 <msdos_initialize_support+0x24><== ALWAYS TAKEN
200da58: d2 06 20 38 ld [ %i0 + 0x38 ], %o1
200da5c: 30 80 00 45 b,a 200db70 <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);
200da60: 40 00 11 a7 call 20120fc <fat_init_volume_info>
200da64: fa 26 20 08 st %i5, [ %i0 + 8 ]
if (rc != RC_OK)
200da68: b8 92 20 00 orcc %o0, 0, %i4
200da6c: 12 80 00 12 bne 200dab4 <msdos_initialize_support+0x78> <== NEVER TAKEN
200da70: 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;
200da74: c2 27 bf f8 st %g1, [ %fp + -8 ]
dir_pos->lname.ofs = FAT_FILE_SHORT_NAME;
200da78: 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;
200da7c: 82 10 20 01 mov 1, %g1
{
free(fs_info);
return rc;
}
fs_info->file_handlers = file_handlers;
200da80: f4 27 60 8c st %i2, [ %i5 + 0x8c ]
fs_info->directory_handlers = directory_handlers;
200da84: 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;
200da88: 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;
200da8c: c2 27 bf f0 st %g1, [ %fp + -16 ]
rc = fat_file_open(&fs_info->fat, &root_pos, &fat_fd);
200da90: 90 10 00 1d mov %i5, %o0
200da94: 92 07 bf f0 add %fp, -16, %o1
200da98: 40 00 0c 80 call 2010c98 <fat_file_open>
200da9c: 94 07 bf ec add %fp, -20, %o2
if (rc != RC_OK)
200daa0: b8 92 20 00 orcc %o0, 0, %i4
200daa4: 02 80 00 08 be 200dac4 <msdos_initialize_support+0x88> <== ALWAYS TAKEN
200daa8: d2 07 bf ec ld [ %fp + -20 ], %o1
{
fat_shutdown_drive(&fs_info->fat);
200daac: 40 00 11 4e call 2011fe4 <fat_shutdown_drive> <== NOT EXECUTED
200dab0: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
free(fs_info);
200dab4: 7f ff da d2 call 20045fc <free> <== NOT EXECUTED
200dab8: 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;
}
200dabc: 81 c7 e0 08 ret <== NOT EXECUTED
200dac0: 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;
200dac4: 03 00 08 00 sethi %hi(0x200000), %g1
200dac8: c2 22 60 14 st %g1, [ %o1 + 0x14 ]
fat_fd->cln = fs_info->fat.vol.rdir_cl;
200dacc: 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;
200dad0: c0 22 60 10 clr [ %o1 + 0x10 ]
fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
fat_fd->cln = fs_info->fat.vol.rdir_cl;
200dad4: c2 22 60 1c st %g1, [ %o1 + 0x1c ]
fat_fd->map.file_cln = 0;
200dad8: 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 )
200dadc: 80 a0 60 00 cmp %g1, 0
200dae0: 12 80 00 09 bne 200db04 <msdos_initialize_support+0xc8> <== NEVER TAKEN
200dae4: c2 22 60 38 st %g1, [ %o1 + 0x38 ]
{
fat_fd->fat_file_size = fs_info->fat.vol.rdir_size;
200dae8: 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 :
200daec: 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) ?
200daf0: 80 a2 00 01 cmp %o0, %g1
200daf4: 1a 80 00 13 bcc 200db40 <msdos_initialize_support+0x104> <== NEVER TAKEN
200daf8: c2 22 60 18 st %g1, [ %o1 + 0x18 ]
200dafc: 10 80 00 11 b 200db40 <msdos_initialize_support+0x104>
200db00: 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);
200db04: 40 00 0f 0c call 2011734 <fat_file_size> <== NOT EXECUTED
200db08: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
if ( rc != RC_OK )
200db0c: b4 92 20 00 orcc %o0, 0, %i2 <== NOT EXECUTED
200db10: 22 80 00 0c be,a 200db40 <msdos_initialize_support+0x104><== NOT EXECUTED
200db14: d0 17 60 06 lduh [ %i5 + 6 ], %o0 <== NOT EXECUTED
{
fat_file_close(&fs_info->fat, fat_fd);
200db18: d2 07 bf ec ld [ %fp + -20 ], %o1 <== NOT EXECUTED
200db1c: 40 00 0d 75 call 20110f0 <fat_file_close> <== NOT EXECUTED
200db20: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
fat_shutdown_drive(&fs_info->fat);
200db24: 40 00 11 30 call 2011fe4 <fat_shutdown_drive> <== NOT EXECUTED
200db28: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
free(fs_info);
200db2c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
200db30: 7f ff da b3 call 20045fc <free> <== NOT EXECUTED
200db34: 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;
}
200db38: 81 c7 e0 08 ret <== NOT EXECUTED
200db3c: 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));
200db40: 7f ff d9 da call 20042a8 <calloc>
200db44: 92 10 20 01 mov 1, %o1
if (fs_info->cl_buf == NULL)
200db48: 80 a2 20 00 cmp %o0, 0
200db4c: 12 80 00 0f bne 200db88 <msdos_initialize_support+0x14c> <== ALWAYS TAKEN
200db50: d0 27 60 94 st %o0, [ %i5 + 0x94 ]
{
fat_file_close(&fs_info->fat, fat_fd);
200db54: d2 07 bf ec ld [ %fp + -20 ], %o1 <== NOT EXECUTED
200db58: 40 00 0d 66 call 20110f0 <fat_file_close> <== NOT EXECUTED
200db5c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
fat_shutdown_drive(&fs_info->fat);
200db60: 40 00 11 21 call 2011fe4 <fat_shutdown_drive> <== NOT EXECUTED
200db64: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
free(fs_info);
200db68: 7f ff da a5 call 20045fc <free> <== NOT EXECUTED
200db6c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(ENOMEM);
200db70: 40 00 31 2c call 201a020 <__errno> <== NOT EXECUTED
200db74: 01 00 00 00 nop <== NOT EXECUTED
200db78: 82 10 20 0c mov 0xc, %g1 ! c <PROM_START+0xc> <== NOT EXECUTED
200db7c: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
200db80: 10 80 00 1b b 200dbec <msdos_initialize_support+0x1b0> <== NOT EXECUTED
200db84: b8 10 3f ff mov -1, %i4 <== NOT EXECUTED
}
sc = rtems_semaphore_create(3,
200db88: 92 10 20 01 mov 1, %o1
200db8c: 90 10 20 03 mov 3, %o0
200db90: 94 10 20 10 mov 0x10, %o2
200db94: 96 10 20 00 clr %o3
200db98: 7f ff ec 0f call 2008bd4 <rtems_semaphore_create>
200db9c: 98 07 60 90 add %i5, 0x90, %o4
1,
RTEMS_BINARY_SEMAPHORE | RTEMS_FIFO,
0,
&fs_info->vol_sema);
if (sc != RTEMS_SUCCESSFUL)
200dba0: 80 a2 20 00 cmp %o0, 0
200dba4: 02 80 00 0e be 200dbdc <msdos_initialize_support+0x1a0> <== ALWAYS TAKEN
200dba8: d2 07 bf ec ld [ %fp + -20 ], %o1
{
fat_file_close(&fs_info->fat, fat_fd);
200dbac: 40 00 0d 51 call 20110f0 <fat_file_close> <== NOT EXECUTED
200dbb0: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
fat_shutdown_drive(&fs_info->fat);
200dbb4: 40 00 11 0c call 2011fe4 <fat_shutdown_drive> <== NOT EXECUTED
200dbb8: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
free(fs_info->cl_buf);
200dbbc: 7f ff da 90 call 20045fc <free> <== NOT EXECUTED
200dbc0: d0 07 60 94 ld [ %i5 + 0x94 ], %o0 <== NOT EXECUTED
free(fs_info);
200dbc4: 7f ff da 8e call 20045fc <free> <== NOT EXECUTED
200dbc8: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EIO );
200dbcc: 40 00 31 15 call 201a020 <__errno> <== NOT EXECUTED
200dbd0: 01 00 00 00 nop <== NOT EXECUTED
200dbd4: 10 bf ff ea b 200db7c <msdos_initialize_support+0x140> <== NOT EXECUTED
200dbd8: 82 10 20 05 mov 5, %g1 ! 5 <PROM_START+0x5> <== NOT EXECUTED
}
temp_mt_entry->mt_fs_root->location.node_access = fat_fd;
200dbdc: c2 06 20 24 ld [ %i0 + 0x24 ], %g1
200dbe0: d2 20 60 08 st %o1, [ %g1 + 8 ]
temp_mt_entry->mt_fs_root->location.handlers = directory_handlers;
200dbe4: f6 20 60 10 st %i3, [ %g1 + 0x10 ]
temp_mt_entry->ops = op_table;
200dbe8: f2 26 20 0c st %i1, [ %i0 + 0xc ]
return rc;
}
200dbec: b0 10 00 1c mov %i4, %i0
200dbf0: 81 c7 e0 08 ret
200dbf4: 81 e8 00 00 restore
0200da08 <msdos_lock>:
.rename_h = msdos_rename,
.statvfs_h = rtems_filesystem_default_statvfs
};
void msdos_lock(const rtems_filesystem_mount_table_entry_t *mt_entry)
{
200da08: 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,
200da0c: 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(
200da10: 92 10 20 00 clr %o1
200da14: d0 00 60 90 ld [ %g1 + 0x90 ], %o0
200da18: 7f ff ed 0d call 2008e4c <rtems_semaphore_obtain>
200da1c: 94 10 20 00 clr %o2
fs_info->vol_sema,
RTEMS_WAIT,
RTEMS_NO_TIMEOUT
);
if (sc != RTEMS_SUCCESSFUL) {
200da20: 80 a2 20 00 cmp %o0, 0
200da24: 02 80 00 04 be 200da34 <msdos_lock+0x2c> <== ALWAYS TAKEN
200da28: 11 37 ab 6f sethi %hi(0xdeadbc00), %o0
rtems_fatal_error_occurred(0xdeadbeef);
200da2c: 7f ff ee b9 call 2009510 <rtems_fatal_error_occurred> <== NOT EXECUTED
200da30: 90 12 22 ef or %o0, 0x2ef, %o0 ! deadbeef <RAM_END+0xdc6dbeef><== NOT EXECUTED
200da34: 81 c7 e0 08 ret
200da38: 81 e8 00 00 restore
02016584 <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)
{
2016584: 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);
2016588: 92 10 20 20 mov 0x20, %o1
201658c: 90 10 00 1a mov %i2, %o0
2016590: 40 00 11 96 call 201abe8 <memset>
2016594: 94 10 00 1b mov %i3, %o2
/*
* Handle '.' and '..' specially.
*/
if ((lfn[0] == '.') && (lfn_len == 1))
2016598: c2 4e 00 00 ldsb [ %i0 ], %g1
201659c: 80 a0 60 2e cmp %g1, 0x2e
20165a0: 12 80 00 23 bne 201662c <msdos_long_to_short+0xa8>
20165a4: 84 10 20 00 clr %g2
20165a8: 80 a6 60 01 cmp %i1, 1
20165ac: 32 80 00 04 bne,a 20165bc <msdos_long_to_short+0x38>
20165b0: c2 4e 20 01 ldsb [ %i0 + 1 ], %g1
return MSDOS_NAME_SHORT;
}
if ((lfn[0] == '.') && (lfn[1] == '.') && (lfn_len == 2))
{
sfn[0] = sfn[1] = '.';
20165b4: 10 80 00 0a b 20165dc <msdos_long_to_short+0x58>
20165b8: 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))
20165bc: 80 a0 60 2e cmp %g1, 0x2e
20165c0: 12 80 00 1c bne 2016630 <msdos_long_to_short+0xac> <== NEVER TAKEN
20165c4: 80 a0 80 19 cmp %g2, %i1
20165c8: 80 a6 60 02 cmp %i1, 2
20165cc: 12 80 00 19 bne 2016630 <msdos_long_to_short+0xac> <== NEVER TAKEN
20165d0: 80 a0 80 19 cmp %g2, %i1
{
sfn[0] = sfn[1] = '.';
20165d4: c2 2e a0 01 stb %g1, [ %i2 + 1 ]
20165d8: 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;
20165dc: 10 80 00 72 b 20167a4 <msdos_long_to_short+0x220>
20165e0: 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] != '.'))
20165e4: 80 a0 60 2e cmp %g1, 0x2e
20165e8: 22 80 00 11 be,a 201662c <msdos_long_to_short+0xa8> <== NEVER TAKEN
20165ec: 84 00 a0 01 inc %g2 <== NOT EXECUTED
20165f0: 80 a0 60 20 cmp %g1, 0x20
20165f4: 22 80 00 0e be,a 201662c <msdos_long_to_short+0xa8>
20165f8: 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) ||
20165fc: 03 00 80 9e sethi %hi(0x2027800), %g1
2016600: c2 00 63 b8 ld [ %g1 + 0x3b8 ], %g1 ! 2027bb8 <__ctype_ptr__>
*
*/
static msdos_name_type_t
msdos_is_valid_name_char(const char ch)
{
if (strchr(" +,;=[]", ch) != NULL)
2016604: 2d 00 80 99 sethi %hi(0x2026400), %l6
return MSDOS_NAME_LONG;
if ((ch == '.') || isalnum((unsigned char)ch) ||
(strchr("$%'-_@~`!(){}^#&", ch) != NULL))
2016608: 2f 00 80 99 sethi %hi(0x2026400), %l7
msdos_is_valid_name_char(const char ch)
{
if (strchr(" +,;=[]", ch) != NULL)
return MSDOS_NAME_LONG;
if ((ch == '.') || isalnum((unsigned char)ch) ||
201660c: c2 27 bf fc st %g1, [ %fp + -4 ]
2016610: b8 10 20 00 clr %i4
2016614: a2 10 3f ff mov -1, %l1
2016618: a4 10 20 00 clr %l2
201661c: a6 10 20 00 clr %l3
*
*/
static msdos_name_type_t
msdos_is_valid_name_char(const char ch)
{
if (strchr(" +,;=[]", ch) != NULL)
2016620: ac 15 a2 80 or %l6, 0x280, %l6
return MSDOS_NAME_LONG;
if ((ch == '.') || isalnum((unsigned char)ch) ||
(strchr("$%'-_@~`!(){}^#&", ch) != NULL))
2016624: 10 80 00 45 b 2016738 <msdos_long_to_short+0x1b4>
2016628: ae 15 e2 88 or %l7, 0x288, %l7
}
/*
* Filenames with only blanks and dots are not allowed!
*/
for (i = 0; i < lfn_len; i++)
201662c: 80 a0 80 19 cmp %g2, %i1
2016630: 26 bf ff ed bl,a 20165e4 <msdos_long_to_short+0x60> <== ALWAYS TAKEN
2016634: c2 4e 00 02 ldsb [ %i0 + %g2 ], %g1
if ((lfn[i] != ' ') && (lfn[i] != '.'))
break;
if (i == lfn_len)
2016638: 80 a0 80 19 cmp %g2, %i1 <== NOT EXECUTED
201663c: 12 bf ff f0 bne 20165fc <msdos_long_to_short+0x78> <== NOT EXECUTED
2016640: 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;
}
2016644: 81 c7 e0 08 ret <== NOT EXECUTED
2016648: 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 == '.';
201664c: 80 a0 00 01 cmp %g0, %g1
*
*/
static msdos_name_type_t
msdos_is_valid_name_char(const char ch)
{
if (strchr(" +,;=[]", ch) != NULL)
2016650: 90 10 00 16 mov %l6, %o0
int dot_at = -1;
int count = 0;
while (*name && (count < name_len))
{
bool is_dot = *name == '.';
2016654: 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)
2016658: 92 10 00 1b mov %i3, %o1
201665c: 40 00 12 85 call 201b070 <strchr>
2016660: aa 10 00 14 mov %l4, %l5
2016664: 80 a2 20 00 cmp %o0, 0
2016668: 12 80 00 12 bne 20166b0 <msdos_long_to_short+0x12c>
201666c: ba 10 20 02 mov 2, %i5
return MSDOS_NAME_LONG;
if ((ch == '.') || isalnum((unsigned char)ch) ||
2016670: 80 8d 20 ff btst 0xff, %l4
2016674: 12 80 00 0e bne 20166ac <msdos_long_to_short+0x128>
2016678: c2 07 bf fc ld [ %fp + -4 ], %g1
201667c: 84 0c 20 ff and %l0, 0xff, %g2
2016680: 84 00 40 02 add %g1, %g2, %g2
2016684: c4 08 a0 01 ldub [ %g2 + 1 ], %g2
2016688: 80 88 a0 07 btst 7, %g2
201668c: 12 80 00 09 bne 20166b0 <msdos_long_to_short+0x12c>
2016690: ba 10 20 01 mov 1, %i5
(strchr("$%'-_@~`!(){}^#&", ch) != NULL))
2016694: 90 10 00 17 mov %l7, %o0
2016698: 40 00 12 76 call 201b070 <strchr>
201669c: 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;
20166a0: 80 a0 00 08 cmp %g0, %o0
20166a4: 10 80 00 03 b 20166b0 <msdos_long_to_short+0x12c>
20166a8: ba 40 20 00 addx %g0, 0, %i5
if ((ch == '.') || isalnum((unsigned char)ch) ||
(strchr("$%'-_@~`!(){}^#&", ch) != NULL))
return MSDOS_NAME_SHORT;
20166ac: 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))
20166b0: 80 8f 60 01 btst 1, %i5
20166b4: 02 80 00 2f be 2016770 <msdos_long_to_short+0x1ec>
20166b8: 80 a4 7f ff cmp %l1, -1
return type;
if (dot_at >= 0)
20166bc: 02 80 00 0a be 20166e4 <msdos_long_to_short+0x160>
20166c0: 80 8d 60 ff btst 0xff, %l5
{
if (is_dot || ((count - dot_at) > 3))
20166c4: 32 80 00 2e bne,a 201677c <msdos_long_to_short+0x1f8> <== ALWAYS TAKEN
20166c8: ba 10 20 02 mov 2, %i5
20166cc: 82 27 00 11 sub %i4, %l1, %g1 <== NOT EXECUTED
20166d0: 80 a0 60 03 cmp %g1, 3 <== NOT EXECUTED
20166d4: 24 80 00 0d ble,a 2016708 <msdos_long_to_short+0x184> <== NOT EXECUTED
20166d8: 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;
20166dc: 10 80 00 28 b 201677c <msdos_long_to_short+0x1f8> <== NOT EXECUTED
20166e0: ba 10 20 02 mov 2, %i5 <== NOT EXECUTED
return MSDOS_NAME_LONG;
}
}
else
{
if (count == 8 && !is_dot)
20166e4: 80 a5 20 00 cmp %l4, 0
20166e8: 12 80 00 05 bne 20166fc <msdos_long_to_short+0x178>
20166ec: 80 8d 60 ff btst 0xff, %l5
20166f0: 80 a7 20 08 cmp %i4, 8
20166f4: 02 80 00 28 be 2016794 <msdos_long_to_short+0x210>
20166f8: 80 8d 60 ff btst 0xff, %l5
#endif
return MSDOS_NAME_LONG;
}
}
if (is_dot)
20166fc: 32 80 00 0e bne,a 2016734 <msdos_long_to_short+0x1b0>
2016700: a2 10 00 1c mov %i4, %l1
dot_at = count;
else if ((*name >= 'A') && (*name <= 'Z'))
2016704: 82 04 3f bf add %l0, -65, %g1
2016708: 82 08 60 ff and %g1, 0xff, %g1
201670c: 80 a0 60 19 cmp %g1, 0x19
2016710: 28 80 00 09 bleu,a 2016734 <msdos_long_to_short+0x1b0>
2016714: a4 10 20 01 mov 1, %l2
uppercase = true;
else if ((*name >= 'a') && (*name <= 'z'))
2016718: a0 04 3f 9f add %l0, -97, %l0
201671c: a0 0c 20 ff and %l0, 0xff, %l0
2016720: 80 a4 20 19 cmp %l0, 0x19
2016724: 28 80 00 04 bleu,a 2016734 <msdos_long_to_short+0x1b0>
2016728: a6 10 20 01 mov 1, %l3
lowercase = true;
count++;
201672c: 10 80 00 03 b 2016738 <msdos_long_to_short+0x1b4>
2016730: b8 07 20 01 inc %i4
2016734: b8 07 20 01 inc %i4
bool lowercase = false;
bool uppercase = false;
int dot_at = -1;
int count = 0;
while (*name && (count < name_len))
2016738: f6 4e 00 1c ldsb [ %i0 + %i4 ], %i3
201673c: 80 a6 e0 00 cmp %i3, 0
2016740: 02 80 00 05 be 2016754 <msdos_long_to_short+0x1d0>
2016744: e0 0e 00 1c ldub [ %i0 + %i4 ], %l0
2016748: 80 a7 00 19 cmp %i4, %i1
201674c: 06 bf ff c0 bl 201664c <msdos_long_to_short+0xc8>
2016750: 82 1e e0 2e xor %i3, 0x2e, %g1
count++;
name++;
}
if (lowercase && uppercase)
2016754: 80 8c e0 ff btst 0xff, %l3
2016758: 02 80 00 11 be 201679c <msdos_long_to_short+0x218>
201675c: 80 8c a0 ff btst 0xff, %l2
2016760: 22 80 00 07 be,a 201677c <msdos_long_to_short+0x1f8> <== ALWAYS TAKEN
2016764: 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;
2016768: 10 80 00 05 b 201677c <msdos_long_to_short+0x1f8> <== NOT EXECUTED
201676c: 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)
2016770: 82 97 60 00 orcc %i5, 0, %g1
2016774: 22 80 00 0d be,a 20167a8 <msdos_long_to_short+0x224> <== NEVER TAKEN
2016778: 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);
201677c: 90 10 00 18 mov %i0, %o0
2016780: 92 10 00 19 mov %i1, %o1
2016784: 40 00 0b 1e call 20193fc <msdos_filename_unix2dos>
2016788: 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;
201678c: 10 80 00 06 b 20167a4 <msdos_long_to_short+0x220>
2016790: 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;
2016794: 10 bf ff fa b 201677c <msdos_long_to_short+0x1f8>
2016798: ba 10 20 02 mov 2, %i5
}
#if MSDOS_NAME_TYPE_PRINT
printf ("MSDOS_NAME_TYPE: SHORT[1]\n");
#endif
return MSDOS_NAME_SHORT;
201679c: 10 bf ff f8 b 201677c <msdos_long_to_short+0x1f8>
20167a0: 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;
}
20167a4: b0 10 00 01 mov %g1, %i0
20167a8: 81 c7 e0 08 ret
20167ac: 81 e8 00 00 restore
0200dbf8 <msdos_mknod>:
const char *name,
size_t namelen,
mode_t mode,
dev_t dev
)
{
200dbf8: 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))
200dbfc: 05 00 00 3c sethi %hi(0xf000), %g2
200dc00: 03 00 00 10 sethi %hi(0x4000), %g1
200dc04: 84 0e c0 02 and %i3, %g2, %g2
const char *name,
size_t namelen,
mode_t mode,
dev_t dev
)
{
200dc08: 88 10 00 19 mov %i1, %g4
200dc0c: 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))
200dc10: 80 a0 80 01 cmp %g2, %g1
200dc14: 02 80 00 07 be 200dc30 <msdos_mknod+0x38>
200dc18: b8 10 00 1b mov %i3, %i4
{
type = MSDOS_DIRECTORY;
}
else if (S_ISREG(mode))
200dc1c: 3b 00 00 20 sethi %hi(0x8000), %i5
200dc20: 80 a0 80 1d cmp %g2, %i5
200dc24: 02 80 00 04 be 200dc34 <msdos_mknod+0x3c> <== ALWAYS TAKEN
200dc28: b2 10 20 04 mov 4, %i1
200dc2c: 30 80 00 06 b,a 200dc44 <msdos_mknod+0x4c> <== NOT EXECUTED
/*
* Figure out what type of msdos node this is.
*/
if (S_ISDIR(mode))
{
type = MSDOS_DIRECTORY;
200dc30: 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);
200dc34: b4 10 00 04 mov %g4, %i2
200dc38: b6 10 00 03 mov %g3, %i3
200dc3c: 40 00 20 f0 call 2015ffc <msdos_creat_node>
200dc40: 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);
200dc44: 40 00 30 f7 call 201a020 <__errno> <== NOT EXECUTED
200dc48: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
200dc4c: 82 10 20 16 mov 0x16, %g1 <== NOT EXECUTED
200dc50: 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;
}
200dc54: 81 c7 e0 08 ret <== NOT EXECUTED
200dc58: 81 e8 00 00 restore <== NOT EXECUTED
0200dc68 <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
)
{
200dc68: 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;
200dc6c: 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,
200dc70: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
200dc74: 92 10 20 02 mov 2, %o1 <== NOT EXECUTED
200dc78: 94 10 00 1b mov %i3, %o2 <== NOT EXECUTED
200dc7c: 96 10 00 1c mov %i4, %o3 <== NOT EXECUTED
200dc80: 19 00 00 20 sethi %hi(0x8000), %o4 <== NOT EXECUTED
200dc84: 40 00 20 de call 2015ffc <msdos_creat_node> <== NOT EXECUTED
200dc88: 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)
200dc8c: b0 92 20 00 orcc %o0, 0, %i0 <== NOT EXECUTED
200dc90: 12 80 00 05 bne 200dca4 <msdos_rename+0x3c> <== NOT EXECUTED
200dc94: b4 10 20 e5 mov 0xe5, %i2 <== NOT EXECUTED
}
/*
* mark file removed
*/
rc = msdos_set_first_char4file_name(old_loc->mt_entry,
200dc98: f0 06 60 14 ld [ %i1 + 0x14 ], %i0 <== NOT EXECUTED
200dc9c: 40 00 23 4b call 20169c8 <msdos_set_first_char4file_name> <== NOT EXECUTED
200dca0: 93 ef 60 20 restore %i5, 0x20, %o1 <== NOT EXECUTED
&old_fat_fd->dir_pos,
MSDOS_THIS_DIR_ENTRY_EMPTY);
return rc;
}
200dca4: 81 c7 e0 08 ret <== NOT EXECUTED
200dca8: 81 e8 00 00 restore <== NOT EXECUTED
0200dcac <msdos_rmnod>:
#include "msdos.h"
int
msdos_rmnod(const rtems_filesystem_location_info_t *parent_pathloc,
const rtems_filesystem_location_info_t *pathloc)
{
200dcac: 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;
200dcb0: 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;
200dcb4: 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)
200dcb8: c4 07 60 10 ld [ %i5 + 0x10 ], %g2
200dcbc: 80 a0 a0 00 cmp %g2, 0
200dcc0: 12 80 00 22 bne 200dd48 <msdos_rmnod+0x9c>
200dcc4: f8 02 20 08 ld [ %o0 + 8 ], %i4
{
bool is_empty = false;
200dcc8: 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);
200dccc: 92 10 00 1d mov %i5, %o1
200dcd0: 40 00 23 8b call 2016afc <msdos_dir_is_empty>
200dcd4: 94 07 bf ff add %fp, -1, %o2
if (rc != RC_OK)
200dcd8: b0 92 20 00 orcc %o0, 0, %i0
200dcdc: 12 80 00 23 bne 200dd68 <msdos_rmnod+0xbc> <== NEVER TAKEN
200dce0: c2 0f bf ff ldub [ %fp + -1 ], %g1
{
return rc;
}
if (!is_empty)
200dce4: 80 a0 60 00 cmp %g1, 0
200dce8: 32 80 00 06 bne,a 200dd00 <msdos_rmnod+0x54>
200dcec: c2 07 60 08 ld [ %i5 + 8 ], %g1
{
rtems_set_errno_and_return_minus_one(ENOTEMPTY);
200dcf0: 40 00 30 cc call 201a020 <__errno>
200dcf4: 01 00 00 00 nop
200dcf8: 10 80 00 11 b 200dd3c <msdos_rmnod+0x90>
200dcfc: 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)
200dd00: 80 a0 60 01 cmp %g1, 1
200dd04: 28 80 00 03 bleu,a 200dd10 <msdos_rmnod+0x64> <== ALWAYS TAKEN
200dd08: c2 06 60 14 ld [ %i1 + 0x14 ], %g1
200dd0c: 30 80 00 09 b,a 200dd30 <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)(
200dd10: 90 10 00 19 mov %i1, %o0
200dd14: c4 00 60 0c ld [ %g1 + 0xc ], %g2
200dd18: c4 00 a0 10 ld [ %g2 + 0x10 ], %g2
200dd1c: 9f c0 80 00 call %g2
200dd20: d2 00 60 24 ld [ %g1 + 0x24 ], %o1
}
/*
* You cannot remove the file system root node.
*/
if (rtems_filesystem_location_is_root(pathloc))
200dd24: 80 8a 20 ff btst 0xff, %o0
200dd28: 22 80 00 08 be,a 200dd48 <msdos_rmnod+0x9c> <== ALWAYS TAKEN
200dd2c: d0 06 60 14 ld [ %i1 + 0x14 ], %o0
{
rtems_set_errno_and_return_minus_one(EBUSY);
200dd30: 40 00 30 bc call 201a020 <__errno> <== NOT EXECUTED
200dd34: 01 00 00 00 nop <== NOT EXECUTED
200dd38: 82 10 20 10 mov 0x10, %g1 ! 10 <PROM_START+0x10> <== NOT EXECUTED
200dd3c: c2 22 00 00 st %g1, [ %o0 ]
200dd40: 81 c7 e0 08 ret
200dd44: 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,
200dd48: 92 07 60 20 add %i5, 0x20, %o1
200dd4c: 40 00 23 1f call 20169c8 <msdos_set_first_char4file_name>
200dd50: 94 10 20 e5 mov 0xe5, %o2
MSDOS_THIS_DIR_ENTRY_EMPTY);
if (rc != RC_OK)
200dd54: b0 92 20 00 orcc %o0, 0, %i0
200dd58: 12 80 00 04 bne 200dd68 <msdos_rmnod+0xbc> <== NEVER TAKEN
200dd5c: 90 10 00 1c mov %i4, %o0
{
return rc;
}
fat_file_mark_removed(&fs_info->fat, fat_fd);
200dd60: 40 00 0e 61 call 20116e4 <fat_file_mark_removed>
200dd64: 92 10 00 1d mov %i5, %o1
return rc;
}
200dd68: 81 c7 e0 08 ret
200dd6c: 81 e8 00 00 restore
020167b0 <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
)
{
20167b0: 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);
20167b4: 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;
20167b8: 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);
20167bc: 94 07 bf fc add %fp, -4, %o2
20167c0: 40 00 0a 74 call 2019190 <msdos_date_unix2dos>
20167c4: 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);
20167c8: d2 06 60 20 ld [ %i1 + 0x20 ], %o1
20167cc: 7f ff ff 60 call 201654c <fat_cluster_num_to_sector_num>
20167d0: 90 10 00 1d mov %i5, %o0
sec += (fat_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);
20167d4: 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);
20167d8: 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);
20167dc: 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);
20167e0: 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);
20167e4: 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);
20167e8: b8 0f 00 01 and %i4, %g1, %i4
time_val = CT_LE_W(time_val);
20167ec: 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);
20167f0: 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);
20167f4: 83 28 60 10 sll %g1, 0x10, %g1
20167f8: 85 30 60 08 srl %g1, 8, %g2
20167fc: 83 30 60 18 srl %g1, 0x18, %g1
2016800: 82 10 80 01 or %g2, %g1, %g1
ret1 = _fat_block_write(&fs_info->fat, sec, byte + MSDOS_FILE_WTIME_OFFSET,
2016804: 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);
2016808: c2 37 bf fc sth %g1, [ %fp + -4 ]
ret1 = _fat_block_write(&fs_info->fat, sec, byte + MSDOS_FILE_WTIME_OFFSET,
201680c: 94 07 20 16 add %i4, 0x16, %o2
2016810: 96 10 20 02 mov 2, %o3
2016814: 98 07 bf fc add %fp, -4, %o4
2016818: 7f ff ec f5 call 2011bec <_fat_block_write>
201681c: 90 10 00 1d mov %i5, %o0
2, (char *)(&time_val));
date = CT_LE_W(date);
2016820: c2 17 bf fe lduh [ %fp + -2 ], %g1
ret2 = _fat_block_write(&fs_info->fat, sec, byte + MSDOS_FILE_WDATE_OFFSET,
2016824: 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);
2016828: 83 28 60 10 sll %g1, 0x10, %g1
201682c: 85 30 60 08 srl %g1, 8, %g2
2016830: 83 30 60 18 srl %g1, 0x18, %g1
2016834: 82 10 80 01 or %g2, %g1, %g1
ret2 = _fat_block_write(&fs_info->fat, sec, byte + MSDOS_FILE_WDATE_OFFSET,
2016838: 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);
201683c: c2 37 bf fe sth %g1, [ %fp + -2 ]
ret2 = _fat_block_write(&fs_info->fat, sec, byte + MSDOS_FILE_WDATE_OFFSET,
2016840: 96 10 20 02 mov 2, %o3
2016844: 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,
2016848: 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,
201684c: 7f ff ec e8 call 2011bec <_fat_block_write>
2016850: 90 10 00 1d mov %i5, %o0
2, (char *)(&date));
ret3 = _fat_block_write(&fs_info->fat, sec, byte + MSDOS_FILE_ADATE_OFFSET,
2016854: 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,
2016858: b2 10 00 08 mov %o0, %i1
2, (char *)(&date));
ret3 = _fat_block_write(&fs_info->fat, sec, byte + MSDOS_FILE_ADATE_OFFSET,
201685c: 94 07 20 12 add %i4, 0x12, %o2
2016860: 90 10 00 1d mov %i5, %o0
2016864: 96 10 20 02 mov 2, %o3
2016868: 7f ff ec e1 call 2011bec <_fat_block_write>
201686c: 98 07 bf fe add %fp, -2, %o4
2, (char *)(&date));
if ( (ret1 < 0) || (ret2 < 0) || (ret3 < 0) )
2016870: 80 a6 60 00 cmp %i1, 0
2016874: 06 80 00 04 bl 2016884 <msdos_set_dir_wrt_time_and_date+0xd4><== NEVER TAKEN
2016878: 80 a6 a0 00 cmp %i2, 0
201687c: 16 80 00 04 bge 201688c <msdos_set_dir_wrt_time_and_date+0xdc><== ALWAYS TAKEN
2016880: 80 a2 20 00 cmp %o0, 0
return -1;
2016884: 81 c7 e0 08 ret <== NOT EXECUTED
2016888: 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) )
201688c: 06 bf ff fe bl 2016884 <msdos_set_dir_wrt_time_and_date+0xd4><== NEVER TAKEN
2016890: 01 00 00 00 nop
return -1;
return RC_OK;
}
2016894: 81 c7 e0 08 ret
2016898: 91 e8 20 00 restore %g0, 0, %o0
020169c8 <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
)
{
20169c8: 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;
20169cc: 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;
20169d0: fa 06 20 08 ld [ %i0 + 8 ], %i5
uint32_t dir_block_size;
fat_pos_t start = dir_pos->lname;
20169d4: c2 27 bf f0 st %g1, [ %fp + -16 ]
20169d8: c2 06 60 0c ld [ %i1 + 0xc ], %g1
fat_pos_t end = dir_pos->sname;
20169dc: 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;
20169e0: c2 27 bf f4 st %g1, [ %fp + -12 ]
fat_pos_t end = dir_pos->sname;
20169e4: 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
)
{
20169e8: 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;
20169ec: c2 27 bf fc st %g1, [ %fp + -4 ]
if ((end.cln == fs_info->fat.vol.rdir_cl) &&
20169f0: c2 07 60 38 ld [ %i5 + 0x38 ], %g1
20169f4: 80 a7 00 01 cmp %i4, %g1
20169f8: 12 80 00 08 bne 2016a18 <msdos_set_first_char4file_name+0x50><== NEVER TAKEN
20169fc: f8 27 bf f8 st %i4, [ %fp + -8 ]
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))
2016a00: 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) &&
2016a04: 80 88 60 03 btst 3, %g1
2016a08: 22 80 00 05 be,a 2016a1c <msdos_set_first_char4file_name+0x54><== NEVER TAKEN
2016a0c: 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;
2016a10: 10 80 00 03 b 2016a1c <msdos_set_first_char4file_name+0x54>
2016a14: f6 07 60 28 ld [ %i5 + 0x28 ], %i3
else
dir_block_size = fs_info->fat.vol.bpc;
2016a18: f6 17 60 06 lduh [ %i5 + 6 ], %i3 <== NOT EXECUTED
if (dir_pos->lname.cln == FAT_FILE_SHORT_NAME)
2016a1c: c2 06 60 08 ld [ %i1 + 8 ], %g1
2016a20: 80 a0 7f ff cmp %g1, -1
2016a24: 12 80 00 07 bne 2016a40 <msdos_set_first_char4file_name+0x78>
2016a28: d2 07 bf f0 ld [ %fp + -16 ], %o1
start = dir_pos->sname;
2016a2c: c2 06 40 00 ld [ %i1 ], %g1
2016a30: c2 27 bf f0 st %g1, [ %fp + -16 ]
2016a34: c2 06 60 04 ld [ %i1 + 4 ], %g1
2016a38: 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) +
2016a3c: d2 07 bf f0 ld [ %fp + -16 ], %o1
2016a40: 7f ff fe c3 call 201654c <fat_cluster_num_to_sector_num>
2016a44: 90 10 00 1d mov %i5, %o0
(start.ofs >> fs_info->fat.vol.sec_log2));
2016a48: c2 07 bf f4 ld [ %fp + -12 ], %g1
2016a4c: d2 0f 60 02 ldub [ %i5 + 2 ], %o1
uint32_t byte = (start.ofs & (fs_info->fat.vol.bps - 1));
2016a50: 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));
2016a54: 93 30 40 09 srl %g1, %o1, %o1
uint32_t byte = (start.ofs & (fs_info->fat.vol.bps - 1));
2016a58: 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) +
2016a5c: 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,
2016a60: 94 0a 80 01 and %o2, %g1, %o2
2016a64: 90 10 00 1d mov %i5, %o0
2016a68: 96 10 20 01 mov 1, %o3
2016a6c: 7f ff ec 60 call 2011bec <_fat_block_write>
2016a70: 98 07 a0 4c add %fp, 0x4c, %o4
1, &fchar);
if (ret < 0)
2016a74: 80 a2 20 00 cmp %o0, 0
2016a78: 06 80 00 1e bl 2016af0 <msdos_set_first_char4file_name+0x128><== NEVER TAKEN
2016a7c: d2 07 bf f0 ld [ %fp + -16 ], %o1
return -1;
if ((start.cln == end.cln) && (start.ofs == end.ofs))
2016a80: 80 a2 40 1c cmp %o1, %i4
2016a84: 12 80 00 08 bne 2016aa4 <msdos_set_first_char4file_name+0xdc><== NEVER TAKEN
2016a88: c2 07 bf f4 ld [ %fp + -12 ], %g1
2016a8c: c4 07 bf fc ld [ %fp + -4 ], %g2
2016a90: 80 a0 40 02 cmp %g1, %g2
2016a94: 12 80 00 05 bne 2016aa8 <msdos_set_first_char4file_name+0xe0>
2016a98: 82 00 60 20 add %g1, 0x20, %g1
return rc;
start.ofs = 0;
}
}
return RC_OK;
2016a9c: 81 c7 e0 08 ret
2016aa0: 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;
2016aa4: 82 00 60 20 add %g1, 0x20, %g1 <== NOT EXECUTED
if (start.ofs >= dir_block_size)
2016aa8: 80 a0 40 1b cmp %g1, %i3
2016aac: 0a bf ff e4 bcs 2016a3c <msdos_set_first_char4file_name+0x74><== ALWAYS TAKEN
2016ab0: c2 27 bf f4 st %g1, [ %fp + -12 ]
{
int rc;
if ((end.cln == fs_info->fat.vol.rdir_cl) &&
2016ab4: c2 07 60 38 ld [ %i5 + 0x38 ], %g1 <== NOT EXECUTED
2016ab8: 80 a7 00 01 cmp %i4, %g1 <== NOT EXECUTED
2016abc: 12 80 00 06 bne 2016ad4 <msdos_set_first_char4file_name+0x10c><== NOT EXECUTED
2016ac0: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))
2016ac4: 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) &&
2016ac8: 80 88 60 03 btst 3, %g1 <== NOT EXECUTED
2016acc: 12 bf ff f4 bne 2016a9c <msdos_set_first_char4file_name+0xd4><== NOT EXECUTED
2016ad0: 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);
2016ad4: 40 00 05 48 call 2017ff4 <fat_get_fat_cluster> <== NOT EXECUTED
2016ad8: 94 07 bf f0 add %fp, -16, %o2 <== NOT EXECUTED
if ( rc != RC_OK )
2016adc: b0 92 20 00 orcc %o0, 0, %i0 <== NOT EXECUTED
2016ae0: 12 80 00 05 bne 2016af4 <msdos_set_first_char4file_name+0x12c><== NOT EXECUTED
2016ae4: 01 00 00 00 nop <== NOT EXECUTED
return rc;
start.ofs = 0;
2016ae8: 10 bf ff d5 b 2016a3c <msdos_set_first_char4file_name+0x74><== NOT EXECUTED
2016aec: 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;
2016af0: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
start.ofs = 0;
}
}
return RC_OK;
}
2016af4: 81 c7 e0 08 ret <== NOT EXECUTED
2016af8: 81 e8 00 00 restore <== NOT EXECUTED
0201689c <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
)
{
201689c: 9d e3 bf 98 save %sp, -104, %sp
ssize_t ret1 = 0, ret2 = 0;
msdos_fs_info_t *fs_info = mt_entry->fs_info;
20168a0: 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);
20168a4: 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;
20168a8: c0 37 bf fc clrh [ %fp + -4 ]
uint16_t le_cl_hi = 0;
20168ac: 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);
20168b0: 7f ff ff 27 call 201654c <fat_cluster_num_to_sector_num>
20168b4: 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;
20168b8: 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);
20168bc: 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);
20168c0: 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);
20168c4: 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);
20168c8: 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);
20168cc: 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);
20168d0: b6 0e c0 01 and %i3, %g1, %i3
rc = msdos_sync_unprotected(fs_info);
rtems_semaphore_release(fs_info->vol_sema);
return rc;
}
20168d4: 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));
20168d8: 83 2f 20 10 sll %i4, 0x10, %g1
rc = msdos_sync_unprotected(fs_info);
rtems_semaphore_release(fs_info->vol_sema);
return rc;
}
20168dc: 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));
20168e0: 83 30 60 18 srl %g1, 0x18, %g1
rc = msdos_sync_unprotected(fs_info);
rtems_semaphore_release(fs_info->vol_sema);
return rc;
}
20168e4: 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));
20168e8: 85 28 a0 08 sll %g2, 8, %g2
20168ec: 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);
20168f0: 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));
20168f4: c2 37 bf fc sth %g1, [ %fp + -4 ]
ret1 = _fat_block_write(&fs_info->fat, sec,
20168f8: 92 10 00 1a mov %i2, %o1
20168fc: 94 06 e0 1a add %i3, 0x1a, %o2
2016900: 96 10 20 02 mov 2, %o3
2016904: 98 07 bf fc add %fp, -4, %o4
2016908: 7f ff ec b9 call 2011bec <_fat_block_write>
201690c: 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));
2016910: 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,
2016914: a0 10 00 08 mov %o0, %l0
rc = msdos_sync_unprotected(fs_info);
rtems_semaphore_release(fs_info->vol_sema);
return rc;
}
2016918: 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,
201691c: 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));
2016920: b3 2e 60 08 sll %i1, 8, %i1
2016924: b9 37 20 08 srl %i4, 8, %i4
ret2 = _fat_block_write(&fs_info->fat, sec,
2016928: 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));
201692c: b8 16 40 1c or %i1, %i4, %i4
ret2 = _fat_block_write(&fs_info->fat, sec,
2016930: 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));
2016934: f8 37 bf fe sth %i4, [ %fp + -2 ]
ret2 = _fat_block_write(&fs_info->fat, sec,
2016938: 96 10 20 02 mov 2, %o3
201693c: 7f ff ec ac call 2011bec <_fat_block_write>
2016940: 98 07 bf fe add %fp, -2, %o4
byte + MSDOS_FIRST_CLUSTER_HI_OFFSET, 2,
(char *)(&le_cl_hi));
if ( (ret1 < 0) || (ret2 < 0) )
2016944: 80 a2 20 00 cmp %o0, 0
2016948: 06 80 00 04 bl 2016958 <msdos_set_first_cluster_num+0xbc> <== NEVER TAKEN
201694c: 80 a4 20 00 cmp %l0, 0
2016950: 16 80 00 03 bge 201695c <msdos_set_first_cluster_num+0xc0><== ALWAYS TAKEN
2016954: b0 10 20 00 clr %i0
return -1;
2016958: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
return RC_OK;
}
201695c: 81 c7 e0 08 ret
2016960: 81 e8 00 00 restore
02017d28 <msdos_sync>:
int
msdos_sync(rtems_libio_t *iop)
{
2017d28: 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;
2017d2c: c2 06 20 28 ld [ %i0 + 0x28 ], %g1 <== NOT EXECUTED
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
2017d30: 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;
2017d34: fa 00 60 08 ld [ %g1 + 8 ], %i5 <== NOT EXECUTED
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
2017d38: 94 10 20 00 clr %o2 <== NOT EXECUTED
2017d3c: 7f ff c4 44 call 2008e4c <rtems_semaphore_obtain> <== NOT EXECUTED
2017d40: d0 07 60 90 ld [ %i5 + 0x90 ], %o0 <== NOT EXECUTED
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
2017d44: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2017d48: 02 80 00 08 be 2017d68 <msdos_sync+0x40> <== NOT EXECUTED
2017d4c: 01 00 00 00 nop <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
2017d50: 40 00 08 b4 call 201a020 <__errno> <== NOT EXECUTED
2017d54: b0 10 3f ff mov -1, %i0 ! ffffffff <RAM_END+0xfdbfffff> <== NOT EXECUTED
2017d58: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
2017d5c: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
2017d60: 81 c7 e0 08 ret <== NOT EXECUTED
2017d64: 81 e8 00 00 restore <== NOT EXECUTED
rc = msdos_sync_unprotected(fs_info);
2017d68: 7f ff ff e1 call 2017cec <msdos_sync_unprotected> <== NOT EXECUTED
2017d6c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
2017d70: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED
rtems_semaphore_release(fs_info->vol_sema);
2017d74: 7f ff c4 80 call 2008f74 <rtems_semaphore_release> <== NOT EXECUTED
2017d78: d0 07 60 90 ld [ %i5 + 0x90 ], %o0 <== NOT EXECUTED
return rc;
}
2017d7c: 81 c7 e0 08 ret <== NOT EXECUTED
2017d80: 81 e8 00 00 restore <== NOT EXECUTED
02017cec <msdos_sync_unprotected>:
return MSDOS_NAME_NOT_FOUND_ERR;
}
int
msdos_sync_unprotected(msdos_fs_info_t *fs_info)
{
2017cec: 9d e3 bf a0 save %sp, -96, %sp
int rc = fat_buf_release(&fs_info->fat);
2017cf0: 7f ff e7 45 call 2011a04 <fat_buf_release>
2017cf4: 90 10 00 18 mov %i0, %o0
2017cf8: ba 10 00 08 mov %o0, %i5
rtems_status_code sc = rtems_bdbuf_syncdev(fs_info->fat.vol.dd);
2017cfc: 7f ff e1 bd call 20103f0 <rtems_bdbuf_syncdev>
2017d00: d0 06 20 58 ld [ %i0 + 0x58 ], %o0
if (sc != RTEMS_SUCCESSFUL) {
2017d04: 80 a2 20 00 cmp %o0, 0
2017d08: 02 80 00 06 be 2017d20 <msdos_sync_unprotected+0x34> <== ALWAYS TAKEN
2017d0c: 01 00 00 00 nop
errno = EIO;
2017d10: 40 00 08 c4 call 201a020 <__errno> <== NOT EXECUTED
2017d14: ba 10 3f ff mov -1, %i5 ! ffffffff <RAM_END+0xfdbfffff> <== NOT EXECUTED
2017d18: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
2017d1c: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
rc = -1;
}
return rc;
}
2017d20: 81 c7 e0 08 ret
2017d24: 91 e8 00 1d restore %g0, %i5, %o0
0200d9dc <msdos_unlock>:
rtems_fatal_error_occurred(0xdeadbeef);
}
}
void msdos_unlock(const rtems_filesystem_mount_table_entry_t *mt_entry)
{
200d9dc: 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);
200d9e0: c2 06 20 08 ld [ %i0 + 8 ], %g1
200d9e4: 7f ff ed 64 call 2008f74 <rtems_semaphore_release>
200d9e8: d0 00 60 90 ld [ %g1 + 0x90 ], %o0
if (sc != RTEMS_SUCCESSFUL) {
200d9ec: 80 a2 20 00 cmp %o0, 0
200d9f0: 02 80 00 04 be 200da00 <msdos_unlock+0x24> <== ALWAYS TAKEN
200d9f4: 11 37 ab 6f sethi %hi(0xdeadbc00), %o0
rtems_fatal_error_occurred(0xdeadbeef);
200d9f8: 7f ff ee c6 call 2009510 <rtems_fatal_error_occurred> <== NOT EXECUTED
200d9fc: 90 12 22 ef or %o0, 0x2ef, %o0 ! deadbeef <RAM_END+0xdc6dbeef><== NOT EXECUTED
200da00: 81 c7 e0 08 ret
200da04: 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 78 ld [ %g1 + 0x78 ], %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 78 ld [ %g1 + 0x278 ], %g1 ! 201c278 <_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 a5 call 2010224 <_fwalk>
2004394: 92 12 61 4c or %o1, 0x14c, %o1
#if REENT_MALLOCED
free(ptr);
#else
_Workspace_Free(ptr);
2004398: 40 00 1b a9 call 200b23c <_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 78 clr [ %g1 + 0x78 ] ! 201d078 <_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 44 call 200fe60 <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 73 call 200fb60 <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 50 call 20181f8 <printf> <== NOT EXECUTED
2001cbc: 31 00 80 8b sethi %hi(0x2022c00), %i0 <== NOT EXECUTED
printf (" PLEASE NOTIFY KARPINKSI!\n");
2001cc0: 40 00 59 8f call 20182fc <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 70 or %o0, 0x370, %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 78 or %o0, 0x378, %o0 ! 201b778 <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 70 ld [ %g1 + 0x70 ], %g1 ! 201d070 <__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 70 ld [ %g2 + 0x70 ], %g2 ! 201d070 <__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 2e call 2016a7c <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 6b call 20099d0 <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 3b call 200991c <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
0200cff0 <pipe_create>:
* Called by pipe() to create an anonymous pipe.
*/
int pipe_create(
int filsdes[2]
)
{
200cff0: 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)
200cff4: 11 00 80 82 sethi %hi(0x2020800), %o0
200cff8: 92 10 21 ff mov 0x1ff, %o1
200cffc: 40 00 05 4e call 200e534 <rtems_mkdir>
200d000: 90 12 22 48 or %o0, 0x248, %o0
200d004: 80 a2 20 00 cmp %o0, 0
200d008: 12 80 00 47 bne 200d124 <pipe_create+0x134> <== NEVER TAKEN
200d00c: 03 00 00 19 sethi %hi(0x6400), %g1
return -1;
/* /tmp/.fifoXXXX */
char fifopath[15];
memcpy(fifopath, "/tmp/.fifo", 10);
200d010: 82 10 62 6f or %g1, 0x26f, %g1 ! 666f <PROM_START+0x666f>
200d014: c2 37 bf f8 sth %g1, [ %fp + -8 ]
sprintf(fifopath + 10, "%04x", rtems_pipe_no ++);
200d018: 03 00 80 89 sethi %hi(0x2022400), %g1
200d01c: d4 10 62 00 lduh [ %g1 + 0x200 ], %o2 ! 2022600 <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);
200d020: 05 0b dd 1b sethi %hi(0x2f746c00), %g2
200d024: 84 10 a1 70 or %g2, 0x170, %g2 ! 2f746d70 <RAM_END+0x2d346d70>
200d028: 07 0b cb 99 sethi %hi(0x2f2e6400), %g3
200d02c: 86 10 e2 69 or %g3, 0x269, %g3 ! 2f2e6669 <RAM_END+0x2cee6669>
200d030: c4 3f bf f0 std %g2, [ %fp + -16 ]
sprintf(fifopath + 10, "%04x", rtems_pipe_no ++);
200d034: 84 02 a0 01 add %o2, 1, %g2
200d038: 90 07 bf fa add %fp, -6, %o0
200d03c: c4 30 62 00 sth %g2, [ %g1 + 0x200 ]
200d040: 95 2a a0 10 sll %o2, 0x10, %o2
200d044: 13 00 80 82 sethi %hi(0x2020800), %o1
200d048: 95 32 a0 10 srl %o2, 0x10, %o2
200d04c: 40 00 13 e6 call 2011fe4 <sprintf>
200d050: 92 12 62 50 or %o1, 0x250, %o1
/* Try creating FIFO file until find an available file name */
while (mkfifo(fifopath, S_IRUSR|S_IWUSR) != 0) {
200d054: 90 07 bf f0 add %fp, -16, %o0
200d058: 40 00 04 8d call 200e28c <mkfifo>
200d05c: 92 10 21 80 mov 0x180, %o1
200d060: 80 a2 20 00 cmp %o0, 0
200d064: 02 80 00 05 be 200d078 <pipe_create+0x88> <== ALWAYS TAKEN
200d068: 90 07 bf f0 add %fp, -16, %o0
if (errno != EEXIST){
200d06c: 40 00 10 7d call 2011260 <__errno> <== NOT EXECUTED
200d070: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
200d074: 30 80 00 2d b,a 200d128 <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);
200d078: 7f ff df ad call 2004f2c <open>
200d07c: 13 00 00 10 sethi %hi(0x4000), %o1
if (filsdes[0] < 0) {
200d080: 80 a2 20 00 cmp %o0, 0
200d084: 16 80 00 06 bge 200d09c <pipe_create+0xac> <== ALWAYS TAKEN
200d088: d0 26 00 00 st %o0, [ %i0 ]
err = errno;
200d08c: 40 00 10 75 call 2011260 <__errno> <== NOT EXECUTED
200d090: 01 00 00 00 nop <== NOT EXECUTED
200d094: 10 80 00 1c b 200d104 <pipe_create+0x114> <== NOT EXECUTED
200d098: fa 02 00 00 ld [ %o0 ], %i5 <== NOT EXECUTED
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]);
200d09c: 03 00 80 87 sethi %hi(0x2021c00), %g1
200d0a0: c4 00 61 30 ld [ %g1 + 0x130 ], %g2 ! 2021d30 <rtems_libio_number_iops>
200d0a4: 80 a2 00 02 cmp %o0, %g2
200d0a8: 1a 80 00 08 bcc 200d0c8 <pipe_create+0xd8> <== NEVER TAKEN
200d0ac: 82 10 20 00 clr %g1
200d0b0: 83 2a 20 03 sll %o0, 3, %g1
200d0b4: 91 2a 20 06 sll %o0, 6, %o0
200d0b8: 90 22 00 01 sub %o0, %g1, %o0
200d0bc: 03 00 80 8a sethi %hi(0x2022800), %g1
200d0c0: c2 00 60 68 ld [ %g1 + 0x68 ], %g1 ! 2022868 <rtems_libio_iops>
200d0c4: 82 00 40 08 add %g1, %o0, %g1
iop->flags &= ~LIBIO_FLAGS_NO_DELAY;
200d0c8: c4 00 60 10 ld [ %g1 + 0x10 ], %g2
filsdes[1] = open(fifopath, O_WRONLY);
200d0cc: 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;
200d0d0: 84 08 bf fe and %g2, -2, %g2
filsdes[1] = open(fifopath, O_WRONLY);
200d0d4: 92 10 20 01 mov 1, %o1
200d0d8: 7f ff df 95 call 2004f2c <open>
200d0dc: c4 20 60 10 st %g2, [ %g1 + 0x10 ]
200d0e0: d0 26 20 04 st %o0, [ %i0 + 4 ]
if (filsdes[1] < 0) {
200d0e4: 80 a2 20 00 cmp %o0, 0
200d0e8: 16 80 00 07 bge 200d104 <pipe_create+0x114> <== ALWAYS TAKEN
200d0ec: ba 10 20 00 clr %i5
err = errno;
200d0f0: 40 00 10 5c call 2011260 <__errno> <== NOT EXECUTED
200d0f4: 01 00 00 00 nop <== NOT EXECUTED
200d0f8: fa 02 00 00 ld [ %o0 ], %i5 <== NOT EXECUTED
close(filsdes[0]);
200d0fc: 7f ff db 61 call 2003e80 <close> <== NOT EXECUTED
200d100: d0 06 00 00 ld [ %i0 ], %o0 <== NOT EXECUTED
}
unlink(fifopath);
200d104: 7f ff eb 01 call 2007d08 <unlink>
200d108: 90 07 bf f0 add %fp, -16, %o0
}
if(err != 0)
200d10c: 80 a7 60 00 cmp %i5, 0
200d110: 02 80 00 06 be 200d128 <pipe_create+0x138> <== ALWAYS TAKEN
200d114: b0 10 20 00 clr %i0
rtems_set_errno_and_return_minus_one(err);
200d118: 40 00 10 52 call 2011260 <__errno> <== NOT EXECUTED
200d11c: 01 00 00 00 nop <== NOT EXECUTED
200d120: fa 22 00 00 st %i5, [ %o0 ] <== NOT EXECUTED
{
rtems_libio_t *iop;
int err = 0;
if (rtems_mkdir("/tmp", S_IRWXU | S_IRWXG | S_IRWXO) != 0)
return -1;
200d124: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
unlink(fifopath);
}
if(err != 0)
rtems_set_errno_and_return_minus_one(err);
return 0;
}
200d128: 81 c7 e0 08 ret
200d12c: 81 e8 00 00 restore
0200e604 <pipe_ioctl>:
pipe_control_t *pipe,
ioctl_command_t cmd,
void *buffer,
rtems_libio_t *iop
)
{
200e604: 9d e3 bf a0 save %sp, -96, %sp
if (cmd == FIONREAD) {
200e608: 03 10 01 19 sethi %hi(0x40046400), %g1
200e60c: 82 10 62 7f or %g1, 0x27f, %g1 ! 4004667f <RAM_END+0x3dc4667f>
200e610: 80 a6 40 01 cmp %i1, %g1
200e614: 12 80 00 11 bne 200e658 <pipe_ioctl+0x54>
200e618: 80 a6 a0 00 cmp %i2, 0
if (buffer == NULL)
200e61c: 02 80 00 11 be 200e660 <pipe_ioctl+0x5c>
200e620: 92 10 20 00 clr %o1
return -EFAULT;
if (! PIPE_LOCK(pipe))
200e624: d0 06 20 28 ld [ %i0 + 0x28 ], %o0
200e628: 7f ff ea da call 2009190 <rtems_semaphore_obtain>
200e62c: 94 10 20 00 clr %o2
200e630: 80 a2 20 00 cmp %o0, 0
200e634: 12 80 00 0d bne 200e668 <pipe_ioctl+0x64> <== NEVER TAKEN
200e638: 01 00 00 00 nop
return -EINTR;
/* Return length of pipe */
*(unsigned int *)buffer = pipe->Length;
200e63c: c2 06 20 0c ld [ %i0 + 0xc ], %g1
PIPE_UNLOCK(pipe);
200e640: d0 06 20 28 ld [ %i0 + 0x28 ], %o0
if (! PIPE_LOCK(pipe))
return -EINTR;
/* Return length of pipe */
*(unsigned int *)buffer = pipe->Length;
200e644: c2 26 80 00 st %g1, [ %i2 ]
PIPE_UNLOCK(pipe);
200e648: 7f ff eb 1c call 20092b8 <rtems_semaphore_release>
200e64c: b0 10 20 00 clr %i0
return 0;
200e650: 81 c7 e0 08 ret
200e654: 81 e8 00 00 restore
}
return -EINVAL;
200e658: 81 c7 e0 08 ret
200e65c: 91 e8 3f ea restore %g0, -22, %o0
rtems_libio_t *iop
)
{
if (cmd == FIONREAD) {
if (buffer == NULL)
return -EFAULT;
200e660: 81 c7 e0 08 ret
200e664: 91 e8 3f f2 restore %g0, -14, %o0
PIPE_UNLOCK(pipe);
return 0;
}
return -EINVAL;
}
200e668: 81 c7 e0 08 ret <== NOT EXECUTED
200e66c: 91 e8 3f fc restore %g0, -4, %o0 <== NOT EXECUTED
0200e298 <pipe_read>:
pipe_control_t *pipe,
void *buffer,
size_t count,
rtems_libio_t *iop
)
{
200e298: 9d e3 bf 98 save %sp, -104, %sp
int chunk, chunk1, read = 0, ret = 0;
if (! PIPE_LOCK(pipe))
200e29c: d0 06 20 28 ld [ %i0 + 0x28 ], %o0
200e2a0: 92 10 20 00 clr %o1
200e2a4: 94 10 20 00 clr %o2
200e2a8: 7f ff eb ba call 2009190 <rtems_semaphore_obtain>
200e2ac: ba 10 00 18 mov %i0, %i5
200e2b0: 80 a2 20 00 cmp %o0, 0
200e2b4: 32 80 00 5d bne,a 200e428 <pipe_read+0x190> <== NEVER TAKEN
200e2b8: b0 10 3f fc mov -4, %i0 <== NOT EXECUTED
200e2bc: 10 80 00 4d b 200e3f0 <pipe_read+0x158>
200e2c0: b0 10 20 00 clr %i0
return -EINTR;
while (read < count) {
while (PIPE_EMPTY(pipe)) {
/* Not an error */
if (pipe->Writers == 0)
200e2c4: 80 a0 60 00 cmp %g1, 0
200e2c8: 32 80 00 04 bne,a 200e2d8 <pipe_read+0x40>
200e2cc: c2 06 e0 10 ld [ %i3 + 0x10 ], %g1
rtems_libio_t *iop
)
{
int chunk, chunk1, read = 0, ret = 0;
if (! PIPE_LOCK(pipe))
200e2d0: 10 80 00 4c b 200e400 <pipe_read+0x168>
200e2d4: b8 10 20 00 clr %i4
while (PIPE_EMPTY(pipe)) {
/* Not an error */
if (pipe->Writers == 0)
goto out_locked;
if (LIBIO_NODELAY(iop)) {
200e2d8: 80 88 60 01 btst 1, %g1
200e2dc: 32 80 00 49 bne,a 200e400 <pipe_read+0x168>
200e2e0: 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 ++;
200e2e4: c2 07 60 18 ld [ %i5 + 0x18 ], %g1
PIPE_UNLOCK(pipe);
200e2e8: 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 ++;
200e2ec: 82 00 60 01 inc %g1
PIPE_UNLOCK(pipe);
200e2f0: 7f ff eb f2 call 20092b8 <rtems_semaphore_release>
200e2f4: c2 27 60 18 st %g1, [ %i5 + 0x18 ]
if (! PIPE_READWAIT(pipe))
200e2f8: d0 07 60 2c ld [ %i5 + 0x2c ], %o0
200e2fc: 40 00 05 68 call 200f89c <rtems_barrier_wait>
200e300: 92 10 20 00 clr %o1
200e304: 80 a0 00 08 cmp %g0, %o0
ret = -EINTR;
if (! PIPE_LOCK(pipe)) {
200e308: 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))
200e30c: b8 60 20 00 subx %g0, 0, %i4
ret = -EINTR;
if (! PIPE_LOCK(pipe)) {
200e310: 92 10 20 00 clr %o1
200e314: 94 10 20 00 clr %o2
200e318: 7f ff eb 9e call 2009190 <rtems_semaphore_obtain>
200e31c: b8 0f 3f fc and %i4, -4, %i4
200e320: 80 a2 20 00 cmp %o0, 0
200e324: 12 80 00 3b bne 200e410 <pipe_read+0x178> <== NEVER TAKEN
200e328: 80 a7 20 00 cmp %i4, 0
/* WARN waitingReaders not restored! */
ret = -EINTR;
goto out_nolock;
}
pipe->waitingReaders --;
200e32c: c2 07 60 18 ld [ %i5 + 0x18 ], %g1
200e330: 82 00 7f ff add %g1, -1, %g1
if (ret != 0)
200e334: 12 80 00 33 bne 200e400 <pipe_read+0x168> <== NEVER TAKEN
200e338: c2 27 60 18 st %g1, [ %i5 + 0x18 ]
if (! PIPE_LOCK(pipe))
return -EINTR;
while (read < count) {
while (PIPE_EMPTY(pipe)) {
200e33c: f8 07 60 0c ld [ %i5 + 0xc ], %i4
200e340: 80 a7 20 00 cmp %i4, 0
200e344: 22 bf ff e0 be,a 200e2c4 <pipe_read+0x2c>
200e348: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
if (ret != 0)
goto out_locked;
}
/* Read chunk bytes */
chunk = MIN(count - read, pipe->Length);
200e34c: 82 26 80 18 sub %i2, %i0, %g1
200e350: 80 a7 00 01 cmp %i4, %g1
200e354: 38 80 00 02 bgu,a 200e35c <pipe_read+0xc4>
200e358: b8 10 00 01 mov %g1, %i4
chunk1 = pipe->Size - pipe->Start;
200e35c: c2 07 60 08 ld [ %i5 + 8 ], %g1
200e360: e0 07 60 04 ld [ %i5 + 4 ], %l0
200e364: d2 07 40 00 ld [ %i5 ], %o1
200e368: 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);
200e36c: 94 10 00 1c mov %i4, %o2
}
/* Read chunk bytes */
chunk = MIN(count - read, pipe->Length);
chunk1 = pipe->Size - pipe->Start;
if (chunk > chunk1) {
200e370: 80 a7 00 10 cmp %i4, %l0
200e374: 90 06 40 18 add %i1, %i0, %o0
200e378: 04 80 00 09 ble 200e39c <pipe_read+0x104>
200e37c: 92 02 40 01 add %o1, %g1, %o1
memcpy(buffer + read, pipe->Buffer + pipe->Start, chunk1);
200e380: 40 00 11 96 call 20129d8 <memcpy>
200e384: 94 10 00 10 mov %l0, %o2
memcpy(buffer + read + chunk1, pipe->Buffer, chunk - chunk1);
200e388: 90 06 00 10 add %i0, %l0, %o0
200e38c: d2 07 40 00 ld [ %i5 ], %o1
200e390: 90 06 40 08 add %i1, %o0, %o0
200e394: 10 80 00 02 b 200e39c <pipe_read+0x104>
200e398: 94 27 00 10 sub %i4, %l0, %o2
}
else
memcpy(buffer + read, pipe->Buffer + pipe->Start, chunk);
200e39c: 40 00 11 8f call 20129d8 <memcpy>
200e3a0: 01 00 00 00 nop
pipe->Start += chunk;
200e3a4: d0 07 60 08 ld [ %i5 + 8 ], %o0
pipe->Start %= pipe->Size;
200e3a8: d2 07 60 04 ld [ %i5 + 4 ], %o1
200e3ac: 40 00 41 a4 call 201ea3c <.urem>
200e3b0: 90 07 00 08 add %i4, %o0, %o0
pipe->Length -= chunk;
200e3b4: c2 07 60 0c ld [ %i5 + 0xc ], %g1
}
else
memcpy(buffer + read, pipe->Buffer + pipe->Start, chunk);
pipe->Start += chunk;
pipe->Start %= pipe->Size;
200e3b8: d0 27 60 08 st %o0, [ %i5 + 8 ]
pipe->Length -= chunk;
200e3bc: 82 20 40 1c sub %g1, %i4, %g1
/* For buffering optimization */
if (PIPE_EMPTY(pipe))
200e3c0: 80 a0 60 00 cmp %g1, 0
200e3c4: 12 80 00 03 bne 200e3d0 <pipe_read+0x138>
200e3c8: c2 27 60 0c st %g1, [ %i5 + 0xc ]
pipe->Start = 0;
200e3cc: c0 27 60 08 clr [ %i5 + 8 ]
if (pipe->waitingWriters > 0)
200e3d0: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
200e3d4: 80 a0 60 00 cmp %g1, 0
200e3d8: 22 80 00 06 be,a 200e3f0 <pipe_read+0x158>
200e3dc: b0 06 00 1c add %i0, %i4, %i0
PIPE_WAKEUPWRITERS(pipe);
200e3e0: d0 07 60 30 ld [ %i5 + 0x30 ], %o0
200e3e4: 40 00 05 18 call 200f844 <rtems_barrier_release>
200e3e8: 92 07 bf fc add %fp, -4, %o1
read += chunk;
200e3ec: b0 06 00 1c add %i0, %i4, %i0
int chunk, chunk1, read = 0, ret = 0;
if (! PIPE_LOCK(pipe))
return -EINTR;
while (read < count) {
200e3f0: 80 a6 00 1a cmp %i0, %i2
200e3f4: 2a bf ff d3 bcs,a 200e340 <pipe_read+0xa8>
200e3f8: f8 07 60 0c ld [ %i5 + 0xc ], %i4
200e3fc: b8 10 20 00 clr %i4
PIPE_WAKEUPWRITERS(pipe);
read += chunk;
}
out_locked:
PIPE_UNLOCK(pipe);
200e400: 7f ff eb ae call 20092b8 <rtems_semaphore_release>
200e404: d0 07 60 28 ld [ %i5 + 0x28 ], %o0
out_nolock:
if (read > 0)
200e408: 10 80 00 04 b 200e418 <pipe_read+0x180>
200e40c: 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;
200e410: b8 10 3f fc mov -4, %i4 <== NOT EXECUTED
out_locked:
PIPE_UNLOCK(pipe);
out_nolock:
if (read > 0)
200e414: 80 a6 20 00 cmp %i0, 0 <== NOT EXECUTED
200e418: 14 80 00 04 bg 200e428 <pipe_read+0x190>
200e41c: 01 00 00 00 nop
return read;
return ret;
200e420: 81 c7 e0 08 ret
200e424: 91 e8 00 1c restore %g0, %i4, %o0
}
200e428: 81 c7 e0 08 ret
200e42c: 81 e8 00 00 restore
0200dd88 <pipe_release>:
*/
void pipe_release(
pipe_control_t **pipep,
rtems_libio_t *iop
)
{
200dd88: 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);
200dd8c: c2 06 60 10 ld [ %i1 + 0x10 ], %g1
void pipe_release(
pipe_control_t **pipep,
rtems_libio_t *iop
)
{
pipe_control_t *pipe = *pipep;
200dd90: 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)
200dd94: 80 88 60 02 btst 2, %g1
200dd98: 02 80 00 05 be 200ddac <pipe_release+0x24>
200dd9c: b8 08 60 06 and %g1, 6, %i4
pipe->Readers --;
200dda0: c4 07 60 10 ld [ %i5 + 0x10 ], %g2
200dda4: 84 00 bf ff add %g2, -1, %g2
200dda8: c4 27 60 10 st %g2, [ %i5 + 0x10 ]
if (mode & LIBIO_FLAGS_WRITE)
200ddac: 80 88 60 04 btst 4, %g1
200ddb0: 02 80 00 05 be 200ddc4 <pipe_release+0x3c>
200ddb4: 01 00 00 00 nop
pipe->Writers --;
200ddb8: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
200ddbc: 82 00 7f ff add %g1, -1, %g1
200ddc0: c2 27 60 14 st %g1, [ %i5 + 0x14 ]
PIPE_UNLOCK(pipe);
200ddc4: 7f ff ed 3d call 20092b8 <rtems_semaphore_release>
200ddc8: d0 07 60 28 ld [ %i5 + 0x28 ], %o0
if (pipe->Readers == 0 && pipe->Writers == 0) {
200ddcc: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
200ddd0: 80 a0 60 00 cmp %g1, 0
200ddd4: 12 80 00 0d bne 200de08 <pipe_release+0x80>
200ddd8: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
200dddc: 80 a0 60 00 cmp %g1, 0
200dde0: 12 80 00 06 bne 200ddf8 <pipe_release+0x70>
200dde4: 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);
200dde8: 7f ff ff dd call 200dd5c <pipe_free>
200ddec: 90 10 00 1d mov %i5, %o0
*pipep = NULL;
200ddf0: 10 80 00 0e b 200de28 <pipe_release+0xa0>
200ddf4: c0 26 00 00 clr [ %i0 ]
}
else if (pipe->Readers == 0 && mode != LIBIO_FLAGS_WRITE)
200ddf8: 02 80 00 05 be 200de0c <pipe_release+0x84> <== NEVER TAKEN
200ddfc: 80 a0 60 00 cmp %g1, 0
/* Notify waiting Writers that all their partners left */
PIPE_WAKEUPWRITERS(pipe);
200de00: 10 80 00 08 b 200de20 <pipe_release+0x98>
200de04: d0 07 60 30 ld [ %i5 + 0x30 ], %o0
else if (pipe->Writers == 0 && mode != LIBIO_FLAGS_READ)
200de08: 80 a0 60 00 cmp %g1, 0
200de0c: 12 80 00 07 bne 200de28 <pipe_release+0xa0> <== NEVER TAKEN
200de10: 80 a7 20 02 cmp %i4, 2
200de14: 02 80 00 06 be 200de2c <pipe_release+0xa4> <== NEVER TAKEN
200de18: 03 00 80 8d sethi %hi(0x2023400), %g1
PIPE_WAKEUPREADERS(pipe);
200de1c: d0 07 60 2c ld [ %i5 + 0x2c ], %o0
200de20: 40 00 06 89 call 200f844 <rtems_barrier_release>
200de24: 92 07 bf fc add %fp, -4, %o1
#ifdef RTEMS_DEBUG
rtems_status_code sc = RTEMS_SUCCESSFUL;
sc =
#endif
rtems_semaphore_release(pipe_semaphore);
200de28: 03 00 80 8d sethi %hi(0x2023400), %g1
200de2c: 7f ff ed 23 call 20092b8 <rtems_semaphore_release>
200de30: d0 00 61 80 ld [ %g1 + 0x180 ], %o0 ! 2023580 <pipe_semaphore>
200de34: 81 c7 e0 08 ret
200de38: 81 e8 00 00 restore
0200e430 <pipe_write>:
pipe_control_t *pipe,
const void *buffer,
size_t count,
rtems_libio_t *iop
)
{
200e430: 9d e3 bf 98 save %sp, -104, %sp
200e434: ba 10 00 18 mov %i0, %i5
int chunk, chunk1, written = 0, ret = 0;
/* Write nothing */
if (count == 0)
200e438: 80 a6 a0 00 cmp %i2, 0
200e43c: 02 80 00 70 be 200e5fc <pipe_write+0x1cc> <== NEVER TAKEN
200e440: b0 10 20 00 clr %i0
return 0;
if (! PIPE_LOCK(pipe))
200e444: d0 07 60 28 ld [ %i5 + 0x28 ], %o0
200e448: 92 10 20 00 clr %o1
200e44c: 7f ff eb 51 call 2009190 <rtems_semaphore_obtain>
200e450: 94 10 20 00 clr %o2
200e454: 80 a2 20 00 cmp %o0, 0
200e458: 32 80 00 69 bne,a 200e5fc <pipe_write+0x1cc> <== NEVER TAKEN
200e45c: b0 10 3f fc mov -4, %i0 <== NOT EXECUTED
return -EINTR;
if (pipe->Readers == 0) {
200e460: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
200e464: 80 a0 60 00 cmp %g1, 0
200e468: 02 80 00 54 be 200e5b8 <pipe_write+0x188>
200e46c: 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;
200e470: c2 07 60 04 ld [ %i5 + 4 ], %g1
200e474: 80 a6 80 01 cmp %i2, %g1
200e478: 18 80 00 03 bgu 200e484 <pipe_write+0x54> <== NEVER TAKEN
200e47c: a2 10 20 01 mov 1, %l1
200e480: 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;
200e484: 10 80 00 49 b 200e5a8 <pipe_write+0x178>
200e488: 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)) {
200e48c: 80 88 60 01 btst 1, %g1
200e490: 32 80 00 4a bne,a 200e5b8 <pipe_write+0x188>
200e494: 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 ++;
200e498: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
PIPE_UNLOCK(pipe);
200e49c: 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 ++;
200e4a0: 82 00 60 01 inc %g1
PIPE_UNLOCK(pipe);
200e4a4: 7f ff eb 85 call 20092b8 <rtems_semaphore_release>
200e4a8: c2 27 60 1c st %g1, [ %i5 + 0x1c ]
if (! PIPE_WRITEWAIT(pipe))
200e4ac: d0 07 60 30 ld [ %i5 + 0x30 ], %o0
200e4b0: 40 00 04 fb call 200f89c <rtems_barrier_wait>
200e4b4: 92 10 20 00 clr %o1
200e4b8: 80 a0 00 08 cmp %g0, %o0
ret = -EINTR;
if (! PIPE_LOCK(pipe)) {
200e4bc: 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))
200e4c0: b8 60 20 00 subx %g0, 0, %i4
ret = -EINTR;
if (! PIPE_LOCK(pipe)) {
200e4c4: 92 10 20 00 clr %o1
200e4c8: 94 10 20 00 clr %o2
200e4cc: 7f ff eb 31 call 2009190 <rtems_semaphore_obtain>
200e4d0: b8 0f 3f fc and %i4, -4, %i4
200e4d4: 80 a2 20 00 cmp %o0, 0
200e4d8: 12 80 00 43 bne 200e5e4 <pipe_write+0x1b4> <== NEVER TAKEN
200e4dc: 80 a7 20 00 cmp %i4, 0
/* WARN waitingWriters not restored! */
ret = -EINTR;
goto out_nolock;
}
pipe->waitingWriters --;
200e4e0: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
200e4e4: 82 00 7f ff add %g1, -1, %g1
if (ret != 0)
200e4e8: 12 80 00 34 bne 200e5b8 <pipe_write+0x188> <== NEVER TAKEN
200e4ec: c2 27 60 1c st %g1, [ %i5 + 0x1c ]
goto out_locked;
if (pipe->Readers == 0) {
200e4f0: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
200e4f4: 80 a0 60 00 cmp %g1, 0
200e4f8: 02 80 00 30 be 200e5b8 <pipe_write+0x188> <== NEVER TAKEN
200e4fc: 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) {
200e500: e0 07 60 04 ld [ %i5 + 4 ], %l0
200e504: c2 07 60 0c ld [ %i5 + 0xc ], %g1
200e508: b8 24 00 01 sub %l0, %g1, %i4
200e50c: 80 a7 00 11 cmp %i4, %l1
200e510: 2a bf ff df bcs,a 200e48c <pipe_write+0x5c>
200e514: c2 06 e0 10 ld [ %i3 + 0x10 ], %g1
ret = -EPIPE;
goto out_locked;
}
}
chunk = MIN(count - written, PIPE_SPACE(pipe));
200e518: 84 26 80 18 sub %i2, %i0, %g2
200e51c: 80 a7 00 02 cmp %i4, %g2
200e520: 38 80 00 02 bgu,a 200e528 <pipe_write+0xf8>
200e524: b8 10 00 02 mov %g2, %i4
chunk1 = pipe->Size - PIPE_WSTART(pipe);
200e528: d0 07 60 08 ld [ %i5 + 8 ], %o0
200e52c: 92 10 00 10 mov %l0, %o1
200e530: 40 00 41 43 call 201ea3c <.urem>
200e534: 90 00 40 08 add %g1, %o0, %o0
200e538: c2 07 40 00 ld [ %i5 ], %g1
200e53c: 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);
200e540: 94 10 00 1c mov %i4, %o2
}
}
chunk = MIN(count - written, PIPE_SPACE(pipe));
chunk1 = pipe->Size - PIPE_WSTART(pipe);
if (chunk > chunk1) {
200e544: 80 a7 00 10 cmp %i4, %l0
200e548: 92 06 40 18 add %i1, %i0, %o1
200e54c: 04 80 00 09 ble 200e570 <pipe_write+0x140>
200e550: 90 00 40 08 add %g1, %o0, %o0
memcpy(pipe->Buffer + PIPE_WSTART(pipe), buffer + written, chunk1);
200e554: 40 00 11 21 call 20129d8 <memcpy>
200e558: 94 10 00 10 mov %l0, %o2
memcpy(pipe->Buffer, buffer + written + chunk1, chunk - chunk1);
200e55c: 92 04 00 18 add %l0, %i0, %o1
200e560: d0 07 40 00 ld [ %i5 ], %o0
200e564: 92 06 40 09 add %i1, %o1, %o1
200e568: 10 80 00 02 b 200e570 <pipe_write+0x140>
200e56c: 94 27 00 10 sub %i4, %l0, %o2
}
else
memcpy(pipe->Buffer + PIPE_WSTART(pipe), buffer + written, chunk);
200e570: 40 00 11 1a call 20129d8 <memcpy>
200e574: 01 00 00 00 nop
pipe->Length += chunk;
200e578: c2 07 60 0c ld [ %i5 + 0xc ], %g1
200e57c: 82 00 40 1c add %g1, %i4, %g1
200e580: c2 27 60 0c st %g1, [ %i5 + 0xc ]
if (pipe->waitingReaders > 0)
200e584: c2 07 60 18 ld [ %i5 + 0x18 ], %g1
200e588: 80 a0 60 00 cmp %g1, 0
200e58c: 22 80 00 06 be,a 200e5a4 <pipe_write+0x174>
200e590: b0 06 00 1c add %i0, %i4, %i0
PIPE_WAKEUPREADERS(pipe);
200e594: d0 07 60 2c ld [ %i5 + 0x2c ], %o0
200e598: 40 00 04 ab call 200f844 <rtems_barrier_release>
200e59c: 92 07 bf fc add %fp, -4, %o1
written += chunk;
200e5a0: b0 06 00 1c add %i0, %i4, %i0
/* Write of more than PIPE_BUF bytes can be interleaved */
chunk = 1;
200e5a4: 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) {
200e5a8: 80 a6 00 1a cmp %i0, %i2
200e5ac: 2a bf ff d6 bcs,a 200e504 <pipe_write+0xd4>
200e5b0: e0 07 60 04 ld [ %i5 + 4 ], %l0
200e5b4: b8 10 20 00 clr %i4
/* Write of more than PIPE_BUF bytes can be interleaved */
chunk = 1;
}
out_locked:
PIPE_UNLOCK(pipe);
200e5b8: 7f ff eb 40 call 20092b8 <rtems_semaphore_release>
200e5bc: d0 07 60 28 ld [ %i5 + 0x28 ], %o0
out_nolock:
#ifdef RTEMS_POSIX_API
/* Signal SIGPIPE */
if (ret == -EPIPE)
200e5c0: 80 a7 3f e0 cmp %i4, -32
200e5c4: 32 80 00 0a bne,a 200e5ec <pipe_write+0x1bc>
200e5c8: 80 a6 20 00 cmp %i0, 0
kill(getpid(), SIGPIPE);
200e5cc: 40 00 01 23 call 200ea58 <getpid>
200e5d0: 01 00 00 00 nop
200e5d4: 40 00 02 94 call 200f024 <kill>
200e5d8: 92 10 20 0d mov 0xd, %o1 ! d <PROM_START+0xd>
#endif
if (written > 0)
200e5dc: 10 80 00 04 b 200e5ec <pipe_write+0x1bc>
200e5e0: 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;
200e5e4: b8 10 3f fc mov -4, %i4 <== NOT EXECUTED
/* Signal SIGPIPE */
if (ret == -EPIPE)
kill(getpid(), SIGPIPE);
#endif
if (written > 0)
200e5e8: 80 a6 20 00 cmp %i0, 0 <== NOT EXECUTED
200e5ec: 14 80 00 04 bg 200e5fc <pipe_write+0x1cc>
200e5f0: 01 00 00 00 nop
200e5f4: 81 c7 e0 08 ret
200e5f8: 91 e8 00 1c restore %g0, %i4, %o0
return written;
return ret;
}
200e5fc: 81 c7 e0 08 ret
200e600: 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
0200c404 <pthread_attr_setschedpolicy>:
int pthread_attr_setschedpolicy(
pthread_attr_t *attr,
int policy
)
{
200c404: 82 10 00 08 mov %o0, %g1
if ( !attr || !attr->is_initialized )
200c408: 80 a0 60 00 cmp %g1, 0
200c40c: 02 80 00 0f be 200c448 <pthread_attr_setschedpolicy+0x44>
200c410: 90 10 20 16 mov 0x16, %o0
200c414: c4 00 40 00 ld [ %g1 ], %g2
200c418: 80 a0 a0 00 cmp %g2, 0
200c41c: 02 80 00 0b be 200c448 <pthread_attr_setschedpolicy+0x44>
200c420: 80 a2 60 04 cmp %o1, 4
return EINVAL;
switch ( policy ) {
200c424: 38 80 00 09 bgu,a 200c448 <pthread_attr_setschedpolicy+0x44>
200c428: 90 10 20 86 mov 0x86, %o0
200c42c: 84 10 20 01 mov 1, %g2
200c430: 85 28 80 09 sll %g2, %o1, %g2
200c434: 80 88 a0 17 btst 0x17, %g2
200c438: 22 80 00 04 be,a 200c448 <pthread_attr_setschedpolicy+0x44><== NEVER TAKEN
200c43c: 90 10 20 86 mov 0x86, %o0 <== NOT EXECUTED
case SCHED_OTHER:
case SCHED_FIFO:
case SCHED_RR:
case SCHED_SPORADIC:
attr->schedpolicy = policy;
200c440: d2 20 60 14 st %o1, [ %g1 + 0x14 ]
200c444: 90 10 20 00 clr %o0
return 0;
default:
return ENOTSUP;
}
}
200c448: 81 c3 e0 08 retl
02007b58 <pthread_barrier_init>:
int pthread_barrier_init(
pthread_barrier_t *barrier,
const pthread_barrierattr_t *attr,
unsigned int count
)
{
2007b58: 9d e3 bf 90 save %sp, -112, %sp
const pthread_barrierattr_t *the_attr;
/*
* Error check parameters
*/
if ( !barrier )
2007b5c: 80 a6 20 00 cmp %i0, 0
2007b60: 12 80 00 04 bne 2007b70 <pthread_barrier_init+0x18>
2007b64: 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;
2007b68: 81 c7 e0 08 ret
2007b6c: 91 e8 20 16 restore %g0, 0x16, %o0
* Error check parameters
*/
if ( !barrier )
return EINVAL;
if ( count == 0 )
2007b70: 22 80 00 1f be,a 2007bec <pthread_barrier_init+0x94>
2007b74: b0 10 20 16 mov 0x16, %i0
return EINVAL;
/*
* If the user passed in NULL, use the default attributes
*/
if ( attr ) {
2007b78: 80 a6 60 00 cmp %i1, 0
2007b7c: 32 80 00 06 bne,a 2007b94 <pthread_barrier_init+0x3c>
2007b80: c2 06 40 00 ld [ %i1 ], %g1
the_attr = attr;
} else {
(void) pthread_barrierattr_init( &my_attr );
2007b84: 90 07 bf f8 add %fp, -8, %o0
2007b88: 7f ff ff bc call 2007a78 <pthread_barrierattr_init>
2007b8c: 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 )
2007b90: c2 06 40 00 ld [ %i1 ], %g1
2007b94: 80 a0 60 00 cmp %g1, 0
2007b98: 22 80 00 15 be,a 2007bec <pthread_barrier_init+0x94>
2007b9c: b0 10 20 16 mov 0x16, %i0
return EINVAL;
switch ( the_attr->process_shared ) {
2007ba0: c2 06 60 04 ld [ %i1 + 4 ], %g1
2007ba4: 80 a0 60 00 cmp %g1, 0
2007ba8: 32 80 00 11 bne,a 2007bec <pthread_barrier_init+0x94> <== NEVER TAKEN
2007bac: 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++;
2007bb0: 03 00 80 7c sethi %hi(0x201f000), %g1
2007bb4: c4 00 61 00 ld [ %g1 + 0x100 ], %g2 ! 201f100 <_Thread_Dispatch_disable_level>
}
/*
* Convert from POSIX attributes to Core Barrier attributes
*/
the_attributes.discipline = CORE_BARRIER_AUTOMATIC_RELEASE;
2007bb8: c0 27 bf f0 clr [ %fp + -16 ]
the_attributes.maximum_count = count;
2007bbc: f4 27 bf f4 st %i2, [ %fp + -12 ]
2007bc0: 84 00 a0 01 inc %g2
2007bc4: c4 20 61 00 st %g2, [ %g1 + 0x100 ]
return _Thread_Dispatch_disable_level;
2007bc8: c2 00 61 00 ld [ %g1 + 0x100 ], %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 *)
2007bcc: 39 00 80 7d sethi %hi(0x201f400), %i4
2007bd0: 40 00 08 67 call 2009d6c <_Objects_Allocate>
2007bd4: 90 17 20 b0 or %i4, 0xb0, %o0 ! 201f4b0 <_POSIX_Barrier_Information>
*/
_Thread_Disable_dispatch(); /* prevents deletion */
the_barrier = _POSIX_Barrier_Allocate();
if ( !the_barrier ) {
2007bd8: ba 92 20 00 orcc %o0, 0, %i5
2007bdc: 12 80 00 06 bne 2007bf4 <pthread_barrier_init+0x9c>
2007be0: 90 07 60 10 add %i5, 0x10, %o0
_Thread_Enable_dispatch();
2007be4: 40 00 0d 4c call 200b114 <_Thread_Enable_dispatch>
2007be8: b0 10 20 0b mov 0xb, %i0
2007bec: 81 c7 e0 08 ret
2007bf0: 81 e8 00 00 restore
return EAGAIN;
}
_CORE_barrier_Initialize( &the_barrier->Barrier, &the_attributes );
2007bf4: 40 00 05 d9 call 2009358 <_CORE_barrier_Initialize>
2007bf8: 92 07 bf f0 add %fp, -16, %o1
Objects_Information *information,
Objects_Control *the_object,
uint32_t name
)
{
_Objects_Set_local_object(
2007bfc: c4 17 60 0a lduh [ %i5 + 0xa ], %g2
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
2007c00: b8 17 20 b0 or %i4, 0xb0, %i4
2007c04: c6 07 20 1c ld [ %i4 + 0x1c ], %g3
Objects_Information *information,
Objects_Control *the_object,
uint32_t name
)
{
_Objects_Set_local_object(
2007c08: c2 07 60 08 ld [ %i5 + 8 ], %g1
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
2007c0c: 85 28 a0 02 sll %g2, 2, %g2
2007c10: 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;
2007c14: c0 27 60 0c clr [ %i5 + 0xc ]
);
/*
* Exit the critical section and return the user an operational barrier
*/
*barrier = the_barrier->Object.id;
2007c18: c2 26 00 00 st %g1, [ %i0 ]
_Thread_Enable_dispatch();
2007c1c: 40 00 0d 3e call 200b114 <_Thread_Enable_dispatch>
2007c20: b0 10 20 00 clr %i0
2007c24: 81 c7 e0 08 ret
2007c28: 81 e8 00 00 restore
02007448 <pthread_cleanup_push>:
void pthread_cleanup_push(
void (*routine)( void * ),
void *arg
)
{
2007448: 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 )
200744c: 80 a6 20 00 cmp %i0, 0
2007450: 02 80 00 13 be 200749c <pthread_cleanup_push+0x54>
2007454: 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++;
2007458: c4 00 61 60 ld [ %g1 + 0x160 ], %g2 ! 201e960 <_Thread_Dispatch_disable_level>
200745c: 84 00 a0 01 inc %g2
2007460: c4 20 61 60 st %g2, [ %g1 + 0x160 ]
return _Thread_Dispatch_disable_level;
2007464: c2 00 61 60 ld [ %g1 + 0x160 ], %g1
return;
_Thread_Disable_dispatch();
handler = _Workspace_Allocate( sizeof( POSIX_Cancel_Handler_control ) );
2007468: 40 00 11 d5 call 200bbbc <_Workspace_Allocate>
200746c: 90 10 20 10 mov 0x10, %o0
if ( handler ) {
2007470: 92 92 20 00 orcc %o0, 0, %o1
2007474: 02 80 00 08 be 2007494 <pthread_cleanup_push+0x4c> <== NEVER TAKEN
2007478: 03 00 80 7b sethi %hi(0x201ec00), %g1
thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ];
200747c: c2 00 62 9c ld [ %g1 + 0x29c ], %g1 ! 201ee9c <_Per_CPU_Information+0xc>
handler_stack = &thread_support->Cancellation_Handlers;
2007480: d0 00 61 5c ld [ %g1 + 0x15c ], %o0
handler->routine = routine;
2007484: f0 22 60 08 st %i0, [ %o1 + 8 ]
handler->arg = arg;
2007488: f2 22 60 0c st %i1, [ %o1 + 0xc ]
_Chain_Append( handler_stack, &handler->Node );
200748c: 40 00 06 21 call 2008d10 <_Chain_Append>
2007490: 90 02 20 e4 add %o0, 0xe4, %o0
}
_Thread_Enable_dispatch();
2007494: 40 00 0d 8a call 200aabc <_Thread_Enable_dispatch>
2007498: 81 e8 00 00 restore
200749c: 81 c7 e0 08 ret
20074a0: 81 e8 00 00 restore
02008420 <pthread_cond_init>:
int pthread_cond_init(
pthread_cond_t *cond,
const pthread_condattr_t *attr
)
{
2008420: 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;
2008424: 80 a6 60 00 cmp %i1, 0
2008428: 32 80 00 05 bne,a 200843c <pthread_cond_init+0x1c>
200842c: c4 06 60 04 ld [ %i1 + 4 ], %g2
else the_attr = &_POSIX_Condition_variables_Default_attributes;
2008430: 33 00 80 78 sethi %hi(0x201e000), %i1
2008434: b2 16 60 94 or %i1, 0x94, %i1 ! 201e094 <_POSIX_Condition_variables_Default_attributes>
/*
* Be careful about attributes when global!!!
*/
if ( the_attr->process_shared == PTHREAD_PROCESS_SHARED )
2008438: c4 06 60 04 ld [ %i1 + 4 ], %g2
200843c: 80 a0 a0 01 cmp %g2, 1
2008440: 02 80 00 26 be 20084d8 <pthread_cond_init+0xb8> <== NEVER TAKEN
2008444: 82 10 20 16 mov 0x16, %g1
return EINVAL;
if ( !the_attr->is_initialized )
2008448: c4 06 40 00 ld [ %i1 ], %g2
200844c: 80 a0 a0 00 cmp %g2, 0
2008450: 02 80 00 22 be 20084d8 <pthread_cond_init+0xb8>
2008454: 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++;
2008458: 03 00 80 80 sethi %hi(0x2020000), %g1
200845c: c4 00 63 70 ld [ %g1 + 0x370 ], %g2 ! 2020370 <_Thread_Dispatch_disable_level>
2008460: 84 00 a0 01 inc %g2
2008464: c4 20 63 70 st %g2, [ %g1 + 0x370 ]
return _Thread_Dispatch_disable_level;
2008468: c2 00 63 70 ld [ %g1 + 0x370 ], %g1
*/
RTEMS_INLINE_ROUTINE POSIX_Condition_variables_Control
*_POSIX_Condition_variables_Allocate( void )
{
return (POSIX_Condition_variables_Control *)
200846c: 39 00 80 81 sethi %hi(0x2020400), %i4
2008470: 40 00 0a 10 call 200acb0 <_Objects_Allocate>
2008474: 90 17 23 b8 or %i4, 0x3b8, %o0 ! 20207b8 <_POSIX_Condition_variables_Information>
_Thread_Disable_dispatch();
the_cond = _POSIX_Condition_variables_Allocate();
if ( !the_cond ) {
2008478: ba 92 20 00 orcc %o0, 0, %i5
200847c: 32 80 00 06 bne,a 2008494 <pthread_cond_init+0x74>
2008480: c2 06 60 04 ld [ %i1 + 4 ], %g1
_Thread_Enable_dispatch();
2008484: 40 00 0e f5 call 200c058 <_Thread_Enable_dispatch>
2008488: 01 00 00 00 nop
return ENOMEM;
200848c: 10 80 00 13 b 20084d8 <pthread_cond_init+0xb8>
2008490: 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(
2008494: 90 07 60 18 add %i5, 0x18, %o0
if ( !the_cond ) {
_Thread_Enable_dispatch();
return ENOMEM;
}
the_cond->process_shared = the_attr->process_shared;
2008498: c2 27 60 10 st %g1, [ %i5 + 0x10 ]
the_cond->Mutex = POSIX_CONDITION_VARIABLES_NO_MUTEX;
_Thread_queue_Initialize(
200849c: 92 10 20 00 clr %o1
20084a0: 15 04 00 02 sethi %hi(0x10000800), %o2
20084a4: 96 10 20 74 mov 0x74, %o3
20084a8: 40 00 10 f0 call 200c868 <_Thread_queue_Initialize>
20084ac: c0 27 60 14 clr [ %i5 + 0x14 ]
Objects_Information *information,
Objects_Control *the_object,
uint32_t name
)
{
_Objects_Set_local_object(
20084b0: c4 17 60 0a lduh [ %i5 + 0xa ], %g2
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
20084b4: b8 17 23 b8 or %i4, 0x3b8, %i4
20084b8: c6 07 20 1c ld [ %i4 + 0x1c ], %g3
Objects_Information *information,
Objects_Control *the_object,
uint32_t name
)
{
_Objects_Set_local_object(
20084bc: c2 07 60 08 ld [ %i5 + 8 ], %g1
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
20084c0: 85 28 a0 02 sll %g2, 2, %g2
20084c4: 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;
20084c8: c0 27 60 0c clr [ %i5 + 0xc ]
0
);
*cond = the_cond->Object.id;
_Thread_Enable_dispatch();
20084cc: 40 00 0e e3 call 200c058 <_Thread_Enable_dispatch>
20084d0: c2 26 00 00 st %g1, [ %i0 ]
return 0;
20084d4: 82 10 20 00 clr %g1
}
20084d8: 81 c7 e0 08 ret
20084dc: 91 e8 00 01 restore %g0, %g1, %o0
02008280 <pthread_condattr_destroy>:
*/
int pthread_condattr_destroy(
pthread_condattr_t *attr
)
{
2008280: 82 10 00 08 mov %o0, %g1
if ( !attr || attr->is_initialized == false )
2008284: 80 a0 60 00 cmp %g1, 0
2008288: 02 80 00 08 be 20082a8 <pthread_condattr_destroy+0x28>
200828c: 90 10 20 16 mov 0x16, %o0
2008290: c4 00 40 00 ld [ %g1 ], %g2
2008294: 80 a0 a0 00 cmp %g2, 0
2008298: 02 80 00 04 be 20082a8 <pthread_condattr_destroy+0x28> <== NEVER TAKEN
200829c: 01 00 00 00 nop
return EINVAL;
attr->is_initialized = false;
20082a0: c0 20 40 00 clr [ %g1 ]
return 0;
20082a4: 90 10 20 00 clr %o0
}
20082a8: 81 c3 e0 08 retl
02007820 <pthread_create>:
pthread_t *thread,
const pthread_attr_t *attr,
void *(*start_routine)( void * ),
void *arg
)
{
2007820: 9d e3 bf 58 save %sp, -168, %sp
int schedpolicy = SCHED_RR;
struct sched_param schedparam;
Objects_Name name;
int rc;
if ( !start_routine )
2007824: 80 a6 a0 00 cmp %i2, 0
2007828: 02 80 00 8c be 2007a58 <pthread_create+0x238>
200782c: ba 10 20 0e mov 0xe, %i5
return EFAULT;
the_attr = (attr) ? attr : &_POSIX_Threads_Default_attributes;
2007830: 80 a6 60 00 cmp %i1, 0
2007834: 32 80 00 05 bne,a 2007848 <pthread_create+0x28>
2007838: c2 06 40 00 ld [ %i1 ], %g1
200783c: 33 00 80 81 sethi %hi(0x2020400), %i1
2007840: b2 16 61 0c or %i1, 0x10c, %i1 ! 202050c <_POSIX_Threads_Default_attributes>
if ( !the_attr->is_initialized )
2007844: c2 06 40 00 ld [ %i1 ], %g1
2007848: 80 a0 60 00 cmp %g1, 0
200784c: 02 80 00 83 be 2007a58 <pthread_create+0x238>
2007850: 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) )
2007854: c2 06 60 04 ld [ %i1 + 4 ], %g1
2007858: 80 a0 60 00 cmp %g1, 0
200785c: 02 80 00 07 be 2007878 <pthread_create+0x58>
2007860: 03 00 80 86 sethi %hi(0x2021800), %g1
2007864: c4 06 60 08 ld [ %i1 + 8 ], %g2
2007868: c2 00 62 5c ld [ %g1 + 0x25c ], %g1
200786c: 80 a0 80 01 cmp %g2, %g1
2007870: 2a 80 00 7b bcs,a 2007a5c <pthread_create+0x23c>
2007874: 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 ) {
2007878: c2 06 60 10 ld [ %i1 + 0x10 ], %g1
200787c: 80 a0 60 01 cmp %g1, 1
2007880: 02 80 00 06 be 2007898 <pthread_create+0x78>
2007884: 80 a0 60 02 cmp %g1, 2
2007888: 32 80 00 74 bne,a 2007a58 <pthread_create+0x238>
200788c: ba 10 20 16 mov 0x16, %i5
schedpolicy = api->schedpolicy;
schedparam = api->schedparam;
break;
case PTHREAD_EXPLICIT_SCHED:
schedpolicy = the_attr->schedpolicy;
2007890: 10 80 00 09 b 20078b4 <pthread_create+0x94>
2007894: 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 ];
2007898: 03 00 80 8b sethi %hi(0x2022c00), %g1
200789c: c2 00 61 2c ld [ %g1 + 0x12c ], %g1 ! 2022d2c <_Per_CPU_Information+0xc>
schedpolicy = api->schedpolicy;
schedparam = api->schedparam;
20078a0: 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 ];
20078a4: d2 00 61 5c ld [ %g1 + 0x15c ], %o1
schedpolicy = api->schedpolicy;
20078a8: e2 02 60 84 ld [ %o1 + 0x84 ], %l1
schedparam = api->schedparam;
20078ac: 10 80 00 04 b 20078bc <pthread_create+0x9c>
20078b0: 92 02 60 88 add %o1, 0x88, %o1
break;
case PTHREAD_EXPLICIT_SCHED:
schedpolicy = the_attr->schedpolicy;
schedparam = the_attr->schedparam;
20078b4: 90 07 bf e4 add %fp, -28, %o0
20078b8: 92 06 60 18 add %i1, 0x18, %o1
20078bc: 40 00 25 70 call 2010e7c <memcpy>
20078c0: 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 )
20078c4: c2 06 60 0c ld [ %i1 + 0xc ], %g1
20078c8: 80 a0 60 00 cmp %g1, 0
20078cc: 12 80 00 63 bne 2007a58 <pthread_create+0x238>
20078d0: ba 10 20 86 mov 0x86, %i5
return ENOTSUP;
/*
* Interpret the scheduling parameters.
*/
if ( !_POSIX_Priority_Is_valid( schedparam.sched_priority ) )
20078d4: 40 00 18 e0 call 200dc54 <_POSIX_Priority_Is_valid>
20078d8: d0 07 bf e4 ld [ %fp + -28 ], %o0
20078dc: 80 8a 20 ff btst 0xff, %o0
20078e0: 02 80 00 5e be 2007a58 <pthread_create+0x238> <== NEVER TAKEN
20078e4: 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);
20078e8: 03 00 80 86 sethi %hi(0x2021800), %g1
return EINVAL;
core_priority = _POSIX_Priority_To_core( schedparam.sched_priority );
20078ec: e4 07 bf e4 ld [ %fp + -28 ], %l2
20078f0: e6 08 62 58 ldub [ %g1 + 0x258 ], %l3
/*
* Set the core scheduling policy information.
*/
rc = _POSIX_Thread_Translate_sched_param(
20078f4: 90 10 00 11 mov %l1, %o0
20078f8: 92 07 bf e4 add %fp, -28, %o1
20078fc: 94 07 bf dc add %fp, -36, %o2
2007900: 40 00 18 e0 call 200dc80 <_POSIX_Thread_Translate_sched_param>
2007904: 96 07 bf e0 add %fp, -32, %o3
schedpolicy,
&schedparam,
&budget_algorithm,
&budget_callout
);
if ( rc )
2007908: ba 92 20 00 orcc %o0, 0, %i5
200790c: 32 80 00 54 bne,a 2007a5c <pthread_create+0x23c>
2007910: b0 10 00 1d mov %i5, %i0
#endif
/*
* Lock the allocator mutex for protection
*/
_RTEMS_Lock_allocator();
2007914: 39 00 80 8a sethi %hi(0x2022800), %i4
2007918: 40 00 06 35 call 20091ec <_API_Mutex_Lock>
200791c: d0 07 20 80 ld [ %i4 + 0x80 ], %o0 ! 2022880 <_RTEMS_Allocator_Mutex>
* _POSIX_Threads_Allocate
*/
RTEMS_INLINE_ROUTINE Thread_Control *_POSIX_Threads_Allocate( void )
{
return (Thread_Control *) _Objects_Allocate( &_POSIX_Threads_Information );
2007920: 11 00 80 8a sethi %hi(0x2022800), %o0
2007924: 40 00 08 d4 call 2009c74 <_Objects_Allocate>
2007928: 90 12 22 20 or %o0, 0x220, %o0 ! 2022a20 <_POSIX_Threads_Information>
* Allocate the thread control block.
*
* NOTE: Global threads are not currently supported.
*/
the_thread = _POSIX_Threads_Allocate();
if ( !the_thread ) {
200792c: a0 92 20 00 orcc %o0, 0, %l0
2007930: 32 80 00 04 bne,a 2007940 <pthread_create+0x120>
2007934: c2 06 60 08 ld [ %i1 + 8 ], %g1
_RTEMS_Unlock_allocator();
2007938: 10 80 00 21 b 20079bc <pthread_create+0x19c>
200793c: d0 07 20 80 ld [ %i4 + 0x80 ], %o0
static inline size_t _POSIX_Threads_Ensure_minimum_stack (
size_t size
)
{
if ( size >= PTHREAD_MINIMUM_STACK_SIZE )
2007940: 05 00 80 86 sethi %hi(0x2021800), %g2
2007944: d6 00 a2 5c ld [ %g2 + 0x25c ], %o3 ! 2021a5c <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(
2007948: c0 27 bf d4 clr [ %fp + -44 ]
200794c: 97 2a e0 01 sll %o3, 1, %o3
2007950: 80 a2 c0 01 cmp %o3, %g1
2007954: 1a 80 00 03 bcc 2007960 <pthread_create+0x140>
2007958: d4 06 60 04 ld [ %i1 + 4 ], %o2
200795c: 96 10 00 01 mov %g1, %o3
2007960: 82 10 20 01 mov 1, %g1
2007964: c2 23 a0 5c st %g1, [ %sp + 0x5c ]
2007968: c2 07 bf dc ld [ %fp + -36 ], %g1
200796c: 9a 0c e0 ff and %l3, 0xff, %o5
2007970: c2 23 a0 60 st %g1, [ %sp + 0x60 ]
2007974: c2 07 bf e0 ld [ %fp + -32 ], %g1
2007978: c0 23 a0 68 clr [ %sp + 0x68 ]
200797c: c2 23 a0 64 st %g1, [ %sp + 0x64 ]
2007980: 82 07 bf d4 add %fp, -44, %g1
2007984: 39 00 80 8a sethi %hi(0x2022800), %i4
2007988: c2 23 a0 6c st %g1, [ %sp + 0x6c ]
200798c: 90 17 22 20 or %i4, 0x220, %o0
2007990: 92 10 00 10 mov %l0, %o1
2007994: 98 10 20 01 mov 1, %o4
2007998: 40 00 0d db call 200b104 <_Thread_Initialize>
200799c: 9a 23 40 12 sub %o5, %l2, %o5
budget_callout,
0, /* isr level */
name /* posix threads don't have a name */
);
if ( !status ) {
20079a0: 80 8a 20 ff btst 0xff, %o0
20079a4: 12 80 00 0a bne 20079cc <pthread_create+0x1ac>
20079a8: 90 17 22 20 or %i4, 0x220, %o0
RTEMS_INLINE_ROUTINE void _POSIX_Threads_Free (
Thread_Control *the_pthread
)
{
_Objects_Free( &_POSIX_Threads_Information, &the_pthread->Object );
20079ac: 40 00 09 89 call 2009fd0 <_Objects_Free>
20079b0: 92 10 00 10 mov %l0, %o1
_POSIX_Threads_Free( the_thread );
_RTEMS_Unlock_allocator();
20079b4: 03 00 80 8a sethi %hi(0x2022800), %g1
20079b8: d0 00 60 80 ld [ %g1 + 0x80 ], %o0 ! 2022880 <_RTEMS_Allocator_Mutex>
20079bc: 40 00 06 21 call 2009240 <_API_Mutex_Unlock>
20079c0: ba 10 20 0b mov 0xb, %i5
*/
*thread = the_thread->Object.id;
_RTEMS_Unlock_allocator();
return 0;
}
20079c4: 81 c7 e0 08 ret
20079c8: 91 e8 00 1d restore %g0, %i5, %o0
}
/*
* finish initializing the per API structure
*/
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
20079cc: f8 04 21 5c ld [ %l0 + 0x15c ], %i4
api->Attributes = *the_attr;
20079d0: 92 10 00 19 mov %i1, %o1
20079d4: 94 10 20 40 mov 0x40, %o2
20079d8: 40 00 25 29 call 2010e7c <memcpy>
20079dc: 90 10 00 1c mov %i4, %o0
api->detachstate = the_attr->detachstate;
20079e0: c2 06 60 3c ld [ %i1 + 0x3c ], %g1
api->schedpolicy = schedpolicy;
api->schedparam = schedparam;
20079e4: 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;
20079e8: c2 27 20 40 st %g1, [ %i4 + 0x40 ]
api->schedpolicy = schedpolicy;
api->schedparam = schedparam;
20079ec: 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;
20079f0: e2 27 20 84 st %l1, [ %i4 + 0x84 ]
api->schedparam = schedparam;
20079f4: 40 00 25 22 call 2010e7c <memcpy>
20079f8: 90 07 20 88 add %i4, 0x88, %o0
/*
* POSIX threads are allocated and started in one operation.
*/
status = _Thread_Start(
20079fc: 90 10 00 10 mov %l0, %o0
2007a00: 92 10 20 01 mov 1, %o1
2007a04: 94 10 00 1a mov %i2, %o2
2007a08: 96 10 00 1b mov %i3, %o3
2007a0c: 40 00 10 0a call 200ba34 <_Thread_Start>
2007a10: 98 10 20 00 clr %o4
_RTEMS_Unlock_allocator();
return EINVAL;
}
#endif
if ( schedpolicy == SCHED_SPORADIC ) {
2007a14: 80 a4 60 04 cmp %l1, 4
2007a18: 32 80 00 0a bne,a 2007a40 <pthread_create+0x220>
2007a1c: c2 04 20 08 ld [ %l0 + 8 ], %g1
_Watchdog_Insert_ticks(
2007a20: 40 00 10 2d call 200bad4 <_Timespec_To_ticks>
2007a24: 90 07 20 90 add %i4, 0x90, %o0
)
{
the_watchdog->initial = units;
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
2007a28: 92 07 20 a8 add %i4, 0xa8, %o1
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
2007a2c: d0 27 20 b4 st %o0, [ %i4 + 0xb4 ]
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
2007a30: 11 00 80 8a sethi %hi(0x2022800), %o0
2007a34: 40 00 11 06 call 200be4c <_Watchdog_Insert>
2007a38: 90 12 20 98 or %o0, 0x98, %o0 ! 2022898 <_Watchdog_Ticks_chain>
}
/*
* Return the id and indicate we successfully created the thread
*/
*thread = the_thread->Object.id;
2007a3c: c2 04 20 08 ld [ %l0 + 8 ], %g1
2007a40: c2 26 00 00 st %g1, [ %i0 ]
_RTEMS_Unlock_allocator();
2007a44: 03 00 80 8a sethi %hi(0x2022800), %g1
2007a48: 40 00 05 fe call 2009240 <_API_Mutex_Unlock>
2007a4c: d0 00 60 80 ld [ %g1 + 0x80 ], %o0 ! 2022880 <_RTEMS_Allocator_Mutex>
return 0;
}
2007a50: 81 c7 e0 08 ret
2007a54: 91 e8 00 1d restore %g0, %i5, %o0
2007a58: b0 10 00 1d mov %i5, %i0
2007a5c: 81 c7 e0 08 ret
2007a60: 81 e8 00 00 restore
0201a79c <pthread_kill>:
int pthread_kill(
pthread_t thread,
int sig
)
{
201a79c: 9d e3 bf 98 save %sp, -104, %sp
POSIX_API_Control *api;
Thread_Control *the_thread;
Objects_Locations location;
if ( !sig )
201a7a0: 80 a6 60 00 cmp %i1, 0
201a7a4: 32 80 00 03 bne,a 201a7b0 <pthread_kill+0x14>
201a7a8: b6 06 7f ff add %i1, -1, %i3
201a7ac: 30 80 00 04 b,a 201a7bc <pthread_kill+0x20>
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !is_valid_signo(sig) )
201a7b0: 80 a6 e0 1f cmp %i3, 0x1f
201a7b4: 28 80 00 06 bleu,a 201a7cc <pthread_kill+0x30>
201a7b8: 90 10 00 18 mov %i0, %o0
rtems_set_errno_and_return_minus_one( EINVAL );
201a7bc: 7f ff d4 97 call 200fa18 <__errno>
201a7c0: 01 00 00 00 nop
201a7c4: 10 80 00 2c b 201a874 <pthread_kill+0xd8>
201a7c8: 82 10 20 16 mov 0x16, %g1 ! 16 <PROM_START+0x16>
the_thread = _Thread_Get( thread, &location );
201a7cc: 7f ff be 8d call 200a200 <_Thread_Get>
201a7d0: 92 07 bf fc add %fp, -4, %o1
switch ( location ) {
201a7d4: c2 07 bf fc ld [ %fp + -4 ], %g1
201a7d8: 80 a0 60 00 cmp %g1, 0
201a7dc: 12 80 00 23 bne 201a868 <pthread_kill+0xcc> <== NEVER TAKEN
201a7e0: 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 ) {
201a7e4: 85 2e 60 02 sll %i1, 2, %g2
201a7e8: 87 2e 60 04 sll %i1, 4, %g3
201a7ec: 86 20 c0 02 sub %g3, %g2, %g3
201a7f0: 05 00 80 78 sethi %hi(0x201e000), %g2
201a7f4: 84 10 a0 80 or %g2, 0x80, %g2 ! 201e080 <_POSIX_signals_Vectors>
201a7f8: 84 00 80 03 add %g2, %g3, %g2
201a7fc: c4 00 a0 08 ld [ %g2 + 8 ], %g2
201a800: 80 a0 a0 01 cmp %g2, 1
201a804: 12 80 00 06 bne 201a81c <pthread_kill+0x80>
201a808: c2 02 21 5c ld [ %o0 + 0x15c ], %g1
_Thread_Enable_dispatch();
201a80c: 7f ff be 70 call 200a1cc <_Thread_Enable_dispatch>
201a810: b0 10 20 00 clr %i0
201a814: 81 c7 e0 08 ret
201a818: 81 e8 00 00 restore
return 0;
}
/* XXX critical section */
api->signals_pending |= signo_to_mask( sig );
201a81c: c4 00 60 d4 ld [ %g1 + 0xd4 ], %g2
201a820: ba 10 20 01 mov 1, %i5
(void) _POSIX_signals_Unblock_thread( the_thread, sig, NULL );
201a824: 92 10 00 19 mov %i1, %o1
201a828: b7 2f 40 1b sll %i5, %i3, %i3
201a82c: 94 10 20 00 clr %o2
return 0;
}
/* XXX critical section */
api->signals_pending |= signo_to_mask( sig );
201a830: b6 10 80 1b or %g2, %i3, %i3
(void) _POSIX_signals_Unblock_thread( the_thread, sig, NULL );
201a834: 7f ff ff 88 call 201a654 <_POSIX_signals_Unblock_thread>
201a838: f6 20 60 d4 st %i3, [ %g1 + 0xd4 ]
if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
201a83c: 03 00 80 78 sethi %hi(0x201e000), %g1
201a840: 82 10 60 20 or %g1, 0x20, %g1 ! 201e020 <_Per_CPU_Information>
201a844: c4 00 60 08 ld [ %g1 + 8 ], %g2
201a848: 80 a0 a0 00 cmp %g2, 0
201a84c: 02 bf ff f0 be 201a80c <pthread_kill+0x70>
201a850: 01 00 00 00 nop
201a854: c4 00 60 0c ld [ %g1 + 0xc ], %g2
201a858: 80 a7 00 02 cmp %i4, %g2
201a85c: 22 bf ff ec be,a 201a80c <pthread_kill+0x70>
201a860: fa 28 60 18 stb %i5, [ %g1 + 0x18 ]
201a864: 30 bf ff ea b,a 201a80c <pthread_kill+0x70>
#endif
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( ESRCH );
201a868: 7f ff d4 6c call 200fa18 <__errno> <== NOT EXECUTED
201a86c: 01 00 00 00 nop <== NOT EXECUTED
201a870: 82 10 20 03 mov 3, %g1 ! 3 <PROM_START+0x3> <== NOT EXECUTED
201a874: c2 22 00 00 st %g1, [ %o0 ]
}
201a878: 81 c7 e0 08 ret
201a87c: 91 e8 3f ff restore %g0, -1, %o0
02009a04 <pthread_mutex_timedlock>:
int pthread_mutex_timedlock(
pthread_mutex_t *mutex,
const struct timespec *abstime
)
{
2009a04: 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 );
2009a08: 92 07 bf fc add %fp, -4, %o1
2009a0c: 40 00 00 37 call 2009ae8 <_POSIX_Absolute_timeout_to_ticks>
2009a10: 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 );
2009a14: 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 )
2009a18: 82 1a 20 03 xor %o0, 3, %g1
2009a1c: 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 );
2009a20: ba 10 00 08 mov %o0, %i5
if ( status != POSIX_ABSOLUTE_TIMEOUT_IS_IN_FUTURE )
2009a24: b8 60 3f ff subx %g0, -1, %i4
do_wait = false;
lock_status = _POSIX_Mutex_Lock_support( mutex, do_wait, ticks );
2009a28: 90 10 00 18 mov %i0, %o0
2009a2c: 7f ff ff b7 call 2009908 <_POSIX_Mutex_Lock_support>
2009a30: 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) ) {
2009a34: 80 a7 20 00 cmp %i4, 0
2009a38: 12 80 00 0c bne 2009a68 <pthread_mutex_timedlock+0x64>
2009a3c: b0 10 00 08 mov %o0, %i0
2009a40: 80 a2 20 10 cmp %o0, 0x10
2009a44: 12 80 00 09 bne 2009a68 <pthread_mutex_timedlock+0x64>
2009a48: 80 a7 60 00 cmp %i5, 0
if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID )
2009a4c: 02 80 00 07 be 2009a68 <pthread_mutex_timedlock+0x64> <== NEVER TAKEN
2009a50: b0 10 20 16 mov 0x16, %i0
return EINVAL;
if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST ||
2009a54: ba 07 7f ff add %i5, -1, %i5
2009a58: 80 a7 60 01 cmp %i5, 1
2009a5c: 18 80 00 03 bgu 2009a68 <pthread_mutex_timedlock+0x64> <== NEVER TAKEN
2009a60: b0 10 20 10 mov 0x10, %i0
status == POSIX_ABSOLUTE_TIMEOUT_IS_NOW )
return ETIMEDOUT;
2009a64: b0 10 20 74 mov 0x74, %i0
}
return lock_status;
}
2009a68: 81 c7 e0 08 ret
2009a6c: 81 e8 00 00 restore
02007104 <pthread_mutexattr_gettype>:
#if defined(_UNIX98_THREAD_MUTEX_ATTRIBUTES)
int pthread_mutexattr_gettype(
const pthread_mutexattr_t *attr,
int *type
)
{
2007104: 82 10 00 08 mov %o0, %g1
if ( !attr )
2007108: 80 a0 60 00 cmp %g1, 0
200710c: 02 80 00 0b be 2007138 <pthread_mutexattr_gettype+0x34>
2007110: 90 10 20 16 mov 0x16, %o0
return EINVAL;
if ( !attr->is_initialized )
2007114: c4 00 40 00 ld [ %g1 ], %g2
2007118: 80 a0 a0 00 cmp %g2, 0
200711c: 02 80 00 07 be 2007138 <pthread_mutexattr_gettype+0x34>
2007120: 80 a2 60 00 cmp %o1, 0
return EINVAL;
if ( !type )
2007124: 02 80 00 05 be 2007138 <pthread_mutexattr_gettype+0x34> <== NEVER TAKEN
2007128: 01 00 00 00 nop
return EINVAL;
*type = attr->type;
200712c: c2 00 60 10 ld [ %g1 + 0x10 ], %g1
return 0;
2007130: 90 10 20 00 clr %o0
return EINVAL;
if ( !type )
return EINVAL;
*type = attr->type;
2007134: c2 22 40 00 st %g1, [ %o1 ]
return 0;
}
2007138: 81 c3 e0 08 retl
020095b8 <pthread_mutexattr_setpshared>:
int pthread_mutexattr_setpshared(
pthread_mutexattr_t *attr,
int pshared
)
{
20095b8: 82 10 00 08 mov %o0, %g1
if ( !attr || !attr->is_initialized )
20095bc: 80 a0 60 00 cmp %g1, 0
20095c0: 02 80 00 0a be 20095e8 <pthread_mutexattr_setpshared+0x30>
20095c4: 90 10 20 16 mov 0x16, %o0
20095c8: c4 00 40 00 ld [ %g1 ], %g2
20095cc: 80 a0 a0 00 cmp %g2, 0
20095d0: 02 80 00 06 be 20095e8 <pthread_mutexattr_setpshared+0x30>
20095d4: 80 a2 60 01 cmp %o1, 1
return EINVAL;
switch ( pshared ) {
20095d8: 18 80 00 04 bgu 20095e8 <pthread_mutexattr_setpshared+0x30><== NEVER TAKEN
20095dc: 01 00 00 00 nop
case PTHREAD_PROCESS_SHARED:
case PTHREAD_PROCESS_PRIVATE:
attr->process_shared = pshared;
20095e0: d2 20 60 04 st %o1, [ %g1 + 4 ]
return 0;
20095e4: 90 10 20 00 clr %o0
default:
return EINVAL;
}
}
20095e8: 81 c3 e0 08 retl
02007170 <pthread_mutexattr_settype>:
#if defined(_UNIX98_THREAD_MUTEX_ATTRIBUTES)
int pthread_mutexattr_settype(
pthread_mutexattr_t *attr,
int type
)
{
2007170: 82 10 00 08 mov %o0, %g1
if ( !attr || !attr->is_initialized )
2007174: 80 a0 60 00 cmp %g1, 0
2007178: 02 80 00 0a be 20071a0 <pthread_mutexattr_settype+0x30>
200717c: 90 10 20 16 mov 0x16, %o0
2007180: c4 00 40 00 ld [ %g1 ], %g2
2007184: 80 a0 a0 00 cmp %g2, 0
2007188: 02 80 00 06 be 20071a0 <pthread_mutexattr_settype+0x30> <== NEVER TAKEN
200718c: 80 a2 60 03 cmp %o1, 3
return EINVAL;
switch ( type ) {
2007190: 18 80 00 04 bgu 20071a0 <pthread_mutexattr_settype+0x30>
2007194: 01 00 00 00 nop
case PTHREAD_MUTEX_NORMAL:
case PTHREAD_MUTEX_RECURSIVE:
case PTHREAD_MUTEX_ERRORCHECK:
case PTHREAD_MUTEX_DEFAULT:
attr->type = type;
2007198: d2 20 60 10 st %o1, [ %g1 + 0x10 ]
return 0;
200719c: 90 10 20 00 clr %o0
default:
return EINVAL;
}
}
20071a0: 81 c3 e0 08 retl
02007eb0 <pthread_once>:
int pthread_once(
pthread_once_t *once_control,
void (*init_routine)(void)
)
{
2007eb0: 9d e3 bf 98 save %sp, -104, %sp
if ( !once_control || !init_routine )
2007eb4: 80 a6 60 00 cmp %i1, 0
2007eb8: 02 80 00 1c be 2007f28 <pthread_once+0x78>
2007ebc: ba 10 00 18 mov %i0, %i5
2007ec0: 80 a6 20 00 cmp %i0, 0
2007ec4: 22 80 00 17 be,a 2007f20 <pthread_once+0x70>
2007ec8: b0 10 20 16 mov 0x16, %i0
return EINVAL;
if ( !once_control->init_executed ) {
2007ecc: c2 06 20 04 ld [ %i0 + 4 ], %g1
2007ed0: 80 a0 60 00 cmp %g1, 0
2007ed4: 12 80 00 13 bne 2007f20 <pthread_once+0x70>
2007ed8: b0 10 20 00 clr %i0
rtems_mode saveMode;
rtems_task_mode(RTEMS_NO_PREEMPT, RTEMS_PREEMPT_MASK, &saveMode);
2007edc: 90 10 21 00 mov 0x100, %o0
2007ee0: 92 10 21 00 mov 0x100, %o1
2007ee4: 40 00 03 05 call 2008af8 <rtems_task_mode>
2007ee8: 94 07 bf fc add %fp, -4, %o2
if ( !once_control->init_executed ) {
2007eec: c2 07 60 04 ld [ %i5 + 4 ], %g1
2007ef0: 80 a0 60 00 cmp %g1, 0
2007ef4: 12 80 00 07 bne 2007f10 <pthread_once+0x60> <== NEVER TAKEN
2007ef8: d0 07 bf fc ld [ %fp + -4 ], %o0
once_control->is_initialized = true;
2007efc: 82 10 20 01 mov 1, %g1
2007f00: c2 27 40 00 st %g1, [ %i5 ]
once_control->init_executed = true;
(*init_routine)();
2007f04: 9f c6 40 00 call %i1
2007f08: c2 27 60 04 st %g1, [ %i5 + 4 ]
}
rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode);
2007f0c: d0 07 bf fc ld [ %fp + -4 ], %o0
2007f10: 92 10 21 00 mov 0x100, %o1
2007f14: 94 07 bf fc add %fp, -4, %o2
2007f18: 40 00 02 f8 call 2008af8 <rtems_task_mode>
2007f1c: b0 10 20 00 clr %i0
2007f20: 81 c7 e0 08 ret
2007f24: 81 e8 00 00 restore
pthread_once_t *once_control,
void (*init_routine)(void)
)
{
if ( !once_control || !init_routine )
return EINVAL;
2007f28: b0 10 20 16 mov 0x16, %i0
(*init_routine)();
}
rtems_task_mode(saveMode, RTEMS_PREEMPT_MASK, &saveMode);
}
return 0;
}
2007f2c: 81 c7 e0 08 ret
2007f30: 81 e8 00 00 restore
02007fdc <pthread_rwlock_init>:
int pthread_rwlock_init(
pthread_rwlock_t *rwlock,
const pthread_rwlockattr_t *attr
)
{
2007fdc: 9d e3 bf 90 save %sp, -112, %sp
const pthread_rwlockattr_t *the_attr;
/*
* Error check parameters
*/
if ( !rwlock )
2007fe0: 80 a6 20 00 cmp %i0, 0
2007fe4: 12 80 00 04 bne 2007ff4 <pthread_rwlock_init+0x18>
2007fe8: 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;
2007fec: 81 c7 e0 08 ret
2007ff0: 91 e8 20 16 restore %g0, 0x16, %o0
return EINVAL;
/*
* If the user passed in NULL, use the default attributes
*/
if ( attr ) {
2007ff4: 32 80 00 06 bne,a 200800c <pthread_rwlock_init+0x30>
2007ff8: c2 06 40 00 ld [ %i1 ], %g1
the_attr = attr;
} else {
(void) pthread_rwlockattr_init( &default_attr );
2007ffc: 90 07 bf f8 add %fp, -8, %o0
2008000: 40 00 01 b2 call 20086c8 <pthread_rwlockattr_init>
2008004: 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 )
2008008: c2 06 40 00 ld [ %i1 ], %g1
200800c: 80 a0 60 00 cmp %g1, 0
2008010: 22 80 00 14 be,a 2008060 <pthread_rwlock_init+0x84> <== NEVER TAKEN
2008014: b0 10 20 16 mov 0x16, %i0 <== NOT EXECUTED
return EINVAL;
switch ( the_attr->process_shared ) {
2008018: c2 06 60 04 ld [ %i1 + 4 ], %g1
200801c: 80 a0 60 00 cmp %g1, 0
2008020: 32 80 00 10 bne,a 2008060 <pthread_rwlock_init+0x84> <== NEVER TAKEN
2008024: 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++;
2008028: 03 00 80 89 sethi %hi(0x2022400), %g1
200802c: 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;
2008030: c0 27 bf f4 clr [ %fp + -12 ]
2008034: 84 00 a0 01 inc %g2
2008038: c4 20 61 f0 st %g2, [ %g1 + 0x1f0 ]
return _Thread_Dispatch_disable_level;
200803c: 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 *)
2008040: 39 00 80 8a sethi %hi(0x2022800), %i4
2008044: 40 00 0a 72 call 200aa0c <_Objects_Allocate>
2008048: 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 ) {
200804c: ba 92 20 00 orcc %o0, 0, %i5
2008050: 12 80 00 06 bne 2008068 <pthread_rwlock_init+0x8c>
2008054: 90 07 60 10 add %i5, 0x10, %o0
_Thread_Enable_dispatch();
2008058: 40 00 0f 90 call 200be98 <_Thread_Enable_dispatch>
200805c: b0 10 20 0b mov 0xb, %i0
2008060: 81 c7 e0 08 ret
2008064: 81 e8 00 00 restore
return EAGAIN;
}
_CORE_RWLock_Initialize( &the_rwlock->RWLock, &the_attributes );
2008068: 40 00 08 d0 call 200a3a8 <_CORE_RWLock_Initialize>
200806c: 92 07 bf f4 add %fp, -12, %o1
Objects_Information *information,
Objects_Control *the_object,
uint32_t name
)
{
_Objects_Set_local_object(
2008070: c4 17 60 0a lduh [ %i5 + 0xa ], %g2
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
2008074: b8 17 20 20 or %i4, 0x20, %i4
2008078: c6 07 20 1c ld [ %i4 + 0x1c ], %g3
Objects_Information *information,
Objects_Control *the_object,
uint32_t name
)
{
_Objects_Set_local_object(
200807c: c2 07 60 08 ld [ %i5 + 8 ], %g1
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
2008080: 85 28 a0 02 sll %g2, 2, %g2
2008084: 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;
2008088: c0 27 60 0c clr [ %i5 + 0xc ]
&_POSIX_RWLock_Information,
&the_rwlock->Object,
0
);
*rwlock = the_rwlock->Object.id;
200808c: c2 26 00 00 st %g1, [ %i0 ]
_Thread_Enable_dispatch();
2008090: 40 00 0f 82 call 200be98 <_Thread_Enable_dispatch>
2008094: b0 10 20 00 clr %i0
2008098: 81 c7 e0 08 ret
200809c: 81 e8 00 00 restore
02008978 <pthread_rwlock_timedrdlock>:
int pthread_rwlock_timedrdlock(
pthread_rwlock_t *rwlock,
const struct timespec *abstime
)
{
2008978: 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 )
200897c: 80 a6 20 00 cmp %i0, 0
2008980: 12 80 00 04 bne 2008990 <pthread_rwlock_timedrdlock+0x18>
2008984: 92 07 bf fc add %fp, -4, %o1
#endif
case OBJECTS_ERROR:
break;
}
return EINVAL;
2008988: 81 c7 e0 08 ret
200898c: 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 );
2008990: 40 00 19 9f call 200f00c <_POSIX_Absolute_timeout_to_ticks>
2008994: 90 10 00 19 mov %i1, %o0
2008998: d2 06 00 00 ld [ %i0 ], %o1
200899c: ba 10 00 08 mov %o0, %i5
20089a0: 94 07 bf f8 add %fp, -8, %o2
20089a4: 11 00 80 83 sethi %hi(0x2020c00), %o0
20089a8: 40 00 0b 14 call 200b5f8 <_Objects_Get>
20089ac: 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 ) {
20089b0: c2 07 bf f8 ld [ %fp + -8 ], %g1
20089b4: 80 a0 60 00 cmp %g1, 0
20089b8: 32 80 00 21 bne,a 2008a3c <pthread_rwlock_timedrdlock+0xc4>
20089bc: b0 10 20 16 mov 0x16, %i0
case OBJECTS_LOCAL:
_CORE_RWLock_Obtain_for_reading(
20089c0: d2 06 00 00 ld [ %i0 ], %o1
20089c4: 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 )
20089c8: 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(
20089cc: 90 02 20 10 add %o0, 0x10, %o0
20089d0: 80 a0 00 01 cmp %g0, %g1
20089d4: 98 10 20 00 clr %o4
20089d8: b8 60 3f ff subx %g0, -1, %i4
20089dc: 40 00 07 8a call 200a804 <_CORE_RWLock_Obtain_for_reading>
20089e0: 94 10 00 1c mov %i4, %o2
do_wait,
ticks,
NULL
);
_Thread_Enable_dispatch();
20089e4: 40 00 0e b1 call 200c4a8 <_Thread_Enable_dispatch>
20089e8: 01 00 00 00 nop
if ( !do_wait ) {
20089ec: 80 a7 20 00 cmp %i4, 0
20089f0: 12 80 00 0e bne 2008a28 <pthread_rwlock_timedrdlock+0xb0>
20089f4: 03 00 80 84 sethi %hi(0x2021000), %g1
if ( _Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE ) {
20089f8: c2 00 61 2c ld [ %g1 + 0x12c ], %g1 ! 202112c <_Per_CPU_Information+0xc>
20089fc: c2 00 60 34 ld [ %g1 + 0x34 ], %g1
2008a00: 80 a0 60 02 cmp %g1, 2
2008a04: 32 80 00 0a bne,a 2008a2c <pthread_rwlock_timedrdlock+0xb4>
2008a08: 03 00 80 84 sethi %hi(0x2021000), %g1
if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID )
2008a0c: 80 a7 60 00 cmp %i5, 0
2008a10: 22 80 00 0b be,a 2008a3c <pthread_rwlock_timedrdlock+0xc4><== NEVER TAKEN
2008a14: b0 10 20 16 mov 0x16, %i0 <== NOT EXECUTED
return EINVAL;
if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST ||
2008a18: ba 07 7f ff add %i5, -1, %i5
2008a1c: 80 a7 60 01 cmp %i5, 1
2008a20: 08 80 00 07 bleu 2008a3c <pthread_rwlock_timedrdlock+0xc4><== ALWAYS TAKEN
2008a24: 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
2008a28: 03 00 80 84 sethi %hi(0x2021000), %g1
2008a2c: 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(
2008a30: 40 00 00 38 call 2008b10 <_POSIX_RWLock_Translate_core_RWLock_return_code>
2008a34: d0 00 60 34 ld [ %g1 + 0x34 ], %o0
2008a38: b0 10 00 08 mov %o0, %i0
case OBJECTS_ERROR:
break;
}
return EINVAL;
}
2008a3c: 81 c7 e0 08 ret
2008a40: 81 e8 00 00 restore
02008a44 <pthread_rwlock_timedwrlock>:
int pthread_rwlock_timedwrlock(
pthread_rwlock_t *rwlock,
const struct timespec *abstime
)
{
2008a44: 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 )
2008a48: 80 a6 20 00 cmp %i0, 0
2008a4c: 12 80 00 04 bne 2008a5c <pthread_rwlock_timedwrlock+0x18>
2008a50: 92 07 bf fc add %fp, -4, %o1
#endif
case OBJECTS_ERROR:
break;
}
return EINVAL;
2008a54: 81 c7 e0 08 ret
2008a58: 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 );
2008a5c: 40 00 19 6c call 200f00c <_POSIX_Absolute_timeout_to_ticks>
2008a60: 90 10 00 19 mov %i1, %o0
2008a64: d2 06 00 00 ld [ %i0 ], %o1
2008a68: ba 10 00 08 mov %o0, %i5
2008a6c: 94 07 bf f8 add %fp, -8, %o2
2008a70: 11 00 80 83 sethi %hi(0x2020c00), %o0
2008a74: 40 00 0a e1 call 200b5f8 <_Objects_Get>
2008a78: 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 ) {
2008a7c: c2 07 bf f8 ld [ %fp + -8 ], %g1
2008a80: 80 a0 60 00 cmp %g1, 0
2008a84: 32 80 00 21 bne,a 2008b08 <pthread_rwlock_timedwrlock+0xc4>
2008a88: b0 10 20 16 mov 0x16, %i0
case OBJECTS_LOCAL:
_CORE_RWLock_Obtain_for_writing(
2008a8c: d2 06 00 00 ld [ %i0 ], %o1
2008a90: 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 )
2008a94: 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(
2008a98: 90 02 20 10 add %o0, 0x10, %o0
2008a9c: 80 a0 00 01 cmp %g0, %g1
2008aa0: 98 10 20 00 clr %o4
2008aa4: b8 60 3f ff subx %g0, -1, %i4
2008aa8: 40 00 07 8a call 200a8d0 <_CORE_RWLock_Obtain_for_writing>
2008aac: 94 10 00 1c mov %i4, %o2
do_wait,
ticks,
NULL
);
_Thread_Enable_dispatch();
2008ab0: 40 00 0e 7e call 200c4a8 <_Thread_Enable_dispatch>
2008ab4: 01 00 00 00 nop
if ( !do_wait &&
2008ab8: 80 a7 20 00 cmp %i4, 0
2008abc: 12 80 00 0e bne 2008af4 <pthread_rwlock_timedwrlock+0xb0>
2008ac0: 03 00 80 84 sethi %hi(0x2021000), %g1
(_Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE) ) {
2008ac4: c2 00 61 2c ld [ %g1 + 0x12c ], %g1 ! 202112c <_Per_CPU_Information+0xc>
ticks,
NULL
);
_Thread_Enable_dispatch();
if ( !do_wait &&
2008ac8: c2 00 60 34 ld [ %g1 + 0x34 ], %g1
2008acc: 80 a0 60 02 cmp %g1, 2
2008ad0: 32 80 00 0a bne,a 2008af8 <pthread_rwlock_timedwrlock+0xb4>
2008ad4: 03 00 80 84 sethi %hi(0x2021000), %g1
(_Thread_Executing->Wait.return_code == CORE_RWLOCK_UNAVAILABLE) ) {
if ( status == POSIX_ABSOLUTE_TIMEOUT_INVALID )
2008ad8: 80 a7 60 00 cmp %i5, 0
2008adc: 22 80 00 0b be,a 2008b08 <pthread_rwlock_timedwrlock+0xc4><== NEVER TAKEN
2008ae0: b0 10 20 16 mov 0x16, %i0 <== NOT EXECUTED
return EINVAL;
if ( status == POSIX_ABSOLUTE_TIMEOUT_IS_IN_PAST ||
2008ae4: ba 07 7f ff add %i5, -1, %i5
2008ae8: 80 a7 60 01 cmp %i5, 1
2008aec: 08 80 00 07 bleu 2008b08 <pthread_rwlock_timedwrlock+0xc4><== ALWAYS TAKEN
2008af0: 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
2008af4: 03 00 80 84 sethi %hi(0x2021000), %g1
2008af8: 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(
2008afc: 40 00 00 05 call 2008b10 <_POSIX_RWLock_Translate_core_RWLock_return_code>
2008b00: d0 00 60 34 ld [ %g1 + 0x34 ], %o0
2008b04: b0 10 00 08 mov %o0, %i0
case OBJECTS_ERROR:
break;
}
return EINVAL;
}
2008b08: 81 c7 e0 08 ret
2008b0c: 81 e8 00 00 restore
0200929c <pthread_rwlockattr_setpshared>:
int pthread_rwlockattr_setpshared(
pthread_rwlockattr_t *attr,
int pshared
)
{
200929c: 82 10 00 08 mov %o0, %g1
if ( !attr )
20092a0: 80 a0 60 00 cmp %g1, 0
20092a4: 02 80 00 0a be 20092cc <pthread_rwlockattr_setpshared+0x30>
20092a8: 90 10 20 16 mov 0x16, %o0
return EINVAL;
if ( !attr->is_initialized )
20092ac: c4 00 40 00 ld [ %g1 ], %g2
20092b0: 80 a0 a0 00 cmp %g2, 0
20092b4: 02 80 00 06 be 20092cc <pthread_rwlockattr_setpshared+0x30>
20092b8: 80 a2 60 01 cmp %o1, 1
return EINVAL;
switch ( pshared ) {
20092bc: 18 80 00 04 bgu 20092cc <pthread_rwlockattr_setpshared+0x30><== NEVER TAKEN
20092c0: 01 00 00 00 nop
case PTHREAD_PROCESS_SHARED:
case PTHREAD_PROCESS_PRIVATE:
attr->process_shared = pshared;
20092c4: d2 20 60 04 st %o1, [ %g1 + 4 ]
return 0;
20092c8: 90 10 20 00 clr %o0
default:
return EINVAL;
}
}
20092cc: 81 c3 e0 08 retl
0200a2d4 <pthread_setschedparam>:
int pthread_setschedparam(
pthread_t thread,
int policy,
struct sched_param *param
)
{
200a2d4: 9d e3 bf 90 save %sp, -112, %sp
int rc;
/*
* Check all the parameters
*/
if ( !param )
200a2d8: 80 a6 a0 00 cmp %i2, 0
200a2dc: 02 80 00 40 be 200a3dc <pthread_setschedparam+0x108>
200a2e0: b6 10 20 16 mov 0x16, %i3
return EINVAL;
rc = _POSIX_Thread_Translate_sched_param(
200a2e4: 90 10 00 19 mov %i1, %o0
200a2e8: 92 10 00 1a mov %i2, %o1
200a2ec: 94 07 bf f4 add %fp, -12, %o2
200a2f0: 40 00 17 63 call 201007c <_POSIX_Thread_Translate_sched_param>
200a2f4: 96 07 bf f8 add %fp, -8, %o3
policy,
param,
&budget_algorithm,
&budget_callout
);
if ( rc )
200a2f8: b6 92 20 00 orcc %o0, 0, %i3
200a2fc: 32 80 00 39 bne,a 200a3e0 <pthread_setschedparam+0x10c>
200a300: b0 10 00 1b mov %i3, %i0
return rc;
/*
* Actually change the scheduling policy and parameters
*/
the_thread = _Thread_Get( thread, &location );
200a304: 90 10 00 18 mov %i0, %o0
200a308: 40 00 0c 16 call 200d360 <_Thread_Get>
200a30c: 92 07 bf fc add %fp, -4, %o1
switch ( location ) {
200a310: c2 07 bf fc ld [ %fp + -4 ], %g1
200a314: 80 a0 60 00 cmp %g1, 0
200a318: 12 80 00 30 bne 200a3d8 <pthread_setschedparam+0x104>
200a31c: b8 10 00 08 mov %o0, %i4
case OBJECTS_LOCAL:
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
200a320: fa 02 21 5c ld [ %o0 + 0x15c ], %i5
if ( api->schedpolicy == SCHED_SPORADIC )
200a324: c2 07 60 84 ld [ %i5 + 0x84 ], %g1
200a328: 80 a0 60 04 cmp %g1, 4
200a32c: 32 80 00 05 bne,a 200a340 <pthread_setschedparam+0x6c>
200a330: f2 27 60 84 st %i1, [ %i5 + 0x84 ]
(void) _Watchdog_Remove( &api->Sporadic_timer );
200a334: 40 00 10 28 call 200e3d4 <_Watchdog_Remove>
200a338: 90 07 60 a8 add %i5, 0xa8, %o0
api->schedpolicy = policy;
200a33c: f2 27 60 84 st %i1, [ %i5 + 0x84 ]
api->schedparam = *param;
200a340: 90 07 60 88 add %i5, 0x88, %o0
200a344: 92 10 00 1a mov %i2, %o1
200a348: 40 00 24 2a call 20133f0 <memcpy>
200a34c: 94 10 20 1c mov 0x1c, %o2
the_thread->budget_algorithm = budget_algorithm;
200a350: c2 07 bf f4 ld [ %fp + -12 ], %g1
the_thread->budget_callout = budget_callout;
switch ( api->schedpolicy ) {
200a354: 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;
200a358: c2 27 20 78 st %g1, [ %i4 + 0x78 ]
the_thread->budget_callout = budget_callout;
200a35c: c2 07 bf f8 ld [ %fp + -8 ], %g1
switch ( api->schedpolicy ) {
200a360: 06 80 00 1b bl 200a3cc <pthread_setschedparam+0xf8> <== NEVER TAKEN
200a364: c2 27 20 7c st %g1, [ %i4 + 0x7c ]
200a368: 80 a6 60 02 cmp %i1, 2
200a36c: 04 80 00 07 ble 200a388 <pthread_setschedparam+0xb4>
200a370: 03 00 80 8c sethi %hi(0x2023000), %g1
200a374: 80 a6 60 04 cmp %i1, 4
200a378: 12 80 00 15 bne 200a3cc <pthread_setschedparam+0xf8> <== NEVER TAKEN
200a37c: 01 00 00 00 nop
true
);
break;
case SCHED_SPORADIC:
api->ss_high_priority = api->schedparam.sched_priority;
200a380: 10 80 00 0d b 200a3b4 <pthread_setschedparam+0xe0>
200a384: 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;
200a388: c2 00 60 30 ld [ %g1 + 0x30 ], %g1
the_thread->real_priority =
_POSIX_Priority_To_core( api->schedparam.sched_priority );
_Thread_Change_priority(
200a38c: 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;
200a390: c2 27 20 74 st %g1, [ %i4 + 0x74 ]
200a394: 03 00 80 88 sethi %hi(0x2022000), %g1
200a398: d2 08 62 c8 ldub [ %g1 + 0x2c8 ], %o1 ! 20222c8 <rtems_maximum_priority>
200a39c: c2 07 60 88 ld [ %i5 + 0x88 ], %g1
the_thread->real_priority =
_POSIX_Priority_To_core( api->schedparam.sched_priority );
_Thread_Change_priority(
200a3a0: 94 10 20 01 mov 1, %o2
200a3a4: 92 22 40 01 sub %o1, %g1, %o1
200a3a8: 40 00 0a bc call 200ce98 <_Thread_Change_priority>
200a3ac: d2 27 20 18 st %o1, [ %i4 + 0x18 ]
the_thread,
the_thread->real_priority,
true
);
break;
200a3b0: 30 80 00 07 b,a 200a3cc <pthread_setschedparam+0xf8>
case SCHED_SPORADIC:
api->ss_high_priority = api->schedparam.sched_priority;
_Watchdog_Remove( &api->Sporadic_timer );
200a3b4: 90 07 60 a8 add %i5, 0xa8, %o0
200a3b8: 40 00 10 07 call 200e3d4 <_Watchdog_Remove>
200a3bc: c2 27 60 a4 st %g1, [ %i5 + 0xa4 ]
_POSIX_Threads_Sporadic_budget_TSR( 0, the_thread );
200a3c0: 90 10 20 00 clr %o0
200a3c4: 7f ff ff 7e call 200a1bc <_POSIX_Threads_Sporadic_budget_TSR>
200a3c8: 92 10 00 1c mov %i4, %o1
break;
}
_Thread_Enable_dispatch();
200a3cc: 40 00 0b d8 call 200d32c <_Thread_Enable_dispatch>
200a3d0: b0 10 00 1b mov %i3, %i0
200a3d4: 30 80 00 03 b,a 200a3e0 <pthread_setschedparam+0x10c>
#endif
case OBJECTS_ERROR:
break;
}
return ESRCH;
200a3d8: b6 10 20 03 mov 3, %i3
}
200a3dc: b0 10 00 1b mov %i3, %i0
200a3e0: 81 c7 e0 08 ret
200a3e4: 81 e8 00 00 restore
02007c00 <pthread_testcancel>:
/*
* 18.2.2 Setting Cancelability State, P1003.1c/Draft 10, p. 183
*/
void pthread_testcancel( void )
{
2007c00: 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() )
2007c04: 03 00 80 7b sethi %hi(0x201ec00), %g1
2007c08: 82 10 62 90 or %g1, 0x290, %g1 ! 201ee90 <_Per_CPU_Information>
2007c0c: c4 00 60 08 ld [ %g1 + 8 ], %g2
2007c10: 80 a0 a0 00 cmp %g2, 0
2007c14: 12 80 00 18 bne 2007c74 <pthread_testcancel+0x74> <== NEVER TAKEN
2007c18: 01 00 00 00 nop
return;
thread_support = _Thread_Executing->API_Extensions[ THREAD_API_POSIX ];
2007c1c: c2 00 60 0c ld [ %g1 + 0xc ], %g1
2007c20: 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++;
2007c24: 03 00 80 7a sethi %hi(0x201e800), %g1
2007c28: c6 00 61 60 ld [ %g1 + 0x160 ], %g3 ! 201e960 <_Thread_Dispatch_disable_level>
2007c2c: 86 00 e0 01 inc %g3
2007c30: c6 20 61 60 st %g3, [ %g1 + 0x160 ]
return _Thread_Dispatch_disable_level;
2007c34: c2 00 61 60 ld [ %g1 + 0x160 ], %g1
_Thread_Disable_dispatch();
if ( thread_support->cancelability_state == PTHREAD_CANCEL_ENABLE &&
2007c38: c2 00 a0 d8 ld [ %g2 + 0xd8 ], %g1
2007c3c: 80 a0 60 00 cmp %g1, 0
2007c40: 12 80 00 05 bne 2007c54 <pthread_testcancel+0x54> <== NEVER TAKEN
2007c44: ba 10 20 00 clr %i5
2007c48: c2 00 a0 e0 ld [ %g2 + 0xe0 ], %g1
2007c4c: 80 a0 00 01 cmp %g0, %g1
2007c50: ba 40 20 00 addx %g0, 0, %i5
thread_support->cancelation_requested )
cancel = true;
_Thread_Enable_dispatch();
2007c54: 40 00 0b 9a call 200aabc <_Thread_Enable_dispatch>
2007c58: 01 00 00 00 nop
if ( cancel )
2007c5c: 80 8f 60 ff btst 0xff, %i5
2007c60: 02 80 00 05 be 2007c74 <pthread_testcancel+0x74>
2007c64: 03 00 80 7b sethi %hi(0x201ec00), %g1
_POSIX_Thread_Exit( _Thread_Executing, PTHREAD_CANCELED );
2007c68: f0 00 62 9c ld [ %g1 + 0x29c ], %i0 ! 201ee9c <_Per_CPU_Information+0xc>
2007c6c: 40 00 17 18 call 200d8cc <_POSIX_Thread_Exit>
2007c70: 93 e8 3f ff restore %g0, -1, %o1
2007c74: 81 c7 e0 08 ret
2007c78: 81 e8 00 00 restore
0200c984 <ramdisk_allocate>:
void *area_begin,
uint32_t block_size,
rtems_blkdev_bnum block_count,
bool trace
)
{
200c984: 9d e3 bf a0 save %sp, -96, %sp
struct ramdisk *rd = malloc(sizeof(struct ramdisk));
200c988: 7f ff e1 86 call 2004fa0 <malloc>
200c98c: 90 10 20 10 mov 0x10, %o0
if (rd == NULL) {
200c990: ba 92 20 00 orcc %o0, 0, %i5
200c994: 02 80 00 16 be 200c9ec <ramdisk_allocate+0x68> <== NEVER TAKEN
200c998: 80 a6 20 00 cmp %i0, 0
return NULL;
}
if (area_begin == NULL) {
200c99c: 32 80 00 0e bne,a 200c9d4 <ramdisk_allocate+0x50>
200c9a0: c0 2f 60 0d clrb [ %i5 + 0xd ]
area_begin = calloc(block_count, block_size);
200c9a4: 90 10 00 1a mov %i2, %o0
200c9a8: 7f ff df 53 call 20046f4 <calloc>
200c9ac: 92 10 00 19 mov %i1, %o1
if (area_begin == NULL) {
200c9b0: b0 92 20 00 orcc %o0, 0, %i0
200c9b4: 12 80 00 07 bne 200c9d0 <ramdisk_allocate+0x4c> <== ALWAYS TAKEN
200c9b8: 82 10 20 01 mov 1, %g1
free(rd);
200c9bc: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
200c9c0: 7f ff e0 22 call 2004a48 <free> <== NOT EXECUTED
200c9c4: ba 10 20 00 clr %i5 <== NOT EXECUTED
return NULL;
200c9c8: 81 c7 e0 08 ret <== NOT EXECUTED
200c9cc: 91 e8 00 1d restore %g0, %i5, %o0 <== NOT EXECUTED
200c9d0: 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;
200c9d4: 82 10 20 01 mov 1, %g1
}
rd->malloced = true;
} else {
rd->malloced = false;
}
rd->block_size = block_size;
200c9d8: f2 27 40 00 st %i1, [ %i5 ]
rd->block_num = block_count;
200c9dc: f4 27 60 04 st %i2, [ %i5 + 4 ]
rd->area = area_begin;
200c9e0: f0 27 60 08 st %i0, [ %i5 + 8 ]
rd->trace = trace;
200c9e4: f6 2f 60 0e stb %i3, [ %i5 + 0xe ]
rd->initialized = true;
200c9e8: c2 2f 60 0c stb %g1, [ %i5 + 0xc ]
return rd;
}
200c9ec: b0 10 00 1d mov %i5, %i0
200c9f0: 81 c7 e0 08 ret
200c9f4: 81 e8 00 00 restore
0200c9f8 <ramdisk_free>:
void ramdisk_free(ramdisk *rd)
{
200c9f8: 9d e3 bf a0 save %sp, -96, %sp
if (rd != NULL) {
200c9fc: 80 a6 20 00 cmp %i0, 0
200ca00: 02 80 00 0a be 200ca28 <ramdisk_free+0x30> <== NEVER TAKEN
200ca04: 01 00 00 00 nop
if (rd->malloced) {
200ca08: c2 0e 20 0d ldub [ %i0 + 0xd ], %g1
200ca0c: 80 a0 60 00 cmp %g1, 0
200ca10: 02 80 00 04 be 200ca20 <ramdisk_free+0x28>
200ca14: 01 00 00 00 nop
free(rd->area);
200ca18: 7f ff e0 0c call 2004a48 <free>
200ca1c: d0 06 20 08 ld [ %i0 + 8 ], %o0
}
free(rd);
200ca20: 7f ff e0 0a call 2004a48 <free>
200ca24: 81 e8 00 00 restore
200ca28: 81 c7 e0 08 ret <== NOT EXECUTED
200ca2c: 81 e8 00 00 restore <== NOT EXECUTED
0200dbec <ramdisk_initialize>:
rtems_device_driver
ramdisk_initialize(
rtems_device_major_number major,
rtems_device_minor_number minor __attribute__((unused)),
void *arg __attribute__((unused)))
{
200dbec: 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();
200dbf0: 7f ff db 37 call 20048cc <rtems_disk_io_initialize>
200dbf4: a8 10 00 18 mov %i0, %l4
if (rc != RTEMS_SUCCESSFUL)
200dbf8: b0 92 20 00 orcc %o0, 0, %i0
200dbfc: 12 80 00 46 bne 200dd14 <ramdisk_initialize+0x128> <== NEVER TAKEN
200dc00: 3b 00 80 98 sethi %hi(0x2026000), %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));
200dc04: d0 07 62 d8 ld [ %i5 + 0x2d8 ], %o0 ! 20262d8 <rtems_ramdisk_configuration_size>
200dc08: 92 10 20 10 mov 0x10, %o1
200dc0c: 7f ff de d5 call 2005760 <calloc>
200dc10: 33 00 80 98 sethi %hi(0x2026000), %i1
r->trace = false;
for (i = 0; i < rtems_ramdisk_configuration_size; i++, c++, r++)
200dc14: a6 10 00 1d mov %i5, %l3
{
dev_t dev = rtems_filesystem_make_dev_t(major, i);
char name [] = RAMDISK_DEVICE_BASE_NAME "a";
200dc18: 39 0b d9 19 sethi %hi(0x2f646400), %i4
200dc1c: 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,
200dc20: 2b 00 80 37 sethi %hi(0x200dc00), %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));
200dc24: b6 10 00 08 mov %o0, %i3
r->trace = false;
200dc28: 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;
200dc2c: b2 16 62 dc or %i1, 0x2dc, %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++)
200dc30: b4 10 20 00 clr %i2
{
dev_t dev = rtems_filesystem_make_dev_t(major, i);
char name [] = RAMDISK_DEVICE_BASE_NAME "a";
200dc34: b8 17 21 76 or %i4, 0x176, %i4
200dc38: 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);
200dc3c: 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,
200dc40: aa 15 61 1c or %l5, 0x11c, %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++)
200dc44: 10 80 00 2f b 200dd00 <ramdisk_initialize+0x114>
200dc48: 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;
200dc4c: f4 2f bf f8 stb %i2, [ %fp + -8 ]
r->block_size = c->block_size;
200dc50: e4 06 40 00 ld [ %i1 ], %l2
r->block_num = c->block_num;
200dc54: e2 06 60 04 ld [ %i1 + 4 ], %l1
if (c->location == NULL)
200dc58: 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;
200dc5c: e4 26 c0 00 st %l2, [ %i3 ]
r->block_num = c->block_num;
if (c->location == NULL)
200dc60: 80 a0 60 00 cmp %g1, 0
200dc64: 12 80 00 0f bne 200dca0 <ramdisk_initialize+0xb4> <== NEVER TAKEN
200dc68: e2 26 e0 04 st %l1, [ %i3 + 4 ]
{
r->malloced = true;
r->area = malloc(r->block_size * r->block_num);
200dc6c: 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;
200dc70: e0 2e e0 0d stb %l0, [ %i3 + 0xd ]
r->area = malloc(r->block_size * r->block_num);
200dc74: 40 00 4f 76 call 2021a4c <.umul>
200dc78: 90 10 00 11 mov %l1, %o0
200dc7c: 7f ff e1 34 call 200614c <malloc>
200dc80: 01 00 00 00 nop
if (r->area == NULL) /* No enough memory for this disk */
200dc84: 80 a2 20 00 cmp %o0, 0
200dc88: 12 80 00 04 bne 200dc98 <ramdisk_initialize+0xac> <== ALWAYS TAKEN
200dc8c: d0 26 e0 08 st %o0, [ %i3 + 8 ]
{
if (r->malloced)
{
free(r->area);
}
r->initialized = false;
200dc90: 10 80 00 19 b 200dcf4 <ramdisk_initialize+0x108> <== NOT EXECUTED
200dc94: c0 2e e0 0c clrb [ %i3 + 0xc ] <== NOT EXECUTED
r->initialized = false;
continue;
}
else
{
r->initialized = true;
200dc98: 10 80 00 05 b 200dcac <ramdisk_initialize+0xc0>
200dc9c: e0 2e e0 0c stb %l0, [ %i3 + 0xc ]
}
}
else
{
r->malloced = false;
200dca0: c0 2e e0 0d clrb [ %i3 + 0xd ] <== NOT EXECUTED
r->initialized = true;
200dca4: e0 2e e0 0c stb %l0, [ %i3 + 0xc ] <== NOT EXECUTED
r->area = c->location;
200dca8: c2 26 e0 08 st %g1, [ %i3 + 8 ] <== NOT EXECUTED
}
rc = rtems_disk_create_phys(dev, c->block_size, c->block_num,
200dcac: f0 23 a0 5c st %i0, [ %sp + 0x5c ]
200dcb0: 90 10 00 14 mov %l4, %o0
200dcb4: 92 10 00 1a mov %i2, %o1
200dcb8: 94 10 00 12 mov %l2, %o2
200dcbc: 96 10 00 11 mov %l1, %o3
200dcc0: 98 10 00 15 mov %l5, %o4
200dcc4: 7f ff da 6c call 2004674 <rtems_disk_create_phys>
200dcc8: 9a 10 00 1b mov %i3, %o5
ramdisk_ioctl, r, name);
if (rc != RTEMS_SUCCESSFUL)
200dccc: 80 a2 20 00 cmp %o0, 0
200dcd0: 22 80 00 0a be,a 200dcf8 <ramdisk_initialize+0x10c> <== ALWAYS TAKEN
200dcd4: b4 06 a0 01 inc %i2
{
if (r->malloced)
200dcd8: c2 0e e0 0d ldub [ %i3 + 0xd ], %g1 <== NOT EXECUTED
200dcdc: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
200dce0: 22 80 00 05 be,a 200dcf4 <ramdisk_initialize+0x108> <== NOT EXECUTED
200dce4: c0 2e e0 0c clrb [ %i3 + 0xc ] <== NOT EXECUTED
{
free(r->area);
200dce8: 7f ff df 73 call 2005ab4 <free> <== NOT EXECUTED
200dcec: d0 06 e0 08 ld [ %i3 + 8 ], %o0 <== NOT EXECUTED
}
r->initialized = false;
200dcf0: 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++)
200dcf4: b4 06 a0 01 inc %i2 <== NOT EXECUTED
200dcf8: b2 06 60 0c add %i1, 0xc, %i1
200dcfc: b6 06 e0 10 add %i3, 0x10, %i3
200dd00: c2 04 e2 d8 ld [ %l3 + 0x2d8 ], %g1
200dd04: 80 a6 80 01 cmp %i2, %g1
200dd08: 2a bf ff d1 bcs,a 200dc4c <ramdisk_initialize+0x60>
200dd0c: f8 3f bf f0 std %i4, [ %fp + -16 ]
free(r->area);
}
r->initialized = false;
}
}
return RTEMS_SUCCESSFUL;
200dd10: b0 10 20 00 clr %i0
}
200dd14: 81 c7 e0 08 ret
200dd18: 81 e8 00 00 restore
0200c854 <ramdisk_ioctl>:
return 0;
}
int
ramdisk_ioctl(rtems_disk_device *dd, uint32_t req, void *argp)
{
200c854: 9d e3 bf a0 save %sp, -96, %sp
struct ramdisk *rd = rtems_disk_get_driver_data(dd);
switch (req)
200c858: 05 08 00 10 sethi %hi(0x20004000), %g2
return 0;
}
int
ramdisk_ioctl(rtems_disk_device *dd, uint32_t req, void *argp)
{
200c85c: ba 10 00 1a mov %i2, %i5
struct ramdisk *rd = rtems_disk_get_driver_data(dd);
switch (req)
200c860: 84 10 a2 07 or %g2, 0x207, %g2
200c864: 80 a6 40 02 cmp %i1, %g2
200c868: 02 80 00 38 be 200c948 <ramdisk_ioctl+0xf4>
200c86c: f8 06 20 3c ld [ %i0 + 0x3c ], %i4
200c870: 05 30 06 10 sethi %hi(0xc0184000), %g2
200c874: 84 10 a2 01 or %g2, 0x201, %g2 ! c0184201 <RAM_END+0xbdd84201>
200c878: 80 a6 40 02 cmp %i1, %g2
200c87c: 12 80 00 3a bne 200c964 <ramdisk_ioctl+0x110>
200c880: 01 00 00 00 nop
{
case RTEMS_BLKIO_REQUEST:
{
rtems_blkdev_request *r = argp;
switch (r->req)
200c884: c2 06 80 00 ld [ %i2 ], %g1
200c888: 80 a0 60 00 cmp %g1, 0
200c88c: 02 80 00 07 be 200c8a8 <ramdisk_ioctl+0x54>
200c890: b6 06 a0 18 add %i2, 0x18, %i3
200c894: 80 a0 60 01 cmp %g1, 1
200c898: 12 80 00 35 bne 200c96c <ramdisk_ioctl+0x118> <== NEVER TAKEN
200c89c: 01 00 00 00 nop
}
static int
ramdisk_write(struct ramdisk *rd, rtems_blkdev_request *req)
{
uint8_t *to = rd->area;
200c8a0: 10 80 00 14 b 200c8f0 <ramdisk_ioctl+0x9c>
200c8a4: 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;
200c8a8: 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++)
200c8ac: 10 80 00 0b b 200c8d8 <ramdisk_ioctl+0x84>
200c8b0: 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);
200c8b4: d2 07 00 00 ld [ %i4 ], %o1
200c8b8: 40 00 3f e5 call 201c84c <.umul>
200c8bc: f0 06 e0 08 ld [ %i3 + 8 ], %i0
200c8c0: d4 06 e0 04 ld [ %i3 + 4 ], %o2
200c8c4: 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++)
200c8c8: 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);
200c8cc: 90 10 00 18 mov %i0, %o0
200c8d0: 40 00 1e fa call 20144b8 <memcpy>
200c8d4: 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++)
200c8d8: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
200c8dc: 80 a6 80 01 cmp %i2, %g1
200c8e0: 2a bf ff f5 bcs,a 200c8b4 <ramdisk_ioctl+0x60>
200c8e4: 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);
200c8e8: 10 80 00 11 b 200c92c <ramdisk_ioctl+0xd8>
200c8ec: 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++)
200c8f0: 10 80 00 0a b 200c918 <ramdisk_ioctl+0xc4>
200c8f4: 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);
200c8f8: d2 07 00 00 ld [ %i4 ], %o1
200c8fc: 40 00 3f d4 call 201c84c <.umul>
200c900: b4 06 a0 01 inc %i2
200c904: d2 06 e0 08 ld [ %i3 + 8 ], %o1
200c908: d4 06 e0 04 ld [ %i3 + 4 ], %o2
200c90c: 90 06 40 08 add %i1, %o0, %o0
200c910: 40 00 1e ea call 20144b8 <memcpy>
200c914: 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++)
200c918: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
200c91c: 80 a6 80 01 cmp %i2, %g1
200c920: 2a bf ff f6 bcs,a 200c8f8 <ramdisk_ioctl+0xa4>
200c924: 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);
200c928: c2 07 60 04 ld [ %i5 + 4 ], %g1
200c92c: 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;
200c930: c0 27 60 0c clr [ %i5 + 0xc ]
req->req_done(req->done_arg, RTEMS_SUCCESSFUL);
200c934: 92 10 20 00 clr %o1
200c938: 9f c0 40 00 call %g1
200c93c: 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);
200c940: 81 c7 e0 08 ret
200c944: 81 e8 00 00 restore
}
break;
}
case RTEMS_BLKIO_DELETED:
if (rd->free_at_delete_request) {
200c948: c2 0f 20 0f ldub [ %i4 + 0xf ], %g1
200c94c: 80 a0 60 00 cmp %g1, 0
200c950: 02 80 00 07 be 200c96c <ramdisk_ioctl+0x118>
200c954: 01 00 00 00 nop
ramdisk_free(rd);
200c958: 40 00 00 28 call 200c9f8 <ramdisk_free>
200c95c: 90 10 00 1c mov %i4, %o0
200c960: 30 80 00 03 b,a 200c96c <ramdisk_ioctl+0x118>
}
break;
default:
return rtems_blkdev_ioctl (dd, req, argp);
200c964: 40 00 0a 0d call 200f198 <rtems_blkdev_ioctl>
200c968: 81 e8 00 00 restore
break;
}
errno = EINVAL;
200c96c: 40 00 1c 8c call 2013b9c <__errno>
200c970: b0 10 3f ff mov -1, %i0
200c974: 82 10 20 16 mov 0x16, %g1
200c978: c2 22 00 00 st %g1, [ %o0 ]
return -1;
}
200c97c: 81 c7 e0 08 ret
200c980: 81 e8 00 00 restore
0200ca30 <ramdisk_register>:
rtems_blkdev_bnum block_count,
bool trace,
const char *disk,
dev_t *dev_ptr
)
{
200ca30: 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);
200ca34: 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;
200ca38: c0 27 bf fc clr [ %fp + -4 ]
ramdisk *rd = NULL;
dev_t dev = 0;
sc = rtems_io_register_driver(0, &ramdisk_ops, &major);
200ca3c: 13 00 80 7e sethi %hi(0x201f800), %o1
200ca40: 94 07 bf fc add %fp, -4, %o2
200ca44: 92 12 63 f0 or %o1, 0x3f0, %o1
200ca48: 7f ff f2 9c call 20094b8 <rtems_io_register_driver>
200ca4c: a0 10 20 0d mov 0xd, %l0
if (sc != RTEMS_SUCCESSFUL) {
200ca50: 80 a2 20 00 cmp %o0, 0
200ca54: 32 80 00 20 bne,a 200cad4 <ramdisk_register+0xa4> <== NEVER TAKEN
200ca58: b0 10 00 10 mov %l0, %i0 <== NOT EXECUTED
return RTEMS_UNSATISFIED;
}
rd = ramdisk_allocate(NULL, block_size, block_count, trace);
200ca5c: 96 10 00 1a mov %i2, %o3
200ca60: 92 10 00 18 mov %i0, %o1
200ca64: 7f ff ff c8 call 200c984 <ramdisk_allocate>
200ca68: 94 10 00 19 mov %i1, %o2
if (rd == NULL) {
200ca6c: b4 92 20 00 orcc %o0, 0, %i2
200ca70: 12 80 00 04 bne 200ca80 <ramdisk_register+0x50> <== ALWAYS TAKEN
200ca74: fa 07 bf fc ld [ %fp + -4 ], %i5
rtems_io_unregister_driver(major);
200ca78: 10 80 00 11 b 200cabc <ramdisk_register+0x8c> <== NOT EXECUTED
200ca7c: 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(
200ca80: f6 23 a0 5c st %i3, [ %sp + 0x5c ]
200ca84: 90 10 00 1d mov %i5, %o0
200ca88: 92 10 20 00 clr %o1
200ca8c: 94 10 00 18 mov %i0, %o2
200ca90: 96 10 00 19 mov %i1, %o3
200ca94: 19 00 80 32 sethi %hi(0x200c800), %o4
200ca98: 9a 10 00 1a mov %i2, %o5
200ca9c: 7f ff dc 6d call 2003c50 <rtems_disk_create_phys>
200caa0: 98 13 20 54 or %o4, 0x54, %o4
block_count,
ramdisk_ioctl,
rd,
disk
);
if (sc != RTEMS_SUCCESSFUL) {
200caa4: 80 a2 20 00 cmp %o0, 0
200caa8: 22 80 00 08 be,a 200cac8 <ramdisk_register+0x98> <== ALWAYS TAKEN
200caac: fa 27 00 00 st %i5, [ %i4 ]
ramdisk_free(rd);
200cab0: 7f ff ff d2 call 200c9f8 <ramdisk_free> <== NOT EXECUTED
200cab4: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
rtems_io_unregister_driver(major);
200cab8: d0 07 bf fc ld [ %fp + -4 ], %o0 <== NOT EXECUTED
200cabc: 7f ff f2 df call 2009638 <rtems_io_unregister_driver> <== NOT EXECUTED
200cac0: b0 10 00 10 mov %l0, %i0 <== NOT EXECUTED
200cac4: 30 80 00 04 b,a 200cad4 <ramdisk_register+0xa4> <== NOT EXECUTED
return RTEMS_UNSATISFIED;
}
*dev_ptr = dev;
200cac8: c0 27 20 04 clr [ %i4 + 4 ]
return RTEMS_SUCCESSFUL;
200cacc: a0 10 20 00 clr %l0
}
200cad0: b0 10 00 10 mov %l0, %i0
200cad4: 81 c7 e0 08 ret
200cad8: 81 e8 00 00 restore
0201a1ac <read>:
ssize_t read(
int fd,
void *buffer,
size_t count
)
{
201a1ac: 9d e3 bf a0 save %sp, -96, %sp
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
201a1b0: 03 00 80 73 sethi %hi(0x201cc00), %g1
201a1b4: c2 00 62 30 ld [ %g1 + 0x230 ], %g1 ! 201ce30 <rtems_libio_number_iops>
201a1b8: 80 a6 00 01 cmp %i0, %g1
201a1bc: 1a 80 00 16 bcc 201a214 <read+0x68>
201a1c0: 83 2e 20 03 sll %i0, 3, %g1
iop = rtems_libio_iop( fd );
201a1c4: b1 2e 20 06 sll %i0, 6, %i0
201a1c8: b0 26 00 01 sub %i0, %g1, %i0
201a1cc: 03 00 80 76 sethi %hi(0x201d800), %g1
201a1d0: d0 00 61 50 ld [ %g1 + 0x150 ], %o0 ! 201d950 <rtems_libio_iops>
201a1d4: 90 02 00 18 add %o0, %i0, %o0
rtems_libio_check_is_open( iop );
201a1d8: c2 02 20 10 ld [ %o0 + 0x10 ], %g1
201a1dc: 80 88 61 00 btst 0x100, %g1
201a1e0: 02 80 00 0d be 201a214 <read+0x68>
201a1e4: 80 a6 60 00 cmp %i1, 0
rtems_libio_check_buffer( buffer );
201a1e8: 12 80 00 06 bne 201a200 <read+0x54> <== ALWAYS TAKEN
201a1ec: 80 a6 a0 00 cmp %i2, 0
201a1f0: 7f ff d6 0a call 200fa18 <__errno> <== NOT EXECUTED
201a1f4: 01 00 00 00 nop <== NOT EXECUTED
201a1f8: 10 80 00 0a b 201a220 <read+0x74> <== NOT EXECUTED
201a1fc: 82 10 20 16 mov 0x16, %g1 ! 16 <PROM_START+0x16> <== NOT EXECUTED
rtems_libio_check_count( count );
201a200: 02 80 00 10 be 201a240 <read+0x94>
201a204: b0 10 20 00 clr %i0
rtems_libio_check_permissions_with_error( iop, LIBIO_FLAGS_READ, EBADF );
201a208: 80 88 60 02 btst 2, %g1
201a20c: 32 80 00 08 bne,a 201a22c <read+0x80>
201a210: c2 02 20 24 ld [ %o0 + 0x24 ], %g1
201a214: 7f ff d6 01 call 200fa18 <__errno>
201a218: 01 00 00 00 nop
201a21c: 82 10 20 09 mov 9, %g1 ! 9 <PROM_START+0x9>
201a220: c2 22 00 00 st %g1, [ %o0 ]
201a224: 81 c7 e0 08 ret
201a228: 91 e8 3f ff restore %g0, -1, %o0
/*
* Now process the read().
*/
return (*iop->pathinfo.handlers->read_h)( iop, buffer, count );
201a22c: 92 10 00 19 mov %i1, %o1
201a230: c2 00 60 08 ld [ %g1 + 8 ], %g1
201a234: 9f c0 40 00 call %g1
201a238: 94 10 00 1a mov %i2, %o2
201a23c: b0 10 00 08 mov %o0, %i0
}
201a240: 81 c7 e0 08 ret
201a244: 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 40 ld [ %g1 + 0x140 ], %g1 ! 201d940 <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 60 ld [ %g1 + 0x60 ], %i4 ! 201e460 <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 ea call 2010754 <__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 d1 call 2010754 <__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 68 or %g1, 0x168, %g1 ! 201d968 <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 30 ld [ %g1 + 0x30 ], %g1 ! 201dc30 <_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 f0 ld [ %g1 + 0x2f0 ], %g1 ! 201daf0 <_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 ec ld [ %i5 + 0x1ec ], %o0
2004710: 92 10 00 18 mov %i0, %o1
2004714: 40 00 13 b0 call 20095d4 <_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 ec ld [ %i5 + 0x1ec ], %o0
errno = EINVAL;
2004728: 40 00 2c bc call 200fa18 <__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 b4 call 2009614 <_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 68 or %g1, 0x168, %g1 ! 201d968 <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 e7 call 2010334 <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 28 ld [ %g1 + 0x28 ], %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
020080f0 <rtems_aio_enqueue>:
* errno - otherwise
*/
int
rtems_aio_enqueue (rtems_aio_request *req)
{
20080f0: 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);
20080f4: 37 00 80 7f sethi %hi(0x201fc00), %i3
* errno - otherwise
*/
int
rtems_aio_enqueue (rtems_aio_request *req)
{
20080f8: 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);
20080fc: 40 00 02 85 call 2008b10 <pthread_mutex_lock>
2008100: 90 16 e2 bc or %i3, 0x2bc, %o0
if (result != 0) {
2008104: b0 92 20 00 orcc %o0, 0, %i0
2008108: 02 80 00 06 be 2008120 <rtems_aio_enqueue+0x30> <== ALWAYS TAKEN
200810c: 01 00 00 00 nop
free (req);
2008110: 7f ff ef 14 call 2003d60 <free> <== NOT EXECUTED
2008114: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
2008118: 81 c7 e0 08 ret <== NOT EXECUTED
200811c: 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);
2008120: 40 00 04 8f call 200935c <pthread_self>
2008124: b6 16 e2 bc or %i3, 0x2bc, %i3
2008128: 92 07 bf e0 add %fp, -32, %o1
200812c: 40 00 03 9c call 2008f9c <pthread_getschedparam>
2008130: 94 07 bf e4 add %fp, -28, %o2
req->caller_thread = pthread_self ();
2008134: 40 00 04 8a call 200935c <pthread_self>
2008138: 01 00 00 00 nop
req->priority = param.sched_priority - req->aiocbp->aio_reqprio;
200813c: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
2008140: c6 07 bf e4 ld [ %fp + -28 ], %g3
2008144: 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 ();
2008148: d0 27 60 10 st %o0, [ %i5 + 0x10 ]
req->priority = param.sched_priority - req->aiocbp->aio_reqprio;
200814c: 84 20 c0 02 sub %g3, %g2, %g2
2008150: c4 27 60 0c st %g2, [ %i5 + 0xc ]
req->policy = policy;
2008154: c4 07 bf e0 ld [ %fp + -32 ], %g2
2008158: c4 27 60 08 st %g2, [ %i5 + 8 ]
req->aiocbp->error_code = EINPROGRESS;
200815c: 84 10 20 77 mov 0x77, %g2
2008160: c4 20 60 34 st %g2, [ %g1 + 0x34 ]
req->aiocbp->return_value = 0;
if ((aio_request_queue.idle_threads == 0) &&
2008164: 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;
2008168: c0 20 60 38 clr [ %g1 + 0x38 ]
if ((aio_request_queue.idle_threads == 0) &&
200816c: 80 a0 a0 00 cmp %g2, 0
2008170: 12 80 00 2e bne 2008228 <rtems_aio_enqueue+0x138> <== NEVER TAKEN
2008174: d2 00 40 00 ld [ %g1 ], %o1
2008178: c2 06 e0 64 ld [ %i3 + 0x64 ], %g1
200817c: 80 a0 60 04 cmp %g1, 4
2008180: 14 80 00 2b bg 200822c <rtems_aio_enqueue+0x13c>
2008184: 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);
2008188: 90 06 e0 48 add %i3, 0x48, %o0
200818c: 7f ff ff 7d call 2007f80 <rtems_aio_search_fd>
2008190: 94 10 20 01 mov 1, %o2
if (r_chain->new_fd == 1) {
2008194: 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);
2008198: b8 10 00 08 mov %o0, %i4
if (r_chain->new_fd == 1) {
200819c: 80 a0 60 01 cmp %g1, 1
20081a0: 12 80 00 1d bne 2008214 <rtems_aio_enqueue+0x124>
20081a4: 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);
20081a8: 92 10 00 1d mov %i5, %o1
20081ac: 40 00 08 ff call 200a5a8 <_Chain_Insert>
20081b0: 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);
20081b4: 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;
20081b8: c0 27 20 18 clr [ %i4 + 0x18 ]
pthread_mutex_init (&r_chain->mutex, NULL);
20081bc: 40 00 01 fc call 20089ac <pthread_mutex_init>
20081c0: 90 07 20 1c add %i4, 0x1c, %o0
pthread_cond_init (&r_chain->cond, NULL);
20081c4: 92 10 20 00 clr %o1
20081c8: 40 00 00 fd call 20085bc <pthread_cond_init>
20081cc: 90 07 20 20 add %i4, 0x20, %o0
AIO_printf ("New thread \n");
result = pthread_create (&thid, &aio_request_queue.attr,
20081d0: 90 07 bf dc add %fp, -36, %o0
20081d4: 92 06 e0 08 add %i3, 8, %o1
20081d8: 15 00 80 1e sethi %hi(0x2007800), %o2
20081dc: 96 10 00 1c mov %i4, %o3
20081e0: 40 00 02 de call 2008d58 <pthread_create>
20081e4: 94 12 a3 c8 or %o2, 0x3c8, %o2
rtems_aio_handle, (void *) r_chain);
if (result != 0) {
20081e8: ba 92 20 00 orcc %o0, 0, %i5
20081ec: 22 80 00 07 be,a 2008208 <rtems_aio_enqueue+0x118> <== ALWAYS TAKEN
20081f0: c2 06 e0 64 ld [ %i3 + 0x64 ], %g1
pthread_mutex_unlock (&aio_request_queue.mutex);
20081f4: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
20081f8: 40 00 02 67 call 2008b94 <pthread_mutex_unlock> <== NOT EXECUTED
20081fc: b0 10 00 1d mov %i5, %i0 <== NOT EXECUTED
2008200: 81 c7 e0 08 ret <== NOT EXECUTED
2008204: 81 e8 00 00 restore <== NOT EXECUTED
return result;
}
++aio_request_queue.active_threads;
2008208: 82 00 60 01 inc %g1
200820c: 10 80 00 3a b 20082f4 <rtems_aio_enqueue+0x204>
2008210: c2 26 e0 64 st %g1, [ %i3 + 0x64 ]
}
else {
/* put request in the fd chain it belongs to */
pthread_mutex_lock (&r_chain->mutex);
2008214: b6 02 20 1c add %o0, 0x1c, %i3
2008218: 40 00 02 3e call 2008b10 <pthread_mutex_lock>
200821c: 90 10 00 1b mov %i3, %o0
rtems_aio_insert_prio (&r_chain->perfd, req);
2008220: 10 80 00 0c b 2008250 <rtems_aio_enqueue+0x160>
2008224: 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,
2008228: 11 00 80 7f sethi %hi(0x201fc00), %o0 <== NOT EXECUTED
200822c: 94 10 20 00 clr %o2
2008230: 7f ff ff 54 call 2007f80 <rtems_aio_search_fd>
2008234: 90 12 23 04 or %o0, 0x304, %o0
req->aiocbp->aio_fildes, 0);
if (r_chain != NULL)
2008238: b8 92 20 00 orcc %o0, 0, %i4
200823c: 02 80 00 0d be 2008270 <rtems_aio_enqueue+0x180>
2008240: b6 07 20 1c add %i4, 0x1c, %i3
{
pthread_mutex_lock (&r_chain->mutex);
2008244: 40 00 02 33 call 2008b10 <pthread_mutex_lock>
2008248: 90 10 00 1b mov %i3, %o0
rtems_aio_insert_prio (&r_chain->perfd, req);
200824c: 90 07 20 08 add %i4, 8, %o0
2008250: 7f ff fe fc call 2007e40 <rtems_aio_insert_prio>
2008254: 92 10 00 1d mov %i5, %o1
pthread_cond_signal (&r_chain->cond);
2008258: 40 00 01 09 call 200867c <pthread_cond_signal>
200825c: 90 07 20 20 add %i4, 0x20, %o0
pthread_mutex_unlock (&r_chain->mutex);
2008260: 40 00 02 4d call 2008b94 <pthread_mutex_unlock>
2008264: 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);
2008268: 10 80 00 24 b 20082f8 <rtems_aio_enqueue+0x208>
200826c: 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);
2008270: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
2008274: 11 00 80 7f sethi %hi(0x201fc00), %o0
2008278: d2 00 40 00 ld [ %g1 ], %o1
200827c: 90 12 23 10 or %o0, 0x310, %o0
2008280: 7f ff ff 40 call 2007f80 <rtems_aio_search_fd>
2008284: 94 10 20 01 mov 1, %o2
if (r_chain->new_fd == 1) {
2008288: 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);
200828c: b8 10 00 08 mov %o0, %i4
2008290: 92 10 00 1d mov %i5, %o1
if (r_chain->new_fd == 1) {
2008294: 80 a0 60 01 cmp %g1, 1
2008298: 12 80 00 0d bne 20082cc <rtems_aio_enqueue+0x1dc>
200829c: 90 02 20 08 add %o0, 8, %o0
20082a0: 40 00 08 c2 call 200a5a8 <_Chain_Insert>
20082a4: 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);
20082a8: 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;
20082ac: c0 27 20 18 clr [ %i4 + 0x18 ]
pthread_mutex_init (&r_chain->mutex, NULL);
20082b0: 40 00 01 bf call 20089ac <pthread_mutex_init>
20082b4: 92 10 20 00 clr %o1
pthread_cond_init (&r_chain->cond, NULL);
20082b8: 90 07 20 20 add %i4, 0x20, %o0
20082bc: 40 00 00 c0 call 20085bc <pthread_cond_init>
20082c0: 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)
20082c4: 10 80 00 05 b 20082d8 <rtems_aio_enqueue+0x1e8>
20082c8: 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);
20082cc: 7f ff fe dd call 2007e40 <rtems_aio_insert_prio>
20082d0: 01 00 00 00 nop
if (aio_request_queue.idle_threads > 0)
20082d4: 11 00 80 7f sethi %hi(0x201fc00), %o0
20082d8: 90 12 22 bc or %o0, 0x2bc, %o0 ! 201febc <aio_request_queue>
20082dc: c2 02 20 68 ld [ %o0 + 0x68 ], %g1
20082e0: 80 a0 60 00 cmp %g1, 0
20082e4: 24 80 00 05 ble,a 20082f8 <rtems_aio_enqueue+0x208> <== ALWAYS TAKEN
20082e8: 11 00 80 7f sethi %hi(0x201fc00), %o0
pthread_cond_signal (&aio_request_queue.new_req);
20082ec: 40 00 00 e4 call 200867c <pthread_cond_signal> <== NOT EXECUTED
20082f0: 90 02 20 04 add %o0, 4, %o0 ! 201fc04 <_PathLocale> <== NOT EXECUTED
}
}
pthread_mutex_unlock (&aio_request_queue.mutex);
20082f4: 11 00 80 7f sethi %hi(0x201fc00), %o0
20082f8: 40 00 02 27 call 2008b94 <pthread_mutex_unlock>
20082fc: 90 12 22 bc or %o0, 0x2bc, %o0 ! 201febc <aio_request_queue>
return 0;
}
2008300: 81 c7 e0 08 ret
2008304: 81 e8 00 00 restore
02007bc8 <rtems_aio_handle>:
* NULL - if error
*/
static void *
rtems_aio_handle (void *arg)
{
2007bc8: 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);
2007bcc: 3b 00 80 7f sethi %hi(0x201fc00), %i5
2007bd0: 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)) {
2007bd4: 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 &&
2007bd8: 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,
2007bdc: 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);
2007be0: b6 06 20 1c add %i0, 0x1c, %i3
2007be4: 40 00 03 cb call 2008b10 <pthread_mutex_lock>
2007be8: 90 10 00 1b mov %i3, %o0
if (result != 0)
2007bec: 80 a2 20 00 cmp %o0, 0
2007bf0: 12 80 00 91 bne 2007e34 <rtems_aio_handle+0x26c> <== NEVER TAKEN
2007bf4: 82 06 20 0c add %i0, 0xc, %g1
2007bf8: 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)) {
2007bfc: 80 a7 00 01 cmp %i4, %g1
2007c00: 02 80 00 3b be 2007cec <rtems_aio_handle+0x124>
2007c04: 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);
2007c08: 40 00 05 d5 call 200935c <pthread_self>
2007c0c: 01 00 00 00 nop
2007c10: 92 07 bf d8 add %fp, -40, %o1
2007c14: 40 00 04 e2 call 2008f9c <pthread_getschedparam>
2007c18: 94 07 bf e4 add %fp, -28, %o2
param.sched_priority = req->priority;
2007c1c: c2 07 20 0c ld [ %i4 + 0xc ], %g1
pthread_setschedparam (pthread_self(), req->policy, ¶m);
2007c20: 40 00 05 cf call 200935c <pthread_self>
2007c24: c2 27 bf e4 st %g1, [ %fp + -28 ]
2007c28: d2 07 20 08 ld [ %i4 + 8 ], %o1
2007c2c: 40 00 05 d0 call 200936c <pthread_setschedparam>
2007c30: 94 07 bf e4 add %fp, -28, %o2
2007c34: 40 00 0a 44 call 200a544 <_Chain_Extract>
2007c38: 90 10 00 1c mov %i4, %o0
rtems_chain_extract (node);
pthread_mutex_unlock (&r_chain->mutex);
2007c3c: 40 00 03 d6 call 2008b94 <pthread_mutex_unlock>
2007c40: 90 10 00 1b mov %i3, %o0
switch (req->aiocbp->aio_lio_opcode) {
2007c44: c2 07 20 14 ld [ %i4 + 0x14 ], %g1
2007c48: c4 00 60 30 ld [ %g1 + 0x30 ], %g2
2007c4c: 80 a0 a0 02 cmp %g2, 2
2007c50: 22 80 00 10 be,a 2007c90 <rtems_aio_handle+0xc8>
2007c54: c4 18 60 08 ldd [ %g1 + 8 ], %g2
2007c58: 80 a0 a0 03 cmp %g2, 3
2007c5c: 02 80 00 15 be 2007cb0 <rtems_aio_handle+0xe8> <== NEVER TAKEN
2007c60: 80 a0 a0 01 cmp %g2, 1
2007c64: 32 80 00 19 bne,a 2007cc8 <rtems_aio_handle+0x100> <== NEVER TAKEN
2007c68: f8 07 20 14 ld [ %i4 + 0x14 ], %i4 <== NOT EXECUTED
case LIO_READ:
AIO_printf ("read\n");
result = pread (req->aiocbp->aio_fildes,
2007c6c: c4 18 60 08 ldd [ %g1 + 8 ], %g2
2007c70: d0 00 40 00 ld [ %g1 ], %o0
2007c74: d2 00 60 10 ld [ %g1 + 0x10 ], %o1
2007c78: d4 00 60 14 ld [ %g1 + 0x14 ], %o2
2007c7c: 96 10 00 02 mov %g2, %o3
2007c80: 40 00 2b 28 call 2012920 <pread>
2007c84: 98 10 00 03 mov %g3, %o4
(void *) req->aiocbp->aio_buf,
req->aiocbp->aio_nbytes, req->aiocbp->aio_offset);
break;
2007c88: 10 80 00 0d b 2007cbc <rtems_aio_handle+0xf4>
2007c8c: 80 a2 3f ff cmp %o0, -1
case LIO_WRITE:
AIO_printf ("write\n");
result = pwrite (req->aiocbp->aio_fildes,
2007c90: d0 00 40 00 ld [ %g1 ], %o0
2007c94: d2 00 60 10 ld [ %g1 + 0x10 ], %o1
2007c98: d4 00 60 14 ld [ %g1 + 0x14 ], %o2
2007c9c: 96 10 00 02 mov %g2, %o3
2007ca0: 40 00 2b 5e call 2012a18 <pwrite>
2007ca4: 98 10 00 03 mov %g3, %o4
(void *) req->aiocbp->aio_buf,
req->aiocbp->aio_nbytes, req->aiocbp->aio_offset);
break;
2007ca8: 10 80 00 05 b 2007cbc <rtems_aio_handle+0xf4>
2007cac: 80 a2 3f ff cmp %o0, -1
case LIO_SYNC:
AIO_printf ("sync\n");
result = fsync (req->aiocbp->aio_fildes);
2007cb0: 40 00 1a 80 call 200e6b0 <fsync> <== NOT EXECUTED
2007cb4: d0 00 40 00 ld [ %g1 ], %o0 <== NOT EXECUTED
break;
default:
result = -1;
}
if (result == -1) {
2007cb8: 80 a2 3f ff cmp %o0, -1 <== NOT EXECUTED
2007cbc: 32 80 00 09 bne,a 2007ce0 <rtems_aio_handle+0x118> <== ALWAYS TAKEN
2007cc0: c2 07 20 14 ld [ %i4 + 0x14 ], %g1
req->aiocbp->return_value = -1;
2007cc4: f8 07 20 14 ld [ %i4 + 0x14 ], %i4 <== NOT EXECUTED
2007cc8: 82 10 3f ff mov -1, %g1 <== NOT EXECUTED
req->aiocbp->error_code = errno;
2007ccc: 40 00 28 19 call 2011d30 <__errno> <== NOT EXECUTED
2007cd0: c2 27 20 38 st %g1, [ %i4 + 0x38 ] <== NOT EXECUTED
2007cd4: c2 02 00 00 ld [ %o0 ], %g1 <== NOT EXECUTED
2007cd8: 10 bf ff c2 b 2007be0 <rtems_aio_handle+0x18> <== NOT EXECUTED
2007cdc: c2 27 20 34 st %g1, [ %i4 + 0x34 ] <== NOT EXECUTED
} else {
req->aiocbp->return_value = result;
2007ce0: d0 20 60 38 st %o0, [ %g1 + 0x38 ]
req->aiocbp->error_code = 0;
2007ce4: 10 bf ff bf b 2007be0 <rtems_aio_handle+0x18>
2007ce8: 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);
2007cec: 40 00 03 aa call 2008b94 <pthread_mutex_unlock>
2007cf0: 90 10 00 1b mov %i3, %o0
pthread_mutex_lock (&aio_request_queue.mutex);
2007cf4: 40 00 03 87 call 2008b10 <pthread_mutex_lock>
2007cf8: 90 10 00 1d mov %i5, %o0
if (rtems_chain_is_empty (chain))
2007cfc: c2 06 20 08 ld [ %i0 + 8 ], %g1
2007d00: 80 a0 40 1c cmp %g1, %i4
2007d04: 12 80 00 48 bne 2007e24 <rtems_aio_handle+0x25c> <== NEVER TAKEN
2007d08: 92 07 bf dc add %fp, -36, %o1
{
clock_gettime (CLOCK_REALTIME, &timeout);
2007d0c: 40 00 01 c9 call 2008430 <clock_gettime>
2007d10: 90 10 20 01 mov 1, %o0
timeout.tv_sec += 3;
2007d14: c2 07 bf dc ld [ %fp + -36 ], %g1
timeout.tv_nsec = 0;
2007d18: 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;
2007d1c: 82 00 60 03 add %g1, 3, %g1
timeout.tv_nsec = 0;
result = pthread_cond_timedwait (&r_chain->cond,
2007d20: 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;
2007d24: c2 27 bf dc st %g1, [ %fp + -36 ]
timeout.tv_nsec = 0;
result = pthread_cond_timedwait (&r_chain->cond,
2007d28: 90 10 00 1c mov %i4, %o0
2007d2c: 92 10 00 1d mov %i5, %o1
2007d30: 40 00 02 70 call 20086f0 <pthread_cond_timedwait>
2007d34: 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) {
2007d38: 80 a2 20 74 cmp %o0, 0x74
2007d3c: 12 80 00 3a bne 2007e24 <rtems_aio_handle+0x25c> <== NEVER TAKEN
2007d40: 01 00 00 00 nop
2007d44: 40 00 0a 00 call 200a544 <_Chain_Extract>
2007d48: 90 10 00 18 mov %i0, %o0
rtems_chain_extract (&r_chain->next_fd);
pthread_mutex_destroy (&r_chain->mutex);
2007d4c: 40 00 02 c3 call 2008858 <pthread_mutex_destroy>
2007d50: 90 10 00 1b mov %i3, %o0
pthread_cond_destroy (&r_chain->cond);
2007d54: 40 00 01 e3 call 20084e0 <pthread_cond_destroy>
2007d58: 90 10 00 1c mov %i4, %o0
free (r_chain);
2007d5c: 7f ff f0 01 call 2003d60 <free>
2007d60: 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)) {
2007d64: c2 07 60 54 ld [ %i5 + 0x54 ], %g1
2007d68: 80 a0 40 1a cmp %g1, %i2
2007d6c: 12 80 00 1b bne 2007dd8 <rtems_aio_handle+0x210>
2007d70: 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);
2007d74: 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;
2007d78: 82 00 60 01 inc %g1
2007d7c: c2 27 60 68 st %g1, [ %i5 + 0x68 ]
--aio_request_queue.active_threads;
2007d80: c2 07 60 64 ld [ %i5 + 0x64 ], %g1
clock_gettime (CLOCK_REALTIME, &timeout);
2007d84: 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;
2007d88: 82 00 7f ff add %g1, -1, %g1
clock_gettime (CLOCK_REALTIME, &timeout);
2007d8c: 40 00 01 a9 call 2008430 <clock_gettime>
2007d90: c2 27 60 64 st %g1, [ %i5 + 0x64 ]
timeout.tv_sec += 3;
2007d94: c2 07 bf dc ld [ %fp + -36 ], %g1
timeout.tv_nsec = 0;
2007d98: 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;
2007d9c: 82 00 60 03 add %g1, 3, %g1
timeout.tv_nsec = 0;
result = pthread_cond_timedwait (&aio_request_queue.new_req,
2007da0: 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;
2007da4: c2 27 bf dc st %g1, [ %fp + -36 ]
timeout.tv_nsec = 0;
result = pthread_cond_timedwait (&aio_request_queue.new_req,
2007da8: 92 10 00 1d mov %i5, %o1
2007dac: 40 00 02 51 call 20086f0 <pthread_cond_timedwait>
2007db0: 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) {
2007db4: 80 a2 20 74 cmp %o0, 0x74
2007db8: 12 80 00 08 bne 2007dd8 <rtems_aio_handle+0x210> <== NEVER TAKEN
2007dbc: c2 07 60 68 ld [ %i5 + 0x68 ], %g1
AIO_printf ("Etimeout\n");
--aio_request_queue.idle_threads;
pthread_mutex_unlock (&aio_request_queue.mutex);
2007dc0: 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;
2007dc4: 82 00 7f ff add %g1, -1, %g1
pthread_mutex_unlock (&aio_request_queue.mutex);
2007dc8: 40 00 03 73 call 2008b94 <pthread_mutex_unlock>
2007dcc: c2 27 60 68 st %g1, [ %i5 + 0x68 ]
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
2007dd0: 81 c7 e0 08 ret
2007dd4: 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;
2007dd8: 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;
2007ddc: 82 00 7f ff add %g1, -1, %g1
2007de0: c2 27 60 68 st %g1, [ %i5 + 0x68 ]
++aio_request_queue.active_threads;
2007de4: c2 07 60 64 ld [ %i5 + 0x64 ], %g1
2007de8: 90 10 00 18 mov %i0, %o0
2007dec: 82 00 60 01 inc %g1
2007df0: 40 00 09 d5 call 200a544 <_Chain_Extract>
2007df4: c2 27 60 64 st %g1, [ %i5 + 0x64 ]
2007df8: c2 07 60 48 ld [ %i5 + 0x48 ], %g1
2007dfc: 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 &&
2007e00: c6 00 60 14 ld [ %g1 + 0x14 ], %g3
2007e04: 80 a0 c0 02 cmp %g3, %g2
2007e08: 16 80 00 04 bge 2007e18 <rtems_aio_handle+0x250>
2007e0c: 80 a0 40 19 cmp %g1, %i1
2007e10: 32 bf ff fc bne,a 2007e00 <rtems_aio_handle+0x238> <== ALWAYS TAKEN
2007e14: 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 );
2007e18: d0 00 60 04 ld [ %g1 + 4 ], %o0
2007e1c: 40 00 09 e3 call 200a5a8 <_Chain_Insert>
2007e20: 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);
2007e24: 40 00 03 5c call 2008b94 <pthread_mutex_unlock>
2007e28: 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);
2007e2c: 10 bf ff 6e b 2007be4 <rtems_aio_handle+0x1c>
2007e30: b6 06 20 1c add %i0, 0x1c, %i3
}
}
AIO_printf ("Thread finished\n");
return NULL;
}
2007e34: b0 10 20 00 clr %i0 <== NOT EXECUTED
2007e38: 81 c7 e0 08 ret <== NOT EXECUTED
2007e3c: 81 e8 00 00 restore <== NOT EXECUTED
02007ea0 <rtems_aio_init>:
* 0 - if initialization succeeded
*/
int
rtems_aio_init (void)
{
2007ea0: 9d e3 bf a0 save %sp, -96, %sp
int result = 0;
result = pthread_attr_init (&aio_request_queue.attr);
2007ea4: 3b 00 80 7f sethi %hi(0x201fc00), %i5
2007ea8: 40 00 03 92 call 2008cf0 <pthread_attr_init>
2007eac: 90 17 62 c4 or %i5, 0x2c4, %o0 ! 201fec4 <aio_request_queue+0x8>
if (result != 0)
2007eb0: b0 92 20 00 orcc %o0, 0, %i0
2007eb4: 12 80 00 31 bne 2007f78 <rtems_aio_init+0xd8> <== NEVER TAKEN
2007eb8: 90 17 62 c4 or %i5, 0x2c4, %o0
return result;
result =
2007ebc: 40 00 03 99 call 2008d20 <pthread_attr_setdetachstate>
2007ec0: 92 10 20 00 clr %o1
pthread_attr_setdetachstate (&aio_request_queue.attr,
PTHREAD_CREATE_DETACHED);
if (result != 0)
2007ec4: 80 a2 20 00 cmp %o0, 0
2007ec8: 22 80 00 05 be,a 2007edc <rtems_aio_init+0x3c> <== ALWAYS TAKEN
2007ecc: 11 00 80 7f sethi %hi(0x201fc00), %o0
pthread_attr_destroy (&aio_request_queue.attr);
2007ed0: 40 00 03 7c call 2008cc0 <pthread_attr_destroy> <== NOT EXECUTED
2007ed4: 90 17 62 c4 or %i5, 0x2c4, %o0 <== NOT EXECUTED
result = pthread_mutex_init (&aio_request_queue.mutex, NULL);
2007ed8: 11 00 80 7f sethi %hi(0x201fc00), %o0 <== NOT EXECUTED
2007edc: 92 10 20 00 clr %o1
2007ee0: 40 00 02 b3 call 20089ac <pthread_mutex_init>
2007ee4: 90 12 22 bc or %o0, 0x2bc, %o0
if (result != 0)
2007ee8: 80 a2 20 00 cmp %o0, 0
2007eec: 22 80 00 06 be,a 2007f04 <rtems_aio_init+0x64> <== ALWAYS TAKEN
2007ef0: 11 00 80 7f sethi %hi(0x201fc00), %o0
pthread_attr_destroy (&aio_request_queue.attr);
2007ef4: 11 00 80 7f sethi %hi(0x201fc00), %o0 <== NOT EXECUTED
2007ef8: 40 00 03 72 call 2008cc0 <pthread_attr_destroy> <== NOT EXECUTED
2007efc: 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);
2007f00: 11 00 80 7f sethi %hi(0x201fc00), %o0 <== NOT EXECUTED
2007f04: 92 10 20 00 clr %o1
2007f08: 40 00 01 ad call 20085bc <pthread_cond_init>
2007f0c: 90 12 22 c0 or %o0, 0x2c0, %o0
if (result != 0) {
2007f10: b0 92 20 00 orcc %o0, 0, %i0
2007f14: 02 80 00 09 be 2007f38 <rtems_aio_init+0x98> <== ALWAYS TAKEN
2007f18: 03 00 80 7f sethi %hi(0x201fc00), %g1
pthread_mutex_destroy (&aio_request_queue.mutex);
2007f1c: 11 00 80 7f sethi %hi(0x201fc00), %o0 <== NOT EXECUTED
2007f20: 40 00 02 4e call 2008858 <pthread_mutex_destroy> <== NOT EXECUTED
2007f24: 90 12 22 bc or %o0, 0x2bc, %o0 ! 201febc <aio_request_queue><== NOT EXECUTED
pthread_attr_destroy (&aio_request_queue.attr);
2007f28: 11 00 80 7f sethi %hi(0x201fc00), %o0 <== NOT EXECUTED
2007f2c: 40 00 03 65 call 2008cc0 <pthread_attr_destroy> <== NOT EXECUTED
2007f30: 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;
2007f34: 03 00 80 7f sethi %hi(0x201fc00), %g1 <== NOT EXECUTED
2007f38: 82 10 62 bc or %g1, 0x2bc, %g1 ! 201febc <aio_request_queue>
2007f3c: 84 00 60 4c add %g1, 0x4c, %g2
2007f40: c4 20 60 48 st %g2, [ %g1 + 0x48 ]
head->previous = NULL;
tail->previous = head;
2007f44: 84 00 60 48 add %g1, 0x48, %g2
2007f48: 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;
2007f4c: 84 00 60 58 add %g1, 0x58, %g2
2007f50: c4 20 60 54 st %g2, [ %g1 + 0x54 ]
head->previous = NULL;
tail->previous = head;
2007f54: 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;
2007f58: c0 20 60 4c clr [ %g1 + 0x4c ]
tail->previous = head;
2007f5c: 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;
2007f60: 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;
2007f64: 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;
2007f68: c0 20 60 64 clr [ %g1 + 0x64 ]
aio_request_queue.idle_threads = 0;
aio_request_queue.initialized = AIO_QUEUE_INITIALIZED;
2007f6c: 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;
2007f70: c0 20 60 68 clr [ %g1 + 0x68 ]
aio_request_queue.initialized = AIO_QUEUE_INITIALIZED;
2007f74: c4 20 60 60 st %g2, [ %g1 + 0x60 ]
return result;
}
2007f78: 81 c7 e0 08 ret
2007f7c: 81 e8 00 00 restore
02007e40 <rtems_aio_insert_prio>:
2007e40: 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 );
2007e44: 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)) {
2007e48: 80 a0 40 03 cmp %g1, %g3
2007e4c: 02 80 00 0e be 2007e84 <rtems_aio_insert_prio+0x44> <== NEVER TAKEN
2007e50: 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;
2007e54: c8 00 60 14 ld [ %g1 + 0x14 ], %g4
while (req->aiocbp->aio_reqprio > prio &&
2007e58: 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;
2007e5c: c8 01 20 18 ld [ %g4 + 0x18 ], %g4
while (req->aiocbp->aio_reqprio > prio &&
2007e60: 10 80 00 04 b 2007e70 <rtems_aio_insert_prio+0x30>
2007e64: 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;
2007e68: c8 00 60 14 ld [ %g1 + 0x14 ], %g4 <== NOT EXECUTED
2007e6c: 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 &&
2007e70: 80 a3 40 04 cmp %o5, %g4
2007e74: 14 80 00 07 bg 2007e90 <rtems_aio_insert_prio+0x50> <== NEVER TAKEN
2007e78: 80 a0 40 03 cmp %g1, %g3
2007e7c: d0 00 60 04 ld [ %g1 + 4 ], %o0
2007e80: 92 10 00 02 mov %g2, %o1
2007e84: 82 13 c0 00 mov %o7, %g1
2007e88: 40 00 09 c8 call 200a5a8 <_Chain_Insert>
2007e8c: 9e 10 40 00 mov %g1, %o7
2007e90: 32 bf ff f6 bne,a 2007e68 <rtems_aio_insert_prio+0x28> <== NOT EXECUTED
2007e94: c2 00 40 00 ld [ %g1 ], %g1 <== NOT EXECUTED
2007e98: 10 bf ff fa b 2007e80 <rtems_aio_insert_prio+0x40> <== NOT EXECUTED
2007e9c: d0 00 60 04 ld [ %g1 + 4 ], %o0 <== NOT EXECUTED
02008070 <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)
{
2008070: 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;
2008074: 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 );
2008078: 82 06 20 04 add %i0, 4, %g1
if (rtems_chain_is_empty (chain))
200807c: 80 a7 40 01 cmp %i5, %g1
2008080: 12 80 00 09 bne 20080a4 <rtems_aio_remove_req+0x34>
2008084: b0 10 20 02 mov 2, %i0
2008088: 81 c7 e0 08 ret
200808c: 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) {
2008090: 80 a7 40 01 cmp %i5, %g1 <== NOT EXECUTED
2008094: 32 80 00 05 bne,a 20080a8 <rtems_aio_remove_req+0x38> <== NOT EXECUTED
2008098: 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;
200809c: 81 c7 e0 08 ret <== NOT EXECUTED
20080a0: 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) {
20080a4: c4 07 60 14 ld [ %i5 + 0x14 ], %g2
20080a8: 80 a0 80 19 cmp %g2, %i1
20080ac: 32 bf ff f9 bne,a 2008090 <rtems_aio_remove_req+0x20> <== NEVER TAKEN
20080b0: 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))
20080b4: 80 a7 40 01 cmp %i5, %g1
20080b8: 02 bf ff f4 be 2008088 <rtems_aio_remove_req+0x18> <== NEVER TAKEN
20080bc: b0 10 20 01 mov 1, %i0
20080c0: 40 00 09 21 call 200a544 <_Chain_Extract>
20080c4: 90 10 00 1d mov %i5, %o0
return AIO_NOTCANCELED;
else
{
rtems_chain_extract (node);
current->aiocbp->error_code = ECANCELED;
20080c8: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
20080cc: 84 10 20 8c mov 0x8c, %g2
20080d0: c4 20 60 34 st %g2, [ %g1 + 0x34 ]
current->aiocbp->return_value = -1;
20080d4: 84 10 3f ff mov -1, %g2
free (current);
20080d8: 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;
20080dc: c4 20 60 38 st %g2, [ %g1 + 0x38 ]
free (current);
20080e0: 7f ff ef 20 call 2003d60 <free>
20080e4: b0 10 20 00 clr %i0
}
return AIO_CANCELED;
}
20080e8: 81 c7 e0 08 ret
20080ec: 81 e8 00 00 restore
0200d2d8 <rtems_bdbuf_add_to_modified_list_after_access>:
}
}
static void
rtems_bdbuf_add_to_modified_list_after_access (rtems_bdbuf_buffer *bd)
{
200d2d8: 9d e3 bf a0 save %sp, -96, %sp
if (bdbuf_cache.sync_active && bdbuf_cache.sync_device == bd->dd)
200d2dc: 3b 00 80 86 sethi %hi(0x2021800), %i5
200d2e0: ba 17 60 8c or %i5, 0x8c, %i5 ! 202188c <bdbuf_cache>
200d2e4: c2 0f 60 30 ldub [ %i5 + 0x30 ], %g1
200d2e8: 80 a0 60 00 cmp %g1, 0
200d2ec: 22 80 00 12 be,a 200d334 <rtems_bdbuf_add_to_modified_list_after_access+0x5c><== ALWAYS TAKEN
200d2f0: c2 06 20 20 ld [ %i0 + 0x20 ], %g1
200d2f4: c4 07 60 38 ld [ %i5 + 0x38 ], %g2 <== NOT EXECUTED
200d2f8: c2 06 20 14 ld [ %i0 + 0x14 ], %g1 <== NOT EXECUTED
200d2fc: 80 a0 80 01 cmp %g2, %g1 <== NOT EXECUTED
200d300: 32 80 00 0d bne,a 200d334 <rtems_bdbuf_add_to_modified_list_after_access+0x5c><== NOT EXECUTED
200d304: c2 06 20 20 ld [ %i0 + 0x20 ], %g1 <== NOT EXECUTED
{
rtems_bdbuf_unlock_cache ();
200d308: 7f ff fe 4b call 200cc34 <rtems_bdbuf_unlock_cache> <== NOT EXECUTED
200d30c: 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);
200d310: d0 07 60 2c ld [ %i5 + 0x2c ], %o0 <== NOT EXECUTED
200d314: 7f ff fe 26 call 200cbac <rtems_bdbuf_lock> <== NOT EXECUTED
200d318: 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,
200d31c: d0 07 60 2c ld [ %i5 + 0x2c ], %o0 <== NOT EXECUTED
200d320: 7f ff fe 3b call 200cc0c <rtems_bdbuf_unlock> <== NOT EXECUTED
200d324: 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 ();
200d328: 7f ff fe 2d call 200cbdc <rtems_bdbuf_lock_cache> <== NOT EXECUTED
200d32c: 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
200d330: c2 06 20 20 ld [ %i0 + 0x20 ], %g1 <== NOT EXECUTED
200d334: 80 a0 60 05 cmp %g1, 5
200d338: 22 80 00 06 be,a 200d350 <rtems_bdbuf_add_to_modified_list_after_access+0x78>
200d33c: 03 00 80 7b sethi %hi(0x201ec00), %g1
200d340: 80 a0 60 03 cmp %g1, 3
200d344: 12 80 00 06 bne 200d35c <rtems_bdbuf_add_to_modified_list_after_access+0x84>
200d348: 82 10 20 07 mov 7, %g1
|| bd->state == RTEMS_BDBUF_STATE_ACCESS_EMPTY)
bd->hold_timer = bdbuf_config.swap_block_hold;
200d34c: 03 00 80 7b sethi %hi(0x201ec00), %g1
200d350: c2 00 61 60 ld [ %g1 + 0x160 ], %g1 ! 201ed60 <rtems_bdbuf_configuration+0x10>
200d354: 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;
200d358: 82 10 20 07 mov 7, %g1
200d35c: 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;
200d360: 03 00 80 86 sethi %hi(0x2021800), %g1
200d364: 82 10 60 8c or %g1, 0x8c, %g1 ! 202188c <bdbuf_cache>
200d368: c4 00 60 54 ld [ %g1 + 0x54 ], %g2
the_node->next = tail;
200d36c: 86 00 60 50 add %g1, 0x50, %g3
tail->previous = the_node;
200d370: 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;
200d374: c6 26 00 00 st %g3, [ %i0 ]
tail->previous = the_node;
old_last->next = the_node;
200d378: f0 20 80 00 st %i0, [ %g2 ]
the_node->previous = old_last;
200d37c: 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)
200d380: c4 06 20 24 ld [ %i0 + 0x24 ], %g2
200d384: 80 a0 a0 00 cmp %g2, 0
200d388: 22 80 00 04 be,a 200d398 <rtems_bdbuf_add_to_modified_list_after_access+0xc0>
200d38c: c2 00 60 74 ld [ %g1 + 0x74 ], %g1
rtems_bdbuf_wake (&bdbuf_cache.access_waiters);
200d390: 7f ff fe ca call 200ceb8 <rtems_bdbuf_wake>
200d394: 91 e8 60 64 restore %g1, 0x64, %o0
else if (rtems_bdbuf_has_buffer_waiters ())
200d398: 80 a0 60 00 cmp %g1, 0
200d39c: 02 80 00 04 be 200d3ac <rtems_bdbuf_add_to_modified_list_after_access+0xd4>
200d3a0: 01 00 00 00 nop
rtems_bdbuf_wake_swapper ();
200d3a4: 7f ff fe 2b call 200cc50 <rtems_bdbuf_wake_swapper>
200d3a8: 81 e8 00 00 restore
200d3ac: 81 c7 e0 08 ret
200d3b0: 81 e8 00 00 restore
0200cd50 <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)
{
200cd50: 9d e3 bf a0 save %sp, -96, %sp
rtems_mode prev_mode;
/*
* Indicate we are waiting.
*/
++waiters->count;
200cd54: c2 06 00 00 ld [ %i0 ], %g1
200cd58: 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 ();
200cd5c: 7f ff ff e1 call 200cce0 <rtems_bdbuf_disable_preemption>
200cd60: c2 26 00 00 st %g1, [ %i0 ]
/*
* Unlock the cache, wait, and lock the cache when we return.
*/
rtems_bdbuf_unlock_cache ();
200cd64: 7f ff ff b4 call 200cc34 <rtems_bdbuf_unlock_cache>
200cd68: ba 10 00 08 mov %o0, %i5
sc = rtems_semaphore_obtain (waiters->sema, RTEMS_WAIT, RTEMS_BDBUF_WAIT_TIMEOUT);
200cd6c: d0 06 20 04 ld [ %i0 + 4 ], %o0
200cd70: 92 10 20 00 clr %o1
200cd74: 7f ff ef e5 call 2008d08 <rtems_semaphore_obtain>
200cd78: 94 10 20 00 clr %o2
if (sc == RTEMS_TIMEOUT)
200cd7c: 80 a2 20 06 cmp %o0, 6
200cd80: 12 80 00 05 bne 200cd94 <rtems_bdbuf_anonymous_wait+0x44> <== ALWAYS TAKEN
200cd84: 80 a2 20 0d cmp %o0, 0xd
rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_CACHE_WAIT_TO);
200cd88: 11 10 80 00 sethi %hi(0x42000000), %o0 <== NOT EXECUTED
200cd8c: 10 80 00 05 b 200cda0 <rtems_bdbuf_anonymous_wait+0x50> <== NOT EXECUTED
200cd90: 90 12 20 12 or %o0, 0x12, %o0 ! 42000012 <RAM_END+0x3fc00012><== NOT EXECUTED
if (sc != RTEMS_UNSATISFIED)
200cd94: 02 80 00 05 be 200cda8 <rtems_bdbuf_anonymous_wait+0x58> <== ALWAYS TAKEN
200cd98: 11 10 80 00 sethi %hi(0x42000000), %o0
rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_CACHE_WAIT_2);
200cd9c: 90 12 20 10 or %o0, 0x10, %o0 ! 42000010 <RAM_END+0x3fc00010><== NOT EXECUTED
200cda0: 7f ff f1 87 call 20093bc <rtems_fatal_error_occurred> <== NOT EXECUTED
200cda4: 01 00 00 00 nop <== NOT EXECUTED
rtems_bdbuf_lock_cache ();
200cda8: 7f ff ff 8d call 200cbdc <rtems_bdbuf_lock_cache>
200cdac: 01 00 00 00 nop
rtems_bdbuf_restore_preemption (prev_mode);
200cdb0: 7f ff ff da call 200cd18 <rtems_bdbuf_restore_preemption>
200cdb4: 90 10 00 1d mov %i5, %o0
--waiters->count;
200cdb8: c2 06 00 00 ld [ %i0 ], %g1
200cdbc: 82 00 7f ff add %g1, -1, %g1
200cdc0: c2 26 00 00 st %g1, [ %i0 ]
200cdc4: 81 c7 e0 08 ret
200cdc8: 81 e8 00 00 restore
0200cef0 <rtems_bdbuf_create_task.constprop.10>:
return NULL;
}
static rtems_status_code
rtems_bdbuf_create_task(
200cef0: 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 ?
200cef4: 03 00 80 7b sethi %hi(0x201ec00), %g1
200cef8: d4 00 61 6c ld [ %g1 + 0x16c ], %o2 ! 201ed6c <rtems_bdbuf_configuration+0x1c>
bdbuf_config.task_stack_size : RTEMS_BDBUF_TASK_STACK_SIZE_DEFAULT;
200cefc: 80 a2 a0 00 cmp %o2, 0
200cf00: 12 80 00 03 bne 200cf0c <rtems_bdbuf_create_task.constprop.10+0x1c><== ALWAYS TAKEN
200cf04: 92 10 00 19 mov %i1, %o1
200cf08: 15 00 00 04 sethi %hi(0x1000), %o2 <== NOT EXECUTED
priority = priority != 0 ? priority : default_priority;
200cf0c: 80 a2 60 00 cmp %o1, 0
200cf10: 22 80 00 02 be,a 200cf18 <rtems_bdbuf_create_task.constprop.10+0x28><== NEVER TAKEN
200cf14: 92 10 20 0f mov 0xf, %o1 <== NOT EXECUTED
sc = rtems_task_create (name,
200cf18: 90 10 00 18 mov %i0, %o0
200cf1c: 96 10 24 00 mov 0x400, %o3
200cf20: 98 10 20 00 clr %o4
200cf24: 7f ff ef f0 call 2008ee4 <rtems_task_create>
200cf28: 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)
200cf2c: b0 92 20 00 orcc %o0, 0, %i0
200cf30: 12 80 00 05 bne 200cf44 <rtems_bdbuf_create_task.constprop.10+0x54><== NEVER TAKEN
200cf34: b2 10 00 1a mov %i2, %i1
sc = rtems_task_start (*id, entry, arg);
200cf38: f0 07 00 00 ld [ %i4 ], %i0
200cf3c: 7f ff f0 77 call 2009118 <rtems_task_start>
200cf40: 95 e8 00 1b restore %g0, %i3, %o2
return sc;
}
200cf44: 81 c7 e0 08 ret <== NOT EXECUTED
200cf48: 81 e8 00 00 restore <== NOT EXECUTED
0200cce0 <rtems_bdbuf_disable_preemption>:
--bd->group->users;
}
static rtems_mode
rtems_bdbuf_disable_preemption (void)
{
200cce0: 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);
200cce4: 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;
200cce8: c0 27 bf fc clr [ %fp + -4 ]
sc = rtems_task_mode (RTEMS_NO_PREEMPT, RTEMS_PREEMPT_MASK, &prev_mode);
200ccec: 92 10 21 00 mov 0x100, %o1
200ccf0: 40 00 11 3d call 20111e4 <rtems_task_mode>
200ccf4: 94 07 bf fc add %fp, -4, %o2
if (sc != RTEMS_SUCCESSFUL)
200ccf8: 80 a2 20 00 cmp %o0, 0
200ccfc: 22 80 00 05 be,a 200cd10 <rtems_bdbuf_disable_preemption+0x30><== ALWAYS TAKEN
200cd00: f0 07 bf fc ld [ %fp + -4 ], %i0
rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_PREEMPT_DIS);
200cd04: 11 10 80 00 sethi %hi(0x42000000), %o0 <== NOT EXECUTED
200cd08: 7f ff f1 ad call 20093bc <rtems_fatal_error_occurred> <== NOT EXECUTED
200cd0c: 90 12 20 0f or %o0, 0xf, %o0 ! 4200000f <RAM_END+0x3fc0000f><== NOT EXECUTED
return prev_mode;
}
200cd10: 81 c7 e0 08 ret
200cd14: 81 e8 00 00 restore
0200e21c <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)
{
200e21c: 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) +
200e220: 83 2e a0 04 sll %i2, 4, %g1
200e224: 82 00 60 20 add %g1, 0x20, %g1
200e228: 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;
200e22c: 03 00 80 33 sethi %hi(0x200cc00), %g1
200e230: 82 10 60 80 or %g1, 0x80, %g1 ! 200cc80 <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) +
200e234: 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;
200e238: 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;
200e23c: 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;
200e240: 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;
200e244: 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;
200e248: c0 27 40 00 clr [ %i5 ]
req->req_done = rtems_bdbuf_transfer_done;
req->done_arg = req;
req->io_task = rtems_task_self ();
200e24c: 40 00 0c 44 call 201135c <rtems_task_self>
200e250: fa 27 60 08 st %i5, [ %i5 + 8 ]
req->status = RTEMS_RESOURCE_IN_USE;
200e254: 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 ();
200e258: d0 27 60 14 st %o0, [ %i5 + 0x14 ]
req->status = RTEMS_RESOURCE_IN_USE;
200e25c: c2 27 60 0c st %g1, [ %i5 + 0xc ]
req->bufnum = 0;
200e260: 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;
200e264: 82 10 20 09 mov 9, %g1
200e268: 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;
200e26c: 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;
200e270: 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;
200e274: f6 27 60 18 st %i3, [ %i5 + 0x18 ]
req->bufs [0].length = block_size;
200e278: e0 27 60 1c st %l0, [ %i5 + 0x1c ]
req->bufs [0].buffer = bd->buffer;
200e27c: c2 27 60 20 st %g1, [ %i5 + 0x20 ]
200e280: 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;
200e284: 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)
200e288: 10 80 00 16 b 200e2e0 <rtems_bdbuf_execute_read_request+0xc4>
200e28c: a4 10 20 09 mov 9, %l2
{
media_block += media_blocks_per_block;
bd = rtems_bdbuf_get_buffer_for_read_ahead (dd, media_block);
200e290: 90 10 00 18 mov %i0, %o0
200e294: 92 10 00 1b mov %i3, %o1
200e298: 7f ff fd 43 call 200d7a4 <rtems_bdbuf_get_buffer_for_read_ahead>
200e29c: b8 07 20 10 add %i4, 0x10, %i4
if (bd == NULL)
200e2a0: 80 a2 20 00 cmp %o0, 0
200e2a4: 32 80 00 09 bne,a 200e2c8 <rtems_bdbuf_execute_read_request+0xac><== ALWAYS TAKEN
200e2a8: e4 22 20 20 st %l2, [ %o0 + 0x20 ]
rtems_bdbuf_show_users ("read", bd);
++transfer_index;
}
req->bufnum = transfer_index;
200e2ac: f2 27 60 10 st %i1, [ %i5 + 0x10 ] <== NOT EXECUTED
return rtems_bdbuf_execute_transfer_request (dd, req, true);
200e2b0: 90 10 00 18 mov %i0, %o0
200e2b4: 92 10 00 1d mov %i5, %o1
200e2b8: 7f ff fe 20 call 200db38 <rtems_bdbuf_execute_transfer_request>
200e2bc: 94 10 20 01 mov 1, %o2
200e2c0: 81 c7 e0 08 ret
200e2c4: 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;
200e2c8: d0 27 20 24 st %o0, [ %i4 + 0x24 ]
req->bufs [transfer_index].block = media_block;
200e2cc: f6 27 20 18 st %i3, [ %i4 + 0x18 ]
req->bufs [transfer_index].length = block_size;
200e2d0: e0 27 20 1c st %l0, [ %i4 + 0x1c ]
req->bufs [transfer_index].buffer = bd->buffer;
200e2d4: c2 02 20 1c ld [ %o0 + 0x1c ], %g1
if (rtems_bdbuf_tracer)
rtems_bdbuf_show_users ("read", bd);
++transfer_index;
200e2d8: 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;
200e2dc: 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)
200e2e0: 80 a6 40 1a cmp %i1, %i2
200e2e4: 2a bf ff eb bcs,a 200e290 <rtems_bdbuf_execute_read_request+0x74>
200e2e8: b6 06 c0 11 add %i3, %l1, %i3
rtems_bdbuf_show_users ("read", bd);
++transfer_index;
}
req->bufnum = transfer_index;
200e2ec: 10 bf ff f1 b 200e2b0 <rtems_bdbuf_execute_read_request+0x94>
200e2f0: f2 27 60 10 st %i1, [ %i5 + 0x10 ]
0200cbf8 <rtems_bdbuf_fatal>:
#define RTEMS_BDBUF_AVL_MAX_HEIGHT (32)
#endif
static void
rtems_bdbuf_fatal (rtems_bdbuf_buf_state state, uint32_t error)
{
200cbf8: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED
rtems_fatal_error_occurred ((((uint32_t) state) << 16) | error);
200cbfc: b1 2e 20 10 sll %i0, 0x10, %i0 <== NOT EXECUTED
200cc00: 7f ff f1 ef call 20093bc <rtems_fatal_error_occurred> <== NOT EXECUTED
200cc04: 90 16 40 18 or %i1, %i0, %o0 <== NOT EXECUTED
0200e90c <rtems_bdbuf_get>:
rtems_status_code
rtems_bdbuf_get (rtems_disk_device *dd,
rtems_blkdev_bnum block,
rtems_bdbuf_buffer **bd_ptr)
{
200e90c: 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 ();
200e910: 7f ff f8 b3 call 200cbdc <rtems_bdbuf_lock_cache>
200e914: 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)
200e918: 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;
200e91c: 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)
200e920: 80 a6 40 01 cmp %i1, %g1
200e924: 1a 80 00 26 bcc 200e9bc <rtems_bdbuf_get+0xb0> <== NEVER TAKEN
200e928: 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)
200e92c: d2 07 60 30 ld [ %i5 + 0x30 ], %o1
200e930: 80 a2 60 00 cmp %o1, 0
200e934: 26 80 00 04 bl,a 200e944 <rtems_bdbuf_get+0x38> <== NEVER TAKEN
200e938: d6 07 60 24 ld [ %i5 + 0x24 ], %o3 <== NOT EXECUTED
return block << dd->block_to_media_block_shift;
200e93c: 10 80 00 09 b 200e960 <rtems_bdbuf_get+0x54>
200e940: 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);
200e944: 94 10 20 00 clr %o2 <== NOT EXECUTED
200e948: 90 10 20 00 clr %o0 <== NOT EXECUTED
200e94c: 40 00 39 52 call 201ce94 <__muldi3> <== NOT EXECUTED
200e950: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
200e954: d6 07 60 20 ld [ %i5 + 0x20 ], %o3 <== NOT EXECUTED
200e958: 40 00 3b 60 call 201d6d8 <__udivdi3> <== NOT EXECUTED
200e95c: 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;
200e960: 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);
200e964: 90 10 00 1d mov %i5, %o0
200e968: 7f ff fb a2 call 200d7f0 <rtems_bdbuf_get_buffer_for_access>
200e96c: 92 02 40 01 add %o1, %g1, %o1
200e970: b8 10 00 08 mov %o0, %i4
switch (bd->state)
200e974: d0 02 20 20 ld [ %o0 + 0x20 ], %o0
200e978: 80 a2 20 02 cmp %o0, 2
200e97c: 02 80 00 08 be 200e99c <rtems_bdbuf_get+0x90>
200e980: 80 a2 20 07 cmp %o0, 7
200e984: 02 80 00 0a be 200e9ac <rtems_bdbuf_get+0xa0>
200e988: 80 a2 20 01 cmp %o0, 1
200e98c: 12 80 00 0a bne 200e9b4 <rtems_bdbuf_get+0xa8> <== NEVER TAKEN
200e990: 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;
200e994: 10 80 00 03 b 200e9a0 <rtems_bdbuf_get+0x94>
200e998: 82 10 20 05 mov 5, %g1
200e99c: 82 10 20 03 mov 3, %g1
200e9a0: c2 27 20 20 st %g1, [ %i4 + 0x20 ]
200e9a4: 10 80 00 06 b 200e9bc <rtems_bdbuf_get+0xb0>
200e9a8: b0 10 20 00 clr %i0
200e9ac: 10 bf ff fd b 200e9a0 <rtems_bdbuf_get+0x94>
200e9b0: 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);
200e9b4: 7f ff f8 91 call 200cbf8 <rtems_bdbuf_fatal> <== NOT EXECUTED
200e9b8: 92 12 60 1e or %o1, 0x1e, %o1 <== NOT EXECUTED
rtems_bdbuf_show_users ("get", bd);
rtems_bdbuf_show_usage ();
}
}
rtems_bdbuf_unlock_cache ();
200e9bc: 7f ff f8 9e call 200cc34 <rtems_bdbuf_unlock_cache>
200e9c0: 01 00 00 00 nop
*bd_ptr = bd;
200e9c4: f8 26 80 00 st %i4, [ %i2 ]
return sc;
}
200e9c8: 81 c7 e0 08 ret
200e9cc: 81 e8 00 00 restore
0200d7f0 <rtems_bdbuf_get_buffer_for_access>:
static rtems_bdbuf_buffer *
rtems_bdbuf_get_buffer_for_access (rtems_disk_device *dd,
rtems_blkdev_bnum block)
{
200d7f0: 9d e3 bf a0 save %sp, -96, %sp
rtems_bdbuf_buffer *bd = NULL;
do
{
bd = rtems_bdbuf_avl_search (&bdbuf_cache.tree, dd, block);
200d7f4: 39 00 80 86 sethi %hi(0x2021800), %i4
static bool
rtems_bdbuf_wait_for_recycle (rtems_bdbuf_buffer *bd)
{
while (true)
{
switch (bd->state)
200d7f8: 35 00 80 32 sethi %hi(0x200c800), %i2
{
rtems_bdbuf_buffer *bd = NULL;
do
{
bd = rtems_bdbuf_avl_search (&bdbuf_cache.tree, dd, block);
200d7fc: b8 17 20 8c or %i4, 0x8c, %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);
200d800: 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);
200d804: 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;
200d808: 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);
200d80c: b6 07 20 74 add %i4, 0x74, %i3
}
static void
rtems_bdbuf_wait_for_buffer (void)
{
if (!rtems_chain_is_empty (&bdbuf_cache.modified))
200d810: a6 07 20 50 add %i4, 0x50, %l3
{
rtems_bdbuf_buffer *bd = NULL;
do
{
bd = rtems_bdbuf_avl_search (&bdbuf_cache.tree, dd, block);
200d814: d0 07 20 3c ld [ %i4 + 0x3c ], %o0
200d818: 92 10 00 18 mov %i0, %o1
200d81c: 7f ff fd 8e call 200ce54 <rtems_bdbuf_avl_search.isra.0>
200d820: 94 10 00 19 mov %i1, %o2
if (bd != NULL)
200d824: ba 92 20 00 orcc %o0, 0, %i5
200d828: 02 80 00 31 be 200d8ec <rtems_bdbuf_get_buffer_for_access+0xfc>
200d82c: 90 10 00 18 mov %i0, %o0
{
if (bd->group->bds_per_group != dd->bds_per_group)
200d830: c2 07 60 28 ld [ %i5 + 0x28 ], %g1
200d834: c4 00 60 08 ld [ %g1 + 8 ], %g2
200d838: c2 06 20 34 ld [ %i0 + 0x34 ], %g1
200d83c: 80 a0 80 01 cmp %g2, %g1
200d840: 02 80 00 37 be 200d91c <rtems_bdbuf_get_buffer_for_access+0x12c>
200d844: a8 10 20 08 mov 8, %l4
static bool
rtems_bdbuf_wait_for_recycle (rtems_bdbuf_buffer *bd)
{
while (true)
{
switch (bd->state)
200d848: d0 07 60 20 ld [ %i5 + 0x20 ], %o0
200d84c: 80 a2 20 0a cmp %o0, 0xa
200d850: 18 80 00 25 bgu 200d8e4 <rtems_bdbuf_get_buffer_for_access+0xf4><== NEVER TAKEN
200d854: 13 10 80 00 sethi %hi(0x42000000), %o1
200d858: 82 16 a3 04 or %i2, 0x304, %g1
200d85c: 91 2a 20 02 sll %o0, 2, %o0
200d860: c2 00 40 08 ld [ %g1 + %o0 ], %g1
200d864: 81 c0 40 00 jmp %g1
200d868: 01 00 00 00 nop
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
previous = the_node->previous;
200d86c: c2 07 60 04 ld [ %i5 + 4 ], %g1 <== NOT EXECUTED
)
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
200d870: 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;
200d874: e8 27 60 20 st %l4, [ %i5 + 0x20 ] <== NOT EXECUTED
previous = the_node->previous;
next->previous = previous;
200d878: c2 20 a0 04 st %g1, [ %g2 + 4 ] <== NOT EXECUTED
previous->next = next;
200d87c: 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;
200d880: c2 07 20 60 ld [ %i4 + 0x60 ], %g1 <== NOT EXECUTED
the_node->next = tail;
200d884: e4 27 40 00 st %l2, [ %i5 ] <== NOT EXECUTED
tail->previous = the_node;
200d888: fa 27 20 60 st %i5, [ %i4 + 0x60 ] <== NOT EXECUTED
old_last->next = the_node;
200d88c: 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 ();
200d890: 7f ff fc f0 call 200cc50 <rtems_bdbuf_wake_swapper> <== NOT EXECUTED
200d894: 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)
200d898: 10 bf ff ed b 200d84c <rtems_bdbuf_get_buffer_for_access+0x5c><== NOT EXECUTED
200d89c: 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)
200d8a0: c2 07 60 24 ld [ %i5 + 0x24 ], %g1
200d8a4: 80 a0 60 00 cmp %g1, 0
200d8a8: 02 80 00 3e be 200d9a0 <rtems_bdbuf_get_buffer_for_access+0x1b0><== NEVER TAKEN
200d8ac: 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);
200d8b0: 7f ff fd 28 call 200cd50 <rtems_bdbuf_anonymous_wait>
200d8b4: 90 10 00 1b mov %i3, %o0
{
rtems_bdbuf_buffer *bd = NULL;
do
{
bd = rtems_bdbuf_avl_search (&bdbuf_cache.tree, dd, block);
200d8b8: 10 bf ff d8 b 200d818 <rtems_bdbuf_get_buffer_for_access+0x28>
200d8bc: 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);
200d8c0: 90 10 00 1d mov %i5, %o0
200d8c4: 10 80 00 04 b 200d8d4 <rtems_bdbuf_get_buffer_for_access+0xe4>
200d8c8: 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);
200d8cc: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
200d8d0: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED
200d8d4: 7f ff fd 3e call 200cdcc <rtems_bdbuf_wait>
200d8d8: 01 00 00 00 nop
static bool
rtems_bdbuf_wait_for_recycle (rtems_bdbuf_buffer *bd)
{
while (true)
{
switch (bd->state)
200d8dc: 10 bf ff dc b 200d84c <rtems_bdbuf_get_buffer_for_access+0x5c>
200d8e0: 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);
200d8e4: 10 80 00 2d b 200d998 <rtems_bdbuf_get_buffer_for_access+0x1a8><== NOT EXECUTED
200d8e8: 92 12 60 06 or %o1, 6, %o1 <== NOT EXECUTED
bd = NULL;
}
}
else
{
bd = rtems_bdbuf_get_buffer_from_lru_list (dd, block);
200d8ec: 7f ff fe c5 call 200d400 <rtems_bdbuf_get_buffer_from_lru_list>
200d8f0: 92 10 00 19 mov %i1, %o1
if (bd == NULL)
200d8f4: ba 92 20 00 orcc %o0, 0, %i5
200d8f8: 32 80 00 0a bne,a 200d920 <rtems_bdbuf_get_buffer_for_access+0x130>
200d8fc: 39 00 80 86 sethi %hi(0x2021800), %i4
}
static void
rtems_bdbuf_wait_for_buffer (void)
{
if (!rtems_chain_is_empty (&bdbuf_cache.modified))
200d900: c2 07 20 4c ld [ %i4 + 0x4c ], %g1 ! 202184c <rtems_termios_linesw+0xc8>
200d904: 80 a0 40 13 cmp %g1, %l3
200d908: 02 bf ff ea be 200d8b0 <rtems_bdbuf_get_buffer_for_access+0xc0>
200d90c: 01 00 00 00 nop
rtems_bdbuf_wake_swapper ();
200d910: 7f ff fc d0 call 200cc50 <rtems_bdbuf_wake_swapper>
200d914: 01 00 00 00 nop
200d918: 30 bf ff e6 b,a 200d8b0 <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);
200d91c: 39 00 80 86 sethi %hi(0x2021800), %i4
static void
rtems_bdbuf_wait_for_access (rtems_bdbuf_buffer *bd)
{
while (true)
{
switch (bd->state)
200d920: 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);
200d924: b8 17 20 f8 or %i4, 0xf8, %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);
200d928: b4 07 3f f8 add %i4, -8, %i2
static void
rtems_bdbuf_wait_for_access (rtems_bdbuf_buffer *bd)
{
while (true)
{
switch (bd->state)
200d92c: d0 07 60 20 ld [ %i5 + 0x20 ], %o0
200d930: 82 02 3f ff add %o0, -1, %g1
200d934: 80 a0 60 09 cmp %g1, 9
200d938: 18 80 00 17 bgu 200d994 <rtems_bdbuf_get_buffer_for_access+0x1a4><== NEVER TAKEN
200d93c: 13 10 80 00 sethi %hi(0x42000000), %o1
200d940: 84 16 e2 dc or %i3, 0x2dc, %g2
200d944: 83 28 60 02 sll %g1, 2, %g1
200d948: c2 00 80 01 ld [ %g2 + %g1 ], %g1
200d94c: 81 c0 40 00 jmp %g1
200d950: 01 00 00 00 nop
{
case RTEMS_BDBUF_STATE_MODIFIED:
rtems_bdbuf_group_release (bd);
200d954: 7f ff fc 91 call 200cb98 <rtems_bdbuf_group_release>
200d958: 90 10 00 1d mov %i5, %o0
)
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
200d95c: c4 07 40 00 ld [ %i5 ], %g2
previous = the_node->previous;
200d960: c2 07 60 04 ld [ %i5 + 4 ], %g1
next->previous = previous;
200d964: c2 20 a0 04 st %g1, [ %g2 + 4 ]
previous->next = next;
200d968: 10 80 00 16 b 200d9c0 <rtems_bdbuf_get_buffer_for_access+0x1d0>
200d96c: 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);
200d970: 90 10 00 1d mov %i5, %o0
200d974: 10 80 00 04 b 200d984 <rtems_bdbuf_get_buffer_for_access+0x194>
200d978: 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);
200d97c: 90 10 00 1d mov %i5, %o0
200d980: 92 10 00 1c mov %i4, %o1
200d984: 7f ff fd 12 call 200cdcc <rtems_bdbuf_wait>
200d988: 01 00 00 00 nop
static void
rtems_bdbuf_wait_for_access (rtems_bdbuf_buffer *bd)
{
while (true)
{
switch (bd->state)
200d98c: 10 bf ff e9 b 200d930 <rtems_bdbuf_get_buffer_for_access+0x140>
200d990: 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);
200d994: 92 12 60 05 or %o1, 5, %o1 <== NOT EXECUTED
200d998: 7f ff fc 98 call 200cbf8 <rtems_bdbuf_fatal> <== NOT EXECUTED
200d99c: 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);
200d9a0: 7f ff fe 85 call 200d3b4 <rtems_bdbuf_remove_from_tree_and_lru_list><== NOT EXECUTED
200d9a4: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
rtems_bdbuf_make_free_and_add_to_lru_list (bd);
200d9a8: 7f ff fe 43 call 200d2b4 <rtems_bdbuf_make_free_and_add_to_lru_list><== NOT EXECUTED
200d9ac: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
rtems_bdbuf_wake (&bdbuf_cache.buffer_waiters);
200d9b0: 7f ff fd 42 call 200ceb8 <rtems_bdbuf_wake> <== NOT EXECUTED
200d9b4: 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);
200d9b8: 10 bf ff 98 b 200d818 <rtems_bdbuf_get_buffer_for_access+0x28><== NOT EXECUTED
200d9bc: d0 07 20 3c ld [ %i4 + 0x3c ], %o0 <== NOT EXECUTED
}
}
while (bd == NULL);
rtems_bdbuf_wait_for_access (bd);
rtems_bdbuf_group_obtain (bd);
200d9c0: 90 10 00 1d mov %i5, %o0
200d9c4: 7f ff fc 70 call 200cb84 <rtems_bdbuf_group_obtain>
200d9c8: b0 10 00 1d mov %i5, %i0
return bd;
}
200d9cc: 81 c7 e0 08 ret
200d9d0: 81 e8 00 00 restore
0200d7a4 <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)
{
200d7a4: 9d e3 bf a0 save %sp, -96, %sp
rtems_bdbuf_buffer *bd = NULL;
bd = rtems_bdbuf_avl_search (&bdbuf_cache.tree, dd, block);
200d7a8: 03 00 80 86 sethi %hi(0x2021800), %g1
200d7ac: d0 00 60 c8 ld [ %g1 + 0xc8 ], %o0 ! 20218c8 <bdbuf_cache+0x3c>
200d7b0: 92 10 00 18 mov %i0, %o1
200d7b4: 94 10 00 19 mov %i1, %o2
200d7b8: 7f ff fd a7 call 200ce54 <rtems_bdbuf_avl_search.isra.0>
200d7bc: ba 10 20 00 clr %i5
if (bd == NULL)
200d7c0: 80 a2 20 00 cmp %o0, 0
200d7c4: 12 80 00 09 bne 200d7e8 <rtems_bdbuf_get_buffer_for_read_ahead+0x44><== NEVER TAKEN
200d7c8: 90 10 00 18 mov %i0, %o0
{
bd = rtems_bdbuf_get_buffer_from_lru_list (dd, block);
200d7cc: 7f ff ff 0d call 200d400 <rtems_bdbuf_get_buffer_from_lru_list>
200d7d0: 92 10 00 19 mov %i1, %o1
if (bd != NULL)
200d7d4: ba 92 20 00 orcc %o0, 0, %i5
200d7d8: 02 80 00 04 be 200d7e8 <rtems_bdbuf_get_buffer_for_read_ahead+0x44><== NEVER TAKEN
200d7dc: 01 00 00 00 nop
rtems_bdbuf_group_obtain (bd);
200d7e0: 7f ff fc e9 call 200cb84 <rtems_bdbuf_group_obtain>
200d7e4: 01 00 00 00 nop
* thus no need for a read ahead.
*/
bd = NULL;
return bd;
}
200d7e8: 81 c7 e0 08 ret
200d7ec: 91 e8 00 1d restore %g0, %i5, %o0
0200d400 <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)
{
200d400: 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;
200d404: 25 00 80 86 sethi %hi(0x2021800), %l2
200d408: 90 14 a0 8c or %l2, 0x8c, %o0 ! 202188c <bdbuf_cache>
200d40c: 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))
200d410: a2 02 20 44 add %o0, 0x44, %l1
200d414: 10 80 00 de b 200d78c <rtems_bdbuf_get_buffer_from_lru_list+0x38c>
200d418: 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)
200d41c: 80 a0 60 00 cmp %g1, 0
200d420: 32 80 00 db bne,a 200d78c <rtems_bdbuf_get_buffer_from_lru_list+0x38c>
200d424: f8 07 00 00 ld [ %i4 ], %i4
{
if (bd->group->bds_per_group == dd->bds_per_group)
200d428: fa 07 20 28 ld [ %i4 + 0x28 ], %i5
200d42c: f6 06 20 34 ld [ %i0 + 0x34 ], %i3
200d430: d2 07 60 08 ld [ %i5 + 8 ], %o1
200d434: 80 a2 40 1b cmp %o1, %i3
200d438: 32 80 00 06 bne,a 200d450 <rtems_bdbuf_get_buffer_from_lru_list+0x50>
200d43c: c2 07 60 0c ld [ %i5 + 0xc ], %g1
{
rtems_bdbuf_remove_from_tree_and_lru_list (bd);
200d440: 7f ff ff dd call 200d3b4 <rtems_bdbuf_remove_from_tree_and_lru_list>
200d444: 90 10 00 1c mov %i4, %o0
200d448: 10 80 00 30 b 200d508 <rtems_bdbuf_get_buffer_from_lru_list+0x108>
200d44c: 84 10 00 1c mov %i4, %g2
empty_bd = bd;
}
else if (bd->group->users == 0)
200d450: 80 a0 60 00 cmp %g1, 0
200d454: 32 80 00 ce bne,a 200d78c <rtems_bdbuf_get_buffer_from_lru_list+0x38c>
200d458: 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;
200d45c: d0 04 7f dc ld [ %l1 + -36 ], %o0
200d460: 40 00 3d 35 call 201c934 <.udiv>
200d464: f4 07 60 10 ld [ %i5 + 0x10 ], %i2
for (b = 0, bd = group->bdbuf;
200d468: a0 10 20 00 clr %l0
b < group->bds_per_group;
b++, bd += bufs_per_bd)
200d46c: 83 2a 20 03 sll %o0, 3, %g1
200d470: 91 2a 20 06 sll %o0, 6, %o0
200d474: 10 80 00 05 b 200d488 <rtems_bdbuf_get_buffer_from_lru_list+0x88>
200d478: a8 22 00 01 sub %o0, %g1, %l4
rtems_bdbuf_remove_from_tree_and_lru_list (bd);
200d47c: 7f ff ff ce call 200d3b4 <rtems_bdbuf_remove_from_tree_and_lru_list>
200d480: 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)
200d484: 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;
200d488: c2 07 60 08 ld [ %i5 + 8 ], %g1
200d48c: 80 a4 00 01 cmp %l0, %g1
200d490: 0a bf ff fb bcs 200d47c <rtems_bdbuf_get_buffer_from_lru_list+0x7c>
200d494: 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;
200d498: 82 14 a0 8c or %l2, 0x8c, %g1
200d49c: 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;
200d4a0: f6 27 60 08 st %i3, [ %i5 + 8 ]
bufs_per_bd = bdbuf_cache.max_bds_per_group / new_bds_per_group;
200d4a4: 40 00 3d 24 call 201c934 <.udiv>
200d4a8: 92 10 00 1b mov %i3, %o1
for (b = 1, bd = group->bdbuf + bufs_per_bd;
200d4ac: f4 07 60 10 ld [ %i5 + 0x10 ], %i2
200d4b0: 83 2a 20 03 sll %o0, 3, %g1
200d4b4: a1 2a 20 06 sll %o0, 6, %l0
200d4b8: b6 10 20 01 mov 1, %i3
200d4bc: a0 24 00 01 sub %l0, %g1, %l0
200d4c0: 10 80 00 05 b 200d4d4 <rtems_bdbuf_get_buffer_from_lru_list+0xd4>
200d4c4: 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);
200d4c8: 7f ff ff 7b call 200d2b4 <rtems_bdbuf_make_free_and_add_to_lru_list>
200d4cc: 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)
200d4d0: 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;
200d4d4: c2 07 60 08 ld [ %i5 + 8 ], %g1
200d4d8: 80 a6 c0 01 cmp %i3, %g1
200d4dc: 0a bf ff fb bcs 200d4c8 <rtems_bdbuf_get_buffer_from_lru_list+0xc8>
200d4e0: 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)
200d4e4: 80 a6 e0 01 cmp %i3, 1
200d4e8: 28 80 00 05 bleu,a 200d4fc <rtems_bdbuf_get_buffer_from_lru_list+0xfc>
200d4ec: c4 07 60 10 ld [ %i5 + 0x10 ], %g2
rtems_bdbuf_wake (&bdbuf_cache.buffer_waiters);
200d4f0: 7f ff fe 72 call 200ceb8 <rtems_bdbuf_wake>
200d4f4: 90 10 00 13 mov %l3, %o0
return group->bdbuf;
200d4f8: 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)
200d4fc: 80 a0 a0 00 cmp %g2, 0
200d500: 22 80 00 a3 be,a 200d78c <rtems_bdbuf_get_buffer_from_lru_list+0x38c><== NEVER TAKEN
200d504: 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 ;
200d508: f0 20 a0 14 st %i0, [ %g2 + 0x14 ]
bd->block = block;
bd->avl.left = NULL;
200d50c: c0 20 a0 08 clr [ %g2 + 8 ]
bd->avl.right = NULL;
200d510: 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;
200d514: 07 00 80 86 sethi %hi(0x2021800), %g3
200d518: 86 10 e0 8c or %g3, 0x8c, %g3 ! 202188c <bdbuf_cache>
200d51c: 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;
200d520: f2 20 a0 18 st %i1, [ %g2 + 0x18 ]
bd->avl.left = NULL;
bd->avl.right = NULL;
bd->waiters = 0;
200d524: 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;
200d528: ba 07 bf 80 add %fp, -128, %i5
break;
}
}
else if ((p->dd != dd) || (p->block != block))
{
p->avl.cache = -1;
200d52c: 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)
200d530: 80 a0 60 00 cmp %g1, 0
200d534: 12 80 00 1d bne 200d5a8 <rtems_bdbuf_get_buffer_from_lru_list+0x1a8>
200d538: b6 10 20 01 mov 1, %i3
{
*root = node;
200d53c: c4 20 e0 3c st %g2, [ %g3 + 0x3c ]
node->avl.left = NULL;
200d540: c0 20 a0 08 clr [ %g2 + 8 ]
node->avl.right = NULL;
200d544: c0 20 a0 0c clr [ %g2 + 0xc ]
node->avl.bal = 0;
200d548: 10 80 00 8e b 200d780 <rtems_bdbuf_get_buffer_from_lru_list+0x380>
200d54c: 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)))
200d550: 32 80 00 0f bne,a 200d58c <rtems_bdbuf_get_buffer_from_lru_list+0x18c><== NEVER TAKEN
200d554: c6 00 60 08 ld [ %g1 + 8 ], %g3 <== NOT EXECUTED
200d558: c6 00 60 18 ld [ %g1 + 0x18 ], %g3
200d55c: 80 a0 c0 19 cmp %g3, %i1
200d560: 1a 80 00 08 bcc 200d580 <rtems_bdbuf_get_buffer_from_lru_list+0x180>
200d564: 01 00 00 00 nop
{
p->avl.cache = 1;
q = p->avl.right;
200d568: c6 00 60 0c ld [ %g1 + 0xc ], %g3
if (q == NULL)
200d56c: 80 a0 e0 00 cmp %g3, 0
200d570: 12 80 00 0c bne 200d5a0 <rtems_bdbuf_get_buffer_from_lru_list+0x1a0>
200d574: f6 28 60 10 stb %i3, [ %g1 + 0x10 ]
{
q = node;
p->avl.right = q = node;
200d578: 10 80 00 12 b 200d5c0 <rtems_bdbuf_get_buffer_from_lru_list+0x1c0>
200d57c: c4 20 60 0c st %g2, [ %g1 + 0xc ]
break;
}
}
else if ((p->dd != dd) || (p->block != block))
200d580: 02 80 00 7e be 200d778 <rtems_bdbuf_get_buffer_from_lru_list+0x378><== NEVER TAKEN
200d584: 11 10 80 00 sethi %hi(0x42000000), %o0
{
p->avl.cache = -1;
q = p->avl.left;
200d588: c6 00 60 08 ld [ %g1 + 8 ], %g3
if (q == NULL)
200d58c: 80 a0 e0 00 cmp %g3, 0
200d590: 12 80 00 04 bne 200d5a0 <rtems_bdbuf_get_buffer_from_lru_list+0x1a0>
200d594: f8 28 60 10 stb %i4, [ %g1 + 0x10 ]
{
q = node;
p->avl.left = q;
200d598: 10 80 00 0a b 200d5c0 <rtems_bdbuf_get_buffer_from_lru_list+0x1c0>
200d59c: 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)
200d5a0: ba 10 00 04 mov %g4, %i5
200d5a4: 82 10 00 03 mov %g3, %g1
while (p != NULL)
{
*buf_prev++ = p;
if (((uintptr_t) p->dd < (uintptr_t) dd)
200d5a8: c6 00 60 14 ld [ %g1 + 0x14 ], %g3
return 0;
}
while (p != NULL)
{
*buf_prev++ = p;
200d5ac: c2 27 40 00 st %g1, [ %i5 ]
if (((uintptr_t) p->dd < (uintptr_t) dd)
200d5b0: 80 a0 c0 18 cmp %g3, %i0
200d5b4: 0a bf ff ed bcs 200d568 <rtems_bdbuf_get_buffer_from_lru_list+0x168><== NEVER TAKEN
200d5b8: 88 07 60 04 add %i5, 4, %g4
200d5bc: 30 bf ff e5 b,a 200d550 <rtems_bdbuf_get_buffer_from_lru_list+0x150>
}
p = q;
}
q->avl.left = q->avl.right = NULL;
200d5c0: c0 20 a0 0c clr [ %g2 + 0xc ]
200d5c4: c0 20 a0 08 clr [ %g2 + 8 ]
q->avl.bal = 0;
200d5c8: c0 28 a0 11 clrb [ %g2 + 0x11 ]
p->avl.bal = 0;
modified = false;
break;
case 0:
p->avl.bal = 1;
200d5cc: 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;
200d5d0: b4 10 3f ff mov -1, %i2
default:
break;
}
}
q = p;
if (buf_prev > buf_stack)
200d5d4: 10 80 00 03 b 200d5e0 <rtems_bdbuf_get_buffer_from_lru_list+0x1e0>
200d5d8: 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)
200d5dc: 82 10 00 04 mov %g4, %g1
{
if (p->avl.cache == -1)
200d5e0: c8 48 60 10 ldsb [ %g1 + 0x10 ], %g4
200d5e4: c6 08 60 11 ldub [ %g1 + 0x11 ], %g3
200d5e8: 80 a1 3f ff cmp %g4, -1
{
switch (p->avl.bal)
200d5ec: 87 28 e0 18 sll %g3, 0x18, %g3
modified = true;
buf_prev--;
while (modified)
{
if (p->avl.cache == -1)
200d5f0: 12 80 00 26 bne 200d688 <rtems_bdbuf_get_buffer_from_lru_list+0x288>
200d5f4: 87 38 e0 18 sra %g3, 0x18, %g3
{
switch (p->avl.bal)
200d5f8: 80 a0 e0 00 cmp %g3, 0
200d5fc: 22 80 00 4d be,a 200d730 <rtems_bdbuf_get_buffer_from_lru_list+0x330>
200d600: c8 28 60 11 stb %g4, [ %g1 + 0x11 ]
200d604: 80 a0 e0 01 cmp %g3, 1
200d608: 02 80 00 28 be 200d6a8 <rtems_bdbuf_get_buffer_from_lru_list+0x2a8>
200d60c: 80 a0 ff ff cmp %g3, -1
200d610: 32 80 00 49 bne,a 200d734 <rtems_bdbuf_get_buffer_from_lru_list+0x334><== NEVER TAKEN
200d614: 86 10 20 01 mov 1, %g3 <== NOT EXECUTED
case 0:
p->avl.bal = -1;
break;
case -1:
p1 = p->avl.left;
200d618: 10 80 00 02 b 200d620 <rtems_bdbuf_get_buffer_from_lru_list+0x220>
200d61c: c6 00 60 08 ld [ %g1 + 8 ], %g3
if (p1->avl.bal == -1) /* simple LL-turn */
200d620: c8 48 e0 11 ldsb [ %g3 + 0x11 ], %g4
200d624: 80 a1 3f ff cmp %g4, -1
200d628: 12 80 00 05 bne 200d63c <rtems_bdbuf_get_buffer_from_lru_list+0x23c>
200d62c: c8 00 e0 0c ld [ %g3 + 0xc ], %g4
{
p->avl.left = p1->avl.right;
200d630: c8 20 60 08 st %g4, [ %g1 + 8 ]
p1->avl.right = p;
200d634: 10 80 00 26 b 200d6cc <rtems_bdbuf_get_buffer_from_lru_list+0x2cc>
200d638: c2 20 e0 0c st %g1, [ %g3 + 0xc ]
p = p1;
}
else /* double LR-turn */
{
p2 = p1->avl.right;
p1->avl.right = p2->avl.left;
200d63c: f0 01 20 08 ld [ %g4 + 8 ], %i0
p2->avl.left = p1;
200d640: c6 21 20 08 st %g3, [ %g4 + 8 ]
p = p1;
}
else /* double LR-turn */
{
p2 = p1->avl.right;
p1->avl.right = p2->avl.left;
200d644: f0 20 e0 0c st %i0, [ %g3 + 0xc ]
p2->avl.left = p1;
p->avl.left = p2->avl.right;
200d648: f0 01 20 0c ld [ %g4 + 0xc ], %i0
p2->avl.right = p;
200d64c: 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;
200d650: 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;
200d654: f0 49 20 11 ldsb [ %g4 + 0x11 ], %i0
200d658: 80 a6 3f ff cmp %i0, -1
200d65c: 12 80 00 04 bne 200d66c <rtems_bdbuf_get_buffer_from_lru_list+0x26c><== ALWAYS TAKEN
200d660: b6 10 00 04 mov %g4, %i3
200d664: 10 80 00 03 b 200d670 <rtems_bdbuf_get_buffer_from_lru_list+0x270><== NOT EXECUTED
200d668: f8 28 60 11 stb %i4, [ %g1 + 0x11 ] <== NOT EXECUTED
200d66c: c0 28 60 11 clrb [ %g1 + 0x11 ]
if (p2->avl.bal == +1) p1->avl.bal = -1; else p1->avl.bal = 0;
200d670: c2 49 20 11 ldsb [ %g4 + 0x11 ], %g1
200d674: 80 a0 60 01 cmp %g1, 1
200d678: 32 80 00 2a bne,a 200d720 <rtems_bdbuf_get_buffer_from_lru_list+0x320>
200d67c: c0 28 e0 11 clrb [ %g3 + 0x11 ]
200d680: 10 80 00 28 b 200d720 <rtems_bdbuf_get_buffer_from_lru_list+0x320>
200d684: f4 28 e0 11 stb %i2, [ %g3 + 0x11 ]
break;
}
}
else
{
switch (p->avl.bal)
200d688: 80 a0 e0 00 cmp %g3, 0
200d68c: 22 80 00 29 be,a 200d730 <rtems_bdbuf_get_buffer_from_lru_list+0x330>
200d690: f8 28 60 11 stb %i4, [ %g1 + 0x11 ]
200d694: 80 a0 e0 01 cmp %g3, 1
200d698: 02 80 00 06 be 200d6b0 <rtems_bdbuf_get_buffer_from_lru_list+0x2b0>
200d69c: 80 a0 ff ff cmp %g3, -1
200d6a0: 32 80 00 25 bne,a 200d734 <rtems_bdbuf_get_buffer_from_lru_list+0x334><== NEVER TAKEN
200d6a4: 86 10 20 01 mov 1, %g3 <== NOT EXECUTED
{
case -1:
p->avl.bal = 0;
200d6a8: 10 80 00 20 b 200d728 <rtems_bdbuf_get_buffer_from_lru_list+0x328>
200d6ac: c0 28 60 11 clrb [ %g1 + 0x11 ]
case 0:
p->avl.bal = 1;
break;
case 1:
p1 = p->avl.right;
200d6b0: c6 00 60 0c ld [ %g1 + 0xc ], %g3
if (p1->avl.bal == 1) /* simple RR-turn */
200d6b4: c8 48 e0 11 ldsb [ %g3 + 0x11 ], %g4
200d6b8: 80 a1 20 01 cmp %g4, 1
200d6bc: 12 80 00 07 bne 200d6d8 <rtems_bdbuf_get_buffer_from_lru_list+0x2d8>
200d6c0: c8 00 e0 08 ld [ %g3 + 8 ], %g4
{
p->avl.right = p1->avl.left;
200d6c4: c8 20 60 0c st %g4, [ %g1 + 0xc ]
p1->avl.left = p;
200d6c8: c2 20 e0 08 st %g1, [ %g3 + 8 ]
p->avl.bal = 0;
200d6cc: c0 28 60 11 clrb [ %g1 + 0x11 ]
200d6d0: 10 80 00 14 b 200d720 <rtems_bdbuf_get_buffer_from_lru_list+0x320>
200d6d4: b6 10 00 03 mov %g3, %i3
p = p1;
}
else /* double RL-turn */
{
p2 = p1->avl.left;
p1->avl.left = p2->avl.right;
200d6d8: f0 01 20 0c ld [ %g4 + 0xc ], %i0
p2->avl.right = p1;
200d6dc: c6 21 20 0c st %g3, [ %g4 + 0xc ]
p = p1;
}
else /* double RL-turn */
{
p2 = p1->avl.left;
p1->avl.left = p2->avl.right;
200d6e0: f0 20 e0 08 st %i0, [ %g3 + 8 ]
p2->avl.right = p1;
p->avl.right = p2->avl.left;
200d6e4: f0 01 20 08 ld [ %g4 + 8 ], %i0
p2->avl.left = p;
200d6e8: 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;
200d6ec: 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;
200d6f0: f0 49 20 11 ldsb [ %g4 + 0x11 ], %i0
200d6f4: 80 a6 20 01 cmp %i0, 1
200d6f8: 12 80 00 04 bne 200d708 <rtems_bdbuf_get_buffer_from_lru_list+0x308><== ALWAYS TAKEN
200d6fc: b6 10 00 04 mov %g4, %i3
200d700: 10 80 00 03 b 200d70c <rtems_bdbuf_get_buffer_from_lru_list+0x30c><== NOT EXECUTED
200d704: f4 28 60 11 stb %i2, [ %g1 + 0x11 ] <== NOT EXECUTED
200d708: c0 28 60 11 clrb [ %g1 + 0x11 ]
if (p2->avl.bal == -1) p1->avl.bal = +1; else p1->avl.bal = 0;
200d70c: c2 49 20 11 ldsb [ %g4 + 0x11 ], %g1
200d710: 80 a0 7f ff cmp %g1, -1
200d714: 32 80 00 03 bne,a 200d720 <rtems_bdbuf_get_buffer_from_lru_list+0x320>
200d718: c0 28 e0 11 clrb [ %g3 + 0x11 ]
200d71c: f8 28 e0 11 stb %i4, [ %g3 + 0x11 ]
p = p2;
}
p->avl.bal = 0;
200d720: c0 2e e0 11 clrb [ %i3 + 0x11 ]
200d724: 82 10 00 1b mov %i3, %g1
modified = false;
200d728: 10 80 00 03 b 200d734 <rtems_bdbuf_get_buffer_from_lru_list+0x334>
200d72c: 86 10 20 00 clr %g3
break;
}
}
else
{
switch (p->avl.bal)
200d730: 86 10 20 01 mov 1, %g3
default:
break;
}
}
q = p;
if (buf_prev > buf_stack)
200d734: 80 a7 40 19 cmp %i5, %i1
200d738: 28 80 00 09 bleu,a 200d75c <rtems_bdbuf_get_buffer_from_lru_list+0x35c>
200d73c: 07 00 80 86 sethi %hi(0x2021800), %g3
{
p = *--buf_prev;
200d740: c8 07 7f fc ld [ %i5 + -4 ], %g4
if (p->avl.cache == -1)
200d744: f6 49 20 10 ldsb [ %g4 + 0x10 ], %i3
200d748: 80 a6 ff ff cmp %i3, -1
200d74c: 32 80 00 06 bne,a 200d764 <rtems_bdbuf_get_buffer_from_lru_list+0x364>
200d750: c2 21 20 0c st %g1, [ %g4 + 0xc ]
{
p->avl.left = q;
200d754: 10 80 00 04 b 200d764 <rtems_bdbuf_get_buffer_from_lru_list+0x364>
200d758: c2 21 20 08 st %g1, [ %g4 + 8 ]
p->avl.right = q;
}
}
else
{
*root = p;
200d75c: 10 80 00 09 b 200d780 <rtems_bdbuf_get_buffer_from_lru_list+0x380>
200d760: c2 20 e0 c8 st %g1, [ %g3 + 0xc8 ]
q->avl.left = q->avl.right = NULL;
q->avl.bal = 0;
modified = true;
buf_prev--;
while (modified)
200d764: 80 88 e0 ff btst 0xff, %g3
200d768: 12 bf ff 9d bne 200d5dc <rtems_bdbuf_get_buffer_from_lru_list+0x1dc>
200d76c: 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;
200d770: 10 80 00 05 b 200d784 <rtems_bdbuf_get_buffer_from_lru_list+0x384>
200d774: 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);
200d778: 7f ff ef 11 call 20093bc <rtems_fatal_error_occurred> <== NOT EXECUTED
200d77c: 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;
200d780: 82 10 20 01 mov 1, %g1
200d784: 10 80 00 06 b 200d79c <rtems_bdbuf_get_buffer_from_lru_list+0x39c>
200d788: 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))
200d78c: 80 a7 00 11 cmp %i4, %l1
200d790: 32 bf ff 23 bne,a 200d41c <rtems_bdbuf_get_buffer_from_lru_list+0x1c>
200d794: c2 07 20 24 ld [ %i4 + 0x24 ], %g1
}
node = rtems_chain_next (node);
}
return NULL;
200d798: 84 10 20 00 clr %g2
}
200d79c: 81 c7 e0 08 ret
200d7a0: 91 e8 00 02 restore %g0, %g2, %o0
0200e4c4 <rtems_bdbuf_init>:
*
* @return rtems_status_code The initialisation status.
*/
rtems_status_code
rtems_bdbuf_init (void)
{
200e4c4: 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())
200e4c8: 03 00 80 88 sethi %hi(0x2022000), %g1
200e4cc: c2 00 62 58 ld [ %g1 + 0x258 ], %g1 ! 2022258 <_Per_CPU_Information+0x8>
200e4d0: 80 a0 60 00 cmp %g1, 0
200e4d4: 12 80 00 16 bne 200e52c <rtems_bdbuf_init+0x68> <== NEVER TAKEN
200e4d8: 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)
200e4dc: 35 00 80 7b sethi %hi(0x201ec00), %i2
200e4e0: b4 16 a1 50 or %i2, 0x150, %i2 ! 201ed50 <rtems_bdbuf_configuration>
200e4e4: f2 06 a0 28 ld [ %i2 + 0x28 ], %i1
200e4e8: f8 06 a0 24 ld [ %i2 + 0x24 ], %i4
200e4ec: 90 10 00 19 mov %i1, %o0
200e4f0: 92 10 00 1c mov %i4, %o1
200e4f4: 40 00 39 bc call 201cbe4 <.urem>
200e4f8: b0 10 20 0a mov 0xa, %i0
200e4fc: 80 a2 20 00 cmp %o0, 0
200e500: 12 80 01 01 bne 200e904 <rtems_bdbuf_init+0x440> <== NEVER TAKEN
200e504: 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 ();
200e508: 7f ff f9 f6 call 200cce0 <rtems_bdbuf_disable_preemption>
200e50c: 3b 00 80 86 sethi %hi(0x2021800), %i5
if (bdbuf_cache.initialised)
200e510: ba 17 60 8c or %i5, 0x8c, %i5 ! 202188c <bdbuf_cache>
200e514: c2 0f 60 95 ldub [ %i5 + 0x95 ], %g1
200e518: 80 a0 60 00 cmp %g1, 0
200e51c: 02 80 00 06 be 200e534 <rtems_bdbuf_init+0x70> <== ALWAYS TAKEN
200e520: b6 10 00 08 mov %o0, %i3
{
rtems_bdbuf_restore_preemption (prev_mode);
200e524: 7f ff f9 fd call 200cd18 <rtems_bdbuf_restore_preemption> <== NOT EXECUTED
200e528: b0 10 20 0c mov 0xc, %i0 <== NOT EXECUTED
return RTEMS_RESOURCE_IN_USE;
200e52c: 81 c7 e0 08 ret <== NOT EXECUTED
200e530: 81 e8 00 00 restore <== NOT EXECUTED
}
memset(&bdbuf_cache, 0, sizeof(bdbuf_cache));
200e534: 92 10 20 00 clr %o1
200e538: 94 10 20 98 mov 0x98, %o2
200e53c: 40 00 18 1c call 20145ac <memset>
200e540: 90 10 00 1d mov %i5, %o0
bdbuf_cache.initialised = true;
200e544: 82 10 20 01 mov 1, %g1
rtems_bdbuf_restore_preemption (prev_mode);
200e548: 90 10 00 1b mov %i3, %o0
200e54c: 7f ff f9 f3 call 200cd18 <rtems_bdbuf_restore_preemption>
200e550: 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;
200e554: 82 07 60 0c add %i5, 0xc, %g1
200e558: c2 27 60 08 st %g1, [ %i5 + 8 ]
head->previous = NULL;
tail->previous = head;
200e55c: 82 07 60 08 add %i5, 8, %g1
200e560: 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;
200e564: 82 07 60 44 add %i5, 0x44, %g1
200e568: c2 27 60 40 st %g1, [ %i5 + 0x40 ]
head->previous = NULL;
tail->previous = head;
200e56c: 82 07 60 40 add %i5, 0x40, %g1
200e570: 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;
200e574: 82 07 60 50 add %i5, 0x50, %g1
200e578: c2 27 60 4c st %g1, [ %i5 + 0x4c ]
head->previous = NULL;
tail->previous = head;
200e57c: 82 07 60 4c add %i5, 0x4c, %g1
200e580: 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;
200e584: 82 07 60 5c add %i5, 0x5c, %g1
200e588: c2 27 60 58 st %g1, [ %i5 + 0x58 ]
head->previous = NULL;
tail->previous = head;
200e58c: 82 07 60 58 add %i5, 0x58, %g1
200e590: 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;
200e594: 82 07 60 8c add %i5, 0x8c, %g1
200e598: c2 27 60 88 st %g1, [ %i5 + 0x88 ]
head->previous = NULL;
tail->previous = head;
200e59c: 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;
200e5a0: 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;
200e5a4: c0 27 60 0c clr [ %i5 + 0xc ]
200e5a8: c0 27 60 44 clr [ %i5 + 0x44 ]
200e5ac: c0 27 60 50 clr [ %i5 + 0x50 ]
200e5b0: c0 27 60 5c clr [ %i5 + 0x5c ]
200e5b4: c0 27 60 8c clr [ %i5 + 0x8c ]
tail->previous = head;
200e5b8: 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'),
200e5bc: 37 10 91 10 sethi %hi(0x42444000), %i3
200e5c0: 92 10 20 01 mov 1, %o1
200e5c4: 90 16 e3 6c or %i3, 0x36c, %o0
200e5c8: 94 10 20 54 mov 0x54, %o2
200e5cc: 96 10 20 00 clr %o3
200e5d0: 7f ff e9 30 call 2008a90 <rtems_semaphore_create>
200e5d4: 98 07 60 28 add %i5, 0x28, %o4
1, RTEMS_BDBUF_CACHE_LOCK_ATTRIBS, 0,
&bdbuf_cache.lock);
if (sc != RTEMS_SUCCESSFUL)
200e5d8: 80 a2 20 00 cmp %o0, 0
200e5dc: 12 80 00 a3 bne 200e868 <rtems_bdbuf_init+0x3a4> <== NEVER TAKEN
200e5e0: 03 00 80 86 sethi %hi(0x2021800), %g1
goto error;
rtems_bdbuf_lock_cache ();
200e5e4: 7f ff f9 7e call 200cbdc <rtems_bdbuf_lock_cache>
200e5e8: 01 00 00 00 nop
sc = rtems_semaphore_create (rtems_build_name ('B', 'D', 'C', 's'),
200e5ec: 90 16 e3 73 or %i3, 0x373, %o0
200e5f0: 92 10 20 01 mov 1, %o1
200e5f4: 94 10 20 54 mov 0x54, %o2
200e5f8: 96 10 20 00 clr %o3
200e5fc: 7f ff e9 25 call 2008a90 <rtems_semaphore_create>
200e600: 98 07 60 2c add %i5, 0x2c, %o4
1, RTEMS_BDBUF_CACHE_LOCK_ATTRIBS, 0,
&bdbuf_cache.sync_lock);
if (sc != RTEMS_SUCCESSFUL)
200e604: 80 a2 20 00 cmp %o0, 0
200e608: 12 80 00 98 bne 200e868 <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', 'a'),
200e610: 90 16 e3 61 or %i3, 0x361, %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 1c call 2008a90 <rtems_semaphore_create>
200e624: 98 07 60 68 add %i5, 0x68, %o4
0, RTEMS_BDBUF_CACHE_WAITER_ATTRIBS, 0,
&bdbuf_cache.access_waiters.sema);
if (sc != RTEMS_SUCCESSFUL)
200e628: 80 a2 20 00 cmp %o0, 0
200e62c: 12 80 00 8f bne 200e868 <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', 't'),
200e634: 90 16 e3 74 or %i3, 0x374, %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 13 call 2008a90 <rtems_semaphore_create>
200e648: 98 07 60 70 add %i5, 0x70, %o4
0, RTEMS_BDBUF_CACHE_WAITER_ATTRIBS, 0,
&bdbuf_cache.transfer_waiters.sema);
if (sc != RTEMS_SUCCESSFUL)
200e64c: 80 a2 20 00 cmp %o0, 0
200e650: 12 80 00 86 bne 200e868 <rtems_bdbuf_init+0x3a4> <== NEVER TAKEN
200e654: 03 00 80 86 sethi %hi(0x2021800), %g1
goto error;
sc = rtems_semaphore_create (rtems_build_name ('B', 'D', 'C', 'b'),
200e658: 90 16 e3 62 or %i3, 0x362, %o0
200e65c: 92 10 20 00 clr %o1
200e660: 94 10 20 24 mov 0x24, %o2
200e664: 96 10 20 00 clr %o3
200e668: 7f ff e9 0a call 2008a90 <rtems_semaphore_create>
200e66c: 98 07 60 78 add %i5, 0x78, %o4
0, RTEMS_BDBUF_CACHE_WAITER_ATTRIBS, 0,
&bdbuf_cache.buffer_waiters.sema);
if (sc != RTEMS_SUCCESSFUL)
200e670: 80 a2 20 00 cmp %o0, 0
200e674: 12 80 00 7d bne 200e868 <rtems_bdbuf_init+0x3a4> <== NEVER TAKEN
200e678: 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;
200e67c: d0 06 a0 20 ld [ %i2 + 0x20 ], %o0
200e680: 40 00 38 ad call 201c934 <.udiv>
200e684: 92 10 00 1c mov %i4, %o1
bdbuf_cache.max_bds_per_group =
bdbuf_config.buffer_max / bdbuf_config.buffer_min;
200e688: 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;
200e68c: b6 10 00 08 mov %o0, %i3
goto error;
/*
* Compute the various number of elements in the cache.
*/
bdbuf_cache.buffer_min_count =
200e690: 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;
200e694: 40 00 38 a8 call 201c934 <.udiv>
200e698: 90 10 00 19 mov %i1, %o0
200e69c: 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 =
200e6a0: 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;
200e6a4: 40 00 38 a4 call 201c934 <.udiv>
200e6a8: 90 10 00 1b mov %i3, %o0
/*
* Allocate the memory for the buffer descriptors.
*/
bdbuf_cache.bds = calloc (sizeof (rtems_bdbuf_buffer),
200e6ac: 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 =
200e6b0: d0 27 60 7c st %o0, [ %i5 + 0x7c ]
bdbuf_cache.buffer_min_count / bdbuf_cache.max_bds_per_group;
200e6b4: b4 10 00 08 mov %o0, %i2
/*
* Allocate the memory for the buffer descriptors.
*/
bdbuf_cache.bds = calloc (sizeof (rtems_bdbuf_buffer),
200e6b8: 7f ff d8 0f call 20046f4 <calloc>
200e6bc: 90 10 20 38 mov 0x38, %o0
bdbuf_cache.buffer_min_count);
if (!bdbuf_cache.bds)
200e6c0: 80 a2 20 00 cmp %o0, 0
200e6c4: 02 80 00 68 be 200e864 <rtems_bdbuf_init+0x3a0> <== NEVER TAKEN
200e6c8: 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),
200e6cc: 90 10 20 14 mov 0x14, %o0
200e6d0: 7f ff d8 09 call 20046f4 <calloc>
200e6d4: 92 10 00 1a mov %i2, %o1
bdbuf_cache.group_count);
if (!bdbuf_cache.groups)
200e6d8: 80 a2 20 00 cmp %o0, 0
200e6dc: 02 80 00 62 be 200e864 <rtems_bdbuf_init+0x3a0> <== NEVER TAKEN
200e6e0: 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)
200e6e4: 92 10 00 1c mov %i4, %o1
200e6e8: 40 00 38 59 call 201c84c <.umul>
200e6ec: 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,
200e6f0: 92 10 20 20 mov 0x20, %o1
cache_aligment,
bdbuf_cache.buffer_min_count * bdbuf_config.buffer_min) != 0)
200e6f4: 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,
200e6f8: 11 00 80 86 sethi %hi(0x2021800), %o0
200e6fc: 40 00 07 50 call 201043c <rtems_memalign>
200e700: 90 12 20 a4 or %o0, 0xa4, %o0 ! 20218a4 <bdbuf_cache+0x18>
200e704: 80 a2 20 00 cmp %o0, 0
200e708: 12 80 00 58 bne 200e868 <rtems_bdbuf_init+0x3a4> <== NEVER TAKEN
200e70c: 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,
200e710: 03 00 80 86 sethi %hi(0x2021800), %g1
200e714: 82 10 60 8c or %g1, 0x8c, %g1 ! 202188c <bdbuf_cache>
200e718: f6 00 60 80 ld [ %g1 + 0x80 ], %i3
bd = bdbuf_cache.bds, buffer = bdbuf_cache.buffers;
200e71c: 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) ==
200e720: 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;
200e724: e0 00 60 18 ld [ %g1 + 0x18 ], %l0
b < bdbuf_cache.buffer_min_count;
200e728: 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))
200e72c: 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;
200e730: 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,
200e734: b0 10 00 1b mov %i3, %i0
200e738: 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;
200e73c: a2 10 00 01 mov %g1, %l1
200e740: 10 80 00 12 b 200e788 <rtems_bdbuf_init+0x2c4>
200e744: 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;
200e748: f0 27 60 28 st %i0, [ %i5 + 0x28 ]
bd->buffer = buffer;
200e74c: e0 27 60 1c st %l0, [ %i5 + 0x1c ]
200e750: c2 04 60 48 ld [ %l1 + 0x48 ], %g1
the_node->next = tail;
200e754: ea 27 40 00 st %l5, [ %i5 ]
tail->previous = the_node;
200e758: fa 24 60 48 st %i5, [ %l1 + 0x48 ]
old_last->next = the_node;
200e75c: fa 20 40 00 st %i5, [ %g1 ]
the_node->previous = old_last;
200e760: 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) ==
200e764: 90 10 00 19 mov %i1, %o0
200e768: 40 00 39 1f call 201cbe4 <.urem>
200e76c: 92 10 00 12 mov %l2, %o1
200e770: 80 a2 00 14 cmp %o0, %l4
200e774: 22 80 00 02 be,a 200e77c <rtems_bdbuf_init+0x2b8>
200e778: 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)
200e77c: b2 06 60 01 inc %i1
200e780: ba 07 60 38 add %i5, 0x38, %i5
200e784: 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,
200e788: 80 a6 40 13 cmp %i1, %l3
200e78c: 32 bf ff ef bne,a 200e748 <rtems_bdbuf_init+0x284>
200e790: c0 27 60 14 clr [ %i5 + 0x14 ]
}
for (b = 0,
group = bdbuf_cache.groups,
bd = bdbuf_cache.bds;
b < bdbuf_cache.group_count;
200e794: 03 00 80 86 sethi %hi(0x2021800), %g1
200e798: 82 10 60 8c or %g1, 0x8c, %g1 ! 202188c <bdbuf_cache>
b++,
group++,
bd += bdbuf_cache.max_bds_per_group)
{
group->bds_per_group = bdbuf_cache.max_bds_per_group;
200e79c: c4 00 60 20 ld [ %g1 + 0x20 ], %g2
}
for (b = 0,
group = bdbuf_cache.groups,
bd = bdbuf_cache.bds;
b < bdbuf_cache.group_count;
200e7a0: c6 00 60 7c ld [ %g1 + 0x7c ], %g3
b++,
group++,
bd += bdbuf_cache.max_bds_per_group)
200e7a4: 83 28 a0 03 sll %g2, 3, %g1
200e7a8: 89 28 a0 06 sll %g2, 6, %g4
200e7ac: 88 21 00 01 sub %g4, %g1, %g4
200e7b0: 10 80 00 06 b 200e7c8 <rtems_bdbuf_init+0x304>
200e7b4: 82 10 20 00 clr %g1
{
group->bds_per_group = bdbuf_cache.max_bds_per_group;
200e7b8: 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++,
200e7bc: 82 00 60 01 inc %g1
group++,
200e7c0: b6 06 e0 14 add %i3, 0x14, %i3
bd += bdbuf_cache.max_bds_per_group)
200e7c4: 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,
200e7c8: 80 a0 40 03 cmp %g1, %g3
200e7cc: 32 bf ff fb bne,a 200e7b8 <rtems_bdbuf_init+0x2f4>
200e7d0: 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'),
200e7d4: 35 00 80 7b sethi %hi(0x201ec00), %i2
200e7d8: b8 16 a1 50 or %i2, 0x150, %i4 ! 201ed50 <rtems_bdbuf_configuration>
200e7dc: 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;
200e7e0: 3b 00 80 86 sethi %hi(0x2021800), %i5
200e7e4: b6 10 20 01 mov 1, %i3
200e7e8: ba 17 60 8c or %i5, 0x8c, %i5
sc = rtems_bdbuf_create_task (rtems_build_name('B', 'S', 'W', 'P'),
200e7ec: 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;
200e7f0: f6 2f 60 04 stb %i3, [ %i5 + 4 ]
sc = rtems_bdbuf_create_task (rtems_build_name('B', 'S', 'W', 'P'),
200e7f4: 90 12 23 50 or %o0, 0x350, %o0
200e7f8: 15 00 80 37 sethi %hi(0x200dc00), %o2
200e7fc: 96 10 20 00 clr %o3
200e800: 94 12 a2 5c or %o2, 0x25c, %o2
200e804: 7f ff f9 bb call 200cef0 <rtems_bdbuf_create_task.constprop.10>
200e808: 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)
200e80c: 80 a2 20 00 cmp %o0, 0
200e810: 12 80 00 16 bne 200e868 <rtems_bdbuf_init+0x3a4> <== NEVER TAKEN
200e814: 03 00 80 86 sethi %hi(0x2021800), %g1
goto error;
if (bdbuf_config.max_read_ahead_blocks > 0)
200e818: c2 06 a1 50 ld [ %i2 + 0x150 ], %g1
200e81c: 80 a0 60 00 cmp %g1, 0
200e820: 32 80 00 06 bne,a 200e838 <rtems_bdbuf_init+0x374>
200e824: d2 07 20 2c ld [ %i4 + 0x2c ], %o1
&bdbuf_cache.read_ahead_task);
if (sc != RTEMS_SUCCESSFUL)
goto error;
}
rtems_bdbuf_unlock_cache ();
200e828: 7f ff f9 03 call 200cc34 <rtems_bdbuf_unlock_cache>
200e82c: b0 10 20 00 clr %i0
return RTEMS_SUCCESSFUL;
200e830: 81 c7 e0 08 ret
200e834: 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;
200e838: f6 2f 60 94 stb %i3, [ %i5 + 0x94 ]
sc = rtems_bdbuf_create_task (rtems_build_name('B', 'R', 'D', 'A'),
200e83c: 11 10 94 91 sethi %hi(0x42524400), %o0
200e840: 15 00 80 38 sethi %hi(0x200e000), %o2
200e844: 90 12 20 41 or %o0, 0x41, %o0
200e848: 94 12 a2 f4 or %o2, 0x2f4, %o2
200e84c: 96 10 20 00 clr %o3
200e850: 7f ff f9 a8 call 200cef0 <rtems_bdbuf_create_task.constprop.10>
200e854: 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)
200e858: 80 a2 20 00 cmp %o0, 0
200e85c: 02 bf ff f3 be 200e828 <rtems_bdbuf_init+0x364> <== ALWAYS TAKEN
200e860: 01 00 00 00 nop
return RTEMS_SUCCESSFUL;
error:
if (bdbuf_cache.read_ahead_task != 0)
200e864: 03 00 80 86 sethi %hi(0x2021800), %g1 <== NOT EXECUTED
200e868: d0 00 61 10 ld [ %g1 + 0x110 ], %o0 ! 2021910 <bdbuf_cache+0x84><== NOT EXECUTED
200e86c: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
200e870: 02 80 00 05 be 200e884 <rtems_bdbuf_init+0x3c0> <== NOT EXECUTED
200e874: 03 00 80 86 sethi %hi(0x2021800), %g1 <== NOT EXECUTED
rtems_task_delete (bdbuf_cache.read_ahead_task);
200e878: 7f ff e9 e5 call 200900c <rtems_task_delete> <== NOT EXECUTED
200e87c: 01 00 00 00 nop <== NOT EXECUTED
if (bdbuf_cache.swapout != 0)
200e880: 03 00 80 86 sethi %hi(0x2021800), %g1 <== NOT EXECUTED
200e884: d0 00 60 8c ld [ %g1 + 0x8c ], %o0 ! 202188c <bdbuf_cache><== NOT EXECUTED
200e888: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
200e88c: 02 80 00 04 be 200e89c <rtems_bdbuf_init+0x3d8> <== NOT EXECUTED
200e890: 3b 00 80 86 sethi %hi(0x2021800), %i5 <== NOT EXECUTED
rtems_task_delete (bdbuf_cache.swapout);
200e894: 7f ff e9 de call 200900c <rtems_task_delete> <== NOT EXECUTED
200e898: 01 00 00 00 nop <== NOT EXECUTED
free (bdbuf_cache.buffers);
200e89c: ba 17 60 8c or %i5, 0x8c, %i5 <== NOT EXECUTED
200e8a0: 7f ff d8 6a call 2004a48 <free> <== NOT EXECUTED
200e8a4: d0 07 60 18 ld [ %i5 + 0x18 ], %o0 <== NOT EXECUTED
free (bdbuf_cache.groups);
200e8a8: 7f ff d8 68 call 2004a48 <free> <== NOT EXECUTED
200e8ac: d0 07 60 80 ld [ %i5 + 0x80 ], %o0 <== NOT EXECUTED
free (bdbuf_cache.bds);
200e8b0: 7f ff d8 66 call 2004a48 <free> <== NOT EXECUTED
200e8b4: d0 07 60 14 ld [ %i5 + 0x14 ], %o0 <== NOT EXECUTED
rtems_semaphore_delete (bdbuf_cache.buffer_waiters.sema);
200e8b8: 7f ff e8 e5 call 2008c4c <rtems_semaphore_delete> <== NOT EXECUTED
200e8bc: d0 07 60 78 ld [ %i5 + 0x78 ], %o0 <== NOT EXECUTED
rtems_semaphore_delete (bdbuf_cache.access_waiters.sema);
200e8c0: 7f ff e8 e3 call 2008c4c <rtems_semaphore_delete> <== NOT EXECUTED
200e8c4: d0 07 60 68 ld [ %i5 + 0x68 ], %o0 <== NOT EXECUTED
rtems_semaphore_delete (bdbuf_cache.transfer_waiters.sema);
200e8c8: 7f ff e8 e1 call 2008c4c <rtems_semaphore_delete> <== NOT EXECUTED
200e8cc: d0 07 60 70 ld [ %i5 + 0x70 ], %o0 <== NOT EXECUTED
rtems_semaphore_delete (bdbuf_cache.sync_lock);
200e8d0: 7f ff e8 df call 2008c4c <rtems_semaphore_delete> <== NOT EXECUTED
200e8d4: d0 07 60 2c ld [ %i5 + 0x2c ], %o0 <== NOT EXECUTED
if (bdbuf_cache.lock != 0)
200e8d8: c2 07 60 28 ld [ %i5 + 0x28 ], %g1 <== NOT EXECUTED
200e8dc: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
200e8e0: 02 80 00 07 be 200e8fc <rtems_bdbuf_init+0x438> <== NOT EXECUTED
200e8e4: 03 00 80 86 sethi %hi(0x2021800), %g1 <== NOT EXECUTED
{
rtems_bdbuf_unlock_cache ();
200e8e8: 7f ff f8 d3 call 200cc34 <rtems_bdbuf_unlock_cache> <== NOT EXECUTED
200e8ec: 01 00 00 00 nop <== NOT EXECUTED
rtems_semaphore_delete (bdbuf_cache.lock);
200e8f0: 7f ff e8 d7 call 2008c4c <rtems_semaphore_delete> <== NOT EXECUTED
200e8f4: d0 07 60 28 ld [ %i5 + 0x28 ], %o0 <== NOT EXECUTED
}
bdbuf_cache.initialised = false;
200e8f8: 03 00 80 86 sethi %hi(0x2021800), %g1 <== NOT EXECUTED
return RTEMS_UNSATISFIED;
200e8fc: b0 10 20 0d mov 0xd, %i0 <== NOT EXECUTED
{
rtems_bdbuf_unlock_cache ();
rtems_semaphore_delete (bdbuf_cache.lock);
}
bdbuf_cache.initialised = false;
200e900: c0 28 61 21 clrb [ %g1 + 0x121 ] <== NOT EXECUTED
return RTEMS_UNSATISFIED;
}
200e904: 81 c7 e0 08 ret <== NOT EXECUTED
200e908: 81 e8 00 00 restore <== NOT EXECUTED
0200cbac <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)
{
200cbac: 9d e3 bf a0 save %sp, -96, %sp
rtems_status_code sc = rtems_semaphore_obtain (lock,
200cbb0: 92 10 20 00 clr %o1
200cbb4: 90 10 00 18 mov %i0, %o0
200cbb8: 7f ff f0 54 call 2008d08 <rtems_semaphore_obtain>
200cbbc: 94 10 20 00 clr %o2
RTEMS_WAIT,
RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
200cbc0: 80 a2 20 00 cmp %o0, 0
200cbc4: 02 80 00 04 be 200cbd4 <rtems_bdbuf_lock+0x28> <== ALWAYS TAKEN
200cbc8: 01 00 00 00 nop
rtems_fatal_error_occurred (fatal_error_code);
200cbcc: 7f ff f1 fc call 20093bc <rtems_fatal_error_occurred> <== NOT EXECUTED
200cbd0: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
200cbd4: 81 c7 e0 08 ret
200cbd8: 81 e8 00 00 restore
0200eeb0 <rtems_bdbuf_purge_dev>:
}
}
void
rtems_bdbuf_purge_dev (rtems_disk_device *dd)
{
200eeb0: 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;
200eeb4: 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;
200eeb8: b6 07 bf 78 add %fp, -136, %i3
head->previous = NULL;
tail->previous = head;
200eebc: 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;
200eec0: f6 27 bf 74 st %i3, [ %fp + -140 ]
rtems_chain_control purge_list;
rtems_chain_initialize_empty (&purge_list);
rtems_bdbuf_lock_cache ();
200eec4: 7f ff f7 46 call 200cbdc <rtems_bdbuf_lock_cache>
200eec8: c0 27 bf 78 clr [ %fp + -136 ]
}
static void
rtems_bdbuf_read_ahead_reset (rtems_disk_device *dd)
{
rtems_bdbuf_read_ahead_cancel (dd);
200eecc: 7f ff fd 56 call 200e424 <rtems_bdbuf_read_ahead_cancel>
200eed0: 90 10 00 18 mov %i0, %o0
dd->read_ahead.trigger = RTEMS_DISK_READ_AHEAD_NO_TRIGGER;
200eed4: 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;
200eed8: 11 00 80 86 sethi %hi(0x2021800), %o0
while (cur != NULL)
{
if (cur->dd == dd)
{
switch (cur->state)
200eedc: 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;
200eee0: 90 12 20 8c or %o0, 0x8c, %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;
200eee4: 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;
200eee8: fa 02 20 3c ld [ %o0 + 0x3c ], %i5
*prev = NULL;
200eeec: 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;
200eef0: b8 07 bf 80 add %fp, -128, %i4
while (cur != NULL)
{
if (cur->dd == dd)
{
switch (cur->state)
200eef4: b4 16 a3 30 or %i2, 0x330, %i2
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
200eef8: b2 10 20 06 mov 6, %i1
200eefc: 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);
200ef00: 10 80 00 3b b 200efec <rtems_bdbuf_purge_dev+0x13c>
200ef04: a2 02 20 6c add %o0, 0x6c, %l1
*prev = NULL;
while (cur != NULL)
{
if (cur->dd == dd)
200ef08: 80 a0 40 18 cmp %g1, %i0
200ef0c: 32 80 00 1f bne,a 200ef88 <rtems_bdbuf_purge_dev+0xd8> <== NEVER TAKEN
200ef10: c2 07 60 08 ld [ %i5 + 8 ], %g1 <== NOT EXECUTED
{
switch (cur->state)
200ef14: c2 07 60 20 ld [ %i5 + 0x20 ], %g1
200ef18: 80 a0 60 0a cmp %g1, 0xa
200ef1c: 18 80 00 18 bgu 200ef7c <rtems_bdbuf_purge_dev+0xcc> <== NEVER TAKEN
200ef20: 11 10 80 00 sethi %hi(0x42000000), %o0
200ef24: 83 28 60 02 sll %g1, 2, %g1
200ef28: c2 06 80 01 ld [ %i2 + %g1 ], %g1
200ef2c: 81 c0 40 00 jmp %g1
200ef30: 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);
200ef34: 7f ff f7 e1 call 200ceb8 <rtems_bdbuf_wake>
200ef38: 90 10 00 11 mov %l1, %o0
/* Fall through */
case RTEMS_BDBUF_STATE_MODIFIED:
rtems_bdbuf_group_release (cur);
200ef3c: 7f ff f7 17 call 200cb98 <rtems_bdbuf_group_release>
200ef40: 90 10 00 1d mov %i5, %o0
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
previous = the_node->previous;
200ef44: c2 07 60 04 ld [ %i5 + 4 ], %g1
)
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
200ef48: c4 07 40 00 ld [ %i5 ], %g2
previous = the_node->previous;
next->previous = previous;
200ef4c: c2 20 a0 04 st %g1, [ %g2 + 4 ]
previous->next = next;
200ef50: 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;
200ef54: c2 07 bf 7c ld [ %fp + -132 ], %g1
the_node->next = tail;
200ef58: f6 27 40 00 st %i3, [ %i5 ]
tail->previous = the_node;
200ef5c: fa 27 bf 7c st %i5, [ %fp + -132 ]
old_last->next = the_node;
200ef60: fa 20 40 00 st %i5, [ %g1 ]
the_node->previous = old_last;
200ef64: 10 80 00 08 b 200ef84 <rtems_bdbuf_purge_dev+0xd4>
200ef68: 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;
200ef6c: 10 80 00 06 b 200ef84 <rtems_bdbuf_purge_dev+0xd4>
200ef70: e0 27 60 20 st %l0, [ %i5 + 0x20 ]
200ef74: 10 80 00 04 b 200ef84 <rtems_bdbuf_purge_dev+0xd4>
200ef78: 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);
200ef7c: 7f ff e9 10 call 20093bc <rtems_fatal_error_occurred> <== NOT EXECUTED
200ef80: 90 12 20 01 or %o0, 1, %o0 <== NOT EXECUTED
}
}
if (cur->avl.left != NULL)
200ef84: c2 07 60 08 ld [ %i5 + 8 ], %g1
200ef88: 80 a0 60 00 cmp %g1, 0
200ef8c: 22 80 00 04 be,a 200ef9c <rtems_bdbuf_purge_dev+0xec>
200ef90: c2 07 60 0c ld [ %i5 + 0xc ], %g1
}
else if (cur->avl.right != NULL)
{
/* Right */
++prev;
*prev = cur;
200ef94: 10 80 00 06 b 200efac <rtems_bdbuf_purge_dev+0xfc>
200ef98: fa 27 20 04 st %i5, [ %i4 + 4 ]
/* Left */
++prev;
*prev = cur;
cur = cur->avl.left;
}
else if (cur->avl.right != NULL)
200ef9c: 80 a0 60 00 cmp %g1, 0
200efa0: 22 80 00 08 be,a 200efc0 <rtems_bdbuf_purge_dev+0x110>
200efa4: c2 07 00 00 ld [ %i4 ], %g1
{
/* Right */
++prev;
*prev = cur;
200efa8: fa 27 20 04 st %i5, [ %i4 + 4 ]
cur = cur->avl.left;
}
else if (cur->avl.right != NULL)
{
/* Right */
++prev;
200efac: 10 80 00 0f b 200efe8 <rtems_bdbuf_purge_dev+0x138>
200efb0: b8 07 20 04 add %i4, 4, %i4
while (*prev != NULL
&& (cur == (*prev)->avl.right || (*prev)->avl.right == NULL))
{
/* Up */
cur = *prev;
--prev;
200efb4: b8 07 3f fc add %i4, -4, %i4
200efb8: ba 10 00 01 mov %g1, %i5
*prev = cur;
cur = cur->avl.right;
}
else
{
while (*prev != NULL
200efbc: c2 07 00 00 ld [ %i4 ], %g1
200efc0: 80 a0 60 00 cmp %g1, 0
200efc4: 22 80 00 0a be,a 200efec <rtems_bdbuf_purge_dev+0x13c>
200efc8: ba 10 00 01 mov %g1, %i5
&& (cur == (*prev)->avl.right || (*prev)->avl.right == NULL))
200efcc: c4 00 60 0c ld [ %g1 + 0xc ], %g2
200efd0: 80 a7 40 02 cmp %i5, %g2
200efd4: 02 bf ff f8 be 200efb4 <rtems_bdbuf_purge_dev+0x104>
200efd8: 80 a0 a0 00 cmp %g2, 0
200efdc: 22 bf ff f7 be,a 200efb8 <rtems_bdbuf_purge_dev+0x108>
200efe0: b8 07 3f fc add %i4, -4, %i4
cur = *prev;
--prev;
}
if (*prev != NULL)
/* Right */
cur = (*prev)->avl.right;
200efe4: 82 10 00 02 mov %g2, %g1
200efe8: ba 10 00 01 mov %g1, %i5
rtems_bdbuf_buffer **prev = stack;
rtems_bdbuf_buffer *cur = bdbuf_cache.tree;
*prev = NULL;
while (cur != NULL)
200efec: 80 a7 60 00 cmp %i5, 0
200eff0: 32 bf ff c6 bne,a 200ef08 <rtems_bdbuf_purge_dev+0x58>
200eff4: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
}
static void
rtems_bdbuf_purge_list (rtems_chain_control *purge_list)
{
bool wake_buffer_waiters = false;
200eff8: b8 10 20 00 clr %i4
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
200effc: 10 80 00 0c b 200f02c <rtems_bdbuf_purge_dev+0x17c>
200f000: 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)
200f004: 80 a0 60 00 cmp %g1, 0
200f008: 22 80 00 02 be,a 200f010 <rtems_bdbuf_purge_dev+0x160>
200f00c: 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)
200f010: 80 a0 60 00 cmp %g1, 0
200f014: 12 80 00 06 bne 200f02c <rtems_bdbuf_purge_dev+0x17c>
200f018: f6 27 60 20 st %i3, [ %i5 + 0x20 ]
{
rtems_bdbuf_remove_from_tree (bd);
200f01c: 7f ff f7 cc call 200cf4c <rtems_bdbuf_remove_from_tree>
200f020: 90 10 00 1d mov %i5, %o0
rtems_bdbuf_make_free_and_add_to_lru_list (bd);
200f024: 7f ff f8 a4 call 200d2b4 <rtems_bdbuf_make_free_and_add_to_lru_list>
200f028: 90 10 00 1d mov %i5, %o0
200f02c: 7f ff f6 cc call 200cb5c <_Chain_Get_unprotected>
200f030: 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)
200f034: ba 92 20 00 orcc %o0, 0, %i5
200f038: 32 bf ff f3 bne,a 200f004 <rtems_bdbuf_purge_dev+0x154>
200f03c: c2 07 60 24 ld [ %i5 + 0x24 ], %g1
wake_buffer_waiters = true;
rtems_bdbuf_discard_buffer (bd);
}
if (wake_buffer_waiters)
200f040: 80 8f 20 ff btst 0xff, %i4
200f044: 02 80 00 04 be 200f054 <rtems_bdbuf_purge_dev+0x1a4>
200f048: 11 00 80 86 sethi %hi(0x2021800), %o0
rtems_bdbuf_wake (&bdbuf_cache.buffer_waiters);
200f04c: 7f ff f7 9b call 200ceb8 <rtems_bdbuf_wake>
200f050: 90 12 21 00 or %o0, 0x100, %o0 ! 2021900 <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 ();
200f054: 7f ff f6 f8 call 200cc34 <rtems_bdbuf_unlock_cache>
200f058: 01 00 00 00 nop
200f05c: 81 c7 e0 08 ret
200f060: 81 e8 00 00 restore
0200e9d0 <rtems_bdbuf_read>:
rtems_status_code
rtems_bdbuf_read (rtems_disk_device *dd,
rtems_blkdev_bnum block,
rtems_bdbuf_buffer **bd_ptr)
{
200e9d0: 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 ();
200e9d4: 7f ff f8 82 call 200cbdc <rtems_bdbuf_lock_cache>
200e9d8: 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)
200e9dc: 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;
200e9e0: 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)
200e9e4: 80 a6 40 01 cmp %i1, %g1
200e9e8: 1a 80 00 72 bcc 200ebb0 <rtems_bdbuf_read+0x1e0> <== NEVER TAKEN
200e9ec: 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)
200e9f0: d2 07 60 30 ld [ %i5 + 0x30 ], %o1
200e9f4: 80 a2 60 00 cmp %o1, 0
200e9f8: 26 80 00 04 bl,a 200ea08 <rtems_bdbuf_read+0x38> <== NEVER TAKEN
200e9fc: d6 07 60 24 ld [ %i5 + 0x24 ], %o3 <== NOT EXECUTED
return block << dd->block_to_media_block_shift;
200ea00: 10 80 00 09 b 200ea24 <rtems_bdbuf_read+0x54>
200ea04: 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);
200ea08: 94 10 20 00 clr %o2 <== NOT EXECUTED
200ea0c: 90 10 20 00 clr %o0 <== NOT EXECUTED
200ea10: 40 00 39 21 call 201ce94 <__muldi3> <== NOT EXECUTED
200ea14: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
200ea18: d6 07 60 20 ld [ %i5 + 0x20 ], %o3 <== NOT EXECUTED
200ea1c: 40 00 3b 2f call 201d6d8 <__udivdi3> <== NOT EXECUTED
200ea20: 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;
200ea24: 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);
200ea28: 90 10 00 1d mov %i5, %o0
200ea2c: 7f ff fb 71 call 200d7f0 <rtems_bdbuf_get_buffer_for_access>
200ea30: 92 02 40 01 add %o1, %g1, %o1
200ea34: b8 10 00 08 mov %o0, %i4
switch (bd->state)
200ea38: d0 02 20 20 ld [ %o0 + 0x20 ], %o0
200ea3c: 80 a2 20 02 cmp %o0, 2
200ea40: 02 80 00 08 be 200ea60 <rtems_bdbuf_read+0x90>
200ea44: 80 a2 20 07 cmp %o0, 7
200ea48: 02 80 00 0b be 200ea74 <rtems_bdbuf_read+0xa4>
200ea4c: 80 a2 20 01 cmp %o0, 1
200ea50: 12 80 00 2d bne 200eb04 <rtems_bdbuf_read+0x134> <== NEVER TAKEN
200ea54: 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;
200ea58: 10 80 00 0e b 200ea90 <rtems_bdbuf_read+0xc0>
200ea5c: 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;
200ea60: c2 07 60 44 ld [ %i5 + 0x44 ], %g1
200ea64: 82 00 60 01 inc %g1
200ea68: 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;
200ea6c: 10 80 00 06 b 200ea84 <rtems_bdbuf_read+0xb4>
200ea70: 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;
200ea74: c2 07 60 44 ld [ %i5 + 0x44 ], %g1
200ea78: 82 00 60 01 inc %g1
200ea7c: 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;
200ea80: 82 10 20 04 mov 4, %g1
200ea84: c2 27 20 20 st %g1, [ %i4 + 0x20 ]
200ea88: 10 80 00 21 b 200eb0c <rtems_bdbuf_read+0x13c>
200ea8c: 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;
200ea90: 82 00 60 01 inc %g1
200ea94: 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)
200ea98: c2 07 60 6c ld [ %i5 + 0x6c ], %g1
200ea9c: 80 a0 40 19 cmp %g1, %i1
200eaa0: 02 80 00 09 be 200eac4 <rtems_bdbuf_read+0xf4>
200eaa4: 90 10 00 1d mov %i5, %o0
{
rtems_bdbuf_read_ahead_cancel (dd);
200eaa8: 7f ff fe 5f call 200e424 <rtems_bdbuf_read_ahead_cancel>
200eaac: 90 10 00 1d mov %i5, %o0
dd->read_ahead.trigger = block + 1;
200eab0: 82 06 60 01 add %i1, 1, %g1
200eab4: c2 27 60 6c st %g1, [ %i5 + 0x6c ]
dd->read_ahead.next = block + 2;
200eab8: 82 06 60 02 add %i1, 2, %g1
200eabc: 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);
200eac0: 90 10 00 1d mov %i5, %o0
200eac4: 92 10 00 1c mov %i4, %o1
200eac8: 7f ff fd d5 call 200e21c <rtems_bdbuf_execute_read_request>
200eacc: 94 10 20 01 mov 1, %o2
if (sc == RTEMS_SUCCESSFUL)
200ead0: b0 92 20 00 orcc %o0, 0, %i0
200ead4: 32 80 00 0e bne,a 200eb0c <rtems_bdbuf_read+0x13c>
200ead8: b8 10 20 00 clr %i4
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
200eadc: 82 10 20 03 mov 3, %g1
)
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
200eae0: c4 07 00 00 ld [ %i4 ], %g2
200eae4: c2 27 20 20 st %g1, [ %i4 + 0x20 ]
previous = the_node->previous;
200eae8: 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);
200eaec: 90 10 00 1c mov %i4, %o0
next->previous = previous;
200eaf0: c2 20 a0 04 st %g1, [ %g2 + 4 ]
200eaf4: 7f ff f8 24 call 200cb84 <rtems_bdbuf_group_obtain>
200eaf8: 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
200eafc: 10 80 00 05 b 200eb10 <rtems_bdbuf_read+0x140>
200eb00: 03 00 80 86 sethi %hi(0x2021800), %g1
{
bd = NULL;
}
break;
default:
rtems_bdbuf_fatal (bd->state, RTEMS_BLKDEV_FATAL_BDBUF_STATE_4);
200eb04: 7f ff f8 3d call 200cbf8 <rtems_bdbuf_fatal> <== NOT EXECUTED
200eb08: 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
200eb0c: 03 00 80 86 sethi %hi(0x2021800), %g1
200eb10: d0 00 61 10 ld [ %g1 + 0x110 ], %o0 ! 2021910 <bdbuf_cache+0x84>
200eb14: 80 a2 20 00 cmp %o0, 0
200eb18: 02 80 00 26 be 200ebb0 <rtems_bdbuf_read+0x1e0>
200eb1c: 01 00 00 00 nop
&& dd->read_ahead.trigger == block
200eb20: c2 07 60 6c ld [ %i5 + 0x6c ], %g1
200eb24: 80 a0 40 19 cmp %g1, %i1
200eb28: 12 80 00 22 bne 200ebb0 <rtems_bdbuf_read+0x1e0>
200eb2c: 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);
200eb30: c4 07 60 64 ld [ %i5 + 0x64 ], %g2
200eb34: 80 a0 a0 00 cmp %g2, 0
200eb38: 12 80 00 05 bne 200eb4c <rtems_bdbuf_read+0x17c> <== NEVER TAKEN
200eb3c: 82 10 20 00 clr %g1
200eb40: c2 07 60 68 ld [ %i5 + 0x68 ], %g1
200eb44: 80 a0 00 01 cmp %g0, %g1
200eb48: 82 60 3f ff subx %g0, -1, %g1
&& !rtems_bdbuf_is_read_ahead_active (dd))
200eb4c: 80 a0 60 00 cmp %g1, 0
200eb50: 02 80 00 18 be 200ebb0 <rtems_bdbuf_read+0x1e0> <== NEVER TAKEN
200eb54: 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;
200eb58: 82 10 60 8c or %g1, 0x8c, %g1 ! 202188c <bdbuf_cache>
{
rtems_status_code sc;
rtems_chain_control *chain = &bdbuf_cache.read_ahead_chain;
if (rtems_chain_is_empty (chain))
200eb5c: c4 00 60 88 ld [ %g1 + 0x88 ], %g2
200eb60: 82 00 60 8c add %g1, 0x8c, %g1
200eb64: 80 a0 80 01 cmp %g2, %g1
200eb68: 12 80 00 0a bne 200eb90 <rtems_bdbuf_read+0x1c0> <== NEVER TAKEN
200eb6c: 03 00 80 86 sethi %hi(0x2021800), %g1
{
sc = rtems_event_send (bdbuf_cache.read_ahead_task,
200eb70: 7f ff e7 2f call 200882c <rtems_event_send>
200eb74: 92 10 20 02 mov 2, %o1
RTEMS_BDBUF_READ_AHEAD_WAKE_UP);
if (sc != RTEMS_SUCCESSFUL)
200eb78: 80 a2 20 00 cmp %o0, 0
200eb7c: 02 80 00 05 be 200eb90 <rtems_bdbuf_read+0x1c0> <== ALWAYS TAKEN
200eb80: 03 00 80 86 sethi %hi(0x2021800), %g1
rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_RA_WAKE_UP);
200eb84: 11 10 80 00 sethi %hi(0x42000000), %o0 <== NOT EXECUTED
200eb88: 7f ff ea 0d call 20093bc <rtems_fatal_error_occurred> <== NOT EXECUTED
200eb8c: 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;
200eb90: 82 10 60 8c or %g1, 0x8c, %g1
200eb94: c4 00 60 90 ld [ %g1 + 0x90 ], %g2
}
rtems_chain_append_unprotected (chain, &dd->read_ahead.node);
200eb98: 86 07 60 64 add %i5, 0x64, %g3
the_node->next = tail;
200eb9c: 88 00 60 8c add %g1, 0x8c, %g4
tail->previous = the_node;
200eba0: 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;
200eba4: c8 27 60 64 st %g4, [ %i5 + 0x64 ]
tail->previous = the_node;
old_last->next = the_node;
200eba8: c6 20 80 00 st %g3, [ %g2 ]
the_node->previous = old_last;
200ebac: c4 27 60 68 st %g2, [ %i5 + 0x68 ]
}
rtems_bdbuf_check_read_ahead_trigger (dd, block);
}
rtems_bdbuf_unlock_cache ();
200ebb0: 7f ff f8 21 call 200cc34 <rtems_bdbuf_unlock_cache>
200ebb4: 01 00 00 00 nop
*bd_ptr = bd;
200ebb8: f8 26 80 00 st %i4, [ %i2 ]
return sc;
}
200ebbc: 81 c7 e0 08 ret
200ebc0: 81 e8 00 00 restore
0200e424 <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);
200e424: c2 02 20 64 ld [ %o0 + 0x64 ], %g1
200e428: 80 a0 60 00 cmp %g1, 0
200e42c: 12 80 00 05 bne 200e440 <rtems_bdbuf_read_ahead_cancel+0x1c><== NEVER TAKEN
200e430: 84 10 20 00 clr %g2
200e434: c4 02 20 68 ld [ %o0 + 0x68 ], %g2
200e438: 80 a0 00 02 cmp %g0, %g2
200e43c: 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))
200e440: 80 a0 a0 00 cmp %g2, 0
200e444: 12 80 00 07 bne 200e460 <rtems_bdbuf_read_ahead_cancel+0x3c><== ALWAYS TAKEN
200e448: 01 00 00 00 nop
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
previous = the_node->previous;
200e44c: c4 02 20 68 ld [ %o0 + 0x68 ], %g2 <== NOT EXECUTED
next->previous = previous;
200e450: c4 20 60 04 st %g2, [ %g1 + 4 ] <== NOT EXECUTED
previous->next = next;
200e454: 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;
200e458: c0 22 20 68 clr [ %o0 + 0x68 ] <== NOT EXECUTED
200e45c: c0 22 20 64 clr [ %o0 + 0x64 ] <== NOT EXECUTED
200e460: 81 c3 e0 08 retl
0200e2f4 <rtems_bdbuf_read_ahead_task>:
return sc;
}
static rtems_task
rtems_bdbuf_read_ahead_task (rtems_task_argument arg)
{
200e2f4: 9d e3 bf a0 save %sp, -96, %sp
200e2f8: 33 00 80 86 sethi %hi(0x2021800), %i1
rtems_chain_control *chain = &bdbuf_cache.read_ahead_chain;
while (bdbuf_cache.read_ahead_enabled)
200e2fc: 35 00 80 86 sethi %hi(0x2021800), %i2
200e300: b2 16 61 14 or %i1, 0x114, %i1
200e304: 10 80 00 41 b 200e408 <rtems_bdbuf_read_ahead_task+0x114>
200e308: 31 00 80 7b sethi %hi(0x201ec00), %i0
{
rtems_chain_node *node;
rtems_bdbuf_wait_for_event (RTEMS_BDBUF_READ_AHEAD_WAKE_UP);
200e30c: 7f ff fa 63 call 200cc98 <rtems_bdbuf_wait_for_event>
200e310: 90 10 20 02 mov 2, %o0
rtems_bdbuf_lock_cache ();
200e314: 7f ff fa 32 call 200cbdc <rtems_bdbuf_lock_cache>
200e318: 01 00 00 00 nop
while ((node = rtems_chain_get_unprotected (chain)) != NULL)
200e31c: 30 80 00 34 b,a 200e3ec <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)
200e320: 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;
200e324: 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)
200e328: 80 a7 00 02 cmp %i4, %g2
200e32c: 1a 80 00 11 bcc 200e370 <rtems_bdbuf_read_ahead_task+0x7c>
200e330: 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)
200e334: d2 07 7f cc ld [ %i5 + -52 ], %o1
200e338: 80 a2 60 00 cmp %o1, 0
200e33c: 16 80 00 0a bge 200e364 <rtems_bdbuf_read_ahead_task+0x70><== ALWAYS TAKEN
200e340: 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);
200e344: d2 07 7f c0 ld [ %i5 + -64 ], %o1 <== NOT EXECUTED
200e348: 94 10 20 00 clr %o2 <== NOT EXECUTED
200e34c: 96 10 00 1c mov %i4, %o3 <== NOT EXECUTED
200e350: 40 00 3a d1 call 201ce94 <__muldi3> <== NOT EXECUTED
200e354: 90 10 20 00 clr %o0 <== NOT EXECUTED
200e358: d6 07 7f bc ld [ %i5 + -68 ], %o3 <== NOT EXECUTED
200e35c: 40 00 3c df call 201d6d8 <__udivdi3> <== NOT EXECUTED
200e360: 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;
200e364: c2 07 7f b4 ld [ %i5 + -76 ], %g1
200e368: 92 02 40 01 add %o1, %g1, %o1
200e36c: 82 10 20 00 clr %g1
*/
RTEMS_INLINE_ROUTINE void _Chain_Set_off_chain(
Chain_Node *node
)
{
node->next = node->previous = NULL;
200e370: 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)
200e374: 80 a0 60 00 cmp %g1, 0
200e378: 12 80 00 1b bne 200e3e4 <rtems_bdbuf_read_ahead_task+0xf0>
200e37c: 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 *)
200e380: 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 =
200e384: 7f ff fd 08 call 200d7a4 <rtems_bdbuf_get_buffer_for_read_ahead>
200e388: 90 10 00 1b mov %i3, %o0
rtems_bdbuf_get_buffer_for_read_ahead (dd, media_block);
if (bd != NULL)
200e38c: 92 92 20 00 orcc %o0, 0, %o1
200e390: 02 80 00 17 be 200e3ec <rtems_bdbuf_read_ahead_task+0xf8> <== NEVER TAKEN
200e394: c2 06 21 50 ld [ %i0 + 0x150 ], %g1
{
uint32_t transfer_count = dd->block_count - block;
200e398: d4 07 7f c4 ld [ %i5 + -60 ], %o2
200e39c: 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)
200e3a0: 80 a2 80 01 cmp %o2, %g1
200e3a4: 2a 80 00 09 bcs,a 200e3c8 <rtems_bdbuf_read_ahead_task+0xd4>
200e3a8: 82 10 3f ff mov -1, %g1
{
transfer_count = max_transfer_count;
dd->read_ahead.trigger = block + transfer_count / 2;
200e3ac: 85 30 60 01 srl %g1, 1, %g2
dd->read_ahead.next = block + transfer_count;
200e3b0: 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;
200e3b4: 84 00 80 1c add %g2, %i4, %g2
dd->read_ahead.next = block + transfer_count;
200e3b8: 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;
200e3bc: c4 27 60 08 st %g2, [ %i5 + 8 ]
dd->read_ahead.next = block + transfer_count;
200e3c0: 10 80 00 03 b 200e3cc <rtems_bdbuf_read_ahead_task+0xd8>
200e3c4: f8 27 60 0c st %i4, [ %i5 + 0xc ]
}
else
{
dd->read_ahead.trigger = RTEMS_DISK_READ_AHEAD_NO_TRIGGER;
200e3c8: c2 27 60 08 st %g1, [ %i5 + 8 ]
}
++dd->stats.read_ahead_transfers;
200e3cc: c2 07 7f e8 ld [ %i5 + -24 ], %g1
rtems_bdbuf_execute_read_request (dd, bd, transfer_count);
200e3d0: 90 10 00 1b mov %i3, %o0
else
{
dd->read_ahead.trigger = RTEMS_DISK_READ_AHEAD_NO_TRIGGER;
}
++dd->stats.read_ahead_transfers;
200e3d4: 82 00 60 01 inc %g1
rtems_bdbuf_execute_read_request (dd, bd, transfer_count);
200e3d8: 7f ff ff 91 call 200e21c <rtems_bdbuf_execute_read_request>
200e3dc: c2 27 7f e8 st %g1, [ %i5 + -24 ]
200e3e0: 30 80 00 03 b,a 200e3ec <rtems_bdbuf_read_ahead_task+0xf8>
}
}
else
{
dd->read_ahead.trigger = RTEMS_DISK_READ_AHEAD_NO_TRIGGER;
200e3e4: 82 10 3f ff mov -1, %g1
200e3e8: c2 27 60 08 st %g1, [ %i5 + 8 ]
200e3ec: 7f ff f9 dc call 200cb5c <_Chain_Get_unprotected>
200e3f0: 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)
200e3f4: ba 92 20 00 orcc %o0, 0, %i5
200e3f8: 32 bf ff ca bne,a 200e320 <rtems_bdbuf_read_ahead_task+0x2c>
200e3fc: f8 07 60 0c ld [ %i5 + 0xc ], %i4
{
dd->read_ahead.trigger = RTEMS_DISK_READ_AHEAD_NO_TRIGGER;
}
}
rtems_bdbuf_unlock_cache ();
200e400: 7f ff fa 0d call 200cc34 <rtems_bdbuf_unlock_cache>
200e404: 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)
200e408: 82 16 a0 8c or %i2, 0x8c, %g1
200e40c: c2 08 60 94 ldub [ %g1 + 0x94 ], %g1
200e410: 80 a0 60 00 cmp %g1, 0
200e414: 12 bf ff be bne 200e30c <rtems_bdbuf_read_ahead_task+0x18><== ALWAYS TAKEN
200e418: 01 00 00 00 nop
}
rtems_bdbuf_unlock_cache ();
}
rtems_task_delete (RTEMS_SELF);
200e41c: 7f ff ea fc call 200900c <rtems_task_delete> <== NOT EXECUTED
200e420: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED
0200ebc4 <rtems_bdbuf_release>:
return RTEMS_SUCCESSFUL;
}
rtems_status_code
rtems_bdbuf_release (rtems_bdbuf_buffer *bd)
{
200ebc4: 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)
200ebc8: 80 a6 20 00 cmp %i0, 0
200ebcc: 02 80 00 31 be 200ec90 <rtems_bdbuf_release+0xcc> <== NEVER TAKEN
200ebd0: 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();
200ebd4: 7f ff f8 02 call 200cbdc <rtems_bdbuf_lock_cache>
200ebd8: 01 00 00 00 nop
sc = rtems_bdbuf_check_bd_and_lock_cache (bd, "release");
if (sc != RTEMS_SUCCESSFUL)
return sc;
switch (bd->state)
200ebdc: d0 06 20 20 ld [ %i0 + 0x20 ], %o0
200ebe0: 80 a2 20 04 cmp %o0, 4
200ebe4: 02 80 00 22 be 200ec6c <rtems_bdbuf_release+0xa8>
200ebe8: 01 00 00 00 nop
200ebec: 18 80 00 06 bgu 200ec04 <rtems_bdbuf_release+0x40>
200ebf0: 80 a2 20 06 cmp %o0, 6
200ebf4: 80 a2 20 03 cmp %o0, 3
200ebf8: 12 80 00 20 bne 200ec78 <rtems_bdbuf_release+0xb4> <== NEVER TAKEN
200ebfc: 13 10 80 00 sethi %hi(0x42000000), %o1
200ec00: 30 80 00 04 b,a 200ec10 <rtems_bdbuf_release+0x4c>
200ec04: 18 80 00 1d bgu 200ec78 <rtems_bdbuf_release+0xb4> <== NEVER TAKEN
200ec08: 13 10 80 00 sethi %hi(0x42000000), %o1
200ec0c: 30 80 00 15 b,a 200ec60 <rtems_bdbuf_release+0x9c>
}
static void
rtems_bdbuf_add_to_lru_list_after_access (rtems_bdbuf_buffer *bd)
{
rtems_bdbuf_group_release (bd);
200ec10: 7f ff f7 e2 call 200cb98 <rtems_bdbuf_group_release>
200ec14: 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;
200ec18: 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;
200ec1c: 11 00 80 86 sethi %hi(0x2021800), %o0
200ec20: c2 26 20 20 st %g1, [ %i0 + 0x20 ]
200ec24: 90 12 20 8c or %o0, 0x8c, %o0
200ec28: c2 02 20 48 ld [ %o0 + 0x48 ], %g1
the_node->next = tail;
200ec2c: 84 02 20 44 add %o0, 0x44, %g2
tail->previous = the_node;
200ec30: 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;
200ec34: c4 26 00 00 st %g2, [ %i0 ]
tail->previous = the_node;
old_last->next = the_node;
200ec38: f0 20 40 00 st %i0, [ %g1 ]
the_node->previous = old_last;
200ec3c: 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)
200ec40: c2 06 20 24 ld [ %i0 + 0x24 ], %g1
200ec44: 80 a0 60 00 cmp %g1, 0
200ec48: 22 80 00 03 be,a 200ec54 <rtems_bdbuf_release+0x90>
200ec4c: 90 02 20 74 add %o0, 0x74, %o0
200ec50: 90 02 20 64 add %o0, 0x64, %o0
rtems_bdbuf_wake (&bdbuf_cache.access_waiters);
else
rtems_bdbuf_wake (&bdbuf_cache.buffer_waiters);
200ec54: 7f ff f8 99 call 200ceb8 <rtems_bdbuf_wake>
200ec58: 01 00 00 00 nop
200ec5c: 30 80 00 09 b,a 200ec80 <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);
200ec60: 7f ff fe 02 call 200e468 <rtems_bdbuf_discard_buffer_after_access>
200ec64: 90 10 00 18 mov %i0, %o0
break;
200ec68: 30 80 00 06 b,a 200ec80 <rtems_bdbuf_release+0xbc>
case RTEMS_BDBUF_STATE_ACCESS_MODIFIED:
rtems_bdbuf_add_to_modified_list_after_access (bd);
200ec6c: 7f ff f9 9b call 200d2d8 <rtems_bdbuf_add_to_modified_list_after_access>
200ec70: 90 10 00 18 mov %i0, %o0
break;
200ec74: 30 80 00 03 b,a 200ec80 <rtems_bdbuf_release+0xbc>
default:
rtems_bdbuf_fatal (bd->state, RTEMS_BLKDEV_FATAL_BDBUF_STATE_0);
200ec78: 7f ff f7 e0 call 200cbf8 <rtems_bdbuf_fatal> <== NOT EXECUTED
200ec7c: 92 12 60 1c or %o1, 0x1c, %o1 <== NOT EXECUTED
}
if (rtems_bdbuf_tracer)
rtems_bdbuf_show_usage ();
rtems_bdbuf_unlock_cache ();
200ec80: 7f ff f7 ed call 200cc34 <rtems_bdbuf_unlock_cache>
200ec84: b0 10 20 00 clr %i0
return RTEMS_SUCCESSFUL;
200ec88: 81 c7 e0 08 ret
200ec8c: 81 e8 00 00 restore
}
200ec90: 81 c7 e0 08 ret <== NOT EXECUTED
200ec94: 91 e8 20 09 restore %g0, 9, %o0 <== NOT EXECUTED
0200ec98 <rtems_bdbuf_release_modified>:
rtems_status_code
rtems_bdbuf_release_modified (rtems_bdbuf_buffer *bd)
{
200ec98: 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)
200ec9c: 80 a6 20 00 cmp %i0, 0
200eca0: 02 80 00 1a be 200ed08 <rtems_bdbuf_release_modified+0x70><== NEVER TAKEN
200eca4: 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();
200eca8: 7f ff f7 cd call 200cbdc <rtems_bdbuf_lock_cache>
200ecac: 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)
200ecb0: d0 06 20 20 ld [ %i0 + 0x20 ], %o0
200ecb4: 80 a2 20 03 cmp %o0, 3
200ecb8: 0a 80 00 0e bcs 200ecf0 <rtems_bdbuf_release_modified+0x58><== NEVER TAKEN
200ecbc: 13 10 80 00 sethi %hi(0x42000000), %o1
200ecc0: 80 a2 20 05 cmp %o0, 5
200ecc4: 08 80 00 05 bleu 200ecd8 <rtems_bdbuf_release_modified+0x40>
200ecc8: 80 a2 20 06 cmp %o0, 6
200eccc: 12 80 00 09 bne 200ecf0 <rtems_bdbuf_release_modified+0x58><== NEVER TAKEN
200ecd0: 01 00 00 00 nop
200ecd4: 30 80 00 04 b,a 200ece4 <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);
200ecd8: 7f ff f9 80 call 200d2d8 <rtems_bdbuf_add_to_modified_list_after_access>
200ecdc: 90 10 00 18 mov %i0, %o0
break;
200ece0: 30 80 00 06 b,a 200ecf8 <rtems_bdbuf_release_modified+0x60>
case RTEMS_BDBUF_STATE_ACCESS_PURGED:
rtems_bdbuf_discard_buffer_after_access (bd);
200ece4: 7f ff fd e1 call 200e468 <rtems_bdbuf_discard_buffer_after_access>
200ece8: 90 10 00 18 mov %i0, %o0
break;
200ecec: 30 80 00 03 b,a 200ecf8 <rtems_bdbuf_release_modified+0x60>
default:
rtems_bdbuf_fatal (bd->state, RTEMS_BLKDEV_FATAL_BDBUF_STATE_6);
200ecf0: 7f ff f7 c2 call 200cbf8 <rtems_bdbuf_fatal> <== NOT EXECUTED
200ecf4: 92 12 60 04 or %o1, 4, %o1 <== NOT EXECUTED
}
if (rtems_bdbuf_tracer)
rtems_bdbuf_show_usage ();
rtems_bdbuf_unlock_cache ();
200ecf8: 7f ff f7 cf call 200cc34 <rtems_bdbuf_unlock_cache>
200ecfc: b0 10 20 00 clr %i0
return RTEMS_SUCCESSFUL;
200ed00: 81 c7 e0 08 ret
200ed04: 81 e8 00 00 restore
}
200ed08: 81 c7 e0 08 ret <== NOT EXECUTED
200ed0c: 91 e8 20 09 restore %g0, 9, %o0 <== NOT EXECUTED
0200cf4c <rtems_bdbuf_remove_from_tree>:
return bdbuf_cache.buffer_waiters.count;
}
static void
rtems_bdbuf_remove_from_tree (rtems_bdbuf_buffer *bd)
{
200cf4c: 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;
200cf50: 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;
200cf54: f8 06 20 14 ld [ %i0 + 0x14 ], %i4
rtems_blkdev_bnum block = node->block;
200cf58: f6 06 20 18 ld [ %i0 + 0x18 ], %i3
rtems_bdbuf_buffer* p = *root;
200cf5c: fa 00 60 c8 ld [ %g1 + 0xc8 ], %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));
200cf60: 90 07 bf 80 add %fp, -128, %o0
200cf64: 92 10 20 00 clr %o1
200cf68: 40 00 1d 91 call 20145ac <memset>
200cf6c: 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;
200cf70: 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;
200cf74: 84 10 20 01 mov 1, %g2
p = p->avl.right;
}
else if ((p->dd != dd) || (p->block != block))
{
p->avl.cache = -1;
200cf78: 10 80 00 15 b 200cfcc <rtems_bdbuf_remove_from_tree+0x80>
200cf7c: b4 10 3f ff mov -1, %i2
memset (buf_stack, 0, sizeof(buf_stack));
while (p != NULL)
{
*buf_prev++ = p;
200cf80: fa 20 c0 00 st %i5, [ %g3 ]
if (((uintptr_t) p->dd < (uintptr_t) dd)
200cf84: 80 a0 40 1c cmp %g1, %i4
200cf88: 0a 80 00 09 bcs 200cfac <rtems_bdbuf_remove_from_tree+0x60><== NEVER TAKEN
200cf8c: 88 00 e0 04 add %g3, 4, %g4
|| ((p->dd == dd) && (p->block < block)))
200cf90: 80 a0 40 1c cmp %g1, %i4
200cf94: 32 80 00 0c bne,a 200cfc4 <rtems_bdbuf_remove_from_tree+0x78><== NEVER TAKEN
200cf98: f4 2f 60 10 stb %i2, [ %i5 + 0x10 ] <== NOT EXECUTED
200cf9c: c2 07 60 18 ld [ %i5 + 0x18 ], %g1
200cfa0: 80 a0 40 1b cmp %g1, %i3
200cfa4: 1a 80 00 05 bcc 200cfb8 <rtems_bdbuf_remove_from_tree+0x6c>
200cfa8: 01 00 00 00 nop
{
p->avl.cache = 1;
200cfac: c4 2f 60 10 stb %g2, [ %i5 + 0x10 ]
p = p->avl.right;
200cfb0: 10 80 00 06 b 200cfc8 <rtems_bdbuf_remove_from_tree+0x7c>
200cfb4: fa 07 60 0c ld [ %i5 + 0xc ], %i5
}
else if ((p->dd != dd) || (p->block != block))
200cfb8: 02 80 00 ba be 200d2a0 <rtems_bdbuf_remove_from_tree+0x354>
200cfbc: 82 07 bf 80 add %fp, -128, %g1
{
p->avl.cache = -1;
200cfc0: f4 2f 60 10 stb %i2, [ %i5 + 0x10 ]
p = p->avl.left;
200cfc4: fa 07 60 08 ld [ %i5 + 8 ], %i5
memset (buf_stack, 0, sizeof(buf_stack));
while (p != NULL)
{
*buf_prev++ = p;
200cfc8: 86 10 00 04 mov %g4, %g3
bool modified = false;
memset (buf_stack, 0, sizeof(buf_stack));
while (p != NULL)
200cfcc: 80 a7 60 00 cmp %i5, 0
200cfd0: 32 bf ff ec bne,a 200cf80 <rtems_bdbuf_remove_from_tree+0x34><== ALWAYS TAKEN
200cfd4: 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);
200cfd8: d0 06 20 20 ld [ %i0 + 0x20 ], %o0 <== NOT EXECUTED
200cfdc: 13 10 80 00 sethi %hi(0x42000000), %o1 <== NOT EXECUTED
200cfe0: 7f ff ff 06 call 200cbf8 <rtems_bdbuf_fatal> <== NOT EXECUTED
200cfe4: 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)
200cfe8: c2 07 60 0c ld [ %i5 + 0xc ], %g1
200cfec: 80 a0 60 00 cmp %g1, 0
200cff0: 32 80 00 08 bne,a 200d010 <rtems_bdbuf_remove_from_tree+0xc4>
200cff4: c4 00 60 08 ld [ %g1 + 8 ], %g2
{
r = q->avl.left;
200cff8: c2 07 60 08 ld [ %i5 + 8 ], %g1
if (r != NULL)
200cffc: 80 a0 60 00 cmp %g1, 0
200d000: 32 80 00 27 bne,a 200d09c <rtems_bdbuf_remove_from_tree+0x150>
200d004: c0 28 60 11 clrb [ %g1 + 0x11 ]
*t = q = s;
}
}
if (p != NULL)
200d008: 10 80 00 26 b 200d0a0 <rtems_bdbuf_remove_from_tree+0x154>
200d00c: 80 a7 20 00 cmp %i4, 0
{
rtems_bdbuf_buffer **t;
r = q->avl.right;
if (r->avl.left == NULL)
200d010: 80 a0 a0 00 cmp %g2, 0
200d014: 02 80 00 06 be 200d02c <rtems_bdbuf_remove_from_tree+0xe0>
200d018: 84 10 00 01 mov %g1, %g2
200d01c: b6 10 00 01 mov %g1, %i3
200d020: 86 10 00 04 mov %g4, %g3
while (s->avl.left != NULL)
{
*buf_prev++ = r = s;
s = r->avl.left;
r->avl.cache = -1;
200d024: 10 80 00 0f b 200d060 <rtems_bdbuf_remove_from_tree+0x114>
200d028: b2 10 3f ff mov -1, %i1
r = q->avl.right;
if (r->avl.left == NULL)
{
r->avl.left = q->avl.left;
200d02c: c4 07 60 08 ld [ %i5 + 8 ], %g2
r->avl.bal = q->avl.bal;
r->avl.cache = 1;
*buf_prev++ = q = r;
200d030: c2 21 3f fc st %g1, [ %g4 + -4 ]
r = q->avl.right;
if (r->avl.left == NULL)
{
r->avl.left = q->avl.left;
200d034: c4 20 60 08 st %g2, [ %g1 + 8 ]
r->avl.bal = q->avl.bal;
200d038: c4 0f 60 11 ldub [ %i5 + 0x11 ], %g2
r->avl.cache = 1;
*buf_prev++ = q = r;
200d03c: 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;
200d040: c4 28 60 11 stb %g2, [ %g1 + 0x11 ]
r->avl.cache = 1;
200d044: 84 10 20 01 mov 1, %g2
200d048: 10 80 00 15 b 200d09c <rtems_bdbuf_remove_from_tree+0x150>
200d04c: 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;
200d050: f2 28 a0 10 stb %i1, [ %g2 + 0x10 ]
s = r;
while (s->avl.left != NULL)
{
*buf_prev++ = r = s;
s = r->avl.left;
200d054: b6 10 00 02 mov %g2, %i3
t = buf_prev++;
s = r;
while (s->avl.left != NULL)
{
*buf_prev++ = r = s;
200d058: 86 00 e0 04 add %g3, 4, %g3
s = r->avl.left;
200d05c: 84 10 00 1a mov %i2, %g2
else
{
t = buf_prev++;
s = r;
while (s->avl.left != NULL)
200d060: f4 00 a0 08 ld [ %g2 + 8 ], %i2
200d064: 80 a6 a0 00 cmp %i2, 0
200d068: 32 bf ff fa bne,a 200d050 <rtems_bdbuf_remove_from_tree+0x104>
200d06c: 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;
200d070: 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;
200d074: 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;
200d078: f4 20 a0 08 st %i2, [ %g2 + 8 ]
r->avl.left = s->avl.right;
200d07c: f4 00 a0 0c ld [ %g2 + 0xc ], %i2
s->avl.right = q->avl.right;
200d080: c2 20 a0 0c st %g1, [ %g2 + 0xc ]
s->avl.bal = q->avl.bal;
200d084: 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;
200d088: f4 26 e0 08 st %i2, [ %i3 + 8 ]
s->avl.right = q->avl.right;
s->avl.bal = q->avl.bal;
200d08c: c2 28 a0 11 stb %g1, [ %g2 + 0x11 ]
s->avl.cache = 1;
200d090: 82 10 20 01 mov 1, %g1
200d094: c2 28 a0 10 stb %g1, [ %g2 + 0x10 ]
*t = q = s;
200d098: 82 10 00 02 mov %g2, %g1
}
}
if (p != NULL)
200d09c: 80 a7 20 00 cmp %i4, 0
200d0a0: 02 80 00 0d be 200d0d4 <rtems_bdbuf_remove_from_tree+0x188>
200d0a4: 05 00 80 86 sethi %hi(0x2021800), %g2
{
if (p->avl.cache == -1)
200d0a8: c4 4f 20 10 ldsb [ %i4 + 0x10 ], %g2
200d0ac: 80 a0 bf ff cmp %g2, -1
200d0b0: 32 80 00 03 bne,a 200d0bc <rtems_bdbuf_remove_from_tree+0x170>
200d0b4: c2 27 20 0c st %g1, [ %i4 + 0xc ]
{
p->avl.left = q;
200d0b8: c2 27 20 08 st %g1, [ %i4 + 8 ]
modified = true;
while (modified)
{
if (buf_prev > buf_stack)
200d0bc: 82 07 bf 80 add %fp, -128, %g1
200d0c0: 80 a0 c0 01 cmp %g3, %g1
200d0c4: 18 80 00 06 bgu 200d0dc <rtems_bdbuf_remove_from_tree+0x190>
200d0c8: ba 10 20 01 mov 1, %i5
200d0cc: 81 c7 e0 08 ret
200d0d0: 81 e8 00 00 restore
p->avl.right = q;
}
}
else
{
*root = q;
200d0d4: 10 bf ff fa b 200d0bc <rtems_bdbuf_remove_from_tree+0x170>
200d0d8: c2 20 a0 c8 st %g1, [ %g2 + 0xc8 ]
case +1:
p->avl.bal = 0;
break;
case 0:
p->avl.bal = -1;
200d0dc: b6 10 3f ff mov -1, %i3
default:
break;
}
}
if (buf_prev > buf_stack)
200d0e0: b2 10 00 01 mov %g1, %i1
while (modified)
{
if (buf_prev > buf_stack)
{
p = *--buf_prev;
200d0e4: c2 00 ff fc ld [ %g3 + -4 ], %g1
else
{
break;
}
if (p->avl.cache == -1)
200d0e8: f8 48 60 10 ldsb [ %g1 + 0x10 ], %i4
200d0ec: c4 08 60 11 ldub [ %g1 + 0x11 ], %g2
200d0f0: 80 a7 3f ff cmp %i4, -1
{
/* rebalance left branch */
switch (p->avl.bal)
200d0f4: 85 28 a0 18 sll %g2, 0x18, %g2
else
{
break;
}
if (p->avl.cache == -1)
200d0f8: 12 80 00 2a bne 200d1a0 <rtems_bdbuf_remove_from_tree+0x254>
200d0fc: 85 38 a0 18 sra %g2, 0x18, %g2
{
/* rebalance left branch */
switch (p->avl.bal)
200d100: 80 a0 a0 00 cmp %g2, 0
200d104: 22 80 00 14 be,a 200d154 <rtems_bdbuf_remove_from_tree+0x208>
200d108: fa 28 60 11 stb %i5, [ %g1 + 0x11 ]
200d10c: 80 a0 a0 01 cmp %g2, 1
200d110: 02 80 00 06 be 200d128 <rtems_bdbuf_remove_from_tree+0x1dc>
200d114: 80 a0 bf ff cmp %g2, -1
200d118: 12 80 00 4f bne 200d254 <rtems_bdbuf_remove_from_tree+0x308><== NEVER TAKEN
200d11c: 84 10 20 01 mov 1, %g2
{
/* rebalance right branch */
switch (p->avl.bal)
{
case +1:
p->avl.bal = 0;
200d120: 10 80 00 4d b 200d254 <rtems_bdbuf_remove_from_tree+0x308>
200d124: c0 28 60 11 clrb [ %g1 + 0x11 ]
p->avl.bal = 1;
modified = false;
break;
case +1:
p1 = p->avl.right;
200d128: c4 00 60 0c ld [ %g1 + 0xc ], %g2
if (p1->avl.bal >= 0) /* simple RR-turn */
200d12c: f4 48 a0 11 ldsb [ %g2 + 0x11 ], %i2
200d130: 80 a6 a0 00 cmp %i2, 0
200d134: 06 80 00 0a bl 200d15c <rtems_bdbuf_remove_from_tree+0x210>
200d138: c8 00 a0 08 ld [ %g2 + 8 ], %g4
{
p->avl.right = p1->avl.left;
200d13c: c8 20 60 0c st %g4, [ %g1 + 0xc ]
p1->avl.left = p;
if (p1->avl.bal == 0)
200d140: 80 a6 a0 00 cmp %i2, 0
200d144: 12 80 00 2d bne 200d1f8 <rtems_bdbuf_remove_from_tree+0x2ac>
200d148: c2 20 a0 08 st %g1, [ %g2 + 8 ]
{
p1->avl.bal = -1;
200d14c: f8 28 a0 11 stb %i4, [ %g2 + 0x11 ]
200d150: 82 10 00 02 mov %g2, %g1
modified = false;
200d154: 10 80 00 40 b 200d254 <rtems_bdbuf_remove_from_tree+0x308>
200d158: 84 10 20 00 clr %g2
}
else /* double RL-turn */
{
p2 = p1->avl.left;
p1->avl.left = p2->avl.right;
200d15c: f4 01 20 0c ld [ %g4 + 0xc ], %i2
p2->avl.right = p1;
200d160: c4 21 20 0c st %g2, [ %g4 + 0xc ]
}
else /* double RL-turn */
{
p2 = p1->avl.left;
p1->avl.left = p2->avl.right;
200d164: f4 20 a0 08 st %i2, [ %g2 + 8 ]
p2->avl.right = p1;
p->avl.right = p2->avl.left;
200d168: f4 01 20 08 ld [ %g4 + 8 ], %i2
p2->avl.left = p;
200d16c: 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;
200d170: 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;
200d174: f4 49 20 11 ldsb [ %g4 + 0x11 ], %i2
200d178: 80 a6 a0 01 cmp %i2, 1
200d17c: 32 80 00 03 bne,a 200d188 <rtems_bdbuf_remove_from_tree+0x23c>
200d180: c0 28 60 11 clrb [ %g1 + 0x11 ]
200d184: f8 28 60 11 stb %i4, [ %g1 + 0x11 ]
if (p2->avl.bal == -1) p1->avl.bal = 1; else p1->avl.bal = 0;
200d188: c2 49 20 11 ldsb [ %g4 + 0x11 ], %g1
200d18c: 80 a0 7f ff cmp %g1, -1
200d190: 32 80 00 2e bne,a 200d248 <rtems_bdbuf_remove_from_tree+0x2fc><== ALWAYS TAKEN
200d194: c0 28 a0 11 clrb [ %g2 + 0x11 ]
200d198: 10 80 00 2c b 200d248 <rtems_bdbuf_remove_from_tree+0x2fc><== NOT EXECUTED
200d19c: fa 28 a0 11 stb %i5, [ %g2 + 0x11 ] <== NOT EXECUTED
}
}
else
{
/* rebalance right branch */
switch (p->avl.bal)
200d1a0: 80 a0 a0 00 cmp %g2, 0
200d1a4: 22 bf ff ec be,a 200d154 <rtems_bdbuf_remove_from_tree+0x208>
200d1a8: f6 28 60 11 stb %i3, [ %g1 + 0x11 ]
200d1ac: 80 a0 a0 01 cmp %g2, 1
200d1b0: 02 80 00 06 be 200d1c8 <rtems_bdbuf_remove_from_tree+0x27c>
200d1b4: 80 a0 bf ff cmp %g2, -1
200d1b8: 32 80 00 27 bne,a 200d254 <rtems_bdbuf_remove_from_tree+0x308><== NEVER TAKEN
200d1bc: 84 10 20 01 mov 1, %g2 <== NOT EXECUTED
p->avl.bal = -1;
modified = false;
break;
case -1:
p1 = p->avl.left;
200d1c0: 10 80 00 04 b 200d1d0 <rtems_bdbuf_remove_from_tree+0x284>
200d1c4: c4 00 60 08 ld [ %g1 + 8 ], %g2
{
/* rebalance right branch */
switch (p->avl.bal)
{
case +1:
p->avl.bal = 0;
200d1c8: 10 80 00 22 b 200d250 <rtems_bdbuf_remove_from_tree+0x304>
200d1cc: c0 28 60 11 clrb [ %g1 + 0x11 ]
break;
case -1:
p1 = p->avl.left;
if (p1->avl.bal <= 0) /* simple LL-turn */
200d1d0: f8 48 a0 11 ldsb [ %g2 + 0x11 ], %i4
200d1d4: 80 a7 20 00 cmp %i4, 0
200d1d8: 14 80 00 0c bg 200d208 <rtems_bdbuf_remove_from_tree+0x2bc>
200d1dc: c8 00 a0 0c ld [ %g2 + 0xc ], %g4
{
p->avl.left = p1->avl.right;
200d1e0: c8 20 60 08 st %g4, [ %g1 + 8 ]
p1->avl.right = p;
if (p1->avl.bal == 0)
200d1e4: 80 a7 20 00 cmp %i4, 0
200d1e8: 12 80 00 04 bne 200d1f8 <rtems_bdbuf_remove_from_tree+0x2ac><== NEVER TAKEN
200d1ec: c2 20 a0 0c st %g1, [ %g2 + 0xc ]
{
p1->avl.bal = 1;
200d1f0: 10 bf ff d8 b 200d150 <rtems_bdbuf_remove_from_tree+0x204>
200d1f4: fa 28 a0 11 stb %i5, [ %g2 + 0x11 ]
modified = false;
}
else
{
p->avl.bal = 0;
200d1f8: c0 28 60 11 clrb [ %g1 + 0x11 ]
p1->avl.bal = 0;
200d1fc: c0 28 a0 11 clrb [ %g2 + 0x11 ]
200d200: 10 80 00 14 b 200d250 <rtems_bdbuf_remove_from_tree+0x304>
200d204: 82 10 00 02 mov %g2, %g1
}
else /* double LR-turn */
{
p2 = p1->avl.right;
p1->avl.right = p2->avl.left;
200d208: f8 01 20 08 ld [ %g4 + 8 ], %i4
p2->avl.left = p1;
200d20c: c4 21 20 08 st %g2, [ %g4 + 8 ]
}
else /* double LR-turn */
{
p2 = p1->avl.right;
p1->avl.right = p2->avl.left;
200d210: f8 20 a0 0c st %i4, [ %g2 + 0xc ]
p2->avl.left = p1;
p->avl.left = p2->avl.right;
200d214: f8 01 20 0c ld [ %g4 + 0xc ], %i4
p2->avl.right = p;
200d218: 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;
200d21c: 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;
200d220: f8 49 20 11 ldsb [ %g4 + 0x11 ], %i4
200d224: 80 a7 3f ff cmp %i4, -1
200d228: 32 80 00 03 bne,a 200d234 <rtems_bdbuf_remove_from_tree+0x2e8>
200d22c: c0 28 60 11 clrb [ %g1 + 0x11 ]
200d230: fa 28 60 11 stb %i5, [ %g1 + 0x11 ]
if (p2->avl.bal == +1) p1->avl.bal = -1; else p1->avl.bal = 0;
200d234: c2 49 20 11 ldsb [ %g4 + 0x11 ], %g1
200d238: 80 a0 60 01 cmp %g1, 1
200d23c: 32 80 00 03 bne,a 200d248 <rtems_bdbuf_remove_from_tree+0x2fc>
200d240: c0 28 a0 11 clrb [ %g2 + 0x11 ]
200d244: f6 28 a0 11 stb %i3, [ %g2 + 0x11 ]
p = p2;
p2->avl.bal = 0;
200d248: c0 29 20 11 clrb [ %g4 + 0x11 ]
200d24c: 82 10 00 04 mov %g4, %g1
}
}
else
{
/* rebalance right branch */
switch (p->avl.bal)
200d250: 84 10 20 01 mov 1, %g2
{
return bdbuf_cache.buffer_waiters.count;
}
static void
rtems_bdbuf_remove_from_tree (rtems_bdbuf_buffer *bd)
200d254: 88 00 ff fc add %g3, -4, %g4
default:
break;
}
}
if (buf_prev > buf_stack)
200d258: 80 a1 00 19 cmp %g4, %i1
200d25c: 28 80 00 09 bleu,a 200d280 <rtems_bdbuf_remove_from_tree+0x334>
200d260: 05 00 80 86 sethi %hi(0x2021800), %g2
{
q = *(buf_prev - 1);
200d264: c8 00 ff f8 ld [ %g3 + -8 ], %g4
if (q->avl.cache == -1)
200d268: f8 49 20 10 ldsb [ %g4 + 0x10 ], %i4
200d26c: 80 a7 3f ff cmp %i4, -1
200d270: 32 80 00 07 bne,a 200d28c <rtems_bdbuf_remove_from_tree+0x340>
200d274: c2 21 20 0c st %g1, [ %g4 + 0xc ]
{
q->avl.left = p;
200d278: 10 80 00 05 b 200d28c <rtems_bdbuf_remove_from_tree+0x340>
200d27c: c2 21 20 08 st %g1, [ %g4 + 8 ]
q->avl.right = p;
}
}
else
{
*root = p;
200d280: c2 20 a0 c8 st %g1, [ %g2 + 0xc8 ]
200d284: 81 c7 e0 08 ret
200d288: 81 e8 00 00 restore
*root = q;
}
modified = true;
while (modified)
200d28c: 80 88 a0 ff btst 0xff, %g2
200d290: 12 bf ff 95 bne 200d0e4 <rtems_bdbuf_remove_from_tree+0x198>
200d294: 86 00 ff fc add %g3, -4, %g3
200d298: 81 c7 e0 08 ret
200d29c: 81 e8 00 00 restore
}
q = p;
buf_prev--;
if (buf_prev > buf_stack)
200d2a0: 80 a0 c0 01 cmp %g3, %g1
200d2a4: 08 bf ff 51 bleu 200cfe8 <rtems_bdbuf_remove_from_tree+0x9c>
200d2a8: b8 10 20 00 clr %i4
{
p = *(buf_prev - 1);
200d2ac: 10 bf ff 4f b 200cfe8 <rtems_bdbuf_remove_from_tree+0x9c>
200d2b0: f8 01 3f f8 ld [ %g4 + -8 ], %i4
0200d3b4 <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)
{
200d3b4: 9d e3 bf a0 save %sp, -96, %sp
switch (bd->state)
200d3b8: d0 06 20 20 ld [ %i0 + 0x20 ], %o0
200d3bc: 80 a2 20 00 cmp %o0, 0
200d3c0: 22 80 00 0b be,a 200d3ec <rtems_bdbuf_remove_from_tree_and_lru_list+0x38>
200d3c4: c4 06 00 00 ld [ %i0 ], %g2
200d3c8: 80 a2 20 02 cmp %o0, 2
200d3cc: 12 80 00 06 bne 200d3e4 <rtems_bdbuf_remove_from_tree_and_lru_list+0x30><== NEVER TAKEN
200d3d0: 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);
200d3d4: 7f ff fe de call 200cf4c <rtems_bdbuf_remove_from_tree>
200d3d8: 90 10 00 18 mov %i0, %o0
break;
200d3dc: 10 80 00 04 b 200d3ec <rtems_bdbuf_remove_from_tree_and_lru_list+0x38>
200d3e0: c4 06 00 00 ld [ %i0 ], %g2
default:
rtems_bdbuf_fatal (bd->state, RTEMS_BLKDEV_FATAL_BDBUF_STATE_10);
200d3e4: 7f ff fe 05 call 200cbf8 <rtems_bdbuf_fatal> <== NOT EXECUTED
200d3e8: 92 12 60 08 or %o1, 8, %o1 <== NOT EXECUTED
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
previous = the_node->previous;
200d3ec: c2 06 20 04 ld [ %i0 + 4 ], %g1
next->previous = previous;
200d3f0: c2 20 a0 04 st %g1, [ %g2 + 4 ]
previous->next = next;
200d3f4: c4 20 40 00 st %g2, [ %g1 ]
200d3f8: 81 c7 e0 08 ret
200d3fc: 81 e8 00 00 restore
0200f174 <rtems_bdbuf_reset_device_stats>:
}
void rtems_bdbuf_reset_device_stats (rtems_disk_device *dd)
{
200f174: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED
rtems_bdbuf_lock_cache ();
200f178: 7f ff f6 99 call 200cbdc <rtems_bdbuf_lock_cache> <== NOT EXECUTED
200f17c: 01 00 00 00 nop <== NOT EXECUTED
memset (&dd->stats, 0, sizeof(dd->stats));
200f180: 90 06 20 44 add %i0, 0x44, %o0 <== NOT EXECUTED
200f184: 92 10 20 00 clr %o1 <== NOT EXECUTED
200f188: 40 00 15 09 call 20145ac <memset> <== NOT EXECUTED
200f18c: 94 10 20 20 mov 0x20, %o2 <== NOT EXECUTED
rtems_bdbuf_unlock_cache ();
200f190: 7f ff f6 a9 call 200cc34 <rtems_bdbuf_unlock_cache> <== NOT EXECUTED
200f194: 81 e8 00 00 restore <== NOT EXECUTED
0200cd18 <rtems_bdbuf_restore_preemption>:
static void
rtems_bdbuf_restore_preemption (rtems_mode prev_mode)
{
200cd18: 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);
200cd1c: 13 00 00 3f sethi %hi(0xfc00), %o1
return prev_mode;
}
static void
rtems_bdbuf_restore_preemption (rtems_mode prev_mode)
{
200cd20: 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);
200cd24: 90 10 00 18 mov %i0, %o0
200cd28: 92 12 63 ff or %o1, 0x3ff, %o1
200cd2c: 40 00 11 2e call 20111e4 <rtems_task_mode>
200cd30: 94 07 a0 44 add %fp, 0x44, %o2
if (sc != RTEMS_SUCCESSFUL)
200cd34: 80 a2 20 00 cmp %o0, 0
200cd38: 02 80 00 04 be 200cd48 <rtems_bdbuf_restore_preemption+0x30><== ALWAYS TAKEN
200cd3c: 11 10 80 00 sethi %hi(0x42000000), %o0
rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_PREEMPT_RST);
200cd40: 7f ff f1 9f call 20093bc <rtems_fatal_error_occurred> <== NOT EXECUTED
200cd44: 90 12 20 11 or %o0, 0x11, %o0 ! 42000011 <RAM_END+0x3fc00011><== NOT EXECUTED
200cd48: 81 c7 e0 08 ret
200cd4c: 81 e8 00 00 restore
0200f064 <rtems_bdbuf_set_block_size>:
}
rtems_status_code
rtems_bdbuf_set_block_size (rtems_disk_device *dd, uint32_t block_size)
{
200f064: 9d e3 bf a0 save %sp, -96, %sp
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_bdbuf_lock_cache ();
200f068: 7f ff f6 dd call 200cbdc <rtems_bdbuf_lock_cache>
200f06c: ba 10 00 18 mov %i0, %i5
if (block_size > 0)
200f070: 80 a6 60 00 cmp %i1, 0
200f074: 02 80 00 33 be 200f140 <rtems_bdbuf_set_block_size+0xdc>
200f078: 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)
200f07c: 03 00 80 7b sethi %hi(0x201ec00), %g1
200f080: 82 10 61 50 or %g1, 0x150, %g1 ! 201ed50 <rtems_bdbuf_configuration>
200f084: c4 00 60 28 ld [ %g1 + 0x28 ], %g2
200f088: 80 a6 40 02 cmp %i1, %g2
200f08c: 18 80 00 2d bgu 200f140 <rtems_bdbuf_set_block_size+0xdc> <== NEVER TAKEN
200f090: 01 00 00 00 nop
return 0;
bufs_per_size = ((size - 1) / bdbuf_config.buffer_min) + 1;
200f094: d2 00 60 24 ld [ %g1 + 0x24 ], %o1
200f098: 40 00 36 27 call 201c934 <.udiv>
200f09c: 90 06 7f ff add %i1, -1, %o0
for (bds_per_size = 1;
200f0a0: 92 10 20 01 mov 1, %o1
200f0a4: 90 02 20 01 inc %o0
200f0a8: 80 a2 40 08 cmp %o1, %o0
200f0ac: 2a bf ff ff bcs,a 200f0a8 <rtems_bdbuf_set_block_size+0x44>
200f0b0: 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;
200f0b4: 03 00 80 86 sethi %hi(0x2021800), %g1
200f0b8: d0 00 60 ac ld [ %g1 + 0xac ], %o0 ! 20218ac <bdbuf_cache+0x20>
200f0bc: 40 00 36 1e call 201c934 <.udiv>
200f0c0: 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)
200f0c4: 80 a2 20 00 cmp %o0, 0
200f0c8: 02 80 00 1e be 200f140 <rtems_bdbuf_set_block_size+0xdc> <== NEVER TAKEN
200f0cc: 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;
200f0d0: f0 07 60 20 ld [ %i5 + 0x20 ], %i0
200f0d4: 90 10 00 19 mov %i1, %o0
200f0d8: 40 00 36 17 call 201c934 <.udiv>
200f0dc: 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;
200f0e0: b8 10 20 00 clr %i4
uint32_t media_blocks_per_block = block_size / dd->media_block_size;
200f0e4: b6 10 00 08 mov %o0, %i3
200f0e8: 84 10 20 01 mov 1, %g2
uint32_t one = 1;
while ((one << block_to_media_block_shift) < media_blocks_per_block)
200f0ec: 83 28 80 1c sll %g2, %i4, %g1
200f0f0: 80 a0 40 1b cmp %g1, %i3
200f0f4: 2a bf ff fe bcs,a 200f0ec <rtems_bdbuf_set_block_size+0x88>
200f0f8: b8 07 20 01 inc %i4
{
++block_to_media_block_shift;
}
if ((dd->media_block_size << block_to_media_block_shift) != block_size)
200f0fc: b1 2e 00 1c sll %i0, %i4, %i0
200f100: 80 a6 00 19 cmp %i0, %i1
200f104: 32 80 00 02 bne,a 200f10c <rtems_bdbuf_set_block_size+0xa8><== NEVER TAKEN
200f108: 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;
200f10c: d0 07 60 1c ld [ %i5 + 0x1c ], %o0
200f110: 92 10 00 1b mov %i3, %o1
200f114: 40 00 36 08 call 201c934 <.udiv>
200f118: f2 27 60 24 st %i1, [ %i5 + 0x24 ]
dd->media_blocks_per_block = media_blocks_per_block;
200f11c: 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;
200f120: 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;
200f124: f8 27 60 30 st %i4, [ %i5 + 0x30 ]
dd->bds_per_group = bds_per_group;
200f128: 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);
200f12c: 7f ff fc be call 200e424 <rtems_bdbuf_read_ahead_cancel>
200f130: 90 10 00 1d mov %i5, %o0
dd->read_ahead.trigger = RTEMS_DISK_READ_AHEAD_NO_TRIGGER;
200f134: 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;
200f138: 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;
200f13c: c2 27 60 6c st %g1, [ %i5 + 0x6c ]
else
{
sc = RTEMS_INVALID_NUMBER;
}
rtems_bdbuf_unlock_cache ();
200f140: 7f ff f6 bd call 200cc34 <rtems_bdbuf_unlock_cache>
200f144: 01 00 00 00 nop
return sc;
}
200f148: 81 c7 e0 08 ret
200f14c: 81 e8 00 00 restore
0200d9d4 <rtems_bdbuf_swapout_modified_processing>:
rtems_chain_control* chain,
rtems_chain_control* transfer,
bool sync_active,
bool update_timers,
uint32_t timer_delta)
{
200d9d4: 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;
200d9d8: 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 );
200d9dc: b2 06 60 04 add %i1, 4, %i1
if (!rtems_chain_is_empty (chain))
200d9e0: 80 a0 40 19 cmp %g1, %i1
200d9e4: 02 80 00 4e be 200db1c <rtems_bdbuf_swapout_modified_processing+0x148>
200d9e8: 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))
200d9ec: 02 80 00 05 be 200da00 <rtems_bdbuf_swapout_modified_processing+0x2c>
200d9f0: 84 10 20 00 clr %g2
200d9f4: c4 06 00 00 ld [ %i0 ], %g2
200d9f8: 80 a0 00 02 cmp %g0, %g2
200d9fc: 84 60 3f ff subx %g0, -1, %g2
}
static bool
rtems_bdbuf_has_buffer_waiters (void)
{
return bdbuf_cache.buffer_waiters.count;
200da00: 07 00 80 86 sethi %hi(0x2021800), %g3
200da04: de 00 e1 00 ld [ %g3 + 0x100 ], %o7 ! 2021900 <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))
200da08: 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;
200da0c: 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))
200da10: 80 a3 60 00 cmp %o5, 0
200da14: 32 80 00 0d bne,a 200da48 <rtems_bdbuf_swapout_modified_processing+0x74>
200da18: c0 20 60 2c clr [ %g1 + 0x2c ]
200da1c: 80 a6 e0 00 cmp %i3, 0
200da20: 02 80 00 07 be 200da3c <rtems_bdbuf_swapout_modified_processing+0x68>
200da24: 80 a3 e0 00 cmp %o7, 0
200da28: c6 06 00 00 ld [ %i0 ], %g3
200da2c: c4 00 60 14 ld [ %g1 + 0x14 ], %g2
200da30: 80 a0 c0 02 cmp %g3, %g2
200da34: 02 80 00 04 be 200da44 <rtems_bdbuf_swapout_modified_processing+0x70>
200da38: 80 a3 e0 00 cmp %o7, 0
|| rtems_bdbuf_has_buffer_waiters ())
200da3c: 22 80 00 04 be,a 200da4c <rtems_bdbuf_swapout_modified_processing+0x78>
200da40: c4 00 60 2c ld [ %g1 + 0x2c ], %g2
bd->hold_timer = 0;
200da44: c0 20 60 2c clr [ %g1 + 0x2c ]
if (bd->hold_timer)
200da48: c4 00 60 2c ld [ %g1 + 0x2c ], %g2
200da4c: 80 a0 a0 00 cmp %g2, 0
200da50: 22 80 00 10 be,a 200da90 <rtems_bdbuf_swapout_modified_processing+0xbc>
200da54: c4 06 00 00 ld [ %i0 ], %g2
{
if (update_timers)
200da58: 80 a7 20 00 cmp %i4, 0
200da5c: 22 80 00 08 be,a 200da7c <rtems_bdbuf_swapout_modified_processing+0xa8>
200da60: c4 00 60 2c ld [ %g1 + 0x2c ], %g2
{
if (bd->hold_timer > timer_delta)
200da64: 80 a0 80 1d cmp %g2, %i5
200da68: 28 80 00 04 bleu,a 200da78 <rtems_bdbuf_swapout_modified_processing+0xa4>
200da6c: c0 20 60 2c clr [ %g1 + 0x2c ]
bd->hold_timer -= timer_delta;
200da70: 84 20 80 1d sub %g2, %i5, %g2
200da74: c4 20 60 2c st %g2, [ %g1 + 0x2c ]
else
bd->hold_timer = 0;
}
if (bd->hold_timer)
200da78: c4 00 60 2c ld [ %g1 + 0x2c ], %g2
200da7c: 80 a0 a0 00 cmp %g2, 0
200da80: 22 80 00 04 be,a 200da90 <rtems_bdbuf_swapout_modified_processing+0xbc>
200da84: c4 06 00 00 ld [ %i0 ], %g2
{
node = node->next;
continue;
200da88: 10 80 00 22 b 200db10 <rtems_bdbuf_swapout_modified_processing+0x13c>
200da8c: 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)
200da90: 80 a0 a0 00 cmp %g2, 0
200da94: 32 80 00 05 bne,a 200daa8 <rtems_bdbuf_swapout_modified_processing+0xd4>
200da98: c6 00 60 14 ld [ %g1 + 0x14 ], %g3
*dd_ptr = bd->dd;
200da9c: c4 00 60 14 ld [ %g1 + 0x14 ], %g2
200daa0: c4 26 00 00 st %g2, [ %i0 ]
if (bd->dd == *dd_ptr)
200daa4: c6 00 60 14 ld [ %g1 + 0x14 ], %g3
200daa8: c4 06 00 00 ld [ %i0 ], %g2
200daac: 80 a0 c0 02 cmp %g3, %g2
200dab0: 12 80 00 17 bne 200db0c <rtems_bdbuf_swapout_modified_processing+0x138><== NEVER TAKEN
200dab4: c6 00 40 00 ld [ %g1 ], %g3
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
previous = the_node->previous;
200dab8: 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;
200dabc: d8 20 60 20 st %o4, [ %g1 + 0x20 ]
next->previous = previous;
200dac0: c4 20 e0 04 st %g2, [ %g3 + 4 ]
previous->next = next;
200dac4: c6 20 80 00 st %g3, [ %g2 ]
rtems_bdbuf_set_state (bd, RTEMS_BDBUF_STATE_TRANSFER);
rtems_chain_extract_unprotected (node);
tnode = tnode->previous;
200dac8: 10 80 00 0c b 200daf8 <rtems_bdbuf_swapout_modified_processing+0x124>
200dacc: 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)
200dad0: c8 00 a0 18 ld [ %g2 + 0x18 ], %g4
200dad4: 80 a2 c0 04 cmp %o3, %g4
200dad8: 28 80 00 08 bleu,a 200daf8 <rtems_bdbuf_swapout_modified_processing+0x124>
200dadc: c4 00 a0 04 ld [ %g2 + 4 ], %g2
)
{
Chain_Node *before_node;
the_node->previous = after_node;
before_node = after_node->next;
200dae0: c8 00 80 00 ld [ %g2 ], %g4
Chain_Node *the_node
)
{
Chain_Node *before_node;
the_node->previous = after_node;
200dae4: c4 20 60 04 st %g2, [ %g1 + 4 ]
before_node = after_node->next;
after_node->next = the_node;
200dae8: c2 20 80 00 st %g1, [ %g2 ]
the_node->next = before_node;
200daec: c8 20 40 00 st %g4, [ %g1 ]
before_node->previous = the_node;
200daf0: 10 80 00 07 b 200db0c <rtems_bdbuf_swapout_modified_processing+0x138>
200daf4: c2 21 20 04 st %g1, [ %g4 + 4 ]
rtems_chain_extract_unprotected (node);
tnode = tnode->previous;
while (node && !rtems_chain_is_head (transfer, tnode))
200daf8: 80 a0 80 1a cmp %g2, %i2
200dafc: 32 bf ff f5 bne,a 200dad0 <rtems_bdbuf_swapout_modified_processing+0xfc>
200db00: d6 00 60 18 ld [ %g1 + 0x18 ], %o3
)
{
Chain_Node *before_node;
the_node->previous = after_node;
before_node = after_node->next;
200db04: 10 80 00 08 b 200db24 <rtems_bdbuf_swapout_modified_processing+0x150>
200db08: c4 06 80 00 ld [ %i2 ], %g2
node = next_node;
}
else
{
node = node->next;
200db0c: 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))
200db10: 80 a0 40 19 cmp %g1, %i1
200db14: 12 bf ff c0 bne 200da14 <rtems_bdbuf_swapout_modified_processing+0x40>
200db18: 80 a3 60 00 cmp %o5, 0
200db1c: 81 c7 e0 08 ret
200db20: 81 e8 00 00 restore
Chain_Node *the_node
)
{
Chain_Node *before_node;
the_node->previous = after_node;
200db24: f4 20 60 04 st %i2, [ %g1 + 4 ]
before_node = after_node->next;
after_node->next = the_node;
200db28: c2 26 80 00 st %g1, [ %i2 ]
the_node->next = before_node;
200db2c: c4 20 40 00 st %g2, [ %g1 ]
before_node->previous = the_node;
200db30: 10 bf ff f7 b 200db0c <rtems_bdbuf_swapout_modified_processing+0x138>
200db34: c2 20 a0 04 st %g1, [ %g2 + 4 ]
0200de5c <rtems_bdbuf_swapout_task>:
* not this.
* @return rtems_task Not used.
*/
static rtems_task
rtems_bdbuf_swapout_task (rtems_task_argument arg)
{
200de5c: 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;
200de60: 33 00 80 7b sethi %hi(0x201ec00), %i1
200de64: b2 16 61 50 or %i1, 0x150, %i1 ! 201ed50 <rtems_bdbuf_configuration>
uint32_t timer_delta;
transfer.write_req = rtems_bdbuf_swapout_writereq_alloc ();
200de68: 7f ff fb e6 call 200ce00 <rtems_bdbuf_swapout_writereq_alloc>
200de6c: 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;
200de70: 82 07 bf ec add %fp, -20, %g1
200de74: c2 27 bf e8 st %g1, [ %fp + -24 ]
head->previous = NULL;
tail->previous = head;
200de78: 82 07 bf e8 add %fp, -24, %g1
200de7c: 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);
200de80: 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 ();
200de84: 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);
200de88: 91 2e e0 07 sll %i3, 7, %o0
200de8c: 90 22 00 01 sub %o0, %g1, %o0
200de90: 03 00 80 83 sethi %hi(0x2020c00), %g1
200de94: d2 00 62 ac ld [ %g1 + 0x2ac ], %o1 ! 2020eac <Configuration+0x10>
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
head->previous = NULL;
200de98: 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;
200de9c: c0 27 bf f4 clr [ %fp + -12 ]
transfer.syncing = false;
200dea0: c0 2f bf f8 clrb [ %fp + -8 ]
/*
* Localise the period.
*/
period_in_ticks = RTEMS_MICROSECONDS_TO_TICKS (period_in_msecs * 1000);
200dea4: 90 02 00 1b add %o0, %i3, %o0
200dea8: 40 00 3a a3 call 201c934 <.udiv>
200deac: 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;
200deb0: 35 00 80 86 sethi %hi(0x2021800), %i2
200deb4: a0 10 00 08 mov %o0, %l0
rtems_bdbuf_swapout_workers_open (void)
{
rtems_status_code sc;
size_t w;
rtems_bdbuf_lock_cache ();
200deb8: 7f ff fb 49 call 200cbdc <rtems_bdbuf_lock_cache>
200debc: b4 16 a0 8c or %i2, 0x8c, %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),
200dec0: 27 10 91 1b sethi %hi(0x42446c00), %l3
200dec4: 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++)
200dec8: b8 10 20 00 clr %i4
200decc: f0 06 60 14 ld [ %i1 + 0x14 ], %i0
the_node->next = tail;
200ded0: 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;
200ded4: 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),
200ded8: a6 14 e3 00 or %l3, 0x300, %l3
200dedc: 10 80 00 25 b 200df70 <rtems_bdbuf_swapout_task+0x114>
200dee0: a8 15 21 94 or %l4, 0x194, %l4
for (w = 0; w < bdbuf_config.swapout_workers; w++)
{
rtems_bdbuf_swapout_worker* worker;
worker = malloc (sizeof (rtems_bdbuf_swapout_worker));
200dee4: 7f ff dc 2f call 2004fa0 <malloc> <== NOT EXECUTED
200dee8: 90 10 20 28 mov 0x28, %o0 <== NOT EXECUTED
if (!worker)
200deec: ba 92 20 00 orcc %o0, 0, %i5 <== NOT EXECUTED
200def0: 32 80 00 05 bne,a 200df04 <rtems_bdbuf_swapout_task+0xa8><== NOT EXECUTED
200def4: c2 06 a0 10 ld [ %i2 + 0x10 ], %g1 <== NOT EXECUTED
rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_SO_NOMEM);
200def8: 11 10 80 00 sethi %hi(0x42000000), %o0 <== NOT EXECUTED
200defc: 10 80 00 1b b 200df68 <rtems_bdbuf_swapout_task+0x10c> <== NOT EXECUTED
200df00: 90 12 20 15 or %o0, 0x15, %o0 ! 42000015 <RAM_END+0x3fc00015><== NOT EXECUTED
200df04: e2 27 40 00 st %l1, [ %i5 ] <== NOT EXECUTED
tail->previous = the_node;
old_last->next = the_node;
200df08: fa 20 40 00 st %i5, [ %g1 ] <== NOT EXECUTED
the_node->previous = old_last;
200df0c: 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;
200df10: 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 ();
200df14: 7f ff fb bb call 200ce00 <rtems_bdbuf_swapout_writereq_alloc><== NOT EXECUTED
200df18: 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),
200df1c: 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 );
200df20: 82 07 60 10 add %i5, 0x10, %g1 <== NOT EXECUTED
200df24: 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 ();
200df28: d0 27 60 24 st %o0, [ %i5 + 0x24 ] <== NOT EXECUTED
head->next = tail;
200df2c: c4 27 60 10 st %g2, [ %i5 + 0x10 ] <== NOT EXECUTED
head->previous = NULL;
200df30: c0 27 60 14 clr [ %i5 + 0x14 ] <== NOT EXECUTED
tail->previous = head;
200df34: c2 27 60 18 st %g1, [ %i5 + 0x18 ] <== NOT EXECUTED
rtems_chain_initialize_empty (&worker->transfer.bds);
worker->transfer.dd = BDBUF_INVALID_DEV;
200df38: 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)
200df3c: 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),
200df40: 94 10 00 14 mov %l4, %o2 <== NOT EXECUTED
200df44: 90 12 00 13 or %o0, %l3, %o0 <== NOT EXECUTED
200df48: 96 10 00 1d mov %i5, %o3 <== NOT EXECUTED
200df4c: 7f ff fb e9 call 200cef0 <rtems_bdbuf_create_task.constprop.10><== NOT EXECUTED
200df50: 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)
200df54: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
200df58: 22 80 00 06 be,a 200df70 <rtems_bdbuf_swapout_task+0x114><== NOT EXECUTED
200df5c: b8 07 20 01 inc %i4 <== NOT EXECUTED
rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_SO_WK_CREATE);
200df60: 11 10 80 00 sethi %hi(0x42000000), %o0 <== NOT EXECUTED
200df64: 90 12 20 16 or %o0, 0x16, %o0 ! 42000016 <RAM_END+0x3fc00016><== NOT EXECUTED
200df68: 7f ff ed 15 call 20093bc <rtems_fatal_error_occurred> <== NOT EXECUTED
200df6c: 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++)
200df70: 80 a7 00 18 cmp %i4, %i0
200df74: 0a bf ff dc bcs 200dee4 <rtems_bdbuf_swapout_task+0x88> <== NEVER TAKEN
200df78: 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 ();
200df7c: 7f ff fb 2e call 200cc34 <rtems_bdbuf_unlock_cache>
200df80: 39 00 80 86 sethi %hi(0x2021800), %i4
/*
* Create the worker threads.
*/
rtems_bdbuf_swapout_workers_open ();
while (bdbuf_cache.swapout_enabled)
200df84: b8 17 20 8c or %i4, 0x8c, %i4 ! 202188c <bdbuf_cache>
200df88: 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,
200df8c: a4 07 20 58 add %i4, 0x58, %l2
timer_delta);
/*
* Process the cache's modified list.
*/
rtems_bdbuf_swapout_modified_processing (&transfer->dd,
200df90: 10 80 00 5d b 200e104 <rtems_bdbuf_swapout_task+0x2a8>
200df94: 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 ();
200df98: 7f ff fb 11 call 200cbdc <rtems_bdbuf_lock_cache>
200df9c: 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)
200dfa0: c2 0f 20 30 ldub [ %i4 + 0x30 ], %g1
200dfa4: 80 a0 60 00 cmp %g1, 0
200dfa8: 02 80 00 04 be 200dfb8 <rtems_bdbuf_swapout_task+0x15c>
200dfac: 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,
200dfb0: 10 80 00 08 b 200dfd0 <rtems_bdbuf_swapout_task+0x174>
200dfb4: ba 07 bf e8 add %fp, -24, %i5
200dfb8: 7f ff fa e9 call 200cb5c <_Chain_Get_unprotected>
200dfbc: 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)
200dfc0: b4 92 20 00 orcc %o0, 0, %i2
200dfc4: 22 bf ff fb be,a 200dfb0 <rtems_bdbuf_swapout_task+0x154><== ALWAYS TAKEN
200dfc8: b4 10 20 00 clr %i2
transfer = &worker->transfer;
200dfcc: 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 );
200dfd0: 82 07 60 04 add %i5, 4, %g1
head->next = tail;
200dfd4: c2 27 40 00 st %g1, [ %i5 ]
}
rtems_chain_initialize_empty (&transfer->bds);
transfer->dd = BDBUF_INVALID_DEV;
transfer->syncing = bdbuf_cache.sync_active;
200dfd8: c2 0f 20 30 ldub [ %i4 + 0x30 ], %g1
head->previous = NULL;
200dfdc: c0 27 60 04 clr [ %i5 + 4 ]
tail->previous = head;
200dfe0: fa 27 60 08 st %i5, [ %i5 + 8 ]
if (worker)
transfer = &worker->transfer;
}
rtems_chain_initialize_empty (&transfer->bds);
transfer->dd = BDBUF_INVALID_DEV;
200dfe4: 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)
200dfe8: 80 88 60 ff btst 0xff, %g1
200dfec: 02 80 00 04 be 200dffc <rtems_bdbuf_swapout_task+0x1a0>
200dff0: c2 2f 60 10 stb %g1, [ %i5 + 0x10 ]
transfer->dd = bdbuf_cache.sync_device;
200dff4: c2 07 20 38 ld [ %i4 + 0x38 ], %g1
200dff8: 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,
200dffc: b0 07 60 0c add %i5, 0xc, %i0
200e000: 92 10 00 12 mov %l2, %o1
200e004: 90 10 00 18 mov %i0, %o0
200e008: 94 10 00 1d mov %i5, %o2
200e00c: 96 10 20 01 mov 1, %o3
200e010: 98 10 20 00 clr %o4
200e014: 7f ff fe 70 call 200d9d4 <rtems_bdbuf_swapout_modified_processing>
200e018: 9a 10 00 1b mov %i3, %o5
timer_delta);
/*
* Process the cache's modified list.
*/
rtems_bdbuf_swapout_modified_processing (&transfer->dd,
200e01c: d6 0f 20 30 ldub [ %i4 + 0x30 ], %o3
200e020: 90 10 00 18 mov %i0, %o0
200e024: 92 10 00 13 mov %l3, %o1
200e028: 94 10 00 1d mov %i5, %o2
200e02c: 98 0e 60 01 and %i1, 1, %o4
200e030: 7f ff fe 69 call 200d9d4 <rtems_bdbuf_swapout_modified_processing>
200e034: 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 ();
200e038: 7f ff fa ff call 200cc34 <rtems_bdbuf_unlock_cache>
200e03c: 01 00 00 00 nop
/*
* If there are buffers to transfer to the media transfer them.
*/
if (!rtems_chain_is_empty (&transfer->bds))
200e040: 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 );
200e044: 82 07 60 04 add %i5, 4, %g1
200e048: 80 a0 80 01 cmp %g2, %g1
200e04c: 02 80 00 11 be 200e090 <rtems_bdbuf_swapout_task+0x234>
200e050: 80 a6 a0 00 cmp %i2, 0
{
if (worker)
200e054: 02 80 00 0b be 200e080 <rtems_bdbuf_swapout_task+0x224> <== ALWAYS TAKEN
200e058: 01 00 00 00 nop
{
rtems_status_code sc = rtems_event_send (worker->id,
200e05c: d0 06 a0 08 ld [ %i2 + 8 ], %o0 <== NOT EXECUTED
200e060: 7f ff e9 f3 call 200882c <rtems_event_send> <== NOT EXECUTED
200e064: 92 10 20 04 mov 4, %o1 <== NOT EXECUTED
RTEMS_BDBUF_SWAPOUT_SYNC);
if (sc != RTEMS_SUCCESSFUL)
200e068: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
200e06c: 02 80 00 0a be 200e094 <rtems_bdbuf_swapout_task+0x238> <== NOT EXECUTED
200e070: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED
rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_SO_WAKE);
200e074: 11 10 80 00 sethi %hi(0x42000000), %o0 <== NOT EXECUTED
200e078: 10 bf ff bc b 200df68 <rtems_bdbuf_swapout_task+0x10c> <== NOT EXECUTED
200e07c: 90 12 20 14 or %o0, 0x14, %o0 ! 42000014 <RAM_END+0x3fc00014><== NOT EXECUTED
}
else
{
rtems_bdbuf_swapout_write (transfer);
200e080: 7f ff ff 1f call 200dcfc <rtems_bdbuf_swapout_write>
200e084: 90 10 00 1d mov %i5, %o0
}
transfered_buffers = true;
200e088: 10 80 00 03 b 200e094 <rtems_bdbuf_swapout_task+0x238>
200e08c: 82 10 20 01 mov 1, %g1
200e090: 82 10 20 00 clr %g1
}
if (bdbuf_cache.sync_active && !transfered_buffers)
200e094: c4 0f 20 30 ldub [ %i4 + 0x30 ], %g2
200e098: b2 10 20 00 clr %i1
200e09c: 80 a0 a0 00 cmp %g2, 0
200e0a0: 02 80 00 13 be 200e0ec <rtems_bdbuf_swapout_task+0x290>
200e0a4: 82 08 60 ff and %g1, 0xff, %g1
200e0a8: 80 a0 60 00 cmp %g1, 0
200e0ac: 12 bf ff bb bne 200df98 <rtems_bdbuf_swapout_task+0x13c>
200e0b0: 01 00 00 00 nop
{
rtems_id sync_requester;
rtems_bdbuf_lock_cache ();
200e0b4: 7f ff fa ca call 200cbdc <rtems_bdbuf_lock_cache>
200e0b8: 01 00 00 00 nop
sync_requester = bdbuf_cache.sync_requester;
200e0bc: fa 07 20 34 ld [ %i4 + 0x34 ], %i5
bdbuf_cache.sync_active = false;
200e0c0: c0 2f 20 30 clrb [ %i4 + 0x30 ]
bdbuf_cache.sync_requester = 0;
rtems_bdbuf_unlock_cache ();
200e0c4: 7f ff fa dc call 200cc34 <rtems_bdbuf_unlock_cache>
200e0c8: c0 27 20 34 clr [ %i4 + 0x34 ]
if (sync_requester)
200e0cc: 80 a7 60 00 cmp %i5, 0
200e0d0: 22 80 00 25 be,a 200e164 <rtems_bdbuf_swapout_task+0x308><== NEVER TAKEN
200e0d4: 90 10 20 04 mov 4, %o0 <== NOT EXECUTED
rtems_event_send (sync_requester, RTEMS_BDBUF_TRANSFER_SYNC);
200e0d8: 90 10 00 1d mov %i5, %o0
200e0dc: 7f ff e9 d4 call 200882c <rtems_event_send>
200e0e0: 92 10 20 02 mov 2, %o1
*/
update_timers = false;
}
while (transfered_buffers);
sc = rtems_event_receive (RTEMS_BDBUF_SWAPOUT_SYNC,
200e0e4: 10 80 00 20 b 200e164 <rtems_bdbuf_swapout_task+0x308>
200e0e8: 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,
200e0ec: 80 a0 60 00 cmp %g1, 0
200e0f0: 02 80 00 1d be 200e164 <rtems_bdbuf_swapout_task+0x308>
200e0f4: 90 10 20 04 mov 4, %o0
200e0f8: 30 bf ff a8 b,a 200df98 <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);
200e0fc: 10 bf ff 9b b 200df68 <rtems_bdbuf_swapout_task+0x10c> <== NOT EXECUTED
200e100: 90 12 20 18 or %o0, 0x18, %o0 <== NOT EXECUTED
/*
* Create the worker threads.
*/
rtems_bdbuf_swapout_workers_open ();
while (bdbuf_cache.swapout_enabled)
200e104: c2 0f 20 04 ldub [ %i4 + 4 ], %g1
200e108: 80 a0 60 00 cmp %g1, 0
200e10c: 12 bf ff a3 bne 200df98 <rtems_bdbuf_swapout_task+0x13c> <== ALWAYS TAKEN
200e110: b2 10 20 01 mov 1, %i1
static void
rtems_bdbuf_swapout_workers_close (void)
{
rtems_chain_node* node;
rtems_bdbuf_lock_cache ();
200e114: 7f ff fa b2 call 200cbdc <rtems_bdbuf_lock_cache> <== NOT EXECUTED
200e118: 01 00 00 00 nop <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return _Chain_Head( the_chain )->next;
200e11c: 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))
200e120: 10 80 00 06 b 200e138 <rtems_bdbuf_swapout_task+0x2dc> <== NOT EXECUTED
200e124: b8 07 20 0c add %i4, 0xc, %i4 <== NOT EXECUTED
{
rtems_bdbuf_swapout_worker* worker = (rtems_bdbuf_swapout_worker*) node;
worker->enabled = false;
200e128: c0 2f 60 0c clrb [ %i5 + 0xc ] <== NOT EXECUTED
rtems_event_send (worker->id, RTEMS_BDBUF_SWAPOUT_SYNC);
200e12c: 7f ff e9 c0 call 200882c <rtems_event_send> <== NOT EXECUTED
200e130: 92 10 20 04 mov 4, %o1 <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Next(
Chain_Node *the_node
)
{
return the_node->next;
200e134: 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))
200e138: 80 a7 40 1c cmp %i5, %i4 <== NOT EXECUTED
200e13c: 32 bf ff fb bne,a 200e128 <rtems_bdbuf_swapout_task+0x2cc><== NOT EXECUTED
200e140: 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 ();
200e144: 7f ff fa bc call 200cc34 <rtems_bdbuf_unlock_cache> <== NOT EXECUTED
200e148: 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);
200e14c: 7f ff da 3f call 2004a48 <free> <== NOT EXECUTED
200e150: d0 07 bf fc ld [ %fp + -4 ], %o0 <== NOT EXECUTED
rtems_task_delete (RTEMS_SELF);
200e154: 7f ff eb ae call 200900c <rtems_task_delete> <== NOT EXECUTED
200e158: 90 10 20 00 clr %o0 <== NOT EXECUTED
200e15c: 81 c7 e0 08 ret <== NOT EXECUTED
200e160: 81 e8 00 00 restore <== NOT EXECUTED
*/
update_timers = false;
}
while (transfered_buffers);
sc = rtems_event_receive (RTEMS_BDBUF_SWAPOUT_SYNC,
200e164: 92 10 20 00 clr %o1
200e168: 94 10 00 10 mov %l0, %o2
200e16c: 7f ff e9 4d call 20086a0 <rtems_event_receive>
200e170: 96 07 bf e4 add %fp, -28, %o3
RTEMS_EVENT_ALL | RTEMS_WAIT,
period_in_ticks,
&out);
if ((sc != RTEMS_SUCCESSFUL) && (sc != RTEMS_TIMEOUT))
200e174: 80 a2 20 06 cmp %o0, 6
200e178: 22 bf ff e4 be,a 200e108 <rtems_bdbuf_swapout_task+0x2ac>
200e17c: c2 0f 20 04 ldub [ %i4 + 4 ], %g1
200e180: 80 a2 20 00 cmp %o0, 0
200e184: 22 bf ff e1 be,a 200e108 <rtems_bdbuf_swapout_task+0x2ac><== ALWAYS TAKEN
200e188: c2 0f 20 04 ldub [ %i4 + 4 ], %g1
rtems_fatal_error_occurred (BLKDEV_FATAL_BDBUF_SWAPOUT_RE);
200e18c: 10 bf ff dc b 200e0fc <rtems_bdbuf_swapout_task+0x2a0> <== NOT EXECUTED
200e190: 11 10 80 00 sethi %hi(0x42000000), %o0 <== NOT EXECUTED
0200e194 <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)
{
200e194: 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;
200e198: 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);
200e19c: b8 06 20 10 add %i0, 0x10, %i4 <== NOT EXECUTED
200e1a0: ba 17 60 8c or %i5, 0x8c, %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 );
200e1a4: 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)
200e1a8: 10 80 00 12 b 200e1f0 <rtems_bdbuf_swapout_worker_task+0x5c><== NOT EXECUTED
200e1ac: b4 07 60 0c add %i5, 0xc, %i2 <== NOT EXECUTED
{
rtems_bdbuf_wait_for_event (RTEMS_BDBUF_SWAPOUT_SYNC);
200e1b0: 7f ff fa ba call 200cc98 <rtems_bdbuf_wait_for_event> <== NOT EXECUTED
200e1b4: 90 10 20 04 mov 4, %o0 <== NOT EXECUTED
rtems_bdbuf_swapout_write (&worker->transfer);
200e1b8: 7f ff fe d1 call 200dcfc <rtems_bdbuf_swapout_write> <== NOT EXECUTED
200e1bc: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
rtems_bdbuf_lock_cache ();
200e1c0: 7f ff fa 87 call 200cbdc <rtems_bdbuf_lock_cache> <== NOT EXECUTED
200e1c4: 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;
200e1c8: 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;
200e1cc: f6 26 20 10 st %i3, [ %i0 + 0x10 ] <== NOT EXECUTED
rtems_chain_initialize_empty (&worker->transfer.bds);
worker->transfer.dd = BDBUF_INVALID_DEV;
200e1d0: 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;
200e1d4: f4 26 00 00 st %i2, [ %i0 ] <== NOT EXECUTED
tail->previous = the_node;
200e1d8: 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;
200e1dc: c0 26 20 14 clr [ %i0 + 0x14 ] <== NOT EXECUTED
tail->previous = head;
200e1e0: 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;
200e1e4: f0 20 40 00 st %i0, [ %g1 ] <== NOT EXECUTED
rtems_chain_append_unprotected (&bdbuf_cache.swapout_workers, &worker->link);
rtems_bdbuf_unlock_cache ();
200e1e8: 7f ff fa 93 call 200cc34 <rtems_bdbuf_unlock_cache> <== NOT EXECUTED
200e1ec: 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)
200e1f0: c2 0e 20 0c ldub [ %i0 + 0xc ], %g1 <== NOT EXECUTED
200e1f4: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
200e1f8: 12 bf ff ee bne 200e1b0 <rtems_bdbuf_swapout_worker_task+0x1c><== NOT EXECUTED
200e1fc: 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);
200e200: 7f ff da 12 call 2004a48 <free> <== NOT EXECUTED
200e204: d0 06 20 24 ld [ %i0 + 0x24 ], %o0 <== NOT EXECUTED
free (worker);
200e208: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
200e20c: 7f ff da 0f call 2004a48 <free> <== NOT EXECUTED
200e210: b0 10 20 00 clr %i0 <== NOT EXECUTED
rtems_task_delete (RTEMS_SELF);
200e214: 7f ff eb 7e call 200900c <rtems_task_delete> <== NOT EXECUTED
200e218: 81 e8 00 00 restore <== NOT EXECUTED
0200dcfc <rtems_bdbuf_swapout_write>:
*
* @param transfer The transfer transaction.
*/
static void
rtems_bdbuf_swapout_write (rtems_bdbuf_swapout_transfer* transfer)
{
200dcfc: 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))
200dd00: 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 );
200dd04: b6 06 20 04 add %i0, 4, %i3
200dd08: 80 a0 40 1b cmp %g1, %i3
200dd0c: 02 80 00 52 be 200de54 <rtems_bdbuf_swapout_write+0x158> <== NEVER TAKEN
200dd10: 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;
200dd14: 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;
200dd18: 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;
200dd1c: f4 07 60 2c ld [ %i5 + 0x2c ], %i2
bool need_continuous_blocks =
(dd->phys_dev->capabilities & RTEMS_BLKDEV_CAP_MULTISECTOR_CONT) != 0;
200dd20: 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;
200dd24: 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;
200dd28: 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;
200dd2c: c4 20 60 0c st %g2, [ %g1 + 0xc ]
transfer->write_req->bufnum = 0;
200dd30: 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;
200dd34: 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;
200dd38: 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)
200dd3c: 10 80 00 35 b 200de10 <rtems_bdbuf_swapout_write+0x114>
200dd40: 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 &&
200dd44: 02 80 00 12 be 200dd8c <rtems_bdbuf_swapout_write+0x90>
200dd48: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
200dd4c: c4 00 60 10 ld [ %g1 + 0x10 ], %g2
200dd50: 80 a0 a0 00 cmp %g2, 0
200dd54: 22 80 00 0f be,a 200dd90 <rtems_bdbuf_swapout_write+0x94>
200dd58: c8 00 60 10 ld [ %g1 + 0x10 ], %g4
200dd5c: c6 02 20 18 ld [ %o0 + 0x18 ], %g3
bd->block != last_block + media_blocks_per_block)
200dd60: 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 &&
200dd64: 80 a0 c0 02 cmp %g3, %g2
200dd68: 22 80 00 0a be,a 200dd90 <rtems_bdbuf_swapout_write+0x94>
200dd6c: c8 00 60 10 ld [ %g1 + 0x10 ], %g4
)
{
Chain_Node *before_node;
the_node->previous = after_node;
before_node = after_node->next;
200dd70: c2 06 00 00 ld [ %i0 ], %g1
Chain_Node *the_node
)
{
Chain_Node *before_node;
the_node->previous = after_node;
200dd74: f0 22 20 04 st %i0, [ %o0 + 4 ]
before_node = after_node->next;
after_node->next = the_node;
200dd78: d0 26 00 00 st %o0, [ %i0 ]
the_node->next = before_node;
200dd7c: c2 22 00 00 st %g1, [ %o0 ]
before_node->previous = the_node;
200dd80: 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;
200dd84: 10 80 00 10 b 200ddc4 <rtems_bdbuf_swapout_write+0xc8>
200dd88: 82 10 20 01 mov 1, %g1
}
else
{
rtems_blkdev_sg_buffer* buf;
buf = &transfer->write_req->bufs[transfer->write_req->bufnum];
200dd8c: c8 00 60 10 ld [ %g1 + 0x10 ], %g4
transfer->write_req->bufnum++;
buf->user = bd;
buf->block = bd->block;
200dd90: 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];
200dd94: 87 29 20 04 sll %g4, 4, %g3
transfer->write_req->bufnum++;
200dd98: 88 01 20 01 inc %g4
200dd9c: 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];
200dda0: 86 00 e0 18 add %g3, 0x18, %g3
200dda4: 84 00 40 03 add %g1, %g3, %g2
transfer->write_req->bufnum++;
buf->user = bd;
buf->block = bd->block;
200dda8: f8 20 40 03 st %i4, [ %g1 + %g3 ]
buf->length = dd->block_size;
200ddac: 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;
200ddb0: d0 20 a0 0c st %o0, [ %g2 + 0xc ]
buf->block = bd->block;
buf->length = dd->block_size;
200ddb4: c2 20 a0 04 st %g1, [ %g2 + 4 ]
buf->buffer = bd->buffer;
200ddb8: c2 02 20 1c ld [ %o0 + 0x1c ], %g1
200ddbc: 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;
200ddc0: 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) ||
200ddc4: c4 06 00 00 ld [ %i0 ], %g2
200ddc8: 80 a0 80 1b cmp %g2, %i3
200ddcc: 02 80 00 0b be 200ddf8 <rtems_bdbuf_swapout_write+0xfc>
200ddd0: d2 06 20 14 ld [ %i0 + 0x14 ], %o1
(transfer->write_req->bufnum >= bdbuf_config.max_write_blocks))
200ddd4: 84 14 61 50 or %l1, 0x150, %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) ||
200ddd8: c6 02 60 10 ld [ %o1 + 0x10 ], %g3
200dddc: c4 00 a0 04 ld [ %g2 + 4 ], %g2
200dde0: 80 a0 c0 02 cmp %g3, %g2
200dde4: 1a 80 00 06 bcc 200ddfc <rtems_bdbuf_swapout_write+0x100>
200dde8: 90 10 00 1d mov %i5, %o0
(transfer->write_req->bufnum >= bdbuf_config.max_write_blocks))
write = true;
if (write)
200ddec: 80 88 60 ff btst 0xff, %g1
200ddf0: 02 80 00 08 be 200de10 <rtems_bdbuf_swapout_write+0x114>
200ddf4: 01 00 00 00 nop
{
rtems_bdbuf_execute_transfer_request (dd, transfer->write_req, false);
200ddf8: 90 10 00 1d mov %i5, %o0
200ddfc: 7f ff ff 4f call 200db38 <rtems_bdbuf_execute_transfer_request>
200de00: 94 10 20 00 clr %o2
transfer->write_req->status = RTEMS_RESOURCE_IN_USE;
200de04: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
200de08: e0 20 60 0c st %l0, [ %g1 + 0xc ]
transfer->write_req->bufnum = 0;
200de0c: 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 );
200de10: 7f ff fb 53 call 200cb5c <_Chain_Get_unprotected>
200de14: 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)
200de18: 80 a2 20 00 cmp %o0, 0
200de1c: 12 bf ff ca bne 200dd44 <rtems_bdbuf_swapout_write+0x48>
200de20: 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 &&
200de24: c2 0e 20 10 ldub [ %i0 + 0x10 ], %g1
200de28: 80 a0 60 00 cmp %g1, 0
200de2c: 02 80 00 0a be 200de54 <rtems_bdbuf_swapout_write+0x158>
200de30: 01 00 00 00 nop
(dd->phys_dev->capabilities & RTEMS_BLKDEV_CAP_SYNC))
200de34: d0 07 60 08 ld [ %i5 + 8 ], %o0
200de38: 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 &&
200de3c: 80 88 60 02 btst 2, %g1
200de40: 02 80 00 05 be 200de54 <rtems_bdbuf_swapout_write+0x158> <== ALWAYS TAKEN
200de44: 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);
200de48: c2 07 60 38 ld [ %i5 + 0x38 ], %g1 <== NOT EXECUTED
200de4c: 9f c0 40 00 call %g1 <== NOT EXECUTED
200de50: 94 10 20 00 clr %o2 <== NOT EXECUTED
200de54: 81 c7 e0 08 ret
200de58: 81 e8 00 00 restore
0200ce00 <rtems_bdbuf_swapout_writereq_alloc>:
*
* @return rtems_blkdev_request* The write reference memory.
*/
static rtems_blkdev_request*
rtems_bdbuf_swapout_writereq_alloc (void)
{
200ce00: 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)));
200ce04: 03 00 80 7b sethi %hi(0x201ec00), %g1
200ce08: d0 00 61 54 ld [ %g1 + 0x154 ], %o0 ! 201ed54 <rtems_bdbuf_configuration+0x4>
200ce0c: 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 =
200ce10: 7f ff e0 64 call 2004fa0 <malloc>
200ce14: 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)
200ce18: b0 92 20 00 orcc %o0, 0, %i0
200ce1c: 12 80 00 05 bne 200ce30 <rtems_bdbuf_swapout_writereq_alloc+0x30><== ALWAYS TAKEN
200ce20: 82 10 20 01 mov 1, %g1
rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_SO_NOMEM);
200ce24: 11 10 80 00 sethi %hi(0x42000000), %o0 <== NOT EXECUTED
200ce28: 7f ff f1 65 call 20093bc <rtems_fatal_error_occurred> <== NOT EXECUTED
200ce2c: 90 12 20 15 or %o0, 0x15, %o0 ! 42000015 <RAM_END+0x3fc00015><== NOT EXECUTED
write_req->req = RTEMS_BLKDEV_REQ_WRITE;
200ce30: c2 26 00 00 st %g1, [ %i0 ]
write_req->req_done = rtems_bdbuf_transfer_done;
200ce34: 03 00 80 33 sethi %hi(0x200cc00), %g1
200ce38: 82 10 60 80 or %g1, 0x80, %g1 ! 200cc80 <rtems_bdbuf_transfer_done>
write_req->done_arg = write_req;
200ce3c: f0 26 20 08 st %i0, [ %i0 + 8 ]
write_req->io_task = rtems_task_self ();
200ce40: 40 00 11 47 call 201135c <rtems_task_self>
200ce44: c2 26 20 04 st %g1, [ %i0 + 4 ]
200ce48: d0 26 20 14 st %o0, [ %i0 + 0x14 ]
return write_req;
}
200ce4c: 81 c7 e0 08 ret
200ce50: 81 e8 00 00 restore
0200ed10 <rtems_bdbuf_sync>:
rtems_status_code
rtems_bdbuf_sync (rtems_bdbuf_buffer *bd)
{
200ed10: 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)
200ed14: 80 a6 20 00 cmp %i0, 0
200ed18: 02 80 00 4c be 200ee48 <rtems_bdbuf_sync+0x138> <== NEVER TAKEN
200ed1c: 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();
200ed20: 7f ff f7 af call 200cbdc <rtems_bdbuf_lock_cache>
200ed24: 01 00 00 00 nop
sc = rtems_bdbuf_check_bd_and_lock_cache (bd, "sync");
if (sc != RTEMS_SUCCESSFUL)
return sc;
switch (bd->state)
200ed28: d0 06 20 20 ld [ %i0 + 0x20 ], %o0
200ed2c: 80 a2 20 03 cmp %o0, 3
200ed30: 0a 80 00 3f bcs 200ee2c <rtems_bdbuf_sync+0x11c> <== NEVER TAKEN
200ed34: 13 10 80 00 sethi %hi(0x42000000), %o1
200ed38: 80 a2 20 05 cmp %o0, 5
200ed3c: 08 80 00 06 bleu 200ed54 <rtems_bdbuf_sync+0x44>
200ed40: 82 10 20 08 mov 8, %g1
200ed44: 80 a2 20 06 cmp %o0, 6
200ed48: 12 80 00 3a bne 200ee30 <rtems_bdbuf_sync+0x120> <== NEVER TAKEN
200ed4c: 92 12 60 03 or %o1, 3, %o1
200ed50: 30 80 00 34 b,a 200ee20 <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;
200ed54: 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;
200ed58: c2 26 20 20 st %g1, [ %i0 + 0x20 ]
200ed5c: 90 12 20 8c or %o0, 0x8c, %o0
200ed60: c2 02 20 60 ld [ %o0 + 0x60 ], %g1
the_node->next = tail;
200ed64: 84 02 20 5c add %o0, 0x5c, %g2
tail->previous = the_node;
200ed68: 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;
200ed6c: c4 26 00 00 st %g2, [ %i0 ]
tail->previous = the_node;
old_last->next = the_node;
200ed70: f0 20 40 00 st %i0, [ %g1 ]
the_node->previous = old_last;
200ed74: 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)
200ed78: c2 06 20 24 ld [ %i0 + 0x24 ], %g1
200ed7c: 80 a0 60 00 cmp %g1, 0
200ed80: 02 80 00 04 be 200ed90 <rtems_bdbuf_sync+0x80>
200ed84: 01 00 00 00 nop
rtems_bdbuf_wake (&bdbuf_cache.access_waiters);
200ed88: 7f ff f8 4c call 200ceb8 <rtems_bdbuf_wake>
200ed8c: 90 02 20 64 add %o0, 0x64, %o0
rtems_bdbuf_wake_swapper ();
200ed90: 7f ff f7 b0 call 200cc50 <rtems_bdbuf_wake_swapper>
200ed94: 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);
200ed98: ba 17 60 f8 or %i5, 0xf8, %i5 ! 20218f8 <bdbuf_cache+0x6c>
static void
rtems_bdbuf_wait_for_sync_done (rtems_bdbuf_buffer *bd)
{
while (true)
{
switch (bd->state)
200ed9c: d0 06 20 20 ld [ %i0 + 0x20 ], %o0
200eda0: 80 a2 20 01 cmp %o0, 1
200eda4: 0a 80 00 0d bcs 200edd8 <rtems_bdbuf_sync+0xc8> <== NEVER TAKEN
200eda8: 13 10 80 00 sethi %hi(0x42000000), %o1
200edac: 80 a2 20 07 cmp %o0, 7
200edb0: 28 80 00 0c bleu,a 200ede0 <rtems_bdbuf_sync+0xd0>
200edb4: c2 06 20 24 ld [ %i0 + 0x24 ], %g1
200edb8: 80 a2 20 0a cmp %o0, 0xa
200edbc: 18 80 00 1d bgu 200ee30 <rtems_bdbuf_sync+0x120> <== NEVER TAKEN
200edc0: 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);
200edc4: 90 10 00 18 mov %i0, %o0
200edc8: 7f ff f8 01 call 200cdcc <rtems_bdbuf_wait>
200edcc: 92 10 00 1d mov %i5, %o1
static void
rtems_bdbuf_wait_for_sync_done (rtems_bdbuf_buffer *bd)
{
while (true)
{
switch (bd->state)
200edd0: 10 bf ff f4 b 200eda0 <rtems_bdbuf_sync+0x90>
200edd4: 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);
200edd8: 10 80 00 16 b 200ee30 <rtems_bdbuf_sync+0x120> <== NOT EXECUTED
200eddc: 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
200ede0: 80 a0 60 00 cmp %g1, 0
200ede4: 12 80 00 15 bne 200ee38 <rtems_bdbuf_sync+0x128>
200ede8: 82 02 3f ff add %o0, -1, %g1
&& (bd->state == RTEMS_BDBUF_STATE_CACHED
200edec: 80 a0 60 01 cmp %g1, 1
200edf0: 18 80 00 12 bgu 200ee38 <rtems_bdbuf_sync+0x128> <== NEVER TAKEN
200edf4: 80 a2 20 01 cmp %o0, 1
|| bd->state == RTEMS_BDBUF_STATE_EMPTY))
{
if (bd->state == RTEMS_BDBUF_STATE_EMPTY)
200edf8: 32 80 00 07 bne,a 200ee14 <rtems_bdbuf_sync+0x104>
200edfc: 11 00 80 86 sethi %hi(0x2021800), %o0
{
rtems_bdbuf_remove_from_tree (bd);
200ee00: 7f ff f8 53 call 200cf4c <rtems_bdbuf_remove_from_tree>
200ee04: 90 10 00 18 mov %i0, %o0
rtems_bdbuf_make_free_and_add_to_lru_list (bd);
200ee08: 7f ff f9 2b call 200d2b4 <rtems_bdbuf_make_free_and_add_to_lru_list>
200ee0c: 90 10 00 18 mov %i0, %o0
}
rtems_bdbuf_wake (&bdbuf_cache.buffer_waiters);
200ee10: 11 00 80 86 sethi %hi(0x2021800), %o0
200ee14: 7f ff f8 29 call 200ceb8 <rtems_bdbuf_wake>
200ee18: 90 12 21 00 or %o0, 0x100, %o0 ! 2021900 <bdbuf_cache+0x74>
200ee1c: 30 80 00 07 b,a 200ee38 <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);
200ee20: 7f ff fd 92 call 200e468 <rtems_bdbuf_discard_buffer_after_access>
200ee24: 90 10 00 18 mov %i0, %o0
break;
200ee28: 30 80 00 04 b,a 200ee38 <rtems_bdbuf_sync+0x128>
default:
rtems_bdbuf_fatal (bd->state, RTEMS_BLKDEV_FATAL_BDBUF_STATE_5);
200ee2c: 92 12 60 03 or %o1, 3, %o1 <== NOT EXECUTED
200ee30: 7f ff f7 72 call 200cbf8 <rtems_bdbuf_fatal> <== NOT EXECUTED
200ee34: 01 00 00 00 nop <== NOT EXECUTED
}
if (rtems_bdbuf_tracer)
rtems_bdbuf_show_usage ();
rtems_bdbuf_unlock_cache ();
200ee38: 7f ff f7 7f call 200cc34 <rtems_bdbuf_unlock_cache>
200ee3c: b0 10 20 00 clr %i0 ! 0 <PROM_START>
return RTEMS_SUCCESSFUL;
200ee40: 81 c7 e0 08 ret
200ee44: 81 e8 00 00 restore
}
200ee48: 81 c7 e0 08 ret <== NOT EXECUTED
200ee4c: 91 e8 20 09 restore %g0, 9, %o0 <== NOT EXECUTED
0200cc0c <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)
{
200cc0c: 9d e3 bf a0 save %sp, -96, %sp
rtems_status_code sc = rtems_semaphore_release (lock);
200cc10: 7f ff f0 88 call 2008e30 <rtems_semaphore_release>
200cc14: 90 10 00 18 mov %i0, %o0
if (sc != RTEMS_SUCCESSFUL)
200cc18: 80 a2 20 00 cmp %o0, 0
200cc1c: 02 80 00 04 be 200cc2c <rtems_bdbuf_unlock+0x20> <== ALWAYS TAKEN
200cc20: 01 00 00 00 nop
rtems_fatal_error_occurred (fatal_error_code);
200cc24: 7f ff f1 e6 call 20093bc <rtems_fatal_error_occurred> <== NOT EXECUTED
200cc28: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
200cc2c: 81 c7 e0 08 ret
200cc30: 81 e8 00 00 restore
0200cc98 <rtems_bdbuf_wait_for_event>:
return RTEMS_UNSATISFIED;
}
static void
rtems_bdbuf_wait_for_event (rtems_event_set event)
{
200cc98: 9d e3 bf 98 save %sp, -104, %sp
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_event_set out = 0;
sc = rtems_event_receive (event,
200cc9c: 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;
200cca0: c0 27 bf fc clr [ %fp + -4 ]
sc = rtems_event_receive (event,
200cca4: 90 10 00 18 mov %i0, %o0
200cca8: 94 10 20 00 clr %o2
200ccac: 7f ff ee 7d call 20086a0 <rtems_event_receive>
200ccb0: 96 07 bf fc add %fp, -4, %o3
RTEMS_EVENT_ALL | RTEMS_WAIT,
RTEMS_NO_TIMEOUT,
&out);
if (sc != RTEMS_SUCCESSFUL || out != event)
200ccb4: 80 a2 20 00 cmp %o0, 0
200ccb8: 12 80 00 05 bne 200cccc <rtems_bdbuf_wait_for_event+0x34> <== NEVER TAKEN
200ccbc: c2 07 bf fc ld [ %fp + -4 ], %g1
200ccc0: 80 a0 40 18 cmp %g1, %i0
200ccc4: 02 80 00 05 be 200ccd8 <rtems_bdbuf_wait_for_event+0x40> <== ALWAYS TAKEN
200ccc8: 01 00 00 00 nop
rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_WAIT_EVNT);
200cccc: 11 10 80 00 sethi %hi(0x42000000), %o0 <== NOT EXECUTED
200ccd0: 7f ff f1 bb call 20093bc <rtems_fatal_error_occurred> <== NOT EXECUTED
200ccd4: 90 12 20 1a or %o0, 0x1a, %o0 ! 4200001a <RAM_END+0x3fc0001a><== NOT EXECUTED
200ccd8: 81 c7 e0 08 ret
200ccdc: 81 e8 00 00 restore
0200ceb8 <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)
{
200ceb8: 9d e3 bf a0 save %sp, -96, %sp
rtems_status_code sc = RTEMS_SUCCESSFUL;
if (waiters->count > 0)
200cebc: c2 06 00 00 ld [ %i0 ], %g1
200cec0: 80 a0 60 00 cmp %g1, 0
200cec4: 02 80 00 09 be 200cee8 <rtems_bdbuf_wake+0x30>
200cec8: 01 00 00 00 nop
{
sc = rtems_semaphore_flush (waiters->sema);
200cecc: 40 00 10 9c call 201113c <rtems_semaphore_flush>
200ced0: d0 06 20 04 ld [ %i0 + 4 ], %o0
if (sc != RTEMS_SUCCESSFUL)
200ced4: 80 a2 20 00 cmp %o0, 0
200ced8: 02 80 00 04 be 200cee8 <rtems_bdbuf_wake+0x30> <== ALWAYS TAKEN
200cedc: 11 10 80 00 sethi %hi(0x42000000), %o0
rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_CACHE_WAKE);
200cee0: 7f ff f1 37 call 20093bc <rtems_fatal_error_occurred> <== NOT EXECUTED
200cee4: 90 12 20 13 or %o0, 0x13, %o0 ! 42000013 <RAM_END+0x3fc00013><== NOT EXECUTED
200cee8: 81 c7 e0 08 ret
200ceec: 81 e8 00 00 restore
0200cc50 <rtems_bdbuf_wake_swapper>:
}
}
static void
rtems_bdbuf_wake_swapper (void)
{
200cc50: 9d e3 bf a0 save %sp, -96, %sp
rtems_status_code sc = rtems_event_send (bdbuf_cache.swapout,
200cc54: 03 00 80 86 sethi %hi(0x2021800), %g1
200cc58: d0 00 60 8c ld [ %g1 + 0x8c ], %o0 ! 202188c <bdbuf_cache>
200cc5c: 7f ff ee f4 call 200882c <rtems_event_send>
200cc60: 92 10 20 04 mov 4, %o1
RTEMS_BDBUF_SWAPOUT_SYNC);
if (sc != RTEMS_SUCCESSFUL)
200cc64: 80 a2 20 00 cmp %o0, 0
200cc68: 02 80 00 04 be 200cc78 <rtems_bdbuf_wake_swapper+0x28> <== ALWAYS TAKEN
200cc6c: 11 10 80 00 sethi %hi(0x42000000), %o0
rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_SO_WAKE);
200cc70: 7f ff f1 d3 call 20093bc <rtems_fatal_error_occurred> <== NOT EXECUTED
200cc74: 90 12 20 14 or %o0, 0x14, %o0 ! 42000014 <RAM_END+0x3fc00014><== NOT EXECUTED
200cc78: 81 c7 e0 08 ret
200cc7c: 81 e8 00 00 restore
02003024 <rtems_bdpart_create>:
const rtems_bdpart_format *format,
rtems_bdpart_partition *pt,
const unsigned *dist,
size_t count
)
{
2003024: 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;
2003028: 80 a6 60 00 cmp %i1, 0
200302c: 02 80 00 08 be 200304c <rtems_bdpart_create+0x28> <== NEVER TAKEN
2003030: 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
2003034: c2 06 40 00 ld [ %i1 ], %g1
2003038: 80 a0 60 00 cmp %g1, 0
200303c: 12 80 00 05 bne 2003050 <rtems_bdpart_create+0x2c> <== NEVER TAKEN
2003040: a0 10 20 00 clr %l0
&& format->mbr.dos_compatibility;
2003044: 10 80 00 03 b 2003050 <rtems_bdpart_create+0x2c>
2003048: e0 0e 60 08 ldub [ %i1 + 8 ], %l0
200304c: 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
2003050: a0 0c 20 01 and %l0, 1, %l0
&& format->type == RTEMS_BDPART_FORMAT_MBR
&& format->mbr.dos_compatibility;
rtems_blkdev_bnum disk_end = 0;
2003054: c0 27 bf fc clr [ %fp + -4 ]
rtems_blkdev_bnum pos = 0;
rtems_blkdev_bnum dist_sum = 0;
rtems_blkdev_bnum record_space =
2003058: 82 0c 20 ff and %l0, 0xff, %g1
200305c: 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;
2003060: 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 =
2003064: 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) {
2003068: 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 =
200306c: 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) {
2003070: 02 80 00 70 be 2003230 <rtems_bdpart_create+0x20c> <== NEVER TAKEN
2003074: ba 07 60 3f add %i5, 0x3f, %i5
/* Nothing to do */
return RTEMS_SUCCESSFUL;
}
/* Check parameter */
if (format == NULL || pt == NULL || dist == NULL) {
2003078: 80 a6 a0 00 cmp %i2, 0
200307c: 02 80 00 6d be 2003230 <rtems_bdpart_create+0x20c> <== NEVER TAKEN
2003080: b0 10 20 09 mov 9, %i0
2003084: 80 a6 60 00 cmp %i1, 0
2003088: 02 80 00 6a be 2003230 <rtems_bdpart_create+0x20c> <== NEVER TAKEN
200308c: 80 a6 e0 00 cmp %i3, 0
2003090: 02 80 00 68 be 2003230 <rtems_bdpart_create+0x20c> <== NEVER TAKEN
2003094: 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);
2003098: 94 10 20 00 clr %o2
200309c: 40 00 01 2a call 2003544 <rtems_bdpart_get_disk_data>
20030a0: 96 07 bf fc add %fp, -4, %o3
if (sc != RTEMS_SUCCESSFUL) {
20030a4: b0 92 20 00 orcc %o0, 0, %i0
20030a8: 12 80 00 62 bne 2003230 <rtems_bdpart_create+0x20c> <== NEVER TAKEN
20030ac: 82 10 20 00 clr %g1
20030b0: 84 10 20 00 clr %g2
#endif
#include <rtems.h>
#include <rtems/bdpart.h>
rtems_status_code rtems_bdpart_create(
20030b4: 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];
20030b8: c6 06 c0 03 ld [ %i3 + %g3 ], %g3
20030bc: a8 00 c0 02 add %g3, %g2, %l4
if (dist_sum < prev_sum) {
20030c0: 80 a5 00 02 cmp %l4, %g2
20030c4: 1a 80 00 04 bcc 20030d4 <rtems_bdpart_create+0xb0> <== ALWAYS TAKEN
20030c8: 80 a0 e0 00 cmp %g3, 0
return RTEMS_INVALID_NUMBER;
20030cc: 81 c7 e0 08 ret <== NOT EXECUTED
20030d0: 91 e8 20 0a restore %g0, 0xa, %o0 <== NOT EXECUTED
}
if (dist [i] == 0) {
20030d4: 02 bf ff fe be 20030cc <rtems_bdpart_create+0xa8> <== NEVER TAKEN
20030d8: 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) {
20030dc: 80 a0 40 1c cmp %g1, %i4
20030e0: 12 bf ff f5 bne 20030b4 <rtems_bdpart_create+0x90>
20030e4: 84 10 00 14 mov %l4, %g2
return RTEMS_INVALID_NUMBER;
}
}
/* Check format */
if (format->type != RTEMS_BDPART_FORMAT_MBR) {
20030e8: c2 06 40 00 ld [ %i1 ], %g1
20030ec: 80 a0 60 00 cmp %g1, 0
20030f0: 12 80 00 52 bne 2003238 <rtems_bdpart_create+0x214> <== NEVER TAKEN
20030f4: 80 8c 20 ff btst 0xff, %l0
return RTEMS_NOT_IMPLEMENTED;
}
/* Align end of disk on cylinder boundary if necessary */
if (dos_compatibility) {
20030f8: 02 80 00 09 be 200311c <rtems_bdpart_create+0xf8> <== NEVER TAKEN
20030fc: 80 a7 20 04 cmp %i4, 4
disk_end -= (disk_end % record_space);
2003100: f2 07 bf fc ld [ %fp + -4 ], %i1
2003104: 92 10 00 1d mov %i5, %o1
2003108: 40 00 7b 37 call 2021de4 <.urem>
200310c: 90 10 00 19 mov %i1, %o0
2003110: 90 26 40 08 sub %i1, %o0, %o0
2003114: 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) {
2003118: 80 a7 20 04 cmp %i4, 4
200311c: 08 80 00 06 bleu 2003134 <rtems_bdpart_create+0x110> <== NEVER TAKEN
2003120: b2 10 00 1d mov %i5, %i1
overhead += (count - 3) * record_space;
2003124: 90 10 00 1d mov %i5, %o0
2003128: 40 00 7a 49 call 2021a4c <.umul>
200312c: 92 07 3f fd add %i4, -3, %o1
2003130: b2 02 00 1d add %o0, %i5, %i1
/*
* Account space to align every partition on cylinder boundaries if
* necessary.
*/
if (dos_compatibility) {
2003134: 80 8c 20 ff btst 0xff, %l0
2003138: 02 80 00 07 be 2003154 <rtems_bdpart_create+0x130> <== NEVER TAKEN
200313c: e6 07 bf fc ld [ %fp + -4 ], %l3
overhead += (count - 1) * record_space;
2003140: 90 10 00 1d mov %i5, %o0
2003144: 40 00 7a 42 call 2021a4c <.umul>
2003148: 92 07 3f ff add %i4, -1, %o1
200314c: b2 06 40 08 add %i1, %o0, %i1
}
/* Check disk space */
if ((overhead + count) > disk_end) {
2003150: e6 07 bf fc ld [ %fp + -4 ], %l3
2003154: 82 06 40 1c add %i1, %i4, %g1
2003158: 80 a0 40 13 cmp %g1, %l3
200315c: 38 80 00 35 bgu,a 2003230 <rtems_bdpart_create+0x20c> <== NEVER TAKEN
2003160: 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;
2003164: aa 24 c0 19 sub %l3, %i1, %l5
2003168: a2 10 00 1a mov %i2, %l1
if ((overhead + count) > disk_end) {
return RTEMS_IO_ERROR;
}
/* Begin of first primary partition */
pos = record_space;
200316c: a0 10 00 1d mov %i5, %l0
/* Space for partitions */
free_space = disk_end - overhead;
for (i = 0; i < count; ++i) {
2003170: b2 10 20 00 clr %i1
#endif
#include <rtems.h>
#include <rtems/bdpart.h>
rtems_status_code rtems_bdpart_create(
2003174: 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];
2003178: e4 06 c0 01 ld [ %i3 + %g1 ], %l2
200317c: 92 10 00 15 mov %l5, %o1
2003180: 40 00 7a 33 call 2021a4c <.umul>
2003184: 90 10 00 12 mov %l2, %o0
if (s < free_space || s < dist [i]) {
2003188: 80 a2 00 15 cmp %o0, %l5
200318c: 0a bf ff d0 bcs 20030cc <rtems_bdpart_create+0xa8> <== NEVER TAKEN
2003190: 80 a2 00 12 cmp %o0, %l2
2003194: 0a bf ff ce bcs 20030cc <rtems_bdpart_create+0xa8> <== NEVER TAKEN
2003198: 01 00 00 00 nop
/* TODO: Calculate without overflow */
return RTEMS_INVALID_NUMBER;
}
s /= dist_sum;
200319c: 40 00 7a 66 call 2021b34 <.udiv>
20031a0: 92 10 00 14 mov %l4, %o1
/* Ensure that the partition is not empty */
if (s == 0) {
20031a4: a4 92 20 00 orcc %o0, 0, %l2
20031a8: 22 80 00 02 be,a 20031b0 <rtems_bdpart_create+0x18c> <== NEVER TAKEN
20031ac: a4 10 20 01 mov 1, %l2 <== NOT EXECUTED
s = 1;
}
/* Align partition upwards */
s += record_space - (s % record_space);
20031b0: 90 10 00 12 mov %l2, %o0
20031b4: 40 00 7b 0c call 2021de4 <.urem>
20031b8: 92 10 00 1d mov %i5, %o1
20031bc: a4 04 80 1d add %l2, %i5, %l2
/* Reserve space for the EBR if necessary */
if (count > 4 && i > 2) {
20031c0: 82 10 20 01 mov 1, %g1
20031c4: 80 a6 60 02 cmp %i1, 2
20031c8: 18 80 00 03 bgu 20031d4 <rtems_bdpart_create+0x1b0>
20031cc: 90 24 80 08 sub %l2, %o0, %o0
20031d0: 82 10 20 00 clr %g1
20031d4: 80 88 60 ff btst 0xff, %g1
20031d8: 22 80 00 0a be,a 2003200 <rtems_bdpart_create+0x1dc>
20031dc: e0 24 40 00 st %l0, [ %l1 ]
20031e0: 80 a7 20 04 cmp %i4, 4
20031e4: 18 80 00 03 bgu 20031f0 <rtems_bdpart_create+0x1cc> <== ALWAYS TAKEN
20031e8: 82 10 20 01 mov 1, %g1
20031ec: 82 10 20 00 clr %g1 <== NOT EXECUTED
20031f0: 80 88 60 ff btst 0xff, %g1
20031f4: 32 80 00 02 bne,a 20031fc <rtems_bdpart_create+0x1d8> <== ALWAYS TAKEN
20031f8: a0 04 00 1d add %l0, %i5, %l0
pos += record_space;
}
/* Partition begin and end */
p->begin = pos;
20031fc: e0 24 40 00 st %l0, [ %l1 ]
pos += s;
2003200: a0 04 00 08 add %l0, %o0, %l0
p->end = pos;
2003204: 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) {
2003208: b2 06 60 01 inc %i1
200320c: 80 a6 40 1c cmp %i1, %i4
2003210: 12 bf ff d9 bne 2003174 <rtems_bdpart_create+0x150>
2003214: 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;
2003218: b2 06 7f ff add %i1, -1, %i1
200321c: 83 2e 60 04 sll %i1, 4, %g1
2003220: b3 2e 60 06 sll %i1, 6, %i1
2003224: b2 26 40 01 sub %i1, %g1, %i1
2003228: b4 06 80 19 add %i2, %i1, %i2
200322c: e6 26 a0 04 st %l3, [ %i2 + 4 ]
2003230: 81 c7 e0 08 ret
2003234: 81 e8 00 00 restore
2003238: b0 10 20 18 mov 0x18, %i0 <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
}
200323c: 81 c7 e0 08 ret <== NOT EXECUTED
2003240: 81 e8 00 00 restore <== NOT EXECUTED
02003244 <rtems_bdpart_dump>:
{
uuid_unparse_lower( type, str);
}
void rtems_bdpart_dump( const rtems_bdpart_partition *pt, size_t count)
{
2003244: 9d e3 bf 60 save %sp, -160, %sp
size_t i = 0;
printf(
2003248: 11 00 80 90 sethi %hi(0x2024000), %o0
break;
case RTEMS_BDPART_MBR_DATA:
type = "DATA";
break;
default:
snprintf( type_buffer, sizeof( type_buffer), "0x%02" PRIx8, type_mbr);
200324c: 35 00 80 91 sethi %hi(0x2024400), %i2
void rtems_bdpart_dump( const rtems_bdpart_partition *pt, size_t count)
{
size_t i = 0;
printf(
2003250: 90 12 23 98 or %o0, 0x398, %o0
2003254: 40 00 4a 2c call 2015b04 <puts>
2003258: 27 00 80 91 sethi %hi(0x2024400), %l3
"------------+------------+-----------------------------------------------------\n"
" BEGIN | END | TYPE\n"
"------------+------------+-----------------------------------------------------\n"
);
for (i = 0; i < count; ++i) {
200325c: 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";
2003260: 37 00 80 90 sethi %hi(0x2024000), %i3
break;
case RTEMS_BDPART_MBR_DATA:
type = "DATA";
break;
default:
snprintf( type_buffer, sizeof( type_buffer), "0x%02" PRIx8, type_mbr);
2003264: b4 16 a0 d8 or %i2, 0xd8, %i2
break;
case RTEMS_BDPART_MBR_FAT_16:
type = "FAT 16";
break;
case RTEMS_BDPART_MBR_FAT_16_LBA:
type = "FAT 16 LBA";
2003268: 21 00 80 90 sethi %hi(0x2024000), %l0
break;
case RTEMS_BDPART_MBR_FAT_32_LBA:
type = "FAT 32 LBA";
break;
case RTEMS_BDPART_MBR_DATA:
type = "DATA";
200326c: 23 00 80 90 sethi %hi(0x2024000), %l1
break;
case RTEMS_BDPART_MBR_FAT_32:
type = "FAT 32";
break;
case RTEMS_BDPART_MBR_FAT_32_LBA:
type = "FAT 32 LBA";
2003270: 25 00 80 90 sethi %hi(0x2024000), %l2
"------------+------------+-----------------------------------------------------\n"
" BEGIN | END | TYPE\n"
"------------+------------+-----------------------------------------------------\n"
);
for (i = 0; i < count; ++i) {
2003274: 10 80 00 39 b 2003358 <rtems_bdpart_dump+0x114>
2003278: a6 14 e0 e0 or %l3, 0xe0, %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)) {
200327c: b8 06 20 08 add %i0, 8, %i4
2003280: 92 07 bf c7 add %fp, -57, %o1
2003284: 40 00 00 a4 call 2003514 <rtems_bdpart_to_mbr_partition_type>
2003288: 90 10 00 1c mov %i4, %o0
200328c: 80 8a 20 ff btst 0xff, %o0
2003290: 22 80 00 27 be,a 200332c <rtems_bdpart_dump+0xe8> <== NEVER TAKEN
2003294: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
switch (type_mbr) {
2003298: d6 0f bf c7 ldub [ %fp + -57 ], %o3
200329c: 82 0a e0 ff and %o3, 0xff, %g1
20032a0: 80 a0 60 0b cmp %g1, 0xb
20032a4: 22 80 00 27 be,a 2003340 <rtems_bdpart_dump+0xfc> <== ALWAYS TAKEN
20032a8: 96 16 e3 80 or %i3, 0x380, %o3
20032ac: 18 80 00 09 bgu 20032d0 <rtems_bdpart_dump+0x8c> <== NOT EXECUTED
20032b0: 80 a0 60 0e cmp %g1, 0xe <== NOT EXECUTED
20032b4: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED
20032b8: 02 80 00 0e be 20032f0 <rtems_bdpart_dump+0xac> <== NOT EXECUTED
20032bc: 80 a0 60 04 cmp %g1, 4 <== NOT EXECUTED
20032c0: 12 80 00 15 bne 2003314 <rtems_bdpart_dump+0xd0> <== NOT EXECUTED
20032c4: 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";
20032c8: 10 80 00 1d b 200333c <rtems_bdpart_dump+0xf8> <== NOT EXECUTED
20032cc: 17 00 80 90 sethi %hi(0x2024000), %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) {
20032d0: 02 80 00 0b be 20032fc <rtems_bdpart_dump+0xb8> <== NOT EXECUTED
20032d4: 80 a0 60 da cmp %g1, 0xda <== NOT EXECUTED
20032d8: 02 80 00 0d be 200330c <rtems_bdpart_dump+0xc8> <== NOT EXECUTED
20032dc: 80 a0 60 0c cmp %g1, 0xc <== NOT EXECUTED
20032e0: 12 80 00 0d bne 2003314 <rtems_bdpart_dump+0xd0> <== NOT EXECUTED
20032e4: 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";
20032e8: 10 80 00 07 b 2003304 <rtems_bdpart_dump+0xc0> <== NOT EXECUTED
20032ec: 96 14 a3 70 or %l2, 0x370, %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";
20032f0: 17 00 80 90 sethi %hi(0x2024000), %o3 <== NOT EXECUTED
20032f4: 10 80 00 13 b 2003340 <rtems_bdpart_dump+0xfc> <== NOT EXECUTED
20032f8: 96 12 e3 60 or %o3, 0x360, %o3 ! 2024360 <ide_part_table_rdax+0x57c><== NOT EXECUTED
case RTEMS_BDPART_MBR_FAT_16:
type = "FAT 16";
break;
case RTEMS_BDPART_MBR_FAT_16_LBA:
type = "FAT 16 LBA";
break;
20032fc: 10 80 00 11 b 2003340 <rtems_bdpart_dump+0xfc> <== NOT EXECUTED
2003300: 96 14 23 88 or %l0, 0x388, %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;
2003304: 10 80 00 10 b 2003344 <rtems_bdpart_dump+0x100> <== NOT EXECUTED
2003308: d2 06 00 00 ld [ %i0 ], %o1 <== NOT EXECUTED
case RTEMS_BDPART_MBR_DATA:
type = "DATA";
break;
200330c: 10 80 00 0d b 2003340 <rtems_bdpart_dump+0xfc> <== NOT EXECUTED
2003310: 96 14 63 68 or %l1, 0x368, %o3 <== NOT EXECUTED
default:
snprintf( type_buffer, sizeof( type_buffer), "0x%02" PRIx8, type_mbr);
2003314: 92 10 20 34 mov 0x34, %o1 <== NOT EXECUTED
2003318: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED
200331c: 40 00 4a b3 call 2015de8 <snprintf> <== NOT EXECUTED
2003320: 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;
2003324: 10 80 00 07 b 2003340 <rtems_bdpart_dump+0xfc> <== NOT EXECUTED
2003328: 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);
200332c: 40 00 2b 10 call 200df6c <uuid_unparse_lower> <== NOT EXECUTED
2003330: 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;
2003334: 10 80 00 03 b 2003340 <rtems_bdpart_dump+0xfc> <== NOT EXECUTED
2003338: 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";
200333c: 96 12 e3 58 or %o3, 0x358, %o3 <== NOT EXECUTED
} else {
rtems_bdpart_type_to_string( p->type, type_buffer);
type = type_buffer;
}
printf(
2003340: d2 06 00 00 ld [ %i0 ], %o1
2003344: d4 06 20 04 ld [ %i0 + 4 ], %o2
2003348: 90 10 00 13 mov %l3, %o0
200334c: 40 00 49 b8 call 2015a2c <printf>
2003350: ba 07 60 01 inc %i5
2003354: b0 06 20 30 add %i0, 0x30, %i0
"------------+------------+-----------------------------------------------------\n"
" BEGIN | END | TYPE\n"
"------------+------------+-----------------------------------------------------\n"
);
for (i = 0; i < count; ++i) {
2003358: 80 a7 40 19 cmp %i5, %i1
200335c: 32 bf ff c8 bne,a 200327c <rtems_bdpart_dump+0x38>
2003360: c0 2f bf c7 clrb [ %fp + -57 ]
p->end,
type
);
}
puts( "------------+------------+-----------------------------------------------------");
2003364: 11 00 80 91 sethi %hi(0x2024400), %o0
2003368: 40 00 49 e7 call 2015b04 <puts>
200336c: 90 12 20 88 or %o0, 0x88, %o0 ! 2024488 <ide_part_table_rdax+0x6a4>
2003370: 81 c7 e0 08 ret
2003374: 81 e8 00 00 restore
02003544 <rtems_bdpart_get_disk_data>:
const char *disk_name,
int *fd_ptr,
rtems_disk_device **dd_ptr,
rtems_blkdev_bnum *disk_end
)
{
2003544: 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);
2003548: 92 10 20 02 mov 2, %o1
)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
int rv = 0;
int fd = -1;
rtems_disk_device *dd = NULL;
200354c: 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);
2003550: 40 00 0d 2b call 20069fc <open>
2003554: 90 10 00 18 mov %i0, %o0
if (fd < 0) {
2003558: ba 92 20 00 orcc %o0, 0, %i5
200355c: 36 80 00 04 bge,a 200356c <rtems_bdpart_get_disk_data+0x28><== ALWAYS TAKEN
2003560: 13 10 01 10 sethi %hi(0x40044000), %o1
sc = RTEMS_INVALID_NAME;
2003564: 10 80 00 12 b 20035ac <rtems_bdpart_get_disk_data+0x68> <== NOT EXECUTED
2003568: 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);
200356c: 94 07 bf fc add %fp, -4, %o2
2003570: 40 00 09 d2 call 2005cb8 <ioctl>
2003574: 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) {
2003578: 80 a2 20 00 cmp %o0, 0
200357c: 32 80 00 0c bne,a 20035ac <rtems_bdpart_get_disk_data+0x68><== NEVER TAKEN
2003580: 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;
2003584: c2 07 bf fc ld [ %fp + -4 ], %g1
*disk_end = dd->size;
2003588: c4 18 60 18 ldd [ %g1 + 0x18 ], %g2
200358c: c6 26 c0 00 st %g3, [ %i3 ]
block_size = dd->block_size;
/* Check block size */
if (block_size < RTEMS_BDPART_BLOCK_SIZE) {
2003590: c2 00 60 24 ld [ %g1 + 0x24 ], %g1
2003594: 80 a0 61 ff cmp %g1, 0x1ff
2003598: 08 80 00 05 bleu 20035ac <rtems_bdpart_get_disk_data+0x68><== NEVER TAKEN
200359c: 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;
20035a0: 80 a0 00 02 cmp %g0, %g2
20035a4: b0 60 20 00 subx %g0, 0, %i0
20035a8: b0 0e 20 1b and %i0, 0x1b, %i0
goto error;
}
error:
if (sc == RTEMS_SUCCESSFUL && fd_ptr != NULL && dd_ptr != NULL) {
20035ac: 80 a6 20 00 cmp %i0, 0
20035b0: 12 80 00 0a bne 20035d8 <rtems_bdpart_get_disk_data+0x94> <== NEVER TAKEN
20035b4: 80 a6 60 00 cmp %i1, 0
20035b8: 02 80 00 08 be 20035d8 <rtems_bdpart_get_disk_data+0x94>
20035bc: 80 a6 a0 00 cmp %i2, 0
20035c0: 02 80 00 06 be 20035d8 <rtems_bdpart_get_disk_data+0x94> <== NEVER TAKEN
20035c4: c2 07 bf fc ld [ %fp + -4 ], %g1
*fd_ptr = fd;
20035c8: fa 26 40 00 st %i5, [ %i1 ]
*dd_ptr = dd;
20035cc: c2 26 80 00 st %g1, [ %i2 ]
20035d0: 81 c7 e0 08 ret
20035d4: 81 e8 00 00 restore
} else {
close( fd);
20035d8: 40 00 08 79 call 20057bc <close>
20035dc: 90 10 00 1d mov %i5, %o0
}
return sc;
}
20035e0: 81 c7 e0 08 ret
20035e4: 81 e8 00 00 restore
02021328 <rtems_bdpart_mount>:
const char *disk_name,
const rtems_bdpart_partition *pt __attribute__((unused)),
size_t count,
const char *mount_base
)
{
2021328: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED
rtems_status_code esc = RTEMS_SUCCESSFUL;
const char *disk_file_name = strrchr( disk_name, '/');
202132c: 92 10 20 2f mov 0x2f, %o1 <== NOT EXECUTED
2021330: 40 00 75 1a call 203e798 <strrchr> <== NOT EXECUTED
2021334: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
2021338: 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);
202133c: 40 00 70 f5 call 203d710 <strlen> <== NOT EXECUTED
2021340: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
2021344: a0 10 00 08 mov %o0, %l0 <== NOT EXECUTED
size_t mount_base_size = strlen( mount_base);
2021348: 40 00 70 f2 call 203d710 <strlen> <== NOT EXECUTED
202134c: 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;
2021350: 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);
2021354: 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);
2021358: 7f ff 89 6d call 200390c <malloc> <== NOT EXECUTED
202135c: 90 04 20 04 add %l0, 4, %o0 <== NOT EXECUTED
if (logical_disk_name == NULL) {
2021360: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2021364: 02 80 00 4d be 2021498 <rtems_bdpart_mount+0x170> <== NOT EXECUTED
2021368: b2 10 00 08 mov %o0, %i1 <== NOT EXECUTED
return RTEMS_NO_MEMORY;
}
strncpy( logical_disk_name, disk_name, disk_name_size);
202136c: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
2021370: 40 00 71 a4 call 203da00 <strncpy> <== NOT EXECUTED
2021374: 94 10 00 10 mov %l0, %o2 <== NOT EXECUTED
/* Get disk file name */
if (disk_file_name != NULL) {
2021378: 80 a7 60 00 cmp %i5, 0 <== NOT EXECUTED
202137c: 22 80 00 06 be,a 2021394 <rtems_bdpart_mount+0x6c> <== NOT EXECUTED
2021380: a4 10 00 10 mov %l0, %l2 <== NOT EXECUTED
disk_file_name += 1;
2021384: b0 07 60 01 add %i5, 1, %i0 <== NOT EXECUTED
disk_file_name_size = strlen( disk_file_name);
2021388: 40 00 70 e2 call 203d710 <strlen> <== NOT EXECUTED
202138c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
2021390: 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);
2021394: a6 04 80 11 add %l2, %l1, %l3 <== NOT EXECUTED
if (mount_point == NULL) {
esc = RTEMS_NO_MEMORY;
2021398: 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);
202139c: 7f ff 89 5c call 200390c <malloc> <== NOT EXECUTED
20213a0: 90 04 e0 05 add %l3, 5, %o0 <== NOT EXECUTED
if (mount_point == NULL) {
20213a4: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
20213a8: 02 80 00 38 be 2021488 <rtems_bdpart_mount+0x160> <== NOT EXECUTED
20213ac: ba 10 00 08 mov %o0, %i5 <== NOT EXECUTED
esc = RTEMS_NO_MEMORY;
goto cleanup;
}
strncpy( mount_point, mount_base, mount_base_size);
20213b0: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
20213b4: 40 00 71 93 call 203da00 <strncpy> <== NOT EXECUTED
20213b8: 94 10 00 11 mov %l1, %o2 <== NOT EXECUTED
mount_point [mount_base_size] = '/';
20213bc: 82 10 20 2f mov 0x2f, %g1 <== NOT EXECUTED
strncpy( mount_point + mount_base_size + 1, disk_file_name, disk_file_name_size);
20213c0: 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] = '/';
20213c4: c2 2f 40 11 stb %g1, [ %i5 + %l1 ] <== NOT EXECUTED
strncpy( mount_point + mount_base_size + 1, disk_file_name, disk_file_name_size);
20213c8: 90 04 60 01 add %l1, 1, %o0 <== NOT EXECUTED
20213cc: 94 10 00 12 mov %l2, %o2 <== NOT EXECUTED
20213d0: 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;
20213d4: 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);
20213d8: 37 00 81 67 sethi %hi(0x2059c00), %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);
20213dc: 40 00 71 89 call 203da00 <strncpy> <== NOT EXECUTED
20213e0: 31 00 81 60 sethi %hi(0x2058000), %i0 <== NOT EXECUTED
/* Markers */
logical_disk_marker = logical_disk_name + disk_name_size;
20213e4: a0 06 40 10 add %i1, %l0, %l0 <== NOT EXECUTED
mount_marker = mount_point + mount_base_size + 1 + disk_file_name_size;
20213e8: a6 07 40 13 add %i5, %l3, %l3 <== NOT EXECUTED
/* Mount supported file systems for each partition */
for (i = 0; i < count; ++i) {
20213ec: 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);
20213f0: b6 16 e2 88 or %i3, 0x288, %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) {
20213f4: 10 80 00 1d b 2021468 <rtems_bdpart_mount+0x140> <== NOT EXECUTED
20213f8: b0 16 22 f0 or %i0, 0x2f0, %i0 <== NOT EXECUTED
/* Create logical disk name */
int rv = snprintf( logical_disk_marker, RTEMS_BDPART_NUMBER_SIZE, "%zu", i + 1);
20213fc: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
2021400: 92 10 20 04 mov 4, %o1 <== NOT EXECUTED
2021404: 94 10 00 1b mov %i3, %o2 <== NOT EXECUTED
2021408: 40 00 6d 24 call 203c898 <snprintf> <== NOT EXECUTED
202140c: 96 10 00 1c mov %i4, %o3 <== NOT EXECUTED
if (rv >= RTEMS_BDPART_NUMBER_SIZE) {
2021410: 80 a2 20 03 cmp %o0, 3 <== NOT EXECUTED
2021414: 14 80 00 1a bg 202147c <rtems_bdpart_mount+0x154> <== NOT EXECUTED
2021418: 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);
202141c: 94 10 20 04 mov 4, %o2 <== NOT EXECUTED
2021420: 40 00 71 78 call 203da00 <strncpy> <== NOT EXECUTED
2021424: 90 10 00 13 mov %l3, %o0 <== NOT EXECUTED
rv = rtems_mkdir( mount_point, S_IRWXU | S_IRWXG | S_IRWXO);
2021428: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
202142c: 40 00 0e 69 call 2024dd0 <rtems_mkdir> <== NOT EXECUTED
2021430: 92 10 21 ff mov 0x1ff, %o1 <== NOT EXECUTED
if (rv != 0) {
2021434: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2021438: 12 80 00 13 bne 2021484 <rtems_bdpart_mount+0x15c> <== NOT EXECUTED
202143c: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
esc = RTEMS_IO_ERROR;
goto cleanup;
}
/* Mount */
rv = mount(
2021440: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
2021444: 94 10 00 18 mov %i0, %o2 <== NOT EXECUTED
2021448: 96 10 20 00 clr %o3 <== NOT EXECUTED
202144c: 7f ff 89 ba call 2003b34 <mount> <== NOT EXECUTED
2021450: 98 10 20 00 clr %o4 <== NOT EXECUTED
mount_point,
"msdos",
0,
NULL
);
if (rv != 0) {
2021454: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2021458: 02 80 00 05 be 202146c <rtems_bdpart_mount+0x144> <== NOT EXECUTED
202145c: 80 a7 00 1a cmp %i4, %i2 <== NOT EXECUTED
rmdir( mount_point);
2021460: 40 00 0e 3f call 2024d5c <rmdir> <== NOT EXECUTED
2021464: 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) {
2021468: 80 a7 00 1a cmp %i4, %i2 <== NOT EXECUTED
202146c: 32 bf ff e4 bne,a 20213fc <rtems_bdpart_mount+0xd4> <== NOT EXECUTED
2021470: 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;
2021474: 10 80 00 05 b 2021488 <rtems_bdpart_mount+0x160> <== NOT EXECUTED
2021478: 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;
202147c: 10 80 00 03 b 2021488 <rtems_bdpart_mount+0x160> <== NOT EXECUTED
2021480: 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;
2021484: b8 10 20 1b mov 0x1b, %i4 <== NOT EXECUTED
}
}
cleanup:
free( logical_disk_name);
2021488: 7f ff 88 38 call 2003568 <free> <== NOT EXECUTED
202148c: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
free( mount_point);
2021490: 7f ff 88 36 call 2003568 <free> <== NOT EXECUTED
2021494: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
return esc;
}
2021498: 81 c7 e0 08 ret <== NOT EXECUTED
202149c: 91 e8 00 1c restore %g0, %i4, %o0 <== NOT EXECUTED
02003a24 <rtems_bdpart_new_record>:
static rtems_status_code rtems_bdpart_new_record(
rtems_disk_device *dd,
rtems_blkdev_bnum index,
rtems_bdbuf_buffer **block
)
{
2003a24: 9d e3 bf a0 save %sp, -96, %sp
rtems_status_code sc = RTEMS_SUCCESSFUL;
/* Synchronize previous block if necessary */
if (*block != NULL) {
2003a28: d0 06 80 00 ld [ %i2 ], %o0
2003a2c: 80 a2 20 00 cmp %o0, 0
2003a30: 12 80 00 0b bne 2003a5c <rtems_bdpart_new_record+0x38>
2003a34: 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);
2003a38: 90 10 00 18 mov %i0, %o0
2003a3c: 92 10 00 19 mov %i1, %o1
2003a40: 40 00 31 17 call 200fe9c <rtems_bdbuf_read>
2003a44: 94 10 00 1a mov %i2, %o2
if (sc != RTEMS_SUCCESSFUL) {
2003a48: ba 92 20 00 orcc %o0, 0, %i5
2003a4c: 22 80 00 0b be,a 2003a78 <rtems_bdpart_new_record+0x54> <== ALWAYS TAKEN
2003a50: 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;
}
2003a54: 81 c7 e0 08 ret <== NOT EXECUTED
2003a58: 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);
2003a5c: 40 00 31 e0 call 20101dc <rtems_bdbuf_sync>
2003a60: 01 00 00 00 nop
if (sc != RTEMS_SUCCESSFUL) {
2003a64: ba 92 20 00 orcc %o0, 0, %i5
2003a68: 02 bf ff f5 be 2003a3c <rtems_bdpart_new_record+0x18> <== ALWAYS TAKEN
2003a6c: 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;
}
2003a70: 81 c7 e0 08 ret <== NOT EXECUTED
2003a74: 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 ) {
2003a78: 80 a0 60 00 cmp %g1, 0
2003a7c: 02 80 00 0e be 2003ab4 <rtems_bdpart_new_record+0x90> <== NEVER TAKEN
2003a80: 92 10 20 00 clr %o1
return RTEMS_INVALID_ADDRESS;
}
/* Clear record */
memset( (*block)->buffer, 0, RTEMS_BDPART_BLOCK_SIZE);
2003a84: d0 00 60 1c ld [ %g1 + 0x1c ], %o0
2003a88: 40 00 47 96 call 20158e0 <memset>
2003a8c: 94 10 22 00 mov 0x200, %o2
/* Write signature */
(*block)->buffer [RTEMS_BDPART_MBR_OFFSET_SIGNATURE_0] =
2003a90: c2 06 80 00 ld [ %i2 ], %g1
2003a94: 84 10 20 55 mov 0x55, %g2
2003a98: c2 00 60 1c ld [ %g1 + 0x1c ], %g1
2003a9c: c4 28 61 fe stb %g2, [ %g1 + 0x1fe ]
RTEMS_BDPART_MBR_SIGNATURE_0;
(*block)->buffer [RTEMS_BDPART_MBR_OFFSET_SIGNATURE_1] =
2003aa0: c2 06 80 00 ld [ %i2 ], %g1
2003aa4: 84 10 3f aa mov -86, %g2
2003aa8: c2 00 60 1c ld [ %g1 + 0x1c ], %g1
2003aac: 10 80 00 03 b 2003ab8 <rtems_bdpart_new_record+0x94>
2003ab0: 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;
2003ab4: 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;
}
2003ab8: b0 10 00 1d mov %i5, %i0
2003abc: 81 c7 e0 08 ret
2003ac0: 81 e8 00 00 restore
020035e8 <rtems_bdpart_read>:
const char *disk_name,
rtems_bdpart_format *format,
rtems_bdpart_partition *pt,
size_t *count
)
{
20035e8: 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;
20035ec: 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;
20035f0: c0 27 bf e8 clr [ %fp + -24 ]
rtems_bdpart_partition *p = pt - 1;
20035f4: c2 27 bf ec st %g1, [ %fp + -20 ]
const rtems_bdpart_partition *p_end = pt + (count != NULL ? *count : 0);
20035f8: 80 a6 e0 00 cmp %i3, 0
20035fc: 02 80 00 07 be 2003618 <rtems_bdpart_read+0x30> <== NEVER TAKEN
2003600: 90 10 00 18 mov %i0, %o0
2003604: c2 06 c0 00 ld [ %i3 ], %g1
2003608: 85 28 60 04 sll %g1, 4, %g2
200360c: b9 28 60 06 sll %g1, 6, %i4
2003610: 10 80 00 03 b 200361c <rtems_bdpart_read+0x34>
2003614: b8 27 00 02 sub %i4, %g2, %i4
2003618: 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;
200361c: 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 */
2003620: c0 27 bf f0 clr [ %fp + -16 ]
rtems_blkdev_bnum ebr = 0; /* Extended boot record block index */
rtems_blkdev_bnum disk_end = 0;
2003624: c0 27 bf f4 clr [ %fp + -12 ]
size_t i = 0;
const uint8_t *data = NULL;
int fd = -1;
2003628: c2 27 bf f8 st %g1, [ %fp + -8 ]
rtems_disk_device *dd = NULL;
200362c: c0 27 bf fc clr [ %fp + -4 ]
/* Check parameter */
if (format == NULL || pt == NULL || count == NULL) {
2003630: 80 a6 a0 00 cmp %i2, 0
2003634: 02 80 00 89 be 2003858 <rtems_bdpart_read+0x270> <== NEVER TAKEN
2003638: b0 10 20 09 mov 9, %i0
200363c: 80 a6 60 00 cmp %i1, 0
2003640: 02 80 00 86 be 2003858 <rtems_bdpart_read+0x270> <== NEVER TAKEN
2003644: 80 a6 e0 00 cmp %i3, 0
2003648: 02 80 00 84 be 2003858 <rtems_bdpart_read+0x270> <== NEVER TAKEN
200364c: 92 07 bf f8 add %fp, -8, %o1
return RTEMS_INVALID_ADDRESS;
}
/* Set count to a save value */
*count = 0;
2003650: c0 26 c0 00 clr [ %i3 ]
/* Get disk data */
sc = rtems_bdpart_get_disk_data( disk_name, &fd, &dd, &disk_end);
2003654: 94 07 bf fc add %fp, -4, %o2
2003658: 7f ff ff bb call 2003544 <rtems_bdpart_get_disk_data>
200365c: 96 07 bf f4 add %fp, -12, %o3
if (sc != RTEMS_SUCCESSFUL) {
2003660: b0 92 20 00 orcc %o0, 0, %i0
2003664: 12 80 00 7d bne 2003858 <rtems_bdpart_read+0x270> <== NEVER TAKEN
2003668: d0 07 bf fc ld [ %fp + -4 ], %o0
return sc;
}
/* Read MBR */
sc = rtems_bdpart_read_record( dd, 0, &block);
200366c: 92 10 20 00 clr %o1
2003670: 7f ff ff 4d call 20033a4 <rtems_bdpart_read_record>
2003674: 94 07 bf e8 add %fp, -24, %o2
if (sc != RTEMS_SUCCESSFUL) {
2003678: b0 92 20 00 orcc %o0, 0, %i0
200367c: 12 80 00 6c bne 200382c <rtems_bdpart_read+0x244> <== NEVER TAKEN
2003680: 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;
2003684: 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);
2003688: 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;
200368c: e4 00 60 1c ld [ %g1 + 0x1c ], %l2
sc = rtems_bdpart_read_mbr_partition( data, &p, p_end, &ep_begin);
2003690: 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;
2003694: ba 04 a1 be add %l2, 0x1be, %i5
sc = rtems_bdpart_read_mbr_partition( data, &p, p_end, &ep_begin);
2003698: a0 07 bf f0 add %fp, -16, %l0
200369c: 90 10 00 1d mov %i5, %o0
20036a0: 92 10 00 11 mov %l1, %o1
20036a4: 94 10 00 1c mov %i4, %o2
20036a8: 7f ff ff 70 call 2003468 <rtems_bdpart_read_mbr_partition>
20036ac: 96 10 00 10 mov %l0, %o3
if (sc != RTEMS_SUCCESSFUL) {
20036b0: b0 92 20 00 orcc %o0, 0, %i0
20036b4: 32 80 00 5e bne,a 200382c <rtems_bdpart_read+0x244> <== NEVER TAKEN
20036b8: 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) {
20036bc: c2 07 bf ec ld [ %fp + -20 ], %g1
20036c0: c2 08 60 08 ldub [ %g1 + 8 ], %g1
20036c4: 80 a0 60 ee cmp %g1, 0xee
20036c8: 02 80 00 58 be 2003828 <rtems_bdpart_read+0x240> <== NEVER TAKEN
20036cc: 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
20036d0: c2 07 bf e8 ld [ %fp + -24 ], %g1
esc = RTEMS_NOT_IMPLEMENTED;
goto cleanup;
}
/* Set format */
format->type = RTEMS_BDPART_FORMAT_MBR;
20036d4: c0 26 40 00 clr [ %i1 ]
format->mbr.disk_id = rtems_uint32_from_little_endian(
20036d8: d0 00 60 1c ld [ %g1 + 0x1c ], %o0
}
return RTEMS_SUCCESSFUL;
}
rtems_status_code rtems_bdpart_read(
20036dc: 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(
20036e0: 7f ff ff 26 call 2003378 <rtems_uint32_from_little_endian>
20036e4: 90 02 21 b8 add %o0, 0x1b8, %o0
block->buffer + RTEMS_BDPART_MBR_OFFSET_DISK_ID
);
format->mbr.dos_compatibility = true;
20036e8: 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(
20036ec: d0 26 60 04 st %o0, [ %i1 + 4 ]
block->buffer + RTEMS_BDPART_MBR_OFFSET_DISK_ID
);
format->mbr.dos_compatibility = true;
20036f0: 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;
20036f4: ba 07 60 10 add %i5, 0x10, %i5
sc = rtems_bdpart_read_mbr_partition( data, &p, p_end, &ep_begin);
20036f8: 92 10 00 11 mov %l1, %o1
20036fc: 90 10 00 1d mov %i5, %o0
2003700: 94 10 00 1c mov %i4, %o2
2003704: 7f ff ff 59 call 2003468 <rtems_bdpart_read_mbr_partition>
2003708: 96 10 00 10 mov %l0, %o3
if (sc != RTEMS_SUCCESSFUL) {
200370c: 80 a2 20 00 cmp %o0, 0
2003710: 12 80 00 45 bne 2003824 <rtems_bdpart_read+0x23c> <== NEVER TAKEN
2003714: 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) {
2003718: 32 bf ff f8 bne,a 20036f8 <rtems_bdpart_read+0x110>
200371c: ba 07 60 10 add %i5, 0x10, %i5
}
}
/* Iterate through the logical partitions within the extended partition */
ebr = ep_begin;
while (ebr != 0) {
2003720: 10 80 00 2e b 20037d8 <rtems_bdpart_read+0x1f0>
2003724: fa 07 bf f0 ld [ %fp + -16 ], %i5
rtems_blkdev_bnum tmp = 0;
/* Read EBR */
sc = rtems_bdpart_read_record( dd, ebr, &block);
2003728: 92 10 00 1d mov %i5, %o1
200372c: 7f ff ff 1e call 20033a4 <rtems_bdpart_read_record>
2003730: 94 07 bf e8 add %fp, -24, %o2
if (sc != RTEMS_SUCCESSFUL) {
2003734: 80 a2 20 00 cmp %o0, 0
2003738: 12 80 00 3b bne 2003824 <rtems_bdpart_read+0x23c> <== NEVER TAKEN
200373c: c2 07 bf e8 ld [ %fp + -24 ], %g1
esc = sc;
goto cleanup;
}
/* Read first partition entry */
sc = rtems_bdpart_read_mbr_partition(
2003740: 92 10 00 11 mov %l1, %o1
2003744: d0 00 60 1c ld [ %g1 + 0x1c ], %o0
2003748: 94 10 00 1c mov %i4, %o2
200374c: 90 02 21 be add %o0, 0x1be, %o0
2003750: 7f ff ff 46 call 2003468 <rtems_bdpart_read_mbr_partition>
2003754: 96 10 20 00 clr %o3
block->buffer + RTEMS_BDPART_MBR_OFFSET_TABLE_0,
&p,
p_end,
NULL
);
if (sc != RTEMS_SUCCESSFUL) {
2003758: 80 a2 20 00 cmp %o0, 0
200375c: 12 80 00 32 bne 2003824 <rtems_bdpart_read+0x23c> <== NEVER TAKEN
2003760: c2 07 bf ec ld [ %fp + -20 ], %g1
esc = sc;
goto cleanup;
}
/* Adjust partition begin */
tmp = p->begin + ebr;
2003764: c6 00 40 00 ld [ %g1 ], %g3
2003768: 84 07 40 03 add %i5, %g3, %g2
if (tmp > p->begin) {
200376c: 80 a0 80 03 cmp %g2, %g3
2003770: 38 80 00 04 bgu,a 2003780 <rtems_bdpart_read+0x198> <== ALWAYS TAKEN
2003774: c4 20 40 00 st %g2, [ %g1 ]
p->begin = tmp;
} else {
esc = RTEMS_IO_ERROR;
2003778: 10 80 00 2c b 2003828 <rtems_bdpart_read+0x240> <== NOT EXECUTED
200377c: b0 10 20 1b mov 0x1b, %i0 <== NOT EXECUTED
goto cleanup;
}
/* Adjust partition end */
tmp = p->end + ebr;
2003780: c4 00 60 04 ld [ %g1 + 4 ], %g2
2003784: ba 07 40 02 add %i5, %g2, %i5
if (tmp > p->end) {
2003788: 80 a7 40 02 cmp %i5, %g2
200378c: 08 80 00 27 bleu 2003828 <rtems_bdpart_read+0x240> <== NEVER TAKEN
2003790: b0 10 20 1b mov 0x1b, %i0
p->end = tmp;
2003794: 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
2003798: c2 07 bf e8 ld [ %fp + -24 ], %g1
200379c: 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 =
20037a0: 7f ff fe f6 call 2003378 <rtems_uint32_from_little_endian>
20037a4: 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) {
20037a8: c2 0e 61 d2 ldub [ %i1 + 0x1d2 ], %g1
20037ac: 80 a0 60 05 cmp %g1, 5
20037b0: 12 80 00 0e bne 20037e8 <rtems_bdpart_read+0x200>
20037b4: 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) {
20037b8: 80 a2 20 00 cmp %o0, 0
20037bc: 02 80 00 0a be 20037e4 <rtems_bdpart_read+0x1fc> <== NEVER TAKEN
20037c0: c2 07 bf f0 ld [ %fp + -16 ], %g1
/* Adjust partition EBR block index */
tmp = ebr + ep_begin;
20037c4: 82 02 00 01 add %o0, %g1, %g1
if (tmp > ebr) {
20037c8: 80 a0 40 08 cmp %g1, %o0
20037cc: 08 80 00 17 bleu 2003828 <rtems_bdpart_read+0x240> <== NEVER TAKEN
20037d0: b0 10 20 1b mov 0x1b, %i0
20037d4: ba 10 00 01 mov %g1, %i5
}
}
/* Iterate through the logical partitions within the extended partition */
ebr = ep_begin;
while (ebr != 0) {
20037d8: 80 a7 60 00 cmp %i5, 0
20037dc: 12 bf ff d3 bne 2003728 <rtems_bdpart_read+0x140> <== ALWAYS TAKEN
20037e0: d0 07 bf fc ld [ %fp + -4 ], %o0
}
}
}
/* Return partition count */
*count = (size_t) (p - pt + 1);
20037e4: 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;
20037e8: b0 10 20 00 clr %i0
}
}
}
/* Return partition count */
*count = (size_t) (p - pt + 1);
20037ec: b4 20 40 1a sub %g1, %i2, %i2
20037f0: b5 3e a0 04 sra %i2, 4, %i2
20037f4: 83 2e a0 02 sll %i2, 2, %g1
20037f8: 82 00 40 1a add %g1, %i2, %g1
20037fc: 85 28 60 04 sll %g1, 4, %g2
2003800: 82 00 40 02 add %g1, %g2, %g1
2003804: 85 28 60 08 sll %g1, 8, %g2
2003808: 82 00 40 02 add %g1, %g2, %g1
200380c: 85 28 60 10 sll %g1, 0x10, %g2
2003810: 82 00 40 02 add %g1, %g2, %g1
2003814: 82 20 00 01 neg %g1
2003818: 82 00 60 01 inc %g1
200381c: 10 80 00 03 b 2003828 <rtems_bdpart_read+0x240>
2003820: c2 26 c0 00 st %g1, [ %i3 ]
esc = sc;
goto cleanup;
}
/* Read first partition entry */
sc = rtems_bdpart_read_mbr_partition(
2003824: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED
/* Return partition count */
*count = (size_t) (p - pt + 1);
cleanup:
if (fd >= 0) {
2003828: d0 07 bf f8 ld [ %fp + -8 ], %o0
200382c: 80 a2 20 00 cmp %o0, 0
2003830: 26 80 00 05 bl,a 2003844 <rtems_bdpart_read+0x25c> <== NEVER TAKEN
2003834: d0 07 bf e8 ld [ %fp + -24 ], %o0 <== NOT EXECUTED
close( fd);
2003838: 40 00 07 e1 call 20057bc <close>
200383c: 01 00 00 00 nop
}
if (block != NULL) {
2003840: d0 07 bf e8 ld [ %fp + -24 ], %o0
2003844: 80 a2 20 00 cmp %o0, 0
2003848: 02 80 00 06 be 2003860 <rtems_bdpart_read+0x278> <== NEVER TAKEN
200384c: 01 00 00 00 nop
rtems_bdbuf_release( block);
2003850: 40 00 32 10 call 2010090 <rtems_bdbuf_release>
2003854: 01 00 00 00 nop
2003858: 81 c7 e0 08 ret
200385c: 81 e8 00 00 restore
}
return esc;
}
2003860: 81 c7 e0 08 ret <== NOT EXECUTED
2003864: 81 e8 00 00 restore <== NOT EXECUTED
02003468 <rtems_bdpart_read_mbr_partition>:
const uint8_t *data,
rtems_bdpart_partition **p,
const rtems_bdpart_partition *p_end,
rtems_blkdev_bnum *ep_begin
)
{
2003468: 9d e3 bf a0 save %sp, -96, %sp
rtems_blkdev_bnum begin =
200346c: 7f ff ff c3 call 2003378 <rtems_uint32_from_little_endian>
2003470: 90 06 20 08 add %i0, 8, %o0
2003474: ba 10 00 08 mov %o0, %i5
rtems_uint32_from_little_endian( data + RTEMS_BDPART_MBR_OFFSET_BEGIN);
rtems_blkdev_bnum size =
2003478: 7f ff ff c0 call 2003378 <rtems_uint32_from_little_endian>
200347c: 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) {
2003480: f8 0e 20 04 ldub [ %i0 + 4 ], %i4
2003484: 80 a7 20 00 cmp %i4, 0
2003488: 02 80 00 21 be 200350c <rtems_bdpart_read_mbr_partition+0xa4><== NEVER TAKEN
200348c: 82 10 20 00 clr %g1
return RTEMS_SUCCESSFUL;
} else if (*p == p_end) {
2003490: c4 06 40 00 ld [ %i1 ], %g2
2003494: 80 a0 80 1a cmp %g2, %i2
2003498: 02 80 00 1d be 200350c <rtems_bdpart_read_mbr_partition+0xa4><== NEVER TAKEN
200349c: 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;
20034a0: 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) {
20034a4: 80 a7 40 1a cmp %i5, %i2
20034a8: 1a 80 00 19 bcc 200350c <rtems_bdpart_read_mbr_partition+0xa4><== NEVER TAKEN
20034ac: 82 10 20 1b mov 0x1b, %g1
return RTEMS_IO_ERROR;
} else if (type == RTEMS_BDPART_MBR_EXTENDED) {
20034b0: 80 a7 20 05 cmp %i4, 5
20034b4: 32 80 00 07 bne,a 20034d0 <rtems_bdpart_read_mbr_partition+0x68>
20034b8: 90 00 a0 30 add %g2, 0x30, %o0
if (ep_begin != NULL) {
20034bc: 80 a6 e0 00 cmp %i3, 0
20034c0: 32 80 00 12 bne,a 2003508 <rtems_bdpart_read_mbr_partition+0xa0><== ALWAYS TAKEN
20034c4: 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;
20034c8: 10 80 00 11 b 200350c <rtems_bdpart_read_mbr_partition+0xa4><== NOT EXECUTED
20034cc: 82 10 20 00 clr %g1 <== NOT EXECUTED
} else {
/* Increment partition index */
++(*p);
/* Clear partition */
memset( *p, 0, sizeof( rtems_bdpart_partition));
20034d0: 92 10 20 00 clr %o1
20034d4: 94 10 20 30 mov 0x30, %o2
20034d8: 40 00 49 02 call 20158e0 <memset>
20034dc: d0 26 40 00 st %o0, [ %i1 ]
/* Set values */
(*p)->begin = begin;
20034e0: d2 06 40 00 ld [ %i1 ], %o1
(*p)->end = end;
rtems_bdpart_to_partition_type( type, (*p)->type);
20034e4: 90 10 00 1c mov %i4, %o0
/* Clear partition */
memset( *p, 0, sizeof( rtems_bdpart_partition));
/* Set values */
(*p)->begin = begin;
20034e8: fa 22 40 00 st %i5, [ %o1 ]
(*p)->end = end;
20034ec: f4 22 60 04 st %i2, [ %o1 + 4 ]
rtems_bdpart_to_partition_type( type, (*p)->type);
20034f0: 7f ff ff d6 call 2003448 <rtems_bdpart_to_partition_type>
20034f4: 92 02 60 08 add %o1, 8, %o1
(*p)->flags = data [RTEMS_BDPART_MBR_OFFSET_FLAGS];
20034f8: c2 06 40 00 ld [ %i1 ], %g1
20034fc: c4 0e 00 00 ldub [ %i0 ], %g2
2003500: c0 20 60 28 clr [ %g1 + 0x28 ]
2003504: 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;
2003508: 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;
}
200350c: 81 c7 e0 08 ret
2003510: 91 e8 00 01 restore %g0, %g1, %o0
020033a4 <rtems_bdpart_read_record>:
static rtems_status_code rtems_bdpart_read_record(
rtems_disk_device *dd,
rtems_blkdev_bnum index,
rtems_bdbuf_buffer **block
)
{
20033a4: 9d e3 bf a0 save %sp, -96, %sp
rtems_status_code sc = RTEMS_SUCCESSFUL;
/* Release previous block if necessary */
if (*block != NULL) {
20033a8: d0 06 80 00 ld [ %i2 ], %o0
20033ac: 80 a2 20 00 cmp %o0, 0
20033b0: 12 80 00 0b bne 20033dc <rtems_bdpart_read_record+0x38>
20033b4: 01 00 00 00 nop
return sc;
}
}
/* Read the record block */
sc = rtems_bdbuf_read( dd, index, block);
20033b8: 90 10 00 18 mov %i0, %o0
20033bc: 92 10 00 19 mov %i1, %o1
20033c0: 40 00 32 b7 call 200fe9c <rtems_bdbuf_read>
20033c4: 94 10 00 1a mov %i2, %o2
if (sc != RTEMS_SUCCESSFUL) {
20033c8: 80 a2 20 00 cmp %o0, 0
20033cc: 22 80 00 0b be,a 20033f8 <rtems_bdpart_read_record+0x54> <== ALWAYS TAKEN
20033d0: c2 06 80 00 ld [ %i2 ], %g1
if (!rtems_bdpart_is_valid_record( (*block)->buffer)) {
return RTEMS_IO_ERROR;
}
return RTEMS_SUCCESSFUL;
}
20033d4: 81 c7 e0 08 ret <== NOT EXECUTED
20033d8: 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);
20033dc: 40 00 33 2d call 2010090 <rtems_bdbuf_release>
20033e0: 01 00 00 00 nop
if (sc != RTEMS_SUCCESSFUL) {
20033e4: 80 a2 20 00 cmp %o0, 0
20033e8: 22 bf ff f5 be,a 20033bc <rtems_bdpart_read_record+0x18> <== ALWAYS TAKEN
20033ec: 90 10 00 18 mov %i0, %o0
if (!rtems_bdpart_is_valid_record( (*block)->buffer)) {
return RTEMS_IO_ERROR;
}
return RTEMS_SUCCESSFUL;
}
20033f0: 81 c7 e0 08 ret <== NOT EXECUTED
20033f4: 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 ) {
20033f8: 80 a0 60 00 cmp %g1, 0
20033fc: 22 80 00 10 be,a 200343c <rtems_bdpart_read_record+0x98> <== NEVER TAKEN
2003400: 90 10 20 09 mov 9, %o0 <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
}
/* Check MBR signature */
if (!rtems_bdpart_is_valid_record( (*block)->buffer)) {
2003404: 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]
2003408: c6 08 a1 fe ldub [ %g2 + 0x1fe ], %g3
200340c: 80 a0 e0 55 cmp %g3, 0x55
2003410: 12 80 00 06 bne 2003428 <rtems_bdpart_read_record+0x84> <== NEVER TAKEN
2003414: 82 10 20 00 clr %g1
2003418: c2 08 a1 ff ldub [ %g2 + 0x1ff ], %g1
200341c: 82 18 60 aa xor %g1, 0xaa, %g1
2003420: 80 a0 00 01 cmp %g0, %g1
2003424: 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)) {
2003428: 80 a0 60 00 cmp %g1, 0
200342c: 22 80 00 04 be,a 200343c <rtems_bdpart_read_record+0x98> <== NEVER TAKEN
2003430: 90 10 20 1b mov 0x1b, %o0 <== NOT EXECUTED
return RTEMS_IO_ERROR;
}
return RTEMS_SUCCESSFUL;
}
2003434: 81 c7 e0 08 ret
2003438: 91 e8 00 08 restore %g0, %o0, %o0
200343c: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED
2003440: 81 c7 e0 08 ret <== NOT EXECUTED
2003444: 81 e8 00 00 restore <== NOT EXECUTED
02003868 <rtems_bdpart_register>:
rtems_status_code rtems_bdpart_register(
const char *disk_name,
const rtems_bdpart_partition *pt,
size_t count
)
{
2003868: 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);
200386c: 90 10 00 18 mov %i0, %o0
2003870: 40 00 4b fb call 201685c <strlen>
2003874: c0 27 bf f4 clr [ %fp + -12 ]
size_t i = 0;
int fd = -1;
2003878: 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
)
{
200387c: 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);
2003880: a0 10 00 08 mov %o0, %l0
size_t i = 0;
int fd = -1;
2003884: 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);
2003888: 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;
200388c: c0 27 bf fc clr [ %fp + -4 ]
/* Get disk data */
sc = rtems_bdpart_get_disk_data( disk_name, &fd, &dd, &disk_end);
2003890: 92 07 bf f8 add %fp, -8, %o1
2003894: 94 07 bf fc add %fp, -4, %o2
2003898: 7f ff ff 2b call 2003544 <rtems_bdpart_get_disk_data>
200389c: 96 07 bf f4 add %fp, -12, %o3
if (sc != RTEMS_SUCCESSFUL) {
20038a0: b0 92 20 00 orcc %o0, 0, %i0
20038a4: 12 80 00 31 bne 2003968 <rtems_bdpart_register+0x100> <== NEVER TAKEN
20038a8: c2 07 bf fc ld [ %fp + -4 ], %g1
return sc;
}
disk = rtems_disk_get_device_identifier( dd);
close( fd);
20038ac: 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;
20038b0: e2 00 40 00 ld [ %g1 ], %l1
20038b4: 40 00 07 c2 call 20057bc <close>
20038b8: 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);
20038bc: 90 04 20 04 add %l0, 4, %o0
20038c0: 40 00 0a 23 call 200614c <malloc>
20038c4: b0 10 20 1a mov 0x1a, %i0
if (logical_disk_name == NULL) {
20038c8: 80 a2 20 00 cmp %o0, 0
20038cc: 02 80 00 27 be 2003968 <rtems_bdpart_register+0x100> <== NEVER TAKEN
20038d0: b8 10 00 08 mov %o0, %i4
return RTEMS_NO_MEMORY;
}
strncpy( logical_disk_name, disk_name, disk_name_size);
20038d4: 92 10 00 1d mov %i5, %o1
20038d8: 94 10 00 10 mov %l0, %o2
20038dc: 40 00 4c 68 call 2016a7c <strncpy>
20038e0: 25 00 80 91 sethi %hi(0x2024400), %l2
logical_disk_marker = logical_disk_name + disk_name_size;
20038e4: a0 07 00 10 add %i4, %l0, %l0
#include <string.h>
#include <rtems.h>
#include <rtems/bdpart.h>
rtems_status_code rtems_bdpart_register(
20038e8: 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);
20038ec: 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) {
20038f0: 10 80 00 16 b 2003948 <rtems_bdpart_register+0xe0>
20038f4: a4 14 a1 08 or %l2, 0x108, %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);
20038f8: 90 10 00 10 mov %l0, %o0
20038fc: 92 10 20 04 mov 4, %o1
2003900: 94 10 00 12 mov %l2, %o2
2003904: 40 00 49 39 call 2015de8 <snprintf>
2003908: 96 27 40 1b sub %i5, %i3, %o3
if (rv >= RTEMS_BDPART_NUMBER_SIZE) {
200390c: 80 a2 20 03 cmp %o0, 3
2003910: 14 80 00 13 bg 200395c <rtems_bdpart_register+0xf4> <== NEVER TAKEN
2003914: 90 10 00 11 mov %l1, %o0
esc = RTEMS_INVALID_NAME;
goto cleanup;
}
/* Create logical disk */
sc = rtems_disk_create_log(
2003918: da 06 60 04 ld [ %i1 + 4 ], %o5
logical_disk,
disk,
p->begin,
p->end - p->begin,
200391c: d8 06 40 00 ld [ %i1 ], %o4
esc = RTEMS_INVALID_NAME;
goto cleanup;
}
/* Create logical disk */
sc = rtems_disk_create_log(
2003920: f8 23 a0 5c st %i4, [ %sp + 0x5c ]
2003924: 92 10 00 1d mov %i5, %o1
2003928: 94 10 00 11 mov %l1, %o2
200392c: 96 10 00 1b mov %i3, %o3
2003930: 9a 23 40 0c sub %o5, %o4, %o5
2003934: 40 00 03 1e call 20045ac <rtems_disk_create_log>
2003938: b2 06 60 30 add %i1, 0x30, %i1
disk,
p->begin,
p->end - p->begin,
logical_disk_name
);
if (sc != RTEMS_SUCCESSFUL) {
200393c: 80 a2 20 00 cmp %o0, 0
2003940: 12 80 00 08 bne 2003960 <rtems_bdpart_register+0xf8> <== NEVER TAKEN
2003944: 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) {
2003948: 80 a7 40 1a cmp %i5, %i2
200394c: 32 bf ff eb bne,a 20038f8 <rtems_bdpart_register+0x90>
2003950: 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;
2003954: 10 80 00 03 b 2003960 <rtems_bdpart_register+0xf8>
2003958: b0 10 20 00 clr %i0
200395c: b0 10 20 03 mov 3, %i0 <== NOT EXECUTED
}
}
cleanup:
free( logical_disk_name);
2003960: 40 00 08 55 call 2005ab4 <free>
2003964: 90 10 00 1c mov %i4, %o0
return esc;
}
2003968: 81 c7 e0 08 ret
200396c: 81 e8 00 00 restore
02003970 <rtems_bdpart_register_from_disk>:
rtems_status_code rtems_bdpart_register_from_disk( const char *disk_name)
{
2003970: 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;
2003974: 82 10 20 10 mov 0x10, %g1
/* Read partitions */
sc = rtems_bdpart_read( disk_name, &format, pt, &count);
2003978: 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;
200397c: c2 27 bc e8 st %g1, [ %fp + -792 ]
/* Read partitions */
sc = rtems_bdpart_read( disk_name, &format, pt, &count);
2003980: 92 07 bc ec add %fp, -788, %o1
2003984: 94 07 bd 00 add %fp, -768, %o2
2003988: 7f ff ff 18 call 20035e8 <rtems_bdpart_read>
200398c: 96 07 bc e8 add %fp, -792, %o3
if (sc != RTEMS_SUCCESSFUL) {
2003990: 80 a2 20 00 cmp %o0, 0
2003994: 12 80 00 05 bne 20039a8 <rtems_bdpart_register_from_disk+0x38><== NEVER TAKEN
2003998: d4 07 bc e8 ld [ %fp + -792 ], %o2
return sc;
}
/* Register partitions */
return rtems_bdpart_register( disk_name, pt, count);
200399c: 90 10 00 18 mov %i0, %o0
20039a0: 7f ff ff b2 call 2003868 <rtems_bdpart_register>
20039a4: 92 07 bd 00 add %fp, -768, %o1
}
20039a8: 81 c7 e0 08 ret
20039ac: 91 e8 00 08 restore %g0, %o0, %o0
020214a0 <rtems_bdpart_unmount>:
const char *disk_name,
const rtems_bdpart_partition *pt __attribute__((unused)),
size_t count,
const char *mount_base
)
{
20214a0: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED
rtems_status_code esc = RTEMS_SUCCESSFUL;
const char *disk_file_name = strrchr( disk_name, '/');
20214a4: 92 10 20 2f mov 0x2f, %o1 <== NOT EXECUTED
20214a8: 40 00 74 bc call 203e798 <strrchr> <== NOT EXECUTED
20214ac: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
20214b0: 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);
20214b4: 40 00 70 97 call 203d710 <strlen> <== NOT EXECUTED
20214b8: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
20214bc: a0 10 00 08 mov %o0, %l0 <== NOT EXECUTED
size_t mount_base_size = strlen( mount_base);
20214c0: 40 00 70 94 call 203d710 <strlen> <== NOT EXECUTED
20214c4: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
size_t i = 0;
/* Get disk file name */
if (disk_file_name != NULL) {
20214c8: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED
20214cc: 02 80 00 07 be 20214e8 <rtems_bdpart_unmount+0x48> <== NOT EXECUTED
20214d0: b8 10 00 08 mov %o0, %i4 <== NOT EXECUTED
disk_file_name += 1;
20214d4: b2 06 60 01 inc %i1 <== NOT EXECUTED
disk_file_name_size = strlen( disk_file_name);
20214d8: 40 00 70 8e call 203d710 <strlen> <== NOT EXECUTED
20214dc: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
20214e0: 10 80 00 03 b 20214ec <rtems_bdpart_unmount+0x4c> <== NOT EXECUTED
20214e4: a0 10 00 08 mov %o0, %l0 <== NOT EXECUTED
} else {
disk_file_name = disk_name;
20214e8: 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);
20214ec: a2 04 00 1c add %l0, %i4, %l1 <== NOT EXECUTED
if (mount_point == NULL) {
esc = RTEMS_NO_MEMORY;
20214f0: 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);
20214f4: 7f ff 89 06 call 200390c <malloc> <== NOT EXECUTED
20214f8: 90 04 60 05 add %l1, 5, %o0 <== NOT EXECUTED
if (mount_point == NULL) {
20214fc: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2021500: 02 80 00 28 be 20215a0 <rtems_bdpart_unmount+0x100> <== NOT EXECUTED
2021504: ba 10 00 08 mov %o0, %i5 <== NOT EXECUTED
esc = RTEMS_NO_MEMORY;
goto cleanup;
}
strncpy( mount_point, mount_base, mount_base_size);
2021508: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
202150c: 40 00 71 3d call 203da00 <strncpy> <== NOT EXECUTED
2021510: 94 10 00 1c mov %i4, %o2 <== NOT EXECUTED
mount_point [mount_base_size] = '/';
2021514: 82 10 20 2f mov 0x2f, %g1 <== NOT EXECUTED
strncpy( mount_point + mount_base_size + 1, disk_file_name, disk_file_name_size);
2021518: 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] = '/';
202151c: c2 2f 40 1c stb %g1, [ %i5 + %i4 ] <== NOT EXECUTED
strncpy( mount_point + mount_base_size + 1, disk_file_name, disk_file_name_size);
2021520: 90 07 40 08 add %i5, %o0, %o0 <== NOT EXECUTED
2021524: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
2021528: 94 10 00 10 mov %l0, %o2 <== NOT EXECUTED
/* Marker */
mount_marker = mount_point + mount_base_size + 1 + disk_file_name_size;
202152c: 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);
2021530: 40 00 71 34 call 203da00 <strncpy> <== NOT EXECUTED
2021534: 37 00 81 67 sethi %hi(0x2059c00), %i3 <== NOT EXECUTED
/* Marker */
mount_marker = mount_point + mount_base_size + 1 + disk_file_name_size;
2021538: a2 07 40 11 add %i5, %l1, %l1 <== NOT EXECUTED
/* Mount supported file systems for each partition */
for (i = 0; i < count; ++i) {
202153c: b8 10 20 00 clr %i4 <== NOT EXECUTED
2021540: 10 80 00 14 b 2021590 <rtems_bdpart_unmount+0xf0> <== NOT EXECUTED
2021544: b6 16 e2 88 or %i3, 0x288, %i3 <== NOT EXECUTED
/* Create mount point */
int rv = snprintf( mount_marker, RTEMS_BDPART_NUMBER_SIZE, "%zu", i + 1);
2021548: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED
202154c: 92 10 20 04 mov 4, %o1 <== NOT EXECUTED
2021550: 94 10 00 1b mov %i3, %o2 <== NOT EXECUTED
2021554: 40 00 6c d1 call 203c898 <snprintf> <== NOT EXECUTED
2021558: 96 10 00 1c mov %i4, %o3 <== NOT EXECUTED
if (rv >= RTEMS_BDPART_NUMBER_SIZE) {
202155c: 80 a2 20 03 cmp %o0, 3 <== NOT EXECUTED
2021560: 14 80 00 10 bg 20215a0 <rtems_bdpart_unmount+0x100> <== NOT EXECUTED
2021564: b0 10 20 03 mov 3, %i0 <== NOT EXECUTED
esc = RTEMS_INVALID_NAME;
goto cleanup;
}
/* Unmount */
rv = unmount( mount_point);
2021568: 40 00 0f 8e call 20253a0 <unmount> <== NOT EXECUTED
202156c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
if (rv == 0) {
2021570: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2021574: 12 80 00 08 bne 2021594 <rtems_bdpart_unmount+0xf4> <== NOT EXECUTED
2021578: 80 a7 00 1a cmp %i4, %i2 <== NOT EXECUTED
/* Remove mount point */
rv = rmdir( mount_point);
202157c: 40 00 0d f8 call 2024d5c <rmdir> <== NOT EXECUTED
2021580: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
if (rv != 0) {
2021584: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2021588: 12 80 00 06 bne 20215a0 <rtems_bdpart_unmount+0x100> <== NOT EXECUTED
202158c: 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) {
2021590: 80 a7 00 1a cmp %i4, %i2 <== NOT EXECUTED
2021594: 32 bf ff ed bne,a 2021548 <rtems_bdpart_unmount+0xa8> <== NOT EXECUTED
2021598: b8 07 20 01 inc %i4 <== NOT EXECUTED
202159c: b0 10 20 00 clr %i0 <== NOT EXECUTED
}
}
cleanup:
free( mount_point);
20215a0: 7f ff 87 f2 call 2003568 <free> <== NOT EXECUTED
20215a4: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
return esc;
}
20215a8: 81 c7 e0 08 ret <== NOT EXECUTED
20215ac: 81 e8 00 00 restore <== NOT EXECUTED
020039b0 <rtems_bdpart_unregister>:
rtems_status_code rtems_bdpart_unregister(
const char *disk_name,
const rtems_bdpart_partition *pt __attribute__((unused)),
size_t count
)
{
20039b0: 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;
20039b4: 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);
20039b8: 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;
20039bc: c0 27 bf f4 clr [ %fp + -12 ]
dev_t disk = 0;
dev_t logical_disk = 0;
size_t i = 0;
int fd = -1;
20039c0: c2 27 bf f8 st %g1, [ %fp + -8 ]
rtems_disk_device *dd = NULL;
20039c4: c0 27 bf fc clr [ %fp + -4 ]
/* Get disk data */
sc = rtems_bdpart_get_disk_data( disk_name, &fd, &dd, &disk_end);
20039c8: 92 07 bf f8 add %fp, -8, %o1
20039cc: 94 07 bf fc add %fp, -4, %o2
20039d0: 7f ff fe dd call 2003544 <rtems_bdpart_get_disk_data>
20039d4: 96 07 bf f4 add %fp, -12, %o3
if (sc != RTEMS_SUCCESSFUL) {
20039d8: b0 92 20 00 orcc %o0, 0, %i0
20039dc: 12 80 00 10 bne 2003a1c <rtems_bdpart_unregister+0x6c> <== NEVER TAKEN
20039e0: c2 07 bf fc ld [ %fp + -4 ], %g1
return sc;
}
disk = rtems_disk_get_device_identifier( dd);
close( fd);
20039e4: d0 07 bf f8 ld [ %fp + -8 ], %o0
20039e8: 40 00 07 75 call 20057bc <close>
20039ec: 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) {
20039f0: 10 80 00 08 b 2003a10 <rtems_bdpart_unregister+0x60>
20039f4: 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);
20039f8: 90 10 00 1c mov %i4, %o0
20039fc: 40 00 02 84 call 200440c <rtems_disk_delete>
2003a00: 92 10 00 1d mov %i5, %o1
if (sc != RTEMS_SUCCESSFUL) {
2003a04: 80 a2 20 00 cmp %o0, 0
2003a08: 32 80 00 05 bne,a 2003a1c <rtems_bdpart_unregister+0x6c> <== NEVER TAKEN
2003a0c: 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) {
2003a10: 80 a7 40 1a cmp %i5, %i2
2003a14: 12 bf ff f9 bne 20039f8 <rtems_bdpart_unregister+0x48>
2003a18: ba 07 60 01 inc %i5
2003a1c: 81 c7 e0 08 ret
2003a20: 81 e8 00 00 restore
02003b08 <rtems_bdpart_write>:
const char *disk_name,
const rtems_bdpart_format *format,
const rtems_bdpart_partition *pt,
size_t count
)
{
2003b08: 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;
2003b0c: 80 a6 60 00 cmp %i1, 0
2003b10: 02 80 00 08 be 2003b30 <rtems_bdpart_write+0x28> <== NEVER TAKEN
2003b14: 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
2003b18: c4 06 40 00 ld [ %i1 ], %g2
2003b1c: 80 a0 a0 00 cmp %g2, 0
2003b20: 12 80 00 05 bne 2003b34 <rtems_bdpart_write+0x2c> <== NEVER TAKEN
2003b24: 82 10 20 00 clr %g1
&& format->mbr.dos_compatibility;
2003b28: 10 80 00 03 b 2003b34 <rtems_bdpart_write+0x2c>
2003b2c: c2 0e 60 08 ldub [ %i1 + 8 ], %g1
2003b30: 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
2003b34: a2 08 60 01 and %g1, 1, %l1
&& format->type == RTEMS_BDPART_FORMAT_MBR
&& format->mbr.dos_compatibility;
rtems_bdbuf_buffer *block = NULL;
2003b38: c0 27 bf f0 clr [ %fp + -16 ]
rtems_blkdev_bnum disk_end = 0;
rtems_blkdev_bnum record_space =
2003b3c: 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;
2003b40: 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 =
2003b44: 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;
2003b48: 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;
2003b4c: c2 27 bf f8 st %g1, [ %fp + -8 ]
rtems_disk_device *dd = NULL;
2003b50: 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 =
2003b54: 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;
2003b58: 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 =
2003b5c: 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) {
2003b60: 80 a6 e0 00 cmp %i3, 0
2003b64: 02 80 00 cd be 2003e98 <rtems_bdpart_write+0x390> <== NEVER TAKEN
2003b68: b8 07 20 3f add %i4, 0x3f, %i4
/* Nothing to do */
return RTEMS_SUCCESSFUL;
}
/* Check parameter */
if (format == NULL || pt == NULL) {
2003b6c: 80 a6 a0 00 cmp %i2, 0
2003b70: 02 80 00 ca be 2003e98 <rtems_bdpart_write+0x390> <== NEVER TAKEN
2003b74: b0 10 20 09 mov 9, %i0
2003b78: 80 a6 60 00 cmp %i1, 0
2003b7c: 02 80 00 c7 be 2003e98 <rtems_bdpart_write+0x390> <== NEVER TAKEN
2003b80: 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);
2003b84: 94 07 bf fc add %fp, -4, %o2
2003b88: 7f ff fe 6f call 2003544 <rtems_bdpart_get_disk_data>
2003b8c: 96 07 bf f4 add %fp, -12, %o3
if (sc != RTEMS_SUCCESSFUL) {
2003b90: b0 92 20 00 orcc %o0, 0, %i0
2003b94: 12 80 00 c1 bne 2003e98 <rtems_bdpart_write+0x390> <== NEVER TAKEN
2003b98: 80 a7 60 00 cmp %i5, 0
return sc;
}
/* Align end of disk on cylinder boundary if necessary */
if (dos_compatibility) {
2003b9c: 02 80 00 09 be 2003bc0 <rtems_bdpart_write+0xb8> <== NEVER TAKEN
2003ba0: c8 07 bf f4 ld [ %fp + -12 ], %g4
disk_end -= (disk_end % record_space);
2003ba4: fa 07 bf f4 ld [ %fp + -12 ], %i5
2003ba8: 92 10 00 1c mov %i4, %o1
2003bac: 40 00 78 8e call 2021de4 <.urem>
2003bb0: 90 10 00 1d mov %i5, %o0
2003bb4: 90 27 40 08 sub %i5, %o0, %o0
2003bb8: 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) {
2003bbc: c8 07 bf f4 ld [ %fp + -12 ], %g4
2003bc0: a0 10 00 1a mov %i2, %l0
2003bc4: 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) {
2003bc8: 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) {
2003bcc: c6 00 40 00 ld [ %g1 ], %g3
2003bd0: 80 a0 c0 04 cmp %g3, %g4
2003bd4: 3a 80 00 a5 bcc,a 2003e68 <rtems_bdpart_write+0x360> <== NEVER TAKEN
2003bd8: b0 10 20 0a mov 0xa, %i0 <== NOT EXECUTED
2003bdc: fa 00 60 04 ld [ %g1 + 4 ], %i5
2003be0: 80 a7 40 04 cmp %i5, %g4
2003be4: 18 80 00 9e bgu 2003e5c <rtems_bdpart_write+0x354> <== NEVER TAKEN
2003be8: 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) {
2003bec: 1a 80 00 9c bcc 2003e5c <rtems_bdpart_write+0x354> <== NEVER TAKEN
2003bf0: 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) {
2003bf4: 02 80 00 06 be 2003c0c <rtems_bdpart_write+0x104>
2003bf8: 84 00 a0 01 inc %g2
2003bfc: fa 00 7f d4 ld [ %g1 + -44 ], %i5
2003c00: 80 a7 40 03 cmp %i5, %g3
2003c04: 38 80 00 99 bgu,a 2003e68 <rtems_bdpart_write+0x360> <== NEVER TAKEN
2003c08: 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) {
2003c0c: 80 a0 80 1b cmp %g2, %i3
2003c10: 12 bf ff ef bne 2003bcc <rtems_bdpart_write+0xc4>
2003c14: 82 00 60 30 add %g1, 0x30, %g1
goto cleanup;
}
}
/* Check format */
if (format->type != RTEMS_BDPART_FORMAT_MBR) {
2003c18: c2 06 40 00 ld [ %i1 ], %g1
2003c1c: 80 a0 60 00 cmp %g1, 0
2003c20: 12 80 00 92 bne 2003e68 <rtems_bdpart_write+0x360> <== NEVER TAKEN
2003c24: 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;
2003c28: 80 a6 e0 04 cmp %i3, 4
2003c2c: 08 80 00 03 bleu 2003c38 <rtems_bdpart_write+0x130> <== NEVER TAKEN
2003c30: ba 10 00 1b mov %i3, %i5
2003c34: 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) {
2003c38: 80 8c 60 ff btst 0xff, %l1
2003c3c: 32 80 00 09 bne,a 2003c60 <rtems_bdpart_write+0x158> <== ALWAYS TAKEN
2003c40: c2 06 80 00 ld [ %i2 ], %g1
RTEMS_BDPART_MBR_SIGNATURE_1;
return RTEMS_SUCCESSFUL;
}
rtems_status_code rtems_bdpart_write(
2003c44: 83 2f 60 04 sll %i5, 4, %g1 <== NOT EXECUTED
2003c48: a5 2f 60 06 sll %i5, 6, %l2
2003c4c: 84 10 00 1d mov %i5, %g2
2003c50: a4 24 80 01 sub %l2, %g1, %l2
2003c54: 82 10 20 00 clr %g1
2003c58: 10 80 00 0e b 2003c90 <rtems_bdpart_write+0x188>
2003c5c: 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) {
2003c60: 80 a0 60 3f cmp %g1, 0x3f
2003c64: 12 80 00 81 bne 2003e68 <rtems_bdpart_write+0x360> <== NEVER TAKEN
2003c68: b0 10 20 0a mov 0xa, %i0
RTEMS_BDPART_MBR_SIGNATURE_1;
return RTEMS_SUCCESSFUL;
}
rtems_status_code rtems_bdpart_write(
2003c6c: 10 bf ff f7 b 2003c48 <rtems_bdpart_write+0x140>
2003c70: 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) {
2003c74: c8 04 40 01 ld [ %l1 + %g1 ], %g4
2003c78: c6 00 ff d4 ld [ %g3 + -44 ], %g3
2003c7c: 86 21 00 03 sub %g4, %g3, %g3
2003c80: 80 a0 c0 1c cmp %g3, %i4
2003c84: 0a 80 00 76 bcs 2003e5c <rtems_bdpart_write+0x354> <== NEVER TAKEN
2003c88: 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) {
2003c8c: 84 00 a0 01 inc %g2
2003c90: 80 a0 80 1b cmp %g2, %i3
2003c94: 0a bf ff f8 bcs 2003c74 <rtems_bdpart_write+0x16c>
2003c98: 86 04 40 01 add %l1, %g1, %g3
2003c9c: b0 10 00 1a mov %i2, %i0
2003ca0: 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;
2003ca4: 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)) {
2003ca8: 90 06 20 08 add %i0, 8, %o0
2003cac: 7f ff fe 1a call 2003514 <rtems_bdpart_to_mbr_partition_type>
2003cb0: 92 07 bf ef add %fp, -17, %o1
2003cb4: 80 8a 20 ff btst 0xff, %o0
2003cb8: 22 80 00 6c be,a 2003e68 <rtems_bdpart_write+0x360> <== NEVER TAKEN
2003cbc: b0 10 20 04 mov 4, %i0 <== NOT EXECUTED
2003cc0: b0 06 20 30 add %i0, 0x30, %i0
esc = RTEMS_INVALID_ID;
goto cleanup;
}
/* Check flags */
if (p->flags > 0xffU) {
2003cc4: c2 06 3f f8 ld [ %i0 + -8 ], %g1
2003cc8: 80 a0 60 00 cmp %g1, 0
2003ccc: 32 80 00 67 bne,a 2003e68 <rtems_bdpart_write+0x360> <== NEVER TAKEN
2003cd0: b0 10 20 04 mov 4, %i0 <== NOT EXECUTED
2003cd4: c2 06 3f fc ld [ %i0 + -4 ], %g1
2003cd8: 80 a0 60 ff cmp %g1, 0xff
2003cdc: 18 80 00 07 bgu 2003cf8 <rtems_bdpart_write+0x1f0> <== NEVER TAKEN
2003ce0: 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) {
2003ce4: 80 a4 c0 1b cmp %l3, %i3
2003ce8: 32 bf ff f0 bne,a 2003ca8 <rtems_bdpart_write+0x1a0>
2003cec: c0 2f bf ef clrb [ %fp + -17 ]
/* Check ID */
/* TODO */
}
/* New MBR */
sc = rtems_bdpart_new_record( dd, 0, &block);
2003cf0: 10 80 00 04 b 2003d00 <rtems_bdpart_write+0x1f8>
2003cf4: d0 07 bf fc ld [ %fp + -4 ], %o0
2003cf8: 10 80 00 5c b 2003e68 <rtems_bdpart_write+0x360> <== NOT EXECUTED
2003cfc: b0 10 20 04 mov 4, %i0 <== NOT EXECUTED
2003d00: 92 10 20 00 clr %o1
2003d04: 7f ff ff 48 call 2003a24 <rtems_bdpart_new_record>
2003d08: 94 07 bf f0 add %fp, -16, %o2
if (sc != RTEMS_SUCCESSFUL) {
2003d0c: b0 92 20 00 orcc %o0, 0, %i0
2003d10: 12 80 00 57 bne 2003e6c <rtems_bdpart_write+0x364> <== NEVER TAKEN
2003d14: 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
2003d18: c2 07 bf f0 ld [ %fp + -16 ], %g1
esc = sc;
goto cleanup;
}
/* Write disk ID */
rtems_uint32_to_little_endian(
2003d1c: c4 06 60 04 ld [ %i1 + 4 ], %g2
format->mbr.disk_id,
block->buffer + RTEMS_BDPART_MBR_OFFSET_DISK_ID
2003d20: c8 00 60 1c ld [ %g1 + 0x1c ], %g4
2003d24: 82 10 20 00 clr %g1
RTEMS_BDPART_MBR_SIGNATURE_1;
return RTEMS_SUCCESSFUL;
}
rtems_status_code rtems_bdpart_write(
2003d28: 86 01 00 01 add %g4, %g1, %g3
data [i] = (uint8_t) value;
2003d2c: 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) {
2003d30: 82 00 60 01 inc %g1
2003d34: 80 a0 60 04 cmp %g1, 4
2003d38: 12 bf ff fc bne 2003d28 <rtems_bdpart_write+0x220>
2003d3c: 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;
2003d40: c2 07 bf f0 ld [ %fp + -16 ], %g1
for (i = 0; i < ppc; ++i) {
2003d44: 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;
2003d48: e6 00 60 1c ld [ %g1 + 0x1c ], %l3
2003d4c: a6 04 e1 be add %l3, 0x1be, %l3
for (i = 0; i < ppc; ++i) {
2003d50: 10 80 00 0b b 2003d7c <rtems_bdpart_write+0x274>
2003d54: b0 10 00 13 mov %l3, %i0
const rtems_bdpart_partition *p = pt + i;
/* Write partition entry */
rtems_bdpart_write_mbr_partition(
2003d58: d4 04 20 04 ld [ %l0 + 4 ], %o2
2003d5c: d6 0c 20 08 ldub [ %l0 + 8 ], %o3
2003d60: d8 0c 20 2f ldub [ %l0 + 0x2f ], %o4
2003d64: 90 10 00 18 mov %i0, %o0
2003d68: 94 22 80 09 sub %o2, %o1, %o2
2003d6c: 7f ff ff 56 call 2003ac4 <rtems_bdpart_write_mbr_partition>
2003d70: 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) {
2003d74: b2 06 60 01 inc %i1
2003d78: a0 04 20 30 add %l0, 0x30, %l0
2003d7c: 80 a6 40 1d cmp %i1, %i5
2003d80: 32 bf ff f6 bne,a 2003d58 <rtems_bdpart_write+0x250>
2003d84: d2 04 00 00 ld [ %l0 ], %o1
RTEMS_BDPART_MBR_SIGNATURE_1;
return RTEMS_SUCCESSFUL;
}
rtems_status_code rtems_bdpart_write(
2003d88: 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;
2003d8c: b0 10 20 00 clr %i0
data += RTEMS_BDPART_MBR_TABLE_ENTRY_SIZE;
}
/* Write extended partition with logical partitions if necessary */
if (ppc != count) {
2003d90: 80 a7 40 1b cmp %i5, %i3
2003d94: 02 80 00 35 be 2003e68 <rtems_bdpart_write+0x360> <== NEVER TAKEN
2003d98: 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;
2003d9c: e0 06 80 12 ld [ %i2 + %l2 ], %l0
/* Write extended partition */
rtems_bdpart_write_mbr_partition(
2003da0: 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;
2003da4: a0 24 00 1c sub %l0, %i4, %l0
/* Write extended partition */
rtems_bdpart_write_mbr_partition(
2003da8: 96 10 20 05 mov 5, %o3
2003dac: 92 10 00 10 mov %l0, %o1
2003db0: 94 22 80 10 sub %o2, %l0, %o2
2003db4: 98 10 20 00 clr %o4
2003db8: 7f ff ff 43 call 2003ac4 <rtems_bdpart_write_mbr_partition>
2003dbc: b4 10 00 11 mov %l1, %i2
RTEMS_BDPART_MBR_EXTENDED,
0
);
/* Write logical partitions */
for (i = ppc; i < count; ++i) {
2003dc0: 10 80 00 22 b 2003e48 <rtems_bdpart_write+0x340>
2003dc4: b2 10 00 1d mov %i5, %i1
const rtems_bdpart_partition *p = pt + i;
/* Write second partition entry */
if (i > ppc) {
2003dc8: 28 80 00 0e bleu,a 2003e00 <rtems_bdpart_write+0x2f8>
2003dcc: 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,
2003dd0: 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;
2003dd4: c2 06 80 00 ld [ %i2 ], %g1
rtems_bdpart_write_mbr_partition(
2003dd8: d0 00 a0 1c ld [ %g2 + 0x1c ], %o0
2003ddc: 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;
2003de0: 82 20 40 1c sub %g1, %i4, %g1
rtems_bdpart_write_mbr_partition(
2003de4: 90 02 21 ce add %o0, 0x1ce, %o0
2003de8: 92 20 40 10 sub %g1, %l0, %o1
2003dec: 94 22 80 01 sub %o2, %g1, %o2
2003df0: 96 10 20 05 mov 5, %o3
2003df4: 7f ff ff 34 call 2003ac4 <rtems_bdpart_write_mbr_partition>
2003df8: 98 10 20 00 clr %o4
0
);
}
/* New EBR */
ebr = p->begin - record_space;
2003dfc: d2 06 80 00 ld [ %i2 ], %o1
sc = rtems_bdpart_new_record( dd, ebr, &block);
2003e00: d0 07 bf fc ld [ %fp + -4 ], %o0
2003e04: 92 22 40 1c sub %o1, %i4, %o1
2003e08: 7f ff ff 07 call 2003a24 <rtems_bdpart_new_record>
2003e0c: 94 07 bf f0 add %fp, -16, %o2
if (sc != RTEMS_SUCCESSFUL) {
2003e10: 80 a2 20 00 cmp %o0, 0
2003e14: 12 80 00 14 bne 2003e64 <rtems_bdpart_write+0x35c> <== NEVER TAKEN
2003e18: c2 07 bf f0 ld [ %fp + -16 ], %g1
esc = sc;
goto cleanup;
}
/* Write first partition entry */
rtems_bdpart_write_mbr_partition(
2003e1c: d4 06 a0 04 ld [ %i2 + 4 ], %o2
2003e20: d0 00 60 1c ld [ %g1 + 0x1c ], %o0
2003e24: d6 0e a0 08 ldub [ %i2 + 8 ], %o3
2003e28: c2 06 80 00 ld [ %i2 ], %g1
2003e2c: d8 0e a0 2f ldub [ %i2 + 0x2f ], %o4
2003e30: 90 02 21 be add %o0, 0x1be, %o0
2003e34: 92 10 00 1c mov %i4, %o1
2003e38: 94 22 80 01 sub %o2, %g1, %o2
2003e3c: 7f ff ff 22 call 2003ac4 <rtems_bdpart_write_mbr_partition>
2003e40: b2 06 60 01 inc %i1
2003e44: b4 06 a0 30 add %i2, 0x30, %i2
RTEMS_BDPART_MBR_EXTENDED,
0
);
/* Write logical partitions */
for (i = ppc; i < count; ++i) {
2003e48: 80 a6 40 1b cmp %i1, %i3
2003e4c: 0a bf ff df bcs 2003dc8 <rtems_bdpart_write+0x2c0>
2003e50: 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;
2003e54: 10 80 00 05 b 2003e68 <rtems_bdpart_write+0x360>
2003e58: 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;
2003e5c: 10 80 00 03 b 2003e68 <rtems_bdpart_write+0x360> <== NOT EXECUTED
2003e60: 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) {
2003e64: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED
}
}
cleanup:
if (fd >= 0) {
2003e68: d0 07 bf f8 ld [ %fp + -8 ], %o0
2003e6c: 80 a2 20 00 cmp %o0, 0
2003e70: 26 80 00 05 bl,a 2003e84 <rtems_bdpart_write+0x37c> <== NEVER TAKEN
2003e74: d0 07 bf f0 ld [ %fp + -16 ], %o0 <== NOT EXECUTED
close( fd);
2003e78: 40 00 06 51 call 20057bc <close>
2003e7c: 01 00 00 00 nop
}
if (block != NULL) {
2003e80: d0 07 bf f0 ld [ %fp + -16 ], %o0
2003e84: 80 a2 20 00 cmp %o0, 0
2003e88: 02 80 00 06 be 2003ea0 <rtems_bdpart_write+0x398> <== NEVER TAKEN
2003e8c: 01 00 00 00 nop
rtems_bdbuf_sync( block);
2003e90: 40 00 30 d3 call 20101dc <rtems_bdbuf_sync>
2003e94: 01 00 00 00 nop
2003e98: 81 c7 e0 08 ret
2003e9c: 81 e8 00 00 restore
}
return esc;
}
2003ea0: 81 c7 e0 08 ret <== NOT EXECUTED
2003ea4: 81 e8 00 00 restore <== NOT EXECUTED
02003b90 <rtems_blkdev_create_partition>:
const char *partition,
const char *device,
rtems_blkdev_bnum block_begin,
rtems_blkdev_bnum block_count
)
{
2003b90: 9d e3 bf 50 save %sp, -176, %sp
rtems_status_code sc = RTEMS_SUCCESSFUL;
int fd = open(device, O_RDWR);
2003b94: 92 10 20 02 mov 2, %o1
2003b98: 90 10 00 19 mov %i1, %o0
2003b9c: 40 00 09 f2 call 2006364 <open>
2003ba0: ba 10 20 04 mov 4, %i5
if (fd >= 0) {
2003ba4: 80 a2 20 00 cmp %o0, 0
2003ba8: 06 80 00 33 bl 2003c74 <rtems_blkdev_create_partition+0xe4>
2003bac: b2 10 00 08 mov %o0, %i1
int rv;
struct stat st;
rv = fstat(fd, &st);
2003bb0: 40 00 06 45 call 20054c4 <fstat>
2003bb4: 92 07 bf b8 add %fp, -72, %o1
if (rv == 0 && S_ISBLK(st.st_mode)) {
2003bb8: 80 a2 20 00 cmp %o0, 0
2003bbc: 12 80 00 2c bne 2003c6c <rtems_blkdev_create_partition+0xdc><== NEVER TAKEN
2003bc0: ba 10 20 15 mov 0x15, %i5
2003bc4: e0 07 bf c4 ld [ %fp + -60 ], %l0
2003bc8: 03 00 00 3c sethi %hi(0xf000), %g1
2003bcc: a0 0c 00 01 and %l0, %g1, %l0
2003bd0: 03 00 00 18 sethi %hi(0x6000), %g1
2003bd4: 80 a4 00 01 cmp %l0, %g1
2003bd8: 12 80 00 25 bne 2003c6c <rtems_blkdev_create_partition+0xdc>
2003bdc: 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);
2003be0: 13 10 01 10 sethi %hi(0x40044000), %o1
2003be4: 94 07 bf b4 add %fp, -76, %o2
2003be8: 92 12 62 09 or %o1, 0x209, %o1
2003bec: 40 00 06 8d call 2005620 <ioctl>
2003bf0: 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) {
2003bf4: 80 a2 20 00 cmp %o0, 0
2003bf8: 12 80 00 1d bne 2003c6c <rtems_blkdev_create_partition+0xdc>
2003bfc: 01 00 00 00 nop
rtems_blkdev_imfs_context *ctx = malloc(sizeof(*ctx));
2003c00: 40 00 07 ad call 2005ab4 <malloc>
2003c04: 90 10 20 80 mov 0x80, %o0 ! 80 <PROM_START+0x80>
if (ctx != NULL) {
2003c08: b8 92 20 00 orcc %o0, 0, %i4
2003c0c: 02 80 00 17 be 2003c68 <rtems_blkdev_create_partition+0xd8>
2003c10: d2 07 bf b4 ld [ %fp + -76 ], %o1
sc = rtems_disk_init_log(
2003c14: 94 10 00 1a mov %i2, %o2
2003c18: 40 00 00 90 call 2003e58 <rtems_disk_init_log>
2003c1c: 96 10 00 1b mov %i3, %o3
phys_dd,
block_begin,
block_count
);
if (sc == RTEMS_SUCCESSFUL) {
2003c20: ba 92 20 00 orcc %o0, 0, %i5
2003c24: 12 80 00 0e bne 2003c5c <rtems_blkdev_create_partition+0xcc>
2003c28: 90 10 00 18 mov %i0, %o0
ctx->fd = fd;
2003c2c: f2 27 20 78 st %i1, [ %i4 + 0x78 ]
rv = IMFS_make_generic_node(
2003c30: 92 14 21 ff or %l0, 0x1ff, %o1
2003c34: 15 00 80 7e sethi %hi(0x201f800), %o2
2003c38: 96 10 00 1c mov %i4, %o3
2003c3c: 40 00 03 8f call 2004a78 <IMFS_make_generic_node>
2003c40: 94 12 a0 98 or %o2, 0x98, %o2
S_IFBLK | S_IRWXU | S_IRWXG | S_IRWXO,
&rtems_blkdev_imfs_control,
ctx
);
if (rv != 0) {
2003c44: 80 a2 20 00 cmp %o0, 0
2003c48: 02 80 00 0b be 2003c74 <rtems_blkdev_create_partition+0xe4>
2003c4c: 90 10 00 1c mov %i4, %o0
free(ctx);
2003c50: 40 00 05 f3 call 200541c <free>
2003c54: ba 10 20 0d mov 0xd, %i5
2003c58: 30 80 00 05 b,a 2003c6c <rtems_blkdev_create_partition+0xdc>
sc = RTEMS_UNSATISFIED;
}
} else {
free(ctx);
2003c5c: 40 00 05 f0 call 200541c <free>
2003c60: 90 10 00 1c mov %i4, %o0
2003c64: 30 80 00 02 b,a 2003c6c <rtems_blkdev_create_partition+0xdc>
2003c68: ba 10 20 1a mov 0x1a, %i5
} else {
sc = RTEMS_INVALID_NODE;
}
if (sc != RTEMS_SUCCESSFUL) {
close(fd);
2003c6c: 40 00 05 2e call 2005124 <close>
2003c70: 90 10 00 19 mov %i1, %o0
} else {
sc = RTEMS_INVALID_ID;
}
return sc;
}
2003c74: 81 c7 e0 08 ret
2003c78: 91 e8 00 1d restore %g0, %i5, %o0
0200f50c <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)
{
200f50c: 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;
200f510: c2 06 80 00 ld [ %i2 ], %g1
if (args->command != RTEMS_BLKIO_REQUEST)
200f514: 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;
200f518: d0 00 60 30 ld [ %g1 + 0x30 ], %o0
if (args->command != RTEMS_BLKIO_REQUEST)
200f51c: 03 30 06 10 sethi %hi(0xc0184000), %g1
200f520: 82 10 62 01 or %g1, 0x201, %g1 ! c0184201 <RAM_END+0xbdd84201>
200f524: 80 a2 40 01 cmp %o1, %g1
200f528: 02 80 00 07 be 200f544 <rtems_blkdev_generic_ioctl+0x38> <== NEVER TAKEN
200f52c: 82 10 3f ff mov -1, %g1
{
args->ioctl_return = dd->ioctl(dd,
200f530: c2 02 20 38 ld [ %o0 + 0x38 ], %g1
200f534: 9f c0 40 00 call %g1
200f538: d4 06 a0 08 ld [ %i2 + 8 ], %o2
200f53c: 10 80 00 03 b 200f548 <rtems_blkdev_generic_ioctl+0x3c>
200f540: d0 26 a0 0c st %o0, [ %i2 + 0xc ]
{
/*
* It is not allowed to directly access the driver circumventing the
* cache.
*/
args->ioctl_return = -1;
200f544: c2 26 a0 0c st %g1, [ %i2 + 0xc ] <== NOT EXECUTED
}
return RTEMS_SUCCESSFUL;
}
200f548: 81 c7 e0 08 ret
200f54c: 91 e8 20 00 restore %g0, 0, %o0
0200f2ec <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)
{
200f2ec: 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;
200f2f0: 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);
200f2f4: 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;
200f2f8: 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);
200f2fc: 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;
200f300: 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);
200f304: 94 10 20 00 clr %o2
200f308: 96 10 00 10 mov %l0, %o3
200f30c: 40 00 37 14 call 201cf5c <__divdi3>
200f310: 92 10 00 1d mov %i5, %o1
uint32_t blkofs = (uint32_t) (args->offset % block_size);
200f314: 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);
200f318: a6 10 00 09 mov %o1, %l3
uint32_t blkofs = (uint32_t) (args->offset % block_size);
200f31c: 94 10 20 00 clr %o2
200f320: 92 10 00 1d mov %i5, %o1
200f324: 96 10 00 10 mov %l0, %o3
200f328: 40 00 37 f8 call 201d308 <__moddi3>
200f32c: 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;
200f330: 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);
200f334: a2 10 00 09 mov %o1, %l1
args->bytes_moved = 0;
200f338: c0 26 a0 1c clr [ %i2 + 0x1c ]
while (count > 0)
200f33c: 10 80 00 1c b 200f3ac <rtems_blkdev_generic_read+0xc0>
200f340: b8 10 20 00 clr %i4
{
rtems_bdbuf_buffer *diskbuf;
uint32_t copy;
rc = rtems_bdbuf_read(dd, block, &diskbuf);
200f344: 90 10 00 12 mov %l2, %o0
200f348: 7f ff fd a2 call 200e9d0 <rtems_bdbuf_read>
200f34c: 94 07 bf fc add %fp, -4, %o2
if (rc != RTEMS_SUCCESSFUL)
200f350: 80 a2 20 00 cmp %o0, 0
200f354: 12 80 00 1a bne 200f3bc <rtems_blkdev_generic_read+0xd0> <== NEVER TAKEN
200f358: ba 24 00 11 sub %l0, %l1, %i5
200f35c: 80 a7 40 1b cmp %i5, %i3
200f360: 38 80 00 02 bgu,a 200f368 <rtems_blkdev_generic_read+0x7c><== NEVER TAKEN
200f364: 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);
200f368: c2 07 bf fc ld [ %fp + -4 ], %g1
200f36c: 94 10 00 1d mov %i5, %o2
200f370: d2 00 60 1c ld [ %g1 + 0x1c ], %o1
200f374: 90 10 00 19 mov %i1, %o0
200f378: 40 00 14 50 call 20144b8 <memcpy>
200f37c: 92 02 40 11 add %o1, %l1, %o1
rc = rtems_bdbuf_release(diskbuf);
200f380: d0 07 bf fc ld [ %fp + -4 ], %o0
200f384: 7f ff fe 10 call 200ebc4 <rtems_bdbuf_release>
200f388: b8 07 20 01 inc %i4
args->bytes_moved += copy;
200f38c: c2 06 a0 1c ld [ %i2 + 0x1c ], %g1
if (rc != RTEMS_SUCCESSFUL)
200f390: 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;
200f394: 82 00 40 1d add %g1, %i5, %g1
if (rc != RTEMS_SUCCESSFUL)
200f398: 12 80 00 09 bne 200f3bc <rtems_blkdev_generic_read+0xd0> <== NEVER TAKEN
200f39c: c2 26 a0 1c st %g1, [ %i2 + 0x1c ]
break;
count -= copy;
200f3a0: b6 26 c0 1d sub %i3, %i5, %i3
buf += copy;
200f3a4: b2 06 40 1d add %i1, %i5, %i1
blkofs = 0;
200f3a8: 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)
200f3ac: 80 a6 e0 00 cmp %i3, 0
200f3b0: 12 bf ff e5 bne 200f344 <rtems_blkdev_generic_read+0x58>
200f3b4: 92 07 00 13 add %i4, %l3, %o1
200f3b8: 90 10 20 00 clr %o0
blkofs = 0;
block++;
}
return rc;
}
200f3bc: 81 c7 e0 08 ret
200f3c0: 91 e8 00 08 restore %g0, %o0, %o0
0200f3c4 <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)
{
200f3c4: 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;
200f3c8: 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);
200f3cc: 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;
200f3d0: 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);
200f3d4: 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;
200f3d8: 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);
200f3dc: 94 10 20 00 clr %o2
200f3e0: 96 10 00 19 mov %i1, %o3
200f3e4: 40 00 36 de call 201cf5c <__divdi3>
200f3e8: 92 10 00 1d mov %i5, %o1
uint32_t blkofs = (uint32_t) (args->offset % block_size);
200f3ec: 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);
200f3f0: a4 10 00 09 mov %o1, %l2
uint32_t blkofs = (uint32_t) (args->offset % block_size);
200f3f4: 94 10 20 00 clr %o2
200f3f8: 92 10 00 1d mov %i5, %o1
200f3fc: 96 10 00 19 mov %i1, %o3
200f400: 40 00 37 c2 call 201d308 <__moddi3>
200f404: 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;
200f408: 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);
200f40c: b8 10 00 09 mov %o1, %i4
args->bytes_moved = 0;
200f410: c0 26 a0 1c clr [ %i2 + 0x1c ]
while (count > 0)
200f414: 10 80 00 26 b 200f4ac <rtems_blkdev_generic_write+0xe8>
200f418: 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);
200f41c: 90 10 00 11 mov %l1, %o0
while (count > 0)
{
rtems_bdbuf_buffer *diskbuf;
uint32_t copy;
if ((blkofs == 0) && (count >= block_size))
200f420: 80 a6 c0 19 cmp %i3, %i1
200f424: 0a 80 00 09 bcs 200f448 <rtems_blkdev_generic_write+0x84> <== NEVER TAKEN
200f428: 94 07 bf fc add %fp, -4, %o2
200f42c: 80 a7 20 00 cmp %i4, 0
200f430: 12 80 00 06 bne 200f448 <rtems_blkdev_generic_write+0x84> <== NEVER TAKEN
200f434: 01 00 00 00 nop
rc = rtems_bdbuf_get(dd, block, &diskbuf);
200f438: 7f ff fd 35 call 200e90c <rtems_bdbuf_get>
200f43c: 01 00 00 00 nop
else
rc = rtems_bdbuf_read(dd, block, &diskbuf);
if (rc != RTEMS_SUCCESSFUL)
200f440: 10 80 00 05 b 200f454 <rtems_blkdev_generic_write+0x90>
200f444: 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);
200f448: 7f ff fd 62 call 200e9d0 <rtems_bdbuf_read> <== NOT EXECUTED
200f44c: 01 00 00 00 nop <== NOT EXECUTED
if (rc != RTEMS_SUCCESSFUL)
200f450: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
200f454: 12 80 00 1a bne 200f4bc <rtems_blkdev_generic_write+0xf8> <== NEVER TAKEN
200f458: ba 26 40 1c sub %i1, %i4, %i5
200f45c: 80 a7 40 1b cmp %i5, %i3
200f460: 38 80 00 02 bgu,a 200f468 <rtems_blkdev_generic_write+0xa4><== NEVER TAKEN
200f464: 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);
200f468: c2 07 bf fc ld [ %fp + -4 ], %g1
200f46c: 92 10 00 10 mov %l0, %o1
200f470: d0 00 60 1c ld [ %g1 + 0x1c ], %o0
200f474: 94 10 00 1d mov %i5, %o2
200f478: 40 00 14 10 call 20144b8 <memcpy>
200f47c: 90 02 00 1c add %o0, %i4, %o0
args->bytes_moved += copy;
200f480: c2 06 a0 1c ld [ %i2 + 0x1c ], %g1
rc = rtems_bdbuf_release_modified(diskbuf);
200f484: 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;
200f488: 82 00 40 1d add %g1, %i5, %g1
200f48c: b0 06 20 01 inc %i0
rc = rtems_bdbuf_release_modified(diskbuf);
200f490: 7f ff fe 02 call 200ec98 <rtems_bdbuf_release_modified>
200f494: c2 26 a0 1c st %g1, [ %i2 + 0x1c ]
if (rc != RTEMS_SUCCESSFUL)
200f498: 80 a2 20 00 cmp %o0, 0
200f49c: 12 80 00 08 bne 200f4bc <rtems_blkdev_generic_write+0xf8> <== NEVER TAKEN
200f4a0: b6 26 c0 1d sub %i3, %i5, %i3
break;
count -= copy;
buf += copy;
200f4a4: a0 04 00 1d add %l0, %i5, %l0
blkofs = 0;
200f4a8: 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)
200f4ac: 80 a6 e0 00 cmp %i3, 0
200f4b0: 12 bf ff db bne 200f41c <rtems_blkdev_generic_write+0x58>
200f4b4: 92 06 00 12 add %i0, %l2, %o1
200f4b8: 90 10 20 00 clr %o0
blkofs = 0;
block++;
}
return rc;
}
200f4bc: 81 c7 e0 08 ret
200f4c0: 91 e8 00 08 restore %g0, %o0, %o0
02003a7c <rtems_blkdev_imfs_fsync_or_fdatasync>:
}
static int rtems_blkdev_imfs_fsync_or_fdatasync(
rtems_libio_t *iop
)
{
2003a7c: 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;
2003a80: c2 06 20 1c ld [ %i0 + 0x1c ], %g1 <== NOT EXECUTED
int rv = 0;
2003a84: 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);
2003a88: 40 00 2f a5 call 200f91c <rtems_bdbuf_syncdev> <== NOT EXECUTED
2003a8c: d0 00 60 50 ld [ %g1 + 0x50 ], %o0 <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL) {
2003a90: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2003a94: 02 80 00 06 be 2003aac <rtems_blkdev_imfs_fsync_or_fdatasync+0x30><== NOT EXECUTED
2003a98: 01 00 00 00 nop <== NOT EXECUTED
errno = EIO;
2003a9c: 40 00 41 a6 call 2014134 <__errno> <== NOT EXECUTED
2003aa0: b0 10 3f ff mov -1, %i0 ! ffffffff <RAM_END+0xfdbfffff> <== NOT EXECUTED
2003aa4: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
2003aa8: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
rv = -1;
}
return rv;
}
2003aac: 81 c7 e0 08 ret <== NOT EXECUTED
2003ab0: 81 e8 00 00 restore <== NOT EXECUTED
02003ab4 <rtems_blkdev_imfs_ioctl>:
static int rtems_blkdev_imfs_ioctl(
rtems_libio_t *iop,
uint32_t request,
void *buffer
)
{
2003ab4: 9d e3 bf a0 save %sp, -96, %sp
int rv = 0;
if (request != RTEMS_BLKIO_REQUEST) {
2003ab8: 03 30 06 10 sethi %hi(0xc0184000), %g1
2003abc: 82 10 62 01 or %g1, 0x201, %g1 ! c0184201 <RAM_END+0xbdd84201>
2003ac0: 80 a6 40 01 cmp %i1, %g1
2003ac4: 02 80 00 09 be 2003ae8 <rtems_blkdev_imfs_ioctl+0x34> <== NEVER TAKEN
2003ac8: 92 10 00 19 mov %i1, %o1
2003acc: c2 06 20 1c ld [ %i0 + 0x1c ], %g1
2003ad0: 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);
2003ad4: c2 02 20 38 ld [ %o0 + 0x38 ], %g1
2003ad8: 9f c0 40 00 call %g1
2003adc: 94 10 00 1a mov %i2, %o2
2003ae0: 81 c7 e0 08 ret
2003ae4: 91 e8 00 08 restore %g0, %o0, %o0
} else {
/*
* It is not allowed to directly access the driver circumventing the cache.
*/
errno = EINVAL;
2003ae8: 40 00 41 93 call 2014134 <__errno> <== NOT EXECUTED
2003aec: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
2003af0: 82 10 20 16 mov 0x16, %g1 <== NOT EXECUTED
2003af4: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
rv = -1;
}
return rv;
}
2003af8: 81 c7 e0 08 ret <== NOT EXECUTED
2003afc: 81 e8 00 00 restore <== NOT EXECUTED
02003900 <rtems_blkdev_imfs_read>:
static ssize_t rtems_blkdev_imfs_read(
rtems_libio_t *iop,
void *buffer,
size_t count
)
{
2003900: 9d e3 bf 98 save %sp, -104, %sp
2003904: 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;
2003908: f8 1e 20 08 ldd [ %i0 + 8 ], %i4
200390c: 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);
2003910: 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);
2003914: f6 04 a0 24 ld [ %l2 + 0x24 ], %i3
rtems_blkdev_bnum block = (rtems_blkdev_bnum) (offset / block_size);
2003918: 90 10 00 1c mov %i4, %o0
200391c: a3 3e e0 1f sra %i3, 0x1f, %l1
2003920: 96 10 00 1b mov %i3, %o3
2003924: 40 00 67 55 call 201d678 <__divdi3>
2003928: 94 10 00 11 mov %l1, %o2
ssize_t block_offset = (ssize_t) (offset % block_size);
200392c: 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);
2003930: a0 10 00 09 mov %o1, %l0
ssize_t block_offset = (ssize_t) (offset % block_size);
2003934: 90 10 00 1c mov %i4, %o0
2003938: 92 10 00 1d mov %i5, %o1
200393c: 96 10 00 1b mov %i3, %o3
2003940: 40 00 68 39 call 201da24 <__moddi3>
2003944: ba 10 00 1a mov %i2, %i5
char *dst = buffer;
while (remaining > 0) {
2003948: 10 80 00 19 b 20039ac <rtems_blkdev_imfs_read+0xac>
200394c: a2 10 00 09 mov %o1, %l1
rtems_bdbuf_buffer *bd;
rtems_status_code sc = rtems_bdbuf_read(dd, block, &bd);
2003950: 92 10 00 10 mov %l0, %o1
2003954: 40 00 2e d2 call 200f49c <rtems_bdbuf_read>
2003958: 94 07 bf fc add %fp, -4, %o2
if (sc == RTEMS_SUCCESSFUL) {
200395c: 80 a2 20 00 cmp %o0, 0
2003960: 12 80 00 1f bne 20039dc <rtems_blkdev_imfs_read+0xdc> <== NEVER TAKEN
2003964: b8 26 c0 11 sub %i3, %l1, %i4
2003968: 80 a7 00 1d cmp %i4, %i5
200396c: 34 80 00 02 bg,a 2003974 <rtems_blkdev_imfs_read+0x74>
2003970: b8 10 00 1d mov %i5, %i4
if (copy > remaining) {
copy = remaining;
}
memcpy(dst, (char *) bd->buffer + block_offset, (size_t) copy);
2003974: c2 07 bf fc ld [ %fp + -4 ], %g1
2003978: 94 10 00 1c mov %i4, %o2
200397c: d2 00 60 1c ld [ %g1 + 0x1c ], %o1
2003980: 90 10 00 19 mov %i1, %o0
2003984: 40 00 44 5d call 2014af8 <memcpy>
2003988: 92 02 40 11 add %o1, %l1, %o1
sc = rtems_bdbuf_release(bd);
200398c: 40 00 2f 41 call 200f690 <rtems_bdbuf_release>
2003990: d0 07 bf fc ld [ %fp + -4 ], %o0
if (sc == RTEMS_SUCCESSFUL) {
2003994: 80 a2 20 00 cmp %o0, 0
2003998: 12 80 00 11 bne 20039dc <rtems_blkdev_imfs_read+0xdc> <== NEVER TAKEN
200399c: ba 27 40 1c sub %i5, %i4, %i5
block_offset = 0;
remaining -= copy;
dst += copy;
20039a0: b2 06 40 1c add %i1, %i4, %i1
++block;
20039a4: 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;
20039a8: 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) {
20039ac: 80 a7 60 00 cmp %i5, 0
20039b0: 14 bf ff e8 bg 2003950 <rtems_blkdev_imfs_read+0x50>
20039b4: 90 10 00 12 mov %l2, %o0
} else {
remaining = -1;
}
}
if (remaining >= 0) {
20039b8: 80 a7 60 00 cmp %i5, 0
20039bc: 12 80 00 08 bne 20039dc <rtems_blkdev_imfs_read+0xdc> <== NEVER TAKEN
20039c0: 01 00 00 00 nop
iop->offset += count;
20039c4: c4 1e 20 08 ldd [ %i0 + 8 ], %g2
20039c8: 86 80 c0 1a addcc %g3, %i2, %g3
20039cc: 84 40 a0 00 addx %g2, 0, %g2
20039d0: c4 3e 20 08 std %g2, [ %i0 + 8 ]
rv = (ssize_t) count;
20039d4: 81 c7 e0 08 ret
20039d8: 91 e8 00 1a restore %g0, %i2, %o0
} else {
errno = EIO;
20039dc: 40 00 41 d6 call 2014134 <__errno> <== NOT EXECUTED
20039e0: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
20039e4: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
20039e8: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
rv = -1;
}
return rv;
}
20039ec: 81 c7 e0 08 ret <== NOT EXECUTED
20039f0: 81 e8 00 00 restore <== NOT EXECUTED
020037d4 <rtems_blkdev_imfs_write>:
static ssize_t rtems_blkdev_imfs_write(
rtems_libio_t *iop,
const void *buffer,
size_t count
)
{
20037d4: 9d e3 bf 98 save %sp, -104, %sp
20037d8: 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;
20037dc: f8 1e 20 08 ldd [ %i0 + 8 ], %i4
20037e0: 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);
20037e4: 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);
20037e8: f6 04 a0 24 ld [ %l2 + 0x24 ], %i3
rtems_blkdev_bnum block = (rtems_blkdev_bnum) (offset / block_size);
20037ec: 90 10 00 1c mov %i4, %o0
20037f0: a3 3e e0 1f sra %i3, 0x1f, %l1
20037f4: 96 10 00 1b mov %i3, %o3
20037f8: 40 00 67 a0 call 201d678 <__divdi3>
20037fc: 94 10 00 11 mov %l1, %o2
ssize_t block_offset = (ssize_t) (offset % block_size);
2003800: 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);
2003804: a0 10 00 09 mov %o1, %l0
ssize_t block_offset = (ssize_t) (offset % block_size);
2003808: 90 10 00 1c mov %i4, %o0
200380c: 92 10 00 1d mov %i5, %o1
2003810: 96 10 00 1b mov %i3, %o3
2003814: 40 00 68 84 call 201da24 <__moddi3>
2003818: ba 10 00 1a mov %i2, %i5
const char *src = buffer;
while (remaining > 0) {
200381c: 10 80 00 27 b 20038b8 <rtems_blkdev_imfs_write+0xe4>
2003820: a2 10 00 09 mov %o1, %l1
rtems_status_code sc;
rtems_bdbuf_buffer *bd;
if (block_offset == 0 && remaining >= block_size) {
2003824: 16 80 00 03 bge 2003830 <rtems_blkdev_imfs_write+0x5c>
2003828: 82 10 20 01 mov 1, %g1
200382c: 82 10 20 00 clr %g1
sc = rtems_bdbuf_get(dd, block, &bd);
2003830: 90 10 00 12 mov %l2, %o0
2003834: 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) {
2003838: 80 88 60 ff btst 0xff, %g1
200383c: 02 80 00 09 be 2003860 <rtems_blkdev_imfs_write+0x8c>
2003840: 94 07 bf fc add %fp, -4, %o2
2003844: 80 a4 60 00 cmp %l1, 0
2003848: 12 80 00 06 bne 2003860 <rtems_blkdev_imfs_write+0x8c>
200384c: 01 00 00 00 nop
sc = rtems_bdbuf_get(dd, block, &bd);
2003850: 40 00 2e e2 call 200f3d8 <rtems_bdbuf_get>
2003854: 01 00 00 00 nop
} else {
sc = rtems_bdbuf_read(dd, block, &bd);
}
if (sc == RTEMS_SUCCESSFUL) {
2003858: 10 80 00 05 b 200386c <rtems_blkdev_imfs_write+0x98>
200385c: 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);
2003860: 40 00 2f 0f call 200f49c <rtems_bdbuf_read>
2003864: 01 00 00 00 nop
}
if (sc == RTEMS_SUCCESSFUL) {
2003868: 80 a2 20 00 cmp %o0, 0
200386c: 12 80 00 1f bne 20038e8 <rtems_blkdev_imfs_write+0x114> <== NEVER TAKEN
2003870: b8 26 c0 11 sub %i3, %l1, %i4
2003874: 80 a7 00 1d cmp %i4, %i5
2003878: 34 80 00 02 bg,a 2003880 <rtems_blkdev_imfs_write+0xac>
200387c: b8 10 00 1d mov %i5, %i4
if (copy > remaining) {
copy = remaining;
}
memcpy((char *) bd->buffer + block_offset, src, (size_t) copy);
2003880: c2 07 bf fc ld [ %fp + -4 ], %g1
2003884: 92 10 00 19 mov %i1, %o1
2003888: d0 00 60 1c ld [ %g1 + 0x1c ], %o0
200388c: 94 10 00 1c mov %i4, %o2
2003890: 40 00 44 9a call 2014af8 <memcpy>
2003894: 90 02 00 11 add %o0, %l1, %o0
sc = rtems_bdbuf_release_modified(bd);
2003898: 40 00 2f b3 call 200f764 <rtems_bdbuf_release_modified>
200389c: d0 07 bf fc ld [ %fp + -4 ], %o0
if (sc == RTEMS_SUCCESSFUL) {
20038a0: 80 a2 20 00 cmp %o0, 0
20038a4: 12 80 00 11 bne 20038e8 <rtems_blkdev_imfs_write+0x114> <== NEVER TAKEN
20038a8: ba 27 40 1c sub %i5, %i4, %i5
block_offset = 0;
remaining -= copy;
src += copy;
20038ac: b2 06 40 1c add %i1, %i4, %i1
++block;
20038b0: 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;
20038b4: 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) {
20038b8: 80 a7 60 00 cmp %i5, 0
20038bc: 14 bf ff da bg 2003824 <rtems_blkdev_imfs_write+0x50>
20038c0: 80 a7 40 1b cmp %i5, %i3
} else {
remaining = -1;
}
}
if (remaining >= 0) {
20038c4: 80 a7 60 00 cmp %i5, 0
20038c8: 12 80 00 08 bne 20038e8 <rtems_blkdev_imfs_write+0x114> <== NEVER TAKEN
20038cc: 01 00 00 00 nop
iop->offset += count;
20038d0: c4 1e 20 08 ldd [ %i0 + 8 ], %g2
20038d4: 86 80 c0 1a addcc %g3, %i2, %g3
20038d8: 84 40 a0 00 addx %g2, 0, %g2
20038dc: c4 3e 20 08 std %g2, [ %i0 + 8 ]
rv = (ssize_t) count;
20038e0: 81 c7 e0 08 ret
20038e4: 91 e8 00 1a restore %g0, %i2, %o0
} else {
errno = EIO;
20038e8: 40 00 42 13 call 2014134 <__errno> <== NOT EXECUTED
20038ec: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
20038f0: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
20038f4: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
rv = -1;
}
return rv;
}
20038f8: 81 c7 e0 08 ret <== NOT EXECUTED
20038fc: 81 e8 00 00 restore <== NOT EXECUTED
0200f198 <rtems_blkdev_ioctl>:
#include <rtems/blkdev.h>
#include <rtems/bdbuf.h>
int
rtems_blkdev_ioctl(rtems_disk_device *dd, uint32_t req, void *argp)
{
200f198: 9d e3 bf a0 save %sp, -96, %sp
rtems_status_code sc;
int rc = 0;
switch (req)
200f19c: 03 10 01 10 sethi %hi(0x40044000), %g1
200f1a0: 84 10 62 03 or %g1, 0x203, %g2 ! 40044203 <RAM_END+0x3dc44203>
200f1a4: 80 a6 40 02 cmp %i1, %g2
200f1a8: 02 80 00 2e be 200f260 <rtems_blkdev_ioctl+0xc8>
200f1ac: 90 10 00 18 mov %i0, %o0
200f1b0: 80 a6 40 02 cmp %i1, %g2
200f1b4: 18 80 00 16 bgu 200f20c <rtems_blkdev_ioctl+0x74>
200f1b8: 84 10 62 09 or %g1, 0x209, %g2
200f1bc: 05 08 00 10 sethi %hi(0x20004000), %g2
200f1c0: 86 10 a2 0a or %g2, 0x20a, %g3 ! 2000420a <RAM_END+0x1dc0420a>
200f1c4: 80 a6 40 03 cmp %i1, %g3
200f1c8: 02 80 00 37 be 200f2a4 <rtems_blkdev_ioctl+0x10c>
200f1cc: 01 00 00 00 nop
200f1d0: 38 80 00 07 bgu,a 200f1ec <rtems_blkdev_ioctl+0x54>
200f1d4: 84 10 a2 0c or %g2, 0x20c, %g2
200f1d8: 84 10 a2 06 or %g2, 0x206, %g2
200f1dc: 80 a6 40 02 cmp %i1, %g2
200f1e0: 12 80 00 3c bne 200f2d0 <rtems_blkdev_ioctl+0x138>
200f1e4: 01 00 00 00 nop
200f1e8: 30 80 00 26 b,a 200f280 <rtems_blkdev_ioctl+0xe8>
200f1ec: 80 a6 40 02 cmp %i1, %g2
200f1f0: 02 80 00 34 be 200f2c0 <rtems_blkdev_ioctl+0x128> <== NEVER TAKEN
200f1f4: 82 10 62 02 or %g1, 0x202, %g1
200f1f8: 80 a6 40 01 cmp %i1, %g1
200f1fc: 12 80 00 35 bne 200f2d0 <rtems_blkdev_ioctl+0x138> <== NEVER TAKEN
200f200: 01 00 00 00 nop
{
case RTEMS_BLKIO_GETMEDIABLKSIZE:
*(uint32_t *) argp = dd->media_block_size;
200f204: 10 80 00 15 b 200f258 <rtems_blkdev_ioctl+0xc0>
200f208: 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)
200f20c: 80 a6 40 02 cmp %i1, %g2
200f210: 22 80 00 2e be,a 200f2c8 <rtems_blkdev_ioctl+0x130>
200f214: f0 26 80 00 st %i0, [ %i2 ]
200f218: 38 80 00 08 bgu,a 200f238 <rtems_blkdev_ioctl+0xa0>
200f21c: 82 10 62 0b or %g1, 0x20b, %g1
200f220: 82 10 62 05 or %g1, 0x205, %g1
200f224: 80 a6 40 01 cmp %i1, %g1
200f228: 12 80 00 2a bne 200f2d0 <rtems_blkdev_ioctl+0x138> <== NEVER TAKEN
200f22c: 01 00 00 00 nop
rc = -1;
}
break;
case RTEMS_BLKIO_GETSIZE:
*(rtems_blkdev_bnum *) argp = dd->size;
200f230: 10 80 00 12 b 200f278 <rtems_blkdev_ioctl+0xe0>
200f234: 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)
200f238: 80 a6 40 01 cmp %i1, %g1
200f23c: 02 80 00 1d be 200f2b0 <rtems_blkdev_ioctl+0x118> <== NEVER TAKEN
200f240: 03 20 01 10 sethi %hi(0x80044000), %g1
200f244: 82 10 62 04 or %g1, 0x204, %g1 ! 80044204 <RAM_END+0x7dc44204>
200f248: 80 a6 40 01 cmp %i1, %g1
200f24c: 12 80 00 21 bne 200f2d0 <rtems_blkdev_ioctl+0x138> <== NEVER TAKEN
200f250: 01 00 00 00 nop
200f254: 30 80 00 05 b,a 200f268 <rtems_blkdev_ioctl+0xd0>
rc = -1;
}
break;
case RTEMS_BLKIO_GETSIZE:
*(rtems_blkdev_bnum *) argp = dd->size;
200f258: 10 80 00 1c b 200f2c8 <rtems_blkdev_ioctl+0x130>
200f25c: 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;
200f260: 10 80 00 06 b 200f278 <rtems_blkdev_ioctl+0xe0>
200f264: c2 06 20 24 ld [ %i0 + 0x24 ], %g1
break;
case RTEMS_BLKIO_SETBLKSIZE:
sc = rtems_bdbuf_set_block_size(dd, *(uint32_t *) argp);
200f268: 7f ff ff 7f call 200f064 <rtems_bdbuf_set_block_size>
200f26c: 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) {
200f270: 10 80 00 07 b 200f28c <rtems_blkdev_ioctl+0xf4>
200f274: 80 a2 20 00 cmp %o0, 0
rc = -1;
}
break;
case RTEMS_BLKIO_GETSIZE:
*(rtems_blkdev_bnum *) argp = dd->size;
200f278: 10 80 00 14 b 200f2c8 <rtems_blkdev_ioctl+0x130>
200f27c: c2 26 80 00 st %g1, [ %i2 ]
break;
case RTEMS_BLKIO_SYNCDEV:
sc = rtems_bdbuf_syncdev(dd);
200f280: 7f ff fe f4 call 200ee50 <rtems_bdbuf_syncdev>
200f284: 01 00 00 00 nop
if (sc != RTEMS_SUCCESSFUL) {
200f288: 80 a2 20 00 cmp %o0, 0
200f28c: 22 80 00 16 be,a 200f2e4 <rtems_blkdev_ioctl+0x14c> <== ALWAYS TAKEN
200f290: b0 10 20 00 clr %i0
errno = EIO;
200f294: 40 00 12 42 call 2013b9c <__errno> <== NOT EXECUTED
200f298: 01 00 00 00 nop <== NOT EXECUTED
200f29c: 10 80 00 10 b 200f2dc <rtems_blkdev_ioctl+0x144> <== NOT EXECUTED
200f2a0: 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);
200f2a4: 7f ff ff 03 call 200eeb0 <rtems_bdbuf_purge_dev>
200f2a8: b0 10 20 00 clr %i0
200f2ac: 30 80 00 0e b,a 200f2e4 <rtems_blkdev_ioctl+0x14c>
break;
case RTEMS_BLKIO_GETDEVSTATS:
rtems_bdbuf_get_device_stats(dd, (rtems_blkdev_stats *) argp);
200f2b0: 7f ff ff a8 call 200f150 <rtems_bdbuf_get_device_stats> <== NOT EXECUTED
200f2b4: 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;
200f2b8: 81 c7 e0 08 ret <== NOT EXECUTED
200f2bc: 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);
200f2c0: 7f ff ff ad call 200f174 <rtems_bdbuf_reset_device_stats> <== NOT EXECUTED
200f2c4: 01 00 00 00 nop <== NOT EXECUTED
break;
200f2c8: 81 c7 e0 08 ret
200f2cc: 91 e8 20 00 restore %g0, 0, %o0
default:
errno = EINVAL;
200f2d0: 40 00 12 33 call 2013b9c <__errno>
200f2d4: 01 00 00 00 nop
200f2d8: 82 10 20 16 mov 0x16, %g1 ! 16 <PROM_START+0x16>
200f2dc: c2 22 00 00 st %g1, [ %o0 ]
rc = -1;
200f2e0: b0 10 3f ff mov -1, %i0
break;
}
return rc;
}
200f2e4: 81 c7 e0 08 ret
200f2e8: 81 e8 00 00 restore
020220e0 <rtems_blkstats>:
#include <fcntl.h>
#include <unistd.h>
#include <errno.h>
void rtems_blkstats(FILE *output, const char *device, bool reset)
{
20220e0: 9d e3 bf 38 save %sp, -200, %sp <== NOT EXECUTED
int fd = open(device, O_RDONLY);
20220e4: 92 10 20 00 clr %o1 <== NOT EXECUTED
20220e8: 7f ff 88 35 call 20041bc <open> <== NOT EXECUTED
20220ec: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
if (fd >= 0) {
20220f0: ba 92 20 00 orcc %o0, 0, %i5 <== NOT EXECUTED
20220f4: 06 80 00 51 bl 2022238 <rtems_blkstats+0x158> <== NOT EXECUTED
20220f8: 01 00 00 00 nop <== NOT EXECUTED
struct stat st;
int rv;
rv = fstat(fd, &st);
20220fc: 40 00 06 94 call 2023b4c <fstat> <== NOT EXECUTED
2022100: 92 07 bf b8 add %fp, -72, %o1 <== NOT EXECUTED
if (rv == 0) {
2022104: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2022108: 12 80 00 34 bne 20221d8 <rtems_blkstats+0xf8> <== NOT EXECUTED
202210c: c4 07 bf c4 ld [ %fp + -60 ], %g2 <== NOT EXECUTED
if (S_ISBLK(st.st_mode)) {
2022110: 03 00 00 3c sethi %hi(0xf000), %g1 <== NOT EXECUTED
2022114: 84 08 80 01 and %g2, %g1, %g2 <== NOT EXECUTED
2022118: 03 00 00 18 sethi %hi(0x6000), %g1 <== NOT EXECUTED
202211c: 80 a0 80 01 cmp %g2, %g1 <== NOT EXECUTED
2022120: 32 80 00 2a bne,a 20221c8 <rtems_blkstats+0xe8> <== NOT EXECUTED
2022124: 11 00 81 60 sethi %hi(0x2058000), %o0 <== NOT EXECUTED
if (reset) {
2022128: 80 a6 a0 00 cmp %i2, 0 <== NOT EXECUTED
202212c: 02 80 00 11 be 2022170 <rtems_blkstats+0x90> <== NOT EXECUTED
2022130: 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);
2022134: 13 08 00 10 sethi %hi(0x20004000), %o1 <== NOT EXECUTED
2022138: 40 00 09 42 call 2024640 <ioctl> <== NOT EXECUTED
202213c: 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) {
2022140: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2022144: 02 80 00 2f be 2022200 <rtems_blkstats+0x120> <== NOT EXECUTED
2022148: 01 00 00 00 nop <== NOT EXECUTED
fprintf(output, "error: reset stats: %s\n", strerror(errno));
202214c: 40 00 51 8c call 203677c <__errno> <== NOT EXECUTED
2022150: 01 00 00 00 nop <== NOT EXECUTED
2022154: 40 00 6d 48 call 203d674 <strerror> <== NOT EXECUTED
2022158: d0 02 00 00 ld [ %o0 ], %o0 <== NOT EXECUTED
202215c: 13 00 81 60 sethi %hi(0x2058000), %o1 <== NOT EXECUTED
2022160: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
2022164: 92 12 63 08 or %o1, 0x308, %o1 <== NOT EXECUTED
2022168: 10 80 00 24 b 20221f8 <rtems_blkstats+0x118> <== NOT EXECUTED
202216c: 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);
2022170: 13 10 01 10 sethi %hi(0x40044000), %o1 <== NOT EXECUTED
2022174: 94 07 bf 98 add %fp, -104, %o2 <== NOT EXECUTED
2022178: 40 00 09 32 call 2024640 <ioctl> <== NOT EXECUTED
202217c: 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) {
2022180: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2022184: 12 80 00 08 bne 20221a4 <rtems_blkstats+0xc4> <== NOT EXECUTED
2022188: 01 00 00 00 nop <== NOT EXECUTED
rtems_blkdev_print_stats(
202218c: 90 07 bf 98 add %fp, -104, %o0 <== NOT EXECUTED
2022190: 13 00 80 dc sethi %hi(0x2037000), %o1 <== NOT EXECUTED
2022194: 94 10 00 18 mov %i0, %o2 <== NOT EXECUTED
2022198: 40 00 00 34 call 2022268 <rtems_blkdev_print_stats> <== NOT EXECUTED
202219c: 92 12 62 60 or %o1, 0x260, %o1 <== NOT EXECUTED
20221a0: 30 80 00 18 b,a 2022200 <rtems_blkstats+0x120> <== NOT EXECUTED
&stats,
(rtems_printk_plugin_t) fprintf,
output
);
} else {
fprintf(output, "error: get stats: %s\n", strerror(errno));
20221a4: 40 00 51 76 call 203677c <__errno> <== NOT EXECUTED
20221a8: 01 00 00 00 nop <== NOT EXECUTED
20221ac: 40 00 6d 32 call 203d674 <strerror> <== NOT EXECUTED
20221b0: d0 02 00 00 ld [ %o0 ], %o0 <== NOT EXECUTED
20221b4: 13 00 81 60 sethi %hi(0x2058000), %o1 <== NOT EXECUTED
20221b8: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
20221bc: 92 12 63 20 or %o1, 0x320, %o1 <== NOT EXECUTED
20221c0: 10 80 00 0e b 20221f8 <rtems_blkstats+0x118> <== NOT EXECUTED
20221c4: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
}
}
} else {
fprintf(output, "error: not a block device\n");
20221c8: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
20221cc: 40 00 54 75 call 20373a0 <fputs> <== NOT EXECUTED
20221d0: 90 12 23 38 or %o0, 0x338, %o0 <== NOT EXECUTED
20221d4: 30 80 00 0b b,a 2022200 <rtems_blkstats+0x120> <== NOT EXECUTED
}
} else {
fprintf(output, "error: get file stats: %s\n", strerror(errno));
20221d8: 40 00 51 69 call 203677c <__errno> <== NOT EXECUTED
20221dc: 01 00 00 00 nop <== NOT EXECUTED
20221e0: 40 00 6d 25 call 203d674 <strerror> <== NOT EXECUTED
20221e4: d0 02 00 00 ld [ %o0 ], %o0 <== NOT EXECUTED
20221e8: 13 00 81 60 sethi %hi(0x2058000), %o1 <== NOT EXECUTED
20221ec: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
20221f0: 92 12 63 58 or %o1, 0x358, %o1 <== NOT EXECUTED
20221f4: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
20221f8: 40 00 54 1a call 2037260 <fprintf> <== NOT EXECUTED
20221fc: 01 00 00 00 nop <== NOT EXECUTED
}
rv = close(fd);
2022200: 40 00 05 d1 call 2023944 <close> <== NOT EXECUTED
2022204: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
if (rv != 0) {
2022208: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
202220c: 02 80 00 15 be 2022260 <rtems_blkstats+0x180> <== NOT EXECUTED
2022210: 01 00 00 00 nop <== NOT EXECUTED
fprintf(output, "error: close device: %s\n", strerror(errno));
2022214: 40 00 51 5a call 203677c <__errno> <== NOT EXECUTED
2022218: 01 00 00 00 nop <== NOT EXECUTED
202221c: 40 00 6d 16 call 203d674 <strerror> <== NOT EXECUTED
2022220: d0 02 00 00 ld [ %o0 ], %o0 <== NOT EXECUTED
2022224: 13 00 81 60 sethi %hi(0x2058000), %o1 <== NOT EXECUTED
2022228: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
202222c: 92 12 63 78 or %o1, 0x378, %o1 <== NOT EXECUTED
2022230: 10 80 00 0a b 2022258 <rtems_blkstats+0x178> <== NOT EXECUTED
2022234: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
}
} else {
fprintf(output, "error: open device: %s\n", strerror(errno));
2022238: 40 00 51 51 call 203677c <__errno> <== NOT EXECUTED
202223c: 01 00 00 00 nop <== NOT EXECUTED
2022240: 40 00 6d 0d call 203d674 <strerror> <== NOT EXECUTED
2022244: d0 02 00 00 ld [ %o0 ], %o0 <== NOT EXECUTED
2022248: 13 00 81 60 sethi %hi(0x2058000), %o1 <== NOT EXECUTED
202224c: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
2022250: 92 12 63 98 or %o1, 0x398, %o1 <== NOT EXECUTED
2022254: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
2022258: 40 00 54 02 call 2037260 <fprintf> <== NOT EXECUTED
202225c: 01 00 00 00 nop <== NOT EXECUTED
2022260: 81 c7 e0 08 ret <== NOT EXECUTED
2022264: 81 e8 00 00 restore <== NOT EXECUTED
02008530 <rtems_chain_get_with_wait>:
rtems_chain_control *chain,
rtems_event_set events,
rtems_interval timeout,
rtems_chain_node **node_ptr
)
{
2008530: 9d e3 bf 98 save %sp, -104, %sp
2008534: 30 80 00 08 b,a 2008554 <rtems_chain_get_with_wait+0x24>
while (
sc == RTEMS_SUCCESSFUL
&& (node = rtems_chain_get( chain )) == NULL
) {
rtems_event_set out;
sc = rtems_event_receive(
2008538: 92 10 20 00 clr %o1
200853c: 94 10 00 1a mov %i2, %o2
2008540: 7f ff fd 03 call 200794c <rtems_event_receive>
2008544: 96 07 bf fc add %fp, -4, %o3
)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_chain_node *node = NULL;
while (
2008548: 80 a2 20 00 cmp %o0, 0
200854c: 32 80 00 09 bne,a 2008570 <rtems_chain_get_with_wait+0x40><== ALWAYS TAKEN
2008550: 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 );
2008554: 40 00 01 88 call 2008b74 <_Chain_Get>
2008558: 90 10 00 18 mov %i0, %o0
sc == RTEMS_SUCCESSFUL
&& (node = rtems_chain_get( chain )) == NULL
200855c: ba 92 20 00 orcc %o0, 0, %i5
2008560: 02 bf ff f6 be 2008538 <rtems_chain_get_with_wait+0x8>
2008564: 90 10 00 19 mov %i1, %o0
2008568: 90 10 20 00 clr %o0
timeout,
&out
);
}
*node_ptr = node;
200856c: fa 26 c0 00 st %i5, [ %i3 ]
return sc;
}
2008570: 81 c7 e0 08 ret
2008574: 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 9d call 2008b64 <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 97 call 2009f94 <_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 22 01 call 200c57c <_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 32 call 201ae5c <__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 16 call 201b208 <__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 d0 call 201a8fc <.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 15 call 201ae5c <__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 f9 call 201b208 <__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 b3 call 201a8fc <.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 4f call 2009f94 <_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
0200f930 <rtems_deviceio_errno>:
[RTEMS_IO_ERROR] = EIO,
[RTEMS_PROXY_BLOCKING] = EIO
};
int rtems_deviceio_errno(rtems_status_code sc)
{
200f930: 9d e3 bf a0 save %sp, -96, %sp
if (sc == RTEMS_SUCCESSFUL) {
200f934: 80 a6 20 00 cmp %i0, 0
200f938: 02 80 00 0d be 200f96c <rtems_deviceio_errno+0x3c>
200f93c: 82 10 20 00 clr %g1
return 0;
} else {
int eno = EINVAL;
if ((unsigned) sc <= RTEMS_STATUS_CODES_LAST) {
200f940: 80 a6 20 1c cmp %i0, 0x1c
200f944: 18 80 00 06 bgu 200f95c <rtems_deviceio_errno+0x2c> <== NEVER TAKEN
200f948: ba 10 20 16 mov 0x16, %i5
eno = status_code_to_errno [sc];
200f94c: b1 2e 20 02 sll %i0, 2, %i0
200f950: 03 00 80 6f sethi %hi(0x201bc00), %g1
200f954: 82 10 63 7c or %g1, 0x37c, %g1 ! 201bf7c <status_code_to_errno>
200f958: fa 00 40 18 ld [ %g1 + %i0 ], %i5
}
errno = eno;
200f95c: 40 00 00 2f call 200fa18 <__errno>
200f960: 01 00 00 00 nop
return -1;
200f964: 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;
200f968: fa 22 00 00 st %i5, [ %o0 ]
return -1;
}
}
200f96c: 81 c7 e0 08 ret
200f970: 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 c3 call 200f704 <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 7d call 200f69c <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 70 ld [ %l0 + 0x370 ], %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 74 ld [ %l3 + 0x374 ], %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 74 ld [ %g3 + 0x374 ], %g3 ! 2021774 <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 74 ld [ %g3 + 0x374 ], %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 70 ld [ %i4 + 0x370 ], %g1 ! 2021770 <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 74 st %o0, [ %i5 + 0x374 ] ! 2021774 <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 68 clrb [ %g1 + 0x368 ]
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 e4 call 2008a90 <rtems_semaphore_create>
2003f04: 98 16 e3 6c or %i3, 0x36c, %o4 ! 202176c <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 74 ld [ %i5 + 0x374 ], %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 68 call 200e4c4 <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 6c ld [ %i3 + 0x36c ], %o0 <== NOT EXECUTED
2003f3c: 40 00 13 44 call 2008c4c <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 74 ld [ %i5 + 0x374 ], %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 70 st %g1, [ %i4 + 0x370 ]
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 70 ld [ %g1 + 0x370 ], %g2 ! 2021770 <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 74 ld [ %g1 + 0x374 ], %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 68 ldub [ %g1 + 0x368 ], %g1 ! 2021768 <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 8c call 20214d0 <fputs> <== NOT EXECUTED
20076a4: 90 12 21 a8 or %o0, 0x1a8, %o0 ! 2030da8 <__FUNCTION__.7059+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 87 call 20214d0 <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 4f call 2021400 <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 3e call 2020fc8 <fflush> <== NOT EXECUTED
20076d4: d0 00 60 0c ld [ %g1 + 0xc ], %o0 <== NOT EXECUTED
va_end (args);
exit (1);
20076d8: 40 00 65 3c call 2020bc8 <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__.7059+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__.7059+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__.7059+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 1f call 20232b4 <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__.7059+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 13 call 2021f00 <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 cd call 20214d0 <fputs> <== NOT EXECUTED
20051a0: 90 12 21 98 or %o0, 0x198, %o0 ! 2030d98 <__FUNCTION__.7059+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 04 call 2029dc0 <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 8f call 2021400 <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 7e call 2020fc8 <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 2a call 20214d0 <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 61 call 2029dc0 <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 ec call 2021400 <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 db call 2020fc8 <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 99 call 200c9b4 <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__.7059+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 ec call 200cb70 <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__.7059+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 be call 200cb70 <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 88 call 200cb70 <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 51 call 20232b4 <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__.7059+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 72 call 200cb70 <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 3b call 20232b4 <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__.7059+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 fc call 2020bbc <__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 0b call 200cc2c <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 ea call 2020bbc <__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 c1 call 2020bbc <__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 b7 call 2020bbc <__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__.7059+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 5b call 2021f00 <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 08 call 20232b4 <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__.7059+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 02 call 2020bbc <__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__.7059+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__.7059+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 20 call 20232b4 <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__.7059+0x600><== NOT EXECUTED
2006804: 09 00 80 c3 sethi %hi(0x2030c00), %g4
2006808: 88 11 22 28 or %g4, 0x228, %g4 ! 2030e28 <__FUNCTION__.7059+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__.7059+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 8e call 20232b4 <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 7b call 20232b4 <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__.7059+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 73 call 2020bbc <__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 6e call 2020bbc <__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 32 call 2020bbc <__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 2a call 2020bbc <__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 14 call 2020bbc <__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 b4 call 2020bbc <__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__.7059+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__.7059+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__.7059+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__.7059+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__.7059+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__.7059+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__.7059+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__.7059+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 fc call 20160e4 <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 13 call 200cd54 <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 a8 call 2020bbc <__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 a4 call 2020bbc <__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__.7059+0x5f0><== NOT EXECUTED
200531c: 05 00 80 c3 sethi %hi(0x2030c00), %g2
2005320: 84 10 a2 18 or %g2, 0x218, %g2 ! 2030e18 <__FUNCTION__.7059+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__.7059+0x600>
200533c: 03 00 80 c3 sethi %hi(0x2030c00), %g1
2005340: 82 10 62 28 or %g1, 0x228, %g1 ! 2030e28 <__FUNCTION__.7059+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__.7059+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 20 call 2021f00 <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__.7059+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 c5 call 20232b4 <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__.7059+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__.7059+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__.7059+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__.7059+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 b2 call 20232b4 <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__.7059+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 9c call 20232b4 <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__.7059+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__.7059+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__.7059+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 ea call 20214d0 <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 21 call 2029dc0 <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 ac call 2021400 <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 9b call 2020fc8 <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
0200c46c <rtems_filesystem_check_access>:
int eval_flags,
mode_t node_mode,
uid_t node_uid,
gid_t node_gid
)
{
200c46c: 9d e3 bf a0 save %sp, -96, %sp
mode_t perm_flags = eval_flags & RTEMS_FS_PERMS_RWX;
uid_t task_uid = geteuid();
200c470: 7f ff ff 0c call 200c0a0 <geteuid>
200c474: b0 0e 20 07 and %i0, 7, %i0
if (task_uid == 0 || task_uid == node_uid) {
200c478: 91 2a 20 10 sll %o0, 0x10, %o0
200c47c: 91 32 20 10 srl %o0, 0x10, %o0
200c480: 80 a2 00 1a cmp %o0, %i2
200c484: 22 80 00 12 be,a 200c4cc <rtems_filesystem_check_access+0x60>
200c488: b1 2e 20 06 sll %i0, 6, %i0
200c48c: 80 a2 20 00 cmp %o0, 0
200c490: 12 80 00 04 bne 200c4a0 <rtems_filesystem_check_access+0x34>
200c494: 01 00 00 00 nop
perm_flags <<= RTEMS_FS_USR_SHIFT;
200c498: 10 80 00 0d b 200c4cc <rtems_filesystem_check_access+0x60>
200c49c: b1 2e 20 06 sll %i0, 6, %i0
} else {
gid_t task_gid = getegid();
200c4a0: 7f ff fe fc call 200c090 <getegid>
200c4a4: 01 00 00 00 nop
if (task_gid == 0 || task_gid == node_gid) {
200c4a8: 91 2a 20 10 sll %o0, 0x10, %o0
200c4ac: 91 32 20 10 srl %o0, 0x10, %o0
200c4b0: 80 a2 00 1b cmp %o0, %i3
200c4b4: 22 80 00 06 be,a 200c4cc <rtems_filesystem_check_access+0x60>
200c4b8: b1 2e 20 03 sll %i0, 3, %i0
200c4bc: 80 a2 20 00 cmp %o0, 0
200c4c0: 32 80 00 04 bne,a 200c4d0 <rtems_filesystem_check_access+0x64><== ALWAYS TAKEN
200c4c4: b0 2e 00 19 andn %i0, %i1, %i0
perm_flags <<= RTEMS_FS_GRP_SHIFT;
200c4c8: b1 2e 20 03 sll %i0, 3, %i0 <== NOT EXECUTED
} else {
perm_flags <<= RTEMS_FS_OTH_SHIFT;
}
}
return (perm_flags & node_mode) == perm_flags;
200c4cc: b0 2e 00 19 andn %i0, %i1, %i0
}
200c4d0: 80 a0 00 18 cmp %g0, %i0
200c4d4: b0 60 3f ff subx %g0, -1, %i0
200c4d8: 81 c7 e0 08 ret
200c4dc: 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 58 ld [ %i5 + 0x158 ], %o0 ! 201d958 <rtems_libio_semaphore>
2004df0: 92 10 20 00 clr %o1
2004df4: 40 00 0a c5 call 2007908 <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 58 ld [ %i5 + 0x158 ], %o0
next->previous = previous;
2004e08: c2 20 a0 04 st %g1, [ %g2 + 4 ]
2004e0c: 40 00 0b 09 call 2007a30 <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 7c call 200742c <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 73 call 200801c <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
0200c518 <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
)
{
200c518: 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);
200c51c: 23 00 80 6f sethi %hi(0x201bc00), %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);
200c520: 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 =
200c524: 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);
200c528: a2 14 60 00 mov %l1, %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);
200c52c: ba 17 63 68 or %i5, 0x368, %i5
rtems_filesystem_eval_path_context_t *ctx,
const char **token,
size_t *tokenlen
)
{
rtems_filesystem_eval_path_next_token(ctx);
200c530: 40 00 00 99 call 200c794 <rtems_filesystem_eval_path_next_token>
200c534: 90 10 00 18 mov %i0, %o0
*token = ctx->token;
*tokenlen = ctx->tokenlen;
200c538: 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) {
200c53c: 80 a7 20 00 cmp %i4, 0
200c540: 02 80 00 54 be 200c690 <rtems_filesystem_eval_path_generic+0x178>
200c544: f6 06 20 08 ld [ %i0 + 8 ], %i3
if ((*config->is_directory)(ctx, arg)) {
200c548: c2 06 80 00 ld [ %i2 ], %g1
200c54c: 90 10 00 18 mov %i0, %o0
200c550: 9f c0 40 00 call %g1
200c554: 92 10 00 19 mov %i1, %o1
200c558: 80 8a 20 ff btst 0xff, %o0
200c55c: 02 80 00 75 be 200c730 <rtems_filesystem_eval_path_generic+0x218>
200c560: 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] == '.';
200c564: 12 80 00 06 bne 200c57c <rtems_filesystem_eval_path_generic+0x64>
200c568: 82 10 20 00 clr %g1
200c56c: c2 4e c0 00 ldsb [ %i3 ], %g1
200c570: 82 18 60 2e xor %g1, 0x2e, %g1
200c574: 80 a0 00 01 cmp %g0, %g1
200c578: 82 60 3f ff subx %g0, -1, %g1
if (rtems_filesystem_is_current_directory(token, tokenlen)) {
200c57c: 80 a0 60 00 cmp %g1, 0
200c580: 02 80 00 0f be 200c5bc <rtems_filesystem_eval_path_generic+0xa4>
200c584: 80 a7 20 02 cmp %i4, 2
if (rtems_filesystem_eval_path_has_path(ctx)) {
200c588: c2 06 20 04 ld [ %i0 + 4 ], %g1
200c58c: 80 a0 60 00 cmp %g1, 0
200c590: 22 80 00 04 be,a 200c5a0 <rtems_filesystem_eval_path_generic+0x88>
200c594: 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);
200c598: 10 80 00 40 b 200c698 <rtems_filesystem_eval_path_generic+0x180>
200c59c: 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) {
200c5a0: 80 88 61 00 btst 0x100, %g1
200c5a4: 32 80 00 04 bne,a 200c5b4 <rtems_filesystem_eval_path_generic+0x9c>
200c5a8: 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);
200c5ac: 10 80 00 3b b 200c698 <rtems_filesystem_eval_path_generic+0x180>
200c5b0: 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);
200c5b4: 10 80 00 5b b 200c720 <rtems_filesystem_eval_path_generic+0x208>
200c5b8: 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] == '.';
200c5bc: 12 80 00 0a bne 200c5e4 <rtems_filesystem_eval_path_generic+0xcc>
200c5c0: 82 10 20 00 clr %g1
200c5c4: c4 4e c0 00 ldsb [ %i3 ], %g2
200c5c8: 80 a0 a0 2e cmp %g2, 0x2e
200c5cc: 12 80 00 07 bne 200c5e8 <rtems_filesystem_eval_path_generic+0xd0>
200c5d0: 80 a0 60 00 cmp %g1, 0
200c5d4: c2 4e e0 01 ldsb [ %i3 + 1 ], %g1
200c5d8: 82 18 60 2e xor %g1, 0x2e, %g1
200c5dc: 80 a0 00 01 cmp %g0, %g1
200c5e0: 82 60 3f ff subx %g0, -1, %g1
status = RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_DONE;
}
}
} else if (rtems_filesystem_is_parent_directory(token, tokenlen)) {
200c5e4: 80 a0 60 00 cmp %g1, 0
200c5e8: 22 80 00 36 be,a 200c6c0 <rtems_filesystem_eval_path_generic+0x1a8>
200c5ec: 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;
200c5f0: 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;
200c5f4: 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 );
200c5f8: c4 02 60 14 ld [ %o1 + 0x14 ], %g2
200c5fc: 80 a0 40 02 cmp %g1, %g2
200c600: 12 80 00 07 bne 200c61c <rtems_filesystem_eval_path_generic+0x104>
200c604: 90 10 20 00 clr %o0
200c608: c2 00 60 0c ld [ %g1 + 0xc ], %g1
200c60c: c2 00 60 10 ld [ %g1 + 0x10 ], %g1
200c610: 9f c0 40 00 call %g1
200c614: 90 10 00 10 mov %l0, %o0
200c618: 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)) {
200c61c: 80 8a 20 01 btst 1, %o0
200c620: 22 80 00 04 be,a 200c630 <rtems_filesystem_eval_path_generic+0x118>
200c624: 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);
200c628: 10 80 00 1c b 200c698 <rtems_filesystem_eval_path_generic+0x180>
200c62c: 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 );
200c630: 90 10 00 10 mov %l0, %o0
200c634: c4 00 60 0c ld [ %g1 + 0xc ], %g2
200c638: c4 00 a0 10 ld [ %g2 + 0x10 ], %g2
200c63c: 9f c0 80 00 call %g2
200c640: 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)) {
200c644: 80 8a 20 ff btst 0xff, %o0
200c648: 22 80 00 19 be,a 200c6ac <rtems_filesystem_eval_path_generic+0x194>
200c64c: c2 06 a0 04 ld [ %i2 + 4 ], %g1
if (currentloc->mt_entry->mt_point_node != NULL) {
200c650: d2 06 20 2c ld [ %i0 + 0x2c ], %o1
200c654: c2 02 60 20 ld [ %o1 + 0x20 ], %g1
200c658: 80 a0 60 00 cmp %g1, 0
200c65c: 22 80 00 0f be,a 200c698 <rtems_filesystem_eval_path_generic+0x180><== NEVER TAKEN
200c660: 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;
200c664: c2 06 20 0c ld [ %i0 + 0xc ], %g1
ctx->path -= tokenlen;
200c668: c4 06 00 00 ld [ %i0 ], %g2
ctx->pathlen += tokenlen;
ctx->tokenlen = 0;
200c66c: c0 26 20 0c clr [ %i0 + 0xc ]
rtems_filesystem_eval_path_context_t *ctx
)
{
size_t tokenlen = ctx->tokenlen;
ctx->path -= tokenlen;
200c670: 84 20 80 01 sub %g2, %g1, %g2
200c674: c4 26 00 00 st %g2, [ %i0 ]
ctx->pathlen += tokenlen;
200c678: c4 06 20 04 ld [ %i0 + 4 ], %g2
rtems_filesystem_eval_path_put_back_token(ctx);
rtems_filesystem_eval_path_restart(
200c67c: 90 10 00 18 mov %i0, %o0
200c680: 82 00 80 01 add %g2, %g1, %g1
200c684: 92 02 60 20 add %o1, 0x20, %o1
200c688: 7f ff e1 60 call 2004c08 <rtems_filesystem_eval_path_restart>
200c68c: c2 26 20 04 st %g1, [ %i0 + 4 ]
200c690: 81 c7 e0 08 ret
200c694: 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);
200c698: 90 10 00 18 mov %i0, %o0
200c69c: 92 10 00 19 mov %i1, %o1
200c6a0: 94 10 00 1d mov %i5, %o2
200c6a4: 10 80 00 0b b 200c6d0 <rtems_filesystem_eval_path_generic+0x1b8>
200c6a8: 96 10 20 01 mov 1, %o3
}
} else {
status = (*config->eval_token)(ctx, arg, "..", 2);
200c6ac: 90 10 00 18 mov %i0, %o0
200c6b0: 92 10 00 19 mov %i1, %o1
200c6b4: 94 10 00 11 mov %l1, %o2
200c6b8: 10 80 00 06 b 200c6d0 <rtems_filesystem_eval_path_generic+0x1b8>
200c6bc: 96 10 20 02 mov 2, %o3
}
} else {
status = (*config->eval_token)(ctx, arg, token, tokenlen);
200c6c0: 90 10 00 18 mov %i0, %o0
200c6c4: 92 10 00 19 mov %i1, %o1
200c6c8: 94 10 00 1b mov %i3, %o2
200c6cc: 96 10 00 1c mov %i4, %o3
200c6d0: 9f c0 40 00 call %g1
200c6d4: 01 00 00 00 nop
}
if (status == RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_NO_ENTRY) {
200c6d8: 80 a2 20 02 cmp %o0, 2
200c6dc: 12 80 00 18 bne 200c73c <rtems_filesystem_eval_path_generic+0x224>
200c6e0: 80 a2 20 00 cmp %o0, 0
if (rtems_filesystem_eval_path_has_path(ctx)) {
200c6e4: c2 06 20 04 ld [ %i0 + 4 ], %g1
200c6e8: 80 a0 60 00 cmp %g1, 0
200c6ec: 02 80 00 16 be 200c744 <rtems_filesystem_eval_path_generic+0x22c>
200c6f0: 01 00 00 00 nop
int eval_flags;
rtems_filesystem_eval_path_eat_delimiter(ctx);
200c6f4: 40 00 00 16 call 200c74c <rtems_filesystem_eval_path_eat_delimiter>
200c6f8: 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
200c6fc: 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 (
200c700: 80 88 60 80 btst 0x80, %g1
200c704: 02 80 00 06 be 200c71c <rtems_filesystem_eval_path_generic+0x204>
200c708: 90 10 00 18 mov %i0, %o0
(eval_flags & RTEMS_FS_ACCEPT_RESIDUAL_DELIMITERS) == 0
|| rtems_filesystem_eval_path_has_path(ctx)
200c70c: c2 06 20 04 ld [ %i0 + 4 ], %g1
200c710: 80 a0 60 00 cmp %g1, 0
200c714: 02 80 00 0c be 200c744 <rtems_filesystem_eval_path_generic+0x22c>
200c718: 01 00 00 00 nop
) {
rtems_filesystem_eval_path_error(ctx, ENOENT);
200c71c: 92 10 20 02 mov 2, %o1 ! 2 <PROM_START+0x2>
200c720: 7f ff e0 55 call 2004874 <rtems_filesystem_eval_path_error>
200c724: 01 00 00 00 nop
200c728: 81 c7 e0 08 ret
200c72c: 81 e8 00 00 restore
}
}
}
} else {
rtems_filesystem_eval_path_error(ctx, ENOTDIR);
200c730: 90 10 00 18 mov %i0, %o0
200c734: 10 bf ff fb b 200c720 <rtems_filesystem_eval_path_generic+0x208>
200c738: 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) {
200c73c: 02 bf ff 7d be 200c530 <rtems_filesystem_eval_path_generic+0x18>
200c740: 01 00 00 00 nop
200c744: 81 c7 e0 08 ret
200c748: 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 49 call 201100c <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 68 or %i1, 0x368, %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 18 ld [ %g1 + 0x318 ], %o5 ! 201cf18 <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 fd call 200bf6c <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
0200c2f0 <rtems_filesystem_get_mount_handler>:
rtems_filesystem_fsmount_me_t
rtems_filesystem_get_mount_handler(
const char *type
)
{
200c2f0: 9d e3 bf 98 save %sp, -104, %sp
find_arg fa = {
200c2f4: f0 27 bf f8 st %i0, [ %fp + -8 ]
.type = type,
.mount_h = NULL
};
if ( type != NULL ) {
200c2f8: 80 a6 20 00 cmp %i0, 0
200c2fc: 02 80 00 06 be 200c314 <rtems_filesystem_get_mount_handler+0x24><== NEVER TAKEN
200c300: c0 27 bf fc clr [ %fp + -4 ]
rtems_filesystem_iterate( find_handler, &fa );
200c304: 11 00 80 30 sethi %hi(0x200c000), %o0
200c308: 92 07 bf f8 add %fp, -8, %o1
200c30c: 7f ff ff ce call 200c244 <rtems_filesystem_iterate>
200c310: 90 12 21 e0 or %o0, 0x1e0, %o0
}
return fa.mount_h;
}
200c314: f0 07 bf fc ld [ %fp + -4 ], %i0
200c318: 81 c7 e0 08 ret
200c31c: 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 18 or %g2, 0x318, %g1 ! 201ab18 <rtems_filesystem_root_configuration>
20034b0: d0 00 a3 18 ld [ %g2 + 0x318 ], %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 f0 or %o0, 0x1f0, %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 c8 call 200801c <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
0200c244 <rtems_filesystem_iterate>:
bool rtems_filesystem_iterate(
rtems_per_filesystem_routine routine,
void *routine_arg
)
{
200c244: 9d e3 bf a0 save %sp, -96, %sp
const rtems_filesystem_table_t *table_entry = &rtems_filesystem_table [0];
200c248: 39 00 80 6a sethi %hi(0x201a800), %i4
rtems_chain_node *node = NULL;
bool stop = false;
200c24c: ba 10 20 00 clr %i5
while ( table_entry->type && !stop ) {
200c250: 10 80 00 06 b 200c268 <rtems_filesystem_iterate+0x24>
200c254: b8 17 23 2c or %i4, 0x32c, %i4
stop = (*routine)( table_entry, routine_arg );
200c258: 92 10 00 19 mov %i1, %o1
200c25c: 9f c6 00 00 call %i0
200c260: b8 07 20 08 add %i4, 8, %i4
200c264: 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 ) {
200c268: c2 07 00 00 ld [ %i4 ], %g1
200c26c: 80 a0 60 00 cmp %g1, 0
200c270: 02 80 00 08 be 200c290 <rtems_filesystem_iterate+0x4c>
200c274: 82 0f 60 ff and %i5, 0xff, %g1
200c278: 80 a0 60 00 cmp %g1, 0
200c27c: 02 bf ff f7 be 200c258 <rtems_filesystem_iterate+0x14>
200c280: 90 10 00 1c mov %i4, %o0
200c284: b0 0f 60 ff and %i5, 0xff, %i0
200c288: 81 c7 e0 08 ret
200c28c: 81 e8 00 00 restore
stop = (*routine)( table_entry, routine_arg );
++table_entry;
}
if ( !stop ) {
200c290: 80 a0 60 00 cmp %g1, 0
200c294: 32 80 00 15 bne,a 200c2e8 <rtems_filesystem_iterate+0xa4>
200c298: b0 0f 60 ff and %i5, 0xff, %i0
rtems_libio_lock();
200c29c: 7f ff ff de call 200c214 <rtems_libio_lock>
200c2a0: 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;
200c2a4: 03 00 80 73 sethi %hi(0x201cc00), %g1
200c2a8: f8 00 63 b0 ld [ %g1 + 0x3b0 ], %i4 ! 201cfb0 <filesystem_chain>
for (
200c2ac: 10 80 00 06 b 200c2c4 <rtems_filesystem_iterate+0x80>
200c2b0: b6 16 e3 b4 or %i3, 0x3b4, %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 );
200c2b4: 9f c6 00 00 call %i0
200c2b8: 92 10 00 19 mov %i1, %o1
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Next(
Chain_Node *the_node
)
{
return the_node->next;
200c2bc: f8 07 00 00 ld [ %i4 ], %i4
200c2c0: ba 10 00 08 mov %o0, %i5
++table_entry;
}
if ( !stop ) {
rtems_libio_lock();
for (
200c2c4: 80 a7 00 1b cmp %i4, %i3
200c2c8: 12 80 00 05 bne 200c2dc <rtems_filesystem_iterate+0x98>
200c2cc: 80 8f 60 ff btst 0xff, %i5
) {
const filesystem_node *fsn = (filesystem_node *) node;
stop = (*routine)( &fsn->entry, routine_arg );
}
rtems_libio_unlock();
200c2d0: 7f ff ff d8 call 200c230 <rtems_libio_unlock>
200c2d4: b0 0f 60 ff and %i5, 0xff, %i0
200c2d8: 30 80 00 04 b,a 200c2e8 <rtems_filesystem_iterate+0xa4>
if ( !stop ) {
rtems_libio_lock();
for (
node = rtems_chain_first( &filesystem_chain );
!rtems_chain_is_tail( &filesystem_chain, node ) && !stop;
200c2dc: 02 bf ff f6 be 200c2b4 <rtems_filesystem_iterate+0x70> <== ALWAYS TAKEN
200c2e0: 90 07 20 08 add %i4, 8, %o0
200c2e4: 30 bf ff fb b,a 200c2d0 <rtems_filesystem_iterate+0x8c> <== NOT EXECUTED
}
rtems_libio_unlock();
}
return stop;
}
200c2e8: 81 c7 e0 08 ret
200c2ec: 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 b8 call 200bfb4 <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 4c call 200fa18 <__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
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 ed call 20087ac <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 0a call 2008858 <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 90 call 20085c4 <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 86 call 20085c4 <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 b8 call 20087ac <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 4e call 200dbb0 <_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 10 or %l1, 0x110, %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 18 or %l3, 0x118, %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 cd call 2015f24 <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 20 ld [ %l2 + 0x120 ], %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 2b call 20154ec <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
0200a5dc <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)
{
200a5dc: 9d e3 bf a0 save %sp, -96, %sp
uint32_t i;
uint32_t api_index;
Thread_Control *the_thread;
Objects_Information *information;
if ( !routine )
200a5e0: ba 10 20 01 mov 1, %i5
200a5e4: 80 a6 20 00 cmp %i0, 0
200a5e8: 02 80 00 0d be 200a61c <rtems_iterate_over_all_threads+0x40><== NEVER TAKEN
200a5ec: 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)
200a5f0: 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 ];
200a5f4: 84 16 a1 34 or %i2, 0x134, %g2
200a5f8: c2 00 80 01 ld [ %g2 + %g1 ], %g1
200a5fc: f6 00 60 04 ld [ %g1 + 4 ], %i3
if ( !information )
200a600: 80 a6 e0 00 cmp %i3, 0
200a604: 12 80 00 0f bne 200a640 <rtems_iterate_over_all_threads+0x64>
200a608: b8 10 20 01 mov 1, %i4
Objects_Information *information;
if ( !routine )
return;
for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; api_index++ ) {
200a60c: ba 07 60 01 inc %i5
200a610: 80 a7 60 04 cmp %i5, 4
200a614: 12 bf ff f8 bne 200a5f4 <rtems_iterate_over_all_threads+0x18>
200a618: 83 2f 60 02 sll %i5, 2, %g1
200a61c: 81 c7 e0 08 ret
200a620: 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 ];
200a624: 83 2f 20 02 sll %i4, 2, %g1
200a628: d0 00 80 01 ld [ %g2 + %g1 ], %o0
if ( !the_thread )
200a62c: 80 a2 20 00 cmp %o0, 0
200a630: 02 80 00 04 be 200a640 <rtems_iterate_over_all_threads+0x64>
200a634: b8 07 20 01 inc %i4
continue;
(*routine)(the_thread);
200a638: 9f c6 00 00 call %i0
200a63c: 01 00 00 00 nop
information = _Objects_Information_table[ api_index ][ 1 ];
if ( !information )
continue;
for ( i=1 ; i <= information->maximum ; i++ ) {
200a640: c2 16 e0 10 lduh [ %i3 + 0x10 ], %g1
200a644: 80 a7 00 01 cmp %i4, %g1
200a648: 28 bf ff f7 bleu,a 200a624 <rtems_iterate_over_all_threads+0x48>
200a64c: 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++ ) {
200a650: 10 bf ff f0 b 200a610 <rtems_iterate_over_all_threads+0x34>
200a654: 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 30 ld [ %g1 + 0x230 ], %i5 ! 201ce30 <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 50 st %o0, [ %g1 + 0x150 ]
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 54 st %o0, [ %g1 + 0x154 ]
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 32 call 2007690 <rtems_semaphore_create>
20039cc: 98 13 21 58 or %o4, 0x158, %o4 ! 201d958 <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 90 call 200801c <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 34 ld [ %g1 + 0x234 ], %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
020048ec <rtems_libio_set_private_env>:
}
rtems_status_code rtems_libio_set_private_env(void)
{
20048ec: 9d e3 bf a0 save %sp, -96, %sp
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_id self_task_id = rtems_task_self();
20048f0: 40 00 06 4a call 2006218 <rtems_task_self>
20048f4: 01 00 00 00 nop
rtems_user_env_t *old_env = rtems_current_user_env;
20048f8: 03 00 80 49 sethi %hi(0x2012400), %g1
20048fc: f8 00 63 fc ld [ %g1 + 0x3fc ], %i4 ! 20127fc <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;
2004900: c2 07 20 24 ld [ %i4 + 0x24 ], %g1
if (uses_global_env || uses_shared_env) {
2004904: 80 a0 40 08 cmp %g1, %o0
2004908: 12 80 00 07 bne 2004924 <rtems_libio_set_private_env+0x38>
200490c: b6 10 00 08 mov %o0, %i3
2004910: 03 00 80 4a sethi %hi(0x2012800), %g1
2004914: 82 10 60 00 mov %g1, %g1 ! 2012800 <rtems_global_user_env>
2004918: 80 a7 00 01 cmp %i4, %g1
200491c: 12 80 00 2b bne 20049c8 <rtems_libio_set_private_env+0xdc><== ALWAYS TAKEN
2004920: b0 10 20 00 clr %i0
rtems_user_env_t *new_env = calloc(1, sizeof(*new_env));
2004924: 90 10 20 01 mov 1, %o0
2004928: 92 10 20 2c mov 0x2c, %o1
200492c: 40 00 13 d3 call 2009878 <calloc>
2004930: b0 10 20 1a mov 0x1a, %i0
if (new_env != NULL) {
2004934: 80 a2 20 00 cmp %o0, 0
2004938: 02 80 00 24 be 20049c8 <rtems_libio_set_private_env+0xdc>
200493c: ba 10 00 08 mov %o0, %i5
*new_env = *old_env;
2004940: 92 10 00 1c mov %i4, %o1
2004944: 40 00 1f 89 call 200c768 <memcpy>
2004948: 94 10 20 2c mov 0x2c, %o2
new_env->reference_count = 1;
200494c: 82 10 20 01 mov 1, %g1
new_env->task_id = self_task_id;
2004950: 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;
2004954: 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);
2004958: 40 00 02 c8 call 2005478 <rtems_filesystem_global_location_obtain>
200495c: 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 =
2004960: 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);
2004964: 40 00 02 c5 call 2005478 <rtems_filesystem_global_location_obtain>
2004968: 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;
200496c: 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 =
2004970: d0 27 40 00 st %o0, [ %i5 ]
rtems_filesystem_global_location_obtain(&old_env->current_directory);
if (
2004974: c4 00 60 10 ld [ %g1 + 0x10 ], %g2
2004978: 03 00 80 48 sethi %hi(0x2012000), %g1
200497c: 82 10 60 74 or %g1, 0x74, %g1 ! 2012074 <rtems_filesystem_null_handlers>
2004980: 80 a0 80 01 cmp %g2, %g1
2004984: 22 80 00 14 be,a 20049d4 <rtems_libio_set_private_env+0xe8>
2004988: 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)
200498c: c4 02 20 10 ld [ %o0 + 0x10 ], %g2
2004990: 80 a0 80 01 cmp %g2, %g1
2004994: 02 80 00 0f be 20049d0 <rtems_libio_set_private_env+0xe4> <== NEVER TAKEN
2004998: 90 10 20 00 clr %o0
) {
sc = rtems_task_variable_add(
200499c: 37 00 80 49 sethi %hi(0x2012400), %i3
20049a0: 15 00 80 12 sethi %hi(0x2004800), %o2
20049a4: 92 16 e3 fc or %i3, 0x3fc, %o1
20049a8: 40 00 06 3c call 2006298 <rtems_task_variable_add>
20049ac: 94 12 a0 78 or %o2, 0x78, %o2
RTEMS_SELF,
(void **) &rtems_current_user_env,
free_user_env
);
if (sc == RTEMS_SUCCESSFUL) {
20049b0: b0 92 20 00 orcc %o0, 0, %i0
20049b4: 32 80 00 08 bne,a 20049d4 <rtems_libio_set_private_env+0xe8>
20049b8: b0 10 20 05 mov 5, %i0
free_user_env_protected(old_env);
20049bc: 7f ff ff c2 call 20048c4 <free_user_env_protected>
20049c0: 90 10 00 1c mov %i4, %o0
rtems_current_user_env = new_env;
20049c4: fa 26 e3 fc st %i5, [ %i3 + 0x3fc ]
20049c8: 81 c7 e0 08 ret
20049cc: 81 e8 00 00 restore
20049d0: b0 10 20 0d mov 0xd, %i0 <== NOT EXECUTED
} else {
sc = RTEMS_UNSATISFIED;
}
if (sc != RTEMS_SUCCESSFUL) {
free_user_env(new_env);
20049d4: 7f ff ff a9 call 2004878 <free_user_env>
20049d8: 90 10 00 1d mov %i5, %o0
sc = RTEMS_NO_MEMORY;
}
}
return sc;
}
20049dc: 81 c7 e0 08 ret
20049e0: 81 e8 00 00 restore
020049e4 <rtems_libio_share_private_env>:
rtems_status_code rtems_libio_share_private_env(rtems_id task_id)
{
20049e4: 9d e3 bf 98 save %sp, -104, %sp
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_id self_task_id = rtems_task_self();
20049e8: 40 00 06 0c call 2006218 <rtems_task_self>
20049ec: 01 00 00 00 nop
if (task_id != RTEMS_SELF && self_task_id != task_id) {
20049f0: 80 a2 00 18 cmp %o0, %i0
20049f4: 22 80 00 27 be,a 2004a90 <rtems_libio_share_private_env+0xac>
20049f8: b0 10 20 00 clr %i0
20049fc: 80 a6 20 00 cmp %i0, 0
2004a00: 22 80 00 24 be,a 2004a90 <rtems_libio_share_private_env+0xac>
2004a04: 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++;
2004a08: 03 00 80 4c sethi %hi(0x2013000), %g1
2004a0c: c4 00 62 30 ld [ %g1 + 0x230 ], %g2 ! 2013230 <_Thread_Dispatch_disable_level>
2004a10: 84 00 a0 01 inc %g2
2004a14: c4 20 62 30 st %g2, [ %g1 + 0x230 ]
return _Thread_Dispatch_disable_level;
2004a18: c2 00 62 30 ld [ %g1 + 0x230 ], %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(
2004a1c: 13 00 80 49 sethi %hi(0x2012400), %o1
2004a20: 90 10 00 18 mov %i0, %o0
2004a24: 92 12 63 fc or %o1, 0x3fc, %o1
2004a28: 40 00 06 6c call 20063d8 <rtems_task_variable_get>
2004a2c: 94 07 bf fc add %fp, -4, %o2
task_id,
(void *) &rtems_current_user_env,
(void *) &env
);
if (sc == RTEMS_SUCCESSFUL) {
2004a30: b0 92 20 00 orcc %o0, 0, %i0
2004a34: 32 80 00 06 bne,a 2004a4c <rtems_libio_share_private_env+0x68>
2004a38: b0 10 20 0d mov 0xd, %i0
++env->reference_count;
2004a3c: c2 07 bf fc ld [ %fp + -4 ], %g1
2004a40: c4 00 60 28 ld [ %g1 + 0x28 ], %g2
2004a44: 84 00 a0 01 inc %g2
2004a48: c4 20 60 28 st %g2, [ %g1 + 0x28 ]
} else {
sc = RTEMS_UNSATISFIED;
}
_Thread_Enable_dispatch();
2004a4c: 40 00 0e 5b call 20083b8 <_Thread_Enable_dispatch>
2004a50: 01 00 00 00 nop
if (sc == RTEMS_SUCCESSFUL) {
2004a54: 80 a6 20 00 cmp %i0, 0
2004a58: 12 80 00 0e bne 2004a90 <rtems_libio_share_private_env+0xac>
2004a5c: 90 10 20 00 clr %o0
sc = rtems_task_variable_add(
2004a60: 3b 00 80 49 sethi %hi(0x2012400), %i5
2004a64: 15 00 80 12 sethi %hi(0x2004800), %o2
2004a68: 92 17 63 fc or %i5, 0x3fc, %o1
2004a6c: 40 00 06 0b call 2006298 <rtems_task_variable_add>
2004a70: 94 12 a0 78 or %o2, 0x78, %o2
RTEMS_SELF,
(void **) &rtems_current_user_env,
free_user_env
);
if (sc == RTEMS_SUCCESSFUL) {
2004a74: b0 92 20 00 orcc %o0, 0, %i0
2004a78: 12 80 00 08 bne 2004a98 <rtems_libio_share_private_env+0xb4><== NEVER TAKEN
2004a7c: d0 07 bf fc ld [ %fp + -4 ], %o0
free_user_env_protected(rtems_current_user_env);
2004a80: 7f ff ff 91 call 20048c4 <free_user_env_protected>
2004a84: d0 07 63 fc ld [ %i5 + 0x3fc ], %o0
rtems_current_user_env = env;
2004a88: c2 07 bf fc ld [ %fp + -4 ], %g1
2004a8c: c2 27 63 fc st %g1, [ %i5 + 0x3fc ]
2004a90: 81 c7 e0 08 ret
2004a94: 81 e8 00 00 restore
} else {
free_user_env_protected(env);
2004a98: 7f ff ff 8b call 20048c4 <free_user_env_protected> <== NOT EXECUTED
2004a9c: b0 10 20 05 mov 5, %i0 <== NOT EXECUTED
2004aa0: 81 c7 e0 08 ret <== NOT EXECUTED
2004aa4: 81 e8 00 00 restore <== NOT EXECUTED
0200c0e4 <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 ) {
200c0e4: 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 )
{
200c0e8: 82 10 00 08 mov %o0, %g1
int fcntl_flags = 0;
if ( (flags & LIBIO_FLAGS_READ_WRITE) == LIBIO_FLAGS_READ_WRITE ) {
200c0ec: 80 a0 a0 06 cmp %g2, 6
200c0f0: 02 80 00 07 be 200c10c <rtems_libio_to_fcntl_flags+0x28>
200c0f4: 90 10 20 02 mov 2, %o0
fcntl_flags |= O_RDWR;
} else if ( (flags & LIBIO_FLAGS_READ) == LIBIO_FLAGS_READ) {
200c0f8: 80 88 60 02 btst 2, %g1
200c0fc: 12 80 00 04 bne 200c10c <rtems_libio_to_fcntl_flags+0x28> <== ALWAYS TAKEN
200c100: 90 10 20 00 clr %o0
fcntl_flags |= O_RDONLY;
} else if ( (flags & LIBIO_FLAGS_WRITE) == LIBIO_FLAGS_WRITE) {
200c104: 91 30 60 02 srl %g1, 2, %o0 <== NOT EXECUTED
200c108: 90 0a 20 01 and %o0, 1, %o0 <== NOT EXECUTED
fcntl_flags |= O_WRONLY;
}
if ( (flags & LIBIO_FLAGS_NO_DELAY) == LIBIO_FLAGS_NO_DELAY ) {
200c10c: 80 88 60 01 btst 1, %g1
200c110: 02 80 00 04 be 200c120 <rtems_libio_to_fcntl_flags+0x3c>
200c114: 80 88 62 00 btst 0x200, %g1
fcntl_flags |= O_NONBLOCK;
200c118: 05 00 00 10 sethi %hi(0x4000), %g2
200c11c: 90 12 00 02 or %o0, %g2, %o0
}
if ( (flags & LIBIO_FLAGS_APPEND) == LIBIO_FLAGS_APPEND ) {
200c120: 32 80 00 02 bne,a 200c128 <rtems_libio_to_fcntl_flags+0x44>
200c124: 90 12 20 08 or %o0, 8, %o0
fcntl_flags |= O_APPEND;
}
if ( (flags & LIBIO_FLAGS_CREATE) == LIBIO_FLAGS_CREATE ) {
200c128: 80 88 64 00 btst 0x400, %g1
200c12c: 32 80 00 02 bne,a 200c134 <rtems_libio_to_fcntl_flags+0x50>
200c130: 90 12 22 00 or %o0, 0x200, %o0
fcntl_flags |= O_CREAT;
}
return fcntl_flags;
}
200c134: 81 c3 e0 08 retl
02004aa8 <rtems_libio_use_global_env>:
return sc;
}
void rtems_libio_use_global_env(void)
{
2004aa8: 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) {
2004aac: 3b 00 80 49 sethi %hi(0x2012400), %i5
2004ab0: c2 07 63 fc ld [ %i5 + 0x3fc ], %g1 ! 20127fc <rtems_current_user_env>
2004ab4: 39 00 80 4a sethi %hi(0x2012800), %i4
2004ab8: b8 17 20 00 mov %i4, %i4 ! 2012800 <rtems_global_user_env>
2004abc: 80 a0 40 1c cmp %g1, %i4
2004ac0: 02 80 00 0a be 2004ae8 <rtems_libio_use_global_env+0x40>
2004ac4: 92 17 63 fc or %i5, 0x3fc, %o1
sc = rtems_task_variable_delete(
2004ac8: 40 00 06 1f call 2006344 <rtems_task_variable_delete>
2004acc: 90 10 20 00 clr %o0
RTEMS_SELF,
(void **) &rtems_current_user_env
);
if (sc != RTEMS_SUCCESSFUL) {
2004ad0: 80 a2 20 00 cmp %o0, 0
2004ad4: 22 80 00 05 be,a 2004ae8 <rtems_libio_use_global_env+0x40><== ALWAYS TAKEN
2004ad8: f8 27 63 fc st %i4, [ %i5 + 0x3fc ]
rtems_fatal_error_occurred(0xdeadbeef);
2004adc: 11 37 ab 6f sethi %hi(0xdeadbc00), %o0 <== NOT EXECUTED
2004ae0: 40 00 06 c8 call 2006600 <rtems_fatal_error_occurred> <== NOT EXECUTED
2004ae4: 90 12 22 ef or %o0, 0x2ef, %o0 ! deadbeef <RAM_END+0xdc6dbeef><== NOT EXECUTED
2004ae8: 81 c7 e0 08 ret
2004aec: 81 e8 00 00 restore
0200719c <rtems_malloc_statistics_at_free>:
* size and thus we skip updating the statistics.
*/
static void rtems_malloc_statistics_at_free(
void *pointer
)
{
200719c: 9d e3 bf 98 save %sp, -104, %sp
uintptr_t size;
if (_Protected_heap_Get_block_size(RTEMS_Malloc_Heap, pointer, &size) ) {
20071a0: 03 00 80 8c sethi %hi(0x2023000), %g1
20071a4: d0 00 60 60 ld [ %g1 + 0x60 ], %o0 ! 2023060 <RTEMS_Malloc_Heap>
20071a8: 92 10 00 18 mov %i0, %o1
20071ac: 40 00 1a ab call 200dc58 <_Protected_heap_Get_block_size>
20071b0: 94 07 bf fc add %fp, -4, %o2
20071b4: 80 8a 20 ff btst 0xff, %o0
20071b8: 02 80 00 08 be 20071d8 <rtems_malloc_statistics_at_free+0x3c><== NEVER TAKEN
20071bc: 03 00 80 91 sethi %hi(0x2024400), %g1
MSBUMP(lifetime_freed, size);
20071c0: c8 07 bf fc ld [ %fp + -4 ], %g4
20071c4: 82 10 60 c0 or %g1, 0xc0, %g1
20071c8: c4 18 60 28 ldd [ %g1 + 0x28 ], %g2
20071cc: 86 80 c0 04 addcc %g3, %g4, %g3
20071d0: 84 40 a0 00 addx %g2, 0, %g2
20071d4: c4 38 60 28 std %g2, [ %g1 + 0x28 ]
20071d8: 81 c7 e0 08 ret
20071dc: 81 e8 00 00 restore
020071e0 <rtems_malloc_statistics_at_malloc>:
}
static void rtems_malloc_statistics_at_malloc(
void *pointer
)
{
20071e0: 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 )
20071e4: 80 a6 20 00 cmp %i0, 0
20071e8: 02 80 00 14 be 2007238 <rtems_malloc_statistics_at_malloc+0x58><== NEVER TAKEN
20071ec: c0 27 bf fc clr [ %fp + -4 ]
return;
_Protected_heap_Get_block_size(RTEMS_Malloc_Heap, pointer, &actual_size);
20071f0: 03 00 80 8c sethi %hi(0x2023000), %g1
20071f4: d0 00 60 60 ld [ %g1 + 0x60 ], %o0 ! 2023060 <RTEMS_Malloc_Heap>
20071f8: 92 10 00 18 mov %i0, %o1
20071fc: 40 00 1a 97 call 200dc58 <_Protected_heap_Get_block_size>
2007200: 94 07 bf fc add %fp, -4, %o2
MSBUMP(lifetime_allocated, actual_size);
2007204: 03 00 80 91 sethi %hi(0x2024400), %g1
2007208: c8 07 bf fc ld [ %fp + -4 ], %g4
200720c: 82 10 60 c0 or %g1, 0xc0, %g1
2007210: c4 18 60 20 ldd [ %g1 + 0x20 ], %g2
2007214: 86 80 c0 04 addcc %g3, %g4, %g3
2007218: 84 40 a0 00 addx %g2, 0, %g2
200721c: c4 38 60 20 std %g2, [ %g1 + 0x20 ]
current_depth = (uint32_t) (s->lifetime_allocated - s->lifetime_freed);
2007220: c4 00 60 2c ld [ %g1 + 0x2c ], %g2
2007224: 84 20 c0 02 sub %g3, %g2, %g2
if (current_depth > s->max_depth)
2007228: c6 00 60 18 ld [ %g1 + 0x18 ], %g3
200722c: 80 a0 80 03 cmp %g2, %g3
2007230: 38 80 00 02 bgu,a 2007238 <rtems_malloc_statistics_at_malloc+0x58>
2007234: c4 20 60 18 st %g2, [ %g1 + 0x18 ]
2007238: 81 c7 e0 08 ret
200723c: 81 e8 00 00 restore
0201043c <rtems_memalign>:
int rtems_memalign(
void **pointer,
size_t alignment,
size_t size
)
{
201043c: 9d e3 bf a0 save %sp, -96, %sp
void *return_this;
/*
* Parameter error checks
*/
if ( !pointer )
2010440: ba 96 20 00 orcc %i0, 0, %i5
2010444: 12 80 00 04 bne 2010454 <rtems_memalign+0x18>
2010448: 03 00 80 87 sethi %hi(0x2021c00), %g1
return EINVAL;
201044c: 81 c7 e0 08 ret
2010450: 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()) &&
2010454: c2 00 62 60 ld [ %g1 + 0x260 ], %g1
2010458: 80 a0 60 03 cmp %g1, 3
201045c: 02 80 00 0f be 2010498 <rtems_memalign+0x5c>
2010460: c0 27 40 00 clr [ %i5 ]
return EINVAL;
/*
* If some free's have been deferred, then do them now.
*/
malloc_deferred_frees_process();
2010464: 7f ff d2 83 call 2004e70 <malloc_deferred_frees_process>
2010468: b0 10 20 0c mov 0xc, %i0
Heap_Control *heap,
uintptr_t size,
uintptr_t alignment
)
{
return
201046c: 03 00 80 83 sethi %hi(0x2020c00), %g1
2010470: d0 00 63 74 ld [ %g1 + 0x374 ], %o0 ! 2020f74 <RTEMS_Malloc_Heap>
2010474: 92 10 00 1a mov %i2, %o1
2010478: 94 10 00 19 mov %i1, %o2
201047c: 7f ff e9 55 call 200a9d0 <_Protected_heap_Allocate_aligned_with_boundary>
2010480: 96 10 20 00 clr %o3
return_this = _Protected_heap_Allocate_aligned(
RTEMS_Malloc_Heap,
size,
alignment
);
if ( !return_this )
2010484: 80 a2 20 00 cmp %o0, 0
2010488: 12 80 00 0a bne 20104b0 <rtems_memalign+0x74>
201048c: b8 10 00 08 mov %o0, %i4
2010490: 81 c7 e0 08 ret
2010494: 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() )
2010498: 7f ff d2 63 call 2004e24 <malloc_is_system_state_OK>
201049c: 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()) &&
20104a0: 80 8a 20 ff btst 0xff, %o0
20104a4: 02 bf ff ea be 201044c <rtems_memalign+0x10> <== NEVER TAKEN
20104a8: 01 00 00 00 nop
20104ac: 30 bf ff ee b,a 2010464 <rtems_memalign+0x28>
return ENOMEM;
/*
* If configured, update the more involved statistics
*/
if ( rtems_malloc_statistics_helpers )
20104b0: 03 00 80 85 sethi %hi(0x2021400), %g1
20104b4: c2 00 63 34 ld [ %g1 + 0x334 ], %g1 ! 2021734 <rtems_malloc_statistics_helpers>
20104b8: 80 a0 60 00 cmp %g1, 0
20104bc: 22 80 00 06 be,a 20104d4 <rtems_memalign+0x98>
20104c0: f8 27 40 00 st %i4, [ %i5 ]
(*rtems_malloc_statistics_helpers->at_malloc)(pointer);
20104c4: c2 00 60 04 ld [ %g1 + 4 ], %g1
20104c8: 9f c0 40 00 call %g1
20104cc: 90 10 00 1d mov %i5, %o0
*pointer = return_this;
20104d0: f8 27 40 00 st %i4, [ %i5 ]
return 0;
}
20104d4: 81 c7 e0 08 ret
20104d8: 91 e8 20 00 restore %g0, 0, %o0
02009680 <rtems_mkdir>:
return (retval);
}
int
rtems_mkdir(const char *path, mode_t mode)
{
2009680: 9d e3 bf 58 save %sp, -168, %sp
int success = 0;
char *dup_path = strdup(path);
2009684: 40 00 65 74 call 2022c54 <strdup>
2009688: 90 10 00 18 mov %i0, %o0
if (dup_path != NULL) {
200968c: b6 92 20 00 orcc %o0, 0, %i3
2009690: 32 80 00 04 bne,a 20096a0 <rtems_mkdir+0x20> <== ALWAYS TAKEN
2009694: c2 4e c0 00 ldsb [ %i3 ], %g1
success = build(dup_path, mode);
free(dup_path);
}
return success != 0 ? 0 : -1;
2009698: 81 c7 e0 08 ret
200969c: 91 e8 3f ff restore %g0, -1, %o0
char *p;
p = path;
oumask = 0;
retval = 1;
if (p[0] == '/') /* Skip leading '/'. */
20096a0: b8 10 20 01 mov 1, %i4
++p;
20096a4: 82 18 60 2f xor %g1, 0x2f, %g1
char *p;
p = path;
oumask = 0;
retval = 1;
if (p[0] == '/') /* Skip leading '/'. */
20096a8: b0 10 20 00 clr %i0
++p;
20096ac: 80 a0 00 01 cmp %g0, %g1
retval = 0;
break;
}
}
if (!last)
*p = '/';
20096b0: a0 10 20 2f mov 0x2f, %l0
p = path;
oumask = 0;
retval = 1;
if (p[0] == '/') /* Skip leading '/'. */
++p;
20096b4: b4 66 ff ff subx %i3, -1, %i2
char *p;
p = path;
oumask = 0;
retval = 1;
if (p[0] == '/') /* Skip leading '/'. */
20096b8: 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)) {
20096bc: 23 00 00 3c sethi %hi(0xf000), %l1
20096c0: 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')
20096c4: c6 4e 80 00 ldsb [ %i2 ], %g3
20096c8: 80 a0 e0 00 cmp %g3, 0
20096cc: 22 80 00 07 be,a 20096e8 <rtems_mkdir+0x68>
20096d0: 84 10 20 01 mov 1, %g2
last = 1;
else if (p[0] != '/')
20096d4: 80 a0 e0 2f cmp %g3, 0x2f
20096d8: 12 80 00 4f bne 2009814 <rtems_mkdir+0x194>
20096dc: 84 10 20 00 clr %g2
continue;
*p = '\0';
20096e0: 10 80 00 03 b 20096ec <rtems_mkdir+0x6c>
20096e4: c0 2e 80 00 clrb [ %i2 ]
20096e8: c0 2e 80 00 clrb [ %i2 ]
if (!last && p[1] == '\0')
20096ec: 80 a0 a0 00 cmp %g2, 0
20096f0: 12 80 00 05 bne 2009704 <rtems_mkdir+0x84>
20096f4: ba 10 20 01 mov 1, %i5
20096f8: c4 4e a0 01 ldsb [ %i2 + 1 ], %g2
20096fc: 80 a0 00 02 cmp %g0, %g2
2009700: ba 60 3f ff subx %g0, -1, %i5
last = 1;
if (first) {
2009704: 80 a0 60 00 cmp %g1, 0
2009708: 02 80 00 08 be 2009728 <rtems_mkdir+0xa8>
200970c: 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);
2009710: 40 00 0a 06 call 200bf28 <umask>
2009714: 90 10 20 00 clr %o0
2009718: b0 10 00 08 mov %o0, %i0
numask = oumask & ~(S_IWUSR | S_IXUSR);
(void)umask(numask);
200971c: 40 00 0a 03 call 200bf28 <umask>
2009720: 90 0a 3f 3f and %o0, -193, %o0
first = 0;
}
if (last)
2009724: 80 a7 60 00 cmp %i5, 0
2009728: 02 80 00 05 be 200973c <rtems_mkdir+0xbc>
200972c: 92 10 21 ff mov 0x1ff, %o1
(void)umask(oumask);
2009730: 40 00 09 fe call 200bf28 <umask>
2009734: 90 10 00 18 mov %i0, %o0
if (mkdir(path, last ? omode : S_IRWXU | S_IRWXG | S_IRWXO) < 0) {
2009738: 92 10 00 19 mov %i1, %o1
200973c: 7f ff fc a3 call 20089c8 <mkdir>
2009740: 90 10 00 1b mov %i3, %o0
2009744: 80 a2 20 00 cmp %o0, 0
2009748: 16 80 00 2d bge 20097fc <rtems_mkdir+0x17c>
200974c: 80 a7 60 00 cmp %i5, 0
if (errno == EEXIST || errno == EISDIR) {
2009750: 40 00 5d 1b call 2020bbc <__errno>
2009754: 01 00 00 00 nop
2009758: c2 02 00 00 ld [ %o0 ], %g1
200975c: 80 a0 60 11 cmp %g1, 0x11
2009760: 12 80 00 09 bne 2009784 <rtems_mkdir+0x104>
2009764: 90 10 00 1b mov %i3, %o0
if (stat(path, &sb) < 0) {
2009768: 40 00 00 3d call 200985c <stat>
200976c: 92 07 bf b8 add %fp, -72, %o1
2009770: 80 a2 20 00 cmp %o0, 0
2009774: 16 80 00 0c bge 20097a4 <rtems_mkdir+0x124> <== ALWAYS TAKEN
2009778: c2 07 bf c4 ld [ %fp + -60 ], %g1
retval = 0;
200977c: 10 80 00 2b b 2009828 <rtems_mkdir+0x1a8> <== NOT EXECUTED
2009780: 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) {
2009784: 40 00 5d 0e call 2020bbc <__errno>
2009788: 01 00 00 00 nop
200978c: c2 02 00 00 ld [ %o0 ], %g1
2009790: 80 a0 60 15 cmp %g1, 0x15
2009794: 02 bf ff f5 be 2009768 <rtems_mkdir+0xe8> <== NEVER TAKEN
2009798: 90 10 00 1b mov %i3, %o0
if (stat(path, &sb) < 0) {
retval = 0;
200979c: 10 80 00 23 b 2009828 <rtems_mkdir+0x1a8>
20097a0: b8 10 20 00 clr %i4
break;
} else if (!S_ISDIR(sb.st_mode)) {
20097a4: 82 08 40 11 and %g1, %l1, %g1
20097a8: 80 a0 40 12 cmp %g1, %l2
20097ac: 02 80 00 0f be 20097e8 <rtems_mkdir+0x168>
20097b0: 80 a7 60 00 cmp %i5, 0
if (last)
20097b4: 02 80 00 08 be 20097d4 <rtems_mkdir+0x154>
20097b8: 01 00 00 00 nop
errno = EEXIST;
20097bc: 40 00 5d 00 call 2020bbc <__errno>
20097c0: b8 10 20 00 clr %i4 ! 0 <PROM_START>
20097c4: 82 10 20 11 mov 0x11, %g1
20097c8: c2 22 00 00 st %g1, [ %o0 ]
20097cc: 10 80 00 17 b 2009828 <rtems_mkdir+0x1a8>
20097d0: ba 10 20 01 mov 1, %i5
else
errno = ENOTDIR;
20097d4: 40 00 5c fa call 2020bbc <__errno>
20097d8: b8 10 20 00 clr %i4
20097dc: 82 10 20 14 mov 0x14, %g1
20097e0: 10 80 00 12 b 2009828 <rtems_mkdir+0x1a8>
20097e4: c2 22 00 00 st %g1, [ %o0 ]
retval = 0;
break;
}
if (last)
20097e8: 32 80 00 09 bne,a 200980c <rtems_mkdir+0x18c>
20097ec: b8 10 20 02 mov 2, %i4
retval = 0;
break;
}
}
if (!last)
*p = '/';
20097f0: e0 2e 80 00 stb %l0, [ %i2 ]
20097f4: 10 80 00 07 b 2009810 <rtems_mkdir+0x190>
20097f8: 84 10 20 00 clr %g2
} else {
retval = 0;
break;
}
}
if (!last)
20097fc: 22 bf ff fe be,a 20097f4 <rtems_mkdir+0x174>
2009800: e0 2e 80 00 stb %l0, [ %i2 ]
else
errno = ENOTDIR;
retval = 0;
break;
}
if (last)
2009804: 10 80 00 03 b 2009810 <rtems_mkdir+0x190>
2009808: 84 10 20 01 mov 1, %g2
200980c: 84 10 20 01 mov 1, %g2
2009810: 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) {
2009814: 80 a0 a0 00 cmp %g2, 0
2009818: 02 bf ff ab be 20096c4 <rtems_mkdir+0x44>
200981c: b4 06 a0 01 inc %i2
2009820: 10 80 00 03 b 200982c <rtems_mkdir+0x1ac>
2009824: 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) {
2009828: 82 10 20 00 clr %g1
}
}
if (!last)
*p = '/';
}
if (!first && !last)
200982c: 80 97 40 01 orcc %i5, %g1, %g0
2009830: 12 80 00 04 bne 2009840 <rtems_mkdir+0x1c0>
2009834: 01 00 00 00 nop
(void)umask(oumask);
2009838: 40 00 09 bc call 200bf28 <umask>
200983c: 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);
2009840: 7f ff fa 7a call 2008228 <free>
2009844: 90 10 00 1b mov %i3, %o0
}
return success != 0 ? 0 : -1;
2009848: 80 a7 20 00 cmp %i4, 0
200984c: 02 bf ff 93 be 2009698 <rtems_mkdir+0x18>
2009850: 01 00 00 00 nop
}
2009854: 81 c7 e0 08 ret
2009858: 91 e8 20 00 restore %g0, 0, %o0
02008de8 <rtems_partition_create>:
uint32_t length,
uint32_t buffer_size,
rtems_attribute attribute_set,
rtems_id *id
)
{
2008de8: 9d e3 bf a0 save %sp, -96, %sp
register Partition_Control *the_partition;
if ( !rtems_is_name_valid( name ) )
2008dec: 80 a6 20 00 cmp %i0, 0
2008df0: 02 80 00 39 be 2008ed4 <rtems_partition_create+0xec>
2008df4: 82 10 20 03 mov 3, %g1
return RTEMS_INVALID_NAME;
if ( !starting_address )
2008df8: 80 a6 60 00 cmp %i1, 0
2008dfc: 02 80 00 36 be 2008ed4 <rtems_partition_create+0xec>
2008e00: 82 10 20 09 mov 9, %g1
return RTEMS_INVALID_ADDRESS;
if ( !id )
2008e04: 80 a7 60 00 cmp %i5, 0
2008e08: 02 80 00 33 be 2008ed4 <rtems_partition_create+0xec> <== NEVER TAKEN
2008e0c: 80 a6 e0 00 cmp %i3, 0
return RTEMS_INVALID_ADDRESS;
if ( length == 0 || buffer_size == 0 || length < buffer_size ||
2008e10: 02 80 00 31 be 2008ed4 <rtems_partition_create+0xec>
2008e14: 82 10 20 08 mov 8, %g1
2008e18: 80 a6 a0 00 cmp %i2, 0
2008e1c: 02 80 00 2e be 2008ed4 <rtems_partition_create+0xec>
2008e20: 80 a6 80 1b cmp %i2, %i3
2008e24: 0a 80 00 2c bcs 2008ed4 <rtems_partition_create+0xec>
2008e28: 80 8e e0 07 btst 7, %i3
2008e2c: 12 80 00 2a bne 2008ed4 <rtems_partition_create+0xec>
2008e30: 80 8e 60 07 btst 7, %i1
!_Partition_Is_buffer_size_aligned( buffer_size ) )
return RTEMS_INVALID_SIZE;
if ( !_Addresses_Is_aligned( starting_address ) )
2008e34: 12 80 00 28 bne 2008ed4 <rtems_partition_create+0xec>
2008e38: 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++;
2008e3c: 03 00 80 89 sethi %hi(0x2022400), %g1
2008e40: c4 00 61 f0 ld [ %g1 + 0x1f0 ], %g2 ! 20225f0 <_Thread_Dispatch_disable_level>
2008e44: 84 00 a0 01 inc %g2
2008e48: c4 20 61 f0 st %g2, [ %g1 + 0x1f0 ]
return _Thread_Dispatch_disable_level;
2008e4c: 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 );
2008e50: 23 00 80 88 sethi %hi(0x2022000), %l1
2008e54: 40 00 06 ee call 200aa0c <_Objects_Allocate>
2008e58: 90 14 63 e4 or %l1, 0x3e4, %o0 ! 20223e4 <_Partition_Information>
_Thread_Disable_dispatch(); /* prevents deletion */
the_partition = _Partition_Allocate();
if ( !the_partition ) {
2008e5c: a0 92 20 00 orcc %o0, 0, %l0
2008e60: 32 80 00 06 bne,a 2008e78 <rtems_partition_create+0x90>
2008e64: f8 24 20 1c st %i4, [ %l0 + 0x1c ]
_Thread_Enable_dispatch();
2008e68: 40 00 0c 0c call 200be98 <_Thread_Enable_dispatch>
2008e6c: 01 00 00 00 nop
return RTEMS_TOO_MANY;
2008e70: 10 80 00 19 b 2008ed4 <rtems_partition_create+0xec>
2008e74: 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 );
2008e78: 92 10 00 1b mov %i3, %o1
_Thread_Enable_dispatch();
return RTEMS_TOO_MANY;
}
#endif
the_partition->starting_address = starting_address;
2008e7c: f2 24 20 10 st %i1, [ %l0 + 0x10 ]
the_partition->length = length;
2008e80: f4 24 20 14 st %i2, [ %l0 + 0x14 ]
the_partition->buffer_size = buffer_size;
2008e84: f6 24 20 18 st %i3, [ %l0 + 0x18 ]
the_partition->attribute_set = attribute_set;
the_partition->number_of_used_blocks = 0;
2008e88: c0 24 20 20 clr [ %l0 + 0x20 ]
_Chain_Initialize( &the_partition->Memory, starting_address,
length / buffer_size, buffer_size );
2008e8c: 40 00 46 6f call 201a848 <.udiv>
2008e90: 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,
2008e94: 92 10 00 19 mov %i1, %o1
length / buffer_size, buffer_size );
2008e98: 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,
2008e9c: 96 10 00 1b mov %i3, %o3
2008ea0: b8 04 20 24 add %l0, 0x24, %i4
2008ea4: 40 00 04 58 call 200a004 <_Chain_Initialize>
2008ea8: 90 10 00 1c mov %i4, %o0
Objects_Information *information,
Objects_Control *the_object,
Objects_Name name
)
{
_Objects_Set_local_object(
2008eac: c4 14 20 0a lduh [ %l0 + 0xa ], %g2
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
2008eb0: a2 14 63 e4 or %l1, 0x3e4, %l1
2008eb4: c6 04 60 1c ld [ %l1 + 0x1c ], %g3
Objects_Information *information,
Objects_Control *the_object,
Objects_Name name
)
{
_Objects_Set_local_object(
2008eb8: c2 04 20 08 ld [ %l0 + 8 ], %g1
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
2008ebc: 85 28 a0 02 sll %g2, 2, %g2
2008ec0: e0 20 c0 02 st %l0, [ %g3 + %g2 ]
information,
_Objects_Get_index( the_object->id ),
the_object
);
the_object->name = name;
2008ec4: f0 24 20 0c st %i0, [ %l0 + 0xc ]
name,
0 /* Not used */
);
#endif
_Thread_Enable_dispatch();
2008ec8: 40 00 0b f4 call 200be98 <_Thread_Enable_dispatch>
2008ecc: c2 27 40 00 st %g1, [ %i5 ]
return RTEMS_SUCCESSFUL;
2008ed0: 82 10 20 00 clr %g1
}
2008ed4: 81 c7 e0 08 ret
2008ed8: 91 e8 00 01 restore %g0, %g1, %o0
020164f4 <rtems_partition_return_buffer>:
rtems_status_code rtems_partition_return_buffer(
rtems_id id,
void *buffer
)
{
20164f4: 9d e3 bf 98 save %sp, -104, %sp
RTEMS_INLINE_ROUTINE Partition_Control *_Partition_Get (
Objects_Id id,
Objects_Locations *location
)
{
return (Partition_Control *)
20164f8: 11 00 80 f2 sethi %hi(0x203c800), %o0
20164fc: 92 10 00 18 mov %i0, %o1
2016500: 90 12 23 74 or %o0, 0x374, %o0
2016504: 40 00 14 15 call 201b558 <_Objects_Get>
2016508: 94 07 bf fc add %fp, -4, %o2
register Partition_Control *the_partition;
Objects_Locations location;
the_partition = _Partition_Get( id, &location );
switch ( location ) {
201650c: c2 07 bf fc ld [ %fp + -4 ], %g1
2016510: 80 a0 60 00 cmp %g1, 0
2016514: 12 80 00 21 bne 2016598 <rtems_partition_return_buffer+0xa4>
2016518: ba 10 00 08 mov %o0, %i5
)
{
void *starting;
void *ending;
starting = the_partition->starting_address;
201651c: d0 02 20 10 ld [ %o0 + 0x10 ], %o0
2016520: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
2016524: 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 ) &&
2016528: 80 a6 40 01 cmp %i1, %g1
201652c: 18 80 00 0b bgu 2016558 <rtems_partition_return_buffer+0x64><== NEVER TAKEN
2016530: 82 10 20 00 clr %g1
2016534: 80 a6 40 08 cmp %i1, %o0
2016538: 0a 80 00 09 bcs 201655c <rtems_partition_return_buffer+0x68>
201653c: 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);
2016540: d2 07 60 18 ld [ %i5 + 0x18 ], %o1
2016544: 40 00 58 56 call 202c69c <.urem>
2016548: 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 ) &&
201654c: 80 a0 00 08 cmp %g0, %o0
2016550: 10 80 00 02 b 2016558 <rtems_partition_return_buffer+0x64>
2016554: 82 60 3f ff subx %g0, -1, %g1
case OBJECTS_LOCAL:
if ( _Partition_Is_buffer_valid( buffer, the_partition ) ) {
2016558: 80 a0 60 00 cmp %g1, 0
201655c: 02 80 00 0b be 2016588 <rtems_partition_return_buffer+0x94>
2016560: 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 );
2016564: 40 00 0c 7c call 2019754 <_Chain_Append>
2016568: 92 10 00 19 mov %i1, %o1
_Partition_Free_buffer( the_partition, buffer );
the_partition->number_of_used_blocks -= 1;
201656c: c2 07 60 20 ld [ %i5 + 0x20 ], %g1
_Thread_Enable_dispatch();
return RTEMS_SUCCESSFUL;
2016570: 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;
2016574: 82 00 7f ff add %g1, -1, %g1
_Thread_Enable_dispatch();
2016578: 40 00 17 ce call 201c4b0 <_Thread_Enable_dispatch>
201657c: c2 27 60 20 st %g1, [ %i5 + 0x20 ]
2016580: 81 c7 e0 08 ret
2016584: 81 e8 00 00 restore
return RTEMS_SUCCESSFUL;
}
_Thread_Enable_dispatch();
2016588: 40 00 17 ca call 201c4b0 <_Thread_Enable_dispatch>
201658c: b0 10 20 09 mov 9, %i0
2016590: 81 c7 e0 08 ret
2016594: 81 e8 00 00 restore
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
2016598: 81 c7 e0 08 ret
201659c: 91 e8 20 04 restore %g0, 4, %o0
02032ed8 <rtems_rate_monotonic_period>:
rtems_status_code rtems_rate_monotonic_period(
rtems_id id,
rtems_interval length
)
{
2032ed8: 9d e3 bf 98 save %sp, -104, %sp
2032edc: 11 00 81 8a sethi %hi(0x2062800), %o0
2032ee0: 92 10 00 18 mov %i0, %o1
2032ee4: 90 12 22 50 or %o0, 0x250, %o0
2032ee8: 7f ff 58 2e call 2008fa0 <_Objects_Get>
2032eec: 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 ) {
2032ef0: c2 07 bf fc ld [ %fp + -4 ], %g1
2032ef4: 80 a0 60 00 cmp %g1, 0
2032ef8: 12 80 00 6a bne 20330a0 <rtems_rate_monotonic_period+0x1c8>
2032efc: ba 10 00 08 mov %o0, %i5
RTEMS_INLINE_ROUTINE bool _Thread_Is_executing (
const Thread_Control *the_thread
)
{
return ( the_thread == _Thread_Executing );
2032f00: 37 00 81 89 sethi %hi(0x2062400), %i3
case OBJECTS_LOCAL:
if ( !_Thread_Is_executing( the_period->owner ) ) {
2032f04: c4 02 20 40 ld [ %o0 + 0x40 ], %g2
2032f08: b6 16 e0 90 or %i3, 0x90, %i3
2032f0c: c2 06 e0 0c ld [ %i3 + 0xc ], %g1
2032f10: 80 a0 80 01 cmp %g2, %g1
2032f14: 02 80 00 06 be 2032f2c <rtems_rate_monotonic_period+0x54>
2032f18: 80 a6 60 00 cmp %i1, 0
_Thread_Enable_dispatch();
2032f1c: 7f ff 5b cd call 2009e50 <_Thread_Enable_dispatch>
2032f20: b0 10 20 17 mov 0x17, %i0
2032f24: 81 c7 e0 08 ret
2032f28: 81 e8 00 00 restore
return RTEMS_NOT_OWNER_OF_RESOURCE;
}
if ( length == RTEMS_PERIOD_STATUS ) {
2032f2c: 12 80 00 0d bne 2032f60 <rtems_rate_monotonic_period+0x88>
2032f30: 01 00 00 00 nop
switch ( the_period->state ) {
2032f34: c2 02 20 38 ld [ %o0 + 0x38 ], %g1
2032f38: 80 a0 60 04 cmp %g1, 4
2032f3c: 18 80 00 05 bgu 2032f50 <rtems_rate_monotonic_period+0x78><== NEVER TAKEN
2032f40: b0 10 20 00 clr %i0
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
2032f44: 05 00 81 6e sethi %hi(0x205b800), %g2
2032f48: 84 10 a3 58 or %g2, 0x358, %g2 ! 205bb58 <CSWTCH.23>
2032f4c: 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();
2032f50: 7f ff 5b c0 call 2009e50 <_Thread_Enable_dispatch>
2032f54: 01 00 00 00 nop
2032f58: 81 c7 e0 08 ret
2032f5c: 81 e8 00 00 restore
return( return_value );
}
_ISR_Disable( level );
2032f60: 7f ff 3d 3c call 2002450 <sparc_disable_interrupts>
2032f64: 01 00 00 00 nop
2032f68: b4 10 00 08 mov %o0, %i2
if ( the_period->state == RATE_MONOTONIC_INACTIVE ) {
2032f6c: f8 07 60 38 ld [ %i5 + 0x38 ], %i4
2032f70: 80 a7 20 00 cmp %i4, 0
2032f74: 12 80 00 15 bne 2032fc8 <rtems_rate_monotonic_period+0xf0>
2032f78: 80 a7 20 02 cmp %i4, 2
_ISR_Enable( level );
2032f7c: 7f ff 3d 39 call 2002460 <sparc_enable_interrupts>
2032f80: 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 );
2032f84: 90 10 00 1d mov %i5, %o0
2032f88: 7f ff ff ba call 2032e70 <_Rate_monotonic_Initiate_statistics>
2032f8c: f2 27 60 3c st %i1, [ %i5 + 0x3c ]
the_period->state = RATE_MONOTONIC_ACTIVE;
2032f90: 82 10 20 02 mov 2, %g1
2032f94: c2 27 60 38 st %g1, [ %i5 + 0x38 ]
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
the_watchdog->routine = routine;
2032f98: 03 00 80 cc sethi %hi(0x2033000), %g1
2032f9c: 82 10 60 ac or %g1, 0xac, %g1 ! 20330ac <_Rate_monotonic_Timeout>
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
2032fa0: c0 27 60 18 clr [ %i5 + 0x18 ]
the_watchdog->routine = routine;
2032fa4: c2 27 60 2c st %g1, [ %i5 + 0x2c ]
the_watchdog->id = id;
2032fa8: f0 27 60 30 st %i0, [ %i5 + 0x30 ]
the_watchdog->user_data = user_data;
2032fac: c0 27 60 34 clr [ %i5 + 0x34 ]
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
2032fb0: f2 27 60 1c st %i1, [ %i5 + 0x1c ]
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
2032fb4: 11 00 81 88 sethi %hi(0x2062000), %o0
2032fb8: 92 07 60 10 add %i5, 0x10, %o1
2032fbc: 7f ff 5e f0 call 200ab7c <_Watchdog_Insert>
2032fc0: 90 12 20 08 or %o0, 8, %o0
2032fc4: 30 80 00 1b b,a 2033030 <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 ) {
2032fc8: 12 80 00 1e bne 2033040 <rtems_rate_monotonic_period+0x168>
2032fcc: 80 a7 20 04 cmp %i4, 4
/*
* Update statistics from the concluding period.
*/
_Rate_monotonic_Update_statistics( the_period );
2032fd0: 7f ff ff 5f call 2032d4c <_Rate_monotonic_Update_statistics>
2032fd4: 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;
2032fd8: 82 10 20 01 mov 1, %g1
the_period->next_length = length;
2032fdc: 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;
2032fe0: c2 27 60 38 st %g1, [ %i5 + 0x38 ]
the_period->next_length = length;
_ISR_Enable( level );
2032fe4: 7f ff 3d 1f call 2002460 <sparc_enable_interrupts>
2032fe8: 90 10 00 1a mov %i2, %o0
_Thread_Executing->Wait.id = the_period->Object.id;
2032fec: d0 06 e0 0c ld [ %i3 + 0xc ], %o0
2032ff0: c2 07 60 08 ld [ %i5 + 8 ], %g1
_Thread_Set_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD );
2032ff4: 13 00 00 10 sethi %hi(0x4000), %o1
2032ff8: 7f ff 5d cd call 200a72c <_Thread_Set_state>
2032ffc: c2 22 20 20 st %g1, [ %o0 + 0x20 ]
/*
* Did the watchdog timer expire while we were actually blocking
* on it?
*/
_ISR_Disable( level );
2033000: 7f ff 3d 14 call 2002450 <sparc_disable_interrupts>
2033004: 01 00 00 00 nop
local_state = the_period->state;
2033008: f4 07 60 38 ld [ %i5 + 0x38 ], %i2
the_period->state = RATE_MONOTONIC_ACTIVE;
203300c: f8 27 60 38 st %i4, [ %i5 + 0x38 ]
_ISR_Enable( level );
2033010: 7f ff 3d 14 call 2002460 <sparc_enable_interrupts>
2033014: 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 )
2033018: 80 a6 a0 03 cmp %i2, 3
203301c: 12 80 00 05 bne 2033030 <rtems_rate_monotonic_period+0x158>
2033020: 01 00 00 00 nop
_Thread_Clear_state( _Thread_Executing, STATES_WAITING_FOR_PERIOD );
2033024: d0 06 e0 0c ld [ %i3 + 0xc ], %o0
2033028: 7f ff 5a aa call 2009ad0 <_Thread_Clear_state>
203302c: 13 00 00 10 sethi %hi(0x4000), %o1
_Thread_Enable_dispatch();
2033030: 7f ff 5b 88 call 2009e50 <_Thread_Enable_dispatch>
2033034: b0 10 20 00 clr %i0
2033038: 81 c7 e0 08 ret
203303c: 81 e8 00 00 restore
return RTEMS_SUCCESSFUL;
}
if ( the_period->state == RATE_MONOTONIC_EXPIRED ) {
2033040: 12 bf ff b9 bne 2032f24 <rtems_rate_monotonic_period+0x4c><== NEVER TAKEN
2033044: b0 10 20 04 mov 4, %i0
/*
* Update statistics from the concluding period
*/
_Rate_monotonic_Update_statistics( the_period );
2033048: 7f ff ff 41 call 2032d4c <_Rate_monotonic_Update_statistics>
203304c: 90 10 00 1d mov %i5, %o0
_ISR_Enable( level );
2033050: 7f ff 3d 04 call 2002460 <sparc_enable_interrupts>
2033054: 90 10 00 1a mov %i2, %o0
the_period->state = RATE_MONOTONIC_ACTIVE;
2033058: 82 10 20 02 mov 2, %g1
203305c: 92 07 60 10 add %i5, 0x10, %o1
2033060: c2 27 60 38 st %g1, [ %i5 + 0x38 ]
the_period->next_length = length;
2033064: f2 27 60 3c st %i1, [ %i5 + 0x3c ]
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
2033068: f2 27 60 1c st %i1, [ %i5 + 0x1c ]
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
203306c: 11 00 81 88 sethi %hi(0x2062000), %o0
2033070: 7f ff 5e c3 call 200ab7c <_Watchdog_Insert>
2033074: 90 12 20 08 or %o0, 8, %o0 ! 2062008 <_Watchdog_Ticks_chain>
2033078: d0 07 60 40 ld [ %i5 + 0x40 ], %o0
203307c: d2 07 60 3c ld [ %i5 + 0x3c ], %o1
2033080: 03 00 81 76 sethi %hi(0x205d800), %g1
2033084: c2 00 63 30 ld [ %g1 + 0x330 ], %g1 ! 205db30 <_Scheduler+0x34>
2033088: 9f c0 40 00 call %g1
203308c: 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();
2033090: 7f ff 5b 70 call 2009e50 <_Thread_Enable_dispatch>
2033094: 01 00 00 00 nop
2033098: 81 c7 e0 08 ret
203309c: 81 e8 00 00 restore
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
20330a0: b0 10 20 04 mov 4, %i0
}
20330a4: 81 c7 e0 08 ret
20330a8: 81 e8 00 00 restore
020260b4 <rtems_rate_monotonic_report_statistics_with_plugin>:
*/
void rtems_rate_monotonic_report_statistics_with_plugin(
void *context,
rtems_printk_plugin_t print
)
{
20260b4: 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 )
20260b8: 80 a6 60 00 cmp %i1, 0
20260bc: 02 80 00 75 be 2026290 <rtems_rate_monotonic_report_statistics_with_plugin+0x1dc><== NEVER TAKEN
20260c0: 90 10 00 18 mov %i0, %o0
return;
(*print)( context, "Period information by period\n" );
20260c4: 13 00 81 63 sethi %hi(0x2058c00), %o1
20260c8: 9f c6 40 00 call %i1
20260cc: 92 12 61 b0 or %o1, 0x1b0, %o1 ! 2058db0 <_TOD_Days_per_month+0x68>
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
(*print)( context, "--- CPU times are in seconds ---\n" );
20260d0: 90 10 00 18 mov %i0, %o0
20260d4: 13 00 81 63 sethi %hi(0x2058c00), %o1
20260d8: 9f c6 40 00 call %i1
20260dc: 92 12 61 d0 or %o1, 0x1d0, %o1 ! 2058dd0 <_TOD_Days_per_month+0x88>
(*print)( context, "--- Wall times are in seconds ---\n" );
20260e0: 90 10 00 18 mov %i0, %o0
20260e4: 13 00 81 63 sethi %hi(0x2058c00), %o1
20260e8: 9f c6 40 00 call %i1
20260ec: 92 12 61 f8 or %o1, 0x1f8, %o1 ! 2058df8 <_TOD_Days_per_month+0xb0>
Be sure to test the various cases.
(*print)( context,"\
1234567890123456789012345678901234567890123456789012345678901234567890123456789\
\n");
*/
(*print)( context, " ID OWNER COUNT MISSED "
20260f0: 90 10 00 18 mov %i0, %o0
20260f4: 13 00 81 63 sethi %hi(0x2058c00), %o1
20260f8: 9f c6 40 00 call %i1
20260fc: 92 12 62 20 or %o1, 0x220, %o1 ! 2058e20 <_TOD_Days_per_month+0xd8>
#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
" "
#endif
" WALL TIME\n"
);
(*print)( context, " "
2026100: 90 10 00 18 mov %i0, %o0
2026104: 13 00 81 63 sethi %hi(0x2058c00), %o1
2026108: 9f c6 40 00 call %i1
202610c: 92 12 62 70 or %o1, 0x270, %o1 ! 2058e70 <_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 ;
2026110: 03 00 81 8a sethi %hi(0x2062800), %g1
rtems_object_get_name( the_status.owner, sizeof(name), name );
/*
* Print part of report line that is not dependent on granularity
*/
(*print)( context,
2026114: 39 00 81 63 sethi %hi(0x2058c00), %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,
2026118: 37 00 81 63 sethi %hi(0x2058c00), %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,
202611c: 35 00 81 63 sethi %hi(0x2058c00), %i2
/*
* If the count is zero, don't print statistics
*/
if (the_stats.count == 0) {
(*print)( context, "\n" );
2026120: 21 00 81 68 sethi %hi(0x205a000), %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 ;
2026124: fa 00 62 58 ld [ %g1 + 0x258 ], %i5
rtems_object_get_name( the_status.owner, sizeof(name), name );
/*
* Print part of report line that is not dependent on granularity
*/
(*print)( context,
2026128: b8 17 22 c0 or %i4, 0x2c0, %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,
202612c: b6 16 e2 d8 or %i3, 0x2d8, %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,
2026130: b4 16 a2 f8 or %i2, 0x2f8, %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 ;
2026134: 10 80 00 52 b 202627c <rtems_rate_monotonic_report_statistics_with_plugin+0x1c8>
2026138: a0 14 23 80 or %l0, 0x380, %l0
id <= _Rate_monotonic_Information.maximum_id ;
id++ ) {
status = rtems_rate_monotonic_get_statistics( id, &the_stats );
202613c: 40 00 32 28 call 20329dc <rtems_rate_monotonic_get_statistics>
2026140: 92 07 bf c8 add %fp, -56, %o1
if ( status != RTEMS_SUCCESSFUL )
2026144: 80 a2 20 00 cmp %o0, 0
2026148: 32 80 00 4d bne,a 202627c <rtems_rate_monotonic_report_statistics_with_plugin+0x1c8>
202614c: 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 );
2026150: 92 07 bf b0 add %fp, -80, %o1
2026154: 40 00 32 93 call 2032ba0 <rtems_rate_monotonic_get_status>
2026158: 90 10 00 1d mov %i5, %o0
#endif
rtems_object_get_name( the_status.owner, sizeof(name), name );
202615c: d0 07 bf b0 ld [ %fp + -80 ], %o0
2026160: 92 10 20 05 mov 5, %o1
2026164: 7f ff a3 a5 call 200eff8 <rtems_object_get_name>
2026168: 94 07 bf a0 add %fp, -96, %o2
/*
* Print part of report line that is not dependent on granularity
*/
(*print)( context,
202616c: d8 1f bf c8 ldd [ %fp + -56 ], %o4
2026170: 92 10 00 1c mov %i4, %o1
2026174: 90 10 00 18 mov %i0, %o0
2026178: 94 10 00 1d mov %i5, %o2
202617c: 9f c6 40 00 call %i1
2026180: 96 07 bf a0 add %fp, -96, %o3
);
/*
* If the count is zero, don't print statistics
*/
if (the_stats.count == 0) {
2026184: d2 07 bf c8 ld [ %fp + -56 ], %o1
2026188: 80 a2 60 00 cmp %o1, 0
202618c: 12 80 00 07 bne 20261a8 <rtems_rate_monotonic_report_statistics_with_plugin+0xf4>
2026190: 94 07 bf a8 add %fp, -88, %o2
(*print)( context, "\n" );
2026194: 90 10 00 18 mov %i0, %o0
2026198: 9f c6 40 00 call %i1
202619c: 92 10 00 10 mov %l0, %o1
continue;
20261a0: 10 80 00 37 b 202627c <rtems_rate_monotonic_report_statistics_with_plugin+0x1c8>
20261a4: 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 );
20261a8: 40 00 02 ef call 2026d64 <_Timespec_Divide_by_integer>
20261ac: 90 07 bf e0 add %fp, -32, %o0
(*print)( context,
20261b0: d0 07 bf d4 ld [ %fp + -44 ], %o0
20261b4: 40 00 a6 93 call 204fc00 <.div>
20261b8: 92 10 23 e8 mov 0x3e8, %o1
20261bc: a6 10 00 08 mov %o0, %l3
20261c0: d0 07 bf dc ld [ %fp + -36 ], %o0
20261c4: 40 00 a6 8f call 204fc00 <.div>
20261c8: 92 10 23 e8 mov 0x3e8, %o1
20261cc: c2 07 bf a8 ld [ %fp + -88 ], %g1
20261d0: a2 10 00 08 mov %o0, %l1
20261d4: d0 07 bf ac ld [ %fp + -84 ], %o0
20261d8: e8 07 bf d0 ld [ %fp + -48 ], %l4
20261dc: e4 07 bf d8 ld [ %fp + -40 ], %l2
20261e0: c2 23 a0 5c st %g1, [ %sp + 0x5c ]
20261e4: 40 00 a6 87 call 204fc00 <.div>
20261e8: 92 10 23 e8 mov 0x3e8, %o1
20261ec: 96 10 00 13 mov %l3, %o3
20261f0: 98 10 00 12 mov %l2, %o4
20261f4: 9a 10 00 11 mov %l1, %o5
20261f8: 94 10 00 14 mov %l4, %o2
20261fc: d0 23 a0 60 st %o0, [ %sp + 0x60 ]
2026200: 92 10 00 1b mov %i3, %o1
2026204: 9f c6 40 00 call %i1
2026208: 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);
202620c: d2 07 bf c8 ld [ %fp + -56 ], %o1
2026210: 94 07 bf a8 add %fp, -88, %o2
2026214: 40 00 02 d4 call 2026d64 <_Timespec_Divide_by_integer>
2026218: 90 07 bf f8 add %fp, -8, %o0
(*print)( context,
202621c: d0 07 bf ec ld [ %fp + -20 ], %o0
2026220: 40 00 a6 78 call 204fc00 <.div>
2026224: 92 10 23 e8 mov 0x3e8, %o1
2026228: a6 10 00 08 mov %o0, %l3
202622c: d0 07 bf f4 ld [ %fp + -12 ], %o0
2026230: 40 00 a6 74 call 204fc00 <.div>
2026234: 92 10 23 e8 mov 0x3e8, %o1
2026238: c2 07 bf a8 ld [ %fp + -88 ], %g1
202623c: a2 10 00 08 mov %o0, %l1
2026240: d0 07 bf ac ld [ %fp + -84 ], %o0
2026244: e8 07 bf e8 ld [ %fp + -24 ], %l4
2026248: e4 07 bf f0 ld [ %fp + -16 ], %l2
202624c: 92 10 23 e8 mov 0x3e8, %o1
2026250: 40 00 a6 6c call 204fc00 <.div>
2026254: c2 23 a0 5c st %g1, [ %sp + 0x5c ]
2026258: 92 10 00 1a mov %i2, %o1
202625c: d0 23 a0 60 st %o0, [ %sp + 0x60 ]
2026260: 94 10 00 14 mov %l4, %o2
2026264: 90 10 00 18 mov %i0, %o0
2026268: 96 10 00 13 mov %l3, %o3
202626c: 98 10 00 12 mov %l2, %o4
2026270: 9f c6 40 00 call %i1
2026274: 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++ ) {
2026278: 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 ;
202627c: 03 00 81 8a sethi %hi(0x2062800), %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 ;
2026280: c2 00 62 5c ld [ %g1 + 0x25c ], %g1 ! 2062a5c <_Rate_monotonic_Information+0xc>
2026284: 80 a7 40 01 cmp %i5, %g1
2026288: 08 bf ff ad bleu 202613c <rtems_rate_monotonic_report_statistics_with_plugin+0x88>
202628c: 90 10 00 1d mov %i5, %o0
2026290: 81 c7 e0 08 ret
2026294: 81 e8 00 00 restore
02008a88 <rtems_rbheap_allocate>:
return big_enough;
}
void *rtems_rbheap_allocate(rtems_rbheap_control *control, size_t size)
{
2008a88: 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;
2008a8c: 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;
2008a90: 90 10 00 19 mov %i1, %o0
2008a94: 92 10 00 1d mov %i5, %o1
2008a98: 40 00 44 f1 call 2019e5c <.urem>
2008a9c: b6 10 00 19 mov %i1, %i3
if (excess > 0) {
2008aa0: 80 a2 20 00 cmp %o0, 0
2008aa4: 02 80 00 05 be 2008ab8 <rtems_rbheap_allocate+0x30> <== ALWAYS TAKEN
2008aa8: 80 a6 c0 19 cmp %i3, %i1
value += alignment - excess;
2008aac: b6 06 40 1d add %i1, %i5, %i3 <== NOT EXECUTED
2008ab0: 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) {
2008ab4: 80 a6 c0 19 cmp %i3, %i1 <== NOT EXECUTED
2008ab8: 0a 80 00 04 bcs 2008ac8 <rtems_rbheap_allocate+0x40> <== NEVER TAKEN
2008abc: 80 a6 60 00 cmp %i1, 0
2008ac0: 32 80 00 04 bne,a 2008ad0 <rtems_rbheap_allocate+0x48>
2008ac4: c2 06 00 00 ld [ %i0 ], %g1
return big_enough;
}
void *rtems_rbheap_allocate(rtems_rbheap_control *control, size_t size)
{
void *ptr = NULL;
2008ac8: 81 c7 e0 08 ret
2008acc: 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);
2008ad0: 84 06 20 04 add %i0, 4, %g2
rtems_rbheap_chunk *big_enough = NULL;
2008ad4: 10 80 00 06 b 2008aec <rtems_rbheap_allocate+0x64>
2008ad8: 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) {
2008adc: 80 a0 c0 1b cmp %g3, %i3
2008ae0: ba 40 3f ff addx %g0, -1, %i5
2008ae4: ba 08 40 1d and %g1, %i5, %i5
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Next(
Chain_Node *the_node
)
{
return the_node->next;
2008ae8: 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) {
2008aec: 80 a7 60 00 cmp %i5, 0
2008af0: 12 80 00 04 bne 2008b00 <rtems_rbheap_allocate+0x78>
2008af4: 80 a0 40 02 cmp %g1, %g2
2008af8: 32 bf ff f9 bne,a 2008adc <rtems_rbheap_allocate+0x54>
2008afc: 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) {
2008b00: 80 a7 60 00 cmp %i5, 0
2008b04: 02 bf ff f1 be 2008ac8 <rtems_rbheap_allocate+0x40>
2008b08: 01 00 00 00 nop
uintptr_t free_size = free_chunk->size;
2008b0c: f4 07 60 1c ld [ %i5 + 0x1c ], %i2
if (free_size > aligned_size) {
2008b10: 80 a6 80 1b cmp %i2, %i3
2008b14: 28 80 00 14 bleu,a 2008b64 <rtems_rbheap_allocate+0xdc>
2008b18: c4 07 40 00 ld [ %i5 ], %g2
rtems_rbheap_chunk *new_chunk = get_chunk(control);
2008b1c: 7f ff ff 80 call 200891c <get_chunk>
2008b20: 90 10 00 18 mov %i0, %o0
if (new_chunk != NULL) {
2008b24: b8 92 20 00 orcc %o0, 0, %i4
2008b28: 02 bf ff e8 be 2008ac8 <rtems_rbheap_allocate+0x40> <== NEVER TAKEN
2008b2c: 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;
2008b30: 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;
2008b34: f4 27 60 1c st %i2, [ %i5 + 0x1c ]
new_chunk->begin = free_chunk->begin + new_free_size;
new_chunk->size = aligned_size;
2008b38: 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;
2008b3c: b4 06 80 01 add %i2, %g1, %i2
*/
RTEMS_INLINE_ROUTINE void _Chain_Set_off_chain(
Chain_Node *node
)
{
node->next = node->previous = NULL;
2008b40: c0 27 20 04 clr [ %i4 + 4 ]
2008b44: f4 27 20 18 st %i2, [ %i4 + 0x18 ]
2008b48: 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);
2008b4c: 90 06 20 18 add %i0, 0x18, %o0
2008b50: 40 00 06 a9 call 200a5f4 <_RBTree_Insert_unprotected>
2008b54: 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;
2008b58: f0 07 20 18 ld [ %i4 + 0x18 ], %i0
2008b5c: 81 c7 e0 08 ret
2008b60: 81 e8 00 00 restore
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
previous = the_node->previous;
2008b64: 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;
2008b68: f0 07 60 18 ld [ %i5 + 0x18 ], %i0
next->previous = previous;
2008b6c: c2 20 a0 04 st %g1, [ %g2 + 4 ]
previous->next = next;
2008b70: c4 20 40 00 st %g2, [ %g1 ]
*/
RTEMS_INLINE_ROUTINE void _Chain_Set_off_chain(
Chain_Node *node
)
{
node->next = node->previous = NULL;
2008b74: c0 27 60 04 clr [ %i5 + 4 ]
2008b78: c0 27 40 00 clr [ %i5 ]
}
}
}
return ptr;
}
2008b7c: 81 c7 e0 08 ret
2008b80: 81 e8 00 00 restore
02008cb4 <rtems_rbheap_extend_descriptors_with_malloc>:
/* Do nothing */
}
void rtems_rbheap_extend_descriptors_with_malloc(rtems_rbheap_control *control)
{
2008cb4: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED
rtems_rbheap_chunk *chunk = malloc(sizeof(*chunk));
2008cb8: 7f ff ed 84 call 20042c8 <malloc> <== NOT EXECUTED
2008cbc: 90 10 20 20 mov 0x20, %o0 <== NOT EXECUTED
if (chunk != NULL) {
2008cc0: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2008cc4: 02 80 00 07 be 2008ce0 <rtems_rbheap_extend_descriptors_with_malloc+0x2c><== NOT EXECUTED
2008cc8: 82 06 20 0c add %i0, 0xc, %g1 <== NOT EXECUTED
Chain_Node *the_node
)
{
Chain_Node *before_node;
the_node->previous = after_node;
2008ccc: c2 22 20 04 st %g1, [ %o0 + 4 ] <== NOT EXECUTED
before_node = after_node->next;
2008cd0: c2 06 20 0c ld [ %i0 + 0xc ], %g1 <== NOT EXECUTED
after_node->next = the_node;
2008cd4: d0 26 20 0c st %o0, [ %i0 + 0xc ] <== NOT EXECUTED
the_node->next = before_node;
2008cd8: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
before_node->previous = the_node;
2008cdc: d0 20 60 04 st %o0, [ %g1 + 4 ] <== NOT EXECUTED
2008ce0: 81 c7 e0 08 ret <== NOT EXECUTED
2008ce4: 81 e8 00 00 restore <== NOT EXECUTED
02008b84 <rtems_rbheap_free>:
_RBTree_Extract_unprotected(chunk_tree, &b->tree_node);
}
}
rtems_status_code rtems_rbheap_free(rtems_rbheap_control *control, void *ptr)
{
2008b84: 9d e3 bf 80 save %sp, -128, %sp
2008b88: b6 10 00 18 mov %i0, %i3
rtems_status_code sc = RTEMS_SUCCESSFUL;
if (ptr != NULL) {
2008b8c: 80 a6 60 00 cmp %i1, 0
2008b90: 02 80 00 45 be 2008ca4 <rtems_rbheap_free+0x120>
2008b94: 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 };
2008b98: 90 07 bf e0 add %fp, -32, %o0
2008b9c: 92 10 20 00 clr %o1
2008ba0: 94 10 20 20 mov 0x20, %o2
2008ba4: 40 00 22 e6 call 201173c <memset>
2008ba8: 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;
2008bac: ba 10 20 00 clr %i5
2008bb0: 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;
2008bb4: 10 80 00 12 b 2008bfc <rtems_rbheap_free+0x78>
2008bb8: 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);
2008bbc: 90 07 bf e8 add %fp, -24, %o0
2008bc0: 9f c0 40 00 call %g1
2008bc4: 92 10 00 1c mov %i4, %o1
if ( _RBTree_Is_equal( compare_result ) ) {
2008bc8: 80 a2 20 00 cmp %o0, 0
2008bcc: 12 80 00 07 bne 2008be8 <rtems_rbheap_free+0x64>
2008bd0: 83 3a 20 1f sra %o0, 0x1f, %g1
found = iter_node;
if ( the_rbtree->is_unique )
2008bd4: c2 0e a0 14 ldub [ %i2 + 0x14 ], %g1
2008bd8: 80 a0 60 00 cmp %g1, 0
2008bdc: 12 80 00 0c bne 2008c0c <rtems_rbheap_free+0x88> <== ALWAYS TAKEN
2008be0: ba 10 00 1c mov %i4, %i5
RTEMS_INLINE_ROUTINE bool _RBTree_Is_greater(
int compare_result
)
{
return compare_result > 0;
2008be4: 83 3a 20 1f sra %o0, 0x1f, %g1 <== NOT EXECUTED
2008be8: 90 20 40 08 sub %g1, %o0, %o0
2008bec: 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];
2008bf0: 91 2a 20 02 sll %o0, 2, %o0
2008bf4: b8 07 00 08 add %i4, %o0, %i4
2008bf8: 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) {
2008bfc: 80 a7 20 00 cmp %i4, 0
2008c00: 32 bf ff ef bne,a 2008bbc <rtems_rbheap_free+0x38>
2008c04: c2 06 a0 10 ld [ %i2 + 0x10 ], %g1
2008c08: b8 10 00 1d mov %i5, %i4
return rtems_rbheap_chunk_of_node(
2008c0c: 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) {
2008c10: 80 a7 7f f8 cmp %i5, -8
2008c14: 02 80 00 24 be 2008ca4 <rtems_rbheap_free+0x120>
2008c18: 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);
2008c1c: c4 07 3f f8 ld [ %i4 + -8 ], %g2
2008c20: 80 a0 a0 00 cmp %g2, 0
2008c24: 12 80 00 05 bne 2008c38 <rtems_rbheap_free+0xb4>
2008c28: 82 10 20 00 clr %g1
2008c2c: c2 07 60 04 ld [ %i5 + 4 ], %g1
2008c30: 80 a0 00 01 cmp %g0, %g1
2008c34: 82 60 3f ff subx %g0, -1, %g1
if (!rtems_rbheap_is_chunk_free(chunk)) {
2008c38: 80 a0 60 00 cmp %g1, 0
2008c3c: 02 80 00 1a be 2008ca4 <rtems_rbheap_free+0x120>
2008c40: 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(
2008c44: b8 07 60 08 add %i5, 8, %i4
2008c48: 92 10 20 00 clr %o1
2008c4c: 40 00 07 0f call 200a888 <_RBTree_Next_unprotected>
2008c50: 90 10 00 1c mov %i4, %o0
2008c54: 92 10 20 01 mov 1, %o1
2008c58: b2 10 00 08 mov %o0, %i1
2008c5c: 40 00 07 0b call 200a888 <_RBTree_Next_unprotected>
2008c60: 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);
2008c64: 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(
2008c68: 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);
2008c6c: 94 10 00 1d mov %i5, %o2
2008c70: 7f ff ff 02 call 2008878 <check_and_merge>
2008c74: 90 10 00 1b mov %i3, %o0
)
{
Chain_Node *before_node;
the_node->previous = after_node;
before_node = after_node->next;
2008c78: c2 06 c0 00 ld [ %i3 ], %g1
Chain_Node *the_node
)
{
Chain_Node *before_node;
the_node->previous = after_node;
2008c7c: f6 27 60 04 st %i3, [ %i5 + 4 ]
before_node = after_node->next;
after_node->next = the_node;
2008c80: fa 26 c0 00 st %i5, [ %i3 ]
the_node->next = before_node;
2008c84: c2 27 40 00 st %g1, [ %i5 ]
before_node->previous = the_node;
2008c88: fa 20 60 04 st %i5, [ %g1 + 4 ]
add_to_chain(free_chain, chunk);
check_and_merge(free_chain, chunk_tree, chunk, pred);
2008c8c: 90 10 00 1b mov %i3, %o0
2008c90: 92 10 00 1a mov %i2, %o1
2008c94: 94 10 00 1d mov %i5, %o2
2008c98: 96 06 7f f8 add %i1, -8, %o3
2008c9c: 7f ff fe f7 call 2008878 <check_and_merge>
2008ca0: b0 10 20 00 clr %i0
sc = RTEMS_INVALID_ID;
}
}
return sc;
}
2008ca4: 81 c7 e0 08 ret
2008ca8: 81 e8 00 00 restore
0201a0b8 <rtems_rfs_bitmap_create_search>:
int
rtems_rfs_bitmap_create_search (rtems_rfs_bitmap_control* control)
{
201a0b8: 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);
201a0bc: 90 10 00 18 mov %i0, %o0
return 0;
}
int
rtems_rfs_bitmap_create_search (rtems_rfs_bitmap_control* control)
{
201a0c0: 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);
201a0c4: 7f ff fe 49 call 20199e8 <rtems_rfs_bitmap_load_map>
201a0c8: 92 07 bf fc add %fp, -4, %o1
if (rc > 0)
201a0cc: b0 92 20 00 orcc %o0, 0, %i0
201a0d0: 14 80 00 32 bg 201a198 <rtems_rfs_bitmap_create_search+0xe0><== NEVER TAKEN
201a0d4: 82 10 3f ff mov -1, %g1
return rc;
control->free = 0;
search_map = control->search_bits;
201a0d8: f6 07 20 14 ld [ %i4 + 0x14 ], %i3
rc = rtems_rfs_bitmap_load_map (control, &map);
if (rc > 0)
return rc;
control->free = 0;
201a0dc: c0 27 20 10 clr [ %i4 + 0x10 ]
search_map = control->search_bits;
size = control->size;
201a0e0: fa 07 20 0c ld [ %i4 + 0xc ], %i5
201a0e4: f2 07 bf fc ld [ %fp + -4 ], %i1
bit = 0;
*search_map = RTEMS_RFS_BITMAP_ELEMENT_CLEAR;
201a0e8: c2 26 c0 00 st %g1, [ %i3 ]
return rc;
control->free = 0;
search_map = control->search_bits;
size = control->size;
bit = 0;
201a0ec: b4 10 20 00 clr %i2
*search_map = RTEMS_RFS_BITMAP_ELEMENT_CLEAR;
while (size)
201a0f0: 10 80 00 26 b 201a188 <rtems_rfs_bitmap_create_search+0xd0>
201a0f4: b0 10 20 01 mov 1, %i0
{
rtems_rfs_bitmap_element bits;
int available;
if (size < rtems_rfs_bitmap_element_bits ())
201a0f8: 38 80 00 09 bgu,a 201a11c <rtems_rfs_bitmap_create_search+0x64>
201a0fc: d0 06 40 00 ld [ %i1 ], %o0
{
bits = rtems_rfs_bitmap_merge (*map,
201a100: 90 10 20 00 clr %o0
201a104: 7f ff fe f2 call 2019ccc <rtems_rfs_bitmap_mask_section>
201a108: 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;
201a10c: 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;
201a110: 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;
201a114: 10 80 00 03 b 201a120 <rtems_rfs_bitmap_create_search+0x68>
201a118: 90 0a 00 01 and %o0, %g1, %o0
available = size;
}
else
{
bits = *map;
available = rtems_rfs_bitmap_element_bits ();
201a11c: 84 10 20 20 mov 0x20, %g2
}
if (rtems_rfs_bitmap_match (bits, RTEMS_RFS_BITMAP_ELEMENT_SET))
201a120: 80 a2 20 00 cmp %o0, 0
201a124: 12 80 00 07 bne 201a140 <rtems_rfs_bitmap_create_search+0x88>
201a128: 82 10 20 00 clr %g1
control->free++;
}
size -= available;
if (bit == rtems_rfs_bitmap_element_bits ())
201a12c: 80 a6 a0 20 cmp %i2, 0x20
201a130: 12 80 00 14 bne 201a180 <rtems_rfs_bitmap_create_search+0xc8><== ALWAYS TAKEN
201a134: ba 27 40 02 sub %i5, %g2, %i5
{
bit = 0;
search_map++;
*search_map = RTEMS_RFS_BITMAP_ELEMENT_CLEAR;
201a138: 10 80 00 0e b 201a170 <rtems_rfs_bitmap_create_search+0xb8><== NOT EXECUTED
201a13c: 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);
201a140: 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))
201a144: 80 88 c0 08 btst %g3, %o0
201a148: 02 80 00 05 be 201a15c <rtems_rfs_bitmap_create_search+0xa4>
201a14c: 82 00 60 01 inc %g1
control->free++;
201a150: c6 07 20 10 ld [ %i4 + 0x10 ], %g3
201a154: 86 00 e0 01 inc %g3
201a158: 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++)
201a15c: 80 a0 40 02 cmp %g1, %g2
201a160: 06 bf ff f9 bl 201a144 <rtems_rfs_bitmap_create_search+0x8c>
201a164: 87 2e 00 01 sll %i0, %g1, %g3
control->free++;
}
size -= available;
if (bit == rtems_rfs_bitmap_element_bits ())
201a168: 10 bf ff f2 b 201a130 <rtems_rfs_bitmap_create_search+0x78>
201a16c: 80 a6 a0 20 cmp %i2, 0x20
{
bit = 0;
201a170: b4 10 20 00 clr %i2 <== NOT EXECUTED
search_map++;
*search_map = RTEMS_RFS_BITMAP_ELEMENT_CLEAR;
201a174: c2 26 e0 04 st %g1, [ %i3 + 4 ] <== NOT EXECUTED
size -= available;
if (bit == rtems_rfs_bitmap_element_bits ())
{
bit = 0;
search_map++;
201a178: 10 80 00 03 b 201a184 <rtems_rfs_bitmap_create_search+0xcc><== NOT EXECUTED
201a17c: b6 06 e0 04 add %i3, 4, %i3 <== NOT EXECUTED
*search_map = RTEMS_RFS_BITMAP_ELEMENT_CLEAR;
}
else
bit++;
201a180: b4 06 a0 01 inc %i2
201a184: 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)
201a188: 80 a7 60 00 cmp %i5, 0
201a18c: 12 bf ff db bne 201a0f8 <rtems_rfs_bitmap_create_search+0x40>
201a190: 80 a7 60 1f cmp %i5, 0x1f
else
bit++;
map++;
}
return 0;
201a194: b0 10 20 00 clr %i0
}
201a198: 81 c7 e0 08 ret
201a19c: 81 e8 00 00 restore
020199e8 <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)
{
20199e8: 9d e3 bf a0 save %sp, -96, %sp
int rc;
if (!control->buffer)
20199ec: 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)
{
20199f0: ba 10 00 18 mov %i0, %i5
int rc;
if (!control->buffer)
20199f4: 80 a0 60 00 cmp %g1, 0
20199f8: 02 80 00 0f be 2019a34 <rtems_rfs_bitmap_load_map+0x4c> <== NEVER TAKEN
20199fc: b0 10 20 06 mov 6, %i0
return ENXIO;
*map = NULL;
2019a00: c0 26 40 00 clr [ %i1 ]
rc = rtems_rfs_buffer_handle_request (control->fs,
2019a04: d4 07 60 08 ld [ %i5 + 8 ], %o2
2019a08: d0 07 60 04 ld [ %i5 + 4 ], %o0
2019a0c: d2 07 40 00 ld [ %i5 ], %o1
2019a10: 40 00 06 e6 call 201b5a8 <rtems_rfs_buffer_handle_request>
2019a14: 96 10 20 01 mov 1, %o3
control->buffer,
control->block,
true);
if (rc)
2019a18: b0 92 20 00 orcc %o0, 0, %i0
2019a1c: 12 80 00 06 bne 2019a34 <rtems_rfs_bitmap_load_map+0x4c> <== NEVER TAKEN
2019a20: 01 00 00 00 nop
return rc;
*map = rtems_rfs_buffer_data (control->buffer);
2019a24: c2 07 40 00 ld [ %i5 ], %g1
2019a28: c2 00 60 08 ld [ %g1 + 8 ], %g1
2019a2c: c2 00 60 1c ld [ %g1 + 0x1c ], %g1
2019a30: c2 26 40 00 st %g1, [ %i1 ]
return 0;
}
2019a34: 81 c7 e0 08 ret
2019a38: 81 e8 00 00 restore
02019fb8 <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)
{
2019fb8: 9d e3 bf a0 save %sp, -96, %sp
int rc = 0;
/*
* By default we assume the allocation failed.
*/
*allocated = false;
2019fbc: 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))
2019fc0: 10 80 00 2d b 201a074 <rtems_rfs_bitmap_map_alloc+0xbc>
2019fc4: 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)
2019fc8: 2a 80 00 07 bcs,a 2019fe4 <rtems_rfs_bitmap_map_alloc+0x2c><== NOT EXECUTED
2019fcc: fa 26 c0 00 st %i5, [ %i3 ] <== NOT EXECUTED
window, 1);
if ((rc > 0) || *allocated)
break;
}
if (lower_seed >= 0)
2019fd0: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED
2019fd4: 36 80 00 17 bge,a 201a030 <rtems_rfs_bitmap_map_alloc+0x78><== ALWAYS TAKEN
2019fd8: 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)
2019fdc: 10 80 00 10 b 201a01c <rtems_rfs_bitmap_map_alloc+0x64> <== NOT EXECUTED
2019fe0: 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,
2019fe4: 90 10 00 18 mov %i0, %o0
2019fe8: 92 10 00 1b mov %i3, %o1
2019fec: 94 10 00 1a mov %i2, %o2
2019ff0: 7f ff fe 93 call 2019a3c <rtems_rfs_search_map_for_clear_bit.constprop.1>
2019ff4: 96 10 20 01 mov 1, %o3
window, 1);
if ((rc > 0) || *allocated)
2019ff8: 80 a2 20 00 cmp %o0, 0
2019ffc: 34 80 00 2d bg,a 201a0b0 <rtems_rfs_bitmap_map_alloc+0xf8><== NEVER TAKEN
201a000: b0 10 20 00 clr %i0 <== NOT EXECUTED
201a004: c2 0e 80 00 ldub [ %i2 ], %g1
201a008: 80 a0 60 00 cmp %g1, 0
201a00c: 02 bf ff f2 be 2019fd4 <rtems_rfs_bitmap_map_alloc+0x1c>
201a010: 80 a6 60 00 cmp %i1, 0
if (lower_seed >= 0)
lower_seed -= window;
}
return 0;
}
201a014: 81 c7 e0 08 ret
201a018: 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)
201a01c: 80 a7 40 01 cmp %i5, %g1
201a020: 2a 80 00 12 bcs,a 201a068 <rtems_rfs_bitmap_map_alloc+0xb0><== ALWAYS TAKEN
201a024: ba 07 68 00 add %i5, 0x800, %i5
upper_seed += window;
if (lower_seed >= 0)
201a028: 10 80 00 11 b 201a06c <rtems_rfs_bitmap_map_alloc+0xb4> <== NOT EXECUTED
201a02c: 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,
201a030: 90 10 00 18 mov %i0, %o0
201a034: 92 10 00 1b mov %i3, %o1
201a038: 94 10 00 1a mov %i2, %o2
201a03c: 7f ff fe 80 call 2019a3c <rtems_rfs_search_map_for_clear_bit.constprop.1>
201a040: 96 10 3f ff mov -1, %o3
window, -1);
if ((rc > 0) || *allocated)
201a044: 80 a2 20 00 cmp %o0, 0
201a048: 34 80 00 1a bg,a 201a0b0 <rtems_rfs_bitmap_map_alloc+0xf8><== NEVER TAKEN
201a04c: b0 10 20 00 clr %i0 <== NOT EXECUTED
201a050: c2 0e 80 00 ldub [ %i2 ], %g1
201a054: 80 a0 60 00 cmp %g1, 0
201a058: 22 bf ff f1 be,a 201a01c <rtems_rfs_bitmap_map_alloc+0x64>
201a05c: c2 06 20 0c ld [ %i0 + 0xc ], %g1
if (lower_seed >= 0)
lower_seed -= window;
}
return 0;
}
201a060: 81 c7 e0 08 ret
201a064: 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)
201a068: 80 a6 60 00 cmp %i1, 0
201a06c: 36 80 00 02 bge,a 201a074 <rtems_rfs_bitmap_map_alloc+0xbc><== ALWAYS TAKEN
201a070: 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))
201a074: 80 a7 60 00 cmp %i5, 0
201a078: 06 80 00 07 bl 201a094 <rtems_rfs_bitmap_map_alloc+0xdc> <== NEVER TAKEN
201a07c: 80 a6 60 00 cmp %i1, 0
201a080: c2 06 20 0c ld [ %i0 + 0xc ], %g1
201a084: 80 a7 40 01 cmp %i5, %g1
201a088: 2a bf ff d7 bcs,a 2019fe4 <rtems_rfs_bitmap_map_alloc+0x2c>
201a08c: fa 26 c0 00 st %i5, [ %i3 ]
|| ((lower_seed >= 0) && (lower_seed < control->size)))
201a090: 80 a6 60 00 cmp %i1, 0
201a094: 26 80 00 07 bl,a 201a0b0 <rtems_rfs_bitmap_map_alloc+0xf8>
201a098: b0 10 20 00 clr %i0
201a09c: c2 06 20 0c ld [ %i0 + 0xc ], %g1
201a0a0: 80 a6 40 01 cmp %i1, %g1
201a0a4: 0a bf ff c9 bcs 2019fc8 <rtems_rfs_bitmap_map_alloc+0x10> <== NEVER TAKEN
201a0a8: 80 a7 40 01 cmp %i5, %g1
if (lower_seed >= 0)
lower_seed -= window;
}
return 0;
}
201a0ac: b0 10 20 00 clr %i0
201a0b0: 81 c7 e0 08 ret
201a0b4: 81 e8 00 00 restore
02019d88 <rtems_rfs_bitmap_map_clear>:
int
rtems_rfs_bitmap_map_clear (rtems_rfs_bitmap_control* control,
rtems_rfs_bitmap_bit bit)
{
2019d88: 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);
2019d8c: 90 10 00 18 mov %i0, %o0
}
int
rtems_rfs_bitmap_map_clear (rtems_rfs_bitmap_control* control,
rtems_rfs_bitmap_bit bit)
{
2019d90: 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);
2019d94: 7f ff ff 15 call 20199e8 <rtems_rfs_bitmap_load_map>
2019d98: 92 07 bf fc add %fp, -4, %o1
if (rc > 0)
2019d9c: b0 92 20 00 orcc %o0, 0, %i0
2019da0: 14 80 00 1b bg 2019e0c <rtems_rfs_bitmap_map_clear+0x84> <== NEVER TAKEN
2019da4: 01 00 00 00 nop
return rc;
if (bit >= control->size)
2019da8: c2 07 60 0c ld [ %i5 + 0xc ], %g1
2019dac: 80 a6 40 01 cmp %i1, %g1
2019db0: 1a 80 00 17 bcc 2019e0c <rtems_rfs_bitmap_map_clear+0x84> <== NEVER TAKEN
2019db4: 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);
2019db8: 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;
2019dbc: c4 07 60 14 ld [ %i5 + 0x14 ], %g2
index = rtems_rfs_bitmap_map_index (bit);
2019dc0: 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);
2019dc4: 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);
2019dc8: 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);
2019dcc: 82 10 20 01 mov 1, %g1
2019dd0: b7 28 40 19 sll %g1, %i1, %i3
bit = index;
index = rtems_rfs_bitmap_map_index (bit);
2019dd4: 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);
2019dd8: 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);
2019ddc: 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);
2019de0: 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);
2019de4: 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);
2019de8: 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);
2019dec: 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);
2019df0: c6 20 80 19 st %g3, [ %g2 + %i1 ]
rtems_rfs_buffer_mark_dirty (control->buffer);
2019df4: c4 07 40 00 ld [ %i5 ], %g2
control->free++;
return 0;
2019df8: 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);
2019dfc: c2 28 80 00 stb %g1, [ %g2 ]
control->free++;
2019e00: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
2019e04: 82 00 60 01 inc %g1
2019e08: c2 27 60 10 st %g1, [ %i5 + 0x10 ]
return 0;
}
2019e0c: 81 c7 e0 08 ret
2019e10: 81 e8 00 00 restore
02019f04 <rtems_rfs_bitmap_map_clear_all>:
int
rtems_rfs_bitmap_map_clear_all (rtems_rfs_bitmap_control* control)
{
2019f04: 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);
2019f08: 90 10 00 18 mov %i0, %o0
return 0;
}
int
rtems_rfs_bitmap_map_clear_all (rtems_rfs_bitmap_control* control)
{
2019f0c: 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);
2019f10: 7f ff fe b6 call 20199e8 <rtems_rfs_bitmap_load_map>
2019f14: 92 07 bf fc add %fp, -4, %o1
if (rc > 0)
2019f18: b0 92 20 00 orcc %o0, 0, %i0
2019f1c: 14 80 00 25 bg 2019fb0 <rtems_rfs_bitmap_map_clear_all+0xac><== NEVER TAKEN
2019f20: c6 07 bf fc ld [ %fp + -4 ], %g3
return rc;
elements = rtems_rfs_bitmap_elements (control->size);
2019f24: c8 07 60 0c ld [ %i5 + 0xc ], %g4
2019f28: 88 01 3f ff add %g4, -1, %g4
control->free = elements;
for (e = 0; e < elements; e++)
2019f2c: 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);
2019f30: 89 31 20 05 srl %g4, 5, %g4
2019f34: 82 01 20 01 add %g4, 1, %g1
control->free = elements;
for (e = 0; e < elements; e++)
2019f38: 10 80 00 05 b 2019f4c <rtems_rfs_bitmap_map_clear_all+0x48>
2019f3c: c2 27 60 10 st %g1, [ %i5 + 0x10 ]
map[e] = RTEMS_RFS_BITMAP_ELEMENT_CLEAR;
2019f40: b6 10 3f ff mov -1, %i3
elements = rtems_rfs_bitmap_elements (control->size);
control->free = elements;
for (e = 0; e < elements; e++)
2019f44: 84 00 a0 01 inc %g2
map[e] = RTEMS_RFS_BITMAP_ELEMENT_CLEAR;
2019f48: f6 20 c0 1c st %i3, [ %g3 + %i4 ]
elements = rtems_rfs_bitmap_elements (control->size);
control->free = elements;
for (e = 0; e < elements; e++)
2019f4c: 80 a0 80 01 cmp %g2, %g1
2019f50: 0a bf ff fc bcs 2019f40 <rtems_rfs_bitmap_map_clear_all+0x3c>
2019f54: 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)
2019f58: 86 88 60 1f andcc %g1, 0x1f, %g3
2019f5c: 22 80 00 02 be,a 2019f64 <rtems_rfs_bitmap_map_clear_all+0x60>
2019f60: 86 10 20 20 mov 0x20, %g3
last_search_bit = rtems_rfs_bitmap_element_bits ();
elements = rtems_rfs_bitmap_elements (elements);
2019f64: 89 31 20 05 srl %g4, 5, %g4
for (e = 0; e < (elements - 1); e++)
2019f68: 10 80 00 06 b 2019f80 <rtems_rfs_bitmap_map_clear_all+0x7c>
2019f6c: 82 10 20 00 clr %g1
control->search_bits[e] = RTEMS_RFS_BITMAP_ELEMENT_CLEAR;
2019f70: b9 28 60 02 sll %g1, 2, %i4 <== NOT EXECUTED
2019f74: 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++)
2019f78: 82 00 60 01 inc %g1 <== NOT EXECUTED
control->search_bits[e] = RTEMS_RFS_BITMAP_ELEMENT_CLEAR;
2019f7c: 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++)
2019f80: 80 a0 40 04 cmp %g1, %g4
2019f84: 12 bf ff fb bne 2019f70 <rtems_rfs_bitmap_map_clear_all+0x6c><== NEVER TAKEN
2019f88: c4 07 60 14 ld [ %i5 + 0x14 ], %g2
control->search_bits[e] = RTEMS_RFS_BITMAP_ELEMENT_CLEAR;
control->search_bits[elements - 1] =
2019f8c: 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);
2019f90: 86 20 00 03 neg %g3
2019f94: 88 10 3f ff mov -1, %g4
2019f98: 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] =
2019f9c: 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);
2019fa0: c2 07 40 00 ld [ %i5 ], %g1
2019fa4: 84 10 20 01 mov 1, %g2
return 0;
2019fa8: 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);
2019fac: c4 28 40 00 stb %g2, [ %g1 ]
return 0;
}
2019fb0: 81 c7 e0 08 ret
2019fb4: 81 e8 00 00 restore
02019cf4 <rtems_rfs_bitmap_map_set>:
int
rtems_rfs_bitmap_map_set (rtems_rfs_bitmap_control* control,
rtems_rfs_bitmap_bit bit)
{
2019cf4: 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);
2019cf8: 90 10 00 18 mov %i0, %o0
}
int
rtems_rfs_bitmap_map_set (rtems_rfs_bitmap_control* control,
rtems_rfs_bitmap_bit bit)
{
2019cfc: 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);
2019d00: 7f ff ff 3a call 20199e8 <rtems_rfs_bitmap_load_map>
2019d04: 92 07 bf fc add %fp, -4, %o1
if (rc > 0)
2019d08: b0 92 20 00 orcc %o0, 0, %i0
2019d0c: 14 80 00 1d bg 2019d80 <rtems_rfs_bitmap_map_set+0x8c> <== NEVER TAKEN
2019d10: 01 00 00 00 nop
return rc;
if (bit >= control->size)
2019d14: c2 07 60 0c ld [ %i5 + 0xc ], %g1
2019d18: 80 a6 40 01 cmp %i1, %g1
2019d1c: 1a 80 00 19 bcc 2019d80 <rtems_rfs_bitmap_map_set+0x8c> <== NEVER TAKEN
2019d20: 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);
2019d24: 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);
2019d28: 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);
2019d2c: 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);
2019d30: 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;
2019d34: 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);
2019d38: 82 10 20 01 mov 1, %g1
2019d3c: 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);
2019d40: 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);
2019d44: c8 26 c0 1c st %g4, [ %i3 + %i4 ]
if (rtems_rfs_bitmap_match(map[index], RTEMS_RFS_BITMAP_ELEMENT_SET))
2019d48: 80 a1 20 00 cmp %g4, 0
2019d4c: 12 80 00 0d bne 2019d80 <rtems_rfs_bitmap_map_set+0x8c> <== ALWAYS TAKEN
2019d50: b0 10 20 00 clr %i0
{
bit = index;
index = rtems_rfs_bitmap_map_index (bit);
2019d54: 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);
2019d58: 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);
2019d5c: 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);
2019d60: 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);
2019d64: 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);
2019d68: c6 20 80 19 st %g3, [ %g2 + %i1 ] <== NOT EXECUTED
control->free--;
2019d6c: c4 07 60 10 ld [ %i5 + 0x10 ], %g2 <== NOT EXECUTED
2019d70: 84 00 bf ff add %g2, -1, %g2 <== NOT EXECUTED
2019d74: c4 27 60 10 st %g2, [ %i5 + 0x10 ] <== NOT EXECUTED
rtems_rfs_buffer_mark_dirty (control->buffer);
2019d78: c4 07 40 00 ld [ %i5 ], %g2 <== NOT EXECUTED
2019d7c: c2 28 80 00 stb %g1, [ %g2 ] <== NOT EXECUTED
}
return 0;
}
2019d80: 81 c7 e0 08 ret
2019d84: 81 e8 00 00 restore
02019e74 <rtems_rfs_bitmap_map_set_all>:
int
rtems_rfs_bitmap_map_set_all (rtems_rfs_bitmap_control* control)
{
2019e74: 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);
2019e78: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
return 0;
}
int
rtems_rfs_bitmap_map_set_all (rtems_rfs_bitmap_control* control)
{
2019e7c: 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);
2019e80: 7f ff fe da call 20199e8 <rtems_rfs_bitmap_load_map> <== NOT EXECUTED
2019e84: 92 07 bf fc add %fp, -4, %o1 <== NOT EXECUTED
if (rc > 0)
2019e88: b0 92 20 00 orcc %o0, 0, %i0 <== NOT EXECUTED
2019e8c: 14 80 00 1c bg 2019efc <rtems_rfs_bitmap_map_set_all+0x88><== NOT EXECUTED
2019e90: 82 10 20 00 clr %g1 <== NOT EXECUTED
return rc;
elements = rtems_rfs_bitmap_elements (control->size);
2019e94: c4 07 60 0c ld [ %i5 + 0xc ], %g2 <== NOT EXECUTED
control->free = 0;
2019e98: 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);
2019e9c: 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;
2019ea0: 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);
2019ea4: 85 30 a0 05 srl %g2, 5, %g2 <== NOT EXECUTED
control->free = 0;
for (e = 0; e < elements; e++)
2019ea8: 10 80 00 04 b 2019eb8 <rtems_rfs_bitmap_map_set_all+0x44> <== NOT EXECUTED
2019eac: 86 00 a0 01 add %g2, 1, %g3 <== NOT EXECUTED
2019eb0: 82 00 60 01 inc %g1 <== NOT EXECUTED
map[e] = RTEMS_RFS_BITMAP_ELEMENT_SET;
2019eb4: 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++)
2019eb8: 80 a0 40 03 cmp %g1, %g3 <== NOT EXECUTED
2019ebc: 0a bf ff fd bcs 2019eb0 <rtems_rfs_bitmap_map_set_all+0x3c><== NOT EXECUTED
2019ec0: b9 28 60 02 sll %g1, 2, %i4 <== NOT EXECUTED
map[e] = RTEMS_RFS_BITMAP_ELEMENT_SET;
elements = rtems_rfs_bitmap_elements (elements);
2019ec4: 85 30 a0 05 srl %g2, 5, %g2 <== NOT EXECUTED
for (e = 0; e < elements; e++)
2019ec8: 82 10 20 00 clr %g1 <== NOT EXECUTED
2019ecc: 10 80 00 05 b 2019ee0 <rtems_rfs_bitmap_map_set_all+0x6c> <== NOT EXECUTED
2019ed0: 84 00 a0 01 inc %g2 <== NOT EXECUTED
control->search_bits[e] = RTEMS_RFS_BITMAP_ELEMENT_SET;
2019ed4: 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++)
2019ed8: 82 00 60 01 inc %g1 <== NOT EXECUTED
control->search_bits[e] = RTEMS_RFS_BITMAP_ELEMENT_SET;
2019edc: 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++)
2019ee0: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED
2019ee4: 2a bf ff fc bcs,a 2019ed4 <rtems_rfs_bitmap_map_set_all+0x60><== NOT EXECUTED
2019ee8: 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);
2019eec: c2 07 40 00 ld [ %i5 ], %g1 <== NOT EXECUTED
2019ef0: 84 10 20 01 mov 1, %g2 <== NOT EXECUTED
return 0;
2019ef4: 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);
2019ef8: c4 28 40 00 stb %g2, [ %g1 ] <== NOT EXECUTED
return 0;
}
2019efc: 81 c7 e0 08 ret <== NOT EXECUTED
2019f00: 81 e8 00 00 restore <== NOT EXECUTED
02019e14 <rtems_rfs_bitmap_map_test>:
int
rtems_rfs_bitmap_map_test (rtems_rfs_bitmap_control* control,
rtems_rfs_bitmap_bit bit,
bool* state)
{
2019e14: 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);
2019e18: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
2019e1c: 7f ff fe f3 call 20199e8 <rtems_rfs_bitmap_load_map> <== NOT EXECUTED
2019e20: 92 07 bf fc add %fp, -4, %o1 <== NOT EXECUTED
if (rc > 0)
2019e24: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2019e28: 14 80 00 11 bg 2019e6c <rtems_rfs_bitmap_map_test+0x58> <== NOT EXECUTED
2019e2c: 01 00 00 00 nop <== NOT EXECUTED
return rc;
if (bit >= control->size)
2019e30: c2 06 20 0c ld [ %i0 + 0xc ], %g1 <== NOT EXECUTED
2019e34: 80 a6 40 01 cmp %i1, %g1 <== NOT EXECUTED
2019e38: 1a 80 00 0d bcc 2019e6c <rtems_rfs_bitmap_map_test+0x58> <== NOT EXECUTED
2019e3c: 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);
2019e40: 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);
2019e44: 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);
2019e48: b3 28 80 19 sll %g2, %i1, %i1 <== NOT EXECUTED
2019e4c: 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);
2019e50: 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);
2019e54: 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;
2019e58: 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);
2019e5c: b2 0e 40 01 and %i1, %g1, %i1 <== NOT EXECUTED
2019e60: 80 a0 00 19 cmp %g0, %i1 <== NOT EXECUTED
2019e64: 82 60 3f ff subx %g0, -1, %g1 <== NOT EXECUTED
2019e68: 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;
}
2019e6c: 81 c7 e0 08 ret <== NOT EXECUTED
2019e70: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED
02019cbc <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;
}
2019cbc: 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);
2019cc0: 90 20 00 08 neg %o0 <== NOT EXECUTED
return mask;
}
2019cc4: 81 c3 e0 08 retl <== NOT EXECUTED
2019cc8: 91 30 40 08 srl %g1, %o0, %o0 <== NOT EXECUTED
02019ccc <rtems_rfs_bitmap_mask_section>:
rtems_rfs_bitmap_element
rtems_rfs_bitmap_mask_section (unsigned int start, unsigned int end)
{
2019ccc: 82 10 00 08 mov %o0, %g1
rtems_rfs_bitmap_element mask = 0;
if (end > start)
2019cd0: 80 a2 40 01 cmp %o1, %g1
2019cd4: 08 80 00 06 bleu 2019cec <rtems_rfs_bitmap_mask_section+0x20><== NEVER TAKEN
2019cd8: 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);
2019cdc: 92 20 40 09 sub %g1, %o1, %o1
2019ce0: 90 10 3f ff mov -1, %o0
2019ce4: 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;
2019ce8: 91 2a 00 01 sll %o0, %g1, %o0
return mask;
}
2019cec: 81 c3 e0 08 retl
0201a1a0 <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)
{
201a1a0: 9d e3 bf a0 save %sp, -96, %sp
size_t elements = rtems_rfs_bitmap_elements (size);
control->buffer = buffer;
201a1a4: f4 26 00 00 st %i2, [ %i0 ]
control->fs = fs;
201a1a8: f2 26 20 04 st %i1, [ %i0 + 4 ]
control->block = block;
201a1ac: f8 26 20 08 st %i4, [ %i0 + 8 ]
control->size = size;
201a1b0: 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);
201a1b4: 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);
201a1b8: 91 32 20 0a srl %o0, 0xa, %o0
201a1bc: 90 02 20 01 inc %o0
control->search_bits = malloc (elements * sizeof (rtems_rfs_bitmap_element));
201a1c0: 7f ff b9 c0 call 20088c0 <malloc>
201a1c4: 91 2a 20 02 sll %o0, 2, %o0
if (!control->search_bits)
201a1c8: 80 a2 20 00 cmp %o0, 0
201a1cc: 02 80 00 04 be 201a1dc <rtems_rfs_bitmap_open+0x3c> <== NEVER TAKEN
201a1d0: d0 26 20 14 st %o0, [ %i0 + 0x14 ]
return ENOMEM;
return rtems_rfs_bitmap_create_search (control);
201a1d4: 7f ff ff b9 call 201a0b8 <rtems_rfs_bitmap_create_search>
201a1d8: 81 e8 00 00 restore
}
201a1dc: 81 c7 e0 08 ret <== NOT EXECUTED
201a1e0: 91 e8 20 0c restore %g0, 0xc, %o0 <== NOT EXECUTED
0201a420 <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)
{
201a420: 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);
201a424: 96 10 20 01 mov 1, %o3
201a428: 90 10 00 18 mov %i0, %o0
201a42c: 92 10 00 19 mov %i1, %o1
201a430: 40 00 04 5e call 201b5a8 <rtems_rfs_buffer_handle_request>
201a434: 94 10 00 1a mov %i2, %o2
if (rc > 0)
201a438: 80 a2 20 00 cmp %o0, 0
201a43c: 14 80 00 26 bg 201a4d4 <rtems_rfs_block_find_indirect+0xb4><== NEVER TAKEN
201a440: 87 2e e0 02 sll %i3, 2, %g3
return rc;
*result = rtems_rfs_block_get_number (buffer, offset);
201a444: c2 06 60 08 ld [ %i1 + 8 ], %g1
201a448: c8 00 60 1c ld [ %g1 + 0x1c ], %g4
if ((*result + 1) == 0)
*result = 0;
if (*result >= rtems_rfs_fs_blocks (fs))
201a44c: 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);
201a450: 84 01 00 03 add %g4, %g3, %g2
201a454: c2 09 00 03 ldub [ %g4 + %g3 ], %g1
201a458: fa 08 a0 03 ldub [ %g2 + 3 ], %i5
201a45c: c6 08 a0 01 ldub [ %g2 + 1 ], %g3
201a460: c4 08 a0 02 ldub [ %g2 + 2 ], %g2
201a464: 83 28 60 18 sll %g1, 0x18, %g1
201a468: 85 28 a0 08 sll %g2, 8, %g2
201a46c: 82 17 40 01 or %i5, %g1, %g1
201a470: 87 28 e0 10 sll %g3, 0x10, %g3
201a474: 82 10 40 03 or %g1, %g3, %g1
201a478: 82 10 40 02 or %g1, %g2, %g1
if ((*result + 1) == 0)
*result = 0;
201a47c: 84 38 00 01 xnor %g0, %g1, %g2
201a480: 80 a0 00 02 cmp %g0, %g2
201a484: 84 60 20 00 subx %g0, 0, %g2
201a488: 82 08 40 02 and %g1, %g2, %g1
if (*result >= rtems_rfs_fs_blocks (fs))
201a48c: c4 06 20 04 ld [ %i0 + 4 ], %g2
201a490: 80 a0 40 02 cmp %g1, %g2
201a494: 0a 80 00 10 bcs 201a4d4 <rtems_rfs_block_find_indirect+0xb4><== ALWAYS TAKEN
201a498: c2 27 00 00 st %g1, [ %i4 ]
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BLOCK_FIND))
201a49c: 90 10 20 00 clr %o0 <== NOT EXECUTED
201a4a0: 7f ff e4 cc call 20137d0 <rtems_rfs_trace> <== NOT EXECUTED
201a4a4: 13 00 00 04 sethi %hi(0x1000), %o1 <== NOT EXECUTED
201a4a8: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
201a4ac: 22 80 00 09 be,a 201a4d0 <rtems_rfs_block_find_indirect+0xb0><== NOT EXECUTED
201a4b0: c0 27 00 00 clr [ %i4 ] <== NOT EXECUTED
printf ("rtems-rfs: block-find: invalid block in table:"
201a4b4: d2 07 00 00 ld [ %i4 ], %o1 <== NOT EXECUTED
201a4b8: 11 00 80 cd sethi %hi(0x2033400), %o0 <== NOT EXECUTED
201a4bc: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED
201a4c0: 90 12 23 20 or %o0, 0x320, %o0 <== NOT EXECUTED
201a4c4: 40 00 1f 0d call 20220f8 <printf> <== NOT EXECUTED
201a4c8: 96 10 00 1b mov %i3, %o3 <== NOT EXECUTED
" block=%" PRId32 ", indirect=%" PRId32 "/%d\n", *result, block, offset);
*result = 0;
201a4cc: c0 27 00 00 clr [ %i4 ] <== NOT EXECUTED
201a4d0: 90 10 20 00 clr %o0 <== NOT EXECUTED
rc = EIO;
}
return 0;
}
201a4d4: 81 c7 e0 08 ret
201a4d8: 91 e8 00 08 restore %g0, %o0, %o0
0201a540 <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)
{
201a540: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED
if (pos == 0)
201a544: 80 96 40 1a orcc %i1, %i2, %g0 <== NOT EXECUTED
201a548: 32 80 00 06 bne,a 201a560 <rtems_rfs_block_get_block_size+0x20><== NOT EXECUTED
201a54c: 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;
201a550: c0 26 c0 00 clr [ %i3 ] <== NOT EXECUTED
size->offset = 0;
201a554: c0 26 e0 04 clr [ %i3 + 4 ] <== NOT EXECUTED
201a558: 81 c7 e0 08 ret <== NOT EXECUTED
201a55c: 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;
201a560: 94 10 20 00 clr %o2 <== NOT EXECUTED
201a564: 96 10 00 1d mov %i5, %o3 <== NOT EXECUTED
201a568: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
201a56c: 40 00 52 50 call 202eeac <__udivdi3> <== NOT EXECUTED
201a570: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED
201a574: 92 02 60 01 inc %o1 <== NOT EXECUTED
size->offset = pos % rtems_rfs_fs_block_size (fs);
201a578: 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;
201a57c: d2 26 c0 00 st %o1, [ %i3 ] <== NOT EXECUTED
size->offset = pos % rtems_rfs_fs_block_size (fs);
201a580: 94 10 20 00 clr %o2 <== NOT EXECUTED
201a584: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED
201a588: 40 00 53 1d call 202f1fc <__umoddi3> <== NOT EXECUTED
201a58c: 96 10 00 1d mov %i5, %o3 <== NOT EXECUTED
201a590: d2 26 e0 04 st %o1, [ %i3 + 4 ] <== NOT EXECUTED
201a594: 81 c7 e0 08 ret <== NOT EXECUTED
201a598: 81 e8 00 00 restore <== NOT EXECUTED
0201a778 <rtems_rfs_block_map_close>:
int
rtems_rfs_block_map_close (rtems_rfs_file_system* fs,
rtems_rfs_block_map* map)
{
201a778: 9d e3 bf a0 save %sp, -96, %sp
int rc = 0;
int brc;
if (map->dirty && map->inode)
201a77c: c2 0e 40 00 ldub [ %i1 ], %g1
}
int
rtems_rfs_block_map_close (rtems_rfs_file_system* fs,
rtems_rfs_block_map* map)
{
201a780: ba 10 00 18 mov %i0, %i5
int rc = 0;
int brc;
if (map->dirty && map->inode)
201a784: 80 a0 60 00 cmp %g1, 0
201a788: 02 80 00 61 be 201a90c <rtems_rfs_block_map_close+0x194>
201a78c: b0 10 20 00 clr %i0
201a790: d2 06 60 04 ld [ %i1 + 4 ], %o1
201a794: 80 a2 60 00 cmp %o1, 0
201a798: 22 80 00 5e be,a 201a910 <rtems_rfs_block_map_close+0x198><== NEVER TAKEN
201a79c: 92 06 60 38 add %i1, 0x38, %o1 <== NOT EXECUTED
{
brc = rtems_rfs_inode_load (fs, map->inode);
201a7a0: 7f ff dd 4e call 2011cd8 <rtems_rfs_inode_load>
201a7a4: 90 10 00 1d mov %i5, %o0
if (brc > 0)
201a7a8: b0 92 20 00 orcc %o0, 0, %i0
201a7ac: 14 80 00 59 bg 201a910 <rtems_rfs_block_map_close+0x198> <== NEVER TAKEN
201a7b0: 92 06 60 38 add %i1, 0x38, %o1
201a7b4: 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);
201a7b8: 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]);
201a7bc: c4 06 60 04 ld [ %i1 + 4 ], %g2
return rc;
}
int
rtems_rfs_block_map_close (rtems_rfs_file_system* fs,
201a7c0: 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);
201a7c4: f6 00 a0 0c ld [ %g2 + 0xc ], %i3
201a7c8: 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]);
201a7cc: c6 00 e0 24 ld [ %g3 + 0x24 ], %g3
201a7d0: 88 00 60 06 add %g1, 6, %g4
201a7d4: 89 29 20 02 sll %g4, 2, %g4
201a7d8: b6 06 c0 04 add %i3, %g4, %i3
201a7dc: b5 30 e0 18 srl %g3, 0x18, %i2
201a7e0: f4 2e e0 04 stb %i2, [ %i3 + 4 ]
201a7e4: f6 00 a0 0c ld [ %g2 + 0xc ], %i3
201a7e8: b5 30 e0 10 srl %g3, 0x10, %i2
201a7ec: b6 06 c0 04 add %i3, %g4, %i3
201a7f0: f4 2e e0 05 stb %i2, [ %i3 + 5 ]
201a7f4: f6 00 a0 0c ld [ %g2 + 0xc ], %i3
201a7f8: b5 30 e0 08 srl %g3, 8, %i2
201a7fc: b6 06 c0 04 add %i3, %g4, %i3
201a800: f4 2e e0 06 stb %i2, [ %i3 + 6 ]
201a804: f6 00 a0 0c ld [ %g2 + 0xc ], %i3
if (rc == 0)
{
int b;
for (b = 0; b < RTEMS_RFS_INODE_BLOCKS; b++)
201a808: 82 00 60 01 inc %g1
201a80c: 88 06 c0 04 add %i3, %g4, %g4
201a810: c6 29 20 07 stb %g3, [ %g4 + 7 ]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
201a814: f8 28 a0 10 stb %i4, [ %g2 + 0x10 ]
201a818: 80 a0 60 05 cmp %g1, 5
201a81c: 12 bf ff e8 bne 201a7bc <rtems_rfs_block_map_close+0x44>
201a820: 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);
201a824: c2 06 60 04 ld [ %i1 + 4 ], %g1
201a828: 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);
201a82c: c8 00 60 0c ld [ %g1 + 0xc ], %g4
201a830: b9 30 a0 18 srl %g2, 0x18, %i4
201a834: f8 29 20 0c stb %i4, [ %g4 + 0xc ]
201a838: c8 00 60 0c ld [ %g1 + 0xc ], %g4
201a83c: b9 30 a0 10 srl %g2, 0x10, %i4
201a840: f8 29 20 0d stb %i4, [ %g4 + 0xd ]
201a844: c8 00 60 0c ld [ %g1 + 0xc ], %g4
201a848: b9 30 a0 08 srl %g2, 8, %i4
201a84c: f8 29 20 0e stb %i4, [ %g4 + 0xe ]
201a850: 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);
201a854: 90 10 00 1d mov %i5, %o0
201a858: c4 29 20 0f stb %g2, [ %g4 + 0xf ]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
201a85c: 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);
201a860: 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);
201a864: f8 0e 60 0e ldub [ %i1 + 0xe ], %i4
201a868: c4 00 60 0c ld [ %g1 + 0xc ], %g2
201a86c: c8 06 60 0c ld [ %i1 + 0xc ], %g4
201a870: f8 28 a0 0a stb %i4, [ %g2 + 0xa ]
201a874: 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);
201a878: 94 10 20 01 mov 1, %o2
201a87c: c8 28 a0 0b stb %g4, [ %g2 + 0xb ]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
201a880: 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);
201a884: c2 06 60 04 ld [ %i1 + 4 ], %g1
201a888: 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);
201a88c: c8 00 60 0c ld [ %g1 + 0xc ], %g4
201a890: b9 30 a0 18 srl %g2, 0x18, %i4
201a894: f8 29 20 30 stb %i4, [ %g4 + 0x30 ]
201a898: c8 00 60 0c ld [ %g1 + 0xc ], %g4
201a89c: b9 30 a0 10 srl %g2, 0x10, %i4
201a8a0: f8 29 20 31 stb %i4, [ %g4 + 0x31 ]
201a8a4: c8 00 60 0c ld [ %g1 + 0xc ], %g4
201a8a8: b9 30 a0 08 srl %g2, 8, %i4
201a8ac: f8 29 20 32 stb %i4, [ %g4 + 0x32 ]
201a8b0: c8 00 60 0c ld [ %g1 + 0xc ], %g4
201a8b4: c4 29 20 33 stb %g2, [ %g4 + 0x33 ]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
201a8b8: c6 28 60 10 stb %g3, [ %g1 + 0x10 ]
rtems_rfs_inode_set_last_data_block (map->inode, map->last_data_block);
201a8bc: c2 06 60 04 ld [ %i1 + 4 ], %g1
201a8c0: 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);
201a8c4: c8 00 60 0c ld [ %g1 + 0xc ], %g4
201a8c8: b9 30 a0 18 srl %g2, 0x18, %i4
201a8cc: f8 29 20 34 stb %i4, [ %g4 + 0x34 ]
201a8d0: c8 00 60 0c ld [ %g1 + 0xc ], %g4
201a8d4: b9 30 a0 10 srl %g2, 0x10, %i4
201a8d8: f8 29 20 35 stb %i4, [ %g4 + 0x35 ]
201a8dc: c8 00 60 0c ld [ %g1 + 0xc ], %g4
201a8e0: b9 30 a0 08 srl %g2, 8, %i4
201a8e4: f8 29 20 36 stb %i4, [ %g4 + 0x36 ]
201a8e8: c8 00 60 0c ld [ %g1 + 0xc ], %g4
201a8ec: c4 29 20 37 stb %g2, [ %g4 + 0x37 ]
brc = rtems_rfs_inode_unload (fs, map->inode, true);
201a8f0: d2 06 60 04 ld [ %i1 + 4 ], %o1
201a8f4: 7f ff dd 5c call 2011e64 <rtems_rfs_inode_unload>
201a8f8: c6 28 60 10 stb %g3, [ %g1 + 0x10 ]
if (brc > 0)
rc = brc;
map->dirty = false;
201a8fc: c0 2e 40 00 clrb [ %i1 ]
201a900: 82 38 00 08 xnor %g0, %o0, %g1
201a904: 83 38 60 1f sra %g1, 0x1f, %g1
201a908: 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);
201a90c: 92 06 60 38 add %i1, 0x38, %o1
}
}
map->inode = NULL;
201a910: c0 26 60 04 clr [ %i1 + 4 ]
201a914: 40 00 02 b1 call 201b3d8 <rtems_rfs_buffer_handle_release>
201a918: 90 10 00 1d mov %i5, %o0
201a91c: 90 10 00 1d mov %i5, %o0
handle->dirty = false;
201a920: c0 2e 60 38 clrb [ %i1 + 0x38 ]
handle->bnum = 0;
201a924: c0 26 60 3c clr [ %i1 + 0x3c ]
handle->buffer = NULL;
201a928: 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);
201a92c: 40 00 02 ab call 201b3d8 <rtems_rfs_buffer_handle_release>
201a930: 92 06 60 44 add %i1, 0x44, %o1
handle->dirty = false;
201a934: c0 2e 60 44 clrb [ %i1 + 0x44 ]
handle->bnum = 0;
201a938: c0 26 60 48 clr [ %i1 + 0x48 ]
handle->buffer = NULL;
201a93c: 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;
}
201a940: 81 c7 e0 08 ret
201a944: 81 e8 00 00 restore
0201a948 <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)
{
201a948: 9d e3 bf 98 save %sp, -104, %sp
int rc = 0;
*block = 0;
201a94c: 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))
201a950: fa 06 80 00 ld [ %i2 ], %i5
201a954: 80 a7 60 00 cmp %i5, 0
201a958: 02 80 00 05 be 201a96c <rtems_rfs_block_map_find+0x24>
201a95c: f8 06 60 08 ld [ %i1 + 8 ], %i4
201a960: 80 a7 20 00 cmp %i4, 0
201a964: 02 80 00 53 be 201aab0 <rtems_rfs_block_map_find+0x168> <== NEVER TAKEN
201a968: 90 10 20 06 mov 6, %o0
201a96c: 80 a7 40 1c cmp %i5, %i4
201a970: 1a 80 00 50 bcc 201aab0 <rtems_rfs_block_map_find+0x168>
201a974: 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))
201a978: c2 06 60 10 ld [ %i1 + 0x10 ], %g1
201a97c: 80 a7 40 01 cmp %i5, %g1
201a980: 12 80 00 08 bne 201a9a0 <rtems_rfs_block_map_find+0x58>
201a984: 80 a7 20 05 cmp %i4, 5
201a988: c2 06 60 18 ld [ %i1 + 0x18 ], %g1
201a98c: 80 a0 60 00 cmp %g1, 0
201a990: 02 80 00 04 be 201a9a0 <rtems_rfs_block_map_find+0x58>
201a994: 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];
201a998: 10 80 00 3d b 201aa8c <rtems_rfs_block_map_find+0x144>
201a99c: 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)
201a9a0: 38 80 00 08 bgu,a 201a9c0 <rtems_rfs_block_map_find+0x78>
201a9a4: e0 06 20 34 ld [ %i0 + 0x34 ], %l0
{
*block = map->blocks[bpos->bno];
201a9a8: ba 07 60 08 add %i5, 8, %i5
201a9ac: bb 2f 60 02 sll %i5, 2, %i5
201a9b0: ba 06 40 1d add %i1, %i5, %i5
201a9b4: c2 07 60 04 ld [ %i5 + 4 ], %g1
201a9b8: 10 80 00 35 b 201aa8c <rtems_rfs_block_map_find+0x144>
201a9bc: 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;
201a9c0: 90 10 00 1d mov %i5, %o0
201a9c4: 40 00 4e 6b call 202e370 <.urem>
201a9c8: 92 10 00 10 mov %l0, %o1
singly = bpos->bno / fs->blocks_per_block;
201a9cc: 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;
201a9d0: a2 10 00 08 mov %o0, %l1
singly = bpos->bno / fs->blocks_per_block;
201a9d4: 7f ff 9f 2a call 200267c <.udiv>
201a9d8: 90 10 00 1d mov %i5, %o0
if (map->size.count <= fs->block_map_singly_blocks)
201a9dc: 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;
201a9e0: d0 27 bf fc st %o0, [ %fp + -4 ]
if (map->size.count <= fs->block_map_singly_blocks)
201a9e4: 80 a7 00 01 cmp %i4, %g1
201a9e8: 18 80 00 09 bgu 201aa0c <rtems_rfs_block_map_find+0xc4> <== NEVER TAKEN
201a9ec: 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,
201a9f0: ba 02 20 08 add %o0, 8, %i5
201a9f4: 92 06 60 38 add %i1, 0x38, %o1
201a9f8: bb 2f 60 02 sll %i5, 2, %i5
201a9fc: 90 10 00 18 mov %i0, %o0
201aa00: ba 06 40 1d add %i1, %i5, %i5
201aa04: 10 80 00 1c b 201aa74 <rtems_rfs_block_map_find+0x12c>
201aa08: 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;
201aa0c: 40 00 4e 59 call 202e370 <.urem> <== NOT EXECUTED
201aa10: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED
if (map->size.count < fs->block_map_doubly_blocks)
201aa14: 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;
201aa18: d0 27 bf fc st %o0, [ %fp + -4 ] <== NOT EXECUTED
201aa1c: a4 10 00 08 mov %o0, %l2 <== NOT EXECUTED
if (map->size.count < fs->block_map_doubly_blocks)
201aa20: 80 a7 00 02 cmp %i4, %g2 <== NOT EXECUTED
201aa24: 1a 80 00 23 bcc 201aab0 <rtems_rfs_block_map_find+0x168> <== NOT EXECUTED
201aa28: 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;
201aa2c: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED
201aa30: 7f ff 9f 13 call 200267c <.udiv> <== NOT EXECUTED
201aa34: 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,
201aa38: 90 02 20 08 add %o0, 8, %o0 <== NOT EXECUTED
201aa3c: 83 2a 20 02 sll %o0, 2, %g1 <== NOT EXECUTED
201aa40: 82 06 40 01 add %i1, %g1, %g1 <== NOT EXECUTED
201aa44: d4 00 60 04 ld [ %g1 + 4 ], %o2 <== NOT EXECUTED
201aa48: b8 06 60 44 add %i1, 0x44, %i4 <== NOT EXECUTED
201aa4c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
201aa50: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
201aa54: 96 10 00 12 mov %l2, %o3 <== NOT EXECUTED
201aa58: 7f ff fe 72 call 201a420 <rtems_rfs_block_find_indirect> <== NOT EXECUTED
201aa5c: 98 07 bf fc add %fp, -4, %o4 <== NOT EXECUTED
&map->doubly_buffer,
map->blocks[doubly],
singly, &singly);
if (rc == 0)
201aa60: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
201aa64: 12 80 00 13 bne 201aab0 <rtems_rfs_block_map_find+0x168> <== NOT EXECUTED
201aa68: d4 07 bf fc ld [ %fp + -4 ], %o2 <== NOT EXECUTED
{
rc = rtems_rfs_block_find_indirect (fs,
201aa6c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
201aa70: 92 06 60 38 add %i1, 0x38, %o1 <== NOT EXECUTED
201aa74: 96 10 00 11 mov %l1, %o3
201aa78: 7f ff fe 6a call 201a420 <rtems_rfs_block_find_indirect>
201aa7c: 98 10 00 1b mov %i3, %o4
}
}
}
}
if (rc == 0)
201aa80: 80 a2 20 00 cmp %o0, 0
201aa84: 12 80 00 0b bne 201aab0 <rtems_rfs_block_map_find+0x168> <== NEVER TAKEN
201aa88: 01 00 00 00 nop
{
rtems_rfs_block_copy_bpos (&map->bpos, bpos);
201aa8c: c2 06 80 00 ld [ %i2 ], %g1
map->bpos.block = *block;
201aa90: 90 10 20 00 clr %o0
}
}
if (rc == 0)
{
rtems_rfs_block_copy_bpos (&map->bpos, bpos);
201aa94: c2 26 60 10 st %g1, [ %i1 + 0x10 ]
201aa98: c2 06 a0 04 ld [ %i2 + 4 ], %g1
201aa9c: c2 26 60 14 st %g1, [ %i1 + 0x14 ]
201aaa0: c2 06 a0 08 ld [ %i2 + 8 ], %g1
201aaa4: c2 26 60 18 st %g1, [ %i1 + 0x18 ]
map->bpos.block = *block;
201aaa8: c2 06 c0 00 ld [ %i3 ], %g1
201aaac: c2 26 60 18 st %g1, [ %i1 + 0x18 ]
}
return rc;
}
201aab0: 81 c7 e0 08 ret
201aab4: 91 e8 00 08 restore %g0, %o0, %o0
0201ab60 <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)
{
201ab60: 9d e3 bf 98 save %sp, -104, %sp
int b;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BLOCK_MAP_GROW))
201ab64: 90 10 20 00 clr %o0
201ab68: 13 00 00 08 sethi %hi(0x2000), %o1
201ab6c: 7f ff e3 19 call 20137d0 <rtems_rfs_trace>
201ab70: ba 10 00 18 mov %i0, %i5
201ab74: 80 8a 20 ff btst 0xff, %o0
201ab78: 22 80 00 08 be,a 201ab98 <rtems_rfs_block_map_grow+0x38> <== ALWAYS TAKEN
201ab7c: c4 06 60 08 ld [ %i1 + 8 ], %g2
printf ("rtems-rfs: block-map-grow: entry: blocks=%zd count=%" PRIu32 "\n",
201ab80: d4 06 60 08 ld [ %i1 + 8 ], %o2 <== NOT EXECUTED
201ab84: 11 00 80 cd sethi %hi(0x2033400), %o0 <== NOT EXECUTED
201ab88: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED
201ab8c: 40 00 1d 5b call 20220f8 <printf> <== NOT EXECUTED
201ab90: 90 12 23 70 or %o0, 0x370, %o0 <== NOT EXECUTED
blocks, map->size.count);
if ((map->size.count + blocks) >= rtems_rfs_fs_max_block_map_blocks (fs))
201ab94: c4 06 60 08 ld [ %i1 + 8 ], %g2 <== NOT EXECUTED
201ab98: c2 07 60 3c ld [ %i5 + 0x3c ], %g1
201ab9c: 84 06 80 02 add %i2, %g2, %g2
201aba0: 80 a0 80 01 cmp %g2, %g1
201aba4: 1a 80 00 b2 bcc 201ae6c <rtems_rfs_block_map_grow+0x30c> <== NEVER TAKEN
201aba8: 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,
201abac: 10 80 00 d4 b 201aefc <rtems_rfs_block_map_grow+0x39c>
201abb0: 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,
201abb4: 90 10 00 1d mov %i5, %o0
201abb8: 94 10 20 00 clr %o2
201abbc: 7f ff db 1f call 2011838 <rtems_rfs_group_bitmap_alloc>
201abc0: 96 07 bf f8 add %fp, -8, %o3
false, &block);
if (rc > 0)
201abc4: b0 92 20 00 orcc %o0, 0, %i0
201abc8: 14 80 00 d4 bg 201af18 <rtems_rfs_block_map_grow+0x3b8>
201abcc: 01 00 00 00 nop
return rc;
if (map->size.count < RTEMS_RFS_INODE_BLOCKS)
201abd0: f8 06 60 08 ld [ %i1 + 8 ], %i4
201abd4: 80 a7 20 04 cmp %i4, 4
201abd8: 38 80 00 08 bgu,a 201abf8 <rtems_rfs_block_map_grow+0x98>
201abdc: f0 07 60 34 ld [ %i5 + 0x34 ], %i0
map->blocks[map->size.count] = block;
201abe0: c2 07 bf f8 ld [ %fp + -8 ], %g1
201abe4: b8 07 20 08 add %i4, 8, %i4
201abe8: b9 2f 20 02 sll %i4, 2, %i4
201abec: b8 06 40 1c add %i1, %i4, %i4
201abf0: 10 80 00 b7 b 201aecc <rtems_rfs_block_map_grow+0x36c>
201abf4: 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;
201abf8: 90 10 00 1c mov %i4, %o0
201abfc: 40 00 4d dd call 202e370 <.urem>
201ac00: 92 10 00 18 mov %i0, %o1
singly = map->size.count / fs->blocks_per_block;
201ac04: 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;
201ac08: a4 10 00 08 mov %o0, %l2
singly = map->size.count / fs->blocks_per_block;
201ac0c: 7f ff 9e 9c call 200267c <.udiv>
201ac10: 90 10 00 1c mov %i4, %o0
if (map->size.count < fs->block_map_singly_blocks)
201ac14: c2 07 60 38 ld [ %i5 + 0x38 ], %g1
201ac18: 80 a7 00 01 cmp %i4, %g1
201ac1c: 1a 80 00 1d bcc 201ac90 <rtems_rfs_block_map_grow+0x130> <== NEVER TAKEN
201ac20: 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) ||
201ac24: 80 a4 a0 00 cmp %l2, 0
201ac28: 22 80 00 07 be,a 201ac44 <rtems_rfs_block_map_grow+0xe4> <== NEVER TAKEN
201ac2c: b8 1f 20 05 xor %i4, 5, %i4 <== NOT EXECUTED
201ac30: 80 a4 a0 05 cmp %l2, 5
201ac34: 12 80 00 10 bne 201ac74 <rtems_rfs_block_map_grow+0x114>
201ac38: 80 a2 20 00 cmp %o0, 0
201ac3c: 12 80 00 0e bne 201ac74 <rtems_rfs_block_map_grow+0x114> <== NEVER TAKEN
201ac40: 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,
201ac44: 80 a0 00 1c cmp %g0, %i4
&map->singly_buffer,
&map->blocks[singly],
201ac48: 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,
201ac4c: 90 10 00 1d mov %i5, %o0
&map->singly_buffer,
&map->blocks[singly],
201ac50: 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,
201ac54: 92 10 00 19 mov %i1, %o1
&map->singly_buffer,
&map->blocks[singly],
201ac58: 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,
201ac5c: 94 10 00 11 mov %l1, %o2
201ac60: 96 02 e0 04 add %o3, 4, %o3
201ac64: 7f ff fd 9e call 201a2dc <rtems_rfs_block_map_indirect_alloc>
201ac68: 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)
201ac6c: 10 80 00 7a b 201ae54 <rtems_rfs_block_map_grow+0x2f4>
201ac70: b0 92 20 00 orcc %o0, 0, %i0
&map->blocks[singly],
upping);
}
else
{
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
201ac74: ac 05 a0 08 add %l6, 8, %l6
201ac78: 90 10 00 1d mov %i5, %o0
201ac7c: ad 2d a0 02 sll %l6, 2, %l6
201ac80: 92 10 00 11 mov %l1, %o1
201ac84: ac 06 40 16 add %i1, %l6, %l6
201ac88: 10 80 00 70 b 201ae48 <rtems_rfs_block_map_grow+0x2e8>
201ac8c: 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;
201ac90: 7f ff 9e 7b call 200267c <.udiv> <== NOT EXECUTED
201ac94: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
singly %= fs->blocks_per_block;
201ac98: 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;
201ac9c: a6 10 00 08 mov %o0, %l3 <== NOT EXECUTED
singly %= fs->blocks_per_block;
201aca0: 40 00 4d b4 call 202e370 <.urem> <== NOT EXECUTED
201aca4: 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)
201aca8: 80 a4 a0 00 cmp %l2, 0 <== NOT EXECUTED
201acac: 12 80 00 4a bne 201add4 <rtems_rfs_block_map_grow+0x274> <== NOT EXECUTED
201acb0: b8 10 00 08 mov %o0, %i4 <== NOT EXECUTED
{
rc = rtems_rfs_block_map_indirect_alloc (fs, map,
201acb4: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
201acb8: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
201acbc: 94 10 00 11 mov %l1, %o2 <== NOT EXECUTED
201acc0: 96 07 bf fc add %fp, -4, %o3 <== NOT EXECUTED
201acc4: 7f ff fd 86 call 201a2dc <rtems_rfs_block_map_indirect_alloc><== NOT EXECUTED
201acc8: 98 10 20 00 clr %o4 <== NOT EXECUTED
&map->singly_buffer,
&singly_block,
false);
if (rc > 0)
201accc: b0 92 20 00 orcc %o0, 0, %i0 <== NOT EXECUTED
201acd0: 04 80 00 04 ble 201ace0 <rtems_rfs_block_map_grow+0x180> <== NOT EXECUTED
201acd4: 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);
201acd8: 10 80 00 62 b 201ae60 <rtems_rfs_block_map_grow+0x300> <== NOT EXECUTED
201acdc: 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) ||
201ace0: 22 80 00 08 be,a 201ad00 <rtems_rfs_block_map_grow+0x1a0><== NOT EXECUTED
201ace4: c4 06 60 08 ld [ %i1 + 8 ], %g2 <== NOT EXECUTED
201ace8: 80 a7 20 05 cmp %i4, 5 <== NOT EXECUTED
201acec: 12 80 00 13 bne 201ad38 <rtems_rfs_block_map_grow+0x1d8> <== NOT EXECUTED
201acf0: 80 a4 e0 00 cmp %l3, 0 <== NOT EXECUTED
201acf4: 32 80 00 12 bne,a 201ad3c <rtems_rfs_block_map_grow+0x1dc><== NOT EXECUTED
201acf8: 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;
201acfc: c4 06 60 08 ld [ %i1 + 8 ], %g2 <== NOT EXECUTED
201ad00: 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],
201ad04: 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;
201ad08: 82 18 80 01 xor %g2, %g1, %g1 <== NOT EXECUTED
rc = rtems_rfs_block_map_indirect_alloc (fs, map,
201ad0c: 80 a0 00 01 cmp %g0, %g1 <== NOT EXECUTED
&map->doubly_buffer,
&map->blocks[doubly],
201ad10: 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,
201ad14: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
&map->doubly_buffer,
&map->blocks[doubly],
201ad18: 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,
201ad1c: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
201ad20: 94 10 00 15 mov %l5, %o2 <== NOT EXECUTED
201ad24: 96 02 e0 04 add %o3, 4, %o3 <== NOT EXECUTED
201ad28: 7f ff fd 6d call 201a2dc <rtems_rfs_block_map_indirect_alloc><== NOT EXECUTED
201ad2c: 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)
201ad30: 10 80 00 0b b 201ad5c <rtems_rfs_block_map_grow+0x1fc> <== NOT EXECUTED
201ad34: b0 92 20 00 orcc %o0, 0, %i0 <== NOT EXECUTED
return rc;
}
}
else
{
rc = rtems_rfs_buffer_handle_request (fs, &map->doubly_buffer,
201ad38: a6 04 e0 08 add %l3, 8, %l3 <== NOT EXECUTED
201ad3c: a7 2c e0 02 sll %l3, 2, %l3 <== NOT EXECUTED
201ad40: a6 06 40 13 add %i1, %l3, %l3 <== NOT EXECUTED
201ad44: d4 04 e0 04 ld [ %l3 + 4 ], %o2 <== NOT EXECUTED
201ad48: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
201ad4c: 92 10 00 15 mov %l5, %o1 <== NOT EXECUTED
201ad50: 40 00 02 16 call 201b5a8 <rtems_rfs_buffer_handle_request><== NOT EXECUTED
201ad54: 96 10 20 01 mov 1, %o3 <== NOT EXECUTED
map->blocks[doubly], true);
if (rc > 0)
201ad58: b0 92 20 00 orcc %o0, 0, %i0 <== NOT EXECUTED
201ad5c: 24 80 00 08 ble,a 201ad7c <rtems_rfs_block_map_grow+0x21c><== NOT EXECUTED
201ad60: c2 06 60 4c ld [ %i1 + 0x4c ], %g1 <== NOT EXECUTED
{
rtems_rfs_group_bitmap_free (fs, false, singly_block);
201ad64: d4 07 bf fc ld [ %fp + -4 ], %o2 <== NOT EXECUTED
201ad68: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
201ad6c: 7f ff db 37 call 2011a48 <rtems_rfs_group_bitmap_free> <== NOT EXECUTED
201ad70: 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);
201ad74: 10 80 00 3b b 201ae60 <rtems_rfs_block_map_grow+0x300> <== NOT EXECUTED
201ad78: 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,
201ad7c: c4 0f bf fc ldub [ %fp + -4 ], %g2 <== NOT EXECUTED
201ad80: c2 00 60 1c ld [ %g1 + 0x1c ], %g1 <== NOT EXECUTED
201ad84: b9 2f 20 02 sll %i4, 2, %i4 <== NOT EXECUTED
201ad88: c4 28 40 1c stb %g2, [ %g1 + %i4 ] <== NOT EXECUTED
201ad8c: c2 06 60 4c ld [ %i1 + 0x4c ], %g1 <== NOT EXECUTED
201ad90: c4 17 bf fc lduh [ %fp + -4 ], %g2 <== NOT EXECUTED
201ad94: c2 00 60 1c ld [ %g1 + 0x1c ], %g1 <== NOT EXECUTED
201ad98: 82 00 40 1c add %g1, %i4, %g1 <== NOT EXECUTED
201ad9c: c4 28 60 01 stb %g2, [ %g1 + 1 ] <== NOT EXECUTED
201ada0: c2 06 60 4c ld [ %i1 + 0x4c ], %g1 <== NOT EXECUTED
201ada4: c4 07 bf fc ld [ %fp + -4 ], %g2 <== NOT EXECUTED
201ada8: c2 00 60 1c ld [ %g1 + 0x1c ], %g1 <== NOT EXECUTED
201adac: 85 30 a0 08 srl %g2, 8, %g2 <== NOT EXECUTED
201adb0: 82 00 40 1c add %g1, %i4, %g1 <== NOT EXECUTED
201adb4: c4 28 60 02 stb %g2, [ %g1 + 2 ] <== NOT EXECUTED
201adb8: c2 06 60 4c ld [ %i1 + 0x4c ], %g1 <== NOT EXECUTED
201adbc: c2 00 60 1c ld [ %g1 + 0x1c ], %g1 <== NOT EXECUTED
201adc0: b8 00 40 1c add %g1, %i4, %i4 <== NOT EXECUTED
201adc4: c2 07 bf fc ld [ %fp + -4 ], %g1 <== NOT EXECUTED
201adc8: c2 2f 20 03 stb %g1, [ %i4 + 3 ] <== NOT EXECUTED
201adcc: 10 80 00 2a b 201ae74 <rtems_rfs_block_map_grow+0x314> <== NOT EXECUTED
201add0: e8 2e 60 44 stb %l4, [ %i1 + 0x44 ] <== NOT EXECUTED
singly,
singly_block);
}
else
{
rc = rtems_rfs_buffer_handle_request (fs,
201add4: a6 04 e0 08 add %l3, 8, %l3 <== NOT EXECUTED
201add8: a7 2c e0 02 sll %l3, 2, %l3 <== NOT EXECUTED
201addc: a6 06 40 13 add %i1, %l3, %l3 <== NOT EXECUTED
201ade0: d4 04 e0 04 ld [ %l3 + 4 ], %o2 <== NOT EXECUTED
201ade4: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
201ade8: 92 10 00 15 mov %l5, %o1 <== NOT EXECUTED
201adec: 40 00 01 ef call 201b5a8 <rtems_rfs_buffer_handle_request><== NOT EXECUTED
201adf0: 96 10 20 01 mov 1, %o3 <== NOT EXECUTED
&map->doubly_buffer,
map->blocks[doubly],
true);
if (rc > 0)
201adf4: b0 92 20 00 orcc %o0, 0, %i0 <== NOT EXECUTED
201adf8: 24 80 00 04 ble,a 201ae08 <rtems_rfs_block_map_grow+0x2a8><== NOT EXECUTED
201adfc: 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);
201ae00: 10 80 00 18 b 201ae60 <rtems_rfs_block_map_grow+0x300> <== NOT EXECUTED
201ae04: 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,
201ae08: b9 2f 20 02 sll %i4, 2, %i4 <== NOT EXECUTED
201ae0c: c4 00 60 1c ld [ %g1 + 0x1c ], %g2 <== NOT EXECUTED
singly);
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
201ae10: 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,
201ae14: 82 00 80 1c add %g2, %i4, %g1 <== NOT EXECUTED
201ae18: d4 08 80 1c ldub [ %g2 + %i4 ], %o2 <== NOT EXECUTED
201ae1c: c6 08 60 03 ldub [ %g1 + 3 ], %g3 <== NOT EXECUTED
201ae20: c4 08 60 01 ldub [ %g1 + 1 ], %g2 <== NOT EXECUTED
201ae24: c2 08 60 02 ldub [ %g1 + 2 ], %g1 <== NOT EXECUTED
201ae28: 95 2a a0 18 sll %o2, 0x18, %o2 <== NOT EXECUTED
201ae2c: 85 28 a0 10 sll %g2, 0x10, %g2 <== NOT EXECUTED
201ae30: 94 10 c0 0a or %g3, %o2, %o2 <== NOT EXECUTED
201ae34: 83 28 60 08 sll %g1, 8, %g1 <== NOT EXECUTED
201ae38: 94 12 80 02 or %o2, %g2, %o2 <== NOT EXECUTED
singly);
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
201ae3c: 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,
201ae40: 94 12 80 01 or %o2, %g1, %o2 <== NOT EXECUTED
201ae44: d4 27 bf fc st %o2, [ %fp + -4 ] <== NOT EXECUTED
singly);
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
201ae48: 40 00 01 d8 call 201b5a8 <rtems_rfs_buffer_handle_request>
201ae4c: 96 10 20 01 mov 1, %o3
singly_block, true);
if (rc > 0)
201ae50: b0 92 20 00 orcc %o0, 0, %i0
201ae54: 24 80 00 09 ble,a 201ae78 <rtems_rfs_block_map_grow+0x318><== ALWAYS TAKEN
201ae58: c2 06 60 40 ld [ %i1 + 0x40 ], %g1
{
rtems_rfs_group_bitmap_free (fs, false, block);
201ae5c: d4 07 bf f8 ld [ %fp + -8 ], %o2 <== NOT EXECUTED
201ae60: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
201ae64: 7f ff da f9 call 2011a48 <rtems_rfs_group_bitmap_free> <== NOT EXECUTED
201ae68: 92 10 20 00 clr %o1 <== NOT EXECUTED
201ae6c: 81 c7 e0 08 ret <== NOT EXECUTED
201ae70: 81 e8 00 00 restore <== NOT EXECUTED
return rc;
}
}
}
rtems_rfs_block_set_number (&map->singly_buffer, direct, block);
201ae74: c2 06 60 40 ld [ %i1 + 0x40 ], %g1 <== NOT EXECUTED
201ae78: c4 0f bf f8 ldub [ %fp + -8 ], %g2
201ae7c: c2 00 60 1c ld [ %g1 + 0x1c ], %g1
201ae80: a5 2c a0 02 sll %l2, 2, %l2
201ae84: c4 28 40 12 stb %g2, [ %g1 + %l2 ]
201ae88: c2 06 60 40 ld [ %i1 + 0x40 ], %g1
201ae8c: c4 17 bf f8 lduh [ %fp + -8 ], %g2
201ae90: c2 00 60 1c ld [ %g1 + 0x1c ], %g1
201ae94: 82 00 40 12 add %g1, %l2, %g1
201ae98: c4 28 60 01 stb %g2, [ %g1 + 1 ]
201ae9c: c2 06 60 40 ld [ %i1 + 0x40 ], %g1
201aea0: c4 07 bf f8 ld [ %fp + -8 ], %g2
201aea4: c2 00 60 1c ld [ %g1 + 0x1c ], %g1
201aea8: 85 30 a0 08 srl %g2, 8, %g2
201aeac: 82 00 40 12 add %g1, %l2, %g1
201aeb0: c4 28 60 02 stb %g2, [ %g1 + 2 ]
201aeb4: c2 06 60 40 ld [ %i1 + 0x40 ], %g1
201aeb8: c2 00 60 1c ld [ %g1 + 0x1c ], %g1
201aebc: a4 00 40 12 add %g1, %l2, %l2
201aec0: c2 07 bf f8 ld [ %fp + -8 ], %g1
201aec4: c2 2c a0 03 stb %g1, [ %l2 + 3 ]
201aec8: e8 2e 60 38 stb %l4, [ %i1 + 0x38 ]
}
map->size.count++;
201aecc: c2 06 60 08 ld [ %i1 + 8 ], %g1
map->size.offset = 0;
201aed0: c0 26 60 0c clr [ %i1 + 0xc ]
}
rtems_rfs_block_set_number (&map->singly_buffer, direct, block);
}
map->size.count++;
201aed4: 82 00 60 01 inc %g1
201aed8: c2 26 60 08 st %g1, [ %i1 + 8 ]
map->size.offset = 0;
if (b == 0)
201aedc: 80 a4 20 00 cmp %l0, 0
201aee0: 12 80 00 03 bne 201aeec <rtems_rfs_block_map_grow+0x38c> <== NEVER TAKEN
201aee4: c2 07 bf f8 ld [ %fp + -8 ], %g1
*new_block = block;
201aee8: c2 26 c0 00 st %g1, [ %i3 ]
map->last_data_block = block;
201aeec: c2 26 60 20 st %g1, [ %i1 + 0x20 ]
map->dirty = true;
201aef0: 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++)
201aef4: 10 80 00 05 b 201af08 <rtems_rfs_block_map_grow+0x3a8>
201aef8: a0 04 20 01 inc %l0
return rc;
}
}
}
rtems_rfs_block_set_number (&map->singly_buffer, direct, block);
201aefc: a8 10 20 01 mov 1, %l4
singly,
singly_block);
}
else
{
rc = rtems_rfs_buffer_handle_request (fs,
201af00: 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,
201af04: 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++)
201af08: 80 a4 00 1a cmp %l0, %i2
201af0c: 32 bf ff 2a bne,a 201abb4 <rtems_rfs_block_map_grow+0x54>
201af10: d2 06 60 20 ld [ %i1 + 0x20 ], %o1
*new_block = block;
map->last_data_block = block;
map->dirty = true;
}
return 0;
201af14: b0 10 20 00 clr %i0
}
201af18: 81 c7 e0 08 ret
201af1c: 81 e8 00 00 restore
0201a2dc <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)
{
201a2dc: 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);
201a2e0: d2 06 60 1c ld [ %i1 + 0x1c ], %o1
201a2e4: 90 10 00 18 mov %i0, %o0
201a2e8: 94 10 20 00 clr %o2
201a2ec: 7f ff dd 53 call 2011838 <rtems_rfs_group_bitmap_alloc>
201a2f0: 96 07 bf fc add %fp, -4, %o3
if (rc > 0)
201a2f4: ba 92 20 00 orcc %o0, 0, %i5
201a2f8: 34 80 00 48 bg,a 201a418 <rtems_rfs_block_map_indirect_alloc+0x13c><== NEVER TAKEN
201a2fc: b0 10 00 1d mov %i5, %i0 <== NOT EXECUTED
return rc;
rc = rtems_rfs_buffer_handle_request (fs, buffer, new_block, false);
201a300: d4 07 bf fc ld [ %fp + -4 ], %o2
201a304: 90 10 00 18 mov %i0, %o0
201a308: 92 10 00 1a mov %i2, %o1
201a30c: 40 00 04 a7 call 201b5a8 <rtems_rfs_buffer_handle_request>
201a310: 96 10 20 00 clr %o3
if (rc > 0)
201a314: ba 92 20 00 orcc %o0, 0, %i5
201a318: 04 80 00 07 ble 201a334 <rtems_rfs_block_map_indirect_alloc+0x58><== ALWAYS TAKEN
201a31c: d4 07 bf fc ld [ %fp + -4 ], %o2
{
rtems_rfs_group_bitmap_free (fs, false, new_block);
201a320: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
201a324: 7f ff dd c9 call 2011a48 <rtems_rfs_group_bitmap_free> <== NOT EXECUTED
201a328: 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;
}
201a32c: 81 c7 e0 08 ret <== NOT EXECUTED
201a330: 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));
201a334: c2 06 a0 08 ld [ %i2 + 8 ], %g1
201a338: d4 06 20 08 ld [ %i0 + 8 ], %o2
201a33c: d0 00 60 1c ld [ %g1 + 0x1c ], %o0
201a340: 40 00 1e f0 call 2021f00 <memset>
201a344: 92 10 20 ff mov 0xff, %o1
if (upping)
201a348: 80 a7 20 00 cmp %i4, 0
201a34c: 02 80 00 2d be 201a400 <rtems_rfs_block_map_indirect_alloc+0x124><== NEVER TAKEN
201a350: 82 10 20 01 mov 1, %g1
{
int b;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BLOCK_MAP_GROW))
201a354: 90 10 20 00 clr %o0
201a358: 7f ff e5 1e call 20137d0 <rtems_rfs_trace>
201a35c: 13 00 00 08 sethi %hi(0x2000), %o1
201a360: 80 8a 20 ff btst 0xff, %o0
201a364: 02 80 00 07 be 201a380 <rtems_rfs_block_map_indirect_alloc+0xa4><== ALWAYS TAKEN
201a368: 84 10 00 19 mov %i1, %g2
printf ("rtems-rfs: block-map-grow: upping: block-count=%" PRId32 "\n",
201a36c: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED
201a370: 11 00 80 cd sethi %hi(0x2033400), %o0 <== NOT EXECUTED
201a374: 40 00 1f 61 call 20220f8 <printf> <== NOT EXECUTED
201a378: 90 12 22 e8 or %o0, 0x2e8, %o0 ! 20336e8 <CSWTCH.2+0x8> <== NOT EXECUTED
201a37c: 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)
{
201a380: 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]);
201a384: 86 10 20 01 mov 1, %g3
201a388: c8 06 a0 08 ld [ %i2 + 8 ], %g4
201a38c: fa 08 a0 24 ldub [ %g2 + 0x24 ], %i5
201a390: c8 01 20 1c ld [ %g4 + 0x1c ], %g4
201a394: fa 29 00 01 stb %i5, [ %g4 + %g1 ]
201a398: c8 06 a0 08 ld [ %i2 + 8 ], %g4
201a39c: fa 10 a0 24 lduh [ %g2 + 0x24 ], %i5
201a3a0: c8 01 20 1c ld [ %g4 + 0x1c ], %g4
201a3a4: 88 01 00 01 add %g4, %g1, %g4
201a3a8: fa 29 20 01 stb %i5, [ %g4 + 1 ]
201a3ac: c8 06 a0 08 ld [ %i2 + 8 ], %g4
201a3b0: fa 00 a0 24 ld [ %g2 + 0x24 ], %i5
201a3b4: c8 01 20 1c ld [ %g4 + 0x1c ], %g4
201a3b8: bb 37 60 08 srl %i5, 8, %i5
201a3bc: 88 01 00 01 add %g4, %g1, %g4
201a3c0: fa 29 20 02 stb %i5, [ %g4 + 2 ]
201a3c4: c8 06 a0 08 ld [ %i2 + 8 ], %g4
201a3c8: fa 00 a0 24 ld [ %g2 + 0x24 ], %i5
201a3cc: c8 01 20 1c ld [ %g4 + 0x1c ], %g4
201a3d0: 84 00 a0 04 add %g2, 4, %g2
201a3d4: 88 01 00 01 add %g4, %g1, %g4
201a3d8: fa 29 20 03 stb %i5, [ %g4 + 3 ]
201a3dc: 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++)
201a3e0: 80 a0 60 14 cmp %g1, 0x14
201a3e4: 12 bf ff e9 bne 201a388 <rtems_rfs_block_map_indirect_alloc+0xac>
201a3e8: c6 2e 80 00 stb %g3, [ %i2 ]
rtems_rfs_block_set_number (buffer, b, map->blocks[b]);
memset (map->blocks, 0, sizeof (map->blocks));
201a3ec: 90 06 60 24 add %i1, 0x24, %o0
201a3f0: 92 10 20 00 clr %o1
201a3f4: 40 00 1e c3 call 2021f00 <memset>
201a3f8: 94 10 20 14 mov 0x14, %o2
}
rtems_rfs_buffer_mark_dirty (buffer);
201a3fc: 82 10 20 01 mov 1, %g1
201a400: c2 2e 80 00 stb %g1, [ %i2 ]
*block = new_block;
201a404: c2 07 bf fc ld [ %fp + -4 ], %g1
map->last_map_block = new_block;
return 0;
201a408: 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;
201a40c: c2 26 c0 00 st %g1, [ %i3 ]
map->last_map_block = new_block;
201a410: c2 26 60 1c st %g1, [ %i1 + 0x1c ]
return 0;
}
201a414: b0 10 00 1d mov %i5, %i0
201a418: 81 c7 e0 08 ret
201a41c: 81 e8 00 00 restore
0201a1fc <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)
{
201a1fc: 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) ||
201a200: 80 a7 20 00 cmp %i4, 0
201a204: 02 80 00 09 be 201a228 <rtems_rfs_block_map_indirect_shrink+0x2c><== NEVER TAKEN
201a208: 82 06 e0 08 add %i3, 8, %g1
201a20c: 80 a7 20 05 cmp %i4, 5
201a210: 32 80 00 2f bne,a 201a2cc <rtems_rfs_block_map_indirect_shrink+0xd0>
201a214: b0 10 20 00 clr %i0
201a218: 80 a6 e0 00 cmp %i3, 0
201a21c: 32 80 00 2c bne,a 201a2cc <rtems_rfs_block_map_indirect_shrink+0xd0><== NEVER TAKEN
201a220: 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];
201a224: 82 06 e0 08 add %i3, 8, %g1
if ((indirect == 0) && (index == RTEMS_RFS_INODE_BLOCKS))
201a228: 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];
201a22c: 83 28 60 02 sll %g1, 2, %g1
201a230: 82 06 40 01 add %i1, %g1, %g1
if ((indirect == 0) && (index == RTEMS_RFS_INODE_BLOCKS))
201a234: 12 80 00 1a bne 201a29c <rtems_rfs_block_map_indirect_shrink+0xa0><== NEVER TAKEN
201a238: fa 00 60 04 ld [ %g1 + 4 ], %i5
201a23c: 80 a6 e0 00 cmp %i3, 0
201a240: 32 80 00 18 bne,a 201a2a0 <rtems_rfs_block_map_indirect_shrink+0xa4><== NEVER TAKEN
201a244: 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);
201a248: c2 06 a0 08 ld [ %i2 + 8 ], %g1
201a24c: 84 10 20 00 clr %g2
201a250: c2 00 60 1c ld [ %g1 + 0x1c ], %g1
201a254: f8 08 40 00 ldub [ %g1 ], %i4
201a258: c8 08 60 01 ldub [ %g1 + 1 ], %g4
201a25c: b9 2f 20 18 sll %i4, 0x18, %i4
201a260: 89 29 20 10 sll %g4, 0x10, %g4
201a264: 88 17 00 04 or %i4, %g4, %g4
201a268: 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,
201a26c: 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);
201a270: 88 11 00 1c or %g4, %i4, %g4
201a274: f8 08 60 02 ldub [ %g1 + 2 ], %i4
201a278: 84 00 a0 04 add %g2, 4, %g2
201a27c: b9 2f 20 08 sll %i4, 8, %i4
201a280: 88 11 00 1c or %g4, %i4, %g4
201a284: c8 20 e0 24 st %g4, [ %g3 + 0x24 ]
{
/*
* Move to direct inode access.
*/
int b;
for (b = 0; b < RTEMS_RFS_INODE_BLOCKS; b++)
201a288: 80 a0 a0 14 cmp %g2, 0x14
201a28c: 12 bf ff f2 bne 201a254 <rtems_rfs_block_map_indirect_shrink+0x58>
201a290: 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);
201a294: 10 80 00 07 b 201a2b0 <rtems_rfs_block_map_indirect_shrink+0xb4>
201a298: 90 10 00 18 mov %i0, %o0
else
{
/*
* One less singly indirect block in the inode.
*/
map->blocks[indirect] = 0;
201a29c: b6 06 e0 08 add %i3, 8, %i3 <== NOT EXECUTED
201a2a0: b7 2e e0 02 sll %i3, 2, %i3 <== NOT EXECUTED
201a2a4: b6 06 40 1b add %i1, %i3, %i3 <== NOT EXECUTED
201a2a8: c0 26 e0 04 clr [ %i3 + 4 ] <== NOT EXECUTED
}
rc = rtems_rfs_group_bitmap_free (fs, false, block_to_free);
201a2ac: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
201a2b0: 92 10 20 00 clr %o1
201a2b4: 7f ff dd e5 call 2011a48 <rtems_rfs_group_bitmap_free>
201a2b8: 94 10 00 1d mov %i5, %o2
if (rc > 0)
201a2bc: b0 92 20 00 orcc %o0, 0, %i0
201a2c0: 14 80 00 05 bg 201a2d4 <rtems_rfs_block_map_indirect_shrink+0xd8><== NEVER TAKEN
201a2c4: 01 00 00 00 nop
return rc;
map->last_map_block = block_to_free;
201a2c8: fa 26 60 1c st %i5, [ %i1 + 0x1c ]
201a2cc: 81 c7 e0 08 ret
201a2d0: 81 e8 00 00 restore
}
return rc;
}
201a2d4: 81 c7 e0 08 ret <== NOT EXECUTED
201a2d8: 81 e8 00 00 restore <== NOT EXECUTED
0201a5f4 <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)
{
201a5f4: 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;
201a5f8: c0 2e 80 00 clrb [ %i2 ]
map->inode = NULL;
201a5fc: 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;
201a600: c0 26 a0 08 clr [ %i2 + 8 ]
size->offset = 0;
201a604: 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;
201a608: c0 26 a0 10 clr [ %i2 + 0x10 ]
bpos->boff = 0;
201a60c: c0 26 a0 14 clr [ %i2 + 0x14 ]
bpos->block = 0;
201a610: 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;
201a614: c0 2e a0 38 clrb [ %i2 + 0x38 ]
handle->bnum = 0;
201a618: c0 26 a0 3c clr [ %i2 + 0x3c ]
handle->buffer = NULL;
201a61c: 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;
201a620: c0 2e a0 44 clrb [ %i2 + 0x44 ]
handle->bnum = 0;
201a624: c0 26 a0 48 clr [ %i2 + 0x48 ]
handle->buffer = NULL;
201a628: 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);
201a62c: 90 10 00 18 mov %i0, %o0
201a630: 7f ff dd aa call 2011cd8 <rtems_rfs_inode_load>
201a634: 92 10 00 19 mov %i1, %o1
if (rc > 0)
201a638: ba 92 20 00 orcc %o0, 0, %i5
201a63c: 14 80 00 40 bg 201a73c <rtems_rfs_block_map_open+0x148> <== NEVER TAKEN
201a640: 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]);
201a644: 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;
201a648: f2 26 a0 04 st %i1, [ %i2 + 4 ]
201a64c: 88 00 a0 06 add %g2, 6, %g4
201a650: 89 29 20 02 sll %g4, 2, %g4
201a654: 88 00 40 04 add %g1, %g4, %g4
201a658: 86 01 20 04 add %g4, 4, %g3
201a65c: f8 09 20 04 ldub [ %g4 + 4 ], %i4
201a660: c8 09 20 05 ldub [ %g4 + 5 ], %g4
201a664: b9 2f 20 18 sll %i4, 0x18, %i4
201a668: 89 29 20 10 sll %g4, 0x10, %g4
201a66c: b8 17 00 04 or %i4, %g4, %i4
201a670: 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,
201a674: bb 28 a0 02 sll %g2, 2, %i5
201a678: b8 17 00 04 or %i4, %g4, %i4
201a67c: c8 08 e0 02 ldub [ %g3 + 2 ], %g4
201a680: ba 06 80 1d add %i2, %i5, %i5
201a684: 89 29 20 08 sll %g4, 8, %g4
201a688: 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++)
201a68c: 84 00 a0 01 inc %g2
201a690: 80 a0 a0 05 cmp %g2, 5
201a694: 12 bf ff ee bne 201a64c <rtems_rfs_block_map_open+0x58>
201a698: 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);
201a69c: c6 08 60 0c ldub [ %g1 + 0xc ], %g3
201a6a0: c4 08 60 0d ldub [ %g1 + 0xd ], %g2
201a6a4: 87 28 e0 18 sll %g3, 0x18, %g3
201a6a8: 85 28 a0 10 sll %g2, 0x10, %g2
201a6ac: 84 10 c0 02 or %g3, %g2, %g2
201a6b0: c6 08 60 0f ldub [ %g1 + 0xf ], %g3
201a6b4: 84 10 80 03 or %g2, %g3, %g2
201a6b8: c6 08 60 0e ldub [ %g1 + 0xe ], %g3
201a6bc: 87 28 e0 08 sll %g3, 8, %g3
201a6c0: 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);
201a6c4: c4 26 a0 08 st %g2, [ %i2 + 8 ]
map->size.offset = rtems_rfs_inode_get_block_offset (inode);
201a6c8: 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);
201a6cc: c4 08 60 0a ldub [ %g1 + 0xa ], %g2
201a6d0: 85 28 a0 08 sll %g2, 8, %g2
201a6d4: 84 10 c0 02 or %g3, %g2, %g2
201a6d8: 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);
201a6dc: c6 08 60 30 ldub [ %g1 + 0x30 ], %g3
201a6e0: c4 08 60 31 ldub [ %g1 + 0x31 ], %g2
201a6e4: 87 28 e0 18 sll %g3, 0x18, %g3
201a6e8: 85 28 a0 10 sll %g2, 0x10, %g2
201a6ec: 84 10 c0 02 or %g3, %g2, %g2
201a6f0: c6 08 60 33 ldub [ %g1 + 0x33 ], %g3
201a6f4: 84 10 80 03 or %g2, %g3, %g2
201a6f8: c6 08 60 32 ldub [ %g1 + 0x32 ], %g3
201a6fc: 87 28 e0 08 sll %g3, 8, %g3
201a700: 84 10 80 03 or %g2, %g3, %g2
map->last_map_block = rtems_rfs_inode_get_last_map_block (inode);
201a704: 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);
201a708: c4 08 60 35 ldub [ %g1 + 0x35 ], %g2
201a70c: c6 08 60 34 ldub [ %g1 + 0x34 ], %g3
201a710: 85 28 a0 10 sll %g2, 0x10, %g2
201a714: 87 28 e0 18 sll %g3, 0x18, %g3
201a718: 86 10 c0 02 or %g3, %g2, %g3
201a71c: c4 08 60 37 ldub [ %g1 + 0x37 ], %g2
201a720: 86 10 c0 02 or %g3, %g2, %g3
201a724: c4 08 60 36 ldub [ %g1 + 0x36 ], %g2
201a728: 85 28 a0 08 sll %g2, 8, %g2
201a72c: 82 10 c0 02 or %g3, %g2, %g1
map->last_data_block = rtems_rfs_inode_get_last_data_block (inode);
201a730: c2 26 a0 20 st %g1, [ %i2 + 0x20 ]
rc = rtems_rfs_inode_unload (fs, inode, false);
201a734: 7f ff dd cc call 2011e64 <rtems_rfs_inode_unload>
201a738: 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);
201a73c: 92 06 a0 38 add %i2, 0x38, %o1 <== NOT EXECUTED
201a740: 40 00 03 26 call 201b3d8 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
201a744: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
201a748: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
handle->dirty = false;
201a74c: c0 2e a0 38 clrb [ %i2 + 0x38 ] <== NOT EXECUTED
handle->bnum = 0;
201a750: c0 26 a0 3c clr [ %i2 + 0x3c ] <== NOT EXECUTED
handle->buffer = NULL;
201a754: 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);
201a758: 92 06 a0 44 add %i2, 0x44, %o1 <== NOT EXECUTED
201a75c: 40 00 03 1f call 201b3d8 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
201a760: b0 10 00 1d mov %i5, %i0 <== NOT EXECUTED
handle->dirty = false;
201a764: c0 2e a0 44 clrb [ %i2 + 0x44 ] <== NOT EXECUTED
handle->bnum = 0;
201a768: c0 26 a0 48 clr [ %i2 + 0x48 ] <== NOT EXECUTED
handle->buffer = NULL;
201a76c: c0 26 a0 4c clr [ %i2 + 0x4c ] <== NOT EXECUTED
return rc;
}
201a770: 81 c7 e0 08 ret <== NOT EXECUTED
201a774: 81 e8 00 00 restore <== NOT EXECUTED
0201af20 <rtems_rfs_block_map_shrink>:
int
rtems_rfs_block_map_shrink (rtems_rfs_file_system* fs,
rtems_rfs_block_map* map,
size_t blocks)
{
201af20: 9d e3 bf a0 save %sp, -96, %sp
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BLOCK_MAP_SHRINK))
201af24: 90 10 20 00 clr %o0
201af28: 7f ff e2 2a call 20137d0 <rtems_rfs_trace>
201af2c: 13 00 00 10 sethi %hi(0x4000), %o1
201af30: 80 8a 20 ff btst 0xff, %o0
201af34: 22 80 00 08 be,a 201af54 <rtems_rfs_block_map_shrink+0x34><== ALWAYS TAKEN
201af38: c2 06 60 08 ld [ %i1 + 8 ], %g1
printf ("rtems-rfs: block-map-shrink: entry: blocks=%zd count=%" PRIu32 "\n",
201af3c: d4 06 60 08 ld [ %i1 + 8 ], %o2 <== NOT EXECUTED
201af40: 11 00 80 cd sethi %hi(0x2033400), %o0 <== NOT EXECUTED
201af44: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED
201af48: 40 00 1c 6c call 20220f8 <printf> <== NOT EXECUTED
201af4c: 90 12 23 a8 or %o0, 0x3a8, %o0 <== NOT EXECUTED
blocks, map->size.count);
if (map->size.count == 0)
201af50: c2 06 60 08 ld [ %i1 + 8 ], %g1 <== NOT EXECUTED
201af54: 80 a0 60 00 cmp %g1, 0
201af58: 12 80 00 04 bne 201af68 <rtems_rfs_block_map_shrink+0x48>
201af5c: 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;
201af60: 10 80 00 b8 b 201b240 <rtems_rfs_block_map_shrink+0x320>
201af64: 90 10 20 00 clr %o0
201af68: 38 80 00 90 bgu,a 201b1a8 <rtems_rfs_block_map_shrink+0x288><== NEVER TAKEN
201af6c: 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,
201af70: 10 80 00 8f b 201b1ac <rtems_rfs_block_map_shrink+0x28c>
201af74: 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;
201af78: ba 00 7f ff add %g1, -1, %i5
if (block < RTEMS_RFS_INODE_BLOCKS)
201af7c: 80 a7 60 04 cmp %i5, 4
201af80: 38 80 00 08 bgu,a 201afa0 <rtems_rfs_block_map_shrink+0x80>
201af84: 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];
201af88: 82 00 60 07 add %g1, 7, %g1
201af8c: 83 28 60 02 sll %g1, 2, %g1
201af90: 82 06 40 01 add %i1, %g1, %g1
201af94: fa 00 60 04 ld [ %g1 + 4 ], %i5
map->blocks[block] = 0;
201af98: 10 80 00 76 b 201b170 <rtems_rfs_block_map_shrink+0x250>
201af9c: 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;
201afa0: 90 10 00 1d mov %i5, %o0
201afa4: 40 00 4c f3 call 202e370 <.urem>
201afa8: 92 10 00 1b mov %i3, %o1
singly = block / fs->blocks_per_block;
201afac: 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;
201afb0: b8 10 00 08 mov %o0, %i4
singly = block / fs->blocks_per_block;
201afb4: 7f ff 9d b2 call 200267c <.udiv>
201afb8: 90 10 00 1d mov %i5, %o0
if (block < fs->block_map_singly_blocks)
201afbc: c2 06 20 38 ld [ %i0 + 0x38 ], %g1
201afc0: 80 a7 40 01 cmp %i5, %g1
201afc4: 1a 80 00 20 bcc 201b044 <rtems_rfs_block_map_shrink+0x124><== NEVER TAKEN
201afc8: 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,
201afcc: 82 02 20 08 add %o0, 8, %g1
201afd0: 83 28 60 02 sll %g1, 2, %g1
201afd4: 82 06 40 01 add %i1, %g1, %g1
201afd8: d4 00 60 04 ld [ %g1 + 4 ], %o2
201afdc: 90 10 00 18 mov %i0, %o0
201afe0: 92 10 00 10 mov %l0, %o1
201afe4: 40 00 01 71 call 201b5a8 <rtems_rfs_buffer_handle_request>
201afe8: 96 10 20 01 mov 1, %o3
map->blocks[singly], true);
if (rc > 0)
201afec: 80 a2 20 00 cmp %o0, 0
201aff0: 14 80 00 94 bg 201b240 <rtems_rfs_block_map_shrink+0x320> <== NEVER TAKEN
201aff4: 85 2f 20 02 sll %i4, 2, %g2
return rc;
block_to_free = rtems_rfs_block_get_number (&map->singly_buffer,
201aff8: c2 06 60 40 ld [ %i1 + 0x40 ], %g1
201affc: c6 00 60 1c ld [ %g1 + 0x1c ], %g3
direct);
rc = rtems_rfs_block_map_indirect_shrink (fs, map, &map->singly_buffer,
201b000: 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,
201b004: 82 00 c0 02 add %g3, %g2, %g1
201b008: fa 08 c0 02 ldub [ %g3 + %g2 ], %i5
201b00c: c8 08 60 03 ldub [ %g1 + 3 ], %g4
201b010: c4 08 60 01 ldub [ %g1 + 1 ], %g2
201b014: c2 08 60 02 ldub [ %g1 + 2 ], %g1
201b018: bb 2f 60 18 sll %i5, 0x18, %i5
201b01c: 85 28 a0 10 sll %g2, 0x10, %g2
201b020: ba 11 00 1d or %g4, %i5, %i5
201b024: 83 28 60 08 sll %g1, 8, %g1
201b028: ba 17 40 02 or %i5, %g2, %i5
direct);
rc = rtems_rfs_block_map_indirect_shrink (fs, map, &map->singly_buffer,
201b02c: 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,
201b030: ba 17 40 01 or %i5, %g1, %i5
direct);
rc = rtems_rfs_block_map_indirect_shrink (fs, map, &map->singly_buffer,
201b034: 94 10 00 10 mov %l0, %o2
201b038: 96 10 00 11 mov %l1, %o3
201b03c: 10 80 00 48 b 201b15c <rtems_rfs_block_map_shrink+0x23c>
201b040: 98 10 00 1c mov %i4, %o4
singly, direct);
if (rc)
return rc;
}
else if (block < fs->block_map_doubly_blocks)
201b044: c2 06 20 3c ld [ %i0 + 0x3c ], %g1 <== NOT EXECUTED
201b048: 80 a7 40 01 cmp %i5, %g1 <== NOT EXECUTED
201b04c: 3a 80 00 5d bcc,a 201b1c0 <rtems_rfs_block_map_shrink+0x2a0><== NOT EXECUTED
201b050: 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;
201b054: 7f ff 9d 8a call 200267c <.udiv> <== NOT EXECUTED
201b058: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
doubly_singly = singly % fs->blocks_per_block;
201b05c: 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;
201b060: a8 10 00 08 mov %o0, %l4 <== NOT EXECUTED
doubly_singly = singly % fs->blocks_per_block;
201b064: 40 00 4c c3 call 202e370 <.urem> <== NOT EXECUTED
201b068: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED
rc = rtems_rfs_buffer_handle_request (fs, &map->doubly_buffer,
201b06c: 82 05 20 08 add %l4, 8, %g1 <== NOT EXECUTED
201b070: 83 28 60 02 sll %g1, 2, %g1 <== NOT EXECUTED
201b074: 82 06 40 01 add %i1, %g1, %g1 <== NOT EXECUTED
201b078: 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;
201b07c: a2 10 00 08 mov %o0, %l1 <== NOT EXECUTED
rc = rtems_rfs_buffer_handle_request (fs, &map->doubly_buffer,
201b080: 92 10 00 12 mov %l2, %o1 <== NOT EXECUTED
201b084: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
201b088: 40 00 01 48 call 201b5a8 <rtems_rfs_buffer_handle_request><== NOT EXECUTED
201b08c: 96 10 20 01 mov 1, %o3 <== NOT EXECUTED
map->blocks[doubly], true);
if (rc > 0)
201b090: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
201b094: 14 80 00 6b bg 201b240 <rtems_rfs_block_map_shrink+0x320> <== NOT EXECUTED
201b098: 85 2c 60 02 sll %l1, 2, %g2 <== NOT EXECUTED
return rc;
singly = rtems_rfs_block_get_number (&map->doubly_buffer,
201b09c: c2 06 60 4c ld [ %i1 + 0x4c ], %g1 <== NOT EXECUTED
201b0a0: 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,
201b0a4: 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,
201b0a8: 82 00 c0 02 add %g3, %g2, %g1 <== NOT EXECUTED
201b0ac: f6 08 c0 02 ldub [ %g3 + %g2 ], %i3 <== NOT EXECUTED
201b0b0: c8 08 60 03 ldub [ %g1 + 3 ], %g4 <== NOT EXECUTED
201b0b4: c4 08 60 01 ldub [ %g1 + 1 ], %g2 <== NOT EXECUTED
201b0b8: c2 08 60 02 ldub [ %g1 + 2 ], %g1 <== NOT EXECUTED
201b0bc: 85 28 a0 10 sll %g2, 0x10, %g2 <== NOT EXECUTED
201b0c0: 83 28 60 08 sll %g1, 8, %g1 <== NOT EXECUTED
201b0c4: 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,
201b0c8: 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,
201b0cc: 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,
201b0d0: 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,
201b0d4: b6 16 c0 02 or %i3, %g2, %i3 <== NOT EXECUTED
201b0d8: 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,
201b0dc: 40 00 01 33 call 201b5a8 <rtems_rfs_buffer_handle_request><== NOT EXECUTED
201b0e0: 94 10 00 1b mov %i3, %o2 <== NOT EXECUTED
singly, true);
if (rc > 0)
201b0e4: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
201b0e8: 14 80 00 56 bg 201b240 <rtems_rfs_block_map_shrink+0x320> <== NOT EXECUTED
201b0ec: 85 2f 20 02 sll %i4, 2, %g2 <== NOT EXECUTED
return rc;
block_to_free = rtems_rfs_block_get_number (&map->singly_buffer,
201b0f0: c2 06 60 40 ld [ %i1 + 0x40 ], %g1 <== NOT EXECUTED
201b0f4: c6 00 60 1c ld [ %g1 + 0x1c ], %g3 <== NOT EXECUTED
direct);
if (direct == 0)
201b0f8: 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,
201b0fc: 82 00 c0 02 add %g3, %g2, %g1 <== NOT EXECUTED
201b100: fa 08 c0 02 ldub [ %g3 + %g2 ], %i5 <== NOT EXECUTED
201b104: c8 08 60 03 ldub [ %g1 + 3 ], %g4 <== NOT EXECUTED
201b108: c4 08 60 01 ldub [ %g1 + 1 ], %g2 <== NOT EXECUTED
201b10c: c2 08 60 02 ldub [ %g1 + 2 ], %g1 <== NOT EXECUTED
201b110: bb 2f 60 18 sll %i5, 0x18, %i5 <== NOT EXECUTED
201b114: 85 28 a0 10 sll %g2, 0x10, %g2 <== NOT EXECUTED
201b118: ba 11 00 1d or %g4, %i5, %i5 <== NOT EXECUTED
201b11c: 83 28 60 08 sll %g1, 8, %g1 <== NOT EXECUTED
201b120: ba 17 40 02 or %i5, %g2, %i5 <== NOT EXECUTED
direct);
if (direct == 0)
201b124: 12 80 00 13 bne 201b170 <rtems_rfs_block_map_shrink+0x250><== NOT EXECUTED
201b128: ba 17 40 01 or %i5, %g1, %i5 <== NOT EXECUTED
{
rc = rtems_rfs_group_bitmap_free (fs, false, singly);
201b12c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
201b130: 92 10 20 00 clr %o1 <== NOT EXECUTED
201b134: 7f ff da 45 call 2011a48 <rtems_rfs_group_bitmap_free> <== NOT EXECUTED
201b138: 94 10 00 1b mov %i3, %o2 <== NOT EXECUTED
if (rc > 0)
201b13c: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
201b140: 14 80 00 40 bg 201b240 <rtems_rfs_block_map_shrink+0x320> <== NOT EXECUTED
201b144: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
return rc;
map->last_map_block = singly;
201b148: f6 26 60 1c st %i3, [ %i1 + 0x1c ] <== NOT EXECUTED
rc = rtems_rfs_block_map_indirect_shrink (fs, map, &map->doubly_buffer,
201b14c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
201b150: 94 10 00 12 mov %l2, %o2 <== NOT EXECUTED
201b154: 96 10 00 14 mov %l4, %o3 <== NOT EXECUTED
201b158: 98 10 00 11 mov %l1, %o4 <== NOT EXECUTED
201b15c: 7f ff fc 28 call 201a1fc <rtems_rfs_block_map_indirect_shrink>
201b160: 01 00 00 00 nop
doubly, doubly_singly);
if (rc)
201b164: 80 a2 20 00 cmp %o0, 0
201b168: 12 80 00 36 bne 201b240 <rtems_rfs_block_map_shrink+0x320><== NEVER TAKEN
201b16c: 01 00 00 00 nop
{
rc = EIO;
break;
}
}
rc = rtems_rfs_group_bitmap_free (fs, false, block_to_free);
201b170: 90 10 00 18 mov %i0, %o0
201b174: 92 10 20 00 clr %o1
201b178: 7f ff da 34 call 2011a48 <rtems_rfs_group_bitmap_free>
201b17c: 94 10 00 1d mov %i5, %o2
if (rc > 0)
201b180: 80 a2 20 00 cmp %o0, 0
201b184: 14 80 00 2f bg 201b240 <rtems_rfs_block_map_shrink+0x320> <== NEVER TAKEN
201b188: b4 06 bf ff add %i2, -1, %i2
return rc;
map->size.count--;
201b18c: c2 06 60 08 ld [ %i1 + 8 ], %g1
map->size.offset = 0;
201b190: 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--;
201b194: 82 00 7f ff add %g1, -1, %g1
map->size.offset = 0;
map->last_data_block = block_to_free;
201b198: 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--;
201b19c: c2 26 60 08 st %g1, [ %i1 + 8 ]
map->size.offset = 0;
map->last_data_block = block_to_free;
map->dirty = true;
201b1a0: 10 80 00 05 b 201b1b4 <rtems_rfs_block_map_shrink+0x294>
201b1a4: 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,
201b1a8: 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,
201b1ac: 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;
201b1b0: a6 10 20 01 mov 1, %l3
return 0;
if (blocks > map->size.count)
blocks = map->size.count;
while (blocks)
201b1b4: 80 a6 a0 00 cmp %i2, 0
201b1b8: 12 bf ff 70 bne 201af78 <rtems_rfs_block_map_shrink+0x58>
201b1bc: c2 06 60 08 ld [ %i1 + 8 ], %g1
map->last_data_block = block_to_free;
map->dirty = true;
blocks--;
}
if (map->size.count == 0)
201b1c0: 80 a0 60 00 cmp %g1, 0
201b1c4: 32 80 00 05 bne,a 201b1d8 <rtems_rfs_block_map_shrink+0x2b8>
201b1c8: c4 06 60 10 ld [ %i1 + 0x10 ], %g2
{
map->last_map_block = 0;
201b1cc: c0 26 60 1c clr [ %i1 + 0x1c ]
map->last_data_block = 0;
201b1d0: c0 26 60 20 clr [ %i1 + 0x20 ]
}
/*
* Keep the position inside the map.
*/
if (rtems_rfs_block_pos_past_end (&map->bpos, &map->size))
201b1d4: c4 06 60 10 ld [ %i1 + 0x10 ], %g2
201b1d8: 80 a0 a0 00 cmp %g2, 0
201b1dc: 02 80 00 06 be 201b1f4 <rtems_rfs_block_map_shrink+0x2d4>
201b1e0: 80 a0 80 01 cmp %g2, %g1
201b1e4: 80 a0 60 00 cmp %g1, 0
201b1e8: 22 80 00 0e be,a 201b220 <rtems_rfs_block_map_shrink+0x300><== ALWAYS TAKEN
201b1ec: c4 06 60 0c ld [ %i1 + 0xc ], %g2
201b1f0: 80 a0 80 01 cmp %g2, %g1 <== NOT EXECUTED
201b1f4: 3a 80 00 0b bcc,a 201b220 <rtems_rfs_block_map_shrink+0x300>
201b1f8: c4 06 60 0c ld [ %i1 + 0xc ], %g2
201b1fc: 86 00 7f ff add %g1, -1, %g3
201b200: 80 a0 80 03 cmp %g2, %g3
201b204: 12 80 00 0f bne 201b240 <rtems_rfs_block_map_shrink+0x320><== NEVER TAKEN
201b208: 90 10 20 00 clr %o0
201b20c: c6 06 60 14 ld [ %i1 + 0x14 ], %g3
201b210: c4 06 60 0c ld [ %i1 + 0xc ], %g2
201b214: 80 a0 c0 02 cmp %g3, %g2
201b218: 08 80 00 0a bleu 201b240 <rtems_rfs_block_map_shrink+0x320><== NEVER TAKEN
201b21c: 01 00 00 00 nop
rtems_rfs_block_size_get_bpos (&map->size, &map->bpos);
201b220: c2 26 60 10 st %g1, [ %i1 + 0x10 ]
201b224: c4 26 60 14 st %g2, [ %i1 + 0x14 ]
201b228: 80 a0 a0 00 cmp %g2, 0
201b22c: 02 80 00 04 be 201b23c <rtems_rfs_block_map_shrink+0x31c> <== ALWAYS TAKEN
201b230: c0 26 60 18 clr [ %i1 + 0x18 ]
201b234: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED
201b238: c2 26 60 10 st %g1, [ %i1 + 0x10 ] <== NOT EXECUTED
return 0;
201b23c: 90 10 20 00 clr %o0
}
201b240: 81 c7 e0 08 ret
201b244: 91 e8 00 08 restore %g0, %o0, %o0
0202075c <rtems_rfs_buffer_bdbuf_release>:
int
rtems_rfs_buffer_bdbuf_release (rtems_rfs_buffer* buffer,
bool modified)
{
202075c: 9d e3 bf a0 save %sp, -96, %sp
rtems_status_code sc;
int rc = 0;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_RELEASE))
2020760: 90 10 20 00 clr %o0
2020764: 7f ff cc 1b call 20137d0 <rtems_rfs_trace>
2020768: 92 10 20 40 mov 0x40, %o1
202076c: 80 8a 20 ff btst 0xff, %o0
2020770: 02 80 00 0e be 20207a8 <rtems_rfs_buffer_bdbuf_release+0x4c><== ALWAYS TAKEN
2020774: 80 a6 60 00 cmp %i1, 0
printf ("rtems-rfs: bdbuf-release: block=%" PRIuPTR " bdbuf=%" PRIu32 " %s\n",
2020778: d2 06 20 34 ld [ %i0 + 0x34 ], %o1 <== NOT EXECUTED
202077c: 02 80 00 05 be 2020790 <rtems_rfs_buffer_bdbuf_release+0x34><== NOT EXECUTED
2020780: d4 06 20 18 ld [ %i0 + 0x18 ], %o2 <== NOT EXECUTED
2020784: 17 00 80 d3 sethi %hi(0x2034c00), %o3 <== NOT EXECUTED
2020788: 10 80 00 04 b 2020798 <rtems_rfs_buffer_bdbuf_release+0x3c><== NOT EXECUTED
202078c: 96 12 e3 a8 or %o3, 0x3a8, %o3 ! 2034fa8 <rtems_termios_baud_table+0x100><== NOT EXECUTED
2020790: 17 00 80 c3 sethi %hi(0x2030c00), %o3 <== NOT EXECUTED
2020794: 96 12 e1 18 or %o3, 0x118, %o3 ! 2030d18 <__FUNCTION__.7059+0x4f8><== NOT EXECUTED
2020798: 11 00 80 d3 sethi %hi(0x2034c00), %o0 <== NOT EXECUTED
202079c: 40 00 06 57 call 20220f8 <printf> <== NOT EXECUTED
20207a0: 90 12 23 b8 or %o0, 0x3b8, %o0 ! 2034fb8 <rtems_termios_baud_table+0x110><== NOT EXECUTED
((intptr_t) buffer->user),
buffer->block, modified ? "(modified)" : "");
if (modified)
20207a4: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED
20207a8: 02 80 00 06 be 20207c0 <rtems_rfs_buffer_bdbuf_release+0x64>
20207ac: 90 10 00 18 mov %i0, %o0
sc = rtems_bdbuf_release_modified (buffer);
20207b0: 7f ff d5 0d call 2015be4 <rtems_bdbuf_release_modified>
20207b4: 01 00 00 00 nop
int
rtems_rfs_buffer_bdbuf_release (rtems_rfs_buffer* buffer,
bool modified)
{
rtems_status_code sc;
int rc = 0;
20207b8: 10 80 00 05 b 20207cc <rtems_rfs_buffer_bdbuf_release+0x70>
20207bc: 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);
20207c0: 7f ff d4 d4 call 2015b10 <rtems_bdbuf_release>
20207c4: 01 00 00 00 nop
int
rtems_rfs_buffer_bdbuf_release (rtems_rfs_buffer* buffer,
bool modified)
{
rtems_status_code sc;
int rc = 0;
20207c8: 80 a0 00 08 cmp %g0, %o0
20207cc: b0 60 20 00 subx %g0, 0, %i0
#endif
rc = EIO;
}
return rc;
}
20207d0: b0 0e 20 05 and %i0, 5, %i0
20207d4: 81 c7 e0 08 ret
20207d8: 81 e8 00 00 restore
0201bbac <rtems_rfs_buffer_close>:
return 0;
}
int
rtems_rfs_buffer_close (rtems_rfs_file_system* fs)
{
201bbac: 9d e3 bf a0 save %sp, -96, %sp
int rc = 0;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CLOSE))
201bbb0: 90 10 20 00 clr %o0
201bbb4: 7f ff df 07 call 20137d0 <rtems_rfs_trace>
201bbb8: 92 10 20 10 mov 0x10, %o1
201bbbc: 80 8a 20 ff btst 0xff, %o0
201bbc0: 22 80 00 06 be,a 201bbd8 <rtems_rfs_buffer_close+0x2c> <== ALWAYS TAKEN
201bbc4: c2 06 20 10 ld [ %i0 + 0x10 ], %g1
printf ("rtems-rfs: buffer-close: closing\n");
201bbc8: 11 00 80 cf sethi %hi(0x2033c00), %o0 <== NOT EXECUTED
201bbcc: 40 00 19 e3 call 2022358 <puts> <== NOT EXECUTED
201bbd0: 90 12 20 80 or %o0, 0x80, %o0 ! 2033c80 <CSWTCH.2+0x5a0> <== 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));
201bbd4: c2 06 20 10 ld [ %i0 + 0x10 ], %g1 <== NOT EXECUTED
201bbd8: 90 10 00 18 mov %i0, %o0
201bbdc: 7f ff ff b9 call 201bac0 <rtems_rfs_buffer_setblksize>
201bbe0: d2 00 60 20 ld [ %g1 + 0x20 ], %o1
if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CLOSE))
201bbe4: ba 92 20 00 orcc %o0, 0, %i5
201bbe8: 04 80 00 0e ble 201bc20 <rtems_rfs_buffer_close+0x74> <== ALWAYS TAKEN
201bbec: 90 10 20 00 clr %o0
201bbf0: 7f ff de f8 call 20137d0 <rtems_rfs_trace> <== NOT EXECUTED
201bbf4: 92 10 20 10 mov 0x10, %o1 <== NOT EXECUTED
201bbf8: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
201bbfc: 02 80 00 09 be 201bc20 <rtems_rfs_buffer_close+0x74> <== NOT EXECUTED
201bc00: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: buffer-close: set media block size failed: %d: %s\n",
201bc04: 40 00 1d ac call 20232b4 <strerror> <== NOT EXECUTED
201bc08: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
201bc0c: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
201bc10: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
201bc14: 11 00 80 cf sethi %hi(0x2033c00), %o0 <== NOT EXECUTED
201bc18: 40 00 19 38 call 20220f8 <printf> <== NOT EXECUTED
201bc1c: 90 12 20 a8 or %o0, 0xa8, %o0 ! 2033ca8 <CSWTCH.2+0x5c8> <== NOT EXECUTED
rc, strerror (rc));
if (close (fs->device) < 0)
201bc20: 7f ff b0 c4 call 2007f30 <close>
201bc24: d0 06 20 0c ld [ %i0 + 0xc ], %o0
201bc28: 80 a2 20 00 cmp %o0, 0
201bc2c: 16 80 00 12 bge 201bc74 <rtems_rfs_buffer_close+0xc8> <== ALWAYS TAKEN
201bc30: 01 00 00 00 nop
{
rc = errno;
201bc34: 40 00 13 e2 call 2020bbc <__errno> <== NOT EXECUTED
201bc38: 01 00 00 00 nop <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CLOSE))
201bc3c: 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;
201bc40: fa 02 00 00 ld [ %o0 ], %i5 <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CLOSE))
201bc44: 7f ff de e3 call 20137d0 <rtems_rfs_trace> <== NOT EXECUTED
201bc48: 90 10 20 00 clr %o0 <== NOT EXECUTED
201bc4c: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
201bc50: 02 80 00 09 be 201bc74 <rtems_rfs_buffer_close+0xc8> <== NOT EXECUTED
201bc54: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: buffer-close: file close failed: %d: %s\n",
201bc58: 40 00 1d 97 call 20232b4 <strerror> <== NOT EXECUTED
201bc5c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
201bc60: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
201bc64: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
201bc68: 11 00 80 cf sethi %hi(0x2033c00), %o0 <== NOT EXECUTED
201bc6c: 40 00 19 23 call 20220f8 <printf> <== NOT EXECUTED
201bc70: 90 12 20 e8 or %o0, 0xe8, %o0 ! 2033ce8 <CSWTCH.2+0x608> <== NOT EXECUTED
rc, strerror (rc));
}
return rc;
}
201bc74: 81 c7 e0 08 ret
201bc78: 91 e8 00 1d restore %g0, %i5, %o0
0201b3d8 <rtems_rfs_buffer_handle_release>:
}
int
rtems_rfs_buffer_handle_release (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
201b3d8: 9d e3 bf a0 save %sp, -96, %sp
int rc = 0;
if (rtems_rfs_buffer_handle_has_block (handle))
201b3dc: c2 06 60 08 ld [ %i1 + 8 ], %g1
}
int
rtems_rfs_buffer_handle_release (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
201b3e0: ba 10 00 18 mov %i0, %i5
int rc = 0;
if (rtems_rfs_buffer_handle_has_block (handle))
201b3e4: 80 a0 60 00 cmp %g1, 0
201b3e8: 02 80 00 6e be 201b5a0 <rtems_rfs_buffer_handle_release+0x1c8>
201b3ec: b0 10 20 00 clr %i0
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_RELEASE))
201b3f0: 90 10 20 00 clr %o0
201b3f4: 7f ff e0 f7 call 20137d0 <rtems_rfs_trace>
201b3f8: 92 10 22 00 mov 0x200, %o1
201b3fc: 80 8a 20 ff btst 0xff, %o0
201b400: 22 80 00 18 be,a 201b460 <rtems_rfs_buffer_handle_release+0x88><== ALWAYS TAKEN
201b404: d0 06 60 08 ld [ %i1 + 8 ], %o0
printf ("rtems-rfs: buffer-release: block=%" PRIu32 " %s refs=%d %s\n",
201b408: c2 0e 40 00 ldub [ %i1 ], %g1 <== NOT EXECUTED
201b40c: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
201b410: 02 80 00 05 be 201b424 <rtems_rfs_buffer_handle_release+0x4c><== NOT EXECUTED
201b414: d2 06 60 04 ld [ %i1 + 4 ], %o1 <== NOT EXECUTED
201b418: 15 00 80 ce sethi %hi(0x2033800), %o2 <== NOT EXECUTED
201b41c: 10 80 00 04 b 201b42c <rtems_rfs_buffer_handle_release+0x54><== NOT EXECUTED
201b420: 94 12 a0 70 or %o2, 0x70, %o2 ! 2033870 <CSWTCH.2+0x190> <== NOT EXECUTED
201b424: 15 00 80 c3 sethi %hi(0x2030c00), %o2 <== NOT EXECUTED
201b428: 94 12 a1 18 or %o2, 0x118, %o2 ! 2030d18 <__FUNCTION__.7059+0x4f8><== 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" : "");
201b42c: c2 06 60 08 ld [ %i1 + 8 ], %g1 <== NOT EXECUTED
201b430: 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",
201b434: 80 a2 e0 00 cmp %o3, 0 <== NOT EXECUTED
201b438: 32 80 00 05 bne,a 201b44c <rtems_rfs_buffer_handle_release+0x74><== NOT EXECUTED
201b43c: 19 00 80 c3 sethi %hi(0x2030c00), %o4 <== NOT EXECUTED
201b440: 19 00 80 ce sethi %hi(0x2033800), %o4 <== NOT EXECUTED
201b444: 10 80 00 03 b 201b450 <rtems_rfs_buffer_handle_release+0x78><== NOT EXECUTED
201b448: 98 13 20 78 or %o4, 0x78, %o4 ! 2033878 <CSWTCH.2+0x198> <== NOT EXECUTED
201b44c: 98 13 21 18 or %o4, 0x118, %o4 <== NOT EXECUTED
201b450: 11 00 80 ce sethi %hi(0x2033800), %o0 <== NOT EXECUTED
201b454: 40 00 1b 29 call 20220f8 <printf> <== NOT EXECUTED
201b458: 90 12 20 88 or %o0, 0x88, %o0 ! 2033888 <CSWTCH.2+0x1a8> <== 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)
201b45c: d0 06 60 08 ld [ %i1 + 8 ], %o0 <== NOT EXECUTED
201b460: c2 02 20 30 ld [ %o0 + 0x30 ], %g1
201b464: 80 a0 60 00 cmp %g1, 0
201b468: 04 80 00 03 ble 201b474 <rtems_rfs_buffer_handle_release+0x9c><== NEVER TAKEN
201b46c: 82 00 7f ff add %g1, -1, %g1
rtems_rfs_buffer_refs_down (handle);
201b470: c2 22 20 30 st %g1, [ %o0 + 0x30 ]
if (rtems_rfs_buffer_refs (handle) == 0)
201b474: c2 02 20 30 ld [ %o0 + 0x30 ], %g1
201b478: 80 a0 60 00 cmp %g1, 0
201b47c: 12 80 00 48 bne 201b59c <rtems_rfs_buffer_handle_release+0x1c4>
201b480: b0 10 20 00 clr %i0
201b484: 7f ff f3 bd call 2018378 <_Chain_Extract>
201b488: 01 00 00 00 nop
{
rtems_chain_extract (rtems_rfs_buffer_link (handle));
fs->buffers_count--;
201b48c: c2 07 60 50 ld [ %i5 + 0x50 ], %g1
if (rtems_rfs_fs_no_local_cache (fs))
201b490: 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--;
201b494: 82 00 7f ff add %g1, -1, %g1
if (rtems_rfs_fs_no_local_cache (fs))
201b498: b0 8e 20 02 andcc %i0, 2, %i0
201b49c: 02 80 00 08 be 201b4bc <rtems_rfs_buffer_handle_release+0xe4>
201b4a0: c2 27 60 50 st %g1, [ %i5 + 0x50 ]
{
handle->buffer->user = (void*) 0;
201b4a4: d0 06 60 08 ld [ %i1 + 8 ], %o0
rc = rtems_rfs_buffer_io_release (handle->buffer,
201b4a8: d2 0e 40 00 ldub [ %i1 ], %o1
201b4ac: 40 00 14 ac call 202075c <rtems_rfs_buffer_bdbuf_release>
201b4b0: c0 22 20 34 clr [ %o0 + 0x34 ]
201b4b4: 10 80 00 3a b 201b59c <rtems_rfs_buffer_handle_release+0x1c4>
201b4b8: 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 +
201b4bc: c2 07 60 60 ld [ %i5 + 0x60 ], %g1
201b4c0: c4 07 60 70 ld [ %i5 + 0x70 ], %g2
201b4c4: 84 00 80 01 add %g2, %g1, %g2
201b4c8: c2 07 60 40 ld [ %i5 + 0x40 ], %g1
201b4cc: 80 a0 80 01 cmp %g2, %g1
201b4d0: 2a 80 00 25 bcs,a 201b564 <rtems_rfs_buffer_handle_release+0x18c>
201b4d4: 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))
201b4d8: 90 10 20 00 clr %o0
201b4dc: 7f ff e0 bd call 20137d0 <rtems_rfs_trace>
201b4e0: 92 10 22 00 mov 0x200, %o1
201b4e4: 80 8a 20 ff btst 0xff, %o0
201b4e8: 22 80 00 09 be,a 201b50c <rtems_rfs_buffer_handle_release+0x134><== ALWAYS TAKEN
201b4ec: c4 07 60 60 ld [ %i5 + 0x60 ], %g2
printf ("rtems-rfs: buffer-release: local cache overflow:"
201b4f0: d2 07 60 70 ld [ %i5 + 0x70 ], %o1 <== NOT EXECUTED
201b4f4: c2 07 60 60 ld [ %i5 + 0x60 ], %g1 <== NOT EXECUTED
201b4f8: 11 00 80 ce sethi %hi(0x2033800), %o0 <== NOT EXECUTED
201b4fc: 92 02 40 01 add %o1, %g1, %o1 <== NOT EXECUTED
201b500: 40 00 1a fe call 20220f8 <printf> <== NOT EXECUTED
201b504: 90 12 20 c0 or %o0, 0xc0, %o0 <== NOT EXECUTED
" %" PRIu32 "\n", fs->release_count + fs->release_modified_count);
if (fs->release_count > fs->release_modified_count)
201b508: c4 07 60 60 ld [ %i5 + 0x60 ], %g2 <== NOT EXECUTED
201b50c: c2 07 60 70 ld [ %i5 + 0x70 ], %g1
201b510: 80 a0 80 01 cmp %g2, %g1
201b514: 08 80 00 09 bleu 201b538 <rtems_rfs_buffer_handle_release+0x160>
201b518: 01 00 00 00 nop
*/
RTEMS_INLINE_ROUTINE rtems_chain_node *rtems_chain_get(
rtems_chain_control *the_chain
)
{
return _Chain_Get( the_chain );
201b51c: 7f ff c8 58 call 200d67c <_Chain_Get>
201b520: 90 07 60 54 add %i5, 0x54, %o0
{
buffer = (rtems_rfs_buffer*) rtems_chain_get (&fs->release);
fs->release_count--;
201b524: c2 07 60 60 ld [ %i5 + 0x60 ], %g1
modified = false;
201b528: 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--;
201b52c: 82 00 7f ff add %g1, -1, %g1
201b530: 10 80 00 08 b 201b550 <rtems_rfs_buffer_handle_release+0x178>
201b534: c2 27 60 60 st %g1, [ %i5 + 0x60 ]
201b538: 7f ff c8 51 call 200d67c <_Chain_Get>
201b53c: 90 07 60 64 add %i5, 0x64, %o0
}
else
{
buffer =
(rtems_rfs_buffer*) rtems_chain_get (&fs->release_modified);
fs->release_modified_count--;
201b540: c2 07 60 70 ld [ %i5 + 0x70 ], %g1
modified = true;
201b544: 92 10 20 01 mov 1, %o1
}
else
{
buffer =
(rtems_rfs_buffer*) rtems_chain_get (&fs->release_modified);
fs->release_modified_count--;
201b548: 82 00 7f ff add %g1, -1, %g1
201b54c: c2 27 60 70 st %g1, [ %i5 + 0x70 ]
modified = true;
}
buffer->user = (void*) 0;
201b550: c0 22 20 34 clr [ %o0 + 0x34 ]
rc = rtems_rfs_buffer_io_release (buffer, modified);
201b554: 40 00 14 82 call 202075c <rtems_rfs_buffer_bdbuf_release>
201b558: 92 0a 60 01 and %o1, 1, %o1
201b55c: b0 10 00 08 mov %o0, %i0
}
if (rtems_rfs_buffer_dirty (handle))
201b560: c2 0e 40 00 ldub [ %i1 ], %g1
201b564: 80 a0 60 00 cmp %g1, 0
201b568: 02 80 00 08 be 201b588 <rtems_rfs_buffer_handle_release+0x1b0>
201b56c: 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 );
201b570: 7f ff c8 37 call 200d64c <_Chain_Append>
201b574: 90 07 60 64 add %i5, 0x64, %o0
{
rtems_chain_append (&fs->release_modified,
rtems_rfs_buffer_link (handle));
fs->release_modified_count++;
201b578: c2 07 60 70 ld [ %i5 + 0x70 ], %g1
201b57c: 82 00 60 01 inc %g1
201b580: 10 80 00 07 b 201b59c <rtems_rfs_buffer_handle_release+0x1c4>
201b584: c2 27 60 70 st %g1, [ %i5 + 0x70 ]
201b588: 7f ff c8 31 call 200d64c <_Chain_Append>
201b58c: 90 07 60 54 add %i5, 0x54, %o0
}
else
{
rtems_chain_append (&fs->release, rtems_rfs_buffer_link (handle));
fs->release_count++;
201b590: c2 07 60 60 ld [ %i5 + 0x60 ], %g1
201b594: 82 00 60 01 inc %g1
201b598: c2 27 60 60 st %g1, [ %i5 + 0x60 ]
}
}
}
handle->buffer = NULL;
201b59c: c0 26 60 08 clr [ %i1 + 8 ]
}
return rc;
}
201b5a0: 81 c7 e0 08 ret
201b5a4: 81 e8 00 00 restore
0201b5a8 <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)
{
201b5a8: 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))
201b5ac: c2 06 60 08 ld [ %i1 + 8 ], %g1
201b5b0: 80 a0 60 00 cmp %g1, 0
201b5b4: 02 80 00 1a be 201b61c <rtems_rfs_buffer_handle_request+0x74>
201b5b8: 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))
201b5bc: 80 a6 a0 00 cmp %i2, 0
201b5c0: 02 80 00 06 be 201b5d8 <rtems_rfs_buffer_handle_request+0x30><== NEVER TAKEN
201b5c4: 90 10 20 00 clr %o0
201b5c8: c2 06 60 04 ld [ %i1 + 4 ], %g1
201b5cc: 80 a0 40 1a cmp %g1, %i2
201b5d0: 02 80 00 75 be 201b7a4 <rtems_rfs_buffer_handle_request+0x1fc>
201b5d4: b0 10 20 00 clr %i0
return 0;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))
201b5d8: 7f ff e0 7e call 20137d0 <rtems_rfs_trace>
201b5dc: 92 10 21 00 mov 0x100, %o1
201b5e0: 80 8a 20 ff btst 0xff, %o0
201b5e4: 22 80 00 07 be,a 201b600 <rtems_rfs_buffer_handle_request+0x58><== ALWAYS TAKEN
201b5e8: 90 10 00 1d mov %i5, %o0
printf ("rtems-rfs: buffer-request: handle has buffer: %" PRIu32 "\n",
201b5ec: d2 06 60 04 ld [ %i1 + 4 ], %o1 <== NOT EXECUTED
201b5f0: 11 00 80 ce sethi %hi(0x2033800), %o0 <== NOT EXECUTED
201b5f4: 40 00 1a c1 call 20220f8 <printf> <== NOT EXECUTED
201b5f8: 90 12 21 00 or %o0, 0x100, %o0 ! 2033900 <CSWTCH.2+0x220> <== NOT EXECUTED
rtems_rfs_buffer_bnum (handle));
rc = rtems_rfs_buffer_handle_release (fs, handle);
201b5fc: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
201b600: 7f ff ff 76 call 201b3d8 <rtems_rfs_buffer_handle_release>
201b604: 92 10 00 19 mov %i1, %o1
if (rc > 0)
201b608: b0 92 20 00 orcc %o0, 0, %i0
201b60c: 14 80 00 8b bg 201b838 <rtems_rfs_buffer_handle_request+0x290><== NEVER TAKEN
201b610: 01 00 00 00 nop
return rc;
handle->dirty = false;
201b614: c0 2e 40 00 clrb [ %i1 ]
handle->bnum = 0;
201b618: c0 26 60 04 clr [ %i1 + 4 ]
}
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))
201b61c: 90 10 20 00 clr %o0
201b620: 7f ff e0 6c call 20137d0 <rtems_rfs_trace>
201b624: 92 10 21 00 mov 0x100, %o1
201b628: 80 8a 20 ff btst 0xff, %o0
201b62c: 22 80 00 07 be,a 201b648 <rtems_rfs_buffer_handle_request+0xa0><== ALWAYS TAKEN
201b630: c2 07 60 50 ld [ %i5 + 0x50 ], %g1
printf ("rtems-rfs: buffer-request: block=%" PRIu32 "\n", block);
201b634: 11 00 80 ce sethi %hi(0x2033800), %o0 <== NOT EXECUTED
201b638: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED
201b63c: 40 00 1a af call 20220f8 <printf> <== NOT EXECUTED
201b640: 90 12 21 38 or %o0, 0x138, %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)
201b644: c2 07 60 50 ld [ %i5 + 0x50 ], %g1 <== NOT EXECUTED
201b648: 80 a0 60 00 cmp %g1, 0
201b64c: 22 80 00 16 be,a 201b6a4 <rtems_rfs_buffer_handle_request+0xfc>
201b650: c2 07 40 00 ld [ %i5 ], %g1
{
/*
* Check the active buffer list for shared buffers.
*/
handle->buffer = rtems_rfs_scan_chain (&fs->buffers,
201b654: 90 07 60 44 add %i5, 0x44, %o0
201b658: 92 07 60 50 add %i5, 0x50, %o1
201b65c: 7f ff ff 22 call 201b2e4 <rtems_rfs_scan_chain>
201b660: 94 10 00 1a mov %i2, %o2
&fs->buffers_count,
block);
if (rtems_rfs_buffer_handle_has_block (handle) &&
201b664: 80 a2 20 00 cmp %o0, 0
201b668: 02 80 00 0e be 201b6a0 <rtems_rfs_buffer_handle_request+0xf8>
201b66c: d0 26 60 08 st %o0, [ %i1 + 8 ]
rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))
201b670: 90 10 20 00 clr %o0
201b674: 7f ff e0 57 call 20137d0 <rtems_rfs_trace>
201b678: 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) &&
201b67c: 80 8a 20 ff btst 0xff, %o0
201b680: 22 80 00 09 be,a 201b6a4 <rtems_rfs_buffer_handle_request+0xfc><== ALWAYS TAKEN
201b684: 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);
201b688: 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",
201b68c: 11 00 80 ce sethi %hi(0x2033800), %o0 <== NOT EXECUTED
201b690: d2 00 60 30 ld [ %g1 + 0x30 ], %o1 <== NOT EXECUTED
201b694: 90 12 21 60 or %o0, 0x160, %o0 <== NOT EXECUTED
201b698: 40 00 1a 98 call 20220f8 <printf> <== NOT EXECUTED
201b69c: 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) &&
201b6a0: c2 07 40 00 ld [ %i5 ], %g1
201b6a4: 80 88 60 02 btst 2, %g1
201b6a8: 12 80 00 20 bne 201b728 <rtems_rfs_buffer_handle_request+0x180>
201b6ac: c2 06 60 08 ld [ %i1 + 8 ], %g1
201b6b0: 80 a0 60 00 cmp %g1, 0
201b6b4: 32 80 00 42 bne,a 201b7bc <rtems_rfs_buffer_handle_request+0x214>
201b6b8: 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)
201b6bc: c2 07 60 60 ld [ %i5 + 0x60 ], %g1
201b6c0: 80 a0 60 00 cmp %g1, 0
201b6c4: 22 80 00 08 be,a 201b6e4 <rtems_rfs_buffer_handle_request+0x13c>
201b6c8: c2 06 60 08 ld [ %i1 + 8 ], %g1
handle->buffer = rtems_rfs_scan_chain (&fs->release,
201b6cc: 90 07 60 54 add %i5, 0x54, %o0
201b6d0: 92 07 60 60 add %i5, 0x60, %o1
201b6d4: 7f ff ff 04 call 201b2e4 <rtems_rfs_scan_chain>
201b6d8: 94 10 00 1a mov %i2, %o2
201b6dc: d0 26 60 08 st %o0, [ %i1 + 8 ]
&fs->release_count,
block);
if (!rtems_rfs_buffer_handle_has_block (handle) &&
201b6e0: c2 06 60 08 ld [ %i1 + 8 ], %g1
201b6e4: 80 a0 60 00 cmp %g1, 0
201b6e8: 32 80 00 10 bne,a 201b728 <rtems_rfs_buffer_handle_request+0x180>
201b6ec: c2 06 60 08 ld [ %i1 + 8 ], %g1
201b6f0: c2 07 60 70 ld [ %i5 + 0x70 ], %g1
201b6f4: 80 a0 60 00 cmp %g1, 0
201b6f8: 22 80 00 0c be,a 201b728 <rtems_rfs_buffer_handle_request+0x180>
201b6fc: c2 06 60 08 ld [ %i1 + 8 ], %g1
fs->release_modified_count)
{
handle->buffer = rtems_rfs_scan_chain (&fs->release_modified,
201b700: 90 07 60 64 add %i5, 0x64, %o0
201b704: 92 07 60 70 add %i5, 0x70, %o1
201b708: 7f ff fe f7 call 201b2e4 <rtems_rfs_scan_chain>
201b70c: 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))
201b710: 80 a2 20 00 cmp %o0, 0
201b714: 02 80 00 04 be 201b724 <rtems_rfs_buffer_handle_request+0x17c>
201b718: d0 26 60 08 st %o0, [ %i1 + 8 ]
rtems_rfs_buffer_mark_dirty (handle);
201b71c: 82 10 20 01 mov 1, %g1
201b720: 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))
201b724: c2 06 60 08 ld [ %i1 + 8 ], %g1
201b728: 80 a0 60 00 cmp %g1, 0
201b72c: 32 80 00 24 bne,a 201b7bc <rtems_rfs_buffer_handle_request+0x214>
201b730: d2 06 60 08 ld [ %i1 + 8 ], %o1
{
rc = rtems_rfs_buffer_io_request (fs, block, read, &handle->buffer);
201b734: 90 10 00 1d mov %i5, %o0
201b738: 92 10 00 1a mov %i2, %o1
201b73c: 94 10 00 1b mov %i3, %o2
201b740: 40 00 13 f6 call 2020718 <rtems_rfs_buffer_bdbuf_request>
201b744: 96 06 60 08 add %i1, 8, %o3
if (rc > 0)
201b748: b0 92 20 00 orcc %o0, 0, %i0
201b74c: 04 80 00 18 ble 201b7ac <rtems_rfs_buffer_handle_request+0x204><== ALWAYS TAKEN
201b750: 90 10 20 00 clr %o0
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))
201b754: 7f ff e0 1f call 20137d0 <rtems_rfs_trace> <== NOT EXECUTED
201b758: 92 10 21 00 mov 0x100, %o1 <== NOT EXECUTED
201b75c: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
201b760: 02 80 00 11 be 201b7a4 <rtems_rfs_buffer_handle_request+0x1fc><== NOT EXECUTED
201b764: 80 a6 e0 00 cmp %i3, 0 <== NOT EXECUTED
printf ("rtems-rfs: buffer-request: block=%" PRIu32 ": bdbuf-%s: %d: %s\n",
201b768: 22 80 00 05 be,a 201b77c <rtems_rfs_buffer_handle_request+0x1d4><== NOT EXECUTED
201b76c: 3b 00 80 ce sethi %hi(0x2033800), %i5 <== NOT EXECUTED
201b770: 3b 00 80 cc sethi %hi(0x2033000), %i5 <== NOT EXECUTED
201b774: 10 80 00 03 b 201b780 <rtems_rfs_buffer_handle_request+0x1d8><== NOT EXECUTED
201b778: ba 17 62 a8 or %i5, 0x2a8, %i5 ! 20332a8 <rtems_rfs_rtems_eval_config+0x2d0><== NOT EXECUTED
201b77c: ba 17 60 f8 or %i5, 0xf8, %i5 <== NOT EXECUTED
201b780: 40 00 1e cd call 20232b4 <strerror> <== NOT EXECUTED
201b784: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
201b788: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED
201b78c: 98 10 00 08 mov %o0, %o4 <== NOT EXECUTED
201b790: 94 10 00 1d mov %i5, %o2 <== NOT EXECUTED
201b794: 11 00 80 ce sethi %hi(0x2033800), %o0 <== NOT EXECUTED
201b798: 96 10 00 18 mov %i0, %o3 <== NOT EXECUTED
201b79c: 40 00 1a 57 call 20220f8 <printf> <== NOT EXECUTED
201b7a0: 90 12 21 98 or %o0, 0x198, %o0 <== NOT EXECUTED
201b7a4: 81 c7 e0 08 ret
201b7a8: 81 e8 00 00 restore
block, read ? "read" : "get", rc, strerror (rc));
return rc;
}
rtems_chain_set_off_chain (rtems_rfs_buffer_link(handle));
201b7ac: c2 06 60 08 ld [ %i1 + 8 ], %g1
201b7b0: c0 20 60 04 clr [ %g1 + 4 ]
201b7b4: c0 20 40 00 clr [ %g1 ]
}
/*
* Increase the reference count of the buffer.
*/
rtems_rfs_buffer_refs_up (handle);
201b7b8: d2 06 60 08 ld [ %i1 + 8 ], %o1
201b7bc: 90 07 60 44 add %i5, 0x44, %o0
201b7c0: c2 02 60 30 ld [ %o1 + 0x30 ], %g1
201b7c4: 82 00 60 01 inc %g1
201b7c8: 7f ff c7 a1 call 200d64c <_Chain_Append>
201b7cc: c2 22 60 30 st %g1, [ %o1 + 0x30 ]
rtems_chain_append (&fs->buffers, rtems_rfs_buffer_link (handle));
fs->buffers_count++;
201b7d0: 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))
201b7d4: 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++;
201b7d8: 82 00 60 01 inc %g1
201b7dc: c2 27 60 50 st %g1, [ %i5 + 0x50 ]
handle->buffer->user = (void*) ((intptr_t) block);
201b7e0: c2 06 60 08 ld [ %i1 + 8 ], %g1
handle->bnum = block;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))
201b7e4: 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);
201b7e8: f4 20 60 34 st %i2, [ %g1 + 0x34 ]
handle->bnum = block;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))
201b7ec: 7f ff df f9 call 20137d0 <rtems_rfs_trace>
201b7f0: f4 26 60 04 st %i2, [ %i1 + 4 ]
201b7f4: 80 8a 20 ff btst 0xff, %o0
201b7f8: 02 80 00 0f be 201b834 <rtems_rfs_buffer_handle_request+0x28c><== ALWAYS TAKEN
201b7fc: 80 a6 e0 00 cmp %i3, 0
printf ("rtems-rfs: buffer-request: block=%" PRIu32 " bdbuf-%s=%" PRIu32 " refs=%d\n",
201b800: 22 80 00 05 be,a 201b814 <rtems_rfs_buffer_handle_request+0x26c><== NOT EXECUTED
201b804: 15 00 80 ce sethi %hi(0x2033800), %o2 <== NOT EXECUTED
201b808: 15 00 80 cc sethi %hi(0x2033000), %o2 <== NOT EXECUTED
201b80c: 10 80 00 03 b 201b818 <rtems_rfs_buffer_handle_request+0x270><== NOT EXECUTED
201b810: 94 12 a2 a8 or %o2, 0x2a8, %o2 ! 20332a8 <rtems_rfs_rtems_eval_config+0x2d0><== NOT EXECUTED
201b814: 94 12 a0 f8 or %o2, 0xf8, %o2 <== NOT EXECUTED
block, read ? "read" : "get", handle->buffer->block,
201b818: 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",
201b81c: 11 00 80 ce sethi %hi(0x2033800), %o0 <== NOT EXECUTED
201b820: d6 00 60 18 ld [ %g1 + 0x18 ], %o3 <== NOT EXECUTED
201b824: d8 00 60 30 ld [ %g1 + 0x30 ], %o4 <== NOT EXECUTED
201b828: 90 12 21 d0 or %o0, 0x1d0, %o0 <== NOT EXECUTED
201b82c: 40 00 1a 33 call 20220f8 <printf> <== NOT EXECUTED
201b830: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED
block, read ? "read" : "get", handle->buffer->block,
handle->buffer->references);
return 0;
201b834: b0 10 20 00 clr %i0
}
201b838: 81 c7 e0 08 ret
201b83c: 81 e8 00 00 restore
0201b840 <rtems_rfs_buffer_open>:
return rc;
}
int
rtems_rfs_buffer_open (const char* name, rtems_rfs_file_system* fs)
{
201b840: 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))
201b844: 90 10 20 00 clr %o0
201b848: 7f ff df e2 call 20137d0 <rtems_rfs_trace>
201b84c: 92 10 20 20 mov 0x20, %o1
201b850: 80 8a 20 ff btst 0xff, %o0
201b854: 22 80 00 07 be,a 201b870 <rtems_rfs_buffer_open+0x30> <== ALWAYS TAKEN
201b858: 90 10 00 18 mov %i0, %o0
printf ("rtems-rfs: buffer-open: opening: %s\n", name);
201b85c: 11 00 80 ce sethi %hi(0x2033800), %o0 <== NOT EXECUTED
201b860: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
201b864: 40 00 1a 25 call 20220f8 <printf> <== NOT EXECUTED
201b868: 90 12 22 10 or %o0, 0x210, %o0 <== NOT EXECUTED
fs->device = open (name, O_RDWR);
201b86c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
201b870: 7f ff b6 52 call 20091b8 <open>
201b874: 92 10 20 02 mov 2, %o1
if (fs->device < 0)
201b878: 80 a2 20 00 cmp %o0, 0
201b87c: 16 80 00 0f bge 201b8b8 <rtems_rfs_buffer_open+0x78> <== ALWAYS TAKEN
201b880: d0 26 60 0c st %o0, [ %i1 + 0xc ]
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_OPEN))
201b884: 90 10 20 00 clr %o0 <== NOT EXECUTED
201b888: 7f ff df d2 call 20137d0 <rtems_rfs_trace> <== NOT EXECUTED
201b88c: 92 10 20 08 mov 8, %o1 <== NOT EXECUTED
201b890: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
201b894: 12 80 00 04 bne 201b8a4 <rtems_rfs_buffer_open+0x64> <== NOT EXECUTED
201b898: 11 00 80 ce sethi %hi(0x2033800), %o0 <== NOT EXECUTED
printf ("rtems-rfs: buffer-open: cannot open file\n");
return ENXIO;
201b89c: 81 c7 e0 08 ret <== NOT EXECUTED
201b8a0: 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");
201b8a4: 90 12 22 38 or %o0, 0x238, %o0 <== NOT EXECUTED
201b8a8: 40 00 1a ac call 2022358 <puts> <== NOT EXECUTED
201b8ac: 01 00 00 00 nop <== NOT EXECUTED
return ENXIO;
201b8b0: 81 c7 e0 08 ret <== NOT EXECUTED
201b8b4: 91 e8 20 06 restore %g0, 6, %o0 <== NOT EXECUTED
}
if (fstat (fs->device, &st) < 0)
201b8b8: 7f ff b2 86 call 20082d0 <fstat>
201b8bc: 92 07 bf b8 add %fp, -72, %o1
201b8c0: 80 a2 20 00 cmp %o0, 0
201b8c4: 16 80 00 12 bge 201b90c <rtems_rfs_buffer_open+0xcc> <== ALWAYS TAKEN
201b8c8: c4 07 bf c4 ld [ %fp + -60 ], %g2
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_OPEN))
201b8cc: 90 10 20 00 clr %o0 <== NOT EXECUTED
201b8d0: 7f ff df c0 call 20137d0 <rtems_rfs_trace> <== NOT EXECUTED
201b8d4: 92 10 20 08 mov 8, %o1 <== NOT EXECUTED
201b8d8: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
201b8dc: 02 bf ff f5 be 201b8b0 <rtems_rfs_buffer_open+0x70> <== NOT EXECUTED
201b8e0: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: buffer-open: stat '%s' failed: %s\n",
name, strerror (errno));
201b8e4: 40 00 14 b6 call 2020bbc <__errno> <== NOT EXECUTED
201b8e8: 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",
201b8ec: 40 00 1e 72 call 20232b4 <strerror> <== NOT EXECUTED
201b8f0: d0 02 00 00 ld [ %o0 ], %o0 <== NOT EXECUTED
201b8f4: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
201b8f8: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
201b8fc: 11 00 80 ce sethi %hi(0x2033800), %o0 <== NOT EXECUTED
201b900: 40 00 19 fe call 20220f8 <printf> <== NOT EXECUTED
201b904: 90 12 22 68 or %o0, 0x268, %o0 ! 2033a68 <CSWTCH.2+0x388> <== NOT EXECUTED
201b908: 30 bf ff ea b,a 201b8b0 <rtems_rfs_buffer_open+0x70> <== NOT EXECUTED
#if RTEMS_RFS_USE_LIBBLOCK
/*
* Is the device a block device ?
*/
if (!S_ISBLK (st.st_mode))
201b90c: 03 00 00 3c sethi %hi(0xf000), %g1
201b910: 84 08 80 01 and %g2, %g1, %g2
201b914: 03 00 00 18 sethi %hi(0x6000), %g1
201b918: 80 a0 80 01 cmp %g2, %g1
201b91c: 22 80 00 0c be,a 201b94c <rtems_rfs_buffer_open+0x10c> <== ALWAYS TAKEN
201b920: d0 06 60 0c ld [ %i1 + 0xc ], %o0
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_OPEN))
201b924: 90 10 20 00 clr %o0 <== NOT EXECUTED
201b928: 7f ff df aa call 20137d0 <rtems_rfs_trace> <== NOT EXECUTED
201b92c: 92 10 20 08 mov 8, %o1 <== NOT EXECUTED
201b930: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
201b934: 02 bf ff df be 201b8b0 <rtems_rfs_buffer_open+0x70> <== NOT EXECUTED
201b938: 11 00 80 ce sethi %hi(0x2033800), %o0 <== NOT EXECUTED
printf ("rtems-rfs: buffer-open: '%s' is not a block device\n", name);
201b93c: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
201b940: 40 00 19 ee call 20220f8 <printf> <== NOT EXECUTED
201b944: 90 12 22 98 or %o0, 0x298, %o0 <== NOT EXECUTED
201b948: 30 bf ff da b,a 201b8b0 <rtems_rfs_buffer_open+0x70> <== 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);
201b94c: 13 10 01 10 sethi %hi(0x40044000), %o1
201b950: 94 06 60 10 add %i1, 0x10, %o2
201b954: 7f ff b2 b6 call 200842c <ioctl>
201b958: 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)
201b95c: 80 a2 20 00 cmp %o0, 0
201b960: 02 80 00 09 be 201b984 <rtems_rfs_buffer_open+0x144> <== ALWAYS TAKEN
201b964: 90 10 20 00 clr %o0
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_OPEN))
201b968: 7f ff df 9a call 20137d0 <rtems_rfs_trace> <== NOT EXECUTED
201b96c: 92 10 20 08 mov 8, %o1 <== NOT EXECUTED
201b970: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
201b974: 02 bf ff cf be 201b8b0 <rtems_rfs_buffer_open+0x70> <== NOT EXECUTED
201b978: 11 00 80 ce sethi %hi(0x2033800), %o0 <== NOT EXECUTED
printf ("rtems-rfs: buffer-open: cannot obtain the disk\n");
201b97c: 10 bf ff cb b 201b8a8 <rtems_rfs_buffer_open+0x68> <== NOT EXECUTED
201b980: 90 12 22 d0 or %o0, 0x2d0, %o0 ! 2033ad0 <CSWTCH.2+0x3f0> <== NOT EXECUTED
#else
fs->media_size = st.st_size;
strcat (fs->name, name);
#endif
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SYNC))
201b984: 92 10 20 20 mov 0x20, %o1
201b988: 7f ff df 92 call 20137d0 <rtems_rfs_trace>
201b98c: b0 10 20 00 clr %i0
201b990: 80 8a 20 ff btst 0xff, %o0
201b994: 02 80 00 07 be 201b9b0 <rtems_rfs_buffer_open+0x170> <== ALWAYS TAKEN
201b998: 11 00 80 ce sethi %hi(0x2033800), %o0
printf ("rtems-rfs: buffer-open: blks=%" PRId32 ", blk-size=%" PRId32 "\n",
rtems_rfs_fs_media_blocks (fs),
201b99c: 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",
201b9a0: d2 00 60 1c ld [ %g1 + 0x1c ], %o1 <== NOT EXECUTED
201b9a4: d4 00 60 20 ld [ %g1 + 0x20 ], %o2 <== NOT EXECUTED
201b9a8: 40 00 19 d4 call 20220f8 <printf> <== NOT EXECUTED
201b9ac: 90 12 23 00 or %o0, 0x300, %o0 <== NOT EXECUTED
rtems_rfs_fs_media_blocks (fs),
rtems_rfs_fs_media_block_size (fs));
return 0;
}
201b9b0: 81 c7 e0 08 ret
201b9b4: 81 e8 00 00 restore
0201bac0 <rtems_rfs_buffer_setblksize>:
return result;
}
int
rtems_rfs_buffer_setblksize (rtems_rfs_file_system* fs, size_t size)
{
201bac0: 9d e3 bf a0 save %sp, -96, %sp
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SETBLKSIZE))
201bac4: 90 10 20 00 clr %o0
return result;
}
int
rtems_rfs_buffer_setblksize (rtems_rfs_file_system* fs, size_t size)
{
201bac8: f2 27 a0 48 st %i1, [ %fp + 0x48 ]
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SETBLKSIZE))
201bacc: 7f ff df 41 call 20137d0 <rtems_rfs_trace>
201bad0: 92 10 24 00 mov 0x400, %o1
201bad4: 80 8a 20 ff btst 0xff, %o0
201bad8: 02 80 00 05 be 201baec <rtems_rfs_buffer_setblksize+0x2c> <== ALWAYS TAKEN
201badc: d2 07 a0 48 ld [ %fp + 0x48 ], %o1
printf ("rtems-rfs: buffer-setblksize: block size: %zu\n", size);
201bae0: 11 00 80 ce sethi %hi(0x2033800), %o0 <== NOT EXECUTED
201bae4: 40 00 19 85 call 20220f8 <printf> <== NOT EXECUTED
201bae8: 90 12 23 d0 or %o0, 0x3d0, %o0 ! 2033bd0 <CSWTCH.2+0x4f0> <== NOT EXECUTED
rc = rtems_rfs_buffers_release (fs);
201baec: 7f ff ff d5 call 201ba40 <rtems_rfs_buffers_release>
201baf0: 90 10 00 18 mov %i0, %o0
if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SETBLKSIZE))
201baf4: ba 92 20 00 orcc %o0, 0, %i5
201baf8: 04 80 00 0e ble 201bb30 <rtems_rfs_buffer_setblksize+0x70><== ALWAYS TAKEN
201bafc: 90 10 20 00 clr %o0
201bb00: 7f ff df 34 call 20137d0 <rtems_rfs_trace> <== NOT EXECUTED
201bb04: 92 10 24 00 mov 0x400, %o1 <== NOT EXECUTED
201bb08: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
201bb0c: 02 80 00 09 be 201bb30 <rtems_rfs_buffer_setblksize+0x70> <== NOT EXECUTED
201bb10: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: buffer-setblksize: buffer release failed: %d: %s\n",
201bb14: 40 00 1d e8 call 20232b4 <strerror> <== NOT EXECUTED
201bb18: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
201bb1c: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
201bb20: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
201bb24: 11 00 80 cf sethi %hi(0x2033c00), %o0 <== NOT EXECUTED
201bb28: 40 00 19 74 call 20220f8 <printf> <== NOT EXECUTED
201bb2c: 90 12 20 00 mov %o0, %o0 ! 2033c00 <CSWTCH.2+0x520> <== NOT EXECUTED
rc, strerror (rc));
rc = rtems_rfs_buffer_sync (fs);
201bb30: 7f ff ff a2 call 201b9b8 <rtems_rfs_buffer_sync>
201bb34: 90 10 00 18 mov %i0, %o0
if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SETBLKSIZE))
201bb38: ba 92 20 00 orcc %o0, 0, %i5
201bb3c: 04 80 00 0e ble 201bb74 <rtems_rfs_buffer_setblksize+0xb4><== ALWAYS TAKEN
201bb40: 90 10 20 00 clr %o0
201bb44: 7f ff df 23 call 20137d0 <rtems_rfs_trace> <== NOT EXECUTED
201bb48: 92 10 24 00 mov 0x400, %o1 <== NOT EXECUTED
201bb4c: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
201bb50: 22 80 00 0a be,a 201bb78 <rtems_rfs_buffer_setblksize+0xb8><== NOT EXECUTED
201bb54: d0 06 20 10 ld [ %i0 + 0x10 ], %o0 <== NOT EXECUTED
printf ("rtems-rfs: buffer-setblksize: device sync failed: %d: %s\n",
201bb58: 40 00 1d d7 call 20232b4 <strerror> <== NOT EXECUTED
201bb5c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
201bb60: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
201bb64: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
201bb68: 11 00 80 cf sethi %hi(0x2033c00), %o0 <== NOT EXECUTED
201bb6c: 40 00 19 63 call 20220f8 <printf> <== NOT EXECUTED
201bb70: 90 12 20 40 or %o0, 0x40, %o0 ! 2033c40 <CSWTCH.2+0x560> <== NOT EXECUTED
rc, strerror (rc));
#if RTEMS_RFS_USE_LIBBLOCK
rc = fs->disk->ioctl (fs->disk, RTEMS_BLKIO_SETBLKSIZE, &size);
201bb74: d0 06 20 10 ld [ %i0 + 0x10 ], %o0
201bb78: 13 20 01 10 sethi %hi(0x80044000), %o1
201bb7c: c2 02 20 38 ld [ %o0 + 0x38 ], %g1
201bb80: 92 12 62 04 or %o1, 0x204, %o1
201bb84: 9f c0 40 00 call %g1
201bb88: 94 07 a0 48 add %fp, 0x48, %o2
if (rc < 0)
201bb8c: b0 92 20 00 orcc %o0, 0, %i0
201bb90: 16 80 00 05 bge 201bba4 <rtems_rfs_buffer_setblksize+0xe4><== ALWAYS TAKEN
201bb94: 01 00 00 00 nop
rc = errno;
201bb98: 40 00 14 09 call 2020bbc <__errno> <== NOT EXECUTED
201bb9c: 01 00 00 00 nop <== NOT EXECUTED
201bba0: f0 02 00 00 ld [ %o0 ], %i0 <== NOT EXECUTED
#endif
return rc;
}
201bba4: 81 c7 e0 08 ret
201bba8: 81 e8 00 00 restore
0201b9b8 <rtems_rfs_buffer_sync>:
return rc;
}
int
rtems_rfs_buffer_sync (rtems_rfs_file_system* fs)
{
201b9b8: 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))
201b9bc: 90 10 20 00 clr %o0
201b9c0: 7f ff df 84 call 20137d0 <rtems_rfs_trace>
201b9c4: 92 10 20 20 mov 0x20, %o1
201b9c8: 80 8a 20 ff btst 0xff, %o0
201b9cc: 22 80 00 06 be,a 201b9e4 <rtems_rfs_buffer_sync+0x2c> <== ALWAYS TAKEN
201b9d0: d0 06 20 10 ld [ %i0 + 0x10 ], %o0
printf ("rtems-rfs: buffer-sync: syncing\n");
201b9d4: 11 00 80 ce sethi %hi(0x2033800), %o0 <== NOT EXECUTED
201b9d8: 40 00 1a 60 call 2022358 <puts> <== NOT EXECUTED
201b9dc: 90 12 23 30 or %o0, 0x330, %o0 ! 2033b30 <CSWTCH.2+0x450> <== 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));
201b9e0: d0 06 20 10 ld [ %i0 + 0x10 ], %o0 <== NOT EXECUTED
201b9e4: 7f ff e8 ee call 2015d9c <rtems_bdbuf_syncdev>
201b9e8: ba 10 20 00 clr %i5
if (sc != RTEMS_SUCCESSFUL)
201b9ec: 80 a2 20 00 cmp %o0, 0
201b9f0: 02 80 00 0f be 201ba2c <rtems_rfs_buffer_sync+0x74> <== ALWAYS TAKEN
201b9f4: b8 10 00 08 mov %o0, %i4
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SYNC))
201b9f8: 90 10 20 00 clr %o0 <== NOT EXECUTED
201b9fc: 92 10 20 20 mov 0x20, %o1 <== NOT EXECUTED
201ba00: 7f ff df 74 call 20137d0 <rtems_rfs_trace> <== NOT EXECUTED
201ba04: ba 10 20 05 mov 5, %i5 <== NOT EXECUTED
201ba08: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
201ba0c: 22 80 00 09 be,a 201ba30 <rtems_rfs_buffer_sync+0x78> <== NOT EXECUTED
201ba10: d0 06 20 10 ld [ %i0 + 0x10 ], %o0 <== NOT EXECUTED
printf ("rtems-rfs: buffer-sync: device sync failed: %s\n",
201ba14: 7f ff b1 68 call 2007fb4 <rtems_status_text> <== NOT EXECUTED
201ba18: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
201ba1c: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED
201ba20: 11 00 80 ce sethi %hi(0x2033800), %o0 <== NOT EXECUTED
201ba24: 40 00 19 b5 call 20220f8 <printf> <== NOT EXECUTED
201ba28: 90 12 23 50 or %o0, 0x350, %o0 ! 2033b50 <CSWTCH.2+0x470> <== NOT EXECUTED
rtems_status_text (sc));
result = EIO;
}
rtems_disk_release (fs->disk);
201ba2c: d0 06 20 10 ld [ %i0 + 0x10 ], %o0
201ba30: 7f ff a4 08 call 2004a50 <rtems_disk_release>
201ba34: b0 10 00 1d mov %i5, %i0
printf ("rtems-rfs: buffer-sync: file sync failed: %d: %s\n",
result, strerror (result));
}
#endif
return result;
}
201ba38: 81 c7 e0 08 ret
201ba3c: 81 e8 00 00 restore
0201ba40 <rtems_rfs_buffers_release>:
return rrc;
}
int
rtems_rfs_buffers_release (rtems_rfs_file_system* fs)
{
201ba40: 9d e3 bf a0 save %sp, -96, %sp
int rrc = 0;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_RELEASE))
201ba44: 90 10 20 00 clr %o0
201ba48: 92 10 20 40 mov 0x40, %o1
201ba4c: 7f ff df 61 call 20137d0 <rtems_rfs_trace>
201ba50: ba 10 00 18 mov %i0, %i5
201ba54: 80 8a 20 ff btst 0xff, %o0
201ba58: 02 80 00 09 be 201ba7c <rtems_rfs_buffers_release+0x3c> <== ALWAYS TAKEN
201ba5c: 92 07 60 60 add %i5, 0x60, %o1
printf ("rtems-rfs: buffers-release: active:%" PRIu32 " "
201ba60: d2 06 20 50 ld [ %i0 + 0x50 ], %o1 <== NOT EXECUTED
201ba64: d4 06 20 60 ld [ %i0 + 0x60 ], %o2 <== NOT EXECUTED
201ba68: d6 06 20 70 ld [ %i0 + 0x70 ], %o3 <== NOT EXECUTED
201ba6c: 11 00 80 ce sethi %hi(0x2033800), %o0 <== NOT EXECUTED
201ba70: 40 00 19 a2 call 20220f8 <printf> <== NOT EXECUTED
201ba74: 90 12 23 80 or %o0, 0x380, %o0 ! 2033b80 <CSWTCH.2+0x4a0> <== 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,
201ba78: 92 07 60 60 add %i5, 0x60, %o1 <== NOT EXECUTED
201ba7c: 94 10 20 00 clr %o2
201ba80: 7f ff fd f6 call 201b258 <rtems_rfs_release_chain>
201ba84: 90 07 60 54 add %i5, 0x54, %o0
201ba88: 82 38 00 08 xnor %g0, %o0, %g1
201ba8c: 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,
201ba90: 92 07 60 70 add %i5, 0x70, %o1
201ba94: b0 0a 00 01 and %o0, %g1, %i0
201ba98: 94 10 20 01 mov 1, %o2
201ba9c: 7f ff fd ef call 201b258 <rtems_rfs_release_chain>
201baa0: 90 07 60 64 add %i5, 0x64, %o0
&fs->release_modified_count,
true);
if ((rc > 0) && (rrc == 0))
201baa4: 80 a6 20 00 cmp %i0, 0
201baa8: 12 80 00 04 bne 201bab8 <rtems_rfs_buffers_release+0x78> <== NEVER TAKEN
201baac: 80 a2 20 00 cmp %o0, 0
201bab0: 34 80 00 02 bg,a 201bab8 <rtems_rfs_buffers_release+0x78><== NEVER TAKEN
201bab4: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED
rrc = rc;
return rrc;
}
201bab8: 81 c7 e0 08 ret
201babc: 81 e8 00 00 restore
0201c19c <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)
{
201c19c: 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))
201c1a0: 90 10 20 00 clr %o0
201c1a4: 7f ff dd 8b call 20137d0 <rtems_rfs_trace>
201c1a8: 13 08 00 00 sethi %hi(0x20000000), %o1
201c1ac: 80 8a 20 ff btst 0xff, %o0
201c1b0: 02 80 00 14 be 201c200 <rtems_rfs_dir_add_entry+0x64> <== ALWAYS TAKEN
201c1b4: a6 07 bf b0 add %fp, -80, %l3
{
int c;
printf ("rtems-rfs: dir-add-entry: dir=%" PRId32 ", name=",
201c1b8: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED
201c1bc: 11 00 80 cf sethi %hi(0x2033c00), %o0 <== NOT EXECUTED
201c1c0: ba 10 00 1a mov %i2, %i5 <== NOT EXECUTED
201c1c4: 90 12 23 f0 or %o0, 0x3f0, %o0 <== NOT EXECUTED
201c1c8: 40 00 17 cc call 20220f8 <printf> <== NOT EXECUTED
201c1cc: a0 06 80 1b add %i2, %i3, %l0 <== NOT EXECUTED
rtems_rfs_inode_ino (dir));
for (c = 0; c < length; c++)
201c1d0: 10 80 00 05 b 201c1e4 <rtems_rfs_dir_add_entry+0x48> <== NOT EXECUTED
201c1d4: 80 a7 40 10 cmp %i5, %l0 <== NOT EXECUTED
printf ("%c", name[c]);
201c1d8: 40 00 18 32 call 20222a0 <putchar> <== NOT EXECUTED
201c1dc: 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++)
201c1e0: 80 a7 40 10 cmp %i5, %l0 <== NOT EXECUTED
201c1e4: 32 bf ff fd bne,a 201c1d8 <rtems_rfs_dir_add_entry+0x3c> <== NOT EXECUTED
201c1e8: d0 4f 40 00 ldsb [ %i5 ], %o0 <== NOT EXECUTED
printf ("%c", name[c]);
printf (", len=%zd\n", length);
201c1ec: 11 00 80 d0 sethi %hi(0x2034000), %o0 <== NOT EXECUTED
201c1f0: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
201c1f4: 40 00 17 c1 call 20220f8 <printf> <== NOT EXECUTED
201c1f8: 90 12 20 20 or %o0, 0x20, %o0 <== NOT EXECUTED
}
rc = rtems_rfs_block_map_open (fs, dir, &map);
201c1fc: a6 07 bf b0 add %fp, -80, %l3 <== NOT EXECUTED
201c200: 90 10 00 18 mov %i0, %o0
201c204: 92 10 00 19 mov %i1, %o1
201c208: 7f ff f8 fb call 201a5f4 <rtems_rfs_block_map_open>
201c20c: 94 10 00 13 mov %l3, %o2
if (rc > 0)
201c210: ba 92 20 00 orcc %o0, 0, %i5
201c214: 34 80 00 c5 bg,a 201c528 <rtems_rfs_dir_add_entry+0x38c> <== NEVER TAKEN
201c218: 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)
201c21c: 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;
201c220: c0 2f bf a4 clrb [ %fp + -92 ]
handle->bnum = 0;
201c224: c0 27 bf a8 clr [ %fp + -88 ]
handle->buffer = NULL;
201c228: 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;
201c22c: c0 27 bf 98 clr [ %fp + -104 ]
bpos->boff = 0;
201c230: c0 27 bf 9c clr [ %fp + -100 ]
bpos->block = 0;
201c234: c0 27 bf a0 clr [ %fp + -96 ]
201c238: a8 15 23 ff or %l4, 0x3ff, %l4
{
if ((length + RTEMS_RFS_DIR_ENTRY_SIZE) <
201c23c: 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);
201c240: 90 10 00 18 mov %i0, %o0
201c244: 92 10 00 13 mov %l3, %o1
201c248: 94 07 bf 98 add %fp, -104, %o2
201c24c: 7f ff f9 bf call 201a948 <rtems_rfs_block_map_find>
201c250: 96 07 bf 94 add %fp, -108, %o3
if (rc > 0)
201c254: ba 92 20 00 orcc %o0, 0, %i5
201c258: 04 80 00 29 ble 201c2fc <rtems_rfs_dir_add_entry+0x160>
201c25c: 80 a7 60 06 cmp %i5, 6
{
if (rc != ENXIO)
201c260: 02 80 00 0f be 201c29c <rtems_rfs_dir_add_entry+0x100> <== ALWAYS TAKEN
201c264: 90 10 00 18 mov %i0, %o0
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_ADD_ENTRY))
201c268: 90 10 20 00 clr %o0 <== NOT EXECUTED
201c26c: 7f ff dd 59 call 20137d0 <rtems_rfs_trace> <== NOT EXECUTED
201c270: 13 08 00 00 sethi %hi(0x20000000), %o1 <== NOT EXECUTED
201c274: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
201c278: 22 80 00 a6 be,a 201c510 <rtems_rfs_dir_add_entry+0x374> <== NOT EXECUTED
201c27c: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED
printf ("rtems-rfs: dir-add-entry: "
201c280: f8 06 60 08 ld [ %i1 + 8 ], %i4 <== NOT EXECUTED
201c284: 40 00 1c 0c call 20232b4 <strerror> <== NOT EXECUTED
201c288: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
201c28c: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
201c290: 11 00 80 d0 sethi %hi(0x2034000), %o0 <== NOT EXECUTED
201c294: 10 80 00 15 b 201c2e8 <rtems_rfs_dir_add_entry+0x14c> <== NOT EXECUTED
201c298: 90 12 20 30 or %o0, 0x30, %o0 ! 2034030 <CSWTCH.2+0x950> <== NOT EXECUTED
}
/*
* We have reached the end of the directory so add a block.
*/
rc = rtems_rfs_block_map_grow (fs, &map, 1, &block);
201c29c: 92 10 00 13 mov %l3, %o1
201c2a0: 94 10 20 01 mov 1, %o2
201c2a4: 7f ff fa 2f call 201ab60 <rtems_rfs_block_map_grow>
201c2a8: 96 07 bf 94 add %fp, -108, %o3
if (rc > 0)
201c2ac: ba 92 20 00 orcc %o0, 0, %i5
201c2b0: 04 80 00 14 ble 201c300 <rtems_rfs_dir_add_entry+0x164> <== ALWAYS TAKEN
201c2b4: a0 10 20 00 clr %l0
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_ADD_ENTRY))
201c2b8: 90 10 20 00 clr %o0 <== NOT EXECUTED
201c2bc: 7f ff dd 45 call 20137d0 <rtems_rfs_trace> <== NOT EXECUTED
201c2c0: 13 08 00 00 sethi %hi(0x20000000), %o1 <== NOT EXECUTED
201c2c4: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
201c2c8: 22 80 00 92 be,a 201c510 <rtems_rfs_dir_add_entry+0x374> <== NOT EXECUTED
201c2cc: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED
printf ("rtems-rfs: dir-add-entry: "
201c2d0: f8 06 60 08 ld [ %i1 + 8 ], %i4 <== NOT EXECUTED
201c2d4: 40 00 1b f8 call 20232b4 <strerror> <== NOT EXECUTED
201c2d8: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
201c2dc: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
201c2e0: 11 00 80 d0 sethi %hi(0x2034000), %o0 <== NOT EXECUTED
201c2e4: 90 12 20 78 or %o0, 0x78, %o0 ! 2034078 <CSWTCH.2+0x998> <== NOT EXECUTED
201c2e8: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
201c2ec: 40 00 17 83 call 20220f8 <printf> <== NOT EXECUTED
201c2f0: 94 10 00 1d mov %i5, %o2 <== NOT EXECUTED
entry += elength;
offset += elength;
}
}
rtems_rfs_buffer_handle_close (fs, &buffer);
201c2f4: 10 80 00 87 b 201c510 <rtems_rfs_dir_add_entry+0x374> <== NOT EXECUTED
201c2f8: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED
201c2fc: a0 10 20 01 mov 1, %l0
}
read = false;
}
bpos.bno++;
201c300: c2 07 bf 98 ld [ %fp + -104 ], %g1
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, read);
201c304: d4 07 bf 94 ld [ %fp + -108 ], %o2
}
read = false;
}
bpos.bno++;
201c308: 82 00 60 01 inc %g1
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, read);
201c30c: a0 0c 20 ff and %l0, 0xff, %l0
}
read = false;
}
bpos.bno++;
201c310: c2 27 bf 98 st %g1, [ %fp + -104 ]
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, read);
201c314: 90 10 00 18 mov %i0, %o0
201c318: 92 07 bf a4 add %fp, -92, %o1
201c31c: 7f ff fc a3 call 201b5a8 <rtems_rfs_buffer_handle_request>
201c320: 96 10 00 10 mov %l0, %o3
if (rc > 0)
201c324: ba 92 20 00 orcc %o0, 0, %i5
201c328: 04 80 00 0f ble 201c364 <rtems_rfs_dir_add_entry+0x1c8> <== ALWAYS TAKEN
201c32c: c2 07 bf ac ld [ %fp + -84 ], %g1
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_ADD_ENTRY))
201c330: 90 10 20 00 clr %o0 <== NOT EXECUTED
201c334: 7f ff dd 27 call 20137d0 <rtems_rfs_trace> <== NOT EXECUTED
201c338: 13 08 00 00 sethi %hi(0x20000000), %o1 <== NOT EXECUTED
201c33c: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
201c340: 22 80 00 74 be,a 201c510 <rtems_rfs_dir_add_entry+0x374> <== NOT EXECUTED
201c344: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED
printf ("rtems-rfs: dir-add-entry: "
201c348: f8 06 60 08 ld [ %i1 + 8 ], %i4 <== NOT EXECUTED
201c34c: 40 00 1b da call 20232b4 <strerror> <== NOT EXECUTED
201c350: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
201c354: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
201c358: 11 00 80 d0 sethi %hi(0x2034000), %o0 <== NOT EXECUTED
201c35c: 10 bf ff e3 b 201c2e8 <rtems_rfs_dir_add_entry+0x14c> <== NOT EXECUTED
201c360: 90 12 20 c0 or %o0, 0xc0, %o0 ! 20340c0 <CSWTCH.2+0x9e0> <== NOT EXECUTED
break;
}
entry = rtems_rfs_buffer_data (&buffer);
if (!read)
201c364: 80 a4 20 00 cmp %l0, 0
201c368: 12 80 00 06 bne 201c380 <rtems_rfs_dir_add_entry+0x1e4>
201c36c: fa 00 60 1c ld [ %g1 + 0x1c ], %i5
memset (entry, 0xff, rtems_rfs_fs_block_size (fs));
201c370: d4 06 20 08 ld [ %i0 + 8 ], %o2
201c374: 90 10 00 1d mov %i5, %o0
201c378: 40 00 16 e2 call 2021f00 <memset>
201c37c: 92 10 20 ff mov 0xff, %o1
offset = 0;
while (offset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
201c380: 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;
201c384: a2 10 20 00 clr %l1
while (offset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
201c388: 10 80 00 5d b 201c4fc <rtems_rfs_dir_add_entry+0x360>
201c38c: 84 00 7f f6 add %g1, -10, %g2
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
201c390: e0 0f 60 08 ldub [ %i5 + 8 ], %l0
eino = rtems_rfs_dir_entry_ino (entry);
201c394: 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);
201c398: a1 2c 20 08 sll %l0, 8, %l0
201c39c: a0 14 00 03 or %l0, %g3, %l0
eino = rtems_rfs_dir_entry_ino (entry);
201c3a0: c6 0f 60 01 ldub [ %i5 + 1 ], %g3
201c3a4: a5 2c a0 18 sll %l2, 0x18, %l2
201c3a8: 87 28 e0 10 sll %g3, 0x10, %g3
201c3ac: a4 14 80 03 or %l2, %g3, %l2
201c3b0: c6 0f 60 03 ldub [ %i5 + 3 ], %g3
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
201c3b4: 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);
201c3b8: a4 14 80 03 or %l2, %g3, %l2
201c3bc: c6 0f 60 02 ldub [ %i5 + 2 ], %g3
201c3c0: 87 28 e0 08 sll %g3, 8, %g3
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
201c3c4: 12 80 00 2a bne 201c46c <rtems_rfs_dir_add_entry+0x2d0>
201c3c8: a4 14 80 03 or %l2, %g3, %l2
{
if ((length + RTEMS_RFS_DIR_ENTRY_SIZE) <
(rtems_rfs_fs_block_size (fs) - offset))
201c3cc: 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) <
201c3d0: 80 a5 40 11 cmp %l5, %l1
201c3d4: 3a bf ff 9c bcc,a 201c244 <rtems_rfs_dir_add_entry+0xa8> <== NEVER TAKEN
201c3d8: 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);
201c3dc: 92 10 00 1b mov %i3, %o1
201c3e0: 40 00 11 0b call 202080c <rtems_rfs_dir_hash>
201c3e4: 90 10 00 1a mov %i2, %o0
rtems_rfs_dir_set_entry_hash (entry, hash);
201c3e8: 83 32 20 18 srl %o0, 0x18, %g1
201c3ec: c2 2f 60 04 stb %g1, [ %i5 + 4 ]
201c3f0: 83 32 20 10 srl %o0, 0x10, %g1
201c3f4: c2 2f 60 05 stb %g1, [ %i5 + 5 ]
201c3f8: 83 32 20 08 srl %o0, 8, %g1
201c3fc: c2 2f 60 06 stb %g1, [ %i5 + 6 ]
rtems_rfs_dir_set_entry_ino (entry, ino);
201c400: 83 37 20 18 srl %i4, 0x18, %g1
201c404: c2 2f 40 00 stb %g1, [ %i5 ]
201c408: 83 37 20 10 srl %i4, 0x10, %g1
201c40c: c2 2f 60 01 stb %g1, [ %i5 + 1 ]
201c410: 83 37 20 08 srl %i4, 8, %g1
201c414: c2 2f 60 02 stb %g1, [ %i5 + 2 ]
rtems_rfs_dir_set_entry_length (entry,
201c418: 82 06 e0 0a add %i3, 0xa, %g1
201c41c: 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);
201c420: d0 2f 60 07 stb %o0, [ %i5 + 7 ]
rtems_rfs_dir_set_entry_ino (entry, ino);
rtems_rfs_dir_set_entry_length (entry,
201c424: c4 2f 60 08 stb %g2, [ %i5 + 8 ]
201c428: c2 2f 60 09 stb %g1, [ %i5 + 9 ]
RTEMS_RFS_DIR_ENTRY_SIZE + length);
memcpy (entry + RTEMS_RFS_DIR_ENTRY_SIZE, name, length);
201c42c: 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);
201c430: 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);
201c434: 90 07 60 0a add %i5, 0xa, %o0
201c438: 40 00 16 23 call 2021cc4 <memcpy>
201c43c: 92 10 00 1a mov %i2, %o1
rtems_rfs_buffer_mark_dirty (&buffer);
201c440: 82 10 20 01 mov 1, %g1
rtems_rfs_buffer_handle_close (fs, &buffer);
201c444: 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);
201c448: c2 2f bf a4 stb %g1, [ %fp + -92 ]
rtems_rfs_buffer_handle_close (fs, &buffer);
201c44c: 7f ff fe 0c call 201bc7c <rtems_rfs_buffer_handle_close>
201c450: 90 10 00 18 mov %i0, %o0
rtems_rfs_block_map_close (fs, &map);
201c454: 90 10 00 18 mov %i0, %o0
201c458: 92 07 bf b0 add %fp, -80, %o1
201c45c: 7f ff f8 c7 call 201a778 <rtems_rfs_block_map_close>
201c460: ba 10 20 00 clr %i5
}
rtems_rfs_buffer_handle_close (fs, &buffer);
rtems_rfs_block_map_close (fs, &map);
return rc;
}
201c464: 81 c7 e0 08 ret
201c468: 91 e8 00 1d restore %g0, %i5, %o0
}
break;
}
if (rtems_rfs_dir_entry_valid (fs, elength, eino))
201c46c: 80 a4 20 0a cmp %l0, 0xa
201c470: 04 80 00 0d ble 201c4a4 <rtems_rfs_dir_add_entry+0x308> <== NEVER TAKEN
201c474: 90 10 20 00 clr %o0
201c478: c6 06 20 1c ld [ %i0 + 0x1c ], %g3
201c47c: 80 a4 00 03 cmp %l0, %g3
201c480: 1a 80 00 09 bcc 201c4a4 <rtems_rfs_dir_add_entry+0x308> <== NEVER TAKEN
201c484: 80 a4 a0 00 cmp %l2, 0
201c488: 02 80 00 07 be 201c4a4 <rtems_rfs_dir_add_entry+0x308> <== NEVER TAKEN
201c48c: 01 00 00 00 nop
201c490: c6 06 20 14 ld [ %i0 + 0x14 ], %g3
201c494: 80 a4 80 03 cmp %l2, %g3
201c498: 28 80 00 18 bleu,a 201c4f8 <rtems_rfs_dir_add_entry+0x35c><== ALWAYS TAKEN
201c49c: ba 07 40 10 add %i5, %l0, %i5
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_ADD_ENTRY))
201c4a0: 90 10 20 00 clr %o0 <== NOT EXECUTED
201c4a4: 7f ff dc cb call 20137d0 <rtems_rfs_trace> <== NOT EXECUTED
201c4a8: 13 08 00 00 sethi %hi(0x20000000), %o1 <== NOT EXECUTED
201c4ac: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
201c4b0: 02 80 00 0a be 201c4d8 <rtems_rfs_dir_add_entry+0x33c> <== NOT EXECUTED
201c4b4: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED
printf ("rtems-rfs: dir-add-entry: "
201c4b8: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED
201c4bc: 11 00 80 d0 sethi %hi(0x2034000), %o0 <== NOT EXECUTED
201c4c0: 94 10 00 10 mov %l0, %o2 <== NOT EXECUTED
201c4c4: 90 12 21 08 or %o0, 0x108, %o0 <== NOT EXECUTED
201c4c8: 96 10 00 12 mov %l2, %o3 <== NOT EXECUTED
201c4cc: 40 00 17 0b call 20220f8 <printf> <== NOT EXECUTED
201c4d0: 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);
201c4d4: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED
201c4d8: 7f ff fd e9 call 201bc7c <rtems_rfs_buffer_handle_close> <== NOT EXECUTED
201c4dc: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
rtems_rfs_block_map_close (fs, &map);
201c4e0: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
201c4e4: 92 07 bf b0 add %fp, -80, %o1 <== NOT EXECUTED
201c4e8: 7f ff f8 a4 call 201a778 <rtems_rfs_block_map_close> <== NOT EXECUTED
201c4ec: 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;
}
201c4f0: 81 c7 e0 08 ret <== NOT EXECUTED
201c4f4: 91 e8 00 1d restore %g0, %i5, %o0 <== NOT EXECUTED
rtems_rfs_block_map_close (fs, &map);
return EIO;
}
entry += elength;
offset += elength;
201c4f8: 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))
201c4fc: 80 a4 40 02 cmp %l1, %g2
201c500: 2a bf ff a4 bcs,a 201c390 <rtems_rfs_dir_add_entry+0x1f4><== ALWAYS TAKEN
201c504: 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);
201c508: 10 bf ff 4f b 201c244 <rtems_rfs_dir_add_entry+0xa8> <== NOT EXECUTED
201c50c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
entry += elength;
offset += elength;
}
}
rtems_rfs_buffer_handle_close (fs, &buffer);
201c510: 7f ff fd db call 201bc7c <rtems_rfs_buffer_handle_close> <== NOT EXECUTED
201c514: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
rtems_rfs_block_map_close (fs, &map);
201c518: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
201c51c: 7f ff f8 97 call 201a778 <rtems_rfs_block_map_close> <== NOT EXECUTED
201c520: 92 07 bf b0 add %fp, -80, %o1 <== NOT EXECUTED
return rc;
}
201c524: b0 10 00 1d mov %i5, %i0 <== NOT EXECUTED
201c528: 81 c7 e0 08 ret <== NOT EXECUTED
201c52c: 81 e8 00 00 restore <== NOT EXECUTED
0201c530 <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)
{
201c530: 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))
201c534: 90 10 20 00 clr %o0
201c538: 13 10 00 00 sethi %hi(0x40000000), %o1
201c53c: 7f ff dc a5 call 20137d0 <rtems_rfs_trace>
201c540: ba 10 00 18 mov %i0, %i5
201c544: 80 8a 20 ff btst 0xff, %o0
201c548: 02 80 00 09 be 201c56c <rtems_rfs_dir_del_entry+0x3c> <== ALWAYS TAKEN
201c54c: aa 07 bf b0 add %fp, -80, %l5
printf ("rtems-rfs: dir-del-entry: dir=%" PRId32 ", entry=%" PRId32 " offset=%" PRIu32 "\n",
201c550: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED
201c554: 11 00 80 d0 sethi %hi(0x2034000), %o0 <== NOT EXECUTED
201c558: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED
201c55c: 90 12 21 50 or %o0, 0x150, %o0 <== NOT EXECUTED
201c560: 40 00 16 e6 call 20220f8 <printf> <== NOT EXECUTED
201c564: 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);
201c568: aa 07 bf b0 add %fp, -80, %l5 <== NOT EXECUTED
201c56c: 90 10 00 1d mov %i5, %o0
201c570: 92 10 00 19 mov %i1, %o1
201c574: 7f ff f8 20 call 201a5f4 <rtems_rfs_block_map_open>
201c578: 94 10 00 15 mov %l5, %o2
if (rc > 0)
201c57c: b0 92 20 00 orcc %o0, 0, %i0
201c580: 14 80 00 c4 bg 201c890 <rtems_rfs_dir_del_entry+0x360> <== NEVER TAKEN
201c584: ac 07 bf a0 add %fp, -96, %l6
return rc;
rc = rtems_rfs_block_map_seek (fs, &map, offset, &block);
201c588: 90 10 00 1d mov %i5, %o0
201c58c: 92 10 00 15 mov %l5, %o1
201c590: 94 10 20 00 clr %o2
201c594: 96 10 00 1b mov %i3, %o3
201c598: 7f ff f9 48 call 201aab8 <rtems_rfs_block_map_seek>
201c59c: 98 10 00 16 mov %l6, %o4
if (rc > 0)
201c5a0: b0 92 20 00 orcc %o0, 0, %i0
201c5a4: 04 80 00 06 ble 201c5bc <rtems_rfs_dir_del_entry+0x8c> <== ALWAYS TAKEN
201c5a8: 80 a6 20 06 cmp %i0, 6
{
if (rc == ENXIO)
201c5ac: 22 80 00 b6 be,a 201c884 <rtems_rfs_dir_del_entry+0x354> <== NOT EXECUTED
201c5b0: 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);
201c5b4: 10 80 00 b5 b 201c888 <rtems_rfs_dir_del_entry+0x358> <== NOT EXECUTED
201c5b8: 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)
201c5bc: 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)
201c5c0: 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: "
201c5c4: 2f 00 80 d0 sethi %hi(0x2034000), %l7
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
201c5c8: c0 2f bf a4 clrb [ %fp + -92 ]
handle->bnum = 0;
201c5cc: c0 27 bf a8 clr [ %fp + -88 ]
handle->buffer = NULL;
201c5d0: 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);
201c5d4: 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)
201c5d8: 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)
201c5dc: 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)
201c5e0: 10 80 00 c1 b 201c8e4 <rtems_rfs_dir_del_entry+0x3b4>
201c5e4: ae 15 e1 d8 or %l7, 0x1d8, %l7
{
uint8_t* entry;
int eoffset;
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, true);
201c5e8: 90 10 00 1d mov %i5, %o0
201c5ec: 92 07 bf a4 add %fp, -92, %o1
201c5f0: 7f ff fb ee call 201b5a8 <rtems_rfs_buffer_handle_request>
201c5f4: 96 10 20 01 mov 1, %o3
if (rc > 0)
201c5f8: a4 92 20 00 orcc %o0, 0, %l2
201c5fc: 04 80 00 13 ble 201c648 <rtems_rfs_dir_del_entry+0x118> <== ALWAYS TAKEN
201c600: 80 a4 e0 00 cmp %l3, 0
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY))
201c604: 90 10 20 00 clr %o0 <== NOT EXECUTED
201c608: 7f ff dc 72 call 20137d0 <rtems_rfs_trace> <== NOT EXECUTED
201c60c: 13 10 00 00 sethi %hi(0x40000000), %o1 <== NOT EXECUTED
201c610: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
201c614: 22 80 00 b9 be,a 201c8f8 <rtems_rfs_dir_del_entry+0x3c8> <== NOT EXECUTED
201c618: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED
printf ("rtems-rfs: dir-del-entry: "
201c61c: f8 06 60 08 ld [ %i1 + 8 ], %i4 <== NOT EXECUTED
201c620: 40 00 1b 25 call 20232b4 <strerror> <== NOT EXECUTED
201c624: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED
201c628: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
201c62c: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
201c630: 94 10 00 12 mov %l2, %o2 <== NOT EXECUTED
201c634: 11 00 80 d0 sethi %hi(0x2034000), %o0 <== NOT EXECUTED
201c638: 40 00 16 b0 call 20220f8 <printf> <== NOT EXECUTED
201c63c: 90 12 21 90 or %o0, 0x190, %o0 ! 2034190 <CSWTCH.2+0xab0> <== NOT EXECUTED
if (rc == ENXIO)
rc = ENOENT;
}
}
rtems_rfs_buffer_handle_close (fs, &buffer);
201c640: 10 80 00 ae b 201c8f8 <rtems_rfs_dir_del_entry+0x3c8> <== NOT EXECUTED
201c644: 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)
201c648: 12 80 00 06 bne 201c660 <rtems_rfs_dir_del_entry+0x130> <== NEVER TAKEN
201c64c: a0 10 20 00 clr %l0
eoffset = 0;
else
eoffset = offset % rtems_rfs_fs_block_size (fs);
201c650: d2 07 60 08 ld [ %i5 + 8 ], %o1
201c654: 40 00 47 47 call 202e370 <.urem>
201c658: 90 10 00 1b mov %i3, %o0
201c65c: a0 10 00 08 mov %o0, %l0
entry = rtems_rfs_buffer_data (&buffer) + eoffset;
201c660: c2 07 bf ac ld [ %fp + -84 ], %g1
201c664: f8 00 60 1c ld [ %g1 + 0x1c ], %i4
while (eoffset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
201c668: 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;
201c66c: b8 07 00 10 add %i4, %l0, %i4
while (eoffset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
201c670: 10 80 00 8d b 201c8a4 <rtems_rfs_dir_del_entry+0x374>
201c674: 84 00 7f f6 add %g1, -10, %g2
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
201c678: e2 0f 20 08 ldub [ %i4 + 8 ], %l1
eino = rtems_rfs_dir_entry_ino (entry);
201c67c: 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);
201c680: a3 2c 60 08 sll %l1, 8, %l1
201c684: a2 14 40 03 or %l1, %g3, %l1
eino = rtems_rfs_dir_entry_ino (entry);
201c688: c6 0f 20 01 ldub [ %i4 + 1 ], %g3
201c68c: 97 2a e0 18 sll %o3, 0x18, %o3
201c690: 87 28 e0 10 sll %g3, 0x10, %g3
201c694: 96 12 c0 03 or %o3, %g3, %o3
201c698: c6 0f 20 03 ldub [ %i4 + 3 ], %g3
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
201c69c: 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);
201c6a0: 96 12 c0 03 or %o3, %g3, %o3
201c6a4: c6 0f 20 02 ldub [ %i4 + 2 ], %g3
201c6a8: 87 28 e0 08 sll %g3, 8, %g3
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
201c6ac: 02 80 00 81 be 201c8b0 <rtems_rfs_dir_del_entry+0x380> <== NEVER TAKEN
201c6b0: 96 12 c0 03 or %o3, %g3, %o3
break;
if (rtems_rfs_dir_entry_valid (fs, elength, eino))
201c6b4: 80 a4 60 0a cmp %l1, 0xa
201c6b8: 24 80 00 0d ble,a 201c6ec <rtems_rfs_dir_del_entry+0x1bc><== NEVER TAKEN
201c6bc: d6 27 bf 9c st %o3, [ %fp + -100 ] <== NOT EXECUTED
201c6c0: c6 07 60 1c ld [ %i5 + 0x1c ], %g3
201c6c4: 80 a4 40 03 cmp %l1, %g3
201c6c8: 1a 80 00 08 bcc 201c6e8 <rtems_rfs_dir_del_entry+0x1b8> <== NEVER TAKEN
201c6cc: 80 a2 e0 00 cmp %o3, 0
201c6d0: 22 80 00 07 be,a 201c6ec <rtems_rfs_dir_del_entry+0x1bc> <== NEVER TAKEN
201c6d4: d6 27 bf 9c st %o3, [ %fp + -100 ] <== NOT EXECUTED
201c6d8: c6 07 60 14 ld [ %i5 + 0x14 ], %g3
201c6dc: 80 a2 c0 03 cmp %o3, %g3
201c6e0: 08 80 00 11 bleu 201c724 <rtems_rfs_dir_del_entry+0x1f4> <== ALWAYS TAKEN
201c6e4: 80 a6 80 0b cmp %i2, %o3
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY))
201c6e8: d6 27 bf 9c st %o3, [ %fp + -100 ] <== NOT EXECUTED
201c6ec: 90 10 20 00 clr %o0 <== NOT EXECUTED
201c6f0: 7f ff dc 38 call 20137d0 <rtems_rfs_trace> <== NOT EXECUTED
201c6f4: 13 10 00 00 sethi %hi(0x40000000), %o1 <== NOT EXECUTED
201c6f8: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
201c6fc: 02 80 00 87 be 201c918 <rtems_rfs_dir_del_entry+0x3e8> <== NOT EXECUTED
201c700: d6 07 bf 9c ld [ %fp + -100 ], %o3 <== NOT EXECUTED
printf ("rtems-rfs: dir-del-entry: "
201c704: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED
201c708: d8 07 bf a0 ld [ %fp + -96 ], %o4 <== NOT EXECUTED
201c70c: 90 10 00 17 mov %l7, %o0 <== NOT EXECUTED
201c710: 94 10 00 11 mov %l1, %o2 <== NOT EXECUTED
201c714: 40 00 16 79 call 20220f8 <printf> <== NOT EXECUTED
201c718: 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);
201c71c: 10 80 00 71 b 201c8e0 <rtems_rfs_dir_del_entry+0x3b0> <== NOT EXECUTED
201c720: 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))
201c724: 12 80 00 5d bne 201c898 <rtems_rfs_dir_del_entry+0x368> <== NEVER TAKEN
201c728: 80 a4 e0 00 cmp %l3, 0
{
uint32_t remaining;
remaining = rtems_rfs_fs_block_size (fs) - (eoffset + elength);
memmove (entry, entry + elength, remaining);
201c72c: 92 07 00 11 add %i4, %l1, %o1
201c730: 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);
201c734: b6 04 00 11 add %l0, %l1, %i3
201c738: b6 20 40 1b sub %g1, %i3, %i3
memmove (entry, entry + elength, remaining);
201c73c: 40 00 15 9f call 2021db8 <memmove>
201c740: 94 10 00 1b mov %i3, %o2
memset (entry + remaining, 0xff, elength);
201c744: 90 07 00 1b add %i4, %i3, %o0
201c748: 92 10 20 ff mov 0xff, %o1
201c74c: 40 00 15 ed call 2021f00 <memset>
201c750: 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);
201c754: c4 0f 20 08 ldub [ %i4 + 8 ], %g2
201c758: c2 0f 20 09 ldub [ %i4 + 9 ], %g1
201c75c: 85 28 a0 08 sll %g2, 8, %g2
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY))
201c760: 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);
201c764: b8 10 80 01 or %g2, %g1, %i4
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY))
201c768: 7f ff dc 1a call 20137d0 <rtems_rfs_trace>
201c76c: 13 10 00 00 sethi %hi(0x40000000), %o1
201c770: 80 8a 20 ff btst 0xff, %o0
201c774: 02 80 00 1a be 201c7dc <rtems_rfs_dir_del_entry+0x2ac> <== ALWAYS TAKEN
201c778: 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");
201c77c: 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: "
201c780: d6 07 bf a0 ld [ %fp + -96 ], %o3 <== NOT EXECUTED
201c784: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
201c788: 12 80 00 08 bne 201c7a8 <rtems_rfs_dir_del_entry+0x278> <== NOT EXECUTED
201c78c: 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");
201c790: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED
201c794: 12 80 00 06 bne 201c7ac <rtems_rfs_dir_del_entry+0x27c> <== NOT EXECUTED
201c798: 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: "
201c79c: 1b 00 80 cb sethi %hi(0x2032c00), %o5 <== NOT EXECUTED
201c7a0: 10 80 00 08 b 201c7c0 <rtems_rfs_dir_del_entry+0x290> <== NOT EXECUTED
201c7a4: 9a 13 61 28 or %o5, 0x128, %o5 ! 2032d28 <_CPU_Trap_slot_template+0xaf0><== 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");
201c7a8: 84 00 bf ff add %g2, -1, %g2 <== NOT EXECUTED
201c7ac: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED
201c7b0: 02 bf ff fc be 201c7a0 <rtems_rfs_dir_del_entry+0x270> <== NOT EXECUTED
201c7b4: 1b 00 80 cb sethi %hi(0x2032c00), %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: "
201c7b8: 1b 00 80 c3 sethi %hi(0x2030c00), %o5 <== NOT EXECUTED
201c7bc: 9a 13 62 18 or %o5, 0x218, %o5 ! 2030e18 <__FUNCTION__.7059+0x5f8><== NOT EXECUTED
201c7c0: 11 00 80 d0 sethi %hi(0x2034000), %o0 <== NOT EXECUTED
201c7c4: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED
201c7c8: 90 12 22 28 or %o0, 0x228, %o0 <== NOT EXECUTED
201c7cc: 94 10 00 1c mov %i4, %o2 <== NOT EXECUTED
201c7d0: 40 00 16 4a call 20220f8 <printf> <== NOT EXECUTED
201c7d4: 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) &&
201c7d8: 03 3f ff c0 sethi %hi(0xffff0000), %g1 <== NOT EXECUTED
201c7dc: b8 38 40 1c xnor %g1, %i4, %i4
201c7e0: 80 a7 20 00 cmp %i4, 0
201c7e4: 12 80 00 23 bne 201c870 <rtems_rfs_dir_del_entry+0x340>
201c7e8: 80 a4 20 00 cmp %l0, 0
201c7ec: 12 80 00 21 bne 201c870 <rtems_rfs_dir_del_entry+0x340> <== ALWAYS TAKEN
201c7f0: c2 07 bf c0 ld [ %fp + -64 ], %g1
(eoffset == 0) && rtems_rfs_block_map_last (&map))
201c7f4: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
201c7f8: 12 80 00 05 bne 201c80c <rtems_rfs_dir_del_entry+0x2dc> <== NOT EXECUTED
201c7fc: c4 07 bf b8 ld [ %fp + -72 ], %g2 <== NOT EXECUTED
201c800: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED
201c804: 02 80 00 07 be 201c820 <rtems_rfs_dir_del_entry+0x2f0> <== NOT EXECUTED
201c808: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
201c80c: 84 00 bf ff add %g2, -1, %g2 <== NOT EXECUTED
201c810: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED
201c814: 12 80 00 18 bne 201c874 <rtems_rfs_dir_del_entry+0x344> <== NOT EXECUTED
201c818: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED
{
rc = rtems_rfs_block_map_shrink (fs, &map, 1);
201c81c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
201c820: 92 07 bf b0 add %fp, -80, %o1 <== NOT EXECUTED
201c824: 7f ff f9 bf call 201af20 <rtems_rfs_block_map_shrink> <== NOT EXECUTED
201c828: 94 10 20 01 mov 1, %o2 <== NOT EXECUTED
if (rc > 0)
201c82c: b8 92 20 00 orcc %o0, 0, %i4 <== NOT EXECUTED
201c830: 04 80 00 10 ble 201c870 <rtems_rfs_dir_del_entry+0x340> <== NOT EXECUTED
201c834: 90 10 20 00 clr %o0 <== NOT EXECUTED
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY))
201c838: 7f ff db e6 call 20137d0 <rtems_rfs_trace> <== NOT EXECUTED
201c83c: 13 10 00 00 sethi %hi(0x40000000), %o1 <== NOT EXECUTED
201c840: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
201c844: 02 80 00 0c be 201c874 <rtems_rfs_dir_del_entry+0x344> <== NOT EXECUTED
201c848: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED
printf ("rtems-rfs: dir-del-entry: "
201c84c: f6 06 60 08 ld [ %i1 + 8 ], %i3 <== NOT EXECUTED
201c850: 40 00 1a 99 call 20232b4 <strerror> <== NOT EXECUTED
201c854: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
201c858: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
201c85c: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
201c860: 94 10 00 1c mov %i4, %o2 <== NOT EXECUTED
201c864: 11 00 80 d0 sethi %hi(0x2034000), %o0 <== NOT EXECUTED
201c868: 40 00 16 24 call 20220f8 <printf> <== NOT EXECUTED
201c86c: 90 12 22 88 or %o0, 0x288, %o0 ! 2034288 <CSWTCH.2+0xba8> <== 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);
201c870: 82 10 20 01 mov 1, %g1
rtems_rfs_buffer_handle_close (fs, &buffer);
201c874: 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);
201c878: c2 2f bf a4 stb %g1, [ %fp + -92 ]
rtems_rfs_buffer_handle_close (fs, &buffer);
201c87c: 7f ff fd 00 call 201bc7c <rtems_rfs_buffer_handle_close>
201c880: 92 07 bf a4 add %fp, -92, %o1
rtems_rfs_block_map_close (fs, &map);
201c884: 90 10 00 1d mov %i5, %o0
201c888: 7f ff f7 bc call 201a778 <rtems_rfs_block_map_close>
201c88c: 92 07 bf b0 add %fp, -80, %o1
201c890: 81 c7 e0 08 ret
201c894: 81 e8 00 00 restore
return 0;
}
if (!search)
201c898: 02 80 00 20 be 201c918 <rtems_rfs_dir_del_entry+0x3e8> <== NOT EXECUTED
201c89c: b8 07 00 11 add %i4, %l1, %i4 <== NOT EXECUTED
rc = EIO;
break;
}
entry += elength;
eoffset += elength;
201c8a0: 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))
201c8a4: 80 a4 00 02 cmp %l0, %g2
201c8a8: 2a bf ff 74 bcs,a 201c678 <rtems_rfs_dir_del_entry+0x148><== ALWAYS TAKEN
201c8ac: c6 0f 20 09 ldub [ %i4 + 9 ], %g3
entry += elength;
eoffset += elength;
}
if (rc == 0)
201c8b0: 80 a4 a0 00 cmp %l2, 0 <== NOT EXECUTED
201c8b4: 32 80 00 0c bne,a 201c8e4 <rtems_rfs_dir_del_entry+0x3b4><== NOT EXECUTED
201c8b8: b0 10 00 12 mov %l2, %i0 <== NOT EXECUTED
{
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
201c8bc: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
201c8c0: 92 10 00 15 mov %l5, %o1 <== NOT EXECUTED
201c8c4: 7f ff f8 9a call 201ab2c <rtems_rfs_block_map_next_block> <== NOT EXECUTED
201c8c8: 94 10 00 16 mov %l6, %o2 <== NOT EXECUTED
if (rc == ENXIO)
201c8cc: 80 a2 20 06 cmp %o0, 6 <== NOT EXECUTED
201c8d0: 12 80 00 05 bne 201c8e4 <rtems_rfs_dir_del_entry+0x3b4> <== NOT EXECUTED
201c8d4: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED
rc = ENOENT;
201c8d8: 10 80 00 06 b 201c8f0 <rtems_rfs_dir_del_entry+0x3c0> <== NOT EXECUTED
201c8dc: 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);
201c8e0: 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)
201c8e4: 80 a6 20 00 cmp %i0, 0
201c8e8: 02 bf ff 40 be 201c5e8 <rtems_rfs_dir_del_entry+0xb8> <== ALWAYS TAKEN
201c8ec: d4 07 bf a0 ld [ %fp + -96 ], %o2
201c8f0: a4 10 00 18 mov %i0, %l2 <== NOT EXECUTED
if (rc == ENXIO)
rc = ENOENT;
}
}
rtems_rfs_buffer_handle_close (fs, &buffer);
201c8f4: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED
201c8f8: 7f ff fc e1 call 201bc7c <rtems_rfs_buffer_handle_close> <== NOT EXECUTED
201c8fc: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
rtems_rfs_block_map_close (fs, &map);
201c900: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
201c904: 92 07 bf b0 add %fp, -80, %o1 <== NOT EXECUTED
201c908: 7f ff f7 9c call 201a778 <rtems_rfs_block_map_close> <== NOT EXECUTED
201c90c: b0 10 00 12 mov %l2, %i0 <== NOT EXECUTED
201c910: 81 c7 e0 08 ret <== NOT EXECUTED
201c914: 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);
201c918: 10 bf ff f2 b 201c8e0 <rtems_rfs_dir_del_entry+0x3b0> <== NOT EXECUTED
201c91c: a4 10 20 05 mov 5, %l2 <== NOT EXECUTED
0201ccb0 <rtems_rfs_dir_empty>:
int
rtems_rfs_dir_empty (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* dir)
{
201ccb0: 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))
201ccb4: 90 10 20 00 clr %o0
201ccb8: 7f ff da c6 call 20137d0 <rtems_rfs_trace>
201ccbc: 13 20 00 00 sethi %hi(0x80000000), %o1
201ccc0: 80 8a 20 ff btst 0xff, %o0
201ccc4: 02 80 00 07 be 201cce0 <rtems_rfs_dir_empty+0x30> <== ALWAYS TAKEN
201ccc8: b8 07 bf b0 add %fp, -80, %i4
printf ("rtems-rfs: dir-empty: dir=%" PRId32 "\n", rtems_rfs_inode_ino (dir));
201cccc: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED
201ccd0: 11 00 80 d0 sethi %hi(0x2034000), %o0 <== NOT EXECUTED
201ccd4: 40 00 15 09 call 20220f8 <printf> <== NOT EXECUTED
201ccd8: 90 12 23 b8 or %o0, 0x3b8, %o0 ! 20343b8 <CSWTCH.2+0xcd8> <== NOT EXECUTED
empty = true;
rc = rtems_rfs_block_map_open (fs, dir, &map);
201ccdc: b8 07 bf b0 add %fp, -80, %i4 <== NOT EXECUTED
201cce0: 90 10 00 18 mov %i0, %o0
201cce4: 92 10 00 19 mov %i1, %o1
201cce8: 7f ff f6 43 call 201a5f4 <rtems_rfs_block_map_open>
201ccec: 94 10 00 1c mov %i4, %o2
if (rc > 0)
201ccf0: ba 92 20 00 orcc %o0, 0, %i5
201ccf4: 34 80 00 82 bg,a 201cefc <rtems_rfs_dir_empty+0x24c> <== NEVER TAKEN
201ccf8: b0 10 00 1d mov %i5, %i0 <== NOT EXECUTED
return rc;
rc = rtems_rfs_block_map_seek (fs, &map, 0, &block);
201ccfc: b6 07 bf a0 add %fp, -96, %i3
201cd00: 90 10 00 18 mov %i0, %o0
201cd04: 92 10 00 1c mov %i4, %o1
201cd08: 94 10 20 00 clr %o2
201cd0c: 96 10 20 00 clr %o3
201cd10: 7f ff f7 6a call 201aab8 <rtems_rfs_block_map_seek>
201cd14: 98 10 00 1b mov %i3, %o4
if (rc > 0)
201cd18: ba 92 20 00 orcc %o0, 0, %i5
201cd1c: 04 80 00 05 ble 201cd30 <rtems_rfs_dir_empty+0x80> <== ALWAYS TAKEN
201cd20: 25 00 00 3f sethi %hi(0xfc00), %l2
{
rtems_rfs_block_map_close (fs, &map);
201cd24: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
201cd28: 10 80 00 69 b 201cecc <rtems_rfs_dir_empty+0x21c> <== NOT EXECUTED
201cd2c: 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: "
201cd30: 27 00 80 d0 sethi %hi(0x2034000), %l3
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
201cd34: c0 2f bf a4 clrb [ %fp + -92 ]
handle->bnum = 0;
201cd38: c0 27 bf a8 clr [ %fp + -88 ]
handle->buffer = NULL;
201cd3c: 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)
201cd40: 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: "
201cd44: a6 14 e3 d8 or %l3, 0x3d8, %l3
offset += elength;
}
if (empty)
{
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
201cd48: a2 10 00 1c mov %i4, %l1
201cd4c: a0 10 00 1b mov %i3, %l0
while (empty)
{
uint8_t* entry;
int offset;
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, true);
201cd50: d4 07 bf a0 ld [ %fp + -96 ], %o2
201cd54: 90 10 00 18 mov %i0, %o0
201cd58: 92 07 bf a4 add %fp, -92, %o1
201cd5c: 7f ff fa 13 call 201b5a8 <rtems_rfs_buffer_handle_request>
201cd60: 96 10 20 01 mov 1, %o3
if (rc > 0)
201cd64: ba 92 20 00 orcc %o0, 0, %i5
201cd68: 14 80 00 4c bg 201ce98 <rtems_rfs_dir_empty+0x1e8> <== NEVER TAKEN
201cd6c: 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))
201cd70: 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);
201cd74: c2 00 60 1c ld [ %g1 + 0x1c ], %g1
offset = 0;
while (offset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
201cd78: 84 00 bf f6 add %g2, -10, %g2
201cd7c: 10 80 00 3b b 201ce68 <rtems_rfs_dir_empty+0x1b8>
201cd80: b6 10 20 00 clr %i3
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
201cd84: f8 08 60 08 ldub [ %g1 + 8 ], %i4
eino = rtems_rfs_dir_entry_ino (entry);
201cd88: 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);
201cd8c: b9 2f 20 08 sll %i4, 8, %i4
201cd90: b8 17 00 03 or %i4, %g3, %i4
eino = rtems_rfs_dir_entry_ino (entry);
201cd94: c6 08 60 01 ldub [ %g1 + 1 ], %g3
201cd98: b5 2e a0 18 sll %i2, 0x18, %i2
201cd9c: 87 28 e0 10 sll %g3, 0x10, %g3
201cda0: b4 16 80 03 or %i2, %g3, %i2
201cda4: c6 08 60 03 ldub [ %g1 + 3 ], %g3
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
201cda8: 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);
201cdac: b4 16 80 03 or %i2, %g3, %i2
201cdb0: c6 08 60 02 ldub [ %g1 + 2 ], %g3
201cdb4: 87 28 e0 08 sll %g3, 8, %g3
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
201cdb8: 02 80 00 48 be 201ced8 <rtems_rfs_dir_empty+0x228>
201cdbc: b4 16 80 03 or %i2, %g3, %i2
break;
if (rtems_rfs_dir_entry_valid (fs, elength, eino))
201cdc0: 80 a7 20 0a cmp %i4, 0xa
201cdc4: 04 80 00 0d ble 201cdf8 <rtems_rfs_dir_empty+0x148> <== NEVER TAKEN
201cdc8: 90 10 20 01 mov 1, %o0
201cdcc: c6 06 20 1c ld [ %i0 + 0x1c ], %g3
201cdd0: 80 a7 00 03 cmp %i4, %g3
201cdd4: 1a 80 00 09 bcc 201cdf8 <rtems_rfs_dir_empty+0x148> <== NEVER TAKEN
201cdd8: 80 a6 a0 00 cmp %i2, 0
201cddc: 02 80 00 07 be 201cdf8 <rtems_rfs_dir_empty+0x148> <== NEVER TAKEN
201cde0: 01 00 00 00 nop
201cde4: c6 06 20 14 ld [ %i0 + 0x14 ], %g3
201cde8: 80 a6 80 03 cmp %i2, %g3
201cdec: 08 80 00 10 bleu 201ce2c <rtems_rfs_dir_empty+0x17c> <== ALWAYS TAKEN
201cdf0: 80 a7 20 0b cmp %i4, 0xb
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_EMPTY))
201cdf4: 90 10 20 01 mov 1, %o0 <== NOT EXECUTED
201cdf8: 7f ff da 76 call 20137d0 <rtems_rfs_trace> <== NOT EXECUTED
201cdfc: 92 10 20 00 clr %o1 <== NOT EXECUTED
201ce00: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
201ce04: 22 80 00 36 be,a 201cedc <rtems_rfs_dir_empty+0x22c> <== NOT EXECUTED
201ce08: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
printf ("rtems-rfs: dir-empty: "
201ce0c: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED
201ce10: 90 10 00 13 mov %l3, %o0 <== NOT EXECUTED
201ce14: 94 10 00 1c mov %i4, %o2 <== NOT EXECUTED
201ce18: 96 10 00 1a mov %i2, %o3 <== NOT EXECUTED
201ce1c: 40 00 14 b7 call 20220f8 <printf> <== NOT EXECUTED
201ce20: 98 10 00 1b mov %i3, %o4 <== NOT EXECUTED
offset += elength;
}
if (empty)
{
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
201ce24: 10 80 00 2e b 201cedc <rtems_rfs_dir_empty+0x22c> <== NOT EXECUTED
201ce28: 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)) ||
201ce2c: 12 80 00 04 bne 201ce3c <rtems_rfs_dir_empty+0x18c>
201ce30: 80 a7 20 0c cmp %i4, 0xc
201ce34: 10 80 00 09 b 201ce58 <rtems_rfs_dir_empty+0x1a8>
201ce38: c6 08 60 0a ldub [ %g1 + 0xa ], %g3
(entry[RTEMS_RFS_DIR_ENTRY_SIZE] != '.')) &&
201ce3c: 32 80 00 18 bne,a 201ce9c <rtems_rfs_dir_empty+0x1ec>
201ce40: 82 10 20 00 clr %g1
((elength != (RTEMS_RFS_DIR_ENTRY_SIZE + 2)) ||
201ce44: c6 08 60 0a ldub [ %g1 + 0xa ], %g3
201ce48: 80 a0 e0 2e cmp %g3, 0x2e
201ce4c: 32 80 00 14 bne,a 201ce9c <rtems_rfs_dir_empty+0x1ec> <== NEVER TAKEN
201ce50: 82 10 20 00 clr %g1 <== NOT EXECUTED
(entry[RTEMS_RFS_DIR_ENTRY_SIZE] != '.') ||
201ce54: c6 08 60 0b ldub [ %g1 + 0xb ], %g3
201ce58: 80 a0 e0 2e cmp %g3, 0x2e
201ce5c: 12 80 00 0c bne 201ce8c <rtems_rfs_dir_empty+0x1dc> <== NEVER TAKEN
201ce60: b6 06 c0 1c add %i3, %i4, %i3
{
empty = false;
break;
}
entry += elength;
201ce64: 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))
201ce68: 80 a6 c0 02 cmp %i3, %g2
201ce6c: 2a bf ff c6 bcs,a 201cd84 <rtems_rfs_dir_empty+0xd4> <== ALWAYS TAKEN
201ce70: c6 08 60 09 ldub [ %g1 + 9 ], %g3
offset += elength;
}
if (empty)
{
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
201ce74: 10 80 00 1a b 201cedc <rtems_rfs_dir_empty+0x22c> <== NOT EXECUTED
201ce78: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
if (rc > 0)
{
if (rc == ENXIO)
201ce7c: 02 80 00 06 be 201ce94 <rtems_rfs_dir_empty+0x1e4> <== ALWAYS TAKEN
201ce80: 82 10 20 01 mov 1, %g1
break;
}
}
}
if ((rc == 0) && !empty)
201ce84: 10 80 00 07 b 201cea0 <rtems_rfs_dir_empty+0x1f0> <== NOT EXECUTED
201ce88: 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] != '.') ||
201ce8c: 10 80 00 04 b 201ce9c <rtems_rfs_dir_empty+0x1ec> <== NOT EXECUTED
201ce90: 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;
201ce94: ba 10 20 00 clr %i5
if (empty)
{
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
if (rc > 0)
{
if (rc == ENXIO)
201ce98: 82 10 20 01 mov 1, %g1
break;
}
}
}
if ((rc == 0) && !empty)
201ce9c: 82 18 60 01 xor %g1, 1, %g1
201cea0: 80 88 60 ff btst 0xff, %g1
201cea4: 02 80 00 06 be 201cebc <rtems_rfs_dir_empty+0x20c>
201cea8: 92 07 bf a4 add %fp, -92, %o1
201ceac: 80 a7 60 00 cmp %i5, 0
201ceb0: 22 80 00 03 be,a 201cebc <rtems_rfs_dir_empty+0x20c> <== ALWAYS TAKEN
201ceb4: ba 10 20 5a mov 0x5a, %i5
rc = ENOTEMPTY;
rtems_rfs_buffer_handle_close (fs, &buffer);
201ceb8: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED
201cebc: 7f ff fb 70 call 201bc7c <rtems_rfs_buffer_handle_close>
201cec0: 90 10 00 18 mov %i0, %o0
rtems_rfs_block_map_close (fs, &map);
201cec4: 90 10 00 18 mov %i0, %o0
201cec8: 92 07 bf b0 add %fp, -80, %o1
201cecc: 7f ff f6 2b call 201a778 <rtems_rfs_block_map_close>
201ced0: b0 10 00 1d mov %i5, %i0
201ced4: 30 80 00 0a b,a 201cefc <rtems_rfs_dir_empty+0x24c>
offset += elength;
}
if (empty)
{
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
201ced8: 90 10 00 18 mov %i0, %o0
201cedc: 92 10 00 11 mov %l1, %o1
201cee0: 7f ff f7 13 call 201ab2c <rtems_rfs_block_map_next_block>
201cee4: 94 10 00 10 mov %l0, %o2
if (rc > 0)
201cee8: ba 92 20 00 orcc %o0, 0, %i5
201ceec: 24 bf ff 9a ble,a 201cd54 <rtems_rfs_dir_empty+0xa4> <== NEVER TAKEN
201cef0: d4 07 bf a0 ld [ %fp + -96 ], %o2 <== NOT EXECUTED
{
if (rc == ENXIO)
201cef4: 10 bf ff e2 b 201ce7c <rtems_rfs_dir_empty+0x1cc>
201cef8: 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;
}
201cefc: 81 c7 e0 08 ret
201cf00: 81 e8 00 00 restore
0202080c <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;
202080c: 05 37 f7 c5 sethi %hi(0xdfdf1400), %g2
2020810: 84 10 a2 9f or %g2, 0x29f, %g2 ! dfdf169f <RAM_END+0xdd9f169f>
2020814: 84 02 40 02 add %o1, %g2, %g2
2020818: 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)
202081c: 10 80 00 48 b 202093c <rtems_rfs_dir_hash+0x130>
2020820: 88 10 00 02 mov %g2, %g4
{
a += k[0];
a += ((uint32_t)k[1])<<8;
a += ((uint32_t)k[2])<<16;
2020824: 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];
2020828: 88 03 40 04 add %o5, %g4, %g4
a += ((uint32_t)k[1])<<8;
202082c: da 0a 20 01 ldub [ %o0 + 1 ], %o5
a += ((uint32_t)k[2])<<16;
2020830: 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;
2020834: 9b 2b 60 08 sll %o5, 8, %o5
2020838: 9a 01 00 0d add %g4, %o5, %o5
a += ((uint32_t)k[2])<<16;
a += ((uint32_t)k[3])<<24;
b += k[4];
202083c: 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;
2020840: 9a 03 40 0c add %o5, %o4, %o5
a += ((uint32_t)k[3])<<24;
b += k[4];
2020844: 86 01 00 03 add %g4, %g3, %g3
b += ((uint32_t)k[5])<<8;
2020848: 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;
202084c: d8 0a 20 03 ldub [ %o0 + 3 ], %o4
b += k[4];
b += ((uint32_t)k[5])<<8;
2020850: 89 29 20 08 sll %g4, 8, %g4
2020854: 86 00 c0 04 add %g3, %g4, %g3
b += ((uint32_t)k[6])<<16;
2020858: 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;
202085c: 99 2b 20 18 sll %o4, 0x18, %o4
b += k[4];
b += ((uint32_t)k[5])<<8;
b += ((uint32_t)k[6])<<16;
2020860: 89 29 20 10 sll %g4, 0x10, %g4
2020864: 86 00 c0 04 add %g3, %g4, %g3
b += ((uint32_t)k[7])<<24;
2020868: 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;
202086c: 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;
2020870: 89 29 20 18 sll %g4, 0x18, %g4
2020874: 86 00 c0 04 add %g3, %g4, %g3
c += k[8];
2020878: 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;
202087c: 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];
2020880: 84 01 00 02 add %g4, %g2, %g2
c += ((uint32_t)k[9])<<8;
2020884: c8 0a 20 09 ldub [ %o0 + 9 ], %g4
2020888: 89 29 20 08 sll %g4, 8, %g4
202088c: 84 00 80 04 add %g2, %g4, %g2
c += ((uint32_t)k[10])<<16;
2020890: c8 0a 20 0a ldub [ %o0 + 0xa ], %g4
2020894: 89 29 20 10 sll %g4, 0x10, %g4
2020898: 84 00 80 04 add %g2, %g4, %g2
c += ((uint32_t)k[11])<<24;
202089c: c8 0a 20 0b ldub [ %o0 + 0xb ], %g4
mix(a,b,c);
length -= 12;
k += 12;
20208a0: 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;
20208a4: 89 29 20 18 sll %g4, 0x18, %g4
20208a8: 84 00 80 04 add %g2, %g4, %g2
mix(a,b,c);
20208ac: 9a 23 40 02 sub %o5, %g2, %o5
20208b0: 99 28 a0 04 sll %g2, 4, %o4
20208b4: 89 30 a0 1c srl %g2, 0x1c, %g4
20208b8: 88 13 00 04 or %o4, %g4, %g4
20208bc: 88 1b 40 04 xor %o5, %g4, %g4
20208c0: 99 29 20 06 sll %g4, 6, %o4
20208c4: 9b 31 20 1a srl %g4, 0x1a, %o5
20208c8: 9a 13 00 0d or %o4, %o5, %o5
20208cc: 84 00 80 03 add %g2, %g3, %g2
20208d0: 86 20 c0 04 sub %g3, %g4, %g3
20208d4: 86 1b 40 03 xor %o5, %g3, %g3
20208d8: 99 28 e0 08 sll %g3, 8, %o4
20208dc: 9b 30 e0 18 srl %g3, 0x18, %o5
20208e0: 9a 13 00 0d or %o4, %o5, %o5
20208e4: 88 01 00 02 add %g4, %g2, %g4
20208e8: 84 20 80 03 sub %g2, %g3, %g2
20208ec: 84 1b 40 02 xor %o5, %g2, %g2
20208f0: 99 28 a0 10 sll %g2, 0x10, %o4
20208f4: 9b 30 a0 10 srl %g2, 0x10, %o5
20208f8: 9a 13 00 0d or %o4, %o5, %o5
20208fc: 86 00 c0 04 add %g3, %g4, %g3
2020900: 88 21 00 02 sub %g4, %g2, %g4
2020904: 88 1b 40 04 xor %o5, %g4, %g4
2020908: 99 29 20 13 sll %g4, 0x13, %o4
202090c: 9b 31 20 0d srl %g4, 0xd, %o5
2020910: 9a 13 00 0d or %o4, %o5, %o5
2020914: 84 00 80 03 add %g2, %g3, %g2
2020918: 86 20 c0 04 sub %g3, %g4, %g3
202091c: 88 01 00 02 add %g4, %g2, %g4
2020920: 86 1b 40 03 xor %o5, %g3, %g3
2020924: 84 20 80 03 sub %g2, %g3, %g2
2020928: 99 28 e0 04 sll %g3, 4, %o4
202092c: 9b 30 e0 1c srl %g3, 0x1c, %o5
2020930: 86 00 c0 04 add %g3, %g4, %g3
2020934: 9a 13 00 0d or %o4, %o5, %o5
2020938: 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)
202093c: 80 a2 60 0c cmp %o1, 0xc
2020940: 38 bf ff b9 bgu,a 2020824 <rtems_rfs_dir_hash+0x18>
2020944: 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 */
2020948: 92 02 7f ff add %o1, -1, %o1
202094c: 80 a2 60 0b cmp %o1, 0xb
2020950: 18 80 00 4b bgu 2020a7c <rtems_rfs_dir_hash+0x270> <== NEVER TAKEN
2020954: 93 2a 60 02 sll %o1, 2, %o1
2020958: 1b 00 80 81 sethi %hi(0x2020400), %o5
202095c: 9a 13 63 dc or %o5, 0x3dc, %o5 ! 20207dc <rtems_rfs_buffer_bdbuf_release+0x80>
2020960: da 03 40 09 ld [ %o5 + %o1 ], %o5
2020964: 81 c3 40 00 jmp %o5
2020968: 01 00 00 00 nop
{
case 12: c+=((uint32_t)k[11])<<24;
202096c: da 0a 20 0b ldub [ %o0 + 0xb ], %o5
2020970: 9b 2b 60 18 sll %o5, 0x18, %o5
2020974: 84 03 40 02 add %o5, %g2, %g2
case 11: c+=((uint32_t)k[10])<<16;
2020978: da 0a 20 0a ldub [ %o0 + 0xa ], %o5
202097c: 9b 2b 60 10 sll %o5, 0x10, %o5
2020980: 84 00 80 0d add %g2, %o5, %g2
case 10: c+=((uint32_t)k[9])<<8;
2020984: da 0a 20 09 ldub [ %o0 + 9 ], %o5
2020988: 9b 2b 60 08 sll %o5, 8, %o5
202098c: 84 00 80 0d add %g2, %o5, %g2
case 9 : c+=k[8];
2020990: da 0a 20 08 ldub [ %o0 + 8 ], %o5
2020994: 84 00 80 0d add %g2, %o5, %g2
case 8 : b+=((uint32_t)k[7])<<24;
2020998: da 0a 20 07 ldub [ %o0 + 7 ], %o5
202099c: 9b 2b 60 18 sll %o5, 0x18, %o5
20209a0: 86 03 40 03 add %o5, %g3, %g3
case 7 : b+=((uint32_t)k[6])<<16;
20209a4: da 0a 20 06 ldub [ %o0 + 6 ], %o5
20209a8: 9b 2b 60 10 sll %o5, 0x10, %o5
20209ac: 86 00 c0 0d add %g3, %o5, %g3
case 6 : b+=((uint32_t)k[5])<<8;
20209b0: da 0a 20 05 ldub [ %o0 + 5 ], %o5
20209b4: 9b 2b 60 08 sll %o5, 8, %o5
20209b8: 86 00 c0 0d add %g3, %o5, %g3
case 5 : b+=k[4];
20209bc: da 0a 20 04 ldub [ %o0 + 4 ], %o5
20209c0: 86 00 c0 0d add %g3, %o5, %g3
case 4 : a+=((uint32_t)k[3])<<24;
20209c4: da 0a 20 03 ldub [ %o0 + 3 ], %o5
20209c8: 9b 2b 60 18 sll %o5, 0x18, %o5
20209cc: 88 03 40 04 add %o5, %g4, %g4
case 3 : a+=((uint32_t)k[2])<<16;
20209d0: da 0a 20 02 ldub [ %o0 + 2 ], %o5
20209d4: 9b 2b 60 10 sll %o5, 0x10, %o5
20209d8: 88 01 00 0d add %g4, %o5, %g4
case 2 : a+=((uint32_t)k[1])<<8;
20209dc: da 0a 20 01 ldub [ %o0 + 1 ], %o5
20209e0: 9b 2b 60 08 sll %o5, 8, %o5
20209e4: 88 01 00 0d add %g4, %o5, %g4
case 1 : a+=k[0];
20209e8: c2 0a 00 00 ldub [ %o0 ], %g1
break;
case 0 : return c;
}
}
final(a,b,c);
20209ec: 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];
20209f0: 88 01 00 01 add %g4, %g1, %g4
break;
case 0 : return c;
}
}
final(a,b,c);
20209f4: 83 28 e0 0e sll %g3, 0xe, %g1
20209f8: 82 13 40 01 or %o5, %g1, %g1
20209fc: 84 18 80 03 xor %g2, %g3, %g2
2020a00: 84 20 80 01 sub %g2, %g1, %g2
2020a04: 9b 28 a0 0b sll %g2, 0xb, %o5
2020a08: 83 30 a0 15 srl %g2, 0x15, %g1
2020a0c: 82 13 40 01 or %o5, %g1, %g1
2020a10: 88 18 80 04 xor %g2, %g4, %g4
2020a14: 88 21 00 01 sub %g4, %g1, %g4
2020a18: 9b 29 20 19 sll %g4, 0x19, %o5
2020a1c: 83 31 20 07 srl %g4, 7, %g1
2020a20: 82 13 40 01 or %o5, %g1, %g1
2020a24: 86 19 00 03 xor %g4, %g3, %g3
2020a28: 86 20 c0 01 sub %g3, %g1, %g3
2020a2c: 9b 28 e0 10 sll %g3, 0x10, %o5
2020a30: 83 30 e0 10 srl %g3, 0x10, %g1
2020a34: 82 13 40 01 or %o5, %g1, %g1
2020a38: 84 18 c0 02 xor %g3, %g2, %g2
2020a3c: 84 20 80 01 sub %g2, %g1, %g2
2020a40: 9b 28 a0 04 sll %g2, 4, %o5
2020a44: 83 30 a0 1c srl %g2, 0x1c, %g1
2020a48: 82 13 40 01 or %o5, %g1, %g1
2020a4c: 88 18 80 04 xor %g2, %g4, %g4
2020a50: 88 21 00 01 sub %g4, %g1, %g4
2020a54: 83 29 20 0e sll %g4, 0xe, %g1
2020a58: 86 19 00 03 xor %g4, %g3, %g3
2020a5c: 89 31 20 12 srl %g4, 0x12, %g4
2020a60: 88 10 40 04 or %g1, %g4, %g4
2020a64: 86 20 c0 04 sub %g3, %g4, %g3
2020a68: 84 18 c0 02 xor %g3, %g2, %g2
2020a6c: 83 28 e0 18 sll %g3, 0x18, %g1
2020a70: 87 30 e0 08 srl %g3, 8, %g3
2020a74: 86 10 40 03 or %g1, %g3, %g3
2020a78: 84 20 80 03 sub %g2, %g3, %g2
return c;
}
2020a7c: 81 c3 e0 08 retl
2020a80: 90 10 00 02 mov %g2, %o0
0201bca4 <rtems_rfs_dir_lookup_ino>:
rtems_rfs_inode_handle* inode,
const char* name,
int length,
rtems_rfs_ino* ino,
uint32_t* offset)
{
201bca4: 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))
201bca8: 90 10 20 00 clr %o0
201bcac: 13 01 00 00 sethi %hi(0x4000000), %o1
201bcb0: 7f ff de c8 call 20137d0 <rtems_rfs_trace>
201bcb4: a0 10 00 18 mov %i0, %l0
201bcb8: 80 8a 20 ff btst 0xff, %o0
201bcbc: 22 80 00 13 be,a 201bd08 <rtems_rfs_dir_lookup_ino+0x64> <== ALWAYS TAKEN
201bcc0: c0 27 00 00 clr [ %i4 ]
{
int c;
printf ("rtems-rfs: dir-lookup-ino: lookup ino: root=%" PRId32 ", path=",
201bcc4: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED
201bcc8: 11 00 80 cf sethi %hi(0x2033c00), %o0 <== NOT EXECUTED
inode->ino);
for (c = 0; c < length; c++)
201bccc: 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=",
201bcd0: 40 00 19 0a call 20220f8 <printf> <== NOT EXECUTED
201bcd4: 90 12 21 20 or %o0, 0x120, %o0 <== NOT EXECUTED
inode->ino);
for (c = 0; c < length; c++)
201bcd8: 10 80 00 05 b 201bcec <rtems_rfs_dir_lookup_ino+0x48> <== NOT EXECUTED
201bcdc: 80 a6 00 1b cmp %i0, %i3 <== NOT EXECUTED
printf ("%c", name[c]);
201bce0: 40 00 19 70 call 20222a0 <putchar> <== NOT EXECUTED
201bce4: 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++)
201bce8: 80 a6 00 1b cmp %i0, %i3 <== NOT EXECUTED
201bcec: 26 bf ff fd bl,a 201bce0 <rtems_rfs_dir_lookup_ino+0x3c> <== NOT EXECUTED
201bcf0: d0 4e 80 18 ldsb [ %i2 + %i0 ], %o0 <== NOT EXECUTED
printf ("%c", name[c]);
printf (", len=%d\n", length);
201bcf4: 11 00 80 cf sethi %hi(0x2033c00), %o0 <== NOT EXECUTED
201bcf8: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
201bcfc: 40 00 18 ff call 20220f8 <printf> <== NOT EXECUTED
201bd00: 90 12 21 58 or %o0, 0x158, %o0 <== NOT EXECUTED
}
*ino = RTEMS_RFS_EMPTY_INO;
201bd04: c0 27 00 00 clr [ %i4 ] <== NOT EXECUTED
*offset = 0;
201bd08: c0 27 40 00 clr [ %i5 ]
rc = rtems_rfs_block_map_open (fs, inode, &map);
201bd0c: 90 10 00 10 mov %l0, %o0
201bd10: 92 10 00 19 mov %i1, %o1
201bd14: 7f ff fa 38 call 201a5f4 <rtems_rfs_block_map_open>
201bd18: 94 07 bf b0 add %fp, -80, %o2
if (rc > 0)
201bd1c: b0 92 20 00 orcc %o0, 0, %i0
201bd20: 04 80 00 12 ble 201bd68 <rtems_rfs_dir_lookup_ino+0xc4> <== ALWAYS TAKEN
201bd24: 90 10 20 00 clr %o0
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
201bd28: 7f ff de aa call 20137d0 <rtems_rfs_trace> <== NOT EXECUTED
201bd2c: 13 01 00 00 sethi %hi(0x4000000), %o1 <== NOT EXECUTED
201bd30: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
201bd34: 02 80 01 18 be 201c194 <rtems_rfs_dir_lookup_ino+0x4f0> <== NOT EXECUTED
201bd38: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: dir-lookup-ino: map open failed for ino %" PRIu32 ": %d: %s",
201bd3c: fa 06 60 08 ld [ %i1 + 8 ], %i5 <== NOT EXECUTED
201bd40: 40 00 1d 5d call 20232b4 <strerror> <== NOT EXECUTED
201bd44: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
201bd48: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
201bd4c: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
201bd50: 94 10 00 18 mov %i0, %o2 <== NOT EXECUTED
201bd54: 11 00 80 cf sethi %hi(0x2033c00), %o0 <== NOT EXECUTED
201bd58: 40 00 18 e8 call 20220f8 <printf> <== NOT EXECUTED
201bd5c: 90 12 21 68 or %o0, 0x168, %o0 ! 2033d68 <CSWTCH.2+0x688> <== NOT EXECUTED
201bd60: 81 c7 e0 08 ret <== NOT EXECUTED
201bd64: 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);
201bd68: 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;
201bd6c: c0 2f bf a4 clrb [ %fp + -92 ]
handle->bnum = 0;
201bd70: c0 27 bf a8 clr [ %fp + -88 ]
handle->buffer = NULL;
201bd74: c0 27 bf ac clr [ %fp + -84 ]
201bd78: 40 00 12 a5 call 202080c <rtems_rfs_dir_hash>
201bd7c: 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);
201bd80: 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);
201bd84: 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);
201bd88: 94 10 20 00 clr %o2
201bd8c: 90 10 00 10 mov %l0, %o0
201bd90: 96 10 20 00 clr %o3
201bd94: 7f ff fb 49 call 201aab8 <rtems_rfs_block_map_seek>
201bd98: 98 07 bf a0 add %fp, -96, %o4
if (rc > 0)
201bd9c: b0 92 20 00 orcc %o0, 0, %i0
201bda0: 04 80 00 d3 ble 201c0ec <rtems_rfs_dir_lookup_ino+0x448> <== ALWAYS TAKEN
201bda4: 90 10 20 00 clr %o0
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
201bda8: 7f ff de 8a call 20137d0 <rtems_rfs_trace> <== NOT EXECUTED
201bdac: 13 01 00 00 sethi %hi(0x4000000), %o1 <== NOT EXECUTED
201bdb0: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
201bdb4: 02 80 00 0a be 201bddc <rtems_rfs_dir_lookup_ino+0x138> <== NOT EXECUTED
201bdb8: 80 a6 20 06 cmp %i0, 6 <== NOT EXECUTED
printf ("rtems-rfs: dir-lookup-ino: block map find failed: %d: %s\n",
201bdbc: 40 00 1d 3e call 20232b4 <strerror> <== NOT EXECUTED
201bdc0: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
201bdc4: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
201bdc8: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
201bdcc: 11 00 80 cf sethi %hi(0x2033c00), %o0 <== NOT EXECUTED
201bdd0: 40 00 18 ca call 20220f8 <printf> <== NOT EXECUTED
201bdd4: 90 12 21 a8 or %o0, 0x1a8, %o0 ! 2033da8 <CSWTCH.2+0x6c8> <== NOT EXECUTED
rc, strerror (rc));
if (rc == ENXIO)
201bdd8: 80 a6 20 06 cmp %i0, 6 <== NOT EXECUTED
201bddc: 22 80 00 dc be,a 201c14c <rtems_rfs_dir_lookup_ino+0x4a8><== NOT EXECUTED
201bde0: 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);
201bde4: 10 80 00 db b 201c150 <rtems_rfs_dir_lookup_ino+0x4ac> <== NOT EXECUTED
201bde8: 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))
201bdec: 7f ff de 79 call 20137d0 <rtems_rfs_trace>
201bdf0: 13 01 00 00 sethi %hi(0x4000000), %o1
201bdf4: 80 8a 20 ff btst 0xff, %o0
201bdf8: 02 80 00 08 be 201be18 <rtems_rfs_dir_lookup_ino+0x174> <== ALWAYS TAKEN
201bdfc: d4 07 bf a0 ld [ %fp + -96 ], %o2
printf ("rtems-rfs: dir-lookup-ino: block read, ino=%" PRIu32 " bno=%" PRId32 "\n",
201be00: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED
201be04: d4 07 bf c0 ld [ %fp + -64 ], %o2 <== NOT EXECUTED
201be08: 11 00 80 cf sethi %hi(0x2033c00), %o0 <== NOT EXECUTED
201be0c: 40 00 18 bb call 20220f8 <printf> <== NOT EXECUTED
201be10: 90 12 21 e8 or %o0, 0x1e8, %o0 ! 2033de8 <CSWTCH.2+0x708> <== NOT EXECUTED
rtems_rfs_inode_ino (inode), map.bpos.bno);
rc = rtems_rfs_buffer_handle_request (fs, &entries, block, true);
201be14: d4 07 bf a0 ld [ %fp + -96 ], %o2 <== NOT EXECUTED
201be18: 90 10 00 10 mov %l0, %o0
201be1c: 92 07 bf a4 add %fp, -92, %o1
201be20: 7f ff fd e2 call 201b5a8 <rtems_rfs_buffer_handle_request>
201be24: 96 10 20 01 mov 1, %o3
if (rc > 0)
201be28: a2 92 20 00 orcc %o0, 0, %l1
201be2c: 04 80 00 15 ble 201be80 <rtems_rfs_dir_lookup_ino+0x1dc> <== ALWAYS TAKEN
201be30: c2 07 bf ac ld [ %fp + -84 ], %g1
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
201be34: 90 10 20 00 clr %o0 <== NOT EXECUTED
201be38: 7f ff de 66 call 20137d0 <rtems_rfs_trace> <== NOT EXECUTED
201be3c: 13 01 00 00 sethi %hi(0x4000000), %o1 <== NOT EXECUTED
201be40: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
201be44: 22 80 00 c2 be,a 201c14c <rtems_rfs_dir_lookup_ino+0x4a8><== NOT EXECUTED
201be48: b0 10 00 11 mov %l1, %i0 <== NOT EXECUTED
printf ("rtems-rfs: dir-lookup-ino: block read, ino=%" PRIu32 " block=%" PRId32 ": %d: %s\n",
201be4c: f8 06 60 08 ld [ %i1 + 8 ], %i4 <== NOT EXECUTED
201be50: fa 07 bf a0 ld [ %fp + -96 ], %i5 <== NOT EXECUTED
201be54: 40 00 1d 18 call 20232b4 <strerror> <== NOT EXECUTED
201be58: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED
201be5c: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
201be60: 98 10 00 08 mov %o0, %o4 <== NOT EXECUTED
201be64: 94 10 00 1d mov %i5, %o2 <== NOT EXECUTED
201be68: 11 00 80 cf sethi %hi(0x2033c00), %o0 <== NOT EXECUTED
201be6c: 96 10 00 11 mov %l1, %o3 <== NOT EXECUTED
201be70: 40 00 18 a2 call 20220f8 <printf> <== NOT EXECUTED
201be74: 90 12 22 20 or %o0, 0x220, %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;
201be78: 10 80 00 b5 b 201c14c <rtems_rfs_dir_lookup_ino+0x4a8> <== NOT EXECUTED
201be7c: b0 10 00 11 mov %l1, %i0 <== NOT EXECUTED
* means the entry is empty.
*/
entry = rtems_rfs_buffer_data (&entries);
map.bpos.boff = 0;
201be80: c0 27 bf c4 clr [ %fp + -60 ]
while (map.bpos.boff < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
201be84: 10 80 00 71 b 201c048 <rtems_rfs_dir_lookup_ino+0x3a4>
201be88: e4 00 60 1c ld [ %g1 + 0x1c ], %l2
{
uint32_t ehash;
int elength;
ehash = rtems_rfs_dir_entry_hash (entry);
201be8c: c8 0c a0 04 ldub [ %l2 + 4 ], %g4
201be90: 85 28 a0 10 sll %g2, 0x10, %g2
201be94: 89 29 20 18 sll %g4, 0x18, %g4
201be98: 88 11 00 02 or %g4, %g2, %g4
201be9c: c4 0c a0 07 ldub [ %l2 + 7 ], %g2
elength = rtems_rfs_dir_entry_length (entry);
201bea0: 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);
201bea4: 88 11 00 02 or %g4, %g2, %g4
201bea8: c4 0c a0 06 ldub [ %l2 + 6 ], %g2
elength = rtems_rfs_dir_entry_length (entry);
*ino = rtems_rfs_dir_entry_ino (entry);
201beac: 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);
201beb0: 85 28 a0 08 sll %g2, 8, %g2
201beb4: 88 11 00 02 or %g4, %g2, %g4
elength = rtems_rfs_dir_entry_length (entry);
201beb8: c4 0c a0 08 ldub [ %l2 + 8 ], %g2
*ino = rtems_rfs_dir_entry_ino (entry);
201bebc: 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);
201bec0: 85 28 a0 08 sll %g2, 8, %g2
201bec4: a6 10 80 03 or %g2, %g3, %l3
*ino = rtems_rfs_dir_entry_ino (entry);
201bec8: c6 0c a0 01 ldub [ %l2 + 1 ], %g3
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
201becc: 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);
201bed0: 87 28 e0 10 sll %g3, 0x10, %g3
201bed4: 86 13 c0 03 or %o7, %g3, %g3
201bed8: de 0c a0 03 ldub [ %l2 + 3 ], %o7
201bedc: 86 10 c0 0f or %g3, %o7, %g3
201bee0: de 0c a0 02 ldub [ %l2 + 2 ], %o7
201bee4: 9f 2b e0 08 sll %o7, 8, %o7
201bee8: 86 10 c0 0f or %g3, %o7, %g3
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
201beec: 12 80 00 07 bne 201bf08 <rtems_rfs_dir_lookup_ino+0x264>
201bef0: c6 27 00 00 st %g3, [ %i4 ]
map.bpos.boff += elength;
entry += elength;
}
if (rc == 0)
201bef4: 80 a4 60 00 cmp %l1, 0
201bef8: 32 80 00 85 bne,a 201c10c <rtems_rfs_dir_lookup_ino+0x468><== NEVER TAKEN
201befc: b0 10 00 11 mov %l1, %i0 <== NOT EXECUTED
{
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
201bf00: 10 80 00 5a b 201c068 <rtems_rfs_dir_lookup_ino+0x3c4>
201bf04: 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))
201bf08: 80 a4 e0 0a cmp %l3, 0xa
201bf0c: 34 80 00 0a bg,a 201bf34 <rtems_rfs_dir_lookup_ino+0x290><== ALWAYS TAKEN
201bf10: de 04 20 1c ld [ %l0 + 0x1c ], %o7
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
201bf14: 90 10 20 00 clr %o0 <== NOT EXECUTED
201bf18: 7f ff de 2e call 20137d0 <rtems_rfs_trace> <== NOT EXECUTED
201bf1c: 13 01 00 00 sethi %hi(0x4000000), %o1 <== NOT EXECUTED
201bf20: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
201bf24: 22 80 00 70 be,a 201c0e4 <rtems_rfs_dir_lookup_ino+0x440><== NOT EXECUTED
201bf28: a2 10 20 05 mov 5, %l1 <== NOT EXECUTED
printf ("rtems-rfs: dir-lookup-ino: "
201bf2c: 10 80 00 0c b 201bf5c <rtems_rfs_dir_lookup_ino+0x2b8> <== NOT EXECUTED
201bf30: 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))
201bf34: 80 a4 c0 0f cmp %l3, %o7
201bf38: 1a bf ff f7 bcc 201bf14 <rtems_rfs_dir_lookup_ino+0x270> <== NEVER TAKEN
201bf3c: 80 a0 e0 00 cmp %g3, 0
201bf40: 02 bf ff f6 be 201bf18 <rtems_rfs_dir_lookup_ino+0x274> <== NEVER TAKEN
201bf44: 90 10 20 00 clr %o0
201bf48: de 04 20 14 ld [ %l0 + 0x14 ], %o7
201bf4c: 80 a0 c0 0f cmp %g3, %o7
201bf50: 08 80 00 0a bleu 201bf78 <rtems_rfs_dir_lookup_ino+0x2d4> <== ALWAYS TAKEN
201bf54: c2 07 bf 9c ld [ %fp + -100 ], %g1
201bf58: 30 bf ff f0 b,a 201bf18 <rtems_rfs_dir_lookup_ino+0x274> <== NOT EXECUTED
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
printf ("rtems-rfs: dir-lookup-ino: "
201bf5c: d6 07 00 00 ld [ %i4 ], %o3 <== NOT EXECUTED
201bf60: d8 07 bf c4 ld [ %fp + -60 ], %o4 <== NOT EXECUTED
201bf64: 90 10 00 17 mov %l7, %o0 <== NOT EXECUTED
201bf68: 40 00 18 64 call 20220f8 <printf> <== NOT EXECUTED
201bf6c: 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;
201bf70: 10 80 00 5d b 201c0e4 <rtems_rfs_dir_lookup_ino+0x440> <== NOT EXECUTED
201bf74: 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)
201bf78: 80 a1 00 01 cmp %g4, %g1
201bf7c: 12 80 00 30 bne 201c03c <rtems_rfs_dir_lookup_ino+0x398>
201bf80: c6 07 bf c4 ld [ %fp + -60 ], %g3
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO_CHECK))
201bf84: 90 10 20 00 clr %o0
201bf88: 7f ff de 12 call 20137d0 <rtems_rfs_trace>
201bf8c: 13 02 00 00 sethi %hi(0x8000000), %o1
201bf90: 80 8a 20 ff btst 0xff, %o0
201bf94: 02 80 00 12 be 201bfdc <rtems_rfs_dir_lookup_ino+0x338> <== ALWAYS TAKEN
201bf98: 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));
201bf9c: c6 0c a0 01 ldub [ %l2 + 1 ], %g3 <== NOT EXECUTED
201bfa0: da 0c 80 00 ldub [ %l2 ], %o5 <== NOT EXECUTED
201bfa4: 87 28 e0 10 sll %g3, 0x10, %g3 <== NOT EXECUTED
201bfa8: 9b 2b 60 18 sll %o5, 0x18, %o5 <== NOT EXECUTED
201bfac: 9a 13 40 03 or %o5, %g3, %o5 <== NOT EXECUTED
201bfb0: 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: "
201bfb4: 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));
201bfb8: 9a 13 40 03 or %o5, %g3, %o5 <== NOT EXECUTED
201bfbc: 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: "
201bfc0: 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));
201bfc4: 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: "
201bfc8: 90 10 00 15 mov %l5, %o0 <== NOT EXECUTED
201bfcc: 98 10 00 13 mov %l3, %o4 <== NOT EXECUTED
201bfd0: 40 00 18 4a call 20220f8 <printf> <== NOT EXECUTED
201bfd4: 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)
201bfd8: 90 04 a0 0a add %l2, 0xa, %o0 <== NOT EXECUTED
201bfdc: 92 10 00 1a mov %i2, %o1
201bfe0: 40 00 17 0f call 2021c1c <memcmp>
201bfe4: 94 10 00 1b mov %i3, %o2
201bfe8: 80 a2 20 00 cmp %o0, 0
201bfec: 12 80 00 14 bne 201c03c <rtems_rfs_dir_lookup_ino+0x398> <== NEVER TAKEN
201bff0: c6 07 bf c4 ld [ %fp + -60 ], %g3
{
*offset = rtems_rfs_block_map_pos (fs, &map);
201bff4: 90 10 00 10 mov %l0, %o0
201bff8: 7f ff f9 4a call 201a520 <rtems_rfs_block_get_pos>
201bffc: 92 07 bf c0 add %fp, -64, %o1
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO_FOUND))
201c000: 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);
201c004: d2 27 40 00 st %o1, [ %i5 ]
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO_FOUND))
201c008: 7f ff dd f2 call 20137d0 <rtems_rfs_trace>
201c00c: 13 04 00 00 sethi %hi(0x10000000), %o1
201c010: 80 8a 20 ff btst 0xff, %o0
201c014: 22 80 00 4f be,a 201c150 <rtems_rfs_dir_lookup_ino+0x4ac><== ALWAYS TAKEN
201c018: 92 07 bf a4 add %fp, -92, %o1
printf ("rtems-rfs: dir-lookup-ino: "
201c01c: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED
201c020: d4 07 00 00 ld [ %i4 ], %o2 <== NOT EXECUTED
201c024: d6 07 40 00 ld [ %i5 ], %o3 <== NOT EXECUTED
201c028: 11 00 80 cf sethi %hi(0x2033c00), %o0 <== NOT EXECUTED
201c02c: 40 00 18 33 call 20220f8 <printf> <== NOT EXECUTED
201c030: 90 12 23 18 or %o0, 0x318, %o0 ! 2033f18 <CSWTCH.2+0x838> <== 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);
201c034: 10 80 00 47 b 201c150 <rtems_rfs_dir_lookup_ino+0x4ac> <== NOT EXECUTED
201c038: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED
return 0;
}
}
map.bpos.boff += elength;
entry += elength;
201c03c: a4 04 80 13 add %l2, %l3, %l2
rtems_rfs_block_map_close (fs, &map);
return 0;
}
}
map.bpos.boff += elength;
201c040: 86 00 c0 13 add %g3, %l3, %g3
201c044: 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))
201c048: c4 04 20 08 ld [ %l0 + 8 ], %g2
201c04c: c6 07 bf c4 ld [ %fp + -60 ], %g3
201c050: 84 00 bf f6 add %g2, -10, %g2
201c054: 80 a0 c0 02 cmp %g3, %g2
201c058: 2a bf ff 8d bcs,a 201be8c <rtems_rfs_dir_lookup_ino+0x1e8><== ALWAYS TAKEN
201c05c: c4 0c a0 05 ldub [ %l2 + 5 ], %g2
map.bpos.boff += elength;
entry += elength;
}
if (rc == 0)
201c060: 10 bf ff a6 b 201bef8 <rtems_rfs_dir_lookup_ino+0x254> <== NOT EXECUTED
201c064: 80 a4 60 00 cmp %l1, 0 <== NOT EXECUTED
{
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
201c068: 92 07 bf b0 add %fp, -80, %o1
201c06c: 7f ff fa b0 call 201ab2c <rtems_rfs_block_map_next_block>
201c070: 94 07 bf a0 add %fp, -96, %o2
if ((rc > 0) && (rc != ENXIO))
201c074: 80 a2 20 06 cmp %o0, 6
201c078: 02 80 00 05 be 201c08c <rtems_rfs_dir_lookup_ino+0x3e8> <== ALWAYS TAKEN
201c07c: b0 10 00 08 mov %o0, %i0
201c080: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
201c084: 14 80 00 07 bg 201c0a0 <rtems_rfs_dir_lookup_ino+0x3fc> <== NOT EXECUTED
201c088: 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)
201c08c: 80 a6 20 06 cmp %i0, 6
201c090: 12 80 00 20 bne 201c110 <rtems_rfs_dir_lookup_ino+0x46c> <== NEVER TAKEN
201c094: 80 a6 20 00 cmp %i0, 0
rc = ENOENT;
201c098: 10 80 00 11 b 201c0dc <rtems_rfs_dir_lookup_ino+0x438>
201c09c: 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))
201c0a0: 7f ff dd cc call 20137d0 <rtems_rfs_trace> <== NOT EXECUTED
201c0a4: 13 01 00 00 sethi %hi(0x4000000), %o1 <== NOT EXECUTED
201c0a8: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
201c0ac: 22 bf ff f9 be,a 201c090 <rtems_rfs_dir_lookup_ino+0x3ec><== NOT EXECUTED
201c0b0: 80 a6 20 06 cmp %i0, 6 <== NOT EXECUTED
printf ("rtems-rfs: dir-lookup-ino: "
201c0b4: e2 06 60 08 ld [ %i1 + 8 ], %l1 <== NOT EXECUTED
201c0b8: 40 00 1c 7f call 20232b4 <strerror> <== NOT EXECUTED
201c0bc: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
201c0c0: 92 10 00 11 mov %l1, %o1 <== NOT EXECUTED
201c0c4: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
201c0c8: 94 10 00 18 mov %i0, %o2 <== NOT EXECUTED
201c0cc: 40 00 18 0b call 20220f8 <printf> <== NOT EXECUTED
201c0d0: 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)
201c0d4: 10 80 00 0f b 201c110 <rtems_rfs_dir_lookup_ino+0x46c> <== NOT EXECUTED
201c0d8: 80 a6 20 00 cmp %i0, 0 <== NOT EXECUTED
201c0dc: 10 80 00 25 b 201c170 <rtems_rfs_dir_lookup_ino+0x4cc>
201c0e0: 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;
201c0e4: 10 80 00 0a b 201c10c <rtems_rfs_dir_lookup_ino+0x468> <== NOT EXECUTED
201c0e8: 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)
201c0ec: 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: "
201c0f0: 2b 00 80 cf sethi %hi(0x2033c00), %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: "
201c0f4: 2d 00 80 cf sethi %hi(0x2033c00), %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: "
201c0f8: 2f 00 80 cf sethi %hi(0x2033c00), %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)
201c0fc: 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: "
201c100: aa 15 62 b8 or %l5, 0x2b8, %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: "
201c104: ac 15 a3 60 or %l6, 0x360, %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: "
201c108: ae 15 e2 68 or %l7, 0x268, %l7
rtems_rfs_buffer_handle_close (fs, &entries);
rtems_rfs_block_map_close (fs, &map);
return rc;
}
while ((rc == 0) && block)
201c10c: 80 a6 20 00 cmp %i0, 0
201c110: 12 80 00 17 bne 201c16c <rtems_rfs_dir_lookup_ino+0x4c8> <== NEVER TAKEN
201c114: c2 07 bf a0 ld [ %fp + -96 ], %g1
201c118: 80 a0 60 00 cmp %g1, 0
201c11c: 12 bf ff 34 bne 201bdec <rtems_rfs_dir_lookup_ino+0x148> <== ALWAYS TAKEN
201c120: 90 10 20 00 clr %o0
201c124: 30 80 00 15 b,a 201c178 <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",
201c128: 40 00 1c 63 call 20232b4 <strerror> <== NOT EXECUTED
201c12c: 90 10 20 05 mov 5, %o0 <== NOT EXECUTED
201c130: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
201c134: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
201c138: 94 10 20 05 mov 5, %o2 <== NOT EXECUTED
201c13c: 11 00 80 cf sethi %hi(0x2033c00), %o0 <== NOT EXECUTED
201c140: 40 00 17 ee call 20220f8 <printf> <== NOT EXECUTED
201c144: 90 12 23 b0 or %o0, 0x3b0, %o0 ! 2033fb0 <CSWTCH.2+0x8d0> <== NOT EXECUTED
}
}
if ((rc == 0) && (block == 0))
{
rc = EIO;
201c148: 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);
201c14c: 92 07 bf a4 add %fp, -92, %o1
201c150: 7f ff fe cb call 201bc7c <rtems_rfs_buffer_handle_close>
201c154: 90 10 00 10 mov %l0, %o0
rtems_rfs_block_map_close (fs, &map);
201c158: 90 10 00 10 mov %l0, %o0
201c15c: 7f ff f9 87 call 201a778 <rtems_rfs_block_map_close>
201c160: 92 07 bf b0 add %fp, -80, %o1
201c164: 81 c7 e0 08 ret
201c168: 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)
201c16c: 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;
201c170: 10 bf ff f7 b 201c14c <rtems_rfs_dir_lookup_ino+0x4a8>
201c174: b0 10 00 11 mov %l1, %i0
}
if ((rc == 0) && (block == 0))
{
rc = EIO;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
201c178: 7f ff dd 96 call 20137d0 <rtems_rfs_trace> <== NOT EXECUTED
201c17c: 13 01 00 00 sethi %hi(0x4000000), %o1 <== NOT EXECUTED
201c180: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
201c184: 32 bf ff e9 bne,a 201c128 <rtems_rfs_dir_lookup_ino+0x484><== NOT EXECUTED
201c188: fa 06 60 08 ld [ %i1 + 8 ], %i5 <== NOT EXECUTED
}
}
if ((rc == 0) && (block == 0))
{
rc = EIO;
201c18c: 10 bf ff f0 b 201c14c <rtems_rfs_dir_lookup_ino+0x4a8> <== NOT EXECUTED
201c190: 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;
}
201c194: 81 c7 e0 08 ret <== NOT EXECUTED
201c198: 81 e8 00 00 restore <== NOT EXECUTED
0201c920 <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)
{
201c920: 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))
201c924: 90 10 20 00 clr %o0
201c928: 7f ff db aa call 20137d0 <rtems_rfs_trace>
201c92c: 13 20 00 00 sethi %hi(0x80000000), %o1
201c930: 80 8a 20 ff btst 0xff, %o0
201c934: 22 80 00 09 be,a 201c958 <rtems_rfs_dir_read+0x38> <== ALWAYS TAKEN
201c938: c0 27 40 00 clr [ %i5 ]
printf ("rtems-rfs: dir-read: dir=%" PRId32 " offset=%" PRId64 "\n",
201c93c: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED
201c940: 11 00 80 d0 sethi %hi(0x2034000), %o0 <== NOT EXECUTED
201c944: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED
201c948: 90 12 22 d0 or %o0, 0x2d0, %o0 <== NOT EXECUTED
201c94c: 40 00 15 eb call 20220f8 <printf> <== NOT EXECUTED
201c950: 96 10 00 1b mov %i3, %o3 <== NOT EXECUTED
rtems_rfs_inode_ino (dir), offset);
*length = 0;
201c954: c0 27 40 00 clr [ %i5 ] <== NOT EXECUTED
rc = rtems_rfs_block_map_open (fs, dir, &map);
201c958: 90 10 00 18 mov %i0, %o0
201c95c: 92 10 00 19 mov %i1, %o1
201c960: 7f ff f7 25 call 201a5f4 <rtems_rfs_block_map_open>
201c964: 94 07 bf b0 add %fp, -80, %o2
if (rc > 0)
201c968: a0 92 20 00 orcc %o0, 0, %l0
201c96c: 14 80 00 cf bg 201cca8 <rtems_rfs_dir_read+0x388> <== NEVER TAKEN
201c970: 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))
201c974: e0 06 20 08 ld [ %i0 + 8 ], %l0
201c978: a2 10 00 10 mov %l0, %l1
201c97c: 92 10 00 1b mov %i3, %o1
201c980: a0 10 20 00 clr %l0
201c984: 96 10 00 11 mov %l1, %o3
201c988: 40 00 48 55 call 202eadc <__moddi3>
201c98c: 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) -
201c990: 92 a4 40 09 subcc %l1, %o1, %o1
201c994: 90 64 00 08 subx %l0, %o0, %o0
201c998: 80 a2 20 00 cmp %o0, 0
201c99c: 34 80 00 15 bg,a 201c9f0 <rtems_rfs_dir_read+0xd0> <== NEVER TAKEN
201c9a0: a2 07 bf b0 add %fp, -80, %l1 <== NOT EXECUTED
201c9a4: 80 a2 20 00 cmp %o0, 0
201c9a8: 32 80 00 06 bne,a 201c9c0 <rtems_rfs_dir_read+0xa0> <== NEVER TAKEN
201c9ac: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
201c9b0: 80 a2 60 0a cmp %o1, 0xa
201c9b4: 38 80 00 0f bgu,a 201c9f0 <rtems_rfs_dir_read+0xd0> <== ALWAYS TAKEN
201c9b8: 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) *
201c9bc: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
201c9c0: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
201c9c4: 94 10 00 10 mov %l0, %o2 <== NOT EXECUTED
201c9c8: 40 00 47 5a call 202e730 <__divdi3> <== NOT EXECUTED
201c9cc: 96 10 00 11 mov %l1, %o3 <== NOT EXECUTED
201c9d0: 94 10 00 10 mov %l0, %o2 <== NOT EXECUTED
201c9d4: 92 82 60 01 inccc %o1 <== NOT EXECUTED
201c9d8: 96 10 00 11 mov %l1, %o3 <== NOT EXECUTED
201c9dc: 40 00 47 11 call 202e620 <__muldi3> <== NOT EXECUTED
201c9e0: 90 42 20 00 addx %o0, 0, %o0 <== NOT EXECUTED
201c9e4: b4 10 00 08 mov %o0, %i2 <== NOT EXECUTED
201c9e8: 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);
201c9ec: a2 07 bf b0 add %fp, -80, %l1 <== NOT EXECUTED
201c9f0: a4 07 bf a0 add %fp, -96, %l2
201c9f4: 90 10 00 18 mov %i0, %o0
201c9f8: 92 10 00 11 mov %l1, %o1
201c9fc: 94 10 00 1a mov %i2, %o2
201ca00: 96 10 00 1b mov %i3, %o3
201ca04: 7f ff f8 2d call 201aab8 <rtems_rfs_block_map_seek>
201ca08: 98 10 00 12 mov %l2, %o4
if (rc > 0)
201ca0c: a0 92 20 00 orcc %o0, 0, %l0
201ca10: 04 80 00 07 ble 201ca2c <rtems_rfs_dir_read+0x10c> <== ALWAYS TAKEN
201ca14: 80 a4 20 06 cmp %l0, 6
{
if (rc == ENXIO)
201ca18: 22 80 00 02 be,a 201ca20 <rtems_rfs_dir_read+0x100> <== NOT EXECUTED
201ca1c: a0 10 20 02 mov 2, %l0 <== NOT EXECUTED
rc = ENOENT;
rtems_rfs_block_map_close (fs, &map);
201ca20: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
201ca24: 10 80 00 9f b 201cca0 <rtems_rfs_dir_read+0x380> <== NOT EXECUTED
201ca28: 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)
201ca2c: 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",
201ca30: 2d 00 80 d0 sethi %hi(0x2034000), %l6
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
201ca34: c0 2f bf a4 clrb [ %fp + -92 ]
handle->bnum = 0;
201ca38: c0 27 bf a8 clr [ %fp + -88 ]
handle->buffer = NULL;
201ca3c: 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)
201ca40: 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",
201ca44: ac 15 a3 80 or %l6, 0x380, %l6
offset, *length);
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
201ca48: ae 10 00 11 mov %l1, %l7
201ca4c: 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);
201ca50: d4 07 bf a0 ld [ %fp + -96 ], %o2
201ca54: 90 10 00 18 mov %i0, %o0
201ca58: 92 07 bf a4 add %fp, -92, %o1
201ca5c: 7f ff fa d3 call 201b5a8 <rtems_rfs_buffer_handle_request>
201ca60: 96 10 20 01 mov 1, %o3
if (rc > 0)
201ca64: a0 92 20 00 orcc %o0, 0, %l0
201ca68: 04 80 00 04 ble 201ca78 <rtems_rfs_dir_read+0x158> <== ALWAYS TAKEN
201ca6c: 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);
201ca70: 10 80 00 88 b 201cc90 <rtems_rfs_dir_read+0x370> <== NOT EXECUTED
201ca74: 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;
201ca78: 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);
201ca7c: c2 00 60 1c ld [ %g1 + 0x1c ], %g1
entry += map.bpos.boff;
201ca80: a2 00 40 13 add %g1, %l3, %l1
elength = rtems_rfs_dir_entry_length (entry);
201ca84: c4 0c 60 09 ldub [ %l1 + 9 ], %g2
201ca88: e4 0c 60 08 ldub [ %l1 + 8 ], %l2
eino = rtems_rfs_dir_entry_ino (entry);
201ca8c: 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);
201ca90: a5 2c a0 08 sll %l2, 8, %l2
eino = rtems_rfs_dir_entry_ino (entry);
201ca94: 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);
201ca98: a4 14 80 02 or %l2, %g2, %l2
eino = rtems_rfs_dir_entry_ino (entry);
201ca9c: c2 0c 60 02 ldub [ %l1 + 2 ], %g1
if (elength != RTEMS_RFS_DIR_ENTRY_EMPTY)
201caa0: 80 a4 80 15 cmp %l2, %l5
201caa4: 02 80 00 5d be 201cc18 <rtems_rfs_dir_read+0x2f8>
201caa8: 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);
201caac: a9 29 20 18 sll %g4, 0x18, %l4
201cab0: 86 08 e0 ff and %g3, 0xff, %g3
201cab4: 84 08 a0 ff and %g2, 0xff, %g2
201cab8: 87 28 e0 10 sll %g3, 0x10, %g3
201cabc: 82 08 60 ff and %g1, 0xff, %g1
201cac0: a8 15 00 03 or %l4, %g3, %l4
201cac4: 83 28 60 08 sll %g1, 8, %g1
201cac8: a8 15 00 02 or %l4, %g2, %l4
if (elength != RTEMS_RFS_DIR_ENTRY_EMPTY)
{
if (rtems_rfs_dir_entry_valid (fs, elength, eino))
201cacc: 80 a4 a0 0a cmp %l2, 0xa
201cad0: 04 80 00 0d ble 201cb04 <rtems_rfs_dir_read+0x1e4> <== NEVER TAKEN
201cad4: a8 15 00 01 or %l4, %g1, %l4
201cad8: c2 06 20 1c ld [ %i0 + 0x1c ], %g1
201cadc: 80 a4 80 01 cmp %l2, %g1
201cae0: 1a 80 00 0a bcc 201cb08 <rtems_rfs_dir_read+0x1e8> <== NEVER TAKEN
201cae4: 90 10 20 00 clr %o0
201cae8: 80 a5 20 00 cmp %l4, 0
201caec: 02 80 00 08 be 201cb0c <rtems_rfs_dir_read+0x1ec> <== NEVER TAKEN
201caf0: 13 20 00 00 sethi %hi(0x80000000), %o1
201caf4: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
201caf8: 80 a5 00 01 cmp %l4, %g1
201cafc: 08 80 00 12 bleu 201cb44 <rtems_rfs_dir_read+0x224> <== ALWAYS TAKEN
201cb00: 90 10 00 1c mov %i4, %o0
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
201cb04: 90 10 20 00 clr %o0 <== NOT EXECUTED
201cb08: 13 20 00 00 sethi %hi(0x80000000), %o1 <== NOT EXECUTED
201cb0c: 7f ff db 31 call 20137d0 <rtems_rfs_trace> <== NOT EXECUTED
201cb10: a0 10 20 05 mov 5, %l0 <== NOT EXECUTED
201cb14: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
201cb18: 22 80 00 5e be,a 201cc90 <rtems_rfs_dir_read+0x370> <== NOT EXECUTED
201cb1c: 92 07 bf a4 add %fp, -92, %o1 <== NOT EXECUTED
printf ("rtems-rfs: dir-read: "
201cb20: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED
201cb24: d8 07 bf c4 ld [ %fp + -60 ], %o4 <== NOT EXECUTED
201cb28: 11 00 80 d0 sethi %hi(0x2034000), %o0 <== NOT EXECUTED
201cb2c: 94 10 00 12 mov %l2, %o2 <== NOT EXECUTED
201cb30: 96 10 00 14 mov %l4, %o3 <== NOT EXECUTED
201cb34: 40 00 15 71 call 20220f8 <printf> <== NOT EXECUTED
201cb38: 90 12 23 00 or %o0, 0x300, %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);
201cb3c: 10 80 00 55 b 201cc90 <rtems_rfs_dir_read+0x370> <== NOT EXECUTED
201cb40: 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));
201cb44: 92 10 20 00 clr %o1
201cb48: 40 00 14 ee call 2021f00 <memset>
201cb4c: 94 10 21 18 mov 0x118, %o2
dirent->d_off = offset;
dirent->d_reclen = sizeof (struct dirent);
201cb50: 82 10 21 18 mov 0x118, %g1
rc = EIO;
break;
}
memset (dirent, 0, sizeof (struct dirent));
dirent->d_off = offset;
201cb54: f4 3f 20 08 std %i2, [ %i4 + 8 ]
dirent->d_reclen = sizeof (struct dirent);
201cb58: c2 37 20 10 sth %g1, [ %i4 + 0x10 ]
*length += elength;
201cb5c: c2 07 40 00 ld [ %i5 ], %g1
201cb60: 82 04 80 01 add %l2, %g1, %g1
201cb64: c2 27 40 00 st %g1, [ %i5 ]
remaining = rtems_rfs_fs_block_size (fs) - (map.bpos.boff + elength);
201cb68: c4 06 20 08 ld [ %i0 + 8 ], %g2
201cb6c: a6 20 80 13 sub %g2, %l3, %l3
201cb70: a6 24 c0 12 sub %l3, %l2, %l3
if (remaining <= RTEMS_RFS_DIR_ENTRY_SIZE)
201cb74: 80 a4 e0 0a cmp %l3, 0xa
201cb78: 14 80 00 04 bg 201cb88 <rtems_rfs_dir_read+0x268> <== ALWAYS TAKEN
201cb7c: a4 04 bf f6 add %l2, -10, %l2
*length += remaining;
201cb80: 82 04 c0 01 add %l3, %g1, %g1 <== NOT EXECUTED
201cb84: c2 27 40 00 st %g1, [ %i5 ] <== NOT EXECUTED
201cb88: 80 a4 a0 ff cmp %l2, 0xff
201cb8c: 34 80 00 02 bg,a 201cb94 <rtems_rfs_dir_read+0x274> <== NEVER TAKEN
201cb90: 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);
201cb94: 92 04 60 0a add %l1, 0xa, %o1
201cb98: 94 10 00 12 mov %l2, %o2
201cb9c: ba 07 20 14 add %i4, 0x14, %i5
201cba0: 40 00 14 49 call 2021cc4 <memcpy>
201cba4: 90 10 00 1d mov %i5, %o0
dirent->d_ino = rtems_rfs_dir_entry_ino (entry);
201cba8: c4 0c 40 00 ldub [ %l1 ], %g2
201cbac: c2 0c 60 01 ldub [ %l1 + 1 ], %g1
201cbb0: 85 28 a0 18 sll %g2, 0x18, %g2
201cbb4: 83 28 60 10 sll %g1, 0x10, %g1
201cbb8: 82 10 80 01 or %g2, %g1, %g1
201cbbc: c4 0c 60 03 ldub [ %l1 + 3 ], %g2
dirent->d_namlen = elength;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
201cbc0: 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);
201cbc4: 82 10 40 02 or %g1, %g2, %g1
201cbc8: c4 0c 60 02 ldub [ %l1 + 2 ], %g2
dirent->d_namlen = elength;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
201cbcc: 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);
201cbd0: 85 28 a0 08 sll %g2, 8, %g2
201cbd4: 82 10 40 02 or %g1, %g2, %g1
dirent->d_namlen = elength;
201cbd8: e4 37 20 12 sth %l2, [ %i4 + 0x12 ]
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
201cbdc: 7f ff da fd call 20137d0 <rtems_rfs_trace>
201cbe0: c2 27 00 00 st %g1, [ %i4 ]
201cbe4: 80 8a 20 ff btst 0xff, %o0
201cbe8: 22 80 00 2a be,a 201cc90 <rtems_rfs_dir_read+0x370> <== ALWAYS TAKEN
201cbec: 92 07 bf a4 add %fp, -92, %o1
printf ("rtems-rfs: dir-read: found off:%" PRIooff_t " ino:%ld name=%s\n",
201cbf0: c4 1f 20 08 ldd [ %i4 + 8 ], %g2 <== NOT EXECUTED
201cbf4: d6 07 00 00 ld [ %i4 ], %o3 <== NOT EXECUTED
201cbf8: 11 00 80 d0 sethi %hi(0x2034000), %o0 <== NOT EXECUTED
201cbfc: 92 10 00 02 mov %g2, %o1 <== NOT EXECUTED
201cc00: 94 10 00 03 mov %g3, %o2 <== NOT EXECUTED
201cc04: 98 10 00 1d mov %i5, %o4 <== NOT EXECUTED
201cc08: 40 00 15 3c call 20220f8 <printf> <== NOT EXECUTED
201cc0c: 90 12 23 48 or %o0, 0x348, %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);
201cc10: 10 80 00 20 b 201cc90 <rtems_rfs_dir_read+0x370> <== NOT EXECUTED
201cc14: 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;
201cc18: c2 06 20 08 ld [ %i0 + 8 ], %g1
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
201cc1c: 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;
201cc20: a6 20 40 13 sub %g1, %l3, %l3
201cc24: c2 07 40 00 ld [ %i5 ], %g1
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
201cc28: 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;
201cc2c: a6 00 40 13 add %g1, %l3, %l3
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
201cc30: 7f ff da e8 call 20137d0 <rtems_rfs_trace>
201cc34: e6 27 40 00 st %l3, [ %i5 ]
201cc38: 80 8a 20 ff btst 0xff, %o0
201cc3c: 02 80 00 08 be 201cc5c <rtems_rfs_dir_read+0x33c> <== ALWAYS TAKEN
201cc40: 90 10 00 18 mov %i0, %o0
printf ("rtems-rfs: dir-read: next block: off:%" PRId64 " length:%zd\n",
201cc44: d6 07 40 00 ld [ %i5 ], %o3 <== NOT EXECUTED
201cc48: 90 10 00 16 mov %l6, %o0 <== NOT EXECUTED
201cc4c: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED
201cc50: 40 00 15 2a call 20220f8 <printf> <== NOT EXECUTED
201cc54: 94 10 00 1b mov %i3, %o2 <== NOT EXECUTED
offset, *length);
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
201cc58: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
201cc5c: 92 10 00 17 mov %l7, %o1
201cc60: 7f ff f7 b3 call 201ab2c <rtems_rfs_block_map_next_block>
201cc64: 94 10 00 14 mov %l4, %o2
if (rc == ENXIO)
201cc68: 80 a2 20 06 cmp %o0, 6
201cc6c: 02 80 00 07 be 201cc88 <rtems_rfs_dir_read+0x368> <== ALWAYS TAKEN
201cc70: 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)
201cc74: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
201cc78: 02 bf ff 77 be 201ca54 <rtems_rfs_dir_read+0x134> <== NOT EXECUTED
201cc7c: 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);
201cc80: 10 80 00 04 b 201cc90 <rtems_rfs_dir_read+0x370> <== NOT EXECUTED
201cc84: 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;
201cc88: a0 10 20 02 mov 2, %l0
}
rtems_rfs_buffer_handle_close (fs, &buffer);
201cc8c: 92 07 bf a4 add %fp, -92, %o1
201cc90: 7f ff fb fb call 201bc7c <rtems_rfs_buffer_handle_close>
201cc94: 90 10 00 18 mov %i0, %o0
rtems_rfs_block_map_close (fs, &map);
201cc98: 90 10 00 18 mov %i0, %o0
201cc9c: 92 07 bf b0 add %fp, -80, %o1
201cca0: 7f ff f6 b6 call 201a778 <rtems_rfs_block_map_close>
201cca4: 01 00 00 00 nop
return rc;
}
201cca8: 81 c7 e0 08 ret
201ccac: 91 e8 00 10 restore %g0, %l0, %o0
0201cf04 <rtems_rfs_file_close>:
}
int
rtems_rfs_file_close (rtems_rfs_file_system* fs,
rtems_rfs_file_handle* handle)
{
201cf04: 9d e3 bf a0 save %sp, -96, %sp
int rrc;
int rc;
rrc = 0;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_CLOSE))
201cf08: 90 10 20 10 mov 0x10, %o0
201cf0c: 7f ff da 31 call 20137d0 <rtems_rfs_trace>
201cf10: 92 10 20 00 clr %o1
201cf14: 80 8a 20 ff btst 0xff, %o0
201cf18: 22 80 00 08 be,a 201cf38 <rtems_rfs_file_close+0x34> <== ALWAYS TAKEN
201cf1c: d2 06 60 1c ld [ %i1 + 0x1c ], %o1
printf ("rtems-rfs: file-close: entry: ino=%" PRId32 "\n",
handle->shared->inode.ino);
201cf20: 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",
201cf24: 11 00 80 d1 sethi %hi(0x2034400), %o0 <== NOT EXECUTED
201cf28: d2 00 60 14 ld [ %g1 + 0x14 ], %o1 <== NOT EXECUTED
201cf2c: 40 00 14 73 call 20220f8 <printf> <== NOT EXECUTED
201cf30: 90 12 20 20 or %o0, 0x20, %o0 <== NOT EXECUTED
handle->shared->inode.ino);
if (handle->shared->references > 0)
201cf34: d2 06 60 1c ld [ %i1 + 0x1c ], %o1 <== NOT EXECUTED
201cf38: c2 02 60 08 ld [ %o1 + 8 ], %g1
201cf3c: 80 a0 60 00 cmp %g1, 0
201cf40: 04 80 00 03 ble 201cf4c <rtems_rfs_file_close+0x48> <== NEVER TAKEN
201cf44: 82 00 7f ff add %g1, -1, %g1
handle->shared->references--;
201cf48: c2 22 60 08 st %g1, [ %o1 + 8 ]
if (handle->shared->references == 0)
201cf4c: c2 02 60 08 ld [ %o1 + 8 ], %g1
201cf50: 80 a0 60 00 cmp %g1, 0
201cf54: 12 80 00 7e bne 201d14c <rtems_rfs_file_close+0x248> <== NEVER TAKEN
201cf58: ba 10 20 00 clr %i5
{
if (!rtems_rfs_inode_is_loaded (&handle->shared->inode))
201cf5c: c2 02 60 18 ld [ %o1 + 0x18 ], %g1
201cf60: 80 a0 60 00 cmp %g1, 0
201cf64: 32 80 00 09 bne,a 201cf88 <rtems_rfs_file_close+0x84> <== NEVER TAKEN
201cf68: c2 06 60 1c ld [ %i1 + 0x1c ], %g1 <== NOT EXECUTED
rrc = rtems_rfs_inode_load (fs, &handle->shared->inode);
201cf6c: 90 10 00 18 mov %i0, %o0
201cf70: 7f ff d3 5a call 2011cd8 <rtems_rfs_inode_load>
201cf74: 92 02 60 0c add %o1, 0xc, %o1
if (rrc == 0)
201cf78: ba 92 20 00 orcc %o0, 0, %i5
201cf7c: 32 80 00 3f bne,a 201d078 <rtems_rfs_file_close+0x174> <== NEVER TAKEN
201cf80: 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,
201cf84: c2 06 60 1c ld [ %i1 + 0x1c ], %g1
201cf88: 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);
201cf8c: c6 00 60 18 ld [ %g1 + 0x18 ], %g3
201cf90: 89 30 a0 18 srl %g2, 0x18, %g4
201cf94: c8 28 e0 10 stb %g4, [ %g3 + 0x10 ]
201cf98: c6 00 60 18 ld [ %g1 + 0x18 ], %g3
201cf9c: 89 30 a0 10 srl %g2, 0x10, %g4
201cfa0: c8 28 e0 11 stb %g4, [ %g3 + 0x11 ]
201cfa4: c6 00 60 18 ld [ %g1 + 0x18 ], %g3
201cfa8: 89 30 a0 08 srl %g2, 8, %g4
201cfac: c8 28 e0 12 stb %g4, [ %g3 + 0x12 ]
201cfb0: c6 00 60 18 ld [ %g1 + 0x18 ], %g3
201cfb4: c4 28 e0 13 stb %g2, [ %g3 + 0x13 ]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
201cfb8: 86 10 20 01 mov 1, %g3
201cfbc: c6 28 60 1c stb %g3, [ %g1 + 0x1c ]
handle->shared->atime);
rtems_rfs_inode_set_mtime (&handle->shared->inode,
201cfc0: c2 06 60 1c ld [ %i1 + 0x1c ], %g1
201cfc4: 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);
201cfc8: c8 00 60 18 ld [ %g1 + 0x18 ], %g4
201cfcc: bb 30 a0 18 srl %g2, 0x18, %i5
201cfd0: fa 29 20 14 stb %i5, [ %g4 + 0x14 ]
201cfd4: c8 00 60 18 ld [ %g1 + 0x18 ], %g4
201cfd8: bb 30 a0 10 srl %g2, 0x10, %i5
201cfdc: fa 29 20 15 stb %i5, [ %g4 + 0x15 ]
201cfe0: c8 00 60 18 ld [ %g1 + 0x18 ], %g4
201cfe4: bb 30 a0 08 srl %g2, 8, %i5
201cfe8: fa 29 20 16 stb %i5, [ %g4 + 0x16 ]
201cfec: c8 00 60 18 ld [ %g1 + 0x18 ], %g4
201cff0: c4 29 20 17 stb %g2, [ %g4 + 0x17 ]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
201cff4: c6 28 60 1c stb %g3, [ %g1 + 0x1c ]
handle->shared->mtime);
rtems_rfs_inode_set_ctime (&handle->shared->inode,
201cff8: c2 06 60 1c ld [ %i1 + 0x1c ], %g1
201cffc: 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);
201d000: c8 00 60 18 ld [ %g1 + 0x18 ], %g4
201d004: bb 30 a0 18 srl %g2, 0x18, %i5
201d008: fa 29 20 18 stb %i5, [ %g4 + 0x18 ]
201d00c: c8 00 60 18 ld [ %g1 + 0x18 ], %g4
201d010: bb 30 a0 10 srl %g2, 0x10, %i5
201d014: fa 29 20 19 stb %i5, [ %g4 + 0x19 ]
201d018: c8 00 60 18 ld [ %g1 + 0x18 ], %g4
201d01c: bb 30 a0 08 srl %g2, 8, %i5
201d020: fa 29 20 1a stb %i5, [ %g4 + 0x1a ]
201d024: c8 00 60 18 ld [ %g1 + 0x18 ], %g4
201d028: c4 29 20 1b stb %g2, [ %g4 + 0x1b ]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
201d02c: c6 28 60 1c stb %g3, [ %g1 + 0x1c ]
handle->shared->ctime);
if (!rtems_rfs_block_size_equal (&handle->shared->size,
201d030: c2 06 60 1c ld [ %i1 + 0x1c ], %g1
201d034: c4 00 60 84 ld [ %g1 + 0x84 ], %g2
201d038: c6 00 60 3c ld [ %g1 + 0x3c ], %g3
201d03c: 80 a0 80 03 cmp %g2, %g3
201d040: 32 80 00 08 bne,a 201d060 <rtems_rfs_file_close+0x15c> <== NEVER TAKEN
201d044: c4 20 60 3c st %g2, [ %g1 + 0x3c ] <== NOT EXECUTED
201d048: c8 00 60 88 ld [ %g1 + 0x88 ], %g4
201d04c: c6 00 60 40 ld [ %g1 + 0x40 ], %g3
201d050: 80 a1 00 03 cmp %g4, %g3
201d054: 02 80 00 08 be 201d074 <rtems_rfs_file_close+0x170> <== ALWAYS TAKEN
201d058: 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);
201d05c: c4 20 60 3c st %g2, [ %g1 + 0x3c ] <== NOT EXECUTED
201d060: c4 00 60 88 ld [ %g1 + 0x88 ], %g2 <== NOT EXECUTED
map->dirty = true;
201d064: 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);
201d068: c4 20 60 40 st %g2, [ %g1 + 0x40 ] <== NOT EXECUTED
map->dirty = true;
201d06c: 84 10 20 01 mov 1, %g2 <== NOT EXECUTED
201d070: 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);
201d074: d2 06 60 1c ld [ %i1 + 0x1c ], %o1
201d078: 90 10 00 18 mov %i0, %o0
201d07c: 7f ff f5 bf call 201a778 <rtems_rfs_block_map_close>
201d080: 92 02 60 34 add %o1, 0x34, %o1
if (rc > 0)
201d084: b8 92 20 00 orcc %o0, 0, %i4
201d088: 04 80 00 14 ble 201d0d8 <rtems_rfs_file_close+0x1d4> <== ALWAYS TAKEN
201d08c: 90 10 20 10 mov 0x10, %o0
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_CLOSE))
201d090: 7f ff d9 d0 call 20137d0 <rtems_rfs_trace> <== NOT EXECUTED
201d094: 92 10 20 00 clr %o1 <== NOT EXECUTED
201d098: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
201d09c: 02 80 00 0d be 201d0d0 <rtems_rfs_file_close+0x1cc> <== NOT EXECUTED
201d0a0: 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));
201d0a4: 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",
201d0a8: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
201d0ac: 40 00 18 82 call 20232b4 <strerror> <== NOT EXECUTED
201d0b0: f6 00 60 14 ld [ %g1 + 0x14 ], %i3 <== NOT EXECUTED
201d0b4: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
201d0b8: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
201d0bc: 94 10 00 1c mov %i4, %o2 <== NOT EXECUTED
201d0c0: 11 00 80 d1 sethi %hi(0x2034400), %o0 <== NOT EXECUTED
201d0c4: 40 00 14 0d call 20220f8 <printf> <== NOT EXECUTED
201d0c8: 90 12 20 48 or %o0, 0x48, %o0 ! 2034448 <CSWTCH.2+0xd68> <== NOT EXECUTED
handle->shared->inode.ino, rc, strerror (rc));
if (rrc == 0)
201d0cc: 80 a7 60 00 cmp %i5, 0 <== NOT EXECUTED
201d0d0: 22 80 00 02 be,a 201d0d8 <rtems_rfs_file_close+0x1d4> <== NOT EXECUTED
201d0d4: ba 10 00 1c mov %i4, %i5 <== NOT EXECUTED
rrc = rc;
}
rc = rtems_rfs_inode_close (fs, &handle->shared->inode);
201d0d8: d2 06 60 1c ld [ %i1 + 0x1c ], %o1
201d0dc: 90 10 00 18 mov %i0, %o0
201d0e0: 7f ff d3 9d call 2011f54 <rtems_rfs_inode_close>
201d0e4: 92 02 60 0c add %o1, 0xc, %o1
if (rc > 0)
201d0e8: b8 92 20 00 orcc %o0, 0, %i4
201d0ec: 04 80 00 14 ble 201d13c <rtems_rfs_file_close+0x238> <== ALWAYS TAKEN
201d0f0: 90 10 20 10 mov 0x10, %o0
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_CLOSE))
201d0f4: 7f ff d9 b7 call 20137d0 <rtems_rfs_trace> <== NOT EXECUTED
201d0f8: 92 10 20 00 clr %o1 <== NOT EXECUTED
201d0fc: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
201d100: 02 80 00 0d be 201d134 <rtems_rfs_file_close+0x230> <== NOT EXECUTED
201d104: 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));
201d108: 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",
201d10c: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
201d110: 40 00 18 69 call 20232b4 <strerror> <== NOT EXECUTED
201d114: f6 00 60 14 ld [ %g1 + 0x14 ], %i3 <== NOT EXECUTED
201d118: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
201d11c: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
201d120: 94 10 00 1c mov %i4, %o2 <== NOT EXECUTED
201d124: 11 00 80 d1 sethi %hi(0x2034400), %o0 <== NOT EXECUTED
201d128: 40 00 13 f4 call 20220f8 <printf> <== NOT EXECUTED
201d12c: 90 12 20 88 or %o0, 0x88, %o0 ! 2034488 <CSWTCH.2+0xda8> <== NOT EXECUTED
handle->shared->inode.ino, rc, strerror (rc));
if (rrc == 0)
201d130: 80 a7 60 00 cmp %i5, 0 <== NOT EXECUTED
201d134: 22 80 00 02 be,a 201d13c <rtems_rfs_file_close+0x238> <== NOT EXECUTED
201d138: 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 );
201d13c: 7f ff ec 8f call 2018378 <_Chain_Extract>
201d140: d0 06 60 1c ld [ %i1 + 0x1c ], %o0
rrc = rc;
}
rtems_chain_extract (&handle->shared->link);
free (handle->shared);
201d144: 7f ff ac 39 call 2008228 <free>
201d148: 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);
201d14c: 90 10 00 18 mov %i0, %o0
201d150: 7f ff f8 a2 call 201b3d8 <rtems_rfs_buffer_handle_release>
201d154: 92 06 60 04 add %i1, 4, %o1
handle->dirty = false;
201d158: c0 2e 60 04 clrb [ %i1 + 4 ]
handle->bnum = 0;
201d15c: 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)
201d160: 80 a7 60 00 cmp %i5, 0
201d164: 04 80 00 0f ble 201d1a0 <rtems_rfs_file_close+0x29c> <== ALWAYS TAKEN
201d168: c0 26 60 0c clr [ %i1 + 0xc ]
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_CLOSE))
201d16c: 90 10 20 10 mov 0x10, %o0 <== NOT EXECUTED
201d170: 7f ff d9 98 call 20137d0 <rtems_rfs_trace> <== NOT EXECUTED
201d174: 92 10 20 00 clr %o1 <== NOT EXECUTED
201d178: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
201d17c: 22 80 00 0a be,a 201d1a4 <rtems_rfs_file_close+0x2a0> <== NOT EXECUTED
201d180: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
printf ("rtems-rfs: file-close: result: %d: %s\n", rrc, strerror (rrc));
201d184: 40 00 18 4c call 20232b4 <strerror> <== NOT EXECUTED
201d188: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
201d18c: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
201d190: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
201d194: 11 00 80 d1 sethi %hi(0x2034400), %o0 <== NOT EXECUTED
201d198: 40 00 13 d8 call 20220f8 <printf> <== NOT EXECUTED
201d19c: 90 12 20 c8 or %o0, 0xc8, %o0 ! 20344c8 <CSWTCH.2+0xde8> <== NOT EXECUTED
}
free (handle);
201d1a0: 90 10 00 19 mov %i1, %o0
201d1a4: 7f ff ac 21 call 2008228 <free>
201d1a8: b0 10 00 1d mov %i5, %i0
return rrc;
}
201d1ac: 81 c7 e0 08 ret
201d1b0: 81 e8 00 00 restore
0201d3d8 <rtems_rfs_file_io_end>:
int
rtems_rfs_file_io_end (rtems_rfs_file_handle* handle,
size_t size,
bool read)
{
201d3d8: 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))
201d3dc: 90 10 20 20 mov 0x20, %o0
201d3e0: 92 10 20 00 clr %o1
201d3e4: 7f ff d8 fb call 20137d0 <rtems_rfs_trace>
201d3e8: ba 10 00 18 mov %i0, %i5
201d3ec: 80 8a 20 ff btst 0xff, %o0
201d3f0: 22 80 00 0e be,a 201d428 <rtems_rfs_file_io_end+0x50> <== ALWAYS TAKEN
201d3f4: c2 07 60 0c ld [ %i5 + 0xc ], %g1
printf ("rtems-rfs: file-io: end: %s size=%zu\n",
201d3f8: 80 a6 a0 00 cmp %i2, 0 <== NOT EXECUTED
201d3fc: 22 80 00 05 be,a 201d410 <rtems_rfs_file_io_end+0x38> <== NOT EXECUTED
201d400: 13 00 80 d1 sethi %hi(0x2034400), %o1 <== NOT EXECUTED
201d404: 13 00 80 cc sethi %hi(0x2033000), %o1 <== NOT EXECUTED
201d408: 10 80 00 03 b 201d414 <rtems_rfs_file_io_end+0x3c> <== NOT EXECUTED
201d40c: 92 12 62 a8 or %o1, 0x2a8, %o1 ! 20332a8 <rtems_rfs_rtems_eval_config+0x2d0><== NOT EXECUTED
201d410: 92 12 60 f0 or %o1, 0xf0, %o1 <== NOT EXECUTED
201d414: 11 00 80 d1 sethi %hi(0x2034400), %o0 <== NOT EXECUTED
201d418: 94 10 00 19 mov %i1, %o2 <== NOT EXECUTED
201d41c: 40 00 13 37 call 20220f8 <printf> <== NOT EXECUTED
201d420: 90 12 21 b0 or %o0, 0x1b0, %o0 <== NOT EXECUTED
read ? "read" : "write", size);
if (rtems_rfs_buffer_handle_has_block (&handle->buffer))
201d424: c2 07 60 0c ld [ %i5 + 0xc ], %g1 <== NOT EXECUTED
201d428: 80 a0 60 00 cmp %g1, 0
201d42c: 02 80 00 1e be 201d4a4 <rtems_rfs_file_io_end+0xcc> <== NEVER TAKEN
201d430: 80 a6 a0 00 cmp %i2, 0
{
if (!read)
201d434: 32 80 00 05 bne,a 201d448 <rtems_rfs_file_io_end+0x70>
201d438: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
rtems_rfs_buffer_mark_dirty (rtems_rfs_file_buffer (handle));
201d43c: 82 10 20 01 mov 1, %g1
201d440: c2 2f 60 04 stb %g1, [ %i5 + 4 ]
rc = rtems_rfs_buffer_handle_release (rtems_rfs_file_fs (handle),
201d444: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
201d448: 92 07 60 04 add %i5, 4, %o1
201d44c: 7f ff f7 e3 call 201b3d8 <rtems_rfs_buffer_handle_release>
201d450: d0 00 60 98 ld [ %g1 + 0x98 ], %o0
rtems_rfs_file_buffer (handle));
if (rc > 0)
201d454: b0 92 20 00 orcc %o0, 0, %i0
201d458: 04 80 00 14 ble 201d4a8 <rtems_rfs_file_io_end+0xd0> <== ALWAYS TAKEN
201d45c: 80 a6 a0 00 cmp %i2, 0
{
printf (
201d460: 22 80 00 05 be,a 201d474 <rtems_rfs_file_io_end+0x9c> <== NOT EXECUTED
201d464: 3b 00 80 d1 sethi %hi(0x2034400), %i5 <== NOT EXECUTED
201d468: 3b 00 80 cc sethi %hi(0x2033000), %i5 <== NOT EXECUTED
201d46c: 10 80 00 03 b 201d478 <rtems_rfs_file_io_end+0xa0> <== NOT EXECUTED
201d470: ba 17 62 a8 or %i5, 0x2a8, %i5 ! 20332a8 <rtems_rfs_rtems_eval_config+0x2d0><== NOT EXECUTED
201d474: ba 17 60 f0 or %i5, 0xf0, %i5 <== NOT EXECUTED
201d478: 40 00 17 8f call 20232b4 <strerror> <== NOT EXECUTED
201d47c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
201d480: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
201d484: 98 10 00 08 mov %o0, %o4 <== NOT EXECUTED
201d488: 94 10 00 19 mov %i1, %o2 <== NOT EXECUTED
201d48c: 11 00 80 d1 sethi %hi(0x2034400), %o0 <== NOT EXECUTED
201d490: 96 10 00 18 mov %i0, %o3 <== NOT EXECUTED
201d494: 40 00 13 19 call 20220f8 <printf> <== NOT EXECUTED
201d498: 90 12 21 d8 or %o0, 0x1d8, %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;
201d49c: 81 c7 e0 08 ret <== NOT EXECUTED
201d4a0: 81 e8 00 00 restore <== NOT EXECUTED
bool read)
{
bool atime;
bool mtime;
bool length;
int rc = 0;
201d4a4: 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;
201d4a8: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
201d4ac: b2 06 40 01 add %i1, %g1, %i1
if (handle->bpos.boff >=
rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle)))
201d4b0: 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;
201d4b4: f2 27 60 14 st %i1, [ %i5 + 0x14 ]
if (handle->bpos.boff >=
rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle)))
201d4b8: c4 00 60 98 ld [ %g1 + 0x98 ], %g2
201d4bc: 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 >=
201d4c0: 80 a6 40 02 cmp %i1, %g2
201d4c4: 0a 80 00 07 bcs 201d4e0 <rtems_rfs_file_io_end+0x108>
201d4c8: 80 a6 a0 00 cmp %i2, 0
rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle)))
{
handle->bpos.bno++;
201d4cc: c6 07 60 10 ld [ %i5 + 0x10 ], %g3
handle->bpos.boff -= rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
201d4d0: 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++;
201d4d4: 86 00 e0 01 inc %g3
handle->bpos.boff -= rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
201d4d8: 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++;
201d4dc: c6 27 60 10 st %g3, [ %i5 + 0x10 ]
}
length = false;
mtime = false;
if (!read &&
201d4e0: 12 80 00 19 bne 201d544 <rtems_rfs_file_io_end+0x16c>
201d4e4: 84 10 20 00 clr %g2
rtems_rfs_block_map_past_end (rtems_rfs_file_map (handle),
201d4e8: c6 07 60 10 ld [ %i5 + 0x10 ], %g3
}
length = false;
mtime = false;
if (!read &&
201d4ec: 80 a0 e0 00 cmp %g3, 0
201d4f0: 02 80 00 05 be 201d504 <rtems_rfs_file_io_end+0x12c>
201d4f4: c4 00 60 3c ld [ %g1 + 0x3c ], %g2
rtems_rfs_block_map_past_end (rtems_rfs_file_map (handle),
201d4f8: 80 a0 a0 00 cmp %g2, 0
201d4fc: 22 80 00 0f be,a 201d538 <rtems_rfs_file_io_end+0x160> <== NEVER TAKEN
201d500: c4 07 60 14 ld [ %i5 + 0x14 ], %g2 <== NOT EXECUTED
201d504: 80 a0 c0 02 cmp %g3, %g2
201d508: 3a 80 00 0c bcc,a 201d538 <rtems_rfs_file_io_end+0x160>
201d50c: c4 07 60 14 ld [ %i5 + 0x14 ], %g2
201d510: 88 00 bf ff add %g2, -1, %g4
201d514: 80 a0 c0 04 cmp %g3, %g4
201d518: 12 80 00 0b bne 201d544 <rtems_rfs_file_io_end+0x16c>
201d51c: 84 10 20 00 clr %g2
201d520: c8 07 60 14 ld [ %i5 + 0x14 ], %g4
201d524: c6 00 60 40 ld [ %g1 + 0x40 ], %g3
201d528: 80 a1 00 03 cmp %g4, %g3
201d52c: 28 80 00 07 bleu,a 201d548 <rtems_rfs_file_io_end+0x170>
201d530: 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;
201d534: c4 07 60 14 ld [ %i5 + 0x14 ], %g2
201d538: c4 20 60 40 st %g2, [ %g1 + 0x40 ]
map->dirty = true;
201d53c: 84 10 20 01 mov 1, %g2
201d540: c4 28 60 34 stb %g2, [ %g1 + 0x34 ]
handle->bpos.boff);
length = true;
mtime = true;
}
atime = rtems_rfs_file_update_atime (handle);
201d544: c2 07 40 00 ld [ %i5 ], %g1
mtime = rtems_rfs_file_update_mtime (handle) && mtime;
201d548: b8 10 20 00 clr %i4
handle->bpos.boff);
length = true;
mtime = true;
}
atime = rtems_rfs_file_update_atime (handle);
201d54c: a2 08 60 01 and %g1, 1, %l1
mtime = rtems_rfs_file_update_mtime (handle) && mtime;
201d550: 80 88 60 02 btst 2, %g1
201d554: a2 1c 60 01 xor %l1, 1, %l1
201d558: 12 80 00 03 bne 201d564 <rtems_rfs_file_io_end+0x18c> <== NEVER TAKEN
201d55c: a0 10 00 11 mov %l1, %l0
201d560: b8 08 a0 ff and %g2, 0xff, %i4
201d564: b2 0f 20 01 and %i4, 1, %i1
length = rtems_rfs_file_update_length (handle) && length;
201d568: 80 88 60 04 btst 4, %g1
201d56c: 12 80 00 03 bne 201d578 <rtems_rfs_file_io_end+0x1a0> <== NEVER TAKEN
201d570: b6 10 20 00 clr %i3
201d574: b6 08 a0 ff and %g2, 0xff, %i3
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
201d578: 90 10 20 20 mov 0x20, %o0
201d57c: 92 10 20 00 clr %o1
201d580: 7f ff d8 94 call 20137d0 <rtems_rfs_trace>
201d584: b6 0e e0 01 and %i3, 1, %i3
201d588: 80 8a 20 ff btst 0xff, %o0
201d58c: 22 80 00 17 be,a 201d5e8 <rtems_rfs_file_io_end+0x210> <== ALWAYS TAKEN
201d590: b8 17 00 11 or %i4, %l1, %i4
printf ("rtems-rfs: file-io: end: pos=%" PRIu32 ":%" PRIu32 " %c %c %c\n",
201d594: 82 0c 20 ff and %l0, 0xff, %g1 <== NOT EXECUTED
201d598: 80 a0 00 01 cmp %g0, %g1 <== NOT EXECUTED
201d59c: d2 07 60 10 ld [ %i5 + 0x10 ], %o1 <== NOT EXECUTED
201d5a0: 96 40 3f ff addx %g0, -1, %o3 <== NOT EXECUTED
201d5a4: 82 0e 60 ff and %i1, 0xff, %g1 <== NOT EXECUTED
201d5a8: d4 07 60 14 ld [ %i5 + 0x14 ], %o2 <== NOT EXECUTED
201d5ac: 80 a0 00 01 cmp %g0, %g1 <== NOT EXECUTED
201d5b0: 82 0e e0 ff and %i3, 0xff, %g1 <== NOT EXECUTED
201d5b4: 98 40 3f ff addx %g0, -1, %o4 <== NOT EXECUTED
201d5b8: 80 a0 00 01 cmp %g0, %g1 <== NOT EXECUTED
201d5bc: 96 0a ff ec and %o3, -20, %o3 <== NOT EXECUTED
201d5c0: 98 0b 3f e0 and %o4, -32, %o4 <== NOT EXECUTED
201d5c4: 9a 40 3f ff addx %g0, -1, %o5 <== NOT EXECUTED
201d5c8: 11 00 80 d1 sethi %hi(0x2034400), %o0 <== NOT EXECUTED
201d5cc: 9a 0b 7f e1 and %o5, -31, %o5 <== NOT EXECUTED
201d5d0: 90 12 22 20 or %o0, 0x220, %o0 <== NOT EXECUTED
201d5d4: 96 02 e0 41 add %o3, 0x41, %o3 <== NOT EXECUTED
201d5d8: 98 03 20 4d add %o4, 0x4d, %o4 <== NOT EXECUTED
201d5dc: 40 00 12 c7 call 20220f8 <printf> <== NOT EXECUTED
201d5e0: 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)
201d5e4: b8 17 00 11 or %i4, %l1, %i4 <== NOT EXECUTED
201d5e8: 80 8f 20 01 btst 1, %i4
201d5ec: 02 80 00 13 be 201d638 <rtems_rfs_file_io_end+0x260> <== NEVER TAKEN
201d5f0: 80 8e e0 ff btst 0xff, %i3
{
time_t now = time (NULL);
201d5f4: 40 00 22 c0 call 20260f4 <time>
201d5f8: 90 10 20 00 clr %o0
if (read && atime)
201d5fc: 80 a6 a0 00 cmp %i2, 0
201d600: 02 80 00 07 be 201d61c <rtems_rfs_file_io_end+0x244>
201d604: 80 8e 60 ff btst 0xff, %i1
201d608: 80 8c 20 ff btst 0xff, %l0
201d60c: 02 80 00 04 be 201d61c <rtems_rfs_file_io_end+0x244> <== NEVER TAKEN
201d610: 80 8e 60 ff btst 0xff, %i1
handle->shared->atime = now;
201d614: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
201d618: d0 20 60 8c st %o0, [ %g1 + 0x8c ]
if (!read && mtime)
201d61c: 02 80 00 07 be 201d638 <rtems_rfs_file_io_end+0x260>
201d620: 80 8e e0 ff btst 0xff, %i3
201d624: 80 a6 a0 01 cmp %i2, 1
201d628: 02 80 00 04 be 201d638 <rtems_rfs_file_io_end+0x260> <== NEVER TAKEN
201d62c: 80 8e e0 ff btst 0xff, %i3
handle->shared->mtime = now;
201d630: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
201d634: d0 20 60 90 st %o0, [ %g1 + 0x90 ]
}
if (length)
201d638: 02 80 00 07 be 201d654 <rtems_rfs_file_io_end+0x27c>
201d63c: 01 00 00 00 nop
{
handle->shared->size.count =
rtems_rfs_block_map_count (rtems_rfs_file_map (handle));
201d640: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
if (!read && mtime)
handle->shared->mtime = now;
}
if (length)
{
handle->shared->size.count =
201d644: c4 00 60 3c ld [ %g1 + 0x3c ], %g2
201d648: c4 20 60 84 st %g2, [ %g1 + 0x84 ]
rtems_rfs_block_map_count (rtems_rfs_file_map (handle));
handle->shared->size.offset =
201d64c: c4 00 60 40 ld [ %g1 + 0x40 ], %g2
201d650: c4 20 60 88 st %g2, [ %g1 + 0x88 ]
rtems_rfs_block_map_size_offset (rtems_rfs_file_map (handle));
}
return rc;
}
201d654: 81 c7 e0 08 ret
201d658: 81 e8 00 00 restore
0201d65c <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))
201d65c: c2 02 20 0c ld [ %o0 + 0xc ], %g1
201d660: 80 a0 60 00 cmp %g1, 0
201d664: 02 80 00 08 be 201d684 <rtems_rfs_file_io_release+0x28> <== ALWAYS TAKEN
201d668: 92 10 00 08 mov %o0, %o1
rc = rtems_rfs_buffer_handle_release (rtems_rfs_file_fs (handle),
201d66c: c2 02 20 1c ld [ %o0 + 0x1c ], %g1 <== NOT EXECUTED
201d670: 92 02 60 04 add %o1, 4, %o1 <== NOT EXECUTED
201d674: d0 00 60 98 ld [ %g1 + 0x98 ], %o0 <== NOT EXECUTED
201d678: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED
201d67c: 7f ff f7 57 call 201b3d8 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
201d680: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED
rtems_rfs_file_buffer (handle));
return rc;
}
201d684: 81 c3 e0 08 retl
201d688: 90 10 20 00 clr %o0
0201d1b4 <rtems_rfs_file_io_start>:
int
rtems_rfs_file_io_start (rtems_rfs_file_handle* handle,
size_t* available,
bool read)
{
201d1b4: 9d e3 bf 98 save %sp, -104, %sp
size_t size;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
201d1b8: 90 10 20 20 mov 0x20, %o0
201d1bc: 92 10 20 00 clr %o1
201d1c0: 7f ff d9 84 call 20137d0 <rtems_rfs_trace>
201d1c4: ba 10 00 18 mov %i0, %i5
201d1c8: 80 8a 20 ff btst 0xff, %o0
201d1cc: 22 80 00 0f be,a 201d208 <rtems_rfs_file_io_start+0x54> <== ALWAYS TAKEN
201d1d0: c2 07 60 0c ld [ %i5 + 0xc ], %g1
printf ("rtems-rfs: file-io: start: %s pos=%" PRIu32 ":%" PRIu32 "\n",
201d1d4: 80 a6 a0 00 cmp %i2, 0 <== NOT EXECUTED
201d1d8: 22 80 00 05 be,a 201d1ec <rtems_rfs_file_io_start+0x38> <== NOT EXECUTED
201d1dc: 13 00 80 d1 sethi %hi(0x2034400), %o1 <== NOT EXECUTED
201d1e0: 13 00 80 cc sethi %hi(0x2033000), %o1 <== NOT EXECUTED
201d1e4: 10 80 00 03 b 201d1f0 <rtems_rfs_file_io_start+0x3c> <== NOT EXECUTED
201d1e8: 92 12 62 a8 or %o1, 0x2a8, %o1 ! 20332a8 <rtems_rfs_rtems_eval_config+0x2d0><== NOT EXECUTED
201d1ec: 92 12 60 f0 or %o1, 0xf0, %o1 <== NOT EXECUTED
201d1f0: d4 07 60 10 ld [ %i5 + 0x10 ], %o2 <== NOT EXECUTED
201d1f4: d6 07 60 14 ld [ %i5 + 0x14 ], %o3 <== NOT EXECUTED
201d1f8: 11 00 80 d1 sethi %hi(0x2034400), %o0 <== NOT EXECUTED
201d1fc: 40 00 13 bf call 20220f8 <printf> <== NOT EXECUTED
201d200: 90 12 20 f8 or %o0, 0xf8, %o0 ! 20344f8 <CSWTCH.2+0xe18> <== NOT EXECUTED
read ? "read" : "write", handle->bpos.bno, handle->bpos.boff);
if (!rtems_rfs_buffer_handle_has_block (&handle->buffer))
201d204: c2 07 60 0c ld [ %i5 + 0xc ], %g1 <== NOT EXECUTED
201d208: 80 a0 60 00 cmp %g1, 0
201d20c: 12 80 00 4f bne 201d348 <rtems_rfs_file_io_start+0x194>
201d210: 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),
201d214: d2 07 60 1c ld [ %i5 + 0x1c ], %o1
201d218: 94 07 60 10 add %i5, 0x10, %o2
201d21c: d0 02 60 98 ld [ %o1 + 0x98 ], %o0
201d220: 96 07 bf fc add %fp, -4, %o3
201d224: 7f ff f5 c9 call 201a948 <rtems_rfs_block_map_find>
201d228: 92 02 60 34 add %o1, 0x34, %o1
rtems_rfs_file_map (handle),
rtems_rfs_file_bpos (handle),
&block);
if (rc > 0)
201d22c: b0 92 20 00 orcc %o0, 0, %i0
201d230: 04 80 00 1e ble 201d2a8 <rtems_rfs_file_io_start+0xf4>
201d234: 80 a6 20 06 cmp %i0, 6
{
/*
* Has the read reached the EOF ?
*/
if (read && (rc == ENXIO))
201d238: 32 80 00 66 bne,a 201d3d0 <rtems_rfs_file_io_start+0x21c><== NEVER TAKEN
201d23c: 90 10 20 20 mov 0x20, %o0 <== NOT EXECUTED
201d240: 80 a6 a0 00 cmp %i2, 0
201d244: 22 80 00 05 be,a 201d258 <rtems_rfs_file_io_start+0xa4> <== ALWAYS TAKEN
201d248: 80 a6 20 06 cmp %i0, 6
{
*available = 0;
201d24c: c0 26 40 00 clr [ %i1 ] <== NOT EXECUTED
return 0;
201d250: 81 c7 e0 08 ret <== NOT EXECUTED
201d254: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED
}
if (rc != ENXIO)
201d258: 12 80 00 5e bne 201d3d0 <rtems_rfs_file_io_start+0x21c> <== NEVER TAKEN
201d25c: 90 10 20 20 mov 0x20, %o0
return rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
201d260: 7f ff d9 5c call 20137d0 <rtems_rfs_trace>
201d264: 92 10 20 00 clr %o1
201d268: 80 8a 20 ff btst 0xff, %o0
201d26c: 22 80 00 06 be,a 201d284 <rtems_rfs_file_io_start+0xd0> <== ALWAYS TAKEN
201d270: d2 07 60 1c ld [ %i5 + 0x1c ], %o1
printf ("rtems-rfs: file-io: start: grow\n");
201d274: 11 00 80 d1 sethi %hi(0x2034400), %o0 <== NOT EXECUTED
201d278: 40 00 14 38 call 2022358 <puts> <== NOT EXECUTED
201d27c: 90 12 21 28 or %o0, 0x128, %o0 ! 2034528 <CSWTCH.2+0xe48> <== NOT EXECUTED
rc = rtems_rfs_block_map_grow (rtems_rfs_file_fs (handle),
201d280: d2 07 60 1c ld [ %i5 + 0x1c ], %o1 <== NOT EXECUTED
201d284: 94 10 20 01 mov 1, %o2
201d288: d0 02 60 98 ld [ %o1 + 0x98 ], %o0
201d28c: 96 07 bf fc add %fp, -4, %o3
201d290: 7f ff f6 34 call 201ab60 <rtems_rfs_block_map_grow>
201d294: 92 02 60 34 add %o1, 0x34, %o1
rtems_rfs_file_map (handle),
1, &block);
if (rc > 0)
201d298: b0 92 20 00 orcc %o0, 0, %i0
201d29c: 14 80 00 4d bg 201d3d0 <rtems_rfs_file_io_start+0x21c>
201d2a0: b8 10 20 00 clr %i4
201d2a4: 30 80 00 0f b,a 201d2e0 <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 &&
201d2a8: 80 a6 a0 00 cmp %i2, 0
201d2ac: 12 80 00 0d bne 201d2e0 <rtems_rfs_file_io_start+0x12c>
201d2b0: b8 10 00 1a mov %i2, %i4
201d2b4: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
201d2b8: 80 a0 60 00 cmp %g1, 0
201d2bc: 12 80 00 09 bne 201d2e0 <rtems_rfs_file_io_start+0x12c>
201d2c0: b8 10 20 01 mov 1, %i4
(rtems_rfs_file_block_offset (handle) ||
(*available < rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle)))))
201d2c4: 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) ||
201d2c8: c4 06 40 00 ld [ %i1 ], %g2
(*available < rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle)))))
201d2cc: 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) ||
201d2d0: c2 00 60 08 ld [ %g1 + 8 ], %g1
201d2d4: 80 a0 80 01 cmp %g2, %g1
201d2d8: 3a 80 00 02 bcc,a 201d2e0 <rtems_rfs_file_io_start+0x12c><== NEVER TAKEN
201d2dc: 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))
201d2e0: 90 10 20 20 mov 0x20, %o0
201d2e4: 7f ff d9 3b call 20137d0 <rtems_rfs_trace>
201d2e8: 92 10 20 00 clr %o1
201d2ec: 80 8a 20 ff btst 0xff, %o0
201d2f0: 22 80 00 0e be,a 201d328 <rtems_rfs_file_io_start+0x174> <== ALWAYS TAKEN
201d2f4: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
printf ("rtems-rfs: file-io: start: block=%" PRIu32 " request-read=%s\n",
201d2f8: 80 8f 20 ff btst 0xff, %i4 <== NOT EXECUTED
201d2fc: 02 80 00 05 be 201d310 <rtems_rfs_file_io_start+0x15c> <== NOT EXECUTED
201d300: d2 07 bf fc ld [ %fp + -4 ], %o1 <== NOT EXECUTED
201d304: 15 00 80 cb sethi %hi(0x2032c00), %o2 <== NOT EXECUTED
201d308: 10 80 00 04 b 201d318 <rtems_rfs_file_io_start+0x164> <== NOT EXECUTED
201d30c: 94 12 a1 28 or %o2, 0x128, %o2 ! 2032d28 <_CPU_Trap_slot_template+0xaf0><== NOT EXECUTED
201d310: 15 00 80 c3 sethi %hi(0x2030c00), %o2 <== NOT EXECUTED
201d314: 94 12 a2 18 or %o2, 0x218, %o2 ! 2030e18 <__FUNCTION__.7059+0x5f8><== NOT EXECUTED
201d318: 11 00 80 d1 sethi %hi(0x2034400), %o0 <== NOT EXECUTED
201d31c: 40 00 13 77 call 20220f8 <printf> <== NOT EXECUTED
201d320: 90 12 21 48 or %o0, 0x148, %o0 ! 2034548 <CSWTCH.2+0xe68> <== NOT EXECUTED
block, request_read ? "yes" : "no");
rc = rtems_rfs_buffer_handle_request (rtems_rfs_file_fs (handle),
201d324: c2 07 60 1c ld [ %i5 + 0x1c ], %g1 <== NOT EXECUTED
201d328: d4 07 bf fc ld [ %fp + -4 ], %o2
201d32c: d0 00 60 98 ld [ %g1 + 0x98 ], %o0
201d330: 92 07 60 04 add %i5, 4, %o1
201d334: 7f ff f8 9d call 201b5a8 <rtems_rfs_buffer_handle_request>
201d338: 96 0f 20 ff and %i4, 0xff, %o3
rtems_rfs_file_buffer (handle),
block, request_read);
if (rc > 0)
201d33c: b0 92 20 00 orcc %o0, 0, %i0
201d340: 14 80 00 24 bg 201d3d0 <rtems_rfs_file_io_start+0x21c> <== NEVER TAKEN
201d344: 80 a6 a0 00 cmp %i2, 0
return rc;
}
if (read
201d348: 02 80 00 12 be 201d390 <rtems_rfs_file_io_start+0x1dc>
201d34c: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
&& rtems_rfs_block_map_last (rtems_rfs_file_map (handle))
201d350: c4 00 60 44 ld [ %g1 + 0x44 ], %g2
201d354: 80 a0 a0 00 cmp %g2, 0
201d358: 12 80 00 05 bne 201d36c <rtems_rfs_file_io_start+0x1b8>
201d35c: c6 00 60 3c ld [ %g1 + 0x3c ], %g3
201d360: 80 a0 e0 00 cmp %g3, 0
201d364: 22 80 00 07 be,a 201d380 <rtems_rfs_file_io_start+0x1cc> <== NEVER TAKEN
201d368: f8 00 60 40 ld [ %g1 + 0x40 ], %i4 <== NOT EXECUTED
201d36c: 86 00 ff ff add %g3, -1, %g3
201d370: 80 a0 80 03 cmp %g2, %g3
201d374: 32 80 00 07 bne,a 201d390 <rtems_rfs_file_io_start+0x1dc>
201d378: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
&& rtems_rfs_block_map_size_offset (rtems_rfs_file_map (handle)))
201d37c: f8 00 60 40 ld [ %g1 + 0x40 ], %i4
201d380: 80 a7 20 00 cmp %i4, 0
201d384: 32 80 00 06 bne,a 201d39c <rtems_rfs_file_io_start+0x1e8>
201d388: 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));
201d38c: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
201d390: c2 00 60 98 ld [ %g1 + 0x98 ], %g1
201d394: f8 00 60 08 ld [ %g1 + 8 ], %i4
*available = size - rtems_rfs_file_block_offset (handle);
201d398: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
201d39c: 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);
201d3a0: 82 27 00 01 sub %i4, %g1, %g1
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
201d3a4: 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);
201d3a8: c2 26 40 00 st %g1, [ %i1 ]
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
201d3ac: 7f ff d9 09 call 20137d0 <rtems_rfs_trace>
201d3b0: b0 10 20 00 clr %i0
201d3b4: 80 8a 20 ff btst 0xff, %o0
201d3b8: 02 80 00 06 be 201d3d0 <rtems_rfs_file_io_start+0x21c> <== ALWAYS TAKEN
201d3bc: 11 00 80 d1 sethi %hi(0x2034400), %o0
printf ("rtems-rfs: file-io: start: available=%zu (%zu)\n",
201d3c0: d2 06 40 00 ld [ %i1 ], %o1 <== NOT EXECUTED
201d3c4: 94 10 00 1c mov %i4, %o2 <== NOT EXECUTED
201d3c8: 40 00 13 4c call 20220f8 <printf> <== NOT EXECUTED
201d3cc: 90 12 21 80 or %o0, 0x180, %o0 <== NOT EXECUTED
*available, size);
return 0;
}
201d3d0: 81 c7 e0 08 ret
201d3d4: 81 e8 00 00 restore
0201dae4 <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)
{
201dae4: 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))
201dae8: 90 10 20 08 mov 8, %o0
201daec: 7f ff d7 39 call 20137d0 <rtems_rfs_trace>
201daf0: 92 10 20 00 clr %o1
201daf4: 80 8a 20 ff btst 0xff, %o0
201daf8: 22 80 00 07 be,a 201db14 <rtems_rfs_file_open+0x30> <== ALWAYS TAKEN
201dafc: c0 26 c0 00 clr [ %i3 ]
printf ("rtems-rfs: file-open: ino=%" PRId32 "\n", ino);
201db00: 11 00 80 d1 sethi %hi(0x2034400), %o0 <== NOT EXECUTED
201db04: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
201db08: 40 00 11 7c call 20220f8 <printf> <== NOT EXECUTED
201db0c: 90 12 22 a0 or %o0, 0x2a0, %o0 <== NOT EXECUTED
*file = NULL;
201db10: 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));
201db14: 90 10 20 20 mov 0x20, %o0
201db18: 7f ff ab 6a call 20088c0 <malloc>
201db1c: a0 10 20 0c mov 0xc, %l0
if (!handle)
201db20: 80 a2 20 00 cmp %o0, 0
201db24: 02 80 00 a4 be 201ddb4 <rtems_rfs_file_open+0x2d0> <== NEVER TAKEN
201db28: ba 10 00 08 mov %o0, %i5
return ENOMEM;
memset (handle, 0, sizeof (rtems_rfs_file_handle));
201db2c: 92 10 20 00 clr %o1
201db30: 40 00 10 f4 call 2021f00 <memset>
201db34: 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);
201db38: 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;
201db3c: c0 2f 60 04 clrb [ %i5 + 4 ]
handle->bnum = 0;
201db40: c0 27 60 08 clr [ %i5 + 8 ]
handle->buffer = NULL;
201db44: c0 27 60 0c clr [ %i5 + 0xc ]
201db48: 7f ff ff d9 call 201daac <rtems_rfs_file_get_shared>
201db4c: 92 10 00 19 mov %i1, %o1
if (shared)
201db50: b8 92 20 00 orcc %o0, 0, %i4
201db54: 02 80 00 0d be 201db88 <rtems_rfs_file_open+0xa4> <== ALWAYS TAKEN
201db58: 90 10 20 08 mov 8, %o0
{
shared->references++;
201db5c: c2 07 20 08 ld [ %i4 + 8 ], %g1 <== NOT EXECUTED
201db60: 82 00 60 01 inc %g1 <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_OPEN))
201db64: 92 10 20 00 clr %o1 <== NOT EXECUTED
201db68: 7f ff d7 1a call 20137d0 <rtems_rfs_trace> <== NOT EXECUTED
201db6c: c2 27 20 08 st %g1, [ %i4 + 8 ] <== NOT EXECUTED
201db70: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
201db74: 22 80 00 8d be,a 201dda8 <rtems_rfs_file_open+0x2c4> <== NOT EXECUTED
201db78: f4 27 40 00 st %i2, [ %i5 ] <== NOT EXECUTED
printf ("rtems-rfs: file-open: ino=%" PRId32 " shared\n", ino);
201db7c: 11 00 80 d1 sethi %hi(0x2034400), %o0 <== NOT EXECUTED
201db80: 10 80 00 87 b 201dd9c <rtems_rfs_file_open+0x2b8> <== NOT EXECUTED
201db84: 90 12 22 c0 or %o0, 0x2c0, %o0 ! 20346c0 <CSWTCH.2+0xfe0> <== 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));
201db88: 7f ff ab 4e call 20088c0 <malloc>
201db8c: 90 10 20 9c mov 0x9c, %o0
if (!shared)
201db90: b8 92 20 00 orcc %o0, 0, %i4
201db94: 12 80 00 04 bne 201dba4 <rtems_rfs_file_open+0xc0> <== ALWAYS TAKEN
201db98: 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);
201db9c: 10 80 00 34 b 201dc6c <rtems_rfs_file_open+0x188> <== NOT EXECUTED
201dba0: 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));
201dba4: 40 00 10 d7 call 2021f00 <memset>
201dba8: 94 10 20 9c mov 0x9c, %o2
rc = rtems_rfs_inode_open (fs, ino, &shared->inode, true);
201dbac: a2 07 20 0c add %i4, 0xc, %l1
201dbb0: 90 10 00 18 mov %i0, %o0
201dbb4: 92 10 00 19 mov %i1, %o1
201dbb8: 94 10 00 11 mov %l1, %o2
201dbbc: 7f ff d0 74 call 2011d8c <rtems_rfs_inode_open>
201dbc0: 96 10 20 01 mov 1, %o3
if (rc > 0)
201dbc4: a0 92 20 00 orcc %o0, 0, %l0
201dbc8: 04 80 00 0f ble 201dc04 <rtems_rfs_file_open+0x120> <== ALWAYS TAKEN
201dbcc: 90 10 20 08 mov 8, %o0
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_OPEN))
201dbd0: 7f ff d7 00 call 20137d0 <rtems_rfs_trace> <== NOT EXECUTED
201dbd4: 92 10 20 00 clr %o1 <== NOT EXECUTED
201dbd8: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
201dbdc: 02 80 00 21 be 201dc60 <rtems_rfs_file_open+0x17c> <== NOT EXECUTED
201dbe0: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: file-open: inode open failed: %d: %s\n",
201dbe4: 40 00 15 b4 call 20232b4 <strerror> <== NOT EXECUTED
201dbe8: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
201dbec: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED
201dbf0: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
201dbf4: 11 00 80 d1 sethi %hi(0x2034400), %o0 <== NOT EXECUTED
201dbf8: 40 00 11 40 call 20220f8 <printf> <== NOT EXECUTED
201dbfc: 90 12 22 e8 or %o0, 0x2e8, %o0 ! 20346e8 <CSWTCH.2+0x1008><== NOT EXECUTED
201dc00: 30 80 00 18 b,a 201dc60 <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);
201dc04: 90 10 00 18 mov %i0, %o0
201dc08: 92 10 00 11 mov %l1, %o1
201dc0c: 7f ff f2 7a call 201a5f4 <rtems_rfs_block_map_open>
201dc10: 94 07 20 34 add %i4, 0x34, %o2
if (rc > 0)
201dc14: a0 92 20 00 orcc %o0, 0, %l0
201dc18: 04 80 00 1e ble 201dc90 <rtems_rfs_file_open+0x1ac> <== ALWAYS TAKEN
201dc1c: 82 10 20 01 mov 1, %g1
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_OPEN))
201dc20: 90 10 20 08 mov 8, %o0 <== NOT EXECUTED
201dc24: 7f ff d6 eb call 20137d0 <rtems_rfs_trace> <== NOT EXECUTED
201dc28: 92 10 20 00 clr %o1 <== NOT EXECUTED
201dc2c: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
201dc30: 22 80 00 0a be,a 201dc58 <rtems_rfs_file_open+0x174> <== NOT EXECUTED
201dc34: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
printf ("rtems-rfs: file-open: block map open failed: %d: %s\n",
201dc38: 40 00 15 9f call 20232b4 <strerror> <== NOT EXECUTED
201dc3c: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
201dc40: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED
201dc44: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
201dc48: 11 00 80 d1 sethi %hi(0x2034400), %o0 <== NOT EXECUTED
201dc4c: 40 00 11 2b call 20220f8 <printf> <== NOT EXECUTED
201dc50: 90 12 23 20 or %o0, 0x320, %o0 ! 2034720 <CSWTCH.2+0x1040><== NOT EXECUTED
rc, strerror (rc));
rtems_rfs_inode_close (fs, &shared->inode);
201dc54: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
201dc58: 7f ff d0 bf call 2011f54 <rtems_rfs_inode_close> <== NOT EXECUTED
201dc5c: 92 10 00 11 mov %l1, %o1 <== NOT EXECUTED
free (shared);
201dc60: 7f ff a9 72 call 2008228 <free> <== NOT EXECUTED
201dc64: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
201dc68: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
201dc6c: 7f ff f5 db call 201b3d8 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
201dc70: 92 07 60 04 add %i5, 4, %o1 <== NOT EXECUTED
rtems_rfs_buffer_handle_close (fs, &handle->buffer);
free (handle);
201dc74: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
handle->dirty = false;
201dc78: c0 2f 60 04 clrb [ %i5 + 4 ] <== NOT EXECUTED
handle->bnum = 0;
201dc7c: c0 27 60 08 clr [ %i5 + 8 ] <== NOT EXECUTED
201dc80: 7f ff a9 6a call 2008228 <free> <== NOT EXECUTED
201dc84: c0 27 60 0c clr [ %i5 + 0xc ] <== NOT EXECUTED
return rc;
201dc88: 81 c7 e0 08 ret <== NOT EXECUTED
201dc8c: 91 e8 00 10 restore %g0, %l0, %o0 <== NOT EXECUTED
}
shared->references = 1;
201dc90: 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);
201dc94: 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 );
201dc98: 90 06 20 74 add %i0, 0x74, %o0
201dc9c: c6 08 60 0c ldub [ %g1 + 0xc ], %g3
201dca0: c4 08 60 0d ldub [ %g1 + 0xd ], %g2
201dca4: 87 28 e0 18 sll %g3, 0x18, %g3
201dca8: 85 28 a0 10 sll %g2, 0x10, %g2
201dcac: 84 10 c0 02 or %g3, %g2, %g2
201dcb0: c6 08 60 0f ldub [ %g1 + 0xf ], %g3
201dcb4: 92 10 00 1c mov %i4, %o1
201dcb8: 84 10 80 03 or %g2, %g3, %g2
201dcbc: c6 08 60 0e ldub [ %g1 + 0xe ], %g3
201dcc0: 87 28 e0 08 sll %g3, 8, %g3
201dcc4: 84 10 80 03 or %g2, %g3, %g2
shared->size.count = rtems_rfs_inode_get_block_count (&shared->inode);
201dcc8: c4 27 20 84 st %g2, [ %i4 + 0x84 ]
shared->size.offset = rtems_rfs_inode_get_block_offset (&shared->inode);
201dccc: 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);
201dcd0: c4 08 60 0a ldub [ %g1 + 0xa ], %g2
201dcd4: 85 28 a0 08 sll %g2, 8, %g2
201dcd8: 84 10 c0 02 or %g3, %g2, %g2
201dcdc: 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);
201dce0: c6 08 60 10 ldub [ %g1 + 0x10 ], %g3
201dce4: c4 08 60 11 ldub [ %g1 + 0x11 ], %g2
201dce8: 87 28 e0 18 sll %g3, 0x18, %g3
201dcec: 85 28 a0 10 sll %g2, 0x10, %g2
201dcf0: 84 10 c0 02 or %g3, %g2, %g2
201dcf4: c6 08 60 13 ldub [ %g1 + 0x13 ], %g3
201dcf8: 84 10 80 03 or %g2, %g3, %g2
201dcfc: c6 08 60 12 ldub [ %g1 + 0x12 ], %g3
201dd00: 87 28 e0 08 sll %g3, 8, %g3
201dd04: 84 10 80 03 or %g2, %g3, %g2
shared->atime = rtems_rfs_inode_get_atime (&shared->inode);
201dd08: 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);
201dd0c: c6 08 60 14 ldub [ %g1 + 0x14 ], %g3
201dd10: c4 08 60 15 ldub [ %g1 + 0x15 ], %g2
201dd14: 87 28 e0 18 sll %g3, 0x18, %g3
201dd18: 85 28 a0 10 sll %g2, 0x10, %g2
201dd1c: 84 10 c0 02 or %g3, %g2, %g2
201dd20: c6 08 60 17 ldub [ %g1 + 0x17 ], %g3
201dd24: 84 10 80 03 or %g2, %g3, %g2
201dd28: c6 08 60 16 ldub [ %g1 + 0x16 ], %g3
201dd2c: 87 28 e0 08 sll %g3, 8, %g3
201dd30: 84 10 80 03 or %g2, %g3, %g2
shared->mtime = rtems_rfs_inode_get_mtime (&shared->inode);
201dd34: 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);
201dd38: c4 08 60 19 ldub [ %g1 + 0x19 ], %g2
201dd3c: c6 08 60 18 ldub [ %g1 + 0x18 ], %g3
201dd40: 85 28 a0 10 sll %g2, 0x10, %g2
201dd44: 87 28 e0 18 sll %g3, 0x18, %g3
201dd48: 86 10 c0 02 or %g3, %g2, %g3
201dd4c: c4 08 60 1b ldub [ %g1 + 0x1b ], %g2
201dd50: 86 10 c0 02 or %g3, %g2, %g3
201dd54: c4 08 60 1a ldub [ %g1 + 0x1a ], %g2
shared->ctime = rtems_rfs_inode_get_ctime (&shared->inode);
shared->fs = fs;
201dd58: f0 27 20 98 st %i0, [ %i4 + 0x98 ]
201dd5c: 85 28 a0 08 sll %g2, 8, %g2
201dd60: 82 10 c0 02 or %g3, %g2, %g1
201dd64: 7f ff be 3a call 200d64c <_Chain_Append>
201dd68: c2 27 20 94 st %g1, [ %i4 + 0x94 ]
rtems_chain_append (&fs->file_shares, &shared->link);
rtems_rfs_inode_unload (fs, &shared->inode, false);
201dd6c: 92 10 00 11 mov %l1, %o1
201dd70: 94 10 20 00 clr %o2
201dd74: 7f ff d0 3c call 2011e64 <rtems_rfs_inode_unload>
201dd78: 90 10 00 18 mov %i0, %o0
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_OPEN))
201dd7c: 90 10 20 08 mov 8, %o0
201dd80: 7f ff d6 94 call 20137d0 <rtems_rfs_trace>
201dd84: 92 10 20 00 clr %o1
201dd88: 80 8a 20 ff btst 0xff, %o0
201dd8c: 22 80 00 07 be,a 201dda8 <rtems_rfs_file_open+0x2c4> <== ALWAYS TAKEN
201dd90: f4 27 40 00 st %i2, [ %i5 ]
printf ("rtems-rfs: file-open: ino=%" PRId32 " share created\n", ino);
201dd94: 11 00 80 d1 sethi %hi(0x2034400), %o0 <== NOT EXECUTED
201dd98: 90 12 23 58 or %o0, 0x358, %o0 ! 2034758 <CSWTCH.2+0x1078><== NOT EXECUTED
201dd9c: 40 00 10 d7 call 20220f8 <printf> <== NOT EXECUTED
201dda0: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
}
handle->flags = oflag;
201dda4: f4 27 40 00 st %i2, [ %i5 ] <== NOT EXECUTED
handle->shared = shared;
201dda8: f8 27 60 1c st %i4, [ %i5 + 0x1c ]
*file = handle;
201ddac: fa 26 c0 00 st %i5, [ %i3 ]
return 0;
201ddb0: a0 10 20 00 clr %l0
}
201ddb4: b0 10 00 10 mov %l0, %i0
201ddb8: 81 c7 e0 08 ret
201ddbc: 81 e8 00 00 restore
0201d68c <rtems_rfs_file_seek>:
int
rtems_rfs_file_seek (rtems_rfs_file_handle* handle,
rtems_rfs_pos pos,
rtems_rfs_pos* new_pos)
{
201d68c: 9d e3 bf 98 save %sp, -104, %sp
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
201d690: 90 10 20 20 mov 0x20, %o0
201d694: 7f ff d8 4f call 20137d0 <rtems_rfs_trace>
201d698: 92 10 20 00 clr %o1
201d69c: 80 8a 20 ff btst 0xff, %o0
201d6a0: 22 80 00 08 be,a 201d6c0 <rtems_rfs_file_seek+0x34> <== ALWAYS TAKEN
201d6a4: d2 06 20 1c ld [ %i0 + 0x1c ], %o1
printf ("rtems-rfs: file-seek: new=%" PRIu64 "\n", pos);
201d6a8: 11 00 80 d1 sethi %hi(0x2034400), %o0 <== NOT EXECUTED
201d6ac: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
201d6b0: 90 12 22 58 or %o0, 0x258, %o0 <== NOT EXECUTED
201d6b4: 40 00 12 91 call 20220f8 <printf> <== NOT EXECUTED
201d6b8: 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),
201d6bc: d2 06 20 1c ld [ %i0 + 0x1c ], %o1 <== NOT EXECUTED
201d6c0: d0 02 60 98 ld [ %o1 + 0x98 ], %o0
201d6c4: 7f ff f3 b6 call 201a59c <rtems_rfs_block_get_size>
201d6c8: 92 02 60 84 add %o1, 0x84, %o1
201d6cc: 80 a6 40 08 cmp %i1, %o0
201d6d0: 18 80 00 23 bgu 201d75c <rtems_rfs_file_seek+0xd0> <== NEVER TAKEN
201d6d4: 01 00 00 00 nop
201d6d8: 32 80 00 06 bne,a 201d6f0 <rtems_rfs_file_seek+0x64> <== NEVER TAKEN
201d6dc: c2 06 20 1c ld [ %i0 + 0x1c ], %g1 <== NOT EXECUTED
201d6e0: 80 a6 80 09 cmp %i2, %o1
201d6e4: 18 80 00 1e bgu 201d75c <rtems_rfs_file_seek+0xd0>
201d6e8: 01 00 00 00 nop
handle->shared))
{
rtems_rfs_file_set_bpos (handle, pos);
201d6ec: c2 06 20 1c ld [ %i0 + 0x1c ], %g1
201d6f0: b8 06 20 10 add %i0, 0x10, %i4
201d6f4: d0 00 60 98 ld [ %g1 + 0x98 ], %o0
201d6f8: 92 10 00 19 mov %i1, %o1
201d6fc: 94 10 00 1a mov %i2, %o2
201d700: 7f ff f3 77 call 201a4dc <rtems_rfs_block_get_bpos>
201d704: 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))
201d708: c2 06 20 0c ld [ %i0 + 0xc ], %g1
201d70c: 80 a0 60 00 cmp %g1, 0
201d710: 02 80 00 18 be 201d770 <rtems_rfs_file_seek+0xe4>
201d714: 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),
201d718: d2 06 20 1c ld [ %i0 + 0x1c ], %o1
201d71c: d0 02 60 98 ld [ %o1 + 0x98 ], %o0
201d720: 96 07 bf fc add %fp, -4, %o3
201d724: 7f ff f4 89 call 201a948 <rtems_rfs_block_map_find>
201d728: 92 02 60 34 add %o1, 0x34, %o1
rtems_rfs_file_map (handle),
rtems_rfs_file_bpos (handle),
&block);
if (rc > 0)
201d72c: 80 a2 20 00 cmp %o0, 0
201d730: 14 80 00 13 bg 201d77c <rtems_rfs_file_seek+0xf0> <== NEVER TAKEN
201d734: c2 07 bf fc ld [ %fp + -4 ], %g1
return rc;
if (rtems_rfs_buffer_bnum (&handle->buffer) != block)
201d738: c4 06 20 08 ld [ %i0 + 8 ], %g2
201d73c: 80 a0 80 01 cmp %g2, %g1
201d740: 02 80 00 0c be 201d770 <rtems_rfs_file_seek+0xe4> <== ALWAYS TAKEN
201d744: 92 06 20 04 add %i0, 4, %o1
{
rc = rtems_rfs_buffer_handle_release (rtems_rfs_file_fs (handle),
201d748: c2 06 20 1c ld [ %i0 + 0x1c ], %g1 <== NOT EXECUTED
201d74c: 7f ff f7 23 call 201b3d8 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
201d750: 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)
201d754: 10 80 00 05 b 201d768 <rtems_rfs_file_seek+0xdc> <== NOT EXECUTED
201d758: 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);
201d75c: 7f ff ff c0 call 201d65c <rtems_rfs_file_io_release>
201d760: 90 10 00 18 mov %i0, %o0
if (rc > 0)
201d764: 80 a2 20 00 cmp %o0, 0
201d768: 14 80 00 05 bg 201d77c <rtems_rfs_file_seek+0xf0> <== NEVER TAKEN
201d76c: 01 00 00 00 nop
return rc;
}
*new_pos = pos;
201d770: f2 26 c0 00 st %i1, [ %i3 ]
201d774: f4 26 e0 04 st %i2, [ %i3 + 4 ]
return 0;
201d778: 90 10 20 00 clr %o0
}
201d77c: 81 c7 e0 08 ret
201d780: 91 e8 00 08 restore %g0, %o0, %o0
0201d784 <rtems_rfs_file_set_size>:
int
rtems_rfs_file_set_size (rtems_rfs_file_handle* handle,
rtems_rfs_pos new_size)
{
201d784: 9d e3 bf 90 save %sp, -112, %sp
201d788: ba 10 00 1a mov %i2, %i5
rtems_rfs_block_map* map = rtems_rfs_file_map (handle);
201d78c: f4 06 20 1c ld [ %i0 + 0x1c ], %i2
}
int
rtems_rfs_file_set_size (rtems_rfs_file_handle* handle,
rtems_rfs_pos new_size)
{
201d790: 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))
201d794: 90 10 20 20 mov 0x20, %o0
201d798: 92 10 20 00 clr %o1
201d79c: 7f ff d8 0d call 20137d0 <rtems_rfs_trace>
201d7a0: b8 10 00 19 mov %i1, %i4
201d7a4: 80 8a 20 ff btst 0xff, %o0
201d7a8: 02 80 00 07 be 201d7c4 <rtems_rfs_file_set_size+0x40> <== ALWAYS TAKEN
201d7ac: b0 06 a0 34 add %i2, 0x34, %i0
printf ("rtems-rfs: file-set-size: size=%" PRIu64 "\n", new_size);
201d7b0: 11 00 80 d1 sethi %hi(0x2034400), %o0 <== NOT EXECUTED
201d7b4: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
201d7b8: 90 12 22 78 or %o0, 0x278, %o0 <== NOT EXECUTED
201d7bc: 40 00 12 4f call 20220f8 <printf> <== NOT EXECUTED
201d7c0: 94 10 00 1d mov %i5, %o2 <== NOT EXECUTED
size = rtems_rfs_file_size (handle);
201d7c4: d2 06 e0 1c ld [ %i3 + 0x1c ], %o1
201d7c8: d0 02 60 98 ld [ %o1 + 0x98 ], %o0
201d7cc: 7f ff f3 74 call 201a59c <rtems_rfs_block_get_size>
201d7d0: 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)
201d7d4: 80 a2 00 1c cmp %o0, %i4
201d7d8: 12 80 00 07 bne 201d7f4 <rtems_rfs_file_set_size+0x70> <== NEVER TAKEN
201d7dc: 80 97 00 1d orcc %i4, %i5, %g0
201d7e0: 80 a2 40 1d cmp %o1, %i5
201d7e4: 12 80 00 04 bne 201d7f4 <rtems_rfs_file_set_size+0x70>
201d7e8: 80 97 00 1d orcc %i4, %i5, %g0
if (rtems_rfs_file_update_mtime (handle))
handle->shared->mtime = time (NULL);
}
return 0;
201d7ec: 10 80 00 ad b 201daa0 <rtems_rfs_file_set_size+0x31c>
201d7f0: 90 10 20 00 clr %o0
if (size != new_size)
{
/*
* Short cut for the common truncate on open call.
*/
if (new_size == 0)
201d7f4: 12 80 00 0a bne 201d81c <rtems_rfs_file_set_size+0x98>
201d7f8: f2 06 e0 1c ld [ %i3 + 0x1c ], %i1
{
rc = rtems_rfs_block_map_free_all (rtems_rfs_file_fs (handle), map);
201d7fc: d0 06 60 98 ld [ %i1 + 0x98 ], %o0
201d800: 7f ff f6 92 call 201b248 <rtems_rfs_block_map_free_all>
201d804: 92 10 00 18 mov %i0, %o1
if (rc > 0)
201d808: 80 a2 20 00 cmp %o0, 0
201d80c: 14 80 00 a6 bg 201daa4 <rtems_rfs_file_set_size+0x320> <== NEVER TAKEN
201d810: 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);
201d814: 10 80 00 97 b 201da70 <rtems_rfs_file_set_size+0x2ec>
201d818: fa 06 e0 1c ld [ %i3 + 0x1c ], %i5
if (rc > 0)
return rc;
}
else
{
if (size < new_size)
201d81c: 80 a7 00 08 cmp %i4, %o0
201d820: 38 80 00 09 bgu,a 201d844 <rtems_rfs_file_set_size+0xc0> <== NEVER TAKEN
201d824: c2 06 60 98 ld [ %i1 + 0x98 ], %g1 <== NOT EXECUTED
201d828: 80 a7 00 08 cmp %i4, %o0
201d82c: 32 80 00 58 bne,a 201d98c <rtems_rfs_file_set_size+0x208><== NEVER TAKEN
201d830: e0 06 60 98 ld [ %i1 + 0x98 ], %l0 <== NOT EXECUTED
201d834: 80 a7 40 09 cmp %i5, %o1
201d838: 28 80 00 55 bleu,a 201d98c <rtems_rfs_file_set_size+0x208>
201d83c: 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));
201d840: c2 06 60 98 ld [ %i1 + 0x98 ], %g1
*/
rtems_rfs_pos count;
uint32_t length;
bool read_block;
count = new_size - size;
201d844: ba a7 40 09 subcc %i5, %o1, %i5
length = rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
201d848: f2 00 60 08 ld [ %g1 + 8 ], %i1
*/
rtems_rfs_pos count;
uint32_t length;
bool read_block;
count = new_size - size;
201d84c: b8 67 00 08 subx %i4, %o0, %i4
length = rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
read_block = false;
201d850: a2 10 20 00 clr %l1
201d854: a0 10 20 01 mov 1, %l0
while (count)
201d858: 10 80 00 48 b 201d978 <rtems_rfs_file_set_size+0x1f4>
201d85c: 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);
201d860: c2 06 a0 3c ld [ %i2 + 0x3c ], %g1
201d864: c4 27 bf f8 st %g2, [ %fp + -8 ]
201d868: c2 27 bf f4 st %g1, [ %fp + -12 ]
201d86c: 80 a0 a0 00 cmp %g2, 0
201d870: 02 80 00 04 be 201d880 <rtems_rfs_file_set_size+0xfc>
201d874: c0 27 bf fc clr [ %fp + -4 ]
201d878: 82 00 7f ff add %g1, -1, %g1
201d87c: c2 27 bf f4 st %g1, [ %fp + -12 ]
rc = rtems_rfs_block_map_find (rtems_rfs_file_fs (handle),
201d880: c2 06 e0 1c ld [ %i3 + 0x1c ], %g1
201d884: 92 10 00 18 mov %i0, %o1
201d888: d0 00 60 98 ld [ %g1 + 0x98 ], %o0
201d88c: 94 07 bf f4 add %fp, -12, %o2
201d890: 7f ff f4 2e call 201a948 <rtems_rfs_block_map_find>
201d894: 96 07 bf f0 add %fp, -16, %o3
map, &bpos, &block);
if (rc > 0)
201d898: 80 a2 20 00 cmp %o0, 0
201d89c: 14 80 00 0b bg 201d8c8 <rtems_rfs_file_set_size+0x144>
201d8a0: 80 a2 20 06 cmp %o0, 6
map, 1, &block);
if (rc > 0)
return rc;
}
if (count < (length - bpos.boff))
201d8a4: c2 07 bf f8 ld [ %fp + -8 ], %g1
201d8a8: 80 a7 20 00 cmp %i4, 0
201d8ac: 12 80 00 17 bne 201d908 <rtems_rfs_file_set_size+0x184> <== NEVER TAKEN
201d8b0: 84 26 40 01 sub %i1, %g1, %g2
201d8b4: 80 a0 80 1d cmp %g2, %i5
201d8b8: 38 80 00 10 bgu,a 201d8f8 <rtems_rfs_file_set_size+0x174>
201d8bc: 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;
201d8c0: 10 80 00 13 b 201d90c <rtems_rfs_file_set_size+0x188>
201d8c4: c0 26 a0 40 clr [ %i2 + 0x40 ]
if (rc > 0)
{
/*
* Have we reached the EOF ?
*/
if (rc != ENXIO)
201d8c8: 12 80 00 76 bne 201daa0 <rtems_rfs_file_set_size+0x31c> <== NEVER TAKEN
201d8cc: 92 10 00 18 mov %i0, %o1
return rc;
rc = rtems_rfs_block_map_grow (rtems_rfs_file_fs (handle),
201d8d0: c2 06 e0 1c ld [ %i3 + 0x1c ], %g1
201d8d4: d0 00 60 98 ld [ %g1 + 0x98 ], %o0
201d8d8: 94 10 20 01 mov 1, %o2
201d8dc: 7f ff f4 a1 call 201ab60 <rtems_rfs_block_map_grow>
201d8e0: 96 07 bf f0 add %fp, -16, %o3
map, 1, &block);
if (rc > 0)
201d8e4: 80 a2 20 00 cmp %o0, 0
201d8e8: 04 bf ff f0 ble 201d8a8 <rtems_rfs_file_set_size+0x124> <== ALWAYS TAKEN
201d8ec: c2 07 bf f8 ld [ %fp + -8 ], %g1
if (rtems_rfs_file_update_mtime (handle))
handle->shared->mtime = time (NULL);
}
return 0;
}
201d8f0: 81 c7 e0 08 ret <== NOT EXECUTED
201d8f4: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED
map->dirty = true;
201d8f8: 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;
201d8fc: f2 26 a0 40 st %i1, [ %i2 + 0x40 ]
}
if (count < (length - bpos.boff))
{
length = count + bpos.boff;
read_block = true;
201d900: 10 80 00 04 b 201d910 <rtems_rfs_file_set_size+0x18c>
201d904: a2 10 20 01 mov 1, %l1
201d908: c0 26 a0 40 clr [ %i2 + 0x40 ] <== NOT EXECUTED
map->dirty = true;
201d90c: 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),
201d910: c2 06 e0 1c ld [ %i3 + 0x1c ], %g1
201d914: d4 07 bf f0 ld [ %fp + -16 ], %o2
201d918: d0 00 60 98 ld [ %g1 + 0x98 ], %o0
201d91c: 92 10 00 12 mov %l2, %o1
201d920: 7f ff f7 22 call 201b5a8 <rtems_rfs_buffer_handle_request>
201d924: 96 0c 60 01 and %l1, 1, %o3
rtems_rfs_file_buffer (handle),
block, read_block);
if (rc > 0)
201d928: 80 a2 20 00 cmp %o0, 0
201d92c: 14 80 00 5d bg 201daa0 <rtems_rfs_file_set_size+0x31c> <== NEVER TAKEN
201d930: d4 07 bf f8 ld [ %fp + -8 ], %o2
return rc;
dst = rtems_rfs_buffer_data (&handle->buffer);
201d934: c2 06 e0 0c ld [ %i3 + 0xc ], %g1
memset (dst + bpos.boff, 0, length - bpos.boff);
201d938: d0 00 60 1c ld [ %g1 + 0x1c ], %o0
201d93c: 92 10 20 00 clr %o1
201d940: 90 02 00 0a add %o0, %o2, %o0
201d944: 40 00 11 6f call 2021f00 <memset>
201d948: 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),
201d94c: 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));
201d950: e0 2e e0 04 stb %l0, [ %i3 + 4 ]
rc = rtems_rfs_buffer_handle_release (rtems_rfs_file_fs (handle),
201d954: d0 00 60 98 ld [ %g1 + 0x98 ], %o0
201d958: 7f ff f6 a0 call 201b3d8 <rtems_rfs_buffer_handle_release>
201d95c: 92 10 00 12 mov %l2, %o1
rtems_rfs_file_buffer (handle));
if (rc > 0)
201d960: 80 a2 20 00 cmp %o0, 0
201d964: 14 80 00 4f bg 201daa0 <rtems_rfs_file_set_size+0x31c> <== NEVER TAKEN
201d968: c2 07 bf f8 ld [ %fp + -8 ], %g1
return rc;
count -= length - bpos.boff;
201d96c: 82 26 40 01 sub %i1, %g1, %g1
201d970: ba a7 40 01 subcc %i5, %g1, %i5
201d974: 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)
201d978: 80 97 00 1d orcc %i4, %i5, %g0
201d97c: 32 bf ff b9 bne,a 201d860 <rtems_rfs_file_set_size+0xdc>
201d980: 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);
201d984: 10 80 00 3b b 201da70 <rtems_rfs_file_set_size+0x2ec>
201d988: 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) /
201d98c: 92 87 7f ff addcc %i5, -1, %o1
201d990: e2 04 20 08 ld [ %l0 + 8 ], %l1
201d994: 90 47 3f ff addx %i4, -1, %o0
201d998: 94 10 20 00 clr %o2
201d99c: 40 00 45 44 call 202eeac <__udivdi3>
201d9a0: 96 10 00 11 mov %l1, %o3
* Shrink
*/
rtems_rfs_block_no blocks;
uint32_t offset;
blocks =
201d9a4: c2 06 a0 3c ld [ %i2 + 0x3c ], %g1
201d9a8: 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));
201d9ac: 90 10 00 1c mov %i4, %o0
* Shrink
*/
rtems_rfs_block_no blocks;
uint32_t offset;
blocks =
201d9b0: 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));
201d9b4: 94 10 20 00 clr %o2
201d9b8: 92 10 00 1d mov %i5, %o1
201d9bc: 40 00 46 10 call 202f1fc <__umoddi3>
201d9c0: 96 10 00 11 mov %l1, %o3
if (blocks)
201d9c4: 80 a6 20 00 cmp %i0, 0
201d9c8: 12 80 00 0b bne 201d9f4 <rtems_rfs_file_set_size+0x270>
201d9cc: 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),
201d9d0: c4 06 e0 10 ld [ %i3 + 0x10 ], %g2
201d9d4: 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;
201d9d8: fa 26 a0 40 st %i5, [ %i2 + 0x40 ]
map->dirty = true;
201d9dc: c2 2e a0 34 stb %g1, [ %i2 + 0x34 ]
201d9e0: 80 a0 a0 00 cmp %g2, 0
201d9e4: 12 80 00 0d bne 201da18 <rtems_rfs_file_set_size+0x294>
201d9e8: c2 06 a0 3c ld [ %i2 + 0x3c ], %g1
201d9ec: 10 80 00 0f b 201da28 <rtems_rfs_file_set_size+0x2a4>
201d9f0: 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),
201d9f4: 90 10 00 10 mov %l0, %o0
201d9f8: 92 06 60 34 add %i1, 0x34, %o1
201d9fc: 7f ff f5 49 call 201af20 <rtems_rfs_block_map_shrink>
201da00: 94 10 00 18 mov %i0, %o2
rtems_rfs_file_map (handle),
blocks);
if (rc > 0)
201da04: 80 a2 20 00 cmp %o0, 0
201da08: 34 80 00 27 bg,a 201daa4 <rtems_rfs_file_set_size+0x320> <== NEVER TAKEN
201da0c: 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),
201da10: 10 bf ff f1 b 201d9d4 <rtems_rfs_file_set_size+0x250>
201da14: c4 06 e0 10 ld [ %i3 + 0x10 ], %g2
201da18: 80 a0 60 00 cmp %g1, 0
201da1c: 22 80 00 0e be,a 201da54 <rtems_rfs_file_set_size+0x2d0> <== NEVER TAKEN
201da20: c2 26 e0 10 st %g1, [ %i3 + 0x10 ] <== NOT EXECUTED
201da24: 80 a0 80 01 cmp %g2, %g1
201da28: 3a 80 00 0b bcc,a 201da54 <rtems_rfs_file_set_size+0x2d0><== NEVER TAKEN
201da2c: c2 26 e0 10 st %g1, [ %i3 + 0x10 ] <== NOT EXECUTED
201da30: 86 00 7f ff add %g1, -1, %g3
201da34: 80 a0 80 03 cmp %g2, %g3
201da38: 32 80 00 0e bne,a 201da70 <rtems_rfs_file_set_size+0x2ec><== NEVER TAKEN
201da3c: fa 06 e0 1c ld [ %i3 + 0x1c ], %i5 <== NOT EXECUTED
201da40: c4 06 e0 14 ld [ %i3 + 0x14 ], %g2
201da44: 80 a0 80 1d cmp %g2, %i5
201da48: 28 80 00 0a bleu,a 201da70 <rtems_rfs_file_set_size+0x2ec>
201da4c: 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),
201da50: c2 26 e0 10 st %g1, [ %i3 + 0x10 ]
201da54: fa 26 e0 14 st %i5, [ %i3 + 0x14 ]
201da58: 80 a7 60 00 cmp %i5, 0
201da5c: 02 80 00 04 be 201da6c <rtems_rfs_file_set_size+0x2e8> <== NEVER TAKEN
201da60: c0 26 e0 18 clr [ %i3 + 0x18 ]
201da64: 82 00 7f ff add %g1, -1, %g1
201da68: c2 26 e0 10 st %g1, [ %i3 + 0x10 ]
rtems_rfs_file_bpos (handle));
}
}
handle->shared->size.count = rtems_rfs_block_map_count (map);
201da6c: fa 06 e0 1c ld [ %i3 + 0x1c ], %i5
201da70: c2 06 a0 3c ld [ %i2 + 0x3c ], %g1
201da74: c2 27 60 84 st %g1, [ %i5 + 0x84 ]
handle->shared->size.offset = rtems_rfs_block_map_size_offset (map);
201da78: c2 06 a0 40 ld [ %i2 + 0x40 ], %g1
201da7c: c2 27 60 88 st %g1, [ %i5 + 0x88 ]
if (rtems_rfs_file_update_mtime (handle))
201da80: c2 06 c0 00 ld [ %i3 ], %g1
201da84: 80 88 60 02 btst 2, %g1
201da88: 12 80 00 06 bne 201daa0 <rtems_rfs_file_set_size+0x31c> <== NEVER TAKEN
201da8c: 90 10 20 00 clr %o0
handle->shared->mtime = time (NULL);
201da90: 40 00 21 99 call 20260f4 <time>
201da94: 90 10 20 00 clr %o0
201da98: d0 27 60 90 st %o0, [ %i5 + 0x90 ]
}
return 0;
201da9c: 90 10 20 00 clr %o0
}
201daa0: b0 10 00 08 mov %o0, %i0
201daa4: 81 c7 e0 08 ret
201daa8: 81 e8 00 00 restore
02010898 <rtems_rfs_format>:
return rc;
}
int
rtems_rfs_format (const char* name, const rtems_rfs_format_config* config)
{
2010898: 9d e3 be c0 save %sp, -320, %sp
rtems_rfs_file_system fs;
int group;
int rc;
if (config->verbose)
201089c: c2 0e 60 15 ldub [ %i1 + 0x15 ], %g1
20108a0: 80 a0 60 00 cmp %g1, 0
20108a4: 22 80 00 07 be,a 20108c0 <rtems_rfs_format+0x28> <== ALWAYS TAKEN
20108a8: 92 10 20 00 clr %o1
printf ("rtems-rfs: format: %s\n", name);
20108ac: 11 00 80 c8 sethi %hi(0x2032000), %o0 <== NOT EXECUTED
20108b0: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
20108b4: 40 00 46 11 call 20220f8 <printf> <== NOT EXECUTED
20108b8: 90 12 22 48 or %o0, 0x248, %o0 <== NOT EXECUTED
memset (&fs, 0, sizeof (rtems_rfs_file_system));
20108bc: 92 10 20 00 clr %o1 <== NOT EXECUTED
20108c0: 94 10 20 84 mov 0x84, %o2
20108c4: 40 00 45 8f call 2021f00 <memset>
20108c8: 90 07 bf 7c add %fp, -132, %o0
)
{
Chain_Node *head = _Chain_Head( the_chain );
Chain_Node *tail = _Chain_Tail( the_chain );
head->next = tail;
20108cc: 82 07 bf c4 add %fp, -60, %g1
20108d0: c2 27 bf c0 st %g1, [ %fp + -64 ]
head->previous = NULL;
tail->previous = head;
20108d4: 82 07 bf c0 add %fp, -64, %g1
20108d8: 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;
20108dc: 82 07 bf d4 add %fp, -44, %g1
20108e0: c2 27 bf d0 st %g1, [ %fp + -48 ]
head->previous = NULL;
tail->previous = head;
20108e4: 82 07 bf d0 add %fp, -48, %g1
20108e8: 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;
20108ec: 82 07 bf e4 add %fp, -28, %g1
20108f0: c2 27 bf e0 st %g1, [ %fp + -32 ]
head->previous = NULL;
tail->previous = head;
20108f4: 82 07 bf e0 add %fp, -32, %g1
20108f8: 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;
20108fc: 82 07 bf f4 add %fp, -12, %g1
2010900: c2 27 bf f0 st %g1, [ %fp + -16 ]
head->previous = NULL;
tail->previous = head;
2010904: 82 07 bf f0 add %fp, -16, %g1
2010908: 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;
201090c: 82 10 20 05 mov 5, %g1
2010910: 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;
2010914: 82 10 20 02 mov 2, %g1
/*
* Open the buffer interface.
*/
rc = rtems_rfs_buffer_open (name, &fs);
2010918: 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;
201091c: c2 27 bf 7c st %g1, [ %fp + -132 ]
/*
* Open the buffer interface.
*/
rc = rtems_rfs_buffer_open (name, &fs);
2010920: 40 00 2b c8 call 201b840 <rtems_rfs_buffer_open>
2010924: 92 07 bf 7c add %fp, -132, %o1
if (rc > 0)
2010928: ba 92 20 00 orcc %o0, 0, %i5
201092c: 04 80 00 08 ble 201094c <rtems_rfs_format+0xb4> <== ALWAYS TAKEN
2010930: c2 07 bf 8c ld [ %fp + -116 ], %g1
{
printf ("rtems-rfs: format: buffer open failed: %d: %s\n",
2010934: 40 00 4a 60 call 20232b4 <strerror> <== NOT EXECUTED
2010938: 01 00 00 00 nop <== NOT EXECUTED
201093c: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
2010940: 11 00 80 c8 sethi %hi(0x2032000), %o0 <== NOT EXECUTED
2010944: 10 80 03 0e b 201157c <rtems_rfs_format+0xce4> <== NOT EXECUTED
2010948: 90 12 22 60 or %o0, 0x260, %o0 ! 2032260 <_CPU_Trap_slot_template+0x28><== NOT EXECUTED
}
/*
* Check the media.
*/
if (rtems_rfs_fs_media_block_size (&fs) == 0)
201094c: c2 00 60 20 ld [ %g1 + 0x20 ], %g1
2010950: 80 a0 60 00 cmp %g1, 0
2010954: 32 80 00 08 bne,a 2010974 <rtems_rfs_format+0xdc> <== ALWAYS TAKEN
2010958: c2 06 40 00 ld [ %i1 ], %g1
{
printf ("rtems-rfs: media block is invalid: %" PRIu32 "\n",
201095c: 11 00 80 c8 sethi %hi(0x2032000), %o0 <== NOT EXECUTED
2010960: 92 10 20 00 clr %o1 <== NOT EXECUTED
2010964: 40 00 45 e5 call 20220f8 <printf> <== NOT EXECUTED
2010968: 90 12 22 90 or %o0, 0x290, %o0 <== NOT EXECUTED
/*
* Check the configuration data.
*/
if (!rtems_rfs_check_config (&fs, config))
return -1;
201096c: 81 c7 e0 08 ret <== NOT EXECUTED
2010970: 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)
2010974: 80 a0 60 00 cmp %g1, 0
2010978: 12 80 00 2a bne 2010a20 <rtems_rfs_format+0x188>
201097c: c2 27 bf 84 st %g1, [ %fp + -124 ]
{
uint64_t total_size = rtems_rfs_fs_media_size (fs);
2010980: 40 00 35 23 call 201de0c <rtems_rfs_fs_media_size>
2010984: 90 07 bf 7c add %fp, -132, %o0
if (total_size >= GIGS (1))
2010988: 80 a2 20 00 cmp %o0, 0
201098c: 12 80 00 08 bne 20109ac <rtems_rfs_format+0x114> <== NEVER TAKEN
2010990: 3b 00 04 00 sethi %hi(0x100000), %i5
2010994: 03 00 03 ff sethi %hi(0xffc00), %g1
2010998: 82 10 63 ff or %g1, 0x3ff, %g1 ! fffff <PROM_START+0xfffff>
201099c: 80 a2 40 01 cmp %o1, %g1
20109a0: 08 80 00 16 bleu 20109f8 <rtems_rfs_format+0x160> <== ALWAYS TAKEN
20109a4: c2 07 bf 84 ld [ %fp + -124 ], %g1
{
uint32_t gigs = (total_size + GIGS (1)) / GIGS (1);
20109a8: 3b 00 04 00 sethi %hi(0x100000), %i5 <== NOT EXECUTED
20109ac: 86 82 40 1d addcc %o1, %i5, %g3 <== NOT EXECUTED
20109b0: 83 30 e0 14 srl %g3, 0x14, %g1 <== NOT EXECUTED
20109b4: b8 10 20 00 clr %i4 <== NOT EXECUTED
int b;
for (b = 31; b > 0; b--)
if ((gigs & (1 << b)) != 0)
20109b8: 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);
20109bc: 84 42 00 1c addx %o0, %i4, %g2 <== NOT EXECUTED
20109c0: 85 28 a0 0c sll %g2, 0xc, %g2 <== NOT EXECUTED
20109c4: 84 10 80 01 or %g2, %g1, %g2 <== NOT EXECUTED
int b;
for (b = 31; b > 0; b--)
20109c8: 82 10 20 1f mov 0x1f, %g1 <== NOT EXECUTED
if ((gigs & (1 << b)) != 0)
20109cc: 89 28 c0 01 sll %g3, %g1, %g4 <== NOT EXECUTED
20109d0: 80 89 00 02 btst %g4, %g2 <== NOT EXECUTED
20109d4: 32 80 00 06 bne,a 20109ec <rtems_rfs_format+0x154> <== NOT EXECUTED
20109d8: 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--)
20109dc: 82 80 7f ff addcc %g1, -1, %g1 <== NOT EXECUTED
20109e0: 12 bf ff fc bne 20109d0 <rtems_rfs_format+0x138> <== NOT EXECUTED
20109e4: 89 28 c0 01 sll %g3, %g1, %g4 <== NOT EXECUTED
if ((gigs & (1 << b)) != 0)
break;
fs->block_size = 1 << b;
20109e8: 84 10 20 01 mov 1, %g2 <== NOT EXECUTED
20109ec: 83 28 80 01 sll %g2, %g1, %g1 <== NOT EXECUTED
20109f0: c2 27 bf 84 st %g1, [ %fp + -124 ] <== NOT EXECUTED
}
if (fs->block_size < 512)
20109f4: c2 07 bf 84 ld [ %fp + -124 ], %g1 <== NOT EXECUTED
20109f8: 80 a0 61 ff cmp %g1, 0x1ff
20109fc: 18 80 00 05 bgu 2010a10 <rtems_rfs_format+0x178> <== NEVER TAKEN
2010a00: c4 07 bf 84 ld [ %fp + -124 ], %g2
fs->block_size = 512;
2010a04: 82 10 22 00 mov 0x200, %g1
2010a08: c2 27 bf 84 st %g1, [ %fp + -124 ]
if (fs->block_size > (4 * 1024))
2010a0c: c4 07 bf 84 ld [ %fp + -124 ], %g2
2010a10: 03 00 00 04 sethi %hi(0x1000), %g1
2010a14: 80 a0 80 01 cmp %g2, %g1
2010a18: 38 80 00 02 bgu,a 2010a20 <rtems_rfs_format+0x188> <== NEVER TAKEN
2010a1c: 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)
2010a20: c2 07 bf 8c ld [ %fp + -116 ], %g1
2010a24: fa 07 bf 84 ld [ %fp + -124 ], %i5
2010a28: f8 00 60 20 ld [ %g1 + 0x20 ], %i4
2010a2c: 90 10 00 1d mov %i5, %o0
2010a30: 40 00 76 50 call 202e370 <.urem>
2010a34: 92 10 00 1c mov %i4, %o1
2010a38: 80 a2 20 00 cmp %o0, 0
2010a3c: 22 80 00 07 be,a 2010a58 <rtems_rfs_format+0x1c0> <== ALWAYS TAKEN
2010a40: c2 06 60 04 ld [ %i1 + 4 ], %g1
{
printf ("block size (%zd) is not a multiple of media block size (%" PRId32 ")\n",
2010a44: 11 00 80 c8 sethi %hi(0x2032000), %o0 <== NOT EXECUTED
2010a48: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
2010a4c: 90 12 22 b8 or %o0, 0x2b8, %o0 <== NOT EXECUTED
2010a50: 10 80 02 cc b 2011580 <rtems_rfs_format+0xce8> <== NOT EXECUTED
2010a54: 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)
2010a58: 80 a0 60 00 cmp %g1, 0
2010a5c: 02 80 00 04 be 2010a6c <rtems_rfs_format+0x1d4> <== ALWAYS TAKEN
2010a60: 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;
2010a64: 10 80 00 03 b 2010a70 <rtems_rfs_format+0x1d8> <== NOT EXECUTED
2010a68: 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);
2010a6c: fa 27 bf a4 st %i5, [ %fp + -92 ]
}
if (fs->group_blocks > rtems_rfs_bitmap_numof_bits (fs->block_size))
2010a70: c2 07 bf a4 ld [ %fp + -92 ], %g1
2010a74: 80 a0 40 1d cmp %g1, %i5
2010a78: 08 80 00 04 bleu 2010a88 <rtems_rfs_format+0x1f0> <== ALWAYS TAKEN
2010a7c: 11 00 80 c8 sethi %hi(0x2032000), %o0
{
printf ("group block count is higher than bits in block\n");
2010a80: 10 80 01 2f b 2010f3c <rtems_rfs_format+0x6a4> <== NOT EXECUTED
2010a84: 90 12 22 f8 or %o0, 0x2f8, %o0 ! 20322f8 <_CPU_Trap_slot_template+0xc0><== NOT EXECUTED
return false;
}
fs->blocks = rtems_rfs_fs_media_size (fs) / fs->block_size;
2010a88: 40 00 34 e1 call 201de0c <rtems_rfs_fs_media_size>
2010a8c: 90 07 bf 7c add %fp, -132, %o0
2010a90: fa 07 bf 84 ld [ %fp + -124 ], %i5
2010a94: 94 10 20 00 clr %o2
2010a98: 40 00 79 05 call 202eeac <__udivdi3>
2010a9c: 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));
2010aa0: 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;
2010aa4: 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),
2010aa8: 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;
2010aac: 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),
2010ab0: 7f ff ff 6f call 201086c <rtems_rfs_rup_quotient>
2010ab4: 92 10 00 1c mov %i4, %o1
rtems_rfs_bits_per_block (fs));
fs->group_inodes = config->group_inodes;
2010ab8: 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),
2010abc: d0 27 bf a0 st %o0, [ %fp + -96 ]
rtems_rfs_bits_per_block (fs));
fs->group_inodes = config->group_inodes;
2010ac0: c2 27 bf a8 st %g1, [ %fp + -88 ]
if (!fs->group_inodes)
2010ac4: 80 a0 60 00 cmp %g1, 0
2010ac8: 12 80 00 14 bne 2010b18 <rtems_rfs_format+0x280> <== NEVER TAKEN
2010acc: 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)
2010ad0: d0 06 60 0c ld [ %i1 + 0xc ], %o0
2010ad4: 80 a2 20 00 cmp %o0, 0
2010ad8: 22 80 00 02 be,a 2010ae0 <rtems_rfs_format+0x248> <== ALWAYS TAKEN
2010adc: 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;
2010ae0: 7f ff c6 ad call 2002594 <.umul>
2010ae4: 92 06 ff ff add %i3, -1, %o1
2010ae8: 7f ff c6 e5 call 200267c <.udiv>
2010aec: 92 10 20 64 mov 0x64, %o1
blocks = rtems_rfs_rup_quotient (blocks, fs->group_count);
2010af0: 7f ff ff 5f call 201086c <rtems_rfs_rup_quotient>
2010af4: 92 10 00 1a mov %i2, %o1
return blocks * (rtems_rfs_fs_block_size (fs) / RTEMS_RFS_INODE_SIZE);
2010af8: 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);
2010afc: b6 10 00 08 mov %o0, %i3
return blocks * (rtems_rfs_fs_block_size (fs) / RTEMS_RFS_INODE_SIZE);
2010b00: 7f ff c6 df call 200267c <.udiv>
2010b04: 90 10 00 1d mov %i5, %o0
2010b08: 92 10 00 08 mov %o0, %o1
2010b0c: 7f ff c6 a2 call 2002594 <.umul>
2010b10: 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);
2010b14: 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;
2010b18: 90 10 00 1d mov %i5, %o0
2010b1c: 7f ff c6 d8 call 200267c <.udiv>
2010b20: 92 10 20 38 mov 0x38, %o1
2010b24: ba 10 00 08 mov %o0, %i5
2010b28: d0 27 bf ac st %o0, [ %fp + -84 ]
fs->group_inodes =
rtems_rfs_rup_quotient (fs->group_inodes,
2010b2c: d0 07 bf a8 ld [ %fp + -88 ], %o0
2010b30: 7f ff ff 4f call 201086c <rtems_rfs_rup_quotient>
2010b34: 92 10 00 1d mov %i5, %o1
fs->inodes_per_block) * fs->inodes_per_block;
2010b38: 7f ff c6 97 call 2002594 <.umul>
2010b3c: 92 10 00 1d mov %i5, %o1
if (fs->group_inodes > rtems_rfs_bitmap_numof_bits (fs->block_size))
2010b40: 80 a2 00 1c cmp %o0, %i4
2010b44: 38 80 00 03 bgu,a 2010b50 <rtems_rfs_format+0x2b8> <== NEVER TAKEN
2010b48: f8 27 bf a8 st %i4, [ %fp + -88 ] <== NOT EXECUTED
2010b4c: 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;
2010b50: c2 06 60 10 ld [ %i1 + 0x10 ], %g1
if (!fs->max_name_length)
2010b54: 80 a0 60 00 cmp %g1, 0
2010b58: 22 80 02 90 be,a 2011598 <rtems_rfs_format+0xd00> <== ALWAYS TAKEN
2010b5c: 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;
2010b60: 10 80 02 8f b 201159c <rtems_rfs_format+0xd04> <== NOT EXECUTED
2010b64: 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",
2010b68: 40 00 34 a9 call 201de0c <rtems_rfs_fs_media_size> <== NOT EXECUTED
2010b6c: 90 07 bf 7c add %fp, -132, %o0 <== NOT EXECUTED
2010b70: 84 10 00 08 mov %o0, %g2 <== NOT EXECUTED
2010b74: 86 10 00 09 mov %o1, %g3 <== NOT EXECUTED
2010b78: 11 00 80 c8 sethi %hi(0x2032000), %o0 <== NOT EXECUTED
2010b7c: 92 10 00 02 mov %g2, %o1 <== NOT EXECUTED
2010b80: 94 10 00 03 mov %g3, %o2 <== NOT EXECUTED
2010b84: 40 00 45 5d call 20220f8 <printf> <== NOT EXECUTED
2010b88: 90 12 23 28 or %o0, 0x328, %o0 <== NOT EXECUTED
rtems_rfs_fs_media_size (&fs));
printf ("rtems-rfs: format: media blocks = %" PRIu32 "\n",
2010b8c: c2 07 bf 8c ld [ %fp + -116 ], %g1 <== NOT EXECUTED
2010b90: 11 00 80 c8 sethi %hi(0x2032000), %o0 <== NOT EXECUTED
2010b94: d2 00 60 1c ld [ %g1 + 0x1c ], %o1 <== NOT EXECUTED
2010b98: 40 00 45 58 call 20220f8 <printf> <== NOT EXECUTED
2010b9c: 90 12 23 50 or %o0, 0x350, %o0 <== NOT EXECUTED
rtems_rfs_fs_media_blocks (&fs));
printf ("rtems-rfs: format: media block size = %" PRIu32 "\n",
2010ba0: c2 07 bf 8c ld [ %fp + -116 ], %g1 <== NOT EXECUTED
2010ba4: 11 00 80 c8 sethi %hi(0x2032000), %o0 <== NOT EXECUTED
2010ba8: d2 00 60 20 ld [ %g1 + 0x20 ], %o1 <== NOT EXECUTED
2010bac: 40 00 45 53 call 20220f8 <printf> <== NOT EXECUTED
2010bb0: 90 12 23 78 or %o0, 0x378, %o0 <== NOT EXECUTED
rtems_rfs_fs_media_block_size (&fs));
printf ("rtems-rfs: format: size = %" PRIu64 "\n",
2010bb4: 40 00 34 8d call 201dde8 <rtems_rfs_fs_size> <== NOT EXECUTED
2010bb8: 90 07 bf 7c add %fp, -132, %o0 <== NOT EXECUTED
2010bbc: 84 10 00 08 mov %o0, %g2 <== NOT EXECUTED
2010bc0: 86 10 00 09 mov %o1, %g3 <== NOT EXECUTED
2010bc4: 11 00 80 c8 sethi %hi(0x2032000), %o0 <== NOT EXECUTED
2010bc8: 92 10 00 02 mov %g2, %o1 <== NOT EXECUTED
2010bcc: 94 10 00 03 mov %g3, %o2 <== NOT EXECUTED
2010bd0: 40 00 45 4a call 20220f8 <printf> <== NOT EXECUTED
2010bd4: 90 12 23 a8 or %o0, 0x3a8, %o0 <== NOT EXECUTED
rtems_rfs_fs_size (&fs));
printf ("rtems-rfs: format: blocks = %zu\n",
2010bd8: d2 07 bf 80 ld [ %fp + -128 ], %o1 <== NOT EXECUTED
2010bdc: 11 00 80 c8 sethi %hi(0x2032000), %o0 <== NOT EXECUTED
2010be0: 40 00 45 46 call 20220f8 <printf> <== NOT EXECUTED
2010be4: 90 12 23 c8 or %o0, 0x3c8, %o0 ! 20323c8 <_CPU_Trap_slot_template+0x190><== NOT EXECUTED
rtems_rfs_fs_blocks (&fs));
printf ("rtems-rfs: format: block size = %zu\n",
2010be8: d2 07 bf 84 ld [ %fp + -124 ], %o1 <== NOT EXECUTED
2010bec: 11 00 80 c8 sethi %hi(0x2032000), %o0 <== NOT EXECUTED
2010bf0: 40 00 45 42 call 20220f8 <printf> <== NOT EXECUTED
2010bf4: 90 12 23 f0 or %o0, 0x3f0, %o0 ! 20323f0 <_CPU_Trap_slot_template+0x1b8><== NOT EXECUTED
rtems_rfs_fs_block_size (&fs));
printf ("rtems-rfs: format: bits per block = %u\n",
2010bf8: d2 07 bf 84 ld [ %fp + -124 ], %o1 <== NOT EXECUTED
2010bfc: 11 00 80 c9 sethi %hi(0x2032400), %o0 <== NOT EXECUTED
2010c00: 93 2a 60 03 sll %o1, 3, %o1 <== NOT EXECUTED
2010c04: 40 00 45 3d call 20220f8 <printf> <== NOT EXECUTED
2010c08: 90 12 20 18 or %o0, 0x18, %o0 <== NOT EXECUTED
rtems_rfs_bits_per_block (&fs));
printf ("rtems-rfs: format: inode size = %zu\n", RTEMS_RFS_INODE_SIZE);
2010c0c: 92 10 20 38 mov 0x38, %o1 <== NOT EXECUTED
2010c10: 11 00 80 c9 sethi %hi(0x2032400), %o0 <== NOT EXECUTED
2010c14: 40 00 45 39 call 20220f8 <printf> <== NOT EXECUTED
2010c18: 90 12 20 40 or %o0, 0x40, %o0 ! 2032440 <_CPU_Trap_slot_template+0x208><== NOT EXECUTED
printf ("rtems-rfs: format: inodes = %zu (%d.%d%%)\n",
2010c1c: d2 07 bf a0 ld [ %fp + -96 ], %o1 <== NOT EXECUTED
fs.group_inodes * fs.group_count,
2010c20: 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",
2010c24: 7f ff c6 5c call 2002594 <.umul> <== NOT EXECUTED
2010c28: 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));
2010c2c: 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",
2010c30: 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,
2010c34: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
2010c38: 91 2f 60 03 sll %i5, 3, %o0 <== NOT EXECUTED
2010c3c: bb 2f 60 06 sll %i5, 6, %i5 <== NOT EXECUTED
2010c40: 7f ff ff 0b call 201086c <rtems_rfs_rup_quotient> <== NOT EXECUTED
2010c44: 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))
2010c48: 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));
2010c4c: 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))
2010c50: 92 00 7f ff add %g1, -1, %o1 <== NOT EXECUTED
2010c54: 80 a7 00 09 cmp %i4, %o1 <== NOT EXECUTED
2010c58: 28 80 00 02 bleu,a 2010c60 <rtems_rfs_format+0x3c8> <== NOT EXECUTED
2010c5c: 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;
2010c60: 84 02 20 01 add %o0, 1, %g2 <== NOT EXECUTED
2010c64: 87 28 a0 02 sll %g2, 2, %g3 <== NOT EXECUTED
2010c68: 89 28 a0 07 sll %g2, 7, %g4 <== NOT EXECUTED
2010c6c: 86 21 00 03 sub %g4, %g3, %g3 <== NOT EXECUTED
2010c70: 90 00 c0 02 add %g3, %g2, %o0 <== NOT EXECUTED
2010c74: 7f ff c6 84 call 2002684 <.div> <== NOT EXECUTED
2010c78: 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",
2010c7c: 92 10 20 0a mov 0xa, %o1 <== NOT EXECUTED
2010c80: 7f ff c6 81 call 2002684 <.div> <== NOT EXECUTED
2010c84: b8 10 00 08 mov %o0, %i4 <== NOT EXECUTED
2010c88: 92 10 20 0a mov 0xa, %o1 <== NOT EXECUTED
2010c8c: ba 10 00 08 mov %o0, %i5 <== NOT EXECUTED
2010c90: 40 00 75 ba call 202e378 <.rem> <== NOT EXECUTED
2010c94: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
2010c98: 94 10 00 1d mov %i5, %o2 <== NOT EXECUTED
2010c9c: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
2010ca0: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
2010ca4: 11 00 80 c9 sethi %hi(0x2032400), %o0 <== NOT EXECUTED
2010ca8: 40 00 45 14 call 20220f8 <printf> <== NOT EXECUTED
2010cac: 90 12 20 68 or %o0, 0x68, %o0 ! 2032468 <_CPU_Trap_slot_template+0x230><== 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);
2010cb0: d2 07 bf a0 ld [ %fp + -96 ], %o1 <== NOT EXECUTED
2010cb4: 11 00 80 c9 sethi %hi(0x2032400), %o0 <== NOT EXECUTED
2010cb8: 40 00 45 10 call 20220f8 <printf> <== NOT EXECUTED
2010cbc: 90 12 20 98 or %o0, 0x98, %o0 ! 2032498 <_CPU_Trap_slot_template+0x260><== NOT EXECUTED
printf ("rtems-rfs: format: group blocks = %zu\n", fs.group_blocks);
2010cc0: d2 07 bf a4 ld [ %fp + -92 ], %o1 <== NOT EXECUTED
2010cc4: 11 00 80 c9 sethi %hi(0x2032400), %o0 <== NOT EXECUTED
2010cc8: 40 00 45 0c call 20220f8 <printf> <== NOT EXECUTED
2010ccc: 90 12 20 b8 or %o0, 0xb8, %o0 ! 20324b8 <_CPU_Trap_slot_template+0x280><== NOT EXECUTED
printf ("rtems-rfs: format: group inodes = %zu\n", fs.group_inodes);
2010cd0: d2 07 bf a8 ld [ %fp + -88 ], %o1 <== NOT EXECUTED
2010cd4: 11 00 80 c9 sethi %hi(0x2032400), %o0 <== NOT EXECUTED
2010cd8: 40 00 45 08 call 20220f8 <printf> <== NOT EXECUTED
2010cdc: 90 12 20 e0 or %o0, 0xe0, %o0 ! 20324e0 <_CPU_Trap_slot_template+0x2a8><== NOT EXECUTED
}
rc = rtems_rfs_buffer_setblksize (&fs, rtems_rfs_fs_block_size (&fs));
2010ce0: d2 07 bf 84 ld [ %fp + -124 ], %o1 <== NOT EXECUTED
2010ce4: 40 00 2b 77 call 201bac0 <rtems_rfs_buffer_setblksize>
2010ce8: 90 07 bf 7c add %fp, -132, %o0
if (rc > 0)
2010cec: ba 92 20 00 orcc %o0, 0, %i5
2010cf0: 24 80 00 08 ble,a 2010d10 <rtems_rfs_format+0x478> <== ALWAYS TAKEN
2010cf4: c0 2f bf 30 clrb [ %fp + -208 ]
{
printf ("rtems-rfs: format: setting block size failed: %d: %s\n",
2010cf8: 40 00 49 6f call 20232b4 <strerror> <== NOT EXECUTED
2010cfc: 01 00 00 00 nop <== NOT EXECUTED
2010d00: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
2010d04: 11 00 80 c9 sethi %hi(0x2032400), %o0 <== NOT EXECUTED
2010d08: 10 80 02 1d b 201157c <rtems_rfs_format+0xce4> <== NOT EXECUTED
2010d0c: 90 12 21 08 or %o0, 0x108, %o0 ! 2032508 <_CPU_Trap_slot_template+0x2d0><== 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;
2010d10: c0 27 bf 34 clr [ %fp + -204 ]
handle->buffer = NULL;
2010d14: 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);
2010d18: 90 07 bf 7c add %fp, -132, %o0
2010d1c: 92 07 bf 30 add %fp, -208, %o1
2010d20: 94 10 20 00 clr %o2
2010d24: 40 00 2a 21 call 201b5a8 <rtems_rfs_buffer_handle_request>
2010d28: 96 10 20 00 clr %o3
if (rc > 0)
2010d2c: ba 92 20 00 orcc %o0, 0, %i5
2010d30: 04 80 00 0a ble 2010d58 <rtems_rfs_format+0x4c0> <== ALWAYS TAKEN
2010d34: 92 07 bf 30 add %fp, -208, %o1
{
rtems_rfs_buffer_handle_close (fs, &handle);
2010d38: 7f ff fe c3 call 2010844 <rtems_rfs_buffer_handle_close> <== NOT EXECUTED
2010d3c: 90 07 bf 7c add %fp, -132, %o0 <== NOT EXECUTED
printf ("rtems-rfs: write-superblock: request failed: %d: %s\n",
2010d40: 40 00 49 5d call 20232b4 <strerror> <== NOT EXECUTED
2010d44: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
2010d48: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
2010d4c: 11 00 80 c9 sethi %hi(0x2032400), %o0 <== NOT EXECUTED
2010d50: 10 80 00 73 b 2010f1c <rtems_rfs_format+0x684> <== NOT EXECUTED
2010d54: 90 12 21 40 or %o0, 0x140, %o0 ! 2032540 <_CPU_Trap_slot_template+0x308><== NOT EXECUTED
rc, strerror (rc));
return false;
}
sb = rtems_rfs_buffer_data (&handle);
2010d58: 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));
2010d5c: 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);
2010d60: 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));
2010d64: 92 10 20 ff mov 0xff, %o1
2010d68: 40 00 44 66 call 2021f00 <memset>
2010d6c: 90 10 00 1d mov %i5, %o0
write_sb (RTEMS_RFS_SB_OFFSET_MAGIC, RTEMS_RFS_SB_MAGIC);
2010d70: 82 10 20 28 mov 0x28, %g1
2010d74: c2 2f 40 00 stb %g1, [ %i5 ]
2010d78: 82 10 20 09 mov 9, %g1
2010d7c: c2 2f 60 01 stb %g1, [ %i5 + 1 ]
2010d80: 82 10 20 20 mov 0x20, %g1
write_sb (RTEMS_RFS_SB_OFFSET_VERSION, RTEMS_RFS_VERSION);
2010d84: 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);
2010d88: c2 2f 60 02 stb %g1, [ %i5 + 2 ]
write_sb (RTEMS_RFS_SB_OFFSET_VERSION, RTEMS_RFS_VERSION);
2010d8c: c0 2f 60 05 clrb [ %i5 + 5 ]
2010d90: c0 2f 60 06 clrb [ %i5 + 6 ]
2010d94: 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);
2010d98: 84 10 20 01 mov 1, %g2
2010d9c: 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));
2010da0: 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);
2010da4: 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));
2010da8: 87 30 60 18 srl %g1, 0x18, %g3
2010dac: c6 2f 60 0c stb %g3, [ %i5 + 0xc ]
2010db0: 87 30 60 10 srl %g1, 0x10, %g3
2010db4: c2 2f 60 0f stb %g1, [ %i5 + 0xf ]
2010db8: c6 2f 60 0d stb %g3, [ %i5 + 0xd ]
2010dbc: 87 30 60 08 srl %g1, 8, %g3
write_sb (RTEMS_RFS_SB_OFFSET_BLOCK_SIZE, rtems_rfs_fs_block_size (fs));
2010dc0: 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));
2010dc4: c6 2f 60 0e stb %g3, [ %i5 + 0xe ]
write_sb (RTEMS_RFS_SB_OFFSET_BLOCK_SIZE, rtems_rfs_fs_block_size (fs));
2010dc8: c2 2f 60 08 stb %g1, [ %i5 + 8 ]
2010dcc: 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);
2010dd0: 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));
2010dd4: c2 2f 60 09 stb %g1, [ %i5 + 9 ]
2010dd8: c2 07 bf 84 ld [ %fp + -124 ], %g1
2010ddc: 83 30 60 08 srl %g1, 8, %g1
2010de0: c2 2f 60 0a stb %g1, [ %i5 + 0xa ]
2010de4: c2 07 bf 84 ld [ %fp + -124 ], %g1
2010de8: c2 2f 60 0b stb %g1, [ %i5 + 0xb ]
write_sb (RTEMS_RFS_SB_OFFSET_BAD_BLOCKS, fs->bad_blocks);
2010dec: c2 0f bf 94 ldub [ %fp + -108 ], %g1
2010df0: c2 2f 60 10 stb %g1, [ %i5 + 0x10 ]
2010df4: c2 17 bf 94 lduh [ %fp + -108 ], %g1
2010df8: c2 2f 60 11 stb %g1, [ %i5 + 0x11 ]
2010dfc: c2 07 bf 94 ld [ %fp + -108 ], %g1
2010e00: 83 30 60 08 srl %g1, 8, %g1
2010e04: c2 2f 60 12 stb %g1, [ %i5 + 0x12 ]
2010e08: c2 07 bf 94 ld [ %fp + -108 ], %g1
2010e0c: c2 2f 60 13 stb %g1, [ %i5 + 0x13 ]
write_sb (RTEMS_RFS_SB_OFFSET_MAX_NAME_LENGTH, fs->max_name_length);
2010e10: c2 0f bf 98 ldub [ %fp + -104 ], %g1
2010e14: c2 2f 60 14 stb %g1, [ %i5 + 0x14 ]
2010e18: c2 17 bf 98 lduh [ %fp + -104 ], %g1
2010e1c: c2 2f 60 15 stb %g1, [ %i5 + 0x15 ]
2010e20: c2 07 bf 98 ld [ %fp + -104 ], %g1
2010e24: 83 30 60 08 srl %g1, 8, %g1
2010e28: c2 2f 60 16 stb %g1, [ %i5 + 0x16 ]
2010e2c: c2 07 bf 98 ld [ %fp + -104 ], %g1
2010e30: c2 2f 60 17 stb %g1, [ %i5 + 0x17 ]
write_sb (RTEMS_RFS_SB_OFFSET_GROUPS, fs->group_count);
2010e34: c2 0f bf a0 ldub [ %fp + -96 ], %g1
2010e38: c2 2f 60 18 stb %g1, [ %i5 + 0x18 ]
2010e3c: c2 17 bf a0 lduh [ %fp + -96 ], %g1
2010e40: c2 2f 60 19 stb %g1, [ %i5 + 0x19 ]
2010e44: c2 07 bf a0 ld [ %fp + -96 ], %g1
2010e48: 83 30 60 08 srl %g1, 8, %g1
2010e4c: c2 2f 60 1a stb %g1, [ %i5 + 0x1a ]
2010e50: c2 07 bf a0 ld [ %fp + -96 ], %g1
2010e54: c2 2f 60 1b stb %g1, [ %i5 + 0x1b ]
write_sb (RTEMS_RFS_SB_OFFSET_GROUP_BLOCKS, fs->group_blocks);
2010e58: c2 0f bf a4 ldub [ %fp + -92 ], %g1
2010e5c: c2 2f 60 1c stb %g1, [ %i5 + 0x1c ]
2010e60: c2 17 bf a4 lduh [ %fp + -92 ], %g1
2010e64: c2 2f 60 1d stb %g1, [ %i5 + 0x1d ]
2010e68: c2 07 bf a4 ld [ %fp + -92 ], %g1
2010e6c: 83 30 60 08 srl %g1, 8, %g1
2010e70: c2 2f 60 1e stb %g1, [ %i5 + 0x1e ]
2010e74: c2 07 bf a4 ld [ %fp + -92 ], %g1
2010e78: c2 2f 60 1f stb %g1, [ %i5 + 0x1f ]
write_sb (RTEMS_RFS_SB_OFFSET_GROUP_INODES, fs->group_inodes);
2010e7c: c2 0f bf a8 ldub [ %fp + -88 ], %g1
2010e80: c2 2f 60 20 stb %g1, [ %i5 + 0x20 ]
2010e84: c2 17 bf a8 lduh [ %fp + -88 ], %g1
2010e88: c2 2f 60 21 stb %g1, [ %i5 + 0x21 ]
2010e8c: c2 07 bf a8 ld [ %fp + -88 ], %g1
2010e90: 83 30 60 08 srl %g1, 8, %g1
2010e94: c2 2f 60 22 stb %g1, [ %i5 + 0x22 ]
2010e98: c2 07 bf a8 ld [ %fp + -88 ], %g1
write_sb (RTEMS_RFS_SB_OFFSET_INODE_SIZE, RTEMS_RFS_INODE_SIZE);
2010e9c: 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);
2010ea0: c2 2f 60 23 stb %g1, [ %i5 + 0x23 ]
write_sb (RTEMS_RFS_SB_OFFSET_INODE_SIZE, RTEMS_RFS_INODE_SIZE);
2010ea4: c0 2f 60 25 clrb [ %i5 + 0x25 ]
2010ea8: c0 2f 60 26 clrb [ %i5 + 0x26 ]
2010eac: 82 10 20 38 mov 0x38, %g1
2010eb0: c2 2f 60 27 stb %g1, [ %i5 + 0x27 ]
rtems_rfs_buffer_mark_dirty (&handle);
rc = rtems_rfs_buffer_handle_release (fs, &handle);
2010eb4: 40 00 29 49 call 201b3d8 <rtems_rfs_buffer_handle_release>
2010eb8: c4 2f bf 30 stb %g2, [ %fp + -208 ]
if (rc > 0)
{
rtems_rfs_buffer_handle_close (fs, &handle);
2010ebc: 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);
2010ec0: ba 10 00 08 mov %o0, %i5
if (rc > 0)
2010ec4: 80 a7 60 00 cmp %i5, 0
2010ec8: 04 80 00 0a ble 2010ef0 <rtems_rfs_format+0x658> <== ALWAYS TAKEN
2010ecc: 90 07 bf 7c add %fp, -132, %o0
{
rtems_rfs_buffer_handle_close (fs, &handle);
2010ed0: 7f ff fe 5d call 2010844 <rtems_rfs_buffer_handle_close> <== NOT EXECUTED
2010ed4: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: write-superblock: buffer release failed: %d: %s\n",
2010ed8: 40 00 48 f7 call 20232b4 <strerror> <== NOT EXECUTED
2010edc: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
2010ee0: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
2010ee4: 11 00 80 c9 sethi %hi(0x2032400), %o0 <== NOT EXECUTED
2010ee8: 10 80 00 0d b 2010f1c <rtems_rfs_format+0x684> <== NOT EXECUTED
2010eec: 90 12 21 78 or %o0, 0x178, %o0 ! 2032578 <_CPU_Trap_slot_template+0x340><== NOT EXECUTED
rc, strerror (rc));
return false;
}
rc = rtems_rfs_buffer_handle_close (fs, &handle);
2010ef0: 7f ff fe 55 call 2010844 <rtems_rfs_buffer_handle_close>
2010ef4: 01 00 00 00 nop
printf ("rtems-rfs: write-superblock: buffer handle close failed: %d: %s\n",
rc, strerror (rc));
return false;
}
return true;
2010ef8: 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)
2010efc: 80 a2 20 00 cmp %o0, 0
2010f00: 04 80 00 0a ble 2010f28 <rtems_rfs_format+0x690> <== ALWAYS TAKEN
2010f04: ba 10 00 08 mov %o0, %i5
{
printf ("rtems-rfs: write-superblock: buffer handle close failed: %d: %s\n",
2010f08: 40 00 48 eb call 20232b4 <strerror> <== NOT EXECUTED
2010f0c: 01 00 00 00 nop <== NOT EXECUTED
2010f10: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
2010f14: 11 00 80 c9 sethi %hi(0x2032400), %o0 <== NOT EXECUTED
2010f18: 90 12 21 b8 or %o0, 0x1b8, %o0 ! 20325b8 <_CPU_Trap_slot_template+0x380><== NOT EXECUTED
2010f1c: 40 00 44 77 call 20220f8 <printf> <== NOT EXECUTED
2010f20: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
rc, strerror (rc));
return false;
2010f24: 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))
2010f28: 80 88 60 ff btst 0xff, %g1
2010f2c: 12 80 00 f3 bne 20112f8 <rtems_rfs_format+0xa60> <== ALWAYS TAKEN
2010f30: ba 10 20 00 clr %i5
{
printf ("rtems-rfs: format: superblock write failed\n");
2010f34: 11 00 80 c9 sethi %hi(0x2032400), %o0 <== NOT EXECUTED
2010f38: 90 12 22 00 or %o0, 0x200, %o0 ! 2032600 <_CPU_Trap_slot_template+0x3c8><== NOT EXECUTED
2010f3c: 40 00 45 07 call 2022358 <puts> <== NOT EXECUTED
2010f40: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
2010f44: 30 80 01 93 b,a 2011590 <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);
2010f48: f8 07 bf a4 ld [ %fp + -92 ], %i4
2010f4c: 90 10 00 1d mov %i5, %o0
2010f50: 7f ff c5 91 call 2002594 <.umul>
2010f54: 92 10 00 1c mov %i4, %o1
if (group_base > rtems_rfs_fs_blocks (fs))
2010f58: 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);
2010f5c: 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,
2010f60: 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))
2010f64: 80 a4 00 01 cmp %l0, %g1
2010f68: 08 80 00 08 bleu 2010f88 <rtems_rfs_format+0x6f0> <== ALWAYS TAKEN
2010f6c: b4 10 00 08 mov %o0, %i2
{
printf ("rtems-rfs: write-group: group %d base beyond disk limit\n",
2010f70: 11 00 80 c9 sethi %hi(0x2032400), %o0 <== NOT EXECUTED
2010f74: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
2010f78: 40 00 44 60 call 20220f8 <printf> <== NOT EXECUTED
2010f7c: 90 12 22 30 or %o0, 0x230, %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;
2010f80: 10 80 00 d9 b 20112e4 <rtems_rfs_format+0xa4c> <== NOT EXECUTED
2010f84: 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))
2010f88: 84 04 00 1c add %l0, %i4, %g2
2010f8c: 80 a0 80 01 cmp %g2, %g1
2010f90: 38 80 00 02 bgu,a 2010f98 <rtems_rfs_format+0x700> <== ALWAYS TAKEN
2010f94: b8 20 40 10 sub %g1, %l0, %i4
group_size = rtems_rfs_fs_blocks (fs) - group_base;
if (verbose)
2010f98: 80 8d e0 ff btst 0xff, %l7
2010f9c: 22 80 00 09 be,a 2010fc0 <rtems_rfs_format+0x728> <== ALWAYS TAKEN
2010fa0: c0 2f bf 30 clrb [ %fp + -208 ]
printf ("\rrtems-rfs: format: group %3d: base = %" PRId32 ", size = %zd",
2010fa4: 11 00 80 c9 sethi %hi(0x2032400), %o0 <== NOT EXECUTED
2010fa8: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
2010fac: 90 12 22 70 or %o0, 0x270, %o0 <== NOT EXECUTED
2010fb0: 94 10 00 10 mov %l0, %o2 <== NOT EXECUTED
2010fb4: 40 00 44 51 call 20220f8 <printf> <== NOT EXECUTED
2010fb8: 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;
2010fbc: c0 2f bf 30 clrb [ %fp + -208 ] <== NOT EXECUTED
handle->bnum = 0;
2010fc0: 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)
2010fc4: 80 8d e0 ff btst 0xff, %l7
2010fc8: 02 80 00 05 be 2010fdc <rtems_rfs_format+0x744> <== ALWAYS TAKEN
2010fcc: c0 27 bf 38 clr [ %fp + -200 ]
printf (", blocks");
2010fd0: 11 00 80 c9 sethi %hi(0x2032400), %o0 <== NOT EXECUTED
2010fd4: 40 00 44 49 call 20220f8 <printf> <== NOT EXECUTED
2010fd8: 90 12 22 a8 or %o0, 0x2a8, %o0 ! 20326a8 <_CPU_Trap_slot_template+0x470><== NOT EXECUTED
/*
* Open the block bitmap using the new buffer.
*/
rc = rtems_rfs_bitmap_open (&bitmap, fs, &handle, group_size,
2010fdc: 98 10 00 10 mov %l0, %o4
2010fe0: b6 07 bf 3c add %fp, -196, %i3
2010fe4: 92 07 bf 7c add %fp, -132, %o1
2010fe8: 90 10 00 1b mov %i3, %o0
2010fec: 94 07 bf 30 add %fp, -208, %o2
2010ff0: 40 00 24 6c call 201a1a0 <rtems_rfs_bitmap_open>
2010ff4: 96 10 00 1c mov %i4, %o3
group_base + RTEMS_RFS_GROUP_BLOCK_BITMAP_BLOCK);
if (rc > 0)
2010ff8: a0 92 20 00 orcc %o0, 0, %l0
2010ffc: 04 80 00 0a ble 2011024 <rtems_rfs_format+0x78c> <== ALWAYS TAKEN
2011000: 92 07 bf 30 add %fp, -208, %o1
{
rtems_rfs_buffer_handle_close (fs, &handle);
2011004: 7f ff fe 10 call 2010844 <rtems_rfs_buffer_handle_close> <== NOT EXECUTED
2011008: 90 07 bf 7c add %fp, -132, %o0 <== NOT EXECUTED
printf ("\nrtems-rfs: write-group: group %3d: open block bitmap failed: %d: %s\n",
201100c: 40 00 48 aa call 20232b4 <strerror> <== NOT EXECUTED
2011010: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
2011014: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
2011018: 11 00 80 c9 sethi %hi(0x2032400), %o0 <== NOT EXECUTED
201101c: 10 80 00 17 b 2011078 <rtems_rfs_format+0x7e0> <== NOT EXECUTED
2011020: 90 12 22 b8 or %o0, 0x2b8, %o0 ! 20326b8 <_CPU_Trap_slot_template+0x480><== 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));
2011024: c2 07 bf 38 ld [ %fp + -200 ], %g1
2011028: d4 07 bf 84 ld [ %fp + -124 ], %o2
201102c: d0 00 60 1c ld [ %g1 + 0x1c ], %o0
2011030: 40 00 43 b4 call 2021f00 <memset>
2011034: 92 10 20 ff mov 0xff, %o1
/*
* Clear the bitmap.
*/
rc = rtems_rfs_bitmap_map_clear_all (&bitmap);
2011038: 40 00 23 b3 call 2019f04 <rtems_rfs_bitmap_map_clear_all>
201103c: 90 10 00 1b mov %i3, %o0
2011040: a0 10 00 08 mov %o0, %l0
if (rc > 0)
2011044: 80 a4 20 00 cmp %l0, 0
2011048: 04 80 00 0f ble 2011084 <rtems_rfs_format+0x7ec> <== ALWAYS TAKEN
201104c: 90 10 00 1b mov %i3, %o0
{
rtems_rfs_bitmap_close (&bitmap);
2011050: 40 00 24 65 call 201a1e4 <rtems_rfs_bitmap_close> <== NOT EXECUTED
2011054: 01 00 00 00 nop <== NOT EXECUTED
rtems_rfs_buffer_handle_close (fs, &handle);
2011058: 92 07 bf 30 add %fp, -208, %o1 <== NOT EXECUTED
201105c: 7f ff fd fa call 2010844 <rtems_rfs_buffer_handle_close> <== NOT EXECUTED
2011060: 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",
2011064: 40 00 48 94 call 20232b4 <strerror> <== NOT EXECUTED
2011068: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
201106c: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
2011070: 11 00 80 c9 sethi %hi(0x2032400), %o0 <== NOT EXECUTED
2011074: 90 12 23 00 or %o0, 0x300, %o0 ! 2032700 <_CPU_Trap_slot_template+0x4c8><== NOT EXECUTED
2011078: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
201107c: 10 80 00 5e b 20111f4 <rtems_rfs_format+0x95c> <== NOT EXECUTED
2011080: 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);
2011084: 40 00 23 1c call 2019cf4 <rtems_rfs_bitmap_map_set>
2011088: 92 10 20 00 clr %o1
/*
* Forced allocation of the inode bitmap.
*/
rtems_rfs_bitmap_map_set (&bitmap, RTEMS_RFS_GROUP_INODE_BITMAP_BLOCK);
201108c: 92 10 20 01 mov 1, %o1
2011090: 40 00 23 19 call 2019cf4 <rtems_rfs_bitmap_map_set>
2011094: 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);
2011098: d0 07 bf a8 ld [ %fp + -88 ], %o0
201109c: d2 07 bf ac ld [ %fp + -84 ], %o1
20110a0: 7f ff fd f3 call 201086c <rtems_rfs_rup_quotient>
20110a4: a2 10 20 00 clr %l1
20110a8: 10 80 00 05 b 20110bc <rtems_rfs_format+0x824>
20110ac: 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);
20110b0: 92 04 60 02 add %l1, 2, %o1
20110b4: 40 00 23 10 call 2019cf4 <rtems_rfs_bitmap_map_set>
20110b8: 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++)
20110bc: 80 a4 40 10 cmp %l1, %l0
20110c0: 06 bf ff fc bl 20110b0 <rtems_rfs_format+0x818>
20110c4: 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);
20110c8: 40 00 24 47 call 201a1e4 <rtems_rfs_bitmap_close>
20110cc: 01 00 00 00 nop
if (rc > 0)
20110d0: b6 92 20 00 orcc %o0, 0, %i3
20110d4: 24 80 00 0d ble,a 2011108 <rtems_rfs_format+0x870> <== ALWAYS TAKEN
20110d8: 82 10 20 01 mov 1, %g1
{
rtems_rfs_buffer_handle_close (fs, &handle);
20110dc: 92 07 bf 30 add %fp, -208, %o1 <== NOT EXECUTED
20110e0: 7f ff fd d9 call 2010844 <rtems_rfs_buffer_handle_close> <== NOT EXECUTED
20110e4: 90 07 bf 7c add %fp, -132, %o0 <== NOT EXECUTED
printf ("\nrtems-rfs: write-group: group %3d: close block bitmap failed: %d: %s\n",
20110e8: 40 00 48 73 call 20232b4 <strerror> <== NOT EXECUTED
20110ec: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
20110f0: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
20110f4: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
20110f8: 94 10 00 1b mov %i3, %o2 <== NOT EXECUTED
20110fc: 11 00 80 c9 sethi %hi(0x2032400), %o0 <== NOT EXECUTED
2011100: 10 80 00 3d b 20111f4 <rtems_rfs_format+0x95c> <== NOT EXECUTED
2011104: 90 12 23 50 or %o0, 0x350, %o0 ! 2032750 <_CPU_Trap_slot_template+0x518><== NOT EXECUTED
return false;
}
rtems_rfs_buffer_mark_dirty (&handle);
if (verbose)
2011108: 80 8d e0 ff btst 0xff, %l7
201110c: 02 80 00 05 be 2011120 <rtems_rfs_format+0x888> <== ALWAYS TAKEN
2011110: c2 2f bf 30 stb %g1, [ %fp + -208 ]
printf (", inodes");
2011114: 11 00 80 c9 sethi %hi(0x2032400), %o0 <== NOT EXECUTED
2011118: 40 00 43 f8 call 20220f8 <printf> <== NOT EXECUTED
201111c: 90 12 23 98 or %o0, 0x398, %o0 ! 2032798 <_CPU_Trap_slot_template+0x560><== NOT EXECUTED
/*
* Open the inode bitmap using the old buffer. Should release any changes.
*/
rc = rtems_rfs_bitmap_open (&bitmap, fs, &handle, group_size,
2011120: 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,
2011124: 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,
2011128: b6 07 bf 30 add %fp, -208, %i3
201112c: 90 07 bf 3c add %fp, -196, %o0
2011130: 92 10 00 17 mov %l7, %o1
2011134: 94 10 00 1b mov %i3, %o2
2011138: 40 00 24 1a call 201a1a0 <rtems_rfs_bitmap_open>
201113c: 98 06 a0 02 add %i2, 2, %o4
group_base + RTEMS_RFS_GROUP_INODE_BITMAP_BLOCK);
if (rc > 0)
2011140: b8 92 20 00 orcc %o0, 0, %i4
2011144: 04 80 00 09 ble 2011168 <rtems_rfs_format+0x8d0> <== ALWAYS TAKEN
2011148: 92 10 00 1b mov %i3, %o1
{
rtems_rfs_buffer_handle_close (fs, &handle);
201114c: 7f ff fd be call 2010844 <rtems_rfs_buffer_handle_close> <== NOT EXECUTED
2011150: 90 10 00 17 mov %l7, %o0 <== NOT EXECUTED
printf ("\nrtems-rfs: write-group: group %3d: open inode bitmap failed: %d: %s\n",
2011154: 40 00 48 58 call 20232b4 <strerror> <== NOT EXECUTED
2011158: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
201115c: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
2011160: 10 80 00 23 b 20111ec <rtems_rfs_format+0x954> <== NOT EXECUTED
2011164: 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));
2011168: c2 07 bf 38 ld [ %fp + -200 ], %g1
201116c: d4 07 bf 84 ld [ %fp + -124 ], %o2
2011170: d0 00 60 1c ld [ %g1 + 0x1c ], %o0
2011174: 40 00 43 63 call 2021f00 <memset>
2011178: 92 10 20 00 clr %o1
/*
* Clear the inode bitmap.
*/
rc = rtems_rfs_bitmap_map_clear_all (&bitmap);
201117c: 40 00 23 62 call 2019f04 <rtems_rfs_bitmap_map_clear_all>
2011180: 90 07 bf 3c add %fp, -196, %o0
2011184: b8 10 00 08 mov %o0, %i4
if (rc > 0)
2011188: 80 a7 20 00 cmp %i4, 0
201118c: 04 80 00 0c ble 20111bc <rtems_rfs_format+0x924> <== ALWAYS TAKEN
2011190: 90 07 bf 3c add %fp, -196, %o0
{
rtems_rfs_bitmap_close (&bitmap);
2011194: 40 00 24 14 call 201a1e4 <rtems_rfs_bitmap_close> <== NOT EXECUTED
2011198: 01 00 00 00 nop <== NOT EXECUTED
rtems_rfs_buffer_handle_close (fs, &handle);
201119c: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
20111a0: 7f ff fd a9 call 2010844 <rtems_rfs_buffer_handle_close> <== NOT EXECUTED
20111a4: 90 10 00 17 mov %l7, %o0 <== NOT EXECUTED
printf ("\nrtems-rfs: write-group: group %3d: inode bitmap" \
20111a8: 40 00 48 43 call 20232b4 <strerror> <== NOT EXECUTED
20111ac: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
20111b0: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
20111b4: 10 80 00 0e b 20111ec <rtems_rfs_format+0x954> <== NOT EXECUTED
20111b8: 90 10 00 14 mov %l4, %o0 <== NOT EXECUTED
}
/*
* Close the inode bitmap.
*/
rc = rtems_rfs_bitmap_close (&bitmap);
20111bc: 40 00 24 0a call 201a1e4 <rtems_rfs_bitmap_close>
20111c0: 01 00 00 00 nop
if (rc > 0)
20111c4: b8 92 20 00 orcc %o0, 0, %i4
20111c8: 24 80 00 0f ble,a 2011204 <rtems_rfs_format+0x96c> <== ALWAYS TAKEN
20111cc: 82 10 20 01 mov 1, %g1
{
rtems_rfs_buffer_handle_close (fs, &handle);
20111d0: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
20111d4: 7f ff fd 9c call 2010844 <rtems_rfs_buffer_handle_close> <== NOT EXECUTED
20111d8: 90 10 00 17 mov %l7, %o0 <== NOT EXECUTED
printf ("\nrtems-rfs: write-group: group %3d: close inode" \
20111dc: 40 00 48 36 call 20232b4 <strerror> <== NOT EXECUTED
20111e0: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
20111e4: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
20111e8: 90 10 00 13 mov %l3, %o0 <== NOT EXECUTED
20111ec: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
20111f0: 94 10 00 1c mov %i4, %o2 <== NOT EXECUTED
20111f4: 40 00 43 c1 call 20220f8 <printf> <== NOT EXECUTED
20111f8: 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;
20111fc: 10 80 00 3a b 20112e4 <rtems_rfs_format+0xa4c> <== NOT EXECUTED
2011200: 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);
2011204: c2 2f bf 30 stb %g1, [ %fp + -208 ]
/*
* Initialise the inode tables if required to do so.
*/
if (initialise_inodes)
2011208: 80 8d a0 ff btst 0xff, %l6
201120c: 12 80 00 27 bne 20112a8 <rtems_rfs_format+0xa10> <== NEVER TAKEN
2011210: a2 10 20 00 clr %l1
rtems_rfs_buffer_mark_dirty (&handle);
}
}
rc = rtems_rfs_buffer_handle_close (fs, &handle);
2011214: 90 07 bf 7c add %fp, -132, %o0
2011218: 7f ff fd 8b call 2010844 <rtems_rfs_buffer_handle_close>
201121c: 92 07 bf 30 add %fp, -208, %o1
if (rc > 0)
2011220: b8 92 20 00 orcc %o0, 0, %i4
2011224: 04 80 00 30 ble 20112e4 <rtems_rfs_format+0xa4c> <== ALWAYS TAKEN
2011228: 82 10 20 01 mov 1, %g1
201122c: 30 80 00 27 b,a 20112c8 <rtems_rfs_format+0xa30> <== NOT EXECUTED
*/
if (initialise_inodes)
{
for (b = 0; b < blocks; b++)
{
rc = rtems_rfs_buffer_handle_request (fs, &handle,
2011230: 90 10 00 17 mov %l7, %o0 <== NOT EXECUTED
return rc;
}
int
rtems_rfs_format (const char* name, const rtems_rfs_format_config* config)
2011234: 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,
2011238: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
201123c: 94 10 00 1c mov %i4, %o2 <== NOT EXECUTED
2011240: 40 00 28 da call 201b5a8 <rtems_rfs_buffer_handle_request><== NOT EXECUTED
2011244: 96 10 20 00 clr %o3 <== NOT EXECUTED
group_base + b + RTEMS_RFS_GROUP_INODE_BLOCK,
false);
if (rc > 0)
2011248: b4 92 20 00 orcc %o0, 0, %i2 <== NOT EXECUTED
201124c: 04 80 00 10 ble 201128c <rtems_rfs_format+0x9f4> <== NOT EXECUTED
2011250: c4 07 bf 38 ld [ %fp + -200 ], %g2 <== NOT EXECUTED
{
rtems_rfs_buffer_handle_close (fs, &handle);
2011254: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
2011258: 7f ff fd 7b call 2010844 <rtems_rfs_buffer_handle_close> <== NOT EXECUTED
201125c: 90 10 00 17 mov %l7, %o0 <== NOT EXECUTED
printf ("\nrtems-rfs: write-group: group %3d: block %" PRId32 " request failed: %d: %s\n",
2011260: 40 00 48 15 call 20232b4 <strerror> <== NOT EXECUTED
2011264: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
2011268: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
201126c: 98 10 00 08 mov %o0, %o4 <== NOT EXECUTED
2011270: 94 10 00 1c mov %i4, %o2 <== NOT EXECUTED
2011274: 11 00 80 ca sethi %hi(0x2032800), %o0 <== NOT EXECUTED
2011278: 96 10 00 1a mov %i2, %o3 <== NOT EXECUTED
201127c: 40 00 43 9f call 20220f8 <printf> <== NOT EXECUTED
2011280: 90 12 20 88 or %o0, 0x88, %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;
2011284: 10 80 00 18 b 20112e4 <rtems_rfs_format+0xa4c> <== NOT EXECUTED
2011288: 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));
201128c: d4 07 bf 84 ld [ %fp + -124 ], %o2 <== NOT EXECUTED
2011290: d0 00 a0 1c ld [ %g2 + 0x1c ], %o0 <== NOT EXECUTED
2011294: 92 10 20 ff mov 0xff, %o1 <== NOT EXECUTED
2011298: 40 00 43 1a call 2021f00 <memset> <== NOT EXECUTED
201129c: a2 04 60 01 inc %l1 <== NOT EXECUTED
rtems_rfs_buffer_mark_dirty (&handle);
20112a0: 10 80 00 05 b 20112b4 <rtems_rfs_format+0xa1c> <== NOT EXECUTED
20112a4: 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,
20112a8: 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);
20112ac: 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,
20112b0: 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++)
20112b4: 80 a4 40 10 cmp %l1, %l0 <== NOT EXECUTED
20112b8: 06 bf ff de bl 2011230 <rtems_rfs_format+0x998> <== NOT EXECUTED
20112bc: c2 07 bf 24 ld [ %fp + -220 ], %g1 <== NOT EXECUTED
rtems_rfs_buffer_mark_dirty (&handle);
}
}
rc = rtems_rfs_buffer_handle_close (fs, &handle);
20112c0: 10 bf ff d6 b 2011218 <rtems_rfs_format+0x980> <== NOT EXECUTED
20112c4: 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",
20112c8: 40 00 47 fb call 20232b4 <strerror> <== NOT EXECUTED
20112cc: 01 00 00 00 nop <== NOT EXECUTED
20112d0: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
20112d4: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
20112d8: 40 00 43 88 call 20220f8 <printf> <== NOT EXECUTED
20112dc: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED
rc, strerror (rc));
return false;
20112e0: 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,
20112e4: 80 88 60 ff btst 0xff, %g1
20112e8: 02 80 00 a9 be 201158c <rtems_rfs_format+0xcf4> <== NEVER TAKEN
20112ec: ba 07 60 01 inc %i5
{
printf ("rtems-rfs: format: superblock write failed\n");
return -1;
}
for (group = 0; group < fs.group_count; group++)
20112f0: 10 80 00 0b b 201131c <rtems_rfs_format+0xa84>
20112f4: 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",
20112f8: 25 00 80 ca sethi %hi(0x2032800), %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" \
20112fc: 27 00 80 ca sethi %hi(0x2032800), %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" \
2011300: 29 00 80 c9 sethi %hi(0x2032400), %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",
2011304: 2b 00 80 c9 sethi %hi(0x2032400), %l5
}
rc = rtems_rfs_buffer_handle_close (fs, &handle);
if (rc > 0)
{
printf ("\nrtems-rfs: write-group: buffer handle close failed: %d: %s\n",
2011308: a4 14 a0 d0 or %l2, 0xd0, %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" \
201130c: a6 14 e0 40 or %l3, 0x40, %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" \
2011310: a8 15 23 f0 or %l4, 0x3f0, %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",
2011314: aa 15 63 a8 or %l5, 0x3a8, %l5
{
printf ("rtems-rfs: format: superblock write failed\n");
return -1;
}
for (group = 0; group < fs.group_count; group++)
2011318: c2 07 bf a0 ld [ %fp + -96 ], %g1
201131c: 80 a7 40 01 cmp %i5, %g1
2011320: 06 bf ff 0a bl 2010f48 <rtems_rfs_format+0x6b0>
2011324: 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)
2011328: 80 8d e0 ff btst 0xff, %l7
201132c: 02 80 00 04 be 201133c <rtems_rfs_format+0xaa4> <== ALWAYS TAKEN
2011330: 01 00 00 00 nop
printf ("\n");
2011334: 40 00 43 db call 20222a0 <putchar> <== NOT EXECUTED
2011338: 90 10 20 0a mov 0xa, %o0 ! a <PROM_START+0xa> <== NOT EXECUTED
rc = rtems_rfs_buffer_close (&fs);
201133c: 40 00 2a 1c call 201bbac <rtems_rfs_buffer_close>
2011340: 90 07 bf 7c add %fp, -132, %o0
if (rc > 0)
2011344: ba 92 20 00 orcc %o0, 0, %i5
2011348: 24 80 00 08 ble,a 2011368 <rtems_rfs_format+0xad0> <== ALWAYS TAKEN
201134c: 90 10 00 18 mov %i0, %o0
{
printf ("rtems-rfs: format: buffer close failed: %d: %s\n",
2011350: 40 00 47 d9 call 20232b4 <strerror> <== NOT EXECUTED
2011354: 01 00 00 00 nop <== NOT EXECUTED
2011358: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
201135c: 11 00 80 ca sethi %hi(0x2032800), %o0 <== NOT EXECUTED
2011360: 10 80 00 87 b 201157c <rtems_rfs_format+0xce4> <== NOT EXECUTED
2011364: 90 12 21 10 or %o0, 0x110, %o0 ! 2032910 <_CPU_Trap_slot_template+0x6d8><== NOT EXECUTED
int rc;
/*
* External API so returns -1.
*/
rc = rtems_rfs_fs_open (name, NULL,
2011368: 92 10 20 00 clr %o1
201136c: 94 10 20 06 mov 6, %o2
2011370: 96 10 20 00 clr %o3
2011374: 40 00 32 b0 call 201de34 <rtems_rfs_fs_open>
2011378: 98 07 bf 28 add %fp, -216, %o4
RTEMS_RFS_FS_FORCE_OPEN | RTEMS_RFS_FS_NO_LOCAL_CACHE,
0, &fs);
if (rc < 0)
201137c: 80 a2 20 00 cmp %o0, 0
2011380: 36 80 00 0e bge,a 20113b8 <rtems_rfs_format+0xb20> <== ALWAYS TAKEN
2011384: d0 07 bf 28 ld [ %fp + -216 ], %o0
{
printf ("rtems-rfs: format: file system open failed: %d: %s\n",
errno, strerror (errno));
2011388: 40 00 3e 0d call 2020bbc <__errno> <== NOT EXECUTED
201138c: b0 10 20 00 clr %i0 <== NOT EXECUTED
2011390: 40 00 3e 0b call 2020bbc <__errno> <== NOT EXECUTED
2011394: 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",
2011398: 40 00 47 c7 call 20232b4 <strerror> <== NOT EXECUTED
201139c: d0 02 00 00 ld [ %o0 ], %o0 <== NOT EXECUTED
20113a0: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
20113a4: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
20113a8: 11 00 80 ca sethi %hi(0x2032800), %o0 <== NOT EXECUTED
20113ac: 40 00 43 53 call 20220f8 <printf> <== NOT EXECUTED
20113b0: 90 12 21 40 or %o0, 0x140, %o0 ! 2032940 <_CPU_Trap_slot_template+0x708><== NOT EXECUTED
20113b4: 30 80 00 77 b,a 2011590 <rtems_rfs_format+0xcf8> <== NOT EXECUTED
errno, strerror (errno));
return -1;
}
rc = rtems_rfs_inode_alloc (fs, RTEMS_RFS_ROOT_INO, &ino);
20113b8: 92 10 20 01 mov 1, %o1
20113bc: 40 00 02 38 call 2011c9c <rtems_rfs_inode_alloc>
20113c0: 94 07 bf 2c add %fp, -212, %o2
if (rc > 0)
20113c4: ba 92 20 00 orcc %o0, 0, %i5
20113c8: 04 80 00 0a ble 20113f0 <rtems_rfs_format+0xb58> <== ALWAYS TAKEN
20113cc: d2 07 bf 2c ld [ %fp + -212 ], %o1
{
printf ("rtems-rfs: format: inode allocation failed: %d: %s\n",
20113d0: 40 00 47 b9 call 20232b4 <strerror> <== NOT EXECUTED
20113d4: 01 00 00 00 nop <== NOT EXECUTED
20113d8: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
20113dc: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
20113e0: 11 00 80 ca sethi %hi(0x2032800), %o0 <== NOT EXECUTED
20113e4: 40 00 43 45 call 20220f8 <printf> <== NOT EXECUTED
20113e8: 90 12 21 78 or %o0, 0x178, %o0 ! 2032978 <_CPU_Trap_slot_template+0x740><== NOT EXECUTED
20113ec: 30 80 00 06 b,a 2011404 <rtems_rfs_format+0xb6c> <== NOT EXECUTED
rc, strerror (rc));
rtems_rfs_fs_close (fs);
return rc;
}
if (ino != RTEMS_RFS_ROOT_INO)
20113f0: 80 a2 60 01 cmp %o1, 1
20113f4: 02 80 00 08 be 2011414 <rtems_rfs_format+0xb7c> <== ALWAYS TAKEN
20113f8: 11 00 80 ca sethi %hi(0x2032800), %o0
{
printf ("rtems-rfs: format: allocated inode not root ino: %" PRId32 "\n", ino);
20113fc: 40 00 43 3f call 20220f8 <printf> <== NOT EXECUTED
2011400: 90 12 21 b0 or %o0, 0x1b0, %o0 ! 20329b0 <_CPU_Trap_slot_template+0x778><== NOT EXECUTED
rtems_rfs_fs_close (fs);
2011404: 40 00 34 87 call 201e620 <rtems_rfs_fs_close> <== NOT EXECUTED
2011408: 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)
201140c: 10 80 00 55 b 2011560 <rtems_rfs_format+0xcc8> <== NOT EXECUTED
2011410: 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);
2011414: d0 07 bf 28 ld [ %fp + -216 ], %o0
2011418: 92 10 20 01 mov 1, %o1
201141c: 94 07 bf 54 add %fp, -172, %o2
2011420: 40 00 02 5b call 2011d8c <rtems_rfs_inode_open>
2011424: 96 10 20 01 mov 1, %o3
if (rc > 0)
2011428: ba 92 20 00 orcc %o0, 0, %i5
201142c: 24 80 00 0e ble,a 2011464 <rtems_rfs_format+0xbcc> <== ALWAYS TAKEN
2011430: 90 07 bf 54 add %fp, -172, %o0
{
printf ("rtems-rfs: format: inode open failed: %d: %s\n",
2011434: 40 00 47 a0 call 20232b4 <strerror> <== NOT EXECUTED
2011438: 01 00 00 00 nop <== NOT EXECUTED
201143c: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
2011440: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
2011444: 11 00 80 ca sethi %hi(0x2032800), %o0 <== NOT EXECUTED
2011448: 40 00 43 2c call 20220f8 <printf> <== NOT EXECUTED
201144c: 90 12 21 e8 or %o0, 0x1e8, %o0 ! 20329e8 <_CPU_Trap_slot_template+0x7b0><== NOT EXECUTED
rc, strerror (rc));
rtems_rfs_group_bitmap_free (fs, true, ino);
2011450: d0 07 bf 28 ld [ %fp + -216 ], %o0 <== NOT EXECUTED
2011454: d4 07 bf 2c ld [ %fp + -212 ], %o2 <== NOT EXECUTED
2011458: 40 00 01 7c call 2011a48 <rtems_rfs_group_bitmap_free> <== NOT EXECUTED
201145c: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
2011460: 30 bf ff e9 b,a 2011404 <rtems_rfs_format+0xb6c> <== NOT EXECUTED
rtems_rfs_fs_close (fs);
return rc;
}
rc = rtems_rfs_inode_initialise (&inode, 0,
2011464: 92 10 20 00 clr %o1
2011468: 15 00 00 10 sethi %hi(0x4000), %o2
201146c: 96 10 20 00 clr %o3
2011470: 94 12 a1 c9 or %o2, 0x1c9, %o2
2011474: 40 00 03 39 call 2012158 <rtems_rfs_inode_initialise>
2011478: 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)
201147c: ba 92 20 00 orcc %o0, 0, %i5
2011480: 24 80 00 0a ble,a 20114a8 <rtems_rfs_format+0xc10> <== ALWAYS TAKEN
2011484: d0 07 bf 28 ld [ %fp + -216 ], %o0
printf ("rtems-rfs: format: inode initialise failed: %d: %s\n",
2011488: 40 00 47 8b call 20232b4 <strerror> <== NOT EXECUTED
201148c: 01 00 00 00 nop <== NOT EXECUTED
2011490: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
2011494: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
2011498: 11 00 80 ca sethi %hi(0x2032800), %o0 <== NOT EXECUTED
201149c: 40 00 43 17 call 20220f8 <printf> <== NOT EXECUTED
20114a0: 90 12 22 18 or %o0, 0x218, %o0 ! 2032a18 <_CPU_Trap_slot_template+0x7e0><== NOT EXECUTED
rc, strerror (rc));
rc = rtems_rfs_dir_add_entry (fs, &inode, ".", 1, ino);
20114a4: d0 07 bf 28 ld [ %fp + -216 ], %o0 <== NOT EXECUTED
20114a8: d8 07 bf 2c ld [ %fp + -212 ], %o4
20114ac: 92 07 bf 54 add %fp, -172, %o1
20114b0: 15 00 80 c1 sethi %hi(0x2030400), %o2
20114b4: 96 10 20 01 mov 1, %o3
20114b8: 40 00 2b 39 call 201c19c <rtems_rfs_dir_add_entry>
20114bc: 94 12 a0 78 or %o2, 0x78, %o2
if (rc > 0)
20114c0: ba 92 20 00 orcc %o0, 0, %i5
20114c4: 24 80 00 0a ble,a 20114ec <rtems_rfs_format+0xc54> <== ALWAYS TAKEN
20114c8: d0 07 bf 28 ld [ %fp + -216 ], %o0
printf ("rtems-rfs: format: directory add failed: %d: %s\n",
20114cc: 40 00 47 7a call 20232b4 <strerror> <== NOT EXECUTED
20114d0: 01 00 00 00 nop <== NOT EXECUTED
20114d4: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
20114d8: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
20114dc: 11 00 80 ca sethi %hi(0x2032800), %o0 <== NOT EXECUTED
20114e0: 40 00 43 06 call 20220f8 <printf> <== NOT EXECUTED
20114e4: 90 12 22 50 or %o0, 0x250, %o0 ! 2032a50 <_CPU_Trap_slot_template+0x818><== NOT EXECUTED
rc, strerror (rc));
rc = rtems_rfs_inode_close (fs, &inode);
20114e8: d0 07 bf 28 ld [ %fp + -216 ], %o0 <== NOT EXECUTED
20114ec: 40 00 02 9a call 2011f54 <rtems_rfs_inode_close>
20114f0: 92 07 bf 54 add %fp, -172, %o1
if (rc > 0)
20114f4: ba 92 20 00 orcc %o0, 0, %i5
20114f8: 04 80 00 09 ble 201151c <rtems_rfs_format+0xc84> <== ALWAYS TAKEN
20114fc: 01 00 00 00 nop
printf ("rtems-rfs: format: inode close failed: %d: %s\n",
2011500: 40 00 47 6d call 20232b4 <strerror> <== NOT EXECUTED
2011504: 01 00 00 00 nop <== NOT EXECUTED
2011508: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
201150c: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
2011510: 11 00 80 ca sethi %hi(0x2032800), %o0 <== NOT EXECUTED
2011514: 40 00 42 f9 call 20220f8 <printf> <== NOT EXECUTED
2011518: 90 12 22 88 or %o0, 0x288, %o0 ! 2032a88 <_CPU_Trap_slot_template+0x850><== NOT EXECUTED
rc, strerror (rc));
rc = rtems_rfs_fs_close (fs);
201151c: 40 00 34 41 call 201e620 <rtems_rfs_fs_close>
2011520: d0 07 bf 28 ld [ %fp + -216 ], %o0
if (rc < 0)
2011524: ba 92 20 00 orcc %o0, 0, %i5
2011528: 16 80 00 0e bge 2011560 <rtems_rfs_format+0xcc8> <== ALWAYS TAKEN
201152c: 80 a7 60 00 cmp %i5, 0
printf ("rtems-rfs: format: file system close failed: %d: %s\n",
errno, strerror (errno));
2011530: 40 00 3d a3 call 2020bbc <__errno> <== NOT EXECUTED
2011534: 01 00 00 00 nop <== NOT EXECUTED
2011538: 40 00 3d a1 call 2020bbc <__errno> <== NOT EXECUTED
201153c: 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",
2011540: 40 00 47 5d call 20232b4 <strerror> <== NOT EXECUTED
2011544: d0 02 00 00 ld [ %o0 ], %o0 <== NOT EXECUTED
2011548: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
201154c: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
2011550: 11 00 80 ca sethi %hi(0x2032800), %o0 <== NOT EXECUTED
2011554: 40 00 42 e9 call 20220f8 <printf> <== NOT EXECUTED
2011558: 90 12 22 b8 or %o0, 0x2b8, %o0 ! 2032ab8 <_CPU_Trap_slot_template+0x880><== NOT EXECUTED
rc, strerror (rc));
return -1;
}
rc = rtems_rfs_write_root_dir (name);
if (rc > 0)
201155c: 80 a7 60 00 cmp %i5, 0 <== NOT EXECUTED
2011560: 24 80 00 0c ble,a 2011590 <rtems_rfs_format+0xcf8> <== ALWAYS TAKEN
2011564: b0 10 20 00 clr %i0
{
printf ("rtems-rfs: format: writing root dir failed: %d: %s\n",
2011568: 40 00 47 53 call 20232b4 <strerror> <== NOT EXECUTED
201156c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
2011570: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
2011574: 11 00 80 ca sethi %hi(0x2032800), %o0 <== NOT EXECUTED
2011578: 90 12 22 f0 or %o0, 0x2f0, %o0 ! 2032af0 <_CPU_Trap_slot_template+0x8b8><== NOT EXECUTED
201157c: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
2011580: 40 00 42 de call 20220f8 <printf> <== NOT EXECUTED
2011584: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
2011588: 30 80 00 02 b,a 2011590 <rtems_rfs_format+0xcf8> <== NOT EXECUTED
/*
* Check the configuration data.
*/
if (!rtems_rfs_check_config (&fs, config))
return -1;
201158c: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
2011590: 81 c7 e0 08 ret
2011594: 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;
2011598: c2 27 bf 98 st %g1, [ %fp + -104 ]
* Check the configuration data.
*/
if (!rtems_rfs_check_config (&fs, config))
return -1;
if (config->verbose)
201159c: c2 0e 60 15 ldub [ %i1 + 0x15 ], %g1
20115a0: 80 a0 60 00 cmp %g1, 0
20115a4: 02 bf fd d0 be 2010ce4 <rtems_rfs_format+0x44c> <== ALWAYS TAKEN
20115a8: d2 07 bf 84 ld [ %fp + -124 ], %o1
20115ac: 30 bf fd 6f b,a 2010b68 <rtems_rfs_format+0x2d0> <== NOT EXECUTED
0201e620 <rtems_rfs_fs_close>:
int
rtems_rfs_fs_close (rtems_rfs_file_system* fs)
{
201e620: 9d e3 bf a0 save %sp, -96, %sp
int group;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_CLOSE))
201e624: 90 10 20 00 clr %o0
201e628: 7f ff d4 6a call 20137d0 <rtems_rfs_trace>
201e62c: 92 10 20 02 mov 2, %o1
201e630: 80 8a 20 ff btst 0xff, %o0
201e634: 22 80 00 06 be,a 201e64c <rtems_rfs_fs_close+0x2c> <== ALWAYS TAKEN
201e638: b8 10 20 00 clr %i4
printf ("rtems-rfs: close\n");
201e63c: 11 00 80 d2 sethi %hi(0x2034800), %o0 <== NOT EXECUTED
201e640: 40 00 0f 46 call 2022358 <puts> <== NOT EXECUTED
201e644: 90 12 22 c8 or %o0, 0x2c8, %o0 ! 2034ac8 <CSWTCH.2+0x13e8><== NOT EXECUTED
return 0;
}
int
rtems_rfs_fs_close (rtems_rfs_file_system* fs)
{
201e648: b8 10 20 00 clr %i4 <== NOT EXECUTED
201e64c: 10 80 00 07 b 201e668 <rtems_rfs_fs_close+0x48>
201e650: 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]);
201e654: 90 10 00 18 mov %i0, %o0
201e658: 92 02 40 1c add %o1, %i4, %o1
201e65c: 7f ff cc 53 call 20117a8 <rtems_rfs_group_close>
201e660: ba 07 60 01 inc %i5
201e664: 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++)
201e668: c2 06 20 24 ld [ %i0 + 0x24 ], %g1
201e66c: 80 a7 40 01 cmp %i5, %g1
201e670: 26 bf ff f9 bl,a 201e654 <rtems_rfs_fs_close+0x34>
201e674: d2 06 20 20 ld [ %i0 + 0x20 ], %o1
rtems_rfs_group_close (fs, &fs->groups[group]);
rtems_rfs_buffer_close (fs);
201e678: 7f ff f5 4d call 201bbac <rtems_rfs_buffer_close>
201e67c: 90 10 00 18 mov %i0, %o0
free (fs);
201e680: 90 10 00 18 mov %i0, %o0
201e684: 7f ff a6 e9 call 2008228 <free>
201e688: b0 10 20 00 clr %i0
return 0;
}
201e68c: 81 c7 e0 08 ret
201e690: 81 e8 00 00 restore
0201de34 <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)
{
201de34: 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))
201de38: 90 10 20 00 clr %o0
201de3c: 7f ff d6 65 call 20137d0 <rtems_rfs_trace>
201de40: 92 10 20 01 mov 1, %o1
201de44: 80 8a 20 ff btst 0xff, %o0
201de48: 02 80 00 05 be 201de5c <rtems_rfs_fs_open+0x28> <== ALWAYS TAKEN
201de4c: 11 00 80 d1 sethi %hi(0x2034400), %o0
printf ("rtems-rfs: open: %s\n", name);
201de50: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
201de54: 40 00 10 a9 call 20220f8 <printf> <== NOT EXECUTED
201de58: 90 12 23 88 or %o0, 0x388, %o0 <== NOT EXECUTED
*fs = malloc (sizeof (rtems_rfs_file_system));
201de5c: 7f ff aa 99 call 20088c0 <malloc>
201de60: 90 10 20 84 mov 0x84, %o0
if (!*fs)
201de64: 80 a2 20 00 cmp %o0, 0
201de68: 12 80 00 0f bne 201dea4 <rtems_rfs_fs_open+0x70> <== ALWAYS TAKEN
201de6c: d0 27 00 00 st %o0, [ %i4 ]
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
201de70: 90 10 20 00 clr %o0 <== NOT EXECUTED
201de74: 7f ff d6 57 call 20137d0 <rtems_rfs_trace> <== NOT EXECUTED
201de78: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
201de7c: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
201de80: 02 80 00 05 be 201de94 <rtems_rfs_fs_open+0x60> <== NOT EXECUTED
201de84: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: open: no memory for file system data\n");
201de88: 11 00 80 d1 sethi %hi(0x2034400), %o0 <== NOT EXECUTED
201de8c: 40 00 11 33 call 2022358 <puts> <== NOT EXECUTED
201de90: 90 12 23 a0 or %o0, 0x3a0, %o0 ! 20347a0 <CSWTCH.2+0x10c0><== NOT EXECUTED
errno = ENOMEM;
201de94: 40 00 0b 4a call 2020bbc <__errno> <== NOT EXECUTED
201de98: 01 00 00 00 nop <== NOT EXECUTED
201de9c: 10 80 01 c5 b 201e5b0 <rtems_rfs_fs_open+0x77c> <== NOT EXECUTED
201dea0: 82 10 20 0c mov 0xc, %g1 ! c <PROM_START+0xc> <== NOT EXECUTED
return -1;
}
memset (*fs, 0, sizeof (rtems_rfs_file_system));
201dea4: 92 10 20 00 clr %o1
201dea8: 40 00 10 16 call 2021f00 <memset>
201deac: 94 10 20 84 mov 0x84, %o2
(*fs)->user = user;
201deb0: c2 07 00 00 ld [ %i4 ], %g1
#endif
/*
* Open the buffer interface.
*/
rc = rtems_rfs_buffer_open (name, *fs);
201deb4: 90 10 00 18 mov %i0, %o0
return -1;
}
memset (*fs, 0, sizeof (rtems_rfs_file_system));
(*fs)->user = user;
201deb8: f2 20 60 80 st %i1, [ %g1 + 0x80 ]
rtems_chain_initialize_empty (&(*fs)->buffers);
201debc: 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;
201dec0: 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 );
201dec4: 84 00 60 44 add %g1, 0x44, %g2
201dec8: 86 00 60 48 add %g1, 0x48, %g3
head->next = tail;
head->previous = NULL;
tail->previous = head;
201decc: 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;
201ded0: c6 20 60 44 st %g3, [ %g1 + 0x44 ]
rtems_chain_initialize_empty (&(*fs)->release);
201ded4: c2 07 00 00 ld [ %i4 ], %g1
head->previous = NULL;
201ded8: 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 );
201dedc: 84 00 60 54 add %g1, 0x54, %g2
201dee0: 86 00 60 58 add %g1, 0x58, %g3
head->next = tail;
head->previous = NULL;
tail->previous = head;
201dee4: 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;
201dee8: c6 20 60 54 st %g3, [ %g1 + 0x54 ]
rtems_chain_initialize_empty (&(*fs)->release_modified);
201deec: c2 07 00 00 ld [ %i4 ], %g1
head->previous = NULL;
201def0: 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 );
201def4: 84 00 60 64 add %g1, 0x64, %g2
201def8: 86 00 60 68 add %g1, 0x68, %g3
head->next = tail;
head->previous = NULL;
tail->previous = head;
201defc: 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;
201df00: c6 20 60 64 st %g3, [ %g1 + 0x64 ]
rtems_chain_initialize_empty (&(*fs)->file_shares);
201df04: c2 07 00 00 ld [ %i4 ], %g1
head->previous = NULL;
201df08: 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 );
201df0c: 84 00 60 74 add %g1, 0x74, %g2
201df10: 86 00 60 78 add %g1, 0x78, %g3
head->next = tail;
head->previous = NULL;
tail->previous = head;
201df14: 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;
201df18: c6 20 60 74 st %g3, [ %g1 + 0x74 ]
(*fs)->max_held_buffers = max_held_buffers;
201df1c: d2 07 00 00 ld [ %i4 ], %o1
201df20: f6 22 60 40 st %i3, [ %o1 + 0x40 ]
(*fs)->buffers_count = 0;
201df24: c0 22 60 50 clr [ %o1 + 0x50 ]
(*fs)->release_count = 0;
201df28: c0 22 60 60 clr [ %o1 + 0x60 ]
(*fs)->release_modified_count = 0;
201df2c: c0 22 60 70 clr [ %o1 + 0x70 ]
#endif
/*
* Open the buffer interface.
*/
rc = rtems_rfs_buffer_open (name, *fs);
201df30: 7f ff f6 44 call 201b840 <rtems_rfs_buffer_open>
201df34: f4 22 40 00 st %i2, [ %o1 ]
if (rc > 0)
201df38: ba 92 20 00 orcc %o0, 0, %i5
201df3c: 04 80 00 16 ble 201df94 <rtems_rfs_fs_open+0x160> <== ALWAYS TAKEN
201df40: f6 07 00 00 ld [ %i4 ], %i3
{
free (*fs);
201df44: 7f ff a8 b9 call 2008228 <free> <== NOT EXECUTED
201df48: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
201df4c: 90 10 20 00 clr %o0 <== NOT EXECUTED
201df50: 7f ff d6 20 call 20137d0 <rtems_rfs_trace> <== NOT EXECUTED
201df54: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
201df58: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
201df5c: 02 80 00 09 be 201df80 <rtems_rfs_fs_open+0x14c> <== NOT EXECUTED
201df60: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: open: buffer open failed: %d: %s\n",
201df64: 40 00 14 d4 call 20232b4 <strerror> <== NOT EXECUTED
201df68: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
201df6c: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
201df70: 11 00 80 d1 sethi %hi(0x2034400), %o0 <== NOT EXECUTED
201df74: 90 12 23 d0 or %o0, 0x3d0, %o0 ! 20347d0 <CSWTCH.2+0x10f0><== NOT EXECUTED
201df78: 40 00 10 60 call 20220f8 <printf> <== NOT EXECUTED
201df7c: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
rc, strerror (rc));
errno = rc;
201df80: 40 00 0b 0f call 2020bbc <__errno> <== NOT EXECUTED
201df84: 01 00 00 00 nop <== NOT EXECUTED
201df88: fa 22 00 00 st %i5, [ %o0 ] <== NOT EXECUTED
return -1;
201df8c: 81 c7 e0 08 ret <== NOT EXECUTED
201df90: 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;
201df94: c0 2f bf cc clrb [ %fp + -52 ]
handle->bnum = 0;
201df98: c0 27 bf d0 clr [ %fp + -48 ]
handle->buffer = NULL;
201df9c: 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);
201dfa0: 90 10 00 1b mov %i3, %o0
201dfa4: 92 07 bf cc add %fp, -52, %o1
201dfa8: 94 10 20 00 clr %o2
201dfac: 7f ff f5 7f call 201b5a8 <rtems_rfs_buffer_handle_request>
201dfb0: 96 10 20 01 mov 1, %o3
if (rc > 0)
201dfb4: ba 92 20 00 orcc %o0, 0, %i5
201dfb8: 04 80 00 0d ble 201dfec <rtems_rfs_fs_open+0x1b8> <== ALWAYS TAKEN
201dfbc: 90 10 20 00 clr %o0
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
201dfc0: 7f ff d6 04 call 20137d0 <rtems_rfs_trace> <== NOT EXECUTED
201dfc4: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
201dfc8: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
201dfcc: 22 80 01 2d be,a 201e480 <rtems_rfs_fs_open+0x64c> <== NOT EXECUTED
201dfd0: 80 a7 60 00 cmp %i5, 0 <== NOT EXECUTED
printf ("rtems-rfs: read-superblock: request failed%d: %s\n",
201dfd4: 40 00 14 b8 call 20232b4 <strerror> <== NOT EXECUTED
201dfd8: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
201dfdc: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
201dfe0: 11 00 80 d2 sethi %hi(0x2034800), %o0 <== NOT EXECUTED
201dfe4: 10 80 00 de b 201e35c <rtems_rfs_fs_open+0x528> <== NOT EXECUTED
201dfe8: 90 12 20 00 mov %o0, %o0 ! 2034800 <CSWTCH.2+0x1120> <== NOT EXECUTED
rc, strerror (rc));
return rc;
}
sb = rtems_rfs_buffer_data (&handle);
201dfec: c2 07 bf d4 ld [ %fp + -44 ], %g1
201dff0: 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)
201dff4: c2 0f 60 01 ldub [ %i5 + 1 ], %g1
201dff8: c4 0f 40 00 ldub [ %i5 ], %g2
201dffc: 83 28 60 10 sll %g1, 0x10, %g1
201e000: 85 28 a0 18 sll %g2, 0x18, %g2
201e004: 84 10 80 01 or %g2, %g1, %g2
201e008: c2 0f 60 03 ldub [ %i5 + 3 ], %g1
201e00c: 84 10 80 01 or %g2, %g1, %g2
201e010: c2 0f 60 02 ldub [ %i5 + 2 ], %g1
201e014: 83 28 60 08 sll %g1, 8, %g1
201e018: 84 10 80 01 or %g2, %g1, %g2
201e01c: 03 0a 02 48 sethi %hi(0x28092000), %g1
201e020: 82 10 60 01 or %g1, 1, %g1 ! 28092001 <RAM_END+0x25c92001>
201e024: 80 a0 80 01 cmp %g2, %g1
201e028: 22 80 00 0b be,a 201e054 <rtems_rfs_fs_open+0x220> <== ALWAYS TAKEN
201e02c: c2 0f 60 0d ldub [ %i5 + 0xd ], %g1
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
201e030: 90 10 20 00 clr %o0 <== NOT EXECUTED
201e034: 7f ff d5 e7 call 20137d0 <rtems_rfs_trace> <== NOT EXECUTED
201e038: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
201e03c: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
201e040: 22 80 00 57 be,a 201e19c <rtems_rfs_fs_open+0x368> <== NOT EXECUTED
201e044: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
printf ("rtems-rfs: read-superblock: invalid superblock, bad magic\n");
201e048: 11 00 80 d2 sethi %hi(0x2034800), %o0 <== NOT EXECUTED
201e04c: 10 80 00 2f b 201e108 <rtems_rfs_fs_open+0x2d4> <== NOT EXECUTED
201e050: 90 12 20 38 or %o0, 0x38, %o0 ! 2034838 <CSWTCH.2+0x1158> <== NOT EXECUTED
rtems_rfs_buffer_handle_close (fs, &handle);
return EIO;
}
fs->blocks = read_sb (RTEMS_RFS_SB_OFFSET_BLOCKS);
201e054: d6 0f 60 0c ldub [ %i5 + 0xc ], %o3
201e058: 83 28 60 10 sll %g1, 0x10, %g1
201e05c: 97 2a e0 18 sll %o3, 0x18, %o3
201e060: 96 12 c0 01 or %o3, %g1, %o3
201e064: 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;
201e068: 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);
201e06c: 96 12 c0 01 or %o3, %g1, %o3
201e070: 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;
201e074: 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);
201e078: 83 28 60 08 sll %g1, 8, %g1
201e07c: 96 12 c0 01 or %o3, %g1, %o3
201e080: d6 26 e0 04 st %o3, [ %i3 + 4 ]
fs->block_size = read_sb (RTEMS_RFS_SB_OFFSET_BLOCK_SIZE);
201e084: c2 0f 60 09 ldub [ %i5 + 9 ], %g1
201e088: f4 0f 60 08 ldub [ %i5 + 8 ], %i2
201e08c: 83 28 60 10 sll %g1, 0x10, %g1
201e090: b5 2e a0 18 sll %i2, 0x18, %i2
201e094: b4 16 80 01 or %i2, %g1, %i2
201e098: c2 0f 60 0b ldub [ %i5 + 0xb ], %g1
201e09c: b4 16 80 01 or %i2, %g1, %i2
201e0a0: c2 0f 60 0a ldub [ %i5 + 0xa ], %g1
201e0a4: 83 28 60 08 sll %g1, 8, %g1
201e0a8: b4 16 80 01 or %i2, %g1, %i2
201e0ac: 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;
201e0b0: 40 00 41 5c call 202e620 <__muldi3>
201e0b4: 92 10 00 1a mov %i2, %o1
201e0b8: b2 10 00 08 mov %o0, %i1
201e0bc: 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))
201e0c0: 7f ff ff 53 call 201de0c <rtems_rfs_fs_media_size>
201e0c4: 90 10 00 1b mov %i3, %o0
201e0c8: 80 a6 40 08 cmp %i1, %o0
201e0cc: 38 80 00 08 bgu,a 201e0ec <rtems_rfs_fs_open+0x2b8> <== NEVER TAKEN
201e0d0: 90 10 20 00 clr %o0 <== NOT EXECUTED
201e0d4: 32 80 00 11 bne,a 201e118 <rtems_rfs_fs_open+0x2e4> <== NEVER TAKEN
201e0d8: c4 0f 60 24 ldub [ %i5 + 0x24 ], %g2 <== NOT EXECUTED
201e0dc: 80 a6 00 09 cmp %i0, %o1
201e0e0: 28 80 00 0e bleu,a 201e118 <rtems_rfs_fs_open+0x2e4> <== ALWAYS TAKEN
201e0e4: c4 0f 60 24 ldub [ %i5 + 0x24 ], %g2
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
201e0e8: 90 10 20 00 clr %o0 <== NOT EXECUTED
201e0ec: 7f ff d5 b9 call 20137d0 <rtems_rfs_trace> <== NOT EXECUTED
201e0f0: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
201e0f4: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
201e0f8: 22 80 00 29 be,a 201e19c <rtems_rfs_fs_open+0x368> <== NOT EXECUTED
201e0fc: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
printf ("rtems-rfs: read-superblock: invalid superblock block/size count\n");
201e100: 11 00 80 d2 sethi %hi(0x2034800), %o0 <== NOT EXECUTED
201e104: 90 12 20 78 or %o0, 0x78, %o0 ! 2034878 <CSWTCH.2+0x1198> <== NOT EXECUTED
201e108: 40 00 10 94 call 2022358 <puts> <== NOT EXECUTED
201e10c: 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);
201e110: 10 80 00 23 b 201e19c <rtems_rfs_fs_open+0x368> <== NOT EXECUTED
201e114: 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)
201e118: c2 0f 60 25 ldub [ %i5 + 0x25 ], %g1
201e11c: 85 28 a0 18 sll %g2, 0x18, %g2
201e120: 83 28 60 10 sll %g1, 0x10, %g1
201e124: 82 10 80 01 or %g2, %g1, %g1
201e128: c4 0f 60 27 ldub [ %i5 + 0x27 ], %g2
201e12c: 82 10 40 02 or %g1, %g2, %g1
201e130: c4 0f 60 26 ldub [ %i5 + 0x26 ], %g2
201e134: 85 28 a0 08 sll %g2, 8, %g2
201e138: 82 10 40 02 or %g1, %g2, %g1
201e13c: 80 a0 60 38 cmp %g1, 0x38
201e140: 22 80 00 1b be,a 201e1ac <rtems_rfs_fs_open+0x378> <== ALWAYS TAKEN
201e144: c4 0f 60 10 ldub [ %i5 + 0x10 ], %g2
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
201e148: 90 10 20 00 clr %o0 <== NOT EXECUTED
201e14c: 7f ff d5 a1 call 20137d0 <rtems_rfs_trace> <== NOT EXECUTED
201e150: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
201e154: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
201e158: 22 80 00 11 be,a 201e19c <rtems_rfs_fs_open+0x368> <== NOT EXECUTED
201e15c: 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);
201e160: c2 0f 60 05 ldub [ %i5 + 5 ], %g1 <== NOT EXECUTED
201e164: d2 0f 60 04 ldub [ %i5 + 4 ], %o1 <== NOT EXECUTED
201e168: 83 28 60 10 sll %g1, 0x10, %g1 <== NOT EXECUTED
201e16c: 93 2a 60 18 sll %o1, 0x18, %o1 <== NOT EXECUTED
201e170: 92 12 40 01 or %o1, %g1, %o1 <== NOT EXECUTED
201e174: 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",
201e178: 11 00 80 d2 sethi %hi(0x2034800), %o0 <== NOT EXECUTED
read_sb (RTEMS_RFS_SB_OFFSET_VERSION), RTEMS_RFS_VERSION_MASK);
201e17c: 92 12 40 01 or %o1, %g1, %o1 <== NOT EXECUTED
201e180: 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",
201e184: 90 12 20 b8 or %o0, 0xb8, %o0 <== NOT EXECUTED
read_sb (RTEMS_RFS_SB_OFFSET_VERSION), RTEMS_RFS_VERSION_MASK);
201e188: 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",
201e18c: 94 10 20 00 clr %o2 <== NOT EXECUTED
201e190: 40 00 0f da call 20220f8 <printf> <== NOT EXECUTED
201e194: 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);
201e198: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
201e19c: 92 07 bf cc add %fp, -52, %o1 <== NOT EXECUTED
201e1a0: 7f ff ff 08 call 201ddc0 <rtems_rfs_buffer_handle_close> <== NOT EXECUTED
201e1a4: ba 10 20 05 mov 5, %i5 <== NOT EXECUTED
201e1a8: 30 80 00 b8 b,a 201e488 <rtems_rfs_fs_open+0x654> <== NOT EXECUTED
return EIO;
}
fs->bad_blocks = read_sb (RTEMS_RFS_SB_OFFSET_BAD_BLOCKS);
201e1ac: c2 0f 60 11 ldub [ %i5 + 0x11 ], %g1
201e1b0: 85 28 a0 18 sll %g2, 0x18, %g2
201e1b4: 83 28 60 10 sll %g1, 0x10, %g1
201e1b8: 82 10 80 01 or %g2, %g1, %g1
201e1bc: 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);
201e1c0: 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);
201e1c4: 82 10 40 02 or %g1, %g2, %g1
201e1c8: 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;
201e1cc: 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);
201e1d0: 85 28 a0 08 sll %g2, 8, %g2
201e1d4: 82 10 40 02 or %g1, %g2, %g1
201e1d8: c2 26 e0 18 st %g1, [ %i3 + 0x18 ]
fs->max_name_length = read_sb (RTEMS_RFS_SB_OFFSET_MAX_NAME_LENGTH);
201e1dc: c4 0f 60 14 ldub [ %i5 + 0x14 ], %g2
201e1e0: c2 0f 60 15 ldub [ %i5 + 0x15 ], %g1
201e1e4: 85 28 a0 18 sll %g2, 0x18, %g2
201e1e8: 83 28 60 10 sll %g1, 0x10, %g1
201e1ec: 82 10 80 01 or %g2, %g1, %g1
201e1f0: c4 0f 60 17 ldub [ %i5 + 0x17 ], %g2
201e1f4: 82 10 40 02 or %g1, %g2, %g1
201e1f8: c4 0f 60 16 ldub [ %i5 + 0x16 ], %g2
201e1fc: 85 28 a0 08 sll %g2, 8, %g2
201e200: 82 10 40 02 or %g1, %g2, %g1
201e204: c2 26 e0 1c st %g1, [ %i3 + 0x1c ]
fs->group_count = read_sb (RTEMS_RFS_SB_OFFSET_GROUPS);
201e208: c2 0f 60 19 ldub [ %i5 + 0x19 ], %g1
201e20c: f0 0f 60 18 ldub [ %i5 + 0x18 ], %i0
201e210: 83 28 60 10 sll %g1, 0x10, %g1
201e214: b1 2e 20 18 sll %i0, 0x18, %i0
201e218: b0 16 00 01 or %i0, %g1, %i0
201e21c: c2 0f 60 1b ldub [ %i5 + 0x1b ], %g1
201e220: b0 16 00 01 or %i0, %g1, %i0
201e224: c2 0f 60 1a ldub [ %i5 + 0x1a ], %g1
201e228: 83 28 60 08 sll %g1, 8, %g1
201e22c: b0 16 00 01 or %i0, %g1, %i0
201e230: f0 26 e0 24 st %i0, [ %i3 + 0x24 ]
fs->group_blocks = read_sb (RTEMS_RFS_SB_OFFSET_GROUP_BLOCKS);
201e234: c2 0f 60 1d ldub [ %i5 + 0x1d ], %g1
201e238: f2 0f 60 1c ldub [ %i5 + 0x1c ], %i1
201e23c: 83 28 60 10 sll %g1, 0x10, %g1
201e240: b3 2e 60 18 sll %i1, 0x18, %i1
201e244: b2 16 40 01 or %i1, %g1, %i1
201e248: c2 0f 60 1f ldub [ %i5 + 0x1f ], %g1
201e24c: b2 16 40 01 or %i1, %g1, %i1
201e250: c2 0f 60 1e ldub [ %i5 + 0x1e ], %g1
201e254: 83 28 60 08 sll %g1, 8, %g1
201e258: b2 16 40 01 or %i1, %g1, %i1
201e25c: f2 26 e0 28 st %i1, [ %i3 + 0x28 ]
fs->group_inodes = read_sb (RTEMS_RFS_SB_OFFSET_GROUP_INODES);
201e260: c2 0f 60 21 ldub [ %i5 + 0x21 ], %g1
201e264: c4 0f 60 20 ldub [ %i5 + 0x20 ], %g2
201e268: 83 28 60 10 sll %g1, 0x10, %g1
201e26c: 85 28 a0 18 sll %g2, 0x18, %g2
201e270: 84 10 80 01 or %g2, %g1, %g2
201e274: c2 0f 60 23 ldub [ %i5 + 0x23 ], %g1
201e278: 84 10 80 01 or %g2, %g1, %g2
201e27c: c2 0f 60 22 ldub [ %i5 + 0x22 ], %g1
fs->blocks_per_block =
201e280: 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);
201e284: 83 28 60 08 sll %g1, 8, %g1
201e288: 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;
201e28c: 85 2a 20 02 sll %o0, 2, %g2
201e290: 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);
201e294: 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;
201e298: 7f ff 90 bf call 2002594 <.umul>
201e29c: c4 26 e0 38 st %g2, [ %i3 + 0x38 ]
201e2a0: 83 2a 20 02 sll %o0, 2, %g1
201e2a4: 90 00 40 08 add %g1, %o0, %o0
fs->inodes = fs->group_count * fs->group_inodes;
201e2a8: 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 =
201e2ac: 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;
201e2b0: 7f ff 90 b9 call 2002594 <.umul>
201e2b4: 90 10 00 1d mov %i5, %o0
fs->inodes_per_block = fs->block_size / RTEMS_RFS_INODE_SIZE;
201e2b8: 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;
201e2bc: d0 26 e0 14 st %o0, [ %i3 + 0x14 ]
fs->inodes_per_block = fs->block_size / RTEMS_RFS_INODE_SIZE;
201e2c0: 7f ff 90 ef call 200267c <.udiv>
201e2c4: 90 10 00 1a mov %i2, %o0
201e2c8: d0 26 e0 30 st %o0, [ %i3 + 0x30 ]
if (fs->group_blocks >
rtems_rfs_bitmap_numof_bits (rtems_rfs_fs_block_size (fs)))
201e2cc: b5 2e a0 03 sll %i2, 3, %i2
{
rtems_rfs_buffer_handle_close (fs, &handle);
201e2d0: 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 >
201e2d4: 80 a6 40 1a cmp %i1, %i2
201e2d8: 08 80 00 0c bleu 201e308 <rtems_rfs_fs_open+0x4d4> <== ALWAYS TAKEN
201e2dc: 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);
201e2e0: 7f ff fe b8 call 201ddc0 <rtems_rfs_buffer_handle_close> <== NOT EXECUTED
201e2e4: ba 10 20 05 mov 5, %i5 <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
201e2e8: 90 10 20 00 clr %o0 <== NOT EXECUTED
201e2ec: 7f ff d5 39 call 20137d0 <rtems_rfs_trace> <== NOT EXECUTED
201e2f0: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
201e2f4: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
201e2f8: 02 80 00 64 be 201e488 <rtems_rfs_fs_open+0x654> <== NOT EXECUTED
201e2fc: 11 00 80 d2 sethi %hi(0x2034800), %o0 <== NOT EXECUTED
printf ("rtems-rfs: read-superblock: groups blocks larger than block bits\n");
201e300: 10 80 00 2e b 201e3b8 <rtems_rfs_fs_open+0x584> <== NOT EXECUTED
201e304: 90 12 21 00 or %o0, 0x100, %o0 ! 2034900 <CSWTCH.2+0x1220><== NOT EXECUTED
return EIO;
}
rtems_rfs_buffer_handle_close (fs, &handle);
201e308: 7f ff fe ae call 201ddc0 <rtems_rfs_buffer_handle_close>
201e30c: 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));
201e310: d2 06 e0 08 ld [ %i3 + 8 ], %o1
201e314: 7f ff f5 eb call 201bac0 <rtems_rfs_buffer_setblksize>
201e318: 90 10 00 1b mov %i3, %o0
if (rc > 0)
201e31c: ba 92 20 00 orcc %o0, 0, %i5
201e320: 04 80 00 13 ble 201e36c <rtems_rfs_fs_open+0x538> <== ALWAYS TAKEN
201e324: 92 07 bf cc add %fp, -52, %o1
{
rtems_rfs_buffer_handle_close (fs, &handle);
201e328: 7f ff fe a6 call 201ddc0 <rtems_rfs_buffer_handle_close> <== NOT EXECUTED
201e32c: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
201e330: 90 10 20 00 clr %o0 <== NOT EXECUTED
201e334: 7f ff d5 27 call 20137d0 <rtems_rfs_trace> <== NOT EXECUTED
201e338: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
201e33c: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
201e340: 22 80 00 50 be,a 201e480 <rtems_rfs_fs_open+0x64c> <== NOT EXECUTED
201e344: 80 a7 60 00 cmp %i5, 0 <== NOT EXECUTED
printf ("rtems-rfs: read-superblock: invalid superblock block size%d: %s\n",
201e348: 40 00 13 db call 20232b4 <strerror> <== NOT EXECUTED
201e34c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
201e350: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
201e354: 11 00 80 d2 sethi %hi(0x2034800), %o0 <== NOT EXECUTED
201e358: 90 12 21 48 or %o0, 0x148, %o0 ! 2034948 <CSWTCH.2+0x1268><== NOT EXECUTED
201e35c: 40 00 0f 67 call 20220f8 <printf> <== NOT EXECUTED
201e360: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
errno = rc;
return -1;
}
rc = rtems_rfs_fs_read_superblock (*fs);
if (rc > 0)
201e364: 10 80 00 47 b 201e480 <rtems_rfs_fs_open+0x64c> <== NOT EXECUTED
201e368: 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));
201e36c: d0 06 e0 24 ld [ %i3 + 0x24 ], %o0
201e370: 7f ff a6 ad call 2007e24 <calloc>
201e374: 92 10 20 50 mov 0x50, %o1
201e378: d0 26 e0 20 st %o0, [ %i3 + 0x20 ]
if (!fs->groups)
201e37c: b2 10 20 00 clr %i1
201e380: 80 a2 20 00 cmp %o0, 0
201e384: 12 80 00 39 bne 201e468 <rtems_rfs_fs_open+0x634> <== ALWAYS TAKEN
201e388: b4 10 20 00 clr %i2
{
rtems_rfs_buffer_handle_close (fs, &handle);
201e38c: 92 07 bf cc add %fp, -52, %o1 <== NOT EXECUTED
201e390: 7f ff fe 8c call 201ddc0 <rtems_rfs_buffer_handle_close> <== NOT EXECUTED
201e394: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
201e398: 90 10 20 00 clr %o0 <== NOT EXECUTED
201e39c: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
201e3a0: 7f ff d5 0c call 20137d0 <rtems_rfs_trace> <== NOT EXECUTED
201e3a4: ba 10 20 0c mov 0xc, %i5 <== NOT EXECUTED
201e3a8: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
201e3ac: 02 80 00 37 be 201e488 <rtems_rfs_fs_open+0x654> <== NOT EXECUTED
201e3b0: 11 00 80 d2 sethi %hi(0x2034800), %o0 <== NOT EXECUTED
printf ("rtems-rfs: read-superblock: no memory for group table\n");
201e3b4: 90 12 21 90 or %o0, 0x190, %o0 ! 2034990 <CSWTCH.2+0x12b0><== NOT EXECUTED
201e3b8: 40 00 0f e8 call 2022358 <puts> <== NOT EXECUTED
201e3bc: 01 00 00 00 nop <== NOT EXECUTED
201e3c0: 30 80 00 32 b,a 201e488 <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),
201e3c4: 90 10 00 1a mov %i2, %o0
201e3c8: 7f ff 90 73 call 2002594 <.umul>
201e3cc: 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,
201e3d0: d8 06 e0 20 ld [ %i3 + 0x20 ], %o4
201e3d4: d6 06 e0 2c ld [ %i3 + 0x2c ], %o3
rtems_rfs_fs_block (fs, group, 0),
201e3d8: 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,
201e3dc: 94 10 00 1d mov %i5, %o2
201e3e0: 98 03 00 19 add %o4, %i1, %o4
201e3e4: 90 10 00 1b mov %i3, %o0
201e3e8: 7f ff cc 72 call 20115b0 <rtems_rfs_group_open>
201e3ec: 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)
201e3f0: 80 a2 20 00 cmp %o0, 0
201e3f4: 04 80 00 1c ble 201e464 <rtems_rfs_fs_open+0x630> <== ALWAYS TAKEN
201e3f8: ba 10 00 08 mov %o0, %i5
201e3fc: b0 10 20 00 clr %i0 <== NOT EXECUTED
201e400: 10 80 00 07 b 201e41c <rtems_rfs_fs_open+0x5e8> <== NOT EXECUTED
201e404: b2 10 20 00 clr %i1 <== NOT EXECUTED
{
int g;
for (g = 0; g < group; g++)
rtems_rfs_group_close (fs, &fs->groups[g]);
201e408: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
201e40c: 92 02 40 18 add %o1, %i0, %o1 <== NOT EXECUTED
201e410: 7f ff cc e6 call 20117a8 <rtems_rfs_group_close> <== NOT EXECUTED
201e414: b2 06 60 01 inc %i1 <== NOT EXECUTED
201e418: 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++)
201e41c: 80 a6 40 1a cmp %i1, %i2 <== NOT EXECUTED
201e420: 26 bf ff fa bl,a 201e408 <rtems_rfs_fs_open+0x5d4> <== NOT EXECUTED
201e424: 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);
201e428: 92 07 bf cc add %fp, -52, %o1 <== NOT EXECUTED
201e42c: 7f ff fe 65 call 201ddc0 <rtems_rfs_buffer_handle_close> <== NOT EXECUTED
201e430: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
201e434: 90 10 20 00 clr %o0 <== NOT EXECUTED
201e438: 7f ff d4 e6 call 20137d0 <rtems_rfs_trace> <== NOT EXECUTED
201e43c: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
201e440: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
201e444: 22 80 00 0f be,a 201e480 <rtems_rfs_fs_open+0x64c> <== NOT EXECUTED
201e448: 80 a7 60 00 cmp %i5, 0 <== NOT EXECUTED
printf ("rtems-rfs: read-superblock: no memory for group table%d: %s\n",
201e44c: 40 00 13 9a call 20232b4 <strerror> <== NOT EXECUTED
201e450: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
201e454: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
201e458: 11 00 80 d2 sethi %hi(0x2034800), %o0 <== NOT EXECUTED
201e45c: 10 bf ff c0 b 201e35c <rtems_rfs_fs_open+0x528> <== NOT EXECUTED
201e460: 90 12 21 c8 or %o0, 0x1c8, %o0 ! 20349c8 <CSWTCH.2+0x12e8><== 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++)
201e464: b4 06 a0 01 inc %i2
201e468: c2 06 e0 24 ld [ %i3 + 0x24 ], %g1
201e46c: 80 a6 80 01 cmp %i2, %g1
201e470: 26 bf ff d5 bl,a 201e3c4 <rtems_rfs_fs_open+0x590>
201e474: 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);
201e478: 10 80 00 14 b 201e4c8 <rtems_rfs_fs_open+0x694>
201e47c: d0 07 00 00 ld [ %i4 ], %o0
errno = rc;
return -1;
}
rc = rtems_rfs_fs_read_superblock (*fs);
if (rc > 0)
201e480: 22 80 00 12 be,a 201e4c8 <rtems_rfs_fs_open+0x694> <== NOT EXECUTED
201e484: d0 07 00 00 ld [ %i4 ], %o0 <== NOT EXECUTED
{
rtems_rfs_buffer_close (*fs);
201e488: 7f ff f5 c9 call 201bbac <rtems_rfs_buffer_close> <== NOT EXECUTED
201e48c: d0 07 00 00 ld [ %i4 ], %o0 <== NOT EXECUTED
free (*fs);
201e490: 7f ff a7 66 call 2008228 <free> <== NOT EXECUTED
201e494: d0 07 00 00 ld [ %i4 ], %o0 <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
201e498: 90 10 20 00 clr %o0 <== NOT EXECUTED
201e49c: 7f ff d4 cd call 20137d0 <rtems_rfs_trace> <== NOT EXECUTED
201e4a0: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
201e4a4: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
201e4a8: 02 bf fe b6 be 201df80 <rtems_rfs_fs_open+0x14c> <== NOT EXECUTED
201e4ac: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: open: reading superblock: %d: %s\n",
201e4b0: 40 00 13 81 call 20232b4 <strerror> <== NOT EXECUTED
201e4b4: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
201e4b8: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
201e4bc: 11 00 80 d2 sethi %hi(0x2034800), %o0 <== NOT EXECUTED
201e4c0: 10 bf fe ae b 201df78 <rtems_rfs_fs_open+0x144> <== NOT EXECUTED
201e4c4: 90 12 22 08 or %o0, 0x208, %o0 ! 2034a08 <CSWTCH.2+0x1328><== NOT EXECUTED
rc, strerror (rc));
errno = rc;
return -1;
}
rc = rtems_rfs_inode_open (*fs, RTEMS_RFS_ROOT_INO, &inode, true);
201e4c8: 92 10 20 01 mov 1, %o1
201e4cc: 94 07 bf d8 add %fp, -40, %o2
201e4d0: 7f ff ce 2f call 2011d8c <rtems_rfs_inode_open>
201e4d4: 96 10 20 01 mov 1, %o3
if (rc > 0)
201e4d8: ba 92 20 00 orcc %o0, 0, %i5
201e4dc: 04 80 00 12 ble 201e524 <rtems_rfs_fs_open+0x6f0> <== ALWAYS TAKEN
201e4e0: d0 07 00 00 ld [ %i4 ], %o0
{
rtems_rfs_buffer_close (*fs);
201e4e4: 7f ff f5 b2 call 201bbac <rtems_rfs_buffer_close> <== NOT EXECUTED
201e4e8: 01 00 00 00 nop <== NOT EXECUTED
free (*fs);
201e4ec: 7f ff a7 4f call 2008228 <free> <== NOT EXECUTED
201e4f0: d0 07 00 00 ld [ %i4 ], %o0 <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
201e4f4: 90 10 20 00 clr %o0 <== NOT EXECUTED
201e4f8: 7f ff d4 b6 call 20137d0 <rtems_rfs_trace> <== NOT EXECUTED
201e4fc: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
201e500: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
201e504: 02 bf fe 9f be 201df80 <rtems_rfs_fs_open+0x14c> <== NOT EXECUTED
201e508: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: open: reading root inode: %d: %s\n",
201e50c: 40 00 13 6a call 20232b4 <strerror> <== NOT EXECUTED
201e510: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
201e514: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
201e518: 11 00 80 d2 sethi %hi(0x2034800), %o0 <== NOT EXECUTED
201e51c: 10 bf fe 97 b 201df78 <rtems_rfs_fs_open+0x144> <== NOT EXECUTED
201e520: 90 12 22 38 or %o0, 0x238, %o0 ! 2034a38 <CSWTCH.2+0x1358><== NOT EXECUTED
rc, strerror (rc));
errno = rc;
return -1;
}
if (((*fs)->flags & RTEMS_RFS_FS_FORCE_OPEN) == 0)
201e524: c2 02 00 00 ld [ %o0 ], %g1
201e528: 80 88 60 04 btst 4, %g1
201e52c: 12 80 00 23 bne 201e5b8 <rtems_rfs_fs_open+0x784>
201e530: 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);
201e534: c2 08 a0 02 ldub [ %g2 + 2 ], %g1
201e538: c4 08 a0 03 ldub [ %g2 + 3 ], %g2
201e53c: 83 28 60 08 sll %g1, 8, %g1
201e540: 82 10 40 02 or %g1, %g2, %g1
{
mode = rtems_rfs_inode_get_mode (&inode);
if ((mode == 0xffff) || !RTEMS_RFS_S_ISDIR (mode))
201e544: 05 3f ff c0 sethi %hi(0xffff0000), %g2
201e548: 87 28 60 10 sll %g1, 0x10, %g3
201e54c: 80 a0 c0 02 cmp %g3, %g2
201e550: 02 80 00 07 be 201e56c <rtems_rfs_fs_open+0x738> <== NEVER TAKEN
201e554: 05 00 00 3c sethi %hi(0xf000), %g2
201e558: 82 08 40 02 and %g1, %g2, %g1
201e55c: 05 00 00 10 sethi %hi(0x4000), %g2
201e560: 80 a0 40 02 cmp %g1, %g2
201e564: 02 80 00 15 be 201e5b8 <rtems_rfs_fs_open+0x784> <== ALWAYS TAKEN
201e568: 01 00 00 00 nop
{
rtems_rfs_inode_close (*fs, &inode);
201e56c: 7f ff ce 7a call 2011f54 <rtems_rfs_inode_close> <== NOT EXECUTED
201e570: 92 07 bf d8 add %fp, -40, %o1 <== NOT EXECUTED
rtems_rfs_buffer_close (*fs);
201e574: 7f ff f5 8e call 201bbac <rtems_rfs_buffer_close> <== NOT EXECUTED
201e578: d0 07 00 00 ld [ %i4 ], %o0 <== NOT EXECUTED
free (*fs);
201e57c: 7f ff a7 2b call 2008228 <free> <== NOT EXECUTED
201e580: d0 07 00 00 ld [ %i4 ], %o0 <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
201e584: 90 10 20 00 clr %o0 <== NOT EXECUTED
201e588: 7f ff d4 92 call 20137d0 <rtems_rfs_trace> <== NOT EXECUTED
201e58c: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
201e590: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
201e594: 02 80 00 04 be 201e5a4 <rtems_rfs_fs_open+0x770> <== NOT EXECUTED
201e598: 11 00 80 d2 sethi %hi(0x2034800), %o0 <== NOT EXECUTED
printf ("rtems-rfs: open: invalid root inode mode\n");
201e59c: 40 00 0f 6f call 2022358 <puts> <== NOT EXECUTED
201e5a0: 90 12 22 68 or %o0, 0x268, %o0 ! 2034a68 <CSWTCH.2+0x1388><== NOT EXECUTED
errno = EIO;
201e5a4: 40 00 09 86 call 2020bbc <__errno> <== NOT EXECUTED
201e5a8: 01 00 00 00 nop <== NOT EXECUTED
201e5ac: 82 10 20 05 mov 5, %g1 ! 5 <PROM_START+0x5> <== NOT EXECUTED
201e5b0: 10 bf fe 77 b 201df8c <rtems_rfs_fs_open+0x158> <== NOT EXECUTED
201e5b4: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
return -1;
}
}
rc = rtems_rfs_inode_close (*fs, &inode);
201e5b8: 7f ff ce 67 call 2011f54 <rtems_rfs_inode_close>
201e5bc: 92 07 bf d8 add %fp, -40, %o1
if (rc > 0)
201e5c0: ba 92 20 00 orcc %o0, 0, %i5
201e5c4: 04 80 00 12 ble 201e60c <rtems_rfs_fs_open+0x7d8> <== ALWAYS TAKEN
201e5c8: 01 00 00 00 nop
{
rtems_rfs_buffer_close (*fs);
201e5cc: 7f ff f5 78 call 201bbac <rtems_rfs_buffer_close> <== NOT EXECUTED
201e5d0: d0 07 00 00 ld [ %i4 ], %o0 <== NOT EXECUTED
free (*fs);
201e5d4: 7f ff a7 15 call 2008228 <free> <== NOT EXECUTED
201e5d8: d0 07 00 00 ld [ %i4 ], %o0 <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
201e5dc: 90 10 20 00 clr %o0 <== NOT EXECUTED
201e5e0: 7f ff d4 7c call 20137d0 <rtems_rfs_trace> <== NOT EXECUTED
201e5e4: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
201e5e8: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
201e5ec: 02 bf fe 65 be 201df80 <rtems_rfs_fs_open+0x14c> <== NOT EXECUTED
201e5f0: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: open: closing root inode: %d: %s\n", rc, strerror (rc));
201e5f4: 40 00 13 30 call 20232b4 <strerror> <== NOT EXECUTED
201e5f8: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
201e5fc: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
201e600: 11 00 80 d2 sethi %hi(0x2034800), %o0 <== NOT EXECUTED
201e604: 10 bf fe 5d b 201df78 <rtems_rfs_fs_open+0x144> <== NOT EXECUTED
201e608: 90 12 22 98 or %o0, 0x298, %o0 ! 2034a98 <CSWTCH.2+0x13b8><== NOT EXECUTED
errno = rc;
return -1;
}
errno = 0;
201e60c: 40 00 09 6c call 2020bbc <__errno>
201e610: b0 10 20 00 clr %i0
201e614: c0 22 00 00 clr [ %o0 ]
return 0;
}
201e618: 81 c7 e0 08 ret
201e61c: 81 e8 00 00 restore
0201dde8 <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)
{
201dde8: 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;
201ddec: d2 06 20 08 ld [ %i0 + 8 ], %o1 <== NOT EXECUTED
201ddf0: d6 06 20 04 ld [ %i0 + 4 ], %o3 <== NOT EXECUTED
201ddf4: 94 10 20 00 clr %o2 <== NOT EXECUTED
201ddf8: 40 00 42 0a call 202e620 <__muldi3> <== NOT EXECUTED
201ddfc: 90 10 20 00 clr %o0 <== NOT EXECUTED
}
201de00: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED
201de04: 81 c7 e0 08 ret <== NOT EXECUTED
201de08: 93 e8 00 09 restore %g0, %o1, %o1 <== NOT EXECUTED
02011838 <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)
{
2011838: 9d e3 bf 98 save %sp, -104, %sp
rtems_rfs_bitmap_bit bit;
int offset;
bool updown;
int direction;
if (inode)
201183c: 80 a6 a0 00 cmp %i2, 0
2011840: 02 80 00 05 be 2011854 <rtems_rfs_group_bitmap_alloc+0x1c>
2011844: ba 10 00 18 mov %i0, %i5
{
size = fs->group_inodes;
2011848: e2 06 20 2c ld [ %i0 + 0x2c ], %l1
goal -= RTEMS_RFS_ROOT_INO;
201184c: 10 80 00 03 b 2011858 <rtems_rfs_group_bitmap_alloc+0x20>
2011850: b2 06 7f ff add %i1, -1, %i1
}
else
size = fs->group_blocks;
2011854: e2 06 20 28 ld [ %i0 + 0x28 ], %l1
group_start = goal / size;
2011858: 92 10 00 11 mov %l1, %o1
201185c: 7f ff c3 88 call 200267c <.udiv>
2011860: 90 10 00 19 mov %i1, %o0
bit = (rtems_rfs_bitmap_bit) (goal % size);
2011864: 92 10 00 11 mov %l1, %o1
goal -= RTEMS_RFS_ROOT_INO;
}
else
size = fs->group_blocks;
group_start = goal / size;
2011868: a8 10 00 08 mov %o0, %l4
bit = (rtems_rfs_bitmap_bit) (goal % size);
offset = 0;
updown = true;
direction = 1;
201186c: b8 10 20 01 mov 1, %i4
}
else
size = fs->group_blocks;
group_start = goal / size;
bit = (rtems_rfs_bitmap_bit) (goal % size);
2011870: 90 10 00 19 mov %i1, %o0
2011874: 40 00 72 bf call 202e370 <.urem>
2011878: a4 10 20 01 mov 1, %l2
offset = 0;
201187c: a0 10 20 00 clr %l0
}
else
size = fs->group_blocks;
group_start = goal / size;
bit = (rtems_rfs_bitmap_bit) (goal % size);
2011880: d0 27 bf fc st %o0, [ %fp + -4 ]
*/
while (true)
{
rtems_rfs_bitmap_control* bitmap;
int group;
bool allocated = false;
2011884: 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);
2011888: 90 10 00 1c mov %i4, %o0
201188c: 7f ff c3 42 call 2002594 <.umul>
2011890: 92 10 00 10 mov %l0, %o1
if (offset)
2011894: 80 a4 20 00 cmp %l0, 0
2011898: 02 80 00 07 be 20118b4 <rtems_rfs_group_bitmap_alloc+0x7c>
201189c: b2 05 00 08 add %l4, %o0, %i1
bit = direction > 0 ? 0 : size - 1;
20118a0: 80 a7 20 00 cmp %i4, 0
20118a4: 14 80 00 03 bg 20118b0 <rtems_rfs_group_bitmap_alloc+0x78>
20118a8: 82 10 20 00 clr %g1
20118ac: 82 04 7f ff add %l1, -1, %g1
20118b0: 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))
20118b4: 80 a6 60 00 cmp %i1, 0
20118b8: 06 80 00 07 bl 20118d4 <rtems_rfs_group_bitmap_alloc+0x9c>
20118bc: 80 8c a0 ff btst 0xff, %l2
20118c0: c2 07 60 24 ld [ %i5 + 0x24 ], %g1
20118c4: 80 a6 40 01 cmp %i1, %g1
20118c8: 26 80 00 0a bl,a 20118f0 <rtems_rfs_group_bitmap_alloc+0xb8>
20118cc: c2 07 60 20 ld [ %i5 + 0x20 ], %g1
{
if (!updown)
20118d0: 80 8c a0 ff btst 0xff, %l2
20118d4: 02 80 00 50 be 2011a14 <rtems_rfs_group_bitmap_alloc+0x1dc>
20118d8: 80 a7 20 00 cmp %i4, 0
break;
direction = direction > 0 ? -1 : 1;
20118dc: 24 80 00 03 ble,a 20118e8 <rtems_rfs_group_bitmap_alloc+0xb0><== ALWAYS TAKEN
20118e0: b8 10 20 01 mov 1, %i4
20118e4: b8 10 3f ff mov -1, %i4 <== NOT EXECUTED
updown = false;
20118e8: 10 bf ff e7 b 2011884 <rtems_rfs_group_bitmap_alloc+0x4c>
20118ec: a4 10 20 00 clr %l2
20118f0: a7 2e 60 04 sll %i1, 4, %l3
20118f4: 85 2e 60 06 sll %i1, 6, %g2
continue;
}
if (inode)
20118f8: 80 a6 a0 00 cmp %i2, 0
bitmap = &fs->groups[group].inode_bitmap;
20118fc: a6 04 c0 02 add %l3, %g2, %l3
direction = direction > 0 ? -1 : 1;
updown = false;
continue;
}
if (inode)
2011900: 02 80 00 04 be 2011910 <rtems_rfs_group_bitmap_alloc+0xd8>
2011904: a6 00 40 13 add %g1, %l3, %l3
bitmap = &fs->groups[group].inode_bitmap;
2011908: 10 80 00 03 b 2011914 <rtems_rfs_group_bitmap_alloc+0xdc>
201190c: a6 04 e0 2c add %l3, 0x2c, %l3
else
bitmap = &fs->groups[group].block_bitmap;
2011910: a6 04 e0 08 add %l3, 8, %l3
rc = rtems_rfs_bitmap_map_alloc (bitmap, bit, &allocated, &bit);
2011914: d2 07 bf fc ld [ %fp + -4 ], %o1
2011918: 90 10 00 13 mov %l3, %o0
201191c: 94 07 bf fb add %fp, -5, %o2
2011920: 40 00 21 a6 call 2019fb8 <rtems_rfs_bitmap_map_alloc>
2011924: 96 07 bf fc add %fp, -4, %o3
if (rc > 0)
2011928: b0 92 20 00 orcc %o0, 0, %i0
201192c: 14 80 00 45 bg 2011a40 <rtems_rfs_group_bitmap_alloc+0x208><== NEVER TAKEN
2011930: 01 00 00 00 nop
return rc;
if (rtems_rfs_fs_release_bitmaps (fs))
2011934: c2 07 40 00 ld [ %i5 ], %g1
2011938: 80 88 60 01 btst 1, %g1
201193c: 12 80 00 06 bne 2011954 <rtems_rfs_group_bitmap_alloc+0x11c><== NEVER TAKEN
2011940: c2 0f bf fb ldub [ %fp + -5 ], %g1
rtems_rfs_bitmap_release_buffer (fs, bitmap);
2011944: d2 04 c0 00 ld [ %l3 ], %o1
2011948: 40 00 26 a4 call 201b3d8 <rtems_rfs_buffer_handle_release>
201194c: 90 10 00 1d mov %i5, %o0
if (allocated)
2011950: c2 0f bf fb ldub [ %fp + -5 ], %g1
2011954: 80 a0 60 00 cmp %g1, 0
2011958: 02 80 00 27 be 20119f4 <rtems_rfs_group_bitmap_alloc+0x1bc>
201195c: 80 8c a0 ff btst 0xff, %l2
{
if (inode)
2011960: 80 a6 a0 00 cmp %i2, 0
2011964: 02 80 00 09 be 2011988 <rtems_rfs_group_bitmap_alloc+0x150>
2011968: c2 07 bf fc ld [ %fp + -4 ], %g1
*result = rtems_rfs_group_inode (fs, group, bit);
201196c: d2 07 60 2c ld [ %i5 + 0x2c ], %o1
2011970: b8 00 60 01 add %g1, 1, %i4
2011974: 7f ff c3 08 call 2002594 <.umul>
2011978: 90 10 00 19 mov %i1, %o0
201197c: 90 07 00 08 add %i4, %o0, %o0
2011980: 10 80 00 09 b 20119a4 <rtems_rfs_group_bitmap_alloc+0x16c>
2011984: d0 26 c0 00 st %o0, [ %i3 ]
else
*result = rtems_rfs_group_block (&fs->groups[group], bit);
2011988: c4 07 60 20 ld [ %i5 + 0x20 ], %g2
201198c: 87 2e 60 04 sll %i1, 4, %g3
2011990: b3 2e 60 06 sll %i1, 6, %i1
2011994: b2 00 c0 19 add %g3, %i1, %i1
2011998: c4 00 80 19 ld [ %g2 + %i1 ], %g2
201199c: 82 00 40 02 add %g1, %g2, %g1
20119a0: c2 26 c0 00 st %g1, [ %i3 ]
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_BITMAPS))
20119a4: 90 10 20 00 clr %o0
20119a8: 13 00 00 80 sethi %hi(0x20000), %o1
20119ac: 40 00 07 89 call 20137d0 <rtems_rfs_trace>
20119b0: b0 10 20 00 clr %i0
20119b4: 80 8a 20 ff btst 0xff, %o0
20119b8: 02 80 00 0d be 20119ec <rtems_rfs_group_bitmap_alloc+0x1b4><== ALWAYS TAKEN
20119bc: 80 a6 a0 00 cmp %i2, 0
printf ("rtems-rfs: group-bitmap-alloc: %s allocated: %" PRId32 "\n",
20119c0: 22 80 00 05 be,a 20119d4 <rtems_rfs_group_bitmap_alloc+0x19c><== NOT EXECUTED
20119c4: 13 00 80 cb sethi %hi(0x2032c00), %o1 <== NOT EXECUTED
20119c8: 13 00 80 cb sethi %hi(0x2032c00), %o1 <== NOT EXECUTED
20119cc: 10 80 00 03 b 20119d8 <rtems_rfs_group_bitmap_alloc+0x1a0><== NOT EXECUTED
20119d0: 92 12 60 48 or %o1, 0x48, %o1 ! 2032c48 <_CPU_Trap_slot_template+0xa10><== NOT EXECUTED
20119d4: 92 12 60 50 or %o1, 0x50, %o1 <== NOT EXECUTED
20119d8: d4 06 c0 00 ld [ %i3 ], %o2 <== NOT EXECUTED
20119dc: 11 00 80 cb sethi %hi(0x2032c00), %o0 <== NOT EXECUTED
inode ? "inode" : "block", *result);
return 0;
20119e0: 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",
20119e4: 40 00 41 c5 call 20220f8 <printf> <== NOT EXECUTED
20119e8: 90 12 20 58 or %o0, 0x58, %o0 <== NOT EXECUTED
20119ec: 81 c7 e0 08 ret
20119f0: 81 e8 00 00 restore
inode ? "inode" : "block", *result);
return 0;
}
if (updown)
20119f4: 22 bf ff a4 be,a 2011884 <rtems_rfs_group_bitmap_alloc+0x4c><== NEVER TAKEN
20119f8: a0 04 20 01 inc %l0 <== NOT EXECUTED
direction = direction > 0 ? -1 : 1;
20119fc: 80 a7 20 00 cmp %i4, 0
2011a00: 24 80 00 03 ble,a 2011a0c <rtems_rfs_group_bitmap_alloc+0x1d4><== NEVER TAKEN
2011a04: b8 10 20 01 mov 1, %i4 <== NOT EXECUTED
2011a08: b8 10 3f ff mov -1, %i4
offset++;
2011a0c: 10 bf ff 9e b 2011884 <rtems_rfs_group_bitmap_alloc+0x4c>
2011a10: a0 04 20 01 inc %l0
}
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_BITMAPS))
2011a14: 90 10 20 00 clr %o0
2011a18: 40 00 07 6e call 20137d0 <rtems_rfs_trace>
2011a1c: 13 00 00 80 sethi %hi(0x20000), %o1
2011a20: 80 8a 20 ff btst 0xff, %o0
2011a24: 12 80 00 04 bne 2011a34 <rtems_rfs_group_bitmap_alloc+0x1fc><== NEVER TAKEN
2011a28: 11 00 80 cb sethi %hi(0x2032c00), %o0
printf ("rtems-rfs: group-bitmap-alloc: no blocks available\n");
return ENOSPC;
2011a2c: 81 c7 e0 08 ret
2011a30: 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");
2011a34: 40 00 42 49 call 2022358 <puts> <== NOT EXECUTED
2011a38: 90 12 20 90 or %o0, 0x90, %o0 <== NOT EXECUTED
return ENOSPC;
2011a3c: b0 10 20 1c mov 0x1c, %i0 <== NOT EXECUTED
}
2011a40: 81 c7 e0 08 ret <== NOT EXECUTED
2011a44: 81 e8 00 00 restore <== NOT EXECUTED
02011a48 <rtems_rfs_group_bitmap_free>:
int
rtems_rfs_group_bitmap_free (rtems_rfs_file_system* fs,
bool inode,
rtems_rfs_bitmap_bit no)
{
2011a48: 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))
2011a4c: 90 10 20 00 clr %o0
2011a50: 13 00 00 80 sethi %hi(0x20000), %o1
2011a54: 40 00 07 5f call 20137d0 <rtems_rfs_trace>
2011a58: ba 10 00 18 mov %i0, %i5
2011a5c: 80 8a 20 ff btst 0xff, %o0
2011a60: 02 80 00 0d be 2011a94 <rtems_rfs_group_bitmap_free+0x4c> <== ALWAYS TAKEN
2011a64: 80 a6 60 00 cmp %i1, 0
printf ("rtems-rfs: group-bitmap-free: %s free: %" PRId32 "\n",
2011a68: 22 80 00 05 be,a 2011a7c <rtems_rfs_group_bitmap_free+0x34><== NOT EXECUTED
2011a6c: 13 00 80 cb sethi %hi(0x2032c00), %o1 <== NOT EXECUTED
2011a70: 13 00 80 cb sethi %hi(0x2032c00), %o1 <== NOT EXECUTED
2011a74: 10 80 00 03 b 2011a80 <rtems_rfs_group_bitmap_free+0x38> <== NOT EXECUTED
2011a78: 92 12 60 48 or %o1, 0x48, %o1 ! 2032c48 <_CPU_Trap_slot_template+0xa10><== NOT EXECUTED
2011a7c: 92 12 60 50 or %o1, 0x50, %o1 <== NOT EXECUTED
2011a80: 11 00 80 cb sethi %hi(0x2032c00), %o0 <== NOT EXECUTED
2011a84: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED
2011a88: 40 00 41 9c call 20220f8 <printf> <== NOT EXECUTED
2011a8c: 90 12 20 c8 or %o0, 0xc8, %o0 <== NOT EXECUTED
inode ? "inode" : "block", no);
if (inode)
2011a90: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED
2011a94: 02 80 00 04 be 2011aa4 <rtems_rfs_group_bitmap_free+0x5c>
2011a98: b4 06 bf ff add %i2, -1, %i2
{
no -= RTEMS_RFS_ROOT_INO;
size = fs->group_inodes;
2011a9c: 10 80 00 03 b 2011aa8 <rtems_rfs_group_bitmap_free+0x60>
2011aa0: f6 07 60 2c ld [ %i5 + 0x2c ], %i3
}
else
{
no -= RTEMS_RFS_SUPERBLOCK_SIZE;
size = fs->group_blocks;
2011aa4: f6 07 60 28 ld [ %i5 + 0x28 ], %i3
}
group = no / size;
2011aa8: 92 10 00 1b mov %i3, %o1
2011aac: 7f ff c2 f4 call 200267c <.udiv>
2011ab0: 90 10 00 1a mov %i2, %o0
bit = (rtems_rfs_bitmap_bit) (no % size);
2011ab4: 92 10 00 1b mov %i3, %o1
{
no -= RTEMS_RFS_SUPERBLOCK_SIZE;
size = fs->group_blocks;
}
group = no / size;
2011ab8: b0 10 00 08 mov %o0, %i0
bit = (rtems_rfs_bitmap_bit) (no % size);
2011abc: 40 00 72 2d call 202e370 <.urem>
2011ac0: 90 10 00 1a mov %i2, %o0
2011ac4: c2 07 60 20 ld [ %i5 + 0x20 ], %g1
2011ac8: b9 2e 20 04 sll %i0, 4, %i4
2011acc: 92 10 00 08 mov %o0, %o1
2011ad0: b1 2e 20 06 sll %i0, 6, %i0
if (inode)
2011ad4: 80 a6 60 00 cmp %i1, 0
bitmap = &fs->groups[group].inode_bitmap;
2011ad8: b8 07 00 18 add %i4, %i0, %i4
}
group = no / size;
bit = (rtems_rfs_bitmap_bit) (no % size);
if (inode)
2011adc: 02 80 00 04 be 2011aec <rtems_rfs_group_bitmap_free+0xa4>
2011ae0: b8 00 40 1c add %g1, %i4, %i4
bitmap = &fs->groups[group].inode_bitmap;
2011ae4: 10 80 00 03 b 2011af0 <rtems_rfs_group_bitmap_free+0xa8>
2011ae8: b8 07 20 2c add %i4, 0x2c, %i4
else
bitmap = &fs->groups[group].block_bitmap;
2011aec: b8 07 20 08 add %i4, 8, %i4
rc = rtems_rfs_bitmap_map_clear (bitmap, bit);
2011af0: 40 00 20 a6 call 2019d88 <rtems_rfs_bitmap_map_clear>
2011af4: 90 10 00 1c mov %i4, %o0
rtems_rfs_bitmap_release_buffer (fs, bitmap);
2011af8: 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);
2011afc: b0 10 00 08 mov %o0, %i0
rtems_rfs_bitmap_release_buffer (fs, bitmap);
2011b00: 40 00 26 36 call 201b3d8 <rtems_rfs_buffer_handle_release>
2011b04: 90 10 00 1d mov %i5, %o0
return rc;
}
2011b08: 81 c7 e0 08 ret
2011b0c: 81 e8 00 00 restore
02011b10 <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)
{
2011b10: 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))
2011b14: 90 10 20 00 clr %o0 <== NOT EXECUTED
2011b18: 13 00 00 80 sethi %hi(0x20000), %o1 <== NOT EXECUTED
2011b1c: 40 00 07 2d call 20137d0 <rtems_rfs_trace> <== NOT EXECUTED
2011b20: ba 10 00 18 mov %i0, %i5 <== NOT EXECUTED
2011b24: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
2011b28: 02 80 00 0d be 2011b5c <rtems_rfs_group_bitmap_test+0x4c> <== NOT EXECUTED
2011b2c: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED
printf ("rtems-rfs: group-bitmap-test: %s test: %" PRId32 "\n",
2011b30: 22 80 00 05 be,a 2011b44 <rtems_rfs_group_bitmap_test+0x34><== NOT EXECUTED
2011b34: 13 00 80 cb sethi %hi(0x2032c00), %o1 <== NOT EXECUTED
2011b38: 13 00 80 cb sethi %hi(0x2032c00), %o1 <== NOT EXECUTED
2011b3c: 10 80 00 03 b 2011b48 <rtems_rfs_group_bitmap_test+0x38> <== NOT EXECUTED
2011b40: 92 12 60 48 or %o1, 0x48, %o1 ! 2032c48 <_CPU_Trap_slot_template+0xa10><== NOT EXECUTED
2011b44: 92 12 60 50 or %o1, 0x50, %o1 <== NOT EXECUTED
2011b48: 11 00 80 cb sethi %hi(0x2032c00), %o0 <== NOT EXECUTED
2011b4c: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED
2011b50: 40 00 41 6a call 20220f8 <printf> <== NOT EXECUTED
2011b54: 90 12 20 f8 or %o0, 0xf8, %o0 <== NOT EXECUTED
inode ? "inode" : "block", no);
if (inode)
2011b58: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED
2011b5c: 22 80 00 0b be,a 2011b88 <rtems_rfs_group_bitmap_test+0x78><== NOT EXECUTED
2011b60: c2 07 60 04 ld [ %i5 + 4 ], %g1 <== NOT EXECUTED
{
if ((no < RTEMS_RFS_ROOT_INO) || (no > rtems_rfs_fs_inodes (fs)))
2011b64: 80 a6 a0 00 cmp %i2, 0 <== NOT EXECUTED
2011b68: 04 80 00 25 ble 2011bfc <rtems_rfs_group_bitmap_test+0xec><== NOT EXECUTED
2011b6c: b0 10 20 16 mov 0x16, %i0 <== NOT EXECUTED
2011b70: c2 07 60 14 ld [ %i5 + 0x14 ], %g1 <== NOT EXECUTED
2011b74: 80 a6 80 01 cmp %i2, %g1 <== NOT EXECUTED
2011b78: 18 80 00 21 bgu 2011bfc <rtems_rfs_group_bitmap_test+0xec><== NOT EXECUTED
2011b7c: b4 06 bf ff add %i2, -1, %i2 <== NOT EXECUTED
return EINVAL;
no -= RTEMS_RFS_ROOT_INO;
size = fs->group_inodes;
2011b80: 10 80 00 06 b 2011b98 <rtems_rfs_group_bitmap_test+0x88> <== NOT EXECUTED
2011b84: f0 07 60 2c ld [ %i5 + 0x2c ], %i0 <== NOT EXECUTED
}
else
{
if (no >= rtems_rfs_fs_blocks (fs))
2011b88: 80 a6 80 01 cmp %i2, %g1 <== NOT EXECUTED
2011b8c: 1a 80 00 1c bcc 2011bfc <rtems_rfs_group_bitmap_test+0xec><== NOT EXECUTED
2011b90: b0 10 20 16 mov 0x16, %i0 <== NOT EXECUTED
return EINVAL;
size = fs->group_blocks;
2011b94: f0 07 60 28 ld [ %i5 + 0x28 ], %i0 <== NOT EXECUTED
}
group = no / size;
2011b98: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
2011b9c: 7f ff c2 b8 call 200267c <.udiv> <== NOT EXECUTED
2011ba0: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
bit = (rtems_rfs_bitmap_bit) (no % size);
2011ba4: 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;
2011ba8: a0 10 00 08 mov %o0, %l0 <== NOT EXECUTED
bit = (rtems_rfs_bitmap_bit) (no % size);
2011bac: 40 00 71 f1 call 202e370 <.urem> <== NOT EXECUTED
2011bb0: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
2011bb4: c2 07 60 20 ld [ %i5 + 0x20 ], %g1 <== NOT EXECUTED
2011bb8: b9 2c 20 04 sll %l0, 4, %i4 <== NOT EXECUTED
2011bbc: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED
2011bc0: a1 2c 20 06 sll %l0, 6, %l0 <== NOT EXECUTED
if (inode)
2011bc4: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED
bitmap = &fs->groups[group].inode_bitmap;
2011bc8: b8 07 00 10 add %i4, %l0, %i4 <== NOT EXECUTED
}
group = no / size;
bit = (rtems_rfs_bitmap_bit) (no % size);
if (inode)
2011bcc: 02 80 00 04 be 2011bdc <rtems_rfs_group_bitmap_test+0xcc> <== NOT EXECUTED
2011bd0: b8 00 40 1c add %g1, %i4, %i4 <== NOT EXECUTED
bitmap = &fs->groups[group].inode_bitmap;
2011bd4: 10 80 00 03 b 2011be0 <rtems_rfs_group_bitmap_test+0xd0> <== NOT EXECUTED
2011bd8: b8 07 20 2c add %i4, 0x2c, %i4 <== NOT EXECUTED
else
bitmap = &fs->groups[group].block_bitmap;
2011bdc: b8 07 20 08 add %i4, 8, %i4 <== NOT EXECUTED
rc = rtems_rfs_bitmap_map_test (bitmap, bit, state);
2011be0: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
2011be4: 40 00 20 8c call 2019e14 <rtems_rfs_bitmap_map_test> <== NOT EXECUTED
2011be8: 94 10 00 1b mov %i3, %o2 <== NOT EXECUTED
rtems_rfs_bitmap_release_buffer (fs, bitmap);
2011bec: 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);
2011bf0: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED
rtems_rfs_bitmap_release_buffer (fs, bitmap);
2011bf4: 40 00 25 f9 call 201b3d8 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
2011bf8: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
return rc;
}
2011bfc: 81 c7 e0 08 ret <== NOT EXECUTED
2011c00: 81 e8 00 00 restore <== NOT EXECUTED
020117a8 <rtems_rfs_group_close>:
int
rtems_rfs_group_close (rtems_rfs_file_system* fs, rtems_rfs_group* group)
{
20117a8: 9d e3 bf a0 save %sp, -96, %sp
int result = 0;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_CLOSE))
20117ac: 90 10 20 00 clr %o0
20117b0: 13 00 00 40 sethi %hi(0x10000), %o1
20117b4: 40 00 08 07 call 20137d0 <rtems_rfs_trace>
20117b8: ba 10 00 18 mov %i0, %i5
20117bc: 80 8a 20 ff btst 0xff, %o0
20117c0: 02 80 00 06 be 20117d8 <rtems_rfs_group_close+0x30> <== ALWAYS TAKEN
20117c4: 01 00 00 00 nop
printf ("rtems-rfs: group-close: base=%" PRId32 "\n", group->base);
20117c8: d2 06 40 00 ld [ %i1 ], %o1 <== NOT EXECUTED
20117cc: 11 00 80 cb sethi %hi(0x2032c00), %o0 <== NOT EXECUTED
20117d0: 40 00 42 4a call 20220f8 <printf> <== NOT EXECUTED
20117d4: 90 12 20 20 or %o0, 0x20, %o0 ! 2032c20 <_CPU_Trap_slot_template+0x9e8><== 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);
20117d8: 40 00 22 83 call 201a1e4 <rtems_rfs_bitmap_close>
20117dc: 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);
20117e0: 92 06 60 44 add %i1, 0x44, %o1
20117e4: b8 10 00 08 mov %o0, %i4
20117e8: 40 00 26 fc call 201b3d8 <rtems_rfs_buffer_handle_release>
20117ec: 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);
20117f0: 90 06 60 08 add %i1, 8, %o0
handle->dirty = false;
20117f4: c0 2e 60 44 clrb [ %i1 + 0x44 ]
handle->bnum = 0;
20117f8: c0 26 60 48 clr [ %i1 + 0x48 ]
20117fc: 40 00 22 7a call 201a1e4 <rtems_rfs_bitmap_close>
2011800: c0 26 60 4c clr [ %i1 + 0x4c ]
if (rc > 0)
2011804: b0 92 20 00 orcc %o0, 0, %i0
2011808: 14 80 00 05 bg 201181c <rtems_rfs_group_close+0x74> <== NEVER TAKEN
201180c: 90 10 00 1d mov %i5, %o0
2011810: b0 38 00 1c xnor %g0, %i4, %i0
2011814: b1 3e 20 1f sra %i0, 0x1f, %i0
2011818: 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);
201181c: 40 00 26 ef call 201b3d8 <rtems_rfs_buffer_handle_release>
2011820: 92 06 60 20 add %i1, 0x20, %o1
handle->dirty = false;
2011824: c0 2e 60 20 clrb [ %i1 + 0x20 ]
handle->bnum = 0;
2011828: c0 26 60 24 clr [ %i1 + 0x24 ]
handle->buffer = NULL;
201182c: 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;
}
2011830: 81 c7 e0 08 ret
2011834: 81 e8 00 00 restore
020115b0 <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)
{
20115b0: 9d e3 bf a0 save %sp, -96, %sp
int rc;
if (base >= rtems_rfs_fs_blocks (fs))
20115b4: c2 06 20 04 ld [ %i0 + 4 ], %g1
20115b8: 80 a6 40 01 cmp %i1, %g1
20115bc: 0a 80 00 10 bcs 20115fc <rtems_rfs_group_open+0x4c> <== ALWAYS TAKEN
20115c0: 84 06 80 19 add %i2, %i1, %g2
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_OPEN))
20115c4: 90 10 20 00 clr %o0 <== NOT EXECUTED
20115c8: 13 00 00 20 sethi %hi(0x8000), %o1 <== NOT EXECUTED
20115cc: 40 00 08 81 call 20137d0 <rtems_rfs_trace> <== NOT EXECUTED
20115d0: ba 10 20 05 mov 5, %i5 <== NOT EXECUTED
20115d4: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
20115d8: 22 80 00 72 be,a 20117a0 <rtems_rfs_group_open+0x1f0> <== NOT EXECUTED
20115dc: b0 10 00 1d mov %i5, %i0 <== NOT EXECUTED
printf ("rtems-rfs: group-open: base outside file system range: %d: %s\n",
20115e0: 40 00 47 35 call 20232b4 <strerror> <== NOT EXECUTED
20115e4: 90 10 20 05 mov 5, %o0 <== NOT EXECUTED
20115e8: 92 10 20 05 mov 5, %o1 <== NOT EXECUTED
20115ec: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
20115f0: 11 00 80 ca sethi %hi(0x2032800), %o0 <== NOT EXECUTED
20115f4: 10 80 00 36 b 20116cc <rtems_rfs_group_open+0x11c> <== NOT EXECUTED
20115f8: 90 12 23 28 or %o0, 0x328, %o0 ! 2032b28 <_CPU_Trap_slot_template+0x8f0><== NOT EXECUTED
EIO, strerror (EIO));
return EIO;
}
if ((base + size) >= rtems_rfs_fs_blocks (fs))
20115fc: 80 a0 80 01 cmp %g2, %g1
2011600: 3a 80 00 02 bcc,a 2011608 <rtems_rfs_group_open+0x58> <== ALWAYS TAKEN
2011604: b4 20 40 19 sub %g1, %i1, %i2
2011608: 80 a6 80 1b cmp %i2, %i3
201160c: 08 80 00 03 bleu 2011618 <rtems_rfs_group_open+0x68> <== NEVER TAKEN
2011610: a0 10 00 1a mov %i2, %l0
2011614: 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))
2011618: 90 10 20 00 clr %o0
201161c: 40 00 08 6d call 20137d0 <rtems_rfs_trace>
2011620: 13 00 00 20 sethi %hi(0x8000), %o1
2011624: 80 8a 20 ff btst 0xff, %o0
2011628: 22 80 00 09 be,a 201164c <rtems_rfs_group_open+0x9c> <== ALWAYS TAKEN
201162c: f2 27 00 00 st %i1, [ %i4 ]
printf ("rtems-rfs: group-open: base=%" PRId32 ", blocks=%zd inodes=%zd\n",
2011630: 11 00 80 ca sethi %hi(0x2032800), %o0 <== NOT EXECUTED
2011634: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
2011638: 90 12 23 68 or %o0, 0x368, %o0 <== NOT EXECUTED
201163c: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED
2011640: 40 00 42 ae call 20220f8 <printf> <== NOT EXECUTED
2011644: 96 10 00 10 mov %l0, %o3 <== NOT EXECUTED
base, size, inodes);
group->base = base;
2011648: f2 27 00 00 st %i1, [ %i4 ] <== NOT EXECUTED
group->size = size;
201164c: 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;
2011650: c0 2f 20 20 clrb [ %i4 + 0x20 ]
handle->bnum = 0;
2011654: c0 27 20 24 clr [ %i4 + 0x24 ]
handle->buffer = NULL;
2011658: 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,
201165c: a2 07 20 08 add %i4, 8, %l1
2011660: b6 07 20 20 add %i4, 0x20, %i3
2011664: 90 10 00 11 mov %l1, %o0
2011668: 92 10 00 18 mov %i0, %o1
201166c: 94 10 00 1b mov %i3, %o2
2011670: 96 10 00 1a mov %i2, %o3
2011674: 40 00 22 cb call 201a1a0 <rtems_rfs_bitmap_open>
2011678: 98 10 00 19 mov %i1, %o4
&group->block_bitmap_buffer, size,
group->base + RTEMS_RFS_GROUP_BLOCK_BITMAP_BLOCK);
if (rc > 0)
201167c: ba 92 20 00 orcc %o0, 0, %i5
2011680: 04 80 00 16 ble 20116d8 <rtems_rfs_group_open+0x128> <== ALWAYS TAKEN
2011684: 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);
2011688: 40 00 27 54 call 201b3d8 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
201168c: 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))
2011690: 90 10 20 00 clr %o0 <== NOT EXECUTED
handle->dirty = false;
2011694: c0 2f 20 20 clrb [ %i4 + 0x20 ] <== NOT EXECUTED
handle->bnum = 0;
2011698: c0 27 20 24 clr [ %i4 + 0x24 ] <== NOT EXECUTED
handle->buffer = NULL;
201169c: c0 27 20 28 clr [ %i4 + 0x28 ] <== NOT EXECUTED
20116a0: 40 00 08 4c call 20137d0 <rtems_rfs_trace> <== NOT EXECUTED
20116a4: 13 00 00 20 sethi %hi(0x8000), %o1 <== NOT EXECUTED
20116a8: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
20116ac: 22 80 00 3d be,a 20117a0 <rtems_rfs_group_open+0x1f0> <== NOT EXECUTED
20116b0: b0 10 00 1d mov %i5, %i0 <== NOT EXECUTED
printf ("rtems-rfs: group-open: could not open block bitmap: %d: %s\n",
20116b4: 40 00 47 00 call 20232b4 <strerror> <== NOT EXECUTED
20116b8: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
20116bc: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
20116c0: 11 00 80 ca sethi %hi(0x2032800), %o0 <== NOT EXECUTED
20116c4: 90 12 23 a0 or %o0, 0x3a0, %o0 ! 2032ba0 <_CPU_Trap_slot_template+0x968><== NOT EXECUTED
20116c8: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
20116cc: 40 00 42 8b call 20220f8 <printf> <== NOT EXECUTED
20116d0: b0 10 00 1d mov %i5, %i0 <== NOT EXECUTED
20116d4: 30 80 00 33 b,a 20117a0 <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,
20116d8: 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;
20116dc: c0 2f 20 44 clrb [ %i4 + 0x44 ]
handle->bnum = 0;
20116e0: c0 27 20 48 clr [ %i4 + 0x48 ]
handle->buffer = NULL;
20116e4: c0 27 20 4c clr [ %i4 + 0x4c ]
20116e8: b4 07 20 44 add %i4, 0x44, %i2
20116ec: 90 07 20 2c add %i4, 0x2c, %o0
20116f0: 92 10 00 18 mov %i0, %o1
20116f4: 94 10 00 1a mov %i2, %o2
20116f8: 96 10 00 10 mov %l0, %o3
20116fc: 40 00 22 a9 call 201a1a0 <rtems_rfs_bitmap_open>
2011700: 98 03 20 01 inc %o4
&group->inode_bitmap_buffer, inodes,
group->base + RTEMS_RFS_GROUP_INODE_BITMAP_BLOCK);
if (rc > 0)
2011704: ba 92 20 00 orcc %o0, 0, %i5
2011708: 04 80 00 1b ble 2011774 <rtems_rfs_group_open+0x1c4> <== ALWAYS TAKEN
201170c: 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);
2011710: 40 00 27 32 call 201b3d8 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
2011714: 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);
2011718: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED
handle->dirty = false;
201171c: c0 2f 20 44 clrb [ %i4 + 0x44 ] <== NOT EXECUTED
handle->bnum = 0;
2011720: c0 27 20 48 clr [ %i4 + 0x48 ] <== NOT EXECUTED
2011724: 40 00 22 b0 call 201a1e4 <rtems_rfs_bitmap_close> <== NOT EXECUTED
2011728: 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);
201172c: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
2011730: 40 00 27 2a call 201b3d8 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
2011734: 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))
2011738: 90 10 20 00 clr %o0 <== NOT EXECUTED
handle->dirty = false;
201173c: c0 2f 20 20 clrb [ %i4 + 0x20 ] <== NOT EXECUTED
handle->bnum = 0;
2011740: c0 27 20 24 clr [ %i4 + 0x24 ] <== NOT EXECUTED
handle->buffer = NULL;
2011744: c0 27 20 28 clr [ %i4 + 0x28 ] <== NOT EXECUTED
2011748: 40 00 08 22 call 20137d0 <rtems_rfs_trace> <== NOT EXECUTED
201174c: 13 00 00 20 sethi %hi(0x8000), %o1 <== NOT EXECUTED
2011750: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
2011754: 22 80 00 13 be,a 20117a0 <rtems_rfs_group_open+0x1f0> <== NOT EXECUTED
2011758: b0 10 00 1d mov %i5, %i0 <== NOT EXECUTED
printf ("rtems-rfs: group-open: could not open inode bitmap: %d: %s\n",
201175c: 40 00 46 d6 call 20232b4 <strerror> <== NOT EXECUTED
2011760: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
2011764: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
2011768: 11 00 80 ca sethi %hi(0x2032800), %o0 <== NOT EXECUTED
201176c: 10 bf ff d7 b 20116c8 <rtems_rfs_group_open+0x118> <== NOT EXECUTED
2011770: 90 12 23 e0 or %o0, 0x3e0, %o0 ! 2032be0 <_CPU_Trap_slot_template+0x9a8><== NOT EXECUTED
rc, strerror (rc));
return rc;
}
if (rtems_rfs_fs_release_bitmaps (fs))
2011774: c2 06 00 00 ld [ %i0 ], %g1
2011778: 80 88 60 01 btst 1, %g1
201177c: 12 80 00 08 bne 201179c <rtems_rfs_group_open+0x1ec> <== NEVER TAKEN
2011780: ba 10 20 00 clr %i5
{
rtems_rfs_bitmap_release_buffer (fs, &group->block_bitmap);
2011784: d2 07 20 08 ld [ %i4 + 8 ], %o1
2011788: 40 00 27 14 call 201b3d8 <rtems_rfs_buffer_handle_release>
201178c: 90 10 00 18 mov %i0, %o0
rtems_rfs_bitmap_release_buffer (fs, &group->inode_bitmap);
2011790: d2 07 20 2c ld [ %i4 + 0x2c ], %o1
2011794: 40 00 27 11 call 201b3d8 <rtems_rfs_buffer_handle_release>
2011798: 90 10 00 18 mov %i0, %o0
}
return 0;
}
201179c: b0 10 00 1d mov %i5, %i0
20117a0: 81 c7 e0 08 ret
20117a4: 81 e8 00 00 restore
02011c04 <rtems_rfs_group_usage>:
size_t* blocks,
size_t* inodes)
{
int g;
*blocks = 0;
2011c04: c0 22 40 00 clr [ %o1 ] <== NOT EXECUTED
*inodes = 0;
2011c08: c0 22 80 00 clr [ %o2 ] <== NOT EXECUTED
for (g = 0; g < fs->group_count; g++)
2011c0c: 86 10 20 00 clr %g3 <== NOT EXECUTED
2011c10: 10 80 00 11 b 2011c54 <rtems_rfs_group_usage+0x50> <== NOT EXECUTED
2011c14: 84 10 20 00 clr %g2 <== NOT EXECUTED
{
rtems_rfs_group* group = &fs->groups[g];
2011c18: c2 02 20 20 ld [ %o0 + 0x20 ], %g1 <== NOT EXECUTED
int g;
*blocks = 0;
*inodes = 0;
for (g = 0; g < fs->group_count; g++)
2011c1c: 84 00 a0 01 inc %g2 <== NOT EXECUTED
{
rtems_rfs_group* group = &fs->groups[g];
2011c20: 82 00 40 03 add %g1, %g3, %g1 <== NOT EXECUTED
*blocks +=
rtems_rfs_bitmap_map_size(&group->block_bitmap) -
2011c24: d8 00 60 14 ld [ %g1 + 0x14 ], %o4 <== NOT EXECUTED
2011c28: da 00 60 18 ld [ %g1 + 0x18 ], %o5 <== NOT EXECUTED
2011c2c: 86 00 e0 50 add %g3, 0x50, %g3 <== NOT EXECUTED
2011c30: 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 +=
2011c34: 88 01 00 0d add %g4, %o5, %g4 <== NOT EXECUTED
2011c38: 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) -
2011c3c: c8 00 60 38 ld [ %g1 + 0x38 ], %g4 <== NOT EXECUTED
2011c40: c2 00 60 3c ld [ %g1 + 0x3c ], %g1 <== NOT EXECUTED
2011c44: 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 +=
2011c48: c8 02 80 00 ld [ %o2 ], %g4 <== NOT EXECUTED
2011c4c: 82 01 00 01 add %g4, %g1, %g1 <== NOT EXECUTED
2011c50: c2 22 80 00 st %g1, [ %o2 ] <== NOT EXECUTED
int g;
*blocks = 0;
*inodes = 0;
for (g = 0; g < fs->group_count; g++)
2011c54: c2 02 20 24 ld [ %o0 + 0x24 ], %g1 <== NOT EXECUTED
2011c58: 80 a0 80 01 cmp %g2, %g1 <== NOT EXECUTED
2011c5c: 06 bf ff ef bl 2011c18 <rtems_rfs_group_usage+0x14> <== NOT EXECUTED
2011c60: 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))
2011c64: c4 02 20 04 ld [ %o0 + 4 ], %g2 <== NOT EXECUTED
2011c68: 80 a1 00 02 cmp %g4, %g2 <== NOT EXECUTED
2011c6c: 08 80 00 03 bleu 2011c78 <rtems_rfs_group_usage+0x74> <== NOT EXECUTED
2011c70: 82 10 00 04 mov %g4, %g1 <== NOT EXECUTED
2011c74: 82 10 00 02 mov %g2, %g1 <== NOT EXECUTED
2011c78: c2 22 40 00 st %g1, [ %o1 ] <== NOT EXECUTED
*blocks = rtems_rfs_fs_blocks (fs);
if (*inodes > rtems_rfs_fs_inodes (fs))
2011c7c: c4 02 20 14 ld [ %o0 + 0x14 ], %g2 <== NOT EXECUTED
2011c80: c2 02 80 00 ld [ %o2 ], %g1 <== NOT EXECUTED
2011c84: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED
2011c88: 38 80 00 02 bgu,a 2011c90 <rtems_rfs_group_usage+0x8c> <== NOT EXECUTED
2011c8c: 82 10 00 02 mov %g2, %g1 <== NOT EXECUTED
2011c90: c2 22 80 00 st %g1, [ %o2 ] <== NOT EXECUTED
*inodes = rtems_rfs_fs_inodes (fs);
return 0;
}
2011c94: 81 c3 e0 08 retl <== NOT EXECUTED
2011c98: 90 10 20 00 clr %o0 <== NOT EXECUTED
02011f54 <rtems_rfs_inode_close>:
}
int
rtems_rfs_inode_close (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* handle)
{
2011f54: 9d e3 bf a0 save %sp, -96, %sp
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_CLOSE))
2011f58: 90 10 20 00 clr %o0
2011f5c: 40 00 06 1d call 20137d0 <rtems_rfs_trace>
2011f60: 13 00 02 00 sethi %hi(0x80000), %o1
2011f64: 80 8a 20 ff btst 0xff, %o0
2011f68: 22 80 00 07 be,a 2011f84 <rtems_rfs_inode_close+0x30> <== ALWAYS TAKEN
2011f6c: 90 10 00 18 mov %i0, %o0
printf ("rtems-rfs: inode-close: ino: %" PRIu32 "\n", handle->ino);
2011f70: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED
2011f74: 11 00 80 cb sethi %hi(0x2032c00), %o0 <== NOT EXECUTED
2011f78: 40 00 40 60 call 20220f8 <printf> <== NOT EXECUTED
2011f7c: 90 12 21 c8 or %o0, 0x1c8, %o0 ! 2032dc8 <_CPU_Trap_slot_template+0xb90><== NOT EXECUTED
rc = rtems_rfs_inode_unload (fs, handle, true);
2011f80: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
2011f84: 92 10 00 19 mov %i1, %o1
2011f88: 7f ff ff b7 call 2011e64 <rtems_rfs_inode_unload>
2011f8c: 94 10 20 01 mov 1, %o2
if ((rc == 0) && (handle->loads > 0))
2011f90: b0 92 20 00 orcc %o0, 0, %i0
2011f94: 32 80 00 11 bne,a 2011fd8 <rtems_rfs_inode_close+0x84> <== NEVER TAKEN
2011f98: c0 26 60 08 clr [ %i1 + 8 ] <== NOT EXECUTED
2011f9c: c2 06 60 24 ld [ %i1 + 0x24 ], %g1
2011fa0: 80 a0 60 00 cmp %g1, 0
2011fa4: 04 80 00 0c ble 2011fd4 <rtems_rfs_inode_close+0x80> <== ALWAYS TAKEN
2011fa8: 13 00 02 00 sethi %hi(0x80000), %o1
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_CLOSE))
2011fac: 90 10 20 00 clr %o0 <== NOT EXECUTED
2011fb0: 40 00 06 08 call 20137d0 <rtems_rfs_trace> <== NOT EXECUTED
2011fb4: b0 10 20 05 mov 5, %i0 <== NOT EXECUTED
2011fb8: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
2011fbc: 22 80 00 07 be,a 2011fd8 <rtems_rfs_inode_close+0x84> <== NOT EXECUTED
2011fc0: c0 26 60 08 clr [ %i1 + 8 ] <== NOT EXECUTED
printf ("rtems-rfs: inode-close: bad loads number: %d\n",
2011fc4: d2 06 60 24 ld [ %i1 + 0x24 ], %o1 <== NOT EXECUTED
2011fc8: 11 00 80 cb sethi %hi(0x2032c00), %o0 <== NOT EXECUTED
2011fcc: 40 00 40 4b call 20220f8 <printf> <== NOT EXECUTED
2011fd0: 90 12 21 f0 or %o0, 0x1f0, %o0 ! 2032df0 <_CPU_Trap_slot_template+0xbb8><== NOT EXECUTED
handle->loads);
rc = EIO;
}
handle->ino = 0;
2011fd4: c0 26 60 08 clr [ %i1 + 8 ]
return rc;
}
2011fd8: 81 c7 e0 08 ret
2011fdc: 81 e8 00 00 restore
020122a8 <rtems_rfs_inode_create>:
uint16_t mode,
uint16_t links,
uid_t uid,
gid_t gid,
rtems_rfs_ino* ino)
{
20122a8: 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))
20122ac: 90 10 20 00 clr %o0
uint16_t mode,
uint16_t links,
uid_t uid,
gid_t gid,
rtems_rfs_ino* ino)
{
20122b0: e2 07 a0 64 ld [ %fp + 0x64 ], %l1
20122b4: e8 17 a0 5e lduh [ %fp + 0x5e ], %l4
20122b8: 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))
20122bc: 40 00 05 45 call 20137d0 <rtems_rfs_trace>
20122c0: 13 00 10 00 sethi %hi(0x400000), %o1
20122c4: 80 8a 20 ff btst 0xff, %o0
20122c8: 02 80 00 36 be 20123a0 <rtems_rfs_inode_create+0xf8> <== ALWAYS TAKEN
20122cc: a4 0f 30 00 and %i4, -4096, %l2
{
const char* type = "unknown";
int c;
if (RTEMS_RFS_S_ISDIR (mode))
20122d0: 82 0f 30 00 and %i4, -4096, %g1 <== NOT EXECUTED
20122d4: 05 00 00 10 sethi %hi(0x4000), %g2 <== NOT EXECUTED
20122d8: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED
20122dc: 02 80 00 11 be 2012320 <rtems_rfs_inode_create+0x78> <== NOT EXECUTED
20122e0: 05 00 00 08 sethi %hi(0x2000), %g2 <== NOT EXECUTED
type = "dir";
else if (RTEMS_RFS_S_ISCHR (mode))
20122e4: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED
20122e8: 02 80 00 11 be 201232c <rtems_rfs_inode_create+0x84> <== NOT EXECUTED
20122ec: 05 00 00 18 sethi %hi(0x6000), %g2 <== NOT EXECUTED
type = "char";
else if (RTEMS_RFS_S_ISBLK (mode))
20122f0: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED
20122f4: 02 80 00 11 be 2012338 <rtems_rfs_inode_create+0x90> <== NOT EXECUTED
20122f8: 05 00 00 20 sethi %hi(0x8000), %g2 <== NOT EXECUTED
type = "block";
else if (RTEMS_RFS_S_ISREG (mode))
20122fc: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED
2012300: 02 80 00 11 be 2012344 <rtems_rfs_inode_create+0x9c> <== NOT EXECUTED
2012304: 05 00 00 28 sethi %hi(0xa000), %g2 <== NOT EXECUTED
type = "file";
else if (RTEMS_RFS_S_ISLNK (mode))
2012308: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED
201230c: 22 80 00 11 be,a 2012350 <rtems_rfs_inode_create+0xa8> <== NOT EXECUTED
2012310: 21 00 80 cb sethi %hi(0x2032c00), %l0 <== NOT EXECUTED
rtems_rfs_inode_handle inode;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_CREATE))
{
const char* type = "unknown";
2012314: 21 00 80 cb sethi %hi(0x2032c00), %l0 <== NOT EXECUTED
2012318: 10 80 00 0f b 2012354 <rtems_rfs_inode_create+0xac> <== NOT EXECUTED
201231c: a0 14 22 68 or %l0, 0x268, %l0 ! 2032e68 <_CPU_Trap_slot_template+0xc30><== NOT EXECUTED
int c;
if (RTEMS_RFS_S_ISDIR (mode))
type = "dir";
2012320: 21 00 80 cb sethi %hi(0x2032c00), %l0 <== NOT EXECUTED
2012324: 10 80 00 0c b 2012354 <rtems_rfs_inode_create+0xac> <== NOT EXECUTED
2012328: a0 14 22 50 or %l0, 0x250, %l0 ! 2032e50 <_CPU_Trap_slot_template+0xc18><== NOT EXECUTED
else if (RTEMS_RFS_S_ISCHR (mode))
type = "char";
201232c: 21 00 80 cb sethi %hi(0x2032c00), %l0 <== NOT EXECUTED
2012330: 10 80 00 09 b 2012354 <rtems_rfs_inode_create+0xac> <== NOT EXECUTED
2012334: a0 14 22 58 or %l0, 0x258, %l0 ! 2032e58 <_CPU_Trap_slot_template+0xc20><== NOT EXECUTED
else if (RTEMS_RFS_S_ISBLK (mode))
type = "block";
2012338: 21 00 80 cb sethi %hi(0x2032c00), %l0 <== NOT EXECUTED
201233c: 10 80 00 06 b 2012354 <rtems_rfs_inode_create+0xac> <== NOT EXECUTED
2012340: a0 14 20 50 or %l0, 0x50, %l0 ! 2032c50 <_CPU_Trap_slot_template+0xa18><== NOT EXECUTED
else if (RTEMS_RFS_S_ISREG (mode))
type = "file";
2012344: 21 00 80 cb sethi %hi(0x2032c00), %l0 <== NOT EXECUTED
2012348: 10 80 00 03 b 2012354 <rtems_rfs_inode_create+0xac> <== NOT EXECUTED
201234c: a0 14 22 60 or %l0, 0x260, %l0 ! 2032e60 <_CPU_Trap_slot_template+0xc28><== NOT EXECUTED
else if (RTEMS_RFS_S_ISLNK (mode))
type = "link";
2012350: a0 14 22 70 or %l0, 0x270, %l0 <== NOT EXECUTED
printf("rtems-rfs: inode-create: parent:%" PRIu32 " name:", parent);
2012354: 11 00 80 cb sethi %hi(0x2032c00), %o0 <== NOT EXECUTED
2012358: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
201235c: 90 12 22 78 or %o0, 0x278, %o0 <== NOT EXECUTED
2012360: 40 00 3f 66 call 20220f8 <printf> <== NOT EXECUTED
2012364: a4 10 00 1a mov %i2, %l2 <== NOT EXECUTED
for (c = 0; c < length; c++)
2012368: 10 80 00 04 b 2012378 <rtems_rfs_inode_create+0xd0> <== NOT EXECUTED
201236c: aa 06 80 1b add %i2, %i3, %l5 <== NOT EXECUTED
printf ("%c", name[c]);
2012370: 40 00 3f cc call 20222a0 <putchar> <== NOT EXECUTED
2012374: 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++)
2012378: 80 a4 80 15 cmp %l2, %l5 <== NOT EXECUTED
201237c: 32 bf ff fd bne,a 2012370 <rtems_rfs_inode_create+0xc8> <== NOT EXECUTED
2012380: 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));
2012384: 11 00 80 cb sethi %hi(0x2032c00), %o0 <== NOT EXECUTED
2012388: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED
201238c: 90 12 22 a8 or %o0, 0x2a8, %o0 <== NOT EXECUTED
2012390: 94 10 00 1c mov %i4, %o2 <== NOT EXECUTED
2012394: 40 00 3f 59 call 20220f8 <printf> <== NOT EXECUTED
2012398: 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)
201239c: a4 0f 30 00 and %i4, -4096, %l2 <== NOT EXECUTED
20123a0: 05 00 00 18 sethi %hi(0x6000), %g2
20123a4: 80 a4 80 02 cmp %l2, %g2
20123a8: 02 80 00 11 be 20123ec <rtems_rfs_inode_create+0x144> <== NEVER TAKEN
20123ac: 82 10 00 12 mov %l2, %g1
20123b0: 80 a4 80 02 cmp %l2, %g2
20123b4: 18 80 00 08 bgu 20123d4 <rtems_rfs_inode_create+0x12c>
20123b8: 05 00 00 20 sethi %hi(0x8000), %g2
20123bc: 05 00 00 08 sethi %hi(0x2000), %g2
20123c0: 80 a4 80 02 cmp %l2, %g2
20123c4: 02 80 00 0a be 20123ec <rtems_rfs_inode_create+0x144> <== NEVER TAKEN
20123c8: 05 00 00 10 sethi %hi(0x4000), %g2
20123cc: 10 80 00 06 b 20123e4 <rtems_rfs_inode_create+0x13c>
20123d0: 80 a0 40 02 cmp %g1, %g2
20123d4: 80 a4 80 02 cmp %l2, %g2
20123d8: 02 80 00 05 be 20123ec <rtems_rfs_inode_create+0x144>
20123dc: 05 00 00 28 sethi %hi(0xa000), %g2
20123e0: 80 a0 40 02 cmp %g1, %g2
20123e4: 12 80 00 81 bne 20125e8 <rtems_rfs_inode_create+0x340> <== NEVER TAKEN
20123e8: a0 10 20 16 mov 0x16, %l0
break;
default:
return EINVAL;
}
rc = rtems_rfs_inode_alloc (fs, parent, ino);
20123ec: 90 10 00 18 mov %i0, %o0
20123f0: 92 10 00 19 mov %i1, %o1
20123f4: 7f ff fe 2a call 2011c9c <rtems_rfs_inode_alloc>
20123f8: 94 10 00 11 mov %l1, %o2
if (rc > 0)
20123fc: a0 92 20 00 orcc %o0, 0, %l0
2012400: 34 80 00 7b bg,a 20125ec <rtems_rfs_inode_create+0x344>
2012404: b0 10 00 10 mov %l0, %i0
return rc;
rc = rtems_rfs_inode_open (fs, *ino, &inode, true);
2012408: d2 04 40 00 ld [ %l1 ], %o1
201240c: 90 10 00 18 mov %i0, %o0
2012410: 94 07 bf d8 add %fp, -40, %o2
2012414: 7f ff fe 5e call 2011d8c <rtems_rfs_inode_open>
2012418: 96 10 20 01 mov 1, %o3
if (rc > 0)
201241c: a0 92 20 00 orcc %o0, 0, %l0
2012420: 04 80 00 04 ble 2012430 <rtems_rfs_inode_create+0x188> <== ALWAYS TAKEN
2012424: 90 07 bf d8 add %fp, -40, %o0
}
rc = rtems_rfs_inode_close (fs, &inode);
if (rc > 0)
{
rtems_rfs_inode_free (fs, *ino);
2012428: 10 80 00 6c b 20125d8 <rtems_rfs_inode_create+0x330> <== NOT EXECUTED
201242c: 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);
2012430: 92 10 00 1d mov %i5, %o1
2012434: 94 10 00 1c mov %i4, %o2
2012438: 96 10 00 14 mov %l4, %o3
201243c: 7f ff ff 47 call 2012158 <rtems_rfs_inode_initialise>
2012440: 98 10 00 13 mov %l3, %o4
if (rc > 0)
2012444: a0 92 20 00 orcc %o0, 0, %l0
2012448: 04 80 00 07 ble 2012464 <rtems_rfs_inode_create+0x1bc> <== ALWAYS TAKEN
201244c: 03 00 00 10 sethi %hi(0x4000), %g1
{
rtems_rfs_inode_close (fs, &inode);
2012450: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
2012454: 7f ff fe c0 call 2011f54 <rtems_rfs_inode_close> <== NOT EXECUTED
2012458: 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);
201245c: 10 80 00 5f b 20125d8 <rtems_rfs_inode_create+0x330> <== NOT EXECUTED
2012460: 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))
2012464: 80 a4 80 01 cmp %l2, %g1
2012468: 12 80 00 17 bne 20124c4 <rtems_rfs_inode_create+0x21c>
201246c: 90 10 00 18 mov %i0, %o0
{
rc = rtems_rfs_dir_add_entry (fs, &inode, ".", 1, *ino);
2012470: d8 04 40 00 ld [ %l1 ], %o4
2012474: 92 07 bf d8 add %fp, -40, %o1
2012478: 15 00 80 c1 sethi %hi(0x2030400), %o2
201247c: 96 10 20 01 mov 1, %o3
2012480: 40 00 27 47 call 201c19c <rtems_rfs_dir_add_entry>
2012484: 94 12 a0 78 or %o2, 0x78, %o2
if (rc == 0)
2012488: a0 92 20 00 orcc %o0, 0, %l0
201248c: 12 80 00 0b bne 20124b8 <rtems_rfs_inode_create+0x210> <== NEVER TAKEN
2012490: 80 a4 20 00 cmp %l0, 0
rc = rtems_rfs_dir_add_entry (fs, &inode, "..", 2, parent);
2012494: 90 10 00 18 mov %i0, %o0
2012498: 92 07 bf d8 add %fp, -40, %o1
201249c: 15 00 80 c1 sethi %hi(0x2030400), %o2
20124a0: 96 10 20 02 mov 2, %o3
20124a4: 94 12 a0 80 or %o2, 0x80, %o2
20124a8: 40 00 27 3d call 201c19c <rtems_rfs_dir_add_entry>
20124ac: 98 10 00 19 mov %i1, %o4
20124b0: a0 10 00 08 mov %o0, %l0
if (rc > 0)
20124b4: 80 a4 20 00 cmp %l0, 0
20124b8: 14 80 00 0b bg 20124e4 <rtems_rfs_inode_create+0x23c> <== NEVER TAKEN
20124bc: 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);
20124c0: 90 10 00 18 mov %i0, %o0
20124c4: 92 10 00 19 mov %i1, %o1
20124c8: 94 07 bf b0 add %fp, -80, %o2
20124cc: 7f ff fe 30 call 2011d8c <rtems_rfs_inode_open>
20124d0: 96 10 20 01 mov 1, %o3
20124d4: a0 10 00 08 mov %o0, %l0
if (rc > 0)
20124d8: 80 a4 20 00 cmp %l0, 0
20124dc: 04 80 00 04 ble 20124ec <rtems_rfs_inode_create+0x244> <== ALWAYS TAKEN
20124e0: 90 10 00 18 mov %i0, %o0
{
rtems_rfs_inode_delete (fs, &inode);
20124e4: 10 80 00 30 b 20125a4 <rtems_rfs_inode_create+0x2fc> <== NOT EXECUTED
20124e8: 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);
20124ec: d8 04 40 00 ld [ %l1 ], %o4
20124f0: 92 07 bf b0 add %fp, -80, %o1
20124f4: 94 10 00 1a mov %i2, %o2
20124f8: 40 00 27 29 call 201c19c <rtems_rfs_dir_add_entry>
20124fc: 96 10 00 1b mov %i3, %o3
if (rc > 0)
2012500: a0 92 20 00 orcc %o0, 0, %l0
2012504: 04 80 00 0b ble 2012530 <rtems_rfs_inode_create+0x288> <== ALWAYS TAKEN
2012508: 03 00 00 10 sethi %hi(0x4000), %g1
{
rtems_rfs_inode_delete (fs, &inode);
201250c: 92 07 bf d8 add %fp, -40, %o1 <== NOT EXECUTED
2012510: 7f ff fe b4 call 2011fe0 <rtems_rfs_inode_delete> <== NOT EXECUTED
2012514: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
rtems_rfs_inode_close (fs, &inode);
2012518: 92 07 bf d8 add %fp, -40, %o1 <== NOT EXECUTED
201251c: 7f ff fe 8e call 2011f54 <rtems_rfs_inode_close> <== NOT EXECUTED
2012520: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
rtems_rfs_inode_close (fs, &parent_inode);
2012524: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
2012528: 10 80 00 23 b 20125b4 <rtems_rfs_inode_create+0x30c> <== NOT EXECUTED
201252c: 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))
2012530: 80 a4 80 01 cmp %l2, %g1
2012534: 12 80 00 15 bne 2012588 <rtems_rfs_inode_create+0x2e0>
2012538: 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);
201253c: c2 07 bf bc ld [ %fp + -68 ], %g1
if (links == 0xffff)
2012540: 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);
2012544: c6 08 60 01 ldub [ %g1 + 1 ], %g3
2012548: c4 08 40 00 ldub [ %g1 ], %g2
201254c: 85 28 a0 08 sll %g2, 8, %g2
2012550: 84 10 80 03 or %g2, %g3, %g2
if (links == 0xffff)
2012554: 87 28 a0 10 sll %g2, 0x10, %g3
2012558: 87 30 e0 10 srl %g3, 0x10, %g3
links = 0;
201255c: 86 39 00 03 xnor %g4, %g3, %g3
2012560: 80 a0 00 03 cmp %g0, %g3
2012564: 86 60 20 00 subx %g0, 0, %g3
2012568: 84 08 80 03 and %g2, %g3, %g2
rtems_rfs_inode_set_links (&parent_inode,
201256c: 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);
2012570: 87 30 a0 08 srl %g2, 8, %g3
2012574: c6 28 40 00 stb %g3, [ %g1 ]
2012578: c2 07 bf bc ld [ %fp + -68 ], %g1
201257c: c4 28 60 01 stb %g2, [ %g1 + 1 ]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
2012580: 82 10 20 01 mov 1, %g1
2012584: c2 2f bf c0 stb %g1, [ %fp + -64 ]
rtems_rfs_inode_get_links (&parent_inode) + 1);
rc = rtems_rfs_inode_close (fs, &parent_inode);
2012588: 7f ff fe 73 call 2011f54 <rtems_rfs_inode_close>
201258c: 90 10 00 18 mov %i0, %o0
if (rc > 0)
{
rtems_rfs_inode_delete (fs, &inode);
2012590: 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);
2012594: a0 10 00 08 mov %o0, %l0
if (rc > 0)
2012598: 80 a4 20 00 cmp %l0, 0
201259c: 04 80 00 09 ble 20125c0 <rtems_rfs_inode_create+0x318> <== ALWAYS TAKEN
20125a0: 90 10 00 18 mov %i0, %o0
{
rtems_rfs_inode_delete (fs, &inode);
20125a4: 7f ff fe 8f call 2011fe0 <rtems_rfs_inode_delete> <== NOT EXECUTED
20125a8: 01 00 00 00 nop <== NOT EXECUTED
rtems_rfs_inode_close (fs, &inode);
20125ac: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
20125b0: 92 07 bf d8 add %fp, -40, %o1 <== NOT EXECUTED
20125b4: 7f ff fe 68 call 2011f54 <rtems_rfs_inode_close> <== NOT EXECUTED
20125b8: b0 10 00 10 mov %l0, %i0 <== NOT EXECUTED
20125bc: 30 80 00 0c b,a 20125ec <rtems_rfs_inode_create+0x344> <== NOT EXECUTED
return rc;
}
rc = rtems_rfs_inode_close (fs, &inode);
20125c0: 7f ff fe 65 call 2011f54 <rtems_rfs_inode_close>
20125c4: 01 00 00 00 nop
if (rc > 0)
20125c8: a0 92 20 00 orcc %o0, 0, %l0
20125cc: 24 80 00 07 ble,a 20125e8 <rtems_rfs_inode_create+0x340> <== ALWAYS TAKEN
20125d0: a0 10 20 00 clr %l0
{
rtems_rfs_inode_free (fs, *ino);
20125d4: d2 04 40 00 ld [ %l1 ], %o1 <== NOT EXECUTED
20125d8: 7f ff fd bb call 2011cc4 <rtems_rfs_inode_free> <== NOT EXECUTED
20125dc: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
return rc;
}
return 0;
}
20125e0: 81 c7 e0 08 ret <== NOT EXECUTED
20125e4: 91 e8 00 10 restore %g0, %l0, %o0 <== NOT EXECUTED
20125e8: b0 10 00 10 mov %l0, %i0
20125ec: 81 c7 e0 08 ret
20125f0: 81 e8 00 00 restore
02011fe0 <rtems_rfs_inode_delete>:
}
int
rtems_rfs_inode_delete (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* handle)
{
2011fe0: 9d e3 bf 50 save %sp, -176, %sp
int rc = 0;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_DELETE))
2011fe4: 90 10 20 00 clr %o0
2011fe8: 40 00 05 fa call 20137d0 <rtems_rfs_trace>
2011fec: 13 00 20 00 sethi %hi(0x800000), %o1
2011ff0: 80 8a 20 ff btst 0xff, %o0
2011ff4: 22 80 00 0f be,a 2012030 <rtems_rfs_inode_delete+0x50> <== ALWAYS TAKEN
2011ff8: c4 06 60 0c ld [ %i1 + 0xc ], %g2
printf("rtems-rfs: inode-delete: ino:%" PRIu32 " loaded:%s\n",
2011ffc: c2 06 60 0c ld [ %i1 + 0xc ], %g1 <== NOT EXECUTED
2012000: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
2012004: 02 80 00 05 be 2012018 <rtems_rfs_inode_delete+0x38> <== NOT EXECUTED
2012008: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED
201200c: 15 00 80 cb sethi %hi(0x2032c00), %o2 <== NOT EXECUTED
2012010: 10 80 00 04 b 2012020 <rtems_rfs_inode_delete+0x40> <== NOT EXECUTED
2012014: 94 12 a1 28 or %o2, 0x128, %o2 ! 2032d28 <_CPU_Trap_slot_template+0xaf0><== NOT EXECUTED
2012018: 15 00 80 c3 sethi %hi(0x2030c00), %o2 <== NOT EXECUTED
201201c: 94 12 a2 18 or %o2, 0x218, %o2 ! 2030e18 <__FUNCTION__.7059+0x5f8><== NOT EXECUTED
2012020: 11 00 80 cb sethi %hi(0x2032c00), %o0 <== NOT EXECUTED
2012024: 40 00 40 35 call 20220f8 <printf> <== NOT EXECUTED
2012028: 90 12 22 20 or %o0, 0x220, %o0 ! 2032e20 <_CPU_Trap_slot_template+0xbe8><== NOT EXECUTED
rtems_rfs_inode_ino (handle),
rtems_rfs_inode_is_loaded (handle) ? "yes" : "no");
if (rtems_rfs_inode_is_loaded (handle))
201202c: c4 06 60 0c ld [ %i1 + 0xc ], %g2 <== NOT EXECUTED
2012030: 80 a0 a0 00 cmp %g2, 0
2012034: 02 80 00 1e be 20120ac <rtems_rfs_inode_delete+0xcc> <== NEVER TAKEN
2012038: 90 10 20 00 clr %o0
rtems_rfs_block_map map;
/*
* Free the ino number.
*/
rc = rtems_rfs_inode_free (fs, handle->ino);
201203c: d2 06 60 08 ld [ %i1 + 8 ], %o1
2012040: 7f ff ff 21 call 2011cc4 <rtems_rfs_inode_free>
2012044: 90 10 00 18 mov %i0, %o0
if (rc > 0)
2012048: 80 a2 20 00 cmp %o0, 0
201204c: 14 80 00 18 bg 20120ac <rtems_rfs_inode_delete+0xcc> <== NEVER TAKEN
2012050: 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);
2012054: 90 10 00 18 mov %i0, %o0
2012058: 40 00 21 67 call 201a5f4 <rtems_rfs_block_map_open>
201205c: 94 07 bf b0 add %fp, -80, %o2
if (rc == 0)
2012060: 80 a2 20 00 cmp %o0, 0
2012064: 12 80 00 12 bne 20120ac <rtems_rfs_inode_delete+0xcc> <== NEVER TAKEN
2012068: 92 07 bf b0 add %fp, -80, %o1
{
int rrc;
rrc = rtems_rfs_block_map_free_all (fs, &map);
201206c: 40 00 24 77 call 201b248 <rtems_rfs_block_map_free_all>
2012070: 90 10 00 18 mov %i0, %o0
rc = rtems_rfs_block_map_close (fs, &map);
2012074: 92 07 bf b0 add %fp, -80, %o1
2012078: 40 00 21 c0 call 201a778 <rtems_rfs_block_map_close>
201207c: 90 10 00 18 mov %i0, %o0
if (rc > 0)
rrc = rc;
memset (handle->node, 0xff, RTEMS_RFS_INODE_SIZE);
2012080: d0 06 60 0c ld [ %i1 + 0xc ], %o0
2012084: 92 10 20 ff mov 0xff, %o1
2012088: 40 00 3f 9e call 2021f00 <memset>
201208c: 94 10 20 38 mov 0x38, %o2
rtems_rfs_buffer_mark_dirty (&handle->buffer);
2012090: 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);
2012094: 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);
2012098: 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);
201209c: 40 00 24 cf call 201b3d8 <rtems_rfs_buffer_handle_release>
20120a0: 92 06 60 10 add %i1, 0x10, %o1
handle->loads = 0;
20120a4: c0 26 60 24 clr [ %i1 + 0x24 ]
handle->node = NULL;
20120a8: c0 26 60 0c clr [ %i1 + 0xc ]
}
}
return rc;
}
20120ac: 81 c7 e0 08 ret
20120b0: 91 e8 00 08 restore %g0, %o0, %o0
02012674 <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]);
2012674: c2 02 20 0c ld [ %o0 + 0xc ], %g1 <== NOT EXECUTED
2012678: 92 02 60 06 add %o1, 6, %o1 <== NOT EXECUTED
201267c: 85 2a 60 02 sll %o1, 2, %g2 <== NOT EXECUTED
2012680: 84 00 40 02 add %g1, %g2, %g2 <== NOT EXECUTED
2012684: 82 00 a0 04 add %g2, 4, %g1 <== NOT EXECUTED
2012688: d0 08 a0 04 ldub [ %g2 + 4 ], %o0 <== NOT EXECUTED
201268c: c4 08 a0 05 ldub [ %g2 + 5 ], %g2 <== NOT EXECUTED
2012690: 91 2a 20 18 sll %o0, 0x18, %o0 <== NOT EXECUTED
2012694: 85 28 a0 10 sll %g2, 0x10, %g2 <== NOT EXECUTED
2012698: 90 12 00 02 or %o0, %g2, %o0 <== NOT EXECUTED
201269c: c4 08 60 03 ldub [ %g1 + 3 ], %g2 <== NOT EXECUTED
20126a0: c2 08 60 02 ldub [ %g1 + 2 ], %g1 <== NOT EXECUTED
20126a4: 90 12 00 02 or %o0, %g2, %o0 <== NOT EXECUTED
20126a8: 83 28 60 08 sll %g1, 8, %g1 <== NOT EXECUTED
}
20126ac: 81 c3 e0 08 retl <== NOT EXECUTED
20126b0: 90 12 00 01 or %o0, %g1, %o0 <== NOT EXECUTED
02011cd8 <rtems_rfs_inode_load>:
}
int
rtems_rfs_inode_load (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* handle)
{
2011cd8: 9d e3 bf a0 save %sp, -96, %sp
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_LOAD))
2011cdc: 90 10 20 00 clr %o0
2011ce0: 40 00 06 bc call 20137d0 <rtems_rfs_trace>
2011ce4: 13 00 04 00 sethi %hi(0x100000), %o1
2011ce8: 80 8a 20 ff btst 0xff, %o0
2011cec: 02 80 00 0f be 2011d28 <rtems_rfs_inode_load+0x50> <== ALWAYS TAKEN
2011cf0: c2 06 60 0c ld [ %i1 + 0xc ], %g1
printf ("rtems-rfs: inode-load: ino=%" PRIu32 " loads=%i loaded=%s\n",
2011cf4: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED
2011cf8: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
2011cfc: 02 80 00 05 be 2011d10 <rtems_rfs_inode_load+0x38> <== NOT EXECUTED
2011d00: d4 06 60 24 ld [ %i1 + 0x24 ], %o2 <== NOT EXECUTED
2011d04: 17 00 80 cb sethi %hi(0x2032c00), %o3 <== NOT EXECUTED
2011d08: 10 80 00 04 b 2011d18 <rtems_rfs_inode_load+0x40> <== NOT EXECUTED
2011d0c: 96 12 e1 28 or %o3, 0x128, %o3 ! 2032d28 <_CPU_Trap_slot_template+0xaf0><== NOT EXECUTED
2011d10: 17 00 80 c3 sethi %hi(0x2030c00), %o3 <== NOT EXECUTED
2011d14: 96 12 e2 18 or %o3, 0x218, %o3 ! 2030e18 <__FUNCTION__.7059+0x5f8><== NOT EXECUTED
2011d18: 11 00 80 cb sethi %hi(0x2032c00), %o0 <== NOT EXECUTED
2011d1c: 40 00 40 f7 call 20220f8 <printf> <== NOT EXECUTED
2011d20: 90 12 21 30 or %o0, 0x130, %o0 ! 2032d30 <_CPU_Trap_slot_template+0xaf8><== NOT EXECUTED
/*
* An inode does not move so once loaded no need to do again.
*/
if (!rtems_rfs_inode_is_loaded (handle))
2011d24: c2 06 60 0c ld [ %i1 + 0xc ], %g1 <== NOT EXECUTED
2011d28: 80 a0 60 00 cmp %g1, 0
2011d2c: 32 80 00 13 bne,a 2011d78 <rtems_rfs_inode_load+0xa0>
2011d30: c2 06 60 24 ld [ %i1 + 0x24 ], %g1
{
int rc;
rc = rtems_rfs_buffer_handle_request (fs,&handle->buffer,
2011d34: d4 06 60 1c ld [ %i1 + 0x1c ], %o2
2011d38: 90 10 00 18 mov %i0, %o0
2011d3c: 92 06 60 10 add %i1, 0x10, %o1
2011d40: 40 00 26 1a call 201b5a8 <rtems_rfs_buffer_handle_request>
2011d44: 96 10 20 01 mov 1, %o3
handle->block, true);
if (rc > 0)
2011d48: b0 92 20 00 orcc %o0, 0, %i0
2011d4c: 14 80 00 0e bg 2011d84 <rtems_rfs_inode_load+0xac> <== NEVER TAKEN
2011d50: 01 00 00 00 nop
return rc;
handle->node = rtems_rfs_buffer_data (&handle->buffer);
2011d54: c4 06 60 18 ld [ %i1 + 0x18 ], %g2
handle->node += handle->offset;
2011d58: c2 06 60 20 ld [ %i1 + 0x20 ], %g1
2011d5c: c4 00 a0 1c ld [ %g2 + 0x1c ], %g2
2011d60: 87 28 60 03 sll %g1, 3, %g3
2011d64: 83 28 60 06 sll %g1, 6, %g1
2011d68: 82 20 40 03 sub %g1, %g3, %g1
2011d6c: 82 00 80 01 add %g2, %g1, %g1
2011d70: c2 26 60 0c st %g1, [ %i1 + 0xc ]
}
handle->loads++;
2011d74: c2 06 60 24 ld [ %i1 + 0x24 ], %g1
return 0;
2011d78: b0 10 20 00 clr %i0
handle->node = rtems_rfs_buffer_data (&handle->buffer);
handle->node += handle->offset;
}
handle->loads++;
2011d7c: 82 00 60 01 inc %g1
2011d80: c2 26 60 24 st %g1, [ %i1 + 0x24 ]
return 0;
}
2011d84: 81 c7 e0 08 ret
2011d88: 81 e8 00 00 restore
02011d8c <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)
{
2011d8c: 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))
2011d90: 90 10 20 00 clr %o0
2011d94: 40 00 06 8f call 20137d0 <rtems_rfs_trace>
2011d98: 13 00 01 00 sethi %hi(0x40000), %o1
2011d9c: 80 8a 20 ff btst 0xff, %o0
2011da0: 02 80 00 07 be 2011dbc <rtems_rfs_inode_open+0x30> <== ALWAYS TAKEN
2011da4: 80 a6 60 00 cmp %i1, 0
printf ("rtems-rfs: inode-open: ino: %" PRIu32 "\n", ino);
2011da8: 11 00 80 cb sethi %hi(0x2032c00), %o0 <== NOT EXECUTED
2011dac: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
2011db0: 40 00 40 d2 call 20220f8 <printf> <== NOT EXECUTED
2011db4: 90 12 21 68 or %o0, 0x168, %o0 <== NOT EXECUTED
if (ino == RTEMS_RFS_EMPTY_INO)
2011db8: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED
2011dbc: 02 80 00 28 be 2011e5c <rtems_rfs_inode_open+0xd0> <== NEVER TAKEN
2011dc0: 82 10 20 16 mov 0x16, %g1
return EINVAL;
if ((ino - RTEMS_RFS_ROOT_INO) > rtems_rfs_fs_inodes (fs))
2011dc4: c4 06 20 14 ld [ %i0 + 0x14 ], %g2
2011dc8: ba 06 7f ff add %i1, -1, %i5
2011dcc: 80 a7 40 02 cmp %i5, %g2
2011dd0: 18 80 00 23 bgu 2011e5c <rtems_rfs_inode_open+0xd0> <== NEVER TAKEN
2011dd4: 90 10 00 1d mov %i5, %o0
return EINVAL;
handle->ino = ino;
2011dd8: 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;
2011ddc: f2 06 20 2c ld [ %i0 + 0x2c ], %i1
gino = gino % fs->group_inodes;
2011de0: 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;
2011de4: 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;
2011de8: 40 00 71 62 call 202e370 <.urem>
2011dec: c0 26 a0 24 clr [ %i2 + 0x24 ]
index = (gino / fs->inodes_per_block) + RTEMS_RFS_GROUP_INODE_BLOCK;
2011df0: 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;
2011df4: 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;
2011df8: 40 00 71 5e call 202e370 <.urem>
2011dfc: 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;
2011e00: 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;
2011e04: 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;
2011e08: 7f ff c2 1d call 200267c <.udiv>
2011e0c: 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);
2011e10: c4 06 20 20 ld [ %i0 + 0x20 ], %g2
2011e14: 87 2a 20 04 sll %o0, 4, %g3
2011e18: 83 2a 20 06 sll %o0, 6, %g1
2011e1c: 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;
2011e20: fa 00 80 01 ld [ %g2 + %g1 ], %i5
2011e24: 90 10 00 10 mov %l0, %o0
2011e28: ba 07 60 02 add %i5, 2, %i5
2011e2c: 7f ff c2 14 call 200267c <.udiv>
2011e30: 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;
2011e34: c0 2e a0 10 clrb [ %i2 + 0x10 ]
handle->offset = gino % fs->inodes_per_block;
handle->block = rtems_rfs_group_block (&fs->groups[group], index);
2011e38: 90 07 40 08 add %i5, %o0, %o0
handle->bnum = 0;
2011e3c: c0 26 a0 14 clr [ %i2 + 0x14 ]
2011e40: d0 26 a0 1c st %o0, [ %i2 + 0x1c ]
handle->buffer = NULL;
2011e44: c0 26 a0 18 clr [ %i2 + 0x18 ]
rc = rtems_rfs_buffer_handle_open (fs, &handle->buffer);
if ((rc == 0) && load)
2011e48: 80 a6 e0 00 cmp %i3, 0
2011e4c: 02 80 00 04 be 2011e5c <rtems_rfs_inode_open+0xd0> <== NEVER TAKEN
2011e50: 82 10 20 00 clr %g1
rc = rtems_rfs_inode_load (fs, handle);
2011e54: 7f ff ff a1 call 2011cd8 <rtems_rfs_inode_load>
2011e58: 93 e8 00 1a restore %g0, %i2, %o1
return rc;
}
2011e5c: 81 c7 e0 08 ret <== NOT EXECUTED
2011e60: 91 e8 00 01 restore %g0, %g1, %o0 <== NOT EXECUTED
020126b4 <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);
20126b4: c2 02 20 0c ld [ %o0 + 0xc ], %g1 <== NOT EXECUTED
20126b8: 92 02 60 06 add %o1, 6, %o1 <== NOT EXECUTED
20126bc: 93 2a 60 02 sll %o1, 2, %o1 <== NOT EXECUTED
20126c0: 82 00 40 09 add %g1, %o1, %g1 <== NOT EXECUTED
20126c4: 85 32 a0 18 srl %o2, 0x18, %g2 <== NOT EXECUTED
20126c8: c4 28 60 04 stb %g2, [ %g1 + 4 ] <== NOT EXECUTED
20126cc: c2 02 20 0c ld [ %o0 + 0xc ], %g1 <== NOT EXECUTED
20126d0: 85 32 a0 10 srl %o2, 0x10, %g2 <== NOT EXECUTED
20126d4: 82 00 40 09 add %g1, %o1, %g1 <== NOT EXECUTED
20126d8: c4 28 60 05 stb %g2, [ %g1 + 5 ] <== NOT EXECUTED
20126dc: c2 02 20 0c ld [ %o0 + 0xc ], %g1 <== NOT EXECUTED
20126e0: 85 32 a0 08 srl %o2, 8, %g2 <== NOT EXECUTED
20126e4: 82 00 40 09 add %g1, %o1, %g1 <== NOT EXECUTED
20126e8: c4 28 60 06 stb %g2, [ %g1 + 6 ] <== NOT EXECUTED
20126ec: c2 02 20 0c ld [ %o0 + 0xc ], %g1 <== NOT EXECUTED
20126f0: 92 00 40 09 add %g1, %o1, %o1 <== NOT EXECUTED
20126f4: d4 2a 60 07 stb %o2, [ %o1 + 7 ] <== NOT EXECUTED
rtems_rfs_buffer_mark_dirty (&handle->buffer);
20126f8: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED
20126fc: 81 c3 e0 08 retl <== NOT EXECUTED
2012700: c2 2a 20 10 stb %g1, [ %o0 + 0x10 ] <== NOT EXECUTED
020120b4 <rtems_rfs_inode_time_stamp_now>:
int
rtems_rfs_inode_time_stamp_now (rtems_rfs_inode_handle* handle,
bool atime,
bool mtime)
{
20120b4: 9d e3 bf a0 save %sp, -96, %sp
time_t now;
if (!rtems_rfs_inode_is_loaded (handle))
20120b8: c2 06 20 0c ld [ %i0 + 0xc ], %g1
int
rtems_rfs_inode_time_stamp_now (rtems_rfs_inode_handle* handle,
bool atime,
bool mtime)
{
20120bc: ba 10 00 18 mov %i0, %i5
time_t now;
if (!rtems_rfs_inode_is_loaded (handle))
20120c0: 80 a0 60 00 cmp %g1, 0
20120c4: 02 80 00 23 be 2012150 <rtems_rfs_inode_time_stamp_now+0x9c><== NEVER TAKEN
20120c8: b0 10 20 06 mov 6, %i0
return ENXIO;
now = time (NULL);
20120cc: 40 00 50 0a call 20260f4 <time>
20120d0: 90 10 20 00 clr %o0
if (atime)
20120d4: 80 a6 60 00 cmp %i1, 0
20120d8: 02 80 00 0f be 2012114 <rtems_rfs_inode_time_stamp_now+0x60><== NEVER TAKEN
20120dc: 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);
20120e0: c2 07 60 0c ld [ %i5 + 0xc ], %g1
20120e4: 85 32 20 18 srl %o0, 0x18, %g2
20120e8: c4 28 60 10 stb %g2, [ %g1 + 0x10 ]
20120ec: c2 07 60 0c ld [ %i5 + 0xc ], %g1
20120f0: 85 32 20 10 srl %o0, 0x10, %g2
20120f4: c4 28 60 11 stb %g2, [ %g1 + 0x11 ]
20120f8: c2 07 60 0c ld [ %i5 + 0xc ], %g1
20120fc: 85 32 20 08 srl %o0, 8, %g2
2012100: c4 28 60 12 stb %g2, [ %g1 + 0x12 ]
2012104: c2 07 60 0c ld [ %i5 + 0xc ], %g1
2012108: d0 28 60 13 stb %o0, [ %g1 + 0x13 ]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
201210c: 82 10 20 01 mov 1, %g1
2012110: c2 2f 60 10 stb %g1, [ %i5 + 0x10 ]
rtems_rfs_inode_set_atime (handle, now);
if (mtime)
2012114: 02 80 00 0f be 2012150 <rtems_rfs_inode_time_stamp_now+0x9c><== NEVER TAKEN
2012118: 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);
201211c: c2 07 60 0c ld [ %i5 + 0xc ], %g1
2012120: 85 32 20 18 srl %o0, 0x18, %g2
2012124: c4 28 60 14 stb %g2, [ %g1 + 0x14 ]
2012128: c2 07 60 0c ld [ %i5 + 0xc ], %g1
201212c: 85 32 20 10 srl %o0, 0x10, %g2
2012130: c4 28 60 15 stb %g2, [ %g1 + 0x15 ]
2012134: c2 07 60 0c ld [ %i5 + 0xc ], %g1
2012138: 85 32 20 08 srl %o0, 8, %g2
201213c: c4 28 60 16 stb %g2, [ %g1 + 0x16 ]
2012140: c2 07 60 0c ld [ %i5 + 0xc ], %g1
2012144: d0 28 60 17 stb %o0, [ %g1 + 0x17 ]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
2012148: 82 10 20 01 mov 1, %g1
201214c: c2 2f 60 10 stb %g1, [ %i5 + 0x10 ]
rtems_rfs_inode_set_mtime (handle, now);
return 0;
}
2012150: 81 c7 e0 08 ret
2012154: 81 e8 00 00 restore
02011e64 <rtems_rfs_inode_unload>:
int
rtems_rfs_inode_unload (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* handle,
bool update_ctime)
{
2011e64: 9d e3 bf a0 save %sp, -96, %sp
int rc = 0;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_UNLOAD))
2011e68: 90 10 20 00 clr %o0
2011e6c: 40 00 06 59 call 20137d0 <rtems_rfs_trace>
2011e70: 13 00 08 00 sethi %hi(0x200000), %o1
2011e74: 80 8a 20 ff btst 0xff, %o0
2011e78: 02 80 00 0f be 2011eb4 <rtems_rfs_inode_unload+0x50> <== ALWAYS TAKEN
2011e7c: c2 06 60 0c ld [ %i1 + 0xc ], %g1
printf ("rtems-rfs: inode-unload: ino=%" PRIu32 " loads=%i loaded=%s\n",
2011e80: d2 06 60 08 ld [ %i1 + 8 ], %o1 <== NOT EXECUTED
2011e84: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
2011e88: 02 80 00 05 be 2011e9c <rtems_rfs_inode_unload+0x38> <== NOT EXECUTED
2011e8c: d4 06 60 24 ld [ %i1 + 0x24 ], %o2 <== NOT EXECUTED
2011e90: 17 00 80 cb sethi %hi(0x2032c00), %o3 <== NOT EXECUTED
2011e94: 10 80 00 04 b 2011ea4 <rtems_rfs_inode_unload+0x40> <== NOT EXECUTED
2011e98: 96 12 e1 28 or %o3, 0x128, %o3 ! 2032d28 <_CPU_Trap_slot_template+0xaf0><== NOT EXECUTED
2011e9c: 17 00 80 c3 sethi %hi(0x2030c00), %o3 <== NOT EXECUTED
2011ea0: 96 12 e2 18 or %o3, 0x218, %o3 ! 2030e18 <__FUNCTION__.7059+0x5f8><== NOT EXECUTED
2011ea4: 11 00 80 cb sethi %hi(0x2032c00), %o0 <== NOT EXECUTED
2011ea8: 40 00 40 94 call 20220f8 <printf> <== NOT EXECUTED
2011eac: 90 12 21 90 or %o0, 0x190, %o0 ! 2032d90 <_CPU_Trap_slot_template+0xb58><== NOT EXECUTED
handle->ino, handle->loads,
rtems_rfs_inode_is_loaded (handle) ? "yes" : "no");
if (rtems_rfs_inode_is_loaded (handle))
2011eb0: c2 06 60 0c ld [ %i1 + 0xc ], %g1 <== NOT EXECUTED
2011eb4: 80 a0 60 00 cmp %g1, 0
2011eb8: 32 80 00 04 bne,a 2011ec8 <rtems_rfs_inode_unload+0x64>
2011ebc: 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;
2011ec0: 10 80 00 23 b 2011f4c <rtems_rfs_inode_unload+0xe8>
2011ec4: 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)
2011ec8: 80 a0 a0 00 cmp %g2, 0
2011ecc: 02 80 00 20 be 2011f4c <rtems_rfs_inode_unload+0xe8> <== NEVER TAKEN
2011ed0: 90 10 20 05 mov 5, %o0
return EIO;
handle->loads--;
2011ed4: 82 00 bf ff add %g2, -1, %g1
if (handle->loads == 0)
2011ed8: 80 a0 60 00 cmp %g1, 0
2011edc: 12 bf ff f9 bne 2011ec0 <rtems_rfs_inode_unload+0x5c>
2011ee0: 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)
2011ee4: c2 0e 60 10 ldub [ %i1 + 0x10 ], %g1
2011ee8: 80 a0 60 00 cmp %g1, 0
2011eec: 02 80 00 15 be 2011f40 <rtems_rfs_inode_unload+0xdc>
2011ef0: 90 10 00 18 mov %i0, %o0
2011ef4: 80 a6 a0 00 cmp %i2, 0
2011ef8: 02 80 00 12 be 2011f40 <rtems_rfs_inode_unload+0xdc> <== NEVER TAKEN
2011efc: 01 00 00 00 nop
rtems_rfs_inode_set_ctime (handle, time (NULL));
2011f00: 40 00 50 7d call 20260f4 <time>
2011f04: 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);
2011f08: c4 06 60 0c ld [ %i1 + 0xc ], %g2
2011f0c: 87 32 20 18 srl %o0, 0x18, %g3
2011f10: c6 28 a0 18 stb %g3, [ %g2 + 0x18 ]
2011f14: c4 06 60 0c ld [ %i1 + 0xc ], %g2
2011f18: 87 32 20 10 srl %o0, 0x10, %g3
2011f1c: c6 28 a0 19 stb %g3, [ %g2 + 0x19 ]
2011f20: c4 06 60 0c ld [ %i1 + 0xc ], %g2
2011f24: 87 32 20 08 srl %o0, 8, %g3
2011f28: c6 28 a0 1a stb %g3, [ %g2 + 0x1a ]
2011f2c: c4 06 60 0c ld [ %i1 + 0xc ], %g2
rtems_rfs_buffer_mark_dirty (&handle->buffer);
2011f30: 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);
2011f34: d0 28 a0 1b stb %o0, [ %g2 + 0x1b ]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
2011f38: c2 2e 60 10 stb %g1, [ %i1 + 0x10 ]
rc = rtems_rfs_buffer_handle_release (fs, &handle->buffer);
2011f3c: 90 10 00 18 mov %i0, %o0
2011f40: 40 00 25 26 call 201b3d8 <rtems_rfs_buffer_handle_release>
2011f44: 92 06 60 10 add %i1, 0x10, %o1
handle->node = NULL;
2011f48: c0 26 60 0c clr [ %i1 + 0xc ]
}
}
return rc;
}
2011f4c: 81 c7 e0 08 ret
2011f50: 91 e8 00 08 restore %g0, %o0, %o0
0201e6d0 <rtems_rfs_link>:
const char* name,
int length,
rtems_rfs_ino parent,
rtems_rfs_ino target,
bool link_dir)
{
201e6d0: 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))
201e6d4: 90 10 20 00 clr %o0
201e6d8: 7f ff d4 3e call 20137d0 <rtems_rfs_trace>
201e6dc: 13 00 40 00 sethi %hi(0x1000000), %o1
201e6e0: 80 8a 20 ff btst 0xff, %o0
201e6e4: 02 80 00 13 be 201e730 <rtems_rfs_link+0x60> <== ALWAYS TAKEN
201e6e8: 90 10 00 18 mov %i0, %o0
{
int c;
printf ("rtems-rfs: link: parent(%" PRIu32 ") -> ", parent);
201e6ec: 11 00 80 d2 sethi %hi(0x2034800), %o0 <== NOT EXECUTED
201e6f0: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
201e6f4: 90 12 22 e0 or %o0, 0x2e0, %o0 <== NOT EXECUTED
201e6f8: 40 00 0e 80 call 20220f8 <printf> <== NOT EXECUTED
201e6fc: a0 10 20 00 clr %l0 <== NOT EXECUTED
for (c = 0; c < length; c++)
201e700: 10 80 00 05 b 201e714 <rtems_rfs_link+0x44> <== NOT EXECUTED
201e704: 80 a4 00 1a cmp %l0, %i2 <== NOT EXECUTED
printf ("%c", name[c]);
201e708: 40 00 0e e6 call 20222a0 <putchar> <== NOT EXECUTED
201e70c: 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++)
201e710: 80 a4 00 1a cmp %l0, %i2 <== NOT EXECUTED
201e714: 26 bf ff fd bl,a 201e708 <rtems_rfs_link+0x38> <== NOT EXECUTED
201e718: d0 4e 40 10 ldsb [ %i1 + %l0 ], %o0 <== NOT EXECUTED
printf ("%c", name[c]);
printf ("(%" PRIu32 ")\n", target);
201e71c: 11 00 80 d2 sethi %hi(0x2034800), %o0 <== NOT EXECUTED
201e720: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
201e724: 40 00 0e 75 call 20220f8 <printf> <== NOT EXECUTED
201e728: 90 12 23 08 or %o0, 0x308, %o0 <== NOT EXECUTED
}
rc = rtems_rfs_inode_open (fs, target, &target_inode, true);
201e72c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
201e730: 92 10 00 1c mov %i4, %o1
201e734: 94 07 bf d8 add %fp, -40, %o2
201e738: 7f ff cd 95 call 2011d8c <rtems_rfs_inode_open>
201e73c: 96 10 20 01 mov 1, %o3
if (rc)
201e740: a0 92 20 00 orcc %o0, 0, %l0
201e744: 12 80 00 49 bne 201e868 <rtems_rfs_link+0x198> <== NEVER TAKEN
201e748: 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)))
201e74c: 12 80 00 10 bne 201e78c <rtems_rfs_link+0xbc> <== NEVER TAKEN
201e750: 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);
201e754: c2 07 bf e4 ld [ %fp + -28 ], %g1
201e758: c4 08 60 02 ldub [ %g1 + 2 ], %g2
201e75c: 03 00 00 3c sethi %hi(0xf000), %g1
201e760: 85 28 a0 08 sll %g2, 8, %g2
201e764: 84 08 80 01 and %g2, %g1, %g2
201e768: 03 00 00 10 sethi %hi(0x4000), %g1
201e76c: 80 a0 80 01 cmp %g2, %g1
201e770: 12 80 00 08 bne 201e790 <rtems_rfs_link+0xc0> <== ALWAYS TAKEN
201e774: 92 10 00 1b mov %i3, %o1
{
rtems_rfs_inode_close (fs, &target_inode);
201e778: 92 07 bf d8 add %fp, -40, %o1 <== NOT EXECUTED
201e77c: 7f ff cd f6 call 2011f54 <rtems_rfs_inode_close> <== NOT EXECUTED
201e780: a0 10 20 86 mov 0x86, %l0 <== NOT EXECUTED
}
rc = rtems_rfs_inode_close (fs, &target_inode);
return rc;
}
201e784: 81 c7 e0 08 ret <== NOT EXECUTED
201e788: 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);
201e78c: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
201e790: 94 07 bf b0 add %fp, -80, %o2
201e794: 7f ff cd 7e call 2011d8c <rtems_rfs_inode_open>
201e798: 96 10 20 01 mov 1, %o3
201e79c: a0 10 00 08 mov %o0, %l0
if (rc)
201e7a0: 80 a4 20 00 cmp %l0, 0
201e7a4: 02 80 00 04 be 201e7b4 <rtems_rfs_link+0xe4> <== ALWAYS TAKEN
201e7a8: 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);
201e7ac: 10 80 00 0f b 201e7e8 <rtems_rfs_link+0x118> <== NOT EXECUTED
201e7b0: 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);
201e7b4: 92 07 bf b0 add %fp, -80, %o1
201e7b8: 94 10 00 19 mov %i1, %o2
201e7bc: 96 10 00 1a mov %i2, %o3
201e7c0: 7f ff f6 77 call 201c19c <rtems_rfs_dir_add_entry>
201e7c4: 98 10 00 1c mov %i4, %o4
if (rc > 0)
201e7c8: a0 92 20 00 orcc %o0, 0, %l0
201e7cc: 04 80 00 0a ble 201e7f4 <rtems_rfs_link+0x124> <== ALWAYS TAKEN
201e7d0: 92 07 bf b0 add %fp, -80, %o1
{
rtems_rfs_inode_close (fs, &parent_inode);
201e7d4: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
201e7d8: 7f ff cd df call 2011f54 <rtems_rfs_inode_close> <== NOT EXECUTED
201e7dc: 01 00 00 00 nop <== NOT EXECUTED
rtems_rfs_inode_close (fs, &target_inode);
201e7e0: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
201e7e4: 92 07 bf d8 add %fp, -40, %o1 <== NOT EXECUTED
201e7e8: 7f ff cd db call 2011f54 <rtems_rfs_inode_close> <== NOT EXECUTED
201e7ec: b0 10 00 10 mov %l0, %i0 <== NOT EXECUTED
201e7f0: 30 80 00 1f b,a 201e86c <rtems_rfs_link+0x19c> <== NOT EXECUTED
return rc;
}
links = rtems_rfs_inode_get_links (&target_inode) + 1;
201e7f4: 7f ff ff a8 call 201e694 <rtems_rfs_inode_get_links>
201e7f8: 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);
201e7fc: c2 07 bf e4 ld [ %fp + -28 ], %g1
201e800: 90 02 20 01 inc %o0
201e804: 85 32 20 08 srl %o0, 8, %g2
201e808: c4 28 40 00 stb %g2, [ %g1 ]
201e80c: 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);
201e810: 92 10 20 01 mov 1, %o1
201e814: d0 28 60 01 stb %o0, [ %g1 + 1 ]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
201e818: 82 10 20 01 mov 1, %g1
201e81c: 90 07 bf b0 add %fp, -80, %o0
201e820: c2 2f bf e8 stb %g1, [ %fp + -24 ]
201e824: 7f ff ce 24 call 20120b4 <rtems_rfs_inode_time_stamp_now>
201e828: 94 10 20 01 mov 1, %o2
if (rc > 0)
{
rtems_rfs_inode_close (fs, &parent_inode);
201e82c: 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);
201e830: a0 10 00 08 mov %o0, %l0
if (rc > 0)
201e834: 80 a4 20 00 cmp %l0, 0
201e838: 14 bf ff e8 bg 201e7d8 <rtems_rfs_link+0x108> <== NEVER TAKEN
201e83c: 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);
201e840: 7f ff cd c5 call 2011f54 <rtems_rfs_inode_close>
201e844: 01 00 00 00 nop
if (rc > 0)
{
rtems_rfs_inode_close (fs, &target_inode);
201e848: 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);
201e84c: a0 10 00 08 mov %o0, %l0
if (rc > 0)
201e850: 80 a4 20 00 cmp %l0, 0
201e854: 14 bf ff e5 bg 201e7e8 <rtems_rfs_link+0x118> <== NEVER TAKEN
201e858: 90 10 00 18 mov %i0, %o0
{
rtems_rfs_inode_close (fs, &target_inode);
return rc;
}
rc = rtems_rfs_inode_close (fs, &target_inode);
201e85c: 7f ff cd be call 2011f54 <rtems_rfs_inode_close>
201e860: 01 00 00 00 nop
201e864: a0 10 00 08 mov %o0, %l0
return rc;
}
201e868: b0 10 00 10 mov %l0, %i0
201e86c: 81 c7 e0 08 ret
201e870: 81 e8 00 00 restore
0201f04c <rtems_rfs_mutex_create>:
RTEMS_INHERIT_PRIORITY | RTEMS_NO_PRIORITY_CEILING | RTEMS_LOCAL)
#endif
int
rtems_rfs_mutex_create (rtems_rfs_mutex* mutex)
{
201f04c: 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'),
201f050: 11 14 91 94 sethi %hi(0x52465000), %o0
201f054: 98 10 00 18 mov %i0, %o4
201f058: 90 12 23 6d or %o0, 0x36d, %o0
201f05c: 92 10 20 01 mov 1, %o1
201f060: 94 10 20 54 mov 0x54, %o2
201f064: 96 10 20 00 clr %o3
201f068: 7f ff b6 53 call 200c9b4 <rtems_semaphore_create>
201f06c: b0 10 20 00 clr %i0
1, RTEMS_RFS_MUTEX_ATTRIBS, 0,
mutex);
if (sc != RTEMS_SUCCESSFUL)
201f070: 80 a2 20 00 cmp %o0, 0
201f074: 02 80 00 0f be 201f0b0 <rtems_rfs_mutex_create+0x64> <== ALWAYS TAKEN
201f078: ba 10 00 08 mov %o0, %i5
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
201f07c: 90 10 20 00 clr %o0 <== NOT EXECUTED
201f080: 92 10 20 04 mov 4, %o1 <== NOT EXECUTED
201f084: 7f ff d1 d3 call 20137d0 <rtems_rfs_trace> <== NOT EXECUTED
201f088: b0 10 20 05 mov 5, %i0 <== NOT EXECUTED
201f08c: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
201f090: 02 80 00 08 be 201f0b0 <rtems_rfs_mutex_create+0x64> <== NOT EXECUTED
201f094: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: mutex: open failed: %s\n",
201f098: 7f ff a3 c7 call 2007fb4 <rtems_status_text> <== NOT EXECUTED
201f09c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
201f0a0: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED
201f0a4: 11 00 80 d3 sethi %hi(0x2034c00), %o0 <== NOT EXECUTED
201f0a8: 40 00 0c 14 call 20220f8 <printf> <== NOT EXECUTED
201f0ac: 90 12 21 38 or %o0, 0x138, %o0 ! 2034d38 <CSWTCH.2+0x1658><== NOT EXECUTED
rtems_status_text (sc));
return EIO;
}
#endif
return 0;
}
201f0b0: 81 c7 e0 08 ret
201f0b4: 81 e8 00 00 restore
0201f0b8 <rtems_rfs_mutex_destroy>:
int
rtems_rfs_mutex_destroy (rtems_rfs_mutex* mutex)
{
201f0b8: 9d e3 bf a0 save %sp, -96, %sp
#if __rtems__
rtems_status_code sc;
sc = rtems_semaphore_delete (*mutex);
201f0bc: d0 06 00 00 ld [ %i0 ], %o0
201f0c0: 7f ff b6 ac call 200cb70 <rtems_semaphore_delete>
201f0c4: b0 10 20 00 clr %i0
if (sc != RTEMS_SUCCESSFUL)
201f0c8: 80 a2 20 00 cmp %o0, 0
201f0cc: 02 80 00 0f be 201f108 <rtems_rfs_mutex_destroy+0x50> <== ALWAYS TAKEN
201f0d0: ba 10 00 08 mov %o0, %i5
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
201f0d4: 90 10 20 00 clr %o0 <== NOT EXECUTED
201f0d8: 92 10 20 04 mov 4, %o1 <== NOT EXECUTED
201f0dc: 7f ff d1 bd call 20137d0 <rtems_rfs_trace> <== NOT EXECUTED
201f0e0: b0 10 20 05 mov 5, %i0 <== NOT EXECUTED
201f0e4: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
201f0e8: 02 80 00 08 be 201f108 <rtems_rfs_mutex_destroy+0x50> <== NOT EXECUTED
201f0ec: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: mutex: close failed: %s\n",
201f0f0: 7f ff a3 b1 call 2007fb4 <rtems_status_text> <== NOT EXECUTED
201f0f4: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
201f0f8: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED
201f0fc: 11 00 80 d3 sethi %hi(0x2034c00), %o0 <== NOT EXECUTED
201f100: 40 00 0b fe call 20220f8 <printf> <== NOT EXECUTED
201f104: 90 12 21 60 or %o0, 0x160, %o0 ! 2034d60 <CSWTCH.2+0x1680><== NOT EXECUTED
rtems_status_text (sc));
return EIO;
}
#endif
return 0;
}
201f108: 81 c7 e0 08 ret
201f10c: 81 e8 00 00 restore
0201f328 <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)
201f328: 9d e3 bf a0 save %sp, -96, %sp
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
201f32c: 92 10 20 00 clr %o1
201f330: 90 10 00 18 mov %i0, %o0
201f334: 94 10 20 00 clr %o2
201f338: 7f ff b6 3d call 200cc2c <rtems_semaphore_obtain>
201f33c: b0 10 20 00 clr %i0
if (sc != RTEMS_SUCCESSFUL)
201f340: 80 a2 20 00 cmp %o0, 0
201f344: 02 80 00 0f be 201f380 <rtems_rfs_mutex_lock.isra.0+0x58> <== ALWAYS TAKEN
201f348: ba 10 00 08 mov %o0, %i5
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
201f34c: 90 10 20 00 clr %o0 <== NOT EXECUTED
201f350: 92 10 20 04 mov 4, %o1 <== NOT EXECUTED
201f354: 7f ff d1 1f call 20137d0 <rtems_rfs_trace> <== NOT EXECUTED
201f358: b0 10 20 05 mov 5, %i0 <== NOT EXECUTED
201f35c: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
201f360: 02 80 00 08 be 201f380 <rtems_rfs_mutex_lock.isra.0+0x58> <== NOT EXECUTED
201f364: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: mutex: obtain failed: %s\n",
201f368: 7f ff a3 13 call 2007fb4 <rtems_status_text> <== NOT EXECUTED
201f36c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
201f370: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED
201f374: 11 00 80 cb sethi %hi(0x2032c00), %o0 <== NOT EXECUTED
201f378: 40 00 0b 60 call 20220f8 <printf> <== NOT EXECUTED
201f37c: 90 12 22 f0 or %o0, 0x2f0, %o0 ! 2032ef0 <_CPU_Trap_slot_template+0xcb8><== NOT EXECUTED
#endif
return EIO;
}
#endif
return 0;
}
201f380: 81 c7 e0 08 ret
201f384: 81 e8 00 00 restore
02012d94 <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)
2012d94: 9d e3 bf a0 save %sp, -96, %sp
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
2012d98: 92 10 20 00 clr %o1
2012d9c: 90 10 00 18 mov %i0, %o0
2012da0: 94 10 20 00 clr %o2
2012da4: 7f ff e7 a2 call 200cc2c <rtems_semaphore_obtain>
2012da8: b0 10 20 00 clr %i0
if (sc != RTEMS_SUCCESSFUL)
2012dac: 80 a2 20 00 cmp %o0, 0
2012db0: 02 80 00 0f be 2012dec <rtems_rfs_mutex_lock.isra.3+0x58> <== ALWAYS TAKEN
2012db4: ba 10 00 08 mov %o0, %i5
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
2012db8: 90 10 20 00 clr %o0 <== NOT EXECUTED
2012dbc: 92 10 20 04 mov 4, %o1 <== NOT EXECUTED
2012dc0: 40 00 02 84 call 20137d0 <rtems_rfs_trace> <== NOT EXECUTED
2012dc4: b0 10 20 05 mov 5, %i0 <== NOT EXECUTED
2012dc8: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
2012dcc: 02 80 00 08 be 2012dec <rtems_rfs_mutex_lock.isra.3+0x58> <== NOT EXECUTED
2012dd0: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: mutex: obtain failed: %s\n",
2012dd4: 7f ff d4 78 call 2007fb4 <rtems_status_text> <== NOT EXECUTED
2012dd8: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
2012ddc: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED
2012de0: 11 00 80 cb sethi %hi(0x2032c00), %o0 <== NOT EXECUTED
2012de4: 40 00 3c c5 call 20220f8 <printf> <== NOT EXECUTED
2012de8: 90 12 22 f0 or %o0, 0x2f0, %o0 ! 2032ef0 <_CPU_Trap_slot_template+0xcb8><== NOT EXECUTED
#endif
return EIO;
}
#endif
return 0;
}
2012dec: 81 c7 e0 08 ret
2012df0: 81 e8 00 00 restore
02012d3c <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)
2012d3c: 9d e3 bf a0 save %sp, -96, %sp
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
2012d40: 90 10 00 18 mov %i0, %o0
2012d44: 7f ff e8 04 call 200cd54 <rtems_semaphore_release>
2012d48: b0 10 20 00 clr %i0
if (sc != RTEMS_SUCCESSFUL)
2012d4c: 80 a2 20 00 cmp %o0, 0
2012d50: 02 80 00 0f be 2012d8c <rtems_rfs_mutex_unlock.isra.2+0x50><== ALWAYS TAKEN
2012d54: ba 10 00 08 mov %o0, %i5
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
2012d58: 90 10 20 00 clr %o0 <== NOT EXECUTED
2012d5c: 92 10 20 04 mov 4, %o1 <== NOT EXECUTED
2012d60: 40 00 02 9c call 20137d0 <rtems_rfs_trace> <== NOT EXECUTED
2012d64: b0 10 20 05 mov 5, %i0 <== NOT EXECUTED
2012d68: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
2012d6c: 02 80 00 08 be 2012d8c <rtems_rfs_mutex_unlock.isra.2+0x50><== NOT EXECUTED
2012d70: 01 00 00 00 nop <== NOT EXECUTED
printf ("rtems-rfs: mutex: release failed: %s\n",
2012d74: 7f ff d4 90 call 2007fb4 <rtems_status_text> <== NOT EXECUTED
2012d78: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
2012d7c: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED
2012d80: 11 00 80 cb sethi %hi(0x2032c00), %o0 <== NOT EXECUTED
2012d84: 40 00 3c dd call 20220f8 <printf> <== NOT EXECUTED
2012d88: 90 12 22 c8 or %o0, 0x2c8, %o0 ! 2032ec8 <_CPU_Trap_slot_template+0xc90><== NOT EXECUTED
#endif
return EIO;
}
#endif
return 0;
}
2012d8c: 81 c7 e0 08 ret
2012d90: 81 e8 00 00 restore
0201b258 <rtems_rfs_release_chain>:
static int
rtems_rfs_release_chain (rtems_chain_control* chain,
uint32_t* count,
bool modified)
{
201b258: 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))
201b25c: 90 10 20 00 clr %o0
201b260: 92 10 20 80 mov 0x80, %o1
201b264: 7f ff e1 5b call 20137d0 <rtems_rfs_trace>
201b268: ba 10 00 18 mov %i0, %i5
201b26c: 80 8a 20 ff btst 0xff, %o0
201b270: 22 80 00 07 be,a 201b28c <rtems_rfs_release_chain+0x34> <== ALWAYS TAKEN
201b274: b0 10 20 00 clr %i0
printf ("rtems-rfs: release-chain: count=%" PRIu32 "\n", *count);
201b278: d2 06 40 00 ld [ %i1 ], %o1 <== NOT EXECUTED
201b27c: 11 00 80 cd sethi %hi(0x2033400), %o0 <== NOT EXECUTED
201b280: 40 00 1b 9e call 20220f8 <printf> <== NOT EXECUTED
201b284: 90 12 23 e8 or %o0, 0x3e8, %o0 ! 20337e8 <CSWTCH.2+0x108> <== NOT EXECUTED
(*count)--;
buffer->user = (void*) 0;
rc = rtems_rfs_buffer_io_release (buffer, modified);
if ((rc > 0) && (rrc == 0))
201b288: b0 10 20 00 clr %i0 <== NOT EXECUTED
201b28c: 10 80 00 10 b 201b2cc <rtems_rfs_release_chain+0x74>
201b290: b8 07 60 04 add %i5, 4, %i4
*/
RTEMS_INLINE_ROUTINE rtems_chain_node *rtems_chain_get(
rtems_chain_control *the_chain
)
{
return _Chain_Get( the_chain );
201b294: 7f ff c8 fa call 200d67c <_Chain_Get>
201b298: 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)--;
201b29c: c2 06 40 00 ld [ %i1 ], %g1
buffer->user = (void*) 0;
rc = rtems_rfs_buffer_io_release (buffer, modified);
201b2a0: 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)--;
201b2a4: 82 00 7f ff add %g1, -1, %g1
201b2a8: c2 26 40 00 st %g1, [ %i1 ]
buffer->user = (void*) 0;
rc = rtems_rfs_buffer_io_release (buffer, modified);
201b2ac: 40 00 15 2c call 202075c <rtems_rfs_buffer_bdbuf_release>
201b2b0: c0 22 20 34 clr [ %o0 + 0x34 ]
if ((rc > 0) && (rrc == 0))
201b2b4: 80 a2 20 00 cmp %o0, 0
201b2b8: 24 80 00 06 ble,a 201b2d0 <rtems_rfs_release_chain+0x78> <== ALWAYS TAKEN
201b2bc: c2 07 40 00 ld [ %i5 ], %g1
201b2c0: 80 a6 20 00 cmp %i0, 0 <== NOT EXECUTED
201b2c4: 22 80 00 02 be,a 201b2cc <rtems_rfs_release_chain+0x74> <== NOT EXECUTED
201b2c8: 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))
201b2cc: c2 07 40 00 ld [ %i5 ], %g1
201b2d0: 80 a0 40 1c cmp %g1, %i4
201b2d4: 12 bf ff f0 bne 201b294 <rtems_rfs_release_chain+0x3c>
201b2d8: 01 00 00 00 nop
rc = rtems_rfs_buffer_io_release (buffer, modified);
if ((rc > 0) && (rrc == 0))
rrc = rc;
}
return rrc;
}
201b2dc: 81 c7 e0 08 ret
201b2e0: 81 e8 00 00 restore
020129dc <rtems_rfs_rtems_chown>:
static int
rtems_rfs_rtems_chown (const rtems_filesystem_location_info_t *pathloc,
uid_t owner,
gid_t group)
{
20129dc: 9d e3 bf 78 save %sp, -136, %sp
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
20129e0: 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);
20129e4: 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);
20129e8: 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);
20129ec: 94 07 bf d8 add %fp, -40, %o2
20129f0: 90 10 00 1d mov %i5, %o0
20129f4: 7f ff fc e6 call 2011d8c <rtems_rfs_inode_open>
20129f8: 96 10 20 01 mov 1, %o3
if (rc > 0)
20129fc: b8 92 20 00 orcc %o0, 0, %i4
2012a00: 04 80 00 07 ble 2012a1c <rtems_rfs_rtems_chown+0x40> <== ALWAYS TAKEN
2012a04: 01 00 00 00 nop
{
return rtems_rfs_rtems_error ("chown: opening inode", rc);
2012a08: 40 00 38 6d call 2020bbc <__errno> <== NOT EXECUTED
2012a0c: b0 10 3f ff mov -1, %i0 ! ffffffff <RAM_END+0xfdbfffff> <== NOT EXECUTED
2012a10: f8 22 00 00 st %i4, [ %o0 ] <== NOT EXECUTED
2012a14: 81 c7 e0 08 ret <== NOT EXECUTED
2012a18: 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();
2012a1c: 40 00 11 21 call 2016ea0 <geteuid>
2012a20: 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;
2012a24: c2 07 bf e4 ld [ %fp + -28 ], %g1
if ((uid != rtems_rfs_inode_get_uid (&inode)) && (uid != 0))
2012a28: 91 2a 20 10 sll %o0, 0x10, %o0
2012a2c: c6 08 60 07 ldub [ %g1 + 7 ], %g3
2012a30: c4 08 60 06 ldub [ %g1 + 6 ], %g2
2012a34: 85 28 a0 08 sll %g2, 8, %g2
2012a38: 84 10 80 03 or %g2, %g3, %g2
2012a3c: 85 28 a0 10 sll %g2, 0x10, %g2
2012a40: 80 a0 80 08 cmp %g2, %o0
2012a44: 02 80 00 0e be 2012a7c <rtems_rfs_rtems_chown+0xa0> <== ALWAYS TAKEN
2012a48: 87 32 20 10 srl %o0, 0x10, %g3
2012a4c: 80 a0 e0 00 cmp %g3, 0 <== NOT EXECUTED
2012a50: 22 80 00 0c be,a 2012a80 <rtems_rfs_rtems_chown+0xa4> <== NOT EXECUTED
2012a54: b5 2e a0 10 sll %i2, 0x10, %i2 <== NOT EXECUTED
{
rtems_rfs_inode_close (fs, &inode);
2012a58: 92 07 bf d8 add %fp, -40, %o1 <== NOT EXECUTED
2012a5c: 7f ff fd 3e call 2011f54 <rtems_rfs_inode_close> <== NOT EXECUTED
2012a60: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
return rtems_rfs_rtems_error ("chown: not able", EPERM);
2012a64: 40 00 38 56 call 2020bbc <__errno> <== NOT EXECUTED
2012a68: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
2012a6c: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED
2012a70: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
2012a74: 81 c7 e0 08 ret <== NOT EXECUTED
2012a78: 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);
2012a7c: b5 2e a0 10 sll %i2, 0x10, %i2
2012a80: b4 16 80 19 or %i2, %i1, %i2
2012a84: 85 36 a0 18 srl %i2, 0x18, %g2
2012a88: c4 28 60 04 stb %g2, [ %g1 + 4 ]
2012a8c: c2 07 bf e4 ld [ %fp + -28 ], %g1
2012a90: 85 36 a0 10 srl %i2, 0x10, %g2
2012a94: c4 28 60 05 stb %g2, [ %g1 + 5 ]
2012a98: c2 07 bf e4 ld [ %fp + -28 ], %g1
2012a9c: b5 36 a0 08 srl %i2, 8, %i2
2012aa0: f4 28 60 06 stb %i2, [ %g1 + 6 ]
2012aa4: 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);
2012aa8: 90 10 00 1d mov %i5, %o0
2012aac: f2 28 60 07 stb %i1, [ %g1 + 7 ]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
2012ab0: 82 10 20 01 mov 1, %g1
2012ab4: 92 07 bf d8 add %fp, -40, %o1
2012ab8: c2 2f bf e8 stb %g1, [ %fp + -24 ]
2012abc: 7f ff fd 26 call 2011f54 <rtems_rfs_inode_close>
2012ac0: b0 10 20 00 clr %i0
if (rc)
2012ac4: 80 a2 20 00 cmp %o0, 0
2012ac8: 02 80 00 05 be 2012adc <rtems_rfs_rtems_chown+0x100> <== ALWAYS TAKEN
2012acc: ba 10 00 08 mov %o0, %i5
{
return rtems_rfs_rtems_error ("chown: closing inode", rc);
2012ad0: 40 00 38 3b call 2020bbc <__errno> <== NOT EXECUTED
2012ad4: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
2012ad8: fa 22 00 00 st %i5, [ %o0 ] <== NOT EXECUTED
}
return 0;
}
2012adc: 81 c7 e0 08 ret
2012ae0: 81 e8 00 00 restore
0201f194 <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);
201f194: d2 02 20 2c ld [ %o0 + 0x2c ], %o1 <== NOT EXECUTED
201f198: d4 02 20 30 ld [ %o0 + 0x30 ], %o2 <== NOT EXECUTED
201f19c: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED
201f1a0: 40 00 03 36 call 201fe78 <rtems_deviceio_close> <== NOT EXECUTED
201f1a4: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED
0201f150 <rtems_rfs_rtems_device_ftruncate>:
static int
rtems_rfs_rtems_device_ftruncate (rtems_libio_t* iop, off_t length)
{
return 0;
}
201f150: 81 c3 e0 08 retl <== NOT EXECUTED
201f154: 90 10 20 00 clr %o0 <== NOT EXECUTED
0201f158 <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);
201f158: d6 02 20 2c ld [ %o0 + 0x2c ], %o3 <== NOT EXECUTED
201f15c: d8 02 20 30 ld [ %o0 + 0x30 ], %o4 <== NOT EXECUTED
201f160: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED
201f164: 40 00 03 85 call 201ff78 <rtems_deviceio_control> <== NOT EXECUTED
201f168: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED
0201f1fc <rtems_rfs_rtems_device_open>:
static int
rtems_rfs_rtems_device_open ( rtems_libio_t *iop,
const char *pathname,
int oflag,
mode_t mode)
{
201f1fc: 9d e3 bf 78 save %sp, -136, %sp <== NOT EXECUTED
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (&iop->pathinfo);
201f200: c2 06 20 28 ld [ %i0 + 0x28 ], %g1 <== NOT EXECUTED
rtems_rfs_ino ino = rtems_rfs_rtems_get_iop_ino (iop);
201f204: 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);
201f208: 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);
201f20c: 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
};
201f210: c2 07 60 80 ld [ %i5 + 0x80 ], %g1 <== NOT EXECUTED
201f214: 94 10 20 00 clr %o2 <== NOT EXECUTED
201f218: 7f ff b6 85 call 200cc2c <rtems_semaphore_obtain> <== NOT EXECUTED
201f21c: d0 00 40 00 ld [ %g1 ], %o0 <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
201f220: b8 92 20 00 orcc %o0, 0, %i4 <== NOT EXECUTED
201f224: 02 80 00 0f be 201f260 <rtems_rfs_rtems_device_open+0x64> <== NOT EXECUTED
201f228: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
201f22c: 90 10 20 00 clr %o0 <== NOT EXECUTED
201f230: 7f ff d1 68 call 20137d0 <rtems_rfs_trace> <== NOT EXECUTED
201f234: 92 10 20 04 mov 4, %o1 <== NOT EXECUTED
201f238: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
201f23c: 22 80 00 09 be,a 201f260 <rtems_rfs_rtems_device_open+0x64><== NOT EXECUTED
201f240: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
printf ("rtems-rfs: mutex: obtain failed: %s\n",
201f244: 7f ff a3 5c call 2007fb4 <rtems_status_text> <== NOT EXECUTED
201f248: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
201f24c: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED
201f250: 11 00 80 cb sethi %hi(0x2032c00), %o0 <== NOT EXECUTED
201f254: 40 00 0b a9 call 20220f8 <printf> <== NOT EXECUTED
201f258: 90 12 22 f0 or %o0, 0x2f0, %o0 ! 2032ef0 <_CPU_Trap_slot_template+0xcb8><== NOT EXECUTED
rtems_device_minor_number minor;
int rc;
rtems_rfs_rtems_lock (fs);
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
201f25c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
201f260: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED
201f264: 94 07 bf d8 add %fp, -40, %o2 <== NOT EXECUTED
201f268: 7f ff ca c9 call 2011d8c <rtems_rfs_inode_open> <== NOT EXECUTED
201f26c: 96 10 20 01 mov 1, %o3 <== NOT EXECUTED
if (rc > 0)
201f270: b8 92 20 00 orcc %o0, 0, %i4 <== NOT EXECUTED
201f274: 04 80 00 09 ble 201f298 <rtems_rfs_rtems_device_open+0x9c><== NOT EXECUTED
201f278: 92 10 20 00 clr %o1 <== NOT EXECUTED
{
rtems_rfs_rtems_unlock (fs);
201f27c: 7f ff ff cb call 201f1a8 <rtems_rfs_rtems_unlock> <== NOT EXECUTED
201f280: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
return rtems_rfs_rtems_error ("device_open: opening inode", rc);
201f284: 40 00 06 4e call 2020bbc <__errno> <== NOT EXECUTED
201f288: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
201f28c: f8 22 00 00 st %i4, [ %o0 ] <== NOT EXECUTED
201f290: 81 c7 e0 08 ret <== NOT EXECUTED
201f294: 81 e8 00 00 restore <== NOT EXECUTED
}
major = rtems_rfs_inode_get_block (&inode, 0);
201f298: 7f ff ff 9e call 201f110 <rtems_rfs_inode_get_block> <== NOT EXECUTED
201f29c: 90 07 bf d8 add %fp, -40, %o0 <== NOT EXECUTED
minor = rtems_rfs_inode_get_block (&inode, 1);
201f2a0: 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);
201f2a4: b8 10 00 08 mov %o0, %i4 <== NOT EXECUTED
minor = rtems_rfs_inode_get_block (&inode, 1);
201f2a8: 7f ff ff 9a call 201f110 <rtems_rfs_inode_get_block> <== NOT EXECUTED
201f2ac: 90 07 bf d8 add %fp, -40, %o0 <== NOT EXECUTED
rc = rtems_rfs_inode_close (fs, &inode);
201f2b0: 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);
201f2b4: a0 10 00 08 mov %o0, %l0 <== NOT EXECUTED
rc = rtems_rfs_inode_close (fs, &inode);
201f2b8: 7f ff cb 27 call 2011f54 <rtems_rfs_inode_close> <== NOT EXECUTED
201f2bc: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
201f2c0: a2 10 00 08 mov %o0, %l1 <== NOT EXECUTED
if (rc > 0)
201f2c4: 80 a4 60 00 cmp %l1, 0 <== NOT EXECUTED
201f2c8: 04 80 00 09 ble 201f2ec <rtems_rfs_rtems_device_open+0xf0><== NOT EXECUTED
201f2cc: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
{
rtems_rfs_rtems_unlock (fs);
201f2d0: 7f ff ff b6 call 201f1a8 <rtems_rfs_rtems_unlock> <== NOT EXECUTED
201f2d4: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
return rtems_rfs_rtems_error ("device_open: closing inode", rc);
201f2d8: 40 00 06 39 call 2020bbc <__errno> <== NOT EXECUTED
201f2dc: 01 00 00 00 nop <== NOT EXECUTED
201f2e0: e2 22 00 00 st %l1, [ %o0 ] <== NOT EXECUTED
201f2e4: 81 c7 e0 08 ret <== NOT EXECUTED
201f2e8: 81 e8 00 00 restore <== NOT EXECUTED
}
rtems_rfs_rtems_unlock (fs);
201f2ec: 7f ff ff af call 201f1a8 <rtems_rfs_rtems_unlock> <== NOT EXECUTED
201f2f0: 01 00 00 00 nop <== NOT EXECUTED
iop->data0 = major;
iop->data1 = (void *) minor;
return rtems_deviceio_open (iop, pathname, oflag, mode, minor, major);
201f2f4: 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;
201f2f8: f8 26 20 2c st %i4, [ %i0 + 0x2c ] <== NOT EXECUTED
iop->data1 = (void *) minor;
201f2fc: e0 26 20 30 st %l0, [ %i0 + 0x30 ] <== NOT EXECUTED
return rtems_deviceio_open (iop, pathname, oflag, mode, minor, major);
201f300: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
201f304: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED
201f308: 96 10 00 1b mov %i3, %o3 <== NOT EXECUTED
201f30c: 98 10 00 10 mov %l0, %o4 <== NOT EXECUTED
201f310: 40 00 02 cd call 201fe44 <rtems_deviceio_open> <== NOT EXECUTED
201f314: 9a 10 00 1c mov %i4, %o5 <== NOT EXECUTED
}
201f318: 81 c7 e0 08 ret <== NOT EXECUTED
201f31c: 91 e8 00 08 restore %g0, %o0, %o0 <== NOT EXECUTED
0201f180 <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);
201f180: d6 02 20 2c ld [ %o0 + 0x2c ], %o3 <== NOT EXECUTED
201f184: d8 02 20 30 ld [ %o0 + 0x30 ], %o4 <== NOT EXECUTED
201f188: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED
201f18c: 40 00 03 47 call 201fea8 <rtems_deviceio_read> <== NOT EXECUTED
201f190: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED
0201f16c <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);
201f16c: d6 02 20 2c ld [ %o0 + 0x2c ], %o3 <== NOT EXECUTED
201f170: d8 02 20 30 ld [ %o0 + 0x30 ], %o4 <== NOT EXECUTED
201f174: 82 13 c0 00 mov %o7, %g1 <== NOT EXECUTED
201f178: 40 00 03 66 call 201ff10 <rtems_deviceio_write> <== NOT EXECUTED
201f17c: 9e 10 40 00 mov %g1, %o7 <== NOT EXECUTED
0201f4cc <rtems_rfs_rtems_dir_open>:
static int
rtems_rfs_rtems_dir_open (rtems_libio_t* iop,
const char* pathname,
int oflag,
mode_t mode)
{
201f4cc: 9d e3 bf 78 save %sp, -136, %sp
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (&iop->pathinfo);
201f4d0: c2 06 20 28 ld [ %i0 + 0x28 ], %g1
rtems_rfs_ino ino = rtems_rfs_rtems_get_iop_ino (iop);
201f4d4: 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);
201f4d8: 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
};
201f4dc: c2 07 60 80 ld [ %i5 + 0x80 ], %g1
201f4e0: 7f ff ff 92 call 201f328 <rtems_rfs_mutex_lock.isra.0>
201f4e4: 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);
201f4e8: 92 10 00 1c mov %i4, %o1
201f4ec: 90 10 00 1d mov %i5, %o0
201f4f0: 94 07 bf d8 add %fp, -40, %o2
201f4f4: 7f ff ca 26 call 2011d8c <rtems_rfs_inode_open>
201f4f8: 96 10 20 01 mov 1, %o3
if (rc)
201f4fc: b8 92 20 00 orcc %o0, 0, %i4
201f500: 02 80 00 09 be 201f524 <rtems_rfs_rtems_dir_open+0x58> <== ALWAYS TAKEN
201f504: c2 07 bf e4 ld [ %fp + -28 ], %g1
{
rtems_rfs_rtems_unlock (fs);
201f508: 7f ff ff a0 call 201f388 <rtems_rfs_rtems_unlock> <== NOT EXECUTED
201f50c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
return rtems_rfs_rtems_error ("dir_open: opening inode", rc);
201f510: 40 00 05 ab call 2020bbc <__errno> <== NOT EXECUTED
201f514: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
201f518: f8 22 00 00 st %i4, [ %o0 ] <== NOT EXECUTED
201f51c: 81 c7 e0 08 ret <== NOT EXECUTED
201f520: 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);
201f524: c4 08 60 02 ldub [ %g1 + 2 ], %g2
}
if (!RTEMS_RFS_S_ISDIR (rtems_rfs_inode_get_mode (&inode)))
201f528: 03 00 00 3c sethi %hi(0xf000), %g1
201f52c: 85 28 a0 08 sll %g2, 8, %g2
201f530: 84 08 80 01 and %g2, %g1, %g2
201f534: 03 00 00 10 sethi %hi(0x4000), %g1
201f538: 80 a0 80 01 cmp %g2, %g1
201f53c: 02 80 00 0c be 201f56c <rtems_rfs_rtems_dir_open+0xa0> <== ALWAYS TAKEN
201f540: 92 07 bf d8 add %fp, -40, %o1
{
rtems_rfs_inode_close (fs, &inode);
201f544: 7f ff ca 84 call 2011f54 <rtems_rfs_inode_close> <== NOT EXECUTED
201f548: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
rtems_rfs_rtems_unlock (fs);
201f54c: 7f ff ff 8f call 201f388 <rtems_rfs_rtems_unlock> <== NOT EXECUTED
201f550: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
return rtems_rfs_rtems_error ("dir_open: not dir", ENOTDIR);
201f554: 40 00 05 9a call 2020bbc <__errno> <== NOT EXECUTED
201f558: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
201f55c: 82 10 20 14 mov 0x14, %g1 <== NOT EXECUTED
201f560: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
201f564: 81 c7 e0 08 ret <== NOT EXECUTED
201f568: 81 e8 00 00 restore <== NOT EXECUTED
}
iop->offset = 0;
201f56c: c0 26 20 08 clr [ %i0 + 8 ]
201f570: c0 26 20 0c clr [ %i0 + 0xc ]
rtems_rfs_inode_close (fs, &inode);
201f574: 7f ff ca 78 call 2011f54 <rtems_rfs_inode_close>
201f578: 90 10 00 1d mov %i5, %o0
rtems_rfs_rtems_unlock (fs);
201f57c: 90 10 00 1d mov %i5, %o0
201f580: 7f ff ff 82 call 201f388 <rtems_rfs_rtems_unlock>
201f584: b0 10 20 00 clr %i0
return 0;
}
201f588: 81 c7 e0 08 ret
201f58c: 81 e8 00 00 restore
0201f3dc <rtems_rfs_rtems_dir_read>:
*/
static ssize_t
rtems_rfs_rtems_dir_read (rtems_libio_t* iop,
void* buffer,
size_t count)
{
201f3dc: 9d e3 bf 70 save %sp, -144, %sp
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (&iop->pathinfo);
201f3e0: c2 06 20 28 ld [ %i0 + 0x28 ], %g1
rtems_rfs_ino ino = rtems_rfs_rtems_get_iop_ino (iop);
201f3e4: 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);
201f3e8: 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);
201f3ec: 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
};
201f3f0: 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);
201f3f4: 7f ff ff cd call 201f328 <rtems_rfs_mutex_lock.isra.0>
201f3f8: 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);
201f3fc: 92 10 00 1c mov %i4, %o1
201f400: 90 10 00 1d mov %i5, %o0
201f404: 94 10 00 10 mov %l0, %o2
201f408: 7f ff ca 61 call 2011d8c <rtems_rfs_inode_open>
201f40c: 96 10 20 01 mov 1, %o3
if (rc)
201f410: b8 92 20 00 orcc %o0, 0, %i4
201f414: 02 80 00 1f be 201f490 <rtems_rfs_rtems_dir_read+0xb4> <== ALWAYS TAKEN
201f418: 90 10 00 1a mov %i2, %o0
{
rtems_rfs_rtems_unlock (fs);
201f41c: 7f ff ff db call 201f388 <rtems_rfs_rtems_unlock> <== NOT EXECUTED
201f420: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
return rtems_rfs_rtems_error ("dir_read: read inode", rc);
201f424: 40 00 05 e6 call 2020bbc <__errno> <== NOT EXECUTED
201f428: 01 00 00 00 nop <== NOT EXECUTED
201f42c: f8 22 00 00 st %i4, [ %o0 ] <== NOT EXECUTED
201f430: 10 80 00 25 b 201f4c4 <rtems_rfs_rtems_dir_read+0xe8> <== NOT EXECUTED
201f434: 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);
201f438: d4 1e 20 08 ldd [ %i0 + 8 ], %o2
201f43c: 90 10 00 1d mov %i5, %o0
201f440: 92 10 00 10 mov %l0, %o1
201f444: 7f ff f5 37 call 201c920 <rtems_rfs_dir_read>
201f448: 9a 07 bf d4 add %fp, -44, %o5
if (rc == ENOENT)
201f44c: 80 a2 20 02 cmp %o0, 2
201f450: 02 80 00 18 be 201f4b0 <rtems_rfs_rtems_dir_read+0xd4>
201f454: b4 10 00 08 mov %o0, %i2
{
rc = 0;
break;
}
if (rc > 0)
201f458: 80 a2 20 00 cmp %o0, 0
201f45c: 24 80 00 06 ble,a 201f474 <rtems_rfs_rtems_dir_read+0x98><== ALWAYS TAKEN
201f460: c4 1e 20 08 ldd [ %i0 + 8 ], %g2
{
bytes_transferred = rtems_rfs_rtems_error ("dir_read: dir read", rc);
201f464: 40 00 05 d6 call 2020bbc <__errno> <== NOT EXECUTED
201f468: b8 10 3f ff mov -1, %i4 <== NOT EXECUTED
201f46c: 10 80 00 11 b 201f4b0 <rtems_rfs_rtems_dir_read+0xd4> <== NOT EXECUTED
201f470: f4 22 00 00 st %i2, [ %o0 ] <== NOT EXECUTED
break;
}
iop->offset += size;
201f474: 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,
201f478: 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;
201f47c: 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++)
201f480: b6 06 e0 01 inc %i3
if (rc > 0)
{
bytes_transferred = rtems_rfs_rtems_error ("dir_read: dir read", rc);
break;
}
iop->offset += size;
201f484: 84 40 a0 00 addx %g2, 0, %g2
201f488: 10 80 00 07 b 201f4a4 <rtems_rfs_rtems_dir_read+0xc8>
201f48c: c4 3e 20 08 std %g2, [ %i0 + 8 ]
struct dirent* dirent;
ssize_t bytes_transferred;
int d;
int rc;
count = count / sizeof (struct dirent);
201f490: 92 10 21 18 mov 0x118, %o1
201f494: 7f ff 8c 7a call 200267c <.udiv>
201f498: 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,
201f49c: b8 10 20 00 clr %i4
struct dirent* dirent;
ssize_t bytes_transferred;
int d;
int rc;
count = count / sizeof (struct dirent);
201f4a0: 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++)
201f4a4: 80 a6 c0 11 cmp %i3, %l1
201f4a8: 12 bf ff e4 bne 201f438 <rtems_rfs_rtems_dir_read+0x5c>
201f4ac: 98 06 40 1c add %i1, %i4, %o4
}
iop->offset += size;
bytes_transferred += sizeof (struct dirent);
}
rtems_rfs_inode_close (fs, &inode);
201f4b0: 90 10 00 1d mov %i5, %o0
201f4b4: 7f ff ca a8 call 2011f54 <rtems_rfs_inode_close>
201f4b8: 92 07 bf d8 add %fp, -40, %o1
rtems_rfs_rtems_unlock (fs);
201f4bc: 7f ff ff b3 call 201f388 <rtems_rfs_rtems_unlock>
201f4c0: 90 10 00 1d mov %i5, %o0
return bytes_transferred;
}
201f4c4: 81 c7 e0 08 ret
201f4c8: 91 e8 00 1c restore %g0, %i4, %o0
02012c34 <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)
{
2012c34: 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);
2012c38: 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);
2012c3c: 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);
2012c40: 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);
2012c44: 94 07 bf d8 add %fp, -40, %o2
2012c48: 90 10 00 1d mov %i5, %o0
2012c4c: 7f ff fc 50 call 2011d8c <rtems_rfs_inode_open>
2012c50: 96 10 20 01 mov 1, %o3
if (rc == 0) {
2012c54: b8 92 20 00 orcc %o0, 0, %i4
2012c58: 12 80 00 10 bne 2012c98 <rtems_rfs_rtems_eval_path+0x64> <== NEVER TAKEN
2012c5c: 90 10 00 18 mov %i0, %o0
rtems_filesystem_eval_path_generic (
2012c60: 92 07 bf d8 add %fp, -40, %o1
2012c64: 15 00 80 cb sethi %hi(0x2032c00), %o2
2012c68: 40 00 11 88 call 2017288 <rtems_filesystem_eval_path_generic>
2012c6c: 94 12 a3 d8 or %o2, 0x3d8, %o2 ! 2032fd8 <rtems_rfs_rtems_eval_config>
ctx,
&inode,
&rtems_rfs_rtems_eval_config
);
rc = rtems_rfs_inode_close (fs, &inode);
2012c70: 90 10 00 1d mov %i5, %o0
2012c74: 7f ff fc b8 call 2011f54 <rtems_rfs_inode_close>
2012c78: 92 07 bf d8 add %fp, -40, %o1
if (rc != 0) {
2012c7c: ba 92 20 00 orcc %o0, 0, %i5
2012c80: 02 80 00 0c be 2012cb0 <rtems_rfs_rtems_eval_path+0x7c> <== ALWAYS TAKEN
2012c84: 01 00 00 00 nop
rtems_filesystem_eval_path_error (
ctx,
rtems_rfs_rtems_error ("eval_path: closing inode", rc)
2012c88: 40 00 37 cd call 2020bbc <__errno> <== NOT EXECUTED
2012c8c: 01 00 00 00 nop <== NOT EXECUTED
2012c90: 10 80 00 05 b 2012ca4 <rtems_rfs_rtems_eval_path+0x70> <== NOT EXECUTED
2012c94: 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)
2012c98: 40 00 37 c9 call 2020bbc <__errno> <== NOT EXECUTED
2012c9c: 01 00 00 00 nop <== NOT EXECUTED
2012ca0: 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 (
2012ca4: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
2012ca8: 7f ff db 16 call 2009900 <rtems_filesystem_eval_path_error><== NOT EXECUTED
2012cac: 92 10 3f ff mov -1, %o1 <== NOT EXECUTED
2012cb0: 81 c7 e0 08 ret
2012cb4: 81 e8 00 00 restore
020130f0 <rtems_rfs_rtems_eval_token>:
rtems_filesystem_eval_path_context_t *ctx,
void *arg,
const char *token,
size_t tokenlen
)
{
20130f0: 9d e3 bf 90 save %sp, -112, %sp
20130f4: f8 06 60 0c ld [ %i1 + 0xc ], %i4
20130f8: 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;
20130fc: c2 0f 20 07 ldub [ %i4 + 7 ], %g1
2013100: 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(
2013104: 90 10 00 19 mov %i1, %o0
2013108: b1 2e 20 08 sll %i0, 8, %i0
201310c: 7f ff fd 52 call 2012654 <rtems_rfs_inode_get_gid>
2013110: 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);
2013114: c2 0f 20 02 ldub [ %i4 + 2 ], %g1
2013118: d4 0f 20 03 ldub [ %i4 + 3 ], %o2
201311c: 83 28 60 08 sll %g1, 8, %g1
2013120: 97 2e 20 10 sll %i0, 0x10, %o3
2013124: 99 2a 20 10 sll %o0, 0x10, %o4
2013128: 92 10 20 01 mov 1, %o1
201312c: 90 10 00 1d mov %i5, %o0
2013130: 94 12 80 01 or %o2, %g1, %o2
2013134: 97 32 e0 10 srl %o3, 0x10, %o3
2013138: 99 33 20 10 srl %o4, 0x10, %o4
201313c: 40 00 10 45 call 2017250 <rtems_filesystem_eval_path_check_access>
2013140: 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) {
2013144: 80 8a 20 ff btst 0xff, %o0
2013148: 02 80 00 71 be 201330c <rtems_rfs_rtems_eval_token+0x21c>
201314c: 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] == '.';
2013150: 12 80 00 06 bne 2013168 <rtems_rfs_rtems_eval_token+0x78>
2013154: 82 10 20 00 clr %g1
2013158: c2 4e 80 00 ldsb [ %i2 ], %g1
201315c: 82 18 60 2e xor %g1, 0x2e, %g1
2013160: 80 a0 00 01 cmp %g0, %g1
2013164: 82 60 3f ff subx %g0, -1, %g1
if (rtems_filesystem_is_current_directory (token, tokenlen)) {
2013168: 80 a0 60 00 cmp %g1, 0
201316c: 22 80 00 04 be,a 201317c <rtems_rfs_rtems_eval_token+0x8c>
2013170: 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;
2013174: 10 80 00 44 b 2013284 <rtems_rfs_rtems_eval_token+0x194>
2013178: 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 (
201317c: 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);
2013180: f8 00 60 08 ld [ %g1 + 8 ], %i4
rtems_rfs_ino entry_ino;
uint32_t entry_doff;
int rc = rtems_rfs_dir_lookup_ino (
2013184: 94 10 00 1a mov %i2, %o2
2013188: 90 10 00 1c mov %i4, %o0
201318c: 96 10 00 1b mov %i3, %o3
2013190: 98 07 bf f4 add %fp, -12, %o4
2013194: 9a 07 bf f8 add %fp, -8, %o5
2013198: 40 00 22 c3 call 201bca4 <rtems_rfs_dir_lookup_ino>
201319c: b0 10 20 02 mov 2, %i0
tokenlen,
&entry_ino,
&entry_doff
);
if (rc == 0) {
20131a0: 80 a2 20 00 cmp %o0, 0
20131a4: 12 80 00 5a bne 201330c <rtems_rfs_rtems_eval_token+0x21c>
20131a8: 90 10 00 1c mov %i4, %o0
rc = rtems_rfs_inode_close (fs, inode);
20131ac: 7f ff fb 6a call 2011f54 <rtems_rfs_inode_close>
20131b0: 92 10 00 19 mov %i1, %o1
if (rc == 0) {
20131b4: 80 a2 20 00 cmp %o0, 0
20131b8: 02 80 00 07 be 20131d4 <rtems_rfs_rtems_eval_token+0xe4> <== ALWAYS TAKEN
20131bc: 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));
20131c0: 92 10 20 00 clr %o1 <== NOT EXECUTED
20131c4: 40 00 3b 4f call 2021f00 <memset> <== NOT EXECUTED
20131c8: 94 10 20 28 mov 0x28, %o2 <== NOT EXECUTED
void *arg,
const char *token,
size_t tokenlen
)
{
rtems_filesystem_eval_path_generic_status status =
20131cc: 81 c7 e0 08 ret <== NOT EXECUTED
20131d0: 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);
20131d4: d2 07 bf f4 ld [ %fp + -12 ], %o1
20131d8: 90 10 00 1c mov %i4, %o0
20131dc: 94 10 00 19 mov %i1, %o2
20131e0: 7f ff fa eb call 2011d8c <rtems_rfs_inode_open>
20131e4: 96 10 20 01 mov 1, %o3
}
if (rc != 0) {
20131e8: 80 a2 20 00 cmp %o0, 0
20131ec: 02 80 00 2f be 20132a8 <rtems_rfs_rtems_eval_token+0x1b8> <== ALWAYS TAKEN
20131f0: 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));
20131f4: 10 bf ff f4 b 20131c4 <rtems_rfs_rtems_eval_token+0xd4> <== NOT EXECUTED
20131f8: 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)) {
20131fc: 02 80 00 04 be 201320c <rtems_rfs_rtems_eval_token+0x11c>
2013200: 80 88 a0 ff btst 0xff, %g2
2013204: 02 80 00 23 be 2013290 <rtems_rfs_rtems_eval_token+0x1a0>
2013208: 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;
201320c: 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);
2013210: 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;
2013214: c2 27 bf fc st %g1, [ %fp + -4 ]
char *link = malloc(len + 1);
2013218: 7f ff d5 aa call 20088c0 <malloc>
201321c: 90 10 24 01 mov 0x401, %o0
if (link != NULL) {
2013220: b6 92 20 00 orcc %o0, 0, %i3
2013224: 02 80 00 14 be 2013274 <rtems_rfs_rtems_eval_token+0x184> <== NEVER TAKEN
2013228: 90 10 00 1c mov %i4, %o0
int rc = rtems_rfs_symlink_read (fs, ino, link, len, &len);
201322c: 92 10 00 1a mov %i2, %o1
2013230: 94 10 00 1b mov %i3, %o2
2013234: 96 10 24 00 mov 0x400, %o3
2013238: 40 00 2f 14 call 201ee88 <rtems_rfs_symlink_read>
201323c: 98 07 bf fc add %fp, -4, %o4
if (rc == 0) {
2013240: 80 a2 20 00 cmp %o0, 0
2013244: 12 80 00 06 bne 201325c <rtems_rfs_rtems_eval_token+0x16c><== NEVER TAKEN
2013248: 90 10 00 1d mov %i5, %o0
rtems_filesystem_eval_path_recursive (ctx, link, len);
201324c: d4 07 bf fc ld [ %fp + -4 ], %o2
2013250: 7f ff da aa call 2009cf8 <rtems_filesystem_eval_path_recursive>
2013254: 92 10 00 1b mov %i3, %o1
2013258: 30 80 00 03 b,a 2013264 <rtems_rfs_rtems_eval_token+0x174>
} else {
rtems_filesystem_eval_path_error (ctx, 0);
201325c: 7f ff d9 a9 call 2009900 <rtems_filesystem_eval_path_error><== NOT EXECUTED
2013260: 92 10 20 00 clr %o1 <== NOT EXECUTED
}
free(link);
2013264: 7f ff d3 f1 call 2008228 <free>
2013268: 90 10 00 1b mov %i3, %o0
void *arg,
const char *token,
size_t tokenlen
)
{
rtems_filesystem_eval_path_generic_status status =
201326c: 81 c7 e0 08 ret
2013270: 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);
2013274: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
2013278: 92 10 20 0c mov 0xc, %o1 <== NOT EXECUTED
201327c: 7f ff d9 a1 call 2009900 <rtems_filesystem_eval_path_error><== NOT EXECUTED
2013280: 01 00 00 00 nop <== NOT EXECUTED
void *arg,
const char *token,
size_t tokenlen
)
{
rtems_filesystem_eval_path_generic_status status =
2013284: 81 c7 e0 08 ret
2013288: 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;
201328c: 90 07 60 18 add %i5, 0x18, %o0
2013290: 40 00 01 1d call 2013704 <rtems_rfs_rtems_set_handlers>
2013294: 92 10 00 19 mov %i1, %o1
2013298: 80 8a 20 ff btst 0xff, %o0
201329c: 12 80 00 18 bne 20132fc <rtems_rfs_rtems_eval_token+0x20c><== ALWAYS TAKEN
20132a0: c2 07 bf f4 ld [ %fp + -12 ], %g1
20132a4: 30 80 00 0f b,a 20132e0 <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)
20132a8: 7f ff ff 53 call 2012ff4 <rtems_rfs_rtems_node_type_by_inode>
20132ac: 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);
20132b0: 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;
20132b4: c4 07 60 10 ld [ %i5 + 0x10 ], %g2
bool terminal = !rtems_filesystem_eval_path_has_path (ctx);
20132b8: 80 a0 00 01 cmp %g0, %g1
20132bc: c0 27 60 0c clr [ %i5 + 0xc ]
20132c0: 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;
20132c4: 85 30 a0 04 srl %g2, 4, %g2
bool terminal = !rtems_filesystem_eval_path_has_path (ctx);
20132c8: b0 10 00 01 mov %g1, %i0
rtems_filesystem_eval_path_clear_token (ctx);
if (is_sym_link && (follow_sym_link || !terminal)) {
20132cc: 80 a2 20 03 cmp %o0, 3
20132d0: 12 bf ff ef bne 201328c <rtems_rfs_rtems_eval_token+0x19c>
20132d4: 84 08 a0 01 and %g2, 1, %g2
20132d8: 10 bf ff c9 b 20131fc <rtems_rfs_rtems_eval_token+0x10c>
20132dc: 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)
20132e0: 40 00 36 37 call 2020bbc <__errno> <== NOT EXECUTED
20132e4: 01 00 00 00 nop <== NOT EXECUTED
20132e8: 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 (
20132ec: 92 10 3f ff mov -1, %o1 <== NOT EXECUTED
ctx,
rtems_rfs_rtems_error ("eval_path: set handlers", rc)
20132f0: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
if (!terminal) {
status = RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_CONTINUE;
}
} else {
rtems_filesystem_eval_path_error (
20132f4: 10 bf ff e2 b 201327c <rtems_rfs_rtems_eval_token+0x18c> <== NOT EXECUTED
20132f8: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
void *arg,
const char *token,
size_t tokenlen
)
{
rtems_filesystem_eval_path_generic_status status =
20132fc: 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);
2013300: c2 27 60 20 st %g1, [ %i5 + 0x20 ]
rtems_rfs_rtems_set_pathloc_doff (currentloc, entry_doff);
2013304: c2 07 bf f8 ld [ %fp + -8 ], %g1
2013308: c2 27 60 24 st %g1, [ %i5 + 0x24 ]
}
}
}
return status;
}
201330c: 81 c7 e0 08 ret
2013310: 81 e8 00 00 restore
020135b4 <rtems_rfs_rtems_fchmod>:
}
static int
rtems_rfs_rtems_fchmod (const rtems_filesystem_location_info_t* pathloc,
mode_t mode)
{
20135b4: 9d e3 bf 78 save %sp, -136, %sp
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
20135b8: 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);
20135bc: 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);
20135c0: 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);
20135c4: 94 07 bf d8 add %fp, -40, %o2
20135c8: 90 10 00 1d mov %i5, %o0
20135cc: 7f ff f9 f0 call 2011d8c <rtems_rfs_inode_open>
20135d0: 96 10 20 01 mov 1, %o3
if (rc)
20135d4: b8 92 20 00 orcc %o0, 0, %i4
20135d8: 02 80 00 07 be 20135f4 <rtems_rfs_rtems_fchmod+0x40> <== ALWAYS TAKEN
20135dc: c2 07 bf e4 ld [ %fp + -28 ], %g1
{
return rtems_rfs_rtems_error ("fchmod: opening inode", rc);
20135e0: 40 00 35 77 call 2020bbc <__errno> <== NOT EXECUTED
20135e4: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
20135e8: f8 22 00 00 st %i4, [ %o0 ] <== NOT EXECUTED
20135ec: 81 c7 e0 08 ret <== NOT EXECUTED
20135f0: 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);
20135f4: f8 08 60 02 ldub [ %g1 + 2 ], %i4
20135f8: c2 08 60 03 ldub [ %g1 + 3 ], %g1
20135fc: 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();
2013600: 40 00 0e 28 call 2016ea0 <geteuid>
2013604: 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;
2013608: c2 07 bf e4 ld [ %fp + -28 ], %g1
if ((uid != rtems_rfs_inode_get_uid (&inode)) && (uid != 0))
201360c: 91 2a 20 10 sll %o0, 0x10, %o0
2013610: c6 08 60 07 ldub [ %g1 + 7 ], %g3
2013614: c4 08 60 06 ldub [ %g1 + 6 ], %g2
2013618: 85 28 a0 08 sll %g2, 8, %g2
201361c: 84 10 80 03 or %g2, %g3, %g2
2013620: 85 28 a0 10 sll %g2, 0x10, %g2
2013624: 80 a0 80 08 cmp %g2, %o0
2013628: 02 80 00 0e be 2013660 <rtems_rfs_rtems_fchmod+0xac> <== ALWAYS TAKEN
201362c: 87 32 20 10 srl %o0, 0x10, %g3
2013630: 80 a0 e0 00 cmp %g3, 0 <== NOT EXECUTED
2013634: 22 80 00 0c be,a 2013664 <rtems_rfs_rtems_fchmod+0xb0> <== NOT EXECUTED
2013638: b8 0f 30 00 and %i4, -4096, %i4 <== NOT EXECUTED
{
rtems_rfs_inode_close (fs, &inode);
201363c: 92 07 bf d8 add %fp, -40, %o1 <== NOT EXECUTED
2013640: 7f ff fa 45 call 2011f54 <rtems_rfs_inode_close> <== NOT EXECUTED
2013644: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
return rtems_rfs_rtems_error ("fchmod: checking uid", EPERM);
2013648: 40 00 35 5d call 2020bbc <__errno> <== NOT EXECUTED
201364c: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
2013650: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED
2013654: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
2013658: 81 c7 e0 08 ret <== NOT EXECUTED
201365c: 81 e8 00 00 restore <== NOT EXECUTED
}
#endif
imode &= ~(S_IRWXU | S_IRWXG | S_IRWXO | S_ISUID | S_ISGID | S_ISVTX);
2013660: b8 0f 30 00 and %i4, -4096, %i4
imode |= mode & (S_IRWXU | S_IRWXG | S_IRWXO | S_ISUID | S_ISGID | S_ISVTX);
2013664: b2 0e 6f ff and %i1, 0xfff, %i1
2013668: 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);
201366c: 85 36 60 08 srl %i1, 8, %g2
2013670: c4 28 60 02 stb %g2, [ %g1 + 2 ]
2013674: c2 07 bf e4 ld [ %fp + -28 ], %g1
rtems_rfs_inode_set_mode (&inode, imode);
rc = rtems_rfs_inode_close (fs, &inode);
2013678: 90 10 00 1d mov %i5, %o0
201367c: f2 28 60 03 stb %i1, [ %g1 + 3 ]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
2013680: 82 10 20 01 mov 1, %g1
2013684: 92 07 bf d8 add %fp, -40, %o1
2013688: c2 2f bf e8 stb %g1, [ %fp + -24 ]
201368c: 7f ff fa 32 call 2011f54 <rtems_rfs_inode_close>
2013690: b0 10 20 00 clr %i0
if (rc > 0)
2013694: 80 a2 20 00 cmp %o0, 0
2013698: 04 80 00 05 ble 20136ac <rtems_rfs_rtems_fchmod+0xf8> <== ALWAYS TAKEN
201369c: ba 10 00 08 mov %o0, %i5
{
return rtems_rfs_rtems_error ("fchmod: closing inode", rc);
20136a0: 40 00 35 47 call 2020bbc <__errno> <== NOT EXECUTED
20136a4: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
20136a8: fa 22 00 00 st %i5, [ %o0 ] <== NOT EXECUTED
}
return 0;
}
20136ac: 81 c7 e0 08 ret
20136b0: 81 e8 00 00 restore
020136d0 <rtems_rfs_rtems_fdatasync>:
* @param iop
* @return int
*/
int
rtems_rfs_rtems_fdatasync (rtems_libio_t* iop)
{
20136d0: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED
int rc;
rc = rtems_rfs_buffer_sync (rtems_rfs_rtems_pathloc_dev (&iop->pathinfo));
20136d4: c2 06 20 28 ld [ %i0 + 0x28 ], %g1 <== NOT EXECUTED
if (rc)
return rtems_rfs_rtems_error ("fdatasync: sync", rc);
return 0;
20136d8: 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));
20136dc: 40 00 20 b7 call 201b9b8 <rtems_rfs_buffer_sync> <== NOT EXECUTED
20136e0: d0 00 60 08 ld [ %g1 + 8 ], %o0 <== NOT EXECUTED
if (rc)
20136e4: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
20136e8: 02 80 00 05 be 20136fc <rtems_rfs_rtems_fdatasync+0x2c> <== NOT EXECUTED
20136ec: ba 10 00 08 mov %o0, %i5 <== NOT EXECUTED
return rtems_rfs_rtems_error ("fdatasync: sync", rc);
20136f0: 40 00 35 33 call 2020bbc <__errno> <== NOT EXECUTED
20136f4: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
20136f8: fa 22 00 00 st %i5, [ %o0 ] <== NOT EXECUTED
return 0;
}
20136fc: 81 c7 e0 08 ret <== NOT EXECUTED
2013700: 81 e8 00 00 restore <== NOT EXECUTED
0201f900 <rtems_rfs_rtems_file_close>:
* @param iop
* @return int
*/
static int
rtems_rfs_rtems_file_close (rtems_libio_t* iop)
{
201f900: 9d e3 bf a0 save %sp, -96, %sp
rtems_rfs_file_handle* file = rtems_rfs_rtems_get_iop_file_handle (iop);
201f904: f8 06 20 20 ld [ %i0 + 0x20 ], %i4
rtems_rfs_file_system* fs = rtems_rfs_file_fs (file);
201f908: c2 07 20 1c ld [ %i4 + 0x1c ], %g1
201f90c: 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);
201f910: 7f ff ff 20 call 201f590 <rtems_rfs_rtems_lock>
201f914: 90 10 00 1d mov %i5, %o0
rc = rtems_rfs_file_close (fs, file);
201f918: 90 10 00 1d mov %i5, %o0
201f91c: 7f ff f5 7a call 201cf04 <rtems_rfs_file_close>
201f920: 92 10 00 1c mov %i4, %o1
if (rc > 0)
201f924: b0 92 20 00 orcc %o0, 0, %i0
201f928: 04 80 00 06 ble 201f940 <rtems_rfs_rtems_file_close+0x40> <== ALWAYS TAKEN
201f92c: 01 00 00 00 nop
rc = rtems_rfs_rtems_error ("file-close: file close", rc);
201f930: 40 00 04 a3 call 2020bbc <__errno> <== NOT EXECUTED
201f934: 01 00 00 00 nop <== NOT EXECUTED
201f938: f0 22 00 00 st %i0, [ %o0 ] <== NOT EXECUTED
201f93c: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
rtems_rfs_rtems_unlock (fs);
201f940: 7f ff ff 29 call 201f5e4 <rtems_rfs_rtems_unlock>
201f944: 90 10 00 1d mov %i5, %o0
return rc;
}
201f948: 81 c7 e0 08 ret
201f94c: 81 e8 00 00 restore
0201f638 <rtems_rfs_rtems_file_ftruncate>:
* @return int
*/
static int
rtems_rfs_rtems_file_ftruncate (rtems_libio_t* iop,
off_t length)
{
201f638: 9d e3 bf a0 save %sp, -96, %sp
rtems_rfs_file_handle* file = rtems_rfs_rtems_get_iop_file_handle (iop);
201f63c: 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));
201f640: c2 06 e0 1c ld [ %i3 + 0x1c ], %g1
201f644: 7f ff ff d3 call 201f590 <rtems_rfs_rtems_lock>
201f648: d0 00 60 98 ld [ %g1 + 0x98 ], %o0
rc = rtems_rfs_file_set_size (file, length);
201f64c: 90 10 00 1b mov %i3, %o0
201f650: 92 10 00 19 mov %i1, %o1
201f654: 7f ff f8 4c call 201d784 <rtems_rfs_file_set_size>
201f658: 94 10 00 1a mov %i2, %o2
if (rc)
201f65c: b0 92 20 00 orcc %o0, 0, %i0
201f660: 22 80 00 07 be,a 201f67c <rtems_rfs_rtems_file_ftruncate+0x44><== ALWAYS TAKEN
201f664: c2 06 e0 1c ld [ %i3 + 0x1c ], %g1
rc = rtems_rfs_rtems_error ("file_ftruncate: set size", rc);
201f668: 40 00 05 55 call 2020bbc <__errno> <== NOT EXECUTED
201f66c: 01 00 00 00 nop <== NOT EXECUTED
201f670: f0 22 00 00 st %i0, [ %o0 ] <== NOT EXECUTED
201f674: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
201f678: c2 06 e0 1c ld [ %i3 + 0x1c ], %g1 <== NOT EXECUTED
201f67c: 7f ff ff da call 201f5e4 <rtems_rfs_rtems_unlock>
201f680: d0 00 60 98 ld [ %g1 + 0x98 ], %o0
return rc;
}
201f684: 81 c7 e0 08 ret
201f688: 81 e8 00 00 restore
0201f68c <rtems_rfs_rtems_file_lseek>:
*/
static off_t
rtems_rfs_rtems_file_lseek (rtems_libio_t* iop,
off_t offset,
int whence)
{
201f68c: 9d e3 bf 98 save %sp, -104, %sp
201f690: b8 10 00 19 mov %i1, %i4
rtems_rfs_file_handle* file = rtems_rfs_rtems_get_iop_file_handle (iop);
201f694: 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)
{
201f698: 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));
201f69c: 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)
{
201f6a0: 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));
201f6a4: 7f ff ff bb call 201f590 <rtems_rfs_rtems_lock>
201f6a8: d0 00 60 98 ld [ %g1 + 0x98 ], %o0
old_offset = iop->offset;
new_offset = rtems_filesystem_default_lseek_file (iop, offset, whence);
201f6ac: 92 10 00 1c mov %i4, %o1
201f6b0: 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;
201f6b4: f4 1e 20 08 ldd [ %i0 + 8 ], %i2
new_offset = rtems_filesystem_default_lseek_file (iop, offset, whence);
201f6b8: 90 10 00 18 mov %i0, %o0
201f6bc: 40 00 01 25 call 201fb50 <rtems_filesystem_default_lseek_file>
201f6c0: 96 10 00 10 mov %l0, %o3
201f6c4: b8 10 00 08 mov %o0, %i4
if (new_offset != -1)
201f6c8: 80 a7 3f ff cmp %i4, -1
201f6cc: 12 80 00 05 bne 201f6e0 <rtems_rfs_rtems_file_lseek+0x54>
201f6d0: ba 10 00 09 mov %o1, %i5
201f6d4: 80 a2 7f ff cmp %o1, -1
201f6d8: 22 80 00 13 be,a 201f724 <rtems_rfs_rtems_file_lseek+0x98><== ALWAYS TAKEN
201f6dc: c2 06 60 1c ld [ %i1 + 0x1c ], %g1
{
rtems_rfs_pos pos = iop->offset;
201f6e0: c4 1e 20 08 ldd [ %i0 + 8 ], %g2
int rc = rtems_rfs_file_seek (file, pos, &pos);
201f6e4: 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;
201f6e8: c4 3f bf f8 std %g2, [ %fp + -8 ]
int rc = rtems_rfs_file_seek (file, pos, &pos);
201f6ec: 92 10 00 02 mov %g2, %o1
201f6f0: 94 10 00 03 mov %g3, %o2
201f6f4: 7f ff f7 e6 call 201d68c <rtems_rfs_file_seek>
201f6f8: 96 07 bf f8 add %fp, -8, %o3
if (rc)
201f6fc: a0 92 20 00 orcc %o0, 0, %l0
201f700: 22 80 00 09 be,a 201f724 <rtems_rfs_rtems_file_lseek+0x98><== ALWAYS TAKEN
201f704: c2 06 60 1c ld [ %i1 + 0x1c ], %g1
{
rtems_rfs_rtems_error ("file_lseek: lseek", rc);
201f708: 40 00 05 2d call 2020bbc <__errno> <== NOT EXECUTED
201f70c: 39 3f ff ff sethi %hi(0xfffffc00), %i4 <== NOT EXECUTED
201f710: e0 22 00 00 st %l0, [ %o0 ] <== NOT EXECUTED
iop->offset = old_offset;
201f714: f4 3e 20 08 std %i2, [ %i0 + 8 ] <== NOT EXECUTED
new_offset = -1;
201f718: b8 17 23 ff or %i4, 0x3ff, %i4 <== NOT EXECUTED
201f71c: ba 10 00 1c mov %i4, %i5 <== NOT EXECUTED
}
}
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
201f720: c2 06 60 1c ld [ %i1 + 0x1c ], %g1 <== NOT EXECUTED
return new_offset;
}
201f724: b0 10 00 1c mov %i4, %i0
iop->offset = old_offset;
new_offset = -1;
}
}
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
201f728: d0 00 60 98 ld [ %g1 + 0x98 ], %o0
201f72c: 7f ff ff ae call 201f5e4 <rtems_rfs_rtems_unlock>
201f730: b2 10 00 1d mov %i5, %i1
return new_offset;
}
201f734: 81 c7 e0 08 ret
201f738: 81 e8 00 00 restore
0201f950 <rtems_rfs_rtems_file_open>:
static int
rtems_rfs_rtems_file_open (rtems_libio_t* iop,
const char* pathname,
int oflag,
mode_t mode)
{
201f950: 9d e3 bf 98 save %sp, -104, %sp
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (&iop->pathinfo);
201f954: c2 06 20 28 ld [ %i0 + 0x28 ], %g1
201f958: 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);
201f95c: 7f ff ff 0d call 201f590 <rtems_rfs_rtems_lock>
201f960: 90 10 00 1d mov %i5, %o0
ino = rtems_rfs_rtems_get_iop_ino (iop);
rc = rtems_rfs_file_open (fs, ino, flags, &file);
201f964: d2 06 20 1c ld [ %i0 + 0x1c ], %o1
201f968: 90 10 00 1d mov %i5, %o0
201f96c: 94 10 20 00 clr %o2
201f970: 7f ff f8 5d call 201dae4 <rtems_rfs_file_open>
201f974: 96 07 bf fc add %fp, -4, %o3
if (rc > 0)
201f978: b8 92 20 00 orcc %o0, 0, %i4
201f97c: 04 80 00 09 ble 201f9a0 <rtems_rfs_rtems_file_open+0x50> <== ALWAYS TAKEN
201f980: c2 07 bf fc ld [ %fp + -4 ], %g1
{
rtems_rfs_rtems_unlock (fs);
201f984: 7f ff ff 18 call 201f5e4 <rtems_rfs_rtems_unlock> <== NOT EXECUTED
201f988: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
return rtems_rfs_rtems_error ("file-open: open", rc);
201f98c: 40 00 04 8c call 2020bbc <__errno> <== NOT EXECUTED
201f990: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
201f994: f8 22 00 00 st %i4, [ %o0 ] <== NOT EXECUTED
201f998: 81 c7 e0 08 ret <== NOT EXECUTED
201f99c: 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);
201f9a0: 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);
201f9a4: c2 26 20 20 st %g1, [ %i0 + 0x20 ]
rtems_rfs_rtems_unlock (fs);
201f9a8: 7f ff ff 0f call 201f5e4 <rtems_rfs_rtems_unlock>
201f9ac: b0 10 20 00 clr %i0
return 0;
}
201f9b0: 81 c7 e0 08 ret
201f9b4: 81 e8 00 00 restore
0201f9b8 <rtems_rfs_rtems_file_read>:
*/
static ssize_t
rtems_rfs_rtems_file_read (rtems_libio_t* iop,
void* buffer,
size_t count)
{
201f9b8: 9d e3 bf 98 save %sp, -104, %sp
rtems_rfs_file_handle* file = rtems_rfs_rtems_get_iop_file_handle (iop);
201f9bc: 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));
201f9c0: c2 04 20 1c ld [ %l0 + 0x1c ], %g1
201f9c4: 7f ff fe f3 call 201f590 <rtems_rfs_rtems_lock>
201f9c8: d0 00 60 98 ld [ %g1 + 0x98 ], %o0
pos = iop->offset;
if (pos < rtems_rfs_file_size (file))
201f9cc: 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;
201f9d0: f8 1e 20 08 ldd [ %i0 + 8 ], %i4
201f9d4: d0 02 60 98 ld [ %o1 + 0x98 ], %o0
201f9d8: 7f ff ea f1 call 201a59c <rtems_rfs_block_get_size>
201f9dc: 92 02 60 84 add %o1, 0x84, %o1
if (pos < rtems_rfs_file_size (file))
201f9e0: 80 a2 00 1c cmp %o0, %i4
201f9e4: 18 80 00 2a bgu 201fa8c <rtems_rfs_rtems_file_read+0xd4> <== NEVER TAKEN
201f9e8: b6 10 20 00 clr %i3
201f9ec: 80 a2 00 1c cmp %o0, %i4
201f9f0: 12 80 00 2d bne 201faa4 <rtems_rfs_rtems_file_read+0xec> <== NEVER TAKEN
201f9f4: 80 a2 40 1d cmp %o1, %i5
201f9f8: 18 80 00 26 bgu 201fa90 <rtems_rfs_rtems_file_read+0xd8>
201f9fc: 80 a6 a0 00 cmp %i2, 0
}
}
}
if (read >= 0)
iop->offset = pos + read;
201fa00: 10 80 00 2a b 201faa8 <rtems_rfs_rtems_file_read+0xf0>
201fa04: ba 86 c0 1d addcc %i3, %i5, %i5
{
while (count)
{
size_t size;
rc = rtems_rfs_file_io_start (file, &size, true);
201fa08: 92 07 bf fc add %fp, -4, %o1
201fa0c: 7f ff f5 ea call 201d1b4 <rtems_rfs_file_io_start>
201fa10: 94 10 20 01 mov 1, %o2
if (rc > 0)
201fa14: a2 92 20 00 orcc %o0, 0, %l1
201fa18: 14 80 00 19 bg 201fa7c <rtems_rfs_rtems_file_read+0xc4> <== NEVER TAKEN
201fa1c: c2 07 bf fc ld [ %fp + -4 ], %g1
{
read = rtems_rfs_rtems_error ("file-read: read: io-start", rc);
break;
}
if (size == 0)
201fa20: 80 a0 60 00 cmp %g1, 0
201fa24: 02 80 00 1d be 201fa98 <rtems_rfs_rtems_file_read+0xe0>
201fa28: 80 a0 40 1a cmp %g1, %i2
break;
if (size > count)
201fa2c: 38 80 00 02 bgu,a 201fa34 <rtems_rfs_rtems_file_read+0x7c>
201fa30: f4 27 bf fc st %i2, [ %fp + -4 ]
size = count;
memcpy (data, rtems_rfs_file_data (file), size);
201fa34: c2 04 20 0c ld [ %l0 + 0xc ], %g1
201fa38: e2 07 bf fc ld [ %fp + -4 ], %l1
201fa3c: d2 00 60 1c ld [ %g1 + 0x1c ], %o1
201fa40: c2 04 20 14 ld [ %l0 + 0x14 ], %g1
201fa44: 94 10 00 11 mov %l1, %o2
201fa48: 92 02 40 01 add %o1, %g1, %o1
201fa4c: 40 00 08 9e call 2021cc4 <memcpy>
201fa50: 90 10 00 19 mov %i1, %o0
data += size;
count -= size;
read += size;
rc = rtems_rfs_file_io_end (file, size, true);
201fa54: 92 10 00 11 mov %l1, %o1
if (size > count)
size = count;
memcpy (data, rtems_rfs_file_data (file), size);
data += size;
201fa58: b2 06 40 11 add %i1, %l1, %i1
count -= size;
201fa5c: b4 26 80 11 sub %i2, %l1, %i2
read += size;
201fa60: b6 06 c0 11 add %i3, %l1, %i3
rc = rtems_rfs_file_io_end (file, size, true);
201fa64: 90 10 00 10 mov %l0, %o0
201fa68: 7f ff f6 5c call 201d3d8 <rtems_rfs_file_io_end>
201fa6c: 94 10 20 01 mov 1, %o2
if (rc > 0)
201fa70: a2 92 20 00 orcc %o0, 0, %l1
201fa74: 04 80 00 07 ble 201fa90 <rtems_rfs_rtems_file_read+0xd8> <== ALWAYS TAKEN
201fa78: 80 a6 a0 00 cmp %i2, 0
{
read = rtems_rfs_rtems_error ("file-read: read: io-end", rc);
201fa7c: 40 00 04 50 call 2020bbc <__errno> <== NOT EXECUTED
201fa80: b6 10 3f ff mov -1, %i3 <== NOT EXECUTED
201fa84: 10 80 00 0c b 201fab4 <rtems_rfs_rtems_file_read+0xfc> <== NOT EXECUTED
201fa88: e2 22 00 00 st %l1, [ %o0 ] <== NOT EXECUTED
pos = iop->offset;
if (pos < rtems_rfs_file_size (file))
{
while (count)
201fa8c: 80 a6 a0 00 cmp %i2, 0 <== NOT EXECUTED
201fa90: 12 bf ff de bne 201fa08 <rtems_rfs_rtems_file_read+0x50>
201fa94: 90 10 00 10 mov %l0, %o0
break;
}
}
}
if (read >= 0)
201fa98: 80 a6 e0 00 cmp %i3, 0
201fa9c: 26 80 00 07 bl,a 201fab8 <rtems_rfs_rtems_file_read+0x100><== NEVER TAKEN
201faa0: c2 04 20 1c ld [ %l0 + 0x1c ], %g1 <== NOT EXECUTED
iop->offset = pos + read;
201faa4: ba 86 c0 1d addcc %i3, %i5, %i5
201faa8: 85 3e e0 1f sra %i3, 0x1f, %g2
201faac: b8 40 80 1c addx %g2, %i4, %i4
201fab0: f8 3e 20 08 std %i4, [ %i0 + 8 ]
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
201fab4: c2 04 20 1c ld [ %l0 + 0x1c ], %g1
return read;
}
201fab8: b0 10 00 1b mov %i3, %i0
}
if (read >= 0)
iop->offset = pos + read;
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
201fabc: 7f ff fe ca call 201f5e4 <rtems_rfs_rtems_unlock>
201fac0: d0 00 60 98 ld [ %g1 + 0x98 ], %o0
return read;
}
201fac4: 81 c7 e0 08 ret
201fac8: 81 e8 00 00 restore
0201f73c <rtems_rfs_rtems_file_write>:
*/
static ssize_t
rtems_rfs_rtems_file_write (rtems_libio_t* iop,
const void* buffer,
size_t count)
{
201f73c: 9d e3 bf 90 save %sp, -112, %sp
rtems_rfs_file_handle* file = rtems_rfs_rtems_get_iop_file_handle (iop);
201f740: 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)
{
201f744: 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));
201f748: c2 06 e0 1c ld [ %i3 + 0x1c ], %g1
201f74c: 7f ff ff 91 call 201f590 <rtems_rfs_rtems_lock>
201f750: d0 00 60 98 ld [ %g1 + 0x98 ], %o0
pos = iop->offset;
file_size = rtems_rfs_file_size (file);
201f754: 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;
201f758: c4 1e 20 08 ldd [ %i0 + 8 ], %g2
201f75c: d0 02 60 98 ld [ %o1 + 0x98 ], %o0
201f760: c4 3f bf f8 std %g2, [ %fp + -8 ]
201f764: 7f ff eb 8e call 201a59c <rtems_rfs_block_get_size>
201f768: 92 02 60 84 add %o1, 0x84, %o1
201f76c: 86 10 00 09 mov %o1, %g3
file_size = rtems_rfs_file_size (file);
if (pos > file_size)
201f770: d2 07 bf f8 ld [ %fp + -8 ], %o1
201f774: 82 10 00 08 mov %o0, %g1
201f778: 80 a2 40 01 cmp %o1, %g1
201f77c: 18 80 00 08 bgu 201f79c <rtems_rfs_rtems_file_write+0x60> <== NEVER TAKEN
201f780: d4 07 bf fc ld [ %fp + -4 ], %o2
201f784: 80 a2 40 01 cmp %o1, %g1
201f788: 12 80 00 11 bne 201f7cc <rtems_rfs_rtems_file_write+0x90> <== NEVER TAKEN
201f78c: 80 a0 40 09 cmp %g1, %o1
201f790: 80 a2 80 03 cmp %o2, %g3
201f794: 08 80 00 0e bleu 201f7cc <rtems_rfs_rtems_file_write+0x90>
201f798: 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);
201f79c: 7f ff f7 fa call 201d784 <rtems_rfs_file_set_size>
201f7a0: 90 10 00 1b mov %i3, %o0
201f7a4: c2 06 e0 1c ld [ %i3 + 0x1c ], %g1
if (rc)
201f7a8: ba 92 20 00 orcc %o0, 0, %i5
201f7ac: 12 80 00 20 bne 201f82c <rtems_rfs_rtems_file_write+0xf0> <== NEVER TAKEN
201f7b0: 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);
201f7b4: d2 07 bf f8 ld [ %fp + -8 ], %o1
201f7b8: d4 07 bf fc ld [ %fp + -4 ], %o2
201f7bc: 7f ff eb 48 call 201a4dc <rtems_rfs_block_get_bpos>
201f7c0: 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)
{
201f7c4: 10 80 00 40 b 201f8c4 <rtems_rfs_rtems_file_write+0x188>
201f7c8: 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)
201f7cc: 38 80 00 09 bgu,a 201f7f0 <rtems_rfs_rtems_file_write+0xb4><== NEVER TAKEN
201f7d0: c4 04 20 10 ld [ %l0 + 0x10 ], %g2 <== NOT EXECUTED
201f7d4: 80 a0 40 09 cmp %g1, %o1
201f7d8: 12 80 00 3b bne 201f8c4 <rtems_rfs_rtems_file_write+0x188><== NEVER TAKEN
201f7dc: b0 10 20 00 clr %i0
201f7e0: 80 a0 c0 0a cmp %g3, %o2
201f7e4: 08 80 00 39 bleu 201f8c8 <rtems_rfs_rtems_file_write+0x18c>
201f7e8: 80 a6 a0 00 cmp %i2, 0
201f7ec: c4 04 20 10 ld [ %l0 + 0x10 ], %g2
201f7f0: 80 88 a2 00 btst 0x200, %g2
201f7f4: 22 80 00 34 be,a 201f8c4 <rtems_rfs_rtems_file_write+0x188>
201f7f8: b0 10 20 00 clr %i0
{
pos = file_size;
201f7fc: c2 27 bf f8 st %g1, [ %fp + -8 ]
201f800: c6 27 bf fc st %g3, [ %fp + -4 ]
rc = rtems_rfs_file_seek (file, pos, &pos);
201f804: 90 10 00 1b mov %i3, %o0
201f808: 92 10 00 01 mov %g1, %o1
201f80c: 94 10 00 03 mov %g3, %o2
201f810: 7f ff f7 9f call 201d68c <rtems_rfs_file_seek>
201f814: 96 07 bf f8 add %fp, -8, %o3
if (rc)
201f818: ba 92 20 00 orcc %o0, 0, %i5
201f81c: 22 80 00 2a be,a 201f8c4 <rtems_rfs_rtems_file_write+0x188><== ALWAYS TAKEN
201f820: b0 10 20 00 clr %i0
{
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
201f824: c2 06 e0 1c ld [ %i3 + 0x1c ], %g1 <== NOT EXECUTED
201f828: d0 00 60 98 ld [ %g1 + 0x98 ], %o0 <== NOT EXECUTED
201f82c: 7f ff ff 6e call 201f5e4 <rtems_rfs_rtems_unlock> <== NOT EXECUTED
201f830: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
return rtems_rfs_rtems_error ("file-write: write append seek", rc);
201f834: 40 00 04 e2 call 2020bbc <__errno> <== NOT EXECUTED
201f838: 01 00 00 00 nop <== NOT EXECUTED
201f83c: fa 22 00 00 st %i5, [ %o0 ] <== NOT EXECUTED
201f840: 81 c7 e0 08 ret <== NOT EXECUTED
201f844: 81 e8 00 00 restore <== NOT EXECUTED
while (count)
{
size_t size = count;
rc = rtems_rfs_file_io_start (file, &size, false);
201f848: 90 10 00 1b mov %i3, %o0
201f84c: 92 07 bf f4 add %fp, -12, %o1
201f850: 7f ff f6 59 call 201d1b4 <rtems_rfs_file_io_start>
201f854: 94 10 20 00 clr %o2
if (rc)
201f858: ba 92 20 00 orcc %o0, 0, %i5
201f85c: 12 80 00 16 bne 201f8b4 <rtems_rfs_rtems_file_write+0x178>
201f860: c2 07 bf f4 ld [ %fp + -12 ], %g1
{
write = rtems_rfs_rtems_error ("file-write: write open", rc);
break;
}
if (size > count)
201f864: 80 a0 40 1a cmp %g1, %i2
201f868: 38 80 00 02 bgu,a 201f870 <rtems_rfs_rtems_file_write+0x134>
201f86c: f4 27 bf f4 st %i2, [ %fp + -12 ]
size = count;
memcpy (rtems_rfs_file_data (file), data, size);
201f870: c2 06 e0 0c ld [ %i3 + 0xc ], %g1
201f874: d4 07 bf f4 ld [ %fp + -12 ], %o2
201f878: d0 00 60 1c ld [ %g1 + 0x1c ], %o0
201f87c: c2 06 e0 14 ld [ %i3 + 0x14 ], %g1
201f880: 92 10 00 19 mov %i1, %o1
201f884: 40 00 09 10 call 2021cc4 <memcpy>
201f888: 90 02 00 01 add %o0, %g1, %o0
data += size;
201f88c: d2 07 bf f4 ld [ %fp + -12 ], %o1
count -= size;
write += size;
rc = rtems_rfs_file_io_end (file, size, false);
201f890: 90 10 00 1b mov %i3, %o0
if (size > count)
size = count;
memcpy (rtems_rfs_file_data (file), data, size);
data += size;
201f894: b2 06 40 09 add %i1, %o1, %i1
count -= size;
201f898: b4 26 80 09 sub %i2, %o1, %i2
write += size;
201f89c: b0 06 00 09 add %i0, %o1, %i0
rc = rtems_rfs_file_io_end (file, size, false);
201f8a0: 7f ff f6 ce call 201d3d8 <rtems_rfs_file_io_end>
201f8a4: 94 10 20 00 clr %o2
if (rc)
201f8a8: ba 92 20 00 orcc %o0, 0, %i5
201f8ac: 02 80 00 07 be 201f8c8 <rtems_rfs_rtems_file_write+0x18c> <== ALWAYS TAKEN
201f8b0: 80 a6 a0 00 cmp %i2, 0
{
write = rtems_rfs_rtems_error ("file-write: write close", rc);
201f8b4: 40 00 04 c2 call 2020bbc <__errno>
201f8b8: b0 10 3f ff mov -1, %i0
201f8bc: 10 80 00 0c b 201f8ec <rtems_rfs_rtems_file_write+0x1b0>
201f8c0: 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)
201f8c4: 80 a6 a0 00 cmp %i2, 0
201f8c8: 32 bf ff e0 bne,a 201f848 <rtems_rfs_rtems_file_write+0x10c>
201f8cc: f4 27 bf f4 st %i2, [ %fp + -12 ]
write = rtems_rfs_rtems_error ("file-write: write close", rc);
break;
}
}
if (write >= 0)
201f8d0: 80 a6 20 00 cmp %i0, 0
201f8d4: 06 80 00 06 bl 201f8ec <rtems_rfs_rtems_file_write+0x1b0> <== NEVER TAKEN
201f8d8: f8 1f bf f8 ldd [ %fp + -8 ], %i4
iop->offset = pos + write;
201f8dc: 85 3e 20 1f sra %i0, 0x1f, %g2
201f8e0: 86 86 00 1d addcc %i0, %i5, %g3
201f8e4: 84 40 80 1c addx %g2, %i4, %g2
201f8e8: c4 3c 20 08 std %g2, [ %l0 + 8 ]
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
201f8ec: c2 06 e0 1c ld [ %i3 + 0x1c ], %g1
201f8f0: 7f ff ff 3d call 201f5e4 <rtems_rfs_rtems_unlock>
201f8f4: d0 00 60 98 ld [ %g1 + 0x98 ], %o0
return write;
}
201f8f8: 81 c7 e0 08 ret
201f8fc: 81 e8 00 00 restore
02013314 <rtems_rfs_rtems_fstat>:
}
int
rtems_rfs_rtems_fstat (const rtems_filesystem_location_info_t* pathloc,
struct stat* buf)
{
2013314: 9d e3 bf 78 save %sp, -136, %sp
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
2013318: 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);
201331c: 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);
2013320: 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);
2013324: 94 07 bf d8 add %fp, -40, %o2
2013328: 90 10 00 1d mov %i5, %o0
201332c: 7f ff fa 98 call 2011d8c <rtems_rfs_inode_open>
2013330: 96 10 20 01 mov 1, %o3
if (rc)
2013334: b8 92 20 00 orcc %o0, 0, %i4
2013338: 02 80 00 07 be 2013354 <rtems_rfs_rtems_fstat+0x40> <== ALWAYS TAKEN
201333c: c4 07 bf e4 ld [ %fp + -28 ], %g2
{
return rtems_rfs_rtems_error ("stat: opening inode", rc);
2013340: 40 00 36 1f call 2020bbc <__errno> <== NOT EXECUTED
2013344: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
2013348: f8 22 00 00 st %i4, [ %o0 ] <== NOT EXECUTED
201334c: 81 c7 e0 08 ret <== NOT EXECUTED
2013350: 81 e8 00 00 restore <== NOT EXECUTED
2013354: c2 08 a0 02 ldub [ %g2 + 2 ], %g1
2013358: 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))
201335c: 05 3f ff ec sethi %hi(0xffffb000), %g2
2013360: 83 28 60 08 sll %g1, 8, %g1
2013364: b8 10 40 1c or %g1, %i4, %i4
2013368: 82 08 40 02 and %g1, %g2, %g1
201336c: 05 00 00 08 sethi %hi(0x2000), %g2
2013370: 80 a0 40 02 cmp %g1, %g2
2013374: 32 80 00 0c bne,a 20133a4 <rtems_rfs_rtems_fstat+0x90> <== ALWAYS TAKEN
2013378: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
{
buf->st_rdev =
rtems_filesystem_make_dev_t (rtems_rfs_inode_get_block (&inode, 0),
201337c: 92 10 20 00 clr %o1 <== NOT EXECUTED
2013380: 7f ff fc bd call 2012674 <rtems_rfs_inode_get_block> <== NOT EXECUTED
2013384: 90 07 bf d8 add %fp, -40, %o0 <== NOT EXECUTED
2013388: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
201338c: b6 10 00 08 mov %o0, %i3 <== NOT EXECUTED
2013390: 7f ff fc b9 call 2012674 <rtems_rfs_inode_get_block> <== NOT EXECUTED
2013394: 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 =
2013398: f6 26 60 18 st %i3, [ %i1 + 0x18 ] <== NOT EXECUTED
201339c: 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);
20133a0: 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);
20133a4: 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);
20133a8: c2 26 60 04 st %g1, [ %i1 + 4 ]
20133ac: 83 38 60 1f sra %g1, 0x1f, %g1
20133b0: c2 26 40 00 st %g1, [ %i1 ]
buf->st_ino = rtems_rfs_inode_ino (&inode);
20133b4: c2 07 bf e0 ld [ %fp + -32 ], %g1
buf->st_mode = rtems_rfs_rtems_mode (mode);
20133b8: 91 32 20 10 srl %o0, 0x10, %o0
20133bc: 40 00 01 03 call 20137c8 <rtems_rfs_rtems_mode>
20133c0: 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);
20133c4: c2 07 bf e4 ld [ %fp + -28 ], %g1
20133c8: d0 26 60 0c st %o0, [ %i1 + 0xc ]
20133cc: c6 08 60 01 ldub [ %g1 + 1 ], %g3
20133d0: c4 08 40 00 ldub [ %g1 ], %g2
if (links == 0xffff)
20133d4: 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);
20133d8: 85 28 a0 08 sll %g2, 8, %g2
20133dc: 84 10 80 03 or %g2, %g3, %g2
if (links == 0xffff)
20133e0: 87 28 a0 10 sll %g2, 0x10, %g3
20133e4: 87 30 e0 10 srl %g3, 0x10, %g3
links = 0;
20133e8: 86 39 00 03 xnor %g4, %g3, %g3
20133ec: 80 a0 00 03 cmp %g0, %g3
20133f0: 86 60 20 00 subx %g0, 0, %g3
20133f4: 84 08 80 03 and %g2, %g3, %g2
buf->st_nlink = rtems_rfs_inode_get_links (&inode);
20133f8: 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;
20133fc: c6 08 60 06 ldub [ %g1 + 6 ], %g3
2013400: c4 08 60 07 ldub [ %g1 + 7 ], %g2
2013404: 87 28 e0 08 sll %g3, 8, %g3
2013408: 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);
201340c: 90 07 bf d8 add %fp, -40, %o0
2013410: 7f ff fc 91 call 2012654 <rtems_rfs_inode_get_gid>
2013414: 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));
2013418: 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);
201341c: 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));
2013420: 40 00 29 a3 call 201daac <rtems_rfs_file_get_shared>
2013424: 90 10 00 1d mov %i5, %o0
if (shared)
2013428: 92 92 20 00 orcc %o0, 0, %o1
201342c: 02 80 00 17 be 2013488 <rtems_rfs_rtems_fstat+0x174>
2013430: c2 07 bf e4 ld [ %fp + -28 ], %g1
{
buf->st_atime = rtems_rfs_file_shared_get_atime (shared);
2013434: 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))
2013438: 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);
201343c: c2 26 60 28 st %g1, [ %i1 + 0x28 ]
buf->st_mtime = rtems_rfs_file_shared_get_mtime (shared);
2013440: c2 02 60 90 ld [ %o1 + 0x90 ], %g1
2013444: c2 26 60 30 st %g1, [ %i1 + 0x30 ]
buf->st_ctime = rtems_rfs_file_shared_get_ctime (shared);
2013448: c2 02 60 94 ld [ %o1 + 0x94 ], %g1
201344c: c2 26 60 38 st %g1, [ %i1 + 0x38 ]
buf->st_blocks = rtems_rfs_file_shared_get_block_count (shared);
2013450: c2 02 60 84 ld [ %o1 + 0x84 ], %g1
2013454: c2 26 60 44 st %g1, [ %i1 + 0x44 ]
if (S_ISLNK (buf->st_mode))
2013458: 03 00 00 3c sethi %hi(0xf000), %g1
201345c: 84 08 80 01 and %g2, %g1, %g2
2013460: 03 00 00 28 sethi %hi(0xa000), %g1
2013464: 80 a0 80 01 cmp %g2, %g1
2013468: 12 80 00 04 bne 2013478 <rtems_rfs_rtems_fstat+0x164> <== ALWAYS TAKEN
201346c: 90 10 00 1d mov %i5, %o0
buf->st_size = rtems_rfs_file_shared_get_block_offset (shared);
2013470: 10 80 00 3d b 2013564 <rtems_rfs_rtems_fstat+0x250> <== NOT EXECUTED
2013474: 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);
2013478: 40 00 1c 49 call 201a59c <rtems_rfs_block_get_size>
201347c: 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);
2013480: 10 80 00 3f b 201357c <rtems_rfs_rtems_fstat+0x268>
2013484: 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);
2013488: c6 08 60 10 ldub [ %g1 + 0x10 ], %g3
201348c: c4 08 60 11 ldub [ %g1 + 0x11 ], %g2
2013490: 87 28 e0 18 sll %g3, 0x18, %g3
2013494: 85 28 a0 10 sll %g2, 0x10, %g2
2013498: 84 10 c0 02 or %g3, %g2, %g2
201349c: c6 08 60 13 ldub [ %g1 + 0x13 ], %g3
20134a0: 84 10 80 03 or %g2, %g3, %g2
20134a4: c6 08 60 12 ldub [ %g1 + 0x12 ], %g3
20134a8: 87 28 e0 08 sll %g3, 8, %g3
20134ac: 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);
20134b0: 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);
20134b4: c6 08 60 14 ldub [ %g1 + 0x14 ], %g3
20134b8: c4 08 60 15 ldub [ %g1 + 0x15 ], %g2
20134bc: 87 28 e0 18 sll %g3, 0x18, %g3
20134c0: 85 28 a0 10 sll %g2, 0x10, %g2
20134c4: 84 10 c0 02 or %g3, %g2, %g2
20134c8: c6 08 60 17 ldub [ %g1 + 0x17 ], %g3
20134cc: 84 10 80 03 or %g2, %g3, %g2
20134d0: c6 08 60 16 ldub [ %g1 + 0x16 ], %g3
20134d4: 87 28 e0 08 sll %g3, 8, %g3
20134d8: 84 10 80 03 or %g2, %g3, %g2
buf->st_mtime = rtems_rfs_inode_get_mtime (&inode);
20134dc: 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);
20134e0: c6 08 60 18 ldub [ %g1 + 0x18 ], %g3
20134e4: c4 08 60 19 ldub [ %g1 + 0x19 ], %g2
20134e8: 87 28 e0 18 sll %g3, 0x18, %g3
20134ec: 85 28 a0 10 sll %g2, 0x10, %g2
20134f0: 84 10 c0 02 or %g3, %g2, %g2
20134f4: c6 08 60 1b ldub [ %g1 + 0x1b ], %g3
20134f8: 84 10 80 03 or %g2, %g3, %g2
20134fc: c6 08 60 1a ldub [ %g1 + 0x1a ], %g3
2013500: 87 28 e0 08 sll %g3, 8, %g3
2013504: 84 10 80 03 or %g2, %g3, %g2
buf->st_ctime = rtems_rfs_inode_get_ctime (&inode);
2013508: 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);
201350c: c6 08 60 0c ldub [ %g1 + 0xc ], %g3
2013510: c4 08 60 0d ldub [ %g1 + 0xd ], %g2
2013514: 87 28 e0 18 sll %g3, 0x18, %g3
2013518: 85 28 a0 10 sll %g2, 0x10, %g2
201351c: 84 10 c0 02 or %g3, %g2, %g2
2013520: c6 08 60 0f ldub [ %g1 + 0xf ], %g3
2013524: 84 10 80 03 or %g2, %g3, %g2
2013528: c6 08 60 0e ldub [ %g1 + 0xe ], %g3
201352c: 87 28 e0 08 sll %g3, 8, %g3
2013530: 84 10 80 03 or %g2, %g3, %g2
buf->st_blocks = rtems_rfs_inode_get_block_count (&inode);
if (S_ISLNK (buf->st_mode))
2013534: 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);
2013538: c4 26 60 44 st %g2, [ %i1 + 0x44 ]
if (S_ISLNK (buf->st_mode))
201353c: 05 00 00 3c sethi %hi(0xf000), %g2
2013540: 86 08 c0 02 and %g3, %g2, %g3
2013544: 05 00 00 28 sethi %hi(0xa000), %g2
2013548: 80 a0 c0 02 cmp %g3, %g2
201354c: 12 80 00 09 bne 2013570 <rtems_rfs_rtems_fstat+0x25c>
2013550: 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);
2013554: c4 08 60 0a ldub [ %g1 + 0xa ], %g2
buf->st_size = rtems_rfs_inode_get_block_offset (&inode);
2013558: c2 08 60 0b ldub [ %g1 + 0xb ], %g1
201355c: 85 28 a0 08 sll %g2, 8, %g2
2013560: 82 10 40 02 or %g1, %g2, %g1
2013564: c0 26 60 20 clr [ %i1 + 0x20 ]
2013568: 10 80 00 05 b 201357c <rtems_rfs_rtems_fstat+0x268>
201356c: c2 26 60 24 st %g1, [ %i1 + 0x24 ]
else
buf->st_size = rtems_rfs_inode_get_size (fs, &inode);
2013570: 7f ff fc 21 call 20125f4 <rtems_rfs_inode_get_size>
2013574: 92 07 bf d8 add %fp, -40, %o1
2013578: d0 3e 60 20 std %o0, [ %i1 + 0x20 ]
}
buf->st_blksize = rtems_rfs_fs_block_size (fs);
201357c: c2 07 60 08 ld [ %i5 + 8 ], %g1
rc = rtems_rfs_inode_close (fs, &inode);
2013580: 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);
2013584: c2 26 60 40 st %g1, [ %i1 + 0x40 ]
rc = rtems_rfs_inode_close (fs, &inode);
2013588: 92 07 bf d8 add %fp, -40, %o1
201358c: 7f ff fa 72 call 2011f54 <rtems_rfs_inode_close>
2013590: b0 10 20 00 clr %i0
if (rc > 0)
2013594: 80 a2 20 00 cmp %o0, 0
2013598: 04 80 00 05 ble 20135ac <rtems_rfs_rtems_fstat+0x298> <== ALWAYS TAKEN
201359c: ba 10 00 08 mov %o0, %i5
{
return rtems_rfs_rtems_error ("stat: closing inode", rc);
20135a0: 40 00 35 87 call 2020bbc <__errno> <== NOT EXECUTED
20135a4: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
20135a8: fa 22 00 00 st %i5, [ %o0 ] <== NOT EXECUTED
}
return 0;
}
20135ac: 81 c7 e0 08 ret
20135b0: 81 e8 00 00 restore
02012e0c <rtems_rfs_rtems_initialise>:
*/
int
rtems_rfs_rtems_initialise (rtems_filesystem_mount_table_entry_t* mt_entry,
const void* data)
{
2012e0c: 9d e3 bf 98 save %sp, -104, %sp
/*
* Parse the options the user specifiies.
*/
while (options)
{
printf ("options=%s\n", options);
2012e10: 3b 00 80 cb sethi %hi(0x2032c00), %i5
if (strncmp (options, "hold-bitmaps",
2012e14: 35 00 80 cb sethi %hi(0x2032c00), %i2
sizeof ("hold-bitmaps") - 1) == 0)
flags |= RTEMS_RFS_FS_BITMAPS_HOLD;
else if (strncmp (options, "no-local-cache",
2012e18: 21 00 80 cb sethi %hi(0x2032c00), %l0
sizeof ("no-local-cache") - 1) == 0)
flags |= RTEMS_RFS_FS_NO_LOCAL_CACHE;
else if (strncmp (options, "max-held-bufs",
2012e1c: 23 00 80 cb sethi %hi(0x2032c00), %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;
2012e20: 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;
2012e24: b8 10 20 00 clr %i4
/*
* Parse the options the user specifiies.
*/
while (options)
{
printf ("options=%s\n", options);
2012e28: ba 17 63 18 or %i5, 0x318, %i5
if (strncmp (options, "hold-bitmaps",
2012e2c: b4 16 a3 28 or %i2, 0x328, %i2
sizeof ("hold-bitmaps") - 1) == 0)
flags |= RTEMS_RFS_FS_BITMAPS_HOLD;
else if (strncmp (options, "no-local-cache",
2012e30: a0 14 23 38 or %l0, 0x338, %l0
int rc;
/*
* Parse the options the user specifiies.
*/
while (options)
2012e34: 10 80 00 2f b 2012ef0 <rtems_rfs_rtems_initialise+0xe4>
2012e38: a2 14 63 48 or %l1, 0x348, %l1
{
printf ("options=%s\n", options);
2012e3c: 40 00 3c af call 20220f8 <printf> <== NOT EXECUTED
2012e40: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
if (strncmp (options, "hold-bitmaps",
2012e44: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
2012e48: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED
2012e4c: 40 00 41 73 call 2023418 <strncmp> <== NOT EXECUTED
2012e50: 94 10 20 0c mov 0xc, %o2 <== NOT EXECUTED
2012e54: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2012e58: 12 80 00 04 bne 2012e68 <rtems_rfs_rtems_initialise+0x5c> <== NOT EXECUTED
2012e5c: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
sizeof ("hold-bitmaps") - 1) == 0)
flags |= RTEMS_RFS_FS_BITMAPS_HOLD;
2012e60: 10 80 00 1a b 2012ec8 <rtems_rfs_rtems_initialise+0xbc> <== NOT EXECUTED
2012e64: b8 17 20 01 or %i4, 1, %i4 <== NOT EXECUTED
else if (strncmp (options, "no-local-cache",
2012e68: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED
2012e6c: 40 00 41 6b call 2023418 <strncmp> <== NOT EXECUTED
2012e70: 94 10 20 0e mov 0xe, %o2 <== NOT EXECUTED
2012e74: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2012e78: 12 80 00 04 bne 2012e88 <rtems_rfs_rtems_initialise+0x7c> <== NOT EXECUTED
2012e7c: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
sizeof ("no-local-cache") - 1) == 0)
flags |= RTEMS_RFS_FS_NO_LOCAL_CACHE;
2012e80: 10 80 00 12 b 2012ec8 <rtems_rfs_rtems_initialise+0xbc> <== NOT EXECUTED
2012e84: b8 17 20 02 or %i4, 2, %i4 <== NOT EXECUTED
else if (strncmp (options, "max-held-bufs",
2012e88: 92 10 00 11 mov %l1, %o1 <== NOT EXECUTED
2012e8c: 40 00 41 63 call 2023418 <strncmp> <== NOT EXECUTED
2012e90: 94 10 20 0d mov 0xd, %o2 <== NOT EXECUTED
2012e94: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2012e98: 12 80 00 07 bne 2012eb4 <rtems_rfs_rtems_initialise+0xa8> <== NOT EXECUTED
2012e9c: 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);
2012ea0: 90 06 60 0e add %i1, 0xe, %o0 <== NOT EXECUTED
2012ea4: 40 00 42 3c call 2023794 <strtoul> <== NOT EXECUTED
2012ea8: 94 10 20 00 clr %o2 <== NOT EXECUTED
2012eac: 10 80 00 06 b 2012ec4 <rtems_rfs_rtems_initialise+0xb8> <== NOT EXECUTED
2012eb0: b6 10 00 08 mov %o0, %i3 <== NOT EXECUTED
}
else
return rtems_rfs_rtems_error ("initialise: invalid option", EINVAL);
2012eb4: 40 00 37 42 call 2020bbc <__errno> <== NOT EXECUTED
2012eb8: 01 00 00 00 nop <== NOT EXECUTED
2012ebc: 10 80 00 18 b 2012f1c <rtems_rfs_rtems_initialise+0x110> <== NOT EXECUTED
2012ec0: 82 10 20 16 mov 0x16, %g1 ! 16 <PROM_START+0x16> <== NOT EXECUTED
options = strchr (options, ',');
2012ec4: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
2012ec8: 40 00 3e b8 call 20229a8 <strchr> <== NOT EXECUTED
2012ecc: 92 10 20 2c mov 0x2c, %o1 <== NOT EXECUTED
if (options)
2012ed0: b2 92 20 00 orcc %o0, 0, %i1 <== NOT EXECUTED
2012ed4: 02 80 00 0a be 2012efc <rtems_rfs_rtems_initialise+0xf0> <== NOT EXECUTED
2012ed8: 01 00 00 00 nop <== NOT EXECUTED
{
++options;
if (*options == '\0')
2012edc: c2 4e 60 01 ldsb [ %i1 + 1 ], %g1 <== NOT EXECUTED
2012ee0: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
2012ee4: 02 80 00 06 be 2012efc <rtems_rfs_rtems_initialise+0xf0> <== NOT EXECUTED
2012ee8: 01 00 00 00 nop <== NOT EXECUTED
return rtems_rfs_rtems_error ("initialise: invalid option", EINVAL);
options = strchr (options, ',');
if (options)
{
++options;
2012eec: b2 06 60 01 inc %i1 <== NOT EXECUTED
int rc;
/*
* Parse the options the user specifiies.
*/
while (options)
2012ef0: 80 a6 60 00 cmp %i1, 0
2012ef4: 12 bf ff d2 bne 2012e3c <rtems_rfs_rtems_initialise+0x30> <== NEVER TAKEN
2012ef8: 92 10 00 19 mov %i1, %o1
if (*options == '\0')
options = NULL;
}
}
rtems = malloc (sizeof (rtems_rfs_rtems_private));
2012efc: 7f ff d6 71 call 20088c0 <malloc>
2012f00: 90 10 20 04 mov 4, %o0
if (!rtems)
2012f04: ba 92 20 00 orcc %o0, 0, %i5
2012f08: 12 80 00 08 bne 2012f28 <rtems_rfs_rtems_initialise+0x11c><== ALWAYS TAKEN
2012f0c: 01 00 00 00 nop
return rtems_rfs_rtems_error ("initialise: local data", ENOMEM);
2012f10: 40 00 37 2b call 2020bbc <__errno> <== NOT EXECUTED
2012f14: 01 00 00 00 nop <== NOT EXECUTED
2012f18: 82 10 20 0c mov 0xc, %g1 ! c <PROM_START+0xc> <== NOT EXECUTED
2012f1c: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
2012f20: 81 c7 e0 08 ret <== NOT EXECUTED
2012f24: 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);
2012f28: 40 00 30 49 call 201f04c <rtems_rfs_mutex_create>
2012f2c: c0 27 40 00 clr [ %i5 ]
if (rc > 0)
2012f30: b4 92 20 00 orcc %o0, 0, %i2
2012f34: 14 80 00 09 bg 2012f58 <rtems_rfs_rtems_initialise+0x14c> <== NEVER TAKEN
2012f38: 01 00 00 00 nop
{
free (rtems);
return rtems_rfs_rtems_error ("initialise: cannot create mutex", rc);
}
rc = rtems_rfs_mutex_lock (&rtems->access);
2012f3c: 7f ff ff 96 call 2012d94 <rtems_rfs_mutex_lock.isra.3>
2012f40: d0 07 40 00 ld [ %i5 ], %o0
if (rc > 0)
2012f44: b4 92 20 00 orcc %o0, 0, %i2
2012f48: 24 80 00 0b ble,a 2012f74 <rtems_rfs_rtems_initialise+0x168><== ALWAYS TAKEN
2012f4c: d0 06 20 38 ld [ %i0 + 0x38 ], %o0
{
rtems_rfs_mutex_destroy (&rtems->access);
2012f50: 40 00 30 5a call 201f0b8 <rtems_rfs_mutex_destroy> <== NOT EXECUTED
2012f54: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
free (rtems);
2012f58: 7f ff d4 b4 call 2008228 <free> <== NOT EXECUTED
2012f5c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
return rtems_rfs_rtems_error ("initialise: cannot lock access mutex", rc);
2012f60: 40 00 37 17 call 2020bbc <__errno> <== NOT EXECUTED
2012f64: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
2012f68: f4 22 00 00 st %i2, [ %o0 ] <== NOT EXECUTED
2012f6c: 81 c7 e0 08 ret <== NOT EXECUTED
2012f70: 81 e8 00 00 restore <== NOT EXECUTED
}
rc = rtems_rfs_fs_open (mt_entry->dev, rtems, flags, max_held_buffers, &fs);
2012f74: 94 10 00 1c mov %i4, %o2
2012f78: 92 10 00 1d mov %i5, %o1
2012f7c: 96 10 00 1b mov %i3, %o3
2012f80: 40 00 2b ad call 201de34 <rtems_rfs_fs_open>
2012f84: 98 07 bf fc add %fp, -4, %o4
if (rc)
2012f88: b8 92 20 00 orcc %o0, 0, %i4
2012f8c: 02 80 00 09 be 2012fb0 <rtems_rfs_rtems_initialise+0x1a4> <== ALWAYS TAKEN
2012f90: d0 07 bf fc ld [ %fp + -4 ], %o0
{
free (rtems);
2012f94: 7f ff d4 a5 call 2008228 <free> <== NOT EXECUTED
2012f98: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
return rtems_rfs_rtems_error ("initialise: open", rc);
2012f9c: 40 00 37 08 call 2020bbc <__errno> <== NOT EXECUTED
2012fa0: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
2012fa4: f8 22 00 00 st %i4, [ %o0 ] <== NOT EXECUTED
2012fa8: 81 c7 e0 08 ret <== NOT EXECUTED
2012fac: 81 e8 00 00 restore <== NOT EXECUTED
}
mt_entry->fs_info = fs;
mt_entry->ops = &rtems_rfs_ops;
2012fb0: 03 00 80 cb sethi %hi(0x2032c00), %g1
2012fb4: 82 10 63 58 or %g1, 0x358, %g1 ! 2032f58 <rtems_rfs_ops>
2012fb8: c2 26 20 0c st %g1, [ %i0 + 0xc ]
mt_entry->mt_fs_root->location.node_access = (void*) RTEMS_RFS_ROOT_INO;
2012fbc: c2 06 20 24 ld [ %i0 + 0x24 ], %g1
{
free (rtems);
return rtems_rfs_rtems_error ("initialise: open", rc);
}
mt_entry->fs_info = fs;
2012fc0: 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;
2012fc4: 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);
2012fc8: fa 02 20 80 ld [ %o0 + 0x80 ], %i5
2012fcc: c4 20 60 08 st %g2, [ %g1 + 8 ]
mt_entry->mt_fs_root->location.handlers = &rtems_rfs_rtems_dir_handlers;
2012fd0: 05 00 80 d3 sethi %hi(0x2034c00), %g2
2012fd4: 84 10 a1 b0 or %g2, 0x1b0, %g2 ! 2034db0 <rtems_rfs_rtems_dir_handlers>
rtems_rfs_buffers_release (fs);
2012fd8: 40 00 22 9a call 201ba40 <rtems_rfs_buffers_release>
2012fdc: c4 20 60 10 st %g2, [ %g1 + 0x10 ]
rtems_rfs_mutex_unlock (&rtems->access);
2012fe0: d0 07 40 00 ld [ %i5 ], %o0
2012fe4: 7f ff ff 56 call 2012d3c <rtems_rfs_mutex_unlock.isra.2>
2012fe8: b0 10 20 00 clr %i0
rtems_rfs_rtems_unlock (fs);
return 0;
}
2012fec: 81 c7 e0 08 ret
2012ff0: 81 e8 00 00 restore
02012798 <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)
{
2012798: 9d e3 bf a0 save %sp, -96, %sp
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (targetloc);
201279c: 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);
20127a0: d6 06 20 08 ld [ %i0 + 8 ], %o3
20127a4: d0 00 60 08 ld [ %g1 + 8 ], %o0
20127a8: d8 06 60 08 ld [ %i1 + 8 ], %o4
20127ac: 92 10 00 1a mov %i2, %o1
20127b0: 94 10 00 1b mov %i3, %o2
20127b4: 9a 10 20 00 clr %o5
20127b8: 40 00 2f c6 call 201e6d0 <rtems_rfs_link>
20127bc: b0 10 20 00 clr %i0
if (rc)
20127c0: 80 a2 20 00 cmp %o0, 0
20127c4: 02 80 00 05 be 20127d8 <rtems_rfs_rtems_link+0x40> <== ALWAYS TAKEN
20127c8: ba 10 00 08 mov %o0, %i5
{
return rtems_rfs_rtems_error ("link: linking", rc);
20127cc: 40 00 38 fc call 2020bbc <__errno> <== NOT EXECUTED
20127d0: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
20127d4: fa 22 00 00 st %i5, [ %o0 ] <== NOT EXECUTED
}
return 0;
}
20127d8: 81 c7 e0 08 ret
20127dc: 81 e8 00 00 restore
0201f590 <rtems_rfs_rtems_lock>:
/**
* Lock the RFS file system.
*/
static inline void
rtems_rfs_rtems_lock (rtems_rfs_file_system* fs)
{
201f590: 9d e3 bf a0 save %sp, -96, %sp
.fstat_h = rtems_rfs_rtems_fstat,
.ftruncate_h = rtems_rfs_rtems_file_ftruncate,
.fsync_h = rtems_rfs_rtems_fdatasync,
.fdatasync_h = rtems_rfs_rtems_fdatasync,
.fcntl_h = rtems_filesystem_default_fcntl
};
201f594: 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);
201f598: 92 10 20 00 clr %o1
201f59c: d0 00 40 00 ld [ %g1 ], %o0
201f5a0: 7f ff b5 a3 call 200cc2c <rtems_semaphore_obtain>
201f5a4: 94 10 20 00 clr %o2
if (sc != RTEMS_SUCCESSFUL)
201f5a8: ba 92 20 00 orcc %o0, 0, %i5
201f5ac: 02 80 00 0c be 201f5dc <rtems_rfs_rtems_lock+0x4c> <== ALWAYS TAKEN
201f5b0: 90 10 20 00 clr %o0
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
201f5b4: 7f ff d0 87 call 20137d0 <rtems_rfs_trace> <== NOT EXECUTED
201f5b8: 92 10 20 04 mov 4, %o1 <== NOT EXECUTED
201f5bc: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
201f5c0: 02 80 00 07 be 201f5dc <rtems_rfs_rtems_lock+0x4c> <== NOT EXECUTED
201f5c4: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
printf ("rtems-rfs: mutex: obtain failed: %s\n",
201f5c8: 7f ff a2 7b call 2007fb4 <rtems_status_text> <== NOT EXECUTED
201f5cc: 31 00 80 cb sethi %hi(0x2032c00), %i0 <== NOT EXECUTED
201f5d0: b0 16 22 f0 or %i0, 0x2f0, %i0 ! 2032ef0 <_CPU_Trap_slot_template+0xcb8><== NOT EXECUTED
201f5d4: 40 00 0a c9 call 20220f8 <printf> <== NOT EXECUTED
201f5d8: 93 e8 00 08 restore %g0, %o0, %o1 <== NOT EXECUTED
201f5dc: 81 c7 e0 08 ret
201f5e0: 81 e8 00 00 restore
02012ae4 <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)
{
2012ae4: 9d e3 bf 60 save %sp, -160, %sp
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (parentloc);
2012ae8: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
rtems_rfs_ino parent = rtems_rfs_rtems_get_pathloc_ino (parentloc);
2012aec: f0 06 20 08 ld [ %i0 + 8 ], %i0
uid_t uid;
gid_t gid;
int rc;
#if defined(RTEMS_POSIX_API)
uid = geteuid ();
2012af0: 40 00 10 ec call 2016ea0 <geteuid>
2012af4: e0 00 60 08 ld [ %g1 + 8 ], %l0
gid = getegid ();
2012af8: 40 00 10 e6 call 2016e90 <getegid>
2012afc: a4 10 00 08 mov %o0, %l2
2012b00: a2 10 00 08 mov %o0, %l1
#else
uid = 0;
gid = 0;
#endif
rc = rtems_rfs_inode_create (fs, parent, name, namelen,
2012b04: 40 00 03 2e call 20137bc <rtems_rfs_rtems_imode>
2012b08: 90 10 00 1b mov %i3, %o0
2012b0c: 82 07 bf d4 add %fp, -44, %g1
2012b10: 99 2a 20 10 sll %o0, 0x10, %o4
2012b14: 96 10 00 1a mov %i2, %o3
2012b18: a5 2c a0 10 sll %l2, 0x10, %l2
2012b1c: a3 2c 60 10 sll %l1, 0x10, %l1
2012b20: a5 34 a0 10 srl %l2, 0x10, %l2
2012b24: a3 34 60 10 srl %l1, 0x10, %l1
2012b28: e4 23 a0 5c st %l2, [ %sp + 0x5c ]
2012b2c: e2 23 a0 60 st %l1, [ %sp + 0x60 ]
2012b30: c2 23 a0 64 st %g1, [ %sp + 0x64 ]
2012b34: 90 10 00 10 mov %l0, %o0
2012b38: 92 10 00 18 mov %i0, %o1
2012b3c: 94 10 00 19 mov %i1, %o2
2012b40: 99 33 20 10 srl %o4, 0x10, %o4
2012b44: 7f ff fd d9 call 20122a8 <rtems_rfs_inode_create>
2012b48: 9a 10 20 01 mov 1, %o5
rtems_rfs_rtems_imode (mode),
1, uid, gid, &ino);
if (rc > 0)
2012b4c: b4 92 20 00 orcc %o0, 0, %i2
2012b50: 14 80 00 09 bg 2012b74 <rtems_rfs_rtems_mknod+0x90>
2012b54: 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);
2012b58: 90 10 00 10 mov %l0, %o0
2012b5c: 94 07 bf d8 add %fp, -40, %o2
2012b60: 7f ff fc 8b call 2011d8c <rtems_rfs_inode_open>
2012b64: 96 10 20 01 mov 1, %o3
if (rc > 0)
2012b68: b4 92 20 00 orcc %o0, 0, %i2
2012b6c: 04 80 00 07 ble 2012b88 <rtems_rfs_rtems_mknod+0xa4> <== ALWAYS TAKEN
2012b70: 03 00 00 3c sethi %hi(0xf000), %g1
{
return rtems_rfs_rtems_error ("mknod: inode open", rc);
2012b74: 40 00 38 12 call 2020bbc <__errno>
2012b78: b0 10 3f ff mov -1, %i0
2012b7c: f4 22 00 00 st %i2, [ %o0 ]
2012b80: 81 c7 e0 08 ret
2012b84: 81 e8 00 00 restore
}
if (S_ISDIR(mode) || S_ISREG(mode))
2012b88: 05 00 00 20 sethi %hi(0x8000), %g2
2012b8c: 82 0e c0 01 and %i3, %g1, %g1
2012b90: 80 a0 40 02 cmp %g1, %g2
2012b94: 02 80 00 1c be 2012c04 <rtems_rfs_rtems_mknod+0x120>
2012b98: 05 00 00 10 sethi %hi(0x4000), %g2
2012b9c: 80 a0 40 02 cmp %g1, %g2
2012ba0: 02 80 00 19 be 2012c04 <rtems_rfs_rtems_mknod+0x120> <== ALWAYS TAKEN
2012ba4: 03 00 00 2c sethi %hi(0xb000), %g1
{
}
else if (S_ISCHR (mode) || S_ISBLK (mode))
2012ba8: b6 0e c0 01 and %i3, %g1, %i3 <== NOT EXECUTED
2012bac: 03 00 00 08 sethi %hi(0x2000), %g1 <== NOT EXECUTED
2012bb0: 80 a6 c0 01 cmp %i3, %g1 <== NOT EXECUTED
2012bb4: 12 80 00 0b bne 2012be0 <rtems_rfs_rtems_mknod+0xfc> <== NOT EXECUTED
2012bb8: 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);
2012bbc: 94 10 00 1c mov %i4, %o2 <== NOT EXECUTED
2012bc0: 7f ff fe bd call 20126b4 <rtems_rfs_inode_set_block> <== NOT EXECUTED
2012bc4: 92 10 20 00 clr %o1 <== NOT EXECUTED
rtems_rfs_inode_set_block (&inode, 1, minor);
2012bc8: 90 07 bf d8 add %fp, -40, %o0 <== NOT EXECUTED
2012bcc: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
2012bd0: 7f ff fe b9 call 20126b4 <rtems_rfs_inode_set_block> <== NOT EXECUTED
2012bd4: 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);
2012bd8: 10 80 00 0c b 2012c08 <rtems_rfs_rtems_mknod+0x124> <== NOT EXECUTED
2012bdc: 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);
2012be0: 92 07 bf d8 add %fp, -40, %o1 <== NOT EXECUTED
2012be4: 7f ff fc dc call 2011f54 <rtems_rfs_inode_close> <== NOT EXECUTED
2012be8: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
return rtems_rfs_rtems_error ("mknod: bad mode", EINVAL);
2012bec: 40 00 37 f4 call 2020bbc <__errno> <== NOT EXECUTED
2012bf0: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
2012bf4: 82 10 20 16 mov 0x16, %g1 <== NOT EXECUTED
2012bf8: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
2012bfc: 81 c7 e0 08 ret <== NOT EXECUTED
2012c00: 81 e8 00 00 restore <== NOT EXECUTED
}
rc = rtems_rfs_inode_close (fs, &inode);
2012c04: 90 10 00 10 mov %l0, %o0
2012c08: 92 07 bf d8 add %fp, -40, %o1
2012c0c: 7f ff fc d2 call 2011f54 <rtems_rfs_inode_close>
2012c10: b0 10 20 00 clr %i0
if (rc > 0)
2012c14: 80 a2 20 00 cmp %o0, 0
2012c18: 04 80 00 05 ble 2012c2c <rtems_rfs_rtems_mknod+0x148> <== ALWAYS TAKEN
2012c1c: ba 10 00 08 mov %o0, %i5
{
return rtems_rfs_rtems_error ("mknod: closing inode", rc);
2012c20: 40 00 37 e7 call 2020bbc <__errno> <== NOT EXECUTED
2012c24: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
2012c28: fa 22 00 00 st %i5, [ %o0 ] <== NOT EXECUTED
}
return 0;
}
2012c2c: 81 c7 e0 08 ret
2012c30: 81 e8 00 00 restore
02013078 <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)
{
2013078: 9d e3 bf 78 save %sp, -136, %sp
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
201307c: 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);
2013080: 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);
2013084: 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);
2013088: 94 07 bf d8 add %fp, -40, %o2
201308c: 90 10 00 1d mov %i5, %o0
2013090: 7f ff fb 3f call 2011d8c <rtems_rfs_inode_open>
2013094: 96 10 20 01 mov 1, %o3
if (rc > 0)
2013098: b8 92 20 00 orcc %o0, 0, %i4
201309c: 04 80 00 07 ble 20130b8 <rtems_rfs_rtems_node_type+0x40> <== ALWAYS TAKEN
20130a0: 01 00 00 00 nop
{
return rtems_rfs_rtems_error ("node_type: opening inode", rc);
20130a4: 40 00 36 c6 call 2020bbc <__errno> <== NOT EXECUTED
20130a8: b0 10 3f ff mov -1, %i0 ! ffffffff <RAM_END+0xfdbfffff> <== NOT EXECUTED
20130ac: f8 22 00 00 st %i4, [ %o0 ] <== NOT EXECUTED
20130b0: 81 c7 e0 08 ret <== NOT EXECUTED
20130b4: 81 e8 00 00 restore <== NOT EXECUTED
}
type = rtems_rfs_rtems_node_type_by_inode (&inode);
20130b8: 7f ff ff cf call 2012ff4 <rtems_rfs_rtems_node_type_by_inode>
20130bc: 90 07 bf d8 add %fp, -40, %o0
rc = rtems_rfs_inode_close (fs, &inode);
20130c0: 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);
20130c4: b0 10 00 08 mov %o0, %i0
rc = rtems_rfs_inode_close (fs, &inode);
20130c8: 7f ff fb a3 call 2011f54 <rtems_rfs_inode_close>
20130cc: 90 10 00 1d mov %i5, %o0
if (rc > 0)
20130d0: ba 92 20 00 orcc %o0, 0, %i5
20130d4: 04 80 00 05 ble 20130e8 <rtems_rfs_rtems_node_type+0x70> <== ALWAYS TAKEN
20130d8: 01 00 00 00 nop
{
return rtems_rfs_rtems_error ("node_type: closing inode", rc);
20130dc: 40 00 36 b8 call 2020bbc <__errno> <== NOT EXECUTED
20130e0: b0 10 3f ff mov -1, %i0 ! ffffffff <RAM_END+0xfdbfffff> <== NOT EXECUTED
20130e4: fa 22 00 00 st %i5, [ %o0 ] <== NOT EXECUTED
}
return type;
}
20130e8: 81 c7 e0 08 ret
20130ec: 81 e8 00 00 restore
0201286c <rtems_rfs_rtems_readlink>:
static ssize_t
rtems_rfs_rtems_readlink (const rtems_filesystem_location_info_t* pathloc,
char* buf,
size_t bufsize)
{
201286c: 9d e3 bf 98 save %sp, -104, %sp
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
2012870: 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);
2012874: d2 06 20 08 ld [ %i0 + 8 ], %o1
2012878: d0 00 60 08 ld [ %g1 + 8 ], %o0
201287c: 94 10 00 19 mov %i1, %o2
2012880: 96 10 00 1a mov %i2, %o3
2012884: 40 00 31 81 call 201ee88 <rtems_rfs_symlink_read>
2012888: 98 07 bf fc add %fp, -4, %o4
if (rc)
{
return rtems_rfs_rtems_error ("readlink: reading link", rc);
}
return (ssize_t) length;
201288c: 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)
2012890: 80 a2 20 00 cmp %o0, 0
2012894: 02 80 00 05 be 20128a8 <rtems_rfs_rtems_readlink+0x3c> <== ALWAYS TAKEN
2012898: ba 10 00 08 mov %o0, %i5
{
return rtems_rfs_rtems_error ("readlink: reading link", rc);
201289c: 40 00 38 c8 call 2020bbc <__errno> <== NOT EXECUTED
20128a0: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
20128a4: fa 22 00 00 st %i5, [ %o0 ] <== NOT EXECUTED
}
return (ssize_t) length;
}
20128a8: 81 c7 e0 08 ret
20128ac: 81 e8 00 00 restore
020127e0 <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)
{
20127e0: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (old_loc);
20127e4: 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);
20127e8: 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);
20127ec: 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);
20127f0: 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);
20127f4: d6 06 a0 08 ld [ %i2 + 8 ], %o3 <== NOT EXECUTED
20127f8: 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);
20127fc: 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);
2012800: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
2012804: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
2012808: 98 10 00 18 mov %i0, %o4 <== NOT EXECUTED
201280c: 40 00 2f b1 call 201e6d0 <rtems_rfs_link> <== NOT EXECUTED
2012810: 9a 10 20 01 mov 1, %o5 <== NOT EXECUTED
if (rc)
2012814: b8 92 20 00 orcc %o0, 0, %i4 <== NOT EXECUTED
2012818: 02 80 00 07 be 2012834 <rtems_rfs_rtems_rename+0x54> <== NOT EXECUTED
201281c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
{
return rtems_rfs_rtems_error ("rename: linking", rc);
2012820: 40 00 38 e7 call 2020bbc <__errno> <== NOT EXECUTED
2012824: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
2012828: f8 22 00 00 st %i4, [ %o0 ] <== NOT EXECUTED
201282c: 81 c7 e0 08 ret <== NOT EXECUTED
2012830: 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,
2012834: 94 10 00 18 mov %i0, %o2 <== NOT EXECUTED
2012838: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED
201283c: 96 10 00 19 mov %i1, %o3 <== NOT EXECUTED
2012840: 98 10 20 02 mov 2, %o4 <== NOT EXECUTED
2012844: 40 00 30 0c call 201e874 <rtems_rfs_unlink> <== NOT EXECUTED
2012848: b0 10 20 00 clr %i0 <== NOT EXECUTED
rtems_rfs_unlink_dir_allowed);
if (rc)
201284c: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2012850: 02 80 00 05 be 2012864 <rtems_rfs_rtems_rename+0x84> <== NOT EXECUTED
2012854: ba 10 00 08 mov %o0, %i5 <== NOT EXECUTED
{
return rtems_rfs_rtems_error ("rename: unlinking", rc);
2012858: 40 00 38 d9 call 2020bbc <__errno> <== NOT EXECUTED
201285c: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
2012860: fa 22 00 00 st %i5, [ %o0 ] <== NOT EXECUTED
}
return 0;
}
2012864: 81 c7 e0 08 ret <== NOT EXECUTED
2012868: 81 e8 00 00 restore <== NOT EXECUTED
02013704 <rtems_rfs_rtems_set_handlers>:
*/
bool
rtems_rfs_rtems_set_handlers (rtems_filesystem_location_info_t* loc,
rtems_rfs_inode_handle* inode)
{
2013704: 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);
2013708: 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))
201370c: 05 00 00 10 sethi %hi(0x4000), %g2
2013710: d2 08 60 02 ldub [ %g1 + 2 ], %o1
2013714: c2 08 60 03 ldub [ %g1 + 3 ], %g1
2013718: 93 2a 60 08 sll %o1, 8, %o1
201371c: 92 12 40 01 or %o1, %g1, %o1
2013720: 03 00 00 3c sethi %hi(0xf000), %g1
2013724: 82 0a 40 01 and %o1, %g1, %g1
2013728: 80 a0 40 02 cmp %g1, %g2
201372c: 12 80 00 05 bne 2013740 <rtems_rfs_rtems_set_handlers+0x3c>
2013730: c0 26 20 10 clr [ %i0 + 0x10 ]
loc->handlers = rtems_rfs_rtems_handlers (dir);
2013734: 03 00 80 d3 sethi %hi(0x2034c00), %g1
2013738: 10 80 00 0a b 2013760 <rtems_rfs_rtems_set_handlers+0x5c>
201373c: 82 10 61 b0 or %g1, 0x1b0, %g1 ! 2034db0 <rtems_rfs_rtems_dir_handlers>
else if (RTEMS_RFS_S_ISCHR (mode) || RTEMS_RFS_S_ISBLK(mode))
2013740: 07 00 00 2c sethi %hi(0xb000), %g3
2013744: 05 00 00 08 sethi %hi(0x2000), %g2
2013748: 86 0a 40 03 and %o1, %g3, %g3
201374c: 80 a0 c0 02 cmp %g3, %g2
2013750: 12 80 00 07 bne 201376c <rtems_rfs_rtems_set_handlers+0x68><== ALWAYS TAKEN
2013754: 05 00 00 28 sethi %hi(0xa000), %g2
loc->handlers = rtems_rfs_rtems_handlers (device);
2013758: 03 00 80 d3 sethi %hi(0x2034c00), %g1 <== NOT EXECUTED
201375c: 82 10 61 84 or %g1, 0x184, %g1 ! 2034d84 <rtems_rfs_rtems_device_handlers><== NOT EXECUTED
2013760: c2 26 20 10 st %g1, [ %i0 + 0x10 ]
else
{
printf ("rtems-rfs: mode type unknown: %04x\n", mode);
return false;
}
return true;
2013764: 10 80 00 13 b 20137b0 <rtems_rfs_rtems_set_handlers+0xac>
2013768: 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))
201376c: 80 a0 40 02 cmp %g1, %g2
2013770: 12 80 00 05 bne 2013784 <rtems_rfs_rtems_set_handlers+0x80>
2013774: 05 00 00 20 sethi %hi(0x8000), %g2
loc->handlers = rtems_rfs_rtems_handlers (link);
2013778: 03 00 80 cb sethi %hi(0x2032c00), %g1
201377c: 10 bf ff f9 b 2013760 <rtems_rfs_rtems_set_handlers+0x5c>
2013780: 82 10 63 ac or %g1, 0x3ac, %g1 ! 2032fac <rtems_rfs_rtems_link_handlers>
else if (RTEMS_RFS_S_ISREG (mode))
2013784: 80 a0 40 02 cmp %g1, %g2
2013788: 32 80 00 05 bne,a 201379c <rtems_rfs_rtems_set_handlers+0x98><== NEVER TAKEN
201378c: 93 2a 60 10 sll %o1, 0x10, %o1 <== NOT EXECUTED
loc->handlers = rtems_rfs_rtems_handlers (file);
2013790: 03 00 80 d3 sethi %hi(0x2034c00), %g1
2013794: 10 bf ff f3 b 2013760 <rtems_rfs_rtems_set_handlers+0x5c>
2013798: 82 10 61 dc or %g1, 0x1dc, %g1 ! 2034ddc <rtems_rfs_rtems_file_handlers>
else
{
printf ("rtems-rfs: mode type unknown: %04x\n", mode);
201379c: 11 00 80 cb sethi %hi(0x2032c00), %o0 <== NOT EXECUTED
20137a0: 93 32 60 10 srl %o1, 0x10, %o1 <== NOT EXECUTED
20137a4: 90 12 23 e0 or %o0, 0x3e0, %o0 <== NOT EXECUTED
20137a8: 40 00 3a 54 call 20220f8 <printf> <== NOT EXECUTED
20137ac: b0 10 20 00 clr %i0 <== NOT EXECUTED
return false;
}
return true;
}
20137b0: b0 0e 20 01 and %i0, 1, %i0
20137b4: 81 c7 e0 08 ret
20137b8: 81 e8 00 00 restore
02012704 <rtems_rfs_rtems_statvfs>:
* @return int
*/
static int
rtems_rfs_rtems_statvfs (const rtems_filesystem_location_info_t* pathloc,
struct statvfs* sb)
{
2012704: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
2012708: c2 06 20 14 ld [ %i0 + 0x14 ], %g1 <== NOT EXECUTED
size_t blocks;
size_t inodes;
rtems_rfs_group_usage (fs, &blocks, &inodes);
201270c: 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);
2012710: fa 00 60 08 ld [ %g1 + 8 ], %i5 <== NOT EXECUTED
size_t blocks;
size_t inodes;
rtems_rfs_group_usage (fs, &blocks, &inodes);
2012714: 94 07 bf fc add %fp, -4, %o2 <== NOT EXECUTED
2012718: 7f ff fd 3b call 2011c04 <rtems_rfs_group_usage> <== NOT EXECUTED
201271c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
sb->f_bsize = rtems_rfs_fs_block_size (fs);
2012720: c2 07 60 08 ld [ %i5 + 8 ], %g1 <== NOT EXECUTED
2012724: c2 26 40 00 st %g1, [ %i1 ] <== NOT EXECUTED
sb->f_frsize = rtems_rfs_fs_media_block_size (fs);
2012728: c2 07 60 10 ld [ %i5 + 0x10 ], %g1 <== NOT EXECUTED
201272c: c4 00 60 20 ld [ %g1 + 0x20 ], %g2 <== NOT EXECUTED
sb->f_blocks = rtems_rfs_fs_media_blocks (fs);
2012730: 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);
2012734: c4 26 60 04 st %g2, [ %i1 + 4 ] <== NOT EXECUTED
sb->f_blocks = rtems_rfs_fs_media_blocks (fs);
2012738: c2 26 60 0c st %g1, [ %i1 + 0xc ] <== NOT EXECUTED
sb->f_bfree = rtems_rfs_fs_blocks (fs) - blocks;
201273c: c4 07 60 04 ld [ %i5 + 4 ], %g2 <== NOT EXECUTED
2012740: 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);
2012744: c0 26 60 08 clr [ %i1 + 8 ] <== NOT EXECUTED
sb->f_bfree = rtems_rfs_fs_blocks (fs) - blocks;
2012748: 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;
201274c: 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;
2012750: c2 26 60 14 st %g1, [ %i1 + 0x14 ] <== NOT EXECUTED
sb->f_bavail = sb->f_bfree;
2012754: c2 26 60 1c st %g1, [ %i1 + 0x1c ] <== NOT EXECUTED
sb->f_files = rtems_rfs_fs_inodes (fs);
2012758: 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;
201275c: c0 26 60 10 clr [ %i1 + 0x10 ] <== NOT EXECUTED
sb->f_bavail = sb->f_bfree;
sb->f_files = rtems_rfs_fs_inodes (fs);
2012760: c2 26 60 20 st %g1, [ %i1 + 0x20 ] <== NOT EXECUTED
sb->f_ffree = rtems_rfs_fs_inodes (fs) - inodes;
2012764: 82 20 40 02 sub %g1, %g2, %g1 <== NOT EXECUTED
2012768: c2 26 60 24 st %g1, [ %i1 + 0x24 ] <== NOT EXECUTED
sb->f_favail = sb->f_ffree;
201276c: c2 26 60 28 st %g1, [ %i1 + 0x28 ] <== NOT EXECUTED
sb->f_fsid = RTEMS_RFS_SB_MAGIC;
2012770: 03 0a 02 48 sethi %hi(0x28092000), %g1 <== NOT EXECUTED
2012774: 82 10 60 01 or %g1, 1, %g1 ! 28092001 <RAM_END+0x25c92001><== NOT EXECUTED
2012778: c2 26 60 2c st %g1, [ %i1 + 0x2c ] <== NOT EXECUTED
sb->f_flag = rtems_rfs_fs_flags (fs);
201277c: 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;
2012780: 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);
2012784: c2 26 60 30 st %g1, [ %i1 + 0x30 ] <== NOT EXECUTED
sb->f_namemax = rtems_rfs_fs_max_name (fs);
2012788: c2 07 60 1c ld [ %i5 + 0x1c ], %g1 <== NOT EXECUTED
201278c: c2 26 60 34 st %g1, [ %i1 + 0x34 ] <== NOT EXECUTED
return 0;
}
2012790: 81 c7 e0 08 ret <== NOT EXECUTED
2012794: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED
020128b0 <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)
{
20128b0: 9d e3 bf 98 save %sp, -104, %sp
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (parent_loc);
20128b4: 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),
20128b8: 90 10 00 1b mov %i3, %o0
20128bc: 40 00 42 a5 call 2023350 <strlen>
20128c0: 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);
20128c4: f0 06 20 08 ld [ %i0 + 8 ], %i0
int rc;
rc = rtems_rfs_symlink (fs, node_name, node_name_len,
20128c8: 40 00 11 76 call 2016ea0 <geteuid>
20128cc: ba 10 00 08 mov %o0, %i5
20128d0: 40 00 11 70 call 2016e90 <getegid>
20128d4: a0 10 00 08 mov %o0, %l0
20128d8: 91 2a 20 10 sll %o0, 0x10, %o0
20128dc: 91 32 20 10 srl %o0, 0x10, %o0
20128e0: f0 23 a0 60 st %i0, [ %sp + 0x60 ]
20128e4: d0 23 a0 5c st %o0, [ %sp + 0x5c ]
20128e8: 98 10 00 1d mov %i5, %o4
20128ec: 9b 2c 20 10 sll %l0, 0x10, %o5
20128f0: 90 10 00 1c mov %i4, %o0
20128f4: 92 10 00 19 mov %i1, %o1
20128f8: 94 10 00 1a mov %i2, %o2
20128fc: 96 10 00 1b mov %i3, %o3
2012900: 9b 33 60 10 srl %o5, 0x10, %o5
2012904: 40 00 30 c8 call 201ec24 <rtems_rfs_symlink>
2012908: b0 10 20 00 clr %i0
target, strlen (target),
geteuid(), getegid(), parent);
if (rc)
201290c: 80 a2 20 00 cmp %o0, 0
2012910: 02 80 00 05 be 2012924 <rtems_rfs_rtems_symlink+0x74> <== ALWAYS TAKEN
2012914: ba 10 00 08 mov %o0, %i5
{
return rtems_rfs_rtems_error ("symlink: linking", rc);
2012918: 40 00 38 a9 call 2020bbc <__errno> <== NOT EXECUTED
201291c: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
2012920: fa 22 00 00 st %i5, [ %o0 ] <== NOT EXECUTED
}
return 0;
}
2012924: 81 c7 e0 08 ret
2012928: 81 e8 00 00 restore
0201f1a8 <rtems_rfs_rtems_unlock>:
/**
* Unlock the RFS file system.
*/
static inline void
rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)
{
201f1a8: 9d e3 bf a0 save %sp, -96, %sp
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
201f1ac: fa 06 20 80 ld [ %i0 + 0x80 ], %i5
rtems_rfs_buffers_release (fs);
201f1b0: 7f ff f2 24 call 201ba40 <rtems_rfs_buffers_release>
201f1b4: 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);
201f1b8: 7f ff b6 e7 call 200cd54 <rtems_semaphore_release>
201f1bc: d0 07 40 00 ld [ %i5 ], %o0
if (sc != RTEMS_SUCCESSFUL)
201f1c0: ba 92 20 00 orcc %o0, 0, %i5
201f1c4: 02 80 00 0c be 201f1f4 <rtems_rfs_rtems_unlock+0x4c> <== ALWAYS TAKEN
201f1c8: 90 10 20 00 clr %o0
{
#if RTEMS_RFS_TRACE
if (rtems_rfs_trace (RTEMS_RFS_TRACE_MUTEX))
201f1cc: 7f ff d1 81 call 20137d0 <rtems_rfs_trace> <== NOT EXECUTED
201f1d0: 92 10 20 04 mov 4, %o1 <== NOT EXECUTED
201f1d4: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
201f1d8: 02 80 00 07 be 201f1f4 <rtems_rfs_rtems_unlock+0x4c> <== NOT EXECUTED
201f1dc: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
printf ("rtems-rfs: mutex: release failed: %s\n",
201f1e0: 7f ff a3 75 call 2007fb4 <rtems_status_text> <== NOT EXECUTED
201f1e4: 31 00 80 cb sethi %hi(0x2032c00), %i0 <== NOT EXECUTED
201f1e8: b0 16 22 c8 or %i0, 0x2c8, %i0 ! 2032ec8 <_CPU_Trap_slot_template+0xc90><== NOT EXECUTED
201f1ec: 40 00 0b c3 call 20220f8 <printf> <== NOT EXECUTED
201f1f0: 93 e8 00 08 restore %g0, %o0, %o1 <== NOT EXECUTED
201f1f4: 81 c7 e0 08 ret
201f1f8: 81 e8 00 00 restore
0201292c <rtems_rfs_rtems_utime>:
static int
rtems_rfs_rtems_utime(const rtems_filesystem_location_info_t* pathloc,
time_t atime,
time_t mtime)
{
201292c: 9d e3 bf 78 save %sp, -136, %sp <== NOT EXECUTED
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
2012930: 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);
2012934: 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);
2012938: 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);
201293c: 94 07 bf d8 add %fp, -40, %o2 <== NOT EXECUTED
2012940: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
2012944: 7f ff fd 12 call 2011d8c <rtems_rfs_inode_open> <== NOT EXECUTED
2012948: 96 10 20 01 mov 1, %o3 <== NOT EXECUTED
if (rc)
201294c: b8 92 20 00 orcc %o0, 0, %i4 <== NOT EXECUTED
2012950: 02 80 00 07 be 201296c <rtems_rfs_rtems_utime+0x40> <== NOT EXECUTED
2012954: c2 07 bf e4 ld [ %fp + -28 ], %g1 <== NOT EXECUTED
{
return rtems_rfs_rtems_error ("utime: read inode", rc);
2012958: 40 00 38 99 call 2020bbc <__errno> <== NOT EXECUTED
201295c: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
2012960: f8 22 00 00 st %i4, [ %o0 ] <== NOT EXECUTED
2012964: 81 c7 e0 08 ret <== NOT EXECUTED
2012968: 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);
201296c: 85 36 60 18 srl %i1, 0x18, %g2 <== NOT EXECUTED
2012970: c4 28 60 10 stb %g2, [ %g1 + 0x10 ] <== NOT EXECUTED
2012974: 85 36 60 10 srl %i1, 0x10, %g2 <== NOT EXECUTED
2012978: c4 28 60 11 stb %g2, [ %g1 + 0x11 ] <== NOT EXECUTED
201297c: 85 36 60 08 srl %i1, 8, %g2 <== NOT EXECUTED
2012980: c4 28 60 12 stb %g2, [ %g1 + 0x12 ] <== NOT EXECUTED
rtems_rfs_buffer_mark_dirty (&handle->buffer);
2012984: 84 10 20 01 mov 1, %g2 <== NOT EXECUTED
2012988: 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);
201298c: 85 36 a0 18 srl %i2, 0x18, %g2 <== NOT EXECUTED
2012990: c4 28 60 14 stb %g2, [ %g1 + 0x14 ] <== NOT EXECUTED
2012994: 85 36 a0 10 srl %i2, 0x10, %g2 <== NOT EXECUTED
2012998: c4 28 60 15 stb %g2, [ %g1 + 0x15 ] <== NOT EXECUTED
201299c: 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);
20129a0: 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);
20129a4: 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);
20129a8: c4 28 60 16 stb %g2, [ %g1 + 0x16 ] <== NOT EXECUTED
20129ac: f4 28 60 17 stb %i2, [ %g1 + 0x17 ] <== NOT EXECUTED
20129b0: 92 07 bf d8 add %fp, -40, %o1 <== NOT EXECUTED
20129b4: 7f ff fd 68 call 2011f54 <rtems_rfs_inode_close> <== NOT EXECUTED
20129b8: b0 10 20 00 clr %i0 <== NOT EXECUTED
if (rc)
20129bc: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
20129c0: 02 80 00 05 be 20129d4 <rtems_rfs_rtems_utime+0xa8> <== NOT EXECUTED
20129c4: ba 10 00 08 mov %o0, %i5 <== NOT EXECUTED
{
return rtems_rfs_rtems_error ("utime: closing inode", rc);
20129c8: 40 00 38 7d call 2020bbc <__errno> <== NOT EXECUTED
20129cc: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
20129d0: fa 22 00 00 st %i5, [ %o0 ] <== NOT EXECUTED
}
return 0;
}
20129d4: 81 c7 e0 08 ret <== NOT EXECUTED
20129d8: 81 e8 00 00 restore <== NOT EXECUTED
0201b2e4 <rtems_rfs_scan_chain>:
*/
static rtems_rfs_buffer*
rtems_rfs_scan_chain (rtems_chain_control* chain,
uint32_t* count,
rtems_rfs_buffer_block block)
{
201b2e4: 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))
201b2e8: 90 10 20 00 clr %o0
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Last(
Chain_Control *the_chain
)
{
return _Chain_Tail( the_chain )->previous;
201b2ec: fa 06 20 08 ld [ %i0 + 8 ], %i5
201b2f0: 7f ff e1 38 call 20137d0 <rtems_rfs_trace>
201b2f4: 92 10 20 80 mov 0x80, %o1
201b2f8: 80 8a 20 ff btst 0xff, %o0
201b2fc: 22 80 00 29 be,a 201b3a0 <rtems_rfs_scan_chain+0xbc> <== ALWAYS TAKEN
201b300: 39 00 80 ce sethi %hi(0x2033800), %i4
printf ("rtems-rfs: buffer-scan: count=%" PRIu32 ", block=%" PRIu32 ": ", *count, block);
201b304: d2 06 40 00 ld [ %i1 ], %o1 <== NOT EXECUTED
201b308: 11 00 80 ce sethi %hi(0x2033800), %o0 <== NOT EXECUTED
201b30c: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED
201b310: 40 00 1b 7a call 20220f8 <printf> <== NOT EXECUTED
201b314: 90 12 20 10 or %o0, 0x10, %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));
201b318: 10 80 00 22 b 201b3a0 <rtems_rfs_scan_chain+0xbc> <== NOT EXECUTED
201b31c: 39 00 80 ce sethi %hi(0x2033800), %i4 <== NOT EXECUTED
while (!rtems_chain_is_head (chain, node))
{
buffer = (rtems_rfs_buffer*) node;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))
201b320: 7f ff e1 2c call 20137d0 <rtems_rfs_trace>
201b324: 01 00 00 00 nop
201b328: 80 8a 20 ff btst 0xff, %o0
201b32c: 22 80 00 06 be,a 201b344 <rtems_rfs_scan_chain+0x60> <== ALWAYS TAKEN
201b330: c2 07 60 34 ld [ %i5 + 0x34 ], %g1
printf ("%" PRIuPTR " ", ((intptr_t) buffer->user));
201b334: d2 07 60 34 ld [ %i5 + 0x34 ], %o1 <== NOT EXECUTED
201b338: 40 00 1b 70 call 20220f8 <printf> <== NOT EXECUTED
201b33c: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
if (((rtems_rfs_buffer_block) ((intptr_t)(buffer->user))) == block)
201b340: c2 07 60 34 ld [ %i5 + 0x34 ], %g1 <== NOT EXECUTED
201b344: 80 a0 40 1a cmp %g1, %i2
201b348: 32 80 00 17 bne,a 201b3a4 <rtems_rfs_scan_chain+0xc0>
201b34c: fa 07 60 04 ld [ %i5 + 4 ], %i5
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))
201b350: 90 10 20 00 clr %o0
201b354: 7f ff e1 1f call 20137d0 <rtems_rfs_trace>
201b358: 92 10 20 80 mov 0x80, %o1
201b35c: 80 8a 20 ff btst 0xff, %o0
201b360: 22 80 00 07 be,a 201b37c <rtems_rfs_scan_chain+0x98> <== ALWAYS TAKEN
201b364: c2 06 40 00 ld [ %i1 ], %g1
printf (": found block=%" PRIuPTR "\n",
201b368: d2 07 60 34 ld [ %i5 + 0x34 ], %o1 <== NOT EXECUTED
201b36c: 11 00 80 ce sethi %hi(0x2033800), %o0 <== NOT EXECUTED
201b370: 40 00 1b 62 call 20220f8 <printf> <== NOT EXECUTED
201b374: 90 12 20 48 or %o0, 0x48, %o0 ! 2033848 <CSWTCH.2+0x168> <== NOT EXECUTED
((intptr_t)(buffer->user)));
(*count)--;
201b378: 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 );
201b37c: 90 10 00 1d mov %i5, %o0
201b380: 82 00 7f ff add %g1, -1, %g1
rtems_chain_extract (node);
rtems_chain_set_off_chain (node);
return buffer;
201b384: b0 10 00 1d mov %i5, %i0
201b388: 7f ff f3 fc call 2018378 <_Chain_Extract>
201b38c: c2 26 40 00 st %g1, [ %i1 ]
*/
RTEMS_INLINE_ROUTINE void _Chain_Set_off_chain(
Chain_Node *node
)
{
node->next = node->previous = NULL;
201b390: c0 27 60 04 clr [ %i5 + 4 ]
201b394: c0 27 40 00 clr [ %i5 ]
201b398: 81 c7 e0 08 ret
201b39c: 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));
201b3a0: b8 17 20 40 or %i4, 0x40, %i4
while (!rtems_chain_is_head (chain, node))
{
buffer = (rtems_rfs_buffer*) node;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))
201b3a4: 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))
201b3a8: 80 a7 40 18 cmp %i5, %i0
201b3ac: 12 bf ff dd bne 201b320 <rtems_rfs_scan_chain+0x3c>
201b3b0: 92 10 20 80 mov 0x80, %o1
return buffer;
}
node = rtems_chain_previous (node);
}
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))
201b3b4: 7f ff e1 07 call 20137d0 <rtems_rfs_trace>
201b3b8: b0 10 20 00 clr %i0
201b3bc: 80 8a 20 ff btst 0xff, %o0
201b3c0: 02 bf ff f6 be 201b398 <rtems_rfs_scan_chain+0xb4> <== ALWAYS TAKEN
201b3c4: 11 00 80 ce sethi %hi(0x2033800), %o0
printf (": not found\n");
201b3c8: 40 00 1b e4 call 2022358 <puts> <== NOT EXECUTED
201b3cc: 90 12 20 60 or %o0, 0x60, %o0 ! 2033860 <CSWTCH.2+0x180> <== NOT EXECUTED
return NULL;
}
201b3d0: 81 c7 e0 08 ret <== NOT EXECUTED
201b3d4: 81 e8 00 00 restore <== NOT EXECUTED
02019a3c <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,
2019a3c: 9d e3 bf 88 save %sp, -120, %sp
rtems_rfs_bitmap_element* map_bits;
int map_index;
int map_offset;
int rc;
*found = false;
2019a40: c0 2e 80 00 clrb [ %i2 ]
/*
* Load the bitmap.
*/
rc = rtems_rfs_bitmap_load_map (control, &map);
2019a44: 90 10 00 18 mov %i0, %o0
2019a48: 7f ff ff e8 call 20199e8 <rtems_rfs_bitmap_load_map>
2019a4c: 92 07 bf fc add %fp, -4, %o1
if (rc > 0)
2019a50: 80 a2 20 00 cmp %o0, 0
2019a54: 14 80 00 98 bg 2019cb4 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x278><== NEVER TAKEN
2019a58: 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;
2019a5c: fa 06 40 00 ld [ %i1 ], %i5
end_bit = test_bit + (window * direction);
if (end_bit < 0)
2019a60: a0 84 00 1d addcc %l0, %i5, %l0
2019a64: 2c 80 00 08 bneg,a 2019a84 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x48>
2019a68: a0 10 20 00 clr %l0
end_bit = 0;
else if (end_bit >= control->size)
2019a6c: c2 06 20 0c ld [ %i0 + 0xc ], %g1
2019a70: 80 a4 00 01 cmp %l0, %g1
2019a74: 3a 80 00 04 bcc,a 2019a84 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x48><== ALWAYS TAKEN
2019a78: 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];
2019a7c: 10 80 00 03 b 2019a88 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x4c><== NOT EXECUTED
2019a80: c4 06 20 14 ld [ %i0 + 0x14 ], %g2 <== NOT EXECUTED
2019a84: c4 06 20 14 ld [ %i0 + 0x14 ], %g2
map_bits = &map[map_index];
2019a88: 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);
2019a8c: 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);
2019a90: 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);
2019a94: 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];
2019a98: 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);
2019a9c: 82 0f 20 1f and %i4, 0x1f, %g1
search_bits = &control->search_bits[search_index];
2019aa0: a6 00 80 13 add %g2, %l3, %l3
map_offset += direction;
test_bit += direction;
}
}
map_bits += direction;
2019aa4: 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];
2019aa8: 85 2f 20 02 sll %i4, 2, %g2
2019aac: a8 10 20 1f mov 0x1f, %l4
2019ab0: 80 a6 e0 00 cmp %i3, 0
2019ab4: 04 80 00 03 ble 2019ac0 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x84>
2019ab8: a2 04 40 02 add %l1, %g2, %l1
2019abc: 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)))
2019ac0: ab 3e e0 1f sra %i3, 0x1f, %l5
return 0;
}
static int
rtems_rfs_search_map_for_clear_bit (rtems_rfs_bitmap_control* control,
2019ac4: 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)))
2019ac8: 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);
2019acc: 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))
2019ad0: 87 36 e0 1f srl %i3, 0x1f, %g3
|| ((direction > 0) && (test_bit >= end_bit)))
2019ad4: 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;
2019ad8: 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))
2019adc: d8 04 c0 00 ld [ %l3 ], %o4
2019ae0: 80 a3 20 00 cmp %o4, 0
2019ae4: 02 80 00 44 be 2019bf4 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x1b8><== NEVER TAKEN
2019ae8: 80 a6 e0 00 cmp %i3, 0
return 0;
}
static int
rtems_rfs_search_map_for_clear_bit (rtems_rfs_bitmap_control* control,
2019aec: 96 07 00 1b add %i4, %i3, %o3
2019af0: 84 10 20 00 clr %g2
2019af4: 97 2a e0 05 sll %o3, 5, %o3
2019af8: 82 20 40 1c sub %g1, %i4, %g1
2019afc: 10 80 00 38 b 2019bdc <rtems_rfs_search_map_for_clear_bit.constprop.1+0x1a0>
2019b00: 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))
2019b04: 80 8b c0 0c btst %o7, %o4
2019b08: 12 80 00 1a bne 2019b70 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x134>
2019b0c: a4 24 80 1d sub %l2, %i5, %l2
return 0;
}
static int
rtems_rfs_search_map_for_clear_bit (rtems_rfs_bitmap_control* control,
2019b10: 10 80 00 1d b 2019b84 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x148>
2019b14: 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);
2019b18: 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))
2019b1c: 80 8a 80 09 btst %o2, %o1
2019b20: 02 80 00 12 be 2019b68 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x12c>
2019b24: 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);
2019b28: 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,
2019b2c: 80 a2 a0 00 cmp %o2, 0
2019b30: 12 80 00 05 bne 2019b44 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x108>
2019b34: 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);
2019b38: c2 04 c0 00 ld [ %l3 ], %g1
2019b3c: 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,
2019b40: de 24 c0 00 st %o7, [ %l3 ]
1 << search_offset);
control->free--;
2019b44: c2 06 20 10 ld [ %i0 + 0x10 ], %g1
*bit = test_bit;
*found = true;
rtems_rfs_buffer_mark_dirty (control->buffer);
2019b48: 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--;
2019b4c: 82 00 7f ff add %g1, -1, %g1
2019b50: c2 26 20 10 st %g1, [ %i0 + 0x10 ]
*bit = test_bit;
2019b54: fa 26 40 00 st %i5, [ %i1 ]
*found = true;
2019b58: 82 10 20 01 mov 1, %g1
2019b5c: c2 2e 80 00 stb %g1, [ %i2 ]
rtems_rfs_buffer_mark_dirty (control->buffer);
2019b60: 10 80 00 54 b 2019cb0 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x274>
2019b64: c2 28 80 00 stb %g1, [ %g2 ]
return 0;
}
if (test_bit == end_bit)
2019b68: 02 80 00 06 be 2019b80 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x144>
2019b6c: ba 07 40 1b add %i5, %i3, %i5
return 0;
}
static int
rtems_rfs_search_map_for_clear_bit (rtems_rfs_bitmap_control* control,
2019b70: 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)
2019b74: 80 a2 a0 1f cmp %o2, 0x1f
2019b78: 28 bf ff e8 bleu,a 2019b18 <rtems_rfs_search_map_for_clear_bit.constprop.1+0xdc><== ALWAYS TAKEN
2019b7c: d2 04 40 00 ld [ %l1 ], %o1
return 0;
}
static int
rtems_rfs_search_map_for_clear_bit (rtems_rfs_bitmap_control* control,
2019b80: ba 00 80 0b add %g2, %o3, %i5
map_offset += direction;
test_bit += direction;
}
}
map_bits += direction;
2019b84: a2 04 40 16 add %l1, %l6, %l1
map_index += direction;
2019b88: 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))
2019b8c: 80 a7 40 10 cmp %i5, %l0
2019b90: 04 80 00 03 ble 2019b9c <rtems_rfs_search_map_for_clear_bit.constprop.1+0x160>
2019b94: 9e 10 20 01 mov 1, %o7
2019b98: 9e 10 20 00 clr %o7
2019b9c: 80 8b e0 ff btst 0xff, %o7
2019ba0: 02 80 00 05 be 2019bb4 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x178>
2019ba4: 84 00 80 04 add %g2, %g4, %g2
2019ba8: 80 a0 e0 00 cmp %g3, 0
2019bac: 32 80 00 29 bne,a 2019c50 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x214>
2019bb0: a4 10 00 14 mov %l4, %l2
|| ((direction > 0) && (test_bit >= end_bit)))
2019bb4: 80 a7 40 10 cmp %i5, %l0
2019bb8: 16 80 00 03 bge 2019bc4 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x188>
2019bbc: 9e 10 20 01 mov 1, %o7
2019bc0: 9e 10 20 00 clr %o7
2019bc4: 80 8b e0 ff btst 0xff, %o7
2019bc8: 02 80 00 05 be 2019bdc <rtems_rfs_search_map_for_clear_bit.constprop.1+0x1a0>
2019bcc: a4 10 00 14 mov %l4, %l2
2019bd0: 80 a5 60 00 cmp %l5, 0
2019bd4: 32 80 00 20 bne,a 2019c54 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x218><== ALWAYS TAKEN
2019bd8: a6 04 c0 16 add %l3, %l6, %l3
return 0;
}
static int
rtems_rfs_search_map_for_clear_bit (rtems_rfs_bitmap_control* control,
2019bdc: 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)
2019be0: 80 a3 e0 1f cmp %o7, 0x1f
2019be4: 28 bf ff c8 bleu,a 2019b04 <rtems_rfs_search_map_for_clear_bit.constprop.1+0xc8><== ALWAYS TAKEN
2019be8: 9f 2d c0 0f sll %l7, %o7, %o7
}
map_bits += direction * bits_skipped;
map_index += direction * bits_skipped;
}
search_bits += direction;
2019bec: 10 80 00 1a b 2019c54 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x218><== NOT EXECUTED
2019bf0: 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)
2019bf4: 04 80 00 07 ble 2019c10 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x1d4><== NOT EXECUTED
2019bf8: ba 0f 7f e0 and %i5, -32, %i5 <== NOT EXECUTED
{
bits_skipped = rtems_rfs_bitmap_element_bits () - search_offset;
2019bfc: 92 23 40 01 sub %o5, %g1, %o1 <== NOT EXECUTED
test_bit += bits_skipped * rtems_rfs_bitmap_element_bits ();
map_offset = 0;
2019c00: 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 ();
2019c04: 83 2a 60 05 sll %o1, 5, %g1 <== NOT EXECUTED
2019c08: 10 80 00 07 b 2019c24 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x1e8><== NOT EXECUTED
2019c0c: ba 00 40 1d add %g1, %i5, %i5 <== NOT EXECUTED
map_offset = 0;
}
else
{
bits_skipped = search_offset + 1;
2019c10: 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;
2019c14: 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;
2019c18: 83 28 60 05 sll %g1, 5, %g1 <== NOT EXECUTED
2019c1c: 82 38 00 01 xnor %g0, %g1, %g1 <== NOT EXECUTED
2019c20: ba 00 40 1d add %g1, %i5, %i5 <== NOT EXECUTED
map_offset = rtems_rfs_bitmap_element_bits () - 1;
}
map_bits += direction * bits_skipped;
2019c24: c6 27 bf f4 st %g3, [ %fp + -12 ] <== NOT EXECUTED
2019c28: c8 27 bf f0 st %g4, [ %fp + -16 ] <== NOT EXECUTED
2019c2c: da 27 bf ec st %o5, [ %fp + -20 ] <== NOT EXECUTED
2019c30: 7f ff a2 59 call 2002594 <.umul> <== NOT EXECUTED
2019c34: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
2019c38: c6 07 bf f4 ld [ %fp + -12 ], %g3 <== NOT EXECUTED
2019c3c: 83 2a 20 02 sll %o0, 2, %g1 <== NOT EXECUTED
map_index += direction * bits_skipped;
2019c40: 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;
2019c44: a2 04 40 01 add %l1, %g1, %l1 <== NOT EXECUTED
2019c48: c8 07 bf f0 ld [ %fp + -16 ], %g4 <== NOT EXECUTED
2019c4c: da 07 bf ec ld [ %fp + -20 ], %o5 <== NOT EXECUTED
map_index += direction * bits_skipped;
}
search_bits += direction;
2019c50: a6 04 c0 16 add %l3, %l6, %l3
search_offset = direction > 0 ? 0 : rtems_rfs_bitmap_element_bits () - 1;
2019c54: 80 a6 e0 00 cmp %i3, 0
2019c58: 04 80 00 03 ble 2019c64 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x228>
2019c5c: 82 10 20 1f mov 0x1f, %g1
2019c60: 82 10 20 00 clr %g1
}
while (((direction < 0) && (test_bit >= end_bit))
2019c64: 80 a7 40 10 cmp %i5, %l0
2019c68: 16 80 00 03 bge 2019c74 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x238>
2019c6c: 84 10 20 01 mov 1, %g2
2019c70: 84 10 20 00 clr %g2
|| ((direction > 0) && (test_bit <= end_bit)));
2019c74: 80 88 a0 ff btst 0xff, %g2
2019c78: 02 80 00 06 be 2019c90 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x254>
2019c7c: 80 a7 40 10 cmp %i5, %l0
2019c80: 80 a0 e0 00 cmp %g3, 0
2019c84: 32 bf ff 97 bne,a 2019ae0 <rtems_rfs_search_map_for_clear_bit.constprop.1+0xa4><== NEVER TAKEN
2019c88: d8 04 c0 00 ld [ %l3 ], %o4 <== NOT EXECUTED
2019c8c: 80 a7 40 10 cmp %i5, %l0
2019c90: 04 80 00 03 ble 2019c9c <rtems_rfs_search_map_for_clear_bit.constprop.1+0x260>
2019c94: 84 10 20 01 mov 1, %g2
2019c98: 84 10 20 00 clr %g2
2019c9c: 80 88 a0 ff btst 0xff, %g2
2019ca0: 02 80 00 04 be 2019cb0 <rtems_rfs_search_map_for_clear_bit.constprop.1+0x274>
2019ca4: 80 a5 60 00 cmp %l5, 0
2019ca8: 32 bf ff 8e bne,a 2019ae0 <rtems_rfs_search_map_for_clear_bit.constprop.1+0xa4><== NEVER TAKEN
2019cac: d8 04 c0 00 ld [ %l3 ], %o4 <== NOT EXECUTED
return 0;
2019cb0: 90 10 20 00 clr %o0
}
2019cb4: 81 c7 e0 08 ret
2019cb8: 91 e8 00 08 restore %g0, %o0, %o0
02020778 <rtems_rfs_shell_block>:
return 0;
}
static int
rtems_rfs_shell_block (rtems_rfs_file_system* fs, int argc, char *argv[])
{
2020778: 9d e3 bf 90 save %sp, -112, %sp <== NOT EXECUTED
uint8_t* data;
bool state;
int b;
int rc;
if (argc <= 1)
202077c: 80 a6 60 01 cmp %i1, 1 <== NOT EXECUTED
2020780: 34 80 00 07 bg,a 202079c <rtems_rfs_shell_block+0x24> <== NOT EXECUTED
2020784: d0 06 a0 04 ld [ %i2 + 4 ], %o0 <== NOT EXECUTED
{
printf ("error: no block number provided\n");
2020788: 11 00 81 5d sethi %hi(0x2057400), %o0 <== NOT EXECUTED
202078c: 40 00 6a d3 call 203b2d8 <puts> <== NOT EXECUTED
2020790: 90 12 23 c8 or %o0, 0x3c8, %o0 ! 20577c8 <rtems_rtc_shell_usage+0x12e8><== 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;
2020794: 81 c7 e0 08 ret <== NOT EXECUTED
2020798: 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);
202079c: 92 10 20 00 clr %o1 <== NOT EXECUTED
20207a0: 40 00 7a 31 call 203f064 <strtoul> <== NOT EXECUTED
20207a4: 94 10 20 00 clr %o2 <== NOT EXECUTED
20207a8: 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);
20207ac: 7f ff fd 06 call 201fbc4 <rtems_rfs_rtems_lock> <== NOT EXECUTED
20207b0: 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);
20207b4: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
20207b8: 92 10 20 00 clr %o1 <== NOT EXECUTED
20207bc: 94 10 00 1d mov %i5, %o2 <== NOT EXECUTED
20207c0: 40 00 3a 71 call 202f184 <rtems_rfs_group_bitmap_test> <== NOT EXECUTED
20207c4: 96 07 bf f3 add %fp, -13, %o3 <== NOT EXECUTED
if (rc > 0)
20207c8: b8 92 20 00 orcc %o0, 0, %i4 <== NOT EXECUTED
20207cc: 04 80 00 0a ble 20207f4 <rtems_rfs_shell_block+0x7c> <== NOT EXECUTED
20207d0: 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);
20207d4: 7f ff fd 11 call 201fc18 <rtems_rfs_rtems_unlock> <== NOT EXECUTED
20207d8: 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",
20207dc: 40 00 73 a6 call 203d674 <strerror> <== NOT EXECUTED
20207e0: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
20207e4: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
20207e8: 11 00 81 5d sethi %hi(0x2057400), %o0 <== NOT EXECUTED
20207ec: 10 80 00 25 b 2020880 <rtems_rfs_shell_block+0x108> <== NOT EXECUTED
20207f0: 90 12 23 e8 or %o0, 0x3e8, %o0 ! 20577e8 <rtems_rtc_shell_usage+0x1308><== NOT EXECUTED
block, rc, strerror (rc));
return 1;
}
printf (" %5" PRIu32 ": block %s\n", block, state ? "allocated" : "free");
20207f4: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
20207f8: 22 80 00 05 be,a 202080c <rtems_rfs_shell_block+0x94> <== NOT EXECUTED
20207fc: 15 00 81 54 sethi %hi(0x2055000), %o2 <== NOT EXECUTED
2020800: 15 00 81 5d sethi %hi(0x2057400), %o2 <== NOT EXECUTED
2020804: 10 80 00 03 b 2020810 <rtems_rfs_shell_block+0x98> <== NOT EXECUTED
2020808: 94 12 a3 b8 or %o2, 0x3b8, %o2 ! 20577b8 <rtems_rtc_shell_usage+0x12d8><== NOT EXECUTED
202080c: 94 12 a3 88 or %o2, 0x388, %o2 <== NOT EXECUTED
2020810: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
2020814: 11 00 81 5e sethi %hi(0x2057800), %o0 <== NOT EXECUTED
2020818: 40 00 6a 18 call 203b078 <printf> <== NOT EXECUTED
202081c: 90 12 20 18 or %o0, 0x18, %o0 ! 2057818 <rtems_rtc_shell_usage+0x1338><== 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);
2020820: 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;
2020824: c0 2f bf f4 clrb [ %fp + -12 ] <== NOT EXECUTED
handle->bnum = 0;
2020828: c0 27 bf f8 clr [ %fp + -8 ] <== NOT EXECUTED
handle->buffer = NULL;
202082c: c0 27 bf fc clr [ %fp + -4 ] <== NOT EXECUTED
2020830: 92 07 bf f4 add %fp, -12, %o1 <== NOT EXECUTED
2020834: 94 10 00 1d mov %i5, %o2 <== NOT EXECUTED
2020838: 40 00 31 b6 call 202cf10 <rtems_rfs_buffer_handle_request><== NOT EXECUTED
202083c: 96 10 20 01 mov 1, %o3 <== NOT EXECUTED
if (rc > 0)
2020840: b8 92 20 00 orcc %o0, 0, %i4 <== NOT EXECUTED
2020844: 04 80 00 14 ble 2020894 <rtems_rfs_shell_block+0x11c> <== NOT EXECUTED
2020848: 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);
202084c: 92 07 bf f4 add %fp, -12, %o1 <== NOT EXECUTED
2020850: 40 00 31 3c call 202cd40 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
2020854: 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);
2020858: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
handle->dirty = false;
202085c: c0 2f bf f4 clrb [ %fp + -12 ] <== NOT EXECUTED
handle->bnum = 0;
2020860: c0 27 bf f8 clr [ %fp + -8 ] <== NOT EXECUTED
2020864: 7f ff fc ed call 201fc18 <rtems_rfs_rtems_unlock> <== NOT EXECUTED
2020868: 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",
202086c: 40 00 73 82 call 203d674 <strerror> <== NOT EXECUTED
2020870: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
2020874: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
2020878: 11 00 81 5e sethi %hi(0x2057800), %o0 <== NOT EXECUTED
202087c: 90 12 20 30 or %o0, 0x30, %o0 ! 2057830 <rtems_rtc_shell_usage+0x1350><== NOT EXECUTED
2020880: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
2020884: 40 00 69 fd call 203b078 <printf> <== NOT EXECUTED
2020888: 94 10 00 1c mov %i4, %o2 <== NOT EXECUTED
block, rc, strerror (rc));
return 1;
202088c: 81 c7 e0 08 ret <== NOT EXECUTED
2020890: 91 e8 20 01 restore %g0, 1, %o0 <== NOT EXECUTED
int mod = b % 16;
if (mod == 0)
{
if (b)
printf ("\n");
printf ("%04x ", b);
2020894: 37 00 81 5e sethi %hi(0x2057800), %i3 <== NOT EXECUTED
}
if (mod == 8)
printf (" ");
printf ("%02x ", *data);
2020898: 35 00 81 5e sethi %hi(0x2057800), %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);
202089c: f8 00 60 1c ld [ %g1 + 0x1c ], %i4 <== NOT EXECUTED
20208a0: ba 10 20 00 clr %i5 <== NOT EXECUTED
int mod = b % 16;
if (mod == 0)
{
if (b)
printf ("\n");
printf ("%04x ", b);
20208a4: b6 16 e0 f8 or %i3, 0xf8, %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);
20208a8: 10 80 00 16 b 2020900 <rtems_rfs_shell_block+0x188> <== NOT EXECUTED
20208ac: b4 16 a1 00 or %i2, 0x100, %i2 <== NOT EXECUTED
b < rtems_rfs_fs_block_size (fs);
b++, data++)
{
int mod = b % 16;
if (mod == 0)
20208b0: 12 80 00 0c bne 20208e0 <rtems_rfs_shell_block+0x168> <== NOT EXECUTED
20208b4: 80 a0 60 08 cmp %g1, 8 <== NOT EXECUTED
{
if (b)
20208b8: 80 a7 60 00 cmp %i5, 0 <== NOT EXECUTED
20208bc: 02 80 00 05 be 20208d0 <rtems_rfs_shell_block+0x158> <== NOT EXECUTED
20208c0: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
printf ("\n");
20208c4: 40 00 6a 57 call 203b220 <putchar> <== NOT EXECUTED
20208c8: 90 10 20 0a mov 0xa, %o0 <== NOT EXECUTED
printf ("%04x ", b);
20208cc: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
20208d0: 40 00 69 ea call 203b078 <printf> <== NOT EXECUTED
20208d4: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
}
if (mod == 8)
printf (" ");
printf ("%02x ", *data);
20208d8: 10 80 00 07 b 20208f4 <rtems_rfs_shell_block+0x17c> <== NOT EXECUTED
20208dc: d2 0f 00 1d ldub [ %i4 + %i5 ], %o1 <== NOT EXECUTED
{
if (b)
printf ("\n");
printf ("%04x ", b);
}
if (mod == 8)
20208e0: 32 80 00 05 bne,a 20208f4 <rtems_rfs_shell_block+0x17c> <== NOT EXECUTED
20208e4: d2 0f 00 1d ldub [ %i4 + %i5 ], %o1 <== NOT EXECUTED
printf (" ");
20208e8: 40 00 6a 4e call 203b220 <putchar> <== NOT EXECUTED
20208ec: 90 10 20 20 mov 0x20, %o0 <== NOT EXECUTED
printf ("%02x ", *data);
20208f0: d2 0f 00 1d ldub [ %i4 + %i5 ], %o1 <== NOT EXECUTED
20208f4: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
20208f8: 40 00 69 e0 call 203b078 <printf> <== NOT EXECUTED
20208fc: 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);
2020900: c2 06 20 08 ld [ %i0 + 8 ], %g1 <== NOT EXECUTED
2020904: 80 a7 40 01 cmp %i5, %g1 <== NOT EXECUTED
2020908: 0a bf ff ea bcs 20208b0 <rtems_rfs_shell_block+0x138> <== NOT EXECUTED
202090c: 82 8f 60 0f andcc %i5, 0xf, %g1 <== NOT EXECUTED
if (mod == 8)
printf (" ");
printf ("%02x ", *data);
}
printf ("\n");
2020910: 40 00 6a 44 call 203b220 <putchar> <== NOT EXECUTED
2020914: 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);
2020918: 92 07 bf f4 add %fp, -12, %o1 <== NOT EXECUTED
202091c: 40 00 31 09 call 202cd40 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
2020920: 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);
2020924: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
handle->dirty = false;
2020928: c0 2f bf f4 clrb [ %fp + -12 ] <== NOT EXECUTED
handle->bnum = 0;
202092c: c0 27 bf f8 clr [ %fp + -8 ] <== NOT EXECUTED
handle->buffer = NULL;
2020930: c0 27 bf fc clr [ %fp + -4 ] <== NOT EXECUTED
2020934: 7f ff fc b9 call 201fc18 <rtems_rfs_rtems_unlock> <== NOT EXECUTED
2020938: b0 10 20 00 clr %i0 <== NOT EXECUTED
}
rtems_rfs_shell_unlock_rfs (fs);
return 0;
}
202093c: 81 c7 e0 08 ret <== NOT EXECUTED
2020940: 81 e8 00 00 restore <== NOT EXECUTED
02020294 <rtems_rfs_shell_data>:
return rc;
}
static int
rtems_rfs_shell_data (rtems_rfs_file_system* fs, int argc, char *argv[])
{
2020294: 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");
2020298: 11 00 81 5d sethi %hi(0x2057400), %o0 <== NOT EXECUTED
202029c: 40 00 6c 0f call 203b2d8 <puts> <== NOT EXECUTED
20202a0: 90 12 21 38 or %o0, 0x138, %o0 ! 2057538 <rtems_rtc_shell_usage+0x1058><== NOT EXECUTED
printf (" flags: %08" PRIx32 "\n", fs->flags);
20202a4: d2 06 00 00 ld [ %i0 ], %o1 <== NOT EXECUTED
20202a8: 11 00 81 5d sethi %hi(0x2057400), %o0 <== NOT EXECUTED
20202ac: 40 00 6b 73 call 203b078 <printf> <== NOT EXECUTED
20202b0: 90 12 21 50 or %o0, 0x150, %o0 ! 2057550 <rtems_rtc_shell_usage+0x1070><== NOT EXECUTED
#if 0
printf (" device: %08lx\n", rtems_rfs_fs_device (fs));
#endif
printf (" blocks: %zu\n", rtems_rfs_fs_blocks (fs));
20202b4: d2 06 20 04 ld [ %i0 + 4 ], %o1 <== NOT EXECUTED
20202b8: 11 00 81 5d sethi %hi(0x2057400), %o0 <== NOT EXECUTED
20202bc: 40 00 6b 6f call 203b078 <printf> <== NOT EXECUTED
20202c0: 90 12 21 70 or %o0, 0x170, %o0 ! 2057570 <rtems_rtc_shell_usage+0x1090><== NOT EXECUTED
printf (" block size: %zu\n", rtems_rfs_fs_block_size (fs));
20202c4: d2 06 20 08 ld [ %i0 + 8 ], %o1 <== NOT EXECUTED
20202c8: 11 00 81 5d sethi %hi(0x2057400), %o0 <== NOT EXECUTED
20202cc: 40 00 6b 6b call 203b078 <printf> <== NOT EXECUTED
20202d0: 90 12 21 90 or %o0, 0x190, %o0 ! 2057590 <rtems_rtc_shell_usage+0x10b0><== NOT EXECUTED
printf (" size: %" PRIu64 "\n", rtems_rfs_fs_size (fs));
20202d4: 40 00 34 ce call 202d60c <rtems_rfs_fs_size> <== NOT EXECUTED
20202d8: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
20202dc: 84 10 00 08 mov %o0, %g2 <== NOT EXECUTED
20202e0: 86 10 00 09 mov %o1, %g3 <== NOT EXECUTED
20202e4: 11 00 81 5d sethi %hi(0x2057400), %o0 <== NOT EXECUTED
20202e8: 92 10 00 02 mov %g2, %o1 <== NOT EXECUTED
20202ec: 94 10 00 03 mov %g3, %o2 <== NOT EXECUTED
20202f0: 40 00 6b 62 call 203b078 <printf> <== NOT EXECUTED
20202f4: 90 12 21 b0 or %o0, 0x1b0, %o0 <== NOT EXECUTED
printf (" media block size: %" PRIu32 "\n", rtems_rfs_fs_media_block_size (fs));
20202f8: c2 06 20 10 ld [ %i0 + 0x10 ], %g1 <== NOT EXECUTED
20202fc: 11 00 81 5d sethi %hi(0x2057400), %o0 <== NOT EXECUTED
2020300: d2 00 60 20 ld [ %g1 + 0x20 ], %o1 <== NOT EXECUTED
2020304: 40 00 6b 5d call 203b078 <printf> <== NOT EXECUTED
2020308: 90 12 21 d0 or %o0, 0x1d0, %o0 <== NOT EXECUTED
printf (" media size: %" PRIu64 "\n", rtems_rfs_fs_media_size (fs));
202030c: 40 00 34 c9 call 202d630 <rtems_rfs_fs_media_size> <== NOT EXECUTED
2020310: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
2020314: 84 10 00 08 mov %o0, %g2 <== NOT EXECUTED
2020318: 86 10 00 09 mov %o1, %g3 <== NOT EXECUTED
202031c: 11 00 81 5d sethi %hi(0x2057400), %o0 <== NOT EXECUTED
2020320: 92 10 00 02 mov %g2, %o1 <== NOT EXECUTED
2020324: 94 10 00 03 mov %g3, %o2 <== NOT EXECUTED
2020328: 40 00 6b 54 call 203b078 <printf> <== NOT EXECUTED
202032c: 90 12 21 f0 or %o0, 0x1f0, %o0 <== NOT EXECUTED
printf (" inodes: %" PRIu32 "\n", rtems_rfs_fs_inodes (fs));
2020330: d2 06 20 14 ld [ %i0 + 0x14 ], %o1 <== NOT EXECUTED
2020334: 11 00 81 5d sethi %hi(0x2057400), %o0 <== NOT EXECUTED
2020338: 40 00 6b 50 call 203b078 <printf> <== NOT EXECUTED
202033c: 90 12 22 10 or %o0, 0x210, %o0 ! 2057610 <rtems_rtc_shell_usage+0x1130><== NOT EXECUTED
printf (" bad blocks: %" PRIu32 "\n", fs->bad_blocks);
2020340: d2 06 20 18 ld [ %i0 + 0x18 ], %o1 <== NOT EXECUTED
2020344: 11 00 81 5d sethi %hi(0x2057400), %o0 <== NOT EXECUTED
2020348: 40 00 6b 4c call 203b078 <printf> <== NOT EXECUTED
202034c: 90 12 22 30 or %o0, 0x230, %o0 ! 2057630 <rtems_rtc_shell_usage+0x1150><== NOT EXECUTED
printf (" max. name length: %" PRIu32 "\n", rtems_rfs_fs_max_name (fs));
2020350: d2 06 20 1c ld [ %i0 + 0x1c ], %o1 <== NOT EXECUTED
2020354: 11 00 81 5d sethi %hi(0x2057400), %o0 <== NOT EXECUTED
2020358: 40 00 6b 48 call 203b078 <printf> <== NOT EXECUTED
202035c: 90 12 22 50 or %o0, 0x250, %o0 ! 2057650 <rtems_rtc_shell_usage+0x1170><== NOT EXECUTED
printf (" groups: %d\n", fs->group_count);
2020360: d2 06 20 24 ld [ %i0 + 0x24 ], %o1 <== NOT EXECUTED
2020364: 11 00 81 5d sethi %hi(0x2057400), %o0 <== NOT EXECUTED
2020368: 40 00 6b 44 call 203b078 <printf> <== NOT EXECUTED
202036c: 90 12 22 70 or %o0, 0x270, %o0 ! 2057670 <rtems_rtc_shell_usage+0x1190><== NOT EXECUTED
printf (" group blocks: %zd\n", fs->group_blocks);
2020370: d2 06 20 28 ld [ %i0 + 0x28 ], %o1 <== NOT EXECUTED
2020374: 11 00 81 5d sethi %hi(0x2057400), %o0 <== NOT EXECUTED
2020378: 40 00 6b 40 call 203b078 <printf> <== NOT EXECUTED
202037c: 90 12 22 88 or %o0, 0x288, %o0 ! 2057688 <rtems_rtc_shell_usage+0x11a8><== NOT EXECUTED
printf (" group inodes: %zd\n", fs->group_inodes);
2020380: d2 06 20 2c ld [ %i0 + 0x2c ], %o1 <== NOT EXECUTED
2020384: 11 00 81 5d sethi %hi(0x2057400), %o0 <== NOT EXECUTED
2020388: 40 00 6b 3c call 203b078 <printf> <== NOT EXECUTED
202038c: 90 12 22 a8 or %o0, 0x2a8, %o0 ! 20576a8 <rtems_rtc_shell_usage+0x11c8><== NOT EXECUTED
printf (" inodes per block: %zd\n", fs->inodes_per_block);
2020390: d2 06 20 30 ld [ %i0 + 0x30 ], %o1 <== NOT EXECUTED
2020394: 11 00 81 5d sethi %hi(0x2057400), %o0 <== NOT EXECUTED
2020398: 40 00 6b 38 call 203b078 <printf> <== NOT EXECUTED
202039c: 90 12 22 c8 or %o0, 0x2c8, %o0 ! 20576c8 <rtems_rtc_shell_usage+0x11e8><== NOT EXECUTED
printf (" blocks per block: %zd\n", fs->blocks_per_block);
20203a0: d2 06 20 34 ld [ %i0 + 0x34 ], %o1 <== NOT EXECUTED
20203a4: 11 00 81 5d sethi %hi(0x2057400), %o0 <== NOT EXECUTED
20203a8: 40 00 6b 34 call 203b078 <printf> <== NOT EXECUTED
20203ac: 90 12 22 e8 or %o0, 0x2e8, %o0 ! 20576e8 <rtems_rtc_shell_usage+0x1208><== NOT EXECUTED
printf (" singly blocks: %zd\n", fs->block_map_singly_blocks);
20203b0: d2 06 20 38 ld [ %i0 + 0x38 ], %o1 <== NOT EXECUTED
20203b4: 11 00 81 5d sethi %hi(0x2057400), %o0 <== NOT EXECUTED
20203b8: 40 00 6b 30 call 203b078 <printf> <== NOT EXECUTED
20203bc: 90 12 23 08 or %o0, 0x308, %o0 ! 2057708 <rtems_rtc_shell_usage+0x1228><== NOT EXECUTED
printf (" doublly blocks: %zd\n", fs->block_map_doubly_blocks);
20203c0: d2 06 20 3c ld [ %i0 + 0x3c ], %o1 <== NOT EXECUTED
20203c4: 11 00 81 5d sethi %hi(0x2057400), %o0 <== NOT EXECUTED
20203c8: 40 00 6b 2c call 203b078 <printf> <== NOT EXECUTED
20203cc: 90 12 23 28 or %o0, 0x328, %o0 ! 2057728 <rtems_rtc_shell_usage+0x1248><== NOT EXECUTED
printf (" max. held buffers: %" PRId32 "\n", fs->max_held_buffers);
20203d0: d2 06 20 40 ld [ %i0 + 0x40 ], %o1 <== NOT EXECUTED
20203d4: 11 00 81 5d sethi %hi(0x2057400), %o0 <== NOT EXECUTED
20203d8: 40 00 6b 28 call 203b078 <printf> <== NOT EXECUTED
20203dc: 90 12 23 48 or %o0, 0x348, %o0 ! 2057748 <rtems_rtc_shell_usage+0x1268><== NOT EXECUTED
*/
static void
rtems_rfs_shell_lock_rfs (rtems_rfs_file_system* fs)
{
#if __rtems__
rtems_rfs_rtems_lock (fs);
20203e0: 7f ff fd f9 call 201fbc4 <rtems_rfs_rtems_lock> <== NOT EXECUTED
20203e4: 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);
20203e8: 94 07 bf fc add %fp, -4, %o2 <== NOT EXECUTED
20203ec: 92 07 bf f8 add %fp, -8, %o1 <== NOT EXECUTED
20203f0: 40 00 3b a2 call 202f278 <rtems_rfs_group_usage> <== NOT EXECUTED
20203f4: 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);
20203f8: 7f ff fe 08 call 201fc18 <rtems_rfs_rtems_unlock> <== NOT EXECUTED
20203fc: 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);
2020400: fa 07 bf f8 ld [ %fp + -8 ], %i5 <== NOT EXECUTED
2020404: d2 06 20 04 ld [ %i0 + 4 ], %o1 <== NOT EXECUTED
2020408: 83 2f 60 02 sll %i5, 2, %g1 <== NOT EXECUTED
202040c: 91 2f 60 07 sll %i5, 7, %o0 <== NOT EXECUTED
2020410: 90 22 00 01 sub %o0, %g1, %o0 <== NOT EXECUTED
2020414: 90 02 00 1d add %o0, %i5, %o0 <== NOT EXECUTED
2020418: 40 00 bd f8 call 204fbf8 <.udiv> <== NOT EXECUTED
202041c: 91 2a 20 03 sll %o0, 3, %o0 <== NOT EXECUTED
ipcent = (inodes * 1000) / rtems_rfs_fs_inodes (fs);
2020420: c2 07 bf fc ld [ %fp + -4 ], %g1 <== NOT EXECUTED
2020424: d2 06 20 14 ld [ %i0 + 0x14 ], %o1 <== NOT EXECUTED
2020428: 85 28 60 02 sll %g1, 2, %g2 <== NOT EXECUTED
202042c: 87 28 60 07 sll %g1, 7, %g3 <== NOT EXECUTED
2020430: 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);
2020434: b6 10 00 08 mov %o0, %i3 <== NOT EXECUTED
ipcent = (inodes * 1000) / rtems_rfs_fs_inodes (fs);
2020438: 90 00 80 01 add %g2, %g1, %o0 <== NOT EXECUTED
202043c: 40 00 bd ef call 204fbf8 <.udiv> <== NOT EXECUTED
2020440: 91 2a 20 03 sll %o0, 3, %o0 <== NOT EXECUTED
printf (" blocks used: %zd (%d.%d%%)\n",
2020444: 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);
2020448: b8 10 00 08 mov %o0, %i4 <== NOT EXECUTED
printf (" blocks used: %zd (%d.%d%%)\n",
202044c: 40 00 bd ed call 204fc00 <.div> <== NOT EXECUTED
2020450: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
2020454: 92 10 20 0a mov 0xa, %o1 <== NOT EXECUTED
2020458: b4 10 00 08 mov %o0, %i2 <== NOT EXECUTED
202045c: 40 00 be 95 call 204feb0 <.rem> <== NOT EXECUTED
2020460: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
2020464: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED
2020468: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
202046c: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
2020470: 11 00 81 5d sethi %hi(0x2057400), %o0 <== NOT EXECUTED
2020474: 40 00 6b 01 call 203b078 <printf> <== NOT EXECUTED
2020478: 90 12 23 68 or %o0, 0x368, %o0 ! 2057768 <rtems_rtc_shell_usage+0x1288><== NOT EXECUTED
blocks, bpcent / 10, bpcent % 10);
printf (" inodes used: %zd (%d.%d%%)\n",
202047c: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
2020480: f6 07 bf fc ld [ %fp + -4 ], %i3 <== NOT EXECUTED
2020484: 40 00 bd df call 204fc00 <.div> <== NOT EXECUTED
2020488: 92 10 20 0a mov 0xa, %o1 <== NOT EXECUTED
202048c: 92 10 20 0a mov 0xa, %o1 <== NOT EXECUTED
2020490: ba 10 00 08 mov %o0, %i5 <== NOT EXECUTED
2020494: 40 00 be 87 call 204feb0 <.rem> <== NOT EXECUTED
2020498: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
202049c: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
20204a0: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
20204a4: 94 10 00 1d mov %i5, %o2 <== NOT EXECUTED
20204a8: 11 00 81 5d sethi %hi(0x2057400), %o0 <== NOT EXECUTED
inodes, ipcent / 10, ipcent % 10);
return 0;
}
20204ac: 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",
20204b0: 40 00 6a f2 call 203b078 <printf> <== NOT EXECUTED
20204b4: 90 12 23 90 or %o0, 0x390, %o0 <== NOT EXECUTED
inodes, ipcent / 10, ipcent % 10);
return 0;
}
20204b8: 81 c7 e0 08 ret <== NOT EXECUTED
20204bc: 81 e8 00 00 restore <== NOT EXECUTED
020204c0 <rtems_rfs_shell_dir>:
return 0;
}
static int
rtems_rfs_shell_dir (rtems_rfs_file_system* fs, int argc, char *argv[])
{
20204c0: 9d e3 bf 90 save %sp, -112, %sp <== NOT EXECUTED
bool state;
int entry;
int b;
int rc;
if (argc <= 1)
20204c4: 80 a6 60 01 cmp %i1, 1 <== NOT EXECUTED
20204c8: 34 80 00 07 bg,a 20204e4 <rtems_rfs_shell_dir+0x24> <== NOT EXECUTED
20204cc: d0 06 a0 04 ld [ %i2 + 4 ], %o0 <== NOT EXECUTED
{
printf ("error: no block number provided\n");
20204d0: 11 00 81 5d sethi %hi(0x2057400), %o0 <== NOT EXECUTED
20204d4: 40 00 6b 81 call 203b2d8 <puts> <== NOT EXECUTED
20204d8: 90 12 23 c8 or %o0, 0x3c8, %o0 ! 20577c8 <rtems_rtc_shell_usage+0x12e8><== 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;
20204dc: 81 c7 e0 08 ret <== NOT EXECUTED
20204e0: 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);
20204e4: 92 10 20 00 clr %o1 <== NOT EXECUTED
20204e8: 40 00 7a df call 203f064 <strtoul> <== NOT EXECUTED
20204ec: 94 10 20 00 clr %o2 <== NOT EXECUTED
20204f0: 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);
20204f4: 7f ff fd b4 call 201fbc4 <rtems_rfs_rtems_lock> <== NOT EXECUTED
20204f8: 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);
20204fc: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
2020500: 92 10 20 00 clr %o1 <== NOT EXECUTED
2020504: 94 10 00 1d mov %i5, %o2 <== NOT EXECUTED
2020508: 40 00 3b 1f call 202f184 <rtems_rfs_group_bitmap_test> <== NOT EXECUTED
202050c: 96 07 bf f3 add %fp, -13, %o3 <== NOT EXECUTED
if (rc > 0)
2020510: b8 92 20 00 orcc %o0, 0, %i4 <== NOT EXECUTED
2020514: 04 80 00 0a ble 202053c <rtems_rfs_shell_dir+0x7c> <== NOT EXECUTED
2020518: 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);
202051c: 7f ff fd bf call 201fc18 <rtems_rfs_rtems_unlock> <== NOT EXECUTED
2020520: 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",
2020524: 40 00 74 54 call 203d674 <strerror> <== NOT EXECUTED
2020528: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
202052c: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
2020530: 11 00 81 5d sethi %hi(0x2057400), %o0 <== NOT EXECUTED
2020534: 10 80 00 25 b 20205c8 <rtems_rfs_shell_dir+0x108> <== NOT EXECUTED
2020538: 90 12 23 e8 or %o0, 0x3e8, %o0 ! 20577e8 <rtems_rtc_shell_usage+0x1308><== NOT EXECUTED
block, rc, strerror (rc));
return 1;
}
printf (" %5" PRIu32 ": block %s\n", block, state ? "allocated" : "free");
202053c: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
2020540: 22 80 00 05 be,a 2020554 <rtems_rfs_shell_dir+0x94> <== NOT EXECUTED
2020544: 15 00 81 54 sethi %hi(0x2055000), %o2 <== NOT EXECUTED
2020548: 15 00 81 5d sethi %hi(0x2057400), %o2 <== NOT EXECUTED
202054c: 10 80 00 03 b 2020558 <rtems_rfs_shell_dir+0x98> <== NOT EXECUTED
2020550: 94 12 a3 b8 or %o2, 0x3b8, %o2 ! 20577b8 <rtems_rtc_shell_usage+0x12d8><== NOT EXECUTED
2020554: 94 12 a3 88 or %o2, 0x388, %o2 <== NOT EXECUTED
2020558: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
202055c: 11 00 81 5e sethi %hi(0x2057800), %o0 <== NOT EXECUTED
2020560: 40 00 6a c6 call 203b078 <printf> <== NOT EXECUTED
2020564: 90 12 20 18 or %o0, 0x18, %o0 ! 2057818 <rtems_rtc_shell_usage+0x1338><== 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);
2020568: 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;
202056c: c0 2f bf f4 clrb [ %fp + -12 ] <== NOT EXECUTED
handle->bnum = 0;
2020570: c0 27 bf f8 clr [ %fp + -8 ] <== NOT EXECUTED
handle->buffer = NULL;
2020574: c0 27 bf fc clr [ %fp + -4 ] <== NOT EXECUTED
2020578: 92 07 bf f4 add %fp, -12, %o1 <== NOT EXECUTED
202057c: 94 10 00 1d mov %i5, %o2 <== NOT EXECUTED
2020580: 40 00 32 64 call 202cf10 <rtems_rfs_buffer_handle_request><== NOT EXECUTED
2020584: 96 10 20 01 mov 1, %o3 <== NOT EXECUTED
if (rc > 0)
2020588: b8 92 20 00 orcc %o0, 0, %i4 <== NOT EXECUTED
202058c: 04 80 00 14 ble 20205dc <rtems_rfs_shell_dir+0x11c> <== NOT EXECUTED
2020590: 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);
2020594: 92 07 bf f4 add %fp, -12, %o1 <== NOT EXECUTED
2020598: 40 00 31 ea call 202cd40 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
202059c: 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);
20205a0: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
handle->dirty = false;
20205a4: c0 2f bf f4 clrb [ %fp + -12 ] <== NOT EXECUTED
handle->bnum = 0;
20205a8: c0 27 bf f8 clr [ %fp + -8 ] <== NOT EXECUTED
20205ac: 7f ff fd 9b call 201fc18 <rtems_rfs_rtems_unlock> <== NOT EXECUTED
20205b0: 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",
20205b4: 40 00 74 30 call 203d674 <strerror> <== NOT EXECUTED
20205b8: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
20205bc: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
20205c0: 11 00 81 5e sethi %hi(0x2057800), %o0 <== NOT EXECUTED
20205c4: 90 12 20 30 or %o0, 0x30, %o0 ! 2057830 <rtems_rtc_shell_usage+0x1350><== NOT EXECUTED
20205c8: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
20205cc: 40 00 6a ab call 203b078 <printf> <== NOT EXECUTED
20205d0: 94 10 00 1c mov %i4, %o2 <== NOT EXECUTED
block, rc, strerror (rc));
return 1;
20205d4: 81 c7 e0 08 ret <== NOT EXECUTED
20205d8: 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)
20205dc: 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]=",
20205e0: 27 00 81 5e sethi %hi(0x2057800), %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 ("...");
20205e4: 29 00 81 5e sethi %hi(0x2057800), %l4 <== NOT EXECUTED
return 1;
}
b = 0;
entry = 1;
data = rtems_rfs_buffer_data (&buffer);
20205e8: 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;
20205ec: b4 10 20 00 clr %i2 <== NOT EXECUTED
entry = 1;
20205f0: 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)
20205f4: 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]=",
20205f8: a6 14 e0 c0 or %l3, 0xc0, %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))
20205fc: 10 80 00 4f b 2020738 <rtems_rfs_shell_dir+0x278> <== NOT EXECUTED
2020600: a8 15 20 f0 or %l4, 0xf0, %l4 <== NOT EXECUTED
rtems_rfs_ino eino;
int elength;
int length;
int c;
eino = rtems_rfs_dir_entry_ino (data);
2020604: d6 0f 40 00 ldub [ %i5 ], %o3 <== NOT EXECUTED
2020608: 83 28 60 10 sll %g1, 0x10, %g1 <== NOT EXECUTED
202060c: 97 2a e0 18 sll %o3, 0x18, %o3 <== NOT EXECUTED
2020610: 96 12 c0 01 or %o3, %g1, %o3 <== NOT EXECUTED
2020614: c2 0f 60 03 ldub [ %i5 + 3 ], %g1 <== NOT EXECUTED
elength = rtems_rfs_dir_entry_length (data);
2020618: 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);
202061c: 96 12 c0 01 or %o3, %g1, %o3 <== NOT EXECUTED
2020620: c2 0f 60 02 ldub [ %i5 + 2 ], %g1 <== NOT EXECUTED
elength = rtems_rfs_dir_entry_length (data);
2020624: 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);
2020628: 83 28 60 08 sll %g1, 8, %g1 <== NOT EXECUTED
202062c: 96 12 c0 01 or %o3, %g1, %o3 <== NOT EXECUTED
elength = rtems_rfs_dir_entry_length (data);
2020630: c2 0f 60 09 ldub [ %i5 + 9 ], %g1 <== NOT EXECUTED
2020634: b8 17 00 01 or %i4, %g1, %i4 <== NOT EXECUTED
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
2020638: 80 a7 00 12 cmp %i4, %l2 <== NOT EXECUTED
202063c: 02 80 00 44 be 202074c <rtems_rfs_shell_dir+0x28c> <== NOT EXECUTED
2020640: 80 a7 20 09 cmp %i4, 9 <== NOT EXECUTED
break;
if ((elength < RTEMS_RFS_DIR_ENTRY_SIZE) ||
2020644: 34 80 00 07 bg,a 2020660 <rtems_rfs_shell_dir+0x1a0> <== NOT EXECUTED
2020648: 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);
202064c: 11 00 81 5e sethi %hi(0x2057800), %o0 <== NOT EXECUTED
2020650: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
2020654: 90 12 20 68 or %o0, 0x68, %o0 <== NOT EXECUTED
2020658: 10 80 00 0f b 2020694 <rtems_rfs_shell_dir+0x1d4> <== NOT EXECUTED
202065c: 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) ||
2020660: 80 a7 00 01 cmp %i4, %g1 <== NOT EXECUTED
2020664: 1a bf ff fa bcc 202064c <rtems_rfs_shell_dir+0x18c> <== NOT EXECUTED
2020668: 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)))
202066c: 02 80 00 07 be 2020688 <rtems_rfs_shell_dir+0x1c8> <== NOT EXECUTED
2020670: 11 00 81 5e sethi %hi(0x2057800), %o0 <== NOT EXECUTED
2020674: c2 06 20 14 ld [ %i0 + 0x14 ], %g1 <== NOT EXECUTED
2020678: 80 a2 c0 01 cmp %o3, %g1 <== NOT EXECUTED
202067c: 2a 80 00 0a bcs,a 20206a4 <rtems_rfs_shell_dir+0x1e4> <== NOT EXECUTED
2020680: c2 0f 60 05 ldub [ %i5 + 5 ], %g1 <== NOT EXECUTED
{
printf (" %5d: entry ino appears corrupt: ino=%" PRId32 "\n", entry, eino);
2020684: 11 00 81 5e sethi %hi(0x2057800), %o0 <== NOT EXECUTED
2020688: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
202068c: 90 12 20 90 or %o0, 0x90, %o0 <== NOT EXECUTED
2020690: 94 10 00 0b mov %o3, %o2 <== NOT EXECUTED
2020694: 40 00 6a 79 call 203b078 <printf> <== NOT EXECUTED
2020698: 01 00 00 00 nop <== NOT EXECUTED
break;
202069c: 10 80 00 2d b 2020750 <rtems_rfs_shell_dir+0x290> <== NOT EXECUTED
20206a0: 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),
20206a4: d8 0f 60 04 ldub [ %i5 + 4 ], %o4 <== NOT EXECUTED
20206a8: 83 28 60 10 sll %g1, 0x10, %g1 <== NOT EXECUTED
20206ac: 99 2b 20 18 sll %o4, 0x18, %o4 <== NOT EXECUTED
20206b0: 98 13 00 01 or %o4, %g1, %o4 <== NOT EXECUTED
20206b4: 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;
20206b8: 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),
20206bc: 98 13 00 01 or %o4, %g1, %o4 <== NOT EXECUTED
20206c0: 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]=",
20206c4: 90 10 00 13 mov %l3, %o0 <== NOT EXECUTED
entry, b,
rtems_rfs_dir_entry_ino (data),
rtems_rfs_dir_entry_hash (data),
20206c8: 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]=",
20206cc: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
20206d0: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED
20206d4: 98 13 00 01 or %o4, %g1, %o4 <== NOT EXECUTED
20206d8: 40 00 6a 68 call 203b078 <printf> <== NOT EXECUTED
20206dc: 9a 10 00 19 mov %i1, %o5 <== NOT EXECUTED
20206e0: 80 a6 60 32 cmp %i1, 0x32 <== NOT EXECUTED
20206e4: 04 80 00 03 ble 20206f0 <rtems_rfs_shell_dir+0x230> <== NOT EXECUTED
20206e8: a2 10 00 19 mov %i1, %l1 <== NOT EXECUTED
20206ec: a2 10 20 32 mov 0x32, %l1 <== NOT EXECUTED
length);
if (length > 50)
length = 50;
for (c = 0; c < length; c++)
20206f0: 10 80 00 05 b 2020704 <rtems_rfs_shell_dir+0x244> <== NOT EXECUTED
20206f4: a0 10 20 00 clr %l0 <== NOT EXECUTED
printf ("%c", data[RTEMS_RFS_DIR_ENTRY_SIZE + c]);
20206f8: d0 08 60 0a ldub [ %g1 + 0xa ], %o0 <== NOT EXECUTED
20206fc: 40 00 6a c9 call 203b220 <putchar> <== NOT EXECUTED
2020700: a0 04 20 01 inc %l0 <== NOT EXECUTED
length);
if (length > 50)
length = 50;
for (c = 0; c < length; c++)
2020704: 80 a4 00 11 cmp %l0, %l1 <== NOT EXECUTED
2020708: 06 bf ff fc bl 20206f8 <rtems_rfs_shell_dir+0x238> <== NOT EXECUTED
202070c: 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)
2020710: 80 a4 40 19 cmp %l1, %i1 <== NOT EXECUTED
2020714: 16 80 00 05 bge 2020728 <rtems_rfs_shell_dir+0x268> <== NOT EXECUTED
2020718: 90 10 20 0a mov 0xa, %o0 <== NOT EXECUTED
printf ("...");
202071c: 40 00 6a 57 call 203b078 <printf> <== NOT EXECUTED
2020720: 90 10 00 14 mov %l4, %o0 <== NOT EXECUTED
printf ("\n");
2020724: 90 10 20 0a mov 0xa, %o0 <== NOT EXECUTED
2020728: 40 00 6a be call 203b220 <putchar> <== NOT EXECUTED
202072c: b4 06 80 1c add %i2, %i4, %i2 <== NOT EXECUTED
b += elength;
data += elength;
2020730: ba 07 40 1c add %i5, %i4, %i5 <== NOT EXECUTED
entry++;
2020734: 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))
2020738: c2 06 20 08 ld [ %i0 + 8 ], %g1 <== NOT EXECUTED
202073c: 82 00 7f f5 add %g1, -11, %g1 <== NOT EXECUTED
2020740: 80 a6 80 01 cmp %i2, %g1 <== NOT EXECUTED
2020744: 2a bf ff b0 bcs,a 2020604 <rtems_rfs_shell_dir+0x144> <== NOT EXECUTED
2020748: 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);
202074c: 92 07 bf f4 add %fp, -12, %o1 <== NOT EXECUTED
2020750: 40 00 31 7c call 202cd40 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
2020754: 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);
2020758: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
handle->dirty = false;
202075c: c0 2f bf f4 clrb [ %fp + -12 ] <== NOT EXECUTED
handle->bnum = 0;
2020760: c0 27 bf f8 clr [ %fp + -8 ] <== NOT EXECUTED
handle->buffer = NULL;
2020764: c0 27 bf fc clr [ %fp + -4 ] <== NOT EXECUTED
2020768: 7f ff fd 2c call 201fc18 <rtems_rfs_rtems_unlock> <== NOT EXECUTED
202076c: b0 10 20 00 clr %i0 <== NOT EXECUTED
}
rtems_rfs_shell_unlock_rfs (fs);
return 0;
}
2020770: 81 c7 e0 08 ret <== NOT EXECUTED
2020774: 81 e8 00 00 restore <== NOT EXECUTED
020200f8 <rtems_rfs_shell_group>:
return 0;
}
static int
rtems_rfs_shell_group (rtems_rfs_file_system* fs, int argc, char *argv[])
{
20200f8: 9d e3 bf 98 save %sp, -104, %sp <== NOT EXECUTED
int g;
start = 0;
end = fs->group_count - 1;
switch (argc)
20200fc: 80 a6 60 02 cmp %i1, 2 <== NOT EXECUTED
2020100: 02 80 00 09 be 2020124 <rtems_rfs_shell_group+0x2c> <== NOT EXECUTED
2020104: f8 06 20 24 ld [ %i0 + 0x24 ], %i4 <== NOT EXECUTED
2020108: 80 a6 60 03 cmp %i1, 3 <== NOT EXECUTED
202010c: 02 80 00 0d be 2020140 <rtems_rfs_shell_group+0x48> <== NOT EXECUTED
2020110: 80 a6 60 01 cmp %i1, 1 <== NOT EXECUTED
2020114: 12 80 00 16 bne 202016c <rtems_rfs_shell_group+0x74> <== NOT EXECUTED
2020118: 11 00 81 5d sethi %hi(0x2057400), %o0 <== NOT EXECUTED
int start;
int end;
int g;
start = 0;
end = fs->group_count - 1;
202011c: 10 80 00 18 b 202017c <rtems_rfs_shell_group+0x84> <== NOT EXECUTED
2020120: b8 07 3f ff add %i4, -1, %i4 <== NOT EXECUTED
switch (argc)
{
case 1:
break;
case 2:
start = end = strtoul (argv[1], 0, 0);
2020124: d0 06 a0 04 ld [ %i2 + 4 ], %o0 <== NOT EXECUTED
2020128: 92 10 20 00 clr %o1 <== NOT EXECUTED
202012c: 40 00 7b ce call 203f064 <strtoul> <== NOT EXECUTED
2020130: 94 10 20 00 clr %o2 <== NOT EXECUTED
2020134: b8 10 00 08 mov %o0, %i4 <== NOT EXECUTED
break;
2020138: 10 80 00 12 b 2020180 <rtems_rfs_shell_group+0x88> <== NOT EXECUTED
202013c: ba 10 00 08 mov %o0, %i5 <== NOT EXECUTED
case 3:
start = strtoul (argv[1], 0, 0);
2020140: d0 06 a0 04 ld [ %i2 + 4 ], %o0 <== NOT EXECUTED
2020144: 92 10 20 00 clr %o1 <== NOT EXECUTED
2020148: 40 00 7b c7 call 203f064 <strtoul> <== NOT EXECUTED
202014c: 94 10 20 00 clr %o2 <== NOT EXECUTED
2020150: ba 10 00 08 mov %o0, %i5 <== NOT EXECUTED
end = strtoul (argv[2], 0, 0);
2020154: d0 06 a0 08 ld [ %i2 + 8 ], %o0 <== NOT EXECUTED
2020158: 92 10 20 00 clr %o1 <== NOT EXECUTED
202015c: 40 00 7b c2 call 203f064 <strtoul> <== NOT EXECUTED
2020160: 94 10 20 00 clr %o2 <== NOT EXECUTED
break;
2020164: 10 80 00 07 b 2020180 <rtems_rfs_shell_group+0x88> <== NOT EXECUTED
2020168: b8 10 00 08 mov %o0, %i4 <== NOT EXECUTED
default:
printf ("error: too many arguments.\n");
202016c: 40 00 6c 5b call 203b2d8 <puts> <== NOT EXECUTED
2020170: 90 12 20 a8 or %o0, 0xa8, %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;
2020174: 81 c7 e0 08 ret <== NOT EXECUTED
2020178: 91 e8 20 01 restore %g0, 1, %o0 <== NOT EXECUTED
{
int start;
int end;
int g;
start = 0;
202017c: ba 10 20 00 clr %i5 <== NOT EXECUTED
default:
printf ("error: too many arguments.\n");
return 1;
}
if ((start < 0) || (end < 0) ||
2020180: 80 a7 20 00 cmp %i4, 0 <== NOT EXECUTED
2020184: 06 80 00 0a bl 20201ac <rtems_rfs_shell_group+0xb4> <== NOT EXECUTED
2020188: 80 a7 60 00 cmp %i5, 0 <== NOT EXECUTED
202018c: 26 80 00 09 bl,a 20201b0 <rtems_rfs_shell_group+0xb8> <== NOT EXECUTED
2020190: d2 06 20 24 ld [ %i0 + 0x24 ], %o1 <== NOT EXECUTED
(start >= fs->group_count) || (end >= fs->group_count))
2020194: c2 06 20 24 ld [ %i0 + 0x24 ], %g1 <== NOT EXECUTED
default:
printf ("error: too many arguments.\n");
return 1;
}
if ((start < 0) || (end < 0) ||
2020198: 80 a7 40 01 cmp %i5, %g1 <== NOT EXECUTED
202019c: 16 80 00 04 bge 20201ac <rtems_rfs_shell_group+0xb4> <== NOT EXECUTED
20201a0: 80 a7 00 01 cmp %i4, %g1 <== NOT EXECUTED
(start >= fs->group_count) || (end >= fs->group_count))
20201a4: 06 80 00 08 bl 20201c4 <rtems_rfs_shell_group+0xcc> <== NOT EXECUTED
20201a8: 01 00 00 00 nop <== NOT EXECUTED
{
printf ("error: group out of range (0->%d).\n", fs->group_count);
20201ac: d2 06 20 24 ld [ %i0 + 0x24 ], %o1 <== NOT EXECUTED
20201b0: 11 00 81 5d sethi %hi(0x2057400), %o0 <== NOT EXECUTED
20201b4: 40 00 6b b1 call 203b078 <printf> <== NOT EXECUTED
20201b8: 90 12 20 c8 or %o0, 0xc8, %o0 ! 20574c8 <rtems_rtc_shell_usage+0xfe8><== NOT EXECUTED
return 1;
20201bc: 81 c7 e0 08 ret <== NOT EXECUTED
20201c0: 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);
20201c4: 7f ff fe 80 call 201fbc4 <rtems_rfs_rtems_lock> <== NOT EXECUTED
20201c8: 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[])
20201cc: a7 2f 60 04 sll %i5, 4, %l3 <== NOT EXECUTED
20201d0: 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",
20201d4: 25 00 81 5d sethi %hi(0x2057400), %l2 <== NOT EXECUTED
return 0;
}
static int
rtems_rfs_shell_group (rtems_rfs_file_system* fs, int argc, char *argv[])
20201d8: a6 04 c0 01 add %l3, %g1, %l3 <== NOT EXECUTED
return 1;
}
rtems_rfs_shell_lock_rfs (fs);
for (g = start; g <= end; g++)
20201dc: b6 10 20 00 clr %i3 <== NOT EXECUTED
20201e0: 10 80 00 25 b 2020274 <rtems_rfs_shell_group+0x17c> <== NOT EXECUTED
20201e4: a4 14 a0 f0 or %l2, 0xf0, %l2 <== NOT EXECUTED
return 0;
}
static int
rtems_rfs_shell_group (rtems_rfs_file_system* fs, int argc, char *argv[])
20201e8: 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];
20201ec: 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);
20201f0: f2 00 60 04 ld [ %g1 + 4 ], %i1 <== NOT EXECUTED
20201f4: 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",
20201f8: 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);
20201fc: e2 06 20 2c ld [ %i0 + 0x2c ], %l1 <== NOT EXECUTED
2020200: 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);
2020204: 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,
2020208: 85 2e a0 02 sll %i2, 2, %g2 <== NOT EXECUTED
202020c: 83 2e a0 04 sll %i2, 4, %g1 <== NOT EXECUTED
2020210: 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",
2020214: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
g, group->base, group->size,
blocks, (blocks * 100) / group->size,
2020218: 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",
202021c: 40 00 be 77 call 204fbf8 <.udiv> <== NOT EXECUTED
2020220: 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);
2020224: 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);
2020228: 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",
202022c: a8 10 00 08 mov %o0, %l4 <== NOT EXECUTED
2020230: e0 23 a0 5c st %l0, [ %sp + 0x5c ] <== NOT EXECUTED
2020234: 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);
2020238: a1 2c 20 04 sll %l0, 4, %l0 <== NOT EXECUTED
202023c: a0 00 40 10 add %g1, %l0, %l0 <== NOT EXECUTED
2020240: 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",
2020244: 40 00 be 6d call 204fbf8 <.udiv> <== NOT EXECUTED
2020248: 90 04 00 08 add %l0, %o0, %o0 <== NOT EXECUTED
202024c: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
2020250: d0 23 a0 60 st %o0, [ %sp + 0x60 ] <== NOT EXECUTED
2020254: 94 10 00 15 mov %l5, %o2 <== NOT EXECUTED
2020258: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED
202025c: 96 10 00 19 mov %i1, %o3 <== NOT EXECUTED
2020260: 98 10 00 1a mov %i2, %o4 <== NOT EXECUTED
2020264: 9a 10 00 14 mov %l4, %o5 <== NOT EXECUTED
2020268: 40 00 6b 84 call 203b078 <printf> <== NOT EXECUTED
202026c: ba 07 60 01 inc %i5 <== NOT EXECUTED
2020270: b6 06 e0 50 add %i3, 0x50, %i3 <== NOT EXECUTED
return 1;
}
rtems_rfs_shell_lock_rfs (fs);
for (g = start; g <= end; g++)
2020274: 80 a7 40 1c cmp %i5, %i4 <== NOT EXECUTED
2020278: 24 bf ff dc ble,a 20201e8 <rtems_rfs_shell_group+0xf0> <== NOT EXECUTED
202027c: 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);
2020280: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
2020284: 7f ff fe 65 call 201fc18 <rtems_rfs_rtems_unlock> <== NOT EXECUTED
2020288: b0 10 20 00 clr %i0 <== NOT EXECUTED
}
rtems_rfs_shell_unlock_rfs (fs);
return 0;
}
202028c: 81 c7 e0 08 ret <== NOT EXECUTED
2020290: 81 e8 00 00 restore <== NOT EXECUTED
0201fc6c <rtems_rfs_shell_inode>:
return 0;
}
static int
rtems_rfs_shell_inode (rtems_rfs_file_system* fs, int argc, char *argv[])
{
201fc6c: 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;
201fc70: d0 06 20 24 ld [ %i0 + 0x24 ], %o0 <== NOT EXECUTED
201fc74: d2 06 20 2c ld [ %i0 + 0x2c ], %o1 <== NOT EXECUTED
201fc78: 40 00 bf a6 call 204fb10 <.umul> <== NOT EXECUTED
201fc7c: 2f 00 81 5c sethi %hi(0x2057000), %l7 <== NOT EXECUTED
show_all = false;
error_check_only = false;
forced = false;
have_start = have_end = false;
for (arg = 1; arg < argc; arg++)
201fc80: 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;
201fc84: 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;
201fc88: a2 10 00 08 mov %o0, %l1 <== NOT EXECUTED
start = RTEMS_RFS_ROOT_INO;
end = total - 1;
201fc8c: b8 10 00 14 mov %l4, %i4 <== NOT EXECUTED
show_all = false;
error_check_only = false;
forced = false;
have_start = have_end = false;
201fc90: ac 10 20 00 clr %l6 <== NOT EXECUTED
201fc94: 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;
201fc98: 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;
201fc9c: 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;
201fca0: 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;
201fca4: 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++)
201fca8: 10 80 00 2e b 201fd60 <rtems_rfs_shell_inode+0xf4> <== NOT EXECUTED
201fcac: ae 15 e3 60 or %l7, 0x360, %l7 <== NOT EXECUTED
{
if (argv[arg][0] == '-')
201fcb0: d2 06 80 01 ld [ %i2 + %g1 ], %o1 <== NOT EXECUTED
201fcb4: c2 4a 40 00 ldsb [ %o1 ], %g1 <== NOT EXECUTED
201fcb8: 80 a0 60 2d cmp %g1, 0x2d <== NOT EXECUTED
201fcbc: 12 80 00 0e bne 201fcf4 <rtems_rfs_shell_inode+0x88> <== NOT EXECUTED
201fcc0: 80 8d a0 ff btst 0xff, %l6 <== NOT EXECUTED
{
switch (argv[arg][1])
201fcc4: c2 4a 60 01 ldsb [ %o1 + 1 ], %g1 <== NOT EXECUTED
201fcc8: 80 a0 60 65 cmp %g1, 0x65 <== NOT EXECUTED
201fccc: 02 80 00 23 be 201fd58 <rtems_rfs_shell_inode+0xec> <== NOT EXECUTED
201fcd0: 80 a0 60 66 cmp %g1, 0x66 <== NOT EXECUTED
201fcd4: 02 80 00 06 be 201fcec <rtems_rfs_shell_inode+0x80> <== NOT EXECUTED
201fcd8: 80 a0 60 61 cmp %g1, 0x61 <== NOT EXECUTED
201fcdc: 12 80 00 0b bne 201fd08 <rtems_rfs_shell_inode+0x9c> <== NOT EXECUTED
201fce0: 01 00 00 00 nop <== NOT EXECUTED
{
case 'a':
show_all = true;
201fce4: 10 80 00 1e b 201fd5c <rtems_rfs_shell_inode+0xf0> <== NOT EXECUTED
201fce8: 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;
201fcec: 10 80 00 1c b 201fd5c <rtems_rfs_shell_inode+0xf0> <== NOT EXECUTED
201fcf0: a6 10 20 01 mov 1, %l3 <== NOT EXECUTED
break;
}
}
else
{
if (have_end && have_start)
201fcf4: 02 80 00 09 be 201fd18 <rtems_rfs_shell_inode+0xac> <== NOT EXECUTED
201fcf8: 82 0d 60 ff and %l5, 0xff, %g1 <== NOT EXECUTED
201fcfc: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
201fd00: 02 80 00 09 be 201fd24 <rtems_rfs_shell_inode+0xb8> <== NOT EXECUTED
201fd04: 90 10 00 09 mov %o1, %o0 <== NOT EXECUTED
printf ("warning: option ignored: %s\n", argv[arg]);
201fd08: 40 00 6c dc call 203b078 <printf> <== NOT EXECUTED
201fd0c: 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++)
201fd10: 10 80 00 14 b 201fd60 <rtems_rfs_shell_inode+0xf4> <== NOT EXECUTED
201fd14: 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)
201fd18: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
201fd1c: 12 80 00 09 bne 201fd40 <rtems_rfs_shell_inode+0xd4> <== NOT EXECUTED
201fd20: 90 10 00 09 mov %o1, %o0 <== NOT EXECUTED
{
start = end = strtoul (argv[arg], 0, 0);
201fd24: 94 10 20 00 clr %o2 <== NOT EXECUTED
201fd28: 92 10 20 00 clr %o1 <== NOT EXECUTED
201fd2c: 40 00 7c ce call 203f064 <strtoul> <== NOT EXECUTED
201fd30: aa 10 20 01 mov 1, %l5 <== NOT EXECUTED
201fd34: ba 10 00 08 mov %o0, %i5 <== NOT EXECUTED
201fd38: 10 80 00 09 b 201fd5c <rtems_rfs_shell_inode+0xf0> <== NOT EXECUTED
201fd3c: b8 10 00 08 mov %o0, %i4 <== NOT EXECUTED
have_start = true;
}
else
{
end = strtoul (argv[arg], 0, 0);
201fd40: 94 10 20 00 clr %o2 <== NOT EXECUTED
201fd44: 92 10 20 00 clr %o1 <== NOT EXECUTED
201fd48: 40 00 7c c7 call 203f064 <strtoul> <== NOT EXECUTED
201fd4c: ac 10 20 01 mov 1, %l6 <== NOT EXECUTED
201fd50: 10 80 00 03 b 201fd5c <rtems_rfs_shell_inode+0xf0> <== NOT EXECUTED
201fd54: b8 10 00 08 mov %o0, %i4 <== NOT EXECUTED
{
case 'a':
show_all = true;
break;
case 'e':
error_check_only = true;
201fd58: 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++)
201fd5c: b6 06 e0 01 inc %i3 <== NOT EXECUTED
201fd60: 80 a6 c0 19 cmp %i3, %i1 <== NOT EXECUTED
201fd64: 06 bf ff d3 bl 201fcb0 <rtems_rfs_shell_inode+0x44> <== NOT EXECUTED
201fd68: 83 2e e0 02 sll %i3, 2, %g1 <== NOT EXECUTED
have_end = true;
}
}
}
if ((start >= total) || (end >= total))
201fd6c: 80 a7 00 11 cmp %i4, %l1 <== NOT EXECUTED
201fd70: 1a 80 00 04 bcc 201fd80 <rtems_rfs_shell_inode+0x114> <== NOT EXECUTED
201fd74: 80 a7 40 11 cmp %i5, %l1 <== NOT EXECUTED
201fd78: 2a 80 00 08 bcs,a 201fd98 <rtems_rfs_shell_inode+0x12c> <== NOT EXECUTED
201fd7c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
{
printf ("error: inode out of range (0->%" PRId32 ").\n", total - 1);
201fd80: 11 00 81 5c sethi %hi(0x2057000), %o0 <== NOT EXECUTED
201fd84: 92 10 00 14 mov %l4, %o1 <== NOT EXECUTED
201fd88: 40 00 6c bc call 203b078 <printf> <== NOT EXECUTED
201fd8c: 90 12 23 80 or %o0, 0x380, %o0 <== NOT EXECUTED
201fd90: 81 c7 e0 08 ret <== NOT EXECUTED
201fd94: 91 e8 20 01 restore %g0, 1, %o0 <== NOT EXECUTED
}
}
if (!error_check_only || error)
{
printf (" %5" PRIu32 ": pos=%06" PRIu32 ":%04zx %c ",
201fd98: 37 00 81 5d sethi %hi(0x2057400), %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)
201fd9c: 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));
201fda0: 33 00 81 5d sethi %hi(0x2057400), %i1 <== NOT EXECUTED
*/
static void
rtems_rfs_shell_lock_rfs (rtems_rfs_file_system* fs)
{
#if __rtems__
rtems_rfs_rtems_lock (fs);
201fda4: 7f ff ff 88 call 201fbc4 <rtems_rfs_rtems_lock> <== NOT EXECUTED
201fda8: a2 1c 20 01 xor %l0, 1, %l1 <== NOT EXECUTED
}
}
if (!error_check_only || error)
{
printf (" %5" PRIu32 ": pos=%06" PRIu32 ":%04zx %c ",
201fdac: b6 16 e0 08 or %i3, 8, %i3 <== NOT EXECUTED
201fdb0: 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));
201fdb4: b2 16 60 68 or %i1, 0x68, %i1 <== NOT EXECUTED
return 1;
}
rtems_rfs_shell_lock_rfs (fs);
for (ino = start; ino <= end; ino++)
201fdb8: 10 80 00 c9 b 20200dc <rtems_rfs_shell_inode+0x470> <== NOT EXECUTED
201fdbc: 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);
201fdc0: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
201fdc4: 94 10 00 1d mov %i5, %o2 <== NOT EXECUTED
201fdc8: 40 00 3c ef call 202f184 <rtems_rfs_group_bitmap_test> <== NOT EXECUTED
201fdcc: 96 07 bf d7 add %fp, -41, %o3 <== NOT EXECUTED
if (rc > 0)
201fdd0: a8 92 20 00 orcc %o0, 0, %l4 <== NOT EXECUTED
201fdd4: 04 80 00 0a ble 201fdfc <rtems_rfs_shell_inode+0x190> <== NOT EXECUTED
201fdd8: 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);
201fddc: 7f ff ff 8f call 201fc18 <rtems_rfs_rtems_unlock> <== NOT EXECUTED
201fde0: 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",
201fde4: 40 00 76 24 call 203d674 <strerror> <== NOT EXECUTED
201fde8: 90 10 00 14 mov %l4, %o0 <== NOT EXECUTED
201fdec: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
201fdf0: 11 00 81 5c sethi %hi(0x2057000), %o0 <== NOT EXECUTED
201fdf4: 10 80 00 b5 b 20200c8 <rtems_rfs_shell_inode+0x45c> <== NOT EXECUTED
201fdf8: 90 12 23 a8 or %o0, 0x3a8, %o0 ! 20573a8 <rtems_rtc_shell_usage+0xec8><== NOT EXECUTED
ino, rc, strerror (rc));
return 1;
}
if (show_all || allocated)
201fdfc: 12 80 00 05 bne 201fe10 <rtems_rfs_shell_inode+0x1a4> <== NOT EXECUTED
201fe00: c2 0f bf d7 ldub [ %fp + -41 ], %g1 <== NOT EXECUTED
201fe04: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
201fe08: 22 80 00 b5 be,a 20200dc <rtems_rfs_shell_inode+0x470> <== NOT EXECUTED
201fe0c: ba 07 60 01 inc %i5 <== NOT EXECUTED
{
uint16_t mode;
bool error;
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
201fe10: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
201fe14: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
201fe18: 94 07 bf d8 add %fp, -40, %o2 <== NOT EXECUTED
201fe1c: 40 00 3d 79 call 202f400 <rtems_rfs_inode_open> <== NOT EXECUTED
201fe20: 96 10 20 01 mov 1, %o3 <== NOT EXECUTED
if (rc > 0)
201fe24: a8 92 20 00 orcc %o0, 0, %l4 <== NOT EXECUTED
201fe28: 04 80 00 0a ble 201fe50 <rtems_rfs_shell_inode+0x1e4> <== NOT EXECUTED
201fe2c: 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);
201fe30: 7f ff ff 7a call 201fc18 <rtems_rfs_rtems_unlock> <== NOT EXECUTED
201fe34: 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",
201fe38: 40 00 76 0f call 203d674 <strerror> <== NOT EXECUTED
201fe3c: 90 10 00 14 mov %l4, %o0 <== NOT EXECUTED
201fe40: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
201fe44: 11 00 81 5c sethi %hi(0x2057000), %o0 <== NOT EXECUTED
201fe48: 10 80 00 a0 b 20200c8 <rtems_rfs_shell_inode+0x45c> <== NOT EXECUTED
201fe4c: 90 12 23 d8 or %o0, 0x3d8, %o0 ! 20573d8 <rtems_rtc_shell_usage+0xef8><== NOT EXECUTED
ino, rc, strerror (rc));
return 1;
}
error = false;
201fe50: 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);
201fe54: e8 08 60 02 ldub [ %g1 + 2 ], %l4 <== NOT EXECUTED
201fe58: c2 08 60 03 ldub [ %g1 + 3 ], %g1 <== NOT EXECUTED
201fe5c: a9 2d 20 08 sll %l4, 8, %l4 <== NOT EXECUTED
mode = rtems_rfs_inode_get_mode (&inode);
if (error_check_only)
201fe60: 80 8c 20 ff btst 0xff, %l0 <== NOT EXECUTED
201fe64: 02 80 00 18 be 201fec4 <rtems_rfs_shell_inode+0x258> <== NOT EXECUTED
201fe68: a8 15 00 01 or %l4, %g1, %l4 <== NOT EXECUTED
{
if (!RTEMS_RFS_S_ISDIR (mode) &&
201fe6c: 03 00 00 3c sethi %hi(0xf000), %g1 <== NOT EXECUTED
201fe70: 07 00 00 08 sethi %hi(0x2000), %g3 <== NOT EXECUTED
201fe74: 82 0d 00 01 and %l4, %g1, %g1 <== NOT EXECUTED
201fe78: 80 a0 40 03 cmp %g1, %g3 <== NOT EXECUTED
201fe7c: 02 80 00 13 be 201fec8 <rtems_rfs_shell_inode+0x25c> <== NOT EXECUTED
201fe80: 80 88 a0 ff btst 0xff, %g2 <== NOT EXECUTED
201fe84: 07 00 00 10 sethi %hi(0x4000), %g3 <== NOT EXECUTED
201fe88: 80 a0 40 03 cmp %g1, %g3 <== NOT EXECUTED
201fe8c: 02 80 00 0f be 201fec8 <rtems_rfs_shell_inode+0x25c> <== NOT EXECUTED
201fe90: 80 88 a0 ff btst 0xff, %g2 <== NOT EXECUTED
!RTEMS_RFS_S_ISCHR (mode) &&
201fe94: 07 00 00 18 sethi %hi(0x6000), %g3 <== NOT EXECUTED
201fe98: 80 a0 40 03 cmp %g1, %g3 <== NOT EXECUTED
201fe9c: 02 80 00 0a be 201fec4 <rtems_rfs_shell_inode+0x258> <== NOT EXECUTED
201fea0: 07 00 00 20 sethi %hi(0x8000), %g3 <== NOT EXECUTED
!RTEMS_RFS_S_ISBLK (mode) &&
201fea4: 80 a0 40 03 cmp %g1, %g3 <== NOT EXECUTED
201fea8: 02 80 00 08 be 201fec8 <rtems_rfs_shell_inode+0x25c> <== NOT EXECUTED
201feac: 80 88 a0 ff btst 0xff, %g2 <== NOT EXECUTED
!RTEMS_RFS_S_ISREG (mode) &&
201feb0: 05 00 00 28 sethi %hi(0xa000), %g2 <== NOT EXECUTED
201feb4: 82 18 40 02 xor %g1, %g2, %g1 <== NOT EXECUTED
201feb8: 80 a0 00 01 cmp %g0, %g1 <== NOT EXECUTED
201febc: 10 80 00 02 b 201fec4 <rtems_rfs_shell_inode+0x258> <== NOT EXECUTED
201fec0: 84 40 20 00 addx %g0, 0, %g2 <== NOT EXECUTED
}
#endif
}
}
if (!error_check_only || error)
201fec4: 80 88 a0 ff btst 0xff, %g2 <== NOT EXECUTED
201fec8: 12 80 00 06 bne 201fee0 <rtems_rfs_shell_inode+0x274> <== NOT EXECUTED
201fecc: c2 07 bf f8 ld [ %fp + -8 ], %g1 <== NOT EXECUTED
201fed0: 80 a4 60 00 cmp %l1, 0 <== NOT EXECUTED
201fed4: 02 80 00 71 be 2020098 <rtems_rfs_shell_inode+0x42c> <== NOT EXECUTED
201fed8: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
{
printf (" %5" PRIu32 ": pos=%06" PRIu32 ":%04zx %c ",
201fedc: c2 07 bf f8 ld [ %fp + -8 ], %g1 <== NOT EXECUTED
201fee0: c6 0f bf d7 ldub [ %fp + -41 ], %g3 <== NOT EXECUTED
201fee4: d4 07 bf ec ld [ %fp + -20 ], %o2 <== NOT EXECUTED
201fee8: 80 a0 00 03 cmp %g0, %g3 <== NOT EXECUTED
201feec: 97 28 60 03 sll %g1, 3, %o3 <== NOT EXECUTED
201fef0: 83 28 60 06 sll %g1, 6, %g1 <== NOT EXECUTED
201fef4: 98 40 3f ff addx %g0, -1, %o4 <== NOT EXECUTED
201fef8: 96 20 40 0b sub %g1, %o3, %o3 <== NOT EXECUTED
201fefc: 98 0b 20 05 and %o4, 5, %o4 <== NOT EXECUTED
201ff00: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
201ff04: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
201ff08: 40 00 6c 5c call 203b078 <printf> <== NOT EXECUTED
201ff0c: 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)
201ff10: c2 0f bf d7 ldub [ %fp + -41 ], %g1 <== NOT EXECUTED
201ff14: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED
201ff18: 12 80 00 0a bne 201ff40 <rtems_rfs_shell_inode+0x2d4> <== NOT EXECUTED
201ff1c: 03 00 00 3c sethi %hi(0xf000), %g1 <== NOT EXECUTED
201ff20: 80 8c e0 ff btst 0xff, %l3 <== NOT EXECUTED
201ff24: 12 80 00 08 bne 201ff44 <rtems_rfs_shell_inode+0x2d8> <== NOT EXECUTED
201ff28: 05 00 00 10 sethi %hi(0x4000), %g2 <== NOT EXECUTED
printf (" --\n");
201ff2c: 11 00 81 5d sethi %hi(0x2057400), %o0 <== NOT EXECUTED
201ff30: 40 00 6c ea call 203b2d8 <puts> <== NOT EXECUTED
201ff34: 90 12 20 28 or %o0, 0x28, %o0 ! 2057428 <rtems_rtc_shell_usage+0xf48><== NOT EXECUTED
201ff38: 10 80 00 58 b 2020098 <rtems_rfs_shell_inode+0x42c> <== NOT EXECUTED
201ff3c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
else
{
const char* type;
type = "UKN";
if (RTEMS_RFS_S_ISDIR (mode))
201ff40: 05 00 00 10 sethi %hi(0x4000), %g2 <== NOT EXECUTED
201ff44: 82 0d 00 01 and %l4, %g1, %g1 <== NOT EXECUTED
201ff48: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED
201ff4c: 02 80 00 10 be 201ff8c <rtems_rfs_shell_inode+0x320> <== NOT EXECUTED
201ff50: 05 00 00 08 sethi %hi(0x2000), %g2 <== NOT EXECUTED
type = "DIR";
else if (RTEMS_RFS_S_ISCHR (mode))
201ff54: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED
201ff58: 02 80 00 10 be 201ff98 <rtems_rfs_shell_inode+0x32c> <== NOT EXECUTED
201ff5c: 05 00 00 18 sethi %hi(0x6000), %g2 <== NOT EXECUTED
type = "CHR";
else if (RTEMS_RFS_S_ISBLK (mode))
201ff60: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED
201ff64: 02 80 00 10 be 201ffa4 <rtems_rfs_shell_inode+0x338> <== NOT EXECUTED
201ff68: 05 00 00 20 sethi %hi(0x8000), %g2 <== NOT EXECUTED
type = "BLK";
else if (RTEMS_RFS_S_ISREG (mode))
201ff6c: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED
201ff70: 02 80 00 10 be 201ffb0 <rtems_rfs_shell_inode+0x344> <== NOT EXECUTED
201ff74: 05 00 00 28 sethi %hi(0xa000), %g2 <== NOT EXECUTED
type = "REG";
else if (RTEMS_RFS_S_ISLNK (mode))
201ff78: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED
201ff7c: 02 80 00 10 be 201ffbc <rtems_rfs_shell_inode+0x350> <== NOT EXECUTED
201ff80: 17 00 81 5c sethi %hi(0x2057000), %o3 <== NOT EXECUTED
if (!allocated && !forced)
printf (" --\n");
else
{
const char* type;
type = "UKN";
201ff84: 10 80 00 10 b 201ffc4 <rtems_rfs_shell_inode+0x358> <== NOT EXECUTED
201ff88: 96 12 e3 50 or %o3, 0x350, %o3 ! 2057350 <rtems_rtc_shell_usage+0xe70><== NOT EXECUTED
if (RTEMS_RFS_S_ISDIR (mode))
type = "DIR";
201ff8c: 17 00 81 5c sethi %hi(0x2057000), %o3 <== NOT EXECUTED
201ff90: 10 80 00 0d b 201ffc4 <rtems_rfs_shell_inode+0x358> <== NOT EXECUTED
201ff94: 96 12 e3 30 or %o3, 0x330, %o3 ! 2057330 <rtems_rtc_shell_usage+0xe50><== NOT EXECUTED
else if (RTEMS_RFS_S_ISCHR (mode))
type = "CHR";
201ff98: 17 00 81 5c sethi %hi(0x2057000), %o3 <== NOT EXECUTED
201ff9c: 10 80 00 0a b 201ffc4 <rtems_rfs_shell_inode+0x358> <== NOT EXECUTED
201ffa0: 96 12 e3 38 or %o3, 0x338, %o3 ! 2057338 <rtems_rtc_shell_usage+0xe58><== NOT EXECUTED
else if (RTEMS_RFS_S_ISBLK (mode))
type = "BLK";
201ffa4: 17 00 81 5c sethi %hi(0x2057000), %o3 <== NOT EXECUTED
201ffa8: 10 80 00 07 b 201ffc4 <rtems_rfs_shell_inode+0x358> <== NOT EXECUTED
201ffac: 96 12 e3 40 or %o3, 0x340, %o3 ! 2057340 <rtems_rtc_shell_usage+0xe60><== NOT EXECUTED
else if (RTEMS_RFS_S_ISREG (mode))
type = "REG";
201ffb0: 17 00 81 5c sethi %hi(0x2057000), %o3 <== NOT EXECUTED
201ffb4: 10 80 00 04 b 201ffc4 <rtems_rfs_shell_inode+0x358> <== NOT EXECUTED
201ffb8: 96 12 e3 48 or %o3, 0x348, %o3 ! 2057348 <rtems_rtc_shell_usage+0xe68><== NOT EXECUTED
else if (RTEMS_RFS_S_ISLNK (mode))
type = "LNK";
201ffbc: 17 00 81 5c sethi %hi(0x2057000), %o3 <== NOT EXECUTED
201ffc0: 96 12 e3 58 or %o3, 0x358, %o3 ! 2057358 <rtems_rtc_shell_usage+0xe78><== 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);
201ffc4: c2 07 bf e4 ld [ %fp + -28 ], %g1 <== NOT EXECUTED
printf ("links=%03i mode=%04x (%s/%03o) bo=%04u bc=%04" PRIu32 " b=[",
201ffc8: 95 2d 20 10 sll %l4, 0x10, %o2 <== NOT EXECUTED
201ffcc: c6 08 60 01 ldub [ %g1 + 1 ], %g3 <== NOT EXECUTED
201ffd0: 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);
201ffd4: 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);
201ffd8: 85 28 a0 08 sll %g2, 8, %g2 <== NOT EXECUTED
201ffdc: 84 10 80 03 or %g2, %g3, %g2 <== NOT EXECUTED
if (links == 0xffff)
201ffe0: 87 28 a0 10 sll %g2, 0x10, %g3 <== NOT EXECUTED
201ffe4: 87 30 e0 10 srl %g3, 0x10, %g3 <== NOT EXECUTED
links = 0;
201ffe8: 86 18 c0 1a xor %g3, %i2, %g3 <== NOT EXECUTED
201ffec: 80 a0 00 03 cmp %g0, %g3 <== NOT EXECUTED
201fff0: 92 60 20 00 subx %g0, 0, %o1 <== NOT EXECUTED
201fff4: 84 08 80 09 and %g2, %o1, %g2 <== NOT EXECUTED
201fff8: 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);
201fffc: c4 08 60 0d ldub [ %g1 + 0xd ], %g2 <== NOT EXECUTED
2020000: 89 29 20 18 sll %g4, 0x18, %g4 <== NOT EXECUTED
2020004: 85 28 a0 10 sll %g2, 0x10, %g2 <== NOT EXECUTED
2020008: 88 11 00 02 or %g4, %g2, %g4 <== NOT EXECUTED
202000c: 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);
2020010: 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);
2020014: 88 11 00 02 or %g4, %g2, %g4 <== NOT EXECUTED
2020018: c4 08 60 0e ldub [ %g1 + 0xe ], %g2 <== NOT EXECUTED
202001c: 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);
2020020: 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);
2020024: 85 28 a0 08 sll %g2, 8, %g2 <== NOT EXECUTED
2020028: 82 11 00 02 or %g4, %g2, %g1 <== NOT EXECUTED
202002c: 98 0d 23 ff and %l4, 0x3ff, %o4 <== NOT EXECUTED
2020030: c2 23 a0 5c st %g1, [ %sp + 0x5c ] <== NOT EXECUTED
2020034: 11 00 81 5d sethi %hi(0x2057400), %o0 <== NOT EXECUTED
2020038: 93 32 60 10 srl %o1, 0x10, %o1 <== NOT EXECUTED
202003c: 90 12 20 30 or %o0, 0x30, %o0 <== NOT EXECUTED
2020040: 95 32 a0 10 srl %o2, 0x10, %o2 <== NOT EXECUTED
2020044: 9a 13 40 03 or %o5, %g3, %o5 <== NOT EXECUTED
2020048: 40 00 6c 0c call 203b078 <printf> <== NOT EXECUTED
202004c: 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));
2020050: 92 10 00 14 mov %l4, %o1 <== NOT EXECUTED
2020054: 7f ff fe cc call 201fb84 <rtems_rfs_inode_get_block> <== NOT EXECUTED
2020058: 90 07 bf d8 add %fp, -40, %o0 <== NOT EXECUTED
202005c: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED
2020060: 40 00 6c 06 call 203b078 <printf> <== NOT EXECUTED
2020064: 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++)
2020068: a8 05 20 01 inc %l4 <== NOT EXECUTED
202006c: 80 a5 20 04 cmp %l4, 4 <== NOT EXECUTED
2020070: 32 bf ff f9 bne,a 2020054 <rtems_rfs_shell_inode+0x3e8> <== NOT EXECUTED
2020074: 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));
2020078: 92 10 20 04 mov 4, %o1 <== NOT EXECUTED
202007c: 7f ff fe c2 call 201fb84 <rtems_rfs_inode_get_block> <== NOT EXECUTED
2020080: 90 07 bf d8 add %fp, -40, %o0 <== NOT EXECUTED
2020084: 92 10 00 08 mov %o0, %o1 <== NOT EXECUTED
2020088: 11 00 81 5d sethi %hi(0x2057400), %o0 <== NOT EXECUTED
202008c: 40 00 6b fb call 203b078 <printf> <== NOT EXECUTED
2020090: 90 12 20 70 or %o0, 0x70, %o0 ! 2057470 <rtems_rtc_shell_usage+0xf90><== NOT EXECUTED
}
}
rc = rtems_rfs_inode_close (fs, &inode);
2020094: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
2020098: 40 00 3d 4c call 202f5c8 <rtems_rfs_inode_close> <== NOT EXECUTED
202009c: 92 07 bf d8 add %fp, -40, %o1 <== NOT EXECUTED
if (rc > 0)
20200a0: a8 92 20 00 orcc %o0, 0, %l4 <== NOT EXECUTED
20200a4: 24 80 00 0e ble,a 20200dc <rtems_rfs_shell_inode+0x470> <== NOT EXECUTED
20200a8: 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);
20200ac: 7f ff fe db call 201fc18 <rtems_rfs_rtems_unlock> <== NOT EXECUTED
20200b0: 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",
20200b4: 40 00 75 70 call 203d674 <strerror> <== NOT EXECUTED
20200b8: 90 10 00 14 mov %l4, %o0 <== NOT EXECUTED
20200bc: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
20200c0: 11 00 81 5d sethi %hi(0x2057400), %o0 <== NOT EXECUTED
20200c4: 90 12 20 78 or %o0, 0x78, %o0 ! 2057478 <rtems_rtc_shell_usage+0xf98><== NOT EXECUTED
20200c8: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
20200cc: 40 00 6b eb call 203b078 <printf> <== NOT EXECUTED
20200d0: 94 10 00 14 mov %l4, %o2 <== NOT EXECUTED
20200d4: 81 c7 e0 08 ret <== NOT EXECUTED
20200d8: 91 e8 20 01 restore %g0, 1, %o0 <== NOT EXECUTED
return 1;
}
rtems_rfs_shell_lock_rfs (fs);
for (ino = start; ino <= end; ino++)
20200dc: 80 a7 40 1c cmp %i5, %i4 <== NOT EXECUTED
20200e0: 08 bf ff 38 bleu 201fdc0 <rtems_rfs_shell_inode+0x154> <== NOT EXECUTED
20200e4: 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);
20200e8: 7f ff fe cc call 201fc18 <rtems_rfs_rtems_unlock> <== NOT EXECUTED
20200ec: b0 10 20 00 clr %i0 <== NOT EXECUTED
}
rtems_rfs_shell_unlock_rfs (fs);
return 0;
}
20200f0: 81 c7 e0 08 ret <== NOT EXECUTED
20200f4: 81 e8 00 00 restore <== NOT EXECUTED
02020944 <rtems_rfs_shell_usage>:
}
void
rtems_rfs_shell_usage (const char* arg)
{
2020944: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED
printf ("%s: RFS debugger\n", arg);
2020948: 11 00 81 5e sethi %hi(0x2057800), %o0 <== NOT EXECUTED
202094c: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
2020950: 40 00 69 ca call 203b078 <printf> <== NOT EXECUTED
2020954: 90 12 21 08 or %o0, 0x108, %o0 <== NOT EXECUTED
printf (" %s [-hl] <path> <command>\n", arg);
2020958: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
202095c: 11 00 81 5e sethi %hi(0x2057800), %o0 <== NOT EXECUTED
2020960: 40 00 69 c6 call 203b078 <printf> <== NOT EXECUTED
2020964: 90 12 21 20 or %o0, 0x120, %o0 ! 2057920 <rtems_rtc_shell_usage+0x1440><== NOT EXECUTED
printf (" where:\n");
2020968: 11 00 81 5e sethi %hi(0x2057800), %o0 <== NOT EXECUTED
202096c: 40 00 6a 5b call 203b2d8 <puts> <== NOT EXECUTED
2020970: 90 12 21 40 or %o0, 0x140, %o0 ! 2057940 <rtems_rtc_shell_usage+0x1460><== NOT EXECUTED
printf (" path: Path to the mounted RFS file system\n");
2020974: 11 00 81 5e sethi %hi(0x2057800), %o0 <== NOT EXECUTED
2020978: 40 00 6a 58 call 203b2d8 <puts> <== NOT EXECUTED
202097c: 90 12 21 50 or %o0, 0x150, %o0 ! 2057950 <rtems_rtc_shell_usage+0x1470><== NOT EXECUTED
printf (" command: A debugger command. See -l for a list plus help.\n");
2020980: 11 00 81 5e sethi %hi(0x2057800), %o0 <== NOT EXECUTED
2020984: 40 00 6a 55 call 203b2d8 <puts> <== NOT EXECUTED
2020988: 90 12 21 88 or %o0, 0x188, %o0 ! 2057988 <rtems_rtc_shell_usage+0x14a8><== NOT EXECUTED
printf (" -h: This help\n");
202098c: 11 00 81 5e sethi %hi(0x2057800), %o0 <== NOT EXECUTED
printf (" -l: The debugger command list.\n");
2020990: 31 00 81 5e sethi %hi(0x2057800), %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");
2020994: 90 12 21 c8 or %o0, 0x1c8, %o0 <== NOT EXECUTED
2020998: 40 00 6a 50 call 203b2d8 <puts> <== NOT EXECUTED
202099c: b0 16 21 e0 or %i0, 0x1e0, %i0 <== NOT EXECUTED
printf (" -l: The debugger command list.\n");
20209a0: 40 00 6a 4e call 203b2d8 <puts> <== NOT EXECUTED
20209a4: 81 e8 00 00 restore <== NOT EXECUTED
0201ec24 <rtems_rfs_symlink>:
const char* link,
int link_length,
uid_t uid,
gid_t gid,
rtems_rfs_ino parent)
{
201ec24: 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))
201ec28: 90 10 20 02 mov 2, %o0
const char* link,
int link_length,
uid_t uid,
gid_t gid,
rtems_rfs_ino parent)
{
201ec2c: e2 07 a0 60 ld [ %fp + 0x60 ], %l1
201ec30: 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))
201ec34: 7f ff d2 e7 call 20137d0 <rtems_rfs_trace>
201ec38: 92 10 20 00 clr %o1
201ec3c: 80 8a 20 ff btst 0xff, %o0
201ec40: 12 80 00 07 bne 201ec5c <rtems_rfs_symlink+0x38> <== NEVER TAKEN
201ec44: 11 00 80 d3 sethi %hi(0x2034c00), %o0
printf (" link:");
for (c = 0; c < link_length; c++)
printf ("%c", link[c]);
}
if (link_length >= rtems_rfs_fs_block_size (fs))
201ec48: c2 06 20 08 ld [ %i0 + 8 ], %g1
201ec4c: 80 a7 00 01 cmp %i4, %g1
201ec50: 1a 80 00 8b bcc 201ee7c <rtems_rfs_symlink+0x258> <== NEVER TAKEN
201ec54: b4 10 20 5b mov 0x5b, %i2
201ec58: 30 80 00 19 b,a 201ecbc <rtems_rfs_symlink+0x98>
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_SYMLINK))
{
int c;
printf ("rtems-rfs: symlink: parent:%" PRIu32 " name:", parent);
201ec5c: 92 10 00 11 mov %l1, %o1 <== NOT EXECUTED
201ec60: 90 12 20 e0 or %o0, 0xe0, %o0 <== NOT EXECUTED
201ec64: 40 00 0d 25 call 20220f8 <printf> <== NOT EXECUTED
201ec68: a0 10 20 00 clr %l0 <== NOT EXECUTED
for (c = 0; c < length; c++)
201ec6c: 10 80 00 05 b 201ec80 <rtems_rfs_symlink+0x5c> <== NOT EXECUTED
201ec70: 80 a4 00 1a cmp %l0, %i2 <== NOT EXECUTED
printf ("%c", name[c]);
201ec74: 40 00 0d 8b call 20222a0 <putchar> <== NOT EXECUTED
201ec78: 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++)
201ec7c: 80 a4 00 1a cmp %l0, %i2 <== NOT EXECUTED
201ec80: 26 bf ff fd bl,a 201ec74 <rtems_rfs_symlink+0x50> <== NOT EXECUTED
201ec84: d0 4e 40 10 ldsb [ %i1 + %l0 ], %o0 <== NOT EXECUTED
printf ("%c", name[c]);
printf (" link:");
201ec88: 11 00 80 d3 sethi %hi(0x2034c00), %o0 <== NOT EXECUTED
for (c = 0; c < link_length; c++)
201ec8c: 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:");
201ec90: 40 00 0d 1a call 20220f8 <printf> <== NOT EXECUTED
201ec94: 90 12 21 08 or %o0, 0x108, %o0 <== NOT EXECUTED
for (c = 0; c < link_length; c++)
201ec98: 10 80 00 05 b 201ecac <rtems_rfs_symlink+0x88> <== NOT EXECUTED
201ec9c: 80 a6 80 1c cmp %i2, %i4 <== NOT EXECUTED
printf ("%c", link[c]);
201eca0: 40 00 0d 80 call 20222a0 <putchar> <== NOT EXECUTED
201eca4: 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++)
201eca8: 80 a6 80 1c cmp %i2, %i4 <== NOT EXECUTED
201ecac: 26 bf ff fd bl,a 201eca0 <rtems_rfs_symlink+0x7c> <== NOT EXECUTED
201ecb0: d0 4e c0 1a ldsb [ %i3 + %i2 ], %o0 <== NOT EXECUTED
printf ("%c", link[c]);
}
if (link_length >= rtems_rfs_fs_block_size (fs))
201ecb4: 10 bf ff e6 b 201ec4c <rtems_rfs_symlink+0x28> <== NOT EXECUTED
201ecb8: c2 06 20 08 ld [ %i0 + 8 ], %g1 <== NOT EXECUTED
return ENAMETOOLONG;
rc = rtems_rfs_inode_create (fs, parent, name, strlen (name),
201ecbc: 40 00 11 a5 call 2023350 <strlen>
201ecc0: 90 10 00 19 mov %i1, %o0
201ecc4: 82 07 bf 74 add %fp, -140, %g1
201ecc8: 96 10 00 08 mov %o0, %o3
201eccc: fa 23 a0 5c st %i5, [ %sp + 0x5c ]
201ecd0: e4 23 a0 60 st %l2, [ %sp + 0x60 ]
201ecd4: c2 23 a0 64 st %g1, [ %sp + 0x64 ]
201ecd8: 90 10 00 18 mov %i0, %o0
201ecdc: 92 10 00 11 mov %l1, %o1
201ece0: 94 10 00 19 mov %i1, %o2
201ece4: 19 00 00 28 sethi %hi(0xa000), %o4
201ece8: 9a 10 20 01 mov 1, %o5
201ecec: 7f ff cd 6f call 20122a8 <rtems_rfs_inode_create>
201ecf0: 98 13 21 ff or %o4, 0x1ff, %o4
RTEMS_RFS_S_SYMLINK,
1, uid, gid, &ino);
if (rc > 0)
201ecf4: b4 92 20 00 orcc %o0, 0, %i2
201ecf8: 34 80 00 62 bg,a 201ee80 <rtems_rfs_symlink+0x25c> <== NEVER TAKEN
201ecfc: b0 10 00 1a mov %i2, %i0 <== NOT EXECUTED
return rc;
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
201ed00: d2 07 bf 74 ld [ %fp + -140 ], %o1
201ed04: 90 10 00 18 mov %i0, %o0
201ed08: 94 07 bf 88 add %fp, -120, %o2
201ed0c: 7f ff cc 20 call 2011d8c <rtems_rfs_inode_open>
201ed10: 96 10 20 01 mov 1, %o3
if (rc > 0)
201ed14: b4 92 20 00 orcc %o0, 0, %i2
201ed18: 34 80 00 5a bg,a 201ee80 <rtems_rfs_symlink+0x25c> <== NEVER TAKEN
201ed1c: 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)
201ed20: 80 a7 20 13 cmp %i4, 0x13
201ed24: 38 80 00 15 bgu,a 201ed78 <rtems_rfs_symlink+0x154> <== NEVER TAKEN
201ed28: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
{
memset (inode.node->data.name, 0, RTEMS_RFS_INODE_DATA_NAME_SIZE);
201ed2c: d0 07 bf 94 ld [ %fp + -108 ], %o0
201ed30: 92 10 20 00 clr %o1
201ed34: 94 10 20 14 mov 0x14, %o2
201ed38: 40 00 0c 72 call 2021f00 <memset>
201ed3c: 90 02 20 1c add %o0, 0x1c, %o0
memcpy (inode.node->data.name, link, link_length);
201ed40: d0 07 bf 94 ld [ %fp + -108 ], %o0
201ed44: 92 10 00 1b mov %i3, %o1
201ed48: 90 02 20 1c add %o0, 0x1c, %o0
201ed4c: 40 00 0b de call 2021cc4 <memcpy>
201ed50: 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);
201ed54: c2 07 bf 94 ld [ %fp + -108 ], %g1
201ed58: c0 28 60 0c clrb [ %g1 + 0xc ]
201ed5c: c2 07 bf 94 ld [ %fp + -108 ], %g1
201ed60: c0 28 60 0d clrb [ %g1 + 0xd ]
201ed64: c2 07 bf 94 ld [ %fp + -108 ], %g1
201ed68: c0 28 60 0e clrb [ %g1 + 0xe ]
201ed6c: c2 07 bf 94 ld [ %fp + -108 ], %g1
201ed70: 10 80 00 38 b 201ee50 <rtems_rfs_symlink+0x22c>
201ed74: 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);
201ed78: 92 07 bf 88 add %fp, -120, %o1 <== NOT EXECUTED
201ed7c: 7f ff ee 1e call 201a5f4 <rtems_rfs_block_map_open> <== NOT EXECUTED
201ed80: 94 07 bf b0 add %fp, -80, %o2 <== NOT EXECUTED
201ed84: b4 10 00 08 mov %o0, %i2 <== NOT EXECUTED
if (rc > 0)
201ed88: 80 a6 a0 00 cmp %i2, 0 <== NOT EXECUTED
201ed8c: 14 80 00 2d bg 201ee40 <rtems_rfs_symlink+0x21c> <== NOT EXECUTED
201ed90: 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);
201ed94: 92 07 bf b0 add %fp, -80, %o1 <== NOT EXECUTED
201ed98: 94 10 20 01 mov 1, %o2 <== NOT EXECUTED
201ed9c: 7f ff ef 71 call 201ab60 <rtems_rfs_block_map_grow> <== NOT EXECUTED
201eda0: 96 07 bf 78 add %fp, -136, %o3 <== NOT EXECUTED
if (rc > 0)
201eda4: b4 92 20 00 orcc %o0, 0, %i2 <== NOT EXECUTED
201eda8: 14 80 00 0c bg 201edd8 <rtems_rfs_symlink+0x1b4> <== NOT EXECUTED
201edac: 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);
201edb0: 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;
201edb4: c0 2f bf 7c clrb [ %fp + -132 ] <== NOT EXECUTED
handle->bnum = 0;
201edb8: c0 27 bf 80 clr [ %fp + -128 ] <== NOT EXECUTED
handle->buffer = NULL;
201edbc: c0 27 bf 84 clr [ %fp + -124 ] <== NOT EXECUTED
201edc0: 92 07 bf 7c add %fp, -132, %o1 <== NOT EXECUTED
201edc4: 7f ff f1 f9 call 201b5a8 <rtems_rfs_buffer_handle_request><== NOT EXECUTED
201edc8: 96 10 20 00 clr %o3 <== NOT EXECUTED
if (rc > 0)
201edcc: b4 92 20 00 orcc %o0, 0, %i2 <== NOT EXECUTED
201edd0: 04 80 00 06 ble 201ede8 <rtems_rfs_symlink+0x1c4> <== NOT EXECUTED
201edd4: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
{
rtems_rfs_block_map_close (fs, &map);
201edd8: 7f ff ee 68 call 201a778 <rtems_rfs_block_map_close> <== NOT EXECUTED
201eddc: 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);
201ede0: 10 80 00 18 b 201ee40 <rtems_rfs_symlink+0x21c> <== NOT EXECUTED
201ede4: 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);
201ede8: c2 07 bf 84 ld [ %fp + -124 ], %g1 <== NOT EXECUTED
memset (data, 0xff, rtems_rfs_fs_block_size (fs));
201edec: 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);
201edf0: fa 00 60 1c ld [ %g1 + 0x1c ], %i5 <== NOT EXECUTED
memset (data, 0xff, rtems_rfs_fs_block_size (fs));
201edf4: 92 10 20 ff mov 0xff, %o1 <== NOT EXECUTED
201edf8: 40 00 0c 42 call 2021f00 <memset> <== NOT EXECUTED
201edfc: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
memcpy (data, link, link_length);
201ee00: 94 10 00 1c mov %i4, %o2 <== NOT EXECUTED
201ee04: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
201ee08: 40 00 0b af call 2021cc4 <memcpy> <== NOT EXECUTED
201ee0c: 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);
201ee10: 92 07 bf 7c add %fp, -132, %o1 <== NOT EXECUTED
201ee14: 7f ff f1 71 call 201b3d8 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
201ee18: 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);
201ee1c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
handle->dirty = false;
201ee20: c0 2f bf 7c clrb [ %fp + -132 ] <== NOT EXECUTED
handle->bnum = 0;
201ee24: c0 27 bf 80 clr [ %fp + -128 ] <== NOT EXECUTED
handle->buffer = NULL;
201ee28: c0 27 bf 84 clr [ %fp + -124 ] <== NOT EXECUTED
201ee2c: 7f ff ee 53 call 201a778 <rtems_rfs_block_map_close> <== NOT EXECUTED
201ee30: 92 07 bf b0 add %fp, -80, %o1 <== NOT EXECUTED
if (rc > 0)
201ee34: b4 92 20 00 orcc %o0, 0, %i2 <== NOT EXECUTED
201ee38: 04 80 00 06 ble 201ee50 <rtems_rfs_symlink+0x22c> <== NOT EXECUTED
201ee3c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
{
rtems_rfs_inode_close (fs, &inode);
201ee40: 7f ff cc 45 call 2011f54 <rtems_rfs_inode_close> <== NOT EXECUTED
201ee44: 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;
}
201ee48: 81 c7 e0 08 ret <== NOT EXECUTED
201ee4c: 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);
201ee50: c2 07 bf 94 ld [ %fp + -108 ], %g1
201ee54: 85 37 20 08 srl %i4, 8, %g2
201ee58: c4 28 60 0a stb %g2, [ %g1 + 0xa ]
201ee5c: c2 07 bf 94 ld [ %fp + -108 ], %g1
}
}
rtems_rfs_inode_set_block_offset (&inode, link_length);
rc = rtems_rfs_inode_close (fs, &inode);
201ee60: 90 10 00 18 mov %i0, %o0
201ee64: f8 28 60 0b stb %i4, [ %g1 + 0xb ]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
201ee68: 82 10 20 01 mov 1, %g1
201ee6c: 92 07 bf 88 add %fp, -120, %o1
201ee70: 7f ff cc 39 call 2011f54 <rtems_rfs_inode_close>
201ee74: c2 2f bf 98 stb %g1, [ %fp + -104 ]
201ee78: b4 10 00 08 mov %o0, %i2
return rc;
}
201ee7c: b0 10 00 1a mov %i2, %i0
201ee80: 81 c7 e0 08 ret
201ee84: 81 e8 00 00 restore
0201ee88 <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)
{
201ee88: 9d e3 bf 18 save %sp, -232, %sp
rtems_rfs_inode_handle inode;
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_SYMLINK_READ))
201ee8c: 90 10 20 04 mov 4, %o0
201ee90: 92 10 20 00 clr %o1
201ee94: 7f ff d2 4f call 20137d0 <rtems_rfs_trace>
201ee98: ba 10 00 18 mov %i0, %i5
201ee9c: 80 8a 20 ff btst 0xff, %o0
201eea0: 22 80 00 07 be,a 201eebc <rtems_rfs_symlink_read+0x34> <== ALWAYS TAKEN
201eea4: 90 10 00 1d mov %i5, %o0
printf ("rtems-rfs: symlink-read: link:%" PRIu32 "\n", link);
201eea8: 11 00 80 d3 sethi %hi(0x2034c00), %o0 <== NOT EXECUTED
201eeac: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
201eeb0: 40 00 0c 92 call 20220f8 <printf> <== NOT EXECUTED
201eeb4: 90 12 21 10 or %o0, 0x110, %o0 <== NOT EXECUTED
rc = rtems_rfs_inode_open (fs, link, &inode, true);
201eeb8: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
201eebc: 92 10 00 19 mov %i1, %o1
201eec0: 94 07 bf 88 add %fp, -120, %o2
201eec4: 7f ff cb b2 call 2011d8c <rtems_rfs_inode_open>
201eec8: 96 10 20 01 mov 1, %o3
if (rc)
201eecc: b0 92 20 00 orcc %o0, 0, %i0
201eed0: 12 80 00 0d bne 201ef04 <rtems_rfs_symlink_read+0x7c> <== NEVER TAKEN
201eed4: d2 07 bf 94 ld [ %fp + -108 ], %o1
return rc;
if (!RTEMS_RFS_S_ISLNK (rtems_rfs_inode_get_mode (&inode)))
201eed8: 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);
201eedc: c4 0a 60 02 ldub [ %o1 + 2 ], %g2
201eee0: 85 28 a0 08 sll %g2, 8, %g2
201eee4: 84 08 80 01 and %g2, %g1, %g2
201eee8: 03 00 00 28 sethi %hi(0xa000), %g1
201eeec: 80 a0 80 01 cmp %g2, %g1
201eef0: 02 80 00 07 be 201ef0c <rtems_rfs_symlink_read+0x84> <== ALWAYS TAKEN
201eef4: 90 10 00 1d mov %i5, %o0
{
rtems_rfs_inode_close (fs, &inode);
201eef8: 92 07 bf 88 add %fp, -120, %o1 <== NOT EXECUTED
201eefc: 7f ff cc 16 call 2011f54 <rtems_rfs_inode_close> <== NOT EXECUTED
201ef00: b0 10 20 16 mov 0x16, %i0 <== NOT EXECUTED
201ef04: 81 c7 e0 08 ret <== NOT EXECUTED
201ef08: 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);
201ef0c: d4 0a 60 0a ldub [ %o1 + 0xa ], %o2
return EINVAL;
}
*length = rtems_rfs_inode_get_block_offset (&inode);
201ef10: c2 0a 60 0b ldub [ %o1 + 0xb ], %g1
201ef14: 95 2a a0 08 sll %o2, 8, %o2
201ef18: 94 10 40 0a or %g1, %o2, %o2
201ef1c: 80 a2 80 1b cmp %o2, %i3
201ef20: 38 80 00 02 bgu,a 201ef28 <rtems_rfs_symlink_read+0xa0>
201ef24: 94 10 00 1b mov %i3, %o2
201ef28: 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);
201ef2c: c2 0a 60 0d ldub [ %o1 + 0xd ], %g1
201ef30: c4 0a 60 0c ldub [ %o1 + 0xc ], %g2
201ef34: 83 28 60 10 sll %g1, 0x10, %g1
201ef38: 85 28 a0 18 sll %g2, 0x18, %g2
201ef3c: 84 10 80 01 or %g2, %g1, %g2
201ef40: c2 0a 60 0f ldub [ %o1 + 0xf ], %g1
201ef44: 84 10 80 01 or %g2, %g1, %g2
201ef48: c2 0a 60 0e ldub [ %o1 + 0xe ], %g1
201ef4c: 83 28 60 08 sll %g1, 8, %g1
if (size < *length)
{
*length = size;
}
if (rtems_rfs_inode_get_block_count (&inode) == 0)
201ef50: 80 90 80 01 orcc %g2, %g1, %g0
201ef54: 32 80 00 07 bne,a 201ef70 <rtems_rfs_symlink_read+0xe8> <== NEVER TAKEN
201ef58: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
{
memcpy (path, inode.node->data.name, *length);
201ef5c: 90 10 00 1a mov %i2, %o0
201ef60: 40 00 0b 59 call 2021cc4 <memcpy>
201ef64: 92 02 60 1c add %o1, 0x1c, %o1
rtems_rfs_inode_close (fs, &inode);
return rc;
}
}
rc = rtems_rfs_inode_close (fs, &inode);
201ef68: 10 80 00 34 b 201f038 <rtems_rfs_symlink_read+0x1b0>
201ef6c: 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);
201ef70: 92 07 bf 88 add %fp, -120, %o1 <== NOT EXECUTED
201ef74: 7f ff ed a0 call 201a5f4 <rtems_rfs_block_map_open> <== NOT EXECUTED
201ef78: 94 07 bf b0 add %fp, -80, %o2 <== NOT EXECUTED
201ef7c: b0 10 00 08 mov %o0, %i0 <== NOT EXECUTED
if (rc > 0)
201ef80: 80 a6 20 00 cmp %i0, 0 <== NOT EXECUTED
201ef84: 14 80 00 29 bg 201f028 <rtems_rfs_symlink_read+0x1a0> <== NOT EXECUTED
201ef88: 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);
201ef8c: 92 07 bf b0 add %fp, -80, %o1 <== NOT EXECUTED
201ef90: 94 10 20 00 clr %o2 <== NOT EXECUTED
201ef94: 96 10 20 00 clr %o3 <== NOT EXECUTED
201ef98: 7f ff ee c8 call 201aab8 <rtems_rfs_block_map_seek> <== NOT EXECUTED
201ef9c: 98 07 bf 78 add %fp, -136, %o4 <== NOT EXECUTED
if (rc > 0)
201efa0: b0 92 20 00 orcc %o0, 0, %i0 <== NOT EXECUTED
201efa4: 14 80 00 0c bg 201efd4 <rtems_rfs_symlink_read+0x14c> <== NOT EXECUTED
201efa8: 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);
201efac: 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;
201efb0: c0 2f bf 7c clrb [ %fp + -132 ] <== NOT EXECUTED
handle->bnum = 0;
201efb4: c0 27 bf 80 clr [ %fp + -128 ] <== NOT EXECUTED
handle->buffer = NULL;
201efb8: c0 27 bf 84 clr [ %fp + -124 ] <== NOT EXECUTED
201efbc: 92 07 bf 7c add %fp, -132, %o1 <== NOT EXECUTED
201efc0: 7f ff f1 7a call 201b5a8 <rtems_rfs_buffer_handle_request><== NOT EXECUTED
201efc4: 96 10 20 00 clr %o3 <== NOT EXECUTED
if (rc > 0)
201efc8: b0 92 20 00 orcc %o0, 0, %i0 <== NOT EXECUTED
201efcc: 04 80 00 06 ble 201efe4 <rtems_rfs_symlink_read+0x15c> <== NOT EXECUTED
201efd0: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
{
rtems_rfs_block_map_close (fs, &map);
201efd4: 7f ff ed e9 call 201a778 <rtems_rfs_block_map_close> <== NOT EXECUTED
201efd8: 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);
201efdc: 10 80 00 13 b 201f028 <rtems_rfs_symlink_read+0x1a0> <== NOT EXECUTED
201efe0: 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);
201efe4: c2 07 bf 84 ld [ %fp + -124 ], %g1 <== NOT EXECUTED
201efe8: d4 07 00 00 ld [ %i4 ], %o2 <== NOT EXECUTED
201efec: d2 00 60 1c ld [ %g1 + 0x1c ], %o1 <== NOT EXECUTED
201eff0: 40 00 0b 35 call 2021cc4 <memcpy> <== NOT EXECUTED
201eff4: 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);
201eff8: 92 07 bf 7c add %fp, -132, %o1 <== NOT EXECUTED
201effc: 7f ff f0 f7 call 201b3d8 <rtems_rfs_buffer_handle_release><== NOT EXECUTED
201f000: 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);
201f004: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
handle->dirty = false;
201f008: c0 2f bf 7c clrb [ %fp + -132 ] <== NOT EXECUTED
handle->bnum = 0;
201f00c: c0 27 bf 80 clr [ %fp + -128 ] <== NOT EXECUTED
handle->buffer = NULL;
201f010: c0 27 bf 84 clr [ %fp + -124 ] <== NOT EXECUTED
201f014: 7f ff ed d9 call 201a778 <rtems_rfs_block_map_close> <== NOT EXECUTED
201f018: 92 07 bf b0 add %fp, -80, %o1 <== NOT EXECUTED
if (rc > 0)
201f01c: b0 92 20 00 orcc %o0, 0, %i0 <== NOT EXECUTED
201f020: 04 80 00 06 ble 201f038 <rtems_rfs_symlink_read+0x1b0> <== NOT EXECUTED
201f024: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
{
rtems_rfs_inode_close (fs, &inode);
201f028: 7f ff cb cb call 2011f54 <rtems_rfs_inode_close> <== NOT EXECUTED
201f02c: 92 07 bf 88 add %fp, -120, %o1 <== NOT EXECUTED
201f030: 81 c7 e0 08 ret <== NOT EXECUTED
201f034: 81 e8 00 00 restore <== NOT EXECUTED
return rc;
}
}
rc = rtems_rfs_inode_close (fs, &inode);
201f038: 7f ff cb c7 call 2011f54 <rtems_rfs_inode_close>
201f03c: 92 07 bf 88 add %fp, -120, %o1
201f040: b0 10 00 08 mov %o0, %i0
return rc;
}
201f044: 81 c7 e0 08 ret
201f048: 81 e8 00 00 restore
02013810 <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;
2013810: 03 00 81 19 sethi %hi(0x2046400), %g1 <== NOT EXECUTED
2013814: c4 18 63 f0 ldd [ %g1 + 0x3f0 ], %g2 ! 20467f0 <rtems_rfs_trace_flags><== NOT EXECUTED
rtems_rfs_trace_flags &= ~mask;
2013818: 90 28 80 08 andn %g2, %o0, %o0 <== NOT EXECUTED
201381c: 92 28 c0 09 andn %g3, %o1, %o1 <== NOT EXECUTED
2013820: d0 38 63 f0 std %o0, [ %g1 + 0x3f0 ] <== NOT EXECUTED
return state;
}
2013824: 90 10 00 02 mov %g2, %o0 <== NOT EXECUTED
2013828: 81 c3 e0 08 retl <== NOT EXECUTED
201382c: 92 10 00 03 mov %g3, %o1 <== NOT EXECUTED
020137f0 <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;
20137f0: 03 00 81 19 sethi %hi(0x2046400), %g1 <== NOT EXECUTED
20137f4: c4 18 63 f0 ldd [ %g1 + 0x3f0 ], %g2 ! 20467f0 <rtems_rfs_trace_flags><== NOT EXECUTED
rtems_rfs_trace_flags |= mask;
20137f8: 90 12 00 02 or %o0, %g2, %o0 <== NOT EXECUTED
20137fc: 92 12 40 03 or %o1, %g3, %o1 <== NOT EXECUTED
2013800: d0 38 63 f0 std %o0, [ %g1 + 0x3f0 ] <== NOT EXECUTED
return state;
}
2013804: 90 10 00 02 mov %g2, %o0 <== NOT EXECUTED
2013808: 81 c3 e0 08 retl <== NOT EXECUTED
201380c: 92 10 00 03 mov %g3, %o1 <== NOT EXECUTED
02013830 <rtems_rfs_trace_shell_command>:
int
rtems_rfs_trace_shell_command (int argc, char *argv[])
{
2013830: 9d e3 be f8 save %sp, -264, %sp <== NOT EXECUTED
const char* table[] =
2013834: 13 00 80 cc sethi %hi(0x2033000), %o1 <== NOT EXECUTED
2013838: 90 07 bf 64 add %fp, -156, %o0 <== NOT EXECUTED
201383c: 92 12 62 e4 or %o1, 0x2e4, %o1 <== NOT EXECUTED
2013840: 94 10 20 9c mov 0x9c, %o2 <== NOT EXECUTED
return 1;
}
}
else
{
if (strcmp (argv[arg], "set") == 0)
2013844: 29 00 80 c3 sethi %hi(0x2030c00), %l4 <== NOT EXECUTED
set = true;
if (strcmp (argv[arg], "clear") == 0)
2013848: 2b 00 80 cc sethi %hi(0x2033000), %l5 <== NOT EXECUTED
}
int
rtems_rfs_trace_shell_command (int argc, char *argv[])
{
const char* table[] =
201384c: 40 00 39 1e call 2021cc4 <memcpy> <== NOT EXECUTED
2013850: 2d 00 80 cc sethi %hi(0x2033000), %l6 <== NOT EXECUTED
rtems_rfs_trace_mask clear_value = 0;
bool set = true;
int arg;
int t;
for (arg = 1; arg < argc; arg++)
2013854: 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;
2013858: 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;
201385c: b4 10 20 00 clr %i2 <== NOT EXECUTED
2013860: b6 10 20 00 clr %i3 <== NOT EXECUTED
"file-close",
"file-io",
"file-set"
};
rtems_rfs_trace_mask set_value = 0;
2013864: b8 10 20 00 clr %i4 <== NOT EXECUTED
2013868: ba 10 20 00 clr %i5 <== NOT EXECUTED
return 1;
}
}
else
{
if (strcmp (argv[arg], "set") == 0)
201386c: a8 15 22 20 or %l4, 0x220, %l4 <== NOT EXECUTED
set = true;
if (strcmp (argv[arg], "clear") == 0)
2013870: aa 15 60 78 or %l5, 0x78, %l5 <== NOT EXECUTED
set = false;
else if (strcmp (argv[arg], "all") == 0)
2013874: ac 15 a0 80 or %l6, 0x80, %l6 <== NOT EXECUTED
rtems_rfs_trace_mask clear_value = 0;
bool set = true;
int arg;
int t;
for (arg = 1; arg < argc; arg++)
2013878: 10 80 00 68 b 2013a18 <rtems_rfs_trace_shell_command+0x1e8><== NOT EXECUTED
201387c: 27 00 81 19 sethi %hi(0x2046400), %l3 <== NOT EXECUTED
{
if (argv[arg][0] == '-')
2013880: e0 06 40 01 ld [ %i1 + %g1 ], %l0 <== NOT EXECUTED
2013884: c2 4c 00 00 ldsb [ %l0 ], %g1 <== NOT EXECUTED
2013888: 80 a0 60 2d cmp %g1, 0x2d <== NOT EXECUTED
201388c: 12 80 00 25 bne 2013920 <rtems_rfs_trace_shell_command+0xf0><== NOT EXECUTED
2013890: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
{
switch (argv[arg][1])
2013894: c2 4c 20 01 ldsb [ %l0 + 1 ], %g1 <== NOT EXECUTED
2013898: 80 a0 60 68 cmp %g1, 0x68 <== NOT EXECUTED
201389c: 02 80 00 06 be 20138b4 <rtems_rfs_trace_shell_command+0x84><== NOT EXECUTED
20138a0: 80 a0 60 6c cmp %g1, 0x6c <== NOT EXECUTED
20138a4: 32 80 00 1a bne,a 201390c <rtems_rfs_trace_shell_command+0xdc><== NOT EXECUTED
20138a8: 11 00 80 cc sethi %hi(0x2033000), %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]);
20138ac: 10 80 00 08 b 20138cc <rtems_rfs_trace_shell_command+0x9c><== NOT EXECUTED
20138b0: 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]);
20138b4: d2 06 40 00 ld [ %i1 ], %o1 <== NOT EXECUTED
20138b8: 11 00 80 cc sethi %hi(0x2033000), %o0 <== NOT EXECUTED
20138bc: 40 00 3a 0f call 20220f8 <printf> <== NOT EXECUTED
20138c0: 90 12 20 08 or %o0, 8, %o0 ! 2033008 <rtems_rfs_rtems_eval_config+0x30><== 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;
20138c4: 81 c7 e0 08 ret <== NOT EXECUTED
20138c8: 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]);
20138cc: 11 00 80 cc sethi %hi(0x2033000), %o0 <== NOT EXECUTED
for (t = 0; t < (sizeof (table) / sizeof (const char*)); t++)
printf (" %s\n", table[t]);
20138d0: 39 00 80 cc sethi %hi(0x2033000), %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]);
20138d4: 90 12 20 30 or %o0, 0x30, %o0 <== NOT EXECUTED
20138d8: 40 00 3a 08 call 20220f8 <printf> <== NOT EXECUTED
20138dc: ba 10 20 00 clr %i5 <== NOT EXECUTED
for (t = 0; t < (sizeof (table) / sizeof (const char*)); t++)
printf (" %s\n", table[t]);
20138e0: b8 17 20 58 or %i4, 0x58, %i4 <== NOT EXECUTED
20138e4: 82 07 bf 64 add %fp, -156, %g1 <== NOT EXECUTED
20138e8: d2 00 40 1d ld [ %g1 + %i5 ], %o1 <== NOT EXECUTED
20138ec: 40 00 3a 03 call 20220f8 <printf> <== NOT EXECUTED
20138f0: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
20138f4: 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++)
20138f8: 80 a7 60 9c cmp %i5, 0x9c <== NOT EXECUTED
20138fc: 12 bf ff fb bne 20138e8 <rtems_rfs_trace_shell_command+0xb8><== NOT EXECUTED
2013900: 82 07 bf 64 add %fp, -156, %g1 <== NOT EXECUTED
printf (" %s\n", table[t]);
return 0;
2013904: 81 c7 e0 08 ret <== NOT EXECUTED
2013908: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED
default:
printf ("error: unknown option\n");
return 1;
201390c: 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");
2013910: 40 00 3a 92 call 2022358 <puts> <== NOT EXECUTED
2013914: 90 12 20 60 or %o0, 0x60, %o0 <== NOT EXECUTED
2013918: 81 c7 e0 08 ret <== NOT EXECUTED
201391c: 81 e8 00 00 restore <== NOT EXECUTED
return 1;
}
}
else
{
if (strcmp (argv[arg], "set") == 0)
2013920: 40 00 3c 80 call 2022b20 <strcmp> <== NOT EXECUTED
2013924: 92 10 00 14 mov %l4, %o1 <== NOT EXECUTED
2013928: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
201392c: 22 80 00 02 be,a 2013934 <rtems_rfs_trace_shell_command+0x104><== NOT EXECUTED
2013930: a4 10 20 01 mov 1, %l2 <== NOT EXECUTED
set = true;
if (strcmp (argv[arg], "clear") == 0)
2013934: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
2013938: 40 00 3c 7a call 2022b20 <strcmp> <== NOT EXECUTED
201393c: 92 10 00 15 mov %l5, %o1 <== NOT EXECUTED
2013940: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2013944: 22 80 00 2e be,a 20139fc <rtems_rfs_trace_shell_command+0x1cc><== NOT EXECUTED
2013948: a4 10 20 00 clr %l2 <== NOT EXECUTED
set = false;
else if (strcmp (argv[arg], "all") == 0)
201394c: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
2013950: 40 00 3c 74 call 2022b20 <strcmp> <== NOT EXECUTED
2013954: 92 10 00 16 mov %l6, %o1 <== NOT EXECUTED
2013958: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
201395c: 12 80 00 09 bne 2013980 <rtems_rfs_trace_shell_command+0x150><== NOT EXECUTED
2013960: 94 10 20 00 clr %o2 <== NOT EXECUTED
{
if (set)
2013964: 80 8c a0 ff btst 0xff, %l2 <== NOT EXECUTED
2013968: 22 80 00 23 be,a 20139f4 <rtems_rfs_trace_shell_command+0x1c4><== NOT EXECUTED
201396c: 35 3f ff ff sethi %hi(0xfffffc00), %i2 <== NOT EXECUTED
set_value = RTEMS_RFS_TRACE_ALL;
2013970: 39 3f ff ff sethi %hi(0xfffffc00), %i4 <== NOT EXECUTED
2013974: b8 17 23 ff or %i4, 0x3ff, %i4 ! ffffffff <RAM_END+0xfdbfffff><== NOT EXECUTED
2013978: 10 80 00 21 b 20139fc <rtems_rfs_trace_shell_command+0x1cc><== NOT EXECUTED
201397c: 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[])
2013980: 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)
2013984: 84 07 bf 64 add %fp, -156, %g2 <== NOT EXECUTED
2013988: d2 00 80 01 ld [ %g2 + %g1 ], %o1 <== NOT EXECUTED
201398c: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
2013990: 40 00 3c 64 call 2022b20 <strcmp> <== NOT EXECUTED
2013994: d4 27 bf 5c st %o2, [ %fp + -164 ] <== NOT EXECUTED
2013998: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
201399c: 12 80 00 10 bne 20139dc <rtems_rfs_trace_shell_command+0x1ac><== NOT EXECUTED
20139a0: d4 07 bf 5c ld [ %fp + -164 ], %o2 <== NOT EXECUTED
{
if (set)
set_value = 1ULL << t;
20139a4: 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)
20139a8: 80 8c a0 ff btst 0xff, %l2 <== NOT EXECUTED
20139ac: 02 80 00 07 be 20139c8 <rtems_rfs_trace_shell_command+0x198><== NOT EXECUTED
20139b0: 92 10 20 01 mov 1, %o1 <== NOT EXECUTED
set_value = 1ULL << t;
20139b4: 40 00 6b 4d call 202e6e8 <__ashldi3> <== NOT EXECUTED
20139b8: 01 00 00 00 nop <== NOT EXECUTED
20139bc: b8 10 00 08 mov %o0, %i4 <== NOT EXECUTED
20139c0: 10 80 00 0f b 20139fc <rtems_rfs_trace_shell_command+0x1cc><== NOT EXECUTED
20139c4: ba 10 00 09 mov %o1, %i5 <== NOT EXECUTED
else
clear_value = 1ULL << t;
20139c8: 40 00 6b 48 call 202e6e8 <__ashldi3> <== NOT EXECUTED
20139cc: 01 00 00 00 nop <== NOT EXECUTED
20139d0: b4 10 00 08 mov %o0, %i2 <== NOT EXECUTED
20139d4: 10 80 00 0a b 20139fc <rtems_rfs_trace_shell_command+0x1cc><== NOT EXECUTED
20139d8: 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++)
20139dc: 94 02 a0 01 inc %o2 <== NOT EXECUTED
20139e0: 80 a2 a0 27 cmp %o2, 0x27 <== NOT EXECUTED
20139e4: 12 bf ff e8 bne 2013984 <rtems_rfs_trace_shell_command+0x154><== NOT EXECUTED
20139e8: 83 2a a0 02 sll %o2, 2, %g1 <== NOT EXECUTED
break;
}
}
}
rtems_rfs_trace_flags |= set_value;
20139ec: 10 80 00 05 b 2013a00 <rtems_rfs_trace_shell_command+0x1d0><== NOT EXECUTED
20139f0: c4 1c e3 f0 ldd [ %l3 + 0x3f0 ], %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;
20139f4: b4 16 a3 ff or %i2, 0x3ff, %i2 <== NOT EXECUTED
20139f8: b6 10 00 1a mov %i2, %i3 <== NOT EXECUTED
break;
}
}
}
rtems_rfs_trace_flags |= set_value;
20139fc: c4 1c e3 f0 ldd [ %l3 + 0x3f0 ], %g2 <== NOT EXECUTED
rtems_rfs_trace_mask clear_value = 0;
bool set = true;
int arg;
int t;
for (arg = 1; arg < argc; arg++)
2013a00: a2 04 60 01 inc %l1 <== NOT EXECUTED
break;
}
}
}
rtems_rfs_trace_flags |= set_value;
2013a04: 84 17 00 02 or %i4, %g2, %g2 <== NOT EXECUTED
2013a08: 86 17 40 03 or %i5, %g3, %g3 <== NOT EXECUTED
rtems_rfs_trace_flags &= ~clear_value;
2013a0c: 84 28 80 1a andn %g2, %i2, %g2 <== NOT EXECUTED
2013a10: 86 28 c0 1b andn %g3, %i3, %g3 <== NOT EXECUTED
2013a14: c4 3c e3 f0 std %g2, [ %l3 + 0x3f0 ] <== NOT EXECUTED
rtems_rfs_trace_mask clear_value = 0;
bool set = true;
int arg;
int t;
for (arg = 1; arg < argc; arg++)
2013a18: 80 a4 40 18 cmp %l1, %i0 <== NOT EXECUTED
2013a1c: 06 bf ff 99 bl 2013880 <rtems_rfs_trace_shell_command+0x50><== NOT EXECUTED
2013a20: 83 2c 60 02 sll %l1, 2, %g1 <== NOT EXECUTED
2013a24: 30 bf ff b8 b,a 2013904 <rtems_rfs_trace_shell_command+0xd4><== NOT EXECUTED
0201e874 <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)
{
201e874: 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))
201e878: 90 10 20 00 clr %o0
201e87c: 7f ff d3 d5 call 20137d0 <rtems_rfs_trace>
201e880: 13 00 80 00 sethi %hi(0x2000000), %o1
201e884: 80 8a 20 ff btst 0xff, %o0
201e888: 02 80 00 08 be 201e8a8 <rtems_rfs_unlink+0x34> <== ALWAYS TAKEN
201e88c: 90 10 00 18 mov %i0, %o0
printf ("rtems-rfs: unlink: parent(%" PRIu32 ") -X-> (%" PRIu32 ")\n", parent, target);
201e890: 11 00 80 d2 sethi %hi(0x2034800), %o0 <== NOT EXECUTED
201e894: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
201e898: 90 12 23 10 or %o0, 0x310, %o0 <== NOT EXECUTED
201e89c: 40 00 0e 17 call 20220f8 <printf> <== NOT EXECUTED
201e8a0: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED
rc = rtems_rfs_inode_open (fs, target, &target_inode, true);
201e8a4: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
201e8a8: 92 10 00 1a mov %i2, %o1
201e8ac: 94 07 bf d8 add %fp, -40, %o2
201e8b0: 7f ff cd 37 call 2011d8c <rtems_rfs_inode_open>
201e8b4: 96 10 20 01 mov 1, %o3
if (rc)
201e8b8: ba 92 20 00 orcc %o0, 0, %i5
201e8bc: 12 80 00 d7 bne 201ec18 <rtems_rfs_unlink+0x3a4> <== NEVER TAKEN
201e8c0: 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));
201e8c4: 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);
201e8c8: c2 08 60 02 ldub [ %g1 + 2 ], %g1
201e8cc: 83 28 60 08 sll %g1, 8, %g1
201e8d0: 82 08 40 02 and %g1, %g2, %g1
201e8d4: 05 00 00 10 sethi %hi(0x4000), %g2
201e8d8: 82 18 40 02 xor %g1, %g2, %g1
201e8dc: 80 a0 00 01 cmp %g0, %g1
201e8e0: a0 60 3f ff subx %g0, -1, %l0
if (dir)
201e8e4: 80 8c 20 ff btst 0xff, %l0
201e8e8: 02 80 00 26 be 201e980 <rtems_rfs_unlink+0x10c>
201e8ec: 80 a7 20 00 cmp %i4, 0
{
switch (dir_mode)
201e8f0: 22 80 00 06 be,a 201e908 <rtems_rfs_unlink+0x94> <== NEVER TAKEN
201e8f4: 90 10 20 00 clr %o0 <== NOT EXECUTED
201e8f8: 80 a7 20 01 cmp %i4, 1
201e8fc: 12 80 00 22 bne 201e984 <rtems_rfs_unlink+0x110> <== NEVER TAKEN
201e900: 90 10 00 18 mov %i0, %o0
201e904: 30 80 00 0f b,a 201e940 <rtems_rfs_unlink+0xcc>
{
case rtems_rfs_unlink_dir_denied:
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
201e908: 7f ff d3 b2 call 20137d0 <rtems_rfs_trace> <== NOT EXECUTED
201e90c: 13 00 80 00 sethi %hi(0x2000000), %o1 <== NOT EXECUTED
201e910: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
201e914: 22 80 00 06 be,a 201e92c <rtems_rfs_unlink+0xb8> <== NOT EXECUTED
201e918: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
printf ("rtems-rfs: link is a directory\n");
201e91c: 11 00 80 d2 sethi %hi(0x2034800), %o0 <== NOT EXECUTED
201e920: 40 00 0e 8e call 2022358 <puts> <== NOT EXECUTED
201e924: 90 12 23 40 or %o0, 0x340, %o0 ! 2034b40 <CSWTCH.2+0x1460><== NOT EXECUTED
rtems_rfs_inode_close (fs, &target_inode);
201e928: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
201e92c: 92 07 bf d8 add %fp, -40, %o1 <== NOT EXECUTED
201e930: 7f ff cd 89 call 2011f54 <rtems_rfs_inode_close> <== NOT EXECUTED
201e934: 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;
}
201e938: 81 c7 e0 08 ret <== NOT EXECUTED
201e93c: 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);
201e940: 7f ff f8 dc call 201ccb0 <rtems_rfs_dir_empty>
201e944: 92 07 bf d8 add %fp, -40, %o1
if (rc > 0)
201e948: ba 92 20 00 orcc %o0, 0, %i5
201e94c: 04 80 00 0d ble 201e980 <rtems_rfs_unlink+0x10c>
201e950: 90 10 20 00 clr %o0
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
201e954: 7f ff d3 9f call 20137d0 <rtems_rfs_trace>
201e958: 13 00 80 00 sethi %hi(0x2000000), %o1
201e95c: 80 8a 20 ff btst 0xff, %o0
201e960: 22 80 00 97 be,a 201ebbc <rtems_rfs_unlink+0x348> <== ALWAYS TAKEN
201e964: 90 10 00 18 mov %i0, %o0
printf ("rtems-rfs: dir-empty: %d: %s\n", rc, strerror (rc));
201e968: 40 00 12 53 call 20232b4 <strerror> <== NOT EXECUTED
201e96c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
201e970: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
201e974: 11 00 80 d2 sethi %hi(0x2034800), %o0 <== NOT EXECUTED
201e978: 10 80 00 8e b 201ebb0 <rtems_rfs_unlink+0x33c> <== NOT EXECUTED
201e97c: 90 12 23 60 or %o0, 0x360, %o0 ! 2034b60 <CSWTCH.2+0x1480><== NOT EXECUTED
default:
break;
}
}
rc = rtems_rfs_inode_open (fs, parent, &parent_inode, true);
201e980: 90 10 00 18 mov %i0, %o0
201e984: 92 10 00 19 mov %i1, %o1
201e988: 94 07 bf b0 add %fp, -80, %o2
201e98c: 7f ff cd 00 call 2011d8c <rtems_rfs_inode_open>
201e990: 96 10 20 01 mov 1, %o3
if (rc)
201e994: ba 92 20 00 orcc %o0, 0, %i5
201e998: 02 80 00 0e be 201e9d0 <rtems_rfs_unlink+0x15c> <== ALWAYS TAKEN
201e99c: 90 10 00 18 mov %i0, %o0
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
201e9a0: 90 10 20 00 clr %o0 <== NOT EXECUTED
201e9a4: 7f ff d3 8b call 20137d0 <rtems_rfs_trace> <== NOT EXECUTED
201e9a8: 13 00 80 00 sethi %hi(0x2000000), %o1 <== NOT EXECUTED
201e9ac: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
201e9b0: 22 80 00 83 be,a 201ebbc <rtems_rfs_unlink+0x348> <== NOT EXECUTED
201e9b4: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
printf ("rtems-rfs: link: inode-open failed: %d: %s\n",
201e9b8: 40 00 12 3f call 20232b4 <strerror> <== NOT EXECUTED
201e9bc: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
201e9c0: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
201e9c4: 11 00 80 d2 sethi %hi(0x2034800), %o0 <== NOT EXECUTED
201e9c8: 10 80 00 7a b 201ebb0 <rtems_rfs_unlink+0x33c> <== NOT EXECUTED
201e9cc: 90 12 23 80 or %o0, 0x380, %o0 ! 2034b80 <CSWTCH.2+0x14a0><== 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);
201e9d0: 92 07 bf b0 add %fp, -80, %o1
201e9d4: 94 10 00 1a mov %i2, %o2
201e9d8: 7f ff f6 d6 call 201c530 <rtems_rfs_dir_del_entry>
201e9dc: 96 10 00 1b mov %i3, %o3
if (rc > 0)
201e9e0: ba 92 20 00 orcc %o0, 0, %i5
201e9e4: 04 80 00 0e ble 201ea1c <rtems_rfs_unlink+0x1a8> <== ALWAYS TAKEN
201e9e8: 01 00 00 00 nop
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
201e9ec: 90 10 20 00 clr %o0 ! 0 <PROM_START> <== NOT EXECUTED
201e9f0: 7f ff d3 78 call 20137d0 <rtems_rfs_trace> <== NOT EXECUTED
201e9f4: 13 00 80 00 sethi %hi(0x2000000), %o1 <== NOT EXECUTED
201e9f8: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
201e9fc: 22 80 00 59 be,a 201eb60 <rtems_rfs_unlink+0x2ec> <== NOT EXECUTED
201ea00: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
printf ("rtems-rfs: unlink: dir-del failed: %d: %s\n",
201ea04: 40 00 12 2c call 20232b4 <strerror> <== NOT EXECUTED
201ea08: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
201ea0c: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
201ea10: 11 00 80 d2 sethi %hi(0x2034800), %o0 <== NOT EXECUTED
201ea14: 10 80 00 50 b 201eb54 <rtems_rfs_unlink+0x2e0> <== NOT EXECUTED
201ea18: 90 12 23 b0 or %o0, 0x3b0, %o0 ! 2034bb0 <CSWTCH.2+0x14d0><== 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);
201ea1c: 7f ff ff 1e call 201e694 <rtems_rfs_inode_get_links>
201ea20: 90 07 bf d8 add %fp, -40, %o0
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
201ea24: 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);
201ea28: ba 10 00 08 mov %o0, %i5
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
201ea2c: 7f ff d3 69 call 20137d0 <rtems_rfs_trace>
201ea30: 90 10 20 00 clr %o0
201ea34: 80 8a 20 ff btst 0xff, %o0
201ea38: 02 80 00 09 be 201ea5c <rtems_rfs_unlink+0x1e8> <== ALWAYS TAKEN
201ea3c: 83 2f 60 10 sll %i5, 0x10, %g1
printf ("rtems-rfs: unlink: target:%" PRIu32 " links:%u\n", target, links);
201ea40: 95 2f 60 10 sll %i5, 0x10, %o2 <== NOT EXECUTED
201ea44: 11 00 80 d2 sethi %hi(0x2034800), %o0 <== NOT EXECUTED
201ea48: 92 10 00 1a mov %i2, %o1 <== NOT EXECUTED
201ea4c: 90 12 23 e0 or %o0, 0x3e0, %o0 <== NOT EXECUTED
201ea50: 40 00 0d aa call 20220f8 <printf> <== NOT EXECUTED
201ea54: 95 32 a0 10 srl %o2, 0x10, %o2 <== NOT EXECUTED
if (links > 1)
201ea58: 83 2f 60 10 sll %i5, 0x10, %g1 <== NOT EXECUTED
201ea5c: 83 30 60 10 srl %g1, 0x10, %g1
201ea60: 80 a0 60 01 cmp %g1, 1
201ea64: 08 80 00 0a bleu 201ea8c <rtems_rfs_unlink+0x218>
201ea68: c2 07 bf e4 ld [ %fp + -28 ], %g1
{
links--;
201ea6c: 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);
201ea70: 85 37 60 08 srl %i5, 8, %g2
201ea74: c4 28 40 00 stb %g2, [ %g1 ]
201ea78: c2 07 bf e4 ld [ %fp + -28 ], %g1
201ea7c: fa 28 60 01 stb %i5, [ %g1 + 1 ]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
201ea80: 82 10 20 01 mov 1, %g1
201ea84: 10 80 00 23 b 201eb10 <rtems_rfs_unlink+0x29c>
201ea88: 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);
201ea8c: 90 10 00 18 mov %i0, %o0
201ea90: 7f ff cd 54 call 2011fe0 <rtems_rfs_inode_delete>
201ea94: 92 07 bf d8 add %fp, -40, %o1
if (rc > 0)
201ea98: ba 92 20 00 orcc %o0, 0, %i5
201ea9c: 04 80 00 0d ble 201ead0 <rtems_rfs_unlink+0x25c> <== ALWAYS TAKEN
201eaa0: 90 10 20 00 clr %o0
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
201eaa4: 7f ff d3 4b call 20137d0 <rtems_rfs_trace> <== NOT EXECUTED
201eaa8: 13 00 80 00 sethi %hi(0x2000000), %o1 <== NOT EXECUTED
201eaac: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
201eab0: 22 80 00 2c be,a 201eb60 <rtems_rfs_unlink+0x2ec> <== NOT EXECUTED
201eab4: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
printf ("rtems-rfs: unlink: inode-del failed: %d: %s\n",
201eab8: 40 00 11 ff call 20232b4 <strerror> <== NOT EXECUTED
201eabc: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
201eac0: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
201eac4: 11 00 80 d3 sethi %hi(0x2034c00), %o0 <== NOT EXECUTED
201eac8: 10 80 00 23 b 201eb54 <rtems_rfs_unlink+0x2e0> <== NOT EXECUTED
201eacc: 90 12 20 08 or %o0, 8, %o0 ! 2034c08 <CSWTCH.2+0x1528> <== NOT EXECUTED
rtems_rfs_inode_close (fs, &parent_inode);
rtems_rfs_inode_close (fs, &target_inode);
return rc;
}
if (dir)
201ead0: 80 8c 20 ff btst 0xff, %l0
201ead4: 02 80 00 10 be 201eb14 <rtems_rfs_unlink+0x2a0>
201ead8: 90 07 bf b0 add %fp, -80, %o0
{
links = rtems_rfs_inode_get_links (&parent_inode);
201eadc: 7f ff fe ee call 201e694 <rtems_rfs_inode_get_links>
201eae0: 90 07 bf b0 add %fp, -80, %o0
if (links > 1)
201eae4: 80 a2 20 01 cmp %o0, 1
201eae8: 08 80 00 03 bleu 201eaf4 <rtems_rfs_unlink+0x280>
201eaec: 82 10 00 08 mov %o0, %g1
links--;
201eaf0: 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);
201eaf4: c4 07 bf bc ld [ %fp + -68 ], %g2
201eaf8: 87 30 60 08 srl %g1, 8, %g3
201eafc: c6 28 80 00 stb %g3, [ %g2 ]
201eb00: c4 07 bf bc ld [ %fp + -68 ], %g2
201eb04: c2 28 a0 01 stb %g1, [ %g2 + 1 ]
rtems_rfs_buffer_mark_dirty (&handle->buffer);
201eb08: 82 10 20 01 mov 1, %g1
201eb0c: 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);
201eb10: 90 07 bf b0 add %fp, -80, %o0
201eb14: 92 10 20 01 mov 1, %o1
201eb18: 7f ff cd 67 call 20120b4 <rtems_rfs_inode_time_stamp_now>
201eb1c: 94 10 20 01 mov 1, %o2
if (rc > 0)
201eb20: ba 92 20 00 orcc %o0, 0, %i5
201eb24: 04 80 00 13 ble 201eb70 <rtems_rfs_unlink+0x2fc> <== ALWAYS TAKEN
201eb28: 90 10 20 00 clr %o0
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
201eb2c: 7f ff d3 29 call 20137d0 <rtems_rfs_trace> <== NOT EXECUTED
201eb30: 13 00 80 00 sethi %hi(0x2000000), %o1 <== NOT EXECUTED
201eb34: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
201eb38: 22 80 00 0a be,a 201eb60 <rtems_rfs_unlink+0x2ec> <== NOT EXECUTED
201eb3c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
printf ("rtems-rfs: link: inode-time-stamp failed: %d: %s\n",
201eb40: 40 00 11 dd call 20232b4 <strerror> <== NOT EXECUTED
201eb44: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
201eb48: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
201eb4c: 11 00 80 d3 sethi %hi(0x2034c00), %o0 <== NOT EXECUTED
201eb50: 90 12 20 38 or %o0, 0x38, %o0 ! 2034c38 <CSWTCH.2+0x1558> <== NOT EXECUTED
201eb54: 40 00 0d 69 call 20220f8 <printf> <== NOT EXECUTED
201eb58: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
rc, strerror (rc));
rtems_rfs_inode_close (fs, &parent_inode);
201eb5c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
201eb60: 7f ff cc fd call 2011f54 <rtems_rfs_inode_close> <== NOT EXECUTED
201eb64: 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);
201eb68: 10 80 00 15 b 201ebbc <rtems_rfs_unlink+0x348> <== NOT EXECUTED
201eb6c: 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);
201eb70: 90 10 00 18 mov %i0, %o0
201eb74: 7f ff cc f8 call 2011f54 <rtems_rfs_inode_close>
201eb78: 92 07 bf b0 add %fp, -80, %o1
if (rc > 0)
201eb7c: ba 92 20 00 orcc %o0, 0, %i5
201eb80: 04 80 00 13 ble 201ebcc <rtems_rfs_unlink+0x358> <== ALWAYS TAKEN
201eb84: 90 10 20 00 clr %o0
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
201eb88: 7f ff d3 12 call 20137d0 <rtems_rfs_trace> <== NOT EXECUTED
201eb8c: 13 00 80 00 sethi %hi(0x2000000), %o1 <== NOT EXECUTED
201eb90: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
201eb94: 02 80 00 0a be 201ebbc <rtems_rfs_unlink+0x348> <== NOT EXECUTED
201eb98: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
printf ("rtems-rfs: link: parent inode-close failed: %d: %s\n",
201eb9c: 40 00 11 c6 call 20232b4 <strerror> <== NOT EXECUTED
201eba0: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
201eba4: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
201eba8: 11 00 80 d3 sethi %hi(0x2034c00), %o0 <== NOT EXECUTED
201ebac: 90 12 20 70 or %o0, 0x70, %o0 ! 2034c70 <CSWTCH.2+0x1590> <== NOT EXECUTED
201ebb0: 40 00 0d 52 call 20220f8 <printf> <== NOT EXECUTED
201ebb4: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
rc, strerror (rc));
rtems_rfs_inode_close (fs, &target_inode);
201ebb8: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
201ebbc: 7f ff cc e6 call 2011f54 <rtems_rfs_inode_close>
201ebc0: 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;
}
201ebc4: 81 c7 e0 08 ret
201ebc8: 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);
201ebcc: 90 10 00 18 mov %i0, %o0
201ebd0: 7f ff cc e1 call 2011f54 <rtems_rfs_inode_close>
201ebd4: 92 07 bf d8 add %fp, -40, %o1
if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
201ebd8: ba 92 20 00 orcc %o0, 0, %i5
201ebdc: 04 80 00 10 ble 201ec1c <rtems_rfs_unlink+0x3a8> <== ALWAYS TAKEN
201ebe0: b0 10 00 1d mov %i5, %i0
201ebe4: 90 10 20 00 clr %o0 <== NOT EXECUTED
201ebe8: 7f ff d2 fa call 20137d0 <rtems_rfs_trace> <== NOT EXECUTED
201ebec: 13 00 80 00 sethi %hi(0x2000000), %o1 <== NOT EXECUTED
201ebf0: 80 8a 20 ff btst 0xff, %o0 <== NOT EXECUTED
201ebf4: 22 80 00 0a be,a 201ec1c <rtems_rfs_unlink+0x3a8> <== NOT EXECUTED
201ebf8: b0 10 00 1d mov %i5, %i0 <== NOT EXECUTED
printf ("rtems-rfs: link: target inode-close failed: %d: %s\n",
201ebfc: 40 00 11 ae call 20232b4 <strerror> <== NOT EXECUTED
201ec00: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
201ec04: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
201ec08: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
201ec0c: 11 00 80 d3 sethi %hi(0x2034c00), %o0 <== NOT EXECUTED
201ec10: 40 00 0d 3a call 20220f8 <printf> <== NOT EXECUTED
201ec14: 90 12 20 a8 or %o0, 0xa8, %o0 ! 2034ca8 <CSWTCH.2+0x15c8> <== NOT EXECUTED
rc, strerror (rc));
return rc;
}
201ec18: b0 10 00 1d mov %i5, %i0 <== NOT EXECUTED
201ec1c: 81 c7 e0 08 ret
201ec20: 81 e8 00 00 restore
020209a8 <rtems_shell_debugrfs>:
}
int
rtems_shell_debugrfs (int argc, char *argv[])
{
20209a8: 9d e3 be f0 save %sp, -272, %sp <== NOT EXECUTED
const rtems_rfs_shell_cmd table[] =
20209ac: 13 00 81 5f sethi %hi(0x2057c00), %o1 <== NOT EXECUTED
20209b0: b8 07 bf c4 add %fp, -60, %i4 <== NOT EXECUTED
20209b4: 92 12 61 90 or %o1, 0x190, %o1 <== NOT EXECUTED
20209b8: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
20209bc: 40 00 64 af call 2039c78 <memcpy> <== NOT EXECUTED
20209c0: 94 10 20 3c mov 0x3c, %o2 <== NOT EXECUTED
};
int arg;
int t;
for (arg = 1; arg < argc; arg++)
20209c4: 80 a6 20 01 cmp %i0, 1 <== NOT EXECUTED
20209c8: 04 80 00 28 ble 2020a68 <rtems_shell_debugrfs+0xc0> <== NOT EXECUTED
20209cc: 11 00 81 5e sethi %hi(0x2057800), %o0 <== NOT EXECUTED
{
if (argv[arg][0] != '-')
20209d0: fa 06 60 04 ld [ %i1 + 4 ], %i5 <== NOT EXECUTED
20209d4: c2 4f 40 00 ldsb [ %i5 ], %g1 <== NOT EXECUTED
20209d8: 80 a0 60 2d cmp %g1, 0x2d <== NOT EXECUTED
20209dc: 12 80 00 20 bne 2020a5c <rtems_shell_debugrfs+0xb4> <== NOT EXECUTED
20209e0: 80 a6 20 02 cmp %i0, 2 <== NOT EXECUTED
break;
switch (argv[arg][1])
20209e4: c2 4f 60 01 ldsb [ %i5 + 1 ], %g1 <== NOT EXECUTED
20209e8: 80 a0 60 68 cmp %g1, 0x68 <== NOT EXECUTED
20209ec: 02 80 00 07 be 2020a08 <rtems_shell_debugrfs+0x60> <== NOT EXECUTED
20209f0: 11 00 81 5e sethi %hi(0x2057800), %o0 <== NOT EXECUTED
20209f4: 80 a0 60 6c cmp %g1, 0x6c <== NOT EXECUTED
20209f8: 12 80 00 38 bne 2020ad8 <rtems_shell_debugrfs+0x130> <== NOT EXECUTED
20209fc: 90 12 22 38 or %o0, 0x238, %o0 <== NOT EXECUTED
{
case 'h':
rtems_rfs_shell_usage (argv[0]);
return 0;
case 'l':
printf ("%s: commands are:\n", argv[0]);
2020a00: 10 80 00 06 b 2020a18 <rtems_shell_debugrfs+0x70> <== NOT EXECUTED
2020a04: d2 06 40 00 ld [ %i1 ], %o1 <== NOT EXECUTED
break;
switch (argv[arg][1])
{
case 'h':
rtems_rfs_shell_usage (argv[0]);
2020a08: 7f ff ff cf call 2020944 <rtems_rfs_shell_usage> <== NOT EXECUTED
2020a0c: 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;
2020a10: 81 c7 e0 08 ret <== NOT EXECUTED
2020a14: 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]);
2020a18: 11 00 81 5e sethi %hi(0x2057800), %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);
2020a1c: 37 00 81 5e sethi %hi(0x2057800), %i3 <== NOT EXECUTED
{
case 'h':
rtems_rfs_shell_usage (argv[0]);
return 0;
case 'l':
printf ("%s: commands are:\n", argv[0]);
2020a20: 90 12 22 10 or %o0, 0x210, %o0 <== NOT EXECUTED
2020a24: 40 00 69 95 call 203b078 <printf> <== NOT EXECUTED
2020a28: 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);
2020a2c: b6 16 e2 28 or %i3, 0x228, %i3 <== NOT EXECUTED
printf (" -h: This help\n");
printf (" -l: The debugger command list.\n");
}
int
rtems_shell_debugrfs (int argc, char *argv[])
2020a30: 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);
2020a34: d2 07 00 1d ld [ %i4 + %i5 ], %o1 <== NOT EXECUTED
2020a38: d4 00 60 08 ld [ %g1 + 8 ], %o2 <== NOT EXECUTED
2020a3c: 40 00 69 8f call 203b078 <printf> <== NOT EXECUTED
2020a40: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
2020a44: 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++)
2020a48: 80 a7 60 3c cmp %i5, 0x3c <== NOT EXECUTED
2020a4c: 12 bf ff fa bne 2020a34 <rtems_shell_debugrfs+0x8c> <== NOT EXECUTED
2020a50: 82 07 00 1d add %i4, %i5, %g1 <== NOT EXECUTED
printf (" %s\t\t%s\n", table[t].name, table[t].help);
return 0;
2020a54: 81 c7 e0 08 ret <== NOT EXECUTED
2020a58: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED
printf ("error: unknown option: %s\n", argv[arg]);
return 1;
}
}
if ((argc - arg) < 2)
2020a5c: 32 80 00 06 bne,a 2020a74 <rtems_shell_debugrfs+0xcc> <== NOT EXECUTED
2020a60: 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]);
2020a64: 11 00 81 5e sethi %hi(0x2057800), %o0 <== NOT EXECUTED
2020a68: d2 06 40 00 ld [ %i1 ], %o1 <== NOT EXECUTED
2020a6c: 10 80 00 42 b 2020b74 <rtems_shell_debugrfs+0x1cc> <== NOT EXECUTED
2020a70: 90 12 22 58 or %o0, 0x258, %o0 <== NOT EXECUTED
rtems_rfs_get_fs (const char* path, rtems_rfs_file_system** fs)
{
struct statvfs sb;
int rc;
rc = statvfs (path, &sb);
2020a74: 40 00 11 58 call 2024fd4 <statvfs> <== NOT EXECUTED
2020a78: 92 07 bf 50 add %fp, -176, %o1 <== NOT EXECUTED
if (rc < 0)
2020a7c: b8 92 20 00 orcc %o0, 0, %i4 <== NOT EXECUTED
2020a80: 16 80 00 0f bge 2020abc <rtems_shell_debugrfs+0x114> <== NOT EXECUTED
2020a84: c4 07 bf 7c ld [ %fp + -132 ], %g2 <== NOT EXECUTED
{
printf ("error: cannot statvfs path: %s: (%d) %s\n",
path, errno, strerror (errno));
2020a88: 40 00 57 3d call 203677c <__errno> <== NOT EXECUTED
2020a8c: b0 10 20 01 mov 1, %i0 <== NOT EXECUTED
2020a90: 40 00 57 3b call 203677c <__errno> <== NOT EXECUTED
2020a94: 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",
2020a98: 40 00 72 f7 call 203d674 <strerror> <== NOT EXECUTED
2020a9c: d0 02 00 00 ld [ %o0 ], %o0 <== NOT EXECUTED
2020aa0: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
2020aa4: 96 10 00 08 mov %o0, %o3 <== NOT EXECUTED
2020aa8: 94 10 00 1c mov %i4, %o2 <== NOT EXECUTED
2020aac: 11 00 81 5e sethi %hi(0x2057800), %o0 <== NOT EXECUTED
2020ab0: 40 00 69 72 call 203b078 <printf> <== NOT EXECUTED
2020ab4: 90 12 22 90 or %o0, 0x290, %o0 ! 2057a90 <rtems_rtc_shell_usage+0x15b0><== NOT EXECUTED
2020ab8: 30 80 00 31 b,a 2020b7c <rtems_shell_debugrfs+0x1d4> <== NOT EXECUTED
path, errno, strerror (errno));
return -1;
}
if (sb.f_fsid != RTEMS_RFS_SB_MAGIC)
2020abc: 03 0a 02 48 sethi %hi(0x28092000), %g1 <== NOT EXECUTED
2020ac0: 82 10 60 01 or %g1, 1, %g1 ! 28092001 <RAM_END+0x25c92001><== NOT EXECUTED
2020ac4: 80 a0 80 01 cmp %g2, %g1 <== NOT EXECUTED
2020ac8: 22 80 00 06 be,a 2020ae0 <rtems_shell_debugrfs+0x138> <== NOT EXECUTED
2020acc: 92 10 00 1d mov %i5, %o1 <== NOT EXECUTED
{
printf ("error: path '%s' is not on an RFS file system\n", path);
2020ad0: 11 00 81 5e sethi %hi(0x2057800), %o0 <== NOT EXECUTED
2020ad4: 90 12 22 c0 or %o0, 0x2c0, %o0 ! 2057ac0 <rtems_rtc_shell_usage+0x15e0><== NOT EXECUTED
2020ad8: 10 80 00 27 b 2020b74 <rtems_shell_debugrfs+0x1cc> <== NOT EXECUTED
2020adc: 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 =
2020ae0: 94 10 20 18 mov 0x18, %o2 <== NOT EXECUTED
2020ae4: 7f ff 8f 5d call 2004858 <rtems_filesystem_eval_path_start><== NOT EXECUTED
2020ae8: 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);
2020aec: c2 02 20 14 ld [ %o0 + 0x14 ], %g1 <== NOT EXECUTED
rtems_filesystem_eval_path_cleanup (&ctx);
2020af0: 90 07 bf 8c add %fp, -116, %o0 <== NOT EXECUTED
2020af4: 7f ff 8f 95 call 2004948 <rtems_filesystem_eval_path_cleanup><== NOT EXECUTED
2020af8: 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)
2020afc: 80 a7 20 00 cmp %i4, 0 <== NOT EXECUTED
2020b00: 32 80 00 1f bne,a 2020b7c <rtems_shell_debugrfs+0x1d4> <== NOT EXECUTED
2020b04: b0 10 20 01 mov 1, %i0 <== NOT EXECUTED
2020b08: 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)
2020b0c: 82 07 bf c4 add %fp, -60, %g1 <== NOT EXECUTED
2020b10: f6 06 60 08 ld [ %i1 + 8 ], %i3 <== NOT EXECUTED
2020b14: d2 00 40 1c ld [ %g1 + %i4 ], %o1 <== NOT EXECUTED
2020b18: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
2020b1c: 40 00 70 f1 call 203cee0 <strcmp> <== NOT EXECUTED
2020b20: b8 07 20 0c add %i4, 0xc, %i4 <== NOT EXECUTED
2020b24: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2020b28: 32 80 00 0d bne,a 2020b5c <rtems_shell_debugrfs+0x1b4> <== NOT EXECUTED
2020b2c: ba 07 60 01 inc %i5 <== NOT EXECUTED
return table[t].handler (fs, argc - 2, argv + 2);
2020b30: 83 2f 60 02 sll %i5, 2, %g1 <== NOT EXECUTED
2020b34: bb 2f 60 04 sll %i5, 4, %i5 <== NOT EXECUTED
2020b38: ba 27 40 01 sub %i5, %g1, %i5 <== NOT EXECUTED
2020b3c: ba 07 80 1d add %fp, %i5, %i5 <== NOT EXECUTED
2020b40: c2 07 7f c8 ld [ %i5 + -56 ], %g1 <== NOT EXECUTED
2020b44: 92 06 3f fe add %i0, -2, %o1 <== NOT EXECUTED
2020b48: 90 10 00 1a mov %i2, %o0 <== NOT EXECUTED
2020b4c: 9f c0 40 00 call %g1 <== NOT EXECUTED
2020b50: 94 06 60 08 add %i1, 8, %o2 <== NOT EXECUTED
2020b54: 81 c7 e0 08 ret <== NOT EXECUTED
2020b58: 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++)
2020b5c: 80 a7 60 05 cmp %i5, 5 <== NOT EXECUTED
2020b60: 12 bf ff ec bne 2020b10 <rtems_shell_debugrfs+0x168> <== NOT EXECUTED
2020b64: 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]);
2020b68: 11 00 81 5e sethi %hi(0x2057800), %o0 <== NOT EXECUTED
2020b6c: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED
2020b70: 90 12 22 f0 or %o0, 0x2f0, %o0 <== NOT EXECUTED
2020b74: 40 00 69 41 call 203b078 <printf> <== NOT EXECUTED
2020b78: b0 10 20 01 mov 1, %i0 <== NOT EXECUTED
}
}
return 1;
}
2020b7c: 81 c7 e0 08 ret <== NOT EXECUTED
2020b80: 81 e8 00 00 restore <== NOT EXECUTED
02020b84 <rtems_shell_rfs_format>:
int
rtems_shell_rfs_format (int argc, char* argv[])
{
2020b84: 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));
2020b88: 92 10 20 00 clr %o1 <== NOT EXECUTED
2020b8c: 90 07 bf e8 add %fp, -24, %o0 <== NOT EXECUTED
2020b90: 94 10 20 18 mov 0x18, %o2 <== NOT EXECUTED
2020b94: 40 00 64 c8 call 2039eb4 <memset> <== NOT EXECUTED
2020b98: 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;
2020b9c: b8 10 20 00 clr %i4 <== NOT EXECUTED
int arg;
memset (&config, 0, sizeof (rtems_rfs_format_config));
for (arg = 1; arg < argc; arg++)
2020ba0: 10 80 00 5b b 2020d0c <rtems_shell_rfs_format+0x188> <== NOT EXECUTED
2020ba4: b6 10 20 01 mov 1, %i3 <== NOT EXECUTED
{
if (argv[arg][0] == '-')
2020ba8: d2 06 40 01 ld [ %i1 + %g1 ], %o1 <== NOT EXECUTED
2020bac: c2 4a 40 00 ldsb [ %o1 ], %g1 <== NOT EXECUTED
2020bb0: 80 a0 60 2d cmp %g1, 0x2d <== NOT EXECUTED
2020bb4: 12 80 00 4e bne 2020cec <rtems_shell_rfs_format+0x168> <== NOT EXECUTED
2020bb8: 80 a7 20 00 cmp %i4, 0 <== NOT EXECUTED
{
switch (argv[arg][1])
2020bbc: c2 4a 60 01 ldsb [ %o1 + 1 ], %g1 <== NOT EXECUTED
2020bc0: 80 a0 60 69 cmp %g1, 0x69 <== NOT EXECUTED
2020bc4: 22 80 00 2e be,a 2020c7c <rtems_shell_rfs_format+0xf8> <== NOT EXECUTED
2020bc8: ba 07 60 01 inc %i5 <== NOT EXECUTED
2020bcc: 14 80 00 09 bg 2020bf0 <rtems_shell_rfs_format+0x6c> <== NOT EXECUTED
2020bd0: 80 a0 60 73 cmp %g1, 0x73 <== NOT EXECUTED
2020bd4: 80 a0 60 49 cmp %g1, 0x49 <== NOT EXECUTED
2020bd8: 02 80 00 35 be 2020cac <rtems_shell_rfs_format+0x128> <== NOT EXECUTED
2020bdc: 80 a0 60 62 cmp %g1, 0x62 <== NOT EXECUTED
2020be0: 12 80 00 41 bne 2020ce4 <rtems_shell_rfs_format+0x160> <== NOT EXECUTED
2020be4: 11 00 81 57 sethi %hi(0x2055c00), %o0 <== NOT EXECUTED
}
config.block_size = strtoul (argv[arg], 0, 0);
break;
case 'b':
arg++;
2020be8: 10 80 00 19 b 2020c4c <rtems_shell_rfs_format+0xc8> <== NOT EXECUTED
2020bec: ba 07 60 01 inc %i5 <== NOT EXECUTED
for (arg = 1; arg < argc; arg++)
{
if (argv[arg][0] == '-')
{
switch (argv[arg][1])
2020bf0: 02 80 00 0a be 2020c18 <rtems_shell_rfs_format+0x94> <== NOT EXECUTED
2020bf4: 80 a0 60 76 cmp %g1, 0x76 <== NOT EXECUTED
2020bf8: 02 80 00 06 be 2020c10 <rtems_shell_rfs_format+0x8c> <== NOT EXECUTED
2020bfc: 80 a0 60 6f cmp %g1, 0x6f <== NOT EXECUTED
2020c00: 12 80 00 39 bne 2020ce4 <rtems_shell_rfs_format+0x160> <== NOT EXECUTED
2020c04: 11 00 81 57 sethi %hi(0x2055c00), %o0 <== NOT EXECUTED
case 'I':
config.initialise_inodes = true;
break;
case 'o':
arg++;
2020c08: 10 80 00 2b b 2020cb4 <rtems_shell_rfs_format+0x130> <== NOT EXECUTED
2020c0c: ba 07 60 01 inc %i5 <== NOT EXECUTED
{
switch (argv[arg][1])
{
case 'v':
config.verbose = true;
break;
2020c10: 10 80 00 3e b 2020d08 <rtems_shell_rfs_format+0x184> <== NOT EXECUTED
2020c14: f6 2f bf fd stb %i3, [ %fp + -3 ] <== NOT EXECUTED
case 's':
arg++;
2020c18: ba 07 60 01 inc %i5 <== NOT EXECUTED
if (arg >= argc)
2020c1c: 80 a7 40 18 cmp %i5, %i0 <== NOT EXECUTED
2020c20: 06 80 00 05 bl 2020c34 <rtems_shell_rfs_format+0xb0> <== NOT EXECUTED
2020c24: 83 2f 60 02 sll %i5, 2, %g1 <== NOT EXECUTED
{
printf ("error: block size needs an argument\n");
2020c28: 11 00 81 5f sethi %hi(0x2057c00), %o0 <== NOT EXECUTED
2020c2c: 10 80 00 40 b 2020d2c <rtems_shell_rfs_format+0x1a8> <== NOT EXECUTED
2020c30: 90 12 20 60 or %o0, 0x60, %o0 ! 2057c60 <rtems_rtc_shell_usage+0x1780><== NOT EXECUTED
return 1;
}
config.block_size = strtoul (argv[arg], 0, 0);
2020c34: d0 06 40 01 ld [ %i1 + %g1 ], %o0 <== NOT EXECUTED
2020c38: 92 10 20 00 clr %o1 <== NOT EXECUTED
2020c3c: 40 00 79 0a call 203f064 <strtoul> <== NOT EXECUTED
2020c40: 94 10 20 00 clr %o2 <== NOT EXECUTED
break;
2020c44: 10 80 00 31 b 2020d08 <rtems_shell_rfs_format+0x184> <== NOT EXECUTED
2020c48: d0 27 bf e8 st %o0, [ %fp + -24 ] <== NOT EXECUTED
case 'b':
arg++;
if (arg >= argc)
2020c4c: 80 a7 40 18 cmp %i5, %i0 <== NOT EXECUTED
2020c50: 06 80 00 05 bl 2020c64 <rtems_shell_rfs_format+0xe0> <== NOT EXECUTED
2020c54: 83 2f 60 02 sll %i5, 2, %g1 <== NOT EXECUTED
{
printf ("error: group block count needs an argument\n");
2020c58: 11 00 81 5f sethi %hi(0x2057c00), %o0 <== NOT EXECUTED
2020c5c: 10 80 00 34 b 2020d2c <rtems_shell_rfs_format+0x1a8> <== NOT EXECUTED
2020c60: 90 12 20 88 or %o0, 0x88, %o0 ! 2057c88 <rtems_rtc_shell_usage+0x17a8><== NOT EXECUTED
return 1;
}
config.group_blocks = strtoul (argv[arg], 0, 0);
2020c64: d0 06 40 01 ld [ %i1 + %g1 ], %o0 <== NOT EXECUTED
2020c68: 92 10 20 00 clr %o1 <== NOT EXECUTED
2020c6c: 40 00 78 fe call 203f064 <strtoul> <== NOT EXECUTED
2020c70: 94 10 20 00 clr %o2 <== NOT EXECUTED
break;
2020c74: 10 80 00 25 b 2020d08 <rtems_shell_rfs_format+0x184> <== NOT EXECUTED
2020c78: d0 27 bf ec st %o0, [ %fp + -20 ] <== NOT EXECUTED
case 'i':
arg++;
if (arg >= argc)
2020c7c: 80 a7 40 18 cmp %i5, %i0 <== NOT EXECUTED
2020c80: 06 80 00 05 bl 2020c94 <rtems_shell_rfs_format+0x110> <== NOT EXECUTED
2020c84: 83 2f 60 02 sll %i5, 2, %g1 <== NOT EXECUTED
{
printf ("error: group inode count needs an argument\n");
2020c88: 11 00 81 5f sethi %hi(0x2057c00), %o0 <== NOT EXECUTED
2020c8c: 10 80 00 28 b 2020d2c <rtems_shell_rfs_format+0x1a8> <== NOT EXECUTED
2020c90: 90 12 20 b8 or %o0, 0xb8, %o0 ! 2057cb8 <rtems_rtc_shell_usage+0x17d8><== NOT EXECUTED
return 1;
}
config.group_inodes = strtoul (argv[arg], 0, 0);
2020c94: d0 06 40 01 ld [ %i1 + %g1 ], %o0 <== NOT EXECUTED
2020c98: 92 10 20 00 clr %o1 <== NOT EXECUTED
2020c9c: 40 00 78 f2 call 203f064 <strtoul> <== NOT EXECUTED
2020ca0: 94 10 20 00 clr %o2 <== NOT EXECUTED
break;
2020ca4: 10 80 00 19 b 2020d08 <rtems_shell_rfs_format+0x184> <== NOT EXECUTED
2020ca8: d0 27 bf f0 st %o0, [ %fp + -16 ] <== NOT EXECUTED
case 'I':
config.initialise_inodes = true;
break;
2020cac: 10 80 00 17 b 2020d08 <rtems_shell_rfs_format+0x184> <== NOT EXECUTED
2020cb0: f6 2f bf fc stb %i3, [ %fp + -4 ] <== NOT EXECUTED
case 'o':
arg++;
if (arg >= argc)
2020cb4: 80 a7 40 18 cmp %i5, %i0 <== NOT EXECUTED
2020cb8: 06 80 00 05 bl 2020ccc <rtems_shell_rfs_format+0x148> <== NOT EXECUTED
2020cbc: 83 2f 60 02 sll %i5, 2, %g1 <== NOT EXECUTED
{
printf ("error: inode percentage overhead needs an argument\n");
2020cc0: 11 00 81 5f sethi %hi(0x2057c00), %o0 <== NOT EXECUTED
2020cc4: 10 80 00 1a b 2020d2c <rtems_shell_rfs_format+0x1a8> <== NOT EXECUTED
2020cc8: 90 12 20 e8 or %o0, 0xe8, %o0 ! 2057ce8 <rtems_rtc_shell_usage+0x1808><== NOT EXECUTED
return 1;
}
config.inode_overhead = strtoul (argv[arg], 0, 0);
2020ccc: d0 06 40 01 ld [ %i1 + %g1 ], %o0 <== NOT EXECUTED
2020cd0: 92 10 20 00 clr %o1 <== NOT EXECUTED
2020cd4: 40 00 78 e4 call 203f064 <strtoul> <== NOT EXECUTED
2020cd8: 94 10 20 00 clr %o2 <== NOT EXECUTED
break;
2020cdc: 10 80 00 0b b 2020d08 <rtems_shell_rfs_format+0x184> <== NOT EXECUTED
2020ce0: d0 27 bf f4 st %o0, [ %fp + -12 ] <== NOT EXECUTED
default:
printf ("error: invalid option: %s\n", argv[arg]);
2020ce4: 10 80 00 06 b 2020cfc <rtems_shell_rfs_format+0x178> <== NOT EXECUTED
2020ce8: 90 12 21 00 or %o0, 0x100, %o0 <== NOT EXECUTED
return 1;
}
}
else
{
if (!driver)
2020cec: 22 80 00 07 be,a 2020d08 <rtems_shell_rfs_format+0x184> <== NOT EXECUTED
2020cf0: b8 10 00 09 mov %o1, %i4 <== NOT EXECUTED
driver = argv[arg];
else
{
printf ("error: only one driver name allowed: %s\n", argv[arg]);
2020cf4: 11 00 81 5f sethi %hi(0x2057c00), %o0 <== NOT EXECUTED
2020cf8: 90 12 21 20 or %o0, 0x120, %o0 ! 2057d20 <rtems_rtc_shell_usage+0x1840><== NOT EXECUTED
2020cfc: 40 00 68 df call 203b078 <printf> <== NOT EXECUTED
2020d00: b0 10 20 01 mov 1, %i0 <== NOT EXECUTED
2020d04: 30 80 00 1c b,a 2020d74 <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++)
2020d08: ba 07 60 01 inc %i5 <== NOT EXECUTED
2020d0c: 80 a7 40 18 cmp %i5, %i0 <== NOT EXECUTED
2020d10: 06 bf ff a6 bl 2020ba8 <rtems_shell_rfs_format+0x24> <== NOT EXECUTED
2020d14: 83 2f 60 02 sll %i5, 2, %g1 <== NOT EXECUTED
return 1;
}
}
}
if (!driver) {
2020d18: 80 a7 20 00 cmp %i4, 0 <== NOT EXECUTED
2020d1c: 12 80 00 07 bne 2020d38 <rtems_shell_rfs_format+0x1b4> <== NOT EXECUTED
2020d20: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
printf ("error: no driver name provided\n");
2020d24: 11 00 81 5f sethi %hi(0x2057c00), %o0 <== NOT EXECUTED
2020d28: 90 12 21 50 or %o0, 0x150, %o0 ! 2057d50 <rtems_rtc_shell_usage+0x1870><== NOT EXECUTED
2020d2c: 40 00 69 6b call 203b2d8 <puts> <== NOT EXECUTED
2020d30: b0 10 20 01 mov 1, %i0 <== NOT EXECUTED
2020d34: 30 80 00 10 b,a 2020d74 <rtems_shell_rfs_format+0x1f0> <== NOT EXECUTED
return 1;
}
if (rtems_rfs_format (driver, &config) < 0)
2020d38: 92 07 bf e8 add %fp, -24, %o1 <== NOT EXECUTED
2020d3c: 40 00 34 74 call 202df0c <rtems_rfs_format> <== NOT EXECUTED
2020d40: b0 10 20 00 clr %i0 <== NOT EXECUTED
2020d44: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
2020d48: 16 80 00 0b bge 2020d74 <rtems_shell_rfs_format+0x1f0> <== NOT EXECUTED
2020d4c: 01 00 00 00 nop <== NOT EXECUTED
{
printf ("error: format of %s failed: %s\n",
driver, strerror (errno));
2020d50: 40 00 56 8b call 203677c <__errno> <== NOT EXECUTED
2020d54: 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",
2020d58: 40 00 72 47 call 203d674 <strerror> <== NOT EXECUTED
2020d5c: d0 02 00 00 ld [ %o0 ], %o0 <== NOT EXECUTED
2020d60: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
2020d64: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED
2020d68: 11 00 81 5f sethi %hi(0x2057c00), %o0 <== NOT EXECUTED
2020d6c: 40 00 68 c3 call 203b078 <printf> <== NOT EXECUTED
2020d70: 90 12 21 70 or %o0, 0x170, %o0 ! 2057d70 <rtems_rtc_shell_usage+0x1890><== NOT EXECUTED
driver, strerror (errno));
return 1;
}
return 0;
}
2020d74: 81 c7 e0 08 ret <== NOT EXECUTED
2020d78: 81 e8 00 00 restore <== NOT EXECUTED
02017a34 <rtems_signal_send>:
rtems_status_code rtems_signal_send(
rtems_id id,
rtems_signal_set signal_set
)
{
2017a34: 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 )
2017a38: 80 a6 60 00 cmp %i1, 0
2017a3c: 02 80 00 35 be 2017b10 <rtems_signal_send+0xdc>
2017a40: 82 10 20 0a mov 0xa, %g1
return RTEMS_INVALID_NUMBER;
the_thread = _Thread_Get( id, &location );
2017a44: 90 10 00 18 mov %i0, %o0
2017a48: 40 00 12 a7 call 201c4e4 <_Thread_Get>
2017a4c: 92 07 bf fc add %fp, -4, %o1
switch ( location ) {
2017a50: c2 07 bf fc ld [ %fp + -4 ], %g1
2017a54: 80 a0 60 00 cmp %g1, 0
2017a58: 12 80 00 2d bne 2017b0c <rtems_signal_send+0xd8>
2017a5c: b8 10 00 08 mov %o0, %i4
case OBJECTS_LOCAL:
api = the_thread->API_Extensions[ THREAD_API_RTEMS ];
2017a60: fa 02 21 58 ld [ %o0 + 0x158 ], %i5
asr = &api->Signal;
if ( ! _ASR_Is_null_handler( asr->handler ) ) {
2017a64: c2 07 60 0c ld [ %i5 + 0xc ], %g1
2017a68: 80 a0 60 00 cmp %g1, 0
2017a6c: 02 80 00 24 be 2017afc <rtems_signal_send+0xc8>
2017a70: 01 00 00 00 nop
if ( asr->is_enabled ) {
2017a74: c2 0f 60 08 ldub [ %i5 + 8 ], %g1
2017a78: 80 a0 60 00 cmp %g1, 0
2017a7c: 02 80 00 15 be 2017ad0 <rtems_signal_send+0x9c>
2017a80: 01 00 00 00 nop
rtems_signal_set *signal_set
)
{
ISR_Level _level;
_ISR_Disable( _level );
2017a84: 7f ff e3 5b call 20107f0 <sparc_disable_interrupts>
2017a88: 01 00 00 00 nop
*signal_set |= signals;
2017a8c: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
2017a90: b2 10 40 19 or %g1, %i1, %i1
2017a94: f2 27 60 14 st %i1, [ %i5 + 0x14 ]
_ISR_Enable( _level );
2017a98: 7f ff e3 5a call 2010800 <sparc_enable_interrupts>
2017a9c: 01 00 00 00 nop
_ASR_Post_signals( signal_set, &asr->signals_posted );
if ( _ISR_Is_in_progress() && _Thread_Is_executing( the_thread ) )
2017aa0: 03 00 80 f4 sethi %hi(0x203d000), %g1
2017aa4: 82 10 62 b0 or %g1, 0x2b0, %g1 ! 203d2b0 <_Per_CPU_Information>
2017aa8: c4 00 60 08 ld [ %g1 + 8 ], %g2
2017aac: 80 a0 a0 00 cmp %g2, 0
2017ab0: 02 80 00 0f be 2017aec <rtems_signal_send+0xb8>
2017ab4: 01 00 00 00 nop
2017ab8: c4 00 60 0c ld [ %g1 + 0xc ], %g2
2017abc: 80 a7 00 02 cmp %i4, %g2
2017ac0: 12 80 00 0b bne 2017aec <rtems_signal_send+0xb8> <== NEVER TAKEN
2017ac4: 84 10 20 01 mov 1, %g2
_Thread_Dispatch_necessary = true;
2017ac8: c4 28 60 18 stb %g2, [ %g1 + 0x18 ]
2017acc: 30 80 00 08 b,a 2017aec <rtems_signal_send+0xb8>
rtems_signal_set *signal_set
)
{
ISR_Level _level;
_ISR_Disable( _level );
2017ad0: 7f ff e3 48 call 20107f0 <sparc_disable_interrupts>
2017ad4: 01 00 00 00 nop
*signal_set |= signals;
2017ad8: c2 07 60 18 ld [ %i5 + 0x18 ], %g1
2017adc: b2 10 40 19 or %g1, %i1, %i1
2017ae0: f2 27 60 18 st %i1, [ %i5 + 0x18 ]
_ISR_Enable( _level );
2017ae4: 7f ff e3 47 call 2010800 <sparc_enable_interrupts>
2017ae8: 01 00 00 00 nop
} else {
_ASR_Post_signals( signal_set, &asr->signals_pending );
}
_Thread_Enable_dispatch();
2017aec: 40 00 12 71 call 201c4b0 <_Thread_Enable_dispatch>
2017af0: 01 00 00 00 nop
return RTEMS_SUCCESSFUL;
2017af4: 10 80 00 07 b 2017b10 <rtems_signal_send+0xdc>
2017af8: 82 10 20 00 clr %g1 ! 0 <PROM_START>
}
_Thread_Enable_dispatch();
2017afc: 40 00 12 6d call 201c4b0 <_Thread_Enable_dispatch>
2017b00: 01 00 00 00 nop
return RTEMS_NOT_DEFINED;
2017b04: 10 80 00 03 b 2017b10 <rtems_signal_send+0xdc>
2017b08: 82 10 20 0b mov 0xb, %g1 ! b <PROM_START+0xb>
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
2017b0c: 82 10 20 04 mov 4, %g1
}
2017b10: 81 c7 e0 08 ret
2017b14: 91 e8 00 01 restore %g0, %g1, %o0
020224dc <rtems_stack_checker_begin_extension>:
* rtems_stack_checker_Begin_extension
*/
void rtems_stack_checker_begin_extension(
Thread_Control *the_thread
)
{
20224dc: 9d e3 bf a0 save %sp, -96, %sp
Stack_check_Control *the_pattern;
if ( the_thread->Object.id == 0 ) /* skip system tasks */
20224e0: c2 06 20 08 ld [ %i0 + 8 ], %g1
20224e4: 80 a0 60 00 cmp %g1, 0
20224e8: 02 80 00 07 be 2022504 <rtems_stack_checker_begin_extension+0x28><== NEVER TAKEN
20224ec: 13 00 81 8a sethi %hi(0x2062800), %o1
return;
the_pattern = Stack_check_Get_pattern_area(&the_thread->Start.Initial_stack);
*the_pattern = Stack_check_Pattern;
20224f0: d0 06 20 b8 ld [ %i0 + 0xb8 ], %o0
20224f4: 90 02 20 08 add %o0, 8, %o0
20224f8: 92 12 61 b8 or %o1, 0x1b8, %o1
20224fc: 40 00 5d df call 2039c78 <memcpy>
2022500: 94 10 20 10 mov 0x10, %o2
2022504: 81 c7 e0 08 ret
2022508: 81 e8 00 00 restore
02022424 <rtems_stack_checker_create_extension>:
*/
bool rtems_stack_checker_create_extension(
Thread_Control *running __attribute__((unused)),
Thread_Control *the_thread
)
{
2022424: 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 )
2022428: 03 00 81 85 sethi %hi(0x2061400), %g1
202242c: c2 00 62 c0 ld [ %g1 + 0x2c0 ], %g1 ! 20616c0 <Stack_check_Initialized>
2022430: 80 a0 60 00 cmp %g1, 0
2022434: 12 80 00 21 bne 20224b8 <rtems_stack_checker_create_extension+0x94>
2022438: 05 00 81 8a sethi %hi(0x2062800), %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 ];
202243c: 07 3f bb 7c sethi %hi(0xfeedf000), %g3
2022440: 82 10 a1 b8 or %g2, 0x1b8, %g1
2022444: 86 10 e0 0d or %g3, 0xd, %g3
2022448: c6 20 a1 b8 st %g3, [ %g2 + 0x1b8 ]
202244c: 05 02 eb 43 sethi %hi(0xbad0c00), %g2
2022450: 84 10 a1 06 or %g2, 0x106, %g2 ! bad0d06 <RAM_END+0x96d0d06>
2022454: c4 20 60 04 st %g2, [ %g1 + 4 ]
2022458: 05 37 ab 7c sethi %hi(0xdeadf000), %g2
202245c: 84 10 a0 0d or %g2, 0xd, %g2 ! deadf00d <RAM_END+0xdc6df00d>
2022460: c4 20 60 08 st %g2, [ %g1 + 8 ]
2022464: 05 18 03 43 sethi %hi(0x600d0c00), %g2
2022468: 84 10 a1 06 or %g2, 0x106, %g2 ! 600d0d06 <RAM_END+0x5dcd0d06>
202246c: 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) {
2022470: 03 00 81 89 sethi %hi(0x2062400), %g1
2022474: d0 00 60 90 ld [ %g1 + 0x90 ], %o0 ! 2062490 <_Per_CPU_Information>
2022478: 80 a2 20 00 cmp %o0, 0
202247c: 02 80 00 0c be 20224ac <rtems_stack_checker_create_extension+0x88><== NEVER TAKEN
2022480: 84 10 60 90 or %g1, 0x90, %g2
2022484: d4 00 a0 04 ld [ %g2 + 4 ], %o2
2022488: 80 a2 a0 00 cmp %o2, 0
202248c: 02 80 00 08 be 20224ac <rtems_stack_checker_create_extension+0x88><== NEVER TAKEN
2022490: 03 00 81 8a sethi %hi(0x2062800), %g1
Stack_check_Interrupt_stack.area = _CPU_Interrupt_stack_low;
2022494: 84 10 61 c8 or %g1, 0x1c8, %g2 ! 20629c8 <Stack_check_Interrupt_stack>
Stack_check_Interrupt_stack.size = (char *) _CPU_Interrupt_stack_high -
2022498: 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;
202249c: d0 20 a0 04 st %o0, [ %g2 + 4 ]
Stack_check_Interrupt_stack.size = (char *) _CPU_Interrupt_stack_high -
20224a0: d4 20 61 c8 st %o2, [ %g1 + 0x1c8 ]
(char *) _CPU_Interrupt_stack_low;
Stack_check_Dope_stack(&Stack_check_Interrupt_stack);
20224a4: 40 00 5e 84 call 2039eb4 <memset>
20224a8: 92 10 20 a5 mov 0xa5, %o1
}
#endif
Stack_check_Initialized = 1;
20224ac: 84 10 20 01 mov 1, %g2
20224b0: 03 00 81 85 sethi %hi(0x2061400), %g1
20224b4: c4 20 62 c0 st %g2, [ %g1 + 0x2c0 ] ! 20616c0 <Stack_check_Initialized>
Thread_Control *the_thread
)
{
Stack_check_Initialize();
if (the_thread)
20224b8: 80 a6 60 00 cmp %i1, 0
20224bc: 02 80 00 06 be 20224d4 <rtems_stack_checker_create_extension+0xb0><== NEVER TAKEN
20224c0: 01 00 00 00 nop
Stack_check_Dope_stack(&the_thread->Start.Initial_stack);
20224c4: d0 06 60 b8 ld [ %i1 + 0xb8 ], %o0
20224c8: d4 06 60 b4 ld [ %i1 + 0xb4 ], %o2
20224cc: 40 00 5e 7a call 2039eb4 <memset>
20224d0: 92 10 20 a5 mov 0xa5, %o1
return true;
}
20224d4: 81 c7 e0 08 ret
20224d8: 91 e8 20 01 restore %g0, 1, %o0
02022624 <rtems_stack_checker_is_blown>:
/*
* Check if blown
*/
bool rtems_stack_checker_is_blown( void )
{
2022624: 9d e3 bf a0 save %sp, -96, %sp
Stack_Control *the_stack = &_Thread_Executing->Start.Initial_stack;
2022628: 03 00 81 89 sethi %hi(0x2062400), %g1
202262c: fa 00 60 9c ld [ %g1 + 0x9c ], %i5 ! 206249c <_Per_CPU_Information+0xc>
)
{
#if defined(__GNUC__)
void *sp = __builtin_frame_address(0);
if ( sp < the_stack->area ) {
2022630: d0 07 60 b8 ld [ %i5 + 0xb8 ], %o0
2022634: 80 a7 80 08 cmp %fp, %o0
2022638: 0a 80 00 06 bcs 2022650 <rtems_stack_checker_is_blown+0x2c><== NEVER TAKEN
202263c: b8 10 20 00 clr %i4
return false;
}
if ( sp > (the_stack->area + the_stack->size) ) {
2022640: c2 07 60 b4 ld [ %i5 + 0xb4 ], %g1
2022644: 82 02 00 01 add %o0, %g1, %g1
2022648: 80 a0 40 1e cmp %g1, %fp
202264c: 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 ) {
2022650: 03 00 81 85 sethi %hi(0x2061400), %g1
2022654: c2 00 62 c0 ld [ %g1 + 0x2c0 ], %g1 ! 20616c0 <Stack_check_Initialized>
2022658: 80 a0 60 00 cmp %g1, 0
202265c: 02 80 00 09 be 2022680 <rtems_stack_checker_is_blown+0x5c><== NEVER TAKEN
2022660: 92 10 20 01 mov 1, %o1
pattern_ok = (!memcmp(
2022664: 90 02 20 08 add %o0, 8, %o0
2022668: 13 00 81 8a sethi %hi(0x2062800), %o1
202266c: 94 10 20 10 mov 0x10, %o2
2022670: 40 00 5d 58 call 2039bd0 <memcmp>
2022674: 92 12 61 b8 or %o1, 0x1b8, %o1
2022678: 80 a0 00 08 cmp %g0, %o0
202267c: 92 60 3f ff subx %g0, -1, %o1
/*
* Let's report as much as we can.
*/
if ( !sp_ok || !pattern_ok ) {
2022680: 82 1a 60 01 xor %o1, 1, %g1
2022684: 80 88 60 ff btst 0xff, %g1
2022688: 12 80 00 05 bne 202269c <rtems_stack_checker_is_blown+0x78><== NEVER TAKEN
202268c: b8 1f 20 01 xor %i4, 1, %i4
2022690: 80 8f 20 ff btst 0xff, %i4
2022694: 02 80 00 05 be 20226a8 <rtems_stack_checker_is_blown+0x84><== ALWAYS TAKEN
2022698: 01 00 00 00 nop
Stack_check_report_blown_task( _Thread_Executing, pattern_ok );
202269c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
20226a0: 7f ff ff 9b call 202250c <Stack_check_report_blown_task> <== NOT EXECUTED
20226a4: 92 0a 60 01 and %o1, 1, %o1 <== NOT EXECUTED
/*
* The Stack Pointer and the Pattern Area are OK so return false.
*/
return false;
}
20226a8: 81 c7 e0 08 ret
20226ac: 91 e8 20 00 restore %g0, 0, %o0
020226b0 <rtems_stack_checker_report_usage_with_plugin>:
void rtems_stack_checker_report_usage_with_plugin(
void *context,
rtems_printk_plugin_t print
)
{
20226b0: 9d e3 bf a0 save %sp, -96, %sp
if ( !print )
20226b4: 80 a6 60 00 cmp %i1, 0
20226b8: 02 80 00 14 be 2022708 <rtems_stack_checker_report_usage_with_plugin+0x58><== NEVER TAKEN
20226bc: 39 00 81 85 sethi %hi(0x2061400), %i4
return;
print_context = context;
print_handler = print;
20226c0: 3b 00 81 85 sethi %hi(0x2061400), %i5
)
{
if ( !print )
return;
print_context = context;
20226c4: f0 27 22 c4 st %i0, [ %i4 + 0x2c4 ]
print_handler = print;
20226c8: f2 27 62 c8 st %i1, [ %i5 + 0x2c8 ]
(*print)( context, "Stack usage by thread\n");
20226cc: 90 10 00 18 mov %i0, %o0
20226d0: 13 00 81 61 sethi %hi(0x2058400), %o1
20226d4: 9f c6 40 00 call %i1
20226d8: 92 12 62 f0 or %o1, 0x2f0, %o1 ! 20586f0 <RTEMS_BDPART_MBR_MASTER_TYPE+0x3f8>
(*print)( context,
20226dc: 90 10 00 18 mov %i0, %o0
20226e0: 13 00 81 61 sethi %hi(0x2058400), %o1
20226e4: 9f c6 40 00 call %i1
20226e8: 92 12 63 08 or %o1, 0x308, %o1 ! 2058708 <RTEMS_BDPART_MBR_MASTER_TYPE+0x410>
" 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 );
20226ec: 11 00 80 88 sethi %hi(0x2022000), %o0
20226f0: 40 00 10 c6 call 2026a08 <rtems_iterate_over_all_threads>
20226f4: 90 12 22 b4 or %o0, 0x2b4, %o0 ! 20222b4 <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);
20226f8: 7f ff fe ef call 20222b4 <Stack_check_Dump_threads_usage>
20226fc: 90 10 3f ff mov -1, %o0
#endif
print_context = NULL;
2022700: c0 27 22 c4 clr [ %i4 + 0x2c4 ]
print_handler = NULL;
2022704: c0 27 62 c8 clr [ %i5 + 0x2c8 ]
2022708: 81 c7 e0 08 ret
202270c: 81 e8 00 00 restore
020225b4 <rtems_stack_checker_switch_extension>:
*/
void rtems_stack_checker_switch_extension(
Thread_Control *running __attribute__((unused)),
Thread_Control *heir __attribute__((unused))
)
{
20225b4: 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);
20225b8: c2 06 20 b8 ld [ %i0 + 0xb8 ], %g1
{
#if defined(__GNUC__)
void *sp = __builtin_frame_address(0);
if ( sp < the_stack->area ) {
return false;
20225bc: ba 10 20 00 clr %i5
)
{
#if defined(__GNUC__)
void *sp = __builtin_frame_address(0);
if ( sp < the_stack->area ) {
20225c0: 80 a7 80 01 cmp %fp, %g1
20225c4: 0a 80 00 06 bcs 20225dc <rtems_stack_checker_switch_extension+0x28><== NEVER TAKEN
20225c8: 90 00 60 08 add %g1, 8, %o0
return false;
}
if ( sp > (the_stack->area + the_stack->size) ) {
20225cc: c4 06 20 b4 ld [ %i0 + 0xb4 ], %g2
20225d0: 82 00 40 02 add %g1, %g2, %g1
20225d4: 80 a0 40 1e cmp %g1, %fp
20225d8: 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,
20225dc: 13 00 81 8a sethi %hi(0x2062800), %o1
20225e0: 94 10 20 10 mov 0x10, %o2
20225e4: 40 00 5d 7b call 2039bd0 <memcmp>
20225e8: 92 12 61 b8 or %o1, 0x1b8, %o1
20225ec: 80 a0 00 08 cmp %g0, %o0
20225f0: 82 60 3f ff subx %g0, -1, %g1
(void *) Stack_check_Pattern.pattern, PATTERN_SIZE_BYTES));
if ( !sp_ok || !pattern_ok ) {
20225f4: 80 a0 60 00 cmp %g1, 0
20225f8: 02 80 00 06 be 2022610 <rtems_stack_checker_switch_extension+0x5c>
20225fc: 92 10 00 01 mov %g1, %o1
2022600: ba 1f 60 01 xor %i5, 1, %i5
2022604: 80 8f 60 ff btst 0xff, %i5
2022608: 02 80 00 05 be 202261c <rtems_stack_checker_switch_extension+0x68><== ALWAYS TAKEN
202260c: 01 00 00 00 nop
Stack_check_report_blown_task( running, pattern_ok );
2022610: 90 10 00 18 mov %i0, %o0
2022614: 7f ff ff be call 202250c <Stack_check_report_blown_task>
2022618: 92 0a 60 01 and %o1, 1, %o1
202261c: 81 c7 e0 08 ret
2022620: 81 e8 00 00 restore
0201d6f0 <rtems_string_to_int>:
const char *s,
int *n,
char **endptr,
int base
)
{
201d6f0: 9d e3 bf 98 save %sp, -104, %sp
long result;
char *end;
if ( !n )
201d6f4: 80 a6 60 00 cmp %i1, 0
201d6f8: 02 80 00 25 be 201d78c <rtems_string_to_int+0x9c>
201d6fc: 82 10 20 09 mov 9, %g1
return RTEMS_INVALID_ADDRESS;
errno = 0;
201d700: 40 00 64 1f call 203677c <__errno>
201d704: 01 00 00 00 nop
201d708: c0 22 00 00 clr [ %o0 ]
*n = 0;
201d70c: c0 26 40 00 clr [ %i1 ]
result = strtol( s, &end, base );
201d710: 90 10 00 18 mov %i0, %o0
201d714: 92 07 bf fc add %fp, -4, %o1
201d718: 40 00 85 05 call 203eb2c <strtol>
201d71c: 94 10 00 1b mov %i3, %o2
if ( endptr )
201d720: 80 a6 a0 00 cmp %i2, 0
return RTEMS_INVALID_ADDRESS;
errno = 0;
*n = 0;
result = strtol( s, &end, base );
201d724: ba 10 00 08 mov %o0, %i5
if ( endptr )
201d728: 02 80 00 03 be 201d734 <rtems_string_to_int+0x44>
201d72c: c4 07 bf fc ld [ %fp + -4 ], %g2
*endptr = end;
201d730: c4 26 80 00 st %g2, [ %i2 ]
if ( end == s )
201d734: 80 a0 80 18 cmp %g2, %i0
201d738: 02 80 00 15 be 201d78c <rtems_string_to_int+0x9c>
201d73c: 82 10 20 0b mov 0xb, %g1
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
201d740: 40 00 64 0f call 203677c <__errno>
201d744: 01 00 00 00 nop
201d748: c2 02 00 00 ld [ %o0 ], %g1
201d74c: 80 a0 60 22 cmp %g1, 0x22
201d750: 32 80 00 0e bne,a 201d788 <rtems_string_to_int+0x98>
201d754: fa 26 40 00 st %i5, [ %i1 ]
(( result == 0 ) || ( result == LONG_MAX ) || ( result == LONG_MIN )))
201d758: 03 20 00 00 sethi %hi(0x80000000), %g1
201d75c: 82 38 40 1d xnor %g1, %i5, %g1
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
201d760: 80 a0 60 00 cmp %g1, 0
201d764: 02 80 00 0a be 201d78c <rtems_string_to_int+0x9c>
201d768: 82 10 20 0a mov 0xa, %g1
201d76c: 80 a7 60 00 cmp %i5, 0
201d770: 02 80 00 07 be 201d78c <rtems_string_to_int+0x9c> <== NEVER TAKEN
201d774: 05 20 00 00 sethi %hi(0x80000000), %g2
(( result == 0 ) || ( result == LONG_MAX ) || ( result == LONG_MIN )))
201d778: 80 a7 40 02 cmp %i5, %g2
201d77c: 02 80 00 04 be 201d78c <rtems_string_to_int+0x9c> <== ALWAYS TAKEN
201d780: 01 00 00 00 nop
errno = ERANGE;
return RTEMS_INVALID_NUMBER;
}
#endif
*n = result;
201d784: fa 26 40 00 st %i5, [ %i1 ] <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
201d788: 82 10 20 00 clr %g1
}
201d78c: 81 c7 e0 08 ret
201d790: 91 e8 00 01 restore %g0, %g1, %o0
0200dad0 <rtems_string_to_long>:
const char *s,
long *n,
char **endptr,
int base
)
{
200dad0: 9d e3 bf 98 save %sp, -104, %sp
long result;
char *end;
if ( !n )
200dad4: 80 a6 60 00 cmp %i1, 0
200dad8: 02 80 00 25 be 200db6c <rtems_string_to_long+0x9c>
200dadc: 82 10 20 09 mov 9, %g1
return RTEMS_INVALID_ADDRESS;
errno = 0;
200dae0: 40 00 0b d7 call 2010a3c <__errno>
200dae4: 01 00 00 00 nop
200dae8: c0 22 00 00 clr [ %o0 ]
*n = 0;
200daec: c0 26 40 00 clr [ %i1 ]
result = strtol( s, &end, base );
200daf0: 90 10 00 18 mov %i0, %o0
200daf4: 92 07 bf fc add %fp, -4, %o1
200daf8: 40 00 17 86 call 2013910 <strtol>
200dafc: 94 10 00 1b mov %i3, %o2
if ( endptr )
200db00: 80 a6 a0 00 cmp %i2, 0
return RTEMS_INVALID_ADDRESS;
errno = 0;
*n = 0;
result = strtol( s, &end, base );
200db04: ba 10 00 08 mov %o0, %i5
if ( endptr )
200db08: 02 80 00 03 be 200db14 <rtems_string_to_long+0x44>
200db0c: c4 07 bf fc ld [ %fp + -4 ], %g2
*endptr = end;
200db10: c4 26 80 00 st %g2, [ %i2 ]
if ( end == s )
200db14: 80 a0 80 18 cmp %g2, %i0
200db18: 02 80 00 15 be 200db6c <rtems_string_to_long+0x9c>
200db1c: 82 10 20 0b mov 0xb, %g1
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
200db20: 40 00 0b c7 call 2010a3c <__errno>
200db24: 01 00 00 00 nop
200db28: c2 02 00 00 ld [ %o0 ], %g1
200db2c: 80 a0 60 22 cmp %g1, 0x22
200db30: 32 80 00 0e bne,a 200db68 <rtems_string_to_long+0x98>
200db34: fa 26 40 00 st %i5, [ %i1 ]
(( result == 0 ) || ( result == LONG_MAX ) || ( result == LONG_MIN )))
200db38: 03 20 00 00 sethi %hi(0x80000000), %g1
200db3c: 82 38 40 1d xnor %g1, %i5, %g1
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
200db40: 80 a0 60 00 cmp %g1, 0
200db44: 02 80 00 0a be 200db6c <rtems_string_to_long+0x9c>
200db48: 82 10 20 0a mov 0xa, %g1
200db4c: 80 a7 60 00 cmp %i5, 0
200db50: 02 80 00 07 be 200db6c <rtems_string_to_long+0x9c> <== NEVER TAKEN
200db54: 05 20 00 00 sethi %hi(0x80000000), %g2
(( result == 0 ) || ( result == LONG_MAX ) || ( result == LONG_MIN )))
200db58: 80 a7 40 02 cmp %i5, %g2
200db5c: 02 80 00 04 be 200db6c <rtems_string_to_long+0x9c> <== ALWAYS TAKEN
200db60: 01 00 00 00 nop
return RTEMS_INVALID_NUMBER;
*n = result;
200db64: fa 26 40 00 st %i5, [ %i1 ] <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
200db68: 82 10 20 00 clr %g1
}
200db6c: 81 c7 e0 08 ret
200db70: 91 e8 00 01 restore %g0, %g1, %o0
0200da04 <rtems_string_to_long_long>:
const char *s,
long long *n,
char **endptr,
int base
)
{
200da04: 9d e3 bf 98 save %sp, -104, %sp
long long result;
char *end;
if ( !n )
200da08: 80 a6 60 00 cmp %i1, 0
200da0c: 02 80 00 2f be 200dac8 <rtems_string_to_long_long+0xc4>
200da10: 82 10 20 09 mov 9, %g1
return RTEMS_INVALID_ADDRESS;
errno = 0;
200da14: 40 00 0c 0a call 2010a3c <__errno>
200da18: 01 00 00 00 nop
200da1c: c0 22 00 00 clr [ %o0 ]
*n = 0;
200da20: c0 26 40 00 clr [ %i1 ]
200da24: c0 26 60 04 clr [ %i1 + 4 ]
result = strtoll( s, &end, base );
200da28: 90 10 00 18 mov %i0, %o0
200da2c: 92 07 bf fc add %fp, -4, %o1
200da30: 40 00 17 c1 call 2013934 <strtoll>
200da34: 94 10 00 1b mov %i3, %o2
if ( endptr )
200da38: 80 a6 a0 00 cmp %i2, 0
return RTEMS_INVALID_ADDRESS;
errno = 0;
*n = 0;
result = strtoll( s, &end, base );
200da3c: b8 10 00 08 mov %o0, %i4
200da40: ba 10 00 09 mov %o1, %i5
if ( endptr )
200da44: 02 80 00 03 be 200da50 <rtems_string_to_long_long+0x4c>
200da48: c4 07 bf fc ld [ %fp + -4 ], %g2
*endptr = end;
200da4c: c4 26 80 00 st %g2, [ %i2 ]
if ( end == s )
200da50: 80 a0 80 18 cmp %g2, %i0
200da54: 02 80 00 1d be 200dac8 <rtems_string_to_long_long+0xc4>
200da58: 82 10 20 0b mov 0xb, %g1
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
200da5c: 40 00 0b f8 call 2010a3c <__errno>
200da60: 01 00 00 00 nop
200da64: c2 02 00 00 ld [ %o0 ], %g1
200da68: 80 a0 60 22 cmp %g1, 0x22
200da6c: 32 80 00 16 bne,a 200dac4 <rtems_string_to_long_long+0xc0>
200da70: f8 3e 40 00 std %i4, [ %i1 ]
(( result == 0 ) || ( result == LONG_LONG_MAX ) || ( result == LONG_LONG_MIN )))
200da74: 05 1f ff ff sethi %hi(0x7ffffc00), %g2
200da78: 07 3f ff ff sethi %hi(0xfffffc00), %g3
200da7c: 84 10 a3 ff or %g2, 0x3ff, %g2
200da80: 86 10 e3 ff or %g3, 0x3ff, %g3
200da84: 84 1f 00 02 xor %i4, %g2, %g2
200da88: 86 1f 40 03 xor %i5, %g3, %g3
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
200da8c: 80 90 80 03 orcc %g2, %g3, %g0
200da90: 02 80 00 0e be 200dac8 <rtems_string_to_long_long+0xc4>
200da94: 82 10 20 0a mov 0xa, %g1
200da98: 80 97 00 1d orcc %i4, %i5, %g0
200da9c: 02 80 00 0b be 200dac8 <rtems_string_to_long_long+0xc4> <== NEVER TAKEN
200daa0: 01 00 00 00 nop
(( result == 0 ) || ( result == LONG_LONG_MAX ) || ( result == LONG_LONG_MIN )))
200daa4: 03 20 00 00 sethi %hi(0x80000000), %g1
200daa8: 80 a7 00 01 cmp %i4, %g1
200daac: 32 80 00 06 bne,a 200dac4 <rtems_string_to_long_long+0xc0><== NEVER TAKEN
200dab0: f8 3e 40 00 std %i4, [ %i1 ] <== NOT EXECUTED
200dab4: 80 a7 60 00 cmp %i5, 0
200dab8: 22 80 00 04 be,a 200dac8 <rtems_string_to_long_long+0xc4><== ALWAYS TAKEN
200dabc: 82 10 20 0a mov 0xa, %g1
return RTEMS_INVALID_NUMBER;
*n = result;
200dac0: f8 3e 40 00 std %i4, [ %i1 ] <== NOT EXECUTED
200dac4: 82 10 20 00 clr %g1
return RTEMS_SUCCESSFUL;
}
200dac8: 81 c7 e0 08 ret
200dacc: 91 e8 00 01 restore %g0, %g1, %o0
0201d7a4 <rtems_string_to_unsigned_char>:
const char *s,
unsigned char *n,
char **endptr,
int base
)
{
201d7a4: 9d e3 bf 98 save %sp, -104, %sp
unsigned long result;
char *end;
if ( !n )
201d7a8: 80 a6 60 00 cmp %i1, 0
201d7ac: 02 80 00 26 be 201d844 <rtems_string_to_unsigned_char+0xa0>
201d7b0: 82 10 20 09 mov 9, %g1
return RTEMS_INVALID_ADDRESS;
errno = 0;
201d7b4: 40 00 63 f2 call 203677c <__errno>
201d7b8: 01 00 00 00 nop
201d7bc: c0 22 00 00 clr [ %o0 ]
*n = 0;
201d7c0: c0 2e 40 00 clrb [ %i1 ]
result = strtoul( s, &end, base );
201d7c4: 90 10 00 18 mov %i0, %o0
201d7c8: 92 07 bf fc add %fp, -4, %o1
201d7cc: 40 00 86 26 call 203f064 <strtoul>
201d7d0: 94 10 00 1b mov %i3, %o2
if ( endptr )
201d7d4: 80 a6 a0 00 cmp %i2, 0
return RTEMS_INVALID_ADDRESS;
errno = 0;
*n = 0;
result = strtoul( s, &end, base );
201d7d8: ba 10 00 08 mov %o0, %i5
if ( endptr )
201d7dc: 02 80 00 03 be 201d7e8 <rtems_string_to_unsigned_char+0x44>
201d7e0: c4 07 bf fc ld [ %fp + -4 ], %g2
*endptr = end;
201d7e4: c4 26 80 00 st %g2, [ %i2 ]
if ( end == s )
201d7e8: 80 a0 80 18 cmp %g2, %i0
201d7ec: 02 80 00 16 be 201d844 <rtems_string_to_unsigned_char+0xa0>
201d7f0: 82 10 20 0b mov 0xb, %g1
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
201d7f4: 40 00 63 e2 call 203677c <__errno>
201d7f8: 01 00 00 00 nop
201d7fc: c2 02 00 00 ld [ %o0 ], %g1
201d800: 80 a0 60 22 cmp %g1, 0x22
201d804: 12 80 00 07 bne 201d820 <rtems_string_to_unsigned_char+0x7c>
201d808: 80 a7 60 ff cmp %i5, 0xff
(( result == 0 ) || ( result == ULONG_MAX )))
201d80c: 84 07 7f ff add %i5, -1, %g2
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
201d810: 80 a0 bf fd cmp %g2, -3
201d814: 18 80 00 0c bgu 201d844 <rtems_string_to_unsigned_char+0xa0><== ALWAYS TAKEN
201d818: 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 ) {
201d81c: 80 a7 60 ff cmp %i5, 0xff <== NOT EXECUTED
201d820: 28 80 00 08 bleu,a 201d840 <rtems_string_to_unsigned_char+0x9c>
201d824: fa 2e 40 00 stb %i5, [ %i1 ]
errno = ERANGE;
201d828: 40 00 63 d5 call 203677c <__errno>
201d82c: 01 00 00 00 nop
201d830: 82 10 20 22 mov 0x22, %g1 ! 22 <PROM_START+0x22>
201d834: c2 22 00 00 st %g1, [ %o0 ]
return RTEMS_INVALID_NUMBER;
201d838: 10 80 00 03 b 201d844 <rtems_string_to_unsigned_char+0xa0>
201d83c: 82 10 20 0a mov 0xa, %g1
}
#endif
*n = result;
return RTEMS_SUCCESSFUL;
201d840: 82 10 20 00 clr %g1
}
201d844: 81 c7 e0 08 ret
201d848: 91 e8 00 01 restore %g0, %g1, %o0
0200dc2c <rtems_string_to_unsigned_int>:
const char *s,
unsigned int *n,
char **endptr,
int base
)
{
200dc2c: 9d e3 bf 98 save %sp, -104, %sp
unsigned long result;
char *end;
if ( !n )
200dc30: 80 a6 60 00 cmp %i1, 0
200dc34: 02 80 00 1e be 200dcac <rtems_string_to_unsigned_int+0x80>
200dc38: 82 10 20 09 mov 9, %g1
return RTEMS_INVALID_ADDRESS;
errno = 0;
200dc3c: 40 00 0b 80 call 2010a3c <__errno>
200dc40: 01 00 00 00 nop
200dc44: c0 22 00 00 clr [ %o0 ]
*n = 0;
200dc48: c0 26 40 00 clr [ %i1 ]
result = strtoul( s, &end, base );
200dc4c: 90 10 00 18 mov %i0, %o0
200dc50: 92 07 bf fc add %fp, -4, %o1
200dc54: 40 00 18 7d call 2013e48 <strtoul>
200dc58: 94 10 00 1b mov %i3, %o2
if ( endptr )
200dc5c: 80 a6 a0 00 cmp %i2, 0
return RTEMS_INVALID_ADDRESS;
errno = 0;
*n = 0;
result = strtoul( s, &end, base );
200dc60: ba 10 00 08 mov %o0, %i5
if ( endptr )
200dc64: 02 80 00 03 be 200dc70 <rtems_string_to_unsigned_int+0x44>
200dc68: c4 07 bf fc ld [ %fp + -4 ], %g2
*endptr = end;
200dc6c: c4 26 80 00 st %g2, [ %i2 ]
if ( end == s )
200dc70: 80 a0 80 18 cmp %g2, %i0
200dc74: 02 80 00 0e be 200dcac <rtems_string_to_unsigned_int+0x80>
200dc78: 82 10 20 0b mov 0xb, %g1
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
200dc7c: 40 00 0b 70 call 2010a3c <__errno>
200dc80: 01 00 00 00 nop
200dc84: c2 02 00 00 ld [ %o0 ], %g1
200dc88: 80 a0 60 22 cmp %g1, 0x22
200dc8c: 32 80 00 07 bne,a 200dca8 <rtems_string_to_unsigned_int+0x7c>
200dc90: fa 26 40 00 st %i5, [ %i1 ]
(( result == 0 ) || ( result == ULONG_MAX )))
200dc94: 84 07 7f ff add %i5, -1, %g2
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
200dc98: 80 a0 bf fd cmp %g2, -3
200dc9c: 18 80 00 04 bgu 200dcac <rtems_string_to_unsigned_int+0x80><== ALWAYS TAKEN
200dca0: 82 10 20 0a mov 0xa, %g1
errno = ERANGE;
return RTEMS_INVALID_NUMBER;
}
#endif
*n = result;
200dca4: fa 26 40 00 st %i5, [ %i1 ] <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
200dca8: 82 10 20 00 clr %g1
}
200dcac: 81 c7 e0 08 ret
200dcb0: 91 e8 00 01 restore %g0, %g1, %o0
0200bbb4 <rtems_string_to_unsigned_long>:
const char *s,
unsigned long *n,
char **endptr,
int base
)
{
200bbb4: 9d e3 bf 98 save %sp, -104, %sp
unsigned long result;
char *end;
if ( !n )
200bbb8: 80 a6 60 00 cmp %i1, 0
200bbbc: 02 80 00 1e be 200bc34 <rtems_string_to_unsigned_long+0x80>
200bbc0: 82 10 20 09 mov 9, %g1
return RTEMS_INVALID_ADDRESS;
errno = 0;
200bbc4: 40 00 aa ee call 203677c <__errno>
200bbc8: 01 00 00 00 nop
200bbcc: c0 22 00 00 clr [ %o0 ]
*n = 0;
200bbd0: c0 26 40 00 clr [ %i1 ]
result = strtoul( s, &end, base );
200bbd4: 90 10 00 18 mov %i0, %o0
200bbd8: 92 07 bf fc add %fp, -4, %o1
200bbdc: 40 00 cd 22 call 203f064 <strtoul>
200bbe0: 94 10 00 1b mov %i3, %o2
if ( endptr )
200bbe4: 80 a6 a0 00 cmp %i2, 0
return RTEMS_INVALID_ADDRESS;
errno = 0;
*n = 0;
result = strtoul( s, &end, base );
200bbe8: ba 10 00 08 mov %o0, %i5
if ( endptr )
200bbec: 02 80 00 03 be 200bbf8 <rtems_string_to_unsigned_long+0x44>
200bbf0: c4 07 bf fc ld [ %fp + -4 ], %g2
*endptr = end;
200bbf4: c4 26 80 00 st %g2, [ %i2 ]
if ( end == s )
200bbf8: 80 a0 80 18 cmp %g2, %i0
200bbfc: 02 80 00 0e be 200bc34 <rtems_string_to_unsigned_long+0x80>
200bc00: 82 10 20 0b mov 0xb, %g1
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
200bc04: 40 00 aa de call 203677c <__errno>
200bc08: 01 00 00 00 nop
200bc0c: c2 02 00 00 ld [ %o0 ], %g1
200bc10: 80 a0 60 22 cmp %g1, 0x22
200bc14: 32 80 00 07 bne,a 200bc30 <rtems_string_to_unsigned_long+0x7c>
200bc18: fa 26 40 00 st %i5, [ %i1 ]
(( result == 0 ) || ( result == ULONG_MAX )))
200bc1c: 84 07 7f ff add %i5, -1, %g2
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
200bc20: 80 a0 bf fd cmp %g2, -3
200bc24: 18 80 00 04 bgu 200bc34 <rtems_string_to_unsigned_long+0x80><== ALWAYS TAKEN
200bc28: 82 10 20 0a mov 0xa, %g1
(( result == 0 ) || ( result == ULONG_MAX )))
return RTEMS_INVALID_NUMBER;
*n = result;
200bc2c: fa 26 40 00 st %i5, [ %i1 ] <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
200bc30: 82 10 20 00 clr %g1
}
200bc34: 81 c7 e0 08 ret
200bc38: 91 e8 00 01 restore %g0, %g1, %o0
0200dcb4 <rtems_string_to_unsigned_long_long>:
const char *s,
unsigned long long *n,
char **endptr,
int base
)
{
200dcb4: 9d e3 bf 98 save %sp, -104, %sp
unsigned long long result;
char *end;
if ( !n )
200dcb8: 80 a6 60 00 cmp %i1, 0
200dcbc: 02 80 00 23 be 200dd48 <rtems_string_to_unsigned_long_long+0x94>
200dcc0: 82 10 20 09 mov 9, %g1
return RTEMS_INVALID_ADDRESS;
errno = 0;
200dcc4: 40 00 0b 5e call 2010a3c <__errno>
200dcc8: 01 00 00 00 nop
200dccc: c0 22 00 00 clr [ %o0 ]
*n = 0;
200dcd0: c0 26 40 00 clr [ %i1 ]
200dcd4: c0 26 60 04 clr [ %i1 + 4 ]
result = strtoull( s, &end, base );
200dcd8: 90 10 00 18 mov %i0, %o0
200dcdc: 92 07 bf fc add %fp, -4, %o1
200dce0: 40 00 18 63 call 2013e6c <strtoull>
200dce4: 94 10 00 1b mov %i3, %o2
if ( endptr )
200dce8: 80 a6 a0 00 cmp %i2, 0
return RTEMS_INVALID_ADDRESS;
errno = 0;
*n = 0;
result = strtoull( s, &end, base );
200dcec: b8 10 00 08 mov %o0, %i4
200dcf0: ba 10 00 09 mov %o1, %i5
if ( endptr )
200dcf4: 02 80 00 03 be 200dd00 <rtems_string_to_unsigned_long_long+0x4c>
200dcf8: c4 07 bf fc ld [ %fp + -4 ], %g2
*endptr = end;
200dcfc: c4 26 80 00 st %g2, [ %i2 ]
if ( end == s )
200dd00: 80 a0 80 18 cmp %g2, %i0
200dd04: 02 80 00 11 be 200dd48 <rtems_string_to_unsigned_long_long+0x94>
200dd08: 82 10 20 0b mov 0xb, %g1
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
200dd0c: 40 00 0b 4c call 2010a3c <__errno>
200dd10: 01 00 00 00 nop
200dd14: c2 02 00 00 ld [ %o0 ], %g1
200dd18: 80 a0 60 22 cmp %g1, 0x22
200dd1c: 32 80 00 0a bne,a 200dd44 <rtems_string_to_unsigned_long_long+0x90>
200dd20: f8 3e 40 00 std %i4, [ %i1 ]
(( result == 0 ) || ( result == ULONG_LONG_MAX )))
200dd24: 86 87 7f ff addcc %i5, -1, %g3
200dd28: 84 47 3f ff addx %i4, -1, %g2
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
200dd2c: 80 a0 bf ff cmp %g2, -1
200dd30: 12 80 00 04 bne 200dd40 <rtems_string_to_unsigned_long_long+0x8c><== NEVER TAKEN
200dd34: 80 a0 ff fd cmp %g3, -3
200dd38: 18 80 00 04 bgu 200dd48 <rtems_string_to_unsigned_long_long+0x94><== ALWAYS TAKEN
200dd3c: 82 10 20 0a mov 0xa, %g1
(( result == 0 ) || ( result == ULONG_LONG_MAX )))
return RTEMS_INVALID_NUMBER;
*n = result;
200dd40: f8 3e 40 00 std %i4, [ %i1 ] <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
200dd44: 82 10 20 00 clr %g1
}
200dd48: 81 c7 e0 08 ret
200dd4c: 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 b8 or %g2, 0x1b8, %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 28 or %g2, 0x328, %g2 ! 2020328 <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 40 or %l2, 0x240, %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 84 or %l3, 0x84, %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 60 or %l4, 0x160, %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 dc call 20140f0 <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 2c call 2014248 <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 9d call 200b820 <_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 99 call 200b820 <_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 95 call 200b820 <_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 a5 call 200b86c <_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 c9 call 2013920 <strcpy>
2003200: 90 07 bf 00 add %fp, -256, %o0
if (full_filename[strlen(full_filename)-1] != '/')
2003204: 40 00 43 89 call 2014028 <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 6f call 20137dc <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 6c call 20137dc <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 71 call 2014028 <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 0a call 200bed0 <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
0200f468 <rtems_task_mode>:
rtems_status_code rtems_task_mode(
rtems_mode mode_set,
rtems_mode mask,
rtems_mode *previous_mode_set
)
{
200f468: 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 )
200f46c: 80 a6 a0 00 cmp %i2, 0
200f470: 02 80 00 5a be 200f5d8 <rtems_task_mode+0x170>
200f474: 82 10 20 09 mov 9, %g1
return RTEMS_INVALID_ADDRESS;
executing = _Thread_Executing;
200f478: 03 00 80 78 sethi %hi(0x201e000), %g1
200f47c: f8 00 60 2c ld [ %g1 + 0x2c ], %i4 ! 201e02c <_Per_CPU_Information+0xc>
api = executing->API_Extensions[ THREAD_API_RTEMS ];
asr = &api->Signal;
old_mode = (executing->is_preemptible) ? RTEMS_PREEMPT : RTEMS_NO_PREEMPT;
200f480: 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 ];
200f484: fa 07 21 58 ld [ %i4 + 0x158 ], %i5
asr = &api->Signal;
old_mode = (executing->is_preemptible) ? RTEMS_PREEMPT : RTEMS_NO_PREEMPT;
200f488: 80 a0 00 01 cmp %g0, %g1
if ( executing->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_NONE )
200f48c: 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;
200f490: b6 60 3f ff subx %g0, -1, %i3
if ( executing->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_NONE )
200f494: 80 a0 60 00 cmp %g1, 0
200f498: 02 80 00 03 be 200f4a4 <rtems_task_mode+0x3c>
200f49c: b7 2e e0 08 sll %i3, 8, %i3
old_mode |= RTEMS_NO_TIMESLICE;
else
old_mode |= RTEMS_TIMESLICE;
200f4a0: b6 16 e2 00 or %i3, 0x200, %i3
old_mode |= (asr->is_enabled) ? RTEMS_ASR : RTEMS_NO_ASR;
200f4a4: c2 0f 60 08 ldub [ %i5 + 8 ], %g1
200f4a8: 80 a0 00 01 cmp %g0, %g1
old_mode |= _ISR_Get_level();
200f4ac: 7f ff f0 0d call 200b4e0 <_CPU_ISR_Get_level>
200f4b0: 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;
200f4b4: a1 2c 20 0a sll %l0, 0xa, %l0
200f4b8: 90 14 00 08 or %l0, %o0, %o0
old_mode |= _ISR_Get_level();
200f4bc: b6 12 00 1b or %o0, %i3, %i3
*previous_mode_set = old_mode;
/*
* These are generic thread scheduling characteristics.
*/
if ( mask & RTEMS_PREEMPT_MASK )
200f4c0: 80 8e 61 00 btst 0x100, %i1
200f4c4: 02 80 00 06 be 200f4dc <rtems_task_mode+0x74>
200f4c8: 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;
200f4cc: 83 36 20 08 srl %i0, 8, %g1
200f4d0: 82 18 60 01 xor %g1, 1, %g1
200f4d4: 82 08 60 01 and %g1, 1, %g1
executing->is_preemptible = _Modes_Is_preempt(mode_set) ? true : false;
200f4d8: c2 2f 20 70 stb %g1, [ %i4 + 0x70 ]
if ( mask & RTEMS_TIMESLICE_MASK ) {
200f4dc: 80 8e 62 00 btst 0x200, %i1
200f4e0: 02 80 00 0b be 200f50c <rtems_task_mode+0xa4>
200f4e4: 80 8e 60 0f btst 0xf, %i1
if ( _Modes_Is_timeslice(mode_set) ) {
200f4e8: 80 8e 22 00 btst 0x200, %i0
200f4ec: 22 80 00 07 be,a 200f508 <rtems_task_mode+0xa0>
200f4f0: c0 27 20 78 clr [ %i4 + 0x78 ]
executing->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE;
200f4f4: 82 10 20 01 mov 1, %g1
200f4f8: c2 27 20 78 st %g1, [ %i4 + 0x78 ]
executing->cpu_time_budget = _Thread_Ticks_per_timeslice;
200f4fc: 03 00 80 76 sethi %hi(0x201d800), %g1
200f500: c2 00 62 50 ld [ %g1 + 0x250 ], %g1 ! 201da50 <_Thread_Ticks_per_timeslice>
200f504: c2 27 20 74 st %g1, [ %i4 + 0x74 ]
}
/*
* Set the new interrupt level
*/
if ( mask & RTEMS_INTERRUPT_MASK )
200f508: 80 8e 60 0f btst 0xf, %i1
200f50c: 02 80 00 06 be 200f524 <rtems_task_mode+0xbc>
200f510: 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 );
200f514: 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 ) );
200f518: 7f ff cc 6f call 20026d4 <sparc_enable_interrupts>
200f51c: 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 ) {
200f520: 80 8e 64 00 btst 0x400, %i1
200f524: 02 80 00 14 be 200f574 <rtems_task_mode+0x10c>
200f528: 88 10 20 00 clr %g4
is_asr_enabled = _Modes_Is_asr_disabled( mode_set ) ? false : true;
if ( is_asr_enabled != asr->is_enabled ) {
200f52c: 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;
200f530: b1 36 20 0a srl %i0, 0xa, %i0
200f534: b0 1e 20 01 xor %i0, 1, %i0
200f538: b0 0e 20 01 and %i0, 1, %i0
if ( is_asr_enabled != asr->is_enabled ) {
200f53c: 80 a6 00 01 cmp %i0, %g1
200f540: 22 80 00 0e be,a 200f578 <rtems_task_mode+0x110>
200f544: 03 00 80 77 sethi %hi(0x201dc00), %g1
)
{
rtems_signal_set _signals;
ISR_Level _level;
_ISR_Disable( _level );
200f548: 7f ff cc 5f call 20026c4 <sparc_disable_interrupts>
200f54c: f0 2f 60 08 stb %i0, [ %i5 + 8 ]
_signals = information->signals_pending;
200f550: c2 07 60 18 ld [ %i5 + 0x18 ], %g1
information->signals_pending = information->signals_posted;
200f554: c4 07 60 14 ld [ %i5 + 0x14 ], %g2
information->signals_posted = _signals;
200f558: 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;
200f55c: c4 27 60 18 st %g2, [ %i5 + 0x18 ]
information->signals_posted = _signals;
_ISR_Enable( _level );
200f560: 7f ff cc 5d call 20026d4 <sparc_enable_interrupts>
200f564: 01 00 00 00 nop
asr->is_enabled = is_asr_enabled;
_ASR_Swap_signals( asr );
if ( _ASR_Are_signals_pending( asr ) ) {
200f568: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
200f56c: 80 a0 00 01 cmp %g0, %g1
200f570: 88 40 20 00 addx %g0, 0, %g4
needs_asr_dispatching = true;
}
}
}
if ( _System_state_Is_up( _System_state_Get() ) ) {
200f574: 03 00 80 77 sethi %hi(0x201dc00), %g1
200f578: c4 00 60 30 ld [ %g1 + 0x30 ], %g2 ! 201dc30 <_System_state_Current>
200f57c: 80 a0 a0 03 cmp %g2, 3
200f580: 12 80 00 16 bne 200f5d8 <rtems_task_mode+0x170>
200f584: 82 10 20 00 clr %g1
bool are_signals_pending
)
{
Thread_Control *executing;
executing = _Thread_Executing;
200f588: 07 00 80 78 sethi %hi(0x201e000), %g3
if ( are_signals_pending ||
200f58c: 80 89 20 ff btst 0xff, %g4
bool are_signals_pending
)
{
Thread_Control *executing;
executing = _Thread_Executing;
200f590: 86 10 e0 20 or %g3, 0x20, %g3
if ( are_signals_pending ||
200f594: 12 80 00 0a bne 200f5bc <rtems_task_mode+0x154>
200f598: c4 00 e0 0c ld [ %g3 + 0xc ], %g2
200f59c: c6 00 e0 10 ld [ %g3 + 0x10 ], %g3
200f5a0: 80 a0 80 03 cmp %g2, %g3
200f5a4: 02 80 00 0d be 200f5d8 <rtems_task_mode+0x170>
200f5a8: 01 00 00 00 nop
(!_Thread_Is_heir( executing ) && executing->is_preemptible) ) {
200f5ac: c4 08 a0 70 ldub [ %g2 + 0x70 ], %g2
200f5b0: 80 a0 a0 00 cmp %g2, 0
200f5b4: 02 80 00 09 be 200f5d8 <rtems_task_mode+0x170> <== NEVER TAKEN
200f5b8: 01 00 00 00 nop
_Thread_Dispatch_necessary = true;
200f5bc: 84 10 20 01 mov 1, %g2 ! 1 <PROM_START+0x1>
200f5c0: 03 00 80 78 sethi %hi(0x201e000), %g1
200f5c4: 82 10 60 20 or %g1, 0x20, %g1 ! 201e020 <_Per_CPU_Information>
200f5c8: c4 28 60 18 stb %g2, [ %g1 + 0x18 ]
if (_Thread_Evaluate_is_dispatch_needed( needs_asr_dispatching ) )
_Thread_Dispatch();
200f5cc: 7f ff ea ac call 200a07c <_Thread_Dispatch>
200f5d0: 01 00 00 00 nop
}
return RTEMS_SUCCESSFUL;
200f5d4: 82 10 20 00 clr %g1 ! 0 <PROM_START>
}
200f5d8: 81 c7 e0 08 ret
200f5dc: 91 e8 00 01 restore %g0, %g1, %o0
0200bf54 <rtems_task_set_priority>:
rtems_status_code rtems_task_set_priority(
rtems_id id,
rtems_task_priority new_priority,
rtems_task_priority *old_priority
)
{
200bf54: 9d e3 bf 98 save %sp, -104, %sp
register Thread_Control *the_thread;
Objects_Locations location;
if ( new_priority != RTEMS_CURRENT_PRIORITY &&
200bf58: 80 a6 60 00 cmp %i1, 0
200bf5c: 02 80 00 08 be 200bf7c <rtems_task_set_priority+0x28>
200bf60: 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 ) );
200bf64: 03 00 80 84 sethi %hi(0x2021000), %g1
200bf68: c4 08 61 98 ldub [ %g1 + 0x198 ], %g2 ! 2021198 <rtems_maximum_priority>
200bf6c: 80 a6 40 02 cmp %i1, %g2
200bf70: 18 80 00 1e bgu 200bfe8 <rtems_task_set_priority+0x94>
200bf74: 82 10 20 13 mov 0x13, %g1
!_RTEMS_tasks_Priority_is_valid( new_priority ) )
return RTEMS_INVALID_PRIORITY;
if ( !old_priority )
200bf78: 80 a6 a0 00 cmp %i2, 0
200bf7c: 02 80 00 1b be 200bfe8 <rtems_task_set_priority+0x94>
200bf80: 82 10 20 09 mov 9, %g1
return RTEMS_INVALID_ADDRESS;
the_thread = _Thread_Get( id, &location );
200bf84: 90 10 00 18 mov %i0, %o0
200bf88: 40 00 09 8a call 200e5b0 <_Thread_Get>
200bf8c: 92 07 bf fc add %fp, -4, %o1
switch ( location ) {
200bf90: c2 07 bf fc ld [ %fp + -4 ], %g1
200bf94: 80 a0 60 00 cmp %g1, 0
200bf98: 12 80 00 14 bne 200bfe8 <rtems_task_set_priority+0x94>
200bf9c: 82 10 20 04 mov 4, %g1
case OBJECTS_LOCAL:
/* XXX need helper to "convert" from core priority */
*old_priority = the_thread->current_priority;
200bfa0: c2 02 20 14 ld [ %o0 + 0x14 ], %g1
if ( new_priority != RTEMS_CURRENT_PRIORITY ) {
200bfa4: 80 a6 60 00 cmp %i1, 0
200bfa8: 02 80 00 0d be 200bfdc <rtems_task_set_priority+0x88>
200bfac: c2 26 80 00 st %g1, [ %i2 ]
the_thread->real_priority = new_priority;
if ( the_thread->resource_count == 0 ||
200bfb0: c2 02 20 1c ld [ %o0 + 0x1c ], %g1
200bfb4: 80 a0 60 00 cmp %g1, 0
200bfb8: 02 80 00 06 be 200bfd0 <rtems_task_set_priority+0x7c>
200bfbc: f2 22 20 18 st %i1, [ %o0 + 0x18 ]
200bfc0: c2 02 20 14 ld [ %o0 + 0x14 ], %g1
200bfc4: 80 a0 40 19 cmp %g1, %i1
200bfc8: 08 80 00 05 bleu 200bfdc <rtems_task_set_priority+0x88> <== ALWAYS TAKEN
200bfcc: 01 00 00 00 nop
the_thread->current_priority > new_priority )
_Thread_Change_priority( the_thread, new_priority, false );
200bfd0: 92 10 00 19 mov %i1, %o1
200bfd4: 40 00 08 45 call 200e0e8 <_Thread_Change_priority>
200bfd8: 94 10 20 00 clr %o2
}
_Thread_Enable_dispatch();
200bfdc: 40 00 09 68 call 200e57c <_Thread_Enable_dispatch>
200bfe0: 01 00 00 00 nop
200bfe4: 82 10 20 00 clr %g1 ! 0 <PROM_START>
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
200bfe8: 81 c7 e0 08 ret
200bfec: 91 e8 00 01 restore %g0, %g1, %o0
02006518 <rtems_termios_baud_to_index>:
#include <rtems/termiostypes.h>
int rtems_termios_baud_to_index(
rtems_termios_baud_t termios_baud
)
{
2006518: 82 10 00 08 mov %o0, %g1
int baud_index;
switch (termios_baud) {
200651c: 80 a0 60 09 cmp %g1, 9
2006520: 02 80 00 17 be 200657c <rtems_termios_baud_to_index+0x64>
2006524: 90 10 20 09 mov 9, %o0
2006528: 80 a0 60 09 cmp %g1, 9
200652c: 18 80 00 23 bgu 20065b8 <rtems_termios_baud_to_index+0xa0>
2006530: 80 a0 60 0e cmp %g1, 0xe
2006534: 80 a0 60 04 cmp %g1, 4
2006538: 02 80 00 11 be 200657c <rtems_termios_baud_to_index+0x64>
200653c: 90 10 20 04 mov 4, %o0
2006540: 80 a0 60 04 cmp %g1, 4
2006544: 18 80 00 10 bgu 2006584 <rtems_termios_baud_to_index+0x6c>
2006548: 80 a0 60 06 cmp %g1, 6
200654c: 80 a0 60 01 cmp %g1, 1
2006550: 02 80 00 0b be 200657c <rtems_termios_baud_to_index+0x64>
2006554: 90 10 20 01 mov 1, %o0
2006558: 80 a0 60 01 cmp %g1, 1
200655c: 0a 80 00 08 bcs 200657c <rtems_termios_baud_to_index+0x64>
2006560: 90 10 20 00 clr %o0
2006564: 80 a0 60 02 cmp %g1, 2
2006568: 02 80 00 05 be 200657c <rtems_termios_baud_to_index+0x64>
200656c: 90 10 20 02 mov 2, %o0
2006570: 80 a0 60 03 cmp %g1, 3
2006574: 12 80 00 3b bne 2006660 <rtems_termios_baud_to_index+0x148><== NEVER TAKEN
2006578: 90 10 20 03 mov 3, %o0
200657c: 81 c3 e0 08 retl
2006580: 01 00 00 00 nop
2006584: 02 bf ff fe be 200657c <rtems_termios_baud_to_index+0x64>
2006588: 90 10 20 06 mov 6, %o0 ! 6 <PROM_START+0x6>
200658c: 80 a0 60 06 cmp %g1, 6
2006590: 0a bf ff fb bcs 200657c <rtems_termios_baud_to_index+0x64>
2006594: 90 10 20 05 mov 5, %o0
2006598: 80 a0 60 07 cmp %g1, 7
200659c: 02 bf ff f8 be 200657c <rtems_termios_baud_to_index+0x64>
20065a0: 90 10 20 07 mov 7, %o0
20065a4: 80 a0 60 08 cmp %g1, 8
20065a8: 12 80 00 2e bne 2006660 <rtems_termios_baud_to_index+0x148><== NEVER TAKEN
20065ac: 90 10 20 08 mov 8, %o0
20065b0: 81 c3 e0 08 retl
20065b4: 01 00 00 00 nop
20065b8: 02 bf ff f1 be 200657c <rtems_termios_baud_to_index+0x64>
20065bc: 90 10 20 0e mov 0xe, %o0 ! e <PROM_START+0xe>
20065c0: 80 a0 60 0e cmp %g1, 0xe
20065c4: 18 80 00 10 bgu 2006604 <rtems_termios_baud_to_index+0xec>
20065c8: 05 00 00 04 sethi %hi(0x1000), %g2
20065cc: 80 a0 60 0b cmp %g1, 0xb
20065d0: 02 bf ff eb be 200657c <rtems_termios_baud_to_index+0x64>
20065d4: 90 10 20 0b mov 0xb, %o0
20065d8: 80 a0 60 0b cmp %g1, 0xb
20065dc: 0a bf ff e8 bcs 200657c <rtems_termios_baud_to_index+0x64>
20065e0: 90 10 20 0a mov 0xa, %o0
20065e4: 80 a0 60 0c cmp %g1, 0xc
20065e8: 02 bf ff e5 be 200657c <rtems_termios_baud_to_index+0x64>
20065ec: 90 10 20 0c mov 0xc, %o0
20065f0: 80 a0 60 0d cmp %g1, 0xd
20065f4: 12 80 00 1b bne 2006660 <rtems_termios_baud_to_index+0x148><== NEVER TAKEN
20065f8: 90 10 20 0d mov 0xd, %o0
20065fc: 81 c3 e0 08 retl
2006600: 01 00 00 00 nop
2006604: 86 10 a0 02 or %g2, 2, %g3
2006608: 80 a0 40 03 cmp %g1, %g3
200660c: 02 bf ff dc be 200657c <rtems_termios_baud_to_index+0x64>
2006610: 90 10 20 11 mov 0x11, %o0
2006614: 80 a0 40 03 cmp %g1, %g3
2006618: 38 80 00 0b bgu,a 2006644 <rtems_termios_baud_to_index+0x12c>
200661c: 86 10 a0 03 or %g2, 3, %g3
2006620: 80 a0 60 0f cmp %g1, 0xf
2006624: 02 bf ff d6 be 200657c <rtems_termios_baud_to_index+0x64>
2006628: 90 10 20 0f mov 0xf, %o0
200662c: 84 10 a0 01 or %g2, 1, %g2
2006630: 80 a0 40 02 cmp %g1, %g2
2006634: 12 80 00 0b bne 2006660 <rtems_termios_baud_to_index+0x148><== NEVER TAKEN
2006638: 90 10 20 10 mov 0x10, %o0
200663c: 81 c3 e0 08 retl
2006640: 01 00 00 00 nop
2006644: 80 a0 40 03 cmp %g1, %g3
2006648: 02 bf ff cd be 200657c <rtems_termios_baud_to_index+0x64>
200664c: 90 10 20 12 mov 0x12, %o0
2006650: 84 10 a0 04 or %g2, 4, %g2
2006654: 80 a0 40 02 cmp %g1, %g2
2006658: 02 bf ff c9 be 200657c <rtems_termios_baud_to_index+0x64>
200665c: 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;
2006660: 90 10 3f ff mov -1, %o0
}
return baud_index;
}
2006664: 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 98 ld [ %g1 + 0x198 ], %o0 ! 201d998 <rtems_termios_ttyMutex>
200586c: 40 00 08 27 call 2007908 <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 e4 or %g1, 0x1e4, %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 0f call 2007908 <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 4e call 2007a30 <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 c6 call 200742c <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 c0 call 200742c <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 b7 call 200801c <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>
2005980: c2 20 a1 9c st %g1, [ %g2 + 0x19c ]
rtems_termios_ttyTail->forw = NULL;
2005984: 10 80 00 03 b 2005990 <rtems_termios_close+0x13c>
2005988: c0 20 40 00 clr [ %g1 ]
}
} 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>
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 a0 st %g1, [ %g2 + 0x1a0 ]
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 ]
}
rtems_semaphore_delete (tty->isem);
20059bc: 40 00 07 a4 call 200784c <rtems_semaphore_delete>
20059c0: d0 07 60 14 ld [ %i5 + 0x14 ], %o0
rtems_semaphore_delete (tty->osem);
20059c4: 40 00 07 a2 call 200784c <rtems_semaphore_delete>
20059c8: d0 07 60 18 ld [ %i5 + 0x18 ], %o0
rtems_semaphore_delete (tty->rawOutBuf.Semaphore);
20059cc: 40 00 07 a0 call 200784c <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 96 call 200784c <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 98 ld [ %g1 + 0x198 ], %o0 ! 201d998 <rtems_termios_ttyMutex>
2005a24: 40 00 08 03 call 2007a30 <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 9c call 200742c <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 93 call 200801c <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 98 ld [ %g1 + 0x298 ], %g1 ! 201d698 <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 e4 or %g1, 0x1e4, %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 e1 call 2018b48 <.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 d8 call 2018b48 <.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 46 call 2007a30 <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 a5 call 2007908 <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 e4 or %g1, 0x1e4, %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 f9 call 2010334 <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 f5 call 2010334 <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 41 call 20071f4 <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 ae call 20187b0 <.umul>
2005cfc: 92 10 00 1c mov %i4, %o1
rtems_clock_get_ticks_per_second() / 10;
2005d00: 40 00 4a e6 call 2018898 <.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 e4 or %g1, 0x1e4, %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 e4 or %g2, 0x1e4, %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 f7 call 2007a30 <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 98 ld [ %g1 + 0x198 ], %o0 ! 201d998 <rtems_termios_ttyMutex>
2005414: 92 10 20 00 clr %o1
2005418: 40 00 09 3c call 2007908 <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 a0 ld [ %g1 + 0x1a0 ], %l0 ! 201d9a0 <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 63 08 ld [ %g1 + 0x308 ], %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> <== NEVER TAKEN
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 63 0c ld [ %g1 + 0x30c ], %g1 ! 201cf0c <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> <== NEVER TAKEN
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 10 ld [ %g1 + 0x310 ], %o0 ! 201cf10 <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> <== ALWAYS TAKEN
20054cc: d0 27 60 1c st %o0, [ %i5 + 0x1c ]
free((void *)(tty->rawOutBuf.theBuf));
20054d0: 7f ff f8 c3 call 20037dc <free> <== NOT EXECUTED
20054d4: 90 10 00 12 mov %l2, %o0 <== NOT EXECUTED
free((void *)(tty->rawInBuf.theBuf));
20054d8: 7f ff f8 c1 call 20037dc <free> <== NOT EXECUTED
20054dc: 90 10 00 11 mov %l1, %o0 <== NOT EXECUTED
free(tty);
20054e0: 7f ff f8 bf call 20037dc <free> <== NOT EXECUTED
20054e4: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
rtems_semaphore_release (rtems_termios_ttyMutex);
20054e8: 03 00 80 76 sethi %hi(0x201d800), %g1 <== NOT EXECUTED
20054ec: d0 00 61 98 ld [ %g1 + 0x198 ], %o0 ! 201d998 <rtems_termios_ttyMutex><== NOT EXECUTED
20054f0: 40 00 09 50 call 2007a30 <rtems_semaphore_release> <== NOT EXECUTED
20054f4: b8 10 20 1a mov 0x1a, %i4 <== NOT EXECUTED
return RTEMS_NO_MEMORY;
20054f8: 81 c7 e0 08 ret <== NOT EXECUTED
20054fc: 91 e8 00 1c restore %g0, %i4, %o0 <== NOT EXECUTED
}
/*
* 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 a0 st %i5, [ %g1 + 0x1a0 ] ! 201d9a0 <rtems_termios_ttyHead>
if (rtems_termios_ttyTail == NULL)
2005530: 03 00 80 76 sethi %hi(0x201d800), %g1
2005534: c4 00 61 9c ld [ %g1 + 0x19c ], %g2 ! 201d99c <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 9c st %i5, [ %g1 + 0x19c ]
/*
* 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 14 ldsb [ %l0 + 0x314 ], %o0 ! 201cf14 <c.6812>
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 49 call 2007690 <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 14 ldsb [ %l0 + 0x314 ], %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 3d call 2007690 <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 14 ldsb [ %l0 + 0x314 ], %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 32 call 2007690 <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 53 call 2010334 <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 14 ldsb [ %l0 + 0x314 ], %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 32 call 2007ae4 <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 14 ldsb [ %l0 + 0x314 ], %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 26 call 2007ae4 <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 14 ldsb [ %g1 + 0x314 ], %o0 ! 201cf14 <c.6812>
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 fc call 2007690 <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 14 ldub [ %g1 + 0x314 ], %g2 ! 201cf14 <c.6812>
2005770: c6 48 63 14 ldsb [ %g1 + 0x314 ], %g3
2005774: 80 a0 e0 7a cmp %g3, 0x7a
2005778: 12 80 00 03 bne 2005784 <rtems_termios_open+0x37c> <== ALWAYS TAKEN
200577c: 84 00 a0 01 inc %g2
c = 'a';
2005780: 84 10 20 61 mov 0x61, %g2 <== NOT EXECUTED
2005784: c4 28 63 14 stb %g2, [ %g1 + 0x314 ]
}
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 67 call 2007d78 <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 5f call 2007d78 <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 0a 03 call 200801c <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 85 call 2007a30 <rtems_semaphore_release>
2005820: d0 00 61 98 ld [ %g1 + 0x198 ], %o0 ! 201d998 <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> <== ALWAYS TAKEN
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> <== NOT EXECUTED
2005844: 03 00 80 76 sethi %hi(0x201d800), %g1 <== NOT EXECUTED
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 28 call 2018b48 <.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 90 call 2007908 <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 50 call 200801c <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 9d call 2007908 <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 e4 or %g1, 0x1e4, %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 aa call 2007de8 <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 aa call 2007214 <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 8f call 2007de8 <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 8f call 2007214 <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 bf call 2018b48 <.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 b6 call 2018b48 <.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 10 ld [ %l1 + 0x310 ], %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 d7 call 2007908 <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 09 call 2007a30 <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 0a 07 call 2007a30 <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 41 call 2018b48 <.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 f4 call 2007a30 <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 58 call 20072a0 <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 ac call 2007c0c <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
02006e14 <rtems_termios_set_initial_baud>:
int rtems_termios_set_initial_baud(
struct rtems_termios_tty *tty,
rtems_termios_baud_t baud
)
{
2006e14: 9d e3 bf a0 save %sp, -96, %sp
int rv = 0;
tcflag_t c_cflag_baud = rtems_termios_number_to_baud(baud);
2006e18: 40 00 16 78 call 200c7f8 <rtems_termios_number_to_baud>
2006e1c: 90 10 00 19 mov %i1, %o0
if ( c_cflag_baud != 0 ) {
2006e20: 80 a2 20 00 cmp %o0, 0
2006e24: 02 80 00 09 be 2006e48 <rtems_termios_set_initial_baud+0x34><== ALWAYS TAKEN
2006e28: 03 3f ff fb sethi %hi(0xffffec00), %g1
tcflag_t cbaud = CBAUD;
tty->termios.c_cflag = (tty->termios.c_cflag & ~cbaud) | c_cflag_baud;
2006e2c: c4 06 20 38 ld [ %i0 + 0x38 ], %g2 <== NOT EXECUTED
2006e30: 82 10 63 f0 or %g1, 0x3f0, %g1 <== NOT EXECUTED
2006e34: 82 08 80 01 and %g2, %g1, %g1 <== NOT EXECUTED
2006e38: 90 12 00 01 or %o0, %g1, %o0 <== NOT EXECUTED
2006e3c: d0 26 20 38 st %o0, [ %i0 + 0x38 ] <== NOT EXECUTED
int rtems_termios_set_initial_baud(
struct rtems_termios_tty *tty,
rtems_termios_baud_t baud
)
{
int rv = 0;
2006e40: 81 c7 e0 08 ret <== NOT EXECUTED
2006e44: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED
} else {
rv = -1;
}
return rv;
}
2006e48: 81 c7 e0 08 ret
2006e4c: 91 e8 3f ff restore %g0, -1, %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 e4 or %i5, 0x1e4, %i5 ! 201d5e4 <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 d5 call 20072a0 <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 29 call 2007c0c <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 ce call 2007908 <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 e4 or %g1, 0x1e4, %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 f2 call 2007a30 <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
02018470 <rtems_timer_cancel>:
*/
rtems_status_code rtems_timer_cancel(
rtems_id id
)
{
2018470: 9d e3 bf 98 save %sp, -104, %sp
RTEMS_INLINE_ROUTINE Timer_Control *_Timer_Get (
Objects_Id id,
Objects_Locations *location
)
{
return (Timer_Control *)
2018474: 11 00 80 f5 sethi %hi(0x203d400), %o0
2018478: 92 10 00 18 mov %i0, %o1
201847c: 90 12 22 f4 or %o0, 0x2f4, %o0
2018480: 40 00 0c 36 call 201b558 <_Objects_Get>
2018484: 94 07 bf fc add %fp, -4, %o2
Timer_Control *the_timer;
Objects_Locations location;
the_timer = _Timer_Get( id, &location );
switch ( location ) {
2018488: c2 07 bf fc ld [ %fp + -4 ], %g1
201848c: 80 a0 60 00 cmp %g1, 0
2018490: 12 80 00 0c bne 20184c0 <rtems_timer_cancel+0x50>
2018494: 01 00 00 00 nop
case OBJECTS_LOCAL:
if ( !_Timer_Is_dormant_class( the_timer->the_class ) )
2018498: c2 02 20 38 ld [ %o0 + 0x38 ], %g1
201849c: 80 a0 60 04 cmp %g1, 4
20184a0: 02 80 00 04 be 20184b0 <rtems_timer_cancel+0x40> <== NEVER TAKEN
20184a4: 01 00 00 00 nop
(void) _Watchdog_Remove( &the_timer->Ticker );
20184a8: 40 00 14 35 call 201d57c <_Watchdog_Remove>
20184ac: 90 02 20 10 add %o0, 0x10, %o0
_Thread_Enable_dispatch();
20184b0: 40 00 10 00 call 201c4b0 <_Thread_Enable_dispatch>
20184b4: b0 10 20 00 clr %i0
20184b8: 81 c7 e0 08 ret
20184bc: 81 e8 00 00 restore
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
20184c0: 81 c7 e0 08 ret
20184c4: 91 e8 20 04 restore %g0, 4, %o0
02018984 <rtems_timer_server_fire_when>:
rtems_id id,
rtems_time_of_day *wall_time,
rtems_timer_service_routine_entry routine,
void *user_data
)
{
2018984: 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;
2018988: 03 00 80 f5 sethi %hi(0x203d400), %g1
201898c: f8 00 63 34 ld [ %g1 + 0x334 ], %i4 ! 203d734 <_Timer_server>
if ( !timer_server )
2018990: 80 a7 20 00 cmp %i4, 0
2018994: 02 80 00 3c be 2018a84 <rtems_timer_server_fire_when+0x100>
2018998: 82 10 20 0e mov 0xe, %g1
return RTEMS_INCORRECT_STATE;
if ( !_TOD.is_set )
201899c: 21 00 80 f3 sethi %hi(0x203cc00), %l0
20189a0: 82 14 20 c8 or %l0, 0xc8, %g1 ! 203ccc8 <_TOD>
20189a4: c4 08 60 14 ldub [ %g1 + 0x14 ], %g2
20189a8: 80 a0 a0 00 cmp %g2, 0
20189ac: 02 80 00 36 be 2018a84 <rtems_timer_server_fire_when+0x100><== NEVER TAKEN
20189b0: 82 10 20 0b mov 0xb, %g1
return RTEMS_NOT_DEFINED;
if ( !routine )
20189b4: 80 a6 a0 00 cmp %i2, 0
20189b8: 02 80 00 33 be 2018a84 <rtems_timer_server_fire_when+0x100>
20189bc: 82 10 20 09 mov 9, %g1
return RTEMS_INVALID_ADDRESS;
if ( !_TOD_Validate( wall_time ) )
20189c0: 7f ff f3 82 call 20157c8 <_TOD_Validate>
20189c4: 90 10 00 19 mov %i1, %o0
20189c8: 80 8a 20 ff btst 0xff, %o0
20189cc: 02 80 00 2e be 2018a84 <rtems_timer_server_fire_when+0x100>
20189d0: 82 10 20 14 mov 0x14, %g1
return RTEMS_INVALID_CLOCK;
seconds = _TOD_To_seconds( wall_time );
20189d4: 7f ff f3 43 call 20156e0 <_TOD_To_seconds>
20189d8: 90 10 00 19 mov %i1, %o0
20189dc: b2 10 00 08 mov %o0, %i1
20189e0: d0 1c 20 c8 ldd [ %l0 + 0xc8 ], %o0
20189e4: 94 10 20 00 clr %o2
20189e8: 17 0e e6 b2 sethi %hi(0x3b9ac800), %o3
20189ec: 40 00 50 0a call 202ca14 <__divdi3>
20189f0: 96 12 e2 00 or %o3, 0x200, %o3 ! 3b9aca00 <RAM_END+0x395aca00>
if ( seconds <= _TOD_Seconds_since_epoch() )
20189f4: 80 a6 40 09 cmp %i1, %o1
20189f8: 08 80 00 23 bleu 2018a84 <rtems_timer_server_fire_when+0x100>
20189fc: 82 10 20 14 mov 0x14, %g1
2018a00: 11 00 80 f5 sethi %hi(0x203d400), %o0
2018a04: 92 10 00 18 mov %i0, %o1
2018a08: 90 12 22 f4 or %o0, 0x2f4, %o0
2018a0c: 40 00 0a d3 call 201b558 <_Objects_Get>
2018a10: 94 07 bf fc add %fp, -4, %o2
return RTEMS_INVALID_CLOCK;
the_timer = _Timer_Get( id, &location );
switch ( location ) {
2018a14: c2 07 bf fc ld [ %fp + -4 ], %g1
2018a18: 80 a0 60 00 cmp %g1, 0
2018a1c: 12 80 00 19 bne 2018a80 <rtems_timer_server_fire_when+0xfc>
2018a20: ba 10 00 08 mov %o0, %i5
case OBJECTS_LOCAL:
(void) _Watchdog_Remove( &the_timer->Ticker );
2018a24: 40 00 12 d6 call 201d57c <_Watchdog_Remove>
2018a28: 90 02 20 10 add %o0, 0x10, %o0
2018a2c: d0 1c 20 c8 ldd [ %l0 + 0xc8 ], %o0
the_timer->the_class = TIMER_TIME_OF_DAY_ON_TASK;
2018a30: 82 10 20 03 mov 3, %g1
2018a34: 94 10 20 00 clr %o2
2018a38: c2 27 60 38 st %g1, [ %i5 + 0x38 ]
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
2018a3c: c0 27 60 18 clr [ %i5 + 0x18 ]
the_watchdog->routine = routine;
2018a40: f4 27 60 2c st %i2, [ %i5 + 0x2c ]
the_watchdog->id = id;
2018a44: f0 27 60 30 st %i0, [ %i5 + 0x30 ]
the_watchdog->user_data = user_data;
2018a48: f6 27 60 34 st %i3, [ %i5 + 0x34 ]
2018a4c: 17 0e e6 b2 sethi %hi(0x3b9ac800), %o3
2018a50: 40 00 4f f1 call 202ca14 <__divdi3>
2018a54: 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 );
2018a58: 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();
2018a5c: 92 26 40 09 sub %i1, %o1, %o1
(*timer_server->schedule_operation)( timer_server, the_timer );
2018a60: 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();
2018a64: d2 27 60 1c st %o1, [ %i5 + 0x1c ]
(*timer_server->schedule_operation)( timer_server, the_timer );
2018a68: 9f c0 40 00 call %g1
2018a6c: 92 10 00 1d mov %i5, %o1
_Thread_Enable_dispatch();
2018a70: 40 00 0e 90 call 201c4b0 <_Thread_Enable_dispatch>
2018a74: 01 00 00 00 nop
return RTEMS_SUCCESSFUL;
2018a78: 10 80 00 03 b 2018a84 <rtems_timer_server_fire_when+0x100>
2018a7c: 82 10 20 00 clr %g1 ! 0 <PROM_START>
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
2018a80: 82 10 20 04 mov 4, %g1
}
2018a84: 81 c7 e0 08 ret
2018a88: 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 78 ld [ %g1 + 0x78 ], %g1 ! 201d078 <_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 20 call 200fe24 <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 4c ld [ %g2 + 0x14c ], %g1 ! 201d94c <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 4c st %g3, [ %g2 + 0x14c ]
*
* 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 f0 ld [ %g1 + 0x2f0 ], %g2 ! 201daf0 <_Thread_Dispatch_disable_level><== NOT EXECUTED
20035e4: 84 00 a0 01 inc %g2 <== NOT EXECUTED
20035e8: c4 20 62 f0 st %g2, [ %g1 + 0x2f0 ] <== NOT EXECUTED
return _Thread_Dispatch_disable_level;
20035ec: c2 00 62 f0 ld [ %g1 + 0x2f0 ], %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 4c ld [ %g1 + 0x14c ], %g1 ! 201d94c <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 03 call 200fa18 <__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 78 ld [ %i3 + 0x78 ], %g1 ! 201d078 <_impure_ptr>
2003620: 92 10 00 19 mov %i1, %o1
2003624: d0 00 60 0c ld [ %g1 + 0xc ], %o0
2003628: 40 00 46 34 call 2014ef8 <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 78 ld [ %i3 + 0x78 ], %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 f8 or %o1, 0x1f8, %o1
2003658: 40 00 32 e5 call 20101ec <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 5c call 2010fec <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 78 ld [ %g1 + 0x78 ], %g1 ! 201d078 <_impure_ptr>
2003698: 90 10 00 1d mov %i5, %o0
200369c: 40 00 36 54 call 2010fec <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 62 08 or %o1, 0x208, %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 78 ld [ %g1 + 0x78 ], %g1
20036bc: 13 00 80 6c sethi %hi(0x201b000), %o1
20036c0: d0 00 60 0c ld [ %g1 + 0xc ], %o0
20036c4: 92 12 62 18 or %o1, 0x218, %o1
20036c8: 94 10 00 1d mov %i5, %o2
20036cc: 40 00 32 c8 call 20101ec <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 78 ld [ %i5 + 0x78 ], %g1
20036dc: 13 00 80 6c sethi %hi(0x201b000), %o1
20036e0: d0 00 60 0c ld [ %g1 + 0xc ], %o0
20036e4: 40 00 32 c2 call 20101ec <fprintf>
20036e8: 92 12 60 50 or %o1, 0x50, %o1
(void) fflush(stderr);
20036ec: c2 07 60 78 ld [ %i5 + 0x78 ], %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 cc call 200fe24 <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
02023c6c <scanInt>:
/*
* Extract an integer value from the database
*/
static int
scanInt(FILE *fp, int *val)
{
2023c6c: 9d e3 bf a0 save %sp, -96, %sp
int c;
unsigned int i = 0;
unsigned int limit = INT_MAX;
2023c70: 37 1f ff ff sethi %hi(0x7ffffc00), %i3
int sign = 0;
2023c74: b8 10 20 00 clr %i4
static int
scanInt(FILE *fp, int *val)
{
int c;
unsigned int i = 0;
unsigned int limit = INT_MAX;
2023c78: b6 16 e3 ff or %i3, 0x3ff, %i3
*/
static int
scanInt(FILE *fp, int *val)
{
int c;
unsigned int i = 0;
2023c7c: ba 10 20 00 clr %i5
unsigned int limit = INT_MAX;
int sign = 0;
int d;
for (;;) {
c = getc(fp);
2023c80: 21 00 81 79 sethi %hi(0x205e400), %l0
limit++;
continue;
}
sign = 1;
}
if (!isdigit(c))
2023c84: 23 00 81 79 sethi %hi(0x205e400), %l1
unsigned int limit = INT_MAX;
int sign = 0;
int d;
for (;;) {
c = getc(fp);
2023c88: c2 06 20 04 ld [ %i0 + 4 ], %g1
2023c8c: 82 00 7f ff add %g1, -1, %g1
2023c90: 80 a0 60 00 cmp %g1, 0
2023c94: 16 80 00 07 bge 2023cb0 <scanInt+0x44> <== ALWAYS TAKEN
2023c98: c2 26 20 04 st %g1, [ %i0 + 4 ]
2023c9c: d0 04 21 60 ld [ %l0 + 0x160 ], %o0 <== NOT EXECUTED
2023ca0: 40 00 61 1e call 203c118 <__srget_r> <== NOT EXECUTED
2023ca4: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
if (c == ':')
2023ca8: 10 80 00 07 b 2023cc4 <scanInt+0x58> <== NOT EXECUTED
2023cac: 80 a2 20 3a cmp %o0, 0x3a <== NOT EXECUTED
unsigned int limit = INT_MAX;
int sign = 0;
int d;
for (;;) {
c = getc(fp);
2023cb0: c4 06 00 00 ld [ %i0 ], %g2
2023cb4: d0 08 80 00 ldub [ %g2 ], %o0
2023cb8: 84 00 a0 01 inc %g2
2023cbc: c4 26 00 00 st %g2, [ %i0 ]
if (c == ':')
2023cc0: 80 a2 20 3a cmp %o0, 0x3a
2023cc4: 02 80 00 21 be 2023d48 <scanInt+0xdc>
2023cc8: 80 a7 20 00 cmp %i4, 0
break;
if (sign == 0) {
2023ccc: 12 80 00 08 bne 2023cec <scanInt+0x80>
2023cd0: c4 04 61 50 ld [ %l1 + 0x150 ], %g2
if (c == '-') {
2023cd4: 80 a2 20 2d cmp %o0, 0x2d
2023cd8: 12 80 00 05 bne 2023cec <scanInt+0x80>
2023cdc: b8 10 20 01 mov 1, %i4
sign = -1;
limit++;
2023ce0: b6 06 e0 01 inc %i3
continue;
2023ce4: 10 bf ff e9 b 2023c88 <scanInt+0x1c>
2023ce8: b8 10 3f ff mov -1, %i4
}
sign = 1;
}
if (!isdigit(c))
2023cec: 84 00 80 08 add %g2, %o0, %g2
2023cf0: c4 08 a0 01 ldub [ %g2 + 1 ], %g2
2023cf4: 80 88 a0 04 btst 4, %g2
2023cf8: 02 80 00 1d be 2023d6c <scanInt+0x100>
2023cfc: b4 02 3f d0 add %o0, -48, %i2
return 0;
d = c - '0';
if ((i > (limit / 10))
2023d00: 92 10 20 0a mov 0xa, %o1
2023d04: 40 00 af bd call 204fbf8 <.udiv>
2023d08: 90 10 00 1b mov %i3, %o0
2023d0c: 80 a7 40 08 cmp %i5, %o0
2023d10: 38 80 00 15 bgu,a 2023d64 <scanInt+0xf8>
2023d14: b0 10 20 00 clr %i0
|| ((i == (limit / 10)) && (d > (limit % 10))))
2023d18: 12 80 00 08 bne 2023d38 <scanInt+0xcc>
2023d1c: 83 2f 60 01 sll %i5, 1, %g1
2023d20: 90 10 00 1b mov %i3, %o0
2023d24: 40 00 b0 61 call 204fea8 <.urem>
2023d28: 92 10 20 0a mov 0xa, %o1
2023d2c: 80 a6 80 08 cmp %i2, %o0
2023d30: 18 80 00 0f bgu 2023d6c <scanInt+0x100> <== ALWAYS TAKEN
2023d34: 83 2f 60 01 sll %i5, 1, %g1
return 0;
i = i * 10 + d;
2023d38: bb 2f 60 03 sll %i5, 3, %i5
2023d3c: ba 00 40 1d add %g1, %i5, %i5
2023d40: 10 bf ff d2 b 2023c88 <scanInt+0x1c>
2023d44: ba 06 80 1d add %i2, %i5, %i5
}
if (sign == 0)
2023d48: 02 80 00 07 be 2023d64 <scanInt+0xf8> <== NEVER TAKEN
2023d4c: b0 10 20 00 clr %i0
return 0;
*val = i * sign;
2023d50: 90 10 00 1c mov %i4, %o0
2023d54: 92 10 00 1d mov %i5, %o1
2023d58: 40 00 af 6e call 204fb10 <.umul>
2023d5c: b0 10 20 01 mov 1, %i0
2023d60: d0 26 40 00 st %o0, [ %i1 ]
return 1;
2023d64: 81 c7 e0 08 ret
2023d68: 81 e8 00 00 restore
continue;
}
sign = 1;
}
if (!isdigit(c))
return 0;
2023d6c: b0 10 20 00 clr %i0
}
if (sign == 0)
return 0;
*val = i * sign;
return 1;
}
2023d70: 81 c7 e0 08 ret
2023d74: 81 e8 00 00 restore
02023e68 <scangr>:
FILE *fp,
struct group *grp,
char *buffer,
size_t bufsize
)
{
2023e68: 9d e3 bf 98 save %sp, -104, %sp
int grgid;
char *grmem, *cp;
int memcount;
if (!scanString(fp, &grp->gr_name, &buffer, &bufsize, 0)
2023e6c: 98 10 20 00 clr %o4
FILE *fp,
struct group *grp,
char *buffer,
size_t bufsize
)
{
2023e70: f4 27 a0 4c st %i2, [ %fp + 0x4c ]
2023e74: f6 27 a0 50 st %i3, [ %fp + 0x50 ]
int grgid;
char *grmem, *cp;
int memcount;
if (!scanString(fp, &grp->gr_name, &buffer, &bufsize, 0)
2023e78: 90 10 00 18 mov %i0, %o0
2023e7c: 92 10 00 19 mov %i1, %o1
2023e80: 94 07 a0 4c add %fp, 0x4c, %o2
2023e84: 7f ff ff bd call 2023d78 <scanString>
2023e88: 96 07 a0 50 add %fp, 0x50, %o3
2023e8c: 80 a2 20 00 cmp %o0, 0
2023e90: 12 80 00 04 bne 2023ea0 <scangr+0x38>
2023e94: 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;
2023e98: 81 c7 e0 08 ret
2023e9c: 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)
2023ea0: 92 06 60 04 add %i1, 4, %o1
2023ea4: 94 07 a0 4c add %fp, 0x4c, %o2
2023ea8: 96 07 a0 50 add %fp, 0x50, %o3
2023eac: 7f ff ff b3 call 2023d78 <scanString>
2023eb0: 98 10 20 00 clr %o4
2023eb4: 80 a2 20 00 cmp %o0, 0
2023eb8: 02 bf ff f8 be 2023e98 <scangr+0x30> <== NEVER TAKEN
2023ebc: 90 10 00 18 mov %i0, %o0
|| !scanInt(fp, &grgid)
2023ec0: 7f ff ff 6b call 2023c6c <scanInt>
2023ec4: 92 07 bf f8 add %fp, -8, %o1
2023ec8: 80 a2 20 00 cmp %o0, 0
2023ecc: 02 bf ff f3 be 2023e98 <scangr+0x30> <== NEVER TAKEN
2023ed0: 90 10 00 18 mov %i0, %o0
|| !scanString(fp, &grmem, &buffer, &bufsize, 1))
2023ed4: 92 07 bf fc add %fp, -4, %o1
2023ed8: 94 07 a0 4c add %fp, 0x4c, %o2
2023edc: 96 07 a0 50 add %fp, 0x50, %o3
2023ee0: 7f ff ff a6 call 2023d78 <scanString>
2023ee4: 98 10 20 01 mov 1, %o4
2023ee8: 80 a2 20 00 cmp %o0, 0
2023eec: 02 bf ff eb be 2023e98 <scangr+0x30> <== NEVER TAKEN
2023ef0: c2 07 bf f8 ld [ %fp + -8 ], %g1
grp->gr_gid = grgid;
/*
* Determine number of members
*/
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
2023ef4: 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;
2023ef8: c2 36 60 08 sth %g1, [ %i1 + 8 ]
/*
* Determine number of members
*/
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
2023efc: 84 10 00 03 mov %g3, %g2
2023f00: 10 80 00 05 b 2023f14 <scangr+0xac>
2023f04: 82 10 20 01 mov 1, %g1
2023f08: 84 00 a0 01 inc %g2
if(*cp == ',')
memcount++;
2023f0c: 80 a0 00 04 cmp %g0, %g4
2023f10: 82 60 7f ff subx %g1, -1, %g1
grp->gr_gid = grgid;
/*
* Determine number of members
*/
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
2023f14: c8 48 80 00 ldsb [ %g2 ], %g4
2023f18: 80 a1 20 00 cmp %g4, 0
2023f1c: 32 bf ff fb bne,a 2023f08 <scangr+0xa0>
2023f20: 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))
2023f24: c4 07 a0 50 ld [ %fp + 0x50 ], %g2
2023f28: 83 28 60 02 sll %g1, 2, %g1
2023f2c: 82 00 60 13 add %g1, 0x13, %g1
2023f30: 80 a0 80 01 cmp %g2, %g1
2023f34: 0a bf ff d9 bcs 2023e98 <scangr+0x30> <== NEVER TAKEN
2023f38: 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++) {
2023f3c: 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);
2023f40: 82 00 60 0f add %g1, 0xf, %g1
2023f44: 82 08 7f f0 and %g1, -16, %g1
2023f48: c2 26 60 0c st %g1, [ %i1 + 0xc ]
/*
* Fill in pointer array
*/
grp->gr_mem[0] = grmem;
2023f4c: c6 20 40 00 st %g3, [ %g1 ]
}
/*
* Extract a single group record from the database
*/
static int scangr(
2023f50: 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++) {
2023f54: 10 80 00 0a b 2023f7c <scangr+0x114>
2023f58: 82 00 60 01 inc %g1
if(*cp == ',') {
2023f5c: 32 80 00 08 bne,a 2023f7c <scangr+0x114>
2023f60: 82 00 60 01 inc %g1
*cp = '\0';
2023f64: c0 28 7f ff clrb [ %g1 + -1 ]
grp->gr_mem[memcount++] = cp + 1;
2023f68: c8 06 60 0c ld [ %i1 + 0xc ], %g4
2023f6c: 87 28 a0 02 sll %g2, 2, %g3
2023f70: 84 00 a0 01 inc %g2
2023f74: c2 21 00 03 st %g1, [ %g4 + %g3 ]
2023f78: 82 00 60 01 inc %g1
/*
* Fill in pointer array
*/
grp->gr_mem[0] = grmem;
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
2023f7c: c6 48 7f ff ldsb [ %g1 + -1 ], %g3
2023f80: 80 a0 e0 00 cmp %g3, 0
2023f84: 32 bf ff f6 bne,a 2023f5c <scangr+0xf4>
2023f88: 80 a0 e0 2c cmp %g3, 0x2c
if(*cp == ',') {
*cp = '\0';
grp->gr_mem[memcount++] = cp + 1;
}
}
grp->gr_mem[memcount] = NULL;
2023f8c: c2 06 60 0c ld [ %i1 + 0xc ], %g1
2023f90: 85 28 a0 02 sll %g2, 2, %g2
2023f94: c0 20 40 02 clr [ %g1 + %g2 ]
return 1;
}
2023f98: 81 c7 e0 08 ret
2023f9c: 91 e8 20 01 restore %g0, 1, %o0
02023fa0 <scanpw>:
FILE *fp,
struct passwd *pwd,
char *buffer,
size_t bufsize
)
{
2023fa0: 9d e3 bf 98 save %sp, -104, %sp
int pwuid, pwgid;
if (!scanString(fp, &pwd->pw_name, &buffer, &bufsize, 0)
2023fa4: 98 10 20 00 clr %o4
FILE *fp,
struct passwd *pwd,
char *buffer,
size_t bufsize
)
{
2023fa8: f4 27 a0 4c st %i2, [ %fp + 0x4c ]
2023fac: f6 27 a0 50 st %i3, [ %fp + 0x50 ]
int pwuid, pwgid;
if (!scanString(fp, &pwd->pw_name, &buffer, &bufsize, 0)
2023fb0: 90 10 00 18 mov %i0, %o0
2023fb4: 92 10 00 19 mov %i1, %o1
2023fb8: 94 07 a0 4c add %fp, 0x4c, %o2
2023fbc: 7f ff ff 6f call 2023d78 <scanString>
2023fc0: 96 07 a0 50 add %fp, 0x50, %o3
2023fc4: 80 a2 20 00 cmp %o0, 0
2023fc8: 12 80 00 04 bne 2023fd8 <scanpw+0x38>
2023fcc: 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;
2023fd0: 81 c7 e0 08 ret
2023fd4: 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)
2023fd8: 92 06 60 04 add %i1, 4, %o1
2023fdc: 94 07 a0 4c add %fp, 0x4c, %o2
2023fe0: 96 07 a0 50 add %fp, 0x50, %o3
2023fe4: 7f ff ff 65 call 2023d78 <scanString>
2023fe8: 98 10 20 00 clr %o4
2023fec: 80 a2 20 00 cmp %o0, 0
2023ff0: 02 bf ff f8 be 2023fd0 <scanpw+0x30> <== NEVER TAKEN
2023ff4: 90 10 00 18 mov %i0, %o0
|| !scanInt(fp, &pwuid)
2023ff8: 7f ff ff 1d call 2023c6c <scanInt>
2023ffc: 92 07 bf f8 add %fp, -8, %o1
2024000: 80 a2 20 00 cmp %o0, 0
2024004: 02 bf ff f3 be 2023fd0 <scanpw+0x30>
2024008: 90 10 00 18 mov %i0, %o0
|| !scanInt(fp, &pwgid)
202400c: 7f ff ff 18 call 2023c6c <scanInt>
2024010: 92 07 bf fc add %fp, -4, %o1
2024014: 80 a2 20 00 cmp %o0, 0
2024018: 02 bf ff ee be 2023fd0 <scanpw+0x30>
202401c: 90 10 00 18 mov %i0, %o0
|| !scanString(fp, &pwd->pw_comment, &buffer, &bufsize, 0)
2024020: 92 06 60 0c add %i1, 0xc, %o1
2024024: 94 07 a0 4c add %fp, 0x4c, %o2
2024028: 96 07 a0 50 add %fp, 0x50, %o3
202402c: 7f ff ff 53 call 2023d78 <scanString>
2024030: 98 10 20 00 clr %o4
2024034: 80 a2 20 00 cmp %o0, 0
2024038: 02 bf ff e6 be 2023fd0 <scanpw+0x30> <== NEVER TAKEN
202403c: 90 10 00 18 mov %i0, %o0
|| !scanString(fp, &pwd->pw_gecos, &buffer, &bufsize, 0)
2024040: 92 06 60 10 add %i1, 0x10, %o1
2024044: 94 07 a0 4c add %fp, 0x4c, %o2
2024048: 96 07 a0 50 add %fp, 0x50, %o3
202404c: 7f ff ff 4b call 2023d78 <scanString>
2024050: 98 10 20 00 clr %o4
2024054: 80 a2 20 00 cmp %o0, 0
2024058: 02 bf ff de be 2023fd0 <scanpw+0x30> <== NEVER TAKEN
202405c: 90 10 00 18 mov %i0, %o0
|| !scanString(fp, &pwd->pw_dir, &buffer, &bufsize, 0)
2024060: 92 06 60 14 add %i1, 0x14, %o1
2024064: 94 07 a0 4c add %fp, 0x4c, %o2
2024068: 96 07 a0 50 add %fp, 0x50, %o3
202406c: 7f ff ff 43 call 2023d78 <scanString>
2024070: 98 10 20 00 clr %o4
2024074: 80 a2 20 00 cmp %o0, 0
2024078: 02 bf ff d6 be 2023fd0 <scanpw+0x30> <== NEVER TAKEN
202407c: 90 10 00 18 mov %i0, %o0
|| !scanString(fp, &pwd->pw_shell, &buffer, &bufsize, 1))
2024080: 92 06 60 18 add %i1, 0x18, %o1
2024084: 94 07 a0 4c add %fp, 0x4c, %o2
2024088: 96 07 a0 50 add %fp, 0x50, %o3
202408c: 7f ff ff 3b call 2023d78 <scanString>
2024090: 98 10 20 01 mov 1, %o4
2024094: 80 a2 20 00 cmp %o0, 0
2024098: 02 bf ff ce be 2023fd0 <scanpw+0x30>
202409c: c2 07 bf f8 ld [ %fp + -8 ], %g1
return 0;
pwd->pw_uid = pwuid;
20240a0: c2 36 60 08 sth %g1, [ %i1 + 8 ]
pwd->pw_gid = pwgid;
20240a4: c2 07 bf fc ld [ %fp + -4 ], %g1
20240a8: c2 36 60 0a sth %g1, [ %i1 + 0xa ]
return 1;
}
20240ac: 81 c7 e0 08 ret
20240b0: 91 e8 20 01 restore %g0, 1, %o0
02007f44 <sched_get_priority_max>:
#include <rtems/posix/priority.h>
int sched_get_priority_max(
int policy
)
{
2007f44: 9d e3 bf a0 save %sp, -96, %sp
switch ( policy ) {
2007f48: 80 a6 20 04 cmp %i0, 4
2007f4c: 18 80 00 06 bgu 2007f64 <sched_get_priority_max+0x20>
2007f50: 82 10 20 01 mov 1, %g1
2007f54: b1 28 40 18 sll %g1, %i0, %i0
2007f58: 80 8e 20 17 btst 0x17, %i0
2007f5c: 12 80 00 08 bne 2007f7c <sched_get_priority_max+0x38> <== ALWAYS TAKEN
2007f60: 03 00 80 86 sethi %hi(0x2021800), %g1
case SCHED_RR:
case SCHED_SPORADIC:
break;
default:
rtems_set_errno_and_return_minus_one( EINVAL );
2007f64: 40 00 21 7f call 2010560 <__errno>
2007f68: b0 10 3f ff mov -1, %i0
2007f6c: 82 10 20 16 mov 0x16, %g1
2007f70: c2 22 00 00 st %g1, [ %o0 ]
2007f74: 81 c7 e0 08 ret
2007f78: 81 e8 00 00 restore
}
return POSIX_SCHEDULER_MAXIMUM_PRIORITY;
2007f7c: f0 08 62 58 ldub [ %g1 + 0x258 ], %i0
}
2007f80: 81 c7 e0 08 ret
2007f84: 91 ee 3f ff restore %i0, -1, %o0
02007f88 <sched_get_priority_min>:
#include <rtems/posix/priority.h>
int sched_get_priority_min(
int policy
)
{
2007f88: 9d e3 bf a0 save %sp, -96, %sp
switch ( policy ) {
2007f8c: 80 a6 20 04 cmp %i0, 4
2007f90: 18 80 00 06 bgu 2007fa8 <sched_get_priority_min+0x20>
2007f94: 82 10 20 01 mov 1, %g1
2007f98: 83 28 40 18 sll %g1, %i0, %g1
2007f9c: 80 88 60 17 btst 0x17, %g1
2007fa0: 12 80 00 06 bne 2007fb8 <sched_get_priority_min+0x30> <== ALWAYS TAKEN
2007fa4: b0 10 20 01 mov 1, %i0
case SCHED_RR:
case SCHED_SPORADIC:
break;
default:
rtems_set_errno_and_return_minus_one( EINVAL );
2007fa8: 40 00 21 6e call 2010560 <__errno>
2007fac: b0 10 3f ff mov -1, %i0
2007fb0: 82 10 20 16 mov 0x16, %g1
2007fb4: c2 22 00 00 st %g1, [ %o0 ]
}
return POSIX_SCHEDULER_MINIMUM_PRIORITY;
}
2007fb8: 81 c7 e0 08 ret
2007fbc: 81 e8 00 00 restore
02007fc0 <sched_rr_get_interval>:
int sched_rr_get_interval(
pid_t pid,
struct timespec *interval
)
{
2007fc0: 9d e3 bf a0 save %sp, -96, %sp
/*
* Only supported for the "calling process" (i.e. this node).
*/
if ( pid && pid != getpid() )
2007fc4: 80 a6 20 00 cmp %i0, 0
2007fc8: 02 80 00 0b be 2007ff4 <sched_rr_get_interval+0x34> <== NEVER TAKEN
2007fcc: 80 a6 60 00 cmp %i1, 0
2007fd0: 7f ff ef 8a call 2003df8 <getpid>
2007fd4: 01 00 00 00 nop
2007fd8: 80 a6 00 08 cmp %i0, %o0
2007fdc: 02 80 00 06 be 2007ff4 <sched_rr_get_interval+0x34>
2007fe0: 80 a6 60 00 cmp %i1, 0
rtems_set_errno_and_return_minus_one( ESRCH );
2007fe4: 40 00 21 5f call 2010560 <__errno>
2007fe8: 01 00 00 00 nop
2007fec: 10 80 00 07 b 2008008 <sched_rr_get_interval+0x48>
2007ff0: 82 10 20 03 mov 3, %g1 ! 3 <PROM_START+0x3>
if ( !interval )
2007ff4: 12 80 00 08 bne 2008014 <sched_rr_get_interval+0x54>
2007ff8: 03 00 80 89 sethi %hi(0x2022400), %g1
rtems_set_errno_and_return_minus_one( EINVAL );
2007ffc: 40 00 21 59 call 2010560 <__errno>
2008000: 01 00 00 00 nop
2008004: 82 10 20 16 mov 0x16, %g1 ! 16 <PROM_START+0x16>
2008008: c2 22 00 00 st %g1, [ %o0 ]
200800c: 81 c7 e0 08 ret
2008010: 91 e8 3f ff restore %g0, -1, %o0
_Timespec_From_ticks( _Thread_Ticks_per_timeslice, interval );
2008014: d0 00 63 50 ld [ %g1 + 0x350 ], %o0
2008018: 92 10 00 19 mov %i1, %o1
200801c: 40 00 0e 99 call 200ba80 <_Timespec_From_ticks>
2008020: b0 10 20 00 clr %i0
return 0;
}
2008024: 81 c7 e0 08 ret
2008028: 81 e8 00 00 restore
020086f0 <sem_open>:
int oflag,
...
/* mode_t mode, */
/* unsigned int value */
)
{
20086f0: 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++;
20086f4: 03 00 80 89 sethi %hi(0x2022400), %g1
20086f8: 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);
20086fc: f4 27 a0 4c st %i2, [ %fp + 0x4c ]
2008700: 84 00 a0 01 inc %g2
2008704: c4 20 61 f0 st %g2, [ %g1 + 0x1f0 ]
return _Thread_Dispatch_disable_level;
2008708: c2 00 61 f0 ld [ %g1 + 0x1f0 ], %g1
200870c: f6 27 a0 50 st %i3, [ %fp + 0x50 ]
2008710: f8 27 a0 54 st %i4, [ %fp + 0x54 ]
2008714: fa 27 a0 58 st %i5, [ %fp + 0x58 ]
Objects_Locations location;
size_t name_len;
_Thread_Disable_dispatch();
if ( oflag & O_CREAT ) {
2008718: b4 8e 62 00 andcc %i1, 0x200, %i2
200871c: 02 80 00 05 be 2008730 <sem_open+0x40>
2008720: b8 10 20 00 clr %i4
va_start(arg, oflag);
mode = va_arg( arg, mode_t );
value = va_arg( arg, unsigned int );
2008724: f8 07 a0 50 ld [ %fp + 0x50 ], %i4
size_t name_len;
_Thread_Disable_dispatch();
if ( oflag & O_CREAT ) {
va_start(arg, oflag);
2008728: 82 07 a0 4c add %fp, 0x4c, %g1
200872c: 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 );
2008730: 37 00 80 8a sethi %hi(0x2022800), %i3
2008734: 92 10 00 18 mov %i0, %o1
2008738: 90 16 e0 e0 or %i3, 0xe0, %o0
200873c: 94 07 bf f0 add %fp, -16, %o2
2008740: 7f ff fe 7d call 2008134 <_POSIX_Name_to_id>
2008744: 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 ) {
2008748: ba 92 20 00 orcc %o0, 0, %i5
200874c: 22 80 00 0e be,a 2008784 <sem_open+0x94>
2008750: 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) ) ) {
2008754: 80 a7 60 02 cmp %i5, 2
2008758: 12 80 00 04 bne 2008768 <sem_open+0x78>
200875c: 80 a6 a0 00 cmp %i2, 0
2008760: 12 80 00 20 bne 20087e0 <sem_open+0xf0>
2008764: d2 07 bf fc ld [ %fp + -4 ], %o1
_Thread_Enable_dispatch();
2008768: 40 00 0d cc call 200be98 <_Thread_Enable_dispatch>
200876c: b0 10 3f ff mov -1, %i0
rtems_set_errno_and_return_minus_one_cast( status, sem_t * );
2008770: 40 00 24 82 call 2011978 <__errno>
2008774: 01 00 00 00 nop
2008778: fa 22 00 00 st %i5, [ %o0 ]
200877c: 81 c7 e0 08 ret
2008780: 81 e8 00 00 restore
/*
* Check for existence with creation.
*/
if ( (oflag & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL) ) {
2008784: 80 a6 6a 00 cmp %i1, 0xa00
2008788: 12 80 00 0a bne 20087b0 <sem_open+0xc0>
200878c: d2 07 bf f0 ld [ %fp + -16 ], %o1
_Thread_Enable_dispatch();
2008790: 40 00 0d c2 call 200be98 <_Thread_Enable_dispatch>
2008794: b0 10 3f ff mov -1, %i0
rtems_set_errno_and_return_minus_one_cast( EEXIST, sem_t * );
2008798: 40 00 24 78 call 2011978 <__errno>
200879c: 01 00 00 00 nop
20087a0: 82 10 20 11 mov 0x11, %g1 ! 11 <PROM_START+0x11>
20087a4: c2 22 00 00 st %g1, [ %o0 ]
20087a8: 81 c7 e0 08 ret
20087ac: 81 e8 00 00 restore
RTEMS_INLINE_ROUTINE POSIX_Semaphore_Control *_POSIX_Semaphore_Get (
sem_t *id,
Objects_Locations *location
)
{
return (POSIX_Semaphore_Control *)
20087b0: 94 07 bf f8 add %fp, -8, %o2
20087b4: 40 00 09 d4 call 200af04 <_Objects_Get>
20087b8: 90 16 e0 e0 or %i3, 0xe0, %o0
}
the_semaphore = _POSIX_Semaphore_Get( (sem_t *) &the_semaphore_id, &location );
the_semaphore->open_count += 1;
20087bc: 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 );
20087c0: d0 27 bf f4 st %o0, [ %fp + -12 ]
the_semaphore->open_count += 1;
20087c4: 82 00 60 01 inc %g1
_Thread_Enable_dispatch();
20087c8: 40 00 0d b4 call 200be98 <_Thread_Enable_dispatch>
20087cc: c2 22 20 18 st %g1, [ %o0 + 0x18 ]
_Thread_Enable_dispatch();
20087d0: 40 00 0d b2 call 200be98 <_Thread_Enable_dispatch>
20087d4: 01 00 00 00 nop
goto return_id;
20087d8: 10 80 00 0d b 200880c <sem_open+0x11c>
20087dc: 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(
20087e0: 94 10 20 00 clr %o2
20087e4: 96 10 00 1c mov %i4, %o3
20087e8: 98 07 bf f4 add %fp, -12, %o4
20087ec: 40 00 19 8d call 200ee20 <_POSIX_Semaphore_Create_support>
20087f0: 90 10 00 18 mov %i0, %o0
/*
* errno was set by Create_support, so don't set it again.
*/
_Thread_Enable_dispatch();
20087f4: 40 00 0d a9 call 200be98 <_Thread_Enable_dispatch>
20087f8: ba 10 00 08 mov %o0, %i5
if ( status == -1 )
20087fc: 80 a7 7f ff cmp %i5, -1
2008800: 22 80 00 04 be,a 2008810 <sem_open+0x120> <== NEVER TAKEN
2008804: 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;
2008808: f0 07 bf f4 ld [ %fp + -12 ], %i0
200880c: b0 06 20 08 add %i0, 8, %i0
#endif
}
2008810: 81 c7 e0 08 ret
2008814: 81 e8 00 00 restore
02007f24 <sigaction>:
int sigaction(
int sig,
const struct sigaction *act,
struct sigaction *oact
)
{
2007f24: 9d e3 bf a0 save %sp, -96, %sp
ISR_Level level;
if ( oact )
2007f28: 80 a6 a0 00 cmp %i2, 0
2007f2c: 02 80 00 0a be 2007f54 <sigaction+0x30>
2007f30: 83 2e 20 02 sll %i0, 2, %g1
*oact = _POSIX_signals_Vectors[ sig ];
2007f34: 85 2e 20 04 sll %i0, 4, %g2
2007f38: 82 20 80 01 sub %g2, %g1, %g1
2007f3c: 13 00 80 85 sethi %hi(0x2021400), %o1
2007f40: 90 10 00 1a mov %i2, %o0
2007f44: 92 12 62 a0 or %o1, 0x2a0, %o1
2007f48: 94 10 20 0c mov 0xc, %o2
2007f4c: 40 00 25 35 call 2011420 <memcpy>
2007f50: 92 02 40 01 add %o1, %g1, %o1
if ( !sig )
2007f54: 80 a6 20 00 cmp %i0, 0
2007f58: 32 80 00 03 bne,a 2007f64 <sigaction+0x40>
2007f5c: 82 06 3f ff add %i0, -1, %g1
2007f60: 30 80 00 06 b,a 2007f78 <sigaction+0x54>
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !is_valid_signo(sig) )
2007f64: 80 a0 60 1f cmp %g1, 0x1f
2007f68: 18 80 00 04 bgu 2007f78 <sigaction+0x54>
2007f6c: 80 a6 20 09 cmp %i0, 9
*
* NOTE: Solaris documentation claims to "silently enforce" this which
* contradicts the POSIX specification.
*/
if ( sig == SIGKILL )
2007f70: 12 80 00 08 bne 2007f90 <sigaction+0x6c>
2007f74: 80 a6 60 00 cmp %i1, 0
rtems_set_errno_and_return_minus_one( EINVAL );
2007f78: 40 00 22 df call 2010af4 <__errno>
2007f7c: 01 00 00 00 nop
2007f80: 82 10 20 16 mov 0x16, %g1 ! 16 <PROM_START+0x16>
2007f84: c2 22 00 00 st %g1, [ %o0 ]
2007f88: 10 80 00 20 b 2008008 <sigaction+0xe4>
2007f8c: 82 10 3f ff mov -1, %g1
/*
* Evaluate the new action structure and set the global signal vector
* appropriately.
*/
if ( act ) {
2007f90: 02 80 00 1e be 2008008 <sigaction+0xe4> <== NEVER TAKEN
2007f94: 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 );
2007f98: 7f ff ea af call 2002a54 <sparc_disable_interrupts>
2007f9c: 01 00 00 00 nop
2007fa0: b8 10 00 08 mov %o0, %i4
if ( act->sa_handler == SIG_DFL ) {
2007fa4: c2 06 60 08 ld [ %i1 + 8 ], %g1
2007fa8: 3b 00 80 85 sethi %hi(0x2021400), %i5
2007fac: 80 a0 60 00 cmp %g1, 0
2007fb0: 12 80 00 0a bne 2007fd8 <sigaction+0xb4>
2007fb4: ba 17 62 a0 or %i5, 0x2a0, %i5
_POSIX_signals_Vectors[ sig ] = _POSIX_signals_Default_vectors[ sig ];
2007fb8: 83 2e 20 02 sll %i0, 2, %g1
2007fbc: 13 00 80 7c sethi %hi(0x201f000), %o1
2007fc0: b1 2e 20 04 sll %i0, 4, %i0
2007fc4: 92 12 60 d4 or %o1, 0xd4, %o1
2007fc8: b0 26 00 01 sub %i0, %g1, %i0
2007fcc: 90 07 40 18 add %i5, %i0, %o0
2007fd0: 10 80 00 09 b 2007ff4 <sigaction+0xd0>
2007fd4: 92 02 40 18 add %o1, %i0, %o1
} else {
_POSIX_signals_Clear_process_signals( sig );
2007fd8: 40 00 16 da call 200db40 <_POSIX_signals_Clear_process_signals>
2007fdc: 90 10 00 18 mov %i0, %o0
_POSIX_signals_Vectors[ sig ] = *act;
2007fe0: 83 2e 20 02 sll %i0, 2, %g1
2007fe4: 92 10 00 19 mov %i1, %o1
2007fe8: b1 2e 20 04 sll %i0, 4, %i0
2007fec: 90 26 00 01 sub %i0, %g1, %o0
2007ff0: 90 07 40 08 add %i5, %o0, %o0
2007ff4: 40 00 25 0b call 2011420 <memcpy>
2007ff8: 94 10 20 0c mov 0xc, %o2
}
_ISR_Enable( level );
2007ffc: 7f ff ea 9a call 2002a64 <sparc_enable_interrupts>
2008000: 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;
2008004: 82 10 20 00 clr %g1
}
2008008: 81 c7 e0 08 ret
200800c: 91 e8 00 01 restore %g0, %g1, %o0
0200846c <sigtimedwait>:
int sigtimedwait(
const sigset_t *set,
siginfo_t *info,
const struct timespec *timeout
)
{
200846c: 9d e3 bf 90 save %sp, -112, %sp
ISR_Level level;
/*
* Error check parameters before disabling interrupts.
*/
if ( !set )
2008470: 80 a6 20 00 cmp %i0, 0
2008474: 02 80 00 0e be 20084ac <sigtimedwait+0x40>
2008478: 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 ) {
200847c: 02 80 00 10 be 20084bc <sigtimedwait+0x50>
2008480: b6 10 20 00 clr %i3
if ( !_Timespec_Is_valid( timeout ) )
2008484: 40 00 0e e1 call 200c008 <_Timespec_Is_valid>
2008488: 90 10 00 1a mov %i2, %o0
200848c: 80 8a 20 ff btst 0xff, %o0
2008490: 02 80 00 07 be 20084ac <sigtimedwait+0x40>
2008494: 01 00 00 00 nop
rtems_set_errno_and_return_minus_one( EINVAL );
interval = _Timespec_To_ticks( timeout );
2008498: 40 00 0e ee call 200c050 <_Timespec_To_ticks>
200849c: 90 10 00 1a mov %i2, %o0
if ( !interval )
20084a0: b6 92 20 00 orcc %o0, 0, %i3
20084a4: 12 80 00 07 bne 20084c0 <sigtimedwait+0x54> <== ALWAYS TAKEN
20084a8: 80 a6 60 00 cmp %i1, 0
rtems_set_errno_and_return_minus_one( EINVAL );
20084ac: 40 00 23 5c call 201121c <__errno>
20084b0: 01 00 00 00 nop
20084b4: 10 80 00 64 b 2008644 <sigtimedwait+0x1d8>
20084b8: 82 10 20 16 mov 0x16, %g1 ! 16 <PROM_START+0x16>
/*
* Initialize local variables.
*/
the_info = ( info ) ? info : &signal_information;
20084bc: 80 a6 60 00 cmp %i1, 0
20084c0: 22 80 00 02 be,a 20084c8 <sigtimedwait+0x5c>
20084c4: b2 07 bf f4 add %fp, -12, %i1
the_thread = _Thread_Executing;
20084c8: 21 00 80 86 sethi %hi(0x2021800), %l0
20084cc: a0 14 23 20 or %l0, 0x320, %l0 ! 2021b20 <_Per_CPU_Information>
20084d0: fa 04 20 0c ld [ %l0 + 0xc ], %i5
* What if they are already pending?
*/
/* API signals pending? */
_ISR_Disable( level );
20084d4: 7f ff ea 3d call 2002dc8 <sparc_disable_interrupts>
20084d8: f8 07 61 5c ld [ %i5 + 0x15c ], %i4
20084dc: b4 10 00 08 mov %o0, %i2
if ( *set & api->signals_pending ) {
20084e0: c4 06 00 00 ld [ %i0 ], %g2
20084e4: c2 07 20 d4 ld [ %i4 + 0xd4 ], %g1
20084e8: 80 88 80 01 btst %g2, %g1
20084ec: 22 80 00 12 be,a 2008534 <sigtimedwait+0xc8>
20084f0: 03 00 80 87 sethi %hi(0x2021c00), %g1
/* XXX real info later */
the_info->si_signo = _POSIX_signals_Get_lowest( api->signals_pending );
20084f4: 7f ff ff c6 call 200840c <_POSIX_signals_Get_lowest>
20084f8: 90 10 00 01 mov %g1, %o0
_POSIX_signals_Clear_signals(
20084fc: 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 );
2008500: 92 10 00 08 mov %o0, %o1
2008504: d0 26 40 00 st %o0, [ %i1 ]
_POSIX_signals_Clear_signals(
2008508: 96 10 20 00 clr %o3
200850c: 90 10 00 1c mov %i4, %o0
2008510: 40 00 17 a7 call 200e3ac <_POSIX_signals_Clear_signals>
2008514: 98 10 20 00 clr %o4
the_info->si_signo,
the_info,
false,
false
);
_ISR_Enable( level );
2008518: 7f ff ea 30 call 2002dd8 <sparc_enable_interrupts>
200851c: 90 10 00 1a mov %i2, %o0
the_info->si_code = SI_USER;
2008520: 82 10 20 01 mov 1, %g1
the_info->si_value.sival_int = 0;
2008524: c0 26 60 08 clr [ %i1 + 8 ]
false,
false
);
_ISR_Enable( level );
the_info->si_code = SI_USER;
2008528: c2 26 60 04 st %g1, [ %i1 + 4 ]
the_info->si_value.sival_int = 0;
return the_info->si_signo;
200852c: 10 80 00 48 b 200864c <sigtimedwait+0x1e0>
2008530: fa 06 40 00 ld [ %i1 ], %i5
}
/* Process pending signals? */
if ( *set & _POSIX_signals_Pending ) {
2008534: c2 00 61 74 ld [ %g1 + 0x174 ], %g1
2008538: 80 88 80 01 btst %g2, %g1
200853c: 22 80 00 12 be,a 2008584 <sigtimedwait+0x118>
2008540: 82 10 3f ff mov -1, %g1
signo = _POSIX_signals_Get_lowest( _POSIX_signals_Pending );
2008544: 7f ff ff b2 call 200840c <_POSIX_signals_Get_lowest>
2008548: 90 10 00 01 mov %g1, %o0
_POSIX_signals_Clear_signals( api, signo, the_info, true, false );
200854c: 94 10 00 19 mov %i1, %o2
}
/* Process pending signals? */
if ( *set & _POSIX_signals_Pending ) {
signo = _POSIX_signals_Get_lowest( _POSIX_signals_Pending );
2008550: ba 10 00 08 mov %o0, %i5
_POSIX_signals_Clear_signals( api, signo, the_info, true, false );
2008554: 96 10 20 01 mov 1, %o3
2008558: 90 10 00 1c mov %i4, %o0
200855c: 92 10 00 1d mov %i5, %o1
2008560: 40 00 17 93 call 200e3ac <_POSIX_signals_Clear_signals>
2008564: 98 10 20 00 clr %o4
_ISR_Enable( level );
2008568: 7f ff ea 1c call 2002dd8 <sparc_enable_interrupts>
200856c: 90 10 00 1a mov %i2, %o0
the_info->si_signo = signo;
the_info->si_code = SI_USER;
2008570: 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;
2008574: fa 26 40 00 st %i5, [ %i1 ]
the_info->si_code = SI_USER;
2008578: c2 26 60 04 st %g1, [ %i1 + 4 ]
the_info->si_value.sival_int = 0;
200857c: 10 80 00 34 b 200864c <sigtimedwait+0x1e0>
2008580: c0 26 60 08 clr [ %i1 + 8 ]
return signo;
}
the_info->si_signo = -1;
2008584: 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++;
2008588: 03 00 80 85 sethi %hi(0x2021400), %g1
200858c: c4 00 61 f0 ld [ %g1 + 0x1f0 ], %g2 ! 20215f0 <_Thread_Dispatch_disable_level>
2008590: 84 00 a0 01 inc %g2
2008594: c4 20 61 f0 st %g2, [ %g1 + 0x1f0 ]
return _Thread_Dispatch_disable_level;
2008598: c2 00 61 f0 ld [ %g1 + 0x1f0 ], %g1
_Thread_Disable_dispatch();
the_thread->Wait.queue = &_POSIX_signals_Wait_queue;
the_thread->Wait.return_code = EINTR;
200859c: 82 10 20 04 mov 4, %g1
20085a0: c2 27 60 34 st %g1, [ %i5 + 0x34 ]
the_thread->Wait.option = *set;
20085a4: c2 06 00 00 ld [ %i0 ], %g1
the_thread->Wait.return_argument = the_info;
20085a8: 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;
20085ac: 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;
20085b0: a2 10 20 01 mov 1, %l1
}
the_info->si_signo = -1;
_Thread_Disable_dispatch();
the_thread->Wait.queue = &_POSIX_signals_Wait_queue;
20085b4: 35 00 80 87 sethi %hi(0x2021c00), %i2
20085b8: b4 16 a1 0c or %i2, 0x10c, %i2 ! 2021d0c <_POSIX_signals_Wait_queue>
20085bc: f4 27 60 44 st %i2, [ %i5 + 0x44 ]
20085c0: 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 );
20085c4: 7f ff ea 05 call 2002dd8 <sparc_enable_interrupts>
20085c8: 01 00 00 00 nop
_Thread_queue_Enqueue( &_POSIX_signals_Wait_queue, interval );
20085cc: 90 10 00 1a mov %i2, %o0
20085d0: 92 10 00 1b mov %i3, %o1
20085d4: 15 00 80 2f sethi %hi(0x200bc00), %o2
20085d8: 40 00 0d 36 call 200bab0 <_Thread_queue_Enqueue_with_handler>
20085dc: 94 12 a2 1c or %o2, 0x21c, %o2 ! 200be1c <_Thread_queue_Timeout>
_Thread_Enable_dispatch();
20085e0: 40 00 0b f1 call 200b5a4 <_Thread_Enable_dispatch>
20085e4: 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 );
20085e8: d2 06 40 00 ld [ %i1 ], %o1
20085ec: 90 10 00 1c mov %i4, %o0
20085f0: 94 10 00 19 mov %i1, %o2
20085f4: 96 10 20 00 clr %o3
20085f8: 40 00 17 6d call 200e3ac <_POSIX_signals_Clear_signals>
20085fc: 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)
2008600: c2 04 20 0c ld [ %l0 + 0xc ], %g1
2008604: c2 00 60 34 ld [ %g1 + 0x34 ], %g1
2008608: 80 a0 60 04 cmp %g1, 4
200860c: 12 80 00 09 bne 2008630 <sigtimedwait+0x1c4>
2008610: 01 00 00 00 nop
|| !(*set & signo_to_mask( the_info->si_signo )) ) {
2008614: fa 06 40 00 ld [ %i1 ], %i5
2008618: 82 07 7f ff add %i5, -1, %g1
200861c: a3 2c 40 01 sll %l1, %g1, %l1
2008620: c2 06 00 00 ld [ %i0 ], %g1
2008624: 80 8c 40 01 btst %l1, %g1
2008628: 12 80 00 09 bne 200864c <sigtimedwait+0x1e0>
200862c: 01 00 00 00 nop
errno = _Thread_Executing->Wait.return_code;
2008630: 40 00 22 fb call 201121c <__errno>
2008634: 01 00 00 00 nop
2008638: 03 00 80 86 sethi %hi(0x2021800), %g1
200863c: c2 00 63 2c ld [ %g1 + 0x32c ], %g1 ! 2021b2c <_Per_CPU_Information+0xc>
2008640: c2 00 60 34 ld [ %g1 + 0x34 ], %g1
2008644: c2 22 00 00 st %g1, [ %o0 ]
return -1;
2008648: ba 10 3f ff mov -1, %i5
}
return the_info->si_signo;
}
200864c: 81 c7 e0 08 ret
2008650: 91 e8 00 1d restore %g0, %i5, %o0
0200a390 <sigwait>:
int sigwait(
const sigset_t *set,
int *sig
)
{
200a390: 9d e3 bf a0 save %sp, -96, %sp
int status;
status = sigtimedwait( set, NULL, NULL );
200a394: 92 10 20 00 clr %o1
200a398: 90 10 00 18 mov %i0, %o0
200a39c: 7f ff ff 7f call 200a198 <sigtimedwait>
200a3a0: 94 10 20 00 clr %o2
if ( status != -1 ) {
200a3a4: 80 a2 3f ff cmp %o0, -1
200a3a8: 02 80 00 06 be 200a3c0 <sigwait+0x30>
200a3ac: 80 a6 60 00 cmp %i1, 0
if ( sig )
200a3b0: 32 80 00 09 bne,a 200a3d4 <sigwait+0x44> <== ALWAYS TAKEN
200a3b4: d0 26 40 00 st %o0, [ %i1 ]
*sig = status;
return 0;
200a3b8: 81 c7 e0 08 ret <== NOT EXECUTED
200a3bc: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED
}
return errno;
200a3c0: 40 00 22 2d call 2012c74 <__errno>
200a3c4: 01 00 00 00 nop
200a3c8: f0 02 00 00 ld [ %o0 ], %i0
200a3cc: 81 c7 e0 08 ret
200a3d0: 81 e8 00 00 restore
status = sigtimedwait( set, NULL, NULL );
if ( status != -1 ) {
if ( sig )
*sig = status;
return 0;
200a3d4: b0 10 20 00 clr %i0
}
return errno;
}
200a3d8: 81 c7 e0 08 ret
200a3dc: 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 e0 call 2007908 <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 24 call 2007a30 <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 f1 call 2011784 <_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
0200720c <sysconf>:
*/
long sysconf(
int name
)
{
200720c: 9d e3 bf a0 save %sp, -96, %sp
if ( name == _SC_CLK_TCK )
2007210: 80 a6 20 02 cmp %i0, 2
2007214: 12 80 00 09 bne 2007238 <sysconf+0x2c>
2007218: 03 00 80 74 sethi %hi(0x201d000), %g1
return (TOD_MICROSECONDS_PER_SECOND /
200721c: 03 00 80 74 sethi %hi(0x201d000), %g1
2007220: d2 00 60 6c ld [ %g1 + 0x6c ], %o1 ! 201d06c <Configuration+0x10>
2007224: 11 00 03 d0 sethi %hi(0xf4000), %o0
2007228: 40 00 46 61 call 2018bac <.udiv>
200722c: 90 12 22 40 or %o0, 0x240, %o0 ! f4240 <PROM_START+0xf4240>
2007230: 81 c7 e0 08 ret
2007234: 91 e8 00 08 restore %g0, %o0, %o0
rtems_configuration_get_microseconds_per_tick());
if ( name == _SC_OPEN_MAX )
2007238: 80 a6 20 04 cmp %i0, 4
200723c: 02 80 00 13 be 2007288 <sysconf+0x7c>
2007240: d0 00 61 b4 ld [ %g1 + 0x1b4 ], %o0
return rtems_libio_number_iops;
if ( name == _SC_GETPW_R_SIZE_MAX )
2007244: 80 a6 20 33 cmp %i0, 0x33
2007248: 02 80 00 10 be 2007288 <sysconf+0x7c>
200724c: 90 10 24 00 mov 0x400, %o0
return 1024;
if ( name == _SC_PAGESIZE )
2007250: 80 a6 20 08 cmp %i0, 8
2007254: 02 80 00 0d be 2007288 <sysconf+0x7c>
2007258: 11 00 00 04 sethi %hi(0x1000), %o0
return PAGE_SIZE;
if ( name == _SC_SYMLOOP_MAX )
200725c: 80 a6 20 4f cmp %i0, 0x4f
2007260: 02 80 00 0a be 2007288 <sysconf+0x7c> <== NEVER TAKEN
2007264: 90 10 20 20 mov 0x20, %o0
return RTEMS_FILESYSTEM_SYMLOOP_MAX;
#if defined(__sparc__)
if ( name == 515 ) /* Solaris _SC_STACK_PROT */
2007268: 80 a6 22 03 cmp %i0, 0x203
200726c: 02 80 00 07 be 2007288 <sysconf+0x7c> <== NEVER TAKEN
2007270: 90 10 20 00 clr %o0
return 0;
#endif
rtems_set_errno_and_return_minus_one( EINVAL );
2007274: 40 00 22 ae call 200fd2c <__errno>
2007278: 01 00 00 00 nop
200727c: 82 10 20 16 mov 0x16, %g1 ! 16 <PROM_START+0x16>
2007280: c2 22 00 00 st %g1, [ %o0 ]
2007284: 90 10 3f ff mov -1, %o0
}
2007288: b0 10 00 08 mov %o0, %i0
200728c: 81 c7 e0 08 ret
2007290: 81 e8 00 00 restore
0201308c <tcsetattr>:
int tcsetattr(
int fd,
int opt,
struct termios *tp
)
{
201308c: 9d e3 bf a0 save %sp, -96, %sp
switch (opt) {
2013090: 80 a6 60 00 cmp %i1, 0
2013094: 02 80 00 10 be 20130d4 <tcsetattr+0x48> <== ALWAYS TAKEN
2013098: 80 a6 60 01 cmp %i1, 1
201309c: 02 80 00 08 be 20130bc <tcsetattr+0x30> <== NOT EXECUTED
20130a0: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
default:
rtems_set_errno_and_return_minus_one( ENOTSUP );
20130a4: 40 00 11 1b call 2017510 <__errno> <== NOT EXECUTED
20130a8: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
20130ac: 82 10 20 86 mov 0x86, %g1 <== NOT EXECUTED
20130b0: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
20130b4: 81 c7 e0 08 ret <== NOT EXECUTED
20130b8: 81 e8 00 00 restore <== NOT EXECUTED
case TCSADRAIN:
if (ioctl( fd, RTEMS_IO_TCDRAIN, NULL ) < 0)
20130bc: 92 10 20 03 mov 3, %o1 <== NOT EXECUTED
20130c0: 40 00 0e 18 call 2016920 <ioctl> <== NOT EXECUTED
20130c4: 94 10 20 00 clr %o2 <== NOT EXECUTED
20130c8: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
20130cc: 26 80 00 04 bl,a 20130dc <tcsetattr+0x50> <== NOT EXECUTED
20130d0: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
return -1;
/*
* Fall through to....
*/
case TCSANOW:
return ioctl( fd, RTEMS_IO_SET_ATTRIBUTES, tp );
20130d4: 40 00 0e 13 call 2016920 <ioctl>
20130d8: 93 e8 20 02 restore %g0, 2, %o1
}
}
20130dc: 81 c7 e0 08 ret <== NOT EXECUTED
20130e0: 81 e8 00 00 restore <== NOT EXECUTED
02008818 <timer_create>:
int timer_create(
clockid_t clock_id,
struct sigevent *evp,
timer_t *timerid
)
{
2008818: 9d e3 bf a0 save %sp, -96, %sp
POSIX_Timer_Control *ptimer;
if ( clock_id != CLOCK_REALTIME )
200881c: 80 a6 20 01 cmp %i0, 1
2008820: 12 80 00 13 bne 200886c <timer_create+0x54>
2008824: 80 a6 a0 00 cmp %i2, 0
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !timerid )
2008828: 02 80 00 11 be 200886c <timer_create+0x54>
200882c: 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) {
2008830: 02 80 00 13 be 200887c <timer_create+0x64>
2008834: 03 00 80 89 sethi %hi(0x2022400), %g1
/* The structure has data */
if ( ( evp->sigev_notify != SIGEV_NONE ) &&
2008838: c2 06 40 00 ld [ %i1 ], %g1
200883c: 82 00 7f ff add %g1, -1, %g1
2008840: 80 a0 60 01 cmp %g1, 1
2008844: 28 80 00 03 bleu,a 2008850 <timer_create+0x38> <== ALWAYS TAKEN
2008848: c2 06 60 04 ld [ %i1 + 4 ], %g1
200884c: 30 80 00 08 b,a 200886c <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 )
2008850: 80 a0 60 00 cmp %g1, 0
2008854: 32 80 00 03 bne,a 2008860 <timer_create+0x48> <== ALWAYS TAKEN
2008858: 82 00 7f ff add %g1, -1, %g1
200885c: 30 80 00 04 b,a 200886c <timer_create+0x54> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !is_valid_signo(evp->sigev_signo) )
2008860: 80 a0 60 1f cmp %g1, 0x1f
2008864: 28 80 00 06 bleu,a 200887c <timer_create+0x64> <== ALWAYS TAKEN
2008868: 03 00 80 89 sethi %hi(0x2022400), %g1
rtems_set_errno_and_return_minus_one( EINVAL );
200886c: 40 00 24 43 call 2011978 <__errno>
2008870: 01 00 00 00 nop
2008874: 10 80 00 11 b 20088b8 <timer_create+0xa0>
2008878: 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++;
200887c: c4 00 61 f0 ld [ %g1 + 0x1f0 ], %g2
2008880: 84 00 a0 01 inc %g2
2008884: c4 20 61 f0 st %g2, [ %g1 + 0x1f0 ]
return _Thread_Dispatch_disable_level;
2008888: 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 );
200888c: 11 00 80 8a sethi %hi(0x2022800), %o0
2008890: 40 00 08 5f call 200aa0c <_Objects_Allocate>
2008894: 90 12 21 20 or %o0, 0x120, %o0 ! 2022920 <_POSIX_Timer_Information>
/*
* Allocate a timer
*/
ptimer = _POSIX_Timer_Allocate();
if ( !ptimer ) {
2008898: 80 a2 20 00 cmp %o0, 0
200889c: 12 80 00 0a bne 20088c4 <timer_create+0xac>
20088a0: 82 10 20 02 mov 2, %g1
_Thread_Enable_dispatch();
20088a4: 40 00 0d 7d call 200be98 <_Thread_Enable_dispatch>
20088a8: 01 00 00 00 nop
rtems_set_errno_and_return_minus_one( EAGAIN );
20088ac: 40 00 24 33 call 2011978 <__errno>
20088b0: 01 00 00 00 nop
20088b4: 82 10 20 0b mov 0xb, %g1 ! b <PROM_START+0xb>
20088b8: c2 22 00 00 st %g1, [ %o0 ]
20088bc: 81 c7 e0 08 ret
20088c0: 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;
20088c4: c2 2a 20 3c stb %g1, [ %o0 + 0x3c ]
ptimer->thread_id = _Thread_Executing->Object.id;
20088c8: 03 00 80 8a sethi %hi(0x2022800), %g1
20088cc: c2 00 63 6c ld [ %g1 + 0x36c ], %g1 ! 2022b6c <_Per_CPU_Information+0xc>
if ( evp != NULL ) {
20088d0: 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;
20088d4: c2 00 60 08 ld [ %g1 + 8 ], %g1
if ( evp != NULL ) {
20088d8: 02 80 00 08 be 20088f8 <timer_create+0xe0>
20088dc: c2 22 20 38 st %g1, [ %o0 + 0x38 ]
ptimer->inf.sigev_notify = evp->sigev_notify;
20088e0: c2 06 40 00 ld [ %i1 ], %g1
20088e4: c2 22 20 40 st %g1, [ %o0 + 0x40 ]
ptimer->inf.sigev_signo = evp->sigev_signo;
20088e8: c2 06 60 04 ld [ %i1 + 4 ], %g1
20088ec: c2 22 20 44 st %g1, [ %o0 + 0x44 ]
ptimer->inf.sigev_value = evp->sigev_value;
20088f0: c2 06 60 08 ld [ %i1 + 8 ], %g1
20088f4: c2 22 20 48 st %g1, [ %o0 + 0x48 ]
Objects_Information *information,
Objects_Control *the_object,
uint32_t name
)
{
_Objects_Set_local_object(
20088f8: c4 12 20 0a lduh [ %o0 + 0xa ], %g2
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
20088fc: 07 00 80 8a sethi %hi(0x2022800), %g3
2008900: c6 00 e1 3c ld [ %g3 + 0x13c ], %g3 ! 202293c <_POSIX_Timer_Information+0x1c>
}
ptimer->overrun = 0;
2008904: c0 22 20 68 clr [ %o0 + 0x68 ]
ptimer->timer_data.it_value.tv_sec = 0;
2008908: c0 22 20 5c clr [ %o0 + 0x5c ]
ptimer->timer_data.it_value.tv_nsec = 0;
200890c: c0 22 20 60 clr [ %o0 + 0x60 ]
ptimer->timer_data.it_interval.tv_sec = 0;
2008910: c0 22 20 54 clr [ %o0 + 0x54 ]
ptimer->timer_data.it_interval.tv_nsec = 0;
2008914: c0 22 20 58 clr [ %o0 + 0x58 ]
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
2008918: c0 22 20 18 clr [ %o0 + 0x18 ]
the_watchdog->routine = routine;
200891c: c0 22 20 2c clr [ %o0 + 0x2c ]
the_watchdog->id = id;
2008920: c0 22 20 30 clr [ %o0 + 0x30 ]
the_watchdog->user_data = user_data;
2008924: c0 22 20 34 clr [ %o0 + 0x34 ]
Objects_Information *information,
Objects_Control *the_object,
uint32_t name
)
{
_Objects_Set_local_object(
2008928: c2 02 20 08 ld [ %o0 + 8 ], %g1
#if defined(RTEMS_DEBUG)
if ( index > information->maximum )
return;
#endif
information->local_table[ index ] = the_object;
200892c: 85 28 a0 02 sll %g2, 2, %g2
2008930: 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;
2008934: 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;
2008938: c2 26 80 00 st %g1, [ %i2 ]
_Thread_Enable_dispatch();
200893c: 40 00 0d 57 call 200be98 <_Thread_Enable_dispatch>
2008940: b0 10 20 00 clr %i0
return 0;
}
2008944: 81 c7 e0 08 ret
2008948: 81 e8 00 00 restore
02007404 <timer_settime>:
timer_t timerid,
int flags,
const struct itimerspec *value,
struct itimerspec *ovalue
)
{
2007404: 9d e3 bf 78 save %sp, -136, %sp
Objects_Locations location;
bool activated;
uint32_t initial_period;
struct itimerspec normalize;
if ( !value )
2007408: 80 a6 a0 00 cmp %i2, 0
200740c: 02 80 00 7c be 20075fc <timer_settime+0x1f8> <== NEVER TAKEN
2007410: 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) ) ) {
2007414: 40 00 0f 55 call 200b168 <_Timespec_Is_valid>
2007418: 90 06 a0 08 add %i2, 8, %o0
200741c: 80 8a 20 ff btst 0xff, %o0
2007420: 02 80 00 77 be 20075fc <timer_settime+0x1f8>
2007424: 01 00 00 00 nop
rtems_set_errno_and_return_minus_one( EINVAL );
}
if ( !_Timespec_Is_valid( &(value->it_interval) ) ) {
2007428: 40 00 0f 50 call 200b168 <_Timespec_Is_valid>
200742c: 90 10 00 1a mov %i2, %o0
2007430: 80 8a 20 ff btst 0xff, %o0
2007434: 02 80 00 72 be 20075fc <timer_settime+0x1f8> <== NEVER TAKEN
2007438: 80 8e 7f fb btst -5, %i1
rtems_set_errno_and_return_minus_one( EINVAL );
}
if ( flags != TIMER_ABSTIME && flags != POSIX_TIMER_RELATIVE ) {
200743c: 12 80 00 70 bne 20075fc <timer_settime+0x1f8>
2007440: 90 07 bf f0 add %fp, -16, %o0
rtems_set_errno_and_return_minus_one( EINVAL );
}
normalize = *value;
2007444: 92 10 00 1a mov %i2, %o1
2007448: 40 00 25 e4 call 2010bd8 <memcpy>
200744c: 94 10 20 10 mov 0x10, %o2
/* Convert absolute to relative time */
if (flags == TIMER_ABSTIME) {
2007450: 80 a6 60 04 cmp %i1, 4
2007454: 12 80 00 1d bne 20074c8 <timer_settime+0xc4>
2007458: 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 );
200745c: 40 00 06 5e call 2008dd4 <_TOD_Get_as_timestamp>
2007460: 90 07 bf e0 add %fp, -32, %o0
_Timestamp_To_timespec( &tod_as_timestamp, tod_as_timespec );
2007464: 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);
2007468: 94 10 20 00 clr %o2
200746c: 90 10 00 1c mov %i4, %o0
2007470: 92 10 00 1d mov %i5, %o1
2007474: 17 0e e6 b2 sethi %hi(0x3b9ac800), %o3
2007478: 40 00 49 4d call 20199ac <__divdi3>
200747c: 96 12 e2 00 or %o3, 0x200, %o3 ! 3b9aca00 <RAM_END+0x395aca00>
_timespec->tv_nsec = (long) (*_timestamp % 1000000000L);
2007480: 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);
2007484: d2 27 bf e8 st %o1, [ %fp + -24 ]
_timespec->tv_nsec = (long) (*_timestamp % 1000000000L);
2007488: 90 10 00 1c mov %i4, %o0
200748c: 92 10 00 1d mov %i5, %o1
2007490: 17 0e e6 b2 sethi %hi(0x3b9ac800), %o3
2007494: 40 00 4a 31 call 2019d58 <__moddi3>
2007498: 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 ) )
200749c: 90 07 bf f8 add %fp, -8, %o0
20074a0: d2 27 bf ec st %o1, [ %fp + -20 ]
20074a4: 40 00 0f 43 call 200b1b0 <_Timespec_Less_than>
20074a8: 92 07 bf e8 add %fp, -24, %o1
20074ac: 80 8a 20 ff btst 0xff, %o0
20074b0: 12 80 00 53 bne 20075fc <timer_settime+0x1f8>
20074b4: 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 );
20074b8: 90 07 bf e8 add %fp, -24, %o0
20074bc: 40 00 0f 4d call 200b1f0 <_Timespec_Subtract>
20074c0: 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 *)
20074c4: 11 00 80 7a sethi %hi(0x201e800), %o0
20074c8: 92 10 00 18 mov %i0, %o1
20074cc: 90 12 20 30 or %o0, 0x30, %o0
20074d0: 40 00 08 e1 call 2009854 <_Objects_Get>
20074d4: 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 ) {
20074d8: c2 07 bf dc ld [ %fp + -36 ], %g1
20074dc: 80 a0 60 00 cmp %g1, 0
20074e0: 12 80 00 47 bne 20075fc <timer_settime+0x1f8>
20074e4: 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 ) {
20074e8: c2 07 bf f8 ld [ %fp + -8 ], %g1
20074ec: 80 a0 60 00 cmp %g1, 0
20074f0: 12 80 00 14 bne 2007540 <timer_settime+0x13c>
20074f4: c2 07 bf fc ld [ %fp + -4 ], %g1
20074f8: 80 a0 60 00 cmp %g1, 0
20074fc: 12 80 00 11 bne 2007540 <timer_settime+0x13c>
2007500: 01 00 00 00 nop
/* Stop the timer */
(void) _Watchdog_Remove( &ptimer->Timer );
2007504: 40 00 10 72 call 200b6cc <_Watchdog_Remove>
2007508: 90 02 20 10 add %o0, 0x10, %o0
/* The old data of the timer are returned */
if ( ovalue )
200750c: 80 a6 e0 00 cmp %i3, 0
2007510: 02 80 00 05 be 2007524 <timer_settime+0x120>
2007514: 90 10 00 1b mov %i3, %o0
*ovalue = ptimer->timer_data;
2007518: 92 06 60 54 add %i1, 0x54, %o1
200751c: 40 00 25 af call 2010bd8 <memcpy>
2007520: 94 10 20 10 mov 0x10, %o2
/* The new data are set */
ptimer->timer_data = normalize;
2007524: 90 06 60 54 add %i1, 0x54, %o0
2007528: 92 07 bf f0 add %fp, -16, %o1
200752c: 40 00 25 ab call 2010bd8 <memcpy>
2007530: 94 10 20 10 mov 0x10, %o2
/* Indicates that the timer is created and stopped */
ptimer->state = POSIX_TIMER_STATE_CREATE_STOP;
2007534: 82 10 20 04 mov 4, %g1
2007538: 10 80 00 2d b 20075ec <timer_settime+0x1e8>
200753c: 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 );
2007540: 40 00 0f 3d call 200b234 <_Timespec_To_ticks>
2007544: 90 10 00 1a mov %i2, %o0
2007548: d0 26 60 64 st %o0, [ %i1 + 0x64 ]
initial_period = _Timespec_To_ticks( &normalize.it_value );
200754c: 40 00 0f 3a call 200b234 <_Timespec_To_ticks>
2007550: 90 07 bf f8 add %fp, -8, %o0
activated = _POSIX_Timer_Insert_helper(
2007554: 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 );
2007558: 92 10 00 08 mov %o0, %o1
activated = _POSIX_Timer_Insert_helper(
200755c: 17 00 80 1d sethi %hi(0x2007400), %o3
2007560: 90 06 60 10 add %i1, 0x10, %o0
2007564: 96 12 e2 14 or %o3, 0x214, %o3
2007568: 40 00 18 47 call 200d684 <_POSIX_Timer_Insert_helper>
200756c: 98 10 00 19 mov %i1, %o4
initial_period,
ptimer->Object.id,
_POSIX_Timer_TSR,
ptimer
);
if ( !activated ) {
2007570: 80 8a 20 ff btst 0xff, %o0
2007574: 02 80 00 1e be 20075ec <timer_settime+0x1e8>
2007578: 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 )
200757c: 02 80 00 05 be 2007590 <timer_settime+0x18c>
2007580: 90 10 00 1b mov %i3, %o0
*ovalue = ptimer->timer_data;
2007584: 92 06 60 54 add %i1, 0x54, %o1
2007588: 40 00 25 94 call 2010bd8 <memcpy>
200758c: 94 10 20 10 mov 0x10, %o2
ptimer->timer_data = normalize;
2007590: 92 07 bf f0 add %fp, -16, %o1
2007594: 94 10 20 10 mov 0x10, %o2
2007598: 40 00 25 90 call 2010bd8 <memcpy>
200759c: 90 06 60 54 add %i1, 0x54, %o0
/* Indicate that the time is running */
ptimer->state = POSIX_TIMER_STATE_CREATE_RUN;
20075a0: 82 10 20 03 mov 3, %g1
struct timespec *tod_as_timespec
)
{
Timestamp_Control tod_as_timestamp;
_TOD_Get_as_timestamp( &tod_as_timestamp );
20075a4: 90 07 bf e0 add %fp, -32, %o0
20075a8: 40 00 06 0b call 2008dd4 <_TOD_Get_as_timestamp>
20075ac: c2 2e 60 3c stb %g1, [ %i1 + 0x3c ]
_Timestamp_To_timespec( &tod_as_timestamp, tod_as_timespec );
20075b0: 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);
20075b4: 94 10 20 00 clr %o2
20075b8: 90 10 00 1c mov %i4, %o0
20075bc: 92 10 00 1d mov %i5, %o1
20075c0: 17 0e e6 b2 sethi %hi(0x3b9ac800), %o3
20075c4: 40 00 48 fa call 20199ac <__divdi3>
20075c8: 96 12 e2 00 or %o3, 0x200, %o3 ! 3b9aca00 <RAM_END+0x395aca00>
_timespec->tv_nsec = (long) (*_timestamp % 1000000000L);
20075cc: 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);
20075d0: d2 26 60 6c st %o1, [ %i1 + 0x6c ]
_timespec->tv_nsec = (long) (*_timestamp % 1000000000L);
20075d4: 94 10 20 00 clr %o2
20075d8: 92 10 00 1d mov %i5, %o1
20075dc: 17 0e e6 b2 sethi %hi(0x3b9ac800), %o3
20075e0: 40 00 49 de call 2019d58 <__moddi3>
20075e4: 96 12 e2 00 or %o3, 0x200, %o3 ! 3b9aca00 <RAM_END+0x395aca00>
20075e8: d2 26 60 70 st %o1, [ %i1 + 0x70 ]
_TOD_Get( &ptimer->time );
_Thread_Enable_dispatch();
20075ec: 40 00 0c 46 call 200a704 <_Thread_Enable_dispatch>
20075f0: b0 10 20 00 clr %i0
20075f4: 81 c7 e0 08 ret
20075f8: 81 e8 00 00 restore
#endif
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EINVAL );
20075fc: 40 00 23 30 call 20102bc <__errno>
2007600: b0 10 3f ff mov -1, %i0
2007604: 82 10 20 16 mov 0x16, %g1
2007608: c2 22 00 00 st %g1, [ %o0 ]
}
200760c: 81 c7 e0 08 ret
2007610: 81 e8 00 00 restore
020075d4 <ualarm>:
useconds_t ualarm(
useconds_t useconds,
useconds_t interval
)
{
20075d4: 9d e3 bf 98 save %sp, -104, %sp
/*
* Initialize the timer used to implement alarm().
*/
if ( !the_timer->routine ) {
20075d8: 3b 00 80 7f sethi %hi(0x201fc00), %i5
20075dc: ba 17 63 c8 or %i5, 0x3c8, %i5 ! 201ffc8 <_POSIX_signals_Ualarm_timer>
20075e0: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
20075e4: 80 a0 60 00 cmp %g1, 0
20075e8: 12 80 00 0a bne 2007610 <ualarm+0x3c>
20075ec: b8 10 00 18 mov %i0, %i4
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
the_watchdog->routine = routine;
20075f0: 03 00 80 1d sethi %hi(0x2007400), %g1
Watchdog_Service_routine_entry routine,
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
20075f4: c0 27 60 08 clr [ %i5 + 8 ]
the_watchdog->routine = routine;
20075f8: 82 10 61 a8 or %g1, 0x1a8, %g1
the_watchdog->id = id;
20075fc: c0 27 60 20 clr [ %i5 + 0x20 ]
Objects_Id id,
void *user_data
)
{
the_watchdog->state = WATCHDOG_INACTIVE;
the_watchdog->routine = routine;
2007600: c2 27 60 1c st %g1, [ %i5 + 0x1c ]
the_watchdog->id = id;
the_watchdog->user_data = user_data;
2007604: c0 27 60 24 clr [ %i5 + 0x24 ]
useconds_t ualarm(
useconds_t useconds,
useconds_t interval
)
{
useconds_t remaining = 0;
2007608: 10 80 00 1b b 2007674 <ualarm+0xa0>
200760c: 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 );
2007610: 40 00 0f f1 call 200b5d4 <_Watchdog_Remove>
2007614: 90 10 00 1d mov %i5, %o0
if ( (state == WATCHDOG_ACTIVE) || (state == WATCHDOG_REMOVE_IT) ) {
2007618: 90 02 3f fe add %o0, -2, %o0
200761c: 80 a2 20 01 cmp %o0, 1
2007620: 18 80 00 15 bgu 2007674 <ualarm+0xa0> <== NEVER TAKEN
2007624: 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);
2007628: c2 07 60 0c ld [ %i5 + 0xc ], %g1
200762c: d0 07 60 14 ld [ %i5 + 0x14 ], %o0
/* remaining is now in ticks */
_Timespec_From_ticks( ticks, &tp );
2007630: 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);
2007634: 90 02 00 01 add %o0, %g1, %o0
2007638: c2 07 60 18 ld [ %i5 + 0x18 ], %g1
/* remaining is now in ticks */
_Timespec_From_ticks( ticks, &tp );
200763c: 40 00 0e 83 call 200b048 <_Timespec_From_ticks>
2007640: 90 22 00 01 sub %o0, %g1, %o0
remaining = tp.tv_sec * TOD_MICROSECONDS_PER_SECOND;
2007644: c2 07 bf f8 ld [ %fp + -8 ], %g1
remaining += tp.tv_nsec / 1000;
2007648: 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;
200764c: 85 28 60 03 sll %g1, 3, %g2
2007650: 87 28 60 08 sll %g1, 8, %g3
2007654: 84 20 c0 02 sub %g3, %g2, %g2
remaining += tp.tv_nsec / 1000;
2007658: 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;
200765c: b1 28 a0 06 sll %g2, 6, %i0
2007660: b0 26 00 02 sub %i0, %g2, %i0
remaining += tp.tv_nsec / 1000;
2007664: 40 00 4c 5b call 201a7d0 <.div>
2007668: 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;
200766c: b1 2e 20 06 sll %i0, 6, %i0
remaining += tp.tv_nsec / 1000;
2007670: 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 ) {
2007674: 80 a7 20 00 cmp %i4, 0
2007678: 02 80 00 19 be 20076dc <ualarm+0x108>
200767c: 3b 00 03 d0 sethi %hi(0xf4000), %i5
Watchdog_Interval ticks;
tp.tv_sec = useconds / TOD_MICROSECONDS_PER_SECOND;
2007680: 90 10 00 1c mov %i4, %o0
2007684: 40 00 4c 51 call 201a7c8 <.udiv>
2007688: 92 17 62 40 or %i5, 0x240, %o1
tp.tv_nsec = (useconds % TOD_MICROSECONDS_PER_SECOND) * 1000;
200768c: 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;
2007690: d0 27 bf f8 st %o0, [ %fp + -8 ]
tp.tv_nsec = (useconds % TOD_MICROSECONDS_PER_SECOND) * 1000;
2007694: 40 00 4c f9 call 201aa78 <.urem>
2007698: 90 10 00 1c mov %i4, %o0
200769c: 85 2a 20 07 sll %o0, 7, %g2
20076a0: 83 2a 20 02 sll %o0, 2, %g1
20076a4: 82 20 80 01 sub %g2, %g1, %g1
20076a8: 90 00 40 08 add %g1, %o0, %o0
20076ac: 91 2a 20 03 sll %o0, 3, %o0
20076b0: d0 27 bf fc st %o0, [ %fp + -4 ]
ticks = _Timespec_To_ticks( &tp );
20076b4: 40 00 0e 7a call 200b09c <_Timespec_To_ticks>
20076b8: 90 07 bf f8 add %fp, -8, %o0
if ( ticks == 0 )
ticks = 1;
_Watchdog_Insert_ticks( the_timer, _Timespec_To_ticks( &tp ) );
20076bc: 40 00 0e 78 call 200b09c <_Timespec_To_ticks>
20076c0: 90 07 bf f8 add %fp, -8, %o0
Watchdog_Control *the_watchdog,
Watchdog_Interval units
)
{
the_watchdog->initial = units;
20076c4: 13 00 80 7f sethi %hi(0x201fc00), %o1
20076c8: 92 12 63 c8 or %o1, 0x3c8, %o1 ! 201ffc8 <_POSIX_signals_Ualarm_timer>
20076cc: d0 22 60 0c st %o0, [ %o1 + 0xc ]
_Watchdog_Insert( &_Watchdog_Ticks_chain, the_watchdog );
20076d0: 11 00 80 7d sethi %hi(0x201f400), %o0
20076d4: 40 00 0f 68 call 200b474 <_Watchdog_Insert>
20076d8: 90 12 23 68 or %o0, 0x368, %o0 ! 201f768 <_Watchdog_Ticks_chain>
}
return remaining;
}
20076dc: 81 c7 e0 08 ret
20076e0: 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 d8 ld [ %g1 + 0x3d8 ], %g1 ! 201d3d8 <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 d4 call 2008118 <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 f9 call 200fdd0 <__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 f5 call 200fdd0 <__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 1d call 20076a0 <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 63 call 20083cc <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
0201a2a4 <write>:
ssize_t write(
int fd,
const void *buffer,
size_t count
)
{
201a2a4: 9d e3 bf a0 save %sp, -96, %sp
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
201a2a8: 03 00 80 73 sethi %hi(0x201cc00), %g1
201a2ac: c2 00 62 30 ld [ %g1 + 0x230 ], %g1 ! 201ce30 <rtems_libio_number_iops>
201a2b0: 80 a6 00 01 cmp %i0, %g1
201a2b4: 1a 80 00 16 bcc 201a30c <write+0x68>
201a2b8: 83 2e 20 03 sll %i0, 3, %g1
iop = rtems_libio_iop( fd );
201a2bc: b1 2e 20 06 sll %i0, 6, %i0
201a2c0: b0 26 00 01 sub %i0, %g1, %i0
201a2c4: 03 00 80 76 sethi %hi(0x201d800), %g1
201a2c8: d0 00 61 50 ld [ %g1 + 0x150 ], %o0 ! 201d950 <rtems_libio_iops>
201a2cc: 90 02 00 18 add %o0, %i0, %o0
rtems_libio_check_is_open( iop );
201a2d0: c2 02 20 10 ld [ %o0 + 0x10 ], %g1
201a2d4: 80 88 61 00 btst 0x100, %g1
201a2d8: 02 80 00 0d be 201a30c <write+0x68>
201a2dc: 80 a6 60 00 cmp %i1, 0
rtems_libio_check_buffer( buffer );
201a2e0: 12 80 00 06 bne 201a2f8 <write+0x54> <== ALWAYS TAKEN
201a2e4: 80 a6 a0 00 cmp %i2, 0
201a2e8: 7f ff d5 cc call 200fa18 <__errno> <== NOT EXECUTED
201a2ec: 01 00 00 00 nop <== NOT EXECUTED
201a2f0: 10 80 00 0a b 201a318 <write+0x74> <== NOT EXECUTED
201a2f4: 82 10 20 16 mov 0x16, %g1 ! 16 <PROM_START+0x16> <== NOT EXECUTED
rtems_libio_check_count( count );
201a2f8: 02 80 00 10 be 201a338 <write+0x94>
201a2fc: b0 10 20 00 clr %i0
rtems_libio_check_permissions_with_error( iop, LIBIO_FLAGS_WRITE, EBADF );
201a300: 80 88 60 04 btst 4, %g1
201a304: 32 80 00 08 bne,a 201a324 <write+0x80>
201a308: c2 02 20 24 ld [ %o0 + 0x24 ], %g1
201a30c: 7f ff d5 c3 call 200fa18 <__errno>
201a310: 01 00 00 00 nop
201a314: 82 10 20 09 mov 9, %g1 ! 9 <PROM_START+0x9>
201a318: c2 22 00 00 st %g1, [ %o0 ]
201a31c: 81 c7 e0 08 ret
201a320: 91 e8 3f ff restore %g0, -1, %o0
/*
* Now process the write() request.
*/
return (*iop->pathinfo.handlers->write_h)( iop, buffer, count );
201a324: 92 10 00 19 mov %i1, %o1
201a328: c2 00 60 0c ld [ %g1 + 0xc ], %g1
201a32c: 9f c0 40 00 call %g1
201a330: 94 10 00 1a mov %i2, %o2
201a334: b0 10 00 08 mov %o0, %i0
}
201a338: 81 c7 e0 08 ret
201a33c: 81 e8 00 00 restore
0200809c <writev>:
ssize_t writev(
int fd,
const struct iovec *iov,
int iovcnt
)
{
200809c: 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 );
20080a0: 03 00 80 76 sethi %hi(0x201d800), %g1
20080a4: c2 00 61 40 ld [ %g1 + 0x140 ], %g1 ! 201d940 <rtems_libio_number_iops>
20080a8: 80 a6 00 01 cmp %i0, %g1
20080ac: 2a 80 00 03 bcs,a 20080b8 <writev+0x1c>
20080b0: 83 2e 20 03 sll %i0, 3, %g1
20080b4: 30 80 00 0c b,a 20080e4 <writev+0x48>
iop = rtems_libio_iop( fd );
20080b8: b1 2e 20 06 sll %i0, 6, %i0
20080bc: b0 26 00 01 sub %i0, %g1, %i0
20080c0: 03 00 80 79 sethi %hi(0x201e400), %g1
20080c4: f8 00 60 60 ld [ %g1 + 0x60 ], %i4 ! 201e460 <rtems_libio_iops>
20080c8: b8 07 00 18 add %i4, %i0, %i4
rtems_libio_check_is_open( iop );
20080cc: c2 07 20 10 ld [ %i4 + 0x10 ], %g1
20080d0: 80 88 61 00 btst 0x100, %g1
20080d4: 02 80 00 04 be 20080e4 <writev+0x48>
20080d8: 80 88 60 04 btst 4, %g1
rtems_libio_check_permissions_with_error( iop, LIBIO_FLAGS_WRITE, EBADF );
20080dc: 12 80 00 06 bne 20080f4 <writev+0x58> <== ALWAYS TAKEN
20080e0: 80 a6 60 00 cmp %i1, 0
20080e4: 40 00 21 9c call 2010754 <__errno>
20080e8: 01 00 00 00 nop
20080ec: 10 80 00 20 b 200816c <writev+0xd0>
20080f0: 82 10 20 09 mov 9, %g1 ! 9 <PROM_START+0x9>
/*
* Argument validation on IO vector
*/
if ( !iov )
20080f4: 02 80 00 1b be 2008160 <writev+0xc4>
20080f8: 80 a6 a0 00 cmp %i2, 0
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iovcnt <= 0 )
20080fc: 04 80 00 19 ble 2008160 <writev+0xc4>
2008100: 80 a6 a4 00 cmp %i2, 0x400
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iovcnt > IOV_MAX )
2008104: 24 80 00 03 ble,a 2008110 <writev+0x74> <== ALWAYS TAKEN
2008108: b5 2e a0 03 sll %i2, 3, %i2
200810c: 30 80 00 15 b,a 2008160 <writev+0xc4> <== NOT EXECUTED
#include <sys/uio.h>
#include <rtems/libio_.h>
#include <rtems/seterr.h>
ssize_t writev(
2008110: 82 10 20 00 clr %g1
2008114: 86 10 20 01 mov 1, %g3
2008118: 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 )
200811c: c8 06 40 01 ld [ %i1 + %g1 ], %g4
2008120: 80 a1 20 00 cmp %g4, 0
2008124: 02 80 00 0f be 2008160 <writev+0xc4>
2008128: 88 06 40 01 add %i1, %g1, %g4
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iov[v].iov_len )
200812c: c8 01 20 04 ld [ %g4 + 4 ], %g4
all_zeros = false;
2008130: 80 a0 00 04 cmp %g0, %g4
2008134: ba 40 3f ff addx %g0, -1, %i5
/* check for wrap */
old = total;
total += iov[v].iov_len;
if ( total < old || total > SSIZE_MAX )
2008138: 88 81 00 02 addcc %g4, %g2, %g4
200813c: 0c 80 00 09 bneg 2008160 <writev+0xc4>
2008140: 86 08 c0 1d and %g3, %i5, %g3
2008144: 80 a1 00 02 cmp %g4, %g2
2008148: 06 80 00 03 bl 2008154 <writev+0xb8>
200814c: ba 10 20 01 mov 1, %i5
2008150: ba 10 20 00 clr %i5
2008154: 80 8f 60 ff btst 0xff, %i5
2008158: 02 80 00 07 be 2008174 <writev+0xd8>
200815c: 82 00 60 08 add %g1, 8, %g1
rtems_set_errno_and_return_minus_one( EINVAL );
2008160: 40 00 21 7d call 2010754 <__errno>
2008164: 01 00 00 00 nop
2008168: 82 10 20 16 mov 0x16, %g1 ! 16 <PROM_START+0x16>
200816c: 10 80 00 21 b 20081f0 <writev+0x154>
2008170: 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++ ) {
2008174: 80 a0 40 1a cmp %g1, %i2
2008178: 12 bf ff e9 bne 200811c <writev+0x80>
200817c: 84 10 00 04 mov %g4, %g2
}
/*
* A writev with all zeros is supposed to have no effect per OpenGroup.
*/
if ( all_zeros == true ) {
2008180: 80 88 e0 ff btst 0xff, %g3
2008184: 12 80 00 19 bne 20081e8 <writev+0x14c>
2008188: b0 10 20 00 clr %i0
200818c: ba 10 20 00 clr %i5
#include <sys/uio.h>
#include <rtems/libio_.h>
#include <rtems/seterr.h>
ssize_t writev(
2008190: 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 )
2008194: d4 06 e0 04 ld [ %i3 + 4 ], %o2
2008198: 80 a2 a0 00 cmp %o2, 0
200819c: 22 80 00 10 be,a 20081dc <writev+0x140> <== NEVER TAKEN
20081a0: ba 07 60 08 add %i5, 8, %i5 <== NOT EXECUTED
continue;
bytes = (*iop->pathinfo.handlers->write_h)(
20081a4: c2 07 20 24 ld [ %i4 + 0x24 ], %g1
20081a8: d2 06 40 1d ld [ %i1 + %i5 ], %o1
20081ac: c2 00 60 0c ld [ %g1 + 0xc ], %g1
20081b0: 9f c0 40 00 call %g1
20081b4: 90 10 00 1c mov %i4, %o0
iop,
iov[v].iov_base,
iov[v].iov_len
);
if ( bytes < 0 )
20081b8: 80 a2 20 00 cmp %o0, 0
20081bc: 26 80 00 0b bl,a 20081e8 <writev+0x14c> <== NEVER TAKEN
20081c0: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
return -1;
if ( bytes > 0 ) {
20081c4: 32 80 00 02 bne,a 20081cc <writev+0x130> <== ALWAYS TAKEN
20081c8: b0 06 00 08 add %i0, %o0, %i0
total += bytes;
}
if (bytes != iov[ v ].iov_len)
20081cc: c2 06 e0 04 ld [ %i3 + 4 ], %g1
20081d0: 80 a2 00 01 cmp %o0, %g1
20081d4: 12 80 00 05 bne 20081e8 <writev+0x14c> <== NEVER TAKEN
20081d8: ba 07 60 08 add %i5, 8, %i5
}
/*
* Now process the writev().
*/
for ( total=0, v=0 ; v < iovcnt ; v++ ) {
20081dc: 80 a7 40 1a cmp %i5, %i2
20081e0: 12 bf ff ed bne 2008194 <writev+0xf8>
20081e4: b6 06 40 1d add %i1, %i5, %i3
20081e8: 81 c7 e0 08 ret
20081ec: 81 e8 00 00 restore
iov[v].iov_base,
iov[v].iov_len
);
if ( bytes < 0 )
return -1;
20081f0: b0 10 3f ff mov -1, %i0
if (bytes != iov[ v ].iov_len)
break;
}
return total;
}
20081f4: 81 c7 e0 08 ret
20081f8: 81 e8 00 00 restore